From 07019577d5af8d83c7a29ea83fda51847fb045d5 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Paul-Etienne=20Fran=C3=A7ois?= Date: Wed, 8 May 2024 14:02:11 +0000 Subject: [PATCH 001/168] Place the user actions in a dropdown window with labels --- app/views/user/show/header.scala | 129 +++++++++++++++---------------- ui/bits/css/user/_profile.scss | 5 ++ ui/bits/css/user/_show.scss | 52 +++++++++++++ 3 files changed, 121 insertions(+), 65 deletions(-) diff --git a/app/views/user/show/header.scala b/app/views/user/show/header.scala index 984b08a20861a..a798c8ff53e85 100644 --- a/app/views/user/show/header.scala +++ b/app/views/user/show/header.scala @@ -39,7 +39,70 @@ object header: )(patronIconChar) ) ), - u.enabled.no.option(span(cls := "closed")("CLOSED")) + u.enabled.no.option(span(cls := "closed")("CLOSED")), + div(cls := "user-actions dropdown")( + a( + cls := "text", + dataIcon := Icon.List + ), + div(cls := "dropdown-window")( + (ctx + .is(u)) + .option( + frag( + a( + cls := "text", + href := routes.Account.profile, + dataIcon := Icon.Gear + )(trans.site.editProfile.txt()), + a( + cls := "text", + href := routes.Relation.blocks(), + dataIcon := Icon.NotAllowed + )(trans.site.listBlockedPlayers.txt()) + ) + ), + isGranted(_.UserModView).option( + a( + cls := "text mod-zone-toggle", + href := routes.User.mod(u.username), + dataIcon := Icon.Agent + )("Mod zone (Hotkey: m)") + ), + a( + cls := "text", + href := routes.User.tv(u.username), + dataIcon := Icon.AnalogTv + )(trans.site.watchGames.txt()), + ctx + .isnt(u) + .option( + views.relation.actions( + u.light, + relation = social.relation, + followable = social.followable, + blocked = social.blocked + ) + ), + a( + cls := "text", + href := s"${routes.UserAnalysis.index}#explorer/${u.username}", + dataIcon := Icon.Book + )(trans.site.openingExplorer.txt()), + a( + cls := "text", + href := routes.User.download(u.username), + dataIcon := Icon.Download + )(trans.site.exportGames.txt()), + (ctx.isAuth && ctx.kid.no && ctx.isnt(u)).option( + a( + cls := "text", + href := s"${routes.Report.form}?username=${u.username}", + dataIcon := Icon.CautionTriangle + )(trans.site.reportXToModerators.txt(u.username)) + ) + ) + ) ), div(cls := "user-show__social")( div(cls := "number-menu")( @@ -89,70 +152,6 @@ object header: ), (ctx.isAuth && ctx.isnt(u)) .option(a(cls := "nm-item note-zone-toggle")(splitNumber(s"${social.notes.size} Notes"))) - ), - div(cls := "user-actions btn-rack")( - (ctx - .is(u)) - .option( - frag( - a( - cls := "btn-rack__btn", - href := routes.Account.profile, - titleOrText(trans.site.editProfile.txt()), - dataIcon := Icon.Gear - ), - a( - cls := "btn-rack__btn", - href := routes.Relation.blocks(), - titleOrText(trans.site.listBlockedPlayers.txt()), - dataIcon := Icon.NotAllowed - ) - ) - ), - isGranted(_.UserModView).option( - a( - cls := "btn-rack__btn mod-zone-toggle", - href := routes.User.mod(u.username), - titleOrText("Mod zone (Hotkey: m)"), - dataIcon := Icon.Agent - ) - ), - a( - cls := "btn-rack__btn", - href := routes.User.tv(u.username), - titleOrText(trans.site.watchGames.txt()), - dataIcon := Icon.AnalogTv - ), - ctx - .isnt(u) - .option( - views.relation.actions( - u.light, - relation = social.relation, - followable = social.followable, - blocked = social.blocked - ) - ), - a( - cls := "btn-rack__btn", - href := s"${routes.UserAnalysis.index}#explorer/${u.username}", - titleOrText(trans.site.openingExplorer.txt()), - dataIcon := Icon.Book - ), - a( - cls := "btn-rack__btn", - href := routes.User.download(u.username), - titleOrText(trans.site.exportGames.txt()), - dataIcon := Icon.Download - ), - (ctx.isAuth && ctx.kid.no && ctx.isnt(u)).option( - a( - titleOrText(trans.site.reportXToModerators.txt(u.username)), - cls := "btn-rack__btn", - href := s"${routes.Report.form}?username=${u.username}", - dataIcon := Icon.CautionTriangle - ) - ) ) ), ctx.isnt(u).option(noteUi.zone(u, social.notes)), diff --git a/ui/bits/css/user/_profile.scss b/ui/bits/css/user/_profile.scss index 8709a80865b21..f5367e1a75206 100644 --- a/ui/bits/css/user/_profile.scss +++ b/ui/bits/css/user/_profile.scss @@ -46,6 +46,11 @@ unicode-bidi: plaintext; text-align: start; + + time { + font-size: 100%; + opacity: 1; + } } .insight { diff --git a/ui/bits/css/user/_show.scss b/ui/bits/css/user/_show.scss index 3bd273be9965c..3b15bba810ec6 100644 --- a/ui/bits/css/user/_show.scss +++ b/ui/bits/css/user/_show.scss @@ -45,6 +45,58 @@ } } + &__header { + .dropdown { + position: relative; + font-size: x-large; + > a { + color: $c-font-page; + float: right; + padding-left: 0.5em; + } + + .dropdown-window { + visibility: hidden; + background: $c-bg-header-dropdown; + border-radius: 3px 0 3px 3px; + box-shadow: 2px 5px 6px rgba(0, 0, 0, 0.3); + position: absolute; + top: 1.45em; + right: 0; + a { + width: 16em; + font-size: small; + display: block; + padding: 0.6rem 1rem; + color: $c-header-dropdown; + &:first-child { + border-radius: 3px 0 0 0; + } + &:last-child { + border-radius: 0 0 3px 3px; + } + &:hover { + background: $c-primary; + &, + &::after { + color: $c-over; + } + } + } + } + } + + .dropdown:hover { + > a { + background: $c-bg-header-dropdown; + box-shadow: 2px 5px 6px rgba(0, 0, 0, 0.3); + } + .dropdown-window { + visibility: visible; + } + } + } + .claim-title { @extend %box-padding; From 665576b8c937a73c6283173486ef819152f483fa Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Paul-Etienne=20Fran=C3=A7ois?= Date: Wed, 15 May 2024 19:48:37 +0000 Subject: [PATCH 002/168] fix: Display relation actions correctly --- app/views/user/show/header.scala | 100 +++++++++--------- modules/relation/src/main/ui/RelationUi.scala | 43 +++----- ui/bits/css/user/_show.scss | 8 -- 3 files changed, 67 insertions(+), 84 deletions(-) diff --git a/app/views/user/show/header.scala b/app/views/user/show/header.scala index a798c8ff53e85..7b3883b78eb40 100644 --- a/app/views/user/show/header.scala +++ b/app/views/user/show/header.scala @@ -40,6 +40,56 @@ object header: ) ), u.enabled.no.option(span(cls := "closed")("CLOSED")), + ), + div(cls := "user-show__social")( + div(cls := "number-menu")( + u.noBot.option( + a( + href := routes.UserTournament.path(u.username, "recent"), + cls := "nm-item", + dataToints := u.toints + )( + splitNumber(trans.site.nbTournamentPoints.pluralSame(u.toints)) + ) + ), + (info.nbSimuls > 0).option( + a( + href := routes.Simul.byUser(u.username), + cls := "nm-item" + )( + splitNumber(trans.site.nbSimuls.pluralSame(info.nbSimuls)) + ) + ), + (info.nbRelays > 0).option( + a( + href := routes.RelayTour.by(u.username), + cls := "nm-item" + )( + splitNumber(trans.broadcast.nbBroadcasts.pluralSame(info.nbRelays)) + ) + ), + a(href := routes.Study.byOwnerDefault(u.username), cls := "nm-item")( + splitNumber(trans.site.`nbStudies`.pluralSame(info.nbStudies)) + ), + ctx.kid.no.option( + a( + cls := "nm-item", + href := routes.ForumPost.search("user:" + u.username, 1).url + )( + splitNumber(trans.site.nbForumPosts.pluralSame(info.nbForumPosts)) + ) + ), + (ctx.kid.no && (info.ublog.exists(_.nbPosts > 0) || ctx.is(u))).option( + a( + cls := "nm-item", + href := routes.Ublog.index(u.username) + )( + splitNumber(s"${info.ublog.so(_.nbPosts)} blog posts") + ) + ), + (ctx.isAuth && ctx.isnt(u)) + .option(a(cls := "nm-item note-zone-toggle")(splitNumber(s"${social.notes.size} Notes"))) + ), div(cls := "user-actions dropdown")( a( cls := "text", @@ -104,56 +154,6 @@ object header: ) ) ), - div(cls := "user-show__social")( - div(cls := "number-menu")( - u.noBot.option( - a( - href := routes.UserTournament.path(u.username, "recent"), - cls := "nm-item", - dataToints := u.toints - )( - splitNumber(trans.site.nbTournamentPoints.pluralSame(u.toints)) - ) - ), - (info.nbSimuls > 0).option( - a( - href := routes.Simul.byUser(u.username), - cls := "nm-item" - )( - splitNumber(trans.site.nbSimuls.pluralSame(info.nbSimuls)) - ) - ), - (info.nbRelays > 0).option( - a( - href := routes.RelayTour.by(u.username), - cls := "nm-item" - )( - splitNumber(trans.broadcast.nbBroadcasts.pluralSame(info.nbRelays)) - ) - ), - a(href := routes.Study.byOwnerDefault(u.username), cls := "nm-item")( - splitNumber(trans.site.`nbStudies`.pluralSame(info.nbStudies)) - ), - ctx.kid.no.option( - a( - cls := "nm-item", - href := routes.ForumPost.search("user:" + u.username, 1).url - )( - splitNumber(trans.site.nbForumPosts.pluralSame(info.nbForumPosts)) - ) - ), - (ctx.kid.no && (info.ublog.exists(_.nbPosts > 0) || ctx.is(u))).option( - a( - cls := "nm-item", - href := routes.Ublog.index(u.username) - )( - splitNumber(s"${info.ublog.so(_.nbPosts)} blog posts") - ) - ), - (ctx.isAuth && ctx.isnt(u)) - .option(a(cls := "nm-item note-zone-toggle")(splitNumber(s"${social.notes.size} Notes"))) - ) - ), ctx.isnt(u).option(noteUi.zone(u, social.notes)), isGranted(_.UserModView).option(div(cls := "mod-zone mod-zone-full none")), standardFlash, diff --git a/modules/relation/src/main/ui/RelationUi.scala b/modules/relation/src/main/ui/RelationUi.scala index b2a46d8f04d07..315c2cb951a67 100644 --- a/modules/relation/src/main/ui/RelationUi.scala +++ b/modules/relation/src/main/ui/RelationUi.scala @@ -51,14 +51,13 @@ final class RelationUi(helpers: Helpers): blocked: Boolean, signup: Boolean = false )(using ctx: Context) = - div(cls := "relation-actions btn-rack")( + div(cls := "relation-actions")( (ctx.isnt(user) && !blocked).option( a( - titleOrText(trans.challenge.challengeToPlay.txt()), + cls := "text", href := s"${routes.Lobby.home}?user=${user.name}#friend", - cls := "btn-rack__btn", dataIcon := Icon.Swords - ) + )(trans.challenge.challengeToPlay.txt()) ), ctx.userId .map: myId => @@ -67,54 +66,46 @@ final class RelationUi(helpers: Helpers): frag( (!blocked && !user.isBot).option( a( - titleOrText(trans.site.composeMessage.txt()), + cls := "text", href := routes.Msg.convo(user.name), - cls := "btn-rack__btn", dataIcon := Icon.BubbleSpeech - ) + )(trans.site.composeMessage.txt()) ), (!blocked && !user.isPatron).option( a( - titleOrText(trans.patron.giftPatronWingsShort.txt()), + cls := "text", href := s"${routes.Plan.list}?dest=gift&giftUsername=${user.name}", - cls := "btn-rack__btn", dataIcon := Icon.Wings - ) + )(trans.patron.giftPatronWingsShort.txt()) ), relation match case None => frag( (followable && !blocked).option( a( - cls := "btn-rack__btn relation-button", + cls := "text relation-button", href := routes.Relation.follow(user.name), - titleOrText(trans.site.follow.txt()), dataIcon := Icon.ThumbsUp - ) + )(trans.site.follow.txt()) ), a( - cls := "btn-rack__btn relation-button", + cls := "text relation-button", href := routes.Relation.block(user.name), - titleOrText(trans.site.block.txt()), dataIcon := Icon.NotAllowed - ) + )(trans.site.block.txt()) ) case Some(Relation.Follow) => a( - dataIcon := Icon.ThumbsUp, - cls := "btn-rack__btn relation-button text hover-text", + cls := "text relation-button", href := routes.Relation.unfollow(user.name), - titleOrText(trans.site.following.txt()), - dataHoverText := trans.site.unfollow.txt() - ) + dataIcon := Icon.ThumbsUp + )(trans.site.unfollow.txt()) case Some(Relation.Block) => a( - dataIcon := Icon.NotAllowed, - cls := "btn-rack__btn relation-button text hover-text", + cls := "text relation-button", href := routes.Relation.unblock(user.name), - titleOrText(trans.site.blocked.txt()), - dataHoverText := trans.site.unblock.txt() - ) + dataIcon := Icon.NotAllowed + )(trans.site.unblock.txt()) ) ) .getOrElse: diff --git a/ui/bits/css/user/_show.scss b/ui/bits/css/user/_show.scss index 3b15bba810ec6..fa3fc0f71425e 100644 --- a/ui/bits/css/user/_show.scss +++ b/ui/bits/css/user/_show.scss @@ -38,14 +38,6 @@ } } - .relation-actions { - @extend %flex-center-nowrap; - - border-inline-end: $border; - } - } - - &__header { .dropdown { position: relative; font-size: x-large; From d5e7788d046df91f3ee1fe3bea26f5d1aa20316f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Paul-Etienne=20Fran=C3=A7ois?= Date: Thu, 16 May 2024 00:42:53 +0200 Subject: [PATCH 003/168] Format code --- app/views/user/show/header.scala | 2 +- modules/relation/src/main/ui/RelationUi.scala | 8 ++++---- 2 files changed, 5 insertions(+), 5 deletions(-) diff --git a/app/views/user/show/header.scala b/app/views/user/show/header.scala index 7b3883b78eb40..4cc92a766941d 100644 --- a/app/views/user/show/header.scala +++ b/app/views/user/show/header.scala @@ -39,7 +39,7 @@ object header: )(patronIconChar) ) ), - u.enabled.no.option(span(cls := "closed")("CLOSED")), + u.enabled.no.option(span(cls := "closed")("CLOSED")) ), div(cls := "user-show__social")( div(cls := "number-menu")( diff --git a/modules/relation/src/main/ui/RelationUi.scala b/modules/relation/src/main/ui/RelationUi.scala index 315c2cb951a67..5d6bdea39c2b0 100644 --- a/modules/relation/src/main/ui/RelationUi.scala +++ b/modules/relation/src/main/ui/RelationUi.scala @@ -83,14 +83,14 @@ final class RelationUi(helpers: Helpers): frag( (followable && !blocked).option( a( - cls := "text relation-button", - href := routes.Relation.follow(user.name), + cls := "text relation-button", + href := routes.Relation.follow(user.name), dataIcon := Icon.ThumbsUp )(trans.site.follow.txt()) ), a( - cls := "text relation-button", - href := routes.Relation.block(user.name), + cls := "text relation-button", + href := routes.Relation.block(user.name), dataIcon := Icon.NotAllowed )(trans.site.block.txt()) ) From 2313d1c6321bc578b565acc475e9f0c5701613df Mon Sep 17 00:00:00 2001 From: Thibault Duplessis Date: Fri, 17 May 2024 09:30:07 +0200 Subject: [PATCH 004/168] update UserName.historicalRegex - closes #15314 for https://lichess.org/@/__kamensky --- modules/core/src/main/userId.scala | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/modules/core/src/main/userId.scala b/modules/core/src/main/userId.scala index 9c0f8053af1d9..943d4c4f3c8a6 100644 --- a/modules/core/src/main/userId.scala +++ b/modules/core/src/main/userId.scala @@ -57,7 +57,7 @@ object userId: extension (e: UserName) def str = UserStr(e) given UserIdOf[UserName] = n => UserId(n.value.toLowerCase) // what existing usernames are like - val historicalRegex = "(?i)[a-z0-9][a-z0-9_-]{0,28}[a-z0-9]".r + val historicalRegex = "(?i)[a-z0-9_][a-z0-9_-]{0,28}[a-z0-9]".r val anonymous: UserName = "Anonymous" val lichess: UserName = "lichess" val anonMod: String = "A Lichess Moderator" From ad68b2388a137ac5a3b4c01d980e7210d2427ffa Mon Sep 17 00:00:00 2001 From: Ben Olden-Cooligan Date: Tue, 11 Jun 2024 17:06:17 -0700 Subject: [PATCH 005/168] Tweak the branch styling for nested variations - Remove the "head" rendered as part of the element as it doesn't accurately represent where we're branching from - Remove the "tail" that extends past the bottom variation as it's visually unnecessary. This means the height is no longer the same as the parent height, so we need a new element with variable height. Tested on Firefox & Chrome with inline & column mode in various zoom levels. --- ui/analyse/src/treeView/columnView.ts | 8 +++--- ui/analyse/src/treeView/inlineView.ts | 8 +++--- ui/tree/css/_tree.scss | 40 ++++++++++++++++----------- 3 files changed, 32 insertions(+), 24 deletions(-) diff --git a/ui/analyse/src/treeView/columnView.ts b/ui/analyse/src/treeView/columnView.ts index f08103f5e4a08..ed340a416f036 100644 --- a/ui/analyse/src/treeView/columnView.ts +++ b/ui/analyse/src/treeView/columnView.ts @@ -100,16 +100,16 @@ function renderLines(ctx: Ctx, nodes: Tree.Node[], opts: Opts): VNode { nodes.map(n => { return ( retroLine(ctx, n) || - h( - 'line', - renderMoveAndChildrenOf(ctx, n, { + h('line', [ + h('branch'), + ...renderMoveAndChildrenOf(ctx, n, { parentPath: opts.parentPath, isMainline: false, withIndex: true, noConceal: opts.noConceal, truncate: n.comp && !treePath.contains(ctx.ctrl.path, opts.parentPath + n.id) ? 3 : undefined, }), - ) + ]) ); }), ); diff --git a/ui/analyse/src/treeView/inlineView.ts b/ui/analyse/src/treeView/inlineView.ts index 8c2181700b585..6f8903793db75 100644 --- a/ui/analyse/src/treeView/inlineView.ts +++ b/ui/analyse/src/treeView/inlineView.ts @@ -68,15 +68,15 @@ function renderLines(ctx: Ctx, nodes: Tree.Node[], opts: Opts): VNode { nodes.map(n => { return ( retroLine(ctx, n) || - h( - 'line', - renderMoveAndChildrenOf(ctx, n, { + h('line', [ + h('branch'), + ...renderMoveAndChildrenOf(ctx, n, { parentPath: opts.parentPath, isMainline: false, withIndex: true, truncate: n.comp && !treePath.contains(ctx.ctrl.path, opts.parentPath + n.id) ? 3 : undefined, }), - ) + ]) ); }), ); diff --git a/ui/tree/css/_tree.scss b/ui/tree/css/_tree.scss index 9c5bf91bd9998..d4e3dfa5ea539 100644 --- a/ui/tree/css/_tree.scss +++ b/ui/tree/css/_tree.scss @@ -301,7 +301,7 @@ margin-top: 2px; margin-inline-start: 6px; margin-bottom: 0.8em; - border-inline-start: 2px solid $c-border; + padding-inline-start: 2px; } > interrupt > lines { @@ -319,37 +319,45 @@ line { display: block; padding-inline-start: 7px; + position: relative; } &-column line { margin: 2px 0; } - lines lines move { - font-size: 13px; + line > branch { + border-inline-start: 2px solid $c-border; + margin-inline-start: -9px; + position: absolute; + width: 8px; + height: 100%; } - lines lines { - margin-inline-start: 1px; + line:last-child > branch { + height: calc(0.8em + 2px); } - lines lines::before { + line > branch::before { + margin-top: 0.8em; content: ' '; border-top: 2px solid $c-border; position: absolute; - margin-inline-start: -11px; - width: 9px; + width: 7px; height: 6px; } - lines line::before { - margin-top: 0.65em; - margin-inline-start: -8px; - content: ' '; - border-top: 2px solid $c-border; - position: absolute; - width: 8px; - height: 6px; + &-column line > branch { + margin-top: -2px; + height: calc(100% + 2px); + } + + lines lines move { + font-size: 13px; + } + + lines lines { + margin-inline-start: 1px; } lines lines:last-child { From 6f4171f5702604685793c28d4efb0df32dbe5428 Mon Sep 17 00:00:00 2001 From: Ben Olden-Cooligan Date: Wed, 12 Jun 2024 00:33:31 -0700 Subject: [PATCH 006/168] Collapse/expand variations --- modules/analyse/src/main/ui/AnalyseI18n.scala | 2 ++ modules/coreI18n/src/main/key.scala | 2 ++ translation/source/site.xml | 2 ++ ui/@types/lichess/tree.d.ts | 1 + ui/analyse/src/ctrl.ts | 5 ++++ ui/analyse/src/treeView/columnView.ts | 24 ++++++++++++------- ui/analyse/src/treeView/contextMenu.ts | 4 ++++ ui/analyse/src/treeView/inlineView.ts | 23 ++++++++++++------ ui/analyse/src/view/util.ts | 4 ++-- ui/tree/css/_tree.scss | 15 +++++++++++- ui/tree/src/tree.ts | 6 +++++ 11 files changed, 70 insertions(+), 18 deletions(-) diff --git a/modules/analyse/src/main/ui/AnalyseI18n.scala b/modules/analyse/src/main/ui/AnalyseI18n.scala index 4b788558741d6..ce5ab5661c83c 100644 --- a/modules/analyse/src/main/ui/AnalyseI18n.scala +++ b/modules/analyse/src/main/ui/AnalyseI18n.scala @@ -91,6 +91,8 @@ final class AnalyseI18n(helpers: Helpers): site.promoteVariation, site.makeMainLine, site.deleteFromHere, + site.collapseVariations, + site.expandVariations, site.forceVariation, site.copyVariationPgn, // practice (also uses checkmate, draw) diff --git a/modules/coreI18n/src/main/key.scala b/modules/coreI18n/src/main/key.scala index 9ae5db0295c50..0bf92e2084696 100644 --- a/modules/coreI18n/src/main/key.scala +++ b/modules/coreI18n/src/main/key.scala @@ -86,6 +86,8 @@ object I18nKey: val `promoteVariation`: I18nKey = "promoteVariation" val `makeMainLine`: I18nKey = "makeMainLine" val `deleteFromHere`: I18nKey = "deleteFromHere" + val `collapseVariations`: I18nKey = "collapseVariations" + val `expandVariations`: I18nKey = "expandVariations" val `forceVariation`: I18nKey = "forceVariation" val `copyVariationPgn`: I18nKey = "copyVariationPgn" val `move`: I18nKey = "move" diff --git a/translation/source/site.xml b/translation/source/site.xml index 02920c3bb6df8..d3bfc03e4e9e6 100644 --- a/translation/source/site.xml +++ b/translation/source/site.xml @@ -70,6 +70,8 @@ Promote variation Make mainline Delete from here + Collapse variations + Expand variations Force variation Copy variation PGN Move diff --git a/ui/@types/lichess/tree.d.ts b/ui/@types/lichess/tree.d.ts index d578442b66434..f47e999fb169e 100644 --- a/ui/@types/lichess/tree.d.ts +++ b/ui/@types/lichess/tree.d.ts @@ -72,6 +72,7 @@ declare namespace Tree { } export interface Node extends NodeBase { children: Node[]; + collapsed?: boolean; } export interface NodeCrazy { diff --git a/ui/analyse/src/ctrl.ts b/ui/analyse/src/ctrl.ts index c4f87723efc2c..58fe5dea3c894 100644 --- a/ui/analyse/src/ctrl.ts +++ b/ui/analyse/src/ctrl.ts @@ -636,6 +636,11 @@ export default class AnalyseCtrl { this.treeVersion++; } + setCollapsed(path: Tree.Path, collapsed: boolean): void { + this.tree.setCollapsedAt(path, collapsed); + this.redraw(); + } + forceVariation(path: Tree.Path, force: boolean): void { this.tree.forceVariationAt(path, force); this.jump(path); diff --git a/ui/analyse/src/treeView/columnView.ts b/ui/analyse/src/treeView/columnView.ts index ed340a416f036..c12e6ade4cd11 100644 --- a/ui/analyse/src/treeView/columnView.ts +++ b/ui/analyse/src/treeView/columnView.ts @@ -1,5 +1,6 @@ import { VNode } from 'snabbdom'; import { isEmpty } from 'common'; +import * as licon from 'common/licon'; import { LooseVNodes, looseH as h } from 'common/snabbdom'; import { fixCrazySan } from 'chess'; import { path as treePath, ops as treeOps } from 'tree'; @@ -63,7 +64,7 @@ function renderChildrenOf(ctx: Ctx, node: Tree.Node, opts: Opts): LooseVNodes | h( 'interrupt', commentTags.concat( - renderLines(ctx, main.forceVariation ? cs : cs.slice(1), { + renderLines(ctx, node, main.forceVariation ? cs : cs.slice(1), { parentPath: opts.parentPath, isMainline: passOpts.isMainline, conceal, @@ -77,7 +78,7 @@ function renderChildrenOf(ctx: Ctx, node: Tree.Node, opts: Opts): LooseVNodes | ]; } if (!cs[1]) return renderMoveAndChildrenOf(ctx, main, opts); - return renderInlined(ctx, cs, opts) || [renderLines(ctx, cs, opts)]; + return renderInlined(ctx, cs, opts) || [renderLines(ctx, node, cs, opts)]; } function renderInlined(ctx: Ctx, nodes: Tree.Node[], opts: Opts): LooseVNodes | undefined { @@ -93,11 +94,18 @@ function renderInlined(ctx: Ctx, nodes: Tree.Node[], opts: Opts): LooseVNodes | }); } -function renderLines(ctx: Ctx, nodes: Tree.Node[], opts: Opts): VNode { - return h( - 'lines', - { class: { single: !nodes[1] } }, - nodes.map(n => { +function renderLines(ctx: Ctx, parentNode: Tree.Node, nodes: Tree.Node[], opts: Opts): VNode { + return h('lines', { class: { single: !nodes[1], collapsed: parentNode.collapsed || false } }, [ + parentNode.collapsed + ? h('line', { class: { expand: true } }, [ + h('branch'), + h('a', { + attrs: { 'data-icon': licon.PlusButton, title: ctx.ctrl.trans.noarg('expandVariations') }, + on: { click: () => ctx.ctrl.setCollapsed(opts.parentPath, false) }, + }), + ]) + : null, + ...nodes.map(n => { return ( retroLine(ctx, n) || h('line', [ @@ -112,7 +120,7 @@ function renderLines(ctx: Ctx, nodes: Tree.Node[], opts: Opts): VNode { ]) ); }), - ); + ]); } function renderMoveOf(ctx: Ctx, node: Tree.Node, opts: Opts): VNode { diff --git a/ui/analyse/src/treeView/contextMenu.ts b/ui/analyse/src/treeView/contextMenu.ts index f7f4a42af9ffc..06dc1a1b53d9b 100644 --- a/ui/analyse/src/treeView/contextMenu.ts +++ b/ui/analyse/src/treeView/contextMenu.ts @@ -82,6 +82,10 @@ function view(opts: Opts, coords: Coords): VNode { action(licon.Trash, trans('deleteFromHere'), () => ctrl.deleteNode(opts.path)), + action(licon.PlusButton, trans('expandVariations'), () => ctrl.setCollapsed(opts.path, false)), + + action(licon.MinusButton, trans('collapseVariations'), () => ctrl.setCollapsed(opts.path, true)), + ...(ctrl.study ? studyView.contextMenu(ctrl.study, opts.path, node) : []), onMainline && diff --git a/ui/analyse/src/treeView/inlineView.ts b/ui/analyse/src/treeView/inlineView.ts index 6f8903793db75..ba4c480119570 100644 --- a/ui/analyse/src/treeView/inlineView.ts +++ b/ui/analyse/src/treeView/inlineView.ts @@ -3,6 +3,7 @@ import { fixCrazySan } from 'chess'; import { path as treePath, ops as treeOps } from 'tree'; import * as moveView from '../view/moveView'; import AnalyseCtrl from '../ctrl'; +import * as licon from 'common/licon'; import { MaybeVNodes } from 'common/snabbdom'; import { mainHook, nodeClasses, renderInlineCommentsOf, retroLine, Ctx, Opts, renderingCtx } from './common'; @@ -31,7 +32,7 @@ function renderChildrenOf(ctx: Ctx, node: Tree.Node, opts: Opts): MaybeVNodes | ]), h( 'interrupt', - renderLines(ctx, main.forceVariation ? cs : cs.slice(1), { + renderLines(ctx, node, main.forceVariation ? cs : cs.slice(1), { parentPath: opts.parentPath, isMainline: true, }), @@ -47,7 +48,7 @@ function renderChildrenOf(ctx: Ctx, node: Tree.Node, opts: Opts): MaybeVNodes | ); } if (!cs[1]) return renderMoveAndChildrenOf(ctx, main, opts); - return renderInlined(ctx, cs, opts) || [renderLines(ctx, cs, opts)]; + return renderInlined(ctx, cs, opts) || [renderLines(ctx, node, cs, opts)]; } function renderInlined(ctx: Ctx, nodes: Tree.Node[], opts: Opts): MaybeVNodes | undefined { @@ -62,10 +63,18 @@ function renderInlined(ctx: Ctx, nodes: Tree.Node[], opts: Opts): MaybeVNodes | }); } -function renderLines(ctx: Ctx, nodes: Tree.Node[], opts: Opts): VNode { - return h( - 'lines', - nodes.map(n => { +function renderLines(ctx: Ctx, parentNode: Tree.Node, nodes: Tree.Node[], opts: Opts): VNode { + return h('lines', { class: { collapsed: parentNode.collapsed || false } }, [ + parentNode.collapsed + ? h('line', { class: { expand: true } }, [ + h('branch'), + h('a', { + attrs: { 'data-icon': licon.PlusButton, title: ctx.ctrl.trans.noarg('expandVariations') }, + on: { click: () => ctx.ctrl.setCollapsed(opts.parentPath, false) }, + }), + ]) + : null, + ...nodes.map(n => { return ( retroLine(ctx, n) || h('line', [ @@ -79,7 +88,7 @@ function renderLines(ctx: Ctx, nodes: Tree.Node[], opts: Opts): VNode { ]) ); }), - ); + ]); } function renderMoveAndChildrenOf(ctx: Ctx, node: Tree.Node, opts: Opts): MaybeVNodes { diff --git a/ui/analyse/src/view/util.ts b/ui/analyse/src/view/util.ts index 030f3b104ae57..9f81a9df22f39 100644 --- a/ui/analyse/src/view/util.ts +++ b/ui/analyse/src/view/util.ts @@ -1,8 +1,8 @@ import { fixCrazySan } from 'chess'; -import { attributesModule, classModule, init, h } from 'snabbdom'; +import { attributesModule, classModule, eventListenersModule, init, h } from 'snabbdom'; import { plyToTurn } from '../util'; -export const patch = init([classModule, attributesModule]); +export const patch = init([classModule, attributesModule, eventListenersModule]); export const emptyRedButton = 'button.button.button-red.button-empty'; diff --git a/ui/tree/css/_tree.scss b/ui/tree/css/_tree.scss index d4e3dfa5ea539..ee30461fe032f 100644 --- a/ui/tree/css/_tree.scss +++ b/ui/tree/css/_tree.scss @@ -334,7 +334,8 @@ height: 100%; } - line:last-child > branch { + line:last-child > branch, + line.expand > branch { height: calc(0.8em + 2px); } @@ -364,6 +365,18 @@ margin-bottom: 0; } + lines.collapsed > * { + display: none; + } + + lines.collapsed > line.expand { + display: block; + } + + line.expand > a { + color: var(--c-font-dim); + } + inline { display: inline; font-style: italic; diff --git a/ui/tree/src/tree.ts b/ui/tree/src/tree.ts index 3ccac90adca99..47f881956e608 100644 --- a/ui/tree/src/tree.ts +++ b/ui/tree/src/tree.ts @@ -26,6 +26,7 @@ export interface TreeWrapper { lastMainlineNode(path: Tree.Path): Tree.Node; pathExists(path: Tree.Path): boolean; deleteNodeAt(path: Tree.Path): void; + setCollapsedAt(path: Tree.Path, collapsed: boolean): MaybeNode; promoteAt(path: Tree.Path, toMainline: boolean): void; forceVariationAt(path: Tree.Path, force: boolean): MaybeNode; getCurrentNodesAfterPly(nodeList: Tree.Node[], mainline: Tree.Node[], ply: number): Tree.Node[]; @@ -212,6 +213,11 @@ export function build(root: Tree.Node): TreeWrapper { node.clock = clock; }); }, + setCollapsedAt(path: Tree.Path, collapsed: boolean) { + return updateAt(path, function (node) { + node.collapsed = collapsed; + }); + }, pathIsMainline, pathIsForcedVariation, lastMainlineNode(path: Tree.Path): Tree.Node { From 00679f2fa401ec9cc1d0953d7ddfcd32b241e25c Mon Sep 17 00:00:00 2001 From: Ben Olden-Cooligan Date: Wed, 12 Jun 2024 16:35:26 -0700 Subject: [PATCH 007/168] Recursively expand/collapse --- ui/analyse/src/ctrl.ts | 8 ++++++++ ui/analyse/src/treeView/contextMenu.ts | 4 ++-- ui/tree/src/tree.ts | 13 +++++++++++++ 3 files changed, 23 insertions(+), 2 deletions(-) diff --git a/ui/analyse/src/ctrl.ts b/ui/analyse/src/ctrl.ts index 58fe5dea3c894..dc989d737b5c0 100644 --- a/ui/analyse/src/ctrl.ts +++ b/ui/analyse/src/ctrl.ts @@ -641,6 +641,14 @@ export default class AnalyseCtrl { this.redraw(); } + setAllCollapsed(path: Tree.Path, collapsed: boolean): void { + // Also update parent + const parentPath = treePath.init(path); + this.tree.setCollapsedAt(parentPath, collapsed); + this.tree.setCollapsedRecursive(path, collapsed); + this.redraw(); + } + forceVariation(path: Tree.Path, force: boolean): void { this.tree.forceVariationAt(path, force); this.jump(path); diff --git a/ui/analyse/src/treeView/contextMenu.ts b/ui/analyse/src/treeView/contextMenu.ts index 06dc1a1b53d9b..edcadf8ef1c28 100644 --- a/ui/analyse/src/treeView/contextMenu.ts +++ b/ui/analyse/src/treeView/contextMenu.ts @@ -82,9 +82,9 @@ function view(opts: Opts, coords: Coords): VNode { action(licon.Trash, trans('deleteFromHere'), () => ctrl.deleteNode(opts.path)), - action(licon.PlusButton, trans('expandVariations'), () => ctrl.setCollapsed(opts.path, false)), + action(licon.PlusButton, trans('expandVariations'), () => ctrl.setAllCollapsed(opts.path, false)), - action(licon.MinusButton, trans('collapseVariations'), () => ctrl.setCollapsed(opts.path, true)), + action(licon.MinusButton, trans('collapseVariations'), () => ctrl.setAllCollapsed(opts.path, true)), ...(ctrl.study ? studyView.contextMenu(ctrl.study, opts.path, node) : []), diff --git a/ui/tree/src/tree.ts b/ui/tree/src/tree.ts index 47f881956e608..e29acbbc3b7c7 100644 --- a/ui/tree/src/tree.ts +++ b/ui/tree/src/tree.ts @@ -27,6 +27,7 @@ export interface TreeWrapper { pathExists(path: Tree.Path): boolean; deleteNodeAt(path: Tree.Path): void; setCollapsedAt(path: Tree.Path, collapsed: boolean): MaybeNode; + setCollapsedRecursive(path: Tree.Path, collapsed: boolean): void; promoteAt(path: Tree.Path, toMainline: boolean): void; forceVariationAt(path: Tree.Path, force: boolean): MaybeNode; getCurrentNodesAfterPly(nodeList: Tree.Node[], mainline: Tree.Node[], ply: number): Tree.Node[]; @@ -110,6 +111,13 @@ export function build(root: Tree.Node): TreeWrapper { return; } + function updateRecursive(path: Tree.Path, update: (node: Tree.Node) => void): void { + const node = nodeAtPathOrNull(path); + if (node) { + ops.updateAll(node, update); + } + } + // returns new path function addNode(node: Tree.Node, path: Tree.Path): Tree.Path | undefined { const newPath = path + node.id, @@ -218,6 +226,11 @@ export function build(root: Tree.Node): TreeWrapper { node.collapsed = collapsed; }); }, + setCollapsedRecursive(path: Tree.Path, collapsed: boolean) { + return updateRecursive(path, function (node) { + node.collapsed = collapsed; + }); + }, pathIsMainline, pathIsForcedVariation, lastMainlineNode(path: Tree.Path): Tree.Node { From bc78ab3475457d7a8fea48f961c15ce1846c06b8 Mon Sep 17 00:00:00 2001 From: Ben Olden-Cooligan Date: Wed, 12 Jun 2024 16:35:47 -0700 Subject: [PATCH 008/168] Auto-expand when navigating through moves --- ui/analyse/src/ctrl.ts | 3 +++ 1 file changed, 3 insertions(+) diff --git a/ui/analyse/src/ctrl.ts b/ui/analyse/src/ctrl.ts index dc989d737b5c0..07a7a20b17477 100644 --- a/ui/analyse/src/ctrl.ts +++ b/ui/analyse/src/ctrl.ts @@ -253,6 +253,9 @@ export default class AnalyseCtrl { this.path = path; this.nodeList = this.tree.getNodeList(path); this.node = treeOps.last(this.nodeList) as Tree.Node; + for (let i = 0; i < this.nodeList.length; i++) { + this.nodeList[i].collapsed = false; + } this.mainline = treeOps.mainlineNodeList(this.tree.root); this.onMainline = this.tree.pathIsMainline(path); this.fenInput = undefined; From 87864009188d954ea4d2dd5cfdd68c914e15a2c4 Mon Sep 17 00:00:00 2001 From: Ben Olden-Cooligan Date: Wed, 12 Jun 2024 18:13:45 -0700 Subject: [PATCH 009/168] Auto-collapse deeply nested variations on page load The node's "collapse" flag we now treat as a tri-state where "undefined" means to use the default collapse state. --- ui/analyse/src/treeView/columnView.ts | 36 +++++++++++++++++++++------ ui/analyse/src/treeView/common.ts | 1 + ui/analyse/src/treeView/inlineView.ts | 21 +++++++++++++--- 3 files changed, 48 insertions(+), 10 deletions(-) diff --git a/ui/analyse/src/treeView/columnView.ts b/ui/analyse/src/treeView/columnView.ts index c12e6ade4cd11..2dee229521913 100644 --- a/ui/analyse/src/treeView/columnView.ts +++ b/ui/analyse/src/treeView/columnView.ts @@ -49,13 +49,28 @@ function renderChildrenOf(ctx: Ctx, node: Tree.Node, opts: Opts): LooseVNodes | if (!cs[1] && isEmpty(commentTags) && !main.forceVariation) return [ isWhite && moveView.renderIndex(main.ply, false), - ...renderMoveAndChildrenOf(ctx, main, { parentPath: opts.parentPath, isMainline: true, conceal }), + ...renderMoveAndChildrenOf(ctx, main, { + parentPath: opts.parentPath, + isMainline: true, + depth: opts.depth, + conceal, + }), ]; const mainChildren = !main.forceVariation && - renderChildrenOf(ctx, main, { parentPath: opts.parentPath + main.id, isMainline: true, conceal }); - - const passOpts = { parentPath: opts.parentPath, isMainline: !main.forceVariation, conceal }; + renderChildrenOf(ctx, main, { + parentPath: opts.parentPath + main.id, + isMainline: true, + depth: opts.depth, + conceal, + }); + + const passOpts = { + parentPath: opts.parentPath, + isMainline: !main.forceVariation, + depth: opts.depth, + conceal, + }; return [ isWhite && moveView.renderIndex(main.ply, false), @@ -67,6 +82,7 @@ function renderChildrenOf(ctx: Ctx, node: Tree.Node, opts: Opts): LooseVNodes | renderLines(ctx, node, main.forceVariation ? cs : cs.slice(1), { parentPath: opts.parentPath, isMainline: passOpts.isMainline, + depth: opts.depth, conceal, noConceal: !conceal, }), @@ -89,14 +105,17 @@ function renderInlined(ctx: Ctx, nodes: Tree.Node[], opts: Opts): LooseVNodes | return renderMoveAndChildrenOf(ctx, nodes[0], { parentPath: opts.parentPath, isMainline: false, + depth: opts.depth, noConceal: opts.noConceal, inline: nodes[1], }); } function renderLines(ctx: Ctx, parentNode: Tree.Node, nodes: Tree.Node[], opts: Opts): VNode { - return h('lines', { class: { single: !nodes[1], collapsed: parentNode.collapsed || false } }, [ - parentNode.collapsed + const collapsed = + parentNode.collapsed === undefined ? opts.depth >= 2 && opts.depth % 2 === 0 : parentNode.collapsed; + return h('lines', { class: { single: !nodes[1], collapsed } }, [ + collapsed ? h('line', { class: { expand: true } }, [ h('branch'), h('a', { @@ -113,6 +132,7 @@ function renderLines(ctx: Ctx, parentNode: Tree.Node, nodes: Tree.Node[], opts: ...renderMoveAndChildrenOf(ctx, n, { parentPath: opts.parentPath, isMainline: false, + depth: opts.depth + 1, withIndex: true, noConceal: opts.noConceal, truncate: n.comp && !treePath.contains(ctx.ctrl.path, opts.parentPath + n.id) ? 3 : undefined, @@ -154,6 +174,7 @@ function renderMoveAndChildrenOf(ctx: Ctx, node: Tree.Node, opts: Opts): LooseVN ...(renderChildrenOf(ctx, node, { parentPath: path, isMainline: opts.isMainline, + depth: opts.depth, noConceal: opts.noConceal, truncate: opts.truncate ? opts.truncate - 1 : undefined, }) || []), @@ -167,6 +188,7 @@ function renderInline(ctx: Ctx, node: Tree.Node, opts: Opts): VNode { withIndex: true, parentPath: opts.parentPath, isMainline: false, + depth: opts.depth, noConceal: opts.noConceal, truncate: opts.truncate, }), @@ -209,6 +231,6 @@ export default function (ctrl: AnalyseCtrl, concealOf?: ConcealOf): VNode { !isEmpty(commentTags) && h('interrupt', commentTags), blackStarts && moveView.renderIndex(root.ply, false), blackStarts && emptyMove(), - ...(renderChildrenOf(ctx, root, { parentPath: '', isMainline: true }) || []), + ...(renderChildrenOf(ctx, root, { parentPath: '', isMainline: true, depth: 0 }) || []), ]); } diff --git a/ui/analyse/src/treeView/common.ts b/ui/analyse/src/treeView/common.ts index cb6c03bc49ad9..782cd7afcdabd 100644 --- a/ui/analyse/src/treeView/common.ts +++ b/ui/analyse/src/treeView/common.ts @@ -164,6 +164,7 @@ export interface Ctx { export interface Opts { parentPath: Tree.Path; isMainline: boolean; + depth: number; inline?: Tree.Node; withIndex?: boolean; truncate?: number; diff --git a/ui/analyse/src/treeView/inlineView.ts b/ui/analyse/src/treeView/inlineView.ts index ba4c480119570..5b81597411a34 100644 --- a/ui/analyse/src/treeView/inlineView.ts +++ b/ui/analyse/src/treeView/inlineView.ts @@ -16,6 +16,7 @@ function renderChildrenOf(ctx: Ctx, node: Tree.Node, opts: Opts): MaybeVNodes | return renderMoveAndChildrenOf(ctx, main, { parentPath: opts.parentPath, isMainline: true, + depth: opts.depth, withIndex: opts.withIndex, }); return ( @@ -26,6 +27,7 @@ function renderChildrenOf(ctx: Ctx, node: Tree.Node, opts: Opts): MaybeVNodes | renderMoveOf(ctx, main, { parentPath: opts.parentPath, isMainline: true, + depth: opts.depth, withIndex: opts.withIndex, }), ...renderInlineCommentsOf(ctx, main, opts.parentPath), @@ -35,6 +37,7 @@ function renderChildrenOf(ctx: Ctx, node: Tree.Node, opts: Opts): MaybeVNodes | renderLines(ctx, node, main.forceVariation ? cs : cs.slice(1), { parentPath: opts.parentPath, isMainline: true, + depth: opts.depth, }), ), ...(main.forceVariation @@ -42,6 +45,7 @@ function renderChildrenOf(ctx: Ctx, node: Tree.Node, opts: Opts): MaybeVNodes | : renderChildrenOf(ctx, main, { parentPath: opts.parentPath + main.id, isMainline: true, + depth: opts.depth, withIndex: true, }) || []), ] @@ -59,13 +63,16 @@ function renderInlined(ctx: Ctx, nodes: Tree.Node[], opts: Opts): MaybeVNodes | return renderMoveAndChildrenOf(ctx, nodes[0], { parentPath: opts.parentPath, isMainline: opts.isMainline, + depth: opts.depth, inline: nodes[1], }); } function renderLines(ctx: Ctx, parentNode: Tree.Node, nodes: Tree.Node[], opts: Opts): VNode { - return h('lines', { class: { collapsed: parentNode.collapsed || false } }, [ - parentNode.collapsed + const collapsed = + parentNode.collapsed === undefined ? opts.depth >= 2 && opts.depth % 2 === 0 : parentNode.collapsed; + return h('lines', { class: { collapsed } }, [ + collapsed ? h('line', { class: { expand: true } }, [ h('branch'), h('a', { @@ -82,6 +89,7 @@ function renderLines(ctx: Ctx, parentNode: Tree.Node, nodes: Tree.Node[], opts: ...renderMoveAndChildrenOf(ctx, n, { parentPath: opts.parentPath, isMainline: false, + depth: opts.depth + 1, withIndex: true, truncate: n.comp && !treePath.contains(ctx.ctrl.path, opts.parentPath + n.id) ? 3 : undefined, }), @@ -102,6 +110,7 @@ function renderMoveAndChildrenOf(ctx: Ctx, node: Tree.Node, opts: Opts): MaybeVN renderChildrenOf(ctx, node, { parentPath: path, isMainline: opts.isMainline, + depth: opts.depth, truncate: opts.truncate ? opts.truncate - 1 : undefined, withIndex: !!comments[0], }) || [], @@ -113,7 +122,12 @@ function renderInline(ctx: Ctx, node: Tree.Node, opts: Opts): VNode { if (retro) return h('interrupt', h('lines', retro)); return h( 'inline', - renderMoveAndChildrenOf(ctx, node, { withIndex: true, parentPath: opts.parentPath, isMainline: false }), + renderMoveAndChildrenOf(ctx, node, { + withIndex: true, + parentPath: opts.parentPath, + isMainline: false, + depth: opts.depth, + }), ); } @@ -134,6 +148,7 @@ export default function (ctrl: AnalyseCtrl): VNode { ...(renderChildrenOf(ctx, ctrl.tree.root, { parentPath: '', isMainline: true, + depth: 0, }) || []), ]); } From 4e598bc47b81d563c9131d2284cc12436b894df0 Mon Sep 17 00:00:00 2001 From: Ben Olden-Cooligan Date: Wed, 12 Jun 2024 19:03:48 -0700 Subject: [PATCH 010/168] Fix autoscroll offset We've added "position: relative" to the elements for styling purposes, but that affects the calculation of the "offsetTop" property. We can instead calculate the offset ourselves. --- ui/analyse/src/treeView/common.ts | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/ui/analyse/src/treeView/common.ts b/ui/analyse/src/treeView/common.ts index 782cd7afcdabd..70d9fe8480295 100644 --- a/ui/analyse/src/treeView/common.ts +++ b/ui/analyse/src/treeView/common.ts @@ -59,7 +59,8 @@ const autoScroll = throttle(200, (ctrl: AnalyseCtrl, el: HTMLElement) => { cont.scrollTop = ctrl.path ? 99999 : 0; return; } - cont.scrollTop = target.offsetTop - cont.offsetHeight / 2 + target.offsetHeight; + const targetOffset = target.getBoundingClientRect().y - el.getBoundingClientRect().y; + cont.scrollTop = targetOffset - cont.offsetHeight / 2 + target.offsetHeight; }); export interface NodeClasses { From aefe9be30f19255f5a9ffbae93d9b7f03c8a2df7 Mon Sep 17 00:00:00 2001 From: Ben Olden-Cooligan Date: Wed, 12 Jun 2024 19:53:28 -0700 Subject: [PATCH 011/168] Add hover styling for expand variations button --- ui/tree/css/_tree.scss | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/ui/tree/css/_tree.scss b/ui/tree/css/_tree.scss index ee30461fe032f..9819ef30d6b1c 100644 --- a/ui/tree/css/_tree.scss +++ b/ui/tree/css/_tree.scss @@ -377,6 +377,10 @@ color: var(--c-font-dim); } + line.expand > a:hover { + color: var(--c-font); + } + inline { display: inline; font-style: italic; From fdd82e33a349cb5ec1142121c4dc8e13417b6ac5 Mon Sep 17 00:00:00 2001 From: Trevor Fitzgerald Date: Thu, 13 Jun 2024 12:29:17 -0400 Subject: [PATCH 012/168] Vitest with jsdom for frontend tests --- .github/workflows/assets.yml | 8 +- .github/workflows/lint.yml | 2 +- pnpm-lock.yaml | 3010 ++++++----------- ui/@types/lichess/index.d.ts | 6 +- ui/README.md | 11 +- ui/chat/src/spam.ts | 2 +- ui/chat/tests/spam.test.ts | 25 + ui/common/src/richText.ts | 6 +- ui/common/tests/richText.test.ts | 31 + ui/game/src/status.ts | 2 +- ui/jest.config.js | 9 - ui/keyboardMove/package.json | 1 - .../{src => tests}/keyboardSubmit.test.ts | 152 +- ui/package.json | 7 +- ui/site/src/clockWidget.ts | 2 +- ui/site/src/log.ts | 4 +- ui/site/src/once.ts | 9 +- ui/site/src/powertip.ts | 2 +- ui/site/tests/once.test.ts | 14 + ui/site/tests/timeago.test.ts | 40 + ui/vitest.config.ts | 7 + 21 files changed, 1280 insertions(+), 2070 deletions(-) create mode 100644 ui/chat/tests/spam.test.ts create mode 100644 ui/common/tests/richText.test.ts delete mode 100644 ui/jest.config.js rename ui/keyboardMove/{src => tests}/keyboardSubmit.test.ts (83%) create mode 100644 ui/site/tests/once.test.ts create mode 100644 ui/site/tests/timeago.test.ts create mode 100644 ui/vitest.config.ts diff --git a/.github/workflows/assets.yml b/.github/workflows/assets.yml index 2288702812daf..571be6c445e7e 100644 --- a/.github/workflows/assets.yml +++ b/.github/workflows/assets.yml @@ -25,7 +25,10 @@ jobs: - uses: actions/checkout@v4 with: submodules: recursive - - uses: pnpm/action-setup@v3 + - uses: actions/setup-node@v4 + with: + node-version: 22 + - uses: pnpm/action-setup@v4 with: run_install: true - uses: actions/checkout@v4 @@ -39,7 +42,8 @@ jobs: - run: pnpm link "$GITHUB_WORKSPACE/ab" if: steps.ab.outcome == 'success' - run: ./ui/build --no-install -p - - run: cd ui && pnpm run test && cd - + - run: pnpm test + working-directory: ui - run: mkdir assets && mv public assets/ && cp -p bin/download-lifat LICENSE COPYING.md README.md assets/ && git log -n 1 --pretty=oneline > assets/commit.txt - run: cd assets && tar --zstd -cvpf ../assets.tar.zst . && cd - - uses: actions/upload-artifact@v4 diff --git a/.github/workflows/lint.yml b/.github/workflows/lint.yml index 88bc7f0d357bf..501a94459dccb 100644 --- a/.github/workflows/lint.yml +++ b/.github/workflows/lint.yml @@ -17,7 +17,7 @@ jobs: security-events: write steps: - uses: actions/checkout@v4 - - uses: pnpm/action-setup@v3 + - uses: pnpm/action-setup@v4 with: run_install: true - uses: github/codeql-action/init@v3 diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml index 85d700620dbe0..f4e6dc0eceb28 100644 --- a/pnpm-lock.yaml +++ b/pnpm-lock.yaml @@ -53,12 +53,12 @@ importers: ui: dependencies: - '@types/jest': - specifier: ^29.5.12 - version: 29.5.12 - jest: - specifier: ^29.7.0 - version: 29.7.0(@types/node@20.12.2) + jsdom: + specifier: ^24.1.0 + version: 24.1.0 + vitest: + specifier: ^1.6.0 + version: 1.6.0(@types/node@20.12.2)(jsdom@24.1.0) ui/@types/lichess: {} @@ -394,9 +394,6 @@ importers: ui/keyboardMove: dependencies: - '@jest/globals': - specifier: ^29.7.0 - version: 29.7.0 chess: specifier: workspace:* version: link:../chess @@ -782,185 +779,152 @@ packages: resolution: {integrity: sha512-1Yjs2SvM8TflER/OD3cOjhWWOZb58A2t7wpE2S9XfBYTiIl+XFhQG2bjy4Pu1I+EAlCNUzRDYDdFwFYUKvXcIA==} engines: {node: '>=0.10.0'} - '@ampproject/remapping@2.3.0': - resolution: {integrity: sha512-30iZtAPgz+LTIYoeivqYo853f02jBYSd5uGnGpkFV0M3xOt9aN73erkgYAmZU43x4VfqcnLxW9Kpg3R5LC4YYw==} - engines: {node: '>=6.0.0'} - - '@babel/code-frame@7.24.2': - resolution: {integrity: sha512-y5+tLQyV8pg3fsiln67BVLD1P13Eg4lh5RW9mF0zUuvLrv9uIQ4MCL+CRT+FTsBlBjcIan6PGsLcBN0m3ClUyQ==} - engines: {node: '>=6.9.0'} - - '@babel/compat-data@7.24.1': - resolution: {integrity: sha512-Pc65opHDliVpRHuKfzI+gSA4zcgr65O4cl64fFJIWEEh8JoHIHh0Oez1Eo8Arz8zq/JhgKodQaxEwUPRtZylVA==} - engines: {node: '>=6.9.0'} - - '@babel/core@7.24.3': - resolution: {integrity: sha512-5FcvN1JHw2sHJChotgx8Ek0lyuh4kCKelgMTTqhYJJtloNvUfpAFMeNQUtdlIaktwrSV9LtCdqwk48wL2wBacQ==} - engines: {node: '>=6.9.0'} - - '@babel/generator@7.24.1': - resolution: {integrity: sha512-DfCRfZsBcrPEHUfuBMgbJ1Ut01Y/itOs+hY2nFLgqsqXd52/iSiVq5TITtUasIUgm+IIKdY2/1I7auiQOEeC9A==} - engines: {node: '>=6.9.0'} - - '@babel/helper-compilation-targets@7.23.6': - resolution: {integrity: sha512-9JB548GZoQVmzrFgp8o7KxdgkTGm6xs9DW0o/Pim72UDjzr5ObUQ6ZzYPqA+g9OTS2bBQoctLJrky0RDCAWRgQ==} - engines: {node: '>=6.9.0'} - - '@babel/helper-environment-visitor@7.22.20': - resolution: {integrity: sha512-zfedSIzFhat/gFhWfHtgWvlec0nqB9YEIVrpuwjruLlXfUSnA8cJB0miHKwqDnQ7d32aKo2xt88/xZptwxbfhA==} - engines: {node: '>=6.9.0'} - - '@babel/helper-function-name@7.23.0': - resolution: {integrity: sha512-OErEqsrxjZTJciZ4Oo+eoZqeW9UIiOcuYKRJA4ZAgV9myA+pOXhhmpfNCKjEH/auVfEYVFJ6y1Tc4r0eIApqiw==} - engines: {node: '>=6.9.0'} - - '@babel/helper-hoist-variables@7.22.5': - resolution: {integrity: sha512-wGjk9QZVzvknA6yKIUURb8zY3grXCcOZt+/7Wcy8O2uctxhplmUPkOdlgoNhmdVee2c92JXbf1xpMtVNbfoxRw==} - engines: {node: '>=6.9.0'} - - '@babel/helper-module-imports@7.24.3': - resolution: {integrity: sha512-viKb0F9f2s0BCS22QSF308z/+1YWKV/76mwt61NBzS5izMzDPwdq1pTrzf+Li3npBWX9KdQbkeCt1jSAM7lZqg==} - engines: {node: '>=6.9.0'} - - '@babel/helper-module-transforms@7.23.3': - resolution: {integrity: sha512-7bBs4ED9OmswdfDzpz4MpWgSrV7FXlc3zIagvLFjS5H+Mk7Snr21vQ6QwrsoCGMfNC4e4LQPdoULEt4ykz0SRQ==} - engines: {node: '>=6.9.0'} - peerDependencies: - '@babel/core': ^7.0.0 - - '@babel/helper-plugin-utils@7.24.0': - resolution: {integrity: sha512-9cUznXMG0+FxRuJfvL82QlTqIzhVW9sL0KjMPHhAOOvpQGL8QtdxnBKILjBqxlHyliz0yCa1G903ZXI/FuHy2w==} - engines: {node: '>=6.9.0'} - - '@babel/helper-simple-access@7.22.5': - resolution: {integrity: sha512-n0H99E/K+Bika3++WNL17POvo4rKWZ7lZEp1Q+fStVbUi8nxPQEBOlTmCOxW/0JsS56SKKQ+ojAe2pHKJHN35w==} - engines: {node: '>=6.9.0'} - - '@babel/helper-split-export-declaration@7.22.6': - resolution: {integrity: sha512-AsUnxuLhRYsisFiaJwvp1QF+I3KjD5FOxut14q/GzovUe6orHLesW2C7d754kRm53h5gqrz6sFl6sxc4BVtE/g==} - engines: {node: '>=6.9.0'} - - '@babel/helper-string-parser@7.24.1': - resolution: {integrity: sha512-2ofRCjnnA9y+wk8b9IAREroeUP02KHp431N2mhKniy2yKIDKpbrHv9eXwm8cBeWQYcJmzv5qKCu65P47eCF7CQ==} - engines: {node: '>=6.9.0'} - - '@babel/helper-validator-identifier@7.22.20': - resolution: {integrity: sha512-Y4OZ+ytlatR8AI+8KZfKuL5urKp7qey08ha31L8b3BwewJAoJamTzyvxPR/5D+KkdJCGPq/+8TukHBlY10FX9A==} - engines: {node: '>=6.9.0'} + '@badrap/result@0.2.13': + resolution: {integrity: sha512-Qvyzz0dmGY0h8pwvBFo1BznAKf5Y5NXIDiqhPALWtfU7oHbAToCtPu4FlYQ3uysskSWLx8GUiyhe0nv0nDd/7Q==} - '@babel/helper-validator-option@7.23.5': - resolution: {integrity: sha512-85ttAOMLsr53VgXkTbkx8oA6YTfT4q7/HzXSLEYmjcSTJPMPQtvq1BD79Byep5xMUYbGRzEpDsjUf3dyp54IKw==} - engines: {node: '>=6.9.0'} + '@blakeembrey/deque@1.0.5': + resolution: {integrity: sha512-6xnwtvp9DY1EINIKdTfvfeAtCYw4OqBZJhtiqkT3ivjnEfa25VQ3TsKvaFfKm8MyGIEfE95qLe+bNEt3nB0Ylg==} - '@babel/helpers@7.24.1': - resolution: {integrity: sha512-BpU09QqEe6ZCHuIHFphEFgvNSrubve1FtyMton26ekZ85gRGi6LrTF7zArARp2YvyFxloeiRmtSCq5sjh1WqIg==} - engines: {node: '>=6.9.0'} + '@blakeembrey/template@1.1.0': + resolution: {integrity: sha512-iZf+UWfL+DogJVpd/xMQyP6X6McYd6ArdYoPMiv/zlOTzeXXfQbYxBNJJBF6tThvsjLMbA8tLjkCdm9RWMFCCw==} - '@babel/highlight@7.24.2': - resolution: {integrity: sha512-Yac1ao4flkTxTteCDZLEvdxg2fZfz1v8M4QpaGypq/WPDqg3ijHYbDfs+LG5hvzSoqaSZ9/Z9lKSP3CjZjv+pA==} - engines: {node: '>=6.9.0'} + '@esbuild/aix-ppc64@0.21.5': + resolution: {integrity: sha512-1SDgH6ZSPTlggy1yI6+Dbkiz8xzpHJEVAlF/AM1tHPLsf5STom9rwtjE4hKAF20FfXXNTFqEYXyJNWh1GiZedQ==} + engines: {node: '>=12'} + cpu: [ppc64] + os: [aix] - '@babel/parser@7.24.1': - resolution: {integrity: sha512-Zo9c7N3xdOIQrNip7Lc9wvRPzlRtovHVE4lkz8WEDr7uYh/GMQhSiIgFxGIArRHYdJE5kxtZjAf8rT0xhdLCzg==} - engines: {node: '>=6.0.0'} - hasBin: true + '@esbuild/android-arm64@0.21.5': + resolution: {integrity: sha512-c0uX9VAUBQ7dTDCjq+wdyGLowMdtR/GoC2U5IYk/7D1H1JYC0qseD7+11iMP2mRLN9RcCMRcjC4YMclCzGwS/A==} + engines: {node: '>=12'} + cpu: [arm64] + os: [android] - '@babel/plugin-syntax-async-generators@7.8.4': - resolution: {integrity: sha512-tycmZxkGfZaxhMRbXlPXuVFpdWlXpir2W4AMhSJgRKzk/eDlIXOhb2LHWoLpDF7TEHylV5zNhykX6KAgHJmTNw==} - peerDependencies: - '@babel/core': ^7.0.0-0 + '@esbuild/android-arm@0.21.5': + resolution: {integrity: sha512-vCPvzSjpPHEi1siZdlvAlsPxXl7WbOVUBBAowWug4rJHb68Ox8KualB+1ocNvT5fjv6wpkX6o/iEpbDrf68zcg==} + engines: {node: '>=12'} + cpu: [arm] + os: [android] - '@babel/plugin-syntax-bigint@7.8.3': - resolution: {integrity: sha512-wnTnFlG+YxQm3vDxpGE57Pj0srRU4sHE/mDkt1qv2YJJSeUAec2ma4WLUnUPeKjyrfntVwe/N6dCXpU+zL3Npg==} - peerDependencies: - '@babel/core': ^7.0.0-0 + '@esbuild/android-x64@0.21.5': + resolution: {integrity: sha512-D7aPRUUNHRBwHxzxRvp856rjUHRFW1SdQATKXH2hqA0kAZb1hKmi02OpYRacl0TxIGz/ZmXWlbZgjwWYaCakTA==} + engines: {node: '>=12'} + cpu: [x64] + os: [android] - '@babel/plugin-syntax-class-properties@7.12.13': - resolution: {integrity: sha512-fm4idjKla0YahUNgFNLCB0qySdsoPiZP3iQE3rky0mBUtMZ23yDJ9SJdg6dXTSDnulOVqiF3Hgr9nbXvXTQZYA==} - peerDependencies: - '@babel/core': ^7.0.0-0 + '@esbuild/darwin-arm64@0.21.5': + resolution: {integrity: sha512-DwqXqZyuk5AiWWf3UfLiRDJ5EDd49zg6O9wclZ7kUMv2WRFr4HKjXp/5t8JZ11QbQfUS6/cRCKGwYhtNAY88kQ==} + engines: {node: '>=12'} + cpu: [arm64] + os: [darwin] - '@babel/plugin-syntax-import-meta@7.10.4': - resolution: {integrity: sha512-Yqfm+XDx0+Prh3VSeEQCPU81yC+JWZ2pDPFSS4ZdpfZhp4MkFMaDC1UqseovEKwSUpnIL7+vK+Clp7bfh0iD7g==} - peerDependencies: - '@babel/core': ^7.0.0-0 + '@esbuild/darwin-x64@0.21.5': + resolution: {integrity: sha512-se/JjF8NlmKVG4kNIuyWMV/22ZaerB+qaSi5MdrXtd6R08kvs2qCN4C09miupktDitvh8jRFflwGFBQcxZRjbw==} + engines: {node: '>=12'} + cpu: [x64] + os: [darwin] - '@babel/plugin-syntax-json-strings@7.8.3': - resolution: {integrity: sha512-lY6kdGpWHvjoe2vk4WrAapEuBR69EMxZl+RoGRhrFGNYVK8mOPAW8VfbT/ZgrFbXlDNiiaxQnAtgVCZ6jv30EA==} - peerDependencies: - '@babel/core': ^7.0.0-0 + '@esbuild/freebsd-arm64@0.21.5': + resolution: {integrity: sha512-5JcRxxRDUJLX8JXp/wcBCy3pENnCgBR9bN6JsY4OmhfUtIHe3ZW0mawA7+RDAcMLrMIZaf03NlQiX9DGyB8h4g==} + engines: {node: '>=12'} + cpu: [arm64] + os: [freebsd] - '@babel/plugin-syntax-jsx@7.24.1': - resolution: {integrity: sha512-2eCtxZXf+kbkMIsXS4poTvT4Yu5rXiRa+9xGVT56raghjmBTKMpFNc9R4IDiB4emao9eO22Ox7CxuJG7BgExqA==} - engines: {node: '>=6.9.0'} - peerDependencies: - '@babel/core': ^7.0.0-0 + '@esbuild/freebsd-x64@0.21.5': + resolution: {integrity: sha512-J95kNBj1zkbMXtHVH29bBriQygMXqoVQOQYA+ISs0/2l3T9/kj42ow2mpqerRBxDJnmkUDCaQT/dfNXWX/ZZCQ==} + engines: {node: '>=12'} + cpu: [x64] + os: [freebsd] - '@babel/plugin-syntax-logical-assignment-operators@7.10.4': - resolution: {integrity: sha512-d8waShlpFDinQ5MtvGU9xDAOzKH47+FFoney2baFIoMr952hKOLp1HR7VszoZvOsV/4+RRszNY7D17ba0te0ig==} - peerDependencies: - '@babel/core': ^7.0.0-0 + '@esbuild/linux-arm64@0.21.5': + resolution: {integrity: sha512-ibKvmyYzKsBeX8d8I7MH/TMfWDXBF3db4qM6sy+7re0YXya+K1cem3on9XgdT2EQGMu4hQyZhan7TeQ8XkGp4Q==} + engines: {node: '>=12'} + cpu: [arm64] + os: [linux] - '@babel/plugin-syntax-nullish-coalescing-operator@7.8.3': - resolution: {integrity: sha512-aSff4zPII1u2QD7y+F8oDsz19ew4IGEJg9SVW+bqwpwtfFleiQDMdzA/R+UlWDzfnHFCxxleFT0PMIrR36XLNQ==} - peerDependencies: - '@babel/core': ^7.0.0-0 + '@esbuild/linux-arm@0.21.5': + resolution: {integrity: sha512-bPb5AHZtbeNGjCKVZ9UGqGwo8EUu4cLq68E95A53KlxAPRmUyYv2D6F0uUI65XisGOL1hBP5mTronbgo+0bFcA==} + engines: {node: '>=12'} + cpu: [arm] + os: [linux] - '@babel/plugin-syntax-numeric-separator@7.10.4': - resolution: {integrity: sha512-9H6YdfkcK/uOnY/K7/aA2xpzaAgkQn37yzWUMRK7OaPOqOpGS1+n0H5hxT9AUw9EsSjPW8SVyMJwYRtWs3X3ug==} - peerDependencies: - '@babel/core': ^7.0.0-0 + '@esbuild/linux-ia32@0.21.5': + resolution: {integrity: sha512-YvjXDqLRqPDl2dvRODYmmhz4rPeVKYvppfGYKSNGdyZkA01046pLWyRKKI3ax8fbJoK5QbxblURkwK/MWY18Tg==} + engines: {node: '>=12'} + cpu: [ia32] + os: [linux] - '@babel/plugin-syntax-object-rest-spread@7.8.3': - resolution: {integrity: sha512-XoqMijGZb9y3y2XskN+P1wUGiVwWZ5JmoDRwx5+3GmEplNyVM2s2Dg8ILFQm8rWM48orGy5YpI5Bl8U1y7ydlA==} - peerDependencies: - '@babel/core': ^7.0.0-0 + '@esbuild/linux-loong64@0.21.5': + resolution: {integrity: sha512-uHf1BmMG8qEvzdrzAqg2SIG/02+4/DHB6a9Kbya0XDvwDEKCoC8ZRWI5JJvNdUjtciBGFQ5PuBlpEOXQj+JQSg==} + engines: {node: '>=12'} + cpu: [loong64] + os: [linux] - '@babel/plugin-syntax-optional-catch-binding@7.8.3': - resolution: {integrity: sha512-6VPD0Pc1lpTqw0aKoeRTMiB+kWhAoT24PA+ksWSBrFtl5SIRVpZlwN3NNPQjehA2E/91FV3RjLWoVTglWcSV3Q==} - peerDependencies: - '@babel/core': ^7.0.0-0 + '@esbuild/linux-mips64el@0.21.5': + resolution: {integrity: sha512-IajOmO+KJK23bj52dFSNCMsz1QP1DqM6cwLUv3W1QwyxkyIWecfafnI555fvSGqEKwjMXVLokcV5ygHW5b3Jbg==} + engines: {node: '>=12'} + cpu: [mips64el] + os: [linux] - '@babel/plugin-syntax-optional-chaining@7.8.3': - resolution: {integrity: sha512-KoK9ErH1MBlCPxV0VANkXW2/dw4vlbGDrFgz8bmUsBGYkFRcbRwMh6cIJubdPrkxRwuGdtCk0v/wPTKbQgBjkg==} - peerDependencies: - '@babel/core': ^7.0.0-0 + '@esbuild/linux-ppc64@0.21.5': + resolution: {integrity: sha512-1hHV/Z4OEfMwpLO8rp7CvlhBDnjsC3CttJXIhBi+5Aj5r+MBvy4egg7wCbe//hSsT+RvDAG7s81tAvpL2XAE4w==} + engines: {node: '>=12'} + cpu: [ppc64] + os: [linux] - '@babel/plugin-syntax-top-level-await@7.14.5': - resolution: {integrity: sha512-hx++upLv5U1rgYfwe1xBQUhRmU41NEvpUvrp8jkrSCdvGSnM5/qdRMtylJ6PG5OFkBaHkbTAKTnd3/YyESRHFw==} - engines: {node: '>=6.9.0'} - peerDependencies: - '@babel/core': ^7.0.0-0 + '@esbuild/linux-riscv64@0.21.5': + resolution: {integrity: sha512-2HdXDMd9GMgTGrPWnJzP2ALSokE/0O5HhTUvWIbD3YdjME8JwvSCnNGBnTThKGEB91OZhzrJ4qIIxk/SBmyDDA==} + engines: {node: '>=12'} + cpu: [riscv64] + os: [linux] - '@babel/plugin-syntax-typescript@7.24.1': - resolution: {integrity: sha512-Yhnmvy5HZEnHUty6i++gcfH1/l68AHnItFHnaCv6hn9dNh0hQvvQJsxpi4BMBFN5DLeHBuucT/0DgzXif/OyRw==} - engines: {node: '>=6.9.0'} - peerDependencies: - '@babel/core': ^7.0.0-0 + '@esbuild/linux-s390x@0.21.5': + resolution: {integrity: sha512-zus5sxzqBJD3eXxwvjN1yQkRepANgxE9lgOW2qLnmr8ikMTphkjgXu1HR01K4FJg8h1kEEDAqDcZQtbrRnB41A==} + engines: {node: '>=12'} + cpu: [s390x] + os: [linux] - '@babel/template@7.24.0': - resolution: {integrity: sha512-Bkf2q8lMB0AFpX0NFEqSbx1OkTHf0f+0j82mkw+ZpzBnkk7e9Ql0891vlfgi+kHwOk8tQjiQHpqh4LaSa0fKEA==} - engines: {node: '>=6.9.0'} + '@esbuild/linux-x64@0.21.5': + resolution: {integrity: sha512-1rYdTpyv03iycF1+BhzrzQJCdOuAOtaqHTWJZCWvijKD2N5Xu0TtVC8/+1faWqcP9iBCWOmjmhoH94dH82BxPQ==} + engines: {node: '>=12'} + cpu: [x64] + os: [linux] - '@babel/traverse@7.24.1': - resolution: {integrity: sha512-xuU6o9m68KeqZbQuDt2TcKSxUw/mrsvavlEqQ1leZ/B+C9tk6E4sRWy97WaXgvq5E+nU3cXMxv3WKOCanVMCmQ==} - engines: {node: '>=6.9.0'} + '@esbuild/netbsd-x64@0.21.5': + resolution: {integrity: sha512-Woi2MXzXjMULccIwMnLciyZH4nCIMpWQAs049KEeMvOcNADVxo0UBIQPfSmxB3CWKedngg7sWZdLvLczpe0tLg==} + engines: {node: '>=12'} + cpu: [x64] + os: [netbsd] - '@babel/types@7.24.0': - resolution: {integrity: sha512-+j7a5c253RfKh8iABBhywc8NSfP5LURe7Uh4qpsh6jc+aLJguvmIUBdjSdEMQv2bENrCR5MfRdjGo7vzS/ob7w==} - engines: {node: '>=6.9.0'} + '@esbuild/openbsd-x64@0.21.5': + resolution: {integrity: sha512-HLNNw99xsvx12lFBUwoT8EVCsSvRNDVxNpjZ7bPn947b8gJPzeHWyNVhFsaerc0n3TsbOINvRP2byTZ5LKezow==} + engines: {node: '>=12'} + cpu: [x64] + os: [openbsd] - '@badrap/result@0.2.13': - resolution: {integrity: sha512-Qvyzz0dmGY0h8pwvBFo1BznAKf5Y5NXIDiqhPALWtfU7oHbAToCtPu4FlYQ3uysskSWLx8GUiyhe0nv0nDd/7Q==} + '@esbuild/sunos-x64@0.21.5': + resolution: {integrity: sha512-6+gjmFpfy0BHU5Tpptkuh8+uw3mnrvgs+dSPQXQOv3ekbordwnzTVEb4qnIvQcYXq6gzkyTnoZ9dZG+D4garKg==} + engines: {node: '>=12'} + cpu: [x64] + os: [sunos] - '@bcoe/v8-coverage@0.2.3': - resolution: {integrity: sha512-0hYQ8SB4Db5zvZB4axdMHGwEaQjkZzFjQiN9LVYvIFB2nSUHW9tYpxWriPrWDASIxiaXax83REcLxuSdnGPZtw==} + '@esbuild/win32-arm64@0.21.5': + resolution: {integrity: sha512-Z0gOTd75VvXqyq7nsl93zwahcTROgqvuAcYDUr+vOv8uHhNSKROyU961kgtCD1e95IqPKSQKH7tBTslnS3tA8A==} + engines: {node: '>=12'} + cpu: [arm64] + os: [win32] - '@blakeembrey/deque@1.0.5': - resolution: {integrity: sha512-6xnwtvp9DY1EINIKdTfvfeAtCYw4OqBZJhtiqkT3ivjnEfa25VQ3TsKvaFfKm8MyGIEfE95qLe+bNEt3nB0Ylg==} + '@esbuild/win32-ia32@0.21.5': + resolution: {integrity: sha512-SWXFF1CL2RVNMaVs+BBClwtfZSvDgtL//G/smwAc5oVK/UPu2Gu9tIaRgFmYFFKrmg3SyAjSrElf0TiJ1v8fYA==} + engines: {node: '>=12'} + cpu: [ia32] + os: [win32] - '@blakeembrey/template@1.1.0': - resolution: {integrity: sha512-iZf+UWfL+DogJVpd/xMQyP6X6McYd6ArdYoPMiv/zlOTzeXXfQbYxBNJJBF6tThvsjLMbA8tLjkCdm9RWMFCCw==} + '@esbuild/win32-x64@0.21.5': + resolution: {integrity: sha512-tQd/1efJuzPC6rCFwEvLtci/xNFcTZknmXs98FYDfGE4wP9ClFV98nyKrzJKVPMhdDnjzLhdUyMX4PsQAPjwIw==} + engines: {node: '>=12'} + cpu: [x64] + os: [win32] '@eslint-community/eslint-utils@4.4.0': resolution: {integrity: sha512-1/sA4dwrzBAyeUoQ6oxahHKmrZvsnLCg4RfxW3ZFGGmQkSNQPFNLV9CUEFQP1x9EYXHTo5p6xdhZM1Ne9p/AfA==} @@ -1003,98 +967,13 @@ packages: '@humanwhocodes/object-schema@2.0.3': resolution: {integrity: sha512-93zYdMES/c1D69yZiKDBj0V24vqNzB/koF26KPaagAfd3P/4gUlh3Dys5ogAK+Exi9QyzlD8x/08Zt7wIKcDcA==} - '@istanbuljs/load-nyc-config@1.1.0': - resolution: {integrity: sha512-VjeHSlIzpv/NyD3N0YuHfXOPDIixcA1q2ZV98wsMqcYlPmv2n3Yb2lYP9XMElnaFVXg5A7YLTeLu6V84uQDjmQ==} - engines: {node: '>=8'} - - '@istanbuljs/schema@0.1.3': - resolution: {integrity: sha512-ZXRY4jNvVgSVQ8DL3LTcakaAtXwTVUxE81hslsyD2AtoXW/wVob10HkOJ1X/pAlcI7D+2YoZKg5do8G/w6RYgA==} - engines: {node: '>=8'} - - '@jest/console@29.7.0': - resolution: {integrity: sha512-5Ni4CU7XHQi32IJ398EEP4RrB8eV09sXP2ROqD4bksHrnTree52PsxvX8tpL8LvTZ3pFzXyPbNQReSN41CAhOg==} - engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} - - '@jest/core@29.7.0': - resolution: {integrity: sha512-n7aeXWKMnGtDA48y8TLWJPJmLmmZ642Ceo78cYWEpiD7FzDgmNDV/GCVRorPABdXLJZ/9wzzgZAlHjXjxDHGsg==} - engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} - peerDependencies: - node-notifier: ^8.0.1 || ^9.0.0 || ^10.0.0 - peerDependenciesMeta: - node-notifier: - optional: true - - '@jest/environment@29.7.0': - resolution: {integrity: sha512-aQIfHDq33ExsN4jP1NWGXhxgQ/wixs60gDiKO+XVMd8Mn0NWPWgc34ZQDTb2jKaUWQ7MuwoitXAsN2XVXNMpAw==} - engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} - - '@jest/expect-utils@29.7.0': - resolution: {integrity: sha512-GlsNBWiFQFCVi9QVSx7f5AgMeLxe9YCCs5PuP2O2LdjDAA8Jh9eX7lA1Jq/xdXw3Wb3hyvlFNfZIfcRetSzYcA==} - engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} - - '@jest/expect@29.7.0': - resolution: {integrity: sha512-8uMeAMycttpva3P1lBHB8VciS9V0XAr3GymPpipdyQXbBcuhkLQOSe8E/p92RyAdToS6ZD1tFkX+CkhoECE0dQ==} - engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} - - '@jest/fake-timers@29.7.0': - resolution: {integrity: sha512-q4DH1Ha4TTFPdxLsqDXK1d3+ioSL7yL5oCMJZgDYm6i+6CygW5E5xVr/D1HdsGxjt1ZWSfUAs9OxSB/BNelWrQ==} - engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} - - '@jest/globals@29.7.0': - resolution: {integrity: sha512-mpiz3dutLbkW2MNFubUGUEVLkTGiqW6yLVTA+JbP6fI6J5iL9Y0Nlg8k95pcF8ctKwCS7WVxteBs29hhfAotzQ==} - engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} - - '@jest/reporters@29.7.0': - resolution: {integrity: sha512-DApq0KJbJOEzAFYjHADNNxAE3KbhxQB1y5Kplb5Waqw6zVbuWatSnMjE5gs8FUgEPmNsnZA3NCWl9NG0ia04Pg==} - engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} - peerDependencies: - node-notifier: ^8.0.1 || ^9.0.0 || ^10.0.0 - peerDependenciesMeta: - node-notifier: - optional: true - '@jest/schemas@29.6.3': resolution: {integrity: sha512-mo5j5X+jIZmJQveBKeS/clAueipV7KgiX1vMgCxam1RNYiqE1w62n0/tJJnHtjW8ZHcQco5gY85jA3mi0L+nSA==} engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} - '@jest/source-map@29.6.3': - resolution: {integrity: sha512-MHjT95QuipcPrpLM+8JMSzFx6eHp5Bm+4XeFDJlwsvVBjmKNiIAvasGK2fxz2WbGRlnvqehFbh07MMa7n3YJnw==} - engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} - - '@jest/test-result@29.7.0': - resolution: {integrity: sha512-Fdx+tv6x1zlkJPcWXmMDAG2HBnaR9XPSd5aDWQVsfrZmLVT3lU1cwyxLgRmXR9yrq4NBoEm9BMsfgFzTQAbJYA==} - engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} - - '@jest/test-sequencer@29.7.0': - resolution: {integrity: sha512-GQwJ5WZVrKnOJuiYiAF52UNUJXgTZx1NHjFSEB0qEMmSZKAkdMoIzw/Cj6x6NF4AvV23AUqDpFzQkN/eYCYTxw==} - engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} - - '@jest/transform@29.7.0': - resolution: {integrity: sha512-ok/BTPFzFKVMwO5eOHRrvnBVHdRy9IrsrW1GpMaQ9MCnilNLXQKmAX8s1YXDFaai9xJpac2ySzV0YeRRECr2Vw==} - engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} - - '@jest/types@29.6.3': - resolution: {integrity: sha512-u3UPsIilWKOM3F9CXtrG8LEJmNxwoCQC/XVj4IKYXvvpx7QIi/Kg1LI5uDmDpKlac62NUtX7eLjRh+jVZcLOzw==} - engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} - - '@jridgewell/gen-mapping@0.3.5': - resolution: {integrity: sha512-IzL8ZoEDIBRWEzlCcRhOaCupYyN5gdIK+Q6fbFdPDg6HqX6jpkItn7DFIpW9LQzXG6Df9sA7+OKnq0qlz/GaQg==} - engines: {node: '>=6.0.0'} - - '@jridgewell/resolve-uri@3.1.2': - resolution: {integrity: sha512-bRISgCIjP20/tbWSPWMEi54QVPRZExkuD9lJL+UIxUKtwVJA8wW1Trb1jMs1RFXo1CBTNZ/5hpC9QvmKWdopKw==} - engines: {node: '>=6.0.0'} - - '@jridgewell/set-array@1.2.1': - resolution: {integrity: sha512-R8gLRTZeyp03ymzP/6Lil/28tGeGEzhx1q2k703KGWRAI1VdvPIXdG70VJc2pAMw3NA6JKL5hhFu1sJX0Mnn/A==} - engines: {node: '>=6.0.0'} - '@jridgewell/sourcemap-codec@1.4.15': resolution: {integrity: sha512-eF2rxCRulEKXHTRiDrDy6erMYWqNw4LPdQ8UQA4huuxaQsVeRPFl2oM8oDGxMFhJUWZf9McpLtJasDDZb/Bpeg==} - '@jridgewell/trace-mapping@0.3.25': - resolution: {integrity: sha512-vNk6aEwybGtawWmy/PzwnGDOjCkLWSD2wqvjGGAgOAwCGWySYXfYoxt00IJkTF+8Lb57DwOb3Aa0o9CApepiYQ==} - '@juggle/resize-observer@3.4.0': resolution: {integrity: sha512-dfLbk+PwWvFzSxwk3n5ySL0hfBog779o8h68wK/7/APo/7cgyWp5jcXockbxdk5kFRkbeXWm4Fbi9FrdN381sA==} @@ -1117,14 +996,88 @@ packages: resolution: {integrity: sha512-oGB+UxlgWcgQkgwo8GcEGwemoTFt3FIO9ababBmaGwXIoBKZ+GTy0pP185beGg7Llih/NSHSV2XAs1lnznocSg==} engines: {node: '>= 8'} - '@sinclair/typebox@0.27.8': - resolution: {integrity: sha512-+Fj43pSMwJs4KRrH/938Uf+uAELIgVBmQzg/q1YG10djyfA3TnrU8N8XzqCh/okZdszqBQTZf96idMfE5lnwTA==} + '@rollup/rollup-android-arm-eabi@4.18.0': + resolution: {integrity: sha512-Tya6xypR10giZV1XzxmH5wr25VcZSncG0pZIjfePT0OVBvqNEurzValetGNarVrGiq66EBVAFn15iYX4w6FKgQ==} + cpu: [arm] + os: [android] + + '@rollup/rollup-android-arm64@4.18.0': + resolution: {integrity: sha512-avCea0RAP03lTsDhEyfy+hpfr85KfyTctMADqHVhLAF3MlIkq83CP8UfAHUssgXTYd+6er6PaAhx/QGv4L1EiA==} + cpu: [arm64] + os: [android] + + '@rollup/rollup-darwin-arm64@4.18.0': + resolution: {integrity: sha512-IWfdwU7KDSm07Ty0PuA/W2JYoZ4iTj3TUQjkVsO/6U+4I1jN5lcR71ZEvRh52sDOERdnNhhHU57UITXz5jC1/w==} + cpu: [arm64] + os: [darwin] + + '@rollup/rollup-darwin-x64@4.18.0': + resolution: {integrity: sha512-n2LMsUz7Ynu7DoQrSQkBf8iNrjOGyPLrdSg802vk6XT3FtsgX6JbE8IHRvposskFm9SNxzkLYGSq9QdpLYpRNA==} + cpu: [x64] + os: [darwin] - '@sinonjs/commons@3.0.1': - resolution: {integrity: sha512-K3mCHKQ9sVh8o1C9cxkwxaOmXoAMlDxC1mYyHrjqOWEcBjYr76t96zL2zlj5dUGZ3HSw240X1qgH3Mjf1yJWpQ==} + '@rollup/rollup-linux-arm-gnueabihf@4.18.0': + resolution: {integrity: sha512-C/zbRYRXFjWvz9Z4haRxcTdnkPt1BtCkz+7RtBSuNmKzMzp3ZxdM28Mpccn6pt28/UWUCTXa+b0Mx1k3g6NOMA==} + cpu: [arm] + os: [linux] + + '@rollup/rollup-linux-arm-musleabihf@4.18.0': + resolution: {integrity: sha512-l3m9ewPgjQSXrUMHg93vt0hYCGnrMOcUpTz6FLtbwljo2HluS4zTXFy2571YQbisTnfTKPZ01u/ukJdQTLGh9A==} + cpu: [arm] + os: [linux] + + '@rollup/rollup-linux-arm64-gnu@4.18.0': + resolution: {integrity: sha512-rJ5D47d8WD7J+7STKdCUAgmQk49xuFrRi9pZkWoRD1UeSMakbcepWXPF8ycChBoAqs1pb2wzvbY6Q33WmN2ftw==} + cpu: [arm64] + os: [linux] + + '@rollup/rollup-linux-arm64-musl@4.18.0': + resolution: {integrity: sha512-be6Yx37b24ZwxQ+wOQXXLZqpq4jTckJhtGlWGZs68TgdKXJgw54lUUoFYrg6Zs/kjzAQwEwYbp8JxZVzZLRepQ==} + cpu: [arm64] + os: [linux] + + '@rollup/rollup-linux-powerpc64le-gnu@4.18.0': + resolution: {integrity: sha512-hNVMQK+qrA9Todu9+wqrXOHxFiD5YmdEi3paj6vP02Kx1hjd2LLYR2eaN7DsEshg09+9uzWi2W18MJDlG0cxJA==} + cpu: [ppc64] + os: [linux] + + '@rollup/rollup-linux-riscv64-gnu@4.18.0': + resolution: {integrity: sha512-ROCM7i+m1NfdrsmvwSzoxp9HFtmKGHEqu5NNDiZWQtXLA8S5HBCkVvKAxJ8U+CVctHwV2Gb5VUaK7UAkzhDjlg==} + cpu: [riscv64] + os: [linux] + + '@rollup/rollup-linux-s390x-gnu@4.18.0': + resolution: {integrity: sha512-0UyyRHyDN42QL+NbqevXIIUnKA47A+45WyasO+y2bGJ1mhQrfrtXUpTxCOrfxCR4esV3/RLYyucGVPiUsO8xjg==} + cpu: [s390x] + os: [linux] + + '@rollup/rollup-linux-x64-gnu@4.18.0': + resolution: {integrity: sha512-xuglR2rBVHA5UsI8h8UbX4VJ470PtGCf5Vpswh7p2ukaqBGFTnsfzxUBetoWBWymHMxbIG0Cmx7Y9qDZzr648w==} + cpu: [x64] + os: [linux] + + '@rollup/rollup-linux-x64-musl@4.18.0': + resolution: {integrity: sha512-LKaqQL9osY/ir2geuLVvRRs+utWUNilzdE90TpyoX0eNqPzWjRm14oMEE+YLve4k/NAqCdPkGYDaDF5Sw+xBfg==} + cpu: [x64] + os: [linux] + + '@rollup/rollup-win32-arm64-msvc@4.18.0': + resolution: {integrity: sha512-7J6TkZQFGo9qBKH0pk2cEVSRhJbL6MtfWxth7Y5YmZs57Pi+4x6c2dStAUvaQkHQLnEQv1jzBUW43GvZW8OFqA==} + cpu: [arm64] + os: [win32] + + '@rollup/rollup-win32-ia32-msvc@4.18.0': + resolution: {integrity: sha512-Txjh+IxBPbkUB9+SXZMpv+b/vnTEtFyfWZgJ6iyCmt2tdx0OF5WhFowLmnh8ENGNpfUlUZkdI//4IEmhwPieNg==} + cpu: [ia32] + os: [win32] + + '@rollup/rollup-win32-x64-msvc@4.18.0': + resolution: {integrity: sha512-UOo5FdvOL0+eIVTgS4tIdbW+TtnBLWg1YBCcU2KWM7nuNwRz9bksDX1bekJJCpu25N1DVWaCwnT39dVQxzqS8g==} + cpu: [x64] + os: [win32] - '@sinonjs/fake-timers@10.3.0': - resolution: {integrity: sha512-V4BG07kuYSUkTCSBHG8G8TNhM+F19jXFWnQtzj+we8DrkpSBCee9Z3Ms8yiGer/dlmhe35/Xdgyo3/0rQKg7YA==} + '@sinclair/typebox@0.27.8': + resolution: {integrity: sha512-+Fj43pSMwJs4KRrH/938Uf+uAELIgVBmQzg/q1YG10djyfA3TnrU8N8XzqCh/okZdszqBQTZf96idMfE5lnwTA==} '@textcomplete/core@0.1.13': resolution: {integrity: sha512-C4S+ihQU5HsKQ/TbsmS0e7hfPZtLZbEXj5NDUgRnhu/1Nezpu892bjNZGeErZm+R8iyDIT6wDu6EgIhng4M8eQ==} @@ -1143,18 +1096,6 @@ packages: '@types/audioworklet@0.0.54': resolution: {integrity: sha512-WR1XcwT2LhCaUiKDDgHdTjrVjoBZnTz6FhszeIKgY9i2UYfIRKtnNvqToUDnbCPXBpVuu4Qo5+mMJt+wDphRew==} - '@types/babel__core@7.20.5': - resolution: {integrity: sha512-qoQprZvz5wQFJwMDqeseRXWv3rqMvhgpbXFfVyWhbx9X47POIA6i/+dXefEmZKoAgOaTdaIgNSMqMIU61yRyzA==} - - '@types/babel__generator@7.6.8': - resolution: {integrity: sha512-ASsj+tpEDsEiFr1arWrlN6V3mdfjRMZt6LtK/Vp/kreFLnr5QH5+DhvD5nINYZXzwJvXeGq+05iUXcAzVrqWtw==} - - '@types/babel__template@7.4.4': - resolution: {integrity: sha512-h/NUaSyG5EyxBIp8YRxo4RMe2/qQgvyowRwVMzhYhBCONbW8PUsg4lkFMrhgZhUe5z3L3MiLDuvyJ/CaPa2A8A==} - - '@types/babel__traverse@7.20.5': - resolution: {integrity: sha512-WXCyOcRtH37HAUkpXhUduaxdm82b4GSlyTqajXviN4EfiuPgNYR109xMCKvpl6zPIpua0DGlMEDCq+g8EdoheQ==} - '@types/chess.js@0.10.1': resolution: {integrity: sha512-cuFMyrUYOWpKm5PRayvk22jLV3BOuWs7iJ7Q4PZJXMWoF7uhjWEojMS4GPk441gn4Ki9BHxbKsll7mrwJ3KT3g==} @@ -1164,24 +1105,12 @@ packages: '@types/dragscroll@0.0.0': resolution: {integrity: sha512-rWr/ryzOUi9r/zUA2GK2qLWGBIBmDeIojBQXuvR76pulHUoEGMJ2A7NWShUaA5AE90ha+l9tlsyGz2UioQE9cg==} + '@types/estree@1.0.5': + resolution: {integrity: sha512-/kYRxGDLWzHOB7q+wtSUQlFrtcdUccpfy+X+9iMBpHK8QLLhx2wIPYuS5DYtR9Wa/YlZAbIovy7qVdB1Aq6Lyw==} + '@types/fnando__sparkline@0.3.7': resolution: {integrity: sha512-irYrS2clNGbnKBBIBAulPH6hDZ/HlBkNsDbYPfO8B2obcxtC9UzKFS5IBSzrUtfKbwf8U01xHj+5iEJ7TtY04Q==} - '@types/graceful-fs@4.1.9': - resolution: {integrity: sha512-olP3sd1qOEe5dXTSaFvQG+02VdRXcdytWLAZsAq1PecU8uqQAhkrnbli7DagjtXKW/Bl7YJbUsa8MPcuc8LHEQ==} - - '@types/istanbul-lib-coverage@2.0.6': - resolution: {integrity: sha512-2QF/t/auWm0lsy8XtKVPG19v3sSOQlJe/YHZgfjb/KBBHOGSV+J2q/S671rcq9uTBrLAXmZpqJiaQbMT+zNU1w==} - - '@types/istanbul-lib-report@3.0.3': - resolution: {integrity: sha512-NQn7AHQnk/RSLOxrBbGyJM/aVQ+pjj5HCgasFxc0K/KhoATfQ/47AyUl15I2yBUpihjmas+a+VJBOqecrFH+uA==} - - '@types/istanbul-reports@3.0.4': - resolution: {integrity: sha512-pk2B1NWalF9toCRu6gjBzR69syFjP4Od8WRAX+0mmf9lAjCRicLOWc+ZrxZHx/0XRjotgkF9t6iaMJ+aXcOdZQ==} - - '@types/jest@29.5.12': - resolution: {integrity: sha512-eDC8bTvT/QhYdxJAulQikueigY5AsdBRH2yDKW3yveW7svY3+DzN84/2NUgkw10RTiJbWqZrTtoGVdYlvFJdLw==} - '@types/json-schema@7.0.15': resolution: {integrity: sha512-5+fP8P8MFNC+AyZCDxrB2pkZFPGzqQWUzpSeuuVLvm8VMcorNYavBqoFcxK8bQz4Qsbn4oUEEem4wDLfcysGHA==} @@ -1203,9 +1132,6 @@ packages: '@types/sortablejs@1.15.8': resolution: {integrity: sha512-b79830lW+RZfwaztgs1aVPgbasJ8e7AXtZYHTELNXZPsERt4ymJdjV4OccDbHQAvHrCcFpbF78jkm0R6h/pZVg==} - '@types/stack-utils@2.0.3': - resolution: {integrity: sha512-9aEbYZ3TbYMznPdcdr3SmIrLXwC/AKZXQeCf9Pgao5CKb8CyHuEX5jzWPTkvregvhRJHcpRO6BFoGW9ycaOkYw==} - '@types/web@0.0.142': resolution: {integrity: sha512-QWDvMW+P3sdq8rhiw3dNyBR64O5adSY80gBjRd2xI3BADGsAFpAglblWucsGUjKVKyPm4EbYZkvFs7BRxPsBOg==} @@ -1215,12 +1141,6 @@ packages: '@types/yaireo__tagify@4.17.5': resolution: {integrity: sha512-nYk4xqky1ZnbgTlP7dO24GA/Kz4Q7mvNGNOsRPygnaVV8kBXIhROFVLG141Y0EF+TZKbmIMUolaJ+Z69Pr9FwQ==} - '@types/yargs-parser@21.0.3': - resolution: {integrity: sha512-I4q9QU9MQv4oEOz4tAHJtNz1cwuLxn2F3xcc2iV5WdqLPpUnj30aUuxt1mAxYTG+oe8CZMV/+6rU4S4gRDzqtQ==} - - '@types/yargs@17.0.32': - resolution: {integrity: sha512-xQ67Yc/laOG5uMfX/093MRlGGCIBzZMarVa+gfNKJxWAIgykYpVGkBdbqEzGDDfCrVUj6Hiff4mTZ5BA6TmAog==} - '@types/zxcvbn@4.4.4': resolution: {integrity: sha512-Tuk4q7q0DnpzyJDI4aMeghGuFu2iS1QAdKpabn8JfbtfGmVDUgvZv1I7mEjP61Bvnp3ljKCC8BE6YYSTNxmvRQ==} @@ -1285,6 +1205,21 @@ packages: '@ungap/structured-clone@1.2.0': resolution: {integrity: sha512-zuVdFrMJiuCDQUMCzQaD6KL28MjnqqN8XnAqiEq9PNm/hCPTSGfrXCOfwj1ow4LFb/tNymJPwsNbVePc1xFqrQ==} + '@vitest/expect@1.6.0': + resolution: {integrity: sha512-ixEvFVQjycy/oNgHjqsL6AZCDduC+tflRluaHIzKIsdbzkLn2U/iBnVeJwB6HsIjQBdfMR8Z0tRxKUsvFJEeWQ==} + + '@vitest/runner@1.6.0': + resolution: {integrity: sha512-P4xgwPjwesuBiHisAVz/LSSZtDjOTPYZVmNAnpHHSR6ONrf8eCJOFRvUwdHn30F5M1fxhqtl7QZQUk2dprIXAg==} + + '@vitest/snapshot@1.6.0': + resolution: {integrity: sha512-+Hx43f8Chus+DCmygqqfetcAZrDJwvTj0ymqjQq4CvmpKFSTVteEOBzCusu1x2tt4OJcvBflyHUE0DZSLgEMtQ==} + + '@vitest/spy@1.6.0': + resolution: {integrity: sha512-leUTap6B/cqi/bQkXUu6bQV5TZPx7pmMBKBQiI0rJA8c3pB56ZsaTbREnF7CJfmvAS4V2cXIBAh/3rVwrrCYgw==} + + '@vitest/utils@1.6.0': + resolution: {integrity: sha512-21cPiuGMoMZwiOHa2i4LXkMkMkCGzA+MVFV70jRwHo95dL4x/ts5GZhML1QWuy7yfp3WzK3lRvZi3JnXTYqrBw==} + '@yaireo/tagify@4.17.9': resolution: {integrity: sha512-x9aZy22hzte7BNmMrFcYNrZH71ombgH5PnzcOVXqPevRV/m/ItSnWIvY5fOHYzpC9Uxy0+h/1P5v62fIvwq2MA==} engines: {node: '>=14.20.0', npm: '>=8.0.0'} @@ -1303,18 +1238,22 @@ packages: peerDependencies: acorn: ^6.0.0 || ^7.0.0 || ^8.0.0 + acorn-walk@8.3.2: + resolution: {integrity: sha512-cjkyv4OtNCIeqhHrfS81QWXoCBPExR/J62oyEqepVw8WaQeSqpW2uhuLPh1m9eWhDuOo/jUXVTlifvesOWp/4A==} + engines: {node: '>=0.4.0'} + acorn@8.11.3: resolution: {integrity: sha512-Y9rRfJG5jcKOE0CLisYbojUjIrIEE7AGMzA/Sm4BslANhbS+cDMpgBdcPT91oJ7OuJ9hYJBx59RjbhxVnrF8Xg==} engines: {node: '>=0.4.0'} hasBin: true + agent-base@7.1.1: + resolution: {integrity: sha512-H0TSyFNDMomMNJQBn8wFV5YC/2eJ+VXECwOadZJT554xP6cODZHPX3H9QMQECxvrgiSOP1pHjy1sMWQVYJOUOA==} + engines: {node: '>= 14'} + ajv@6.12.6: resolution: {integrity: sha512-j3fVLgvTo527anyYyJOGTYJbG+vnnQYvE0m5mmkc1TK+nxAppkCLMIL0aZ4dblVCNoGShhm+kzE4ZUykBoMg4g==} - ansi-escapes@4.3.2: - resolution: {integrity: sha512-gKXj5ALrKWQLsYG9jlTRmR/xKluxHV+Z9QEwNIgCfM1/uwPMCuzVVnh5mwTd+OuBZcwSIMbqssNWRm1lE51QaQ==} - engines: {node: '>=8'} - ansi-escapes@6.2.1: resolution: {integrity: sha512-4nJ3yixlEthEJ9Rk4vPcdBRkZvQZlYyu8j4/Mqz5sgIkddmEnH2Yj2ZrnP9S3tQOvSNRUIgVNF/1yPpRAGNRig==} engines: {node: '>=14.16'} @@ -1327,10 +1266,6 @@ packages: resolution: {integrity: sha512-n5M855fKb2SsfMIiFFoVrABHJC8QtHwVx+mHWP3QcEqBHYienj5dHSgjbxtC0WEZXYt4wcD6zrQElDPhFuZgfA==} engines: {node: '>=12'} - ansi-styles@3.2.1: - resolution: {integrity: sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==} - engines: {node: '>=4'} - ansi-styles@4.3.0: resolution: {integrity: sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==} engines: {node: '>=8'} @@ -1353,9 +1288,6 @@ packages: arg@4.1.3: resolution: {integrity: sha512-58S9QDqG0Xx27YwPSt9fJxivjYl432YCwfDMfZ+71RAqUrZef7LrKQZ3LHLOwCS4FLNBplP533Zx895SeOCHvA==} - argparse@1.0.10: - resolution: {integrity: sha512-o5Roy6tNG4SL/FOkCAN6RzjiakZS25RLYFrcMttJqbdd8BWrnA+fGz57iN5Pb06pvBGvl5gQ0B48dJlslXvoTg==} - argparse@2.0.1: resolution: {integrity: sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q==} @@ -1363,30 +1295,11 @@ packages: resolution: {integrity: sha512-HGyxoOTYUyCM6stUe6EJgnd4EoewAI7zMdfqO+kGjnlZmBDz/cR5pf8r/cR4Wq60sL/p0IkcjUEEPwS3GFrIyw==} engines: {node: '>=8'} - babel-jest@29.7.0: - resolution: {integrity: sha512-BrvGY3xZSwEcCzKvKsCi2GgHqDqsYkOP4/by5xCgIwGXQxIEh+8ew3gmrE1y7XRR6LHZIj6yLYnUi/mm2KXKBg==} - engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} - peerDependencies: - '@babel/core': ^7.8.0 - - babel-plugin-istanbul@6.1.1: - resolution: {integrity: sha512-Y1IQok9821cC9onCx5otgFfRm7Lm+I+wwxOx738M/WLPZ9Q42m4IG5W0FNX8WLL2gYMZo3JkuXIH2DOpWM+qwA==} - engines: {node: '>=8'} - - babel-plugin-jest-hoist@29.6.3: - resolution: {integrity: sha512-ESAc/RJvGTFEzRwOTT4+lNDk/GNHMkKbNzsvT0qKRfDyyYTskxB5rnU2njIDYVxXCBHHEI1c0YwHob3WaYujOg==} - engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} - - babel-preset-current-node-syntax@1.0.1: - resolution: {integrity: sha512-M7LQ0bxarkxQoN+vz5aJPsLBn77n8QgTFmo8WK0/44auK2xlCXrYcUxHFxgU7qW5Yzw/CjmLRK2uJzaCd7LvqQ==} - peerDependencies: - '@babel/core': ^7.0.0 + assertion-error@1.1.0: + resolution: {integrity: sha512-jgsaNduz+ndvGyFt3uSuWqvy4lCnIJiovtouQN5JZHOKCS2QuhEdbcQHFhVksz2N2U9hXJo8odG7ETyWlEeuDw==} - babel-preset-jest@29.6.3: - resolution: {integrity: sha512-0B3bhxR6snWXJZtR/RliHTDPRgn1sNHOR0yVtq/IiQFyuOVjFS+wuio/R4gSNkyYmKmJB4wGZv2NZanmKmTnNA==} - engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} - peerDependencies: - '@babel/core': ^7.0.0 + asynckit@0.4.0: + resolution: {integrity: sha512-Oei9OH4tRh0YqU3GxhX79dM/mwVgvbZJaSNaRk+bshkj0S5cfHcgYakreBjrHwatXKbz+IoIdYLxrKim2MjW0Q==} balanced-match@1.0.2: resolution: {integrity: sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==} @@ -1405,16 +1318,9 @@ packages: resolution: {integrity: sha512-b8um+L1RzM3WDSzvhm6gIz1yfTbBt6YTlcEKAvsmqCZZFw46z626lVj9j1yEPW33H5H+lBQpZMP1k8l+78Ha0A==} engines: {node: '>=8'} - browserslist@4.23.0: - resolution: {integrity: sha512-QW8HiM1shhT2GuzkvklfjcKDiWFXHOeFCIA/huJPwHsslwcydgk7X+z2zXpEijP98UCY7HbubZt5J2Zgvf0CaQ==} - engines: {node: ^6 || ^7 || ^8 || ^9 || ^10 || ^11 || ^12 || >=13.7} - hasBin: true - - bser@2.1.1: - resolution: {integrity: sha512-gQxTNE/GAfIIrmHLUE3oJyp5FO6HRBfhjnw4/wMmA63ZGDJnWBmgY/lyQBpnDUkGmAhbSe39tx2d/iTOAfglwQ==} - - buffer-from@1.1.2: - resolution: {integrity: sha512-E+XQCRwSbaaiChtv6k6Dwgc+bx+Bs6vuKJHHl5kox/BaKbhiXzqQOwK4cO22yElGp2OCmjwVhT3HmxgyPGnJfQ==} + cac@6.7.14: + resolution: {integrity: sha512-b6Ilus+c3RrdDk+JhLKUAQfzzgLEPy6wcXqS7f/xe1EETvsDP6GORG7SFuOs6cID5YkqchW/LXZbX5bc8j7ZcQ==} + engines: {node: '>=8'} callsites@3.1.0: resolution: {integrity: sha512-P8BjAsXvZS+VIDUI11hHCQEv74YT67YUi5JJFNWIqL235sBmjX4+qx9Muvls5ivyNENctx46xQLQ3aTuE7ssaQ==} @@ -1424,15 +1330,8 @@ packages: resolution: {integrity: sha512-L28STB170nwWS63UjtlEOE3dldQApaJXZkOI1uMFfzf3rRuPegHaHesyee+YxQ+W6SvRDQV6UrdOdRiR153wJg==} engines: {node: '>=6'} - camelcase@6.3.0: - resolution: {integrity: sha512-Gmy6FhYlCY7uOElZUSbxo2UCDH8owEk996gkbrpsgGtrJLM3J7jGxl9Ic7Qwwj4ivOE5AWZWRMecDdF7hqGjFA==} - engines: {node: '>=10'} - - caniuse-lite@1.0.30001605: - resolution: {integrity: sha512-nXwGlFWo34uliI9z3n6Qc0wZaf7zaZWA1CPZ169La5mV3I/gem7bst0vr5XQH5TJXZIMfDeZyOrZnSlVzKxxHQ==} - - chalk@2.4.2: - resolution: {integrity: sha512-Mti+f9lpJNcwF4tWV8/OrTTtF1gZi+f8FqlyAdouralcFWFQWF2+NgCHShjkCb+IFBLq9buZwE1xckQU4peSuQ==} + chai@4.4.1: + resolution: {integrity: sha512-13sOfMv2+DWduEU+/xbun3LScLoqN17nBeTLUsmDfKdoiC1fr0n9PU4guu4AhRcOVFk/sW8LyZWHuhWtQZiF+g==} engines: {node: '>=4'} chalk@4.1.2: @@ -1443,10 +1342,6 @@ packages: resolution: {integrity: sha512-dLitG79d+GV1Nb/VYcCDFivJeK1hiukt9QjRNVOsUtTy1rR1YJsmpGGTZ3qJos+uw7WmWF4wUwBd9jxjocFC2w==} engines: {node: ^12.17.0 || ^14.13 || >=16.0.0} - char-regex@1.0.2: - resolution: {integrity: sha512-kWWXztvZ5SBQV+eRgKFeh8q5sLuZY2+8WUIzlxWVTg+oGwY14qylx1KbKzHd8P6ZYkAg0xyIDU9JMHhyJMZ1jw==} - engines: {node: '>=10'} - chart.js@4.4.0: resolution: {integrity: sha512-vQEj6d+z0dcsKLlQvbKIMYFHd3t8W/7L2vfJIbYcfyPcRx92CsHqECpueN8qVGNlKyDcr5wBrYAYKnfu/9Q1hQ==} engines: {pnpm: '>=7'} @@ -1468,6 +1363,9 @@ packages: peerDependencies: chart.js: '>=3.2.0' + check-error@1.0.3: + resolution: {integrity: sha512-iKEoDYaRmd1mxM90a2OEfWhjsjPpYPuQ+lMYsoxB126+t8fw7ySEO48nmDg5COTjxDI65/Y2OWpeEHk3ZOe8zg==} + chess.js@https://codeload.github.com/ornicar/chess.js/tar.gz/ad0709c0b07773d9d0da8e4605a9a2a28f00d249: resolution: {tarball: https://codeload.github.com/ornicar/chess.js/tar.gz/ad0709c0b07773d9d0da8e4605a9a2a28f00d249} version: 0.10.2 @@ -1485,13 +1383,6 @@ packages: resolution: {integrity: sha512-7VT13fmjotKpGipCW9JEQAusEPE+Ei8nl6/g4FBAmIm0GOOLMua9NDDo/DWp0ZAxCr3cPq5ZpBqmPAQgDda2Pw==} engines: {node: '>= 8.10.0'} - ci-info@3.9.0: - resolution: {integrity: sha512-NIxF55hv4nSqQswkAeiOi1r83xy8JldOFDTWiug55KBu9Jnblncd2U6ViHmYgHf01TPZS77NJBhBMKdWj9HQMQ==} - engines: {node: '>=8'} - - cjs-module-lexer@1.2.3: - resolution: {integrity: sha512-0TNiGstbQmCFwt4akjjBg5pLRTSyj/PkWQ1ZoO2zntmg9yLqSRxwEa4iCfQLGjqhiqBfOJa7W/E8wfGrTDmlZQ==} - cli-cursor@4.0.0: resolution: {integrity: sha512-VGtlMu3x/4DOtIUwEkRezxUZ2lBacNJCHash0N0WeZDBS+7Ux1dm3XWAgWYxLJFMMdOeXMHXorshEFhbMSGelg==} engines: {node: ^12.20.0 || ^14.13.1 || >=16.0.0} @@ -1503,33 +1394,20 @@ packages: cliui@6.0.0: resolution: {integrity: sha512-t6wbgtoCXvAzst7QgXxJYqPt0usEfbgQdftEPbLL/cvv6HPE5VgvqCuAIDR0NgU52ds6rFwqrgakNLrHEjCbrQ==} - cliui@8.0.1: - resolution: {integrity: sha512-BSeNnyus75C4//NQ9gQt1/csTXyo/8Sb+afLAkzAptFuMsod9HFokGNudZpi/oQV73hnVK+sR+5PVRMd+Dr7YQ==} - engines: {node: '>=12'} - - co@4.6.0: - resolution: {integrity: sha512-QVb0dM5HvG+uaxitm8wONl7jltx8dqhfU33DcqtOZcLSVIKSDDLDi7+0LbAKiyI8hD9u42m2YxXSkMGWThaecQ==} - engines: {iojs: '>= 1.0.0', node: '>= 0.12.0'} - - collect-v8-coverage@1.0.2: - resolution: {integrity: sha512-lHl4d5/ONEbLlJvaJNtsF/Lz+WvB07u2ycqTYbdrq7UypDXailES4valYb2eWiJFxZlVmpGekfqoxQhzyFdT4Q==} - - color-convert@1.9.3: - resolution: {integrity: sha512-QfAUtd+vFdAtFQcC8CCyYt1fYWxSqAiK2cSD6zDB8N3cpsEBAvRxp9zOGg6G/SHHJYAT88/az/IuDGALsNVbGg==} - color-convert@2.0.1: resolution: {integrity: sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==} engines: {node: '>=7.0.0'} - color-name@1.1.3: - resolution: {integrity: sha512-72fSenhMw2HZMTVHeCA9KCmpEIbzWiQsjN+BHcBbS9vr1mtt+vJjPdksIBNUmKAW8TFUDPJK5SUU3QhE9NEXDw==} - color-name@1.1.4: resolution: {integrity: sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==} colorette@2.0.20: resolution: {integrity: sha512-IfEDxwoWIjkeXL1eXcDiow4UbKjhLdq6/EuSVR9GMN7KVH3r9gQ83e73hsz1Nd1T3ijd5xv1wcWRYO+D6kCI2w==} + combined-stream@1.0.8: + resolution: {integrity: sha512-FQN4MRfuJeHf7cBbBMJFXhKSDq+2kAArBlmRBvcvFE5BB1HZKXtSFASDhdlz9zOYwxh8lDdnvmMOe/+5cdoEdg==} + engines: {node: '>= 0.8'} + commander@11.1.0: resolution: {integrity: sha512-yPVavfyCcRhmorC7rWlkHn15b4wDVgVmBA7kV4QVBsF7kv/9TKJAbAXVTxvTnwP8HHKjRCJDClKbciiYS7p0DQ==} engines: {node: '>=16'} @@ -1537,13 +1415,8 @@ packages: concat-map@0.0.1: resolution: {integrity: sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg==} - convert-source-map@2.0.0: - resolution: {integrity: sha512-Kvp459HrV2FEJ1CAsi1Ku+MY3kasH19TFykTz2xWmMeq6bk2NU3XXvfJ+Q61m0xktWwt+1HSYf3JZsTms3aRJg==} - - create-jest@29.7.0: - resolution: {integrity: sha512-Adz2bdH0Vq3F53KEMJOoftQFutWCukm6J24wbPWRO4k1kMY7gS7ds/uoJkNuV8wDCtWWnuwGcJwpWcih+zEW1Q==} - engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} - hasBin: true + confbox@0.1.7: + resolution: {integrity: sha512-uJcB/FKZtBMCJpK8MQji6bJHgu1tixKPxRLeGkNzBoOZzpnZUJm0jm2/sBDWcuBx1dYgxV4JU+g5hmNxCyAmdA==} cropperjs@1.6.1: resolution: {integrity: sha512-F4wsi+XkDHCOMrHMYjrTEE4QBOrsHHN5/2VsVAaRq8P7E5z7xQpT75S+f/9WikmBEailas3+yo+6zPIomW+NOA==} @@ -1552,9 +1425,17 @@ packages: resolution: {integrity: sha512-iRDPJKUPVEND7dHPO8rkbOnPpyDygcDFtWjpeWNCgy8WP2rXcxXL8TskReQl6OrB2G7+UJrags1q15Fudc7G6w==} engines: {node: '>= 8'} + cssstyle@4.0.1: + resolution: {integrity: sha512-8ZYiJ3A/3OkDd093CBT/0UKDWry7ak4BdPTFP2+QEP7cmhouyq/Up709ASSj2cK02BbZiMgk7kYjZNS4QP5qrQ==} + engines: {node: '>=18'} + csstype@3.1.3: resolution: {integrity: sha512-M1uQkMl8rQK/szD0LNhtqxIPLpimGm8sOBwU7lLnCpSbTyY3yeU1Vc7l4KT5zT4s/yOxHH5O7tIuuLOCnLADRw==} + data-urls@5.0.0: + resolution: {integrity: sha512-ZYP5VBHshaDAiVZxjbRVcFJpc+4xGgT0bK3vzy1HLN8jTO975HEbuYzZJcHoQEY5K1a0z8YayJkyVETa08eNTg==} + engines: {node: '>=18'} + date-fns@2.29.3: resolution: {integrity: sha512-dDCnyH2WnnKusqvZZ6+jA1O51Ibt8ZMRNkDZdyAyK4YfbDwa/cEmuztzG5pk6hqlp9aSBPYcjOlktquahGwGeA==} engines: {node: '>=0.11'} @@ -1578,13 +1459,12 @@ packages: resolution: {integrity: sha512-z2S+W9X73hAUUki+N+9Za2lBlun89zigOyGrsax+KUQ6wKW4ZoWpEYBkGhQjwAjjDCkWxhY0VKEhk8wzY7F5cA==} engines: {node: '>=0.10.0'} - dedent@1.5.1: - resolution: {integrity: sha512-+LxW+KLWxu3HW3M2w2ympwtqPrqYRzU8fqi6Fhd18fBALe15blJPI/I4+UHveMVG6lJqB4JNd4UG0S5cnVHwIg==} - peerDependencies: - babel-plugin-macros: ^3.1.0 - peerDependenciesMeta: - babel-plugin-macros: - optional: true + decimal.js@10.4.3: + resolution: {integrity: sha512-VBBaLc1MgL5XpzgIP7ny5Z6Nx3UrRkIViUkPUdtl9aya5amy3De1gsUUSB1g3+3sExYNjCAsAznmukyxCb1GRA==} + + deep-eql@4.1.4: + resolution: {integrity: sha512-SUwdGfqdKOwxCPeVYjwSyRpJ7Z+fhpwIAtmCUdZIWZ/YP5R9WAsyuSgpLVDi9bjWoN2LXHNss/dk3urXtdQxGg==} + engines: {node: '>=6'} deep-is@0.1.4: resolution: {integrity: sha512-oIPzksmTg4/MriiaYGO+okXDT7ztn/w3Eptv/+gSIdMdKsJo0u4CfYNFJPy+4SKMuCqGw2wxnA+URMg3t8a/bQ==} @@ -1593,9 +1473,9 @@ packages: resolution: {integrity: sha512-3sUqbMEc77XqpdNO7FRyRog+eW3ph+GYCbj+rK+uYyRMuwsVy0rMiVtPn+QJlKFvWP/1PYpapqYn0Me2knFn+A==} engines: {node: '>=0.10.0'} - detect-newline@3.1.0: - resolution: {integrity: sha512-TLz+x/vEXm/Y7P7wn1EJFNLxYpUD4TgMosxY6fAVJUnJMbupHBOncxyWUG9OpTaH9EBD7uFI5LfEgmMOc54DsA==} - engines: {node: '>=8'} + delayed-stream@1.0.0: + resolution: {integrity: sha512-ZySD7Nf91aLB0RxL4KGrKHBXl7Eds1DAmEdcoVawXnLD7SDhpNgtuII2aAkg7a7QS41jxPSZ17p4VdGnMHk3MQ==} + engines: {node: '>=0.4.0'} dialog-polyfill@0.5.6: resolution: {integrity: sha512-ZbVDJI9uvxPAKze6z146rmfUZjBqNEwcnFTVamQzXH+svluiV7swmVIGr7miwADgfgt1G2JQIytypM9fbyhX4w==} @@ -1621,13 +1501,6 @@ packages: dragscroll@0.0.8: resolution: {integrity: sha512-nMrx/KErHpEkiKZlrghcT/nLWCj8vEJgv6s6TF84gmgn6uROPx2wRvClkcnjSEyvppYY9okOI1DIv573Toql1w==} - electron-to-chromium@1.4.723: - resolution: {integrity: sha512-rxFVtrMGMFROr4qqU6n95rUi9IlfIm+lIAt+hOToy/9r6CDv0XiEcQdC3VP71y1pE5CFTzKV0RvxOGYCPWWHPw==} - - emittery@0.13.1: - resolution: {integrity: sha512-DeWwawk6r5yR9jFgnDKYt4sLS0LmHJJi3ZOnb5/JdbYwj3nW+FxQnHIjhBKz8YLC7oRNPVM9NQ47I3CVx34eqQ==} - engines: {node: '>=12'} - emoji-mart@5.5.2: resolution: {integrity: sha512-Sqc/nso4cjxhOwWJsp9xkVm8OF5c+mJLZJFoFfzRuKO+yWiN7K8c96xmtughYb0d/fZ8UC6cLIQ/p4BR6Pv3/A==} @@ -1640,20 +1513,14 @@ packages: encode-utf8@1.0.3: resolution: {integrity: sha512-ucAnuBEhUK4boH2HjVYG5Q2mQyPorvv0u/ocS+zhdw0S8AlHYY+GOFhP1Gio5z4icpP2ivFSvhtFjQi8+T9ppw==} - error-ex@1.3.2: - resolution: {integrity: sha512-7dFHNmqeFSEt2ZBsCriorKnn3Z2pj+fd9kmI6QoWw4//DL+icEBfc0U7qJCisqrTsKTjw4fNFy2pW9OqStD84g==} - - escalade@3.1.2: - resolution: {integrity: sha512-ErCHMCae19vR8vQGe50xIsVomy19rg6gFu3+r3jkEO46suLMWBksvVyoGgQV+jOfl84ZSOSlmv6Gxa89PmTGmA==} - engines: {node: '>=6'} - - escape-string-regexp@1.0.5: - resolution: {integrity: sha512-vbRorB5FUQWvla16U8R/qgaFIya2qGzwDrNmCZuYKrbdSUMG6I1ZCGQRefkRVhuOkIGVne7BQ35DSfo1qvJqFg==} - engines: {node: '>=0.8.0'} + entities@4.5.0: + resolution: {integrity: sha512-V0hjH4dGPh9Ao5p0MoRY6BVqtwCjhz6vI5LT8AJ55H+4g9/4vbHx1I54fS0XuclLhDHArPQCiMjDxjaL8fPxhw==} + engines: {node: '>=0.12'} - escape-string-regexp@2.0.0: - resolution: {integrity: sha512-UpzcLCXolUWcNu5HtVMHYdXJjArjsF9C0aNnquZYY4uW/Vu0miy5YoWvbV345HauVvcAUnpRuhMMcqTcGOY2+w==} - engines: {node: '>=8'} + esbuild@0.21.5: + resolution: {integrity: sha512-mg3OPMV4hXywwpoDxu3Qda5xCKQi+vCTZq8S9J/EpkhB2HzKXq4SNFZE3+NK93JYxc8VMSep+lOUSC/RVKaBqw==} + engines: {node: '>=12'} + hasBin: true escape-string-regexp@4.0.0: resolution: {integrity: sha512-TtpcNJ3XAzx3Gq8sWRzJaVajRs0uVxA2YAkdb1jm2YkPz4G6egUFAyA3n5vtEIZefPk5Wa4UXbKuS5fKkJWdgA==} @@ -1676,11 +1543,6 @@ packages: resolution: {integrity: sha512-oruZaFkjorTpF32kDSI5/75ViwGeZginGGy2NoOSg3Q9bnwlnmDm4HLnkl0RE3n+njDXR037aY1+x58Z/zFdwQ==} engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0} - esprima@4.0.1: - resolution: {integrity: sha512-eGuFFw7Upda+g4p+QHvnW0RyTX/SVeJBDM/gCtMARO0cLuT2HcEKnTPvhjV6aGeqrCB/sbNop0Kszm0jsaWU4A==} - engines: {node: '>=4'} - hasBin: true - esquery@1.5.0: resolution: {integrity: sha512-YQLXUplAwJgCydQ78IMJywZCceoqk1oH01OERdSAJc/7U2AylwjhSCLDEtqwg811idIS/9fIU5GjG73IgjKMVg==} engines: {node: '>=0.10'} @@ -1693,6 +1555,9 @@ packages: resolution: {integrity: sha512-MMdARuVEQziNTeJD8DgMqmhwR11BRQ/cBP+pLtYdSTnf3MIO8fFeiINEbX36ZdNlfU/7A9f3gUw49B3oQsvwBA==} engines: {node: '>=4.0'} + estree-walker@3.0.3: + resolution: {integrity: sha512-7RUKfXgSMMkzt6ZuXmqapOurLGPPfgj6l9uRZ7lRGolvk0y2yocc35LdcxKC5PQZdn2DMqioAQ2NoWcrTKmm6g==} + esutils@2.0.3: resolution: {integrity: sha512-kVscqXk4OCp68SZ0dkgEKVi6/8ij300KBWTJq32P/dYeWTSwK41WyTxalN1eRmA5Z9UU/LX9D7FWSmV9SAYx6g==} engines: {node: '>=0.10.0'} @@ -1703,22 +1568,10 @@ packages: eventemitter3@5.0.1: resolution: {integrity: sha512-GWkBvjiSZK87ELrYOSESUYeVIc9mvLLf/nXalMOS5dYrgZq9o5OVkbZAVM06CVxYsCwH9BDZFPlQTlPA1j4ahA==} - execa@5.1.1: - resolution: {integrity: sha512-8uSpZZocAZRBAPIEINJj3Lo9HyGitllczc27Eh5YYojjMFMn8yHMDMaUHE2Jqfq05D/wucwI4JGURyXt1vchyg==} - engines: {node: '>=10'} - execa@8.0.1: resolution: {integrity: sha512-VyhnebXciFV2DESc+p6B+y0LjSm0krU4OgJN44qFAhBY0TJ+1V61tYD2+wHusZ6F9n5K+vl8k0sTy7PEfV4qpg==} engines: {node: '>=16.17'} - exit@0.1.2: - resolution: {integrity: sha512-Zk/eNKV2zbjpKzrsQ+n1G6poVbErQxJ0LBOJXaKZ1EViLzH+hrLu9cdXI4zw9dBQJslwBEpbQ2P1oS7nDxs6jQ==} - engines: {node: '>= 0.8.0'} - - expect@29.7.0: - resolution: {integrity: sha512-2Zks0hf1VLFYI1kbh0I5jP3KHHyCHpkfyHBzsSXRFgl/Bg9mWYfMW8oD+PdMPlEwy5HNsR9JutYy6pMeOh61nw==} - engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} - fast-deep-equal@3.1.3: resolution: {integrity: sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q==} @@ -1735,9 +1588,6 @@ packages: fastq@1.17.1: resolution: {integrity: sha512-sRVD3lWVIXWg6By68ZN7vho9a1pQcN/WBFaAAsDDFzlJjvoGx0P8z7V1t72grFJfJhu3YPZBuu25f7Kaw2jN1w==} - fb-watchman@2.0.2: - resolution: {integrity: sha512-p5161BqbuCaSnB8jIbzQHOlpgsPmK5rJVDfDKO91Axs5NC1uu3HRQm6wt9cd9/+GtQQIO53JdGXXoyDpTAsgYA==} - file-entry-cache@6.0.1: resolution: {integrity: sha512-7Gps/XWymbLk2QLYK4NzpMOrYjMhdIxXuIvy2QBsLE6ljuodKvdkWs/cpyJJ3CVIVpH0Oi1Hvg1ovbMzLdFBBg==} engines: {node: ^10.12.0 || >=12.0.0} @@ -1764,6 +1614,10 @@ packages: flatted@3.3.1: resolution: {integrity: sha512-X8cqMLLie7KsNUDSdzeN8FYK9rEt4Dt67OsG/DNGnYTSDBG4uFAJFBnUeiV+zCVAvwFy56IjM9sH51jVaEhNxw==} + form-data@4.0.0: + resolution: {integrity: sha512-ETEklSGi5t0QMZuiXoA/Q6vcnxcLQP5vdugSpuAyi6SVGi2clPPp+xgEhuMaHC+zGgn31Kd235W35f7Hykkaww==} + engines: {node: '>= 6'} + fs.realpath@1.0.0: resolution: {integrity: sha512-OO0pH2lK6a0hZnAdau5ItzHPI6pUlvI7jMVnxUQRtw4owF2wk8lOSabtGDCTP4Ggrg2MbGnWO9X8K1t4+fGMDw==} @@ -1772,13 +1626,6 @@ packages: engines: {node: ^8.16.0 || ^10.6.0 || >=11.0.0} os: [darwin] - function-bind@1.1.2: - resolution: {integrity: sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA==} - - gensync@1.0.0-beta.2: - resolution: {integrity: sha512-3hN7NaskYvMDLQY55gnW3NQ+mesEAepTqlg+VEbj7zzqEMBVNhzcGYYeqFo/TlYz6eQiFcp1HcsCZO+nGgS8zg==} - engines: {node: '>=6.9.0'} - get-caller-file@2.0.5: resolution: {integrity: sha512-DyFP3BM/3YHTQOCUL/w0OZHR0lpKeGrxotcHWcqNEdnltqFwXVfhEBQ94eIo34AfQpo0rGki4cyIiftY06h2Fg==} engines: {node: 6.* || 8.* || >= 10.*} @@ -1787,13 +1634,8 @@ packages: resolution: {integrity: sha512-2nk+7SIVb14QrgXFHcm84tD4bKQz0RxPuMT8Ag5KPOq7J5fEmAg0UbXdTOSHqNuHSU28k55qnceesxXRZGzKWA==} engines: {node: '>=18'} - get-package-type@0.1.0: - resolution: {integrity: sha512-pjzuKtY64GYfWizNAJ0fr9VqttZkNiK2iS430LtIHzjBEr6bX8Am2zm4sW4Ro5wjWW5cAlRL1qAMTcXbjNAO2Q==} - engines: {node: '>=8.0.0'} - - get-stream@6.0.1: - resolution: {integrity: sha512-ts6Wi+2j3jQjqi70w5AlN8DFnkSwC+MqmxEzdEALB2qXZYV3X/b1CTfgPLGJNMeAWxdPfU8FO1ms3NUfaHCPYg==} - engines: {node: '>=10'} + get-func-name@2.0.2: + resolution: {integrity: sha512-8vXOvuE167CtIc3OyItco7N/dpRtBbYOsPsXCz7X/PMnlGjYjSGuZJgM1Y7mmew7BKf9BqvLX2tnOVy1BBUsxQ==} get-stream@8.0.1: resolution: {integrity: sha512-VaUJspBffn/LMCJVoMvSAdmscJyS1auj5Zulnn5UoYcY531UWmdwhRWkcGKnGU93m5HSXP9LP2usOryrBtQowA==} @@ -1810,10 +1652,6 @@ packages: glob@7.2.3: resolution: {integrity: sha512-nFR0zLpU2YCaRxwoCJvL6UvCH2JFyFVIvwTLsIf21AuHlMskA1hhTdk+LlYJtOlYt9v6dvszD2BGRqBL+iQK9Q==} - globals@11.12.0: - resolution: {integrity: sha512-WOBp/EEGUiIsJSp7wcv/y6MO+lV9UoncWqxuFfm8eBwzWNgyfBd6Gz+IeKQ9jCmyhoH99g15M3T+QaVHFjizVA==} - engines: {node: '>=4'} - globals@13.24.0: resolution: {integrity: sha512-AhO5QUcj8llrbG09iWhPU2B204J1xnPeL8kQmVorSsy+Sjj1sk8gIyh6cUocGmH4L0UuhAJy+hJMRA4mgA4mFQ==} engines: {node: '>=8'} @@ -1822,9 +1660,6 @@ packages: resolution: {integrity: sha512-jhIXaOzy1sb8IyocaruWSn1TjmnBVs8Ayhcy83rmxNJ8q2uWKCAj3CnJY+KpGSXCueAPc0i05kVvVKtP1t9S3g==} engines: {node: '>=10'} - graceful-fs@4.2.11: - resolution: {integrity: sha512-RbJ5/jmFcNNCcDV5o9eTnBLJ/HszWV0P73bc+Ff4nS/rJj+YaS6IGyiOL0VoBYX+l1Wrl3k63h/KrH+nhJ0XvQ==} - graphemer@1.4.0: resolution: {integrity: sha512-EtKwoO6kxCL9WO5xipiHTZlSzBm7WLT627TqC/uVRd0HKmq8NXyebnNYxDoBi7wt8eTWrUrKXCOVaFq9x1kgag==} @@ -1832,29 +1667,30 @@ packages: resolution: {integrity: sha512-tSQXBXS/MWQOn/RKckawJ61vvsDpCom87JgxiYdGwHdOa0ht0vzUWDlfioofFCRU0L+6NGDt6XzbgoJvZkMeRQ==} engines: {node: '>=0.8.0'} - has-flag@3.0.0: - resolution: {integrity: sha512-sKJf1+ceQBr4SMkvQnBDNDtf4TXpVhVGateu0t918bl30FnbE2m4vNLX+VWe/dpjlb+HugGYzW7uQXH98HPEYw==} - engines: {node: '>=4'} - has-flag@4.0.0: resolution: {integrity: sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==} engines: {node: '>=8'} - hasown@2.0.2: - resolution: {integrity: sha512-0hJU9SCPvmMzIBdZFqNPXWa6dqh7WdH0cII9y+CyS8rG3nL48Bclra9HmKhVVUHyPWNH5Y7xDwAB7bfgSjkUMQ==} - engines: {node: '>= 0.4'} + html-encoding-sniffer@4.0.0: + resolution: {integrity: sha512-Y22oTqIU4uuPgEemfz7NDJz6OeKf12Lsu+QC+s3BVpda64lTiMYCyGwg5ki4vFxkMwQdeZDl2adZoqUgdFuTgQ==} + engines: {node: '>=18'} - html-escaper@2.0.2: - resolution: {integrity: sha512-H2iMtd0I4Mt5eYiapRdIDjp+XzelXQ0tFE4JS7YFwFevXXMmOp9myNrUvCg0D6ws8iqkRPBfKHgbwig1SmlLfg==} + http-proxy-agent@7.0.2: + resolution: {integrity: sha512-T1gkAiYYDWYx3V5Bmyu7HcfcvL7mUrTWiM6yOfa3PIphViJ/gFPbvidQ+veqSOHci/PxBcDabeUNCzpOODJZig==} + engines: {node: '>= 14'} - human-signals@2.1.0: - resolution: {integrity: sha512-B4FFZ6q/T2jhhksgkbEW3HBvWIfDW85snkQgawt07S7J5QXTk6BkNV+0yAeZrM5QpMAdYlocGoljn0sJ/WQkFw==} - engines: {node: '>=10.17.0'} + https-proxy-agent@7.0.4: + resolution: {integrity: sha512-wlwpilI7YdjSkWaQ/7omYBMTliDcmCN8OLihO6I9B86g06lMyAoqgoDpV0XqoaPOKj+0DIdAvnsWfyAAhmimcg==} + engines: {node: '>= 14'} human-signals@5.0.0: resolution: {integrity: sha512-AXcZb6vzzrFAUE61HnN4mpLqd/cSIwNQjtNWR0euPm6y0iqx3G4gOXaIDdtdDwZmhwe82LA6+zinmW4UBWVePQ==} engines: {node: '>=16.17.0'} + iconv-lite@0.6.3: + resolution: {integrity: sha512-4fCk79wshMdzMp2rH06qWrJE4iolqLhCUH+OiuIgU++RB0+94NlDL81atO7GX55uUKueo0txHNtvEyI6D7WdMw==} + engines: {node: '>=0.10.0'} + idb-keyval@6.2.1: resolution: {integrity: sha512-8Sb3veuYCyrZL+VBt9LJfZjLUPWVvqn8tG28VqYNFCo43KHcKuq+b4EiXGeuaLAQWL2YmyDgMp2aSpH9JHsEQg==} @@ -1866,11 +1702,6 @@ packages: resolution: {integrity: sha512-veYYhQa+D1QBKznvhUHxb8faxlrwUnxseDAbAp457E0wLNio2bOSKnjYDhMj+YiAq61xrMGhQk9iXVk5FzgQMw==} engines: {node: '>=6'} - import-local@3.1.0: - resolution: {integrity: sha512-ASB07uLtnDs1o6EHjKpX34BKYDSqnFerfTOJL2HvMqF70LnxpjkzDB8J44oT9pu4AMPkQwf8jl6szgvNd2tRIg==} - engines: {node: '>=8'} - hasBin: true - imurmurhash@0.1.4: resolution: {integrity: sha512-JmXMZ6wuvDmLiHEml9ykzqO6lwFbof0GG4IkcGaENdCRDDmMVnny7s5HsIgHCbaq0w2MyPhDqkhTUgS2LU2PHA==} engines: {node: '>=0.8.19'} @@ -1881,16 +1712,10 @@ packages: inherits@2.0.4: resolution: {integrity: sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==} - is-arrayish@0.2.1: - resolution: {integrity: sha512-zz06S8t0ozoDXMG+ube26zeCTNXcKIPJZJi8hBrF4idCLms4CG9QtK7qBl1boi5ODzFpjswb5JPmHCbMpjaYzg==} - is-binary-path@2.1.0: resolution: {integrity: sha512-ZMERYes6pDydyuGidse7OsHxtbI7WVeUEozgR/g7rd0xUimYNlvZRE/K2MgZTjWy725IfelLeVcEM97mmtRGXw==} engines: {node: '>=8'} - is-core-module@2.13.1: - resolution: {integrity: sha512-hHrIjvZsftOsvKSn2TRYl63zvxsgE0K+0mYMoH6gD4omR5IWB2KynivBQczo3+wF1cCkjzvptnI9Q0sPU66ilw==} - is-extglob@2.1.1: resolution: {integrity: sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ==} engines: {node: '>=0.10.0'} @@ -1907,10 +1732,6 @@ packages: resolution: {integrity: sha512-OVa3u9kkBbw7b8Xw5F9P+D/T9X+Z4+JruYVNapTjPYZYUznQ5YfWeFkOj606XYYW8yugTfC8Pj0hYqvi4ryAhA==} engines: {node: '>=18'} - is-generator-fn@2.1.0: - resolution: {integrity: sha512-cTIB4yPYL/Grw0EaSzASzg6bBy9gqCofvWN8okThAYIxKJZC+udlRAmGbM0XLeniEJSs8uEgHPGuHSe1XsOLSQ==} - engines: {node: '>=6'} - is-glob@4.0.3: resolution: {integrity: sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg==} engines: {node: '>=0.10.0'} @@ -1923,9 +1744,8 @@ packages: resolution: {integrity: sha512-Fd4gABb+ycGAmKou8eMftCupSir5lRxqf4aD/vd0cD2qc4HL07OjCeuHMr8Ro4CoMaeCKDB0/ECBOVWjTwUvPQ==} engines: {node: '>=8'} - is-stream@2.0.1: - resolution: {integrity: sha512-hFoiJiTl63nn+kstHGBtewWSKnQLpyb155KHheA1l39uvtO9nWIop1p3udqPcUd/xbF1VLMO4n7OI6p7RbngDg==} - engines: {node: '>=8'} + is-potential-custom-element-name@1.0.1: + resolution: {integrity: sha512-bCYeRA2rVibKZd+s2625gGnGF/t7DSqDs4dP7CrLA1m7jKWz6pps0LpYLJN8Q64HtmPKJ1hrN3nzPNKFEKOUiQ==} is-stream@3.0.0: resolution: {integrity: sha512-LnQR4bZ9IADDRSkvpqMGvt/tEJWclzklNgSw48V5EAaAeDd6qGvN8ei6k5p0tvxSR171VmGyHuTiAOfxAbr8kA==} @@ -1934,180 +1754,27 @@ packages: isexe@2.0.0: resolution: {integrity: sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw==} - istanbul-lib-coverage@3.2.2: - resolution: {integrity: sha512-O8dpsF+r0WV/8MNRKfnmrtCWhuKjxrq2w+jpzBL5UZKTi2LeVWnWOmWRxFlesJONmc+wLAGvKQZEOanko0LFTg==} - engines: {node: '>=8'} - - istanbul-lib-instrument@5.2.1: - resolution: {integrity: sha512-pzqtp31nLv/XFOzXGuvhCb8qhjmTVo5vjVk19XE4CRlSWz0KoeJ3bw9XsA7nOp9YBf4qHjwBxkDzKcME/J29Yg==} - engines: {node: '>=8'} + js-tokens@4.0.0: + resolution: {integrity: sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ==} - istanbul-lib-instrument@6.0.2: - resolution: {integrity: sha512-1WUsZ9R1lA0HtBSohTkm39WTPlNKSJ5iFk7UwqXkBLoHQT+hfqPsfsTDVuZdKGaBwn7din9bS7SsnoAr943hvw==} - engines: {node: '>=10'} + js-tokens@9.0.0: + resolution: {integrity: sha512-WriZw1luRMlmV3LGJaR6QOJjWwgLUTf89OwT2lUOyjX2dJGBwgmIkbcz+7WFZjrZM635JOIR517++e/67CP9dQ==} - istanbul-lib-report@3.0.1: - resolution: {integrity: sha512-GCfE1mtsHGOELCU8e/Z7YWzpmybrx/+dSTfLrvY8qRmaY6zXTKWn6WQIjaAFw069icm6GVMNkgu0NzI4iPZUNw==} - engines: {node: '>=10'} + js-yaml@4.1.0: + resolution: {integrity: sha512-wpxZs9NoxZaJESJGIZTyDEaYpl0FKSA+FB9aJiyemKhMwkxQg63h4T1KJgUGHpTqPDNRcmmYLugrRjJlBtWvRA==} + hasBin: true - istanbul-lib-source-maps@4.0.1: - resolution: {integrity: sha512-n3s8EwkdFIJCG3BPKBYvskgXGoy88ARzvegkitk60NxRdwltLOTaH7CUiMRXvwYorl0Q712iEjcWB+fK/MrWVw==} - engines: {node: '>=10'} + jsdom@24.1.0: + resolution: {integrity: sha512-6gpM7pRXCwIOKxX47cgOyvyQDN/Eh0f1MeKySBV2xGdKtqJBLj8P25eY3EVCWo2mglDDzozR2r2MW4T+JiNUZA==} + engines: {node: '>=18'} + peerDependencies: + canvas: ^2.11.2 + peerDependenciesMeta: + canvas: + optional: true - istanbul-reports@3.1.7: - resolution: {integrity: sha512-BewmUXImeuRk2YY0PVbxgKAysvhRPUQE0h5QRM++nVWyubKGV0l8qQ5op8+B2DOmwSe63Jivj0BjkPQVf8fP5g==} - engines: {node: '>=8'} - - jest-changed-files@29.7.0: - resolution: {integrity: sha512-fEArFiwf1BpQ+4bXSprcDc3/x4HSzL4al2tozwVpDFpsxALjLYdyiIK4e5Vz66GQJIbXJ82+35PtysofptNX2w==} - engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} - - jest-circus@29.7.0: - resolution: {integrity: sha512-3E1nCMgipcTkCocFwM90XXQab9bS+GMsjdpmPrlelaxwD93Ad8iVEjX/vvHPdLPnFf+L40u+5+iutRdA1N9myw==} - engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} - - jest-cli@29.7.0: - resolution: {integrity: sha512-OVVobw2IubN/GSYsxETi+gOe7Ka59EFMR/twOU3Jb2GnKKeMGJB5SGUUrEz3SFVmJASUdZUzy83sLNNQ2gZslg==} - engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} - hasBin: true - peerDependencies: - node-notifier: ^8.0.1 || ^9.0.0 || ^10.0.0 - peerDependenciesMeta: - node-notifier: - optional: true - - jest-config@29.7.0: - resolution: {integrity: sha512-uXbpfeQ7R6TZBqI3/TxCU4q4ttk3u0PJeC+E0zbfSoSjq6bJ7buBPxzQPL0ifrkY4DNu4JUdk0ImlBUYi840eQ==} - engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} - peerDependencies: - '@types/node': '*' - ts-node: '>=9.0.0' - peerDependenciesMeta: - '@types/node': - optional: true - ts-node: - optional: true - - jest-diff@29.7.0: - resolution: {integrity: sha512-LMIgiIrhigmPrs03JHpxUh2yISK3vLFPkAodPeo0+BuF7wA2FoQbkEg1u8gBYBThncu7e1oEDUfIXVuTqLRUjw==} - engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} - - jest-docblock@29.7.0: - resolution: {integrity: sha512-q617Auw3A612guyaFgsbFeYpNP5t2aoUNLwBUbc/0kD1R4t9ixDbyFTHd1nok4epoVFpr7PmeWHrhvuV3XaJ4g==} - engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} - - jest-each@29.7.0: - resolution: {integrity: sha512-gns+Er14+ZrEoC5fhOfYCY1LOHHr0TI+rQUHZS8Ttw2l7gl+80eHc/gFf2Ktkw0+SIACDTeWvpFcv3B04VembQ==} - engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} - - jest-environment-node@29.7.0: - resolution: {integrity: sha512-DOSwCRqXirTOyheM+4d5YZOrWcdu0LNZ87ewUoywbcb2XR4wKgqiG8vNeYwhjFMbEkfju7wx2GYH0P2gevGvFw==} - engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} - - jest-get-type@29.6.3: - resolution: {integrity: sha512-zrteXnqYxfQh7l5FHyL38jL39di8H8rHoecLH3JNxH3BwOrBsNeabdap5e0I23lD4HHI8W5VFBZqG4Eaq5LNcw==} - engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} - - jest-haste-map@29.7.0: - resolution: {integrity: sha512-fP8u2pyfqx0K1rGn1R9pyE0/KTn+G7PxktWidOBTqFPLYX0b9ksaMFkhK5vrS3DVun09pckLdlx90QthlW7AmA==} - engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} - - jest-leak-detector@29.7.0: - resolution: {integrity: sha512-kYA8IJcSYtST2BY9I+SMC32nDpBT3J2NvWJx8+JCuCdl/CR1I4EKUJROiP8XtCcxqgTTBGJNdbB1A8XRKbTetw==} - engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} - - jest-matcher-utils@29.7.0: - resolution: {integrity: sha512-sBkD+Xi9DtcChsI3L3u0+N0opgPYnCRPtGcQYrgXmR+hmt/fYfWAL0xRXYU8eWOdfuLgBe0YCW3AFtnRLagq/g==} - engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} - - jest-message-util@29.7.0: - resolution: {integrity: sha512-GBEV4GRADeP+qtB2+6u61stea8mGcOT4mCtrYISZwfu9/ISHFJ/5zOMXYbpBE9RsS5+Gb63DW4FgmnKJ79Kf6w==} - engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} - - jest-mock@29.7.0: - resolution: {integrity: sha512-ITOMZn+UkYS4ZFh83xYAOzWStloNzJFO2s8DWrE4lhtGD+AorgnbkiKERe4wQVBydIGPx059g6riW5Btp6Llnw==} - engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} - - jest-pnp-resolver@1.2.3: - resolution: {integrity: sha512-+3NpwQEnRoIBtx4fyhblQDPgJI0H1IEIkX7ShLUjPGA7TtUTvI1oiKi3SR4oBR0hQhQR80l4WAe5RrXBwWMA8w==} - engines: {node: '>=6'} - peerDependencies: - jest-resolve: '*' - peerDependenciesMeta: - jest-resolve: - optional: true - - jest-regex-util@29.6.3: - resolution: {integrity: sha512-KJJBsRCyyLNWCNBOvZyRDnAIfUiRJ8v+hOBQYGn8gDyF3UegwiP4gwRR3/SDa42g1YbVycTidUF3rKjyLFDWbg==} - engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} - - jest-resolve-dependencies@29.7.0: - resolution: {integrity: sha512-un0zD/6qxJ+S0et7WxeI3H5XSe9lTBBR7bOHCHXkKR6luG5mwDDlIzVQ0V5cZCuoTgEdcdwzTghYkTWfubi+nA==} - engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} - - jest-resolve@29.7.0: - resolution: {integrity: sha512-IOVhZSrg+UvVAshDSDtHyFCCBUl/Q3AAJv8iZ6ZjnZ74xzvwuzLXid9IIIPgTnY62SJjfuupMKZsZQRsCvxEgA==} - engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} - - jest-runner@29.7.0: - resolution: {integrity: sha512-fsc4N6cPCAahybGBfTRcq5wFR6fpLznMg47sY5aDpsoejOcVYFb07AHuSnR0liMcPTgBsA3ZJL6kFOjPdoNipQ==} - engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} - - jest-runtime@29.7.0: - resolution: {integrity: sha512-gUnLjgwdGqW7B4LvOIkbKs9WGbn+QLqRQQ9juC6HndeDiezIwhDP+mhMwHWCEcfQ5RUXa6OPnFF8BJh5xegwwQ==} - engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} - - jest-snapshot@29.7.0: - resolution: {integrity: sha512-Rm0BMWtxBcioHr1/OX5YCP8Uov4riHvKPknOGs804Zg9JGZgmIBkbtlxJC/7Z4msKYVbIJtfU+tKb8xlYNfdkw==} - engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} - - jest-util@29.7.0: - resolution: {integrity: sha512-z6EbKajIpqGKU56y5KBUgy1dt1ihhQJgWzUlZHArA/+X2ad7Cb5iF+AK1EWVL/Bo7Rz9uurpqw6SiBCefUbCGA==} - engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} - - jest-validate@29.7.0: - resolution: {integrity: sha512-ZB7wHqaRGVw/9hST/OuFUReG7M8vKeq0/J2egIGLdvjHCmYqGARhzXmtgi+gVeZ5uXFF219aOc3Ls2yLg27tkw==} - engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} - - jest-watcher@29.7.0: - resolution: {integrity: sha512-49Fg7WXkU3Vl2h6LbLtMQ/HyB6rXSIX7SqvBLQmssRBGN9I0PNvPmAmCWSOY6SOvrjhI/F7/bGAv9RtnsPA03g==} - engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} - - jest-worker@29.7.0: - resolution: {integrity: sha512-eIz2msL/EzL9UFTFFx7jBTkeZfku0yUAyZZZmJ93H2TYEiroIx2PQjEXcwYtYl8zXCxb+PAmA2hLIt/6ZEkPHw==} - engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} - - jest@29.7.0: - resolution: {integrity: sha512-NIy3oAFp9shda19hy4HK0HRTWKtPJmGdnvywu01nOqNC2vZg+Z+fvJDxpMQA88eb2I9EcafcdjYgsDthnYTvGw==} - engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} - hasBin: true - peerDependencies: - node-notifier: ^8.0.1 || ^9.0.0 || ^10.0.0 - peerDependenciesMeta: - node-notifier: - optional: true - - js-tokens@4.0.0: - resolution: {integrity: sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ==} - - js-yaml@3.14.1: - resolution: {integrity: sha512-okMH7OXXJ7YrN9Ok3/SXrnu4iX9yOk+25nqX4imS2npuvTYDmo/QEZoqwZkYaIDk3jVvBOTOIEgEhaLOynBS9g==} - hasBin: true - - js-yaml@4.1.0: - resolution: {integrity: sha512-wpxZs9NoxZaJESJGIZTyDEaYpl0FKSA+FB9aJiyemKhMwkxQg63h4T1KJgUGHpTqPDNRcmmYLugrRjJlBtWvRA==} - hasBin: true - - jsesc@2.5.2: - resolution: {integrity: sha512-OYu7XEzjkCQ3C5Ps3QIZsQfNpqoJyZZA99wd9aWd05NCtC5pWOkShK2mkL6HXQR6/Cy2lbNdPlZBpuQHXE63gA==} - engines: {node: '>=4'} - hasBin: true - - json-buffer@3.0.1: - resolution: {integrity: sha512-4bV5BfR2mqfQTJm+V5tPPdf+ZpuhiIvTuAB5g8kcrXOZpTT/QwwVRWBywX1ozr6lEuPdbHxwaJlm9G6mI2sfSQ==} - - json-parse-even-better-errors@2.3.1: - resolution: {integrity: sha512-xyFwyhro/JEof6Ghe2iz2NcXoj2sloNsWr/XsERDK/oiPCfaNhl5ONfp+jQdAZRQQ0IJWNzH9zIZF7li91kh2w==} + json-buffer@3.0.1: + resolution: {integrity: sha512-4bV5BfR2mqfQTJm+V5tPPdf+ZpuhiIvTuAB5g8kcrXOZpTT/QwwVRWBywX1ozr6lEuPdbHxwaJlm9G6mI2sfSQ==} json-schema-traverse@0.4.1: resolution: {integrity: sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg==} @@ -2115,22 +1782,9 @@ packages: json-stable-stringify-without-jsonify@1.0.1: resolution: {integrity: sha512-Bdboy+l7tA3OGW6FjyFHWkP5LuByj1Tk33Ljyq0axyzdk9//JSi2u3fP1QSmd1KNwq6VOKYGlAu87CisVir6Pw==} - json5@2.2.3: - resolution: {integrity: sha512-XmOWe7eyHYH14cLdVPoyg+GOH3rYX++KpzrylJwSW98t3Nk+U8XOl8FWKOgwtzdb8lXGf6zYwDUzeHMWfxasyg==} - engines: {node: '>=6'} - hasBin: true - keyv@4.5.4: resolution: {integrity: sha512-oxVHkHR/EJf2CNXnWxRLW6mg7JyCCUcG0DtEGmL2ctUo1PNTin1PUil+r/+4r5MpVgC/fn1kjsx7mjSujKqIpw==} - kleur@3.0.3: - resolution: {integrity: sha512-eTIzlVOSUR+JxdDFepEYcBMtZ9Qqdef+rnzWdRZuMbOywu5tO2w2N7rqjoANZ5k9vywhL6Br1VRjUIgTQx4E8w==} - engines: {node: '>=6'} - - leven@3.1.0: - resolution: {integrity: sha512-qsda+H8jTaUaN/x5vzW2rzc+8Rw4TAQ/4KjB46IwK5VH+IlVeeeje/EoZRpiXvIqjFgK84QffqPztGI3VBLG1A==} - engines: {node: '>=6'} - levn@0.4.1: resolution: {integrity: sha512-+bT2uH4E5LGE7h/n3evcS/sQlJXCpIp6ym8OWJ5eV6+67Dsql/LaaT7qJBAt2rzfoa/5QBGBhxDix1dMt2kQKQ==} engines: {node: '>= 0.8.0'} @@ -2145,9 +1799,6 @@ packages: resolution: {integrity: sha512-K2U4W2Ff5ibV7j7ydLr+zLAkIg5JJ4lPn1Ltsdt+Tz/IjQ8buJ55pZAxoP34lqIiwtF9iAvtLv3JGv7CAyAg+g==} engines: {node: '>=14'} - lines-and-columns@1.2.4: - resolution: {integrity: sha512-7ylylesZQ/PV29jhEDl3Ufjo6ZX7gCqJr5F7PKrqc93v7fzSymt1BpwEU8nAUXs8qzzvqhbjhK5QZg6Mt/HkBg==} - lint-staged@15.2.2: resolution: {integrity: sha512-TiTt93OPh1OZOsb5B7k96A/ATl2AjIZo+vnzFZ6oHK5FuTk63ByDtxGQpHm+kFETjEWqgkF95M8FRXKR/LEBcw==} engines: {node: '>=18.12.0'} @@ -2157,6 +1808,10 @@ packages: resolution: {integrity: sha512-ovJXBXkKGfq+CwmKTjluEqFi3p4h8xvkxGQQAQan22YCgef4KZ1mKGjzfGh6PL6AW5Csw0QiQPNuQyH+6Xk3hA==} engines: {node: '>=18.0.0'} + local-pkg@0.5.0: + resolution: {integrity: sha512-ok6z3qlYyCDS4ZEU27HaU6x/xZa9Whf8jD4ptH5UZTQYZVYeb9bnZ3ojVhiJNLiXK1Hfc0GNbLXcmZ5plLDDBg==} + engines: {node: '>=14'} + locate-path@5.0.0: resolution: {integrity: sha512-t7hw9pI+WvuwNJXwk5zVHpyhIqzg2qTlklJOf0mVxGSbe3Fp2VieZcduNYjaLDoy6p9uGpQEGWG87WpMKlNq8g==} engines: {node: '>=8'} @@ -2176,19 +1831,15 @@ packages: resolution: {integrity: sha512-lyuxPGr/Wfhrlem2CL/UcnUc1zcqKAImBDzukY7Y5F/yQiNdko6+fRLevlw1HgMySw7f611UIY408EtxRSoK3Q==} hasBin: true - lru-cache@5.1.1: - resolution: {integrity: sha512-KpNARQA3Iwv+jTA0utUVVbrh+Jlrr1Fv0e56GGzAFOXN7dk/FviaDW8LHmK52DlcH4WP2n6gI8vN1aesBFgo9w==} + loupe@2.3.7: + resolution: {integrity: sha512-zSMINGVYkdpYSOBmLi0D1Uo7JU9nVdQKrHxC8eYlV+9YKK9WePqAlL7lSlorG/U2Fw1w0hTBmaa/jrQ3UbPHtA==} lru-cache@6.0.0: resolution: {integrity: sha512-Jo6dJ04CmSjuznwJSS3pUeWmd/H0ffTlkXXgwZi+eq1UCmqQwCh+eLsYOYCwY991i2Fah4h1BEMCx4qThGbsiA==} engines: {node: '>=10'} - make-dir@4.0.0: - resolution: {integrity: sha512-hXdUTZYIVOt1Ex//jAQi+wTZZpUpwBj/0QsOzqegb3rGMMeJiSEu5xLHnYfBrRV4RH2+OCSOO95Is/7x1WJ4bw==} - engines: {node: '>=10'} - - makeerror@1.0.12: - resolution: {integrity: sha512-JmqCvUhmt43madlpFzG4BQzG2Z3m6tvQDNKdClZnO3VbIudJYmxsT0FNJMeiB2+JTSlTQTSbU8QdesVmwJcmLg==} + magic-string@0.30.10: + resolution: {integrity: sha512-iIRwTIf0QKV3UAnYK4PU8uiEc4SRh5jX0mwpIwETPpHdhVM4f53RSwS/vXvN1JhGX+Cs7B8qIq3d6AH49O5fAQ==} merge-stream@2.0.0: resolution: {integrity: sha512-abv/qOcuPfk3URPfDzmZU1LKmuw8kT+0nIHvKrKgFrwifol/doWcdA4ZqsWQ8ENrFKkd67Mfpo/LovbIUsbt3w==} @@ -2201,6 +1852,14 @@ packages: resolution: {integrity: sha512-DMy+ERcEW2q8Z2Po+WNXuw3c5YaUSFjAO5GsJqfEl7UjvtIuFKO6ZrKvcItdy98dwFI2N1tg3zNIdKaQT+aNdA==} engines: {node: '>=8.6'} + mime-db@1.52.0: + resolution: {integrity: sha512-sPU4uV7dYlvtWJxwwxHD0PuihVNiE7TyAbQ5SWxDCB9mUYvOgroQOwYQQOKPJ8CIbE+1ETVlOoK1UC2nU3gYvg==} + engines: {node: '>= 0.6'} + + mime-types@2.1.35: + resolution: {integrity: sha512-ZDY+bPm5zTTF+YpCrAU9nK0UgICYPT0QtT1NZWFv4s++TNkcgVaT0g6+4R2uI4MjQjzysHB1zxuWL50hzaeXiw==} + engines: {node: '>= 0.6'} + mimic-fn@2.1.0: resolution: {integrity: sha512-OqbOk5oEQeAZ8WXWydlu9HJjz9WVdEIvamMCcXmuqUYjTknH/sqsWvhQ3vgwKFRR1HpjvNBKQ37nbJgYzGqGcg==} engines: {node: '>=6'} @@ -2216,18 +1875,20 @@ packages: resolution: {integrity: sha512-RHiac9mvaRw0x3AYRgDC1CxAP7HTcNrrECeA8YYJeWnpo+2Q5CegtZjaotWTWxDG3UeGA1coE05iH1mPjT/2mg==} engines: {node: '>=16 || 14 >=14.17'} + mlly@1.7.1: + resolution: {integrity: sha512-rrVRZRELyQzrIUAVMHxP97kv+G786pHmOKzuFII8zDYahFBS7qnHh2AlYSl1GAHhaMPCz6/oHjVMcfFYgFYHgA==} + ms@2.1.2: resolution: {integrity: sha512-sGkPx+VjMtmA6MX27oA4FBFELFCZZ4S4XqeGOXCv68tT+jb3vk/RyaKWP0PTKyWtmLSM0b+adUTEvbs1PEaH2w==} + nanoid@3.3.7: + resolution: {integrity: sha512-eSRppjcPIatRIMC1U6UngP8XFcz8MQWGQdt1MTBQ7NaAmvXDfvNxbvWV3x2y6CdEUciCSsDHDQZbhYaB8QEo2g==} + engines: {node: ^10 || ^12 || ^13.7 || ^14 || >=15.0.1} + hasBin: true + natural-compare@1.4.0: resolution: {integrity: sha512-OWND8ei3VtNC9h7V60qff3SVobHr996CTwgxubgyQYEpg290h9J0buyECNNJexkFm5sOajh5G116RYA1c8ZMSw==} - node-int64@0.4.0: - resolution: {integrity: sha512-O5lz91xSOeoXP6DulyHfllpq+Eg00MWitZIbtPfoSEvqIHdl5gfcY6hYzDWnj0qD5tz52PI08u9qUvSVeUBeHw==} - - node-releases@2.0.14: - resolution: {integrity: sha512-y10wOWt8yZpqXmOgRo77WaHEmhYQYGNA6y421PKsKYWEK8aW+cqAphborZDhqfyKrbZEN92CN1X2KbafY2s7Yw==} - normalize-path@3.0.0: resolution: {integrity: sha512-6eZs5Ls3WtCisHWp9S2GUy8dqkpGi4BVSz3GaqiE6ezub0512ESztXUwUB6C6IKbQkY2Pnb/mD4WYojCRwcwLA==} engines: {node: '>=0.10.0'} @@ -2235,14 +1896,13 @@ packages: nouislider@15.7.1: resolution: {integrity: sha512-5N7C1ru/i8y3dg9+Z6ilj6+m1EfabvOoaRa7ztpxBSKKRZso4vA52DGSbBJjw5XLtFr/LZ9SgGAXqyVtlVHO5w==} - npm-run-path@4.0.1: - resolution: {integrity: sha512-S48WzZW777zhNIrn7gxOlISNAqi9ZC/uQFnRdbeIHhZhCA6UqpkOT8T1G7BvfdgP4Er8gF4sUbaS0i7QvIfCWw==} - engines: {node: '>=8'} - npm-run-path@5.3.0: resolution: {integrity: sha512-ppwTtiJZq0O/ai0z7yfudtBpWIoxM8yE6nHi1X47eFR2EWORqfbu6CnPlNsjeN683eT0qG6H/Pyf9fCcvjnnnQ==} engines: {node: ^12.20.0 || ^14.13.1 || >=16.0.0} + nwsapi@2.2.10: + resolution: {integrity: sha512-QK0sRs7MKv0tKe1+5uZIQk/C8XGza4DAnztJG8iD+TpJIORARrCxczA738awHrZoHeTjSSoHqao2teO0dC/gFQ==} + object-assign@4.1.1: resolution: {integrity: sha512-rJgTQnkUnH1sFw8yT6VSU3zD3sWmu6sZhIseY8VX+GRu3P6F7Fu+JNDoXfklElbLJSnc3FUQHVe4cU5hj+BcUg==} engines: {node: '>=0.10.0'} @@ -2277,6 +1937,10 @@ packages: resolution: {integrity: sha512-TYOanM3wGwNGsZN2cVTYPArw454xnXj5qmWF1bEoAc4+cU/ol7GVh7odevjp1FNHduHc3KZMcFduxU5Xc6uJRQ==} engines: {node: '>=10'} + p-limit@5.0.0: + resolution: {integrity: sha512-/Eaoq+QyLSiXQ4lyYV23f14mZRQcXnxfHrN0vCai+ak9G0pp9iEQukIIZq5NccEvwRB8PUnZT0KsOoDCINS1qQ==} + engines: {node: '>=18'} + p-locate@4.1.0: resolution: {integrity: sha512-R79ZZ/0wAxKGu3oYMlz8jy/kbhsNrS7SKZ7PxEHBgJ5+F2mtFW2fK2cOtBh1cHYkQsbzFV7I+EoRKe6Yt0oK7A==} engines: {node: '>=8'} @@ -2293,9 +1957,8 @@ packages: resolution: {integrity: sha512-GQ2EWRpQV8/o+Aw8YqtfZZPfNRWZYkbidE9k5rpl/hC3vtHHBfGm2Ifi6qWV+coDGkrUKZAxE3Lot5kcsRlh+g==} engines: {node: '>=6'} - parse-json@5.2.0: - resolution: {integrity: sha512-ayCKvm/phCGxOkYRSCM82iDwct8/EonSEgCSxWxD7ve6jHggsFl4fZVQBPRNgQoKiuV/odhFrGzQXZwbifC8Rg==} - engines: {node: '>=8'} + parse5@7.1.2: + resolution: {integrity: sha512-Czj1WaSVpaoj0wbhMzLmWD69anp2WH7FXMB9n1Sy8/ZFF9jolSQVMu1Ij5WIyGmcBmhk7EOndpO4mIpihVqAXw==} path-exists@4.0.0: resolution: {integrity: sha512-ak9Qy5Q7jYb2Wwcey5Fpvg2KoAc/ZIhLSLOSBmRmygPsGwkVVt0fZa0qrtMz+m6tJTAHfZQ8FnmB4MG4LWy7/w==} @@ -2313,13 +1976,16 @@ packages: resolution: {integrity: sha512-haREypq7xkM7ErfgIyA0z+Bj4AGKlMSdlQE2jvJo6huWD1EdkKYV+G/T4nq0YEF2vgTT8kqMFKo1uHn950r4SQ==} engines: {node: '>=12'} - path-parse@1.0.7: - resolution: {integrity: sha512-LDJzPVEEEPR+y48z93A0Ed0yXb8pAByGWo/k5YYdYgpY2/2EsOsksJrq7lOHxryrVOn1ejG6oAp8ahvOIQD8sw==} - path-type@4.0.0: resolution: {integrity: sha512-gDKb8aZMDeD/tZWs9P6+q0J9Mwkdl6xMV8TjnGP3qJVJ06bdMgkbBlLU8IdfOsIsFz2BW1rNVT3XuNEl8zPAvw==} engines: {node: '>=8'} + pathe@1.1.2: + resolution: {integrity: sha512-whLdWMYL2TwI08hn8/ZqAbrVemu0LNaNNJZX73O6qaIdCTfXutsLhMkjdENX0qhsQ9uIimo4/aQOmXkoon2nDQ==} + + pathval@1.1.1: + resolution: {integrity: sha512-Dp6zGqpTdETdR63lehJYPeIOqpiNBNtc7BpWSLrOje7UaIsE5aY92r/AunQA7rsXvet3lrJ3JnZX29UPTKXyKQ==} + peerjs-js-binarypack@2.1.0: resolution: {integrity: sha512-YIwCC+pTzp3Bi8jPI9UFKO0t0SLo6xALnHkiNt/iUFmUUZG0fEEmEyFKvjsDKweiFitzHRyhuh6NvyJZ4nNxMg==} engines: {node: '>= 14.0.0'} @@ -2340,18 +2006,17 @@ packages: engines: {node: '>=0.10'} hasBin: true - pirates@4.0.6: - resolution: {integrity: sha512-saLsH7WeYYPiD25LDuLRRY/i+6HaPYr6G1OUlN39otzkSTxKnubR9RTxS3/Kk50s1g2JTgFwWQDQyplC5/SHZg==} - engines: {node: '>= 6'} - - pkg-dir@4.2.0: - resolution: {integrity: sha512-HRDzbaKjC+AOWVXxAU/x54COGeIv9eb+6CkDSQoNTt4XyWoIJvuPsXizxu/Fr23EiekbtZwmh1IcIG/l/a10GQ==} - engines: {node: '>=8'} + pkg-types@1.1.1: + resolution: {integrity: sha512-ko14TjmDuQJ14zsotODv7dBlwxKhUKQEhuhmbqo1uCi9BB0Z2alo/wAXg6q1dTR5TyuqYyWhjtfe/Tsh+X28jQ==} pngjs@5.0.0: resolution: {integrity: sha512-40QW5YalBNfQo5yRYmiw7Yz6TKKVr3h6970B2YE+3fQpsWcrbj1PzJgxeJ19DRQjhMbKPIuMY8rFaXc8moolVw==} engines: {node: '>=10.13.0'} + postcss@8.4.38: + resolution: {integrity: sha512-Wglpdk03BSfXkHoQa3b/oulrotAkwrlLDRSOb9D0bN86FdRyE9lppSp33aHNPgBa0JKCoB+drFLZkQoRRYae5A==} + engines: {node: ^10 || ^12 || >=14} + prelude-ls@1.2.1: resolution: {integrity: sha512-vkcDPrRZo1QZLbn5RLGPpg/WmIQ65qoWWhcGKf/b5eplkkarX0m9z8ppCat4mlOqUsWpyNuYgO3VRyrYHSzX5g==} engines: {node: '>= 0.8.0'} @@ -2365,10 +2030,6 @@ packages: resolution: {integrity: sha512-Pdlw/oPxN+aXdmM9R00JVC9WVFoCLTKJvDVLgmJ+qAffBMxsV85l/Lu7sNx4zSzPyoL2euImuEwHhOXdEgNFZQ==} engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} - prompts@2.4.2: - resolution: {integrity: sha512-NxNv/kLguCA7p3jE8oL2aEBsrJWgAakBpgmgK6lpPWV+WuOmY6r2/zbAVnP+T8bQlA0nzHXSJSJW0Hq7ylaD2Q==} - engines: {node: '>= 6'} - prop-types@15.8.1: resolution: {integrity: sha512-oj87CgZICdulUohogVAR7AjlC0327U4el4L6eAvOqCeudMDVU0NThNaV+b9Df4dXgSP1gXMTnPdhfe/2qDH5cg==} @@ -2396,18 +2057,21 @@ packages: prosemirror-view@1.33.3: resolution: {integrity: sha512-P4Ao/bc4OrU/2yLIf8dL4lJaEtjLR3QjIvQHgJYp2jUS7kYM4bSR6okbBjkqzOs/FwUon6UGjTLdKMnPL1MZqw==} + psl@1.9.0: + resolution: {integrity: sha512-E/ZsdU4HLs/68gYzgGTkMicWTLPdAftJLfJFlLUAAKZGkStNU72sZjT66SnMDVOfOWY/YAoiD7Jxa9iHvngcag==} + punycode@2.3.1: resolution: {integrity: sha512-vYt7UD1U9Wg6138shLtLOvdAu+8DsC/ilFtEVHcH+wydcSpNE20AfSOduf6MkRFahL5FY7X1oU7nKVZFtfq8Fg==} engines: {node: '>=6'} - pure-rand@6.1.0: - resolution: {integrity: sha512-bVWawvoZoBYpp6yIoQtQXHZjmz35RSVHnUOTefl8Vcjr8snTPY1wnpSPMWekcFwbxI6gtmT7rSYPFvz71ldiOA==} - qrcode@1.5.3: resolution: {integrity: sha512-puyri6ApkEHYiVl4CFzo1tDkAZ+ATcnbJrJ6RiBM1Fhctdn/ix9MTE3hRph33omisEbC/2fcfemsseiKgBPKZg==} engines: {node: '>=10.13.0'} hasBin: true + querystringify@2.2.0: + resolution: {integrity: sha512-FIqgj2EUvTa7R50u0rGsyTftzjYmv/a3hO345bZNrqabNqjtgiDMgmo4mkUjd+nzU5oF3dClKqFIPUKybUyqoQ==} + queue-microtask@1.2.3: resolution: {integrity: sha512-NuaNSa6flKT5JaSYQzJok04JzTL1CA6aGhv5rfLW3PgqA+M2ChpZQnAC8h8i4ZFkBS8X5RqkDBHA7r4hej3K9A==} @@ -2428,26 +2092,13 @@ packages: require-main-filename@2.0.0: resolution: {integrity: sha512-NKN5kMDylKuldxYLSUfrbo5Tuzh4hd+2E8NPPX02mZtn1VuREQToYe/ZdlJy+J3uCpfaiGF05e7B8W0iXbQHmg==} - resolve-cwd@3.0.0: - resolution: {integrity: sha512-OrZaX2Mb+rJCpH/6CpSqt9xFVpN++x01XnN2ie9g6P5/3xelLAkXWVADpdz1IHD/KFfEXyE6V0U01OQ3UO2rEg==} - engines: {node: '>=8'} + requires-port@1.0.0: + resolution: {integrity: sha512-KigOCHcocU3XODJxsu8i/j8T9tzT4adHiecwORRQ0ZZFcp7ahwXuRU1m+yuO90C5ZUyGeGfocHDI14M3L3yDAQ==} resolve-from@4.0.0: resolution: {integrity: sha512-pb/MYmXstAkysRFx8piNI1tGFNQIFA3vkE3Gq4EuA1dF6gHp/+vgZqsCGJapvy8N3Q+4o7FwvquPJcnZ7RYy4g==} engines: {node: '>=4'} - resolve-from@5.0.0: - resolution: {integrity: sha512-qYg9KP24dD5qka9J47d0aVky0N+b4fTU89LN9iDnjB5waksiC49rvMB0PrUJQGoTmH50XPiqOvAjDfaijGxYZw==} - engines: {node: '>=8'} - - resolve.exports@2.0.2: - resolution: {integrity: sha512-X2UW6Nw3n/aMgDVy+0rSqgHlv39WZAlZrXCdnbyEiKm17DSqHX4MmQMaST3FbeWR5FTuRcUwYAziZajji0Y7mg==} - engines: {node: '>=10'} - - resolve@1.22.8: - resolution: {integrity: sha512-oKWePCxqpd6FlLvGV1VU0x7bkPmmCNolxzjMf4NczoDnQcIWrAF+cPtZn5i6n+RfD2d9i0tzpKnG6Yk168yIyw==} - hasBin: true - restore-cursor@4.0.0: resolution: {integrity: sha512-I9fPXU9geO9bHOt9pHHOhOkYerIMsmVaWB0rA2AI9ERh/+x/i7MV5HKBNrg+ljO5eoPVgCcnFuRjJ9uH6I/3eg==} engines: {node: ^12.20.0 || ^14.13.1 || >=16.0.0} @@ -2463,22 +2114,36 @@ packages: resolution: {integrity: sha512-JZkJMZkAGFFPP2YqXZXPbMlMBgsxzE8ILs4lMIX/2o0L9UBw9O/Y3o6wFw/i9YLapcUJWwqbi3kdxIPdC62TIA==} hasBin: true + rollup@4.18.0: + resolution: {integrity: sha512-QmJz14PX3rzbJCN1SG4Xe/bAAX2a6NpCP8ab2vfu2GiUr8AQcr2nCV/oEO3yneFarB67zk8ShlIyWb2LGTb3Sg==} + engines: {node: '>=18.0.0', npm: '>=8.0.0'} + hasBin: true + rope-sequence@1.3.4: resolution: {integrity: sha512-UT5EDe2cu2E/6O4igUr5PSFs23nvvukicWHx6GnOPlHAiiYbzNuCRQCuiUdHJQcqKalLKlrYJnjY0ySGsXNQXQ==} + rrweb-cssom@0.6.0: + resolution: {integrity: sha512-APM0Gt1KoXBz0iIkkdB/kfvGOwC4UuJFeG/c+yV7wSc7q96cG/kJ0HiYCnzivD9SB53cLV1MlHFNfOuPaadYSw==} + + rrweb-cssom@0.7.1: + resolution: {integrity: sha512-TrEMa7JGdVm0UThDJSx7ddw5nVm3UJS9o9CCIZ72B1vSyEZoziDqBYP3XIoi/12lKrJR8rE3jeFHMok2F/Mnsg==} + run-parallel@1.2.0: resolution: {integrity: sha512-5l4VyZR86LZ/lDxZTR6jqL8AFE2S0IFLMP26AbjsLVADxHdhB/c0GUsH+y39UfCi3dzz8OlQuPmnaJOMoDHQBA==} + safer-buffer@2.1.2: + resolution: {integrity: sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg==} + sax@1.3.0: resolution: {integrity: sha512-0s+oAmw9zLl1V1cS9BtZN7JAd0cW5e0QH4W3LWEK6a4LaLEA2OTpGYWDY+6XasBLtz6wkm3u1xRw95mRuJ59WA==} + saxes@6.0.0: + resolution: {integrity: sha512-xAg7SOnEhrm5zI3puOOKyy1OMcMlIJZYNJY7xLBwSze0UjhPLnWfj2GF2EpT0jmzaJKIWKHLsaSSajf35bcYnA==} + engines: {node: '>=v12.22.7'} + sdp@3.2.0: resolution: {integrity: sha512-d7wDPgDV3DDiqulJjKiV2865wKsJ34YI+NDREbm+FySq6WuKOikwyNQcm+doLAZ1O6ltdO0SeKle2xMpN3Brgw==} - semver@6.3.1: - resolution: {integrity: sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==} - hasBin: true - semver@7.6.0: resolution: {integrity: sha512-EnwXhrlwXMk9gKu5/flx5sv/an57AkRplG3hTK68W7FRDN+k+OWBj65M7719OkA82XLBxrcX0KSHj+X5COhOVg==} engines: {node: '>=10'} @@ -2499,6 +2164,9 @@ packages: resolution: {integrity: sha512-2hbz3N7GuuTjI7y3sfnoqKnH0cNhExx67IJtCTGQI2KhBEyvegsDYW5qjj5BlvvVtQjmL/O/J1GQEciwfoZWpw==} engines: {node: 16.* || >= 18} + siginfo@2.0.0: + resolution: {integrity: sha512-ybx0WO1/8bSBLEWXZvEd7gMW3Sn3JFlW3TvX1nREbDLRNQNaeNN8WK0meBwPdAaOI7TtRRRJn/Es1zhrrCHu7g==} + signal-exit@3.0.7: resolution: {integrity: sha512-wnD2ZE+l+SPC/uoS0vXeE9L1+0wuaMqKlfz9AMUo38JsyLSBWSFcHR1Rri62LZc12vLr1gb3jl7iwQhgwpAbGQ==} @@ -2506,9 +2174,6 @@ packages: resolution: {integrity: sha512-bzyZ1e88w9O1iNJbKnOlvYTrWPDl46O1bG0D3XInv+9tkPrxrN8jUUTiFlDkkmKWgn1M6CfIA13SuGqOa9Korw==} engines: {node: '>=14'} - sisteransi@1.0.5: - resolution: {integrity: sha512-bLGGlR1QxBcynn2d5YmDX4MGjlZvy2MRBDRNHLJ8VI6l6+9FUiyTFNJ0IveOSP0bcXgVDPRcfGqA0pjaqUpfVg==} - slash@3.0.0: resolution: {integrity: sha512-g9Q1haeby36OSStwb4ntCGGGaKsaVSjQ68fBxoQcutl5fS1vuY18H3wSt3jFyFtrkx+Kz0V1G85A4MyAdDMi2Q==} engines: {node: '>=8'} @@ -2528,19 +2193,15 @@ packages: sortablejs@1.15.2: resolution: {integrity: sha512-FJF5jgdfvoKn1MAKSdGs33bIqLi3LmsgVTliuX6iITj834F+JRQZN90Z93yql8h0K2t0RwDPBmxwlbZfDcxNZA==} - source-map-support@0.5.13: - resolution: {integrity: sha512-SHSKFHadjVA5oR4PPqhtAVdcBWwRYVd6g6cAXnIbRiIwc2EhPrTuKUBdSLvlEKyIP3GCf89fltvcZiP9MMFA1w==} - - source-map@0.6.1: - resolution: {integrity: sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==} + source-map-js@1.2.0: + resolution: {integrity: sha512-itJW8lvSA0TXEphiRoawsCksnlf8SyvmFzIhltqAHluXd88pkCd+cXJVHTDwdCr0IzwptSm035IHQktUu1QUMg==} engines: {node: '>=0.10.0'} - sprintf-js@1.0.3: - resolution: {integrity: sha512-D9cPgkvLlV3t3IzL0D0YLvGA9Ahk4PcvVwUbN0dSGr1aP0Nrt4AEnTUbuGvquEC0mA64Gqt1fzirlRs5ibXx8g==} + stackback@0.0.2: + resolution: {integrity: sha512-1XMJE5fQo1jGH6Y/7ebnwPOBEkIEnT4QF32d5R1+VXdXveM0IBMJt8zfaxX1P3QhVwrYe+576+jkANtSS2mBbw==} - stack-utils@2.0.6: - resolution: {integrity: sha512-XlkWvfIm6RmsWtNJx+uqtKLS8eqFbxUg0ZzLXqY0caEy9l7hruX8IpiDnjsLavoBgqCCR71TqWO8MaXYheJ3RQ==} - engines: {node: '>=10'} + std-env@3.7.0: + resolution: {integrity: sha512-JPbdCEQLj1w5GilpiHAx3qJvFndqybBysA3qUOnznweH4QbNYUsW/ea8QzSrnh0vNsezMMw5bcVool8lM0gwzg==} stockfish-mv.wasm@0.6.1: resolution: {integrity: sha512-6QE1LeWbv9NNMABHCjDGyjgob+1CfMpIszxUKCUcCH0znreWPXz48G09rhKTUpRzC8YsOTHPQL/s74gDcqXJGw==} @@ -2558,10 +2219,6 @@ packages: resolution: {integrity: sha512-aqD2Q0144Z+/RqG52NeHEkZauTAUWJO8c6yTftGJKO3Tja5tUgIfmIl6kExvhtxSDP7fXB6DvzkfMpCd/F3G+Q==} engines: {node: '>=0.6.19'} - string-length@4.0.2: - resolution: {integrity: sha512-+l6rNN5fYHNhZZy41RXsYptCjA2Igmq4EG7kZAYFQI1E1VTXarr6ZPXBg6eq7Y6eK4FEhY6AJlyuFIb/v/S0VQ==} - engines: {node: '>=10'} - string-width@4.2.3: resolution: {integrity: sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==} engines: {node: '>=8'} @@ -2578,14 +2235,6 @@ packages: resolution: {integrity: sha512-iq6eVVI64nQQTRYq2KtEg2d2uU7LElhTJwsH4YzIHZshxlgZms/wIc4VoDQTlG/IvVIrBKG06CrZnp0qv7hkcQ==} engines: {node: '>=12'} - strip-bom@4.0.0: - resolution: {integrity: sha512-3xurFv5tEgii33Zi8Jtp55wEIILR9eh34FAW00PZf+JnSsTmV/ioewSgQl97JHvgjoRGwPShsWm+IdrxB35d0w==} - engines: {node: '>=8'} - - strip-final-newline@2.0.0: - resolution: {integrity: sha512-BrpvfNAE3dcvq7ll3xVumzjKjZQ5tI1sEUIKr3Uoks0XUl45St3FlatVqef9prk4jRDzhW6WZg+3bk93y6pLjA==} - engines: {node: '>=6'} - strip-final-newline@3.0.0: resolution: {integrity: sha512-dOESqjYr96iWYylGObzd39EuNTa5VJxyvVAEm5Jnh7KGo75V43Hk1odPQkNDyXNmUR6k+gEiDVXnjB8HJ3crXw==} engines: {node: '>=12'} @@ -2594,22 +2243,13 @@ packages: resolution: {integrity: sha512-6fPc+R4ihwqP6N/aIv2f1gMH8lOVtWQHoqC4yK6oSDVVocumAsfCqjkXnqiYMhmMwS/mEHLp7Vehlt3ql6lEig==} engines: {node: '>=8'} - supports-color@5.5.0: - resolution: {integrity: sha512-QjVjwdXIt408MIiAqCX4oUKsgU2EqAGzs2Ppkm4aQYbjm+ZEWEcW4SfFNTr4uMNZma0ey4f5lgLrkB0aX0QMow==} - engines: {node: '>=4'} + strip-literal@2.1.0: + resolution: {integrity: sha512-Op+UycaUt/8FbN/Z2TWPBLge3jWrP3xj10f3fnYxf052bKuS3EKs1ZQcVGjnEMdsNVAM+plXRdmjrZ/KgG3Skw==} supports-color@7.2.0: resolution: {integrity: sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==} engines: {node: '>=8'} - supports-color@8.1.1: - resolution: {integrity: sha512-MpUEN2OodtUzxvKQl72cUF7RQ5EiHsGvSsVG0ia9c5RbWGL2CI4C7EpPS8UTBIplnlzZiNuV56w+FuNxy3ty2Q==} - engines: {node: '>=10'} - - supports-preserve-symlinks-flag@1.0.0: - resolution: {integrity: sha512-ot0WnXS9fgdkgIcePe6RHNk1WA8+muPa6cSjeR3V8K27q9BB1rTE3R1p7Hv0z1ZyAc8s6Vvv8DIyWf681MAt0w==} - engines: {node: '>= 0.4'} - svg.draggable.js@2.2.2: resolution: {integrity: sha512-JzNHBc2fLQMzYCZ90KZHN2ohXL0BQJGQimK1kGk6AvSeibuKcIdDX9Kr0dT9+UJ5O8nYA0RB839Lhvk4CY4MZw==} engines: {node: '>= 0.8.0'} @@ -2641,30 +2281,41 @@ packages: resolution: {integrity: sha512-h5IS/hKkuVCbKSieR9uQCj9w+zLHoPh+ce19bBYyqF53g6mnPB8sAtIbe1s9dh2S2fCmYX2xel1Ln3PJBbK4kw==} engines: {node: '>= 0.8.0'} + symbol-tree@3.2.4: + resolution: {integrity: sha512-9QNk5KwDF+Bvz+PyObkmSYjI5ksVUYtjW7AU22r2NKcfLJcXp96hkDWU3+XndOsUb+AQ9QhfzfCT2O+CNWT5Tw==} + tablesort@5.3.0: resolution: {integrity: sha512-WkfcZBHsp47gVH9CBHG0ZXopriG01IA87arGrchvIe868d4RiXVvoYPS1zMq9IdW05kBs5iGsqxTABqLyWonbg==} - test-exclude@6.0.0: - resolution: {integrity: sha512-cAGWPIyOHU6zlmg88jwm7VRyXnMN7iV68OGAbYDk/Mh/xC/pzVPlQtY6ngoIH/5/tciuhGfvESU8GrHrcxD56w==} - engines: {node: '>=8'} - text-table@0.2.0: resolution: {integrity: sha512-N+8UisAXDGk8PFXP4HAzVR9nbfmVJ3zYLAWiTIoqC5v5isinhr+r5uaO8+7r3BMfuNIufIsA7RdpVgacC2cSpw==} textarea-caret@3.1.0: resolution: {integrity: sha512-cXAvzO9pP5CGa6NKx0WYHl+8CHKZs8byMkt3PCJBCmq2a34YA9pO1NrQET5pzeqnBjBdToF5No4rrmkDUgQC2Q==} - tmpl@1.0.5: - resolution: {integrity: sha512-3f0uOEAQwIqGuWW2MVzYg8fV/QNnc/IpuJNG837rLuczAaLVHslWHZQj4IGiEl5Hs3kkbhwL9Ab7Hrsmuj+Smw==} + tinybench@2.8.0: + resolution: {integrity: sha512-1/eK7zUnIklz4JUUlL+658n58XO2hHLQfSk1Zf2LKieUjxidN16eKFEoDEfjHc3ohofSSqK3X5yO6VGb6iW8Lw==} - to-fast-properties@2.0.0: - resolution: {integrity: sha512-/OaKK0xYrs3DmxRYqL/yDc+FxFUVYhDlXMhRmv3z915w2HF1tnN1omB354j8VUGO/hbRzyD6Y3sA7v7GS/ceog==} - engines: {node: '>=4'} + tinypool@0.8.4: + resolution: {integrity: sha512-i11VH5gS6IFeLY3gMBQ00/MmLncVP7JLXOw1vlgkytLmJK7QnEr7NXf0LBdxfmNPAeyetukOk0bOYrJrFGjYJQ==} + engines: {node: '>=14.0.0'} + + tinyspy@2.2.1: + resolution: {integrity: sha512-KYad6Vy5VDWV4GH3fjpseMQ/XU2BhIYP7Vzd0LG44qRWm/Yt2WCOTicFdvmgo6gWaqooMQCawTtILVQJupKu7A==} + engines: {node: '>=14.0.0'} to-regex-range@5.0.1: resolution: {integrity: sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ==} engines: {node: '>=8.0'} + tough-cookie@4.1.4: + resolution: {integrity: sha512-Loo5UUvLD9ScZ6jh8beX1T6sO1w2/MpCRpEP7V280GKMVUQ0Jzar2U3UJPsrdbziLEMMhu3Ujnq//rhiFuIeag==} + engines: {node: '>=6'} + + tr46@5.0.0: + resolution: {integrity: sha512-tk2G5R2KRwBd+ZN0zaEXpmzdKyOYksXwywulIX95MBODjSzMIuQnQ3m8JxgbhnL1LeVo7lqQKsYa1O3Htl7K5g==} + engines: {node: '>=18'} + tree-kill@1.2.2: resolution: {integrity: sha512-L0Orpi8qGpRG//Nd+H90vFB+3iHnue1zSSGmNOOCh1GLJ7rUKVwV2HvijphGQS2UmhUZewS9VgvxYIdgr+fG1A==} hasBin: true @@ -2687,10 +2338,6 @@ packages: resolution: {integrity: sha512-Ne+eE4r0/iWnpAxD852z3A+N0Bt5RN//NjJwRd2VFHEmrywxf5vsZlh4R6lixl6B+wz/8d+maTSAkN1FIkI3LQ==} engines: {node: '>=10'} - type-fest@0.21.3: - resolution: {integrity: sha512-t0rzBq87m3fVcduHDUFhKmyyX+9eo6WQjZvf51Ea/M0Q7+T374Jp1aUiyUl0GKxp8M/OETVHSDvmkyPgvX+X2w==} - engines: {node: '>=10'} - types-serviceworker@0.0.1: resolution: {integrity: sha512-EKO/SZ3AsHEZsqv+bsdlTCz5k955riOksnYGlG6JhVwNTVsPWj/TScTbiNVZ5+mmX8TcEXF0C8aSxUw0jTDpIw==} @@ -2699,28 +2346,86 @@ packages: engines: {node: '>=14.17'} hasBin: true + ufo@1.5.3: + resolution: {integrity: sha512-Y7HYmWaFwPUmkoQCUIAYpKqkOf+SbVj/2fJJZ4RJMCfZp0rTGwRbzQD+HghfnhKOjL9E01okqz+ncJskGYfBNw==} + undate@0.3.0: resolution: {integrity: sha512-ssH8QTNBY6B+2fRr3stSQ+9m2NT8qTaun3ExTx5ibzYQvP7yX4+BnX0McNxFCvh6S5ia/DYu6bsCKQx/U4nb/Q==} undici-types@5.26.5: resolution: {integrity: sha512-JlCMO+ehdEIKqlFxk6IfVoAUVmgz7cU7zD/h9XZ0qzeosSHmUJVOzSQvvYSYWXkFXC+IfLKSIffhv0sVZup6pA==} - update-browserslist-db@1.0.13: - resolution: {integrity: sha512-xebP81SNcPuNpPP3uzeW1NYXxI3rxyJzF3pD6sH4jE7o/IX+WtSpwnVU+qIsDPyk0d3hmFQ7mjqc6AtV604hbg==} - hasBin: true - peerDependencies: - browserslist: '>= 4.21.0' + universalify@0.2.0: + resolution: {integrity: sha512-CJ1QgKmNg3CwvAv/kOFmtnEN05f0D/cn9QntgNOQlQF9dgvVTHj3t+8JPdjqawCHk7V/KA+fbUqzZ9XWhcqPUg==} + engines: {node: '>= 4.0.0'} uri-js@4.4.1: resolution: {integrity: sha512-7rKUyy33Q1yc98pQ1DAmLtwX109F7TIfWlW1Ydo8Wl1ii1SeHieeh0HHfPeL2fMXK6z0s8ecKs9frCuLJvndBg==} + url-parse@1.5.10: + resolution: {integrity: sha512-WypcfiRhfeUP9vvF0j6rw0J3hrWrw6iZv3+22h6iRMJ/8z1Tj6XfLP4DsUix5MhMPnXpiHDoKyoZ/bdCkwBCiQ==} + uuid@9.0.0: resolution: {integrity: sha512-MXcSTerfPa4uqyzStbRoTgt5XIe3x5+42+q1sDuy3R5MDk66URdLMOZe5aPX/SQd+kuYAh0FdP/pO28IkQyTeg==} hasBin: true - v8-to-istanbul@9.2.0: - resolution: {integrity: sha512-/EH/sDgxU2eGxajKdwLCDmQ4FWq+kpi3uCmBGpw1xJtnAxEjlD8j8PEiGWpCIMIs3ciNAgH0d3TTJiUkYzyZjA==} - engines: {node: '>=10.12.0'} + vite-node@1.6.0: + resolution: {integrity: sha512-de6HJgzC+TFzOu0NTC4RAIsyf/DY/ibWDYQUcuEA84EMHhcefTUGkjFHKKEJhQN4A+6I0u++kr3l36ZF2d7XRw==} + engines: {node: ^18.0.0 || >=20.0.0} + hasBin: true + + vite@5.3.0: + resolution: {integrity: sha512-hA6vAVK977NyW1Qw+fLvqSo7xDPej7von7C3DwwqPRmnnnK36XEBC/J3j1V5lP8fbt7y0TgTKJbpNGSwM+Bdeg==} + engines: {node: ^18.0.0 || >=20.0.0} + hasBin: true + peerDependencies: + '@types/node': ^18.0.0 || >=20.0.0 + less: '*' + lightningcss: ^1.21.0 + sass: '*' + stylus: '*' + sugarss: '*' + terser: ^5.4.0 + peerDependenciesMeta: + '@types/node': + optional: true + less: + optional: true + lightningcss: + optional: true + sass: + optional: true + stylus: + optional: true + sugarss: + optional: true + terser: + optional: true + + vitest@1.6.0: + resolution: {integrity: sha512-H5r/dN06swuFnzNFhq/dnz37bPXnq8xB2xB5JOVk8K09rUtoeNN+LHWkoQ0A/i3hvbUKKcCei9KpbxqHMLhLLA==} + engines: {node: ^18.0.0 || >=20.0.0} + hasBin: true + peerDependencies: + '@edge-runtime/vm': '*' + '@types/node': ^18.0.0 || >=20.0.0 + '@vitest/browser': 1.6.0 + '@vitest/ui': 1.6.0 + happy-dom: '*' + jsdom: '*' + peerDependenciesMeta: + '@edge-runtime/vm': + optional: true + '@types/node': + optional: true + '@vitest/browser': + optional: true + '@vitest/ui': + optional: true + happy-dom: + optional: true + jsdom: + optional: true vosk-browser@0.0.8: resolution: {integrity: sha512-df9MuChirUGKxP/+4k8tBV6hJOic8IRdJXv64+ET0Ue5CddOzLZINiHOWCka765gBzHJWNtQKgaYakS0FXZIJA==} @@ -2728,13 +2433,30 @@ packages: w3c-keyname@2.2.8: resolution: {integrity: sha512-dpojBhNsCNN7T82Tm7k26A6G9ML3NkhDsnw9n/eoxSRlVBB4CEtIQ/KTCLI2Fwf3ataSXRhYFkQi3SlnFwPvPQ==} - walker@1.0.8: - resolution: {integrity: sha512-ts/8E8l5b7kY0vlWLewOkDXMmPdLcVV4GmOQLyxuSswIJsweeFZtAsMF7k1Nszz+TYBQrlYRmzOnr398y1JemQ==} + w3c-xmlserializer@5.0.0: + resolution: {integrity: sha512-o8qghlI8NZHU1lLPrpi2+Uq7abh4GGPpYANlalzWxyWteJOCsr/P+oPBA49TOLu5FTZO4d3F9MnWJfiMo4BkmA==} + engines: {node: '>=18'} + + webidl-conversions@7.0.0: + resolution: {integrity: sha512-VwddBukDzu71offAQR975unBIGqfKZpM+8ZX6ySk8nYhVoo5CYaZyzt3YBvYtRtO+aoGlqxPg/B87NGVZ/fu6g==} + engines: {node: '>=12'} webrtc-adapter@9.0.1: resolution: {integrity: sha512-1AQO+d4ElfVSXyzNVTOewgGT/tAomwwztX/6e3totvyyzXPvXIIuUUjAmyZGbKBKbZOXauuJooZm3g6IuFuiNQ==} engines: {node: '>=6.0.0', npm: '>=3.10.0'} + whatwg-encoding@3.1.1: + resolution: {integrity: sha512-6qN4hJdMwfYBtE3YBTTHhoeuUrDBPZmbQaxWAqSALV/MeEnR5z1xd8UKud2RAkFoPkmB+hli1TZSnyi84xz1vQ==} + engines: {node: '>=18'} + + whatwg-mimetype@4.0.0: + resolution: {integrity: sha512-QaKxh0eNIi2mE9p2vEdzfagOKHCcj1pJ56EEHGQOVxp8r9/iszLUUV7v89x9O1p/T+NlTM5W7jW6+cz4Fq1YVg==} + engines: {node: '>=18'} + + whatwg-url@14.0.0: + resolution: {integrity: sha512-1lfMEm2IEr7RIV+f4lUNPOqfFL+pO+Xw3fJSqmjX9AbXcXcYOkCe1P6+9VBZB6n94af16NfZf+sSk0JCBZC9aw==} + engines: {node: '>=18'} + which-module@2.0.1: resolution: {integrity: sha512-iBdZ57RDvnOR9AGBhML2vFZf7h8vmBjhoaZqODJBFWHVtKkDmKuHai3cx5PgVMrX5YDNp27AofYbAwctSS+vhQ==} @@ -2743,14 +2465,15 @@ packages: engines: {node: '>= 8'} hasBin: true + why-is-node-running@2.2.2: + resolution: {integrity: sha512-6tSwToZxTOcotxHeA+qGCq1mVzKR3CwcJGmVcY+QE8SHy6TnpFnh8PAvPNHYr7EcuVeG0QSMxtYCuO1ta/G/oA==} + engines: {node: '>=8'} + hasBin: true + wrap-ansi@6.2.0: resolution: {integrity: sha512-r6lPcBGxZXlIcymEu7InxDMhdW0KDxpLgoFLcguasxCaJ/SOIZwINatK9KY/tf+ZrlywOKU0UDj3ATXUBfxJXA==} engines: {node: '>=8'} - wrap-ansi@7.0.0: - resolution: {integrity: sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q==} - engines: {node: '>=10'} - wrap-ansi@9.0.0: resolution: {integrity: sha512-G8ura3S+3Z2G+mkgNRq8dqaFZAuxfsxpBB8OCTGRTCtp+l/v9nbFNmCUP1BZMts3G1142MsZfn6eeUKrr4PD1Q==} engines: {node: '>=18'} @@ -2758,9 +2481,21 @@ packages: wrappy@1.0.2: resolution: {integrity: sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ==} - write-file-atomic@4.0.2: - resolution: {integrity: sha512-7KxauUdBmSdWnmpaGFg+ppNjKF8uNLry8LyzjauQDOVONfFLNKrKvQOxZ/VuTIcS/gge/YNahf5RIIQWTSarlg==} - engines: {node: ^12.13.0 || ^14.15.0 || >=16.0.0} + ws@8.17.0: + resolution: {integrity: sha512-uJq6108EgZMAl20KagGkzCKfMEjxmKvZHG7Tlq0Z6nOky7YF7aq4mOx6xK8TJ/i1LeK4Qus7INktacctDgY8Ow==} + engines: {node: '>=10.0.0'} + peerDependencies: + bufferutil: ^4.0.1 + utf-8-validate: '>=5.0.2' + peerDependenciesMeta: + bufferutil: + optional: true + utf-8-validate: + optional: true + + xml-name-validator@5.0.0: + resolution: {integrity: sha512-EvGK8EJ3DhaHfbRlETOWAS5pO9MZITeauHKJyb8wyajUfQUenkIg2MvLDTZ4T/TgIcm3HU0TFBgWWboAZ30UHg==} + engines: {node: '>=18'} xml2js@0.5.0: resolution: {integrity: sha512-drPFnkQJik/O+uPKpqSgr22mpuFHqKdbS835iAQrUC73L2F5WkboIRd63ai/2Yg6I1jzifPFKH2NTK+cfglkIA==} @@ -2770,16 +2505,12 @@ packages: resolution: {integrity: sha512-fDlsI/kFEx7gLvbecc0/ohLG50fugQp8ryHzMTuW9vSa1GJ0XYWKnhsUx7oie3G98+r56aTQIUB4kht42R3JvA==} engines: {node: '>=4.0'} + xmlchars@2.2.0: + resolution: {integrity: sha512-JZnDKK8B0RCDw84FNdDAIpZK+JuJw+s7Lz8nksI7SIuU3UXJJslUthsi+uWBUYOwPFwW7W7PRLRfUKpxjtjFCw==} + y18n@4.0.3: resolution: {integrity: sha512-JKhqTOwSrqNA1NY5lSztJ1GrBiUodLMmIZuLiDaMRJ+itFd+ABVE8XBjOvIWL+rSqNDC74LCSFmlb/U4UZ4hJQ==} - y18n@5.0.8: - resolution: {integrity: sha512-0pfFzegeDWJHJIAmTLRP2DwHjdF5s7jo9tuztdQxAhINCdvS+3nGINqPd00AphqJR/0LhANUS6/+7SCb98YOfA==} - engines: {node: '>=10'} - - yallist@3.1.1: - resolution: {integrity: sha512-a4UGQaWPH59mOXUYnAG2ewncQS4i4F43Tv3JoAM+s2VDAmS9NsK8GpDMLrCHPksFT7h3K6TOoUNn2pb7RoXx4g==} - yallist@4.0.0: resolution: {integrity: sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A==} @@ -2791,22 +2522,18 @@ packages: resolution: {integrity: sha512-o50j0JeToy/4K6OZcaQmW6lyXXKhq7csREXcDwk2omFPJEwUNOVtJKvmDr9EI1fAJZUyZcRF7kxGBWmRXudrCQ==} engines: {node: '>=6'} - yargs-parser@21.1.1: - resolution: {integrity: sha512-tVpsJW7DdjecAiFpbIB1e3qxIQsE6NoPc5/eTdrbbIC4h0LVsWhnoa3g+m2HclBIujHzsxZ4VJVA+GUuc2/LBw==} - engines: {node: '>=12'} - yargs@15.4.1: resolution: {integrity: sha512-aePbxDmcYW++PaqBsJ+HYUFwCdv4LVvdnhBy78E57PIor8/OVvhMrADFFEDh8DHDFRv/O9i3lPhsENjO7QX0+A==} engines: {node: '>=8'} - yargs@17.7.2: - resolution: {integrity: sha512-7dSzzRQ++CKnNI/krKnYRV7JKKPUXMEh61soaHKg9mrWEhzFWhFnxPxGl+69cD1Ou63C13NUPCnmIcrvqCuM6w==} - engines: {node: '>=12'} - yocto-queue@0.1.0: resolution: {integrity: sha512-rVksvsnNCdJ/ohGc6xgPwyN8eheCxsiLM8mxuE/t/mOVqJewPuO1miLpTHQiRgTKCLexL4MeAFVagts7HmNZ2Q==} engines: {node: '>=10'} + yocto-queue@1.0.0: + resolution: {integrity: sha512-9bnSc/HEW2uRy67wc+T8UwauLuPJVn28jb+GtJY16iiKWyvmYJRXVT4UamsAEGQfPohgr2q4Tq0sQbQlxTfi1g==} + engines: {node: '>=12.20'} + zxcvbn@4.4.2: resolution: {integrity: sha512-Bq0B+ixT/DMyG8kgX2xWcI5jUvCwqrMxSFam7m0lAf78nf04hv6lNCsyLYdyYTrCVMqNDY/206K7eExYCeSyUQ==} @@ -2814,216 +2541,80 @@ snapshots: '@aashutoshrathi/word-wrap@1.2.6': {} - '@ampproject/remapping@2.3.0': - dependencies: - '@jridgewell/gen-mapping': 0.3.5 - '@jridgewell/trace-mapping': 0.3.25 + '@badrap/result@0.2.13': {} - '@babel/code-frame@7.24.2': - dependencies: - '@babel/highlight': 7.24.2 - picocolors: 1.0.0 + '@blakeembrey/deque@1.0.5': {} - '@babel/compat-data@7.24.1': {} - - '@babel/core@7.24.3': - dependencies: - '@ampproject/remapping': 2.3.0 - '@babel/code-frame': 7.24.2 - '@babel/generator': 7.24.1 - '@babel/helper-compilation-targets': 7.23.6 - '@babel/helper-module-transforms': 7.23.3(@babel/core@7.24.3) - '@babel/helpers': 7.24.1 - '@babel/parser': 7.24.1 - '@babel/template': 7.24.0 - '@babel/traverse': 7.24.1 - '@babel/types': 7.24.0 - convert-source-map: 2.0.0 - debug: 4.3.4 - gensync: 1.0.0-beta.2 - json5: 2.2.3 - semver: 6.3.1 - transitivePeerDependencies: - - supports-color + '@blakeembrey/template@1.1.0': {} - '@babel/generator@7.24.1': - dependencies: - '@babel/types': 7.24.0 - '@jridgewell/gen-mapping': 0.3.5 - '@jridgewell/trace-mapping': 0.3.25 - jsesc: 2.5.2 + '@esbuild/aix-ppc64@0.21.5': + optional: true - '@babel/helper-compilation-targets@7.23.6': - dependencies: - '@babel/compat-data': 7.24.1 - '@babel/helper-validator-option': 7.23.5 - browserslist: 4.23.0 - lru-cache: 5.1.1 - semver: 6.3.1 + '@esbuild/android-arm64@0.21.5': + optional: true - '@babel/helper-environment-visitor@7.22.20': {} + '@esbuild/android-arm@0.21.5': + optional: true - '@babel/helper-function-name@7.23.0': - dependencies: - '@babel/template': 7.24.0 - '@babel/types': 7.24.0 + '@esbuild/android-x64@0.21.5': + optional: true - '@babel/helper-hoist-variables@7.22.5': - dependencies: - '@babel/types': 7.24.0 + '@esbuild/darwin-arm64@0.21.5': + optional: true - '@babel/helper-module-imports@7.24.3': - dependencies: - '@babel/types': 7.24.0 + '@esbuild/darwin-x64@0.21.5': + optional: true - '@babel/helper-module-transforms@7.23.3(@babel/core@7.24.3)': - dependencies: - '@babel/core': 7.24.3 - '@babel/helper-environment-visitor': 7.22.20 - '@babel/helper-module-imports': 7.24.3 - '@babel/helper-simple-access': 7.22.5 - '@babel/helper-split-export-declaration': 7.22.6 - '@babel/helper-validator-identifier': 7.22.20 + '@esbuild/freebsd-arm64@0.21.5': + optional: true - '@babel/helper-plugin-utils@7.24.0': {} + '@esbuild/freebsd-x64@0.21.5': + optional: true - '@babel/helper-simple-access@7.22.5': - dependencies: - '@babel/types': 7.24.0 + '@esbuild/linux-arm64@0.21.5': + optional: true - '@babel/helper-split-export-declaration@7.22.6': - dependencies: - '@babel/types': 7.24.0 + '@esbuild/linux-arm@0.21.5': + optional: true - '@babel/helper-string-parser@7.24.1': {} + '@esbuild/linux-ia32@0.21.5': + optional: true - '@babel/helper-validator-identifier@7.22.20': {} + '@esbuild/linux-loong64@0.21.5': + optional: true - '@babel/helper-validator-option@7.23.5': {} + '@esbuild/linux-mips64el@0.21.5': + optional: true - '@babel/helpers@7.24.1': - dependencies: - '@babel/template': 7.24.0 - '@babel/traverse': 7.24.1 - '@babel/types': 7.24.0 - transitivePeerDependencies: - - supports-color + '@esbuild/linux-ppc64@0.21.5': + optional: true - '@babel/highlight@7.24.2': - dependencies: - '@babel/helper-validator-identifier': 7.22.20 - chalk: 2.4.2 - js-tokens: 4.0.0 - picocolors: 1.0.0 + '@esbuild/linux-riscv64@0.21.5': + optional: true - '@babel/parser@7.24.1': - dependencies: - '@babel/types': 7.24.0 - - '@babel/plugin-syntax-async-generators@7.8.4(@babel/core@7.24.3)': - dependencies: - '@babel/core': 7.24.3 - '@babel/helper-plugin-utils': 7.24.0 - - '@babel/plugin-syntax-bigint@7.8.3(@babel/core@7.24.3)': - dependencies: - '@babel/core': 7.24.3 - '@babel/helper-plugin-utils': 7.24.0 - - '@babel/plugin-syntax-class-properties@7.12.13(@babel/core@7.24.3)': - dependencies: - '@babel/core': 7.24.3 - '@babel/helper-plugin-utils': 7.24.0 - - '@babel/plugin-syntax-import-meta@7.10.4(@babel/core@7.24.3)': - dependencies: - '@babel/core': 7.24.3 - '@babel/helper-plugin-utils': 7.24.0 - - '@babel/plugin-syntax-json-strings@7.8.3(@babel/core@7.24.3)': - dependencies: - '@babel/core': 7.24.3 - '@babel/helper-plugin-utils': 7.24.0 - - '@babel/plugin-syntax-jsx@7.24.1(@babel/core@7.24.3)': - dependencies: - '@babel/core': 7.24.3 - '@babel/helper-plugin-utils': 7.24.0 - - '@babel/plugin-syntax-logical-assignment-operators@7.10.4(@babel/core@7.24.3)': - dependencies: - '@babel/core': 7.24.3 - '@babel/helper-plugin-utils': 7.24.0 - - '@babel/plugin-syntax-nullish-coalescing-operator@7.8.3(@babel/core@7.24.3)': - dependencies: - '@babel/core': 7.24.3 - '@babel/helper-plugin-utils': 7.24.0 - - '@babel/plugin-syntax-numeric-separator@7.10.4(@babel/core@7.24.3)': - dependencies: - '@babel/core': 7.24.3 - '@babel/helper-plugin-utils': 7.24.0 - - '@babel/plugin-syntax-object-rest-spread@7.8.3(@babel/core@7.24.3)': - dependencies: - '@babel/core': 7.24.3 - '@babel/helper-plugin-utils': 7.24.0 - - '@babel/plugin-syntax-optional-catch-binding@7.8.3(@babel/core@7.24.3)': - dependencies: - '@babel/core': 7.24.3 - '@babel/helper-plugin-utils': 7.24.0 - - '@babel/plugin-syntax-optional-chaining@7.8.3(@babel/core@7.24.3)': - dependencies: - '@babel/core': 7.24.3 - '@babel/helper-plugin-utils': 7.24.0 - - '@babel/plugin-syntax-top-level-await@7.14.5(@babel/core@7.24.3)': - dependencies: - '@babel/core': 7.24.3 - '@babel/helper-plugin-utils': 7.24.0 - - '@babel/plugin-syntax-typescript@7.24.1(@babel/core@7.24.3)': - dependencies: - '@babel/core': 7.24.3 - '@babel/helper-plugin-utils': 7.24.0 + '@esbuild/linux-s390x@0.21.5': + optional: true - '@babel/template@7.24.0': - dependencies: - '@babel/code-frame': 7.24.2 - '@babel/parser': 7.24.1 - '@babel/types': 7.24.0 + '@esbuild/linux-x64@0.21.5': + optional: true - '@babel/traverse@7.24.1': - dependencies: - '@babel/code-frame': 7.24.2 - '@babel/generator': 7.24.1 - '@babel/helper-environment-visitor': 7.22.20 - '@babel/helper-function-name': 7.23.0 - '@babel/helper-hoist-variables': 7.22.5 - '@babel/helper-split-export-declaration': 7.22.6 - '@babel/parser': 7.24.1 - '@babel/types': 7.24.0 - debug: 4.3.4 - globals: 11.12.0 - transitivePeerDependencies: - - supports-color + '@esbuild/netbsd-x64@0.21.5': + optional: true - '@babel/types@7.24.0': - dependencies: - '@babel/helper-string-parser': 7.24.1 - '@babel/helper-validator-identifier': 7.22.20 - to-fast-properties: 2.0.0 + '@esbuild/openbsd-x64@0.21.5': + optional: true - '@badrap/result@0.2.13': {} + '@esbuild/sunos-x64@0.21.5': + optional: true - '@bcoe/v8-coverage@0.2.3': {} + '@esbuild/win32-arm64@0.21.5': + optional: true - '@blakeembrey/deque@1.0.5': {} + '@esbuild/win32-ia32@0.21.5': + optional: true - '@blakeembrey/template@1.1.0': {} + '@esbuild/win32-x64@0.21.5': + optional: true '@eslint-community/eslint-utils@4.4.0(eslint@8.57.0)': dependencies: @@ -3073,223 +2664,80 @@ snapshots: '@humanwhocodes/object-schema@2.0.3': {} - '@istanbuljs/load-nyc-config@1.1.0': - dependencies: - camelcase: 5.3.1 - find-up: 4.1.0 - get-package-type: 0.1.0 - js-yaml: 3.14.1 - resolve-from: 5.0.0 - - '@istanbuljs/schema@0.1.3': {} - - '@jest/console@29.7.0': - dependencies: - '@jest/types': 29.6.3 - '@types/node': 20.12.2 - chalk: 4.1.2 - jest-message-util: 29.7.0 - jest-util: 29.7.0 - slash: 3.0.0 - - '@jest/core@29.7.0': + '@jest/schemas@29.6.3': dependencies: - '@jest/console': 29.7.0 - '@jest/reporters': 29.7.0 - '@jest/test-result': 29.7.0 - '@jest/transform': 29.7.0 - '@jest/types': 29.6.3 - '@types/node': 20.12.2 - ansi-escapes: 4.3.2 - chalk: 4.1.2 - ci-info: 3.9.0 - exit: 0.1.2 - graceful-fs: 4.2.11 - jest-changed-files: 29.7.0 - jest-config: 29.7.0(@types/node@20.12.2) - jest-haste-map: 29.7.0 - jest-message-util: 29.7.0 - jest-regex-util: 29.6.3 - jest-resolve: 29.7.0 - jest-resolve-dependencies: 29.7.0 - jest-runner: 29.7.0 - jest-runtime: 29.7.0 - jest-snapshot: 29.7.0 - jest-util: 29.7.0 - jest-validate: 29.7.0 - jest-watcher: 29.7.0 - micromatch: 4.0.5 - pretty-format: 29.7.0 - slash: 3.0.0 - strip-ansi: 6.0.1 - transitivePeerDependencies: - - babel-plugin-macros - - supports-color - - ts-node + '@sinclair/typebox': 0.27.8 - '@jest/environment@29.7.0': - dependencies: - '@jest/fake-timers': 29.7.0 - '@jest/types': 29.6.3 - '@types/node': 20.12.2 - jest-mock: 29.7.0 + '@jridgewell/sourcemap-codec@1.4.15': {} - '@jest/expect-utils@29.7.0': - dependencies: - jest-get-type: 29.6.3 + '@juggle/resize-observer@3.4.0': {} - '@jest/expect@29.7.0': - dependencies: - expect: 29.7.0 - jest-snapshot: 29.7.0 - transitivePeerDependencies: - - supports-color + '@kurkle/color@0.3.2': {} - '@jest/fake-timers@29.7.0': - dependencies: - '@jest/types': 29.6.3 - '@sinonjs/fake-timers': 10.3.0 - '@types/node': 20.12.2 - jest-message-util: 29.7.0 - jest-mock: 29.7.0 - jest-util: 29.7.0 + '@msgpack/msgpack@2.8.0': {} - '@jest/globals@29.7.0': + '@nodelib/fs.scandir@2.1.5': dependencies: - '@jest/environment': 29.7.0 - '@jest/expect': 29.7.0 - '@jest/types': 29.6.3 - jest-mock: 29.7.0 - transitivePeerDependencies: - - supports-color + '@nodelib/fs.stat': 2.0.5 + run-parallel: 1.2.0 - '@jest/reporters@29.7.0': - dependencies: - '@bcoe/v8-coverage': 0.2.3 - '@jest/console': 29.7.0 - '@jest/test-result': 29.7.0 - '@jest/transform': 29.7.0 - '@jest/types': 29.6.3 - '@jridgewell/trace-mapping': 0.3.25 - '@types/node': 20.12.2 - chalk: 4.1.2 - collect-v8-coverage: 1.0.2 - exit: 0.1.2 - glob: 7.2.3 - graceful-fs: 4.2.11 - istanbul-lib-coverage: 3.2.2 - istanbul-lib-instrument: 6.0.2 - istanbul-lib-report: 3.0.1 - istanbul-lib-source-maps: 4.0.1 - istanbul-reports: 3.1.7 - jest-message-util: 29.7.0 - jest-util: 29.7.0 - jest-worker: 29.7.0 - slash: 3.0.0 - string-length: 4.0.2 - strip-ansi: 6.0.1 - v8-to-istanbul: 9.2.0 - transitivePeerDependencies: - - supports-color + '@nodelib/fs.stat@2.0.5': {} - '@jest/schemas@29.6.3': + '@nodelib/fs.walk@1.2.8': dependencies: - '@sinclair/typebox': 0.27.8 + '@nodelib/fs.scandir': 2.1.5 + fastq: 1.17.1 - '@jest/source-map@29.6.3': - dependencies: - '@jridgewell/trace-mapping': 0.3.25 - callsites: 3.1.0 - graceful-fs: 4.2.11 + '@rollup/rollup-android-arm-eabi@4.18.0': + optional: true - '@jest/test-result@29.7.0': - dependencies: - '@jest/console': 29.7.0 - '@jest/types': 29.6.3 - '@types/istanbul-lib-coverage': 2.0.6 - collect-v8-coverage: 1.0.2 + '@rollup/rollup-android-arm64@4.18.0': + optional: true - '@jest/test-sequencer@29.7.0': - dependencies: - '@jest/test-result': 29.7.0 - graceful-fs: 4.2.11 - jest-haste-map: 29.7.0 - slash: 3.0.0 + '@rollup/rollup-darwin-arm64@4.18.0': + optional: true - '@jest/transform@29.7.0': - dependencies: - '@babel/core': 7.24.3 - '@jest/types': 29.6.3 - '@jridgewell/trace-mapping': 0.3.25 - babel-plugin-istanbul: 6.1.1 - chalk: 4.1.2 - convert-source-map: 2.0.0 - fast-json-stable-stringify: 2.1.0 - graceful-fs: 4.2.11 - jest-haste-map: 29.7.0 - jest-regex-util: 29.6.3 - jest-util: 29.7.0 - micromatch: 4.0.5 - pirates: 4.0.6 - slash: 3.0.0 - write-file-atomic: 4.0.2 - transitivePeerDependencies: - - supports-color + '@rollup/rollup-darwin-x64@4.18.0': + optional: true - '@jest/types@29.6.3': - dependencies: - '@jest/schemas': 29.6.3 - '@types/istanbul-lib-coverage': 2.0.6 - '@types/istanbul-reports': 3.0.4 - '@types/node': 20.12.2 - '@types/yargs': 17.0.32 - chalk: 4.1.2 + '@rollup/rollup-linux-arm-gnueabihf@4.18.0': + optional: true - '@jridgewell/gen-mapping@0.3.5': - dependencies: - '@jridgewell/set-array': 1.2.1 - '@jridgewell/sourcemap-codec': 1.4.15 - '@jridgewell/trace-mapping': 0.3.25 + '@rollup/rollup-linux-arm-musleabihf@4.18.0': + optional: true - '@jridgewell/resolve-uri@3.1.2': {} + '@rollup/rollup-linux-arm64-gnu@4.18.0': + optional: true - '@jridgewell/set-array@1.2.1': {} + '@rollup/rollup-linux-arm64-musl@4.18.0': + optional: true - '@jridgewell/sourcemap-codec@1.4.15': {} + '@rollup/rollup-linux-powerpc64le-gnu@4.18.0': + optional: true - '@jridgewell/trace-mapping@0.3.25': - dependencies: - '@jridgewell/resolve-uri': 3.1.2 - '@jridgewell/sourcemap-codec': 1.4.15 + '@rollup/rollup-linux-riscv64-gnu@4.18.0': + optional: true - '@juggle/resize-observer@3.4.0': {} + '@rollup/rollup-linux-s390x-gnu@4.18.0': + optional: true - '@kurkle/color@0.3.2': {} + '@rollup/rollup-linux-x64-gnu@4.18.0': + optional: true - '@msgpack/msgpack@2.8.0': {} + '@rollup/rollup-linux-x64-musl@4.18.0': + optional: true - '@nodelib/fs.scandir@2.1.5': - dependencies: - '@nodelib/fs.stat': 2.0.5 - run-parallel: 1.2.0 + '@rollup/rollup-win32-arm64-msvc@4.18.0': + optional: true - '@nodelib/fs.stat@2.0.5': {} + '@rollup/rollup-win32-ia32-msvc@4.18.0': + optional: true - '@nodelib/fs.walk@1.2.8': - dependencies: - '@nodelib/fs.scandir': 2.1.5 - fastq: 1.17.1 + '@rollup/rollup-win32-x64-msvc@4.18.0': + optional: true '@sinclair/typebox@0.27.8': {} - '@sinonjs/commons@3.0.1': - dependencies: - type-detect: 4.0.8 - - '@sinonjs/fake-timers@10.3.0': - dependencies: - '@sinonjs/commons': 3.0.1 - '@textcomplete/core@0.1.13': dependencies: eventemitter3: 5.0.1 @@ -3316,53 +2764,15 @@ snapshots: '@types/audioworklet@0.0.54': {} - '@types/babel__core@7.20.5': - dependencies: - '@babel/parser': 7.24.1 - '@babel/types': 7.24.0 - '@types/babel__generator': 7.6.8 - '@types/babel__template': 7.4.4 - '@types/babel__traverse': 7.20.5 - - '@types/babel__generator@7.6.8': - dependencies: - '@babel/types': 7.24.0 - - '@types/babel__template@7.4.4': - dependencies: - '@babel/parser': 7.24.1 - '@babel/types': 7.24.0 - - '@types/babel__traverse@7.20.5': - dependencies: - '@babel/types': 7.24.0 - '@types/chess.js@0.10.1': {} '@types/debounce-promise@3.1.9': {} '@types/dragscroll@0.0.0': {} - '@types/fnando__sparkline@0.3.7': {} - - '@types/graceful-fs@4.1.9': - dependencies: - '@types/node': 20.12.2 - - '@types/istanbul-lib-coverage@2.0.6': {} - - '@types/istanbul-lib-report@3.0.3': - dependencies: - '@types/istanbul-lib-coverage': 2.0.6 - - '@types/istanbul-reports@3.0.4': - dependencies: - '@types/istanbul-lib-report': 3.0.3 + '@types/estree@1.0.5': {} - '@types/jest@29.5.12': - dependencies: - expect: 29.7.0 - pretty-format: 29.7.0 + '@types/fnando__sparkline@0.3.7': {} '@types/json-schema@7.0.15': {} @@ -3385,8 +2795,6 @@ snapshots: '@types/sortablejs@1.15.8': {} - '@types/stack-utils@2.0.3': {} - '@types/web@0.0.142': {} '@types/webrtc@0.0.33': {} @@ -3395,12 +2803,6 @@ snapshots: dependencies: '@types/react': 18.2.74 - '@types/yargs-parser@21.0.3': {} - - '@types/yargs@17.0.32': - dependencies: - '@types/yargs-parser': 21.0.3 - '@types/zxcvbn@4.4.4': {} '@typescript-eslint/eslint-plugin@7.5.0(@typescript-eslint/parser@7.5.0(eslint@8.57.0)(typescript@5.4.3))(eslint@8.57.0)(typescript@5.4.3)': @@ -3491,6 +2893,35 @@ snapshots: '@ungap/structured-clone@1.2.0': {} + '@vitest/expect@1.6.0': + dependencies: + '@vitest/spy': 1.6.0 + '@vitest/utils': 1.6.0 + chai: 4.4.1 + + '@vitest/runner@1.6.0': + dependencies: + '@vitest/utils': 1.6.0 + p-limit: 5.0.0 + pathe: 1.1.2 + + '@vitest/snapshot@1.6.0': + dependencies: + magic-string: 0.30.10 + pathe: 1.1.2 + pretty-format: 29.7.0 + + '@vitest/spy@1.6.0': + dependencies: + tinyspy: 2.2.1 + + '@vitest/utils@1.6.0': + dependencies: + diff-sequences: 29.6.3 + estree-walker: 3.0.3 + loupe: 2.3.7 + pretty-format: 29.7.0 + '@yaireo/tagify@4.17.9(prop-types@15.8.1)': dependencies: prop-types: 15.8.1 @@ -3503,8 +2934,16 @@ snapshots: dependencies: acorn: 8.11.3 + acorn-walk@8.3.2: {} + acorn@8.11.3: {} + agent-base@7.1.1: + dependencies: + debug: 4.3.4 + transitivePeerDependencies: + - supports-color + ajv@6.12.6: dependencies: fast-deep-equal: 3.1.3 @@ -3512,20 +2951,12 @@ snapshots: json-schema-traverse: 0.4.1 uri-js: 4.4.1 - ansi-escapes@4.3.2: - dependencies: - type-fest: 0.21.3 - ansi-escapes@6.2.1: {} ansi-regex@5.0.1: {} ansi-regex@6.0.1: {} - ansi-styles@3.2.1: - dependencies: - color-convert: 1.9.3 - ansi-styles@4.3.0: dependencies: color-convert: 2.0.1 @@ -3551,65 +2982,13 @@ snapshots: arg@4.1.3: {} - argparse@1.0.10: - dependencies: - sprintf-js: 1.0.3 - argparse@2.0.1: {} array-union@2.1.0: {} - babel-jest@29.7.0(@babel/core@7.24.3): - dependencies: - '@babel/core': 7.24.3 - '@jest/transform': 29.7.0 - '@types/babel__core': 7.20.5 - babel-plugin-istanbul: 6.1.1 - babel-preset-jest: 29.6.3(@babel/core@7.24.3) - chalk: 4.1.2 - graceful-fs: 4.2.11 - slash: 3.0.0 - transitivePeerDependencies: - - supports-color + assertion-error@1.1.0: {} - babel-plugin-istanbul@6.1.1: - dependencies: - '@babel/helper-plugin-utils': 7.24.0 - '@istanbuljs/load-nyc-config': 1.1.0 - '@istanbuljs/schema': 0.1.3 - istanbul-lib-instrument: 5.2.1 - test-exclude: 6.0.0 - transitivePeerDependencies: - - supports-color - - babel-plugin-jest-hoist@29.6.3: - dependencies: - '@babel/template': 7.24.0 - '@babel/types': 7.24.0 - '@types/babel__core': 7.20.5 - '@types/babel__traverse': 7.20.5 - - babel-preset-current-node-syntax@1.0.1(@babel/core@7.24.3): - dependencies: - '@babel/core': 7.24.3 - '@babel/plugin-syntax-async-generators': 7.8.4(@babel/core@7.24.3) - '@babel/plugin-syntax-bigint': 7.8.3(@babel/core@7.24.3) - '@babel/plugin-syntax-class-properties': 7.12.13(@babel/core@7.24.3) - '@babel/plugin-syntax-import-meta': 7.10.4(@babel/core@7.24.3) - '@babel/plugin-syntax-json-strings': 7.8.3(@babel/core@7.24.3) - '@babel/plugin-syntax-logical-assignment-operators': 7.10.4(@babel/core@7.24.3) - '@babel/plugin-syntax-nullish-coalescing-operator': 7.8.3(@babel/core@7.24.3) - '@babel/plugin-syntax-numeric-separator': 7.10.4(@babel/core@7.24.3) - '@babel/plugin-syntax-object-rest-spread': 7.8.3(@babel/core@7.24.3) - '@babel/plugin-syntax-optional-catch-binding': 7.8.3(@babel/core@7.24.3) - '@babel/plugin-syntax-optional-chaining': 7.8.3(@babel/core@7.24.3) - '@babel/plugin-syntax-top-level-await': 7.14.5(@babel/core@7.24.3) - - babel-preset-jest@29.6.3(@babel/core@7.24.3): - dependencies: - '@babel/core': 7.24.3 - babel-plugin-jest-hoist: 29.6.3 - babel-preset-current-node-syntax: 1.0.1(@babel/core@7.24.3) + asynckit@0.4.0: {} balanced-match@1.0.2: {} @@ -3628,32 +3007,21 @@ snapshots: dependencies: fill-range: 7.0.1 - browserslist@4.23.0: - dependencies: - caniuse-lite: 1.0.30001605 - electron-to-chromium: 1.4.723 - node-releases: 2.0.14 - update-browserslist-db: 1.0.13(browserslist@4.23.0) - - bser@2.1.1: - dependencies: - node-int64: 0.4.0 - - buffer-from@1.1.2: {} + cac@6.7.14: {} callsites@3.1.0: {} camelcase@5.3.1: {} - camelcase@6.3.0: {} - - caniuse-lite@1.0.30001605: {} - - chalk@2.4.2: + chai@4.4.1: dependencies: - ansi-styles: 3.2.1 - escape-string-regexp: 1.0.5 - supports-color: 5.5.0 + assertion-error: 1.1.0 + check-error: 1.0.3 + deep-eql: 4.1.4 + get-func-name: 2.0.2 + loupe: 2.3.7 + pathval: 1.1.1 + type-detect: 4.0.8 chalk@4.1.2: dependencies: @@ -3662,8 +3030,6 @@ snapshots: chalk@5.3.0: {} - char-regex@1.0.2: {} - chart.js@4.4.0: dependencies: '@kurkle/color': 0.3.2 @@ -3682,6 +3048,10 @@ snapshots: chart.js: 4.4.0 hammerjs: 2.0.8 + check-error@1.0.3: + dependencies: + get-func-name: 2.0.2 + chess.js@https://codeload.github.com/ornicar/chess.js/tar.gz/ad0709c0b07773d9d0da8e4605a9a2a28f00d249: {} chessground@9.1.1: {} @@ -3706,10 +3076,6 @@ snapshots: optionalDependencies: fsevents: 2.3.3 - ci-info@3.9.0: {} - - cjs-module-lexer@1.2.3: {} - cli-cursor@4.0.0: dependencies: restore-cursor: 4.0.0 @@ -3725,50 +3091,23 @@ snapshots: strip-ansi: 6.0.1 wrap-ansi: 6.2.0 - cliui@8.0.1: - dependencies: - string-width: 4.2.3 - strip-ansi: 6.0.1 - wrap-ansi: 7.0.0 - - co@4.6.0: {} - - collect-v8-coverage@1.0.2: {} - - color-convert@1.9.3: - dependencies: - color-name: 1.1.3 - color-convert@2.0.1: dependencies: color-name: 1.1.4 - color-name@1.1.3: {} - color-name@1.1.4: {} colorette@2.0.20: {} + combined-stream@1.0.8: + dependencies: + delayed-stream: 1.0.0 + commander@11.1.0: {} concat-map@0.0.1: {} - convert-source-map@2.0.0: {} - - create-jest@29.7.0(@types/node@20.12.2): - dependencies: - '@jest/types': 29.6.3 - chalk: 4.1.2 - exit: 0.1.2 - graceful-fs: 4.2.11 - jest-config: 29.7.0(@types/node@20.12.2) - jest-util: 29.7.0 - prompts: 2.4.2 - transitivePeerDependencies: - - '@types/node' - - babel-plugin-macros - - supports-color - - ts-node + confbox@0.1.7: {} cropperjs@1.6.1: {} @@ -3778,8 +3117,17 @@ snapshots: shebang-command: 2.0.0 which: 2.0.2 + cssstyle@4.0.1: + dependencies: + rrweb-cssom: 0.6.0 + csstype@3.1.3: {} + data-urls@5.0.0: + dependencies: + whatwg-mimetype: 4.0.0 + whatwg-url: 14.0.0 + date-fns@2.29.3: {} dayjs@1.11.10: {} @@ -3792,13 +3140,17 @@ snapshots: decamelize@1.2.0: {} - dedent@1.5.1: {} + decimal.js@10.4.3: {} + + deep-eql@4.1.4: + dependencies: + type-detect: 4.0.8 deep-is@0.1.4: {} deepmerge@4.3.1: {} - detect-newline@3.1.0: {} + delayed-stream@1.0.0: {} dialog-polyfill@0.5.6: {} @@ -3818,10 +3170,6 @@ snapshots: dragscroll@0.0.8: {} - electron-to-chromium@1.4.723: {} - - emittery@0.13.1: {} - emoji-mart@5.5.2: {} emoji-regex@10.3.0: {} @@ -3830,15 +3178,33 @@ snapshots: encode-utf8@1.0.3: {} - error-ex@1.3.2: - dependencies: - is-arrayish: 0.2.1 - - escalade@3.1.2: {} - - escape-string-regexp@1.0.5: {} + entities@4.5.0: {} - escape-string-regexp@2.0.0: {} + esbuild@0.21.5: + optionalDependencies: + '@esbuild/aix-ppc64': 0.21.5 + '@esbuild/android-arm': 0.21.5 + '@esbuild/android-arm64': 0.21.5 + '@esbuild/android-x64': 0.21.5 + '@esbuild/darwin-arm64': 0.21.5 + '@esbuild/darwin-x64': 0.21.5 + '@esbuild/freebsd-arm64': 0.21.5 + '@esbuild/freebsd-x64': 0.21.5 + '@esbuild/linux-arm': 0.21.5 + '@esbuild/linux-arm64': 0.21.5 + '@esbuild/linux-ia32': 0.21.5 + '@esbuild/linux-loong64': 0.21.5 + '@esbuild/linux-mips64el': 0.21.5 + '@esbuild/linux-ppc64': 0.21.5 + '@esbuild/linux-riscv64': 0.21.5 + '@esbuild/linux-s390x': 0.21.5 + '@esbuild/linux-x64': 0.21.5 + '@esbuild/netbsd-x64': 0.21.5 + '@esbuild/openbsd-x64': 0.21.5 + '@esbuild/sunos-x64': 0.21.5 + '@esbuild/win32-arm64': 0.21.5 + '@esbuild/win32-ia32': 0.21.5 + '@esbuild/win32-x64': 0.21.5 escape-string-regexp@4.0.0: {} @@ -3898,8 +3264,6 @@ snapshots: acorn-jsx: 5.3.2(acorn@8.11.3) eslint-visitor-keys: 3.4.3 - esprima@4.0.1: {} - esquery@1.5.0: dependencies: estraverse: 5.3.0 @@ -3910,24 +3274,16 @@ snapshots: estraverse@5.3.0: {} + estree-walker@3.0.3: + dependencies: + '@types/estree': 1.0.5 + esutils@2.0.3: {} eventemitter3@4.0.7: {} eventemitter3@5.0.1: {} - execa@5.1.1: - dependencies: - cross-spawn: 7.0.3 - get-stream: 6.0.1 - human-signals: 2.1.0 - is-stream: 2.0.1 - merge-stream: 2.0.0 - npm-run-path: 4.0.1 - onetime: 5.1.2 - signal-exit: 3.0.7 - strip-final-newline: 2.0.0 - execa@8.0.1: dependencies: cross-spawn: 7.0.3 @@ -3940,16 +3296,6 @@ snapshots: signal-exit: 4.1.0 strip-final-newline: 3.0.0 - exit@0.1.2: {} - - expect@29.7.0: - dependencies: - '@jest/expect-utils': 29.7.0 - jest-get-type: 29.6.3 - jest-matcher-utils: 29.7.0 - jest-message-util: 29.7.0 - jest-util: 29.7.0 - fast-deep-equal@3.1.3: {} fast-glob@3.3.2: @@ -3968,10 +3314,6 @@ snapshots: dependencies: reusify: 1.0.4 - fb-watchman@2.0.2: - dependencies: - bser: 2.1.1 - file-entry-cache@6.0.1: dependencies: flat-cache: 3.2.0 @@ -3998,518 +3340,179 @@ snapshots: flatpickr@4.6.13: {} - flatted@3.3.1: {} - - fs.realpath@1.0.0: {} - - fsevents@2.3.3: - optional: true - - function-bind@1.1.2: {} - - gensync@1.0.0-beta.2: {} - - get-caller-file@2.0.5: {} - - get-east-asian-width@1.2.0: {} - - get-package-type@0.1.0: {} - - get-stream@6.0.1: {} - - get-stream@8.0.1: {} - - glob-parent@5.1.2: - dependencies: - is-glob: 4.0.3 - - glob-parent@6.0.2: - dependencies: - is-glob: 4.0.3 - - glob@7.2.3: - dependencies: - fs.realpath: 1.0.0 - inflight: 1.0.6 - inherits: 2.0.4 - minimatch: 3.1.2 - once: 1.4.0 - path-is-absolute: 1.0.1 - - globals@11.12.0: {} - - globals@13.24.0: - dependencies: - type-fest: 0.20.2 - - globby@11.1.0: - dependencies: - array-union: 2.1.0 - dir-glob: 3.0.1 - fast-glob: 3.3.2 - ignore: 5.3.1 - merge2: 1.4.1 - slash: 3.0.0 - - graceful-fs@4.2.11: {} - - graphemer@1.4.0: {} - - hammerjs@2.0.8: {} - - has-flag@3.0.0: {} - - has-flag@4.0.0: {} - - hasown@2.0.2: - dependencies: - function-bind: 1.1.2 - - html-escaper@2.0.2: {} - - human-signals@2.1.0: {} - - human-signals@5.0.0: {} - - idb-keyval@6.2.1: {} - - ignore@5.3.1: {} - - import-fresh@3.3.0: - dependencies: - parent-module: 1.0.1 - resolve-from: 4.0.0 - - import-local@3.1.0: - dependencies: - pkg-dir: 4.2.0 - resolve-cwd: 3.0.0 - - imurmurhash@0.1.4: {} - - inflight@1.0.6: - dependencies: - once: 1.4.0 - wrappy: 1.0.2 - - inherits@2.0.4: {} - - is-arrayish@0.2.1: {} - - is-binary-path@2.1.0: - dependencies: - binary-extensions: 2.3.0 - - is-core-module@2.13.1: - dependencies: - hasown: 2.0.2 - - is-extglob@2.1.1: {} - - is-fullwidth-code-point@3.0.0: {} - - is-fullwidth-code-point@4.0.0: {} - - is-fullwidth-code-point@5.0.0: - dependencies: - get-east-asian-width: 1.2.0 - - is-generator-fn@2.1.0: {} - - is-glob@4.0.3: - dependencies: - is-extglob: 2.1.1 - - is-number@7.0.0: {} - - is-path-inside@3.0.3: {} - - is-stream@2.0.1: {} - - is-stream@3.0.0: {} - - isexe@2.0.0: {} - - istanbul-lib-coverage@3.2.2: {} - - istanbul-lib-instrument@5.2.1: - dependencies: - '@babel/core': 7.24.3 - '@babel/parser': 7.24.1 - '@istanbuljs/schema': 0.1.3 - istanbul-lib-coverage: 3.2.2 - semver: 6.3.1 - transitivePeerDependencies: - - supports-color - - istanbul-lib-instrument@6.0.2: - dependencies: - '@babel/core': 7.24.3 - '@babel/parser': 7.24.1 - '@istanbuljs/schema': 0.1.3 - istanbul-lib-coverage: 3.2.2 - semver: 7.6.0 - transitivePeerDependencies: - - supports-color - - istanbul-lib-report@3.0.1: - dependencies: - istanbul-lib-coverage: 3.2.2 - make-dir: 4.0.0 - supports-color: 7.2.0 - - istanbul-lib-source-maps@4.0.1: - dependencies: - debug: 4.3.4 - istanbul-lib-coverage: 3.2.2 - source-map: 0.6.1 - transitivePeerDependencies: - - supports-color - - istanbul-reports@3.1.7: - dependencies: - html-escaper: 2.0.2 - istanbul-lib-report: 3.0.1 - - jest-changed-files@29.7.0: - dependencies: - execa: 5.1.1 - jest-util: 29.7.0 - p-limit: 3.1.0 - - jest-circus@29.7.0: - dependencies: - '@jest/environment': 29.7.0 - '@jest/expect': 29.7.0 - '@jest/test-result': 29.7.0 - '@jest/types': 29.6.3 - '@types/node': 20.12.2 - chalk: 4.1.2 - co: 4.6.0 - dedent: 1.5.1 - is-generator-fn: 2.1.0 - jest-each: 29.7.0 - jest-matcher-utils: 29.7.0 - jest-message-util: 29.7.0 - jest-runtime: 29.7.0 - jest-snapshot: 29.7.0 - jest-util: 29.7.0 - p-limit: 3.1.0 - pretty-format: 29.7.0 - pure-rand: 6.1.0 - slash: 3.0.0 - stack-utils: 2.0.6 - transitivePeerDependencies: - - babel-plugin-macros - - supports-color - - jest-cli@29.7.0(@types/node@20.12.2): - dependencies: - '@jest/core': 29.7.0 - '@jest/test-result': 29.7.0 - '@jest/types': 29.6.3 - chalk: 4.1.2 - create-jest: 29.7.0(@types/node@20.12.2) - exit: 0.1.2 - import-local: 3.1.0 - jest-config: 29.7.0(@types/node@20.12.2) - jest-util: 29.7.0 - jest-validate: 29.7.0 - yargs: 17.7.2 - transitivePeerDependencies: - - '@types/node' - - babel-plugin-macros - - supports-color - - ts-node - - jest-config@29.7.0(@types/node@20.12.2): - dependencies: - '@babel/core': 7.24.3 - '@jest/test-sequencer': 29.7.0 - '@jest/types': 29.6.3 - babel-jest: 29.7.0(@babel/core@7.24.3) - chalk: 4.1.2 - ci-info: 3.9.0 - deepmerge: 4.3.1 - glob: 7.2.3 - graceful-fs: 4.2.11 - jest-circus: 29.7.0 - jest-environment-node: 29.7.0 - jest-get-type: 29.6.3 - jest-regex-util: 29.6.3 - jest-resolve: 29.7.0 - jest-runner: 29.7.0 - jest-util: 29.7.0 - jest-validate: 29.7.0 - micromatch: 4.0.5 - parse-json: 5.2.0 - pretty-format: 29.7.0 - slash: 3.0.0 - strip-json-comments: 3.1.1 - optionalDependencies: - '@types/node': 20.12.2 - transitivePeerDependencies: - - babel-plugin-macros - - supports-color - - jest-diff@29.7.0: - dependencies: - chalk: 4.1.2 - diff-sequences: 29.6.3 - jest-get-type: 29.6.3 - pretty-format: 29.7.0 - - jest-docblock@29.7.0: - dependencies: - detect-newline: 3.1.0 + flatted@3.3.1: {} - jest-each@29.7.0: + form-data@4.0.0: dependencies: - '@jest/types': 29.6.3 - chalk: 4.1.2 - jest-get-type: 29.6.3 - jest-util: 29.7.0 - pretty-format: 29.7.0 + asynckit: 0.4.0 + combined-stream: 1.0.8 + mime-types: 2.1.35 - jest-environment-node@29.7.0: - dependencies: - '@jest/environment': 29.7.0 - '@jest/fake-timers': 29.7.0 - '@jest/types': 29.6.3 - '@types/node': 20.12.2 - jest-mock: 29.7.0 - jest-util: 29.7.0 + fs.realpath@1.0.0: {} + + fsevents@2.3.3: + optional: true + + get-caller-file@2.0.5: {} - jest-get-type@29.6.3: {} + get-east-asian-width@1.2.0: {} + + get-func-name@2.0.2: {} + + get-stream@8.0.1: {} - jest-haste-map@29.7.0: + glob-parent@5.1.2: dependencies: - '@jest/types': 29.6.3 - '@types/graceful-fs': 4.1.9 - '@types/node': 20.12.2 - anymatch: 3.1.3 - fb-watchman: 2.0.2 - graceful-fs: 4.2.11 - jest-regex-util: 29.6.3 - jest-util: 29.7.0 - jest-worker: 29.7.0 - micromatch: 4.0.5 - walker: 1.0.8 - optionalDependencies: - fsevents: 2.3.3 + is-glob: 4.0.3 - jest-leak-detector@29.7.0: + glob-parent@6.0.2: dependencies: - jest-get-type: 29.6.3 - pretty-format: 29.7.0 + is-glob: 4.0.3 - jest-matcher-utils@29.7.0: + glob@7.2.3: dependencies: - chalk: 4.1.2 - jest-diff: 29.7.0 - jest-get-type: 29.6.3 - pretty-format: 29.7.0 + fs.realpath: 1.0.0 + inflight: 1.0.6 + inherits: 2.0.4 + minimatch: 3.1.2 + once: 1.4.0 + path-is-absolute: 1.0.1 - jest-message-util@29.7.0: + globals@13.24.0: dependencies: - '@babel/code-frame': 7.24.2 - '@jest/types': 29.6.3 - '@types/stack-utils': 2.0.3 - chalk: 4.1.2 - graceful-fs: 4.2.11 - micromatch: 4.0.5 - pretty-format: 29.7.0 - slash: 3.0.0 - stack-utils: 2.0.6 + type-fest: 0.20.2 - jest-mock@29.7.0: + globby@11.1.0: dependencies: - '@jest/types': 29.6.3 - '@types/node': 20.12.2 - jest-util: 29.7.0 + array-union: 2.1.0 + dir-glob: 3.0.1 + fast-glob: 3.3.2 + ignore: 5.3.1 + merge2: 1.4.1 + slash: 3.0.0 - jest-pnp-resolver@1.2.3(jest-resolve@29.7.0): - optionalDependencies: - jest-resolve: 29.7.0 + graphemer@1.4.0: {} - jest-regex-util@29.6.3: {} + hammerjs@2.0.8: {} - jest-resolve-dependencies@29.7.0: - dependencies: - jest-regex-util: 29.6.3 - jest-snapshot: 29.7.0 - transitivePeerDependencies: - - supports-color + has-flag@4.0.0: {} - jest-resolve@29.7.0: + html-encoding-sniffer@4.0.0: dependencies: - chalk: 4.1.2 - graceful-fs: 4.2.11 - jest-haste-map: 29.7.0 - jest-pnp-resolver: 1.2.3(jest-resolve@29.7.0) - jest-util: 29.7.0 - jest-validate: 29.7.0 - resolve: 1.22.8 - resolve.exports: 2.0.2 - slash: 3.0.0 + whatwg-encoding: 3.1.1 - jest-runner@29.7.0: + http-proxy-agent@7.0.2: dependencies: - '@jest/console': 29.7.0 - '@jest/environment': 29.7.0 - '@jest/test-result': 29.7.0 - '@jest/transform': 29.7.0 - '@jest/types': 29.6.3 - '@types/node': 20.12.2 - chalk: 4.1.2 - emittery: 0.13.1 - graceful-fs: 4.2.11 - jest-docblock: 29.7.0 - jest-environment-node: 29.7.0 - jest-haste-map: 29.7.0 - jest-leak-detector: 29.7.0 - jest-message-util: 29.7.0 - jest-resolve: 29.7.0 - jest-runtime: 29.7.0 - jest-util: 29.7.0 - jest-watcher: 29.7.0 - jest-worker: 29.7.0 - p-limit: 3.1.0 - source-map-support: 0.5.13 + agent-base: 7.1.1 + debug: 4.3.4 transitivePeerDependencies: - supports-color - jest-runtime@29.7.0: + https-proxy-agent@7.0.4: dependencies: - '@jest/environment': 29.7.0 - '@jest/fake-timers': 29.7.0 - '@jest/globals': 29.7.0 - '@jest/source-map': 29.6.3 - '@jest/test-result': 29.7.0 - '@jest/transform': 29.7.0 - '@jest/types': 29.6.3 - '@types/node': 20.12.2 - chalk: 4.1.2 - cjs-module-lexer: 1.2.3 - collect-v8-coverage: 1.0.2 - glob: 7.2.3 - graceful-fs: 4.2.11 - jest-haste-map: 29.7.0 - jest-message-util: 29.7.0 - jest-mock: 29.7.0 - jest-regex-util: 29.6.3 - jest-resolve: 29.7.0 - jest-snapshot: 29.7.0 - jest-util: 29.7.0 - slash: 3.0.0 - strip-bom: 4.0.0 + agent-base: 7.1.1 + debug: 4.3.4 transitivePeerDependencies: - supports-color - jest-snapshot@29.7.0: - dependencies: - '@babel/core': 7.24.3 - '@babel/generator': 7.24.1 - '@babel/plugin-syntax-jsx': 7.24.1(@babel/core@7.24.3) - '@babel/plugin-syntax-typescript': 7.24.1(@babel/core@7.24.3) - '@babel/types': 7.24.0 - '@jest/expect-utils': 29.7.0 - '@jest/transform': 29.7.0 - '@jest/types': 29.6.3 - babel-preset-current-node-syntax: 1.0.1(@babel/core@7.24.3) - chalk: 4.1.2 - expect: 29.7.0 - graceful-fs: 4.2.11 - jest-diff: 29.7.0 - jest-get-type: 29.6.3 - jest-matcher-utils: 29.7.0 - jest-message-util: 29.7.0 - jest-util: 29.7.0 - natural-compare: 1.4.0 - pretty-format: 29.7.0 - semver: 7.6.0 - transitivePeerDependencies: - - supports-color + human-signals@5.0.0: {} - jest-util@29.7.0: + iconv-lite@0.6.3: dependencies: - '@jest/types': 29.6.3 - '@types/node': 20.12.2 - chalk: 4.1.2 - ci-info: 3.9.0 - graceful-fs: 4.2.11 - picomatch: 2.3.1 + safer-buffer: 2.1.2 + + idb-keyval@6.2.1: {} + + ignore@5.3.1: {} - jest-validate@29.7.0: + import-fresh@3.3.0: dependencies: - '@jest/types': 29.6.3 - camelcase: 6.3.0 - chalk: 4.1.2 - jest-get-type: 29.6.3 - leven: 3.1.0 - pretty-format: 29.7.0 + parent-module: 1.0.1 + resolve-from: 4.0.0 + + imurmurhash@0.1.4: {} - jest-watcher@29.7.0: + inflight@1.0.6: dependencies: - '@jest/test-result': 29.7.0 - '@jest/types': 29.6.3 - '@types/node': 20.12.2 - ansi-escapes: 4.3.2 - chalk: 4.1.2 - emittery: 0.13.1 - jest-util: 29.7.0 - string-length: 4.0.2 + once: 1.4.0 + wrappy: 1.0.2 + + inherits@2.0.4: {} + + is-binary-path@2.1.0: + dependencies: + binary-extensions: 2.3.0 + + is-extglob@2.1.1: {} + + is-fullwidth-code-point@3.0.0: {} + + is-fullwidth-code-point@4.0.0: {} - jest-worker@29.7.0: + is-fullwidth-code-point@5.0.0: dependencies: - '@types/node': 20.12.2 - jest-util: 29.7.0 - merge-stream: 2.0.0 - supports-color: 8.1.1 + get-east-asian-width: 1.2.0 - jest@29.7.0(@types/node@20.12.2): + is-glob@4.0.3: dependencies: - '@jest/core': 29.7.0 - '@jest/types': 29.6.3 - import-local: 3.1.0 - jest-cli: 29.7.0(@types/node@20.12.2) - transitivePeerDependencies: - - '@types/node' - - babel-plugin-macros - - supports-color - - ts-node + is-extglob: 2.1.1 + + is-number@7.0.0: {} + + is-path-inside@3.0.3: {} + + is-potential-custom-element-name@1.0.1: {} + + is-stream@3.0.0: {} + + isexe@2.0.0: {} js-tokens@4.0.0: {} - js-yaml@3.14.1: - dependencies: - argparse: 1.0.10 - esprima: 4.0.1 + js-tokens@9.0.0: {} js-yaml@4.1.0: dependencies: argparse: 2.0.1 - jsesc@2.5.2: {} + jsdom@24.1.0: + dependencies: + cssstyle: 4.0.1 + data-urls: 5.0.0 + decimal.js: 10.4.3 + form-data: 4.0.0 + html-encoding-sniffer: 4.0.0 + http-proxy-agent: 7.0.2 + https-proxy-agent: 7.0.4 + is-potential-custom-element-name: 1.0.1 + nwsapi: 2.2.10 + parse5: 7.1.2 + rrweb-cssom: 0.7.1 + saxes: 6.0.0 + symbol-tree: 3.2.4 + tough-cookie: 4.1.4 + w3c-xmlserializer: 5.0.0 + webidl-conversions: 7.0.0 + whatwg-encoding: 3.1.1 + whatwg-mimetype: 4.0.0 + whatwg-url: 14.0.0 + ws: 8.17.0 + xml-name-validator: 5.0.0 + transitivePeerDependencies: + - bufferutil + - supports-color + - utf-8-validate json-buffer@3.0.1: {} - json-parse-even-better-errors@2.3.1: {} - json-schema-traverse@0.4.1: {} json-stable-stringify-without-jsonify@1.0.1: {} - json5@2.2.3: {} - keyv@4.5.4: dependencies: json-buffer: 3.0.1 - kleur@3.0.3: {} - - leven@3.1.0: {} - levn@0.4.1: dependencies: prelude-ls: 1.2.1 @@ -4526,8 +3529,6 @@ snapshots: lilconfig@3.0.0: {} - lines-and-columns@1.2.4: {} - lint-staged@15.2.2: dependencies: chalk: 5.3.0 @@ -4552,6 +3553,11 @@ snapshots: rfdc: 1.3.1 wrap-ansi: 9.0.0 + local-pkg@0.5.0: + dependencies: + mlly: 1.7.1 + pkg-types: 1.1.1 + locate-path@5.0.0: dependencies: p-locate: 4.1.0 @@ -4574,21 +3580,17 @@ snapshots: dependencies: js-tokens: 4.0.0 - lru-cache@5.1.1: + loupe@2.3.7: dependencies: - yallist: 3.1.1 + get-func-name: 2.0.2 lru-cache@6.0.0: dependencies: yallist: 4.0.0 - make-dir@4.0.0: - dependencies: - semver: 7.6.0 - - makeerror@1.0.12: + magic-string@0.30.10: dependencies: - tmpl: 1.0.5 + '@jridgewell/sourcemap-codec': 1.4.15 merge-stream@2.0.0: {} @@ -4599,6 +3601,12 @@ snapshots: braces: 3.0.2 picomatch: 2.3.1 + mime-db@1.52.0: {} + + mime-types@2.1.35: + dependencies: + mime-db: 1.52.0 + mimic-fn@2.1.0: {} mimic-fn@4.0.0: {} @@ -4611,26 +3619,29 @@ snapshots: dependencies: brace-expansion: 2.0.1 - ms@2.1.2: {} + mlly@1.7.1: + dependencies: + acorn: 8.11.3 + pathe: 1.1.2 + pkg-types: 1.1.1 + ufo: 1.5.3 - natural-compare@1.4.0: {} + ms@2.1.2: {} - node-int64@0.4.0: {} + nanoid@3.3.7: {} - node-releases@2.0.14: {} + natural-compare@1.4.0: {} normalize-path@3.0.0: {} nouislider@15.7.1: {} - npm-run-path@4.0.1: - dependencies: - path-key: 3.1.1 - npm-run-path@5.3.0: dependencies: path-key: 4.0.0 + nwsapi@2.2.10: {} + object-assign@4.1.1: {} once@1.4.0: @@ -4674,6 +3685,10 @@ snapshots: dependencies: yocto-queue: 0.1.0 + p-limit@5.0.0: + dependencies: + yocto-queue: 1.0.0 + p-locate@4.1.0: dependencies: p-limit: 2.3.0 @@ -4688,12 +3703,9 @@ snapshots: dependencies: callsites: 3.1.0 - parse-json@5.2.0: + parse5@7.1.2: dependencies: - '@babel/code-frame': 7.24.2 - error-ex: 1.3.2 - json-parse-even-better-errors: 2.3.1 - lines-and-columns: 1.2.4 + entities: 4.5.0 path-exists@4.0.0: {} @@ -4703,10 +3715,12 @@ snapshots: path-key@4.0.0: {} - path-parse@1.0.7: {} - path-type@4.0.0: {} + pathe@1.1.2: {} + + pathval@1.1.1: {} + peerjs-js-binarypack@2.1.0: {} peerjs@1.5.4: @@ -4722,14 +3736,20 @@ snapshots: pidtree@0.6.0: {} - pirates@4.0.6: {} - - pkg-dir@4.2.0: + pkg-types@1.1.1: dependencies: - find-up: 4.1.0 + confbox: 0.1.7 + mlly: 1.7.1 + pathe: 1.1.2 pngjs@5.0.0: {} + postcss@8.4.38: + dependencies: + nanoid: 3.3.7 + picocolors: 1.0.0 + source-map-js: 1.2.0 + prelude-ls@1.2.1: {} prettier@3.0.2: {} @@ -4740,11 +3760,6 @@ snapshots: ansi-styles: 5.2.0 react-is: 18.2.0 - prompts@2.4.2: - dependencies: - kleur: 3.0.3 - sisteransi: 1.0.5 - prop-types@15.8.1: dependencies: loose-envify: 1.4.0 @@ -4794,9 +3809,9 @@ snapshots: prosemirror-state: 1.4.3 prosemirror-transform: 1.8.0 - punycode@2.3.1: {} + psl@1.9.0: {} - pure-rand@6.1.0: {} + punycode@2.3.1: {} qrcode@1.5.3: dependencies: @@ -4805,6 +3820,8 @@ snapshots: pngjs: 5.0.0 yargs: 15.4.1 + querystringify@2.2.0: {} + queue-microtask@1.2.3: {} react-is@16.13.1: {} @@ -4819,22 +3836,10 @@ snapshots: require-main-filename@2.0.0: {} - resolve-cwd@3.0.0: - dependencies: - resolve-from: 5.0.0 + requires-port@1.0.0: {} resolve-from@4.0.0: {} - resolve-from@5.0.0: {} - - resolve.exports@2.0.2: {} - - resolve@1.22.8: - dependencies: - is-core-module: 2.13.1 - path-parse: 1.0.7 - supports-preserve-symlinks-flag: 1.0.0 - restore-cursor@4.0.0: dependencies: onetime: 5.1.2 @@ -4848,17 +3853,47 @@ snapshots: dependencies: glob: 7.2.3 + rollup@4.18.0: + dependencies: + '@types/estree': 1.0.5 + optionalDependencies: + '@rollup/rollup-android-arm-eabi': 4.18.0 + '@rollup/rollup-android-arm64': 4.18.0 + '@rollup/rollup-darwin-arm64': 4.18.0 + '@rollup/rollup-darwin-x64': 4.18.0 + '@rollup/rollup-linux-arm-gnueabihf': 4.18.0 + '@rollup/rollup-linux-arm-musleabihf': 4.18.0 + '@rollup/rollup-linux-arm64-gnu': 4.18.0 + '@rollup/rollup-linux-arm64-musl': 4.18.0 + '@rollup/rollup-linux-powerpc64le-gnu': 4.18.0 + '@rollup/rollup-linux-riscv64-gnu': 4.18.0 + '@rollup/rollup-linux-s390x-gnu': 4.18.0 + '@rollup/rollup-linux-x64-gnu': 4.18.0 + '@rollup/rollup-linux-x64-musl': 4.18.0 + '@rollup/rollup-win32-arm64-msvc': 4.18.0 + '@rollup/rollup-win32-ia32-msvc': 4.18.0 + '@rollup/rollup-win32-x64-msvc': 4.18.0 + fsevents: 2.3.3 + rope-sequence@1.3.4: {} + rrweb-cssom@0.6.0: {} + + rrweb-cssom@0.7.1: {} + run-parallel@1.2.0: dependencies: queue-microtask: 1.2.3 + safer-buffer@2.1.2: {} + sax@1.3.0: {} - sdp@3.2.0: {} + saxes@6.0.0: + dependencies: + xmlchars: 2.2.0 - semver@6.3.1: {} + sdp@3.2.0: {} semver@7.6.0: dependencies: @@ -4877,12 +3912,12 @@ snapshots: '@floating-ui/dom': 1.6.3 deepmerge: 4.3.1 + siginfo@2.0.0: {} + signal-exit@3.0.7: {} signal-exit@4.1.0: {} - sisteransi@1.0.5: {} - slash@3.0.0: {} slice-ansi@5.0.0: @@ -4899,18 +3934,11 @@ snapshots: sortablejs@1.15.2: {} - source-map-support@0.5.13: - dependencies: - buffer-from: 1.1.2 - source-map: 0.6.1 - - source-map@0.6.1: {} + source-map-js@1.2.0: {} - sprintf-js@1.0.3: {} + stackback@0.0.2: {} - stack-utils@2.0.6: - dependencies: - escape-string-regexp: 2.0.0 + std-env@3.7.0: {} stockfish-mv.wasm@0.6.1: {} @@ -4922,11 +3950,6 @@ snapshots: string-argv@0.3.2: {} - string-length@4.0.2: - dependencies: - char-regex: 1.0.2 - strip-ansi: 6.0.1 - string-width@4.2.3: dependencies: emoji-regex: 8.0.0 @@ -4947,28 +3970,18 @@ snapshots: dependencies: ansi-regex: 6.0.1 - strip-bom@4.0.0: {} - - strip-final-newline@2.0.0: {} - strip-final-newline@3.0.0: {} strip-json-comments@3.1.1: {} - supports-color@5.5.0: + strip-literal@2.1.0: dependencies: - has-flag: 3.0.0 + js-tokens: 9.0.0 supports-color@7.2.0: dependencies: has-flag: 4.0.0 - supports-color@8.1.1: - dependencies: - has-flag: 4.0.0 - - supports-preserve-symlinks-flag@1.0.0: {} - svg.draggable.js@2.2.2: dependencies: svg.js: 2.7.1 @@ -5000,26 +4013,35 @@ snapshots: dependencies: svg.js: 2.7.1 - tablesort@5.3.0: {} + symbol-tree@3.2.4: {} - test-exclude@6.0.0: - dependencies: - '@istanbuljs/schema': 0.1.3 - glob: 7.2.3 - minimatch: 3.1.2 + tablesort@5.3.0: {} text-table@0.2.0: {} textarea-caret@3.1.0: {} - tmpl@1.0.5: {} + tinybench@2.8.0: {} + + tinypool@0.8.4: {} - to-fast-properties@2.0.0: {} + tinyspy@2.2.1: {} to-regex-range@5.0.1: dependencies: is-number: 7.0.0 + tough-cookie@4.1.4: + dependencies: + psl: 1.9.0 + punycode: 2.3.1 + universalify: 0.2.0 + url-parse: 1.5.10 + + tr46@5.0.0: + dependencies: + punycode: 2.3.1 + tree-kill@1.2.2: {} ts-api-utils@1.3.0(typescript@5.4.3): @@ -5034,33 +4056,88 @@ snapshots: type-fest@0.20.2: {} - type-fest@0.21.3: {} - types-serviceworker@0.0.1: {} typescript@5.4.3: {} + ufo@1.5.3: {} + undate@0.3.0: {} undici-types@5.26.5: {} - update-browserslist-db@1.0.13(browserslist@4.23.0): - dependencies: - browserslist: 4.23.0 - escalade: 3.1.2 - picocolors: 1.0.0 + universalify@0.2.0: {} uri-js@4.4.1: dependencies: punycode: 2.3.1 + url-parse@1.5.10: + dependencies: + querystringify: 2.2.0 + requires-port: 1.0.0 + uuid@9.0.0: {} - v8-to-istanbul@9.2.0: + vite-node@1.6.0(@types/node@20.12.2): + dependencies: + cac: 6.7.14 + debug: 4.3.4 + pathe: 1.1.2 + picocolors: 1.0.0 + vite: 5.3.0(@types/node@20.12.2) + transitivePeerDependencies: + - '@types/node' + - less + - lightningcss + - sass + - stylus + - sugarss + - supports-color + - terser + + vite@5.3.0(@types/node@20.12.2): + dependencies: + esbuild: 0.21.5 + postcss: 8.4.38 + rollup: 4.18.0 + optionalDependencies: + '@types/node': 20.12.2 + fsevents: 2.3.3 + + vitest@1.6.0(@types/node@20.12.2)(jsdom@24.1.0): dependencies: - '@jridgewell/trace-mapping': 0.3.25 - '@types/istanbul-lib-coverage': 2.0.6 - convert-source-map: 2.0.0 + '@vitest/expect': 1.6.0 + '@vitest/runner': 1.6.0 + '@vitest/snapshot': 1.6.0 + '@vitest/spy': 1.6.0 + '@vitest/utils': 1.6.0 + acorn-walk: 8.3.2 + chai: 4.4.1 + debug: 4.3.4 + execa: 8.0.1 + local-pkg: 0.5.0 + magic-string: 0.30.10 + pathe: 1.1.2 + picocolors: 1.0.0 + std-env: 3.7.0 + strip-literal: 2.1.0 + tinybench: 2.8.0 + tinypool: 0.8.4 + vite: 5.3.0(@types/node@20.12.2) + vite-node: 1.6.0(@types/node@20.12.2) + why-is-node-running: 2.2.2 + optionalDependencies: + '@types/node': 20.12.2 + jsdom: 24.1.0 + transitivePeerDependencies: + - less + - lightningcss + - sass + - stylus + - sugarss + - supports-color + - terser vosk-browser@0.0.8: dependencies: @@ -5068,27 +4145,39 @@ snapshots: w3c-keyname@2.2.8: {} - walker@1.0.8: + w3c-xmlserializer@5.0.0: dependencies: - makeerror: 1.0.12 + xml-name-validator: 5.0.0 + + webidl-conversions@7.0.0: {} webrtc-adapter@9.0.1: dependencies: sdp: 3.2.0 + whatwg-encoding@3.1.1: + dependencies: + iconv-lite: 0.6.3 + + whatwg-mimetype@4.0.0: {} + + whatwg-url@14.0.0: + dependencies: + tr46: 5.0.0 + webidl-conversions: 7.0.0 + which-module@2.0.1: {} which@2.0.2: dependencies: isexe: 2.0.0 - wrap-ansi@6.2.0: + why-is-node-running@2.2.2: dependencies: - ansi-styles: 4.3.0 - string-width: 4.2.3 - strip-ansi: 6.0.1 + siginfo: 2.0.0 + stackback: 0.0.2 - wrap-ansi@7.0.0: + wrap-ansi@6.2.0: dependencies: ansi-styles: 4.3.0 string-width: 4.2.3 @@ -5102,10 +4191,9 @@ snapshots: wrappy@1.0.2: {} - write-file-atomic@4.0.2: - dependencies: - imurmurhash: 0.1.4 - signal-exit: 3.0.7 + ws@8.17.0: {} + + xml-name-validator@5.0.0: {} xml2js@0.5.0: dependencies: @@ -5114,11 +4202,9 @@ snapshots: xmlbuilder@11.0.1: {} - y18n@4.0.3: {} - - y18n@5.0.8: {} + xmlchars@2.2.0: {} - yallist@3.1.1: {} + y18n@4.0.3: {} yallist@4.0.0: {} @@ -5129,8 +4215,6 @@ snapshots: camelcase: 5.3.1 decamelize: 1.2.0 - yargs-parser@21.1.1: {} - yargs@15.4.1: dependencies: cliui: 6.0.0 @@ -5145,16 +4229,8 @@ snapshots: y18n: 4.0.3 yargs-parser: 18.1.3 - yargs@17.7.2: - dependencies: - cliui: 8.0.1 - escalade: 3.1.2 - get-caller-file: 2.0.5 - require-directory: 2.1.1 - string-width: 4.2.3 - y18n: 5.0.8 - yargs-parser: 21.1.1 - yocto-queue@0.1.0: {} + yocto-queue@1.0.0: {} + zxcvbn@4.4.2: {} diff --git a/ui/@types/lichess/index.d.ts b/ui/@types/lichess/index.d.ts index 8b3963431e128..d9c566a98c71b 100644 --- a/ui/@types/lichess/index.d.ts +++ b/ui/@types/lichess/index.d.ts @@ -13,7 +13,11 @@ // file://./../../site/src/site.ts interface Site { debug: boolean; - info: any; + info: { + commit: string; + message: string; + date: string; + }; StrongSocket: { // file://./../../site/src/socket.ts new (url: string, version: number | false, cfg?: any): any; diff --git a/ui/README.md b/ui/README.md index 0722d069f0022..7da754f10cdae 100644 --- a/ui/README.md +++ b/ui/README.md @@ -6,7 +6,7 @@ Client builds are performed by the ui/build script. Stick to `ui/build -w` and l Usage examples: -``` +```bash ui/build # builds all client assets in dev mode ui/build -w # builds all client assets and watches for changes ui/build -p # builds minified client assets (prod builds) @@ -22,11 +22,14 @@ Usage examples: ## Testing -The frontend uses the Jest testing framework. +The frontend uses the [Vitest](https://vitest.dev/) testing framework. + +```bash +cd ui -``` -cd ui/ pnpm test +## or +pnpm test:watch ``` ## CSS diff --git a/ui/chat/src/spam.ts b/ui/chat/src/spam.ts index cf66bf23856b0..459bbe5baccc9 100644 --- a/ui/chat/src/spam.ts +++ b/ui/chat/src/spam.ts @@ -5,7 +5,7 @@ export const skip = (txt: string) => (suspLink(txt) || followMe(txt)) && !isKnow export const selfReport = (txt: string) => { if (isKnownSpammer()) return; const hasSuspLink = suspLink(txt); - if (hasSuspLink) xhr.text(`/jslog/${window.location.href.substr(-12)}?n=spam`, { method: 'post' }); + if (hasSuspLink) xhr.text(`/jslog/${window.location.href.slice(-12)}?n=spam`, { method: 'post' }); if (hasSuspLink || followMe(txt)) site.storage.set('chat-spam', '1'); }; diff --git a/ui/chat/tests/spam.test.ts b/ui/chat/tests/spam.test.ts new file mode 100644 index 0000000000000..1d43e1d0b5aa7 --- /dev/null +++ b/ui/chat/tests/spam.test.ts @@ -0,0 +1,25 @@ +import { expect, test, vi } from 'vitest'; +import { selfReport } from '../src/spam'; +import * as xhr from 'common/xhr'; + +test('self report', () => { + vi.stubGlobal('window', { location: { href: 'https://lichess.org/abcdef123456' } }); + + vi.stubGlobal('site', { + storage: { + set: (key: string, value: string) => { + expect(key).toBe('chat-spam'); + expect(value).toBe('1'); + }, + get: () => '0', + }, + }); + + const spy = vi.spyOn(xhr, 'text').mockImplementation((url: string, init?: RequestInit) => { + expect(url).toBe('/jslog/abcdef123456?n=spam'); + return Promise.resolve('ok'); + }); + + selfReport('check out bit.ly/spam'); + expect(spy).toHaveBeenCalled(); +}); diff --git a/ui/common/src/richText.ts b/ui/common/src/richText.ts index 0a9d44385904b..d037c7a11141d 100644 --- a/ui/common/src/richText.ts +++ b/ui/common/src/richText.ts @@ -6,7 +6,7 @@ import { VNode, Hooks } from 'snabbdom'; export const linkRegex = /(^|[\s\n]|<[A-Za-z]*\/?>)((?:(?:https?|ftp):\/\/|lichess\.org)[\-A-Z0-9+\u0026\u2019@#\/%?=()~_|!:,.;]*[\-A-Z0-9+\u0026@#\/%=~()_|])/gi; export const newLineRegex = /\n/g; -export const userPattern = /(^|[^\w@#/])@([a-z0-9][a-z0-9_-]{0,28}[a-z0-9])/gi; +export const userPattern = /(^|[^\w@#/])@([a-zA-Z0-9_-]{2,30})/gi; // looks like it has a @mention or #gameid or a url.tld export const isMoreThanText = (str: string) => /(\n|(@|#|\.)\w{2,}|(board|game) \d)/i.test(str); @@ -59,8 +59,8 @@ export function richHTML(text: string, newLines = true): Hooks { const linkPattern = /\b\b(?:https?:\/\/)?(lichess\.org\/[-–—\w+&'@#\/%?=()~|!:,.;]+[\w+&@#\/%=~|])/gi; const pawnDropPattern = /^[a-h][2-7]$/; -const movePattern = - /\b(\d+)\s*(\.+)\s*(?:[o0-]+[o0]|[NBRQKP\u2654\u2655\u2656\u2657\u2658\u2659]?[a-h]?[1-8]?[x@]?[a-z][1-8](?:=[NBRQK\u2654\u2655\u2656\u2657\u2658\u2659])?)\+?#?[!\?=]{0,5}/gi; +export const movePattern = + /\b(\d+)\s*(\.+)\s*(?:[o0-]+[o0]|[NBRQKP\u2654\u2655\u2656\u2657\u2658\u2659]?[a-h]?[1-8]?[x@]?[a-h][1-8](?:=[NBRQK\u2654\u2655\u2656\u2657\u2658\u2659])?)\+?#?[!\?=]{0,5}/gi; const boardPattern = /\b(?:board|game)\s(\d{1,2})/gi; function moveReplacer(match: string, turn: number, dots: string) { diff --git a/ui/common/tests/richText.test.ts b/ui/common/tests/richText.test.ts new file mode 100644 index 0000000000000..1abc3a98c49a8 --- /dev/null +++ b/ui/common/tests/richText.test.ts @@ -0,0 +1,31 @@ +import { describe, expect, test, vi } from 'vitest'; +import { movePattern, userPattern } from '../src/richText'; + +describe('test regex patterns', () => { + test('username mentions', () => { + expect('@foo'.match(userPattern)).toStrictEqual(['@foo']); + expect('@foo-'.match(userPattern)).toStrictEqual(['@foo-']); + expect('@__foo'.match(userPattern)).toStrictEqual(['@__foo']); + }); + + test.each([ + ['1.e4'], + ['1. e4'], + ['5...Nf6'], + ['5... Nf6'], + ['12.♔d1'], + ['10.O-O-O'], + ['10.o-o-o'], + ['10.0-0-0'], + ])('moves', move => { + expect(move.match(movePattern)).toStrictEqual([move]); + }); + + test('move with comment', () => { + expect('I considered 34. f7+ instead'.match(movePattern)).toStrictEqual(['34. f7+']); + }); + + test('not a move', () => { + expect('4.m3'.match(movePattern)).toBeNull(); + }); +}); diff --git a/ui/game/src/status.ts b/ui/game/src/status.ts index 44332623ee6cb..0e82af555f360 100644 --- a/ui/game/src/status.ts +++ b/ui/game/src/status.ts @@ -1,6 +1,6 @@ import { GameData } from './interfaces'; -// https://github.com/lichess-org/scalachess/blob/master/src/main/scala/Status.scala +// https://github.com/lichess-org/scalachess/blob/master/core/src/main/scala/Status.scala export const ids = { created: 10, diff --git a/ui/jest.config.js b/ui/jest.config.js deleted file mode 100644 index f83c256ad492d..0000000000000 --- a/ui/jest.config.js +++ /dev/null @@ -1,9 +0,0 @@ -/* eslint-env node */ -module.exports = { - testMatch: ['**/dist/**/*.test.js'], - testEnvironment: 'node', - transform: {}, - globals: { - site: {}, - }, -}; diff --git a/ui/keyboardMove/package.json b/ui/keyboardMove/package.json index 70b661488e72d..5af514527cb00 100644 --- a/ui/keyboardMove/package.json +++ b/ui/keyboardMove/package.json @@ -14,7 +14,6 @@ "author": "Thibault Duplessis", "license": "AGPL-3.0-or-later", "dependencies": { - "@jest/globals": "^29.7.0", "chess": "workspace:*", "common": "workspace:*", "game": "workspace:*", diff --git a/ui/keyboardMove/src/keyboardSubmit.test.ts b/ui/keyboardMove/tests/keyboardSubmit.test.ts similarity index 83% rename from ui/keyboardMove/src/keyboardSubmit.test.ts rename to ui/keyboardMove/tests/keyboardSubmit.test.ts index ddebe92f0ba31..16de93bf5a79d 100644 --- a/ui/keyboardMove/src/keyboardSubmit.test.ts +++ b/ui/keyboardMove/tests/keyboardSubmit.test.ts @@ -1,6 +1,6 @@ -import { jest, beforeEach, describe, expect, test } from '@jest/globals'; +import { beforeEach, describe, expect, test, vi } from 'vitest'; import { Prop, propWithEffect } from 'common'; -import { makeSubmit } from './keyboardSubmit'; +import { makeSubmit } from '../src/keyboardSubmit'; import { Dests, destsToUcis, sanWriter } from 'chess'; // Tips for working with this file: @@ -42,24 +42,18 @@ const defaultCtrl = { }; const defaultClear = unexpectedErrorThrower('clear'); -// we don't have access to DOM elements in jest (testEnvironment: 'node'), so we need to mock this -const input = { - value: '', - classList: { contains: () => false, toggle: () => {} }, -} as unknown as HTMLInputElement; - describe('keyboardSubmit', () => { - let mockClear = jest.fn(); + let mockClear = vi.fn(); beforeEach(() => { - mockClear = jest.fn(); + mockClear = vi.fn(); }); test('resigns game', () => { - const mockResign = jest.fn(); + const mockResign = vi.fn(); const submit = makeSubmit( { - input, + input: document.createElement('input'), ctrl: { ...defaultCtrl, resign: mockResign, @@ -75,10 +69,10 @@ describe('keyboardSubmit', () => { }); test('draws game', () => { - const mockDraw = jest.fn(); + const mockDraw = vi.fn(); const submit = makeSubmit( { - input, + input: document.createElement('input'), ctrl: { ...defaultCtrl, draw: mockDraw, @@ -94,10 +88,10 @@ describe('keyboardSubmit', () => { }); test('goes to next puzzle', () => { - const mockNext = jest.fn(); + const mockNext = vi.fn(); const submit = makeSubmit( { - input, + input: document.createElement('input'), ctrl: { ...defaultCtrl, next: mockNext, @@ -113,10 +107,10 @@ describe('keyboardSubmit', () => { }); test('up votes puzzle', () => { - const mockVote = jest.fn(); + const mockVote = vi.fn(); const submit = makeSubmit( { - input, + input: document.createElement('input'), ctrl: { ...defaultCtrl, vote: mockVote, @@ -133,10 +127,10 @@ describe('keyboardSubmit', () => { }); test('down votes puzzle', () => { - const mockVote = jest.fn(); + const mockVote = vi.fn(); const submit = makeSubmit( { - input, + input: document.createElement('input'), ctrl: { ...defaultCtrl, vote: mockVote, @@ -153,10 +147,10 @@ describe('keyboardSubmit', () => { }); test('reads out clock', () => { - const mockSpeakClock = jest.fn(); + const mockSpeakClock = vi.fn(); const submit = makeSubmit( { - input, + input: document.createElement('input'), ctrl: { ...defaultCtrl, speakClock: mockSpeakClock, @@ -172,10 +166,10 @@ describe('keyboardSubmit', () => { }); test('berserks a game', () => { - const mockGoBerserk = jest.fn(); + const mockGoBerserk = vi.fn(); const submit = makeSubmit( { - input, + input: document.createElement('input'), ctrl: { ...defaultCtrl, goBerserk: mockGoBerserk, @@ -190,11 +184,30 @@ describe('keyboardSubmit', () => { expect(mockClear).toHaveBeenCalledTimes(1); }); + test('speaks opponent name', () => { + vi.stubGlobal('site', { sound: { say: vi.fn() } }); + + const submit = makeSubmit( + { + input: document.createElement('input'), + ctrl: { + ...defaultCtrl, + opponent: 'opponent-name', + }, + }, + mockClear, + ); + + submit('who', { isTrusted: true }); + expect(site.sound.say).toHaveBeenCalledTimes(1); + expect(site.sound.say).toBeCalledWith('opponent-name', false, true); + }); + test('opens help modal with ?', () => { - const mockSetHelpModalOpen = jest.fn(); + const mockSetHelpModalOpen = vi.fn(); const submit = makeSubmit( { - input, + input: document.createElement('input'), ctrl: { ...defaultCtrl, helpModalOpen: mockSetHelpModalOpen as Prop, @@ -212,10 +225,10 @@ describe('keyboardSubmit', () => { describe('from starting position', () => { test('plays e4 via SAN', () => { - const mockSan = jest.fn(); + const mockSan = vi.fn(); const submit = makeSubmit( { - input, + input: document.createElement('input'), ctrl: { ...defaultCtrl, legalSans: fenDestsToSans(startingFen, { e2: ['e4'] }), @@ -233,10 +246,10 @@ describe('keyboardSubmit', () => { }); test('selects e2 via UCI', () => { - const mockSelect = jest.fn(); + const mockSelect = vi.fn(); const submit = makeSubmit( { - input, + input: document.createElement('input'), ctrl: { ...defaultCtrl, legalSans: fenDestsToSans(startingFen, { e2: ['e4'] }), @@ -254,11 +267,11 @@ describe('keyboardSubmit', () => { }); test('with e2 selected, plays e4 via UCI', () => { - const mockSan = jest.fn(); - const mockSelect = jest.fn(); + const mockSan = vi.fn(); + const mockSelect = vi.fn(); const submit = makeSubmit( { - input, + input: document.createElement('input'), ctrl: { ...defaultCtrl, legalSans: fenDestsToSans(startingFen, { e2: ['e4'] }), @@ -281,10 +294,10 @@ describe('keyboardSubmit', () => { }); test('selects e2 via ICCF', () => { - const mockSelect = jest.fn(); + const mockSelect = vi.fn(); const submit = makeSubmit( { - input, + input: document.createElement('input'), ctrl: { ...defaultCtrl, legalSans: fenDestsToSans(startingFen, { e2: ['e4'] }), @@ -302,11 +315,11 @@ describe('keyboardSubmit', () => { }); test('with e2 selected, plays e4 via ICCF', () => { - const mockSan = jest.fn(); - const mockSelect = jest.fn(); + const mockSan = vi.fn(); + const mockSelect = vi.fn(); const submit = makeSubmit( { - input, + input: document.createElement('input'), ctrl: { ...defaultCtrl, legalSans: fenDestsToSans(startingFen, { e2: ['e4'] }), @@ -333,10 +346,10 @@ describe('keyboardSubmit', () => { const ambiguousPawnBishopCapture = '4k3/8/8/8/8/2r5/1P1B4/4K3 w - - 0 1'; test('does pawn capture', () => { - const mockSan = jest.fn(); + const mockSan = vi.fn(); const submit = makeSubmit( { - input, + input: document.createElement('input'), ctrl: { ...defaultCtrl, legalSans: fenDestsToSans(ambiguousPawnBishopCapture, { b2: ['c3'], d2: ['c3'] }), @@ -355,10 +368,10 @@ describe('keyboardSubmit', () => { }); test('does bishop capture', () => { - const mockSan = jest.fn(); + const mockSan = vi.fn(); const submit = makeSubmit( { - input, + input: document.createElement('input'), ctrl: { ...defaultCtrl, legalSans: fenDestsToSans(ambiguousPawnBishopCapture, { b2: ['c3'], d2: ['c3'] }), @@ -382,7 +395,7 @@ describe('keyboardSubmit', () => { test('does not castle short', () => { const submit = makeSubmit( { - input, + input: document.createElement('input'), ctrl: { ...defaultCtrl, legalSans: fenDestsToSans(ambiguousCastlingFen, { e1: ['c1', 'g1'] }), @@ -397,10 +410,10 @@ describe('keyboardSubmit', () => { }); test('does castle long', () => { - const mockSan = jest.fn(); + const mockSan = vi.fn(); const submit = makeSubmit( { - input, + input: document.createElement('input'), ctrl: { ...defaultCtrl, legalSans: fenDestsToSans(ambiguousCastlingFen, { e1: ['c1', 'g1'] }), @@ -422,10 +435,10 @@ describe('keyboardSubmit', () => { const promotablePawnFen = 'r3k3/1P6/8/8/8/8/8/4K3 w - - 0 1'; test('with no piece specified does not promote by advancing', () => { - const mockPromote = jest.fn(); + const mockPromote = vi.fn(); const submit = makeSubmit( { - input, + input: document.createElement('input'), ctrl: { ...defaultCtrl, legalSans: fenDestsToSans(promotablePawnFen, { b7: ['a8', 'b8'] }), @@ -442,10 +455,10 @@ describe('keyboardSubmit', () => { }); test('with piece specified does promote by advancing', () => { - const mockPromote = jest.fn(); + const mockPromote = vi.fn(); const submit = makeSubmit( { - input, + input: document.createElement('input'), ctrl: { ...defaultCtrl, legalSans: fenDestsToSans(promotablePawnFen, { b7: ['a8', 'b8'] }), @@ -462,10 +475,10 @@ describe('keyboardSubmit', () => { }); test('with no piece specified does not promote by capturing', () => { - const mockPromote = jest.fn(); + const mockPromote = vi.fn(); const submit = makeSubmit( { - input, + input: document.createElement('input'), ctrl: { ...defaultCtrl, legalSans: fenDestsToSans(promotablePawnFen, { b7: ['a8', 'b8'] }), @@ -482,10 +495,10 @@ describe('keyboardSubmit', () => { }); test('with piece specified does promote by capturing', () => { - const mockPromote = jest.fn(); + const mockPromote = vi.fn(); const submit = makeSubmit( { - input, + input: document.createElement('input'), ctrl: { ...defaultCtrl, legalSans: fenDestsToSans(promotablePawnFen, { b7: ['a8', 'b8'] }), @@ -503,10 +516,10 @@ describe('keyboardSubmit', () => { describe('with pawn selected', () => { test('with no piece specified does not promote by advancing', () => { - const mockPromote = jest.fn(); + const mockPromote = vi.fn(); const submit = makeSubmit( { - input, + input: document.createElement('input'), ctrl: { ...defaultCtrl, legalSans: fenDestsToSans(promotablePawnFen, { b7: ['a8', 'b8'] }), @@ -524,10 +537,10 @@ describe('keyboardSubmit', () => { }); test('with piece specified does promote by advancing', () => { - const mockPromote = jest.fn(); + const mockPromote = vi.fn(); const submit = makeSubmit( { - input, + input: document.createElement('input'), ctrl: { ...defaultCtrl, legalSans: fenDestsToSans(promotablePawnFen, { b7: ['a8', 'b8'] }), @@ -545,10 +558,10 @@ describe('keyboardSubmit', () => { }); test('with no piece specified does not promote by capturing', () => { - const mockPromote = jest.fn(); + const mockPromote = vi.fn(); const submit = makeSubmit( { - input, + input: document.createElement('input'), ctrl: { ...defaultCtrl, legalSans: fenDestsToSans(promotablePawnFen, { b7: ['a8', 'b8'] }), @@ -566,10 +579,10 @@ describe('keyboardSubmit', () => { }); test('with piece specified does promote by capturing', () => { - const mockPromote = jest.fn(); + const mockPromote = vi.fn(); const submit = makeSubmit( { - input, + input: document.createElement('input'), ctrl: { ...defaultCtrl, legalSans: fenDestsToSans(promotablePawnFen, { b7: ['a8', 'b8'] }), @@ -590,10 +603,10 @@ describe('keyboardSubmit', () => { describe('in crazyhouse variant', () => { test('with incomplete crazyhouse entry does nothing', () => { - const mockDrop = jest.fn(); + const mockDrop = vi.fn(); const submit = makeSubmit( { - input, + input: document.createElement('input'), ctrl: { ...defaultCtrl, legalSans: fenDestsToSans(startingFen, { e2: ['e4'] }), @@ -610,10 +623,10 @@ describe('keyboardSubmit', () => { }); test('with complete crazyhouse entry does a drop', () => { - const mockDrop = jest.fn(); + const mockDrop = vi.fn(); const submit = makeSubmit( { - input, + input: document.createElement('input'), ctrl: { ...defaultCtrl, legalSans: fenDestsToSans(startingFen, { e2: ['e4'] }), @@ -631,8 +644,9 @@ describe('keyboardSubmit', () => { }); test('with incorrect entry marks it wrong', () => { - input.classList.toggle = jest.fn() as any; - site.sound = { play: jest.fn() } as any; + vi.stubGlobal('site', { sound: { play: vi.fn() } }); + + const input = document.createElement('input'); const submit = makeSubmit( { input, @@ -646,8 +660,8 @@ describe('keyboardSubmit', () => { submit('j4', { isTrusted: true }); - expect(input.classList.toggle).toHaveBeenCalledTimes(1); - expect(input.classList.toggle).toBeCalledWith('wrong', true); + expect(input.classList.contains('wrong')).toBe(true); expect(site.sound.play).toHaveBeenCalledTimes(1); + expect(site.sound.play).toBeCalledWith('error'); }); }); diff --git a/ui/package.json b/ui/package.json index 19906028729d8..80d6ca633c58d 100644 --- a/ui/package.json +++ b/ui/package.json @@ -9,10 +9,11 @@ "author": "Thibault Duplessis", "license": "AGPL-3.0-or-later", "dependencies": { - "@types/jest": "^29.5.12", - "jest": "^29.7.0" + "jsdom": "^24.1.0", + "vitest": "^1.6.0" }, "scripts": { - "test": "node --experimental-vm-modules node_modules/jest/bin/jest.js" + "test": "vitest run", + "test:watch": "vitest" } } diff --git a/ui/site/src/clockWidget.ts b/ui/site/src/clockWidget.ts index 0ac793b5e148b..fa721560fd68c 100644 --- a/ui/site/src/clockWidget.ts +++ b/ui/site/src/clockWidget.ts @@ -14,7 +14,7 @@ export default function (el: HTMLElement, opts: Opts) { class ClockWidget { target: number; - interval: number; + interval: Timeout; constructor( readonly el: HTMLElement, private opts: Opts, diff --git a/ui/site/src/log.ts b/ui/site/src/log.ts index c4802ee89c8c0..933060ff3ec83 100644 --- a/ui/site/src/log.ts +++ b/ui/site/src/log.ts @@ -44,7 +44,9 @@ export default function makeLog(): LichessLog { } const log: LichessLog = async (...args: any[]) => { - const msg = `#${site.info ? `${site.info.commit.substr(0, 7)} - ` : ''}${args.map(stringify).join(' ')}`; + const msg = `#${site.info ? `${site.info.commit.substring(0, 7)} - ` : ''}${args + .map(stringify) + .join(' ')}`; let nextKey = Date.now(); console.log(...args); if (nextKey === lastKey) { diff --git a/ui/site/src/once.ts b/ui/site/src/once.ts index 633208e0ed09b..757bc47eb8466 100644 --- a/ui/site/src/once.ts +++ b/ui/site/src/once.ts @@ -2,9 +2,8 @@ import { storage } from './storage'; export default function once(key: string, mod?: 'always' | undefined) { if (mod === 'always') return true; - if (!storage.get(key)) { - storage.set(key, '1'); - return true; - } - return false; + if (storage.get(key)) return false; + + storage.set(key, '1'); + return true; } diff --git a/ui/site/src/powertip.ts b/ui/site/src/powertip.ts index 8bf17d8d2353a..0abe0bec83ed5 100644 --- a/ui/site/src/powertip.ts +++ b/ui/site/src/powertip.ts @@ -245,7 +245,7 @@ function cssCoordinates(): Coords { class DisplayController { scoped: { [key: string]: any } = {}; - hoverTimer?: number; + hoverTimer?: Timeout; el: WithTooltip; constructor( diff --git a/ui/site/tests/once.test.ts b/ui/site/tests/once.test.ts new file mode 100644 index 0000000000000..b11a6d4cb7f3a --- /dev/null +++ b/ui/site/tests/once.test.ts @@ -0,0 +1,14 @@ +import { describe, expect, test } from 'vitest'; +import once from '../src/once'; + +describe('test once', () => { + test('once', () => { + expect(once('foo')).toBe(true); + + // subsequent calls should return false + expect(once('foo')).toBe(false); + expect(once('foo')).toBe(false); + + expect(once('foo', 'always')).toBe(true); + }); +}); diff --git a/ui/site/tests/timeago.test.ts b/ui/site/tests/timeago.test.ts new file mode 100644 index 0000000000000..5b81377c10646 --- /dev/null +++ b/ui/site/tests/timeago.test.ts @@ -0,0 +1,40 @@ +import { beforeEach, describe, expect, test, vi } from 'vitest'; + +describe('test formatter', () => { + beforeEach(() => { + vi.resetModules(); + }); + + test.each([ + ['en-US', 'Jan 1, 2024, 5:00 PM'], + ['en-UK', '1 Jan 2024, 17:00'], + ['fr', '1 janv. 2024, 17:00'], + ])('lang code formatting', async (lang, expected) => { + document.documentElement.lang = lang; + const formatter = await import('../src/timeago').then(m => m.formatter); + expect(formatter()(new Date(2024, 0, 1, 17, 0, 0))).toBe(expected); + }); + + test.each([ + ['ar-ae'], + ['ar-bh'], + ['ar-dz'], + ['ar-eg'], + ['ar-iq'], + ['ar-jo'], + ['ar-kw'], + ['ar-lb'], + ['ar-ly'], + ['ar-ma'], + ['ar-om'], + ['ar-qa'], + ['ar-sa'], + ['ar-sy'], + ['ar-tn'], + ['ar-ye'], + ])('arabic lang code uses the gregorian calendar', async lang => { + document.documentElement.lang = lang; + const formatter = await import('../src/timeago').then(m => m.formatter); + expect(formatter()(new Date(2024, 0, 1, 17, 0, 0))).toBe('1 يناير 2024، 5:00 م'); + }); +}); diff --git a/ui/vitest.config.ts b/ui/vitest.config.ts new file mode 100644 index 0000000000000..647a9e54c8c99 --- /dev/null +++ b/ui/vitest.config.ts @@ -0,0 +1,7 @@ +import { defineConfig } from 'vitest/config'; + +export default defineConfig({ + test: { + environment: 'jsdom', + }, +}); From 7571264bdc65c0c1e2885129055e22e6d995c6ae Mon Sep 17 00:00:00 2001 From: Thibault Duplessis Date: Fri, 14 Jun 2024 00:16:34 +0200 Subject: [PATCH 013/168] rename relay Plan --- modules/relay/src/main/RelaySync.scala | 2 +- modules/relay/src/main/RelayUpdatePlan.scala | 7 ++-- .../relay/src/test/RelayUpdatePlanTest.scala | 34 +++++++++---------- 3 files changed, 20 insertions(+), 23 deletions(-) diff --git a/modules/relay/src/main/RelaySync.scala b/modules/relay/src/main/RelaySync.scala index 0a89675098637..50b8ee4b7cc9f 100644 --- a/modules/relay/src/main/RelaySync.scala +++ b/modules/relay/src/main/RelaySync.scala @@ -20,7 +20,7 @@ final private class RelaySync( study <- studyApi.byId(rt.round.studyId).orFail("Missing relay study!") chapters <- chapterRepo.orderedByStudyLoadingAllInMemory(study.id) games = RelayInputSanity.fixGames(rawGames) - plan = RelayUpdatePlan(chapters, games).output + plan = RelayUpdatePlan(chapters, games) _ <- plan.reorder.so(studyApi.sortChapters(study.id, _)(who(study.ownerId))) updates <- plan.update.sequentially: (chapter, game) => updateChapter(rt.tour, study, game, chapter) diff --git a/modules/relay/src/main/RelayUpdatePlan.scala b/modules/relay/src/main/RelayUpdatePlan.scala index b62fca9e87c87..5e9b1df8de182 100644 --- a/modules/relay/src/main/RelayUpdatePlan.scala +++ b/modules/relay/src/main/RelayUpdatePlan.scala @@ -9,7 +9,7 @@ object RelayUpdatePlan: override def toString: String = s"Input(chapters = ${chapters.map(_.name)}, games = ${games.map(_.tags.names)})" - case class Output( + case class Plan( reorder: Option[List[StudyChapterId]], update: List[(Chapter, RelayGame)], append: RelayGames @@ -17,8 +17,6 @@ object RelayUpdatePlan: override def toString: String = s"Output(reorder = $reorder, update = ${update.map(_._1.name)}, append = ${append.map(_.tags.names)})" - case class Plan(input: Input, output: Output) - def apply(chapters: List[Chapter], games: RelayGames): Plan = apply(Input(chapters, games)) @@ -52,9 +50,8 @@ object RelayUpdatePlan: val ids = updates.map(_._1.id) Option.when(ids.size == chapters.size && ids != chapters.map(_.id))(ids) - val output = Output( + Plan( reorder = reorder, update = updates, append = appends ) - Plan(input, output) diff --git a/modules/relay/src/test/RelayUpdatePlanTest.scala b/modules/relay/src/test/RelayUpdatePlanTest.scala index 2e96615c59954..12d742f863d7a 100644 --- a/modules/relay/src/test/RelayUpdatePlanTest.scala +++ b/modules/relay/src/test/RelayUpdatePlanTest.scala @@ -7,84 +7,84 @@ class RelayUpdatePlanTest extends munit.FunSuite: import RelayPlanUpdateFixtures.* - def output(input: Input)(check: PartialFunction[Output, Unit]): Unit = - val out = RelayUpdatePlan(input).output + def output(input: Input)(check: PartialFunction[Plan, Unit]): Unit = + val out = RelayUpdatePlan(input) check.applyOrElse(out, _ => fail(s"Unexpected output: $out")) test("add no game to empty relay"): - assertEquals(RelayUpdatePlan(Input(Nil, games.take(0))).output, Output(None, Nil, Vector.empty)) + assertEquals(RelayUpdatePlan(Input(Nil, games.take(0))), Plan(None, Nil, Vector.empty)) test("add one game to empty relay"): output(Input(Nil, games.take(1))): - case Output(None, Nil, append) => assertEquals(append, games.take(1)) + case Plan(None, Nil, append) => assertEquals(append, games.take(1)) test("add all games to empty relay"): output(Input(Nil, games)): - case Output(None, Nil, append) => assertEquals(append, games) + case Plan(None, Nil, append) => assertEquals(append, games) test("add no game to relay with initial chapter"): assertEquals( - RelayUpdatePlan(Input(List(initialChapter), games.take(0))).output, - Output(None, Nil, Vector.empty) + RelayUpdatePlan(Input(List(initialChapter), games.take(0))), + Plan(None, Nil, Vector.empty) ) test("add one game to relay with initial chapter"): output(Input(List(initialChapter), games.take(1))): - case Output(None, update, Vector()) => + case Plan(None, update, Vector()) => assertEquals(update, List(initialChapter -> games(0))) test("add all games to relay with initial chapter"): output(Input(List(initialChapter), games)): - case Output(None, update, append) => + case Plan(None, update, append) => assertEquals(update, List(initialChapter -> games(0))) assertEquals(append, games.drop(1)) test("1 chapter, 1 game, matching tags"): output(Input(chapters.take(1), games.take(1))): - case Output(None, update, append) => + case Plan(None, update, append) => assertEquals(update, List(chapters(0) -> games(0))) assert(append.isEmpty) test("1 chapter, 1 game, not matching tags"): output(Input(chapters.take(1), games.drop(1).take(1))): - case Output(None, Nil, append) => assertEquals(append, games.drop(1).take(1)) + case Plan(None, Nil, append) => assertEquals(append, games.drop(1).take(1)) test("1 chapter, 5 games, first matching tags"): output(Input(chapters.take(1), games)): - case Output(None, update, append) => + case Plan(None, update, append) => assertEquals(update, List(chapters(0) -> games(0))) assertEquals(append, games.drop(1)) test("5 chapters, 5 games, matching tags"): output(Input(chapters, games)): - case Output(None, update, append) => + case Plan(None, update, append) => assertEquals(update, chapters.zip(games)) assert(append.isEmpty) test("2 chapters, 2 games, reverse order"): val in = Input(chapters.take(2), games.take(2).reverse) output(in): - case Output(reorder, update, Vector()) => + case Plan(reorder, update, Vector()) => assertEquals(update, in.chapters.reverse.zip(in.games)) assertEquals(reorder, in.chapters.reverse.map(_.id).some) test("5 chapters, 5 games, reverse order"): val in = Input(chapters, games.reverse) output(in): - case Output(Some(reorder), update, Vector()) => + case Plan(Some(reorder), update, Vector()) => assertEquals(update, in.chapters.reverse.zip(in.games)) assertEquals(reorder, in.chapters.reverse.map(_.id)) test("5 chapters, 2 games, reverse order"): output(Input(chapters, games.take(2).reverse)): - case Output(None, update, Vector()) => + case Plan(None, update, Vector()) => assertEquals(update, List(chapters(1) -> games(1), chapters(0) -> games(0))) test("2 chapters, 3 games, reverse order"): // A B, C B A val in = Input(chapters.take(2), games.take(3).reverse) output(in): - case Output(Some(reorder), update, append) => + case Plan(Some(reorder), update, append) => assertEquals(update, List(chapters(1) -> games(1), chapters(0) -> games(0))) assertEquals(reorder, in.chapters.reverse.map(_.id)) assertEquals(append, Vector(games(2))) From 8a53bf8660938849ecbba40c002073823338cc51 Mon Sep 17 00:00:00 2001 From: Thibault Duplessis Date: Fri, 14 Jun 2024 08:56:47 +0200 Subject: [PATCH 014/168] use scss variables --- ui/tree/css/_tree.scss | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/ui/tree/css/_tree.scss b/ui/tree/css/_tree.scss index 9819ef30d6b1c..aac5fed98067a 100644 --- a/ui/tree/css/_tree.scss +++ b/ui/tree/css/_tree.scss @@ -374,11 +374,11 @@ } line.expand > a { - color: var(--c-font-dim); + color: $c-font-dim; } line.expand > a:hover { - color: var(--c-font); + color: $c-font; } inline { From 5ef62f45a3d6322152b42b91000e02a8c0c1eb8d Mon Sep 17 00:00:00 2001 From: Ben Olden-Cooligan Date: Fri, 14 Jun 2024 00:30:55 -0700 Subject: [PATCH 015/168] Don't render collapsed nodes (instead of just hiding) --- ui/analyse/src/treeView/columnView.ts | 39 ++++++++++++++------------- ui/analyse/src/treeView/inlineView.ts | 37 ++++++++++++------------- ui/tree/css/_tree.scss | 8 ------ 3 files changed, 39 insertions(+), 45 deletions(-) diff --git a/ui/analyse/src/treeView/columnView.ts b/ui/analyse/src/treeView/columnView.ts index 2dee229521913..472b62c93dd46 100644 --- a/ui/analyse/src/treeView/columnView.ts +++ b/ui/analyse/src/treeView/columnView.ts @@ -114,7 +114,9 @@ function renderInlined(ctx: Ctx, nodes: Tree.Node[], opts: Opts): LooseVNodes | function renderLines(ctx: Ctx, parentNode: Tree.Node, nodes: Tree.Node[], opts: Opts): VNode { const collapsed = parentNode.collapsed === undefined ? opts.depth >= 2 && opts.depth % 2 === 0 : parentNode.collapsed; - return h('lines', { class: { single: !nodes[1], collapsed } }, [ + return h( + 'lines', + { class: { single: !nodes[1], collapsed } }, collapsed ? h('line', { class: { expand: true } }, [ h('branch'), @@ -123,24 +125,23 @@ function renderLines(ctx: Ctx, parentNode: Tree.Node, nodes: Tree.Node[], opts: on: { click: () => ctx.ctrl.setCollapsed(opts.parentPath, false) }, }), ]) - : null, - ...nodes.map(n => { - return ( - retroLine(ctx, n) || - h('line', [ - h('branch'), - ...renderMoveAndChildrenOf(ctx, n, { - parentPath: opts.parentPath, - isMainline: false, - depth: opts.depth + 1, - withIndex: true, - noConceal: opts.noConceal, - truncate: n.comp && !treePath.contains(ctx.ctrl.path, opts.parentPath + n.id) ? 3 : undefined, - }), - ]) - ); - }), - ]); + : nodes.map(n => { + return ( + retroLine(ctx, n) || + h('line', [ + h('branch'), + ...renderMoveAndChildrenOf(ctx, n, { + parentPath: opts.parentPath, + isMainline: false, + depth: opts.depth + 1, + withIndex: true, + noConceal: opts.noConceal, + truncate: n.comp && !treePath.contains(ctx.ctrl.path, opts.parentPath + n.id) ? 3 : undefined, + }), + ]) + ); + }), + ); } function renderMoveOf(ctx: Ctx, node: Tree.Node, opts: Opts): VNode { diff --git a/ui/analyse/src/treeView/inlineView.ts b/ui/analyse/src/treeView/inlineView.ts index 5b81597411a34..13cdf38f62fe9 100644 --- a/ui/analyse/src/treeView/inlineView.ts +++ b/ui/analyse/src/treeView/inlineView.ts @@ -71,7 +71,9 @@ function renderInlined(ctx: Ctx, nodes: Tree.Node[], opts: Opts): MaybeVNodes | function renderLines(ctx: Ctx, parentNode: Tree.Node, nodes: Tree.Node[], opts: Opts): VNode { const collapsed = parentNode.collapsed === undefined ? opts.depth >= 2 && opts.depth % 2 === 0 : parentNode.collapsed; - return h('lines', { class: { collapsed } }, [ + return h( + 'lines', + { class: { collapsed } }, collapsed ? h('line', { class: { expand: true } }, [ h('branch'), @@ -80,23 +82,22 @@ function renderLines(ctx: Ctx, parentNode: Tree.Node, nodes: Tree.Node[], opts: on: { click: () => ctx.ctrl.setCollapsed(opts.parentPath, false) }, }), ]) - : null, - ...nodes.map(n => { - return ( - retroLine(ctx, n) || - h('line', [ - h('branch'), - ...renderMoveAndChildrenOf(ctx, n, { - parentPath: opts.parentPath, - isMainline: false, - depth: opts.depth + 1, - withIndex: true, - truncate: n.comp && !treePath.contains(ctx.ctrl.path, opts.parentPath + n.id) ? 3 : undefined, - }), - ]) - ); - }), - ]); + : nodes.map(n => { + return ( + retroLine(ctx, n) || + h('line', [ + h('branch'), + ...renderMoveAndChildrenOf(ctx, n, { + parentPath: opts.parentPath, + isMainline: false, + depth: opts.depth + 1, + withIndex: true, + truncate: n.comp && !treePath.contains(ctx.ctrl.path, opts.parentPath + n.id) ? 3 : undefined, + }), + ]) + ); + }), + ); } function renderMoveAndChildrenOf(ctx: Ctx, node: Tree.Node, opts: Opts): MaybeVNodes { diff --git a/ui/tree/css/_tree.scss b/ui/tree/css/_tree.scss index aac5fed98067a..406581eeb43db 100644 --- a/ui/tree/css/_tree.scss +++ b/ui/tree/css/_tree.scss @@ -365,14 +365,6 @@ margin-bottom: 0; } - lines.collapsed > * { - display: none; - } - - lines.collapsed > line.expand { - display: block; - } - line.expand > a { color: $c-font-dim; } From b94531f5674ae930d87c6d15a806a0428596e404 Mon Sep 17 00:00:00 2001 From: Thibault Duplessis Date: Fri, 14 Jun 2024 11:07:28 +0200 Subject: [PATCH 016/168] fide player not found page - closes #15457 --- app/controllers/Fide.scala | 18 +++++++++++------- app/views/fide.scala | 9 ++++----- modules/fide/src/main/ui/FideUi.scala | 24 ++++++++++++++++++++++++ 3 files changed, 39 insertions(+), 12 deletions(-) diff --git a/app/controllers/Fide.scala b/app/controllers/Fide.scala index 04f652a4d5e1a..e2704d8d9b410 100644 --- a/app/controllers/Fide.scala +++ b/app/controllers/Fide.scala @@ -22,13 +22,17 @@ final class Fide(env: Env) extends LilaController(env): yield Ok(renderedPage) def show(id: chess.FideId, slug: String, page: Int) = Open: - Found(env.fide.repo.player.fetch(id)): player => - if player.slug != slug then Redirect(routes.Fide.show(id, player.slug)) - else - for - tours <- env.relay.playerTour.playerTours(player, page) - rendered <- renderPage(views.fide.player.show(player, tours)) - yield Ok(rendered) + env.fide.repo.player + .fetch(id) + .flatMap: + case None => NotFound.page(views.fide.player.notFound(id)) + case Some(player) => + if player.slug != slug then Redirect(routes.Fide.show(id, player.slug)) + else + for + tours <- env.relay.playerTour.playerTours(player, page) + rendered <- renderPage(views.fide.player.show(player, tours)) + yield Ok(rendered) def federations(page: Int) = Open: for diff --git a/app/views/fide.scala b/app/views/fide.scala index dbfd78573a19e..18d32b8bffe3c 100644 --- a/app/views/fide.scala +++ b/app/views/fide.scala @@ -10,13 +10,12 @@ lazy val ui = lila.fide.ui.FideUi(helpers)(active => Context ?=> views.relay.tou export ui.federation object player: - export ui.player.index + export ui.player.{ index, notFound } def show(player: FidePlayer, tours: Paginator[RelayTour.WithLastRound])(using Context) = ui.player.show( player, - (tours.nbResults > 0).option( - views.relay.tour.renderPager(views.relay.tour.asRelayPager(tours)): page => - routes.Fide.show(player.id, player.slug, page) - ) + (tours.nbResults > 0).option: + views.relay.tour.renderPager(views.relay.tour.asRelayPager(tours)): + routes.Fide.show(player.id, player.slug, _) ) diff --git a/modules/fide/src/main/ui/FideUi.scala b/modules/fide/src/main/ui/FideUi.scala index 67147eb4c1460..83b0707dd95b0 100644 --- a/modules/fide/src/main/ui/FideUi.scala +++ b/modules/fide/src/main/ui/FideUi.scala @@ -111,6 +111,30 @@ final class FideUi(helpers: Helpers)(menu: String => Context ?=> Frag): playerList(players, np => routes.Fide.index(np, query.some.filter(_.nonEmpty))) ) + def notFound(id: chess.FideId)(using Context) = + page("FIDE player not found", "players")( + cls := "fide-players", + boxTop( + h1("FIDE player not found"), + div(cls := "box__top__actions"): + searchForm("") + ), + div(cls := "box__pad")( + p( + "We could not find anyone with the FIDE ID \"", + strong(id), + "\", please make sure the number is correct." + ), + p( + "If the player appears on the ", + a(href := "https://ratings.fide.com/", targetBlank)("official FIDE website"), + ", then the player was not included in the latest rating export from FIDE.", + br, + "FIDE exports are provided once a month and includes players who have at least one official rating." + ) + ) + ) + def searchForm(q: String) = st.form(cls := "fide-players__search-form", action := routes.Fide.index(1), method := "get")( input( From 553c67cb50bd04c5f8186078f77d86ed344fb7ed Mon Sep 17 00:00:00 2001 From: Thibault Duplessis Date: Fri, 14 Jun 2024 11:11:01 +0200 Subject: [PATCH 017/168] New Crowdin updates (#15490) * New translations: site.xml (Persian) * New translations: learn.xml (Bengali) * New translations: coordinates.xml (Russian) * New translations: coordinates.xml (Chinese Simplified) * New translations: arena.xml (Swiss German) * New translations: site.xml (English, United States) * New translations: lag.xml (English, United States) --- translation/dest/arena/gsw-CH.xml | 6 +++--- translation/dest/coordinates/ru-RU.xml | 1 + translation/dest/coordinates/zh-CN.xml | 1 + translation/dest/lag/en-US.xml | 2 +- translation/dest/learn/bn-BD.xml | 4 ++-- translation/dest/site/en-US.xml | 8 ++++---- translation/dest/site/fa-IR.xml | 4 ++-- 7 files changed, 14 insertions(+), 12 deletions(-) diff --git a/translation/dest/arena/gsw-CH.xml b/translation/dest/arena/gsw-CH.xml index df7e485c61591..0e803538cbd62 100644 --- a/translation/dest/arena/gsw-CH.xml +++ b/translation/dest/arena/gsw-CH.xml @@ -57,7 +57,7 @@ Wer schnäll schpillt und sofort zrugg id Turnierübersicht gaht, hät meh Schpi Lass d\'Schpiller ime Chatruum diskutiere Arena Sieges Serie Nach 2 Sieg in Serie gits 4 Pünkt anstatt 2. - Berserk nöd möglich + Berserk nöd erlaubt Kei Arena-Serie Durchschnittlichi Leischtig Durchschnittlichi Punktzahl @@ -80,8 +80,8 @@ Bischpil: Rang 3 ime Turnier mit 100 Schpiler = 3% oder Rang 10 bi 1000 Schpiler All Durchschnittswert uf dere Site sind %s. Total Punktedurchschnitt - Azahl Pünkt - Rang - Durchschnitt + Azahl Pünkt + Rang - Durchschnitt Turnier - Sieger Turnier - Schilder Nur Schpiler mit Titel diff --git a/translation/dest/coordinates/ru-RU.xml b/translation/dest/coordinates/ru-RU.xml index d21b68ad390e2..25db548b72e3d 100644 --- a/translation/dest/coordinates/ru-RU.xml +++ b/translation/dest/coordinates/ru-RU.xml @@ -13,6 +13,7 @@ У вас есть 30 секунд на то, чтобы правильно отметить как можно больше полей! Продвиньтесь так далеко, как сможете. Время не ограничено! Показывать координаты + Координаты на каждом поле Показывать фигуры Начать тренировку Найти поле diff --git a/translation/dest/coordinates/zh-CN.xml b/translation/dest/coordinates/zh-CN.xml index 5e78dbcde088e..215243eb3e570 100644 --- a/translation/dest/coordinates/zh-CN.xml +++ b/translation/dest/coordinates/zh-CN.xml @@ -13,6 +13,7 @@ 您有30秒时间正确配对尽可能多的棋格。 没有时间限制，尽情练习吧！ 显示坐标 + 在每个格子上显示坐标 显示棋子 开始训练 找格子 diff --git a/translation/dest/lag/en-US.xml b/translation/dest/lag/en-US.xml index 828a6ba2f9d20..ab6af8b78b00d 100644 --- a/translation/dest/lag/en-US.xml +++ b/translation/dest/lag/en-US.xml @@ -7,7 +7,7 @@ Yes. It will be fixed soon! And now, the long answer! Game lag is composed of two unrelated values (lower is better): Lichess server latency - The time it takes to process a move on the server. It is the same for everybody, and only depends on the server load. The more players and the higher it gets, but Lichess developers do their best to keep it low. It rarely exceeds 10ms. + The time it takes to process a move on the server. It is the same for everybody, and only depends on the server load. The more players, the higher it gets, but Lichess developers do their best to keep it low. It rarely exceeds 10ms. Network between Lichess and you The time it takes to send a move from your computer to Lichess server, and get the response back. It\'s specific to your distance to Lichess (France) as well as the quality of your Internet connection. Lichess developers cannot fix your wifi or make light go faster. You can find both these values at any time, by clicking your username in the top bar. diff --git a/translation/dest/learn/bn-BD.xml b/translation/dest/learn/bn-BD.xml index 099628fb2c943..df7563ce67dd3 100644 --- a/translation/dest/learn/bn-BD.xml +++ b/translation/dest/learn/bn-BD.xml @@ -7,9 +7,9 @@ আমার অগ্রগতি রিসেট হোক আপনি আপনার সকল অগ্রগতি হারাবেন! খেলুন! - দাবার টুকরা + দাবার ঘুটি নৌকা - এটা সোজা রেখা গুলোতে সরান + এটা সোজাসুজি (সোজা রেখার মতো) যায় দাবার নৌকা হয় একটি শক্তিশালী টুকরা. এটাকে নির্দেশ দিতে আপনি কি প্রস্তুত? তারায় নিয়ে আসতে নৌকায় ক্লিক করুন! সকল তারা দখল করুন! diff --git a/translation/dest/site/en-US.xml b/translation/dest/site/en-US.xml index 806e22f8e97a8..bbcb425b17843 100644 --- a/translation/dest/site/en-US.xml +++ b/translation/dest/site/en-US.xml @@ -223,8 +223,8 @@ You are leaving Lichess Never type your Lichess password on another site! Proceed to %s - Do not set a password suggested by someone else. They could use it to steal your account. - Do not set an email address suggested by someone else. They could use it to steal your account. + Do not set a password suggested by someone else. They will use it to steal your account. + Do not set an email address suggested by someone else. They will use it to steal your account. Help with email confirmation Didn\'t receive your confirmation email after signing up? What username did you use to sign up? @@ -233,10 +233,10 @@ We have sent an email to %s. It can take some time to arrive. Wait 5 minutes and refresh your email inbox. - If you do not receive a confirmation email, check your spam folder. Be sure to indicate messages from Xxxxx as \'safe\' so you can stay informed of important communication. + Also check your spam folder, it might end up there. If so, mark it as not spam. If you still have questions, please send us an email: Copy and paste the above text and send it to %s - We will be back with you shortly to help complete your signup process. + We will come back to you shortly to help you complete your signup. The user %s is successfully confirmed. You can login right now as %s. You do not need a confirmation email. diff --git a/translation/dest/site/fa-IR.xml b/translation/dest/site/fa-IR.xml index cae1141a4a3ad..e16aacef370da 100644 --- a/translation/dest/site/fa-IR.xml +++ b/translation/dest/site/fa-IR.xml @@ -147,8 +147,8 @@ پیشنهاد مساوی مساوی - %s نفر بازیکن آنلاین - %s نفر بازیکن آنلاین + %s بازیکن + %s بازیکن تساوی با توافق طرفین قانون ۵۰ حرکت From 5321ff3f7a30cbe0afc8c1d60582e100a747a494 Mon Sep 17 00:00:00 2001 From: Vincent Velociter Date: Fri, 14 Jun 2024 11:33:24 +0200 Subject: [PATCH 018/168] Add mobile scope to more challenge api endpoints --- app/controllers/Challenge.scala | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/app/controllers/Challenge.scala b/app/controllers/Challenge.scala index 6ef5fea5ec0bd..78aa8761188a3 100644 --- a/app/controllers/Challenge.scala +++ b/app/controllers/Challenge.scala @@ -26,7 +26,7 @@ final class Challenge( api.allFor(me).map(env.challenge.jsonView.apply).map(JsonOk) } - def apiList = ScopedBody(_.Challenge.Read) { ctx ?=> me ?=> + def apiList = ScopedBody(_.Challenge.Read, _.Web.Mobile) { ctx ?=> me ?=> api.allFor(me, 300).map { all => JsonOk: Json.obj( @@ -39,7 +39,7 @@ final class Challenge( def show(id: ChallengeId, _color: Option[Color]) = Open: showId(id) - def apiShow(id: ChallengeId) = Scoped(_.Challenge.Read) { ctx ?=> _ ?=> + def apiShow(id: ChallengeId) = Scoped(_.Challenge.Read, _.Web.Mobile) { ctx ?=> _ ?=> Found(api.byId(id)): c => val direction: Option[Direction] = if isMine(c) then Direction.Out.some @@ -125,7 +125,7 @@ final class Challenge( ) def apiAccept(id: ChallengeId) = - Scoped(_.Challenge.Write, _.Bot.Play, _.Board.Play) { _ ?=> me ?=> + Scoped(_.Challenge.Write, _.Bot.Play, _.Board.Play, _.Web.Mobile) { _ ?=> me ?=> def tryRematch = env.bot.player.rematchAccept(id.into(GameId)).flatMap { if _ then jsonOkResult @@ -173,7 +173,7 @@ final class Challenge( ) .inject(NoContent) } - def apiDecline(id: ChallengeId) = ScopedBody(_.Challenge.Write, _.Bot.Play, _.Board.Play) { ctx ?=> me ?=> + def apiDecline(id: ChallengeId) = ScopedBody(_.Challenge.Write, _.Bot.Play, _.Board.Play, _.Web.Mobile) { ctx ?=> me ?=> api.activeByIdFor(id, me).flatMap { case None => env.bot.player.rematchDecline(id.into(GameId)).flatMap { @@ -195,7 +195,7 @@ final class Challenge( then api.cancel(c).inject(NoContent) else notFound - def apiCancel(id: ChallengeId) = Scoped(_.Challenge.Write, _.Bot.Play, _.Board.Play) { ctx ?=> me ?=> + def apiCancel(id: ChallengeId) = Scoped(_.Challenge.Write, _.Bot.Play, _.Board.Play, _.Web.Mobile) { ctx ?=> me ?=> api.activeByIdBy(id, me).flatMap { case Some(c) => api.cancel(c).inject(jsonOkResult) case None => From 6dd7dffb711726dadc614873fdb8a0f7a53bd4fa Mon Sep 17 00:00:00 2001 From: Vincent Velociter Date: Fri, 14 Jun 2024 11:42:59 +0200 Subject: [PATCH 019/168] Fix format --- app/controllers/Challenge.scala | 110 ++++++++++++++++---------------- 1 file changed, 56 insertions(+), 54 deletions(-) diff --git a/app/controllers/Challenge.scala b/app/controllers/Challenge.scala index 78aa8761188a3..04adf129889d5 100644 --- a/app/controllers/Challenge.scala +++ b/app/controllers/Challenge.scala @@ -173,19 +173,20 @@ final class Challenge( ) .inject(NoContent) } - def apiDecline(id: ChallengeId) = ScopedBody(_.Challenge.Write, _.Bot.Play, _.Board.Play, _.Web.Mobile) { ctx ?=> me ?=> - api.activeByIdFor(id, me).flatMap { - case None => - env.bot.player.rematchDecline(id.into(GameId)).flatMap { - if _ then jsonOkResult - else notFoundJson() - } - case Some(c) => - bindForm(env.challenge.forms.decline)( - jsonFormError, - data => api.decline(c, data.realReason).inject(jsonOkResult) - ) - } + def apiDecline(id: ChallengeId) = ScopedBody(_.Challenge.Write, _.Bot.Play, _.Board.Play, _.Web.Mobile) { + ctx ?=> me ?=> + api.activeByIdFor(id, me).flatMap { + case None => + env.bot.player.rematchDecline(id.into(GameId)).flatMap { + if _ then jsonOkResult + else notFoundJson() + } + case Some(c) => + bindForm(env.challenge.forms.decline)( + jsonFormError, + data => api.decline(c, data.realReason).inject(jsonOkResult) + ) + } } def cancel(id: ChallengeId) = @@ -195,49 +196,50 @@ final class Challenge( then api.cancel(c).inject(NoContent) else notFound - def apiCancel(id: ChallengeId) = Scoped(_.Challenge.Write, _.Bot.Play, _.Board.Play, _.Web.Mobile) { ctx ?=> me ?=> - api.activeByIdBy(id, me).flatMap { - case Some(c) => api.cancel(c).inject(jsonOkResult) - case None => - api.activeByIdFor(id, me).flatMap { - case Some(c) => api.decline(c, ChallengeModel.DeclineReason.default).inject(jsonOkResult) - case None => - import lila.core.misc.map.Tell - import lila.core.round.Abort - import lila.core.round.AbortForce - env.game.gameRepo - .game(id.into(GameId)) - .dmap { - _.flatMap { Pov(_, me) } - } - .flatMapz { p => - env.round.proxyRepo.upgradeIfPresent(p).dmap(some) - } - .flatMap { - case Some(pov) if pov.game.abortableByUser => - lila.common.Bus.publish(Tell(id.value, Abort(pov.playerId)), "roundSocket") - jsonOkResult - case Some(pov) if pov.game.playable => - Bearer.from(get("opponentToken")) match - case Some(bearer) => - val required = OAuthScope.select(_.Challenge.Write).into(EndpointScopes) - env.oAuth.server.auth(bearer, required, ctx.req.some).map { - case Right(access) if pov.opponent.isUser(access.me) => + def apiCancel(id: ChallengeId) = Scoped(_.Challenge.Write, _.Bot.Play, _.Board.Play, _.Web.Mobile) { + ctx ?=> me ?=> + api.activeByIdBy(id, me).flatMap { + case Some(c) => api.cancel(c).inject(jsonOkResult) + case None => + api.activeByIdFor(id, me).flatMap { + case Some(c) => api.decline(c, ChallengeModel.DeclineReason.default).inject(jsonOkResult) + case None => + import lila.core.misc.map.Tell + import lila.core.round.Abort + import lila.core.round.AbortForce + env.game.gameRepo + .game(id.into(GameId)) + .dmap { + _.flatMap { Pov(_, me) } + } + .flatMapz { p => + env.round.proxyRepo.upgradeIfPresent(p).dmap(some) + } + .flatMap { + case Some(pov) if pov.game.abortableByUser => + lila.common.Bus.publish(Tell(id.value, Abort(pov.playerId)), "roundSocket") + jsonOkResult + case Some(pov) if pov.game.playable => + Bearer.from(get("opponentToken")) match + case Some(bearer) => + val required = OAuthScope.select(_.Challenge.Write).into(EndpointScopes) + env.oAuth.server.auth(bearer, required, ctx.req.some).map { + case Right(access) if pov.opponent.isUser(access.me) => + lila.common.Bus.publish(Tell(id.value, AbortForce), "roundSocket") + jsonOkResult + case Right(_) => BadRequest(jsonError("Not the opponent token")) + case Left(err) => BadRequest(jsonError(err.message)) + } + case None if api.isOpenBy(id, me) => + if pov.game.abortable then lila.common.Bus.publish(Tell(id.value, AbortForce), "roundSocket") jsonOkResult - case Right(_) => BadRequest(jsonError("Not the opponent token")) - case Left(err) => BadRequest(jsonError(err.message)) - } - case None if api.isOpenBy(id, me) => - if pov.game.abortable then - lila.common.Bus.publish(Tell(id.value, AbortForce), "roundSocket") - jsonOkResult - else BadRequest(jsonError("The game can no longer be aborted")) - case None => BadRequest(jsonError("Missing opponentToken")) - case _ => notFoundJson() - } - } - } + else BadRequest(jsonError("The game can no longer be aborted")) + case None => BadRequest(jsonError("Missing opponentToken")) + case _ => notFoundJson() + } + } + } } def apiStartClocks(id: GameId) = Anon: From 232eed23bcf429571f2f8f35407d4c2508d25875 Mon Sep 17 00:00:00 2001 From: Thibault Duplessis Date: Fri, 14 Jun 2024 14:21:16 +0200 Subject: [PATCH 020/168] smoother transitions during layout switch --- ui/bits/css/user/_sub-rating.scss | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/ui/bits/css/user/_sub-rating.scss b/ui/bits/css/user/_sub-rating.scss index 2264ecdaab299..dacb734627a5b 100644 --- a/ui/bits/css/user/_sub-rating.scss +++ b/ui/bits/css/user/_sub-rating.scss @@ -6,7 +6,7 @@ white-space: nowrap; - @include transition; + @include transition(background); &.empty { opacity: 0.5; @@ -17,7 +17,9 @@ opacity: 0.5; margin-inline-end: 0.2em; - @include transition; + transition: + opacity $transition-duration, + color $transition-duration; } &[href=''] { From 58398cf4be77824cd1256264ef6efbb4016de80d Mon Sep 17 00:00:00 2001 From: Thibault Duplessis Date: Fri, 14 Jun 2024 14:23:41 +0200 Subject: [PATCH 021/168] fix transitions --- ui/bits/css/coach/_editor.scss | 2 +- ui/bits/css/team/_list.scss | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/ui/bits/css/coach/_editor.scss b/ui/bits/css/coach/_editor.scss index b924e061d30bc..31af0981bd6ba 100644 --- a/ui/bits/css/coach/_editor.scss +++ b/ui/bits/css/coach/_editor.scss @@ -107,7 +107,7 @@ .status { opacity: 0; - @include transition(); + @include transition; text-align: center; color: $c-good; } diff --git a/ui/bits/css/team/_list.scss b/ui/bits/css/team/_list.scss index fa75daa12a062..a33cc23d17b3b 100644 --- a/ui/bits/css/team/_list.scss +++ b/ui/bits/css/team/_list.scss @@ -35,12 +35,12 @@ .team__quit { opacity: 0; - @include transition(0.1s); + transition: opacity 0.1s; } tr:hover .team__quit { opacity: 1; - @include transition(0.6s); + transition: opacity 0.6s; } .info { From 7f97977243d3c920b2489ed16e5ec207084bd15e Mon Sep 17 00:00:00 2001 From: Thibault Duplessis Date: Fri, 14 Jun 2024 14:24:26 +0200 Subject: [PATCH 022/168] user dropdown icon --- app/views/user/show/header.scala | 5 +---- 1 file changed, 1 insertion(+), 4 deletions(-) diff --git a/app/views/user/show/header.scala b/app/views/user/show/header.scala index e4c0ed963a539..5143d91f10480 100644 --- a/app/views/user/show/header.scala +++ b/app/views/user/show/header.scala @@ -90,10 +90,7 @@ object header: .option(a(cls := "nm-item note-zone-toggle")(splitNumber(s"${social.notes.size} Notes"))) ), div(cls := "user-actions dropdown")( - a( - cls := "text", - dataIcon := Icon.List - ), + a(cls := "text", dataIcon := Icon.Hamburger), div(cls := "dropdown-window")( (ctx .is(u)) From 976e6e02b1ebd8a2ab84740942666f4f6371bd4e Mon Sep 17 00:00:00 2001 From: Thibault Duplessis Date: Fri, 14 Jun 2024 15:39:53 +0200 Subject: [PATCH 023/168] scala codegolf --- app/views/user/show/header.scala | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/app/views/user/show/header.scala b/app/views/user/show/header.scala index 5143d91f10480..fdf75ef45443d 100644 --- a/app/views/user/show/header.scala +++ b/app/views/user/show/header.scala @@ -92,8 +92,8 @@ object header: div(cls := "user-actions dropdown")( a(cls := "text", dataIcon := Icon.Hamburger), div(cls := "dropdown-window")( - (ctx - .is(u)) + ctx + .is(u) .option( frag( a( From e22abf72f03a436730a71bafa327403d0771da48 Mon Sep 17 00:00:00 2001 From: Thibault Duplessis Date: Fri, 14 Jun 2024 15:40:26 +0200 Subject: [PATCH 024/168] tweak user menu css, fix mobile view it can't wrap back to the left side --- ui/bits/css/user/_show.scss | 37 +++++++++++++++++++++---------------- 1 file changed, 21 insertions(+), 16 deletions(-) diff --git a/ui/bits/css/user/_show.scss b/ui/bits/css/user/_show.scss index fa3fc0f71425e..4520832709804 100644 --- a/ui/bits/css/user/_show.scss +++ b/ui/bits/css/user/_show.scss @@ -22,16 +22,19 @@ } &__social { - @extend %flex-between; + @extend %flex-between-nowrap; background: $c-bg-zebra; .number-menu { + flex: 0 1 auto; + overflow: hidden; margin: 0 0 0.2em 1em; } .user-actions { - margin: 1em; + flex: 0 0 auto; + margin: 1em 1em 1em 0.3em; form { display: inline; @@ -40,24 +43,26 @@ .dropdown { position: relative; - font-size: x-large; + font-size: 2em; > a { + display: block; + height: 1.5em; color: $c-font-page; - float: right; padding-left: 0.5em; } .dropdown-window { + @extend %dropdown-shadow; + z-index: z('link-overlay'); visibility: hidden; background: $c-bg-header-dropdown; border-radius: 3px 0 3px 3px; - box-shadow: 2px 5px 6px rgba(0, 0, 0, 0.3); position: absolute; - top: 1.45em; + top: 1.5em; right: 0; a { width: 16em; - font-size: small; + font-size: 1rem; display: block; padding: 0.6rem 1rem; color: $c-header-dropdown; @@ -76,15 +81,15 @@ } } } - } - - .dropdown:hover { - > a { - background: $c-bg-header-dropdown; - box-shadow: 2px 5px 6px rgba(0, 0, 0, 0.3); - } - .dropdown-window { - visibility: visible; + &:hover { + > a { + border-radius: 3px 3px 0 0; + background: $c-bg-header-dropdown; + box-shadow: 2px 5px 6px rgba(0, 0, 0, 0.3); + } + .dropdown-window { + visibility: visible; + } } } } From 65d8bc8fa960e77bdd037e9fe6df827aefd34756 Mon Sep 17 00:00:00 2001 From: Thibault Duplessis Date: Fri, 14 Jun 2024 15:48:51 +0200 Subject: [PATCH 025/168] fix fide player page layout - closes #15496 --- modules/fide/src/main/ui/FideUi.scala | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/modules/fide/src/main/ui/FideUi.scala b/modules/fide/src/main/ui/FideUi.scala index 83b0707dd95b0..f56dd7d6c271f 100644 --- a/modules/fide/src/main/ui/FideUi.scala +++ b/modules/fide/src/main/ui/FideUi.scala @@ -212,7 +212,7 @@ final class FideUi(helpers: Helpers)(menu: String => Context ?=> Frag): ), tcTrans.map: (tc, name) => card(name(), player.ratingOf(tc).fold("Unrated")(_.toString)), - tours.map: tours => - div(cls := "fide-player__tours")(h2("Recent tournaments"), tours) - ) + ), + tours.map: tours => + div(cls := "fide-player__tours")(h2("Recent tournaments"), tours) ) From ea77f084138bb2684abe08737345dcdafdf2ec51 Mon Sep 17 00:00:00 2001 From: Niklas Fiekas Date: Fri, 14 Jun 2024 16:30:36 +0200 Subject: [PATCH 026/168] svgo cooke pieces --- public/piece-css/cooke.css | 24 +++++----- public/piece/cooke/bB.svg | 77 +------------------------------- public/piece/cooke/bK.svg | 66 +-------------------------- public/piece/cooke/bN.svg | 88 +----------------------------------- public/piece/cooke/bP.svg | 91 +------------------------------------- public/piece/cooke/bQ.svg | 69 +---------------------------- public/piece/cooke/bR.svg | 86 +---------------------------------- public/piece/cooke/wB.svg | 72 +----------------------------- public/piece/cooke/wK.svg | 69 +---------------------------- public/piece/cooke/wN.svg | 84 +---------------------------------- public/piece/cooke/wP.svg | 84 +---------------------------------- public/piece/cooke/wQ.svg | 68 +--------------------------- public/piece/cooke/wR.svg | 89 +------------------------------------ 13 files changed, 24 insertions(+), 943 deletions(-) diff --git a/public/piece-css/cooke.css b/public/piece-css/cooke.css index 2a9f3bca1aa7e..6ea20bfbd7e29 100644 --- a/public/piece-css/cooke.css +++ b/public/piece-css/cooke.css @@ -1,12 +1,12 @@ -.is2d .pawn.white {background-image:url('data:image/svg+xml;base64,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')} -.is2d .knight.white {background-image:url('data:image/svg+xml;base64,<?xml version="1.0" encoding="UTF-8"?>
<svg id="Layer_2" data-name="Layer 2" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 141.73 141.73">
  <defs>
    <style>
      .cls-1 {
        stroke-width: 1.57px;
      }

      .cls-1, .cls-2 {
        fill: none;
        stroke: #1e1e1e;
        stroke-linecap: round;
        stroke-linejoin: round;
      }

      .cls-3 {
        opacity: .35;
      }

      .cls-3, .cls-4, .cls-5, .cls-6, .cls-7, .cls-8, .cls-9, .cls-10 {
        stroke-width: 0px;
      }

      .cls-3, .cls-4, .cls-5, .cls-7 {
        fill-rule: evenodd;
      }

      .cls-3, .cls-4, .cls-5, .cls-7, .cls-11, .cls-10 {
        isolation: isolate;
      }

      .cls-3, .cls-4, .cls-7, .cls-10 {
        fill: #000;
      }

      .cls-4, .cls-10 {
        opacity: .18;
      }

      .cls-5, .cls-9 {
        fill: #fff;
      }

      .cls-6 {
        fill: #f0f0f0;
      }

      .cls-2 {
        stroke-width: 3px;
      }

      .cls-7 {
        opacity: .4;
      }

      .cls-8 {
        fill: #5f5955;
      }
    </style>
  </defs>
  <path class="cls-6" d="M95.25,32.12c-1.19-1.02-1.78-6.6-5.78-7.28-2.49-.43-16.26-17.75-10.92-1.76,1.14,3.42-3.29,4.55-5.55,4.94-2.27.38-5.27,1.02-5.27,1.02,0,0-6.13-2.27-10.37,1.61-.75.65-6.63,7.82-16.04,9.04-9.4,1.22-9.61,2.57-10.21,4.17-.6,1.6-2.89,6.58-2.89,6.58,0,0-1.71,4.47,1.17,3.86.25.3-.25,2.27,2.08,1.48,2.34-.8,8.19-.91,7.84-3.52,0-.7,3.51-2.02,3.84-1.01.2.64,1.98,6.26.75,6.78-1.47.62-12.64.03-12.64.03,0,0-.5.45-.16,1.59-.25.42-1.96,1.63.29,2.72,2.26,1.1,2.22.88,3.38,2.09,1.17,1.21,9.53,3.92,11.91,1.19,2.38-2.72,2.94-5.5,6.3-4.95,22.82,3.75,25.56-6.84,22.61-2.48,0,0-21.31,16.11-23.15,25.51-.59,3-6.46,7.16-6.32,10.64h56.95s7.13-49.48-7.83-62.24Z"/>
  <path class="cls-7" d="M65.1,36.09c1.03-.81,1.09-.71,1.11-.98.06-1.03-.76-2.13-1.79-2.44-1.16-.35-1.37-.45-2.45-.38-.29.02-.75.15-.99.3-2.44,1.58-1.66,6.22,1.75,4.42.09-.05.19-.09.29-.13l1.54-.51c.2-.07.39-.16.55-.29Z" image-rendering="optimizeQuality"/>
  <path class="cls-3" d="M35.53,44.35c-.84.25-2.2,1.43-2.53,1.86-.72.96.37,2.31,1.48,1.81.55-.25,2.85-.68,3.26-2.21,0,0-.09-.48-.24-.56-.18-.1-1.98-.89-1.98-.89Z" image-rendering="optimizeQuality"/>
  <g class="cls-11">
    <path class="cls-9" d="M27.71,53.22c.33-1.62,3.04-9.63,4.23-11.33,1.44-2.29,11.77-2.33,14.05-3.78,16.15-10.16,11.18-7.88,21.21-9.26,14.57-2.01,11.35-5.79,10.54-8.52-.39-1.29,0-3.2.72-2.66,1.49,1.41,5.67,8.01,3.85,9.64-1.52,1.65-9.15,2.97-11.6,3.53-7.96,1.82-8.26-4.09-15.08,4.62-1.8,2.3-9.36,5.27-10.63,5.7-1.53.53-7.43.63-11.42,3.18-2.45,1.57-5.87,8.87-5.87,8.87Z"/>
  </g>
  <path class="cls-4" d="M51.32,60.37c2.37.87,6.62,4.04,21.15-1.43,1.04-.39,5.1-3.58,4.51-2.67-.67,1.03-.91,3.43-.78,3.3,1.83-1.71,5.02-5,6.09-11.71.21-1.29-1.8-2.12-2.32-.91-7.46,17.06-36.08,10.71-28.65,13.42Z" image-rendering="optimizeQuality"/>
  <path class="cls-5" d="M76.41,57.79c-21.76,18.85-25.12,25.69-29.45,35.16-.58,1.27,6.08,2.29,6.27.91,3.34-24.83,23.18-21.86,23.18-36.08Z" image-rendering="optimizeQuality"/>
  <path class="cls-4" d="M78.46,17.68s7.69,5.91,11.54,12.42c22.13,25.97,6.81,65.54,1.21,64.25h11.88c.79-6.92,7.98-51.04-13.61-69.52-3.72-2.87-4.71-6.69-11.92-8.15l.91.99Z" image-rendering="optimizeQuality"/>
  <path class="cls-2" d="M95.25,32.12c-1.19-1.02-1.3-4.26-5.78-7.28-2.1-1.42-16.26-17.75-10.92-1.76,1.14,3.42-3.29,4.55-5.55,4.94-2.27.38-5.27,1.02-5.27,1.02,0,0-6.13-2.27-10.37,1.61-.75.65-6.63,7.82-16.04,9.04-9.4,1.22-9.61,2.57-10.21,4.17-.6,1.6-2.89,6.58-2.89,6.58,0,0-1.71,4.47,1.17,3.86.25.3-.25,2.27,2.08,1.48,2.34-.8,8.19-.91,7.84-3.52,0-.7,3.51-2.02,3.84-1.01.2.64,1.98,6.26.75,6.78-1.47.62-12.64.03-12.64.03,0,0-.5.45-.16,1.59-.25.42-1.96,1.63.29,2.72,2.26,1.1,2.22.88,3.38,2.09,1.17,1.21,9.53,3.92,11.91,1.19,2.38-2.72,2.94-5.5,6.3-4.95,22.82,3.75,25.56-6.84,22.61-2.48,0,0-21.31,16.11-23.15,25.51-.59,3-6.46,7.16-6.32,10.64h56.95s7.13-49.48-7.83-62.24Z"/>
  <g>
    <path class="cls-6" d="M50.06,94.52h-2.6s0,.04,0,.04c0,0-1.18.22-2.09.9-.92.68-.65,2.64-.65,2.64,0,0-1.32.73-2.94,1.97-1.77,1.35-3.9,3.31-5.03,5.55-2.16,4.29,1.67,8.01,1.67,8.01,0,0-3.9,1.47-3.87,5.1.03,3.62,1.39,5.45,3.48,6.09h72.52c2.09-.63,3.46-2.46,3.48-6.08.02-3.63-3.88-5.1-3.88-5.1,0,0,3.83-3.72,1.67-8.01-1.13-2.25-3.25-4.2-5.03-5.55-1.62-1.24-2.94-1.97-2.94-1.97,0,0,.26-1.96-.65-2.64-.92-.68-2.09-.9-2.09-.9,0,0,0-.02,0-.04h-2.61"/>
    <line class="cls-8" x1="110.06" y1="113.65" x2="38.32" y2="113.64"/>
  </g>
  <path class="cls-9" d="M35.79,118.92c.04,3.51,1.82,5.28,4.54,5.91.02,0,.04,0,.06.01-1.11-1.02-1.76-2.59-1.78-4.84-.04-3.68,4.86-5.17,4.86-5.17,0,0-4.8-3.77-2.1-8.12,1.42-2.28,4.09-4.26,6.31-5.63,2.03-1.25,3.69-2,3.69-2,0,0-.33-1.98.82-2.67,1.15-.69,2.63-.92,2.63-.92,0,0,0,0,0-.04h-3.7s1.5.04,1.5.04c0,0-3.05.22-4.25.88-1.19.65-.85,2.55-.85,2.55,0,0-1.72.71-3.83,1.91-2.31,1.31-4.01,3.03-5.48,5.2-2.81,4.16,2.62,7.94,2.62,7.94,0,0-5.09,1.43-5.05,4.94Z"/>
  <path class="cls-10" d="M112.52,119.39c-.04,3.69-.18,5.57-2.9,6.23-.02,0-8.57,0-5.34,0,1.11-1.08,4.09-2.79,4.11-5.16.04-3.87-4.02-6.24-4.02-6.24,0,0,6.72-3.65,4.03-8.23-1.41-2.4-1.23-2.63-3.45-4.07-2.03-1.32-4.45-3.43-4.45-3.43,0,0,.33-2.09-.82-2.81-1.14-.72-2.62-.97-2.62-.97,0,0-3.52,0-3.53-.03h7.22s-1.5.03-1.5.03c0,0,1.8-.25,2.99.44,1.19.69,1.39,2.3,1.39,2.3,0,0,.37,1.55,2.47,2.81,2.31,1.38,4.01,2.82,5.48,5.11,2.8,4.38-4.09,8.8-4.09,8.8,0,0,5.08,1.51,5.04,5.2Z"/>
  <path class="cls-10" d="M112.52,119.39c-.04,3.69-.18,5.57-2.9,6.23-.02,0-8.57,0-5.34,0,1.11-1.08,4.09-2.79,4.11-5.16.04-3.87-4.02-6.24-4.02-6.24,0,0,6.72-3.65,4.03-8.23-1.41-2.4-1.23-2.63-3.45-4.07-2.03-1.32-4.45-3.43-4.45-3.43,0,0,.33-2.09-.82-2.81-1.14-.72-2.62-.97-2.62-.97,0,0-3.52,0-3.53-.03h7.22s-1.5.03-1.5.03c0,0,1.8-.25,2.99.44,1.19.69,1.39,2.3,1.39,2.3,0,0,.37,1.55,2.47,2.81,2.31,1.38,4.01,2.82,5.48,5.11,2.8,4.38-4.09,8.8-4.09,8.8,0,0,5.08,1.51,5.04,5.2Z"/>
  <g>
    <line class="cls-1" x1="110.09" y1="113.65" x2="38.35" y2="113.64"/>
    <line class="cls-2" x1="99.52" y1="94.53" x2="48.11" y2="94.52"/>
    <path class="cls-2" d="M50.01,94.52h-2.6s0,.04,0,.04c0,0-1.18.22-2.09.9-.92.68-.65,2.64-.65,2.64,0,0-1.32.73-2.94,1.97-1.77,1.35-3.9,3.31-5.03,5.55-2.16,4.29,1.67,8.01,1.67,8.01,0,0-3.9,1.47-3.87,5.1.03,3.62,1.39,5.45,3.48,6.09h72.52c2.09-.63,3.46-2.46,3.48-6.08.02-3.63-3.88-5.1-3.88-5.1,0,0,3.83-3.72,1.67-8.01-1.13-2.25-3.25-4.2-5.03-5.55-1.62-1.24-2.94-1.97-2.94-1.97,0,0,.26-1.96-.65-2.64-.92-.68-2.09-.9-2.09-.9,0,0,0-.02,0-.04h-2.61"/>
  </g>
</svg>')} -.is2d .bishop.white {background-image:url('data:image/svg+xml;base64,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')} -.is2d .rook.white {background-image:url('data:image/svg+xml;base64,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')} -.is2d .queen.white {background-image:url('data:image/svg+xml;base64,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')} -.is2d .king.white {background-image:url('data:image/svg+xml;base64,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')} -.is2d .pawn.black {background-image:url('data:image/svg+xml;base64,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')} -.is2d .knight.black {background-image:url('data:image/svg+xml;base64,<?xml version="1.0" encoding="UTF-8"?>
<svg id="Layer_2" data-name="Layer 2" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 141.73 141.73">
  <defs>
    <style>
      .cls-1 {
        stroke-width: 3.03px;
      }

      .cls-1, .cls-2, .cls-3 {
        fill: none;
        stroke: #1e1e1e;
        stroke-linejoin: round;
      }

      .cls-4 {
        opacity: .35;
      }

      .cls-4, .cls-5, .cls-6, .cls-7 {
        fill-rule: evenodd;
      }

      .cls-4, .cls-5, .cls-6, .cls-7, .cls-8, .cls-9, .cls-10, .cls-11 {
        stroke-width: 0px;
      }

      .cls-4, .cls-5, .cls-6, .cls-7, .cls-12, .cls-11 {
        isolation: isolate;
      }

      .cls-4, .cls-5, .cls-7, .cls-11 {
        fill: #000;
      }

      .cls-5, .cls-11 {
        opacity: .18;
      }

      .cls-2 {
        stroke-width: 3px;
      }

      .cls-6, .cls-8, .cls-10 {
        fill: #fff;
      }

      .cls-6, .cls-8, .cls-12 {
        opacity: .25;
      }

      .cls-7 {
        opacity: .4;
      }

      .cls-3 {
        stroke-width: 1.58px;
      }

      .cls-9 {
        fill: #5f5955;
      }
    </style>
  </defs>
  <path class="cls-9" d="M95.42,32.06c-1.2-1.03-1.79-6.65-5.82-7.34-2.51-.43-16.38-17.88-11-1.78,1.15,3.45-3.31,4.59-5.59,4.97-2.28.39-5.31,1.03-5.31,1.03,0,0-6.18-2.29-10.45,1.62-.75.65-6.68,7.88-16.16,9.1-9.47,1.23-9.68,2.58-10.29,4.2-.61,1.61-2.91,6.62-2.91,6.62,0,0-1.73,4.5,1.18,3.89.25.31-.25,2.29,2.1,1.49,2.36-.8,8.25-.91,7.9-3.55,0-.71,3.53-2.04,3.87-1.01.2.64,1.99,6.3.75,6.82-1.48.62-12.73.03-12.73.03,0,0-.5.45-.17,1.6-.25.42-1.98,1.64.29,2.74,2.27,1.11,2.23.88,3.4,2.1,1.18,1.22,9.6,3.95,12,1.2,2.39-2.74,2.96-5.54,6.35-4.98,22.98,3.78,25.74-6.89,22.77-2.49,0,0-21.46,16.23-23.32,25.69-.59,3.02-6.51,7.21-6.36,10.72h57.36s7.18-49.83-7.89-62.68Z"/>
  <path class="cls-7" d="M65.06,36.06c1.04-.82,1.1-.71,1.12-.98.06-1.04-.76-2.15-1.8-2.46-1.17-.35-1.38-.45-2.47-.38-.3.02-.75.15-1,.31-2.46,1.59-1.67,6.26,1.76,4.45.09-.05.19-.09.29-.13l1.55-.51c.2-.07.39-.17.55-.29Z" image-rendering="optimizeQuality"/>
  <path class="cls-4" d="M35.28,44.39c-.84.25-2.22,1.44-2.54,1.87-.72.96.37,2.32,1.49,1.82.56-.25,2.87-.69,3.29-2.23,0,0-.09-.49-.24-.57-.18-.1-1.99-.9-1.99-.9Z" image-rendering="optimizeQuality"/>
  <g class="cls-12">
    <path class="cls-10" d="M27.41,53.32c.34-1.63,3.06-9.7,4.26-11.41,1.45-2.3,11.85-2.35,14.15-3.8,16.26-10.24,11.26-7.93,21.36-9.32,14.67-2.02,11.43-5.83,10.61-8.58-.39-1.3,0-3.22.73-2.68,1.5,1.42,5.71,8.07,3.88,9.71-1.53,1.66-9.21,2.99-11.68,3.56-8.01,1.83-8.32-4.11-15.18,4.65-1.81,2.32-9.43,5.3-10.7,5.74-1.55.53-7.48.64-11.51,3.21-2.47,1.58-5.91,8.93-5.91,8.93Z"/>
  </g>
  <path class="cls-5" d="M51.18,60.52c2.39.87,6.66,4.06,21.3-1.44,1.05-.39,5.13-3.6,4.54-2.69-.67,1.04-.92,3.45-.78,3.33,1.84-1.72,5.05-5.03,6.14-11.79.21-1.3-1.81-2.13-2.34-.92-7.51,17.19-36.33,10.78-28.85,13.51Z" image-rendering="optimizeQuality"/>
  <path class="cls-6" d="M76.44,57.91c-21.91,18.98-25.29,25.88-29.66,35.41-.59,1.28,6.12,2.31,6.31.92,3.36-25,23.35-22.01,23.35-36.33Z" image-rendering="optimizeQuality"/>
  <path class="cls-5" d="M78.51,17.52s7.74,5.95,11.62,12.51c22.28,26.16,6.85,66.01,1.21,64.71h11.96c.79-6.97,8.03-51.4-13.7-70.01-3.75-2.89-4.75-6.74-12-8.21l.91,1Z" image-rendering="optimizeQuality"/>
  <path class="cls-2" d="M95.42,32.06c-1.2-1.03-1.31-4.29-5.82-7.34-2.11-1.43-16.38-17.88-11-1.78,1.15,3.45-3.31,4.59-5.59,4.97-2.28.39-5.31,1.03-5.31,1.03,0,0-6.18-2.29-10.45,1.62-.75.65-6.68,7.88-16.16,9.1-9.47,1.23-9.68,2.58-10.29,4.2-.61,1.61-2.91,6.62-2.91,6.62,0,0-1.73,4.5,1.18,3.89.25.31-.25,2.29,2.1,1.49,2.36-.8,8.25-.91,7.9-3.55,0-.71,3.53-2.04,3.87-1.01.2.64,1.99,6.3.75,6.82-1.48.62-12.73.03-12.73.03,0,0-.5.45-.17,1.6-.25.42-1.98,1.64.29,2.74,2.27,1.11,2.23.88,3.4,2.1,1.18,1.22,9.6,3.95,12,1.2,2.39-2.74,2.96-5.54,6.35-4.98,22.98,3.78,25.74-6.89,22.77-2.49,0,0-21.46,16.23-23.32,25.69-.59,3.02-6.51,7.21-6.36,10.72h57.36s7.18-49.83-7.89-62.68Z"/>
  <g>
    <path class="cls-9" d="M49.92,94.91h-2.62s-.01.04-.01.04c0,0-1.18.23-2.11.91-.92.68-.66,2.65-.66,2.65,0,0-1.33.74-2.96,1.99-1.79,1.36-3.93,3.33-5.06,5.59-2.17,4.32,1.68,8.07,1.68,8.07,0,0-3.92,1.48-3.9,5.14.03,3.65,1.4,5.49,3.51,6.13h73.03c2.1-.64,3.48-2.48,3.51-6.12.03-3.65-3.9-5.14-3.9-5.14,0,0,3.86-3.75,1.69-8.07-1.13-2.26-3.28-4.23-5.07-5.59-1.63-1.25-2.96-1.99-2.96-1.99,0,0,.26-1.97-.66-2.65-.92-.68-2.11-.91-2.11-.91,0,0,0-.02-.01-.04h-2.62"/>
    <line class="cls-9" x1="110.34" y1="114.17" x2="38.09" y2="114.16"/>
  </g>
  <path class="cls-8" d="M35.54,119.48c.04,3.53,1.83,5.32,4.57,5.95.02,0,.04,0,.06.01-1.12-1.03-1.77-2.61-1.79-4.88-.04-3.7,4.89-5.21,4.89-5.21,0,0-4.84-3.8-2.12-8.18,1.43-2.29,4.12-4.29,6.36-5.67,2.05-1.26,3.72-2.01,3.72-2.01,0,0-.33-2,.83-2.69,1.15-.69,2.64-.92,2.64-.92,0,0,0,0,0-.04h-3.73s1.52.04,1.52.04c0,0-3.07.22-4.28.88-1.2.66-.86,2.57-.86,2.57,0,0-1.74.72-3.86,1.92-2.33,1.32-4.04,3.05-5.52,5.24-2.83,4.18,2.64,8,2.64,8,0,0-5.12,1.44-5.08,4.98Z"/>
  <path class="cls-11" d="M112.7,119.57c-.04,3.69-.19,5.56-3.07,6.22-.02,0-9.08,0-5.65,0,1.17-1.07,4.33-2.78,4.35-5.15.04-3.86-4.26-6.23-4.26-6.23,0,0,7.12-3.65,4.26-8.21-1.5-2.39-1.3-2.62-3.65-4.06-2.15-1.31-4.71-3.42-4.71-3.42,0,0,.35-2.08-.87-2.8-1.21-.72-2.77-.96-2.77-.96,0,0-3.73,0-3.74-.03h7.65s-1.59.03-1.59.03c0,0,1.9-.25,3.17.44,1.26.68,1.47,2.3,1.47,2.3,0,0,.39,1.55,2.62,2.81,2.44,1.38,4.25,2.81,5.8,5.1,2.97,4.37-4.33,8.78-4.33,8.78,0,0,5.38,1.5,5.33,5.19Z"/>
  <g>
    <line class="cls-1" x1="99.73" y1="94.92" x2="47.95" y2="94.91"/>
    <g>
      <line class="cls-3" x1="110.37" y1="114.17" x2="38.12" y2="114.16"/>
      <path class="cls-2" d="M49.86,94.91h-2.62s-.01.04-.01.04c0,0-1.18.23-2.11.91-.92.68-.66,2.65-.66,2.65,0,0-1.33.74-2.96,1.99-1.79,1.36-3.93,3.33-5.06,5.59-2.17,4.32,1.68,8.07,1.68,8.07,0,0-3.92,1.48-3.9,5.14.03,3.65,1.4,5.49,3.51,6.13h73.03c2.1-.64,3.48-2.48,3.51-6.12.03-3.65-3.9-5.14-3.9-5.14,0,0,3.86-3.75,1.69-8.07-1.13-2.26-3.28-4.23-5.07-5.59-1.63-1.25-2.96-1.99-2.96-1.99,0,0,.26-1.97-.66-2.65-.92-.68-2.11-.91-2.11-.91,0,0,0-.02-.01-.04h-2.62"/>
    </g>
  </g>
</svg>')} -.is2d .bishop.black {background-image:url('data:image/svg+xml;base64,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')} -.is2d .rook.black {background-image:url('data:image/svg+xml;base64,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')} -.is2d .queen.black {background-image:url('data:image/svg+xml;base64,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')} -.is2d .king.black {background-image:url('data:image/svg+xml;base64,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')} +.is2d .pawn.white {background-image:url('data:image/svg+xml;base64,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')} +.is2d .knight.white {background-image:url('data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIGlkPSJMYXllcl8yIiBkYXRhLW5hbWU9IkxheWVyIDIiIHZpZXdCb3g9IjAgMCAxNDEuNzMgMTQxLjczIj48ZGVmcz48c3R5bGU+LmNscy0ye2ZpbGw6bm9uZTtzdHJva2U6IzFlMWUxZTtzdHJva2UtbGluZWNhcDpyb3VuZDtzdHJva2UtbGluZWpvaW46cm91bmR9LmNscy0xMCwuY2xzLTQsLmNscy02LC5jbHMtOXtzdHJva2Utd2lkdGg6MH0uY2xzLTR7ZmlsbC1ydWxlOmV2ZW5vZGR9LmNscy0xMCwuY2xzLTR7aXNvbGF0aW9uOmlzb2xhdGU7ZmlsbDojMDAwO29wYWNpdHk6LjE4fS5jbHMtOXtmaWxsOiNmZmZ9LmNscy02e2ZpbGw6I2YwZjBmMH0uY2xzLTJ7c3Ryb2tlLXdpZHRoOjNweH08L3N0eWxlPjwvZGVmcz48cGF0aCBkPSJNOTUuMjUgMzIuMTJjLTEuMTktMS4wMi0xLjc4LTYuNi01Ljc4LTcuMjgtMi40OS0uNDMtMTYuMjYtMTcuNzUtMTAuOTItMS43NiAxLjE0IDMuNDItMy4yOSA0LjU1LTUuNTUgNC45NC0yLjI3LjM4LTUuMjcgMS4wMi01LjI3IDEuMDJzLTYuMTMtMi4yNy0xMC4zNyAxLjYxYy0uNzUuNjUtNi42MyA3LjgyLTE2LjA0IDkuMDQtOS40IDEuMjItOS42MSAyLjU3LTEwLjIxIDQuMTdzLTIuODkgNi41OC0yLjg5IDYuNTgtMS43MSA0LjQ3IDEuMTcgMy44NmMuMjUuMy0uMjUgMi4yNyAyLjA4IDEuNDggMi4zNC0uOCA4LjE5LS45MSA3Ljg0LTMuNTIgMC0uNyAzLjUxLTIuMDIgMy44NC0xLjAxLjIuNjQgMS45OCA2LjI2Ljc1IDYuNzgtMS40Ny42Mi0xMi42NC4wMy0xMi42NC4wM3MtLjUuNDUtLjE2IDEuNTljLS4yNS40Mi0xLjk2IDEuNjMuMjkgMi43MiAyLjI2IDEuMSAyLjIyLjg4IDMuMzggMi4wOSAxLjE3IDEuMjEgOS41MyAzLjkyIDExLjkxIDEuMTkgMi4zOC0yLjcyIDIuOTQtNS41IDYuMy00Ljk1IDIyLjgyIDMuNzUgMjUuNTYtNi44NCAyMi42MS0yLjQ4IDAgMC0yMS4zMSAxNi4xMS0yMy4xNSAyNS41MS0uNTkgMy02LjQ2IDcuMTYtNi4zMiAxMC42NGg1Ni45NXM3LjEzLTQ5LjQ4LTcuODMtNjIuMjRaIiBjbGFzcz0iY2xzLTYiLz48cGF0aCBkPSJNNjUuMSAzNi4wOWMxLjAzLS44MSAxLjA5LS43MSAxLjExLS45OC4wNi0xLjAzLS43Ni0yLjEzLTEuNzktMi40NC0xLjE2LS4zNS0xLjM3LS40NS0yLjQ1LS4zOC0uMjkuMDItLjc1LjE1LS45OS4zLTIuNDQgMS41OC0xLjY2IDYuMjIgMS43NSA0LjQyLjA5LS4wNS4xOS0uMDkuMjktLjEzbDEuNTQtLjUxYy4yLS4wNy4zOS0uMTYuNTUtLjI5WiIgaW1hZ2UtcmVuZGVyaW5nPSJvcHRpbWl6ZVF1YWxpdHkiIHN0eWxlPSJzdHJva2Utd2lkdGg6MDtmaWxsLXJ1bGU6ZXZlbm9kZDtpc29sYXRpb246aXNvbGF0ZTtmaWxsOiMwMDA7b3BhY2l0eTouNCIvPjxwYXRoIGQ9Ik0zNS41MyA0NC4zNWMtLjg0LjI1LTIuMiAxLjQzLTIuNTMgMS44Ni0uNzIuOTYuMzcgMi4zMSAxLjQ4IDEuODEuNTUtLjI1IDIuODUtLjY4IDMuMjYtMi4yMSAwIDAtLjA5LS40OC0uMjQtLjU2LS4xOC0uMS0xLjk4LS44OS0xLjk4LS44OVoiIGltYWdlLXJlbmRlcmluZz0ib3B0aW1pemVRdWFsaXR5IiBzdHlsZT0ib3BhY2l0eTouMzU7c3Ryb2tlLXdpZHRoOjA7ZmlsbC1ydWxlOmV2ZW5vZGQ7aXNvbGF0aW9uOmlzb2xhdGU7ZmlsbDojMDAwIi8+PHBhdGggZD0iTTI3LjcxIDUzLjIyYy4zMy0xLjYyIDMuMDQtOS42MyA0LjIzLTExLjMzIDEuNDQtMi4yOSAxMS43Ny0yLjMzIDE0LjA1LTMuNzggMTYuMTUtMTAuMTYgMTEuMTgtNy44OCAyMS4yMS05LjI2IDE0LjU3LTIuMDEgMTEuMzUtNS43OSAxMC41NC04LjUyLS4zOS0xLjI5IDAtMy4yLjcyLTIuNjYgMS40OSAxLjQxIDUuNjcgOC4wMSAzLjg1IDkuNjQtMS41MiAxLjY1LTkuMTUgMi45Ny0xMS42IDMuNTMtNy45NiAxLjgyLTguMjYtNC4wOS0xNS4wOCA0LjYyLTEuOCAyLjMtOS4zNiA1LjI3LTEwLjYzIDUuNy0xLjUzLjUzLTcuNDMuNjMtMTEuNDIgMy4xOC0yLjQ1IDEuNTctNS44NyA4Ljg3LTUuODcgOC44N1oiIGNsYXNzPSJjbHMtOSIgc3R5bGU9Imlzb2xhdGlvbjppc29sYXRlIi8+PHBhdGggZD0iTTUxLjMyIDYwLjM3YzIuMzcuODcgNi42MiA0LjA0IDIxLjE1LTEuNDMgMS4wNC0uMzkgNS4xLTMuNTggNC41MS0yLjY3LS42NyAxLjAzLS45MSAzLjQzLS43OCAzLjMgMS44My0xLjcxIDUuMDItNSA2LjA5LTExLjcxLjIxLTEuMjktMS44LTIuMTItMi4zMi0uOTEtNy40NiAxNy4wNi0zNi4wOCAxMC43MS0yOC42NSAxMy40MiIgY2xhc3M9ImNscy00IiBpbWFnZS1yZW5kZXJpbmc9Im9wdGltaXplUXVhbGl0eSIvPjxwYXRoIGQ9Ik03Ni40MSA1Ny43OUM1NC42NSA3Ni42NCA1MS4yOSA4My40OCA0Ni45NiA5Mi45NWMtLjU4IDEuMjcgNi4wOCAyLjI5IDYuMjcuOTFDNTYuNTcgNjkuMDMgNzYuNDEgNzIgNzYuNDEgNTcuNzhaIiBpbWFnZS1yZW5kZXJpbmc9Im9wdGltaXplUXVhbGl0eSIgc3R5bGU9InN0cm9rZS13aWR0aDowO2ZpbGwtcnVsZTpldmVub2RkO2lzb2xhdGlvbjppc29sYXRlO2ZpbGw6I2ZmZiIvPjxwYXRoIGQ9Ik03OC40NiAxNy42OFM4Ni4xNSAyMy41OSA5MCAzMC4xYzIyLjEzIDI1Ljk3IDYuODEgNjUuNTQgMS4yMSA2NC4yNWgxMS44OGMuNzktNi45MiA3Ljk4LTUxLjA0LTEzLjYxLTY5LjUyLTMuNzItMi44Ny00LjcxLTYuNjktMTEuOTItOC4xNWwuOTEuOTlaIiBjbGFzcz0iY2xzLTQiIGltYWdlLXJlbmRlcmluZz0ib3B0aW1pemVRdWFsaXR5Ii8+PHBhdGggZD0iTTk1LjI1IDMyLjEyYy0xLjE5LTEuMDItMS4zLTQuMjYtNS43OC03LjI4LTIuMS0xLjQyLTE2LjI2LTE3Ljc1LTEwLjkyLTEuNzYgMS4xNCAzLjQyLTMuMjkgNC41NS01LjU1IDQuOTQtMi4yNy4zOC01LjI3IDEuMDItNS4yNyAxLjAycy02LjEzLTIuMjctMTAuMzcgMS42MWMtLjc1LjY1LTYuNjMgNy44Mi0xNi4wNCA5LjA0LTkuNCAxLjIyLTkuNjEgMi41Ny0xMC4yMSA0LjE3cy0yLjg5IDYuNTgtMi44OSA2LjU4LTEuNzEgNC40NyAxLjE3IDMuODZjLjI1LjMtLjI1IDIuMjcgMi4wOCAxLjQ4IDIuMzQtLjggOC4xOS0uOTEgNy44NC0zLjUyIDAtLjcgMy41MS0yLjAyIDMuODQtMS4wMS4yLjY0IDEuOTggNi4yNi43NSA2Ljc4LTEuNDcuNjItMTIuNjQuMDMtMTIuNjQuMDNzLS41LjQ1LS4xNiAxLjU5Yy0uMjUuNDItMS45NiAxLjYzLjI5IDIuNzIgMi4yNiAxLjEgMi4yMi44OCAzLjM4IDIuMDkgMS4xNyAxLjIxIDkuNTMgMy45MiAxMS45MSAxLjE5IDIuMzgtMi43MiAyLjk0LTUuNSA2LjMtNC45NSAyMi44MiAzLjc1IDI1LjU2LTYuODQgMjIuNjEtMi40OCAwIDAtMjEuMzEgMTYuMTEtMjMuMTUgMjUuNTEtLjU5IDMtNi40NiA3LjE2LTYuMzIgMTAuNjRoNTYuOTVzNy4xMy00OS40OC03LjgzLTYyLjI0WiIgY2xhc3M9ImNscy0yIi8+PHBhdGggZD0iTTUwLjA2IDk0LjUyaC0yLjZ2LjA0cy0xLjE4LjIyLTIuMDkuOWMtLjkyLjY4LS42NSAyLjY0LS42NSAyLjY0cy0xLjMyLjczLTIuOTQgMS45N2MtMS43NyAxLjM1LTMuOSAzLjMxLTUuMDMgNS41NS0yLjE2IDQuMjkgMS42NyA4LjAxIDEuNjcgOC4wMXMtMy45IDEuNDctMy44NyA1LjFjLjAzIDMuNjIgMS4zOSA1LjQ1IDMuNDggNi4wOWg3Mi41MmMyLjA5LS42MyAzLjQ2LTIuNDYgMy40OC02LjA4LjAyLTMuNjMtMy44OC01LjEtMy44OC01LjFzMy44My0zLjcyIDEuNjctOC4wMWMtMS4xMy0yLjI1LTMuMjUtNC4yLTUuMDMtNS41NS0xLjYyLTEuMjQtMi45NC0xLjk3LTIuOTQtMS45N3MuMjYtMS45Ni0uNjUtMi42NGMtLjkyLS42OC0yLjA5LS45LTIuMDktLjl2LS4wNEg5OC41IiBjbGFzcz0iY2xzLTYiLz48cGF0aCBkPSJtMTEwLjA2IDExMy42NS03MS43NC0uMDEiIHN0eWxlPSJzdHJva2Utd2lkdGg6MDtmaWxsOiM1ZjU5NTUiLz48cGF0aCBkPSJNMzUuNzkgMTE4LjkyYy4wNCAzLjUxIDEuODIgNS4yOCA0LjU0IDUuOTEuMDIgMCAuMDQgMCAuMDYuMDEtMS4xMS0xLjAyLTEuNzYtMi41OS0xLjc4LTQuODQtLjA0LTMuNjggNC44Ni01LjE3IDQuODYtNS4xN3MtNC44LTMuNzctMi4xLTguMTJjMS40Mi0yLjI4IDQuMDktNC4yNiA2LjMxLTUuNjMgMi4wMy0xLjI1IDMuNjktMiAzLjY5LTJzLS4zMy0xLjk4LjgyLTIuNjcgMi42My0uOTIgMi42My0uOTJ2LS4wNGgtMy43bDEuNS4wNHMtMy4wNS4yMi00LjI1Ljg4Yy0xLjE5LjY1LS44NSAyLjU1LS44NSAyLjU1cy0xLjcyLjcxLTMuODMgMS45MWMtMi4zMSAxLjMxLTQuMDEgMy4wMy01LjQ4IDUuMi0yLjgxIDQuMTYgMi42MiA3Ljk0IDIuNjIgNy45NHMtNS4wOSAxLjQzLTUuMDUgNC45NFoiIGNsYXNzPSJjbHMtOSIvPjxwYXRoIGQ9Ik0xMTIuNTIgMTE5LjM5Yy0uMDQgMy42OS0uMTggNS41Ny0yLjkgNi4yM2gtNS4zNGMxLjExLTEuMDggNC4wOS0yLjc5IDQuMTEtNS4xNi4wNC0zLjg3LTQuMDItNi4yNC00LjAyLTYuMjRzNi43Mi0zLjY1IDQuMDMtOC4yM2MtMS40MS0yLjQtMS4yMy0yLjYzLTMuNDUtNC4wNy0yLjAzLTEuMzItNC40NS0zLjQzLTQuNDUtMy40M3MuMzMtMi4wOS0uODItMi44MWMtMS4xNC0uNzItMi42Mi0uOTctMi42Mi0uOTdzLTMuNTIgMC0zLjUzLS4wM2g3LjIybC0xLjUuMDNzMS44LS4yNSAyLjk5LjQ0IDEuMzkgMi4zIDEuMzkgMi4zLjM3IDEuNTUgMi40NyAyLjgxYzIuMzEgMS4zOCA0LjAxIDIuODIgNS40OCA1LjExIDIuOCA0LjM4LTQuMDkgOC44LTQuMDkgOC44czUuMDggMS41MSA1LjA0IDUuMloiIGNsYXNzPSJjbHMtMTAiLz48cGF0aCBkPSJNMTEyLjUyIDExOS4zOWMtLjA0IDMuNjktLjE4IDUuNTctMi45IDYuMjNoLTUuMzRjMS4xMS0xLjA4IDQuMDktMi43OSA0LjExLTUuMTYuMDQtMy44Ny00LjAyLTYuMjQtNC4wMi02LjI0czYuNzItMy42NSA0LjAzLTguMjNjLTEuNDEtMi40LTEuMjMtMi42My0zLjQ1LTQuMDctMi4wMy0xLjMyLTQuNDUtMy40My00LjQ1LTMuNDNzLjMzLTIuMDktLjgyLTIuODFjLTEuMTQtLjcyLTIuNjItLjk3LTIuNjItLjk3cy0zLjUyIDAtMy41My0uMDNoNy4yMmwtMS41LjAzczEuOC0uMjUgMi45OS40NCAxLjM5IDIuMyAxLjM5IDIuMy4zNyAxLjU1IDIuNDcgMi44MWMyLjMxIDEuMzggNC4wMSAyLjgyIDUuNDggNS4xMSAyLjggNC4zOC00LjA5IDguOC00LjA5IDguOHM1LjA4IDEuNTEgNS4wNCA1LjJaIiBjbGFzcz0iY2xzLTEwIi8+PHBhdGggZD0ibTExMC4wOSAxMTMuNjUtNzEuNzQtLjAxIiBzdHlsZT0ic3Ryb2tlLXdpZHRoOjEuNTdweDtmaWxsOm5vbmU7c3Ryb2tlOiMxZTFlMWU7c3Ryb2tlLWxpbmVjYXA6cm91bmQ7c3Ryb2tlLWxpbmVqb2luOnJvdW5kIi8+PHBhdGggZD0ibTk5LjUyIDk0LjUzLTUxLjQxLS4wMW0xLjkgMGgtMi42di4wNHMtMS4xOC4yMi0yLjA5LjljLS45Mi42OC0uNjUgMi42NC0uNjUgMi42NHMtMS4zMi43My0yLjk0IDEuOTdjLTEuNzcgMS4zNS0zLjkgMy4zMS01LjAzIDUuNTUtMi4xNiA0LjI5IDEuNjcgOC4wMSAxLjY3IDguMDFzLTMuOSAxLjQ3LTMuODcgNS4xYy4wMyAzLjYyIDEuMzkgNS40NSAzLjQ4IDYuMDloNzIuNTJjMi4wOS0uNjMgMy40Ni0yLjQ2IDMuNDgtNi4wOC4wMi0zLjYzLTMuODgtNS4xLTMuODgtNS4xczMuODMtMy43MiAxLjY3LTguMDFjLTEuMTMtMi4yNS0zLjI1LTQuMi01LjAzLTUuNTUtMS42Mi0xLjI0LTIuOTQtMS45Ny0yLjk0LTEuOTdzLjI2LTEuOTYtLjY1LTIuNjRjLS45Mi0uNjgtMi4wOS0uOS0yLjA5LS45di0uMDRoLTIuNjEiIGNsYXNzPSJjbHMtMiIvPjwvc3ZnPg==')} +.is2d .bishop.white {background-image:url('data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIGlkPSJMYXllcl8yIiBkYXRhLW5hbWU9IkxheWVyIDIiIHZpZXdCb3g9IjAgMCAxNDEuNzMgMTQxLjczIj48ZGVmcz48c3R5bGU+LmNscy0ye3N0cm9rZTojMWUxZTFlO3N0cm9rZS1saW5lam9pbjpyb3VuZDtmaWxsOm5vbmV9LmNscy01e2ZpbGwtcnVsZTpldmVub2RkfS5jbHMtNSwuY2xzLTYsLmNscy04e3N0cm9rZS13aWR0aDowfS5jbHMtNXtmaWxsOiMwMDA7aXNvbGF0aW9uOmlzb2xhdGU7b3BhY2l0eTouMTh9LmNscy0ye3N0cm9rZS13aWR0aDozcHh9LmNscy02e2ZpbGw6I2YwZjBmMH0uY2xzLTh7ZmlsbDojZmZmfTwvc3R5bGU+PC9kZWZzPjxwYXRoIGQ9Ik04MC4xMyA2MS4wOSA5NC4xIDQzLjU2Yy4yNi0uMzMuNzctLjMyIDEuMDEuMDEgOC4wMSAxMC45NCAxMS43NSAyOC4wNi0zLjgzIDQ5LjQ0LS4xMi4xNy0uMzIuMjctLjUyLjI3SDUxLjA4Yy0uMjEgMC0uNC0uMS0uNTItLjI3LTI2LjU5LTM2LjUgMy4xMi02MC41NiAxNC4xOS02Mi43My41Mi0uMS43Mi0uNzMuMzQtMS4xbC0uMDMtLjAzYy0uMzctLjM1LS43MS0uNzUtMS4wMS0xLjE3YTguNiA4LjYgMCAwIDEtMS41OC00Ljk3YzAtNC43MSAzLjc5LTguNTIgOC40Ni04LjUyczguNDYgMy44MSA4LjQ2IDguNTJjMCAxLjg1LS41OSAzLjU3LTEuNTggNC45Ny0uMy40Mi0uNjQuODItMS4wMSAxLjE3LS4zNy4zNy0uMTcgMS4wMS4zNCAxLjA5IDMuMTIuNDcgNy4zMiAyLjM3IDExLjkyIDYuNy4yNC4yMy4yNy42MS4wNS44N0w3NC4xNyA1NS45N2MtLjIyLjI3LS4xOS42Ni4wOC44OWw0Ljk3IDQuM2MuMjcuMjQuNjkuMi45Mi0uMDhaIiBjbGFzcz0iY2xzLTYiLz48cGF0aCBkPSJNNzUuNDYgMzAuMmguMDMiIHN0eWxlPSJzdHJva2U6IzFlMWUxZTtzdHJva2UtbGluZWpvaW46cm91bmQ7c3Ryb2tlLXdpZHRoOjMuMDhweDtmaWxsOiM1ZjU5NTUiLz48Y2lyY2xlIGN4PSI2Ni42NiIgY3k9IjE4LjM4IiByPSIxLjkiIGNsYXNzPSJjbHMtOCIvPjxwYXRoIGQ9Ik02NC43IDMwLjM1YzMuODktNC4yNy0xMi42OCAzLjQzLTE4LjUgMTUuODktMy4wNCA2LjUyLTYuNjUgMTQuNy02LjUgMjEuNC4xNSA2LjEgOS4zNSAyMy41OSA3Ljk2IDE5LjYxQzM2LjA5IDUzLjk3IDU4LjEgMzcuNjEgNjQuNyAzMC4zNloiIGNsYXNzPSJjbHMtOCIvPjxwYXRoIGQ9Ik05My4yNCA5MC4xNGMtMi4xOSAyLjY4LTQuMjkgMy4xMi03LjU2IDMuMjEtMTAuMjYtLjY4LTIwLjU4LS4xLTIwLjU4LS4xbC0xNC4zMi0xLjM0YzM1LjgxLTEuODkgMzktMy40OSA0Ni4yMS05Ljg4bC0zLjc1IDguMVptLTI4LjYtNTguNDljMTEuNzctMS4wOCAxMS4zMi0uNTkgMTMuNi01LjkzbC0uNDcgNi4xNmMtLjggMi43OS03LjQ4IDMuNDItOS45MSAyLjI4LTEuMzUtLjYzLTMuMjEtMi41MS0zLjIxLTIuNTFaIiBjbGFzcz0iY2xzLTUiLz48cGF0aCBkPSJNNjYuMTMgMzAuMzhjMTEuMDItNC4yOSAxMC43Mi0zLjY5IDExLjQzLTkuNDZsMS4yNSA2LjA1YzAgMi45LTYuMjQgNS4zNS04LjkgNC45My0xLjQ3LS4yMy0zLjc4LTEuNTItMy43OC0xLjUyIiBjbGFzcz0iY2xzLTUiLz48cGF0aCBkPSJNODEuMzEgNTkuNTQgOTQgNDMuNjJjLjI2LS4zMi43Ni0uMzIgMSAuMDEgOC4wMSAxMC45NCAxMS43NiAyOC4wNy0zLjgyIDQ5LjQ2LS4xMi4xNi0uMzEuMjYtLjUxLjI2SDUwLjk4Yy0uMiAwLS40LS4xLS41MS0uMjYtMjYuNjEtMzYuNTIgMy4xNC02MC41OCAxNC4yMS02Mi43My41MS0uMS43MS0uNzIuMzMtMS4wOWwtLjA0LS4wNGMtLjM3LS4zNS0uNzEtLjc1LTEuMDEtMS4xN2E4LjYgOC42IDAgMCAxLTEuNTgtNC45N2MwLTQuNzEgMy43OS04LjUyIDguNDYtOC41MnM4LjQ2IDMuODEgOC40NiA4LjUyYzAgMS44NS0uNTkgMy41Ny0xLjU4IDQuOTctLjMuNDItLjY0LjgyLTEuMDEgMS4xN2gtLjAxYy0uMzcuMzctLjE3IDEuMDEuMzQgMS4wOCAzLjEyLjQ2IDcuMzMgMi4zNiAxMS45NCA2LjcxLjI0LjIzLjI2LjYxLjA1Ljg2TDc1LjY2IDU0LjE0YTMuMTg0IDMuMTg0IDAgMCAwIC4zNyA0LjQybDEuNTQgMS4zM2MxLjEzLjk4IDIuODQuODIgMy43Ny0uMzVaIiBjbGFzcz0iY2xzLTIiLz48cGF0aCBkPSJNNzUuNDYgMzAuMmguMDMiIHN0eWxlPSJzdHJva2U6IzFlMWUxZTtzdHJva2UtbGluZWpvaW46cm91bmQ7ZmlsbDpub25lO3N0cm9rZS13aWR0aDozLjA4cHgiLz48cGF0aCBkPSJNNjUgMjkuMjdjNC4xOCAzLjYyIDkuNDYgMS43MyAxMS42OC0uMDQiIGNsYXNzPSJjbHMtMiIvPjxwYXRoIGQ9Ik00Ny41MyA5MS41OWgtMi41MXYuMDRzLTEuMTMuMjItMi4wMi44N2MtLjg4LjY1LS42MyAyLjU0LS42MyAyLjU0cy0xLjI3LjcxLTIuODQgMS45Yy0xLjcxIDEuMzEtMy43NiAzLjE5LTQuODUgNS4zNi0yLjA4IDQuMTQgMS42MSA3LjczIDEuNjEgNy43M3MtMy43NiAxLjQyLTMuNzMgNC45MmMuMDMgMy40OSAxLjM1IDUuMjYgMy4zNiA1Ljg4aDY5Ljk3YzIuMDEtLjYxIDMuMzQtMi4zNyAzLjM2LTUuODdzLTMuNzQtNC45Mi0zLjc0LTQuOTIgMy43LTMuNTkgMS42MS03LjczYy0xLjA5LTIuMTctMy4xNC00LjA2LTQuODUtNS4zNi0xLjU2LTEuMi0yLjg0LTEuOS0yLjg0LTEuOXMuMjUtMS44OS0uNjMtMi41NC0yLjAyLS44Ny0yLjAyLS44N3YtLjA0aC0yLjUxIiBjbGFzcz0iY2xzLTYiLz48cGF0aCBkPSJtMTA1LjQyIDExMC4wNS02OS4yMi0uMDEiIHN0eWxlPSJzdHJva2Utd2lkdGg6MDtmaWxsOiM1ZjU5NTUiLz48cGF0aCBkPSJNMzMuNzYgMTE1LjEzYy4wMyAzLjM5IDEuNzUgNS4wOSA0LjM4IDUuNy4wMiAwIC4wNCAwIC4wNi4wMS0xLjA3LS45OS0xLjctMi41LTEuNzItNC42Ny0uMDMtMy41NSA0LjY5LTQuOTkgNC42OS00Ljk5cy00LjYzLTMuNjQtMi4wMy03LjgzYzEuMzctMi4yIDMuOTQtNC4xMSA2LjA5LTUuNDMgMS45Ni0xLjIxIDMuNTYtMS45MyAzLjU2LTEuOTNzLS4zMi0xLjkxLjc5LTIuNTdjMS4xLS42NiAyLjUzLS44OCAyLjUzLS44OHYtLjA0aC0zLjU3bDEuNDUuMDRzLTIuOTUuMjEtNC4xLjg1Yy0xLjE1LjYzLS44MiAyLjQ2LS44MiAyLjQ2cy0xLjY2LjY5LTMuNyAxLjg0Yy0yLjIzIDEuMjctMy44NyAyLjkyLTUuMjkgNS4wMi0yLjcxIDQuMDEgMi41MyA3LjY2IDIuNTMgNy42NnMtNC45MSAxLjM4LTQuODcgNC43N1oiIGNsYXNzPSJjbHMtOCIvPjxwYXRoIGQ9Im0xMDUuNDQgMTEwLjA1LTY5LjIxLS4wMSIgc3R5bGU9InN0cm9rZTojMWUxZTFlO3N0cm9rZS1saW5lam9pbjpyb3VuZDtmaWxsOm5vbmU7c3Ryb2tlLXdpZHRoOjEuNTVweCIvPjxwYXRoIGQ9Ik00Ny40OCA5MS41OWgtMi41MXYuMDRzLTEuMTMuMjItMi4wMi44N2MtLjg4LjY1LS42MyAyLjU0LS42MyAyLjU0cy0xLjI3LjcxLTIuODQgMS45Yy0xLjcxIDEuMzEtMy43NiAzLjE5LTQuODUgNS4zNi0yLjA4IDQuMTQgMS42MSA3LjczIDEuNjEgNy43M3MtMy43NiAxLjQyLTMuNzMgNC45MmMuMDMgMy40OSAxLjM1IDUuMjYgMy4zNiA1Ljg4aDY5Ljk3YzIuMDEtLjYxIDMuMzQtMi4zNyAzLjM2LTUuODdzLTMuNzQtNC45Mi0zLjc0LTQuOTIgMy43LTMuNTkgMS42MS03LjczYy0xLjA5LTIuMTctMy4xNC00LjA2LTQuODUtNS4zNi0xLjU2LTEuMi0yLjg0LTEuOS0yLjg0LTEuOXMuMjUtMS44OS0uNjMtMi41NC0yLjAyLS44Ny0yLjAyLS44N3YtLjA0SDQ3LjQ5WiIgY2xhc3M9ImNscy0yIi8+PHBhdGggZD0iTTEwNy41OSAxMTUuM2MtLjA0IDMuNjMtLjE4IDUuNDgtMi44NSA2LjEzaC01LjI1YzEuMDktMS4wNiA0LjAyLTIuNzQgNC4wNC01LjA3LjA0LTMuODEtMy45Ni02LjE0LTMuOTYtNi4xNHM2LjYxLTMuNTkgMy45Ni04LjA5Yy0xLjM5LTIuMzYtMS4yMS0yLjU4LTMuMzktNC4wMS0xLjk5LTEuMjktNC4zNy0zLjM3LTQuMzctMy4zN3MuMzItMi4wNS0uOC0yLjc2LTIuNTgtLjk1LTIuNTgtLjk1LTMuNDYgMC0zLjQ3LS4wM2g3LjFsLTEuNDguMDNzMS43Ny0uMjUgMi45NC40M2MxLjE3LjY3IDEuMzYgMi4yNiAxLjM2IDIuMjZzLjM2IDEuNTMgMi40MyAyLjc3YzIuMjcgMS4zNiAzLjk0IDIuNzcgNS4zOCA1LjAzIDIuNzYgNC4zLTQuMDIgOC42NS00LjAyIDguNjVzNC45OSAxLjQ4IDQuOTUgNS4xMloiIHN0eWxlPSJzdHJva2Utd2lkdGg6MDtmaWxsOiMwMDA7aXNvbGF0aW9uOmlzb2xhdGU7b3BhY2l0eTouMTgiLz48L3N2Zz4=')} +.is2d .rook.white {background-image:url('data:image/svg+xml;base64,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')} +.is2d .queen.white {background-image:url('data:image/svg+xml;base64,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')} +.is2d .king.white {background-image:url('data:image/svg+xml;base64,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')} +.is2d .pawn.black {background-image:url('data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIGlkPSJMYXllcl8yIiBkYXRhLW5hbWU9IkxheWVyIDIiIHZlcnNpb249IjEuMSIgdmlld0JveD0iMCAwIDE0MS43IDE0MS43Ij48ZGVmcz48c3R5bGU+LmNscy0xLC5jbHMtMiwuY2xzLTN7c3Ryb2tlLXdpZHRoOjB9LmNscy0xLC5jbHMtNXtmaWxsOm5vbmV9LmNscy0yLC5jbHMtM3tpc29sYXRpb246aXNvbGF0ZTtvcGFjaXR5Oi4yfS5jbHMtMntmaWxsLXJ1bGU6ZXZlbm9kZDtmaWxsOiMwMDB9LmNscy0ze2ZpbGw6I2ZmZn0uY2xzLTV7c3Ryb2tlLXdpZHRoOjIuOHB4fS5jbHMtNSwuY2xzLTl7c3Ryb2tlLWxpbmVjYXA6cm91bmQ7c3Ryb2tlLWxpbmVqb2luOnJvdW5kfS5jbHMtNXtzdHJva2U6IzFlMWUxZX0uY2xzLTl7c3Ryb2tlOiMzYzNjM2M7c3Ryb2tlLXdpZHRoOjIuOXB4O2ZpbGw6IzVmNTk1NX08L3N0eWxlPjwvZGVmcz48cGF0aCBkPSJNMzEuOSAxNi4yaDc4djEwOS4zaC03OHoiIGNsYXNzPSJjbHMtMSIvPjxwYXRoIGQ9Ik05NC44IDkwLjlzMCAwIDAgMGgtMi42bC01LjktNC44LTMuNy0yNC41YzIwLjktMTUuOSA2LjctNDEuMi0xMS44LTQxLjJoMGMtMTguNSAwLTMyLjEgMjUuNC0xMS4yIDQxLjNsLTQuMSAyNC41LTUuOSA0LjhINDciIGNsYXNzPSJjbHMtOSIvPjxwYXRoIGQ9Ik04MyA2MS4yYy02LjIgNC4yLTE3LjUgNC4yLTIzLjkgMCIgY2xhc3M9ImNscy05Ii8+PHBhdGggZD0iTTgzIDYxLjJjLTYuMiA0LjItMTcuNSA0LjItMjMuOSAwIiBzdHlsZT0iZmlsbDpub25lO3N0cm9rZS1saW5lY2FwOnJvdW5kO3N0cm9rZS1saW5lam9pbjpyb3VuZDtzdHJva2U6IzNjM2MzYztzdHJva2Utd2lkdGg6Mi45cHgiLz48cGF0aCBkPSJNNjMuNyA2NC41IDYxLjggODdoLTUuOWwzLjItMjMuNHoiIGNsYXNzPSJjbHMtMyIvPjxjaXJjbGUgY3g9IjYwLjEiIGN5PSIzMC42IiByPSI0LjYiIGNsYXNzPSJjbHMtMyIvPjxwYXRoIGQ9Im02MS44IDg3LTQuOSAzLjYtNS4xLS4yIDQuMS0zLjR6IiBjbGFzcz0iY2xzLTMiLz48cGF0aCBkPSJNODMuNyA2NC4xYy0yIDIuMy0zLjUgNC02LjkgNC42LTguOCAxLTExLjMtMi4zLTEyLjctMy45LS4zLS4zLS4zLS43IDAtMS4xbC0zLjktLjdjLS42IDIgMTUuNiA0LjMgMjIuNC0xLjZsMS4xIDIuNloiIGNsYXNzPSJjbHMtMiIvPjxwYXRoIGQ9Ik04NS4zIDU5LjNjLTIuNiAxLjYtMy41IDQtNi45IDQuNi04LjggMS0xMSAxLjctMTIuMy4yLS4zLS4zLS4zLS43IDAtMS4xbC0zLjktLjdjLS42IDIgMjctLjggMjkuNC0yNC4xIDIuNi0uMSAxLjYgMTYuMy02LjMgMjFaIiBjbGFzcz0iY2xzLTIiLz48cGF0aCBkPSJNOTQuOSA5MC45czAgMCAwIDBoLTIuNmwtNS45LTQuOC0zLjctMjQuNWMyMC45LTE1LjkgNi43LTQxLjItMTEuOC00MS4yaDBjLTE4LjUgMC0zMi4xIDI1LjQtMTEuMiA0MS4zbC00LjEgMjQuNS01LjkgNC44aC0yLjYiIGNsYXNzPSJjbHMtNSIvPjxwYXRoIGQ9Ik04MyA2MS4yYy02LjIgNC4yLTE3LjUgNC4yLTIzLjkgMCIgY2xhc3M9ImNscy01Ii8+PHBhdGggZD0iTTkzLjcgOTUuM0g0OCIgc3R5bGU9ImZpbGw6bm9uZTtzdHJva2UtbGluZWpvaW46cm91bmQ7c3Ryb2tlOiMxZTFlMWU7c3Ryb2tlLXdpZHRoOjIuOXB4Ii8+PHBhdGggZD0iTTkyLjggOTFoMi40czEuMS4zIDEuOS45Yy44LjcuNiAyLjYuNiAyLjZzMS4yLjcgMi43IDJjMS42IDEuNCAzLjUgMy4zIDQuNiA1LjYgMiA0LjMtMS41IDgtMS41IDhzMy41IDEuNSAzLjUgNS4xLTEuMyA1LjUtMy4yIDYuMUgzOGMtMS45LS42LTMuMS0yLjUtMy4yLTYuMSAwLTMuNiAzLjUtNS4xIDMuNS01LjFzLTMuNS0zLjctMS41LThjMS0yLjMgMi45LTQuMiA0LjYtNS42IDEuNS0xLjIgMi43LTIgMi43LTJzLS4yLTIgLjYtMi42Yy44LS43IDEuOS0uOSAxLjktLjlINDkiIHN0eWxlPSJzdHJva2UtbGluZWNhcDpyb3VuZDtzdHJva2UtbGluZWpvaW46cm91bmQ7c3Ryb2tlOiMzYzNjM2M7ZmlsbDojNWY1OTU1O3N0cm9rZS13aWR0aDoyLjdweCIvPjxwYXRoIGQ9Ik0zOC40IDExMC4yaDY1LjEiIGNsYXNzPSJjbHMtMSIvPjxwYXRoIGQ9Ik0xMDUuOCAxMTUuNWMwIDMuNS0uMiA1LjMtMi42IDUuOWgtNC45YzEtMSAzLjctMi43IDMuNy00LjkgMC0zLjctMy43LTYtMy43LTZzNi4xLTMuNSAzLjctNy45Yy0xLjMtMi4zLTEuMS0yLjUtMy4xLTMuOS0xLjgtMS4zLTQtMy4zLTQtMy4zcy4zLTItLjctMi43LTIuNC0uOS0yLjQtLjloLTMuMiA2LjYtMS40czEuNi0uMiAyLjcuNSAxLjMgMi4yIDEuMyAyLjIuMyAxLjUgMi4yIDIuN2MyLjEgMS4zIDMuNiAyLjcgNSA0LjkgMi42IDQuMi0zLjcgOC40LTMuNyA4LjRzNC42IDEuNCA0LjYgNVoiIHN0eWxlPSJzdHJva2Utd2lkdGg6MDtpc29sYXRpb246aXNvbGF0ZTtmaWxsOiMwMDA7b3BhY2l0eTouMiIvPjxwYXRoIGQ9Ik0zNS45IDExNGMwIDMuNiAxLjggNS41IDQuNiA2LjEtMS4xLTEuMS0xLjgtMi43LTEuOC01IDAtMy44IDQuOS01LjQgNC45LTUuNHMtNC44LTMuOS0yLjEtOC40YzEuNC0yLjQgNC4xLTQuNCA2LjMtNS44IDItMS4zIDMuNy0yLjEgMy43LTIuMXMtLjMtMi4xLjgtMi44IDIuNi0xIDIuNi0xaC0zLjcgMS41cy0zLjEuMy00LjMuOWMtMS4yLjctLjkgMi42LS45IDIuNnMtMS43LjctMy44IDJjLTIuMyAxLjQtNCAzLjEtNS41IDUuNC0yLjggNC4zIDIuNiA4LjIgMi42IDguMnMtNS4xIDEuNS01LjEgNS4xWiIgY2xhc3M9ImNscy0zIi8+PHBhdGggZD0iTTM4LjQgMTEwLjJoNjUuMSIgc3R5bGU9ImZpbGw6bm9uZTtzdHJva2UtbGluZWNhcDpyb3VuZDtzdHJva2UtbGluZWpvaW46cm91bmQ7c3Ryb2tlOiMxZTFlMWU7c3Ryb2tlLXdpZHRoOjEuNXB4Ii8+PHBhdGggZD0iTTkyLjkgOTFoMi40czEuMS4zIDEuOS45Yy44LjcuNiAyLjYuNiAyLjZzMS4yLjcgMi43IDJjMS42IDEuNCAzLjUgMy4zIDQuNiA1LjYgMiA0LjMtMS41IDgtMS41IDhzMy41IDEuNSAzLjUgNS4xLTEuMyA1LjUtMy4yIDYuMUgzOGMtMS45LS42LTMuMS0yLjUtMy4yLTYuMSAwLTMuNiAzLjUtNS4xIDMuNS01LjFzLTMuNS0zLjctMS41LThjMS0yLjMgMi45LTQuMiA0LjYtNS42IDEuNS0xLjIgMi43LTIgMi43LTJzLS4yLTIgLjYtMi42Yy44LS43IDEuOS0uOSAxLjktLjl6IiBjbGFzcz0iY2xzLTUiLz48L3N2Zz4=')} +.is2d .knight.black {background-image:url('data:image/svg+xml;base64,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')} +.is2d .bishop.black {background-image:url('data:image/svg+xml;base64,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')} +.is2d .rook.black {background-image:url('data:image/svg+xml;base64,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')} +.is2d .queen.black {background-image:url('data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIGlkPSJMYXllcl8yIiBkYXRhLW5hbWU9IkxheWVyIDIiIHZpZXdCb3g9IjAgMCAxNDEuNzMgMTQxLjczIj48ZGVmcz48c3R5bGU+LmNscy0xe2ZpbGwtcnVsZTpldmVub2RkfS5jbHMtMSwuY2xzLTIsLmNscy0ze3N0cm9rZS13aWR0aDowfS5jbHMtMXtmaWxsOiMwMDA7aXNvbGF0aW9uOmlzb2xhdGU7b3BhY2l0eTouMTh9LmNscy02e2ZpbGw6bm9uZTtzdHJva2U6IzFlMWUxZTtzdHJva2UtbGluZWpvaW46cm91bmQ7c3Ryb2tlLXdpZHRoOjMuMDJweH0uY2xzLTJ7ZmlsbDojZmZmO29wYWNpdHk6LjI1fS5jbHMtM3tmaWxsOiM1ZjU5NTV9PC9zdHlsZT48L2RlZnM+PHBhdGggZD0iTTQyLjE1IDc3LjAxYy0zLjg5LTExLjg5LTEwLjM4LTI1Ljc0LTE3LjUyLTM2LjI5IDAgMCAyLjg1LjA3IDcuNTkuMDEgMCAwIDEuMDMgNS42NCA0LjAyIDUuODMgMy4wMy4yIDMuNDktNC4xMSAzLjQ5LTQuMTFoNi4yMmwyLjAxIDEuMjRoMS4wMXM1Ljg3LTcuOTcgMTUuNjItNy45NWMtMi45My0xLjkyLTQuODctNS4yLTQuODctOC45MyAwLTUuOTEgNC44Ny0xMC43IDEwLjg3LTEwLjcuMSAwIC4yMSAwIC4zMS4wMS4xLS4wMS4yMS0uMDEuMzEtLjAxIDYgMCAxMC44NyA0Ljc5IDEwLjg3IDEwLjcgMCAzLjczLTEuOTQgNy4wMS00Ljg3IDguOTMgOS43NS0uMDIgMTQuODMgNi4zNiAxNC44MyA2LjM2aDEuMDFsMi44LjM1aDYuMjJzLjQ1IDQuMzEgMy40OSA0LjExYzIuOTktLjE5IDQuMDItNS44MyA0LjAyLTUuODMgNC43NC4wNiA3LjU5LS4wMSA3LjU5LS4wMS03LjE0IDEwLjU1LTEzLjYzIDI0LjQtMTcuNTIgMzYuMjlsLTMuMDEgMTEuNGMtLjczIDMuODYtLjk1IDcuMTUtLjU2IDkuNTZINDUuNzNjLjM5LTIuNDEuMTYtNS43LS41Ni05LjU2bC0zLjAxLTExLjRaIiBjbGFzcz0iY2xzLTMiLz48cGF0aCBkPSJNNjQuNTggMzUuNzRzNi4xNyAzLjU4IDEyLjYzIDBoLS4wMyIgY2xhc3M9ImNscy0zIi8+PHBhdGggZD0iTTI3LjExIDQxLjE3czE3LjUxIDI5LjQ0IDE4LjYxIDU2LjgxYy4wNSAxLjE2IDIuNDUgMS41MyAyLjg1IDAgNC40LTE3LjEtMTcuNjUtNTYuODEtMTcuNjUtNTYuODF6IiBjbGFzcz0iY2xzLTIiLz48ZWxsaXBzZSBjeD0iNjciIGN5PSIyMCIgY2xhc3M9ImNscy0yIiByeD0iMi40MiIgcnk9IjIuMzgiLz48cGF0aCBkPSJNOTYuMzIgOTUuNjRjLTIuMTEgMi4xNi0yLjM2IDIuMDEtNS40OSAyLjEtOS44MS0uNTEtMTkuNjggMC0xOS42OCAwbC0xMy42OS0xLjAyYzM0LjI2LTEuNjYgMzIuMDEtNC40OSAzOC45My05LjY2eiIgY2xhc3M9ImNscy0xIi8+PHBhdGggZD0iTTQ4LjU0IDk4LjAyaC0yLjR2LjA0cy0xLjA5LjItMS45My44MmMtLjg1LjYyLS42IDIuNC0uNiAyLjRzLTEuMjIuNjctMi43MiAxLjc5Yy0xLjY0IDEuMjMtMy42IDMuMDEtNC42NCA1LjA1LTEuOTkgMy45IDEuNTQgNy4yOSAxLjU0IDcuMjlzLTMuNiAxLjM0LTMuNTggNC42NGMuMDMgMy4yOSAxLjI5IDQuOTYgMy4yMiA1LjU0aDY3LjAyYzEuOTMtLjU4IDMuMTktMi4yNCAzLjIyLTUuNTMuMDItMy4zLTMuNTgtNC42NC0zLjU4LTQuNjRzMy41NC0zLjM5IDEuNTUtNy4yOWMtMS4wNC0yLjA0LTMuMDEtMy44My00LjY1LTUuMDUtMS41LTEuMTMtMi43Mi0xLjc5LTIuNzItMS43OXMuMjQtMS43OC0uNi0yLjRjLS44NS0uNjItMS45My0uODItMS45My0uODJ2LS4wNGgtMi40MW0xMC42NiAxNy40LTY2LjMtLjAxIiBjbGFzcz0iY2xzLTMiLz48cGF0aCBkPSJNMzUuMzUgMTIwLjIyYy4wMyAzLjE5IDEuNjggNC44IDQuMTkgNS4zOC4wMiAwIC4wNCAwIC4wNi4wMS0xLjAyLS45My0xLjYzLTIuMzUtMS42NC00LjQtLjAzLTMuMzUgNC40OS00LjcgNC40OS00LjdzLTQuNDQtMy40My0xLjk0LTcuMzljMS4zMS0yLjA3IDMuNzgtMy44NyA1Ljg0LTUuMTIgMS44OC0xLjE0IDMuNDEtMS44MiAzLjQxLTEuODJzLS4zMS0xLjguNzYtMi40M2MxLjA2LS42MiAyLjQzLS44MyAyLjQzLS44M3YtLjAzaC0zLjQybDEuMzkuMDNzLTIuODIuMi0zLjkzLjhjLTEuMS41OS0uNzkgMi4zMi0uNzkgMi4zMnMtMS41OS42NS0zLjU0IDEuNzRjLTIuMTQgMS4xOS0zLjcgMi43NS01LjA2IDQuNzMtMi42IDMuNzggMi40MiA3LjIyIDIuNDIgNy4yMnMtNC43IDEuMy00LjY2IDQuNVoiIGNsYXNzPSJjbHMtMiIvPjxwYXRoIGQ9Ik02NC42MiAzNi41NGMxMi45NC0xLjA2IDEyLjQzLjM4IDE0Ljk2LTQuNjdsLS41NSA1LjgxYy0uODkgMi42My04LjIyIDMuMjUtMTAuOSAyLjE5LTEuNDgtLjU5LTMuNTItMy4zMy0zLjUyLTMuMzNabTIzLjQ2IDEyLjJjLS4yLTQuNjMtLjA3LTguMzktNi40MS0xMS4ybDcuNDUuOTFjMy4zMyAxLjA0IDMuNjMgNi4xMiAyLjA4IDguNjgtLjg2IDEuNDItMy4xMiAxLjYtMy4xMiAxLjZaIiBjbGFzcz0iY2xzLTEiLz48cGF0aCBkPSJNNjYuMjYgNDMuODRzLTEuMDMgNS43NiA0LjY4IDUuN2M1LjMyLS4wNiA0LjQ1LTUuNzEgNC40NS01LjcxaDEwLjE2cy40NSA0LjMxIDMuNDkgNC4xMWMyLjk5LS4xOSA0LjAyLTUuODMgNC4wMi01LjgzaDIuNzRsNi4yMi0uMDFzLjQ1IDQuMzEgMy40OSA0LjExYzIuOTktLjE5IDQuMDItNS44MyA0LjAyLTUuODMgNC43NC4wNiA3LjU5LS4wMSA3LjU5LS4wMS03LjE0IDEwLjU1LTEzLjYzIDI0LjQtMTcuNTIgMzYuMjlsLTMuMDEgMTEuNGMtLjczIDMuODYtLjk1IDcuMTUtLjU2IDkuNTZINDUuNjhjLjM5LTIuNDEuMTYtNS43LS41Ni05LjU2bC0zLjAxLTExLjRjLTMuODktMTEuODktMTAuMzgtMjUuNzQtMTcuNTItMzYuMjkgMCAwIDIuODUuMDcgNy41OS4wMSAwIDAgMS4wMyA1LjY0IDQuMDIgNS44MyAzLjAzLjIgMy40OS00LjExIDMuNDktNC4xMWg4Ljg3czEuMDMgNS42NCA0LjAyIDUuODNjMy4wMy4yIDMuNDktNC4xMSAzLjQ5LTQuMTFsOC4zMS4wM2gxLjkxWiIgY2xhc3M9ImNscy02Ii8+PHBhdGggZD0iTTEwNy41MiAxMTkuNzRjLS4wNCAzLjE5LS4yMSA0LjgxLTMuMzggNS4zOEg5Ny45YzEuMjktLjkzIDQuNzgtMi40IDQuOC00LjQ1LjA0LTMuMzQtNC43LTUuMzktNC43LTUuMzlzNy44NS0zLjE1IDQuNy03LjExYy0xLjY1LTIuMDctMS40My0yLjI3LTQuMDMtMy41Mi0yLjM3LTEuMTQtNS4yLTIuOTYtNS4yLTIuOTZzLjM5LTEuOC0uOTYtMi40M2MtMS4zNC0uNjItMy4wNi0uODMtMy4wNi0uODNzLTQuMTIgMC00LjEzLS4wM2g4LjQ0bC0xLjc1LjAzczIuMS0uMjIgMy41LjM4YzEuMzkuNTkgMS42MiAxLjk5IDEuNjIgMS45OXMuNDMgMS4zNCAyLjg5IDIuNDNjMi43IDEuMTkgNC42OSAyLjQzIDYuNCA0LjQxIDMuMjggMy43OC00Ljc4IDcuNi00Ljc4IDcuNnM1LjkzIDEuMyA1Ljg4IDQuNDlaIiBzdHlsZT0ic3Ryb2tlLXdpZHRoOjA7ZmlsbDojMDAwO2lzb2xhdGlvbjppc29sYXRlO29wYWNpdHk6LjE4Ii8+PHBhdGggZD0ibTEwNC4wMSAxMTUuNDMtNjYuMjktLjAxIiBzdHlsZT0iZmlsbDpub25lO3N0cm9rZTojMWUxZTFlO3N0cm9rZS1saW5lam9pbjpyb3VuZDtzdHJva2Utd2lkdGg6MS41OHB4Ii8+PHBhdGggZD0iTTQ4LjQ5IDk4LjAyaC0yLjR2LjA0cy0xLjA5LjItMS45My44MmMtLjg1LjYyLS42IDIuNC0uNiAyLjRzLTEuMjIuNjctMi43MiAxLjc5Yy0xLjY0IDEuMjMtMy42IDMuMDEtNC42NCA1LjA1LTEuOTkgMy45IDEuNTQgNy4yOSAxLjU0IDcuMjlzLTMuNiAxLjM0LTMuNTggNC42NGMuMDMgMy4yOSAxLjI5IDQuOTYgMy4yMiA1LjU0aDY3LjAyYzEuOTMtLjU4IDMuMTktMi4yNCAzLjIyLTUuNTMuMDItMy4zLTMuNTgtNC42NC0zLjU4LTQuNjRzMy41NC0zLjM5IDEuNTUtNy4yOWMtMS4wNC0yLjA0LTMuMDEtMy44My00LjY1LTUuMDUtMS41LTEuMTMtMi43Mi0xLjc5LTIuNzItMS43OXMuMjQtMS43OC0uNi0yLjRjLS44NS0uNjItMS45My0uODItMS45My0uODJ2LS4wNEg0OC41M1oiIHN0eWxlPSJzdHJva2Utd2lkdGg6My4wM3B4O2ZpbGw6bm9uZTtzdHJva2U6IzFlMWUxZTtzdHJva2UtbGluZWpvaW46cm91bmQiLz48cGF0aCBkPSJNNjcuMjQgMzUuMzFjMTIuNzEtNC44OSAxMi4zNi00LjIgMTMuMTQtMTAuODlsMS40OSA3LjAzYy4wMiAzLjM2LTcuMTcgNi4xNi0xMC4yNSA1LjY1LTEuNy0uMjgtNC4zOC0xLjgtNC4zOC0xLjhaIiBjbGFzcz0iY2xzLTEiLz48cGF0aCBkPSJNNDkuMzIgNDIuMDlzNS41LTYuMzcgMTUuMjYtNi4zNWMtMi45My0xLjkyLTQuODctNS4yLTQuODctOC45MyAwLTUuOTEgNC44Ny0xMC43IDEwLjg3LTEwLjcuMSAwIC4yMSAwIC4zMS4wMS4xLS4wMS4yMS0uMDEuMzEtLjAxIDYgMCAxMC44NyA0Ljc5IDEwLjg3IDEwLjcgMCAzLjczLTEuOTQgNy4wMS00Ljg3IDguOTMgOS43NS0uMDIgMTUuODQgNi4zNiAxNS44NCA2LjM2IiBjbGFzcz0iY2xzLTYiLz48cGF0aCBkPSJNNjQuNTggMzUuNzRzNi4xNyAzLjU4IDEyLjYzIDBoLS4wMyIgY2xhc3M9ImNscy02Ii8+PC9zdmc+')} +.is2d .king.black {background-image:url('data:image/svg+xml;base64,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')} diff --git a/public/piece/cooke/bB.svg b/public/piece/cooke/bB.svg index acd017f6615c6..8b3edfeb8a8a2 100644 --- a/public/piece/cooke/bB.svg +++ b/public/piece/cooke/bB.svg @@ -1,76 +1 @@ - - - - - - - - - - - - - - - - - - - - - - - - - - - - \ No newline at end of file + \ No newline at end of file diff --git a/public/piece/cooke/bK.svg b/public/piece/cooke/bK.svg index 373b8827f5324..48b91bc6ad8b0 100644 --- a/public/piece/cooke/bK.svg +++ b/public/piece/cooke/bK.svg @@ -1,65 +1 @@ - - - - - - - - - - - - - - - - - - - - - - - - \ No newline at end of file + \ No newline at end of file diff --git a/public/piece/cooke/bN.svg b/public/piece/cooke/bN.svg index 6875e4d199153..b120f611acec9 100644 --- a/public/piece/cooke/bN.svg +++ b/public/piece/cooke/bN.svg @@ -1,87 +1 @@ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - \ No newline at end of file + \ No newline at end of file diff --git a/public/piece/cooke/bP.svg b/public/piece/cooke/bP.svg index b9515ac790919..cafb3ffb8d146 100644 --- a/public/piece/cooke/bP.svg +++ b/public/piece/cooke/bP.svg @@ -1,90 +1 @@ - - - - - - - - - - - - - - - - - - - - - - - - - - - - \ No newline at end of file + \ No newline at end of file diff --git a/public/piece/cooke/bQ.svg b/public/piece/cooke/bQ.svg index be666f974178f..72819d6440ae0 100644 --- a/public/piece/cooke/bQ.svg +++ b/public/piece/cooke/bQ.svg @@ -1,68 +1 @@ - - - - - - - - - - - - - - - - - - - - - - - - - - - \ No newline at end of file + \ No newline at end of file diff --git a/public/piece/cooke/bR.svg b/public/piece/cooke/bR.svg index 43304a074fa9f..be06839d5ff68 100644 --- a/public/piece/cooke/bR.svg +++ b/public/piece/cooke/bR.svg @@ -1,85 +1 @@ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - \ No newline at end of file + \ No newline at end of file diff --git a/public/piece/cooke/wB.svg b/public/piece/cooke/wB.svg index bc46ff2fe3444..428f6be5d764d 100644 --- a/public/piece/cooke/wB.svg +++ b/public/piece/cooke/wB.svg @@ -1,71 +1 @@ - - - - - - - - - - - - - - - - - - - - - - - - \ No newline at end of file + \ No newline at end of file diff --git a/public/piece/cooke/wK.svg b/public/piece/cooke/wK.svg index 19111ab772185..42ad237ae5219 100644 --- a/public/piece/cooke/wK.svg +++ b/public/piece/cooke/wK.svg @@ -1,68 +1 @@ - - - - - - - - - - - - - - - - - - - - - - - - \ No newline at end of file + \ No newline at end of file diff --git a/public/piece/cooke/wN.svg b/public/piece/cooke/wN.svg index 170212b9aba5b..6de7b018d5f22 100644 --- a/public/piece/cooke/wN.svg +++ b/public/piece/cooke/wN.svg @@ -1,83 +1 @@ - - - - - - - - - - - - - - - - - - - - - - - - - - - - \ No newline at end of file + \ No newline at end of file diff --git a/public/piece/cooke/wP.svg b/public/piece/cooke/wP.svg index ee712fc0bd25f..ad46cddad2ddf 100644 --- a/public/piece/cooke/wP.svg +++ b/public/piece/cooke/wP.svg @@ -1,83 +1 @@ - - - - - - - - - - - - - - - - - - - - - - - - - - - - \ No newline at end of file + \ No newline at end of file diff --git a/public/piece/cooke/wQ.svg b/public/piece/cooke/wQ.svg index 4b98dcd5c9850..414078b8aa768 100644 --- a/public/piece/cooke/wQ.svg +++ b/public/piece/cooke/wQ.svg @@ -1,67 +1 @@ - - - - - - - - - - - - - - - - - - - - - - - - - - - \ No newline at end of file + \ No newline at end of file diff --git a/public/piece/cooke/wR.svg b/public/piece/cooke/wR.svg index 2b9ef3c97b4a7..79373b65b5f99 100644 --- a/public/piece/cooke/wR.svg +++ b/public/piece/cooke/wR.svg @@ -1,88 +1 @@ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - \ No newline at end of file + \ No newline at end of file From 7fd2fb0d6d50df9a47bbd1d743874b44ba10a126 Mon Sep 17 00:00:00 2001 From: Scala Steward Date: Fri, 14 Jun 2024 17:00:49 +0000 Subject: [PATCH 027/168] Update scalafmt-core to 3.8.2 --- .scalafmt.conf | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.scalafmt.conf b/.scalafmt.conf index 03d951870dc2a..f1245a49e7c76 100644 --- a/.scalafmt.conf +++ b/.scalafmt.conf @@ -1,4 +1,4 @@ -version = "3.8.1" +version = "3.8.2" runner.dialect = scala3 align.preset = more From 2b774ffaf8926dc9986954f3c427cbe479e05f6a Mon Sep 17 00:00:00 2001 From: Scala Steward Date: Fri, 14 Jun 2024 17:02:40 +0000 Subject: [PATCH 028/168] Reformat with scalafmt 3.8.2 Executed command: scalafmt --non-interactive --- modules/activity/src/main/activities.scala | 4 +- modules/coach/src/main/ui/CoachUi.scala | 3 +- modules/db/src/main/dsl.scala | 20 ++++---- modules/game/src/main/GameDiff.scala | 4 +- modules/game/src/main/JsonView.scala | 50 +++++++++---------- modules/msg/src/main/BsonHandlers.scala | 6 +-- modules/rating/src/main/RatingRegulator.scala | 4 +- .../src/main/TournamentStandingApi.scala | 4 +- 8 files changed, 48 insertions(+), 47 deletions(-) diff --git a/modules/activity/src/main/activities.scala b/modules/activity/src/main/activities.scala index 07d5c1752a24a..19856416d59a1 100644 --- a/modules/activity/src/main/activities.scala +++ b/modules/activity/src/main/activities.scala @@ -15,7 +15,7 @@ object activities: extension (a: Games) def add(pt: PerfKey, score: Score): Games = a.value + (pt -> a.value.get(pt).fold(score)(_.plus(score))) - def hasNonCorres = a.value.exists(_._1 != PerfKey.correspondence) + def hasNonCorres = a.value.exists(_._1 != PerfKey.correspondence) given Zero[Games] = Zero(Map.empty) opaque type ForumPosts = List[ForumPostId] @@ -62,7 +62,7 @@ object activities: extension (a: Practice) def +(studyId: StudyId): Practice = a.value + (studyId -> a.value.get(studyId).fold(1)(1 +)) - given Zero[Practice] = Zero(Map.empty) + given Zero[Practice] = Zero(Map.empty) opaque type Simuls = List[SimulId] object Simuls extends TotalWrapper[Simuls, List[SimulId]]: diff --git a/modules/coach/src/main/ui/CoachUi.scala b/modules/coach/src/main/ui/CoachUi.scala index 30114635ec9f2..97dd2087c1235 100644 --- a/modules/coach/src/main/ui/CoachUi.scala +++ b/modules/coach/src/main/ui/CoachUi.scala @@ -148,7 +148,8 @@ final class CoachUi(helpers: Helpers)( cls := "text button button-empty", dataIcon := Icon.BubbleSpeech, href := s"${routes.Msg.convo(c.user.username)}" - )(trc.sendPM()), + )(trc.sendPM()) + , ), div(cls := "coach-show__main coach-main box")( div(cls := "coach-widget")(widget(c, link = false)), diff --git a/modules/db/src/main/dsl.scala b/modules/db/src/main/dsl.scala index a2eff998db74e..8370c9fc9b665 100644 --- a/modules/db/src/main/dsl.scala +++ b/modules/db/src/main/dsl.scala @@ -339,21 +339,21 @@ object dsl extends dsl with Handlers: // like headOption, but with stopOnError defaulting to false def uno: Fu[Option[A]] = - c.collect[Iterable](1, Cursor.ContOnError[Iterable[A]]()).map(_.headOption) + c.collect[Iterable](1, Cursor.ContOnError[Iterable[A]]()).map(_.headOption) - // extension [A](cursor: Cursor.WithOps[A])(using Executor) + // extension [A](cursor: Cursor.WithOps[A])(using Executor) - // def gather[M[_]](upTo: Int)(using Factory[A, M[A]]): Fu[M[A]] = - // cursor.collect[M](upTo, Cursor.ContOnError[M[A]]()) + // def gather[M[_]](upTo: Int)(using Factory[A, M[A]]): Fu[M[A]] = + // cursor.collect[M](upTo, Cursor.ContOnError[M[A]]()) - // def list(): Fu[List[A]] = - // gather[List](Int.MaxValue) + // def list(): Fu[List[A]] = + // gather[List](Int.MaxValue) - // def list(limit: Int): Fu[List[A]] = - // gather[List](limit) + // def list(limit: Int): Fu[List[A]] = + // gather[List](limit) - // def list(limit: Option[Int]): Fu[List[A]] = - // gather[List](limit | Int.MaxValue) + // def list(limit: Option[Int]): Fu[List[A]] = + // gather[List](limit | Int.MaxValue) def vector(limit: Int): Fu[Vector[A]] = gather[Vector](limit) diff --git a/modules/game/src/main/GameDiff.scala b/modules/game/src/main/GameDiff.scala index ab73a10237385..e52890c4ce2dc 100644 --- a/modules/game/src/main/GameDiff.scala +++ b/modules/game/src/main/GameDiff.scala @@ -33,7 +33,7 @@ object GameDiff: val vb = getter(b) if getter(a) != vb then if vb == None || vb == null || vb == "" then unsetBuilder += (name -> bTrue) - else setBuilder += name -> toBson(vb) + else setBuilder += name -> toBson(vb) def dOpt[A](name: String, getter: Game => A, toBson: A => Option[BSONValue]): Unit = val vb = getter(b) @@ -42,7 +42,7 @@ object GameDiff: else toBson(vb) match case None => unsetBuilder += (name -> bTrue) - case Some(x) => setBuilder += name -> x + case Some(x) => setBuilder += name -> x def dTry[A](name: String, getter: Game => A, toBson: A => Try[BSONValue]): Unit = d[A](name, getter, a => toBson(a).get) diff --git a/modules/game/src/main/JsonView.scala b/modules/game/src/main/JsonView.scala index ff6a26fa29b8b..8d4743f51d5a5 100644 --- a/modules/game/src/main/JsonView.scala +++ b/modules/game/src/main/JsonView.scala @@ -13,31 +13,31 @@ final class JsonView(rematches: Rematches): import JsonView.given def base(game: Game, initialFen: Option[Fen.Full]) = - Json - .obj( - "id" -> game.id, - "variant" -> game.variant, - "speed" -> game.speed.key, - "perf" -> game.perfKey, - "rated" -> game.rated, - "fen" -> Fen.write(game.chess), - "turns" -> game.ply, - "source" -> game.source, - "status" -> game.status, - "createdAt" -> game.createdAt - ) - .add("startedAtTurn" -> game.chess.startedAtPly.some.filter(_ > 0)) - .add("initialFen" -> initialFen) - .add("threefold" -> game.history.threefoldRepetition) - .add("boosted" -> game.boosted) - .add("tournamentId" -> game.tournamentId) - .add("swissId" -> game.swissId) - .add("winner" -> game.winnerColor) - .add("rematch" -> rematches.getAcceptedId(game.id)) - .add("rules" -> game.metadata.nonEmptyRules) - .add("drawOffers" -> (!game.drawOffers.isEmpty).option(game.drawOffers.normalizedPlies)) - - // adds fields that could be computed by the client instead + Json + .obj( + "id" -> game.id, + "variant" -> game.variant, + "speed" -> game.speed.key, + "perf" -> game.perfKey, + "rated" -> game.rated, + "fen" -> Fen.write(game.chess), + "turns" -> game.ply, + "source" -> game.source, + "status" -> game.status, + "createdAt" -> game.createdAt + ) + .add("startedAtTurn" -> game.chess.startedAtPly.some.filter(_ > 0)) + .add("initialFen" -> initialFen) + .add("threefold" -> game.history.threefoldRepetition) + .add("boosted" -> game.boosted) + .add("tournamentId" -> game.tournamentId) + .add("swissId" -> game.swissId) + .add("winner" -> game.winnerColor) + .add("rematch" -> rematches.getAcceptedId(game.id)) + .add("rules" -> game.metadata.nonEmptyRules) + .add("drawOffers" -> (!game.drawOffers.isEmpty).option(game.drawOffers.normalizedPlies)) + + // adds fields that could be computed by the client instead def baseWithChessDenorm(game: Game, initialFen: Option[Fen.Full]) = base(game, initialFen) ++ Json .obj( diff --git a/modules/msg/src/main/BsonHandlers.scala b/modules/msg/src/main/BsonHandlers.scala index 42791a3d27b33..3ec345eff99a1 100644 --- a/modules/msg/src/main/BsonHandlers.scala +++ b/modules/msg/src/main/BsonHandlers.scala @@ -42,9 +42,9 @@ private object BsonHandlers: ) def writeThread(thread: MsgThread, delBy: List[UserId]): Bdoc = - threadHandler.writeTry(thread).get ++ $doc("del" -> delBy) - ++ $doc("maskWith" -> $doc("date" -> thread.lastMsg.date)) - // looks weird, but maybe.. it is the way + threadHandler.writeTry(thread).get ++ $doc("del" -> delBy) + ++ $doc("maskWith" -> $doc("date" -> thread.lastMsg.date)) + // looks weird, but maybe.. it is the way def selectNotDeleted(using me: Me) = if UserId.lichess.is(me) then $empty // using "del" is too expensive diff --git a/modules/rating/src/main/RatingRegulator.scala b/modules/rating/src/main/RatingRegulator.scala index 3821942d81441..cbdded7184650 100644 --- a/modules/rating/src/main/RatingRegulator.scala +++ b/modules/rating/src/main/RatingRegulator.scala @@ -11,8 +11,8 @@ object RatingRegulator: } private def apply(factor: RatingFactor, perfType: PerfType, before: Perf, after: Perf): Perf = - if (after.nb == before.nb + 1) && // after playing one game - (after.glicko.rating > before.glicko.rating) // and gaining rating + if (after.nb == before.nb + 1) && // after playing one game + (after.glicko.rating > before.glicko.rating) // and gaining rating then val diff = after.glicko.rating - before.glicko.rating val extra = diff * (factor.value - 1) diff --git a/modules/tournament/src/main/TournamentStandingApi.scala b/modules/tournament/src/main/TournamentStandingApi.scala index 30b91e2c1ff00..b7acb3ca7c11d 100644 --- a/modules/tournament/src/main/TournamentStandingApi.scala +++ b/modules/tournament/src/main/TournamentStandingApi.scala @@ -56,8 +56,8 @@ final class TournamentStandingApi( compute(tourId, page, withScores = true) def clearCache(tour: Tournament): Unit = - first.invalidate(tour.id) - // no need to invalidate createdCache, these are only cached when tour.isCreated + first.invalidate(tour.id) + // no need to invalidate createdCache, these are only cached when tour.isCreated private def compute(id: TourId, page: Int, withScores: Boolean): Fu[JsObject] = cached.tourCache.byId(id).orFail(s"No such tournament: $id").flatMap { compute(_, page, withScores) } From c661d9014cc1d4d43a36c5f0ee5a98a1c9ceb7ee Mon Sep 17 00:00:00 2001 From: Scala Steward Date: Fri, 14 Jun 2024 17:02:40 +0000 Subject: [PATCH 029/168] Add 'Reformat with scalafmt 3.8.2' to .git-blame-ignore-revs --- .git-blame-ignore-revs | 3 +++ 1 file changed, 3 insertions(+) diff --git a/.git-blame-ignore-revs b/.git-blame-ignore-revs index 9d1ff9eb089b9..be304c6e33c6e 100644 --- a/.git-blame-ignore-revs +++ b/.git-blame-ignore-revs @@ -57,3 +57,6 @@ cd9708a0d772fe445635ae05306f1cb9365902de # Scala Steward: Reformat with scalafmt 3.8.1 1aae0c7b022f9e505e1ca7fec3b32efeef9f9981 + +# Scala Steward: Reformat with scalafmt 3.8.2 +2b774ffaf8926dc9986954f3c427cbe479e05f6a From cdc25555b67c35be6f72f85f061b2f645a92a119 Mon Sep 17 00:00:00 2001 From: Thibault Duplessis Date: Fri, 14 Jun 2024 20:55:32 +0200 Subject: [PATCH 030/168] scalafmtAll --- modules/coach/src/main/ui/CoachUi.scala | 1 - modules/db/src/main/dsl.scala | 2 +- modules/game/src/main/JsonView.scala | 46 +++++++++---------- modules/msg/src/main/BsonHandlers.scala | 4 +- .../src/main/TournamentStandingApi.scala | 2 +- 5 files changed, 27 insertions(+), 28 deletions(-) diff --git a/modules/coach/src/main/ui/CoachUi.scala b/modules/coach/src/main/ui/CoachUi.scala index 97dd2087c1235..d3efb32c1e4ce 100644 --- a/modules/coach/src/main/ui/CoachUi.scala +++ b/modules/coach/src/main/ui/CoachUi.scala @@ -149,7 +149,6 @@ final class CoachUi(helpers: Helpers)( dataIcon := Icon.BubbleSpeech, href := s"${routes.Msg.convo(c.user.username)}" )(trc.sendPM()) - , ), div(cls := "coach-show__main coach-main box")( div(cls := "coach-widget")(widget(c, link = false)), diff --git a/modules/db/src/main/dsl.scala b/modules/db/src/main/dsl.scala index 8370c9fc9b665..10c81749777af 100644 --- a/modules/db/src/main/dsl.scala +++ b/modules/db/src/main/dsl.scala @@ -339,7 +339,7 @@ object dsl extends dsl with Handlers: // like headOption, but with stopOnError defaulting to false def uno: Fu[Option[A]] = - c.collect[Iterable](1, Cursor.ContOnError[Iterable[A]]()).map(_.headOption) + c.collect[Iterable](1, Cursor.ContOnError[Iterable[A]]()).map(_.headOption) // extension [A](cursor: Cursor.WithOps[A])(using Executor) diff --git a/modules/game/src/main/JsonView.scala b/modules/game/src/main/JsonView.scala index 8d4743f51d5a5..05c2912856ca3 100644 --- a/modules/game/src/main/JsonView.scala +++ b/modules/game/src/main/JsonView.scala @@ -13,29 +13,29 @@ final class JsonView(rematches: Rematches): import JsonView.given def base(game: Game, initialFen: Option[Fen.Full]) = - Json - .obj( - "id" -> game.id, - "variant" -> game.variant, - "speed" -> game.speed.key, - "perf" -> game.perfKey, - "rated" -> game.rated, - "fen" -> Fen.write(game.chess), - "turns" -> game.ply, - "source" -> game.source, - "status" -> game.status, - "createdAt" -> game.createdAt - ) - .add("startedAtTurn" -> game.chess.startedAtPly.some.filter(_ > 0)) - .add("initialFen" -> initialFen) - .add("threefold" -> game.history.threefoldRepetition) - .add("boosted" -> game.boosted) - .add("tournamentId" -> game.tournamentId) - .add("swissId" -> game.swissId) - .add("winner" -> game.winnerColor) - .add("rematch" -> rematches.getAcceptedId(game.id)) - .add("rules" -> game.metadata.nonEmptyRules) - .add("drawOffers" -> (!game.drawOffers.isEmpty).option(game.drawOffers.normalizedPlies)) + Json + .obj( + "id" -> game.id, + "variant" -> game.variant, + "speed" -> game.speed.key, + "perf" -> game.perfKey, + "rated" -> game.rated, + "fen" -> Fen.write(game.chess), + "turns" -> game.ply, + "source" -> game.source, + "status" -> game.status, + "createdAt" -> game.createdAt + ) + .add("startedAtTurn" -> game.chess.startedAtPly.some.filter(_ > 0)) + .add("initialFen" -> initialFen) + .add("threefold" -> game.history.threefoldRepetition) + .add("boosted" -> game.boosted) + .add("tournamentId" -> game.tournamentId) + .add("swissId" -> game.swissId) + .add("winner" -> game.winnerColor) + .add("rematch" -> rematches.getAcceptedId(game.id)) + .add("rules" -> game.metadata.nonEmptyRules) + .add("drawOffers" -> (!game.drawOffers.isEmpty).option(game.drawOffers.normalizedPlies)) // adds fields that could be computed by the client instead def baseWithChessDenorm(game: Game, initialFen: Option[Fen.Full]) = diff --git a/modules/msg/src/main/BsonHandlers.scala b/modules/msg/src/main/BsonHandlers.scala index 3ec345eff99a1..22261f37b1e53 100644 --- a/modules/msg/src/main/BsonHandlers.scala +++ b/modules/msg/src/main/BsonHandlers.scala @@ -42,8 +42,8 @@ private object BsonHandlers: ) def writeThread(thread: MsgThread, delBy: List[UserId]): Bdoc = - threadHandler.writeTry(thread).get ++ $doc("del" -> delBy) - ++ $doc("maskWith" -> $doc("date" -> thread.lastMsg.date)) + threadHandler.writeTry(thread).get ++ $doc("del" -> delBy) + ++ $doc("maskWith" -> $doc("date" -> thread.lastMsg.date)) // looks weird, but maybe.. it is the way def selectNotDeleted(using me: Me) = diff --git a/modules/tournament/src/main/TournamentStandingApi.scala b/modules/tournament/src/main/TournamentStandingApi.scala index b7acb3ca7c11d..67ec89c763426 100644 --- a/modules/tournament/src/main/TournamentStandingApi.scala +++ b/modules/tournament/src/main/TournamentStandingApi.scala @@ -56,7 +56,7 @@ final class TournamentStandingApi( compute(tourId, page, withScores = true) def clearCache(tour: Tournament): Unit = - first.invalidate(tour.id) + first.invalidate(tour.id) // no need to invalidate createdCache, these are only cached when tour.isCreated private def compute(id: TourId, page: Int, withScores: Boolean): Fu[JsObject] = From 1af9c1114105ea1b3aefda5f8b7dae2ed141ba50 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?S=C3=A9rgio=20Gl=C3=B3rias?= <9739913+SergioGlorias@users.noreply.github.com> Date: Fri, 14 Jun 2024 21:00:32 +0100 Subject: [PATCH 031/168] Reduce anarcandy --- public/piece-css/anarcandy.css | 24 ++++++++++++------------ public/piece/anarcandy/bB.svg | 2 +- public/piece/anarcandy/bK.svg | 2 +- public/piece/anarcandy/bN.svg | 2 +- public/piece/anarcandy/bP.svg | 2 +- public/piece/anarcandy/bQ.svg | 2 +- public/piece/anarcandy/bR.svg | 2 +- public/piece/anarcandy/wB.svg | 2 +- public/piece/anarcandy/wK.svg | 2 +- public/piece/anarcandy/wN.svg | 2 +- public/piece/anarcandy/wP.svg | 2 +- public/piece/anarcandy/wQ.svg | 2 +- public/piece/anarcandy/wR.svg | 2 +- 13 files changed, 24 insertions(+), 24 deletions(-) diff --git a/public/piece-css/anarcandy.css b/public/piece-css/anarcandy.css index 13a6ed98633a9..334042c3bcd4a 100644 --- a/public/piece-css/anarcandy.css +++ b/public/piece-css/anarcandy.css @@ -1,12 +1,12 @@ -.is2d .pawn.white {background-image:url('data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSI1MTIiIGhlaWdodD0iNTEyIiBmaWxsPSJub25lIj48cGF0aCBmaWxsPSIjMDAxNzNDIiBkPSJNMzg4LjI1IDQ4Ny4yMzdjOS42ODIgMCAxNi44MjctOS4wMzUgMTQuNTk2LTE4LjQ1NmwtMTUuNzAzLTY2LjMxOGMtMS41NjQtNy4yMjctOC44MzgtMTIuOTQzLTE2LjI5MS0xMi45NDNoLTIyLjkxNWwtNjguMjgzLTI1MS4yOTljLS41MTktNS42ODgtMTYuMjM4LTcuMjIxLTI1LjU4MS03LjIyMXMtMjUuMDY1IDEuNTMzLTI1LjU5IDcuMjIxTDE2MC4yMTEgMzg5LjUyaC0yMC40NTljLTcuNDU1IDAtMTQuNzMzIDUuNzE2LTE2LjI3NyAxMi45NDNsLTE1LjA5NiA2Ni40NTFjLTIuMTMyIDkuMzg3IDUuMDAyIDE4LjMyMyAxNC42MjcgMTguMzIzSDM4OC4yNVoiLz48cGF0aCBmaWxsPSIjRkY5Q0FFIiBkPSJNMjQzLjI1IDE0NC43OWMzLjYyNi43NSAxMy4wOTkgMS43OTUgMjEuOTg1LS4wMjRsOS45ODggMzYuNzk3Yy0xNi4yMTggMy42NzctMzQuNzE0IDEuNTMyLTQxLjkzNSAwbDkuOTYyLTM2Ljc3M1pNMjMwLjA3MSAxOTMuNDM3bC0yOC44NDkgMTA2LjQ4OWMxOS45MjEgNC45NzkgNjkuMDM2IDExLjk1MSAxMDYuMTMgMGwtMjguOTA5LTEwNi41MDFjLTE4LjIzOCAzLjk3NC0zOS44NDggMS42NjQtNDguMzcyLjAxMloiLz48cGF0aCBmaWxsPSIjRkY5Q0FFIiBmaWxsLXJ1bGU9ImV2ZW5vZGQiIGQ9Ik0zMTAuNjc5IDMxMi4xODNjLTQ4LjEzOCAxMy4xNzctOTUuMjQzIDUuNDkxLTExMi43NzcgMGwtMjUuNTI4IDk0LjIzMS0zMS4zNC0uMTg0Yy0xLjEzOSAwLTMuODA2IDEuODU0LTUuMzY4IDkuMjcyLTEuNTYyIDcuNDE3LTcuNDgzIDM0LjMyMi0xMC4yNDggNDYuODQ4LS40ODggMi42MDIuODc4IDcuOTA1IDEwLjI0OCA4LjI5NiA5LjM3LjM5IDgzLjI4NS4xNjIgMTE5LjA3MSAwaC40MDNjMzUuNzg2LjE2MiAxMDkuNzAxLjM5IDExOS4wNzEgMCA5LjM2OS0uMzkxIDEwLjczNi01LjY5NCAxMC4yNDgtOC4yOTYtMi43NjYtMTIuNTI2LTguNjg3LTM5LjQzMS0xMC4yNDgtNDYuODQ4LTEuNTYyLTcuNDE4LTQuMjMtOS4yNzItNS4zNjgtOS4yNzJsLTMyLjU4Ni4xODQtMjUuNTc4LTk0LjIzMVpNMTYxLjYwMyA0MjMuNzk4YzEuODIgMTMuMTQgNDIuNTcxIDIzLjY2MiA5Mi42MDggMjMuNjYyIDUwLjA0NCAwIDkwLjgwMy0xMC41MTkgOTIuNjAxLTIzLjY2Mi4wNDMtNy4wMjctNS4zMzItOC4yNTctOC4wMjQtNy45OTMtMTQuNTE2IDguNTM3LTQ2Ljg5MyAxNC40ODQtODQuNTIgMTQuNDg0LTM3LjYzMiAwLTcwLjAxMi01Ljk1Mi04NC41MjgtMTQuNDkzLTIuNDk3LS4yNi03LjYxOS45NzUtOC4xMzcgOC4wMDJaIiBjbGlwLXJ1bGU9ImV2ZW5vZGQiLz48L3N2Zz4=')} -.is2d .knight.white {background-image:url('data:image/svg+xml;base64,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')} -.is2d .bishop.white {background-image:url('data:image/svg+xml;base64,<svg xmlns="http://www.w3.org/2000/svg" width="512" height="512" fill="none"><path fill="#00173C" d="M155.535 228.37C193.7 173.432 186.986 85.45 255.731 85.45c68.744 0 62.027 87.985 100.196 142.92 30.882 44.451 51.539 82.662 51.539 122.498 0 88.497-62.715 138.898-150.863 139.558l.003.028c-.293 0-.575-.011-.871-.014-.293.003-.576.014-.872.014v-.025C166.712 489.766 104 439.366 104 350.871c.007-39.838 20.664-78.048 51.546-122.497l-.011-.004Z"/><path fill="#FF9CAE" fill-rule="evenodd" d="M193.727 188.72c-3.558 9.781-7.603 19.935-12.582 29.841l-5.074 9.489-6.452 10.101c-30.81 44.345-48.476 78.673-48.483 112.723 0 39.925 13.993 69.778 36.627 89.909 22.9 20.368 56.276 32.203 97.229 32.511l.503.004.98-.008c40.951-.306 74.326-12.14 97.227-32.508 22.635-20.132 36.628-49.987 36.628-89.914 0-34.044-17.664-68.372-48.476-112.721-10.816-15.567-18.153-33.021-24.121-49.425-2.565-7.05-4.779-13.582-6.889-19.807-3.108-9.168-5.989-17.669-9.433-26.175-5.556-13.724-11.234-23.682-18.162-30.231-6.308-5.963-14.507-9.923-27.518-9.923-13.011 0-21.211 3.96-27.519 9.923-6.928 6.549-12.607 16.507-18.163 30.23-3.444 8.506-6.326 17.008-9.434 26.176l-.001.005c-2.109 6.223-4.323 12.753-6.887 19.8Z" clip-rule="evenodd"/><path fill="#00173C" d="M244.634 119.424c.184.396.393.769.622 1.116-3.45.287-6.502.205-8.546-.012a6.719 6.719 0 0 0-7.393 5.971 6.719 6.719 0 0 0 5.971 7.393c4.377.466 11.286.453 18.447-.996 7.08-1.431 15.244-4.437 21.191-10.632a6.72 6.72 0 0 0-9.695-9.308c-.431.449-.895.877-1.387 1.285-3.774-8.362-13.377-33.498-8.892-63.441.399-2.66-1.333-5.219-3.98-5.69l-11.434-2.035c-2.573-.458-5.05 1.228-5.457 3.81-5.1 32.368 4.503 59.501 10.553 72.539ZM349.297 395.86a90.345 90.345 0 0 1-18.436 22.16v.004a93.676 93.676 0 0 1-3.803 3.144c-2.682 2.101-5.773-2.002-3.732-4.73 37.565-50.212 11.911-127.204-.683-164.999-.593-1.781-1.158-3.475-1.685-5.075-.229-.983 1.223-1.58 1.774-.734a128.38 128.38 0 0 0 1.997 2.972c23.146 33.262 38.571 61.962 38.571 91.8 0 21.614-4.991 40.202-14.003 55.458Z"/><path fill="#810F23" fill-rule="evenodd" d="m230.512 279.792-9.442-34.046c-2.518-.838-3.497 8.031-3.672 12.571.35 2.27.734 6.809-.525 6.809s-1.224 5.587-1.049 8.381c-2.518 2.514-5.245 7.333-6.294 9.428-3.777.419-12.765 3.667-16.786 5.238 0 1.027-1.12 1.83-2.335 2.701-.645.463-1.316.945-1.862 1.489l-5.246 5.238c-1.635-1.306-2.862 1.867-3.809 4.315l-.106.274c-.524 1.35-.96 2.405-1.33 2.221-.839-.42-6.295 9.253-8.918 14.142.42.838-3.672 13.618-5.77 19.904-4.721 1.746-14.268 5.238-14.688 5.238-.15 0-.691.13-1.409.302-1.782.428-4.662 1.119-5.41.745-1.049-.523-1.574 2.619-1.574 4.715 0 1.413 6.212 1.635 10.573 1.79 2.102.075 3.774.134 4.115.305.839.419 1.749-1.222 2.098-2.095.525.698 1.679 1.99 2.099 1.571.419-.419 4.021-.175 5.77 0 0 1.397.315 4.295 1.573 4.714-.349.349-.839 1.886 0 5.238 1.05 4.19 3.148 7.857 3.148 8.381 0 .419 3.497 4.365 5.245 6.285l1.05.524v1.048l5.048 4.39c.941.895 1.443 1.371 1.246 1.371-.839 0-.349 4.889 0 7.333-.839 0-1.399 3.143-1.573 4.714-2.099 2.515-.875 6.984 0 8.905 3.357.838 4.546-.699 4.721-1.571.524-1.048 1.573-3.457 1.573-4.715 0-1.257 1.049-2.968 1.574-3.666.35-1.921 1.259-5.657 2.098-5.238 0-.873.21-2.514 1.049-2.095.7.524 2.308 1.571 3.148 1.571.839 0 3.497 2.445 4.721 3.667 1.049.524 3.672 1.466 5.77 1.047 1.399.524 4.406 1.572 5.246 1.572.839 0 1.748.698 2.098 1.047 2.273.175 7.029.524 7.868.524 1.049 0 7.869 1.571 9.442 0 1.574-1.571 6.82 1.048 6.82-.524 5.036-.838 13.289-5.587 16.786-7.857 1.399-.174 3.882-.314 2.623.524-1.259.838 1.923 2.445 3.672 3.143-.42 2.933 3.322 8.555 5.245 11 2.973 1.92 8.288 4.295 5.77-1.572-2.518-5.866-3.497-16.761-3.672-21.475-1.678 0 .35-4.54 1.574-6.81 2.098-1.222 6.085-4.19 5.246-6.285-.84-2.095.699-3.667 1.573-4.19-.349-1.572-.839-4.505 0-3.667.84.838 1.749-3.492 2.099-5.762-1.679-.838-.35-4.888.524-6.809 2.098.838 5.77-1.048 7.344-2.095.42-2.095 10.316-4.016 15.212-4.714l1.049-4.714-23.08-1.572c0-2.933-1.399-5.761-2.099-6.809 3.358-2.514-.349-9.777-2.622-13.095.839-3.352-7.344-11.872-11.541-15.714-2.098-3.352-5.77-6.983-7.344-8.38-2.622-.175-8.707-1.467-12.065-5.238-3.357-3.771-9.791-4.016-12.589-3.667Zm-2.098 34.571c-1.679-.419-5.596-13.444-7.344-19.904 0 .216-.884 2.299-1.932 4.77l-.001.001c-.983 2.319-2.111 4.977-2.788 6.752 1.15 1.913-.221 6.343-1.042 9-.303.979-.532 1.717-.532 2 0 .271-.635 1.564-1.502 3.331-2.478 5.046-6.852 13.954-3.743 13.954 3.357 0 10.141 1.396 13.114 2.095 5.455-.419 11.715-2.619 14.163-3.667-2.098-5.936-6.715-17.913-8.393-18.332Zm32.523 30.903c-2.099 1.257-5.071.873-6.295.524 1.259 2.095.524 5.762 0 7.333 1.678 2.095 1.748 5.413 1.574 6.809 1.049.524 3.252 1.781 3.671 2.619.42.838 1.224-.698 1.574-1.571-.419-.838-.175-2.794 0-3.667 2.098-2.514 3.322-9.079 3.672-12.047-.524-.524-2.098-1.257-4.196 0Zm-68.718-36.141c1.679-2.095 10.491-7.508 14.688-9.952.419 2.933-1.924 8.206-3.148 10.475-.349 2.096-1.364 6.391-2.622 6.81-1.259.419-1.224 4.365-1.05 6.285-2.517 3.353-3.147 9.079-3.147 11.524-.42.419-5.42-.524-7.868-1.048-1.05.524-11.541 3.143-9.967.524 1.574-2.619 2.098-4.714 1.574-4.714-.42 0 1.224-3.492 2.098-5.238-.839-.838.699-2.445 1.574-3.143-1.259-2.095 2.273-5.762 4.196-7.333.525-.524 1.993-2.095 3.672-4.19Zm-13.114 40.332c2.098-.175 6.505-.629 7.344-1.048 1.049.175 3.567.419 5.245 0-1.398 1.921-4.091 6.076-3.672 7.333-1.223 2.095-3.357 6.6-2.098 7.857-.51 1.189-1.318 3.633-.59 4.151-1.766-1.062-5.07-3.213-4.655-3.627.419-.419-.525-4.365-1.05-6.286-.174-1.396-.419-4.295 0-4.714-.524-1.047-1.363-3.247-.524-3.666Zm57.702-51.332c4.021 2.619 12.17 7.857 12.589 7.857.525 0 11.541 9.952 14.163 18.333 1.05.523 3.148 2.933 3.148 8.38-.375 0-.885.04-1.436.082-1.247.096-2.703.209-3.285-.082-.84-.419-8.743.524-12.59 1.048-1.049-3.667-3.882-11.838-6.819-15.19.35-.524.524-2.41-1.574-5.762-2.623-4.19-6.819-13.095-4.196-14.666Zm-30.425 48.713c2.798-.175 8.603-.21 9.442 1.047 1.399-.698 4.721-1.676 6.82 0 2.098 1.676 12.414 0 17.31-1.047.35 2.095 1.259 6.18 2.098 5.761-.524.524-.419 3.667 4.197 12.048.175 2.619.944 7.856 2.623 7.856 1.678 0 .349 2.096-.525 3.143-1.049 1.222-3.986 3.876-7.344 4.714-4.196 1.048-9.966 2.619-12.065 3.667-1.678.838-9.442-.349-13.114-1.048l-.524 1.048c-2.098-1.746-6.82-4.924-8.918-3.667-1.923-1.746-5.98-4.923-6.819-3.666-1.049 1.571-3.147-4.714-2.098-4.191.839.419 1.398-6.809 1.573-10.475 2.099-3.842 6.295-11.629 6.295-12.048 0-.081-.013-.201-.028-.348-.085-.791-.251-2.352 1.077-2.794Z" clip-rule="evenodd"/></svg>')} -.is2d .rook.white {background-image:url('data:image/svg+xml;base64,<svg xmlns="http://www.w3.org/2000/svg" width="512" height="512" fill="none"><path fill="#00173C" d="M328.469 488.071h-197.29c-7.831 0-14.179-7.144-14.179-15.957V83.292c0-6.25 2.925-12.04 7.698-15.236l40.073-26.836A30.869 30.869 0 0 1 181.948 36h193.331c11.366 0 20.58 9.214 20.58 20.58v352.47c0 6.372-2.033 12.533-5.73 17.36l-37.79 49.349c-5.986 7.817-14.701 12.312-23.87 12.312Z"/><path fill="#FF9CAE" d="M375.002 421.131c3.774-4.849 5.855-11.076 5.855-17.522V57.88c0-5.683-4.607-10.29-10.29-10.29H191.628c-5.37 0-10.606 1.68-14.972 4.806l-35.988 25.758c-5.146 3.499-7.784 9.002-7.784 15.292v368.031c0 5.875 4.232 10.638 9.453 10.638h181.056c6.662 0 13.015-3.165 17.494-8.715l34.115-42.269Z"/><path fill="#00173C" d="M319.149 89.167H151.168c-3.893 0-5.875-5.264-3.166-8.41 4.151-4.823 10.214-4.89 16.181-4.89h154.864c6.566 0 12.968-2.31 18.312-6.603l10.972-8.818c5.642-4.534 12.901-8.426 19.689-5.911l.871.323c3.734 1.382 4.845 5.382 1.758 7.896l-16.464 13.112c-10.451 9.903-12.464 17.156-12.464 28.248v343.321c0 6.181-2.123 11.751-7.2 14.109-3.571 1.657-7.494-1.297-7.494-5.644V98.032c0-4.896-3.527-8.865-7.878-8.865Z"/><path fill="#00173C" d="m183.383 60.316 5.249-3.36a15.433 15.433 0 0 1 8.321-2.434h45.218c4.015 0 5.654 5.161 2.374 7.478l-4.349 3.071a15.432 15.432 0 0 1-8.904 2.828h-45.69c-4.112 0-5.682-5.366-2.219-7.583ZM268.929 57.832l-3.45 2.718c-3.068 2.417-1.359 7.349 2.548 7.349h48.509c3.203 0 6.327-.996 8.938-2.851l4.3-3.054c3.269-2.322 1.626-7.472-2.384-7.472h-48.91a15.434 15.434 0 0 0-9.551 3.31Z"/><path fill="#810F23" d="M210.956 298.318a36.692 36.692 0 0 1-4.231-5.569c-1.188-2.079-2.079-4.157-2.673-6.236a26.261 26.261 0 0 0-.668 2.895l-.891 2.673-.891 2.227a7.546 7.546 0 0 1-1.782 2.005c1.188 1.039 2.079 1.856 2.673 2.45a10.361 10.361 0 0 1 1.559 2.005l1.113 2.227c.446.891 1.114 2.153 2.005 3.786a81.404 81.404 0 0 1 4.677 9.578 55.318 55.318 0 0 1 2.673 9.355 55.81 55.81 0 0 1-5.345 3.563c-1.931 1.04-3.787 1.782-5.569 2.228-1.188 9.057-2.821 17.744-4.9 26.059-2.079 8.315-4.454 16.037-7.127 23.164 4.454 4.009 9.28 7.128 14.477 9.355a51.237 51.237 0 0 0 16.26 4.009l.223-87.756a31.409 31.409 0 0 1-6.237-3.341c-2.079-1.485-3.861-3.044-5.346-4.677ZM190.911 354.446a359.958 359.958 0 0 0 5.122-23.387c-2.078-4.455-4.528-8.909-7.35-13.364-2.821-4.455-6.088-8.686-9.8-12.696-1.485 7.87-3.415 15.22-5.791 22.051-2.524 6.83-5.494 12.918-8.909 18.264a176.694 176.694 0 0 0 4.454 9.132 72.165 72.165 0 0 0 4.901 8.018 78.007 78.007 0 0 0 5.345 6.905 78.462 78.462 0 0 0 5.791 6.459c2.227-6.682 4.306-13.809 6.237-21.382ZM288.022 261.79c.594-1.337.891-2.822.891-4.455v-7.35h10.468a173.975 173.975 0 0 0-4.009-14.032 364.084 364.084 0 0 0-4.678-13.587c-3.415 6.088-6.236 12.993-8.463 20.714-2.228 7.721-3.564 16.185-4.01 25.391 1.485 0 2.896-.222 4.232-.668 1.188-.594 2.302-1.41 3.341-2.45a14.455 14.455 0 0 0 2.228-3.563ZM282.453 292.526a8.59 8.59 0 0 0-4.232-1.113 96.58 96.58 0 0 0 1.782 13.364 109.249 109.249 0 0 0 2.896 12.473 89.138 89.138 0 0 0 3.786 11.136 89.726 89.726 0 0 0 4.9 10.023 175.683 175.683 0 0 0 4.455-13.364 188.169 188.169 0 0 0 3.564-14.477l-10.691-.446v-7.573c0-1.336-.297-2.672-.891-4.009a14.455 14.455 0 0 0-2.228-3.563c-1.039-1.04-2.153-1.857-3.341-2.451Z"/><path fill="#810F23" d="M268.867 262.235a9.79 9.79 0 0 0 2.672 3.786c.446-5.197 1.188-10.097 2.228-14.7.891-4.751 2.004-9.206 3.341-13.364 1.336-4.306 2.895-8.315 4.677-12.027 1.782-3.712 3.787-7.053 6.014-10.023-2.673-6.088-5.791-11.805-9.355-17.151-3.564-5.494-7.424-10.542-11.582-15.145-3.118 9.206-5.791 19.452-8.018 30.737-2.376 11.136-4.084 23.09-5.123 35.859l1.782-.222v60.137l-1.782-.222a236.656 236.656 0 0 0 2.005 18.264 211.705 211.705 0 0 0 2.895 17.373 164.385 164.385 0 0 0 3.786 15.814 184.846 184.846 0 0 0 4.455 14.477 124.835 124.835 0 0 0 11.805-14.7 107.507 107.507 0 0 0 9.132-16.705c-2.227-2.97-4.232-6.311-6.014-10.023a92.923 92.923 0 0 1-4.677-11.805 125.406 125.406 0 0 1-3.341-13.364c-1.04-4.751-1.782-9.726-2.228-14.923a9.8 9.8 0 0 0-2.672 3.787 10.32 10.32 0 0 0-1.114 4.677v7.35h-6.459v-60.137h6.459v7.573c0 1.484.371 3.044 1.114 4.677ZM188.238 252.658a35.142 35.142 0 0 1 10.246-2.896c-1.337-12.621-3.119-24.426-5.346-35.414-2.376-11.137-5.197-21.234-8.464-30.292-3.861 4.009-7.499 8.538-10.914 13.587-3.563 4.9-6.756 10.394-9.577 16.482 3.712 5.642 6.904 12.25 9.577 19.823 2.525 7.424 4.381 15.443 5.569 24.055a33.821 33.821 0 0 1 8.909-5.345ZM163.069 290.745a16.325 16.325 0 0 0-4.454-1.114c-.149-1.336 0-2.524.445-3.564a7.064 7.064 0 0 1 2.005-2.673 6.614 6.614 0 0 1 3.118-1.781c1.039-.446 2.153-.594 3.341-.446 0-2.821.52-5.568 1.559-8.241.891-2.673 2.153-4.974 3.786-6.905a328.413 328.413 0 0 0-1.559-12.695 142.458 142.458 0 0 0-2.673-12.028 155.344 155.344 0 0 0-3.786-10.914c-1.336-3.563-2.821-6.83-4.455-9.8-3.266 8.909-5.791 18.413-7.572 28.51-1.931 9.948-2.896 20.268-2.896 30.96 0 10.394.891 20.417 2.673 30.068 1.782 9.652 4.232 18.932 7.35 27.842 2.97-5.049 5.568-10.914 7.796-17.596 2.078-6.83 3.563-14.181 4.454-22.05-.445-1.188-1.113-2.302-2.004-3.341-1.04-1.04-2.153-1.857-3.341-2.451a17.637 17.637 0 0 0-3.787-1.781ZM214.297 255.999a34.079 34.079 0 0 0 8.242 2.895l-.223-92.211a44.34 44.34 0 0 0-15.814 3.341c-5.197 1.93-10.097 4.752-14.7 8.464 1.93 4.9 3.712 10.171 5.345 15.814a373.354 373.354 0 0 1 4.232 17.373 306.934 306.934 0 0 1 3.118 18.709 403.06 403.06 0 0 1 2.228 20.269 43.74 43.74 0 0 0 7.572 5.346ZM230.78 166.906v92.656c2.524-.148 5.122-.594 7.795-1.336a27.463 27.463 0 0 0 7.128-3.787 236.793 236.793 0 0 1 2.227-21.159c.891-6.831 2.005-13.364 3.341-19.601 1.188-6.385 2.598-12.398 4.232-18.041 1.485-5.791 3.192-11.211 5.123-16.259-4.455-3.712-9.132-6.608-14.032-8.687a52.387 52.387 0 0 0-15.814-3.786ZM248.375 329.945a273.103 273.103 0 0 1-2.004-19.6 43.098 43.098 0 0 1-7.573.223 37.688 37.688 0 0 1-8.018-1.337l-.223 84.861c5.494-.742 10.839-2.227 16.037-4.454a64.288 64.288 0 0 0 14.477-9.132c-1.93-4.752-3.638-9.801-5.123-15.146a201.55 201.55 0 0 1-4.232-16.928 227.503 227.503 0 0 1-3.341-18.487ZM294.035 294.977v11.136h22.274v-4.455h-8.91v-5.791h-4.677v5.791h-4.009v-6.681h-4.678ZM294.035 287.404v4.677h22.274v-4.677h-22.274Z"/><path fill="#810F23" fill-rule="evenodd" d="M294.035 277.158v6.905h22.273v-6.905c0-.891-.148-1.782-.445-2.673a2.79 2.79 0 0 0-.668-1.113l-1.114-1.114c-.891-.594-2.004-1.04-3.341-1.337-1.336-.445-3.192-.668-5.568-.668-.891 0-1.633.075-2.227.223a11.3 11.3 0 0 0-2.228.223c-1.336.148-2.524.519-3.563 1.113-1.04.594-1.856 1.263-2.45 2.005-.446.891-.669 2.005-.669 3.341Zm17.373 2.45h-12.473l.001-1.336c0-1.188.445-2.079 1.336-2.673 1.039-.446 2.673-.668 4.9-.668 1.93 0 3.267.074 4.009.222.891.297 1.411.669 1.559 1.114.149.149.297.446.446.891.148.297.222.668.222 1.114v1.336Z" clip-rule="evenodd"/><path fill="#810F23" d="M294.035 255.776v12.25h22.274v-12.473h-4.901v8.018h-4.454v-7.35h-4.678v7.35h-3.563v-7.795h-4.678Z"/></svg>')} -.is2d .queen.white {background-image:url('data:image/svg+xml;base64,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')} -.is2d .king.white {background-image:url('data:image/svg+xml;base64,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')} -.is2d .pawn.black {background-image:url('data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSI1MTIiIGhlaWdodD0iNTEyIiBmaWxsPSJub25lIj48cGF0aCBmaWxsPSIjMDAxNzNDIiBkPSJNMzg3LjkyNyA0MDIuNDYzYy0xLjU2NS03LjIyNy04LjgzOS0xMi45NDMtMTYuMjkxLTEyLjk0M2gtMjIuOTE1bC02OC4yODQtMjUxLjI5OWMtLjUxOC01LjY4OC0xNi4yMzgtNy4yMjEtMjUuNTgxLTcuMjIxcy0yNS4wNjUgMS41MzMtMjUuNTg5IDcuMjIxTDE2MC45OTUgMzg5LjUyaC0yMC40NmMtNy40NTUgMC0xNC43MzIgNS43MTYtMTYuMjc3IDEyLjk0M2wtMTUuODQgNjYuMjg4Yy0yLjI1MyA5LjQyOSA0Ljg5NSAxOC40ODYgMTQuNTg5IDE4LjQ4NkgzODguMjVjOS42MTMgMCAxNi43NDQtOC45MTQgMTQuNjM0LTE4LjI5MmwtMTQuOTU3LTY2LjQ4MloiLz48cGF0aCBmaWxsPSIjRkY5Q0FFIiBkPSJNMjU0Ljk5NSA0NDkuNDZjLTUwLjAzNyAwLTkwLjc4OC0xMC41MjItOTIuNjA5LTIzLjY2Mi41MTgtNy4wMjcgNS42NDEtOC4yNjIgOC4xMzctOC4wMDIgMTQuNTE3IDguNTQxIDQ2Ljg5NiAxNC40OTMgODQuNTI5IDE0LjQ5MyAzNy42MjYgMCA3MC4wMDQtNS45NDcgODQuNTE5LTE0LjQ4NCAyLjY5My0uMjY0IDguMDY3Ljk2NiA4LjAyNSA3Ljk5My0xLjc5OSAxMy4xNDMtNDIuNTU3IDIzLjY2Mi05Mi42MDEgMjMuNjYyWk0yMDQuNzM1IDMxNS44NTZjMTkuODYgNC44OTggNTkuNDcgOS43MzEgMTAwLjcyMi0uMTM0IDMuMzMtLjc5NiA1LjI4LTQuMjE0IDQuMzgzLTcuNTE4LS45MjgtMy40MTktNC41MjEtNS4zNTgtNy45NS00LjQ2OS0zMi42MzcgOC40NTktNzIuMzUzIDQuMDEzLTkzLjYzNS0uMzkyLTMuNDg3LS43MjItNi45OTUgMS4zMzMtNy45MjYgNC43Ny0uOTE4IDMuMzkuOTk2IDYuOTAyIDQuNDA2IDcuNzQzWk0yMzcuMzE2IDE5Ni40NGM4Ljk5IDEuMTMgMjIuNjQxIDEuOTIxIDM1LjU4MS4xMDcgMy40NjQtLjQ4NSA1LjU2Mi0zLjk1MiA0LjY0NS03LjMyOC0uODU4LTMuMTYxLTQuMDU2LTUuMDY1LTcuMjk4LTQuNTk1LTExLjI3IDEuNjM1LTIyLjg2LjkyNC0zMC41MDQtLjEwNy0zLjItLjQzMi02LjMyOSAxLjQ4NC03LjE3NCA0LjYwMS0uOTI0IDMuNDEzIDEuMjQyIDYuODgyIDQuNzUgNy4zMjJaIi8+PC9zdmc+')} -.is2d .knight.black {background-image:url('data:image/svg+xml;base64,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')} -.is2d .bishop.black {background-image:url('data:image/svg+xml;base64,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')} -.is2d .rook.black {background-image:url('data:image/svg+xml;base64,<svg xmlns="http://www.w3.org/2000/svg" width="512" height="512" fill="none"><path fill="#00173C" d="M328.469 486.071h-197.29c-7.831 0-14.179-7.144-14.179-15.957V81.292c0-6.25 2.925-12.04 7.698-15.236l40.073-26.836A30.869 30.869 0 0 1 181.948 34h193.331c11.366 0 20.58 9.214 20.58 20.58v352.47c0 6.372-2.033 12.533-5.73 17.36l-37.79 49.349c-5.986 7.817-14.701 12.312-23.87 12.312Z"/><path fill="#FF385C" d="M208.899 296.317a36.742 36.742 0 0 1-4.232-5.568c-1.188-2.079-2.079-4.158-2.673-6.237a26.327 26.327 0 0 0-.668 2.896l-.891 2.673-.891 2.227a7.561 7.561 0 0 1-1.782 2.005c1.188 1.039 2.079 1.856 2.673 2.45a10.385 10.385 0 0 1 1.559 2.004l1.114 2.228c.445.891 1.113 2.153 2.004 3.786a81.327 81.327 0 0 1 4.677 9.578 55.334 55.334 0 0 1 2.673 9.354 55.512 55.512 0 0 1-5.345 3.564c-1.931 1.039-3.787 1.782-5.569 2.227-1.187 9.058-2.821 17.745-4.9 26.06-2.078 8.315-4.454 16.037-7.127 23.164 4.455 4.009 9.28 7.127 14.477 9.355a51.263 51.263 0 0 0 16.26 4.009l.223-87.756a31.437 31.437 0 0 1-6.237-3.341c-2.079-1.485-3.86-3.044-5.345-4.678ZM188.853 352.446a360.618 360.618 0 0 0 5.123-23.387c-2.079-4.455-4.529-8.909-7.351-13.364-2.821-4.455-6.088-8.687-9.8-12.696-1.485 7.87-3.415 15.22-5.791 22.051-2.524 6.83-5.494 12.918-8.909 18.264 1.485 3.266 2.97 6.31 4.455 9.132a72.009 72.009 0 0 0 4.9 8.018 78.153 78.153 0 0 0 5.345 6.905 78.462 78.462 0 0 0 5.791 6.459c2.228-6.682 4.306-13.809 6.237-21.382ZM285.964 259.789c.594-1.336.891-2.821.891-4.454v-7.351h10.468a174.092 174.092 0 0 0-4.009-14.032 363.406 363.406 0 0 0-4.678-13.586c-3.415 6.088-6.236 12.992-8.463 20.714-2.228 7.721-3.564 16.185-4.009 25.391 1.484 0 2.895-.223 4.231-.668 1.188-.594 2.302-1.411 3.341-2.45a14.442 14.442 0 0 0 2.228-3.564ZM280.395 290.526a8.589 8.589 0 0 0-4.231-1.113c.296 4.603.89 9.057 1.781 13.364a109.232 109.232 0 0 0 2.896 12.472 89.153 89.153 0 0 0 3.786 11.137 89.9 89.9 0 0 0 4.9 10.023 175.683 175.683 0 0 0 4.455-13.364 188.169 188.169 0 0 0 3.564-14.477l-10.691-.446v-7.573c0-1.336-.297-2.673-.891-4.009a14.48 14.48 0 0 0-2.228-3.564c-1.039-1.039-2.153-1.856-3.341-2.45Z"/><path fill="#FF385C" d="M266.809 260.235a9.782 9.782 0 0 0 2.673 3.786c.445-5.197 1.187-10.097 2.227-14.7.891-4.752 2.004-9.206 3.341-13.364 1.336-4.306 2.895-8.315 4.677-12.028 1.782-3.712 3.787-7.053 6.014-10.022-2.673-6.088-5.791-11.805-9.355-17.151-3.563-5.494-7.424-10.542-11.582-15.146-3.118 9.207-5.791 19.452-8.018 30.737-2.376 11.137-4.083 23.09-5.123 35.86l1.782-.223v60.138l-1.782-.223a237.042 237.042 0 0 0 2.005 18.264 211.563 211.563 0 0 0 2.895 17.373 164.312 164.312 0 0 0 3.787 15.814 184.318 184.318 0 0 0 4.454 14.478 124.835 124.835 0 0 0 11.805-14.7 107.507 107.507 0 0 0 9.132-16.705c-2.227-2.97-4.232-6.311-6.014-10.023a92.923 92.923 0 0 1-4.677-11.805 125.406 125.406 0 0 1-3.341-13.364c-1.04-4.751-1.782-9.726-2.227-14.923a9.785 9.785 0 0 0-2.673 3.787 10.316 10.316 0 0 0-1.114 4.677v7.35h-6.459v-60.138h6.459v7.573c0 1.485.371 3.044 1.114 4.678ZM186.18 250.657a35.14 35.14 0 0 1 10.246-2.895c-1.337-12.622-3.119-24.426-5.346-35.415-2.376-11.136-5.197-21.233-8.464-30.291-3.86 4.009-7.498 8.538-10.914 13.587-3.563 4.9-6.756 10.394-9.577 16.482 3.712 5.642 6.905 12.25 9.577 19.823 2.525 7.424 4.381 15.442 5.569 24.055a33.851 33.851 0 0 1 8.909-5.346ZM161.011 288.744a16.313 16.313 0 0 0-4.454-1.113c-.149-1.337 0-2.525.445-3.564a7.074 7.074 0 0 1 2.005-2.673 6.607 6.607 0 0 1 3.118-1.782c1.039-.445 2.153-.594 3.341-.445 0-2.821.52-5.568 1.559-8.241.891-2.673 2.153-4.975 3.786-6.905a328.708 328.708 0 0 0-1.559-12.696 142.915 142.915 0 0 0-2.672-12.027 155.492 155.492 0 0 0-3.787-10.914c-1.336-3.564-2.821-6.83-4.455-9.8-3.266 8.909-5.791 18.412-7.572 28.51-1.931 9.948-2.896 20.268-2.896 30.959 0 10.394.891 20.417 2.673 30.069 1.782 9.652 4.232 18.932 7.35 27.842 2.97-5.049 5.568-10.914 7.796-17.596 2.078-6.831 3.563-14.181 4.454-22.051-.445-1.188-1.113-2.301-2.004-3.341-1.04-1.039-2.153-1.856-3.341-2.45a17.688 17.688 0 0 0-3.787-1.782ZM212.24 253.998a34.018 34.018 0 0 0 8.241 2.896l-.223-92.211a44.324 44.324 0 0 0-15.814 3.341c-5.197 1.93-10.097 4.751-14.7 8.464 1.93 4.9 3.712 10.171 5.345 15.814a373.354 373.354 0 0 1 4.232 17.373 306.934 306.934 0 0 1 3.118 18.709 403.06 403.06 0 0 1 2.228 20.269 43.795 43.795 0 0 0 7.573 5.345ZM228.722 164.906v92.656c2.524-.149 5.123-.594 7.795-1.336a27.477 27.477 0 0 0 7.128-3.787 236.793 236.793 0 0 1 2.227-21.159c.891-6.831 2.005-13.364 3.341-19.601 1.188-6.385 2.599-12.399 4.232-18.041 1.485-5.791 3.192-11.211 5.123-16.259-4.455-3.713-9.132-6.608-14.032-8.687a52.387 52.387 0 0 0-15.814-3.786ZM246.317 327.945a273.677 273.677 0 0 1-2.004-19.6 43.098 43.098 0 0 1-7.573.223 37.688 37.688 0 0 1-8.018-1.337l-.223 84.861a61.424 61.424 0 0 0 16.037-4.455 64.266 64.266 0 0 0 14.477-9.132c-1.93-4.751-3.638-9.8-5.123-15.145a201.648 201.648 0 0 1-4.232-16.928 227.581 227.581 0 0 1-3.341-18.487ZM291.977 292.976v11.137h22.274v-4.455h-8.91v-5.791h-4.677v5.791h-4.009v-6.682h-4.678ZM291.977 285.403v4.678h22.274v-4.678h-22.274Z"/><path fill="#FF385C" fill-rule="evenodd" d="M291.977 275.158v6.904h22.274v-6.904a8.41 8.41 0 0 0-.446-2.673 2.794 2.794 0 0 0-.668-1.114l-1.114-1.113c-.891-.594-2.004-1.04-3.341-1.337-1.336-.445-3.192-.668-5.568-.668-.891 0-1.633.074-2.227.223a11.3 11.3 0 0 0-2.228.223c-1.336.148-2.524.519-3.563 1.113-1.04.594-1.856 1.262-2.45 2.005-.446.891-.669 2.004-.669 3.341Zm17.374 2.45h-12.473v-1.337c0-1.188.445-2.078 1.336-2.672 1.039-.446 2.673-.669 4.9-.669 1.931 0 3.267.075 4.009.223.891.297 1.411.668 1.56 1.114.148.148.296.445.445.891.148.297.223.668.223 1.113v1.337Z" clip-rule="evenodd"/><path fill="#FF385C" d="M291.977 253.776v12.25h22.274v-12.473h-4.9v8.018h-4.455v-7.35h-4.677v7.35h-3.564v-7.795h-4.678Z"/><path fill="#FF9CAE" d="M323.709 84.215H144.608c-4.031 0-12.353-2.169-9.549-5.312 3.984-4.465 10.043-4.436 15.827-4.407.456.002.909.004 1.36.004h168.237c6.798 0 15.307-.089 20.839-4.378L366.5 51c4.574-3.546 13.04-8.844 17.526-5.167 1.974 1.667-5.877 8.162-9.273 10.96L352 75.5c-8.129 6.696-8.5 16.23-8.5 27.309v340.352c0 6.173-.755 16.304-6.012 18.659-3.697 1.656-3.988-5.506-3.988-9.848V98.382c0-7.969-5.287-14.167-9.791-14.167ZM185.159 49.06l-5.253 2.843c-3.466 1.876-1.895 6.416 2.221 6.416h45.727c3.192 0 6.305-.836 8.912-2.393l4.352-2.599c3.283-1.96 1.642-6.327-2.376-6.327h-45.255c-2.952 0-5.842.715-8.328 2.06Z"/><path fill="#FF9CAE" d="m268.684 49.801-3.452 2.3c-3.071 2.045-1.36 6.218 2.549 6.218h48.549c3.206 0 6.332-.843 8.946-2.413l4.303-2.584c3.272-1.965 1.628-6.322-2.385-6.322h-48.95c-3.469 0-6.836.987-9.56 2.801Z"/></svg>')} -.is2d .queen.black {background-image:url('data:image/svg+xml;base64,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')} -.is2d .king.black {background-image:url('data:image/svg+xml;base64,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')} +.is2d .pawn.white {background-image:url('data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIGZpbGw9Im5vbmUiIHZpZXdCb3g9IjAgMCA1MTIgNTEyIj48cGF0aCBmaWxsPSIjMDAxNzNDIiBkPSJNMzg4LjMgNDg3LjJhMTUgMTUgMCAwIDAgMTQuNS0xOC40bC0xNS43LTY2LjNhMTcgMTcgMCAwIDAtMTYuMi0xM2gtMjNsLTY4LjItMjUxLjNjLS42LTUuNy0xNi4zLTcuMi0yNS42LTcuMnMtMjUgMS41LTI1LjYgNy4ybC02OC4zIDI1MS4zaC0yMC40Yy03LjUgMC0xNC44IDUuNy0xNi4zIDEzbC0xNS4xIDY2LjRhMTUgMTUgMCAwIDAgMTQuNiAxOC4zaDI2NS4zWiIvPjxwYXRoIGZpbGw9IiNGRjlDQUUiIGQ9Ik0yNDMuMyAxNDQuOGMzLjYuNyAxMyAxLjggMjIgMGwxMCAzNi44YTExMC42IDExMC42IDAgMCAxLTQyIDBsMTAtMzYuOFpNMjMwIDE5My40IDIwMS4yIDMwMGMyMCA1IDY5IDEyIDEwNi4yIDBsLTI5LTEwNi41Yy0xOC4yIDQtMzkuOCAxLjctNDguMyAwWiIvPjxwYXRoIGZpbGw9IiNGRjlDQUUiIGZpbGwtcnVsZT0iZXZlbm9kZCIgZD0iTTMxMC43IDMxMi4yYTIyMS41IDIyMS41IDAgMCAxLTExMi44IDBsLTI1LjUgOTQuMi0zMS40LS4yYy0xLjEgMC0zLjggMS45LTUuMyA5LjNsLTEwLjMgNDYuOGMtLjUgMi43LjkgOCAxMC4zIDguMyA5LjMuNCA4My4zLjIgMTE5IDBoLjRjMzUuOC4yIDEwOS43LjQgMTE5LjEgMCA5LjQtLjMgMTAuNy01LjYgMTAuMy04LjNsLTEwLjMtNDYuOGMtMS42LTcuNC00LjItOS4zLTUuNC05LjNsLTMyLjUuMi0yNS42LTk0LjJaTTE2MS42IDQyMy44YzEuOCAxMy4xIDQyLjYgMjMuNyA5Mi42IDIzLjcgNTAgMCA5MC44LTEwLjYgOTIuNi0yMy43IDAtNy01LjMtOC4zLTgtOC0xNC41IDguNS00NyAxNC41LTg0LjUgMTQuNS0zNy43IDAtNzAtNi04NC42LTE0LjUtMi41LS4zLTcuNiAxLTguMSA4WiIgY2xpcC1ydWxlPSJldmVub2RkIi8+PC9zdmc+')} +.is2d .knight.white {background-image:url('data:image/svg+xml;base64,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')} +.is2d .bishop.white {background-image:url('data:image/svg+xml;base64,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')} +.is2d .rook.white {background-image:url('data:image/svg+xml;base64,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')} +.is2d .queen.white {background-image:url('data:image/svg+xml;base64,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')} +.is2d .king.white {background-image:url('data:image/svg+xml;base64,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')} +.is2d .pawn.black {background-image:url('data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIGZpbGw9Im5vbmUiIHZpZXdCb3g9IjAgMCA1MTIgNTEyIj48cGF0aCBmaWxsPSIjMDAxNzNDIiBkPSJNMzg4IDQwMi41Yy0xLjYtNy4zLTktMTMtMTYuNC0xM2gtMjIuOWwtNjguMy0yNTEuM2MtLjUtNS43LTE2LjItNy4yLTI1LjUtNy4ycy0yNS4xIDEuNS0yNS42IDcuMkwxNjEgMzg5LjVoLTIwLjVhMTcgMTcgMCAwIDAtMTYuMiAxM2wtMTUuOSA2Ni4zYTE1IDE1IDAgMCAwIDE0LjYgMTguNGgyNjUuM2ExNSAxNSAwIDAgMCAxNC42LTE4LjNsLTE1LTY2LjRaIi8+PHBhdGggZmlsbD0iI0ZGOUNBRSIgZD0iTTI1NSA0NDkuNWMtNTAgMC05MC44LTEwLjYtOTIuNi0yMy43LjUtNyA1LjYtOC4zIDguMS04IDE0LjUgOC41IDQ3IDE0LjUgODQuNiAxNC41IDM3LjYgMCA3MC02IDg0LjUtMTQuNSAyLjctLjMgOCAxIDggOC0xLjggMTMuMS00Mi42IDIzLjctOTIuNiAyMy43Wm0tNTAuMy0xMzMuNmMxOS45IDQuOSA1OS41IDkuNyAxMDAuOC0uMmE2IDYgMCAwIDAgNC4zLTcuNSA2LjUgNi41IDAgMCAwLTgtNC41Yy0zMi41IDguNS03Mi4zIDQtOTMuNS0uNGE3IDcgMCAwIDAtOCA0LjhjLS45IDMuNCAxIDcgNC40IDcuOFptMzIuNi0xMTkuNWM5IDEuMiAyMi43IDIgMzUuNi4xIDMuNS0uNCA1LjYtNCA0LjYtNy4zLS44LTMuMS00LTUtNy4zLTQuNi0xMS4yIDEuNy0yMi44IDEtMzAuNSAwYTYuNSA2LjUgMCAwIDAtNy4xIDQuNSA1LjggNS44IDAgMCAwIDQuNyA3LjNaIi8+PC9zdmc+')} +.is2d .knight.black {background-image:url('data:image/svg+xml;base64,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')} +.is2d .bishop.black {background-image:url('data:image/svg+xml;base64,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')} +.is2d .rook.black {background-image:url('data:image/svg+xml;base64,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')} +.is2d .queen.black {background-image:url('data:image/svg+xml;base64,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')} +.is2d .king.black {background-image:url('data:image/svg+xml;base64,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')} diff --git a/public/piece/anarcandy/bB.svg b/public/piece/anarcandy/bB.svg index 706f3c14b3a9f..9e9fdeac1a6c1 100644 --- a/public/piece/anarcandy/bB.svg +++ b/public/piece/anarcandy/bB.svg @@ -1 +1 @@ - \ No newline at end of file + \ No newline at end of file diff --git a/public/piece/anarcandy/bK.svg b/public/piece/anarcandy/bK.svg index 8530018b17831..289ce8ae396e4 100644 --- a/public/piece/anarcandy/bK.svg +++ b/public/piece/anarcandy/bK.svg @@ -1 +1 @@ - \ No newline at end of file + \ No newline at end of file diff --git a/public/piece/anarcandy/bN.svg b/public/piece/anarcandy/bN.svg index 1c65e1a227e3f..1324689d9b72a 100644 --- a/public/piece/anarcandy/bN.svg +++ b/public/piece/anarcandy/bN.svg @@ -1 +1 @@ - \ No newline at end of file + \ No newline at end of file diff --git a/public/piece/anarcandy/bP.svg b/public/piece/anarcandy/bP.svg index faacdcc128b82..8885435dca787 100644 --- a/public/piece/anarcandy/bP.svg +++ b/public/piece/anarcandy/bP.svg @@ -1 +1 @@ - \ No newline at end of file + \ No newline at end of file diff --git a/public/piece/anarcandy/bQ.svg b/public/piece/anarcandy/bQ.svg index 99a342f6a0826..43f962bddcc47 100644 --- a/public/piece/anarcandy/bQ.svg +++ b/public/piece/anarcandy/bQ.svg @@ -1 +1 @@ - \ No newline at end of file + \ No newline at end of file diff --git a/public/piece/anarcandy/bR.svg b/public/piece/anarcandy/bR.svg index e072cc156e664..c1bdae13a548c 100644 --- a/public/piece/anarcandy/bR.svg +++ b/public/piece/anarcandy/bR.svg @@ -1 +1 @@ - \ No newline at end of file + \ No newline at end of file diff --git a/public/piece/anarcandy/wB.svg b/public/piece/anarcandy/wB.svg index 96db00c3fe55e..712e646e0898b 100644 --- a/public/piece/anarcandy/wB.svg +++ b/public/piece/anarcandy/wB.svg @@ -1 +1 @@ - \ No newline at end of file + \ No newline at end of file diff --git a/public/piece/anarcandy/wK.svg b/public/piece/anarcandy/wK.svg index e433f29263a22..2b58c65dbcf5f 100644 --- a/public/piece/anarcandy/wK.svg +++ b/public/piece/anarcandy/wK.svg @@ -1 +1 @@ - \ No newline at end of file + \ No newline at end of file diff --git a/public/piece/anarcandy/wN.svg b/public/piece/anarcandy/wN.svg index 7665324eae442..00332cf2f0fc1 100644 --- a/public/piece/anarcandy/wN.svg +++ b/public/piece/anarcandy/wN.svg @@ -1 +1 @@ - \ No newline at end of file + \ No newline at end of file diff --git a/public/piece/anarcandy/wP.svg b/public/piece/anarcandy/wP.svg index 479740bef219d..662e07f8f1de2 100644 --- a/public/piece/anarcandy/wP.svg +++ b/public/piece/anarcandy/wP.svg @@ -1 +1 @@ - \ No newline at end of file + \ No newline at end of file diff --git a/public/piece/anarcandy/wQ.svg b/public/piece/anarcandy/wQ.svg index 263064878d939..9104dbb2adcba 100644 --- a/public/piece/anarcandy/wQ.svg +++ b/public/piece/anarcandy/wQ.svg @@ -1 +1 @@ - \ No newline at end of file + \ No newline at end of file diff --git a/public/piece/anarcandy/wR.svg b/public/piece/anarcandy/wR.svg index 7690eff6a4ce5..d5f608c9ac6fb 100644 --- a/public/piece/anarcandy/wR.svg +++ b/public/piece/anarcandy/wR.svg @@ -1 +1 @@ - \ No newline at end of file + \ No newline at end of file From a93bad40a16e7057fe2d7b0d96809123be141868 Mon Sep 17 00:00:00 2001 From: Thibault Duplessis Date: Fri, 14 Jun 2024 22:06:57 +0200 Subject: [PATCH 032/168] sync only a list of relay tour ids useful in dev env --- conf/base.conf | 3 +++ modules/relay/src/main/Env.scala | 4 ++++ modules/relay/src/main/RelayApi.scala | 16 ++++++++++------ modules/relay/src/main/RelayFetch.scala | 7 +++++-- 4 files changed, 22 insertions(+), 8 deletions(-) diff --git a/conf/base.conf b/conf/base.conf index cb4084b954715..bd47354c11d86 100644 --- a/conf/base.conf +++ b/conf/base.conf @@ -125,6 +125,9 @@ puzzle { path = puzzle2_path } } +relay { + syncOnlyIds = null +} storm.secret = "somethingElseInProd" coordinate { collection { diff --git a/modules/relay/src/main/Env.scala b/modules/relay/src/main/Env.scala index 8ba1817eaa08d..bf3c2415fcdc9 100644 --- a/modules/relay/src/main/Env.scala +++ b/modules/relay/src/main/Env.scala @@ -16,6 +16,7 @@ import lila.relay.RelayTour.WithLastRound @Module final class Env( + config: play.api.Configuration, ws: StandaloneWSClient, db: lila.db.Db, yoloDb: lila.db.AsyncDb @@ lila.db.YoloDb, @@ -114,6 +115,9 @@ final class Env( private val relayFidePlayerApi = wire[RelayFidePlayerApi] + import lila.common.config.given + private val syncOnlyIds = config.getOptional[List[String]]("relay.syncOnlyIds").map(RelayTourId.from) + // start the sync scheduler wire[RelayFetch] diff --git a/modules/relay/src/main/RelayApi.scala b/modules/relay/src/main/RelayApi.scala index ad63e3ad2b6cf..a2a36920842ea 100644 --- a/modules/relay/src/main/RelayApi.scala +++ b/modules/relay/src/main/RelayApi.scala @@ -110,16 +110,16 @@ final class RelayApi( get(tour.id).map(RelayTour.WithGroupTours(tour, _)) def invalidate(id: RelayTourId) = cache.underlying.synchronous.invalidate(id) - private def toSyncSelect = $doc( + private def toSyncSelect(onlyIds: Option[List[RelayTourId]]) = $doc( "sync.until".$exists(true), "sync.nextAt".$lt(nowInstant) - ) + ) ++ onlyIds.so(ids => $doc("tourId".$in(ids))) - private[relay] def toSyncOfficial(max: Max): Fu[List[WithTour]] = + private[relay] def toSyncOfficial(max: Max, onlyIds: Option[List[RelayTourId]]): Fu[List[WithTour]] = roundRepo.coll .aggregateList(max.value, _.pri): framework => import framework.* - Match(toSyncSelect) -> List( + Match(toSyncSelect(onlyIds)) -> List( PipelineOperator(tourRepo.lookup("tourId")), UnwindField("tour"), Match($doc("tour.tier".$exists(true))), @@ -128,11 +128,15 @@ final class RelayApi( ) .map(_.flatMap(readRoundWithTour)) - private[relay] def toSyncUser(max: Max, maxPerUser: Max = Max(5)): Fu[List[WithTour]] = + private[relay] def toSyncUser( + max: Max, + onlyIds: Option[List[RelayTourId]], + maxPerUser: Max = Max(5) + ): Fu[List[WithTour]] = roundRepo.coll .aggregateList(max.value, _.pri): framework => import framework.* - Match(toSyncSelect) -> List( + Match(toSyncSelect(onlyIds)) -> List( PipelineOperator(tourRepo.lookup("tourId")), UnwindField("tour"), Match($doc("tour.tier".$exists(false))), diff --git a/modules/relay/src/main/RelayFetch.scala b/modules/relay/src/main/RelayFetch.scala index c15ba31bb3792..eb8f1344de023 100644 --- a/modules/relay/src/main/RelayFetch.scala +++ b/modules/relay/src/main/RelayFetch.scala @@ -27,7 +27,8 @@ final private class RelayFetch( fidePlayers: RelayFidePlayerApi, gameRepo: GameRepo, pgnDump: PgnDump, - gameProxy: lila.core.game.GameProxy + gameProxy: lila.core.game.GameProxy, + onlyIds: Option[List[RelayTourId]] = None )(using Executor, Scheduler, lila.core.i18n.Translator)(using mode: play.api.Mode): import RelayFetch.* @@ -51,7 +52,9 @@ final private class RelayFetch( private val maxRelaysToSync = Max(50) private def syncRelays(official: Boolean): Funit = - val relays = if official then api.toSyncOfficial(maxRelaysToSync) else api.toSyncUser(maxRelaysToSync) + val relays = + if official then api.toSyncOfficial(maxRelaysToSync, onlyIds) + else api.toSyncUser(maxRelaysToSync, onlyIds) relays .flatMap: relays => lila.mon.relay.ongoing(official).update(relays.size) From 8d00782625cb7bc3ff2f091f17898aef3488f504 Mon Sep 17 00:00:00 2001 From: Thibault Duplessis Date: Fri, 14 Jun 2024 22:09:46 +0200 Subject: [PATCH 033/168] list all participated broadcasts on fide profiles - closes #14950 even if they're part of a group and not the first one of the group --- modules/relay/src/main/RelayPager.scala | 48 +++++++++++++++---------- 1 file changed, 30 insertions(+), 18 deletions(-) diff --git a/modules/relay/src/main/RelayPager.scala b/modules/relay/src/main/RelayPager.scala index daff274c6e7c6..88016822b2547 100644 --- a/modules/relay/src/main/RelayPager.scala +++ b/modules/relay/src/main/RelayPager.scala @@ -115,12 +115,14 @@ final class RelayPager( forSelector( $inIds(ids) ++ selectors.officialPublic, page, + onlyKeepGroupFirst = false, List("syncedAt") ) private def forSelector( selector: Bdoc, page: Int, + onlyKeepGroupFirst: Boolean = true, sortFields: List[String] = List("tier", "syncedAt", "createdAt") ): Fu[Paginator[WithLastRound]] = Paginator( @@ -132,7 +134,7 @@ final class RelayPager( import framework.* Match(selector) -> { List(Sort(sortFields.map(Descending(_))*)) ::: - aggregateRoundAndUnwind(framework) ::: + aggregateRoundAndUnwind(framework, onlyKeepGroupFirst) ::: List(Skip(offset), Limit(length)) } .map(readToursWithRound) @@ -141,26 +143,36 @@ final class RelayPager( maxPerPage = maxPerPage ) - private def aggregateRoundAndUnwind(framework: tourRepo.coll.AggregationFramework.type) = - aggregateRound(framework) ::: List(framework.UnwindField("round")) - - private def aggregateRound(framework: tourRepo.coll.AggregationFramework.type) = List( - framework.PipelineOperator(RelayListing.group.lookup(colls.group)), - framework.Match(RelayListing.group.filter), - framework.PipelineOperator( - $lookup.pipeline( - from = roundRepo.coll, - as = "round", - local = "_id", - foreign = "tourId", - pipe = List( - $doc("$sort" -> RelayRoundRepo.sort.start), - $doc("$limit" -> 1), - $doc("$addFields" -> $doc("sync.log" -> $arr())) + private def aggregateRoundAndUnwind( + framework: tourRepo.coll.AggregationFramework.type, + onlyKeepGroupFirst: Boolean = true + ) = + aggregateRound(framework, onlyKeepGroupFirst) ::: List(framework.UnwindField("round")) + + private def aggregateRound( + framework: tourRepo.coll.AggregationFramework.type, + onlyKeepGroupFirst: Boolean = true + ) = + onlyKeepGroupFirst.so( + List( + framework.PipelineOperator(RelayListing.group.lookup(colls.group)), + framework.Match(RelayListing.group.filter) + ) + ) ::: List( + framework.PipelineOperator( + $lookup.pipeline( + from = roundRepo.coll, + as = "round", + local = "_id", + foreign = "tourId", + pipe = List( + $doc("$sort" -> RelayRoundRepo.sort.start), + $doc("$limit" -> 1), + $doc("$addFields" -> $doc("sync.log" -> $arr())) + ) ) ) ) - ) private def readToursWithRound(docs: List[Bdoc]): List[WithLastRound] = for doc <- docs From 38ea2cefa6053fc11f6b4f0e9f0ab3b3cab6209b Mon Sep 17 00:00:00 2001 From: Thibault Duplessis Date: Fri, 14 Jun 2024 23:40:13 +0200 Subject: [PATCH 034/168] better broadcast search ranking - closes #15504 mixing date, tier, and search score --- modules/relay/src/main/RelayPager.scala | 25 +++++++++++++++++++++---- 1 file changed, 21 insertions(+), 4 deletions(-) diff --git a/modules/relay/src/main/RelayPager.scala b/modules/relay/src/main/RelayPager.scala index 88016822b2547..ba23a71bb593e 100644 --- a/modules/relay/src/main/RelayPager.scala +++ b/modules/relay/src/main/RelayPager.scala @@ -109,20 +109,36 @@ final class RelayPager( ) def search(query: String, page: Int): Fu[Paginator[WithLastRound]] = - forSelector($text(query) ++ selectors.officialPublic, page) + val day = 1000L * 3600 * 24 + forSelector( + selector = $text(query) ++ selectors.officialPublic, + page = page, + onlyKeepGroupFirst = false, + addFields = $doc( + "searchDate" -> $doc( + "$add" -> $arr( + $doc("$ifNull" -> $arr("$syncedAt", "$createdAt")), + $doc("$multiply" -> $arr($doc("$add" -> $arr("$tier", -RelayTour.Tier.NORMAL)), 60 * day)), + $doc("$multiply" -> $arr($doc("$meta" -> "textScore"), 30 * day)) + ) + ) + ).some, + sortFields = List("searchDate") + ) def byIds(ids: List[RelayTourId], page: Int): Fu[Paginator[WithLastRound]] = forSelector( $inIds(ids) ++ selectors.officialPublic, - page, + page = page, onlyKeepGroupFirst = false, - List("syncedAt") + sortFields = List("syncedAt") ) private def forSelector( selector: Bdoc, page: Int, onlyKeepGroupFirst: Boolean = true, + addFields: Option[Bdoc] = None, sortFields: List[String] = List("tier", "syncedAt", "createdAt") ): Fu[Paginator[WithLastRound]] = Paginator( @@ -133,7 +149,8 @@ final class RelayPager( .aggregateList(length, _.sec): framework => import framework.* Match(selector) -> { - List(Sort(sortFields.map(Descending(_))*)) ::: + addFields.map(AddFields(_)).toList ::: + List(Sort(sortFields.map(Descending(_))*)) ::: aggregateRoundAndUnwind(framework, onlyKeepGroupFirst) ::: List(Skip(offset), Limit(length)) } From f6225d8fb5685f448a84018b3100fbfce0a166e5 Mon Sep 17 00:00:00 2001 From: Thanh Le Date: Sat, 15 Jun 2024 09:40:31 +0700 Subject: [PATCH 035/168] Bump lila-search RC8 And use count output as Long --- modules/gameSearch/src/main/GameSearchForm.scala | 2 +- modules/search/src/main/PaginatorBuilder.scala | 2 +- modules/search/src/main/SearchReadApi.scala | 2 +- modules/studySearch/src/main/Env.scala | 2 +- project/Dependencies.scala | 2 +- 5 files changed, 5 insertions(+), 5 deletions(-) diff --git a/modules/gameSearch/src/main/GameSearchForm.scala b/modules/gameSearch/src/main/GameSearchForm.scala index c18a05900f664..fba10520ccd4f 100644 --- a/modules/gameSearch/src/main/GameSearchForm.scala +++ b/modules/gameSearch/src/main/GameSearchForm.scala @@ -7,7 +7,7 @@ import java.time.LocalDate import lila.common.Form.* import lila.core.i18n.Translate -import lila.search.spec.{ Sorting as SpecSorting, Clocking, IntRange, DateRange, Query } +import lila.search.spec.{ Sorting as SpecSorting, IntRange, DateRange, Query } import smithy4s.Timestamp final private[gameSearch] class GameSearchForm: diff --git a/modules/search/src/main/PaginatorBuilder.scala b/modules/search/src/main/PaginatorBuilder.scala index f59515efb12a3..2302d3e1da784 100644 --- a/modules/search/src/main/PaginatorBuilder.scala +++ b/modules/search/src/main/PaginatorBuilder.scala @@ -10,7 +10,7 @@ final class PaginatorBuilder[A, Q]( def apply(query: Q, page: Int): Fu[Paginator[A]] = Paginator( adapter = new AdapterLike[A]: - def nbResults = searchApi.count(query) + def nbResults = searchApi.count(query).dmap(_.toInt) def slice(offset: Int, length: Int) = searchApi.search(query, From(offset), Size(length)) , diff --git a/modules/search/src/main/SearchReadApi.scala b/modules/search/src/main/SearchReadApi.scala index b6b03488009a2..acb96d65434fe 100644 --- a/modules/search/src/main/SearchReadApi.scala +++ b/modules/search/src/main/SearchReadApi.scala @@ -4,4 +4,4 @@ trait SearchReadApi[A, Q]: def search(query: Q, from: From, size: Size): Fu[List[A]] - def count(query: Q): Fu[Int] + def count(query: Q): Fu[Long] diff --git a/modules/studySearch/src/main/Env.scala b/modules/studySearch/src/main/Env.scala index 8f679c25973f4..5348917f1fc9f 100644 --- a/modules/studySearch/src/main/Env.scala +++ b/modules/studySearch/src/main/Env.scala @@ -27,7 +27,7 @@ final class Env( Paginator[Study.WithChaptersAndLiked]( adapter = new AdapterLike[Study]: def query = Query.study(text.take(100), me.map(_.id.value)) - def nbResults = api.count(query) + def nbResults = api.count(query).dmap(_.toInt) def slice(offset: Int, length: Int) = api.search(query, From(offset), Size(length)) .mapFutureList(pager.withChaptersAndLiking(me)), currentPage = page, diff --git a/project/Dependencies.scala b/project/Dependencies.scala index 955da39388b30..273cb5afdb76f 100644 --- a/project/Dependencies.scala +++ b/project/Dependencies.scala @@ -26,7 +26,7 @@ object Dependencies { val lettuce = "io.lettuce" % "lettuce-core" % "6.3.2.RELEASE" val nettyTransport = ("io.netty" % s"netty-transport-native-$notifier" % "4.1.111.Final").classifier(s"$os-$arch") - val lilaSearch = "org.lichess.search" %% "client" % "3.0.0-RC7" + val lilaSearch = "org.lichess.search" %% "client" % "3.0.0-RC8" val munit = "org.scalameta" %% "munit" % "1.0.0" % Test val uaparser = "org.uaparser" %% "uap-scala" % "0.17.0" val apacheText = "org.apache.commons" % "commons-text" % "1.12.0" From 334f70b7ada8bc2a250f83f150c981798a928f91 Mon Sep 17 00:00:00 2001 From: Thanh Le Date: Sat, 15 Jun 2024 10:40:35 +0700 Subject: [PATCH 036/168] Bump lila-search RC9 and fix forum's post date As We used to store date as milliseconds --- modules/forumSearch/src/main/ForumSearchApi.scala | 3 +-- project/Dependencies.scala | 2 +- 2 files changed, 2 insertions(+), 3 deletions(-) diff --git a/modules/forumSearch/src/main/ForumSearchApi.scala b/modules/forumSearch/src/main/ForumSearchApi.scala index 9ab9a94b5d2e0..3a223b357ca45 100644 --- a/modules/forumSearch/src/main/ForumSearchApi.scala +++ b/modules/forumSearch/src/main/ForumSearchApi.scala @@ -7,7 +7,6 @@ import lila.core.forum.{ ForumPostApi, ForumPostMini, ForumPostMiniView } import lila.core.id.ForumPostId import lila.search.client.SearchClient import lila.search.spec.{ ForumSource, Query } -import smithy4s.Timestamp final class ForumSearchApi( client: SearchClient, @@ -37,7 +36,7 @@ final class ForumSearchApi( author = view.post.userId.map(_.value), topicId = view.topic.id.value, troll = view.post.troll, - date = Timestamp.fromInstant(view.post.createdAt) + date = view.post.createdAt.toEpochMilli() ) def reset = diff --git a/project/Dependencies.scala b/project/Dependencies.scala index 273cb5afdb76f..52412dd976ab2 100644 --- a/project/Dependencies.scala +++ b/project/Dependencies.scala @@ -26,7 +26,7 @@ object Dependencies { val lettuce = "io.lettuce" % "lettuce-core" % "6.3.2.RELEASE" val nettyTransport = ("io.netty" % s"netty-transport-native-$notifier" % "4.1.111.Final").classifier(s"$os-$arch") - val lilaSearch = "org.lichess.search" %% "client" % "3.0.0-RC8" + val lilaSearch = "org.lichess.search" %% "client" % "3.0.0-RC9" val munit = "org.scalameta" %% "munit" % "1.0.0" % Test val uaparser = "org.uaparser" %% "uap-scala" % "0.17.0" val apacheText = "org.apache.commons" % "commons-text" % "1.12.0" From f1bbf837f7086078884873980c202628cc9f80e4 Mon Sep 17 00:00:00 2001 From: Thibault Duplessis Date: Sat, 15 Jun 2024 07:21:34 +0200 Subject: [PATCH 037/168] New Crowdin updates (#15495) * New translations: site.xml (Danish) * New translations: site.xml (Spanish) * New translations: site.xml (Catalan) * New translations: site.xml (German) * New translations: site.xml (Polish) * New translations: site.xml (Slovak) * New translations: site.xml (Albanian) * New translations: site.xml (Portuguese) * New translations: site.xml (Portuguese, Brazilian) * New translations: site.xml (Galician) * New translations: site.xml (Sorani (Kurdish)) * New translations: site.xml (English, United States) * New translations: site.xml (French) * New translations: site.xml (Norwegian Nynorsk) * New translations: faq.xml (English, United States) * New translations: site.xml (Persian) * New translations: site.xml (Swiss German) * New translations: site.xml (Afrikaans) * New translations: site.xml (Hebrew) * New translations: site.xml (Slovenian) * New translations: site.xml (Russian) * New translations: site.xml (Danish) * New translations: challenge.xml (Danish) * New translations: site.xml (Vietnamese) --- translation/dest/challenge/da-DK.xml | 2 +- translation/dest/faq/en-US.xml | 2 +- translation/dest/site/af-ZA.xml | 2 ++ translation/dest/site/ca-ES.xml | 2 ++ translation/dest/site/ckb-IR.xml | 2 ++ translation/dest/site/da-DK.xml | 4 +++- translation/dest/site/de-DE.xml | 2 ++ translation/dest/site/en-US.xml | 2 ++ translation/dest/site/es-ES.xml | 2 ++ translation/dest/site/fa-IR.xml | 2 ++ translation/dest/site/fr-FR.xml | 1 + translation/dest/site/gl-ES.xml | 2 ++ translation/dest/site/gsw-CH.xml | 2 ++ translation/dest/site/he-IL.xml | 2 ++ translation/dest/site/nn-NO.xml | 2 ++ translation/dest/site/pl-PL.xml | 2 ++ translation/dest/site/pt-BR.xml | 2 ++ translation/dest/site/pt-PT.xml | 2 ++ translation/dest/site/ru-RU.xml | 2 ++ translation/dest/site/sk-SK.xml | 2 ++ translation/dest/site/sl-SI.xml | 2 ++ translation/dest/site/sq-AL.xml | 2 ++ translation/dest/site/vi-VN.xml | 2 ++ 23 files changed, 44 insertions(+), 3 deletions(-) diff --git a/translation/dest/challenge/da-DK.xml b/translation/dest/challenge/da-DK.xml index 1bb763b89c775..d93acfe401ffd 100644 --- a/translation/dest/challenge/da-DK.xml +++ b/translation/dest/challenge/da-DK.xml @@ -12,7 +12,7 @@ Kan ikke udfordre på grund af provisorisk %s rating. %s accepterer kun udfordringer fra venner. Jeg accepterer ikke udfordringer i øjeblikket. - Det er ikke et godt tidspunkt for mig, spørg venligst igen senere. + Det er ikke et godt tidspunkt for mig, spørg gerne igen senere. Denne tidskontrol er for hurtig for mig. Udfordr mig gerne igen med et langsommere spil. Denne tidskontrol er for langsom for mig. Udfordr mig gerne igen med et hurtigere spil. Jeg accepterer ikke udfordringer med denne tidskontrol. diff --git a/translation/dest/faq/en-US.xml b/translation/dest/faq/en-US.xml index 3ecb689732a68..df2a03671a1ae 100644 --- a/translation/dest/faq/en-US.xml +++ b/translation/dest/faq/en-US.xml @@ -167,7 +167,7 @@ We show the red icon to alert you when this happens. Often you can explicitly al 3. Click Cookies and Site Permissions 4. Scroll down and click Media autoplay 5. Add lichess.org to Allow - Stop me from playing. + Stop myself from playing stand-alone mental health condition Lichess userstyles fewer lobby pools diff --git a/translation/dest/site/af-ZA.xml b/translation/dest/site/af-ZA.xml index e6f5a6d2e36c1..7d5e2587694c4 100644 --- a/translation/dest/site/af-ZA.xml +++ b/translation/dest/site/af-ZA.xml @@ -70,6 +70,8 @@ Bevorder variasie Maak hooflyn Verwyder hiervandaan + Verberg variasies + Vertoon variasies Forseer variasie Kopieer variasie-PGN Skuif diff --git a/translation/dest/site/ca-ES.xml b/translation/dest/site/ca-ES.xml index 4e5da1414ddd1..88b4f62d71dd2 100644 --- a/translation/dest/site/ca-ES.xml +++ b/translation/dest/site/ca-ES.xml @@ -70,6 +70,8 @@ Promoure variant Convertir en línia principal Esborrar des d\'aquí + Amagar variacions + Expandir variacions Forçar variant Copia el PGN de la variació Moviment diff --git a/translation/dest/site/ckb-IR.xml b/translation/dest/site/ckb-IR.xml index 68697cad916f3..31055d425193a 100644 --- a/translation/dest/site/ckb-IR.xml +++ b/translation/dest/site/ckb-IR.xml @@ -70,6 +70,8 @@ برەوپێدانی جۆراوجۆر کردن بە رستەی سەرەکی لێرە بیسڕەوە + تێکدانی لایەنەکانی دیکە + درێژکردنەوەی لایەنەکانی دیکە هێزی جۆراوجۆر کۆپی گۆڕانکاری PGN جوڵە diff --git a/translation/dest/site/da-DK.xml b/translation/dest/site/da-DK.xml index fe3de8d53c803..404fa19acad46 100644 --- a/translation/dest/site/da-DK.xml +++ b/translation/dest/site/da-DK.xml @@ -70,6 +70,8 @@ Forfrem variant Gør til hovedlinjen Slet herfra + Fold variationer sammen + Udvid variationer Gennemtving variation Kopiér variant-PGN Træk @@ -799,7 +801,7 @@ Nulstil farver til standard Brikker Indlejr på din hjemmeside - Dette brugernavn er allerede i brug. Vælg venligst et andet og prøv igen. + Dette brugernavn er allerede i brug. Vælg et andet og prøv igen. Brugernavnet skal begynde med et bogstav. Brugernavnet skal afsluttes med et bogstav eller et tal. Brugernavnet må kun indeholde bogstaver, tal, underscore og bindestreger. diff --git a/translation/dest/site/de-DE.xml b/translation/dest/site/de-DE.xml index fb7b076f3b623..ae4a17e4c7e0c 100644 --- a/translation/dest/site/de-DE.xml +++ b/translation/dest/site/de-DE.xml @@ -70,6 +70,8 @@ Variante aufwerten Zur Hauptvariante machen Ab hier löschen + Varianten einklappen + Varianten ausklappen Variante erzwingen PGN-Variante kopieren Zug diff --git a/translation/dest/site/en-US.xml b/translation/dest/site/en-US.xml index bbcb425b17843..332903fbaaaaa 100644 --- a/translation/dest/site/en-US.xml +++ b/translation/dest/site/en-US.xml @@ -70,6 +70,8 @@ Promote variation Make main line Delete from here + Collapse variations + Expand variations Force variation Copy variation PGN Move diff --git a/translation/dest/site/es-ES.xml b/translation/dest/site/es-ES.xml index 411a758e6657d..c1e3946adc929 100644 --- a/translation/dest/site/es-ES.xml +++ b/translation/dest/site/es-ES.xml @@ -70,6 +70,8 @@ Promocionar variante Convertir en línea principal Borrar a partir de aquí + Cerrar variantes + Abrir variantes Convertir en variante Copiar PGN de la variante Movimiento diff --git a/translation/dest/site/fa-IR.xml b/translation/dest/site/fa-IR.xml index e16aacef370da..f4d20c9beedd6 100644 --- a/translation/dest/site/fa-IR.xml +++ b/translation/dest/site/fa-IR.xml @@ -70,6 +70,8 @@ افزایش عمق شاخه اصلی خط کنونی را به خط اصلی تبدیل کنید از اینجا به بعد را پاک کنید + بستن شاخه‌ها + باز کردن شاخه‌ها نتیجه تحلیل را به عنوان یکی از تنوعهای بازی انتخاب نمایید کپی PGN این شاخه انتقال بدهید diff --git a/translation/dest/site/fr-FR.xml b/translation/dest/site/fr-FR.xml index c07b89a488af3..117f82cc56078 100644 --- a/translation/dest/site/fr-FR.xml +++ b/translation/dest/site/fr-FR.xml @@ -70,6 +70,7 @@ Promouvoir la variante En faire la variante principale Supprimer à partir d\'ici + Afficher les variantes Forcer la variante Copier le PGN de la variante Coup diff --git a/translation/dest/site/gl-ES.xml b/translation/dest/site/gl-ES.xml index 9089d78ff9c18..2a36432053d19 100644 --- a/translation/dest/site/gl-ES.xml +++ b/translation/dest/site/gl-ES.xml @@ -70,6 +70,8 @@ Promover variante Converter en liña principal Borrar desde aquí + Contraer as variantes + Despregar as variantes Forzar variante Copiar o PGN da variante Movemento diff --git a/translation/dest/site/gsw-CH.xml b/translation/dest/site/gsw-CH.xml index b482e0232a6e8..7c442c77447cf 100644 --- a/translation/dest/site/gsw-CH.xml +++ b/translation/dest/site/gsw-CH.xml @@ -70,6 +70,8 @@ Variante ufwerte Zur Hauptvariante mache Ab da lösche + Variante kollabiere + Variante erwitere Variante erzwinge PGN Variante kopiere Zug diff --git a/translation/dest/site/he-IL.xml b/translation/dest/site/he-IL.xml index ac2748d70ecdd..5db647b9d37b3 100644 --- a/translation/dest/site/he-IL.xml +++ b/translation/dest/site/he-IL.xml @@ -72,6 +72,8 @@ העדפת וריאנט קביעה כוריאנט הראשי מחיקה מכאן והלאה + הסתרת מהלכים חלופיים + הצגת מהלכים חלופיים וריאנט יחיד העתקת ה-PGN של הוריאנט מסע diff --git a/translation/dest/site/nn-NO.xml b/translation/dest/site/nn-NO.xml index bc31504d6a541..64a80714a7d24 100644 --- a/translation/dest/site/nn-NO.xml +++ b/translation/dest/site/nn-NO.xml @@ -70,6 +70,8 @@ Forfremjingsvariant Gjer til hovudline Slett herifrå + Skjul variantar + Vis variantar Tving fram varianten Kopier variant-PGN Trekk diff --git a/translation/dest/site/pl-PL.xml b/translation/dest/site/pl-PL.xml index 950fdaf959d33..bb9d250caf713 100644 --- a/translation/dest/site/pl-PL.xml +++ b/translation/dest/site/pl-PL.xml @@ -72,6 +72,8 @@ Promuj ten wariant Promuj na główny wariant Usuń od tego miejsca + Zwiń warianty + Rozwiń warianty Przedstaw jako wariant Skopiuj wariant PGN Ruch diff --git a/translation/dest/site/pt-BR.xml b/translation/dest/site/pt-BR.xml index 77ea363fdf7c8..705434a0b1373 100644 --- a/translation/dest/site/pt-BR.xml +++ b/translation/dest/site/pt-BR.xml @@ -70,6 +70,8 @@ Promover variante Transformar em linha principal Excluir a partir daqui + Esconder variantes + Mostrar variantes Variante forçada Copiar PGN da variante Movimentos diff --git a/translation/dest/site/pt-PT.xml b/translation/dest/site/pt-PT.xml index 1442735f6adf9..b6e72e924705f 100644 --- a/translation/dest/site/pt-PT.xml +++ b/translation/dest/site/pt-PT.xml @@ -70,6 +70,8 @@ Promover variante Tornar variante principal Eliminar a partir de aqui + Recolher variações + Expandir variações Forçar variante Copiar variação PGN Jogada diff --git a/translation/dest/site/ru-RU.xml b/translation/dest/site/ru-RU.xml index a39c228b6eaac..97db45e465e21 100644 --- a/translation/dest/site/ru-RU.xml +++ b/translation/dest/site/ru-RU.xml @@ -72,6 +72,8 @@ Повысить приоритет варианта Сделать этот вариант главным Удалить с этого места + Свернуть варианты + Развернуть варианты Сделать вариантом Скопировать вариант в формате PGN Ход diff --git a/translation/dest/site/sk-SK.xml b/translation/dest/site/sk-SK.xml index 71f953fda6f79..f7eb9ef00fe9f 100644 --- a/translation/dest/site/sk-SK.xml +++ b/translation/dest/site/sk-SK.xml @@ -72,6 +72,8 @@ Povýšiť variant Povýšiť na hlavnú variantu Vymazať odtiaľto + Skryť varianty + Ukázať varianty Povýšiť variant Kopírovať PGN variantu Ťah diff --git a/translation/dest/site/sl-SI.xml b/translation/dest/site/sl-SI.xml index 5f7b9ff27ed38..45b0341f50a14 100644 --- a/translation/dest/site/sl-SI.xml +++ b/translation/dest/site/sl-SI.xml @@ -72,6 +72,8 @@ Promoviraj variacijo Nastavite kot glavno varianto Izbriši od tukaj + Strni različice + Razširite različice Vsili varianto Kopiraj različico PGN Poteza diff --git a/translation/dest/site/sq-AL.xml b/translation/dest/site/sq-AL.xml index ad98c27935570..81ebc24c7f7be 100644 --- a/translation/dest/site/sq-AL.xml +++ b/translation/dest/site/sq-AL.xml @@ -70,6 +70,8 @@ Promovoni variacion Bëje variantin kryesor Fshije nga këtu + Tkurri variantet + Shfaqi variantet Detyro variant Kopjo PGN varianti Lëvizje diff --git a/translation/dest/site/vi-VN.xml b/translation/dest/site/vi-VN.xml index 95c6b1edb3eba..d74461afe3a23 100644 --- a/translation/dest/site/vi-VN.xml +++ b/translation/dest/site/vi-VN.xml @@ -69,6 +69,8 @@ Thay đổi biến Biến chính Xoá từ đây + Thu gọn các biến + Mở rộng các biến Đổi biến Sao chép biến PGN Nước cờ From ca49c021164b98c04854ac0ac8f8c33a58f66b26 Mon Sep 17 00:00:00 2001 From: Thibault Duplessis Date: Sat, 15 Jun 2024 08:03:08 +0200 Subject: [PATCH 038/168] read forum posts from primary --- modules/forum/src/main/ForumPostRepo.scala | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/modules/forum/src/main/ForumPostRepo.scala b/modules/forum/src/main/ForumPostRepo.scala index daf971b555f8b..33029a19f59fc 100644 --- a/modules/forum/src/main/ForumPostRepo.scala +++ b/modules/forum/src/main/ForumPostRepo.scala @@ -121,4 +121,4 @@ final class ForumPostRepo(val coll: Coll, filter: Filter = Safe)(using val filter = since.fold(noGhost)(instant => $and(noGhost, $doc("createdAt".$gt(instant)))) coll .find(filter, miniProjection.some) - .cursor[ForumPostMini](ReadPref.sec) + .cursor[ForumPostMini](ReadPref.priTemp) From 02eff3a3b8a3d35aa8b7f0761da729fd99a18b9b Mon Sep 17 00:00:00 2001 From: Thibault Duplessis Date: Sat, 15 Jun 2024 08:27:51 +0200 Subject: [PATCH 039/168] scala rewrite with for --- app/controllers/Study.scala | 115 ++++++++++++++++++------------------ 1 file changed, 58 insertions(+), 57 deletions(-) diff --git a/app/controllers/Study.scala b/app/controllers/Study.scala index 231bc2b23e552..891c315883d64 100644 --- a/app/controllers/Study.scala +++ b/app/controllers/Study.scala @@ -33,13 +33,14 @@ final class Study( def search(text: String, page: Int) = OpenBody: Reasonable(page): if text.trim.isEmpty then - env.study.pager - .all(Orders.default, page) - .flatMap: pag => - preloadMembers(pag) >> negotiate( - Ok.page(views.study.list.all(pag, Orders.default)), - apiStudies(pag) - ) + for + pag <- env.study.pager.all(Orders.default, page) + _ <- preloadMembers(pag) + res <- negotiate( + Ok.page(views.study.list.all(pag, Orders.default)), + apiStudies(pag) + ) + yield res else env .studySearch(ctx.me)(text, page) @@ -62,13 +63,14 @@ final class Study( case order if !Orders.withoutSelector.contains(order) => Redirect(routes.Study.allDefault(page)) case order => - env.study.pager - .all(order, page) - .flatMap: pag => - preloadMembers(pag) >> negotiate( - Ok.page(views.study.list.all(pag, order)), - apiStudies(pag) - ) + for + pag <- env.study.pager.all(order, page) + _ <- preloadMembers(pag) + res <- negotiate( + Ok.page(views.study.list.all(pag, order)), + apiStudies(pag) + ) + yield res def byOwnerDefault(username: UserStr, page: Int) = byOwner(username, Orders.default, page) @@ -83,50 +85,55 @@ final class Study( ) def mine(order: Order, page: Int) = Auth { ctx ?=> me ?=> - env.study.pager - .mine(order, page) - .flatMap: pag => - preloadMembers(pag) >> negotiate( - env.study.topicApi.userTopics(me).flatMap { topics => - Ok.page(views.study.list.mine(pag, order, topics)) - }, - apiStudies(pag) - ) + for + pag <- env.study.pager.mine(order, page) + _ <- preloadMembers(pag) + res <- negotiate( + env.study.topicApi.userTopics(me).flatMap { topics => + Ok.page(views.study.list.mine(pag, order, topics)) + }, + apiStudies(pag) + ) + yield res } def minePublic(order: Order, page: Int) = Auth { ctx ?=> me ?=> - env.study.pager - .minePublic(order, page) - .flatMap: pag => - preloadMembers(pag) >> negotiate( - Ok.page(views.study.list.minePublic(pag, order)), - apiStudies(pag) - ) + for + pag <- env.study.pager.minePublic(order, page) + _ <- preloadMembers(pag) + res <- negotiate( + Ok.page(views.study.list.minePublic(pag, order)), + apiStudies(pag) + ) + yield res } def minePrivate(order: Order, page: Int) = Auth { ctx ?=> me ?=> - env.study.pager - .minePrivate(order, page) - .flatMap: pag => - preloadMembers(pag) >> negotiate( - Ok.page(views.study.list.minePrivate(pag, order)), - apiStudies(pag) - ) + for + pag <- env.study.pager.minePrivate(order, page) + _ <- preloadMembers(pag) + res <- negotiate( + Ok.page(views.study.list.minePrivate(pag, order)), + apiStudies(pag) + ) + yield res + } def mineMember(order: Order, page: Int) = Auth { ctx ?=> me ?=> - env.study.pager - .mineMember(order, page) - .flatMap: pag => - preloadMembers(pag) >> negotiate( - Ok.async: - env.study.topicApi - .userTopics(me) - .map: - views.study.list.mineMember(pag, order, _) - , - apiStudies(pag) - ) + for + pag <- env.study.pager.mineMember(order, page) + _ <- preloadMembers(pag) + res <- negotiate( + Ok.async: + env.study.topicApi + .userTopics(me) + .map: + views.study.list.mineMember(pag, order, _) + , + apiStudies(pag) + ) + yield res } def mineLikes(order: Order, page: Int) = Auth { ctx ?=> me ?=> @@ -327,9 +334,8 @@ final class Study( def clearChat(id: StudyId) = Auth { _ ?=> me ?=> env.study.api .isOwnerOrAdmin(id, me) - .flatMapz { + .flatMapz: env.chat.api.userChat.clear(id.into(ChatId)) - } .inject(Redirect(routes.Study.show(id))) } @@ -339,12 +345,7 @@ final class Study( val chapterDatas = data.toChapterDatas limit.studyPgnImport(me, rateLimited, cost = chapterDatas.size): env.study.api - .importPgns( - id, - chapterDatas, - sticky = data.sticky, - ctx.pref.showRatings - )(Who(me, sri)) + .importPgns(id, chapterDatas, sticky = data.sticky, ctx.pref.showRatings)(Who(me, sri)) .map(f) def importPgn(id: StudyId) = AuthBody { ctx ?=> me ?=> From 5e38f28c02fead339f5b6650f63462b298da18c9 Mon Sep 17 00:00:00 2001 From: Thibault Duplessis Date: Sat, 15 Jun 2024 09:05:45 +0200 Subject: [PATCH 040/168] fix relay form help indentation --- modules/relay/src/main/ui/FormUi.scala | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/modules/relay/src/main/ui/FormUi.scala b/modules/relay/src/main/ui/FormUi.scala index 26d1da70df36d..e9108a463e6cc 100644 --- a/modules/relay/src/main/ui/FormUi.scala +++ b/modules/relay/src/main/ui/FormUi.scala @@ -268,7 +268,7 @@ final class FormUi(helpers: Helpers, ui: RelayUi, tourUi: RelayTourUi): pre("player name / rating / title / new name"), "All values are optional. Example:", pre("""Magnus Carlsen / 2863 / GM - YouGotLittUp / 1890 / / Louis Litt""") +YouGotLittUp / 1890 / / Louis Litt""") ).some, half = true )(form3.textarea(_)(rows := 3)), @@ -280,7 +280,7 @@ final class FormUi(helpers: Helpers, ui: RelayUi, tourUi: RelayTourUi): pre("Team name; Fide Id or Player name"), "Example:", pre("""Team Cats ; 3408230 - Team Dogs ; Scooby Doo"""), +Team Dogs ; Scooby Doo"""), "By default the PGN tags WhiteTeam and BlackTeam are used." ).some, half = true @@ -389,8 +389,8 @@ final class FormUi(helpers: Helpers, ui: RelayUi, tourUi: RelayTourUi): br, "Example:", pre("""Youth Championship 2024 - tour1-id Youth Championship 2024 | G20 - tour2-id Youth Championship 2024 | G16 - """) +tour1-id Youth Championship 2024 | G20 +tour2-id Youth Championship 2024 | G16 +""") ) ) From b4d06bd54e9a9199a0920768f7d37a5d4bda1ab2 Mon Sep 17 00:00:00 2001 From: Thibault Duplessis Date: Sat, 15 Jun 2024 09:08:54 +0200 Subject: [PATCH 041/168] rename broadcast private tier --- modules/relay/src/main/RelayTour.scala | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/modules/relay/src/main/RelayTour.scala b/modules/relay/src/main/RelayTour.scala index 749caecec038d..1f3b1ccd1cc25 100644 --- a/modules/relay/src/main/RelayTour.scala +++ b/modules/relay/src/main/RelayTour.scala @@ -60,7 +60,7 @@ object RelayTour: NORMAL.toString -> "Official: normal tier", HIGH.toString -> "Official: high tier", BEST.toString -> "Official: best tier", - PRIVATE.toString -> "Official: Private" + PRIVATE.toString -> "Private" ) def name(tier: Tier) = options.collectFirst { case (t, n) if t == tier.toString => n From 7fed8a65a4bb07721e903c0ffd2df3167c20586a Mon Sep 17 00:00:00 2001 From: Thibault Duplessis Date: Sat, 15 Jun 2024 09:18:52 +0200 Subject: [PATCH 042/168] hide broadcast pinned streamer form --- modules/relay/src/main/ui/FormUi.scala | 63 ++++++++++++++------------ 1 file changed, 33 insertions(+), 30 deletions(-) diff --git a/modules/relay/src/main/ui/FormUi.scala b/modules/relay/src/main/ui/FormUi.scala index e9108a463e6cc..d8bda1ef7337c 100644 --- a/modules/relay/src/main/ui/FormUi.scala +++ b/modules/relay/src/main/ui/FormUi.scala @@ -320,38 +320,41 @@ Team Dogs ; Scooby Doo"""), form3.select(_, langList.popularLanguagesForm.choices) ), tg.map: t => - div( - cls := "relay-pinned-streamer-edit", - data("post-url") := routes.RelayTour.image(t.tour.id, "pinnedStreamerImage".some) - )( + details( + summary("Pinned streamer"), div( - form3.group( - form("pinnedStreamer"), - "Pinned streamer", - help = frag( - p("The pinned streamer is featured even when they're not watching the broadcast."), - p("An optional placeholder image will embed their stream when clicked."), - p( - "To upload one, you must first submit this form with a pinned streamer. " - + "Then return to this page and choose an image." - ) - ).some - )(form3.input(_)), - span( - button(tpe := "button", cls := "button streamer-select-image")("select image"), - button( - tpe := "button", - cls := "button button-empty button-red streamer-delete-image", - data("post-url") := routes.RelayTour.image(t.tour.id, "pinnedStreamerImage".some) - )("delete image") - ) - ), - ui.thumbnail(t.tour.pinnedStreamerImage, _.Size.Small16x9)( - cls := List( - "streamer-drop-target" -> true, - "user-image" -> t.tour.pinnedStreamerImage.isDefined + cls := "relay-pinned-streamer-edit", + data("post-url") := routes.RelayTour.image(t.tour.id, "pinnedStreamerImage".some) + )( + div( + form3.group( + form("pinnedStreamer"), + "Pinned streamer", + help = frag( + p("The pinned streamer is featured even when they're not watching the broadcast."), + p("An optional placeholder image will embed their stream when clicked."), + p( + "To upload one, you must first submit this form with a pinned streamer. " + + "Then return to this page and choose an image." + ) + ).some + )(form3.input(_)), + span( + button(tpe := "button", cls := "button streamer-select-image")("select image"), + button( + tpe := "button", + cls := "button button-empty button-red streamer-delete-image", + data("post-url") := routes.RelayTour.image(t.tour.id, "pinnedStreamerImage".some) + )("delete image") + ) ), - attr("draggable") := "true" + ui.thumbnail(t.tour.pinnedStreamerImage, _.Size.Small16x9)( + cls := List( + "streamer-drop-target" -> true, + "user-image" -> t.tour.pinnedStreamerImage.isDefined + ), + attr("draggable") := "true" + ) ) ) ) From 3fbb922212761ec8096a6484d8277ae173da1362 Mon Sep 17 00:00:00 2001 From: Thibault Duplessis Date: Sat, 15 Jun 2024 09:59:26 +0200 Subject: [PATCH 043/168] fix lobby game load background in light theme - closes #15502 --- ui/lobby/css/app/_app.scss | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ui/lobby/css/app/_app.scss b/ui/lobby/css/app/_app.scss index 112ad2ba37c43..2fe0bb360b589 100644 --- a/ui/lobby/css/app/_app.scss +++ b/ui/lobby/css/app/_app.scss @@ -35,7 +35,7 @@ } .lredir { - background: $c-bg-box; + background: $c-bg-box !important; display: flex; .spinner { From f48a2f13dd61a9ec5c8e6ca967fb6e4c6eb2f65e Mon Sep 17 00:00:00 2001 From: Thibault Duplessis Date: Sat, 15 Jun 2024 09:59:42 +0200 Subject: [PATCH 044/168] monospace in technical broadcast form textareas --- ui/bits/css/relay/_form.scss | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/ui/bits/css/relay/_form.scss b/ui/bits/css/relay/_form.scss index 4518e6ad7041c..5e2d055418f52 100644 --- a/ui/bits/css/relay/_form.scss +++ b/ui/bits/css/relay/_form.scss @@ -28,6 +28,13 @@ margin-bottom: 2em; } } + +#form3-grouping, +#form3-players, +#form3-teams { + font-family: monospace; +} + .relay-image { max-width: 100%; height: auto; From 72e520f645c9d13c402d332de83ff973983580f8 Mon Sep 17 00:00:00 2001 From: Jonathan Gamble Date: Sat, 15 Jun 2024 04:06:25 -0500 Subject: [PATCH 045/168] use scss variables for important z-index values --- ui/analyse/css/_context-menu.scss | 2 +- ui/analyse/css/_player-clock.scss | 2 +- ui/analyse/css/study/relay/_video-player.scss | 4 +- ui/bits/css/build/bits.lpv.scss | 2 +- ui/bits/css/streamer/_header.scss | 4 +- ui/bits/css/user/_show.scss | 2 +- ui/chess/css/_promotion.scss | 2 +- ui/common/css/abstract/_extends.scss | 4 +- ui/common/css/abstract/_z-index.scss | 80 ++++++++----------- ui/common/css/component/_announce.scss | 2 +- ui/common/css/component/_complete.scss | 2 +- ui/common/css/component/_dialog.scss | 4 +- ui/common/css/component/_friend-box.scss | 2 +- ui/common/css/component/_mselect.scss | 2 +- ui/common/css/component/_power-tip.scss | 2 +- ui/common/css/component/_reconnecting.scss | 2 +- ui/common/css/component/_subnav.scss | 2 +- ui/common/css/component/_zen-toggle.scss | 2 +- ui/common/css/header/_buttons.scss | 2 +- ui/common/css/header/_header.scss | 2 +- ui/common/css/header/_topnav-hidden.scss | 6 +- ui/common/css/theme/board/_chessground.scss | 14 ++-- ui/game/css/_row.scss | 2 +- ui/lobby/css/app/_hook-chart.scss | 2 +- ui/mod/css/_inquiry.scss | 2 +- ui/mod/css/_user.scss | 2 +- ui/round/css/_meta.scss | 2 +- ui/tutor/css/_util.scss | 2 +- 28 files changed, 72 insertions(+), 86 deletions(-) diff --git a/ui/analyse/css/_context-menu.scss b/ui/analyse/css/_context-menu.scss index 09dba62142b6b..93ba9a97d95ab 100644 --- a/ui/analyse/css/_context-menu.scss +++ b/ui/analyse/css/_context-menu.scss @@ -4,7 +4,7 @@ background: $c-bg-box; position: absolute; display: none; - z-index: z('context-menu'); + z-index: $z-context-menu-108; cursor: default; user-select: none; -webkit-user-select: none; diff --git a/ui/analyse/css/_player-clock.scss b/ui/analyse/css/_player-clock.scss index d4f0fdff870ce..94a777e2700ab 100644 --- a/ui/analyse/css/_player-clock.scss +++ b/ui/analyse/css/_player-clock.scss @@ -9,7 +9,7 @@ $clock-height: 20px; &.top { top: #{-$clock-height}; - z-index: z('above-site-header'); + z-index: $z-above-site-header-107; .is3d & { top: #{-$clock-height - 35px}; diff --git a/ui/analyse/css/study/relay/_video-player.scss b/ui/analyse/css/study/relay/_video-player.scss index 4b8333a02eda0..44a90f13872ad 100644 --- a/ui/analyse/css/study/relay/_video-player.scss +++ b/ui/analyse/css/study/relay/_video-player.scss @@ -1,5 +1,5 @@ #video-player { - z-index: z('video-player'); + z-index: $z-video-player-100; display: none; position: absolute; border: 0; @@ -11,7 +11,7 @@ } img.video-player-close { - z-index: z('video-player-controls'); + z-index: $z-video-player-controls-101; position: absolute; height: 20px; width: 20px; diff --git a/ui/bits/css/build/bits.lpv.scss b/ui/bits/css/build/bits.lpv.scss index 1df05a5fa6ac0..15552bd0997bd 100644 --- a/ui/bits/css/build/bits.lpv.scss +++ b/ui/bits/css/build/bits.lpv.scss @@ -8,7 +8,7 @@ } .lpv__gamebook { @extend %popup-shadow; - z-index: z('cg__board.overlay'); + z-index: $z-cg__board_overlay-100; position: absolute; top: 50%; @include inline-start(50%); diff --git a/ui/bits/css/streamer/_header.scss b/ui/bits/css/streamer/_header.scss index 9600d0805c774..087e134ee4aa9 100644 --- a/ui/bits/css/streamer/_header.scss +++ b/ui/bits/css/streamer/_header.scss @@ -133,11 +133,11 @@ gap: 1em; align-self: flex-start; font-weight: bold; - z-index: z('link-overlay'); + z-index: $z-link-overlay-2; } .streamer-profile { - z-index: z('link-overlay'); + z-index: $z-link-overlay-2; } .live .streamer-lang { diff --git a/ui/bits/css/user/_show.scss b/ui/bits/css/user/_show.scss index 4520832709804..b6ed004f1b19e 100644 --- a/ui/bits/css/user/_show.scss +++ b/ui/bits/css/user/_show.scss @@ -53,7 +53,7 @@ .dropdown-window { @extend %dropdown-shadow; - z-index: z('link-overlay'); + z-index: $z-link-overlay-2; visibility: hidden; background: $c-bg-header-dropdown; border-radius: 3px 0 3px 3px; diff --git a/ui/chess/css/_promotion.scss b/ui/chess/css/_promotion.scss index 7c6ab1922e90a..b87cb4dbc313f 100644 --- a/ui/chess/css/_promotion.scss +++ b/ui/chess/css/_promotion.scss @@ -1,6 +1,6 @@ #promotion-choice { background: $m-bg--fade-30; - z-index: z('cg__promotion'); + z-index: $z-cg__promotion-205; position: absolute; width: var(---cg-width, 100%); diff --git a/ui/common/css/abstract/_extends.scss b/ui/common/css/abstract/_extends.scss index 83afbac2698d2..7c4aa78db700c 100644 --- a/ui/common/css/abstract/_extends.scss +++ b/ui/common/css/abstract/_extends.scss @@ -255,7 +255,7 @@ width: 100vw; // escape from bounding box of any fixed position parent height: 100vh; background: $c-page-mask; - z-index: z('fullscreen-mask'); + z-index: $z-fullscreen-mask-110; } %link-overlay { @@ -264,7 +264,7 @@ left: 0; width: 100%; height: 100%; - z-index: z('link-overlay'); + z-index: $z-link-overlay-2; } %abs-100 { diff --git a/ui/common/css/abstract/_z-index.scss b/ui/common/css/abstract/_z-index.scss index 21b23109deab7..46462a3eb330c 100644 --- a/ui/common/css/abstract/_z-index.scss +++ b/ui/common/css/abstract/_z-index.scss @@ -1,48 +1,34 @@ -/// Z-indexes map, gathering all Z layers of the application -/// @access private -/// @type Map -/// @prop {String} key - Layer’s name -/// @prop {Number} value - Z value mapped to the key -$z-indexes: ( - 'cg__promotion': 205, - 'cg__piece.dragging': 204, - 'cg__board.overlay': 100, - 'cg__piece.anim': 3, - 'cg__svg.cg-shapes': 2, - 'cg__svg.cg-custom-svgs': 4, - 'cg__cg-auto-pieces': 2, - 'cg__piece': 2, - 'cg__piece.fading': 1, - 'powertip': 120, - 'complete': 113, - 'inquiry': 112, - 'zen-toggle': 111, - 'modal': 111, - 'mselect': 111, - 'topnav': 111, - 'fullscreen-mask': 110, - 'dropdown': 109, - 'context-menu': 108, - 'above-site-header': 107, - 'site-header': 106, - 'network-status': 105, - 'tour-reminder': 104, - 'video-player-controls': 101, - 'video-player': 100, - 'mz-menu': 4, - 'above-link-overlay': 3, - 'friend-box': 2, - 'link-overlay': 2, - 'game-bookmark': 2, - 'subnav-side': 2, - 'default': 0, -); +/// Z-indexes, gathering all Z layers of the application -/// Get a z-index value from a layer name -/// @access public -/// @param {String} $layer - Layer’s name -/// @return {Number} -/// @require $z-indexes -@function z($layer) { - @return map-get($z-indexes, $layer); -} +$z-cg__promotion-205: 205; +$z-cg__piece_dragging-204: 204; +$z-cg__board_overlay-100: 100; +$z-cg__piece_anim-3: 3; +$z-cg__svg_cg-shapes-2: 2; +$z-cg__svg_cg-custom-svgs-4: 4; +$z-cg__cg-auto-pieces-2: 2; +$z-cg__piece-2: 2; +$z-cg__piece_fading-1: 1; +$z-powertip-120: 120; +$z-complete-113: 113; +$z-inquiry-112: 112; +$z-zen-toggle-111: 111; +$z-modal-111: 111; +$z-mselect-111: 111; +$z-topnav-111: 111; +$z-fullscreen-mask-110: 110; +$z-dropdown-109: 109; +$z-context-menu-108: 108; +$z-above-site-header-107: 107; +$z-site-header-106: 106; +$z-network-status-105: 105; +$z-tour-reminder-104: 104; +$z-video-player-controls-101: 101; +$z-video-player-100: 100; +$z-mz-menu-4: 4; +$z-above-link-overlay-3: 3; +$z-friend-box-2: 2; +$z-link-overlay-2: 2; +$z-game-bookmark-2: 2; +$z-subnav-side-2: 2; +$z-default-0: 0; diff --git a/ui/common/css/component/_announce.scss b/ui/common/css/component/_announce.scss index cc9b4f6c7c056..2592adc209745 100644 --- a/ui/common/css/component/_announce.scss +++ b/ui/common/css/component/_announce.scss @@ -8,7 +8,7 @@ background: $c-primary; color: $c-over; padding: 0.7rem 1rem; - z-index: z('tour-reminder'); + z-index: $z-tour-reminder-104; width: 100%; @media (min-width: at-least($xx-small)) { diff --git a/ui/common/css/component/_complete.scss b/ui/common/css/component/_complete.scss index 3bf7122d06a9f..7f63b3834c135 100644 --- a/ui/common/css/component/_complete.scss +++ b/ui/common/css/component/_complete.scss @@ -8,7 +8,7 @@ position: absolute; top: 100%; - z-index: z('complete'); + z-index: $z-complete-113; width: 14em; min-height: 2em; background-color: $c-bg-box; diff --git a/ui/common/css/component/_dialog.scss b/ui/common/css/component/_dialog.scss index 9f544157d558a..a78efd82223ec 100644 --- a/ui/common/css/component/_dialog.scss +++ b/ui/common/css/component/_dialog.scss @@ -9,7 +9,7 @@ dialog { @include if-rtl { transform: translate(50%, -50%); } - z-index: z('modal'); + z-index: $z-modal-111; padding: 0; border: none; background: $c-bg-high; @@ -38,7 +38,7 @@ dialog { @include inline-end(4px); width: 40px; // bigger for phones height: 40px; - z-index: z('modal') + 1; + z-index: $z-modal-111 + 1; background: $c-bg-high; color: $c-font; border-radius: 6px; diff --git a/ui/common/css/component/_friend-box.scss b/ui/common/css/component/_friend-box.scss index 303efdeba76b7..fe993d6df1a68 100644 --- a/ui/common/css/component/_friend-box.scss +++ b/ui/common/css/component/_friend-box.scss @@ -8,7 +8,7 @@ position: fixed; bottom: 0; @include inline-end(0); - z-index: z('friend-box'); + z-index: $z-friend-box-2; background: $c-bg-popup; border: $border; border-inline-end: 0; diff --git a/ui/common/css/component/_mselect.scss b/ui/common/css/component/_mselect.scss index e9fc66f17f8b5..1a41d794b5ccc 100644 --- a/ui/common/css/component/_mselect.scss +++ b/ui/common/css/component/_mselect.scss @@ -44,7 +44,7 @@ $c-mselect: $c-primary; min-width: 100%; max-height: 60vh; overflow-y: auto; - z-index: z('mselect'); + z-index: $z-mselect-111; background: $c-bg-popup; transform: scale(1, 0); transform-origin: top; diff --git a/ui/common/css/component/_power-tip.scss b/ui/common/css/component/_power-tip.scss index bc14800365541..29066ac33ddc1 100644 --- a/ui/common/css/component/_power-tip.scss +++ b/ui/common/css/component/_power-tip.scss @@ -8,7 +8,7 @@ background: $c-bg-popup; display: none; position: absolute; - z-index: z('powertip'); + z-index: $z-powertip-120; .mini-game__player { @include padding-direction(3px, 0.5em, 0.3em, 0.7em); diff --git a/ui/common/css/component/_reconnecting.scss b/ui/common/css/component/_reconnecting.scss index dee881bf20cbf..15a930ad39300 100644 --- a/ui/common/css/component/_reconnecting.scss +++ b/ui/common/css/component/_reconnecting.scss @@ -25,7 +25,7 @@ $recon-height: 2.5rem; height: $recon-height; padding: 0 1rem; border-top-right-radius: 3px; - z-index: z('network-status'); + z-index: $z-network-status-105; opacity: 0; transform: translateY($recon-height); diff --git a/ui/common/css/component/_subnav.scss b/ui/common/css/component/_subnav.scss index 4d0b792dc52c8..5b05b9267a07c 100644 --- a/ui/common/css/component/_subnav.scss +++ b/ui/common/css/component/_subnav.scss @@ -56,7 +56,7 @@ @include mq-subnav-side { margin-top: 5px; - z-index: z('subnav-side'); + z-index: $z-subnav-side-2; /* active border must go over the page content */ a { diff --git a/ui/common/css/component/_zen-toggle.scss b/ui/common/css/component/_zen-toggle.scss index 9171b9dc94d20..6645e30213d98 100644 --- a/ui/common/css/component/_zen-toggle.scss +++ b/ui/common/css/component/_zen-toggle.scss @@ -3,7 +3,7 @@ display: none; flex-flow: row nowrap; align-items: center; - z-index: z('zen-toggle'); + z-index: $z-zen-toggle-111; body.zenable.zen & { display: flex; diff --git a/ui/common/css/header/_buttons.scss b/ui/common/css/header/_buttons.scss index 0df6d88607981..b3660e62dab63 100644 --- a/ui/common/css/header/_buttons.scss +++ b/ui/common/css/header/_buttons.scss @@ -55,7 +55,7 @@ @include inline-end(0); top: $site-header-height; background: $c-bg-header-dropdown; - z-index: z('dropdown'); + z-index: $z-dropdown-109; a, button { diff --git a/ui/common/css/header/_header.scss b/ui/common/css/header/_header.scss index 5594f5ed03a82..a246b28ed6a96 100644 --- a/ui/common/css/header/_header.scss +++ b/ui/common/css/header/_header.scss @@ -8,7 +8,7 @@ body > header { display: flex; justify-content: space-between; position: relative; - z-index: z('site-header'); + z-index: $z-site-header-106; max-width: 1800px; margin: 0 auto; user-select: none; diff --git a/ui/common/css/header/_topnav-hidden.scss b/ui/common/css/header/_topnav-hidden.scss index a227284c3b0d8..d4c694efc368c 100644 --- a/ui/common/css/header/_topnav-hidden.scss +++ b/ui/common/css/header/_topnav-hidden.scss @@ -13,7 +13,7 @@ width: $site-header-height; height: $site-header-height; cursor: pointer; - z-index: z('topnav'); + z-index: $z-topnav-111; &__in { &, @@ -145,7 +145,7 @@ section { flex: 1 0 50%; margin-top: 1rem; - z-index: z('topnav'); + z-index: $z-topnav-111; > a { font-size: 1.2em; @@ -174,7 +174,7 @@ } .topnav-toggle:checked ~ & { - z-index: z('topnav'); + z-index: $z-topnav-111; transform: translateX(0); a { opacity: 1; diff --git a/ui/common/css/theme/board/_chessground.scss b/ui/common/css/theme/board/_chessground.scss index 2e1ed8c562e28..2691386ed9872 100644 --- a/ui/common/css/theme/board/_chessground.scss +++ b/ui/common/css/theme/board/_chessground.scss @@ -127,21 +127,21 @@ piece { width: 12.5%; height: 12.5%; background-size: cover; - z-index: z('cg__piece'); + z-index: $z-cg__piece-2; will-change: transform; pointer-events: none; &.dragging { cursor: move; - z-index: z('cg__piece.dragging') !important; + z-index: $z-cg__piece_dragging-204 !important; } &.anim { - z-index: z('cg__piece.anim'); + z-index: $z-cg__piece_anim-3; } &.fading { - z-index: z('cg__piece.fading'); + z-index: $z-cg__piece_fading-1; opacity: 0.5; } @@ -173,11 +173,11 @@ cg-auto-pieces { cg-container .cg-shapes { opacity: 0.6; - z-index: z('cg__svg.cg-shapes'); + z-index: $z-cg__svg_cg-shapes-2; } cg-container .cg-custom-svgs { - z-index: z('cg__svg.cg-custom-svgs'); + z-index: $z-cg__svg_cg-custom-svgs-4; } cg-container .cg-shapes { @@ -189,7 +189,7 @@ cg-container .cg-custom-svgs svg { } cg-auto-pieces { - z-index: z('cg__cg-auto-pieces'); + z-index: $z-cg__cg-auto-pieces-2; piece { opacity: 0.3; diff --git a/ui/game/css/_row.scss b/ui/game/css/_row.scss index 81d3b733e41d7..c7fa1ae8c60c7 100644 --- a/ui/game/css/_row.scss +++ b/ui/game/css/_row.scss @@ -89,7 +89,7 @@ a { font-weight: bold; position: relative; - z-index: z('above-link-overlay'); + z-index: $z-above-link-overlay-3; } .anon { diff --git a/ui/lobby/css/app/_hook-chart.scss b/ui/lobby/css/app/_hook-chart.scss index 9f1eafda45a49..78e831b970374 100644 --- a/ui/lobby/css/app/_hook-chart.scss +++ b/ui/lobby/css/app/_hook-chart.scss @@ -77,7 +77,7 @@ display: none; background: $c-bg-box; position: absolute; - z-index: z('powertip'); + z-index: $z-powertip-120; .inner { @extend %flex-column; diff --git a/ui/mod/css/_inquiry.scss b/ui/mod/css/_inquiry.scss index 8d3a1352743f4..894dcf6db0e95 100644 --- a/ui/mod/css/_inquiry.scss +++ b/ui/mod/css/_inquiry.scss @@ -34,7 +34,7 @@ body.no-inquiry { top: 0; left: 0; right: 0; - z-index: z('inquiry'); + z-index: $z-inquiry-112; .costello { flex: 0 0 160px; diff --git a/ui/mod/css/_user.scss b/ui/mod/css/_user.scss index 78757cfc9dffa..a312d662e47d1 100644 --- a/ui/mod/css/_user.scss +++ b/ui/mod/css/_user.scss @@ -136,7 +136,7 @@ position: fixed; bottom: 0; background: $c-brag; - z-index: z('mz-menu'); + z-index: $z-mz-menu-4; // border-top: 1px solid $c-brag; // border-width: 3px 2px 0 2px; diff --git a/ui/round/css/_meta.scss b/ui/round/css/_meta.scss index cb441e3ad9eb9..ae32ae923e614 100644 --- a/ui/round/css/_meta.scss +++ b/ui/round/css/_meta.scss @@ -52,7 +52,7 @@ .bookmark { position: absolute; @include inline-end(0); - z-index: z('game-bookmark'); + z-index: $z-game-bookmark-2; color: $c-font-dim; ::before { diff --git a/ui/tutor/css/_util.scss b/ui/tutor/css/_util.scss index 2b7836022c967..74c33c42f7da2 100644 --- a/ui/tutor/css/_util.scss +++ b/ui/tutor/css/_util.scss @@ -36,7 +36,7 @@ padding: 0.8em 1.5em; width: 300px; position: absolute; - z-index: z('powertip'); + z-index: $z-powertip-120; } } } From 5c40632abfa87669652b982d4fb2b07cba17c5cd Mon Sep 17 00:00:00 2001 From: Ben Rollin Date: Sat, 15 Jun 2024 02:08:09 -0700 Subject: [PATCH 046/168] clear scenario timeouts when switching levels --- ui/learn/src/levelCtrl.ts | 2 ++ 1 file changed, 2 insertions(+) diff --git a/ui/learn/src/levelCtrl.ts b/ui/learn/src/levelCtrl.ts index 3c224242cad48..002c0dea5a800 100644 --- a/ui/learn/src/levelCtrl.ts +++ b/ui/learn/src/levelCtrl.ts @@ -57,6 +57,8 @@ export class LevelCtrl { readonly opts: LevelOpts, readonly redraw: () => void, ) { + timeouts.clearTimeouts(); + this.isAppleLevel = prop(blueprint.apples?.length > 0); this.items = makeItems({ apples: blueprint.apples }); this.chess = makeChess(blueprint.fen, blueprint.emptyApples ? [] : this.items.appleKeys()); From 9cecd70978c0b00191583d1b5aa3cb7bfafb284d Mon Sep 17 00:00:00 2001 From: kraktus Date: Sat, 15 Jun 2024 12:23:15 +0200 Subject: [PATCH 047/168] thinner profile header (back to before profile menu) close https://github.com/lichess-org/lila/issues/15512 --- ui/bits/css/user/_show.scss | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ui/bits/css/user/_show.scss b/ui/bits/css/user/_show.scss index 4520832709804..7970466e5bd08 100644 --- a/ui/bits/css/user/_show.scss +++ b/ui/bits/css/user/_show.scss @@ -34,7 +34,7 @@ .user-actions { flex: 0 0 auto; - margin: 1em 1em 1em 0.3em; + margin: 0 1em 0 0.3em; form { display: inline; From 89710b0d377c12a7766b415673a4c8316d9bf6ff Mon Sep 17 00:00:00 2001 From: kraktus Date: Sat, 15 Jun 2024 12:56:20 +0200 Subject: [PATCH 048/168] Profile, fix dropdown button covering others when screen too narrow --- ui/bits/css/user/_show.scss | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ui/bits/css/user/_show.scss b/ui/bits/css/user/_show.scss index 4520832709804..475e276e3a994 100644 --- a/ui/bits/css/user/_show.scss +++ b/ui/bits/css/user/_show.scss @@ -28,7 +28,7 @@ .number-menu { flex: 0 1 auto; - overflow: hidden; + overflow-x: auto; margin: 0 0 0.2em 1em; } From 84415481c611b8e7a206f3a2f0983f930e785ebf Mon Sep 17 00:00:00 2001 From: Thibault Duplessis Date: Sat, 15 Jun 2024 13:04:37 +0200 Subject: [PATCH 049/168] study search text.take(100) --- app/controllers/Study.scala | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/app/controllers/Study.scala b/app/controllers/Study.scala index 891c315883d64..13d7f269a664c 100644 --- a/app/controllers/Study.scala +++ b/app/controllers/Study.scala @@ -43,7 +43,7 @@ final class Study( yield res else env - .studySearch(ctx.me)(text, page) + .studySearch(ctx.me)(text.take(100), page) .flatMap: pag => negotiate( Ok.page(views.study.list.search(pag, text)), From d842b21e69c489583d85c5a2716ba2cfb27b69ba Mon Sep 17 00:00:00 2001 From: Thibault Duplessis Date: Sat, 15 Jun 2024 13:22:33 +0200 Subject: [PATCH 050/168] monitor broadcast crowds --- modules/common/src/main/mon.scala | 1 + modules/relay/src/main/Env.scala | 2 +- modules/relay/src/main/RelayApi.scala | 5 +++++ modules/relay/src/main/RelayRoundRepo.scala | 13 +++++++++++++ 4 files changed, 20 insertions(+), 1 deletion(-) diff --git a/modules/common/src/main/mon.scala b/modules/common/src/main/mon.scala index ee84be6d53dff..6fcfe9420ec23 100644 --- a/modules/common/src/main/mon.scala +++ b/modules/common/src/main/mon.scala @@ -284,6 +284,7 @@ object mon: def moves(official: Boolean, slug: String) = counter("relay.moves").withTags(relay(official, slug)) def fetchTime(official: Boolean, slug: String) = timer("relay.fetch.time").withTags(relay(official, slug)) def syncTime(official: Boolean, slug: String) = timer("relay.sync.time").withTags(relay(official, slug)) + def tourCrowd(tourId: RelayTourId) = gauge("relay.tour.crowd").withTag("tour", tourId.value) def httpGet(host: String, proxy: Option[String]) = future("relay.http.get", tags("host" -> host, "proxy" -> proxy.getOrElse("none"))) diff --git a/modules/relay/src/main/Env.scala b/modules/relay/src/main/Env.scala index bf3c2415fcdc9..98ddc40f3070f 100644 --- a/modules/relay/src/main/Env.scala +++ b/modules/relay/src/main/Env.scala @@ -122,7 +122,7 @@ final class Env( wire[RelayFetch] scheduler.scheduleWithFixedDelay(1 minute, 1 minute): () => - api.autoStart >> api.autoFinishNotSyncing + api.autoStart >> api.autoFinishNotSyncing >> api.monitorCrowd lila.common.Bus.subscribeFuns( "study" -> { case lila.core.study.RemoveStudy(studyId) => diff --git a/modules/relay/src/main/RelayApi.scala b/modules/relay/src/main/RelayApi.scala index a2a36920842ea..b29b071a4de2b 100644 --- a/modules/relay/src/main/RelayApi.scala +++ b/modules/relay/src/main/RelayApi.scala @@ -408,6 +408,11 @@ final class RelayApi( update(relay)(_.finish) } + private[relay] def monitorCrowd: Funit = + roundRepo.tourCrowds.map: crowds => + crowds.pp.foreach: (tourId, crowd) => + lila.mon.relay.tourCrowd(tourId).update(crowd) + private[relay] def WithRelay[A: Zero](id: RelayRoundId)(f: RelayRound => Fu[A]): Fu[A] = byId(id).flatMapz(f) diff --git a/modules/relay/src/main/RelayRoundRepo.scala b/modules/relay/src/main/RelayRoundRepo.scala index a288e03cbf128..1b8fab34c82f3 100644 --- a/modules/relay/src/main/RelayRoundRepo.scala +++ b/modules/relay/src/main/RelayRoundRepo.scala @@ -49,6 +49,19 @@ final private class RelayRoundRepo(val coll: Coll)(using Executor): def studyIdsOf(tourId: RelayTourId): Fu[List[StudyId]] = coll.distinctEasy[StudyId, List]("_id", selectors.tour(tourId)) + def tourCrowds: Fu[List[(RelayTourId, Int)]] = + coll + .aggregateList(maxDocs = 500, _.sec): framework => + import framework.* + Match($doc("sync.until" -> $exists(true))) -> + List(GroupField("_id")("crowd" -> SumField("crowd"))) + .map: docs => + for + doc <- docs + id <- doc.getAsOpt[RelayTourId]("_id") + crowd <- doc.getAsOpt[Int]("crowd") + yield (id, crowd) + private object RelayRoundRepo: object sort: From 0cc944c9c3c7d5ab6f3c3b3d70b0d80072a97156 Mon Sep 17 00:00:00 2001 From: Thibault Duplessis Date: Sat, 15 Jun 2024 14:20:57 +0200 Subject: [PATCH 051/168] upgrade chart.js --- pnpm-lock.yaml | 31 ++++++++++++++++++++++++------- ui/chart/package.json | 2 +- 2 files changed, 25 insertions(+), 8 deletions(-) diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml index f4e6dc0eceb28..b12793ea45865 100644 --- a/pnpm-lock.yaml +++ b/pnpm-lock.yaml @@ -257,17 +257,17 @@ importers: specifier: workspace:* version: link:../ceval chart.js: - specifier: 4.4.0 - version: 4.4.0 + specifier: 4.4.3 + version: 4.4.3 chartjs-adapter-dayjs-4: specifier: ^1.0.4 - version: 1.0.4(chart.js@4.4.0)(dayjs@1.11.10) + version: 1.0.4(chart.js@4.4.3)(dayjs@1.11.10) chartjs-plugin-datalabels: specifier: ^2.2.0 - version: 2.2.0(chart.js@4.4.0) + version: 2.2.0(chart.js@4.4.3) chartjs-plugin-zoom: specifier: ^2.0.1 - version: 2.0.1(chart.js@4.4.0) + version: 2.0.1(chart.js@4.4.3) common: specifier: workspace:* version: link:../common @@ -1346,6 +1346,10 @@ packages: resolution: {integrity: sha512-vQEj6d+z0dcsKLlQvbKIMYFHd3t8W/7L2vfJIbYcfyPcRx92CsHqECpueN8qVGNlKyDcr5wBrYAYKnfu/9Q1hQ==} engines: {pnpm: '>=7'} + chart.js@4.4.3: + resolution: {integrity: sha512-qK1gkGSRYcJzqrrzdR6a+I0vQ4/R+SoODXyAjscQ/4mzuNzySaMCd+hyVxitSY1+L2fjPD1Gbn+ibNqRmwQeLw==} + engines: {pnpm: '>=8'} + chartjs-adapter-dayjs-4@1.0.4: resolution: {integrity: sha512-yy9BAYW4aNzPVrCWZetbILegTRb7HokhgospPoC3b5iZ5qdlqNmXts2KdSp6AqnjkPAp/YWyHDxLvIvwt5x81w==} engines: {node: '>=10'} @@ -3034,18 +3038,31 @@ snapshots: dependencies: '@kurkle/color': 0.3.2 + chart.js@4.4.3: + dependencies: + '@kurkle/color': 0.3.2 + chartjs-adapter-dayjs-4@1.0.4(chart.js@4.4.0)(dayjs@1.11.10): dependencies: chart.js: 4.4.0 dayjs: 1.11.10 + chartjs-adapter-dayjs-4@1.0.4(chart.js@4.4.3)(dayjs@1.11.10): + dependencies: + chart.js: 4.4.3 + dayjs: 1.11.10 + chartjs-plugin-datalabels@2.2.0(chart.js@4.4.0): dependencies: chart.js: 4.4.0 - chartjs-plugin-zoom@2.0.1(chart.js@4.4.0): + chartjs-plugin-datalabels@2.2.0(chart.js@4.4.3): dependencies: - chart.js: 4.4.0 + chart.js: 4.4.3 + + chartjs-plugin-zoom@2.0.1(chart.js@4.4.3): + dependencies: + chart.js: 4.4.3 hammerjs: 2.0.8 check-error@1.0.3: diff --git a/ui/chart/package.json b/ui/chart/package.json index 4308cd4a6a40b..47c82da99ac7f 100644 --- a/ui/chart/package.json +++ b/ui/chart/package.json @@ -11,7 +11,7 @@ "dependencies": { "@juggle/resize-observer": "^3.4.0", "ceval": "workspace:*", - "chart.js": "4.4.0", + "chart.js": "4.4.3", "chartjs-adapter-dayjs-4": "^1.0.4", "chartjs-plugin-datalabels": "^2.2.0", "chartjs-plugin-zoom": "^2.0.1", From cffbbca3d5a028616d17ef68702e52d9b3657c4b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?S=C3=A9rgio=20Gl=C3=B3rias?= <9739913+SergioGlorias@users.noreply.github.com> Date: Sat, 15 Jun 2024 13:55:35 +0100 Subject: [PATCH 052/168] Reduce caliente --- public/piece-css/caliente.css | 24 +-- public/piece/caliente/bB.svg | 206 +------------------------- public/piece/caliente/bK.svg | 232 +---------------------------- public/piece/caliente/bN.svg | 167 +-------------------- public/piece/caliente/bP.svg | 144 +----------------- public/piece/caliente/bQ.svg | 267 +--------------------------------- public/piece/caliente/bR.svg | 227 +---------------------------- public/piece/caliente/wB.svg | 199 +------------------------ public/piece/caliente/wK.svg | 226 +--------------------------- public/piece/caliente/wN.svg | 157 +------------------- public/piece/caliente/wP.svg | 139 +----------------- public/piece/caliente/wQ.svg | 261 +-------------------------------- public/piece/caliente/wR.svg | 218 +-------------------------- 13 files changed, 24 insertions(+), 2443 deletions(-) diff --git a/public/piece-css/caliente.css b/public/piece-css/caliente.css index f684f5f5340b9..a6850e5b72754 100644 --- a/public/piece-css/caliente.css +++ b/public/piece-css/caliente.css @@ -1,12 +1,12 @@ -.is2d .pawn.white {background-image:url('data:image/svg+xml;base64,<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<!-- Created with Inkscape (http://www.inkscape.org/) -->

<svg
   width="64"
   height="64"
   viewBox="0 0 16.933331 16.933331"
   version="1.1"
   id="svg5"
   xmlns:xlink="http://www.w3.org/1999/xlink"
   xmlns="http://www.w3.org/2000/svg"
   xmlns:svg="http://www.w3.org/2000/svg"
   xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
   xmlns:cc="http://creativecommons.org/ns#">
  <defs
     id="defs2">
    <linearGradient
       id="wood_black_accent">
      <stop
         style="stop-color:#ba845f;stop-opacity:1;"
         offset="0"
         id="stop5970" />
    </linearGradient>
    <linearGradient
       id="wood_black_fill">
      <stop
         style="stop-color:#995e33;stop-opacity:1;"
         offset="0"
         id="stop5940" />
    </linearGradient>
    <linearGradient
       id="wood_white_shade">
      <stop
         style="stop-color:#d0b793;stop-opacity:1;"
         offset="0"
         id="stop3347" />
    </linearGradient>
    <linearGradient
       id="wood_white_fill">
      <stop
         style="stop-color:#f9e7d2;stop-opacity:1;"
         offset="0"
         id="stop3028" />
    </linearGradient>
    <linearGradient
       id="white_fill">
      <stop
         style="stop-color:#ffffff;stop-opacity:1;"
         offset="0"
         id="stop2367" />
    </linearGradient>
    <linearGradient
       id="white_shade"
       gradientTransform="translate(-5.8013919e-8,2.1166665)">
      <stop
         style="stop-color:#cccccc;stop-opacity:1;"
         offset="0"
         id="stop45894" />
    </linearGradient>
    <linearGradient
       id="linearGradient45642">
      <stop
         style="stop-color:#000000;stop-opacity:0.2;"
         offset="0"
         id="stop45640" />
    </linearGradient>
    <linearGradient
       id="black_accent"
       gradientTransform="scale(0.07000432)">
      <stop
         style="stop-color:#8c8c8c;stop-opacity:1;"
         offset="0"
         id="stop52163" />
    </linearGradient>
    <linearGradient
       id="black_fill"
       gradientTransform="matrix(0.07000432,0,0,0.07000432,-53.975025,2.1166665)">
      <stop
         style="stop-color:#595959;stop-opacity:1;"
         offset="0"
         id="stop51990" />
    </linearGradient>
    <linearGradient
       xlink:href="#linearGradient45642"
       id="linearGradient174041"
       x1="4.2333326"
       y1="24.341663"
       x2="103.04872"
       y2="24.341663"
       gradientUnits="userSpaceOnUse"
       gradientTransform="matrix(1,0,0,1.25,0.79374989,-3.0427069)" />
    <linearGradient
       xlink:href="#white_fill"
       id="linearGradient2407"
       x1="4.7624993"
       y1="9.5249987"
       x2="12.170832"
       y2="9.5249987"
       gradientUnits="userSpaceOnUse" />
    <linearGradient
       xlink:href="#white_shade"
       id="linearGradient4110"
       gradientTransform="translate(-5.8013919e-8,2.1166665)"
       gradientUnits="userSpaceOnUse" />
  </defs>
  <metadata
     id="metadata505">
    <rdf:RDF>
      <cc:Work
         rdf:about="" />
    </rdf:RDF>
  </metadata>
  <g
     id="layer6">
    <path
       style="font-variation-settings:normal;opacity:1;vector-effect:none;fill:url(#linearGradient174041);fill-opacity:1;stroke:none;stroke-width:1.25861;stroke-linecap:round;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;-inkscape-stroke:none;stop-color:#000000;stop-opacity:1"
       d="m 5.0270826,14.816665 c 0,0.992188 2.645833,1.322916 4.2333328,1.322916 1.5874976,0 4.2333306,-0.330728 4.2333306,-1.322916 0,-0.992187 -2.778792,-1.322916 -4.2333306,-1.322916 -1.4545399,0 -4.2333328,0.330729 -4.2333328,1.322916 z"
       id="path104271"
       class="UnoptimicedTransforms"
       transform="matrix(1.0937503,0,0,0.99999995,-1.2650402,9.6337469e-7)" />
    <g
       id="g62410-9"
       style="display:inline;opacity:1">
      <path
         style="display:inline;opacity:1;fill:url(#linearGradient2407);fill-opacity:1;stroke:none;stroke-width:1.05833;stroke-linecap:round;stroke-linejoin:round;stroke-dasharray:none;stroke-opacity:1"
         d="m 4.7624993,14.287498 c 1.5874998,0.529167 3.7041663,0.529167 3.7041663,0.529167 0,0 2.1166664,0 3.7041664,-0.529167 0,-2.116666 -0.79375,-2.645833 -2.38125,-4.233333 1.5875,-1.5874995 0.79375,-2.6458327 -0.2645833,-3.7041659 0.7937503,-0.7937499 0,-2.1166663 -1.0583332,-2.1166663 -1.0583332,0 -1.8520831,1.3229164 -1.0583332,2.1166663 -1.0583332,1.0583332 -1.8520831,2.1166664 -0.2645833,3.7041659 -1.5874998,1.5875 -2.3812497,2.116667 -2.3812497,4.233333 z"
         id="path71447-1" />
      <path
         style="display:inline;fill:url(#linearGradient4110);fill-opacity:1;stroke:none;stroke-width:0.79375;stroke-linejoin:round"
         d="m 12.170833,14.287498 -1.852084,0.529167 c 0,-0.835948 -0.247609,-1.630627 -0.5309499,-2.335143 C 9.353705,11.402163 8.8357422,10.534435 8.9958322,10.054165 9.2604156,9.2604154 9.2604155,8.9958321 9.2604155,8.4666655 c 0,-1.0583332 -0.7937499,-1.3229165 -0.5291666,-2.1166664 0.2645833,-0.7937499 0,-1.5874998 -0.7937499,-1.8520831 1.3229165,-0.5291666 1.6436342,1.3657023 1.8520831,1.8520831 0.3385889,0.7900413 1.0583339,2.3812497 0,3.7041659 1.8520839,1.5875 2.3812509,3.721739 2.3812509,4.233333 z"
         id="path71538-8" />
      <path
         style="display:inline;opacity:1;fill:none;fill-opacity:1;stroke:#000000;stroke-width:1.05833;stroke-linecap:round;stroke-linejoin:round;stroke-dasharray:none;stroke-opacity:1"
         d="m 4.7624993,14.287498 c 1.5874998,0.529167 3.7041663,0.529167 3.7041663,0.529167 0,0 2.1166664,0 3.7041664,-0.529167 0,-2.116666 -0.79375,-2.645833 -2.38125,-4.233333 1.5875,-1.5874995 0.79375,-2.6458327 -0.2645833,-3.7041659 0.7937503,-0.7937499 0,-2.1166663 -1.0583332,-2.1166663 -1.0583332,0 -1.8520831,1.3229164 -1.0583332,2.1166663 -1.0583332,1.0583332 -1.8520831,2.1166664 -0.2645833,3.7041659 -1.5874998,1.5875 -2.3812497,2.116667 -2.3812497,4.233333 z"
         id="path64922-9" />
    </g>
  </g>
</svg>
')} -.is2d .knight.white {background-image:url('data:image/svg+xml;base64,<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<!-- Created with Inkscape (http://www.inkscape.org/) -->

<svg
   width="63.999992"
   height="63.999996"
   viewBox="0 0 16.933329 16.93333"
   version="1.1"
   id="svg5"
   xmlns:xlink="http://www.w3.org/1999/xlink"
   xmlns="http://www.w3.org/2000/svg"
   xmlns:svg="http://www.w3.org/2000/svg"
   xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
   xmlns:cc="http://creativecommons.org/ns#">
  <defs
     id="defs2">
    <linearGradient
       id="wood_black_accent">
      <stop
         style="stop-color:#ba845f;stop-opacity:1;"
         offset="0"
         id="stop5970" />
    </linearGradient>
    <linearGradient
       id="wood_black_fill">
      <stop
         style="stop-color:#995e33;stop-opacity:1;"
         offset="0"
         id="stop5940" />
    </linearGradient>
    <linearGradient
       id="wood_white_shade">
      <stop
         style="stop-color:#d0b793;stop-opacity:1;"
         offset="0"
         id="stop3347" />
    </linearGradient>
    <linearGradient
       id="wood_white_fill">
      <stop
         style="stop-color:#f9e7d2;stop-opacity:1;"
         offset="0"
         id="stop3028" />
    </linearGradient>
    <linearGradient
       id="white_fill">
      <stop
         style="stop-color:#ffffff;stop-opacity:1;"
         offset="0"
         id="stop2367" />
    </linearGradient>
    <linearGradient
       id="white_shade"
       gradientTransform="translate(-5.8013919e-8,2.1166665)">
      <stop
         style="stop-color:#cccccc;stop-opacity:1;"
         offset="0"
         id="stop45894" />
    </linearGradient>
    <linearGradient
       id="linearGradient45642">
      <stop
         style="stop-color:#000000;stop-opacity:0.2;"
         offset="0"
         id="stop45640" />
    </linearGradient>
    <linearGradient
       id="black_accent"
       gradientTransform="scale(0.07000432)">
      <stop
         style="stop-color:#8c8c8c;stop-opacity:1;"
         offset="0"
         id="stop52163" />
    </linearGradient>
    <linearGradient
       id="black_fill"
       gradientTransform="matrix(0.07000432,0,0,0.07000432,-53.975025,2.1166665)">
      <stop
         style="stop-color:#595959;stop-opacity:1;"
         offset="0"
         id="stop51990" />
    </linearGradient>
    <linearGradient
       xlink:href="#white_fill"
       id="linearGradient2405"
       x1="4.0848351"
       y1="8.8635406"
       x2="13.229165"
       y2="8.8635406"
       gradientUnits="userSpaceOnUse" />
    <linearGradient
       xlink:href="#white_shade"
       id="linearGradient4108"
       gradientTransform="translate(-5.8013927e-8,2.1166665)"
       gradientUnits="userSpaceOnUse" />
    <linearGradient
       xlink:href="#linearGradient45642"
       id="linearGradient26986"
       gradientUnits="userSpaceOnUse"
       gradientTransform="matrix(1,0,0,1.25,0.79374989,-3.0427069)"
       x1="4.2333326"
       y1="24.341663"
       x2="103.04872"
       y2="24.341663" />
  </defs>
  <metadata
     id="metadata505">
    <rdf:RDF>
      <cc:Work
         rdf:about="" />
    </rdf:RDF>
  </metadata>
  <g
     id="layer6"
     transform="translate(-17.991667)">
    <path
       style="font-variation-settings:normal;vector-effect:none;fill:url(#linearGradient26986);fill-opacity:1;stroke:none;stroke-width:1.25861;stroke-linecap:round;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;-inkscape-stroke:none;stop-color:#000000"
       d="m 5.0270826,14.816665 c 0,0.992188 2.645833,1.322916 4.2333328,1.322916 1.5874976,0 4.2333306,-0.330728 4.2333306,-1.322916 0,-0.992187 -2.778792,-1.322916 -4.2333306,-1.322916 -1.4545399,0 -4.2333328,0.330729 -4.2333328,1.322916 z"
       id="use175060"
       class="UnoptimicedTransforms"
       transform="matrix(1.0937503,0,0,0.99999995,16.726624,9.6337469e-7)" />
    <g
       id="g62410"
       style="display:inline;opacity:1"
       transform="translate(17.99167)">
      <path
         style="display:inline;opacity:1;fill:url(#linearGradient2405);fill-opacity:1;stroke:none;stroke-width:1.05833;stroke-linecap:round;stroke-linejoin:round;stroke-dasharray:none;stroke-opacity:1"
         d="m 4.7624993,14.287498 c 1.5874998,0.529167 3.7041663,0.529167 3.7041663,0.529167 0,0 2.1166664,0 3.7041664,-0.529167 -0.79375,-2.38125 1.058333,-3.968749 1.058333,-6.3499991 0,-3.9687494 -4.7624995,-5.0270826 -4.7624995,-5.0270826 v 1.3229164 c 0,0 -3.9687496,2.9104163 -4.2333328,3.1749996 -0.2645832,0.2645833 -0.1183253,0.5570994 0,0.7937499 0.2645833,0.5291666 0.5291666,0.7937499 0.7937499,1.0583332 0.2645833,0.2645833 0.5291666,0.2645833 0.7937499,0 0.2645833,-0.2645833 0.7937499,-0.5291666 1.0583332,-0.5291666 0.2645833,0 1.0583332,0.2645833 1.3229165,0.2645833 0.2645833,0 1.3229165,-0.2645833 1.8520828,-0.7937499 C 8.7312488,9.5249987 7.9374989,9.5249987 7.143749,10.054165 6.3499991,10.583332 4.7624993,12.170832 4.7624993,14.287498 Z"
         id="path59942" />
      <path
         style="font-variation-settings:normal;display:inline;opacity:1;vector-effect:none;fill:url(#linearGradient4108);fill-opacity:1;stroke:none;stroke-width:1.05833;stroke-linecap:butt;stroke-linejoin:round;stroke-miterlimit:2.4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;-inkscape-stroke:none;stop-color:#000000;stop-opacity:1"
         d="m -6.0854366,12.699998 0.2645826,1.5875 -2.3812468,0.529167 c -0.5291664,-3.968749 2.9104162,-4.233333 2.9104162,-6.8791661 0.7937499,0.7937499 -0.793752,4.7624991 -0.793752,4.7624991 z"
         id="path12697"
         transform="translate(17.991677)" />
      <path
         style="display:none;fill:#d9d9d9;fill-opacity:1;stroke:none;stroke-width:0.264583;stroke-linecap:butt;stroke-opacity:1"
         d="m 6.8791599,8.2020822 c 1.5874998,0 1.5874998,-0.5291666 3.1749991,-0.5291666 L 8.731243,8.9958321"
         id="path12788" />
      <path
         style="display:inline;opacity:1;fill:none;fill-opacity:1;stroke:#000000;stroke-width:1.05833;stroke-linecap:round;stroke-linejoin:round;stroke-dasharray:none;stroke-opacity:1"
         d="m 4.7624993,14.287498 c 1.5874998,0.529167 3.7041663,0.529167 3.7041663,0.529167 0,0 2.1166664,0 3.7041664,-0.529167 -0.79375,-2.38125 1.058333,-3.968749 1.058333,-6.3499991 0,-3.9687494 -4.7624995,-5.0270826 -4.7624995,-5.0270826 v 1.3229164 c 0,0 -3.9687496,2.9104163 -4.2333328,3.1749996 -0.2645832,0.2645833 -0.1183253,0.5570994 0,0.7937499 0.2645833,0.5291666 0.5291666,0.7937499 0.7937499,1.0583332 0.2645833,0.2645833 0.5291666,0.2645833 0.7937499,0 0.2645833,-0.2645833 0.7937499,-0.5291666 1.0583332,-0.5291666 0.2645833,0 1.0583332,0.2645833 1.3229165,0.2645833 0.2645833,0 1.3229165,-0.2645833 1.8520828,-0.7937499 C 8.7312488,9.5249987 7.9374989,9.5249987 7.143749,10.054165 6.3499991,10.583332 4.7624993,12.170832 4.7624993,14.287498 Z"
         id="path64922" />
      <ellipse
         style="display:inline;opacity:1;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1.05833;stroke-linecap:round;stroke-linejoin:round;stroke-dasharray:none;stroke-opacity:1"
         id="path63964"
         cy="6.0854158"
         cx="8.7312489"
         ry="0.52916658"
         rx="0.52916664" />
      <path
         style="display:inline;opacity:1;fill:none;fill-opacity:1;stroke:#000000;stroke-width:1.05833;stroke-linecap:butt;stroke-linejoin:round;stroke-dasharray:none;stroke-opacity:1"
         d="m 11.906243,12.699998 c -1.322916,0.529167 -3.4395775,0.529167 -3.4395775,0.529167 0,0 -2.1166722,0 -3.4395887,-0.529167"
         id="path65119" />
    </g>
  </g>
</svg>
')} -.is2d .bishop.white {background-image:url('data:image/svg+xml;base64,<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<!-- Created with Inkscape (http://www.inkscape.org/) -->

<svg
   width="63.999985"
   height="64"
   viewBox="0 0 16.933327 16.933331"
   version="1.1"
   id="svg5"
   xmlns:xlink="http://www.w3.org/1999/xlink"
   xmlns="http://www.w3.org/2000/svg"
   xmlns:svg="http://www.w3.org/2000/svg"
   xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
   xmlns:cc="http://creativecommons.org/ns#">
  <defs
     id="defs2">
    <linearGradient
       id="wood_black_accent">
      <stop
         style="stop-color:#ba845f;stop-opacity:1;"
         offset="0"
         id="stop5970" />
    </linearGradient>
    <linearGradient
       id="wood_black_fill">
      <stop
         style="stop-color:#995e33;stop-opacity:1;"
         offset="0"
         id="stop5940" />
    </linearGradient>
    <linearGradient
       id="wood_white_shade">
      <stop
         style="stop-color:#d0b793;stop-opacity:1;"
         offset="0"
         id="stop3347" />
    </linearGradient>
    <linearGradient
       id="wood_white_fill">
      <stop
         style="stop-color:#f9e7d2;stop-opacity:1;"
         offset="0"
         id="stop3028" />
    </linearGradient>
    <linearGradient
       id="white_fill">
      <stop
         style="stop-color:#ffffff;stop-opacity:1;"
         offset="0"
         id="stop2367" />
    </linearGradient>
    <linearGradient
       id="white_shade"
       gradientTransform="translate(-5.8013919e-8,2.1166665)">
      <stop
         style="stop-color:#cccccc;stop-opacity:1;"
         offset="0"
         id="stop45894" />
    </linearGradient>
    <linearGradient
       id="linearGradient45642">
      <stop
         style="stop-color:#000000;stop-opacity:0.2;"
         offset="0"
         id="stop45640" />
    </linearGradient>
    <linearGradient
       id="black_accent"
       gradientTransform="scale(0.07000432)">
      <stop
         style="stop-color:#8c8c8c;stop-opacity:1;"
         offset="0"
         id="stop52163" />
    </linearGradient>
    <linearGradient
       id="black_fill"
       gradientTransform="matrix(0.07000432,0,0,0.07000432,-53.975025,2.1166665)">
      <stop
         style="stop-color:#595959;stop-opacity:1;"
         offset="0"
         id="stop51990" />
    </linearGradient>
    <linearGradient
       xlink:href="#white_fill"
       id="linearGradient2399"
       x1="6.8791485"
       y1="2.9104161"
       x2="10.054144"
       y2="2.9104161"
       gradientUnits="userSpaceOnUse" />
    <linearGradient
       xlink:href="#white_fill"
       id="linearGradient2401"
       x1="4.7624993"
       y1="13.758332"
       x2="12.170832"
       y2="13.758332"
       gradientUnits="userSpaceOnUse" />
    <linearGradient
       xlink:href="#white_fill"
       id="linearGradient2403"
       x1="40.76622"
       y1="8.2020826"
       x2="48.133766"
       y2="8.2020826"
       gradientUnits="userSpaceOnUse" />
    <linearGradient
       xlink:href="#white_shade"
       id="linearGradient4104"
       gradientTransform="translate(-5.8013919e-8,2.1166665)"
       gradientUnits="userSpaceOnUse" />
    <linearGradient
       xlink:href="#white_shade"
       id="linearGradient4106"
       gradientTransform="translate(-5.8013919e-8,2.1166665)"
       gradientUnits="userSpaceOnUse" />
    <linearGradient
       xlink:href="#linearGradient45642"
       id="linearGradient28409"
       gradientUnits="userSpaceOnUse"
       gradientTransform="matrix(1,0,0,1.25,0.79374989,-3.0427069)"
       x1="4.2333326"
       y1="24.341663"
       x2="103.04872"
       y2="24.341663" />
  </defs>
  <metadata
     id="metadata505">
    <rdf:RDF>
      <cc:Work
         rdf:about="" />
    </rdf:RDF>
  </metadata>
  <g
     id="layer6"
     transform="translate(-35.98333)">
    <path
       style="font-variation-settings:normal;vector-effect:none;fill:url(#linearGradient28409);fill-opacity:1;stroke:none;stroke-width:1.25861;stroke-linecap:round;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;-inkscape-stroke:none;stop-color:#000000"
       d="m 5.0270826,14.816665 c 0,0.992188 2.645833,1.322916 4.2333328,1.322916 1.5874976,0 4.2333306,-0.330728 4.2333306,-1.322916 0,-0.992187 -2.778792,-1.322916 -4.2333306,-1.322916 -1.4545399,0 -4.2333328,0.330729 -4.2333328,1.322916 z"
       id="use175064"
       class="UnoptimicedTransforms"
       transform="matrix(1.0937503,0,0,0.99999995,34.718289,9.6337469e-7)" />
    <g
       id="g127818"
       style="display:inline"
       transform="translate(35.983347)">
      <path
         style="font-variation-settings:normal;display:inline;opacity:1;vector-effect:none;fill:url(#linearGradient2403);fill-opacity:1;stroke:none;stroke-width:1.05833;stroke-linecap:butt;stroke-linejoin:round;stroke-miterlimit:2.4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;-inkscape-stroke:none;stop-color:#000000;stop-opacity:1"
         d="m 42.333328,12.964582 c -4.497917,-5.5562497 2.116666,-9.5249991 2.116666,-9.5249991 0,0 6.614582,3.9687494 2.116667,9.5249991"
         id="path129343"
         transform="translate(-35.983347)" />
      <path
         style="font-variation-settings:normal;display:inline;opacity:1;vector-effect:none;fill:url(#linearGradient4106);fill-opacity:1;stroke:none;stroke-width:1.05833;stroke-linecap:butt;stroke-linejoin:round;stroke-miterlimit:2.4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;-inkscape-stroke:none;stop-color:#000000;stop-opacity:1"
         d="M 8.2020638,4.2333325 C 10.31873,5.0270826 11.906231,10.847915 7.9374808,13.229165 L 10.583314,12.964582 C 14.816647,8.4666648 11.11248,4.4979155 8.4666468,3.9687495 Z"
         id="path127802" />
      <path
         style="font-variation-settings:normal;opacity:1;vector-effect:none;fill:none;fill-opacity:1;stroke:#000000;stroke-width:1.05833;stroke-linecap:butt;stroke-linejoin:round;stroke-miterlimit:2.4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;-inkscape-stroke:none;stop-color:#000000;stop-opacity:1"
         d="m 42.333328,12.964582 c -4.497917,-6.0854163 2.116666,-8.9958325 2.116666,-8.9958325 0,0 6.614582,2.9104162 2.116667,8.9958325"
         id="path127804"
         transform="translate(-35.983347)" />
      <path
         style="display:inline;opacity:1;fill:url(#linearGradient2401);fill-opacity:1;stroke:none;stroke-width:1.05833;stroke-linecap:round;stroke-linejoin:round;stroke-dasharray:none;stroke-opacity:1"
         d="m 5.027064,12.699998 c 0,0 -0.2645833,0.529167 -0.2645647,1.5875 1.5874998,0.529167 3.7041663,0.529167 3.7041663,0.529167 0,0 2.1166664,0 3.7041664,-0.529167 -1.9e-5,-1.058333 -0.264602,-1.5875 -0.264602,-1.5875 -1.322917,0.529167 -3.4395831,0.529167 -3.4395831,0.529167 0,0 -2.1166664,0 -3.4395829,-0.529167 z"
         id="path127806" />
      <path
         style="font-variation-settings:normal;opacity:1;vector-effect:none;fill:url(#linearGradient4104);fill-opacity:1;stroke:none;stroke-width:1.05833;stroke-linecap:butt;stroke-linejoin:round;stroke-miterlimit:2.4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;-inkscape-stroke:none;stop-color:#000000;stop-opacity:1"
         d="m 11.906229,12.699998 0.264583,1.5875 -1.852082,0.264583 -0.264583,-1.322916 1.852082,-0.529167"
         id="path127808" />
      <path
         style="display:inline;opacity:1;fill:none;fill-opacity:1;stroke:#000000;stroke-width:1.05833;stroke-linecap:round;stroke-linejoin:round;stroke-dasharray:none;stroke-opacity:1"
         d="m 5.027064,12.699998 c 0,0 -0.2645833,0.529167 -0.2645647,1.5875 1.5874998,0.529167 3.7041663,0.529167 3.7041663,0.529167 0,0 2.1166664,0 3.7041664,-0.529167 -1.9e-5,-1.058333 -0.264602,-1.5875 -0.264602,-1.5875 -1.322917,0.529167 -3.4395831,0.529167 -3.4395831,0.529167 0,0 -2.1166664,0 -3.4395829,-0.529167 z"
         id="path127810" />
      <ellipse
         style="font-variation-settings:normal;opacity:1;vector-effect:none;fill:url(#linearGradient2399);fill-opacity:1;stroke:#000000;stroke-width:1.05833;stroke-linecap:butt;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;-inkscape-stroke:none;stop-color:#000000;stop-opacity:1"
         id="ellipse127816"
         cx="8.4666462"
         cy="2.9104161"
         rx="1.0583324"
         ry="1.0583333" />
      <path
         style="font-variation-settings:normal;opacity:1;fill:none;fill-opacity:1;stroke:#000000;stroke-width:1.05833;stroke-linecap:round;stroke-linejoin:round;stroke-miterlimit:2.4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;stop-color:#000000;stop-opacity:1"
         d="m 8.4666469,3.9687495 c 3.1749991,1.5874997 1.0583332,3.7041661 0,4.7624993"
         id="path128615" />
    </g>
  </g>
  <g
     id="layer5"
     style="display:none"
     transform="translate(-35.98333)">
    <ellipse
       style="display:inline;opacity:1;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1.05833;stroke-linecap:round;stroke-linejoin:round;stroke-dasharray:none;stroke-opacity:1"
       id="path63964-3"
       cy="6.349999"
       cx="43.920826"
       ry="0.52916658"
       rx="0.52916664" />
  </g>
</svg>
')} -.is2d .rook.white {background-image:url('data:image/svg+xml;base64,<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<!-- Created with Inkscape (http://www.inkscape.org/) -->

<svg
   width="64"
   height="63.999996"
   viewBox="0 0 16.933331 16.93333"
   version="1.1"
   id="svg5"
   xmlns:xlink="http://www.w3.org/1999/xlink"
   xmlns="http://www.w3.org/2000/svg"
   xmlns:svg="http://www.w3.org/2000/svg"
   xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
   xmlns:cc="http://creativecommons.org/ns#">
  <defs
     id="defs2">
    <linearGradient
       id="wood_black_accent">
      <stop
         style="stop-color:#ba845f;stop-opacity:1;"
         offset="0"
         id="stop5970" />
    </linearGradient>
    <linearGradient
       id="wood_black_fill">
      <stop
         style="stop-color:#995e33;stop-opacity:1;"
         offset="0"
         id="stop5940" />
    </linearGradient>
    <linearGradient
       id="wood_white_shade">
      <stop
         style="stop-color:#d0b793;stop-opacity:1;"
         offset="0"
         id="stop3347" />
    </linearGradient>
    <linearGradient
       id="wood_white_fill">
      <stop
         style="stop-color:#f9e7d2;stop-opacity:1;"
         offset="0"
         id="stop3028" />
    </linearGradient>
    <linearGradient
       id="white_fill">
      <stop
         style="stop-color:#ffffff;stop-opacity:1;"
         offset="0"
         id="stop2367" />
    </linearGradient>
    <linearGradient
       id="white_shade"
       gradientTransform="translate(-5.8013919e-8,2.1166665)">
      <stop
         style="stop-color:#cccccc;stop-opacity:1;"
         offset="0"
         id="stop45894" />
    </linearGradient>
    <linearGradient
       id="linearGradient45642">
      <stop
         style="stop-color:#000000;stop-opacity:0.2;"
         offset="0"
         id="stop45640" />
    </linearGradient>
    <linearGradient
       id="black_accent"
       gradientTransform="scale(0.07000432)">
      <stop
         style="stop-color:#8c8c8c;stop-opacity:1;"
         offset="0"
         id="stop52163" />
    </linearGradient>
    <linearGradient
       id="black_fill"
       gradientTransform="matrix(0.07000432,0,0,0.07000432,-53.975025,2.1166665)">
      <stop
         style="stop-color:#595959;stop-opacity:1;"
         offset="0"
         id="stop51990" />
    </linearGradient>
    <linearGradient
       xlink:href="#white_fill"
       id="linearGradient2393"
       x1="4.4978838"
       y1="5.8061337"
       x2="12.435383"
       y2="5.8061337"
       gradientUnits="userSpaceOnUse" />
    <linearGradient
       xlink:href="#white_fill"
       id="linearGradient2395"
       x1="4.2333326"
       y1="13.758332"
       x2="12.699999"
       y2="13.758332"
       gradientUnits="userSpaceOnUse" />
    <linearGradient
       xlink:href="#white_fill"
       id="linearGradient2397"
       x1="41.274979"
       y1="9.7895823"
       x2="47.624981"
       y2="9.7895823"
       gradientUnits="userSpaceOnUse" />
    <linearGradient
       xlink:href="#white_shade"
       id="linearGradient4098"
       gradientTransform="translate(-5.8013919e-8,2.1166665)"
       gradientUnits="userSpaceOnUse" />
    <linearGradient
       xlink:href="#white_shade"
       id="linearGradient4100"
       gradientTransform="translate(-5.8013919e-8,2.1166665)"
       gradientUnits="userSpaceOnUse" />
    <linearGradient
       xlink:href="#white_shade"
       id="linearGradient4102"
       gradientTransform="translate(-5.8013919e-8,2.1166665)"
       gradientUnits="userSpaceOnUse" />
    <linearGradient
       xlink:href="#linearGradient45642"
       id="linearGradient21284"
       gradientUnits="userSpaceOnUse"
       gradientTransform="matrix(1,0,0,1.25,0.79374989,-3.0427069)"
       x1="4.2333326"
       y1="24.341663"
       x2="103.04872"
       y2="24.341663" />
  </defs>
  <metadata
     id="metadata505">
    <rdf:RDF>
      <cc:Work
         rdf:about="" />
    </rdf:RDF>
  </metadata>
  <g
     id="layer6"
     transform="translate(-53.974995)">
    <path
       style="font-variation-settings:normal;vector-effect:none;fill:url(#linearGradient21284);fill-opacity:1;stroke:none;stroke-width:1.25861;stroke-linecap:round;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;-inkscape-stroke:none;stop-color:#000000"
       d="m 5.0270826,14.816665 c 0,0.992188 2.645833,1.322916 4.2333328,1.322916 1.5874976,0 4.2333306,-0.330728 4.2333306,-1.322916 0,-0.992187 -2.778792,-1.322916 -4.2333306,-1.322916 -1.4545399,0 -4.2333328,0.330729 -4.2333328,1.322916 z"
       id="use60224"
       class="UnoptimicedTransforms"
       transform="matrix(1.215278,0,0,0.99999995,51.569856,9.6337469e-7)" />
    <g
       id="g20504"
       style="display:inline"
       transform="translate(53.975025)">
      <path
         style="font-variation-settings:normal;display:inline;opacity:1;vector-effect:none;fill:url(#linearGradient2397);fill-opacity:1;stroke:none;stroke-width:1.05833;stroke-linecap:butt;stroke-linejoin:round;stroke-miterlimit:2.4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;-inkscape-stroke:none;stop-color:#000000;stop-opacity:1"
         d="m 41.27498,12.964582 0.529167,-6.3499996 h 5.291666 l 0.529167,6.3499996"
         id="path20620"
         transform="translate(-35.983347)" />
      <path
         style="font-variation-settings:normal;display:inline;opacity:1;vector-effect:none;fill:url(#linearGradient4102);fill-opacity:1;stroke:none;stroke-width:1.05833;stroke-linecap:butt;stroke-linejoin:round;stroke-miterlimit:2.4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;-inkscape-stroke:none;stop-color:#000000;stop-opacity:1"
         d="m 9.5249662,6.8791657 0.5291668,6.3499993 1.5875,-0.264583 -0.529167,-6.3499996 z"
         id="path20490" />
      <path
         style="font-variation-settings:normal;display:inline;opacity:1;vector-effect:none;fill:none;fill-opacity:1;stroke:#000000;stroke-width:1.05833;stroke-linecap:butt;stroke-linejoin:round;stroke-miterlimit:2.4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;-inkscape-stroke:none;stop-color:#000000;stop-opacity:1"
         d="m 41.27498,12.699998 0.529167,-5.0270824 m 5.291666,0 0.529167,5.0270824"
         id="path20492"
         transform="translate(-35.983347)" />
      <path
         style="display:inline;opacity:1;fill:url(#linearGradient2395);fill-opacity:1;stroke:none;stroke-width:1.05833;stroke-linecap:round;stroke-linejoin:round;stroke-dasharray:none;stroke-opacity:1"
         d="m 4.4978974,12.699998 c 0,0 -0.2645833,0.529167 -0.2645647,1.5875 1.5874998,0.529167 4.2333329,0.529167 4.2333329,0.529167 0,0 2.6458334,0 4.2333334,-0.529167 -1.9e-5,-1.058333 -0.264602,-1.5875 -0.264602,-1.5875 -1.322917,0.529167 -3.9687501,0.529167 -3.9687501,0.529167 0,0 -2.645833,0 -3.9687495,-0.529167 z"
         id="path20494" />
      <path
         style="font-variation-settings:normal;display:inline;opacity:1;vector-effect:none;fill:url(#linearGradient4100);fill-opacity:1;stroke:none;stroke-width:1.05833;stroke-linecap:butt;stroke-linejoin:round;stroke-miterlimit:2.4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;-inkscape-stroke:none;stop-color:#000000;stop-opacity:1"
         d="m 12.435396,12.699998 0.264583,1.5875 -1.852082,0.264583 -0.264583,-1.322916 1.852082,-0.529167"
         id="path20496" />
      <path
         style="display:inline;opacity:1;fill:none;fill-opacity:1;stroke:#000000;stroke-width:1.05833;stroke-linecap:round;stroke-linejoin:round;stroke-dasharray:none;stroke-opacity:1"
         d="m 4.4978974,12.699998 c 0,0 -0.2645833,0.529167 -0.2645647,1.5875 1.5874998,0.529167 4.2333329,0.529167 4.2333329,0.529167 0,0 2.6458334,0 4.2333334,-0.529167 -1.9e-5,-1.058333 -0.264602,-1.5875 -0.264602,-1.5875 -1.322917,0.529167 -3.9687501,0.529167 -3.9687501,0.529167 0,0 -2.645833,0 -3.9687495,-0.529167 z"
         id="path20498" />
      <path
         style="display:inline;fill:url(#linearGradient2393);fill-opacity:1;stroke:none;stroke-width:1.05833;stroke-linecap:round;stroke-linejoin:round;stroke-dasharray:none;stroke-opacity:1"
         d="m 5.2916335,3.9687495 c 0,0 -0.7937685,2.3812496 -0.7937499,3.4395828 1.5874991,0.5291676 3.9687796,7e-7 3.9687796,7e-7 0,0 2.3812198,0.5291669 3.9687198,-7e-7 -1.9e-5,-1.0583332 -0.529167,-3.4395828 -0.529167,-3.4395828 -1.322917,0.5291666 -3.4395829,0.2645833 -3.4395829,0.2645833 0,0 -1.8520842,0.2645833 -3.1749996,-0.2645833 z"
         id="path20494-3" />
      <path
         style="font-variation-settings:normal;display:inline;vector-effect:none;fill:url(#linearGradient4098);fill-opacity:1;stroke:none;stroke-width:1.05833;stroke-linecap:butt;stroke-linejoin:round;stroke-miterlimit:2.4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;-inkscape-stroke:none;stop-color:#000000"
         d="m 11.906227,5.2916656 0.264572,2.1166667 -0.79375,0.7937499 -0.529166,-4.2333327 h 0.79375"
         id="path20496-4" />
      <path
         style="display:inline;fill:none;fill-opacity:1;stroke:#000000;stroke-width:1.05833;stroke-linecap:round;stroke-linejoin:round;stroke-dasharray:none;stroke-opacity:1"
         d="m 4.7624669,3.9687495 c 0,0 -0.2646019,2.3812496 -0.2645833,3.4395828 1.3229165,0.5291666 3.9687796,0.5291673 3.9687796,0.5291673 0,0 2.6458028,-7e-7 3.9687198,-0.5291673 -1.9e-5,-1.0583332 -0.264584,-3.4395828 -0.264584,-3.4395828 0,0 -1.5875,0 -3.7041659,0 -2.1166664,0 -3.7041662,0 -3.7041662,0 z"
         id="path20498-9" />
      <path
         style="font-variation-settings:normal;opacity:1;fill:none;fill-opacity:1;stroke:#000000;stroke-width:1.05833;stroke-linecap:butt;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;stop-color:#000000;stop-opacity:1"
         d="M 7.1437166,3.7041662 6.9971105,6.0854158 M 9.6312714,3.7041662 9.7778775,6.0854158"
         id="path21359"
         class="UnoptimicedTransforms"
         transform="translate(0.07913911,0.00673837)" />
    </g>
  </g>
  <g
     id="layer5"
     style="display:none"
     transform="translate(-53.974995)">
    <ellipse
       style="display:inline;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1.05833;stroke-linecap:round;stroke-linejoin:round;stroke-dasharray:none;stroke-opacity:1"
       id="path63964-5"
       cy="9.7895823"
       cx="61.11874"
       ry="0.52916658"
       rx="0.52916664" />
    <ellipse
       style="display:inline;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1.05833;stroke-linecap:round;stroke-linejoin:round;stroke-dasharray:none;stroke-opacity:1"
       id="path63964-6"
       cy="9.7895823"
       cx="62.970825"
       ry="0.52916658"
       rx="0.52916664" />
  </g>
</svg>
')} -.is2d .queen.white {background-image:url('data:image/svg+xml;base64,<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<!-- Created with Inkscape (http://www.inkscape.org/) -->

<svg
   width="64.000015"
   height="63.999996"
   viewBox="0 0 16.933335 16.93333"
   version="1.1"
   id="svg5"
   xmlns:xlink="http://www.w3.org/1999/xlink"
   xmlns="http://www.w3.org/2000/svg"
   xmlns:svg="http://www.w3.org/2000/svg"
   xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
   xmlns:cc="http://creativecommons.org/ns#">
  <defs
     id="defs2">
    <linearGradient
       id="wood_black_accent">
      <stop
         style="stop-color:#ba845f;stop-opacity:1;"
         offset="0"
         id="stop5970" />
    </linearGradient>
    <linearGradient
       id="wood_black_fill">
      <stop
         style="stop-color:#995e33;stop-opacity:1;"
         offset="0"
         id="stop5940" />
    </linearGradient>
    <linearGradient
       id="wood_white_shade">
      <stop
         style="stop-color:#d0b793;stop-opacity:1;"
         offset="0"
         id="stop3347" />
    </linearGradient>
    <linearGradient
       id="wood_white_fill">
      <stop
         style="stop-color:#f9e7d2;stop-opacity:1;"
         offset="0"
         id="stop3028" />
    </linearGradient>
    <linearGradient
       id="white_fill">
      <stop
         style="stop-color:#ffffff;stop-opacity:1;"
         offset="0"
         id="stop2367" />
    </linearGradient>
    <linearGradient
       id="white_shade"
       gradientTransform="translate(-5.8013919e-8,2.1166665)">
      <stop
         style="stop-color:#cccccc;stop-opacity:1;"
         offset="0"
         id="stop45894" />
    </linearGradient>
    <linearGradient
       id="linearGradient45642">
      <stop
         style="stop-color:#000000;stop-opacity:0.2;"
         offset="0"
         id="stop45640" />
    </linearGradient>
    <linearGradient
       id="black_accent"
       gradientTransform="scale(0.07000432)">
      <stop
         style="stop-color:#8c8c8c;stop-opacity:1;"
         offset="0"
         id="stop52163" />
    </linearGradient>
    <linearGradient
       id="black_fill"
       gradientTransform="matrix(0.07000432,0,0,0.07000432,-53.975025,2.1166665)">
      <stop
         style="stop-color:#595959;stop-opacity:1;"
         offset="0"
         id="stop51990" />
    </linearGradient>
    <linearGradient
       xlink:href="#white_fill"
       id="linearGradient2381"
       x1="76.200043"
       y1="12.964581"
       x2="84.666718"
       y2="12.964581"
       gradientUnits="userSpaceOnUse" />
    <linearGradient
       xlink:href="#white_fill"
       id="linearGradient2383"
       x1="19.049967"
       y1="5.8208327"
       x2="22.224962"
       y2="5.8208327"
       gradientUnits="userSpaceOnUse" />
    <linearGradient
       xlink:href="#white_fill"
       id="linearGradient2385"
       x1="29.633303"
       y1="5.8208327"
       x2="32.808296"
       y2="5.8208327"
       gradientUnits="userSpaceOnUse" />
    <linearGradient
       xlink:href="#white_fill"
       id="linearGradient2387"
       x1="26.4583"
       y1="3.4395828"
       x2="29.633295"
       y2="3.4395828"
       gradientUnits="userSpaceOnUse" />
    <linearGradient
       xlink:href="#white_fill"
       id="linearGradient2389"
       x1="22.22497"
       y1="3.4395826"
       x2="25.399965"
       y2="3.4395826"
       gradientUnits="userSpaceOnUse" />
    <linearGradient
       xlink:href="#white_fill"
       id="linearGradient2391"
       x1="20.637465"
       y1="8.2020826"
       x2="31.220797"
       y2="8.2020826"
       gradientUnits="userSpaceOnUse" />
    <linearGradient
       xlink:href="#white_shade"
       id="linearGradient4094"
       gradientTransform="translate(-5.8013919e-8,2.1166665)"
       gradientUnits="userSpaceOnUse" />
    <linearGradient
       xlink:href="#white_shade"
       id="linearGradient4096"
       gradientTransform="translate(-5.8013919e-8,2.1166665)"
       gradientUnits="userSpaceOnUse" />
    <linearGradient
       xlink:href="#linearGradient45642"
       id="linearGradient22730"
       gradientUnits="userSpaceOnUse"
       gradientTransform="matrix(1,0,0,1.25,0.79374989,-3.0427069)"
       x1="4.2333326"
       y1="24.341663"
       x2="103.04872"
       y2="24.341663" />
  </defs>
  <metadata
     id="metadata505">
    <rdf:RDF>
      <cc:Work
         rdf:about="" />
    </rdf:RDF>
  </metadata>
  <g
     id="layer6"
     transform="translate(-71.966652)">
    <path
       style="font-variation-settings:normal;vector-effect:none;fill:url(#linearGradient22730);fill-opacity:1;stroke:none;stroke-width:1.25861;stroke-linecap:round;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;-inkscape-stroke:none;stop-color:#000000"
       d="m 5.0270826,14.816665 c 0,0.992188 2.645833,1.322916 4.2333328,1.322916 1.5874976,0 4.2333306,-0.330728 4.2333306,-1.322916 0,-0.992187 -2.778792,-1.322916 -4.2333306,-1.322916 -1.4545399,0 -4.2333328,0.330729 -4.2333328,1.322916 z"
       id="use60280"
       class="UnoptimicedTransforms"
       transform="matrix(1.215278,0,0,0.99999995,69.561534,9.6337469e-7)" />
    <g
       id="g28618"
       style="display:inline"
       transform="translate(54.504191)">
      <path
         style="font-variation-settings:normal;display:inline;opacity:1;fill:url(#linearGradient2391);fill-opacity:1;stroke:none;stroke-width:1.05833;stroke-linecap:butt;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;stop-color:#000000;stop-opacity:1"
         d="M 22.754133,12.964582 20.637465,5.8208325 c 3.175,2.9104163 3.175,1.3229165 3.175,-2.3812496 2.116666,2.6458329 2.116666,2.6458329 4.233333,0 0,3.7041661 -0.01298,5.3096054 3.174999,2.3812496 l -2.116665,7.1437495"
         id="path45261" />
      <path
         style="font-variation-settings:normal;display:inline;opacity:1;vector-effect:none;fill:url(#linearGradient4096);fill-opacity:1;stroke:none;stroke-width:1.05833;stroke-linecap:butt;stroke-linejoin:round;stroke-miterlimit:2.4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;-inkscape-stroke:none;stop-color:#000000;stop-opacity:1"
         d="m 29.104131,12.964582 -2.116667,0.264583 c 0,0 1.058334,-2.645833 1.058334,-6.8791659 0.79375,1.0583332 2.381249,1.0583332 2.381249,1.0583332 0,0 -1.587499,3.7041657 -1.322916,5.5562497 z"
         id="path28748" />
      <path
         style="font-variation-settings:normal;display:inline;opacity:1;fill:none;fill-opacity:1;stroke:#000000;stroke-width:1.05833;stroke-linecap:butt;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;stop-color:#000000;stop-opacity:1"
         d="m 22.224965,11.112498 -1.5875,-5.2916655 c 3.175,2.9104163 3.175,1.3229165 3.175,-2.3812496 2.116666,3.4395828 2.116666,3.4395828 4.233333,0 0,3.7041661 -0.01298,5.3096054 3.174999,2.3812496 l -1.5875,5.2916655"
         id="path28743" />
      <ellipse
         style="font-variation-settings:normal;display:inline;vector-effect:none;fill:url(#linearGradient2389);fill-opacity:1;stroke:#000000;stroke-width:1.05833;stroke-linecap:butt;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;-inkscape-stroke:none;stop-color:#000000"
         id="ellipse127816-5"
         cx="23.812468"
         cy="3.4395826"
         rx="1.0583324"
         ry="1.0583333" />
      <ellipse
         style="font-variation-settings:normal;display:inline;vector-effect:none;fill:url(#linearGradient2387);fill-opacity:1;stroke:#000000;stroke-width:1.05833;stroke-linecap:butt;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;-inkscape-stroke:none;stop-color:#000000"
         id="ellipse127816-7"
         cx="28.045797"
         cy="3.4395828"
         rx="1.0583324"
         ry="1.0583333" />
      <ellipse
         style="font-variation-settings:normal;display:inline;vector-effect:none;fill:url(#linearGradient2385);fill-opacity:1;stroke:#000000;stroke-width:1.05833;stroke-linecap:butt;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;-inkscape-stroke:none;stop-color:#000000"
         id="ellipse127816-1"
         cx="31.2208"
         cy="5.8208327"
         rx="1.0583324"
         ry="1.0583333" />
      <ellipse
         style="font-variation-settings:normal;display:inline;vector-effect:none;fill:url(#linearGradient2383);fill-opacity:1;stroke:#000000;stroke-width:1.05833;stroke-linecap:butt;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;-inkscape-stroke:none;stop-color:#000000"
         id="ellipse127816-3"
         cx="20.637465"
         cy="5.8208327"
         rx="1.0583324"
         ry="1.0583333" />
      <path
         style="display:inline;fill:url(#linearGradient2381);fill-opacity:1;stroke:none;stroke-width:1.05833;stroke-linecap:round;stroke-linejoin:round;stroke-dasharray:none;stroke-opacity:1"
         d="m 76.464607,11.112498 c 0,0 -0.264583,2.116667 -0.264565,3.175 1.587502,0.529167 4.233337,0.529167 4.233337,0.529167 0,0 2.645835,0 4.233335,-0.529167 -1.9e-5,-1.058333 -0.264602,-3.175 -0.264602,-3.175 -1.322917,0.529167 -3.968751,0.529167 -3.968751,0.529167 0,0 -2.645835,0 -3.968754,-0.529167 z"
         id="path55930"
         transform="translate(-54.504191)" />
      <path
         style="font-variation-settings:normal;display:inline;vector-effect:none;fill:url(#linearGradient4094);fill-opacity:1;stroke:none;stroke-width:1.05833;stroke-linecap:butt;stroke-linejoin:round;stroke-miterlimit:2.4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;-inkscape-stroke:none;stop-color:#000000"
         d="m 83.872944,11.112498 0.79375,3.175 -1.852082,0.264583 -0.529207,-2.910416 1.587539,-0.529167"
         id="path55932"
         transform="translate(-54.504191)" />
      <path
         style="display:inline;fill:none;fill-opacity:1;stroke:#000000;stroke-width:1.05833;stroke-linecap:round;stroke-linejoin:round;stroke-dasharray:none;stroke-opacity:1"
         d="m 76.729154,11.112498 c 0,0 -0.52913,2.116667 -0.529112,3.175 1.587502,0.529167 4.233337,0.529167 4.233337,0.529167 0,0 2.645835,0 4.233335,-0.529167 -1.9e-5,-1.058333 -0.529226,-3.175 -0.529226,-3.175 -1.322917,0.529167 -3.704167,0.529167 -3.704167,0.529167 0,0 -2.381248,0 -3.704167,-0.529167 z"
         id="path55934"
         transform="translate(-54.504191)" />
      <path
         style="display:inline;fill:none;fill-opacity:1;stroke:#000000;stroke-width:1.05833;stroke-linecap:butt;stroke-linejoin:round;stroke-dasharray:none;stroke-opacity:1"
         d="m 84.402076,12.699998 c -1.32292,0.529167 -3.968746,0.529167 -3.968746,0.529167 0,0 -2.645841,0 -3.968758,-0.529167"
         id="path55936"
         transform="translate(-54.504191)" />
    </g>
  </g>
  <g
     id="layer5"
     style="display:none"
     transform="translate(-71.966652)">
    <ellipse
       style="display:inline;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1.05833;stroke-linecap:round;stroke-linejoin:round;stroke-dasharray:none;stroke-opacity:1"
       id="path63964-2"
       cy="9.7895823"
       cx="78.316658"
       ry="0.52916658"
       rx="0.52916664" />
    <ellipse
       style="display:inline;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1.05833;stroke-linecap:round;stroke-linejoin:round;stroke-dasharray:none;stroke-opacity:1"
       id="path63964-9"
       cy="9.7895823"
       cx="80.697906"
       ry="0.52916658"
       rx="0.52916664" />
    <path
       style="fill:#000000;fill-opacity:1;stroke:#000000;stroke-width:1.05833;stroke-linecap:round;stroke-linejoin:round;stroke-opacity:1;-inkscape-stroke:none;stop-color:#000000"
       d="m 80.962489,7.4083323 -0.79375,0.7937499"
       id="path75020" />
    <path
       style="fill:#000000;fill-opacity:1;stroke:#000000;stroke-width:1.05833;stroke-linecap:round;stroke-linejoin:round;stroke-opacity:1;-inkscape-stroke:none;stop-color:#000000"
       d="m 78.052073,7.4083323 0.793749,0.7937499"
       id="path75298" />
  </g>
</svg>
')} -.is2d .king.white {background-image:url('data:image/svg+xml;base64,<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<!-- Created with Inkscape (http://www.inkscape.org/) -->

<svg
   width="64.000015"
   height="63.999996"
   viewBox="0 0 16.933335 16.93333"
   version="1.1"
   id="svg5"
   xmlns:xlink="http://www.w3.org/1999/xlink"
   xmlns="http://www.w3.org/2000/svg"
   xmlns:svg="http://www.w3.org/2000/svg"
   xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
   xmlns:cc="http://creativecommons.org/ns#">
  <defs
     id="defs2">
    <linearGradient
       id="wood_black_accent">
      <stop
         style="stop-color:#ba845f;stop-opacity:1;"
         offset="0"
         id="stop5970" />
    </linearGradient>
    <linearGradient
       id="wood_black_fill">
      <stop
         style="stop-color:#995e33;stop-opacity:1;"
         offset="0"
         id="stop5940" />
    </linearGradient>
    <linearGradient
       id="wood_white_shade">
      <stop
         style="stop-color:#d0b793;stop-opacity:1;"
         offset="0"
         id="stop3347" />
    </linearGradient>
    <linearGradient
       id="wood_white_fill">
      <stop
         style="stop-color:#f9e7d2;stop-opacity:1;"
         offset="0"
         id="stop3028" />
    </linearGradient>
    <linearGradient
       id="white_fill">
      <stop
         style="stop-color:#ffffff;stop-opacity:1;"
         offset="0"
         id="stop2367" />
    </linearGradient>
    <linearGradient
       id="white_shade"
       gradientTransform="translate(-5.8013919e-8,2.1166665)">
      <stop
         style="stop-color:#cccccc;stop-opacity:1;"
         offset="0"
         id="stop45894" />
    </linearGradient>
    <linearGradient
       id="linearGradient45642">
      <stop
         style="stop-color:#000000;stop-opacity:0.2;"
         offset="0"
         id="stop45640" />
    </linearGradient>
    <linearGradient
       id="black_accent"
       gradientTransform="scale(0.07000432)">
      <stop
         style="stop-color:#8c8c8c;stop-opacity:1;"
         offset="0"
         id="stop52163" />
    </linearGradient>
    <linearGradient
       id="black_fill"
       gradientTransform="matrix(0.07000432,0,0,0.07000432,-53.975025,2.1166665)">
      <stop
         style="stop-color:#595959;stop-opacity:1;"
         offset="0"
         id="stop51990" />
    </linearGradient>
    <linearGradient
       xlink:href="#white_fill"
       id="linearGradient2373"
       x1="25.929119"
       y1="8.5989571"
       x2="31.74995"
       y2="8.5989571"
       gradientUnits="userSpaceOnUse" />
    <linearGradient
       xlink:href="#white_fill"
       id="linearGradient2375"
       x1="21.695839"
       y1="12.964581"
       x2="30.16251"
       y2="12.964581"
       gradientUnits="userSpaceOnUse" />
    <linearGradient
       xlink:href="#white_fill"
       id="linearGradient2377"
       x1="92.074989"
       y1="8.5989571"
       x2="98.954155"
       y2="8.5989571"
       gradientUnits="userSpaceOnUse" />
    <linearGradient
       xlink:href="#white_fill"
       id="linearGradient2379"
       x1="23.283287"
       y1="7.1437492"
       x2="28.574949"
       y2="7.1437492"
       gradientUnits="userSpaceOnUse" />
    <linearGradient
       xlink:href="#white_shade"
       id="linearGradient4090"
       gradientTransform="translate(-5.8013919e-8,2.1166665)"
       gradientUnits="userSpaceOnUse" />
    <linearGradient
       xlink:href="#white_shade"
       id="linearGradient4092"
       gradientTransform="translate(-5.8013919e-8,2.1166665)"
       gradientUnits="userSpaceOnUse" />
    <linearGradient
       xlink:href="#linearGradient45642"
       id="linearGradient24184"
       gradientUnits="userSpaceOnUse"
       gradientTransform="matrix(1,0,0,1.25,0.79374989,-3.0427069)"
       x1="4.2333326"
       y1="24.341663"
       x2="103.04872"
       y2="24.341663" />
  </defs>
  <metadata
     id="metadata505">
    <rdf:RDF>
      <cc:Work
         rdf:about="" />
    </rdf:RDF>
  </metadata>
  <g
     id="layer6"
     transform="translate(-89.958321)">
    <path
       style="font-variation-settings:normal;vector-effect:none;fill:url(#linearGradient24184);fill-opacity:1;stroke:none;stroke-width:1.25861;stroke-linecap:round;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;-inkscape-stroke:none;stop-color:#000000"
       d="m 5.0270826,14.816665 c 0,0.992188 2.645833,1.322916 4.2333328,1.322916 1.5874976,0 4.2333306,-0.330728 4.2333306,-1.322916 0,-0.992187 -2.778792,-1.322916 -4.2333306,-1.322916 -1.4545399,0 -4.2333328,0.330729 -4.2333328,1.322916 z"
       id="use60284"
       class="UnoptimicedTransforms"
       transform="matrix(1.215278,0,0,0.99999995,87.553212,9.6337469e-7)" />
    <g
       id="g33068"
       style="display:inline"
       transform="translate(72.495868)">
      <path
         style="font-variation-settings:normal;opacity:1;fill:#a6a6a6;fill-opacity:1;stroke:#000000;stroke-width:1.05833;stroke-linecap:round;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;stop-color:#000000;stop-opacity:1"
         d="M 25.929118,1.3229165 V 4.7624993"
         id="path33070" />
      <ellipse
         style="font-variation-settings:normal;display:inline;opacity:1;fill:url(#linearGradient2379);fill-opacity:1;stroke:#000000;stroke-width:1.05833;stroke-linecap:round;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;stop-color:#000000;stop-opacity:1"
         id="path37484"
         cx="25.929119"
         cy="7.1437492"
         rx="2.1166663"
         ry="2.9104159" />
      <path
         style="font-variation-settings:normal;opacity:1;fill:url(#linearGradient2377);fill-opacity:1;stroke:#000000;stroke-width:1.05833;stroke-linecap:round;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;stop-color:#000000;stop-opacity:1"
         d="m 94.720821,11.112498 c 0,0 -2.116666,-1.058333 -2.116666,-3.1749991 0,-1.0583332 1.001019,-2.1166664 2.116666,-2.1166664 2.116667,0 3.704166,1.5874998 3.704166,5.5562495"
         id="path37703"
         transform="translate(-72.495869)" />
      <path
         style="display:inline;opacity:1;fill:url(#linearGradient2375);fill-opacity:1;stroke:none;stroke-width:1.05833;stroke-linecap:round;stroke-linejoin:round;stroke-dasharray:none;stroke-opacity:1"
         d="m 21.960404,11.112498 c 0,0 -0.264583,2.116667 -0.264565,3.175 1.587501,0.529167 4.233336,0.529167 4.233336,0.529167 0,0 2.645835,0 4.233335,-0.529167 -1.9e-5,-1.058333 -0.264602,-3.175 -0.264602,-3.175 -1.322917,0.529167 -3.968751,0.529167 -3.968751,0.529167 0,0 -2.645835,0 -3.968753,-0.529167 z"
         id="path33048" />
      <path
         style="font-variation-settings:normal;display:inline;opacity:1;vector-effect:none;fill:url(#linearGradient4092);fill-opacity:1;stroke:none;stroke-width:1.05833;stroke-linecap:butt;stroke-linejoin:round;stroke-miterlimit:2.4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;-inkscape-stroke:none;stop-color:#000000;stop-opacity:1"
         d="m 29.36874,11.112498 0.79375,3.175 -1.852082,0.264583 -0.529207,-2.910416 1.587539,-0.529167"
         id="path33052" />
      <path
         style="font-variation-settings:normal;opacity:1;fill:url(#linearGradient2373);fill-opacity:1;stroke:none;stroke-width:1.05833;stroke-linecap:round;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;stop-color:#000000;stop-opacity:1"
         d="m 29.633285,11.112498 c 0,0 2.116666,-1.058333 2.116666,-3.1749991 0,-1.0583332 -1.001019,-2.1166664 -2.116666,-2.1166664 -2.116667,0 -3.704167,1.5874998 -3.704166,5.5562495"
         id="path37937" />
      <path
         style="font-variation-settings:normal;opacity:1;fill:url(#linearGradient4090);fill-opacity:1;stroke:none;stroke-width:1.05833;stroke-linecap:round;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;stop-color:#000000;stop-opacity:1"
         d="m 30.162451,6.3499991 c 0,2.645833 -0.79375,3.7041659 -2.116666,4.7624989 2.116666,0 3.704166,-1.8520826 3.704167,-3.174999 1e-6,-0.8819444 -1.587501,-1.5874999 -1.587501,-1.5874999 z"
         id="path38253" />
      <path
         style="display:inline;opacity:1;fill:none;fill-opacity:1;stroke:#000000;stroke-width:1.05833;stroke-linecap:round;stroke-linejoin:round;stroke-dasharray:none;stroke-opacity:1"
         d="m 22.224951,11.112498 c 0,0 -0.52913,2.116667 -0.529112,3.175 1.587501,0.529167 4.233336,0.529167 4.233336,0.529167 0,0 2.645835,0 4.233335,-0.529167 -1.9e-5,-1.058333 -0.529226,-3.175 -0.529226,-3.175 -1.322917,0.529167 -3.704167,0.529167 -3.704167,0.529167 0,0 -2.381248,0 -3.704166,-0.529167 z"
         id="path33056" />
      <path
         style="font-variation-settings:normal;opacity:1;fill:#a6a6a6;fill-opacity:1;stroke:#000000;stroke-width:1.05833;stroke-linecap:round;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;stop-color:#000000;stop-opacity:1"
         d="m 24.870786,2.3812497 h 2.116667"
         id="path33074" />
      <path
         style="display:inline;fill:none;fill-opacity:1;stroke:#000000;stroke-width:1.05833;stroke-linecap:butt;stroke-linejoin:round;stroke-dasharray:none;stroke-opacity:1"
         d="m 102.39374,12.699998 c -1.32292,0.529167 -3.968746,0.529167 -3.968746,0.529167 0,0 -2.645841,0 -3.968757,-0.529167"
         id="path65119-2"
         transform="translate(-72.495868)" />
      <path
         style="font-variation-settings:normal;opacity:1;fill:none;fill-opacity:1;stroke:#000000;stroke-width:1.05833;stroke-linecap:round;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;stop-color:#000000;stop-opacity:1"
         d="m 29.633285,11.112498 c 0,0 2.116666,-1.058333 2.116666,-3.1749991 0,-1.0583332 -1.001019,-2.1166664 -2.116666,-2.1166664 -2.116667,0 -3.704167,1.5874998 -3.704166,5.5562495"
         id="path38251" />
    </g>
  </g>
  <g
     id="layer5"
     style="display:none"
     transform="translate(-89.958321)">
    <ellipse
       style="display:inline;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1.05833;stroke-linecap:round;stroke-linejoin:round;stroke-dasharray:none;stroke-opacity:1"
       id="path63964-6-1"
       cy="12.435415"
       cx="97.895821"
       ry="0.52916658"
       rx="0.52916664" />
    <ellipse
       style="display:inline;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1.05833;stroke-linecap:round;stroke-linejoin:round;stroke-dasharray:none;stroke-opacity:1"
       id="path63964-6-7"
       cy="12.435415"
       cx="96.308319"
       ry="0.52916658"
       rx="0.52916664" />
  </g>
</svg>
')} -.is2d .pawn.black {background-image:url('data:image/svg+xml;base64,<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<!-- Created with Inkscape (http://www.inkscape.org/) -->

<svg
   width="63.999996"
   height="64"
   viewBox="0 0 16.93333 16.933331"
   version="1.1"
   id="svg5"
   xmlns:xlink="http://www.w3.org/1999/xlink"
   xmlns="http://www.w3.org/2000/svg"
   xmlns:svg="http://www.w3.org/2000/svg"
   xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
   xmlns:cc="http://creativecommons.org/ns#">
  <defs
     id="defs2">
    <linearGradient
       id="wood_black_accent">
      <stop
         style="stop-color:#ba845f;stop-opacity:1;"
         offset="0"
         id="stop5970" />
    </linearGradient>
    <linearGradient
       id="wood_black_fill">
      <stop
         style="stop-color:#995e33;stop-opacity:1;"
         offset="0"
         id="stop5940" />
    </linearGradient>
    <linearGradient
       id="wood_white_shade">
      <stop
         style="stop-color:#d0b793;stop-opacity:1;"
         offset="0"
         id="stop3347" />
    </linearGradient>
    <linearGradient
       id="wood_white_fill">
      <stop
         style="stop-color:#f9e7d2;stop-opacity:1;"
         offset="0"
         id="stop3028" />
    </linearGradient>
    <linearGradient
       id="white_fill">
      <stop
         style="stop-color:#ffffff;stop-opacity:1;"
         offset="0"
         id="stop2367" />
    </linearGradient>
    <linearGradient
       id="white_shade"
       gradientTransform="translate(-5.8013919e-8,2.1166665)">
      <stop
         style="stop-color:#cccccc;stop-opacity:1;"
         offset="0"
         id="stop45894" />
    </linearGradient>
    <linearGradient
       id="linearGradient45642">
      <stop
         style="stop-color:#000000;stop-opacity:0.2;"
         offset="0"
         id="stop45640" />
    </linearGradient>
    <linearGradient
       id="black_accent"
       gradientTransform="scale(0.07000432)">
      <stop
         style="stop-color:#8c8c8c;stop-opacity:1;"
         offset="0"
         id="stop52163" />
    </linearGradient>
    <linearGradient
       id="black_fill"
       gradientTransform="matrix(0.07000432,0,0,0.07000432,-53.975025,2.1166665)">
      <stop
         style="stop-color:#595959;stop-opacity:1;"
         offset="0"
         id="stop51990" />
    </linearGradient>
    <linearGradient
       xlink:href="#black_fill"
       id="linearGradient5968"
       x1="4.7624993"
       y1="9.5249987"
       x2="12.170832"
       y2="9.5249987"
       gradientUnits="userSpaceOnUse" />
    <linearGradient
       xlink:href="#black_accent"
       id="linearGradient6006"
       x1="4.7624993"
       y1="9.6110868"
       x2="8.9958324"
       y2="9.6110868"
       gradientUnits="userSpaceOnUse" />
    <linearGradient
       xlink:href="#linearGradient45642"
       id="linearGradient26276"
       gradientUnits="userSpaceOnUse"
       gradientTransform="matrix(1,0,0,1.25,0.79374989,-3.0427069)"
       x1="4.2333326"
       y1="24.341663"
       x2="103.04872"
       y2="24.341663" />
  </defs>
  <metadata
     id="metadata505">
    <rdf:RDF>
      <cc:Work
         rdf:about="" />
    </rdf:RDF>
  </metadata>
  <g
     id="layer6"
     transform="translate(-4.6411134e-7,-17.991665)">
    <path
       style="font-variation-settings:normal;vector-effect:none;fill:url(#linearGradient26276);fill-opacity:1;stroke:none;stroke-width:1.25861;stroke-linecap:round;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;-inkscape-stroke:none;stop-color:#000000"
       d="m 5.0270826,14.816665 c 0,0.992188 2.645833,1.322916 4.2333328,1.322916 1.5874976,0 4.2333306,-0.330728 4.2333306,-1.322916 0,-0.992187 -2.778792,-1.322916 -4.2333306,-1.322916 -1.4545399,0 -4.2333328,0.330729 -4.2333328,1.322916 z"
       id="use174813"
       class="UnoptimicedTransforms"
       transform="matrix(1.0937503,0,0,0.99999995,-1.2650402,17.991665)" />
    <g
       id="g62410-2"
       style="display:inline"
       transform="translate(-5.8715821e-8,17.991664)">
      <path
         style="display:inline;opacity:1;fill:url(#linearGradient5968);fill-opacity:1;stroke:none;stroke-width:1.05833;stroke-linecap:round;stroke-linejoin:round;stroke-dasharray:none;stroke-opacity:1"
         d="m 4.7624993,14.287498 c 1.5874998,0.529167 3.7041663,0.529167 3.7041663,0.529167 0,0 2.1166664,0 3.7041664,-0.529167 0,-2.116666 -0.79375,-2.645833 -2.38125,-4.233333 1.5875,-1.5874995 0.79375,-2.6458327 -0.2645833,-3.7041659 0.7937503,-0.7937499 0,-2.1166663 -1.0583332,-2.1166663 -1.0583332,0 -1.8520831,1.3229164 -1.0583332,2.1166663 -1.0583332,1.0583332 -1.8520831,2.1166664 -0.2645833,3.7041659 -1.5874998,1.5875 -2.3812497,2.116667 -2.3812497,4.233333 z"
         id="path71447" />
      <path
         style="display:inline;fill:url(#linearGradient6006);fill-opacity:1;stroke:none;stroke-width:0.79375;stroke-linejoin:round"
         d="m 4.7624994,14.287498 1.8520831,0.529167 c -1e-7,-2.116667 1.5874999,-3.96875 1.3229164,-4.7625 C 7.6729156,9.2604154 7.6729156,8.9958321 7.6729156,8.4666655 c 0,-1.0583332 0.7937499,-1.3229165 0.5291666,-2.1166664 -0.2645833,-0.7937499 0,-1.5874998 0.7937499,-1.8520831 C 7.6729156,3.9687494 7.3521979,5.8636183 7.143749,6.3499991 c -0.3385891,0.7900413 -1.0583332,2.3812497 0,3.7041659 -1.8520831,1.5875 -2.3812496,3.721739 -2.3812496,4.233333 z"
         id="path71538" />
      <path
         style="display:inline;opacity:1;fill:none;fill-opacity:1;stroke:#000000;stroke-width:1.05833;stroke-linecap:round;stroke-linejoin:round;stroke-dasharray:none;stroke-opacity:1"
         d="m 4.7624993,14.287498 c 1.5874998,0.529167 3.7041663,0.529167 3.7041663,0.529167 0,0 2.1166664,0 3.7041664,-0.529167 0,-2.116666 -0.79375,-2.645833 -2.38125,-4.233333 1.5875,-1.5874995 0.79375,-2.6458327 -0.2645833,-3.7041659 0.7937503,-0.7937499 0,-2.1166663 -1.0583332,-2.1166663 -1.0583332,0 -1.8520831,1.3229164 -1.0583332,2.1166663 -1.0583332,1.0583332 -1.8520831,2.1166664 -0.2645833,3.7041659 -1.5874998,1.5875 -2.3812497,2.116667 -2.3812497,4.233333 z"
         id="path64922-8" />
    </g>
  </g>
</svg>
')} -.is2d .knight.black {background-image:url('data:image/svg+xml;base64,<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<!-- Created with Inkscape (http://www.inkscape.org/) -->

<svg
   width="63.999992"
   height="64"
   viewBox="0 0 16.933329 16.933331"
   version="1.1"
   id="svg5"
   xmlns:xlink="http://www.w3.org/1999/xlink"
   xmlns="http://www.w3.org/2000/svg"
   xmlns:svg="http://www.w3.org/2000/svg"
   xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
   xmlns:cc="http://creativecommons.org/ns#">
  <defs
     id="defs2">
    <linearGradient
       id="wood_black_accent">
      <stop
         style="stop-color:#ba845f;stop-opacity:1;"
         offset="0"
         id="stop5970" />
    </linearGradient>
    <linearGradient
       id="wood_black_fill">
      <stop
         style="stop-color:#995e33;stop-opacity:1;"
         offset="0"
         id="stop5940" />
    </linearGradient>
    <linearGradient
       id="wood_white_shade">
      <stop
         style="stop-color:#d0b793;stop-opacity:1;"
         offset="0"
         id="stop3347" />
    </linearGradient>
    <linearGradient
       id="wood_white_fill">
      <stop
         style="stop-color:#f9e7d2;stop-opacity:1;"
         offset="0"
         id="stop3028" />
    </linearGradient>
    <linearGradient
       id="white_fill">
      <stop
         style="stop-color:#ffffff;stop-opacity:1;"
         offset="0"
         id="stop2367" />
    </linearGradient>
    <linearGradient
       id="white_shade"
       gradientTransform="translate(-5.8013919e-8,2.1166665)">
      <stop
         style="stop-color:#cccccc;stop-opacity:1;"
         offset="0"
         id="stop45894" />
    </linearGradient>
    <linearGradient
       id="linearGradient45642">
      <stop
         style="stop-color:#000000;stop-opacity:0.2;"
         offset="0"
         id="stop45640" />
    </linearGradient>
    <linearGradient
       id="black_accent"
       gradientTransform="scale(0.07000432)">
      <stop
         style="stop-color:#8c8c8c;stop-opacity:1;"
         offset="0"
         id="stop52163" />
    </linearGradient>
    <linearGradient
       id="black_fill"
       gradientTransform="matrix(0.07000432,0,0,0.07000432,-53.975025,2.1166665)">
      <stop
         style="stop-color:#595959;stop-opacity:1;"
         offset="0"
         id="stop51990" />
    </linearGradient>
    <linearGradient
       xlink:href="#black_fill"
       id="linearGradient5966"
       x1="4.0848351"
       y1="8.8635406"
       x2="13.229165"
       y2="8.8635406"
       gradientUnits="userSpaceOnUse" />
    <linearGradient
       xlink:href="#black_accent"
       id="linearGradient6002"
       x1="4.7624993"
       y1="11.509374"
       x2="10.583332"
       y2="11.509374"
       gradientUnits="userSpaceOnUse" />
    <linearGradient
       xlink:href="#black_accent"
       id="linearGradient6004"
       x1="4.2333326"
       y1="5.953124"
       x2="9.8979397"
       y2="5.953124"
       gradientUnits="userSpaceOnUse" />
    <linearGradient
       xlink:href="#linearGradient45642"
       id="linearGradient27687"
       gradientUnits="userSpaceOnUse"
       gradientTransform="matrix(1,0,0,1.25,0.79374989,-3.0427069)"
       x1="4.2333326"
       y1="24.341663"
       x2="103.04872"
       y2="24.341663" />
  </defs>
  <metadata
     id="metadata505">
    <rdf:RDF>
      <cc:Work
         rdf:about="" />
    </rdf:RDF>
  </metadata>
  <g
     id="layer6"
     transform="translate(-17.991667,-17.991665)">
    <path
       style="font-variation-settings:normal;vector-effect:none;fill:url(#linearGradient27687);fill-opacity:1;stroke:none;stroke-width:1.25861;stroke-linecap:round;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;-inkscape-stroke:none;stop-color:#000000"
       d="m 5.0270826,14.816665 c 0,0.992188 2.645833,1.322916 4.2333328,1.322916 1.5874976,0 4.2333306,-0.330728 4.2333306,-1.322916 0,-0.992187 -2.778792,-1.322916 -4.2333306,-1.322916 -1.4545399,0 -4.2333328,0.330729 -4.2333328,1.322916 z"
       id="use175062"
       class="UnoptimicedTransforms"
       transform="matrix(1.0937503,0,0,0.99999995,16.726624,17.991665)" />
    <g
       id="g62410-91"
       style="display:inline"
       transform="translate(17.99167,17.991669)">
      <path
         style="display:inline;opacity:1;fill:url(#linearGradient5966);fill-opacity:1;stroke:none;stroke-width:1.05833;stroke-linecap:round;stroke-linejoin:round;stroke-dasharray:none;stroke-opacity:1"
         d="m 4.7624993,14.287498 c 1.5874998,0.529167 3.7041663,0.529167 3.7041663,0.529167 0,0 2.1166664,0 3.7041664,-0.529167 -0.79375,-2.38125 1.058333,-3.968749 1.058333,-6.3499991 0,-3.9687494 -4.7624995,-5.0270826 -4.7624995,-5.0270826 v 1.3229164 c 0,0 -3.9687496,2.9104163 -4.2333328,3.1749996 -0.2645832,0.2645833 -0.1183253,0.5570994 0,0.7937499 0.2645833,0.5291666 0.5291666,0.7937499 0.7937499,1.0583332 0.2645833,0.2645833 0.5291666,0.2645833 0.7937499,0 0.2645833,-0.2645833 0.7937499,-0.5291666 1.0583332,-0.5291666 0.2645833,0 1.0583332,0.2645833 1.3229165,0.2645833 0.2645833,0 1.3229165,-0.2645833 1.8520828,-0.7937499 C 8.7312488,9.5249987 7.9374989,9.5249987 7.143749,10.054165 6.3499991,10.583332 4.7624993,12.170832 4.7624993,14.287498 Z"
         id="path59942-5" />
      <path
         style="display:inline;opacity:1;fill:url(#linearGradient6004);fill-opacity:1;stroke:none;stroke-width:1.05833;stroke-linecap:round;stroke-linejoin:round;stroke-dasharray:none;stroke-opacity:1"
         d="M 8.4666655,3.1749996 C 9.789582,4.2333327 10.318749,5.0270826 9.5249987,5.5562492 8.7312488,6.0854158 6.8791657,6.3499991 4.7624993,8.7312488 L 4.2333327,7.4083323 8.4666655,4.2333327"
         id="path65088-1" />
      <path
         style="display:inline;opacity:1;fill:url(#linearGradient6002);fill-opacity:1;stroke:none;stroke-width:1.05833;stroke-linecap:round;stroke-linejoin:round;stroke-dasharray:none;stroke-opacity:1"
         d="M 6.6145824,14.816665 4.7624993,14.287498 c 0,-2.116666 1.5874998,-3.968749 2.3812497,-4.4979164 0.7937499,-0.5291663 2.1166666,-0.2645829 3.439583,-1.5874994 0,0.5291666 -1.8520833,1.8520828 -2.3812498,2.3812498 -0.7937499,0.79375 -1.5874998,2.645833 -1.5874998,4.233333 z"
         id="path65058-7" />
      <path
         style="display:inline;opacity:1;fill:none;fill-opacity:1;stroke:#000000;stroke-width:1.05833;stroke-linecap:round;stroke-linejoin:round;stroke-dasharray:none;stroke-opacity:1"
         d="m 4.7624993,14.287498 c 1.5874998,0.529167 3.7041663,0.529167 3.7041663,0.529167 0,0 2.1166664,0 3.7041664,-0.529167 -0.79375,-2.38125 1.058333,-3.968749 1.058333,-6.3499991 0,-3.9687494 -4.7624995,-5.0270826 -4.7624995,-5.0270826 v 1.3229164 c 0,0 -3.9687496,2.9104163 -4.2333328,3.1749996 -0.2645832,0.2645833 -0.1183253,0.5570994 0,0.7937499 0.2645833,0.5291666 0.5291666,0.7937499 0.7937499,1.0583332 0.2645833,0.2645833 0.5291666,0.2645833 0.7937499,0 0.2645833,-0.2645833 0.7937499,-0.5291666 1.0583332,-0.5291666 0.2645833,0 1.0583332,0.2645833 1.3229165,0.2645833 0.2645833,0 1.3229165,-0.2645833 1.8520828,-0.7937499 C 8.7312488,9.5249987 7.9374989,9.5249987 7.143749,10.054165 6.3499991,10.583332 4.7624993,12.170832 4.7624993,14.287498 Z"
         id="path64922-0" />
      <ellipse
         style="display:inline;opacity:1;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1.05833;stroke-linecap:round;stroke-linejoin:round;stroke-dasharray:none;stroke-opacity:1"
         id="path63964-0"
         cy="6.0854158"
         cx="8.7312489"
         ry="0.52916658"
         rx="0.52916664" />
      <path
         style="display:inline;opacity:1;fill:none;fill-opacity:1;stroke:#000000;stroke-width:1.05833;stroke-linecap:butt;stroke-linejoin:round;stroke-dasharray:none;stroke-opacity:1"
         d="m 11.906248,12.699998 c -1.322916,0.529167 -3.4395825,0.529167 -3.4395825,0.529167 0,0 -1.8520831,10e-7 -3.1749996,-0.529166"
         id="path65119-8" />
    </g>
  </g>
</svg>
')} -.is2d .bishop.black {background-image:url('data:image/svg+xml;base64,<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<!-- Created with Inkscape (http://www.inkscape.org/) -->

<svg
   width="63.999985"
   height="64"
   viewBox="0 0 16.933327 16.933331"
   version="1.1"
   id="svg5"
   xmlns:xlink="http://www.w3.org/1999/xlink"
   xmlns="http://www.w3.org/2000/svg"
   xmlns:svg="http://www.w3.org/2000/svg"
   xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
   xmlns:cc="http://creativecommons.org/ns#">
  <defs
     id="defs2">
    <linearGradient
       id="wood_black_accent">
      <stop
         style="stop-color:#ba845f;stop-opacity:1;"
         offset="0"
         id="stop5970" />
    </linearGradient>
    <linearGradient
       id="wood_black_fill">
      <stop
         style="stop-color:#995e33;stop-opacity:1;"
         offset="0"
         id="stop5940" />
    </linearGradient>
    <linearGradient
       id="wood_white_shade">
      <stop
         style="stop-color:#d0b793;stop-opacity:1;"
         offset="0"
         id="stop3347" />
    </linearGradient>
    <linearGradient
       id="wood_white_fill">
      <stop
         style="stop-color:#f9e7d2;stop-opacity:1;"
         offset="0"
         id="stop3028" />
    </linearGradient>
    <linearGradient
       id="white_fill">
      <stop
         style="stop-color:#ffffff;stop-opacity:1;"
         offset="0"
         id="stop2367" />
    </linearGradient>
    <linearGradient
       id="white_shade"
       gradientTransform="translate(-5.8013919e-8,2.1166665)">
      <stop
         style="stop-color:#cccccc;stop-opacity:1;"
         offset="0"
         id="stop45894" />
    </linearGradient>
    <linearGradient
       id="linearGradient45642">
      <stop
         style="stop-color:#000000;stop-opacity:0.2;"
         offset="0"
         id="stop45640" />
    </linearGradient>
    <linearGradient
       id="black_accent"
       gradientTransform="scale(0.07000432)">
      <stop
         style="stop-color:#8c8c8c;stop-opacity:1;"
         offset="0"
         id="stop52163" />
    </linearGradient>
    <linearGradient
       id="black_fill"
       gradientTransform="matrix(0.07000432,0,0,0.07000432,-53.975025,2.1166665)">
      <stop
         style="stop-color:#595959;stop-opacity:1;"
         offset="0"
         id="stop51990" />
    </linearGradient>
    <linearGradient
       xlink:href="#black_fill"
       id="linearGradient5962"
       x1="4.7624993"
       y1="13.758332"
       x2="12.170832"
       y2="13.758332"
       gradientUnits="userSpaceOnUse" />
    <linearGradient
       xlink:href="#black_fill"
       id="linearGradient5964"
       x1="40.76622"
       y1="8.2020826"
       x2="48.133766"
       y2="8.2020826"
       gradientUnits="userSpaceOnUse" />
    <linearGradient
       xlink:href="#black_accent"
       id="linearGradient5996"
       x1="6.8791485"
       y1="2.9104161"
       x2="10.054144"
       y2="2.9104161"
       gradientUnits="userSpaceOnUse" />
    <linearGradient
       xlink:href="#black_accent"
       id="linearGradient5998"
       x1="4.7624812"
       y1="13.62604"
       x2="6.8791471"
       y2="13.62604"
       gradientUnits="userSpaceOnUse" />
    <linearGradient
       xlink:href="#black_accent"
       id="linearGradient6000"
       x1="40.412125"
       y1="8.5989571"
       x2="44.97916"
       y2="8.5989571"
       gradientUnits="userSpaceOnUse" />
    <linearGradient
       xlink:href="#linearGradient45642"
       id="linearGradient20556"
       gradientUnits="userSpaceOnUse"
       gradientTransform="matrix(1,0,0,1.25,0.79374989,-3.0427069)"
       x1="4.2333326"
       y1="24.341663"
       x2="103.04872"
       y2="24.341663" />
  </defs>
  <metadata
     id="metadata505">
    <rdf:RDF>
      <cc:Work
         rdf:about="" />
    </rdf:RDF>
  </metadata>
  <g
     id="layer6"
     transform="translate(-35.98333,-17.991665)">
    <path
       style="font-variation-settings:normal;vector-effect:none;fill:url(#linearGradient20556);fill-opacity:1;stroke:none;stroke-width:1.25861;stroke-linecap:round;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;-inkscape-stroke:none;stop-color:#000000"
       d="m 5.0270826,14.816665 c 0,0.992188 2.645833,1.322916 4.2333328,1.322916 1.5874976,0 4.2333306,-0.330728 4.2333306,-1.322916 0,-0.992187 -2.778792,-1.322916 -4.2333306,-1.322916 -1.4545399,0 -4.2333328,0.330729 -4.2333328,1.322916 z"
       id="use175066"
       class="UnoptimicedTransforms"
       transform="matrix(1.0937503,0,0,0.99999995,34.718308,17.991665)" />
    <g
       id="g9121"
       style="display:inline"
       transform="translate(35.983347,17.99167)">
      <path
         style="font-variation-settings:normal;display:inline;opacity:1;vector-effect:none;fill:url(#linearGradient5964);fill-opacity:1;stroke:none;stroke-width:1.05833;stroke-linecap:butt;stroke-linejoin:round;stroke-miterlimit:2.4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;-inkscape-stroke:none;stop-color:#000000;stop-opacity:1"
         d="m 42.333328,12.964582 c -4.497917,-5.5562497 2.116666,-9.5249991 2.116666,-9.5249991 0,0 6.614582,3.9687494 2.116667,9.5249991"
         id="path9105"
         transform="translate(-35.983347)" />
      <path
         style="font-variation-settings:normal;display:inline;opacity:1;vector-effect:none;fill:url(#linearGradient6000);fill-opacity:1;stroke:none;stroke-width:1.05833;stroke-linecap:butt;stroke-linejoin:round;stroke-miterlimit:2.4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;-inkscape-stroke:none;stop-color:#000000;stop-opacity:1"
         d="M 44.714577,4.2333327 C 42.862494,6.3499991 41.01041,10.847915 44.97916,13.229165 L 42.333327,12.964582 C 38.099994,8.4666648 41.804161,4.497916 44.449994,3.9687495 Z"
         id="path9107"
         transform="translate(-35.983347)" />
      <path
         style="font-variation-settings:normal;opacity:1;vector-effect:none;fill:none;fill-opacity:1;stroke:#000000;stroke-width:1.05833;stroke-linecap:butt;stroke-linejoin:round;stroke-miterlimit:2.4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;-inkscape-stroke:none;stop-color:#000000;stop-opacity:1"
         d="m 42.333328,12.964582 c -4.497917,-6.0854163 2.116666,-8.9958325 2.116666,-8.9958325 0,0 6.614582,2.9104162 2.116667,8.9958325"
         id="path9109"
         transform="translate(-35.983347)" />
      <path
         style="display:inline;opacity:1;fill:url(#linearGradient5962);fill-opacity:1;stroke:none;stroke-width:1.05833;stroke-linecap:round;stroke-linejoin:round;stroke-dasharray:none;stroke-opacity:1"
         d="m 5.027064,12.699998 c 0,0 -0.2645833,0.529167 -0.2645647,1.5875 1.5874998,0.529167 3.7041663,0.529167 3.7041663,0.529167 0,0 2.1166664,0 3.7041664,-0.529167 -1.9e-5,-1.058333 -0.264602,-1.5875 -0.264602,-1.5875 -1.322917,0.529167 -3.4395831,0.529167 -3.4395831,0.529167 0,0 -2.1166664,0 -3.4395829,-0.529167 z"
         id="path9111" />
      <path
         style="font-variation-settings:normal;opacity:1;vector-effect:none;fill:url(#linearGradient5998);fill-opacity:1;stroke:none;stroke-width:1.05833;stroke-linecap:butt;stroke-linejoin:round;stroke-miterlimit:2.4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;-inkscape-stroke:none;stop-color:#000000;stop-opacity:1"
         d="m 5.0270645,12.699998 -0.2645833,1.5875 1.8520826,0.264583 0.2645833,-1.322916 -1.8520826,-0.529167"
         id="path9113" />
      <path
         style="display:inline;opacity:1;fill:none;fill-opacity:1;stroke:#000000;stroke-width:1.05833;stroke-linecap:round;stroke-linejoin:round;stroke-dasharray:none;stroke-opacity:1"
         d="m 5.027064,12.699998 c 0,0 -0.2645833,0.529167 -0.2645647,1.5875 1.5874998,0.529167 3.7041663,0.529167 3.7041663,0.529167 0,0 2.1166664,0 3.7041664,-0.529167 -1.9e-5,-1.058333 -0.264602,-1.5875 -0.264602,-1.5875 -1.322917,0.529167 -3.4395831,0.529167 -3.4395831,0.529167 0,0 -2.1166664,0 -3.4395829,-0.529167 z"
         id="path9115" />
      <ellipse
         style="font-variation-settings:normal;opacity:1;vector-effect:none;fill:url(#linearGradient5996);fill-opacity:1;stroke:#000000;stroke-width:1.05833;stroke-linecap:butt;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;-inkscape-stroke:none;stop-color:#000000;stop-opacity:1"
         id="ellipse9117"
         cx="8.4666462"
         cy="2.9104161"
         rx="1.0583324"
         ry="1.0583333" />
      <path
         style="font-variation-settings:normal;opacity:1;fill:none;fill-opacity:1;stroke:#000000;stroke-width:1.05833;stroke-linecap:round;stroke-linejoin:round;stroke-miterlimit:2.4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;stop-color:#000000;stop-opacity:1"
         d="m 8.4666469,3.9687495 c 3.1749991,1.5874997 1.0583332,3.7041661 0,4.7624993"
         id="path9119" />
    </g>
  </g>
  <g
     id="layer5"
     style="display:none"
     transform="translate(-35.98333,-17.991665)">
    <ellipse
       style="display:inline;opacity:1;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1.05833;stroke-linecap:round;stroke-linejoin:round;stroke-dasharray:none;stroke-opacity:1"
       id="ellipse74907"
       cy="24.341665"
       cx="43.920826"
       ry="0.52916658"
       rx="0.52916664" />
  </g>
</svg>
')} -.is2d .rook.black {background-image:url('data:image/svg+xml;base64,<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<!-- Created with Inkscape (http://www.inkscape.org/) -->

<svg
   width="64"
   height="64"
   viewBox="0 0 16.933331 16.933331"
   version="1.1"
   id="svg5"
   xmlns:xlink="http://www.w3.org/1999/xlink"
   xmlns="http://www.w3.org/2000/svg"
   xmlns:svg="http://www.w3.org/2000/svg"
   xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
   xmlns:cc="http://creativecommons.org/ns#">
  <defs
     id="defs2">
    <linearGradient
       id="wood_black_accent">
      <stop
         style="stop-color:#ba845f;stop-opacity:1;"
         offset="0"
         id="stop5970" />
    </linearGradient>
    <linearGradient
       id="wood_black_fill">
      <stop
         style="stop-color:#995e33;stop-opacity:1;"
         offset="0"
         id="stop5940" />
    </linearGradient>
    <linearGradient
       id="wood_white_shade">
      <stop
         style="stop-color:#d0b793;stop-opacity:1;"
         offset="0"
         id="stop3347" />
    </linearGradient>
    <linearGradient
       id="wood_white_fill">
      <stop
         style="stop-color:#f9e7d2;stop-opacity:1;"
         offset="0"
         id="stop3028" />
    </linearGradient>
    <linearGradient
       id="white_fill">
      <stop
         style="stop-color:#ffffff;stop-opacity:1;"
         offset="0"
         id="stop2367" />
    </linearGradient>
    <linearGradient
       id="white_shade"
       gradientTransform="translate(-5.8013919e-8,2.1166665)">
      <stop
         style="stop-color:#cccccc;stop-opacity:1;"
         offset="0"
         id="stop45894" />
    </linearGradient>
    <linearGradient
       id="linearGradient45642">
      <stop
         style="stop-color:#000000;stop-opacity:0.2;"
         offset="0"
         id="stop45640" />
    </linearGradient>
    <linearGradient
       id="black_accent"
       gradientTransform="scale(0.07000432)">
      <stop
         style="stop-color:#8c8c8c;stop-opacity:1;"
         offset="0"
         id="stop52163" />
    </linearGradient>
    <linearGradient
       id="black_fill"
       gradientTransform="matrix(0.07000432,0,0,0.07000432,-53.975025,2.1166665)">
      <stop
         style="stop-color:#595959;stop-opacity:1;"
         offset="0"
         id="stop51990" />
    </linearGradient>
    <linearGradient
       xlink:href="#black_fill"
       id="linearGradient5944"
       x1="4.4978838"
       y1="5.8061337"
       x2="12.435383"
       y2="5.8061337"
       gradientUnits="userSpaceOnUse" />
    <linearGradient
       xlink:href="#black_fill"
       id="linearGradient5946"
       x1="4.2333326"
       y1="13.758332"
       x2="12.699999"
       y2="13.758332"
       gradientUnits="userSpaceOnUse" />
    <linearGradient
       xlink:href="#black_fill"
       id="linearGradient5948"
       x1="41.274979"
       y1="9.7895823"
       x2="47.624981"
       y2="9.7895823"
       gradientUnits="userSpaceOnUse" />
    <linearGradient
       xlink:href="#black_accent"
       id="linearGradient5974"
       x1="10.847883"
       y1="6.0854158"
       x2="12.170799"
       y2="6.0854158"
       gradientUnits="userSpaceOnUse" />
    <linearGradient
       xlink:href="#black_accent"
       id="linearGradient5976"
       x1="10.583314"
       y1="13.62604"
       x2="12.699979"
       y2="13.62604"
       gradientUnits="userSpaceOnUse" />
    <linearGradient
       xlink:href="#black_accent"
       id="linearGradient5978"
       x1="9.5249662"
       y1="9.921874"
       x2="11.641633"
       y2="9.921874"
       gradientUnits="userSpaceOnUse" />
    <linearGradient
       xlink:href="#linearGradient45642"
       id="linearGradient22025"
       gradientUnits="userSpaceOnUse"
       gradientTransform="matrix(1,0,0,1.25,0.79374989,-3.0427069)"
       x1="4.2333326"
       y1="24.341663"
       x2="103.04872"
       y2="24.341663" />
  </defs>
  <metadata
     id="metadata505">
    <rdf:RDF>
      <cc:Work
         rdf:about="" />
    </rdf:RDF>
  </metadata>
  <g
     id="layer6"
     transform="translate(-53.974995,-17.991665)">
    <path
       style="font-variation-settings:normal;vector-effect:none;fill:url(#linearGradient22025);fill-opacity:1;stroke:none;stroke-width:1.25861;stroke-linecap:round;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;-inkscape-stroke:none;stop-color:#000000"
       d="m 5.0270826,14.816665 c 0,0.992188 2.645833,1.322916 4.2333328,1.322916 1.5874976,0 4.2333306,-0.330728 4.2333306,-1.322916 0,-0.992187 -2.778792,-1.322916 -4.2333306,-1.322916 -1.4545399,0 -4.2333328,0.330729 -4.2333328,1.322916 z"
       id="use60224-5"
       class="UnoptimicedTransforms"
       transform="matrix(1.215278,0,0,0.99999995,51.569855,17.991665)" />
    <g
       id="g67576"
       style="display:inline"
       transform="matrix(-1,0,0,1,70.908357,17.99167)">
      <path
         style="font-variation-settings:normal;display:inline;opacity:1;vector-effect:none;fill:url(#linearGradient5948);fill-opacity:1;stroke:none;stroke-width:1.05833;stroke-linecap:butt;stroke-linejoin:round;stroke-miterlimit:2.4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;-inkscape-stroke:none;stop-color:#000000;stop-opacity:1"
         d="m 41.27498,12.964582 0.529167,-6.3499996 h 5.291666 l 0.529167,6.3499996"
         id="path67556"
         transform="translate(-35.983347)" />
      <path
         style="font-variation-settings:normal;display:inline;opacity:1;vector-effect:none;fill:url(#linearGradient5978);fill-opacity:1;stroke:none;stroke-width:1.05833;stroke-linecap:butt;stroke-linejoin:round;stroke-miterlimit:2.4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;-inkscape-stroke:none;stop-color:#000000;stop-opacity:1"
         d="m 9.5249662,6.8791657 0.5291668,6.3499993 1.5875,-0.264583 -0.529167,-6.3499996 z"
         id="path67558" />
      <path
         style="font-variation-settings:normal;display:inline;opacity:1;vector-effect:none;fill:none;fill-opacity:1;stroke:#000000;stroke-width:1.05833;stroke-linecap:butt;stroke-linejoin:round;stroke-miterlimit:2.4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;-inkscape-stroke:none;stop-color:#000000;stop-opacity:1"
         d="m 41.27498,12.699998 0.529167,-5.0270824 m 5.291666,0 0.529167,5.0270824"
         id="path67560"
         transform="translate(-35.983347)" />
      <path
         style="display:inline;opacity:1;fill:url(#linearGradient5946);fill-opacity:1;stroke:none;stroke-width:1.05833;stroke-linecap:round;stroke-linejoin:round;stroke-dasharray:none;stroke-opacity:1"
         d="m 4.4978974,12.699998 c 0,0 -0.2645833,0.529167 -0.2645647,1.5875 1.5874998,0.529167 4.2333329,0.529167 4.2333329,0.529167 0,0 2.6458334,0 4.2333334,-0.529167 -1.9e-5,-1.058333 -0.264602,-1.5875 -0.264602,-1.5875 -1.322917,0.529167 -3.9687501,0.529167 -3.9687501,0.529167 0,0 -2.645833,0 -3.9687495,-0.529167 z"
         id="path67562" />
      <path
         style="font-variation-settings:normal;display:inline;opacity:1;vector-effect:none;fill:url(#linearGradient5976);fill-opacity:1;stroke:none;stroke-width:1.05833;stroke-linecap:butt;stroke-linejoin:round;stroke-miterlimit:2.4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;-inkscape-stroke:none;stop-color:#000000;stop-opacity:1"
         d="m 12.435396,12.699998 0.264583,1.5875 -1.852082,0.264583 -0.264583,-1.322916 1.852082,-0.529167"
         id="path67564" />
      <path
         style="display:inline;opacity:1;fill:none;fill-opacity:1;stroke:#000000;stroke-width:1.05833;stroke-linecap:round;stroke-linejoin:round;stroke-dasharray:none;stroke-opacity:1"
         d="m 4.4978974,12.699998 c 0,0 -0.2645833,0.529167 -0.2645647,1.5875 1.5874998,0.529167 4.2333329,0.529167 4.2333329,0.529167 0,0 2.6458334,0 4.2333334,-0.529167 -1.9e-5,-1.058333 -0.264602,-1.5875 -0.264602,-1.5875 -1.322917,0.529167 -3.9687501,0.529167 -3.9687501,0.529167 0,0 -2.645833,0 -3.9687495,-0.529167 z"
         id="path67566" />
      <path
         style="display:inline;fill:url(#linearGradient5944);fill-opacity:1;stroke:none;stroke-width:1.05833;stroke-linecap:round;stroke-linejoin:round;stroke-dasharray:none;stroke-opacity:1"
         d="m 5.2916335,3.9687495 c 0,0 -0.7937685,2.3812496 -0.7937499,3.4395828 1.5874991,0.5291676 3.9687796,7e-7 3.9687796,7e-7 0,0 2.3812198,0.5291669 3.9687198,-7e-7 -1.9e-5,-1.0583332 -0.529167,-3.4395828 -0.529167,-3.4395828 -1.322917,0.5291666 -3.4395829,0.2645833 -3.4395829,0.2645833 0,0 -1.8520842,0.2645833 -3.1749996,-0.2645833 z"
         id="path67568" />
      <path
         style="font-variation-settings:normal;display:inline;vector-effect:none;fill:url(#linearGradient5974);fill-opacity:1;stroke:none;stroke-width:1.05833;stroke-linecap:butt;stroke-linejoin:round;stroke-miterlimit:2.4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;-inkscape-stroke:none;stop-color:#000000"
         d="m 11.906227,5.2916656 0.264572,2.1166667 -0.79375,0.7937499 -0.529166,-4.2333327 h 0.79375"
         id="path67570" />
      <path
         style="display:inline;fill:none;fill-opacity:1;stroke:#000000;stroke-width:1.05833;stroke-linecap:round;stroke-linejoin:round;stroke-dasharray:none;stroke-opacity:1"
         d="m 4.7625328,3.9687436 c 0,0 -0.2646678,2.3812555 -0.2646492,3.4395887 1.3229165,0.5291666 3.9687796,0.5291673 3.9687796,0.5291673 0,0 2.6458028,-7e-7 3.9687198,-0.5291673 -1.9e-5,-1.0583332 -0.264518,-3.4395887 -0.264518,-3.4395887 0,0 -1.5875,0 -3.7041661,0 -2.1166664,0 -3.7041661,0 -3.7041661,0 z"
         id="path67572" />
      <path
         style="font-variation-settings:normal;opacity:1;fill:none;fill-opacity:1;stroke:#000000;stroke-width:1.05833;stroke-linecap:butt;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;stop-color:#000000;stop-opacity:1"
         d="M 7.1437166,3.7041662 6.9971105,6.0854158 M 9.6312714,3.7041662 9.7778775,6.0854158"
         id="path67574"
         class="UnoptimicedTransforms"
         transform="translate(0.07913911,0.00673837)" />
    </g>
  </g>
  <g
     id="layer5"
     style="display:none"
     transform="translate(-53.974995,-17.991665)">
    <ellipse
       style="display:inline;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1.05833;stroke-linecap:round;stroke-linejoin:round;stroke-dasharray:none;stroke-opacity:1"
       id="ellipse74935"
       cy="27.781256"
       cx="61.11874"
       ry="0.52916658"
       rx="0.52916664" />
    <ellipse
       style="display:inline;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1.05833;stroke-linecap:round;stroke-linejoin:round;stroke-dasharray:none;stroke-opacity:1"
       id="ellipse74937"
       cy="27.781256"
       cx="62.970825"
       ry="0.52916658"
       rx="0.52916664" />
  </g>
</svg>
')} -.is2d .queen.black {background-image:url('data:image/svg+xml;base64,<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<!-- Created with Inkscape (http://www.inkscape.org/) -->

<svg
   width="64.000015"
   height="64"
   viewBox="0 0 16.933335 16.933331"
   version="1.1"
   id="svg5"
   xmlns:xlink="http://www.w3.org/1999/xlink"
   xmlns="http://www.w3.org/2000/svg"
   xmlns:svg="http://www.w3.org/2000/svg"
   xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
   xmlns:cc="http://creativecommons.org/ns#">
  <defs
     id="defs2">
    <linearGradient
       id="wood_black_accent">
      <stop
         style="stop-color:#ba845f;stop-opacity:1;"
         offset="0"
         id="stop5970" />
    </linearGradient>
    <linearGradient
       id="wood_black_fill">
      <stop
         style="stop-color:#995e33;stop-opacity:1;"
         offset="0"
         id="stop5940" />
    </linearGradient>
    <linearGradient
       id="wood_white_shade">
      <stop
         style="stop-color:#d0b793;stop-opacity:1;"
         offset="0"
         id="stop3347" />
    </linearGradient>
    <linearGradient
       id="wood_white_fill">
      <stop
         style="stop-color:#f9e7d2;stop-opacity:1;"
         offset="0"
         id="stop3028" />
    </linearGradient>
    <linearGradient
       id="white_fill">
      <stop
         style="stop-color:#ffffff;stop-opacity:1;"
         offset="0"
         id="stop2367" />
    </linearGradient>
    <linearGradient
       id="white_shade"
       gradientTransform="translate(-5.8013919e-8,2.1166665)">
      <stop
         style="stop-color:#cccccc;stop-opacity:1;"
         offset="0"
         id="stop45894" />
    </linearGradient>
    <linearGradient
       id="linearGradient45642">
      <stop
         style="stop-color:#000000;stop-opacity:0.2;"
         offset="0"
         id="stop45640" />
    </linearGradient>
    <linearGradient
       id="black_accent"
       gradientTransform="scale(0.07000432)">
      <stop
         style="stop-color:#8c8c8c;stop-opacity:1;"
         offset="0"
         id="stop52163" />
    </linearGradient>
    <linearGradient
       id="black_fill"
       gradientTransform="matrix(0.07000432,0,0,0.07000432,-53.975025,2.1166665)">
      <stop
         style="stop-color:#595959;stop-opacity:1;"
         offset="0"
         id="stop51990" />
    </linearGradient>
    <linearGradient
       xlink:href="#black_fill"
       id="linearGradient5950"
       x1="76.200043"
       y1="12.964581"
       x2="84.666718"
       y2="12.964581"
       gradientUnits="userSpaceOnUse" />
    <linearGradient
       xlink:href="#black_fill"
       id="linearGradient5952"
       x1="20.637465"
       y1="8.2020826"
       x2="31.220797"
       y2="8.2020826"
       gradientUnits="userSpaceOnUse" />
    <linearGradient
       xlink:href="#black_accent"
       id="linearGradient5980"
       x1="82.285408"
       y1="12.832289"
       x2="84.666695"
       y2="12.832289"
       gradientUnits="userSpaceOnUse" />
    <linearGradient
       xlink:href="#black_accent"
       id="linearGradient5982"
       x1="19.049967"
       y1="5.8208327"
       x2="22.224964"
       y2="5.8208327"
       gradientUnits="userSpaceOnUse" />
    <linearGradient
       xlink:href="#black_accent"
       id="linearGradient5984"
       x1="29.633301"
       y1="5.8208327"
       x2="32.8083"
       y2="5.8208327"
       gradientUnits="userSpaceOnUse" />
    <linearGradient
       xlink:href="#black_accent"
       id="linearGradient5986"
       x1="26.458298"
       y1="3.4395828"
       x2="29.633295"
       y2="3.4395828"
       gradientUnits="userSpaceOnUse" />
    <linearGradient
       xlink:href="#black_accent"
       id="linearGradient5988"
       x1="22.22497"
       y1="3.4395826"
       x2="25.399967"
       y2="3.4395826"
       gradientUnits="userSpaceOnUse" />
    <linearGradient
       xlink:href="#black_accent"
       id="linearGradient5990"
       x1="26.987465"
       y1="9.7895823"
       x2="30.427048"
       y2="9.7895823"
       gradientUnits="userSpaceOnUse" />
    <linearGradient
       xlink:href="#linearGradient45642"
       id="linearGradient23467"
       gradientUnits="userSpaceOnUse"
       gradientTransform="matrix(1,0,0,1.25,0.79374989,-3.0427069)"
       x1="4.2333326"
       y1="24.341663"
       x2="103.04872"
       y2="24.341663" />
  </defs>
  <metadata
     id="metadata505">
    <rdf:RDF>
      <cc:Work
         rdf:about="" />
    </rdf:RDF>
  </metadata>
  <g
     id="layer6"
     transform="translate(-71.96666,-17.991665)">
    <path
       style="font-variation-settings:normal;vector-effect:none;fill:url(#linearGradient23467);fill-opacity:1;stroke:none;stroke-width:1.25861;stroke-linecap:round;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;-inkscape-stroke:none;stop-color:#000000"
       d="m 5.0270826,14.816665 c 0,0.992188 2.645833,1.322916 4.2333328,1.322916 1.5874976,0 4.2333306,-0.330728 4.2333306,-1.322916 0,-0.992187 -2.778792,-1.322916 -4.2333306,-1.322916 -1.4545399,0 -4.2333328,0.330729 -4.2333328,1.322916 z"
       id="use60282"
       class="UnoptimicedTransforms"
       transform="matrix(1.215278,0,0,0.99999995,69.561533,17.991665)" />
    <g
       id="g28618-2"
       style="display:inline"
       transform="matrix(-1,0,0,1,106.36242,17.991664)">
      <path
         style="font-variation-settings:normal;display:inline;opacity:1;fill:url(#linearGradient5952);fill-opacity:1;stroke:none;stroke-width:1.05833;stroke-linecap:butt;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;stop-color:#000000;stop-opacity:1"
         d="M 22.754133,12.964582 20.637465,5.8208325 c 3.175,2.9104163 3.175,1.3229165 3.175,-2.3812496 2.116666,2.6458329 2.116666,2.6458329 4.233333,0 0,3.7041661 -0.01298,5.3096054 3.174999,2.3812496 l -2.116665,7.1437495"
         id="path45261-3" />
      <path
         style="font-variation-settings:normal;display:inline;opacity:1;fill:url(#linearGradient5990);fill-opacity:1;stroke:none;stroke-width:1.05833;stroke-linecap:butt;stroke-linejoin:round;stroke-miterlimit:2.4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;stop-color:#000000;stop-opacity:1"
         d="m 29.104131,12.964582 -2.116667,0.264583 c 0,0 1.058334,-2.645833 1.058334,-6.8791659 0.79375,1.0583332 2.381249,1.0583332 2.381249,1.0583332 0,0 -1.587499,3.7041657 -1.322916,5.5562497 z"
         id="path28748-1" />
      <path
         style="font-variation-settings:normal;display:inline;opacity:1;fill:none;fill-opacity:1;stroke:#000000;stroke-width:1.05833;stroke-linecap:butt;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;stop-color:#000000;stop-opacity:1"
         d="m 22.224965,11.112498 -1.5875,-5.2916655 c 3.175,2.9104163 3.175,1.3229165 3.175,-2.3812496 2.116666,3.4395828 2.116666,3.4395828 4.233333,0 0,3.7041661 -0.01298,5.3096054 3.174999,2.3812496 l -1.5875,5.2916655"
         id="path28743-8" />
      <ellipse
         style="font-variation-settings:normal;display:inline;fill:url(#linearGradient5988);fill-opacity:1;stroke:#000000;stroke-width:1.05833;stroke-linecap:butt;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;stop-color:#000000"
         id="ellipse127816-5-1"
         cx="23.812468"
         cy="3.4395826"
         rx="1.0583324"
         ry="1.0583333" />
      <ellipse
         style="font-variation-settings:normal;display:inline;fill:url(#linearGradient5986);fill-opacity:1;stroke:#000000;stroke-width:1.05833;stroke-linecap:butt;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;stop-color:#000000"
         id="ellipse127816-7-9"
         cx="28.045797"
         cy="3.4395828"
         rx="1.0583324"
         ry="1.0583333" />
      <ellipse
         style="font-variation-settings:normal;display:inline;fill:url(#linearGradient5984);fill-opacity:1;stroke:#000000;stroke-width:1.05833;stroke-linecap:butt;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;stop-color:#000000"
         id="ellipse127816-1-4"
         cx="31.2208"
         cy="5.8208327"
         rx="1.0583324"
         ry="1.0583333" />
      <ellipse
         style="font-variation-settings:normal;display:inline;fill:url(#linearGradient5982);fill-opacity:1;stroke:#000000;stroke-width:1.05833;stroke-linecap:butt;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;stop-color:#000000"
         id="ellipse127816-3-0"
         cx="20.637465"
         cy="5.8208327"
         rx="1.0583324"
         ry="1.0583333" />
      <path
         style="display:inline;fill:url(#linearGradient5950);fill-opacity:1;stroke:none;stroke-width:1.05833;stroke-linecap:round;stroke-linejoin:round;stroke-dasharray:none;stroke-opacity:1"
         d="m 76.464607,11.112498 c 0,0 -0.264583,2.116667 -0.264565,3.175 1.587502,0.529167 4.233337,0.529167 4.233337,0.529167 0,0 2.645835,0 4.233335,-0.529167 -1.9e-5,-1.058333 -0.264602,-3.175 -0.264602,-3.175 -1.322917,0.529167 -3.968751,0.529167 -3.968751,0.529167 0,0 -2.645835,0 -3.968754,-0.529167 z"
         id="path55930-9"
         transform="translate(-54.504191)" />
      <path
         style="font-variation-settings:normal;display:inline;fill:url(#linearGradient5980);fill-opacity:1;stroke:none;stroke-width:1.05833;stroke-linecap:butt;stroke-linejoin:round;stroke-miterlimit:2.4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;stop-color:#000000"
         d="m 83.872944,11.112498 0.79375,3.175 -1.852082,0.264583 -0.529207,-2.910416 1.587539,-0.529167"
         id="path55932-3"
         transform="translate(-54.504191)" />
      <path
         style="display:inline;fill:none;fill-opacity:1;stroke:#000000;stroke-width:1.05833;stroke-linecap:round;stroke-linejoin:round;stroke-dasharray:none;stroke-opacity:1"
         d="m 76.729154,11.112498 c 0,0 -0.52913,2.116667 -0.529112,3.175 1.587502,0.529167 4.233337,0.529167 4.233337,0.529167 0,0 2.645835,0 4.233335,-0.529167 -1.9e-5,-1.058333 -0.529226,-3.175 -0.529226,-3.175 -1.322917,0.529167 -3.704167,0.529167 -3.704167,0.529167 0,0 -2.381248,0 -3.704167,-0.529167 z"
         id="path55934-4"
         transform="translate(-54.504191)" />
      <path
         style="display:inline;fill:none;fill-opacity:1;stroke:#000000;stroke-width:1.05833;stroke-linecap:butt;stroke-linejoin:round;stroke-dasharray:none;stroke-opacity:1"
         d="m 84.402076,12.699998 c -1.32292,0.529167 -3.968746,0.529167 -3.968746,0.529167 0,0 -2.645841,0 -3.968758,-0.529167"
         id="path55936-3"
         transform="translate(-54.504191)" />
    </g>
  </g>
  <g
     id="layer5"
     style="display:none"
     transform="translate(-71.96666,-17.991665)">
    <ellipse
       style="display:inline;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1.05833;stroke-linecap:round;stroke-linejoin:round;stroke-dasharray:none;stroke-opacity:1"
       id="ellipse75320"
       cy="27.781256"
       cx="78.316658"
       ry="0.52916658"
       rx="0.52916664" />
    <ellipse
       style="display:inline;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1.05833;stroke-linecap:round;stroke-linejoin:round;stroke-dasharray:none;stroke-opacity:1"
       id="ellipse75322"
       cy="27.781256"
       cx="80.697906"
       ry="0.52916658"
       rx="0.52916664" />
    <path
       style="fill:#000000;fill-opacity:1;stroke:#000000;stroke-width:1.05833;stroke-linecap:round;stroke-linejoin:round;stroke-opacity:1;-inkscape-stroke:none;stop-color:#000000"
       d="m 80.962489,25.400008 -0.79375,0.793751"
       id="path91417" />
    <path
       style="fill:#000000;fill-opacity:1;stroke:#000000;stroke-width:1.05833;stroke-linecap:round;stroke-linejoin:round;stroke-opacity:1;-inkscape-stroke:none;stop-color:#000000"
       d="m 78.052073,25.400008 0.793749,0.793751"
       id="path91419" />
  </g>
</svg>
')} -.is2d .king.black {background-image:url('data:image/svg+xml;base64,<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<!-- Created with Inkscape (http://www.inkscape.org/) -->

<svg
   width="64.000038"
   height="64"
   viewBox="0 0 16.933341 16.933331"
   version="1.1"
   id="svg5"
   xmlns:xlink="http://www.w3.org/1999/xlink"
   xmlns="http://www.w3.org/2000/svg"
   xmlns:svg="http://www.w3.org/2000/svg"
   xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
   xmlns:cc="http://creativecommons.org/ns#">
  <defs
     id="defs2">
    <linearGradient
       id="wood_black_accent">
      <stop
         style="stop-color:#ba845f;stop-opacity:1;"
         offset="0"
         id="stop5970" />
    </linearGradient>
    <linearGradient
       id="wood_black_fill">
      <stop
         style="stop-color:#995e33;stop-opacity:1;"
         offset="0"
         id="stop5940" />
    </linearGradient>
    <linearGradient
       id="wood_white_shade">
      <stop
         style="stop-color:#d0b793;stop-opacity:1;"
         offset="0"
         id="stop3347" />
    </linearGradient>
    <linearGradient
       id="wood_white_fill">
      <stop
         style="stop-color:#f9e7d2;stop-opacity:1;"
         offset="0"
         id="stop3028" />
    </linearGradient>
    <linearGradient
       id="white_fill">
      <stop
         style="stop-color:#ffffff;stop-opacity:1;"
         offset="0"
         id="stop2367" />
    </linearGradient>
    <linearGradient
       id="white_shade"
       gradientTransform="translate(-5.8013919e-8,2.1166665)">
      <stop
         style="stop-color:#cccccc;stop-opacity:1;"
         offset="0"
         id="stop45894" />
    </linearGradient>
    <linearGradient
       id="linearGradient45642">
      <stop
         style="stop-color:#000000;stop-opacity:0.2;"
         offset="0"
         id="stop45640" />
    </linearGradient>
    <linearGradient
       id="black_accent"
       gradientTransform="scale(0.07000432)">
      <stop
         style="stop-color:#8c8c8c;stop-opacity:1;"
         offset="0"
         id="stop52163" />
    </linearGradient>
    <linearGradient
       id="black_fill"
       gradientTransform="matrix(0.07000432,0,0,0.07000432,-53.975025,2.1166665)">
      <stop
         style="stop-color:#595959;stop-opacity:1;"
         offset="0"
         id="stop51990" />
    </linearGradient>
    <linearGradient
       xlink:href="#black_fill"
       id="linearGradient5954"
       x1="25.929119"
       y1="8.5989571"
       x2="31.74995"
       y2="8.5989571"
       gradientUnits="userSpaceOnUse" />
    <linearGradient
       xlink:href="#black_fill"
       id="linearGradient5956"
       x1="21.695839"
       y1="12.964581"
       x2="30.16251"
       y2="12.964581"
       gradientUnits="userSpaceOnUse" />
    <linearGradient
       xlink:href="#black_fill"
       id="linearGradient5958"
       x1="92.074989"
       y1="8.5989571"
       x2="98.954155"
       y2="8.5989571"
       gradientUnits="userSpaceOnUse" />
    <linearGradient
       xlink:href="#black_fill"
       id="linearGradient5960"
       x1="23.283287"
       y1="7.1437492"
       x2="28.574949"
       y2="7.1437492"
       gradientUnits="userSpaceOnUse" />
    <linearGradient
       xlink:href="#black_accent"
       id="linearGradient5992"
       x1="28.04579"
       y1="8.4627514"
       x2="31.749952"
       y2="8.4627514"
       gradientUnits="userSpaceOnUse" />
    <linearGradient
       xlink:href="#black_accent"
       id="linearGradient5994"
       x1="27.7812"
       y1="12.832289"
       x2="30.162491"
       y2="12.832289"
       gradientUnits="userSpaceOnUse" />
    <linearGradient
       xlink:href="#linearGradient45642"
       id="linearGradient24909"
       gradientUnits="userSpaceOnUse"
       gradientTransform="matrix(1,0,0,1.25,0.79374989,-3.0427069)"
       x1="4.2333326"
       y1="24.341663"
       x2="103.04872"
       y2="24.341663" />
  </defs>
  <metadata
     id="metadata505">
    <rdf:RDF>
      <cc:Work
         rdf:about="" />
    </rdf:RDF>
  </metadata>
  <g
     id="layer6"
     transform="translate(-89.958321,-17.991665)">
    <path
       style="font-variation-settings:normal;vector-effect:none;fill:url(#linearGradient24909);fill-opacity:1;stroke:none;stroke-width:1.25861;stroke-linecap:round;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;-inkscape-stroke:none;stop-color:#000000"
       d="m 5.0270826,14.816665 c 0,0.992188 2.645833,1.322916 4.2333328,1.322916 1.5874976,0 4.2333306,-0.330728 4.2333306,-1.322916 0,-0.992187 -2.778792,-1.322916 -4.2333306,-1.322916 -1.4545399,0 -4.2333328,0.330729 -4.2333328,1.322916 z"
       id="use60286"
       class="UnoptimicedTransforms"
       transform="matrix(1.215278,0,0,0.99999995,87.553211,17.991665)" />
    <g
       id="g39473"
       style="display:inline"
       transform="matrix(-1,0,0,1,124.35411,17.991664)">
      <path
         style="font-variation-settings:normal;opacity:1;fill:#a6a6a6;fill-opacity:1;stroke:#000000;stroke-width:1.05833;stroke-linecap:round;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;stop-color:#000000;stop-opacity:1"
         d="M 25.929118,1.3229165 V 4.7624993"
         id="path39451" />
      <ellipse
         style="font-variation-settings:normal;display:inline;opacity:1;fill:url(#linearGradient5960);fill-opacity:1;stroke:#000000;stroke-width:1.05833;stroke-linecap:round;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;stop-color:#000000;stop-opacity:1"
         id="ellipse39453"
         cx="25.929119"
         cy="7.1437492"
         rx="2.1166663"
         ry="2.9104159" />
      <path
         style="font-variation-settings:normal;opacity:1;fill:url(#linearGradient5958);fill-opacity:1;stroke:#000000;stroke-width:1.05833;stroke-linecap:round;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;stop-color:#000000;stop-opacity:1"
         d="m 94.720821,11.112498 c 0,0 -2.116666,-1.058333 -2.116666,-3.1749991 0,-1.0583332 1.001019,-2.1166664 2.116666,-2.1166664 2.116667,0 3.704166,1.5874998 3.704166,5.5562495"
         id="path39455"
         transform="translate(-72.495869)" />
      <path
         style="display:inline;opacity:1;fill:url(#linearGradient5956);fill-opacity:1;stroke:none;stroke-width:1.05833;stroke-linecap:round;stroke-linejoin:round;stroke-dasharray:none;stroke-opacity:1"
         d="m 21.960404,11.112498 c 0,0 -0.264583,2.116667 -0.264565,3.175 1.587501,0.529167 4.233336,0.529167 4.233336,0.529167 0,0 2.645835,0 4.233335,-0.529167 -1.9e-5,-1.058333 -0.264602,-3.175 -0.264602,-3.175 -1.322917,0.529167 -3.968751,0.529167 -3.968751,0.529167 0,0 -2.645835,0 -3.968753,-0.529167 z"
         id="path39457" />
      <path
         style="font-variation-settings:normal;display:inline;opacity:1;vector-effect:none;fill:url(#linearGradient5994);fill-opacity:1;stroke:none;stroke-width:1.05833;stroke-linecap:butt;stroke-linejoin:round;stroke-miterlimit:2.4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;-inkscape-stroke:none;stop-color:#000000;stop-opacity:1"
         d="m 29.36874,11.112498 0.79375,3.175 -1.852082,0.264583 -0.529207,-2.910416 1.587539,-0.529167"
         id="path39459" />
      <path
         style="font-variation-settings:normal;display:inline;opacity:1;fill:url(#linearGradient5954);fill-opacity:1;stroke:none;stroke-width:1.05833;stroke-linecap:round;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;stop-color:#000000;stop-opacity:1"
         d="m 29.633285,11.112498 c 0,0 2.116666,-1.058333 2.116666,-3.1749991 0,-1.0583332 -1.001019,-2.1166664 -2.116666,-2.1166664 -2.116667,0 -3.704167,1.5874998 -3.704166,5.5562495"
         id="path39471" />
      <path
         style="font-variation-settings:normal;display:inline;opacity:1;fill:url(#linearGradient5992);fill-opacity:1;stroke:none;stroke-width:1.05833;stroke-linecap:round;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;stop-color:#000000;stop-opacity:1"
         d="m 28.04579,6.6145826 c 1.852083,0.2645833 2.910416,2.645833 1.5875,4.2333324 2.116665,-0.79375 2.11666,-1.5874996 2.116662,-2.910416 4e-6,-3.1749995 -3.704162,-1.3229164 -3.704162,-1.3229164 z"
         id="path39463" />
      <path
         style="font-variation-settings:normal;display:inline;opacity:1;fill:none;fill-opacity:1;stroke:#000000;stroke-width:1.05833;stroke-linecap:round;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;stop-color:#000000;stop-opacity:1"
         d="m 29.633285,11.112498 c 0,0 2.116666,-1.058333 2.116666,-3.1749991 0,-1.0583332 -1.001019,-2.1166664 -2.116666,-2.1166664 -2.116667,0 -3.704167,1.5874998 -3.704166,5.5562495"
         id="path39461" />
      <path
         style="display:inline;opacity:1;fill:none;fill-opacity:1;stroke:#000000;stroke-width:1.05833;stroke-linecap:round;stroke-linejoin:round;stroke-dasharray:none;stroke-opacity:1"
         d="m 22.224951,11.112498 c 0,0 -0.52913,2.116667 -0.529112,3.175 1.587501,0.529167 4.233336,0.529167 4.233336,0.529167 0,0 2.645835,0 4.233335,-0.529167 -1.9e-5,-1.058333 -0.529226,-3.175 -0.529226,-3.175 -1.322917,0.529167 -3.704167,0.529167 -3.704167,0.529167 0,0 -2.381248,0 -3.704166,-0.529167 z"
         id="path39465" />
      <path
         style="font-variation-settings:normal;opacity:1;fill:#a6a6a6;fill-opacity:1;stroke:#000000;stroke-width:1.05833;stroke-linecap:round;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;stop-color:#000000;stop-opacity:1"
         d="m 24.870786,2.3812497 h 2.116667"
         id="path39467" />
      <path
         style="display:inline;fill:none;fill-opacity:1;stroke:#000000;stroke-width:1.05833;stroke-linecap:butt;stroke-linejoin:round;stroke-dasharray:none;stroke-opacity:1"
         d="m 102.39374,12.699998 c -1.32292,0.529167 -3.968746,0.529167 -3.968746,0.529167 0,0 -2.645841,0 -3.968757,-0.529167"
         id="path39469"
         transform="translate(-72.495868)" />
    </g>
  </g>
  <g
     id="layer5"
     style="display:none"
     transform="translate(-89.958321,-17.991665)">
    <ellipse
       style="display:inline;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1.05833;stroke-linecap:round;stroke-linejoin:round;stroke-dasharray:none;stroke-opacity:1"
       id="ellipse75659"
       cy="30.42709"
       cx="97.895821"
       ry="0.52916658"
       rx="0.52916664" />
    <ellipse
       style="display:inline;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1.05833;stroke-linecap:round;stroke-linejoin:round;stroke-dasharray:none;stroke-opacity:1"
       id="ellipse75661"
       cy="30.42709"
       cx="96.308319"
       ry="0.52916658"
       rx="0.52916664" />
  </g>
</svg>
')} +.is2d .pawn.white {background-image:url('data:image/svg+xml;base64,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')} +.is2d .knight.white {background-image:url('data:image/svg+xml;base64,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')} +.is2d .bishop.white {background-image:url('data:image/svg+xml;base64,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')} +.is2d .rook.white {background-image:url('data:image/svg+xml;base64,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')} +.is2d .queen.white {background-image:url('data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHhtbG5zOnhsaW5rPSJodHRwOi8vd3d3LnczLm9yZy8xOTk5L3hsaW5rIiB2aWV3Qm94PSIwIDAgMTYuOTMzMzM1IDE2LjkzMzMzIj48ZGVmcz48bGluZWFyR3JhZGllbnQgaWQ9ImEiPjxzdG9wIG9mZnNldD0iMCIgc3RvcC1jb2xvcj0iI2ZmZiIvPjwvbGluZWFyR3JhZGllbnQ+PGxpbmVhckdyYWRpZW50IGlkPSJiIiBncmFkaWVudFRyYW5zZm9ybT0idHJhbnNsYXRlKC02ZS04IDIuMTE2NjY2NSkiPjxzdG9wIG9mZnNldD0iMCIgc3RvcC1jb2xvcj0iI2NjYyIvPjwvbGluZWFyR3JhZGllbnQ+PGxpbmVhckdyYWRpZW50IGlkPSJjIj48c3RvcCBvZmZzZXQ9IjAiIHN0b3Atb3BhY2l0eT0iLjIiLz48L2xpbmVhckdyYWRpZW50PjxsaW5lYXJHcmFkaWVudCB4bGluazpocmVmPSIjYSIgaWQ9ImsiIHgxPSI3Ni4yMDAwNDMiIHgyPSI4NC42NjY3MTgiIHkxPSIxMi45NjQ1ODEiIHkyPSIxMi45NjQ1ODEiIGdyYWRpZW50VW5pdHM9InVzZXJTcGFjZU9uVXNlIi8+PGxpbmVhckdyYWRpZW50IHhsaW5rOmhyZWY9IiNhIiBpZD0iaiIgeDE9IjE5LjA0OTk2NyIgeDI9IjIyLjIyNDk2MiIgeTE9IjUuODIwODMyNyIgeTI9IjUuODIwODMyNyIgZ3JhZGllbnRVbml0cz0idXNlclNwYWNlT25Vc2UiLz48bGluZWFyR3JhZGllbnQgeGxpbms6aHJlZj0iI2EiIGlkPSJpIiB4MT0iMjkuNjMzMzAzIiB4Mj0iMzIuODA4Mjk2IiB5MT0iNS44MjA4MzI3IiB5Mj0iNS44MjA4MzI3IiBncmFkaWVudFVuaXRzPSJ1c2VyU3BhY2VPblVzZSIvPjxsaW5lYXJHcmFkaWVudCB4bGluazpocmVmPSIjYSIgaWQ9ImgiIHgxPSIyNi40NTgzIiB4Mj0iMjkuNjMzMjk1IiB5MT0iMy40Mzk1ODI4IiB5Mj0iMy40Mzk1ODI4IiBncmFkaWVudFVuaXRzPSJ1c2VyU3BhY2VPblVzZSIvPjxsaW5lYXJHcmFkaWVudCB4bGluazpocmVmPSIjYSIgaWQ9ImciIHgxPSIyMi4yMjQ5NyIgeDI9IjI1LjM5OTk2NSIgeTE9IjMuNDM5NTgyNiIgeTI9IjMuNDM5NTgyNiIgZ3JhZGllbnRVbml0cz0idXNlclNwYWNlT25Vc2UiLz48bGluZWFyR3JhZGllbnQgeGxpbms6aHJlZj0iI2EiIGlkPSJlIiB4MT0iMjAuNjM3NDY1IiB4Mj0iMzEuMjIwNzk3IiB5MT0iOC4yMDIwODI2IiB5Mj0iOC4yMDIwODI2IiBncmFkaWVudFVuaXRzPSJ1c2VyU3BhY2VPblVzZSIvPjxsaW5lYXJHcmFkaWVudCB4bGluazpocmVmPSIjYiIgaWQ9ImwiIGdyYWRpZW50VHJhbnNmb3JtPSJ0cmFuc2xhdGUoLTZlLTggMi4xMTY2NjY1KSIgZ3JhZGllbnRVbml0cz0idXNlclNwYWNlT25Vc2UiLz48bGluZWFyR3JhZGllbnQgeGxpbms6aHJlZj0iI2IiIGlkPSJmIiBncmFkaWVudFRyYW5zZm9ybT0idHJhbnNsYXRlKC02ZS04IDIuMTE2NjY2NSkiIGdyYWRpZW50VW5pdHM9InVzZXJTcGFjZU9uVXNlIi8+PGxpbmVhckdyYWRpZW50IHhsaW5rOmhyZWY9IiNjIiBpZD0iZCIgeDE9IjQuMjMzMzMyNiIgeDI9IjEwMy4wNDg3MiIgeTE9IjI0LjM0MTY2MyIgeTI9IjI0LjM0MTY2MyIgZ3JhZGllbnRUcmFuc2Zvcm09Im1hdHJpeCgxIDAgMCAxLjI1IC43OTM3NDk4OSAtMy4wNDI3MDY5KSIgZ3JhZGllbnRVbml0cz0idXNlclNwYWNlT25Vc2UiLz48L2RlZnM+PHBhdGggZmlsbD0idXJsKCNkKSIgZD0iTTUuMDI3MDgyNiAxNC44MTY2NjVjMCAuOTkyMTg4IDIuNjQ1ODMzIDEuMzIyOTE2IDQuMjMzMzMyOCAxLjMyMjkxNiAxLjU4NzQ5NzYgMCA0LjIzMzMzMDYtLjMzMDcyOCA0LjIzMzMzMDYtMS4zMjI5MTYgMC0uOTkyMTg3LTIuNzc4NzkyLTEuMzIyOTE2LTQuMjMzMzMwNi0xLjMyMjkxNi0xLjQ1NDUzOTkgMC00LjIzMzMzMjguMzMwNzI5LTQuMjMzMzMyOCAxLjMyMjkxNnoiIGNsYXNzPSJVbm9wdGltaWNlZFRyYW5zZm9ybXMiIHN0eWxlPSJmb250LXZhcmlhdGlvbi1zZXR0aW5nczpub3JtYWw7LWlua3NjYXBlLXN0cm9rZTpub25lIiB0cmFuc2Zvcm09Im1hdHJpeCgxLjIxNTI4IDAgMCAxIC0yLjQwNTExOCA5LjZlLTcpIi8+PGcgdHJhbnNmb3JtPSJ0cmFuc2xhdGUoLTE3LjQ2MjQ2MSkiPjxwYXRoIGZpbGw9InVybCgjZSkiIGQ9Im0yMi43NTQxMzMgMTIuOTY0NTgyLTIuMTE2NjY4LTcuMTQzNzQ5NWMzLjE3NSAyLjkxMDQxNjMgMy4xNzUgMS4zMjI5MTY1IDMuMTc1LTIuMzgxMjQ5NiAyLjExNjY2NiAyLjY0NTgzMjkgMi4xMTY2NjYgMi42NDU4MzI5IDQuMjMzMzMzIDAgMCAzLjcwNDE2NjEtLjAxMjk4IDUuMzA5NjA1NCAzLjE3NDk5OSAyLjM4MTI0OTZsLTIuMTE2NjY1IDcuMTQzNzQ5NSIgc3R5bGU9ImZvbnQtdmFyaWF0aW9uLXNldHRpbmdzOm5vcm1hbCIvPjxwYXRoIGZpbGw9InVybCgjZikiIGQ9Im0yOS4xMDQxMzEgMTIuOTY0NTgyLTIuMTE2NjY3LjI2NDU4M3MxLjA1ODMzNC0yLjY0NTgzMyAxLjA1ODMzNC02Ljg3OTE2NTljLjc5Mzc1IDEuMDU4MzMzMiAyLjM4MTI0OSAxLjA1ODMzMzIgMi4zODEyNDkgMS4wNTgzMzMycy0xLjU4NzQ5OSAzLjcwNDE2NTctMS4zMjI5MTYgNS41NTYyNDk3eiIgc3R5bGU9ImZvbnQtdmFyaWF0aW9uLXNldHRpbmdzOm5vcm1hbDstaW5rc2NhcGUtc3Ryb2tlOm5vbmUiLz48cGF0aCBmaWxsPSJub25lIiBzdHJva2U9IiMwMDAiIHN0cm9rZS1saW5lam9pbj0icm91bmQiIHN0cm9rZS13aWR0aD0iMS4wNTgzMyIgZD0ibTIyLjIyNDk2NSAxMS4xMTI0OTgtMS41ODc1LTUuMjkxNjY1NWMzLjE3NSAyLjkxMDQxNjMgMy4xNzUgMS4zMjI5MTY1IDMuMTc1LTIuMzgxMjQ5NiAyLjExNjY2NiAzLjQzOTU4MjggMi4xMTY2NjYgMy40Mzk1ODI4IDQuMjMzMzMzIDAgMCAzLjcwNDE2NjEtLjAxMjk4IDUuMzA5NjA1NCAzLjE3NDk5OSAyLjM4MTI0OTZsLTEuNTg3NSA1LjI5MTY2NTUiIHN0eWxlPSJmb250LXZhcmlhdGlvbi1zZXR0aW5nczpub3JtYWwiLz48ZWxsaXBzZSBjeD0iMjMuODEyNDY4IiBjeT0iMy40Mzk1ODI2IiBmaWxsPSJ1cmwoI2cpIiBzdHJva2U9IiMwMDAiIHN0cm9rZS1saW5lam9pbj0icm91bmQiIHN0cm9rZS13aWR0aD0iMS4wNTgzMyIgcng9IjEuMDU4MzMyNCIgcnk9IjEuMDU4MzMzMyIgc3R5bGU9ImZvbnQtdmFyaWF0aW9uLXNldHRpbmdzOm5vcm1hbDstaW5rc2NhcGUtc3Ryb2tlOm5vbmUiLz48ZWxsaXBzZSBjeD0iMjguMDQ1Nzk3IiBjeT0iMy40Mzk1ODI4IiBmaWxsPSJ1cmwoI2gpIiBzdHJva2U9IiMwMDAiIHN0cm9rZS1saW5lam9pbj0icm91bmQiIHN0cm9rZS13aWR0aD0iMS4wNTgzMyIgcng9IjEuMDU4MzMyNCIgcnk9IjEuMDU4MzMzMyIgc3R5bGU9ImZvbnQtdmFyaWF0aW9uLXNldHRpbmdzOm5vcm1hbDstaW5rc2NhcGUtc3Ryb2tlOm5vbmUiLz48ZWxsaXBzZSBjeD0iMzEuMjIwOCIgY3k9IjUuODIwODMyNyIgZmlsbD0idXJsKCNpKSIgc3Ryb2tlPSIjMDAwIiBzdHJva2UtbGluZWpvaW49InJvdW5kIiBzdHJva2Utd2lkdGg9IjEuMDU4MzMiIHJ4PSIxLjA1ODMzMjQiIHJ5PSIxLjA1ODMzMzMiIHN0eWxlPSJmb250LXZhcmlhdGlvbi1zZXR0aW5nczpub3JtYWw7LWlua3NjYXBlLXN0cm9rZTpub25lIi8+PGVsbGlwc2UgY3g9IjIwLjYzNzQ2NSIgY3k9IjUuODIwODMyNyIgZmlsbD0idXJsKCNqKSIgc3Ryb2tlPSIjMDAwIiBzdHJva2UtbGluZWpvaW49InJvdW5kIiBzdHJva2Utd2lkdGg9IjEuMDU4MzMiIHJ4PSIxLjA1ODMzMjQiIHJ5PSIxLjA1ODMzMzMiIHN0eWxlPSJmb250LXZhcmlhdGlvbi1zZXR0aW5nczpub3JtYWw7LWlua3NjYXBlLXN0cm9rZTpub25lIi8+PHBhdGggZmlsbD0idXJsKCNrKSIgZD0iTTc2LjQ2NDYwNyAxMS4xMTI0OThzLS4yNjQ1ODMgMi4xMTY2NjctLjI2NDU2NSAzLjE3NWMxLjU4NzUwMi41MjkxNjcgNC4yMzMzMzcuNTI5MTY3IDQuMjMzMzM3LjUyOTE2N3MyLjY0NTgzNSAwIDQuMjMzMzM1LS41MjkxNjdjLS4wMDAwMTktMS4wNTgzMzMtLjI2NDYwMi0zLjE3NS0uMjY0NjAyLTMuMTc1LTEuMzIyOTE3LjUyOTE2Ny0zLjk2ODc1MS41MjkxNjctMy45Njg3NTEuNTI5MTY3cy0yLjY0NTgzNSAwLTMuOTY4NzU0LS41MjkxNjd6IiB0cmFuc2Zvcm09InRyYW5zbGF0ZSgtNTQuNTA0MTkxKSIvPjxwYXRoIGZpbGw9InVybCgjbCkiIGQ9Im04My44NzI5NDQgMTEuMTEyNDk4Ljc5Mzc1IDMuMTc1LTEuODUyMDgyLjI2NDU4My0uNTI5MjA3LTIuOTEwNDE2IDEuNTg3NTM5LS41MjkxNjciIHN0eWxlPSJmb250LXZhcmlhdGlvbi1zZXR0aW5nczpub3JtYWw7LWlua3NjYXBlLXN0cm9rZTpub25lIiB0cmFuc2Zvcm09InRyYW5zbGF0ZSgtNTQuNTA0MTkxKSIvPjxwYXRoIGZpbGw9Im5vbmUiIHN0cm9rZT0iIzAwMCIgc3Ryb2tlLWxpbmVjYXA9InJvdW5kIiBzdHJva2UtbGluZWpvaW49InJvdW5kIiBzdHJva2Utd2lkdGg9IjEuMDU4MzMiIGQ9Ik0yMi4yMjQ5NjMgMTEuMTEyNDk4cy0uNTI5MTMgMi4xMTY2NjctLjUyOTExMiAzLjE3NWMxLjU4NzUwMi41MjkxNjcgNC4yMzMzMzcuNTI5MTY3IDQuMjMzMzM3LjUyOTE2N3MyLjY0NTgzNSAwIDQuMjMzMzM1LS41MjkxNjdjLS4wMDAwMTktMS4wNTgzMzMtLjUyOTIyNi0zLjE3NS0uNTI5MjI2LTMuMTc1LTEuMzIyOTE3LjUyOTE2Ny0zLjcwNDE2Ny41MjkxNjctMy43MDQxNjcuNTI5MTY3cy0yLjM4MTI0OCAwLTMuNzA0MTY3LS41MjkxNjd6Ii8+PHBhdGggZmlsbD0ibm9uZSIgc3Ryb2tlPSIjMDAwIiBzdHJva2UtbGluZWpvaW49InJvdW5kIiBzdHJva2Utd2lkdGg9IjEuMDU4MzMiIGQ9Ik0yOS44OTc4ODUgMTIuNjk5OTk4Yy0xLjMyMjkyLjUyOTE2Ny0zLjk2ODc0Ni41MjkxNjctMy45Njg3NDYuNTI5MTY3cy0yLjY0NTg0MSAwLTMuOTY4NzU4LS41MjkxNjciLz48L2c+PC9zdmc+')} +.is2d .king.white {background-image:url('data:image/svg+xml;base64,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')} +.is2d .pawn.black {background-image:url('data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHhtbG5zOnhsaW5rPSJodHRwOi8vd3d3LnczLm9yZy8xOTk5L3hsaW5rIiB2aWV3Qm94PSIwIDAgMTYuOTMzMzMgMTYuOTMzMzMxIj48ZGVmcz48bGluZWFyR3JhZGllbnQgaWQ9ImMiPjxzdG9wIG9mZnNldD0iMCIgc3RvcC1vcGFjaXR5PSIuMiIvPjwvbGluZWFyR3JhZGllbnQ+PGxpbmVhckdyYWRpZW50IGlkPSJiIiBncmFkaWVudFRyYW5zZm9ybT0ic2NhbGUoLjA3KSI+PHN0b3Agb2Zmc2V0PSIwIiBzdG9wLWNvbG9yPSIjOGM4YzhjIi8+PC9saW5lYXJHcmFkaWVudD48bGluZWFyR3JhZGllbnQgaWQ9ImEiIGdyYWRpZW50VHJhbnNmb3JtPSJtYXRyaXgoLjA3IDAgMCAuMDcgLTUzLjk3NTAyNSAyLjExNjY2NjUpIj48c3RvcCBvZmZzZXQ9IjAiIHN0b3AtY29sb3I9IiM1OTU5NTkiLz48L2xpbmVhckdyYWRpZW50PjxsaW5lYXJHcmFkaWVudCB4bGluazpocmVmPSIjYSIgaWQ9ImUiIHgxPSI0Ljc2MjQ5OTMiIHgyPSIxMi4xNzA4MzIiIHkxPSI5LjUyNDk5ODciIHkyPSI5LjUyNDk5ODciIGdyYWRpZW50VW5pdHM9InVzZXJTcGFjZU9uVXNlIi8+PGxpbmVhckdyYWRpZW50IHhsaW5rOmhyZWY9IiNiIiBpZD0iZiIgeDE9IjQuNzYyNDk5MyIgeDI9IjguOTk1ODMyNCIgeTE9IjkuNjExMDg2OCIgeTI9IjkuNjExMDg2OCIgZ3JhZGllbnRVbml0cz0idXNlclNwYWNlT25Vc2UiLz48bGluZWFyR3JhZGllbnQgeGxpbms6aHJlZj0iI2MiIGlkPSJkIiB4MT0iNC4yMzMzMzI2IiB4Mj0iMTAzLjA0ODcyIiB5MT0iMjQuMzQxNjYzIiB5Mj0iMjQuMzQxNjYzIiBncmFkaWVudFRyYW5zZm9ybT0ibWF0cml4KDEgMCAwIDEuMjUgLjc5Mzc0OTg5IC0zLjA0MjcwNjkpIiBncmFkaWVudFVuaXRzPSJ1c2VyU3BhY2VPblVzZSIvPjwvZGVmcz48cGF0aCBmaWxsPSJ1cmwoI2QpIiBkPSJNNS4wMjcwODI2IDE0LjgxNjY2NWMwIC45OTIxODggMi42NDU4MzMgMS4zMjI5MTYgNC4yMzMzMzI4IDEuMzIyOTE2IDEuNTg3NDk3NiAwIDQuMjMzMzMwNi0uMzMwNzI4IDQuMjMzMzMwNi0xLjMyMjkxNiAwLS45OTIxODctMi43Nzg3OTItMS4zMjI5MTYtNC4yMzMzMzA2LTEuMzIyOTE2LTEuNDU0NTM5OSAwLTQuMjMzMzMyOC4zMzA3MjktNC4yMzMzMzI4IDEuMzIyOTE2eiIgY2xhc3M9IlVub3B0aW1pY2VkVHJhbnNmb3JtcyIgc3R5bGU9ImZvbnQtdmFyaWF0aW9uLXNldHRpbmdzOm5vcm1hbDstaW5rc2NhcGUtc3Ryb2tlOm5vbmUiIHRyYW5zZm9ybT0ibWF0cml4KDEuMDkzNzUgMCAwIDEgLTEuMjY1MDQwNjYgMCkiLz48cGF0aCBmaWxsPSJ1cmwoI2UpIiBkPSJNNC43NjI0OTkzIDE0LjI4NzQ5OGMxLjU4NzQ5OTguNTI5MTY3IDMuNzA0MTY2My41MjkxNjcgMy43MDQxNjYzLjUyOTE2N3MyLjExNjY2NjQgMCAzLjcwNDE2NjQtLjUyOTE2N2MwLTIuMTE2NjY2LS43OTM3NS0yLjY0NTgzMy0yLjM4MTI1LTQuMjMzMzMzIDEuNTg3NS0xLjU4NzQ5OTUuNzkzNzUtMi42NDU4MzI3LS4yNjQ1ODMzLTMuNzA0MTY1OS43OTM3NTAzLS43OTM3NDk5IDAtMi4xMTY2NjYzLTEuMDU4MzMzMi0yLjExNjY2NjNTNi42MTQ1ODI0IDUuNTU2MjQ5MiA3LjQwODMzMjMgNi4zNDk5OTkxQzYuMzQ5OTk5MSA3LjQwODMzMjMgNS41NTYyNDkyIDguNDY2NjY1NSA3LjE0Mzc0OSAxMC4wNTQxNjVjLTEuNTg3NDk5OCAxLjU4NzUtMi4zODEyNDk3IDIuMTE2NjY3LTIuMzgxMjQ5NyA0LjIzMzMzM3oiIHRyYW5zZm9ybT0idHJhbnNsYXRlKC01LjJlLTcgLS4wMDAwMDEpIi8+PHBhdGggZmlsbD0idXJsKCNmKSIgZD0ibTQuNzYyNDk5NCAxNC4yODc0OTggMS44NTIwODMxLjUyOTE2N2MtMWUtNy0yLjExNjY2NyAxLjU4NzQ5OTktMy45Njg3NSAxLjMyMjkxNjQtNC43NjI1LS4yNjQ1ODMzLS43OTM3NDk2LS4yNjQ1ODMzLTEuMDU4MzMyOS0uMjY0NTgzMy0xLjU4NzQ5OTUgMC0xLjA1ODMzMzIuNzkzNzQ5OS0xLjMyMjkxNjUuNTI5MTY2Ni0yLjExNjY2NjQtLjI2NDU4MzMtLjc5Mzc0OTkgMC0xLjU4NzQ5OTguNzkzNzQ5OS0xLjg1MjA4MzEtMS4zMjI5MTY1LS41MjkxNjY2LTEuNjQzNjM0MiAxLjM2NTcwMjMtMS44NTIwODMxIDEuODUyMDgzMS0uMzM4NTg5MS43OTAwNDEzLTEuMDU4MzMzMiAyLjM4MTI0OTcgMCAzLjcwNDE2NTktMS44NTIwODMxIDEuNTg3NS0yLjM4MTI0OTYgMy43MjE3MzktMi4zODEyNDk2IDQuMjMzMzMzeiIgdHJhbnNmb3JtPSJ0cmFuc2xhdGUoLTUuMmUtNyAtLjAwMDAwMSkiLz48cGF0aCBmaWxsPSJub25lIiBzdHJva2U9IiMwMDAiIHN0cm9rZS1saW5lY2FwPSJyb3VuZCIgc3Ryb2tlLWxpbmVqb2luPSJyb3VuZCIgc3Ryb2tlLXdpZHRoPSIxLjA1ODMzIiBkPSJNNC43NjI0OTg3OCAxNC4yODc0OTdjMS41ODc0OTk4LjUyOTE2NyAzLjcwNDE2NjMuNTI5MTY3IDMuNzA0MTY2My41MjkxNjdzMi4xMTY2NjY0IDAgMy43MDQxNjY0LS41MjkxNjdjMC0yLjExNjY2Ni0uNzkzNzUtMi42NDU4MzMtMi4zODEyNS00LjIzMzMzMyAxLjU4NzUtMS41ODc0OTk1Ljc5Mzc1LTIuNjQ1ODMyNy0uMjY0NTgzMy0zLjcwNDE2NTkuNzkzNzUwMy0uNzkzNzQ5OSAwLTIuMTE2NjY2My0xLjA1ODMzMzItMi4xMTY2NjYzcy0xLjg1MjA4MzEgMS4zMjI5MTY0LTEuMDU4MzMzMiAyLjExNjY2NjNjLTEuMDU4MzMzMiAxLjA1ODMzMzItMS44NTIwODMxIDIuMTE2NjY2NC0uMjY0NTgzMyAzLjcwNDE2NTktMS41ODc0OTk4IDEuNTg3NS0yLjM4MTI0OTcgMi4xMTY2NjctMi4zODEyNDk3IDQuMjMzMzMzeiIvPjwvc3ZnPg==')} +.is2d .knight.black {background-image:url('data:image/svg+xml;base64,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')} +.is2d .bishop.black {background-image:url('data:image/svg+xml;base64,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')} +.is2d .rook.black {background-image:url('data:image/svg+xml;base64,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')} +.is2d .queen.black {background-image:url('data:image/svg+xml;base64,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')} +.is2d .king.black {background-image:url('data:image/svg+xml;base64,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')} diff --git a/public/piece/caliente/bB.svg b/public/piece/caliente/bB.svg index 4935501e0ef2e..97efccbf874a8 100644 --- a/public/piece/caliente/bB.svg +++ b/public/piece/caliente/bB.svg @@ -1,205 +1 @@ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + \ No newline at end of file diff --git a/public/piece/caliente/bK.svg b/public/piece/caliente/bK.svg index 435def07cb935..28a36438750bc 100644 --- a/public/piece/caliente/bK.svg +++ b/public/piece/caliente/bK.svg @@ -1,231 +1 @@ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + \ No newline at end of file diff --git a/public/piece/caliente/bN.svg b/public/piece/caliente/bN.svg index c416437d88e6d..aa1590b3bce43 100644 --- a/public/piece/caliente/bN.svg +++ b/public/piece/caliente/bN.svg @@ -1,166 +1 @@ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + \ No newline at end of file diff --git a/public/piece/caliente/bP.svg b/public/piece/caliente/bP.svg index 08eeb11d80f09..73ceb65b70144 100644 --- a/public/piece/caliente/bP.svg +++ b/public/piece/caliente/bP.svg @@ -1,143 +1 @@ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + \ No newline at end of file diff --git a/public/piece/caliente/bQ.svg b/public/piece/caliente/bQ.svg index 343805525b364..71b790fde257e 100644 --- a/public/piece/caliente/bQ.svg +++ b/public/piece/caliente/bQ.svg @@ -1,266 +1 @@ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + \ No newline at end of file diff --git a/public/piece/caliente/bR.svg b/public/piece/caliente/bR.svg index e7a78ae2d0bf4..313d8fc10cb49 100644 --- a/public/piece/caliente/bR.svg +++ b/public/piece/caliente/bR.svg @@ -1,226 +1 @@ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + \ No newline at end of file diff --git a/public/piece/caliente/wB.svg b/public/piece/caliente/wB.svg index 9c1d32b054bb5..2fb7d754e8962 100644 --- a/public/piece/caliente/wB.svg +++ b/public/piece/caliente/wB.svg @@ -1,198 +1 @@ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + \ No newline at end of file diff --git a/public/piece/caliente/wK.svg b/public/piece/caliente/wK.svg index bcae54ae99066..32291bab79f78 100644 --- a/public/piece/caliente/wK.svg +++ b/public/piece/caliente/wK.svg @@ -1,225 +1 @@ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + \ No newline at end of file diff --git a/public/piece/caliente/wN.svg b/public/piece/caliente/wN.svg index 695bcbb8a868c..f1bbcd14a0acf 100644 --- a/public/piece/caliente/wN.svg +++ b/public/piece/caliente/wN.svg @@ -1,156 +1 @@ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + \ No newline at end of file diff --git a/public/piece/caliente/wP.svg b/public/piece/caliente/wP.svg index 103fc9b2156f8..09e31d9b1fb05 100644 --- a/public/piece/caliente/wP.svg +++ b/public/piece/caliente/wP.svg @@ -1,138 +1 @@ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + \ No newline at end of file diff --git a/public/piece/caliente/wQ.svg b/public/piece/caliente/wQ.svg index fef54e18f6a54..fe1af43da9bad 100644 --- a/public/piece/caliente/wQ.svg +++ b/public/piece/caliente/wQ.svg @@ -1,260 +1 @@ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + \ No newline at end of file diff --git a/public/piece/caliente/wR.svg b/public/piece/caliente/wR.svg index 746ed7b0bc71e..9bbf690c4602e 100644 --- a/public/piece/caliente/wR.svg +++ b/public/piece/caliente/wR.svg @@ -1,217 +1 @@ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + \ No newline at end of file From ed086ca8281858de3b79e2c438cf0d5759170dd7 Mon Sep 17 00:00:00 2001 From: kraktus Date: Sat, 15 Jun 2024 15:05:48 +0200 Subject: [PATCH 053/168] Appeal: display "my mark" after isolating an account --- modules/mod/src/main/ModlogApi.scala | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/modules/mod/src/main/ModlogApi.scala b/modules/mod/src/main/ModlogApi.scala index 8cdf6c3462b66..7e939d7371aef 100644 --- a/modules/mod/src/main/ModlogApi.scala +++ b/modules/mod/src/main/ModlogApi.scala @@ -22,7 +22,7 @@ final class ModlogApi(repo: ModlogRepo, userRepo: UserRepo, ircApi: IrcApi, pres private given Conversion[Me, ModId] = _.modId private val markActions = - List(Modlog.alt, Modlog.booster, Modlog.closeAccount, Modlog.engine, Modlog.troll, Modlog.rankban) + List(Modlog.alt, Modlog.booster, Modlog.closeAccount, Modlog.engine, Modlog.troll, Modlog.rankban, Modlog.isolate) def streamerDecline(streamerId: UserId)(using MyId) = add: Modlog(streamerId.some, Modlog.streamerDecline) From 1dd4e95fe009348585cdd49135a5ebea02ca8482 Mon Sep 17 00:00:00 2001 From: kraktus Date: Sat, 15 Jun 2024 15:06:41 +0200 Subject: [PATCH 054/168] scalafmt --- modules/mod/src/main/ModlogApi.scala | 10 +++++++++- 1 file changed, 9 insertions(+), 1 deletion(-) diff --git a/modules/mod/src/main/ModlogApi.scala b/modules/mod/src/main/ModlogApi.scala index 7e939d7371aef..4722e03d9f8b6 100644 --- a/modules/mod/src/main/ModlogApi.scala +++ b/modules/mod/src/main/ModlogApi.scala @@ -22,7 +22,15 @@ final class ModlogApi(repo: ModlogRepo, userRepo: UserRepo, ircApi: IrcApi, pres private given Conversion[Me, ModId] = _.modId private val markActions = - List(Modlog.alt, Modlog.booster, Modlog.closeAccount, Modlog.engine, Modlog.troll, Modlog.rankban, Modlog.isolate) + List( + Modlog.alt, + Modlog.booster, + Modlog.closeAccount, + Modlog.engine, + Modlog.troll, + Modlog.rankban, + Modlog.isolate + ) def streamerDecline(streamerId: UserId)(using MyId) = add: Modlog(streamerId.some, Modlog.streamerDecline) From 15c7ad02ddf5f5073cfee146b4ecdc2d051449ec Mon Sep 17 00:00:00 2001 From: kraktus Date: Sat, 15 Jun 2024 15:07:20 +0200 Subject: [PATCH 055/168] remove debug from broadcast crowd monitoring api --- modules/relay/src/main/RelayApi.scala | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/modules/relay/src/main/RelayApi.scala b/modules/relay/src/main/RelayApi.scala index b29b071a4de2b..f115665a50419 100644 --- a/modules/relay/src/main/RelayApi.scala +++ b/modules/relay/src/main/RelayApi.scala @@ -410,7 +410,7 @@ final class RelayApi( private[relay] def monitorCrowd: Funit = roundRepo.tourCrowds.map: crowds => - crowds.pp.foreach: (tourId, crowd) => + crowds.foreach: (tourId, crowd) => lila.mon.relay.tourCrowd(tourId).update(crowd) private[relay] def WithRelay[A: Zero](id: RelayRoundId)(f: RelayRound => Fu[A]): Fu[A] = From f872ad973b5a97c1ca7cb03e35aef665d8d2c290 Mon Sep 17 00:00:00 2001 From: Thibault Duplessis Date: Sat, 15 Jun 2024 15:16:21 +0200 Subject: [PATCH 056/168] delete bin/relay --- bin/relay/package.json | 15 --------------- bin/relay/server.js | 43 ------------------------------------------ bin/relay/yarn.lock | 25 ------------------------ 3 files changed, 83 deletions(-) delete mode 100644 bin/relay/package.json delete mode 100644 bin/relay/server.js delete mode 100644 bin/relay/yarn.lock diff --git a/bin/relay/package.json b/bin/relay/package.json deleted file mode 100644 index 8f288991d1811..0000000000000 --- a/bin/relay/package.json +++ /dev/null @@ -1,15 +0,0 @@ -{ - "name": "pgnstudyrelay-data", - "version": "1.0.0", - "description": "As an example, gct-09 has a complete set of files from before the games started until after they end", - "main": "server.js", - "scripts": { - "test": "echo \"Error: no test specified\" && exit 1", - "start": "node server.js" - }, - "author": "", - "license": "ISC", - "dependencies": { - "fs-extra": "^4.0.2" - } -} diff --git a/bin/relay/server.js b/bin/relay/server.js deleted file mode 100644 index 6ecb67b58e70d..0000000000000 --- a/bin/relay/server.js +++ /dev/null @@ -1,43 +0,0 @@ -const http = require('http'); -const fs = require('fs-extra'); - -const port = parseInt(process.argv[2]); -const dir = process.argv[3]; -const delay = parseInt(process.argv[4] || 1000); - -let files, - file, - completion = -1; - -fs.readdir(dir).then(list => { - files = list.filter(n => n.endsWith('.pgn')); - serveIndex(0); -}); - -function serveIndex(index) { - if (!files[index]) index = 0; - const percent = Math.floor((index * 100) / files.length); - if (percent > completion) { - completion = percent; - console.log(`${percent}%`); - } - file = files[index]; - setTimeout(() => serveIndex(index + 1, delay), delay); -} - -http - .createServer((request, response) => { - const path = `${dir}/${file}`; - return fs - .readFile(path, { - encoding: 'utf8', - }) - .then(content => { - console.log(`${path} ${content.length}`); - response.end(content); - }); - }) - .listen(port, err => { - if (err) return console.log(err); - console.log(`server is listening on ${port}`); - }); diff --git a/bin/relay/yarn.lock b/bin/relay/yarn.lock deleted file mode 100644 index f36b9aa6d04cf..0000000000000 --- a/bin/relay/yarn.lock +++ /dev/null @@ -1,25 +0,0 @@ -# THIS IS AN AUTOGENERATED FILE. DO NOT EDIT THIS FILE DIRECTLY. -# yarn lockfile v1 - - -fs-extra@^4.0.2: - version "4.0.2" - resolved "https://registry.yarnpkg.com/fs-extra/-/fs-extra-4.0.2.tgz#f91704c53d1b461f893452b0c307d9997647ab6b" - dependencies: - graceful-fs "^4.1.2" - jsonfile "^4.0.0" - universalify "^0.1.0" - -graceful-fs@^4.1.2, graceful-fs@^4.1.6: - version "4.1.11" - resolved "https://registry.yarnpkg.com/graceful-fs/-/graceful-fs-4.1.11.tgz#0e8bdfe4d1ddb8854d64e04ea7c00e2a026e5658" - -jsonfile@^4.0.0: - version "4.0.0" - resolved "https://registry.yarnpkg.com/jsonfile/-/jsonfile-4.0.0.tgz#8771aae0799b64076b76640fca058f9c10e33ecb" - optionalDependencies: - graceful-fs "^4.1.6" - -universalify@^0.1.0: - version "0.1.1" - resolved "https://registry.yarnpkg.com/universalify/-/universalify-0.1.1.tgz#fa71badd4437af4c148841e3b3b165f9e9e590b7" From a3b524381e698e92d3cdd6038c7aa7ba1ed55ba4 Mon Sep 17 00:00:00 2001 From: Trevor Fitzgerald Date: Sat, 15 Jun 2024 09:33:31 -0400 Subject: [PATCH 057/168] Add study flair to json page view --- modules/study/src/main/JsonView.scala | 24 +++++++++++++----------- 1 file changed, 13 insertions(+), 11 deletions(-) diff --git a/modules/study/src/main/JsonView.scala b/modules/study/src/main/JsonView.scala index 200d4e35725fd..cb85ddc58e5ca 100644 --- a/modules/study/src/main/JsonView.scala +++ b/modules/study/src/main/JsonView.scala @@ -80,17 +80,19 @@ final class JsonView( .pipe(addChapterMode(c)) def pagerData(s: Study.WithChaptersAndLiked) = - Json.obj( - "id" -> s.study.id, - "name" -> s.study.name, - "liked" -> s.liked, - "likes" -> s.study.likes, - "updatedAt" -> s.study.updatedAt, - "owner" -> lightUserApi.sync(s.study.ownerId), - "chapters" -> s.chapters.take(Study.previewNbChapters), - "topics" -> s.study.topicsOrEmpty, - "members" -> s.study.members.members.values.take(Study.previewNbMembers) - ) + Json + .obj( + "id" -> s.study.id, + "name" -> s.study.name, + "liked" -> s.liked, + "likes" -> s.study.likes, + "updatedAt" -> s.study.updatedAt, + "owner" -> lightUserApi.sync(s.study.ownerId), + "chapters" -> s.chapters.take(Study.previewNbChapters), + "topics" -> s.study.topicsOrEmpty, + "members" -> s.study.members.members.values.take(Study.previewNbMembers) + ) + .add("flair", s.study.flair) private def addChapterMode(c: Chapter)(js: JsObject): JsObject = js.add("practice", c.isPractice) From 58a0ed56ba66b9c2f50c303904056f3109421b4b Mon Sep 17 00:00:00 2001 From: Thanh Le Date: Sat, 15 Jun 2024 19:20:19 +0700 Subject: [PATCH 058/168] Stop using http request to index forum posts We use lila-search's ingestor instead --- modules/core/src/main/forum.scala | 2 -- modules/forum/src/main/ForumDelete.scala | 9 ++++----- modules/forum/src/main/ForumPostApi.scala | 5 +---- modules/forumSearch/src/main/Env.scala | 6 +----- 4 files changed, 6 insertions(+), 16 deletions(-) diff --git a/modules/core/src/main/forum.scala b/modules/core/src/main/forum.scala index 69840a3a78704..3493b6e9a0d33 100644 --- a/modules/core/src/main/forum.scala +++ b/modules/core/src/main/forum.scala @@ -10,9 +10,7 @@ import reactivemongo.api.bson.Macros.Annotations.Key enum BusForum: case CreatePost(post: ForumPostMini) case RemovePost(id: ForumPostId, by: Option[UserId], text: String, asAdmin: Boolean)(using val me: MyId) - case RemovePosts(ids: List[ForumPostId]) // erasing = blanking, still in db but with empty text - case ErasePost(id: ForumPostId) case ErasePosts(ids: List[ForumPostId]) object BusForum: diff --git a/modules/forum/src/main/ForumDelete.scala b/modules/forum/src/main/ForumDelete.scala index ace794c95053d..0d508311e8dbc 100644 --- a/modules/forum/src/main/ForumDelete.scala +++ b/modules/forum/src/main/ForumDelete.scala @@ -19,16 +19,15 @@ final class ForumDelete( .allByUserCursor(user) .documentSource() .mapAsyncUnordered(4): post => - postApi.viewOf(post).flatMap { _.so(deletePost) } + postApi.viewOf(post).flatMap(_.so(deletePost)) .runWith(Sink.ignore) .void def deleteTopic(view: PostView)(using Me): Funit = for - postIds <- postRepo.idsByTopicId(view.topic.id) - _ <- postRepo.removeByTopic(view.topic.id) - _ <- topicRepo.remove(view.topic) - _ <- categApi.denormalize(view.categ) + _ <- postRepo.removeByTopic(view.topic.id) + _ <- topicRepo.remove(view.topic) + _ <- categApi.denormalize(view.categ) yield publishDelete(view.post) def deletePost(view: PostView)(using Me): Funit = diff --git a/modules/forum/src/main/ForumPostApi.scala b/modules/forum/src/main/ForumPostApi.scala index 8411bde90e844..77dae8e497674 100644 --- a/modules/forum/src/main/ForumPostApi.scala +++ b/modules/forum/src/main/ForumPostApi.scala @@ -223,14 +223,11 @@ final class ForumPostApi( postRepo.coll.update .one($id(post.id), post.erase) .void - .andDo: - Bus.pub(BusForum.ErasePost(post.id)) def eraseFromSearchIndex(user: User): Funit = postRepo.coll .distinctEasy[ForumPostId, List]("_id", $doc("userId" -> user.id), _.sec) - .map: ids => - Bus.pub(BusForum.ErasePosts(ids)) + .map(ids => Bus.pub(BusForum.ErasePosts(ids))) def teamIdOfPostId(postId: ForumPostId): Fu[Option[TeamId]] = postRepo.coll.byId[ForumPost](postId).flatMapz { post => diff --git a/modules/forumSearch/src/main/Env.scala b/modules/forumSearch/src/main/Env.scala index 9ec7cbf024c8c..89dc672311df7 100644 --- a/modules/forumSearch/src/main/Env.scala +++ b/modules/forumSearch/src/main/Env.scala @@ -45,8 +45,4 @@ final class Env( private lazy val paginatorBuilder = lila.search.PaginatorBuilder(api, config.maxPerPage) lila.common.Bus.sub[BusForum]: - case CreatePost(post) => api.store(post) - case RemovePost(id, _, _, _) => client.deleteById(index, id.value) - case RemovePosts(ids) => client.deleteByIds(index, ids.map(_.value)) - case ErasePost(id) => client.deleteById(index, id.value) - case ErasePosts(ids) => client.deleteByIds(index, ids.map(_.value)) + case ErasePosts(ids) => client.deleteByIds(index, ids.map(_.value)) From 81e6907bdf38f137e398cb9919c1c615f056ec41 Mon Sep 17 00:00:00 2001 From: Thanh Le Date: Sat, 15 Jun 2024 19:21:26 +0700 Subject: [PATCH 059/168] Remove unneded forum search write apis --- modules/api/src/main/Cli.scala | 1 - modules/forumSearch/src/main/Env.scala | 12 ------- .../forumSearch/src/main/ForumSearchApi.scala | 35 ------------------- 3 files changed, 48 deletions(-) diff --git a/modules/api/src/main/Cli.scala b/modules/api/src/main/Cli.scala index 8078f3c419278..da551708e9062 100644 --- a/modules/api/src/main/Cli.scala +++ b/modules/api/src/main/Cli.scala @@ -56,7 +56,6 @@ final private[api] class Cli( private def processors = security.cli.process .orElse(teamSearch.cli.process) - .orElse(forumSearch.cli.process) .orElse(tournament.cli.process) .orElse(fishnet.cli.process) .orElse(study.cli.process) diff --git a/modules/forumSearch/src/main/Env.scala b/modules/forumSearch/src/main/Env.scala index 89dc672311df7..badff6d3f567f 100644 --- a/modules/forumSearch/src/main/Env.scala +++ b/modules/forumSearch/src/main/Env.scala @@ -30,18 +30,6 @@ final class Env( def apply(text: String, page: Int, troll: Boolean) = paginatorBuilder(Query.forum(text.take(100), troll), page) - def cli: lila.common.Cli = new: - def process = { - case "forum" :: "search" :: "reset" :: Nil => api.reset.inject("done") - case "forum" :: "search" :: "backfill" :: epochSeconds :: Nil => - Either - .catchNonFatal(java.lang.Long.parseLong(epochSeconds)) - .fold( - e => fufail(s"Invalid epochSeconds: $e"), - since => api.backfill(java.time.Instant.ofEpochSecond(since)).inject("done") - ) - } - private lazy val paginatorBuilder = lila.search.PaginatorBuilder(api, config.maxPerPage) lila.common.Bus.sub[BusForum]: diff --git a/modules/forumSearch/src/main/ForumSearchApi.scala b/modules/forumSearch/src/main/ForumSearchApi.scala index 3a223b357ca45..3fea6a027cf2f 100644 --- a/modules/forumSearch/src/main/ForumSearchApi.scala +++ b/modules/forumSearch/src/main/ForumSearchApi.scala @@ -22,38 +22,3 @@ final class ForumSearchApi( def count(query: Query.Forum) = client.count(query).dmap(_.count) - - def store(post: ForumPostMini) = - postApi - .toMiniView(post) - .flatMapz: view => - client.storeForum(view.post.id.value, toDoc(view)) - - private def toDoc(view: ForumPostMiniView) = - ForumSource( - body = view.post.text.take(10000), - topic = view.topic.name, - author = view.post.userId.map(_.value), - topicId = view.topic.id.value, - troll = view.post.troll, - date = view.post.createdAt.toEpochMilli() - ) - - def reset = - client.mapping(index) >> - readAndIndexPosts(none) >> - client.refresh(index) - - def backfill(since: Instant) = - readAndIndexPosts(since.some) - - private def readAndIndexPosts(since: Option[Instant]) = - postApi - .nonGhostCursor(since) - .documentSource() - .via(lila.common.LilaStream.logRate("forum index")(logger)) - .grouped(200) - .mapAsync(1)(posts => postApi.toMiniViews(posts.toList)) - .map(_.map(v => v.post.id.value -> toDoc(v))) - .mapAsyncUnordered(2)(client.storeBulkForum) - .runWith(Sink.ignore) From 7ac6ae9b11c9a8973eeb2668f0bdd22d2743b348 Mon Sep 17 00:00:00 2001 From: Thanh Le Date: Sat, 15 Jun 2024 20:32:30 +0700 Subject: [PATCH 060/168] Code tweak & scalafmt --- modules/forumSearch/src/main/Env.scala | 6 ++---- modules/forumSearch/src/main/ForumSearchApi.scala | 8 ++------ 2 files changed, 4 insertions(+), 10 deletions(-) diff --git a/modules/forumSearch/src/main/Env.scala b/modules/forumSearch/src/main/Env.scala index badff6d3f567f..6092317e9eff1 100644 --- a/modules/forumSearch/src/main/Env.scala +++ b/modules/forumSearch/src/main/Env.scala @@ -13,15 +13,13 @@ import lila.search.client.SearchClient import lila.search.spec.Query @Module -private class ForumSearchConfig( - @ConfigName("paginator.max_per_page") val maxPerPage: MaxPerPage -) +private class ForumSearchConfig(@ConfigName("paginator.max_per_page") val maxPerPage: MaxPerPage) final class Env( appConfig: Configuration, postApi: lila.core.forum.ForumPostApi, client: SearchClient -)(using Executor, akka.stream.Materializer): +)(using Executor): private val config = appConfig.get[ForumSearchConfig]("forumSearch")(AutoConfig.loader) diff --git a/modules/forumSearch/src/main/ForumSearchApi.scala b/modules/forumSearch/src/main/ForumSearchApi.scala index 3fea6a027cf2f..3b85b2094005d 100644 --- a/modules/forumSearch/src/main/ForumSearchApi.scala +++ b/modules/forumSearch/src/main/ForumSearchApi.scala @@ -8,17 +8,13 @@ import lila.core.id.ForumPostId import lila.search.client.SearchClient import lila.search.spec.{ ForumSource, Query } -final class ForumSearchApi( - client: SearchClient, - postApi: ForumPostApi -)(using Executor, akka.stream.Materializer) +final class ForumSearchApi(client: SearchClient, postApi: ForumPostApi)(using Executor) extends SearchReadApi[ForumPostId, Query.Forum]: def search(query: Query.Forum, from: From, size: Size) = client .search(query, from.value, size.value) - .map: res => - res.hitIds.map(ForumPostId.apply) + .map(res => res.hitIds.map(ForumPostId.apply)) def count(query: Query.Forum) = client.count(query).dmap(_.count) From a4f9d204e2a1c37b504d62dfb4a500030e9e902a Mon Sep 17 00:00:00 2001 From: Thibault Duplessis Date: Sat, 15 Jun 2024 15:39:13 +0200 Subject: [PATCH 061/168] broadcast stats WIP What is done: - DB storage, recording and fetching stats of a tournament - Empty stats page linked on the tournament page To do: - use chart.js to draw the viewers graph --- app/controllers/RelayTour.scala | 7 ++++ conf/routes | 1 + modules/relay/src/main/Env.scala | 6 +++- modules/relay/src/main/RelayApi.scala | 5 --- modules/relay/src/main/RelayRoundRepo.scala | 4 +-- modules/relay/src/main/RelayStatsApi.scala | 38 +++++++++++++++++++++ modules/relay/src/main/ui/RelayTourUi.scala | 17 +++++++++ ui/analyse/src/study/relay/relayTourView.ts | 7 ++++ ui/bits/package.json | 1 + ui/bits/src/bits.relayStats.ts | 3 ++ 10 files changed, 81 insertions(+), 8 deletions(-) create mode 100644 modules/relay/src/main/RelayStatsApi.scala create mode 100644 ui/bits/src/bits.relayStats.ts diff --git a/app/controllers/RelayTour.scala b/app/controllers/RelayTour.scala index c3008f2ad4854..465ba63651d20 100644 --- a/app/controllers/RelayTour.scala +++ b/app/controllers/RelayTour.scala @@ -188,6 +188,13 @@ final class RelayTour(env: Env, apiC: => Api) extends LilaController(env): asAttachmentStream(s"${env.relay.pgnStream.filename(tour)}.pgn"): Ok.chunked(source).as(pgnContentType) + def stats(id: RelayTourId) = Open: + Found(env.relay.api.tourById(id)): tour => + env.relay.stats + .get(tour.id) + .flatMap: stats => + Ok.page(views.relay.tour.stats(tour, stats)) + def apiIndex = Anon: apiC.jsonDownload: env.relay.tourStream diff --git a/conf/routes b/conf/routes index ba6d629e8aaa5..8cc00de17428e 100644 --- a/conf/routes +++ b/conf/routes @@ -262,6 +262,7 @@ GET /broadcast/all-private controllers.RelayTour.allPrivate(p GET /broadcast/:ts/$id<\w{8}> controllers.RelayTour.show(ts, id: RelayTourId) GET /api/broadcast/$id<\w{8}> controllers.RelayTour.apiShow(id: RelayTourId) GET /api/broadcast/$tourId<\w{8}>.pgn controllers.RelayTour.pgn(tourId: RelayTourId) +GET /broadcast/$tourId<\w{8}>/stats controllers.RelayTour.stats(tourId: RelayTourId) GET /broadcast/$tourId<\w{8}>/edit controllers.RelayTour.edit(tourId: RelayTourId) POST /broadcast/$tourId<\w{8}>/edit controllers.RelayTour.update(tourId: RelayTourId) POST /broadcast/$tourId<\w{8}>/delete controllers.RelayTour.delete(tourId: RelayTourId) diff --git a/modules/relay/src/main/Env.scala b/modules/relay/src/main/Env.scala index 98ddc40f3070f..c5dbf759d6e33 100644 --- a/modules/relay/src/main/Env.scala +++ b/modules/relay/src/main/Env.scala @@ -90,6 +90,9 @@ final class Env( private lazy val delay = wire[RelayDelay] + // must instanciate eagerly to start the scheduler + val stats = wire[RelayStatsApi] + import SettingStore.CredentialsOption.given val proxyCredentials = settingStore[Option[Credentials]]( "relayProxyCredentials", @@ -122,7 +125,7 @@ final class Env( wire[RelayFetch] scheduler.scheduleWithFixedDelay(1 minute, 1 minute): () => - api.autoStart >> api.autoFinishNotSyncing >> api.monitorCrowd + api.autoStart >> api.autoFinishNotSyncing lila.common.Bus.subscribeFuns( "study" -> { case lila.core.study.RemoveStudy(studyId) => @@ -150,6 +153,7 @@ private class RelayColls(mainDb: lila.db.Db, yoloDb: lila.db.AsyncDb @@ lila.db. val tour = mainDb(CollName("relay_tour")) val group = mainDb(CollName("relay_group")) val delay = yoloDb(CollName("relay_delay")) + val stats = mainDb(CollName("relay_stats")) private trait ProxyCredentials private trait ProxyHostPort diff --git a/modules/relay/src/main/RelayApi.scala b/modules/relay/src/main/RelayApi.scala index f115665a50419..a2a36920842ea 100644 --- a/modules/relay/src/main/RelayApi.scala +++ b/modules/relay/src/main/RelayApi.scala @@ -408,11 +408,6 @@ final class RelayApi( update(relay)(_.finish) } - private[relay] def monitorCrowd: Funit = - roundRepo.tourCrowds.map: crowds => - crowds.foreach: (tourId, crowd) => - lila.mon.relay.tourCrowd(tourId).update(crowd) - private[relay] def WithRelay[A: Zero](id: RelayRoundId)(f: RelayRound => Fu[A]): Fu[A] = byId(id).flatMapz(f) diff --git a/modules/relay/src/main/RelayRoundRepo.scala b/modules/relay/src/main/RelayRoundRepo.scala index 1b8fab34c82f3..675529bf87a58 100644 --- a/modules/relay/src/main/RelayRoundRepo.scala +++ b/modules/relay/src/main/RelayRoundRepo.scala @@ -53,8 +53,8 @@ final private class RelayRoundRepo(val coll: Coll)(using Executor): coll .aggregateList(maxDocs = 500, _.sec): framework => import framework.* - Match($doc("sync.until" -> $exists(true))) -> - List(GroupField("_id")("crowd" -> SumField("crowd"))) + Match($doc("sync.until" -> $exists(true), "crowd".$gt(0))) -> + List(GroupField("tourId")("crowd" -> SumField("crowd"))) .map: docs => for doc <- docs diff --git a/modules/relay/src/main/RelayStatsApi.scala b/modules/relay/src/main/RelayStatsApi.scala new file mode 100644 index 0000000000000..ffc2979976060 --- /dev/null +++ b/modules/relay/src/main/RelayStatsApi.scala @@ -0,0 +1,38 @@ +package lila.relay + +import lila.db.dsl.{ *, given } + +object RelayStats: + type Minute = Int + type Crowd = Int + type Graph = List[(Minute, Crowd)] + +final class RelayStatsApi(roundRepo: RelayRoundRepo, colls: RelayColls)(using scheduler: Scheduler)(using + Executor +): + import RelayStats.* + + // on measurement by minute at most; the storage depends on it. + scheduler.scheduleWithFixedDelay(0 seconds, 1 minute)(() => record()) + + def get(id: RelayTourId): Fu[Graph] = + colls.stats + .primitiveOne[List[Int]]($id(id), "d") + .mapz: + _.grouped(2) + .collect: + case List(minute, crowd) => (minute, crowd) + .toList + + private def record(): Funit = for + crowds <- roundRepo.tourCrowds + nowMinutes = nowSeconds / 60 + update = colls.stats.update(ordered = false) + elements <- crowds.sequentially: (tourId, crowd) => + update.element( + q = $id(tourId), + u = $push("d" -> $doc("$each" -> $arr(nowMinutes, crowd))), + upsert = true + ) + _ <- elements.nonEmpty.so(update.many(elements).void) + yield () diff --git a/modules/relay/src/main/ui/RelayTourUi.scala b/modules/relay/src/main/ui/RelayTourUi.scala index 78df22aa49466..5d10ced899eb6 100644 --- a/modules/relay/src/main/ui/RelayTourUi.scala +++ b/modules/relay/src/main/ui/RelayTourUi.scala @@ -6,6 +6,7 @@ import ScalatagsTemplate.{ *, given } import scalalib.paginator.Paginator import lila.relay.RelayTour.WithLastRound import lila.core.LightUser +import play.api.libs.json.Json final class RelayTourUi(helpers: Helpers, ui: RelayUi): import helpers.{ *, given } @@ -101,6 +102,22 @@ final class RelayTourUi(helpers: Helpers, ui: RelayUi): ) ) + def stats(t: RelayTour, graph: RelayStats.Graph)(using Context) = + Page(s"${t.name.value} - Stats") + .css("bits.relay.index") + .js( + PageModule( + "bits.relayStats", + Json + .obj("points" -> graph.map: (minute, crowd) => + Json.arr(minute * 60, crowd)) + ) + ): + main(cls := "relay-tour page box box-pad")( + boxTop(h1(a(href := routes.RelayTour.show(t.slug, t.id).url)(t.name), " - Stats")), + "Here, a graph shows the number of viewers over time." + ) + def page(title: String, pageBody: Frag, active: String)(using Context): Page = Page(title) .css("bits.page") diff --git a/ui/analyse/src/study/relay/relayTourView.ts b/ui/analyse/src/study/relay/relayTourView.ts index 64af89bbd0294..edac7327fd2af 100644 --- a/ui/analyse/src/study/relay/relayTourView.ts +++ b/ui/analyse/src/study/relay/relayTourView.ts @@ -285,6 +285,13 @@ const makeTabs = (ctrl: AnalyseCtrl) => { makeTab('boards', 'Boards'), relay.teams && makeTab('teams', 'Teams'), relay.data.tour.leaderboard ? makeTab('leaderboard', 'Leaderboard') : undefined, + study.members.myMember() + ? h( + 'a.text', + { attrs: { ...dataIcon(licon.LineGraph), href: `/broadcast/${relay.data.tour.id}/stats` } }, + 'Popularity stats', + ) + : undefined, ]); }; diff --git a/ui/bits/package.json b/ui/bits/package.json index 4dfd6503ed721..cc1cbc6100f36 100644 --- a/ui/bits/package.json +++ b/ui/bits/package.json @@ -72,6 +72,7 @@ "src/bits.publicChats.ts", "src/bits.qrcode.ts", "src/bits.relayForm.ts", + "src/bits.relayStats.ts", "src/bits.soundMove.ts", "src/bits.streamer.ts", "src/bits.team.ts", diff --git a/ui/bits/src/bits.relayStats.ts b/ui/bits/src/bits.relayStats.ts new file mode 100644 index 0000000000000..04fd2c9080fcb --- /dev/null +++ b/ui/bits/src/bits.relayStats.ts @@ -0,0 +1,3 @@ +export function initModule(data: any) { + console.log(data); +} From b906c073476b439b7c282aeed48ec3d5adf8159b Mon Sep 17 00:00:00 2001 From: slither77 <132110444+slither77@users.noreply.github.com> Date: Sat, 15 Jun 2024 13:11:53 -0400 Subject: [PATCH 062/168] added monarch piece set made by slither77 --- public/piece/monarchy/bB.svg | 1 + public/piece/monarchy/bK.svg | 1 + public/piece/monarchy/bN.svg | 1 + public/piece/monarchy/bP.svg | 1 + public/piece/monarchy/bQ.svg | 1 + public/piece/monarchy/bR.svg | 1 + public/piece/monarchy/wB.svg | 1 + public/piece/monarchy/wK.svg | 1 + public/piece/monarchy/wN.svg | 1 + public/piece/monarchy/wP.svg | 1 + public/piece/monarchy/wQ.svg | 1 + public/piece/monarchy/wR.svg | 1 + 12 files changed, 12 insertions(+) create mode 100644 public/piece/monarchy/bB.svg create mode 100644 public/piece/monarchy/bK.svg create mode 100644 public/piece/monarchy/bN.svg create mode 100644 public/piece/monarchy/bP.svg create mode 100644 public/piece/monarchy/bQ.svg create mode 100644 public/piece/monarchy/bR.svg create mode 100644 public/piece/monarchy/wB.svg create mode 100644 public/piece/monarchy/wK.svg create mode 100644 public/piece/monarchy/wN.svg create mode 100644 public/piece/monarchy/wP.svg create mode 100644 public/piece/monarchy/wQ.svg create mode 100644 public/piece/monarchy/wR.svg diff --git a/public/piece/monarchy/bB.svg b/public/piece/monarchy/bB.svg new file mode 100644 index 0000000000000..a5ac5db2167c0 --- /dev/null +++ b/public/piece/monarchy/bB.svg @@ -0,0 +1 @@ + \ No newline at end of file diff --git a/public/piece/monarchy/bK.svg b/public/piece/monarchy/bK.svg new file mode 100644 index 0000000000000..3f4e68aadf871 --- /dev/null +++ b/public/piece/monarchy/bK.svg @@ -0,0 +1 @@ + \ No newline at end of file diff --git a/public/piece/monarchy/bN.svg b/public/piece/monarchy/bN.svg new file mode 100644 index 0000000000000..0213ea8382250 --- /dev/null +++ b/public/piece/monarchy/bN.svg @@ -0,0 +1 @@ + \ No newline at end of file diff --git a/public/piece/monarchy/bP.svg b/public/piece/monarchy/bP.svg new file mode 100644 index 0000000000000..854569e647b71 --- /dev/null +++ b/public/piece/monarchy/bP.svg @@ -0,0 +1 @@ + \ No newline at end of file diff --git a/public/piece/monarchy/bQ.svg b/public/piece/monarchy/bQ.svg new file mode 100644 index 0000000000000..df3811688a7f5 --- /dev/null +++ b/public/piece/monarchy/bQ.svg @@ -0,0 +1 @@ + \ No newline at end of file diff --git a/public/piece/monarchy/bR.svg b/public/piece/monarchy/bR.svg new file mode 100644 index 0000000000000..312278e8cfc45 --- /dev/null +++ b/public/piece/monarchy/bR.svg @@ -0,0 +1 @@ + \ No newline at end of file diff --git a/public/piece/monarchy/wB.svg b/public/piece/monarchy/wB.svg new file mode 100644 index 0000000000000..671a6f5c8ddaa --- /dev/null +++ b/public/piece/monarchy/wB.svg @@ -0,0 +1 @@ + \ No newline at end of file diff --git a/public/piece/monarchy/wK.svg b/public/piece/monarchy/wK.svg new file mode 100644 index 0000000000000..6ddeb192c48ae --- /dev/null +++ b/public/piece/monarchy/wK.svg @@ -0,0 +1 @@ + \ No newline at end of file diff --git a/public/piece/monarchy/wN.svg b/public/piece/monarchy/wN.svg new file mode 100644 index 0000000000000..7a728d5b4973a --- /dev/null +++ b/public/piece/monarchy/wN.svg @@ -0,0 +1 @@ + \ No newline at end of file diff --git a/public/piece/monarchy/wP.svg b/public/piece/monarchy/wP.svg new file mode 100644 index 0000000000000..c0cfccfa8f1b3 --- /dev/null +++ b/public/piece/monarchy/wP.svg @@ -0,0 +1 @@ + \ No newline at end of file diff --git a/public/piece/monarchy/wQ.svg b/public/piece/monarchy/wQ.svg new file mode 100644 index 0000000000000..e73504e4b8323 --- /dev/null +++ b/public/piece/monarchy/wQ.svg @@ -0,0 +1 @@ + \ No newline at end of file diff --git a/public/piece/monarchy/wR.svg b/public/piece/monarchy/wR.svg new file mode 100644 index 0000000000000..5e7a364ff6f56 --- /dev/null +++ b/public/piece/monarchy/wR.svg @@ -0,0 +1 @@ + \ No newline at end of file From 931e61f44f546d4a20b422733a05c26cca6cb4f7 Mon Sep 17 00:00:00 2001 From: Thibault Duplessis Date: Sat, 15 Jun 2024 22:28:42 +0200 Subject: [PATCH 063/168] integrate monarchy piece set --- COPYING.md | 1 + bin/gen/piece-sprite | 1 + modules/pref/src/main/PieceSet.scala | 1 + public/piece-css/monarchy.css | 12 ++++++++++++ public/piece-css/monarchy.external.css | 12 ++++++++++++ 5 files changed, 27 insertions(+) create mode 100644 public/piece-css/monarchy.css create mode 100644 public/piece-css/monarchy.external.css diff --git a/COPYING.md b/COPYING.md index 0362eaf249abe..6531d7f304a28 100644 --- a/COPYING.md +++ b/COPYING.md @@ -59,6 +59,7 @@ public/piece/disguised | danegraphics | [CC BY-NC-SA 4.0](https://creativecommon public/piece/kiwen-suwi | [neverRare](https://github.com/neverRare) | [CC BY 4.0](https://creativecommons.org/licenses/by/4.0/) public/piece/mpchess | [Maxime Chupin](https://github.com/chupinmaxime) | [GPL3v3+](https://www.gnu.org/licenses/quick-guide-gplv3.en.html) public/piece/cooke | [fejfar](https://github.com/fejfar) | [CC BY-NC-SA 4.0](https://creativecommons.org/licenses/by-nc-sa/4.0/) +public/piece/monarchy | [slither77](https://github.com/slither77) | [CC BY-NC-SA 4.0](https://creativecommons.org/licenses/by-nc-sa/4.0/) public/sounds/futuristic | [Enigmahack](https://github.com/Enigmahack) | AGPLv3+ public/sounds/nes | [Enigmahack](https://github.com/Enigmahack) | AGPLv3+ public/sounds/piano | [Enigmahack](https://github.com/Enigmahack) | AGPLv3+ diff --git a/bin/gen/piece-sprite b/bin/gen/piece-sprite index afcb9537bb27c..cf2f374d4c976 100755 --- a/bin/gen/piece-sprite +++ b/bin/gen/piece-sprite @@ -44,6 +44,7 @@ themes = [ ['kiwen-suwi', 'svg'], ['mpchess','svg'], ['cooke','svg'], + ['monarchy', 'svg'], ] types = { 'svg' => 'svg+xml;base64,', diff --git a/modules/pref/src/main/PieceSet.scala b/modules/pref/src/main/PieceSet.scala index 55178a1e70e5f..38874ecf48c98 100644 --- a/modules/pref/src/main/PieceSet.scala +++ b/modules/pref/src/main/PieceSet.scala @@ -47,6 +47,7 @@ object PieceSet extends PieceSetObject: PieceSet("tatiana"), PieceSet("staunty"), PieceSet("cooke"), + PieceSet("monarchy"), PieceSet("governor"), PieceSet("dubrovny"), PieceSet("icpieces"), diff --git a/public/piece-css/monarchy.css b/public/piece-css/monarchy.css new file mode 100644 index 0000000000000..87558a658876f --- /dev/null +++ b/public/piece-css/monarchy.css @@ -0,0 +1,12 @@ +.is2d .pawn.white {background-image:url('data:image/svg+xml;base64,<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="614.635" height="614.635" viewBox="0 0 460.977 460.977"><mask id="b"><use xlink:href="#a" width="1280" height="1280" transform="rotate(.193) scale(.36014)"/></mask><symbol id="a" viewBox="0 0 1280 1280"><image width="1280" height="1280" xlink:href="data:image/png;base64, iVBORw0KGgoAAAANSUhEUgAABQAAAAUACAAAAAA9j6ArAAAACXBIWXMAAA7EAAAO xAGVKw4bAAA+UklEQVR4nO3dB5SV5b228XFmGBjKSEdALESN0ZgTv8RgieYQDYqC EcGuiAUrKAgiWMCGAcWKLYpii1GwxY5BMaICcmJMscSCiEiHoQ3T93xDZ6izZ973 vZ/n+V+/s1bOSuKBe23Y19mz37ZTBgAYtZN6AACoEEAAZhFAAGYRQABmEUAAZhFA AGYRQABmEUAAZhFAAGYRQABmEUAAZhFAAGYRQABmEUAAZhFAAGYRQABmEUAAZhFA AGYRQABmEUAAZhFAAGYRQABmEUAAZhFAAGYRQABmEUAAZhFAAGYRQABmEUAAZhFA AGYRQABmEUAAZhFAAGYRQABmEUAAZhFAAGYRQABmEUAAZhFAAGYRQABmEUAAZhFA AGYRQABmEUAAZhFAAGYRQABmEUAAZhFAAGYRQABmEUAAZhFAAGYRQABmEUAAZhFA AGYRQABmEUAAZhFAAGYRQABmEUAAZhFAAGYRQABmEUAAZhFAAGYRQABmEUAAZhFA AGYRQABmEUAAZhFAAGYRQABmEUAAZhFAAGYRQABmEUAAZhFAAGYRQABmEUAAZhFA AGYRQABmEUAAZhFAAGYRQABmEUAAZhFAAGYRQABmEUAAZhFAAGYRQABmEUAAZhFA AGYRQABmEUAAZhFAAGYRQABmEUAAZhFAAGYRQABmEUAAZhFAAGYRQABmEUAAZhFA AGYRQABmEUAAZhFAAGYRQABmEUAAZhFAAGYRQABmEUAAZhFAAGYRQABmEUAAZhFA AGYRQABmEUAAZhFAAGYRQABmEUAAZhFAAGYRQABmEUAAZhFAAGYRQABmEUAAZhFA AGYRQABmEUAAZhFAAGYRQABmEUAAZhFAAGYRQABmEUAAZhFAAGYRQABmEUAAZhFA AGYRQABmEUAAZhFAAGYRQABmEUAAZhFAAGYRQABmEUAAZhFAAGYRQABmEUAAZhFA AGYRQABmEUAAZhFAAGYRQABmEUAAZhFAAGYRQABmEUAAZhFAAGYRQABmEUAAZhFA AGYRQABmEUAAZhFAAGYRQABmEUAAZhFAAGYRQABmEUAAZhFAAGYRQABmEUAAZhFA AGYRQABmEUAAZhFAAGYRQABmEUAAZhFAAGYRQABmEUAAZhFAAGYRQABmEUAAZhFA AGYRQABmEUAAZhFAAGYRQABmEUAAZhFAAGYRQABmEUAAZhFAAGYRQABmEUAAZhFA AGYRQABmEUAAZhFAAGYRQABmEUAAZhFAAGYRQABmEUAAZhFAAGYRQABmEUAAZhFA AGYRQABmEUAAZhFAAGYRQABmEUAAZhFAAGYRQABmEUAAZhFAAGYRQABmEUAAZhFA AGYRQABmEUAAZhFAAGYRQABmEUAAZhFAAGYRQABmEUAAZhFAAGYRQABmEUAAZhFA AGYRQABmEUAAZhFAAGYRQABmEUAAZhFAAGYRQABmEUAAZhFAAGYRQABmEUAAZhFA AGYRQABmEUAAZhFAAGYRQABmEUAAZhFAAGYRQABmEUAAZhFAAGYRQABmEUAAZhFA AGYRQABmEUAAZhFAAGYRQABmEUAAZhFAAGYRQABmEUAAZhFAAGYRQABmEUAAZhFA AGYRQABmEUAAZhFAAGYRQABmEUAAZhFAAGYRQABmEUAAZhFAAGYRQABmEUAAZhFA AGYRQABmEUCI7FShXgAQQCTusKaV/9K+3fczKv/XoinqNbCMACIZXTM6tWxxYEbd 3C3/q8Liik8WzP9r6vXkV8E4Aoh4tTi4w//8Irdx9f7h/MLp/5w6NT/eRcAGBBCx 6dpp/wOrWb4qKvI//s8bb0U+B9gCAUQcup59aIvs2v0SpfMnP/J2NGuAbSCAiNi+ Zx568Fa+6KuZlR++96eZUf1iwOYIICK075mdDqzlB78tlXz0xlOzov5FgdUIICLS oucp0cdvvZJpTzyzMq5fHHYRQEThsPNPqMnhjrTMH/fIP+P+PWAMAUStdb7y8Ng+ +lVV/NYtU5P5nWADAUTtDDjloER/v/LJY59I9DdEyAggaqHzlR0Fv2v5KyOmCX5b BIgAoqYOvPGYhH7y3VLRuGEzVb83AkIAUSMthlwU2cl+NbPk1nsKtQvgPwKIGuh8 Q7Jf/G1d+duD/6HeAL8RQKRL/+Fvo8Uj7uNjIGqOACI9B96uOO6xbWUvDPxevQHe IoBIR88+Lvzsu5m3bpuongBPEUBU37UDYr/co2a+u+ZP6gnwEgFEdd3RV3bWy44t v/o+9QR4iACiepzO32rLh9yvngDvEEBUh/P5W235VQ+qJ8AzBBA75kX+Vls2mAQi HQQQO+JN/lZbdtUf1RPgEQKI7btwhKNHfrfloys+UE+ANwggtqfDm57lb7XJ3Rar J8ATBBDb1vpPbl31UV2pxy4oV2+AFwggtmlsL/WCGiscOko9AT4ggNiGC+905pYH NTHrrPfUE+A+Aoitav0XBy/6TUtq/KnqCXAeAcTW3NFfvSACBX0eU0+A4wggtuTl sd+tmdQ9Xz0BTiOA2MJz3dULIlM08nr1BLiMAGIzJzzt9cGPzU0/dYZ6AtxFAFFV QB//1iq98Wb1BDiLAGJTwXz7t6m3eyxVT4CjCCA2EcTB3y2tuJgbRmOrCCA22PWj 1uoJMal4MbQf7BENAoj1LrzXo9tepWvOCdPVE+AgAoh1gjv6UVXp0BHqCXAPAcQa u/47wKMfVb3WRb0AziGAWO2EF9ULEjCvwyz1BDiGACLD6xtfpaPosofVE+AWAogA 7vxSXeWPn6eeAKcQQHSYFNS1b9v3ty4r1RPgEAJonomv/zaa02G2egLcQQCtC/Ti j20rOMtW8bE9BNC4d/x87FFtlI0aop4AVxBA0+wc/thU+aMXqCfAEQTQsl2/NHT4 Y1NvHa1eADcQQMNMHf6t6u3jV6knwAUE0C5jh3+rmnXIHPUEOIAAmmW6fxQQaxBA q8yd/rK5FWe+rJ4AOQJolPn+UUBkEECr6F+l5We8qp4AMQJoEv1bgwKaRwAton/r UEDrCKBB9G+DZWe8pp4AJQJoD/3bBAW0jQCaQ/+qoICmEUBr6N9mlp32hnoCZAig MfRvC0tPp4BmEUBbrr1JvcBBi4/+u3oCRAigKcav/92W6Z2WqidAgwBaQv+2Yfrv lqknQIIAGrLr9+oFzpr0W/UCSBBAO8ze/7k6XjxRvQAKBNCOVfRvO545Tb0AAgTQ jI8sPv+o+spuu1o9AckjgFY81129wHEF/caoJyBxBNAIToDeoSXd31VPQNIIoA2c AFMNUzpzMow1BNCEXb/NVk/wwatd1QuQMAJoAgeAq+eps9QLkCwCaAEHgKupdOR1 6glIFAE0gAMg1bb4xPfUE5AkAhg+DoCk4YNjl6snIEEEMHhcAZeWcaeoFyBBBDB4 c1qrF3il/K6B6glIDgEM3dhe6gWeWXrG6+oJSAwBDBxfAKZtche+BjSDAIat9Td8 AZi2P5+uXoCkEMCwvdNRvcBDRVffqZ6AhBDAoPEMpBqZc8y/1ROQDAIYMu6BX0Nv HKtegGQQwJBxBkwNlY8arJ6ARBDAgPEDcI390Jkfgk0ggOHiB+BaeK2LegGSQADD xQ/AtVB+K48IsYAABosfgGtl9jGfqicgfgQwVK3nqBd47pXj1QsQPwIYKm6CWksl N9yinoDYEcBAXfigeoH3vunIUaTgEcBAlfIUpFp74mz1AsSNAIaJx6BHYFmvl9QT EDMCGKQOU9ULgjDpyAr1BMSLAAYpv7F6QRBSt/CQuMARwBBxBCQi049bqJ6AWBHA EHEEJCqPnaNegFgRwADxGJDILDr1bfUExIkAhodrQCL04onqBYgTAQwPt8GPUOEl j6knIEYEMDgHfqxeEJSJnTgVJmAEMDhcBBypkivuU09AfAhgaHgQcMQmH7NKPQGx IYCh4RzoiKVuuFE9AbEhgIHhHOjITe26SD0BcSGAgeEDYORS13Nv7WARwLDwATAG U47nI2CoCGBY+AAYAz4ChosABoUPgLHgI2CwCGBQ+AAYi9Swm9UTEA8CGJLOr6sX BGpSF84FDBMBDAkXgcSk+LKH1BMQCwIYEK4Cjs2bndULEAsCGBA+AMaGj4CBIoDh aLFAvSBgfz5dvQBxIIDh4FGYMVpy5hvqCYgBAQwHTwKJ0wOXqBcgBgQwGHf0Vy8I 2ve//4d6AqJHAIPBSdCxSl0zQj0B0SOAoeAk6Ji9fTwnQ4eHAIaCc2BiVtxnjHoC IkcAA8E5MLH705nqBYgcAQwEh0BiN+sEDoMEhwAGYlWuekH4bhymXoCoEcAwcBlw Al7rol6AqBHAMLzTUb3AgILznlVPQMQIYBi4CiQJIwerFyBiBDAIA0apF5gwrfsP 6gmIFgEMAicBJqLokrHqCYgWAQxChXqAEQ9dqF6AaBHAEHASYEK+O+ET9QREigCG YE5r9QIjSvvfp56ASBHAAHAZXGKePVW9AJEigAHgJ+DEzOzGz8BBIYAB4CfgxJRe /oB6AqJEAAPAMeDk3DFAvQBRIoD+4yzoBE3tPkc9AREigP7jLOgEFV34hHoCIkQA /cd1wEkafq16ASJEAL132PvqBaa8dkKZegKiQwC9x/PQE7XotInqCYgOAfQej8NM VGrQ7eoJiA4B9B2XgSRsTG/1AkSHAPqOk2ASNqUHJ8KEgwD6jpvhJ2xlr+fVExAZ Aug7HgeXtGtuUS9AZAig5/gKMHE8ID0gBNBzN1+jXmDOt93+qZ6AqBBAz/EVYOJW nP2iegKiQgA9x1eAyRsyQr0AUSGAfuMrQAEejRQOAui3no+rFxg0qXu+egIiQgD9 9koX9QKDlpw+QT0BESGAfuNCYIHUFXerJyAiBNBv3A1fYeRg9QJEhAB6bd/P1QtM euwc9QJEhAB6jTshSHzYY656AqJBAL3GMRAJjoIEgwB6jWMgEhwFCQYB9BrPQ9K4 /gb1AkSDAPqM60BEHrxYvQDRIIA+6/qyeoFRb3ZfpZ6ASBBAn43uo15g1Owe09QT EAkC6DPuhSWyoudL6gmIBAH0GQeBRVL9RqsnIBIE0GccBFYZdqN6ASJBAH3GlcAq dwxQL0AkCKDHDntfvcCsp3uWqycgCgTQY5wFI/NGD86DCQIB9NgTZ6kXmLXwlEnq CYgCAfQYt0KQWXLaW+oJiAIB9Nic1uoFZpVe9Kh6AqJAAD3GaYAy5f3uVU9AFAig xzgNUGfoTeoFiAIB9BinAercPlC9AFEggP7iZlhC91+qXoAoEEB/cRqg0HNnFakn IAIE0F8EUIgAhoEA+qvn4+oFhk08aal6AiJAAP3FhSBCC09+Vz0BESCA/nr2ZPUC wxafzqUgISCA/uJKOCECGAYC6C+uhBPiWrgwEEB/cSWcENfChYEA+osAChHAMBBA fxFAIQIYBgLoL+6FoHTdzeoFiAAB9BefAIX4BBgGAugvAihEAMNAAP1FAIUIYBgI oL8IoBABDAMB9BcnQgtxInQYCKC/uBROiEvhwkAA/cXNEIQIYBgIoL+4HZYQt8MK AwH0FzdEFeKGqGEggP7ilvhC3BI/DATQXwRQiACGgQB6jOcC6/Bc4DAQQI8RQB0C GAYC6DFuB6Mz9Cb1AkSBAHqMa+FkuBIuEATQY1wLJ8OVcIEggB7jWjiZJadxIUgQ CKDHRvdRLzBrdo9p6gmIAgH0GCcCyrzRY5V6AqJAAD122PvqBWY93bNcPQFRIIA+ 40RAlTsGqBcgEgTQZ5wIqDLsRvUCRIIA+owTAUVS/UarJyASBNBnnAcjwlkwoSCA PuM8GBHOggkFAfQZ58GIvNmds2DCQAB91mKBeoFRD16sXoBoEECvcRhY4/ob1AsQ DQLoNQ4DS6SuuFs9AdEggF7jMLDEktMnqCcgGgTQawNGqReY9GGPueoJiAYB9Nq+ n6sXmPTYOeoFiAgB9BtXAyuMHKxegIgQQL9xFESAYyDhIIB+4yiIAMdAwkEA/dbz cfUCgyZ1z1dPQEQIoN+4FkTgoQvVCxAVAui5VbnqBfYMGaFegKgQQM+901G9wJwV Z7+onoCoEEDPcSp04qb0mKOegKgQQM/xJWDi+AowIATQd3wJmLRrblEvQGQIoO/4 EjBhK3s9r56AyBBA3/ElYML4CjAkBNB3fAmYsDG91QsQHQLoPS4HTlRq0O3qCYgO AfTec93VC0xZdNpE9QREhwB677D31QtMee2EMvUERIcA+o8nIyVp+LXqBYgQAfTf RwepFxhSdOET6gmIEAH0HyfCJGhqd06CCQkBDAD3xU/OHQPUCxAlAhiAOa3VC8wo vfwB9QREiQAG4I7+6gVmzOz2iXoCokQAA8DFIIl59lT1AkSKAIaAn4ETUtr/PvUE RIoAhoCfgRPy3Qn8BBwWAhgEjgMng3uhhoYABoFzoRNRdMlY9QREiwAGgXOhEzGt +w/qCYgWAQwD1wMnYeRg9QJEjACGgRvjJ6DgvGfVExAxAhiGAz9WLzDgtS7qBYga AQwED4eL343D1AsQNQIYCE4FjN2sE/6hnoCoEcBAcDlc7P50pnoBIkcAQ8GpgDEr 7jNGPQGRI4Ch6Py6ekHg3j5+lXoCIkcAg7GygXpB2K6/Qb0A0SOAweAwSKy+/z2H QAJEAMNRnqleELKHL1AvQAwIYDh4QnqMlpz5hnoCYkAAw8GZMDEad4p6AeJAAAPC mTCxKb7sIfUExIEABoQLgmPzZmf1AsSCAIbkm/bqBYEq6cfTMMNEAENywovqBYGa 1IWToMNEAIOyLE+9IEgVN3ASdKAIYFAufFC9IEhTjl+knoB4EMCwLG+kXhCgipu4 EWCoCGBY+AgYAz4AhosABoZbIkRv+LXqBYgLAQwMHwEjN7UrHwCDRQBDw0fAqP3h avUCxIYAhoZzASM2+RjOAQwXAQzOghbqBUEpH3qLegLiQwCD02GqekFQJnaqUE9A fAhgeLgpTIRKBtyrnoAYEcDwtJ6jXhCQV7uqFyBOBDBA73RULwhG4aVj1RMQJwIY ovzG6gWBSN05UD0BsSKAIeJs6IhMP26hegJiRQCDxKkwkSi//mb1BMSLAAbppHHq BUH4sPNy9QTEiwCG6bvd1AsCUHr1KPUExIwAhunIieoFAfhbpxL1BMSMAAbqvcPV C7xX1J9jScEjgIHa6yv1Au+91kW9ALEjgKF6rrt6geeW9+K+OuEjgKFqvDBbPcFv z56qXoD4EcBg3dFfvcBr87tNUU9A/AhgsDKX7Kye4LGK+/uoJyABBDBc3V5QL/DY lE4r1ROQAAIYsHd/o17gLU6BMYIABqztrEz1BF+9crx6ARJBAEN21+XqBZ5a2O0D 9QQkggAGjbvC1Ejq7ivUE5AMAhi0gz5SL/DSO0fxICQjCGDYxvZSL/DQ0jNeV09A Qghg2LIWcXf8dFX88WL1BCSFAAbuUL7NT9ekTmXqCUgKAQzd/XycSc+Sk99WT0Bi CGDw5rRWL/BK+V08CM4QAhi8n/yH06HTMOEY9QIkiACGb+Bt6gUe+aHTZ+oJSBAB NODNo9ULvFF41Wj1BCSJABpQd0GeeoIvHjtHvQCJIoAWdJjCn3O1TDoqpZ6ARPHG MGHQSPUCL8zp9Kl6ApJFAG14oZt6gQcK+o1RT0DCCKANmbM5G3BHyu/tp56ApBFA I9rMqKue4LqX+JRsDwG04ohJnA+9XZOPKlFPQOIIoBkXPaBe4LZ7ryxST0DiCKAd 916qXuCyiactUk9A8gigIRM6qRe464fO/1ZPgAABNCRrVhv1BFet6vaWegIUCKAl LWbWV09wU+q8x9QTIEEATTlwepZ6gpOuG85TkGwigLac8KJ6gYvuu4IzYIwigMb0 vUe9wD3P9F6pngARAmjNrVeqF7hmwpmcAGMWATTnqTPUC9wy7aTv1RMgQwDt+etR 6gUumd91unoCdAigPVlf76Ge4I6CU15TT4AQATSo4cxm6gmuKD3vSfUEKBFAi1rO aKCe4IbUZfepJ0CKAJq0z7+4O2CliuuGqydAiwDadNAULgnJyLhtMM9AMo4AGtX5 Ve6P+lBfLgCxjgBa1fNx9QK1Z84vUE+AGgE0a+Bt6gVar/bMV0+AHAG0y/ZFce+e Plc9AXoE0LCHz1cv0Pno5O/UE+AAAmjZvFbqBSolZ45XT4ALCKBpM3dXL9AoPPcZ 9QQ4gQCalvn1nuoJCvQP6xBA23JmtFVPSF7xxWPVE+AIAmhc3gxzN0YoG8BdsbEO AbSu5TcN1ROSlRp2s3oCnEEAzdvj83rqCUmqGHG1egLcQQCx/z/qqCck6O5+6gVw CAFExsHv27k1zCMXlaknwCEEEBkZnd6wcmuYp88tVk+ASwggKp38rHpBMl46iycA Y1MEEKv1fki9IAlvns4NYFAFAcQaV41QL4jf5JPmqyfAMQQQa+z1lXpB/Mb0Vi+A awgg1hgwSr0gfu+fzC0AURUBxBpTO6gXxK/wHCPHelBtBBCrtf9GvSAJj52jXgDH EECs9tej1AuSsPSM19UT4BYCiEpHTlQvSMZzp5eqJ8ApBBAZGVkLm6gnJKP8qtvV E+AUAoiMjJe7qhckZdHJk9QT4BICiIxBI9ULkvPOqQvVE+AQAoguL1v6W/DsOYXq CXCHpb/62Kpfv2vnZlirjbmYG2JhPQJoXYfJlm6Hutr9fVPqCXAFATTuiInW+peR 8eBlnAyDtQigbd3G2/r5d60nL1qlngA3EEDTBt6mXqDxWq9F6glwAgG0bGwv9QKV 6b3/qZ4AFxBAuxr+9WD1BJ0V549TT4ADCKBZB09soJ6glBo5lNNhQACtun6o9T/7 1y7+Xj0BatbfBFY1fvlw9QS9/HNfUk+AGAE06bSxddUTXFDx0OCl6g2QIoAG1R93 nHqCK344i7vDmEYA7TnroXrqCe5I/fFqPgQaRgCtaTL+SPUEt8w/e4J6AmQIoDFD r8tWT3DOuMt4YLpVBNCUQ59rrZ7golXXPFCs3gAJAmhI3lNmbn2frm/P/FA9AQoE 0I5h19i781X1/bnfAvUEJI8AWnH8o83UE9xWNPwObpJlDgG0Ye/HDlVPcN/Ci1+o UG9AsgigBXmP9FBP8MPkiz9VT0CiCGD4sm6/lFNfquuFPnPVE5AgAhi8Qdfnqif4 pOxhLg0xhAAG7uQHmqon+Kbw5jt5dLAVBDBonca0U0/w0dLBj3FitA0EMGC/uP9X 6gm+mn/Z8+XqDUgAAQzWfg9yz9NamHXRBJ6fHj4CGKi9H+CmL7U0vf+HnBYYOgIY pPYPdFJPCMHUfh+RwLARwADt9sdj1BNC8UHfT0hgyAhgcNrfR/4iNLn/xyQwXAQw MHvff5R6QmimXP5/JDBUBDAo+93bUT0hRNP6TyWBYSKAATnwbk58icn0Qe9xUkyI CGAwDru9g3pCyGb1fY1To8NDAAPRZfQe6gmhmztgHAkMDQEMQs8/tFFPsGDh0IdJ YFgIYAAGXM0dXxKybNQfSGBICKDvsm68vIF6gyWF91/DnWLCQQD9Vn/UeTnqDdaU Pj5guXoDIkIAfdZydPcs9QaLUi/25cb5YSCA/tr3rqPVE+ya2I/HJ4WAAPrq8BE8 6FJqyuD31BNQawTQT2fdsqt6An4Y8qR6AmqJAHoo88qrmqg3YLX8EaO4Qs5rBNA7 df9wEc+5dEbh/UNK1RtQcwTQMy3uPIWnnDul7Ol++eoNqCkC6JV97zyaPzHnpF7v /7V6A2qGt5NHOg4/RD0BWzd5yAfqCagJAuiNC6/fRT0B2zb7mifUE5A+AuiHrBsu a6TegO1bOmq4egLSRQB90HjUWVzx64GiMYMK1RuQFgLovj3u6pqp3oDqKR/fb756 A9JAAF3X4dYj1BOQhoq3BnCVsD8IoNtOG7GbegLSNWXoRPUEVBMBdFjmoEFc8ual edf/UT0B1UIAnVV/5Pn11BtQUyvuvIGrhD1AAB3V6h7udeq3krEDV6o3YEcIoJP2 v+so9QTUWvmLV3yv3oDtI4AOOnI4jzgPxMQrP1FPwPYQQOf0vpFL3gIybdgE9QRs GwF0S+Z1V+SpNyBa864bo56AbSGALskd2ZsDvwFaOmKkegK2jgC6o8k9p3Kv00Ct um9IuXoDtoIAumK3e4/jit+AlYwdxOPU3UMA3XDAXb9VT0DMysb350YJriGALjj8 1oPVE5CA1CsDuXe+Wwig3km3t1NPQEIq3ubEQKcQQLVeI1qpJyBJ7101VT0BGxBA rUtvbKqegKRNHfKuegLWIYBKg4dw1rNJ317xknoC1iCAMplDBjdUb4DKzCteVE9A BgGUybx2UAP1BijN6kcC9QigROYNA3LVG6A2+4rx6gnmEUCFa4bw6Q+VZvZ9VT3B OAKYvIHD+O4P63x05XvqCaYRwKRd8geO/GITH/Sfrp5gGAFM1kn3tVBPgGMq3ur7 lXqDWQQwSUc+ylN+saXUC5fNVW8wigAmZ98xh6knwFGlY/uvUm8wiQAmpdnYruoJ cNiqkTeqJ1hEAJORdc+FPOYX27Xw8j+rJ9hDABNx6W2c94wd+qAP98pKGAFMwKHj 2qonwAupZ/rkqzfYQgBjl/fE79UT4I2C60epJ5hCAON21U111BPgk+kX/109wRAC GK+fvcrt7pGe8sf6Fqo3mEEA45T5YG/1BHho0SXcJiYhBDBGv365iXoCvJR64Twe IpwIAhifh89XL4C3Fl3A7VKTQADj8uN3d1FPgMfKH72wQr3BAAIYk753cuUHamVK ry/VE8JHAGOR9dwJ6gnw3op+j6onBI8AxqHN3/nxF7VXfv9l6gmhI4AxOOKtuuoJ CMNLpxarJ4SNAEav1yOZ6gkIxeQTF6knBI0ARm7QSPUCBGR6zy/UE0JGAKN27U3q BQjKt10/VU8IGAGM2FUj1AsQmOknzlZPCBcBjNZpT6sXIDjvdluqnhAsAhipX3zE 8Q9E7qUTuSgkJgQwSrnzG6knIEAVd12hnhAqAhilvx6lXoAgFVzAVyvxIIAROvcR 9QIE6v3fL1FPCBMBjE6dZTz6DTG5u596QZgIYHQevFC9AMGad+IU9YQgEcDI1Cng 6UeIzYMXqxcEiQBGZvjV6gUI2MwuXBASAwIYmUXN1AsQsPIht6knhIgARmWvr9QL ELSXuqkXhIgARuWWIeoFCNr33XhgevQIYFQ+OFS9AEErvOgJ9YQAEcCoLMtTL0DQ Utfdop4QIAIYlTKeAodY3TZIvSBABDAidYvUCxC4hzjRPnoEMCKt5qkXIHCP91Iv CBABjAifABGzMb3VCwJEAKPCLSsRr/svVS8IEAGMCgdBEC8OgsSAAEZlYXP1AgSt /Krb1RMCRACj8upx6gUI2rKz/6KeECACGJW+96gXIGjTTpyjnhAgAhiVhst4IBxi xDGQOBDAyLzTUb0AASvo/Wf1hBARwMh0mqBegIBNPL5QPSFEBDA6P7RRL0Cwygbe rZ4QJAIYnd+8q16AYL3x+1L1hCARwAi90kW9AIFa1usl9YQwEcAI5c7jnoCIQ8Vd V6gnBIoARunA/+NUGMTghR5cah4PAhipUzlVAdF758Rl6gmhIoDROv9h9QIE570e C9UTgkUAI3bC+Gz1BITljVOXqyeEiwBGbf8PdlZPQEBSY3vz/V98CGDk6j7H2TCI yvIBY9QTgkYAY3DymEbqCQhCxV8umaveEDYCGIfMO/pwf2jU2swL31JPCB0BjEfe 6DNIIGpl7lVPqieEjwDGpf4tveurN8BbFVNvekO9wQICGKOTBnRQT4CXCscN/0q9 wQYCGKvGV5/BPbKQntJJo19VbzCDAMat2SVdfskVwqimVW8/8kpKPcIQApiAzON6 dmymHgHnlf3jjWc/U48whgAmJPfE449oySdBbEPxx++9NFU9wiACmKSDOx9+YGP1 CDimbMFHE16fpV5hFAFMWuZBRx7y/5rnqGfAARWrPvvntIkz1TMsI4AaDQ/r8Muf teBEQatSKz779D/vf1Ku3mEeAZTa56ADfvqT5g24aMSM0uVffv3VJ//HFb6OIIAu aHjAAe3b7bl3oxz+OAKVKl725YxZX/7ry2L1ElTBO84pTfb7cfu2u7fPq1+HA8YB SJUULJsx8/tvPvtqpXoKto4AOiq3/d67t2rRbJc9GtSrwx+SR1KlRStnzl2yYN53 /53Jo3ydx3vLA3Xa7tGmbfPmjVu2a1AvJ5vPho5JlRUXFXy/IH/xwtlzZs7huIZX CKB/mrRu1bJ508aNGzZs1rZeTk52Fn+ICaooLyspKfph8cqVS5cuWbRg/tx89SLU Au+dEDRu3qxp0yaNGzZqWL9es9Z169apk5XFB8VaS5Wvid3c/MJVBcsre7d4yeJF 5C4sBDBcDZs3btw4L69hg9zc3Hr16jVulZNTJzs7Vz3LPaXFZaWlJfOWFhcVFRat KihYvnzp0mWLlnNPAgMIoDW5jfIqPyk2atCgfr3KLNatm1M3J+8Q9ajk5P97ZXFJ ZenWtG7lijVWkTqzCCAy7r5MvSA5M3r8Qz0BDiGAMBXAmScSQGxEAJHxxwvUC5Iz u8c09QQ4hAAiY8RV6gXJ+fi0L9UT4BACiIzXO6sXJGfxKW+rJ8AhBBAZs9qpFySn +Jw/qyfAIQQQGassnRvY7271AjiEACLT1OWrNw5TL4BDCCB+burEkDEXVKgnwB0E EJffpV6QpEmnLFRPgDsIIB45V70gSXO68/RJbEAAMeVg9YIkFZz5knoC3EEAsbyR ekGSUpc+qJ4AdxBA82wdBM7IGHqTegHcQQDNO3iKekGyHr3AWPGxHQTQvKuHqxck a/Kpc9QT4AwCaN4rXdQLkrXw5HfVE+AMAmjenNbqBckqOedp9QQ4gwCaV5qtXpCw K0epF8AZBNC6vc3dH+/evuoFcAYBtK7fneoFSXvnVC6GwzoE0LqXfq9ekLT5J01W T4ArCKB1c3dRL0gaR0GwAQG0rjxTvSBxV92qXgBXEEDjDvlQvSB5Yy7iWhCsRQCN G361ekHyXu2qXgBXEEDj3jtcvSB5S5qpF8AVBNA4Uw9EWq/RSvUCOIIA2tZ2tnqB wsnj1QvgCAJo28Db1AsUxp2iXgBHEEDb/nqUeoHCwpbqBXAEAbRtZQP1Agm+BMRa BNC03b5TL9A4+wn1AriBAJo29Ab1Ao03jlUvgBsIoGm2noi50SqbP/ljCwTQNHM3 Q13vJ1+oF8AJBNCyo/6qXqBydz/1AjiBAFo2vod6gcrsduoFcAIBtGxZnnqBSkXj 5eoJcAEBNKz9N+oFOhc/qF4AFxBAw+69VL1A58PD1AvgAgJo2LxW6gU6qYaF6glw AAG0y+adYNa78CH1AjiAANo1uo96gRI/AyODAFo23/Q9UVLN89UToEcAzdrnv+oF Wjdfp14APQJo1p9OVy/Qmm/ugcjYEgE0q6C+eoHYz/6tXgA5AmhV15fVC9S4MT4I oFmTf61eoFaay/PRzSOARrVYoF6gN/B29QKoEUCjHuqtXqDHYRAQQJsyC+qpJzjg t5PUCyBGAG3qf4d6gQve7aheADECaJPl+yBsVLHXDPUEaBFAk45+U73ADS+eqF4A LQJo0tc/Ui9wQ2rXueoJkCKAFnWYql7gimdOUy+AFAG06MND1AtcUd52vnoClAig Qb+erF7gjufNPhgPqxFAg/gGcKPU3hwItowA2tP5dfUCl0w4Rr0AQgTQnjmt1Qtc UtHxb+oJ0CGA5lxyn3qBW2bwhYBhBNCazOUN1BMc03uMegFkCKA19/RVL3DN8iYp 9QSoEEBjWs/OVE9wzhhuDWYWATRm0v+qF7in/KdfqCdAhADactI49QIXTf+VegFE CKApdfI5ArI11w5XL4AGATTF+rOAt6Vodx6RYhMBtISLgLdl8hHqBZAggIZkLWqs nuAsfgi2iQAawg/A21a8HzdFsIgA2sFNELbn2/bqBRAggGY0XJCrnuC0hy5UL0Dy CKAZ7/AMyO1KdXtZPQGJI4BWXHuTeoHrVuyer56ApBFAIzpM4Y96R6Ycql6ApPGu sKH+/IbqCR547Bz1AiSMANrw3uHqBT5IXfSwegKSRQBNGN1HvcAPRYd8op6ARBFA C057Wr3AFwt3L1RPQJIIoAH7/zNLPcEbH/xavQBJIoDhy5vdSD3BI+NOUS9Agghg 8DK/4iKvNFTc0089AckhgMF7vbN6gV/KB96lnoDEEMDQPXy+eoFvSk7imjgzCGDg rrlZvcA/Bb/mZBgrCGDYznhKvcBHSw6Yo56AZBDAoHWcyFOAa2LevsvUE5AIAhiy X0zNVk/w1Kz25eoJSAIBDNg+/6qrnuCtaQerFyAJBDBcbb6qr57gMZ4TZwIBDFaT b3dWT/DaW0erFyB+BDBUeV+3UE/w3IRj1AsQOwIYqLyvWqoneO+1LuoFiBsBDFP9 r9qoJwSAAgaPAAaJ/kXjpW7qBYgXAQxRvf/upp4QCAoYOAIYoPqf07+o8FNw2Ahg ePj5N0pvHKtegBgRwODkfdFaPSEonA8YMgIYGs5/idrE36kXIDYEMDBNvmyunhCc Sb9VL0BcCGBYWnzRVD0hQFwXHCwCGJRdPm+snhCkDw9TL0A8CGBI2nzBAzDj8VEH 9QLEggAGZLfPGqgnBGvG3in1BMSAAIZjr3/lqicEbOZPitQTED0CGIz9p9O/OM36 MQUMDwEMxf5/5/738fphv+XqCYgaAQzEz6flqCcEb85P89UTEDECGIaD3qd/8Zu/ /2L1BESLAAahw+Q66gkmUMDQEMAQ0L+kUMDAEMAA0L/kUMCwEED/0b8kzdt7pXoC okMAvffTj+lfkr7fg2tCwkEAfdf+03rqCcZM/5V6ASJDAD23y1cN1RPM4e5Y4SCA fmvyTRP1BIO4R3QwCKDXcr9tpZ5g0gvd1QsQDQLos52mHaSeYNToy9QLEAkC6LNX eGitSGrAXeoJiAIB9Nh9l6gX2FV64qvqCYgAAfTXwNvUCywr/NV/1BNQewTQW91e UC+wbUmbYvUE1BoB9NU+n2arJxjHo+ICQAA9VXcuJwCqPXG2egFqiwB66p2O6gVI 9XpSPQG1RAD9dNO16gXIyCj68Sz1BNQOAfTSEX9TL8BqM/dUL0DtEEAf1V3EHRDc 8ACnYvqNAPro1ePUC7BW6qhJ6gmoDQLoofMfVi/AeotaqBegNgigf/IW8ghMdzx6 nnoBaoEA+mdCJ/UCbJQ6eLp6AmqOAHrnpHHqBdjUrN3VC1BzBNA3WfmN1BNQxTW3 qBegxgigb/54gXoBqipqWqiegJoigJ5pOytTPQGbeeos9QLUFAH0zMQj1QuwudSP v1ZPQA0RQL90fEe9AFuacIx6AWqIAPplBhefOqhivy/UE1AzBNArnSaoF2Br3jpa vQA1QwC9wgdAN/ER0FcE0Cd8AHQVHwE9RQB9wgdAV1Xsw4FgLxFAjxw8Rb0A2/Ls qeoFqAkC6BHOAXRXWf1S9QTUAAH0R7OF/Gm56+br1AtQA7yl/DGGO885bCmPKfUR AfRGZkE99QRsx/GvqBcgfQTQG/3uVC/A9kz6rXoB0kcAvcE5MG5L1S9WT0DaCKAv mi1SL8D2DR6pXoC0EUBf3NFfvQDb981e6gVIGwH0xfyW6gXYgZYL1QuQLgLoib2+ Ui/Ajoy6Ur0A6SKAnhjbS70AO8Lz4fxDAD2xsLl6AXakouEq9QSkiQD6ocUC9QLs 2HmPqhcgTQTQD4P/oF6AHZv4O/UCpIkA+uHDQ9QLsGMlddULkCYC6IXMkiz1BFTD odyx0TME0AvHvqZegOq49Sr1AqSHAHrh8Z7qBaiOaQerFyA9BNAL3++qXoDqKM1R L0B6CKAPMksz1RNQLQd+ol6AtBBAH/zvJPUCVM+Nw9QLkBYC6IM7+6kXoHq4K6pn CKAPOAvQF8saqxcgLQTQBwX11QtQTdnl6gVIBwH0QC7X2HvjN++pFyAdBNADXXje mDc4CuIXAuiB2waqF6C63jpavQDpIIAeePc36gWornmt1QuQDgLogUXN1AtQXdwQ xi8E0AOl2eoFqLYGHLHyCQF0X5Ml6gWovo7vqhcgDQTQfRwE9smQEeoFSAMBdN+w 69ULUH2PnqdegDQQQPc9eaZ6AarvPQ7Z+4QAuu+DQ9ULUH2cB+MVAui+BS3UC1B9 hVy37RMC6L4iTi3zSAX3rvUJAXRfhXoA0tFyoXoBqo8AOq/tbPUCpINHY/qEADqv 4zvqBUhHzyfVC1B9BNB55z6iXoB0XDtcvQDVRwCdx3nQfrnncvUCVB8BjF6dvZvt 33rJ3HnzFuenIvjl7rskgl8EiXnmtKh+paxmzVu1bt1w1ueLZkTxFwlbQQAjlPvL zu322HP1s7Eb11n3H6VSpYWrvpu3ePGC+XPnLV5SkwdGjO8R4UTEbvIRNf2/zGra bJc2rVo2b7rLbg3q1cla/94sXpqZkVE4Y8ZXr33GA0eiRgCjsX/Hw3/Zpt6O/7mK 8tKiglnzlixaNHfu/EX5pdX4pd8/rNbrkKBv21f3n1wdvNa7tGjWbJfd6+duDN52 rPjnx9P+9kNt1qEqAlhrjY89/teta3r2a2UQl3/57Zw5s+d9v6ykZKtn/M3cvRbj kLj5u2z7v8vJyWvXsm3bNnv+eOe6mTX9O1Py8fuvv1+d/9eJHSOAtZLV/cz/bVT7 XyZVXlzw7ew5//x61vKi0rI1GdxpQwy5Es4vy3eu8m/X/UFm16mb2+Tn/9Ou3Y8a 1Muu/cUiqfmvPjy91r8KCGAttO/TbbdIr3sqWPTdrHlzfpg3a2Uqu2TZ+gIuj6Cw SE5RbpV/2zA3lZHTZO9d27Ru0Wqfnbfxf1MjxZOffn55lL+gRQSwhnIH9W4bwy9b kSotXDZzfnH2ohWlywtWrFi+fOWnOTH8PohN+eoHGNTNa5mXl9ew4c51GrTMyGq0 y571c2r8I+92lL1zx4Tof1VLCGCNdO9zRKzXvKcy1vzyqZLCgtkHx/kbIXp96uQ1 a9Zmj0b1c9Y8yyWVsVOc77KC8bd9FuMvHzoCmL6s6y/LU2+AuyoSflOlPhg2Kdnf MSAEMG239q3G6S5AgqYPeVs9wVMEME2Dh+bu+B8CEja5/9/VE7xEANNy5FPbOckL 0Cl7pt9i9QYPEcB0PHOKegGwLUv6cSOutBHA6jviL43VE4BtS407t1C9wTcEsNoG 35ylngBs15Ten6oneIYAVtdjZ6sXADuypM+f1RP8QgCrqdU89QJgx0p6UcB0EMDq +c276gVAtdzbV73AJwSwWi65T70AqKZJnYvVE/xBAKuDu9LDI/mH/Fc9wRsEcMfq PHOiegKQhrIj31NP8AUB3KE6z3ZTTwDSQgGriwDuCJ//4B8KWE0EcAfoH3xEAauH AO7A05E95RVIUNnPuSikGgjgdjV9rAuvELxUfMET6gke4O29XWN7qRcANZSqW6ae 4D4CuD2Dbq6jngDU1CyeKL1DBHA79n9lT/UEoOZuvk69wHkEcDvG91AvAGpjz5nq Ba4jgNs2dCg3AITXFrZUL3AdAdymA17eQz0BqJ0RQ9QLHEcAt+m57uoFQC1V7P+5 eoLbCOC2XD4qWz0BqK25bdQL3EYAt6HJXw5XTwBq77xH1QucRgC34R7uq4sQlNZL qSe4jABu3SHPt1ZPAKLw8AXqBS4jgFv31BnqBUA0muarFziMAG5VrwfqqScA0Zh6 iHqBwwjgVnEKDMKx99fqBe4igFszcATXgCAYi5urF7iLAG5Fg5eOUk8AotPjefUC ZxHArRh+tXoBEKGSXE6F2QYCuKV2zx+kngBEiftibQsB3NLoPuoFQKTK6pWrJziK AG6Bu8AgOLcNUi9wFAHcwg1D1QuAiBXX51vArSKAm2v5wmHqCUDU+t+lXuAmAri5 i+7hQUgIzux26gVuIoCb40EgCBGXg2wVAdzMEeNaqScA0Xuyp3qBkwjgZh47W70A iANv9a3hVamq6xON1ROAOLxxrHqBiwhgVUOv5xVBkIpy1QtcxNu9Kq4CQah4r28F L0pVfzpdvQCIR5Ol6gUOIoBVnPJIA/UEIB7v/Ua9wEEEsIph16sXADEp5jEPWyKA Vdx9mXoBEBfe7FviNaniyTPVC4C4NFqpXuAeAripzk81VU8A4vKXE9QL3EMANzVw ZKZ6AhCXpU3UC9xDADd120D1AiA2Ffy/9y0QwE1xGjRCxrt9C7wkm+JWWAjZnjPV C5xDADdx0qMN1ROA+Ez6rXqBcwjgJq69kZcDASusr17gHN7xm7j9CvUCIEYcBdkC AdwEx0AQNt7um+MV2QTXgSBsOy9XL3ANAdyo65M7qycAcZpwjHqBawjgRlffzKuB oK3ibm+b4S2/EdeBIHAcBdkcAdyIYyAIHe/3zfCCbDS2l3oBEK+slHqBYwjgBgc/ 30Y9AYjXo+epFziGAG5wwegc9QQgXrPbqRc4hgBuwPNAELySuuoFjiGAG3AhHMLH G74qXo8NOAiM8HEUpCoCuF72C13VE4C4HTpFvcAtBHC9bo83Uk8A4vb2UeoFbiGA 6w24lbPkEbxljdUL3EIA17tliHoBELtUlnqBWwjgenddrl4AxI93fBW8HOtxIRws +NEM9QKnEMB1Wj53uHoCEL+Bt6sXOIUArtPrgXrqCUD8ZvxIvcApBHAd7oYKE3gy XBW869e59Ur1AiAB3BO1CgK4Dp8AYQKfAKvgXb/OyEHqBUAC+ARYBQFc5+7L1AuA JPCW3xSvxjpjuFUuTOAtvylejbUOfHF39QQgCbdepV7gEgK4VpcnuUgcJrzZWb3A JQRwrfPv44EgMIHHgmyKAK7FWTAwoihXvcAlvO3XGjVAvQBIBu/5TfBirMVZMLCC 9/wmeDHWevh89QIgGbznN8GLscbPX9xDPQFIxgjufb4RAVzj6KebqicAyXj2VPUC hxDANc56iLsBwojpv1IvcAgBXKP/KC4RhxE8GG4TBHCNm65VLwASUp6tXuAQArgG j4SDHbzpN+K1WIPTAGEHb/qNeC1Waz3+MPUEICn971IvcAcBXO3g59uoJwBJuf9S 9QJ3EMDVfv9EnnoCkJSJv1MvcAcBXO3cB7gZFszghlgbEcDVrhzJ6wAzChqqF7iD N/5qt3B1JOxIZakXuIMArsZpgLCEd/0GvBSrEUBYwrt+A16KSq3GH66eACTnstHq Bc4ggJU6PLeregKQnHv4iWc9ApjBMzFhzIRj1AucQQArXXBvHfUEIDnzWqsXOIMA ZvBMTBjDkzE34J1facRV6gVAgiq4/e96BLDSnf3UC4Ak8bZfj1cig9MAYQ1v+/V4 JSo91Fu9AEgSb/v1eCUyMv7npT3UE4Ak8Wjg9QggdwOEOW8fpV7gCgKYkXHRaB6T BVMWtFIvcAUBzMi4erh6AZCo4nrqBa4ggNwNEOZwIuB6BDAjY9QA9QIgWbzv1+GF 4Dxo2MP7fh1eiIyM269QLwCSxft+HV4IPgHCHt736/BCZLQdf4h6ApCsISPUCxxB ADOOGMdJUTBm7LnqBY4ggBmnPFpfPQFI1pRD1QscQQAz+t7JY1JhTH5T9QJHEMCM G4aqFwAJK+fqz7UIIGfBwCDe+GvxOnAWDAzijb8Wr0O78R3UE4CkXXezeoEbCGDH Z1uoJwBJe7KneoEbCGDGEb1/tG8eB4JhRlH+p5/yvc9aBHCd/Xrstc++jbhLEAJW kv/pZ58+qF7hFAJY1QE92u/zYzqIsJTkf/bpF/epV7iIAG7VASf+qLKD/FwMzxXl f/b5Zw+oVziMAG7XUWe133fnOuoVQJoqVi3+/FNu9LtjBLA6jjhpn/2a5vJawXll K/771Tc3qFf4gzd1Gn5x/O4/2jcvRz0D2EJq1ZIvvviSr/nSRQBr4JDj2+21dyN+ MoZeqij/i//OuF09w1sEsBYO6dp2z312rstriMSVFeT/96sZd6pneI83bxQ6Hdd6 970a1uHFRMzKi5Z++e13N6pnhIP3bKQ6H9tyt70a8pkQ0SotXPr1zNnD1DMCxFs1 HocftUvLtu0bkELUXGnRsm+/mzvrXvWOkPEGjdvhR7Tcpd2ejepyB0pUR6pk1bJv Zs2d9ZB6iA0EMEFHHtG8eZs9GuXyZSGqKisu+G7O4oU/jFYPMYe3okinw5o2b71H w/o5XG9nU6q0qOC7eYsXzbtbvcQ0AuiCLh0aN22zW4P6dbO5DUO4KspKCwu+n7t0 8UJO23MGAXRPl583bpLXql2DejnZfDz0Waq8pHjV9wuWL1uyiJ9tHUUA3df9Zzvn NWrZtn69unWy+ITororyspKiwtmLVixfmj9KPQbVQwB9dMp+DXZu2KBZm3p1cyqb yJ+hQKqydiVFcxavWrFixVJy5y3ePAE4Ze8GDRvWr5fbuHXdOnWyK4vIn2rEKip7 Vxm84rlLigoLKpN3l3oQIsJbJWBn7Va/Xv3c3Lp1G++Sk5NdJysrk0+L21GRSqXK Vndu3rLi4qJVhYUFBVxrGzreEEad3rpebuX/5NTNycnJa5mTnV35yTFrp5A/PFZU VBauvHz1R7n5K0oqP84VlxQVVlaO+yVbFu7fd9TWWU0rPzzWyamXXSenTnZ2TnaD lnUys7IzM7N3qvwkWVlKF/7uVKztWkX56rSVl5UuWllSVlZaUlpaUlxaUli0iusp sF0u/CVGGC6uWy8rJyMzK6vyL1XW6jMaM9ef1pja8M9sOIqd2vw/2IpUWWr1v5Sv PsBansooKS8q53QSRIoAAjCLAAIwiwACMIsAAjCLAAIwiwACMIsAAjCLAAIwiwAC MIsAAjCLAAIwiwACMIsAAjCLAAIwiwACMIsAAjCLAAIwiwACMIsAAjCLAAIwiwAC MIsAAjCLAAIwiwACMIsAAjCLAAIwiwACMIsAAjCLAAIwiwACMIsAAjCLAAIwiwAC MIsAAjCLAAIwiwACMIsAAjCLAAIwiwACMIsAAjCLAAIwiwACMIsAAjCLAAIwiwAC MIsAAjCLAAIwiwACMIsAAjCLAAIwiwACMIsAAjCLAAIwiwACMIsAAjCLAAIwiwAC MIsAAjCLAAIwiwACMIsAAjCLAAIwiwACMIsAAjCLAAIwiwACMIsAAjCLAAIwiwAC MIsAAjCLAAIwiwACMIsAAjCLAAIwiwACMIsAAjCLAAIwiwACMIsAAjCLAAIwiwAC MIsAAjCLAAIwiwACMIsAAjCLAAIwiwACMIsAAjCLAAIwiwACMIsAAjCLAAIwiwAC MIsAAjCLAAIwiwACMIsAAjCLAAIwiwACMIsAAjCLAAIwiwACMIsAAjCLAAIwiwAC MIsAAjCLAAIwiwACMIsAAjCLAAIwiwACMIsAAjCLAAIwiwACMIsAAjCLAAIwiwAC MIsAAjCLAAIwiwACMIsAAjCLAAIwiwACMOv/A4mbFKbCN8B7AAAAAElFTkSuQmCC"/></symbol><g mask="url(#b)"><g transform="rotate(.193) scale(.36014)"><symbol id="c" viewBox="0 0 1280 1280"><image width="1280" height="1280" xlink:href="data:image/png;base64, iVBORw0KGgoAAAANSUhEUgAABQAAAAUACAIAAACXhmigAAAACXBIWXMAAA7EAAAO xAGVKw4bAADLWUlEQVR4nOzdeZCc5WHgf10MSMg2cTQjzYi/FhBH7AKcMv/Yv6o4 v98u5dQ6VdmqlMvBSVWc/WurnD3idZKtWlflIs4mYIOFQQIkAcYCDNg4OizAmGCw LXEKYsfm0mgOzdEzfcxMd09PX79XGq9CQEf3qJ+3u+f9fMpF6eh+3idkpujvvM/7 PCtXAAAAQAKsbPcEAAAAIA4CGAAAgEQQwAAAACSCAAYAACARBDAAAACJIIABAABI BAEMAABAIghgAAAAEkEAAwAAkAgCGAAAgEQQwAAAACSCAAYAACARBDAAAACJIIAB AABIBAEMAABAIghgAAAAEkEAAwAAkAgCGAAAgEQQwAAAACSCAAYAACARBDAAAACJ IIABAABIBAEMAABAIghgAAAAEkEAAwAAkAgCGAAAgEQQwAAAACSCAAYAACARBDAA AACJIIABAABIBAEMAABAIghgAAAAEkEAAwAAkAgCGAAAgEQQwAAAACSCAAYAACAR BDAAAACJIIABAABIBAEMAABAIghgAAAAEkEAAwAAkAgCGAAAgEQQwAAAACSCAAYA ACARBDAAAACJIIABAABIBAEMAABAIghgAAAAEkEAAwAAkAgCGAAAgEQQwAAAACSC AAYAACARBDAAAACJIIABAABIBAEMAABAIghgAAAAEkEAAwAAkAgCGAAAgEQQwAAA ACSCAAYAACARBDAAAACJIIABAABIBAEMAABAIghgAAAAEkEAAwAAkAgCGAAAgEQQ wAAAACSCAAYAACARBDAAAACJIIABAABIBAEMAABAIghgAAAAEkEAAwAAkAgCGAAA gEQQwAAAACSCAAYAACARBDAAAACJIIABAABIBAEMAABAIghgAAAAEkEAAwAAkAgC GAAAgEQQwAAAACSCAAYAACARBDAAAACJIIABAABIBAEMAABAIghgAAAAEkEAAwAA kAgCGAAAgEQQwAAAACSCAAYAACARBDAAAACJIIABAABIBAEMAABAIghgAAAAEkEA AwAAkAgCGAAAgEQQwAAAACSCAAYAACARBDAAAACJIIABAABIBAEMAABAIghgAAAA EkEAAwAAkAgCGAAAgEQQwAAAACSCAAYAACARBDAAAACJIIABAABIBAEMAABAIghg AAAAEkEAAwAAkAgCGAAAgEQQwAAAACSCAAYAACARBDAAAACJIIABAABIBAEMAABA IghgAAAAEkEAAwAAkAgCGAAAgEQQwAAAACSCAAYAACARBDAAAACJIIABAABIBAEM AABAIghgAAAAEkEAAwAAkAgCGAAAgEQQwAAAACSCAAYAACARBDAAAACJIIABAABI BAEMAABAIghgAAAAEkEAAwAAkAgCGAAAgEQQwAAAACSCAAYAACARBDAAAACJIIAB AABIBAEMAABAIghgAAAAEkEAAwAAkAgCGAAAgEQQwAAAACSCAAYAACARBDAAAACJ IIABAABIBAEMAABAIghgAAAAEkEAAwAAkAgCGAAAgEQQwAAAACSCAAYAACARBDAA AACJIIABAABIBAEMAABAIghgAAAAEkEAAwAAkAgCGAAAgEQQwAAAACSCAAYAACAR BDAAAACJIIABAABIBAEMAABAIghgAAAAEkEAAwAAkAgCGAAAgEQQwAAAACSCAAYA ACARBDAAAACJIIABAABIBAEMAABAIghgAAAAEkEAAwAAkAgCGAAAgEQQwAAAACSC AAYAACARBDAAAACJIIABAABIBAEMAABAIghgAAAAEkEAAwAAkAgCGAAAgEQQwAAA ACSCAAYAACARBDAAAACJIIABAABIBAEMAABAIghgAAAAEkEAAwAAkAgCGAAAgEQQ wAAAACSCAAYAACARBDAAAACJIIABAABIBAEMAABAIghgAAAAEkEAAwAAkAgCGAAA gEQQwAAAACSCAAYAACARBDAAAACJIIABAABIBAEMAABAIghgAAAAEkEAAwAAkAgC GAAAgEQQwAAAACSCAAYAACARBDAAAACJIIABAABIBAEMAABAIghgAAAAEkEAAwAA kAgCGAAAgEQQwAAAACSCAAYAACARBDAAAACJIIABAABIBAEMAABAIghgAAAAEkEA AwAAkAgCGAAAgEQQwAAAACSCAAYAACARBDAAAACJIIABAABIBAEMAABAIghgAAAA EkEAAwAAkAgCGAAAgEQQwAAAACSCAAYAACARBDAAAACJIIABAABIBAEMAABAIghg AAAAEkEAAwAAkAgCGAAAgEQQwAAAACSCAAYAACARBDAAAACJIIABAABIBAEMAABA IghgAAAAEkEAAwAAkAgCGAAAgEQQwAAAACSCAAYAACARBDAAAACJIIABAABIBAEM AABAIghgAAAAEkEAAwAAkAgCGAAAgEQQwAAAACSCAAYAACARBDAAAACJIIABAABI BAEMAABAIghgAAAAEkEAAwAAkAgCGAAAgEQQwAAAACSCAAYAACARBDAAAACJIIAB AABIBAEMAABAIghgAAAAEkEAAwAAkAgCGAAAgEQQwAAAACSCAAYAACARBDAAAACJ IIABAABIBAEMAABAIghgAAAAEkEAAwAAkAgCGAAAgEQQwAAAACSCAAYAACARBDAA tFhvb+/Kd/wHduXx30T/q0dO/mH0y1Qq1YbJAUCCCWAAaE5fX++K41m7KsrYNWvW XHjhhdFvV61adcEFFyxhtKiKS6VSrVaLfp3P5yuVSjR2vX78t5OTChkAWkkAA8Cp bdiwYdWqlVHorlmzeu3atVHirlu3LuY5RHlcLBajPI7+GbVx9NtqtTY9PR3zNABg eRDAAPBLfX29i7l74YUXnn/++atXr273jE7hRANXS6WFQiFfqVSjNraUGgAaJIAB SK6oeM8777y1a9f2nNDu6SxRlMTlcjlK4vn5YvQLC6cB4HQEMAAJ0tvbu2rV8Xu8 73vf+5b2yG7ni3p4fn5+bm6uUqmcuD881e4ZAUCnEMAALHMno/cDH/hA997mXZoo hhcWFmZmZiqVamRqSgwDkGgCGIBlaMOGDatXR9G7JoHRezrviOHKiRi2kxYAiSOA AVg+ent7e3rOu/DCC+Pfrrm7LG4rXSgUFhbK9tACIDkEMABdb3EvKzd7l+DkbeHo n54WBmDZE8AAdKuNG/vWrFnzwQ9+sDPPK+ouUQlXKpVsNlsuVyYnJ9s9HQAIQgAD 0GUW7/fq3kBOlrDV0QAsPwIYgO6w+Hyvdc6xiUq4VCrNzs5aHQ3AsiGAAehoGzZs OP/8nmV8bG/ni0q4UCgWCnklDEC3E8AAdChLnTuKpdEALAMCGIDO4pZvhztxhNJ8 Pp8vl90QBqDLCGAAOsXiU75u+XaFer1eLpdzuZwbwgB0EQEMQPv19fWdd96aKIDb PRGaVq1W0+m0DAagKwhgANpp8+aBCy+8cN26de2eCOekVqvl8/lCoTg2NtbuuQDA aQlgANojSl9nGi0z9Xp9fn5+dnb22DEZDEAnEsAAxE36Lm8yGICOJYABiI/0TY4o g4vF+bk5GQxABxHAAMRB+ibTiQwuzs3NyWAAOoEABiAs6YsMBqBDCGAAQhkY6F+/ fr0dnllUrVanp9PlsgOTAGgbAQxA623atPH973+/9OW9arXa1NT0wkIp+me75wJA 4ghgAFqpt3dDT09Pb29vuydCR6tUKplMJp/PZ7O5ds8FgAQRwAC0zObNAx/84AdX r17d7om0U61Wa/zFq1atCjeTzjc/Pz8zM3vs2LF2TwSApBDAALTAwED/+9///gsu uKDdE4lPtVpd3NnrQx/68Pnn9/zar33oV3/1g9Fvb7jhs2d4Vy6Xi6pv8ddRKj/6 6KOrVq1MpzOvv/6LhYWF119/PfrzcrmcnB8iRP8S8vlCPp8fHx9v91wAWP4EMADn JCFrnuv1+rp167ZsufwjH/lIFLpnrtxTOrEF1HQ0ToMv/va3v53JpP/5n//5yJHB +fni8r5XvLgienTUrWAAwhLAACzdcl3zvHh390Mf+nCUu5dffvn1119/jgPOzMwU i8VznNLTTz/91ltvvfbaq2+88Wa1Wll+/9qjf0Wzs7OOSgIgHAEMwFIsv32e6/X6 li1bouj91Kc+de2117Zq2FqtNj093dSDwQ0Oe/jw4ccff/yNN14fGhpaNveHo85P p9Pz86XoX1q75wLAMiSAAWjasrnxG/2fEBXvv//3/99v/ub/29/f3/Lx5+bm8vl8 y4d9lyiGx8bGnnnmmeeee+7NN98IfbkYzM/Pz87OWhENQMsJYACa0N+/6QMf+EBX b3ZVrVavuOKKj3/8//nd3/3dENF70tTUVHStcOOfUhTDIyMje/b84/PPPx/9ont/ SLF453xhYSGVmmr3XABYPgQwAI3avHmgeze7Wrt27Uc+8ut/9Ed/1MLlzaeTz+fn 5uZCX+Wsovx+8cUXH3rooX/5l5/Fn+ItEQVwLpdzKxiAVhHAAJxd9z7xG3Xvb/zG Jz7/+c8Hvdn7Tm258XtmtVptaGho584dzz//Qq3WWXM7q8Wngt0KBqAlBDAAZ9GN T/zG372RQqEwOzsb2+WWICrhwcHBe+7Z1XUlXCwWZ2Zmx8ZsEA3AORHAAJzWpk0b 15/Q7ok0Kqr0//Afro+5exdNT09XKpWYL7pkUQkfOXJk586dzz///Mou+SzgrGAA zl2X/EcPgNgNDPRfdNFFPT097Z7I2VWr1Y985Nf/63/9rzE83/tepVIpm83Gf92W KJfLhw4duvfee95+++3Ov8lfr9cXn68eH59o91wA6EoCGIBT6Jb9rgYGBn7v937v hhs+264JZDKZhYWFdl29hQqF/H333bd3776FhVK753IWpVIpl5s5dsytYACaJoAB +De6Yr+r9t7yXVSpVNLpdL1eb9cEQiiXyz/5yU/uvfeewcHBTr4hvLgzluXQADRL AAPwr/r7N23YsKGTy2fxKd8bb7yxvdOYmZkpFovtnUNQUV7+/d///YsvvrBq1ap2 z+W05ubyc3OzlkMD0DgBDMAvdfiy57Vr1/7n//yfP/e5P2rvNOr1+tTUVK1Wa+80 4lEo5Hfs2LF3796OvdE9Pz8/MzNz7JjdoQFoiAAGYEVv74aenp6Ord+BgYG//uu/ aeNq55MWd2Bq9yziVi6Xn3jiidtv/3r0i3bP5RSiWWWzWcuhAWiEAAZIuk2bNl50 0UUXXHBBuydyCp2Tviu67aCjluvkDK7VatH/d0ql0tTUdLvnAkBHE8AAidaxD/12 VPp29UFHrRXV74EDB+644/YO/FnA3AkeCQbgDAQwQHJ15kO/HZW+kSh9owBu9yw6 y4kM/t4dd9zRaRlcLBZnZmbGxsbbPREAOpQABkioDqzfTkvfarU6PT3dsfs/tV2U wfv379+27Y7oX1S75/KvFhYWcrmcR4IBOCUBDJA4Hbjl1erVq//Lf/kvbd/h+Z3m 5uby+Xy7Z9EFZmZm7rzzzgMHDqxa1SkfKmyLBcDpdMp/qwCIR6dteVWtVj/72d// 4he/2O6J/BsJ3+9qCdLp9E033XTo0MEOeZ58cVssDQzAuwhggATpqPqN0vcjH/n1 Xbt2tXsi/8bCwkImk2n3LLrV0aNHv/Sl/z0+Pr5yZfs/YCw28Pz8/PR0ut1zAaBT tP+/TwDEo6M2fF67du0tt9z60Y9+tN0T+TdmZmaKxWK7Z9HdKpXKt7/97bvuurMT GjgyOzuXz9saGoBf6oj/OAEQWufUb7Va/W//7b911OO+i1KpVK1Wa/cslomZmZmv fe3Wp59+uhO+5DQwACcJYIDlr3M2fL766mv+9m//tr+/v90T+Tfm5+dzuVy7Z7Hc 1Ov1Q4cO/cM//P3s7Gy75+J4JAB+SQADLHMdUr9RDv3VX/31pz71qXZP5N0c8xtU VJ533nnnP/7jd9t+K1gDA7BCAAMsbx1Sv1dffU2nbXa1yLLneLz55ht/+qd/2vZj pTQwAAIYYNnqhPrt2Bu/lj3HLIrP7du37dmzp723gjUwQMIJYIDlqRPqt2Nv/Fr2 3C4///nP/9f/+l+FQjtvBRcKxdlZDQyQUAIYYBlqe/1Wq9W/+ZsbO/DG7wrLntut WCzedtvWAwcOtPFWcKFQmJmZHR/XwACJI4ABlpu21+/AwMBdd93daVs9R0qlUjab bfcsOO7xxx//6le/0safRGhggGQSwADLSnvrt1qt/sf/+Kkbb7yxXRM4g5mZmWKx 2O5Z8K9GR0f/+q//6u233165sj2fRjQwQAIJYIDlo73127H7XUWmpqaiOG/3LHi3 +fn52267bf/+fWvWrGnLBDQwQNIIYIBlor3127HLniuVyvT0dLtnwZl873vfu+WW r9br9bZcXQMDJIoABlgO2lu/n/zkb3Xmsud8Pj83N9fuWXB2w8PDf/VXfzk0NNSW q0dfJ9lsLpVKteXqAMRJAAN0vf7+TRs2bGjLnrqdvNtzJpNZWFho9yxoVKlU+j// 5++ee+65tlw9qt90Ol0szrfl6gDERgADdLc21m+9Xt+zZ+/FF18c/6XPyllHXeob 3/jGPffsasvX84kGztgpDWB5E8AAXWzTpo29vb1tqYWOfei3XC6n0+l2z4Kl27Nn z223bW3LI8FRA4+OHov/ugDERgADdKuofi+66KILLrgg/ktfffU1u3btiv+6Z+Wh 3+Xh1Vdf/dKX/vf8fNwLkmu12vR0enR0NObrAhAbAQzQra644vK21G/Hbnnlod/l ZGho6C//8i9GRkZivq4GBljeBDBAV2rLts+dvOWVh36Xn/n5+S9/+W9/8pOfxHzd hYWFXC5nLTTAsiSAAbqP+n2naGJTU1PtngVBtKuBi8X5mZmZsbGxmK8LQGgCGKDL tKV+O3bD5yiQcrlcu2dBWLt27bz//vtj3uwtny9ks1mHAwMsMwIYoJu05dCjjq3f ubm5fD7f7lkQh507d37zm3E3sIORAJYfAQzQNTZt2vjBD36wp6cnzot2bP3a8ipp 7r777gce2B1nA0df/FNTUx4GBlhOBDBA14h/2+e1a9c+9NC3OrB+oyypVqvtngVx 2717986dO1atWhXbFW0KDbDMCGCA7hD/o78DAwN79+6L84oNmpycrNfr7Z4F7bFn z55bb70lzga2KTTAciKAAbqA+l1kw2eyudyePf94z65dca6Fzufz2WzOhlgAy4AA Buh08W981Zn1WyqVstlsu2dBm5XL5dzMzHcfe2z37m/G+U0R1W8mky0UCrFdEYAQ BDBAR9u0aeNFF10U56O/nVm/UXjMzs62exZ0hGwuNz4+/sNnnnnooQdja+BqtZpO py2EBuh2Ahigo1166SXr16+P7XL1ev2VVw7HdrkGzczMOIqGk8rlctTAoyMjTzzx xIEDB9asiamBj183m9XAAF1NAAN0rpgf/e3ME48cd8R7RQF87Nix0vz8d7/72A9/ +MM1a9bEc91CoRA18OSkh4EBupUABuhQMT/625n1m06ny+Vyu2dBx4m+KjLZ7OjI SPTrxx577Nln42vgqH6jBvYwMECXEsAAnai3d8Ov/uqvxvbob2fWr8N+OYNsLjcy PLz485HHHvvOs88+G08DexgYoKsJYIBOFOfi5+gD/d/8zY2f+tSn4rlcg1KpVK1W a/cs6FxRAE9OTubn5lac2CF8166dg4OD8Vx6fn5+Zmb22DENDNB9BDBAx1G/6pez WjwP6djo6OIygaiBd+7ccfTo0XiuPjc3l8vlUimnUgN0GQEM0Fk2bdoY1W9sj/5+ 5jO/98UvfjGeazVocnKyXq+3exZ0gcXzkIr/93HcdDp95513ZrOZeK6eSqUshAbo OgIYoLPEee7RJz/5WzfeeGM812pE1L1R/bZ7FnSNk+chnfyJSfT1s3379nx+Lqar OxUJoNsIYIAOEufi54GBgb1798VzrUbUarVUyukyNOd4AI+OLpRKJ//khRdeePDB B+M5HNhCaICuI4ABOkWci5+jq7zwwosxXKhB6peleed5SCc9+eSTBw58L55NoS2E BuguAhigU8S2+LnTDj1Sv5yLbC43PDxc+bfnRT/66CM//vFPYrgPbCE0QHcRwAAd IbbFz5227bP65RxFATwxMVHI59/5h6VSaceOu4eGhmKYgIXQAF1EAAO0X2/vhk2b NsWz+Lmjtn1Wv5y7xa2wjo2OvuvorHQ6vX379lwuG8McLIQG6BYCGKD9Yrv9e/XV 1+zatSuGCzXCns+0ShTAY2Nj88Xiu/78Zz/72X333RvDBEqlUi43c+yYBgbodAIY oM0GBvr7+vpiuFCnbXw1MTHR7imwTCzeBB4ZHn7vXz3++ONPPPF4DBtizc7OzszM WtEA0OEEMECbXXXVlT09PaGvUq1W9+3b3zkbX01OTp48uxXO3fEAHhkpLyy896/u u+/en/3sZ6EnEH09T01NWQgN0OEEMEA7xbb4+fOf//znPvdHMVyoEalU6l2Pa8I5 igJ4cnIyPzf33r+anZ3dtm3b9HTwTaoKhUI2m52cdBMYoHMJYIC22bRp46ZNm2K4 UEc9+js1NVWtVts9C5abcrmcm5kZHR2tneqr66c//ek3vnFfDNOwGxZAhxPAAG2z Zctl69atC32Vjnr0d3p6ulKptHsWLE+n2wpr0fe+973vf//J0A8DR1/eUQNPTNjd DaBDCWCA9ohn76tqtXr33Ts++tGPhr5QI9LpdLlcbvcsWLbOsBXWihNnbt11151H jhwJPY0ogKMv9WJxPvSFAFgCAQzQHvHsfdU5p/7mcrn5eUlAWGfYCmvFiQUI27Zt m52dCToHu2EBdDIBDNAG8ex9tXbt2h/96Mehr9KIfD4/d6rdiaC1yuVyOpM5Njp6 uhf80z89vWfPntALoaMv+NzxTbnshgXQcQQwQNx6ezds2rRp9erVQa/SOecelUql bDbb7lmQFNlcbujo0TNstLZr185f/OIXoaeRSk2Nnr7DAWgXAQwQt3hu/3bI4uda rZZKuQ9GfM68FdaKXy6EvmN2djboNObn5zOZjN2wADqNAAaIVZS+UQCHvkrnLH6e mJho9xRIljNvhbXo6ad/sHfv3tALoR2JBNCBBDBArGK4/ds5i5+jAKjVau2eBYlz 5q2wFu3YseONN14POo1SqZROp90EBugoAhggPv39mzZu3Bj6Kh2y+NmhR7RLFMAT k5OFM+67NjU1tW3bHaH3ZjtxJFKmePr12ADETAADxGfLlsvWrVsX9BKrV69+4YUX g16iEbOzs4VCod2zIKHK5XJuZmZ0ZOTMCxAOHDjw5JNPBF0IXalUUqkpDwIAdA4B DBCTgYH+vr6+oJeoVqt3373jox/9aNCrnNXCwkImk2nvHEi4bC53bGysdMZbr1Ee b9++7ejRo0Fn4iYwQEcRwAAxieH279VXX7Nr166gl2iE+120XblczmSzoyMjZ37Z 4cOHH3hgd9CZnLgJnPIkMECHEMAAcYjn9u+rr74W9BKNsPEVHSKbyw0PD1fO9iD6 gw8+8PLLL69cGfATkZvAAJ1DAAPEIYbbv5///Oc/97k/CnqJs8pkMgtn3HoXYnN8 K6yJiUI+f+aXzczM3H7717PZbLiZuAkM0DkEMEBwMdz+7YSDfwuFwuzsbHvnACct Hgg8OjJSr9fP/Mqnnvr+/v37g+6G5SYwQIcQwADBxXD7d/v2O9u+95VHf+k0xwN4 dHShVDrzy6JC3rr1a8eOHQs3E9tBA3QIAQwQVl9f78DAQNBLdMLeVx79pQOVy+V0 JnNsdPSsrzx8+JXdu3d7Ehhg2RPAAGFt3jzQ29sbbvxqtXrgwOP9/f3hLnFWMzMz PtbTmbK53NGjR2vV6llfedddd7311pvhZlIqldLptCeBAdpLAAMEFKVvFMBBL/Gx j31869atQS9xZsdvsqXTbZwAnEEjBwIv+pd/+Zf77rv3rA8Mn4tUKjU6GnChNQBn JYABAorh9m/bjz6anJwM2gxwLho8EHjRN7/5zVdfPRxuIbSbwABtJ4ABQtmwYUN/ /6bVq1eHu8QnP/lbN954Y7jxzyr6NF8+2zmr0F7HDwQeGqpUKmd95dtvv71z545G XrlkbgIDtJcABghl2d/+LZVKQU9PhZaIAnh8fLxYKDTy4m9+8/5XX3013E3gQqEQ fddMTqYCjQ/AmQlggFCuuurKnp6ecOO3/favM13oCosHAo8MDzfy4tA3gev1+tTU lJvAAO0igAGCWPa3f7PZbOlsx6tChzi+Cnp4uNLYcv377//Ga6+9Fu4m8Ozs3MzM TCrlJjBAGwhggCC2bLls3bp14cZv7+1fOz/TXY6vgp6YKObzjbz4rbfe2rlzR7WB k5OWplKppFJTFlAAtIUABmi9vr7egYGApx+1/favnZ/pLr9cBT0ysqKxr9vQN4FT qVQ6nXF6NkD8BDBA64Ve/9ze278zMzM+uNN1FgO4vLDQyItD3wR2HhJAuwhggBYL ffpRe2//1mo1zy7SjaIAnpiYKDS2CjryjW9845//OexNYFthAcRPAAO02PK+/Ts1 NRXuthiEs7gKenRkpMHV+2+99daOHTtqtVBf7bbCAmgLAQzQYldccfkFF1wQaPAo Pg8ceLy/vz/Q+Gfm4F+6WlOroCPbtt0xODgYaDLR9/Lk5KRV0AAxE8AArdTb27t5 c8Dtr66++ppdu3aFG//M7H1FV2t2FfRLL7304IMPrFq1KtB8rIIGiJ8ABmil0Ouf 9+3b367bv3Nzc/mGywE6ULOroCNbt24dHR0JNJ9isZjJZCcn3QQGiI8ABmilq666 sqenJ9DgAwMDe/fuCzT4WTm2lGWg2VXQTz/9g717965ZsybEZKIOHx+f8J0FECcB DNAyGzf2Bb09++Uv/931118fbvwzyGQyCw03A3SsKICj5Cw2vJahWCx+7Wu3Rl// geaTSqWmp9Pz8/OBxgfgXQQwQMsEXf9cr9dfeeVwoMHPzNFHLBuLq6BHhocbf8vD Dz986NDBQAeblUqlKICtggaIjQAGaJkPf/hD4Y7/bePpR9PT05VKpS2XhpaLAnh4 eLhSLjf4+jfffHPnzh21Wi3QfGyFBRAnAQzQGkFv/1ar1VdffS3Q4Ge99NTUVFsu DSEcXwU9Pl4sFBp/y9133xVlcKD5zJ4wOWmRBUAcBDBAa1x66SXr168PNPhll132 0EPfCjT4mbn9yzKzhFXQzz333He+8501a4Ks71hYWIi+yxwIDBAPAQzQAhs2bLj4 4s3hxm/X9ldR+kYfzeO/LgQVBfDQ0FC14Z/sFIvFW2+9NZsNuBWWVdAA8RDAAC2w XLe/mpqaqlarbbk0hBMF8LFjx0rN7L38rW996/nnDwV6yN8qaIDYCGCAFgi6/vlj H/v41q1bAw1+Bm7/slyVy+V0JnNsdLTxt7z22mv333//yjCfm6yCBoiNAAZogaD7 P+/btz/o8cKn4+lflrFsLjc4OFhvZm/nW2+9ZWxsLNB8xsbGJyYmAg0OwEkCGOBc bdzYFy5Q165d+6Mf/TjQ4Gfg7F+Wt+P7YI2MlBcWGn/L/v37n3rq+2vWrAkxn+jb LZ3OFIvFEIMDcJIABjhXQR8Abtfxv5lMZqGZNoDuEgXwxMREIZ9v/C1vvPHGzp07 6vV6iPnMz89HATw5aRU0QFgCGOBcXXXVlT09PYEGb9f6Z6sxWd6WcBhS5JZbbhkf D7IKOurq8eOLoH3fAYQlgAHOSW9v7+bNA4EGb9f659nZ2UKhEP91IU5RAA8PDTX1 oPu+fft+8IOnwq2CzuVyc3NN3JQGoFkCGOCcLMv1z25DkQRRAI+Njc0389jtiVXQ O+v1JrbOalw+n89mc569BwhKAAOcky1bLlu3bl2gwduy/rlQKMzOzsZ8UYjfEg5D WhFyFXQ0n6mpKYchAQQlgAGWbsOGDRdfvDnQ4O1a/zw5ORlomx/oNJls9ujgYFNf 8Hv37n366R8EWgXtMCSA0AQwwNIFPQCpLeufq9Xq1NRUzBeFdjn+GPDwcKVcbvwt r7/++q5duwKtgnYYEkBoAhhg6YI+ANyW9c+5XG5+fj7mi0K7LOEx4BUhV0FH6ZvJ ZB2GBBCOAAZYuiuuuPyCCy4IMXK9Xn/llcMhRj4zyy9JlKU9BvzQQw++8MILq1ev bvl8qtXq5GTKtyFAOAIYYImCPgB89dXX7Nq1K9DgpzM/P5/L5WK+KLTXEh4DPnTo 0COPPLxq1aoQ80mlUqOjx0KMDMAKAQywZBs3buzv3xRo8C9/+e+uv/76QIOfztTU VLVajfmi0F5LeAy4WCzecstXA/20aHZ2dmZm1mFIAIEIYIAlCvcAcFShr776WoiR z6Ber3vykARa2mPAO3bseOON10PMx2PAAEEJYIAlCvcAcFsOQJqbm8vn8zFfFNpu aY8B79mz55ln/sljwABdRwADLEXQB4DbcgCS439JrEw2O3jkSFNvef311++5Z1et FuQwJKcBA4QjgAGWoq+vb2Ag1BlFO3bsvPbaawMNfkrWP5Nk2VxuaGioWqk0/pYo fW+66aZ0ejrEfFKp1PR02oFkACEIYIClWGYPAFv/TJJFATw6OrpQKjX1rnvvvfdn P/vpypWt/yhVKBSy2ezkpH2wAFpPAAMsxZYtl61bty7EyG15ANj6Z5IsCuDxiYli kz8DCvcYcLlcnpqampiwKAOg9QQwwFJ8+MMfCvHBN/Kxj31869atIUY+Aw8ckmRR cGay2dGRkabedfjw4d27vxniDvAKjwEDBCOAAZrW29u7efNAoMHjPwE4n8/Pzc3F eUXoNNlcbvDIkabWQRSLxa9+9SszMzMh5iOAAQIRwABN27ixr78/1A5YL7/8SqCR TyeVSgXazBa6RRTAw0NDlWb2wYrcccftR48eDTGf6Lsync4UmzydGICzEsAATQu3 A9bq1atfeOHFECOfgRtNsLR9sB555JGDB38S4mkI+2ABBCKAAZoWbgesq6++Zteu XSFGPp2FhYVMJhPnFaEDHd8Ha3y8WCg09a6DBw8++ugjq1atavl87IMFEIgABmja VVdd2dPTE2LkP/zDz/3xH/9xiJFPJ5fLOW4UouBMZzLHRkebetfQ0NCdd25vduF0 I+r1ehTkAhig5QQwQHM2bNhw8cWbAw2+Y8fOa6+9NtDgp+QAJFiUyWYHjxxp6i21 Wu2mm25Kp6dDzMc+WAAhCGCA5vT19Q4MBNkCulqtvvrqayFGPgOfsGFRNpc7evRo rVpt6l133XXXW2+9GWI+9sECCEEAAzRn48aN/f2bQowc/w5Y0WfrQIe4QNc5vhH0 8HClXG7qXeH2wZqbm8vlZqIMbvnIAEkmgAGaE24L6Msuu+yhh74VYuTTyWQyCwsL cV4ROlYUwMeOHSs1+Uj8M888s2fPP4YI4GKxGH2H2ggaoLUEMEBzwm0B/YlP/ObN N98cYuTTsf4ZTlraRtCHD7+ye/fulStb/4HKRtAAIQhggOaE2wL6C1/4wg03fDbE yKcjgOGkKIAnJyfzc3NNvSuVSm3d+rUQKylObAQ94ZsUoLUEMEBzrrnm6kAj79u3 v7+/P9Dg73X83Jd0OrbLQYeLviOiBh4ZHm72jTfffHMqFeQ+rY2gAVpOAAM0obe3 d/PmZbIF9NzcXD6fj/OK0OGiAB48cqTZg8HCbQQ9NjZmCTRAawlggCaEOwMp/i2g p6enK5VKnFeEDre0k5DCbQTtJCSAlhPAAE3YuLEv0CrlqKv37t0XYuTTsbQS3mVp JyEdOHDgySefWLNmTcvnk8/nc8efTLYRNEDLCGCAJoQ7A+m6667btm17iJFPRwDD u0QBPDo6ulAqNfWugwcPPvLIwyHuAOfzhWw26yhggBYSwABNuPTSS9avXx9i5N/5 nf/0pS99KcTIp7SwsJDJZGK7HHSFpR0F/POf//zee+9p9snhRkTfp9PT0x4DBmgh AQzQhHCHAMd8BlI+n59r8rgXWPaWdhTw5OTkbbdtDXESkqOAAVpOAAM0IdwhwDt2 7Lz22mtDjHxKmUwmxOd16GpRAE9MThaa/NlQrVb7h3/4+xBLKk4cBTwugAFaSAAD NCHcIcAvv/xKoJFPaXJyMsSKTehqxw/HzmSOjY42+8avf/224eYPEG6Eo4ABWksA AzRqw4YNF1+8OcTI8R8C7CM1nFImkxkcHGz2XXfeuf3tt98OMB0BDNBiAhigUcvp EGAfqeGUMtns4JEjzb7r4YcfPnToYIiNoMfGxiyBBmghAQzQqGUTwLaAhtPJ5nJR ADf7gIAABugWAhigUX19fQMD/SFGjrp67959IUY+pUKhMDs7G9vloItEAXx0cLBW qzX1rgMHDjz55BNr1qxp+XxSqVQ6nS4WmzuZCYDTEcAAjdq4sa+/P0gAX3fdddu2 bQ8x8ilF9Vto8qAXSIgogIeOHq1Wq0296+DBg4888nCIO8D5fD6bzUUZ3PKRAZJJ AAM0atkEsDOQ4HSOB/DQULVSaepdIQO4kM1mBTBAqwhggEZt3jzQ29sbYuRPfOI3 b7755hAjn1L0YbrZFZ6QEFEADw8PV8rlpt71yisvP/DAAytXtv5jlQAGaC0BDNCo Sy+9ZP369SFG/sIXvnDDDZ8NMfIp2QIaTmdpATw5Obl169fKTb6rEaVSKZ1O2wcL oFUEMECjtmy5bN26dSFGFsDQIaIAHhkZKTf5jEC4AI7GnJqaEsAArSKAARolgGHZ iwJ4dGSk2YfkBTBAtxDAAI1aHgFcr9ejD+vxXAu6zvEAHh1dKJWaepcABugWAhig UVdddWVPT0+IkeMM4Gq1Gn2ejuda0HU6LYDr9fr4+IRVGwCtIoABGrU87gBHn9HT 6XQ814Ku02kB7A4wQGsJYIBGLY8ALpVK2Ww2nmtB1xHAAMubAAZoVLgAjvMc4GKx ODMzE8+1oOssLYDDnQMsgAFaSwADNCpcAF933XXbtm0PMfJ75fP5ubm5eK4FXWdp AXzw4MFHHnl49erVLZ+PAAZoLQEM0KhLL71k/fr1IUaOM4BnZ2cLhUI814Ku02kB XCqV0um0AAZoFQEM0KjNmwd6e3tDjDwwMLB3774QI79XLpebn5+P51rQdZYWwAcO HHjyySfWrFnT8vnk84VsNptKpVo+MkAyCWCARm3c2Nff3x9i5NWrV7/wwoshRn6v 6MN0qckP95AcxwN4ZGRhYaGpdz388MOHDh0McQdYAAO0lgAGaJQAhmUvCuCRkZFy BwVwPpvNCWCAVhHAAI3q6+sbGAgSwNVq9dVXXwsx8nsJYDiDKICHh4crTR5odOed 299+++0Q84nSN51OF4seWwBoDQEM0Ki+vt6BgYFAg7/88iuBRn6XTCbT7PJOSI7j ATw0VKlUmnrX179+W5TNIeYzNjZmByyAFhLAAI0KGsA7duy89tprAw3+TgIYziAK 4KGhoWozAVyr1f7hH/4++s4KMR8BDNBaAhigCddcc3Wgkb/whS/ccMNnAw3+Tul0 utzk8k5IjiiAjx49WqtWG3/L5OTkbbdtDfRzpbGx8YmJiRAjAySTAAZoQrgA/p3f +U9f+tKXAg3+TgIYzuB4AA8O1mq1xt/y85///N5776nX6yHmI4ABWksAAzThqquu 7OnpCTHyddddt23b9hAjv4sAhjOIAnjwyJGmavbgwYOPPPJwiC2go2mMj49bAg3Q QgIYoAlbtly2bt26ECMPDAzs3bsvxMjv4hlgOINMNhsFcFNvOXDgwJNPPrFmzZqW T6ZcLk9NTQlggBYSwABNuPTSS9avXx9i5NiOAs7lcvPzjlSBU8tkMoODg0295ZFH Hjl48Cch7gAvLCxMT08LYIAWEsAATdi8eaC3tzfEyLEdBTwzM1MsFmO4EHSdcrmc zmSOjY429a677rrrrbfeDDGffL6QzWZTqVSIwQGSSQADNGHjxo39/ZsCDb5v3/7+ /v5Ag580OztbKBRCXwW6UTaXm5icLMzNNfWum2++OZUKcpN2bm4ul5sRwAAtJIAB mhD0KOB4TkKKPlLn8/nQV4FuFAXw+Ph4sZmfEEV1unXr1wI9Vx8Nnk5nLNkAaCEB DNCE3t7ezZtDBfAnPvGbN998c6DBT4rqd67JG1yQEFEAHzt2rNTMQ/KHD7+ye/fu lSuDfKAaGxvzADBAawlggOaEOwr4sssue+ihbwUa/KRCoTA7Oxv6KtCNogAeHR1d KJUaf8szzzyzZ88/htgBa4VDgAECEMAAzQl3FHA8G0GXSqVsNhv6KtCNogAeHh6u NHNQdrgtoE8cAjwhgAFaSwADNCfcUcDxbARdqVSmp6dDXwW6URTAQ0ePRt+Jjb8l 3BbQDgEGCEEAAzQn3ElIkR07dl577bWBBl9Uq9VsKgunFAXw4JEj9Xq9wddH3003 3XRTOh3kJ0rOQAIIQQADNCfoSUh/+Ief++M//uNAg59kUSWcUiabjQK48dcPDQ3d eef2SqUSYjLOQAIIQQADNCfoSUhXX33Nrl27Ag1+kgCG9yqXy+lM5tjoaONvOXjw 4KOPPrJq1aoQ83EGEkAIAhigORs2bLj44s2BBo9nHywBDO91/BDgiYliM6dkh9sB a4UtoAHCEMAATQu3EXTk5ZdfCTTyST5Vw3st4RDgO+64/ejRoyEmc2IL6HE7YAG0 nAAGaFq4jaAjX/7y311//fWBBl+USqVqtVrQS0DXiQJ4ZGSkvLDQ4OuLxeJXv/qV mZmZEJOxBTRAIAIYoGlBN4L+2Mc+vnXr1kCDL8pkMgsNf8qHhGj2DKTDhw/v3v3N lSuDfJQqFI5vAT05aQcsgBYTwABN27ixr7+/P9Dga9eu/dGPfhxo8EVzc3P5Zh50 hCRo9gykPXv2PPPMPwV6ANgOWACBCGCApvX29m7eHGoj6Gq1+uqrrwUafNH8/Hwu lwt6Cegu5XI5k82Ojow0/pZ77733Zz/7aaA7wHbAAghEAAMsxYc//KFAd34iO3bs vPbaawMNHqlUKtPT0+HGh66TzeUmJicLc3MNvr5Wq910003pdKjvIwEMEIgABliK oPtgxfAYsM/W8E5RAI+Njc03vOT48OHDDzywO9Bk7IAFEI4ABliKoPtgxfAYsACG d2p2C+igDwDbAQsgHAEMsBR9fX0DA6H2wYrhMWABDO/U7BbQO3bseOON1wNNJpVK TU+n55s5kRiABglggKXYsGHDxRdvDjd+6NOAp6enK5VKuPGhu2Sy2cEjRxp8cbFY vOWWr4bbSc4DwADhCGCAJbriissvuOCCQINfffU1u3btCjR4ZGZmxgkrsOj4FtCZ zOjoaIOvP3To0COPPLxq1aoQk6lWq5OTKQEMEIgABliioI8B1+v1V145HGjwFU5C gnfI5nLj4+PFQqHB1z/00IMvvPBCoAeAi8ViJpOdnLQDFkAQAhhgiTZu7OvvD/UY 8IrAhyFVq9WpqalAg0N3iQJ4dHR0oVRq5MW1Wu3mm2+eng717ZNKpdLpjAUaAIEI YIAlCv0Y8Cc/+Vs33nhjuPGtsYRFx3fAGhqqNvZU/Ouvv75r1656vRZoMh4ABghK AAMsXdDHgEMfhuRDNizKZLNHBwfr9XojL967d+/TT/9gzZo1IWbiAWCA0AQwwNIF fQw4sm/f/nCrrG0EDSua3wHrlltuGR8fCzQZDwADhCaAAZYu9GPAQVdBz87OFhre 9QeWq6Z2wHrjjTd27twZbv2zB4ABQhPAAEsX+jHgoKugS6VSNpsNNDh0i6Z2wNq3 b98PfvBUoPXPKzwADBCeAAY4J1u2XLZu3bpw4wddBe2jNhzfAevo0Wq12siLg65/ LpfLU1NTExPWPwMEJIABzknox4CDroIWwCRc1JxRAI8MDzfy4hPrn3c0uFfWEuTz +Ww2l0qlAo0PwAoBDHCOovqNGjjc+EFXQdsHi4SL6ndycjI/N9fIi/fv3//UU98P t/45St9cLjc3lw80PgArBDDAubvqqit7enrCjR9uFfRc9Fk779M2yRUF8NjY2Hxj m07deust0YsDzaRer48ff/7XogyAsAQwwLkKvQr6Yx/7+NatW0OMvLCwkMlkQowM XSEK4OHh4Uq5fNZXvvbaa/fff//KYJ+b5ufn0+mMA5AAQhPAAOcq9GFI9Xr9lVcO BxrcHSeSLArgwcHBeu3sxxp961vfev75Q6tXrw40EwcgAcRDAAO0wIc//KFwn4wj X/7y311//fUhRhbAJFa5XM5ks6MjI2d9ZdSlt956azYbcLmEA5AA4iGAAVrg0ksv Wb9+fbjxBwYG9u7dF2LkTCazsLAQYmTocNlcbnx8vFgonPWVTz311P79+8JtfxV9 D05PTzsACSAGAhigBUI/BlytVg8ceDzEQutisTgzM9PyYaHzHT8AaWSk3MAPgG6/ /etDQ0PhZjJ7wuSkA5AAghPAAC2wYcOGiy/eHPQSgW4C1+t1++6QTFEAHz16tFat nvllTz/9g71794a7/bvixAPAo6PHwo0PwEkCGKA1Qq+CrtVqhw49f/7557d8ZE8e kkDlcvn4HeDh4bO+ctu2OwYHB8PNxPpngDgJYIDWCL0KOnLddddt27a95cOm0+ly A8fAwHJy/AHgiYni2c7BPnz48AMP7A46E+ufAeIkgAFaJvRe0JVK5bXX/rnlwxYK hejzd8uHhU4WBfDo6OhCqXTml+3YseONN14POhPrnwHiJIABWiaGm8Cf+czvffGL X2ztmLVaLfoI3toxocM18gDwyMjI9u3bgq6PKJVK09Npz+EDxEYAA7TMxo19ITZq fqcoVg8ffrXlw3oMmERp8AHghx568KWXXlq5MuCHpVQqFQXw/Px8uEsA8E4CGKCV rrrqyp6enqCX+B//409+//d/v7VjOg2YRGnkAeDZ2dnbbtuay+XCTaNer49H8/Dj J4AYCWCAVophFfSqVatefPGl1o45Pz8f9IM+dJRGHgB+7LHHnn32h0FPPyoWi5lM 1vpngDgJYIBWiuo3auCgl6jX6zt37rr22mtbO6zbUCTH8QeABwdrtdoZXnPLLbeM j48FnYbtrwDiJ4ABWuyKKy6/4IILgl6ip6fn4MFDrR1zcnIySuvWjgkdqFwuZ7LZ 0ZGRM7xm//79Tz31/aC3f6vVavRN5/hfgJgJYIAWi2EVdPTRef/+723evLmFY87M zBSLxRYOCJ3p+APA4+PFQuEMr7njjtuPHj0adBqzs3PRN50N2AFiJoABWmzDhg39 /ZuCHggc+chHPnL33TtaOGC5XE6n0y0cEDrT8f2fR0bKp9/17fDhV3bv3h108+cV 1j8DtIkABmi9eG4C//CHz37gAx9o4ZgeAyYJogAePHLkDAv+d+zY8cYbrwedQ6lU SqfT1j8DxE8AA7ReX1/vwEDYrbAiv/Ebn/jKV77SwgGnp6crlUoLB4ROc3ylQyZz bHT0dC/4xS9+cc8999TrZ9of69ylUql0OuOhA4D4CWCAIC6/fMvatWuDXqJWqx06 9Pz555/fqgGjj+MzMzOtGg06UDaXGxsbmz99ed5//zdee+21oOufbX8F0EYCGCCI GFZBR377t3/7L/7iL1s4oFXQLG9RAA8PD1fK5VP+7eDg4N13312pnPpvW8X2VwBt JIABQvm1X7vqvPPOC3qJWq320ksvt3DDLYchsYyVy+XFHbBWnOaL/MEHH3jppZdW rVoVdBq2vwJoIwEMEEo8N4E//elP/9mf/XmrRpudnS2c8XgY6F5R/U5MThbm5k75 t1EY33nn9oXT7w7dEtH3VzabnZx0+xegPQQwQCjxnIdUr9dfeunlVt2zqlarU1NT LRkKOk0UwMeOHSvNz5/yb7/zne/86EfPhf6GdfsXoL0EMEBA8dwE/oM/+IP//t// R6tG8xgwy1UUwENDQ9VTbXU+PT19xx23z53m5nCrOP0IoO0EMEBAUf1GDRz+Oitf fPHFVt0EzuVy86e5RQbd65cPAA8Pn/Jvv/vd7z777A/d/gVY9gQwQFiXXPLv3ve+ 94W+SgtvAlcqlenp6ZYMBZ0jqt/x8fHiqR5xd/sXIDkEMEBY/f2bNm7cGP46rbwJ bBU0y8/i/s/lU+1xFdvt33Q6Uzz9EcQAxEAAAwR3+eVb1q5dG/oqn/3s7//Jn/xJ S4bKZrOlUqklQ0GHyGSzRwcH33vK19TU1LZtd4S+/VupVKIAdvsXoO0EMEBwAwP9 fX19oa/SwjOBy+VyOp0+93GgQxz/ks5kjo2OvvevHn744UOHDrr9C5AQAhggDvHc BP7t3/7tv/iLv2zJUFZBs5yc7gCkoaGhu+66M8rjoFd3+xegcwhggDjEdhP4Jz85 2JLStgqa5eR0ByDt3r37lVdadoz26bj9C9A5BDBATOK5Cfwbv/GJr3zlK+c+zsLC QiaTOfdxoO1OdwDSm2++uXPnzlqtGvTq1Wp1cjJlSQVAhxDAADGJ5yZw9Gn7+99/ qre399yH8pGd5eF0ByDdc889P//5v4S+utu/AB1FAAPE5/LLL1+79oLQV/nQhz50 333fOPdxrIJmeTjlAUiHD7+ye/fulSvDfhBy+xeg0whggPjEcyZwrVa79977rr76 6nMcp1KpTE9Pt2RK0EZRAA8eOfKuA5DuuOP2o0ePhr60278AnUYAA8TqsssuvfDC C0Nf5Vd+5VeeeuoH5z6OO1d0u1MegPTcc8995zvfXrNmTehLT01N+yYC6CgCGCBW mzZt3LRpU+ir1Ov1//k/v3jDDTec4zgzMzNuXtHV3nsAUj6fv+OO26empkJfOpVK jY4eC30VAJoigAHitnnzQEs2qTqrQ4eeP++8885lhGq1GkMnQDjHD0A6ejT6Sj75 J4899p3nnntu9erVQa9bKpXS6bSzfwE6jQAGiFtv74aBgYHQu++saNGRSJOTk+96 eBK6xfEDkLLZkZGRk3/y1ltv7dy54509HIjbvwCdSQADtEE8N4ErlerDDz98+eWX n8sgc3Nz+Xy+VVOCOL33AKQdO+5+4403Ql93fn4+nc5MTrr9C9BxBDBAe2zZctm6 detCX+XCC9c/++yz5ziIXXzoUlEADw8PV8rlxd/+8Ic//O53Hwu991WlUslkMm7/ AnQmAQzQHgMD/X19fTFc6IYbPvuFL3zhXEaYmpqKYckotNbx9c8nTgBecWINfzqd 3rbtjpmZmdDXPXH0UbpYnD/7SwGInQAGaJt4jkSK2vV73zswMDCw5BGKxWIM2QCt FdXvxMRE4f8u4L///m+89tproZ+9d/QRQIcTwABt09+/qa+vL4bdsC666KIf/ODp cxnBB3q6ThTAo6OjC6VS9Osf//jHjz76SOjFzytO3P7NZLKFdzx1DEBHEcAA7XTJ Jf/ufe97XwwX+vSnP/1nf/bnS357JpNZWFho4XwgtCiAjw4O1mq1qamp7du3z84G X8UQfY9MT6f9tAigkwlggHaK7SZwtVp96KGHrrjiyqW9vVwup9Pp1k4Jwom+Yk/s RDUa/XrXrp2/+MUvYrhoKpWanp6eny/FcC0AlkYAA7TZwMBAX1/wI5EiPT09P/rR j1evXr20t7uvRRfJ5nLHjh0rzc8/8cQTjz9+IIbFz6VSKZ1OT0w4+gigowlggDbr 7d2wadOmJXdpU6677rpt27Yv7b2zs7OebKRbRAE8NDT0s5/+9J577qnXazFcMZVK OfoIoPMJYID227x5oLc3jpvA9Xr9T//0zz7zmc8s7e1uAtMVFg9Aev0Xv9i+fVs8 X7SFQjGbzU5Ouv0L0OkEMED79fZuiAK4p6cnhmvVarVHH/32JZdcsoT3OhCYrhDV 7/j4+N133fnqq6/G8IB9vV6PvjXc/gXoCgIYoCPEdhM4ct55Pc8999x5553X7Bvn 5+dzuVyIKUELRQG84+679+3bG8Ojv5F8Pp/N5lKpVAzXAuAcCWCAjrBp08b3v//9 69ati+dyV1555Te/uXsJb7QKmg5XLpe//9RTX7n55vC3fo+rVContpt2+xegOwhg gE4R25FIK04s2vz0pz/953/+/7N3L/Bt1/X+x7v03vSepE3SyW3gJgwUDyiofxWP /z8o6hyCV7wiAh7lgOIRhsBQBozbuINcRS5bBwwGTA6KXJzcNm7C5kAE1m1t0tyT 5p78kv+3+W1lbF3XbvndX8/Hg5Kl6ff76Zamv3e+t3lT/cJ4PJ7NZpUoCaiKN//1 r/Pnn6faqV0cfQQAxkIABgAdUXMidKlUmj///Llz507pqyRJCoVCCpUE7KZ0On3W WWe9+eYb6nSXzWaj0ShHHwGAgRCAAUBHXC5nb2+vOgsXaypp9u677znwwAOn9FXB YFCEZ4VKAnbHRRdd+NRTT6kzjaKGo48AwIAIwACgL2oOAteMzoWueeKJJ7q7uyf/ Jel0emRkRLmSgF1zyy03L1myRLX3j9j7CgCMiAAMALqz33772u121bpraWn5299W 1tbWTv5L2AoLerN8+fLrrrvWZrOp093oUcOxGMO/AGA4BGAA0B23u9flck0pke6m /fff/+6775n848Wlfy7Hrj/Qi9WrV8+ff56ah1Qz+RkADIoADAB6pPJEaOHoo4++ 4IIFk3wwW2FBP4aGhubNO8vv96vWYzqdjsVigQCTnwHAeAjAAKBHnZ0dPT09qh0L XFPZFPqUU3568sknT/LxbIUFPRBB9JxzfvPWW2+p1iMH/wKAoRGAAUCn3G63y+VU cyK0JEkLFlz45S9/eTIPzmQyiURC6ZKACWSz2fPPP/+VV15Ws9NgMBiPx5PJlJqd AgCqhQAMAPql/kToYrF42223H3rooZN5MFthQUOlUmnhwovVPPSoZnTn53Q8zuRn ADAwAjAA6Nq++85obW1Vs0eRKx58cPnee++900fG4/FsNqtCScD2rrvu2gcffFDN KRLs/AwAJkAABgBdc7vdTqdDtaNNZTab7S9/eXynhwOLqMwhqNDEnXfeeccdf1D5 54KdnwHABAjAAKB3Xq/X5XKqOc9TaGpqfuqppxobGyd+WCgUUvPsGUB46KGHrr32 GtWO/JUlk8l4PME7PgBgdARgADAA9RcDCx/4wB7Lly+fOHjncrlYLKZaScBTTz21 cOHF5XJZzU6z2WwikRga8qnZKQBACQRgADAAp9PpcHQ3Nzer3O8BBxxw1113T/wY tsKCalavXvXb3/62UCio2akkSZFIhMnPAGAOBGAAMAa3u1fEYJUXPQqf/OSnrr32 2gkeMDIykk6nVasHlvXmm2/Om3dWKqX2+UMs/QUAMyEAA4BhaLIYuFwuz5kz5/zz fzvBYxgEhtLEc+zss+dt2rRJ5X4rS3/jwWBI5X4BAAohAAOAkfT19YkMrHKnIgP/ 6EcnnHrqqTt6QCQSUXlWKiwlFoudc85v3nrrLZX7zWRGl/76fCz9BQDzIAADgJG4 3b2tFSr3KzLwL395xne/+91xPyvSr8jAKpcEi0ilUvPnz3/99ddU7pdTfwHAlAjA AGAwIgN3dXXt9ICiqhMZ+KSTTj7llFPG/WwgEFB5Y15YQSIRP/fc8954Y53K/ZZK pXA4TPoFAPMhAAOA8bjdbqfTof6GWCLifvazR1x55ZXbfyqTySQSCZXrgbkNDg7O m3eWJivMg8GgCMDZbE79rgEAiiIAA4Aheb0ep9Nps9nU77q1ta2/v9/r9W5zP1th oboWLlz4+ON/qa2tVb9rn8/P8xkATIkADABG1dfndblcmnQtSdIPf/jD00//xdZ3 JhKJTCajST0wmXXr1l144YJAIKDynueyYDAYiUR5MgOAKRGAAcDANMzAQktLyxVX LPr4xz8+dg+DZthNyWTyiisu/9vf/qb+DP+xAjj3CABMjAAMAAbW2dnhdDrV3xR6 TKlUmjVr1sKFl+y1117ij+FwuFgsalUMDE2SpFtvvfX+++/TZNRXls1mRfr1+fxa FQAAUBoBGACMraenp7u7q6mpScMaRHTZf/8Dfve734kYzHlImKp8Pv+HP/zhgQeW lUolDdNvoVCIRqNDQ5z6CwBmRgAGAMNzu3sdDkd9fb22ZYj00tnZ+a1vfWvu3GO0 rQRGMTAwcOuttzz//As2m8YXJJx7BAAWQQAGADPweNxOp1OT/XK3J0nShz/8kRNO OOFDH/qQ1rVAj5LJ5LJlyx544IFkckQnT1rOPQIAiyAAA4BJaHgw0rjK5fK0adMO OuigY4897mMf+5jW5UB7ImE++uijf/nLn4eGhnSSe2XBYCgcDpF+AcAKCMAAYB59 fV6RgTVcRbkjxWJx+vQPfOxjhx511Bf22WcfrcuBejKZzHPPPffnPz/22muvFwp5 XeVeGYceAYCl6O4iCQCwO7Q9GGkyJElyu92zZx946KGHfuITn9B2+y4oYePGjX// +99feOGFf//7rWw2q9WBRpNRmfkcEUVqXQgAQCUEYAAwG/1n4DHyrr8ej3e//fab PfuAww47vLe3V+uiMDWFQuFf//rXqlWr1qx5/e23306lUjabTYfTELYnSo3F4iID a10IAEA9Bvj9BACYks7ODofD0dbWpnUhu6JYLDY0NPT09O6555577bXXzJkzDzjg gI6ODq3rwihJkoaGhtauXSsS79tv/3vjxo3JZLJcLutwYvNOZTKZeDzh93PkLwBY CwEYAEzI7e5ta2u321u0LqQKRL4SuUtErJaWlt7eXrfb43a7P1AhEnJ7e7vWBZqN fCDQu+++u2HDhk2bNgUCwyIlBoPBXC5fLpeMmHW3l8/no9GYz8eRvwBgOQRgADAn kYE7Ojqam5u1LkRZIhuLj/X19Y2NTQ5Ht9DR0dnV1elwOF0uV2+FuFM/m2Nrq1Ao hEKh4VEi04YikUgsFovHY+FwJBqN5HK5YrFoq9C6UgWJv4RoNDo0RPoFACsiAAOA aYkM3NXV1djYqHUhGpPHkKdV1NXV1dbWNTTUd3Z2trTYm5ubmptbhObmZrvd3loh bre1tYkb9gpxu6GhQetvYrNsNptMJlOp1JaPI6lUOjlq9EYmk0mnRz/mcqMPi8fj hVHFUkmSl1sbZXWucsQzQaT9oaEhrQsBAGjD0r8FAcD0RAZ2OBz19fVaF2JsIkKL ACnfkO+Rx0i3ipTixrSxeyoPmVZbO9E4qiSJBkdbEy3LzYr/V3oob3VPSX6wnFqJ r7tJ/K2GQqHBQdIvAFgXv0cBwOTcbrfT6dDzUTSAOiqHHoWz2ZzWhQAANEMABgDz 83o9DofDHNsXAbsmGAxV0i9H/gKApRGAAcASvF6v0+kw9+ZGwI5Uxn4jpF8AAAEY AKyir09kYCeLSGE1Iv1GItFMJqN1IQAA7XEZBAAWQgaG1QQCwWiU9AsA2IxrIACw ln333be11a51FYAacrlcOBwJBAJaFwIA0AsCMABYzowZ+7S1tWldBaCsbDYbjyd8 Pp/WhQAAdIQADACW43b32u12MjBMjPQLABgXARgArEhk4NYKrQsBqi+Xy8VicdIv AGB7BGAAsCiRgdva2u32Fq0LAaopn8+L9Ds0NKR1IQAAPSIAA4B1iQzc0dHR3Nys dSFAdRSLxWg0OjhI+gUAjI8ADACWJjJwZ2dnU1OT1oUAu0uSpEgkQvoFAEyAAAwA Vud2u7u6OhsbG7UuBNh1pVIpHA6TfgEAEyMAAwBGM7DD0V1fX691IcCuKJfLoVAo Ho8nkymtawEA6BoBGAAwyuMRGdhRV1endSHAlAWDoWAwmM/ntS4EAKB3BGAAwGYe j8fpdNTW1mpdCDAFIvqGw+FsNqd1IQAAAyAAAwDe4/V6HA4yMAyjkn4j2WxW60IA AMZAAAYAvE9fn9flcmldBbBzpF8AwFQRgAEA7+NyOfv6+rSuAtg5n88/PDysdRUA ACMhAAMA3qe3t8fj8WhdBbBzwWAwEolmMhmtCwEAGAYBGADwPkyBhlFks1kRgAOB gNaFAAAMgwAMAHiPy+V0u91sggWjCAaDg4NDWlcBADAMAjAA4D0M/8JY0ul0LBYL BIJaFwIAMAYCMABgM4/HLdKvzWZTqP3Gxsa2tvbKhNWycr1AJ8rlsiRJzc3NHR2d 4h/dZlPqkoOVwACAySMAAwBGdXZ29PT0tLS0KNfF3LlzTzrpZHEjn8+/+OKLr776 yj//uW7jxo2ZTFrcSSQ2umKxWFdX19vbu9dee3/oQ7M+9rGP77PPPuL+TZs2nXXW mSKmKtRvoVCIRmNDQ0yEBgDsHAEYADBKhcnPV1551axZs8b9lMgwa9euXbNmzTvv vLNx4wa/fziXy5bLZVYj65D4dymVSuKfpqXFLp42e++9z8yZMw888MA99thjR19y xhlnrFnzunIlpVKpeDzORGgAwE4RgAEANV6vSL/OadMU/KUgSdJf/vL4VL9qcHDw rbfeWr/+XZ/PHwwGKpNdIyItiwxms9kULdjiRMSV/5IbG5ucTkdPT29PT8/06dNn VHR2dk6ptauvvvqRRx5WdJBffm5kMlnlugAAmACXDgBgdR6P2+Fw1tUpO9YqstMt t9xaxQbz+fzGCp/PFwqFotFoIpGIRiPiRi6XKxSKpZIkEjI5eRvy+K24UVtbW19f 39TU1NXV1d3t6Ojo6O7udrmcXm/fnnvu2dvbW8W8umLFiquuukq5ZcAykYGj0Vg6 nVa0FwCAoXFNAACW5naL9NstgpDSHR133NdPOOEEpXvZniRJIhcNDw/HYrF4PC7i cSqVTCZTIiZls9lMJiP+KJKziNMiM4sHV8JhWSZ+S4rMpqvFyXJhokg51U+rEBWK NFtXV9/W1tra2tbU1Njc3NzU1Nzaam9psYs7Ozu7Ojs7Rb7t6ekRcVf97+idd975 9a//Z2RkRNFexN9MKBQS/8ri31fRjgAAxkUABgDrcrt7RShqaGhQuiMR2O65Z7HT 6VS6IyWI4kVyy1bkcjkRlUV4rgwy5yt35EQgFXeK8Fwzupi5KN8oFsWN4gTNjibW urqazSOxm2+IfwuRZ0V8FTcaGxvFx5aWFvmGuFPcaG9vV+Wbrr4zz/z1q6++qnQv 4h8rHA5zMjAAYEcIwABgUW63u7u7S4X0K9jt9vvvX6ZCR9CtpUuX3nzzTSrsaiZn YA5GAgCMiwAMAFbk8Yj0q8bMZ9nxx3/3+OOPV6cv6FMoFDrjjF/6/X4V+pLnQpOB AQDbIwADgOV4vV6Ho1u1E4aKxeJjj/2ZA40srlAoXHrppU8//ZRqe5JV9oUmAwMA 3ocADADW0tfndTqVPfFoG7NnH3jZZZep1h30KRqL/WnFij/+8Q41n3siA+fzBfFR tR4BADpHAAYAq3A6HY2NjS6XS81Oi8XikiX9Bt3+ClUUjkQ2DAz8/vc3rl+/Xs1+ M5lMIjHi8/nU7BQAoFsEYACwBLfb3dHR3tzcrHK/BxxwwOWXX6Fyp9ChWDw+NDT0 /HPP9fcvUflk5kKhIB+CxfFIAAACMACYX1+ft6urSz50R00M/2LMaAqtZODrr7t2 YGBA/QKYDg0AqCEAA4C5uVzOhoYGlRf9jjn44IMvuuhi9fuFPokMHIlGH/3Tn5Ys WaxJAel0emRkxOdTYydqAIA+EYABwLQ8Hk9nZ0djY6MmvZfL5eXLH2pqatKkd+hT LB4fHBy89ZZbXn/9NU02Bi8WpWg0ks/ng8GQ+r0DADRHAAYAE3I4ukXy1Grgt6aS fk899dSjj/6SJr1Dt+SJ0G+sW3f11VeNjIxoVUYymUylUgwFA4AFEYABwGw8Hk9H R7u2Q6/Tp0+//fY/SJKkYQ3QJxGAA4HAww8tf/TRR9Vflz6mWCxGo1GGggHAagjA AGAeDoejqalRw4Ffmci9f/rTo/X19RrWAN0qFArxRGJ4ePjqq65cv369ts/Vykhw kqFgALAOAjAAmERfn7ejo6OhoUHbMsrl8i9/ecbXvvY1DSe4QufGJkJfddWVyWRS 22IkSYpEIrlcPhRiKBgAzI8ADACG53a7W1vtra2tWhcy6uCDD77tttuDwWCpVNK6 FuiXPBH6qSefvO++e202m9bl1GSz2URiJJ8nBgOAyRGAAcDAnE5nY2ODw+HQQ4QQ 6urqnn32OfFRZButa4GujU2EvvOPd7z00kua7Ai9vZGRkVQq7fczIxoATIsADABG pZM5z2MkSVq27IF9991XpIh0Oq11OdA7eSL00ODgtddeu2HDgLaLgcfIM6Lz+UIw GNS6FgBA9enilw0AYEo8Hndra6vdbte6kPeI2HDppZcdeeSR4vbw8LDW5cAY5InQ 4VDommuuFrFT63Lek81mR0ZGxMdwWEdVAQB2HwEYAIxEnvOs+T7P2yiVSv/1Xz/7 yU9+UlMZ1tNVkoGejU2E3rhh4Prrb8jnc1pX9D6jO0Qn2SMaAExFR9dPAIAJyNG3 u7tbJ6slx5TL5blz55533nz5jyL9ilSjaUUwks0ToYeG3nhj3R1/+IPe9k4TT+9g MFQocFwwAJgEARgA9K6zs8Nut+tque8YEQ/+8z8/f/nll4/dw/xnTJWcgcPh8HPP Ptvfv0TrcsaxZWEwMRgADI8ADAC65vV629vbmpqatC5kHCL9fvazn73yyqvG7pGn jGpYEgxKngsdCASefeaZe+9dqqsZ/mNGg3osRgwGAEPT4y8YAEDN6E5XnspOVy1a FzK+7dOvIAKMuF+rkmBom9cD+/3PPvvsfffdq88MXLPlxGAmRQOAQen0twsAWJnH 425psYvwq9sMIFLu5z//+csuu3zrO9n+CrtJngvt9/tXr1rV379Et89/IZ1OJ5PJ fL4QChGDAcBI9PurBQAsyOVy1dfXu1z62uR5G6VS6dhjjzvnnHO2uT8cDheLRU1K gmnIGdg3NLR27do//vEOnU8oqMz5T2Uy6VgsrnUtAIBJ0e8FFgBYioi+DQ31DofD ZrNpXctEJEn6+c9PPfHEE7f/FNtfoSrkpbZDQ0MbNmy46abf639T8ZGRpEjCfj+n JQGAARCAAUBj8vlG+o++NZX0u3DhJV/4whe2/1Q8Hs9ms+qXBFMSoTcqMvDgoHhe 3XjjDZFIRM9zImoqiwJCoVA+XwgGg1rXAgCYiK5/nQCAublczoYGPR7tOy6Rz++5 Z/HMmTPH/SzDv6iu0SXl0ejQ0JAIlzfccP27776r/x8TYjAA6B8BGAA0II/6GiX6 CtOnT1+8eElra+u4n00mR6eAqlwSTC8Wjw8HAunKwVr33XffCy88X1dXp3VRO0cM BgA9IwADgKqMNepbU9ny6nOf+89FixZN8BiGf6EE+WAkESYz6bT44wsvvLBs2f36 XykgEz84oVBYfAvEYADQFQIwAKjEcKO+NZVFv+ecc+5xxx03wWMY/oVy5AwsMmQ2 kxF/FDduvvnmRCKu8yXBY0QMDofDjAYDgH4Y4/cHABiaUXZ43kZTU9OSJf177rnn xA9j+BeKkjNwIBDIbdll7bbbbl23bp0hpkPLmBQNAPpBAAYABRk0+pZKpSOO+NwV V1yx07IZ/oUK5Azs9/sL+bx8z7PPPrN8+XJj/ViNxeDaWpvfz9tGAKANAjAAKEKO vk6n0yhzNceIy/SFCy858sgjJ/Nghn+hjtHDgeNxkYGLW44FjsfjN910UzAYMNCa gprKz1cymUyn05lMJhaLa10OAFiOwS7LAED/PB53S0tLa2urEaPv/vvvf8stt4r6 J/N4zv6FmuQM7PP5pGJx7M6HHlq+cuVKA02HHlOZPSFicJoYDABqMtjFGQDomdfr EdHRbrcbLvrWVKY9n3XWvG9+85uT/xKGf6GyzRl4aEiSpLE7RSS+7bZbE4mEsWZE y1IV6TQxGABUYrxLNADQIa/X29pqn+TAqd6Uy+VZsz508803t7W1Tf6rIpFIYctk VEA1cgYeGhoqbZWBhWXLlj333LNGHAoWRACWkzAxGACURgAGgF3X2dlht9tbW1ub m5u1rmUXifR73nnz586dO6WvEiFEBGCFSgImJp5+0VjMJzJwqbT1/cPD/ttvvz0a jRpxKFjIZrMjIyO5XD4UCmldCwCYFgEYAHaFw9Hd1NTU3t7e2NiodS27SJKkT3zi k1ddddUufAuBQEAkZyWqAiZjRxlYeOyxxx5//PG6OiPtjLW1fD4fj8eJwQCgEAIw AEyNvL1zZ2dnfX291rXsOpHer7vuuo9+9D924WtHRkbS6XTVSwKmRM7AQ4OD278X k0qlbr/99g0bBoy1QfTWRmd6x2IiDAeDxGAAqCYCMABMlhx9u7u7jXtVXVMZ+P3x j0889dRTd7kF9r6CToxm4Gh0aGho3PkIa9euWbJkiciQBp0RXVP5aY1EIsRgAKgi AjAA7FxPj6u+vt7hcBj3Srqmss/zIYccctVVV7e2tu5yI6FQSHr/5kOAhkaXo0ej vh1k4JrKOUl///vfDf2mlfjJDYfD+XwhGAxqXQsAGB4BGAAm4vF47Hajnmy0tZaW lmuuuWbX5jyPqZxcmqpWSUBV7DQDyzOiBwbWG3SPaJn47uQjk3w+n9a1AICBGft6 DgAU4nb31tbWitxr0JONtiaum3/+81NPOOGE3W8nEAhUpSSgunaagYU33njjnnvu zuVyhp7HUVM5MymZTJVKkt/PYgQAmDICMAC8j9PpbGxsaGtra2pq0rqW3VUsFo8+ +ugFCy6syvzPYDC4/Y67gE5MJgMLTz755KOPPmqzTTP6nA75zCTxMRzmQDIAmAJj v/oDQBXJ0bejo6OhoUHrWnaXSKoHHnjgokVXulyuqjQYj8fFpXZVmgIUMskMLCxe vPjll18y9IxomXxmUjabC4fDWtcCAMZAAAaAzds7d3V1G/fs0DHi0r+7u/uyyy7b zeW+W8vlcrFYrFqtAcqZfAZOJBJ33XXX+vXvGnp/LFmxWIxGo2wWDQCTQQAGYGnm 2N55TEND43nnnffFL36xus1y7hEMZPPZSD5feRIz9oeGhu6+++5gMGCCGLzlzCQ2 iwaAiRCAAViU1+tpaTHD9s5bTPvpT3964oknVr1dlv7CcEYzcCzmGxqa5FN3zZo1 /f39+bzh98eqqcwBSSZTmUx6aIjNogFgHOa47AOAyers7BCht7W1tbm5WetaqkNc 4h933NfnzZunxLW7PK+y6s0CStucgX2+0qSPrV65cuWKFY+IAGmOGJzJZEQSHhoa 0roWANAXAjAAq3C5nA0NDe3t7Y2NjVrXUh2SJH3xi0eff/75Cn1HIyMj6XRaiZYB FYgMHKtkYGnSGVh47LHHnnjir9OmGX6b6JpKDM7lcuIHmeXBADDG8C/uALBTcvTt 6uoywaavsmKx+LnPfW7BggtbW1sV6iKbzcbjcYUaB9QxmoHjcb/PJ35kpvSFy5cv f+aZv9sqxyUpVJtqRAwW334sFhdhOBQiBgOwOsO/rAPABOTtnbu7u02ww41MXMge fvjhl1xyaWdnp3K9SJLEhTLMQc7Aw36/uDHVr+3vX/Liiy+KVw8TxOAaNosGgAoz vKADwPY8Hk9LS3Nra6s5rlxrKqH00EMPveiii3t6ehTtqFwuBwIBRbsA1CRnYPGs zudyU/1aERpFDH711VdNE4NLpVI4HGazaACWZYaXcgAY43b32my1ra32lpYWrWup GhF9Dz74oxdffLFI9Sp0J3LCTs9QBYxFZOB4IiGe27lsdhe+PJ/PL1my+PXXXzfN MgrxM55KpdJpNosGYDkEYAAm4XB0NzU1tbW1iY9a11I1Ivp++MMfvuiii6dPn65O j6RfmJWcgUOhUGZXt3bLZrP33HPPunX/NFMMFt9UMpkULzV+P8d9A7AEAjAAw3M6 nY2NDZ2dnfX19VrXUjXqR98ajvyF2ckZOByJpFOpml19o2csBptmUrSIwfl8PpFI VHbJCmtdDgAoywwv3AAsS97e2Ux7XNVU1hz+x38cctFFF6kz4XkM6RdWIDJwKp0W Sc/n85V34wkvWliyZPGaNWvMFIMrm0XHWB4MwNzM8JINwIJ6elz19fUOh8Nms2ld S9VIknTYYYddcMECpbe52h7pF5YiYnA0FvNP8Yjg7eXz+f7+/tde+4dpYnBN5YUo EomIv6JAgBgMwIRM8mINwDq8Xk9LS4vdbjfN5WZNZdT3U5/6PwsWLOju7la/d9b9 woI2HxHs9xenfjzSNsTP79Kl/a+88oqZYrC8WTQxGID5mORlGoDpud294uKytbW1 ublZ61qqSVxlHnHE584///yOjg5NCiD9wrLkDBwMBndta+htiJ/l++67d/Xq1SaL wel0OpVK+3xsFg3AJEzyAg3AxOSFvu3t7Y2NjVrXUk3iyvKoo44677z5Wp3YJApg pR8sbve3ht7esmX3P//88zabzTQxuFwuZzKZVCo1ODikdS0AsLtM8tIMwJQcDkdT U1NHR7sIwFrXUk3ianLOnDnz5p2tYaTP5/PRaFSr3gH9kDNwpLI1dBVnQzzyyMMr V66cVlGtNrUl/nJyudzIyIhIwrFYXOtyAGAXmeRFGYDJyCcbdXV1mea8TZnNZvv2 t79z+umna7t3VzqdFlexGhYA6Iq8NXQ+n9/9bbG28fjjj//1r4+L6GimGLzlzKR8 KBTSuhwAmDKTvBwDMA1TnmwkiG/q5JNP+eEPf6h1ITXxeDxbjRWPgMnIS4KHh4cL +Xx1W37uuedWrFhRLBZME4Nr5L+uWIwYDMBwzPNCDMDoTHmyUblcbmtr/9WvfvWV r3xF61pGhcPhYrGodRWATsnToYOhULZ6S4LH/POf/3zggWWJRMJML3Hi9SQajebz +WCQGAzAGAjAALTn8bhbWuytraY62ahUKu2zzz7z5p196KGHal3LKBHFg8EgGz4D E3tvSXA6XVbgcOwNGzbce+/S4eFhM01ykWMwZyYBMATzXGsCMKLKob52u73FTNG3 WJQ+8pEPz59//owZM7SuZbNsNhuPs2kNMCnvLQn2+yVlZkyIgL148eKBgfVm2ixa kiTxfTEaDEDnTPKaC8BwRPS121tF9NW6kGoS13+f+tT/+e1vf+t0OrWu5T0s+gV2 QXVPCR5XJpMRMXjdun+a6ejgLTG4wClrAPTJJK+2AAzE6/W2tra2tDRrXUg1lUql L33py2effbZWh/ruiLgGLSkwjROwAnk6dDgczqTTyi0fKBaLy5Yte/HF1SYbDU5X +Hx+rWsBgPcxyessAP1zu3ttttq2ttbmZlNFX3HN+p3vfOe///s0va3oy2QyiURC 6yoAY1NhOvSYRx/909NPPy1umCYGl0qlVCpFDAagKyZ5hQWgZyL6inDY2trW3Nyk dS1VUy6Xm5qaf/7zn33nO8drXcs4IpGIuHDXugrAJOTp0IFAIJ/LKd3Xs88+s2LF nySpSAwGACWY5LUVgD7J0betra2pyTzRV1zM7bHHHmec8avPfOYzWtcyjnw+H41G ta4CMBt5OnQoHM4qOR16zLp16x544IF4PGaaM5MqMVik4BQxGIC2CMAAlOL1ekX0 NdOoryRJs2fPPu+8+TNnztS6lvHJB3JqXQVgTu9Nh/b5xKuBCj36fL7+/iWDg4N1 dXUqdKcCRoMBaI4ADKD6KtHXVGt9xUXbpz71qfnzz3e5XFrXMj4GfgF1qLA79DYS iUR/f/+//vWmaWKwJEnh8OgyDXaKBqA+AjCAavJ6Pa2tbWba4blcLs+ZM+fMM8/S c55n4BdQ0+bdoSORTCqlwnRomfgZf+CBZS+99JLe9tvbZRyYBEATBGAA1eHxuFtb W+12u9aFVE19fcMPfvCDk08+Wc9r8LLZbDwe17oKwHLk6dCFfN4/PFxUccO5Uqn0 2GOPPf3002bZIWv0FKhoNJrL5UOhkNa1ALAEs7x8AtCOiL4tLS0i/Zpjz9JyudzR 0XHGGb/68pe/rHUtOxEOh4sKn8sCYALyUHAwGMxmMip3vWrVqocffrhQyJvjhXd0 Ynksls/ng0FiMABlmeFFE4BWXC5XQ0O90+k0xxWYJEmzZs0655xzDzzwQK1r2YmR kZF0Oq11FQA2DwXncjm/z1cqlVTu/Z133rnvvntDoZA55kWLAByPx7PZbDgc0boW AKZlhmtWAOpzOh2NjY3d3d3muOoqFouHH374eefN7+vr07qWnRAXiLFYTLVlhwAm Q82DgrcXDAb7+/s3bBgwxwuyCMAjIyODg0NaFwLAnAjAAKams7PDbrd3dnbW19dr XUsVlEqlL3zhi7/5zW9aW1u1rmXnIpHRfVO1rgLAODbvjBUOZ1Q5KHh7qVTq3nuX rl271gSbRYu/wHQ6nUymfD6f1rUAMBsCMIAp8Ho97e3tTU1mONrXZrMdf/zxp576 34YYM2HOM6B/Wu2MtU0NDz/88AsvPK/n3fsmSd4mWnxHgQDbRAOoGgIwgElxu92t rXZDDJNOrFwui+/i5z8/9Rvf+IbWtUxKNptNJBLMeQaMYvPOWKFQVrs3rUql0tNP P/34439Rf1ly1VX2x5IXBoe1rgWAGRCAAeyE0+lsbGxwOBxGH08QF4J77733mWee ddhhh2ldy6TIp4OY4PoVsBp5KDify/n9fkmStCpDvHqsXbtm+fLlyWTS6FsVZjKj C4OHhlgYDGB3GfvVEIDS+vq8HR0dDQ0NWheyW0SS/MhHPjJ//vkzZszQupbJYrkv YHTyzljBYDCXzWpYRrlc3rBhw733Lg0EAoZY8bEjIs+Hw+F8viD+SrWuBYCBEYAB jM/t7rXbW9vajD3nWZKkz372iPnz53d3d2tdy2TJp4BoXQWAKnjvkCS/v6TdULBM pMclS5asX/+uoXfJ4sRgALuJAAxgWyL61tbWGv2Io3K5PHfu3DPPPKuxsVHrWiYr mUymUimtqwBQZdoekrQN8SJz3333rlmzxtAxWHwX4gXT5/NrXQgA4yEAA3gft9vd 3t7W0tKidSG7rq6u/kc/+tFJJ51koEXL6XR6ZGRE6yoAKEXeGSsSiWTSaT0s7M/l citWrDD0ZtHyLgm5XD4UYigYwBQQgAG8p6/Pa9yB33K53NbWdtppp3/ta1/TupYp YJNnwCI2H5I0eqiPLoaCayolyZtFG3eLLIaCAUyVUV/vAFRX5ZQjwa51IbuiVCrt ueeeZ5017/DDD9e6linI5XLxeJzoC1iKPBQcjkSy+hgKrqkMpb744osrVjwiajNi EpZXBQ8OskE0gEkx3sscgKrzej1dXV319fVaFzJlkiTtv/8B8+fPnzVrlta1TIGI volEQifXvgBUpsOh4JrKO4lvvvnmsmX3i1cnw82LLpfLoVCIDaIBTAYBGLC0zs4O u93udDoN966/iL6HHHLI7353QV9fn9a1TEE+n4/H40RfADocCq6pJMmBgYGlS/tF njTccphMJpNIjPh8Pq0LAaBrBrvkBVBFbndva2ub4aY9i+j7mc98RkTfzs5OrWuZ AqIvAJkImfJ7jvocCpb5/f4lSxYPDg4aa7NopkMD2CkCMGBRbre7q6vTQEcE1VRm 6H3xi0efe+65zc3NWtcyBUx4BrCNsQxco9ehYFkkEunvX/LOO+8YKAaLv8NwOBwM hvL5vNa1ANAjAjBgRV6vp7u720AXNOJi8dhjjzvrrLOMNSWP6AtgAoYYChbE69jS pUvffPMNA/3WCAaDkUg0k8loXQgA3SEAA5bj9XodDsOcdSSuDo8//vjTTjvdWJuy cLgRgKmSY3Aul/P7/SVJ0rqcbY2MjCxbtmzNmteNEoNFBmZbLADbIwAD1tLXJ9Kv wxBhUkT0H//4xJNPPlnrQqYmnU4nk0miL4BdM7qKNR4XsS2XzWpdyzhSqdTy5ctf eeVlQ8RgEdoTiUQwGNK6EAA6QgAGLMQo6VdcV51yyik/+tEJWhcyNSL3iktDrasA YHjyUHA+l/MPD0vFotbljEO81j3yyMMvvfSS/icTBYPBcDiS1eW7CQA0QQAGrMLj 8TidDp1frNTV1Z966qnf/e53tS5kahKJBCvNAFSXPBQcCoVGw5suJ5WIGLxixYrV q1fpfDS4sh44ksmQgQGMIgADluB29zocjvr6eq0L2SEjRt9yuRyPx3P627EGgDls HgrO54eHh4uFgtbljE8eDX7xxRf1HINFBuZsJAAyAjBgfi6Xs7u7W7dHB9lstv/6 r/8y1oTnYrEoom9Rl1MTAZjM5nOSwuFMJlPW667yIgY/+OADr776qj5jsHi5jkaj ZGAANQRgwAr6+rwul0vrKsYxbdq0E0/8ySmnnKJ1IVPAyUYA1Kfzc5LGiJfHBx5Y tmbNGh3G4EwmE43GxF+g1oUA0BgBGDA5j8fT0+OSj5rUDxEgv//97//iF7/UupAp SKVSyWRS6yoAWJfOz0kaE4/H+/uXvPXWW3qLwZUNscLZrH7fQQCgAn1dEwOoLoej 2+VyNTU1aV3Ie0T0PeaYY37zm3N0vh3XuMrlsqhf/jh2Y0d3al0sAHOSN8fS+VCw ICpcsmTxxo2b6ur08movSVIkEmEiNGBxBGDAzHQ1+Vlcefzf//v/LrjgAt2uRlba 9jl5R/lZ60oB6JohNseSbdy4ccmSJaFQUCcn8CWTyXg8EQwGtS4EgGYIwIBpORzd vb29DQ0NWhcyGn0PPfTQSy+9rLu7W+tajGqSyZnwDFjH5s2xIpFsOq3zn/21a9f0 9/eLxK75ehzxUhkKhRgEBqyMAAyYlh6Gf8Wlxh577Llo0aIZM2ZoW4mVbROVJxiI 1rpSAFMztjnW6HHB+j6NXLzCPPPMMytWPKJ5Bh4ZGUkkEsFgSNsyAGiFAAyY1n77 7Wu32zUsoL6+/vzzf/uFL3xBwxqwmybIzAw7AxqSo698O5fLiQCcz+drdL/7QDab feih5atWrdLwXHr5/YLhYbaDBiyKAAyYk8vl9Hq9Wr3RLhLRd7/7vTPOOEOT3qG5 ckVpK+P+ka3CgKkay73iRjQaFR+LhYLh3oQS+XPx4ns2btyo1W6IwWCQWdCAZRGA AXPq7e31eNzq9yuuww4++KPXXHNNW1ub+r3D6Erj2SY8a10joLatB3vF7XAkUqzk XqO/hfTaa6/19/eXShqc5zQykqzMgmYrLMCKCMCAOWmyALihoeHKK688/PBPqNwv rGzczLxNfta6RmDKtgm90Wi0WCEVi9oWVl35fP6RRx5+9tlnVZ4Rnc1mI5FoIMAs aMCKCMCAOc2c+UE1TxuSJOnYY48799xzVesR2DVbjyeL5+3WUVn+o9YFwrrGDb3i aSlCr7nfx/H5fHfffVcoFFJt2Y74iw0GQ8PDw+p0B0BXCMCAOR1wwP6qvaEursw+ 9KH9v/3tbx111Bc03NcEqLqxtLx1VN76ttYFwti2TrzyHyORyFjo1bAwlcVisb/9 7W/PP/+cmjnf5/MTgAFrIgADJuR0Ovv6NNgBS1yzNTe3zJ59wKc//emjjjqqt1eD RciAJuSoPJaN5RtjH7WuDnqxfeKNRqOSrFi0zlsq4jvdsGHDq6++8tZb/w4EAjbb NJvNpnINBGDAsgjAgAmJADx9ep+2Ncj7AHd2dh5wwOyPf/xjn/rU/+EoYKCm8j6R TM7GYzfMPcfVssYZ441GS2PPAcu8OSK+8YGBgXXr1r3zzjvDw37xx7q6Om1L8vl8 nIQEWBMBGDAhPQTg7YmrvcbGxj322GPmzFmzZ88+7LDD9tlnH62LAvRIGo91hgeN a5u4W1PZ5Gks8ZYs848o/h42bdr0xhtvDA4O+v3+RCJRU1PW6sSjHWEEGLAsAjBg TgcddKD6M8qmSlwRikui9vb2vfba64Mf/OCsWR866KCDZsyYof/KAW2RkPVg+7i7 9QCvPBXe9AP7IuGLlDswsH5wcMjv90Ui0Xw+Z6vQurSdIAADlkUABsxJzU2wqku+ iG9qana73dOnT+/r6xPxeObMmfvvv7+a+1oDhrZ5I6XRhaXFsYSsdVHGNu7objQW K1WGdiWzx91UKrVhwwaRdUOhUDgcjkajqVRSPLsMkXXHRQAGLIsADJjTfvvta7fb ta6imuRNhmpra5uamlyuHq939KBjEZA/8IE9hH322aelpUXrGgFj2CYeF620/dJk bJ91xevPe3G3knXNd8R0JpPx+/2BQEBE3EgkEo/HY7GYnHLFZ8Vrr/obKypH/BOL b5M1wIA1mee1DMDW+vpG86HWVahHXImK63ibzVZfX9/c3OJyOXt6eru7u51Oh9vt 6evrmz59usjJBh0VB1QjfpTGUvHYR5Mlva2Nm3VHN2d+f9Y1+hsE4jsKBoPh8Ojg rYi1icSITORbEezFdyfCrd7W6CoqnU7HYnGR9rUuBIAGCMCAOfX29ng8Hq2r0JdK SBbXeTV1dXX19Q3NzU0ul8vhcLa3t3d2dnZ1dbpcPUJvb6/b7e7o6NC6XkB3ihVy MDZcNt5h1o1Gxw52NtY+ValUKrZFIpFIJpMi14lMKxPfmvwPJMKtzWYz0/jt7gsG g5FINJPJaF0IAA3wagiYU2Xk0635ORPGJV8My8vbRFpubGzorLDbWwWRmdva2rpE aO7s7K4QsVl8tNQQCrC1rYOxttl4+6Bbs9Uc5vJWQVc/WVdUIiJrPB7fMjA7mmKz WRHQxH9p8T+RbLPZbKFQFKXLf7HGXXyrBywABqyMAAyYltVmQWtOXqUs37bZRBYe nY8twnNnZ4fIzC0tLU1NzXa7vbl59KO4p62ttaOjs6OjQyRnEaflgK3ttwAoYetU LN+oVsvjZt33BV211uuKjCpSq4ip8jCsUAmuIrRmRT0iyubzhdwoEWiz8gnQlaJG XzEYoVWZ+MeKRmPMfwYsi1dbwLRE+vV6PVxUGcjWEbpyTVwrropH52vX1wnt7R0i OTdt0Txq9KO4KdK1SNTis+KGyNKVdN0mD1Nr+x0BE5DXG2+djXe0VfVEg7qVCczv xd3JDeqKL5SHVTNySM1mx9Jpfgvx58JmefkBokCRXcd6kWcX11QGY3mlNZBgMCgC cHq7ZxQAi+D1GjCzffedIbKQ1lVAVZWL87K4OJ9WYXtPbV1drSCisYjKIlE3NIxO 7RYfRMIey9WNjY1ytG5p2TxYLefqsYzNYVRQlHj6plIp8VEEzpFkUtwQWTQej/uH hzOVvFoJrqlcNlcZXBWPyssZNZ8viAgtbokPW25I4n7xiC3znUvl8uahYPkj8dWC xBMlHA6z/zNgZbziA2bm8bhdLhfrxFBF5Qp5BGzaFnKE2Hpqq3y/3d46Y8YMEbO1 qxf6YrPVhkLBgYENIqJuk0Vra2vlWcFbj+KOPcc0qxjmwvZXAPiNApgcK4EBAKjZ fPpRLBAIal0IAC0RgAGTc7mc3d3dTFsFAFhZsViMRqODg0NaFwJAYwRgwPzc7l6H w1FfX691IQAAaCMYDJJ+AdQQgAGL8Hg8TqeDU2oBABbE0l8AYwjAgFWQgQEAFlRJ v5FMJqt1IQB0gQAMWIjH4+7u7mYuNADACsrlcigU4tRfAFsjAAPW4na729vbWlpa tC4EAAAFsesVgHERgAHLcTqdjY0N4iNHawIATCmTySQSIz6fT+tCAOgOl7+ARXk8 nvb2No5HAgCYiTzwm8/ng8GQ1rUA0CMCMGBdbndvbW1tZ2cnq4IBAEZXLpeTyWQ6 nfb5/FrXAkC/CMCA1ckzoonBAACDKpVKIvemUmnmPAPYKQIwgFEOR3dTU1Nra1tz c5PWtQAAMCmSJEUikUKhEAgEta4FgDEQgAG8T09PT319XXd3NycGAwD0qVwu53K5 kZGRXC4fCrHWF8AUEIABjMPlcjY0NDQ3N7e0tNhsNq3LAQBgVD6fj8fjDPkC2GUE YAATcTodtaPqurpYJAwA0ECpVMrl8snkSKFQtNmm+f3DWlcEwMAIwAAmxe3uFZcg IgO3tLQ0NTUxQRoAoJxyuVwoFOLxeLFYLJXKwSDjvQCqgwAMYMpcLue0abb6+rrm 5mYRhuvq6rSuCABgeCL05vP5RCJRLEqlksRBvgCUQAAGsLtEHrbZbCIG2+32xsZG BocBAJMhD/OK0JvJZIoi9UoldrQCoDQCMIBqcrt7xRVMJQ/XNjc319fXNzQ0TJvG Sw0AYPTUIhF3k8mkSLsi/5ZKJYZ5AaiMq1IAynI6HSIPT5s2Gokr86VFJK5nlBgA zK1cLstxN5VKbYm75UIhH4vFtS4NgKURgAFowOVyTauQU3FtbV19fZ3AWDEAGE6p VCoWi4VCMZ0WWbdYU0m/AqO7AHSIa00AeuF0OqZNGx0trrw0lUUebmlpER9FPBYf tK4OACxNHtEtVlSW7EqV+8R/JfGRtbsAjIIADMAAHI7RedRbsnHNlnHj9zB0DAC7 ScTZyk5UQqlUkrLZbCXlbh7OFUE3FAprXSMA7C4uGQEYnsvlFB/lOdVbXtZGB5Cb m5tFNha5mZAMwOLk8VtpS7qVd12Wp9vIny2VRj+EwxGtKwUAZXE5CMASHI5ukYTf i8mjNk+0bmpqsm0hB+bKIwFA70YHaiuBdkwmk5Wk4thbgeXN8baG3acAQEYABoBt yTOuKzl567RcI19H1teLzNwsPi9H5WmVhcuMMAPYHfIIbUkeh92snM1mCoWi/Fok P6rySPnho+k3HGZOMgBMDZdrAFAd8kzsLZl52lbXrLLRi1Z5wLkyCi1n52ljEVq+ oUHdAHabnFrH/VhZSVvc8sDNU45r3sux8j5SZaIsAKiDiy0A0IvKPtijxAXx+1N0 eevxn5rKpXNlIFrO0u8R92hWPWBY+XxekqTyVkRq3TL0Khv7AZy2ZV5xzdgEY/Ff bW2t3z+sfuUAgKkiAAOAeVRGoUcv0N8/mDzt/VMot83SgojTTqeTIWgYVzqdTqVS 7x9rlZW3+uN7a2LHPivU1dURXwHAIrjWAQDU9I7qUWj3r/3226+9vb2KjWez2Wo1 BTWJ2Llu3T8lSVKi8ZGRkURiJBgMKtE4AMA0CMAAgNEA7PG4lWjZ7Xb/4Q93OByO urq6arU5PMxgnVEtXrz49ttvU+KtFgIwAGAyCMAAAAUD8N57771s2QPVbZMAbFwP PfTQtddeo0QATiaT8XiCAAwAmBgBGACgYAAuFouvv76mig1KkhQKharYINS0cOHC J598QomWxbNiZGREZGAlGgcAmAYBGABQ09fndblcSrRss9leeunlKjaYy+VisVgV G4Sabrzxxvvvv6+2trbqLadS6Xg8FggwAgwAmAgBGABQM2PGjLa2ViVa7urqeuKJ J6vYYCqVSiaTVWwQalq6dOktt9ysxBToXC4XDkcCgUDVWwYAmAkBGABQM2vWTIXO ED7ooA/fcccdVWwwHo+zC7RxPfHEXy+99NKtjyGqFkmSRPodHiYAAwAmQgAGAKtz u3tdLpcSs1KF4477+rx586rYYCgUUugcHahg7dq1Z589T6G3MHw+HwEYADAxAjAA WF1Pj8vr9SrU+Pz558+ZM6eKDbIFtKElEonTTz99cHCTEo37fH6eHgCAiRGAAcDq ent7PB6PQo0/8siKvr6+KjZIwjG6//mfX7322mtKtBwMBiORSCbDDHkAwA4RgAHA 6pQ7A0mSpNdee726bRKAjW7BggUrV/5NiZYrRwHHg0FOyQIA7BABGACszkBnIBWL xXA4XMUGob7rr79u2bJldXV1VW85k8lEo1FOQgIATIAADABWN3PmB5ubm5Vo2evt W7FiRRUbzGaz8Xi8ig1Cfffdd99NN/1eiZOQisViMBhkHywAwAQIwABgaYpuAf3p T3/mqquuqmKDIyMj6XS6ig1CfStXrrz44osU2sqbjaABABMjAAOApblczupuUrW1 n/zkJ6ec8tMqNhiNRvP5fBUbhPrWr19/xhm/TCaTSjTORtAAgIkRgAHA0pTbAUu4 7bbbDz744Co2GAgEyuVyFRuE+sS/4E9/esq7776rROOVjaCjmUxGicYBACZAAAYA S1NuByxJkl599R/VXerJ4J45zJ8///nnn1Oi5VQqFYvFRQxWonEAgAkQgAHA0vbd d0Zra6tCjb/yyqvVbZAAbA7XXHPNQw8tV2LleS6XC4cjgQDLgAEA4yMAA4Cl7b// hxoaGpRouepbQEuSFApxxKsZLF269JZbblZiI+hyuewfXQXMGyUAgPERgAHAupxO 5/TpSu2AdcQRn7viiiuq2CBnIJnGs88+e8EFF5RKCm0EzT5YAIAdIgADgHUpugPW aaed9v3v/6CKDXIGkmkEg8Ff/OJ0hVbqVvbBimQyWSUaBwAYHQEYAKxLuR2whPvv X7bPPvtUsUGRagqFQhUbhIZ++ctfrF27VomWU6lUPB4PBNgHCwAwDgIwAFjXvvvu 29pqV6LlYrH4+utrqtsm81rNZMGCBStX/k2JltkHCwAwAQIwAFjX7NkH1NXVKdFy Q0PDCy+sqm6bBGAzueWWW/r7lyixEXQNy4ABADtGAAYAi3K5XH19XoUanz179p13 3lXdNok0ZvLYY/+7aNEihRonAAMAdoQADAAW1dvb4/F4FGr8hz/80amnnlrFBvP5 fDQarWKD0NYzzzzzu9/9VqHGg8Hg4OCQQo0DAAyNAAwAFqXoDlh33nnX7Nmzq9hg KpVKJpNVbBDaSqdTc+bMUWgKdCqVfuutt5RoGQBgdARgALCoWbNmNjU1KdGyEjtg RaPRfD5f3TahraOOOlKhliVJ8vl8oVBYofYBAMZFAAYAK3K5nF6vd9o0RX4LiFz9 3HPPV7fNQCBQLper2ya0ddJJPxkYGFCo8aEhHxtBAwC2RwAGACvq7e31eNwKNf7R j3701ltvq26b7GlkPjfccMPy5Q8q1DjLgAEA4yIAA4AVKboA+LTTTvv+939QxQbL 5TKjeebzxhtvnHbafyvUeCqVeuutfyvUOADAuAjAAGBFM2fObG5WZAGwCKt//vNf enp6qthmLpeLxWJVbBB6IEnSUUcdqdA+WCwDBgCMiwAMAJbjdDr7+pRaAFwqlf7x j9eq22YymUylUtVtE3rw1a/OyWazCjXOMmAAwPYIwABgOYouAN5jjz2XL19e3TYj kUihUKhum9CDefPOevnllxVqnGXAAIDtEYABwHIUXQB87LHHnn32b6rbJjtgmdUT TzxxySULFWo8k8m++eabCjUOADAoAjAAWM4BB+xfX1+vUON//OOdBx54YHXbJACb VTqd+spXvlJXV6dE46VSyefzB4NBJRoHABgUARgArMXlcvX1eRVqXIkFwMViMRxm KyPT+vKXv6Tc/HZmQQMAtkEABgBrUXT+s9frXbHiT9VtM51Oj4yMVLdN6MeZZ/76 1VdfVajxZDL573+/rVDjAAAjIgADgLV88IMfbGlpVqjxuXOPOffcc6vbZjQazefz 1W0T+vHEE3+95JJLFGq8WCz6/cOhUEih9gEAhkMABgALcbmcXq9SByAJf/jDHR/+ 8Ier2yYLgM0tnU7NmTNHodOABZ/PNzzMYUgAgM0IwABgIYrOf1ZiAXANAdgC5s79 aiaTUahxlgEDALZGAAYAC9lvv33tdrtCje+9997Llj1Q3TbZAcsKFiy4YOXKlQo1 XigUAoFAMMgsaADAKAIwAFiFy+X0eDw2m02h9k844cc/+9nPqtsmO2BZwbp1604/ /TTl2mcWNABgDAEYAKxC0fnP5XL5L395vOrtswOWFZRKpSOP/H/KLQNmFjQAYAwB GACsQtH5zzab7aWXXq56sywAtoiTTvrJwMCAQo0Xi0Wfz89cegBADQEYACzC5XJ5 vR7l9n/++McPu/HGG6veLAHYIpYvf/CGG25Qrn0GgQEAMgIwAFhCX1+fy+VUrv1r r73uk5/8ZHXbzOfz0Wi0um1Cn5LJ5Ny5X1VuFnQymfr3v/+tUOMAAAMhAAOAJcya NbOpqUmhxhU6ACmRSCh3Og705phjjkmnUwo1LkmS3+9nL2gAAAEYAMyvp8fl9XqV a3/mzFlLliyperPBYFBE66o3C3265pqrV6xYoVz7zIIGANQQgAHAChTd/1k466x5 X//616veLAuALUX8cx9//HeUmwWdy+V8Pl8sFleofQCAIRCAAcDknE6nx+NWLldI kvTKK69WvX3RbCjEhFVrmTNnTi6XVajxcrkcDIaGhhgEBgBLIwADgMkpPfw7Y8aM ++67v+rNplKpZDJZ9WahZ1dfffWf/qTgLGi2wgIAEIABwMzc7t7Ozk7ltr+qUWz+ cyQSKRQKVW8WehYMBr/97W8pN1uhVCr5/f5AIKhQ+wAA/SMAA4CZeb3enh4Fh38V mv9cwwJgq/rqV+dks0rNgq5hKywAsDwCMACY2X777Wu325Vsf7+lS++terOlUkkE lao3C/37/e9vfOCBB5Rrv1gsDg8Pcx4SAFgWARgATMvjcff09EybpuBL/e9+d8GX vvSlqjfLAmDLisVixx13rHKzoGtGB4FDg4ODyrUPANAzAjAAmNaMGfu0tbUp136p VPrHP15TouVwOFwsFpVoGfr3wx/+wOfzKdd+oVAIBAIMAgOANRGAAcCcXC6X1+tR dPj3kEMOufnmW5RomQXAVvbYY/+7aNEiRbtgEBgALIsADADmpPTpR+Vy+c477zrw wAOr3nKxWAyHw1VvFkaRzWa/8pWv2GwKXqIUCoXh4QAHTQOABRGAAcCE3G53T4/L ZrMp10V9ff2qVauVaDmZTKZSKSVahlHMm3fWyy+/rGgXbAcNANZEAAYAE1J69a/w zW9+69e//rUSLYtkUiqVlGgZRjEwMPDjH5+g6FZYrAQGAGsiAAOA2bjd7t5eZTd/ liRp9eoXGxsblWicBcAQjjlmbjqdVrQLBoEBwIIIwABgNvvuO6O1tVXRLg466KA7 7vijEi3n8/loNKpEyzCW/qVLb7/tVkW7KBalcDjk8/kV7QUAoCsEYAAwFa/X09PT o2gX5XL5rrvunj17thKNx2KxXC6nRMswlkAwePx3vq3oOnZhZGTk7bffUbQLAICu EIABwDzc7t6Ojo7m5mZFe2ltbVu5cqVCjTP/GbJYPH755ZevXvWCor2USqVgMKTo scMAAF0hAAOAeSh99JHs178+85vf/KYSLUuSxMk0kBUKhYENG04+6Sd1dXWKdpRO ZxKJuN/POy8AYAkEYAAwCZfL2dPTU19fr2gv06ZNe/nlVxRqfGRkROl9j2AgsXj8 V2ecsXHjBkV7KZfLoVCI3bAAwCIIwABgEuoM/x5zzNfOOecchRoPBAIijSjUOAxH BODVq1YtXLiwrk7B85BqNh+JFBQU7QUAoAcEYAAwA4/H3dOj7NFHNZUFk6tWrVbo 9KMaFgDj/UQAHhoaunDBBSpMjOdIJACwCAIwABiew9HtdDqV3vtK+PznP3/ppZcp 1HgqlUomkwo1DiMSAXg4EFi3du11111bW6vsIHCpVAqFwiJvK9oLAEBzBGAAMLy+ vj6Xy6l0L5IkPfvsc8qdMBwMBkUIUahxGFGhUBAZeNPGjRdffHE8HlO6u1wuJzIw E6EBwNwIwABgbG63W6RfpcfHhE9+8lPXXnutcu0z/xnbEwF4YGDgrX/966abfq/0 mcA1TIQGAAsgAAOAgXV2dvT09LS0tCjdUbFYXLny752dnQq1z/xnjGt0BHjTpkI+ v3DhxbGY4oPAkiSFwxEmQgOAiRGAAcDA1Jn8LHz605++6qqrlWuf+c8YlwjAPp8v m8msX7/++uuvU2GmQy6Xi0ajHAsMAGZFAAYAo3K73T09LhXmhSq9+reG+c/YARGA A4FAqjI74IorrggGAyp0OjIy8vbb76jQEQBAfQRgADAkp9PhdDqbmppU6OvII4+6 +OKLlWs/mUymUinl2odxje2DJW4PDQ1deeUiFQaBS6VSOBxmMTAAmBIBGAAMqa/P 63K5VOhIkqTVq19U7uxfIRAIlMtl5dqHoYkAvGFgQDwPxe3f//7G9evXq9CpCN6R SMTn86vQFwBATQRgADAekX6dTue0aWq8hn/ve987/fRfKNd+sVgMh8PKtQ+jEwF4 cHAwn8uN3o7FFiy4oK6uToV+M5lMKBTmyQkAJkMABgCDcbt7RfpVJwOIXlavflHR LkSkyVWyDTAuEYD9fn8mnZb/eP/99734orLPyTGcigQA5kMABgAjcTi6Rfptbm5W oa9yubxgwYKjj/6Sor2w/RUmVigUorHY4KZN8h+z2ez8+eepM/2BxcAAYD4EYAAw EtWW/lb66nvkkRWKdpHJZBKJhKJdwARi8fj6d98dWyj+3HPPLV/+oDoZuFgsRiKR oSGfCn0BAFRAAAYAw1Az/RaL0sMPP7zXXnsp2gvH/2IyRADeuHFjsVCQ/yiS8CWX XBKLRdXpPZvNxmIxTgYGAHMgAAOAMXg8HpfLqcKpv7JPf/rTV111taJdSJIUCoUU 7QLmIALw0NBQLpsdu2dwcPDKKxepsxJeSKVSIgMHgzxdAcDwCMAAYABut9vh6K6v r1enu3K5vHr1i0p3x/ZXmCQRgIcDgXQyufWd99xz9+uvv65OAeInIhQKsRgYAEyA AAwAeud293Z0dKiz8VVN5Vr/zDPP+uY3v6l0R2x/hUkqFAoiA2/auHHrO1Op1IIF F6h2gjQbYgGAORCAAUDXRPq12+1tbW2q9bjnnns++OBypXtJJpMiwCjdC0xDBOAN AwOSJG195z/+8Y+7776rtrZWnRqKxWI0GiUDA4ChEYABQNfU3PiqprIu94knnnQ6 nUp3xPAvpkQE4MHBwfx2c+ZvvPGGgYEB1coYPZMpGhsaIgMDgFERgAFAv1ROv8K3 v/2dX/3qV0r3ks1m4/G40r3ATEQA9g8PZ7abNSCeSBdeuEC1zeGEXC4Xi8V8Pr9q PQIAqogADAA65fWK9OtU57BTWXt7+9NP/02FjgKBgGpLN2EOo8uAY7FNmzZt/6lV q1bdf/99ambgTCYbj3MwEgAYEgEYAPTI4/E4nQ7VFjfWVCY/r1ix4gMf2EPpjvL5 fDSq0gmuMJNYPD4wMFB6/zJg2U03/f7dd99Vs5h0Op1IJMjAAGA4BGAA0B2Px93d rd6hRzWVnZ+/973v/eIXv1Shr1AoJI2XYYCJ7WgZsCCy6IUXXqjibInRH5lUSmTg eCAQVK9XAMBuIwADgL643b0i/TY0NKjZqdfrXbHiTyp0VCwWw+GwCh3BfHa0DFj2 2muv3XnnH+vq6lSrR2TgZDIpns+xGAvaAcAwCMAAoCMi/XZ1dTU2NqrZqSRJTz75 lMPhUKEvhn+xy8Y9DXhr/f1LXn31VTVLEhlYPKU5GAkADIQADAB6IdJvR0dnc3OT mp2WSqV5887+xje+oUJfDP9iN02wDLimsj/z5ZdfNjIyomZJ4idIPKvJwABgFARg ANCFnp6ezs6OlpYWlfs9+OCDb7vtdnX6YvgXu2mCZcAy8dkrr1yk5kToGjIwABgK ARgAtOd297a1tdntdpX7ra+vf+6559XZa5rNn7H7RAAeHh5O72AZsGzlypWPPPKw mqci1VTWEUQiETIwAOgfARgANKZV+hWX7EuW9O+///7qdBcMBkulkjp9wax2ugxY duedf/znP/+pTkljyMAAYAgEYADQkki/rRUq91sul3/+81NPOOEEdbrLZDKJREKd vmBuIgBv2LBBKhYneEwul7viisvVf8qRgQFA/wjAAKAZrdKvcMghh958882qdTc8 PKxaXzA3EYCHhoZy2ezED/P7/YsWXaHyROgaMjAA6B4BGAC0IdKv3d7a1qZB+rXb 7X//+zOqdTcyMpJOp1XrDuYmAnAgEEglkzt95CuvvLJ48T3qLHHfGhkYAPSMAAwA GtAw/ZZKpcce+7Pb7VatR4Z/UUXyMuDBTZvK5fJOH/zQQw89++wz06apfbVDBgYA 3SIAA4DaNJz5XCwWFy268vOf/7xqPUaj0Xw+r1p3sILRfbA2bSpM4nklgujtt9/+ 9tv/VqGq7bsmAwOADhGAAUBVGqbfcrn8gx/88LTTTlOtR5G3w+Gwat3BIkQA9g8P ZyY8DGlMJpO5+uqrYrGY0lVtjwwMADpEAAYA9Wh14pHssMMOu+GGG9XskaOPoIRJ HoY0JhAILFp0haIl7QgZGAD0hgAMACrp6enp6GjXKv329fU98sgKNXtMpVLJSexU BOwCEYA3btxYLBQm+fg333zzllturqurU7SqcZGBAUBXCMAAoIZK+u2w21s06b2+ vv7JJ59SOXuz9xWUIwKwz+/PTmV38RdffLG/fwkZGAAsjgAMAIpzu3vb29tbWrRJ v+VyzYoVK/r6+tTsNBwOF4tFNXuEpYzOgo7FNm3aNKWveuKJv/7v//6v+gcj1VR2 Xxc/FGRgANAcARgAlCXSb0dHR3Nzsya9S5J0xx1/PPjgg9XsNJPJJBIJNXuEBcXi 8Q0bNkhTfJ/lgQeWvfDCC+ofjFRTycChUHhoiAwMAFoiAAOAgirpt7O5uUmT3ovF 4sKFl3zxi19UuV8mP0MFo7Ogfb5sJjOlrxI/FHffffcbb6xTqKqJiQycqvD7+RkB AG0QgAFAKSL9dnZ2NjVpk37FpfbPfvazE0/8icr9MvkZ6ti1WdBCLpe7+eabBwen /IVVQQYGAG0RgAFAEW63u7OzQ6v0Wy6Xv/rVr86ff77K/bLzM9Q0uhf0hg278IaL eKLeeOMNoVBIiap2Svx4JpOjPytkYABQHwEYAKpPpN+urs7GxkZNeheX10ccccSi RVeq328gEFC5U1iZCMB+vz8zlb2gx8Tj8euvv06rxerih0V+t4gMDAAqIwADQJW5 3b1dXV1apV/hox/9j1tvvVX9foPBYKlUUr9fWNboLOh4fNPGjbv25cPD/muvva5Y nOxhwtUlZ+BEYoS3jQBATQRgAKgmzdPvrFmzFi9eon6/iUQiM8XtiIDdNxqAN20q 5PO79uXia6+//jqRRatb1SRVMnBa/OyQgQFANQRgAKgakX7/f3v3Ah9XWed/fJKZ SWYmt0kyl1xKLZZaWIQCCrLrH1RoQQVBXou6+lqR/y6goqvorgKKXBRdEJCirvQC 0kKRi4qK/kUXUJEVb6u20NLSNqWXzEwyM0lmkrlmbv9n5jTTIU3TtDnPOTNzPu+X DqfT5PecpMmc5zvPc56nq6urqalJrxNYsGDBT3/6M+3bzWQyo6Oj2rcLiAA8HAwm 5nHn+cDAwJo1qxsbG1U8q7kTGTiRSESjZGAA0AgBGADUoXv6bWtr+/Wvf2M2m7Vv mn2PoJdMJhMdH/cNDs5n+v22bdseeOC7ZGAAMAICMACoQPf063C0PPvss7osOh0O h3O5nPbtAopINOr3+9Op1HyKvPzyy+vWrTObycAAUOcIwAAwX7qnX5F7n332Vw6H Q/umufUXujvqDYGn2bx584MPPqhjBo7HE7HYBOtCA4BUBGAAmBfdV73SMf2m02kR PLRvF5hmnkthlW3e/FIpA+twH4GJ/YEBQBMEYAA4eiL9Op1OXSYeK5qamp555tm2 tjZdWufWX1SJ4jJsY2N+n2/+pV588cUNGx7SMQOHw2Gfz69L6wBgBARgADhKIv12 dHTY7Xa9TkDf9Muuv6gqkWh07969uWx2/qX0zcDi1yocHvH7ycAAIAUBGACOhsfj cTo7dJl4rNA3/Y6OjmYyGV2aBmZU3A9peDgRj6tSTfcMPDIywjgwAMhAAAaAI+Z2 u5xOZ0tLi14noG/6ZeErVKH9+yH5fHmV1iTXNwPncrnR0VEyMACojgAMAEesv7/P 7Xbr1Xpzs+3pp5/WK/2K6CsCsC5NA7OLRKNDQ0PJREKtglu2bF6/fj0ZGADqCQEY AI6MvunXZrM/++yzek29Fj3ycDisS9PAYRX3Q4pG/T6finenl/YHfkCvDCy+orGx CPcDA4CKCMAAcARE+nW5XA0N+rx42u32Z57RLf2aWPYZVU/1QWBh69atIgM3Nuqz P/Dk5OTY2FggMKRL6wBQfwjAADBXfX19brdu6belpfWZZ57Rccslln1G9ds/COz3 q3UnsOKVV1554IHv6vW7n0qlIpEImwMDgCoIwAAwJ729PS6XS6+ZkE6n85e//O+m piZdWhfC4XBO1UQBSKLuctBlAwMDa9eu0SsDx+OJsbExbkAAgPkjAAPA4fX0eLu6 uvTKnwsWHPPjH/9Yr+xtYtMj1BRlOWi/36/KnsCVdu3add999xUKOsyDKBQKIv2y IBYAzB8BGAAOw+VydXV16nXn7bHHHvvDHz6h17iTEIlE0um0Xq0DR0Fk4NGxMb/P p3rlPXv23Hff2qza0Xou2BwYAFRBAAaAw9Bx2eelS49/5JFHdEy/bPmLGhWJRn0+ 36SE924GBwdXr16dzeowJ0IE75GR0UAgoH3TAFA3CMAAMBsdl30+8cQTN2x4WPt2 y2KxWFztGykBbSirYfkGBwuFgurFRQS9//77dPntYEEsAJgnAjAAHFJPT4/brc/C V8uWnbJu3Trt2y0TnXsRgHU8AWCeZGyJVDYyMrJ69aqJiQkZxWcnGh0Y2KV9uwBQ HwjAADAzl8vV3d1lt9u1b/rNb37z2rX3ad9uWTKZHB8f1/EEgPlTVsMKBAJZOUu4 jY6OrlmzOhqNyig+C24GBoD5IAADwMz0uvX3LW85c9WqVdq3W5ZKpbTv0wMyiAw8 Fon4fT4ZE6FNpSXiVq26V/vfl+IqX6OjgcCQxu0CQB0gAAPADHp7ez0et/a3/uqe ftPptOjT63gCgLqkToQ26ZeB4/H4jh07NW4UAOoAARgApnO5XG63q7m5WeN2Sb+A 6pSJ0EOBgLy9rHXJwOwMDABHhwAMANPpMvmZ9AtIsn9FaJ+vkM9LakKXDJzNZkUG ZkVoADgiBGAAeI3e3h6Px6Px5GfSLyCVCMDDwWBC5sLm4jfo29/+djyu6drprAgN AEeKAAwABzidHV6vV+OVn0899dTvfvcBLVuchvSLuqdMhA4Gg+lUSl4rov63vvWt bFbWXOuD5fP5cHjE72ciNADMFQEYAA7QfvLz0qXHP/roo1q2OA1rPsMglInQQ0ND knZFUgwODt5773fy0uZaHyydTofD4VAorFmLAFDTCMAAsJ/b7fJ6vRaLRbMWFy1a 9MQTP9J+reky9vuFoRQzcCTi9/ulBtQ9e/aIDKzZ73VpNawRn8+nTXMAUOsIwACw n8bDv06n85lnnjWbzZq1OE08Ho/JvCUSqELFHXTHxvyS4+LAwMDq1as0++0WX1Qw GGQQGADmggAMAEW9vT0i/TY2NmrTXFNT83PPPWez2bRp7mAi+ooArFfrgI6KE6GH h5OSf/43bdr08MMbNMvAoVCILZEAYC4IwABQtHjx69va2rRpq1AwPfPM0y6X1jst lU1MTCQSCb1aB/SlzYJYwvPPP//Tnz6pTQbOZnPDw8MiBmvQFgDUNAIwAGi69VEu l3v88cePP/4EDdqaUTQaTUnu9wNVTsnAgUBA6oJYhUJBBOAXXnhBm9cWBoEBYC4I wACg3fBvNpu7++67ly9frkFbMxobG5ucnNSrdaB6KItCFxfEyuXktZLNZh966KHt 21+R10RFWwwCA8DhEYABGJ1mw7+FQuGqqz569dVXy27oUEZHRzMyx7uA2iJ+HcYi Eb/PJ3435bWSSqVWrlwZjWqx1TaDwABwWARgAEan2fDvGWecsXr1Gg0amtHIyEg2 m9WrdaA6abMotMild9zxdQ1uBi4NAg+xHDQAzIIADMDQ3G5XX1+fBsO/Npvtd797 QbNVpqcR/W+pG58CtSsSjQ4PDyckLwq9cePG733vYQ0yMIPAADA7AjAAQ9Nm799c Lvfznz+1YMEC2Q3NKBgMSp3hCdQ0ZUEskRtTyaTUhh577FERg6U2IUxOToo8PzIy KrshAKhRBGAAxuVydff09FoscsdkRPi89trrPvjBD0pt5VBIv8BhKRlY5MbJdFpe K+l0+s4774jFYvKaMJVecMLhMIPAAHAoBGAAxqXN8O/JJy9bv3697FYOls/nWQ8W mCNlUeihoSGpGyP5fL6VK++2WCzymhASicT27TukNgEAtYsADMCgenq8nZ2dzc3N UlsRKfT3v/+Dw+GQ2srBstnsyMiIxo0CNU2bjZGeeOKJP//5T/Lqm0ovOyLJB4O8 /wUAMyAAAzCovr4+j0fu8G+hULjhhi9deumlUls5WDqdjkS02HMFqDMabIwkfj2/ /OVbZC9Kx1JYAHAoBGAABqXB7keLFh37ox/9SGoTB0smk+Pj4xo3CtSNSDQaDAbj Mu/U3bJl84MPPih1TXiR5IeHg+Ew+yEBwHQEYABG5HJ19/b2St2SJJvN/vd/Py1a kdfEweLxuOwldoD6piyIJaJjMpGQ18pdd90pNZ2yFBYAHAoBGIARabD81Vlnnf3N b35TahPTiOgbl7yXKWAEGiwKHQwG77zzDqnvwU1MTAwM7JJXHwBqFAEYgBEtWXJc S0uLvPq5XO6Pf/yT3W6X18Q0orObkDlgBRiKsiBWIBDIZbOSmvjWt77p90scoRWv QoHAELOgAWAaAjAAw3G7XX19fQ0NEl8AzzvvvNtv/7q8+tOMj48nk0nNmgOMQPaC WKFQ6I47vi51EJilsADgYARgAIYje/6zxsO/pF9Akkg0OhwMJqTdV//tb3/L5/NJ Km4qTgyJDQwMyKsPALWIAAzAcGTPfz7//PNvu+12efUrkX4BeWTfDCx7EDibzQYC gZGRUUn1AaAWEYABGIvL5err65W3AYnocf7xj39yOByS6ldi1StANuVmYL/fn8/l ZNS/7bb/jEajMiorRAAeHg7Kqw8ANYcADMBYvF5vb2+PvPonn7xs/fr18uqXJRKJ iYkJDRoCDE7qzsBbtmzZsOEhGZUV3AYMANMQgAEYi9QbgAuFwmOPPb506VJJ9cvS 6XQkEpHdCgCT5InQ+Xz+C1+4Xt6afOK1YuvWbZKKA0AtIgADMJCeHm93d7fVapVU v62t7be/fV5S8TLRYw6FQrJbAVBWnAgdifjkrAj9+OOP/e1vf1O9rEKcsN8f4BUD AMoIwAAMxONx9/X1yat/5ZVXXX311fLqK4LBoKR9WQAcirItcErCmnPj4+O33voV eUthcRswAFQiAAMwEKnzn7PZ7F//+jd5w8uKUCiUz+elNgHgYMpqWL7BQRlvP910 042Tk5Oql1VwGzAAVCIAAzCQxYsXt7W1Siq+ZMmSxx//vqTiikgkkpazHQuAwyou Bx0IpCUMAv/iF7947rnfqF5WIaL1yy9vlVQcAGoOARiAUci+AfiWW7580UUXSSou pFIpqdulAJidMgg8uG+f6pWTyeSNN37JYrGoXtlUug04EAgEg9wGDABFBGAARuF2 u/v7Zd0AnMvlNm7cJG97YWF4eFhecQBzUQzAg4MZCdOVb7jhhlwuq3pZBbcBA0AZ ARiAUUjdAfiYYxY++eSTkooLIyMj2ayszjGAOZK3J/Ajjzzy4oubVC+r4DZgACgj AAMwCqkrYP3rv17xyU9+UlLxZDI5Pj4uqTiAuVP2BPYNDqq+Ft3w8NDdd98taUPg RCKxffsOGZUBoOYQgAEYxdKlS+12m4zKoiv861//pqurS0ZxE5OfgWpSXArL70+n UuqWFS8j1113raTNkHK53L59+yIRFhEAAAIwAGNwu129vb2S7tG1WCx//vP/yqgs RKPRlNpdbQBHLZPJjI6N+X0+1SvfeecdIyMjqpdV+Hz+UIh1sACAAAzAGDwed1+f rBWwTj755PXrH5RUnOFfoNpEotHdu3cX1J4F/bOf/ex3v/sfdWuWsQ4WACgIwAAM wev19Pb2Sip+zTXXfOQjl8uoPDY2NilhvVkA8yFpLehQKHTXXXdKug2YdbAAQEEA BmAI8lbAKhQKv/rVr2XcACwqB4OM2ABVRwTgoaGhZCKhbtl8Pn/ttZ+XtBtwLBbf uXOnjMoAUFsIwAAMYcmS41paWiQV/9vfNsooG4lE0um0jMoA5iOTyYxFIr7BQdUr 33zzTZJ+60XZrVu3yagMALWFAAzAEP7u705oamqSUXnhwtf95Cc/kVGZu3+BqhWJ Rvfs3q36Zkhr167dtWtA3ZqKQqEwODg4MjIqozgA1BACMID6193dvWBBv6Q76y64 4MJbb71V9bKxWCwej6teFoAqJN0G/Pzzz//85/9P3ZplLAQNACYCMAAjkLoE9Fe+ cuuFF16oetlgMFgoFFQvC0AVIgAHAoFUMqlu2Wg0+p//+TVJ79YFAkPMKwEAAjCA +idvCWiRUZ9//n/a2trULZvL5cLhsLo1AahIBOBgMBiPxVSv/LnP/YekdbAIwABg IgADMAJ5ATifz2/a9KLqZcfHx5NqjywBUFEmkynOgt63T/XK1113LTshAYA8BGAA 9U/eHkjNzbY//OEPqpdllAaofsV1sPbsyedy6pa9/fbbIpGIujUVsVhs504pK2wB QA0hAAOof/L2QHrDG5Y+9thj6tZk+1+gJigjwJlMRt2y69ev37Ztq7o1FalUatu2 V2RUBoAaQgAGUP9OOOH45uZmGZVlLAEdj8djEm4sBKAuEYD9fn86lVK37NNPP/2r Xz2rbk1FNpvdvHmLjMoAUEMIwADq30knvdFsNsuo/NnPfvbDH75M3ZojIyOin6pu TQCqEwF4aHg4qfZ2ZS+//PJDDz2obk1FoVDw+fwssAfA4AjAAOqc2+3q7++XVHzN mrWnn366ujW5ARioCZlMZnRszO/zqVs2Ho/feutX1K1ZxlbAAEAABlDn5G0CXCgU Xnjh9w6HQ8Wa+Xye7ilQK8Yikd2vvqp62c9//nOSJq34/QGWGABgcARgAHVO3h5I 2Wz2pZc2q1szlUpFo1F1awKQJBKN7t69u5DPq1tWXgAOBALDwwRgAIZGAAZQ5+QF 4IaGhr/+9W/q1hTpN6X2mjoAJBEBeO/evTm1b9r/4he/kFc7VCsCgSFusgBgcARg wIi6u7saG80NDcUIpzxTKFIO8haLZWiofnpIXq+3t7dHRmW73f7CC79Xt2YoFJLU 8QWguuJOSIODmclJdct+9au3SloKvr4DsNPZYbU2mYrvTpYeStc3cWkT1zVxYDab 6+nSBuCoEYCBOud2uxqKGkU3QCRbkdnKoVewis5CU9PBn5V/rVwun0olS0sTVwbm gnKQzWYikeqdtStvBPiYYxY++eST6tas474pUH9EAPb5fJPptLpl77ln5dDQkLo1 FaFQyOfzy6gsgwi0Fou1YSrOTl27GsqXs8aDTKsgrlCTk5OV6+rn84XS5SxXOs5l MlV9/QIgAwEYqDci8YpOgOgc2Gw2Jd+KP5bzakNFJ0JF+YMkk+XArOTk0kNB+eDc yMio6udwKP39fW63W0bl00477f77v6tuTQIwUENEAA4EAqlkUt2y999//86dO9St qZiYmBgY2CWj8lzMFGiV61GhdM2ym82HCbTzN+1qmMvlREKOxWIiEpf+Jh8KsU0U UOcIwEDNK43xNlqtxbfDm5ubRTdCRsRVV2VUFt2OZDJRej9+f1QWfRDRS1PrVtjF i1/f1tamSqlpzj13+Z133qliQdEVY4tOoIZI2gr4+9///l//+hd1ayri8fiOHTtl VBYXoNbW1oo7axosFrN40my2VMZaGU2rSBkxHh8fz2az4li8Jmv5di0AbVR7LxnA jJzOjqamJqvVKjocIvRWf69idspb8qW51jklFScSifIAcj5fiMUmksmjzMNLlhzX 0tKi7gkrPvCBf7ruuutULJhOpyORiIoFAUglAnAwGIyrfb/uU0899dvfPqduTUUi kdy+fbta1ex2W1tbuxJ4lTnJ5teO4Vb/u7GzUAJwKpVKJpOTkxk2qAPqRg2/MAEG 5Ha7RO612WxKP6Om+xZzpEylFl2Q8k1cyvy1uUfipUvfIL5dMs7t6quvvvLKq1Qs GI/HJa18A0CGTCYzFon4BgfVLfvCCy/89Kcqry+gSKfTW7duO7rPrYy7ChF6W1pa xCWp1t+EPazyyHAmk83n80zVAWpa/feegTqg5F57iaTNIatWeamtfL74oAwRK+/K V9xjvP8usqlP2f95yg1m3d1dzc3NMs7tpptufu9736tiwUgkklZ7NR0AUokAvPvV V9WtuXnz5ocf3qBuTYVI7Fu2vFz5jIi1ra2tU2smK3fnmipeWg+8rlqtFofDUR7j LS6uWMq9RngrtkxcWsT3MBqNisdgkDFhoCYZ6DULqEUej0f0OTo7Oy0Wi97nUkUK FUyl7ld5rl1pVeqsEpJFWE6nU+K7J+ldg29/+7/e+ta3qlgwHA6Lk1axIADZItGo CMD7l/hTyeDg4H/917dVLFhWuql1RLw2Tj2hrD5lK0XaYrYVf1RirXJbSvnraqgg 48RqjvjOpFKpWCzG7Gig5vAqBlQjp7OjpajVbrfR26haP/jBDxcvXqxiQZaABmqO CMB7du9Wd/vueDx+661fUbFgpWw2a5A7aLQhvp+jo2PZLAPCQM3g5Q+oOv39fe3t 7U1NTXRQqtyqVauPPfbYtrY2te4xJgADNUcE4L179qg7d0PE6S984XouATVE/ACM jo4yLxqoCby2AlWkr09E37bm5mb6PdWvUCi0t7c7nZ0dHcXheofDUX4URCpuLREH 4sO6urrEwWHnsROAgZojAvC+ffuymcwRfZZyK2kymZyYmBCPpZWGxf8TqaJ0PB7b tGlT3a8sVX+UbZPEvyyTooFqRicbqAq9vT1KfKLHU9NK22bkGxuLL63mIovVamlq anI6ne3tHXa7TQTk0lpm+w/Ev3lLS6v4d1fSsug2dXZ2iufFp+j9pQCYExGABwcH M5OTpqlYKyKsEmtLyTaVTqeVx8nJ4kP5QDwqW+xM7QBXvOvW9NpFDVCLxD9tNDou /tnD4RG9zwXADHh5BfTX39/X1dVltOWdjUxZXUY53r/yTKO5tPZMQ1tbm8jGymZX VqtVeRSRuLlERGVxXH6ce4unnHKKnC8FqG0bN26c40eKX9tESXK/hJJtRdQZGxsT UTYzRUm85VXrTVOr2ZNsDUX8qExMxAKBgN4nAmA6XoUBPfX09LS3F+8gpUuEQymn ZXGgLMFaXq917kVEum5tbRXR2jalnKJbW1uUidvK/G1l2rZ4lLR5MiCPsipvWSIR j8eLkVUci6NiZk0oc4yLxN+K58sbjM+FEmgr10Y2ld7D4gUcMxI/XWNjkbGxMfGD p/e5ADiAl2xAN319fZ2dTqvVqveJADOoHKY2TW2ComRvJX9bLGYRmJubbSJdW0ua mqzKUHZzc7P4mNIzTcrf2mzNpf9abLbiaLb4dGsF8THiI8WTIpkrjyJTiDyu45eP ozA5OZnNZlKptLJTt3gUz2ReK5fLlu59TYm/Uj6sdJAVH6g8U/4wQRyIR/FXqVQx u2az4u+L/1d+OJUgqrwxZCKIoiqJn89wOCx+tkOhsN7nAmA/LhWAPrxej8C0Z2B2 5d2eK8fcyhNKywcHf6JI6+IDtTrN+lH5fVa+w5XfZCVtljNn+TvP9rDALOLx4jQE pkMDVYLLFaADl8t17rnnbN26lSWvYHDk29rRoCzRNM0s/1jlkEw2BtLpdCQSJQMD 1YBrEqC13t6eRYsWJZNJvU8EAABoJJ/Pj4yM+Hx+vU8EMDoCMKCpvr5el8utbJMD AAAMJRQKpdOT4TC3BAO6oRcOaKe/v6+zs9Niseh9IgAAQB+JRGJ8fGJoaEjvEwEM igAMaMFut3d1dbpcLu6FAwDA4CYnJ0dHx8jAgC7oiwPSldJvl8vVTfoFAABCJpMZ GRklAwPaozsOyMXYLwAAOBgZGNAFPXJAItIvAAA4FDIwoD065YBE/f19pF8AAHAo 3A8MaIx+OSCFzdbc3d3d1dVlNpv1PhcAAFC90ul0NBr1+wN6nwhgCARgQIr+/j63 2633WQAAgBqQzWbD4fDQ0LDeJwLUPwIwoL6+vr6Ojvbm5ma9TwQAANSGiYnYwMCA 3mcB1D8CMKAyt9vV3t7e1tam94kAAIBaEgqFfD6/3mcB1DkCMKAyJj8DAICjkMvl RAZmIjQgFQEYUJNIv06n02q16n0iAACg9sTj8R07dup9FkA9IwADqqm/yc+FQiGf z5f/2NjYyJZOAADdiWuTuEIpx+LCJC5P+p6PupgIDUhFXxZQTU1PflY6Ezabva+v 99hjX3/ccceddtppJ510Umtra/ljJiYmtm/fvm3b1t27d4trs8/nGxoaSqdT4nPJ xgAAdSlvwlqtVnEl6u/vX7jwdQsXLhSXpxNPPFH8sfIjBwYG/vKXv7z88svbt7+y b98+cbUSn1i72xCWJkKH2RkYkIQOK6AOr9fT3d3d1NSk94kcnjKoa7fbjznmGCXr nnzyyaI/MZ+x60AgIIKxiMd79uzds2e33+8X/Y9MJmMqjRurduoAgPqipFyz2eJw 2Ht6esSFacGCBeLadMIJJyxZsmQ+txSJVLxx48bStWnH7t2viqtSNputlVQci8V2 7mRFaEAKAjCgApvN1t3dVZ3Dv7lcTlzvRX/iuONEX2LJm970ppNOOsnhcGjW+u7d u7dt2yY6IoODg3v37vX7fbFYPJvN1N+kNQDAjJSUK17zbTZ7b29vf39fX1//okWL 3vCGNxx//PGVU41kE5ehP/3pT1u2bN66dduePbvj8XjVRuLh4WAgEND7LIA6RAAG VCCu5d3d3VUS50TmtFgsIuueeuppZ5111qmnnqpZ3D0imUxGZONXXnll165dSjYO BPyiL8K4MQDUoqmxXLPdXhzL7e9fILKuSLnieiRSbtUukCGuPs8995sXXvj95s0v RaPR6snD6XR6bGyMFaEB1RGAgflyu90dHe1avoF9MGX+2JvedNoFF1z49re/3el0 6ngy8ye+HL/fX8rGA4ODvuHhYfHHUCiYTCa53xgAdJTL5cQrcFNTU0tLS19f34IF x/T1iZR77HGlWUbNzc16n+B8iRj8858/9dxzz+3du8diseh7MqyGBchAJxKYLx3X vhIdEdEFEaH3sssuW7hwoS7noL1YLDYwMLBjxw7RO/H7A4ODg4GAP5FITE5OFgoF 4jEAzIeyJqLVarXZbF6vV6Tc3t5e5b7c448/3uPx6H2CGhHfh1/+8pff+97DmzZt 0mtYWFzlxWVuZGREl9aBekU3EZgXr9fT2dkpegkatysuzGefffYnP/lvS5cu1bjp Kjc6Orpr165XX3113769ot8QDodDoaB4TKfTjB4DgGlqFFdEXLvd0dvbI4ig29+/ 4HWve92SJUtE4uUmlEri2rF+/fp16x6IRqPaX0EYBAZUR0cQmBfth3/Flfh973v/ Nddco++k6xqVyWT27t0r4vGePXsCgUAwOCwMDQ0lk6nJybSyYBgJGUDtKhQK4qVM JFiLxeJwOFwutwi3LpdLWWB50aJFixcv5vJxdF566aUvfvGLe/fu0fIyIf5BS9cp 7gQGVEM/Dzh6pV5F93w2aTgiok9z6qmn3XHHHcaZgaY98U32+Xy7d+8uzawOhEKh kZFwaRg5nEols9ksw8gA9FIKt+IlqEGE26amJhFru7q6u7qKexCI69GCBcUhXMFu t+t9pvXsySefvPHGL2l5FYjHEzt27NCsOaDu0YcDjpLGWx+J3PUv//Ivn/70Ndo0 h1mIkDw0NLRv3z4RksWBSMg//vFP8vnilEKCMYD5K0w577zz+vr6Sjfi9i9cuFBE 3DpYZaoOxGKxD33og+IqoE1z4ichGAwGAkPaNAfUPfpqwFHyej2iU6LNjVJWa9NX v/rVFStWaNAW5iMcDgdKSjcej4yNjUWj0YmJ8dHR0ZGRkVQqnclMivysDCNzlx1g HMoWQaV3yRqtVqvIsV1dXZ2dne3t7R0dHU5nR1dXt8fjKS86xetD9fvMZz7z61// Spv3PdkSCVARARg4GloO/4qu0le+cuv555+vQVvQ0sTERDAYDIVCIjaPjIRF52Z8 fCISicTjMWFiIiaemZyczGYzIjMrw0ENU/Q+d8C4lJtsi0G2sdFsNiuzkZ1OZ2tr a0tLi3hsaxOZtt3p7BQR1+VyeUrEsd4nDvVdc801zz33G23aYjUsQC30ooCj0d/f J7o1GuSQfD5/+eWXf+Yzn5XdEGpFIpEYHR0VPaFIRATkyHhJrCQ5JZVKJRLxSCSa yWRKA845JUKbSn138chtzDAg5V0kZRhW/FE8mqdYLFYRWUV6bW5uttttdrvDbrcr gbatra2jpLOzs7u72+12i2f0/lJQRd7+9rdFo1ENGpqcnPT7/eKFXYO2gPpGBwg4 Ym63q729XZs+0FvecuaqVas0aAhGUxpknhCPIj/HS0rZOSHis8jYIkJnMqK7lUmn 08X/FP+QzhblxHHpIJtOp0SFfDFe50uKWVukDHFkmkraymP5oBw8GMc2oPJ9raaK H4zyj0T5UXl3RkmnDQ2NZnNxnFW84jY1NVtKrFarxbJ/3FU8Kf6vzCgWBzabyK7i weZwtIgEK+Krw+EQr9WlUdlijtXvq0fdEi+Gp556iviB1KAtBoEBVdD/AI6YZnf/ Lliw4KGHNjidTtkNAXoRCVzJQiJ8iwBtKg1xKxFahHDRszSVbn5TDirN+CTkEf37 g5dfKj8pDpTt0MULo8icpYMGkUKVD2PIFPXtRz/60S233KzBm3rcCQyoggAMHBnN 7v4VGeATn/jkVVddJbshAAAwH+95z4WDg4MaNBQMhvx+BoGBeSEAA0fG6y2uZaLB RhTLlp2ybt062a0AAIB5CoVC55xzjsVilt1QLBbbuXNAditAfSMAA0emv79Pg+Ff u91+772rli1bJrshAAAwf7ffftujjz4qu5VCoeD3+0OhsOyGgDpGAAaOgIi+HR0d ra0tUlvJ5XIXXXTRrbd+VWorAABARW9+85uUtQykYiksYJ4IwMAR0Gb4d8mSJY8/ /n3ZrQAAABVt2rTpsss+rMEamRs3bpLdBFDHCMDAXHk8bqfTqSxwKo+4cN54400X X3yx1FYAAIDqrrjiir/85X9lt8IgMDAfBGBgrrxer8jAZrPcJS7OOOOM1avXSG0C AADIkMvlTjllmextgVOp1LZtr0htAqhjBGBgrkQA7u3tkdpEa2vbunXrFi9eLLUV AAAgyZo1a+699ztSmygUCps2vSi1CaCOEYCBuerv73e7XfLq5/P5c8459+6775bX BAAAkO2UU5Y1NMjtY/t8PtaCBo4OARiYE4/H09nptNvt8pqw2ewrV65csmSJeUpj Y6NyIPs6CgAA1PKd73xn7Vq5dzNxGzBw1OhVA3Pi9Xq8Xq+8pR0LhcKpp5522223 zf5hIglXBuPKqCzpxAAAwFzkp2Qymb//+zOlLhqSTqe3bt0mrz5QxwjAwJzIvwG4 4XOf+9y55547/0LT4jHDyAAAHIX8THK5nHJQKDnU51533XUbN/5N6rm9+OJL8uoD dYwOMTAnsm8APuaYY9auvU9e/UoMIwMAjEaE1RkDbSUVmxsYGLj66o9Lfet5cHAw HB6RVx+oVwRg4PBk7wCcy+UuvPDCT3/6Gkn1jwLDyACAanbYNDvL8Kw23v3ud+fz OXn1uQ0YODr0ZYHD83q9Lle31WqVVN9stnzpS18688wzJdWXpDIYVwZmQjIA4Igc KsFKGp7Vxte+9rXf/vY5efUTicT27Tvk1QfqFf1U4PC8Xk9vb6+8+scee+y9966S V19HlcGYkAwAdU9JrbPPN9Z9bFYbw8PDl132YXnXu2w2t3nzZknFgTpGHxQ4PKkr YFXh/GeNKfcklxNy5SM5GQB0NEuOLf+VQdLs0bngggtyuayk4uI7v2nTi5KKA3WM ziVweP39fW63W1JxkfSuv/76s846W1L9utFYQk4GgKNQGWWnxdrKP+p9mvXmpptu /OMf/yivvs/nC4XC8uoDdYleI3AYHo+ns9Npt9sl1e/v77/vvvuJcGopr3FdTsiV B3yfAdS6ueRYRmWrxNatWz/zGYkzvFgHCzgK9AWBw/B6vR6PW9J29qKb8n/+z1k3 3nijjOKYnQjDM4Zk5YCoDECeaVOIZ5xXTI6tDytWLJfUhRBSqdS2ba9IKg7UK3p4 wGFIvQFY9G+uuuqjl156qaT6UEvj4RCYAUOZttTTLH8kxBrcxz/+sVdffVVS8Vwu 99JLrIMFHBl6bMBhSA3ANpvtrru+sXjxYkn1oRcCM1C1ClMqM+qMfywf633KqGGP PPLI+vXrJBVnHSzgKNADAw6jv7/f7XZJKl7HGyDhSDWUVCbkQx3rfaaAPspxtDKm zp5g9T5lwDQ+Pv6+910q76V7cNAXDrMOFnAE6EgBs/F43E6n0+FwyCguOmdnn/22 G264QUZxGEfDFCUez/FA77NGPSscWmVwnfGPep87oL7zzjtPvPRKKs46WMCRog8E zEb2ClhXXHHl+9//fhnFgaNwcJauVPkBs/+t3l8HXqM8ibcyah72+Vno++UANeej H71qz549koonk6lXXmEdLOAI0E0BZiPyb29vr6TidrvjnnvuWbhwoaT6QDUrZ2ZV HqeVnbGto3tyWt47OP7N/gEz/nEuj3P5AAA14YknfrhmzRpJxVkHCzhSBGBgNlJX wOIGYAAA6p7U24ALrIMFHCECMDCb/v4+t9stqfiyZafcfvvtkooDAIAqIXU34KGi YUnFgfpDAAYOye12dXR0tLa2yiiezWYvuujiT33qUzKKAwCA6vGe91yYyWQkFWcd LOCIEICBQ/J6PV1dXc3NzZLq//u//8eKFSskFQcAAFXiuuuu3bhxo6TisVhs584B ScWB+kMABg5JBGCv19vY2CijeE9P73333WexWGQUBwAA1WPTpk3XXvt5ScXT6fTW rdskFQfqDwEYOCSpK2CdcMIJd9+9UlJxAABQVc4//zxJ62CxEDRwRAjAwCFJDcCs gAUAgHGwDhZQJQjAwMxaW1s6OjokLQGdy+UuvfR9H/3oR2UUBwAA1eaSSy5JJhOS ivt8/lAoJKk4UGcIwMDMPB5PZ6fTbrfLKC7K3n33ykWLFskoDgAAqs3DDz/80EMP SirOQtDA3BGAgZl5vR632y1pkaqFCxeuWbNWRmUAAFCFREb98If/WVLxRCKxffsO ScWBOkMABmYm9QbgE09841133SWpOAAAqELnnbdC0tYSmUxmy5aXZVQG6g8BGJiZ vABcKBTOPPPvb7nlFhnFAQBAdVq+/FxJM8tE12LTphdlVAbqDwEYmJm8AJzL5S65 5JKrr/6EjOIAAKA6XXzxxel0SlJxn88XCoUlFQfqCQEYmIHNZuvq6vJ4pCwBLYp/ 4xt3v/71r5dRHAAAVKeHHnro4Yc3SCoeDIb8ftbBAg6PAAzMwOv1iADc3Nwso/iC BQvuu+9+GZUBAEDV2rdv35VXXiGp+MTExMDALknFgXpCAAZm4BUJ2OOWtGH98ccf v3LlPTIqAwCAanb++ec1NEjpfqdSqW3bXpFRGagzBGBgBlKXgD7llFNvu+02ScUB AEDVWrFiuaS313O53EsvbZZRGagzBGBgBvJGgMX16Zxzzr3++utVrwwAAKocI8CA 7gjAwAxE/u3t7ZVRWQTgf/7nD3/kIx+RURwAAFSzyy+/fGgoIKNyNpvdvHmLjMpA nSEAAzOQNwW6p6dn7dr7rFarjOIAAKCabdq06dprPy+p+MaNmyRVBuoJARiYQX9/ n9stZQ+kpUuPv+ceVsACAMCI8vn8u9/9LknFCcDAXBCAgelE9G1vbxNkFGcJaAAA jEzebcCBQGB4OCijMlBPCMDAdB6P2+l0OhwO1SsXCoW3vOUtX/7yV1SvDAAAaoK8 haBDoZDP55dRGagnBGBgOq/X09XV1dzcrHrlXC73j/946cc+9jHVKwMAgJpwySWX JJMJGZVjsdjOnQMyKgP1hAAMTCdvD6RCofDxj1/93ve+V/XKAACgJvzbv31yx44d MiqzExIwFwRgYDp5S0CbzZabb7759NNPl1EcAABUv3vuWfnUU0/JqJzP51988SUZ lYF6QgAGppMXgI899th7710lozIAAKgV73zn+ZIqsxA0cFgEYGA69kACAADyEIAB HRGAgdfweNxtbbL2QFq27JTbb79dRmUAAFAr5C0EzU5IwGERgIHXEAG4o8PZ0qL+ Hki5XG758hXXXnut6pUBAEANkTcCTAAGDosADLyGx+Pp6uq02WyqV85ms//0Tx+8 4oorVK8MAABqyPved+nExISMymwFDBwWARh4Da/X43a7LRaL6pXz+cInPnH1xRez BxIAAIZ2zTWf3rZtm4zKiURi+3YpeywBdYMADLyGCMA9PT0NDer/apjNlptuuumM M85QvTIAAKghK1eu/MUvpOyElMlktmx5WUZloG4QgIHXYA8kAAAgm6TbgAuFwqZN L8qoDNQNAjDwGvIC8BvesPSb3/ymjMoAAKC2sBMSoBcCMHCA3W7v6uqUtAnwiSee eNdd35BRGQAA1JbzzlvR2Ngoo3IgMDQ8PCyjMlAfCMDAAW63q6Ojo7W1VfXK+Xz+ H/7hrTfffLPqlQEAQM0hAAN6IQADB3g8HqfT6XDYVa+czWYvuujiT33qU6pXBgAA Neeii94zOTkpozI7IQGzIwADB3i9nq6urubmZtUr5/P5yy//vx/60IdUrwwAAGrO lVdesW/fPhmVJyZiAwMDMioD9YEADBwgbxNg8bv2+c9/7pxzzpVQGQAA1Jgvf/nL L7zwOxmVk8nkK69sl1EZqA8EYOAAeUtAW61NX//610844QQZxQEAQG1Zt+6BRx99 VEblbDa7efMWGZWB+kAABg5gE2AAAKANtgIGdEEABg5gE2AAAKANtgIGdEEABvaz 2WxdXV0ej5RNgE866aQ77rhTRmUAAFCLli9fbrGYZVQOBALDw0EZlYE6QAAG9nO7 3e3t7W1t6m8CXCgUli1b9vWv36F6ZQAAUKOWLz9XzrqbbAUMzIYADOzn8bhLmwA7 5DUhknAul2tqavZ4PAsWLOjv7z/rrLPe+MY3ymsRAADo6wc/+MGuXbv27Nnt9wfi 8XihkDebpQz8lrEVMDALAjCwn9fr6e7ubmpq0rhdJRWLa2FLS2tvb8+CBce84x3v OPPMMzU+DQAAME+rV6/et2+f3+8LBoOpVKqxRPvTiMViO3eyFTAwMwIwsJ9XJGCP W/absnMngnE+n7dam0QsF8HY6+1529ve9uY3v1nv8wIAwOjuv/9+X9Hg0NBwMpkQ l+zq6T8I6XR669Ztep8FUKUIwMB+8paAVpdIxeJCa7FYWlpaent7+/r6ly9ffvrp p+t9XgAA1Jt7773X7/cHAn5lRLfagu6h5HK5l17arPdZAFWKAAzsVysB+FCUEeOG hka73eZ2e0Q2drvdb3/7208++WS9Tw0AgOr10EMPipA7OLhveHg4FotnMpMN4mqq x9RltbAVMDALAjCwX60H4Fko2dhsNttsNo/H09PT093d/Y53nEM2BgAYxLp1DwQC Q+FwOBgcHhkZFSlXPFkTw7lHh62AgUMhAAP79ff3ud1SNgGuZsoSXI2NjU1NTZ2d xW2QXS7xv+6zz37b0qVL9T47AADm6rHHHgsEAqFQcHh4WATdVCqlXOAaGozY3SUA A4dixFcE4GClTYDbBL1PpLpMTatusFqtXUXdnSIld3WtWLHihBNO0PvsAADG8sAD DwSDwdHR0XA4FA6PpNOpbDar10rLVS4QCAwPB/U+C6AaEYCBIo/HU9oE2K73idQY ZUWuxkZzU1MxIYt47HR2tre3n3/++SeeeKLeZwcAqCVr1qwZGRmJRCIjI2FxkEoV 862pricqy8NWwMChEICBIr02Aa57yhiysmy1+PYqIbmjw9ne3vaud72bYWQAMIhV q1aNjY0p4XZ0dKwUbjPK+hTGnKIsWzwe37Fjp95nAVQjXnGAomrbBNho8iWNjY1K Tu4saWtrdzpFVG4/99xzFy1apPc5AgCme+SRR8bGRkWwjUYjIt+Ojo6m0+lMJpvL ZUWs5aqqI7YCBg6FAAwU1fES0PWkPJ4sOlVKVO7o6BA5ubW1pbW1TRy3traKtHzM McfofaYAUKsef/xxEWWj0ejExEQ8HhMHIt9mMpOZTCaXy4kPMOyyUrUlm81u3rxF 77MAqhGvX0ARAbgulQeWBWuJCMnt7R0tLY6Wlta2tja73fbOd76LwAygjm3YsGF8 XKTZmJBIxKMl6fRkNpsRGUlZ6ZBMW3/YChg4FF7sgCICMBTKCLM4UCbvWSwWEZtF Zm5ra7XZbA5Hi8PhEMfNzbYLLrigp4efGQAaefjhDbFYXITYeDyeSCSSyWQsNiGi 7OSkiLI5IZ/PiZcvJh6jjJ2QgBkRgIEiAjDmSYnNymNLS2tfX29LS4vIzHa7w263 t7Q4mpqaRWZ2uVx6nykA/T322GNKlE2WpIpEoI3t2bOnocRUehtO79NEDWMEGDgU XluBIgIwdFG+q7nU420U3V1ziTLyLCK0w+Fo3k9kabv4j3gUf3vJJZd0dXXpffqA sWzYsCGZTIi4KiJrOp0WkTWdnpycFIeT4nmRZ3O5bDZbHIktzyURD42NDexSC10w AgzMiAAMmGw2W3d3l9vt1vtEgPlSEnX5j8pQkuh8i1BdWmRbhGqHzWa3TmlqEv9r Fgfit0B5FBnbYjFffPF7W1tbdfxCgKPw+OOPF2NpUTqTEcF0srQi8WRJRhDxVCTV eDyeyylzhvcrlJTHXcmrqA+BwNDw8LDeZwFUHQIwYBLR1+nsaGlp0ftEgBowNWot csL+Kd9KWlAW0RHZoZS1G0vD2GaHo6WpqUkZ0C4/CiJmlwK4RXxYc3OTOBKf+IEP fEAkcL2/Pqjj4Yc3lAJnbnIyPXVQjKPFEdJcVjyRyexPpOLHSaTWUijNl8ZOlR8x JZSKn7H9Q6mmqWjKxGBgjgKBwPBwUO+zAKoOVxHA5PF4Ojs77XZ63kANKFQwlUJR 5didqSKQiydKcamxNAfVrOSmyhBVGu62lkf8GiqID6m1S2RhaiDzwDdHiZHZbEYk T1PFlPvSsakibRZKn55XPsVUcU+78u01vfabo+MXCWDuQqGQz+fX+yyAqsNlDDB5 vR6Xy2W1WvU+EQAAAHUkEont23fofRZA1SEAA8UA3NPTw7AGAACoG5lMZsuWl/U+ C6Dq0OMHWAIaAADUG3ZCAmZEAAYIwAAAoA6xExJwMAIwjI49kAAAQF1iJyTgYARg GJ3H4+7oYA8kAABQb9gJCTgYARgo7gPc2NhgsVhEDFb2KWVBLAAAUHPy+byyyXYy mcxmcwz/Agejlw/MoBSJG02mAqkYAABUoamsm00mEyLrik4Lg73AXNChB+bK7XaV UrHJbLa0tpKKAQCAFsi6gIrouwPzUk7FjBUDAIB5mjaHmawLqI5uOiCFMonaYjE7 HA4lFSs5GQAAQMhms5mMeMimUtyvC2iHAAxop5yK7Xa7iMQiGJvNZr1PCgAASFQo FDKlpBuPx8WjeIZBXUBHBGBAZ8oa1KbSJGqHw6EEY4aLAQCoLSLo5nI5JeumUikm MAPViQAMVKnKYNzS0mIpIRgDAKA7ZfZyLpflTl2g5hCAgRoztUWTyWw2t7Q4xKPF YjWbG1l5CwAAFZWnLudyOUZ0gbpBjxmoH+Xti0UoLg0ai2xs4TZjAAAORaTcbIlI uVPDuSbWowLqGAEYMASPx93QUMzGyp3GpXHjYjZm3BgAUPfy+fxUyM0pSy4zlgsY Fn1fwOhK2bih9GpAPAYA1CQl4uZKSgO5WeW6RsoFMA29WwCzmRaP7XYRjxuVhMyK XAAAbSgLLAsi5Obz5TtyTURcAEeKAAxgXg5KyHYRjM1TGEMGABxWefxWHCQSianx WxP5FoDq6JsCkG5qSydlVyezzWarDMmMJANAvSqP3CrhtnJysqm41hThFoDWCMAA qsW0wWQlJysYTwaA6iFirUizU6m2qLSyFMO2AGoAvUkAtWdqUWvF9LSsBOaGEj3P EgBqhzJUW4q10zKtiQFbAPWE3iGA+ufxeEpZeH8fTgnMIh4raVk5IDMDqBvlNFui jNfmSwtHVQbaBna7BWBAdPUAYGYVsblIdCGtViU5K6m5oXLMmeQMQHUixO4PrweC bCGVSmYy2amXnP3/IcoCwBzRYwMAFZTS8v5BldITxaHmQsFUysx2JTA3TEXnykd9 TxuANiqHYpUcKx4KJRUDs6aKFxCGZwFACvpeAFBFpoadTZVB2nQgS9saDlIZp0nU gCrKcVXJqJXHSmTNZIqR9aDf1gbWfwKAKkdXCQDq3EGhWnEgWgsHp2vxwaXNq0zl aF3xV4CelGw6K5MyT9h0IKOaDvr5J6wCgBHRjwEAqOO1i41VTgg3lfO2aSpymypS dzGkNJiUaF3O2JV5mwRePSpDZqGQLz9T8VfTnxP/KQ+Zml6TSE0H/YSwiQ4AQC66 EQCA+uT1eqbNJC+ZlswNpfzGRBmBEwBgLMbsAQAAAAAADIcADAAAAAAwBAIwAAAA AMAQCMAAAAAAAEMgAAMAAAAADIEADAAAAAAwBAIwAAAAAMAQCMAAAAAAAEMgAAMA AAAADIEADAAAAAAwBAIwAAAAAMAQCMAAAAAAAEMgAAMAAAAADIEADAAAAAAwBAIw AAAAAMAQCMAAAAAAAEMgAAMAAAAADIEADAAAAAAwBAIwAAAAAMAQCMAAAAAAAEMg AAMAAAAADIEADAAAAAAwBAIwAAAAAMAQCMAAAAAAAEMgAAMAAAAADIEADAAAAAAw BAIwAAAAAMAQCMAAAAAAAEMgAAMAAAAADIEADAAAAAAwBAIwAAAAAMAQCMAAAAAA AEMgAAMAAAAADIEADAAAAAAwBAIwAAAAAMAQCMAAAAAAAEMgAAMAAAAADIEADAAA AAAwBAIwAAAAAMAQCMAAAAAAAEMgAAMAAAAADIEADAAAAAAwBAIwAAAAAMAQCMAA AAAAAEMgAAMAAAAADIEADAAAAAAwBAIwAAAAAMAQCMAAAAAAAEMgAAMAAAAADIEA DAAAAAAwBAIwAAAAAMAQCMAAAAAAAEMgAAMAAAAADIEADAAAAAAwBAIwAAAAAMAQ CMAAAAAAAEMgAAMAAAAADIEADAAAAAAwBAIwAAAAAMAQCMAAAAAAAEMgAAMAAAAA DIEADAAAAAAwBAIwAAAAAMAQCMAAAAAAAEMgAAMAAAAADIEADAAAAAAwBAIwAAAA AMAQCMAAAAAAAEMgAAMAAAAADIEADAAAAAAwBAIwAAAAAMAQCMAAAAAAAEMgAAMA AAAADIEADAAAAAAwBAIwAAAAAMAQCMAAAAAAAEMgAAMAAAAADIEADAAAAAAwBAIw AAAAAMAQCMAAAAAAAEMgAAMAAAAADIEADAAAAAAwBAIwAAAAAMAQCMAAAAAAAEMg AAMAAAAADIEADAAAAAAwBAIwAAAAAMAQCMAAAAAAAEMgAAMAAAAADIEADAAAAAAw BAIwAAAAAMAQCMAAAAAAAEMgAAMAAAAADIEADAAAAAAwBAIwAAAAAMAQCMAAAAAA AEMgAAMAAAAADIEADAAAAAAwBAIwAAAAAMAQCMAAAAAAAEMgAAMAAAAADIEADAAA AAAwBAIwAAAAAMAQCMAAAAAAAEMgAAMAAAAADIEADAAAAAAwBAIwAAAAAMAQCMAA AAAAAEMgAAMAAAAADIEADAAAAAAwBAIwAAAAAMAQCMAAAAAAAEMgAAMAAAAADIEA DAAAAAAwBAIwAAAAAMAQCMAAAAAAAEMgAAMAAAAADIEADAAAAAAwBAIwAAAAAMAQ CMAAAAAAAEMgAAMAAAAADIEADAAAAAAwBAIwAAAAAMAQ/j+1V7oo1AKKCgAAAABJ RU5ErkJggg=="/></symbol><use xlink:href="#c" width="1280" height="1280"/></g></g></svg>')} +.is2d .knight.white {background-image:url('data:image/svg+xml;base64,<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="614.635" height="614.635" viewBox="0 0 460.977 460.977"><mask id="b"><use xlink:href="#a" width="1280" height="1280" transform="rotate(.193) scale(.36014)"/></mask><symbol id="a" viewBox="0 0 1280 1280"><image width="1280" height="1280" xlink:href="data:image/png;base64, iVBORw0KGgoAAAANSUhEUgAABQAAAAUACAAAAAA9j6ArAAAACXBIWXMAAA7EAAAO xAGVKw4bAABJOElEQVR4nO3dd4AV5d238Q3LLrCsVAEFRUQFUeNjSV5LFCtWrCgW IpZYsJcYY2I3atTYO/YoFhAVRUURRBF7bIkgIkoRkbbSWdh2XkGlLFtOmZnvfd+/ 6/PH8yQKZ7/sMld2z5kz85s8ADDqN+oBAKBCAAGYRQABmEUAAZhFAAGYRQABmEUA AZhFAAGYRQABmEUAAZhFAAGYRQABmEUAAZhFAAGYRQABmEUAAZhFAAGYRQABmEUA AZhFAAGYRQABmEUAAZhFAAGYRQABmEUAAZhFAAGYRQABmEUAAZhFAAGYRQABmEUA AZhFAAGYRQABmEUAAZhFAAGYRQABmEUAAZhFAAGYRQABmEUAAZhFAAGYRQABmEUA AZhFAAGYRQABmEUAAZhFAAGYRQABmEUAAZhFAAGYRQABmEUAAZhFAAGYRQABmEUA AZhFAAGYRQABmEUAAZhFAAGYRQABmEUAAZhFAAGYRQABmEUAAZhFAAGYRQABmEUA AZhFAAGYRQABmEUAAZhFAAGYRQABmEUAAZhFAAGYRQABmEUAAZhFAAGYRQABmEUA AZhFAAGYRQABmEUAAZhFAAGYRQABmEUAAZhFAAGYRQABmEUAAZhFAAGYRQABmEUA AZhFAAGYRQABmEUAAZhFAAGYRQABmEUAAZhFAAGYRQABmEUAAZhFAAGYRQABmEUA AZhFAAGYRQABmEUAAZhFAAGYRQABmEUAAZhFAAGYRQABmEUAAZhFAAGYRQABmEUA AZhFAAGYRQABmEUAAZhFAAGYRQCRu9a3fdy/VD0CyBwBRM7aj22R98PmC9QzgIwR QORqg3Hr/PR/Z21GAeEdAogcdf5v0xX/f9bmc8VLgEwRQOSmy2dNfvlPJZtRQHiG ACInW37caOV/Luk2W7gEyBwBRC62+aBwtf82rwsFhFcIIHKwZv8oIHxDAJG9LT8p rPZPKCC8QgCRtdWf//sVBYRPCCCyVVP/KCC8QgCRpZr7RwHhEwKI7HT9vOb+UUB4 hAAiKx2/LKr131FA+IIAIhttJjar499SQHiCACILzb5tXee/n9eZd8XBBwQQmSv4 doN6fkVJZ64NAw8QQGRuzB/q/SUzOy9JYAiQGwKIjL14UBq/aPomS2MfAuSIACJT 9/ZL65dN6VIW8xAgVwQQGTrn9jR/4cRuFbEOAXJGAJGZfV5N++/MuN9WxbkEyBkB REa6fFGQ/i8etWd8Q4AIEEBkotEPLTP55UMPjmsIEAUCiEy8uVtmv/6JP8azA4gE AUQG7jg7099x7xlx7ACiQQCRvsOey/z3XH1F9DuAiBBApK3td9WvgJ+OM++JfAgQ EQKItE3cJJvflTry2aiHABEhgEhXmu8AWUvVnm9FOwSICgE0o3mDealcfv8eI7P9 y1L+269y+cBAbAigGfft2v+OHH57Qck6Wf/exRtzgVQ4iQBa8fsxhUufuXxy1r9/ yCE5fPBZG3FpGLiIABrR8oVdf/q/X/3t+Sx/f++BOX34CV1z+u1APAigDY3+ed6K L/WS566emM0zgY3mNsltwEvpXEMQSBgBNKHgpOtb/PyfKkfdMCKLB3jusFwn3HNm ro8ARI4AmvCHAZ1+/Y9Vk+8cUJLpN4F7ZRPNai64NffHAKJFAE0Y2Hu1/1L1ytUf ZfbbG5S0yH1D6vAhuT8IECkCaEDh2VcWr/7fq768LLPXQjK/BkJNKn/3WRQPA0SH ABrQ57oNq32dywdekMGZee2mN4hkx5KNZ0XyOEBUCKABX2yx1pc5NfmmR0rT/f1v dY9oyMwNyyN6JCASBDB4vznxgZq+gZv3yIVp3rGj59DItryzS2QPBUSAAAZv18c6 1fjPy0bfP2xROg8wq010YwYdFd1jATkjgKErfGHf2r7Is/rfmEYBL/xXlHOuuyTK RwNyQwAD1+CoAbW/grHgiZt+qO+ZwIIFjSMddPxjkT4ckAsCGLhtB2xR179eNumK QXU/wH2nRTknL69qtzHRPiCQPQIYtua39a37FJbUNyfXebnSZiUNIx2Ul1fW7duI HxHIFgEM25nXF9f3SyoGH1PHv33q6AjX/Gz+RvMjf0wgKwQwaP/39Ob1/6KKIRdN qu3ftf0hmnOg1zC1c2X0DwpkgQAG7eG++Wn8qsrX+02p5V+9GMtVrEbuHcejAhkj gCHb+9lmaf26ynduerXG92i0+yGevyCP943lYYEMEcCANR2S9ndaP171QE3nw8Tz DWAet0uHIwhgwK6/oCDtX7vkkSvnrPUP4/oG8Cd9H4/rkYH0EcBwtftfJu9hK3/w /GXV/9ngXhHOWRM3C4YLCGCwGv7rvMx+w5QeX6/5D4rnpfMSSpbK/+/L+B4cSA8B DFX+wQ+0zvC3vHPimgV86KTo5qxtySYz4nx4IA0EMFQb/nuPTH9LatTRq18mtWBR YYR71lbSKa2L0QDxIYChuvpvmb+HLTXuiPGr/ttVl0c4pyZTNyuL+SMAdSOAgdry pU5Z/K7UO6esKuCPLSNbU4svt0rzmqxAPAhgmIruPzqrFzBSb5z43S//8dDMbpyU Fd4SAi0CGKYTbmue3W+sfKXf9J//0/iu0c2p1ZCcb7gO5IAAhmn0Ltl+ZVMvnLri lZAo7oWehsFHJvJhgBoRwCD1fjqHL+wbfb/Pi/ZOIHV5sk8yHweoAQEMUYfhdV4G uh6pl376KbggsRdoBxyX1EcCqiOAASq87ryc3sKRGnB86oorIxpTPwoIGQIYoN++ 2j7HR3ir5+RM30aSAwoIFQIYnqJ/nZ7rlzU1cbNIpqSJV0IgQgDD0/ORddUTMvXC oeoFsIkABqfpkwf591UdsS/vCYGAf4cK6tH37npvBOegsdtUqCfAIAIYmlZP7+3l F3XylkvUE2CPl8cK6nDpJY3VE7Izu1uJegLMIYChmdJRvSBbC7eerJ4AawhgWH6z +0h/v6RLu3+kngBj/D1aUIPftL83rhtZJqHyyAQuwQWsQgCD0ujCi318CXil1F9u Vk+AKQQwKFsO3MLzr+jdZ6kXwBLPDxes6dS7M78RiGN4UwgSRABD0mToXuoJuRu3 /VL1BJhBAENy8u1F6gkRqHz/uzmzvp8yZUq5egmCRwADUvxS96C+nlVlSxZM+W7m tMmTvuZdIohFUAeMdUc+5umbQOqXKl+ycPK0mVMmjJ/MVRMQHQIYjqLHeqknJKFi yYJvJ0+fNP7L2eol8B8BDMchDyV4FWcHpMoWz/t6wjdffMZ7iJEtAhiMwicPa6De oFG1dN7Er77+738IITJFAIPR+eMW6gliVUtKvhr733cnqHfAHwQwGCc8zBdzhdSS 2WM//2TMTPUOeIBjJhRtBuyjnuCWynk/ZXD0t+oZcBoBDMUJdzVVT3BR1YKxn7wz gmcHUTMCGIohh6gXOKxs5idvj/hcvQLuIYCBaPtlK/UE11WVfDzq5bHqFXAKAQzE CfcXqCd4oXL2R288N1W9Aq4ggIEYtp96gUeWTRk9cFSlegUcQADDsP7XvASSmdSc 918ZOFe9AmIEMAgNjnxaPcFL8999btAC9QgIEcAgNL/zOPUEb81959lBXG3LKgIY hG1e8PZuwE6YOfze99QboEAAg3Dsv72/F4ha+fvPP8pTguYQwCA8dJJ6QRBKht/+ gXoDEkUAQ1D00RbqCaEoffP+F7nmtB0EMAQHPbGOekJAKt978tFS9QgkgwCG4M4z jF4KNS6pbx68bZl6BBJAAEPw1q58HaNW9eW99/FmkeBx4ASg0VcbqScEqXLMPYN5 PjBsBDAAOw1pq54QqvJhV3ym3oAYEUD/NfjjPbwROD5zHruKd8sFiwD6L/+sW3gN JE6pd29+Xr0B8SCAAbjsavWC4C195i/cZClEBNB/TZ44TD3BgNS7Vw9Xb0DkCKD/ th24mXqCDfMeuIITpANDAP130APt1BOsqHz1onHqDYgSAfTf/oOK1RMM+frcYeoJ iA4B9N+Oo7kfUpJmXtFfPQFRIYD+O/ZxzoJJ1sLbr+RdcmEggP679mICmLSyf5/H ZfRDQAC91+Aff+OrmLyKAWeSQP9x6Hgv/4w71BNsIoEBIIDeK7j8UvUEqyoePYcT A/1GAL3X7LYT1RPsIoGeI4DeK+x/PF9FnfJb/s41A/3FoeO/QUeqF9i24LxH1BOQ LQLov6E91Qus++6Po9UTkB0C6L0GTxzFV1Htrb5T1ROQDQ4d/w0+nK+iXGrQibwa 4iEOHf8N20+9AD9ZeuHd6gnIGAH0XoN7T1VPwAqTDv2vegIyRAC91/Cv16gn4Gep p0/kdup+IYDea3TNheoJ+FXpuQ+oJyATBNB7BVdyNRiHTNx/onoC0kcA/XcJPwK7 pOqGv6snIG0E0H/Xcjkst0zb50v1BKSJQ8d/f7uKS+K7peqO89UTkB4C6L8Tr1tP PQHVzNiXM2K8QAD9t8F2L6gnoLpU/9PVE5AGAhiClHoA1vbDHl+pJ6BeBDAEBNBF VZddp56A+hDAEBBAN405aJ56AupGAENAAB219IiX1RNQJwIYAgLorAdPUS9AXQhg CAigu6buMEM9AbUjgCEggA4rO2qIegJqRQBDQACddu8Z6gWoDQEMwdQN1QtQl/E7 LFBPQM0IYAgKuQyn2xbv9rF6AmpEAIPAz8COqzr7HvUE1IQABqGKr6PrBhynXoAa cOAEoYwLYjlv/O8XqSdgLQQwCAuL1QtQr3k7TFBPQHUEMAjzmqsXoH4VvV5UT0A1 BDAIywrVC5CG1MU3qidgTQQwBJtzDwpP3H+aegHWQABDcDdvNfDFqwdWqSdgNQQw BJM6qRcgXd9svUQ9AasQwADkl3FndH/M3nK2egJWIoABOOw59QJkYNH2nA7jDAIY gCGHqBcgE2W7va+egF8QwABwFqBnKg8Yrp6AnxFA/3WYpl6ADFUdM0g9ASsQQP/d 9Gf1AmQqdXp/9QQsRwD9901n9QJk7i83qRcgjwAGoGApJ8H46BJum+4AAui94x5T L0BWrrxKvQAE0H/De6gXIDvXXaJeAALovdLG6gXIEgWUI4C+24GTav11xdXqBdYR QN8N7K1egOxdeq16gXEE0Hfzm6kXIAcX3qxeYBsB9NwWY9ULkJNTHlQvMI0Aeu7R 49ULkJPUUc+oJ1hGAD1X0kq9ALmp2p8rI+gQQL91mqRegFxV7PyReoJdBNBv/U9V L0DOlm3xrXqCWQTQb/wEHIKFG5eoJ1hFAL3G/TDDMGujpeoJRhFArz1xrHoBIjGx K3fLlCCAXltYrF6AaLxyoHqBTQTQZzu+p16AqNx3unqBSQTQZ9wOLiC8KU6BAHqs QWmhegIikzr0RfUEgwigx065X70AEarYmtf0E0cAPfZVF/UCRGnBhgvUE8whgP5q M5OvXlgmbqZeYA6HkL/uP0W9ABF79gj1AmsIoL8WrKNegKhxr8yEEUBv7TVCvQCR S/UYqZ5gCwH01uhd1QsQvWWdZqgnmEIAfdV2Bl+7EE3fkHcFJ4iDyFcD+qgXIBYv 8vaeBBFAT/EukGD95Sb1AkMIoKf+er16AWJStSOXyE8MAfTUzLbqBYjLonZL1BPM IIB+6sGdxAL2zi7qBWYQQD99ubl6AWJ041/VC6wggF767X/VCxCn1O6j1ROMIIBe GrW7egFitbgtTwMmggD6qONkvm6Be2t39QIbOJB8NLSnegHidsXV6gUmEEAPtZ7N ly14VdvyPG8COJI89Ozh6gWIX0lb3hQcPwLonw7f8VWzYODR6gUGcCj5Z3gP9QIk ovcz6gXhI4De2WKsegGSsawtN0mKGwH0zpg/qBcgIZwLEzsC6Jvd3lQvQGLOvUO9 IHQE0DeTN1IvQGIqNpqunhA4AuiZkx5SL0CCuFNwzAigXxrML1ZPQJKuvEq9IGwE 0C93n6FegERVbTJZPSFoBNAr609roJ6AZH2zqXpB0AigV7gXsD2XXaNeEDIC6JPe A9ULkLjKzlPVEwJGAD3SqKSpegKS9xW3P4gPAfTIoCPVC6DA6dDxIYD+6P6WegEk ytvOU08IFgH0Rv7sluoJ0Bi5t3pBsAigNwb0US+AyjFPqxeEigD6Yo831Asgs7hl uXpCoAigJ5rM4j1whj3xR/WCQBFAT7y6r3oBhFLbfaaeECYC6Icz7lYvgNS0DdUL wkQAvdBlXL56ArQuvVa9IEgE0Af5M9ZVT4AYJwPGggD6YMgh6gWQe+VA9YIQEUAP XHSDegEcsDvvBIoeAXTfLqP5KiEvb+Z66gUB4tByXuvvmqgnwAlcHj96BNB1+VPb qyfADRWtuVF61Aig64b3UC+AK4YerF4QHALouHv7qRfAHb/7WL0gNATQbX+9Xr0A Dpm8sXpBaAig0455gi8QVtOvv3pBYDi+XLbbG9wFE6tb0qxSPSEsBNBh23zUUD0B junPc8KRIoDu2vSLRuoJcE1luxL1hKAQQGe1n8BNMLGWYQeoFwSFALqq/fh11BPg Ik6FiRIBdBT9Q82+2VS9ICQE0E0dv6B/qNlRg9QLAkIAndTlMy6AgFr82Fq9ICAE 0EXbvM/rv6jVxVwfMjIE0EG7vV6gngCHla7D2dBRIYDu6TWI93+gLvecqV4QDALo nH738EVBnbgwYGQ41lxzw0XqBXDewKPVC0JBAB0zsLd6AdxXtd5s9YRAEECnFIzc VT0BPniRG6VGgwC6ZL3P26onwAupjb5TTwgDAXTIziMbqyfAE6/vo14QBgLojtPu 4fQXpKvrBPWCIBBAZzx0knoBPPJ2d/WCIBBARxR9uKV6Aryy4wfqBSEggG7Yakxz 9QT4ZUJX9YIQEEAn9Lubp/+QoX1eVy8IAAF0QIOnOPsZGZu6kXpBAAigXvsPNlBP gI96vqxe4D8CKHfwM4XqCfAS3wLmjgCq3XG2egF8te9w9QLvEUCt1mM2V0+AtyZ1 Vi/wHgGUOngQ175H9vYcpV7gOwKo9PCJ6gXw2tdd1At8RwB1Or7Dq7/Iza5j1As8 RwBlTurfUD0BvhvfTb3AcwRQpOAZLmmJ3PGO4NwQQI1dXuK9v4jA2K3UC/xGACXu PY1PPCKx9f/UC7zGcSiw6Zsd1BMQCq4LmBMCmLyLr+XSL4jMJt+qF/iMACatxdBd 1BMQklcOVC/wGQFM2An9ufQBopRqU6Ke4DECmKii5/ZVT0BonvijeoHHCGCSej3e RD0BwakoXqae4C8CmJxGAzn3GTG48xz1An8RwMTsO7hYPQFBKi2uUk/wFgFMSP6A o9UTEKpLrlMv8BYBTEaPwc3UExCseS3VC7xFAJNQ8FQv9QSE7MRH1Qt8RQATcODT PPuHOH3PlSWzRABjx4u/iF33t9ULPEUA43bYgCL1BARvzK7qBZ4igPEqGry/egIM SG34vXqCnwhgrE64t7F6AkwYfKR6gZ8IYIxaPre7egKM4P1w2SGA8TnnpgL1BJhx 41/VC7xEAOOywXBu2IXkLOAmM9kggDG5/PJ89QSY0vdx9QIfEcBYdHmtk3oCjJm8 sXqBjwhgHG45l7t+IGlbjVUv8BABjN42w9ZTT4BBw7naeOYIYNQa9P8Tn1QIVLWe p57gH47ViHV/vpV6Aox68BT1Av8QwEgV/PsY9QSYVcq7zjNGAKO0/8B11BNg2KkP qBd4hwBGp8nTB6snwDTOhMkYAYxM70e55yW0unytXuAbAhiRZoN7qCfAvCGHqRf4 hgBG4+S7GqknABVF5eoJniGAUeC6V3DD1VeoF3iGAEbgjNu47hWcMKeNeoFnCGDO 2jy3i3oC8Itd3lEv8AsBzNX5NzZUTwB+NWpP9QK/EMDctH99C/UEYJVUK94QnAkC mJM/X8+3f3BK/37qBV4hgDlo8/wf1BOANS0uVi/wCgHMHi/+wkEHvaRe4BMCmK0W Q3ZTTwDWNmZX9QKfEMAsnXhfoXoCUANeBskEAcxK8fN7qycANbv7LPUCjxDAbPQc xIVf4Kr5LdQLPEIAM9fgiaPVE4Da7fGmeoE/CGDGtn29tXoCUIc39lIv8AcBzNSN F/I5g9Oq1lminuANDubMtB+9iXoCUI9/XaRe4A0CmJFT7uGtb3BeybrqBd4ggBnI f467HsEHO36gXuALApi+bd5oqZ4ApOPV/dULfEEA03bJ1Q3UE4C0VDSuVE/wBAFM U9FLe6gnAOm64Fb1Ak8QwPTsMbSpegKQtm82VS/wBAFMy00X8ImCT9rOVi/wA8d1 Gope5QpD8Mu9Z6gX+IEA1m+HEVxkF56Z20q9wA8EsF4XXc8nCd753cfqBV7g2K5H g2cPVU8AMjeUk/bTQQDr1v6j9uoJQBbKG1epJ/iAANZpr5cbqScAWTnlQfUCHxDA uvD0H7w1bkv1Ah9wgNdhYG/1AiBbqRYL1BM8QABrVfzJZuoJQPZuvlC9wAMEsDab fsS9ZeCzGeurF3iAANZin5cK1BOAnGw0Vb3AfQSwZmfcxWcGnnv4T+oF7uMwr9Gt 56kXALmaxwV860UAa/LcYeoFQO62+Vy9wHkEcG0Fo/6gngBE4Nkj1AucRwDX0nxs B/UEIAqlReoFziOA1W3wP05/QSB6jFAvcB0BrGbLj5qoJwAReW0/9QLXEcA1bf9u oXoCEBUuCVMfAriG7iMbqicA0enzpHqB4wjg6vYfmq+eAERoDHezqRsBXE3vp7j1 OYJSVbRMPcFtBHCVkx7ks4HAXHizeoHbOORXOvNOPhkIzZdbqBe4jWP+V6fcr14A RI6fgetGAH9x8v18KhAgfgauE0f9z/o+ymcCIeJn4Dpx2K/Q53E+EQgSPwPXieN+ ud5P83lAoM69Q73AZRz4PznsWT4NCNXYrdQLXMaRn5e32xuc/4xgVTUuV09wGAHM 2/o/3P4IAeNn4DoQwI5fNVZPAGLEz8B1MB/A1t82U08A4sTPwHWwHsCiyW3UE4B4 ncabnGplPID5EzupJwAx45pYtTMewBF7qRcAcass5LrQtbEdwMeOUy8A4tf7GfUC Z5kO4OVXqRcACRi+r3qBsywH8JgnLP/pYccyzvSqjeEE7PgObwCBDXu8qV7gKrsB 7DihkXoCkIzneqkXuMpsABtNb6WeACRk0TrqBa4yG8DRnBsFO7Yaq17gKKsBfOgk 9QIgOY/3VS9wlNEA9rtXvQBIUMm66gWOshlAXgCGMRt8r17gJpMBbDOliXoCkKg7 z1EvcJPFADaY2kE9AUjWtA3VC9xkMYCDOSkK1qSKl6gnOMlgAM+5Xb0ASNzp96kX OMleALf9Dy+AwJ63dlcvcJK5ABbN4KR4GFReqF7gJHMB5B0gsIkLItTEWgBvPU+9 AJB4prd6gYuMBbDHa8b+wMAv5rVUL3CRrR4Uz+IMaFjFm0FqYCuAPAEIu275s3qB g0wF8B+XqhcAMpM6qxc4yFIAd3jP0p8WWFOqUbl6gnsMJaHRrGbqCYBQ38fVC9xj KIDD9lMvAJRe30e9wD12Anga74WEbaVF6gXuMRPA9lMaqicAWt3Gqxc4x0wAv+El MFh3z5nqBc6xEsBbzlcvANSmdFIvcI6RAHIGDJBXVVipnuAaG13In9NCPQHQO2qQ eoFrbATwqaPVCwAHDD1YvcA1JgK476vqBYALFvJegGosBLDRnGL1BMAJXBGmGgsB HHKIegHghhv/ql7gGAMB7DVYvQBwxISu6gWOCT+ARXO4CCrws8rCKvUEt4QfwJcP UC8AnLHfa+oFbgk+gIc+r14AuGMgZ4StIfQANippqp4AuGNWO/UCt4QewMG91AsA h6SalqonOCXwAPYYrl4AOOX4x9QLnBJ2APNLmqsnAE55uad6gVPCDuBjx6kXAG5Z wPcEqws6gNt/FPQfD8hC29nqBS4JuhA/rKdeALjmglvVC1wScgBvuEi9AHDOW7ur F7gk4AB2+qaBegLgnKW8NXQ1AQdwPO/7BtbWdYJ6gUPCDeDZd6gXAC66jRuErRJs AItLCtUTABdxSazVBBvAoZzvCdSkokC9wCGhBnCvEeoFgKP+30fqBe4INIANZrdS TwAcdc+Z6gXuCDSAd5ytXgC4iicBVwkzgJ2/5hRAoBblvD64UpgBHNdNvQBw13af qhc4I8gAnviwegHgsDvPUS9wRogBbDSXN/sAtftqc/UCZ4QYwCeOVS8AXMaTgCsF GMBtPgnwDwVEaJvP1QtcEWArpnRULwDcdvt56gWuCC+AF/5LvQBw3JdbqBe4IrgA chEEoD5ljdQLXBFcAEftrl4AOG+rseoFjggtgH++Sb0AcN9VV6oXOCK0AFbyHjig XqN3Uy9wRGABfGMP9QLAA4uL1QscEVYA281QLwC8sG6JeoEbwgrg63urFwBeOO1+ 9QI3BBXA/V9RLwD8MPRg9QI3BBXAEi4DDaRlThv1AjeEFMCrLlcvADyRKqhUT3BC QAEsmst7QIA0HcjzRcsFFMCnj1IvALzx7xPUC5wQTgDbTeccaCBdkzqrFzghnAAO 20+9APAHt0dfIZgAbvZVMH8UIAFcD2G5YKrBm+CATFxxtXqBC0IJYOeJofxJgES8 sZd6gQtCycar+6oXAF5Z0Fy9wAWBBHD97wP5gwBJKSpVL3BAIN3gHEAgQ4cNUS9w QBgBzC/lNX0gM5wKnRdKAC+5Rr0A8M03m6oXOCCMAM7i0hZAhrg1XF4gAezylXoB 4J8Nvlcv0AsigAP6qBcA/jn7LvUCvSACuJA7vAAZ46rQYQRwp3fVCwAPzWqnXqAX QgD5CRjIQlVBlXqCXAgBnMH/kAFZ2Pk99QK5AAJYtCiAPwSQvH9wF50A2nHSQ+oF gJdGch/tAAL4Aq9lAdmYy31kAwjgtA7qBYCXUg3NvwoSQADLuBACkJVd3lEvUPM/ gB2mqRcAnuJVEP8DeOLD6gWAp3gVxP8A/vNi9QLAU7wK4n8A/91XvQDwFK+C+B/A N3dTLwB8Zf5VEP8DOKWjegHgK/OvgvgfwB9bqhcAvjL/Koj/AZzbQr0A8JX5V0EI IGCX+VdBCCBg2HafqhdoEUDAsIv+pV6gRQABw6zfF8T/AP6wnnoB4K1pG6oXaPkf wImbqBcA3rJ+d3T/AzhiL/UCwF/rlqgXSPkfwLvPUC8A/HXsU+oFUv4H8Lxb1QsA f915jnqBlP8B3P4/6gWAv97ZRb1Ayv8ANqjw/88AqCxorl4gFUA85tn+CgK5MP5m uAACyMvAQPZ2el+9QCmAAF78T/UCwF+XXqteoBRAADecql4A+Mv2m+ECCGDewmL1 AsBbUzqpFyiFEMCXDlQvALy1tIl6gVIIATzgZfUCwF+Nl6kXCIUQwLyyAvUCwFu7 jVYvEAoigMP2Uy8AvGX6ZeAgArjje+oFgLdMvwwcRAC5NSaQtakbqRcIhRHAGy5S LwB8Zfpl4DAC2GhxvnoC4CvLLwOHEcC8wb3UCwBf7TlKvUAnkAC2nRHIHwRInOWX gUPpxssHqBcAnrL8MnAoAezwXSh/EiBhkzdWL9AJJhvPHq5eELjKr5/q0kc9AnFY bPhqIsEEsOVsXgiOz5w3HhpRlfdWd/UOxCHVQL1AJ5gA5t11pnpBoBa/P2TAvBX/ qaSVeAri0XWCeoFMOAFsMN/wN/JxWfrRK49/v/K/VRr+TiFoJz2iXiATTgDzjnlS vSAsiz8cPujb1f9B529UUxCv289TL5AJKIB5o3ZXLwhFau4HLw+aXf2fnvyAYgvi N3Jv9QKZkALYekZD9YQAlH/39uDXymv6N4//MektSMaM9dULZEIKYN6fb1Iv8FvV nA9HvDC51n89dovkpiBJyxqrF8gEFUAO0aylFnz89ssf1f1rFjVNZgsSZ/dyCGEF cL2pXBw/c4umvDNkRI0/9K6hyZIEtkBiZ7OXFA4rgHknPaRe4JXU/M8/GDmq/vat cOjz8Y6BzgW3qheoBBbAvKE91Qs8UVnyyZiRH1Zl8DseOim2MRB76GT1ApXQAlgw k6vj16d0+n/eHP5t/b+umnHdYtgCJ4zZVb1AJbQA5m39KW9XqFVFyecfvv12aXa/ eXFRtGPgjtlt1QtUggtg3vm3qBe4KDX/i8/eHzEzh0do+WNkY+CaskbqBSrhBZDL 41ezZPono0eNy/lhTu0fwRY4qmGleoFIgAFsMGUD9QRHLJ3x2XvvfJjmi7z1eenA aB4HLtr2M/UCkQADmNd2suX7/K1QXvL5h2OyfbKvZlwLK2SnPKheIBJiAPN2eNfw CyGLpn70ek5P9tWM06CDdusF6gUiQQbQ6vnQSz54b9RbEf3EW91RT8fzuHDCa/up F4iEGcC8m/4c8QNWVpSVpfLyChs2cvXK+zOv7h/nE9m8tBS0KZ3UC0QCDWCE90ia /7//fvz5uFVPpxVssfMuO23o2IW3lj124YJ4P8Kc1vE+PqTM3hcp1ADmfbFlBA9S MurpV2p+JWH3c/d359SpkptuzOQ9bdloPSfmDwCpKld/sIlbsAEsnLhhjo8wbeA/ S+r41w3OubJ5jh8hGpMvSOAqBVxqMXDtf1Av0Ag2gHnNJuVy3sbiZ/5e/9+IW87T f/rGnjE6iQ/z9i5JfBTIHDxUvUBDfwTHZr2JWV/Ac9oVD6f16/Z9WfuTQ2rkmQnd 0LCMCy2G7W/XqxdoBBzAvK7/Lczq93118ph0f+lxj2X1ESIy4rTMr+mSnZ3eTegD QaR/P/UCjZADmLfzW1m8WDupb9r5+8m0Dpl/hIiMOu3rxD7Wk8ck9qEgYfXGcEEH MK/7G5n+iDq336CMfv0dZ2f4AaIyrvfYBD/a3BYJfjAITN1IvUAj7ADm9RiWUQEr b7koww8g+tlw9kkvJfnhuCV68Ba4cUpD4gIPYN6BL2bwtuBRR9Z13kuN8isy/R0R WHrFjcl+wPtOS/bjIXGVjp3an5TQA5jX88V0/4ilpzyRxeOXJ/8X55njkr6J4ex1 E/6ASJzRO2MGH8C8XoPS+x5w5KGLsnn4xG+WO+PQDxL+iPwEbMF2n6oXSIQfwLz9 h6bxPGDFBXdm9+gLk30TZeWNf0/0463w8InJf0wk7HjpGV0yBgKYt9uIen9MndR9 WpYPnmwAp+82MckP94v5zQQfFMm67hL1AgkLAczb4e2638eQuuO8rB87yR+BUw+e mtwHW4WzoC14vK96gYSJAOZt835dl25Zdtiw7B86wfeILT5kZGIfa3XcDcSCd2y+ 29tGAPO6flz7N2qT/9/sHB65MrGr74/dOeZL/tUif6nRMyRsmbG+eoGEkQDmrTe2 tmvD/PuEXB630dJcfncm7js9qY9UzV+Nvk3eGKOXRLUSwLxm/+tY0z+uPCm3F7+2 /SSn35621Fn3JPOB1vYddxm1wOiZ0GYCmFfwRg1Pcizc5b+5PeoJj+T2+9NUceDw RD5ODTb/UvWRkSib90a3E8C8vBcPqv5PJvw+16fVbsj0zcNZWbqT7r7Va3/WEKTN FGdYyVkKYF7/ameRDDgu54cc3iPnh6jf4q2Tuu7f2hottnq3CGsOfEW9QMFUAPPO v3m1P2/qvDtyf8QZ7XJ/jPos3CLbs7QjcN3fdB8bSTony/dC+c1WAPP2f3HlU71l B0RxVl0CpwEu6TY19o9RO94FYsXNF6oXKBgLYF63D395tb9kuyiy0m5GBA9St6W/ VT43k9CLPNB7so96gYK1AOY1/9+K22W+s1ckV/85tX8Uj1KXsu2/iPtD1IVzYMx4 u7t6gYK5AOY1GHJQXuWTEb3x8ZkjonmcWlXs/FHMH6FOe41QfnQkaVquN9L2kr0A 5uVd/ffuUb29f0qNZ1dHp2p/2fl/K3zVRfrhkSCbF8W3GMC8TpOjeqSKmM8ROUn7 FFxS73OBA8qzu4ms50wGMDJxB+KKq+N9/Pq8bfMKITalErush0sIYC5ivinmg6fE +vD12uF97cdHotbJ6p4QniOAufhiyzgffdgBcT56GsZuIR6AJG39P/UCAQKYi2Vx Pm0yadOqGB89DTu+p/34SNZBid5r2hEEMAdbxnmK3vyOmuufrjJxE/EAJOr0+9QL BAhgDuJ8CrCsm+4CCD87+AXxACTrmsvUCwQIYA4mbBbbQ1fto7n/x2qSuM4DHNK/ n3qBAAHMQYxnAZ76QGwPnaYz7lYvQLKe6a1eIEAAs7fPa7E9tP7KHPkLitQTkCyT 94UjgNkbGNv/Yj7XK65HTlv1i8cieFM3Ui8QIIDZm9M6pgceF+vphWlp+4PJ9wWY Nre2GyeGjABmrfWcmB54dsfE7rVZqzf2UC9A0kotPulBALP2j0vjedzFnWfF88AZ ONDiObHWmbwxJgHM2viusTxs+bZjY3ncjPzYUr0AiTN5NQQCmK38slj+vlTtPSqO h83MreepF0CgsFy9IHkEMFtHDorjUVNHx/Kwmen8tcXvBbDB9+oFySOA2Rq2XxyP euY9cTxqhrgOtE2/+1i9IHkEMFuL43jN7C83xfCgmTrndvUCSFi8NToBzNL/fRbD g152TQwPmqmWM+O/1zFcdOKj6gXJI4BZeuSE6B/Tif7lvWXy9ohw5OePhBHALM1q E/lD/vXGyB8yC/3uVS+AyPV/Uy9IHgHMTrsZUT9i6gwnrkfZ+gd+ALbq3jPUC5JH ALNzy/kRP2BV72cjfsTscB8Qu57so16QPAKYnajviL50r6ju1Z6bS/+hXgCZFw9R L0geAcxKs3nRfuJm/J/+/b/LdR3HKdB2WbwgIAHMSsTfKA09rDLSx8tWg+/XU0+A zoR43t3uNAKYlUjfK1F5jgtv/1hugMEngbCSxSuiEsBsFCyL8PM2ucfE6B4sJ70H qhdAacb66gXJI4DZOPOuyB6q8h9XRfZYOWr7XZz3eYfzStZVL0geAczG3BZRPdJr x82O6qFyNqmTegGkFjRXL0geAczCzmMi+rRNOvb9aB4oCnG8uQ8+WdJUvSB5BDAL EX0DOKnf8EgeJxpHP6VeALGyRuoFySOAmXvq6AgeJPXmX5y6+lrHibwFzroKg38F CGDGOnyX+yftxyeuKolgSnTyp7dVT4BaVb56QfIIYMYuuyDHn4B/HHrjuGimROfV fdULIGfxrkgEMAvNeh+2U4vsPnMLPxn6mDuv+650ncELIWEtBmtg8I8cjfxde+z8 f80y+JmhatGMd158rTS+RTk4eAh/D5CX19CNd2Qmib/4OWm98+832rhzhzp+RWpZ 6bxvJ0/79P2ZiY3KWJcvDD77jbU1X6BekDgCGIG6njqpSmxF1oq/i+y8bnit5Tz1 gsQRQIw3eBEQ1MTgjYEJoHlPH6VeAEd0/E69IHEE0LrLnbkYA9S6jVcvSBwBNO7I gfwVwC8IIIzZ9iODZ/+jFv/vI/WCxBFA09pMLlJPgDsIIExpPIV3AGOVPd5UL0gc AbSME2Cwuj1HqRckjgAaNrSnegGcQgBhyH2nqRfALQQQdkR8b2P4jwDCjJMeUi+A a3Zy6BY1CSGARu3/Ml96VMNpMDBi+w84ARrVEUDYsOkXBm8Ahvps87l6QeIIoEVt vylWT4CDeC8wLGg2qZV6AlxEAGFA4bd1XcMfdm02Ub0gcQTQnAZfdlFPgJu4IjTC 91Z39QI4qt0s9YLEEUBrhu2nXgBXNV6mXpA4AmjM4F7qBXCWwRoY/COb9ujx6gVw Vqqu+7sGigCacs/p6gVwV5XBdwcRQEtu+rN6ARxWUaBekDwCaMhVl6sXwGVlBt8f SQDtuOgG9QI4rdTgHbIIoBln3qVeALctbKZekDwCaEW/e9UL4LgfW6sXJI8AGnHy /XypUbeZ66kXJI+jwobj/s1XGvWY0km9IHkcFib0eZwvNOozbkv1guRxXFjQ6xm+ zqjXiB7qBcnjwDDg4CF8mVG/AcepFySPIyN8PV8w+B5PZO7us9QLkkcAg9fjVfqH dFxzmXpB8ghg6HoMM/gWd2Tj/NvUC5JHAANH/5CuPk+qFySPAIaN/iFte49UL0ge AQwa/UP6thqrXpA8Ahiy7m/QP6St5Tz1guQRwIB1H9lQPQH+sHhFfAIYMPqHTJQX qhcIEMBg0T9kZEFz9QIBAhgq+ofMTO+gXiBAAANF/5AhixeDIYCBon/I1LAD1AsE CGCQOP8PGbv3DPUCAQIYIvqHzF1xtXqBAAEMEP1DFk58VL1AgACGh/4hG7uNVi8Q IIDB2fdl+ocstJqrXiBAAEPD9Z+RlSqT/7tJAAND/5CdJU3VCxQIYFjoH7L0Q3v1 AgUCGJTDBtM/ZOft7uoFCgQwJNz/F1l79ET1AgUOmIDQP2TvqivVCxQ4YsJx9JN8 NZG1Y59SL1DgkAlGn8f5YiJ7Fu8IQgDDQf+Qk4aV6gUKHDSBOOFhvpTIwbLG6gUS HDVhOPl+vpLIhc3TAAlgGOgfcjRyb/UCCY6bENA/5Or289QLJDhwAkD/kLM/Paxe IMGR4z/6h9xtOU69QIJDx3v0D7lLNaxST5Dg2PEd/UMESovUCzQ4eDxH/xCF7zqq F2hw9PiN/iESLx2kXqDB4eM1+odoXHqteoEGx4/P6B8i0v1t9QINDiCPnfQgXz5E o7BcvUCDI8hfXP8FUVlcrF4gwiHkLfqHyHzdRb1AhGPIV72f5muHqAw6Sr1AhIPI U9z/AxE66271AhGOIj/RP0TJ6DuBCaCnuP85olSVr16gQgB9RP8QqZnrqReoEEAP Hfgi/UOUXu6pXqBCAP2zx+tmf2BBPC68Wb1AhQB6Z8e3G6onIDBdJ6gXqBBA32zz YYF6AgJTYfevFAH0zJafFKonIDTTO6gXyBBAv2z6P5v3r0achhymXiBDAL3S8Uuj Vy5HnMy+D4QA+qX9+HXUExCg9j+oF8gQQI+0mdBCPQEBsnpDpOUIoD+af9NaPQEh eru7eoEOAfRG0bft1BMQpKuuVC/QIYC+KPza6I0LEbdu49ULdAigJxqM3Vw9AWEq t3xmKQH0xKjd1QsQKLOXw1+OAPrhpQPVCxCq/v3UC4QIoBcG9FEvQLB2eUe9QIgA +uCOs9ULECzDV0LII4BeuPQf6gUI14Su6gVKBNB9p92nXoCA3XqBeoESAXQeN4BD nDabqF6gxLHlul3e4gYgiI/lNwLnEUDndfvc9HPUiNvIvdULpAig29b7xvb/QCNu Z9+lXiBFAJ1WPKWVegLC1mqueoEUAXRZ/rdcAAGxKllXvUCLALps5J7qBQjcgOPU C7QIoMOeOFa9AKH73cfqBVoE0F3X/U29AKFb2kS9QIwAOuuU+9ULELzh+6oXiBFA V/V4ja8N4tbnSfUCMQ4yR3X5ghOgEbeqwkr1BDEC6KbmU5upJyB8pi8GvQIBdFL+ pA3VE2DA1VeoF6gRQCe9bvsNmkhGqsUC9QQ1Auiiey3fpQGJmdRZvUCOADqo373q BTCBn4AJoIO4AiASwU/ABNBB601qrJ4AE/gJmAC6p+C7duoJsIGfgAmge4b3UC+A DfwEnEcAnXPTn9ULYMQ3m6oXOIAAuqXXYPUCWHH+beoFDiCATukytqF6AoyoaGz9 fcDLEUCXFMxsqZ4AK8xfCWsFAugS3gGHxOw5Sr3ABQTQIVdfpl4AMxYXqxc4gQC6 Y6/X+WogKY/3VS9wAoecM1pP4x0gSMzGk9ULnEAAnfE1p2UhMVM3Ui9wAwF0xV1n qhfAkHPvUC9wAwF0xL7D+FIgMWVNqtQT3MBR54aW31u/QSuSNPhI9QJHEEA3jN1C vQCWbPKteoEjCKAT/nGpegEsmdJJvcAVBNAFW3/KNaCRoHPuVC9wBQF0QINZrdUT YMmyIl4C+QUBdMCTx6gXwJRHTlIvcAYB1Dv4BfUCmJJqPVc9wRkEUK7J7KbqCTBl JBcdWokAyr14kHoBbNnuU/UCdxBAtcOeUy+ALdM2VC9wCAEUa1LCW0CQqNPvUy9w CAEUG9pTvQC2LOEp59UQQK19X1UvgDE3X6he4BICKNXgx+bqCbClvGm5eoJLCKDU Q5yRimQ9/Cf1AqcQQKWt/svnH4mqarlAPcEpHIBKkzqpF8CY53qpF7iFAAqdeZd6 AYxJdfhBPcEtBFCn0TxuA4dkvb6PeoFjCKDOU0erF8CY1KZcCXpNBFCGV0CQtBE9 1AtcwzEo8+Xm6gUwhm8A10IAVQ59Xr0A1vAN4FoIoMrsddULYAzfAK6NAIpc/E/1 AljDN4BrI4Aa+Ys4BQbJSnWerJ7gHgKocdeZ6gWwZujB6gUOIoASTeYXqCfAmKq2 JeoJDiKAEo8er14Aax7vq17gIgKo0HJ2vnoCjClvXqqe4CICqDDoSPUCWHPrBeoF TiKAAi1KGqgnwJglzSrVE5xEAAUG9FEvgDXn36Ze4CYCmLxmP/IMIJI1Y331AkcR wOQ9fKJ6AazZe6R6gaMIYOIKFnMOIJL15h7qBa4igIm78S/qBTCmquP36gmuIoCJ W9RUvQDGcA50rQhg0s6+Q70AxixtsUw9wVkEMGkz2qkXwJhz7lQvcBcBTNhO76oX wJipG6kXOIwAJmzU7uoFsCW13WfqCQ4jgMlqPZvPOBL17BHqBS7jcEzWQyepF8CW Za2WqCe4jAAma0kT9QLYcsGt6gVOI4CJ6jNAvQC2TN5YvcBtBDBR47qpF8CUVLev 1BPcRgCT1GYmn28k6b7T1QscxwGZpP6nqhfAlLnrVqknOI4AJmluC/UCmMJVsOpD ABO07SfqBTDlxUPUC5xHABP07OHqBbCktDU3gqsPAUxQaWP1AlhyzNPqBe4jgMk5 4GX1Aljy+j7qBR4ggMkZtp96AQxZ1naBeoIHCGBylhWqF8CQkx5RL/ABAUxMz6Hq BTCE+yClhQAmhp+AkZyydvPUE7xAABPDa8BITt/H1Qv8QACT8vsP1Qtgx6v7qxd4 ggAmZUAf9QKYsWRdToFODwFMSkkr9QKY0ZNTTtNEABPSdqZ6AcwYdJR6gTcIYEIu ukG9AFb82LZSPcEbBDAhY/6gXgAjUtt/qp7gDwKYkLIC9QIYcc1l6gUeIYDJ+MMY 9QIY8eUW6gU+IYDJ4H7ASEZZ+xL1BJ8QwGRM6qReABu4CGBGCGAyKvLVC2DCk5xv nxECmAieAkQipm/IbeAyQgATwf0wkYSKTaaqJ3iGACbiqy7qBbDg+MfUC3xDABOx tJF6AQx4+hj1Au8QwCRsyA8miN+MDjwBmCkCmITzblUvQPgqNpusnuAfApiEFw9S L0D4TnxUvcBDBDAJP6ynXoDgDT5SvcBHBDAJnAaNuM1szxOAWSCACdhirHoBQlfR 9Vv1BC8RwAScf4t6AULHGYDZIYAJePZw9QIE7uE/qRd4igAmgEvBIF4TuqoX+IoA JoBboiNWizvMV0/wFQGMX5Ml6gUIWtXOH6gneIsAxm+PN9QLELQLb1Yv8BcBjN8l 16gXIGTP9VIv8BgBjN/zh6oXIGBcAzUXBDB+EzdRL0C4yjaaoZ7gMwIYv/nN1AsQ rNSBw9QTvEYA48c7gRGbGy5WL/AbAYxdM87RQlxe3V+9wHMEMHbd31IvQKhmbFCp nuA5Ahi7s+9QL0CglnXiBZAcEcDY3XmWegHClNprlHqC9whg7F7fW70AYfrrjeoF /iOAsZvSUb0AQRp0lHpBAAhg7Baso16AEH2zqXpBCAhg7MobqhcgQFwCKxIEMHYp 9QAEqOp3n6onBIEAxm396eoFCNCfHlYvCAMBjBvnQSN6952uXhAIAhi3E/mfakTt zT3UC0JBAON25RXqBQjN7A7l6gmhIIBx63+qegECU7bJNPWEYBDAuL26r3oBwpLq MVI9IRwEMG5jt1AvQFguuU69ICAEMG68Ew6Reukg9YKQEMC4zV5XvQAhmd1WvSAo BDBuC4vVCxCQipaL1BOCQgDjtqxQvQAB2fwr9YKwEMC4VTZQL0A4eAdcxAhg3LgW AiJz+PPqBaEhgDFr+aN6AYJx5znqBcEhgDHbYqx6AULxJaeURo4Axmynd9ULEIjS 9bkEauQIYMz2f0W9AGHgHXBxIIAxO+pp9QKE4ZY/qxeEiADG7NT+6gUIwtdd1AuC RABjduG/1AsQgrINZ6knBIkAxozroSIKxz6lXhAmAhizm3jmBrkbcph6QaAIYMzu 4e41yNnC1lwDPx4EMGYP/km9AP7bc5R6QagIYMweO069AN57vK96QbAIYMyePEa9 AL5b2LJSPSFYBDBmg3upF8B3PV9WLwgXAYzZ6F3VC+C5Vw5ULwgYAYzZ+K7qBfBb RZt56gkBI4Axm9RJvQB+u/lC9YKQEcCYTV9fvQBem9+qSj0hZAQwZjO5iyFy0Y+r acSJAMaspJV6AXz2Y2v1grARwJjNa65eAJ+ddbd6QdgIYMwWrKNeAI8tbaJeEDgC GLNFTdUL4LGHeSt5vAhgzEobqxfAY+24DGq8CGDMljZSL4C/pndQLwgdAYzZskL1 Avjr9vPUC0JHAGNWVqBeAH9tNlG9IHQEMGblDdUL4C1eA44dAYwZAUTW3tlFvSB4 BDBmBBBZ4ynA2BHAmFXkqxfAW72fUS8IHgGMGQFE1tr/oF4QPAIYs8oG6gXwVYq/ O7EjgDEjgMhWaZF6QfgIYMx4LzCyNaeNekH4CGDMZq+rXgBfTd5YvSB8BDBmXBAV 2Xq7u3pB+AhgzOa2UC+Ar4Ycpl4QPgIYMwKIbA08Wr0gfAQwZlwSH9l67Hj1gvAR wJgtLFYvgK8eOlm9IHwEMGYEENkigPEjgDEjgMjWA6eqF4SPAMaMACJbfAcYPwIY MwKIbBHA+BHAmBFAZItXgeNHAGNGAJGt5w9XLwgfAYze+r/bttsRXAga0agY/OWn /+HCgDEhgBFq8rsdd/jtesVcAAtRq1o0438fvP+fUvWO4BDAaGy5x27btW+sXoHA LZ3+yVujxqpXhIQA5qzFAYfuvD7f9SEpVT+8O+SVeeoVgSCAOcnvddxu66hHwKCF bz3+bKV6RAAIYPY6n3NIR77zg0rV1Bfu+FY9wncEMEtNLjqlg3oDzPv+gRt5YSQX BDArvc7Zhe/94IKqMXc8q97gMQKYufwrz2mm3gCstOCOK3k6MEsEMGM3ncnpLnDL 0rsvVE/wFAHM0MWXN1FPANZSevX16gleIoAZ2WvAeuoJQI1m/HGkeoKHCGAmBh3B 5wuuSg3urZ7gHw7o9HV/gTu8wWXzDhmtnuAbApi2i6/JV08A6lR5Kc8EZoYApmvw 4Xyu4LrUc0eoJ/iFgzo9zT/rpJ4ApGHyNvPVE3xCANOy6Sdc8gB+WLjdRPUEjxDA dGz6KRe2hy8WbUsB00YA00D/4BMKmD4CWL9NP2uqngBkYPE2FDBNBLBeLafy/R/8 sqjjXPUETxDA+uwzqLl6ApCh+b2Hqyf4gQDWZwkXP4B/SovUC/xAAOvxVnf1AiAL o3dTL/ACAaxbv3v4DMFHqTPuU0/wAYd3nQoXFagnAFkpLy5TT/AAAazThM3UC4As fd1FvcADBLAu593C5we+Sl1wm3qC+zjA69B8Nj8Aw1/lbbguQn0IYB3GdVMvAHLw 5RbqBc4jgLXb/yXu/QufVfUcpp7gOgJYu3m8BQR+m89NHOpBAGt1/UV8cuC31I0X qyc4jmO8VmW8AgLflReqFziOANbm9b3VC4CcjeihXuA2AliLooW8AgL/Va2zRD3B aQSwFpM6qRcAEZi8sXqB0whgzXZ+m28AEYKqXd9VT3AZAawZp8AgEJwKUxcCWKOz b+cTgzCkzr1TPcFhHOc1WshtQBCKRdzTunYEsCYXXc/nBaFIXXyjeoK7ONBrMpen TRCOeS3VC9xFAGtwzBN8WhCOVJ+n1BOcxZFeg7FcRQghGbeleoGzCODams3lHECE pKrlAvUEVxHAtd11Bp8VhCR1z1nqCa7iUF9bJd8AIixV+eoFriKAaxnYW70AiNig o9QLHEUA1/IjJw0gNHNbqRc4igCupYIfFxCayobqBY4igGvhKUAEhycBa0EAq3tl f/UCIHKvHKhe4CYCWB0XwkKAuChWzQhgdTwFiADxJGDNCGB1PAWIAPEkYM0IYDUD +qgXADF44o/qBU4igNVMX1+9AIjBD+3VC5xEAKvhdugIErdIrxEBrIanABEkngSs EQFcU/ECPiMIUarZIvUEF3G4r+klzhdFmF7uqV7gIgK4Jq6EgEBxPYSaEMA1lXO+ KMJUwct7NSCAa+I1EASKV0FqQgDXVMUnBGFK8b/tNeB4X8Ozh6sXADF5rpd6gYMI 4BpKeKIYofqxtXqBgwjgGngNBMHivSA1IIBr4DUQBItXQWpAANfAayAIFq+C1IAD fnW3nateAMTm9vPUC9xDAFc3vqt6ARCb8d3UC9xDAFe3sFi9AIjNwmbqBe4hgKvj fiAIGG+GWxsBXB2vgSBgvAqyNo741XQZz6cD4UptPkE9wTkc8at58SD1AiBGQw9W L3AOAVzND+upFwAxmsEdv6ojgKtZ2ki9AIjRssbqBc4hgKvhjXAIGm+GWwsBXKXF j3w2ELJUq3nqCa7hkF/lqKf4bCBkqWMGqie4hkN+lbd3US8AYjVmV/UC1xDAVea2 UC8AYjWPmx5WQwBX4WqoCBzXRK2OAK7CPYEROO4NXB0BXKWM94ojbHwHWB0BXIVL ISBwnAhYHcf8KgQQgSOA1XHMr3TJP/hkIGypy65VT3AMx/xK3BQdwXv2CPUCxxDA lbghCIL31ebqBY4hgCvNa65eAMSMM6GrIYArcUMQBK+Sk/3XRABX4kVgBI/bglTD Qb8SAUTwCGA1HPS/+tt16gVA3FJ/v149wS0E8FcP/km9AIjdQyerF7iFAP5qNJdK Q/hG76Ze4BYC+KsZ7dQLgNhxY7g1EcBflXLHLIRvaRP1ArcQwF/xIjAM4HIIa+Ko /xUBhAEEcE0c9b84/hE+FQhf6oTH1BOcwlH/ixv/ol4AxC9148XqCU4hgL8Y2lO9 AEjA0IPVC5xCAH/BxbBgwvhu6gVOIYC/KOF+WbBgThv1AqcQwF9wSziYUNZIvcAp BPAXnAUDEzgPZg0c9r8ggDCBAK6Bw/5nx/2bzwQsSPUdoJ7gEg77n137d/UCIAmp 6y5VT3AJAfzZ84eqFwCJeK6XeoFLCODPJm6iXgAkYuJm6gUuIYA/m99MvQBIBHfG XB0B/Fk5twuEDeWF6gUuIYA/4ywYGMF5MKvjuP8ZAYQRBHB1HPc/I4AwggCujuN+ hb9fq14AJINbA6+OAK7A1QBhRWroIeoJDiGAK0zeSL0ASMikzuoFDiGAKyxYR70A SMj8FuoFDiGAK3A1QJjBFQFXQwBXqGygXgAkpJKT/lchgCtwFgzM4DyY1XDgr0AA YQYBXA0H/goEEGYQwNVw4C93+t18HmBFqt/96gnu4MBf7s6z1AuApKTuPFc9wR0E cLmRe6oXAIkZ0UO9wB0EcLnp66sXAImZtqF6gTsI4HKljdULgMSUFqkXuIMALseL wDCEl4FX4chfjgDCEAK4Ckf+T865jU8D7Eidc5d6gjM48n9ybz/1AiA5qXvPVE9w BgFc7vptu7VuwqcC4UstnjP+07+rV7iDo36Vvttu1a11Iz4jCFGqdM74Lz57XD3D NRzuazl+2y03b92YTwzCsLx84z59TD3DURzntem7zZb8XAyPVS1ZXr4B6hlu4wCv z5W/79qmmOulwh+Vi2Z99dHV6hV+IIBpOm/rLl2aF6pXALVLlc2b8PXnd6hneIUA ZubY7Tbvum4x1xSHSyoWzp7w5adPqWf4iABm5/htN+/aqiln1EOpclHJhK8+4fWN HBDA3PTZvstm6xbzozESlCpbOOfrCZ88qd4RAgIYkVO277xpy6bcXRPxKV/848Rv P35QPSMoBDBqp2zfaZNWTQv5xCIaqWWLf/x20icPqHeEieM0Nof+vt3GnVoWkUJk IVW2eN6kyTM/GqIeEjiOzgQc8Lv1fkphcWNeM0HdKpYtnDf525n/eUU9xAwCmKye O6zbcaMWxU0K+MTjZ6ny0oXzp0yd88FL6iUWcRzq7L9T69btOxYXFXBaoTUVZaWL pk4vKXn3VfUS6wigI/bt3qJlhw7FTRoV8La7EFWVL1uyeNr0uXPffk09BashgE7a fdfmLZu169C0SaOGPHHopVRVxbLSxd/PnD9v/ttvqsegVgTQC7vvuU7z4nbtixo3 KshvwNfMPamqyvJlpUumz1o0f+Ebb6rXIG0cTJ7aaf+i4mZNW6/fuHFhQX4+X8Yk pSory8uWLv2hZPGCRUuGvaeegxxw5ARkmwOLiouLmrRq17iwsLDhT1nkq5ub1E+p qygrK1s688fSJYsWLXn5M/UiRIxDxIDNezUqalzUpHHLNo0KCwsKGuY3aEAbV0ql qqoqK8rLy8qWzZ67tHTJ0iXLnh2vHoWEcBwYt2Hv/KKixo1/KmOjFusWFBY0/Ok7 xwbLAxnK34zU8sBV/fSdXEV5Wfmcect+6tzSpUuWVA76Tr0MDgjlrzl80Lqef1+S yApgJQIIwCwCCMAsAgjALAIIwCwCCMAsAgjALAIIwCwCCMAsAgjALAIIwCwCCMAs AgjALAIIwCwCCMAsAgjALAIIwCwCCMAsAgjALAIIwCwCCMAsAgjALAIIwCwCCMAs AgjALAIIwCwCCMAsAgjALAIIwCwCCMAsAgjALAIIwCwCCMAsAgjALAIIwCwCCMAs AgjALAIIwCwCCMAsAgjALAIIwCwCCMAsAgjALAIIwCwCCMAsAgjALAIIwCwCCMAs AgjALAIIwCwCCMAsAgjALAIIwCwCCMAsAgjALAIIwCwCCMAsAgjALAIIwCwCCMAs AgjALAIIwCwCCMAsAgjALAIIwCwCCMAsAgjALAIIwCwCCMAsAgjALAIIwCwCCMAs AgjALAIIwCwCCMAsAgjALAIIwCwCCMAsAgjALAIIwCwCCMAsAgjALAIIwCwCCMAs AgjALAIIwCwCCMAsAgjALAIIwCwCCMAsAgjALAIIwCwCCMAsAgjALAIIwCwCCMAs AgjALAIIwCwCCMAsAgjALAIIwCwCCMAsAgjALAIIwCwCCMAsAgjALAIIwCwCCMAs AgjALAIIwCwCCMAsAgjALAIIwCwCCMAsAgjALAIIwCwCCMAsAgjALAIIwCwCCMAs AgjALAIIwCwCCMAsAgjALAIIwCwCCMAsAgjALAIIwKz/DwAPu7XAD5+RAAAAAElF TkSuQmCC"/></symbol><g mask="url(#b)"><g transform="rotate(.193) scale(.36014)"><symbol id="c" viewBox="0 0 1280 1280"><image width="1280" height="1280" xlink:href="data:image/png;base64, iVBORw0KGgoAAAANSUhEUgAABQAAAAUACAIAAACXhmigAAAACXBIWXMAAA7EAAAO xAGVKw4bAAEgIUlEQVR4nOzdd4BU5b3/cbawvU3dmd2NURBbRL1Xo9FITDSJLbnX Fu9VY4t41XiDLfkpokCugoCxYgVir1gApamAShHQqKhEIygQhWXZKTtnZqefmfN7 2Em4XOrszGkz8379sSE453m+u8Ds+ezznO9TNgAAAAAAgBJQZnQBAAAAAADogQAM AAAAACgJBGAAAAAAQEkgAAMAAAAASgIBGAAAAABQEgjAAAAAAICSQAAGAAAAAJQE AjAAAAAAoCQQgAEAAAAAJYEADAAAAAAoCQRgAAAAAEBJIAADAAAAAEoCARgAAAAA UBIIwAAAAACAkkAABgAAAACUBAIwAAAAAKAkEIABAAAAACWBAAwAAAAAKAkEYAAA AABASSAAAwAAAABKAgEYAAAAAFASCMAAAAAAgJJAAAYAAAAAlAQCMAAAAACgJBCA AQAAAAAlgQAMAAAAACgJBGAAAAAAQEkgAAMAAAAASgIBGAAAAABQEgjAAAAAAICS QAAGAAAAAJQEAjAAAAAAoCQQgAEAAAAAJYEADAAAAAAoCQRgAAAAAEBJIAADAAAA AEoCARgAAAAAUBIIwAAAAACAkkAABgAAAACUBAIwAAAAAKAkEIABAAAAACWBAAwA AAAAKAkEYAAAAABASSAAAwAAAABKAgEYAAAAAFASCMAAAAAAgJJAAAYAAAAAlAQC MAAAAACgJBCAAQAAAAAlgQAMAAAAACgJBGAAAAAAQEkgAAMAAAAASgIBGAAAAABQ EgjAAAAAAICSQAAGAAAAAJQEAjAAAAAAoCQQgAEAAAAAJYEADAAAAAAoCQRgAAAA AEBJIAADAAAAAEoCARgAAAAAUBIIwAAAAACAkkAABgAAAACUBAIwAAAAAKAkEIAB AAAAACWBAAwAAAAAKAkEYAAAAABASSAAAwAAAABKAgEYAAAAAFASCMAAAAAAgJJA AAYAAAAAlAQCMAAAAACgJBCAAQAAAAAlgQAMAAAAACgJBGAAAAAAQEkgAAMAAAAA SgIBGAAAAABQEgjAAAAAAICSQAAGAAAAAJQEAjAAAAAAoCQQgAEAAAAAJYEADAAA AAAoCQRgAAAAAEBJIAADAAAAAEoCARgAAAAAUBIIwAAAAACAkkAABgAAAACUBAIw AAAAAKAkEIABAAAAACWBAAwAAAAAKAkEYAAAAABASSAAAwAAAABKAgEYAAAAAFAS CMAAAAAAgJJAAAYAAAAAlAQCMAAAAACgJBCAAQAAAAAlgQAMAAAAACgJBGAAAAAA QEkgAAMAAAAASgIBGAAAAABQEgjAAAAAAICSQAAGAAAAAJQEAjAAAAAAoCQQgAEA AAAAJYEADAAAAAAoCQRgAAAAAEBJIAADAAAAAEoCARgAAAAAUBIIwAAAAACAkkAA BgAAAACUBAIwAAAAAKAkEIABAAAAACWBAAwAAAAAKAkEYAAAAABASSAAAwAAAABK AgEYAAAAAFASCMAAAAAAgJJAAAYAAAAAlAQCMACgGNjttsrKSkUZkE6nPB6v0eUA AAAzIgADAAqey9Xa1NRUV1cnft3bp6tri9FFAQAA0yEAAwAKm0i/zc3NtbW1234n HA6HQiEyMAAA2AEBGABQwPrSb0ttbc0Ovy8ysCQFu7u7DakKAACYEwEYAFCoRPpt aWmpqdkx/WaEwxFJksjAAABgGwIwAKAguVwui6Wlurp6D68hAwMAgO0RgAEAhcfl arVYLHtOvxmRSCQQIAMDAICtCMAAgAKTffrNIAMDAIAMAjAAoJBks/N5Z2RgAAAw gAAMACgguaXfDDIwAAAgAAMACkM+6TeDDAwAQIkjAAMACkD+6TeDDAwAQCkjAAMA zE6t9JtBBgYAoGQRgAEApuZytba0tNTU1Kg4JhkYAIDSRAAGAJiX0+m0WFpqa2tV H5kMDABACSIAAwBMyuVqbWxsqq+v02h8MjAAAKWGAAwAMCObzWqxWBoaGjSdJRyO hELBrq4tms4CAABMggAMADCj9vZ2h8Ouw0ThcDgUCpGBAQAoBQRgAIDpdHS02+16 pN+M3j5kYAAAih4BGABgLu3tIv3aysp0/Q4VCoXC4TAZGACA4kYABgCYSFtbm8Nh 1zn9ZgSDoUiEDAwAQDEjAAMAzMLtdtnt9oqKCqMKCAaDkUiEDAwAQLEiAAMATMHl arVarVVVVcaW4fV6N27cZGwNAABAIwRgAIDx7Ha71Wqpq9PqyN9+IQMDAFCsCMAA AOPp3PZ5r8jAAAAUJQIwAMBguh35mz1FUXw+HxkYAIAiQwAGABjJ7XY5HI7y8nKj C9mRyMBer3fTpk6jCwEAAKohAAMADONytVoslurqaqML2bV0Oi0ycGfnZqMLAQAA 6iAAAwAMM3jwoMbGRqOr2JNUKiUy8ObNXUYXAgAAVEAABgAYw4SP/u5SMpn0+/1k YAAAigABGAAKUm1tbV1dnc/nM7qQHLndLrvdXlFRYXQhWYnH4z09ga4uMjAAAIWN AAwABamjo72qqioWi3d2Fl6XJpvNKtKvyPBGF9IP0WhUZODu7m6jCwEAALkjAANA 4XE4HHa7rbq6Oh6Ph0Ih8dHj8RpdVD+Y7dTfLIXDYfHV7uraYnQhAAAgRwRgACgw NTU1Nptt29Oz6XS6t7c3Go0WykOqbrdbFG/Cc4+yEQwG161bb3QVAAAgRwRgACgk VVVVDofDarVs//SsyMCJRELEYJ/PF43GDCxvr+xb2USGN7qQ3Hm93o0bNxldBQAA yAUBGAAKRm1trcXS0tDQUFdXt/N/TSaTkiTF4wmPx6N/bVkq0M3P21MUxefzkYEB AChEBGAAKBgOh6OpqbG+vn53+4dlWY5uFevp6RH/o3N5e+V2u8SnUKCbn7cnMrDH 4y3E9mMAAJQ4AjAAFIyOjnar1brXAClicCAQMNtSsMvV2tTUtMu160KUSqW8Xm+h PHcNAAAyCMAAUABqaqqtVltjY0OWRweJDBwOR2IxE3XGam9v39a4qzgkk0mfz0dT aAAACggBGAAKgNvtrtuqdvveV3uVOSQpFot7vQYfkmS321tbnQMHDjS2DNXFYrFA IEAGBgCgUBCAAaAA7Lfffg0N9f1KvxmpVCoSiUSj0UBAEr/QorZsFEHvq90Jh8N+ v9/n8xtdCAAA2DsCMACYndvttlotOS+fKooiAnA4HNm0yZjGxW63y+l0lpUV7Xcc j8dr1NcWAAD0S9HejgBAcXA6HY2NjQ0NDfkESJGBE4lEKBRKJJLBoBSLxVWscK+G DNm/vr5en7lkWa6srNRnru1xODAAAAWBAAwA5lVTU2232y0WSw6bn3cpHA5HIhGf z6dbBm5raxMZXp+5Kisqnn32ubPPOVv/DKwoisjAmzZxMBIAAKZGAAYA83K73Tab VcU4l06n4/G4iMHi44C+vbtqjbxLoniHw1FTU6PpLBmyLL/99jt2u/3TTz+94ILz 9c/A4msrMnBn52ad5wUAANkjAAOASYno2NjY0NTUpMXg8T7RaGzzZg0Dm269r1Kp 1IQ77jjt9F9k/u+ypUuvuuqqikp1ls2zJ0K41+vr6jLL0VMAAGAHBGAAMKPa2lqb zdrS0qLdSqYIjeFwJBqNaHRWsJ5HHx115FFTp03b/nfmzpl90003Vei+DhyPx3t6 ejgYCQAAcyIAA4AZtbW5GxsbRQzWdBZFUZLJZDAY1KKBk27Lv9VVVStWvr/z7z/5 +ON33XO3Wo9PZy8SiQQCge5uj87zAgCAvSIAA4DpZDY/iwCsz9FBiURCZGCv1xeL xdQaU3wKra1OHR7ElWV53rz5HR0du/yvd4wf/8KLL5SXl2tdxg5CoV6fzxsISDrP CwAA9owADACm09HR3tzcrM/m4YxkMilJks/nj0ajqgyoz/KvoigXXXjR9TfcsLsX iGB/3XXXffjhX/Q/hZiDkQAAMCECMACYi8PhsFotNTU1Ome2TAbuOy64N88YLKKv y9Wqw/Kv1WJduGjRHl4gPinxuVw+/LI1a9dqXczOyMAAAJgNARgATETkXrvdZrVa 9d+1mxEOR8LhcCAQiEQiOQ+iz/KvCLcL3lrgcruzefHJP/9Zt0fvh3I5HBgAALMh AAOAibS3t2U2P+u/ZXebaDTW29vr9+e4HVq35d/jjvvhHXfckeUxUel0+gc/OEZk Zq2r2nlej8er6VlTAAAgewRgADALER0tlpb6+nqjC9l6lk8oFIrF4l6vt7/X6rP8 O3DgwAULFtbW1mb/pHQ4HD7uuOPKy/X+xifLss/n0+isKQAA0C8EYAAwhYaG+ubm FrvdZuDa7w5EBpakYL8ysKi/tbVV6/ZdqVTq6aeePvyII/p74caNG0899RQdVqd3 kEgk/P6eri4yMAAABjPLbRYAlDin09nc3FxfX2d0If9L5EwR2/x+XzSa7fFI+iz/ HjDkgBenT8/t2pUrVwwfPlz/DCy+hpIU6OraovO8AABgewRgADCe4b2vdkdk4J6e niz3QttsVhHjq6urNS0pmUyuWLGyoaEh5xGmv/ji7eNur6ioULGqbITDkVAoSAYG AMBABGAAMF6m91VVVZXRheyCLMsiufX29nr21kVZfBYOh0PrevrV+2p3xo8bN/2l 6frvNg+FQuFwmAwMAIBRCMAAYDCHwy7iXGNjo9GF7FZmHdjn20tf6AMOGFJXp/EW bkV5d/GSfvW+2p1LL7l41SefqFJUvwSDwUgkQgYGAMAQBGAAMJLIcjabNXP0kdG1 7EkmA3u9vlhs188Du92u1tZWTWtQFGXM6DFnnnWWWgOecvLPt3R3qzVa9rxe78aN m/SfFwAAEIABwEitrVt7X4kYbJ7mz7uTTCYlSdrdOvCgQfvluS15r6qrqlesXKni gOl0+pijvy+nUiqOmSUyMAAAhjD7/RYAFLf29nar1aJ/Q6bc/HMv9I59od1ul9Pp 1DTDi7D64AMPHj9smLrDikg/bNiwigoDeo+RgQEA0B8BGAAM43a7bTar/kfy5ENR FBGAd9gLPWTI/vX19ZrOa7VYFi56W4uR13z55Vlnn2XIFnQyMAAAOiMAA4AxHA57 Y2Oj1tuGtSDLciAQ2LYXWmT4jo4OrZd/n3rq6cMPP1yj8d+YP/8Pf/h9he4/icj8 NIEMDACAbgjAAGCAmppqm83e0mL23le7k9kLnUluOpx+ZLVYFy5apOkUkyffP23a NP3PYSYDAwCgJwIwABjA4bA3Nzc3NDQYXUhevF6vLMuNjY2a7n/Wevk3IxgMXnvt tR999KH+3cjIwAAA6IYADAB6yxx9ZLEUTO+r3UmlUuFwpLGxQdPQ2NLc8vY772g3 fkYymYxGoxdfdNGGv2/Qeq5d4nlgAAB0QAAGAL05nY7m5matu0bpI51Oa7ptWFGU +++7/0cnnKDdFDv48QknSEFJt+m2RwYGAEBrBGAA0FVNTY3dbiuC5V99VJRXLF+x Qs8npZPJ5DHHHKMoad1m3F5mV3lX1xZDZgcAoOgRgAFAV06n02Jpqa2tNbqQwnD2 2eeMGDFC517ZIoWeeOJPjPoJhSQFo9EIGRgAAC0QgAFAPzU11Xa7vaXFUlnJ8u/e pdPpJUuW1tbW6t8re/Xq1eed959GHdEcCoXC4TAZGAAA1RGAAUA/7e1tjY2N1dXV +rcaLkQ/+fGP777nXqNmnzd37o03/j/9DwfOEAFYkoLd3d2GzA4AQLHiDgwA9DN4 8KCGBm17JiuKIj4WQcCWZfmjjz429pzkByZPnjptqv6HA2dEo1FJklgHBgBARQV/ hwQAhcLpdLS2tmr9ZGkqlRo4sCqZTBR6ky0ROz/88KPcrk0kElVVVfnXEAwG//CH P6xcucKoHyjE4/Genh4yMAAAaiEAA4AeMs2f7Xa71hMNHTp0xIhrnn/++TfffMOo R1hV8eADDx73wx/mcGFvb284HB7QF6EdDkc+NWQOB77yiiu++NsX+YyTZw1+v3/z 5i6jCgAAoJgQgAFAc1VVVSL6NjY2aN38OZVKTZ78wEEHHSR+/eqrrz7++OPxeMyo Hbz5yGf/85Yt/2e9tLm5uaamJs96Tjv1lM1dhkVQ8cfq8/k7OzuNKgAAgKJBAAYA zTkc9oaGxoaGek23JctyatCg/aZMmfrP/yvPmTNn6tQp4hfaTaqRY475waRJk3I4 /SgWi0mStMNvVldXt7S05FnSD487LhKN5DlIzhRF8Xp9mzZtMqoAAACKAwEYADTX 2uq02WyqPJW6O+l0WsS8q6767WmnnbbtN0X0/eCD9++++55QKKjd1KpLpVJLly7L 7fQjj8cjvhQ7/355ebndbs/nUd5EInHssT/Y5eD6EBnY5/Nt3EgGBgAgdwRgANBW XV2d1WrR+ulfkXV/9rOfX3PNNTtv9126dOl9990XCPQUSlssm9W2YOHCHC4UEXHP 5wY1NTXlsws9FAwO+9GPjG2wHQwGI5EIbbEAAMgNARgAtNXa6mxpsdTW5vsY6p7V 19dPmTLVZrPt8r8uWLDggQceiEYj5j8eSYTYefPmu93uHK7d1v5qD6qqqiwWS06l bSUC9s9+elK5oT9KSCaTgYCUSm3d2d536JWSkU6nfT6/gYUBAGB+Zr8TAoCCVlNT bbfbReLSdPU1lUqdeupp119//e5eIMvya6+99vjjjyUSCZNnYPG5fPjhR7m1vxLp NHMM8p7luR16w4YNv/zlL0zYYVt87uKrJ/6sUymRhVPxeDzz+Lf4koh0LD6K3yQh AwBKnKlvgwCg0DmdTqvVkn8X4j0Qmec739ln1KhRgwcP3vMrZ82aNWXKoyIUmTkD n3TST0ePHp1D+6sBO/V/3rN8tkN/+umnF1xwvgkz8J5lEvI/pWOx2LZl5L6ErFRU VLC5GgBQ3Mx7DwQAhU7kK5vNqvXyb3l5xcUXX3zGGWdUV1fv9cUrV64cN25cPB4z ZwYW4XzZsvdya38ViURCoVC/LslnO/SHf/nLxZdcnNtKtWml0+m+BeSU+CD+kvxz AVlJb03HitfrNbpAAADyZcYbIAAoDk6ns7m5qa6uTtO0eeyxx15zzbXZH/Pz2muv TZ06JR6Pm/B8YLfLPXfevNyuFfFMJLf+XiW+CA6HI7cZly1deuVVVxbcOnDO/rm/ eqvM/uptzx57vT6jqwMAICsEYADQRObpX5FLNQ1IIopMnTpt33337ddVM2fOfOih B00YgF99dcZ+++2X27X92v+8g+bm5ty2qS9dsuS3v/1tRWVhtNfWjgjDyaTIxnIs FusLxgP6cjHBGABgOgRgANCEw7G191Vtba12y78i/YroKwJwDtd+9tmno0aNSiQS qleVs5Qsf/rZ6tyuFZ9IT09PPrNXV1dnv4q+vYULF1537bVk4F3qC8ZJ8XHbinE6 rXg8HqPrAgCULgIwAGiitdUpaPf0b6Zl0dVX//fpp5+e2+UrVqy48847w+FekzwP PHBg1bJly3J7qlaSpFgslmcBOW+HLrW90HlKpVKJhEjFyUwqFpG4b62YB4wBAHow xU0PABSZ2toam81mt9u1m0Ikh6OPPnrUqFvq6+tzHmH27NlTpkxJp/v96KwWjjv2 uDsmTNCh//OetbS0ZNNObAdk4HwoiiL+NopUHI1G/rlQnPZ4iMQAAPURgAFAfa2t TpGjcj5lJ0u33z7uqKOOymeERCIxf/78qVOnJJNJtarK2Z2T7jzhxz/OYQVY5KXu 7m4VK6mpqWlubu7vVR/+5S+XXHoJGVgtfZE4EQ5HUqnMKnGKJ4oBAPkjAAOA+jo6 2q1Wq3ZdplKp1NChQ++++x5VRps5c+af/zzN2L7QIu18lusDwDkcgLRXuW2HLtDz gQuCoiiJrZLxeCyZTPIsMQAgNwRgAFCZCE4WS0tdXZ12U1RUVNxwww0nnniSWgPO nTv34YcfEvHCqOeBnQ7H7Dlzc3sA2OfzZU6sVV0O3aG/+mrtWWedpenJz8jI9NaK RqPJpJxOp9gyDQDIBgEYAFTW2uq02WxVVVUajZ9Op48++phbbrklt5N7dklE3xf6 pFKyIRn44osv+c1vfmP4A8A7E3+OFoulX5ds3Ljx9NNPM+EpU8UtmUzG44lYLNp3 IFOKrloAgF0iAAOAyjo62kVk0m4NUATUW28dfdxxx6k+8rRp06ZPn15erve3hpQs L132Xm1tbQ4rwLIs+3zaPhoqvuA2m61ff6A9fv+JJ500YICiXVXYg8x+aZGHt36I J5LJRCAgGV0UAMAUCMAAoCaHw261WmtqajRaR02lUt/73vfGjv1jbofW7tVbb715 111365zcRIj96KOPc9v/HAwGo9Go6iXtrL6+vqGhIfvXx2KxE370o0TSRCctlyxZ TsXjsb7N0knxa61/YgIAMDMCMACoyel0ut0u7XYRl5eX/9d/XfHLX/5SuxXmWbNm ZfpC67YX+qSTTho9ekxu+5+7u7sVRae4Lr7m/TraKp1On/zzn3t97MU1EfGHEovF IpGI+BueSnH+MACUHAIwAKimtrbWZrNqevzv0KFDb7zxJk2nEJ544vFnn31Wn05O KVl+d8nShvr63FaANX0AeJcaGxv71eHsrDPPWLd+vVHdxbAH24fhvr30fqMrAgBo ju/HAKAap9PR2Eej8VOp1OjRY4YNG6bR+NvMnv365MmT9cls5577H1dffXVuy7/R aDQYDKpe0l5VVlbabLYsXywqHDFixMcff0RbLDMT/7iiURGHo/F4ggOWAKCIEYAB QDVOp9Nu16r/s6IoAwcOnD17jhaDby+dTp922qlaz5IhkuTChYtya381QMsDkLKR 5VJwMpkUQf3RRx55+pmnOR6pIMTj8WAwJMs8MAwARYgADACq6eho125zskh6w4YN GzNmrEbjbzNp0qRFixZqPcuAvkh/7z33/vgnP8l5BP33P++gX08Fv/LKy2PHjhWZ X9OSoKJ0Oh2NxqLRCMvCAFA0CMAAoA6bzdrc3JzbVt5slJdXiGh66KGHajR+xqZN my655GJ9FiqtFsvCRW/nfHk8Hg8EAirWk7O6uros972vXLli+PDhZOBCFIvFent7 E4lEeXl5V5fBP3kBAOSMAAwA6nA6HRaLpba2VqPxhwwZMnnyAxoNvs155/1nT0+P 1rMM6DuZZuaMGYP33z/nEUSdIo2oWFI+ysrKmpqaampq9vrKb7/55pf/9kt6YhWu ZDIpSZL4mE6nPR6aSANAgeEbMACow+VqtdlsuT3LuleyLF988cUXXniRFoNv8+yz zz711JP6ZLMh++8//aWX8xnB8P3PO6uoqLBarXttdhUOh3/y4xOSxj29DFWkUqlw OBKPx+LxBMcpAUChIAADgDo6OtotFotGm4dramrGjv3jEUccocXgGd3d3eeff54+ u3NFnl+58v1+HSa0g2Qy6feb9NCagQMHihi859ek0+nTTzu1y3wZHjkQf58zSTgS iQQCktHlAAD2hAAMACqw2+3NzU319fVaHHWjKMqxxx57ww2/1+6AJeFXvzonFApp N/72fnrSSXf+6a58RggEAvF4XK16tFBVVdXS0rLn5fTLfvObDz/6kO3QRSOzO5rn hAHAzPimCwAqcDgcLS3NIgBrMXgqlRo3bvzRRx+txeAZ48ePX7z4Xe3G357I86tW fZLnICbc/7xLlZWVzc3Ne1hX/9Oddz751FOVlRyPVFREBg4Gg+Jjdze9owHAXAjA AKACp9NpsbRo1wHrtdde1+h4YeHNN9/805/u1GLtemci/d488uZz/+M/8hnEPP2f s1RWVlbfZ5f/9bVZs0bdMorW0MVH/G2PbBUVf2N5SBgATIIADAAqaG11OhwOLTKM uIf+znf2mTZtmuojZ6xZs+bqq3+rz7lHA7aeGFS/bNmyPAfx+/3JZFKVenQmvs51 fXb4/dWrV59//nm6/SlAZ7Kc6unpEX9pu7u7ja4FAEodARgAVNDa2up2u7QYWdw6 n3feeZdddpkWg4vb8Qsv/LVuz6CmZHnmzFmDBg/Oc5xC2f+8B+Xl5TV9trUN7/H7 TzzpRGOrgtYyhwnHYiwIA4BhCMAAkK+6ujqr1WK327UYPJ1OT5v253322Uf1kf1+ /wUXnK8oiuoj786R//qv0/78WJ6DRCIR3Zp16UOE4aqqKpGEv1q7duzYMaGteuPx mJxKD1DS5RUV+uxOh25SqZTfv/UUa4+HJ4QBQG8EYADIl8PhaGxsbGrSpEXzwIFV r7/+uurD+v2+X//61yJdqz7y7oi5Pv54Vf5Zrru7W8/QrrOysrLMZye+UBV9fF7v qk8/3bRxY6+Ixb0hEZkCfYLBUCKZkGVZvF5cxfbpQhSJRMLhSCIR93hYEAYAnRCA ASBfTqejubm5rq5O9b3EqVTqgAMOuPfe+7ZtlFXF3/72txEjfqfnuqIIaePHjTvt 9F/kOY7Iez6fT5WSCkUymQxHIuIX9XV1u/tr4PF6//rXvwYlSerp6erq8vm8ASkY CPSIxCwnk6m+H3OIhMx5S+aUOTwpHmdBGAD0wPdCAMiXCMAWi0WLFtAi75188skj RlxTXV2t1pgLFiyYOHGCzguG+31331dnzsx/nMJtf6WpTEjeQ0IWNm7cuGLlynAo JLKW1+vx95GkYCKZVJR0eR89a8YO0ul0b6/4Y4x0dXUZXQsAFDMCMADky+GwOxwO LY4pEvfE559/wa9//Wu1+kvffvttixcv1jnqiBj/l798qEqGL4L2V0bZc0gWX9j3 P/igx+cTqbira7PH4+np6YlEY+LPboCSrqisZPVYH4qihLem4HBn52ajawGA4sT3 MwDIl3MrTc5ASqVSI0fefOKJKjQH3rBhw+WXD9f/SVFxQ3/rrbeeffY5+Q8VCoUi fZuBobo9x+OgJH366adff/31t99807Wly+v1SlIwKSfFXURlJc8eayIajfb29obD 4UBAMroWACgqBGAAyJfL1Wq32zUKwI8+OmXQoEF5jjNhwoRFixYassf1u/vsM3PW a6oMxfKv2Xi83lUff9y9ZcvmzZs3bvxW/AEFAoGkLNOUSy3xeDwUCokw7PP5ja4F AIoEARgA8tUXgB1aLIUNHDjwiSeetNlsOY+wePHi8ePHDxhgTNtkWZY/+eRTVYJ3 ZjUs/3Ggot2tG4tgvGzZsq7Ozq7Nm//+7TcejycWi5GKc5bpkkUMBgBVEIABIF+t rU632636sIqiWK3Wu+++J7fB16xZM3bsGJ/PZ9TTm6L+Rx5+5AfHHqvKaCz/FpBd BuNMKt74zTednZu+/Xaj1+dNJBKVPF2cNWIwAKiC7zoAkC+Xq9Xlcqk+rAiQzc3N 06b9uampqV8XfvPNN+PHj1u3bp2xfX0POeSQhx9+pL/F71IkEgmFQvmPAwPtnIoD kiT+lv71s8/+vmHD1+u+3tLtSSTi9KPes0QiEQwG43GODgaAHBGAASBfIgA7nU7V 79pFAK6pqZ01a1b2l3z11Vd/+tOfvv76K8P3mippZfGSJbW1taqcYMzyb1HaZSRe v2HDpx9//NXatevWr/N4fel0Soun6wsdMRgAckYABoB8iQDscDhUz5zpdLqj4zuP PfZYNi9evnz5fffd6/f7zbB6lkqlli5dpsraryBu9KPRqCpDweR2jsQer/fdd99d ++WX69et29i5SUQ+VX6kUhxEDJYkSfxz6+riJ0QAkC0CMADkS6Mt0LKcOuyww267 7bb6+vrdvUaE5Gefffall6aLYGCSZykVRbn+uusvuvhitQZk+beU7RCJMw8Sf756 9Vdfre3c3CUnk5UDS319OBqNBoOhzZs5NxgAsmKKuyUAKGitrSIAt6qeP0WS/N73 Dr3jjjuqq6t3/q9+v3/y5PtFGDDDku/2hgwZMn36S2qNJj5NEYHUGg2Fboc8LP7v BytXLnp70V//+leRjSsqKkzyYyCdifeKvi7p4a6uLqNrAQCzK8XvEwCgLhGAnU71 t0ALRx555Lhx43f4TRF6//znP3/77TeGP+i7M3EjvmrVJ2qNJsuyz+dTazQUt4Ak fblmzYqlS0UY/mbjxpScrCixh4fT6bTf74/F4l4vDwYDwG4RgAEgXxo9AyzC5FFH HXXzzaMyW6DFre1DDz20dOkSdWdRUSqVeuedd61Wq1oDejwecU+v1mgobjssDsdj sfnz5i1YuHDd+nWJeLx0wrAspwKBHvpjAcDuEIABIF+tW6nfBVoYNGjQmDFjFy9e /PLLL4kAbMIl321EUn3ggQeHDRum1oD0voJaxF+keXPnLFq0aN269YlkohTaSosA LElSZycPBgPAjgjAAJAvl2trAtbi4cPy8opkMmHm3JuhKMrll//X1VdfrdaAbH6G RkQYfvWVVxYtWvjtt9+WlZcX8TPDfQ8G9/Y9GEwbOQD4X0X7vg8AuhHp1+1Wvwt0 ATn+h8dPfuABFQfs7u4Wt+8qDgjsICBJn3zyydzZs//25d9ESizWZeFUKtXT08OD wQCwDQEYAPKl3QpwQdh3331nzJip4oCSJMViMRUHBHa2/TPD8VhszpzZc+bM+fs3 31ZUFOGysPgHFQwG2RENAAMIwACQPxGA7XZ7sa4g7VlDQ8O77y5W8fnneDweCATU Gg3ol4Akvfvuu/PmzF63foNIwcWUhBVFCYV6IxF2RAModcXzzg4ARtGuCZbJVVdX L126TMXkL+7Ru7u71RoN6K9ty8Li46efffbajBmff/GFLCeL5l+3+AQDAWnTpk1G FwIAhiEAA0C+SnMFeODAqqVLl1ZVVak4Jo/+wiS2T8IiA7/y0vS/rv5rWkkXRxIO hTLNsbqMLgQADEAABoB8tba22mxWdaOgyam+9iv4fD5ZllUcEMjf9kl41apVr7z0 0pdr1hTB7mjxb62nJ8BSMIASVNhv3wBgBk6ns6mpqaGh3uhCdNLe3jF79mx1x+TU X5jc9kl4xYoVr7780rr16wt930dvb7i3N8RTwQBKCgEYAPJVU1NjsbS0trYaXYjm FEU56sgjp/35MXWHDYfFXXivumMCGtmWhMWvZ82Y8dLLL/n8/sJNwqlUyu/vYSkY QOkgAAOAOo444nCjS9CWSL///u9n/PGPf1R32Gg0GgwG1R0T0E1AktZv2PDi88+t WrVK/Bsp0K3RvVvxVDCAklCQb9MAYELFHYBTqdTIm0aed/756g7LoUcodNtvjV62 bJlIwp2bNxfigrD4RHp6Ap2dnUYXAgDaIgADgDqKOACLO+N58+Z/5zvfUX1Yv9+v 7piAUbYl4Xgs9qc//Wn58vfKCq1ltKIoPp8vHo97PF6jawEArRCAAUAdxRqAKyoq 3n//A9VPf5FlWdxqqzsmYB4iD8+dM+eZZ54JSAHxj8jocvohFosFAhLboQEUKwIw AKij+AKwoigHH3jQ8y++qPrIiUSip6dH9WEBswlI0urVq5964vHCahmdTqf9fv/G jXTGAlCECMAAoI4iC8CyLI8ZPeacX/1K9ZFjsZgkSaoPC5jQ9vuiJ0yYsPL9lQW0 GhwK9YbDvRySBKDIEIABQB3FFIDLy8vnzp2nxcFOkUgkFAqpPixQEEQefmDy5Plv zC+UZtGZNnWbN7MdGkDxKIz3XwAwv+IIwOl0euihhz7z7HNaDC6irwjAWowMFBAR g199+eWnn3k6KcvmT8JshwZQZMz+tgsAhWLw4MGNjQ1GV5GXVCo1ccLEU087TYvB e3p6EomEFiMDhSggSXNmz37u2WflVAHE4GAwGIlE2A4NoAiY/Q0XAAqFy9XqdDpV 75asj3Q6PWi/QdNfemngwIFajO/1ekW61mJkoEBlHg8W//Ref/21F194QfwDMXkM jkajkiSRgQEUOlO/1QJAYTnssKGFGIBlWR47duzZZ5+jxeCKong8HvFRi8GBQrd9 DH7h+efFL8wcg8V7hd/v7+zcbHQhAJA7877JAkDBGTr00AJq8Tqg73b26O9/f8rU aRqVTcNnIBvbYvCMGTNenj49rZg3BiuK4vP5eCQYQOEy6dsrABSigw8+qLq62ugq siJutV2trU88+ZTb7dZoChF9RQDWaHCg+GyLwY8/9tj8+fPM/NM0HgkGULgIwACg mgMPPKC2ttboKvZCUZSBlZW33z7u5FNO0W4Wj8cj7uO1Gx8oVpkYXFleftdddy1e slijx/LzJwKwiMFkYAAFhwAMAKo54IAhdXV1RlexWyL6VldXjxk9+rTTf6HdLJmD Q7UbHygdQUkaOXLkl2u+rKysNLqWXUgkEj09PZwSDKCwEIABQDWm3QKdTqfr6+pu u+32k376U00nEtFXBGBNpwBKSkCSPv3ss4cm3+/v6TFhj71UKuXz+Ts7O40uBACy RQAGAHU4HI62NrfZWtfIsrz/4P3H33HHwQcfrPVEfr+fbs+AurZvE/3M089UVJgu A4t/9V6vb9Mm2mIBKAzmulEDgMLV0dFut9uNruIfxC1peVn5ySf//H9uu12HZwiD wWA0GtV6FqBkZWJw1cCB48eNW7FyhQl3RHu9XlmWeSQYgPkRgAFAHYMHD2psbDS2 BpF70+n0IQcfPPLmUYcffrgOM7LwC+gpIEmff/HFfXffJX5htv0moVAoHA6TgQGY nLneOgGgQLW0NHd0dBi1LCPyZyqV2n/w/jfccMPxw4bpNi9P/AI62/7E4Beef85s RyWJACxJwe7ubqMLAYDdIgADgAqcTmdbm1YH6u6OCL1VA6sOP/zwG37/+0MOOUTP qUXulSSJhV/AENuOSho1atTnX3xuqhgcjUbFmwPrwABMiwAMACrQ7QHgdDpdVlbm druP/NcjR1xzjQjeOky6A7/fL+6/9Z8XwA4CkvT2228//NCDpmoQHY/He3oCXV0c jwTAjAjAAKACTU8AzuxwFqH3iCOOGDHimo6ODpE/o9FobW2tDg2uttfb2xsOh/Wc EcAebGuONfrWW1d98kllpVmWgkVhfr+fI4IBmBABGADy5XDY29raNGpII9LvtKnT jvr+940KvRmJRCIQCLDnGTCngCQtWbLkgcn3m6czlizLPp/IwJuNLgQA/g+zvEsC QOFqb28XGVijwcVN5GefrdZo8GyI0Ov3+0UZBtYAYM+2LQXfdtttH3zwvknOSUql Uj6fr7OTDAzARAjAAJAvTQ9Aslos899405BV3wH0eQYKTUCS3n33nQcmP1BRYYqn gvsysL+zs9PoQgDgHwjAAJAXm83qdru1W2/5yU9OHDt2bFNTk0bj7w6P+wKFaFuD 6D/84Q9fr/vaDM2x0um01+sjAwMwCQIwAORF0wOQxI3jnDlzW1tb9VwBjkajwWBQ t+kAaCEgSdNffHH6iy9UGrR/ZHvirczn823aRAYGYDwCMADkResDkD7+eJV2g++A 032BopFMJqVQ6Kuvvhp32/+Y4dwy8cbi9XrJwAAMRwAGgLwcdNCBNTU1Gg2+3777 vjj9JR2WfxOJhIi+6XRa64kA6GZbZ6zx48atfH9lRYXBhySRgQGYAQEYAHLncDja 29u0G//SS39zySWXaPoA8NZlIklKpVLaTQHAWAFJmv36648//phR7fS2IQMDMBwB GAByp+n+ZxFN33tvuXYH/8qyHAgEiL5A0ctsh/76669vGztWThl8pBk9sQAYiwAM ALk78MADREDVaPCG+oZFb7+tRfol+gKlZtt26FE3j/zr558b2x2aDAzAQARgAMiR w+Foa3OXlWn1Rnr88cPGjRun7v5nnvUFSlxAkh577LG5c2Zrd3hbNlKplMjAmzdv NrAGAKWJAAwAOdJ0/7O4O5w7d56KByDF4/FgMEj0BUpcZjv0yhXL77n7nspKI9ti 9WVg7+bNXQbWAKAEEYABIEdDhgypr6/TaPCysrKPPvpYlaFisZiIvhxuBCAjk4G/ +eab0bfcIstGnpAky7LP5yMDA9ATARgAcuFw2Nva2rTb/3z4YYc/8eSTeQ4SiUR6 e3uJvgB2sO2R4Buuu27dhvXavZVlU4nIwF1dW4wqAECpIQADQC7a29tFBtZocBFZ n3zyqcMPPzznEcLhsIi+KpYEoFhNmjTxrbfeMvCU4Hg83tPTQwYGoA8CMADkQtP9 z7Kc+uyzz3K7NhQKRSIRdesBUMQCkvTC88+//PJLBrbFikajPT2B7u5uowoAUDoI wADQb1r3f3a1ul57/fX+tr8KBALxeFyjkgAUq8wjwcuWLrn/vvs0OnU8G+FwOBQK sQ4MQGsEYADoN037PwsXXnjR8OHDszwAKZVKSZIkbmG1qwdAcctk4C+//PJ/xo4x 8HngYDAUiYTJwAA0RQAGgH478MADamtrNRpcTiaXvbdcjJ/lUsyWLdwsAshXpi1W WpYvvfTSeMKwvSRer3fjxk1GzQ6gFBCAAaB/tO7/bLVY57/xRpbpl2ZXANQVj8Uu v3x4t8djyOyKoni9vk2byMAAtEIABoD+0Xr/85lnnnXttddmuf/Z4/Gk02ntigFQ gpLJ5PXXXbdm7RpDtkOLDOzxeDs7O/WfGkApIAADQD+4XK0Wi6W6ulqj8WVZXrJk aX19fTYrwGx+BqCdW2655YMP3jckA6dSKa/Xu3lzl/5TAyh6BGAA6Ie2NrfT6dRu /KbGxgULF/H0LwAzmDhhwsJFC8vLy/WfOpFI+P09XV1kYAAqIwADQD8MGjSoqalR u/FPPvnkm28eleX+ZwIwAK098MADs2bNrKio0H/qSCQaDEo0hQagLgIwAGTLbre7 3S7tbgRlWV68eElDQwMrwABMIiBJU6dOffON+YZk4GAwtG7dOv3nBVDECMAAkC2t 21+1NDe/+daCLNNvLBaTJEm7Yvrr22+/Xbp06XnnnWd0IQDUlDki+MnHH58/f54h GZiDkQCoiwAMANnS9Phf4ZxzfvW73/0uy/3PPp9PlmXtiumXtWvXPvTQQ2vWrDn9 9NN/+9vfGl0OADVlMvBzzzzz+uuv6Z+BaQoNQF0EYADIitPpaGtr0258OZlc9t5y EbALbv+zx+M5//zzQqFQWVlZZWXlQw89PHToUKOLAqAmYzMwTaEBqIgADABZ0Xr/ s9PhnD1nTsHtf37kkYeffvoZcXuaOSolnU5bLJb5898wui4AKstk4GeeemrOnNn6 Z+B4PN7T00NDLAD5IwADwN45HA6Xq1XTe77hwy+/8MILC2v/84gRI95//33xi+0P Ck2l0ieccMKdd95pWFkAtJHJwI8/9pghPbF6+5CBAeSJAAwAe6f18q8sp5YtW1ZA +5+9Xu911123du3asl19G1EU5eWXX+no6NC9LgDaEhk4HIm88Nxzr854Vf/zgWmI BSB/BGAA2AuXq9VisVRXV2s3xZD995/+0stZvtjw/c+rVq2666671qz5cne3v4oy QHy5Hnnk4YMPPkTn2gDo49577pk7b67OGZiGWADyRwAGgL1ob29zOBzajZ9Op198 8cWDDjo4y9d7vd5UKqVdPXv2+uuvP/zwQz09PXt+mbhPPfzwIx599FF9qgKgv9tu u23p0iVlu9wHohlZlsV7IBuhAeSMAAwAezFkyP719fXajV9eVrZi5ftZbn4eYOj+ 56lTpz7xxBPpdFbxW2TgSy659Morr9S6KgBGuenGGz9e9bHOGTgajYoM7PP59ZwU QNEgAAPAnrjdLqfTqent3THH/GDSpElZtr+KRCKhUEi7YvZg9OjRb775xtaOV1l/ McrLy6+44sqLLrpIy7oAGOmqK69Yv2GDzpN6PN5Nm3gYGEAuCMAAsCeDBu2XZTTN jSzL77zzrpgiyxVgj8eTTqe1q2eXurq6Jk6cuHz5ezn8IKC+vmHs2LHHH3+8FoUB MFwymbzk4ot8fr3XY8nAAHJDAAaA3XI47G63W9MuL21u95y587J/vf77n7/44ot7 7rnnk09W5fZ1EHG9tdX12GOPadpGG4CBotHof5z7q0QyqeekqVRKZOCuri49JwVQ BAjAALBbWp9+pCjK/ffd/6MTTsjy9b29veFwWLt6dtbZ2XnppZdKUqCsrExRBvR3 AThzicjAJ5300/Hjx2tTIwDj+bze884/T+em0DwMDCAHBGAA2DURfd1uV0VFhXZT iAC8atUn2b++u7tbXKJdPTtYvHjxLbfckkwm8h8qnVYuv/zy4cOH5z8UABMKSNLq 1avHjL41+35+quBkYAD9RQAGgF3TevlXOO7Y4x586KEsX5xOpz0ej6b1bG/ChAmz Zs0SIV2V0URsr6qqGjdu3LBhw1QZEICpJJNJKRRatnTJ5Pvvr6ys1G1eRVFEBt60 iZOBAWSLAAwAu2C321wul6a3cbIsv//+B7W1tVm+PhgMRqNR7erZ3k033bRkyWLV u20NGXLApEmTxBdW3WEBmEEmA7/y8ksvv/SSpntndsDJwAD6hQAMALugw/Lvdzo6 Xnt9dvav16f91RdffD5r1mszZswoL1f/G4SiDPjBD35w7733qj4yADMQGTgciTzx 5z/Pe2O+nocDh8PhUChEBgaQDQIwAOzI4bC3troqKzVcwUin088//8IhhxyS5esT iURPT4929WTMnz//oYce6u7eot2dq8jAp5566pgxYzQaH4AZjPjdf69Zu1bPGXkY GECWCMAAsCMdln8rKiqWL1+RfbcYv9+f1PiIkXnz5k2cODEWi2m9bFNdXTNy5MiT Tz5Z22kAGEe8X11w/vnBUFC3GTNdEjZv5lQkAHtBAAaA/8PhcLjdLq0P8/jlL3/5 +9//oampKcvXa73/+emnn3744YfT6ZQOuxYVRTnyyKMefPBBrScCYKAev//c/zhX z4eB4/G4x+MVdJsRQCEiAAPA/9He3u5waLv8K8vysmXv1dbWZrkCHIlEQqGQdvXc csstixYtTKcV3R7ZE3MdfPDBTzzxhE7zAdBdQJI++uij8eNu17MpNBuhAewVARgA /pfb7XI6nVqvgh591PcfnTo1+9d7PB7VGzJvc9NNNy1e/K6exwtniAmvuOKKSy+9 VOd5Aegj0xR6xiuvTJ/+om7rwOKtzOPxdnZyKhKA3SIAA8D/Gjx4UGNjo6ZT9Pf0 I+2O//X7/XfccceSJYv1bNa6TeZk4KlTpx544IH6zw5AB5mm0Pfdc897y9/T7X0m kUiINzc6QgPYHQIwAPyD2+12Oh1a36UddOCBz7/wYvav1+j4X5/Pd/vtty/X8a50 l9zutilTpmjdcgyAsS789a89Xk1+kLdLwWBo3bp1uk0HoLAQgAFgK5ertbm5OfuF 2dyk5NQ7775rtVqzv0SL9lci/V533XVffvk3rXt97ZWiKD/84fF33XWXsWUA0JQk Seecc05FhX5vOB6PZ9MmNkID2AUCMABspcPRR8J399ln5qzXsn99PB4PBALq1vD3 v//9qquuEhm4vNwk3wLKLrvssuHDhxtdBgCtBCRp5cqVd06aqFtDrGQyKd7l2AgN YGcmufsBACM5HHan05n9qby5SaVSs2fP2WeffbK/xOv1iqtUrOHzzz8fNWpUZ+cm w9d+t1dbW3vLLbeceOJJRhcCQBOZhlhPPv74G2/M1+3Nh43QAHaJAAwAehx9JLQ6 nfPfeDP71yuK0t3drWIB3377rUi/a9Z8aexzv7vU2Nj06KOP7rfffkYXAkATmYZY o0aO/Hrd17pNykZoADsz3T0QAOhMn95X6XT6+edfOOSQQ7K/RPX2V9dee+2KFctN mH4HbF0eTx900EFPPfWU0YUA0FAkEjnrrLMGDNDp3DU2QgPYmRlvgwBAN3a73Waz 1dbWaD2RpcWy6O23+3WJuu2vTj/9NI/Hq2cTmv5SFOWMM8686aabjC4EgFYCkvTJ J5/c9j9/1O1h4GAwuG7den3mAlAQCMAASpo+va9SqdQLL7zYr+XfWCwmSZJaBYwY MWLlyhWmeu53lxRlwPjx43gYGChWmYeBn3vmmdmzX9fnHUlRFI/H29nJRmgA/0AA BlC6XC6X0+nQ4SbM7XLNnTe/X5d4PJ50Oq3K7H/84x/nzp1rmp7PeyI+ZZfLPWvW LKMLAaCVzMPAI2+8cf0GnRZmE4mEZyuvPtMBMLkCuB8CAC20tDQ7nc66ujqtJ5Jl ec6cuf1q/ixyoLhZU2X2SZMmzZw5U1HUydL6ePTRKYcddpjRVQDQUG8odPY5Z+vW ksDr9W7cuEmfuQCYHAEYQInSZ/OzMGi//V55dUa/LgkEAvF4PP+pn3766QcffNCU Ta92S1EGnHbaaaNHjza6EAAaypwMPGniBK3Pn8voa6rv2bx5sw5zATC5grotAgCV uN0ukX4rKiq0nkiW5SWLl7RYLP26Sq32Vz/84Q9TKdmcbZ93RwTghob6BQsWGl0I AA1lNkI/Nm3aG2++oc97VDQa83o9Pp9fh7kAmFkh3RUBgCocDrvVaq2trdVhrqHf O/SpZ57p1yW9vb3hcDjPeSVJGj9+/LvvvltQ4fcf0un07beP+9nPfmZ0IQC0JWLw eef9p3jT02c6NkIDGEAABlCCdNv8LO7tPvjgL/1N2qos/957770vvPB8Ya39bu/f //0MzkMCil5Akr766qubbvx/+pyKlEqlPB4PxwIDJa5Q740AIDdtbW6Hw6FPMjxh 2I/uvf/+fl2iyulHS5YsGT36VjFUnuMYaMiQA+6++259fk4BwCiZU5Gmv/jCzBkz 9DkVKRTq/frrr3WYCIBpEYABlBCXq9Vms+nTcyWdSn3y6Wf9vUqV048uvPDCNWvW FMS5R7ukKAPq6moXLXrb6EIAaC7zMPDvr79u4yadNid3d3s4FhgoZYV6ewQA/dXS 0uxwOOrr63WYS1GUG66/4cKLLurXVbIs+3y+PKd+7733rr/+usLd/DygLwALs2fP ZgUYKBGSJJ1z9lkVumyE5lhgoMQV8B0SAPSLbo/+CtXVNStWrOjvVX6/P5lM5jn1 Nddcs3LlykLOv1ul0+m5c+fZbDajCwGgh4AkzZ075/HHHtOhOf8AumEBpa3Ab5EA IDttbW0Oh12fddFUKvXcc88feuih/bqq75jK7jynXrVq1YgRI5LJRJ7jmMHy5f3+ CQKAApXZCH3LzSO/0uUB3XQ67fF4Nm/u0mEuAGZDAAZQ/Fwul91u06fLqHDIwQc/ +9zz/b2qp6cnkcg3uM6YMWPChDv06SWjKUUZMHHixBNOOMHoQgDopzcUOvOsM/VZ BA6Hw2vXfqXDRADMhgAMoMg5nU6r1VJTU6PPdLKc+uijj3Los6XK6UdnnnlmV9fm /McxXDqdfuihh4888kijCwGgH503Qns8nk2b6IYFlBwCMIBi1tLSbLfbGxoa9JlO UZQRI675zW9+098LJUnK/9Sit9566447xkej0TzHMYN0Wlm5cqXRVQDQVWYj9M03 3bRu/TodpkskEt3dHq+XblhAaSEAAyhmeja+EqwW68JFi3K4UJXl37vuuuvVV1/J /xQlcyhbvny50TUAMEAwGDzrrLMqK+mGBUATBGAARau9vd3h0C/9yrK8YMHC1tbW /l4o7vZUWba94oorPvlkVUEfgJShKAMOO+ywKVOmGF0IAAMEJGnmzJnPPfuMDu0M UqmUx+Pp6lLhR5AACkXB3ycBwC61t7fZ7Tq1fc449eRTxk+YkMOFqiz/Cmedddam TZvKywv+jV1RlH/7t3+/+eabjS4EgAGSyWSot/ea3/23R5fNyaFQ6Ouv9dhxDcAk Cv4+CQB25na77XabPm1UMqoGVq18//0cLuzt7Q2Hw/kXsGHDhquvvtrr9RRBC+iB A6tGjBhxzjnnGF0IAGMEJGn9hg2/v/66HBoK9peiKB6Pp7OzGNoHAsgGARhAsXG7 XVarVYfbpm1kWZ41c9agwYNzuFat5d9PP/305ptHer3eItgCvf/+QyZOnNjW1mZ0 IQCMkUwmpVDoqSeffGP+PB3e02KxWFdXVyAgaT0RADMo+PskANiey9Uq0m9VVZWe k55y8sl3TJiYw4WhUCgSiahSw8cffzx27NgtW7oKPQAryoALLrjgd7/7ndGFADBS ZiP05ZddFo6osEdmr+iGBZSOwr5PAoDtifRrsViqq6v1nLSmumb5ihW5XavW8u+A vi3QY8aM+fLLLws6/yqK0tjY+NZbC4wuBIDxApK0evXqsWNGV1ZWaj2XyNviDdnr 9Wk9EQDDFfKNEgBsR6Tf5ubm2tpaPSeVZXnevPkdHR05XKtW8+eMv//975MnT166 dGlBB+B0Wrn00kuuvPIqowsBYLzMscB33XnnB3/5QIfpWAQGSkQh3ygBwD8Zkn4V RbnqyquuuPLK3C5XcflX6Onpefjhh19//TUVx9RZOp0eMuSAZ555xuhCAJhIJBI5 88wzdHi4Q7wFdXd3cyQSUPQIwAAKniHpV/hOe8drs2fndm0gEIjH4+rW8+KLL957 7z3qjqmnxsbGW28dPWzYMKMLAWAiAUl68403pk2bqkOLe45EAkoBARhAYTMq/aZS 6Q8//DDnXtPqLv9mbN68+Ywztq6TFOIuaEUZMH78uBNPPMnoQgCYS6Yb1rUjRnR7 urWeS1GU7m6PeC/VeiIABirAuyQA+CeRfltaWmpqanSeNyXLjz32+FHf/35ul/f0 9CQSCXVLGtDXB+uyyy4Lh8MFF4DFTef5518wYsQIowsBYEYBSVq3bt0ffn+DDufb hcORtWvXaj0LAAMV2l0SAPyTIT2fB/SltXN/de7No0bldnkqlfJ6veqWtM211167 cmWOLamNUl5efsopp956661GFwLApDLdsB595OG3335bh+k8Hs+mTZ06TATAEARg AAXJ7XaJ9Kvzeb8ZbW73nLnzcr5cpF+RgVWsZ3uvvPLKnXdOKpQ90IqiVFfXnHLK KSNHjjS6FgBmF4lEzjrrTB0misViXV1dgYCkw1wA9FcYN0kAsD2Rfq1Wqw574XYm MtsHH/wl56nFfZUkaXtT9fOf/zwYDJo8AivK1g/iD/Hiiy859dRTm5qajK4IgNkF JGnBW29NmfKoDt2wOBIJKGLmvkUCgJ20tbltNltFRYX+U8uy/MrLrxxw4IE5j9Dd 3a30hT/tPPjgg08//ZRpF4Ezn315edmwYT+aOHGi0eUAKBiZblgj/vtqr8+nw1xb tnRr97gKAAOZ9A4JAHapvb3dZrPq8OP/naXT6RtvvPH88y/IeYRQKBSJRFQsaZe6 urouueSSQKDHnBlYBOCjjjpq+PDhRxxxhNG1ACgwAUn6cs2aUSNvqqys1HouFoGB YmXG2yMA2KWODpF+bUbluh8cc8zDjzyazwhaHH20S/Pnzx87dqzZ8q/4g/uXf/nX W2+91eVyGV0LgIKU6YY1acKEjz7+SOu5ZFnu6trCIjBQfEx2fwQAu2KzWWtra+12 u1EFOB3ON958M58R/H6/uHVTq569EgF4/vx5ZlgETqfTjY2NP/7xT372s58dc8wx RpcDoOD1hkJnnnlGBYvAAHJi/L0RAOyZy9UqElR9fb1RBZSXl7///gf5PHUsy7JP +4fWtidi58033/zOO28blYEVZevXbfDgwUcdddTQoUNPPPFEQ8oAUHwCkvTss8++ Nmum1u9vqVSqq2uLx+PRdBYAOiMAAzA1l8tlsbTof9jvNiK7Lly4yOl05jOIuH8S iVStkrIhpguFQrfeeuuKFSsqKvR7ZDrT3nngwIEHH3zIMcccc9ppp7ndbt1mB1AK Mt2wLrrw1+L9Weu5WAQGig8BGIB5tbW5rVarDs1OdkfcXU2bNu2YY36QzyC9vb3h cFitkrIkAnB5ebkkSWPGjFm+/D2t24b9s7V1WW1t7dChQ88999zjjz9e0xkBlLKA JC1btvTee+7R+kQAFoGB4kMABmBSHR3tIv0a0vA5Q9z3iPR49tnn5DmObr2vtpcJ wJlfL1265NZbR0ejUdV3C4pZ+rY6l1VX1/zLv/zLmWeeecIJJ6g8BwDsJLMIfO2I Ed2ebq3nYhEYKDIEYACm43K11tbWNTc3GViDiHYXX3TR9Tf8Ps9xxJ2TCNKqlNQv iqJs/3Tc888/98QTT0hSUFHSZWXl+SThzGJv38cy8Wd09NHHnHPOOZxpBEBnAUla s3btyBv/38CBAzWdSHw76O7u7uoy4EeZALRAAAZgLiL9NjU11dXVGViDSHdHHfX9 u+++W1SSzziRSCQUCqlVVf4mTZq0YMFbkiT1a109E3gz3y9Efq6pqT3ggANOP/30 M844Q6tCAWBvMkciTRg/ftUnq7SeKxgMrlu3XutZAOiDAAzARNra3BaLResf5++Z SL8i4D3y6JTGhoY8K+nv5uft9y1rZ/Xq1U8++eRXX30lknA8Hu9boN66oJtZ2s0s DvetHme+QShlZeXNzc3777//EUccIUKvgYdRAcAO4rHY6b/4RWWltk8Ci7fH7u7u zZu7NJ0FgD4IwABMweVqraystNlshh9du+93933yqadqa2vzTL86H/zbLyL6rlix Yt26dWvXrl2/fn0kEpZlWQRd8UdQVVVl79Pa2nrAAQcce+yx4vXi/wYCgZaWFqML B4AdTb7//jlz52g9SygU+vrrdVrPAkAHBGAAxhPpt6GP0YUMcLW2zpv/Rv7jxONx kRjzH0dnX3zxeSwWF0G3qo/D4TC6IgDYi0gkcuaZZ2j9w1NFUbZs6e7qYhEYKHgE YAAGc7tdInEZeNLvNpaWlkVvv6PKUNlvft6hWxUAoF8CkvTS9Okvv/yS1u+lLAID xYG7LgBGam9vt1otWh/kmI2WZpF+31bl/snn88mynM0rxcsMPOUYAIpA5kikiy68 UJa1feqEJ4GB4kAABmAMp9PZ0FCfZ5tltaiYfsPhcG9vb/7jAACyFJCkBQsWTHn0 Ea37CLIIDBQBAjAAA5hn2/MAVdNvZn0g/3EAANnLLAJfPvyycDis6UQsAgNFgAAM QG8dHe1Wq1WH836yYbVYFyxcqNaTYx6PJ51OqzIUACB7gb7m9nf96U6tn6kJBkPr 1rEIDBQwAjAA/Zin23OG2+WaO2++WqNJkhSLxdQaDQCQvcwi8G+vvEIkYU0noh00 UOgIwAB04na7LZat5+sYXcg/7Pvd786YOUut0cS9l9/vV2s0AEB/iei7atWqcbff pv0icHDduvWaTgFAOwRgAJqz2ay1tbU2m80k5/0oivK9Qw559rnnVRwz+3OPAABa yCwCXztiRLdH214M6XS6u7u7q4u3faAgmeJmFEARc7lcTU2NdXV1RhfyD+LG5f+z dx/wTZX7/8DbdO82oxktBZmK3nu9Io7rvk5ArygbFQfDxVDZlCXIXoIDFSeKUhAB RYYCKojiBFxAgTKbtBlt0jSz55z8H5r7748LpaTJeZ6cJJ/37/W/L/8l+T6Hlp7z fPKszp2vWrhwoYgbUAd+7hEAANBjtdn+2r9/8sRi2ifM2Ww1R49iEBggIiEAAwBF 0jnm14/n+X59+z09dGhaWlpSUpIoNWtqalwulyilAAAgFP5B4NGjRpaXl1NtSBAE g8FgMpmptgIANCAAAwAVUtvviuA5/plnn33sscdErOnxeKxWq4gFAQAgFFab7fDh w+PGjqE9CEzSL+2YDQA0IAADgPh0Ol1eXq5YQ6yi4DjupSUv3XzLLeKWveDSX9Iu 7U4YAAA0qKurczidUyZNOlh6kGpDGAQGiFAIwAAgJpVKmZKSIp39rvxIN2XtJ2tb t2kjblmj0ejz+Zp4Ac/z0pn+DQAQO2pstvt73E/780ez2XzqFAaBASKMhHqoABDp dDptTk4OCcDhvpD/kZSUtG3rtizxtrzyu+DGVyQbS+pTAACAmDJq5Mg//vyDahPk KVBRUWE2W6i2AgDiQucMAEQgtYOO/EgEbVFYuP7Tz2QymbiVbTab2+1uumlJfSsA AGINBoEBoFHonwFAqLRaTU5OTmpqargv5H8IgnDllZ0XLVok4nFHfk6n0263i1sT AADEVVdXN2LE8LKyMqqteL1eo9FEYjDVVgBARAjAABA8pVKZmpoil8tFH2INEcdx w4cO69Ovn4jHHfmRvk51dbWIBQEAgAarzXb02LHRI5/DdtAAcCYEYAAIklaryc7O Jgkz3BdyNp7n337r7Ss7dxa9siAIJpNJ9LIAACA6/5nA48aMOXHyBNWG3G631Wqt qLjAoQAAIBEIwADQbLm5OZmZmRIc+CWSk1O++OKLnJwcGsUvuO0zAABIh/9M4LFj RtM+ls9oNOn1eqpNAIBYEIABoHkkO/BLommH9h1KVq2iVB/pFwAgsvgHgUePGkl7 irLT6SwtPUS1CQAQCwIwAATKv9WzNAd+OY4bNHDgiGeepVTfZDIJgkCpOAAAUGK1 2Q6WlhaPH0d7JbDRaNTrDVSbAABRIAADQEA0Gk1OjhQHfgmB5995970rrriCUv0L HvkLAADS5B8EHvnss4YKuum0trb28OEjVJsAAFEgAAPABUh2q+e4+mnPSoXy840b U1JSKDVRVVVF+k+UigMAAG1Wm+2v/fsnTyymOghMnkcGg8FoxEaJAFKHAAwATZHm Gb9+PM9fc8018+cvEP2k3wYXTL+CIEjwcwEAAGjgHwR+Zvhwo8lItSGz2XzqFM5D ApA6BGAAaJyUV/zG1affGTNm3HTTzaKf9Nugurra6/U28QKfzxcfj7soAIDUWW22 ffv2vTB9WkJCAr1WyIOpoqLCZDLTawIAQoeuGwA0QqfT5uTk0JtXHCKSeDds+Dw/ P59eExdMvwAAECn8g8BPDBlcY7dTbQiDwADShwAMAP9DoVCkpaWS/5Xm2KYgCP+8 /J/vvvce1Vaw7hcAIMpYbbadO3e8tGQJ1WlNXq/XaDSRGEyvCQAIkRQ7uAAQLjqd Ljc3Jzk5OdwX0jiO46ZPf6F79+5UW0H6BQCIPv5B4AEPPcRxdO/wJpOZ9rHDABAK BGAAOE2jUaenp2dlZUlz4JdIT0vfsGFDnlxOtRWceAQAEK2sNtu6des++nAF1Sed y+U6eLCUXn0ACJFEe7oAwFJBgS43N5fSVlKh4zj+tn//e9HixbQbMpvNPM8H8Uby LqobqwAAQOjq6uocTme/Pn18cT6qDVVWGg0GuscOA0DQEIABYppGo87IyMjKygr3 hZyXIAivvvLqdddfT7shk8lE2gr67VLYEVoK1wAAIHFvLlv28ZqPqTZht9uPHCmj 2gQABA1dJYDYVVBQkJeXm5iYGO4LaRyJczqtdu269Qw2ozYajaQ52q3QhgAMAHBB dXV13bp2kdGctkPuxnq9HuchAUgTukoAsUijUWdmZmVmZoT7Qs6L47hBAweOeOZZ Bg1ZLBbarbCBAAwAEIg5s2d99fXXVJvAeUgAkoWuEkBsIdE3MTExLy9PymtWk5KS 1ny8pkVREe2G3G63zWaj3QozCMAAAIHwuN3d7u5GdQIUx3GVlZUYBAaQIHSVAGKI RqPJzs5KT08P94WcF8fxN95wwyuvvsqgrdraWofDwaAhZhCAAQACNHbMmH2/7aPa BAaBAaQJXSWAmKBQyNPS0iQ+8Evy2+uvv3711dcwaKu6utrr9TJoCAAAJKjGZru/ x/1UB4HdbveBAwfp1QeA4CAAA0Q/jUaTk5NNAnC4L+S8BEFo367dypJVbPJ50Mcd SRmGfwEAAldXVzdo4MBKYyXVVoxGo16P85AApAW9JYBoplIpU1JS5HK5TCYL97Wc F8dxkyZO6t2nD4O2SO61WCxRsOEzAACEwmqz/fLrL3NmzaL6fMR5SAAShAAMELW0 Wm1OTnZqamq4L+S8SBDVqNUff7wmk8lBxC6Xq6amhkFDZxEEQcofQAAAxKC6ujp7 be0jAx7y1tXRa4Xc//V6g9mMrbAAJAQBGCAKKZXK1NQUhUIh5TmxHMcNGzpsyOOP s2mORF8SgNm0dS7MTwYAkBqrzbZmzZpVJSup3p+xFRaA1KBDBhBttFptbm5OSkpK uC/kvEgaVMgVpNuRm5fHpkWLxULyNpu2AAAgItTV1Tmczt69elKdpOP1eisrKy2W KnpNAECzIAADRA+FQpGWlir9gd9BAweOeOZZNs0JgmA2m6N40S/GlgEAQjF3zpzt X22n2oTJZCov11NtAgACh24TQJTQ6bQ5OVIf+M1IT//44zVanY5Ni06n0263s2kL AAAikcvluueeu6meh+RwOA4dOkyvPgA0CwIwQMSLlBW//fr2m1BczKxFnPQLAAAX VFdXN3zY0KPHjtFrwufz6fUGk8lErwkACJx0u8sAEAidTpebm5OcnBzuCzkv8uBP T08vWVnSoqiIWYuknxHF054BAEAsVpvtwIEDE4snUB0ExlZYANKBAAwQqTQaNQmW WVlZEh/4feCBB8eNG8esxViY9ox1vwAAYvGfh/TUE4+TJEyvFfI0rKysNJlwHhJA +KELBRCRdDpdXl5uUlJSuC/kvE6v+M3I/Hj1amYrfuMw7RkAAJqPRN+vv/566auv 4DwkgFiAAAwQYZRKZUpKilIp9RW/jz7y6HMjRzJrked5i8WCac8AANBc/vOQ+vXt Q/Uh4nK5Dh4spVcfAAIk3Q40AJxLp9Pm5uZKfMWvPE++atUqpUrFrFG73e50Opk1 R1vDDGdBEKieTgkAAA0WLVy45YstVJvQ6/VGI7bCAggzBGCAyKBSnR74lf5Wz48P GTJ02HCWjZrNZp7nWbYIAADRx+N2d7u7G7bCAoh60u1JA0ADrVabmyv1M37V+fkl Jaty8/KYNepyuWpqapg1BwAAUayuru6pJ588eeokvSY4jq+srMBWWADhhQAMIGlK pSI1NVX6A7+jR48ZMGAAy0arqqpIZ4VliwAAEMWsNtu+fftemD4tISGBXisk/ZaX YxAYIJyk26UGAK1Wk5OTQwJwuC/kvARBaFnUsmTVqrS0NGaNer1eq9WK/a4AAEBE /q2wHh7wkMfjodeK0+ksLT1Erz4AXBACMIAUaTTqxMREuVwu5T2QBJ5/ftr07t27 s2yURF+qXRMAAIhlH37wwfIP3qfaRHm53mTCVlgAYYMADCA5JP1mZWVnZKSH+0LO i+f5Sy6++IMVH7I8iLiurq66uhoDvwAAQA951nTt2oXqLGhshQUQXgjAANJSUFCQ l5dLdRfKEAmCb/GLL958yy0sG8XALwAAMEAC8JjRo/cf2E+vCY7jDAaDxVJFrwkA aAICMIBUaDTqjIyMrKyscF/IefE83+mKK956+x2WE7NJR6GqqgoDvwAAwIDVZisr KxszehTVT6KxFRZAGCEAA0iCTqfNzc1NTk4O94WcV3x8/LI3lnW68kqWjdpsNrfb zbJFAACIZXV1dfba2qeeeJwkYXqtOByOQ4cO06sPAE1AAAYIs9zcnMzMTCkfdMRz /I033vjyK6+wbBRbPQMAQFiQ6Lt169Zlb7xO77lMnm56vQFbYQGEhUQ73AAxQqNR Z2dnp6dLd7+rpKSk5e8tv/iSS1g2Wl1dTQIwyxYBAAD8/Och9e7Vk+p6H2yFBRAu CMAAYaPT6eTyPMnud8Vx3N3dus2aPYdlo26320Zz1hkAAMAFkQw8sbh432/7qDZR Xl5uteKRB8AaAjBAGCgU8rS0NMlOe/b5fJkZGStLVhUWFrJst6qqinQIWLYIAABw LqvNdvTYsdEjn6P6IbXRaNLr9fTqA0CjpNj5BohuWq0mOzsnLS013BfSOI7jHnv0 sWefe45lo06n0263s2wRAADgfPyzoJ964vGq6mp6rZAH35EjZfTqA0CjEIABmCoo KJDL8xISEsJ9IY3w+XwqpbJk1Wq5XM6yUYvFwvM8sxYBAAACsXHDhiUvv0SvPnn2 GQwVZrOZXhMAcC4EYABGFAp5amqaSqUM94U0juO4EcNHDBo8mGWjdrvd6XSybBEA ACBAdXV13bp2kdH8zBpbYQGwhwAMwIJGo87JyUlLSwv3hTTC5/MV6HQlJasys7KY NUp6FdXV1TjlCAAAJIs8qkaPGnXg4AF6TTidztLSQ/TqA8C5EIABqJPybs8cx40f P75//wdYNopTjgAAQPqsNtvB0tKJE8bTW7iEA4EB2EMABqBIo1GT3CvN3Z4FQWhZ VFSyajXLcWmccgQAAJHCvxXW4IED7bUUt2nELGgAxiTXKQeIGiT9ZtYL94U0guP4 qVOn9OjRk2WjFouF4ziWLQIAAIRo1cqVb7/7Dr36Ho+nurq6oqKSXhMAcCYEYAAq tFpNbm5uSkpKuC/kbIIgtL6o9cqSEpbXhs2uAAAgQtXV1XXp0iUxkeJWWJWVRoPB QK8+AJwJARhAfPWLfuVUH5bB4Xl+1oyZ3e65h1mL2OwKAAAiGnmQjRg+rOzoUXpN 1NTUlJVRrA8AZ0IABhBZYWGBBBf9CoLQtk2blSWrkpKSmDWKza4AACDSWW22vXv3 zpzxgkwmo9QEDgQGYElafXSAiKbRqNPTM7Kz2R0mFCCO46dPn969e3dmLbpcrpqa GmbNAQAAUOLfCqt/v36CwNNrxWQyl5djKywAFhCAAcRB0m92dnZ6enq4L+R/+Hy+ osIWJavZbfVMWrRYLDxPsZcAAADA2JzZs7/6+it69WtrHYcPH6ZXHwAaIAADiECa W15xHDdu7LgHHnyQWYvY7AoAAKJSrd3evXv3xKRESvUFQdDrDZgFDcAAAjBAqHQ6 bf2WV7QeikHw+XxajWb16o8zsxjNx8ZmVwAAEN0e6N/fUmWhVx8HAgOwgQAMEJKC ggKFQk5vY4wgcBw3YviIQYMHM2sRm10BAEDUW7927dLXX6NX3+l0lpYeolcfAPwQ gAGCJ8ENn9PT0teuW5efn8+mOWx2BQAAMYL2gcA+n0+vN5hMJkr1AcBPQh13gAii UMhTU9NUKmW4L+T/8BzfrVvXWbPnsGkOm10BAEBMIQF46FNPHT95gl4TmAUNwAAC MECz5eersrOzMzMzw30h/yc+XrZ8+fLLLruMTXPY7AoAAGKN1Wb7+aef5s6dQ2/d k9vtPnDgIKXiAOCHAAzQPFI77ojn+Sv+ecW7773HpjmO46qqqrDZFQAAxBr/gcD9 +vTxxVF8CJaX6zELGoAqBGCAZtBoNLm5OampqeG+kP8i6XfB/AW333EHm+asVqvH 42HTFgAAgNSQDDx16pRffvmFXhOYBQ1AGwIwQKA0GnVeXp5EDvv1H3S0bv2nbK6H 5F6Sfhk0BAAAIFlWm+3osWOjRz5H7+xDr9dbVVVVUVFJqT4AIAADBESj0cjlecnJ yeG+kNM4jhvw0IDRY8awaY48ievq6ti0BQAAIFn+WdCDBw6019rptaLXG4xGI736 ADEOARjgwkj6VSjkSUlJ4b6Q/3r//Q/Y7HeFU44AAADO8s5bb5WsXkWvPmZBA1CF AAxwAVqtlqRfepOdAicIQru2bVet/pje/pNnslgsHMcxaAgAACCCeNzubnd3o9cx IA/fiopKEoMp1QeIcQjAAE0h6VepVCQk0Dr1PnDkcfjss8899thjDNpyOBy1tbUM GgIAAIhEDz34oMlMca9mo9Gk1+vp1QeIZQjAAOel02kVCkmkX5ksYf369YWFhbQb 8vl8FouF53naDQEAAESutWvWvL7sDXr1a2pqysqO0qsPEMsQgAEaJ5H0KwjCJRdf vLKE4lqjBrW1tQ6Hg0FDAAAAEa2urq5Ll7swCxogEiEAAzRCIjOfeY4fOnTokMcf p90QBn4BAAACRwLw4EEDKyopHlaEWdAAlCAAA5xNImO/JJSu/GjlxZdcQrshDPwC AAA0i9Vm27p167I3Xo+Pp9WXxixoAEoQgAH+hxTGfkn0ValUGzduYnDwktlsxsAv AABAs/gPBO7ds4eMWocBs6ABKEEABvg/Uki/JI5effU1CxYsyM7OptoQtnoGAAAI GsnAw4Y+fez4cXpNYBY0AA0IwAD/pdVqFApFeM/75ThuwvgJ3e6+Oy0tjerwLwZ+ AQAAQmG12X788ccF8+fRmwVts9UcPYpZ0AAiQwAGOI2kX7lczmDKcRMEQShZWUJ7 0a/b7bbZbFSbAAAAiHr+WdB9eveiF4A5jjMYDBZLFaX6ALEJARggTqNRk/SbnJwc xmtIS0vbunVbeno61Vaqq6u9Xi/VJgAAAGIEycCjR406cPAAvSYwCxpAdAjAEOtI +s3NzU1NTQ3XBfh8vrZt2ny85hOqrXAcV1VVRdqi2goAAEDssNpsf/zxx7Tnp8pk MkpNYBY0gOgQgCGm5efn5+XlpqWlhesCeJ6/6aabZ8yYQXXLq5qaGpfLRa8+AABA DPLPgu7bp09cHK3PlzELGkB0CMAQuzQadVZWVkZGRrgugDzVxowec2/37lS3vDKZ TIIgUCoOAAAQy0gGHjN69P4D++k1QQJwZaWRXn2AWIMADDEqNzdHoVCQAByuCyDp d9kby6659lp6TWC/KwAAAKoYzII2m82nTpVTKg4QgxCAIUYVFhYolcpwte7z+T77 9LMWRUX0mrBarR6Ph159AAAAYDALmjRhsVgqKiop1QeINQjAEIvCm34TEhK/2r49 i+aiX0x7BgAAYIPBLGi93mA0YhY0gDgQgCHmFBToSPqld2pf03Jzcrdu25aQkECp PqY9A0QH/7BSRnp6eM8nB4ALwixogMiCAAyxRavVKpUKevmzaQW6gg2ff06vPqY9 A0SN8vLytWvXnjp1cvbsOeG+FgBoCoNZ0OThvn8/xdOGAWIKAjDEEI1Go1DIwzKc wuCwX0x7BogatbW1Q4YMJr/U5L/btW376tLXwn1FANAUBrOgy8v1/nsCAIQIARhi hUajzsvLS0lJYd80Sb8dOnRYtuxNSof9chxnsVhoVAYAlvzjSMlJSc9PmbJn317/ dEqe5y/u0OGll18J99UBwHlhFjRABEEAhpigVCrl8rz09HT2TZP0e/nl/1y4aFFW ZiaNwWeHw1FbWyt6WQBgxp97yX9wPH/86NEfvv/+k3VrExMTG15AMvCll1469flp WBIMIE0MZkG7XK6DB0spFQeIKQjAEBMKCgpUqjBs+ywIwnXXXf/CjBmU0m91dbXX 6xW9LACw4e80k9x78vhx/1eMFRXzFixITDx7nwKO4/r179+jR8/cnBzmlwkAF0Z7 FrTP59Pr9SaTmVJ9gNiBAAzRL1yHHpH026tnr+EjRqSlpdFIv2azmed50csCAAPn Rl/C6XTOnDGDFxr5vSZ9X5KB161bn5WVxfAyASBQVpvtt99/f2Ha85gFDSBxCMAQ 5XQ6LUm/9J5G50PSb79+/ceNG0ejOBb9AkSuRqOv36uvvnL8+PHz3a/IXUWpULz6 2uuYCA0gQf5f7T69e9E7Z9HhcB46dIhScYDYgQAM0Uyj0SiVijOX0rFB+qm9e/cp Li6mURwn/QJEqCaiL/HB++/v+21f0/crnucfePCh7t27YyI0gASR3/ERI4aXlZVR qo9Z0ACiQACGqJWfny+X56WmpjJul6Tfm2++Zfr06TT2fK6trXU4HKKXBQCqmo6+ 5Kbx3rvv7j+wP5AjyjmOW7X6Y0rbCgBAKKw2265du5YsfpHeIDBJv+XlmAUNEBIE YIhOGo06sx7jdv3pd8rUqTS6p1ar1ePxiFsTAKhqOvr6lR058vobrwe4UoPcZG64 8aZhw4ZhEBhAavy/77169gjkw6zg2O21R44coVQcIEYgAEN0CsvGVz6f71//uo7S ns8Wi4XjOHFrAgA9gUTfuPoR3fHjxiUmBbpSg9xneJ7HIDCAZD0+ZPDxEycoFSe/ /nq93mKpolQfIBYgAEMU0ul0KpWS3gSkRpFe6VVXXTV7zlwavVKTySQIgrg1AYAe kn5tdnvT0ddv/ry5lqrm9WXJ3eD++3v07dcPg8AAErRl8+ZFLy6iV99gMFRWGunV B4h6CMAQbTQatVKpZLzxFUm/HTp0WPra66KnX1KZpF/yvyLWBAB6Ahz49Tt18sRL L7/c3G3qyQ0hKSn5veXLs7OyMAgMIDXkJtCly130+iE4DAkgRAjAEFUUCjlJv2lp aYzbLSoqev/9D0Q/7xfHHQFEkGZFX78xY0YHt1aQ5/nJk6f87e9/xyAwgAQ9POCh SiOtQVqPx7N//wFKxQFiAQIwRJWCggKVivXSX6VC8eXWbaKX9Xq91dXVopcFABoC n/Pc4P3l7/3511/BLdbw+XyXXXbZ+AnFOdnZGAQGkJoPV6xY/v5yevXLy/Umk4le fYDohgAM0SMs6Tc5OeX7779v7gzGC8JhvwCRIoiBX8LpdE6ZMjnoSZKnt8LiuDFj x1119dUYBAaQGo/b3e3ubpgFDSBNCMAQJbRajVKppHfwQKPi4+O/++570Y8aJj1j u90ubk0AoCGIgV+/4uJiQeBDbP3O2+94YMCAvNxcDAIDSE2f3r1tNbQ+yCb9hNLS Q5SKA0Q9BGCIBkqlgqRf0YNo0wSe//rrb/LkcnHL1tbWOhwOcWsCAA1Bp9/d3323 dv260GeOFOgKRjzzTIuiIpKBQywFAOJa+uor6z/9lFJxn8+n1+tNJjOl+gDRDQEY ogH7yc8cx5WsLOl46aXilq2pqXG5XOLWBADRBTftucHo0aNEmRuZkJDwwgszNJrT 818wCAwgKTU2W4+ePehNTCPpt7wcs6ABgoEADBGvoECnUqlYtshz3Jw5c7t07Spu WZvN5na7xa0JAKILeuA3rn5zuwkTJiQmJohyUDnH8bNnzybRt6hlSwwCA0hNt25d eT7UlQ7nY7fbjxwpo1QcILohAENkqz/1V0V6k8xaFARh0KBBw4YNF7cs0i9ARAgl /RKvvvrKyZMnxboYro6bPWdOQkICBoEBpIbcK8aMHr3/wH5K9TmOMxgMFksVpfoA UQwBGCIY6fApFHKWp/76fL7Ona9asGBBdna2iGWRfgEiQojpt8ZmmzFzhoibxpMe 8B23k/+7Q5aQUISVwABSYrXZfvn1l7mzZ4sy3aNRer3BSO20YYAohgAMEaywsIBk YJYttmrZ6r3ly0nkFnGkBekXQPpCXPQbVx9WJxYXx8vEfOySml3uvOvft90Wd3on fK1CocAgMIBE+G8avXr0SKA2SQ2HIQEEBwEYIpVOp1WpVPQ+WD1XSnLy7h9+FLem 1Wr1eDzi1gQAcYU48Ou3fevWL7dtFeuS/ARBuPP2O/wBODExsUVREc4EBpCUIYMH nRBv1cNZ3G73gQMHKRUHiGIIwBCRNBq1XC5PTk5m1iLP8zt3fpsjaucS6RdA+kRJ vyaTad68uaLvB+vz+e647XZ/AI6r3w8/Ly8Pg8AA0rF+3bqlry2lVLz+MCQDub1Q qg8QrRCAISK1adM6KyuLWXMcx7333vIrrrhCxJpIvwDSJ0r6JTeQSZMmkc6qWFfV 4MwRYCI5JYVkYAwCA0gHuYd06XKXKMeeNQqzoAGCgAAMkYfxqb+kizl82PCBgwaJ WBPrfgGkT5T0S2zetOmbHd+Ickln4Xn+9ttuv/2OO/z/3/j4+JatWmErLABJ6dO7 t63GRqk4DkMCCAICMEQYjUatUqnonSx/Fp/Pd/nl/1yyZImI2z6Tx5XT6RSrGgDQ IFb6dTgcU6dOoTT+Qy5y/vwFZ34FW2EBSAr5JV2wYP7XX39NqT7HcadOnbJaaQVs gKiEAAyRJDc3Jz8/Pz09nVmLSqVyzZpPRNz2uba2lnSIRSkFAJSIlX6JJYsXGyoM oddpVHy8bObMmWd+hdypClu0wCxoAImw2mxlZWVjx4ym98G9Xq83GrEMGKAZEIAh kjA+90gQhB9//CklJUWsgk6n0263i1UNAGgQMf2SjunixS+KePDvWRRy+ajRY878 CmZBA0iK/zCkfn37+Hzi7wLgh2XAAM2FAAwRQ6vVqFQqel3Js3Act2LFh3//+9/F Kuh2u202TFICkDQR0y8xZfIkb12dKKUadcP113ftdvdZX9TqdCQYYxY0gESQu8rI 554rPVRKqb7L5Tp4kFZxgKiEAAyRQalUKhTytLQ0Ns35fL7BgwY9PXSYWAW9Xm91 dbVY1QCABnHTr8FgWLz4RXpnlfM8X1w88dyz2bAXNICkWG22Xbt2LaF2N6g/DElv MplpFAeISgjAEBkYT35u17btqtUfi1WN4ziLxSJWNQCgQdz0S37rJ0wYT3W7voSE xBdeeOHcr8sSElq2bIkADCAR/lnQPXvcT+8wJJJ+y8sxCxogUAjAEAEYT36WyRJ+ +uknsZrz+XxGo1GUUgBAibjp1+v1vv32W8dFqnY+t/371ltvv73RP2p10UVYBgwg KQ89+IDJTGuQtqampqzsKKXiANEHARikTqGQk/SbmprKpjmO477Y8oVWpxOrIEm/ 9La+AIDQiZt+4+p/6xcuXEBv8jPBc9zMWbPPN6CEw5AAJIXcZJYsWfzll1/Sq2+x WCoqKinVB4gyCMAgdSwnPwuCMGrkqIcGDBCroMlkIjXFqgYANFhttqNlZSIWfGH6 NAfls76vuOKKXr16n+9PU1JTdTodZkEDSMTpm8yxY2NGjcRhSABSgAAMksZ48vPF HTp8tLJErGoWi4XjOLGqAQANog//btq48Zsd39Ad/uX5mTNnNbGeMDEpqQVOAwaQ DP8y4L59+sTF4TAkgPBDAAbpYrzzsyw+/qeffxErbFdVVdXRPP4EAEInevq1mM2z 55x3ZrJY/n3zLbffeWcTLyD3sZatWiEAA0jKiOHDDpbSOq/I4XAcOnSYUnGAKIMA DNLFcvIzx3Hr161v3aZNcG/nef7MeU02m83tdot0aQBAhejpl9xGJk4spjr26zd9 +gsXzNjYBwtAarZt3Tpv/jxKxUk/pKKiAochAQQCARgkiuXkZ5/P9+QTTz7+xBNB vPes6EvU1tY6HA6RLg0AqBA9/RJLX331xMkTIhY8F7lZDRk8JJCP6lq2aiXPy6N6 MQDQLOS206XLXfRmiOj1Bpw6ARAIBGCQotzcnPz8/PT0dDbNtSgs/PSzDc1917nR l/B4PFarVaTrAgAqaKTf3/btW/HhCvqf2cXPmjUrkNcVFRUpFArKFwMAzdOnd29b jY1ScSwDBggQAjBIEdOdn3n+519+be55IY2mX0EQTCbswQggaTTSr72mZtq0aYlJ dJf++ny+0aNGKwK7N7Zo0YLZXRQAAkFuPnPnzNn57U5K9Z1OVym1NcYA0QQBGCRH o1GrVCp6RwWcieTYJYuX3HzLLaJUC/zIXxKVmW1tDQANaKTfuNPnHk13OKkvfEhP z5g0aVKALy4sLCQ3UqrXAwDNYrXZDpaWTiqeQKkDQHog5eV6sxnLgAEuAAEYJKdt 2zaZmZls2rqyU6dlb74lSikc+QsgcZTS77q1a3f/sJv23lc8z08snpgd8MbOBQUF +fn5VC8JAJrFfxhS7169ZDJatwuDwVBZiWXAABeAAAzSQjptKhWjaXsJCYk///xz 4K9vYtgWhx4BSByl9Gsw6BctWsRgxkqnKzr17NUr8NcjAANI0+NDBh8/QWu3PCwD BggEAjBIiEajVigUzV2OG5wQzz06U01NjcvlCuKNmAgNwAal9Ov1eicWT0igfOov wXP8xInNGP6NQwAGkKqVH3307nvvUirudrsPHDhIqThA1EAABglp3fqi7OxsBg35 fL7evXpPKC4O/C0kMDd6dIHT6bTb7eJdGgCIjFL6JRbMn2e2WEQvexZyv7rrzrua u1UBAjCANLlcrnvuuZvSYUjkdqHXG7AfJ0DTEIBBKnQ6rUqlor2Ozi89LW3Xd9+H XoekYgv97i8ABI1e+t2yedNXX3/N4JZFmnjuuZHN3dIZARhAsrp168rzPKXiJpO5 vByzoAGaggAMkqBUKkj6TUlJYdAWSa1fbPlCq9OFXqqysjL0IgBACb30a6uunjl7 FoMlDIIg9O7Zq1Pnzs19I3aBBpCsZ0YMP3CQ1kTlmpqasrKjlIoDRAcEYJAEZgf/ +ny+hwc8/OxzzwX4+kbP+/UTa9tnj8fDJvkDxBR66dfr9U6YMJ7NbgVKheLxJ54M YmP8FkVF5L00LgkAQrRl8+ZFLy6iVJzcoP76az+l4gDRAQEYwk+r1ahUKjbbQcnz 5Nu2bw+9TnV1NXnGhF4HAGigl345jpswfnxCIouDysnfYvDAQR0uuSSI9xa1bKmQ y0W/JAAIHfnV7nLXXYlJtPbPKy/XYxkwQBMQgCHMNBp1dnZ2eno6g7ZIz3Xnjp25 eXmBvNjn851vdV9tba3D4RD10gBANFTT75Qpk5md+N2x46X9+/cP7oyllq1ayQO7 1wEAe/fee6/H46ZUHIchATQNARjCjNnBvyTQDho4cOiw4SHW8Xq91dXVolwSAIiO avqdNXOGM6gzz4JAblnDhw3TFRQG8d74+PhWF12U25xjkwCAGXKbGjdu7J9//kmp fk2NvaysjFJxgCiAAAzhpNGolUolpcMAzpKXm7v9q68DfPH5Dj2KC3bjK/K0czid GenpZ60bPN/XASAIVNPv+8uXlx4qFb1yowRBuOO222+9/fbg3p6QkFDUsiUCMIA0 WW223bt3L1q4gNI28lgGDNA0BGAIJ2YH/5LO69at29RqdYh1gt74ijztNmzYsG/v XpPReObXVfn5LVu17Nq1m1wuRwwGCAXV9Pvee+8dPnxI9Mrnk6/KHzxkSBB7X/kl JScXFhYiAANIk/+z7x7330fvoY9lwABNQACGsNFqtfn5LA7+9fl8ffv2GzduXIh1 mrvxVcPo7osLF2758kuPx+311slk//P3FQRfcnJSYWGLHr16/fuWW2QyGWIwQHP5 f9c4nqeRfolvd+78fOPnNCo3iuTtgY8+dnHHjkFXUKvVKpUKdxIAKevXt0+11Uqp OE4DBmgCAjCEh/I0RWpqKoO2UlNSv9+9O8QiDoejtra2WW+x2mw7d+4sWbny0KHS pve4JhFdJku48YYb7ujS5e9//3tOVhZ6rgABojfwG1efRWts1lmz5yQy2fZZEIT4 +Pirr7r6vvvvD6VOUVGRAmcgAUgYuXHNnjVr13e7KNXHacAATUAAhvBgdvAv6b9+ 9tmGVq1ahVjEYrEE+GL/YFRyUlL/fn31BgNJtgEOcvt8cQkJsomTJne+6ipkYIBA UE2/RNnhw8veepNS8XORW83l/7j87nvuyQlt9nKriy7Ky80V66oAQHRWm+2333+f MX0algEDsIcADGGg0Zyenhfc2R7NdfONNy1avDjAF/M83+hVGY1GH4mnAfB3x3/+ 6afJkyaRNNuMC60nCEJOdk7/Bx/s3r071u8BNIH2tGfi1MkTi5csYbNLn588N2/0 2LEhFklITCwqKsINBEDK/Hewnj160JtdgmXAAOeDAAxh0KZN66ysLAYNyWSyX375 NcQiFouF47gAX2y12TZv3vz+e+9VVVcF11x8vIzk8BtvuKF40iSsBwZoFO2B3zj/ kb+TJws+Rkf+nm6xjpv6/PMZGRkh1klJTdXpdAjAANLXv1/fKmoHK+I0YIDzQQAG 1kjPLD9fxaAhEiPffuvtKzt3DvD1Pp/v3JlINTU1ruYc+zmxuHjrtm2hT2jy+eKe Hjr0nnvuQS8W4EwMBn7j6mcPTnv+eV7g6TVxFnK/GjRwUPsOHUIvRe6xcrkcn50B SBy5m82aOfO777+jVB/LgAHOBwEYmFIqFSqVKiUlhUFbl3bs+MGKD0Op4PF4rM3Z oXHhggUlq0qa3u8qcEql8pNP1qIXC9CAwcCv36yZM2rsdtqtnKnjJR0fGjAg9Drx 8fEtW7XCAmAA6bPabHv37iV3G0rLgEkfZv/+AzQqA0Q6BGBgitneVzwv7NmzJ8Rl xpWVlYG8rGHXq3//+98iPsUEQbjxxhuLJ2IiNACjgV+/F6ZPr3XUMjihrQH5BZ88 eYooi41xAjBApPj/y4Dvp7fRQHl5uclkplQcIHIhAAM7zCY/k+g4fdr0/9x7byhF TCYTqRPIK6022/bt2xcumM/zIk+Y9Pl8L8yYeeWVV6I7CzGLZfTlOG7ZG28cP3Gc Zfrl6rgJxcV5eXmiVNNqtQqFAh+ZAUQKqqcBV5wW0Ef5ADEFARjYueyyS9nsp6rT aj/fuCmUCjabze12B/hi0kHv0qVLbW0tjT5zpys6LXrxRXRnITYxm/Pst/XLL7dt 38amLT+O4wcPEmfpbxzmPwNEGnKLmz5t2o8//UipPvbBAmgUAjAwwmzyM3mcfPPN DoVCEXSF5i79HT9+/Pbt28Ra+nuWhISEDZ9vxCxoiDUsB379vtq+ffOWzZR+kRvl 8/muufqa7vfdJ1bB5JSUgoICTBgBiBRWm+2XX3+ZO3s2pVknLpf74MGDNCoDRDQE YGCBRN+CAh2bWYU33njT9OnTs7Ozg64Q4NJfv+enTt20eVP90EvQDTbO5yNFT+8N O+TxJ3r27IlOLcQI9tGX2Lxp0/avtrM5nLxBvkr17HMjRSyoKyiQ5+XhwzKASEF7 GbDP5ysvLzebLTSKA0QuBGBggdnwL+n5bd26LS0tLeguYOBLf4n58+atWr06IYHu kFHbNm3ffucddGoh6oUl+hJ79+z5aOVHLMd+4+o/M5s69fnk5GSxCpL0XtSyJT4p A4g4ffv0ttpslIobDIbKSiOl4gARCgEYqNNoNPn5KgadS47jSlaWdLz00qArNGvp 70tLlqz4cAXtYW2fL+7qq65avGQJ1VYAwitc0Zf46ccfP17zMeP0S25WxcUTc0Vd rEvutEqlEp+UAUQWcvd7/vmpP//8M6X6WAYMcC4EYKCuXbt2GRnpDBq6/B//eOfd 94J+e7OW/pIn1o033hB0W4Hz+XwXXXTR0tdexzJgiEphjL5x4Uu/z454RldYKGJN bH8FEKGsNtvu3bsXLVxA6fN0h8Nx6NBhGpUBIhcCMNBVUKBTqRgdfbRnz95QOrLN OvV33Jgx+37bF3RbzUIy8OSpz//r2msxuRGihv/3iPxHuKIvsevbb9d/up7xul+e 5/v06t2pc2dxy6akpup0OtwiACKO/2bY4/77KH3GTe45J0+etFppTbEGiEQIwECR QiHPz89PSUmh3RCJiBPGT+jdp0/QFcxmc4Cn+Fpttp9//rl4wnhmo0Y8L7wwc+ZV nTujdwtRILxDvg1I+v30s08Zj/2SO9W111x7b/fuolcuKCzMy83FJBGACHXvvfd6 PIGuwGouvV5vNJooFQeIRAjAQBGzva+UCsWXW4M/vdNutzvrB6MCQbrvt99+m8fj Cbq5wDVsBP3Agw89/PDDCMAQ0SQSfePCl37btm03aNAg0Svj9COASDdq5Mg//vyD UnEsAwY4CwIw0EKir0ajprSz/5k4jtv65Va1RhP02y2WZpwQsOyN1996+x0mJzr9 F88LY8aNu+3WW9HBhQglnehLbN+2bcsXWxinX0Ihl48aPYZGZQz/AkS6LZs2LVr8 IqXidrv9yJEySsUBIhECMNDCbPj3huuuX/Lyy0G/3Wg0+ny+AF9M+vE33HA9mwON G5B+7aefbcAmWBBxpLDQ9ywk/W7espnxut+4+t/iyZOn0PhAMCk5ubCwEJ+OAUQ0 j9t9993dEuiMGXi93r/+2k+jMkCEQgAGKkj01Wo1LHqZPt+evcFvRlVVVUX66IG/ fuSzz363+/ugmwsCCeePPPzwE08+xbJRgKA1hN44KeVevy+/2LJ12zb2Y78ESb9p aWk0KmP4FyA6dOlyV+AfxzdXeXm5yWSmVBwg4iAAAxVshn8FQZg/b/7td9wR3Nud Tqfdbj/zKzzPNxHaSc/++uuvl8nY/tb4fN/v/oFpiwDNcWbijZNe6G2w4bPPvt31 LePpG4TA88XFE7PpjNBi9S9A1Hji8SHHqN08K04L6KgLgFiAAAziU6mUGg2L4d8C nW7D5xuDe6/P5zMajc16y9JXXln+wfvBNRccny/uhuuvnzd/PstGAS5IysO8jVq3 du3uH3azT78cx40bO05B59NA8tcpaNEiNzsbw78AkY7cVJctW/bpp+sp1cc+WABn QgAG8TEb/t2589vs7Ozg3m4ymUiFZr3lvu7dKyorgmsuOOQK161br9VqWTYKcK5I GeZt1Afvv//Hn3+EIf3Wcc8+95xOp6NUPyUtTafVYvgXIApYbbajx46NHT2K0hoN p9NVWlpKozJAJEIABpExG/5t1bLl2nVBflZqs9nc7tMH7pGEGfjD5pprrmHZhfb5 4nr17j1w4EB0cCEsIm6Yt1Gvv/ba0WNHwzL2O3rkqPxgd6e/IHLj0hUWYvgXIDr4 77e9evag1H0ivR2DwYBlwAB+CMAgMjbDv6Rz+fvvQZ6YRx4zVVVVzX2L2WLpfu9/ mG2f4/P5brrxpvHFxdj8GZiJ6GHeRs2eNdNqs4Ul/T4zfERBixb0mtBqtQqFAjcH gGjy0IMPmswmSsX1er3RSKs4QGRBAAYx5ebm6HS65ORkqq2QcPjsiGcefvTR4N7e rHOP4uo/N62x20tLS0cMHxZci4Ej10X66tj5GZiJjmHeRr2/fPmff/3JPv2Sb+nQ p55u1bo1vSYSk5JatGiBuSEA0YTcOubOmbPz252U6mMZMEADBGAQE0m/+fkq2q1o 1OpNm7cE997mnnvkZ7XZjhw5MvRpFomUZODbbr31hRkzGLQFMSj6hnnPxXHcwgXz q6qrwzL2O3jQ4PYdOlBtBUcfAUQf0tPYu3fvrJkzKN24amrsZWVlNCoDRBwEYBBT u3ZtMzIyqDZB+pfffrsrJ6ihD5fLVVNTE8QbSWYgT6Z77u5Guz8tCELv3r0HDhqM sR0QSywk3jORW8Q7b79ddjQM/Tw26TclNVWn0+EWARBl/Pfqnj3uT0xMpFHf4/Hs 33+ARmWAiIMADKJRqVQ6nZZ2RLzpxpumTZ8e3ObPlZUhHYJ3zTVX0/vb+Xy+zMys kaNGdb7qqpysLIztQNBiLfGeyel0zps71+1xs2+apN9HHn7k0ssuo9pKQkKCtqAA e18BRKv/3HOPt85LozLpZuj1euyDBRCHAAwiYrD9FcmfX3/9TVpaWhCdP7PZzPN8 KK1fe801lH5jyGPp2mv/NXfuXJJbsOsVNFcsJ94zWczmOXNmJ9AZPGkam/RL6AoK 5Hl5uEUARKtnRgw/cPAgpeIGg6Gy0kipOEAEQQAG0XTo0J5EU3r1BUFYuHDRrbfe GsR7a2trHQ5HiBdwww3Xk25uiEXOQv5S7du1f2ro0EsuuQRzGiFASLzn+nbHjvWf fUpp6mDTmKVfTH4GiHqrVq58+913KBXHPlgAfgjAIA6VSlVQoKPbhFL5xZdbg3gj CZkmU6hb/5PI0ad3b0OFIcQ6/n2e/VeVnZX98KOPdu3aVSaTYeAXmoDE2wSv1/vi ooWWqipmp5Sdic263zhMfgaIDbV2+/097qd0N3M4HIcOHaZRGSCyIACDOGjPf+Z5 fu0na9u0bRvEe0n6JWkzxAuw2my7d+9+fuqUoCs0RN/6//Y9/PAjffr2RfSFRiHx Bshqtc6ePYv9bs9+5Mc0ZPAQBuk3DpOfAWLGHbffJktIoFGZ4ziz2VxREdJ+KABR AAEYxEF7/+cWhYWffrYhiDfW1NS4XK7QL8C/EfTd3brJZCH91vC88LfLLhs0ZEi7 9u2x2RX4nRV345B4A0B6cru//37d+nXh+iUiF/D0k09RPe+3gVqtVqlUuF0AxIIH +ve3VFkoFS8v14c+Jw4g0iEAgwgUCrlOp0ug84FlXP3w75YtX2i12ua+kfRQLRbR niIkpYx87rmffv6pWe9qGPj1+XxpqWnDn3nmpptuwsBvzDo368Yh7jZfdXX1668t tQV1qpkoyM9x2NBhLVu1YtBWYmJiYYsWebm5DNoCgLB7Yfq0b3ftolS84jSMAEOs QwAGEajV+UGk08DptNrPN24K4o1Go5HETrEuw2qz/frrrxPGjw9iuqUg+AY89OCQ x5/APs+xA1mXBo7jvtq27YutWxMTaX3iFsg1PDN8REGLFgzaio+PLygoyM3NxU0D IEZ8u2PHCzNnUCqOfbAA4hCAQRRUFwALgvDx6o/btW/f3DdarVaPxyPilfjzzF13 3hH4gkP/8O/d3e6+5l//6tSpE7ZvjVbIugyQ2Llp48bvd38v4qdawV3GyOdGamh+ 5HcmrU6nkMuRfgFiB3mgdLnrrsQkKnvaO53O0tJDNCoDRBAEYBBB27ZtMjMzKRVP SkretWtXc/t/JPqSAEzjeoY9/fTPv/5ywZfVR9/4fv37DxgwICM9HQO/UQabVDH2 y88/r1q9OsQV+KHj6uqKJxTnyuVsmsO5RwCxqUuXuyh90sfzvMlkwixoiHEIwCCC jh0vSU5OplT8P/+5d+TIkdnZ2c16V2UlrZs7ST7XX39do0cU1D+tfAkJiR07duzb r59GoykoKEDujQ5IvOFCou+aNWsEnxCurZ4bcBw/auRItUbDprnEpCSNVotzjwBi 0JBBg06cOkmpOPbBAkAAhlCpVEqdTkepb8px3K5d36WlpTWrC1hVVUXiCo3r8Xvj 9dfffufsc+rJN+Daa64dNXo0+W74wxKibxRoyL1IvIyR3/1vvvpq6/ZtPp8v7NGX EHh+zJixCpqHvZ1JJpPpCguRfgFiEHnuLFm8+MutX1Kqj32wAMLfq4BIl5+fr9PR Wg6n0Wg+/fSzZnUB3W63zWajdD1+Vpvt888/P+uL3bp1w0zFqIHcG0Yul2v9unW/ /PprGLe5OosgCOPGjc/Ly2PWIk79BYhZpI/x2++/z5g+jdJnf9gHCwABGEKl0ag1 1OYE9urdZ+jTTzdr/jO9yc8NGt3xCOO90cH/w0XuDQvyy7vig/f1BoPUfpWKiyfS 2+bgXOSOqlQqpfZNAAA2/I+hHvffR+kmgH2wABCAIVT0AjDHcTt27CT9zsCfAbQn P0MUQ/QNF4fD8fnnG/bu2SuFhb5nkckSJk6cmJaWxqxFbHwFAHGnp5V15XmeRmXs gwUgra4GRCKaZyDF79mzJ/BXM5j8DFEJ0TcsOI776Ycftn+13WqzJSZSOfAjROlp aWPHjae3w9+5kpKSNDpdTlYWhn8BYtwTjw85Ru2RhH2wIMYhAEOo2rRpnZWVRaNy gU634fONgb+eweRniDKIvuydzr0//rhjxzdmi0WaudcvNydn5KjRLK8wISFBW1CA ja8A4PQ+WEsWf/kl9sECoAIBGELVvn279PR0GpWv7NTp1aWvBdgXxORnaBZEX8Zc Ltf3u3b9+NOPlqoqKefeuNPnmfk0avXQYcNZXqdMJtPqdHm5uUi/AIB9sACoQgCG UNELwLfdetukyZMD2QGL9K1rampoXANEJZJ+bXY7oi8DJpNpy5bNB/Yf8Hg9Es+9 fiT9tm7desiQx1k2Svq4OpJ+se0zANTDPlgAVCEAQ6joBeA+ffo+9dRTgQRgTH6G AGHglwGv1/vzTz/98MMPhgqDTCaT2r5WTSDp92+X/e2BBx9k3C5Jv3K5HOkXAM5E bx8sjuPNZuyDBbErYvolIFlhD8AWi4XjOBoXAFEGA7/0kN/BQ6UHd+3aVXb0KPk+ R8Rg71kEQfjXtf+6t3t3xu1qtVqFQoH0CwBnwT5YAJQgAEOo6AXgbl27jRk7tukA jMnPEAgM/NJAQu+J48d37NhxpKzM5XJGdITjef6uO+/69623Mm5Xo9UqkX4B4By0 98EyGCowew5iFgIwhIpeAL7h+hsWLFzYdNcQt2+4IAz8ioiE3gP79+/e/f2xY8cj ZVnvBZG/VO9evTtfdRXjdjUajVKpRPoFgHNhHywAehCAIVRt27bNzMygUrlNm9Uf r2niBZj8DBeE9Bu62traX37++bff9hkMFd46b5QFNvIvZOCjj11y6aWM21Wr1SqV Ksq+mQAgFtr7YNnttUeOHKFRGUD6EIAhVK1bt87OpnIOcHJy8g8//Hi+P8XkZ2ga pj0HzT+3+ddffz10+FBVVbVMFi+TycJ9UVSQv+nQp4e2bNWKcbtIvwAQCHr7YHk8 nv37D9CoDCB9CMAQqsLCAqVSSaMy6Zv+/vsf5/tTTH6GJmDgt7lqbLZd3367/8B+ o8lEfvViIZuRv+bYMWOVKhXjdlNSU3U6XW5ODuN2ASDiDBk86MTJkzQq+3y+8vJy s9lCoziAxCEAQ6g0GrVGo6FUfO6cubffcce5X8fkZ2gC0m8grFbr3l9//fOvP/V6 g381bwSdVxQ68o9kzJix+fn5jNtNTkkhd8ycrKxY+IgBAEJBblPz5s7dsXMHpfrk 5m80GikVB5CyGOruACVqtVqrpRWAL+7Q4aOVJWd90el02u12Si1CRMO05yZUV1fv 27Nn/4H9ekOF2+VMiLHEeyby72TixEm5ubmM201JTc1Xq5F+ASAQVptt69atby57 g1L9itMwmQ5iUYz2fkBEKpWqoEBHqTjP899+uystLe3M/iImP0OjMPB7Jo7jLGbz 3r17Dh4srTRWer3ehISEmE28ZyJ3lalTn6e0d30T1Gp1ekZGRno60i8ABII81EgG 7te3D6X99k0mc3k5NoKGWITOEIRKozm9mwvpW1Oq/8gjjxINpwFj8jM0CumXRNzS /fv3Hzxw9OgxS1WVIPDRcUaRuOLj4qc+/3xycjLjdrHrFQAE54477pDJqHTXXS7X wYOlNCoDSBwCMIiA3lHARFZm5rbtX/k7jtj5GRoVg+mX4zhrVdW+334rLT1YUVHh dLni4+PpfQ4VHcjNZMzYcew/F8B5vwAQtAf697NUVdGozPO8yWTCLGiIQQjAIAJ6 G0ETgiCUlJRcfPElcZj8DOeInUW/9pqa/Qf2HzpYevLUSavNRjouGOANnM/n02l1 Tz39dBjSr1arVCiQfgEgOJOKi3/65WdKxcvLy00mM6XiAJKFAAwioLoPFpGvUm35 4ktMfoazRPHAr9frPVRaeuDAgWPHTs9nrvN6ExKxgjdIJP3+7bK/PfDgg+yb1mq1 CqRfAAgWecx99OGHH370IaX6BkMFhhYgBqE7BSJQqVQ6nZZe71wQhCWLl1x8ySWU 6kMkiqb0y3HcqRMn/vzrryNHjphMJpfbLZNhPrM4SPq94fobut19N+N2yf2QpF+5 XI70CwBBs9psR48dGzt6lEwmo1HfbDafOoV9sCDmIACDODp0aJ+WlkavfnJS8vIP PsAGquAX6enXaDT+8dtvR48eLdfr7bWnz/TCfGZKyDd2+vQXGDdKuqpanS4vNxf3 KwAIhX+ZT88e91N6Rtjt9iNHymhUBpAyBGAQB9VlwHH1wzhdunR95NFHc3Ny6LUC ESHi0q/T6Ty4f//+AwdOnDhebbX6l+9iPjMbF7W6aMjjj7NsMSExkaTf3OxspF8A EMV//nOP1+ulUdntdh84cJBGZQApQw8MxJGfr9LpaJ0G7Mdx3OpVq/Pkcqqt0OP/ HJf8R9Pj2P6XYay7UZGy5ZXJZNpXfwBvRUWF2+OW1Qv3RcWo6679193/+Q+z5pKS k9UaDdIvAIjoiceHHKPz1BMEQa83mM3YBwtiCwIwiKZjx0ton67Zsqhozrz5ERoO TWbzoUOHjEYj5/W63a7q6mqeFxr+NCkpMTMz6/T4dnx8cmrqlVdeqaI5oh6JpDnw y3Hcvj17srKySNbd99tv5H89Xg8GeKWjV89eV3TqxKatlNRUVX4+0i8AiGvJiy9u 3LyJUvHycr3JZKJUHECa0EUD0dCeBR1X/1Fl/wce7N69u8QnQtfa7Tu++Wbfvn1H ysosFrPL7eY5nvy2Bb6tEc/zPsGXkJiQkpyiUavbd+hwxRVXXHfddaSHHReTo8QS TL/V1dVvvbmsorKS/BR8Ph8SrzSNfPY5ZX4+g4bUGk16enpM/VYCAANer3frF18s efklSvWxETTEIPTYQDQqlVKn09GOARzHlawsUUhsdNThcGzZvGnnzp1HjpQ5XU5K U15JKibfXJ1W17FjxxtvueXiiy8mve1YSMKSSr/kZ12ycuVf+//CMK/0kV+ZmTNn 0d5gjPwz0Gi1Cmz4DABiI4+/+o2aT40fP47SrQwbQUMMQu8NxNS+fbv09HTarajz 899b/j7tVi6IPJY2b9y4afPmI2VHBEFgfGiNjxCEoqKW3e6555ZbboniJCyd9Eui 79JXXzGaTDigKFKQfzzz5y+g2gT5x0DSLzZ8BgAarDbbqZMnya1s9OhR2AgaQCwI wCCmgoIClYr62CyJfvf+597+Dz4YlrxXa7cvW7Zs584dNXa7FI6uOR2Eeb6oqKhf /weu7NxZ4pPDm0si6ZfjuHfeefvQoUOIvpGF/HbMnj2HXn1seQUAVFVbrcePHSO3 silTJmMjaACxIACDmJRKpVqdz6AvSHLRcyNHXnfd9bTzXsNqWxKBXlu69Jtvvq51 OKSQe88lCEJqSmrv3r379O0bHd1xKaRf0uFYvXr1nj2/Rse3NNZkZmQUT5xEqbha rU7PyIjKaRcAIAXkIWipqjLo9eS/l776yomTJ2m0go2gIQYhAIPIGGyF5cfz/KqS VbRPRbLabF9//fWa1asNFQZp5t5z8bxw1513PvnUU966ugjtnUvhuKPa2toPV6wo PVQaid9A8GtZ1PKJJ58UvSwW/QIAA6QHUl5e7vV4yH9/sWXLV19/RakhvV5vNGIj aIghCMAgMpVKpVbns8mKCrlixYcfiluzYchX4PnXXntt0+ZNEbrBL4nB3e+7r1+/ fjKZLLJicNgHfs1m84crPjh56lSkfOQB59P5ys739+ghbk0s+gUANkgAPn7smCCc PjGx/NSpl195mVJD2AgaYk3kdetB+pgNApNoSjq4o8aMESXg+aMvedIcP3HinTff 9G/zK8p1hgv5/pDO+pNPPX3DDTdEytrg8KZfg8HwwfvLjSZTpP/owe++++676qqr RSyYnJKSr1Zj0S8A0EaehtXV1eXl/92fmeM4bAQNIBYEYBCfSqVUq9VsIgTJq127 dntwwICcrKygu6QN0besrOytN944dORwNOUf8tS8/rrrxowdJ/0Z0WFMv0aj8b13 3zGZzdjmijHye0fjzLC4+g+ARo0aLdqHcfHxGo0mLS1N4r9EABAdrDabXq/3uN0N X8FG0ABiQQAGKpgNAsfVp6Ynn3r65ltuCToDk8fM0WPHXnvl5SNlZdEUfc9E/l7j iyd26NAhlE8KqApX+jWbzST6VlRWRuuPXprIj9vlcnk8nvj4eEr3Co7j5s2bL0op WUKCVqPJy8uT5u8OAESf0/Ofjx8XeL7hK1MmT/bWUdkImtyNDx4spVEZQJoQgIEK hUKh0aiZdRZJZ3rylKmXXnZZEOmO3PenTZv2008/Rn3+IXmgX/8HevToIcHp0GFJ v1ar9Z2339IbImZ7s0gnCIKrnsfjTUiQVVScXnJG78Mynufnzp0Xep3k5OR8nHUE AGxVW63Hjh498yv0NoImd8vff/+DRmUAaUIABlrYnAncgOf4WXPntm3TJpB055/z nJyU9O7bb3+ybl1iYqzMeiUZuG/vPoOGDAn3hfwP9unX6/W+v3z5gYMHEH1p8/l8 brfH4aglP2USgE2ms0/aaNeuXUZGOo2mSV6dNm16SCXi4zVqdVp6OqY9AwBL5IZp NpsrKirO/CLVjaDLy/UmEzaChliBAAy0aDTqnJyctLQ0Zi3Gx8WvLCnJCSAAW222 b7755vXXlvo3V4wp5K988003TyguDveF/Bfj9Mtx3KaNG3fs3IHoSw8JvR6Pp7aW hF5OEPhzQ++ZLr20I6VsSbLriGeeDfrt2O0ZAMKF9FJOnDjBc9yZXyw/efLlV1+h 1KJebzAajZSKA0gNAjBQpNVq8/NVLM8Qys7KXvHhh+frsPoHfn08P27c2LKjR2N2 uyOST/72t7/Nn78gvJfB/rDfvXv2rCxZGYmHWklf/Uiv2+FwBBJ6G6hUyoKCAkqX dGWnK3v07Bnce1NSU1X5+Zj2DABhce7857j6D3AnTBhPqetScRpOQoJYgY4g0MVy Nyw/jVq97M23zuq2Nuzz/OGKFevWrcXoH4krt9xyyxNPPhWuuZ2MB36rq6uXLn21 pqYG6VdEPM+73R6Xy0l+mjwvmM0Bhd4zqdX5Wq2WxrURPXv07HTllc19l0wm02g0 JABj2jMAhAW5o1qqqgx6/bl/NGrUSEr3JZyEBDEFfUGgS6lU5OfnJycns2y0fbt2 S176v/Pi/Vnr2NGj8+bMttpsiEB+JL10v+/+Pn37st8XmmX65Thu7dq1P/ywG2Em dD6fj/zsPPW8Xi/5J2SxVIVSkN4HZORSx4+fEMiCiDMlJSersd8VAIQV6aicOnWq ztvIhs8TJxbzZ+wLLaLa2trDh4/QqAwgQUgCQJ1Op1OplCxj51lTfMmzZMWKFWvX fJyITu3/IuFw2PDhN910M8t9oVmmX/2pUy+98gr5F8GgrWhF/pGQuOtyuc63i1Uo Wre+KDs7W8SCDcjVNm+SP/a7AgBpIJ2WY0ePkp7MuX+0YP58s0XMm3ADcp/fv/8A jcoAEoQADCzQ6+aeD3lyXNmp04yZsxwOx4jhw06cPCmTyVheQKTg6riSkhIFw0Ob 2aRfr9f75pvLjh07FrMrvYPG8zzpCTmdThJ9eV6gui9ohw7tKe2TFx8XP3PWrABf nJiYqNZosN8VAIQdeUpWVVfryxufjVyycuXefXtptCsIgl5vCGIlC0AkQgAGFjQa tVwuZzwRmmTg1he1PnLksAwRqEmFBYXzFy5kMPDFLP3qT51a/NISfOQRINLvqZ/S XOcl/69OhInNAVKplFqtltKPSSGXjxo9JpBXqusHfjMzMpB+ASDsmpj/TPyw+/t1 69dTahonIUHsQAAGRtjvCA0BIvnnkUcf69q1K9WJ0GzSL8dxq1ev+vXXX7HPWRPO GuMVBEaJ9yzkhqDT6SgVv+Kf/+zVu0/Trzl90JFGk5eXh+gLABLRxPznuPoNHefM mU2pK2UwGCorcRISxASkEWCH/Y7QECCSiNav/zQ9PZ1SfTbp12QyLVm8mOO5C780 xpDvv9frrV/He/qMIhL8pHDcBdUbQt8+ff9x+eVNvAAHHQGA1JB7NYm45eeZ/+w3 evQoSp/w4iQkiB0IwMCOQiFXKBT0UhaEotMVnWbMnEmjMpv0++2OHes/+xQDv3H1 Q/re00jo9dDYuUos9LYGIH/lKVOmnu9WI6sf+E1JScF+VwAgKVabjaRfr8fTxGvG jBmTkEBl5QhOQoLYgQAMTGk0aqVSiZQiQRzHffbZBnF3JPIfv8zxPNX0S678jTde P378eGwu+vUfTUS4XC7/lGbyNWkm3rNcfHGH1NRUGpW5urp559kCOjklJV+txsAv AEhQ0/Of/aY9/7zL7aLRusPhOHToMI3KAFKDAAyssT8VCQJ0y803jx03XqxqbAZ+ q6ur58+fLwhUzkWUJpJyvV6vfwWvIPgEQYjEfTsVCkVhYQGl+wAJt9OmTT/ri6cH ftXqlNRUDPwCgASdnv9stZafOtX0y15buvT4CSoPVpyEBLEDIQTCAIuBpYlkqQ2f bxQlG7BJv/pTpxa9uCi6j3eu36LZW7+I1z+f2Rcdu3Sq1flarZZS8VYtWz3+xBNn fgUDvwAgcafnP5865T3P/s8NNnz22a7vdtG4APK4OXHihNVqo1EcQFIQgCEMNBp1 RkZmVlZmuC8Ezvbow4/06dcvxCJs0u+Pu3evXvNxlE2n9y/fJd9Aj8dTv2FV2LZo po3qp2D/ufuea6+7zv/fGPgFgIgQyPxn4s8//vhgxQeUrkGv1xuN0fAZK0DTEIAh PEgGzs3NpbQCEIKWmpKybv2noVRgk37XfvLJ97u/T4jwE579y3dJ4HW7I2z5buja t29HaT88QRAmTZqcmXn68zVs9QwAESGQ/Z/9HA7H9OnTcBISQCgQgCFssCGWBPEc 92kIW2GxSb9vvfXmoUOHInEZef18Zo//UCKSeyN0+W7oVCqlRqOh9PkF+fbOn78A Wz0DQASx2mynTp2qu9D8Z79Ro0ZSuq3hJCSIEZHXg4RootVqSVc4NjfvlawH+vV/ 6OGHg3gjg/TLcdySxS8aTaZISb8+n8/t9jgctf4B3midz9xc+fn5Oh2tBcBpqWkz Zs3CwC8ARJBqq/XYsWNxF5r/7DdmzGhKHyDiJCSIEZHRiYQoVlBQoFQqIiXPhI4k ovrNe/+r4evx8TKZLJ480hITE8P73dDkq99dvry572KTfufNnVNjt9NrQizkJ+t0 upxOh9PpxIYi56K6APgff//7+OKJGPgFgEhBHqCWqiqDXh/g6ydPnkTeQuNK7Hb7 kSNlNCoDSEqspA6QsijeFJoEIbfb7T+xhkRfQfBdcJGnQiGXyRJIGCbd95SUlNTU VMb9eHKpH6/5pFn5gUH6JU3Mnj2LfCfpNSEKj8dDOhButyc25zYHqF27dhkZVBYA E8OHDe/arRul4gAAorPabCdPnuQCzrSLFi40mqis1HW5XAcPltKoDCApCMAgCRdd dFFOTna4r0IcJPS6XG6Xy+n11pHMG/qeRiqVKiUlOSsri+RhUa6waSSoj59QfPnl l+fm5ATyejbpd9asmeTBTK+J0DkcTofDIQg8FlA1TalU6HQ6SgsfeI7bsOHzFOyu BwCR4/T856NHA3/9yo8+2vfbPhpXwnHcH3/8SaMygKQgAIMkRMHBSPWzXp0k+no8 brPZInp98i2SyRIyMzMo7Z17pi533vXU0KGBjACzmfk8Z/asWoeDXhOh8Pl8tbW1 5EdvMFSE+1oiA9UTgEmu3rhxE6XiAACiI49Rs9lcUdGMJ8h3u3Z9tuEzStdTXl4e I4cRQCxDAAapIAEvOzubQboTHQm9Dketx+Nh88woKCjIy8tLTKR4AlD7du2WvPTy BV/GJv0umD/PapPiMlpBEOz2WpfL1ayOC1Bd8tCmdetXXl1KqTgAgOjIA+7EiRM8 xwX+lsqKihcXv0jpenAUMMQCBGCQEJKBc3Jy09IiY/pi/dCfo37oz8C4aa1WI5fL 6a0NTk9L+2TtuiZeQKIv+ZtzPM9gz2eT9BbT8jxfXV3t8XhNJvQSmq1jx0uSk5Mp FX/k4Uf69utHqTgAgOiqqquPHzvWrLeQh+OECeMpbQRtMFRUVmIhD0Q5BGCQFo1G k5eXy2axa9BI9LXb7U5nOIf+tFptfr6K0n7RPC98+eWX5/tTNof9Ei8tWaxn/uFC 0/5/9GU02h99VCpVQYGOUnHy01m3bn1GRgal+gAA4iLPU5PJFETgHD16VGJiIo1L wlHAEAsQgEFySAZWKCgOb4bCv+DT4XBKYdZr27ZtMjOprJrmOG7r1m2N/hGz9Pvm m28ePnxIOudjCYJQVVWF7Z1DRHX+M/n13LLlC0rFAQBEZ7XZjh8/LvB8c984Yfx4 X1xAhwY3F44Chlgglc4lwJmkmYGdTqfdXst+wvP5FBQUqFRUsgQJeys+/Cg3J+es HwGz9Lv2k09++PEHiaRfKQz4R4327dvRW+df1KLFG8vepFQcAEBc5JFaVV2tLw8m bc6aNbOmpkb0S4rDUcAQGyTRvwQ4F+1lrs1CnlJWq608qKcUPVRnk46fMOEf//if k5CYpd8d33zz+cbPKR2T01wOh6O2thY7PItCpVLqdDp6n2sMemxgz969KRUHABCX 1Xa6X+H1eIJ47xuvv3a0mSuHA4SjgCEWIACDdGk0GqVSQWmVS4B8Pp/FYnG7qZxs FKLc3JyioiJKQXHE8BG33X57wwcQzNLv/j//fPvdd8L7Q/cjP/Samv/H3p3Hx1Xf 9/63JVmyJEu2pRlpRnKT4JUdbkK2pg1beu+jaXOTNmlIfml/bZLbtOHX381tsQle 8L5v2BC2hLAGMCRhB7Nvsc2OwTZg403LLNKs54xmNMs5M3OPLOoSY8mydb5nfT3/ uA9K7M/3C+ZqznvO9/v59IVCIbM34hxCzz+rqvo4E4AB2EdSkjo7O8ul0in83gd+ //s33nxD9y2NOfJx/95774uoDFgHARiW5vf7mptNy8BaBJLllHXOPH+SuIa6P/nn f/7bb39n8K8NS7894fCGjRtMT7+Dna647qu7GTOmi+tQVVNd8/AjjwgqDgD60j5Y 44lE+FS/Y3391VcffHi4YQ2nrFwuB4MhPv7gbARgWJ0pGdjKL34/btasmbW1tSIq Hz1Nalj6jUaja9asGTfO5PSbTmfS6T56YOpO9Pnn8849b/mKFRa5NAEAw5NkORAI KIXCqf32nlBo83XX6rulo7QAzJA/OBsBGDZgcE+sQqEgSVIoZN0Xv0eJDsCGpd9s NrtkyWJzu15Z86a3Y4ju/zx33vzzz/+jW+sAYFlJSero6NB+eJ3ab1dVdf78eYLu QGnPP5FIRERlwCIIwLAHw3pi9fX1ZTIZu7wAFBqAv/k3f2NM+tU+yFeuXKFlYNEL DSN9hF3+3O1o5syZdXVC/lvVlIrF+3/3+/q6Ot4AA7A+RVFisdgoJwvMnn2FoJ94 jAKG4xGAYRs+X6uWgQVdeR3znzc/7TX+btasWbW1Qrr+/NM//tPX/sf/MCD9aq7d vCls3oQhO/65247X621r84t7w9/e1vbrW28TVBwA9CXJcnd3t6oooyly5ZVXVlYK eQNMAIbjEYBhJ1oGnjx5ck1Nje6V8/l8MinZbtCruCZY3//e98897zwRlY9x//33 vf3222Ydfs5ms6lUiilHogk9/zzmj3u2AYDFJZPJjlEPMbr66qtVdVQReijRaIzb QHA2AjBsxufzTZw4Ud/Xnn0D0na88XL22WcJag/24x/+aPrMmSIqf9y2l19+9PHH zBr5K8upbLaf77lFmzRpYltbm7izG6qqbt36JIefAdiCoijRaLS3d7QfPevXrY0n Erps6RjpdPrAgYMiKgMWQQCG/fh8rQ0NjfX1daMvVSqVEomETY+/ejye9nZRbXVn XzG7WeQrO83BAwduuvkmU4YeaX/u8XiCb7iNof1X6vV6xdVvbmq6+557xdUHAB1J stzV2VksFkdZ5/Zbb923/0NdtnSMbDa7b5+QyoBFEIBhS1oGrq+f0NAwYTRFFEVJ JpO26PZ8XFqo0KKFiMrlcnnp0mXiXtmNGWgyGbrmmo2mpF9VVROJhH3/3G1n+vRp EyaM6v+rDu+yv/vuD3/8Y3H1AUAvgw8eunz9uvXxx1/e9ofR1/kkbZPvvfe+iMqA RRCAYVfNzU21tbWnfLEwm83Ksmzr46+trS1+v19EZS0irlu3XkTlQX19fcuWLa2s rBS3xFAKhYL28MGlX8OIbn+l/bf66KOPCeqFDgD6kmQ5FArlc7nRl9qze9fd99wz +jqfVC6XOzs7JUkWURywAgIw7O3UmuukUqn+fttf/vT5Wn0+n4jKqqKuWy8qAGsR dOmSJcXSaE9/nYJcLidJkt3/3O1FdPurpsmT77l3i7j6AKAjLQB3dnSUSiUdSiUS a9atHX2d4woGg9FoTFBxwHQEYNhee7v2hN08wldM5XI5Ho/b9NLvMcRFC+2zec0a IR+rqqpuWL9OewIQUXx42WxOlkm/htL++2xtbRHanur7l33vH3/4Q3H1AUAviqIk ksmQTu0ntM/T+fPnCeoiGQqFIpGoiMqAFRCA4QRtbW3NzU0nPFJ75PJnUvuxbsyu RJs+ffqECfUiKlePG7dk6TIRlW+88Yauri4RlYfngBPvdtTe3u71Cnz9qyrq448/ XjNeyChsANCXJMvBYLCQz+tVcM6c2YJaaYTD4d5e+43GAEaIAAyH8Pl8TU2Th+nb lM/nJUly0uVPcUOAvR7Pf1wxW/ey923ZsvOdncaP/OXdr1lmzZop9HZui7flzrvu ElcfAHSUlKTOzs6yHuefB82ZM6eqSkg3jZ4BfGjCsQjAcI4jI4Ibj/vAncn09/Wl nPTTXOgMpLPPPOsH//AP+tbc+sQTL770ovEjf/P5fDKZdNIfvV20tflbWlqELvG/ /+3///pf/7XQJQBAF4qixBOJsK5n0ObOnTtmTFnHgkcRgOFsBGA4SkuLt6Gh8Zjx SNFoTEtBsZij2jmIawGt+fpffv3Pv/pVHQu++MILT2x9wvi2z6RfE02bNm2Ug8qG p6rq1q1PCr1gDAB6kWQ5EAgohYKONZcvW5bpz+hY8CjtwUmXWU2ANRGA4TQ+X2tV VVVz80BbLEVR5IGPHAf+EBfXAatcLs+ePUfH4tu3bXv4kYeNT7+FQiGRSJB+TeH3 +1paWoQed//Mpz993S+uJwADsIWB888dHdonrI41r7t2cygsZKZ9X1/64MGDIioD VkAAhjO1t7dNmjQpHtfyj3Mu/X6cuNdriqKsX79Br2ovvfji4088bnz6VVU1Ho87 6cq3vUydOrWxsUFc/VKpNG/+gvPPP3/SxIniVgEAXQycfx74SNI5rN515x3vf/CB vjUH9fdnP/zwQxGVASsgAMOxvF6Pg6fYnXXWmYLefek4A2nrE0+88OILxqdf7R9B +6PX/VEDI+T1ev1+n9D73uOqxt119931dXW8AQZgfQPnn7u7tRisb9mtjz/+8rY/ 6FtzUKFQeP99IdEasAICMGA/WsBob28TVLyxoWHuvPmjr3PXnXfueW+P8V2vyuVy LBYLBh0y7MqOxJ3PP+pb3/zmv/70cqFLAIBekpLUcfiw7mXfefvt+357v+5lNcVi cffuPSIqA1ZAAAbsR+h41fPOPe973//+aCpks9lrN2/SPu+Nn3ik0dKvI29924XP 19rS0iL0iw9VVR9/jPG/AOxBURTtg0nEhazenp5NmzfpXnZQIBCIxeKCigPmIgAD 9nPaaadNnNgoqPj/+/f/cMZZZ53ybz944MDNv7zZ+GPPg0i/pps69bTGRlH/cQ76 9Kc+/YvraX8FwB4kWe7u7lb1Pv885shB5auvXiDoC8dgMOjge2RwOQIwYD9nnHF6 TU2NiMqqWlyxYkV1dfUp/N50On3Lr34ZCofNSr99fX2ZTIa2zyby+XwtLV6hr3+L xeKixUvOPvts2l8BsIVkMtnR0SGo+OzZVwj6NjAUCkUiURGVAdMRgAGb8Xo97e3t gooXi6W1a0+6A1ZfKnXPvffs37/fxJdy/f39qVSK9Gsu0c2fNdXjqm+/886GCRN4 AwzA+hRFiUajvb2iPpvEBeBwONzbGxFRGTAdARiwGaEXgJsmT55z5c9H+IsLhcJb b7zx4ksvJpLJqqoqQVsaiXw+n0wmSb/mMmD2b7lc/u53L/v2d77D618AtiDJcldX V1FVBdW/8so5gk5d9QzgUxXORAAGbEboS7a/+Npf/OOPftTd2TnUL8hms+/v2fPO u+92dnZkczlzc+8gRv5axPTp0ydMqBe6hBaA77v/t0w/AmAXiWSyU9j5Z83cuXO1 H40iKhOA4WAEYMBmxE0A1tLFBZ+7oFQqJRKJL3zhC81NTcFQSPsATCTisVgslepT lMLYigqzrvgel7ZbbW+hECN/TdbW5m9paRG9yl987S+umD1b9CoAoAvR5581S5cs yeayIioTgOFgBGDAToROALadIyN/48EgbZ9NNmnSRJ/PN17wXCKmHwGwl4Hzz52d xWJR3BLXbNwQiQppVRWNxvh4hVMRgAE7mTKl3eMRdQHYdhh6ZBFC76Ufdd45565Z t070KgCgC0VRkpIUDASErnLzTTd2DH1raTT6+tIHDx4UURkwHQEYsJMZM2bU19eZ vQtLSKVShw4dNnsXGDiV0NLiFX0pV1XUBx54oJHeVwBsQpLlUCiUz+WErnLvvffs 2rVLROX+/v4PP9wvojJgOgIwYBseT3NbW5vQIat2kclk+vr6uJ5kBcacSvj0pz79 i+uvp/cVALsw4Pyz5smtW196+SURlXO53N69+0RUBkxHAAZso729zev1mr0L82Wz OVmWSL9W4PP5WlvFjj4ac+T278rVa2bOmMH0IwC2MHD+OZk04A7tG6+//sCDD4io rP0jvPfe+yIqA6YjAAO2MXXqaY2NjWbvwmSFQiGRSPb0MPTIEmbOnFFXJ/xMvhay N27a3DBhAm+AAdiCMeefNV0dHTfefJOIysVicffuPSIqA6YjAAP2MGnSxPb2dpcH AEb+Wooxva+0P/Sly1ececYZvP4FYBdaAO7s7CwJPv+syaTTy1csF1G5XC4HAoF4 PCGiOGAuAjBgDy0tLW1tfrN3YaZisRiLaemXkb+W4PO1ejyeqqoq0Qv5ff4N11zD 618AdqEoSiKZDBkyQ0hV1QUL5gu6hxIMBqPRmIjKgLkIwIA9uHwAUqlUisVioRDp 1yqmTp3a2NggehXt2W7FqtWzZs7k9S8AuzDs/POgOXNmC/ouMhgMRcUMGQbMRQAG 7OH002eNHz/e7F2Y40j6jWvPE2ZvBB9pa2vzej2ie18NLORvW79xI69/AdjIwPnn jg7tk8uY5cQFYO1jNxIhAMOBCMCADXi93rY2vwF5w4K0Z4h4PB4Mkn6torm5uaXF W1NTI3ohRVHWrF03ffp0Xv8CsAsjzz8PEheAw+Fwb29ERGXAXG58ngZsx7Xnn0m/ FmTYf41nn3X2goUL6+vqeP0LwC4kWQ4Gg4V83rAVr7xyTmVlpYjK4XBPby8TB+FA BGDABmbMmF5fX2/2LozGyWcLamvze71eAw4jqKr68MOPuPA/ewC2ZvD5Z81VV/1c 0M/kngEEYDgQARiwOo/Ho6WOiooKszdiqGKxGI/H6XplKS0tLc3NTQYcftZc+NUL 586bZ8BCAKCXgfPPiYTB39suWLCgWFRFVCYAw6kIwIDVGTNt1VIGnyGY92s1U6ee 1tjYaMBCxWLp4YcfrqurM2AtANCL8eefNSuWL0tnMiIqE4DhVARgwOqmTZvW0DDB 7F0YJ5fLSZKsfeqavRH8kfb2No/HiM7P5XL529/+zncvu4zeVwDsJSlJnZ2dZQPP P2s2rF8fiwuZ1ssdYDgVARiwNC1y+P0+Qf0tLCh9BF85W43P52tubjKmGVV1dfXt d9zJ6CMA9qIoSjyRCBvet+KG63/RHQiIqByNxoIGtrMGDEMABiytvb3N6/WavQsj lMvleDyupV9Jks3eC/6Iz9c6YYIWSI3oR1UsFmfPufKLX/wir38B2Isp5581t996 6779H4qonEr1HTp0SERlwFwEYMDSDLt1aS5FUZLJJC2vrMnIKVynfea0VWvWMPoI gO0MnH/u6CiXywave8/dv9m9Z4+Iyn19fQcPEoDhQARgwLqam5v8/raqKoeff9Y+ YjOZDMeercnv93u9HmOakKuq+tCDD01oaDBgLQDQkVnnnzW/++1v33r7LRGV0+nM gQMHRFQGzEUABqyrrc3f0tJi9i4E0p4YJEkKBpn0a1E+X+vkyZONmXtULpe/+93v /vjH/8uAtQBAX5IsBwIBpVAwfunHH3ts2/ZtIipnMv379+8XURkwFwEYsK6ZM2c4 dRJMqVRKJBK5XD4WE9K7ErqYNm1qg1HvYysrKx966GFOPgOwI7POP2uee/bZZ597 VkTlbDa7b5+Q28WAuQjAgEX5fD6v1+O8/s/a80E6nc5k+hl0ZHFGXv1VVfWK2XO+ /OUv0/sKgO0MnH+Ox8Nhc9pYvLJjxyOPPiKici6X27t3n4jKgLkIwIBFOe/172D0 7e/vD4eJvlZn5NVfzdlnnb1g4UJ6XwGwIxPPP2ve2bnzvvvvE1E5n89/8MFeEZUB cxGAASsy8uWbAYrFYjKZzOcL0WjU7L3gxHy+1qampurqamOWK5fLjz7yaLUhN40B QHdJSero6BhjxvlnzYf79t12+20iKiuK8t5774uoDJiLAAxYjtfr8fl8Djj8rAWb /v5sf39/Pp+LxeJmbwcjMmnSRK/XW19vxNTfMUdugy9dsvRLX/6yMcsBgL60lBiL x3tMOv+sCQUC113/CxGVVVXds+c9EZUBcxGAActpbW2dOLFx/Pjxhh1A1ddg7s1m +3nla0cGnz749Kc+dc+9W/r6+gxbEQB0JMlyd3e3qihmbSAlS6tWrxZRuVgs7t4t ZMIwYC4CMGBRWgiprKwYN25cXV1dTU2NxV8Il0qlfD6fyWQURSkWS/R2tqn2di39 No8da9BHg6oW33zzTS39ao9ZxqwIAPoaOP98+LCJG1ALhasXLRRRuVwuv/vuLhGV AXMRgAEbmDRp4rhx1VoerqqqqjvSKEj7C8NSynGpqvaZq6iqUjhC+5iMRgm99ub3 +4587WLQVy2lUmnhwoXf/vZ3ent7jVkRAPQ1cP45FjN3qIH2cbxgwXxBjwQdHR2S JIuoDJiIAAzYksfTXHHEmIEBqlW1teNFXNosfkw+n9c+ZccM5JayFl14x+swBje+ GnPk8PNDDz+i/XclSZJhiwKAjkw//zzo5z+/UtCdqUAgyMc9nIcADDiEFmB0r9nT w6s5V9D+42lsbDRy7Jaqqm+++VZNTU0ymSyYNDsEAEbJ9PPPg668co6gwzvBYJDj XXAeAjAAuN3UqadpAdiw5Uql0srlK/7qG9/Q/przzwBsSlGUaCzWa+r550EEYOCk EIABwNWMHzp9xumn33PvFu0vCoVCMpk0cmkA0MvA+eeursHLQeaaM2dOVZWgABxi mgOchwAMAO7V3t6mpV8jG6qVy+W33945eF1NkqR8Pm/Y0gCgo0Qy2dnRYfYuBsye fcW4ceNEVCYAw5EIwADgUga3fR5z5OrvbbfedsHnPz/4f3L+GYBNDZx/jkYt8kOM AAycFAIwALiRz9fa3Nws6JlpKJdefMn6jRsH/1p7fEwkEkauDgB6kWS5q7PTIjPM CcDASSEAA4DrtLS0NDVNHj9+vJGLTpo46YUXXzz6f3L+GYBNKYqSTCaDwaDZG/kI ARg4KQRgAHAXn6+1oaFBxODoYaiqun37jo/3mrbI0UEAOFmSLIdCoXwuZ/ZGPkIA Bk4KARgA3MXgoUeaYrG4etWqr//VXx/9O/l8XpIkI/cAAHrRAnBnR0epVDJ7Ix8R F4C1nB+JEIDhNARgAHAR44ceab5wwedv/tWvPv53EomEoigGbwMARm+wf4GWDM3e yH8hAAMnhQAMAG6hpd/m5mYjhx5p6mrrtu/Ycczf5PwzAJuSZDkYDBas1MKAAAyc FAIwALiC8SN/xwxc/S3u2L694Y9PXPf39/f19Rm5DQDQS1KSOjs6yuWy2Rv5LwRg 4KQQgAHA+fx+v9frqaioMHJRVVU3b9p8yaWXHvP3o9Gode7OAcDIKYoSj8fD4bDZ G/kjIptgBaPRmIjKgIkIwADgcD6fz+NprqqqMnLRcrl84YUXLVu27JiGW9rfj0Qi Ru4EAPQiyXJ3d7dqsRYGdIEGTgoBGACczOdrbW5uFvRsNIwp7e1333NvbW3tMUv3 9fX19/cbvBkA0EVSkjoOHzZ7F8ciAAMnhQAMAI6lpd/JkyfX1NQYvO7YsWPfeOPN ysrKT/5PtL8CYFOKomhp0II/xAjAwEkhAAOAM2npd+LEibW1tQavq6rq1q1PTpky 5ZP/U6FQSCaTBu8HAHQhyXJXZ2exWDR7I8ciAAMnhQAMAA6kpd+Ghsb6+jqD19Ue DZctXfrNb/3Ncf/XeDyuxWODtwQAozcw/jeZDAWDZm/kOAjAwEkhAAOA02jpd8IR Bq87VOOroyx4dBAARsKC43+Pogs0cFIIwADgKFr6raurGyqCCjX1tNNuu/2OTza+ GkT7KwD2ZcHxv0fNmTNbUJ9/AjAciQAMAI4yZUq7x+Mxft2a6ppXX3ttmF/A618A NmXN8b9HXXnlnOM2HRw9jkDDkQjAAOAcZqXfYrG0fdu2hqFfO9P+CoB9WXP87yBV VRcsmD92rJBH+kAgGIvxBhhOQwAGAIcwK/1qj1/33rvl7LPPHubXaI9QFmydCgAn pChKUpKCgYDZGzm+fDa7eOkSEZXL5fK77+4SURkwFwEYAJxAS7/Nzc2CXgIMQ1WL K5Yv/5/f/OYwv0aLvrxDAGBTkiyHQqF8Lmf2Ro5PSiTWrFsrorL2o3v37j0iKgPm IgADgO2ZlX5LpdLf/+Dv51x55fC/LJlMFgoFY7YEAPpKSlJXZ6f2487sjRxfoLvr +htuEFFZVdU9e94TURkwFwEYAOytvb3d4zEh/ZbL5XPOOef66284Ycdp2l8BsKmB 9leJRDgUMnsjQ/pw797b7rhdROVCofD++x+IqAyYiwAMADbW3t7m8XiMT78av8+3 5b77hxp6dBTTjwDYlyTLgUBAsfAZlnfefvu+394vonI+n//gg70iKgPmIgADgF21 tWnpt7miosL4paura1555ZWRLM3rXwD2lZSkjsOHzd7FcHZs3/7oY4+KqJzL5fbu 3SeiMmAuAjAA2FJbm9/j8ZiSfseUy9t3vFJXV3fCX9jf39/X12fAjgBAd4qiRKNR i3+L99yzzz773LMiKmez2X37PhRRGTAXARgA7EdLv83NzZWVlcYvrarq00897W9r G8kvjkQi5XJZ9JYAQARJljs7Oizb/mrQY488sv2VHSIq9/f3f/jhfhGVAXMRgAHA Zvx+v8djWvq94447P/vZz47kF+dyOVmWRW8JAESwfvurQVvuvffdXe+KqJzJZPbv PyCiMmAuAjAA2Im56Xf1ylV/9Y1vjPDX8/oXgH1Jstzd3a0qitkbOYFbb7ll/0Eh MbWvr+/gwUMiKgPmIgADgG2YmH6LxeLll1/+r//60xH++nw+L0mS0C0BgCCKoiQl KRgImL2RE/vFtdcGw0JeU6dSqUOHLN0ADDg1BGAAsAe/39fc3FxVVWX80uVy+aKL L1m6ZMkJR/4eFY1GLX5xDgCGIslyMBgs5PNmb+TE1q1dm0gmRFSOxWKBQFBEZcBc BGAAsAFz0++55563afPmhgkThh/5e1ShUEgmk6I3BgCCJCWps6PDFpc4li5Zks1l RVTuGWDpDtjAqSEAA4DVmZh+NVNPm3rb7bfX1taOMP2O4fUvADtTFCUWi2nhz+yN jMj8efNKZSE/bwnAcCoCMABYmpZ+m5qaRh4+9dXa0vLkU0+f1G/h9S8AW5Nkuauz s1gsmr2REbnqqp+PHSvkeZ4ADKciAAOAdZmbfmtra7dt215RUXFSv4vXvwDsS1GU RCIRsvz0o6PmzJlTVSWkM2I43NPbSwCGAxGAAcCizE2/FRWVr7zySnV19Un9Lpo/ A7A1u0w/Omr27CsEfUyEQuFIJCKiMmAuAjAAWJG56bdcHvOHl19uGHHP56OY/QvA vmw0/eioOXNmC+oQEQqFIpGoiMqAuQjAAGA55qbfUrH4zLPPtbS0nOxvzGazqVRK xJYAwAA2mn40qFAoLFx4taA7wNq/img0JqIyYC4CMABYi8/na242Lf2qqvroo499 5jOfOYXfy20xAPalKIqUSgW6uszeyEno7enZtHmToOIEYDgVARgALMT09HvflvvO POusU/i96XQ6k8noviUAMIYky6FQKJ/Lmb2Rk7B717v33HuviMrFYnH37j0iKgOm IwADgFWYnn5vu/W2Cz7/+VP77bz+BWBrSUnq7OiwVxeDZ55++vkXnhdRuVAovP/+ ByIqA6YjAAOAJZiefjdt2nzppZee2m+XZTlnq9cmAPBxiqLEYrGenh6zN3Jyttx7 77u73hVROZvN7tv3oYjKgOkIwABgPnPTb1Etrlq58q++8Y1T++3lcplRGQBsLSlJ XZ2dtpthftONN3Z2dYqonE6nDxw4KKIyYDoCMACYzPR3v1cvuPq7l112yhXi8bhW RMctAYCRBl7/xuM94bDZGzlpa9esTooZvZ5KpQ4dOiyiMmA6AjAAmMnkd7/F4hX/ /h//+MMfnnKFfD4viXn8AgBjSLLc1dmp/Tw0eyMnbeHVCxQx3z/GYrFAICiiMmA6 AjAAmMbceb/a095P//WnP7388tEUiUQi9uoZAwAfpyhKPB4P2/D1r+aqq34uaAhw zwBaG8KZCMAAYA5z02+pVPrRD3/4s//z76Mp0tfX19/fr9eWAMB4A69/u7qK9rzH MXv2FYI+RAjAcDACMACYwPT0+93vXjZ//vxR1mH0EQBbG3j9m0iEQyGzN3IqVFWd O3duVVWliOLhcLi3l+6GcCYCMAAYzfT0e+mlX1u8eHFjY+No6tD7CoDdSbLc3dVl 0x9lKUlatWa1oOLBYCgajQoqDpiLAAwAhjI9/V500cWLFi9umDBhNHug9xUAu1MU JZFMhoJ2bfX0zs6d991/n6Di3d2BeDwuqDhgLgIwABhHS7/Nzc1VVVWmrF4ul7/0 pS+vXLVqlOl3DIefAdjfwOvf7m5VUczeyCl67JFHtr+yQ0RlVVX37HlPRGXACgjA AGAQ09PvBRd8fu26daNPv7Is53I5vTYGAMaz++tfza233LL/4AERlbPZ3L59+0RU BqyAAAwARjA9/X72s59bv2HD6NNvsViMxWJ6bQwATGH317+atWtWJ8VcRUmn0wcO HBRRGbACAjAACGd6+j3nnHM2X3vd6NPvGAb/ArC/gde/iUTIns2fj1qwYH6xWBRR ORaLBQI2fjcODI8ADABimZ5+zzjjzOtvuEGX9JtKpbLZrC4bAwCzOOD1r2bOnNmC PlkYAgxnIwADgECmp99Zs2bdeNPNuqTfUqnEVAwAdueM17+a2bOvEDRQgAAMZyMA A4Aofr+/ubnJGelXo6VfLQOPvg4AmMgZr39jsdj69evGjhXyJB8KhSORiIjKgBUQ gAFACC39ejzNlZWVpqyue/rl8DMAB3DM69/XXnnloUceFlQ8GAxGozQ7hGMRgAFA fw5Lv3R+BuAMkix3dXUVVdXsjYzW/Vu27Hz3HRGVS6WS9q9IkmQRxQErIAADgM7a 2vzNzc5Jv2Po/AzAERRFiScSYfu//tVcs3FjJCrklHI+n//gg70iKgMWQQAGAD05 7N2vRpIk7XlIl1IAYKKB17+dnYJGBxlswYIFxaKQ99gMAYbjEYABQDfOS79a9NUC sC6lAMBEiqLE4vGecNjsjehjzpw5VVVCPmsYAgzHIwADgD6cl341vb1MwgDgBElJ 6ursdEYre1VV5869iiHAwKkhAAOADhyZfuPxuGr/VjEAMPD6NxbTgp3ZG9FHNBLZ eM1GQcXD4XBvLzOQ4GQEYAAYLUem33Q6nclk9KoGACZKSlJnZ2fZEa9/Nc89+8yz zz0nqHgwGIpGo4KKA1ZAAAaAUXFk+lVVNR6P61UNAEykKIqW6Jx0oePGG67v6u4W UblYLGr/rjgCDWcjAAPAqXNk+h3D3CMATqGlXymVCnZ3O+ln2qKFVxcURUTlXC63 d+8+EZUB6yAAA8Apcmr6TSQSiphHKwAwmCTLoVAon8uZvRE9zZkzW1AHrL6+9MGD zECCwxGAAeBUODX9cvUXgGMoipKUpGAgYPZG9FQoFBYsmC/o04cZSHADAjAAnDTT 0+8555yz+drrdE+/XP0F4CSSLAcCAaVQMHsjevpw797b7rhdUPFwuMdJl6WB4yIA A8DJcWr6HcPUXwAOoihKIpkMBZ32PvOhBx987fXXBBUPhUKRCC2g4XAEYAA4CQ5O v0z9BeAkkix3d3erjutosGH9+lg8JqJyqVQKBoPxeEJEccA6CMAAMFIOTr+yLOec 1SQGgJspihJPJMKhkNkb0d9VV/187FghD/DZbG7fPlpAw/kIwAAwIqan3/PP/28b r7lGRPrVoq8WgPWtCQAmSkpSV1dXqVg0eyM6U1V17tyrBLWATqX6Dh06JKIyYCkE YAA4MdPT72c/+7n1GzaISL+lUika5cYXAOdQFCUWi/X09Ji9Ef11dXbeeNONgorT AhouQQAGgBPw+33Nzc2CvnE/IaHpVxOJRLQldC8LAKbQ0q+USgW7ux35k01oB6xw ONzbGxFUHLAOAjAADMfZ6ZfGVwAcRpLlUCiUd2hTg3Vr1ySSSUHFg8EQB4LgBgRg ABiS6en3S1/68spVqwSlXxpfAXCYgde/khQIBMzeiCg///mVFRUVIipr/+ree+99 EZUBqyEAA8DxOTv99vf39/X16V4WAEw0MPqoq8upB1uEdsDKZDL79x8QURmwGgIw AByHz+fzeBybfhVFSSSY9AjAUQZ/soWcOPpo0L4PPrj9zjsEFacDFtyDAAwAx/L7 fU1NTSKS50iUSqWvfOUry1esFJR+Nb29vSLKAoBZtPQr9/UFuroc2ftq0O233bbv Q1FzeumABfcgAAPAH/H5fM3NZqbfiy66eNHixeLSL22fATjPQO+rcDifzZq9EYEW LVpYKBQEFacDFtyDAAwA/8Xna21qaqqurjZldQPSL22fATiPoihJSQo6t/fVoDmz Z1eNE3Ixhw5YcBUCMAB8xOfzTZ48qaamxpTVDUi/kiTl83kRlQHARJIsd3V1FR39 7Z6UTK5es3rsWCGP7ul0+sCBgyIqAxZEAAaAAT5f66RJk8aPH2/K6gakX+35JpPJ iKgMACZSFCUWj/eEw2ZvRKyHHnjgtTdeF1ScDlhwFQIwADg//ebzeUmSRFQGABMN DP5NpQJdXWZvRLhVq1amUilBxemABVchAANwOy39Tpw4sba21pTVDUi/2hK0NgHg SJIsBwIBRVhrKOuYM2e2oMl85XI5FApFozERxQELIgADcLWWlpZJkybW1dWZsroB 6XcMQ48AOJSiKPFEIuzcwb9HxWKx9evXCboAnMvl9u4VNV0JsCACMAD3amnxTpw4 qb7eyek3Go1qCwkqDgBmGTz8HOzudsNctwcfeOB1YReAo9FYMMgFYLgIARiAS/l8 rRMmaNmz3pTVjUm/sVisWCwKKg4AJnLP4WfNiuXL0sK6GPYM4KAQXIQADMCNtPRb X1/f0NBgyurGpN9kMllwx6MhALdxz+Fnjaqqc+deJegCsCYYDNEnAq5CAAbgOlr6 raura2xsNGV1Y9JvKpXKZrOCigOAiVx1+FnTefjwTb+8WVDxfD7/wQd7BRUHrIkA DMB1pkxp93g8pixtTPrNZDLpdFpQcQAwlyTLwWCwkM+bvRGD3Hbrrz/cv19Q8VSq 79ChQ4KKA9ZEAAbgLo5Pv4z8BeBgrjr8PGj+/HniehnGYrFAgA5YcBcCMAAXMTH9 lsvlL33pyytXrRKafovFovY0I6g4AJhr8PBzKBBwT3P7QqEwb95ccZ8aXACGCxGA AbhFe7uWfpsFzVEcnjHpdwwjfwE42sDh50DAVe39dmzf/uhjjwoqrv2bfP/9DwQV ByyLAAzAFdrb2zwej1np94ILPr923TrR6TcSibikJQwAF3Lh4WfN+nVrtX9qQcVT qdShQ4cFFQcsiwAMwPna2vxa+q2oqDB+aS2Rfvazn1u/YYPo9BuNRt1zJhCA23zU +TkQKLvsB93s2bPHjRM1ACkajQWDXACG6xCAATic3+/T0m9lZaXxS2vp9/zz/9vG a64RnX7j8biqquLqA4C5JFkOBAKKmw4/a0LBwLXXXSfo7JL2CRUKhbQMLKI4YGUE YABO5vP5mpubhIbPoWjPFuecc87ma68TnX6TyaSrbsQBcJuBw8/xeDgcNnsjRvvl zTcd7ugQVDyXy+3du09QccDKCMAAHEtLv5MnT6qpqTF+acPSryzL2kOMuPoAYK6P Dj93d7uwx8FVV/1cXOsKBiDBtQjAAJzJ52udOHFSbe1445fWntJmzpx10803i06/ 6XQ6k8mIqw8ApnPn4ecxR073rF69Slz3inA43NsbEVQcsDICMAAH0tJvQ0NjfX2d KavPmD7jll//ura2Vmj67e/v7+vrE1cfAEynKEosHu9x3+FnzT333L17925BxUul UjAYisfjguoDVkYABuA0kyZNbG5ubmhoMGX1z3z60w8+9LDoVfL5vCRJolcBABMN HH6WpGAw6MLDz5p58+aK+wfPZDL79x8QVBywOAIwAKeZMqXd4/GYsnSb3//4E1tF r6KqKl/bA3A8SZa7u7tVRTF7IybQkv/KlSvEzS/gAjDcjAAMwFFMTL8tXu9TTz8j epVyuRyJcGsLgMMNHH6OxXp6eszeiDmEnn/WBIOhaDQqrj5gZQRgAM7R3q6l32Zx PTOHMXnSpOdfeNGAhXp7ew1YBQBMpKXfpCSF3Hr4eYzg888MQILLEYABOERbm9/j 8YhrmDmM2trabdu2G7B0JBJx7eMgAPfQ0m+gu1tVVbM3Yg7OPwNCEYABOIHf72tu bq6qqjJ+6Zrq6m3bdxiwdDQaLZVKolcBAHMpiqL9uHPzaRfR559DoTBXaeBmBGAA tufztTY1NVVXVxu/dFVl1R+2bRs/Xvi04Xg87tqXIQDcY+DwczIZDLr6/eS8efPK ZVFfd2ofJYFAQJJkQfUB6yMAA7C3lhbv5MmTa2trzVh87Pbt2+vqhE8bTiQSiiv7 oAJwlYG5R6lUOBgsFotm78U0PT0911yzUdydmlSq79ChQ4KKA7ZAAAZgY0dG/noa GiYYv3S5XH7ppZcnTpwoeiFJkvL5vOhVAMB0kiyHQqF8Lmf2Rsx00003dnZ2iqsf jUaDwZC4+oD1EYAB2JhZQ4+KxeIzzzzb2toqeqFUKpXNZkWvAgCmUxQlkUyG3H34 WTNnzpyqKlHtr7QPr3C4JxaLCaoP2AIBGIBdtbe3e70mpF9VVR9+6OGp06aJXiid TmcyGdGrAIDpBg8/hwIBl7f6O7B//y2/vkXcML++vr6DBzn/DLcjAAOwJbOGHmlP affcc++5554reqH+/n7tSUX0KgBgBZIsB4PBguuve6xftzaeSIirz/lnYAwBGIAd +Xw+j8eEoUeqqt54w41/9ud/LnqhfD4vSZLoVQDAChRF0VJfOOT2YFYoFObPnyfu o43zz8AgAjAAm/H5WidPnlxTU2Pwulr6XbF8xf/85jcNWCgej4teBQCsYODwsyQF g8FyuWz2Xkz22KOPbt+xXVx9zj8DgwjAAOykublJU19fb/C6xWLx//zsZz/68f8S vVCpVIpGo6JXAQCLkGS5u7tbZdLbwPjfuUK/BeD8MzCIAAzATkxp+6yF0h98//+5 8qqrDFirt7fXgFUAwAoURYnFYj09PWZvxHzxaHTt+nXiGltw/hk4igAMwDba27X0 2yyuPeZxlcvlL3zhC+vXb2hsbBS9ViQS4RAgAJfQ0m8ymQy6fu7RoGs3bw73hMXV T6X6Dh3i/DMwgAAMwB78fp/H46msFDUdcShnnH7GTTffXFtbO27cOKELRaNRl8// AOAeg3OPwsFgsVg0ey/mKxQK8+bNFfopE4lEQ65vMwYMIgADsAGfr7Wpqam6utrg df0+3xNbnzRgoVgsxlMgAPeQZFnLY/lczuyNWMLjjz26bbvA9leKogSDQUmSxS0B 2AgBGIDVNTc3NTc319XVGbxubW3tjh2vGLBQIpFQaAADwDW0n3jazz1eSB4luv1V LBYLBDhqDnyEAAzA6kxpfFUxduwrr75mwDvnZDJZKBRErwIAFjF4+DkUCHDpY1BP KLTp2s1C21uEQqFIhPkCwEcIwAAsrb29TUu/Bje+KhWLL7740uSmJtELybKc4wQg ADeRZDkQCCh88fef1q5Zk5SS4upns9l9+z4UVx+wHQIwAOsypfGVqqq//93vZ86a JXqhdDqdyWRErwIA1sHco2PIsrx8+bKqqipxS3D+GTgGARiARbW0tDQ1TR4/fryR i2rp97prr7vo4otFL5TNZlOplOhVAMA6BuYeSdLA3CPmvf2nX/3ql0KnE5VKpXA4 HI0y/hf4LwRgABY1derUxsYGI1csFov/8e//8U8//KHohQqFQjIp8MAbAFgNc48+ SVXVuVddVTVO4Ovfvr6+gwcZ/wv8EQIwACtqb2/3eg1tfFUuly+88KJly5Y1NjYK XUh7+IvF+DIegLsw9+iTtj7++Mvb/iB0Ccb/Ap9EAAZgOaZc/T191qybf/mr2tra cePGCV2ot7dXaH0AsBpFUeKJRJgk9seuuuoqoR0e8/l8Mpns6eFDB/gjBGAA1mLK 1d/mpqZnn3vegIUikYjQYY8AYDUDh5+PXP3lp9/HvbNz55b7tgidcUD7K+C4CMAA rGXq1NNEH0I+RkVFxeuvv2HAC+doNMrcSwBuI8lyd3e3qihmb8RaFiyYL/Q6NO2v gKEQgAFYSHt7m9frNXJFVS2+8MILHo/w+8axWIzWLwDcRlGUaDTK1Y9jdHd2Xn/j DUJf/9L+ChgKARiAVfh8rVoQFToO8Riqqt52620XfP7zohdKJpOFQkH0KgBgKVr6 TSSToSCncI+1fNmyTL/YOfCRSCQUCgtdArApAjAAS9DSb0NDQ319vWErlkqlf/v/ /u2ff/IT0QvJspyj8SkAlxmcexQKBLj6cYxEPL5m7ZqKigpxS9D+ChgGARiAJUyZ 0m7AOeSjyuXyZz/7uU2bNom+b5xOpzMZsV/zA4AFSbIcCAQUDr98wto1q5OSJHQJ 2l8BwyAAAzCf3+/zer1Cvw4/dkWfb8t994seepTL5WRZFlcfAKxJURQtg/X09Ji9 EctJSdLylSuEtl1UVTUc7onH4+KWAGyNAAzAZF6vp6mpubbWuLlHY8eOfeONN0W3 fdYeQXj+AOBCWvpNJpPBUGgMc48+gde/gOkIwABMZvDhZy2XPv3U0/62NqGrlMvl SCQidAkAsKCPrv4GgyX63n+CAa9/tU+fUCgcjUbFLQHYHQEYgJkMPvxcLBZXrVz1 V3/916IX0tJvmVcfANxHkuVgIEDf++My4PVvOp0+cOCg0CUAuyMAAzCN1+tpbm4e P96gw89aIr3kkksXL14suvFVNBql6ykAF+Lq7zAMeP07hulHwAgQgAGYxuDDz38y Zcpv7r5HdOOrRCKhPQKKqw8A1sTV3+GtWb1aksW+/s1mc/v27RO6BOAABGAA5jD4 8PPYsRVvvvmm6OUY+QvAnbj6O7xQILDp2s2iX/9Go7FgkPZXwAkQgAGYwOdrbWxs rKurM2Y5VVUfffSxz3zmM0JXyWQy6XRa6BIAYE1c/R3eokULRf/L0er39vbG4wmh qwAOQAAGYAIjDz+XSqX58+Z/97LLhK6Sz+clwa1NAMCauPo7vA/ee++Ou+4cO1bs UzfTj4ARIgADMJrP1+rxeKuqxJ4EO+qCz33uV7f8WugSWsZm5gQAd+Lq7wnNnTt3 zBix/3K0P4Xe3oiWgYWuAjgDARiA0aZNm9rQ0GDMWtXjql97/XXRqzD0CIA7cfX3 hHbs2PHIIw/z+hewDgIwAEO1tflbWlqMWUtV1eeee170cgw9AuBakiwHAgGFq79D 0D6G5s2bV1kptv9isVjs6emJRnn9C4wIARiAcTwDDBr8a8zVX4YeAXAtrv6e0P33 37dz507Rq/D6FzgpBGAAxjGy99VZZ575m7vvEbpEX19ff3+/0CUAwJq09JtIJkMM 3RlaJpNZtGih0MnzY3j9C5w8AjAAg/h8rV6vV/QUxP809q233hI69TeXy8myLK4+ AFjWR1d/AwEugAzjF9ddO9AbTDBe/wIniwAMwCBTp57W2NhowELak9k9d99z7nnn iVuCts8A3IyrvyeUkuVly5dVVVUJXYXXv8ApIAADMILf72tpaRHdBlNTLpcvueTS xYsXCw3btH0G4FqKokSj0d7eXrM3Ymkrli9PZ9KiV+H1L3AKCMAAjDBjxvT6+noD Fpo0adLDDz9SW1sr7tqV9sBRZOAHAFfi6u9IvLd7952/uUvoNZwxvP4FThUBGIBw bW1tLS1eAxZSVfWll15uamoSt4QkSfl8Xlx9ALCswau/wUCgzNXfoRkz+mgMr3+B U0UABiDWpEkTfT6fAaOPyuXyv/zkX356+eXilujv7+/r6xNXHwCsTJLl7u5uldlv w/rNXXe99/57olfh9S9wygjAAMRqb2/3eo0YfeT1eJ5+5llx9bWnjViMRw0ALsXV 35FIxOOrVq8S3ftqDK9/gVEgAAMQSIu+Xq+3urpa9EKqqm7fvkNo4yse+wC41sDV 30QiJH6oj92tWrkiJf6gkPbHoX0kxWJx0QsBjkQABiDQlCntHo/w17/lcvlHP/zR //7Zz8QtQeMrAK41cPVXkoKhEFd/h2dM76sxvP4FRocADECU5uZmn69VXDfmo2rH j9/xyqvi6qdSqWw2K64+AFjWYOOrnnCYq7/DKxQKCxbMr6ysNGCh6ACu5ACniAAM QBRjXv8W1eJDDz00ddo0QfXz+bwkSYKKA4DFSbIcCoXyuZzZG7G6X99yy4GDBwxY SIu+QcZQAaNAAAYghNfraWlpMeD175e++KUbb7pJXH2u/gJwLUVR4olEmKu/JxKP xVavWW1A76tcLtfT0yNJsuiFAAcjAAMQwrDbv++88664+tFotMSdNwCu9NHV32BQ +0lr9l6sbsGCBcWiasBCkUiUVmTAKBGAAehPi76trcJf/2rPZIsXL/nWt74lqL4s yzlO/QFwpY+u/oZCqmpErrO1J7duffGlF8eOFf5QnU6nDxw4KHoVwPEIwAD0Z8zr X09z8zPPPieoOFd/AbgZV39HSJblZcuWGnDfp1QqRaPRcLhH9EKA4xGAAeisubmp tbVV9OxfVVWffvoZv98vqD5XfwG4Fld/R86Ywb9jGH0E6IcADEBn7e3tXq/w17/n n3f+bbffLqg4U38BuJaWfpOSFOLq7whs37bt0cceNeDws6qqvb29jD4CdEEABqCz WbNm1tbWCl1CexR47bXX6+rqRBRPp9OZTEZEZQCwOK7+jlxfKrV02VIDOj+P4fUv oCsCMAA9tbX5W1paRK/y1a9euGzZssbGRt0rF4tF7TlD97IAYAtc/R25NatXS7IR rSLy+Xw0GuOzCdALARiAnmbMmF5fXy96lZdeerm2tlZE05FIJMKpPwDupChKIpFg ys5IvPbqqw8+9KABh5/HHPlgCoXCBiwEuAQBGIBuvF5vW5tf6AOBlk4XzF/wnb/7 OxHFJUnK5/MiKgOAxQ0efg4GAmWGn59IOp1esnhx1TgjDj/39fUdPHjIgIUA9yAA A9CNAdOPxo0b9/rrb4ioXCgUksmkiMoAYH2SLHd3d6uKYvZGbMCwzs/FYjEajfb0 MJUA0BMBGIA+PJ5mn89fVVUpbolyubxh/YZLv/Y1EcU5/AzAtRRF0YIW499G4oXn n3/q6aeMOfxM7ytABAIwAH0Y8Pq3vq5u2/YdIipz+BmAaw1c/U0mQ0GC1onFY7HV a1Yb0/lZ+1SKRCLxeMKAtQBXIQAD0Mfpp88aP368uPqlUumG62/4yp/9me6VB/u+ 6F4WAKxv8OpvKBAocfV3BBYtvLpg1CnxSCRKQzJABAIwAB34/f7WVrHTj2pra3fs eEVEZQ4/A3AtSZYDgYBSKJi9ERt46MEHX33tVWMOP9P7ChCHAAxAB1OnniZiKu9R WkDddM2miy6+WPfKsiznmHgJwJUURYnFYj09PWZvxAaikciatWtEjN/7JFVVY7E4 fy6AIARgAKPl8Xj8fl9lpcD2V9XVNa+99pruZUulUjQa1b0sAFifln6TkhQKBjkC c0KFQmHhwquNeferiUZjQa5kA8IQgAGMVnt7u9crsP2V9nC2ePGSb33rW7pX1tIv 194AuNDg1d9wKFRUVbP3YgPXX/+LQCBgzFr9/f2pVIrRR4A4BGAAozVz5oy6ujpx 9bUA/MYbb+p+8Ex7yOgzZJAjAFiNJMuhUCjPBZAReGfnznu33FtRUWHAWoPnksJh Dj8DAhGAAYyK1+tta/MLPRh2ySWXLlq0SPc7xky8BOBOzD0aub5UaunSpVXjjJh7 NIbBv4AhCMAARkX0+F9VVbdv31FbW6vvG2AG/wJwJ+YejZz2AbRyxYpsLmvMcrlc Lh6PR6MxY5YDXIsADGBUzjjj9JqaGnH1L/jcBb+65RZ9a9L7CoBrSbIcDAYLfAM4 AnffffeePbuNWatcLkci0XA4bMxygJsRgAGcupYWb1tbm7j6RVXdtn2H7oefY7FY sVjUtyYAWJ+iKPF4nJQ1Eh/u23fLr28ROuDg4zj8DBiGAAzg1Ik+/+xrbd365FP6 1iwUCslkUt+aAGB9g4efg4FAmcPPJ5JOp5csXmzY1d98Ph+NahGYw8+AEQjAAE6d 0PPP5XL5lzf/8gtf/KK+ZRl9BMCdJFkOBAJKoWD2Rmxg+bKlmf5+Y9bi8DNgMAIw gFMk+vyzZufOd/QtmM1mU6mUvjUBwPoURYnF4z2krBG4//773n77baHTDT6Ow8+A wQjAAE6R6PPPF1900cZrNulbMxKJlMtlfWsCgMVp6TcpSaFgkB+AJ3To4MEbb7qp qsqgq7/5fF4LwHR+BoxEAAZwik4/fdb48eMFFVdV9fXX36itrdWxJq9/AbiTJMvd 3d2qopi9EasbuPq7ZHFVlUFXfzn8DJiCAAzgVHi93vZ2geefmyZPfvKpp/Wd/cvr XwAuxOHnkVuxfFk6kzFsOQ4/A6YgAAM4FaLPP//gBz/4yU/+RccBSLz+BeBCA52f JSnI4ecR+P3vfvfGm28YdvU3m80lEnEOPwPGIwADOBUzZsyor68TVFxV1O07dtTW 1ur4BpjXvwBcaKDzc3e3wuHnEzly9fdGww4/l0qlSCTa09NjzHIAPo4ADOCkeb1e v99XUVEhqP60qVN/9/sHdCyYy+VkWdaxIABYH4efR0iSpOXLl48zaurvGA4/A6Yi AAM4aa2trVoAFlS8XC7f8qtbLvj853WsyexfAG4zcPg5lQp2d3P4ZXiqqi5etKhY Khq2Yn9/fyQSkSS+lgXMQQAGcNLa29u9XlEXgIvF4q5du3UsqD3cxONxHQsCgPVJ shwMBgv5vNkbsbobb7ihq7vLsOW0j6RYLNbT02vYigCOQQAGcNLOPPOM6upqQcVn TJ9+/29/p2NBLf1qDxw6FgQAi1MUJZFIhEIhszdidS+9+OITW58Qd6Pnk6LRaDDI nwtgJgIwgJMjdACSiPPPvb180Q7ARQYPP4eCwVLRuGO9dtQTDm/YuMGwxleaVCp1 6NBhw5YDcFwEYAAnR+gAJFUt7t6t5/ln7Wkjm83qWBAALE6S5VAolM/lzN6IpfX3 9y9evKiystKwFfP5fDyeiEQihq0I4LgIwABOzrRpUxsaGgQV97W2PvLoYzpOP+L1 LwBXURQlKUnBQMDsjViaqqprVq9KZzKGrVgqlaLRWJiO3IAFEIABnJyzzjpTx4B6 jMsu+97ll1/e2NioSzWmHwFwGwb/jsQdd9yxd+8HRq7I3CPAOgjAAE6C0AvAqqr+ 4Q/b6uvr9QrY2gNHkStwAFxDy73xRCJM76thvf3WW1vu22Lk4ef0EXR+BiyCAAzg JAgdgFRXW7t9xys6FuT8MwBXSUpSV2cnY8+HEQqFNm7cIO4c0ycVCoVEIkH6BayD AAzgJEydeppe55M/6cI//+qma6/Vq1o6nc4YeL8LAMylKEo0GuWLv2FoWXTh1QvG Gjj0qFQqxWKxUIirv4CFEIABnIQzzji9pqZGROVyufzII49+6lOf0qsgT4EA3GNg 9JEkBYJB7Yep2XuxrtWrVsqplJErcvUXsCACMICR8nq9bW3+sWOF/NwoFou7duk2 AEmrpj126FUNACxOkuVgMFjI583eiHX95q679ry3R9BH2HFx9RewJgIwgJFqbW31 +32Cijc3NW198im97mXJspxjBiYAdxgYfZRMagHY7I1Y12uvvvrAgw9UGHj4mau/ gGURgAGM1JQp7R6PqA5YF371wqXLlul1wZjzzwDcQ5Ll7u5uldFHQ4hGImvWrjGy 8VW5XI5Go1z9BayJAAxgpKZPnzZhwgQRlbVnhQcfeHDKn/yJLg8oqqrG4/HR1wEA 62P00fAymcySJYuNHHo0hqu/gLURgAGM1FlnnSnoG3R9LwCnUqlsNqtXNQCwsqQk dXd1MfP8uFRVXbF8eS5v6I2YdDqTTvdx+BmwLAIwgBHxer3t7W2CijdNbnru+ef1 qsb5ZwAuoShKLB7vCXPU9vhuuunGzs5OI1cceCGv/YmQfgELIwADGJHW1ha/3y+o +CUXX7xh4zW6lCqXy5FIRJdSAGBxSUnq6uwslUpmb8SKnn/uuaeefsrIxldM/QVs gQAMYESEdsDasG79JV/7mi6lMplMOp3WpRQAWNnA699YrKenx+yNWFFXZ+e1111r ZOOrMVz9BWyCAAxgRKZNm9rQ0CCisqqqu3fv0aua9vzBXTgAbsDr36Ekk8mVK1ZU jasyctFUKnXo0GEjVwRwagjAAEbk9NNnjR8/XkTlsWPHvv32Tr2qcQEYgBsoihKN RvmJ90mFQmHxooVlYxfNZnPJZCISiRq7LIBTQQAGcGJer8fv9wu6SdXe1vbY40/o Ukp7IkwkErqUAgArS0pSZ2dnmde/n7B+3dq4sR8EqqoeOYvOlxGAPRCAAZxYS4u3 rU1UC+iv/+XXV6xcqUspBiABcANu/w7lvi1bdr6zc+xY455vy+VyNBoLMYcZsA8C MIATa21t9ft9goqvXbP2L/77f9elVCQS0Z5FdCkFAJbF7d/jeuP113/7u99WVlYa uSiNrwDbIQADODFxLaCLxeI777yr1+FqrsMBcDxm/x7X5s2bgsGgwek3fQSHnwF7 IQADODFxLaCLxdKuXbt0KcUFYABuIMlyV2cn7e4/7rlnn33m2WeMPPmsyefzyWSS 9AvYDgEYwInNmjWztrZWROW6uvrt27frUqqvr6+/v1+XUgBgTYqixBOJMDdOPyYa iaxbv87gd7/FYjEa5Ro2YEsEYAAndtZZZ44bN05E5amnnbblvvt1Kc4EYACOJ8ly d3e3qihmb8Qqstns1VcvEPQJNZRyuax94gSDfA0B2BIBGMAJeDye9vY2QUfLLrzw oqVLlzY2No6+FBeAATiboihJSQoGAmZvxCpUVV149dXlMUb3PqTxFWBrBGAAJ+D1 erUALKj4kiVL//Iv/3L0X96Xy+VIJKLLlgDAmiRZDgaDhXze7I1Yxc0339TR0WHw oul0JhaLSpJs8LoA9EIABnACra0tfr9fROVSqbRz5zu6tIDO5/OSJI2+DgBYVlKS Ojs6GPY2aO8HH9x6260GX/2l8RXgAARgACfg87X6fEKGAKuqunv3Hl1KpVKpbDar SykAsCBFUaKxWC9dl45IJBKrVq6sGldl5KKqWozHY+EwfwSAvRGAAZyAuCHAmp07 39GlTjwe1+K0LqUAwIKYfnSU9tN+8aJFxZKh/yrK5XI0GgvRfxuwPwIwgBMQNwR4 0sRJL7z4oi6l6IAFwMEG5pwnk6EgjZcGmHL1l8ZXgGMQgAGcgLghwLNmzNxy//26 lCIAA3Aw2l8d9cbrr//u97/TpXnEyPX19R08eMjIFQGIQwAGcAJnnnlGdXW1iMpf +dOvXLNp0+hbQBeLxVgspsuWAMCCaH81KBKJrF27xuCpv9lsNplMRiJRIxcFIA4B GMAJnHvuOYK+a//bv/32z372s9EPAc7lcrLMRAoAzqQoSiwW63F9+ytTpv5q//Lj 8ThtnwEnIQADGI7X62lvbxdUfOPGjX/2Z38++u/yaQENwMEkWe7u6qLP3y9vvvlw x2EjVyyVStFoLBwOG7koANEIwACG4/V629vbRFTWcQgwLaABOFgimew0vOeT1by3 e/cdd91p8NRfLf0GaTwGOA4BGMBwWlpa2tr8IioXVXWXTkOA6YAFwKkGxv9Goy7/ KdeXSi1dutTgqb+0fQacigAMYDg+X6vP5xNRWVXV3QRgABjWwPjfrq6iuw+5rFi+ LJ3JGLliJpNJJBLxeMLIRQEYgwAMYDjiArD282fnzp26FCIAA3AkRVGSkhQMBMze iJme3Lr1xZdeHDvWuEfWfD6fTCZpfAU4FQEYwHCmTGn3eDwiKtfW1u7Y8cro6zAD CYBTSbIcCofzLm7y19vTs279OiPnHg1+poTDbu+5DTgYARjAcKZOPW30Y4qOq83v f/yJraOvk8/nJUkafR0AsJqB88+dnVokM3sj5lBVdfGiRcWScf/45XI5Go2FQiHD VgRgPAIwgOFMmzatoWGCiMrnn3vebXfcMfo6mUwmnU6Pvg4AWI3L+z9vuffed3e9 a+SKNL4C3IAADGA4M2ZMr6+vF1H5T7/85U2brx39wTZZlnO5nC5bAgDrcHn/51Ao tHHjBiMPP2cymf37Dxi2HACzEIABDGfWrJm1tbUiKl988SWLFy8e/fnqRCKhPSbq siUAsA5Jlru7ulw75Hzh1VcrqnE/2wuFgvZpQuMrwA0IwACGc8YZp9fU1Iio/Ld/ ++2f/exnow/AsVjMtRfkADhYUpI6Dh82exfmeObpp597/jnDOj+XSqVIJNrTQ+Mr wBUIwACGc/bZZ1VVVYmo/K8/vfz73/ve6AOwa88HAnAwRVFisZg7I5ksy8uWLTXs 8PORts/xcDhszHIATEcABjCcc889p6KiQkTlTdds+tOvfGX0jzgEYADOI8lyIBBQ CgWzN2KCDevXxeJxY9YqlUrRaJShR4CrEIABDKm5uflP/mSKoOJPPflUS2vr6OsQ gAE4jxaAOw4fLpfLZm/EaMHu7s3XXVtZWWnMctFoLBik7TPgLgRgAEPyer3t7W0i KheLxV27dutSigAMwGEURUkkkyFXBrMF8+cbNvg3lUodOuTSW9aAmxGAAQxJYABW 1V2794y+TrlcjkQio68DANYhyXIoHM5ns2ZvxGjb/vCHxx5/zJjeV7lcLpFIRCJR A9YCYCkEYABDamnxtrUJCcCqqu7WIwAfaV4SG30dALAOdw5A0v55582ba8zh58HP Dq7+Au5EAAYwpJaWlrY2v4jKqlrcvVuHI9DaA1PcqF4pAGAMdw5AeuD3v3/jzTeM WYurv4CbEYABDKm1tcXvFxKAS8XSu7t2jb5OoVBIJpOjrwMAFqEoSjyRCIdCZm/E UKqqzp17laCpe8dIpfoOHTpkwEIArIkADGBIra2tfr9PSOlyeec7746+TD6flyRp 9HUAwCIGLgCHQvlczuyNGMqw17/ap0YymezpoXsi4F4EYABD8vlafT4hAbiiouKt t94efZ1sNptKpUZfBwAswoUXgA17/Xtk6m8sHA6LXgiAlRGAAQxJXAAeN27c66/r 8GV/JpNJp9OjrwMAFuHCC8Bbn3ji5T+8bMBCsVgsEODqL+B2BGAAQxIXgGtra3fs eGX0dbT0q2Xg0dcBACsYmACcSIRcdgF43rx55XJJ9CrZbFYLwPF4QvRCACyOAAxg SOICcNPkyc89/8Lo6/T19fX394++DgBYgQsnAPeEQpuu3Sx69i9zjwAcRQAGMCRx AbjN539869bR10mlUlk3PSkCcLaBC8Dd3aqimL0R42xYvy4mfpodh58BHEUABjAk cQG4taXlyaeeHn0dWZZzLuuVCsDBtADc0dFRLgk/D2wR2Wx24cKrRbe/0lbp7e2V JFnoKgDsggAMYEjiArDmwQce/Mxpp42yCAEYgJMkksnOjg6zd2Gcxx59dPuO7UKX KJVKkUi0p4fDzwA+QgAGMKQpU9o9Ho+IyuVy+R095gBLkpTP50dfBwBMpyhKLB7v cdOQnkULFxaUgtAlOPwM4BgEYABDmjr1tMbGRhGVi8Xirl27R18nmUwWCmIfngDA GJIsB4PBgmu+1DPg/LP2AREdEBO3BADbIQADGNK0aVMbGhpEVC6q6q7de0ZfhwAM wDG0ANzV1aX9eDR7IwZ5cusTL70sdvyvFn2DQV7/AvgjBGAAQ5o+fdqECRNEVFYV Zfee90ZfhwAMwDEGOmAdPlwul83eiEGWL1uW6Rc4yL2/vz+VSvX09IpbAoAdEYAB DGnGjOn19fUiKququps3wADwMW7rgDVnzmyh558jkUgo5KIL1QBGiAAMYEgzZsyo r68TUZkADAAf57YOWNFIZMPGDWPHinoQzWT69+/fL6g4AFsjAAMY0syZM+rqCMAA IJwky6FQKO+auW533Xnn+x+8L64+r38BDIUADGBIs2bNrK2tFVG5WCzt2rVr9HUI wACcQQvA3d3dqqKYvRGDLFp4dUHYP2wul9u7d5+g4gDsjgAMYEjiAnC5POadd94Z fR0CMABn0AJwZ0dHqVQyeyMGmTP7iqpx4wQVZ/YvgGEQgAEM6fTTZ40fP15E5bFj x7799s7R15EkKe+amZkAHCwpSR2HD5u9C4NkMpmlS5dUVFSIKF4qlcLhnmg0KqI4 AAcgAAMY0hlnnF5TUyOicmVF5ZtvvTX6OgRgAM4Qj8e7urrM3oX+CoVCdXX1MX/z 9ddfe/DBBwWtmE6nDxw4KKg4AAcgAAMYkrgAXFVZ+cabOgRgWZZzrukZA8CpFEWJ xmK9PT1mb+S/ZLPZysrKiiOO/s2P/3WpVNL+z2P+36P/a/mIYrGo/f1xnzjq/Js7 73xPWAcszj8DGB4BGMCQzjzzjE9+c6+L8TXjX3n11dHXIQADcABJloPBYMGk8yxa cM3n81pMHcy3gk4mf9zqVSvlVEpEZS11h0KhaDQmojgAZyAAA/+3vTuBbqQ8EDwu S7JkSZbvq213A+6DprvJwTJAuCEwMJBkXmbeZubNJjOZ3X3QOQgkNFdOQiBcYQIJ V9idSTLJ5s3Mzkw2CR1y00AaAi+EhPR9uJtu37Ily7pVVdJ+peoWwrZk2arSVf8f iVu25U/lPqTv76r6CnkZF8Bul2vniy+VPs7c3FwsFit9HACoIHUJ6GPHZFmu9IaU yR133CFa1YiRWf8ZwJIIYAB5GRjAbs/OnTtLHycUCkWj0dLHAYAKMtsS0Nu23bzw uGhd+HzTo6Mc/wygEAIYQF6bN28yaI7S3tb+q2efLX2ccDgciURKHwcAKshUS0DL snzHHbfb7XYjBp9QTRoxMoC6QQADyMu4AO7t6f3JT39a+jiifkUDlz4OAFTQjN9/ 7I03Kr0VZTI3O3vv/fcZNPjY2PjU1JRBgwOoDwQwgLyMC+BVfat+/MwzpY9DAAOo dZIkTc/MTIyPV3pDyuTA/v3f/NY3DRp8dHSUFbAAFEYAA8jLuAAe6B94evv20seJ RqOhUKj0cQCgUmaDwbGxsYRpFrTf+etfP739aSNGlmVl165dRowMoJ4QwADy2rJl s0Gnaa1ZveYHP/xh6ePE4/FgMFj6OABQKSKAR0ZGpGSy0htSJk//8Ic7X3rRiJFZ AhpAMQhgAHmdfvoGl8tlxMhnnXXWk09+o/Tdy4lEYnZ2VpdNAoCKMNs1kL77z/+8 e+8eI0aORCIHDx4yYmQA9YQABpDX+vXrPB6PESNfdtnld955Z0tLS4njJJPJQCCg yyYBQEWY7RpI/+upp4aPDBsxcigUOnzYkJEB1BMCGEBeGzasd7vdRox85ZVXfvaz nys9gGVZnpmZ0WWTAKAiTHUNJOHxRx89PjpixMhcBBhAMQhgAHlVfwArijI9zYKf AGqYPxB44+jRSm9F+Tz81a9OThlyqd7x8YnJSS4CDGAJBDCAvKo/gFOplM/n02WT AKAipmdmjh87VumtKJ8HH3jAH/AbMfKEigAGsAQCGEBexgXw1Vdffccdny49gAV+ 3g+gdqkXAZ6eFt1W6Q0pny/fc08obMjl6whgAMUggAHkZdwq0O997/u2bdtGAAMw ObNdBNhCAAOoNAIYQF7GBfCPfvR0b29v6ZdBshDAAGqZ2S4CbCGAAVQaAQwgL+MC +PnnnvfqsfvXQgADqGUigI8dO6aY5iLAFgIYQKURwADyIoABwFAigI8ePZo2zUWA LQQwgEojgAHkRQADgKHMdhFgCwEMoNIIYAB5EcAAYCizXQTYQgADqDQCGEBeNRHA Pp8vZaajBwHUk5mZmWNmugiwxcgAnp6eHhkZNWJkAPWEAAbMqLu7q6GhwWq12u32 1tZWXVZjXhYdA1jMeBRF0WUoACgzn2i248crvRVlZVwALyRJUjAYlGU5lUql02mf b7o8jwugmhHAQJ3TWlfUbmOj3eFwircid202m/hQBbdKxwD2+/1iiqPLUABQTuK5 y+fzmeE8juxxOqJFH7j/vkg0Wv5tEAGsKIqkkpPJhHibTlPFgBkRwEC9EcVrtYrc bXQ6Re42OhwO8W6lN2q+b33zW6v6+5ubm8VGapu34iCfnZ1NJBK6bh0AlMNsMDg6 Opqsi2cwLXG1yBTEu6J1RWvGYjHxDYrn+Xg87g8EJsbHXnnlFavNVuntPUFsZzKZ FNspXkfEW/EuPQzUPQIYqHmZfbxWh6OxqalJ9KTdbq/s3t1inLLmlJ7e3tWrV/f1 9XqbvW6P29XkcjY1eb3e1pYWm90uur2lpUV8R7al5knBYFDMq8qz2QCgIxHAI8eP 19wxLFrrpjLExotnYPE8nFKUQCDg9/tnZwOhUCgWEx+Oi6pMSkmthwXxq2hk8axe hT+W1YiAF90uNltsvOjidJoeBupQtc+SASyqra3VkeHxeLI7UWuImGGIeYYW6mLj xWyoIXNCsqOxsckluFtbW1cPDp5yyind3d2dXV39q1Y1Ohyih0UVi0/nFr6YaYXD 4Zr7HQAAEcDHjh1TZLnSG7I4kayxWEw8M2tPsNpOXfGRaCQiQndyctLnmwoG50T9 RmNR8V2ooZtOWxsa0pkvzz5RazfmvVsTxLcsYjgSiSQzZmeDld4iADqomecgAJbM zl5nhojAip/HqxdRwvNui7faHgbxDYpv0+lwuD3NXq+3s7NzaGho/bp1q/r716xe LVJZTE3CoZC4W0dnpzZFkyRp3tllHre7/Kt8AcCSRAC/cfRoFa5jL55Ip32+cCQy GwiMjIyIFx3xkVBItO5cIBAQuStLctpy4qm74aTsu5XbcKNoh3aL+E9ksFsYqGl1 +CQF1B/RvQ6Hw5Wx5CHBdSYnicUNMeNK2+x2p8PZ1tbqcnsyn0l3dXa53S7xSbfH 0+hobGiwuj3qf57mZvG/0049VdQyeQyg2ogAPjI8XJGHTiaTMz7f2MT4+Nj49LRv ZsY/NzeXSCZlWRYBK54wtR9EiprN/owyuyM3m7t12bpL0kpYPbc5maSEgVpkxmcu oIb09PQ4HI1tbW12u73S21JF0jksmUmYmK5pUzHtDC5tfmazqecSt7W2dHR0tAje lkanQ9xXVLHb7fZ6veLG2qGhwYEB8hhA+QUCgaNHjxo0eDgcnpo8wS8CNxAIhUOJ REJ7hizmGKLcw3MsZs3dAsTv5OzsbDIpTU1NVXpbACwDz2VANWpra/Woml2uJuYc OlIURZ3SpdNWdRUWm9PR2NLS2t7W2twsYtjTqK6YbXN7PGoeN4uPedeuXSvyuKmp SftyChmAjmb8/mNvvLGyr41EItMivHw+8cbvnwnOBoNzc9FoVJKldCot5nd1c5pM lROvKbFYPBIJiz8RThIGagLPjEDVGRgYaGnxOhwO5i5lpq1Tajm5S9lutzd7PNoi 1R6Px+VyNTrU9cbUdzxu9ejqlpbVg4OnnnKK1+vNDrIwki10MoAM7fkh+4QwPT19 /PjxhXeLxWKzfv/0jChcXyAQUE+9VVf7C0WiMUWR6dsqJDI4mUzOzYVGR0crvS0A lsBTJ1BF+vv7Rfo6nU6mNdXpxA7kDLWQbTaH05mpY5HHTa6mpmav12pTD1ZXP+Z2 aycii1Jes3q16GTxJ5s7GqkM1IF5TVvYyMjIb199NZFZSFnUr0hc/4w/FA5Fo9Gk JGWXxydua5T440skEiKDx8bGKr0tAPLi6RWoCqtW9WnFxOV8alpmpVD1Qpfauw0N VptVnctqF6xyudxNmUW8RRSLMLZkVpfR1jbLTWXxP/GRhYMvGsxFoquBwrL/vpb7 j2VsfPwPf/hDUr3qbWxmeiYwG5gLzoUjYVFBkUg4kRRZKymKYnnragWoY6lUKhqN RiKR8fGJSm8LgEXwLAxU3uDgQHt7u9mWdzYzbXlVbRGvk8uqWjMaxMw7sy9ZlLKj 0W53qJe8crvdLmdTU+bk5bT4lPiAeCum6cU/4ruvuKKttXXJu+U2Ns2MWqHL31vf 9PTw8PDs7GxaUST1iq+zc6E5kbKRqBhb1ExUNK34NZFMKhkLV+ADcom/JAH1IlIc EQ1UHZ6ygUrq6+trafG6XC7mT8gnt5Yt2rP2W6+6WQy7YLOr8ewSad3kdDia1B3P IrVdzd5md+YoblEO4mGUVMqjrv/lXb9+fXdXl1Hf1VsV2LlNh1ezKvmDE+168ODB UCgUCYdtmR6NZPa/iTfhUDgWj8VicfFGtGsiEVdvx+NKSo1Y8SatrXWcTouQ5aeQ 0FdmfazY3FxoYoJdwUAVYc4NVEx/f397exuTe1SnbHg3qLdPvFyou7qsNm2vl1oa 6mLaVrWnHc5G0diNjTZrg3jbaG8ULWGz2xyNDnvmE6K9G9UbIsJdTqfTbrM1Zjkc sUyhiNHE3cSITZkfCYkkt6jHRwyWrcOxXKI8R0ZGLJkVicVfFRGXSiol8lKEpUv9 aYtLSialk2RFSYgAjcdkWRbvibuJX8V/SSmpyGqOqu9IkpJKy+q9ZZGr8URSXZhO TdXUiR8DpcTnM6cYpC0NDerJBuyDRZUTf50DgVnOCgaqBy8YQGVw2DNQjOyu7+zy Y9r+OvWWGkDZG/O/UBRReuFHUVjub9iJn3y85fc525najeUeiQCYE4dDA1WF1y2g 3Hp6ur1er8fjYb0rAADMIJVKRSKRUCg0NeWr9LYAZkcAA2XV19fb2tra1NTEbhMA AMxDPU0gHg8GgxMTk5XeFsDUmIID5UP9AgBgWjQwUA2YhQNlQv0CAGByNDBQcUzE gXKgfgEAgIUGBiqNuThguJ6envb2NuoXAABYTjZwIDA7NTVV6W0BTIfpOGCsVav6 vF6vK3Nd00pvCwAAqAqigWOxWCgUGh+fqPS2AObCjBww1saNpzc1NVV6KwAAQNWJ x+P79u2v9FYA5kIAAwYaHBzo6Ojger8AAGChVCrl9/tHRkYrvSGAiRDAgFH6+1eJ +rXb7ZXeEAAAUKVkWRYNPDY2XukNAcyCAAYM0dfX297e7nQ6K70hAACgqiUSiUAg wKLQQHkQwIAhhoaGmps9HPwMAAAKS6VS4XBkeHi40hsCmAIBDOivv78/c/CzrdIb AgAAaoAsK5kDoccqvSFA/SOAAZ319HR3dXU5HI5KbwgAAKgZyWRyenp6aspX6Q0B 6hwBDOhsaOi05ubmmjj4WVEU8dZZdKun0ieeMtLq9QvTqZT4vyLeNFga0pmPNVhV XPEYAKAX8XKzZvVqu82enbRaG6w5E9jMS85bXnZOfES8GM3Ozo6Nj4sbNlsNHJOV ORA6PDx8pNIbAtQ55qmAnvr6+rq6Oqtz5WdZlkWddrR39Pb29q1addmll15z7bWN jY26DC4mKErG5NTUzp07R0eOT4yNj46NTU1NzgaDyaQk7lKdvy0AgIpTX0QyL1JO p7O9vV28mHZ0dvX09Jx//vmXXHJJiYNLkvTj7duf3bFjYnx8cnLSH/CL1KzOlyTx Sj09PTMxMVHpDQHqGQEM6GnDhvUul6tKdoHKsmKz2Qb6+9/2trddecUVF11yiZa7 YioQi8XEdupVv7nyDS5L0m9efvn5F56fHBsfnxjfu3evbbHJR5X81gEAdKceOqQo aUuDw9HY2tLa29Pd3il0nXvuOVdddfW8Vw19X6rmjSbefeG5537+i1+8/vrro2Nj iqJUybId4rdIbOeBAwcrvSFAPWOuCehmYEBd+6qyx1llXsUb161de/4FF/zN3/xN T09PBTdmnnnzj1AotOuPf3zpNy/t2bNn2ueb8fvD4bAsy+JT2gHk82KYNgaA6ney ci3ixaittbW7u6u1tbWzq2toaO173/OeVf39uXc29AeyxZuamvre97734s6dhw4f lmWp4q/jfr9/dJTVsACjMKEEdLNp0xmVWvtKkWW3233uee/advPNq9esqZIpRTEW 3VSfz/f711579dVX9x3YP+Pz+QOBWDQqybJ4wmrIObk6N4nJYwAoG+20F3HD0djY 0vJm5Z42tPbaa64ZHBzMvbP2PC9uVO2rUu4r0fFjx77y0EMv/+alaDS66JFKZZBM Jvfs2VuRhwbMgCkjoI/BwYGOjo7yr32VSqUvueiiz3/hC61tbbUSvUVatI2npqZe f/0Pr/3utf0H9k9N+YLBYCQSTiQSlpwG1m7MexcAsCwicUXo2mw2p8PR3t7e09PT 1tbe0dl51llnXXXVVU6nM/fO1V+5Rcq+9ARnZ+/64hefe+EFq7XcLyKpVMrv94+M jJb5cQGTYF4I6KCvr7ezs7PcL/lpy3vf974bb7xRPHRZH7cKLDrTikajf3z99f37 9+/Zs+fI0SOBQGBubi4eiysppUH93Vq8kMljAKYlQiulKA1Wq3gibW1p6erq8ra0 tLW1rVlzyrvOO++cc8+dd/8aOrxILzMzM4888siPfvjDMk+ZxW+1eOiJicmyPipg Dsz8AB2sXTvU3NxctpSSZfmqK//0c1/4gnhEU01EirToFG18fHz37l2vv/76gQMH fT5fKCTqOJRIxLWzjk9e3mmRNqaQAdQubS+u1WrVjlXu6ups9npbW9sGBwfPPvvs Cy+8cN6BS3WzI1cv2m+I+D380he/+NOf/6xsa0eLRwyHw4cPD5fn4QBTYWIHlKr8 lz565OFHLi75shDmlG9u5/f7D+zff/DgwX379x87diwSDodCoeBcUEomZUURMxH1 upLptIjhhZFMIQOoiOyJuFrfNjd729vbO9rbWlrbWtvazjzzzHP+5E8GV6+e91Uk 7oo9/9xzN950Y9kejksiAQZh3gaUqpyXPuru6vrf//hPa9asKcNjmVO+A/x8Pt/h Q4eGh4cPHjr4xhtvzM7ORjLisbgkS+mMbCdbFitkOhlA8TJxmxK/iqcOu93udDhb W1s6Ojo8qua+VatE315++eXiyWrh15rwQOWyOXbs2P/8H//dNz1dhsfikkiAQZiQ ASXp71/V2dlZnksmdHV2fee73+3r6yvDYyGfAjtPxsfHjx45IvL48OHDx0dGgsHZ cDgSi0WjkWgimZBlOZVKiRmNnSkpYGLZqwSJsrXZRNk6vN7mtta2lpYWl9vt9rj7 +tS4vfjii+etMqVh/23FTUxMfOiDH5yeKUcDK4oyMzMzNjZehscCzIMABkpy+ukb mpqayrBzT8yZvv2tb7/9He8w+oFQuuwM1bJgkjo3N/d/vve9yYmJqLr/OBwMBkPq 6cihcDiclKRUSj3cusGqYo8xUCuyTZu5Upu10W53OkXWekXTepu9TleTw+Hs7Ozs 6e3dvGnT+eefn+96AcRtrfjD73//dx/+u/K89Mfj8f37Dxj9QICpMMECVq6/v7+z s6MMu3/FS+A9X7r72ve+1+gHgtGKnOAmEokXX9y5d+8+n8/n988kE8lkIjGnrts1 J7pZfFZWlFQqpR16LSZhBDOgixNn1WZ+DiXetVmtdlWj2+3yeJo9bpeoWrujUV0z ubVNNO26des2btiwdv36AmMW+IkYatf2H/3oM5/7bBmeeDM7gf1jY2NGPxBgHkyY gJUr29m/7zrvXQ8/8ojD4TD6gVA9ljVpFjOkg/v379u/f/jIcMAfEJ2syIosS5mz lGOxeDwaFb/EJFmEs3oktnowtsWiLetloZ9R+7QfBml/sbWfCmk/GLJm3oiEFf+I mgSnSvzq9rhtNrvVZvU2e1taW1rb2tcNDW3YsGF1ESssELQQksnkTTfe+NJvXjL6 gTgTGNAdMx5ghVatWtXVVY6zf8Wc7lvf+vY73vlOox8Ita6UefnRI0cCfv/x0dHj x49HM2IxNZpFH4usSCYlKZlIiF8y/8mZkk6o4pld0Yr6Nn1ij3S2Q9RFs9OZw0Jz lgfLXRUsW93qxahOfjb7KZq8hmT/6LXbFu3PXZPz55j9Y7WqP3nJ5KnIVBGi6tmw VlGmok61Q4gbHY2NdnVHq8PhsDeqS0CJEcXfMpGwTU1qzLrdHpfbPTigamttPfW0 05a7zbn/XiykLJbv96+99uEP/11DngPadSSeYaenZ8bHORMY0AfTC2CFhoZOa25u zncql47e//6/uOmmm1paWox+IGBeElgMroLQ3Jx2w7vYX2/ts7OzsyfeDYW0rg6H w+nMDVHpopxD4fCUz6ddzzlXUl14TDFoy+uV2+3O3rbb7T3d3d7mZnFD+7iY6Isn PUvmojter1e7W1tbmyXPn6C+Fv7ltFCtqKi5ubmHH374+9//T6MfSDz1iee94eEj Rj8QYBIEMLASXV1dvb09ZZh4nXrKqY8+9lhPTzkeC6hFi3YRdEFeAgWIJ5+pqamP f+xjR984WobHmpycmi7L5ZeAukcAAysxMDDQ0dFu9PHPsiw/9dRT73rX+YY+CgAA WJmXXnrxuuuus9vthj6Koih+f2B0dNTQRwFMggAGVmLLls1Gv9oJl1562Z133tna 2mr0AwEAgBUIBoPilXrHjmeNfiBZlnft2m30owBmQAADyzY4ONDR0WH02b8ul+sb 33hq48aNHIIIAEB1kiRp3759119/ndHnYqRSKb/fPzLCTmCgVAQwsGxluPqReJ27 7977/uyaa4x7CAAAoItnfvzj2++43bifjGtLrHM9JEAXBDCwbJs3bzJ6r+zbtpz5 5FNPicw29FEAAEDpRJpuve6613f90YjB0yevKybL8u7de4x4CMBUCGBg2Yw+AVi8 wj355DcuuOAC4x4CAADoaOfOnVu3Xq/v9CCde0ntzFJYnAYMlI4ABpanDCcAn7l5 y5NPPZV7QU4AAFDNotHo1uuu++PuXXoNOK9+tY9wGjBQOgIYWB6jTwBWFOXrX/v6 JZdeatD4AADACM/t2HHDJ27Q5RKJC+tXw2nAQOkIYGB5jD4BuKO94//++793dHQY 9xAAAEB3k5OTH/jAf52bmytlkHzpq+E0YKB0BDCwPEafAPyea99z4003NTU12Ww2 q9VqyzB0xWkAAFA6kb733XffM8/8eMUjFK5fC6cBA3pgVg0sg9EnAEuSdNMnP3nR RRe3tbYuegdRwrlhnGX0RYkBAEBhiUTi2WefvWXbzfYVHSm2ZP1aMldJDAQCnAYM lIIABpZh3bq1Ho/HuP2xfb29d971pYH+/lKOsp6Xx+xGBgBgBVKLURRFu5HOmPcl ok4/9alPjo+PL/exiqlfTSQSOXTo8HLHB5DFhBhYhk2bznA4HMaN/5d/8Zcf/vu/ N/oiw+xGBgCYjSjMRYM2V+mPIknSt775zf/4z/9Y7rYVf+dkMrl3775lbheANxHA wDIYegKwLMs33nRTgeOfy4ndyACAarZkzS6rKvUyGwy+8MLzjzz8cPGzheVuJ6cB AyViLgsUq6urs6+vz7gA7uzovOvuu9esXm30HmC95IZxbjATyQCAZclXsPruni0D SZKOHT/++c9+dsY/U+SXrCCAJyYmpqeLHR/APMxTgWIZvQLWVX961Uc/9jGn02nQ +BWRG8ZEMgDUPa1aCx9vXJF9s2WTSCQef+yxn/7sp8XceQW/FeJL/H4/62ABK8Yc FCjWhg3rXS6XQeUmy/JHP/bxyy+/vBqOfy4z7ZzkbCHnvqWTAaCCCnRs9lP1XbMr MBsM/upXv3r8sUcLHzJWyu9bLBY7cODgir8cMDkml0CxDF0By26z3Xv/AxtPP71W jn8uP2sGnQwAK5CbsvOyNvfdSm9mPZAkad/+/XfcdqusKIveofQfGYiH2LNnb4mD AKbFrBEolqErYG0+Y9Ndd9/t8XgMGt88smtcZws59wapDKDWFdOx7JWtrEgk8vnP fnb33j3zPq7XnwvrYAGlYC4IFMvQAP7QBz/0gb/6K3b/lpOI4UUjWbtBKgMwzrxD iBc9rpiOrV2SJP3bv/7rd777ndwP6vinSQADpWCGBxTF0BWwxCvlDZ+48dJLLzXh CcC1wroUghkwlXlLPRV4l4g1odlgcMeOHV//2iPaz7V1/zvAOlhAKZixAUVZv369 223UClg2q/W+Bx7kBOB6QjADVSt9Um6jLvpu9nalNxk1RjsN+PZbb1EM+wlINBo9 ePCQESMDdY8ZGFAUQ1fAevuZb7vzrrtcLpdB46MmNGTkFnK+25XeUqAysjmam6mF C7bSmwzzisVid37+879//Q8Gjc86WMCKMZECimLoCcAfuX7rn7///QYNjrrXcJKW x0XeqPRWo56l88sN10XfrfS2A7r5wfe///iTTxg0OKcBAyvGHAgoiqEBvHXr1muv fQ/HP6PiFrZ0rtw7FP5spb8PvEX2IN7c1Fzy4wVU9tsBaoIkSdu3P/3EEwQwUHWY pgBLM3QFLFmSP3nzzRdccAErYMFUss2sy9t5wy76WCv74LzeW5h/he+w6LvFvC3m DgCq1mwwuHPnzq8+9JDNbjNi/FQq5fcHRkdZBwtYNgIYWNrQ0Gler9eg/VptrW33 3HvvmtWr2QMMAEB9kCTp2PHjn7njjsBswIjx0+l0OBweHj5ixOBAfSOAgaWdfvqG pqYmgwL4z9/3vuuu32qzGfITYgAAUBGKojz1jSf/3w9+YND48Xh8//4DBg0O1DEC GFja5s2bjNs9u+3mbVdceaVBgwMAgEr5xc9//uBXHjRocBaCBlaGAAaWZuwS0Fs/ cs2113L8MwAA9UQE6o+3b3/8iccNGp91sICVIYCBJXR3d/f19Rp0iLJ49dp2y63n nnsuK2ABAFBPZoPBl19++SsPPmDQIppiCjE5OeXz+YwYHKhjBDCwBEOXgN68afMt t93W2dHBHmAAAOqJJEkzfv+D99+/a/cuI8ZPp9MzM34WggaWiwAGlrBu3TqPx23Q Clj//cN//4G//msjRgYAABX3b//yL//4zX8yaPBIJHLo0GGDBgfqFQEMLOGMMzY6 HA6DApgTgAEAqFdGnwacSCT27dtv0OBAvSKAgSUYtwKWLMsfv+ETl156KScAAwBQ f4LB4LM7djz69a8ZtJKImEjs3r3HiJGBOkYAA4V0d3f19fUZ9rql3HbHHX9y9tkE MAAA9UcE8Cu//e39937ZuKU0Jycnfb5pIwYH6hUBDBTS09PT29tj0OvWpjM2fWrb tt6eHg6BBgCg/kiSNOXz/cNXHty125DrFaVSqcnJKcGIwYF6RQADhWhLQDdk6D74 B/+b+O+D4oZBJxgDAICK+953v/vt7/yzESOzEDSwAky7gUI2bFjvcrm027pn6vXX b7325ApYNDAAAPVHkqTt259+4oknDBo/FosdOHDQoMGBusScGyhk06Yz5h2frFep ptPp667fevnll2dPAKaBAQCoM8Fg8Je/+tU3njQqgEVg79mz16DBgbrEhBsoJHcP cJYupSrL8s3bbjnvvPMIYAAA6pUI4Bd/85uHHnzAoPVEotHYwYPsAQaWgQk3UMjC PcCa0mM1nU7f8enPvP3tb89dApoGBgCgnkiStHfv3ttuvTWVThkxfjKZ3Lt3nxEj A/WK2TZQyJYtm/P9yLbEWL3qqqs/9Ld/2+L1GnSINQAAqAaKojz+2GNPb3/aoMF3 7TJkiWmgXjHVBgopEMCW0mJ1283b3n3FFboPCwAAqs0vf/GLBx58wIiRCWBguZhn A3n19vb29HRbrdYC91lxrG69fus1J5eA1nFYAABQVSRJ+vH27Y8/8bgRg6dSqamp qclJLgUMFItJNpBX9iLAS95zub0qy8rHb7jhkksuyT0BuMQxAQBAFQrOze3YsePr X3vEiHWwRAD7/QEuBQwUjxk2kNfQ0GnNzc1FhuiyelVRlNs//emz3nlWgQBe7pgA AKAKiQB+9dVX7/3yPYWPKVuZdDodDoeHh4/oPjJQr5heA3kteg2kwopMVqfDcd8D D64dGsp3CPRyBwQAANVJkqTh4eFbb70lHo/rPrgIYDHsgQNcCQkoFnNrIK/NmzfZ 7fYVfOGS1bp6cPDBrzzUWnD3b/GjAQCAahYMBm/ZdvMbx44ZMbgI7D179hoxMlCX mFgDeRVeAnpJBcL11m23XPbud+syFAAAqH6/+uUv73/gfiNGZiFoYFmYVQN5lRjA lvzhWngJ6GUNBQAAqpwkSc9s3/6YMQtBE8DAsjClBhZXzDWQijSvXdPp9NatH7n0 sssKr4C15DgAAKAmBOfmnn322ccfe9SIl/LMlZB8k5OTuo8M1CXm08Di+vpEAPfo +EKVHUqSpFtuve3cc89dbgBbaGAAAGqQCOCXX375/vvuXdnaIoURwMCyMJkGFjcw MNDZWdRFgIunjSZeqG7/9Gfe+Y53rCCALTQwAAC1RgTwa79/7ct3323QHmAuBQwU j5k0sLh169Z5PG7dhxWvfE1NTffed38x10AqMIi+WwUAAIyjXgnpyJHbbr01Fovq OGw6ndZuRKPRQ4cO6zgyUMeYRgOL27jxdKfTacTIa1avLv4aSPnQwAAA1BDdr4SU rV8hmUzu27dfr5GB+sYcGlhc6UtA53P7bbdfetllpY9DAwMAUEN2PPvsvffdq8tQ ufVrySwEvXv3Hl1GBuoeE2hgcdUfwBYaGACA2qFXAM+rXwsBDCwHs2dgET09Pb29 PbpcA2mhGz5+w59eddWKTwCehwYGAKD6SZL0s5/97Gtfe6TEcRbWr+XkQtBTU1Ml Dg6YAVNnYBF9fb3d3fpcBHgeWZZv+uSnLrzwwpUtAb0oGhgAgCoXnJv79a9//dV/ eKiU48sWrV/t41wJCSgS82ZgEUZcA0mjKMptt99x9tln6xjAFhoYAIDqJgL41Vdf /fI9d684gPPVr/Ypv98/Ojq20q0DTIRJM7CIoaHTmpubjahKq9V6+6c/c+aWLe1t bfqOTAMDAFC1JEk6cPDgrbdsk2V5uV9bIH2zdwiHI0eOHFnp1gEmwowZWMT69evc bv0vAix0dXZ96Z57Bvr7GxsbdU9WGhgAgKoVCAQ+ccMNU75lnKm7ZPpm7xaLxQ8d OrTSTQNMhOkysIgzztjocDiMGPnMzVvuvOuubF3TwAAAmEQ0Gv3C5z73+q4/Fnn/ IutXI0nS3r37VrRdgLkwVwYWYdw1kG679bZ510CigQEAMIkir4S0rPTVcCUkoEhM lIFFGBfAH/3ox66++up510CigQEAqHuSJP3kJz959NGvF7jPCtJXQwADRWKWDMxn 6EWAr9/6kQsvvNBut3vc7twMpoEBAKhjon5D4fDzzz//xOOP5bvPiuvXcuJSwIJv xSMAJsEUGZivV+RvjyEXARYvTh//2McH16xxud19vb3ZKyGJF8VINCqSdV4Vl4gG BgCg/MTLejQWc7tcua/p0zMzI8LxYw8//PCiR5mVUr+WzBzD55vmUsDAkpgfA/MZ dxHgrFSGw+Foa23rX9XX3tF5wUUX9fb1rerrm1fF4kYpVUwDAwBgEC10xY2Frbtn 9+4XXng+MOMfGx+fnZ1NSknxipzvZ+slpq9GzCsCgQCXAgaWxOQYmG9oaKi52VOR dJRl2WazuZpcXZ2d7R3tV/3ZNZ2dnYODg91dXdn7LDeMaWAAAEpRIHRHRkZmZmZ+ sn37jN8/45+Jx2KKolhttuJffHWpX22cSCQyPMylgIElMDMG5tuwYb3L5ar0Vrwp lUqJVzW73e52ubu6utrb2999xRVd3d3FhzENDADAkgqH7rTP9/Of/Wx2dtbnm4pG Y5IsWTNKeUS96lcbKh6PHzzIpYCBJTAtBubbtOkMHU/ENY4axqmUzWZ3uZo6Ozpb 21qvvOrq3t7eeWFsyXlF1/ccYwAAak6+yrWcDN3JycmfPvPMXDA47Z+JxWKKrDRY 8x69XAp969eSOY6MSwEDSyKAgfmMuwaSERbu3RWvgoqiiI87HM621pburm5Pc/OF F1/c19e3aBuXfqYxAABVRa1c8erW0LBI5U5PH89U7gvPPx8Jh6Z808HgbDIppdOp cr76616/lsxPxrkSErAkAhiYr7YCWFPkQc7q0luija02h6OxrbWtq6vT7fZcdPHF q/r7F7axhTwGAFSrE4lrsbgXe4XSKnd8bExUbjQa8U3PzKmVmxQvg8s6QdcIRqSv hgAGikEAA/PVYgBbSj7RV9tvLG7Y7fYmp7O9vb27u9vtaT7nnHOWzGMLhQwA0FW2 by15Etc3PT2SSdxXXnklGgn7fL7A7Gw8FldSinhFq9rXcePq10IAA8UhgIG3MO4i wGVg3I+0c/PY6XC2tLR0dnY0NTWd967zTzn1VPHxRQvZwj5kAMBilnx10PpW3Hjj 6NHfvPRiPB73+/3BYDCRTMqyLF6WbHZ7uTe6NDqmb77RxAenpnxTU1M6PhBQfwhg 4C0GBgY6OtprNIA1FTmySzu4Wjy2mMc4HI4Wb4v4bWxu9l58ycU9vX2W/IVsYU8y ANSRIp/Ss307NTnx/HPPh8OhQCAwNzcXT4i+lUTJVfxAZR2VIX2zn+JSwMCS6uSZ BdDL2rVDHk9lLgKsu6r6LsSrcmbZajGnEf9ZnU6n19vS3t7W7Gm+8KKLVg0MaHcr 0MkWUhkAKqT4p99s2Qrjo6O/fuGFcCQcCMyGQnOJREJRf1qaEq9PNlsN/6B5WcpW v9pno9EolwIGCqui+TFQDTZsWN/U1FRV6Vii2vpeTizTpV5xosFuszudjuZmb1tr q7fF6232vvOss3pXrdLuWTiVLdQyABS0rCfJ3KydHB9/7Xe/C4VF0oZmg8FwOJRI JGVFTqsXrVeXmFr0KCp9O7AmlDN9T97HkkhwKWBgCbU0MwbKoFYuArxctZXBxVAU JZ3K7EawiumWvdHh8LhdXq/X4/E0i2hu9m7esqXIHcua3LmghWYGUFNW8Aw2b1ft 7l27RNOGw+FIJBIKhSLRmJRMKoqsiGfadLpBfaZd4bJSJkxfSyXqVyP+Juzbt1/H hwbqT73NiYESbd68yV5r62oUr/4yuEipDEvaou5atlrtajA3etwilcUsURBvXWec sem0tWuzX1JMM2soZwB6WfHzSW7NCkcOH967d080GotGxXhRtWqjESkpyYqsnY0i JoDWDP2/hxykb/lHUxRlz569Om4AUH9MOhsG8qnRayAti2kzeFlOLHwtZh4NajM3 qGes2cVM1O1qcrncLleT+L/Lrb43tHbtho0bs19YfDlnzZvyWqhooAbp8g95Xsce 2Ldv+PDhWDwmQjYaEzK3YnHxWIoia2sraE9TtipbMsqc6Wsx+CpHxSCAgSVV0XMl UA3MEMAWGthI6YzsrDTDarM22Oz2RrtdrWaX2+F0NAnOJrfbLX7tHxw8Y9Om3EFW UNGahVNwDUUNzKP7P5Z57Srs3bNnbGQkHo+Leo0nxK/xZCIZjaklK8myIv6XOWlW 7Zycn7XVwfOzOeu3sjt+swhgYEk1/yQL6MskAaypg2lWvXpLRavzYvEnJSbH6vzY liHiWQS0Q5S0o9HpbHI6xS2n0NPXe9Z/OXvhgCsu6nnyNYOFxoauyvA3bWGvan73 6m+nJiYTQlL7fzyZlJJJ0a8J8Z+SkTmpIq3+S828rad2LRHpW9kBxdelUgQwsASz P1MDuXp6enp7e2r6IsDLxXTNJE4WdWaynqH90atzdmumrG3qWmJaUtvt6jnSjepb R+a6zipR1+Kt1+s9+5xzFn0IvRobsOSvU+G3r7wSCoWSyUyeZkiSWqiSLKvnuMqy +Ggis3pTSsmc7aq2qvrXPicqGk7mKk+AeqJ+Kzha9uvEM73P55ua8um2TUDd4akf eFOvyN+eblMFsIZZIEqXzlHpbUENa8hR6W3BMpjzH3611W/mdmp6enpyckqfbQLq Ea8uwJsGBgY6OtpNGMAWGhgAsCKkb2UHzPm6E0c6BAKzY2Nj+mwWUI+Y8gJvWrdu rdvttpi4Bk37jQMAVoD6reCAb/2iN9+JRmPDw8OlbhNQv5jsAm/auPF0h8Oh3TZt Cpr2GwcAFM+c6Wup+voVksnkgQMHS9omoK4x0wXetGXL5tzjn82cgmb+3gEAhVG/ lR2tQP0KqVSKhaCBApjjAm+aF8AaM6egmb93AMBCpG/FB5x30u9CBDBQGLNb4ITe 3p7u7h6rdfF/FGZOQTN/7wAAi4m711JT6atJpdLT01wJCciLeS1wgnYNpMKxZ+YU NPP3DgCmRfpWw4CFj3le+Cg+3/TUFFdCAhbHjBZ4k2hgu93W1NRkt9sbGxvzXQ/J zClo5u8dAEyF9K2SAYvZ8ZtKpSRJVhQ5Ho/LskL9AgUwlwUK6enpEcknelhUcWOj WsXZAjR5Cpr82weAOkb6VsmAi+74FQNKInZl0boJ8Tazv5ejnYFlYAoLLJuoYqu1 wWYTVexszMi3r7jukcEAUDfM3L0WY779Eo95TqdT2dZVFDmVonUBHTB5BfSRW8Xa EdQ2m63SG1UmZDAA1DSTp6+lCnb8Zo5hVls3kVD369K6gHGYtgLGypxXbHc6Hdkq rtdcrNfvCwDqGOlb/h2/sqzIstq6yWRSvJ2c5HxdoKyYsAIV0NvbI/712e02l8s9 79TiWlc33wgA1DfS12Lwjl9xW86IRmOKIovPsDYVUA2YqgLVoqen22q12u12h0Pd XaypxZ6sxW0GAFOhfnX8HciGriwryeSJham4DC9QtZinAtUu9+xi8baxUQ3jSm/U 0shgAKhCpK9lpb8J4qsURdFKN3OmrpIJXXbqAjWGGSpQq7Qw1vYY20QZZ1TVetQ0 MABUFeq3mN+BVCqdOUdX1K62R1eEboo9ukDdYHoK1KFsGzudzmwbVypHyWAAqAbU 76In6IrKZXcuYCpMTAFzyR5QnWlja3n2G9PAAFBB5kxf8V2nUiktcTOVmzx5di6V C5gas1IAJ2ircIkb2vnGVqvNblf3H4tO1mV8MhgAyqy+0/etiZtKJBLaYsscsQyg AOajAIqSzWPtrGORxyKMteOrl1u2lDAAGK0+0lc7UFnbhStaV9uLm/k4iQtghZiG AtBHbiE3NjpEHlszlaxZ9EsoYQDQVw11r7b/VlGyeZuSpKQk0bcAjMXsE0D5ZCPZ 8uaB1m9GclUtYQ0ANaTauvdk2aq/iv/H4+rBydlPEbcAKogABlB1cjtZW8u6ocGq 7VLWgplUBgBNOdNXuxCuFreplLr/NnOVIMoWQC0hgAHUsO5uNZW1I6nFJFDUsrZX eR6OtQZQZ/Tq3lRGNmgz59mqTZt9XhUf8fnIWgD1g0khABMRwZy7qHVmQS8RzA1a JNPMAKpfgfRNvYV2jm06mUxIkpx9ShOpS9ACMDNmeACwhHnZnN3V3NCgVXNDtpm1 GxXcVAC1LjdeszfF/+PxN3fMakhZAFgBAhgADNTT0y26ODtnFfEsbmuXksr2c0PO LfY/A7UrW60n9r1mZAs2mVQv4aM9CZy8P8sdA0C5MccCgBqQe7Zzlpg9NzaqLZ25 pJRW0Q25slFNUQMLZTM1G6s5yZrOHGmsVmvu8cMnv5AzYwGgVjElAgCTykR1w8Lr MWdPMMwswe3IfFoLaktDfhz7DX3Ni9IFtFNh1VuJRDK7EPFif5nVoCVWAQAaAhgA gJXr6uo0dPzp6RlDxwcAwFQIYAAAAACAKRDAAAAAAABTIIABAAAAAKZAAAMAAAAA TIEABgAAAACYAgEMAAAAADAFAhgAAAAAYAoEMAAAAADAFAhgAAAAAIApEMAAAAAA AFMggAEAAAAApkAAAwAAAABMgQAGAAAAAJgCAQwAAAAAMAUCGAAAAABgCgQwAAAA AMAUCGAAAAAAgCkQwAAAAAAAUyCAAQAAAACmQAADAAAAAEyBAAYAAAAAmAIBDAAA AAAwBQIYAAAAAGAKBDAAAAAAwBQIYAAAAACAKRDAAAAAAABTIIABAAAAAKZAAAMA AAAATIEABgAAAACYAgEMAAAAADAFAhgAAAAAYAoEMAAAAADAFAhgAAAAAIApEMAA AAAAAFMggAEAAAAApkAAAwAAAABMgQAGAAAAAJgCAQwAAAAAMAUCGAAAAABgCgQw AAAAAMAUCGAAAAAAgCkQwAAAAAAAUyCAAQAAAACmQAADAAAAAEyBAAYAAAAAmAIB DAAAAAAwBQIYAAAAAGAKBDAAAAAAwBQIYAAAAACAKRDAAAAAAABTIIABAAAAAKZA AAMAAAAATIEABgAAAACYAgEMAAAAADAFAhgAAAAAYAoEMAAAAADAFAhgAAAAAIAp EMAAAAAAAFMggAEAAAAApkAAAwAAAABMgQAGAAAAAJgCAQwAAAAAMAUCGAAAAABg CgQwAAAAAMAUCGAAAAAAgCkQwAAAAAAAUyCAAQAAAACmQAADAAAAAEyBAAYAAAAA mAIBDAAAAAAwBQIYAAAAAGAKBDAAAAAAwBQIYAAAAACAKRDAAAAAAABTIIABAAAA AKZAAAMAAAAATIEABgAAAACYAgEMAAAAADAFAhgAAAAAYAoEMAAAAADAFAhgAAAA AIApEMAAAAAAAFMggAEAAAAApkAAAwAAAABMgQAGAAAAAJgCAQwAAAAAMAUCGAAA AABgCgQwAAAAAMAUCGAAAAAAgCkQwAAAAAAAUyCAAQAAAACmQAADAAAAAEyBAAYA AAAAmAIBDAAAAAAwBQIYAAAAAGAKBDAAAAAAwBQIYAAAAACAKRDAAAAAAABTIIAB AAAAAKZAAAMAAAAATIEABgAAAACYAgEMAAAAADAFAhgAAAAAYAoEMAAAAADAFAhg AAAAAIApEMAAAAAAAFMggAEAAAAApkAAAwAAAABMgQAGAAAAAJgCAQwAAAAAMAUC GAAAAABgCgQwAAAAAMAUCGAAAAAAgCkQwAAAAAAAUyCAAQAAAACmQAADAAAAAEyB AAYAAAAAmAIBDAAAAAAwBQIYAAAAAGAKBDAAAAAAwBQIYAAAAACAKRDAAAAAAABT IIABAAAAAKZAAAMAAAAATIEABgAAAACYAgEMAAAAADAFAhgAAAAAYAr/H3kHyEQ3 PuMGAAAAAElFTkSuQmCC"/></symbol><use xlink:href="#c" width="1280" height="1280"/></g></g></svg>')} +.is2d .bishop.white {background-image:url('data:image/svg+xml;base64,<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="614.635" height="614.635" viewBox="0 0 460.977 460.977"><mask id="b"><use xlink:href="#a" width="1280" height="1280" transform="rotate(.193) scale(.36014)"/></mask><symbol id="a" viewBox="0 0 1280 1280"><image width="1280" height="1280" xlink:href="data:image/png;base64, iVBORw0KGgoAAAANSUhEUgAABQAAAAUACAAAAAA9j6ArAAAACXBIWXMAAA7EAAAO xAGVKw4bAABGKUlEQVR4nO3dBZhVdcLHcQYpqVXXBVQ6RECwQERBFywwQEnFQrFY WUXsIk0MbF2xFSwMsMDAVxBEAaWlawABW0JC4EVCJu7M3HvuOef3j+/n3ed5d12Y +T5X72+Ze8/9n4xCAOCpDHUAAKgwgAC8xQAC8BYDCMBbDCAAbzGAALzFAALwFgMI wFsMIABvMYAAvMUAAvAWAwjAWwwgAG8xgAC8xQAC8BYDCMBbDCAAbzGAALzFAALw FgMIwFsMIABvMYAAvMUAAvAWAwjAWwwgAG8xgAC8xQAC8BYDCMBbDCAAbzGAALzF AALwFgMIwFsMIABvMYAAvMUAAvAWAwjAWwwgAG8xgAC8xQAC8BYDCMBbDCAAbzGA ALzFAALwFgMIwFsMIABvMYAAvMUAAvAWAwjAWwwgAG8xgAC8xQAC8BYDCMBbDCAA bzGAALzFAALwFgMIwFsMIABvMYAAvMUAAvAWAwjAWwwgAG8xgAC8xQAC8BYDCMBb DCAAbzGAALzFAALwFgMIwFsMIABvMYAAvMUAAvAWAwjAWwwgAG8xgAC8xQAC8BYD CMBbDCAAbzGAALzFAALwFgMIwFsMIABvMYAAvMUAIkZFS1Uoue++R+X8p27r+B9/ XLdi7SZJE3zGACIee5cvW7Vxub0q7Xlgwv96zh+Zv676atHvK3+JuQteYwARuZLl Kx22X51qe1cs8Fcu/WXhd99/m7lyXQxVAAOIiJXYp3Kzg+s2TOn3TJw5fcySn9dH VATsxgAiOv+o0OSoek0D/dYvZoz/csVvIfcAOTCAiEjZA4496ZAaaXyB+VM+Gr3s 99B6gNwYQESh1D9PatU2hK/z1ocf/bQ2hK8DJMQAInRF9zny7GMqh/TFlox95euf uUAG0WAAEbLi/7r43HR+8s1t/stP/7Ah1K8I7MAAIkwZe1S7t00EX3fYdQs3b43g 68JzDCDCk7HH2f85KqKvPf7xV5hAhI0BRGhKX3NBtQi//MIX7l8T4ZeHjxhAhKTY 3Z3LR/wtVg65cWPE3wJ+YQARjisejeXbdH8slm8DTzCACMM5vRKfcRC+Of0Gx/Sd 4AEGEOk75qm6MX63mZeOjfG7wWkMINJV8d6zYv6Or163NObvCEcxgEhT7z6Cb9qn r+Cbwj0MINLS6Ll6ku8748IJku8LtzCASEOp/pFf+pKXlUNu45QEpIsBRHDNntD8 8W+HGd3GCL87nMAAIqjid3TeTxrw/ZBbOCMBaWEAEVDDh5uoEwp9eeVEdQKsxgAi mEtuq6RO2Caz/yB1AmzGACKIfW/poU7Y6cE7flQnwF4MIAJo+EAzdcLfxvTkx2AE xQAiZXucfndtdUMWs298d7O6AZZiAJGqPbveUkHdkM2KO575Q90AOzGASNHeV/ZR J+TS5+Ff1AmwEgOI1NR94GR1QgIje85UJ8BGDCBSUuOtBuqEhKa2na9OgIUYQKSi wRDlh9/yM6PzVHUC7MMAIgVNXz1AnZCnZWd9oU6AdRhAJO/oN/ZXJ+RjeYdx6gTY hgFE0hoPU519lZyVbb5SJ8AyDCCS1dD8I0gb8aEQpIQBRJKOsGFcGk5SF8AqDCCS c9g36oKkHP6tugA2YQCRlMqL1QVJqrJEXQCLMIBIRulpVdUJSVpUf406AfZgAJGE kpNrqROSNvfQdeoEWIMBRBLeOlNdkIK326oLYA0GEAXKeOZCdUJKnuu6VZ0ASzCA KEjGeS+oE1J0wUssIJLCAKIgVlwAmB2XAyI5DCAKUH6FuiCACivVBbACA4j8lf3a pPt/JGv2kb+rE2ADBhD52vPF9uqEQIaez21CUDAGEPkp3GmIOiGgzq9tUSfAfAwg 8tNouFk3gEveitbmH14DOQYQ+aj43iHqhMCmnLZUnQDjMYDIW9GHuqkT0vDEVZvU CTAdA4i8tR6mLkhLm+HqApiOAUSear9zkDohLbPOmK1OgOEYQOSl+NPnqhPS9PLF G9QJMBsDiLyc8ba6IG1nvqMugNkYQORh/9eaqhPS9kWn5eoEGI0BRB5u7a8uCMFt t6sLYDQGEIk1fbGaOiEEC8//Qp0AkzGASKjYsJbqhFCMaLNRnQCDMYBI6ILn1QUh 6WLbaa6IEwOIRMqMaqhOCMnEFqvVCTAXA4hErhugLgjN9feqC2AuBhAJVP2gjjoh NN+dskidAGMxgEjg3mvVBSG67zp1AYzFACK3yh/ZeAx+XmaftESdAFMxgMjtgavV BaEa2FNdAFMxgMil4qha6oRQzW3B0ahIjAFELgN7qAtC9qBbf6JFeBhA5LT/mOrq hJAtaMaZCEiIAURON9ytLgjdjfeoC2AmBhA5ZMx26xXAv8ytvVWdACMxgMjhsifV BRG4/H/qAhiJAUQOU+urCyIwrYG6AEZiAJFdvenqgkgcPENdABMxgMju6a7qgkg8 c7G6ACZiAJFNifn7qxMisbzGenUCDMQAIpvuj6gLIvLfR9UFMBADiGxm1FUXRGRm PXUBDMQAIqtyK9UFkSm/Sl0A8zCAyOq2fuqCyPRy4TafCBkDiKwWuHAvzMQWuvYJ Z4SAAUQWVReqCyJUbZG6AMZhAJFFn97qggj17aMugHEYQGQxy6Wj8HOafZC6AMZh ALHbP35VF0Rqr9/UBTANA4jdOg9WF0TqnCHqApiGAcRub7RXF0RqaAd1AUzDAOJv RTapCyJW9E91AQzDAGKXjOM+UydErPnnHAyNbBhA7FL40W7qhIg90X2LOgFmYQCx yx5fNlInRGxCk83qBJiFAcQuxd0/Ma/EBnUBzMIAYpdjvlAXRK7pWHUBzMIAYqci 91+pTojcw9fwPjCyYgCxU/H3TlAnRO6T0/gZGFkxgNip9LSq6oTILaq/Rp0AozCA 2Kn8CnVBDCq4e+I1gmAAsUPG6cPUCTFo8y6XQiMLBhA7FLnV5bMAd+l7O++CIAsG EDuUGNxWnRCDt85x/2JHpIABxA5lv/LhvNBZjX9XJ8AkDCB22GvG/uqEGCyv5/aZ r0gRA4gdvHgTmLeBkR0DiB2aj1IXxKKF60d+ISUMILYr3PUpdUIsLn2GE7GwGwOI 7Yre3EedEIs+d7p+7DVSwQBiu5KDOqsTYjHkknXqBBiEAcR2ZV5vqU6IxYiOq9UJ MAgDiO32/uRwdUIsvjnhF3UCDMIAYrtykyqqE2Kx9IhV6gQYhAHEdv+aUEWdEIvF jX5QJ8AgDCC2q7xYXRCTKkvUBTAIA4jtGn2tLojJkRPUBTAIA4jtmoxTF8Tk6C/V BTAIA4jtGED4iAHEdgwgfMQAYjsGED5iALEdAwgfMYDYjgGEjxhAbMcAwkcMILZj AOEjBhDbMYDwEQOI7RhA+IgBxHZ8FA4+YgCxHYchwEcMILbjOCz4iAHEdhyICh8x gNhu748aqhNiMfEkjsTHbgwgtivz6inqhFh8cBY3RcJuDCC2K/nkeeqEWLx0ObfF xG4MILYret0d6oRY3HIvN0bHbgwgtit84dPqhFhc/NwWdQIMwgBih6Zj1AWxaPaF ugAmYQCxQ7mV6oJYlOcqGGTBAGKHvab5cCHg0vq/qhNgEgYQO5QZd7A6IQbTj+Yq GGTBAGKH4s+fpU6IwatdNqgTYBIGEDvscf2d6oQY3DxgszoBJmEAsUPGSSPUCTFo +dFWdQJMwgBip9I+vDpWZo26AEZhALHTnhPqqRMiN6PRH+oEGIUBxE7F326lTojc h2fyHgiyYgCx0x79blYnRO7OXrwHgqwYQOzSYIq6IHKHTFUXwCwMIHYpulFdELli HAWDbBhA7LLHqGPVCREb3YKfgJENA4hdCt9+kzohYnfdyllYyIYBxC4ZlVy/NWaV TC6DRjYMIHZzfR74px058I8Ednu6q7ogUs9crC6AaRhA7Hay2x8HbjlSXQDTMIDY rfh6dUGkSvAxEOTAACKLD1uqCyI0wv2P+iFVDCCyOPcldUGEzntZXQDjMIDI4p8/ qgsitO9P6gIYhwFEVp+2UBdEZtTx6gKYhwFEVu2Gqgsi0/5NdQHMwwAiq5Jr1QWR KbVOXQDzMIDI5s226oKIvNVOXQADMYDIpvkodUFEWnymLoCBGEBkN7emuiAS82qp C2AiBhDZ9eqrLohE737qApiIAUR25ScdoE6IwLIjVqoTYCIGEDkM7qwuiMCQc9QF MBIDiBwaj1cXROCor9QFMBIDiJyGtVYXhG54G3UBzMQAIqdT3lcXhO7UD9QFMBMD iJxKj22gTgjZ1GPWqBNgJgYQuVzxqLogZN0fUxfAUAwgcik1+nB1Qqi+OdbdTzgj PQwgcuv2uLogVP95Ql0AUzGAyK30qEbqhBBNaMErgMgDA4gELnlKXRCiSwepC2As BhAJlHnqLHVCaF69dLU6AcZiAJFIsyEV1QkhWdp5jDoB5mIAkUjhh7qrE0Ly6FVb 1AkwFwOIhOq/VkedEIrvOk1TJ8BgDCAS63m/uiAU1zygLoDJGEAkVm5oM3VCCMa0 X6VOgMkYQOShrQu3kWz3lroARmMAkYc9b+itTkhb33v+UCfAaAwg8lJ96GHqhDR9 236BOgFmYwCRpw6vqwvS1PENdQEMxwAiT6V6Xa9OSMuAfpwCg/wxgMhbpaFHqhPS 8HX7THUCTMcAIh8tPlUXpOH4UeoCGI8BRD6KXTVAnRDY9Q9tVCfAeAwg8vOPN05U JwT0cYff1AkwHwOIfNV9t7o6IZAFp89UJ8ACDCDyd/IIdUEgLUeqC2ADBhAFsPIe cdwHDklhAFGQ1zqqC1L2eid1AezAAKIgpf/vCHVCiib9m9sgISkMIApU/XO7zsdf ehwfAUZyGEAU7MSXyqsTUrDyvI/VCbAFA4gktLfpVIEOQ9UFsAYDiGRc9Iy6IGld n1UXwB4MIJLyH1uuK7nicXUBLMIAIjm9+6gLktKnr7oANmEAkZxiN9owLb3v5gQE pIABRJKKD2mrTijQW503qBNgFQYQyXrxPHVBgV46X10AuzCASNb3FdQFBVqxn7oA dmEAkZwu/SqpE5KQ2et5dQJswgAiGQe/Wk+dkKQZZ01XJ8AeDCAKts9Lp6gTUvDB eT+rE2ALBhAFKfzIf9QJKXr8v1vUCbADA4gCdLt1f3VCypbf/oQ6AVZgAJGv2kMP VicEMr39bHUCLMAAIh9lX2qtTghs+Hm/qxNgPAYQecq4/2p1QloGXrNVnQDDMYDI S8M3qqoT0rSow0R1AszGACKxsq/YdOlLXj44m5+DkQ8GEAn1u01dEJL+vdQFMBgD iARqvHeQOiE0s06br06AsRhA5FJ40EXqhFA9ewnXRSMxBhA5NXrThmMPUpHZboI6 AWZiAJFdsVfMP/c0dW+dzUnRSIABRDbHDDX/1L8gVrQfq06AgRhAZOHmH/924A+B yI0BxG6N33Hzj387rDjjK3UCTMMAYpfCL5yrTojYyxfwdjCyYQCxU82PqqkTIrfw pHnqBBiFAcQO91yvLojFgBvUBTAJA4i/lPnsCHVCTCY1X61OgDkYQGzT6Gt1QYyO 5Kpo7MIAolChJy5XF8TqyW7qApiCAUTZMQ3UCTGb2oxDsrAdA+i9BiNdvvgvsRUn T1UnwAgMoO9uvkNdIHHLneoCmIAB9FvhD09SJ4h81IqLosEA+q3sl3XVCTIzm/BC IBhAn1UfY989z8OzvNkCdQLUGECPHfu5ukDsuNHqAogxgP66/RZ1gdwdt6oLoMUA euv1DuoCA7zRUV0AKQbQUxmftFAnGGHUCVvVCRBiAP1U9EtfDj8oyKQmm9QJ0GEA vVR6Ym11gjFmN1yjToAMA+ijspPdP/s0eQsP5YJAbzGAHtpnUlV1glEWHfGzOgEi DKB/9v3GtRufpyvz8B/VCdBgAL2z7+QD1AnGWXYoC+gnBtA3+0ypqE4w0NJD+CnY SwygZ0pPq6pOMNKi+rwX7CMG0C/FpnL9S2KzG2xUJyB+DKBXinxTX51grGmH/6lO QOwYQK+Mb6wuMNhXR6kLEDsG0Cdvn6EuMNo7Z6oLEDcG0CN9e6kLDNevt7oAMWMA /dF8lLrAeC0+UxcgXgygN2rOVRdYoNY8dQFixQD6ovg8LoAu2NKaG9QJiBMD6Itx TdQFVvjyaHUB4sQAeuK+a9QFlrj/WnUBYsQA+qHhBHWBNRpNVBcgPgygF8pw5Gfy yq5WFyA2DKAX+ARICvhEiEcYQB/cdKe6wCo336UuQFwYQA/s+4O6wDL/4nhUXzCA HpjILTBTM6mhugAxYQDdd9WD6gLr9HhIXYB4MIDOK75eXWChEnwgxA8MoPNe7aQu sNBrZ6kLEAsG0HWVF6sLrFRliboAcWAAXff5seoCK40+Tl2AODCAjjtksrrAUodO URcgBgyg4yYfoi6w1JRD1QWIAQPotpNHqAus1XKkugDRYwDd9n+8lBXU5/9WFyB6 DKDTKvFeZnCVM9UFiBwD6LTXOqoLLPY6F1C6jwF0WeHN6gKr7bFFXYCoMYAuu/Ze dYHVrrtPXYCoMYAu++IYdYHVxjZVFyBqDKDDSq5VF1iu1Dp1ASLGADqMg6DTxNHQ zmMAHfbRieoCy318kroAEWMAHbaynLrAcqvKqwsQMQbQXbVnqQusd9BsdQGixQC6 i5cA08aLgK5jAN31Zlt1gfW6PqsuQLQYQHd93UhdYD0uhXYdA+iuBdXUBdZ75mJ1 AaLFALprqzrAft9wR2XHMYDOKrpRXWC/7+qqCxAtBtBZnAWYvjm11QWIFgPorEZf qwvsN6/On+oERIoBdBYDmD4G0HUMoLPqTVcX2G/ugeoCRIsBdFaVReoC+/EaoOsY QGdlcKB72qbXVxcgWgygu7gOMG1fNFMXIFoMoLtm1lEXWO+RK9UFiBYD6C7OQ03b hc+rCxAtBtBdd9+gLrBew0nqAkSLAXTXMV+oC2w3vy4fJ3QcA+gw3gVJE/fFdB4D 6LD3T1EXWK77Y+oCRIwBdFiX59QFdlvSZLk6ARFjAB3GpdDpGXOsugBRYwBd9r9L 1QVWazNcXYCoMYAuK71aXWCzyYepCxA5BtBpr5ylLrDYeS+rCxA5BtBppdaoC+w1 vom6ANFjAN3W/1Z1gbWajlUXIHoMoONmcFufYO69Xl2AGDCAjiu/Ql1gJ26I6QcG 0HWth6kLbLT8pBnqBMSBAXTek5epCyzEJYCeYADd98nx6gLrXPG4ugDxYADdlzHu KHWCZW68R12AmDCAPvi0hbrAKhwC4w8G0Atvn6EusMg5Q9QFiA0D6IfrBqgLbLGk Lcfge4QB9ETtTyqqE6ww5rTf1QmIEQPoi6LPd1YnWKDLC+oCxIoB9Mfhb1RXJxju s3M5AtozDKBPbupRTp1gsKndxqkTEDcG0CtFB/RQJ5hq5k18+MNDDKBnCve5oLK6 wUATbxilToACA+if1t1PVCcY5uVeC9UJ0GAAfVT8htMaqRuM8cng59UJkGEAPVX2 mubN1A0GeP/dZzepGyDEAPqrcKdTDqmvjhD6asI7n6obIMYA+q1Ih+MPbqyOiF/m vMnvM35gALFNldOPPLyeOiI2Y2aMe5ub5WEHBhB/eeJydUFsWo1QF8AcDCD+MvkQ dUFsnuymLoA5GEBsU3KtuiA+82uqC2AOBhCFPDsusP50dQGMwQBim49PUBfEqHc/ dQGMwQBim63qgDhN9ef1ThSEAYR3N0//14/qApiCAUShQq+cpS6I1VmvqQtgCgYQ hQot9uuErFe4OQB2YgBRqNYcdUG8llZSF8AUDCAK3d9TXRCz40arC2AIBhCFvvbt cMCBvi0+8sIAouhGdUHc5tRWF8AQDCCueFRdELsD56oLYAYGEO+foi6I3WVPqQtg BgYQK/27WfB7p6sLYAYG0HtNx6gLBEqtUxfACAyg9569UF0g0PpddQGMwAB6b9rB 6gKBpy9RF8AIDKDvyv6mLlBYWF1dACMwgL7r20tdINFooroAJmAAfTfaz/uj33Gr ugAmYAA9V3izukBjho+vfCIXBtBz57+gLhCptFRdAAMwgJ776ER1gciVj6gLYAAG 0G/dHlcXyNScry6AHgPoN0/fAvlLfz/f/kY2DKDXMraoC3Sm11cXQI8B9FrnweoC oQOWqwsgxwB6bbjPp6L0HKgugBwD6DWvboie00Tf7gSA3BhAn53m95ko//xZXQA1 BtBnb7RXF0h1fkVdADUG0GfL9lcXSL3p9/6jEAPoteaj1AVay2uvUSdAjAH02JCz 1QViHYaqCyDGAHps6QHqArHXO6kLIMYA+uuYL9QFaksP/EOdAC0G0F+DO6sL5Nq9 pS6AFgPor8yK6gK5V31/FdR7DKC3moxTF+gtrblBnQApBtBbL56nLjDAGcPUBZBi AL21pJK6wABDzlEXQIoB9FXDCeoCEyypuUmdACUG0FfPX6AuMEJrv8+D8B4D6Ct+ At6On4H9xgB6qukYdYEZuBbabwygp7z/HPAu7d9UF0CIAfTU8v3UBYYY2kFdACEG 0E8nj1AXmGJZvd/UCdBhAP30Zlt1gTHOGaIugA4D6Cev74aU3bAz1AXQYQC91P4N dYE5lh/6gzoBMgygl7y+H3BOVz2sLoAMA+ijjC3qApNMaqgugAwD6KOLB6kLjFJl iboAKgygj0Y1VxcYpVd/dQFUGEAPFV+vLjDLzHrqAqgwgB7q01tdYJjDv1UXQIQB 9NCkw9UFhhnYU10AEQbQP+VWqgtMM7+mugAiDKB/nrhcXWCcEz9RF0CDAfTPoirq AuO80EVdAA0G0Dv//kxdYJ4lddapEyDBAHrnjfbqAgNdyqXhfmIAfcPH4BKZcKS6 ABIMoG8ue1JdYKRqi9QFUGAAfTO6mbrASH37qAugwAB6piwHwCc0+yB1ARQYQM88 dKW6wFDHjVYXQIAB9MzCquoCQz3bVV0AAQbQLy0+VReYakndteoExI8B9Muw1uoC Y3V/TF2A+DGAXim8WV1grm+OUBcgfgygV64boC4wWJ1Z6gLEjgH0yteN1AUGG3CD ugCxYwB9UuF7dYHJ5h6oLkDsGECfvHSuusBo5w5WFyBuDKBHOAchf+ObqAsQNwbQ Iz0GqgsMd+BcdQFixgB6ZEJDdYHh7r1eXYCYMYD+qLxYXWC6+bW2qhMQLwbQH691 VBcYr+uz6gLEiwH0Bp8CKRgHQ/uGAfTGDXerCyxQb6a6ALFiAL3xHUd+FmxgT3UB YsUA+qLhBHWBDRbU/lOdgDgxgL54p426wApXPK4uQJwYQE+U5LjPpEw5VF2AODGA nnjganWBJY4Zpy5AjBhAT2RWVBdY4oUu6gLEiAH0Q5fn1AW2WNp4uToB8WEA/fDl UeoCa/TvpS5AfBhAL1RZpC6wx9yDODXMHwygF7gZXAq4EsYjDKAPSq1RF9iEK2E8 wgD64NEr1AVWOW60ugBxYQA9kLG8gjrBKq90VhcgLgygB669V11gl+XN56gTEBMG 0ANza6oLLPPof9UFiAkD6L62b6oLbLP48J/VCYgHA+i+L45RF1indz91AeLBADqP i6BTx8XQvmAAnffeqeoCC3V/TF2AWDCArtvnJ3WBjabXVxcgFgyg6wZzUVsQ5w5W FyAODKDjOAk6mEkN1QWIAwPouMf+oy6wFJ+H8wID6Dbuhh7UghrqAsSAAXTb7beo C6z1bFd1AaLHADotY+n+6gR78dzwAH+TnXbTneoCiz3ZTV2AyDGATltSSV1gM54c 7uPvscuuelBdYLVHrlQXIGoMoMvmV1cX2I1nh/P4W+ywy55UF1juoR7qAkSMAXTY PC5lSxNPD9fxd9hdFw9SF1jvgWvUBYgWA+iuObXUBfbj+eE4/gY7q+vT6gIH8EdA xzGAzuJWSGHgCeI2/v66qtvj6gIncC2g2xhAVy2sqi5wA88Qp/G311E971cXOOLV s9UFiBAD6Cg+BRyWwlvVBYgOA+imm+9QFzjj28PVBYgOA+ikwssqqBPccfAMdQEi wwA6aUoDdYFDVuynLkBkGEAX1ZuuLnDKLRwr6ywG0EV8CC5U68v/rk5ARBhABzUZ py5wzJdHqwsQEQbQQVwDHbYLn1cXIBoMoHtOHqEucM7KyhvVCYgEA+ieZdwKM3RD O6gLEAkG0DmcgxqBzY2+VScgCgygc/jkVhQWV9+iTkAEGEDX9O6jLnDToEvVBYgA A+iYDP6gEo319RaoExA+BtAxz1ykLnDVrDrqAoSPAXRLqTXqAnfdeYu6AKFjAN3y YUt1gbtW11ylTkDYGECnVFqiLnDZpIbqAoSNAXTKjLrqAqdd/j91AULGALqk06vq ApdtHtZ5g7oBIWMAHZKxnHOgo5PZdqI6AaFjAB1yz/XqAnetH3wpV1g6iAF0RxmO 7YzMrNPmqxMQBQbQHcNaqwtctfrRm9UJiAYD6Iy63LwsIpNO4QJAVzGAzphVW13g pp/6P6ROQGQYQFfcxK3LorB5xFl8utBhDKAj+BBwJJZ1GqtOQJQYQEcMbacucNDG 1y/8U92ASDGAbqgzU13goDlnfKdOQMQYQDd8d5C6wDmrH79RnYDIMYBO6NVXXeCc Cadx7YsHGEAXlP1NXeCaVX2eUCcgDgygC0Y3Uxe45c/h561TNyAWDKADOAUrXPPb TVEnICYMoP0KLzlAneCS1U9yqI4/GED7cSO4MI0//Ud1AuLDAFqvxjx1gUO+v/l5 dQLixABaj0MQQrPh1Us2qRsQKwbQdnfepC5wxtTTuamebxhAy5VbqS5wxZreD6gT EDsG0HJTGqgL3LDlgzM598BDDKDdegxUF7ghsyk//XqJAbQan4ELxR/971InQIMB tNq3h6oLXDD2WO546SsG0GZXPagucMDyVlPVCZBhAC1WerW6wH7rB/RWJ0CIAbTY jLrqAutNOJr3fr3GANqLU1DTNeP8b9QJ0GIArcU7wOm67XZ1AdQYQGstqaQusNvI jr+rEyDHANqq2+PqAqstO+sLdQIMwABaaq9f1AVWe+Fi3vxAIQbQWuMbqwssNvv0 ueoEmIEBtNO196oLLHYPN/zFTgyglTgEK7iJp3LDX+zCAFqJQ7AC6/6YugAGYQBt NOA6dYGthp2zVp0AkzCAFqrJS/jBZLadqE6AWRhA+xSeV02dYKdBl3PsFbJjAO3z 4nnqAivNPG2hOgHGYQCt03i8usBK/Tj2CrkxgLYpNb+8OsFCX536kzoBJmIAbTOu ibrAQv95Ql0AMzGAlrnpTnWBfYZ35toXJMYA2qXyYnWBdZa2/0qdAGMxgFbJmF1L nWCbF7ty7gvyxABa5bku6gLLzG89U50AkzGANjl6rLrAMo/9d6s6AUZjAC3CXUBS 810rXjFF/hhAi0w6XF1gFY79Q4EYQHvcd426wCZTWq5QJ8B8DKA1Dp6mLrDJvder C2ADBtAWxecfoE6wSGZldQGswADaYnQzdYFNRh2vLoAVGEBL3HyHusAqL52vLoAV GEA7VJ+vLrDLnbeoC2AFBtAKReZWVSfYhVsfISkMoBU+OlFdYJmOb6gLYAUG0AZX PagusM3xo9QFsAIDaIFKS9QF1mn2hboAVmAAzVd4Tg11gnXaDFcXwAoMoPk+aKUu sM8lT6sLYAUG0HhXPKousFD/XuoCWIEBNB2H4Afx3EXqAliBATQcLwAGwkfhkBQG 0HAjTlYXWGn2QeKAnvN4G8YGDKDZegxUF1iqaHS3Qsoo+Jj9Ws8dM7flgsgKEBoG 0GhVFqkLbNX5lei+duEtBfyC+3sULlTosxbRFSAsDKDJ+AhwYEPOkX3rouN33Lqg T19ZApLFAJrsU/4QEZTuRcDK3+6z8991el3VgGQxgAa76U51gcUqrIzwi+fzQ/DN fYru+rfzT50dYQPCwACaq+ZcdYHNHrkyyq+e1wJmjG6a5T+Nab45ygikjwE0VrF5 ldQJNltYXfBN95mc/e/Z7bcJIpACBtBY3AQkPYIDYdq+vGeOv3Lu4NgjkAoG0FT9 +MNDet5tHemXL5L7QsOXzs31lxaeMTXSCqSJATQUdwFOW6l1kX75nAtYfEL9BL9q bIuNkVYgPQygmUrN3U+dYL2HekT79bMvYPWJeyf8Vdyh3WgMoJm+bqQusN/K/Qr+ zFpobu1VNI//puuz8VUgVQygkQZG/IcXP0T9UYxif/90m/F53u9YLe4wIdoMpIEB NFFDnjJhyKwc8TcovmHH/99rSn7fafwJayPuQGAMoIH2+kVd4Ihbov4ozY6XAQ8d WzLfX/Xg1RFnIDAG0EBTGqgLHLGsUhyvAt53deECfgW3aTcWA2iepy5RFzgj8k9i lFhfZPwRBf6qzHNHR9yBgBhA4/z7M3WBQ4ptivgbtH+sXBK/avrxqyLuQDAMoGnK RXmKiXcGXRrt10/2wLL3T4u2AwExgIbJmKm+m4Vb9v0pwi9edGbNZH9pT+5tYCQG 0DBDzlYXuOWjCG8qVWFm4g9/JLK864joQhAYA2iWU95XF7im4aSovvL5g4ql8Ktn tsyMKgTBMYBG4S7ooVtYI6JLYRKc/ZKvkS2j6UA6GECTFJmtOMXTcQ9fFcmXTf3T 2jffFUUH0sIAmuTjE9QFLtpvRfhfs9j8iin/nhWXDws/BOlhAA1yw93qAidNPiz0 L1ljcukAv2v2afNCL0F6GEBzcBOkiIT+s2fPe4oE+n2jTizoluqIGQNojOJzuQlS RP75c6hf7t3AVzX37hdmB9LHABpjTNOCfw0C+abgj+smr/C0usF/81mvhReCEDCA prj9FnWBw+65MbQvtc/sfdP43fPPmB5aCULAABqiwRR1gdMODOv11fYvlUjr939+ EjdJMgkDaIbScyuoE5y2qFbuu1gGMejidL/CHbeG0YGQMIBmmBjmq1TI7fVOIXyR jLFN0v8iXV5I/2sgLAygER66Ul3gvONHpf0lyswI4336hR0nhvBVEA4G0ASNvlYX eCDtD4TUHV8mlJCxJ3OTJGMwgAYo+5u6wAdzD0rvKuSb+gW7+jm3ATeE9IWQNgbQ AJMPURd44eOT0vndH50YVgf3SjcIA6j3eDd1gSfSuEVSmUm1QgxZdNZXIX41pIEB lDt6rLrAG0cGveF87S+TP/s5GWNbrgn16yEoBlBt73A/p4r8VFkS6Lf1vCuVs5+T ce/1IX9BBMMAqk2try7wyNK6q1P/TRnvnRJ+ySVPh/81kToGUIy7oMdq5iEpfyJk r/G1IwhZdM64CL4qUsUAajUdoy7wzIQjU/wNh366TyQh41oG+MMowsYASu0T5V1r kcgnqV3O0v+GohGF3HddRF8YKWAApabXUxf4573Tk/+1RT9tFl3IpYOi+9pIEgOo 9OyF6gIfDTsj2V9ZZXTlCDsWn8MFUHIMoNC/P1MX+CnZPwP2uL1UpB1ftuIzkGoM oM6+P6gLfJXU64CF32sVdcf910b9HVAABlBnRhr3lkBavm66qaBfUvGzmtF3cDWg GgMowxWAQrOb/JL/L7jizrIxZPChYDUGUKXxeHWB11adODWf/zaGH393GNOKswGl GECRMr+rC3yXz9kw1T6tFldF/15xfSckwgCKTGioLvDeVyfl8T9Ct94Y7bu/2XR+ Jb7vhVwYQI27ORTYAN0fS/AXS358dJwNc9pxp2AhBlCiHv/QG+GbNktz/qXDPoj5 BqUfnxLOHTsRBAOoUHxeRXUCdnj1kuxHkz56SdhH/xXo5rvi/o74GwOo8H/HqQvw t5e6734psPyngg9nr7hsePzfFDswgAI33K0uQFbv3r3zbL4eff6h+P4zTl+o+LYo xAAqVFmkLkAOs9+8c22h4iNVfzB/t7XoG4MBjF3hOTXUCchtwvRWMb/7kcV/H5V9 a88xgLF7raO6AKbJ7DJKneApBjBuJ49QF8A837ZcpU7wEwMYs3/+qC6AiV7vpC7w EwMYsykN1AUw0vkvqQu8xADG68Gr1AUw09yOk9UJPmIAY3XwNHUBTPXRaQUe0orQ MYBxKjavkjoBxrr2fnWBhxjAOH1yvLoA5lp2MRcIxI4BjNEVXO6KfHx7ygp1gncY wPhwBQzy9+rZ6gLvMIDxmXyIugCGO2eIusA3DGBsOAQaBZnV9jt1gmcYwLhUn68u gPmGt1EXeIYBjEnGXM6AQcH+84S6wC8MYExeOF9dABss7Mz9ouPEAMaj4QR1Aezw Ses/1Ak+YQBjUWzRfuoEWOL6e9UFPmEAY/EOr20jSUu7fKpO8AgDGIfmnPeLpI0+ /feCfxHCwQDGoNSagn8NsMstd6oL/MEAxmB0M3UBbPL9xR+oE7zBAEaPMxCQmrGt f1Yn+IIBjNxev6gLYJve/dQFvmAAIze+sboAtll52TB1gicYwKj1GKgugH2+bM3Z abFgACPGD8AIgh+C48EARuzLo9QFsNGKy4arE7zAAEar+yPqAthpbJuf1Ak+YAAj VfY3dQFs1au/usAHDGCkxjVRF8BWKy59V53gAQYwSpc9qS6Avca04Q20yDGAESq5 Vl0Am3EwVvQYwAi9fYa6ADbLvOAzdYLzGMDocAo00jOyzQZ1gusYwMgUXlRJnQDL XfG4usB1DGBknu6qLoDt5p71jTrBcQxgVGrMUxfAfm+1Uxc4jgGMyncHqQvggHMH qwvcxgBGpHcfdQFcMLX1YnWC0xjAaPAZOITjuYvUBU5jAKPxQSt1AdzAXTIjxQBG ovF4dQFc8dEZf6gTHMYARiFjUWV1Apxx6SB1gcMYwCg83k1dAHfM6jRVneAuBjAC +y9TF8Alr3RWF7iLAYzAV0eqC+ASTgaMDgMYvrOHqAvglk/arFMnuIoBDB3vgCBs Fz+jLnAVAxi6+65RF8A1M9rNVic4igEMGzcCRvj4PEhEGMCwvXuaugDu4XDoiDCA IWswRV0AFw1v96c6wUkMYMhm1FUXwEmdXlcXOIkBDFc3zjBHJP7vzF/VCS5iAEOV kXmAOgGO4iPBUWAAQ8UlMIjK9LZz1QkOYgDDVHq1ugDu+t/l6gIHMYBherWTugDu mn/OV+oE9zCAIaq0RF0Al3EqTPgYwBB9fIK6AC5bduHH6gTnMIDhqTNTXQC3vdVh izrBNQxgeCYdri6A21ZdMlyd4BoGMDSth6kL4Lr3221QJziGAQwNH4JD5DoMVRc4 hgEMS5fn1AVw3ydnrlEnuIUBDMv86uoCeODcweoCtzCAIen+iLoAPvisHQfuhokB DMnCquoCeOG8l9UFTmEAw3HZk+oC+GFU29/UCS5hAMMxr4a6AJ7o/Iq6wCUMYCi6 Pq0ugC8+acuZQ+FhAEMxq7a6AN7gcPwQMYBh6My1CYjNyLbr1AnuYADDwIdAEKN2 b6kL3MEAhuDkEeoC+GR4+03qBGcwgCH4/Fh1AXzy/YUj1QnOYADTx0HQiNeQc9QF zmAA0/dOG3UB/LLonHHqBFcwgGkr87u6AL4ZdKm6wBUMYNqeuUhdAN9MaT9PneAI BjBdRXhHDrHr/pi6wBEMYLp69VUXwD9j2q9SJ7iBAUzXnFrqAnio4xvqAjcwgGlq 8am6AD56q+NmdYITGMA0fdBKXQAfLTl3jDrBCQxgekpxjxpIPNlNXeAEBjA9D16l LoCfJrTnA0ghYADTs6SSugCe4uYgYWAA09Ke9+Ig8l6H9eoEBzCAaRlxsroAvso8 d7Q6wQEMYDqKblQXwF8P8/pz+hjAdPApEOjwaZAQMIDpmHS4ugAeazNcXWA/BjAN Fb5XF8BnL16gLrAfA5gGDsKC0rcd5qsTrMcApiGzoroAXjuX27GmiwEM7pgv1AXw 29COW9UJtmMAg3vxPHUB/Da1wxx1gu0YwOAWV1YXwHOdX1EX2I4BDOywb9QF8N0r ndUFtmMAA3u6q7oAvvu2/QJ1guUYwMBm1VYXwHudXlcXWI4BDKpiproAeOl8dYHl GMCg7u+pLgDGd1iqTrAbAxjUuCbqAmBllxHqBLsxgAFlbFEXAIUKPXCNusBuDGBA HXj1GQYY3olzodPBAAY0mCuwYIBpHWarE6zGAAY0s466ANimw1B1gdUYwGDK/K4u AP4y6FJ1gdUYwGCuG6AuAP4yqsPP6gSbMYDBDGutLgD+MrvDNHWCzRjAYObUUhcA 2/FpuHQwgIGUXKsuAHZ4spu6wGYMYCBdn1YXADt82HGNOsFiDGAgz3VRFwA7cGuk dDCAgYxvrC4Adljecaw6wWIMYCDciwbGuOg5dYHFGMAguCM6zPHMxeoCizGAQXTh f3NhjA86ck1CYAxgEE9cri4AdpnYfrE6wV4MYBAfn6AuAHZZ0HGSOsFeDGAQHAUD g7R7S11gLwYwCN4EhkEe664usBcDGABvAsMo+61QF1iLAQyA4/BhlI5vqAusxQAG 0Ke3ugDIom8fdYG1GMAAnr9AXQBk8UIXdYG1GMAARp6kLgCy+OhkdYG1GMAAJh6h LgCymNRQXWAtBjAAjoOGUeYeqC6wFgMYAJcBwiw8jYPikQuAAYRZeBoHxSOXuhJ/ qAuAbPZcry6wFQOYunrT1QVANgfPUBfYigFM3fGfqAuAbE74VF1gKwYwdWcPURcA 2XR+RV1gKwYwdRcPUhcA2VzCbVoDYgBTd9WD6gIgmx4PqQtsxQCm7qY71QVANjff pS6wFQOYur691AVANv04nyggBjB1DCAMwwAGxQCmjgGEYRjAoBjA1DGAMAwDGBQD mDreBIFheBMkKAYwdVwGA8NwGUxQDGDqLnlKXQBkcynX5gfEAKaOj8LBMHwULigG MHX//kxdAGTT/P/UBbZiAFNXa466AMjmwLnqAlsxgKkrzumTMEuJDeoCWzGAAXAk PszC0zgoHrkAGECYhadxUDxyAczmLoQwyZza6gJrMYABTOA+1DDJxEbqAmsxgAF8 2FJdAGQxopW6wFoMYADPXqguALJ47iJ1gbUYwAB69VUXAFn07qcusBYDGEDbN9UF QBbt3lIXWIsBDGDvn9UFQBb7/KIusBYDGAQXAsIkPIsD46ELYmYddQHwt+/qqgvs xQAGMeJkdQHwt5FclhUYAxjEfdeoC4C/3X+tusBeDGAQp76nLgD+dtr76gJ7MYBB FN6sLgD+tscWdYG9GMBA5tZUFwA7zaulLrAYAxjIxyeoC4CdPjlRXWAxBjCQh65U FwA7PXyVusBiDGAgJ49QFwA7tRypLrAYAxgMnwWBKXgOp4EHL5ivjlQXANt93Vhd YDMGMJgnL1MXANv973J1gc0YwGB4ERCG4CXAdDCAAfEiIMzAUzgdPHoB8SIgjMBL gGlhAAMa2ENdAGzz4NXqAqsxgAGVX6EuALapsFJdYDUGMCjujg4DcE/09DCAQb14 nroAKPTS+eoCuzGAQbX4VF0AFDp+lLrAbgxgYCvKqwvgvZUV1AWWYwADG366ugDe e7e1usByDGBg3B4dctwSPU0MYHDf8+MHtFbspy6wHQMY3EvnqgvguZe5FCFNDGBw h32jLoDnDv9WXWA7BjAN3BoJUtwOKW0MYBru76kugNceuEZdYD0GMA1lf1MXwGv/ +F1dYD0GMB2jmqsL4LHPWqgL7McApoNLASHERYDpYwDTsrCqugDeWlRNXeAABjAt d9+gLoC37rlRXeAABjAtxTaoC+Ct4hvVBQ5gANPz9hnqAnjqnTPVBS5gANNTbYG6 AJ6qvlBd4AIGME1jmqoL4KUvmqkLnMAApunU99QF8NJp76sLnMAApmtmHXUBPPRd XXWBGxjAdHV9Wl0AD138jLrADQxg2rgYGrHjIuiQMIBpu+lOdQG8c/Nd6gJHMIBp y8g8QJ0AzyyrtFWd4AgGMH3X36MugGduGKAucAUDGIJFVdQF8MriquoCZzCAIbji UXUBvNL9MXWBMxjAMMyroS6AR+ZzL5rQMIBhOP8FdQE8csGL6gJ3MIChmMF1+YjL zHrqAocwgKE4lPuzIi6HTVYXOIQBDMfIk9QF8MRHJ6sLXMIAhqPcSnUBPFF+lbrA JQxgSJ69UF0ALzx3kbrAKQxgSLg7CGLBnUBCxQCG5eY71AXwwC0cvREqBjA0s2qr C+C82QepCxzDAIamzkx1AZxX9zt1gWMYwPC82kldAMe9dpa6wDUMYHiKr1cXwHEl eKstZAxgiDgVBpHiFJjQMYBhmnS4ugAO++YIdYF7GMAwVcxUF8BhlZaqC9zDAIZq wHXqAjjr3uvVBQ5iAMP1HddpIRqz6qgLXMQAhqvKInUBHFV1sbrARQxgyB66Ul0A Jz18lbrASQxg2ObUUhfAQXMPVBe4iQEMW4156gI4qOZ8dYGbGMDQPXC1ugDOGdhT XeAoBjB80w5WF8Ax0+urC1zFAIaP4/ERMo7BjwoDGIGe96sL4JRrHlAXOIsBjMKY puoCOOSLZuoCdzGAUSg1v7w6Ac5YWWOtOsFdDGAkGk5QF8AZjSaqCxzGAEbj0SvU BXDEY93VBS5jACMy+RB1AZww5VB1gdMYwIjs/bO6AE7Y5xd1gdMYwKgc84W6AA5o OlZd4DYGMDJPXaIugPUGXaoucBwDGJ0pDdQFsNxUXkmOGAMYnbJzuBoQ6Vh54O/q BNcxgBE6ZLK6AFY7dIq6wHkMYJR691EXwGJ9+qoL3McARurTFuoCWGvU8eoCDzCA kSoyq4Y6AZaaf9Cf6gQPMIDRqvC9ugCW2m+FusAHDGDEGo9XF8BKR32lLvACAxi1 Pr3VBbBQ3z7qAj8wgJH7oJW6ANb58BR1gScYwMhlTKunToBlZtTfqk7wBAMYvTKz 91MnwCrf116tTvAFAxiDWnPUBbDKgXPVBd5gAOPQfJS6ABZp8Zm6wB8MYCz636ou gDVuv01d4BEGMB7vtFEXwBLDzlAX+IQBjMnXjdQFsMKEI9UFXmEAY1JsJp8KRsHm 192oTvAKAxiXf87geFQUZGW9n9QJfmEAY1NjnroAxqs5X13gGQYwPpyLgAJwAkLc GMAYtR6mLoDR2gxXF3iHAYzTPderC2CwATeoC/zDAMaKywGRJy4AFGAA4zW6mboA hhpzrLrARwxgvApPPEydACN923CLOsFHDGDMik2trU6AgWY34AJoBQYwbqVnVFYn wDhL6q1RJ/iJAYzdvtMqqBNgmBX1f1QneIoBjF+VReoCGKbqYnWBrxhAgYOnqQtg lPrT1QXeYgAVGk5QF8AgjSaqC/zFAEoc+7m6AMY4brS6wGMMoEarD9QFMMQpH6oL fMYAinR4XV0AI3R8Q13gNQZQ5YLn1QUwQJcX1AV+YwBl7rtGXQC5+69VF3iOAdR5 /gJ1AcRe6KIu8B0DKDS4s7oAUkPOURd4jwFUeqO9ugBCQzuoC8AASg0/XV0AmXdb qwvAAIp92FJdAJERrdQFYADlPj5BXQCJT05UF6AQA6jHAnqJ/TMDAyjHAnqI/TME A6jHAnqH/TMFA2gAFtAz7J8xGEATsIBeYf/MwQAagQX0CPtnEAbQDCygN9g/kzCA hviAy2L98OEp6gJkwQCaggX0AvtnFgbQGHwu2AN8/tcwDKA53mmjLkDEhp2hLkB2 DKBBXu2kLkCkXjtLXYAcGECTvHieugAReul8dQFyYgCNcn9PdQEi8wA3gTEPA2iW i55RFyAiXZ9VFyA3BtAwnQerCxCJc4aoC5AAA2iatm+qCxCBdm+pC5AIA2icVh+o CxC6Uz5UFyAhBtA8zUarCxCyY8eoC5AYA2ighhPUBQhVo4nqAuSBATTRwdPUBQhR /enqAuSFATRSjXnqAoSm5nx1AfLEAJrpkJHl1QkIxapLlpYsVKpI8aK7/sK6LYX+ XFtoy5pC6zdu/OPP1co2MICROrhJvSr7laumzoDFFq5avmTGl/wQHREGMBLlmh9e s3L5SuoMOCNzRea8bz5bpc5wDgMYssLN/1232mHqCjjqm0UzPv9si7rCIQxgiKp2 bFK7jjoCzps5e/zri9QRjmAAQ1LqPyc24H0LxGXllI+fWKuOcAADGIZjujY6WN0A 70yb8Mw4dYPtGMC07d3vtKrqBnhq4Xu9f1E3WI0BTE/GNe0bqxvgtfFDH9iqbrAX A5iO0vddpk4ACj153Rp1gq0YwOBKPXKhOgHY7tkreUckEAYwqIyBV6kTgL892JMf hANgAAPq0r+iOgHIIvO2F9QJFmIAAyn9QTN1ApDD6FN5KTBVDGAQx36uLgASOI7D xFPEAAbwIK/+wUwPXq0usAwDmLKio5qqE4A8jDl+kzrBKgxgqiqO5nw/mGvBscvU CTZhAFNUj6MpYbaDZ6gLLMIApob9g/FYwOQxgClh/2ABFjBpDGAq2D9YgQVMFgOY gsqL1QVAUqosURdYggFMXotP1QVAklp8pi6wAwOYtMKb1QVA0vbg1knJYACTNrW+ ugBI2tRD1AVWYACT1beXugBIQe9+6gIbMIBJKrdSXQCkpNwP6gILMIBJmlNLXQCk ZPZB6gILMIDJueNmdQGQottvUxeYjwFMSiUuq4J9Ki1VFxiPAUzKzDrqAiBlMw5W FxiPAUzGxYPUBUAAFz2nLjAdA5iEDK4phZ0Kc6u4/DGASXjicnUBEMhj3dUFhmMA C1bmd3UBEFDZ1eoCszGABZvQUF0ABPTVUeoCszGABTpwtroACOzAueoCozGABZpX Q10ABDantrrAaAxgQTq8ri4A0tD+TXWByRjAAnAJDCzHpTD5YAALwClYsFyv/uoC gzGA+eMYaFiPw6HzxgDm764b1QVAmu64VV1gLgYwXxkryqkTgDSt2J9XAfPCAObr qgfVBUDa/vuousBYDGC+Jh6hLgDSNuFIdYGxGMD8VMxUFwAhqLhMXWAqBjA/r3dQ FwAhGHKOusBUDGB+eO0YbuB5ngcemHy800ZdAITirXbqAkMxgPnIrKguAEKxtJK6 wFAMYD74CRiu4ImeGI9L3vb5SV0AhGSfX9QFZmIA8/bxCeoCICQjWqkLzMQA5o2f gOEOnukJ8bDkjQGEO3imJ8TDkqd//KouAELzD+5tmAgDmKc32qsLgNC8dpa6wEgM YJ5mH6guAELzXV11gZEYwDzxEiBcwlM9ER6VPDGAcAlP9UR4VPLC/dDhFO6QnggD mJeRJ6kLgBB9cKq6wEQMYF44CQFOWVJFXWAiBjAvvAQIt/BcT4AHJS8MINzCcz0B HpQ87P2zugAI1d58tCk3BjAPw09XFwCherutusBADGAeFvGSMdyysLq6wEAMYB54 CRCu4cmeG49JHhhAuIYne248JokV3qwuAEK2xxZ1gXkYwMSevExdAITs0f+qC8zD ACY28Qh1ARCyrxurC8zDACbGS4BwD8/2XHhIEmMA4R6e7bnwkCTEeyBwEO+C5MIA JtR8lLoACN1xo9UFxmEAE/qwpboACN27rdUFxmEAE5pTS10AhG5WHXWBcRjAhHgP BC7i6Z4Tj0hCDCBcxNM9Jx6RRGrPUhcAEeDGSDkxgIn0GKguACLQ/TF1gWkYwETG NVEXABEYc6y6wDQMYCJLKqkLgAgsrqouMA0DmAjvgcBNPN9z4AFJZHFldQEQAU7F z4kBTIQ/AcJNPN9z4AFJhAGEm3i+58ADkggDCDfxfM+BBySBgT3UBUAkBtygLjAM A5jAMA7NgJuGdlAXGIYBTIAbgsBR47nEPzsGMIHMiuoCIBJLqqgLDMMAJsB7IHAV T/jseDwSYADhKp7w2fF4JMAAwlU84bPj8cjt/p7qAiAid9+kLjALA5jb0HbqAiAi r3RWF5iFAczti2PUBUBE/q+5usAsDGBu3BIOzvqurrrALAxgbrwHAnfxjM+GhyM3 BhDu4hmfDQ9Hbgwg3MUzPhsejlyuv0ddAESmJ3c8zIoBzOWpS9QFQGQe/a+6wCgM YC7vn6IuACLzzpnqAqMwgLl83UhdAETmy6PVBUZhAHNZUE1dAERmHle5ZsUA5sKb wHAZT/mseDRyYQDhMp7yWfFo5MIAwmU85bPi0cjp2nvVBUCErnxEXWASBjCnx7up C4AIDeS4yywYwJy4Jyac9kZHdYFJGMCcvjlMXQBEaMKR6gKTMIA5LT1AXQBEiDtj ZsUA5sSbwHAbz/kseDByYgDhNp7zWfBg5MQAwm0857PgwciJAYTbeM5nwYORw33X qAuASN15i7rAIAxgDpwGCMdxImAWDGAOkw9RFwCRmtRQXWAQBjAHLgOE4zIrqwsM wgDmwHsgcB1P+t14LHJgAOE6nvS78VjkwADCdTzpd+OxyIEBhOt40u/GY5EDAwjX 8aTfjcciu1v7qwuAiF3Poed/YwCze+F8dQEQsacuUxeYgwHMblRzdQEQsZEt1QXm YACz++4gdQEQsWkN1AXmYACz4z0QuI9n/d94KLJjAOE+nvV/46HIjgGE+3jW/42H Ipu+vdQFQORuultdYAwGMJvBndUFQOSe7aouMAYDmN0jVfcvV1EdAURmyfeZi65T R5iDAUzkyjpV9jtUHQGEasKyhbOeUkeYhgHMR4+DqlRgB2G7CcsXzXpSHWEoBrBg Vx1UuQI/F8M6S1ZsW77/qSvMxgAm7+EqFcpVVUcABZq/YvliXudLCgOYsjuqHfCv OuoIIIHpK5Yu7KeOsAoDGNTVtSqW37e6ugLYZu6qFUvmPa6usBEDmK4bq1cst28V dQW8tOCHFUsXPKCusBkDGJYbqu33r31rqSvghVk/rFy+aKC6wgUMYOju2Paj8T7V 1BVw0Lyffvx+aV91hVMYwOjctX+5f+7FnwmRrtk//7RyWW91hZsYwBhcW7HCP/fe q4Y6A1aZ+/OvP6zIfFid4TgGMFZXViz/r732KnuAugOGWvrrr7/8sHLZY+oObzCA Ktftv+/ee5Upw4uFWPD7b7/+/NOyB9UdPmIATXD9th+Ry5YtzeuF/pi9+vfffvn5 ey5hEWMAjXPzv/beq2zp0iW5ttAti9asXfPbr7+sGqAOQRYMoOGu2/ZnwzJlSpXc s6q6BClatHbtutWrf/v5Z/6YZy4G0DK37rVXmVKlSpYoWYLzacySuX7d+rVr12xb PA6ctwcDaL1b/1GmTMlSJfYsUbx4ZXWLNxZvWL9+/R/r1qxe+8td6hakgQF00o1l SpcuVaL4nsWLFytejFlMx+KNGzZuWL9t77b94W7NPeoahIwB9MpNpUqVKFFy2ywW K1602Lb/218dZIjlmzZu3PavbVO3Yd22qVvLD7G+YACxU8+Se+5ZokTREn8tY5Fi RfcotkfRIq4M5PI/N23euHnjpk2btu3cX3+iW/fHOs4SAAOIVPT464XGosWKFS1S pFiRIkX32KNIkT0KF/3rX5qlXL5505a//vXnn5s3b/rzz41/bvpzw6ZNGzas/4OL ipEUBhDRuX6PEoWLZZQoVKJQ8UKFthbK+o9bxt//qXCO//y3jYU2FFpfaP3WjVvW b+biOUSCAQTgLQYQgLcYQADeYgABeIsBBOAtBhCAtxhAAN5iAAF4iwEE4C0GEIC3 GEAA3mIAAXiLAQTgLQYQgLcYQADeYgABeIsBBOAtBhCAtxhAAN5iAAF4iwEE4C0G EIC3GEAA3mIAAXiLAQTgLQYQgLcYQADeYgABeIsBBOAtBhCAtxhAAN5iAAF4iwEE 4C0GEIC3GEAA3mIAAXiLAQTgLQYQgLcYQADeYgABeIsBBOAtBhCAtxhAAN5iAAF4 iwEE4C0GEIC3GEAA3mIAAXiLAQTgLQYQgLcYQADeYgABeIsBBOAtBhCAtxhAAN5i AAF4iwEE4C0GEIC3GEAA3mIAAXiLAQTgLQYQgLcYQADeYgABeIsBBOAtBhCAtxhA AN5iAAF4iwEE4C0GEIC3GEAA3mIAAXiLAQTgLQYQgLcYQADeYgABeIsBBOAtBhCA txhAAN5iAAF4iwEE4C0GEIC3GEAA3mIAAXiLAQTgLQYQgLcYQADeYgABeIsBBOAt BhCAtxhAAN5iAAF4iwEE4C0GEIC3GEAA3mIAAXiLAQTgLQYQgLcYQADeYgABeIsB BOAtBhCAtxhAAN5iAAF4iwEE4C0GEIC3GEAA3mIAAXiLAQTgLQYQgLcYQADeYgAB eIsBBOAtBhCAtxhAAN5iAAF4iwEE4C0GEIC3GEAA3mIAAXiLAQTgLQYQgLcYQADe YgABeIsBBOAtBhCAtxhAAN76f/jfNaaHYiHZAAAAAElFTkSuQmCC"/></symbol><g mask="url(#b)"><g transform="rotate(.193) scale(.36014)"><symbol id="c" viewBox="0 0 1280 1280"><image width="1280" height="1280" xlink:href="data:image/png;base64, iVBORw0KGgoAAAANSUhEUgAABQAAAAUACAIAAACXhmigAAAACXBIWXMAAA7EAAAO xAGVKw4bAAEWsElEQVR4nOzdC3zb9X3v/0g/WbLkS2I74MTkHkt22Nq15b+t6elO z7o91p6eraX0sZ718eg4oy0ZtGM7XU5pAozDrdwGpbRQSkdLgbJCWzr6gKZAGOFA uKxcSyGxJMd362bdZd1l6/+1RbPgOLZs/b4//SS9no/HPMWRP99vbFH77e/3+/ka 1gAAAAAA0AAM1Z4AAAAAAABaIAADAAAAABoCARgAAAAA0BAIwAAAAACAhkAABgAA AAA0BAIwAAAAAKAhEIABAAAAAA2BAAwAAAAAaAgEYAAAAABAQyAAAwAAAAAaAgEY AAAAANAQCMAAAAAAgIZAAAYAAAAANAQCMAAAAACgIRCAAQAAAAANgQAMAAAAAGgI BGAAAAAAQEMgAAMAAAAAGgIBGAAAAADQEAjAAAAAAICGQAAGAAAAADQEAjAAAAAA oCEQgAEAAAAADYEADAAAAABoCARgAAAAAEBDIAADAAAAABoCARgAAAAA0BAIwAAA AACAhkAABgAAAAA0BAIwAAAAAKAhEIABAAAAAA2BAAwAAAAAaAgEYAAAAABAQyAA AwAAAAAaAgEYAAAAANAQCMAAAAAAgIZAAAYAAAAANAQCMAAAAACgIRCAAQAAAAAN gQAMAAAAAGgIBGAAAAAAQEMgAAMAAAAAGgIBGAAAAADQEAjAAAAAAICGQAAGAAAA ADQEAjAAAAAAoCEQgAEAAAAADYEADAAAAABoCARgAAAAAEBDIAADAAAAABoCARgA AAAA0BAIwAAAAACAhkAABgAAAAA0BAIwAAAAAKAhEIABAAAAAA2BAAwAAAAAaAgE YAAAAABAQyAAAwAAAAAaAgEYAAAAANAQCMAAAAAAgIZAAAYAAAAANAQCMAAAAACg IRCAAQAAAAANgQAMAAAAAGgIBGAAAAAAQEMgAAMAAAAAGgIBGAAAAADQEAjAAAAA AICGQAAGAAAAADQEAjAAAAAAoCEQgAEAAAAADYEADAAAAABoCARgAAAAAEBDIAAD AAAAABoCARgAAAAA0BAIwAAAAACAhkAABgAAAAA0BAIwAAAAAKAhEIABAAAAAA2B AAwAAAAAaAgEYAAAAABAQyAAAwAAAAAaAgEYAAA1KYpisVhW8YHZbHZmZkb1+QAA gOMIwAAArNIJWbdYLM79X2tray6X27Fj+yqqDQ0Nm83m6elpw5w1pe/RpGIAAFRE AAYAoCwnLu3Ozs6KuGsymez2XqmDut2DhUJBBGKj0Vh6D5EYAIBVIwADAHBKx0Ov iLtdczpLi7PVIqYRCoVDoVBpGoRhAABWhAAMAMA7GI3G5ubmNfNps62tradnY7Vn dEoejzeRSJTCcCaTmZ2drfaMAADQNQIwAABzTtzh7HDYqzuZVXC53KUHLAsDAHAq BGAAQEP7be4ttre3b9iwodrTUYHP54vH4+JbPEkYAIAFCMAAgEZ0fJ+ziL4Oh6PK s5HD5XKVvtGzOxoAgBICMACgsRzf6my391a3o5U2isWi2z24hq3RAAAQgAEAjaO0 6tvcbNmyZUu151IFY2NjmUyW1WAAQCMjAAMA6l9Li212tqgoSm/vzmrPpcoGB4/N zMwYjYZkMlXtuQAAoDUCMACgbplMJrPZvKZhdjuX7/i+6FwuVygUqj0dAAA0wk8D AID6ZLPZRMzr63OIt6Tfk5U+LU6nS7xNpVgNBgA0BH4gAADUG0VRNm7c2NXVKR4T fZcmYrB4GwqFvV4vLbIAAHWPHwsAAPVDRN+mpiaj0ehw2Ks9lxozOHisUCjk83li MACgjhGAAQD1oBR9zWbz9u3bWPVdnWKxODw8ksvliMEAgHrFjwgAgJpnNBq7urp6 ejYSfSsnYrDH4w2FQtyWBACoP/ygAACoYYqi9PT0BIPBvj5HtedSV1wud1dXl8fj YSkYAFBPCMAAgJpkNBrNZnNTU9POnTuqPZe6NTw8ks1mc7kcq8EAgPpAAAYA1B5F UUT6ZdVXG06nS2RgloIBAHWAAAwAqCWlZlcmk6m3d2e159JAhoaGaY4FAKgDBGAA QM1g4be6WAoGANQ6AjAAoAYoitFstogAzMJvdQ0NDefz+VwuOzPDqWAAQO0hAAMA 9M5oNDY3WxwOFn71wuVyZTJZOmMBAGoOARgAoGuKYuzo6Ni0aVO1J4J38Pl8U1NT rAMDAGoLARgAoFOlbc/F4mx/f3+xWDQY+J6lF6Uvh9PpFD9IsB0aAFBD+GECAKBH iqJYLBaHw17tiWAZLpc7m83SGQsAUBMIwAAA3aHbc22hOzQAoFYQgAEA+iLSb1tb 27ZtW6s9kRWLRKLd3d3btm0788wzu7q69uzZU+YH3nXXXZOTk0ePHhkdHZuamurq 6pQ6TxlGRkYTiQQZGACgcwRgAIBezG97NhsMRru9tyYO/fp8/v7+/h07drz3ve8t P+4uYDKZ4vF4Nps98Z333HPPG2+8MTo66nK5eno2qjFZiUpfLLd7sFiczWZZCgYA 6Jfef7YAADQIRTE2N1tF9K32RJYxPDwi4u573vOes88+e/fu3RVWE+nX7/MZFWWJ 57z00ku/+MUv3nzzTRGJd+zYXuGIsokYnMmkaYsFANAnAjAAoPoURWluttjt+m15 5fP5Re4999xzzznnHFUKGubF4/F8Pl/+Rz366KMPPvjgr3/9az0vC7vd7kyGtlgA AD0iAAMAqkzPLa9Uz70lRqMxkUjkcrlVV9B5EqYtFgBAnwjAAIBq0mf6Le1z/tSn PrXqk72nIv696Xmzs+psEr7nnnseeeQRHe6OJgMDAHSIAAwAqBodpl+fz/+xj33s 6quvXr9+vbqVS3ueK1z4PZVQKHTttdcePHhQVwvCZGAAgN4QgAEA1aEoxo0be9av 76r2RN6WTmc+85nP7N+/X0Zxo9E4PT29oNWzDLfccsvPfvazlhab7IHK5PX6gsEp emIBAHSCAAwAqAJFUbq7u08//bRqT2SOiL5/93d/p/pu5xLxLxW5N5VKabkQes89 99x11106icEejzcUCrEODADQAwIwAEBrIhOuX79+48YN1Z6I3Oi7RsOF30XpJwZP TExGIhEyMACg6gjAAABNifTb1dVV9aOqsqOv+GeWom+xWJQ0RJl0EoPHxyei0SgZ GABQXQRgAIB2TCaT2Wy223sNhqp9A/L5/BdccIGks75r5ptdidAr0u+KLviV7eab b7777rs3bTqjWhMQnxO3ezCXyxUKhWrNAQAAAjAAQDvNzc19fY4qpt/Nm7d85zvf Ub3D83HV3fO8NL/ff9FFF8XjsWpNQGRgp9OVyWSqNQEAAAjAAACNiHBoNjf19/dX ZfR0OnPnnXfu3r1bUn2R6guFQiqV0vMKp8/vP/TUU9/4xjc6OtZVZQIDAwO5XF6t O5ABAFgpAjAAQAuKYmxqqk76HR4e+dSnPnXHHXfIG0Jk+3g8rqs9z4sS4dzj9YZD oVtvvfXw4cM7d+7Qfg4iA4tPFBcjAQCqggAMAJBOURSz2dzX59B+6HQ68+Mf/1he 8DYYDLlcLpVK1cqqpsjAY6OjsXh8fHz8a1/7WlWWgp1Ol/ik0RALAKA9AjAAQC6R fq1Wa2/vTu2H7u/fdc8998irbzQaY7GYnvc8L8rv9/t8vlJi/+d//udwOKT9HAYH j6XTaTIwAEBjBGAAgEQiInZ1dZ1xRo/G40Yi0euvv/6cc86RVL904jeZTNZihBMz 9/p8oWCwdEXT4cOHv//973d3n67xNCYnPaFQqFZWzgEA9YEADACQRVEUi8XicNg1 Hlek00cf/YXUVs+JRCKXy0mqrwGRgUfHxuKxtztCx2Kxyy//J5tN67uCXS53Nput xV8iAABqFAEYACCLCFTap1/Z255Ld/zW3Lbnk/kDgbmN0CeEz6pshxYZOJVKaTwo AKBhEYABAFJov/w7PDxyzTXX7NmzR1J98S+Kx+M1vfB7ormN0H5/aGqqtBG65MCB Az/4wQ+07A7NIjAAQEsEYACA+oxGo0i/WrZ99vn8DzzwgLxrfsW/aHp6WkQ1SfWr Yq4j9Ph4LBo98Z1Hjhy59tprN2/epNk0nE6X+MRyGBgAoAECMABAZYqiNDc32+29 mo0YiUSff/55SYd+DQZDPp9PJpN1mdD8gYDf51uwABuLxb785S9r2RbL7R7MZDKs AwMAZCMAAwBUZrPZRPoVuVGb4aSmXxHmE4lEnS38nmjRjdBrNM/AYnSRgTkMDACQ jQAMAFCTSIzr1q3dvHmzNsNZrbann35aUvE66PZcjrmN0GNjsd92hD7RV77yFZNJ 0WYa4+Pj0WiMRWAAgFQEYACAakRitFqb7XZ7sVjUYAVYavoVsXB6enrBumi9Orkj 9HHaZODSC8btdqfTmbrcag4A0AkCMABANVreeyQv/TbIwu+J5jZC+3yhYHDRwK/l OjC3IgEApCIAAwDUoShKR0fHpk1naDCWvPRb94d+T2VuI/ToaCweX/RvNcvAExOT kUiEjdAAAEkIwAAAdVitVm3uPTIYDC+++B8yKhuNxlgsJqKgjOL65/f75zZCn2IH 8j/8w9/bbDYNpuF0utLptAYDAQAaEAEYAKACRVGamkz9/f2yB5LX87lYLIr02yCH fhclkr/H6w2HQot+EjTrCz0wMJDPF1gEBgDIQAAGAFRKpF+LxaLB6V956TeXyyWT SdXL1hyRgUdHRuKJxKJ/q1kGdrnc2WyWDAwAUB0BGABQKZvN6nBI3/w8PDzyzDPP yFhkTqVSDXjo91R88061Ej4+Pr53796dO3fInobL5Uql2AgNAFAZARgAUBFtel+J 9Pvzn/989+7dqldOJpMN1fB5WYVCYXxiIhqJnOoJR44cueKKK2RnYLphAQBkIAAD ACpS6n0l++Lf//bf/viGG25Qvez09HQ+n1e9bK3zBwJ+n2+J8HnXXXcdOzYobwKl lxPdsAAAqiMAAwBWT1GUtra2bdu2Sh2lq2v9gQMHVC+bSCQatuHz0ua6Yfl84VNc C1xy2WWXzczI/eyNjIyKrxGLwAAAFRGAAQCr19zc3N/fJ3WISCTqcrlUL8va79JE Bh4ZGUmcohtWyec+9znZDbEGBpyZTEbqEACAhkIABgCskqIoIgDb7b3yhhgeHjly 5IjqbZ/pelUOr8/nP3U3rDXzTaHPP/98qYeB3e5BEYBZBAYAqIUADABYJQ2Wf88+ +5P79+9Xt2Y6nWZRsRyFQmFsbEyk3CWe88ADD/z6169LnQaLwAAAFRGAAQCrocHy r4yjvzMzM/F4XN2adczn989diTQ7u8RzZB8GZhEYAKAiAjAAYDVkL//6fP5XXnlF 3c3PBoMhEokssacXCyx7JdKa+Y3QX/rSlzZv3iRvGiwCAwDUQgAGAKyYohibm61S l38///kv7NmzR8WCiqJwr+wq+AMBn9c7u+Qi8IEDB5599hl5c5hfBE7PzCw1BwAA ykEABgCsmOzlX9U3PxuNxunpaRpfrUKhUJiYnIyEw0s/TfZGaBaBAQCqIAADAFZG UZTW1pbt27dLqi9j8zONryrhDwT8Pt/Si+eyN0IPDw9PTydZwAcAVIgADABYGdnL v6p3fi4Wi9FoVMWCjaZQKEx6POFQaOmnye4IzSIwAKByBGAAwAooitLW1rZt21ZJ 9dPpzBtvvKFiQaPRGIvFRIRTsWYDKmcRWLjgggs6OtZJmsPIyGgikWARGABQCQIw AGAFmpub+/ocBoOsbx/f+Matu3fvVquamGcymeTob+XKXAQ+evTovffeI2kOxWLR 6XSxCAwAqAQBGACwAl2dnZu3bJZUfPPmLT/96U9VLMjmZxWVuQh89dVXp1JJSXMY HxsPLdeOCwCAJRCAAQDlUhSjxdLscNhlFB8eHjly5IiKva/Y/KyuMttBi8/5+eef v3PnDhlzcLnc2WyG+5AAAKtGAAYAlMtiseza1S+puMPRd99996lYMJVKsflZXeXc CSzceOMNkUhE0hyOHh3gywoAWDUCMACgLIqiWK3W3t6dMorLWP4NLXdgFStVKBTG Jyaiy4VbqYvAg4PH0uk0rbAAAKtDAAYAlEVq+yt1l39FVk8kEqwTyuDz+31eb7FY XPpp8haBaYUFAKgEARgAUJa1a9du375NRmXVl38LhYIIwGpVw4nE53Z0bCweiy39 NKmLwOIFE1tuAgAALIoADABYnqIoFotFUvsr1Zd/RTrK5/NqFcQCHq/X7/Mt+zR5 i8DzrbCy7IIGAKwCARgAsDx5+59VX/4V0SiVSqlVDScLTE35fL6Z5dpry1sEZhc0 AGDVCMAAgOWJANzf3yej8rp1HY8//rha1YxGYzQaZW1QqjLvQxIuueSSYlHKlUUD A04CMABgFQjAAIBlzF3/a7Y4+hwyin/jG7fu3r1brWrpdJpcpAF/IOD1eJZthXX0 6NF7771HxgRcTlc2l+VCYADAShGAAQDLkLf/WcTVN954Q61qRqMxEokse0stKjfX Cmt0NB6PL/vMCy64oKNjneoTYBc0AGB1CMAAgGW0tLTY7b0yKp999if379+vVjUR h9LptFrVsLQJj2fK71/2aQ888MCvf/26jAm43YPJZFJGZQBAHSMAAwCWYTabzzxz l+plh4dHAoGAWtUURYlEIpz+1czcLmivt1jGevunP/1pGa2wjhw5msvlVC8LAKhv BGAAwFKMRqPZ3NTf36965Y0bex5++GG1qoksxHqglsq8EFi48sorMxn1V+YHBgZy uTw73gEAK0IABgAsZd26ddu2bZVR+atf3XfOOeeoUspkMsViMdYDNVbmLujDhw// 4hePypjAyMhoNBqVURkAUK8IwACAU7LZbHZ7r4z2Vz6ff3R0VK1qs7OzsTKWIqGu MntBC5/97Gc3b96k+gTE0G73INc+AwDKRwAGAJySvACs4v5nMb14PF4oFFSphvLN 7YIeGYknEss+U9IuaAIwAGClCMAAgFOyWq0Oh11GAFZx/7OYXjgcVqUUVmp8YiI4 NbXs0yTtghYB2OVy0/obAFA+AjAA4JQ61q3bKuEAsLr7n0X+4T7YavF6vT6fr5xn StoFPToyGuEYMACgbARgAMDibDabw2GXUVnF/c8mkykajebzeVWqYaUCU1Nej6ec VsySdkELLpebXdAAgDIRgAEAi5MXgM8++5P79+9XpVSxWKQPcBUVCoWx0dFYPL7s Mx944IFf//p1GXMgAAMAykcABgAszmq19vU5ZFT+j//4lSp1DAZDMpnMZrOqVMPq lHkMWNi/f5+MCTidLo4BAwDKRAAGACzCZDKZzWYZK8DpdOaNN95QpZSiKJFIZGZm RpVqWB2P1+sv7xjwBRdc0NGxTvUJuFzuXC5HG3AAQDkIwACARcjb/+xw9N13332q lOL6Xz0o/zbgG2+8IRKJyJgDu6ABAGUiAAMAFiEvAH/+81/Ys2ePKqWSyWQul1Ol FFatUCiMDA8npqeXfeaBAweeffYZGXMgAAMAykQABgAsQl4AVusAsMlkikQibHzV g9GxsXAoVM4zJR0DJgADAMpEAAYALEJSAI5Eoi6XS5VSBoMhHA6rUgoVKr8P1uc+ 97nu7tNVnwABGABQJgIwAGARzc3N/f19qpddt67j8ccfV6VUJpOh969OTHq9gfL6 YF1yySXF4vKXBq/UwIBTvB5ULwsAqD8EYADAIiwWy65d/aqXfd/7zrrjjjsqr2Mw GGKxGP2fdcLn93s9nnKe+c1vftPrLeuZK3L06AC3YQEAykEABgAsZDQazeam/n71 A7BaHbAURQmHw7Oz6q8lYhUCU1MiAJfz5ZDUB2tgYCCXy/N6AAAsiwAMAFhIXges n/zkJ1u2bFWllKQLdbAK5TeCDgQCt9zydRlz4BgwAKAcBGAAwEKSAvDw8IjIP6qU ymazpB1dGRkZKfNXEp/+9Kd37tyh+gQIwACAchCAAQALSQrA+Xzh1VdfrbyOwWBI JBL5fL7yUlBL+TchfelLX2pvb1N9AgRgAEA5CMAAgIUkBWC1WkCbTKZoNEoA1pXy b0KS1AiaAAwAKAcBGACwkM1mdTgcqpd1OPruu+++yusoihIMBiuvAxVNTE5Olbe/ /cYbb5BxftvlcqVSXIsFAFgGARgAsJDVau3rUz8Aq3UHUrFYjEajldeBisq/CljS TUhOp4t7oQEAyyIAAwAWknQJsFp3IOVyuWQyWXkdqMjj9frLC8CSbkLiKmAAQDkI wACAhZqbLbq9BNhgMIj0S9TRG5/P5/V6y3mmvKuAMxleFQCAZRCAAQDvoCjKunVr N2/erHrlb3zj1t27d1dYRATgeDxeKBRUmRLU4vP7vZ6yNjYfPXr03nvvUX0C4+Pj 0WhsZmZG9coAgHpCAAYAvIOkFtDCf/zHryovYjKZRABmBVhv/IGARwTgYrGcJ+/f v0/GHGgEDQBYFgEYAPAOLS02u13XATgcDrPQpzciAHs9nmJVA7Db7U4mCcAAgKUQ gAEA76DzAMwdSPokArDP652dLeuCXwIwAKBaCMAAgHfQeQA2GAzhcLjyOlBXYGrK 5/PNlHc2mwAMAKgWAjAA4B10HoCFSCSiSh2oqFAojAwPJ6any3kyARgAUC0EYADA O+g8AM/OzsZiscrrQHXDw8PRaLScZxKAAQDVQgAGALyDzgNwoVBIJBKV14HqCMAA AP0jAAMA3kHnATifz0+Xt88WGiMAAwD0jwAMAHgHnQfgXC6XTCYrrwPVEYABAPpH AAYAvAMBGKtDAAYA6B8BGADwDjoPwNlsNpUi5OjR8NBQtLz+ZARgAEC1EIABAO9g s4kA3GswqP8N4oUXXjQajRUWYQVYn8q/Bml2dvbSSy9RfQLFYtHtHuSXIwCApRGA AQDvoCjKunXrNm/epHrlm2/++gc/+MEKi9AFWp8CU1M+n2+mUFj2mW+++eb99/9Q 9QmMj09Eo9GZmRnVKwMA6gkBGACwUHOzpb+/X/Wyf/M351144YUVFhEJJx6PqzIf qMgfCPi83tnZ2WWf+eijjz733GHVJzAwMJDJZFUvCwCoMwRgAMBCFotl1y6dBuBi sVhmpyVoSQRgr8cjvjrLPlNSAD56dCCbJQADAJZBAAYALGS1Wvv6HKqXfc973nvn nXdWWMRgMITDYVXmAxWJAOyZnCznmbfeeqvP51V9Ak6nK51Oq14WAFBnCMAAgIUk BeDeXvv9999fYRFFUYLBoCrzgYp8fr/X4ynnmTfccL2MNXwCMACgHARgAMBCNpvN 4VD/JqT29rUHDx6ssIjJZAqFQuWcNYWWfD6f11vWuu6+ffsktBhf43K5aQENAFgW ARgAsJCkAJzL5V977bUKi4gAHI1G8/m8KlOCWjxer9/nK+eZF1544bp1a1WfAAEY AFAOAjAAYCFJAfjYsaGpqakKbxgWHx6LxbjtRm8mvd5AGQG4WCz+5V/+pd3eq/oE CMAAgHIQgAEAC0kKwMIPf3i/3V5p5WQymcvlVJkP1DLh8Uz5/cs+bXJy8rbbviVj AgRgAEA5CMAAgIWMRqPFYpHRB+uzn/3riy66qMIiIv2KDKzKfKCW8YmJ4NTUsk/7 +c9//uKLL6g+utPpymaznAwHACyLAAwAWISkq4Df9a5333XXXRUW4SpgHRodGwuH Qss+7ZZbbgkEll8oXikuAQYAlIkADABYRHNzc39/n+plW1pan3rqqQqLKIoSCoVE DFZlSlDF6OhoOfczX3zxxYpiVH30gQFnJpNRvSwAoP4QgAEAi5B0DDgUCg8ODlZY xGQyxeNxVvz0o1AojIyMJBKJZZ953nnnbdjQrfoEOAAMACgTARgAsAh5fbCefPLf 29raKqlgMBiSySQBWD8CU1M+r3fZ1tzpdPqqq66UMQECMACgTARgAMAi5AXg//k/ /+of//EfKyySz+enp6dVmQ8q5/P7vR7Psk976KGHXn75JRkTIAADAMpEAAYALMJk MjU1NcloBL1ly9af/OQnFRYxGo2hMlouQRten8/n9S77tGuuuSaZVP/XFk6nK5/P FwoF1SsDAOoPARgAsDhJfbDi8cTRo0crLCLyeSwW4zZgnZj0egM+37JP+8IXvnDa aetVH50OWACA8hGAAQCLs1qtMlaAhccee7yjo6OSChwD1pVyLgFOJBLXXvs1GaM7 na50Oi2jMgCg/hCAAQCLk3cM+E/+5E+vvfbaCosUCoVy2g5DA+VcAnz33Xe7XE4Z o3MAGABQPgIwAGBxIgDb7b0Gg/rfKTo6Oh977LEKi3AbsE4UCoXRkZH4cr+MuOSS S4rFWdVHFy8At3uQAAwAKBMBGABwSuvXr9+06QzVy46Pj4+MjJrN5kqKiGQej8dp fVR1gakpr9c7u+QdSPl8/txz/3rbtm2qjz4xMRkMBlUvCwCoVwRgAMApWa1Wh8Mu YxH485//wp49eyosksvlksmkKvPBqpVzB9KBAweeffYZ1YcuFosul5sDwACA8hGA AQCnJG8XdHv72oMHD1ZYxGg0hsNhdkFXVzktoPft2yfhRcT+ZwDAihGAAQCnpChK U5Opv79f9crj4+PDwyMWi6WSIuyC1oNlW0Dncrn/9b/OlbH/eWBgIJ8vzCy5+xoA gBMRgAEASznttNN6ejbKWAT+m78578ILL6ywCL2gq2uuA9bYWDwWW+I5jz766HPP HVZ96GKx6PF4p5a7fgkAgBMRgAEAS1EUY1NTk4xFYJut5dChQxUWURQlHA7Pzqrf XhjlCExN+bzepddgL774YvEqUn3o+eXf/MwMX3oAwAoQgAEAyzCbzWeeuUv1si6X e2hoqKOjo5IiBoMhmUxms1m1ZoUVWbYD1vT09LnnntvX51B96CNHjuZyOdXLAgDq GwEYALCMtWvbt23bJmMX9B/8wR9+61vfqrxOJBKpvAhWYdLjCfj9Szzh29/+9vj4 mOrjFovFkZGRWCyuemUAQH0jAAMAlmE0Gs1mKbugQ6HwwMCAyWSqpIj48Hg8ziJw VYyNj4dOfQ3vzMzMF77whQ0bulUfV7xscrk8W98BACtFAAYALM9isezapX4AFi64 4MLzzjuvwiJcCFwVcx2wRkbip25C9sQTTxw69JSMoY8eHeBXHgCAVSAAAwCW19ra 2tu7U0blYnHNr371qwqLGI3GSCTCeqDG/IGA1+NZ4h7miy66qLW1RcbQg4PHpqen ZVQGANQ3AjAAYHnydkG7XO5Dhw695z3vqbBOMpmkJZLGJr3egM93qr89duzYV77y FRntr9j/DABYNQIwAKAsNpvN4bDLqNzevvbgwYMVFjEYDOFwWJX5oExLHwDet2+f hL5pc1wudyqVklIaAFDvCMAAgLJ0dXVt3rxJRuWBgYFDh55+3/veV0kREYDj8Xih UFBrVlia+FSPDA8nTrEPeXBw8Ctf+T8ytgwI4+MToVBIRmUAQN0jAAMAyiJvF7TQ 1tb+5JNPVlikWCxGo1FV5oNl+f1+r9d7qgPA8pZ/2f8MAKgEARgAUK62tradO3fI qCxSzVNPHTrrrLMqKaIoSjwe5ySwNiYmJ6cCgUX/yu12X3zxVyT9ruTYsaHEqftO AwCwNAIwAKBczc3NfX0Og5ylvaYm8+HDhyssMjs7G4vFVJkPljB3AdLoaDweX/Rv 9+7dazY3yRi3WCw6na5MJiOjOACgERCAAQDlUhTFarVKuw+peMUVV37sYx+rpIjJ ZBIBmEVg2eYuQPJ6i4vtQ37ppZceeuinkn5LMjh4LJ1Oz8zMyCgOAGgEBGAAwApY LJZdu6RsbV0zf8z42WcPixBbSZFCocAWWdkmPJ4pv//k94tounfvP1qtVknjHj06 kM1mJRUHADQCAjAAYAVERhUZWMblriWf/OQ5+/btq6QCJ4FlKxQKY6OjscX2Pz/4 4IOvv/6apHGdTpdIv7S/AgBUggAMAFgZefchCT6f/1e/+lV3d3clRVgElmpu/7PH c3L/50gkctFFF8l7bXD7EQCgcgRgAMDKSL0PSejttd9///2VVGARWKpT9X++4Ybr 5V1Dxe1HAABVEIABACvW2dGxZesWScUHB4/97Gc/+9CHPlRJERaBJRGf2JGRkZM/ t2+88cZVV11lt/dKGndsdCwciUgqDgBoHARgAMCKWa3NDoes+5CETCZ76NChzs7O VVcwmUzxeJyGSarz+f0+r3fB/meRhy+++OJ169ZKGlQM53K50mluPwIAVIoADABY MUVR2tvatm7bKm+IM8/8nbvvvruSCtwJrLq59lfj47GT9jnffPPNweCUvHFHR0bj iQS3HwEAKkcABgCshtVqdTjs8haB3e7Bhx566I//+I9XXYGTwKrzBwI+r3fBQdzX X3/96quvFi8GSYPOL/+60+m0pPoAgIZCAAYArIYGi8DpdObAgQObNq2+q7DI5+Fw WMUpNbJCoTDp8YTf2Yc5GAxedtllHR3r5I3L8i8AQEUEYADAKsleBF4zd+XSepGB V/3hYm7xeFwkNxWn1LACU1M+n2/mnZ/Mf/qny6R+eln+BQCoiwAMAFglo9G4tr1d 6iKw8N//+8euuOKKVX+4mCSXx6pi0uMJ+P0nvue+++47cuQtqYOOjozG4nFuPwIA qIUADABYPREvLRZLX59D3hDDwyMPP/zwBz7wgVVXSKVStIOu0Mm3H7311ltXXnnl zp075A3qdLrEF470CwBQEQEYAFAREYB37eovFovy9kInk8mHH/55b+8q75hVFCUc DpOjKuHx+QI+3/HbjyYnJ6+88oquri5Jw5VeTkePDvCbCwCAugjAAICKGI3G5uZm u71X6mFgq9X26KOPtra2ru7DC4XCiauXWJEFy7/pdPryyy83mRR5I4oA7HYPZjIZ fm0BAFAXARgAUCkRgPv7+2SPsnnz5h/96IGmpqZVfCxXIlXC4/UG/P7S8q8Iw9dd d10qlZQ96MCAUwRg2aMAABoNARgAUClFMba2tm7fvl32QO9//+5bb711dR9LN6zV yefzoyMjienp0h/vuOOOsbFR2YMODw9PT0/PzLD8CwBQGQEYAKACq9UqtRVWyfDw yBVXXPHFL35xFR9rMBiSySRnSlekUCh4vN5wKFRa/n3kkUfuu+8+qY2vSpxOF1cf AQBkIAADAFSgKEpXZ2fPGT2yBxoaGr7llls++9nPruJjxSRDv81yKIc/EPD5fLMz M+Lxk08+eeedd/b27pQ9qGfSEwqHZ+YHBQBAXQRgAIA6FMVosTQ7HHbZA/n9gdtu u+3P//zPV/GxIlbF43HVp1SXCoXC+MRENBIRj1988cXbb79906YzZA/qcrmz2Qyb nwEAkhCAAQCqsVqb+/qkd8MSQqHwLbfc8hd/8Rcr/UCj0ZhIJOiGVQ7fvGKxKNLv nXfeuWFDtwaDOp3OdJreVwAAWQjAAADVKIrS3ta2ddtWqdcCl4gM/PWvf/3jH//4 Sj9QTDIYDMqYUj0pFAqjIyPxROKFF1747ne/Kzv9ll4woyOjYkQ2PwMA5CEAAwDU JOKlxWy2O+yyA/Ca+Qx80003nX322Sv9wGw2m0qlZEypPhzvffXcc8/9y7/8iwZr v3MX/7rc2VyO9AsAkIoADABQmTYdoUuGh0c+8IEP3HzzzTt3rqA5E9cCL83n97/2 6qvf+c53jhw5okHP5xI6PwMANEAABgCoTMTLjo4ODRomHVcsFiORqMPhePe73/3R j370v/7X/1rO+nNkvr0TSsTn8Pnnn//3f//3t956y+VynX76aRqs4R83MTEpvhws /wIAZCMAAwDUJzJwc3Oz3d5bldHHxsa3bNmyY8f23/3dd334wx9+//vfv2iWS6VS jXwtsEi8L7/88jPPPDMwcHRkZHRiYmLr1i1VmYnbPZjJZEi/AAANEIABAFJouRF6 aUNDw5s2bdq4caNIxQ6H4/d///d3795tMpkaaiN0oVB46aWXXnvttcHBwcnJSZ/P 5/V6d+zYXu15zWHzMwBAMwRgAIAUc92wLBYNrgVeBZfL3dXVtX79+tNOO62jo6On p2fz5s12u33Xrl2tra3Vnl1Fpqenjx496na7x8fHPR5PIBAIhULhebr9WmSzWZZ/ AQDaIAADAGQ5fitStSdSrmKxODY2LjJwe3u7eNs2Tzxeu3btunXrOjs7RWYWb7u7 u8UDEe81m5iIiMFg0O/3ixwrHoi30Wg0FovF4/HEPJF7xWPxdsuWzVqe3a0Q9x4B ADRWM98jAQC1qHQrkkMfe6HV5XK5m5qazGazSMJm89xD8X9Go9FkMom34h9e2mUt Hi9RZHZ2VsS/QqEg3orH4oF4m5+Ty+XyIvfO/b98Xp+LtxVyOV3cewQA0BgBGAAg l81mq8v8hgq5XG5uYwYAaIwADACQy2QyWSyWanWEhj653YPZbLZQKFR7IgCAxkIA BgBIpyiK2WzWSVNoVJ3T6cqx+RkAUA0EYACAFhTFaDZbyMCYT7/ZmZnZak8EANCI CMAAAI2IDNza2rZ9+7YqzwPVMzw8Mj2dIP0CAKqFAAwA0I6iKG1tbdtq52IkqGhk ZDTBpUcAgKoiAAMANMV54MbEuV8AgB4QgAEAWiMDNxrSLwBAJwjAAIAqEBnYYrFw P3AjcLsHM5kM6RcAoAcEYABAddhsVoeDReD653K5Uql0tWcBAMAcAjAAoDpsNhsr wI3A5XKnUqlqzwIAgDkEYABAdVitVo4BNwKn05VOswIMANAFAjAAQGs2m23NmiL7 nxuHy+USP3KwDgwAqDoCMABAO4qiNDc39/buNBj4BtRYisXi4OAxumEBAKqLnz8A AFpQFKPZbBEP2PbcyJxOl3iby2VnZmarPRcAQCMiAAMApLPZbE1Npu3bt1d7ItCF 4eHhfL7AjmgAgPYIwAAAiUT0LRaLrPriZE6ny2DgYDAAQFMEYACAFEaj0Wq12u29 1Z4IdM3tHkyn07Oz7IgGAGiBAAwAUJmiKBaLhYVflKm0FJzNZumPBQCQjQAMAFCT zWYzm83btm2t9kRQY0ZGRnO5HDuiAQBSEYABAOpQFKPF0uxw2Ks9EdQwl8udzWbo EQ0AkIQADAColKIoZrN5zZpiX19fteeCmud0OsXPJ7lcjh3RAADVEYABABWx2Wwt LS1nnNFT7YmgrkxOepLJJDuiAQDqIgADAFZJUYzNzc12O3ueIYvb7c5k2BENAFAN ARgAsBo2m81kMu3Ysb3aE0GdGxoaLhQKLAUDAFRBAAYArIzRaLRYLFxxBC05na5s Nst1wQCAChGAAQArYLNZ5y/4raVmV2LCgcBUe3t7JBLZuHGDwdC43/vEp2J8fKK1 tTWdTvf0bKytT4XT6RQTTqXS1Z4IAKCG1dJ3PgBAFZVaPdfWwq/Ie2az5bLLLvvo Rz9aek80Gn3llVfeeuutkZERn88XCoXC4XAsFhPv37Zta20FwlMR/+qhoeGWlhYR dNvmdXZ2dnd3b9261W63i3eWnvbyyy//67/+q9ncVFv/aqfTRYNoAMCq1dL3PABA tdTcwq+YrdFo3L//kk984hNlfkgikTh69Ojw8JDX6/P7/ZFIJB6PT09Pl3oRZzIZ 8SAzL5fLav+pcDqdTU1mi8XS3Nxss9lKb61Wqwi6IuKuXbvWJh60tHR0dm7evFm8 v8yyL7zwwgMP/Eg8v4ZiMEvBAIBVq5nvdgCAqqjFhd9cLn/xxRd/5jOfkTeEiMHB YDAUCkWj0VgsJgKziMfZbLZQKIi3uVxOPMjn8+KBiOJL1BFBTnx6m5qaTCaTeCDy rXhgmdfe3r52XmdnZ1dXl3jPsrMSI05MTsai0aUHPdnTTz/94x//eO3a9hV9VHWx FAwAWAUCMADglGw2m3jrcNTMRUcihf793//Dnj17tBlOURQRd1OplH5imAjeXp8v HAqtol/UgQMHHn7430TYljExGVwut3hLg2gAQPkIwACARRiNc3f81lD0jUSif/u3 f7t3717NRhSfounpaRGANRuxTCIDB0Oh6URCTG+lS8HCQw899Itf/KK7+3QZc5NB xOBMJkODaABAOQjAAICFauuO36mp4Lnnnnv55ZeLRKrNiIqiJBKJZbc3V1c+n5/0 eKKRyComKcLk/fff/+STT/b0bJQxN9VxVzAAoEwEYADAfyodQLXbe6s9kbJ4PN6/ +qu/uvbaa5uamrQZ0WAwzMzMJJNJEbe0GbESc9uh/f5wMLi61VHx4XfffffTTz+9 Zctm1ecmg9s9WDqGXe2JAAD0iwAMAHib0Wjs6elZv74GjoCOjY1/8pOfvOmmm0qn lLUh0m88Hq+tfFXaDp1MzO2HXt16tYiU3/3ud5977rnt27epOzcZgsGQx+NhOzQA 4FQIwACAOSJJioCn/7XfwcFjH/nIR2677bbOzk7NBlUUpXQHkp73PC+hku3QJSJB i8/5K6+8ov9XiNs9KP6ZbIcGACyKAAwAjU6ku+bmZv0HG5Fq2trav/e9723btk2z QQ0GgxhXpN9cLqfZoDJUuB26xOfz3XLLLQbDGv1fGixicCaT0U93bgCATuj9GxgA QKpauea3WFxz1VVXffSjH9VyUKPRWGp2peWg8ogMHJrvDr3q7dAlL7/88r333tvS ot3m89XhomAAwMkIwADQuGqi23Mymdy79/+cd955Wg6qKEomk0mlUvV3mrTy7dAl TzzxxE9/+hOdXxpMd2gAwAIEYABoUK2trTt37tDzXtapqeDnP//5Sy65RONJiuGm p6frZuH3ZCIT+vz+UCg0W9nqqIjQDzzwwGOPPabn25LEJI8dGxJf0GpPBACgC/r9 uQcAIMn8oV+L3W6v9kROaXh45JxzzvnmN79pNpu1HNdoNIqklM1mtRy0Kt7eDj09 tyG6wqXgfD5/xx13HD58eOfOHWpNT3VutzuTybIdGgBAAAaAxqLzQ78ijK1du+7e e+/duFHTRUWDwVDaK1tbtxxVSK3t0IKI0zfddFOxOKvbPQUcCQYArCEAA0BDEem3 o6Nj06Yzqj2RxWUy2auuuuoTn/iExuPW4gW/alFrO3TJCy+8cO+9965bt7byUjJM TExGIhEyMAA0MgIwADQKm81mNBp7e3dWeyKL8PsD559//qWXXqrxuIqipFKpdDpd oxf8qkLF7dAlP/rRjw4cOKDP37MMDh6bnZ2lLRYANCwCMAA0BN22vDp2bOjjH//4 t771rZaWFi3HrZsLftWi4nboNXOL+Zlvf/vbzz//vA7vl6YtFgA0Mt39JAQAUJ1I vzpc+BU5pLnZ+sMf/nDLli0aD904za5WpFAoeP3+cDCo1uVPgUDgxhtvNJkUHf7m ZXDwGBkYABqQ7r4hAQDU1dLSosNVuFAo/NWvfvX888/XeFyRxPL5fCqV4iDoot7e Dp1IJKan1doW/stf/vLHP/7xhg3dqlRTkds9mEwmqz0LAICmCMAAULdMJpPFYtbb dUeDg8fOOeec22+/XeMrjtbMp99YLEb0XZa626FLBcVX/PDhw3r7XYzb7c5mc43Z /wwAGhMBGADqk6IoFovF4dBX+hX+9V9/tHOn1vuxxWcjmUxmMplGbna1IqpvhxY8 Hs/111/f0mJTq6AqXC6RgbkiGAAaBQEYAOqQohgtlmZdpd/JSc+FF16ofZ9nml2t msjAwfnt0NPqbYdeM98j+pFHHtm6VeuD30uYz8CZmRnVoj4AQLcIwABQb4xGY3Oz xeFwVHsibxPZqaOjU8Sezs5OjYem2VXl8vn8xORkLBpVMQMnEonrrrtudnZGP82x XC5XJpNVcbkbAKBPevnGAwBQhYh8Foulr08v6TcYDP7f/3vFueeeq/G4IlkVCoVU KsXxzsrNbYf2+cKhkLr58Mknn/zhD+/buHGjijUr4XS6slkyMADUOQIwANQPRTGa zXpJv8Visbu7+4EHHtT4gt818+k3Ho8TfVX09nboeHw6mVRxKTiTyVx33bUidupk KVhk4Fwuy15oAKhjuvh+AwConMlkMpvNOjn3GwwGr7jiyr/+67/WeFxFUVKplIhV rOPJMLcdemIiFoup20tMV0vBLpc7l6MvNADULQIwANQJm82mh/QrolFX1/qf/OQn ra2tGg9tMBiSySQnfqUSydDj9YZDIXUzcDqd/trXrhHF9bAULDJwKpWq9iwAAFJU /9sMAKByLS0terhhdXLS89WvfvWiiy7SeFxFURKJBNFXGyKm+gKBcDCo+tVBP//5 zx988EE9NIh2uweTyWS1ZwEAUB8BGABqnk7Sb1OT+Wc/+9npp5+u5aAGg2F2dlZk lXw+r+W4DU5k4FA4PJ2Yo+5ScDQaveqqqywWs4o1V4cMDAB1iQAMALWttbW1t3dn decwOHjs/PPPv/766zUe12g0igDGBb/VImLwhMcTDYfVzcDC9773vV/+8pdV/7WO eGFPT09Xdw4AAHURgAGghtlsNhESqntsMhKJPvjgg+9973u1HLR0y1EymVR9Fy5W ZO6GJL8/HAyq3nVscHDw2muv7e7WdEPBAiLYu92DnAcGgHpCAAaAWqUoitVqre7y b1tb+8MPP6xxvyuj0RiLxejTqxOSbkhaM98Z68orr6xuV6zBwWNiGvyeBQDqBgEY AGqSCIEdHR2bN2+q1gREMLjwwguvueYaLQc1GAy5XC6VSnHLkd5IuiFJuOeeex55 5JEqboceH5+IRCK85ACgPhCAAaAmWa3Wvj5HtUb3+wMPPvjgH/7hH2o5qMj80WiU tTjdKhQKk15vRO0bkoSBgYFrr/3aGWecoW7Z8jmdrnQ6Xa3RAQAqIgADQO2pbtvn QmHml7/8pZbdnln4rRVzNyT5/aFQaFbt31NEo9HLLrusrU3ry6WPoyk0ANQHAjAA 1BibzeZw2Ks1+oYNG//t3/7NaDRqNiInfmvL20eCE4np6Wl1l4JnZ2evuuqqbDaj Ys0VcbncNMQCgFpHAAaAWqIoRqvVVpXGV06n88ILv3jddddpNqLBYMjn88lkkoXf miPvSPD3v//9Rx99pK+vT92y5ZhviJWameHVCAA1jAAMADXDZDJt2LBh/fou7Yce Gxv/wQ9+8JGPfESzEY1GYzweFzlKsxGhrrkjwR5PRMItwS+//PJNN920ffs2dcuW IxgM+Xw+9iMAQO0iAANAzajW0d+pqeCjjz565plnajaiiEzT09PEjFon75bg0dHR yy+/vKdno7ply8FhYACoaQRgAKgNNptNpF+D5peiJhLTTzzxxKZNGt23pChKPB7P 5XLaDAfZRAb2T02FgsEZtX+dEQwG9+/fr/2GiGKxKDIwh4EBoEYRgAGgBhiNxs7O zk2btL4GplCYOXToUHt7uzbDiX9mIpEg/dYZkYFD4fB0PJ5Quy2WSKEXX3yx9q2h JyYmw+EwR9MBoBYRgAGgBlRl83NTk/mpp54ym80ajFW66CiZTKp+XhQ6MdcWa3Iy Fo2q+yUWZfft22c2N6lYsxxshAaAGkUABgC9q8q9RzZby8GDB00mkwZjsfDbICS1 xZqZmdm/f7+iaHc1Vwm3IgFALSIAA4DenXFGz2mnnabliO3tax9//HFtLvs1GAzT 09Ok3wYhMrDH6w2HQqpfEXzppZeuWaPp9oGpqanJSY+WIwIAKkcABgBd0375d926 jscee0ybblsiDk2rfS4UOiepNbR4FYkMXCxqei6XRWAAqDkEYADQL0VRRADeuXOH ZiO2t6994oknNEi/bHtuZCID+wKB0NSU6hn4kksu0XId+NixIRGAZ2ZmNBsRAFAh AjAA6JfVau3rc2g2XFOT+emnn9bg3K8I9iL9ZrNZ2QNBt0rXIwVFBlY1PYosevHF F2vZE8vpdKXTac2GAwBUiAAMADolUmJTk6m/v1+b4YrF4uHDz2nQ89loNMbj8Xw+ L3sg6NzbVwRPTam7gipeWnv3/mNLS4uKNZcwMDCQzxdYBAaAWkEABgCd0vLqo3Q6 /cILL2qQGUTMFumXC1RRIikDZzKZ//2//6Gjo0PFmkvgSiQAqCEEYADQI5vNJtKv Np2opqaCzz///IYNG2QPlM/nuekXC0jKwOFw+Mtf/nJPz0YVa56KeEmLDEw3LACo CQRgANAjzU7/jo2NP/HEE+9617tkD5TNZkkIWJSkDDw8PLx///7t27epWPNUOAkM ALWCAAwAuqMoisVi0eD2I5fL/eCDD/7Zn/2Z7IFENshkMrJHQe2SlIFfeeWVr33t axr8Lkn8p5TNZjkJDAD6RwAGAN3R7O7f979/96233ip7lFQqRcNnLOvtvtCBgLpH xO+4446xsVEVC54KdwIDQE0gAAOA7nR3d2/cKP1ErtlsefbZZ2WPQvpF+ebuB/b7 g1NT6h4U37t3rwYXI3m9Yu5+2aMAACpEAAYAfdFm+Tccjrzyyivt7e1SR2HnM1ZK ZGCvzxcKBlXMwKlU6ktf+tKGDd1qFTwVFoEBQP8IwACgLxq0v3K7Bw8ePHjWWWdJ HSWXy3E3DFZBZOBJjycSDquYgd1u9759+2T/aolWWACgfwRgANCRpqYmEYB37Ngu dZTf//0/uO2226QOMTs7G4vFpA6BOiYy8OjYWFzVl9Dtt98+MTGuYsGTDQ0NiwCc z+eljgIAqAQBGAB0RIP9z5lM9vXXX5d6w7DRaIxEIuq2MkKj8QcCfr9/plBQq2Cx WPziF7+4bt1atQouil3QAKBzBGAA0BHZ+5/FT+fPPPOM1Ft/RfqNx+MsgqFCc02h A4Gpqamier9JGR4e3rt3r9T/xNgFDQA6RwAGAB2RHYB7e+3333+/vPoGgyGRSJB+ oQqRgT1ebzgUUvEw8A03XB+NRtWqdjICMADoHAEYAPTCZrM6HBLTr8fjPXLkSFtb m7whRPSdnp6WVx+NZu4w8OhoPB5Xq2AqlTr//PO3bNmsVsGTuVyuVIoMDAA6RQAG AL2QfQD4gx/8o5tvvllefYPBEI1GOfoLdfn9fp/Pp+Lr6rvf/e7w8JBa1U7GMWAA 0DMCMADohdQA7PP53W632WyWVF+k31gsNjMzI6k+GtbcRmifL6zezcBvvvnmFVdc Ybf3qlJtgclJTzgc5j8EANAtAjAA6IXUA8BnnfX/ffvb35ZUfM18SkkkEvLqo5Gp uxFa1Lnpppvy+Zwq1RYYGhpWccM2AEB1BGAA0IvmZkt/f7+MyoODx1wuV1dXl4zi a+Y7P0ejUVa9II/P7/d5vWotAh84cODZZ59RpdQCLpc7m83MzHAQAAB0igAMAHrR 0dGxdesWGZVttpZDhw7JqFySTqczmYy8+kChUBifmIhGIqpUGx8fv+aaqzs7O1Wp tgCNoAFAzwjAAKAL69at3bp1q8Eg5X+W/8f/+PPLL79cRuU188u/4XBYxYtqgEX5 A4G5blhqbDRIJpO3335bRKU4vcDAgJPfBwGAbhGAAUAXWlpsdrusDlg/+ME9u3bt klQ8nU7PzKP/M6QqFAqTHk84FFKl2kMPPfTyyy+pUmoBAjAA6BkBGAB0QV4L6OHh kUAgIKPycSaTSbwtzhMx+HgeFm9L7zQajeIJpfdLnQnqmz8Q8Pv9M4VC5aWeffbZ Awd+UXmdkxGAAUDPCMAAoAvyArDX6xsbG5NRuRylTd0iAB/f3S2C8fGcfPztgpxc ek+15gzdKhQKXp8vpMaVSK+99trVV18to+86ARgA9IwADAC6IG8L9MDAwJtvvrV5 82YZxdWyRE4+MSqvmV9nPjEns++60YgMPDI8nJierrAOW6ABoDERgAFAF+StAK+Z b/nz9NP/b/369ZLqa+bknHx83/WCnFzafW0ymY6/v5rzhqo8Xm/A769kEfiNN964 8cYbN2/epOKsjiMAA4CeEYABQC+kZmCfz3/ppZfu2bNHUn1dOR6PFUUpPSj+1onn k9fMrzOznlxzKlkETqfT991338GDB3t7d6o+sRICMADoGQEYAPSip6fn9NNPkzqE CHtf/eq+s88+W+ootWLR9eTS1usFfbzEAxaTdWXC45ny+1f0Iblc7pFHHnn88ce6 urokzWrN/EvI5XJzDzAA6BYBGAD0orm5ub+/T4OBstncpz71qb1799psNg2Gq3Wl eHziYvKJIfl4Qj6x0zUdvGSbawft85XZVDwUCv3oRz969dVXu7tPlz2xwcFjqVSK 35IAgG4RgAFAL6xWq4yetKcyPDzy3ve+98Mf/vAXv/jFtrY2zcatP6fq4DVzgtIG bJGiSciqKBQKE5OTkXB4ieeMjY0dPHjwN7/5jXig2X9ZY2Pj4SVnBQCoLgIwAOiF 1DPAS3C7B+12+7vf/e4//dM/OeecTzU1NWk/h7q3YBn5xLugBBHnSMgr5Q8EfF7v grXW6enpp59+WoTeoaGhrq7O47+S0EwoFB4fH9d4UABA+QjAAKAX1QrAJxocPLZt 2za7vfd3fud3P/ShD/3RH/2R9hGiMS2akBesIZeOIpOQSwqFwvjERMDvf/XVV996 6y0ROz2eyWAw2NenxTmCU6EDFgDoHD/WAICObNjQvWHDhmrP4j8NDQ2fccYZGzdu nE/F9rPOOusDH/gAS8RVcXJCPr6AfOI5ZPFAJMN6PYMajUZffPHFI0eODA0NTU5O TkxMhEKhqv/a6Dg6YAGA/hGAAUBHND4GvApOp7Ozs0tYv3796aef3tPTs2XLFofD 8b73va+jo6Pas2tcC84hn3g38vGO1rWygCzmFggEfvOb3xw7dkykXL/fFwyGwuFw MBjs6dmo5y0JExOTkUikzNZcAICq0O93EQBoQHrYBb1qw8Mj7e3tbW1ta9euFW/F 43Xr1omo3NnZKaJyd3e3SMubNm2i4VZVlLOALJ5T2nctaQFZFI/H4555U1NToVBI xEWRbBOJeCwWTyaTid+Sd0mvVAMDA5lMttqzAAAshQAMAPqiwW3A1eV2D1osFuuc ZrPZ0tzcLP4o3prnNM0/nHuP+EPp/aU/mkwm8aCpqUk8aGlpEQ/EU6xWm3jQ2tp6 Yn2Rwav1T6tlb/88kEql1vx2ATmfz4ssms1mRTTN5XLij+JBoVBIp9PisXiQEWnv t3Lzjj8WTxB/W3pPPp9LpzPio8Qfa/f3O8ti/zMA1AQCMADoS00vAgMNy+fzTU0F 2f8MADpHAAYAfTGZTG1tbVu3bqn2RACsgNPpYvkXAPSPAAwAusMiMFBbPB5vKBRi +RcA9I8ADAC609Rk6uzs2rhRR/chATgVTv8CQA0hAAOAHrEIDNSKYDDk9XpZ/gWA mkAABgCdammx2e1kYEDXhoaGk8kk6RcAagUBGAB0ymg0dnV1nXFGT7UnAmBxbH4G gJpDAAYA/VIUpanJ1N/fX+2JAFiE0+nK5XIs/wJADSEAA4CucRgY0Ccu/gWAWkQA BgC9a21t6e3trfYsAPyniYnJSCRC+gWAmkMABoAa0NLSYreTgQFdGBsbi8XipF8A qEUEYACoDa2trb29O6s9C6DRsfYLADWNAAwANUNk4J07dxgM/E83UB1ery8Y5Nwv ANQwfooCgFpis9kURRExuNoTARqOy+XKZun5DAC1jQAMADXGaDRaLJa+Pke1JwI0 CqfTJd5y4xEA1AECMADUJJvNViwWicGAbOPj49FojOgLAPWBAAwAtUpRFIvFwi3B gCSDg8dE7s3n84VCodpzAQCogwAMALWNpWBAdU6ns1hcI6IvC78AUGcIwABQD0QM bm1p6Tmjp9oTAWob0RcA6hsBGADqh4jBa9YUHQ5Wg4EVK214ptMVANQ3AjAA1JvS pmhFUXp7d1Z7LoDeif9Y/P5APB7PZrNEXwCoewRgAKhbpSRsMBholAWcbGJiMpVK ip+FUqlUtecCANAIARgA6lypWbRIwmZz0/bt26s9HaCaxH8IU1PBaDQqHpN7AaAB EYABoIHMHxJeMzs7azabd+wgDKMhiNA7OelJJpMGw9yPPeReAGhkBGAAaFClMCyy wdq17d3d3aVsANQHl8s9MzNjNBoJvQCAE/HjDgDg7TAsiLBgt3NgGDVpaGg4n88b 5qzJZnOFQqHaMwIA6A4BGADwn0QSpmMWatTExEQwGKr2LAAAukYABgD8J6vV2tfH NcKoSYODx1Kp1OzsbLUnAgDQLwIwAOBtTU1NFotF3u3BAwPO/v4+ScVRE4rFotPp kvcyEK+xTCYjqTgAoA4QgAEAb5O6/3lw8NjY2Fgul/POi0QisXnJeel0OjMvn89n s+JtIT+vUCjMzMyIBzPzZueIP869U0SpbDZbeufxUeb+emZG0j+h7hkMBkVRTmyH psxramoyGo1NTSZFMYkHpU++eJrJpBiNpacopjnimeameeZ5Vqu1ubm5paVFvLTW rl3b2dm5fv363/zmNw899FNJ/wSv1+f3+yUVBwDUAQIwAOBtUvc/i0x0+PBhFQuK rCvys4oFUQ6ReycmJwMVhMypqalLL72kq6tLxVkdNzQ0nEwm+SUIAOBUCMAAgLed fvrpPT0bJRX/L//lg1//+tdVLChyTi6XU7EgyjTp9QZ8vlV/eCaT+eY3b41EIipO 6bhisehyudJpdkEDABZHAAYAzJG6/1nEkn/5l7t+7/d+T62CJpMpGo3m83m1CqJ8 Pr/f6/FUUuHgwYNPPfXvas1ngWAwNDExIak4gP+fvTsPjLq69z7OLCHJTMIaBNkh CUHvre1tvc9Vu7nUrfbW9tbW2tZd+rhcq4KAKAKVfVFCccOqV1u1rnUDcUFaQcGK gqjILNm3mUySmcyWWTPz/ID7IGUNyTlntvfrv1r8noMzmfw+c875HiDTEYABAHtI DcBer89isQgsqNPp3G63wILoOVdbm9Ph6Ms2Y6fTOW3atLFjxwic1X719Q2SlpcB AFmAAAwA2MNkKpw0SdYB4NLSsmeeeUZgwUgk0tXVJbAgei4ejzfU13t9vl5XCAQC ixcvTiSknNS12ezhcJjLkAAAh0UABgDsWf4tLy87sP2vWP/93zdffvnloqpp8/T5 fFoME1UQx6uhqamjra3X/7r22v3lL3/58stdAqd0oN27LZFIRFJxAEBGIwADAOTu f25sbGxqatbr9aIKGgwGt9vNEl8K9bEPlqahoeHWW2+pqJByIXBzc0tbH/I5ACCL EYABAHIvQBo4cNDbb78tsGAymezs7BRYEMer732wvF7vnDlzTKZCUVM6UHV1TVdX F5chAQAORQAGAPQbMGDAxIkTJBW/6KIfaVFHYMFQKBQOc89NKvW9D1YkElmzZo3D 0acUfRQWi5U3CQDgUARgAMh1Uvc/W63W6uqaoUOHiiqo0+m8Xi+Le6kVj8fr6+t9 feiDpXn//ffXrVsrakoHaW11ORwOScUBAJmLAAwAuU7q/ud4vPuTTz4RWJADwGmi obGxo729LxVcLtcdd9wxfPgJoqZ0oLq6evbJAwAORQAGgFwnNQB/4xv/tmbNGoEF OQCcJppbWlytrX2pEAwG77vvXknXWVkslmg0xhclAICDEIABIKdJ3f+sWbRo8Tnn nCOwIAeA00Tf+2Bp6fTVV1/96KN/iJrSQTo63I2NjZKKAwAyFAEYAHKa1ADc2uqq q6sTWJADwOnD1dbmcDgSfXstmpubb7vtttLSiaJmdaCmpqb29g4ZlQEAmYsADAA5 raCgYPJkKXexak48ceQrr7wisKDRaOzo6GBfazoQ0gfL7/fPnz/fYBB2R/SBqqqq u7q6eLcAAA5EAAaA3GUwGPLz8+WtAF9xxZU33XST2Joej0dsQfRa3/tgRaPRJ598 sqamWtSUDmKxWMLhiKTiAIBMRAAGgNwldf9zTU1tU1OTFrAF1oxEIpJ6JqEX+t4H S7Njx47nn39OyHwO5XA4W/s8QwBANiEAA0Duktr/uaCg8L333hNYUKfT+f3+WCwm sCb6wul09v2uXZfLNWfO3YMHDxYypYPU1NQGAgF2QQMA9iMAA0DuGjp06JgxoyUV //73z1y2bJnAgkaj0e120wErfbja2rQE3MdXJBwOr1692u2W1a3KYrHSNhwAsB8B GABylNT9z8lk8oknnjz55JMF1tTpdFoAFlgQfSSkD5Zmw4YN7767QciUDuVytbX0 7bomAEA2IQADQI4qKjKXlZVJKu73B7788kuxNbW45ff7xdZEH/W9D1a/PSd1HTNm zBg9epSQKR2ktrY2EAiycQAAsA8BGABykdTlX01JybB169YJLMgB4PTU7HC4nM4+ FvF6vb///e/z8/sLmdKhmhqb2ju4EBgAsAcBGABykdT2V5rbb5/+85//XGBBDgCn J2drq6PPG4y1l/W55577/PPPhEzpUFVV1aFQV3c3rbAAAARgAMhJgwYNGj9+nKTi Wt5ob2/X6UT+iuEAcHoS0gdL89lnn/3lL88ImdJh0QoLALAPARgAco7s/c86nf7D Dz8UW1NLL6FQSGxN9F08Hm+or/f2uQ+Wy+W68847hw0rETKrQzU3t7S1tUkqDgDI IARgAMg5JlPhpEkS9z//+McX33XXXQILGgwGv98fiUQE1oQoDU1NHX3OltqLu2bN GodDVrvmmpraYJBWWAAAAjAA5J5hJSWj5HTc7bf3AqS1a9edcMIJAmtqAbijo0Or LLAmRBHSB0uzZcuW119/re91Dkt789hsdjYRAAAIwACQW2Tvf/Z4Om02m9ia3d3d fb9sFpII6YOlaWlpmT59+tixY/pe6gj1HS6XS1JxAECmIAADQG6RHYC/8Y1/W7Nm jcCCOp0uEAhEo1GBNSGQqD5YwWBwxYoV4bCsRdqa6hof90gDQM4jAANAbpF9AdKq VX847bTTBBY0GAwej4fTm2krHo/XNzT4vN4+1kkmk+vWrfvgg/eFzOpQFoslGo0l ElyGBAA5jQAMADlE9vJvS4ujsbFRbE0tsXj7HK4gVWNTU7uIHssNDQ1Tp04tLy/r e6nD2r3bQis1AMhxBGAAyCFSA3AymRw5ctQrr7wisKZOpwsGg4SWNCeqD5bP55s/ f77RaOh7qcNiFzQAgAAMADlE6v7ncDjyySefGI1GgTUNBkNnZ2c8HhdYE8KJ6oPV b8+Fvc2zZ88eMWK4kGoHYRc0AIAADAC5wmQylZeX6XSyPvlPPfXfH3jgAbE12f+c Efb0wXI6u0V8TxEMBleuXBkMBvpe6rDYBQ0AOY4ADAC5Qvb+54cfXvPNb35TYE0t q/v9/lgsJrAmZBDVB6vf3jfS+vXrN2/e1PdSh1VbW+v1cqUWAOQuAjAA5Aqp+5/9 /sCXX34ptqbBYOjo6NASkdiykKGxubld0C27LS0tM2fOHD16lJBqB7FabZFIhF3Q AJCzCMAAkBPMZlNZmcT9z//6r1977LHHxNaMxWKBgKytsBCrxeFoFdEHS6O96CtW rIhEwkKqHYpd0ACQywjAAJATZF+AdOdds39y8cUCV2sNBoPf7yeoZIpWl8vR0iLk DZBIJF5++eWPP97W91KHVVtbx8FyAMhZBGAAyAkmU+GkSbL2Pzc3t1itVrPZLLCm Tqdzu90CC0KqeDxeV1fnF3TJUFNT0/Tp08ePHyek2kHYBQ0AuYwADADZT3b/54ED Br79zjtia3Z1dbH8m1nqGxrcHR1CSmlBesmSJYlEt5Bqh7JYLOEw7y4AyEUEYADI frL3P19z1dX/94YbBBbk+t9M1NTS0tbaKqRUd3f3iy+++OmnO4RUOxS7oAEgZxGA ASD7yd7/XF1VlV9QILCmln98Pu6qyTAOp9PpcIiq1tjYOH369AkTxosqeCB2QQNA ziIAA0CWk73/eUBR8TvvviuwoDZVr9erZWCBNaGAq63N0dIiKlX6/f7Fixcnk7Iy Kr2gASA3EYABIMvJ3v98xW8uv+nmmwUW1Ov1HYKOkkKleDxeX18vaum+u7v7hRde 2LnzUyHVDlVbW+v1sssAAHIOARgAslxhYWFFhaz9z01NzTXV1WL3P4dCoXBY1h2w kKqhsbGjvV1YtYaG22+/vbR0oqiCB7JYLNFojF3QAJBrCMAAkM1kL/8WFhRu2LjR aDCIKmgwGDweD/ufM1RzS4tLUB+sfuyCBgBIQAAGgGwmOwBffPFPfnfrrcVmczKZ FFJQq9PZ2SmkFNRztrY6WlpEVevu7n7uuec+//wzUQUPUlNd4xN0cTEAIFMQgAEg mw0bNmzUqJGSijc2Nn7xxa4BAweKWgHW6/V+vz8ajQqpBvVcbW1Oh0PgAn59ff30 6dPZBQ0AEIUADABZS/byb37//I1//7vA/c+xWCwQCIiqBvX29MFqaPCJu2LX5/Mt WrRIWgtzdkEDQM4hAANA1pJ6/a/moh/959Rp00TtfzYYDH6/nzSS6Rqbmtrb2kRV 6+7ufvbZZ7/44nNRBQ9SW1sbCAQ5cw4AuYMADABZa+jQIWPGjJFUvLGh8Ytdgvc/ c/tRFmhxOFqdToEFpe6CTiaTNps9FArJKA4ASEMEYADITrL3PxcXFb+7caOo3lea SCTS1dUlqhpSpdXlcjgcSXEHa2X3gm5pbnGJW7IGAKQ5AjAAZCep1/9qrrn6mv97 /fWiqhkMBp/PR/urLLDnGHBdncDuyt3d3S+++OKnn+4QVfAg1VXVXaEQu6ABIEcQ gAEgOxUVFZWVlUoq7mhx2O32/IICUQV1Op3b7RZVDanV0NjY0d4usmBDw8yZM8eP Hyew5oEsFms4HJZUHACQVgjAAJCFZO9/Lhlasu6NNwQWDIVCJJCs0dzS4mptFVjQ 7/cvW7YsHo8JrHmgxsYmzp8DQI4gAANAFpK9//nOWXf+7JJL4vG4kGpGo7GzszMW kxVvoJiztdXR0iKwYCKRePXVVz/66B8Cax7Ibq8Kh8PsggaAXEAABoBso9fr8/Pz 5QXg1lZXbU2NTq8XWNPj8QishtRytbU5HQ6xebKxsXHWrFljxowWWPNA7IIGgBxB AAaAbCN7//OoE0f+9ZVXBBYMBoO0v8ome/pgNTT4vF6BNQOBwL333hsOy7qvqL6+ gW9hACAXEIABINuYTIWTJsla/k0mk8uXLT/nBz8Qtf/ZYDBowYPdp1mmqbm5zeUS W3Pt2rUffPC+2Jr7Wa22SCSSEHd7EwAgPRGAASCrmEym8vIynU7Wx3tHe4fdbhe4 /1mLvj6fT1Q1pAmH0+l0OMTWbG5unj179ogRw8WW3c9isYTDEUnFAQBpggAMAFlF 9v7n8WPHPffCC6KqaUHd7/fT/ir7uNraHC0tYhdUg8FgZWVlICDshuGD1NXV+3w+ FoEBILsRgAEgq5SUlIwePUpScYvFsmP7jtKysmQyKaSgXq93u92iqiF97DkGXF8v fG1/w4YN7767QWzN/bT3oc1mD4VkHTMGAKQDAjAAZA/Zy79dwa4vdu0SmFdjsVgg EBBVDWmlsampva1NbE2HwzFnzpySkqFiy+7X0uJwiT66DABIKwRgAMgesq///bev f+PhRx4RVU2n03m9XtpfZasWh6PV6RRbMxwOP/zww62tgsvuV1VVHQp1dXezCxoA shYBGACyhMFgKCgoKC8vk1RfywZWi6Vk2DBRBfV6fUdHh6hqSDetLpfD4UiKPlK7 devW1157VWzNA3EhMABkNwIwAGQJ2fufk4nkR9u2CSwYiUS6uroEFkRa2XMMuK7O 5xfcs8rlct1zzz3FxUViy+7X2NjE9zIAkMUIwACQJWQH4PPPPe+eBQtEVTMajV6v NxqNiiqINNTQ2NjR3i62pvaeeeKJJ2pra8SW3c9mtUWiEXZBA0C2IgADQDaQff1v Q31DTW1tYWGhwJoej0dgNaQhGceANTU1NTNmzJC3258LgQEgixGAASAbyF7+LTIX vbtxo8CCwWCQ5d+st+cYcEuL8GuuvF7v4sWLpX3b06+2ti4QCNCeDQCyEgEYALLB oEGDxo8fJ6/+lGuvu+63vxVVzWAweDweAkbWi8fjdXV1ftHHgLV3zosvvvjppzvE lt2PC4EBIIsRgAEg48le/nU6W21Wa35BgaiCWi4SHoqQnmQcA9bU19ffeeedY8eO EV55n+bmljbRlxgDANIBARgAMp7s639Hjjjx5VeFXTyj0+l8Pp+WgUUVRDprdjhc Eo4BBwKBe++9NxyWtUi790LgEJsUACD7EIABILPp9fr8/Hx5Adhisfzjw3+cdPLJ ok5yahN2u93Cz4UiPUk6BqxZv379pk3vCS+7HxcCA0BWIgADQGaTvf+5q6vriy92 CQww0Wg0GAyKqoY0J+kYsKalpWXu3LklJUOFV96nvq7e5/ezCAwAWYYADACZraSk ZPToUfLqn/Z//mPV6tWiqhmNRp/PF4lwx0wOkXQMOBwOP/LIIw5Hi/DK+9AKCwCy EgEYADKY7OXf2tq6Krt9wMCBogrqdDq32y2qGjKCpNuANXa7febMGRUVFTKK99uz yOxwuVySigMAUoIADAAZTHb7q4L8gvc2bRJYsKuri+XfXNPqcjkdjkQiIbxyZ2fn okWLDAa98Mr72O1V4XCYXdAAkE0IwACQqQwGQ16ecfLkyfKG4Ppf9F08Hq+vr/f5 fMIra++l559//rPPdgqvvB+tsAAgyxCAASBTyd7/3OZy7d5t4fpf9F1jU1O7nGt1 tWg9Z87dI0eOlFG8H62wACDrEIABIFMNGTx47Lix8upPHD/hL889J6oa1//mMnnH gIPB4KpVq/x+8cvL+9AKCwCyDAEYADKS7OVf7aH/888/HzNmjMDrfzs6OoSUQsZx tbU5HI6EnHXUDRs2vPvuBhmV92lpbnHJWb4GAKhHAAaAjGQ2m8rLJQbgeCy+fccO gdf/hsNhltFy1p5jwA0NPq9XRnGn0zl//vwBA4plFO9HKywAyC4EYADIPCaTln7L dDqJn+Hn/uDcBQsXiqpmNBo7OztjsZiogsg4TS0tba2tMipHo9HHH3+8vr5ORvF9 aIUFAFmDAAwAmUf2/ufGhsbqmprCwkJRBZPJpBaARVVDJmp1uRwtLQL3FByourp6 1qxZpaUTZRTX1NXV+2mFBQBZgQAMABkmLy/PVFgwYaKsZ33NCSXDXl+3TlQ1nU4X CASi0aiogshE8Xi8rq5OUhtwrezK++4LhSXusbdabezhB4AsQAAGgAwje/lXe9Df 9tFHkyoqBLa/8ng8iURCSDVkrobGxo72dknF17/55qb3/i6puKapsamdLm4AkPkI wACQYQoLCysqJsmrH41EP925U+BW1VgsFggERFVD5pJ3GZLG4XAsWLBAXissq9UW iUT4HgcAMh0BGAAyiezlX8355553z4IFoqoZDAafz8f+Z/STfBmS9h576qmn7Hab jOL77N5t0TKwvPoAAAUIwACQSWQv/zY3t9jtdoHtr3Q6ndvtFlUNGS0ejzc0Nnql tUOrqam56667xo8fJ6l+VVV1KNTV3c0iMABkMAIwAGQMg8GQl2ecPHmyvCFGnjjy 5VdeEVgwGAyy/Iv9mh0Ol7Rd0H6/f/X9q/0+n6T6/bgPCQAyHwEYADKG7P3PNpt9 +yefTCwtFXUAWEvsbrebY5PYr9Xlcjoc8t4SmzZtWr/+DUnF+3EfEgBkPgIwAGSG vDxjYaFp4sQJ8oaIRWMfffyx0WAQVpD2V/hn8Xi8vqHB5/VKqu90OhcuXFhUZJZU vx/3IQFAhiMAA0BmUND+6pxzfnDn7NnFZrOQFWDaX+Gwmlpa2lpbJRWPxWLPPf/8 ri8+l1Rf09jY1MF9SACQsQjAAJAZZLe/amlx7Ny5c8DAgaJWgGl/hcNqdbkcLS0C 79k6iNPhuH369DFjRkuqb7FYotEYG/sBIEMRgAEgAyhY/h07ZuyLL70kMJbQ/gqH tWcXdH29T1qrKu2N98ADD3g8Er984T4kAMhcBGAAyACyA7DdXrXriy9GjhpF+yso 0NTc3OZyyav/4YcfvvqqyGbmB7HZ7OFwmLc3AGQiAjAApDst/ZaXl+l0Ej+x84x5 H2zZInD5l/ZXOArZu6Db2tqWLl2Sl5cnqX6/vRuhw2EWgQEg8xCAASDdyT79q+WQ G2648eqrrxZVkPZXOLp4PN5QX++Vtgs6kUisXbt269Ytkuprqququ0Ih7kMCgIxD AAaAtKaFybw84+TJk+UN0enp/Oyzz/ILCkQVpP0VjklqL2hNR0fHrFmzhg4dIm8I i8UaDofl1QcAyEAABoC0pqD91Rmnn7GyslJgQdpf4ZhaXS6nwyHvGG0kEnnyySdr a2sk1dfU1dX7/X4WgQEgsxCAASB9GQz6wkJTWVmpvCEaGxqrqqpMZrOognq93uPx 0B8IR7enF3RDg8/rlTeEw+G45ZZbSksnyhuCRWAAyDgEYABIXwqWf0eNHPXXl18W WDAajQaDQYEFka2aHQ6X0ymvfiAQWL16tc8nMWPX1zf4fD4WgQEggxCAASBN5eXl mc3m8ePHyRvCbq/64vPPR40eLaofr9Fo9Hq97H9GT8jeBa35YMuWta+/Jq++xmq1 hUIhqUMAAAQiAANAmlKw/FuQn79p8/sCb6PRwoxX5qZWZJM9vaAbG72dnfKGaG9v X7x4cf/+Eu9Dampsau/okFcfACAWARgA0tSwkpJRo0fJq6/l3tmz7/6v//ovLYcI KajT6Xw+n6hqyAXOveRdCKxVXrdu3QcfvC+pfr+9FwJr731OAgNApiAAA0A6UrD8 G/D7v/hil06vF1WQ249wvOLxeF1dnd/vlzdER0fH7NmzBw0aKG8Ijc1m7+rqkjoE AEAIAjAApKPCwsKKiklSh7jw/Avm3XOPwIJaAIhEIgILIhc0NTe3uVzy6sdisWf+ 8hfL7i/lDaGpranx+iTGeACAKARgAEg7CpZ/W1tdVoslv6BAVEGDweDxeGiHi+Ol oBWW0+mcPn36aJkHCvqxCAwAGYIADABpx2QqnDRJ7vLvN075+po//lFgwXg8LnUj K7KVglZYoVDo0ccea2lukjeEpra2jg5wAJD+CMAAkF4ULP82NDTabLbi4mJRBQ0G g8/n4/Yj9I7D6WyV2QpL09jYOHXq1LKyUnlD9GMRGAAyAQEYANKLggA8auSov778 stiaHo9HbEHkjj2tsGpr/YGAvCECgcAfVq/2++Su0NbV1XfKXMoGAPQdARgA0oiC 9FtVVf3ll1+OGDFC1IKbTqfT0gXLv+iLxubmdpmtsDTvv//+unVrpQ7Rj0VgAEh7 BGAASCMKAnCRuWjj3/4mcLupXq93u91S968i6ylohdXW1rZixQq9Xu6TD4vAAJDm CMAAkC4UpF+b1bZ169aTTj5ZYF4NhULhcFhUNeQmBa2wNG+99dbf//43qUP0YxEY ANIbARgA0oWCAGw0GLds3Sow/XL7EURxtrY6HQ6pWwmcTueSJUsKC4Xd/nVYLAID QDojAANAWlCQfi0Wy9///t6pp54qMK9Go9FgMCiqGnLZnkXg+nqvzydvCC1dP//8 859+ukPeEPuwCAwAaYsADABpQUEADoXCn33+eT9xK2xGo9Hr9dL+CqKouQ9p0aKF gwYNkjeEpramxuvjWmwASEcEYABIPQXpV/Of//njW6dOLTabRQWMRCKhBWAhpYB+ ++5Dqqvz+yVGR22IJ554orq6St4Q+7AIDADpiQAMAKmnIAB7PJ1btm4dNGiQ0WAQ UtBgMGhBJRKJCKkG7NPc0uJqbZU6hJaxb7/99vLyMqmj2O1VnA4AgDREAAaAFFOz /Hv22efcdffdApd/++0J1R5RpYB9XG1tTqezOx6XN0Q0Gl28eHE4HJI3xD4sAgNA GiIAA0CKFRYWVlRMkjpER3vHR9u2DRg4UNTyr06nCwQCnP6FcPF4vLmlxd3RIXWU mpqa6dOnK2g7Fw6zRQIA0gsBGABSSdHy71lnL1m6VODar16vd7vdUpsVIWe1ulyt TqfUu7UikcjChQtjMenf4LARGgDSDQEYAFJJwfJvm8u1e7clv0Dk3aehUCgcDgss COynZhG4qqpqxowZsn/6ksmkNlAwyEZoAEgXBGAASBmz2Sy7E4/m9P84rfIPfxBY 0GAweDweqQt0yHEKFoHD4fD8+fMTCelvY6vVFgpJP28MAOghAjAApIbZbCorK9Pp 5H4OO52tFoulsLBQYM1oNMquTkilZhHYbrfPnDmjoqJC6ij96IYFAOmEAAwAqaHm 9O9p/+c/Vq1eLbCgwWDwer2xWExgTeBQChaBQ6HQggULFCwC795t0SI9myYAIB0Q gAEgBRQt/zqcFqtV7PKv9hzv9/sFFgQOS3untTgc7o4Oqb3WlC0CV1VVBQLsmwCA 1CMAA0AKqFn+/dY3v/XgQw8JLGg0Gr1eL7cfQY1YLFZfV+cPBOQN0dXVtWDBgmQy IW+IfbQYb7dXsREaAFKOAAwAqmnpt7xc+vKvw+G0il7+TSQSWgAWWBA4uhaHw9Xa KnUR+PPPP58zZ87kydIXgemGBQDpgAAMAKopuPqon4TlX4PB4PP5WP6FSvF4vL6u zidt130ikVi8eLHf75P9hdQ+dMMCgJQjAAOAUmo2P8to/pxMJjs7OwUWBHrCob2b nU4Zi8Bbtmx56KGHRo8eJbzykezevXtvMyy6YQFAyhCAAUCp4gHFpRMnyh7ljNPP WFlZKbCgTqfz+XzxeFxgTaAn9iwCNzT4hO697+rqmjt3rsGgV7PweyCbzdbVxUZo AEgZAjAAqKNm+bfN5dq925JfUCCwppYT3G63wIJAzzlbW50Oh6hF4D//+c+vvvpq eXmZkGq9wEZoAEghAjAAqDNw4IAJEybIHuXss85evGSJwIJa+g0EApz+RarE4/HG pqZOj6ePdaxW6/Lly4cNKxEyq17jWmAASCECMAAoomb5t6PDveuLL4Qv/3o8Hqmd eIGja3W5Wp3OXodGLXDOn39PJBJRv+f5sOx2ezDIIjAApEBa/BoAgKyXl2fMy+uv IAD/8MIfzp03T2zNYDDI8i9SS0uwLU6nu729F1/ErF279umnnxo/fryEefUeG6EB ICUIwACggslUOGmS9KuPOto7du3aJXb5V6/Xu91uln+Rcr24Esnn891xxx0DBw6Q N6tes1gs0WgskUikeiIAkFsIwAAgncFgyMszTp48WfZAF/3wojlz54qt2dXVFYlE xNYEese5Vw+/jlm5cuXmzZsqKipkz6rX7PaqYDCY6lkAQG4hAAOAdGazqbxc+ubn lhZHdVVV//x8gTX1er3H42GRCmkiHo83NDZ6j3Uf9ebNmx9++OGxY8eomVWvaUle y8BshAYAlQjAACCXyaSl3zIFrXdu+d0tl19xhdjWsiz/It0cvRtWOByeOXNGYWFh mjS7Oordu3cbDAbuBAYAxdL91wMAZDrtWbyiQvrpX1erq6GxUWz6ZfkXaSgejzuc zo7DdcN68MEHN2zYoODHre9sNlskEunu5ocLAFQjAAOARGquPtKSwOzZd1988cVi W1WFQqFwOCywICDEno3Q9fVen2//P7Hb7fPn3zNq1KgUzqqHdu+27F34ZdszAKQG ARgAZDEajVoAnjhxguyB3G5PVVWV2PTL8i/SmbO1tdXp3Pf+fPrpp19++eXy8rJU T+rYbDZ7JBJm4RcAUogADACyKFv+vX/1/f9x2mks/yJ37LkW2OH4bOfOJUuWFBWZ Uz2dY7NYLHo9C78AkHoEYACQQtnVR8FgcNeuL1n+RU6JxWLTpk1bt25d+i/8aj+b VVXVoVCIHygASAcEYACQQtny71N/fmqS6JtOWf5FOnvxxReXLl06dOiQVE/k2CwW q16vZ+EXANIHARgAxFOTfjWJ7sS2jz8WW5PlX6Qt7Z05ZcoUv9+XIbccGaPRaDwe T/VcAABfSfffHwCQcfLyjMVFxWPHjZU9kMVisdrsI4YPF1uW5V+kp8rKyscee2zU qJGpnsixWa02LfqKvZYMACAEARgABFO2/KsN9Pq6N4rNZoEHgFn+RRpqaGiYMuW6 9F/17cctRwCQ9jLgdwkAZBDt2bd///4VFZNkD2Sz2b/44ovhI0YYDQaBZbUH90gk IrAg0BeJROKuu+566aWXFFwn1nd7bzmKsPALAOmMAAwAIpnNpvJyFcu/k8onPfX0 08KbP7vdbrE1gV7buXPnTTfdWFRUlOqJHBu3HAFApiAAA4AwyjY/NzU11dXV5+Xl iS0bDAaj0ajYmkAvhEKhW2+95e23364Q3eFcOG45AoDMQgAGADEMBkNxcfH48eMU jHXWmWctXbZM7FKtTqfzeDws/yLl/vSnP61aVTls2LBUT+TYrFab9oPDwi8AZBAC MACIYTaby8vLFAzkdLbW1dWJbQikVQsEAiz/IrU6OjquvfbaUKgr/ftd7Wt2Fdsr 1XMBAByHdP8FAwAZwWQyaelXzVP7f/7oP2fffbfYmtrM3W632JrAcVm+fPkTT/zP mDFjUj2RY6PZFQBkLgIwAAhQWFiooPOzxu322Gw24cu/Pp8vHo8LrAn0XE1NzZQp U/LyjKmeyLHR7AoAMh0BGAD6SlnvK81VV119ww03CC/r8XiE1wSOKR6Pz5o165VX XiktnZjquRwDza4AIDsQgAGgTwwGfX5+gZoAHI/Ft+/YIbZPlcFg8Pv93P0L9Xbu 3HnDDTcMGFCc6okcG82uACBrEIABoE+UXfyr5d677pp98cUXCy/b2dkptiZwdBl0 y9G+ZldEXwDIGgRgAOg9lZuf8/MLNm3aJLam0Wj0+Xws/0KlZ599dsWKFSUlQ1M9 kWOz26vC4TDNrgAgmxCAAaCX9Hq9FoDLykoVjKU9iH/88ccTJwo+JxmPx/1+v9ia wJF0dnZed911fr8v/W85otkVAGSrdP8NBABpS9nFv5oJ4yc8+9xzYmsaDAav18st plDjwQcffOihh0aNGpnqiRzD7t279+55DqV6IgAAKQjAANAbKjc/NzY2Wq224mLB vYIikQgLXFDA6XRec801iUQGbCS22WyRSJQ9zwCQxQjAAHDcDAZDkdk0QfSG5CP5 7ne/t2LFCrE19Xp9Z2cnD/qQbcmSJU8++eS4cWNTPZFjoNkVAOQIAjAAHDeVm5+9 Xt+XX36p5VWxZbUHfXpfQar6+vprr73GaDSmeiLHkEwmq6urA4FgqicCAFCBAAwA x0fl5mft0fzmm393+eWXiy2r0+k8Ho/Y+4SB/bS31uzZs1944YWJEyekei7HwAW/ AJBrCMAAcByMRmNBQYGazs+agoLC9957T2xN7XE/EAhEo1GxZYF9LBbLlClTzGZT qidyDOx5BoDcRAAGgOOgPdaXlyta/q2pqd2+ffuYMWPEltUCsNvtFlsT0CQSienT p7/66qvKviHqnWQyWVVVHQyy5xkAchEBGAB6SuXmZ83pp59RWVkptqbBYPD7/Zz+ hXCff/759df/X+G9yoWz2+3JZD8WfgEgZxGAAaBHtOiYn5+vLAD7/YFdu3bpdII/ pbu7u30+n9iayHGxWGzatGlr165V+fVQLzQ3twSDQaIvAOQ4AjAA9IjJVDhp0iQ1 Y1mt1ldee/2s739fbJ8qLcN7vV4trgisiRz36aefXn/99YMGDUz1RI7GYrHo9Xou +AUA9CMAA0BPmEym8vIy4euxRzJq1OjnX3jBaDCILRuJRFj+gijRaPTWW29dv/6N ioqKVM/laKxWmzZVoi8AYB8CMAAcg8FgGDRooPBmVEfS1tb2xRe7tMgttqxer/d4 PIlEQmxZ5KZPPvnkxhtvHDx4UKoncjRVVdXaG54vfQAAByIAA8AxmM3m8vIyNWMl k8lbb73tV7/6ldiyOp0uGAzS+wp9lykLvzabPRwO840PAOAgBGAAOBrFm59POGH4 66+/LrwsVx9BiIxY+K2trY3F4iz8AgAOiwAMAEek1+sHDBgwfvw4NcN1dLg///zz wsJCsWW5+gh9lxELv/su+A2FQiz8AgCOhAAMAEekcvOz1Wpdv/7N008/XXjleDyu BWDhZZE7MmLht6mpuWuvVE8EAJDWCMAAcHgmk0nlvaYnn/wv//M//yO8rMFg6Ozs 1DKw8MrIBbFY7NZbb33jjXXpvPC795YjQywWjcV4nwMAjoEADACHodfrtQBcVlaq ZriurtCuXbtk7NsMhULhcFh4WeSCnTt3Xn/99QMHDkj1RI7GZrNFIpHubvY8AwB6 hAAMAIehcvm3qqr6o48+Ki0VH7Z1Op3H40kmk8IrI7vF4/Hbb7/9tddeU7kJ4njZ 7VXae5s9zwCA40IABoCDKd78fM45P1i0aJHwslr69fl8bH7G8dq1a9dvfzuluLg4 1RM5GrvdHg5Huru7Uz0RAECGIQADwD8xGAz9+/evqJikZrhEIrFjx6cyYqpW2ev1 Ci+LLJZMJmfOnPnXv/5V2eb/Xqirq49Goyz8AgB6hwAMAF/JyzMajXnK0m91dU1d XV1RUZHwylqM19JvLBYTXhnZqra29qqrriosLEj1RI6IW44AAH1HAAaArxQVmcvK FN17pD3N33jjTVrkkFGc3lc4Lvfcc89TTz01ceKEVE/kiJqbm4NBbjkCAPQVARgA /pfJZCovL9PpFH0wDh48eMOGd2Vsfqb3FXqupaXl6quvUva27wWrxarT67nlCAAg RPr+wgMAlQwGQ5HZNGHiRDXDNTU1OZ2tMlr40PsKPVdZWfnII2vGjh2b6okckdVq i0ajNLsCAIhCAAaAPVR2frZYLB9u/fCkk0+WUVyLCloAllEZ2aSzs/OKK66IRiOp nsgRccsRAEAGAjAAqL736NRvnbrmkUdkLNLq9Xqv18vyL47umWeeWbJkyciRJ6Z6 Ikdks9kjEW45AgCIRwAGkOsU33vk8/rsVVWSMmowGIxGozIqIztob49rrrmmrc2V tod+q6trtNzLwi8AQJI0/f0HAGpo6XfI4MGjRo9SM1xrq2vnzp0DBw6UUVyLNG63 W0ZlZIfPPvtsypQpgwcPSvVEjshut4fDLPwCACQiAAPIaWazubxc0b1HVqtt3bq1 3//+mZI2P/v9fpZ/cVjJZHLmzJkvvfSSsnf78aqrq4tGYyz8AgBkIwADyF2Kj/6e UDJs/VtvSdr8rEXfYDAoozIyXXNz8+WXX96/f16qJ3JEdntVKBRKJBKpnggAIPsR gAHkKIPBUFBQoGxBrL29fefOz4qKimQU1+v1Ho+H/IBD3X///Q888MC4cWl60VEy mayurgkEAqmeCAAgVxCAAeSowsJCZY2v7Paqd99999RTT+XiXygTDAavuOKKQMCf tv2u+u09FxAKhVI9CwBADknfX4oAII/Ko7+a8rLyvzz7rKTWPlz8i0Nt27bthhtu KCkZmuqJHAMBGACgGAEYQM4xmUxa+lW2LOb3+Xfs2JFfUCCjOBf/4iCJROL2229/ 5ZVXVJ5v7zWbzU7jKwCASgRgALnFYDCYzeaJEyeoGa62tu6D99+fVFGRTCZl1Ofi Xxyoubn517/+dUFBfqon0lMEYACAYgRgALlFZednLfR++4xvV65aJSn9ajwej6TK yDgPPvjg/fevHjs2TftdHRYBGACgGAEYQA4pKjKXlak7+huPxbds2SJp87PBYPD5 fCz/QhOJRK688gqPx5PO/a4OiwAMAFAsw35TAkCvKT7629Li+Pjjj4cPHy6pfigU CofDkoojg+zateuaa64ZPHhQqifSGwRgAIBiBGAAOcFgMBQXF48fP07NcFar7a8v vXTe+edLak+lxXiPxyNvZzUyxfz585988smystJUT6SXCMAAAMUIwABygsqjv5oT h49Y+8YbktKvFub9fn8kEpFRHJnC6/X+6le/6u7O7AbgBGAAgGIEYADZr6ioSOUS Waen89OdOwsLCyXVD4fDXJ2a47Zv3z5lynXDhg1L9UT6igAMAFCMAAwgyyk++ltb U/O3v7/3r//6r5L2J+v1erfbzebnXHb33Xc/88wz2rs61RMRgAAMAFCMAAwgmxkM hqKiogkTxqsZTva9R1r69fv9dH7OWdmx7flABGAAgGIEYADZTPHRXy0Bb9q0WdK9 R/3Y/Jzbsmbb84GsVhtvaQCASgRgAFlL8dFfp7N1+yefDC0pkVSfzc+5bM6cOU8/ /XR2bHs+kMVi5Tav1DKZTJFIpLu7O9UTAQBFCMAAspPio782m/3N9eu//Z3v0PkZ YgWDwcsuuywazc6X3m6v0v6CqZ5FjtLr9SZTYVlZmfbxRQYGkDsIwACy0N6jv+YJ EyYoG7GstOy555+XlH77sfk5V+3ateuqq64aOnRIqiciEceAU8JkMnV3x0866aR9 /5O96AByBwEYQBZSfPS3qyv08bZt8o7+6nQ6j8fD5udcc++9965Zs2biRHXf46QE AVg9s9l80HZ6LQBHo1EWgQHkAgIwgGyj+OhvY0Pjto8/Hj16tKSAyubnHKRFkcsv v7yz06NsD38KcQxYJe3zpH//vIqKikP/r9raukAgQAYGkPWy/zcrgJyi+OivxWJ5 5qmnL/7pT+Vtfg6FQsSDnNLQ0PCrX11WVFSU6okoov0QRaOxRCKR6olkv73bnrtP Omnykf6AzWbXPm14LQBkNwIwgOyh1+u12KByy+gJJcPWv/WWvPSr8Xg88ooj3WzY sOGWW343ZsyYVE/knySTydZW14gRwyXVZxe0Amazuays9JhfDnIYGEDWIwADyB4m U+GkSZOUDdfZ6f30008LCwsl1dfyvM/ni8Vikuoj3UybNu2ll16cPPmIC3Qp0dzc fMUVV+7atcvpdEgaggAslcGg798/v6KiR5+NFqstGomwCAwgixGAAWSJoiJzWZm6 W1Lr6urf37x5UkWFpKO/Op0uGAxy9DdH+P3+Sy+9NJFIu+OXiUTy7rvvLioq2rhx 4zvvvC1pFO2HyG6vIgPLYDab4vGjbXs+VE1Nrfbhw2FgANmKAAwgGyg++qs9r19w 3vnzFy6U15k5kUh4vV5JxZFW0vOuo7q6up/85KdaLN/3PyORyK9//euDWgcLZLPZ urrYeStYUVFRaenEXnwwcjMwgCxGAAaQ8QwGQ0FBgbxH80OZCk1vvvmmvHuP9Hp9 Z2cnT5+54IEHHli1alW63XXk9wfmzJlzwgknHPgPb7nlFpNJ1oZ/LW8Hg11s+BfI bDaVl/f+NjgOAwPIVgRgAJktL89oNOb18HibEO4O986dO01ms6T6Op3O5/NJbayF dJBMJn/72982NNSn1V1HWuw5++yzb7rppkNnpQV1eceA+3ESWByDwZCXlzd58mHu Ouo5i8Uai8X4Gg5A9kmjX7oA0Atms1nl2m9tTe3f/va3f/3a1+RtftYeOgOBgKTi SBPaS/yLX/w83VoNtba67rjjjiN1ktu6detrr70qb3SWHIU45l1HPVdVXRPq6iID A8gyBGAAGUx71Js0qfd7/I6XFnrPOvOsZcuXy0u/er3e7XbLq490UFNTc9lllw0e PCjVE/mK9pYzGvNmz55dcOSN/dqfufzyy8eMGS1vGiwC91FRkbm09Nh3HfWczWYL h2kKDSCrEIABZCqDQZ+fX6AyAPfP679hwwZ5R38NBoPf76fzc3Z79913b775v8eO HZvqiXylrq7+F7/4xU9/+tNj/sn58++RGlBZBO417dMjP7+/jHvgeFEAZBkCMICM pD3tDRkyZNSokcpG7Ohw79ixo7i4WN4QWrQg/Wa3u++++6mn/lxR0afDmWL5/YG5 c+cOGzasJ3/47bff/tvfNkqdD4vAvaB9HhqNRiHbng9lsVj2HgZmERhAliAAA8hI 6o/+bty48WunnCJvc7JWubOzU1JxpFw8Hv/1r3/t9abRS2y1Wr/3ve/fcsstPd8x m0gkfvOb34wbJ3H5mvXG47X30G/8pJNOkjdEfV29z+/nMDCA7EAABpB51B/9/f53 v7fivvukHv31er10fs5W2ov7X//1X3l5xlRP5CvNzc233z79lFNOOd5/ceHChYGA X8aU9mMRuOeUfRVotdqi0SgZGEAWIAADyDAGg6F///4q7z3KMxrffXejvKO/Op3O 7/dzA2q2qqmpufTSS4cOHZLqiXwlGo3Nmzevd/v5P/7445deelH4lA7U0uJwuVxS h8gCJpMpmUyq/CS026tCoRANsQBkOgIwgEyi1+sHDRw4VuYOzIN0tHfs+PRTqUd/ ufcoi73//vu//e2U9Gl5pWWYCy644LrrrutLkSlTppSUDBU1pcNiEfjoioqKSksn Kr5BWsvb2vuH1wVApiMAA8gkijc/NzY2btq0uaxM4g5D7j3KYkuXLl2zZo3Kd+zR OZ2td955Z3l5X+ej/aXq6mqFTOlI6urqfD4/i42Hpfhj8EC1tbWBQJCN0AAyGgEY QMZQf/T3yiuvuummm+QNYTAYfD5fNBqVNwRS5frrr6+trVG8RncU3d2JefPmaT9E fS/V1dV11VVXlZZO7Hupo6Ab1qH0en3//v0nT05lF3EOAwPIdOnyixkAjk7Linl5 xsmTpdzzcVhjx4574YUXpA4RDAZJv9knHo//8pe/lN0pqufs9qqLLrro6quvFlhz /vz5XV1BgQUPZbVao9EYQWu/vd2euyXddXRc7HZ7OBzhpQGQoQjAADKAln6Li4vH jx+nbETtyfuTTz7R6/XyhkgkEl6vV159pITf7//pT39qNBpSPZH/1drquuuuu0pL S8WW3b1795NPPiF7fZuTwPul5NDvUdhstq4u1ucBZKR0+SQFgKNQvPm5pcWxdevW 0aNHyxtCi/Qej4cllCzT3Nz8s5/9bNCggameyP9KJJLz5s0rLCyUUXzq1Kn5+f1l VD4QGbif8mvPe6KqqjoUCvEJBiATEYABpLuiIrPUNlQHsVgszz//wvnnny9vCL1e HwgEIpGIvCGg3q5duy677LKRI09M9UT2sNurLrzwwmuvvVbeEJs3b37jjXXy6u9T W1vn9+d0N6zCwkKVdx31HIeBAWQoAjCAtGYymcrLy1Ru/DvllK//8Y9/lDpEKBQK h8NSh4BiW7Zs0dLmOIUXdB1FS4tj1qxZCg7M33jjjQMHDpA9ihbmg0G5543Tk8Gg z8vLU9n44HjZbHbtoyyXv54AkIkIwADSl16vLyoqmjhxgspBP/zwH1LzdjKZ7Ozs lFcf6r3xxhu33HKL7K7IPRQKhebPXyD15ur9Xnvtta1btygYKAc3QqdPy6ujo1k3 gIxDAAaQvkymwkmT1O39a211ffzxxyUlJfKG0CK91+uNx+PyhoBiS5cuffjhhyoq UnkzzT5Wq/XMM8+6+eabVe6YuP766wcPHiR7lIaGRq+3s7s7V1Ya063l1VHY7VXh cJiN0AAySAZ8tgLITYr7vths9rVr137729+WN4T2OKulX54Us4mWNm02azoElbq6 +mnTpp166qmKx12/fv2mTe8pGCh3NkIr7vnXd83NzW43Lf0AZIzU/84GgEOpfwQ8 /fQzKisrpQ4RiURybRtndrviiitcrtZUz2IPt9s9f/6CE044ISWjqzkJ3C8HNkIb DPr+/fPTs+XV0Wkvjfb5RgYGkBEIwADSjsFgKCgoULn8qz10bt68WfYonZ2dyWRS 9ihQQHsdf/nLX3q9aXGWW6fTz5s3r39/6TcSHcnGjRvffvstBcvg1dU1wWAwW1su Zcqh3yPhMDCATEEABpBejEZjXl6eyjWQjg739u3bBwyQuITF0d9sor2OP/vZzyKR 1PfxttnsF1100TXXXJPqifS77bbbCgryFQyUrYvAGXTo90joCA0gU2TwRy2ArKT4 6G9VVfU777zzzW9+U94Q2kOtz+cj/WaHaDR68cUXJ5Opf8pvbGyaNWvWv/zLv6R6 InvU1tZOmzZVTSew7MvAiq86l6exsbGzkzYHANIdARhAGlF/9Pf88y+45557pA7B 0d+sEQwGf/zjH+flGVM9kX5azFi4cOGQIUNSPZGvzJs3T82quNVqjUZj2ZGyjEZj //55Knvdy7b3MHA4d/p1A8hEBGAA6UKv1xcUFKgMwAMGDHznnXdkj8LR3+zg9/sv uugik6kw1RPRflIMv//977XslOqJ/BO323399deruQy5oaFR+7HK9N22BoMhL884 eXKmHvo9Eg4DA0hzBGAAaUF7FhwyZMioUSOVjejz+T/55BOTySRvCO0vpT2ms/k5 C2jp94c//KHZLPHd0hNatNCmcd1116V2GkfywAMPNDU1qhkr0zdCZ3rLq6PQ3qXR aDQ7lugBZCUCMIC0oPjob21t3XvvvXfSSSfJG0Kn0wWDwUgkIm8IqJEm6be+vmHG jBnf+MY3UjuNo4jH41OmTBkxYria4aqqqgKBjLwZuKjIXFpamtEtr46uob7B6/OR gQGkp6z98AWQQRQf/U0mkz/72SUzZ86UOor28Ofz+aQOAQXSJP22t3fMnz9/xIgR qZ3GMb3xxhubNr2nJtppP8h2e1VmrQPvPfTbX3Gng5TgZmAAaYsADCDFDAaD9kSo 8t6j4cOHv/ba61KH0Ov1brebo7+ZLk3SbyQSXbhwYWFh6o8f98T06dONRoOasbQA HAqFMuUwsPaxoH3WTZ6sold2OuAwMID0RAAGkEp7jv4OHjxq9ChlI4ZC4U8++SQv L0/eEEaj0ePxcPQ30wWDwQsuuCC16TeZTJrN5tmz786g7bLt7e033nijmm5Y/fZe B9XZ2Zn+K41ZfOj3SCwWSywWT/+XBkCuyZhfqACykpYuysvV7QZsbGz88MN/jB07 Vt4Qer0+Ix7HcXTRaPTCCy9M7Y1HVqvtJz/5yRVXXJHCOfTOI488Ultbo2w47T9U TEtaafyVU1FRUWnpxAz6FkOU+rp6n9/HrUgA0krOfRYDSB/qj/5effU1N9xwg7wh DAaD3++n8VWm06LUj370I+0tk8I51NXVzZx5Rzq3vDoK7WftxhtvHDRooLIR7XZ7 MJiOh4G1z4SCgnyVX/MdncViGT16TFGRWdmIHAYGkG4IwABSQ3suzM/PVxmAx40b //zzz8urT9vn7JBIJH7yk59Eo6l8HZ3O1nvuuWfMmDEpnEMfaQH+9ttvV9na3W6v 0n4AlQ3XE3tv+s1Ln0O/1dU1Cxcu1D6pKisri4uLlI3LYWAAaYUADCAFDAb9sGHD VLa0jce7t23bptfrZQ4R9/v98upDjZ///JLUvo4eT+fSpUsHDlS3fCrJH/7wB4ej ReWIaXUxUrod+nU6W1evXl1UtCf3fvjhh/fff/+YMaPVDM1hYABphQAMIAUUH/1t aXFo6Vdq3qbtc3a44oorXK7WFE4gGo0tWrQoPz8/hXMQRQs8N954w5AhQ1QOWlVV HQgEVI54WIovNj8mLX8uX778wEPIr7766hNP/M/kyYryeX1dvdfny5R+3QCyGwEY gGqKj/5ardaXX37lrLPOkjeEln59Pl8sFpM3BBS47bbbdu/+MoUTKCgonDNnTja1 Sqqvr582bZriKJjaDLz3cEf/SZPU3et2dMlkcvjwEdp7+6B/HgqFKitXqryr3Gaz RSJR1oEBpFz2/JYFkBH23vqbV1Gh7lDct7516oMPPiivvhZXtIfIdO5Ai55YuXLl m2+uT1X4tFgsF174w9/+9rcpGV2qxx9/3G63KR40VRnYZDIlEon0OfRrs9lvuOGG H/zgB4f9f+vq6rQMrPJ+aQ4DA0gHBGAA6uj1e47+nniiuqO/2ohbtmyVmmoikUhX Vzq2n0XP/e1vf7vuuutStWdVSyn//d//LXWTQmpNnTo1P7+/4kHVZ+B0u+uooaGx srJS+8g9yp/Ztm3b/fffP3LkiWqmxGFgAOkgXT6mAeQCxUd/W1td27dvl3oEMZlM dnZ2yqsPBT777LNLLrlk4sQJKRm9urpm5syZ3/rWt1Iyuhper/fGG28cO1Z1U2tl faHV97Q/Jo+n84EHHtAmdsw/uXbt2scff7yiQtGebW4GBpByBGAAiig++qs9+77x xhunnXaavCG0h0uPx8NqRkZrbm6+8MILla2AHaS+vmHu3LkqTwSkyvr169977+/q V0cVXEKbbtueNUZj3vz583v4h6PRaGXlSu2jTOqUDsTNwABSiwAMQAUtKxYUFKjc Yvrd735vxYoV8urr9fpAIMCtvxmtq6vrBz/4wYABxSkZvaXFsXDhwtGjFV1Fk3Lz 5s2LRMLqx7VabVrGkxS30m3bczKZLC0tmzJlynH9W01NTffdd6/K3uMcBgaQQuny kQ0gixmNxhEjRpSUDFU2YmGh6e9//7vUIbTsRPrNaFpUuOiiixKJ1CxDuVxty5Yt GzpU3Q9FysVisRtvvFHl58B+1dU1WgAWe1Y/Dbc92+1Vt99+e++2vezYsWP16tXD h58gfFaHtfdbiQgboQGkBAEYgHSKr8R0uz3bt28vLpa4rKc9TKu8PgQyXHPNNS0t zSkZ2u12L1++YsCAASkZPYWampqmTp1aWjoxJaNr+TAcDgtZCk7Dbc/Nzc333/9A X95Ub7755qOPPqrss7qpqZkjJABSggAMQC7FR3+rqqrfeeedb37zm/KG0Ov12nOb 9vgrbwjIdu+997799lsp2bnq9fpWrFih/VyoHzodvPTSS9u2fZSqPcNaSgwGu/qy FJyXl9e/f/+ystL02fasCQSClZWVPWl5dRSxWEwr4nZ3iJrVMXEYGEBKpNHHN4Ds oz2Qmc1mlf11zznnB4sWLZJXX0u/fr8/Go3KGwKybdu27bLLLtMyjPqhtei1bNly lYct09A99/w+hec/k8lkVVV175aC915j3l9Zw+Se0P46ZnPR3XffLaSaw+FYsWJF //55Qqr1BIeBAahHAAYgUWFhocqHRe1BcOPGjfLq63Q6Lf3GYjF5Q0C2jo6Oc845 e8QIdZdR7xeNxpYuXWo0GtUPnVa05HnLLbcUFxelcA5aBk4kEtFoNB6P9/BfMZlM 2sxPOmmy1IkdF6vVeumlv7z00ksF1vz0009Xr159wglHuz1YIIH70gGghwjAAGQp KjKXlak7+uvxdG7fvr2oSOJTtfa4rOZaUUiSTCbPPfdco7FPO0V7Jx7vXrJkSR83 qWYNn8/3u9/dfOKJqbl9ar/a2rpYLHbMXbh6vb6wsEDlHeY9UV1ds3jx4tJS8RsZ 3nzzzccee0zZFgmpbboB4FAEYABSmEym8vIyZcfktGfBDRs2fOMb35A6Smdnp5ag pA4Bqa699trm5ib145J+D1VTU3PHHXekqiHWgfauBmvpS3fYs8Fp2O9K43S2VlZW Dhw4UEbxeDy+atWq9vY2GcUPy263h8McBgagCAEYgHjag/7AgQPGjh2rbMRzzz1v wYIF8uprfyMt/fZ8tyTS0KOPPvrCC8+r711E+j2SLVu2LF++bPLktNhUnEwm7faq fnt6QUVjsf/9SS8qMpeWple/K00kElm2bLnUvfROp3PFihV5eeq269tstq4uDgMD UCG9PtMBZAfFnZ+LiorfffddefX1en0gEODW34zW0NBw/vnnjxun7kuZfUi/R7dm zZq6utpUz+KfVFVVd3d3a6FXi8Rp1e+q396UPmTI0BkzZigYS/Fh4Nra2kAgyCIw AAUIwAAEU5x+PZ7OHTt2mM1meUN0dXWRfjNaIpE4++yzCwpU916ORmPLli0j/R7d 3LlzaKveEzab/corr/zxj3+sbMS33nrr0UcfVXYY2GazRSIcBgYgHQEYgEjas35e nlHZnsbq6pqNGzeecsop8obQnsZ8Pp+8+lBg6tSpX365S/GgwWDXfffdR8/nY0ok EtOmTVP/9URmqa9vWLx48bhx41QOqn36VVZWqj0MXBUKhbhlHYBUBGAAwuj1+pKS kpEj1XV2veCCC3//+9/Lq6/9jTweD09jGW3btm2XXnqpyl0JGq/Xt3Llyhy/77fn IpHIbbfdNnDggFRPJE253e4VK+4tLi5WP7Tiw8D7TmIfthsZAIhCAAYgjNlsLi9X d+/RwIGD3n77bXn1tfTr9/vZnJnRgsHg97///ZKSoSoH9Xg899230mQyqRw00wUC gVtvvXXYsJJUTyQN6RYsWJDCjfQ7d+5cvXq1spemob7B6/OxERqAPARgAGIoPvrb 2endvn27vKO/Op1OS7+xWExSfahxySWXBAJ+lSO6XG2VlZUpWazLdO3t7dOnTx8x YniqJ5IuksnkqFGjb7755lRPpN/69esfe+wxZd9v2mz2Y17ODAC9RgAGIIDBYNAC sLIrPWtqajdu3Pi1r31N3hDa4xfb8DLdn/70p6effkrlHTbNzc333nvfsGGKGudm H5fLpWVglcco0lZVVfWUKVPOO++8VE9kDy2L3nvvvR6PW9mIVqstFOJWJABSEIAB CFBYWKjyvpALL/zhvHnzpA7h8Xik1odsXV1d3/nOd5Rd4qKpq6tbtGjxhAkTlI2Y lZxO54wZ00eNGpXqiaRSS4tj4cKFo0ePTvVEvqK9LksWLy40FaoZTsv/oVBXdzf9 FwCIRwAG0FdFReayMnVHf2Xf+mswGLT0y+67THfdddc2NTUpG85ur5ozZ47UhuS5 o7m5edasWaNGjUz1RFLD7w8sWbKkqKgo1RM52CeffPKHP/xB2fq81WqLRrkVCYB4 BGAAfWIymcrLy5TtMu3ocO/YsUPeAUsaX2WHbdu2/eIXP6+oqFAznNVqve22qd/9 7nfVDJcLXC7XzJkzc/A8cP/++XPnztU+iFI9kcN7/fXXn3jiCWXtHrgVCYAMBGAA vaf43iPtYejtt98+9dRT5Q0RDAZJv5kuFot95zvfGTx4kLIRx40bf/311ysbLkd0 dHTMmDFD5Sb21LJabRdffPGVV16Z6okcjfbxuGzZsmAwoGY4bkUCIAMBGEDvKb73 6Iwzvr1y5Up59ePxuN+vtGMwZJg1a9aOHduVDWcwGBYsWKhsuJzi8/nuuOOOXLgf uK6uXnvfZsQW+vr6+mVLlw5Q9aI0NjZ2dnrZCA1AIAIwgF5SfO+R0Zj3wQcfyKuv 0+k8Hk8ymZQ3BBRob2//7ne/O27cWDXD+f2BVatWpfCO1qwXjUbvuusuozGb/wu3 t3csXLjwhBNOSPVEeurDDz984IEHRo9W1KjMbreHw9yKBEAYAjCA3tCe+M1m88SJ ihreOp2t27dvHzp0qKT6er3e5/Nx628W+M1vftPe3qZmLO1tqaXfAQOyf30ytZLJ 5IIF84PBoMobrZSJx7vnz59fUFCQ6okcnxdeeOGZZ56ePHmymuFsNjsboQGIkoW/ SwAooHL512q1vvLKq2eeeaa8IbT0y/JCFti5c+fFF/9YzUN5dXXN0qVLufRImWee eeavf/2ryjMXsmnBfsiQoTNmzEj1RHpDi6NLly5R1jGhtrY2EAjyKQ1ACAIwgOOm ePPzKad8/Y9//KO8+qFQKBwOy6sPZc4888yCgnwFA2nR5d/+7ZuXXnqpgrGwn81m W7BgfnZcEVxdXXPZZZf99Kc/TfVEes9ut69YsWLIkMFqhrPZ7JEIG6EBCEAABnB8 DAZ9fn6BsgAcj3dv27ZN3qUgiUTC6/VKKg6VHn300RdffEHNWNqPwLx589SMhQP5 fL65c+dk3Ibhgzgcjjlz5k6cODHVE+mr99577+GHHx4/fpya4axWWygUUjMWgCxG AAZwfAoLCysqJqkZq6mp+R//+Mfo0aMl1ddytcfj4ZLJ7HDGGWcMGCDrgugDeb2+ 1atX0/gqhR566KF33nlH2QeRWH5/YNGiRVlzdHzVqlVOp0PNWCwCAxCCAAzgOKjc /JxMJq+88qqbbrpJUn0t/fr9fm79zQ4PPvjga6+9qmCgurp6Lf2WlJQoGAtHYbPZ li1bNmxYhr0QeXn9586dm03fnng8nkULFxrzjGqGs1pt0aiWgfnWEkDvEYAB9JT2 0JaXZ1TW9nPkyJEvv/yKpOI6nU5Lv7R9zg7JZPL0008fNGigkoHOuPjii2UPhJ6I x+OrVq364IMPMmIpWEtuP/rRj6655ppUT0S8L774YlXlypJhw9QMx0ZoAH1EAAbQ I1r0HT58REmJrIuIDhIMBnfs+DQvL09S/UgkwqUaWUNLQevXv6FgIKPROH/+AgUD oeeqqqruvfdeBV9/9EV9fcPMmTO//vWvp3oisrz11luPP/64movx9i4CR9kIDaDX CMAAeqSoyFxWpugCkpqa2s2bN8tbak4mk52dnZKKQ73TTjtNQf5pbXU99NBD+fkq ukzjuGg/0U888cTbb7+trBvTcWlv75g/f/6IESPUD63T6YoGDAj4fNp/IqkDJRKJ 5cuXd3Z6pI6yHxkYQF8QgAEcm8lkKi8v056l1Ax37rnnLVgga51Nr9dr6Zcnp6zx 1B5/lj2K9sC9dOnS8nJ1t3/heAUCgZUrV27fvn3y5IpUz+Ur8Xi3ln7Vt63eE33N 5qLi4kGDBzscDm9np+wM3NzcvHTJEnORWeoo+7ERGkCvEYABHIPBYBg6dOjIkSeq Ga5///zNmzdLKq79Xfx+fyQSkVQf6p1//nkKvpoZMmTo9OnTZY+CvmhpaZk7d66y YxrHZLFYzjrr7N/97nfqh9Z+IgYNGTLqxBP3nSKJxWL1dXX+QED2uB9++OGDDz44 atRI2QP12/ufNxaL81UmgF4gAAM4BrPZXF6uaPOz09m6Y8eOIUOGyChO46vss3Xr 1nnz5soOwK2trjVr1sg7kY6+e+WVV5599tkJE8aneB7/X3V1za233nrGGWcoHnff wq+5uHhYSYnR+FVnZmdrq9PpTMq/8u355577y7N/UdMrkY3QAHqHAAzgaFRufrZY LC+++NK5554rqT6Nr7LP5Zf/pq2tTeoQyWTyggsuPPPMM6WOgl7T8s+iRYuCwYCy MxrH5HS2zp07d/z48YrH3bPwO3jwqJEjD/2yJh6Ptzgc7o4O2Ruhg8Gg9nIkEopC KRuhAfRCuvy2AJCGFG9+njSp4s9/lnWYk8ZX2Ud7Qf/93/+9tHSi1FHo/JzOXC7X vHnzBg4ckOqJfKWrK7Rw4cKioiKVgx5p4fdAWgaub2jweb2yJ7Nr167KlStLlFzR zEZoAL1AAAZwRCo3P0u994jGV1lp7ty5//jHh1KHqKurW7PmkQED0ihfYb9t27at XLly3LixqZ7I/0omk0VFxXfeeaf2gaNy3KMs/B6k1eVqdToVfBKuX7/+8ccfLysr lT1QPzZCAzh+BGAAh6dy83N1dc2mTZtOPvlkGcVpfJWtvvOd7xRJbjk7btz466+/ XuoQ6IVEIlFZWbl58yY1Z017oqqq+uc///kvfvELlYP2ZOH3QPF43OlytbtcsjdC a3F0+bJlXp/01eZ92AgN4LgQgAEchhYahw0rUXZx5fe+9/3ly5fLqEzjq2z1wQcf 3HPP76V+QdPa6vrjH/+o/SzIGwK94PF45syZI/u7j+PicDjuvntOaamKBc/9er7w eyAtAzc1N3d6PLIzcF1d3fLly9TsnmAjNIDjQgAGcBjaw2VZmaLNz3q9futWWRtZ aXyVraZMmdLY2CB1iG9/+zs/+tGPpA6B47Vjx44VK1aMHTsm1RP5SjDYtXDhwuLi YmUjHu/C70H23IpUX+/3+2XM7UCbNm16+OGH1exRZyM0gJ4jAAM4mMrNz01NzR9/ /PGJJ0rps5VIJLzyO75APe2V/frXvy71ulGPp1N7dpdXH8crmUxWVlZu2vRe+mx7 1qZkNhfdddddKg/9ap/Mg4cMGfn/7/jtHWfrnmuREvJvRVq5cqXL1Sp7lH3YCA2g hwjAAP6J9lA1fPjwkpKhCsbSHh9/+cvLpk6dKqO49kjq8XgUPOFBvRdffPHRR/8o dYizzjr7vPPOkzoEeq6jo2Pu3LnFxUpbKx9dVVX1JZdccumllyobcc/C714lvVr4 PdCeW5GcTnd7u+yN0G1tbYsWLSooyJc6yj4sAgPoIQIwgH9iMhVOmjRJzViDBg1+ 6623ZFTW0u//Y+9O4KOs7v2PJzPZZiYJSUggQNhCQnCp1q3Lrdpe622t/xavS2vV WrV1qeKCuLLJKogLSmtxoS6IghsqcEtBaV2qYqUVpQqZZLIvs2SZyWSyziT5n0ks tYgQkuecZ56Zz/t1L42Y/M6jkszznXOe36+1tVXcDMkoDt1deeWva2tr5dVvafGv Xr1aXn0ckV27dj300EMRdezZ5XLPmzdP5UO/mmz8fpGyqUh///vfH3744TFjVHSU KCkp6eoiAwM4DAIwgH8zm01JSUlFRUUK1mpoaNyzZ4+kaZki/YrbOxmVEQlOPvlk qYcUvvvd75111lny6mOQent7H3zwwXff/WvkHHuOUz7p9/ON37S07JEjh7nxewBl U5Fefvnl9evXFxWpeGtVZGDxH0jBQgCMiwAM4N+Ubf/29fXNnHnzxRdfLKN4R0dH Z2enjMqIBO+9996SJYvl1W9oaPzDH/4grz4GyePxLFy4cMSICBrCLH5wpaePmD17 tpoWCUK8yZSZlTVuzBhto++A8FQkt7uxoUH2Qei2tra77767r0/FAykOR5l4CWAT GMAhEIABfM5qtU6dWqhmrTFjxr722msyKov7Hr/fL6MyIsSsWbP27v1MXv1p0466 7LLL5NXHYLz66qsvvvjCpEmT9L6QfysrK7/ooovOPfdcNcuJjJ2WlmZLTdV84/eL lE1F+uSTT37721WjRo2SusqAkpLSrq4uMjCAr0IABhBmNptsttT8/MkK1vJ6ff/8 5z+Tk7VviyJuGb3y7+SgrzPPPDMhQdZs3urqmqefflqrxywxBMFgcOnSJSLAKNtl HQy3O7wdPWGCiok+cf1dDAae+JUXffdTNhVp06ZNzzzzjJq3WTkIDeAQIujVBYCO bDZrYaGK+xK73b59++vf/OY3Na9sNpt9Ph+P/kY3cbN+1FFHFRTIaj40cMBVUnEc lkhiS5cuVdOFfvCCwdDixYutVquCtcIbv+npqTbbSJkbvwdwhYciufok98zv6upa dvfd3UEVvQmrqqr9fj+bwAAOigAMQOnh56OPPuapp57SvCxtn2OE1AFIfX19F198 yXHHHSepPg5t3bp1mzdvlvfuxhDY7fbvf//MGTNmqFnOZDZnZWWNyc1VFn0HhKci OZ3NTU2yj8/s3bv3wZUrs3Oypa4yoLTU0dnZSQYG8GUEYCDWmftvucaNG6tgrUCg 7eOPP9b8fGl8fHwgECD9xoKZM2cWF++TVNzr9T366KOSiuMQxPfvokWL5J1sH5qq qupbbrnlpJNOUrCW+CGWPmKEzWYbmZWlOP0OEBm4uqqqRX4DhS1btjzzzDMK3uYQ YV5k4Pb2dtkLATAcAjAQ6ywWi6rpFKV/+ctfTjjhBM0rd3V1cZcTI370o7PkbVJN mjT5mmuukVQcX+WTTz554IH7x40bp/eF/Aev17d48WI1TZvMCQlZWVm5o0frEn33 c3s8LqezV/JB6GAwuOzuuzu7VDTqt9tLuru7enpUdJ8GYCAEYCCmmc3mpKRENYN/ jzvu+DVrtD+8Km7XWlpaNC+LyHTUUUdNnCilEZHI1dddN0NZlyPE9fdsX7ly5fvv vxdRY34FEUTvumuBgl5o8fHxIzIyrFarXhu/XxQKhZwuV1Njo+yD0MXFxQ888ICa J71FBu7ooBsWgP9AAAZimrLBv62tgT179mh+h2cymbxer+wtC0SIffv23XzzTEnF m5ubH3vscUnF8WW1tbVLly7JzMzU+0L+Q2mp45xzzrn00ktlLySib2q/7Oxs3aPv fuGD0DU1LT6f7IWUHYQuc5S1tbfzGgHgiwjAQOxS1vuqpKR0x44dmj9KZzabW1pa gsGgtmURsR5//PFXXtkoqfjo0bkzZ8pK1zjA2rVr//jHP06Zkq/3hfwHl8s9Z84c Bf3wTSZTRlbWOCVTjo6U2+Nxu1yye0d1d3cvW3Z3V1eX1FUGMBYYwAEIwECMEjde Nptt8uRJCtY65phjn3zySW1rijvIQCCg5v4JEUJqB6z/9/9+fOqpp0oqjv18Pt/i xYtkjAEfJvHDZPHiJampqVJXCTe7SkuzpqZmK5xydERCoZDL42n0eKKpI7TIwPSJ ALAfARiIUSL9FhYWKFjI72/ds2ePtk/TiZvItrY20m+sOffcczs6pNzFlpWVP//8 8yaTSUZx7Ld58+YXXnhhwoTxel/If7Db7Wec8f3rr79e9kJ6TTk6UiID19bV+bxe 2RlY/Hl45plnFLwS9XfD6mYTGMAAAjAQi6xWq7jnEDFS9kLiznLHjj+ffPLJ2pal 7XNs+s53vpOWJmWDrqure+XKlTIqY0BnZ+fSpUtDoaCCHztHpLq65tZbb5XRnf6L dJ9ydKSCwWBVZWVrICB1FRFKly5ZEgypeIylpKSkvZ1uWADCIut1CIAaynpfTZ1a tG7dOm1r0vY5Zh1zzNHjx0vZPMzJGTVr1iwZlRHXf9j1vvvuy80drfeFHKilxb94 8eLsbImncMPNrkTwTUvLiaRmV4Ph6id7E3jPnj2rVj2kYNxUeXlFW1uAkUgA4gjA QAxS1vuqqalZ3NyI5TSsSdvnmBUIBM4//zxJ+4cnn3zK+eefL6NyjAsGgw899NDO ne+rmbU2eCLX2Wypc+bMMZvN8lYRf1wzs7LGjhmjYKKS5kKhUF19vbe5WXYGfvml l9Zv2KBgHH1pqaOjo4OXDwAEYCC2iLu9zMzMvLxxshcS90zXXnvdFVdcoWFNcfE+ n0/clmlYE0axa9eu+fPnSSp++eVXRFpCiwKlpaUrVqzIUdLl6IhUVlb+/OcXnXPO OfKWENE3LS3NFsHNrgYjfBC6qqq1tVXqKqL+0iVLTGYVT+DTDQtAHAEYiDXKDj+n p4944403NCxoMpnEfVJ3d7eGNWEg69evf+aZtTIqOxxlL774YqQ9m2poPT09v/3t b//6178q2NY7Ul6vd+HCRbm5ufKWMJnN4Y3fiG92NRgutzt8EFryrukHH3zwyCOP jB07Ruoqcf1PAnd10Q0LiHW83gMxxGw2JycnKzj/XFdXv2fPnqysLK0KinAi0i8j f2PZfffd9+c/75BR2eVyP/XUUzIqx6by8vJ77lk+cuRIvS/kQH19feIH4Pz5d8nL pYZrdnVY4YPQTqe3qUn2QegHV670NHikLjGATWAABGAghih7+vd///fc2bNna1iw o6Ojs7NTw4IwnEWLFu3c+b6Myu3tHatWrZJROdb09PQ8/PDD77zzjpqfM0ekrKz8 p/0k1Tdus6vDEhm4qrLSL/kgtNPpXLZsWWqqTeoqcf19v1taWtgEBmIZARiIFcrS b3y86YMPPtCwoLj9kv0QGiLfnXfe+fHHu2VUFn9ixZ23jMoxpbS09N57783OjriN X6GxsWnBggV5eXmS6ptMpozMTIM2uxoMlzt8Elp2+6g333xzzZo1EydOkLpKXP9Y 4I4ORiIBsYsADMQKi8Wi4Hk8h6Psww8/nDJlioY1fT6f7NN3iHwzZ84sLt4no7LV ap0//y4ZlWNEKBRatWrVe++9F4FP/IofHUlJyfPnz5cUTcPNrtLTbTaboZtdHZb4 T1zvdDZLPggtii9bdndA8vDhuP7Xqfb2dtpBAzGLAAzEBGXbv1//+gmPPfaYVtVM JpNIv5xVg3DttddWVJTLqJyePkLbE/sxpbi4+L777hs1KkfvCzmIsrLyCy644Gc/ +5mk+uGm+iNHjhk9Ooqj737hg9BVVX6/X+oq+/bte3DlypHyzxEwEgmIZQRgIPqJ m7OsrCwFDTa9Xt9nn32m1U6LuLlsaWmh8RUG/PrXv66rq5VROTs755ZbbpFRObp1 dnY++OCDu3Z9GJkTpJqamhYuXDR27FgZxePj40dkZFit1qhpdjUYag5Cv/zyyxs2 bJD9jm1fX5/IwHTDAmITARiIfmq2f7Ud/GsymQKBQFdXlybVEAWuvfY3FRUVMipn ZmbdfvvtMipHsa1bt77wwgsK3lYbgv5uzynz5s2Tcew5Ogb8Do2ajtCtra1LFi82 J5jlLTGgpKRUvMRwwgiIQQRgIMqZzWabzZafP1n2Qlar7c0339SklLjFFOmXkb/4 ohtuuKG0tERG5fT09Nmz58ioHJV8Pt+yZctMpvjInJxcWVn5s59deO6558ooHk0D fodGTUfod9999/HHHx83Tsru/RcxEgmITZH46gVAQ2p6X1VX1+zevTs3N1eTap2d nbToxAFmzZq1d+9nMiqnpFgWLFggo3L0Wbdu3datf5w0aZLeF3JwLS3+hQsXjho1 SvPK0Tfgd8hcbrfL6ZTdmHDFihU+n1fqEnH97aC7u7t6engSGIgtBGAgmpnN5qSk RAVP6H3nO6euXLlSk1IMPcJByRuDJG5/7733XhmVo0l5efn9998/YkS63hdycHa7 /dRTT5s5c6bJZNK2cvjMc2pq+Mxz1A34HZrwQej6em9zs9QM7HA4xJ+3zMwMeUsM KCkpaW/n/VYgthCAgWhms9kKCwtkr+L3t3722Wda3Xcy9AgHtXDhwg8+2CmjckuL f/Xq1TIqR4eOjo6HHnpo165dETjlaEBtbd2tt956/PHHa15Z/FgLn3keM4bo+0XB YLCqqkr2O5Wvvfbas88+K/slrH8TuJsngYGYQgAGopbVahW3DrKf0xNh9YYbbrz0 0kuHX4qhRziExx9//JVXNsqoXFVVvX79ehmVo8BLL720efPmvLxxel/IV+rq6lq4 cFF6usZb05x5PjRXP6lvVra1tS1atMhs1nhL/8t4EhiINQRgIGrZbCIAS2/+bLFY 33rrreHXYegRDm3btm0PPfSgpOI33HCjpHk5xlVdXX3//feLHyN6X8hXKi11nHXW WVdeeaW2ZQfOPFtTU3M48/zV1ByEfuedd9asWSP7/Zfq6pqWFh9PAgOxgwAMRCc1 o4/Kyys++uij8ePHD7MOQ49wWBUVFdde+xtJxb/97f+aPn26pOKG097e/tvf/vbD Dz+M2DPPQmNj05w5cyZP1ri/PX2eBy98ELqysjUQkLrKsmXLWlv9UpeI40lgIMYQ gIHopCYAn3DCiY8++ugwizD0CIM0ZcoUSQ8EpqePmD17tozKxtLX1/fss89u27Zt woThvqslj7hIi8Uq0q+2Y3458zwETpfLLfkg9L59+1auXJmdPVLeEnHh99cqxcsQ D+AAMYIADEQhNem3qal57969SUlJw6zT0dHR2dmpySUhup188smS7oMbG5vWrFkj o7KB7Ny5c+3atQr67g5HdXXNJZdccvbZZ2tYkz7PQxYKhapralp8PqmrvNBP9nkE u72E8XtAjCAAA1FITQC+8MKfz5o1a5hFGHqEwZs+fXp3t5Rz8n19fVdeeVVBgfSW 6ZHJ5XKtXLnSZIqX3TNvmDo7uxYsWJCRoWVEN5vNGZx5Hga3x+N2uaTunTY3Ny9Z vDjFkiJvibj+hywCgTY2gYFYENEvdQCGQE367e4O7t493KGsInW0tLQw9AiDNGPG jLIyh6TiubljbrrpJknFI1Z7e/vDD//uww93KZiXNhwOR9mPfvSjX/3qVxrWFGl/ REaG+IHJmefhCIVCTre7qaFB6k/yP/7xj888szY/P1/eEnFsAgMxgwAMRBsFAVjc 6MydO++cc84ZThGTyeT1ent7abyJwVq1atWf/rRVUnGXy/3kk09G+Baohnp6ep54 4ok333xz0qSJel/LYXi9vrlz5w6/2d5+4TPP6ek2my175Eii7/CJDFxVXe1vaZG3 RGdn56KFC2XftFZWhocbswkMRL1YeaUHYoSa7V+r1Sbum4dTwWw2+3w+cduk1SUh FuzatWv+/Hny6n/jG98899xz5dWPEH19fc8///zrr7+emzta72s5DLu95LTTTrvp pptMJm2GwYromyqCb1oaI4605Xa7XS6X1Dc0//rXvz7++OOyRyLRDhqIBQRgIKoo CMAOR9nu3bsnTJgw5AriXra1tZW2zzhSIrkde+yx48fnSarv9XofffQxScUjxKZN m7Zs2ZKTk633hRyey+W+/fbbjzrqKK0Kip88mVlZY3JztW0fjbiBscBOp7epSepB 6KVLlrS1t8mrL1RVVfv9fjaBgehGAAaih5rt36lTi9atWzecCiL9sveLoTn33HM7 Otrl1f/610+48MIL5dXX0Y4dOzZu3JiRMULvCzk8EaISE5Pmzp2bkqJN3yNGHCkQ HgtcVSW1qeEnn3yyatWq0aNHyVsijk1gIAYQgIHoYbNZCwvlBuDa2rp9+/alp6cP uUJbWxt7vxiyRYsW7dz5vrz6dXV1jz76mNVqlbeEeq+//vprr702YsTQv21VEv8J Lr74krPOOkuTauHHfdPSwo/7cuZZPgVjge+///6mpkZ59YWamhqfr4VNYCCKEYCB KCFu2QsLC2S38PnGN775u9/9bshfLqKvCMAaXg9izSeffHLHHbdLXcJsTli6dKnU JZTZunXrli1bDLHrG9e/8WsymefNm6fVGxBms3ngzDPRVw0FY4FLSkpEBh45Mkve Ev2rlLa3SzxpAkBfBGAgSlgslqKiqVKXcLs9drs9OTl5aF/e29vbIrNNKGLEySef nJ09Ul59EcNOPPGkn/3sZ/KWkE38I7zyyitvvPFGZqaWI3Olqq6uufDCC6dPn65J NZPJNCIjQ/xU5MyzYm6Px+V0Su2G9dxzz7788svTpk2Tt4TdXtLd3c0mMBCtCMBA NDCbzSKXyn4A+Iwzvr98+fKhfW18fLzX62XkL4bv6quvrq6ukrqEw1Em/qgXFET0 aNyDEnft69ate/fddyO/w/MX9fT0zp8/Py0tbfileNxXX6FQqN7pbJbZDau2tnb5 smXpko/0swkMRDECMBANFLS/ampqLi4uHtoNpclk8vl8vJsOTbz55l9WrFghe5Xq 6hqRgYfT7VyxlpaWp556ateuXRMmaDYvVwHx7/mCCy7QZPoUj/tGCJGBKysrpXbD ev7551988UWph55EAO7q6uJlC4hKBGDA8MStnrjnmzx5ktRVzjnnf+fMmTOELzSb zX6/n8ZX0NA3vvGNrKxM2avU1NQuWrRoypQpshcapvfff3/r1q3FxcWFhUbasu7r 64uPN82dOzc1NXWYpQam+1rT0kYRfSOD7G5YHo9n6dKl4r+5pPoD2AQGohUBGDA8 Bdu/ra2Bzz77bAgdtkwmUyAQ6OrqknFViFkzZ84sLt6nYKGysvLbbrvtlFNOUbDW kRLfVs8///z777+XlSW3IZAMdXV1P//5RWefffbwS5nM5szMTKb7RhQF3bBeeeWV 9evXS33Tx24v6ehgHhIQhQjAgOHl5o7Ozc2VusSFF/581qxZR/pVIjCL9MveLzRX XV393e+eXlRUpGCt4uLiU0897eabbzaZTAqWG4y33nrrzTff3Ldv35Qp+XpfyxHr n/GbOHv2nOG3eo43mUaMGCHq8LhvBJLdDaupqWnJ4sUWq0VS/bj+7/1gMMQpaCD6 EIABY1Ow/ev3t+7du3cI27+dnZ28fQ5Jzj333I4OdacTxd32rbfeNnWq3EbrhyYS 7/bt2z/55BNjNbj6IpfLfckll5x55pnDrBPudJWebrXZskeOJPpGplAoVFtf721q krfExo0bN6xfXyjzFZBNYCAqEYABY1MQgM877/w77rjjSL9K3P1IbYKCGLd58+bV q3+vckW73f61rx137bXXyj5wcYCB3PvZZ5+NHJkle9C3PCJIfPvb377pppuSkpKG U4dOVwbi9njcbndPKCSpfkNDw9KlS7SaGn1QVZVV/tZWNoGBKGPUl1IAcf3pt7Cw QOo9sc/XUlxcPIQlfD4fQ48g1WmnnSa7C86XiSB39NFHn3322f/1X/8lb5VgMLhj x46PP97tcJTl5GQbN/cO8Hp9t99+e37+sA5shztdpabaUlNziL4GEQqFnG53U0OD vNeCl19+ecOGDVLfBS4pKWlvZxMYiCrGfk0FYpzFYpE6B0KYPv2cuXPnHtGXmEwm r9cr79EvYMDDDz/8f/+3Ra/VGxubjj322B/84AdHHXWUJgW7urr++te/fvbZZ1VV VTU1NQUFkd59ejDKysrPPPPMq666apgZ3mw2Z2Rljc3NJfoaS7gbVlVVi98vqb7b 7b576VJbqk1S/bj+ANzV1c0mMBBNCMCAUSUmJlitcqcfNTd77Xb7EfX+EfepLS0t wWBQ3lUB+5166neGP0RnOPr6+lwu17hxefn5+UVFRV//+tcHfz11dXV79uyprKwU FTz9h0Vlv5+lWHd38I477hg1atRwioifPyMyMy0pKXS6MiiX2+1yOuVtAr/QT/ZM YOYhAdGEAAwYlYKnf3/0o7MXLlw4+M9n6BEUEze+Tz75ROScEBZ3+fX19ampadZ+ iYmJCQlmobe3Lxjs7urqFtra2lpbW8X9tLHG9h6R+nrn+eefP3369OEUET9P0jMy rBYL0dfQZI9EcjqdS5cuTU9Pk1Q/jlZYQNSJlJsGAEdK9vlnl8vtcDgGP1qToUfQ xVlnnSWCp95Xgc+VlJR+61vfuvHGG5OTk4dcRPwwGSGiL/ONooXskUgPPvig2+2S 90ZYmaOsvaODU9BA1CAAA4akYPv3pJNOXr169eA/v6Ojo7OzU971AAe1d+/eH//4 x7K/HTAYra2B2267beLEiUOuEJ5v1D/al/lG0SQ8EqmuztvcLKn+Z5999tBDD2Vn j5RUP45WWEB0IQADhmS1WqSOJK2oqBSv9xkZGYP8fIYeQUfXX3+9w1Gq91XEtNra urPPPvuiiy4acoXwfKP0dBujfaNUeBPY5eqVtom6fPlyv79FUvE4WmEB0YUADBhS VlbmhAkT5NWfNGnyCy+8MMhP7uvra2lpYegR9BIMBk877bSMjBF6X0gsKi11fPvb 354xY0ZKSsrQKnwefa1WRvtGsVAoVFdf39zUJKn+3/72t0dWrx4zdoyk+nG0wgKi CAEYMB7Z55/Fy/wnn3wyyIDN0CNEgo8//vi8887jILRKfX19wWDotttuy83NHVqF cPRNS7PabIz2jQXu/lbnPaGQpPoLFizo7pbYgpFWWEDUIAADxiO7/VVGRub27dsH 85kMPULkuPHGG0tK7HpfRaxoaGj8+c9/fuaZZw7ty4m+MSgUCjldrqbGRknHhd58 880n/rBmvLSzUTU1tT6fj1PQQBQgAAMGYzKZUlJSpO503Xbb7RdccMFgrqS1tZW2 z4gQ4q76rLN+GDkjkaJVdXWNyL2XXXbZEU0I34/oG8tEBq6sqGgNBGQU7+jouOuu uxISzDKKD+AUNBAduFEADEb2+ee2trZPP/3ssJ/G0CNEIJ/PJ7KZ1GawsWzgcd/r rrvOYrEM4cuJvhDqXS6PyyVpE3jjxo0bNmyQN2Hbbrd3dDDsADA8AjBgMLLPP59x xveXL19+2E9j6BEi06effnreeefl50/W+0KiSn9ciZ81a9aoUaOG8OVEX+wX3gSu rJQ0NaC2tnbZsmUjRqTLKB7HQGAgWhCAASOxWq2FhQXyDnlWV9c4HA6bzXboT2Po ESLZli1bbrzxhqKiIr0vJEq0tbVfeumlp5xyyhC+lg7P+DKny+WWtgm8YsUKn88r o/IATkEDUYAADBiJ7PPPg5x+5PP5GHqESLZhw4bZs++cNm2a3hdibD5fy09/+tMz zjhjCF8rom/6iBHiRxZzfXGAUChUVVnpl/Mu6gcffPDII4+MlTYPiVPQQBQgAANG YrVapk6Vdf5ZZNqVKx889dRTD/E5JpOJNpgwhIULF+7c+T49sYamsbHpJz/5yfTp 04fwtfEmU3p6OtEXhyDvSWDx8jR/3ry+OFlv0VZUVAQCbbwIAobGnQFgGDabtaBA 4vnnYDD00UcfHeITzGaz3++n8RWM4qabbiou3kcGPiIeT8MPfvCDn/3sZ0P492Yy m0eMGGGxWEZmZRF9cQhSnwTesmXLs8+uy8/Pl1E8jlPQgPFxWwAYhuzzzz/84VmL Fy/+qr9rMpkCgUBXV5e8CwA0t3Tp0iee+APPAw9GQ0Pj//zP/wwt+poTEkT0TUlJ IfpikORtAtfX19+9dGm6tFZYnIIGjI4ADBiGuLmcNk3WfXx5eYWQmpp60L8rbojb 2tpIvzCirVu3zpw5k77Qh9DY2PSDH/zgggsuONLoG+5xlZqaYrUmJiZmZWYSfTF4 UmcCL1++3O9vkVFZqKysam1t5RQ0YFwEYMAYzGZzYmKCvKY+WVkj//SnP33V3xXR lxNfMK5du3ZdccUVeXnj9L6QiOP1+n74wx+ee+65R/qFnz/oa7HQ3hlDVltX1+Dx yKj81ltvrVmzZsKE8TKKx3EKGjA4AjBgDLLPP//mN9eKhHDQv9XT0+P3++UtDShQ V1d38cUXWywpel9IROjr6+vq6j7nnHO+973vHenXms3mdB70hRbcHo/b5ZKxlSpe sxYsWJCSkqx55QF2e0lHR4ek4gBkIwADxiBuN4uKZPV/drs9FRUVBz39KH7T6/Uy 9AhRoLe399e//nV9fV0st8UqLXUcc8wxF1xwwde+9rUj+sLwaee0tBSLRYReoi80 EQqFauvqvM3NMoo/9NBDLpdT0je7CMDd3d2cggYMKnZvAgBjGTkya/x4Wae5CgoK n3vuuS//vtls9vl84h5F0rqAek899dQDDzwQg8ehq6trTjrppMsvvzwrK+uIvtBk Nqenp1ssFsYaQXNuj8fldPb29mpeedeuXb///e/HjMnVvPIATkEDxkUABgxA9vnn efPm/+QnPzngN2n7jGjl9Xqvvvoqv98fC1vBfX19ra2B008//YILLjCbzYP/QrZ8 oUAoFKquqWnx+TSv3NnZedf8+eaEI/gzf0QIwIBxRf9rPxAFpAbghobG8vLyL/9+ a2sre7+IYq+++uo999yTmZmh94XIUlFRecwxR//4xz854YQTBv9VIvem2mzJFktS UhK5Fwq43G6X0ynjQZvnnnvu5ZdfktQ8srjYLjK2jMoAZCMAAwYgdQBSfn7+hg3P H/Cb7e3t7P0i6oVCobvuumvz5s3RdCLabrdPmjT5lFNOOf/880WIHfwXms3mtPR0 S0oKjZ2hkvg2rKqqktFqcc+ePStXrpR0Crqqssrf6u/p0f7wNgDZCMBApBN3ouIu Vt4O8G233X7BBRd88XeCwWBAzmxGIAK1t7eLGPynP22V95i9Gm635/jjj7/oootG jRo1+K8ayL3JycniRw2zfKGLOqfT43JpXnbgWzsxUdYfaU5BAwZFAAYindTzz1/u /9zX1+eT8DgWEOECgYC4V96xY8fYsWP0vpYj43K5jzrqqDPOOOPkk08e/FeZExLS 0tLIvYgE8uYhPfjgg263S14vaIYhAUZEAAYindQAPH78+Jdf3rj/L00mk9frldGQ EzCEUCj02GOPvfLKKwkJ5khukdXX1+fxNAzk3pNOOmmQXzXQ1yqpP/SazWZyLyKE +L6rqa31eb2aV965c+cjjzwybtxYzSvH8RgwYFiR++oOYIDUB4B/8YtLb7jhhoGP xQ1xS0tLMBiUtBZgIB988MHatWv//ve/jxx5ZEODpCorK584cWJRUZHIvfn5+YP5 koGmVkkpKeb+1EtfK0QmSa2wmpubFy1aaLVatS07oKKiIhBoYxowYDgEYCCiJfaT tANcWuqoqamx2Wxx/Xu/ra2t3d3dMhYCjOudd9556aWXdu3aNWJEui57wiL0jhkz Ji8v76STTvrud787mFFG4dCbmpqYlJTQj9CLyCevFdaSJUva29s0LzuAx4ABIyIA AxFN6vnn+HjTBx980P9BfCAQIP0Ch1BRUbFp06bdu3c7HKV1dXWSZqvE9T9YmJGR kZubO3HixBNPPFHkXpPJdOgvGdjmFYnXZP4coReGU1tf3+B2a152y5Ytzz67bpAn Jo4UjwEDRkQABiKa1AB8wgknPvroo+KDzs5OXsKBwfP5fNu3b9+7d29lZaXT6XS7 3X5/S1HRET+qYLfbrVZbWr+cnJy8vLypU6cef/zxh86uIg/brFYRd+NNYebw/5N4 YXhuj0d8N/Vp3YSipKTkvvvuy84eqW3ZAeJbuKODx4ABgyEAAxHNYrEUFU2VVHzB goVnn312T0+PjFNnQEzp7Oz8x0cfVVdX19fVNTY2Blpbg6FQV1dXqF9c/+MMSUlJ ycnJ4ps6JSVFxN0J/b68uxs+aB0fb4qPt1qtItOKvxRBt/+Xz38V6F+F6BM+BV1d 7W9p0bas+DacN29eQsLhnx0Ygn37ikV9GZUByEMABiLa2LFjR43KkVG5rq6+pqZG 3E/7fD7N+44AEHfzzV7vAd9c4b882Pdb+MU4fuCXz1+XxQekXMSauvp6j4RT0Pfd d19zc5PmZeP6j0B3d3fTBwswFgIwELmsVkthYaGkvjsWi/Wdd94R6ZdXbgBAJHB7 PC6nU/NRfNu3b3/66acnTZqobdkB9MECDIcADEQuqQ8Af+Mb37znnntofAUAiBCS TkGXlZWtWLFC0kgz+mABhkMABiKX1AB84403nX322ZKKAwAwBDJ6QYuAOn/evMSk RG3LDiAAA4ZDAAYil7wOWA5H2b59+xITpdwNAAAwNOFe0PX1mnemuPvuuwOBVm1r Digutnd20ggaMBICMBC5UlJSpk074sEqg9HZ2fXWW2/JqAwAwJCFQqHKysrWVo3D 6saNGzds2FBYWKBtWaGqssrf2ko3DcBACMBA5MrJyRk3bqyMyqNH565du1ZGZQAA hqO6pqapsVHbmv/4xz9WrVol4yW1r6+vrKw8EAhoXhmAJARgIEJJbQH9ne+cOn/+ fBmVAQAYjjqn0+NyaV724d/9rq6+TvOycf0ZuLS0tL2dJ4EBYyAAAxGKDlgAgBgk 6THgHW+88ee//FnbmvsxDAkwEAIwEKHkBeDi4mK7vSQ5OVlGcQAAhkPSY8Dd3d0X XvizadOmaVt2AAEYMBACMBCh5AXgxsamv//97zIqAwAwfFXV1c1NTZqXvfQXv8gb n6d52TgCMGAoBGAgQsmbgWQymbdu3SqjMgAAw1dbV9fg8WhedsaMGenpaZqXjWMa MGAoBGAgQskLwLm5Y55++mkZlQEAGD6ny+VyOjUvO3fOnN6+Xs3LxhGAAUMhAAMR St4Q4OOOO/7ee++VURkAgOFzud3O+nrNy967YoXX59W8bFy4uYa9s7NTRmUAmiMA AxFqzJgxo0ePklH57LP/34033iijMgAAw+dpaHC5XD2hkLZln3ryyZLSEm1rDqiu rmlubpZRGYDmCMBAhEpLS5syJV9G5euumzF9+nQZlQEAGL5QKFRdVdXi92tbdvu2 bW+9/Za2NQeUljra2tpkVAagOQIwEImsVsvUqVIeABYeeGDlMcccI6k4AADDJ6MR 9N69n61bt07bmvuVlJS0t/MYMGAABGAgEtls1sJCKTOQ+vr6Nm/ewhBgAEAkq6mt bWxo0LZme3v74sWL4uOl3P2Wlpa2tTEJCTAAAjAQieQNAa6oqLTb7TIqAwCglbr6 eo/brXnZn/70pwUFUzQvG8coYMA4CMBAJJIXgN1uz+7du2VUBgBAK/VOp9vl0rzs JRdfPGHiBM3LxhGAAeMgAAORSF4Abm1tfe+992VUBgBAK5JGAV9xxeW5ubmal40j AAPGQQAGIpG8ANzV1f3mm2/KqAwAgFYkjQK+6qqrsrNHal42jgAMGAcBGIhE8gJw b2/f66+/LqMyAABakRSAr/3NbzIyMzQvG0cABoyDAAxEInkB2GQyb926VUZlAAC0 4vZ46uvqNC97/YwZaelpmpeNIwADxkEABiIRARgAEMsIwAAkIQADkYgADACIZQRg AJIQgIFIRAAGAMQySc8Az5gxI50ADMQ2AjAQieQF4FCoZ8eOHTIqAwCgFUkB+DfX XJOZlal52TgCMGAcBGAgEjEGCQAQyyTNAWYMEgACMBCJ5AVgv9///vs7ZVQGAEAr 9U6n2+XSvOwVl1+eOyZX87JxBGDAOAjAQCSSF4Ddbs/u3btlVAYAQCt19fUet1vz spdcfPGEiRM0LxtHAAaMgwAMRCJ5AbiiotJut8uoDACAVmrq6ho9Hs3L/vSnPy0o mKJ52TgCMGAcBGAgEskLwH19fZs3b0lOTpZRHAAATVTX1DQ1Nmpbsy0QWLJ0SXy8 lLtfAjBgFARgIBKlpqZKeotauP/+B4499lhJxQEAGKZQKFRdVdXi92tbdu+nn657 7llta+7ncJQFAgFJxQFoiAAMRKj09PT8/MkyKl933Yzp06fLqAwAwPB5GhpcLldP KKRt2e3btr319lva1hxA+gUMhAAMRKi8vDxJoxp++MOzbr75ZhmVAQAYPklDgJ/4 wx8cZQ7Nywp1tXUNWh/YBiAJARiIUCkpKdOmFcmofOyxX7v//vtlVAYAYPgkzUBa cc89vhaf5mWF4mJ7Z2enjMoANEcABiKUxWIpKpoqo3JOTs66dbIeggIAYJgktYC+ 8847JHXAsttLOjo6ZFQGoDkCMBChrFbL1KlSAnBvb9/rr78uozIAAMMUCoWqqqv9 LS2aV772N7/JyMzQvGxcuAV0SXs7ARgwBgIwEKHkTUJyuVwff/yJjMoAAAxTuAOW 09nT06N55V9ccsn4CeM1LxvHDCTAUAjAQISSOgr42Wefy8nJkVEcAIDhcLpcIgBr Xtbtcj340IMMAQZAAAYilM1mLSyUEoCFX/7ysosvvlhScQAAhqymtraxoUHzsq++ 8sqHuz7UvOyA0tLStjYCMGAMBGAgQlmtFhGAJb1Xfdxxx997770yKgMAMGThB4Ar K/2trZpXvnfFCq/Pq3nZuP5zVSIA8wwwYBQEYCByjRo1auzYMTIqp6amvfzyyzIq AwAwZG6Px1lfLyKl5pVnzZqVnJykeVmhqqra65USrQHIQAAGIpe8UcBer+9vf/ub jMoAAAxZbV1dg4QBSMJlv/zl2HFjZVRmCDBgLARgIHLJm4Rkt9v/+c9PU1NTZRQH AGAIwuefq6r8fr/mlQOBwKWX/mLatGmaV45jBhJgNARgIHLJawQtXHDBT6+88kpJ xQEAOFJut9vpdMo4/7xh/fo9/9yjedkBtIAGjIUADEQuqY2gx4+fsGbNGknFAQA4 IqFQqLauztvcLKP4grvu6g52y6gcRwtowGgIwEBES01NLSiYIqNyR0fn22+/LaMy AABHytPQ4HI6e3p6ZBS/8sorc3KyZVRm+xcwHAIwENHk9cHiMWAAQOSoczo9LpeM ylIfAKYDFmA4BGAgolkslqIiKX2w4ngMGAAQGeS1v4qT/ACw3V7S0UEHLMBICMBA RJPaB2v06Ny1a9dKKg4AwCC53G6XnPZXwpzZs/vipFSO4wg0YEAEYCCiSQ3ALpfr 448/kVQcAIDBCIVC1TU1LT6fpPq/uOSS8RPGSypOAAYMhwAMRLrs7Oy8vHGSit96 621nnnmmpOIAAByW2+Nx1tdL2v59+803t72+XUZlobKyyicttwOQhAAMRDqpjwEX FBQ+/PDDkooDAHBooVCoprbW5/VKqr908eK2Dlk7tDwADBgRARiIdFJPQbe0+Hfu 3CmpOAAAh+b2eFxOZ29vr6T6v7riitG5oyUV5/wzYEQEYCDSSQ3AfX19y5ffc+KJ J0qqDwDAV5G9/fvJxx9veH5DfLys210CMGBEBGDAAKQ+BlxYOPV3v/udpOIAAHwV 2du/S5csaWtvk1ScB4ABgyIAAwYg9THgpqbmXbt2SSoOAMBByW7+LFz2y1+OHTdW UnEeAAYMigAMGIDUU9DCddfNmD59urz6AAAcQOrsX2H7tm1vvf2WpOJxnH8GDIsA DBiAyWRKSkqcNm2apPqjRo1+5plnJBUHAOAAoVCoqrra39Iib4nZd94p7z63uLi4 uzso7/A2AHkIwIAxpKSkTJtWJKl4TU3Nxx9/kpiYKKk+AABf5HS53C6XvO3fYDB4 6aW/mDx5sqT6xcX2zs5OScUBSEUABoxB9ino//mfH9xyyy3y6gMAMCAUClVWVra2 tspb4g9r1pSVl8mrz/lnwLgIwIAxyA7AHR2db7/9trz6AADE9affeqezualJ3vav cPVVV43MHimvPgEYMC4CMGAYUntBixuRO++887//+wxJ9QEAiJM/+kh49513/m/r H+WN/6X/M2BoBGDAMKxWy9SpsgJwXHjacM6zzz4rrz4AIMYpGH0k3HnHHfEmibe4 JSUl7e0EYMCoCMCAYcg+BV1eXvGPf/wjLS1N3hIAgFgmu/eV0NraesUVVxQWFshb gvPPgKERgAEjkXoKWvj610+455575NUHAMSsYDBYVVnZGghIXeX+++5ram6SV5/z z4DREYABI5G9Cex0uv7xj38kJCTIWwIAEINCoVBdfb23uVnq9q9Y5bLLLpswYby8 Jdj+BYyOAAwYic1mLSgokNfYQ/je9/77zjvvlFcfABCDXG63y+mUmn6FRx95pKq6 Sl59cf0Oh6OtjQAMGBgBGDAY2ZvAzc3ev/3tb1IzNgAgpoRCoarKSr/Mwb9x/en0 issvHzN2jLwl2P4FogD3uIDByA7AwrnnnnfNNddIXQIAECPUDP4Vnnv22U8/+1Tq EgRgIAoQgAGDMZvNIgNPmZIvb4n29o533nlHXn0AQOxwud1ul0vq4N8BV111VXb2 SHn1S0sdnZ2dPT098pYAoAABGDAe2b2ghYsuuviyyy6TugQAIOqFDz9XVfn9ftkL vfTiix/t/kjqEvR/BqIDARgwHpvNWlgo9xR0IBB49933pC4BAIhuyg4/C1f++lc5 o0ZJXaK0tJT2V0AUIAADhqTgSeDp08+57rrrpC4BAIhi4c7PLlef/MPPz6xdu694 n9QlePoXiBoEYMCQFARgr9f3wQcf0A4aADAEwWCwqqqqVXLn57iB5s9XXDFmTK7U VQjAQNTg1hYwqpEjR44fnyd1iTPP/J9bb71V6hIAgOgTCoXq6uu9zc0KDj+veeyx 8soKqUtUVFS2tLRIXQKAMgRgwKisVsvUqXJbYTU0NOzc+UFSUpLUVQAA0USkX5fH 0+jxKEi/3d3dV/76V+Py5L4dXFJS0t5O+ysgShCAAaMym81JSYlFRUVSVznuuOPv vfdeqUsAAKKJ2+Nxu909oZCCte5dscLr80pdori4OBgMMf0IiBoEYMDAFMxDqqio fO+997Kzs6WuAgCIDqFQqLqmpsXnU7BWY0PDtdddV1AwReoqTD8CogwBGDAwm81a UFAgu09VTs6odevWSV0CABAFRPp1ulxNjY0KDj8Ld955p+xGjeIfxOFwMP0IiCYE YMDYFMwEttvtW7b837HHHit1FQCA0bnc4cFHvfLnHgn79u6dM3fOtGnTpK7C7F8g +hCAAWNTMA8pLvymfs+OHTtkrwIAMK5gMFhdVeWXP/dowLXXXpuRMUL2Kkw/AqIP ARgwPDUZ+Mc//sn1118vexUAgBGpnHskrH366WJ7sexVSL9AVCIAA4anJgDX1zvf f//91NRU2QsBAIwlPPfI7W5saFCTfgOBwNVXXz1x4gTZCxGAgahEAAaigYJ20EJe Xt4f/vCE7FUAAMYSnnvkcikbFHTX/HlB+TOWaP4MRCsCMBAN1GwC2+32TZs2H3fc cbIXAgAYRSgUqqqq8vv9apb79NNP58+fJ7v3VRzbv0D0IgADUcJqtUydKn0TuK2t /Z133pE9eAkAYAiKH/0Vq1x91VXZOdJH05eUlLS3s/0LRCfuYoEooWYTWPjWt769 cOFCBQsBACJZ+NFfj6fR41GTfoXfrlrldDkVLMT2LxDFCMBA9FCTgcvLK/7yl7/k 5eXJXggAEMkUP/pbV1s78+abCwqmyF6I9AtENwIwED2UbQIzFhgAYlwoFKquqmpR 9eivcN21146QP/g3jgAMRDsCMBBVbDZrYaGKDHz66d+dM2eOgoUAAJFG8aO/wiOr V1fXVCtYqLS0tK2N9AtEMwIwEFXMZnNSUmJRUZHshaqqqnfs2DFu3DjZCwEAIori qb9x4UH09TfffHN+/mTZCxUXFweDIWWHugHoggAMRBs1M4EHbNu2Xc1CAIAI4Xa7 RQDuVZgSr79+RlpamoKFmP0LxAICMBBtTCaTuFGYPHmSgrVOO+30uXPnKlgIABAJ gsFgdXW1sqm/wurf/76mtkbBQg5HWXt7e29vr4K1AOiIAAxEIWXdsMrLK7Zu3VpQ UKBgLQCAvkKhUG1dnc/rVXb4ubK8/Nbbby8sVPEqQ+8rIEYQgIHolJeXl509UsFC bW3tb7/9tslkUrAWAEAvIv063e4mhY/+9vb2XnP11dk52QrWqqurb2hoULAQAN0R gIHopGwTWCgqmrZq1So1awEAdOEKP/vrUnlCeNndd7cGWtWsxfYvEDsIwEDUUpaB 7Xb7iy++dMoppyhYCwCgXjAYrKqsbA0ElK24+6OPFi9ZPG3aNAVrkX6BmEIABqKW 2Wy2WCwFBVMUrNXY2PTWW2+lpqYqWAsAoFIoFKqprW3x+ZQdfm4LBK697rpx48Yq WEuk366uLkYfAbGDAAxEM5UHoZOTUzZt2qRmLQCAGiL91judzU1NytKvcPPMmSmW FDVrsf0LxBoCMBDllHXDEk4//btz5sxRsxYAQDaRfl0eT6PHozL9PrJ6dXVNtZq1 6H0FxCACMBDlrFZrYWFBfLyKb/aysvLXXnvtmGOOUbAWAEA2t8fjdrlUHg+22+1z 58wpVHJ2SaT60lIH279ArCEAA9HPZrOpGaIoeL2+t956y2KxqFkOACBJMBisrq72 +/3KVuzs6PjNtdeOGZOrZjmRftva2tSsBSByEICB6Gc2m9PT0ydOnKBmubS0tJde elnNWgAAGUKhUG1dnc/rVXn4+bbbbk1ISFCzVnl5hUi/9L4CYhABGIgJKrthCf/9 32fccccdypYDAGgo3PjK5WpubFSZfh977LHKygply9H7CohZBGAgVths1sJCRRnY 4SjbuHHj8ccfr2Y5AIBWRPp1ezwNDQ19vb3KFv30n/9csHChsjdqS0tL29pIv0CM IgADscJsNttstvz8yWqWE7dPf/7znzMzM9UsBwDQhPrGVz6v94Ybb8zLG6dmOYej rKOjg8PPQMwiAAMxRPFB6N7e3u3bX1fTgBoAMHzqG1/19fVdP+O69BEjlK3I4Wcg xnFjCsQWxRl43Li8J554QtlyAIAh06Xx1cIFC7q6u5QtR/oFQAAGYovZbLLZUpUd hBZ3Ueeff8HVV1+tZjkAwNDo0vhq/XPP7fnnHmUHhUpLHZ2dHT096p5tBhCBCMBA zFG8CVxeXvHqq68ec8wxylYEABwRkX5dHk+j2sZXxfv2zb/rroKCKcpWZPsXQBwB GIhNNputsLBA2XKNjU1vvPEGDbEAIDLp0vjqxptuGjdurLIVS0sdbW1typYDELEI wEAsMplMI0eOVHnnEQyGtm/fnpCQoGxFAMBghBtfVVX5W1uVrRgKhW64/vqMzAxl K1ZWVvn9/l6F+9sAIhYBGIhRVqu1sLBAZYtmEbmfe269suUAAIclsmhNbW2Lz6fy 0d85s+9Ut1h/N4rSUgeHnwEMIAADsSs11VZQoO4gtHDaaafPnTtX5YoAgK8Sbnzl dDY3NalMv6sffrimrlbZcnHhwb+OQIDDzwA+RwAGYldiYkJCQmJR0VRlK5aUlD79 9FOnn/5dZSsCAA4q3PjK7Q43vlKYft97990HVq5U+bpjt5eEQsFgMKRsRQARjgAM xDSz2WSxWFU24ayqqn7ttdeKioqUrQgA+DKRft0ul8rHYktKSubPn69sDl//iqVd XZ3MPQLwRQRgINYpnooU198Uetu2bdnZ2SoXBQDsFwwGqyorWwMBZSs2NjTMuuUW lc0X45h7BOBgCMAAVE9FEtrbO954443k5GSViwIA4voPP1fX1PhbWpQdfu7u7p4x Y0Z29kg1yw1g7hGAgyIAA4gzm82jR48eNSpH5aJJScmbN29WuSIAQKTf2vp6X3Oz ykd/Z950k8VqUbacUFtb5/V6VU42BmAUBGAAYSIDJycnKz4LPW5c3hNPPKFyRQCI ZSL9Ol2upsZGlel34YIFXd1dypaL62981d3dTfoFcFAEYACfU/8wsLgDO+200+fN m6dyUQCITSL9uj2ehoaGPoWNr37/8MM1tTUqZ87H8egvgEMiAAP4N/UPA9vt9t// fvXZZ5+tclEAiEEi/bpdLpX7om+8/vrqR1ZPmzZN2YpxPPoL4HAIwAD+zWw2JyUl qZzQKJSXVzz33HOnnHKKykUBIKaE2z5XVbW2tipb8aN//GPZ8uXK31Tl8DOAwyAA A/gPIgPbbDaVcxrj+ruVbN68OT8/X+WiABAjQqFQTU1Ni8K2z5Xl5bPnzJk0eZKa 5QaUljo6OztJvwAOjQAM4EBWq7WwsEDxI1sMBwYAGUT6rauv9yps+6zLyF/xTycC MI/+AjgsAjCAg0hNTS0omKJ40UCgbfv27TabTfG6ABCt1Ld9bmtru+mmG3NylM7V ExyOskAgoHhRAEZEAAZwcOqbQsf136v96U/bEhMTFa8LANFnoO1zY0NDr6q2z8Fg 8KYbbxiRkaFmuf1o+wxg8AjAAA7OZDLl5OSMGZOreN2kpORNmzYpPoANANFHcdvn vr6+m2fOtFgtapbbr7q6xufzKQv5AIyOW0wAX8lsNlssFvVnoUeMyHjhhRcULwoA 0UR92+c7br/dZDYpW25ASUlpV1cXja8ADB4BGMCh6NIQSxg/fsKaNWsULwoA0SEU ClXX1PgVtn1etHBhZ1enmrX2o/EVgCEgAAM4DF0aYonbmmOP/doDDzygeF0AMDr1 bZ/vu/fepuYm9W+V0vgKwBAQgAEcns1mKywsULyouHU744zv33HHHYrXBQDjUt/2 +bFHH62orFCffktLHW1tbYoXBRAFCMAADi8hISExMbGoaKride12+4MPPvS///u/ itcFACMS6dfl8TR6PMrS79atW9eseXzatGlqltvPbi8JBoPin1fxugCiAAEYwKCY TKbMzMzx4/MUr1ta6li9evUPf/hDxesCgOG43GG9qjpC/eXPf374979X/95oRUVl a2srbZ8BDA0BGMBg6dUUury84sknnzz11FMVrwsABhJu+1xZ2arqmdgPdu68/4EH 1D8dQ9tnAMNEAAZwBPRqCl1RUblhw4YTTzxR8boAYAgi/dbW1LT4/WoOP3+ye/fS Zct06Y9I22cAw0QABnBkdGkKLdTU1LzwwovHHnus+qUBIJKFQqHaujqf16sm/e7b u3fR4kWTJ09WsNYBaPsMYPgIwACOmC5NoYXa2rqNGzcWFRWpXxoAIpNIv/VOZ3NT k5r0W1JSsuCuuyZNnqRgrQPQ9hmAJgjAAIbCarVOnVqoft26uvpXX321oECH+A0A kSY89MjtbmpoUJN+y8vK5s6bN2nSRAVrHaCkpJSTzwA0QQAGMBQmkyk5OVl980/B 6XS99tprupy+A4DIIdKv2+NpbGhQ0w+5qrJyzty5EyaMV7DWAez2kq6uLto+A9AE ARjAEJnNpqyskePGjVW/tMfTIDLwhAkT1C8NABFCpF+3y6WmH3JtdfXsuXPz8sYp WOsAlZVVra3+nh7SLwBtEIABDJ3ZbLbZbPn5OmzGNjY2bdq0adw4He7GAEB34aFH VSIZtipYq76u7s7Zs3V5u7O01NHZ2cnQIwAaIgADGBaRgZOTk3V5HpgMDCA2hUKh 6poaf0uLgkd/dUy/dntJd3c36ReAtgjAAIZLr+HAcWRgALFH5dAjHdMvI38BSEIA BqABvYYDx/Vn4K1bt44aNUqX1QFAJZVDjzwez6233qpL+o1j5C8AaQjAALSRmmrT azpRU1PzH//4RzIwgOgm0q/L7W5UMvRIpN/bbrtt7Ngxshc6KIfDEQgw8heAFARg AJqx2WyFhWRgANBeeOhRQ0Ojx6NgGpC+6be01NHWRvoFIAsBGICWrFarLg2x4sjA AKKasqFH+qbfkpJSnvsFIBUBGICWEhISkpISp06dqsvqIgO/9tpr9MQCEGWUDT2q r6ubPWeOfum3pLs7GAqFdFkdQIwgAAPQmMlkSk5OLirSJwPTFxpAlFE29EjHns9x /UOPurq6FBzwBhDjCMAAtGc2m7Ozs8eMydVldZGBX3vttby8PF1WBwANKRt6VFdT M3vuXL3Sb3V1TUtLCyN/AShAAAYghcjAmZmZeXn67MR6PA0iA0+YMEGX1QFAE8qG HtVWV4v0q9dP7MrK8Olu0i8ANQjAAGQxm02pqWmTJ0/SZXWRgV999dWJEyfqsjoA DJNIv063u0n+0KOaqqo58+bplX4djrKOjvaeHk4+A1CEAAxAIrPZbLPZ8vMn67K6 0+nauHGjXtOJAWDIwkOPPJ7GhgbZz8SWl5XNv+uuCRPGS13lq5SWOjo7O9n7BaAS ARiAXCIDWyyWgoIpuqxeV1f/wgsvHH300bqsDgBD4+4nOxkWFxcvWrRo0iR9TsqU lJR2dXWRfgEoRgAGIJ3IwMnJyXrNB66trVu/fv1xxx2ny+oAcKTUDD369J//vPvu uydNniR1la9it5d0d3eTfgGoRwAGoILIwImJCdOmTdNl9erq6nXrnj3ppJN0WR0A Bk+k39qamha/X+qjvx/v3r38nuX5+fnyljiE4uLiYDBE+gWgCwIwAEWsVmthYUF8 vD4/dioqKteuXfutb31Ll9UBYDDUDD3a9eGH9953n15Ppoh/tNJSR3t7uy6rAwAB GIA6qampU6bk65WBy8sr/vCHNaef/l1dVgeAQxPpt87p9EoeevTeu+8+tGqVjum3 rKw8EAjosjoAxBGAASimbwZ2OMoefvjhs846S5fVAeCrhIceuVxNjY1S0++fd+xY /cgjenVkIP0CiAQEYACqiQys1+ZDXH/f0fvvv/+8887T6wIA4AAi/bo8nkaPR2r6 /b8tW5586qmioqnyljg0h6OM9AtAdwRgADrQNwPb7farr75m9uzZel0AAOwXHvnb 0CDSr9SRv4+sXv36G6/r1YkwjvQLIGIQgAHoQ98M3NfXd+yxX3vggQf0ugAAGOD2 eMIjf0MheUvcd++9Tc1Nej17Ekf6BRBJCMAAdJOaaisoKNBrdZGB8/OnPPLII3pd AAAEg8Hqqiq/zJG/S5csCbQFdE2/jkCgTa/VAeAABGAAetI3Awu5uWOefvppHS8A QMwKhULVNTX+lhZ5j/7Onzcv1CNxb/mwSL8AIg0BGIDOdM/AI0ZkPP/88zpujwCI QbJH/oqyd95xh8lsklF8kEi/ACIQN3wA9Kd7BrZYrC+99FJCQoKO1wAgdoj0W+90 Nksb+Svq33H77UnJSTKKDxLpF0BkIgADiAi6Z2CTybxp06bExEQdrwFALAiP/HW7 mxoaJKXfYDB4y6xZtlSbjOKDRPoFELEIwAAihe4ZOBTq2bJli8Vi0fEaAES3z0f+ ivQrZ+hRZ0fHzbNmZWSMkFF8kEi/ACIZARhABNE9A3d2dokMnJaWpuM1AIhWn4/8 bWjo7emRUb+1tfWWW24ZOTJLRvFBIv0CiHAEYACRRfcM7Pe3btq0KScnR8drABCV pI78Fbn69jvuGD16lIzig0T6BRD5CMAAIk5qampBwRQdL6CpqXnjxo0TJkzQ8RoA RBmpI39rq6vnzps3dtxYGcUHyeEoCwQCOl4AAAwGARhAJNI9AzudrhdeeGHatGk6 XgOAqCF15G+J3b5o8eIJE8ZrXnnwSL8AjIIADCBC6Z6Ba2pq161bd+KJJ+p4DQCi gNSRv5/s3r18xYrJkydpXnnwSL8ADIQADCByiQw8ZUp+fLxuP6nKyysef/zx733v e3pdAACjkzry992//nXVb3+r43uF4h+qrKyc9AvAQAjAACKa7hnY4Si77bbbrrnm Gr0uAIBxSR35u23btjVr1kydWqh55UEi/QIwIgIwgEinewYWN3nf/Oa3Fi9erNcF ADCigZG/Iv32Shj5+9ijj27bvk3HPgWkXwAGRQAGYABWq7W3t0ffW73Jk/MfffRR vS4AgOG43G6P290jYeTvvStWNHubdXxbsLi42GQyt7e363UBADBkBGAAxmA2m5OS EouKinS8BovF+uqrr+p4AQCMIhgMVlVWtkrYIF20cGFHZ4e+6TcYDMkI9gCgAAEY gGGIDJycnKzjA29CW1v722+/bTKZdLwGABFOpN+amhq/36/to7+i2pzZd8bpF30F u72ku7ub9AvAuAjAAIxEZGCLxaLveKS6uvrt27ePHTtWx2sAELFCoVBNbW2Lz6dt +hVlb7v11hRLioY1j1RJSWlXVxfpF4ChEYABGIzIwDabLT9/so7X4HCULV68+OKL L9bxGgBEoPDI3/p6X3Oztum3s6PjlltuSR+RrmHNI1Va6ujs7CT9AjA6AjAA4xEZ OD09feLECTpew0BbrEceeUTHJ/EARBRJI39bWlpuvfXW7OyRGtY8UuXlFW1tbaRf AFGA+zYAhmQ2mzIzs/Lyxul7GeJ+96WXXs7MzNT3MgDoTtLIX2d9/ew5c8aMydWw 5pGqrKxqbfX39Gg/zAkA1CMAAzAqs9k8cuTIsWPH6HsZ9fXOJ5544pRTTtH3MgDo SNLI3/KysgULF+r7Tl91VXWL38/eL4CoQQAGYGBmsyk3NzcnJ0ffyygpKb344ouX Ll2q72UA0IvLHdaraUr85549y5YvnzRpooY1j1RdbV2zt5m9XwDRhAAMwNhSU1N7 e3v1nY00ICEhccOGDWlpaXpfCAClZIz83blz58qVK/XteG+3l5jNpt7ef5/ojo+P O+z57oGuCF/xaeHj4eITTCZzQMKEZAAYDAIwgANZrdZ/fRi+WRH/b7FY9O04ZRSN jU1PPPHE8ccfr/eFAFBEpN/ampoWTUf+btu2bc2aNZHwvp5ehv8vs6Kisru7Oz5+ oE3h57e77e3tw70yAMZHAAZims1m+9d9Rvh/e3t7k5KSpkzJ1/myjMzhKLv88svn zZun94UAkC4UClXX1PhbWjRMv489+ui27dumTZumVUHD0baL2BeJn8/iP5nJZNqf ikU+bmtrk7QcgMhEAAZiy792d8UNRt+IESNGjx7NFB8ZUlIs69ev/8JeOoBoEx75 W1fn83o1DGz3LF/ua/HF8o9leen3q5arq6trb2/v/3ce/tfOLjEQ9WL3JywQI6xW S/93el9vb19SUlJ+/mS9ryhWNDU1r1279uijj9b7QgBoT8bI3/nz5oV6QlpVMyjF AfjLHI6ynp4ek2kgD/e1t3foez0ANEcABqJQYmJCYmLSwG3E1KmFsbyZoK/y8opr rrnmlltu0ftCAGhJ85G/InHNufNOU4JZk2rGpXv6PYC4ntJSR1z/SelgsDsYjPW3 J4DowG0xED0GDtz29vYmJCQMPMdL9I0E6ekj1q1bl5ycrPeFANDAwMjfRpF+tRv5 u+vDD5ctX8Zzv5FMJGHx8moymeI4Jg0YHDfHgOGZzeaBcFVYWPDlv0sGjgQtLX6R gQsKDvIfCICBiPTrbmgQ6XfII39FdvK43a+//nqZwxEQf9He1tnZFezuLqTns0GI q3U4ysQHXV1dPZpOfgagBnfGgIFZrVbxSiwC8KH7NpOBI0F5ecVNN900Y8YMvS8E wNC5PSK9untC/z4KG2htFb/X2NDo9YUFAv2ptr29s7Ojo7Ozu6tbCP/S1dUdDCso mMLP5C8yVvr9otJSh7h48V+TDWHAWPgRDBhPQkJCUlJSVlbWyJFZg/wS7rcihN/f +o1vfCMjIyMzMzMnJ2fMmNxx4/ImTpzIAWlgmEKhkIigmRkZ4ifkEL5cRNMyh8Pl cjU0NLSIINsS1tbW1i7+r729Q6TZjk4RYzuFrq7w46DdQRFre3p6Ynla7/AZN/1+ UX29U/xREX88QiEeEgYMgHtiwEgGulslJiZOmjTxSL+WDByxxC1gRUWlzWazWq0W i8XaLzXVlpqalpqamtFvVL+xY8eOHj2atIzoINJCs9crPsjKzBxaav2iOqezqrKy LRAQUTacYL1ef2trIBDoaG9vC+/HDkTX8C/B/nZG3V1d4gJEiA3/ZTjKhmL5EVy9 REcAHlBZWdW/x0+vLCDScUMMGIYIRUlJSRMnThhyBTJwFBD3i+XlFSIDW/qlpKTs /8DWL7Vfenr6QHLOycnJ7jfM2KxtVkHkU/BfXERWj9sdaG0Nb50Fg36/P9Dqbw2E d1zb2to6Ojr642o4tPYfHv78EHEoTIQM8UtQpFbxQfg3xce9PSRYY4mm9LtfdXWN +DPLoWggknE3DBjAwLO+mhy0IwPHLIejLCkpqT85p4j/FR+LPJE0cKig//fFbyWn hFktFutAmLZaw3naZkvvP1YqPk/8URw1evS4MWPUX/9AHht44i4KQnjk/+MMpFOR QON6e/t6e9s7O9v6n25t6z8S3PWv7dTufuEt1ODnwvH0Xx/0iITa/z///vhfH4hf e3t7CwsL+KEUg6Iy+n5RSUkpzwYDEYtXHSCiidvilJTkKVOmaFiT200M2cBUTJPJ lBgOxIlmkykhwWwyJwx8YE5INAvhjxPCnyPSdYJZfJ6p/3fEXw58IPK2+Fxz+M92 ysDvp4Tzd7LJbE4SeTwpHMXFL6JOitUqPtNitSSYzOJ+uaOzUwRy8QdYrxCuoYF4 2TegpyfVZhPBMtTbE+wOimDZ29vT0d4R198xeCAodnSE/7Kjvb2vv/fs/pwp/q74 VXyCSKDi1/3BUnwgfhVJU3xi+H97egd+v/83v/DRvz4I/eszBrKpSLy9/W+68eMC mov69Dug/7ROeWdnFw8GA5GGFzYgcomMkJmZOW7cWM0rc1MLQysuLu7rDd9DixQ9 8Ec5XmTr/j/V4gNz/6DO8O/0f/BF4k/+l39zaA46/qTnP+90RaYcuE4RJgdmxvb0 76b2X14853URg2Ik/e5XV1fv9XqZlgREFG6CgQil4bHngyIDAwBUirX0O4Dj0ECk 4Q4YiEQ2m62gQMtjzwdFBgYAqBGb6Xc/h6Osra1N76sAEMbtLxBZzGZzcnJyYWGB muXIwAAA2WI8/Q4oLXV0dXVxHBrQHfe+QAQR6XdEevr4CeNVLkoGBgDIQ/rdr7q6 xu/3k4EBfXHjC0QKkX7T0tKGM+Z3yMjAAAAZSL8HIAMDuuOuF4gIOqbfAWRgAIC2 SL8HRQYG9MUtL6A/3dPvADIwAEArpN9DIAMDOuJ+F9CZSL/p6ekT1D73+1XIwACA 4SP9HhYZGNALN7uAnkT6zcrKHDt2rN4X8m9kYADAcJB+B6m+3tnc3EwGBhTjThfQ U3p6+uTJk3S+iC8hAwMAhob0e0QqKypb/H69rwKILdzmArqx2awFBYrm/R4pMjAA 4EiRfofA4Shra2vT+yqAGMI9LqAPq9VaWBih6XcAGRgAMHik3yErLXW0t7frfRVA rOAGF9CByWRKSUkuLCzU+0IOgwwMADgsou8wORxlHR0dvb29el8IEBO4uwV0EPnb v/uRgQHg/7d351GO3IWBx2uk1i313XP1TN/H+ILYjs1kgweDDXZeyEtimyMxyYId 7GxC8l7I4oRNNsk/a5KAwbxdB4LzNgkkJLA2JMDuI8AY4wMM+MBjbEt9TPccnj5m pi+11JL6mP2pqrtcLbXUVaUqXfX9jK1Rq0ulUk+3qr79K1WhCOrXEgwCA2XDpi1Q bjVUv4pdGzgWG3ELLtfGpUvr6+tDQ9U+sg0AsITd9Ts2Nu73+8V6MxgIeDwe8XCh UEiE4vz8/OLSUn9/n62PXmY0MFAeBDBQVqITfT5v9e/8nENtYLF6bmyMNDY2tbW2 Hjhw4PLLL7/5ppuuvvbaS3L6ulwuceWZH/zg2WefnZiYmJqaEtsoS0tL8eWslZXk kSNHKvtEAABWKb1+tX0rLhrF2qWpqb29vbOzc2ho6Lrrrjtw8KD8+9WsnN/GXtrY +NGPfnj8O8d/+vLLYnUzNze3uCSiOD4w0F/iUlWK+GqkUinOigTYjQAGyqqGhn8n JiYbIxF5W6Strb2jp6fn6NGjt95yi8/v107W0NCwtramfii2VHJW3mILaWNjQ1zG 4/HHHnvspRMnTp06NTMzs7CwEI8viTBOJBI9vb3saw0ANWTX+hUTTE6e8vt8ATlu Q6FgJNLY0tIiKrdj797LLrvsxmPHDnZ27nG5Cs0hZ/2iZ4J0KvXNb37zmR/+cHJy 8uKF8xcuXFxcXFyKx3t7e/Q/tQoaGxtLJBgEBuzFFidQPtVcv6dOnc52bnv7vn37 +vr7jx07dtPb3qa27tr6ejqd9vl8DW636YcQibvjBpPo4+np6SeeeOKll146ffr0 +fPn5+fn48vxRFayt7eHNgaAqiJezGOxmM/rC4aCAb8o3EAkHG5samqW7du//8or r3zLsWPien7fihVKKp0O+P0+r7d435qjzN+vWWGJKj5+/PgTTz45cfLkzMyMWMtc uHixu7vL8oe2BDtCA3ZjsxIon7bW1kOHD1V6KTaJ4hWt29PV9YY3vvG22267+uqr lc2UQq1bKF8tUejX/KKNz7322pNPP/3KT396+syZ2dlZ0cby/tTLyZUVsflCGwOA 5bKDtxOTflkwFAoFg5FIpKmxsU3+JWl/f//PXP0zV1x+xY6Dt3r61tYVyo7zz6li sXJ54YUXvvrVr774k5+cOn16emamenr47NnXLl68WOmlAOoZ245AmQSDwYGB/soG 2+Tkqa6urmuuvvqO229/+zveoW675PSn3ZsmhhRp44WFheOPPfaTn/xk6ty5+bm5 +YWFxaWl5Xg8mUwmkkmOxQUA+WKxEa/HEwgoA7eBUHbn5FCTPHib3QOot/eKK684 cuQyUbyuwrv8FN85uapWIqqcpdI+BbFC+c63v/3II488/8ILood7erortIybGAQG bEUAA+UgVrRer2dgILv/c/kb+MzpM8PDw2+7+ebf+d3f7WhrE1sAu76xqiaIZ5HO ZFZSKX/eeLXYmolFoz945ploNDo1NXXhwoXs0HFiOZlcSSQSqVRqeHioUosNAHbI lq3X4/eJP9m2DYq4DYUi4bBI23A43Nbe3j8w8Kaf/dnhI0eKvO1Wkl9aleMalm3J q4GyWhQr6PMXLnzmM585/u1vx2Kxw12HK7IwY2Pj6XS6DlbTQHUigIFyEFsh2rM1 lKeBxcq7v6//nb/4ix/9kz/xeL2lv4m3OhUaaigS+WLD7sSLLz7/3HMjo6Mijy9e zB4lZVl+z/GKSORUqnYPIgqgzojXt/Hxkz6vV0SteA0PyHEbCgXDoXBzS4tYubR3 dAwMDFx/3XXislDZ2v2223qi7iy9msl87P77v/GNb4yfHB8eHi7zYogGFqukMj8o 4BAEMGA7ZefnnBvtbuC1zOrnHn74uuuvV+OwOvdJq5QieawclOu7jz/+yiuvzM7O Ls7PLywuLi0tJUQbi/+EVKq/v4+3HwMwZ7NpfaJGPW6Xe2Njwy8fRKq5Obsnsvhf JG5La2tfX9+111zT1dVVZG9k/WXLKkA/7ddKXP/xj3507733uty552GylVgA0cDs CA3YgQ04wHY7BrBkWwNPTU1/8J57PvShD7W1trK5Y06RnasluZAvXrz4xFNPvfLy y7MzM4uLi9nDVsezh62W+zgrnU4TyYBDRKPRhgaPSFBvNmnFZTZts4ePkndCDsuH RxZ/tbS09PT0vPENb+ju7hbrhSLvsNVm7a57I1O2dhNfYfGa/9Df/M3n/vZvDxzY X7bH5Z3AgE3YOAPsVah+FZYH0mpm9Vvf+lYwHK7LvZ3LrMhmZfFClraO0SU2i0Uk T0xOnp+dnc+e9ziekI9fvZISd02nxf+ZTC/neQKqxkhsRHSpkrKeBo93M2azl8q7 aoPyu2rFB01NTZ2HDl11xRWHZMXfVSsZbFqJrK0yyj9fcnn51ltuafA0lOdBGQQG bMJWF2Cvtra2zs6DRSawMH72dux99NFH/YGAJK84rZotCim+hSoiWVwW3ylxY31d bNxMTEw8+/zzkxMTC/PziURiaWlpeXlZZLK4nhaZnM5eZNLiT2ZtbfXIkSPWPxOg Loifx9HRMZfL5REasrJXvPIfz2bN+v3+gHJqn1BIfBAOh/fv3z80MHDg4EHRsTue tzaftmal3X7MVTRtTVNW1ivJ5Lve9a7pmeny/OLy3Lmp8+fPl+GBAEchgAEbFR/+ VVmyHu1o7/jKV74itudKnxXKye12i2+A4uPJqksbG6KWz5w588orr5w5eza+tJTt 5K0TI6dSqUwm28mr4q/V1Uw6vSpbW18jm1G1cqrVLf40eMTPxVbDNoi/vEq+ysGZ LdhgMBQMiinEa+ze9vaevr59ezva28V/7cVP3pMjp2Ml3SkrUbOOpPyLp1OpO+64 Y/b8bHkelB2hAcsRwICNWltaDh0+pGfKEhs4tZL68Y9/TP3WNJ3b08rAss5gVohs Pvfaa2dfO/tKNDZ17txyPC7aWDRzInvG5ISYlajmdCqdWX2dyID19XXx1/rampzQ 62Img0OD7K3tQLHYiPh3F4EqLrM96s4Sf4vObFCuuV8nSlUedc3Gq1cZcvX5xDeq SFYxC3FDMBTqaGvrPHSouamptS37p7m5WUyjv1pV+flq4uQ9dCx00n6fiAZ+05ve JL6zy/C4Z8+cvTg3V4YHApyDTRnALjqHf1Wm02JycnLi5EQ4EmEzzlEMbbibyOYc G+vr6XT6gmxpaWlqenpmenpRHoIWAS22DZVDf4nropizl6Kc1zYv1tfFvbN/b8iy bb2+Jl+9JG7N/iW6ZW3tkvwokhw20tZYnPJZcSme71CdFng0GhXP0iWT5J0CxKVL JT9l0Yd7NDeKf/7sP6J8uUczpfK3SFLxDZKNUDlQxS2iS5VW3YxT+TIQCGS/MS5d cns8/kCgMRJpb2trbW1tamoSL1+NjeKGLHN1mk/pVXFFm6ySqWpVka8oj5xvM/GN F4/H+/v7enp6yvDoDAID1qrDLQmgSoiNy8HBAUN3Mbdx/85ffOcf3ndfOBhkQxC7 KiUYlL21letrctcqPWOuqI0SbZxKpST5KcxdvKjcuLC4eEnKPp34UlxEsriyHI+v y1fm5uZSKys5M8kWuzyT0ok+DG7f56LB09DS0irCUr3FL7/lNPupBncoHM4uvLSn ualJ+WxrW5vyb+H3+y0pTHNy/h2V35WoSqnTfMr3D69UqC3537HZAE4kPvXAA1// +tfK8Fu5kZHRlbxXMwCmEcCALYwO/6qMrkoz6cx3H3880tjIMZ9RfmXuGffWN7me H5Md38ypxl7pdsz+nHosTv26WViY5tClQCGFfi7Ei8nS4uLNN93k8Xp2nMBaDAID FiKAAVv4/f6hoUFz99XfwOPjJ186caLz0CG2XAGdrBqu4YcOqHvFf8zFi8lrZ8++ 4Y1v7O/vs3tJGAQGLEQAA9ZT3ms3PDxkeg46t9Gvvfqaz37uc2yIAwBgLT3rVrGy /i+//dvPPf+c3QsTjUblQxNWeG8RoD4QwID1wuFwX19viTPZtYHn5uZe/unLHPkZ AABr6f/NcjqVuuqqq1paW2xdHkne52t5ednuRwGcgAAGrPeGN1xlyXyKNHA0Gvve 449fc+21DP8CAGAhQytWsaZ+/rnn3vq2tw4PD9u3SIoXXzxh90MATkAAAxYLBAID A/1Wvc+w0HzaWlu/+R/fon4BALCQiRWrWFP/wq23Xpy7aMfyaHEoLMASBDBgMZ/P pxz+yr4GnpiYPDU5GQyFLJk/AABQmPvNcjKR6Ovv6+7utnx5tF59NZo97zqA0hDA gMXUAJZsa+C33vjWv/rrv7ZkzgAAQFHKflX/7aMfPf7YcQsXJl80Gk2nCWCgVAQw YCVl/2f1Q6sCWDur6anp0dFRjn0FAIBVSn9LUTqVGhoe3r9/nyXLUwjnQwJKRwAD VsoJYMmGBn7LDcc+/sADVs0TAACHs+qAGn90332Pf+9xS2ZVCAEMlI4ABqy0t6Nj X95vfy1s4NOnz5w7d87n80nyCntjY0Oybs0NAIDTWLgOFWna19fX1XXYqhnmO3du 6vz58/bNH3ACAhiwkt/vHxwcyL/dqgbev3ffF/75n91ut8vlEvMUAaxccW8R15Vb JAoZAICi9K8f1fW4upJV56CsbRW333bb9My09Qu6JRYbSaVS9s0fcAICGLBMKBTs 6+sr9FlLGvi+j9x389vfvutkYvWsxLBSyOIWt4YSycqURDIAwIGUlfIemXqjsirU Bq1K3C4uxafEalSdQKlf7d2Pf+c7H//Exy3c8yvf2NhYIsHJkADzCGDAMvlvAM5R 4hpxcWHxqaef9ng8pcxEXRKGkQEA9aH48GyRoBWrPOWK9nZzlLXk6urqsWPHmpub Sno+RXE2YKBEBDBgmUL7P2uV0sD9ff2f+exnTd/dqCLDyC6Z+otzIhkAYBVtzUrb 15vqoGuR4VlJE7SF1kqWr63UGa6trf3u7/zO6TOnrZ2/VjQaS6fT9s0fqHsEMGCZ cDjc29uz62TmGjgWGzn+ne8MDA6auK99tMPISg+rhax+ikgGAMfadWy2eM0qq4zS h2e17Ktf4fyFC6Ojo++789eHh4etfRTV2Nh4IpGwaeaAExDAgGWuuupKnVOaaOD4 UvwHzzxj9F7VQDuSnB/J2t2tJToZAKqYoT2N1ddzQ2OzdrO1fiV5BHhufv5XfvmX m5oarX0g7SOeOPGSTTMHnIAABqwRDAb7+wseASuf0QY+1Hnof//93xtcqJqhVrEk bx4pnawOI+cMJkt0MgCUplDKSvKLsKTjQFDaaWrlpdju+lVvvPeee86cPWPtY2nx NmCgFAQwYI1dj4CVz1AD//7v/f47f+mXDC5UvVHee2yikyVSGUCd0rmPcU7QKnvl 5KesVbsZV6Gy1a+4/H/f+Mb/+puHrH04rZGR0ZWVFfvmD9Q3Ahiwhs/nGxoy/AZd nQ187tzUCy+8YMnxn51APca1tNXJynaha0uRXa8lUhlA2RU57NOl7XJSVn2LrJKy StbW1qhseZSzfsVlIpF485t//uDBg9Y+qOrVV6OZTMammQN1jwAGrGF0F2itXTM4 4A/8+9e+Zm7mKEIdQBbX19fXlTyWtg7upaay9szJErUMII/2ZTx/p2Jp+37F2j2H 88djtU1Lx1rCjq9h/jzVW5R/63ffcUcyZdcg7ejIaJIRYMAsAhiwxpVXXiGVcJaj 4nf8+f/083/+F39hbs6wijqALMm1rFaxK8+eLcodCWagyuW8AucXrDoAK21PU+2h ntQr2p2KidiKK0/9qjeqr/Yfu//+p7//tOUPrT4Wx8ECTCOAAQsEg4G+vs3hXzsa +NMPfvqyyy83N1tUyq7BrO6VvUdDvXvOthQb0EC+XcNV2t6uOVGqrVP1Q0kuWDEf 7TgtP4A1qpz1m/N9EotGP/yHHza9SbCr0dHRZJJBYMAMAhiwQCAQ0O7/bG0DT0/P PPfcc7wB2AnU3a3V9wGq5Sy2q3SWs0I77KzeUr5nAuwkv1fzb5S2WkLKe/urNlyV 60qmqt/tDQ0NkqZy838K4Chlq98dz0qQTCaP3XDD/gP7LV8GBQEMmEYAAxbw+XyD gwPaW8w18I738vv8X/v6100uGZxBzWDtcbDX1takrTEx5ZacafITulBLS5qx6PxP oaYVerEqVKcKbaNqL9US2JE6rKpML3o1P3RJVliiPPWb84OQ447bbktl0pYvhiIa jabTHAcLMIMABiwQCoV6e3tybrSqgd/21rf98Uc/amaxAOPyW1rpFiWntROon8pP 6HzqfaUCmV2cduPSwkAyt4ls4T6N2oOrmZhtzi6XOS2aP44qbU9N5UPlcXNul7bq VB1izVHKswbsVrb6lfJ+DLU++cADj333McuXRDE2Np5IJGyaOVDfCGDAAsoRsPJZ 0sC8ARj1Su3hXS+V7Ut1ZFvNNu1lzmx3fKwcO262FhoD1z+Bng+Vp6Dusittf6bq XXKaNn8CADnKUL/qh8V/HzcSi/3Bh//Awl+Z5SwDx8ECzCGAgVKJddsVVxQM1BIb eHz8ZDQa5Q3AAADsyvL6LTTwK+nYGyWZTF577bWmT5G4KxHA/C4MMIEABkqVcwSs fKZ/+yvumFhOPP3975u7OwAAzlHO+tX5XoAbb7wxHA5Zu1Sq0dEx0dg2zRyoYwQw UCq/3z8w0F98GtMNvH/f/i/80z+Zuy8AAE5Q5jf96n/Eu++6a2Z2xvJlU8RiI6lU yqaZA3WMAAZK1dHetm+/rvMcmMjg97//A+9573sb3G7jywUAQP2r2voV/v3f/u3h v3vY2mVTvXb2tQsXL9o0c6COEcBAqXbdBVrLaAM/8MlPdXZ2trW2Gl8uAADqXDXX r5hydmbmrrvvsuk4WKMjo8kVTgUMGEYAAyURa7XL5UM061y7GVoLnjw58dTTT3d0 dDACDABAjmquX2XiRCJx3XXXcRwsoKoQwEBJAoFAX192xaY/bPU38Nrq2ncff9zU cgEAUM+qv36VK7fecovHa9epHDgOFmACAQyURA7gXuVHyfIGvvEtN/7Jn/6p6WUD AKAulfNkv6XUr/CJj3/8e098z4oF3MHo6GgyyV7QgDEEMFASn8+3dQjozZ8mC/eF vv9/3H/d9debXjYAAOqPTTv9amdrVf0KLzz//J/9+Z9ZsYA7iEZj6XTappkD9YoA BkoSiUS6ug5vfWRlA4+Pj8diIx6PXftNAQBQc2qrfoVEInHNNdcMDQ2WvIw7mJiY XFpasmPOQB0jgIGSaEaAFcYaWCqcwVPnzv305VdKWTYAAOqJ3fWbn8El1q9CBHBn 58ESFrCgaDSaTmfsmDNQxwhgwLxgMNDb25t3szUNnE6ln3jySdPLBgBAPbG1fnd8 A7Al9Su8/eab/QG/2QXcBW8DBowigAHzto6Alc+CBj52ww3//c/+3PSyAQBQN8pW v4Wu7zqTIj7+V3/1xFN2/UabA0EDRhHAgHl+v7/wyf1KbeD7PnLfW2+6iTMAAwAc zr5jPhc68rP+B9Uz2Q++//37P3a/wQXUKxYbSaVSNs0cqEsEMGCez+cdGBgo/Hnz DSxWqJ/81IOdnZ1tra2lLCEAALWrIgO/+h9X52SzMzN33X2XzjMgGvXqq9FMhrcB AwYQwIB5hXeBVpls4MnJU088+WRHRwcjwAAAZ6pU/ep8aP2Lt7y8fPTo0d7eHp3T GzI2OpZgF2jACAIYMC/vENA7MtPAcxfnnnv+efNLBgBALbNvt2epvPWrTPlzR492 7O3QeRdDOBA0YBQBDJgXDoe7u7v0TZv9WdPfwA3uhm/+x3+YXCwAAGpWBQd+dT66 0foVfvVXfmV9Y13nvQwZHz+5vLxsx5yBekUAA+ZdfvllUuET+eYx0MAf+MBd73nv e9n/GQDgKPbVr553+dpUv8LXv/a1h//uYZ13NOrFF0/YNGegLhHAgHlKAEs2NPAn PvHAocOH29vaTC8bAAC1pV7rV5iemrrn3nt03tcoAhgwhAAGTAoEAr29PeqH1jbw Jz/5qYOdnQQwAMAh6ql+8yeenZm5+7futulA0JwKGDCEAAZMyglgyboGPndu6vhj j3EIaACAQ9R3/QqJROKGG244dKhT/0z0Gx0dTSZX7JgzUJcIYMAkv9+ffw4kSxp4 fW39u48/XsKiAQBQM6q/fvVPVmTKX7j1Vo/Xo3MmhsRiI6lUyo45A3WJAAZM8vm8 /f07nAPJUANLO2Vwc1PzI48+WsqyAQBQE2yq342NDT2PVbb6Fd53551L8SWd8zHk 1VejmQxnQgL0IoABk/J3gVaV2MCDA4P/86GH2P8ZAFDfyjb2u+NjlbN+xafu+8hH YiMxnbMyZGRkdGWFXaABvQhgwCT1ENA7KqWBP/mpBw8ePMgRsAAAdcyO+tWZvjof 3ZL0VT87OzPzwXs+qHOGRnEgaEA/AhgwqXgASyU0MAEMAKhv5anfQo9S/vqVCGCg ahDAgBlF9n/WMtHAp06dfvKpp9rb29kFGgBQf2xK35w5F98bWc/cDD20ns8mEomj R4/mHz7TEpwJCdCPAAbMCAT8vb261mFGG3hxcfHZZ581u1wAAFQvy+s3P32LP4qF 9WtiVm9+85vb2lp1zt+QkZGRlRUOBA3oQgADZux4DqRCjDXwpUvHH3vM5GIBAFCV Kj7wq2cCW+tX+KV3vtPldul8CEM4ExKgHwEMmOHz+UQA6y7bLH0T72lrafnyI4+Y XjAAAKqNTQO/Uk3V78bGxgfe/58XFhd1Pooh0WgsnU7bMWeg/hDAgBlNTU0HDx6Q DIzuSjonHhoc4hxIAIC6YW397pi+eh6l4vUrbv/j++4bGRvV+UCGnDp1emFhwY45 A/WHAAbMuOyyI+p1axv4Uw9+urOzs63VlvcIAQBQNuUZ+NXzQNVQv+LK+dnZe3/7 Xp2PZYiY/4kTL9kxZ6D+EMCAGdoAlixtYAIYAFAHqF+FWr+SnQEscSYkQDcCGDAs EAj09HTn364/gwtNOT5+8pkf/pBzIAEAappNuz3nz7ls9Wt6VtoATiaT119//dDQ oP4H1Y8zIQE6EcCAYYUCWCq5gc/Pnj/xErswAQBqGPWr0tav4ueOHj0gH0PEcgQw oBMBDBjm9/t7e3sKfbaUBk6n0k89/bTJxQIAoNKoX1V+/Qq3vOMdoXBI/0Prx6mA AZ0IYMAwv9/X21vsJMCmGzgYCHz9G//X/JIBAFA55alfPY9Snvot8qkd63d1dfV9 v/7rq+tr+h9dP04FDOhEAAOG+Xzevr6+4tOYOyzW4UOH/+Ef/9H8kgEAUDkWBnD1 12+Rzxaq37W1tf/64Q9PzUzrXwD9otFoOp2xY85AnSGAAcMikXBn56FdC9dEA//s tdfe/7G/dHMELABArbGqfvPnU+j4zyYWo7L1K25/4BOfeOEnL+hfBv1OnpyIx+N2 zBmoMwQwYNiRI8PKz47lDfzgg58+yDmQAAA1pUrSt/hkZUhfabf6FdcX5uc/9Hsf 0r8k+nEqYEAnAhgwTA5gyY4GVgK4va3N9LIBAFA21ZO+xaeskvoV16dnZj76x3+k f2EM4VTAgB4EMGBMIBDo7u7a+sjKBj59+sy3vv3tcCTS1tLCXtAAgGpmX/pKlatf 00eWFumb/1mRu+KW9fV19fb48vJSPH77r/7qwEC/zkUyhDMhAXoQwIAx2wNYsrCB z52b+vKXvyym7Ni7d/++fertYt25uLTU1NhIFQMAqoEl9WtV+haZ2MKB3yIT7Drw q8hkMgsLC+l0+s477+zqOqx/wfQbGRldWVmxY85APSGAAWP8fn9PT/f22yzeF/r0 6TORSKS5qam5uXnfvn0HDhy4/Y472js6tFW8Jqp4cVFcaWpqaiCMAQBlUW0Dv0Um rmD9JhKJpcXFL37xi6+dPTt7/vz8wsLiwsJSPG7TwK+KUwEDehDAgDE+n6+3tyfv Zl0NLJVwiuCxsfFwKNQssripqbW1TfTwXXffLW7fu324WAljsSpuJowBAJayb+BX Mlu/haYvQ/2K9E0mk8vygZcfeuih6ampi3NzC6J1l5YSieXh4WH9C2AVTgUM6EEA A8Z4vd6+vt6dPmN7A+9ocvJUJBJpjEREGLe1tbW3t//m+98v7RTGYq0srjQ3NxPG AACjyrDbs4lHKU/9JoTlZXH9s5/9rAjdCxcvLsriy8t2D+oa8uqr0UyGUwEDuyCA AWNCodDhw4cKfHLzB8rC3aGNHER626NPTExGwllNTY0tLa2ije/+4AelvDCWaGMA wG5Kr9/yDPwanU/OxGroPvjgg+dnZ+fm58X6MR6PLycSVRW6hYyNjYtnUOmlAKod AQwYMzw8vFuT2nKKYJ0Tbk1fcIrR0THR8JFIWPxpamxslQeNf+3OO8WnOjo6Duzf r52YNgYA2F2/JuZfSv2qlfvwww9PT03Nzc0tLi2J/5az4keOHDG6MNWDUwEDehDA gDHKu3qqv4H1LEDO/LNvMxZEHofDEdHGWS13vu83xGc79u7NaWOJPAYAByixfnc9 O5Hp+l1dXV2SO7YxHPZ4PDmzen2n5c985vz583Pz80uLi0vyWK4wODhg/KnUBk4F DOyKAAaMGR4e0te3lXlLsPbRdS6AnvmPjIwG/P5IJBIMhbLH4soeiKu1pbX19ne9 S5J3qy6Ux2JzRMyWQgaAWlTB+s1kMqJvlZWISFyv15szz5nZ2ZmZGXHl37/61YX5 +bm5uYXFRRG38eVs5CaTiZoeyzWNAAZ2RQADBgQC/q4u5STAlWlgIxNb3MBFjI6O +f3+kBAMhsPhSCTc1NTc2NT0G7/5m8q2C4UMADWnlPotfl/x2bW1tfnFxfy+VU3P ZCkT/MsXv7i8tCT6Nh6PZ0d2Rd+K/1ZW5F9JYxtOBQzsigAGDBCZ193dtfWR3gbW MVkVNbDRhdFz35MnJwKBgPjqBYNBEcmikBsbxQZP5P133VWkkCVNJCtzppMBoAxK SV9RtnOa1+2WpqaGhob8mU9NT6t9+4XPf14E7ZL8Llx5D+WESLiVVKq/v6/EJ+JA nAoY2BUBDBjg8/l6ero1N1R/AxtYANMLU/p9Y7ERn9cr8lhEciCY/RMOhyKRxlAo dNdv/Za6IVWokyV5k0sZTJAKbHIBAPTYsX5zsra1ubnQa+y5qSmlbJUpP/8P/5CQ 4zYhj9kmk8ls3CaTmdVMRc6UW/ei0Vg6na70UgBVjQAGDPB6vb29Pdtv07mfcwUP iyWVv4FLv/uOxsfGxT+BXxlNlseTg/JO101NTcFQ6N3vfvfrqbxvX6FUlpRa1g5Q FN6SA4B6lW3a+fnXm7alRbwSFhr7fW1qalaTtV955BGRskvyiXCTspVUKrWykhLt lUoN1O8hpqofpwIGdkUAAwaEgsFDO5wEmAa25e6mZys20SYnJ70er09Usk/w+uVo DgSC4VAoHImIbL7tjju0tXywcC1L24NZopkBVB9tzUqaoC1yl5ym/eqjj66srChv sk0mE5sxm05n0mkRt6Kpenq6bXpVh4U4FTCwK17IAAN2GgFW0MC23L08cx6TB5Z9 4j/RyuI/+XpAln3TcigkOvo9v/Zr2i3LvXv3HjxwYNc5U84ADDHRsQptzSp3/NK/ /qto1+Xl5RV5eFbErQha0bHi/5QctEJ/fx9NW2ei0aj4d670UgBVjVc9wICiB5yk gW2cQzlnq8fo6FiD2+3z+z2eBq9H/PEq2ZzdQ1sm4lmUs8jpd7/nPSbKWZWT0BIV DVSrnHaVjOSrKr9j/8+Xv7yayYiOTcn7GCuDsSJixY2Z1VX1qnj0Oj63LQzhTEhA cQQwYMDQ0GDh6NLZlpU9N5JEA1dWLBZzu8X2cINIZU+D2+PxNniyvKKkGxp8MrWi g8GgSOvbb799Y/sm9b59+wxVtCK/pdU5FjmeDVCv8ntVYaJaFTntKm3tV7y6uppM JlOy9Bbx6OJ2UbDZv5T/Rciura2vr3FoKJRCfAeeOPFSpZcCqGo1tu0IVNbQ0JBF fWv9OLDB6fV2eCnLY+3dKzLnKiSebDQaVSpayHaziGf542xJK3/Jl15lp275MhAI uFwu7Y7c2hmaK+oc2oPE5j8EjQ1DCtWpVEKg5sjvVXX+X/qXf9nY2Hh9n2H5Ui5W zYVI1bXNDxW0K6oEI8BAcQ7aagRKFAj4Dx/OngS4nA0sMRRcBXOuQtY+WVHULpfb vVXVbpcreyl/uHmj/Je48Lwe2ZsD1x45sAWxTLfdfnuhYrGksfMVqe78ZSDCdSoS nzmsatF8hepU2hpWFZ9ShlKVPYEVa1vDqevrcp5uXmguNza2YlVcXadXUZdGRkZX VlYqvRRA9XLQ9iJQIr/f39V1WF+4GtgdWsdk1dXARpfH8rtXZM5Vq1aesmhssbDZ yJbr2uXKFnc2teUL9cPsRXYSl3Ip17ZbuVHN7uxwt9zebrm73qV5l3URyuG+O22I 8PpTJD5zZN+h+qUviSsiLpW9eUVZbrVoNjKV6hQfbojczDbnxuaN2fyUP8z+//qH a5tX1yXpEnUKmEMAA8XVxpYTUA22AlihN4NrZXdoPctQwkNYf/eKzLlqOfApGyVy TmwU7pFtJrdsjxLbeySR4uKLqP3Mnj3ZT2XvIH+0eZOs9OXR/pO5LPrnyxakTDxZ 9S9xIXpSvuHShjqBJInsFH9lP7XxunV5eqHo8Q5sp6e9ARQSi42kUqlKLwVQvdhm AvTyer09Pd2aG8rdwBJDwVUw52rmzGeNekL6AqWLRmPpdLrSSwFUL7aWAL2ampr2 7du7/bZqb2CD05PB9cCZzxp1gPoFLHHq1OmFhYVKLwVQvdhOAvQaHBzcqSwsbmB9 UzIUXPk5VznHPnHUItIXsIryLoaXXvpppRcEqF5sIQF6FQhgyeoxXofuDm3JHMo/ 52rmzGeNmkP9AhZSfqA4FTBQBJtHgC5+v//w4ewRsJzRwAaWoYSHsGUOlZp51XLm s0ZNIH0BC2l/oEZHxzgQNFAIG0aALnIAHyqahTXQwAanZyi4TjjzWaNq0b2A5XJ+ rAhgoAi2igC9RAMrKxhxKYqiu7srbxIa2MRD2DWHSs28ajnzWaOqkL6AHZTTvG1s bCgnaROv9tQvUATbQ4B5Ionlv7MbdZFIJB6Pd3dvnieJQ0PTwFXImc8a1YD0BawS i42Ew+Hl5bj8kp59VSd3AUPYGAIstlXF2Q0+pYq3nz1YRQOXbyZlnnOVc+wTR0WQ voBpauvKr9y0LmANNoOAcggE/MpGoHJ+Arfb3dV12AkNbPBR7JpD+edc5Rz7xFE2 dC9gyMjI6Pr6usvlkl+eaV3ARmwDAZWkhLFSxR6PRz7O1o709mcZGljPYpTwKHbN ofxzrn5Ofu6wD+kLFDc2Nr62trpnz2brErpAmbH1A1SdQCCgbEOK/4OBwN59e7dC xdFDwbwl2CZOfu6wFukLaImfiDOnzyRXVvZsSSaTlV4oAAQwUCPkKla2Ly9tbFzy +30HD3YWKRc7G1jiyFj1x8nPHaUjfeFk4vt/cnIync4olSvJr6i0LlC12OIBapsm jMXlhtfrPXTo9f2o2SO62mZe5Zz83GEa9QvnOHlyIpNJK3svi0txC6EL1By2dYD6 pISxuiu1+HBlZaW/v2/XO9bKULBVM6nIzKuck587DCF9UZei0WgwGBJlqwzoErpA nWErB3Ac9T3GkvyX3+/v7DyYM42JDK7IAaKtmklFZl79HP70URz1i5omvoFPnTqd Sq0ofetyUbmAU7BxA+B1W+PGmwemDgaDOseN63gouAzzr3IOf/rYEfWLmhCLjYgV WSKREK9jLtceZVVF5QIOx2YNAF20baxciq2K1MpK3+t5XMlzBVs1k4rMvCbwFYCC 9EVVGRkZFasnJXHVY1BJVC6AwtigAWABNY+lrUNViwuv19vVdVhnOFV/A5dh/tWP r4CTkb4oP/FdNzExmU6n5SHczRPnKp8icQGYw6YMgHIIBoPaNx4rFwG/P53JaHex rv4MpgAlvgjOQ/rCJiMjo36/f2sX5ey7cBnCBWA3NmIAVItgMCBelNRNbeVKJBJJ p1Jd3V2GoouhYLvxFXACuhemyYeYOuX1eJficeXNtwzeAqgSbMEAqDHawWRp+3uS V1dXe3t7lNtp4DLgi1CX6F4UIr43Tp6c8Hq9icSyeAHIGbOVKFsAtYBtFwB1S05l QSlk+dpWLYfD4XQ6LYJ5eHiolIegAPkK1BPS14Gi0ajH4/V5vcuJ5T17XOpPNFkL oF6x4QIAm7aCWaHG8uZlIBBYE8W8tpbfzEQgX4GaRvfWjVgs1uBu8GZrNqEdns35 CSVoATgZmywAUJKdslnSlnM4HM5kMuvra4ODg5VYwDKhgWsR6VudxsbGXXv2eOQ9 jffs2babMSkLACViewUAKmZ7PEvbe2QzocX/kXAks7q6vra2vrExNFTVFU0G1wS6 1z4jI6Nul8vd0ODxeJaX48qGlnr8J+2BoFRELACUE1sqAFDz8kJasS1ztj7I/h0K hdZFT2eD2q6ipoSrE+mbQ/Sqy+VqaHC73Q3Ly8vK8Yql7d/AO1arRLgCQG1iAwUA sIMCUZ2VH1GaW9TAzhKBLT4u8UhjsErN1a+oU+X0sG6ZfLZYSd10yf8lS5FfuxCr AAAFAQwAqKQipS3T7hSee3v+EHdjJLImwlv8d+mSkt/C0NCgw0ekTaSvuMvo6Nge mUhQl7h0uxvc7qV4XNphgFTSblFs/2IX+8rTpQCAMnP0BgEAADl2C/LaRnACAByO AAYAAAAAOAIBDAAAAABwBAIYAAAAAOAIBDAAAAAAwBEIYAAAAACAIxDAAAAAAABH IIABAAAAAI5AAAMAAAAAHIEABgAAAAA4AgEMAAAAAHAEAhgAAAAA4AgEMAAAAADA EQhgAAAAAIAjEMAAAAAAAEcggAEAAAAAjkAAAwAAAAAcgQAGAAAAADgCAQwAAAAA cAQCGAAAAADgCAQwAAAAAMARCGAAAAAAgCMQwAAAAAAARyCAAQAAAACOQAADAAAA AByBAAYAAAAAOAIBDAAAAABwBAIYAAAAAOAIBDAAAAAAwBEIYAAAAACAIxDAAAAA AABHIIABAAAAAI5AAAMAAAAAHIEABgAAAAA4AgEMAAAAAHAEAhgAAAAA4AgEMAAA AADAEQhgAAAAAIAjEMAAAAAAAEcggAEAAAAAjkAAAwAAAAAcgQAGAAAAADgCAQwA AAAAcAQCGAAAAADgCAQwAAAAAMARCGAAAAAAgCMQwAAAAAAARyCAAQAAAACOQAAD AAAAAByBAAYAAAAAOAIBDAAAAABwBAIYAAAAAOAIBDAAAAAAwBEIYAAAAACAIxDA AAAAAABHIIABAAAAAI5AAAMAAAAAHIEABgAAAAA4AgEMAAAAAHAEAhgAAAAA4AgE MAAAAADAEQhgAAAAAIAjEMAAAAAAAEcggAEAAAAAjkAAAwAAAAAcgQAGAAAAADgC AQwAAAAAcAQCGAAAAADgCAQwAAAAAMARCGAAAAAAgCMQwAAAAAAARyCAAQAAAACO QAADAAAAAByBAAYAAAAAOAIBDAAAAABwBAIYAAAAAOAIBDAAAAAAwBEIYAAAAACA IxDAAAAAAABHIIABAAAAAI5AAAMAAAAAHIEABgAAAAA4AgEMAAAAAHAEAhgAAAAA 4AgEMAAAAADAEQhgAAAAAIAjEMAAAAAAAEcggAEAAAAAjkAAAwAAAAAcgQAGAAAA ADgCAQwAAAAAcAQCGAAAAADgCAQwAAAAAMARCGAAAAAAgCMQwAAAAAAARyCAAQAA AACOQAADAAAAAByBAAYAAAAAOAIBDAAAAABwBAIYAAAAAOAIBDAAAAAAwBEIYAAA AACAIxDAAAAAAABHIIABAAAAAI5AAAMAAAAAHIEABgAAAAA4AgEMAAAAAHAEAhgA AAAA4AgEMAAAAADAEQhgAAAAAIAjEMAAAAAAAEcggAEAAAAAjkAAAwAAAAAcgQAG AAAAADgCAQwAAAAAcAQCGAAAAADgCAQwAAAAAMARCGAAAAAAgCMQwAAAAAAARyCA AQAAAACOQAADAAAAAByBAAYAAAAAOAIBDAAAAABwBAIYAAAAAOAIBDAAAAAAwBEI YAAAAACAIxDAAAAAAABHIIABAAAAAI7w/wGYryYX1pCKDwAAAABJRU5ErkJggg=="/></symbol><use xlink:href="#c" width="1280" height="1280"/></g></g></svg>')} +.is2d .rook.white {background-image:url('data:image/svg+xml;base64,<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="614.635" height="614.635" viewBox="0 0 460.977 460.977"><mask id="b"><use xlink:href="#a" width="1280" height="1280" transform="rotate(.193) scale(.36014)"/></mask><symbol id="a" viewBox="0 0 1280 1280"><image width="1280" height="1280" xlink:href="data:image/png;base64, iVBORw0KGgoAAAANSUhEUgAABQAAAAUACAAAAAA9j6ArAAAACXBIWXMAAA7EAAAO xAGVKw4bAABHbUlEQVR4nO3dBbxVZaKG8SMWQ4h0SSmSooKOChhYKHYnKBhjII5g jl5zxlZ0xBwDFOxOFAxUwiIU6S7pkDgiitwDBnX2/tY+Z631fvH8fzP3ej3r6juj PJ6z99rf2iIPAAK1hXoAAKgQQADBIoAAgkUAAQSLAAIIFgEEECwCCCBYBBBAsAgg gGARQADBIoAAgkUAAQSLAAIIFgEEECwCCCBYBBBAsAgggGARQADBIoAAgkUAAQSL AAIIFgEEECwCCCBYBBBAsAgggGARQADBIoAAgkUAAQSLAAIIFgEEECwCCCBYBBBA sAgggGARQADBIoAAgkUAAQSLAAIIFgEEECwCCCBYBBBAsAgggGARQADBIoAAgkUA AQSLAAIIFgEEECwCCCBYBBBAsAgggGARQADBIoAAgkUAAQSLAAIIFgEEECwCCCBY BBBAsAgggGARQADBIoAAgkUAAQSLAAIIFgEEECwCCCBYBBBAsAgggGARQADBIoAA gkUAAQSLAAIIFgEEECwCCCBYBBBAsAgggGARQADBIoAAgkUAAQSLAAIIFgEEECwC CCBYBBBAsAgggGARQADBIoAAgkUAAQSLAAIIFgEEECwCCCBYBBBAsAgggGARQADB IoAAgkUAAQSLAAIIFgEEECwCCCBYBBBAsAgggGARQADBIoAAgkUAAQSLAAIIFgEE ECwCCCBYBBBAsAgggGARQADBIoAAgkUAAQSLAAIIFgEEECwCCCBYBBBAsAgggGAR QADBIoAAgkUAAQSLAAIIFgEEECwCCCBYBBBAsAgggGARQADBIoAAgkUAAQSLAAII FgEEECwCCCBYBBBAsAgggGARQADBIoAAgkUAAQSLAAIIFgEEECwCCCBYBBBAsAgg gGARQADBIoAAgkUAAQSLAAIIFgEEECwCCCBYBBBAsAgggGARQADBIoAAgkUAAQSL AAIIFgEEECwCCCBYBBBAsAgggGARQADBIoAAgkUAAQSLAAIIFgEEECwCCCBYBBBA sAgggGARQADBIoAAgkUAAQSLAAIIFgEEECwCCCBYBBBAsAgggGARQADBIoAAgkUA AQSLAAIIFgFEWrYsVXKrMluVzPDVlb8u/3Vl/upUFyF4BBCJqFSzWtVKFcuXLVOq QMm6Of3/Tl2ZX2D5ssULF8ydM2tBMgOBPAKIGFXasU7NalXKb1+u3I6x/nEn//jj ksXz5syaNpkYIl4EEMVTYocGdWtVr1KpYqNU/nRjFy6YN3vG1PEzf0vlTwfPEUAU SamGDevVrFqlYlPZglEL582dNWXcuHzZAriPACIXpZs2qLdD9cqV6quHbGDigvmz Z04ZP2qFegjcQwARQamGjXbcoXqVyjZ1b3MT58+bPXPyWL4nRGQEEEYnPLm9ekJO lpz7mnoCHEEAYXTGs+oFOTrzOfUCOIIAwmiPb9QLcrTnUPUCOIIAwqiUa28vlOZV QERDAGG2Rj0gR/xdjYj4WwVmjgVwTQn1AriCAMLMsQAuLadeAFcQQJg5FsAFldUL 4AoCCDPHAji7hnoBXEEAYTattnpBTqbXUS+AKwggzCbY/RG4TU3cWb0AriCAMBuT zlFXcRnbWL0AriCAMPuumXpBTkbuql4AVxBAmI3YTb0gJ9/url4AVxBAmH2zh3pB TobuqV4AVxBAmBFAeIoAwowAwlMEEGYEEJ4igDAjgPAUAYQZAYSnCCDMCCA8RQBh RgDhKQIIMwIITxFAnXLlym23fdkyZf+27bbbrLX1lnlblcjL23LLvLzVq/PyVuXl /fLrqlU/ryr490/Lli/58cdFS37WLCWAkWy7fYVy5bZf+xe04K9mwb+32jovb5v1 f0F/+zVv9S+r1vp57V/QZUuW/vjjj5ql+BMBTM/2tWpUrVKpfNkyZUqXLl23qH+U yfn5K/JXLFu8aP78WbPm/hbjvswIYGFKVK1Zs3LlCuXLli5VulSpHYv6h5m6YsWK 5cuXLV4wb+4PM5bEORBmBDBRJarXqV29apXyFbbfrm5Cf4oxS35cvHDB3NnTpy1K 6M+Ql/e1Wz9TfvP3xP7QFdb+9axUsXy57ZM6cWbq0iWLFs9b+9dzdjr/dAsbAUxA yfo71dqhauUKFRuk/Cces3jxgvmzZ0wevyzeP+7glvH+8RI2pFW8f7yyDXasVb1y pfLl0z5ma/zCRfPnzpwxaeLKlP/E4SCA8anWeMfaNatUrmTD6aHTFhV8V/jDlPHj YvmlE2QASzZsUK9GwXd7FWw4X3rigvnzZk2fPGaOeohvCGCxVWpav+4O1apUrake UrgJCwq+iZg+fmxxfkAOKYAVGjWoXfDteyVLT5WeNXfenJlTJ45aoB7iCQJYVNs2 aLJT7RpVK9dTD4lq2sJ5Bd9ETBw1O/f/1wACWL1p/YJv36tUtOHbvUimzJ/7w/RJ o8eLbgzwBQHM1fbNGu1Uq1rVpuodRVfwTcTsWVPHj4r+PaG/AazQtEHdmtWt/fY9 ilFz58yYNHYk7x8XCQGMqmazhvVqVqtq6U9GRTJ13vwfZk7uP9d4oX8BrHrojjvU qFylbvJjUjNh7pxZU8aNnKXe4RYCaFbx3zWrVa+lXpGYG/5tvMS/AF5/Swo7NGbM njPr+oXqFa4ggGbNh6kXJKpDH+Ml/gWwfe8Udui0GK5e4AoCaLbfZ+oFiTruTeMl /gXw2DdS2KGz/+fqBa4ggGaeB/DQD42X+BfAQ/qnsEOHAEZFAM08D2CEXyz+BZC/ pliHAJrxi4UAOoYARkUAzfjFQgAdQwCjIoBm/GIhgI4hgFERQDN+sRBAxxDAqAig WdsP1AsSRQD9c1g/9QJXEECzw/uqFySKAPqn3fvqBa4ggGaeB7D1YOMl/gWw1aAU dugQwKgIoJnnAYzwsSn/Auj5xxsJYFQE0IwAEkDHEMCoCKAZASSAjiGAURFAMwJI AB1DAKMigGaeB7DJGOMl/gWw8egUdugQwKgIoJnnAWw43niJfwFsMC6FHToEMCoC aOZ5AOtNNV7yxd7Jz4jRl/sYL6k7JYUdOgQwKgJo5nkAa5gfE/fNHinsiM/QPY2X VP8hhR06BDAqAmjmeQCrmx+27V8AqxXh4aAOIYBREUAzzwO43TLjJf4FsOzSFHbo EMCoCKAZASSAjiGAURFAM88DuNVq4yX+BXDLX1PYoUMAoyKAZp4HMMLfAv4FMG9N 8jOECGBUBNCMABJAxxDAqAigGQEkgI4hgFERQDO/A5hf2nzNiN2S3xGjb3c3X0MA sRYBNPM7gD9ub77mu2bJ74jRyF3N1xBArEUAzfwO4KKK5msIoGMIYFQE0OyEV9UL kjS3mvkaAuiYE19TL3AFATQ78RX1giTN2sF8DQF0zEle/zM7TgTQzO8ATq1nvsbD AE6pm/gMIQIYFQE08zuAExqYrxnTKPkdMRrb2HzN+J2T36FDAKMigGZ+B3B0U/M1 HgZwVJPkd+gQwKgIoJnfARzR3HyNhwEcHuFeQXcRwKgIoNlJL6sXJOnrvczXeBjA r/6e/A6dk73+Z3acCKBZ+97qBUkatK/5mrENk98Ro3ERej2wdfI7dDr0US9wBQE0 8zuAnxxkvmbSjsnviNHknczXfHxg8jt0CGBUBNDM7wC+3858jYcB7Ht48jt0CGBU BNDM7wC+eZz5Gg8D+Maxye/QIYBREUAzvwP40qnma6bWSX5HjKbVNV/z4ilJr1Ai gFERQDO/A/h0R/M102slPiNOM2qbr+l1dvI7dAhgVATQzO8APnKx+RoPA/jwRcnv 0CGAURFAM78DeO8V5ms8DOA9lye/Q4cARkUAzfwO4C03mq9x7OiUOdXN19x8Q/I7 dAhgVATQzO8AXn2X+RrHAhjliMOr7kx+hw4BjIoAmvkdwM4Pm69xLIALKpuvufih 5HfoEMCoCKCZ3wE88znzNY4FcHEF8zVnPJv8Dh0CGBUBNPM7gEe/Y77GsQAuKW++ 5qi3k9+hQwCjIoBm5z2uXpCk1oPN1zgWwOVlzde0GpT8Dp3zn1AvcAUBNLvgUfWC JDUdbb7GsQBGedRxk1HJ79C58DH1AlcQQDO/A1htrvkaxwIY5e/qqnOSn6FDAKMi gGZ+B3Cr1eZrPAzglr8mP0OHAEZFAM28DuCaElEuSnxGvKL8Xe3af6acEMCoCKCZ 1wGM8o7ptiuT3xGrkj+bryGAyCOAUXh9z+wPNc3XbL84+R2xKr/EfI3XAYxydzvW IoBml92nXpCgiRGej1v9h+R3xKrGbPM1E+onv0Om6/3qBa4ggGZeB/DbCI+HbDAu +R2xajjefM2I3ZLfIUMAoyKAZl4HcEgr8zW7jUh+R6x2/9Z8zeCWye+QIYBREUAz rwP40SHma/YZkvyOWLX8wnzNhwcnv0OGAEZFAM28DuBbER4O1OaT5HfE6sAB5mve PCbxGToEMCoCaNa1u3pBgp4703zN4X2T3xGrdu+br3n2jOR3yHTz+Z/ZsSKAZv+6 Tb0gQVEeCXLiK8nviNVJr5qv8fqhINferl7gCgJo5nUA77zGfM1ZTye/I1ZnP2O+ 5o6rk98hQwCjIoBmXgcwyon4zt0JHuU+YK/PxCeAURFAM68DGOXkuCvuTn5HrK68 x3yN16c8EsCoCKCZ1w8QO/E18zU33Jz8jljdeIv5mhMivE7orCiP+sNaBNDM6wDu G+FkZOdeLovywmbrgcnvkCGAURFAM68DGOVTYw90SX5HrHpcar7Guc/35YIARkUA zbwO4HbLzNf87/zkd8Tq8X+Yrym7NPkdMgQwKgJodteV6gUJivI3QO/2ic+IV58O ES7y+Tysu69SL3AFATTzOYBRzkPNe/mkxHfE65WTI1xEAEEAo/A5gDNrRbio7+GJ 74jX++0iXEQAQQCjuPsK9YLkjGsU4aJP9098R7w+OyDCRWMbJr5D5h6P/5kdLwJo 9t8I7ym6atgeES76JspFNhm6Z5SLWiS+Q+aBf6oXuIIAmvkcwEjfK41unPiOeI1p EuEi576vzQEBjIoAmvkcwL5HRLhoap3Ed8RrWt0IF70X5YVCRxHAqAig2YOd1QuS 89KpES5y7u2C+VUiXPTiKYnvkHnoEvUCVxBAs8ci3Fbrqp7nRLjIuQDml45w0VOd Et8h878L1AtcQQDNfA5glG8Vtvw1+R0x22q1+Rqfv7EngFERQDPnPgmWgyjHBlSd k/yOmFWba77GuSMechDls4BYiwCa9TpbvSA51//HfE3zYcnviFmL4eZr/u/fye9Q ebqjeoErCKCZzwG8tIf5mqPeTn5HzI5+x3xNlweS36FCAKMigGbOnQWQg069zNdc 8GjiM+J24WPmazr2TH6HSqTTIJBHAKN4/jT1guSc8bz5Ggd/Vozyk/3pzyW/Q+WF 09ULXEEAzXwOYJQHSN7v3l21/73MfI1zD/vMAQGMigCavXa8ekFyojxC3MGXAKL8 COjc495z8PoJ6gWuIIBmPgfwwAHma945MvEZcXv3KPM1bT5JfocKAYyKAJo5GIDI Wn5hvubzfZPfEbOB+5mv2WdI8jtUovwDAGsRQDOfAxjlhrnvmiW/I2YjdzVf4+Dt jZERwKgIoFm/Q9ULkhMlgLNqJL8jZj/UNF/jcwD7t1UvcAUBNAs9gM6dhVAwuYT5 GgIIAhjFgCiHhjoqQgArz0thR9yqzDde4nMAP22jXuAKAmjm89HBEQK432cp7Ijb /p8bL/E5gJEO+kYeAYxicEv1guRECKCTHxmL8BE/nwM4pJV6gSsIoNmXe6kXJKeV +V6QG25OYUfcbrzFeEnLwSnsEPlqb/UCVxBAM+ceipaDw/oZL3HyPNgIJ4K2/SCF HSKRHouHPAIYhYP3wUUW4bPAbxybwo64vXmc8RKfPwsc5T5IrEUAzb5vql6QnAiv lQ1y8fWkwa2Nlzj52mZEo3ZRL3AFATQb21C9IDmdHzZe4txDMdeaVtd4ycUPJb5C Zlwj9QJXEECzSTuqFyTnynuMlzh4H3SkO6GvuDuFHSKTd1IvcAUBNHPyW6CI7r7K dMVOE9PYEbv6k0xX3HVlGjs0ptVVL3AFATRz8lugiJ48z3TFSS+nsSN2Jxvf4nji 3DR2aMzaQb3AFQTQzOcAmg+Ou958R52NbjCe4+/zMY9zq6kXuIIAmvkcwE8OMl3R s2MKM+LXq5Ppio8PTGOHxqKK6gWuIIBmPgdwmPEm7w8PTmNH7D46xHTF0BZp7NBY Xla9wBUE0MznAM6sZbpidOM0dsRuTBPTFTM8fp0synFgWIsAmvkcQPOvFEf/0y/b znSFo//BouHXdUT8F2Xm9a+UGrOzf73BuHR2xK7h+Oxfr/5DOjs0+HUdEf9FGW27 Ur0gSce8nf3r5z6Rzo7Ynfdk9q8f/VY6OzRK/qxe4AgCaFR2qXpBkv7v1uxf73FJ Ojti92CX7F+/7j/p7NDYbpl6gSMIoJHfPyuZHiHu7ANRTI/FcPBx7zkwvbKBPxBA o1rT1QuS9OU+2b8+pW4qM+I3tV72r3/h9ZmhtWeoFziCABo5+zZAJAsrZf3y1qtS 2hG/bX7J+mWv39oyvgWEPxBAo11GqhckKvupAa0GpbUjdq2zHnnv6BkPUTX7Xr3A EQTQyOeH5xTo8mC2rzp8ZlT2k74u6ZHWDokoz3tGHgGMwPMAPn9G1q+eltaO2L1w eravPpf1q84jgBERQCPPAzipfravjjJ+osxao7M+yWCi30eGEsCICKCR32+CZL9j Ystf09sRtzVbr878Rb/vbeJNkMgIoFHtaeoFybr6rsxfa/NJejtid+CAzF+76s7U ZkjU8frerRgRQCPfv1n4MMutzjffkN6O2N1yY+av9TeeluU2boSOiAAalVqhXpCs FRUzf270raNTHBK3t4/J+CW/P99doHS+eoEjCKCZ37fM5uVdkvn5kJMNH6ew2pTM T/PrnPXeHw/w6zoi/osy8z2AmT8N5/g5EJlPBPD7c3AF39WXUS9wBQE08z2AmT8M 0r53qjvi1qFPhi94/jGQvLw51dULXEEAzcY2VC9I2OP/yPCFp4xPFrJaz3MyfOF/ 56e6I33jGqkXuIIAmvn+81LekuoZ3hNw+DbotTLdCl3yp3R3pM90xg/+RADN3jlS vSBpt19b6O92/v3vDO+F3vavlHek7t2j1AtcQQDNHrpYvSBpC2sXWopTX0h7SMxO e7Gw3+t8180e7qxe4AoCaNa1u3pB4p4o9EUx518qK/zFzcfPS3tH6rrdp17gCgJo tt9n6gWJW9O4sA88f7tr6kPi9d1uhfzOhmNT35G6/T9XL3AFATQrkeVD9b74ouXm v8/99wrWlCrk3Z0h/r9BkF/2N/UEVxDACEYU9o2EZwo5EuG05wU74nX65q9i+n4M wlrf7q5e4AwCGMEzhien+WB5881uDn76LMWQWD1z9qa/p/4ExY6U9Xb/r1xaCGAE J7+kXpCCSbtu+k7whKxHpTph4s6b/I5S3/l9EOrvTnlZvcAZBDCCrbI/X8wTX7Te +IUjL44B2+RYqBKD/H8BsOC7+fIOn2ObMgIYxYcHqxekYZO7Z724+2eT+0H8v6d9 rY88P+wwTgQwCscPBYjqrWM3/L+8iMXGUX8z8wmBPsl4CAQ2QwCj2CKQuwo+OWyD H/a9OARnbrX1v731BwfqhqRoTg0v/tKlgwBG0uMS9YJ0fHvwwj9/c68vlUNis/dX f/5WxY8CuJtprQe7qBc4hABGUibj0Zqemdup7x+/df8/pUPi8t/L/viNdu9Jd6Rn Sa3l6gkOIYDRdO+qXpCW3uf8/hbiyF3EQ+LxfbN1/2urpwK4l/N393VTL3AJAYzG /Y+FRTa525sF/7PyPPWOmFSZX/A/ju2e+fkgnplb1/cHPsWKAEYUyBvB63xy6fd5 l9+jXhGTK+7N2+WBMN79WIe3gHNCAKP6oK16QYreufyxNuoNMRlwwb0hnQ7a7zD1 ArcQwKi2G1NDPQEw+KGx2w/ySx0BjKzJKPUCILvle49WT3AMAYyuY0/1AiCrTr3U C1xDAHNw043qBUAWN9+kXuAcApgLCgiL0b/cEcCcXHuregGQwXW3qRc4iADm5qi3 1QuAwiw6+x31BBcRwBzV7tdQPQHYzLi209UTnEQAc7VVz/bqCcAm+nTiEOgiIYC5 O/a/ddQTgA1M++eb6gmuIoBFsPWj56gnAH956sIgHlqTCAJYJE0eaqOeAKwzoDOf /ig6AlhEh9/WXD0ByBt+7fvqCU4jgEV2wo27qicgcN/d/Jp6guMIYDEcfn0r9QQE bPC/+e6vuAhgsTS/+lT1BIRp+bt3Dldv8AABLKYy/zotmNPWYY3JL9zOo4/iQACL 7/ALjzVfBMRl+UeP8rNvTAhgHEp2PqOFegMCMey5h3jsUWwIYExGBPLUbYh9u7t6 gVcIYEwGt1QvQBCGcOdBnAhgTAggUkEAY0UAY0IAkQoCGCsCGBMCiFQQwFgRwJgQ QKSCAMaKAMaEACIVBDBWBDAmBBCpIICxIoAxIYBIBQGMFQGMyef7qhcgCAP3Uy/w CgGMyYAD1AsQhE/bqBd4hQDG5MOD1QsQhI8OUS/wCgGMSb9D1QsQhP5t1Qu8QgBj 8u4R6gUIwntHqhd4hQDG5B3+vkQa3j1KvcArBDAmrx2vXoAgvH6CeoFXCGBMXuXv S6ThtRPVC7xCAGPy/GnqBQjCC6erF3iFAMbk2TPUCxCE585UL/AKAYxJr7PVCxCE pzuqF3iFAMbkiXPVCxCEJ89TL/AKAYzJg53VCxCEhy5RL/AKAYzJXVeqFyAId1+l XuAVAhiTG29SL0AQbrpZvcArBDAmV9ytXoAgXHmPeoFXCGBMLnpYvQBBuPgR9QKv EMCYtO+tXoAgdOijXuAVAhiTY99QL0AQjntTvcArBDAmB36sXoAgHPSJeoFXCGBM 9vhGvQBB2HOoeoFXCGBMdpqoXoAg1J+kXuAVAhiTSvPVCxCEygvUC7xCAGNSYrV6 AYKw5W/qBV4hgHFZox6AECwvq17gFwIYFwKIFMyprl7gFwIYl8n11AsQgCk7qhf4 hQDGZeQu6gUIwPfN1Av8QgDj8sXe6gUIwJf7qBf4hQDG5aOD1AsQgI8PVi/wCwGM y5vHqBcgAG8dq17gFwIYl97t1QsQgD4d1Av8QgDj8vBF6gUIwCMXqxf4hQDG5Y6r 1QsQgDuvUS/wCwGMS7d71QsQgMu7qxf4hQDGhSOhkQIOhI4XAYzLIf3VCxCAQz9U L/ALAYxL49HqBQhAkzHqBX4hgHEpvVy9AAEos0K9wC8EMDYcB4PErSmhXuAZAhgb AojELaisXuAZAhibiTupF8B7k+qrF3iGAMZmWHP1AnhveAv1As8QwNh8ur96Abz3 2QHqBZ4hgLHhOBgkjsNgYkYAY9Ozo3oBvNerk3qBZwhgbO65XL0A3rv3CvUCzxDA 2Fx9h3oBvHfNneoFniGAsenYU70A3uvUS73AMwQwNm0/UC+A9w7rp17gGQIYm4Zj 1QvgvUbj1As8QwBjU4qPqSNppfPVCzxDAOPDh4GRMM5CiBsBjM1+n6kXwHv7f65e 4BkCGBt+BEbi+BE4ZgQwPvwIjITNrqFe4BsCGJ/BLdUL4LkhrdQLfEMA4/P8aeoF 8NwLp6sX+IYAxufmG9QL4LlbblQv8A0BjM8Jr6oXwHMnvqZe4BsCGJ/K89QL4Lkq 89ULfEMAY8TbwEjU/CrqBd4hgDH6ci/1Anjtq73VC7xDAGP0wqnqBfDai9xnEDcC GKMbblYvgNduvEW9wDsEMEacCIhEcRpg7AhgjPg0MBLFJ4FjRwDjNLWOegE8Nq2u eoF/CGCc+h2qXgCP9W+rXuAfAhin/16qXgCPPfBP9QL/EMA4nfGsegE8duZz6gX+ IYBxqrBQvQAeq7hIvcA/BDBWU+qqF8BbU+upF3iIAMbqraPVC+Ctt49RL/AQAYwV nwVBYvgcSAIIYKxaDlYvgLdaDVEv8BABjNUWv6kXwFdLKnDcWvwIYLw+aaNeAE8N OFC9wEcEMF63XqteAE/ddp16gY8IYLz2+Ea9AJ7ac6h6gY8IYMx4nQaJ4Dj8RBDA mPU9XL0AXnq/nXqBlwhgzC6/R70AXrriXvUCLxHAmPFxYCSCDwInggDGbWgL9QJ4 aNge6gV+IoBxu+V69QJ46N83qBf4iQDGre4U9QJ4qN5U9QI/EcDYjWmkXgDvjG2s XuApAhi7O65WL4B37rxGvcBTBDB21WarF8A71eeoF3iKAMZvYGv1Anhm0L7qBb4i gPHr2FO9AJ7p1Eu9wFcEMH4lVqsXwC/zq3HOZEIIYAJ6na1eAK883VG9wFsEMAFN RqkXwCtNR6sXeIsAJmFQK/UCeGQw76olhgAm4dg31AvgkePeVC/wFwFMxKgm6gXw xuim6gUeI4CJOOtp9QJ44+xn1As8RgCTMa6BegE8Mb6heoHPCGAyuBkaMeEm6CQR wIR810y9AF4Yuat6gdcIYEKOelu9AF44+h31Aq8RwKR8tp96ATzw+f7qBX4jgElp ME69AO5b02i8eoLfCGBinjxHvQDOe+pc9QLPEcDEbD2hjnoCHDdt51/UEzxHAJNz JC9fo3iOele9wHcEMEFvHKteAKe9eZx6gfcIYIJKjuWHYBTdtEYr1RO8RwCT1OYT 9QI47MAB6gX+I4CJeqCLegGc1eNS9YIAEMBkfc7jvFA0A7mTPgUEMFllR9VST4CT ZjRdpp4QAgKYsKbfqxfARcv34cEyaSCASWvfW70ADurQR70gDAQwcXdcrV4A59x5 jXpBIAhg8nq3Vy+AY/p0UC8IBQFMAZ8IQU74BEhqCGAKtvjgUPUEOKT/YWvUE4JB ANNQom9b9QQ4o1+739QTwkEAU7HFO0eoJ8AR7x3F93/pIYApeeVE9QI44dWT1AuC QgDT0uMS9QI44EE+PZ4qApiaf92mXgDrXXu7ekFgCGB6jn5LvQB2W9SRh6mmjACm qObHDdQTYLHxB81STwgOAUzTtm9xOwwy6XfMz+oJ4SGA6ereVb0Alrqvm3pBiAhg uvb4Rr0AltpzqHpBiAhgunhKCDLgCSAKBDBdR/E2Hwp3NI+RFiCA6TrtefUCWOr0 F9QLQkQA03Xe4+oFsNT5T6gXhIgApuuCR9ULYKkLH1MvCBEBTBcBRAYEUIEAposA IgMCqEAA00UAkQEBVCCA6brsPvUCWKrr/eoFISKA6SKAyIAAKhDAdHV5QL0Alrq0 h3pBiAhgus7lZi8U7rwn1QtCRADTxSdBkAGfBFEggOnis8DIgM8CKxDAdHEaDDLg NBgFApguzgNEBpwHqEAA09VgnHoBLNVwvHpBiAhguirPUy+AparMVy8IEQFM2Rr1 AFiKX4oK/LeeMgKIQi0pr14QJAKYsmm11Qtgpel11AuCRABTNmI39QJY6dvd1QuC RABT9tFB6gWw0scHqxcEiQCm7IVT1QtgpRdPUy8IEgFMWfeu6gWw0n3d1AuCRABT dvFD6gWwUueH1QuCRABT1nqgegGstO8g9YIgEcCUlV6uXgArlVmhXhAkApg27oRG IeZVVS8IEwFM2+CW6gWw0JBW6gVhIoBp691evQAW6tNBvSBMBDBt/7pNvQAWuvZ2 9YIwEcC0tRysXgALtRqiXhAmApi2LX5TL4B9lm/Hm2MSBDB1Q1uoF8A6w/ZQLwgU AUxdz47qBbBOr07qBYEigKk7/Tn1AljnDJ4XrUEAU1fyJ/UC2GZNqZXqCYEigOnj TFRsgtNQVQhg+u7l4CNsrPvl6gWhIoDpaz5MvQCWaTFcvSBUBFBgKs+/wYam1VUv CBYBFOBGGGyEm2BkCKBAK86+xIZa8/FIFQKoMHEn9QJYZFJ99YJwEUCFe3jTD+vd e4V6QbgIoEKt6eoFsEjtGeoF4SKAEp+0US+ANQYcqF4QMAIo0e499QJY44i+6gUB I4Aa43dWL4AlJjRQLwgZAdTo/KB6ASxxyUPqBSEjgBpbTOHTIFhrWj3OghYigCLd 7lUvgBUu765eEDQCKFJiMt8CouAbwB15RowSAVTp2FO9ABbo1Eu9IGwEUIaHI4GH IakRQJkDBqgXQK7Np+oFgSOAOq+cqF4AsVdPUi8IHQHUKbVCvQBas+vnqyeEjgAK te+tXgCpDn3UC4JHAJXePUK9AELvHaleAAKoVHJcbfUEyExvyMOA5QigFO8EB4x3 gC1AALU4GzpYnANtAwIo1vdw9QJIvN9OvQB5BFBu6+FN1RMgMKr5L+oJyCOAepXn qRcgfXN2na+egLUIoNzO49ULkLbFe09QT8A6BFBvz6/VC5CuFW2+UU/A7wigBU5+ Sb0AqTrlZfUC/IEA2uDsXuoFSM+aTk+rJ+BPBNAKJ/EtQTDyz35FPQF/IYB22Pdz 9QKkY3m7geoJWI8AWqLp9+oFSMOcQ0apJ2ADBNAWVT9tqJ6AxI07YK56AjZEAK1R st9+6glI2OdtOQDGLgTQIg90US9Aonpcql6ATRBAmxz9lnoBkjP/3LfVE7ApAmiV Su/srZ6AhHx51AL1BGyGAFrmuv+oFyAJK26/VT0BhSCAtqnzdjP1BMRu5NHT1BNQ GAJonS2uv1k9AfFaeu+/16g3oFAE0EKVnjtUPQEx6n8Gr/7ZigBa6YQ7dlZPQEwm XPOaegIyIoB22qLbPeoJiMOce7rz06/FCKCttrmNB8Y5b8mT165Sb0A2BNBepW/9 p3oCimNR7+tWqDcgOwJos1I3XamegKJa0POmfPUGmBBAu23d9fz66g0ogomP38dz Lx1AAK133JWt1BOQo8F3v6GegEgIoAMadLtAPQHRzXmzO086dQUBdMIWZ17YWr0B kQx69Fnue3EHAXRF1YtO4EPCthv52iOc+OwUAuiQnS86ig+I2GvCO49MUG9Ajgig Wxqcc7V6Agqz6PGneOHPQQTQNcOaqxegEMNbqBegKAiga6bVVi9AIabXUS9AURBA 1/AWo5XyS6sXoCgIoGMqLFQvQKEqLlIvQBEQQMe0HKxegEK1GqJegCIggI5p31u9 AIXq0Ee9AEVAAB3DU+Ms9X889c1FBNAxD12sXoBCPdxZvQBFQAAd8+oJ6gUo1Gsn qhegCAigYz7dX70AhfrsAPUCFAEBdMyoJuoFKNTopuoFKAIC6Bjug7bU/CrqBSgC AuiWEqvVC5DBlr+pFyB3BNAtdaeoFyCDelPVC5A7AuiWth+oFyCDw/qpFyB3BNAt Fz+kXoAMOj+sXoDcEUC33MF5qLa68xr1AuSOALqld3v1AmTQp4N6AXJHAN3S71D1 AmTQv616AXJHAN3CgfjW4lB8FxFAt8yqoV6ADH6oqV6A3BFAt/BBEGutKaFegNwR QKfUnKlegIx2mKVegJwRQKcc9JF6ATI6+GP1AuSMADrlgkfVC5DRhY+pFyBnBNAp t16rXoCMbrtOvQA5I4BOefos9QJk9MzZ6gXIGQF0St/D1QuQ0fvt1AuQMwLolKHc bGuvYXuoFyBnBNApM7nZ1l6zdlAvQM4IoFO4D9pi3AntIALokqpz1AuQRbW56gXI FQF0SZtP1AuQxYED1AuQKwLoknOfUC9AFuc9qV6AXBFAl3AftNW4E9o9BNAl3Adt Ne6Edg8BdAnnQVuNM6HdQwBdMmI39QJk8e3u6gXIFQF0CbcBWm1uNfUC5IoAOmTL X9ULkNVWq9ULkCMC6JAG49QLkFXD8eoFyBEBdMhxr6sXIKvj31AvQI4IoEOuulO9 AFldfZd6AXJEAB3yYGf1AmT10CXqBcgRAXTI68epFyCrN45XL0COCKBDBrdUL0BW Q1qpFyBHBNAhE+qrFyCriTurFyBHBNAh3AdtuWXbqRcgRwTQHRUWqhfAoOIi9QLk hgC644AB6gUwaPOpegFyQwDdcf7/1Atg8I/H1QuQGwLojtv+pV4Ag9s5sdYxBNAd vdurF8CgTwf1AuSGALqj/yHqBTD4kBNrHUMA3fFdM/UCGIzcVb0AuSGA7uA2QOst rKRegNwQQGeU/Em9AEZ/W6legJwQQGfs9aV6AYz2/kq9ADkhgM44h8du2+/cp9QL kBMC6AxuA3QANwI6hgA649kz1Atg9NyZ6gXICQF0xidt1AtgNOBA9QLkhAA6Y0wj 9QIYjW2sXoCcEEBncBugA5aUVy9ATgigK7ZfrF6ACMovUS9ALgigKzgN0AmcCOgW AuiKix5WL0AEFz+iXoBcEEBX3HO5egEiuPcK9QLkggC64qWT1QsQwcunqBcgFwTQ FQNbqxcggkH7qhcgFwTQFTwU2Ak8GtgtBNAV3AbohOVl1QuQCwLoiGqz1QsQSfU5 6gXIAQF0xOF91QsQSbv31QuQAwLoiK7d1QsQSbf71AuQAwLoiIcvUi9AJI9crF6A HBBAR7xzpHoBInn3KPUC5IAAOmL47uoFiGREc/UC5IAAOoK7YBwxv4p6AXJAAN1Q aoV6ASIqna9egOgIoBtaD1QvQET7DlIvQHQE0A0chuUMDsRyCQF0w/3/VC9ARP+9 TL0A0RFAN7x+nHoBInrjePUCREcA3fDV39ULENHXe6kXIDoC6AbugnHG7BrqBYiO ADph61XqBYhsm1/UCxAZAXRC82HqBYisxXD1AkRGAJ3Qsad6ASLr1Eu9AJERQCfc cbV6ASK78xr1AkRGAJ3wIs8ac8dLp6oXIDIC6IRBrdQLENlgnt/nDgLohOm11AsQ 2Yza6gWIjAC6oMRq9QLkYMvf1AsQFQF0QePR6gXIQZMx6gWIigC6oH1v9QLkoEMf 9QJERQBdwF0wTuE+GHcQQBe8cqJ6AXLw6knqBYiKALrgSw4YcclXe6sXICoC6ALO gnHK3GrqBYiKADqAJyI5huciOYMAOuCAAeoFyEmbT9ULEBEBdMBl96kXICdd71cv QEQE0AGPXqBegJw8dqF6ASIigA54/zD1AuTkg8PVCxARAXTAqCbqBcjJ6KbqBYiI ADqAu2Acs7ScegEiIoD2qzVdvQA5qj1DvQDREED7nfiKegFydNKr6gWIhgDa76Yb 1QuQo5tvUi9ANATQfs+eoV6AHD13pnoBoiGA9hvIMyZcM2hf9QJEQwDtN2MH9QLk aCbPcHEEAbTe1qvUC5CzbX5RL0AkBNB6e32pXoCc7f2VegEiIYDWu6SHegFy1uVB 9QJEQgCtx1EIDuI4BEcQQOv1P0S9ADn78FD1AkRCAK03uZ56AXI2ZUf1AkRCAG1X YrV6AXK3Zqvf1BMQBQG0XfNh6gUoghbD1QsQBQG03UUPqxegCC5+RL0AURBA2z10 sXoBiuDhzuoFiIIA2u6DtuoFKIJ+PMbACQTQdhN3Ui9AEUyqr16AKAig5XgT2E28 DewGAmi5Zt+pF6BIdh2pXoAICKDlzv+fegGK5B+PqxcgAgJouQe6qBegSHpcql6A CAig5fryjG03vd9OvQAREEDLjW6sXoAiGcPT7F1AAC3HQ9EdlV9avQAREEC7NR6t XoAiajJGvQBmBNBu5zypXoAiOvcp9QKYEUC78Saws3gb2AUE0G58EthZfBrYBQTQ blPqqhegiKZykrcDCKDVeCaww3g2sAMIoNX2+0y9AEW2/+fqBTAigFa76k71AhTZ 1XepF8CIAFqtd3v1AhRZnw7qBTAigFYbso96AYrsi5bqBTAigFbjg3AOm19FvQBG BNBmVeeoF6AYqs1VL4AJAbTZqS+oF6AYTntRvQAmBNBmd12pXoBiuPsq9QKYEECb vXW0egGK4e1j1AtgQgBt9n1T9QIUw6hd1AtgQgAttgVPVnRafhnexbcdAbRY82Hq BSiWFsPVC2BAAC12SQ/1AhRLlwfVC2BAAC32xLnqBSiWJ89TL4ABAbTYp/urF6BY PjtAvQAGBNBis2qoF6BYfqipXgADAmivCgvVC1BMFRepFyA7Amivk19SL0AxnfKy egGyI4D2uudy9QIU071XqBcgOwJor/d5rJjrPjhcvQDZEUB7Ta2jXoBimlZXvQDZ EUBrlVqhXoBiK52vXoCsCKC12r2nXoBiO6KvegGyIoDWuvVa9QIU223XqRcgKwJo rTc5Tc59bx2rXoCsCKC1JtRXL0CxTdxZvQBZEUBbbb1KvQAx2OYX9QJkQwBtdcAA 9QLEoM2n6gXIhgDa6rr/qBcgBv93q3oBsiGAtnrpZPUCxODlU9QLkA0BtNWI3dQL EINvd1cvQDYE0FI8EMkPK8ryYCSbEUBL7fGNegFisedQ9QJkQQAt1e1e9QLE4vLu 6gXIggBaqnd79QLEok8H9QJkQQAt9c0e6gWIxdA91QuQBQG0E++B+GL5drwLYjEC aKd9hqgXICYtv1AvQGYE0E7X8gECX1x3m3oBMiOAdnr1BPUCxOS1E9ULkBkBtNN4 jlHyxYQG6gXIjABaqeRP6gWIzd9WqhcgIwJoJZ4H4hGeC2IxAmilO65WL0Bs7rxG vQAZEUAr8Ux0j/B0dIsRQCtNr6VegNjMqK1egIwIoI0qzVcvQIwqL1AvQCYE0Ebt e6sXIEYd+qgXIBMCaKOHL1IvQIweuVi9AJkQQBt9tp96AWL0+f7qBciEANqI80O8 sqCyegEyIYAW2nm8egFi1WCCegEyIIAW6vygegFidclD6gXIgABa6BlOUfdL77PU C5ABAbTQ0BbqBYjVMJ5vYCsCaJ8Sq9ULEK/8sjzhwFIE0D4HfaRegJgd/LF6AQpH AO3DUTDe4UAYWxFA+/Q7VL0AMevfVr0AhSOA9uE2aO/Mqa5egMIRQOvUm6xegNjt OEW9AIUigNbp8oB6AWJ3aQ/1AhSKAFrnhVPVCxC7F09TL0ChCKB1xjZUL0DsxjVS L0ChCKBtSq1QL0ACSuerF6AwBNA2J7yqXoAEnPiaegEKQwBt80AX9QIkoMel6gUo DAG0zef7qhcgAQM55NtKBNA23AbtpcUV1AtQGAJomebD1AuQiBbD1QtQCAJomWtv VS9AIq67Tb0AhSCAlnnjWPUCJOLN49QLUAgCaJkpddULkIip9dQLUAgCaJdK89UL kJDKC9QLsDkCaJeOPdULkJBOvdQLsDkCaJeneX6Yr545W70AmyOAdhnVRL0ACRnd VL0AmyOAVuEkBI9xHoKFCKBVTn1BvQCJOe1F9QJshgBa5bF/qBcgMf+7QL0AmyGA Vvl6T/UCJOabv6sXYDME0CZb/aJegOTkl/tVPQGbIoA2OfId9QIk6Kh31QuwKQJo k/9yaqbPHvinegE2RQBtMrilegESNKSVegE2RQAtUmK1egGStLzcb+oJ2AQBtMjh fdULkKh276sXYBME0CK8BOg5XgS0DgG0CC8Beo4XAa1DAO3BS4C+40VA6xBAe7R7 T70ACTuCV3ktQwDt0eMS9QIk7EGeem8ZAmiPIfuoFyBhX/Aqr2UIoDX4ILD/+Diw bQigNY5+S70AiTvmbfUCbIQAWuORC9ULkLhHL1IvwEYIoDW+a6ZegMSN3FW9ABsh gLbgcSBB4MEgdiGAtjj9OfUCpOCM59ULsCECaIueHdULkIJendQLsCECaIuxDdUL kIJxjdQLsCECaIntF6sXIBXll6gXYAME0BLnPa5egFSc/4R6ATZAAC3x/GnqBUjF C6erF2ADBNASU+qqFyAVU+upF2ADBNAOtaepFyAldaarF2A9AmiHq+5UL0BKrr5L vQDrEUA7vNdOvQAp6XuEegHWI4B2WKMegLTMr6JegPUIoBX2GaJegNS0/EK9AH8h gFa4+wr1AqTmnivVC/AXAmiFga3VC5CaQfuqF+AvBNAGnIYfEs7FtwgBtMGJr6gX IEUnvapegD8RQBv0Olu9ACl6uqN6Af5EAG0wob56AVI0cWf1AvyJAFqgFh+OCkvt GeoF+AMBtMDVd6gXIFXX8MFHWxBAC/Q7VL0AqerfVr0AfyCAelv8pl6AdC2uyEcf LUEA9Q57X70AKTv8A/UC/I4A6j1yoXoBUvboReoF+B0B1BvVRL0AKRvdVL0AvyOA cpXmqxcgdZUXqBdgHQIo1+UB9QKk7tIe6gVYhwDKvXW0egFS9/Yx6gVYhwDKcUdE gOZVVS/AOgRQreVg9QIItOIMcCsQQLXuXdULIHBfN/UCrEUA1Ybvrl4AgRHN1Quw FgEUK7tUvQAS2y1TL0AeAZQ79wn1Akic96R6AfIIoNxLJ6sXQOLlU9QLkEcA5WbV UC+AxA811QuQRwDV9vxavQAif/9GvQAEUI2bYILFjTA2IIBa3zVTL4DIyF3VC0AA xTgJJmCcCGMBAih12X3qBZDper96AQigVt/D1Qsg83479QIQQCkehxSyJRU4CEiO ACod9bZ6AYSOfke9AARQ6alO6gUQ6nmOegEIoNKkHdULIDR5J/UCEEChncerF0Cq wQT1guARQKFbrlcvgNS/b1AvCB4BFPrq7+oFkPp6L/WC4BFAnVIr1AugtaZMvnpC 6AigzjkciRm6c59SLwgdAdR59QT1Aoi9dqJ6QegIoA6fAwjenOrqBaEjgDKtB6oX QG7fQeoFgSOAMj0uUS+A3INd1AsCRwBlxjZUL4DcuEbqBYEjgCq1p6kXwAJ1pqsX hI0Aqtx4k3oBLHDTzeoFYSOAKnwMBHl8GESNAIqUXapeABusKbdMPSFoBFDkoofV C2CFix9RLwgaARR59wj1AljhvSPVC4JGADVKrFYvgB2WVOTBMEIEUOOEV9ULYIkT X1MvCBkB1Hj2DPUCWOK5M9ULQkYANWbsoF4AS8yspV4QMgIosdeX6gWwxt5fqRcE jABKPMBn4PGnHpeqFwSMAEqMbqxeAGuMaaJeEDACqFCLT8Bjvdoz1AvCRQAVbuAT 8FjvxlvUC8JFABU4CAEb4EAEHQIowEEI2BAHIugQQIEL+fw7NnTRo+oFwSKAAhyE gI1wIIIMAUwfByFgYxyIIEMA03fqC+oFsMxpL6oXhIoApu/FU9QLYJmXTlUvCBUB TN8a9QDYZm419YJQEcDUtf1AvQDWOayfekGgCGDqnuqkXgDr9DxHvSBQBDB1U+uo F8A60+qqFwSKAKZtj2/UC2ChPYeqF4SJAKaNowBRCA4F1CCAaRvbUL0AFhrXSL0g TAQwZTtNVC+AlepPUi8IEgFM2a3XqhfASrddp14QJAKYshG7qRfASt/url4QJAKY rsrz1AtgqSrz1QtCRADTdfUd6gWw1DV3qheEiACma3BL9QJYakgr9YIQEcBUlV6u XgBbrSm7Qj0hQAQwVRc9rF4Aa13MkxLSRwBT9V479QJYqy9PSkgfAUzTVr+oF8Be Syv+qp4QHgKYpva91QtgsQ591AvCQwDT9Ppx6gWw2BvHqxeEhwCmaAue/YUsFlXi aQlpI4ApOvEV9QJY7aRX1QuCQwBTxOPgkBUPh0sdAUwRP+Agq3lV1QuCQwDT0+49 9QJY7oi+6gWhIYDp6d1evQCW69NBvSA0BDA9s2qoF8ByP9RULwgNAUzNAQPUC2C9 Np+qFwSGAKbmiXPVC2C9J89TLwgMAUwND0SH0bS66gWBIYBp2fNr9QI44O/fqBeE hQCm5aGL1QvggIc7qxeEhQCmZUJ99QI4YOLO6gVhIYApaTJKvQBOaDpavSAoBDAl 3buqF8AJ93VTLwgKAUzJ6MbqBXDCmCbqBUEhgOnYaaJ6ARxRf5J6QUgIYDruuFq9 AI648xr1gpAQwHR831S9AI4YtYt6QUgIYCpqT1MvgDPqTFcvCAgBTMWt16oXwBm3 XadeEBACmIoRu6kXwBnf7q5eEBACmIaaM9UL4JAdZqkXhIMApuGmG9UL4JCbb1Iv CAcBTMOw5uoFcMjwFuoF4SCAKag6R70ATqk2V70gGAQwBdffol4Ap9zwb/WCYBDA FHyzh3oBnDJ0T/WCYBDA5FWep14Ax1SZr14QCgKYvH/dpl4Ax1x7u3pBKAhg8r7c S70Ajvlqb/WCUBDAxFVYqF4A51RcpF4QCAKYuCvuVi+Ac668R70gEAQwcV/w4wxy 9eU+6gWBIIBJK7dEvQDuWVP+R/WEMBDApHXtrl4AB3W7T70gDAQwaYNaqRfAQYNb qxeEgQAmrOxS9QK4aE25ZeoJQSCACevygHoBnHRpD/WCIBDAhH10kHoBnPTxweoF QSCAySr5k3oB3JRfcaV6QggIYLI6P6heAEdd8pB6QQgIYLL6H6JeAEd9eKh6QQgI YKK25ccYFFF+hZ/VEwJAABN1Gbezoqi63q9eEAACGL9qu+9S61L1CPhi4bMzvh/B U2USQgBjVLL5Hk12rNVEPQMeGj1j8uihw3lFJW4EMB6NWzdv2KCWegU8N2P8uOGD xqhX+IQAFlu5Q9vszgc3kZolo0YM6M9hMfEggMVS4phj9t1ZPQIBmjDwrbd+U4/w AAEsurpnHnygegPCtXToR89OVY9wHQEsom3+cdbf1RsQvK+f+d8q9QanEcAiObrT 8eoJwFo/ftzzbfUGhxHA3JW49KIG6g3AX8Y/8gAvBxYRAczZVV12UE8ANjKzx13q CY4igDm64F911BOAzUy7/TH1BCcRwJw0fXoP9QSgUEPPHqWe4CACmIsHO6sXAJnk 97xEPcE9BDC6Rq83Uk8Ashh7/Fj1BNcQwMgueFS9AMhu0bW8EpgbAhhVz47qBYDJ mqc7qSe4hQBGU6of5x3ABYPa5qsnuIQARlL1c448gBsm7DdXPcEhBDCKqgPrqycA EU3clwJGRgAjqDpoJ/UEILJJrSlgVATQjP7BLRQwMgJoVHoEP//CLRN3X6Ge4AgC aNLs5YbqCUCOxp08Uj3BDQTQZCqHH8A90+qqF7iBABq8xsmncNHrJ6gXOIEAZndo P/UCoCiWn9BfPcEFBDCrrX5RLwCKZk6tX9UTHEAAs/qgrXoBUET9DlMvcAABzObI d9QLgKJaceq76gn2I4BZlOJmKjhs7o6ci2BCALN49wj1AqAY3jtSvcB6BDCz3Yer FwDFsWz/EeoJtiOAmY3lIyBw2zge4mBAADO6/B71AqB41lx5r3qC5QhgRmvUA4Di mltNvcByBDCT505XLwCK7fkz1AvsRgAz2OZn9QKg+JZUXaWeYDUCmMHHB6oXADH4 5CD1AqsRwMLtPF69AIjD0j0nqCfYjAAW7vum6gVALEbtol5gMwJYqHbvqRcA8cg/ qa96gsUIYKG4Bxre4G7oLAhgYY59Q70AiEv+GW+qJ9iLABbmu2bqBUBsRu6qXmAv AliI1gPVC4D45LcdpJ5gLQJYiHc4RQg+efco9QJrEcDNcQ4q/LKkJiejZkAAN3fD zeoFQJzW3HSLeoKtCODmOAYGnllaTr3AVgRwMz0uUS8AYvZgF/UCSxHAzXzLTQPw zXe7qRdYigBuhp+A4Z2FldQLLEUAN0MA4R1eBMyAAG7q6bPUC4DYPXO2eoGdCOCm OAgLHuJQrMIRwE3xEzA8xIuAhSOAmyKA8NCy7dQL7EQAN9G9q3oBkID7uqkXWIkA bmJwS/UCIAFDWqkXWIkAboKfgOGlH2qqF1iJAG6CAMJLP26vXmAlArixkj+pFwBJ WF55pXqCjQjgxnp2VC8AEtGrk3qBjQjgxjgJAZ7iPITCEMCN8RIgPDWvqnqBjQjg xgggPMW7IIUhgBsjgPDU8rLqBTYigBt59AL1AiAhj12oXmAhAriRYc3VC4CEDG+h XmAhArgRfgKGt+ZUVy+wEAHcCAGEtzgVuhAEcCMEEN7iXZBCEMANXfcf9QIgMf93 q3qBfQjghvoerl4AJOb9duoF9iGAGxrTSL0ASMzYxuoF9iGAG+IlQHhsfhX1AvsQ wA0RQHiM54JsjgBuoOZM9QIgOfkNZqknWIcAbuApTkyDz3qeo15gHQK4gSH7qBcA CfqCJ35tigBuYFpt9QIgQdPrqBdYhwBugPdA4LXFFdQLrEMA1yu9XL0ASFJ+lRXq CbYhgOud8Kp6AZCkNSe9pp5gGwK43hvHqhcAiXrzOPUC2xDA9b5rpl4AJGokDz3c BAFcj/dA4DnORN0UAVyPZwLDczwbeFMEcD2+A4TnZtdQL7ANAVyPAMJzHIewKQK4 HgGE5zgVf1ME8C/d7lUvABJ2eXf1AssQwL/wUHR4j4ejb4IA/oUHgsB7PBZkEwTw LyN3US8AEvY9N/tvjAD+hfdA4L2FldQLLEMA/0IA4T3eBt4EAfwLAYT3VpRRL7AM AfzTZfepFwCJ63q/eoFdCOCfHuiiXgAkrsel6gV2IYB/ep2j0uC/N45XL7ALAfzT l3upFwCJ+2pv9QK7EMA/TeWJWfDftLrqBXYhgH/iTWAEYGk59QK7EMA/EUAEgPtg NkYA/3D6c+oFQPLWnPm8eoJVCOAfbrxJvQBIwU03qxdYhQD+4alO6gVACnqeo15g FQL4Bw7DQhA4EGsjBPAPw5qrFwApGN5CvcAqBPAPvAmMIPBguI0QwD8QQASBA7E2 QgD/QAARhPzS6gVWIYC/O/UF9QIgFae9qF5gEwL4u+v+o14ApOL/blUvsAkB/N3/ zlcvAFLx+D/UC2xCAH/34cHqBUAqPjpEvcAmBPB3o5qoFwCpGN1UvcAmBPB3vAmM QMyrql5gEwL4OwKIQHAj4IYI4O8IIAJBADdEAH9HABEI7oTeEAFcp2t39QIgJd14 AvZ6BHCdnh3VC4CU9OLoy/UI4DoDDlAvAFLyaRv1AosQwHXGNFIvAFIytrF6gUUI 4Dq8B4JgzKmuXmARArgOAUQweDTwBgjgOgQQweDRwBsggOsQQASDO6E3QADXIYAI BndCb4AArnXOk+oFQGrOfUq9wB4EcK27rlQvAFJz91XqBfYggGu9dLJ6AZCal09R L7AHAVxryD7qBUBqvmipXmAPArjWtNrqBUBqptdRL7AHAVyLN4EREO6DWY8ArkUA ERDug1mPABa44FH1AiBFFz6mXmANAljg3m7qBUCKul+uXmANArjWjQ1r1eKFYYRg 2owZ425Wj7AHAVzv9F12qlV7B/UKIBEzp8+Y9P3z6hW2IYCbOb3ZjjvUrqVeAcRk xvSZk0dSvsIRwExOa1Zvh9r8XAx3TZs+c8rIF9Qr7EYATa5qWrMGZ4jDJWN+mDXq LvUINxDAiC7cpXaNPdQjgKyG/jD9e+7pygUBzM1JzerUqL6LegWwke9n/zBt5Cvq FS4igEVzerM61avxkzG0xsyZPY33N4qDABbPybvuUL1Kc/UKBGb4vNkzv3tZvcIH BDAmZ+1WvWoVfjZGkr6fN3f2t8+oV3iFAMbtrN2qVa5UpaZ6Brwxa96C+XPoXjII YGKO3L1q1UoVy3PUIIpi+uKFC+bOHfGueofnCGAK2u5atVqlCuV3Vu+A9SYsXrRg ztzv+ql3BIMApuuwFhUrV9x++6bqHbDIqCVLFs5fOOwD9Y4QEUCdQ/Yo+Al5+3Lb 7aQegtRNWvrjkoKfcYd+qB4SOgJoiYP2KV++/HZly5blGAY/zVi2bNnSxYsXf/Gx egk2QACt1Hqf7cqXK8hhmdIcx+CqaSuWFyTvx8VLvxiknoKMCKATWu+73drvDkuV LvU3vkO004yf8lfkr/0ub+lAgucOAuiovQ4sVaZc6YIgFuC7xLRN+6lA/ooVPy7P /+Qr9RgUAwH0SLNDS5YpU6bk30r+bduSJUvWVc/xwtSVK1f+/NPKn1YuX758Zf+R 6jmIGQEMQIOjtl73neK2JbfZtsA22/Bj9MZmrFr1c4FVBalb+53dL++MVy9CSghg 4Goeu2VBGktuU3LrgjJuvU3Bv7beemvfAjnjl19+WfXLqoJ//fzzLytXrSyo3Oo3 Z6lXwQIEEECwCCCAYBFAAMEigACCRQABBIsAAggWAQQQLAIIIFgEEECwCCCAYBFA AMEigACCRQABBIsAAggWAQQQLAIIIFgEEECwCCCAYBFAAMEigACCRQABBIsAAggW AQQQLAIIIFgEEECwCCCAYBFAAMEigACCRQABBIsAAggWAQQQLAIIIFgEEECwCCCA YBFAAMEigACCRQABBIsAAggWAQQQLAIIIFgEEECwCCCAYBFAAMEigACCRQABBIsA AggWAQQQLAIIIFgEEECwCCCAYBFAAMEigACCRQABBIsAAggWAQQQLAIIIFgEEECw CCCAYBFAAMEigACCRQABBIsAAggWAQQQLAIIIFgEEECwCCCAYBFAAMEigACCRQAB BIsAAggWAQQQLAIIIFgEEECwCCCAYBFAAMEigACCRQABBIsAAggWAQQQLAIIIFgE EECwCCCAYBFAAMEigACCRQABBIsAAggWAQQQLAIIIFgEEECwCCCAYBFAAMEigACC RQABBIsAAggWAQQQLAIIIFgEEECwCCCAYBFAAMEigACCRQABBIsAAggWAQQQLAII IFgEEECwCCCAYBFAAMEigACCRQABBIsAAggWAQQQLAIIIFgEEECwCCCAYBFAAMEi gACCRQABBIsAAggWAQQQLAIIIFgEEECwCCCAYBFAAMEigACCRQABBIsAAggWAQQQ LAIIIFj/D6xRPrWuQLCxAAAAAElFTkSuQmCC"/></symbol><g mask="url(#b)"><g transform="rotate(.193) scale(.36014)"><symbol id="c" viewBox="0 0 1280 1280"><image width="1280" height="1280" xlink:href="data:image/png;base64, iVBORw0KGgoAAAANSUhEUgAABQAAAAUACAIAAACXhmigAAAACXBIWXMAAA7EAAAO xAGVKw4bAAEYb0lEQVR4nOzdCXxU9bnwcRIIS9ZJJisEEtQu96pordWPrdX2dtO2 Xvtau17bvq+1drO91harVq0IooJQrawCCgiiouACCCggSIBAWBIggQBJZjLZk1my J5OZef9hFBEQkjDPOTPn/L6tiKjPOcjh5PzmbFGDAAAAAAAwgSi9VwAAAAAAAC0Q wAAAAAAAUyCAAQAAAACmQAADAAAAAEyBAAYAAAAAmAIBDAAAAAAwBQIYAAAAAGAK BDAAAAAAwBQIYAAAAACAKRDAAAAAAABTIIABAAAAAKZAAAMAAAAATIEABgAAAACY AgEMAAAAADAFAhgAAAAAYAoEMAAAAADAFAhgAAAAAIApEMAAAAAAAFMggAEAAAAA pkAAAwAAAABMgQAGAAAAAJgCAQwAAAAAMAUCGAAAAABgCgQwAAAAAMAUCGAAAAAA gCkQwAAAAAAAUyCAAQAAAACmQAADAAAAAEyBAAYAAAAAmAIBDAAAAAAwBQIYAAAA AGAKBDAAAAAAwBQIYAAAAACAKRDAAAAAAABTIIABAAAAAKZAAAMAAAAATIEABgAA AACYAgEMAAAAADAFAhgAAAAAYAoEMAAAAADAFAhgAAAAAIApEMAAAAAAAFMggAEA AAAApkAAAwAAAABMgQAGAAAAAJgCAQwAAAAAMAUCGAAAAABgCgQwAAAAAMAUCGAA AAAAgCkQwAAAAAAAUyCAAQAAAACmQAADAAAAAEyBAAYAAAAAmAIBDAAAAAAwBQIY AAAAAGAKBDAAAAAAwBQIYAAAAACAKRDAAAAAAABTIIABAAAAAKZAAAMAAAAATIEA BgAAAACYAgEMAAAAADAFAhgAAAAAYAoEMAAAAADAFAhgAAAAAIApEMAAAAAAAFMg gAEAAAAApkAAAwAAAABMgQAGAAAAAJgCAQwAAAAAMAUCGAAAAABgCgQwAAAAAMAU CGAAAAAAgCkQwAAAAAAAUyCAAQAAAACmQAADAAAAAEyBAAYAAAAAmAIBDAAAAAAw BQIYAAAAAGAKBDAAAAAAwBQIYAAAAACAKRDAAAAAAABTIIABAAAAAKZAAAMAAAAA TIEABgAAAACYAgEMAAAAADAFAhgAAAAAYAoEMAAAAADAFAhgAAAAAIApEMAAAAAA AFMggAEAAAAApkAAAwAAAABMgQAGAAAAAJgCAQwAAAAAMAUCGAAAAABgCgQwAAAA AMAUCGAAAAAAgCkQwAAAAAAAUyCAAQAAAACmQAADAAAAAEyBAAYAAAAAmAIBDAAA AAAwBQIYAAAAAGAKBDAAAAAAwBQIYAAAAACAKRDAAAAAAABTIIABAAAAAKZAAAMA AAAATIEABgAAAACYAgEMAAAAADAFAhgAAAAAYAoEMAAAAADAFAhgAAAAAIApEMAA AAAAAFMggAEAAAAApkAAAwAAAABMgQAGAAAAAJgCAQwAAAAAMAUCGAAAAABgCgQw AAAAAMAUCGAAAAAAgCkQwAAAAAAAUyCAAQAAAACmQAADAAAAAEyBAAYAAAAAmAIB DAAAAAAwBQIYAAAAAGAKBDAAAAAAwBQIYAAAAACAKRDAAAAAAABTIIABAAAAAKZA AAMAAAAATIEABgAAAACYAgEMAAAAADAFAhgAAAAAYAoEMAAAAADAFAhgAAAAAIAp EMAAAAAAAFMggAEAAAAApkAAAwAAAABMgQAGAAAAAJgCAQwAAAAAMAUCGAAAAABg CgQwAAAAAMAUCGAAAAAAgCkQwAAAAAAAUyCAAQAAAACmQAADAAAAAEyBAAYAAAAA mAIBDAAAAAAwBQIYAAAAAGAKBDAAAAAAwBQIYAAAAACAKRDAAAAAAABTIIABAAAA AKZAAAMAAAAATIEABgAAAACYAgEMAAAAADAFAhgAAAAAYAoEMAAAAADAFAhgAAAA AIApEMAAAAAAAFMggAEAAAAApkAAAwAAAABMgQAGAAAAAJgCAQwAAAAAMAUCGAAA AABgCgQwAAAAAMAUCGAAAAAAgCkQwAAAAAAAUyCAAQAAAACmQAADAAAAAEyBAAYA AAAAmAIBDADAQFgsSdHRgwcNCkRFRcl8PQ0oarLf73O7PQLzAQAwHQIYAGBqVmvK mb4aHm/PD/8U/H4gKcni9XrVX6SmWqOjo493r0bUQv1+f2Njk1poTEyMx+NW63x8 +VEf/WnQGX8WTU1OzVYSAIDwRwADAAzr9Lj9KGh7JcTHJ6ekqJTVa/U0oLLZ6XS2 trZGRQVTOeq0bieSAQAmQgADACJVZmaG1+s96WtZb94G4zYxMfH4JcpGjttQUZHs dnuam5ujoj7K5JP+k8bExNTW1um4egAAhBABDAAIa6ecxQ18JKlXIokr7bQ8PvnI gbPHAIAIQwADAPSXnJx8csp+FLn+2Ni4tLRULe+2Rd+pX6GG+ob2jvaoqOhT2lhl s8vl0nHdAAA4Iw4pAAAa+eS53BOXK/tHjIhNT0+jco1E/brW1zd0fNzGg07+pee8 MQBALxxtAADEDRs2LC4udvTo0VQuVBtXVla2tbV3dXXpvS4AANPhQAQAIM5qtY4e na33WiCMVFY6mpqa9F4LAIDpEMAAAHEEME5BAAMAdEEAAwDEWa0po0eP1nstEEYq Kyu5ExgAoD0CGACghcsuG8cNwAgKBAKFhUV6rwUAwIw4FgEAaOHSSy8ZPHiw3muB sODz+fbvP6D3WgAAzIgABgBoISsrKyMjXe+1QFiw2ey8JRgAoAsCGACghZEjR6an p+m9FggLZWXlzc3Neq8FAMCMCGAAgBbGjBmdkpKi91ogLJSXl3s8BDAAQAcEMABA C0lJSWPH5uq8EggP5eUVHo9H77UAAJgRAQwA0ILFkpSbm6v3WiAsVFRUuN0EMABA BwQwAEALFoslNzdH77VAWKiosLndbr3XAgBgRgQwAEALBDBOIIABAHohgAEAWiCA cQIBDADQCwEMANBCcrIlJ4cARi+bzeZyEcAAAB0QwAAALRDAOIEABgDohQAGAGiB AMYJBDAAQC8EMABACwQwTiCAAQB6IYABAFoggHECAQwA0AsBDADQAgGMEwhgAIBe CGAAgBYIYJxAAAMA9EIAAwC0QADjBAIYAKAXAhgAoAUCGCcQwAAAvRDAALRjtaZ8 9N1P7HyiogYFAif/wId/8ckfPMM/cMadWNTHPxZ1/J88244uEAhER0c3Njae5Z9B SBgvgAMfqa+rV1tZVFT04MGDz//LqtpkfT5fIOBX30vPSI/6SAjWOGwQwNpITU31 +/3n2ngCH+0qj//Fmfe6Z9vlDjp1r/vxD5427cO/bmpynnWVAECQob6gAtBYSkry 8UOrU/YkgeMHPb3fBvMgPj6+p8ebmZkZtgfx6hixvr4hJmZIS0tL72Hbh7lxYn0/ +lPUhz+3mJiY2to6vdY2QoVzAKvg9Hiahw2NGT58hBIbq/4fFKf+UBtwgvp/YqLa IHp8vrj4XukZGbk5OZakJNEVc3s8tXV1rS0t7e3tLc3NQ1RgR0W1tbWp7ze3tLS1 tqrvq7+l/ujoaO/95rjOzo6ubq/FkqSCXHT1BowAHoDMzAyv1zvo+I7ppLAM7m0H ndjlqu8kJCT0eHvS0tOio6P1WtuzU+tZW1MzJGZoa2vrSZ/wfPjtaf9swOl06bGa AIwpTA9GAejr+JFWzyk/eOJ8V+8BVnx8ckpK2B5dSes96VffMGzYMLfbHTx0O/mD gOB5j+MHbZzl+FhycnJOzhjtl6t+IZqamlTWxsfFqTBITEhMsljUysQez9zejh07 9sILLuhLyqr8UKl54i9VHMfExEiu+wCXGMxmFclul0t1serk+oZ6Z5PTc1xLa4uq DpXOKpVTU1N1+VjKZrO7XCTNx1JSUoJ7kpPLNri7VX+ojbOruzs9PS1sP0OU5vf7 1e5UbbYffUB5hmsiYmKG8LkkgL4w6Z4UwPGTt9HBQ4hTTtiqSEhOtpg2bkPI5/O1 NLeoGjn5FMeJv2u2QpYLYPVf0uV0xcXHJ6q+TUxUW6/VmpqYlKS25As/c9G4S8dZ U1JO/7dObksNUlZLffmpqc2yprbW2dTU3tqqOrmmpqa+vt7lcro9veeWW1ta1AT1 X1KouMwWwMG+PekHPt7fqrhNSEwI23P1EURFssvlbmlpOe2UcvATST+nkQEEEcCA kaWmWj95PiF4yOWPi4vT68wPTlZbW9fR0REdHTxY+8Q5DeMdrskF8K23/uiOO+44 5QdPRKDB4jZUzvnfp7SkZOlLL+Xv2imxdOMFcPAjxRN/GbxSpndv6w+MGDEiMzND x3XDoOO/GI2NjW1tbcc/+f3Ex5Hq+42NTbquHQBNcfgLRLzjT5Y68Xs5WLn+6OjB I0dmcVYhcp3xcC2iL66WC+Cf//x/fvnLX0pMNrPSQ4deeeWVvO3bJIZHaAB/8kJl PlI0Dp/PV11d4/f7Prow6uMvqTyvCzAedtZAZFBHV71PhT0pgYIHXsOGDc/KytR7 7aC1mprazs7O4KnjTz6HLHwP1wjgyGLaAD7tI8UPT+QOH87O1ozUzrarq/OjDyI/ /vhD/QivDwAiFAEMhJdPXkf34YFXQkLCR89bBs7hk6cywuiWYwI4shg7gE+5KTcY uVw4g74LPpu6paXlxD0sH/240e5eAYyH42lAH1ar9cQDP0+czh0xIjYjI13vVYNh 1dbWdXZ2nHILXFtbW2dnpwZLJ4AjizECePjw4XFxcce/+/EVy8OHc1MuBNXV1Xd0 tJ84aTzoo1cDNDVxpzEQFghgQAvDhg2Lj48PZm50dDQnGRA+Kisd2hyWEcCRxRgB bLVaR4/O1mBBwDl9dHmOPxjGra2tXV1deq8UYEYEMKAFDsIQtghgnBEBDIjSbN8L 4BQEMKAFDsIQthwOhzavACGAI4sxAjg11Zqdzb4X4YgABvRCAANaIIARtjgDjDMy RgCz70XYIoABvRDAgBY4CEPYIoBxRgQwIIoABvRCAANa4CAMYYsAxhkRwIAoAhjQ CwEMaIGDMIQtAhhnRAADoghgQC8EMKAFDsIQtghgnBEBDIgigAG9EMCAFjgIQ9gi gHFGBDAgigAG9EIAA1rgIAxhiwDGGRHAgCgCGNALAQxogXdRImwRwDgjAhgQpdk7 2AGcggAGtEAAI2wRwDgjAhgQRQADeiGAAS0QwAhbBDDOiAAGRBHAgF4IYEALBDDC FgGMMyKAAVEEMKAXAhjQAgGMsEUA44wIYEAUAQzohQAGtEAAI2wRwDgjAhgQRQAD eiGAAS0QwAhbBDDOiAAGRBHAgF4IYEALBDDClt1e6XQ6NVgQARxZjBHAKSkpY8aM 1mBBQH8RwIBeCGBACwQwwpYBzgDfdtsvbrvtNonJZnbk0KFXly//IG+rxHDOAAME MKAXAhjQAgGMsFVZWdnUpM0ZYEtOTo7E5Ntvv/3HP/6JxGQzO1pa+vrrr23avFli uM1mc7ncEpNPYbWmjB7NGWCEIwIY0AsBDGiBAEbY0uwgjACOLMYIYPa9CFsEMKAX AhjQAgdhQYFAwO/3qy/5Q4YMjhkSEzN0aMyQIUOHDYsZPFh9f/DgwUPU31DfV3/q /SMoRv2L6kejo6ODQwYf/+eC43p6etTAwKBB6lufz9f7Y36/1+vt8fl6erw9vXzH v1X/mE/9sPpfd1e3+tbb7e3u7lb/SnpG+onJ5qThPcAEcCQxRgBzD7DaN9bXN6i9 5lC1v1W73SExw4YNVftV9X21J/3k/jb4p8FRUb27xBN73dN3ub3fVZPVDlR9PxBQ e9Suru6Ojo7g3tbnD/4dn9rVqh9Re9qeD3fHXvXDaWmpamxUFMefBDCgG3ZAgBYM HMDqYEjl0/Dhw0cMHxEXFxcbG5uQEB8XF9/7R4ISrw601NGTxWLJGjXqs5/5jDUl Re9V/pDb46mtq2tva+vq6nI5neqQTXWx+rm0HNfaprS2t6u/364O7Do61f96dXV3 Z2VlGenojQDGGRHAYSgQCNTW1AwdNkztb4PULlftd+N6xavdbmJiYm/HxsQkJiVZ rdaMzMxRI0dakpKkV8zldttttmAbn53q4KhAoLW11aW2AI+npaW5ubnlw/2s2uF2 tKvvdaq9rfq2q1PFs/pZGPUzSgIY0ItxjuGAcBahAayOZtxujzrGOl608Qnx8UkW S3JysjrkUodd6tBK9cyFF1549qMrr9fb1t4e/L7q45iYGE3W/dxOXrFBfVs3dbhW U1vb1NjY3dmp+rhOfb+pSR3GeZo9x5O5ta03mNvUgVxaWlqkRHJFRYX6VdZgQQRw ZDFGAFssSbm5uRos6PypuG1sbIxVTdv7UWKc2t+qmlW7XNXw6gdGxMXl5OZe/J// mWq1nn3OAPZs56/388Ta2o6TlhsSqpaHDB7c1tJS19BQX1+v9r29zayKubV3Z9sb zO3tXd3dat8SiZFMAAN6iYzjMyDShW0A+3y+9rb2hITjR1qJSepgy2q1qj/HJyR8 9rOf/Y//+I8zxm3YNq20Ez/xs/ysg5HsbGpqb21tbm6uralRB7W9kezxNLceP7nc 3NLe0ZGZmREmhbxvX6E2CyKAI4sxAli5/PLLtFnQ2am+raurj42NTUzovThG7W+T lZSU3vO2CQkXXHjBuEvHfdoFMn3Z8+hLraHa9VVXV/uP34qiJRXJg6OinE5npcNR X1fX5HS63e7eq3h6I7k3k9UXuMGDB2u8Vn1BAAN6CYvDL8DwdAxgddTV0NCojgAs qm6TkhJ6Szdp5MiRl1122de+9rXU1NQT/2RXV5c6bhgUCQdb4eyc//V6DxNramqr qz1ud/Px0yaNvaeRew/aPM3N6rBNy8M1v99fVLRfm2URwJHFMAE8btylmp0e9Pl8 bW3tib0fKSalqLy1WuN7L55JuPCii6644oqszMzT/xXD7G+DN5V0tLXpvSKf0HsO OTra5XLZKytra2oaGhpcbpenuaW196KdVpXH6em6Xa1DAAN6IYABLUgHsKrc+vqG xMQEVbnJyclJx40eM+brX//6F77whdjY2BP/pDrY6ujoUN8ZMWLEKQdbJwIYos5y vBs8glRV3NPd3VBfX1lZWV1dXVNb03syo61VYmUIYHwaAvicEhMSMzLS09LSe/e6 ycmf+/znP/fZz55y1Yxh+vacdDwJPGBqnbs6OhxVVVUOR319vdPl9HiaFbW/bWtr V7+4om1MAAN6IYABLcgFsPpqPX/+/CuvvDIxMfHED56lcs+CANbd6cfK6oDy8OHD FUePvrB4kcQSbTa7y+WSmHw6i8WSmysSwHfe+dtbbrlFYrKZHTtyZOXKFe9t3Cgx vKLCptneJiMjIyvrDKdez9+MmbMuuvDCQWaq3LMLz5PAA9Pd3d3e2lpWVjZv/nxL skViEQQwoBcCGNCCXAD7/f6Cgt0hOeQigMOQOqAsKS4+cvjwSy8vk5hfVlbe3Nws Mfl0cgH8xz/eddNNN0lMNrOyo0fffPPNde+ulxhujACe+tS0Sy+5RGJyhPrwJHBV VV8eBx0RKisqpk6bFhcfJzGcAAb0QgADWpAL4EBg0L59+0IyigAOQ+po8uCBA4cO Hly+4nWJ+QQwPo1hAjgrKysjI11i8sRJj33pyislJkeu4FMAO0P9OGi9EMCAIRHA gBasVuvo0SIBPHjwkIKCgpCMIoDDkNfrLT18eHdBAWeAz4IAlmCYAM7Ozk5NPcer gwZm8uTHr7jiConJkSt4ErjK4QgEAnqvSwioAJ729NMjRgwXGV7paGoigAEdEMCA FuQCOCZm6M6dO0MyigAOT1WVle+9++6yV1+RGF5eXuHxaPES4EEEcKQxTADn5uQI 3cM5ceKkL33pSxKTI1rwUVhdnZ16r0gIVNps/3r66WHDh4kMJ4ABnRDAgBYIYAyY OgJbt3btaytXSAwngPFpDBPASUlJY8fmSkx+8MEHr732qxKTI5rX63W53VUOh94r EgIEMGBIBDCgBQIYA1ZRVrZm9eq3Vq8SGV5R4XZHfAD/7//efeONN0pMNrOKY8fe fvvt1WvfERmuYQBbLEm5ubkSk//6179961vfkpgc6dwej8Ph8HZ3670i54sABgyJ AAa0QABjwMqPHn3rrbfeWb9OYri2HSIVwPfc89dvf/vbEpPNrKKsbPWqVW+vWS0y 3BAb3l13/en73/++xORI5/V6m5zOmupqvVfkfBHAgCERwIAWCGAM2NHS0pUrVmx4 f5PEcJvN5nJFfIcQwBIME8DJyZacHJEN7447fnPrrbdKTDYAt8djq6iI9PchEcCA IRHAgBbkXoNEABvekUOHXl2+/IO8rRLDCWB8GgL4nG677Re33XabxGQDMMajsEQD mNcgAXohgAEtyJ0Bjo2Ny8vLC8koAjg8HS4ufmnZsvxdofmY4xQ2m93lcklMPh0B HFkMFMDJOTljJCb/6Ec//vWvfy0x2QCM8Sgsh832zLPPDokZIjGcM8CAXghgQAsE MAaseP/+F5cs2Vu4T2K43W53OjULYKlnEf3jHw9+9as8jDfE7BUV69auff2NlRLD tXz6WkpK8pgxIgH8/e/fdNddd0lMNga3x2O32Xw+n94rMnAEMGBIBDCgBQIYA3aw sHDBwoXFJcUSw40RwLyNRoLo+7eMEcDf+MY3x48fLzHZGFQA19TUdHZ06L0iA0cA A4ZEAANaIIAxYPv37n1u/vwjx45KDLfbK51Op8Tk0xHAkcVAAZwyZsxoiclqq1Pb nsRkYzDAVdAEMGBIBDCgBQIYA1a4e/esOXNslXaJ4ZWVlU1NGgVwUlLS2LG5EpMf fPCha6+9VmKymakAXr9u3fIVr0sMLy+v8Hg0CmCrNWX0aJEAvvLKL02aNElismH0 PgvaZvNH7FXQBDBgSAQwoAUCGAO2d9euZ2fNrK6pkRhujAB+7LHJX/ziFyUmm1lV ZeXGDRuWvrxMYrgxAnjcuHFTpkyVmGwYkf4saAIYMCQCGNACAYwB252fP/2ZZ5qc IsdJWh6BEcCRxUABLLX7/cxnPvvss89KTDYMr9frdDpVA+u9IgNEAAOGRAADWiCA MWC7tm+fOn16c0uzxHACGJ+GAD6nMWNynnvuOYnJRuJyu20VFYFAQO8VGQgCGDAk AhjQAgGMAdu5bdsTU6e0yzxJVcsjsDGjs1OsVonJBHDIeb3e0sOHC3btWvbKyxLz y8vLPR6Rz3ROJ7f7zczMXLhwkcRkI3F7PJWVlT1er94rMhAEMGBIBDCgBQIYA7Yj L2/S5Mk9vh6J4VoegWVnZ6emigTwo49OvOqqqyQmm5aKlgMHDhw6cEDoKdBlZeXN zREfwMnJKcuWiZwhN5KIfhkSAQwYEgEMaIEAxoBt/+CDRyZOjIoW2V1reQQ2cuTI 9PQ0icmPTZ78xSs4AxxKKloOHjhwuLj41ddfk5hvjACOjY1dsWKlxGQj6b0N2OWq rqrSe0UGggAGDIkABrRAAGPA8rZsefDhh4cNHyYxXMsjsMxeGRKTp0x9atyll0pM Ni0VwCXFxaWHDgldAm2MAI6Kin7nnXckJhuMy+2uKC/Xey0GggAGDIkABrRAAGPA tr7//r0PPJCYmCAxXNMAzsjIzMqUmPzUtOmXXHyxxGTT6g3gkpKjhw8vXfaSxPyy srLm5haJyaeT2/12dXVv2rRJYrLBqM3Jbrf7ekTu4xBFAAOGRAADWpA7AktMTNy8 eUtIRhHA4Wnrpk333Dte6PFRWh6BpaWljho1SmLyjJmzLrrwQonJpqWK5fDhwxVH j76wWOQhT8YI4JaWlry8bRKTDUZtTlVVVd1dXXqvSL9V2e3PzpxpgDtQAJyMAAa0 kJpqzc4WOQKzWCybNr0fklEEcLjxer1t7e278/P/du+9GTIXD2t5BJaRkZElcwZ4 1uw5F4wdKzHZtFSxlKoAPnbs+UULJebbbHaXyyUx+XRyAdzQ0Lhjx46YmBiJ4Uai Nqfa2tqO9na9V6TfVADPnD1L6A1ODoejsZEABnRAAANaIIAxAL1HjXV1xw4dembG s9HR0RKLsNsrnU6nxOTTjRt3qdDPYsHzL4waOVJismmpbe/o0aOV5eVz58+TmO/3 +4uK9ktMPl1KSsqYMaMlJqufxavLX7MkJUkMNxKv1+tyuaoi8DlYBDBgSAQwoAUC GAMQjBCHzTbnubkS8wOBgM1mc7s9EsNPJxfALyxclJUpcm7ZtKS3PS0D2GJJysnJ iYoSOeBh2+ujCH0OFgEMGBIBDGiBAMYAqAg5dOjQscOHX3xpqcR8n8+3f/8Bicln dNll44Qi5OVXXuUsXGipba+8vLzW4XhmxrMS8wOBQGFhkcTkM7r00ksGDx4sMflf Tz/zH5//vMRkg+l9DpbNpvY5eq9I/xDAgCERwIAWCGAMgNfrLS0t3VtQsETmSbx2 u93p1Og+zNTU1OxskSdgqZR65dXlBHBonbj8/t8zZwh9bOFwVDU2NkpMPt2oUSPT 0kTeQf3EE09efvnlEpMNRm1Rqve83d16r0j/EMCAIRHAgBbknsKSnJyycePGkIwi gMNQpc22bu3a11aukBheXl7u8Wj0LtaUlOQxY8ZITPb7/atXr+FBRKEVfABbwY4d U6Y9JXb/uXafv+TkjElOTpaY/OCDD1577VclJhuMCuDq6uquzk69V6R/jgfw7MAg kQTmKdCAXghgQAtyAZyenrFu3bqQjCKAw1D50aNvvPnmunfXSwyvqKjQ7AZgqzVl 9GiRBxHV1dXv3btXYjI+2LTprrvvFnp2d2VlZVOTRg9gs1iScnNzJSb/8Y933XTT TRKTDSZ4TUFHW5veK9I/1ZWVs+fO7fGJvMGYAAb0QgADWiCAMTBHDh1a/tryLVu3 SgyvqLBp9isu9yTexsamgoICiclQAfynv/wlU+YVXFo+gdxiseTm5khM/uUvf/nz n/+PxGSD8Xq9TperOtIeBE0AA4ZEAANaIIAxMCUHDixZunT33j0Sw43xLlaXy52f ny8xGVs3bfrfv/0tLS1VYriWR//Jyck5OSJX4N988w9+//vfS0w2nkh8EDQBDBgS AQxogQDGwBwsLFywcGFxSbHEcC1Pwcn9FmhpacnL2yYxGSqA77l3fIrVKjFcy6N/ uQsQvvGNb44fP15isvG4PR4VwIGA0COlRBDAgCERwIAWCGAMTOGePXPmzi23VUgM N0YAd3R0bt68WWIy8t5//2/33ZdkEXnCtjEC+Oqrr54w4VGJycYTiW9CIoABQyKA AS0QwBiYPTt3/nvmjNq6OonhWj6FSO5NYD09Pe+9t0FiMvI2b77vH/+Ii4+TGK7l O2DknsF28cWXTJs2TWKy8agAVvucHq9X7xXpBwIYMCQCGNCCXACPHDlq9erVIRlF AIehgh07nvrXv9wekV8XLQ+/5H4LqC9ka9eulZlsdiqAH3j44REjhksMN8bml5s7 ds6cORKTjUcFcFVVVXdXl94r0g81lZVz58/v6hZZZwIY0AsBDGhB7vArOzv77bdX hWQUARyGdublPT51SofMyzONUSBDhsSsWhWa3wI4xbYtWx565JGYoSLvWDbG5pee nrF48WKJycYTia8CVgE87/kFBtgDAzgZAQxogQDGwOzYunXCpEmBQSKPjTFGgcTG xq5YsVJiMrZv3frIo49GRYscKhhj84uPT3jttdckJhtP76uAa2s72tv1XpF+IIAB QyKAAS0QwBiYbVu2/OPhh4cNHyYx3BgFYrEkv/zyyxKTsSMvb9LkyQa4AVJu84uK in7nnXckJhuPCuC6urr2tja9V6QfCGDAkAhgQAtyh19jx44N1ekvAjgMGeYxvHK/ BTIyMhYt4hpUETu3bXt8ypSOzg6J4cbY/HgIed95vV6ny1VdVaX3ivRDjcPx/MIX WmWinQAG9EIAA1qQO/y64IILXn99RUhGEcBhRR0strW379658+/335eamiqxCGMU yOjRY+bNmycxGbu2b586fXpzS7PEcGNsfi6Xa+vWvJgYkdukjUcFsK2iQu+16AcV wC8sXNjS1ioxnAAG9EIAA1oggNFfvffL1dUdLSn598wZ0dHREovQ9j3AUu+hufDC i2bOnCkxGbvz86c9/bTTJbKRaPkWLrn3APv9/leXv2ZJErlGw3hcbndFebnea9EP BDBgSAQwoAUCGP2lAvjYsWOOiorZz80VWoQxAvg///Pi6dOnS0zG7p07n50xo7Y+ 4l9DLRfAysJFizMzMoSGG4zarZWXlem9Fv1AAAOGRAADWpAL4M9+9nOvvPJKSEYR wGFFHSmWlJQcPXx46bKXJOb7/f6iov0Sk89ILoC/8IUvPP74ExKTsa+gYObs2ZVV DonhWgawMm7cpUJXUjw1bfolF18sMdl41G6torw8EBB5rL2E2qqqRYsXu5s9EsMJ YEAvBDCgBbkA/tznPh+qR+ASwGHF6/WWHj5csHPnsldD8wHHKex2u9Ppkph8RnKn 4K655sv//Oc/JSajaM+eOfPmlZWLnLLT8gIEZdSokWlpaRKTJ0167Morr5SYbDwq gG0VFX6/X+8V6aveAH7xRbdH5CsjAQzohQAGtEAAYwBs5eVr33ln5VtvSgwvL6/w eEROa5yRXABff/3X7r//fonJOLBv37znnz9celhiuMYBnJuba5F5mvrf/37f17/+ dYnJxtMbwDab3+fTe0X6igAGDIkABrRAAGMAjh05snLlivc2bpQYXlFh0/KXOzk5 OSdnjMTkG2648e6775aYjOKiooWLFxcdELlU3mazu1zaXYNgsVhyc3MkJt95529v ueUWicnGowLYbrf7ekTeLC2BAAYMiQAGtCAXwJdccumLL74YklEEcLg5XFLy8rJl 23fmSwy32Wwul5YBbMnJEcmPn/zkp//v//0/iclgC+wLtsC+UwFcabf3RE4A11VX v7h0aZNTJFMJYEAvBDCgBbkAvvTScYsXLw7JKAI43HD+rS/uuOM3t956q8RkHC0t XblixYb3N0kM5xoEE+oN4MrKHq9X7xXpKxXAS156qbGpUWI4AQzohQAGtCAXwOPG XbZo0aKQjCKAw83+ffvmzZ9fevSIxHCN78BMSkoaOzZXYvI99/z129/+tsRkVJSV rV616u01qyWGG+Yu9Ouuu+6BB/4hMdl4VAA7HA5vd7feK9JXKoCXvvRSAwEMGAsB DGhBLoC/+MUr58+fH5JRBHC4Kdy9e/bcuRV2m8RwjV9CM2rUqLS0VInJ//znI9dc c43EZJPzer2HDx3K37Fj+euvScwvKytvbm6WmHxGci/i+tKXrpo4caLEZOOJuACu r6lZ9sortXW1EsMJYEAvBDCgBQIYA7B3165nZswwxrFXRkZ6VlaWxOTJkx+/4oor JCabnGqV4oMHDxUXv/racon5Gt8DLLcTvvjiS6ZNmyYx2XjURlVVVdXd1aX3ivQV AQwYEgEMaEHu2Ouqq66aO/e5kIwigMPN7vz86c88Y4Dnr1gsSTk5OVFRIl9xZs+Z OzY3V2KyyalWKS0ttR07tmDhCxLzA4GAamC3W6OroOV2whdd9JkZM2ZITDaeiAvg htral199pbqmRmI4AQzohQAGtCB39d2Xv/yVmTNnhmQUARxudm3fPmXatJbWFonh Wh57yd1+qSJq2cuvpCQnSww3OdUqtbW1R0pKZsyeJfThhZY3ossFcHb26FBdhmN4 ERfAjbW1r77+WqXDITFc4/tQAJxAAANaIIAxAPl5eY898US3V+R+OS0DWK49amvr du3aFRMTIzHc5Lxeb1t7++78/HvGj8/KypRYhDE2Qqs1denSpRKTjYcAPhkBDOiF AAa0IBfA1113/TPPPBOSUQRwuNmxdeujj03yBwISw43RHm63Z8eOHRKTEbR106a7 //a3VJkHmBljI0xISFi+XOQ5YcajAri6urqrs1PvFemrxrq611esMMaTCAGcQAAD WpAL4K9//b+mT58eklEEcLjZ/sEHj0x8NCo6WmK4w+FobNSoPVJTrdnZIu3R09Pz 3nsbJCYjKG/z5vv+8Y+4+DiJ4cbYCEeMGLFy5RsSk40n4gK4qb5+xcqVZRXlEsMJ YEAvBDCgBbl7IAlgA9u2ZctDjzwSM1Tk+l5jnHyLjY1dsWKlxGQEHf8UZmJUtMjR gjE2wiFDYlatWiUx2XgI4JNp/DJ2ACcQwIAW5AL429/+zpNPPhmSUQRwuMnbvPmB hx8eMWK4xHBjtEd6esbixYslJiNoZ17e41OndMgUizE2QnUotXbtWpnJRhNxAexs aHjjrbeOHD0iMZwABvRCAANakAvgG2648fHHHw/JKAI43Bjm6lO5WwB4A4004Xdx aXcJKNfhh4NIDOC33n778JFSieEEMKAXAhjQglwA33jjdydPnhySUQRwuMl7//2/ 3XdfkiVJYrgxXoP0xS9+8bHHQrP944z27d49a/Zsu6NSYrgxXoPU0dG5efNmicnG E5EBvGrV4dLDEsMJYEAvBDCgBbkAuPnmHzzyyCMhGUUAh5utmzbdc+/4FKtVYriW AZycnJyTM0Zi8je+8c3x48dLTEbQwcLCBQsXFpcUSwy32ewul0ti8unkArilpSUv b5vEZOOJuNcguRobV69Zc1Bm+yeAAb0QwIAWCGAMQO8baMaPT02N+AC2WCy5uTkS k2+99Ud33HGHxGQEHSouXrZsWf6unRLDKypsmu1z5ALY42nevn27xGTjIYBPRgAD eiGAAS2kpCSPGSNyBuyHP7z1wQcfDMkoAjjcGCaA5e4B/t3vfveDH/wfickIOnbk yBtvvPHuhvckhmt5DzABHA4iLoDdTU3vrF1bdGC/xHC73e50anQFBICTEcCAFuQC +Cc/+el9990XklEEcLgxTABfeuklgwcPlph8//0PXH/99RKToXi93pLi4m15eW+8 9abEfJ/Pt3//AYnJpyOAw0HEBbDH6Vy3fv3ewn0SwwlgQC8EMKAFuQC+7bZf/PWv fw3JKAI43BgjgOU2fuWJJ6dcftllQsOhcqX44MHSkpKXl78qtAjNGoAADgdqi3I4 HN7ubr1XpK9UAL+3YUPBnt0SwwlgQC8EMKAFuYcA/epX//fuu+8OySgCONwYI4Dl wiMQCLy4ZGl6WprEcAw6nis1NTWlxcWz5s6JihI5YDDAdkgA913EBXCz273hvfd2 7i6QGK7lQ+AAnIwABrQgF8C33377n/7055CMIoDDjTECWO79q+rYcevWvJiYGInh GHT8Eui29vbdO3f+/f77UlNTJRah2fuoCeBw0BvAlZVqu9J7RfqqxeN5//1N23bs kBhOAAN6IYABLXAGGAMg/BokjZ4/JBce6kvY2rVrZSbjY3mbNz/w8MMjRgyXGK7h GWCpJ7HxGqS+UwGs9jw9ERXAmzdvztsu8utLAAN6IYABLSQnW3JyRF4Dc+edv/39 738fklEEcLjZ+v77995/f2JSosRwA1x6mpycsmzZMonJOFl+Xt7EyZN7fD0Sww2w HXZ2dr3//vsSk41HBbDdbvf1iGxLEtpbWz/44IP3t2yWGG6z2VwuvuYCOiCAAS3I vQf1D3/4429+85uQjCKAw03e5s33P/RgbGysxHANH4Il9RLsCy64cNasWRKTcbKC HTumP/200y1yqkqzV6HKBbDf71+//l2JycbTG8A2m8/n03tF+koF8LZt2zZs2igx XMv3YAM4GQEMaEEugO+++y+/+tWvQjKKAA4327ZseeiRR2KGitzjqtm9l3LX/199 9dUTJjwqMRknK9yzZ87cueW2Conhml0FKncv+pAhMatWrZKYbDwqgG02mz9yArij rS0/P3/du+slhhPAgF4IYEALcgF83333/eQnPw3JKAI43GzfunXCxEcH8fTdT3HT Tf/9xz/+UWIyTlZy4MDiF18UehWqAbbDuLi4119fITHZeFQAV1RUBPx+vVekr7o6 OnYXFLy9ZrXEcAIY0AsBDGjBYknKzc2VmPzQQw/fcsstIRlFAIebHXl5kyL/3stL L71k8ODBEpPvvPO3odr4cRbHjhxZuXLFextFrgL1+Xz79x+QmHwK7kUPB70BXF4e CAT0XpG+6u7s3Ld378q33pQYXlFR4XZ7JCYDODsCGNBCUlLS2LG5EpMnTXrse9/7 XkhGEcDhZue2bY9PmdLR2SExXJsAlnv0rvLww//88pe/LDQcQV6v91BJSf6OHa+t eF1oEdo8kFwugDMyMhYtWiwx2XhUAJeXlem9Fv3g7e7eX1i4XGbjLy+v8HgIYEAH BDCghdycHEuyRWLy1KlPffOb3wzJKAI43BTs2PHU9OnuZpEjJG2qQ+7GS2X2nLlj ZS6swAmqWEpLS23Hji1Y+ILQIrS5HV3us5jc3LFz5syRmGw8Lre7orxc77XoB5/X W1JcvPRlkTP8BDCgFwIY0IJqAFUCEpNnzZp9zTXXhGQUARxu9hYUPDtzRnVNjcRw bZ6+K3farb6+YeOmTZakJInhOEEFcG1d3dGSkoceeSQjI11iEdpcjCD3NPJx48ZN mTJVYrLxqH2OzWbTey36IeDzHT1y5PlFCyWGl5WVNzc3S0wGcHYEMKCFrKwsoWPH JUuWXnzxxSEZRQCHm/379s1fsODwkVKJ4Xa73ekUf/qu3Gm3QGDQqlWrYmJEHpGN E7xeb1t7+96CgkcnThw2fJjEIrS5GCElJXnMGJGnkV933fUPPPCAxGSDUduSCuDq 6mq9V6Q//P6K8vK58+dJzCaAAb0QwIAWMntlSEx+8823QnVURwCHm5IDB5a+9FLB nt0Sw202m8sl/sstd9otKyvrhRcWSkzG6XZu2/bkU1NVCUsM1+ZihORkS06OyKP4 f/CD//O73/1OYrLBuD2eurq69rY2vVekH6IHDXLY7c/OFnnfuGbvAANwCgIY0ILc g3DXrVufnh6ac8sEcLg5Wlq6YsWKje9vkhiuzXWnci8Au+KKKyZPflxiMk63r6Bg 5pzZlQ6HxHBtXgYjdzX+r399x49+9COJyQbTezl9bW2HzMcoQgZHRdXW1Ex/5mmJ 4Zo9Ah3AKQhgQAvjxl0aHR0tMXnLlg8SEhJCMooADiter7f44MG8rVvfWvW2xHxt jr2yMjMzZK594CXAWio5cODFJUv27NsrMVyb82Byn0KOH3/vN77xDYnJBqMCuLqm pqtD5LH2QmIGD25saHhi6hSJ4X6/v6hov8RkAGdHAANauOyycVFRIr/ddu/eE8K0 rq+vj6A3NBqbOlg8eODA4eLiV19/TWgR0vdeyl3/rPzpT38O1QvAcHZer/dAUdHm zZvXrl8ntAjpq6BFX8f12OTJX7zii0LDjUTt06qqqrq7uvRekX4YHBXlcjofn/Kk xHD11bawsEhiMoCzI4ABcampqdnZoyQmqy+f+/YVhnZmV1dXc3Oz3+8P7Vj0V/Bs yaEDB+bOe07o0xPpq6DlLjpVpj417dJLLhEajpOpTbGkuPjI4cMvybwMZlAkb4pq J7xw0eKszEyJ4QajNiSHw+Ht7tZ7Rfqhp6envqbm3zNnCO2EHY6qxsZGickAzoIA BsTJnQdTmSr0+bHX6/V4PD6fT2I4+iL49N3d+fn33n9fWlqaxCIitzrUlvnKq8tT kpMlhuMUwVs3S4uLn501U+gq4sjdFJ1OZ17eNp5G3hdqQ6qsrOzxevVekf6xlZXN mjtH6CYmbZ4AB+AUBDAgTu7qu/r6hqqqKonJJ7hcru6I+sDeYPI2b37g4YdHjBgu MVz+EmipF890d3vXrVtHdWgj+FnMnl27/jlhQlxcrMQipF/KJXkJdNTatWtlJhuN CmC7zRZxn6uqAP7no49mZYmc5NfmHWAATkEAA+LkTj40NDQ4HLIBHNTR0cHrCnWR n5f32BNPdHtFPoOQfvhQaqo1O1tky09Pz1i8eLHEZHyanXl5j0+d0tHZKTHc4XA0 NgqeAU5OTs7JEfksxmpNXbp0qcRk41EBXFFeHnGPmbCXlz/0yD9HjhwpMVybp/ED OAUBDIiTuwTa6XTZbDaJyWfk9/vVl2puD9bS3l27np01s7qmRmK46NV3VmvKqFGj hK4b/NKXrpo4caLEZHyawt27Z8+dW2EX2eGovUpVVZXcqbDRo0erDVJi8rhx46ZM mSox2XhcbrcKYL3Xot9UAP/z0UczZZ5mzyXQgC4IYECc3Blgl8tdUVEhMfnsmpub OyLqVRaRq3j//heXLNlbuE9ovtwFeKJPwLrttl/cdtttQsNxRkcOHXp1+fIP8rYK zZc7FSb6COjvf/+mu+66S2i4wThdLpseX7DOkwrgCRMnpmekSwznDDCgCwIYECdX Ai0trUePHpWY3Bfd3d0ej4cTwnJ6Xz+zf/+Wze+/s07q9TNyl56KBvCTT0657LLL hIbjdGpTPFJaumf37iUvSV3uK1cCcpfiK3/+8/9+97vfFRpuJGoTcjqd1dXVeq9I v6kAnjh5stqKJIYTwIAuCGBAnFEDOCgQCKgM7oqoVztGiuBDUw/s27fwxcVib0KS OgMsd+U/j4DWngYPgpa7FlTuDLDa+82cNfuiCy+UGG4wwU2oo71d7xXpNwIYMB4C GBAnF8AeT3NZWZnE5AHo6OhobW3lhHAIffj03fz8+x58MCVFpPfkzgCLvv561arV PAJaS8FNcW9BwcRJE4cOGyaxCLkXosqdAVZ74C1btrAp9oUK4Jqams4IvHfGXlb2 6OTJaWmpEsMJYEAXBDAgzjAPweoLFcAtLS2dMo+KNacdeXkTH3vM5xd5d4iKSdXA IT8JbLEkjR49WuhUYU5O7ty5cyUm4+wKduyYOn26p9kjMdzn81VWVrrdIR5utaao +hW6gCIpyfLKK69ITDYeFcBVVVXdEXitEA/BAoyHAAbEyV2A19jYpA4ZJSafP9XA qoQ5IXz+9hUUzJg10yF275zEKQjRG4C//vX/+vvf/y40HGdxYN++BS+8UHL4kND8 iNsUL7/88ieeeFJouMEEb+jo8Xr1XpF+s5WVPTJxolAA8x5gQBcEMCBOLoB9Pl9R 0X6JyaESCASam5s5ITxgXq937+7d69atzdu+XWgRdrvd6Qzx24BFq+POO397yy23 CA3Hp1GbYlFh4YYNGzZu2ii0CIkATklJHjNG5A3Ayv/8z//84he/FBpuMCqAbTab 3ydyJYsoFcAz58wWup6FAAZ0QQAD4kQfwbJ79x6hL8yhpRq4tbXVF4FHP/pSR40l JSVHDx9euuwloUXYbPa2trbu7u4QzpS77F9t8/9+dsbnPvtZieE4i+AZvKI9exYv XSJ0RXHILwcdOnRocnJyVlZmCGee7Klp0y+5+GKh4Qajtp/y8nL1G1jvFemfnp6e 2qqqGbNnRdxjCAGcBQEMaOGyy8YJffl8++1Vcm/4CDlVLy0tLbxDuO96H51aV3e0 pGTi5MnJyRahpYT8zJvok8/ff/99HjukvQ8fybZz5wMPPmiR2RQjaDscdPwJWO+s XWtJShKabzAul0uXt9afp4DPV308gEWGBwKFhUUSkwGcHQEMaCEjI0PoLMS//vX0 1772NYnJorq6ulQJc0L4nILVcWDfvn8983Sb2BtEqqqqGxoaQjUtJSUlO3tUdHR0 qAaeLDMzc+HCRRKT0Rc7t217YuqUdpnPsPx+v8NRFcKTwGlpaaNGjQzVtNOHP//8 C3wW0xeR+xJgf0/PoZKSF2Vef22z2V2uEN9+AqAvCGBAC2NGZ6dYRd4i+Kc//fn2 22+XmKwNlcHtEfhmSI0V79+/aPHiwv1S5wpUeFRVVYXqSjzR027XXXf9Aw88IDQc 57R/3775CxYcPlIqND+EJ4Gt1pRRo6Q+iFG++93v/fnPfxYabjCR+xLgjra27du3 v7vhPYnh5eXlHk+zxGQAZ0cAA1qwWCy5uTkSk2+88buTJ0+WmKyZhoYGHhZ9Fl6v t7S0dG9BwRKx24AHhfRWNNEA/tOf/vy9731PaDjOTm2KB4qKNm/evHb9OqFFhDaA hR6+EPTEE09efvnlcvONRAVwdXV1VwQ+DdHZ0LBq9WqhJ59XVNjcbrfEZABnRwAD WkhOTs7JEXkSaUZG5tq1ayUma6a+vj4QaU9G0VLwNuAjxcUTJ09OSUkWWordbm9t be3uDsFLSlJTU7OzR53/nNOp7WTB8y9kjxIZjnPqfZVrdXXJ/v3zFswXeqiBw1HV 2Nh4/nOGDo1JO+78R52Ry+Vet349NwD3kdpyHJWV3gh8B1J1ZeXcefO6vaF8RuAJ XAIN6IUABrQg91Bcv98/Z87ca665RmK4Nurq6vRehbAWvA24uKhoxsyZTrfg0VJI Tr6JXnfa7e1Zt3Ytd13qJbgp7t21658TJsTGxUosIlRX44tehqCMHpMza+ZMNsU+ UgFst9ki76EPfv+e3btfeW250A4t5I89B9BHBDCgBdGjMZfLPW3atB/+8IdC86UR wOekwmPf3r3vrl+3ZetWuaWoo7GO485niOimnps7ds6cOULD0UcFO3Y89a9/uT1S l26e/wcxI0aMSE1NtVpTQrVKp/vVr371s5/9XG6+wagArigvj6wrfbxdXZu3bFn2 8svp6VLXEUi8+BpAXxDAgBakT0eoA4vLLrt85syZ8fHxcksRQgCfU+8ddDU1h/bv n/3cXNHXPtfU1NTV1Z/PBNEbL2+44ca7775baDj6qLioaOHixUUH9gvNP//b0TMy 0rOyskK1Pqfz+XyLX1ySlSn1emGD8Xq9Lre7yuHQe0X6qru722G3r1i5srGpUehS /yACGNALAQxoQTqAg1pb2/7whz+oQhD9mh1yBPA5BS893b9379Rp04TuRgtSR/bV 1TXnc0wmdwOw8tBDD3/lK18RGo6+UJvioZKS/B07XlvxutAizvM2YLWzHTkyS/Rz oqQky5IlS7j+uY/cHo/aybe3tem9IufW09PjcbnWrFmzNS8vRfIKgiACGNBLJB0l AxFN+qTECYHAoN8eJ/f+j9AigPtChcfugoJ31qzJ37VTdEHn807glJTkUaNGCbVH fX3Dho0bky0WieHoo+D7bI6UlDw8YYLap0kswufzVVVVOZ0DvN1d9N2/QT/+8U8i +uVzGlPbTE1NTafMu6NDJZi+77777rYdO+Jk7m8/hc1mc7l4BDSgDwIY0Ijcm5DO SPXST3/6s7/85S9xcXGaLXRgCOC+CL5HpHj//rnznhM9uzXoPM5LiF7pwGm3cKDN xQjhuQUGqT5fuGjxqJGyjW0kvY+Adji83YKXrpyP7u7uhtratevX79m7JzExUbPl 8g4kQEcEMKAR6ZdSnlFTk/OGG77zhz/8MZzfV0kA90UwPA7u2zf9mafVd0SXZbPZ OzraOzu7+vsvim7k11//tfvvv19oOPpl/759859//nDpYaH5A7sNePjwYRZLcmZm hsQqnZCamvrCCwv5IKbvwvYR0NGDBhXs2rVh06bikhLpzeZ0IXz1OoD+IoABjWhz G/AZBQKBxMTEH/7w1t/85jexsVpc3NUvBHAfqQbeX1i4adOmdze8J70sh8PR1tbe 3ydCp6Zas7OlNvL77rv/a1/7mtBw9J3aDkuKi7flbX3jrbeEFqE2v8bG/p0BHjFi RFxcrNzmd8Lvf/+Hm2++WXopRuJyuyvKy/Vei491d3c3NTRs3Lix6MD+qON0WQ1u AAZ0RAADGomPj4uPT9D+Y+aTNTQ0XnfddT/60Y9+8IMfhM+DsgjgPjpx++UTU55M kL9Ur783A1utKSo/hLarmpraDRs3plqtEsPRL723dNbWlh48+PCECVlZIk9CDgQC qoH7dX5Mg1t/B/U+aLD17VWruRG973ofAe1yVVVV6b0ivXf5drS15eXlFezeffTY MaFNt49sNrvX293aGgEPBgMMKVyOgAEzSElJGTNG66ugz0h93b3++utuvfVH3/nO d3QvYQK4j9ShZEtra+GePa+9/vqxsmMaLLG6uqa+vq9vRRK9xiEuLv7ll1/mutNw ELwav2jPniemTvX7pa5r7df5sfT09JEjtXjE4FVXXf3QQw+xHfZd8GO7DuG7Ns5C dW9XR8fOnTt3Few6dqxMg2c794XdXul0cv0zoBsCGNCOjldBf5r29o6vfvVafUuY AO47dTRZWVmp2mPhi4ulH4UV1PcGFv185ytfuVaFh9BwDEDR3r3PzZ9/9NhRofl9 LwTN6tfn882aPeczF12kwbIMQ+2yqqqqurv6/UCB83Ry95aVlSenJGu8AmfH9c+A vghgQFNjx+YmJSXpvRZnoEr4y1/+8ve///2bb755yJAhmi03EAj0/RwjgieBd23f vnDxYpd7gO+J6a/q6uqWltZz3g+cm5NjSZa6NPQvf7nnO9/5jtBw9JfaDg8eOPDB li2r31kjtIi+BPCIESMSEuJHavVA5tFjcmbNnMnp337pfQKW3e7r6dFmcb2XJ7S2 7ti+fV9hYUVFRbh1bxCPvwJ0RwADmgrDk8CncDpdV111lYqNH//4xxq8E8Ln8zU2 NkovxUjUAWVZWVlBfv7rK1dodtK+qqqqubml69NP44hu2DU1Ne9t2JiWmio0H/0V fLNraXHxwxMekXu9+dnPkg0bNiwxMWHUqFFCSz9FIBCYOHGS2jdqszjD6H0CVkVF 7+vpJQWfa7UtL+9ASbHNZhd6Q3WocPoX0B0BDGhq+PBhKhXS0tL0XpFzU2mamZn1 X//1Xz/72c9ycqTeYNzT08OhQL8ETwLv2Lp17rx5Xd3aXVhot1eq3v60XyzRAE5M TFq6dCln3sLHibcBT3nqKW+PV2gpZ+kEtb0lxMfLXXFwOktyyouLF7MR9ov0E7A6 2tsrbbZt27eXHjnS4+vR5q6Q82S329vbB/KSOQAhRAADWgv/k8CnCAQCw4cPv/ba a3/4w1uvueaa0A5XR0g8C6S/3B7PsaNHd2zb9taqt7W8c9vv99fV1bW1tZ3+8NK0 tFS5c3Hf+MY3x48fLzQcA3awsHDBwoXFJcVC81U4NTScenlIfHyckpGRER0dLbTc 06l94IMPPvTVr35VsyUag8QTsHp6enxeb2FhYf7O/LKy8mHDh+n+HMd+4fQvEA4i aa8BGMPQoTEjs0Zqee4ihH7xi1/ec889IRzY3d3tcml0L6thBE8C5+flzX/++bZ2 rV+k4XA41Lcnv6Y1JSU5OztbLkieeOLJyy+/XGg4BkZthKWlpXsLCpYse0loEX6/ X21sTufH+4fU1N73YGnwst9TpKdnLFiwgNO//dX7BCyHQ+3kQzjT2dDw3saNe/ft DeFMzdjtla2tLd3dUhdNAOgjAhjQgdVqzc4eFVmfWwd961vfnjJlSggHdnV1ud3u EA40CXVkWV5eXpCfv/z117Q8FRYUCASqq2tUnwRPZagskWsSj6f5nbVrLWH56Dgz 6z25V1d3tKRk0uTJch/nqQAOftSi9plqOx85Mkv73abazh+b/PiXrrxS4+UagNpI bDab3xfKd2U11de/8dZbco8fl3P87dZVnP4FwkHkHX8DxpCenqbZw0tDKOQB3NnZ 6fF4QjjQJIIngXfn5y9esqShsUGXdVBhUFtb19PTM2TIYLmNmUfvhqfgbcDFRUUz Zs50ij2QvLq6uqfHN2TIkMxMTa95PtkFF170zNNPswUOQO8TsMrLQzszcgNYbcz1 9frsqwGcggAG9DF06NCEhITIuhl4kEAAd3R0NDc3h3CgeQRfsFmyf/+TT021Wq16 rYbKYPWtXJz8+Mc/uf3224WG43yoBt5TULBmzZr8XTuFFiG9dZ2T0+lc+caboyLw w0rdqc2jyemsqa4O7dgIDeDKSkdLS0torwYHMGAEMKCb4cOHWSzJmZkZeq9IP9xw w42PP/54CAe2t7erw4IQDjSP4EngkoMH165du6tgl96rIyIQCMyaPefCCy7Qe0Vw Bm6Pp9LhOLhv3wuLF0XiDR19cdNN/33nnXdy+ncA1OZRXV3d1dkZ2rHOhoa33n77 8JHS0I4VZbPZOzp48jMQRoz5FQuIFKmp1lGjIulm4JAH8PFHCreGcKCpBO/DLD14 cPbcObLv2dSJ+q3x1ltvkx/hKXgV9L6CgomPTYoZOlTv1Qk9teG9uGQp958PTO/n I3Z7T09PaMdGXAAHAoGqqqqTnxoIQHcRc9gNGFVGRnpmZmakNHDIA1jVr2rgEA40 FVUgnuZmh8NRtGfPtKefzsrK1HuNQuzqq6+eMOFRvdcCZ1O4Z8+cuXPLbRV6r0iI 1dbWLVmy5HOf+xyfvwyMxA3AgyItgFX91qotqa5e7xUB8AmRccwNGFsENfB///fN EyZMCOHAlpaW9pC+JdJsghdCHywqWrNmzd7CfXqvTojdf/8D119/vd5rgU+lNr+S 4uLt27atfPMNvdclxL7znRvuuusu6ndggi94rw71DcCKq7Fx1Zo1cm+fDiHqFwhb EXDADZiBauCMDN0ec9p3N9/8g0ceeSSEA5ubmzs6OkI40ISCF0IfKS6eO29ejy/E FxzqyOlyr1u3LtkSkW/MNoneba+2Vm17j06ebLWm6L06ITN8+IiFixZx8fOACd0A POh4AK9es+Zg2Aew3++v60X9AuGIAAbChdVqjR0xwpqq2+N8+yLkAezxeDoFDpJM JXghdE1tbdGe3f+eMTNZ7KWsGuMFSOFPm5chaczjaV6ydOmY0aPZ9gZM6AbgQRES wHa7PSoqmlf+AmGLAAbCyPDhw+LjE7KzR+m9Ip8q5AHscrl4M8T5CzbwsWPH8jZv Xvvu+vC/lKAvbrvtF7fddpvea4FzUNve3j171q1bl7ctT+91CQG/3/+/d//l29/6 FvV7PoRuAB4UCQHscFS1trbwzGcgnBHAQHiJj4+LjY3LygrTW4J/8pOf3nfffSEc 6HQ61QF0CAeaVvBm4AOFhW+88UbxoRK9V+d8qQ55/oWF2aPC98MgBPW+j7q6urio aN6C+Qb45OWr11137/h7qd/zIfQG4CCP07lu/frwfN5BIBCoqaltb29rbeXJjkBY C8cjbACpqdZAYNDo0dl6r8ipQh7ATU1NEpfJmVPwZuDy0tKly5Y1NjXqvTrnJTY2 9pVXXqVDwl/wKuiiPXuemDrF7/frvTrnZdSo7GnTp3Pr73nq/Uykqqq7S+QUaNgG cGWlIypqEK87AiICAQyEqREjRiQmJqSnpw8ePFjvdflYyAO4sbHR5/OFcKCZBS+E bmhsLD14cP7zz3t7IvjU+je/+a2//e1veq8F+kRteDu2bVuxcmVJJF96MCI2bu7c uckWCx+7nCcVwHabTWjHHoYBrH6m9fX1zc0tPNARiBQEMBDWrFbr4MHRWVlZYXJF 9M9+9vN77703hAMbGhoi/axRWAk2sDoaO1BYOOe5uUOHDtV7jQYiEAg88eSUL1x+ ud4rgj5RwVNRUbFn585XXlseJnuq/lIN88LCRRnp6dTveVK7IJfbXeVwCM1XAbz+ 3Xf37NsrNL9fjl/zXOPz+XneFRBZIvILFWA2qalWdVg5Kgzuh/zVr/7v3XffHcKB KtXUMUQIByLYwLW1tfv37p07f97w4cP1XqN+8wcCq1etJkUiRfAq6L27dj362KRh w4bpvTr9ptZ/3vwFo7Oz2eTOX/DNWB1ib3dvdrs3vPfezt0FQvP7rqqqSn3x4ppn IBIRwEDEsFp7M1jfZ0SHPIDr6upCOA1BH74YqaZGNfCcefNiY0fovUb9c/XVV0+Y 8Kjea4H+KdqzZ/bcueW2Cr1XpH86O7vmL1iQM2YM9RsSvS9AqqzsEXu0YTgEsMPR m76c9QUiFwEMRJjjZ4OjR47U56JoAjhSnNzAzy2YH1nngVX9qgbWey3QD2p7O3zo 0M78/FdfW673uvRDt9f73HPzqN8QcrndtooKuet6dAxg9ZOqrq4JBPyc9QUiHQEM RCSr1aq+HMfEDM3MzNByub/+9R133XVXCAcSwHI+vBa6ru5gYeELixbqvTp91dra umr1Gp7EG1mCTyA/WlLy+JNPJCQm6r06fTJ4yJCZM2eNGjmS+g0V0RcgBbV4PJs2 bty+M19uEaez2ezR0eqAOYqzvoAxEMBABBs+fFhcXHxU1KDsbI1emPTb3/5OCeFA AljUh8+Fbmg4fPDgi0uXtIndmBdCn/v855+a+hRNElmCtwGrzWzuc89V19bovTrn ZrFY/vX0M6lWK1taCIm+AClIBfDmzZvztm+TW8TJHA5HIDCora21s1PwJwVAYwQw YASpqVa/PzB0qPgJYQI44gQbuLGxsdpuf2nZssoqR5g/p/fuu/9yww036L0W6De1 pR3Yv/+DLVvWrH1H73U5m0AgcOGFF0149FFLUhL1G1rB54EHJB/sr00A22x2tZ+M jo7iamfAkML6MAhAvwwdGpOYmKi+bI8cOVIocgjgSBQ8OxcXG+uorHx+wfy3V6/R +Mr5vmtqalr/7nvJFoveK4J+Cz7+90hJyYRJE1NTU/VenTOrq6u/997xN373e+q3 A/UbWmo/43S5qquqRJciGsDH7/KtVt82Nzd3d0fwe9QBnB0BDBhQWlqq0DuTCOCI phKlrKxsd37+i0uXxsbF6r06ZzB6TM6smTMpk0gU/JyluKhoxsyZTrdL79U5g46O zmf+/e/LL7tM7xUxJrV7UfXY1dkpuhTRAK6qqmpoaJSYDCCsEMCAASUnJ+fkjJGY TABHtODl0PUNDeWlpYuXLHF73OF2OfSdd/72lltu0XstMEBqAysqLNywYcPGTRv1 XpdPCAQCo0ZlT5w0KT0tjY9XhKgAtlVU+CWvfx4kHMA2m93lCsfPbgCEVngd+gAI CQIYnyZ4mk4dpJYUF7+3fv3qd95JSUnWe6U+1NDQuG79+tTeJ5wjIqkEqqmtLT14 cIJKzfQ0vVfnQ06n669//et3briBy57laHP98yACGEAoEMCAARHAOLsP35BUW3vk 0P9n7z4AJK3KfP93zqFC51A9wwwzhEFQFxTDrrJ/wuoaEBcQVxEDe1nD4t27ot57 XS8qO+IKCIIkQUCERWAlzBBmGEkDk5jADGFSh8o5d+XwP9U1Ns3EDu+pt8L3AxTV PT3Pe7q6u+r99Tnvc96+/w9/CIVDxTAVPDg4dOuttxJRStf0Kugbb7rJHwyoPZzc xG93T+9PfvKTocFBvq+kKkD/5zwCMICFU/+MB4DiCMA4pump4L179z6/bt0zzz7T 0NCg7pC+9rWv/8M//IO6Y8ACie+rHdu3r1275vkXXlB9JP/6r//rQx/+MBO/BVCA /s95BGAAC0cABsoQARizNL1JktNme+SRR8RppVr9ex0O57Nr1nQXa/dgzFJuFbTN tufNN3989dW9KjUbF9/Pn/rUp//5m99ko6PCyK1/9nqtVmsBjkUABrBwBGCgDBGA MXvTU8F2u904NvbIo49seW1rb29PgYfRPzB4+223EVdKXf7b6Y0dO351003BULDA R3c4nH/7t2d993/+a6vAxG+h+AMBs9mcTCQKcCwCMICFIwADZYgAjLmajsFWm218 796HH31k+47XC7ld8GWXffWiiy4q2OEgj/he2r5t29o1a1546cWCHdRud3zkox/5 3veu6ujoIPoWkvhy5y4ANpuz2WwBDkcABrBwBGCgDBGAMT/TMdhmt5vGxv70pz9t 3b69AG2iRXpZs3Yt65/LQ34V9O433vj3q6/u7++TfTiv1/fxj3/829/5TltbG9G3 8MSX2+5wRCcnC3M4AjCAhSMAA2VIXgC+7LKvfuc731GwIAG4CE3HYPHVcdhsjz/+ +PYd26W2yOrr67/jjjuILuVhehX0DTfeGAqH5B0okUj87d/+f1//xjcaGxuJvmoR AdhkMqWSycIcLuj3r1u3buPmTTKKE4CBCkEABsqQTqc1GKQE4Esv/cqVV16pYEEC cNGajsFOlysZi23ZvPmpp5/es3evjHXRX/7ypZdcconiZaGW3CrorVufffbZl9a/ rHhxu91x2mmn/f2nP33Wxz9eU1ND9FWR+EL7/H6L2VywI4oA/NzatZte2yKjuNFo 9HoJwED5IwADZUin0xkMwzIqX3zxF6666ioFCxKAi1w+BouMIW6tVqvL4VizZs2W LZsz2azIHoocwmazP7tmTW9PodtuQR5/IGC12Xbv2vXjn/xEqVXQmUymob7hQx/5 yGWXXdal1+e/LYm+6sp9oa3WeCxWsCMGvN5nnn12247tMoobjSav1yujMoCiQgAG ypC8GeCLLrr4+9//voIFCcClYmYSNplMo3v3Pv/88zt27qyvr6uuXtBLSU9v7913 3V1bW6vUUKG6A6ugt2+//sZfhRd2dWg2m02nM6effvpXLrvsuMWLyb1Fxef3Gycm MvK3/50mOQAzAwxUBAIwUIbkzQCff/7nfvSjHylVTZzaOp1OpaqhMA5KwhOjoy+/ /PKO119PpVPzC7H/+I9f+sd//EfFxwl1ie+Tba+99swzT69/9dV5/PV0Ot3Y2PRX p5/+hS98gdxbnMSX2OP12gqy/e80n9u9+qmndr35hozizAADFYIADJQheQH4M5/5 7I9//GOlqmUyGZfLpVQ1FNi7VkfbbF63+7XNm7a8tnV0bKytrXWW08Ii5/zunnsH BwZkjxYFll8c++bOnbfdcfssfzOSzWaj0diSJUtOP+P088//HOuci1xu+1+TKVmo 9ld5IgCvWr36jbfelFGcAAxUCAIwUIbkBeDzzvu7//iP/1Cqmgg/brdbqWpQy3QS FkFFnBNPTEyM7d+/Y/v2N99+W5wft7W3HSUM6/X63/3uHhJO+RHfFaFweMPLL9/x 2zujR75GNBd6I9Gh4eETTzrps5/97CkrVsz8dirkgDEnhW9/led1uR5/4onde/fI KE4ABioEARgoQ/IC8Lnnnrdy5UqlqolTKM42ysxBYdhkMtksltd3bH/zrbeMJpPb 7ZnZRLqrq/vCiy769Kc+peKAIY/4Bti1a9f6l17auXOn2/POr7rsdsdAf9/g0NCJ J5706c98ZumSJYTeklP49ld5IgA/9vjje/btlVGcAAxUCAIwUIbkBeCPf/ys6667 Tqlq8Xjc7/crVQ3F5qAwbLfbU4nE6P7927Zt27N3TzAUuvt393R2dJB5ypX4BggE g26PZ3T37pt/c8vQ0LDwnlNP/ehf/7VWoyH0li7xtRM/0RazOZvNFvjQHqfz0f/+ 79HxMRnFCcBAhSAAA2VIr9eJE00ZlT/2sY9df/0NSlWLxWKBQECpaihmB6Udwk+F 4OtelvK/z4pGIoU/tAjAjzz66NjEuIziJpPJ4yEAA+WPAAyUIXkB+EMf+vDNN9+s VLVIJBIKhZSqBgAoABGAjRMT6XS68Id22+0PPfKwSc61xwRgoEIQgIEyJC8An376 6bfffodS1SYnJ8PhsFLVAACyqbL70TSXzfbgQw9Z7TYZxQnAQIUgAANlSK/XDw8P yai8YsUp9913n1LVQqFQRI1FdACA+ck1tzMaU6mUKkd3WK333X+/x+uRUdxkMns8 UioDKCoEYKAMyQvAS5ce/8c//lGpaoFAIFbwJqIAgPnJte73+awWi1oDsJvNd997 bzAUlFGcAAxUCAIwUIbkBWCDwfDYY48rVc3n8yUSCaWqAQCk8gcCZpNJxGC1BmAz me68+65INCqjOAEYqBAEYKAMyQvAPT29zzzzjFLVvF6viidSAIDZE0/XPp/Pot70 r2A1mX5z222ptJQF2ARgoEIQgIEy1NWlHxqSEoA7OjpeeOFFpaq5XK5MJqNUNQCA PLnpX7M5qeqyHYvReNPNN1fXSDl9FZ+d200ABsofARgoQ/JmgBsbmzZs2KBUNafT mc1mlaoGAJAkN/3r91vk7D80e+aJiet/9auGxgYZxZkBBioEARgoQ/JmgKurq7du 3aZUNYfDoVQpAIA8xTD9K5jGx//z+utaWlpkFGcGGKgQBGCgDMmbAY7HE2+++aZS 1QjAAFD8iuHq3zzT2Ng1116r0XRKKc4MMFAZCMBAGZIXgAOB4OjoqFLVCMAAUPxU b/48zTg6evU113R3d8koTgAGKgQBGChDer1ueHhYRmWn06XgJAABGACKnOp7/840 MTr671df3d/fJ6O4yWTyeLwyKgMoKgRgoAzJC8DZbHbr1m01NTWKVCMAA0CR8wcC JqMxlZKy89CciDHYLZZf/+aW6mopp68EYKBCEICBMtTX1ytIOkVYtWr1wMCAIqUI wABQzJLJpMfrtVmtag8kJ5tOi5HcdMvNUopns+IlyW7nVQkofwRgoDz15fTKqHzr rbd94AMfUKQUARgAipZIv/5AwGq1ZtJptceSIwLw/n37fvu7u2UUn5gw+nw+GZUB FBsCMFCeDMNDOr1eRuWf/eyaT3ziE4qUIgADQNES6ddms8WiUbUHckAykdj1+usP PfKwjOJjY2OBQFBGZQDFhgAMlCeNpnPRokUyKv+v//VvX/ziFxUpRQAGgOKUn/61 mM3ZbFbtsRwQi0Q2b9q0+pmnZRQfHx/3+wMyKgMoNgRgoDxpNJpFi0ZkVP7a177+ rW99S5FSBGAAKE659GuxJOJxtQfyjnAw+NJLL7348ksyio+PT/j9fhmVARQbAjBQ nrRa7ciIQUbliy/+wlVXXaVIKQIwABShotr6aFrA612zdu1r27bKKM41wEDlIAAD 5Umn0xoMUgLwpz716auvvnrhdbLZrNPpXHgdAICCRPoNBINWqzVdBFsfzeRzu59c terNt9+SUdxoNHq9BGCgIhCAgfKk0+kMBilbAX/sYx+7/vobFl6HAAwARcgfCNjt 9mgkovZADuZxOB757/8emxiXUdxoNHm9bAIMVAQCMFCe9Hrd8LCUAPy+973vt7+9 a+F1CMAAUGyKsPfVNKfN9sCDD9qdUq6dMZlMHg8BGKgIBGCgPOn1+uHhIRmVlyxZ +vDDCuxCQQAGgKKSX/xst9uTiYTaYzkMu9l89733BkNSNisymcwej0dGZQDFhgAM lCd5Abinp/eZZ55RpBRNsACgePgDAfG0HJmcVHsgh2c1mX5z222ptJQrkwnAQOUg AAPlSV4AbmpqfvXVVxUpRQAGgCJRzIuf88wTEzfceGN9Q72M4gRgoHIQgIHyJC8A J5OpXbt2KVKKAAwAxaDIFz/nGcfGfv6LX3R0dsgoTgAGKgcBGChP8gKw3+8fGxtX pBQBGACKQa7zs8MRLdbFz3kiAF/9s592d3fLKE4ABioHARgoT/ICcDab3b59hyKl CMAAoLpkMunz+60WS9EufhZSqZTTZrvx5l9XV0s5dyUAA5WDAAyUJ61WOzJikFR8 1arVAwMDC69DAAYAdeUXP9tstlQyqfZYjiabTtus1ptuuVlS/YkJo8/nk1QcQFEh AANl65RTVtTW1sqofMstvznzzDMXXsfpdBbzhAMAlD1/ICDSbywaVXsgxyAC8L69 e++653cyiqfT6Z07leltAaD4EYCBsmUwGHQ6rYzK//7vP/7sZz+78Dput1ucdiy8 DgBgHpLJpNfns1osag/k2JLx+PZt2x597E8yihuNJq/XK6MygCJEAAbKlkbTuWjR IhmVr7jiny+//PKF1/H7/fF4fOF1AABzld/3SKTfTCaj9liOLRIOv7J+/XPP/1lG 8fHxcb8/IKMygCJEAAbKllarGRkZkVH5kku++G//9m8LrxMOhyeLu+koAJSlUrn0 d1rQ51uzdu2Wra/JKD4xMeHz+WVUBlCECMBA2ZLXB+vv/u4T11xzzcLrxGKxQIBf ugNAoZXKpb/TvC7X408+uXvPbhnF6YAFVBQCMFC2dDqdwTAso/IHP/jB3/zm1oXX SafTbrd74XUAALOXTCY9Xq/NalV7IHPgstsf+uNDZjlj5hpgoKIQgIGypdfrhoel BODly0948MEHFSnFTkgAUEglsevvoewWyz333ecPSFmobDKZPB4CMFApCMBA2dLr 9cPDQzIq9/X1P/XUU4qUIgADQMEcaHxltWZKrQO/1WS67Y47EsmEjOImk9nj8cio DKAIEYCBsiUvADc3t7zyyiuKlGInJAAojHz6tdvtpdL4aibzxMQNN91UX18nozgB GKgoBGCgbHV16YeGpATgcHhy7969ipQKBoPR0unCAgAlKt/22eFwJEpz8znj2NjP Vq6UtLm92Wx2uwnAQKUgAANlS94McCaT2bHjdUVKxeNxv5/NJwBAonz6dblcJdT2 +SATo6O33HZrTU2NjOLMAAMVhQAMlC15ATibzb722tba2lpFqnEZMABIlVv57HBE S3bfdfGiM75//2133lFdLeXElQAMVBQCMFC25HWBFucizz67pqenR5FqBGAAkKcU Nz06SDwWGx8dvfvee6QFYLpAAxWEAAyUs1NOWaHUPO1BVq1aPTAwoEgpr9ebLMGO LABQ/MSzq9fns4r0W1KbHh0km06LAH/TLTfLKJ5Op3fu3CWjMoDiRAAGypa8JdDC //7f/+fzn/+8IqVisVggEFCkFABgWm7L36n0W1pb/h4qEYttfe21x558QlJ9lkAD FYUADJQtvV43NDQkacHYhRde9IMf/ECpaqyCBgBl5dKv359Lv5mM2mNZqIDX++ya NVu3b5NRPJvNms1mlkADlYMADJSzxYsXd3Z2yKj8/ve//847f6tUNZfLlSn9UzQA KBL59GuzWsvjqdVpsz3wXw/a5fyq1Gg0eb2kX6CCEICBcqbVakdGDDIq6/Vda9eu VapaOByeLNn2pABQVMos/QoWk+mWW2/NZNIyik9MGH0+n4zKAIoTARgoZzqdzmCQ 0gh6cjKyZ88epapls1mn06lUNQCoWOWXfgXj2Ng1K1dqdVopxZkBBioMARgoZ1K3 AlZwJyRBBOBSb9MCAOoqy/SbiMeN4+N33n0XmwADUAQBGChnUhtB/9//+6PPfe5z SlVjFTQALERZpl8hEg5v3779iVVPSqpPAAYqDQEYKGc6nXZ4eFjSb83PP/9zP/rR jxQsSC9oAJifAzse2Wxl0PP5IH6P56mnn359104ZxbPZrMlk8nq5BhioIARgoMyN GAySrps68cST/vCHPyhY0OPxpFIpBQsCQCUQ6dfr89lKf7/fw3JYLPf+/vdev5SM ygXAQAUiAANlTl4j6Pr6+k2bNitYMB6P+/1+BQsCQHkT0XcyEonHYjabrSzTr2Ce mLj+Vzc0NDbKKE4LaKACEYCBMqfX64aHpTSCTqfTIgA3NTUpWJNV0AAwSyL9BoJB j8cTKd8GCqlUymY233TLzbW1tTLqm0wmj4cZYKCyEICBMie1D9a11/7i7LPPVrAg rbAAYDby6dfldsciEbXHIlE8Gn3jjTf++MjDkurTAQuoQARgoMxJDcD/8A8X/vCH P1S2JpPAAHB0+fTrdDrjsZjaY5Er4PU+8+yz23Zsl1SfAAxUIAIwUOb0et3g4GBN TY2M4suXn/Dggw8qW9Pv98fjcWVrAkDZEOnXHwg4HI5kIqH2WKSzWyz33HefPyCl PUQmk7FYLCyBBioNARgof/ImgbPZqu3bFf7FfDabdTqdytYEgPKQT782my1dGT3z TePj/3nddS2tLVKKM/0LVCQCMFD+dDqtwSClEbQIq88+u6anp0fZsl6vV5zkKVsT AEpdbrNfv99mtWbKbrPfw0rE48bx8TvvvkvSbvZGo5EdgIEKRAAGyp/Uy4C//e3v fPWrX1W2ZjqddrvdytYEgNKV3+4oFovZy3e7o0MFA4GNG15d9/zzkuozAwxUJgIw UP6kBuAzzjjjtttuV7ysOClJVcYCPwA4ugMNn12uWDSq9lgKymW3P/THh8xWq6T6 BGCgMhGAgfKn0+lEAJa0hKy+vn7Tps2Kl2USGACqKqzl1UHMExPX/+qGhsZGGcWz 2awIwF4vHbCAikMABiqCzD5Y2aeeerq/v1/xykwCA6hw+Yt+7XZ7hbS8mikej0+M jt51z+8k/faW6V+gYhGAgYqg0+kMhmFJxS+//PIrrvhnxcsyCQygYlXmRb8z+b3e 9a+sf3n9ekn1jUYT079AZSIAAxVB6mXAJ5xw4gMPPCCjMu2gAVSgir3odyaHxXLv 73/v9cvq0swMMFCxCMBARdDrdcPDsmaAA4HA22/vbmhoULwyewIDqDT5i37tdnuq gn/9l0ql7BbL1T/9qb5LL+kQJpPJ42EGGKhEBGCgUgwODnR3d0sq/oMf/PDCCy+U Udnv98fjcRmVAaCo5Jc9i2c8u81WITv9Hkk4FNq2devqp5+SVJ8dgIFKRgAGKoVO pzUYDJKKv//977/zzt9KKu5wOCRVBoAiwbLnmVw224MPPWS12yTVJwADlYwADFQK qZcBRyLRnTt3ylgFLYRCoUgkIqMyABQDlj3PlEqlbGbzNStXarQaSYfgAmCgkhGA gUohNQALV1753UsvvVRScSaBAZSld7o92+3Zyl72PC0UDG7auHHtuufkHYIADFQy AjBQQUYMBq1OK6n40NDQE088Kal4NBoNBoOSigOAKvITv06nM0GngxlsZvNv775r UtrCHzZAAiocARioIFIvA85kMmvWrO3p6ZFU3+VyVXhXGABlIz/xK3Kv3W5Pp9Nq D6eIxGOxsf377773npqaGkmH4AJgoMIRgIEK0tWlHxqSuAr6M5/57I9//GNJxVOp FCvWAJSB/MSv2+2m39WhXHb76qeffnv32/IOYTab3W5eTYDKRQAGKohOpxsaGpT3 a/V4PLF9+3ZJrbAEr9ebpEMMgJJ1YOI3kXDY7alUSu3hFJ389r8rr722vaNd0iEy mYzZbGEJNFDJCMBAZenu7hocHJRX//LLL7/iin+WV59uWABKVH6jo/zEbzabVXs4 xcjv9a5/Zf3L69fLO4TFYnG53PLqAyh+BGCgssjuBV1XV/fKK6/W19dLqh8Ohycn JyUVBwAZ3pn4dTjY6OhIUqmUw2q9/lc31EtbRlRF/2cABGCg0ogAPDQ0WF0t8Wf/ 29/+zle/+lV59Z1OJ5MnAEoFE7+zFAwENm54dd3zz8s7hHj8zWYLARiocARgoOJ0 dXWJDCyvfk1NzZYtr8nL2OJsksu3ABQ/rvidvfzVv7+84fqmpiZ5RxHp1+1m/TNQ 6QjAQMWRvQpa+PKXL/3ud78rrz7dsAAUOVo9z4nX7X5u3XNbt22TehTWPwOoIgAD FairSz8wMCCvF7QQDAa3bdve0dEh7xB0wwJQnPITv/F43MEev7MjHivT+Pi1//mf +i69vKNkMhmr1coGSAAIwEAl6u7uHhwckHqIk09e8fvf/15e/UgkEgqF5NUHgHnI T/w6nc5EPK72WEqG1WS6/4EHvD6517ZYLFaXyyX1EABKAgEYqERdXfqhIbmroLPZ 7MqVPz/vvPPkHUKcymQyGXn1AWD28hO/sVjMYbfz1DR76WTy1VdffXL1KqndGaty FwCbmf4FUEUABirWiMGg1WmlHiKRSG7atKm1tVVS/XQ6TTsTAKqbbnbldDhoTzAn 4kEzT0xcd8MN7R3tUg9kNJrongggjwAMVCi9Xjc8PCz7KMcfv+yhhx6SVz8QCMRi MXn1AeDoaHY1b/nOz/f94f5gMCj7WCaTyeMhAAPIIQADFaoAGwLnXXjhRT/4wQ/k 1WdbYACqONDsKhazs+Z5XjxO57Nr1ry+a6fsA7H9L4CZCMBA5SpAK6yqqcabv/jF f55zzjmS6icSCZ/PJ6k4ABzqnQ1+HY4Ua57nJZNKvfrqq48/+YTULQnyaH8FYCYC MFC5CtAKKy8YCD63bt2iRYsk1RcBWJyJSioOANPy0VfcikAV5/qL+aqtqdn99tvX /uIXUvc9mkb7KwAzEYCBitbV1TU0NFiAA6XTmXXr1onDSarPtsAAZBO5NxAMuj2e WCTClRfzFotGJ8bGfv2b37S1yWqROJPZbKFdIoCZCMBARdPr9cPDhZgEFurrG557 7rn2dimtPmOxWCAQkFEZAA6seY7HbXZ7Jp1WezglTDyG4/v333rnnY2NDYU5oslk 5upfADMRgIFKV7CF0EJDQ8PTTz+j1UrZfsnr9bIBCQBlHVjznEjYudx3weKx2Oi+ fXfefZd4LSjMEVn8DOBQBGCg0hUyAE+pXr16dX9/v4zSLIQGoJTpy32dTmciHld7 OCUvGons3bPnt3ff3dLSXLCDEoABHIoADKCqu7trcLAQVwLnRSPRxx5/fPny5cpX jkYLsJ8kgLKXv9zX5XKxu68ixOnmls2b77zrLo2ms2AHtVgsLhdX/wI4GAEYQOH2 BJ7mdnuuv/76z3/+84pX9ng8qVRK8bIAKkR+4jcWi9lstio6XSkhGY+/8MILf3jw wd7enoIdlL1/ARwJARhATk9P98CA9D2BZxJnJ+edd97KlT9XvDILoQHMQz76xuNx u82WyWTUHk45SKVSPrf7sSce37d/fyF/xypYrVank71/ARwGARhAjk6nGxwcqK2t LfBxe3p6H3jgAXF0BWtGIpFQKKRgQQDlbbrTlc1mS9PkWSGxWGx8//4/PPhgMlXo 5mHii2ixWL1eb4GPC6AkEIABHNDb2yOpN9XRhcOTK1euvOCCCxSsyUJoALMx3enK 7XbHYzF291VKMh5/5plnnly1SquT0vb/6Gw2m8PhLPxxAZQEAjCAA5qbm1taWgq2 LfBM4qTzxBNPuu66X3Z1ddfX1ytSk4XQAI4kn3vFnUQi4XK5kokE0Vcp4iE1T0w8 /OijXp+3wMue80wmcyQSidK9DMAREIABvKPw3bBm8np93/ve9775zW8qUo2F0AAO NT3l6/F6k/E4S0UUJB7McDC4Zs2atevW6dSY+K2i9xWAWSAAA3iXnp6egQEVFkJP 02q11177i7/6q79aeCmvOMFNFvraMwDFKR99E4mE2+0Wt1naXClKnFC+sn79qtWr 0qo+sFarzelk8TOAoyEAA3iXhob69vYOVRZCT8tkMiefdPKvbryxu7t7gaVYCA1U uOnVzrFYzO1y8UsxxcWi0YnR0ceefNLj9dTU1Kg4EpPJHAoFEwm+xACOhgAM4GB6 vX5wcEDd85iqqS4mF1xwwU9/+jOtdv5L6aLRaDAYVHBUAErFzAZXiXicnY0UF4/F zCbT4088vmPHjv7CbqR3KPH1tVisLH4GcEwEYACHoVZH6EM5HM7zzz//Bz/4wdDQ PCelWQgNVJTpKd94PJ5vcKX2iMpQNBod37//mWef3bFzZ19fr9rDyaHzM4BZIgAD OLyenu4BtX+jPy2dTp94wolXff/7S5cubW5unmunaBZCA5Vg5pSvyL3s6CtDTXX1 5k2bnn722UDAX/it44/EarU6nS61RwGgNBCAARxeY2NjW1ubuhcDHySbzYro+z/+ x//46le/NqdW1bFYLBAIyBsYABUx5VsAqVRqMhx+/s9/3rRlczqdVmuzgMMymczh cFh89dUeCIDSUETPXwCKjcjAWq22SJa3zRQKhf/+7z/5rW99e+nSpbP8Kz6fL8Fp MVBe3nWVbyKRYcpXgkgksn/v3udfeOGtt97q1HSqPZyDTUwYxQhJvwBmjwAM4GiK pCHWYWWz2daW1n8UvvQlcf+YS6NZCA2Uh3zuFT/1IvbQ2FmSZCLh9Xr//Oc/79ix PSvOF4tpyncaja8AzEMxPp0BKCrF0xDrSGw2+wknnHDZZZddfPHF4oT4SElY/JHf 7y/88AAoYnqpM3v5ypNKpcKh0PqXXtqybdvY2Fh/f5/aIzoaGl8BmAcCMIBj6+np GRgo6gycJ86Eli9ffskll3zpS19qamo69AMCgUAsFiv8wADM23TuFXc8Ho/IvelU Su1BlRvx2Ab8/ldefnnHzp3j4+M9vT1qj+jYrFab00n6BTBnBGAAs1IqGTgvk8mI Z7cLL7zo8n/6p87Ozmg0Oj0tLE6Ystms2gMEcGzTl/jmNzOju5Xi4vG4zWJZ9+c/ 79y5s6GxoTivdjks0i+AeSMAA5itotoYaZZE1g0EgqeccsqVV1551llnVU0tnvT5 fGqPC8ARzezqnN/QiF9aKSiVSqWTye3btj3/4otjY2MaraY4r+89CjY9ArAQJfaU B0BdpZiBp6XT6ebm5osuuvgTn/iEVqvNn2S3trTMdVdhADIcdImveJOuzgqKRaMW s3nDhg07dr4u3iyeLXznivQLYIEIwADmprTWQh9WNpv1eX1Lli79wAc+8JnPfnbx okXTZ97kYaDAZl7i6/Z4klziq5zcxshO55bNm17fuctkNuv1upKb7D0IK58BLFxp Pw8CUEUZZOBpIgyHgsHFxy1ZtmzZ33zsY6eddpqms5PJYUC2g1pbidsUuxktWCqV qs5mJyYmNm/ZvG/ffpPZpNGU3grnIyH9AlBEmTwnAiiw3t6evr6+sjmvmub1eBcJ ixe/933vO/vss7v0eiaHAWUd3NpK5F4u8V0A8QDGopGdO15/4803TRaLw27X6XVq D0ph2WzWbrez4xEARZTbySuAghEZuLe3t4S6hs5VOp2uylYNDA4YDCNnfvjDHzrz TE1nZ9VfTt/Jw8Cc5H9wRJLJt7ZKJZO0tpqfVCqVTaf37Nnz+s6dRqPR4XDU1deV 7jW9x5TJZBw5pF8AyiAAA5g/vV7f0tys79KrPZBCEKdfvT09w8NDhpGRE09e8bG/ +ZsufUV84sBCTOfehMi9U5f4knvnKrcDVCz21ttv79m922wxO10ur9fXWwpb9S6c SPjV1TUej0ftgQAoHwRgAAvS2NjQ3t4+NDSk9kAKLTNl6dLjly1bduqpp55++ukd HR1qDwooFgdvZZRMZjMZtQdVMhKJRNDv37Vr1/79+602m8fjbmxqKuPlNkdiNptD oVA8zv7PAJREAAawUA0NDRpNZ+luj6SIbDYbiUQHBwcNhuHFi49bsWLF+973vtbW VrXHBRTUQbk3lUxmyL3HIuLuZCj01ltvjY6N2e128bj5/H5tCW7Pqyyr1er3B8SD o/ZAAJSbin5uBaCg3t6e/v4yaQ2tCBGJo9GYiMTDw0NLlixdvny5SMVdXV1qjwtQ 3jtb+P5lnTO597BSqVRtdbXH49m9e/fExITVZhNx1+/3ayo+7h7EZrNx0S8ASXi2 BaAMvV4vkp7aoyh2Pp+vp6e3v79fBOPFixefcMIJIhW3tLSoPS5gPt7JvYlEfp1z Jp1We1DFoq6+XsTdoNe7d9++8fFxu93m9nhF1g2FQ93d3WqPrtiZTGau+wUgCQEY gDIIwPOTzWbD4cm+vt7u7twUusFgEMF4+fLlTKejaL0r93o8qUQiXdm5VwTdmupq p9OZu2TXYnG6nF6fPxDwB4MhnU7L1O48EIAByMOTMgBlEICV5XA4xEMqUnFvb+/g 4ODQ0NCiRYuOP35pVxdzR1DHzNzrmVrnXJm51+/352Z0bTaz2ex2uwOBQDAUnAyH +yu7D4KyCMAA5CEAA1AGAbgwMplMKBTWaDQ6nU5kY4PBsGTJkqVLlx533HGNjY1q jw5l6ODcm0ymUym1ByWd+GStVquIuBaLxel0eL2+YDAYDosfvc4K7MZceARgAPIQ gAEogwCsrmw2K87RtVoRjbUiG3dN6evrGxoaNBhGhoaGOGvHnJR97s1kMi6Xy263 u3Lb6uauzs1doJsTDIXC3d1dLF1WEQEYgDw8uQNQRleXvgJ3Ay4V+XnjzimaKfmE nF9fPTw8LDKz2mNEUZjOvcmp63tLOvcGg0GHw+F2u/P5NhgMiJ8CEXDD4XAkEmEu t5hNLS8nAAOQggAMQBkE4JKWTqcjkWhHR0d7e7u4FTlZRGKtViu+rL29fQNT2Na4 jL2Te5PJfF+rVHHn3mg06p7i84lwG8jN2waDk38h8q34Xq6trVV7mJgnAjAAeQjA AJRBAC57+ZDc2trSfkBH51+ItDzVsiunq6uL4FEqii33ZjIZ/18EAoH8bG1eNBrJ J9tYLE64LXsEYADyEIABKIMAjLxsNutyuVtamtva2kVabm1tmyL+d2BuWdBq37lQ md5dhTcz9+av700lk5KOlUgkRJSdvrw2HJ7Mr0AWogeIOzFxG48nent7uPIWVQRg ADLxMgNAGTTBwvxkMhkRkBobm1paRFpumdI6dT93K6LzgenmDvHvgYXZGo2mvr5e 7YGXngXm3lQqNTUlGwoGQ5OT4anp2AM5NvaO3H3xjng8nkwmxNeL62wxDzTBAiAP ARiAMgjAKJhsNiticzAYbGhoaGpqEuF56nbqf1N3RHLO35+K081NTc1CPluLRD2d rsVtJQRpkVHdbrfIqYFAwGG3B0OhyOSkiKkioyYSifyd/P14PJZIJMX/p26nxUX0 1Wq1IsoyPYvCIAADkIdXMgDKIACjFOWztNfrq50iErWIeXV1tXV19eJNcb++vk6k vvr6hvzH19Xl3nS5XKqMtru7Wwx4+jLdZDIh3kwmU+JTSKfTqVQylUqL+yKzTr2Z 0ut1pFaUIgIwAHl4UQSgDAIwAEARBGAA8hCAASiDAAwAUAQBGIA8BGAAypAXgLPZ LGs4AaDYyHtyJgADkIdzSgDKkBeAQ6Hw3517zsZNm+OJOB1lAUBdmUymvr7hvaed uva5dRpNp4xDEIAByEMABqAMmQE4tG/f/mQyuW7Nmv966KHtr+9Ip9MkYQAoJJF7 q6urTzvtveeee65WqzWOjv505X+IZ34ZxyIAA5CHAAxAGTqdzmAYllFZxN3XX985 /aZIws+sXn3X7+4eHRtjaTQAyJbNZpcuPf6CCy4QuTf/nlQq5bBaf/Xrm2pra2Uc 0Wg0eb1eGZUBgHNHAMrQ6bQGg0FS8RdffKm9vX3me4LB4DPPPLNu7dpNW7aYzaaB gQFJhwaAymS1WoeGhv/mb/7mYx/7WENDw8w/qs5mXU7nL2+4XtKhjUaj1+uTVBxA hSMAA1DMqae+R9KU7L333nfKKafMfE8ymYxGo83NzeJ2y5YtmzZsWLdu3d59+zo1 nUwLA8D8ZLNZn89/wvLl55533kknnXTEj8tkRvfvv+Ou30oaw44dr8uoDABVBGAA ChocHOju7pZR+f/8n/97wQUXHPaPppNwfX19Kpl8bu3ahx56aOPmzbW1NVwnDACz kclk0qn0GR/4wDnnnKPRaI758YlYbNvWrX964nEZg2H6F4BUBGAAiuns7Fy8eJGM yl/5ymX/8i//MvuPDwaDz//5z6+sX79ly5Y9+/bp9ToZowKAkuZ2e5Ydf/yHP/KR M844o66ubvZ/MRQIvPjCCy+/+oqMUY2NjQcCARmVAaCKAAxAQRqNZtGiERmVzz33 vJUrV87+42dOC9us1g2vvPLkqlXbtm9LpdOSWrYAQElIp9N1tbXvfe/7PnjmmcPD 8+xc6HW5Hn/yyd17dis7trzx8Qm/3y+jMgBUEYABKEheH6wVK0657777FlgkNy38 /PObNmzY8fqOffv3NzY2crUwgEqQzWZjsdjSJUvf9/73z3Wy97AcVut999/v8UrZ qYgl0ACk4uQPgGL0et285xOOTqfTPffcugUWmTkt7PF4Hn/ssY0bNuzes2dsfFyr PfY1bwBQWnw+/6KRkZNXrPjoRz86myt7Z89iNN5y628y2ayCNaeZTCaPhz2QAMhC AAagGL1ePzw8JKNyODy5d+9eBQvObCK9YePGt3bt2rp169u7d1tttq4uvYIHAoBC crs9huGhZcuWn37GGccdd5ykoxjHxn62cqVOp5VR3GQyezxS5pYBoIoADEBB8gJw NptdtWr14OCg4pXzSVjUtzsc4l+3y2UaH9++ffvbu9+22ux0zwJQ/Dwe7/DQ0PLl y9//V3+1ZMkS2YeLxWITo6N333uPpKtICMAApCIAA1CMvAAsXHnldy+99FJJxaty 0yZujze36K61pWUyEhFh2ONy2azWN9944+3duy0WS2NTI/sqASgGmUwmHo8PDQ4d f/zx7zn11MWLFxfy6KFgcNPGjWvXPSepPgEYgFQEYACK0Wq1BsOwpDmBs87621/+ 8pcyKk8Tp1ypVKpqalpYZOCqqTBcX1/vDwSsNlvA631j166dO3eOjY87nE6NppMe WgAKI5vN+v2B3p5uw8iik0488b3ve19TU5Nag/E4nX967LF9o/tlFBefqdFo8vlo ggVAFs7eAChpZGREUkOp3t6+p59+WkblmVwuVyaTOeid+TycD8PiTZGHzRaL1+l8 ++23d+/ePWGcsNsdLa0tzA8DUIp4IopEor09PUNDQ0uWLj3ttNPa29vVHtQBVpPp 1ttvT6aSMoqL9Ov10gELgEQEYABK0mq1IyNSdkJyudz7p/YuklF8JqfTmT1qa9ND 87DNZotOThonJkQeNplMNrvd7XYHgsG+vl7ZowVQBuw2e2dnp16v7+npGRwcXLR4 8bJlyxoaGtQe12GkUimb2fyj//f/JD2/TUwYmf4FIBUBGICS5O2EJPzoR/9+/vnn Syo+k8PhmP0HH5SHq6Yisd3h8Pt8Qb/fYjFbTGaH0+Hx+rw+XyDgn5yMDAz0yxk4 gKJmtdpaW1s62jtE3NXptD09vf39/SOLFolbtYc2W9HJyW3btj2x6klJ9dkDCYBs BGAASpLaB+tDH/rwzTffLKn4TNls1ul0zvuvH3QJ8fT788E44PcnYjG322232cRt PhWHQuFQKDQ5GY7GYjqdjtXUQCnKZDI+n6+pqam5qbmtra1d/NvertFq9Dp9d3d3 30C/Xt+l9hgXyu1wPPzIIxMmo6T6dMACIBsBGICSpM4AV1fXbN26VVLxgywwAx/W kYLxtHxCDgWDIiTHY7HI5KTb4/F5vYFAIBwW7w7l/gmFI9FoMpnI52S73SHG2s+U MiCBzWavrq7u7e0Rydbr9TbUN7S0tLR3tHd2dHZ2dIh0q9FompubG5uaunt6DCMj ixctEj+V4ifd7XbH4/HsIQ0FyoBpfPyX11/f3NIsqz4zwAAkIwADUFhfjpRrw0Qo vfvu3733ve+VUfywh1M8Ax/ddEKuOnJInmk6MGfTaY/bbTKb7Xab2+3x+XzBKeHJ Sa1Ww3wycCQi2fr9gfa2to6O/LJkXW9Pj0ar7dBoli1btmTJEk1n59Er5H9sRZ10 Oi0Sr9vjSYjoe9Q+AqVLnDW+vmP7/Q88IKkHPhcAAygAAjAAhYnENTIyIqn4hz/8 kV//+teSih9KnMW6XK6iPZc9+pTyzBXXfp/ParOJz8Xr8fj/suI6PBmORCLd3d3s 54RyJX543W53bto2txi5vaOjXavVdXd1ibfEv0uPP/7EE088NOIec7HGoR+cSCTE z5eIvrI+k+Lgcjgefvhho9kkqf7ExITP55dUHADyOOkBoDCpq6AnJyNvv/12gac0 j9kXujjNZsW1zW73eb0iIYs87JhqXu3z+QLBYC4eh8OTU+KJOCEZRSgfbhsbGlun TOXb3CxuV5e+tbWtubV10eLFJ590kl6nO/TvziniHkm+SDwedzmd4v6CPplSkEql rCbTNStXanVaSYdg/TOAAuCEBoDCpPbBEr71rW9/7Wtfk1f/sA67P3Cpm00GyE0j i5Ds86WTybAIyU6nx+Px+/2hYO6S5MnJSFSIiX9y4olEf38/URkLIWKt3WZraGxs bmrOa2lpaWtr7cjp1Gm14m0RbhcvWrT8hBPEm4ctoki+PZLp4rFYTERfEQuVrV+0 /F7vy+vXr39lvbxD0AELQAFwmgJAYTqddnBwsLa2VlL99vb2F198SVLxoxCnZZVz pjtt9kEiP5/scbuT8bgIw56pyeRgMBDMLbUOR6K5f6KxA8QdUbm7u4vrkytBJpNx u9z1DSLVNjbU14tA2zr1n/inderiW42ms7GxqaGpadhgOPmkk7r0+qNUkxpujy5/ aHHrmVo3kU6nC3l0dYlnP4fN9uubb5Z35igeT4vF4vVyDTAAuQjAAJQngo3IwPLq X331Tz71qU/Jq38kfr8/Xu7X+M3bnGLJdPuuYCCQTuV4vV7x8Io3c6uuI5H8lLLI yfEccZuYuhNPpdN9fb1MMqslm806HM7a2tpGkWabmppEnm1orBNvNubeyi9Cbp/q jSzibl1dnVarHRgaWnLccfnrbMXXXSSc3t7eQyOuirF2Nqajr9vtFt+L5bce5JjC odDW11576pmn5R1CfG+4XG559QEgj3MIAMqTvQq6ra3tpZdellf/KEQ6C4fDqhy6 nMy133VePjaHcxsmT2bS6UwqFQgERIiORCLhycmo+N/UHHNc/JuIJxLJKQlxJ5VK Tt2mcveSSRG5M9lMX19f5cw/i8DmcDhqakR0rW2YiqZCQ0N9fV29eI94HJqam0Wa nYqxObkZ2paW/LW1NXV11TU1ItP2DwwsGhk5qGWU+KKIyuLBF3+5v79fq9Hk33/Y L3H+ncUZcY9kZo8r8W1Uiu0AFq4A079VrH8GUCgEYADKkx2Ahf/5P//1S1/6ktRD HIk4FWajDlXMLzYfKh+kI5OToqC4za/Kbm5qamxsnLqiOSrenw/Q2UxG/G9qgxsR t1Mi/OSm/rJZkfSU+7RmS6R3u90uPut8bs/fyQda8VqeW148tcA4lU6LMYs/Fe9v bmkRabazszP97tX7dVN/rNfpRJqdZZfj/P1DH/b8n4pHprq6urSS7dFNf9bxWMzp cqUqoMfVUQT8/ldfeeWFl16UehQCMIDCIAADkEJ2BhbxZNu2beIUX94hjq5EW0Oj 6t2JblrZhLdDPzvxHrMpt29NLvfW14ufzfxnWjafsrLeudB3akffirrQ97DEQ2E1 mf7zuuva2tvkHYX0C6BgCMAApJC6GVLeaae99/bbb1fxDN7r9VbC3icodeK7NBAM 1tbW5q+dJvceyYHom0i4pi705TdceQ6L5Y+PPmqxWqQehQ2QABQMARiAFAVYBZ3J ZH76s2vOO/dcFc/mQ6FQ5JC5RAAl5J3VzvF4/kJftUdURLKZzJbNmx9+9BHZF8wz AwygYAjAAGTp6tIPDcnNwJFI9Pnnn1flgsxp4uzZ62XiAig906udxY9wIh6vwH3O ji6RSJgnJq6/8ca2tlapBzKbzW436RdAgRCAAchSgElgoa+v/6mnnpJ9lGOqzF2C gRI1c7WzuK3AbY2OSTyh2czme+6799AL5hXH9C+AQiIAA5BFBODBwYEC7DTz0Y/+ 9Y033ij7KMfEcmigyLHaefacNttjTzw+OjYm+0CZTMZisRKAARQMARiARD093QMD A7KPks1mL7nkku997yrZBzqmVCrl9XrpnQMUG3o7z0kkHF69evWWra/lG6dJZbVa nU6X7KMAwDQCMACJCrMKumpqDuGb3/zm5Zf/UwGOdUw+ny/BzBJQBKanfEXoza92 5vdTxxSPRteuXfviyy8VYP1OFeufARQcARiAXF1dXUNDgwU4kMjA3/72t7/+9W8U 4FjHFIvFAoGA2qMAKte7pnwTiTSX6M9OLv2uWfPi+pcLk37NZovb7S7AgQBgGgEY gFwFmwSumsrAX/3q1/7lX/6lMIc7JjpjAQXGlO9CRMPh1U8/tWnz5sKk3yqmfwGo gQAMQLpCZmBxsnvWx8+67vrrC3O4Y4pGo8FgUO1RAOWPKd+FyPUvcLn+9Phjo2Nj BbjuN4/0C0AVBGAA0hUyAOctWrT4gQceaGpqKuRBj4KpYECSmY2d3Uz5zot40ExG 44P/9V+hcKiQxyUAA1AFARhAIRQ+AwsPP/zwkiVLC3zQI2EqGFDQdO4Vd/K5l8bO 81NTXb11y5Z77ru3qbm5kMcl/QJQCwEYQCF0demHhgodgO12x1VXXXXllVcW+LhH 4fV6xfm62qMAStj0UufcT1MiwQ/UvKVSqaDfv3bt2tVPP93f31fgo5vNZrebAAxA BQRgAAXS3d01OFiIdtAH6e3tu+eee3p7ewt/6MNKJBJ+v59VmsCcvNPdKpFwu93i NpvJqD2oEhaNRkf37Xvoj39MJFXYs81isbhcNH8GoA4CMIAC0ev1Q0ODBWuvMpPT 6briiit++MMfFqy16TEFAoFYLKb2KIASQHcrZeX7XT2xatXL69f39anwm8FsNms2 W1j/DEAtBGAAhdPT0zMw0K/W0Wuqa67+yU8++clPqjWAg6TTaa/Xm2EWCzicfO4V YWm6u5XaIyoH6WTyubVrn3722camRrXGYLXanE6nWkcHAAIwgMJpbm7u6+vr7OxQ awDiZLq3t+/nP//5aaedptYYDhKJREKhgnZeBYrZwRv5JpMsdVZETVXVxg0bnly9 Op6Iq7ISJ89oNEWnqDUAACAAAygoFRdCT8tkMkuWLPnxj//fe97zHhWHMZPP50sw wYUK9k5X50TC7fHQ1VlBNdXVmzdufGbNmkAwoO5lICx+BlAMCMAACk3dhdDTxKnY 8PDw97531amnntrc3FxfX6/ueEQA8Pv9rIhGpZl5ia+4TdHVWUGZzCvr1z/3/J8n JyfV/bVjHoufARQD9Z8NAVSahob69vaOwm8LfFgiBtfU1Fx++T8JxXCCKM5Tw+Gw 2qMApDvoEl+Re2mNrpRUKhUOhdY9t3bzli3iMS2GZ7aqqY1/Q6FgIsEvOACorCie EwFUGr1ePzg4UDw9mQWROz/72fOv+Od/FmNTfUKYFdEoV9NLnQ+0tuISX0VFo1Hj 2Nhzf173xptvdnSo1m3hUJlMxmKxsvgZQDEgAANQR29vT3+/+guhDyLO0lpaWr/x jW988YtfFCfoKiZhVkSjnBy0i694M8MlvsrJT/m+9MILG7dsSSYTRfW7xTybzeZw sPgZQFEgAANQTZFcDHxY4hz9lFPeI5Lw3//930ejUbWSMD2iUdLeaW2VTOZzL7v4 Kkjk3mQ8vmHDhk2bN+/bv6+rq0vtER0el/4CKCoEYACqEamyra11cHBQ7YEcTSAQ OPnkFV/5ylc+9alPxWIxVZKwGIM4dIEPCszbzNzrmWrpnCL3Kkc8mPFodNPGja9t 2zo6NtbZ2an2iI7GYrGEw5PsewSgeBCAAaipoaFhYGBAoynqE7g8t9u9fPkJX7j4 4ou/8AUx7AJPC2ezWa/XS4pAMXtX7vV6c7mXls7KEY+n3+/f8Oorr+/cNT4xXrTz vTMZjaZwOExHAwBFhQAMQGWNjY3d3V0lcTKXl06nxZjf855Tv/71r5955pmFPHQ8 Hg8EAjTLRVGZzr2pVMrt8cRjMa7vVYp4SLPp9FtvvbVx48b9o6OZbKa2tlbtQc2W 0WicnIyIZy21BwIA70IABqA+kSc1Gk1/f5/aA5mzYDB0wgknnHP22ed/7nMGg6Ew B2WrJBSDmfO9LpcrkUjQz1kp0WjUYjJt2bJl3/79Vqu1sxTWyBxkYsIYiZB+ARQj AjCAoqDX6wcG+ktocuMg2Ww2FosvW7bszA9+8B8uvHDp0qUiFUhdJu33+zm5RIFN h96qqfUILqczN0XJkoQFEw9jdTY7Nja25bXXRkdHrTZbW1trkezfOw/pdNpqtbHp EYDiVKrPrQDKT29vj1C6GXimQCA4YjAct2TJBRdccPbZZ4sMLCMPZzIZn8/HhcGQ 7aCmVolEgmbOCycezFg0+sauXW++9ZbJZLI7HCXRDeGYRPp1Op1segSgaBGAARSR ri59bW1dKa6FPgpxOlhTXWMwGI5ftuzzn//8Bz/4werqagXzcGKqNQ6zcFDWQZO9 bpdLvIdvs4VIpVKZVGrvvn0i9I5PjNsdzrq62vL4ld+0iQljbW2N283cL4DiRQAG UFyamho1Gm1fX6/aA5HFbnf09/UNDA4sWrT4M5/5zF//9V83Njbm83DV1NZQ84vE 7BiMhZsZehOJRG4HI3buXQDx6MWj0bd3796zZ4/JbHI5nR6vr4yf3ET6jUYjsRiX ZgAoagRgAEVHBML+/v7yWA14TJlMJh6Ld3d39/b1LV++/NOf/vTpp59eU1NTNXX2 PNdZ4mAwyH6bmJOZoTcpQq/Pl0omU0z2zl0qlUonk+Pj4yLxms1mh8Ph9flaW1vy P85lz2g0TU5O0pgAQPEjAAMoRk1NTW1tbUNDg2oPRAXpdDqZSE5dEd07MDh47rnn fvjDH+7o6Kj6SySuOtZEsdfrTbL/Ko5q5mW9+S2mcwt02b5o1hKJRDgY3D86Oj42 ZrVZPR6P3+9vam4usyXNs2Q2W8LhcCwWU3sgAHBsBGAARaqhoV6j0QwMDKg9EPVl s1mv16fTanU6nV6vHzYYTj/99HPOOUfcz3/AocFYhBmfz5dhWxrMMB16xXdUPB7P 5d5kMk3oPSrxo1RXU+P1+fbt22c2mRxOp9vtFj9coXBYr9eVbqNmBVmtVhH+Ewl+ 6QagNPDEDaCo9fb29Pb2VsgawrlyOJyazs6uLn1np6ajs3NoaPC009571llniUcs /wGxWCwYDIq0M518WltaJG3LhOI0M/Qm4nHP1GQvl/UeSjwstdXVXq93bHzcarW4 XG6/z+cP+AOBYHhyUjwRqT3AYpTJZBw5NHwGUEoIwACKnV6vb2tt1eq0ag+kZNhs ttbWNq0mRz81a9ze0d6p0S5fvvzkk0/WaQ/zSJKQy8m7Qm8iMb3CuYrLeqcym3hA rFar0+kwG01+vz8QCoWFUCgajfSz5GTWjEZTdXU1m/0CKDkEYAAloLGxsaOjY3CQ c9OFym8d3NLS2tba2t7e3tnZqZ3SIrS2Llq8+JRTTunp7j5KhZk9k0jLxeNdDZxn zPRWWi8r8Ti43W6RykTKDQQCwRxxOxVxw+FIZFKj0bCiZOEsFqt4ZGl5BaAUEYAB lAy9Xl9XV267BBcbkZccDmdjY2NLc7OIxK0tza2tbe3tbR3tHR2dnR0dHXX19bW1 tTq9fmBw8PilSzWdc2jWPTOkVZGfF+ygXYumZ3qzZXftt8iu+TQbCoUmp+QDrbgj Mm0kEo1MicVivb09XJcr1cSEsaamholfAKWLFwkApWRqKrh9cLASu0MXoXxabmio b2psEl+apqam5mZxR9w2NzY2iHfm7jU1iSDd0tLS1tYmkkkmmxVRur29vbunp6+3 V0RqMvCcHLxr0V9meou84ZkYpAioU3k1Eo2KvDopbmOxuLgV0T0+JZlMiPfF4yLG Tv2Xu4klEsmenm4ybZGwWCzBYIiJXwAljVcUAKVHr9c3NDTQlqbUiczmdntqa2vr 6urEF1Tc1h+Quzv1zvr8HfEu8QG1tTXivviL4s3q6hoh/6b4I3FbN0Ukpfkl6uTU zrdiSCKPVU1tRpVvjzzjzVQ6nRFBTrxnaGhIwcdhNsTAxAitNltdbW06k66uqs6r mno0xK14NPIb8IgHIb/Ed96PQ9WMT3/6TTEA8fiIB6Eql2Zzb+Znm/OPTDKZu5P6 i/xjJf5uamoNtkiwrDoudUz8AigbBGAAJamxsbGzs6O/v5+pIQCQJ5vN2my2QIAr fgGUCU4cAZQwvV4vAvDQECuiAUB5ZrNFBGAmfgGUEwIwgJLX1aXPNzRWeyAAUCZM ptwuR2430RdAuSEAAygHTU2Nra1t4rb7qFv4AACOzmg0VlfXTE6GYzHWPAMoQwRg AOWjqalpauOeZn2XXu2xAECJ+Uv0nYzFYmqPBQBkIQADKDfNzc0tLbktbHU6rdpj AYASYDTmFjznN6lSeywAIBcBGEB5ysfg6uqqwu9YAwClwmw2Z7NVRF8AlYMADKDM 6fX6mpqagQE2TAKAA7LZrNVqy2QydHgGUGk4HQRQEXQ6nQjA7e3tGg3NogFUrvxq ZxGAvV6v2mMBABUQgAFUlvyEcH9/n7hVeywAUCCZTMZmszPlCwAEYACVKD8hXFNT PTAwwNJoAOVqaqmzNZPJMuULAHmc9gGoaHp9bsMkkYEHB0nCAMqEiLsWi1XcivtM +QLATJztAUBOfk6YPYQBlLT8Xr7M9wLAkRCAAeAdWq1mZGRE7VEAwDxNTEz4fH61 RwEAxYsADADv6OzsXLx4kcqDAID5GhsbDwQCao8CAIoXARgA3tHb29Pf36/2KABg npgBBoCjIwADwAE6nc5gGFZ7FACwIEajiQuAAeBICMAAcIBerxseJgADKG0mk8nj IQADwOERgAHgAL1ePzw8pPYoAGBBTCYzWx8BwJEQgAHgAHkBOJPJVE+RURxAyclO qampkVGcAAwAR8HZGAAcIC8Ad3Z2Xv6Ny996662J8XGT2exwOuvqagUZxwJQhNLp dDKR7O7u7h8YWHLccT3d3b+///50Ji3jWARgADgKAjAAHCCvCdayZcvvuOOO5ubm +vp68WYwGHzttdd27NgxNrrfZrXZ7DZxtlpXX08kBsqDiLvxeFyv0/X09i0yGI5f vnzx4sUz53vtFss9993nD0hp10wTLAA4CgIwAByg1WpHRgwyKn/kIx+96aabpt9M JpPRaFTcmY7Ewq5du1544QXj+LjNbrfZbB632+f3d2o6WTgNFLNsNhsIBHVabXd3 t16v7+nrW75smcFgOPryZrfD8fAjj0yYjDKGNDFh9Pl8MioDQBngvAoADtBoNIsW jciofP75n/vRj3509I/Jp+KZkTgYDG7YuHHn66/brVaXy2V3ODxeb8DvE+/vHxiQ MU4AR2G1Wjs7OrVabVdXV19fX09vz+Ljlpx55pk93d35DxA/woFAwGazHbOU3+N5 6umnX9+1U8Y4x8cn/H62AgaAwyMAA8ABIwaDVqeVUfnyy//piiuumOvfOuxEsbBn 9+5NmzfbLBaX02m1WZ2u3FxxMOAPhsJ9fb1KjhuoSHa7o6OjXdOpEVm3p6dbq9Xp urpOXrHilBUrNJ2d0x8mfkInI5HWlpbpH09/IGC326ORyDEPEQmHX3rppedffEHG +FkCDQBHQQAGgBwRHXt6eiQ1Zf3pT3/2yU9+Uqlqh84V542Ojr755pv79u3zeb1+ n8/lcuVmjAOBUCgUiUTaO9q5xhjIS6fToWCopaWlo6NDo9HodLqe7u5OrVaj1Sxb tnzJkiWHBl1xZ2bWPSwRgK1WazwWO+YAkonEzh07/vjoIwv/XA6VyWScTqeI8TKK A0CpIwADQI7UTYAfeeTR4447TlLxaUeaMc7bt3fvzl27xsfHA35/MBh0OZ0+vy8c nhTC4n+RyXg8MTDQL3uQQAFYrbbmpsaW1ra2VvFfW3t7m0aj7e7qauvIWXL88Scs Xz4z4ubNPugeiQjAFoslEY8f8yMzqZTRaLztjtvncZTZoBE0ABwJARgAcqRuArxt 23ZJc8uzd1A89nq94j35P8qt23Q4RA4WwTgRy3G5XD6vNxAMhoLB8GQ4Go1Fo5FY LB6Lx8W9RDKh0+mYT0YhpdNpn8/XUN/QlNMo/mtubhHa29o6Ojs1Gk3+vd09PcMG w4jBcGi+rVIi4h6d+FEymUypv/xkHUUqlbJbLDfdcjNbAQNAgRGAASBHXgCenIzs 2bNHRuWFcDjeWR45nQqqZrfIM5+WRRJOp1LJRMLj9fr9/oDfHw6HI5FILkDHY4lE Mh6PJ8Ufi7iciCeS4kOT8YR4T0okmf7+PrpbV5psNmu32Wtqaxvq6xoaG+vrxDda faO4U1/f0CDe0dgobkWsbWpqzc3ZtotMK94vPkqr0w0MDg4NDh42006b07exJOKn Y2JiIpOe1e6+xrGxa1aulNR3gAAMAEfC+QcA5MgLwI2NTRs2bJBRed5ETA2FQvP7 uwuMGdP5ORqJhCcnxW1TY2Ndba1IyyI4R3PZOSbux0VojsWSUxIiNE/diggl0nM2 kyPuiDdFrK6amkyrys20p8X7s5lsOjOr+HGQ2tpakclrqmtqpma26+rqqvPvrBGq 62rrxAumeDP3/uoaVaKFCJDdPT3ik02nxWea+xxzc/jZKvF2IpHIha7c+KvFn2bF o5DNpmcXww5SW1M79SgI7zwOdfXitrq2rjb//vxj1VCfy7Aio+YSrIiyTU35BNs0 FWLFl0Z8EZuaxd2mlpYWMXLD8PDRE+yhiiHTzon49h4bGxNfqtl8sHli4vpf/aqh sUHGSAjAAHAkBGAAyNHrdcPDwzIqDwwMrFq1WkbleXM6ndnZnaMrbmakySuJYDNv 2SnVUxZYyj+1v04sGhWhVARxvU7X0NjY1tpanI9epX2h83x+/7gIwLNjNZnu+O2d sVlcMDwPJpPJ46ERNAAcBgEYAHJ0Oq3BYJBR+bTT3nv33XfLqDw/6XTa7XarPYqK I2JwJpPJzSbPNwmLSBmenBR38hUqIU+WFvEF8vp8Votllh/vtNnuf+ABp8spYzBG o9Hr9cmoDACljgAMADlarWZkZERG5XPPPW/lypUyKs+P3++Py5l0wjEpOCGMYpNf 3h+d+iXFbHhdrscef3zPvr0yBjMxMeHz+WVUBoBSxwswAOTIWwJ96aVfufLKK2VU np+Z7a+glkwmQwwuM9Nr1Gf58SG//7l16zZu3iRjMCyBBoAj4aUXAHJOOWWFpH19 vv/971900cUyKs9DNBoNBoNqjwIH5K/EJgaXh9lvApwXj0Zf27LlidWrZAwmnU7v 3LlLRmUAKHW86AKAxBbQwm233X7GGWdIKj5XLpcrk8moPQq8S3bq+uDqBVwejGIw +02A81Lx+P79+393372SxkMjaAA4LF5rAUBiABbR5uWX17e1tckoPldiME6nlI47 WDguDy51c9oEuGqqaZbNbL7ltlslfcUJwABwWLzKAkBVV5d+aEhKAA4Gg/v3j8qo PA9iMNFZX6AIVRCDS5cIwONjY3PaYMw4OvrT//gPfZdexnjMZrPbTQAGgIPx+goA EmeA6+rqN2/eLKPyPND+qlQQg0vRnDYBzjNNTFx3ww1NTY0yxsMMMAAcFq+sACCx BXR//8Dq1atlVJ6reDzu97MtSikhBpeQuW4CnGc1mW67445EMiFjSDSCBoDD4jUV AKp0Oq3BYJBR+T3vOfWee+6RUXmu3G53etZXJ6J4EINLwlw3Ac5zWK33/+EPLo9b xpCMRqPX65NRGQBKGq+mAFCl1WpGRkZkVD7nnHN//vOfy6g8V6x/Lml0ii5yc90E OM/rcv3pscf27t8nY0gTExM+H4s+AOBgvI4CgMRrgL/85Uu/+93vyqg8J6FQKBKJ qD0KLBT7BhetuW4CnBf0+9etW7dx8yYZQ+IaYAA4LF5EAaDqlFNW1NbWyqj8b//2 vUsuuURG5Tlh+recEIOL0Fw3Ac6LRyKbN29e9fRTMoaUTqd37twlozIAlDRePgFU Op1OZzBI6YAl3HrrbR/4wAckFZ+lRCLh83EpYLnJZDJcGFw85roJcF4yHt+3b9+9 v79P0qiMRpPXSx8sAHgXXjgBVDp565+z2exLL73c3t4uo/jseTyeVCql7hggA1PB xWMemwBXTfWOtppMv7n9NklfRFZBA8CheNUEUOnkBeBAIDA6Ord9QWVg/XN5y2Yy VUwFq20emwDnGcfGfnLNz7q6uhQfUhUBGAAOh9dLAJVOXgCura3bsmWLjMqzFw6H J+e4NQtKDlPB6sptAuz1Wq3Wefxd0/j4L2+4obm5SfFRVRGAAeBweLEEUOn0et3w sJRrgPv6+p96Skp7m9lj+rdyMBWsltwmwHZ7dF6N1q0m02133JFIJhQfVVUuAJs8 Hq4BBoB34WUSQKXT6bQGg0FG5RUrTrnvPlntbWYjPzGl4gBQYEwFq0IEYKvVGo/F 5vF3HVbrffff7/FKmac1Go1eLw3wAOBdeI0EUOk0Gs2iRSMyKp999jnXXnutjMqz JNJvco77sqAM0CC6wEQANpvNycR8ZnE9TuefHn983/59io9KGB+f8Pv9MioDQOni 1RFApVs0MqLRamRU/vKXL/3ud78ro/Issf65YpGBC0kEYKPRmJ5Xr/Wg379u3bqN mzcpPqoqtkECgMPhpRFARdNoOg0GQ01NjYzi3//+9y+66GIZlWeD9lcVjuXQBZPb A2l8PHcN9tzFo9HXtmx5YvUqxUdVNfV7EJHM/f6AjOIAUKJ4XQRQ0XQ6ncEgpQOW cN99v1+xYoWk4sfE9C+qpmIwGVi2ee+BJKQSidHR0bvv+Z2iI3oHk8AAcBBeFAFU NHl7IGUyma1bt9XW1soofkyJRML3/7N3J3BS1Xe+96EbaAWUrqVpmi66wcwkk4lZ JrnjjJnkaqKT1SQzPhPnJnkycXTGPDom5s7LZCaTRCK474iCKAKCCFFWFVRQxAWN +76i0FV1zqmq7lq7u9ZTyz1NOTxcROilfnVOnfN5z7zyQuj+nr8tdNWX/5bg8BsM 4XRoUbquG3/WVFUd3acXi8Wwqi5cdLPQOhRuQgKAg/ByCMDR5ApwJpN95513JJKH w3jLWxzVjkTYEluC5SRTqUgkkhnDdoPg3r2XXnmlS+YkAgowAByE10IAjiZXgCdP nrJr1y6J5OFg/TMOwpZgIUYBDoVCuWx21AmK379g4cIJEyfUcFT7UYAB4CC8EAJw NLk9wHPmzNmwYaNE8hFx/BUOiQ4swSjAqqoW8vlRJ4QUZdmK5YMyf2bZAwwAB+FV EICjuVyu7u4uieS//uu/Xrz4FonkI2L6F4fBsVi1ZRTgYDBYHMOF233h8N333K1o Wg1HtZ/fH+A4AAA4EC+BAByttXXa7NmzJZL/7u/+fu7cuRLJh5fP55PJZP2fiwZC B64howD7/f5yqTT6hFhs64MPvvb6azUc1X49PT1cgwQAB+L1D4CjdcyY0T6jXSL5 3HPPO+eccySSDy8ajZbG8F4cDkEHrpWhS4D37q0uLx+dzODgrl27dux8tIaj2o8Z YAA4CC9+AJxL9BLgq6++5tRTTxUK/yjGu/De3t46PxQNig5cE2O5BLiqpOtvvfnm 6rVrajWkg7ANGAAOxCsfAOeSOwLa8NBD26ZPny4U/lH6+/uzYziNFk5DBx4jXdeN bqmNcftuuRwJh29YeGONBnUwDoIGgAPxsgfAueQKcCwWDwQCEsmHx/FXGCk68Fgk U6lwOJzNZMYSUiwWI5r2u7lzhbZjUIAB4EC85gFwLrkCbDSKF198SSL5MHK5XCrF aTcYMTrwqBkFWNO0fC43xpxgT8811183efLkmozq4HAKMAAcgBc8AM7l8bhnzRLZ Azx9evtDDz0kkXwYfX195XK5zg+FPdCBR8cowEowqI/hDqQqLRhcvGRJsVSsyagO EgwGYzH2AAPAB3i1A+Bcbrerq0vkEuDjj//0qlWrJJI/SqlUikaj9XwibIYOPApG AQ74/WM/dz2iaatWr47FReZpA4FAPM5B0ADwAV7qADhXa2vr7NndEslf+9rXr7zy Sonkj5JIJAqFQj2fCJupXuRDBx4RowDv3bt33BjuQKqK9/Vt2rx59/vv1WRUB+np 8XM3OADsx+scAOeaNWuWx+OWSD7zzH++4IILJJI/CsdfYezowCMVTyT8PT1jzxlI pR7dsePpZ58Ze9SHcQ0SAByIFzkADuV2u4wCLPRe/ze/+e0//MM/SCQf0uDgYDqd rtvjYGPlcnn8PmYPpAHouh6Lx0NjvANpn0Iu9+ILL2y+/76xR31YpVIJBoOsggaA Kl7hADiU6CXAa9as/bM/+zOh8A9j+hc1VCqVmpqa6MBHlEylQqFQrhY3b5d0vWfv 3qXLl4096pA4CBoA9uPlDYBDeb0en0+kAJfL5ZdeetmoEBLhH5bP59ngh9oyfg/X 7Tdw4zIKsKqqhXx+7FHFYjGsKAsXLxL6siuKEo1SgAFgCAUYgEPJzQDruv76629I JB8Stx9BAodCH5FRgIPBYHHMdyBVBffuvfKaq4859tiapB0czgwwAPw3XtsAOJTc JcAul3vHjh0SyR/G7UeQQwc+PKMA+3t6avXXT2ogcPPixZVxYz1Q+pC4ChgA9uOF DYBDyV0C/MlP/vldd90lkfxh3H4EORwKfXiJZLJn795apUVUdeWdd8aTIkdVcRUw AOzHqxoAh5K7BPiUU0655pprJZI/jOOvIIpJ4I+i67pRgFVFqVVgrLd346ZN7+/d U6vAA3EVMADsx6saAIfq7JzZ1tYmkfyTn5z5i1/8QiL5IP39/dlanEALHAYd+JCS qVQkEsnU7vqxgWTykR07nnnu2VoFHogZYADYj5c0AE4kegnw73530emnny6RfBCm f1EfdOAPq+EdSFWFXO7ll17aeO/mWgUeiKuAAWA/Xs8AOJHoJcDr12847rjjhML3 S6fTg4OD0k8BxrEZ+FBqeAdSVblYDAQCS267tVaBB+EgaACo4sUMgBPJXQJcKpVe ffU1ieSDMP2LeqqUy+O5GfgAQ3cgBQLFYrFWgUZURNMW3LSwubm5VpkH4ipgAKii AANwIrkZ4FKp/Oqrr0okHyiXy6VSKemnAAdiIfSBjALc09NTqekV3MGenquuvXbq 1Ck1zPz/w5kBBoB9eCUD4ERut7urS+QS4La26du2bZNIPlBfX1+tbh8FhomF0Aeq 7R1IVVowuHjJkmKpZrPKBwoEgvE4VwEDAAUYgCO5XK7ubpFLgD/96c+sXLlSInk/ Xdd5IwtTMAlcVf0zqGlabWMjmnbnXXdFY9Haxlb5/YFEgkOwAIACDMCRWlunzZ49 WyL5a1/7+pVXXimRvF80Gi2VSqKPAD4KHXjcvvXP4XA4m8nUNjbe13fvffe9s/vd 2sZW9fT0JJPsmwAACjAAR5oxpF0i+cwz//mCCy6QSK4yqq9RgOXygcNjIfQ4gSOg qwZSqccfe+zJp5+qbWwVM8AAUOXoFzAAziR3BLRh/vxLTjvtNKFwQzwe13VdLh84 IiaBh46ADgaLtf6TqOfzr7366j0b1tc2dj8OggaAcRRgAA4kWoC3bNk6c+ZMoXCj ePT29gqFA8Pn8A5sFGB/T0/ND6KrlEohTVu46Obaxu5HAQaAcRRgAA4kdweS8eYy GAxKJFclk8l8rVddAqPg8IXQEkdAj/vvq4B/O3eu0AYNbkICgHEUYAAOJFeAjT7w 4osvSSRXRSIRuXBgRCrl8vimJrNHYYKhI6ATCU1VJcKDPT3XXH/d5MmTRcIpwABA AQbgQHKXAHd0zNy6datEsqG/vz+bzQqFA6PgzIXQQkdAV2nB4JLbbivoBYlwrgIG gHEUYAAO5HK1dnd3SyR//vOfv/32ZRLJ45j+hfVUyuWhZQ8O68BCR0BXRUKhtWvX hntF/rD7/f5EIimRDAANxFkvWgBg6O7qcrldEsmnnfad+fPnSySn0+nBwUGJZGAs yuVyk8MWQgsdAV2ViEbv37r1zbfelAhnBhgAxlGAATiNx+P2+XxCc1bnnnveOeec I5HM9C+syYGnYQkdAV2VGRx8ateuR3Y+KhFu/MdSFCUWowMDcDQHvWIBwDjJE7AM Cxfe9KUvfanmsdlstr+/v+axQE047TQsoSOgqwq53O53371zzV1C+ZyDBQAUYADO IncJcKVSefLJXVOnTq15cm9vb3WeDbAm55yGNXQEdDyuaZpcfkhRFi25RejryVXA AOCIlysA2E9uBjiXy7/11ls1jy0UColEouaxQA05pwAnU6lQKJSTPI89uHfvZVdd 1do6TSScGWAAjueIlysA2E/uDqTW1tZHH91Z89hoNFoqlWoeC9SWQzqw6BHQVWog cPPiRUJLPjgHCwDs/1oFAAeSuwPpU586/s4776xtplF9jQJc20xAgkNOwzIKcCAQ KBWLco+IaNqq1atjcZF5Wm5CAgCbv1ABwEHmzJkzbdqxEslf+9rXr7zyytpmxuNx Xea2FaDmnHAlklGAe/buFd2TH+/ru/e++97Z/a5EODPAAEABBuAgHo+7s7NT6D36 2Wefff75P6ttJrcfoYHYfhJY1/VEMqkqiuhTBvv7n3ji8ceffFIivFwuq6rKTUgA nMy2r1IA8GGidyBdddXVf/u3f1vDwFQqlcvlahgISLP3JHAylQpHItl0WvQp+Wz2 jTfeuGf9OqF8zsEC4HAUYAAOInoH0qOP7nS5XDXMZPoXDcfek8BGAdY0LS/811KF QkEJBG5dehs3IQGABHu+RAHAIcnNAA8MDL733ns1DEyn04ODgzUMBOrDxpPARgEO BoNF+W35gT17LrniCo/HLRHODDAAh6MAA3AQ4w3lrFkidyBNmTL1yZru2WP6F43L rlciGQXY39NjNHzpByl+/4033dQ8oVki3Ojw7AEG4GQ2fH0CgI/icrm6u7skkv/0 Tz9+99131yotl8ulUqlapQF1ZtdJ4EQy2bN3bx0eFFbVFStXpvpFvgn4/YFEIiGR DAANgQIMwEHklkB/9aunXHvttbVK6+vrq8MsEyDHfpPAuq7H4vGQptXhWbHe3g2b Nu3Zu0cinCXQABzOVi9OAHAYM2a0t7W1NTeLrCo866yzfvazn9ckqlgs8vYUjc5+ k8DJVCoUCuWy2To8ayCV2rnz0af++EeJ8FKp1NfXFw6zyQKAQ1GAATiF6B1I8+bN /853vlOTqHg8rsufsgNIs9kksFGAFUXRC4U6PEvP51995ZV1GzcI5TMJDMDJ7PPK BACHJ1qAt259oKOjoyZRHH8Fe7DZJHDdTsAaUi6HNO3Gm28SiqcAA3AyCjAAp5Ar wIlEsqenpyZR/f39WbE1luPHj69e0wrUh50mget2Ata4ffsgIpp20cUXT5/eJpFP AQbgZDZ5WQKAI3K73V1dIncgTZrU8swzz9QkSm76l/aL+rPNJLCu6/F4XKvLCVhV it9/3YIFLS2TJMIDgaDxryORDADWRwEG4BRydyDNmTNnw4aNY8/JZDIDAwNjzzkk CjBMYY9J4HqegFUVUpRlK5YPptMS4dyEBMDJGv41CQCGaXZ3d6urVSL55JNPvv76 G8ae09vbK9RRab8wiz0mget5AlZVLBJZv3HjXn+PRDgzwACcjAIMwBE8HrfP5xOa iTrzzH++4IILxhhSXWNZk/EA1lH9m5dGnwQeOgHL7y+XSnV74kAq9eiOHU8/W5u9 FQcx/qMYfT4W4xsOACdq7BckABgm0SOgL730sm9961tjDInFYsVisSbjASzFBpPA 9TwBqyqbybz+2msbNtVgb8UhcQ4WAMeiAANwBLkCXKlUHnlkh5E/xhxuP4JdNfok sK7rsXg8VMcTsAyFQiHo9992+1KhrxsFGIBjNeqrEQCMiFwBTqcz77777hhDUqlU LperyXgACyqXSk3NzWaPYpSSqZQWCuXreAJWVWDv3suuuMLldkmEU4ABOBYFGIAj yN2BNG3atJ07HxtjCNO/sLeGngQ2CnAwGCzqep2fqwYCNy26eZzMF41zsAA4VkO+ FAHASLW2ts6e3S2RfPzxn161atVYErLZbH9/f63GA1hTqVRqbsxJYKMA9/T0VMrl Oj83ommrVq+OxUXmaXt6/MlkUiIZACyOAgzAETo6Otrbp0skn3bad+bPnz+WBLnb jwDraNALgXVdTySTqqLU/9GJaPT+rVvffOtNiXCuAgbgWI33UgQAIyV6BPT5559/ 9tn/MupPLxaL7MSDQzRiB06mUuFIJJtO1//RxkOfemrXwzt2COWzDRiAMzXY6xAA jIJoAV6y5NYTTjhh1J8ej8f1uu8tBEzRoAVYVdVCPl//Rxfz+ffff3/FqpVC+RRg AM7UYK9DADAKcgW4VCo999zzLS0to07g+Cs4SsN1YKMABwKBkhl3dBeLxZCiLFx0 s9DeaQowAGdqpBchABgdj8c9a5bIEdCVyriXX3551J8+MDCQyWRqOB7A4srlclNT k9mjGIFEMtnT0zPOpF36wZ6ea667bvKUySLhwWAsxkHQAByHAgzA/lwuV3d3l0Ty zJmdW7ZsGfWnM/0Lp2ms+5B0XY8nEpqqmjWAUDC4ZOnSfEFkATbnYAFwpsZ4BQKA sZBbAn3iiV9ctGjR6D43l8ulUqnajgewvgaaBE6mUqFQKJfNmjWAvnD4nnXrgqrI GdQsgQbgTBRgADbn8bg7OzuF3nD/4Ac//NWvfjW6z+3r6yvX/WZRwHQNNAlsFGAl GDTxmLpUPP7wI488/+ILEuHG9x9VVVkFDcBpGuDlBwDGQvQI6N/97qLTTz99FJ9Y KpWi0WjNxwM0BOP3v9DBTrVlFOCenp6KeX9RVcjlXn7ppY33bhbKZxIYgANRgAHY nNfr8fmkCvCWLVtnzpw5ik9MJpN5My5WAaygIc6C1nU9kUyqisjy42GqlEohTVu4 6GahfEVRolEKMABnsfrLDwCMkdwMsFFi9+7tGd3ncvwVHM76HTiZSoXD4ayp57QX i8WIps2dd3FbW5tEPjPAABzI0q89ADB2brerq0vkCOjJk6fs2rVrFJ+YTqcHBwdr Ph6ggVj/KCyjAKuqWjB7pYbi9y9YuHDCxAkS4YFAIB7nIGgAzkIBBmBzcjPAn/jE n61du3YUn9jb21sx6VpRwCKsfxSWUYD9fn+5VDJ3GGFVvWPVqmQqKRHODDAAB7Lu Cw8AjN2MGe1tbW1Cx+18/evfuOKKK0b6WYVCgbs3AYPRLZusehSWruvVI6DNHsi4 eF/fvfff/86770iEl0qlvr6+cJgdGQAchAIMwM5Ej4A+77x/+9d//deRflYsFisW ixLjARqLlbcBG+03Eolk0mmzBzIuMzj41FNPPfLoDqF8JoEBOI1FX3gAoCZEj4Be terO448/fqSfxfFXwH6W7cAW2QBsKBYKe/bsWX7HCqF8DoIG4DRWfNUBgFqRmwHu 7e1VFHWk7937+/uz2azEeIBGZNmjsIwCHPD7S2ZvAB637yDosKr+du5FHR0dEvnM AANwGgowADtzu91dXbMkkidOnPTss8+O9LOY/gUOYsFJYOtsAK4K+v3X33BDy1Et EuGBQDAej0skA4A1WeslBwBqS24J9Mc+9ifr1q0b0afkcrlUKiUxGKBxWXAS2Dob gKvCirJ85cr+gX6JcJZAA3AaCjAA2xI9AvqUU0695pprRvQpfX19xnt9icEAjcuC M8DW2QBcFevt3XTvve+9/55EOAdBA3Aaa73kAEANeTzuWbNE1j8bzjnnp+eee+7w P96ovsa7TKHBAA3Nah3YOhuAqzKDg0888cTOxx8Tyg8Gg7EYq6ABOIWFXm8AoLZE 70BatGjxiSeeOPyPTyaTectMKAGWYqlV0FbbAGzQ8/ndu3evWn2nUD7nYAFwFAow ANuSmwEulUrPPfd8S8sIzqTh+CvgMKwzCWy033AkkrXMBuBx+w6CDinKwkU3C23o YAYYgKNY4sUGACTIHQE9fnzTiy++OPyPz2QyAwMDEiMB7ME6k8BW2wBcFezpufb6 64+efLREOAdBA3AUCjAA22ptbZ09u1siec6cORs2bBz+x/f29lYqFYmRAPZgqRlg f0+P1c6rCynKshXLB2XmpXt6/MlkUiIZACzIEi82ACChvb29o2OGRPJJJ518ww03 DPODi8Ui++uAI7JCB9Z1PZFMqopi7jA+LNbbu2Hjxj09eyXC/f5AIpGQSAYAC6IA A7An0ROwzjrr7J/97GfD/OB4PG68qxYaCWAbVlgFnUylQuFwLpMxdxgfNtjf//jj jz+x60mhfM7BAuAcFGAA9uT1enw+qQJ8ww0LTjrppGF+MMdfAcNR3SZg7iRw9fxn C/6NVSGXe/vtt9f8Ya1QvqIo0SgFGIAjUIAB2JPcEdDlcvnpp/84efLk4Xzw4OBg 2krHyQJWVi6VmmQOOh6mRDLp7+mx4I59o5OHVfWmxYuEJsk5CBqAc1CAAdiT3BHQ xnvjl19+eZgfzPQvMHzmbgM2SmY8kdBU1awBHF6wp+ea666bPGVYf/U2UhwEDcA5 KMAA7EluCfSsWbPuvfe+4XxkoVDgaBlgREzswMlUStO0fC5nytOPKBQM3rZsWTaX lQhnCTQA56AAA7Ahj8fd2dkptFbwf/7PkxYsWDCcj4zFYsViUWIMgF2ZeBSWUYAD gUDJqn9mo5HI+g0begJ+iXDjy66qKqugATgBBRiADVnkCGjWPwMjZdZRWLquV0/A qvNzh28gldq5c+dTf3xaKJ+DoAE4BAUYgA2JFuDrr7/h5JNPPuKH9ff3Z7MiixUB eyuVSs11PwrLaL/hcDhrvQuQ9hs6CPqtt9bc/QehfAowAIegAAOwISscAc30LzA6 pqyCHpr+VRS9UKjzc4dP1/WQotx8y2IOggaAsaAAA7Ahl8vV3d0lkTxhwoTnnnv+ iB+Wy+VSqZTEAAAnqP9RWJa9AOlAwZ6e629c0NLSIhHu9wc4tA+AE1CAAdhQd1eX y+2SSP6TP/nTe+6554gf1tfXVy6XJQYAOEGdLwS2+AVI+4UVZfnKlf0D/RLh3IQE wCEowADsxu12z5rlE5o++vrXv3HFFVcc/mOM6msUYImnAw5R5xlgi1+AtF+8r+/e ++9/5913JMKNr3kwqNCBAdgeBRiA3YiegHXBBb8488wzD/8xqVQqZ/l30oDF1bMD D12A5PeXSqX6PG7Usun0H//4x20PbxfK5xwsAE5AAQZgN6IFeMOGjXPmzDn8x3D8 FTB2dTsKa+gCpGRSUZQ6PGuMysWiEgwuvnWJUD4FGIATUIAB2I3b7e7qEjkCur+/ //339xz+Y7LZrPFhEk8HHKVuM8DJVCoUDucsfAHSfsViMaJpF8+f7/F6JPLZBgzA CSjAAOymtbV19uxuoeRHH915+I/h+CugVurTgY0CHAwGi7ou/aCaUAOBmxcvEjqr uqfHn0wmZbIBwCoowADspr19ekdHh0TyF77whaVLbz/MB5RKpWg0KvFowIHqsAp6 aP1zKqUEg6JPqaHeUGjNH9aGZfZZ+P3+RIICDMDmKMAAbEV0A/APfvDDX/3qV4f5 gEQiUSgUhJ4OOE31Vl7RSWCj/RplMptOyz2itlLx+MOPPPL8iy8I5bMNGIDtUYAB 2IrX6/H5pArwJZdc+u1vf/swH8DxV0BtlUqlZskLgYemfxVFb5y/t8pmMq+9+urG zZuE8o2vRjRKAQZgZxRgALbi8bhnzRI5AatSqTz22OPTpk37qA9Ip9ODg4MSjwYc S3oVdCKZ9Pf0VKeaG4Ku62ogcMtttwpNjAeDwViMc7AA2BkFGICtuFyu7u4uieRS qfzqq68e5gN6e3sb6G000BBEV0EbZTIWj4c0TSJcTqCn5+prr506dYpEuN8fSCQS EskAYBEUYAC2IrcHuLu7e9OmzR/1q8Y7aa4PASSUS6UmmVXQyVRKVdVCPi8RLicU DN6+Ynla5t4m9gADsD0KMAD7cLvdRvsVmiz6yle+ct1113/UrxrtV2+Qa1SAxiJ3 GdLQ+me/v9Jo95bFens3btr0/t4j3Ek+OsZX2+jA/HUeABujAAOwD9EjoM8556fn nnvuR/0qx18BciQ6cHXVhtZo658NmcHBJ554YufjjwnlMwkMwN4owADsQ7QAr1p1 5/HHH3/IXxocHEw3zjUqQMORWAXdoOufDcVCYc+ePcvvWCGUTwEGYG8UYAD24Xa7 u7pEjoCORmPBYPCjfpXpX0CUxAywUYD9PT3lRlv/bCgWixFN++3cuTNmtEvkBwJB lkADsDEKMAD7kJsBnjx5yq5duw75S4VCgUNTAWm17cBD658TCU1VaxVYZ4rfv2Dh wgkTJ0iEMwMMwN4owABswuNxd3Z2Cl0Z+pnPfPaOO+445C8Z7xSLxaLEQwHsV9sL gRt3/XNVRNNW33VXXywqEW58qY0vDrcBA7ArCjAAmxDdAHzGGf/461//+pC/xPpn oA5qOwPcuOufq1Lx+Lbt2198+SWhfCaBAdgYBRiATYgW4Msvv+Ib3/jGh39+YGAg I3MbJ4CD1KoDN/r6Z0Muk3n99dfXb9wglE8BBmBjFGAANiF3Ala5XN6166mpU6d+ +JeY/gXqplaroBt9/fO4fR0+FAzevOQWoU0fnIMFwMYowABswuv1+HwiM8ATJkx4 7rnnP/zz+Xw+mUxKPBHAh9VqBrjR1z9XBf3+6xfc0NLSIhGuKEo0ygwwAHuiAAOw A4/HPXPmzOZa3xRa9YlP/NnatWs//PPRaLRUKkk8EcAhjb0DD61/jsc1TavVkMwS UdUVq1YlUyJ/B2d8ZzO+RJyDBcCWKMAA7EB0A/Df/d3fz50796CfNN6I9/b2Cj0R wCGNfRW0DdY/VyVjsa0PPvja668J5bMNGIBdUYAB2IFoAf7d7y46/fTTD/rJ/v7+ bDYr9EQAhzTGGWBd14cKsKIYOTUclSkyg4Mvv/zyfVvuF8qnAAOwKwowADuQOwHL eKP86KM7XS7XQT/P8VeAKcbSgY32a/zJzaTTtR2SKQqFghII3Lr0threDnUgzsEC YFcUYAB20NraOnt2t0RyuVx55ZVXDvrJXC6XSqUkHgfg8MayCtoowIqi6IVCbYdk lmBPz9XXXTdlymSJ8J4eP4f8AbAlCjAAO2hvb+/omCGRfNxxx61ff/Blm319fY1+ hCzQoKqrl0cx7Vld/2wU4HGNv/65Kqwoy1asGEgPSoT7/YFEIiGRDADmogADaHii G4C/+c1vXXbZZQf+jFF9jQIs9DgAR1QqlUZx5LvRfsPhcDaTkRiSKeJ9ffdv2fLW O28L5bMNGIAtUYABNDzRAnzhhb/80Y9+dODPpFKpXC4n9DgARzS6VdBGAQ4Gg0Vd lxiSKQb6+59/7rltD28XyqcAA7AlCjCAhufxuGfNkjoB64EHHuzo6DjwJzn+CjDX KFZB67qeSCZVRREblAny+bx/z55ld6wQOgcrGAxyFTAA+6EAA2h4Lldrd7fICVj5 fOHNN9888Gey2Wx/f7/EswAM30hXQSdTqVAolLPd1WXBvXsvv/rqadOOlQj3+/2J BOdgAbAbCjCAhjdjSLtEss/nu+++/+uaTY6/AqxgpKugjQJs1LlyqSQ3JFOEgsHb lt2eldmUwTlYAGyJAgygsYluAP7qV0+59tpr9/9jqVSKRqNCzwIwfCNaBa3rejyR 0FRVeFAmiPX2btq8+b097wvlsw0YgP1QgAE0Nq/X4/NJFeDzzz//7LP/Zf8/JpPJ fD4v9CwAIzL8VdDJVEpV1YId//Bm0+mnntr18I4dQvmKokSjFGAAtkIBBtDY3G53 V5fICViGDRs2zpkzZ/8/cvwVYB3DXAVdvf5XVZSKXa7/PVC5WFSCwcW3LhHKDwSC 8TjnYAGwFQowgMbm9Xp9vk6J5MHB9O7du/f/YyaTGRgYkHgQgFEY5ipoo/1GIpFM Ol2XQdVbsVgMq+r8yy5zu10S+Yqisu8DgM1QgAE0MOM9n8/nG8WNoMMxY0bHAw88 sP8fe3t7bTmDBDSu4ayCtt/1vwfRAoElS5cW9IJEeLlcVhQlHucoLAD2QQEG0MBE T8A6+eSvXH/99dUfF4tFToIBrOaIq6Btef3vQWK9vRs2bdqzd49QPudgAbAZCjCA BiZagC+44Bdnnnlm9ceJRKJQEJlgATBqlUrl8Eugk6mUpml5mVuCLKI/lXrmmWd2 PCp1DhYFGIDNUIABNDC5E7CMN9Zbtz4wc+bM6j9y/BVgTYfvwEPX//b02PvubqPe 9+zZs3zlHcO8FGqkOAcLgM1QgAE0MLkZYF0vvv7669Ufp9PpwcFBiacAGKPDrILW dT0Wj4c0rc5Dqr/A3r1XXXvtMcdMlQhnBhiAzVCAATQqj8ft8/mEJj2OO+649es3 VH/M8VeAZR1mBjiZSimKojtg80JYUZatWDGQFvl7OuMrbHwZYzEmgQHYBAUYQKMS 3QB82mnfmT9//jiOvwIs75AduHr9rxIMmjKkOktEo/dv3frmW28K5TMJDMBOKMAA GpVoAf7d7y46/fTTjR/E43HdvheoADZwyFXQRvsNhUK5bNaUIdVZZnDw5Zdfvm/L /UL5FGAAdkIBBtCo3G5XV1eXRLLxfvrxx5+YNm3aOI6/AizvkDPARgEO+P2lUsmU IdWZrutqILD41iVCl6IHAgGuAgZgGxRgAI3KaL9GB5ZInjhx4rPPPmf8YHBwMJ1O SzwCQA0d1IGNQhiPxzUHHH+1X9Dvv2HBDZNaWiTCOQgagJ1QgAE0JNH1z8cf/+lV q1aN4/groEEctAraOcdf7RfRtFWrV8fiUguVWQUNwDYowAAakmgB/l//6wf/8R// UZ1EEnoEgBo6cAbYUcdf7ZeKx7c//PALL70olE8BBmAbFGAADcnjcc+aNUso/Lrr rv/KV75ivNsrFotCjwBQW/s7sKOOv9qvkM2+9fbba+/+g1B+MBjkJiQA9kABBtCQ XK7W7u5uieTe3r69e/dOmjSJ46+ABrJ/FbRRgP09PcY/mj2iuioWi2FV/e3cuR0d MyTy/X5/IpGUSAaAOqMAA2hI7e3TOzo6JJKPPfbYxx57nOOvgMZSnQHWdT0Wj4ec dPzVfmogsPDmm8c3iby1owADsA0KMIDGI7oB+IQTTliy5Famf4GGY3TgVH9/MBgs OvLu7r5w+O577lbEyj/bgAHYAwUYQOMRLcBnnXX2T3/600SCSy+BBpPP5VIDA6qi mD0Qcwz29z/++ONP7HpSKJ8CDMAeKMAAGo/b7erq6hIKv+uuNdOnT+f4K6DhJJLJ UChk1GCzB2KOkq7v3bv39uXLhPIDgUA8zt8MAmh4FGAAjWf27NmtrdMkkgcGBt57 733WPwMNp3r7kaoojr27u1gsRjTt4kvmezweifxAIMjNcABsgAIMoMG43e6uLqkL kGbM6Lj77rszmYxQPgAhRvsNh8NZZ//h1QKBJUuXFvSCUD4dGIANUIABNBjRDcBf /eopv/rVr4TCAcgxCnDA7y+VSmYPxEyx3t5Nmze/t+d9oXy2AQOwAQowgAbj8bhn zZKaAb7gF//7m9/4hlA4ACG6rsfjcc2Rtx8daLC///nnn39o+zah/GAwGIsxAwyg sVGAATQYr9fr83VKJJfL5fXrNxxzzDES4QDkJFMpx95+dKBCoaAEAktuu7WpqUki X1HUaDQqkQwAdUMBBtBIPB53Z2en0Hu7SZNa7r33XolkAHJ0XU8kk469/eggit9/ /Y03Tpo0USK8XC6rqsokMICGRgEG0EhENwB/+tOfufrqq4XCAQgZOvxZVQv5vNkD sYRIKLR27dpwr9RR9mwDBtDoKMAAGonoBuAzzvjHs846SygcgARuPzrIQCq1c+fO p/74tFA+24ABNDoKMIBG4nK5uru7hMKvuvqaz3z600LhACQY7TcUCuWyWbMHYhUl Xe/Zu3fp8mVC+X5/IJFICIUDQB1QgAE0Ep+v0+v1SiQPDAzu3Llz4kSRjXMAJFSn fzVVLZfLZo/FKorFYlhVL7388lZXq0R+IBCIxynAABoYBRhAwxDdADxzZueyZVJz JgAkGO03HIlk02mzB2ItIUW5ffnydEbqy8I2YAANjQIMoGF4vR6fT6oAn3rq3154 4YVC4QAkGAU44PeXSiWzB2ItiWh0y9atb7z1plC+oijRKAUYQKOiAANoGG63u6tL 6gSsX//6v0466SShcAA1p+t6PB7XNM3sgVhONpN57dVXN27eJJQfCASNr7xQOABI owADaBhyS6BLpdKatX/wejwS4QAkJFOpYDBY1HWzB2I5uq6HFOWmxYuam5sl8lkC DaChUYABNAaPx+3z+caPF/mu1dLSsm7dek7AAhqF0fESyaSqKGYPxKLUQOCmRYuE 3uVVKhVFUbgMCUCDogADaAyiG4C/8IUvXHrpZULhAGquevdvoVAweyAW1ReJrFu3 LqAEhfLZBgygcVGAATQGj8c9a5bUBuCzzjr7jDPOEAoHUFtM/x5RKpl8+umnH3v8 MaH8YDDIDDCABkUBBtAYvF6vz9cpkVypVBbfsuS4OXMkwgHU3ND0r6oW8nmzB2Jd +VyuZ8+e5SvvENo2oihqNBqVSAYAaRRgAA3A43F3dnY2NTVJhBcK+kMPPcQGYKAh 6LpuFGBFUcZVKmaPxdKCPT1XX3fdlCmTJcLL5bKqqkwCA2hEFGAADUDu/GfDccd9 bNGiRULhAGrLaL+apuVzObMHYnURVV15553xZEIon7OgATQoCjCABiBagL/3vb87 99xzhcIB1FB1+ldVlArTv0eSise3P/zwCy+9KJRPAQbQoCjAABqAy+Xq7u4SCr/i iis/97nPCYUDqCGj/YZCoVw2a/ZAGkAhl9v97rt3rrlLKN/vDyQSUtPLACCHAgzA 6qZOnWLo6OiQCI/FYtsffqR12jSJcAA1VJ3+1VS1XC6bPZYGUCwWI5r2+/nzvF6v RL7f7zf+iwwOpiXCAUAOBRiA1Ymuf3a53CtXruQELMD6jPYbDoezmYzZA2kYoWBw ydKl+YLUcdmsggbQiCjAAKxOtACfcsqpv/zlL4XCAdQK07+jkIhG79+y5c233xLK pwADaEQUYABWJ7oB+Ne//q+TTjpJKBxArTD9OwrGl+u1V1/duHmTUD7bgAE0Igow AKubMaRdIjkcjux49FG3yyURDqBWPpj+1bRyqWT2WBpJsVgMKcrvfv/7jo4ZEvkU YACNiAIMwNK8Xo/PJ7X+ecqUqWvXrmUDMGBxQ9O/kUg2zXlLI6YGg4tuuaVclvqL A0VRolFWQQNoJBRgAJYmugH4i1/8m4suukgoHEBN6Lqe6u/XVLXE9O/IxXp7N23e /N6e94Xy2QYMoOFQgAFYmugG4Asu+MU3v/lNoXAANZFMpSKRSIbp31EZHBh48YUX HnjoQaF8VkEDaDgUYACWJrcBuFwur7pzdfv06RLhAGqC6d8xMr6AaiCw+NYlTU1N EvkUYAANhwIMwLpE1z9PmDBx48aNbAAGrIzp37FTAoEbb7qpuVmkAI9jFTSARkMB BmBdogX4f/yPv7zkkkuEwgGMHdO/NRGNRNatX+8PBoTyKcAAGgsFGIB1iW4APvfc 8773ve8JhQMYO6Z/a2Kgv/+5Z5/d/sjDQvmsggbQWCjAACxq6tQpU6ZMFbq+slwu 37FyVccMkXAAY8f0b63ohYISCNxy261y24B1vTA4yN9TAGgMFGAAFsUGYMDJuPu3 htgGDAD7UYABWJTH4541a5ZQOBuAASvTdd0owJqmlZn+rQX5bcDBWCwuFA4AtUUB BmBRbW3ezs5OoXA2AANWNjT9Gw5nMxmzB2IT0tuAVVXt64sKhQNAbVGAAViRx+Oe OXNmc3OzRDgbgAEr+2D6V1WNP6pmj8UmpLcBl0olTdOYBAbQECjAAKyIDcCAYzH9 K4FtwABQRQEGYEVsAAacielfIWwDBoAqCjAAK/J6vT4fG4ABxzHabygUymWzZg/E bqS3ASuKGo2yDRhAA6AAA7Act9vl8/mE9qqVy+WVq+6c0d4uEQ5gLKrTv6qiVCoV s8diN8bXVvH75bYBG99aFUWJxxMS4QBQQxRgAJYjugG4paVl3br1bAAGLKh69VE+ lzN7IPakBgI3LVok99aPbcAAGgIFGIDluN3uri6pDcAnnvjFuXPnCoUDGLWh6d9k UlHVcUz/yoj19m7ctOn9vXuE8gOBYDzONmAAVkcBBmA5Xq/H55OaAb7wwl+eeuqp QuEARm1o8bOqFvJ5swdiW5nBwZdffvm+LfcL5SuKEo0yAwzA6ijAAKzF43Eb7Xf8 eJHvTuFw5OFHHvF6PBLhAEZN1/VEMqkqitkDsTPjixxSlIsuvrijQ+QW9EqlYnRg zoIGYHEUYADWIroB+Nhjp61evZoNwIDVJFMpozvphYLZA7E5LRi85dZb9aIulM82 YADWRwEGYC2iG4BPOeXUX/7yl0LhAEZH1/V4IqGpqtkDsb9ENHr/li1vvv2WUD7b gAFYHwUYgLV0d3W53C6h8Llzf3/iiScKhQMYnWQqFQwGi7rUtCT2y2ezb7zxxj3r 1wnlU4ABWB8FGICFiK5/jsVi27Y/7GptFcoHMAq6rsfi8ZCmmT0QRygWi2FVvfiS +V6vV+gRrIIGYHEUYAAWIlqA29rali1bzgZgwDqGrj5KpYz2WyqVzB6LU4QU5fbl y9KZjFA+BRiAxVGAAViIy+Xq7u4SCv/mN791wQUXCIUDGAWj/YbD4axYGcOHpeLx h7Zte+mVl4Xy/f5AIpEQCgeAsaMAA7CKqVOnTJkyVeh+DsNll13++c9/XigcwEhV p39VVa2Uy2aPxUGKhcL777+/YuUdQvlGAdb1wuBgWigfAMaIAgzAKkTXPxvvxu7f sqV12jShfAAjZbRfLRTKZ7NmD8RZisViRNMuv/LKY449RugRrIIGYGUUYABW4fG4 Z82SugBp9uw5CxcuZAMwYBFD07/J5ND0b6Vi9lgcxyjAq1avjsWlOmowGIzFOAsa gEVRgAFYhdfr8fmkZoB/9KMf/fjH/yQUDmCkqoufC/m82QNxomQ8/uSTT+x6+mmh fEVRolFmgAFYFAUYgCV4PEb77Rw/XuSbUqVSuWXJrXNmz5YIBzBSuq7HEwlNVc0e iEPl83n/nj3L7lgh9y1XUVRWQQOwJgowAEsQ3QBsvMm79977WP8MWIHRflP9/SFN KxaLZo/FuRS//4YbF0ycNEkon23AACyLAgzAEtxuV1eX1AVIX/jCFy699DKhcAAj kkylIpFIJs0pwWbqi0TWrVsXUIJC+YFAIB7nMiQAVkQBBmAJPl+n1+sVCv/Zz37+ 7W9/WygcwPBVrz7SVLXM1UemGuzvf+GFFx7c9pBQPgUYgGVRgAGYT3T9c6lUWn3X multbUL5AIbPaL+hUCjH1Udm03VdCwZvvmVxc3Oz0CNYBQ3AmijAAMwnegHS1KlT 16xZywZgwHRcfWQpRgFevOSWYqkklM9lSACsiQIMwHxer9fn6xQK/+pXT/nVr34l FA5g+Lj6yFIS0eiWrVvfeOtNoXxFUaPRqFA4AIwaBRiAyTwed2dnZ1NTk1D+vHnz TzjhBKFwAMPE1UdWo+fzu3fvXrX6TqH8crmsqiqTwACshgIMwGSiG4AHBga3bN3a Om2aUD6A4ahefaRpWomrjyyjWCxGNO3SK66YNu1YoUewDRiABVGAAZjM7XZ3dUlt AJ4957iFN97IBmDAXMlUKhwOZzMZsweC/4tRgO+8665oTGqhciAQjMeZAQZgLRRg ACbr7u52uVqFwv/pn37ywx/+UCgcwHBUrz5SFYWzr6wmlUzuevLJJ3Y9KZRPAQZg QRRgAGYSPf+5XC7fvmz5LJ/U+moAw8HZV5ZVKBSCPT233r5U7hQGzoIGYDUUYABm Et0A3NLSsm7detY/AybSdT2RSKicfWVVaiBw06JFcu8H2QYMwGoowADM1Nbm7eyU ugDpy1/+n7/5zW+EwgEcUfXsq1AoVNR1s8eCQ4v39W26997d7+0WyldVta+Py5AA WAgFGIBp3G63zyd4AdJFF8394he/KBQO4IiSqVQkEsmk02YPBB8pn8m8/sYb6zas F8ovl8uKorITGIB1UIABmEZ0/XM8kdy2bRsXIAFmqZ59pamqUYHMHgs+0tBlSKp6 8aWXejxuoUewChqApVCAAZhG9AKkmTM7lyxZwgZgwCxD7VfT8rmc2QPBEYRVdcXK lan+lFA+Z0EDsBQKMADTiM4Af//7Z5x99tlC4QAOj7OvGkgiFtv52M5nn3tOKJ8Z YACWQgEGYA7RC5Aqlcqixbd87LjjhPIBHEb17CtN00rFotljwZHlcjn/nj3LV94x frzU20IuQwJgHRRgAOYQnf413sbde+99rH8GTJFMpcLhcDaTMXsgGC7F77/hxgUT J00SymcSGIB1UIABmEP0AqS//MsT5s+fLxQO4DCqZ1+pilKpVMweC4YrGoms37Ch J+AXyucyJADWQQEGYAKPx220X7kLkC688JennnqqUDiAwxhqv6payOfNHghGIDM4 +PLLL9+35X6h/HK5bPyuYBU0ACugAAMwgej6597evocfecTtcgnlA/gouq7H43FN 08weCEamWCyGFGXuvHnt7dOFHsEqaAAWQQEGYALRC5Da2tqWLVvOBmCgzj64+FfT yqWS2WPBiIWCwdtXLE+L7dzmMiQAFkEBBmCCzs6ZRk0VCj/ttO+cf/75QuEAPorR fkOhUC6bNXsgGI1Yb+/2Rx555dVXhPIDgUA8nhAKB4DhowADqDfR9c+VSuXa664/ /lOfEsoHcEhDF/8mk6qimD0QjFI2k3nv3XdXr10jeRkSq6ABmI8CDKDepAvw/fdv Yf0zUE/Vi39Dmlbk4t9GFvT7b1hww6SWFql8CjAAC6AAA6g3r9fj80kVYC5AAuqP i3/tQfoyJEVRolEKMACTUYAB1JXHY7TfTrkldv/xH//5la98RSgcwIdx8a9tZNPp V155ZfN99wrlG79DFEVlEhiAuSjAAOpKdP1zPB5/aNt2V2urUD6ADzPar6IoeqFg 9kAwVsViMayq8y65xOP1CD2CVdAATEcBBlBXbW1tnZ0zhcI7O3233HILG4CButF1 PRaPh7j41y6MAnzHypXJ/pRQvqpqfX19QuEAMBwUYAD14/G4Z86c2dzcLJT/ox/9 6Mc//iehcAAH+eDiX1Utl8tmjwW1kYzHn3zyiV1PPy2UXyqVNE2LxbgQGIBpKMAA 6kf0+CvjLfjSpbd3dXUJ5QM4yNDWX1Ut5PNmDwQ1Y/zXDPT03Lbs9qamJqFHcBQW AHNRgAHUj9vt7uqaJRR+1NFH33P3Pax/BupD1/V4IqGpqtkDQY2pgcDNtyyWO9Is EAjG48wAAzANBRhA/cyePbu1dZpQ+Mknf+U///M/hcIBHOiDxc+aVi6VzB4LaiwR jd6/Zcubb78llE8BBmAuCjCAOhE9/9kwb978E044QS4fwH7V9pvP5cweCGpPz+d3 7969avWdco/gLGgAJqIAA6gT0QKczmTvu+++1mlS08sA9mPxs70Vi8WIpl1x1VVT j5kq9AgKMAATUYAB1InX6/X5OoXCP/7xT1x77bVsAAakVRc/hzStxOJn++oNhdb8 4Q/hSFgoX1HUaDQqFA4Ah0cBBlAPHo/b5/ONHy/1Pee88/7tu9/9rlA4gP2G2m8o lMtmzR4IBA309z/37LPbH3lYKL9SqSiKwmVIAExBAQZQD6LrnyOR3m3bt7d5vUL5 AKp0XU8kEiqLn+3O+A8dUpS58+bNmNEu9AhWQQMwCwUYQD20tbV1ds4UCvd6vcuX r2D9MyDqg8XPoVCpWDR7LBAXCgaXLl+WEZvqV1Wtr69PKBwADoMCDECc2+022m9z c7NQ/ne/+73zzjtPKBxAFYufHSXe1/fwjh0vvfySUH6pVDI6MPchAag/CjAAcV6v x+eTWv9cqVRuXHjTJz7+caF8AONY/Ow8uWx2z3vvrVx9p9zZDYqiRKOsggZQbxRg AOLcbndX1yyh8PFNzfdu3sz6Z0AOi5+dSfH7FyxcOGHiBKH8QCDIDDCA+qMAAxDX 2Tmzra1NKPzEE784d+5coXAA41j87FSx3t4Nmzbt2btHKD8QCMTjCaFwAPgoFGAA skTPfzZcdNHcL37xi3L5gMOx+Nmx8pnM62+8sW7DerlHcBY0gPqjAAOQ5fG4Z82S Wv+cSvU/8OCDrdOmCeUDDsfiZycrFothVb308stbXa1CjwgGg9wGDKDOKMAAZInO AH/sY39yww03sAEYEMLiZ4frDYVWr1nT29crlM8MMID6owADECS9/vmnP/3//v7v /14uH3AyFj9joL//2WeeeXjHI3KPoAMDqDMKMABBouufI5Hebdu3t3m9QvmAk32w +FnTSqWS2WOBaYzfBiFFmTtv3owZ7UKPYBU0gDqjAAMQ5PV6fb5OofDp7e23L72d 9c+ABKP9apqWz+XMHghMZhTgZSuWD6bTQvmKokajUaFwAPgwCjAAKR6Px2i/48dL fZ/5/vfPOPvss4XCASfTdT2eSGgsfsa4cYlYbOdjO5997jmh/EqlYnRgVkEDqBsK MAApohuAy+Xyrbctnd3dLZQPOFZ18bPRfo0/ZWaPBebL5/OBvXuXLl/W1NQk9Ai2 AQOoJwowACltbW2dnTOFwo86+uh77r6H9c9AzRntV1XVQj5v9kBgFWogcPMtiyuV ilS+qvX19QmFA8BBKMAARLjdbqP9Njc3C+WfeurfXnjhhULhgGPpuh6Lx0OaZvZA YCF94fADDz301ttvCeWXSiWjA8fjHIUFoB4owABEiK5/rlQqV1519ec++1mhfMCZ WPyMQ8qk0++8/fYf7rlb7kwHVkEDqBsKMAARbre7q0vqAqRypbLl/i2sfwZqyGi/ qf7+cDisFwpmjwWWE+zpuf7GBS0tLUL5gUCQGWAA9UEBBiCis3NmW1ubUPhf/uUJ 8+fPFwoHnCmZSoUjkazYbTdoaNFIZP2GDT0Bv1B+IBCIxxNC4QBwIAowgNoTXf9s +M1vfvvlL39ZLh9wGl3XE8mkpqpyBx2hoWUzmddfe23Dpo1yj2AVNID6oAADqD2P xz1rltT651Sq/4EHH2ydNk0oH3Ca6uLnUChU1HWzxwKLKhaLYVW95PLLXa5WoUcE g8FYjFXQAMRRgAHU3uzu7laxN0lz5hx34403sgEYqJVkKmW031w2a/ZAYGkRTVt9 1119sahQPtuAAdQHBRhAjUmvfz7nnJ+efvrpcvmAowwtfk4kVFU1eyCwuv5U6pln ntnx6A65R7AKGkAdUIAB1JhoAY5Eerdt397m9QrlA45SvfcopGmlUsnsscDqjN8t IUWZO2/ejBntQo+gAAOoAwowgBoTLcBtbW3Lli1n/TNQE0O3/mpaPpczeyBoDEYB vn35snQmI5RPAQZQBxRgALUkvf759NP/n3POOUcuH3AOXddj8XhI08weCBpGIhrd sXPn8y88L/cIOjAAaRRgALUkev5zuVxecuttc2bPFsoHnKO6+FlV1Uq5bPZY0DDy +bx/z57bVyxvamoSegRnQQOQRgEGUEter9fn6xQKP/royXfffTfrn4Ex4t4jjJoa DC5avKgsdl+0oqjRqNRB0wAwjgIMoIY8HrfP5xs/Xuoby9e+9vV///d/FwoHnGPo 4KtwOCe2kxM2Fo1EHty27Y033xDKr1QqiqIwCQxADgUYQM2IbgA23hVdf8OCP//k J4XyAYfg3iOMRTaTeX/37jvX3CX3d51sAwYgigIMoGba2rydnVLrn8c3Nd+7eTPr n4GxqG791TStzL1HGC3F71+wcOGEiROE8lVV7etjFTQAKRRgALXhdrt8Pp/cyShf +tKXf/vb3wqFA05Q3fobiUQK+bzZY0EDi/f13Xvffe/sflcov1wuK4oSjyeE8gE4 HAUYQG1IX4A0b978E044QS4fsL1kKmW030w6bfZA0Nj0fH737t2rVt8p9whWQQOQ QwEGUBttbW2dnTOFwnO5/KbNm1unTRPKB2xvaOtvMqmpakXs/F44RLFYjGjaVdde O3ny0UKPUFWtr69PKByAw1GAAdSAy+Xy+Tqbm5uF8j/9mc9edumlbAAGRod7j1Bb 0Uhk3fr1/mBAKL9UKimKmkiwChpA7VGAAdSA1+vx+QTXP//udxf9zd/8jVw+YG9D 9x6FQrls1uyBwCZymczrr7++fuMGuUcoihKNsgoaQO1RgAHUgNvt7uqaJRTe3z+w 9YEHWP8MjI6u6/FEQuPeI9ROdRX0JZdf3toq9Z05EAjG49wGDKD2KMAAxmrq1CnH HHNse/t0ofw//dOPX3fddax/Bkbhg3uPVLVcLps9FthKbyi0Zu3acG9EKN/vD+h6 YXCQM9sA1BgFGMBYSZ///POfX/Ctb31LLh+wqw/uPQqHC4WC2WOB3QwODLz4wvMP PPSQ3CM4CxqABAowgLESXf9svPt5aNt2t8sllA/YWDKVCkciWe49goBisRhSlHmX XuL1eoUewSpoABIowADGapbP5/F6hMJ9vlmLFy9m/TMwUtx7BGkRVV2xalUylRTK DwQC8TgHQQOoMQowgDGRXv981llnn3HGGXL5gC1Vt/6GQqFSsWj2WGBbqWTy6aef fuzxx+QewSpoADVHAQYwJh6Pe9YsqfXPoVB4+8MPT29rE8oHbOmDrb+RSCGfN3ss sDPjd5oaCPx+/vyOjhlCjwgGg7EYq6AB1BIFGMCYdHd3u1ytQuFtbW3Lli1n/TMw IslUymi/Gbb+Ql5IUW5fviydyQjlsw0YQM1RgAGMnvT65zPO+MezzjpLLh+wH7b+ op4Ssdhjjz32zHPPyj2CVdAAaosCDGD0RNc/l8vlpUtv7+rqEsoH7Ietv6izQj4f 2Lv3tuXLmpqahB7BKmgAtUUBBjB6ojPAU6dOXbNmLeufgeEz2q+maflczuyBwEG0 YHDxkluKpZJQPjPAAGqLAgxglKTXP5922nfOP/98uXzAZnRdj8XjIU0zeyBwllhv 7/ZHHnnl1VfkHkEHBlBDFGAAoyS9/nnR4lv+5GMfE8oHbGZo8XMyqbL1F3WXy+V6 3n9/+co7WAUNoCFQgAGMkugMcEvLUevWrWP9MzAc1a2/4XC4qOtmjwVOpAYCNy1a JPemkhlgADVEAQYwGqLTv4avfe3r//7v/y6XD9hJ9eCrXDZr9kDgUNFI5MFt2954 8w25RzAJDKBWKMAARkN0+rdSqVx/w4I//+QnhfIBO9F1PR6Pa2z9hXmymcz7u3ff ueau8eOl3lgyCQygVijAAEbD6/X4fFIFeMKEiRs3bmT9M3BE1cXPmqqWy2WzxwJH U/z+G2++ublZahuwoijRKAUYQA1QgAGMmMdjtN9Oub/pP+mkk3/9618LhQO2YbTf VH9/KBRi6y9M1xcO379167u73xXKr1QqiqIyCQxg7CjAAEZMev3zFVde9Ref+5xQ PmAbbP2FdWTS6XfeeusP6+5hFTQAi6MAAxgxr9fr83WKxY+/7777WP8MHN7Q1t9E QlNVswcCfEDx+6+/8cZJk6S+eyuKGo1GhcIBOAcFGMDIeDxun88n93f8X/rSl3/7 298KhQP2wNZfWFC8r2/T5s27339PKH/fKmiFs6ABjBEFGMDIiK5/Nlx55VWf/exn 5fKBRlfd+hsOhXS2/sJK9Hz+3XffvfOu1XKPYBU0gLGjAAMYGdH1z7lcftPmza3T pgnlAzbA1l9YU7FYjGjaVddeO3ny0UKPYBU0gLGjAAMYAen1z3/xF38xb958NgAD H4Vbf2FlsUhk/caNe/09QvmsggYwdhRgACMgvf754ovn/dVf/ZVcPtDQ2PoLi8tn s2+++ebd6+6RewSroAGMEQUYwAi0tXk7O6XWP6fT6fvu38L6Z+CQuPUX1lddBX35 VVcec8wxQo9QVbWvj1XQAEaPAgxguDwej8/XKbf++VOfOv6KK65g/TNwSGz9RUPo C4fvWbcuqCpC+ftWQatMAgMYNQowgOGSXv/861//10knnSSXDzQutv6iUWTT6Vdf fXXTvZvlHsEqaABjQQEGMFyi659Tqf4HHnyQ9c/Ahw1t/U0mVVWtVCpmjwU4gmKx GFbVSy+/vNXVKvQIVkEDGAsKMIBhcbvdPl9nU1OTUP7HP/7xa6+9jvXPwEGqB1+F QyGjV5g9FmBYekOhNX9YG45EhPLL5bKiqPE4Z0EDGA0KMIBhkV7//Itf/O9vfOMb cvlAgxo69lnT8rmc2QMBhmtwYOClF1/c+uADco9gFTSAUaMAAxgW0fXPiUTywYce crVKrZcDGpSu67F4PMTWXzSUYrEYUpRLLr/c7XYJPYJV0ABGjQIM4MiMNzE+n09u /fNxx31swYIFrH8GDmS030QyqbH1Fw2oV9PuXLOmL9onlL9vFbQSjyeE8gHYGAUY wJFJr3/++c8v+Na3viWXDzSc6tbfUChUYusvGtDgwMCLLzz/wEMPyT2CVdAARocC DODI2traOjtnCoXH4/GHtm1n/TOwn9F+U/39vb29bP1Fg6qeBT3vkks8Xo/QI1RV 6+uTmmEGYGMUYABHIH3+8+zZcxYuXMj6Z2C/ZCoViUQy6bTZAwFGL6Jpq1avjsWl Jmk5CxrA6FCAARyB9Prn8877t+9+97ty+UBjYesv7GGgv/+5Z5/d/sjDco9gFTSA UaAAAzgC0fXP0Whs2/btbpfUSaFAY/lg66+mlUols8cCjEn1LOiLL5lvvIgIPYJV 0ABGgQIM4HA8HvfMmTObm5uF8ru6um+++WbWPwPj/nvrbyQSKeTzZo8FqIGIqq5c vTqekFqlXCqVNE2LxVgFDWAEKMAADkd6/fM55/z09NNPl8sHGkgylQqHw9lMxuyB ALXRn0o988wzOx7dIfcIVkEDGCkKMIDDEV3/3NcXfWjbNq9H6oxQoIHouh5PJDRV NXsgQM0Yv6v3rYK+ZPp0VkEDsAoKMICP5Ha7jfYrt/65s9N3yy23sP4ZqG79Ndpv uVw2eyxALYVV9Y6VK5P9KaH8UqlkdGDOggYwfBRgAB9Jev3z2Wf/y/e//325fKAh VLf+hkMh4wdmjwWosf5U6umnn9r52GNyj2AVNIARoQAD+Ehut6urq0soPBLp3bZ9 e5vXK5QPNIqhY59DoVw2a/ZAgNqrroKeO2/ejBntQo8IBALxeEIoHID9UIABHNqk SRNdLndHxwyh/I6ZnbcuWcL6Zzjc0NbfeFzTNLMHAkgJK8rylSv7B/qF8v3+QDo9 WCiwgALAsFCAARya9Prnn/zkJz/4wQ/l8gHrG9r6m0yqmlZh6y/sK5VMPrXrycef fFLuEayCBjB8FGAAhya6/jkcjmzbvn16m9S5oID1VQ++CodCxWLR7LEAgozf6mog 8Pv58+WWFLEKGsDwUYABHMKkSZNcLpfcm5X29hlLly5l/TMcq3rwVW9vbz6XM3ss gLiwoixbsWIgPSiUv28VdLpQKAjlA7ATCjCAQ2hvn97R0SGX/6Mf/b8//vGP5fIB i0umUpFIJJNOmz0QoB4G+/ufeOKJx598Qu4RoVAoEumVywdgGxRgwIm8Xo/xv5XK 0I8nT57s8bjrPIDlK+7omCE1vQxYnK7riWRSU9VK9Q8hYHcTm5vj0ehlV11Z5+cG AsHx44fe6+77n3HRKPuEAVCAAbtzu13j9zHeaRvvtsvl8tFHHz19elv1PYFZ1v7h 7tZp00wcAGCW6tbfkKaVSiWzxwLUScukSQPJ5Nz580wcg/EK2Nvbl81mm5qa9r0q Dv2Mgc3DgNNQgAG78Xg81R8Yr+vGK3xn50zjxd7cIX3YggU3HjttWnNzc9M+1Yq+ /1enTJ7M9mDYUnXrbyQSKeTzZo8FEFTtlsYPSqVSuVye0NQUj0avu3GB2eM6mDE2 VdWqL5fVn+E0acD2KMBAw/N43NUJXuOFfPLko71er7mzu8PxyU9+cvr0dqMDT548 +aijjpo0aZLReCdOmtRimDRpxowZbperoOsTJkwwSnL1U2jFsIGhY5/D4WwmY/ZA gNowqmOxWDRarq7rhf/WMnFiuVIx/jlfKOSy2cF0enBgQFXVd9/bbfZ4j8D41wkG g8br6b6/mR36x1gsbvagANSY1d8lA/go1Zleo+vOnNlhwTnewwuHI8abi4n7eq/R cof+t7l5UsvQ/xmVuKOjo9XlMrrwtNbWY445ZsrUqVOmTOmYMWPyvg5sOLDhG29Q jG5sVGgT/3WA4TAaQjyR0FTV7IEAR1advz3om225XDbqrvE72ai1Q2uJx4/P5nID AwOpZDIej8fi8WQymcvlSuVSUf+gFRsfP9SJdb1cKrXPaDfvX2g0jH9fTQtVvxTM DAO2QQEGGkm19BpvQlpajjJ9H2+tHHgOUPXHkXB4fFPzpH2OPvooo/dOnXpMe3u7 y+XytrW53e7q1HHLvtJrfMrMmTO7Zs0y3malPzSxxrwxLKK69ddov8ZbarPHAhyB 8X3V+B07ODholNimpiajuxq11njFGRwYMFputK8v0tsbjUbzhXze+IVcvqpcNiru 0OmGB7422eZ1at95Wsa/ztBfN1OGgYZmh+9KgO0ddVTL1KlTjdfdGTPa9y8Jdohq JTb+NxLpNd6HtbQMTREfu29a2O1yHXX00UbvnTJlytEtLXqxOLFl0pTJU4yGPPWY Y442TJ7caZTjjg7jU4w3Ycb7uYMaMvUY9VHd+hsKhYq6bvZYgCHGN1Wj3GYymaEC m81OaG4u6Hp/KmU0W6PKGr9jjV9Np9PGDyZNmmT8IJlMGnU3bXwPTaeNwmv8anv7 9P8+YNlZbyaNf/dwOFKplAcHB43yb/ZwAIyYs75nAQ3H4/EYb1OOOmpovtfssVhI 9XiVSDhifA9rbmr2eD3Vk7Sqv9TX1zdp4iSj/U6ZfPSxx0471qjLxxzbOm2a8TPj m8a73B7jn41KfMR6PI6GjBoZmvsNhfLZrNkDgYNUK+6+pcpZo+I2NTfrhYJRcXt7 e42fMTrtwMCA8b/poV83arDx2zNbKOT3nyJRXfAci8ZK5dK4yrj2Ge0HnVYIvz9Q /ZowIQw0Fr6RARZlVF/jnUZnZydvOGrIeDuYiCdaWlqOOtr4v6OmHmP042OmTjUa 8TGTWlqMEu32eI899tihyWPj/6dM8fl8HTNmVDcY05AxOsbvnFg8HtI0swcCuzEK aj6fr1bc5qYmo98aP0imUn19vblsLrOv5Q7N2Gayudz/ae9Oo9u6DgOPgwBIcMG+ EgQXOd5kyatORiexk4mbuM2XzOnifGhzmqRfm9M5dWc6mU7ddHEybZxJOk7t1LIl L7Js2Wm8dNKmdu04cb3JbrVZi2VLtkiA+4Id3LDOfe9RFERSJEjiEiDf/2cLAkHo vieJBN5fb7nT4rPq0cpZp9OhtyOJpCqVSoPKnN4cFw1sGmxYA3VHO9G3s5P03Wjq 7o6JxkblYtTNzc0ig62atrY2q7WxqUn8jbg9nrlCbhPxO7cPWXyojbBkJBvoZB0T XxLxRGJI2T4urfxsoIy2/1a53NTMjNlonFX7NplIjI2Pz6imp6am1PoVGZzN5WbV s3Fzuazb7d50V0bc7MQ3+MCAcn07Mhiof2xeA3XE6/WIjWTSt26J7dFYLNZoVhK5 udnSbLFoISxiWcSwzWYzmkyinJVCbm1t0ah3OkMh0clms1kb53KdbCCVtxbtwlfD w8OFfL7W64I6UiwWxdeGyFelbE0m5f4FyWRSubjUrHJxKfHZbHZW2WmbzebzuRnl klOz+VzW6XKxC7c+aRks3sAnJshgoH6xkQ3UBYvFYrfbgsHNN6ERyomtn+HhEWVK pzlqLDc1Kh3c2tKs7FduFsVsMpvFHavV2qzuaNb2Ns+ncnsgsGBWp2WCuRJEdU1o F74aHR0V1VLrdcFG0A5I1sJVy9qZ6ekZ8YB6m0qlosplkxXiMfU2m81lC4WiiNvs bFb7VD6fb1fPtq317wZrJ74ShoeHU6n0LN/7QF3iFRaoPY/HYzabg8H2Wq8INojW yUajsVGZA1n8UEpZmw5ZNLDF0iwC2GKxiA9bW9vEIyX1n0ja2tqaVWpHN1c+9XFH R8eNN9yw4tMWZDbZvE6JZHJkdHR6crLWK4KlTU9NjYyMVPjkVvWC8zPqpD/akcZT k5PRWEzErfjGER2bz+XVyW5zOWWW3FyhWCoURNcqn9QeFVFE2epKOBwRL/IcEQ3U IV6IgVrSdgOGQh1sFeFytGuxToxPiC8SNZdNJpNZU+EIJnX6KItFZHaTcty2GtAt 6m7nVlHYbW3KT62tYkH5QqFVOd/Z6vX5erq7nQ6H1N9aJXu2N2mHK6f+xuODg4O1 XpG6YzSZioVCdccUadpkNov+nFRpJ8ZqJ8eKVtVm+lH2us7OqntdVUq15iqflUqU TEEUraDcFMTfr/i2LL/+PLCYen2sIXW2pJlarwuAi3jVBmrG6/W0NLeITaharwiw hLnwnohqe6qV8DY3mi/Ed2OjGuKmuXvKI01KnYu8aTQ3mi88STS3yWhqVHZoN2kP KPuuGxu1zypxMjPTOD+i2SwiXYzV1KQ8uVk9tbo9EJDd4TLEE4lIOCz+AGu9InKJ FrSof1miacXfpkhE0ZeiE7OzWdGJOSUVlVbM5+fKsVBUiGfmlATNiqeJJxS15xQK WmEW8jnxNOUX5PJzD6o3ytPy2jMKcw+LEM3nxReqz+clRFG3IhFlVzBnBQP1g3cL oDb8fn8g4OdCJsDytDmftTtjo2PFUlF0jtGofOMY1ehR7piM2iPlxKfE4xu/wnNK peKmuuyz6NDF16kuFkWKltQ7c58Vj4g74k9bvHxpwcncsMCKCoXC6OiYUOsVAaDg TQvYaNrkOsFgO9e7AgBAD9QrY41kMpnp6elarwugdwQwsKE46RcAAB3ilGCgTrAJ DmwctX7bQiGm+QUAQHfUBh7MZCZpYKCG2AoHNgj1CwCAztHAQM2xIQ5sBOoXAAAY aGCg1tgWB6SjfgEAwDwaGKghNscBuSwWi81m46pXAABgnnZNrHQ6PTs7W+t1AfSF LXJALo/H09XVWeu1AAAAdae/fyAajdZ6LQB9IYABidxud2dniPl+AQDAYsVicWBg MBaL1XpFAB0hgAFZLBaLy+Vqbw/UekUAAECdCocjU1NTHAgNbBgCGJDCam3zen1O p6PWKwIAAOpaJNKfzc5mMpO1XhFAFwhgQAoOfgYAAJXgQGhgIxHAQPVZLBan0xkM ttd6RQAAwCbAgdDAhiGAgSpraWkJ+P1Ol7PWKwIAADaNSKR/WlXrFQG2OAIYqLJN dPBzoVAQt21tVmMFrwSlkvi/KF40SurBWoV8vlDI53LitpBTfsrnsrlCsRAMBpnx GACwNqVSaWRkxNhgNJtN5sYmodFsbmxUPjCbTPPvrca5962G+RvDwo3aBvGeJd6d pqanxAcmk2mjfgdrx4HQwMZgOxWopuZmi8vpCtTllZ9HRkb9Pp/Pr7jqqqu+9KUv 3XLLLY2NjesfWWyvFFSjo6NnPvhgMp0eGhzs7e0dHhmJRqPxeDyRTKRSaY4JBwBo xFuSzWa1Wm0et0LcdnR0fGLbtkAg0NzcPJPLZXO5K7Zt237ddetcUCqVOnz48Jkz ZyJ9fSKtBwYHR0ZHxXtTfb4lhcOR6empmRkOhAYkIoCBavJ6vaFQR53sAh0eHmkP +Du7unbs2PnlL395165dZrM5l8tph1e1tLRUpX7LaYMvHllsapx+//3+/v6RoaGx kZHevr633zkk/qwWj1Anf3QAgDUrlUqLH5yYmLj1U58WfdvV2XnVlVeKO6JyZ7PZ bdu27dixY8GTL/dusgaL3/VEEh85cuTkyRNnP/gw0h8Jh8Ojo2PBjuA6F1QV4o9u cHBI/FnVekWArYxtTaBqvF5PMBis7XFWw8PD3V3dO3bu/MpXvnL77beLnpSXu5Vb srpj0eibb711+PDhgf7+ZDKh7CaOx1Pp1OTklN/vMyyKYdoYAOrHgsrVPhwbG29r a7Xb7U6H0+vx+Px+j9vt9fuvvvrq22691e64ZGrAKlbuqix4SxI9/Pbbb79/6tSx Y8feP3NmYHCgo6NjI9dngUKhIN7KJyaiNVwHYGtjgxKomm09PbW69tXIyOi11177 1a9+9bd/+7ebmppqskmxBpfbHS2S+K233jp+4sTQwIBo42QylRQ/ytpYU57E5DEA VFd54pbfHx8bbxWVa7M77Ha32+33+12Cx3P1NdfcfvvtzqUq11Drf4ddRnmHJxKJ l19++e033zx2/Pi5c+dqdUJTJNLPmcCAPGwyAtXh8bhDoRpc+8pkNH31a18T6Ws2 m+t282INLrfNFIlE3jl06MTJk0NDQ6lUMp1Kx+PxlJBOFwt5f0DZWNFieD6JaWMA uJz5stXuzO3IHR01msx2m81utzscDrfb5ff5naJy3e7du3d/5jOfWTBI/VduheZj 2GQ0vv3WW/ufeOLQoUONTRv9OyoWi4ODg9EoDQxIwXYhUAXNzRaPx+Pz+VZ+avWI 4v2TP/lfv/7rvy7ubORya+5yW1qZdPrNN988/t57AwMDyURC5HEsFkunRSNnxPNF HhsajIGA33BpIZPHALa28rLVbkdHxwylokhc8SoqKtdmszodTvEuJlrX7nR2d3ff duutO3buXDBOrY5YrqFUKvXGG2/88tVXf/7qqw2VzJdQPZGIMi0wV8MCZGDLD6gC t9vV1dW1YSk1MTHxR//tv3/1d3/X6XTqZ0OkEsvshRgeHj569Mi//8fhkeFhkcqZ TCaRiCdTqclMZmp6pqgoiE1D8ZcYCAQoZACbxYK+HR0d1e6bTGaj0dja0mK1ttlV LpdbiV2b7corr9y1a9cnP/nJBUNtmR251aL9gRSKxZdfeumlF1989Re/8Hg9G7No 8ZfY398fi8U3ZnGArrBhB6yXxWJxu93arsUNYLVa77//gZ07d7J1slrLbNsl4vG+ vr73z5w5ffp0OByempqanppKpZKZzOTk1OTMzKzYFlEjuVgqFhqMxvJIppAByFNS aXfGRkeLyr/TGTXixae52WJtU4iuFYnb2tbm8Xo7OzuDweCNN9xwub24BhJ3NeYy OJ//yTPP7Nm3d8lrXMsQDis7gWdn2QkMVBnbbcB6OZ3Onp7ujamg66+/4b777vN4 NuhfoPVmmU3DWDTa39//4Ycfnvvoo+GhoVgsNjMznUymMkoiT4pflS/kiwXRx0t0 MnuSASw2n7VK2Y6NidcOw4Wy1epWubJDa6tSt62tNpvVbnd4PR6rzebz+6+99tpb b73VZrMtGHP+RcxA4kog/nj/3/PP7923b2xifAMWJ74wRAMnEokNWBagK2yQAeti sVicTkcwuBHzB+7cef0Pf/hD6reGlt95MjY6OjQ8/NG5cx/39saj0bHx8VQqOTsz m1YjeUb8yumpfGHuWGux6au0shLMhYYGo9/vY5cysAVcssN2bFx8i4tv8AZ1p63J JLJW/KfcaWkWryIib5W+tVqt7YGAzW43NzZ6vd5rrrlm9+7dTucScwqw/7bmtAZ+ eN++8Q1pYPWIpGl2AgPVxWYWsC4btvtXbCk988wz3d3dsheEdVpmD0wqlTpy9OjE +Hg8FlPCt1BQL9aVisVj4xPRabGZM6PI5rIim7PZ2YK6L1l8bYlYLhSKFw/DVjap G/z+VRx1X9vpqYH6JL4HK3+yspNWPfxY+1cq8ZPJLIrWpMZtg7hnbmxqtliamy1K 2La0tFnbRNY2t7aJ7z7xTuF0ua668sqbb755ybI1ELebh3itfvrJJ+974AGTSfq8 D+wEBmQggIG127Ddv+It8MEH93z605+WvSBIVfnRiR9++OHQ0NDs7GwiHle2tUul ZCqVViZ7Ui7fNTk9nUmnxSZRSUljg9gSF18hYvD5Xy5GNjZc3DITIT04NCjv9wVs Uj6vz6he2lf7likZ5nbeNswdiqH826aSuuoeXK/HI9q1QT3z1qZODtTT07Otp6e7 p2fxocjzOCZ5S0rG4w/t2XPwx89swD9/sxMYqDoCGFi7Ddv9+zu/85W77rqrqalJ 9oJQJ1a70fzRuXNDw8NZYXZW/FplWpO2NnGnkFcUCoWfPPecMqPG7Kx4gvgh/svm srlcXjxHfYq4Ix5RPioWi4GAnyOxselcOJl23Gg0NjaaG83mxiaLuG1SNKq3yu5Z ZSdtS6tyjq3R+OU77xSfMDc2drS3+/1+l9u94lIIWmjeffvtvfv2Hjl2TPaC2AkM VB3bN8AaiQ0ph8MZDLbLXpBomaeeOtjV1SV7Qdi8yjfKDavfLo9Fo6KAJ2Kx0dFR LZjFbTqVmpycFG1gbmhQTl+eVnZBTKu3Gi2elWoWLZ0viNuC8ksLWnMXlYO2i8pd 5QPlzGetroulkniKWKh4XFnzvHY/XzIYioW8cjr0hfymwDeX0gVjo2MldY5Z8fdn Umcpb1RvTWZTg6FBPKJd40l8ZZmMJsFsFv8r943KfSVcTeqtmq3iC7mpqJ4vIL4U m8XLrnKMsXL6rPgp2N4e8PvtDkcoFBKvk3a7vfK1Xee3DCBeIfft3fvEkwc2YFki gMVrMHMCA9XC5gWwRm63u7MzJDbjZC/oL/7iL3/jN35D9lKABUmgkRcGYvNRu2Nb qlu0z4p+zmQyyp1CYXpqSrlwWKE4NTmZTKWisVg2m1WDuiRqfMHJnOJB7bMy1nxL Ei9loi3LP2xoaBB1KirU7XKJthTZqT3Y2tYqClXcEV8bZrVsgx0dUtdtya9MA9WK mkqlUocOHXr1lVdeefXnspclXsoGBgZjsZjsBQE6QQADayE2vNxul8/nk72gW2+9 7Tvf+Y7L5ZK9IGATuVwRQQY6E1hMvAplJiff+OUv9x944nxvr+zFRSKR6ekZXveA qiCAgbXweDwdHUHZV9adnc3+7Gc/u+KKK6QuBQAArEEykXjowQcf2rfPbr/shdCq olAoDA0NR6NRqUsBdIIABtYiGAwGAquYhGZt/vAP7/r617/OmZAAANShVCr12muv vfzSS28delv2ssLhSDwel70UQA/YsAZWzePxhEIdss/+7enpefDBPRswxxIAAFiD XC6XTCZf+tnP9j36aDKVlLqsYrE4ODjETmBg/QhgYNU2YPYj8T63d+++3bt3y1sE AABYv1Qy+fCePQcOPiX1X8aZDwmoFgIYWLWOYNAv+fjnL33pv9x9993Nzc1SlwIA ANbvjdd+ueehh9//4IzUpZw/35u6cP18AGtGAAOrJvsE4GQy+fLLr1x11VXyFgEA AKolk04f2L//b+691+P1yFsKpwEDVUEAA6vj8bhDIbnT//7mb/7WN7/5TXb/AgCw Wbz+i1/sfeSRU++flrcI9TTgwWiUCYGBdSGAgdWRfQJwoVB4/PH9u3btkjQ+AACo unQqtfehhx4/8IS8KRI5DRioCgIYWB3ZJwDv2LHz/vvvd7vd8hYBAACqK5fLPbl/ /4GnnoonJB6lzGnAwPoRwMDqBNvbA+0BeePfddcf3XnnnSaTyWg0mlTMAwwAQJ0T XfrG66+//K//+vqbb8hbCqcBA+vHhjWwCrJnAJ6cnHro4Yd3XHfdkp8VJVwexvNk z0gMAACWNzs7G4lEXnnppf/7d39ntbZJWgqzAQPrRwADq+Byubq7u+Ttkt15/fXf +rNvOZ3ONY+wII/ZjQwAwBoUl1IoFLQ7JdWCX5LP5//jnXcee/zxyEC/pLUSC41E +tkJDKwH28TAKvT0dIsGljf+H//x/7jjjjvkjW9gNzIAQH9ENy4ZtOXWv5RcLnf6 1Km33nzzn372z+sf7XJ6e3uTSU4DBtaOAAZWIRAIBIPtkgafnp55cM+eyx3/vJHY jQwAqGcr1uzi3bMbIJFM9vX1nTh2bN8jj7S2tUpaCtfBAtaJzVmgUk1NjW63p13a FbB6tm371rf+vDMUkjR+dZWHcXkwE8kAgFW5XMFWd/fsBhABPDI6eu7MmRdeeGFo ZFjSUsLhyORkJpvNSRof2PLYVAUq5fG4Q6GQvEOFv/7137vzzjubmpokjb/xysOY SAaALU+r1uWPN67JvtmNkcvlUun0R2fPvvH66z//xauSllJUroM1GI3GJI0PbHls hgKVcjqdPT3dkuJtbGz88f37b7zhBhmD1zPtnOT5Qi6/pZMBoIaW6dj5T23hml2b RDLZ29t7/PDhv/vRjwIBv4xFiD/zcDiSSCRkDA7oAduXQKU6QyGvzytpcLvD8b3v /Z9tPT2Sxt/sjCo6GQDWoDxlF2Rt+Ye1Xs2tQATw8MjI6ePHn/7xM5NTU5KWwmnA wHqw4QhUSuoVsD53+6/81z/4A6vVKml8nZi/xvV8IZffIZUBbHaVdCx7ZWtIOwr6 47Nnn3322ROnTkpaCgEMrAebg0Cl2hWyroD1rW/9+W233SZpcCwmYnjJSNbukMoA 5FlwCPGSxxXTsZuXaOAPzpx559Ch5154XtIiwuEIUwEDa8ZGHlARj8cTCnVIugLW xMTE4/ufuH7nThmDY/2MKyGYAV1ZcKmnZT4kYnVIOw34vSNH7v/7H/l8PhmLUK+D NRSNRmUMDmx5bLQBFXG5nN3dsq6AZbXZvv/9H3AC8JZBMAN1q3RBeaMu+eH8/Vqv MjaZudOAjx176pmnp2dmZCxCfFlGIpF4nOtgAWvBRhhQke6uTrfHI2nwO+741d// /d9va2uTND7qX4OqvJAvd7/WawrUxnyOlmfq8gVb61WGTuVyuXQmc/7cueeee+7Y e8clLaW3tzeZ5DRgYC3YlgIq4vf7Ojo6JA3+l3/5V5/61KckDY6treECLY8rvFPr tcZWVrq88nBd8sNarztQNQORyM9feeWZn/yDpPHPnz+fSqUlDQ5sbWwGARWRegWs 73733ptvvlnS4ECFFrd0ufInLP/ZWv8+cIn5g3jLU3PFx5dR298OsCnkcrmzZ88e O3z4yacPSloE18EC1owtFWBlUq+ANTMz++CePddt3y5jcKA+zTdzVW4XDLvkstb2 4ILeW5x/yz9hyQ8rua3kCQDqViKZ7AuHTx49uu/RR1taW2QsgutgAWtGAAMrc7vd XV2dknZtdYQ677nnns5QSMbgAABgg4kAHhkdPfv++z959tnxiXEZiyiVSv39A7FY TMbgwNZGAAMrczqdPT2yLgH91a997ct3ftliscgYHAAAbLBcLpeZnBwaGHjpxRdf efXnMhYhAjgcjiQSXAgaWDUCGFhZKBTy+bySBv/e9/7PjTfeKGlwAABQEyKA/+21 1/Y/eUDS+OfP96ZSXAgaWDUCGFiZ1EtA33vv92666SZJgwMAgI2Xy+XOnT179MiR Jw8+JWkRXAgaWBsCGFiBxdLkdLqCwXYZgxeLpQd+9KNrrr5axuAAAKAmEslkOBI5 dfz44/v3m8wmGYsIhyNTU5Ozs1kZgwNbGAEMrEDqJaC/8IU7vvGNb7S1tckYHAAA 1EQul0tnMh+fPfv8888fe++4jEVwIWhgbQhgYAUul6u7u0vSFbDuvvvPPvvZz8oY GQAA1Fakr+9fX3rpuX98QcbgpVIpEulnNmBgtQhgYAUOh2Pbth5JAcwJwAAAbEmy TwMWAdzXF04mkzIGB7YwAhhYQbsiIGPkkZHRJ5966vqdO2UMDgAAaiiRTPb29r53 5Mh9998vaUOCC0EDa0AAA8tpbm52OBySroBVKBQf3LPnqiuvlDE4AACoIRHAg0ND xw8ffvSxxxqbGmUsIhyOTE9Pz8zMyBgc2KoIYGA5Ho+noyNoMkm5fuPnP/+Fb3zj G1arVcbgAACghnK5XCqd/vjcueefe+74ifdkLKJQKAwNDXMdLGBVCGBgOW63u7Mz JOkS0N/85v/8/Oc/L2NkAABQD8K9vS/+y7/84z/9VMbgxWJxYGAwFovJGBzYqghg YDlOp7Onp1vSFbC++917b775ZhkjAwCAmsvlcmfPnj12+PCTTx+UMX6pVAqHI4lE QsbgwFZFAAPL6e7qdHs8MkYWb1rf/vZ3du/eLWNwAABQc9p1sP7jnXeee+F5Sf+Y LsZPJrkOFrAKBDCwHHl7gBOJ5GOPP37d9u1VHxkAANQDEcADg4OHDx168OGHXS5n 1cdnDzCwBgQwsJzu7i632y1jZEtzy3333XfFtm0yBgcAADUnAnh4ePjU8eP7DxzI F/IyFsEeYGC1CGBgOX6/r6OjQ8bIX/v67935W79lsVhkDA4AAGoul8tlJieHBwdf evHFl3/+ioxFnD9/PpVKyxgZ2KoIYGA57Qopk9d///s/uP7662WMDAAA6sfQ4ODr r732+IEnZAweDkfi8biMkYGtigAGLkvqJMD33vu9m266ScbIAACgTuRyuXNnzx49 cuTJg0/JGJ+pgIHVIoCByxIBHAp1yJgEeGRk9KmDB3fu2FH1kQEAQP1QLgTd13fi yJG//eEPg8H2qo9fLBYHB4cIYKByBDBwWW63q6urS8YloEslw4N79nziiiuqPjIA AKgfIoCHhoffO3Lk0cceM5mrf0xZqVTq7++PxTgKGqgUAQxclrw5kDwe73fvvber s7PqIwMAgPohAnhkdPTMiRNP//jHqXT1L9fMTEjAahHAwGV1BIP+gF/GyDfffMuf /umf2u12GYMDAIA6kcvlkqnUB6dPHzx48Hxfr4xFnD/fm0oxExJQKQIYuCyfzxsK hWSM/IMf/O3OnTtljAwAAOrN8ODg6//2b489sV/G4MyEBKwKAQxcViAQkHG9CgOX gAYAQDdkXwiamZCAVSGAgaXJuwR0qVT6zv/+6//0yU9WfWQAAFBvlAtB9/Yefvfd Z59/TsaFRbgQNLAqBDCwNI/HHQqFZARwOp3e98ij123fXvWRAQBAvREBPDg4+O/v vPPw3ocdDkfVx1cDeDAajVV9ZGBLIoCBpbnd7q6uThn/Umsymx+4/4ErmAMJAAAd 0GZCOnH06P4n9pckjK/OhDQQixHAQEUIYGBpLperu1vKJMA+n/+v/+ZvmAMJAAA9 0GZC+uDkyWf+4R8SyerPVyQCOBLp5zRgoEIEMLA0h8OxbVuPjAC+6aab7777buZA AgBAD3K5XDyROPLuu//405+GI+Gqjy8CuK8vnEwmqz4ysCURwMDS/H5fR0eHjJHv uefbu3fvljEyAACoQ4lk8tSpUx+cOvXsC8/LGJ+ZkIDKEcDA0uTNgUQAAwCgK7ID mJmQgMoRwMASPB5PR0fQZDLJGJwABgBAV0QAnz516oy0AC4UCkNDw8yEBFSCAAaW IG8S4ImJiQNPPsUcSAAA6IcI4L6+vhNHj/7wgft9Pl/Vx2cqYKByBDCwBHkBnMvl H96798pPfKLqIwMAgPqkzIQ0NHTs8OF9jzxiabZUfXwCGKgcAQwswe12dXVJmQPJ arP94Ad/29PdXfWRAQBAfRIBPDwy8v7x408+fXB6Zqbq46tTAffHYpwGDKyMAAaW 4HI5u7u7ZQTwNddce8899zidzqqPDAAA6lMul0umUqeOH3/iwIGhkeGqj69OBRyJ x6s/yTCw9RDAwBK6u7vcbreMkX/lVz5/1113WSzVP/wJAADUrZmZmbffeOOn//zP H3z4gYzxe3t7k8mUjJGBLYYABpbg83lDoZCMkbkENAAAOsRUwECdIICBJTAJMAAA qCKmAgbqBAEMLCRvEuBSqfRX93x7+/btba2tjY2NVR8fAADUm1wuNzk1lc/n+/v7 D7/77rPPPyfjIiNMBQxUiAAGFpI3B9Lw8PA93/7Otdu3twcCTodDe1B7XxR3qGIA ADa1Jd/TE8nkyOjo9NSU+P/0yZMP/P2PgsFg1RfNTEhAhQhgYCGPxx0KhWQE8LxC oTA9PeNyOn0+n8vl8rcH7vjVX7vyE59YXMUGwhgAgDpzubdprXXTqdRkOn3s6JGh oeHRsbGJiQnxeFtbq4yDy+apATwYjcbkLQLYGghgYCG3293V1Snj8KTllUqleDxh t9u9Ho/Nbvf5/V/84hcD7e1L7i42EMYAAEi2fOhOT02JJ8QnJt566y0RurFYLBqN ptJpj8ddk62I/v4BsQ4bvFxg0yGAgYWcTmdPj5RJgNemUChMTU45nA63yy3y2OP1 fuGOO9qDQcIYAICqWDl0s1lRt+++8874xHg0GovHY4lkymazSt2puyoigMPhSCLB VMDACuplEx+oH52hkNfnrfVarKxYLKbTaYfd7nK5bXab2+35tS9+sSMUKg9jA20M AIBqmTfE+dDNZrMTY2OH3n47Gp1QOjcRT6VSDodD6olR1XL+fK9Y21qvBVDvCGBg IXmTAG+MUqkUi0ZtNrvd4fC4XVarzel2f+5zn6ONAQBbXoWVG49Gjxw+PBGNxmOx eCIhPpXJpL1eb/0c/7UGTAUMVGITf5MDkmz2AF5GsVgUb/I2q9XhsLtcrrY2q9Pl +s+f+1xnV9eCNjaQxwCAurT829PFyp2dnRgfP3rkSDQWS8TjiaT4TCozOelyOTfF 7tw1IICBShDAwEKBQCAYbK/1Wmy0Uqk0NjZutbbZbXabzeZ2u1pFHjudn/r0p1fM YwOFDACokhXfX8oTNxaNnjp5MqqclRtLJJKZTCaVTmUyk4GAf1Pvy12bcDgSj8dr vRZAvdPdSwOwPHmTAG9qIo/Hx8bb2lptah47HPbmFnHf9pnPfra9vb2ltZVCBgBU ovK+FfdnpqdHh4dPnDihHKScSqZSaUUmPTU17ff7dJi4y2MqYKASvHAAl9iASYC3 JOXg6nhClLC1rc1ms9rtdktzS1tb222f+UxnZ+eShWxYtBlkoJMBYNOq8CW9vG/F 7dDAwImTJ0XVplJJpW0zk5lMZmp62u128V68WkwFDFSCAAYuId5xu7q6+EflqiuV SiPDI80tLWJ7qE1lt9uamizig1tvu62np0c853KdbCCVAaBGKn/5LS9bYWpysj8c Pn36dCaTVnfcZqampsRQk5OTMzMzwWA7b7VVp04F3B+LcRQ0sBxeeoBL1NskwHpT LBaj0ahFhLFKdLLNarXabBaLRcTzLbt2dXV1GZZNZQO1DADLWtWL5IKsFXeGh4Y+ /uijTCaTTKVE3E5mJsVomtnsrNfrZc9trTAVMFAJtvKBS3R3dbo9nlqvBVZWKBSS iaTF0tQsyljV2tLSZhXJbBWbcZbm5htuvHHFHcvzaGYAm9QaXr4W76oVTRvu6xMl m0mnJ1XTMzPTwoz4aWpmNutyOU0mk8TfBqqkt7c3mWQqYGA5BDBwCb/f19HRUeu1 QJUVi8WJ8Ykmi+ji5ma1mcXPra0tyk5m5b828akrr7rq6quv1p5fSTNrKGcAVbHm F5MFNSs0mc0ff/zx+++/P60ebyyGFS07pcbszKzyn7iXzWZ9PnbVbkHMhASsiAAG LuH1eDq7Omu9Fqi9Uqk0OjpmNpmUbLYITcqNerdFiefW5haln8Xmac8VV2zfvl37 VZWX87zFW70GKhrYVKryXby4YxtNpnNnz547d25a5OvUlLpLVqTszGw2O6sQd3Lq ndl8Pt/eHuDkHQgff3w+nSaAgeXwWglcwufzhkKhWq8FNrGSanx8wmw2NTY2CZam pkb1VrsvIlrbBd2iHr1tMpuDodCOHTvmR1hDRWuW3ArXUNTAvKp/pyxuV8FsNIp8 DUfC09PKscTix4wSrTPiNivkRMXO3wrZfC7vU+f1oWOxHuwBBlbEiyxwiUDAHwwG a70W0Lv5ijYajWJzvKnRbBYNrd5amhobzVpZKzfKYd2WuZ3TDQ3GQDB4yy23LBht zUW9wDLZYKCxUSUb8GW2ZK9qjAbD6VOnBgcHZ7PKHlZ1N6tyV01WJVOVH+Imr9zN 55Ub8UixUKBdUSfC4XA8zkWwgOXwSg1c5PV6Ojo6OCcKW49W1KOjY+LL22w2iZJu NJtM4me1rMVd8bH2sEopbHGrJrYS2cp1xSwWMYLL49m1a9fi8avV2MAydSo0lEqn T5+ORieySpbOZpUcVQ4I1opUrVH1h0L5uVAoaB8WCnnl54Jyt1gsBgJ+ehVbkvjy HhoampiI1npFgPrFSz9wkcfjCYUIYGAtSheMj08Ui4Varw42JaPR5PN5Gy6o9eoA m48I4MHBoWiUAAYui3cX4CK3293V1clWFwAA2IxKpVJ//0AsFqv1igD1iw194CKX y9Xd3UUAAwCAzUgEcCTSH4/Ha70iQP1iQx+4yOFwbNvWQwADAIDNSARwX184mUzW ekWA+sWGPnARcyABAIBNjZmQgOURwMBFzIEEAAA2NWZCApZHAANzmAMJAABsdsyE BCyPAAbmMAcSAADY7JgJCVgeAQxcJBrYYCgViyWRwR0dQZPJVOs1AgAAWEGhUBga GhbpazSKbfsG6hdYBgEMLEdNYsN8FbOLGAAA1JC2g3e+dcUj5C6wKgQwsGpUMQAA kI3WBWQggIHqmK9ioaFBOYJaVDFTCgMAgOWJLQf1ylXD4md1y4HWBSRi6xyQSzuv uFRS/h23tbXV5/NSxQAA6JPYIBgfn5iamlL/ldzA+brAxmNDHKgBbXexsrO4VHQ6 nTabjYOoAQDYSorFYiqZTKZSDQ1zR4TRukA9IICBeuH1ekolg9bFxWLJZrO63W52 FwMAUM/Eu7Yo20xmUj3zSTmAWdwwDS9Qt9i2Bupd+dnFIoyt1jbxCGEMAMBGWhy6 BnbqApsQ29DAZlUWxgblUGqH02bnUGoAANalWCwqBy6nkuqhywZCF9hiCGBgC1qw 09hutzudDtoYAACNqNx4PJFOp9mdC+gNAQzoS3kbC0ajiRmbAABbz/zcQsVioaGB ygUwh01eAHPm29gwt92gFHJzc3N7e4A8BgDUG/EmNTI8MjM7K96kLuzINVC5AJbH Ri2AilzIY8OFs46VRrbZbC6Xi4OrAQAyqAcqx9PptDaT0PwZuQYSF8BaEcAAqmOp Qi45HY7pmRn2IQMAFlD2346MNlss6ky5DfQtgI3BJimAjVMWyWolXzgV2Wazu1xO 9iQDwNZw4RJTqfmTb8v/GZS4BVBDBDCAuqNOdGwozZ2MbCjfpaxNg0wqA8DGE1mr TYRbvsN2/la8UFO2AOofAQxgEytPZeWHcnNht7KyY9mqnaLMAdgAsJh2nWT1JNtM wyVRq32erAWwBbFRCEBHyo/BLt+9PL+T2WZtc7ndNDOATWdRzRrKd8+Wb/IRtAD0 jC08AFjBUtk8f2+unK1Wa6FQ8Pt9HJ4NYD1ExI6NjZtMpkymvGPn98kaSFkAWA8C GAAk8njc84cRqsdpN8zvczYYLjnP2W6357K5YqnY3t7O/mdgM1KnpR02Gk1NTY3J VOrSHbCGsj2xpfKXhWg0VsN1BgC9YRsLADYBt9u9qIovnvZctl/64hHdNqu1WCx6 vB6O6AaWpB0zHJ2Iiu+RtLK71VB+tPCldwwLNpnEr43FCFcA2HzYJAIAnbr00O4F Lh7pXfbhJZltt9vy+YK45/N5RTRw7DeqS6Sp+OoaH58QX11msymVSi9I0wUHAy/4 cAEOFQYAaAhgAAAAAIAuEMAAAAAAAF0ggAEAAAAAukAAAwAAAAB0gQAGAAAAAOgC AQwAAAAA0AUCGAAAAACgCwQwAAAAAEAXCGAAAAAAgC4QwAAAAAAAXSCAAQAAAAC6 QAADAAAAAHSBAAYAAAAA6AIBDAAAAADQBQIYAAAAAKALBDAAAAAAQBcIYAAAAACA LhDAAAAAAABdIIABAAAAALpAAAMAAAAAdIEABgAAAADoAgEMAAAAANAFAhgAAAAA oAsEMAAAAABAFwhgAAAAAIAuEMAAAAAAAF0ggAEAAAAAukAAAwAAAAB0gQAGAAAA AOgCAQwAAAAA0AUCGAAAAACgCwQwAAAAAEAXCGAAAAAAgC4QwAAAAAAAXSCAAQAA AAC6QAADAAAAAHSBAAYAAAAA6AIBDAAAAADQBQIYAAAAAKALBDAAAAAAQBcIYAAA AACALhDAAAAAAABdIIABAAAAALpAAAMAAAAAdIEABgAAAADoAgEMAAAAANAFAhgA AAAAoAsEMAAAAABAFwhgAAAAAIAuEMAAAAAAAF0ggAEAAAAAukAAAwAAAAB0gQAG AAAAAOgCAQwAAAAA0AUCGAAAAACgCwQwAAAAAEAXCGAAAAAAgC4QwAAAAAAAXSCA AQAAAAC6QAADAAAAAHSBAAYAAAAA6AIBDAAAAADQBQIYAAAAAKALBDAAAAAAQBcI YAAAAACALhDAAAAAAABdIIABAAAAALpAAAMAAAAAdIEABgAAAADoAgEMAAAAANAF AhgAAAAAoAsEMAAAAABAFwhgAAAAAIAuEMAAAAAAAF0ggAEAAAAAukAAAwAAAAB0 gQAGAAAAAOgCAQwAAAAA0AUCGAAAAACgCwQwAAAAAEAXCGAAAAAAgC4QwAAAAAAA XSCAAQAAAAC6QAADAAAAAHSBAAYAAAAA6AIBDAAAAADQBQIYAAAAAKALBDAAAAAA QBcIYAAAAACALhDAAAAAAABdIIABAAAAALpAAAMAAAAAdIEABgAAAADoAgEMAAAA ANAFAhgAAAAAoAsEMAAAAABAFwhgAAAAAIAuEMAAAAAAAF0ggAEAAAAAukAAAwAA AAB0gQAGAAAAAOgCAQwAAAAA0AUCGAAAAACgCwQwAAAAAEAXCGAAAAAAgC4QwAAA AAAAXSCAAQAAAAC6QAADAAAAAHSBAAYAAAAA6AIBDAAAAADQBQIYAAAAAKALBDAA AAAAQBcIYAAAAACALhDAAAAAAABdIIABAAAAALpAAAMAAAAAdIEABgAAAADoAgEM AAAAANAFAhgAAAAAoAsEMAAAAABAFwhgAAAAAIAuEMAAAAAAAF0ggAEAAAAAukAA AwAAAAB0gQAGAAAAAOgCAQwAAAAA0AUCGAAAAACgCwQwAAAAAEAX/j+juZA0qycO cQAAAABJRU5ErkJggg=="/></symbol><use xlink:href="#c" width="1280" height="1280"/></g></g></svg>')} +.is2d .queen.white {background-image:url('data:image/svg+xml;base64,<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="614.635" height="614.635" viewBox="0 0 460.977 460.977"><mask id="b"><use xlink:href="#a" width="1280" height="1280" transform="rotate(.193) scale(.36014)"/></mask><symbol id="a" viewBox="0 0 1280 1280"><image width="1280" height="1280" xlink:href="data:image/png;base64, iVBORw0KGgoAAAANSUhEUgAABQAAAAUACAAAAAA9j6ArAAAACXBIWXMAAA7EAAAO xAGVKw4bAABGnElEQVR4nO3dd2BUZcK28VmEJIRQAlKkqYAgRcWCYi+gvouiqKu4 rhVXxb67oq5trWvFde2ou6jgqlhRVv1WQRSxi4pSpEoXCJ2QRvskIWSSzCRTznnu 55zn+v31vkpmrp3h3CaZmXN+EwEAR/1GHQAAKgwgAGcxgACcxQACcBYDCMBZDCAA ZzGAAJzFAAJwFgMIwFkMIABnMYAAnMUAAnAWAwjAWQwgAGcxgACcxQACcBYDCMBZ DCAAZzGAAJzFAAJwFgMIwFkMIABnMYAAnMUAAnAWAwjAWQwgAGcxgACcxQACcBYD CMBZDCAAZzGAAJzFAAJwFgMIwFkMIABnMYAAnMUAAnAWAwjAWQwgAGcxgACcxQAC cBYDCMBZDCAAZzGAAJzFAAJwFgMIwFkMIABnMYAAnMUAAnAWAwjAWQwgAGcxgACc xQACcBYDCMBZDCAAZzGAAJzFAAJwFgMIwFkMIABnMYAAnMUAAnAWAwjAWQwgAGcx gACcxQACcBYDCMBZDCAAZzGAAJzFAAJwFgMIwFkMIABnMYAAnMUAAnAWAwjAWQwg AGcxgACcxQACcBYDCMBZDCAAZzGAAJzFAAJwFgMIwFkMIABnMYAwqH7zHk12zWpT 9W/d1sVF89dMySuUNMFlDCDM2K1byzat2+68e1aTmP96TdHPKxYtWbxs2jyzWXAb Awjf5XbfrfmuB+zRKKvWP1m0btY38/PmTV1toApgAOGzRh067XHgfi0zk/iS4mXf fjVr9tx1vjUB5RhA+GeXXbsdfWDnlL505lfjp83/xeMeoAoGED5p2XHvM/ZpmsYN rJr8yg9zlnnWA1THAMIPzXY5+KyjPLidj178/JeVHtwOEBMDCM/V36X74MMaeXRj 6yYOm/oLb5CBPxhAeCynzXkXN/P0Flc+/fzifE9vESjDAMJLder1fOBwH273k2u/ 37jFh9uF4xhAeKdO3YG37+7Tbf9866hNTCA8xgDCM7nXXJbr482vfuJB3iANbzGA 8Ej2g+fX/lGP9BQ9d02Bz3cBtzCA8MaTFyTzaY9UFT97qYF7gTMYQHjhzitin+PA e2seu8XQPcEBDCDSN/Bxb9/3UrOVl48yeG8INQYQ6dr/P10M3+OMP0wyfI8IKQYQ aRr9fyZ++VdZ8f8bYPw+EUYMINIy4JmdJfe74qLRkvtFuDCASEPzV3r7/daXeIq+ OCNPdNcIDwYQqTvrYc23f2VWXP2i8N4RCgwgUtXozYPrSwMKPz+F00YjLQwgUnTy gx3VCZE517ylTkCgMYBIzT8HNVQn/Gr98D+pExBkDCBS0fmZI9QJ2024aKY6AcHF ACIF/YemdqkjP8wcMkadgMBiAJG0jKuubaFuiLL8gUdK1A0IKAYQycq99xztq79V FY78KycKREoYQCRpt3+erE6o5q0/zVMnIJAYQCTnsH/ur06IYdKfJqoTEEQMIJKy /2u7qRNimvc7ThCD5DGASMbRI9qqE+JYdO54dQKChwFEEn7/TAN1QlwbLnpJnYDA YQCRuNOfy1Yn1KDg/FfVCQgaBhAJO/U/qnNfJaboD2+oExAwDCAS1f9V86d+Tk7x 6XwoBElhAJGgE/6rLkjAie+oCxAoDCASc9z/1AUJOf59dQGChAFEQrpPURckqMdU dQEChAFEInLnmrrwebrWdOBzwUgYA4gENJvTWJ2QsLUdV6oTEBgMIBIwp4O6IAlz 9afqR1AwgKhVnW/3USckZfJ+W9QJCAgGELWp8/e/qhOSdO9NLCASwgCiNoF4A2Bl vB0QiWEAUYsOc9QFKeg4V12AQGAAUbPmU2y6/keilvfIUycgCBhA1Cj31T7qhJSM O523A6J2DCBqUvfmW9UJKbr9rk3qBNiPAURNBrxk9xmw4iv6/Wh1AuzHAKIGXd7b XZ2Qsp9/O0OdAOsxgIgv+8lz1QlpGHFpgToBtmMAEd+f/6EuSMtfHlIXwHYMIOLq /WYrdUJalp7yhToBlmMAEU+jF/qrE9I05ux16gTYjQFEPEMeUBek7dqh6gLYjQFE HD1HdVYnpG3mwO/VCbAaA4g4XjldXeCBV89QF8BqDCBi+/3jueoED6y+/CV1AmzG ACKmnA97qRM88fUx+eoEWIwBREz3Xq8u8Mh9QTubK0xiABFLqy/bqxM8suCgpeoE 2IsBRCwjzlEXeGZkkD/OB58xgIjhkDFN1QmeWdX/M3UCrMUAIoaxwTwLamzj+qoL YC0GENUd9F4Y3gJTbvVvv1QnwFYMIKobf5S6wFMfHa0ugK0YQFSz/7jG6gRPre0z SZ0ASzGAqObjI9QFHptwpLoAlmIAUVXPT3LUCR7LP5xzIiAmBhBVvfh7dYHnXjpL XQA7MYCoos6qcP0GcJu1TbeoE2AlBhBVPHKlusAHj16lLoCVGEBUsayFusAHy1uq C2AlBhCVnRzO64kPeEtdABsxgKjs233VBb74bj91AWzEAKKSxssy1Qm+KG65Vp0A CzGAqOSpi9UFPnn6EnUBLMQAopIVzdQFPlm5s7oAFmIAEa3rNHWBb7pNVxfAPgwg or1+qrrAN2+cpi6AfRhARFsfto8BV8hvqC6AfRhARDnkU3WBjw7l1PioigFElLdO Uhf46O2T1QWwDgOIKKvCdCr8qlaH50JP8AoDiAptF6oLfNVukboAtmEAUeGxy9UF vnr8CnUBbMMAosKsTuoCX83eQ10A2zCA2KFeibrAZxkb1QWwDAOIcr859BN1gs8O /3SrOgF2YQBRbqfh56oTfDZi0GZ1AuzCAKJcvVm7qhN8Nn8PfgZGJQwgymVvUBf4 rkGBugB2YQBRrvfn6gLfHfyFugB2YQCxXeZjf1Qn+O5fVxSrE2AVBhDb5UzcR53g u8mH5asTYBUGENs1+bmJOsF3a3Zfo06AVRhAbNd8ubrAgBZ56gJYhQFEmTr9w3lB 4MoGjNmiToBNGECUybz1BnWCAffczqsgiMIAokyj0UerEwwYP2CdOgE2YQBRpuU0 F84XuqrbMnUCbMIAokyb2VnqBAOKOi1WJ8AmDCDKtJ+vLjBi1wXqAtiEAUSZIz5W Fxhx5AR1AWzCAKLUTn8cpk4wYvC/OCMWKjCAKFX/ppvUCUb8/e+F6gRYhAFEqdwR J6oTjPjvuavVCbAIA4hSLf7bS51gxNcnuvCJPySKAUSpdp+3UScYsfjgcF/7GMlh AFFqjx9ceBtgJFK09yx1AizCAKJUp+8bqBOM2NBztjoBFmEAUarzDHWBIV1mqgtg EQYQpfb5Xl1gSM/J6gJYhAFEqZ7fqQsM2deVpUciGECUYgDhIgYQpRhAuIgBRCkG EC5iAFGKAYSLGECUYgDhIgYQpRhAuIgBRCkGEC5iAFGKAYSLGECU6jZVXWBI92nq AliEAUSpTj/UVycYUbg3J0NABQYQpTpNzlYnGFGwDwOICgwgSnX4trE6wYi1+81V J8AiDCBKtfywmzrBiGnHLFMnwCIMIEq1eHd/dYIRk/pxTRBUYABRKueBweoEI4Zd m69OgEUYQJTK/Mvd6gQjbvxHsToBFmEAUebk0eoCIwa8pS6ATRhAlOk+RV1gRA9X 3vCNhDCAKNNmkbrAiLaL1QWwCQOIMi1/aqJOMGDNnrwLBlEYQJRp9kUndYIBs3uv VCfAJgwgymQPO0edYMDIwQXqBNiEAUSZnc4drk4wYNCIzeoE2IQBxHY9flQXGLCX G691I1EMILZrslpdYEDuGnUBrMIAYrtGM1qpE3y3tMs6dQKswgBiu/qvnqBO8N07 pxeqE2AVBhDb7XTlQ+oE3/35UV4DQTQGEOWah/9EUS3y1AWwCwOIcpnLG6kTfLau BaeCQSUMIMrV++gQdYLPPjtqozoBdmEAUa7OXx5QJ/js2n9sUSfALgwgdshdpS7w WVMX3uqIZDCAqLA+R13gq/yG6gLYhgFEhQ/6qgt8NfZYdQFswwCiQv+31QW+OmmM ugC2YQARpThDXeCjkkx1AazDACLKjM7qAh/N7KIugHUYQES5/W/qAh/dcau6ANZh ABFtqzrAR/xdRzX8pUC0OR3UBb6Z21FdAPswgIg26N/qAt9c6MIp/5EkBhCVFIX1 pdLiLHUBLMQAopKJh6oLfPLpYeoCWIgBRCVHfqQu8MlRH6sLYCEGEJUtbaku8MWy 8F/wBClgAFHZE5eqC3zx5GXqAtiIAURlzRZkqxN8UNB+pToBNmIAUcXHR6gLfDDh SHUBrMQAoopDxoXvDSNFfT5TJ8BKDCCqmr6nusBzP3VVF8BODCCquvIRdYHnrnpU XQA7MYCoZkE7dYHHFrZXF8BSDCCqufU2dYHHbrtdXQBLMYCo7ufd1AWemre7ugC2 YgBRXcjOi8qZUBEPA4gYZnVSF3ho9h7qAliLAUQMd14bnrNiFT9wizoB1mIAEcuk /dQFnvl2f3UB7MUAIpaLHmyoTvDI+mueUSfAXgwgYppwuLrAI5+E8aPN8AoDiJiO fLG1OsETS87iRKiIjwFEbCE5LyDnAURNGEDE1vyDfdQJHph8bJ46ATZjABHHVXc3 UCekbcON4TuxA7zEACKe0SerC9L21gB1AezGACKeg14I+udBZp/9pToBdmMAEdeN f1cXpOmmu9UFsBwDiLiyRv5OnZCW184pUifAcgwg4uvxcnd1QhqmnjlFnQDbMYCo wdnPBPcCSUUXvaBOgPUYQNQge2hw3w795JACdQKsxwCiJru9eLA6IUWfnzVPnQD7 MYCo0SGvt1InpGTpaVwJGLVjAFGzPwbzbFIX/UtdgCBgAFGzug9doU5IwWN/3qRO QBAwgKjNh0erC5I2/hh1AYKBAURtsqcE7bKSP/fgBWAkhAFErfb8Kljnx19/4E/q BAQEA4ja5J446Ch1Q1Kmvfe/CcXqCAQCA4ga9Drx4C4tg3iFzK0FC3/8+L256gzY jgFETBn9Tjxg18YB/+uxacXMT1+fpK6AxQL+Nzz4WvzhyA7NG9Tdurlw9cLv3v5s i7rnV3X6DujdsZG6wjNb8qZ+9MZUdcWv6hxy0r7tcuvv9JtNG/Lmfvyf5eoeRBhA rUNuOrzKywtzPnhkuqalTI/zjtijSQj/Umxa9sM7ryonp+tVx3as/E/Wf/J3Pqwi F8K/64Ex5Lrmsf7xqnevX2I6ZZu6A07t3bae4p5N2fDThy99p7jj1vf1axrrn+fd P9R0CipjAFUGPRT/p8xpt7xhsORXzS747d7NnPi7sGn+56+9Y/ZTIqfe2S3uv1v3 5+EGS1CNE3/pLdRqXPyDYpu8Ox81VBLJueC0no1N3ZkVtiz6+Nnxpu7syltifp+/ w7Q+Sw2VIAYGUOL0V2r9I6uvN3AWgqyzzjigmf93Y6FN88Y+Z+CKSRfdl1vrnznj Vf87EAcDqDD0mkT+1NLz3ve14pArj2rp9PNf8tOrw339detxzyd0LrEHh/gZgZo4 fQCovHRmgn9w8oB5PiU0unjgXkF8g7PXtq4c/9Q4n257t9H7JPgnX/69TwmoDQNo 3ssDE/+zIy704Rf2B13R1+1v/ar47sUR3r9Dpu6/z038D49K9D+J8BjHgXFDHkjm T+f/cZS3d9//6oOzvb3FENi6eNQT3n5ubuC/cpL549fyfhgNBtC03p8n+QXf9Mvz 6r7rnDN4vwyvbixktq5462HPLqPZ/N0DkvyKg7/w6r6RDAbQsMZLkv/+6/r7vbjn jMvO77GTFzcUXmv+95Anrwxfd1/SX1LQeq0X94wkMYCGTa35/X+xzeyzKM27rXPh 5XvVSfM2nLD2rQfS/T6w7bjOKXzVtCBfgz64GECzLkjxjf833pPOvZ5wU6+66Xy9 W1aM/Ec6/7254e7Uvm7Qs2ncKVLEABpVd02DFL/yp6NT/cBAl7uPT/VOXbVl7kPP pXhS/Vbj90zxTjc04TpO5jGARj2fxFsjqkrphcKsG/7YOvW7dFjJhNsnpvBlyb3E X9mI81L/WqSIATSp8Zp0vnry0auT/Ioj7uvFyx4pWznsoZXJfUXu+ETf+hxTE14H MY4BNOmFP6T15cUXjUziT2f97aKd07o7bPr05mS+DTznmfQ+XPOfs9P6cqSAATQo I+0r9YzvV5Tgn+z0eB+++fPAL3f9qySxP5n1btrXT85M8K7gGQbQoAfS/9B7/qkf JPLHBtzbJe27QpkNI+5I5PWnY99I6qMfMQ29Nu2bQHIYQINWxjwtcJJGnVXbdUPq DLmWn329tOmD62p7b2CdF5P4gHdcq9w8NZkSA2jO/t94cjMr+vxQ07/OGjqovif3 gwpbJv9pQk3/fu9x3vwn5wAuYWcYA2jOu7/16IZqOH9co8cHhvqyHjJbZ/3lnbj/ MrHzOybgvX4e3RASxACaU+TZCfjmHr0g5j/PHd6fVz58M3/IazH/efvxHby6i+Is r24JiWEAjekz1sMbi3V+hEb/OpX589XcP42p/g9TOPNBfH39OjsrYmMAjXm7v5e3 NrlPlTfpZj11Fp/39d2MS6tcTanZuLTe+1zVmJO8vDXUigE0Zo3Hl16r9OH5Ovdd xYn+TNj69SXfR/2/qZ7cIp61Tby9PdSCATSl7UKvb/Gz364r/z+vvIfzHZiy5b0r 5m3/Pxu9d4jXt94u3ROfISkMoCl33uz5TRZdXPbRuKNf4IQHJhU/eWvpf3rOedr7 1yzuusXzm0QNGEBTJu3nw41O/G1+pMWYA324ZdRk1ZBnIznvHebDLX+7vw83irgY QFMKfHl7ctFF+/yZl34Fvn79Nl/eslLIFauMYgAN8f5XgAglfgloFANoSKonSodj 0rv4AZLEABry7b7qAgTCd378rhjxMICGbFUHICA4JE3i0TaEAURiOCRN4tE249j3 1QUIiOMSOuUtvMEAmvHRkeoCBMTHR6kLXMIAmrGuoboAAbG+kbrAJQygGfwKEIni mDSIB9uILj+pCxAYe85QFziEATRi+AXqAgTGs4PUBQ5hAI2Y0VldgMCYySVNzWEA jeBXgEgcB6U5PNYm9It/QTGgqhPeVRe4gwE04ZXT1QUIkFfPUBe4gwE04ZdW6gIE yNJd1AXuYAANyN6gLkCgNChQFziDATTgssfVBQiUy59QFziDATRg4qHqAgTKp35c bQSxMIAGbOA6D0hGARc5NYUB9F/XaeoCBEy36eoCVzCA/ntysLoAATPsUnWBKxhA //28m7oAATNvd3WBKxhA39XdqC5A4NTbpC5wBAPouwuGqwsQOIOeVRc4ggH0HWfD R9I4L74hDKDv8nlPA5K1IUdd4AgG0G89flQXIID2mqIucAMD6DdOBo0UcFpoMxhA vy1urS5AAC1poy5wAwPos5z16gIE0dZG+eoEJzCAPrvuPnUBAun6+9UFTmAAfTZ5 b3UBAumHfdQFTmAA/VVns7oAwbQ5Y4s6wQUMoL/OGaEuQECdO1Jd4AIG0F+cCxUp 4qyoJjCA/irKVBcgoIqz1AUuYAB91WesugCB1XecusABDKCv3umnLkBgvXuCusAB DKCvuBoIUsaVQQxgAP109IfqAgTYMePVBeHHAPrpg77qAgTY2GPVBeHHAPqpoL66 AAFWyC9QfMcA+qjfO+oCBNoJ76oLQo8B9NH4o9QFCLSPjlYXhB4D6B8+B4z0bMzi 88A+YwD9M/hJdQEC7tJh6oKwYwD9M7WbugABN627uiDsGEDfNF6jLkDgNVmrLgg5 BtA3//izugCB99Bf1AUhxwD6ZlkLdQECb3lLdUHIMYB+OegLdQFCoPeX6oJwYwD9 8gnns0T6Jh6uLgg3BtAn2RvUBQiFBgXqglBjAH0y9Bp1AULhwSHqglBjAH2yKldd gFBY3VRdEGoMoD84DwI8whkR/MQA+uOnLuoChMSMPdUFYcYA+qLHj+oChMZeU9QF IcYA+uKzg9UFCI3PD1EXhBgD6IcWy9QFCJGWy9UF4cUA+uHNAeoChMjoU9QF4cUA +iB3lboAodJ0tbogtBhAH7zdX12AUBlzkrogtBhA7/EbQHiM3wL6hQH03tg+6gKE zDguMO0TBtBz7eerCxA6uy5QF4QUA+i5b/dVFyB0vttPXRBSwRrADv+3d6fcnAb1 623cuLF49aI50775QZ1UzQn/VRcghE6078Plex/QrWPb3Mx69eptLNyQv3r2D/9v rjopeYEZwDqnnXlg2xj/fP3i6eNfzjOeE1edPM7eAe+tam7RJYKbn3l01zYNY/yL RV+9/LpFnQkIxgBmX/v7Gk8uUDT/ixfH2vHAP3GpugCh9ORl6oJSdfqe1XvXrJr+ xIyXHgjQOVyDMID97+iZyB9b8vUrr5X43VKbzjPUBQipLjPVBRm/O6NX60T+4Pd/ G+N3i1esH8A6f7u6SeJ/+pcvX3xzk38xtZvfXnnvCLEFuyrvve4pZx20S+J/fM3D d9jxE1ltLB/AuvcPrp/s1yz65NkP/GhJxEN/Ut0zQu+fsgtNH3vB4bF+/16jwmHX Sb8VSZDVA1jn4YszUvvKWe8PU5xEjUthwkeSS2T2GHzcHql9ZcnTV9v/XaDNAzj4 yXS+umja6GGGXx3O/qWR2TuEU9btYvjVheaDB3Sr8QWP2lw6zKsUv9g7gIe8lsSv HOJY8/V//mPw+/Dv9zF3X3DQ5IReDfRG3T/8oVcSv32P45fffeZBi49sHcDsN473 6JYWfPDY9x7dVC1GnGPmfuCskeeauZ+eVxzr1at5/zvV6jfFWDqAf3w0re+8qyj6 4fWn1np4e7HdcofvdwHX/e1O3++i8SWn7e3p0Xflvzy8Na9ZOYAtxu7l+W3mffLU +57faLQrH/H15oFtrnrU15s/7pLDm3t+oz/2tfdsXjYO4OWP+XTD00c/stSnm45c 9rhftwxEufwJv2651VUDuvp001dYe3TYN4CNxx7g581Pe/RpP16bv/5eH24UqO6v 9/lwo3UuvrKbDze7wzd9/f8dVEqsG8DTR2b6fh8/vzhskbe3OPJsb28PiOsFj19s azv4rN29vcUYis951ff7SIVlA1jn1VMN3dP8yeNe8ern4dwvOnt0S0DtZvb26iJJ rc7os4+pT9i9cbqNb4u2awC7fuz9b2BrULx48tjX0v/97B8fT/HzKkBKSi5P/4XV Fr/ru08b/3/aipJ35HSTd5cYqwbwmqGCO/11Bce9uST1r+/yhq+/PAFimHZqGqcd an1KH8Pbt92QBwV3WjOLBjBj7OG6O180/dO3v0vh63o809vzFqB2X1yUyqfd9z3p 0K5Jn9fAO5/0lZ+wrgp7BnDf8Y3VCWsWTP5kTBK/GMy45uLdfIsBajbv6QeTmJNW /Q/fp336n21L09qjU/k2w0fWDOANd6sLyq1eMvPbj74uru2Pdb74pBTPkgF4ZNbb T9d6mtTMXkft17l1romcRNx4j7qgEksGMOODI9QJVa3OWzjr59nTZ26u9m+yDzpi vx6S36EAVRUvnvLthC+rf952p85dO+2+R7vm1ixfuQnH2vRjsB0D2OZH656mCkUl xcUFhVu3/Z+/ycpqkJ2tDgKqKSjYUFRU9pe0fnZmZoaXn+b12Oq9FqsTKtgxgNkr LX6+AHioqJlF54exYgB3+n991QkADBn7f9V/r6RixQBmL2+gTgBgyIYW9nwLaMUA Ro78SF0AwJCjPlYXVLBjACP/vFpdAMCIh226dKIlAxiZvqe6AIABP/l10sGU2DKA uUt4HRgIv6LWXp3KxhO2DGDk5NHqAgC+G/CWuqASawYw8tx56gIAPnv+fHVBZfYM YGSeqTMzAtCYv5u6oAqLBrC1RR+QAeCDNmmcedMXFg1g5OyR6gIAPjrnBXVBVTYN YOTNAeoCAL4ZfYq6oBqrBrDOkpbqBAA+WdbavssiWTWAkU6z1AUAfLLHbHVBdXYN YOTyx9QFAHxxxePqghgsG8DI2D7qAgA+GGflOe9sG8Cc9eoCAD5omK8uiMW2AYxc d5+6AIDnrr9fXRCTdQMYmdVJXQDAY7MtvYSifQMY2bSTugCApzbXVRfEYeEAtl2o LgDgqXaL1AVxWDiAkfuvVRcA8NAD16kL4rFxACO/tFIXAPDM0l3UBXFZOYCRLXZm AUje1jrqgvjsXJruU9QFADzSY6q6ID47BzDy/LnqAgCeGGHzud4tHcDI6ibqAgAe WJOrLqiJrQPIrwGBMLD5F4ARiwfwCIuuHg8gRUdOUBfUyNoBjPzvOHUBgDS9f7y6 oGb2DmCkoL66AEBaCrPVBbWweAAzitUFANKSWaIuqIXFAxg57zl1AYA0nP+8uqA2 Ng9gZNJ+6gIAKft2f3VBrawewEhJPXUBgBRtzFAX1M7uAcxdpS4AkKKmq9UFtbN7 ACM33K0uAJCSG+9RFyTA8gGM/LybugBACubtri5IhO0DGNls9ydpAMSyJRhXtrB+ ADvMURcASFrHueqChFg/gJEnLlUXAEjSk5epCxJj/wBG8nZWFwBIyorm6oIEBWAA OTMWECyWnwMrShC2pddX6gIASTjwa3VBooIwgJHRJ6sLACTsrQHqgoQFYgAj+Q3U BQAStCFHXZC4YAxgZKs6AECCAjIqpQLSeurr6gIACTntDXVBEgIygJHPDlYXAEjA 54eoC5IRlAGMFAfg1DqA80oy1QVJCcwA5qxXFwCoVcN8dUFSAjOAkWuGqgsA1GLI g+qC5ARnACOzO6oLANRoTid1QZICNICcGQuwW0DOgRUlSAPImbEAqwXkHFhRgjSA kacuVhcAiOvpS9QFSQvUAEZW5aoLAMSxuqm6IHnBGkDOjAXYKjjnwIoSsEE54mN1 AYCYjpygLkhBwAYwMu4YdQGAGD7soy5IRdAGMFKYpS4AUE1RfXVBSgI3gBnF6gIA 1WSWqAtSErgBjFwyTF0AoIrBT6kLUhO8AYz81EVdAKCSGXuqC1IUwAGMbArc522A UNtcV12QqiAOYNuF6gIAUdotUhekKogDGPnn1eoCADs8/Cd1QcoCOYCR5UG57jwQ fnkt1AWpC+YA8pE4wBaB/AhcuYAOSa+v1AUASh34tbogDQEdwMiYE9UFAH713/7q gnQEdQAjBcH85A0QLoXZ6oK0BHYA+UgcYIGAfgSuXGAHMHLec+oCwHnnP68uSE9w BzDyw17qAsBxP+6tLkhTgAeQj8QBWsH9CFy5IA8gH4kDpIL7EbhyQR7AyKNXqAsA hz12pbogbYEewMjKAF6GCgiJVc3UBekL9gBGtqoDAGcFfDxKBfx/Q7931AWAo054 V13ggYAPYGTioeoCwEmfHqYu8ELQBzBSUk9dADhoY4a6wBOBH8Cc9eoCwEEN89UF ngj8AEZuu1VdADjn9tvUBd4I/gBGFrdWFwCOWdJGXeCREAwgp4cGzAr0SaArCcN2 cHpowKhAnwS6kjAMIKeHBkwK9kmgKwnFAHJ6aMCcgJ8EupJwDCCnhwaMCfhJoCsJ xwBGLntcXQA44vIn1AUeCskARmZ1UhcATpi9h7rAS2EZwMjm0LwwD1hsS7jOwx6a Aezyk7oAcMCeM9QFngrNAEaeP1ddAITeiPPUBd4KzwBG1jVUFwAht76RusBjIRpA Tg8N+CxMe1EqTP+DBr6sLgBC7cxR6gKvhWkAuVQ64KfAXwa9ulANIJdKB/wT/Mug VxeuAewwR10AhFbHueoC74VrACMjz1YXACH1wjnqAh+EbAAj+Q3UBUAobchRF/gh bAPIeWEAX4TpHDAVwjaAkUuGqQuAEBr8lLrAF6EbwMjsjuoCIHTmhPR0S+EbQM4L A3gtZOeAqRDCAew+RV0AhEyPqeoCn4RwACOjT1YXAKHy1gB1gV/COICRwix1ARAi ReG96FgoB5D3wgAeCuc7YEqFcgAj192nLgBC4/r71QX+CecARha2VRcAIbGonbrA RyEdwMiWsP4PA8zaGuq3lYV1J3p9pS4AQuHAr9UFfgrrAEbGHaMuAELgwz7qAl+F dgAjxRnqAiDwSjLVBf4K7wDmrFcXAIHXMF9d4K/wDmDk7hvUBUDA3XOjusBnIR7A yPLm6gIg0PJaqAv8FuYB5L0wQDrC/Q6YUqGeiH7vqAuAADvhXXWB70I9gJFJ+6kL gMD6dn91gf/CPYBcKBhIVRgvA1xNyAewy0/qAiCg9pyhLjAg5AMYef1UdQEQSG+c pi4wIewDGCkK+TvZAV8Uu3FW4dAPIB8IAVIQ9o+AbBf6AeQDIUDyQv8RkO3CP4CR lU3VBUDArGqmLjDEgQGMbFUHAAHjwi6UcuF/6Nkj1QVAoJzzgrrAFBcGMDJzD3UB ECCzOqsLjHFiACObw/+hbsArWxz6/JQbA9jzO3UBEBj7fq8uMMeNAYx8eLS6AAiI 8S5dTseRAYyU1FMXAIGw0amL6bgygC2WqQuAQGi5XF1gkisDGHnqYnUBEABPX6Iu MMqZAYysz1EXANbLb6guMMudAcwoVhcA1sssUReY5c4ARq56WF0AWO7qR9QFhjk0 gJGFbdUFgNUWtVMXmObSAHKZTKAmDlwGsyqnJqHPWHUBYLG+49QFxjk1gJFvHLjO H5CiSQeoC8xzawA5KwIQj0vnQNjBsQHsPkVdAFiqx1R1gYBjA8hZEYDYnDoHwg6u DWBkowuXuweStcnN04U4N4BtF6oLAAu1W6QukHBuACOvn6ouAKzzxmnqAg33BjBS 7NT5zoAElGSqC0QcHMDcVeoCwDJNV6sLRBwcwMjwC9QFgFWeHaQuUHFxACMF9dUF gEUKs9UFMk4OYM56dQFgkYb56gIZJwcwMvQadQFgjQeHqAt03BzAyDrHTvwNxLW+ kbpAyNEB5Pz4wHaunQW/EkcHMHLD3eoCwAo33qMuUHJ1ACMrm6oLAAusaqYukHJ2 ACNb1QGABdxdgFLu/s+/ZJi6AJAb/JS6QMvdAYwsbq0uAMSWtFEXiDk8gPwQDOe5 fPyXcvkBOPV1dQEgddob6gI1lwcwMrujugAQmtNJXSDn9ABypXS4zMHroFfj9gJw pXQ4zMHroFfj9gBGfuyhLgBEpuylLrCA4wPID8FwFT8Ab+P68X/Ex+oCQOLICeoC G7g+gPwQDDfxA3Ap5weQH4LhIn4ALsPRzw/BcBA/AJdhACM/dVEXAIbN2FNdYAkG kB+C4Rx+AC7Hsc/boeEc3gJdjgGM8EMwHMMPwDswgNvwQzAcwg/AFTjyt+GHYDiE H4ArMICl+CEYzuAH4CgMYBl+CIYj+AE4Gsd9mf5vqwsAI04aoy6wCQO43fz26gLA gAW7qguswgCW4xJJcAFHfCU8HOUG/VtdAPjuwuHqArswgDssa6EuAHy2vKW6wDIM YAV+CEbYcbxXwQNS4Zqh6gLAV0MeVBfYhgGMsrqJugDw0ZpcdYF1GMBo/BCMMONo r4aHJNpdN6kLAN/8/WZ1gX0YwEryG6gLAJ9syFEXWIgBrCSjWF0A+CSzRF1gIQaw suEXqAsAXzw7SF1gIwawipJ66gLABxsz1AVWYgCraLtQXQD4oN0idYGVGMCqxh2j LgA892EfdYGdGMBqNnPCSITNlp3UBZZiAKvp9ZW6APDYgV+rCyzFAFY3tZu6APDU tO7qAlsxgDFwgRCECpcBiYtDPYaBL6sLAA+dOUpdYC0GMJZfWqkLAM8s3UVdYC8G MCZOC4Pw4CCPj8cmplvuUBcAHvnbneoCizGAsW3IVhcAnijgDEc1YABjy1mvLgA8 0TBfXWAzBjCO109VFwAeeOM0dYHVGMB4NvHhIQTf1l6T1AlWYwDj6T5FXQCk7aa7 1QV2YwDj+rGHugBIU173PHWC3RjA+PhEHILuyAnqAstxjMd39kh1AZCWERdsUSdY jgGswYpm6gIgDUVd56kTbMcA1oRPxCHIThqjLrAeA1iTf16tLgBSNvH4AnWC9RjA GhVlqguAFG3Ze6o6wX4MYI24RhwC66pH1QUBwADW7Kte6gIgJUt6rFYnBAADWAve DIhgOvQzdUEQcHjXgjcDIpCev3CzOiEIGMDarG6iLgCSVrznPHVCIDCAtckoVhcA STv9NXVBMDCAtRp5troASNLkQ3gLYEIYwNpxZkAEzNaeP6gTAoIBrF3P79QFQFJu v01dEBQMYAJmdVIXAElY02W5OiEoGMBEcFIEBMkx49UFgcEAJuK6+9QFQMLeOWWj OiEwGMCEFGapC4AEbe42U50QHAxgQlosUxcACRr8lLogQBjAxEzaT10AJGRZV06C kDgGMEGcFAHBwEkQksFhnaCrHlYXAAl4cyCvgCSBAUxUQX11AVCrzZ3nqhMChQFM FK+DIAAufkZdECwMYMK+PFBdANTil65r1QnBwgAmjtdBYLuDv1AXBAzHdOIuGaYu AGo06g+cBjo5DGASNmSrC4AabOq4QJ0QNAxgEnJXqQuAGpz/vLogcBjAZHzeW10A xPXLnuvUCYHDACaF10Fgr95fqguChwM6KZwXC9biLFgpYACTU5SpLgBi2rIHnwFJ HgOYnA5z1AVATEMe2qJOCCAGMElzOqgLgBjWteczIClgAJPF9UFgI64DkhIGMFlP XKouAKr5+lBeAUkFA5g0rpMO62ztOkOdEEwMYNIO+VRdAFTxwF95BSQlDGDyVjRT FwCVFLdZqU4IKAYweRnF6gKgklNGqwuCigFMwf+OUxcAUeZ1LVInBBUDmAo+Egyb 7Pu9uiCwOJJTcc1QdQGww5jTeAtMqhjAlJTUUxcA221tv0idEFwMYEp6fqcuALa7 /Q7eApMyBjA1y5urC4BSxS35EHDqGMDU8FYYWIK3wKSDAUzRhMPVBcCvlnTkLTBp YABTxVlhYIMDJqkLAo0BTNVtt6oLgMj4Y7kScDoYwJRtrKsugPO27saVgNPCAKaM s8JAbuj1vAUmLQxg6lY3URfAcRub8xaY9DCAqctZry6A4/7wMt8ApocBTMNPXdQF cNraVrwFJk0MYDp4KwyUDp+oLgg8BjAdo09WF8Bhs/fkLTDpYgDTwokBodNjqrog +DiA03LLHeoCOGvccbwCkjYGMD1cIxMinAbQCwxgevqMVRfAUY9dzTeA6WMA07Qh W10AJ21uxnugPcAApqnFMnUBnHTp03wD6AEGMF2LW6sL4KDCJiXqhFBgANPGu6Fh 3vEf8PfOCwxg2j7vrS6Ac5bvwg/AnmAA08d/imEa54H2CAOYPj4QB8PmdOYbQG8w gB7gW0CY1W26uiAsGEAPPHqFugBO+eYgvgH0CAPoBc6JAJN2n6cuCA2OXC9cd5+6 AA55/7d8A+gVBtATnBMB5rRcri4IDwbQEwNfVhfAGS+cxzeAnmEAvVFST10AR2zN 5SwI3mEAvdHrK3UBHHHfjXwD6B0G0COcFgtGbGnAleA8xAB6pMMcdQGccP1QvgH0 EAPolXUN1QVwwKZM9s9LDKBXODMqDLh8GAPoJQbQM2saqwsQenwD6DEG0DN8Cwjf DX6GAfQUA+idVbnqAoTcxgx1QdgwgN7JXaUuQMgNep5vAL3FAHpoRTN1AUKNbwA9 xwB6KGe9ugChdu5/+AbQYwygl/J2VhcgxEoy1QXhwwB6iW8B4aNzXlAXhA8D6Kml LdUFCK3iLHVBCDGAnuJbQPjmrJfUBSHEAHqLbwHhE74B9AMD6C2+BYRPzhrFS8De YwA9xsdB4AveA+gLBtBjfCIYvrh0mLoglBhAr63PURcghDbXVReEEwPoNU4NDR9c f7+6IJwYQM8V8modvLaFC0/7gwH0HBeIg+fu+6u6IKQYQO8V83odvLW1Lm+B8QcD 6L1+76gLEDJPX6IuCCsG0AcbecUOXtqaVaJOCCsG0Adnj1QXIFReGaguCC0G0A+b 66gLECYNCtQFocUA+uGWO9QFCJEP+6gLwosB9MUWHld4pkWeuiC8OFB98fqp6gKE xpxO6oIQYwD9sVUdgNDoNl1dEGIMoD+mdlMXICTWNlEXhBkD6BO+BYQ3jhmvLggz BtAnXCETnuBamL5iAH3CiVHhCU6E6isG0C8F9dUFCAHOg+UvBtAvh3yqLkAIPHqV uiDcGEDfbOK/3UgbB6i/eHx9c81QdQEC74Pj1AUhxwD6h8/DIV1N1qoLQo5j1D// 47/eSM+CXdUFYccA+og3QyM9+36vLgg7BtBHS1uqCxBoxVxg0G8MoI94MzTSwpug fccA+onrwyENWzmxuO8YQD9xcRCkYdSZ6oLwYwB9xTthkLr6ReqC8OMA9dXok9UF CKy5HdUFDmAA/cU7YZCqHlPVBQ5gAP21uLW6AAFVxOmEDGAA/ZW7Sl2AgLpwuLrA BQygz4o4oS9SwXtgjGAAfTbo3+oCBNKrZ6gLnMAA+o2XQZCKBgXqAicwgH77rqe6 AAG0kotqGcEA+i2jWF2AADrhXXWBGxhA3xVySg8ki2shGcIA+o4PBCNpL52lLnAE A+g/XgZBsvgYsCEMoP++2V9dgIBZ0Vxd4AoG0AC+BURy+o5TF7iCATSggE91Ihm8 BGIMA2jAwJfVBQgUXgIxhgE0gfOiIhmZJeoCZ3BkmsDLIEhCXgt1gTsYQBP4NAiS cPz76gJ3MIBGcHk4JIwTYRnEABpxw93qAgTGuL7qAocwgGbwVkAkaueV6gKHMIBm /NJKXYCA4FogJjGAZnSYoy5AQFx/v7rAJQygIbwVEInhL4pJPNqGTDxUXYBAWNJG XeAUBtAQ3gqIhHAeBKMYQFNK6qkLEAC8CdAsBtCUodeoCxAAXxysLnALA2gMbwVE 7XZdoC5wCwNoTH4DdQGst4lflJjFABoz6N/qAljv1TPUBY5hAM3hZ2DUpmG+usAx DKA5q3LVBbBcSaa6wDUMoDl9xqoLYLlHr1IXuIYBNIifgVEzDkfTeMQNWtxaXQCr FfBGAdMYQIN6fqcugNVuu11d4BwG0CR+BkZNOBqN4yE3aWFbdQEstiFHXeAeBtCk 7lPUBbDYjfeoC9zDABrFz8CIj4PRPB5zo/gZGHHxE7AAA2gUrwMjLl4DFmAAzeJn YMTDsSjAg27WyqbqAliqOEtd4CIG0KxTX1cXwFJPX6IucBEDaBg/AyO2zBJ1gYsY QMM4LzRi4lzQEgygYXfdpC6AlcYeqy5wEgNoGj8DI5Z2i9QFTmIATdtYV10AC3E9 YA0G0LQPj1YXwEI/d1AXuIkBNC2jWF0ACx3/vrrATQygcVt4zFENfyk0eNyN48T4 qCa/obrAUQygcVwcDtUMvVZd4CgG0DzeCIOqdtqiLnAUA2heEVe/RmVbdlIXuIoB NO/lgeoCWGZyT3WBqxhAAX4GRmUHTFIXuIoBFOCNMKiMvxAqPPICy1qoC2AVrgYi wwAKnPecugBWGX6husBZDKACvwREtMbr1AXOYgAVNvGuB1TgTDA6DKDC1G7qAlhk eUt1gbsYQIXuU9QFsMhfHlIXuIsBlOCXgKjAQajDYy9RwhVwUI7PwQkxgBLf7K8u gDUWtVMXOIwBlOgwR10Aa1z8jLrAYQygBr8ERDmOQSEefI0VzdQFsMTKndUFLmMA NTglFrYbdaa6wGUMoEbrxeoCWKLNEnWByxhAEX4JiDIcgko8+iJrG6kLYIV1jdUF TmMARd4/Vl0AK3xwnLrAaQygyN6T1QWwwj4/qAucxgCq8EtAbMMRKMXDr8LFMfGr 4ix1gdsYQJUZndUFsMDMLuoCtzGAKnferC6ABe66RV3gNgZQJatQXQAL1C9SF7iN AZThVRBwAKrx+MvwVmjwNmg1BlDmk8PUBZCbeLi6wHEMoEz/t9UFkDtpjLrAcQyg Dr8EBMefGE+ADgMIjj8xngCdxa3VBRBb0kZd4DoGUGfEOeoCiI08V13gOgZQp+s0 dQHEuk1XF7iOARTil4Cu4/BT4xkQYgBdx+GnxjMgtKyFugBSy1uqC5zHAAq9+1t1 AaTe66cucB4DKHTs++oCSB33gbrAeQygEr8EdBtHnxxPgRID6DaOPjmeAqU1nAzJ ZWubqAvAACp93ltdAKEvDlYXgAFUumSYugBCg59SF4ABVKq7UV0AoXqb1AVgAKV4 FcRlHHx6PAdShVwW211F9dUFYAC1FrRTF0BmYXt1ARhArdEnqwsg89YAdQEYQC0u jOQwLohkAQZQi1dB3MWxZwGeBC0G0F0cexbgSdAqylQXQKSYdwBYgAHUWthWXQCR RbwDwAIMoNaYE9UFEPlvf3UBGEC1372qLoDI6a+pC8AAyvEqiKs49GzAsyDGALqK Q88GPAtixRnqAkiU8Pq/DRhAsbyd1QWQWNFcXYAIAyj39QHqAkh800tdgAgDKPeP P6sLIPHQX9QFiDCAct2nqAsg0WOqugARBlCPl4HdxJFnBZ4GNQbQTRx5VuBpUON9 ME7iXTB2YADVeB+Mk3gXjB0YQDXeB+Mk3gVjBwZQjffBOIl3wdiBAVTjfTBO4l0w dmAA5XgZ2EUceHbgeZBjAF3EgWcHngc5BtBFHHh24HmQW5+jLoBx+Q3VBSjFAMr9 vJu6AMbN211dgFIMoNzYPuoCGDeur7oApRhAudtuVRfAuNtvUxegFAMo13mGugDG dZmpLkApBlCPl4Hdw3FnCZ4IPQbQPRx3luCJ0GMA3cNxZwmeCL38BuoCGLaB935a ggHUW9hWXQDDFrVTF6AMA6j3yWHqAhg28XB1AcowgHqPXa4ugGGPX6EuQBkGUG/A m+oCGHbKaHUByjCAelmF6gIYVr9IXYAyDKAFeB+MazjsbMEzYQEG0DUcdrbgmbAA A+gaDjtb8ExYoKC+ugBGFWarC7AdA2iB5Vwk2y15LdQF2I4BtMDUbuoCGDWtu7oA 2zGAFni7v7oARo05SV2A7RhAC9xwt7oARt14j7oA2zGAFug+RV0Ao3pMVRdgOwbQ BrwPxi0cddbgqbABA+gWjjpr8FTYgAF0C0edNXgqbMAAuoWjzho8FTYoylQXwKDi LHUByjGANljdRF0Ag9bkqgtQjgG0wfz26gIYtGBXdQHKMYA2+PoAdQEM+qaXugDl GEAbjDpDXQCDXhmoLkA5BtAGN9+pLoBBt9ylLkA5BtAGvT9XF8Cgg79QF6AcA2gF 3gjoEg46e/BcWIEBdAkHnT14LqzAALqEg84ePBdWYABdwkFnD54LKzCALuGgswfP hRUK+XSoO4q4CKA9GEArrGmsLoAxa/nktz0YQCssbq0ugDFL2qgLsAMDaAUujOkQ LoppEQbQCuOOURfAmA/7qAuwAwNoheEXqAtgzLOD1AXYgQG0wpAH1AUw5tqh6gLs wABa4bBP1AUw5vCJ6gLswABaIbNIXQBjsorVBdiBAbQDHwVxB8ecRXgy7MAAuoNj ziI8GXZgAN3BMWcRngw7MIDu4JizCE+GHRhAd3DMWYQnww7FGeoCGFKSqS5ABQbQ DvkN1AUwZEOOugAVGEA7rGyqLoAhq5qpC1CBAbTDgnbqAhiysL26ABUYQDtwPixn cDYsmzCAdvj4CHUBDJlwpLoAFRhAO7w8UF0AQ0adqS5ABQbQDvf8VV0AQ+69QV2A CgygHQb9W10AQy4cri5ABQbQDvt+qy6AIft9py5ABQbQDpwQ0BmcDtAmDKAl+DCw KzjkbMKzYQkG0BUccjbh2bAEA+gKDjmb8GxYggF0BYecTXg2LMEAuoJDziY8G5Zg AF3BIWcTng1LMICu4JCzCc+GJYo4T7AbirPUBYjCAFqCU0I7ghNCW4UBtASnhHYE J4S2CgNoicWt1QUwYkkbdQGiMICWmN1RXQAj5nRSFyAKA2iJ7/dRF8CIyT3VBYjC AFqCc+I7gjPiW4UBtMTb/dUFMGLMSeoCRGEALfHvQeoCGDH8QnUBojCAluCiII7g kiBWYQAtceUj6gIYcdWj6gJEYQAt0e8ddQGMOOFddQGiMICW6DpNXQAjuk1XFyAK A2iJnTapC2BE3c3qAkRhAG3B+bDcwBFnFZ4OWzCAbuCIswpPhy0YQDdwxFmFp8MW DKAbOOKswtNhCwbQDRxxVuHpsAUD6AaOOKvwdNiCAXQDR5xVeDpswQC6gSPOKjwd tmAA3cARZxWeDltwXUwncFVMuzCAtiiory6AAYXZ6gJEYwBtsa6hugAGrG+kLkA0 BtAWXBjYCVwW2C4MoC1+aaUugAFLd1EXIBoDaIv57dUFMGDBruoCRGMAbTGtq7oA Bkzvpi5ANAbQFpP2UxfAgG/3VxcgGgNoi08OUxfAgImHqwsQjQG0xTv91AUw4N0T 1AWIxgDa4uWB6gIYMOpMdQGiMYC2GHaJugAGPDVYXYBoDKAt7vmrugAG3HuDugDR GEBbDHlAXQADrh2qLkA0BtAW5z2nLoAB5z+vLkA0BtAWfcaqC2BA33HqAkRjAG2x x0x1AQzoPEtdgGgMoC2yN6gLYECDAnUBojGA1uCc+C7ggLMLz4c1GEAXcMDZhefD GgygCzjg7MLz4aFmfzy3ZU6MaxsVF+evWbpo1k/TZxfX8NUMoAtqOuAyO3Xdc4+2 rZrkZMb6S5S/bMS/VvrW5SoG0Bu/P3+fpvUS/cPFJfmr8xbM+XUQo38jzgC6IPqA y/518Dq2b56bk5HwFQE3rpr83Es+ZDmLAUxbh9uOa5nWDRStz1s8Z+bPb3rUA5ud snvnjm2aN0zv4pjL3r9trkc9rmMA05L1+Cm5Ht1USYZHNwSbefY0r37z8iKPbspl DGDqjn1wL3UCnPbjNR+oE4KOAUxRs9GcwRl6Ewfwwkg6GMCUDDu3vjoBKFU4glMM po4BTF7W+N7qBCDKF0fz68AUMYBJ+3ZfdQFQxXdcUzA1DGCSxvZRFwAxjOurLggk BjAp19+rLgDi+Ot96oIAYgCTsTS9dzwDflrWSl0QPAxg4q56WF0A1OjqR9QFQcMA Jozf/sF6/CYwSQxgopY3VxcAtcproS4IFgYwMe3nqwuAhOy6QF0QJAxgQrhkGwKD C88lgQFMBPuHAGEBE8cAJoD9Q6CwgAljAGvH/iFgWMBEMYC16jBHXQAkqSNnjE4M A1ibm+9UFwBJu+UudUEwMIC14VpFCCKO7ITwMNWigDOfIogKs9UFgcAA1mzUGeoC ICWvDFQXBAEDWKOc9eoCIEUN89UFAcAA1qgk4YudA5bZyIVWa8cA1uTt/uoCIGVj TlIX2I8BrAFnQECgcV6EWjGANSjKVBcAaSjOUhdYjwGM77Zb1QVAWm6/TV1gOwYw Pt4CjaDj+K4FD1BcX/VSFwBp+vpAdYHlGMC4+AYQwccBXjMen3jW56gLgLTlN1QX 2I0BjKPZCnUB4IGdV6oLrMYAxsEPwAgHDvGa8OjEdtnj6gLAE5c/oS6wGQMYG98A Iiw4xmvAgxPTmwPUBYBHRp+iLrAYAxgT3wAiPDjI4+OxieV/x6kLAM+8f7y6wF4M YCx8A4gw4SiPi4cmhicHqwsADw27VF1gLQYwBk6DhVDhtFhxMYDVcR5UhAxnRo2H Aaxuajd1AeCpad3VBbZiAKvjJRCEDcd5HDww1fzSSl0AeGzpLuoCSzGA1fANIMKH Az02HpdqGECEDwd6bDwu1TCACB8O9Nh4XKpa01hdAHhubRN1gZ0YwKr4BhBhxJEe Ew9LVQwgwogjPSYelqoYQIQRR3pMPCxVLGyrLgB8sKidusBKDGAVfAOIcOJQj4VH pQoGEOHEoR4Lj0oVDCDCiUM9Fh6VylovVhcAvmizRF1gIwawstW8XxThtCZXXWAj BrAyfgJGWHGsx8CDUhkDiLDiWI+BB6UyBhBhxbEeAw9KZQwgwopjPQYelEqWN1cX AD7Ja6EusBADWAnfACK8ONir4zGphAFEeHGwV8djUgkDiPDiYK+Ox6QSBhDhxcFe HY9JtB/2UhcAvvlxb3WBfRjAaMUZ6gLANyWZ6gL7MIDR+AkYYcbRXg0PSTQGEGHG 0V4ND0k0BhBhxtFeDQ9JlAFvqgsAH50yWl1gHQYwyirOmIYwW91UXWAdBjAKPwEj 3Djcq+IRicIAItw43KviEYnCACLcONyr4hGp0GGOugDwVce56gLbMIAVhl+gLgB8 9ewgdYFtGMAKhVnqAsBXRfXVBbZhACvwK0CEHcd7FTwgFRhAhB3HexU8IBUYQIQd x3sVPCAVGECEHcd7FTwgFRhAhB3HexU8IBUYQIQdx3sVPCA7fHmgugDw2VcHqQss wwDuwEXREXpcHL0KBnAHLgiC0OOyIFUwgDvwK0CEHwd8ZTweOzCACD8O+Mp4PHZg ABF+HPCV8XjswAAi/DjgK+PxKPd5b3UB4LsvDlYX2IUBLPdLK3UB4Lulu6gL7MIA livgVGkIv8JsdYFdGMBy/AoQLuCIr4SHoxwDCBdwxFfCw1GOAYQLOOIr4eEoxwDC BRzxlfBwbDfqDHUBYMArA9UFVmEAt5vWVV0AGDC9m7rAKgzgdqty1QWAAaubqgus wgBux8mw4AROiFUJA7gdr4HADRzy0Xg0tmMA4QYO+Wg8GtsxgHADh3w0Ho3tGEC4 gUM+Go9GmRd/ry4AjHjpLHWBTRjAMj/spS4AjPhxb3WBTRjAMiuaqQsAI1burC6w CQNYpqSeugAwYiPveI3CAJbhNRC4gmM+Cg9GGQYQruCYj8KDUYYBhCs45qPwYJRh AOEKjvkoPBhlGEC4gmM+Cg9GKS4KDGdwaeAoDGCp1U3UBYAhazj1ZQUGsBQ/AcMd HPQVeCxKMYBwBwd9BR6LUgwg3MFBX4HHohQDCHdw0FfgsSjFAMIdHPQVeCxKMYBw Bwd9BR6LUgwg3MFBX4HHYpt3+qkLAGPePUFdYA8GcJt5u6oLAGPm76YusAcDuE1+ A3UBYMyGHHWBPRjAbfgVIFzCUb8DD8U2DCBcwlG/Aw/FNgwgXMJRvwMPxTYMIFzC Ub8DD8WvxvZRFwAGjeurLrAGA/irhW3VBYBBi9qpC6zBAG4zrR1vDIAr8hd2UyfY gwGsMGr/luwgwit/2aSB6gbbMIDVjDqgBTuIMMlf/g3LFxsDGM/LB/D9IAIuf9k3 Z6ob7MYA1ubbDtn11A1AUjYWzN1P3RAMDGCCxnVvnKVuAGpRtHYq7+lKBgOYnBEH tWjAN4SwzcYNy788Vx0RRAxgakYd0LyhugGIrM/j9Y10MIDpeeHA5tkZ6gg4p6Qg 76uz1RFhwAB6ZPT+TXjRGH7LXzNpgLohVBhAr43ev3EWvyWElzYWrWX3/MEA+uax I5o35EzTSN2G9XkTrlBHhBwDaMDQI1s0yeI3hUhESdGa5R8PUVc4gwE06x/HNG2U lamugGWKi9at+vAv6goXMYA69x/btGFWfXUFRAqL1q/64Dp1hesYQEvc069JTv26 vHoSZhs3FeavefcGdQaiMIBWuvmkxo3qZ7CHAbdxU0nhurVv36XuQFwMYCDcfFrD BlmZDKLlNm4qLtqw/nUGLzgYwID687nZ2dkZdXdiE1U2bt5UUlBQMOIhdQjSwACG yKBLsnKyM+vttBNvufFWyebNG4sL8oueGq4ugccYQAf87tqM7MzMjF+XsQ7fMMa3 ccuvO1dSXFxQ8sBr6hYYwgACcBYDCMBZDCAAZzGAAJzFAAJwFgMIwFkMIABnMYAA nMUAAnAWAwjAWQwgAGcxgACcxQACcBYDCMBZDCAAZzGAAJzFAAJwFgMIwFkMIABn MYAAnMUAAnAWAwjAWQwgAGcxgACcxQACcBYDCMBZDCAAZzGAAJzFAAJwFgMIwFkM IABnMYAAnMUAAnAWAwjAWQwgAGcxgACcxQACcBYDCMBZDCAAZzGAAJzFAAJwFgMI wFkMIABnMYAAnMUAAnAWAwjAWQwgAGcxgACcxQACcBYDCMBZDCAAZzGAAJzFAAJw FgMIwFkMIABnMYAAnMUAAnAWAwjAWQwgAGcxgACcxQACcBYDCMBZDCAAZzGAAJzF AAJwFgMIwFkMIABnMYAAnMUAAnAWAwjAWQwgAGcxgACcxQACcBYDCMBZDCAAZzGA AJzFAAJwFgMIwFkMIABnMYAAnMUAAnAWAwjAWQwgAGcxgACcxQACcBYDCMBZDCAA ZzGAAJzFAAJwFgMIwFkMIABnMYAAnMUAAnAWAwjAWQwgAGcxgACcxQACcBYDCMBZ DCAAZzGAAJzFAAJwFgMIwFkMIABnMYAAnMUAAnAWAwjAWQwgAGcxgACcxQACcBYD CMBZDCAAZzGAAJzFAAJwFgMIwFkMIABnMYAAnMUAAnAWAwjAWQwgAGcxgACcxQAC cBYDCMBZDCAAZzGAAJzFAAJwFgMIwFkMIABnMYAAnMUAAnDW/wc77wqmRWWJUAAA AABJRU5ErkJggg=="/></symbol><g mask="url(#b)"><g transform="rotate(.193) scale(.36014)"><symbol id="c" viewBox="0 0 1280 1280"><image width="1280" height="1280" xlink:href="data:image/png;base64, iVBORw0KGgoAAAANSUhEUgAABQAAAAUACAIAAACXhmigAAAACXBIWXMAAA7EAAAO xAGVKw4bAAE6aUlEQVR4nOzdC3xcdZ3//zT3uWeSyWRya6GFtiAKv5WKl8Ur+NvV PxZFquwKAlpALru6WuSiD8qiCJatoigrXVAU1ooWcIEWqVS8rJdKufqD0tA218lk Mvf7ff7fZGrsJZfJ5HzPmcy8ng83W9KZz/fbmenpeed7W1IDAAAAAEAVWKJ1BwAA AAAAUAMBGAAAAABQFQjAAAAAAICqQAAGAAAAAFQFAjAAAAAAoCoQgAEAAAAAVYEA DAAAAACoCgRgAAAAAEBVIAADAAAAAKoCARgAAAAAUBUIwAAAAACAqkAABgAAAABU BQIwAAAAAKAqEIABAAAAAFWBAAwAAAAAqAoEYAAAAABAVSAAAwAAAACqAgEYAAAA AFAVCMAAAAAAgKpAAAYAAAAAVAUCMAAAAACgKhCAAQAAAABVgQAMAAAAAKgKBGAA AAAAQFUgAAMAAAAAqgIBGAAAAABQFQjAAAAAAICqQAAGAAAAAFQFAjAAAAAAoCoQ gAEAAAAAVYEADAAAAACoCgRgAAAAAEBVIAADAAAAAKoCARgAAAAAUBUIwAAAAACA qkAABgAAAABUBQIwAAAAAKAqEIABAAAAAFWBAAwAAAAAqAoEYAAAAABAVSAAAwAA AACqAgEYAAAAAFAVCMAAAAAAgKpAAAYAAAAAVAUCMAAAAACgKhCAAQAAAABVgQAM AAAAAKgKBGAAAAAAQFUgAAMAAAAAqgIBGAAAAABQFQjAAAAAAICqQAAGAAAAAFQF AjAAAAAAoCoQgAEAAAAAVYEADAAAAACoCgRgAAAAAEBVIAADAAAAAKoCARgAAAAA UBUIwAAAAACAqkAABgAAAABUBQIwAAAAAKAqEIABAAAAAFWBAAwAAAAAqAoEYAAA AABAVSAAAwAAAACqAgEYAAAAAFAVCMAAAAAAgKpAAAYAAAAAVAUCMAAAAACgKhCA AQAAAABVgQAMAAAAAKgKBGAAAAAAQFUgAAMAAAAAqgIBGAAAAABQFQjAAAAAAICq QAAGAAAAAFQFAjAAAAAAoCoQgAEAAAAAVYEADAAAAACoCgRgAAAAAEBVIAADAAAA AKoCARgAAAAAUBUIwAAALEh7u62urm7Jktolh9RM/N+8/4XNTzr0//L5XDabHR/3 SOkxAADVigAMAMD8OBwdU3G3tlb8b+LX9fUN4v83NTWJEFtfX1dC2UwmK4JzMpnM 5fKZTHoiBE/IT0Vil2tM8T8LAABVhQAMAMAc2traGhoaCkFXfKmrqxP/Kb42NjaK b0ptWiTgVCqVzWbT6bT4WsjD4pviP71er9SmAQCoPARgAACmYbPZ6uvrJkNvbSHx NjaK/zVOTm/WjEi/qQnpQh4uDBJnMlmPh8nSAADMjQAMAMDfTC7orRe5V6Tf+voG vV5XX1+vdadmlMlkYrF4JpMWGVgk4Ww2w7JhAABmQQAGAKAw3ltfVydy78Qwr8Gg 17pH8xaNxlKplAjD2WxOBGPGhAEAOBYBGABQvWy2tsncOzHYazabxC+07pECstls KBSeTMLZySTMUmEAAA4hAAMAqk7h4KLa2tqGhoampma9Xqd1j6SIxeLJZCKdTk/O juZQJQAACMAAgGoyOeTbUF9fp9PpRe7VdkcrdeTzeZGE4/FYJpPNZNIMCAMAqlnl /8MPAIDD0SHin8i9zc3NJlOFTHWer2w2Gw6HE4lE4aXgVGEAQBUiAAMAKpmIvuJr bW2dTtes1+urM/oeTsTg2MSIcCKXy4r/JAYDAKoKARgAULHsdntjY8PEXGddVcx2 Ll4+n5+YFR2LpVJpt9utdXcAAFAJdwMAgArkcHQ0NDQYjcampiYR9ki/xyq8LMlk MhKJpNNphoIBANWAGwIAQKXp7e0R0bexsVH8mug7OxGDxddUKiVi8NDQsNbdAQBA Lm4LAACVo6enW6/XNzU1sdZ3vrLZbDKZjMViw8MjWvcFAABZCMAAgErQ1dVpMBia m5tra2sZ9S1NPp/P5XKJRCIajTqdo1p3BwAA5XGLAABY3ByODr1eL9Iv0VcRhRgs MnAsFmNhMACgwnCjAABYxJYuXWow6BsaGkT61bovFUVk4HQ6LVLw4OCg1n0BAEAx BGAAwKJUmPPc1NRUX1+vdV8qViaTSSaTzIgGAFQMAjAAYJGx2+06nU6v14n0q3Vf qsLk5lhxgRODAQCLHQEYALCYdHV1GQz65uZm9nlWUzabndwcK+Z0OrXuCwAApSMA AwAWB4ejo6mpWacT4bdZ675UKZGB4/FEMplgcywAwCJFAAYALAJdXZ2T0571DPxq K5vNxibnQ7MqGACwGBGAAQDlrre3R0RfEYC17ggOEQFYxOChoWGtOwIAwPwQgAEA 5cvh6GhubjaZTAz8lptsNhsOhxMJpkMDABYTAjAAoEx1dXUW0u+SJUvy+bz4qnWP cEjh7RBfCxmY6dAAgMWCmwkAQNlxODrq6ur1ep3BYNC6L5hDNBqNxeLZbIahYABA +SMAAwDKi91ub2pqFNGX3Z4Xi8kTkqLJZIqDggEAZY4ADAAoIw5HR2Njk8ViXoyL fvP5vF6vX7p02amnnmqz2davX1/kE7ds2eLxeF588cXBwYFYLLYYJ3tns9lgMJRK JRkHBgCUs8X3TywAoFI5HA6drtloNIr0uygW/YrUZ7O1r1ix4i1veUvxcbcYIhLv 3r17//79Hs94+f8soPBmiVcjEonE4wmXy6V1jwAAmF6531sAAKqEw9FhMBhMJpPW HZlDIfS++c1vXrdu3Zo1a1Ro8c9//vNDDz20Z8+eRRGGw+FwNBplHBgAUJ4IwAAA 7XV2OkT6NRqNWndkRiL3Ll26dP36y9auXathN7Zt+9mWLVtGRkbq6+s17MbsIpGI yMCjo4wDAwDKDgEYAKCxrq5Ok8ms05XjlldlknuFdDodCARyuVzhP3/xi1/8938/ WLZJOB5PhMMhjkcCAJQbAjAAQEsi/ZrN5nLb8Lkwz/mCCy5QdmVvaTKZjIi+okvT /u6DDz746KOPBgL+cpsdnUgkQiEyMACgvBCAAQCaKcP0K3LmGWe89aabburp6dG6 LzW5XM7v94sAPOcjR0dHN2/e/Pzzz5XVgDAZGABQbgjAAABtiPRrsViampq07sgh dXV155330euvv17rjhwiom8qlZrvs+6669vbt2+fmimtuWQyGQwGycAAgDJBAAYA aECk37a2tjKZtSu6cfnlV5TDbOcCkRgTicRCKjw44YEyicGZTMbn85GBAQDlgAAM AFBbZ6fDZrOVQ/ott+hb2D9ZqWrlE4OzmazH62FfaACA5gjAAABVORwi/bZpvlS1 3KJvLBYLh8MyKk+E4Ad+lM/nZRQvXiaT8Xi8LhcZGACgJQIwAEA9dru9pcWi0+mW LNHsH6BsNnvBBf9UPmt9U6lUIBCQHVDvuOOOJ5/coeHPHcQfMB6PBwJBt9utVR8A ACAAAwBUUg7pd9Wq1SIKlsMOzzWTmzz7fL6ZzjdSVjqd3rdv32233z7uHlOhuWmR gQEAmiMAAwBUsmLFcqPRqFX6rauru/vu/1yzZo0mrR8rEAgkk0k1WxQZ2B8I/PqZ Z/7rv7Zo9S6IDByJRPbvP6BJ6wAAEIABANI5HB06nc5kMtXW1qrfeuFo3y1btqjf 9LSU3elqXgLBoMvlisdid99998GDBzTZhyyXy4XD4Xg87nJpNhYNAKhaBGAAgFwi /dbX17e2tmqSfstq4LdwKK6G+1Gl0+lgKOQaHRW/6Ovru/fe/9JkKLgw9zuTyZCB AQAqIwADAOTS8Mjf009fUyYDvyL0er1edZb7zk5E30AgMDIyUsjhd9999+DggPrd EC+FeEE4HBgAoDICMABAIoejo729Xf30K9LdzTf/+9q1a1Vud1qhUCgej2vdi78J BINjY2Oxv07D3r17989+9lP136PJg5E8DAIDANREAAYAyGK32y0Ws8FgULldnU73 0EM/LYetntU54mi+Dk2EdrnSqVThO16vd/Pm/8jlcir3JBqNBoMhNoUGAKiGAAwA kEKkXxFErdYWldstn2nPPp9PRE2tezG9iYnQweDEROjDQq8m06H9/kA8HicDAwDU QQAGACivsPGV1WpVc2JtNpu95pp/Wb9+vWotzkTDfZ6LNzER2u2ORSKHf3PnhKdU ftf8fj8bYgEA1EEABgAor6ur02w2Nzc3q9aiyFG33PIVzRf9im74fD715xKXoDAR emxsLHXkccS7d+/+6U8fqq+vV60niUQiFAqxIRYAQAUEYACAwhwOh8GgN5lMqrWY z+cff/wJzRf9lttmV3MqTIR2jowcldi9Xu/tt9+m5jhwOByORmMul0u1FgEA1YkA DABQksPR0dDQ2NpqVe2A2XJIv4VDfcpts6tiTDsRukb1DCxeOp/Pn06nmAgNAJCK AAwAUFJ3d7dIv6oFJ6u1ddeuXeq0NZNwOByLxbTtQ8kOTYR2uVJ/3RH6cBs3bkwm E+r0JJPJ+P0TBxSr0xwAoDoRgAEAinE4HEajwWg05vN5FUaAyyH9jo+PL4oVv7OY dkfoKepk4MIHJjIhykRoAIA8BGAAgDIcjo6mpiar1apOc5qn31gsFg6HNeyAgiYm Qo+NxWbYuVrNcWC/359MJpkIDQCQhAAMAFCGmpOfNU+/5XzGbwkKE6Fdo6Mz/aFU y8BMhAYASEUABgAowOHo0OsNZrMaOz/rdLrf//4PKjQ0rVwu5/F4FuN+V7ObmAgd mEieM/3RbrzxBnUme4dC4VgsyiAwAEAGAjAAQAFLl/ZarWrs/Kztns+VNO35WIFg 0OVyxWfY0Eu1faHFW+z3+wcHh2Q3BACoQgRgAMBCdXV1Go1GvV4vuyFt028gEEgm k5o0rY7CROhRpzOTyUz7ANUycCwWi0QiTueo7IYAANWGAAwAWBCHo0On01ksFtkN ZbPZe++9b82aNbIbmpbH4xEd0KRpNYkM7Pf7Z1mC29fXt2XLPSpk4GAwGI/HmQgN AFAWARgAsCA9Pd1Wq/S9r0T4vOWWr6xdu1ZqKzM1LdKv+u1qJRAMOp3OZGLGLa92 7979s5/9VPY7nslkAoHA8DC7YQEAlEQABgCUzuHoMBiMJpP0g3/POuvsTZs2yas/ k2QyKWKY+u1qqHAssHNkZJYtr+6///69e1+V14fCxykcjkSjEQaBAQAKIgADAErX 29vb0mKRPRjY3d39+ONPSG1iWpGICGDTH41b2SZ2wxobi8/6Z7/11lvD4ZDUbmQy mWAwNDTEblgAAMUQgAEAJXI4HCaTyWCQu/dVPp9/4YUXpTYxrWAwmJh5GnBlK+yG 5XQ6szPshlVw7bUbZP/sIxqd2Hbb5XJJbQUAUD0IwACAEi1btsxsNkmNQNlsdvv2 Hepv++z3+1OplMqNlhWRgX1+v3Pm3bBqVNkUWnwAQqHwwMCAvCYAAFWFAAwAKIXD 0WE2m2UffXT++effcMONUps4ls/nE/FP5UbLUCAYHBkenv0HAdu2bXv22T9L7UYs FguFQqwEBgAoggAMACiFCsO/Dkfnjh075NWfltfrnekU3GozcSRSIDBxJFI+P8vD ZC8GZhAYAKAgAjAAYN5UGP4VKXTHjidVnvxM+j3KnEci1Uy+aLfd9rX6+np53WAQ GACgFAIwAGDejjtumckkd/j3sssu/8xnPiOv/rGY+XyswpFII8PD+VkHgXfu3Llr 19PyupHNZsPhcH8/g8AAgIUiAAMA5sfh6LBYLDqdTmYTjh07npRX/1jsejUTEYBH R0cT8fjsD5M9EToejweDQQaBAQALRAAGAMzP0qW9ZrNZ3pTXTCazffuO3t5eSfWP Vc0nHs2pMAjsHBnJ5XKzPEz2RGjxqQiFQoODnAkMAFgQAjAAYB5UWP177rnn3nTT Rnn1jxKJRKLRqGrNLUaBiaFXVzwWm/1hsneEZiUwAGDhCMAAgHno6emxWlvkrf6t ra3ds+c5ScWPlUgkgsGgas0tUkUOAgvXXffFJUtk3Vpks1m/PzA8PCypPgCgGhCA AQDzcOKJJ+j1enkh5847v/XOd75TUvGjiDg3Pj6uTluLXZGDwH19fffdd6+kPuTz +Vgs1tf3uqT6AIBqQAAGABSrq6uzra1N3vDv8ccvf/jhhyUVP5bb7Z59c2NMKX4Q ePPmzePjbkndyGazXq/X6RyVVB8AUPEIwACAYh1//HFGo1FSABbZ5pFHHl2xYoWM 4sfyeDyiRXXaqgxFbgctAurtt98m70MSiUQOHuyXURwAUA0IwACAotjt7W1tbU1N TZLqqzn8GwqF4nMFORylyDOBayQPAieTSZGx3W7mrgMASkEABgAUpbe3x2Jpqa+X NbL36KM/X758uYziR0mlUn6/X4WGKs/ELGinMznXkVFSB4EzmWwwGBgaYissAEAp CMAAgKJI3f5KzeHfsTHO0SlROp32BwIjRezDLG8QmK2wAAALQQAGAMzN4XC0t9sq YPWv1+vNZDIqNFSpAsHg8PBwOpWa/WGyVwKPj3tcLpeM4gCAykYABgDMbenSXovF IinPqDb8G4/HQ6GQCg1VMBGA3W53NBKZ85HyBoFFAA4Gg4ODQzKKAwAqGwEYADC3 VatWNjc3y5j/LMLMww8/csIJJyhe+VhMfl64dDodDIVGRkZyc+2hLW8QOJ/PJxKJ 117bp3hlAEDFIwADAOYgdf6zyWT+zW9+I6PyUZj8rJQiz0MSNm7cmEzOsWNWaZgF DQAoDQEYADCHpUuXtrRYamtrZRT/xje++e53v1tG5cMlk8lAICC7lSpROA9peGju Gch9fX333XevjD7kcrlAIDg4OCijOACgghGAAQBzWLnyRJ1OJ2P+swjVe/Y8p3jZ YzH5WVkiAA8NDWXS6Tkfed11X5Txycnn8/F4fN++PsUrAwAqGwEYADAbh6PDZmuX dPzvhz70oZtv/ncZlQ8XCoXiRczXRfFEAHaNjcWj0TkfuW3btmef/bOMPmQyWY9n 3OXiRxsAgHkgAAMAZtPb22O1WmXMf85ms88993x9fb3ilQ+Xz+fdbil7EVezQ7Og h4fF6zvng6+9doOMBeS5XM7v9w8NzX0oMQAAUwjAAIDZLF++3GQyypjF2tHR8eST v1C87FF8Pl+6iJm6mK8iDwQWbr311nBY+dOn8vl8OBw5cOCA4pUBABWMAAwAmFFb W2tXV5ek/Z+vv/6GdevWyag8JZPJeL1eqU1UreJnQe/evfuRR6Sc85zNZp1Op9fr k1EcAFCRCMAAgBk5HI6ODruM4V8RTV9++S+Klz2Kx+PJznVcLUpT/F7QwoYNX5Ax 1z2fz4+NuTkMCQBQPAIwAGB6LS0Wk8nc2mqVEYBFtN6x40nFyx4ulUr5/X6pTVS5 ib2gBweLOV1Z3ixon88vKgcCQcWLAwAqEgEYADC9trbWlpYWo1HKAuAvfelL5533 UcXLHm58fDyXy0ltosqJADw6OpooYodtSbOgRQCORCKBQIBZ0ACAIhGAAQDTk7cA WIX5z+l02ucjFMklXmS/3z8yMlLMgyXNgmYZMABgXgjAAIDpOSZ0SKose/4zq3/V EQgG+w8ezBdxGJKkWdCCyzXGMmAAQJEIwACAadhsNp2uua2tTUbx88776Je+9CUZ lQtE9BUBWF59TCnsg1XMQVPbtm179tk/y+iD1+uNxxO84wCAYhCAAQDTsNnaTCaT xWKRUfz551+QUXaK3+9PFXE+LRau+GXANRMHX10now/BYDAcDns8nHcFAJgbARgA MI32dpvVatXr9YpXrq2t3bPnOcXLHm5sbExqfUyZWGvt9zuLWwZ83XVflLGhWiwW 8/v94+OMAAMA5kYABgBMw263d3V1yqh84okrH3roIRmVCyKRSDQalVcfR/EHAv0H DxbzyM2bN4+Pu2X0wekcdbulVAYAVBgCMADgaA5HR21trcjAMopfeeVV69evl1G5 gOFflQWCwcGBgWK2HNu5c+euXU/L6INIv7lczuXirQcAzIEADAA4ms1ma25uEl9l FJe6ADiVSvn9fnn1cSwRgEdGRlLJZDEPlrQM2OPxJBJJ9sECAMyJAAwAOJqIvgaD wWptUbxyPp9/4YUXFS87xefzFbMjMRQ0r32wrr12g4yTpf3+QDQaJQADAOZEAAYA HE0E4NZWKTtgtbRYf/WrXyledgrzn9UnAvCY2x2LRIp58MaNG5PJhOJ9iMViPp+f AAwAmBMBGABwtPZ2EYFtTU1Nilc+/fQ1W7ZsUbxsQTweD4VCkopjJul0unAacDEP vvvuuwcHBxTvQzI5Mf+ZjaABAHMiAAMAjibSb3d3l4wTa6TugCUiUDFbMUFxIgD3 HzyYz+fnfKSkfbBE0yMjTkaAAQBzIgADAI7mmNAho/Jjjz3e09Mjo3IN85+1U/xG 0F6v9447Nsnog8s15nK5ZFQGAFQSAjAA4AgtLRaDwdDe3q54ZRGQXnrpZcXLFiQS iWAwKKk4ZicC8NDQUKa47cck7YM1Pj4ejUYDAT4DAIDZEIABAEdob59Y/SvjDCQR e559do/iZQu8Xm8mk5FUHLOb10lI1133RRmz6z0eTzKZZBkwAGB2BGAAwBHa2tqM RoPValW8stXaumvXLsXLFjD/WUPzOglJ0kbQfr8/Eol6vV7FKwMAKgkBGABwhPb2 dhGALRaL4pVXrVq9detWxcsKmUyG5KMhEYBdLlc8FivmwZs3bx4fdyveh2AwKALw +Pi44pUBAJWEAAwAOIIIwBaL2Wg0Kl5Z3hlI4XA4Vlz6ggzzOgpY0klIkUgkGAwR gAEAsyMAAwCOMHEEsK2tublZ8cryzkASsSeXy8mojGKk02mf3+8cGSnmwZJOQkok Eh6Pl5OQAACzIwADAI7Q3m5rbW3T6RZTAGYBsOb8fn9/f38xj5QUgOPxhM/nZRMs AMDsCMAAgCO0t7c7HB0yDqq5554ta9asUbxsNptl3E9z/kCg/+DBYh7Z19d33333 Kt4B8TFwucaYAg0AmB0BGABwBBGAu7u7ZFR+/vkXZJSNRqOR4lafQp5AMHhQBOB8 vpgHX3/9dTL6MDLiJAADAGZHAAYAHMFub+/qWkwB2OfzpdNpGZVRPBGA+w8ezGsa gJ1Op9tNAAYAzIYADAA4wqILwCwALgciAA/09xe5FRkBGACgFQIwAOAIBGCUYCIA DwzkstliHkwABgBohQAMADjC4grAuVyOZZ/lQATgwYGBLAEYAFDeCMAAgCMsrgCc SCSCwaDiZTFfEwF4cDCbyRTzYAIwAEArBGAAwBEWVwCORCLRaFTxspgvAjAAYFEg AAMAjrC4AnAgEEgmk4qXxXwRgAEAiwIBGABwBHkBeOPGm9euXatsTY/HU+S6U0hV fADevXv3I488LKMPBGAAwJwIwACAI8gLwFdeedX69euVrckW0GWi+AC8c+fOXbue ltEHAjAAYE4EYADAEdrb2zs67PX19YpXJgBXsOJ3gZYUgDOZzNiYmy3BAQCzIwAD AI7Q3m5ra2trbm5WvPKqVau3bt2qbE0CcJkoPgBv3rx5fNyteAcSiYTX6x0f9yhe GQBQSQjAAIAjEIBRAhGABwYGcgRgAEB5IwADAI4gArDVatXr9YpX1ul0v//9H5St SQAuExMBuL8/l8vN+cgbb7yhmIfNVywW8/v9BGAAwOwIwACAI9hsNrPZZDabFa9c V1f37LN7FCyYz+fdbuXHElECEYD7Dx4U78icj7zuui8uWaL87UdoQtjjIQADAGZD AAYAHKG9vd1oNFgsFhnFlT0KOJfLselRmRAB+OCBA8U8UtIhwMFgMBKJ8nkAAMyO AAwAOILN1qbT6dra2mQUv+eeLWvWrFGqGgG4fPgDgf6DB+d8WF9f33333SujA16v Nx6PezxeGcUBABWDAAwAOILNZmtqampvt8koruxJSNlslimvZcLv9/f398/5MHmH AI+Pe5LJJJ8HAMDsCMAAgKN1dXXa7XYZlZXdCJoR4DKRTqd9fr9zZGTOR0raAlpw u91O56iMygCASkIABgAczTGhQ0ZlxTeCZhfochAIBsfc7lgkMucjJW0BLbhcYy6X S0ZlAEAlIQADAI7W3m4TCbiurk7xytls9qWXXlawIAG4HIgA7Bobi0ejcz5yw4Yv 1NfXK94B8bkS6ZczkAAAcyIAAwCOZrPZWlulHAUsPPbY4z09PUpVIwCXAxGAR0dH E/H47A/zer133LFJRgdisZjP52cBMABgTgRgAMDRbLY2s9liNptkFF+37mPXX3+9 UtUIwOVABOCRkZFUMjn7w7Zt2/bss3+W0YFQKBwKBdkCGgAwJwIwAOBobW2ter1B fJVRvLu7+/HHn1CqGgG4HIgAPDw8nE6lZn/YrbfeGg6HZHTA6/XFYlHxVUZxAEAl IQADAI7W0mIRAdhub5dRPJ/Pv/DCi0pVGx8fl7SpEoonAvDg4GA2k5n9Yddeu0HG wvKaiS2gx0UADgSCMooDACoJARgAMA2Ho8PhcEgqruAyYJ/Pl06nFSmFkokAPNDf P/tPIuQtAK6Z2AJaYC4AAGBuBGAAwDTkbQQtnHXW2Zs2KZOFwuFwLBZTpBRK5g8E +g8enP0x999//969r8ponS2gAQDFIwADAKZhs9laWixGo1FGcau1ddeuXYqUSiaT gUBAkVIoTTqdFgF4ZHh49odt3LgxmUzI6EAkEgkEgmwBDQAoBgEYADCN9nabXq+3 Wq0yiit4GnAulxsfH1ekFEoTCAbH3O5YJDL7w+QtAPb7/bFYjBFgAEAxCMAAgGm0 tFgMBkN7u5R9sGoUPQyJjaC1VcwhwPIOQKqZ3AgtGmUHLABAUQjAAIDp2e12h6Oj trZWRnEFZ0G73e58Pq9IKZSgmEOA5c1/zuVyLteY+AzIKA4AqDwEYADA9Gw2W1tb a3Nz85Ilyv9joeAs6EAgkJw1fUEqEYCHBgczs56BJGn+cz6fTyQSXq+PBcAAgCIR gAEA0xPp12QyWSwWGQG4RrlZ0PF4PBQKLbwOSiMCcH9/f37mM5DkzX8WATgYDIbD YZGBZdQHAFQeAjAAYHoOR0ddXb3N1iYpACs1C1qkIGbAaiWdTosAPDw0NMtj5M1/ Fm+9x+PNZjMcAgwAKBIBGAAwI6nLgIXHHnu8p6dn4XXYB0src24B7fV677hDmTOf j8UCYADAfBGAAQCzWbVqpaRlwMJZZ529aZMC6cjv96dSqYXXwXzNuQX0/fffv3fv qzKaLiwAfu21fTKKAwAqFQEYADCbZcuWWiwWSYPASm2FxTJgrUzMfx4eTs/804cN G75QX18vo+lcLhcMBgcGBmUUBwBUKgIwAGA2XV2dNptN3izoK6+8av369Quvwyxo TYgAPNDfn5thB6ydO3fu2vW0pKZFox6Px+kclVQfAFCRCMAAgDmcdNLqxsZGSbOg dTrd73//h4XX4TRg9c25A9aNN94wUzZeIPFep1KpV1/dK6M4AKCCEYABAHNYvvx4 o9EobxD4nnu2rFmzZoFFIpFINBpVpD8o0sQOWGNjsRle9r6+vvvuu1dS0yJXi3f8 wIGDkuoDACoVARgAMIeenm6r1VpXVyepviLnIYlEND4+rkh/UCQRgJ1OZzIx/RFH 8k4/qplcPe73+4eHRyTVBwBUKgIwAGBub3zjKfICcI1Cg8DMglaZCMBDg4OZTObY 35I6/FszGYBffvkv8uoDACoVARgAMLcVK5YbDAZ5s6AVGQRmFrSaZl8ALHX4N5fL iTd6//4DkuoDACoYARgAMLeurq7WVquk82xqJgf07r33voUPArMXtGomFgC73bFI 5Njf6uvr27LlHnlTBjKZjM/ndzqdkuoDACoYARgAUJSTTlrd1NQkr74ig8Dj4+OS th3GUWZZACx1+FdIJpPs/wwAKA0BGABQlOOOW2Yymcp8JXA8Hg+FQkr1B7MQAXhw YCCbzR71fRVW/4bD4f7+AXlNAAAqGAEYAFCUzk6HzWaTGoAVOROYWdAqmFgAHAgM Dw8f+1vyzv4tEAHY4/GMjrrkNQEAqGAEYABAsU488QS9Xr9kicR/O6688qr169cv pIIIZslkUqn+YFqBYNDlcsVjsaO+v3Pnzl27npbXbj6fj8VifX2vy2sCAFDZCMAA gGL19va0tLRIHQTOZrMvvfTyAit4PB6l+oNpTRyANDSUSaeP+v6GDV+Qt1NazeSb GwgEhoamGXkGAKAYBGAAQLHsdntrq7W5uVlqK6tWrd66detCKrAVllSHDkAaHq45 8tTlzZs3j4+7pTadSCR8Pr/bLbcVAEAFIwADAOZBha2wFn4kkohJwWBQwS7hcBPz n8fG4kceuSz76KMatr8CACiBAAwAmAeHw9HSYpE9CCxy1LPP7llIBbbCkmdi+Hdo KH3k/Ofrrvui1MXhNZM/1wgEJtYeS20FAFDZCMAAgPlZvvx4o9FYW1srtZXTT1+z ZcuWkp8eiUSiRw5RQhGH5j8PDR3+zbvvvntwUO7AbC6XE+/pgQMHpbYCAKh4BGAA wPx0d3e1trZKnexao8REaAaBZTh2/2cVJj/XTH4efD7fyIhTaisAgIpHAAYAzNuK FStMJqPsVhY4EToYDCYSCQX7g5rJADw4OJjNZKa+o8LkZyEcjuzfv192KwCAikcA BgDMW3d3d2urVfagX82Cd4RmEFhZ6XTaHwiMDP/tFCIVdn6uOTT86x8ZGZHdEACg 4hGAAQClWLFiuclkUqGhjRtvXrt2bWnP9fv9qVRK2f5Us0AwKFJoKpks/Ofu3bsf eeRhFdoNh8P79x9QoSEAQMUjAAMAStHT0221qjEInM1mt2/f0dPTU8Jz8/k8Z8Yq pbD91cjwcH7y+F+v13v77bep8AHIZDKBQGB4mOFfAIACCMAAgBItX77cbFZjEHgh i4EZBFbKUdtfqbP0VwiFwgcOMPwLAFAGARgAUKKenm6TydTU1KRCW93d3Y8//kQJ T2QQWBHpdDoYCo2MjOSyWfGft956azgcUqHdZDIZDocZ/gUAKIUADAAo3fHHH2ex WNRp66yzzt60aVMJT2QQeOECweDY2Fhs8mjl+++/f+/eV9VpNxgMHjzYr05bAIBq QAAGAJSuu7vLaDTqdDp1mrvyyqvWr18/32cxCLxAheFfp9OZzWR27ty5a9fT6rQb j8cjkQhn/wIAFEQABgAsyHHHLWtpaVGnrWw2e8stXylhU+hAIJD8697FmK+J4V+3 OxaJ7N69+2c/+6kKG18dajcQ6O8fUKctAECVIAADABaks9NhMBiMRqM6zYkMfO+9 961Zs2a+T+RM4NJMDf/uffXVLVvuUS39RiKRaDQ6OupSpzkAQJUgAAMAFqq3t6el pUW1aJTP5x9//In5HowUDAYTiYSkLlWwwurfocFBdQ49Kshms4FAYGhoWJ3mAADV gwAMAFgou91uMOhV2w2rptQMzCDwfBXO/n35pZe+9rVbVUu/NZM/rYhGY6zcBgAo jgAMAFDA5G5YJp2uWbUWS8jAhVm18rpUeUT6/ctf/nLzxpvUTL/xeCISCbP3FQBA BgIwAEAZS5cubW21qtliCRmYQeDipdPpffv2ffaz/6pm+hV8Pv/g4KCaLQIAqgcB GACgDIejQ683mM0mNRudbwaOx+OhUEhqlyrGa/v2XX3VlSqn31AoHItFXS5+TgEA kIIADABQTHd3d2urVeXINN+zkcbHx3O5nNQuVYDt27d/4xubVX4rM5mM3x8YGRlR s1EAQFUhAAMAFONwdDQ2Nra2tqrc7rwycDqd9vl8sru0qGmSfmsmJj/7UqkUw78A AHkIwAAAJYkMrNPpLRZzPp9fskTVf2XOOuvsTZs2FfNIEbREDJbdn0Xqlltu+d// /Z2aLRY+KsFgKB6PkX4BAFIRgAEACuvq6jKbTc3N6u0IPeW4445/5JFHinkku2FN 61Of+tTIiAan7yYSiVAo7HSy8zMAQC4CMABAYQ5HR0NDg9Vqra2tVb910ejPf/4/ c26LFQqF4vF4aU0URrbz+fxRBaOTgsFgJBKJTYjGYvFkMhGfkEgmk+FwqLGxUTy4 qam5qalJp2vW6XTi13q9Tq836PV6o9FosVgMk8xmc2ndK83o6Ogll1ysZotTcrmc 3+9Pp9MM/wIAZCMAAwCUJzJwc3NzS0uLJq1ns9kNG6698MILZ3/YTIPAIrg6nc7R Udf4JJHNQqFgKBROJCZCbCol/pdKT8ofUlNXV6v4fG9RV/xBlkyqnVDX0NDQ2Cj+ 1yReWxGezWaLeIVbW1ttNltHh72rq9tut4tEXUJb27b97D//8z/VX/RbEAgExGtL +gUAqIAADACQwuFwGI0Go9GoSesiPYpAuH379sO/GYvF+vv79+/fPzQ0NDo66nSO eDyeSCQSjcZErBVps7AYVZOBa0WI/hc2uBZ/iPr6uqamJr3eYDIZrVarzdYu3pGu rq5ly5b19PQUBqILLrzwE263W+UF21MiE6Iul0uT1gEA1YYADACQRcSt1lZrfX29 Vh3IZLIWi3ly2DYlwqFItlrFvLJSGFsWr4Z4a9LptFYDvzWT5x75fH6W/gIAVMN9 AABAlsJi4NbWVmInjiVyeGE7biY/AwBUwx0JAECuZcuWWa3aLAZGOfP7AwMDA1r3 AgBQXQjAAAC5HI4Og8FgMpm07gjKSDgcjkajjP0CAFRGAAYASNfZ6TCbzaVtUIzK E4/HQ6HQ6CgbXwEA1EYABgDIZbfb6+vrGxoazGaThvstoUxks9loNJpKpbPZTDqd 8Xg8WvcIAFBFCMAAAIU5HB0i8YqsK2Lv5Lm1jWyChWmJMFw4VDmTyWQnMSkaACAV dyQAgAURcbe2tnYy7k4M84q4q+G5R1jU8vm8CMMiEmf+ijwMAFAWARiAZkRwEqGp 7m8OndEqboJzuVz2rzKZrPge98HlQ7xx4p2qnyQCb1NTIxObIYO4FIgMnExODBFP XAkyWZeLZcPlQlwHxG1k/WGX8KlzticPmv7bNVy8d1zAAZQPAjAAtTkcDhGZmicV OTNW3EDFYrHJqZIZ7oA1MTmruUEk3sbGhqamJhIv1PfXPJycmjJNrFKfuIA3NIjr QKNery/yOiDeuMSkZDLFBRyA5gjAANTT3d2t1+vEbVPJK0LFjVQ8Hhc3UiIMc+8r VWFic2FWs0i84n5X6x4BR8jlciIMTy0h5oIglbggiItAc3OzTqdbyAU8NiE+MjKi bPcAoHgEYABq6OrqMpmMCp6CU9hIViRhp3NUqZqw2+0i7haGecWdLsO8WCwKi4en BodFNiYPK6Wrq1NcDQwGg4IXhHg8Hg5HnE6nUgUBoHgEYAByORwder3eZDLJ2Af4 r+MJsZERbqRKNLkSu66weZW4za2trdW6R8BCiRicSCQnN9NKc9pwybq7u/STJF29 w+GwuHrzowoAKiMAA5Coq6uztbVVhT2BxV1UNBolBhdpcnpz3eRCviadjtCLilVY NhyPJ9LpiZnSZK0iiehrMBhE9JXdkHh3fD4fE3kAqIkADECWnp6e1larmuEqEhEp OMKAz0wcDsfkqbwToZfpzag2IgynUqnCyDD7Es+ks9NhMBiNRoNqLeZyOZ/PPzw8 rFqLAKocARiAFEuX9lqtVhkT52Yn7nFDoVA8HufutqBw1lRhTW9TU5PW3QHKQjab ndyUeGLNMD8yKxDXCp1OZzabNblu+/3+wcEhldsFUJ0IwACUp1X6nSLubgOBYDpd vTtFF7ZsFcQdLYO9wEwKc6QnT1lLV+2wsLhcNDQ0trRYNLxWkIEBqIYADEBh3d3d Nlubhul3yuRGo+GqWl3W1dUpbmR1uokzlrXuC7DIZDJZcdFIJpOZTBWtFhYXDZPJ pOAW/SUTGdjj8XJCEgDZtL9DBVBJHA5He7utfIYcCzOio9GY2+3Wui+yFHa0amxs ELewTHIGFq4wQVqo7H2z7Ha7waDXZM7zTMQrPz7ucbmYlA5AonK55AGoAHZ7u9Xa qtOV3dijuKny+fwVNrBQOL6osbFRr9c3NDRo3R2gAuVyuUISTqUqbT1Fd3d3a6u1 fH5YOSUeT/j9Prd7XOuOAKhYBGAAilm+/Hiz2ax1L6ZXMWdOknsB9RWScOE4pQq4 hsg7m10RoVDowIGDWvcCQMUq02sfgEWnq6urvd1WtndUBYt6KLirq7OQe8VXrfsC VCmRhOMTEot0nXDZDvweLp/Pj497nE7OdQcgRVnfqgJYLByODovFUg7bqMxp0Q0F Fw7v1en0ZTi3HKhak3tHx5PJRDabXRQXk/If+D1cPB4PBoOL4oUFsOgsgosggPLX 29vb1taqdS/mQdy8+v2Bch4KFner9fX1zc3NBoNhUdywAtUpmUzGYrFkMlXOWzd1 d3dbrS3ikqJ1R+bB6/UNDXEqEgDlcVMFYKHs9na73b64bq1qyniDaIfD0dzcJHIv S3yBxeKvU6PjqVS6rC4pZbjVc5EymYx7ArthAVDYIrsaAihDS5f2trYupuHfwyWT yWAwVA6LzQpDvjqdTq/XL7pbVQAFqVQqFoslEslyGBDu6uqyWMyL93Q0n883OMgg MACFcY8FYEFEbLPZbItu+Pdw+Xw+EAgmkwmt1puJ11DcoRqNRoZ8gcqQy+VEDI7H 41qtEJ68qjS3tFgW9U/TMpmMx+NhJTAAZS3iyyKActDT02OztWndCwWIW9VQKDQ6 quqgTVdXZ3Nzs4i+tbW1arYLSUTaKfwin8+L91Rkj9pJdXX1Ql1dnU7XnM3m8vlc Op0RDxb39+JLbpJ4ivg6FVfKfJ9eFCkeT8Ri0XRa1S2jOzsdZrN5UexKOCePxzs8 PKx1LwBUFAIwgAU58cQTDQa91r1QhogfgUAglZJ+zufkWb71ej2znctXIZSK7CqC a2NjY3Nz8+QOuiJWmIzGif9nMBiMRkNzs85qtbZNEt9UcAxfRKZgMOj1en2+iS/h cFj8ZzQaCYUm9jCPRMKRSCQejyeTSfHIqd7yk5TyJK4q0WhUvFkqXFvEx7WlpaVi PgnRaKyvr0/rXgCoKNx4ASiduNkSKizCiftUETYk3aeKV0xkJJGdRKCSUR9zmhpo FW9EYZNtkRZaW1vb2+3d3V29vUuF3t5ei8Vy7HNFgEkkEuKrKKJ+z4shQvLIJKfT OTbm8ng84juhUGjywJ5kNpsRHa+rq62wv7OLRSaTEZeXeDwhaXmwuLyYTCbxkZZR XCvi79qY+CgzCxqAcvgnEEDpli1barVate6F8sR9aiAQVHbeXWFkxmg0iq8KlsWx piJuc7NOvOCtrdaOjo6ent7ly5efdNJJK1eunNeeQIlJIj3K67DK4vF4X1/f66+/ Pjg46HKNjo97JhNyLJ1O5XL5+nqmXsuVzWZFDBYfKqdzVMGyPT09LS2WRb0dw0z8 fv/AwKDWvQBQOQjAAEp30kmrF+/+onMKh8PiPnXhIw92u725udlkYo8rhRXWzTY1 NZvNZvEi9/b2nnDCCW984xtPPfVUvb70afmiZiH0plIpBXu7WASDwVde+X+vvrp3 YGBgdNQpskckEkmn03V1dYwbK0h8eidHg+MLj8EOR4fBYDCZTIp0rAwlk0nxgdS6 FwAqB/+YAShRZ+fEBGiteyFXNpv1+fwjIyOlPb0w6ituTIm+CyTeiPr6BovF0tnZ KVLuySeffNppp65cuUqphY4ijRRCr0h6ihSsPKlU6rXX9r7yyqt9fX2DgwMejyca jU2+L4wYl27hMbi7u7u11VrxW6aNjY2pvEMhgApGAAZQokqd/3yUfD4fCoXEvb7b 7S7+WZNrfRvNZqLvvIlMJV408dHq6uo68cSVb3rTm972trfZ7XYZDRVCbyaTUbx4 lRCv4cjIyJ49e/bu3StSsfg7Eg5H8vlcxecxZYkYXNjSbF4ZT/ylMBj0ZrO5Gkbm mQUNQEGVf9EEIMnKlScuZKLp4iJu9L1en9PpnPORIvrW1zeYTMYKnhyulMJiXZ1O b7e3r1hxwmmnnXrmme9csWKFvBYLobdwOqu8VqpcOp1+7bXX/vSnP7322t7h4WER XTKZDJF4TuIzGQ5HxMezmGUXXV1dbW2t1fOqxmKxffvYCxqAMgjAAEpRkfs/z06k tWAwKOLTLLen3d1dRqOxMo7flEHc4jc1NXd2Ok4++eS3vvWt73znu1pbW2U3KjK2 SLyM9GpIvAVOp/N///d/X3zxhYMHD4pILD4J1RPe5kV8SsPh8CwHJolrb3Nzs8Vi qbbLL3tBA1BKFV09ASiop6fbZrNp3QsNiBvTYDB07FCwCHWTB8MaNelVeSqcFSTu 1JcvX37aaf/n7LPPFrlXnaYLa3pF7iX0lifx7rz44osiEr/22l6nczQej7HJ1uHE dSYcjmQy6aMiX1dXl8Virs7ZJR6PZ3i4xO0YAOBw/GMDoBTHH3/ctAelVoOjhoIn B2R0ZrNJqQ2ZFq/8pNbWtpNOWv33f3/mBz7wgZaWFjU7EJ/ERlaLTi6XGxoa3Lnz l88///zQ0FAhD2vdKe3FYrFIJFr4cVt1DvweTlx1Dx7s17oXACpBlV5GASzQ6tWr xN2YtPJLcrlsmedJEYBDobDopMViruadrkR0MZstK1ee+Pa3v+Occ86RsVvV7FKp VGGGs8rtQp5sNtvX1/fLX+586aWXRkZGxFtctXlY/P0Kh8OpVNpkMsq85Cpgcl39 kro6Wddt8Xd8797XJBUHUFUIwADmTfYC4Ntuu+0973nvHXfc8dOfPiSpCUXk8/kq HI0Rd+T19fW9vUvPOOOM8847b+XKler3QdxqFwZ7RWfUbx0qEwF4z55nn3zyF6+8 8kog4K+tra22v3dlfqkRfx/F1WDt2nNffvnlhx76iaRWWAYMQCnlez0FULa6u7vb 22UtABZ3OS+88GLh1yLe3HHHpgcffLDMR4MrnrjBNRqNq1ef9J73vOfcc881mUzq 90F8MAqhl2W9Va6/v3/79if27HluZGSYzbS0Jf4yvv3t71i7du3UJfraazfIe0fG xz0ln8oOAFMIwADm7XiZC4BPPvkN99xzj8FgmPpOIpHYsOELv/71r7nTVZO4tRXv 8qmnnvbhD3/4ve99r1Y/g0in07FYjBnOmJbP5/3FL5565plnBgb6c7kcPylTTTab Xbly5Sc/+cmGhsbDv//d735naGhIUqMsAwagCAIwgHl74xtPkZdFb7rppre97e0d HR1HfX9gYODyyy93uUbLeSrgYiduag0GwxvecMo555zzwQ9+sL6+XquesJ0V5mts bOzxxx//3e9+NzIyvGSS1j2qTPl83mAwiqvxsQv+xWu+7/XX7/uvLZKaFheol1/+ i6TiAKoH/zwAmLdTT32TpJtLcX+zc+cvxS8aGhqmPSH2oYceuvXWr3JrqyBxO1tb W7ty5cq1a8/98Ic/rOFGO+Ldj8ViIvcWzk8CSpNOp1/bt++x//mfP/3pT9FohJkj ChJ/ScWF4h3veMe0v1tXX9/V1XXBxz8m6TUXV4YXX3xJRmUAVYWbSADz09npOHZ4 VilWq/XHP9469evGxsZjH5NIJK644vLnn3+e6Y4LIW5kxSssbmQ/9alPr1ixQsOe JJNJkXtTqZSGfUDlETE4EAw6nc4/7979u9/9tnCYEBeNkuVyuZ6eniuuuOKoOc9T lixZojMYOuz2z1xxud/vl9SNsbGx0VGXpOIAqgQBGMD8HHfcMnmHu77vfWdt2LCh 8GtxOzXLmTrPPPPM5z//b2wCPF/5fL4w2Hv++edP+/MF1cTjcZF72dEK8ogMHAyF fD6f+KiJa8Xo6OhvfvObV175f+Kzx7DwvIhX78ILLzrllFNmekAh/ba1tlrM5m9+ 85tPP/1LST0JBAL9/QOSigOoEgRgAPOzatVKnU4nqfgdd/zH4fdYoiGz2TzTg1Op 1OWXX/7cc3sY1ZmdCL3idv+00/7PZZdddsYZZ2jbmWg0GptMI9p2A1VCZGDxgRNf x1yuqSXl4kP4+9///o9//GMoFNRwofuiIP6q9vYuveKKK2Z/oQqTn0X6bWho+Mtf /vKFL3xeUn/i8fhrr+2TVBxAlSAAA5gfeTtgTS0APpzdbp99xe/TTz+9YcMXWDV6 LHHn2tyse9vb3nbllVdqclrv4ci90FBhKHjc40nEYod/P5lM7tmz57e//a3HM04S Ppa4Jn/iExe+6U1vmv1hU5OfW/56OsDZZ58l758J9sECsEAEYADz4JggawFwc3Pz o4/+/Khvirsom22OM4cTicRll61/8cUXGQqumRzvFa/ke9/73n/5l38V75a2nSH3 okwUhoJF4nW5XLls9qjfFbFKXECefvppt3uMJFwz+eOz7u7uz3zmMzOt+J1y+OTn hoaGwjfPPXetvKPLXK4x8SZKKg6gGhCAAcxDb29vW9s0mzMrIpfLP/XUU8d+32w2 FzPp+rHHHvvyl79UtRtEi9wrbtz//u/P/NznPrds2TJtOyNCr4i+5F6Um8LOWGNj Y+kZNl3LZDJ//vOff/WrXX6/v2qTcDabPf/8dWvWrCnmwYdPfp765vvf//7aWlmX Yq/XJ++oYQDVoErvFAGUZvny5WazSVJxi8Xyk588NO1vFbnvdDgcvuiiiw4ePFBV MVjcrZ5yyhtF7i3yhlWeeDwucm/2mOE1oHwUpkN7vN54LFYz89IJ8Ul+5pln/vjH PySTyerZMSufz7e2tl1zzTVFbvRw7OTngo99bF0wGJTTx5pQKHzgwAFJxQFUgyq6 RwSwcPIWAAsXXnjRP//zP0/7W42NjVartcg6P/rRD++4446Knw4tcmZ7u/3CCz9x 0UWf1PYPm0qlIpHI1A5DQJkrTIcWn1vX6OicP68ZGRnZvn37vn376usrPAZnMpkP fvCD7373e4p/yrTDv8KDDz4orsNKd/AQlgEDWCACMIBidXZ2dnTMeC7RAuXz+See 2D7LnMPW1taj7rFm4fGMX3DBBR6PR6HelZd8vubd7373DTfcMMsxUSrI5XLhcFje Sj9AqsJ0aLfbnUom53yw+LTv3r37qaeeikTCFTkgrNPpPvvZz82y6/6xZhr+rTmU pT8gbybO2Jh7dHRUUnEAFY8ADKBYS5f2ihQqqfi0W0AfbvZjgae1adPXf/SjH1XM 3aq4BbfZ2tevX//xj39c255EJ7HzNha7IqdDH87lcm3f/sTevXsr5sIirr1vf/vb zz33w/N61rR7Xx1O3kbQgs/nGxxkGTCAEhGAARTrhBNOMBoNkopPuwX0sY+xHDPU MLt9+/Z98pOfTCTiC+ia9sQd6pvf/OaNG2/WdncrkRbC4TBTnVFJ5jUdekomk/n1 r5/ZtWuX+MWiXm2xZEnt1Vdf3dXVNd8nzjT5eYrUjaAjkejrr78uqTiAikcABlAU h6Ojvb1d3k/0r7rq6nPOOWfOh9lsthL68LnPfe7pp3+5GEdsxL31Rz7ykQ0brm1s nOMwEqkikUgsFmPIF5VqXtOhD/fqq68++ugjfr9/0V1eRNpfvfqkSy+9tITnzjL5 ecpjjz32ne/ctYAOzkZ0fnx83OUak1QfQGUjAAMoSnd3lwjAkorncrmnntpZzCNF ICytG3/4wx+uvvqqxXIwj4iaBoPhiis+c+GFF2rYjUwmEwqFGPJFNShhOvQUp9P5 yCMP9/f3L5aTk8SV8NJLP7Vq1aoSnjvn5Ocp73//2fKGx0UAHhlxSioOoLIRgAEU 5bjjlrW0tEgqbrfbf/jDHxX5YL1ebzKVchSTiHOXXXbZnj3PlvOUxcljSFpvuOHG s846S8NuxGKxSCTCkC+qyqHp0MnkqMuVm/9pXn6//5FHHnn11VfKOQaLv9Td3d1X XnlVyUPWc05+nnLRRRe63e7SWplTIBDo7x+QVBxAZSMAAyjKqlWrdLpmScU//OGP XH755cU/vrSJ0MK99957553fLM/JiuLGVPy5vvrVW8844wwNuxEMBtnYGdWsMB16 bGwsnUqV8PRoNPrwww+/9NKLZRuDe3uXXnTRRUajsYTnFjP5ecr3vve9Rx55uIRW ihGPJ1577TVJxQFUNgIwgLk5HI6ODrukMy1yudzWrVtbW9uKf0ppE6G/+tWvPPTQ Q2U4/FsO0ZfZzsCUQ9OhPZ6J6dAliUQiDz+87eWXXy7PGCwuOBdffElb2zyuujXz mfxc4PN5P/7xj0u65IrL5tiY2+VyySgOoLIRgAHMrbe3Z763SsUTt0fbt++Y77N0 Ot28jqzcuPGmRx99VN65lKUR93BGo+lrX/vamWeeqVUfEolEOBxeLKujAXUUpkMn k0nX6GjJfztCodDWrT/u6+srwxhstVovvfRSm20eP0ksfvLzlA984B/lXVu8Xu/Q 0LCk4gAqWHndCwIoTytWLC9t2W0xTjjhhLvu+k4JTyx+InR5pl/R+Wuv/eK6deu0 6gALfYHZFaZDu1yuzAImR4in//d/Pyi+ltviC5GBP/WpTxf5w815TX6ecvXVV8k7 rygcDu/ff0BScQAVrLxuBwGUIdkHIH3mM1euXbu2hCeKGzK73T7nw66//rodO3aU VfrN5XIXXPBP1113nVYdELk3Go1q1TqwiBSmQ7vd7uTC1sbv3bt369at8XisrFZh WCwtl1566ZwX0vlOfp7y85///O67v7uwPs6Iw5AAlKaM7ggBlKeuri67XdYBSJlM ZseOJ+d1R3W4pqam2femvu66Lz755JPlk37FHdtb3nLGt771Lb1er0kHQqFQPB7X pGlgkSpkYO/kCUkLnDHxzDPPPPlkef08TlxCL7lkjgxcwuTnAvHS/eM//oO8GeBu 97jTyWFIAOanjC7BAMqT1AOQmpt1jz766EIqWK3WxsbGaX+r3NKv0Wi6++67Tznl FE1aZ3tnoGSHTkhKpUZHR0s4IelwyWTygQd+tHfv3vJZGGyxtHz605+aaT1waZOf p5x77rmJhKwfunEYEoASlMt9IYCyJfUApLe+9W0bN25cYJGOjo5jv/m1r33tJz/Z WibpN5fLXXbZ5VdddZUmrRN9AUUcOiHJ5Vr4fun79+9/4IEHYrFomcyIbm+3X3LJ JVar9ajvlzz5eYq4wv/xj39Qoo/T4DAkACUoi1tDAGVr4vyjjg55MXLz5m+cfPLJ CywibstaW1sP/8599913553fLIc7SxF93/CGU773ve/J20VsFkRfQFmF6dDj4+MJ JZYS7Nix41e/+lVdnfZXqpqJyT7HfeITFxoMhsO/WfLk5ymvvPLKv/3b55To4DQm D0MaYxkwgHkhAAOYTW9vb1tb69yPK0kul3/qqacUKWU0Gqfu2x577LEbb7yhTDZc vf32r7///e9Xv91wOBwr9QhTALM4tCTY54tHowvfRN3v92/Zco/H4ymHS9bJJ79h 3bp1TU1Nhf9c4OTnKeIaWFsr64bT6/UNDQ1JKg6gIhGAAczmhBNWiGwpqXhnZ+f3 v/8Dpaq1t7fX1tb+4Q9/uOyy9Zovrsvlcqeeeuo992xpbpY1e3wm0Wg0Eomo3ChQ VQ4tCU4mRxdwSvDhnnrqqV/+8peaDwWLPL9mzVvOPfdckcYXPvl5yiWXXCxeKKU6 eRRxuXv99f2SigOoSARgADOSfQDSxz9+wcUXX6xUNXG75vf71607vxxmPmsy8BuL xcLhsMqNAlXr0CnBo6OZTGbh1cTl65577vF6NR4Kzmaz73vfWf/wD/+gVPoVfvCD H2zd+mNFuncsDkMCMF8EYAAz6u7ubm+3SSqey+W2bXtYwZWxIvudf/5HlapWmnw+ v3r16h/84H6VB35TqVQgEFj4bEwA81LIwG63O5VMKlLwiSeeeOaZX2k7h0Xk+XXr PvaR885TJP3WTF6czzvvI/J+NDk+7hkZGZFUHEDlIQADmNHxxx9vsZglFRf3VY89 9rhS1UScFuk3Go0qVbAE4q7xqquuvuKKK9RsVPzB/X6/IgNQAEqg7LZYNZMbRH// +9/PZNIabmKfz+dvuPFL73rnO5UqeM45/9/Ct86eSTAYOnjwoKTiACoPARjA9GTP f/67v/u7W2/9mlLVrrnm6r6+PqWqlaC+vuGBBx5YtWqVmo0GAoGkQuNOAEqm7LZY NZPTeu+669vDw8MaDgWbTObbb799+fLlilS74Ybrn3vuOUVKHUu8/l6vl1nQAIpE AAYwva6uLru9XV792267/bTTTlOklLhTfOyxx7QaLRH3uyef/IYf/vCHat6qstMV UFYU3xarpgymQ5944ok333xza2vbwku98MIL1133xYXXmYnbPe50OuXVB1BJCMAA pnfccctaWlokFVfwAKSdO3d+/eu3a7VtTCaTveyyy6655hrVWhT32X6/n+W+QBma +OsZCLhGR7PZrCIF+/r6fvCD7yuVqEvw3ve+95pr/kWn0y281Pvff7a8ZcCBQKC/ f0BScQAVhgAMYHonnbR66jRIxXV399x7770LrzM8PHzxxZ/UaoRE3JXeddd3zjzz TNVa9Pl88tbRAVi4Q1tDu1wZhf6qhkKhO++8MxIJa7K/vbjKffrT69etW7fwUhdf fLHLJeswpGQy+eqreyUVB1BhCMAAptHZ6ejo6JBX/5JLLv3Yxz62wCLizmzt2g9p FQibmpoeffTnDodDneYikYi2W3wBKNKhraHHxlKplFI1v/Odu/r7+zX5YZ+40t56 69dOP/30Bdb5wf0/2PpjWYchCWNjY6OjLnn1AVQMAjCAaSxbttRqtUoqnslknnhi +8KHlz/72X/du1ebH/kfd9zxP/nJTxobG1VoS7xcfr9fwzmQAOarsC2W2+1OJhJK 1dy27Wd//OMfNcnA4p+D2267bdmy4xZSZMzt/ud/ukBe/8V1cmBgUFJxAJWEAAxg GqtXr5J3kq3BYNi27eEFFtm69cff//731d/4Kp/Pv/3t7/jud7+rTnPs8wwsUoof jyQ888yvtm/frsmWB295y1s2bLh2ISe3B4LBCy/8RFq5UfGjJBKJvXtfk1QcQCUh AAM4muz5z2efffbnP/+FhVQ4cODA5Zdfpv5dYC6X++hHz//yl7+sQlsi94r0q0JD ACQpZGCP1xtXbv3C888//+Mf/7iuTu31wOLqd8kll15wwQUlVxAB+Pbbbnv+eVmH IdUwCxpAcQjAAI4mdf6zuIt64IEH7XZ7yRUymczatWuz2YyCvSpGNpu95pp/Wb9+ vQpt+f1+BVcPAtDKoSOCvd6Ychn4wIEDW7bco1S14i1wMbAIwK/u3XvTl78kbzcv ZkEDKAYBGMDRpM5/rq+vf/zxJxZSYcOGDS+//JJS/SmSSL9f/eqt55xzjuyGEolE MBiU3QoA1RzKwD7fRAZW6AAzt9v97W9/K5NR++eANlv7bbfd1tPTU8JzC6/DJ/75 nxTv1RRmQQMoBgEYwBE6Ozs7Okofnp3T6aef/pWvfLXkp//2t7+95ZZ/V/k4EJF+ N23a9H//7z/IbohTjoCKVMh+vskMrNQh3qLa5s2b1Z8L88EPfvCKKz7T0NBQwnMD weCXbrzx9df7FO/VlLEx9+iorMOWAFQGAjCAIyxbtsxqbZFUXNz53Xnnt1avXl3a 05PJ5Ic+dI7KG1+pk35TqZTf75faBAANiQwcjcXERWzU6VQ2A2cyaTWviplM5pZb bnnb295ewnNFAP7tb39717e/Ja/Dfn9gYGBAUnEAlYEADOBvHI6O9vZ2eZtLiZue HTueLPnpV1111f79ryvYnzmJ9Pvtb9/1rne9S2orwWAwodxZKQDKlojBPr9fwQwc CoU2bfq6KKtmBrZYLJs23bF06dL5PlEE4MHBwc//2+fk/SuTSqV8Pp/LNSapPoAK QAAG8Dfd3V0iAMur/8Y3vlHcNpX23Cef3PGNb3xD5YGOu+76jtT0m8vlPB6PUrfC AMpfIQM7nU6l1gOLDPz1r39d5bnQ73vfWVdffbVOp5vXswoB+Bub/0PqLOXx8fGR Eae8+gAWOwIwgL9Zvvx4s9ksr/43vvHNk046qYQnxuPxtWs/pObS32w2e8stX1m7 dq28JqLRaCQSkVcfQHkSOdDtdkeV++s/NjZ2553fVPNHaZlM5qabNp555pnzelYh AL/4wgsPPviApI7VTP5E4MCBg/LqA1jsCMAADrHb2zs6OuTNTBM3Z8899/z4+HgJ z/3sZ/917969indpJrlc7uqrr5F64hH7XQFV62/7QiuXgffv33/PPd9T86eEra2t X//6pv+fvfMAi+ro+jjSmyhtpSigWIg9iSVETUSjaMTeYsXejS12BUQUFEGUXkRQ LNhA1Bi7BnsXe0FFadJZYAvsLt9hNx8PL3XZvXfu3bvze94nr65355zdnTtz/nfO nGlURWiJABYKBGvWrCZvrhEKhd++fcvKkmWuwWAwygAWwBgM5j8gjjExMSav/U6d OkVFRefm5jb2jY8ePVq/fh2ywA6E+vjx4zdu3ERS+wKBANQvTnvGYJQZMs4Hfvz4 8ZEjR9TVyRKWNRk3bvzMmTOll7KVAnjPHr/MzEzyHMvJyU1NTSWvfQwGo9BgAYzB YP6jXbu2enp65LUfEBDYs2dPGWodOzkNQ3ncZd++ff39A0hqHKc9YzAYCRINnJOT w+VwiGrz6tWr58//ra6uTlSD9SMSiXx8fLp06Srl9ZUC+PXr1wcORJPnGIy0798j rZiIwWAUCCyAMRhMBWZmLQAyS0w1efLkCZfLZbPZjXqbt7f3lSuXSfKpJi1btjxz 5ixJjYP4Ly0tJalxDAajcEg0cHZ2No/LJarNQ4dinj59ikwDt2vXbssWdyMjI2ku rhTA8Oc1a9aoqZGV11NeXv7t2zdcCxqDwdQKFsAYDKYCGxvr5s3JOv4X6N69+/79 UY1d/8zIyJg2bSqySE5TUysxMVFTU5OMxiHGFYlEZLSMwWAUF4kGBrVWyucT1ebu 3bszMtLJ22RbFRjW/vxzmZOTkzQXVxXAAQH+aWlp5DlWUFDw+TM+EBiDwdQCFsAY DKZi+dfExIQ8nVleXr5vX+SPP/5YVFTEaUyyn7PzdIgLSfKqGhDGXbhw0czMjPCW S0tLZUj8xmAwSgJoYFCG3zIzCSyMt3Wre0lJCZpz43R0dHbv9rOxsWnwyqoCODk5 OTw8jDwPBQJBTk4OXgTGYDA1wQIYg8GQXv4KQpzHj5+oiB/J86Ve5bhz546bmyua AE4oFIaGhtnb2xPeMt70i8FgGkSigTPS02EsIqRBGHm2bfNAVmxv9Ogxc+bMaXDN uaoAVqnIgiaxFrQKLoWFwWDqAAtgDAaj0r59O11dXfLa//nnPoGBgSqNPPtnxIgR paWE5QTWA8SIs2bN/vPPPwlvuVGCH4PBKDMwNuYXFKSnp5cTtFfi1atXUVFR5O2z rQqMonv27LGza+CY92oCODw87OPHj+R5xeFw3r17T177GAxGQcECGINRdszNzVks U/IWWkUiUXz86datW6s0Zh/swYMHDx2KIcmlatja2p44cZLwZnNzc1EWr8ZgMIoO aOC8/Px04nbGxsbGPnr0EM1m4N69f1q7do2ubn1HCVRkemdlcUtKJEvT37598/X1 Ie+IO7CSlZWdkZFBUvsYDEZBwQIYg1F22rRpbWBgQF77urq6t27dlvxZyg29EAUO G/Y7moN/ITS8ffsO4YWvcMkrDAYjAyARM7994xJ3OLC3904YjhBoYKFQ6OW148cf f6znGknFr/T09MpF4I0bN4pExGR91wqbzf748RN57WMwGEUEC2AMRqkxM2vBYrFI lZoTJ/6xbt06yZ+lFMBubm53794hz6VKIGI7ejS2Y8eOBLZZXl4O4SayrXcYDIZJ SCRiVlYWn8cjpEGBQODq6kqqyKzE2tpm27ZtJiYm9VxTLQv61KlTDx7cJ88lkUgE XyYuhYXBYKqCBTAGo9SQffoRKMw7d+7q6f2XFCeNAC4uLh49ehSC9Qoytv5CrJmb m0tggxgMRtmQFMTKzMwUEFQU+uXLF9HR0WgWgV1cXPv161fPNdUEMI/Hc3HZTKpv +DwkDAZTDSyAMRjlRXz6kam6OomRh7m5xd9//135V2kE8Lp1a58+fUqeS5WwWC0u XLhAYIP4uCMMBkMIEg2cnpZG1E6KyMjI169fIThT3cLC0svLi8Vi1XVBNQEMbNu2 rbi4iDyXBAJhTk42XgTGYDCVYAGMwSgvVlZWRkaGpJrYuHHTuHHjJH+GSC47O7v+ 69ls9pgxoxFEaeDMlStX60/VaxR8Pr+goICo1jAYjJJDeEEsV1dXPp9H9sFyMLTC sP/rr7/WdUFNAXz79u0zZxJI9SovLx+MkmoCg8EoEFgAYzBKCovFatGCRWriWXm5 StW13Ip4Li+v/resXLny1auX5Lkkoby8fNWqVdOmTSeqQR6PV1hYSFRrGAwGoyLW ihkZGTwul5DWPn78GBISjCARGiYXb+9dLVq0qPVfawpgYPXq1aTmIgmFwm/fsgDy TGAwGAUCC2AMRkmxtrYyNCR3+dfBYYCvr2/lXxtUiXl5uRMnTkQQn9nYtI6LiyOq Nax+MRgMGUgKYmVmZpaVlhLSYExMzLNnT8lOsSkvL1+zZu3AgQNr/ddaBfD+/fvf vXtLqlf5+fkpKXgRGIPBVIAFMAajjJiZtTA1NSVVagqFwuvXbxgZGVW+UlxcXFLv 2R5Lliz+8OEDeS5JEIlEN278S1TpL5z5jMFgyIPwzcCuri4wapGdCG1kZOzj42Nu bl7zn2oVwDA7uLtvIXtKys7GO4ExGEwFWABjMMqItbW1oSGJxZ9VapS/AgoLC3l1 H+wBMnL8+HEIln9nzpxFVOVnXPUKg8GQDSjGrKyskuJiQlp78eJFdHQUgkXgDRs2 1roTuFYBrFJRCsujmKDPWBf5+QUpKbgcNAaDwQIYg1E+ECz/At7eu3777beqr+Tm 5gpqBD2VrF+/7smTJ6S6BDRt2vTffxMJaQqfeITBYBBA+MnAgYEBnz9/JlsDW1q2 3Llzp7GxcbXXQQB/y8rilpRUOyz92bNnR48eIdUlvAiMwWAkYAGMwSgdrVvbNGvW jFQToK4fPnxU7UUI4KpFPJVwudzhw53IDsgg+jl27Jid3XfyNwUfBNdTwWAwaJAk QmdkZNRcOJUBGAk3bdoofzsNWvH09OrRo0e11yV6PiM9vebz0HXr1pKdm11YWPjp 02dSTWAwGPqDBTCmAjOzFqBYVCuA/8IEpFr533IxItF//y8Uiv4fIX6MqohYWJib mpqSHWSMHTtu06ZN1V6s5xBgT0/PGzeuk+oSYG9vHxQUTEhT9Yh5DAaDIRzQjfkF BWlpaSpEjDznzp27fv0a2c8c27fvsHXr1prPW+vKgj5+/Pjjx9WfnBILjNvZ2dnp 6RmkWsGQAUSq4hhVHKqqQZAqiVObSBCHqaLK/0KMWhGnCnGkiqkdLICVFPE4ogqT n6ampra2tmyzIIwspaWlMCsLBAL4M/w/XhOjOfC7GxgY6OrqkmoFZp0HDx5C16r2 el0CGK4fMmQITGNke3Xv3n3o7fI3BfETUQVpMBgMRkpAN2ZmZnI5HEJa27JlC5fL IfVhKMQGfn57OnfuXO31ugQwXL9+/TqyZTmHw2FX1NbGuojWsFgsDQ11NTU16A8a GhoQUci2bws6FY/Hg2AV/gATN/7dMRKwAFYuxCu96lpamnp6eoRvAS0vL+fz+WJJ DONMGfwVDzR0o1WrljV3ZBHOzz/3CQwMrPl6XQI4NDQ0Lu4UyU6pzJgxc9myZfK3 k5eXV1ZWJn87GAwG0yjqSR6WgaSkpIMHD5CtNnv06LFu3Xp9ff2qL9YlgIHw8LCP Hz+S6pKKuCDF16+pZFvBNAoIUJs0aSJWuxVrM1paWoQ/nREKhSUlJRCoCoUCHKAq OVgAKwsWFuYwmsAkhKDKrgQYaLhcLshh8VM3nIVCPWhqX9U8/UhCPSWjnJyGERLP 1QNMpvfu3ZO/naKiIg5Byy8YDAbTWIhNhN61yzsrK4vUSaG8vDwwMLBt23ZVX6xH ACM4D0kFV8OiDZKsZnE2ooaOjg7KABV6Gp/Px8nwSgsWwAwHBhcYWXTFUOiGQCDk 8SRiuAynoFCFrW2bpk2bkm2lQ4cOR4/G1nydx+MVFhbWfP3Ondtubm6kpuFBBLZz p/fgwYPlbAcfeoTBYChHUg2Lx+XK31Rubu6OHV5kq44JEyY6OztXtVKPAAZ8fX1A nZLqkor4aWZyMulLzZia/P8WPA0QvdraOurqiERvrXDECAR4QVjpwAKYsYilr4a+ vh4hmx4JRCgUcjjcsrKKzcMZGZlUu6MstGzZ0sSE9ORnkUh08uSptm3b1vyn4uLi kpKSmq9PmzaV7FjH2Nj48uUr8rdTTxEvDAaDQQOxFaFDQoI/fvxIqgbW0dH19/eH OajylfoFMHw0P7/doJHIc0lCTk5uaipOhEaEubmZRgWaurroVnqlhMfjQYQiEJRh Gaw8YAHMQED6whijr6+vpaVFtS8NIN6PwZGIYTzukAd0CRMTUwTPWVmsFhcuXKj1 n/Lz80tLS6u9mJOTM2nSH6TOhaDJ9+/f/8MPP8rZTv2HGGMwGAwyKhKh8/MrEqHl hsvlurm5kq02165d5+DgUPnX+gUwsHXrVg6nlgemxCIQCHNycCI0iUjCURC9enq6 dBO9NeHz+cXFxTgcVRKwAGYalpYWRkZG9B9oqiEpoAXA0FNaWoarSROIuPJzM11d HbINgdSMiNjXs2fPWv+11srJ69eve/LkCalemZmZnz9/Xs5G6lq+xmAwGEoADZme ns7n8eRvKiIi/N27d6SGDS1btty507uyNgQ4/y0ri1tSUtdhcu/fvwevECwCczhc NrsQCx4CYbFYmpoVqldLDNlnLhKOUCjMy8tLS0un2hEMuShYv8TUg5mZmb6+XrVa i4oIyCQejycWw7h6FgG0bm1T8xhGMmjRwuyff/6p619r5g+LTz9yJDXEARNHjhzt 2LGjPI1AiIafyGAwGFohSYROT0uT/0g2gUCwceMGUodiEBV79uytHIol5axBwFO+ CAwUFhZ++vQZgSEGI6llpaGhDopXW1sbwZMLsimuoCQzE2/TYyxYADMBGHpg0AGR w4BBpxriDcMcyWnDWAnLQKtWrYyNqxdkJoMGpWZNAXzixPGIiAhSvbKysjp9OkHO RnJycqAfEuIPBoPBEEXFOuq3bxwiklOioqJevXpJ6iLwwIG/LV26tLIoSYNZ0F+/ fg0I8EcT1eTm5oE5BIYYhiTDWVNTU1dXATKcGwtENYWFhXw+HwefjAQLYIXHwsLC wKAp3SpdEY4kR5rHq8iRLisrzcoivUQkA2jZ0tLY2BhNApK1tXV8/Om6/hUEJMjI ai9OmDCBza6lLjRRELL8W1JSUlxcTJRLGAwGQxT/HQuckSGQ+2RyBIvAoJQCA4Os rKwkf21QAAM7dngVFBSQ51IlEGDk5uamphKwp5rxsFimoHnh19TWVsgM58bC4/HY 7KL0dJwRzTQY3nGZjZlZCx0dXVC/jB+AqgHChsvlSjYM4zrSdWFpaQHqF83jc9C3 cXHxtra2dV1Q8wwkBOWvTE1NL168JGcjuPIzBoOhLf8dC0xEKeOQkODk5GR1dXX5 m6qLdevW9e//XyksaQRwZmamr68PmqVFiCtAA+Odn3UhqeEMildHR4d5yYb1U15e DhqYy+XgpWAmoVzCiUkoaLErwhHXkS4pLS3Fx7hVBXH3aNeu3bFjx+u5oKioiMPh VH3F1dX13r275LkEM1ZgYFCfPn3kaaTWytUYDAZDH4iqhsVmsz08PNTUSNQ2bdrY enp6SmpSSCOAAR+fXTWzh0gCVz+qhvg0TXVNTU09PT0cbeLuwTCwAFY8WCxTGIwM DAyUbeG3fkDwiEQiEMN8Ph/GKWUWw5aWlkZGhsimK/i2//77fNUzHmtS8wyhIUMc SfVKX79pYmKiPC3UmraNwWAwtEJSDSstNbWuisrSs3v37oyMdPLmDhhUg4OD27Zt pyJFIWgJMHfs2OGFcjrLyyPmfCkFBUQvfNtaWloQZ6qqquI4syripWA2xJl4Fx4D wD1bwbCwMG/WrBn9D/ilFhikYBqTpEkr28qwlVUrQ0NDlJNWnz59AgIC67+mWiLx jRs3PD23k+mUiouL6+jRo+VpAde+wmAwCgGIyczMTO7/ZtnIQGpq6p49fqRmQU+Y MNHZ2RkkljSFoCWEh4d//JhMnkvVgPghPz//yxclqoklWemVpDfDT4NFb/1AYFlY kXaRQbUjGLnAvVxhgBFKU1OzefPmyrb7Qk4kK8McDqesTCAUChi8OMxisfT19Q0M mqI0Ct/tgwcPoWfWf1k1ATx//ryUlBTyvGrSRPXx48fytADBWV5eHlH+YDAYDHlI FoEzQEzK/cxu2zYPNptNXphhaGjo7x9gYmKiInUWtEAgWL9+HamyvCZsdlFxcTFT D8CTLPOqqalraKjr6urild7GApFPQUFBaWkpU+NJZQD3eMXAzMysaVN9PT09qh1R eEAPl4qBiEEohhnjl4WFRbNmBuhTAxYuXDRv3rz6r4HwJTc3t/KvMHM4Og4mNaVt 5MiRbm5b5GkhOztb/tM1MRgMBg0gJkGtlchdsj4xMTEh4TR5ahOmg4CAADu771Sk FsDAxYsXr127SpJLdSFe6GMzo/zv/yteNcmpRQBWvPJTUlJSVFSMzwpWUPANoABY WloYGhoifvypJDBAD5uZmenq6jRtSkEx8GbNml2/fqPByzgcTlFRUeVf4+PjQ0KC yfMKfsS7d+/p6urK3AJe/sVgMIoFgUcibdiwobycxMd/Q4f+vnDhQtBg0gtglYq6 iS7oSxJChCCu4MhVOJGDFS8aBAJBfn4+royliOD7gdbAEKatrQ0yA49caJDkS3O5 XAgmBBXp0rTePyzuHiB99Skpzwjfz4kTJzp06NDglQUFBXw+v/Kv06dPIzWvzM7u uyNHjsjTAt79i8FgFI6KI5HyCSjgdOTI4cePH5P3zF1PTy8kJNTU1LRRAhg+l5+f n7o6BZMdTAdFRcU8Hpfm8YCaGvxoFYpXclIRjhvRAHFjYWEhj8ejc/fA1ATfHvQF hjMDAwN5FrIw8iMQCMTrw/D/ApGIFkvEknlOW/u/Io1UufHrr7/6+e2R5kqQu5V1 PiFEGzp0CHmhFRg6evSoJL9ONnDxZwwGo6CApExNTS2Tb6UUxsD169eR91xVJBL5 +u7u3LmzlIWgK4mM3Pf+/XuSvGoQyTETPB6fDk/GJQu8qqoVkldDo+KkIpwkSC0c DofNZlPeMTDSgwUwTUF8kg1GSiRLxHw+//9LalVoYtDGCCSTuE6jhvhEPl3KO4aG hubdu3ellN9VK2AdOHDg8OFDpPmloqure+vWbXlawGf/YjAYBaViEbigIC01Vc52 fHx2wbhN3kTzyy+/rly5EtqXshC0BJh8N2zYQPm6Jkz6JSUcmCYEgjIEgsfExKRi YbcCVUnZKi0tLbzAS0PwGVqKBb5/aAdOe1Y4JKcuiafDiiVikQj+J1HK5Twet6Cg UIY2jY2NQOuqqkr28KjTag8PfMaoqKgffvhRmourVcCaPHlyXl5uPdfLybRp0yGu kqeFagWrMRgMRoEoqDigJZ3P48nTyKNHj44cOayhoUGUV9XQ1tYJDQ1t0aJFo7Kg geTk5NDQEMofAUuoUkNEIJn64c+5ubLUj2jevBl8J2JVW6FtJVM/yF6Y9/G5RAoE TodWIPBNRS9MTU0MDQ1x2jNjkOjgsrIyyR/Ewri81voiTcSoVgBzngadn+8OGDDQ x8dHyotLSkqK/78wKYjhIUMcycvUghDk4cNHDZ7JVA9VvcVgMBiFQ3IkUlpqqpR5 xXWxYcN6OVuoB5gL/fz2dOzYsbECGIiKinr79g1JjsmJZKIHRSx+Dv7ffF/zMpjq xdN9E8lEr6FB6xkf01g4HE5+fn52Nt5LRWvw/UYvzMxaNG/eXFtbm2pHMJja0dPT v3nzpvTX5+Xllf1/VdJjx45FRu4jx68K2rZte/z4CXlaqLpduVGAtr9z5w58M8nJ HwoKCrhcLqhxiGlA7evq6pqZmYFvv/32mzybkzEYDJN48+b15cuXP3z4kJmZCRGz uMyESE1NTUdHB8IAW9u2ffv2tbe3l+GJISGLwAcPHnz+PIm8tdbBgx0XLVrE4/Mb K4CBTZs2CYWNewsGgwwejwdhAF4EpjlYANOI5s2bATDz4QeBGHoC8dnZs2dbtbKS /i1VM4qdnaeTl2AMwjU4OATiRZlbkKH8FVwfHh7+4MF9NpstTZwKJuDbmzJlysCB A2V1E6PYcLlc+C+IHKodwVDDlStXDh069PXrF2m0JahiAwODnj17zZ0718TEREoT hCwCw5jm4bGVPAGsr68PI7aGpmaj6mBJyMnJ3rlzJ00SoTGYakBnBgFcWFgo2w44 DBqw0KIRxsZGMMPhwAhDT2BMX7Vq1bRp0xv1rkrFC+LZ0XEweSFLkyaqjx8/lqcF ydYdKS++d+9eQIB/ZmamzJ9o8GDHP//8E5fuZDbQ7a9du3bp0sXk5GQ2u0goFEh+ cRA2amrqBgZNbW1tBw0a7ODgQGFFdwwC4Bffu3fvxYsXZHu7UCg0MzNbsmRp7969 pbmekEXgrVu3FhcXkdQz4RP5+wdA/29UHaxKrl+/9s8//+DVAgw94XK5OTk5sm0I x6ABjx30wtzcDDQwfq6JoSH29vZBQcGNegvMAWw2W/LnM2fOBAYGkODXf/z8c5/A wEB5WpBydRr0zO7du/l8nvyxF6ijCRMmzpkzR852MHQDftnjx4+fPn06K+ubNM84 QB2xWC1Gjhw5fvx4rISZR0RExLFjsfL/suXl5Vpa2itWrHBwcKj/SkIWgc+ePXPj xg3yHtKNGDFizpy5HC5XhixoICws9NOnT2Q4hsHIgySbLCMjk2pHMPWBBTDtaNWq pbGxMdVeYDD/g6Gh4dWr1xr7rqobgBcuXPjp00ei/foPCPJOnjxla2srcwvVqlXX yrt371xcNufn5xO77AARrbe3d/v27QlsE0MVXC7Xz8/v2rWrsqkdUM4ODgOWL1+O U4GYAQwaq1ev5vPlWomtBgx3MCC7u2+tf9AgZBF4zZrV5D2RNzEx3bt3r6qammwC GHBzc+Xz+YQ7hsHIA8QSX7/KexQZhmywAKYjbdq0NjAwoNoLDOY/IJS/cuVq8+bN G/vGqmuqjo6DyUtX09LSunv3njwtsNlsyebMWgEZv3nzpkePHpEUC4L8HjVq9JIl S8hoHIMG+BG9vLxu3LgufycRCoW//tp/3bp1OENeoQkICIiPjyPpR4RO8uOPP27d 6lHXYUWELALv2LEjNzeHvHEvImJfc0NDGbYBSygpKXF334KTJjD0AWKJjx9xYoIC gAUwHWGxWMbGRhDTU+0IBlOxJHXy5Km2bds29o1Va0p9/Phx4cIF5AngYcOcPDw8 5GmhnvrPV65c2blzB9mbzcC6lZVVcHAI1jyKSGxs7L59+1RViewkIlH57NmzJ06c SGCbGDSAtIMR78uXLwjGjTVr1tZVVE/+ReDr16+dO3eOvEFpxYqVAwYMkG0bsISM jAxfXx88bGLoAJ/Pz83Ng3CCakcwDYMFME2xsDA3MTHBzzUx1AJhnL9/QP/+/WV4 b3FxcUlJieTPoE5v3kwk0rMqgES/dOkyi8WSuQUIImudscrKytasWf3y5Utkd6Km plZUVJSRkREacxj5KSgoWLp0CfQfMqQO9Ezo2HAPypB/gaGKvLy8GTNmlJYiSs2F AbBTp047d3rXXAqWLAKnpqaqyLEIvHbtGvIGwI4dO7q7bxUIhTJnQQMvXryIjo7C GhhDLXAn5uTkpKdnUO0IRiqwAKYvrVq1MjbGcTCGMoRC4fr1GyZNmiTb27Ozs2E+ kPx59OjRXC6HONf+By0t7bt378rTAofDKSoqqvbi06dP169fJ0/2oMxEROxr2bIl eruYxnLmzJm9e/eQXbYQ7sQ//1w2fPhwUq1gCAHU5pw5s9HbbdKkiaenV/fu3au9 Lv8i8M6dO3Nysknq5KqqapGRkdo6OjJnQUtITEw8cyYBFxDFUEhubt7Xr1+p9gIj LVgA0xpb2zZNmzal2guMMgLadfHiJfPmzZO5hcoNwHw+38lpGHmhyW+/DfL29pan hdzcXMH/Lj7s3Lnj0qVLVIVT8OWDBrayasR5yxj0bNq08f79+2iyA6BL9OrVy8Nj GwJbGJn58uULqF+qUreEQuGgQYPWrFlb9cWKReCCgopFYFm5ePHi5ctkDYageH18 fDt06CBPFrQE8PPKlcs4bw5DCUVFRcnJZJX5xJABFsC0xsyshampKX6oiUEMRNvO zjNWrlwpcwtV11RPnToVFhZKkGvVgfjp9OkEa2treRqpWqwrJydnwYL5xcXFcrsm F/ATREcfMDc3p9YNTK1A3541a2bNrAGyadq0aWTkfvxUlJ5kZGQ4O0+nXIDp6+uH hISamJhUvlJRCistrVSOasmrV69WVycrDhk2bNj8+QtkPgypKgkJCbdu3aT8J8Ao G0KhMDs7OzNTqpMUMTQBC2C6Y2FhYWJijAd0DDJgKF+0aPGCBQvkaaRq/vOiRYs+ fkwmwrVa0NDQuH//gTwtgJ/greTPZ8+e3bPHjzaPnJocO3YMF4SnGykpn+HuoCQ3 XkWc6RoSEmJtbUOJdUxdsNnsCRMmqKhQ0yuqAWP4smXLnZycJH8tKyvLLyhIk2MR eNs2D/iAJMUhpqame/ZUHIYkZxa0hAsXLly5cpk2YziG+Yi3/uamp6dT7QimcWAB rABYWVkZGRlS7QVGKYDIafXq1dOmTZeznaprqkOGDCEvLrS3/zkoKEieFiSL1RAj rlq16u3bN2RXbW0UWlpaJ06crOuYEwx6Hjy4v379emrL7QgEAk9Pz549e1HoA6Yq MHqMGzeWVgfSgozs0MHOx8dHMnpISmGVlZbK1lpCwunExESSur1IVL5//34WiyV/ FrSE69ev/f3331gDY9CQl5f/5csXqr3ANBoahXqYujAza6Gv31RfX49qRzAMB9Sv t7e3o+MQOdupmv+ck5MzZcpk8lRlWFh4z5495WkhLy/v8eNHa9eurVyyphXm5ub7 90dR7QWmgitXrnh6bqdDsVnQwOvXb6jr8BsMYmbOnJGRQcfSr6qqqjt27OjSpStI 9Lz8/PS0NNnaKS4udnffQp6kdHV1s7e3B5Uufxa0hCdPnhw+fIgOtyqG2RQXlxQX F+HkZ0UEC2DFgBmbgStTm2i1yIaRAKHSkSNH27dvL39TVfOfg4ODTp8+LX+btQJW nj1LkrORZcuWXbt2lc43V58+fTdv3ky1F8pOfHx8QIA/fUJq0MBLliwdNWoU1Y4o O1u3br116ybVXtSJUCh0cBiwYcMGkJdfv34VlJXJ1g4MQWVlpSTN3T/9ZL927Vp+ aSkhWdAS0tPT9+zxw9vHaAhjQkG89VehUezOp1RYWlqYmJgo+nihIh4y4FPACNjk /6HaI4yKkZFxXFwcIdtNq26pBaZNm1r1r8RiY9Ma3Jb57R8+fJg5cwbl9a4aBG6W 3r1/cnd3p9oR5eXkyRMhISF0e0oCY+mCBQvGjh1HtSPKi4uLy717d+k/i+no6Gxx 36qlrc2RdbiLjIx88+Y1SbeAnp5eWFg4TEBEZUFL4HA43t47eXIcAYUhivIqwP1C t7FUBuCD5OTkpKXhrb+KCt1HbUxVrK2tDQ2bU+0FMUDoZm5ubmdn9/LlS8mCoWRA pH8kwTDgmx882FHOY4SqUlhYWDXgGDx4sKoqWb/p0qV/zpo1S7b3btmyBVSNokzD 8DOdO/c33gxMCTQrjfY/VCt3hEFJWVnZsGG/K8oaI3SV/v0dhg8fDn+Q4e2vX7/e ty+CpCEIXAoPj7CxsSEwC7qS6OjoV69eKsrPxBgky7ySzqavr9+yZcv09PSioiJ6 DqQykJ9fkJKSQrUXGNnBYkORMDNrATBJIkJY37p1m6NHj/L5/E+fPj569Pj+/Xsw 0RYUFMB0xaRPSk9gitq+3fP3338nsM2q5a8glJk7dw5Jv6NAIHzw4IG2tnZj3/jh w4cZM2aUlNB94bcavXr1cnffSrUXSsc//5z38fGhc9AGIeaqVauGDBlKtSNKh4vL 5vv371PtReNQV9dYtGiRbOerrVu3lrxJed26daDPQQATmAVdyaNHj2Jjj9L5LmYG 8KsJBAIdHV1LS4u2bdvZ2raBkFVDQ8PHxzc/P49JzyDgk0Kog5OfFRosMBQMS0tL U1OThq9TKEAGm5qaxsYeMzY2rnyxqKjo3r17t27devHi+devqRxOCZbEBALDd/v2 7ffvj9LTI7K4GpfLZbPZlX/199977tw5Atuviq6u7q1btxv7LhcXl/j4OEWMhEDn REVFwwhAtSNKxJ07d0Dk0L+3QN9wd99qb29PtSNKRFpa2owZzvTvGzWB3vL99z9M mjSpsW/09t6ZnZ1N0kfu1au3pL46sVnQlfB4vMDAAPAfRxFEAVEE9CUNDU0jI8NW razs7OwgqNDR0am8AKI4X18fDofDJOkrITs7J03WknIYmoAHAsWjTZs2BgZNqfaC eGAwbdrUICYmxtrautYLcnJyLl26dO/e3UePHhcW4iVi2YHvbfNml9GjRxPectXy V4Cz8/SqC8LE0qdPn4CAQOmvf/Xq1Zw5s0Gik+QPAlgs1oEDB6n2Qll48eLF8uXL 6FP1qn4EAoGf357OnTtT7YiyMH36tKysLKq9kB2YQBcsWNiqVSvp35KQkJCY+C9J d4SBgUFwcIixsTFJi8AS7t69e+rUSUV8bEEHJIpXW1u7devW7dq179atW111Q+DW 2Lt3r0BQxsggjc0u+vjxI9VeYOSFgV1TGejUqSNTdwPCCKulpRURsa9Lly71XwkB 3/nz5yMjIz9//iTZZ4JntQaBL8rRcYinpycZQQz8Irm5uVVfGTx4EHmPfvfu9e/X r580V4ImX7lyxdWrtC71LA1wd2zatFnKT42Rh7S0tJkzZyjWwgX08/37o3COAAIS ExM9PLYqenAP04Gdnd2MGTOl7Od5eXnkHQMG08e+ffusrW3KyspIWgSWAJ86Jibm 5csXij4dIAC+K0nNKhMTEweHAT/88EODX1pKSkpISLDkXWicRAz0z5cvX1HtBYYA mNlBGQ/zNgNXA0ZPGGd37vSW/qBLCP7u3Llz6dLFp0+fpqamlpaW4umtKjCTdezY 0c9vj5mZGUkmcnJyqpZXycjImDHDmaReCoaSkp5Lc+X169dXrVpJzzN+ZQB69blz f1PtBcMpKiqaMGE8GQtQZAO327Fjx5s2ZWCKEK0YNux32UpJ0RAYG6dNmy5l7sDG jRsk5ziQ4cnGjZskT/dIXQSWkJ+fv39/ZGZmJo4TqgI/rqqqqqGhoY2NTdeu3Tp0 6CD9Q8CkpKRDh2KYfbQH3vrLJBjbTRlPy5aWJiZM2wxcExhu1q5dJ8NuJRjHExMT QQ8/e/YMlFhZWZnSznPwVbRv397Hx7eu3HJCqLn8GxoaGhd3iiRzRkbGV65cqf8a kDFz5859/fqVYq3jNciIESMWLVpMtReMBXryuHFjFffoFG1t7RMnTipK5rYiEhQU mJCQQLUXRAIauEULs4ULF1bdwFkr/v57v379StJk2rdvv7/++gs6MNmLwJVkZWVF R0dnZ2cpc3gAerVZs+bW1lbdunXv2LGjDNMlxFpnziQow3eYk5OTmoq3/jIELIAV mLZtbfX19an2AgUwPc+ZM3fp0qUytwBB7fXr169evZKUlKQ8ehi+tz59+ri5bWGx WGTbqrb8C8ybN/fLly8kmXNyGr51a30lkcPDwwMC/BkmfSVAZ46PP60k9z56Zs2a CZE31V7IhYWFRWTkfqq9YCbFxcWjRo1k5PMFGFgGD3YcNGhQPddcu3b1/PnzJM2e RkbGQUFBzZtXnPWIYBG4ksLCgtjY2Pfv3zPyZ61GpeK1srLq0qVL586d5fk1z507 d/36NWX43lTE9/6HD8lUe4EhDCyAFZvOnTspydCjIh64x4wZA3KOkKYSExOvXr36 /PnztLQ0Ho/LJD0Mn87IyGj8+AkLFy5EowBrLv8Cv//+u0hEVpbgwYMxdeXsffjw Ye7cufn5eQxOxPruu+927/aj2gsG4uLicv/+Paq9IIBevXq7u7tT7QUDWbFi+evX r6n2gizENTi0FyxYUNc5SXw+f9OmjSRFHWA9OvqAZJMOskXgSkQi0YULF+7evcPl Mi0eUFVVMzQ0lChe2dZ4axIbe/Thw4fKE39CkPPixUuqvcAQCWMDRCXBrGI3MIvB gX5NYDTv27dfUFAQsc0+efIEJr+kpKSvX7+y2YWKuI8Fvhk9Pb3+/fuvWrXKxMQU pemay78QJzk5DSMpjIBI5dmzpFpfh89++fIlxs/K8G0HBga1b9+eakcYRXR09OHD hxTuxq8V0BKTJ09xdnam2hFG8e7du8WLFzFJHdUKxPrffddxxozai8CRug3Yz2+P nZ2d5M8oF4GrwmazExJOv3r1Cr4HhfutJYWatbS0jY2Nra2tu3fv3qZNG2JNhIWF fvjwQeG+GXkQb/3NyszMpNoRDJEwYaZXclq1amVsbES1F6iBIb5Tp84HDx4kSeoU FRVdv379zp3br1+/+fYts6SkhJ6SuFyMubnFoEG/zZ49R5I8hhjQugUFBdVe/Oef 835+ZC1RwtR++XL1DcBnz551dXVhTLGrBjEwMDh27DjVXjCHO3fubN68WV2dOVGd QCDcuhUfDkwkEyaMr3rOObOBsXT8+PE9evSs9jqp24DHj58wffp0ySEX6BeBqwHz /uXLl5OSktjsQvi89AwAIBbS1NRs1qyZhYVlhw4dOnfu3OBGbtkAQ3v37s3ISFcq 6SshNzcP+jzVXmAIhnb3M0YG2rdvp6urS7UXFAAztJWV1fHjJ7S1tcm2BTLv7t27 9+/fe/XqdWrq18JCNp9fUSYH/S5TyYRnaWn5ww8//vHHHzDnIXagGllZWTWf0G/Y sOHx40ckWXR0dPTy2lH515yc7NmzZ6ekpNAwQCEP+M4XLFhIxmHOSkhGRsb06dOY F9jBWHHgwMG60lkxjSIuLi4kJFjZBpnmzZsvWrS46nGvFy9evHTpIkmPnm1t2+7Y saOywAFVi8A1SUtLu3nz5qdPHwsKCiDwQD9WiMSoqanr6uoYGRm3bGnZrl279u07 IDgRs6ysdNeuXfDBGVlTo0E4HM67d++p9gJDPEo0lDObLl3kqmSg0MCsYGJiGht7 FHHer8p/h/EkPXv29M2bN1+/pubn57PZbC6XU1ZWpkLEucSSTDOQ9xCFtGpl1blz Z3t7+549e9JnHhJ/Xm7N18ePH1dUVESSUW9v7y5dusLXC3O/j49PfHyccnZ+CArP nfub8fneZAN36+jRowQUrTKRDXSPuLh4pp4bjwzoHsOG/a5U6rcS+Ow9e/aaMGGC 5K8lJSVubq4kDTuampqRkfsrT7igfBG4ViDk+PDhw7t3b798+ZqbmwMCCb4i6BuE zPgwqsP8rqGhqaOjo6ena2xsYmlpaSMG/bwP87uvry+ENPQJORADv8jz5y+o9gJD Cso4mjMSJdwMXA2YNvT09A4cOGhra0u1L/9RUFDw6dOnrKxveXn5YvIKC9nFxUVl ZbXM5RChGhg01dPTb9asGfya1tbWrVu3RlC9WR7gO8/Kyqr1nwYN+o0kUQoT0qVL l1UqclZve3hsEwppFBih5+ef+7i4uFDthWIza9as9HQmn2xhYWEZGRlJtReKjbu7 ++3bt6j2gkrKy1WmTp0qKT24YcN6EIFkxBswvEdFRYPkq3yFPovADVIIrn77lp2d DVN/SUkJn88H6SgU1rIrR01NVVtbW1dXF2Z8CTDvt2jRAmIY9G7XSmZmpr+/P0yv Sh5V4q2/DEZ5ezbzsLa2MjQ0pNoLioEBS1NTKzg4+Mcff6TaF+ZTs/aVhIyMjBkz nEmaOHV0dCGaX7NmdUpKitI+lq4Evv+YmEMQOVHtiKKyc+fOq1cbOFCaAQwYMHDN mjVUe6GogKqZOnWKcqaZVEWcbGWyYMHCkJAQ8s7OdXV1q7pxXbIInJuXpxAamAEk JyeHh4dDMKXM0ldCfn5+SgpZRzliKEfZ+zfDsLPrgGA3LP2RJBF5ee0YPHgw1b4w lpKSkuLi4lr/KTo6+siRwyTZbdaseV5eLp2DUeh+FhaWHE5JYWEhAnNmZuZRUVEI DDGPCxcu+PjsUobHKOIC6X85OjpS7YhCMmPGjMzMDASGNMUUFRXRWXsIhUITE1MQ wCRlQQ8c+NvSpUurRjL0TIRmHk+fPj18+BCMh3Tufsjg8Xhv3ryl2gsMieBezijM zFqwWCxliOekBMK+v/5aPW3aNKodYRr1JD8Df/659N27dyj9oQ8QHS5d+ufcuXOh 73Xv3g2BUIffYtOmzf369SPbEMNITU2dMcNZeXZQCwSCqKjoli1bUu2IgpGYmOjh sRWBJACZt3OnN0zfly5dunjxAs17JoxvJEUaFhYWu3f7NWvWrOqLCpQIrYhcv379 3LmzNO9yKIHuDRFOZuY3qh3BkAgWwEwDJg8WC3UtKJoDY5mz84yVK1dS7QhzyM7O rufAoZEjR/D5fJT+0AR9/aaxsbFwD0r++uLFi6lTpyAInSFwOXv2HNlWmASIjVGj RtaawE82klp9OTnZ6E2rqanFx5/GBbEahZPTMAQF0kDXLVq0yMrKWvLXvLy83bt9 mVqYrX5AV0dHHzA1/Z8wBidCk0RCQkJi4r9Y+lYjKys7PT2dai8w5IIFMANp3dqm 2tNTjIp4ac7JyWn7dk+qHVF48vPzS0tL67mAvApYtAV61+DBjrt27ar2+uTJk1+/ foXAAejbS5YsRWCIGcybN/fLF9SbuyBw/+GHHzw9veDP69eve/z4MfpUQysrq7Cw cMRGFZeAAP+zZ88iMMRitVixYkW1F6Ojo1++fKGEY2lERIS1tU2113EiNLHExMQ8 e/YUS9+aFBYWfvr0mWovMKSDBTAz6djxO01NTaq9oCMwudrb24eGhlHtiKJSXFxc UlJSzwWfP39esGA+Mn/oQZO9e/fWmoRcWlrao8ePCEJYgUBw6lRc1eM6MXURGhp6 6tRJxOIT1K+j45CqeSi+vr4XLvyD3o0xY8bOn69sd6gssNnsMWNGI1AIcPN6enrV aujVq1dRUVFqasq1rWndunX9+zvUfB0nQhNCSEjwx48fle3BipTAlP3q1WuqvcCg AAtgZsJisczNzXAlg7oAGdyxY8eYmEP48Wej4PP5BQUF9V8TGRl57FgsGn8oB+Kw 1q3bxMTE1HN8RVhYWHBwEAJnbGxsQkJCERhSaJ48ebJ69Wp1daTBn0gkGjt2XE3Z CVL85MkTiKs2CARCb2/v77//HqVRRWTBgvmfP39GYMjBYUA99Rp5PN6ePXvy8/OU Z0IfMGDAn38uq1nREydCywOEPXv2+GVmZmLpWxfQqTIyMuupb4JhEsoyniohlpaW pqYmVHtBayAqtbRsefz4cfocvkdnYPrMyclp8LLly5e9efMGgT+UA1/I4sWL589f 0OCVP/9sz+VyyfYH+rOnpxc+AKweioqKxo4dq6qKetF1+PARS5YsqfVfAwICzpxJ QKxtRKLykydPNm3aFKVRxeLRo0fr169D8GwCTGzbtr3Byy5cuHD58iUleWIL8/Lu 3btrzWfBGlgGeDyej88uNpuNK6TWT3Z2Tloak8+Ex1QFC2AmY2vbBoc4DQKTqJGR 0bFjxyTFaTC1Un/Z56qMGTOaw+GQ7Q/l6Os3jYmJsba2lubie/fuzZs3F0HwoaGh eebMGbKtKC6TJv2Rn5+P0iLcOEOH/r58+fJ6rvHz8zt//m/EGtjQ0PDIkaMoLSoW w4cPLyurr9IBIYhEotmz57Rv316ai2EE3rt3r1DI/B2woPOjoqJNTGp/go81sPSA 6PX19QEBrDzpAzJTVFSUnPyRai8w6MC3BMPp3LmTkjwzlhOYR3V0dKKjD0gZiygV 0qtfFSWogCUUCkeMGOnh4dGod40bNzY5OZkkl6oyevQYvMOzVrZu3Xrr1k2UFuHG sbf/2c3NrcEr4Zo7d24jDlL79Om7efNmlBYVhdDQ0Li4UwgMGRkZr169ulFvOXz4 8NOnT5g9xgoEgoMHY8zNzeu6AGvgBklPTw8I8BeJRFj6SgN0uRcvXlLtBQYp+MZg OGZmLQA8AkoJTKUaGhoBAYG9e/em2he60Cj1m5eXO2nSJAb3N+ge4eER3bp1a+wb c3JyBgxwQBC2gj4/dSoOp35U48qVKzt2eCHOALSzs/Pz2yPlxej3DkBwvHbtuoED B6I0Sn+KiorGjBmNpnDd5s0uMhSu+/z5c0hIMIOHWcDT06v+bepYA9fFu3fvIiP3 wR+Y3UMIBPrPt2/f8Km/yga+PZhPq1YtjY2NqfZCkYDREAJld/etTk5OVPtCMRCi 5ebmSn/9iRPHIyIiyPOHQkBYDhgw0NfXV2YRtWnTpnPnUBypYmvbNjAwEIEhRSEn J2fSpD8QL5qZmJjGxMQ06i1Tp05FfD4w9OojR47WlWuqnCxevDg5+QMCQ126dJ08 ebJs7xWJRFFRUW/evGbqUrCT0/D58+fXf2Y11sDVePjwwbFjx2CGwtK3UUCQ8/Vr KtVeYFCDbxKloF27trjOkwzAnLpixQpn5xlUO0INPB6vsLCwUW/ZsGH948ePSfKH QiAOCwkJ+eEHuepLQczao0eP8nIRUV7VY2jXLp+uXbuSbUhRGDt2TP1ndxGOlpb2 iRMn6g/fawIB/bhx4/h8Hkle1QpMDSdPokj3VQiSkpL++msVgkwBoVDk5SVvSkJy cnJ4eBgj1Y6tbdsdO3bo6+vXfxnWwBKuXbt6/vx5pj4NIRWYGt6/R/HAC0M3GDhu YmqlS5fOeHCUDZATU6dOXb16DdWOIIXNZstQuHjixAmN1cw0RygU/vbboF27dhES E8fFxW3Z4oYgYNXU1ExIwNWwKnBxcbl//x5KixCIx8Yea968uQzvLSgogJsIsaTp 1au3u7s7Sou0ZcSI4aWlpNe+gh4yatTon376Sf6mYHqKjo5+/foVw+Z3bW3tyMj9 RkZGDV6p5Bo4Pj7u1q1buNSLbMD8/vz5C6q9wFADFsDKAvrNwDAxM6nmPgyUQ4YM 3blzJ9WOoCA3N1cgkKXWqKPjYCYtR0AQFhYW3qVLFwLbHDx4UHY2ijTXkSNHLly4 CIEhOnPhwgUfH2IeXkgJDBTBwcFt27aTuYUPH94vXLgQpZ6BsXrVqr8cHR2RWaQn wcFBp0+fRmBIR0fXxcWFwAZTUlLCwkLhdySwTWqB++jgwRgzMzNpLq7UwHweTyQU KokMPnAg+vnz50ySvoiDRrz1V8lhTqiKaRArKysjI0OUFm1tbd+/f88kGQyysFev Xvv2RVLtCFlAJJGfny9bAMHlckeOHMGMnxvCr1GjRpOxLPbhw4fRo0erq6MosXPi xEnZ1iGZQU5Ozh9/TEQZIEK3+euv1fIrSdDtu3Z5o9TA0FuOHo1V5s3ABQUF48aN RdBbBALhypUr6ylxLDNHjhx58uQxY5aC9+71l/5QBpi5SjiciqIVSrAUHBgY+Pnz JyZJXxg5TU1ZeXmNKDgiP3l5+V++fEFpEUMrsABWLjp0aK+jo4PMHExCt27djoqK CgsLZYYukgCDtbW19aFDh2Uo4ElnCgsLeTzZ9x9eunTJx2cXgf5QhaGh0f79+6U8 41cG5s+fd//+fZIar4qlZct9+/YhMERPEB9JDcPd8OHDlyxZSkhrAQH+Z86cQZlP oaure+pUHDJzdGP27NlpaSgK4cDAsmDBQpIaz8rKCgoKQryNnCSmTJk6efLkRul5 ZqdDw2i2Z49ffn4+Y55xqIgfvQ0YMNDBwcHNzRXlcMflct++fYfMHIaGYAGsdHTt 2gWlFhWJRM+eJcEfjh07tn37Niblx0qODg4ICPzxR7lqI9GB0tLSgoICOSMGLy+v 69evEeUSJUB3XbRo0fz5C0i1wuPxevfuheA2hB90w4aNv/76K9mGaMimTRsfPnyI 0iLhxbeRlSOupEePHh4e21BapAk3btxAMz1BuL99+3YNDU1SrVy4cOHy5UuKvkLY vXt3V1e3xj6yZ2Q6dHJycmTkPqFQyKQICj7OyJGj+vTpA39evfovlN0VJvqkpOfI zGHoCXPuJYyUWFiYm5qaohxGra1t4uPjJX+GOGPlyhVMGsfLxcybNx+iVap9kQVw Pj8/H4IG+ZtCtoRCBjAjdujQISJiH5pV/aCgoPDwMASGQGafPXuOSfkX0nDp0iVv 750oP7W2tvapU3HEWoQ+OWbMaHmSMmSwuHr1mkGDBiGzSAfgUzs5DUOzgfaXX34d OnQoAkMcDic4OCgrK0tx730jI6Pg4JBmzZo19o1MSoc+f/781atX1NTUGBYyTZ8+ vVOnzpJXvLy8CgsLUDqQnZ2dnp6BzCKGnjDkjsI0Chsba5Q7A2G42b7d8/fff698 5fnz53PmzOHzeYwZ01XEjzN79OgZFhamQM/dCwoK+Hw+Ua2hKaBKBhBe7Nixc+DA gSiN9unzM5oE3b59+23atAmBIZqQl5c7ceJEtEWkyo8ePWJkRPxx6/BZ/vhjkqoq unESxrHY2FgyPgtt8fDwuHkzEYEhVVW1bduQLrAnJSUdPnxIQedZcPvgwRiZ96Ur 9FIw3IYhIcEpKSlMynaGn0BVVXX+/AVVtxc9evTo+PFjKLsohD2fP6cgM4ehLQo5 LGLk57vv7LS0tJCZq0yErgoM7lOnTi0qYivo9Fwr8ElNTEyjo6NbtmxJtS/1Ied2 31r57beBCiT+JUiKe8t/IKcMPH78aObMmUhOHBXu3x9F8w5JIOPGjS0uLkZmDr7e 7du39+zZi6T2Hzy4v2HDBpRxsL6+/okTJ5GZo5bU1NSZM2cg+Hphapg3b76trS3Z hmrajYk5+OLFC4WTUnBnHThwUJ5qYVWXghVFBufm5gYEBHA4JYq7dF8T+No1NDSX Ll3KYrGq/dPatWtQflI+n//69Rtk5jB0hjnCA9Mo0J+KBLYeP35S83U2mz1+/LjM zEyGDfd//33ewsKCakeqA47BF05GUmVOTs6UKZMV6FkGfBWmpqYREfvIK3bVIJMn T379+hUCQ4aGhkeOHEVgiHLc3Nzu3r2DzBz0ojFjxs6fP59UK6GhoadOnUR5c/30 kz18k8jMUcikSX/k5+cjMMRitVixYgUCQ7WSlZUVEhLM4XAUaIgGPD29vv/+ezkb USAZnJeXt3PnDsX6jepHJBLp6+uvWvWXrq5uzX9ds2Y1yucy+NwjTFWYc5thGoul pQUIAJQWf/65T11FYkCSTZo0KTn5g8I9pa6LJmJA4axYsZIO2p7P5xcVFQmFQpIa X7RokQJtAIaJcPXqNVOmTKHWDfhF+vbtg6Ya1uzZcyZMmEC2IWq5du2ap+d2lLdb 69ZtgoODERhauHDhp08fERiSAGHr+vUbHBwckFmkhGPHju3bF4Gm9pW7+1aURzDU yr//3jh79qwCTbImJqYhISGgoORvqpoMhlfoo4Thdjtz5szt27fAHwX6deoHgg34 +VasWF5Xybfw8LCPH9GNaUB2dnZaWjpKixg6gwWwUmNr26Zp06bIzMHgHhNzqHPn zvVcM2OG86NHjxGckooM+NRDhgzZvNlFT0+PEuvFxcXk7TWFmdvf3//cubN0EPnS ALNyr169AwICtLW1qfalAl9f34MHDyAwBL9UfPzpWh/DM4OcnJxJk/5AGT5CXzp/ /h80af8QuA8dOgTxpzty5CiDTwaGUXHUqJFoBi57+59HjBiBwFCDlJWVhodHfP78 SVGEFvRDJ6fhS5cuJeSXkshgFfENRYcFYR6Pd/z48efPkxTl55AGgUBoZdVq6dI/ 67nmy5eUoKAglGvdRUVFyclI9TaG5mABrOx07twJ5b5NmHWeP3/R4GUrVqxgwCkO VYFZvEuXrps3b7Kz+w6NOQjvuFwuqVN7RET4sWPHUVbokRN9/aYw6Xbp0oVqR/4H e3t7Ho+LwBDh5/TQiokTJxQWFiIzJxKJwsLCbWxskFn8/PnzvHlzUT5patasWWzs MWTmEIPslKkmTVS3b9+OwJD0pKSkRERECAQEFP9Hg0hUPmHC+Dlz5hLVIOULwqmp qSdOHE9LS2NSnAPf53ffdZw1a1aDVyI+9wgce/HiJTJzGIVAYSJXDEmg3wysq6t7 69Ztaa7cts0jNjaWSU9GJfthxo4du2jRYjJWIEtLS0H0Ijg35ciRI9HR0SoqtMgf kwb45ufPX7Bo0SKqHamFe/fuoRE28CVs2bLF3v5nsg2hJyQkJD4+DqXFKVOmTps2 DaVF4ODBg4cOxaC0OGrU6AULyD0WmxLu3Lnt6uqK5qabPXtO+/btyTYkA5IjdhRK gDVxdnaeNGkSUc3VXBBWIVkJl5WVwtd+7959gaBMUdKmpAG+wN69e48bN16aizdu 3CgSkbIbq1bw1l9MrWABjFFp1aqlsTHSQy9gAluzZq2UF4eFhQUGBjBpqlARzxZW VlaTJ0+Br0LOj8YTQ+BpRvXj6+t78eIFNLYIQSgUdu/ePTg4hJIUdCn544+Jb9++ RWKqydmzZxUq5G2YlJTPs2fPRvmh4OYNCwtHZq4q8+bN/fLlCzJzMFLt27fP2toG mUUEwIdycnJC8/zO1NR05cpVCAzJBswdYWGhqampivWgefBgx5UrVxLYYK1KWIU4 MSwSiW7eTLx582Z+fj7Dhl/4xgYNGgxIeX1cXNz9+/dIdakaubm5X78qTIESDDKw AMZU0L59O5SbA2FGuX79RqPOIo6Pj9uyxb28XMSkAokqYnnWqlWrESNGTJs2XZqf ACabUjEwYcOcisDDSkJCQk6ePKFYcZKenr6/v7/8dUTJpqCg4Jdf+qH5bn/44Yft 2z0RGELG6NGjuFwUOeQSNDU1ExLOIDNXE8QHbuvo6MTFxSMzh4ANG9Y/fvwYgSEY rt3cttD50ZuEjx8/RkZGCoUCqh1pBDB1jh07jvD0hEolrFJDDKs0Xg/z+fzr168/ evSQeboXvgeRqHzs2DG9e/8k/btKSkq2bnVHGcVxOJx3794jM4dRIBilJTDy0KVL Z5TaptaTgRvkzp3bS5cuhWmJYTJYRVw3onnz5n379nV2dra1tYXvRygGPqzkDxT6 9u3bt6lTpyiW9IUvcOHCRQqUventvfPw4cMIDEFf8vHx7dq1KwJbCPD09Lxx4zoy c3A/njhxslEP7winoKBg3LixKOPpX3/tv379emTmSCUpKWnVqpVoRrPevXuPGjUa gSFCuHDhgsKV3oDRLCbmUIsWLchovKoYVqlND0uoqYrT09OvXr369u0bHo/PpIqe EiQfdsaMmXZ2do19L+Ktv9A9pCk6g1FOmKYiMDJjVrEbmIVSWFpb28THy7Kw8Pbt W1CJPB6XeTJYRTy7wPxiZdXKwWHAiBEjUJbprgmbzd6yxe3Zs2cKFBXBnNezZy9/ f3+Fq3hsb/8Tgv3bAPyaCQlnGLCt4NWrV8uW/Yns0QzcmZs2be7Xrx8ac/WQmJjo 4bEV2QAI99SePXs7duyIxhx5iESiESOGg5JBYAt+HYVLteDz+RERESkpnxXocSf8 mt26dXN1dTMwMCDVUDU9XGldooo5HA7clU8eP8rKylZTU2VqcKKqqrZ48WJLS0sZ 3u7l5VVYWEC4V3Uh3vqblZmZicwiRrFg4C2KkRlra2tDQ3QrGzA87dzpLf3WkWqk pqZOmTK5sLCQkTONBAjX1NU1bGxs7O3thw0bZmRkhMx0VlbW9u3bXr58qUCREPQo +IqCgoLQlNomnMePH82YMQPNF/7zz31cXFwQGCIPuDuGDx+OMm+zb99+mzZtQmau fjw8PG7eTERmTk1N/cwZhX9o4u7ufvv2LQSGhELh/PkLbG1tEdgiHJhbIyLCeTye As2t8IV36tRpw4aNLBYLmdG8vLyEhITbt29//foVBiJFvzvqAeZWTU3NZcuWy1wv 5unTp0ePHkHZo/LzC1JSUpCZwygcCjO6YdDw3Xd2WlpayMzBpJWU9FyeFths9sSJ E9PT0xg890gQ5x01adGC1b379w4ODt26dSPpIycmJoaFhWZmZiqQ9FURfz+rVq2a Nm061Y7IxcyZMyBQQGCIAWt669eve/LkCTJzurp6p06dQmZOGsaMGcPhlCAz9/33 33t6eiEzRzgo8wUsLS2XLFmKwBB5XL9+7e+//1asWQCGNTMzs3nz5pOUpiHeuvXs 2rVrT58++fYtC6YdBXpGIBvwkZs2NVi5cqWcGVVr1qxG2Zf4fP7r12+QmcMoIgy/ dTGNxcysBYvFQikmYUx8+PCRnI0IBII//pj47t07xZqt5UEgEGpqasJkb2dn98MP 3/fu/ZOcydIQHUZF7U9KSgIlqViTOgQ9Dg4O3t674Auh2hd54XA49vY/obkBFToR OjExcetWd2TOQx87dSqO2v0INSkqKhozZjSyQQ9C4c2bXeiQAS4DKJOfwYqHxzaU j5JJAj5IdHTU27dvFWtilUxhXbt2nTFjppzP+OAWu3fv7uPHT968eZOZmVlaWsq8 Pb11AYOeqSkLpK/8v/66dWtRBhVws2dlZeFzjzD1o0hhLgYNlpYWpqamKC06Ojp6 ee0gpKnZs2fdv39fgTasEoW4JKNIV1fX0NCQxWphZWXVrl07W1tbS0tLHR2dWt+S kZFx586dZ8+evX//Ljs7W7FCHAnwqc3NLUJCQqytran2hTCiovb7+fmhCRd++sne zc0NgSFi4XK5o0aNRBZRQTfz8PDo2bMXGnON4sGD+5s2bUL5VcTHn65rSKEz0M/v 3r2DwBB8RYMHOw4YMACBLTSAlggLCysuLlKsB6MSxCrOtF279t26dbO3tzc3N6/1 MhhS0tLSkpOT379//+XLl6ysb/n5+RwOR1WVmbt560cgENjYtF68eDEhrR08ePDV q5eENCUlEM+kpaWjtIhRRJTuxsZIQ5s2rcmuJ1EViBhOn04gUMP89ddfFy9eUERF RwZCcY3KqmtlIJVhUlf07wf8d3PbIj7Pk2lA9Jyfn4fAEPQNb+9d3bt3R2CLQBYs mP/582dk5nr3/mnLli3IzDUWV1fXe/fuIjNnY2MTEhKKzBwhPH36dPXqv9CMeFpa 2or4UKlBHj58cOLECUVXg0ydDYkCpG/nzl2cnZ2JajArK8vX1wdlt2Gz2R8/fkJm DqO4KPZYhiGPTp06amhoIDMHwy7h1eq9vXfGxMQoaIYnph4giBkzZqyLiwtTf9wP Hz4gS22F7zAh4YwCJU3Ex8cHBwchi6hgGDxz5iwaWzIzfLhTWVkZGlugHxYuXDRq 1Cg05uQHJpcRI4ajOTUdhqYVK1bWtcyo6MB3ePz4cVDCCjRcYKQEbpM+ffoQfmoX 4nOPYBh8+fIVMnMYhQYLYEztVByK1KIFyud2pqamFy9eIrzZ6Oio3bt3K/pza4wE iMA6dOgQEhKKsiA2JSxfvhzZ8badOnX28fFBY0tOCgoKxo8fh2y5BoLCuLh4um39 rUlRUdHo0aOQBZog844fP0HtYcjSs2rVqpcvEZ0F2q5d+1mzZqGxRRXFxcWhoSFZ WVlMff6obMDtPHToUAcH4pP23d3dudzqB0eRh/jco2946y9GSrAqwNRJq1YtZS55 Lxtr1qydNGkSGS2fPXt28+ZNClfeCVMVXV1dX9/dvXv3ptoRFID06tmzBxpbIpFo /foNDg4OaMzJw5QpU3Jzc9DYguFi9erVv/02CI05Obl8+ZK3tzey8c3Y2OTQoUNo bMnDtWvXPD23o5FqICQ8Pb2IfToDrUnqOxDYJiG8e/cuOjpaJBJS7QhGRiT9asKE CT169CSj/cTExL//PkdGy3WRm5v79WsqSosYhQaLAUx9tGvXVk9PD5k5GI4fPHhI Xi3fe/fuLVmyuKysDMtgxQKm6gULFi5YsIBqR5By4cI/a9ciKp4Jt97Jk6dovtQZ ERFx/PgxZDdvmza2QUFBaGwRwqJFiz5+TEZjC27J8eMnzJkzB4052SgqKho7dgwa 9QtfyMSJf3z//fcEtqmmri7Jps7JzeVzueKT8OjFhQsXrly5jDfQKhaSjjRr1uz2 7duTZEIgEGzcuAFljkBJScn79x+QmcMwACwDMA3QpUtnxNPbkyfknoP67t07Z+fp XC4Xy2D6IxAI+/bts3u3n7a2NtW+UMDo0aM/f0ZUz4PFYh04cBCNLRn4/PnznDmz kWX5Qox44cJFNLYIxNFxMLJhDWLciIh9NjY2aMzJwPTp07KystDYMjQ0WrNmDYEN wrRrbmHRvFkz+HMJh1NWWvotKwv+S6AJQigrK42MjPzwIVl5zgdSXCQFwJYsWWph YUGqIcSn/gqFQsKLyGAYDxYAmAZAvxm4V69eoaFhZFvJycmeMGFCXl4elsG0BWbr kydP2draUu1IA5SUlMAETEbhdDabDfofTSRB5zU9kUg0atSo0lI+MnOHDx8xMTFB Y45AcnJyJk+ehGzhRVNTKz4+np57QVHmC8Dt7+a2RVdXl6gGK9VvZSnKsrIykMF8 Pv9bZiaYI8oQUWRmZvr54Vob9AWGd21t7ZUrVyE44CMkJDglJYVsK5Xgrb8Y2cCj FaZhrK2tDA0NkZmD4Sw29liHDh0Q2ALpMn78+LS0VHrGcErOrl0+AwcOpNqL+oC+ mpubK4lH9fT09PX1CTcREhISGhpCeLO1Ah8kMDCIvLw4mXFx2Xz//n00tkD9OjvP mDJlChpzhHPo0KHo6ChkA1qvXr3c3beisSU97969W7x4EbI1qP79HRwdHYlqrab6 rQRkcEFhIT0zopOSkmJiDuJ0aLoBAxqI3lWr/kKTRZWWlubvvxflo5D8/PyUlC/I zGEYAxbAGKmws+uAMgeVjFOR6jc3deqUV69e4cmbDoAMGzt2nKurK9WONEBRURGH 8z8lLkEAk7FnHjRGWRmi1Ee4BU6fTqDVMSeJiYlbt7ojU3Tdu3f38tqBxhZJrFu3 9ulTcjeSVALh9ebNLv369UNjThpgPB85cgSyZVLQoV5eXkS1Jtn3W6v6lSBZCqZt RnRsbOyjRw/xTEoH4BYwMzNbtmw5yp8D8blHPB7vzZu3yMxhmAQWwBipMDNrwWKx UC6T6us3hcAXmTkJCxcuuHXrFp68qaK8vLxNG9uIiAian3IEgUVeXl6tpVmbNm1K YCakhK9fvzg5OSG7+2xt2wYGBqKx1SAo6xipiPX/mTNnFT0fBHrm8OFOyBQg3Sqo LV68ODkZUTkc+OyrV682MTElpDV1DQ1QLPWo30pABhey2TAK8bhcumVEFxcXBwUF 4u1FFAJdwtbWdv581GUjN2/eLBAgOpBcRXz3ZWVl4eRnjGzg4QkjLRYWFiwWMdO8 lMyaNXvp0qUoLUrw9fWJjo5W9CBY4dDU1AoICOjZk5QjGQiksLCQx+PVcwEZGnjq 1CkvX74kts26KC8vnz7dmSY5wFOnTs3JyUZjC6LG3bv9OnfujMYcqbx48WLFCnQr P6AAY2Ji0Niqn0OHDh04EI1MeklW2AhpSkNTs0WLFtKoXwn/LQWXleXk5PB5PLpl RL9//37//ki6ecV4BAJBv379RowYid70uXPnbt5EumiRlZWdnp6O0iKGSWABjGkE rVu3btaM9AoKlcDceevWbZTnMFXlzp3by5YtKy0txY+xyQaEx9Klf86dO5dqRxoA OkNBQYE0IR0ZudAQ1hQXFxHbZl1AFBUUFEz5ZuCAgICzZ88gM/fLL79u2LABmTmy 2b59+7//3kBmzslp+JIlS5CZq5V3794tWrQQWQammpq6h4cHIU1pammxWCzp1W8l NM+IvnTp0oUL/zT2Q2Eai2RWmjFjpp2dHSUO8Hg8NzdXlMFSYSH70ydERyRgGAmO 7DGNo1OnjignM5FI9OxZEjJzNcnLy5syZUpaWirOiyYDgUDo6Ojo5eVFq02ntZKf n1/amPhSV1eX2KTQt2/fjh8/Dlk/hFDm1Kk4HR0dNOZqkpSUtHLlSmRnq2hra8fH n0ZjCxmjRo2sP1uBQOBe9vX17dq1KxpzNeFyuWPGjEa25CgUCpctW25paSl/U9o6 Oqamps0MDGSeW+mcEQ3+xMTEvHjxAp+TRAbiAwiaLV++nIwSjNKDeOsvdPiXL18h M4dhJFgAYxoH+lOR7Oy+O3LkCDJzdbF06ZIbN25gGUwUIpGoQ4cOISGhNN/uqyIO rNlstgxvBPVI7JkTLi4uZ84kENhg/ZiZmUVFRSMzVxUOhwNiBpk5gUCwb98+a2sb ZBbRkJLyefZsdIcnA6dOxRGe/y8lM2Y4Z2ZmIjPXtWu3SZMmyd+Ojp6eibGxPOpX As0zoouLi0NDQ7KysvDeIqKAUQvm0DlzqM+c8vPz+/YN3a2Hzz3CEAIWwJhG06pV S2NjY2TmYLALDg6xt7dHZrEeDh48uGuXN57C5QF+0BYtzPz9/SnPsJWG3NxciDNk fruWllbz5s0J9KdPn5+rlZ4mlT59+m7evBmZuUoQi5nRo8fMnz8fmTmUhIaGxsWd QmaOqocmW7duvXXrJjJzqqpq27Ztk7ORJk2a6OrpGRkZya9+K6F5RnR6evq+fftK SorxxiJ5gClp2DCn/v37U+1IRep+RkaG984dKH9QmJS/fk1FZg7DVPAYhJGFdu3a 6emhe8wvFAqTkp4jM9cg27Z5xMbG4tVgGdDW1vbw2Ebz030lFBcXl5SUyN8OhLYE rnIjToQWiUQLFy4aPRrdYqyKeD3h/Pm/kUVUhoaGR44cRWOLEiZN+iM/Px+NrfLy 8qFDf1++nJi6UFISFxcXHByE7LkkIcnPqmpq5ubmmpqaerq6hO8qonNGtIp4d8PR o0fotkatEMCv2atXr3HjxlPtSEXNNhaLBR14/LixKGOhkhLO+/fvkZnDMBgsgDEy 0qVLZ5SjHoyz9+7dR2ZOGg4fPrxjhxdeDZYSCPKWL18xefJkqh1pGAgfQTAQGJ/B nWJiYkJUa1u2bImPjyOqtQYRCAR+fnuQ1UZOTEx0d9+CbGyBgDI2NtbICF1KC3ry 8nInTpyI8it1cXFFdjLwixcvli9fhjLNu3v37+H7lKcF6Y87khmaZ0QD//777/nz f1PthcIA4/Dw4SN++eUXqh0RS19TU00tLT1d3dGjR8mTIdVYYGx5/vwFMnMYZoMF MEZGzM3NWSxTlHkvY8aMpSQbs35u3bq1cuUKPp+Pc7rqQlVVdf78BfPmzaPaEalo bLErKYHuwWKxiGrt119/kW1bsmyIRKLDh48QqOHrAoL1yZMnIXuoBKpg7ty5dFhO IZsTJ46Hh4cjG6OY2mFUxA/y3N23ytOClra2qakpqeq3EppnRAMXL168cuUyfo5c FzBGwW07fbrzd999R7UvFQ9uYBbTEktf6L1+fn7//HMemXX4KrKysjMyMpBZxDAb HLJjZMfGxprY/Y31A8Pf9es3UFqUnvT09KVLl7x//x7nRVdFIBDMnDlr5cqVVDsi FTIXu5IeIyMjQqLer1+/DBs2DGVnA7dPnDgJoQ95JqC3jB07ls9HVLUYaNmyZUTE PmTmqGXOnNmpqeg2zmlpaZ88eZLUhVk+nz9u3FjQeOSZqAZ00bVr15qYmMrcgo6u romJCYGbfqWB5hnRQEJCQmLiv/Q/CwAl8EuZmprOnj2HDnUiq0lfeAXmyvHjx6F8 7l9QUPD5cwoycxjGgwUwRi46dvxOU1MTmTnKT0WqH3AvMDAwIiIcP88uLy83MzOP j4/X1tam2peGgR8OokM0oWHTpk0JKZO7d+/eyMh9KOMPiMNiYg6R17fnz5+fkvKZ pMZrAj96fPxpqkoWo4fD4YwaNRLl0GRtbRMaGkpS4/DzTZ06BW5bktqvCYxp/fr9 MmzYMNne3kRV1dzcvKqEQAn9M6LLykq9vHbg+lgq4ucs/fs7DB06lA6BRE3pK2HQ oN9QPoEtLS199eo1MnMYZUDZBxqMnKA/Faldu3bHjh1HZk42MjMz/fx2X716FUZt ZZvOIbQyMDA4deqUPOskKCksLER2VqoEbW3tZs2ayd/OkCFDUB4+AVhZWYWFhZPR so+Pz8WLF1Dm6K5fv8HBwQGNOZpw7do1T8/tKDPMBw92XLVqFRmNz5s398uXL2S0 XBe6unoy78FRU1c3NzNr3rw5eulbFfpnRLPZbG9vbxDDSjhvwn87ders5ORkaGhI tTsV1CV9VZA/rMTnHmHIQLmGGAwZtGxpiWCvVyW0OhWpQT58+BAQ4H/79p3SUuZv EoafRkdH9+DBg23btqXaF6kA3QvqlxLT6urq8p8llpeX5+DQH/EqQefOXXbt2kVs m4ir+KqIA02Q3MjM0QeQoy9foqsiQ1IV8b/++uvFC6TnAggEAldXN319fRneq6ml BUICzaZfaZDIYD6fD5KCnhnRGRkZ/v7+IpFQGSZNiMPbt283dOjv5ubmVLvzHyB9 QffWdUDXo0ePNmxYj/KnycnJSU1NQ2YOoyQwfHDBoKFtW1vZIgPZoNupSNKQkpIC If7NmzfZbDbz9gmLpa9OSEhot27dqPZFKsBhUI8oy1fWBAIIU1N5y8jFx8e5urqi lI7w1fXs2dPDQ95DUCt58OD+hg0bUN4UqqpqCQkJyrnhEPr8iBEjQFogswjD9fbt 23v27EVUg5s2bXzw4AHK+Btk/JgxY3r3/kmG91Ky6VcaQAYXFBbm5ObyuVwaZkQD nz9/Dg8Pg/7DPBkMH0pTU7NDBztHR0cCiyPKT6X0heGxrlx9xMnPxcXFHz4kIzOH UR6YNqxgqKJz587q6ujGRG1t7Tt37iIzRyBFRUUHDhz455/zX758ocMOHzmRJDwH BQUjOyZHfthsNpfLpdqL/2jevLmclaVmzZr15MljovyRBvjRf/rJfsuWLfI39fHj x3nz5qLUoqAAAwIC7OyoL6lKFW/evF6yZAni7zwsLLxNmzbyN+Xq6nr37h3Eiqhl y5aLFy9p7LtgeDejbtOvNFRuDM769o2M0veE8OVLSnh4BDOSouFGAG3Zvfv3/fv3 19HRodqd/6Ey4Rn+XE+PHTFiOMquIhAIX7zA5x5hSEHhBxQMTUC/GdjZecby5cuR mSODJ0+exMTE3L9/v7CwQOGWhYVCobW1tZ/fHltbW6p9kRYEdZ5lACIhAwMDmd8O QZW9vb1AgK4WropYA/fo0XPbNrnWgTMyMpydpyN+DDRs2LClS/9EaZGG+PvvPXfu HEqLIpEoOvqAnEmeGzdufPgQ6dqvSkVXV4F+3tjxGcFJv0RB/4xoFXFZjf37I/Pz 8xVxogRVaWvb9pdffiHkGRDhQBc1rWOvbzUiIsJPnDiBzDG89RdDKlgAYwjD2toK ZfEGGBxv3bqtp6eHzCJ5QHQI8WhCQsLLly+KioponpwJ3g4dOtTNbcv/sXcn8FFW 9/7HQ/YQCBCyDEnYE9YEr9fettrev/cWl167qPXWalurt7bVttr6kh1BcQHRiloV tNXijrZVUdFWEC3uC6KShE0EzTIzycxktiyzZJb/CUMjhZBMJnPOPM/M5/3qqy9M 5jm/Awx5nu88v+ccXazwHCGuQux2u5h5oifStyE+Erx3757zzz9f/aXhtGnT7rrr 7tiOFX8dP/zhD8W/4/hOqX/iB9QTTzypsqJmXXjhBSJOqK05bMOGDTHv6fKb31z5 ySefxHdCAxI/N37zm99WVFQM6qicvLyS4mINtj33Q/sd0WmHVop+8sk/19bu1Pgp MhAIZGdnV1SM/9KXvnTSSSdpttUrKztbvFGzo2tS6OrqOvfcc1R+/CR+QDU0KF3o DimFAIx4mjFjuspQpPFdkWIjflOvv/76pk2bdu782Gq1Djsk0ZPqIa4FRX646aaV //mf/5nouQyOOI9qtsGvl/hbFhk45hC7du3a++//o/q3SnFx8fr1Dw72Ql+k3x// +EeKP48Q5f7yl79qcyNx9ZxO5/nnf1/xpbko99hjjw82A4ts9n//d4nNZpM0q+MR OfDUU//rf/7nf6I/RPwDzMvPH3uc1YM07ouOaIvF7/Mlejr92b1795NPPuH1ejVy Q1i8VcT5ccSIERMnThKhd9asWZoNvRE90bekRKT06PvzzzjjdJW/KfGXu3fvPmXl kII0cWGNpGEwlIqfqip/Sp5wwgkPPfSwsnLqNTc3v/jiC++++96nn37qdrsU52Fx Xhd/m1VVVV/+8pfnzZuvrG68dHR0dHZ2JnoWgyAuoWJuajjvvO8dPHgwvvOJhrh+ evDBh6JfCl5cXv/kJxdJndKxRPpdsGDh6aefrriulr388su/+92t6q/UH3nk0egX /jGbzT//+c8Ssl6dCOriPRP96zMzM0sNhkGFCg36oiO6tTWY0GUCo/Hcc899+ul+ MVXxNlZ8ZhSJNzc3r7S0VJwfRegd+qr+KgwbJt6fxcXFg32XXnXVb/fu3St1akcS P67FaYLmZ0hFAEaclZeXiR+vysqJ89Bjjz2uoxWYhkjk4X/849UdOz7cv/8Tq9Uq 4yNwce4RVxIVFRWnnnrqj37047KysviOr4a4gHO5XJrt5euHuCiJrU1UvBm+9rVT EtLmLa4Fly69Jpptdffu3fOb3/xGfej6t3/7t9Wrb1FcVPsWL1708ccfKy4q3qJ3 3XXXgOuQiSS2ecvm3995Z0Lu8olJ3nTTTVlZ2VG+Pic3V5z4dPHQbzTEH77L7bbZ bF4Nd0QfyW63v/76a7t373E6HeL8FfefMIFAQLwPCwoKDIZxU6ZMrqmZo4/E+0/i zyQ7J0e8RcX7c7Af0Ijo+9vf/kbl5wvi2sZoNCkrh9REAEb8TZkypaBgpLJy4sxU V5e66wRaLJYPPvhgz57dBw4cMJlMNlubx9Ml/kwiN2/7P2mJ14jrvJ4ND/JHiMQ7 a9ask08++ZRTThk+fLiy+cedCGMOh0Ozq7lEI+Z2aBEvv//97yfkATnxRvrqV09e sWJFP5eeL7309zVr1qjPM9nZOc8++6zGmxITQvytnXPOOX6/6n5X8c9z3rx53/xm 393FIn21d3Tccsvqjz78MCF/a+Ln529/e1WUj/7quu25HzrqiD6Kz+cTmW3fvn3N zc3iXODzecWZTvzYieZsGDlvZmVljxw5YsyYMaWlBvE2qKycOmqUXh+dGJaenpOT U1RUFEP0jTjttLkqzylud3tCWpmQagjAkKK6erbKn5gFBQWvvfa6snI6Iq5dmpqa nE6nx+PpzYQ5OdnivF5eXi5OikmWCnTxuG+UYmuHXr9+/V13/T5Rz42Lq6tVq26u qak59lvXXnvtu+++o/79JsLMww8/It7tiuvqhdFovPjin6j/0CTyickNN9xw5Bcj oWvnzp2rb16VqBuPou7pp58+d+5p0bxY/LkZDIYsnbc99yPyNyICcKvFEuhWutR8 fIn3W3t7e1tbmzgb9nbUp6cPy87OET9me/ZqHjUqsTOMu/SMDBF9x44dG3P0TTv0 ZI3Kx4jEX019/S5l5ZDKCMCQwtCzLVKJyqvwq6666uKLL1FWDlqjqd194yW2duhL L/3phx8q3Rn4SOJCs7KycsWK63uf89y9e/fixYvV32ZMOxRmfvnLX51zzjnqS+vI s88+e++96xLyoYmIH6tXr66qqhIpK63nEY+m1TffbLFYEvjBXEXF+F//+tfRvDLJ 2p77EemIFunR6/Fodi199MrMzMzOzR1bWNjT3jWEj2b+8pe/rF//p/jOrR+H9j2y tLS0KKuIVEYAhizjx48fOzbGHS9iIM7K27d/kJ0d7SNbSBq6W+lqUEQsGTNmzKCu YMS/hVNPPbWjo13erAYUDAbHjRt39dXz7r777sbGhkQt1jp7dvWaNWsSUlpf5s2b t2tXYh4kEW+VsrLy884779FHH3U6E7zRqwgM119/w4Dxe1h6+vDhwwuTru25H70d 0Var1efzpenhweAUlHVojaucnBzx6yF2JYi/62996yyVH0W1tdmbmpqUlUOKIwBD ounTp+Xl5SkrJ87I6hd0QQJ5PJ729nZdrNEyROLfUUFBQfSvt9vtc+d+Q958oiT+ ahK4iVdOTu7GjRuTrMlfklAodO655/p83kRNILFvlQgRxa+99roRI0b0/zIRKkoN hqG0lerX4Y5ov99isXQny8MmSSCyxlVRUVEcFyE/44wz0tPV/ZMUZ/N9+1Rv9I1U RgCGXHPm1Ki8AD3llK+tXbtWWTkkin4XeY5ZRkZG9FsNCR9+uOOSSy7RyD6Z6okw 8/jjG6Lfbgci0vzoRz9M5TfMZZddPnXq1P5fljd8eM/zoilz47dP+toqKbmlZ2T0 RN+hPeh7rKVLl4ozSFyGikYoFKqtrVNWDkgjAEO2srJxKq9BRSJ66qmnKysrlVWE Yn6/X0TflH0ObeTIkdGv0f3www/dfvvtKXgLVISZZcuWn3rqqYmeiM689tprN910 YwpmYPHz5Jvf/OZ//3d/TRPij8VgMIiwkYI3fvv0xYPBXm9Iz6vu61RmVpZ4Nw79 Qd9jff7555dd9guVHRkWi8VkMisrB6QRgKHA5MmTR40aRPfmEKX4rkhJTFxvOZ3O lI2+vcTlTvRbUC5duuRvf/tbwptLVQqHw2eccca8efMTPRFdWrPmti1btqTaG6a6 uubHP/5xP68RSaOkpCQV1rsalN4HgyMxOJzyP5wVOLLbOW3ID/r2SfG+Ry6X+7PP PlNWDohIoZMcEmj27FkqrxuKi4u3bHlZWTnIluJ3ffs0atSo3NzcaF55wQUX7Nu3 V/Z8tKO8vOJPf1K3cmnyufTSS43G5kTPQp3i4pKrr776eN8dlp6eN3x48m3zG0df rI9ls/m93pR6MkWljMxMEXqHuK3RgC688AKHwyFj5D6Jt82uXbuVlQN6EYChQs+m SKWlKu8qLFu2/LzzzlNWDpIQffsR5SZJ4k9v7txvOJ1OBVNKuKys7I0bN6rf1TaZ BAKBc889t7s7JZY4EoniuutWHO8xgazsbHHmSs31rgbryGWi/T4fMThexIVTz9rO RUXZ8VjbuX8vvvji3XffJWnwYx3a96i1paVVWUWgFwEYikyYMD6GHU1jJi76d+6s VVYOcefz+dxuN9F3QAUFBQOutd7e3j537tykjzShUHjDhg2DWioMfbLZbD/84Q9V rgGbECKjXXfddX3+8xGpIzcvj/WuBosYHEdqbvke6YwzTle5ZoTdbm9sZN8jJEaS n96gKYp3RRo2LP3DDz+M+XCv1xtliyniK3U2N4qXaJ4Kttmsp59+upr5JEQwGFy9 +paTTjop0RNJEjt27Fi8eFESL4gVWSmtz93FRPDoWe8qfjvKpBqaoodiWHq6eNep ueV7pG9+85tpaer+ptj3CIlFAIY6BkNpSUmJys8XzzzzTHFNHNuxkRg2cuRIlaE9 xXV0dHR2diZ6Fno14ALRBw4c+N73zk3KRaFDodCvf33F2WefneiJJJXnnntu7dp7 kvINEwgE5s2bL1Lusd+K3Phlvauh643BtrY2EYNp5xlQVna2+F/hmDHqu+5XrVr5 +uuvKysn3gwWi4XmZyQQARhKlZeXFRcXKysXDoe3bt1aVBRjxba2tsChTQ7z8/NH jBgR16nhC+Kvye12e73eRE9E90RWKSws7Oeu3Y4dO3760/9Lskgj3j8i+v7qV79O 9ESS0Lp1a0UMTrJFoY+35S8bHcnwxUrRdrvf52Pf4GNlZmZm/bPVOU3hLd9ednvb hRdeqPKfudVqNRpNysoBx0qqsxp0YerUKSNHjlRWbogPA7e2fvEJZW5ubkFBQZJd CyaW3+9vb28PcEkUV+KNOmrUqON995133rn88suSKQP/+7//+6pVNyd6Fklr6dIl Q3mWRGtE+r300p9Nnz79qK9z41eqSAxOO7S4g81mEz/501K+LzpD5N6sLJF75W1o FKXTTz9N5cMO4qR/4MBBZeWAPnEpjwSorp6tcpnWGTNmPvHEE7Ed29XVJX5YH/kV MXORLlhmdog6D+HZMHn62SdJZODLLvtFcjzeOXnylHvvvTfRs0hyv/zlLz/7LBku WAOBwM9+9vOj0m/PE7+lpdz4VeOLvmibrdvvDwaDiZ6RatrJvRG/+tWvDh48oKyc +DdYX79LWTngeAjASABDz7ZIJcpupYqU9eCDD5144omxHS7O08eepMXk8w8Z8uxS i/iTbG9v9/l8iZ5IShARd8yYMX0G3ddee+3KK6/QewYuLS19+OFHEj2LlHDxxT85 sh1Gj8SV9yWXXDJ7dvWRX+TGb0IcdUNYJOGk/zA0s6fROato7NgsbeTeiPr6+nnz rlZ5MdbaamlpaVFTDugHARiJMWHChMLCMcrKiUufurr6mA/v58ovOzu7oKBA70FC AW75Jop4i4oYfOzXt2/ffumlP9XvW7egYNSTTz6ZTL3cWhYKhS644AK325XoicRI JK7LLru8qqqq9ysij5Sy1HOi9d4Qttvt4v8D3d3JdI4QwVKE3sgq/Yl6vrd/p502 V2U7m93uaGxsVFYO6AcBGAkzY8Z0lfsMjRlT+Oqrr8Z2rEhuHR0d/byAG8LHw1O+ GtHnQm579+75wQ9+oMcMOXJkwYYNGzR1KZn0RD754Q9/2N7uTvREBk38/Pntb6+q qKiI/Cd7/GpN7w3h5EjCGZmHjTm0nnOa9nJvxPe//32V/5y9Xu/evfuUlQP6RwBG wqjfFWnZsuXnnXdebMf22Qh9rIyMDBEz2EC454Kms5NWZ605dqukpqbGs88+JxzW 0w4lhYWFjzzyKM/hqyeS5E9+cpGIKImeyCAEg6GFCxf07gWQlZ0tTjxZ3PjVpCOT sMPhCByii4Wjxak/knvFT6fe95WW32Mvvvji3Xffpawc+x5BawjASKTy8vLi4iJl 5YayInQ4HBY/vqN/vTgR5ufnp1oSJvdq37Bhw0aNGpWTk9P7lfb29u9859sulz66 W0tKSh566GE93rVODuKn6CWXXDyoH4YJlJ2dvXjxkshe7ukZGeIXIp9w41f7epNw 2j9vC0eSsHYWzRI/SCOhV/yv8J93etO0HXqPdMYZp6v8KWq12oxGo7JywIAIwEiw ysqpKrfYFbl0+/YPYju2o6NDpLvBHiVOkSIJR67AkpXX6+069BxXoieCaIlLHxGD I8uQph1KNT/60Y/27Nmt5V2+wuFwZWXV2rVrEz0RpP3617/+9NP9Gn+3lJSUXnXV VeKtLuaZk5tbVFQkkole8gl6HRmGxV+r3++3OxwiDIeCQZV5WLyR0nsib4b4f5F4 e394pukn9PY666yzQiF1f3Ti2unTT9UtNA1EQ7tnL6SOmppqlSvx/OAHFyxevDi2 Y61Wq4gKsR3b8+BZbq5Iwvo6Ux6PuPLwHBLzHwgSTlzRjR49uvcNef311z/99FPa XBZLvM2+8Y25Mf/LRdytXr361Vdf0eatePHT6aSTvvSDH/xA/Do7J6ekuJie56Rx VB6ONEuHjhAW/xvC88PiTD3s0KcmPf8n4m56+pjRo0XcPfLjHl2/l+65554XXtik rJz4xziUJUgBSQjASLyeTZFKS1UuxP/WW2/HtmCVOLmKDDz0OWQcasYTeVibYeN4 IqHX6/Vqpw8NQ3fk3eBt27b99re/0VqqObR9688uuODCRE8E/+LJJ5944IEHtPYw tni3XHzxJdXV1WJiJaWlOWzwm9SOzMNH6snGfr/T5QpHHPrSUa+JXHUMO6TnZ6B4 kxz69VEvS6b3T1dX17nnnqN236NWHv2FBhGAoQkTJ04cM2a0snJDeRi4vb29q6/T bcxE2BBJWFylHdlSpRGRfjPfIdzpTW7ifVhQUCDeh3a7/X//938dDq0sdCSuWlet WnXSSScleiLow44dO5YuXaqdVuicnNz58+f3POWelzeWx31T2/GycZ+SKeX2Q/Gj vw6Hs6GhQVk5IHqaOWsh5c2cOePIhXlkO+mkLz3wwAOxHTuURugBZWRkZP+T+htx gUCg+xASb2oaNmzYyJEj8/LyVq686c9//nPCOxSKiorvu+8+lcsEYLA6Ojouv/xy my0OrTFDEQwGv/zlL59//g8i0ZfHfYGjzJ8/v76+Tlk5cRWxZ89eZeWAQSEAQyvU N0I/9dTTlZWVMRwrrrRsNlvcp3Q84s9EXMZF9hXM+Kchjil+C4FDK2pG/r9bz5su QgaROVtaWi655JKOjvaETEC8M7/97e9cddVVCamOwbrzzjtfeGFTotqhRd0rr7xy 4qTJY8eOJfoCx/r8888vu+wXND8DEQRgaEhFRXlRkbpdkcQVdsxrM7jdbo/HE9/5 xCzyCFNksdPI6e3INHt4XRDyLQYvLy/v/vv/+MgjjyhuRhg+PP+2226bMmWKyqIY ooMHD86fP7+ra9BL5Q+F+DH+//7f/zv/ggu56wv047TT5qr8fMpmszU3s+8RtIsA DG2pqqqMbXmq2JSVlb344t9iO9ZisZAqkQr8fv+KFSu2b39fQUe0yDMXXHDBz372 c9mFIMkDD9z/5JNPKrjUDgaDkydP+fUVV5SXl/fsu070BY7jJz+5SOXe3Z2dnfv3 f6qsHBADAjA0R+WuSCLBrllz+9y5c2M4Vlypt7W1xX1KgDY1NjauXHnTwYMHJf3z FHmmpmbOtddeO3q0uvXwIIPT6bzhhhvq6mrlvVWKi4vnzV8wderUtJRZvgiIzRtv vHHTTTcqa35m3yPoAgEYmjNu3LiSkmKVP6xra2NcFsLlcnm93vjOB9Ayi6V19erV tbW1cbzFR/RNSjJicCAQmDhx0rz588vKysi9QDROP/00lTcVLBar2WxWUw6IGQEY WjR58qRRo0YpK5ebm/vOO+/GdiyN0EhB7e3tf/rTn1599RWv1xvz48HiH05GRuYp p5xyxRVXEH2TlYjB99xzz9tvvx0MBmL+WDMUCmVmZn796//5k4svHjFiBNEXiNJ3 v/sdv9+vrJzL5frss8+VlQNiRgCGRs2ePUvlJc7ll19+2WWXx3Bgd3e33a6VHVMB xZqbm++7797a2jqPpyvKmwyRD4wqK6suu+yyOXPmSJ4gtKK2tvYPf/jDp5/uTzu0 bl80hwSDways7Mqqyp9d+rMJEyeSe4FBefTRRx9//DFl5cTl0K5du5WVA4aCAAyN MvRsi1SirBE6FApt3/5BdnZ2DMc6nU6fzxf3KQE6Ii59tmzZ8sorrzQ0fN7R0SGi S2+PdGQRcpFkxo8f/5WvfOW73/2uysXeoTU2m+35559/7733mpqaurv9kRXsI98K BHruEufm5hoM48Rb5axvfWv48OFpPOULDJ74mfytb52lbAH/Q/seWVpaWtSUA4aI AAztmjBhfGFhocqKH330cWwH0ggNHMVoNO7evXvatKrx4yco3kUJOhIKhZqaGj/5 ZP+sWbNKSko6Ont2UYp89EnuBWJ25plnKLuFINjt9sbGJmXlgCEiAEPTZs6ckZOT o6zcaaed/rvf/S6GA/1+v8PhiPt8AAAABuXGG2986603lZXz+Xx79uxVVg4YOgIw NK2nD7q0VNmnmOFweOvWrUVFxTEcKwKwyqUmAAAAjmK3t1144YUqL5xaW1tbWlrV lAPiggAMrauoKFf5xOBQdkWiERoAACTQaafNjeM2dQOy2WzNzUZl5YC4IABDB6qq qvLzhysrN3v27MceezyGA2mEBgAAiXLllVfs379fWbnOzi6V5YB4IQBDH+bMqVG5 mOFTTz1dWVkZw7E0QgMAAPU+//zzyy77hcrtM2LumAMSiwAMfSgrKyspieXR3NgM pRG6tZUnYQAAgFKnn35alPuxx4XFYjWZTMrKAXFEAIZuTJkypaBgpLJykyZN3rhx YwwH0ggNAABUuvTSS43GZmXl3O72gwcPKisHxBcBGHpSXT1b2dIO4XD4wQcfOvHE E2M4lkZoAACgRn19/bx5Vytrfg4EAvX1u9TUAmQgAENPFO+KRCM0AADQOJXNz+x7 hCRAAIbOTJw4ccyY0crKlZSUbN68JYYDfT6f0+mM+3wAAAB6/fCHF9rtdmXlHA5n Q0ODsnKADARg6M+sWTOzs7PV1AqHw2vW3D537twYjqURGgAAyPPGG2/cdNONyjrj xFXN7t171NQC5CEAQ39ohAYAAKD5GYgBARi6NH58xdixY5WVKygoeO2112M4kEZo AAAgw3nnfa+zs1NZuba2tqYmdQtNA/IQgKFX06dPy8vLU1Zu2bLl5513XgwH0ggN AADi68UXX7z77ruUlfN4PPv2faKsHCAVARh6ZTCUlpSUpKenqylHIzQAANAIlc3P oVDIYrHQ/IykQQCGjpWXlxUXFysrl5ub984778RwII3QAAAgXr773e/6/T5l5axW q9FoUlYOkI0ADH2rrJw6YsQIZeWuuOLKSy+9NIYDaYQGAABD98QTTzz88EPKynV0 dHz66QFl5QAFCMDQvZqaapVdQDt31sZ2LI3QAABgiM4443SVz3/V1dWrqQUoQwCG 7o0bZygpKVG2K1JmZub27R/EcCCN0AAAYCjOOuusUCioplY4HLZYLGZzi5pygDIE YCSDyZMnjRo1Slm5iy666Oqr58VwII3QAAAgNn/4wx82bnxGWTmXy/XZZ58rKwco QwBGkpg9e1ZWVpaaWqFQaPv2D7Kzs2M4lkZoAAAwWN3d3d/61lnKmp9FuV27dqup BShGAEaSMBgMpaXqGqGFjz76OIajaIQGAACDdeaZZyi7yAmHw62tlpYWmp+RnAjA SB4TJ04cM2a0snJnn332ihXXx3AgjdAAACB6a9bc9vLLLysr53A4GxoalJUDFCMA I6nMmjUzts7kGITD4bfeejs/Pz+GY2mEBgAA0ejq6jr33HOU3f71+/27d+9RUwtI CAIwkkpPH3RpqcoeoY8/3hnDgeLs4nA44j4fAACQZM4444z0dJXNz60tLXxMj2RG AEaymTBhfGFhobJyp5566p13/j6GA2mEBgAA/bv22mvff/89ZeXsdntjY5OyckBC EICRhGbOnJGTk6OmVjgc3rp1a1FRcQzHWiwWcXjcpwQAAJKA3d524YUXKutr8/l8 e/bsVVMLSCACMJJQSUnJuHEGZSeMUCi0c2dtDAfSCA0AAI7n9NNPy8jIUFMrHA6b zS0Wi0VNOSCBCMBITuPHjx87Vl0j9CmnfG3t2rUxHOh0On0+X9znAwAAdG3p0qUf frhDWbm2NntTE83PSAkEYCStGTOm5+bmqqlFIzQAAIgXxc3PXq937959amoBCUcA RtJSvCJ0zI3Q3d3ddrs97vMBAAA6pbj5mZWfkVIIwEhmFRUVRUVjlZWjERoAAAyR 4uZnm62tublZWTkg4QjASHLTp0/Ly8tTU4tGaAAAMBSKm589Hs++fZ+oqQVoBAEY Sc5gKC0pKUlPT1dTjkZoAAAQM5XNz+KixWKx0PyMVEMARvIrLy8vLi5SVi7mRmiX y+X1euM+HwAAoAuKm5+tVpvRaFRWDtAIAjBSQlVVVX7+cDW1wuHwtm2vjR49OoZj aYQGACA1ud3u73//f5U1P3d2du3fv19NLUBTCMBIFXPm1Gi/EToQCLS1tcV9PgAA QOPOOON0lRcqtbV1amoBWkMARqooLy8rLo5learYnHrqqXfe+fsYDqQRGgCAVHPt tde+//57yspZrVaj0aSsHKApBGCkkMrKqSNGjFBTi0ZoAAAQDcXNzx0dHZ9+ekBN LUCDCMBILTU11SoXV6QRGgAA9E9l83MwGKyrq1dTC9AmAjBSS1nZuJKSEmXlvvGN uWvWrInhQBqhAQBIBTfccMPbb7+lrJzFYjGZzMrKARpEAEbKmTp1ysiRI9XUCofD b731dn5+fgzH0ggNAEBy6+rqOvfcc5Q1P7e3tx84cFBNLUCzCMBIRSoboUWI/fjj nTEc2N3dbbfb4z4fAACgETQ/A+oRgJGKxo0zlJSUKPvA9XvfO2/58uUxHOh0On0+ X9znAwAAEqi7u7uzq+u+e+/dtu0faiqGw2GLxWI2t6gpB2gZARgpavLkyaNGFaip Jc4677+/PTs7O4ZjaYQGACCZiPTrcDrNZvPCBfOVfRbvcrk/++wzNbUAjSMAI3VV V8/OzMxUU2vYsPQPP/wwhgNphAYAIGlE0m9rS8vVV1+dkaGo+TkQCNTX71JTC9A+ AjBSl8FgKC1V1wj9059eeuWVV8ZwII3QAAAkgcP3fk2mTZs2vfnmG2qKhsPh1lZL SwvNz8BhBGCkNJWN0DFvC5xGIzQAAHoWeejX7/OZTCZxQl+0aKGyta9ofgaOQgBG qlPZCJ2dnf3ee+/HcKDf73c4HHGfDwAAkC1y49dms/m8XvGfS5YsVlaa5mfgWARg pDrFjdBXXz3voosuiuFAEYBFDI77fAAAgDyHH/ptbQ10d4v/3LZt2+bNL6kpTfMz 0CcCMJA2ZcrkggIdNEKL02d8JwMAAOSJpN8WszkYDEa+orL52e12HzxI8zNwNAIw 0KO6ujozM0NNrREjRrzxxpsxHOj1el0uV9znAwAA4q4n/TockYd+I19ZvnxZIBBQ Uz0QCNbX16upBegLARjoMW6coaREXSP0ypWrzjrrrBgObGtrU3buBAAAMYgseeXz +UxGY+8Xd+zY8dRTf1UzARG5LRaL2UzzM9AHAjBwmMpG6GAwWFtbF9uxNEIDAKBZ kbZnq9Xq/9ctDBcuXJCRoajXjOZnoB8EYOALKhuhS0sNL70UyzIYnZ2dHR0dcZ8P AAAYosNLXrW0HNWudeONN3Z1daqZA83PQP8IwMAXVDZCh8Phxx57XETuGI612Wy9 y2kAAAAtiKRfs8kUCoWO/HpjY8O6deuUXV3Q/Az0jwAM/AuVjdCBQKCuLpbPaCOn t7jPBwAAxCDy0K/f5ztyyateCxbMz8zMVDMTmp+BARGAgaPV1FQre0pnxoyZTzzx RAwHtre3d3V1xX0+AABgUCI3fm02m8/rPfa7d9xxh8WiaPGOYDAY2wfrQEohAANH KysbV1JSoqZWOBz+29/+XlZWFsOxFovl2I+ZAQCAMocf+m1tDXR3H/tdu91+6623 KNtjQlwYmExmNbUA/SIAA32YOnXKyJEj1dQKhUI7d9bGcGAgEGhra4v7fAAAQDQi 6bfFbD7ewhwqm5/b29sPHDiophagawRgoG8qG6H/67/++4477ojhQKfT6fvXXRYA AIACkfTb89Dvvy551Wv9+vX793+iZjI0PwPRIwADfSsrKyspKVZTKxwOv/XW2/n5 +TEcy7bAAACoFFnyyufzmYzG473G6/WuWHGdwuZnq4jiamoBekcABo6rqqoytlAa k2EfffRRDId5PB632x332QAAgGP1v+RVr4ULF2ZkpKuZUmdn5/79n6qpBSQBAjDQ nzlzatLTFZ3ALrzwwoULF8VwINsCAwCgQP9LXvXauHHj+++/p2ZKoVCotrZOTS0g ORCAgf6Ul5cVFytqhI55NSy2BQYAQLZI+jWbzaGBPnRetGihsk/PrVar0UjzMzAI BGBgANOmVQ0fPlxNrezsnPfei+UzY7fb7fF44j4fAACQFkm/DkfPklcDbUC4dOkS ZZsUdnV1ffLJfjW1gKRBAAYGprIReuXKVWeddVYMB7ItMAAAcRfNkle9duzY8dRT f1UwqzSan4FYEYCBgVVUlBcVFampFQgE6+piOZ/5/X6HwxH3+QAAkLIibc9Wq9Uf 3aaDCxYsyMxUtIeizWZrbh44kwM4CgEYiMr06dPy8vLU1Bo/fvzzz2+K4UC73d7d 77IcAAAgSoeXvGppCQQC0bx+9eqbXS6X7FlFeDyeffsUbTIMJBkCMBAVg6FUULOh Xzgcfu655ydOnBjDsWwLDADA0EXSb4vZHOU+CxaL5fbb1yi7ThCn+5YWzvhALAjA QLTGjx8/dmyhmloxrwjd2dnZ0dER9/kAAJA6ol/yqteCBfMzMzOlzqpXW5u9qalJ TS0g+RCAgUGYOXNGTk6Omlr/9V//fccdd8RwIKthAQAQm0EtedVr/fr1+/crakgW c9uzZ6+aWkBSIgADg6C4Efr997dnZ2cP9kBWwwIAIAaRtmebzebzeqM/KhAILFt2 Dc3PgF4QgIHBmThx4pgxo9XUGjYs/cMPP4zhwLa2tihX7AAAAGm9S161tgYGuZzk woULMzIU7ZXocDgbGhrU1AKSFQEYGLTZs2dlZWWpqXXVVVddfPElMRzIalgAAERp sEte9frHP17dsmWLpFkdRUxy167damoBSYwADAyaykZocSaObZt7t9vt8XjiPh8A AJJMJP2aTaZQKDTYYxcuXJCRoWLjX5qfgXghAAOxmDJlckFBgZpaY8YUvvrqqzEc yE1gAAD6F8OCz71WrFjh8w3iaeGhcLvdBw9+pqYWkNwIwECMamqqlX3o+9hjj1dX Vw/2QK/X63K5ZEwJAAC9i23B516NjQ3r1q1T1g5WV1evoBCQCgjAQIzKysaVlJSo qRVzI7TVao2hoQsAgOQW24LPR1K58a/FYjGZzGpqAUmPAAzErrKycsSIfDW1Tjnl a2vXrh3sUSI5i7O7jPkAAKBTMS/43Ov++/948ODB+M7qeDo6Oj/99FM1tYBUQAAG hmTOnJr0dBWbH8S8LbDD4fD7/TKmBACA7hxe8LmlJRjrfoEqN/4NhUKxtYABOB4C MDAkFRXlRUVFamqJpL1jRyzbArMaFgAAaUNb8LnXokUL1Xz2LdhstubmWB5RBnA8 BGBgqKZPn56Xl6um1pIlS88///zBHtXe3t7V1SVjPgAA6MVQFnzu9dZbb73wwqY4 zqofHo933759amoBqYMADAyVLrYF5iYwACBlDXHB5yOx8S+gdwRgIA4mTBhfWFio plZFRcWmTS8M9qiurq729nYZ8wEAQMuGvuBzr5tvXuV2u+MyqwHZ7fbGxiY1tYCU QgAG4mP27FlZWVkKCoXD4eeee37ixImDPdBisQyl6QsAAN2JpF9xBuwe8nqQIvqu WrVSTcNXIBC02azc/gVkIAAD8WHo6YQu0XIjtM/nczqdMuYDAIAGDX27oyMpa34W rFabccjd2gD6RAAG4mby5MmjRhWoqXX22WevWHH9YI+y2WwiPMuYDwAAmjL07Y6O 9OKLL7755htDHycanZ2dLpfbYrGoKQekGgIwEE81NdVqPh4OhUI7d9YO9qhAINDW 1iZjPgAAaEdctjs6krKtj8SELRaryO0KagGpiQAMxFNZWVlJSbGaWjk5ue++++5g j7Lb7d3x6AQDAECbIunXZDTGa+WLa69druzU2dYmTtN+nv4F5CEAA3FWVVWVnz9c Ta116+49+eSTB3WIuBqgqwoAkKwim/0aTaa0OKVfo9F49913qVnjw+v1Onvatkm/ gEQEYCD+5sypUdMoFQgE6urqB3uUOLn6fD4Z8wEAIIFE+rU7HEPf7PdICxbMz8zM jOOAxxMOh61Wq8lkVlALSGUEYCD+xo+vGDt2rJpap5zytbVr1w72qNZWPl0GACQP EX07u7p8Pl980+8TT2yorR30ihuxcTqdXq+X27+AbARgQIqZM2fk5OQoKBQOh99/ f3t2dvagjnK73R6PR9KUAABQKfLQr9Vq9ce1vykYDC5dukRNS5f4LbS12Vn7ClCA AAxI0bMrcGmpmkeGsrKy33///cEexU1gAEASiO9mv0datuwaZXsHivRuNJrU1AJS HAEYkGXy5EmjRo1SU+u229bMnTt3UIe0t7d3dXVJmg8AAAocTr8tLYF4bPZ7pIaG hnvvXafmg+yOjg63u50lKgE1CMCARMq2BQ4Gg7W1dYM9ipvAAAD9iqTflpaWYLzT r7Bw4QI1Z3A2/gUUIwADEqncFvikk770wAMPDOqQjo6Ozs5OSfMBAECeSPo1m80h CV3Kjzzy8J49e+I+bJ/a2uzt7W6n06WmHAACMCDXtGlVw4er2BY4ttWwuAkMANCd w+nXZAqFQnEfXOXaVz6fz+FwsPIzoBIBGJBL5WpYGRkZH3ywY1CHcBMYAKAvkfRr MhrD4bCM8ZcuXRoOxz9XH4uNf4GEIAAD0k2YML6wsFBNrZUrV5111lmDOoSbwAAA vehJvw6HyWSSlH4PHDjwwAP3yxj5WC6Xy+PxcPsXUIwADKgwe/asrKwsBYUCgUBd Xf2gDmE5aACALkTSr9FkSpOTfoUFC+ZnZmZKGvxIgUDQZrOSfgH1CMCACioboU84 4YSHHnp4UIdwExgAoHGH06/RKK/E+vV/2r9/v7zxj2Sz2ZqbJf5eABwPARhQZMqU KQUFIxUUimE1LLfb7fF45E0JAIChEOnX7nCYZKZflWtfdXV1iTMvt3+BhCAAA+rM mVOj5syalZUlMvCgDuEmMABAmxSkX2HZsmXBYPz3Ez5WOBy2WCxmMxv/AolBAAbU KS8vLy4uUlNr3bp7Tz755Ohf73Q6fT6fvPkAADBYIvp2dnWJ05Ps9Gs0Gu+++y41 Tyo5HI6Ojo62NruCWgCORQAGlJoxY3pubq6CQsFgsLa2blCHcBMYAKAdke2ObDab z+uVXWv+/Hlq1qoUv6m2tjaan4EEIgADSqlcDevMM89cvfqW6F9vt9vFiVnefAAA iFIk/Voslm6/X3at55577t1335FdJcJqtRqNJjW1APSJAAyoNnnypFGjRikoFAqF du6sjf71wWDQZrPJmw8AANFQmX6FhQsXZGRkKCjU2dnpcrnF70tBLQDHQwAGEqCm plrNuXb06NH/+Me26F8vArCIwdKmAwDAABSn35Urb+ro6FBQKBQKWSzWlhbWvgIS jAAMJEB5eVlxcbGCQuFw+Lnnnp84cWKUr+9ZadPOshwAgMRQnH7dbveqVSvVPJck Tq+dnZ2sfQUkHAEYSAxlq2ENthFaXHaI2CxvPgAA9Elx+k3raX5emJGhYntC1r4C tIMADCSGytWwfv7zX/zqV7+K8sUej8ftdkudDwAAR1Gfft9+++1Nm55XU4u1rwDt IAADCTNp0qTRo1WshjXYLZHYDwkAoJL69CssWDA/MzNTQaGOjg63222xWBXUAjAg AjCQSMpWw5o4cdKzzz4b5Yvb29u7urqkzgcAgIjD6be1VeVWfHfd9Xuz2aygEGtf AVpDAAYSSeVqWG+99XZ+fn6Ur+cmMABAgUj6FSedgML0293tX758ubK1r9xut9Pp UlALQDQIwECCTZ8+PS9PxWpYGRkZH3ywI8oXOxwOv8I+NABACkrIvV9h6dKl4XBI QSHWvgI0iAAMJFhJScm4cQY1n0P/8Y/3/8d//Ec0rwwEAuKcLXs+AICUlZDnfgWT yXTXXb9XcNoNh8NWq02Uk10IwKAQgIHEmzRp4ujRoxUUGtRqWFarNRRS8QE5ACDV JCr9pqld+0rg9i+gNQRgQBOUrYZ10UUXXX31vGheyX5IAABJnC6XyWTyeb2K627b 9o/NmzcrKHRo7SsL6RfQIAIwoAnl5eXFxUUKCg3qJjBLYQEA4q67u9vucJiMRvWl FyxYkJmp4uNmh8PR0dHR1mZXUAvAoBCAAa2YOXNGTk6OgkJTp0596qmno3ml2+32 eDyy5wMASB0JTL9r165tbm5SUCgQCNhsNm7/AtpEAAa0wmAoFdQsy/H++9uzs7Oj eTE3gQEA8ZLA9BsMBq+5ZqmaJSetVqsoRwAGtIkADGjI1KlTRo4cqaCQSL/vvfd+ NK+02WziLC57PgCApNez8JXDYUxE+hWWL18WCAQUFPJ4POK3abFYFdQCEAMCMKAt c+bUpKenKyj06KOPVVdXD/gyn8/ndDoVzAcAkMQSm34tFsvtt69R02MlapnNLbIL AYgZARjQlvHjK8aOHaugUCgU2rmzNppX0gUNABiKxKZfYeHCBWq2WnC5XG63m7Wv AC0jAAOaM3v2rKysLAWFfv7zX/zqV78a8GUshQUAiFlky1+T0RgOhxMygbfffnvT pucVFAoGg1arraWF27+AphGAAc0x9ChVUCj6LZG4CQwAiMHh9GsyhUOhRM1B2e1f m80WCARY+wrQOAIwoEVVVZX5+fkKCp144r+vX79+wJexFBYAYLAi6ddsMoUSl34f fPDBTz7Zp6CQz+dra7NbLBYFtQAMBQEY0CKVWyJ9/PHOAV/m9XpdLpfsyQAAkkYk /baYzYn9/HTRooUKlpYUJ1Or1WoymWUXAjB0BGBAoyZOnDBmzBgFhQoLx77yyisD vowuaABAlCLpt7WlRc3OQ8ezevVql0vFRgbt7e2dnZ00PwO6QAAGtKumplrBY0vh cPitt94esOPa6XT6fD7ZkwEA6N3h9NvaGujuTug0/MuXL1fQSxUKhSwWC+kX0AsC MKBd5eVlxcXFCgqJmP3BBzv6f00gEGhra1MwGQCAfkXSrwiE3X5/YmdyzTXXhEIq uq8dDkdHRwdbHwF6QQAGNG3WrJnZ2dkKCj366GPV1dX9v0Zc0CRqEwsAgC44XS6T yeTzehM7DXHCuv32NQpu/wYCAZvNxu1fQEcIwICmGQylBoNBQaFQKLRzZ23/r+no 6Ojs7FQwGQCAHnV3d9sdDpPRmOiJpC1YsCAzk62PAPSBAAxonbItkRYuXHThhRf2 /xqWwgIA9Kmn+dnhMGog/X700Ud/+cufFRQ6tPVRm8ViVVALQLwQgAGtU7YlUjAY rK2t6/81bAgMADhW5NFfk9GohSdlFi5coGYJSbY+AvSIAAzowKRJE0ePHq2g0Jln nrl69S39vIANgQEAR4mkX7PZHNLAJ6TPPrvxvffeU1Co4xCanwHdIQAD+qBmS6Ro ngSmCxoA0EsjW/72Unb7V5wNSb+AHhGAAX2oqCgvKipSUGjy5CnPPPNMPy9gQ2AA QIR2Nj2KWLv2nubmZgWFHA6nyyXOh7REAfpDAAZ0Q82WSOFw+OOPd/bzAjYEBgBE aGTTo16LFi1MT0+XXSUYDFqtVm7/AjpFAAZ0w9CjVEGhESNGvvHGG/28gC5oAIB2 ln2OuPHGG7u6VOzVZ7O1BQLdBGBApwjAgJ5Mm1Y1fPhw2VXC4fBbb73dz95Lbrfb 4/HIngYAQLM0texzWs98/MuXL1ewY4Lf77fZbGx9BOgXARjQE2VbImVmZm3fvv14 3w2FQlYr534ASFGHl302mcTpINFzOWzZsmXBoIpVuET0DYWC3P4F9IsADOjMlCmT CwoKZFcJh8PPPff8xIkTj/cCi8WikU/9AQAqRdJvS0tLUBvLPqcd6ktatWqlgk+H u7q6RC3SL6BrBGBAf+bMqVGwyIeItx9//PHxvtvR0dHZqeJRKwCApjhdLqPR6NfS dgBLlixWUOXQ1kcWkfwV1AIgDwEY0J8JEyYUFo5RUGj9+gdPPPHEPr8lrgMsFouC OQAAtKO7u9vucJg0s/CVYDabf//7OxXc/nW72+32NrY+AvSOAAzoUk1NdUZGhuwq wWCwtrbueN+1Wq3aefoLACCb1pZ9jliwYEFmpvQTojjfWSxWbv8CSYAADOhSRUV5 UVGRgkIrVlx/9tln9/mtzs7Ojo4OBXMAACTc4WWfTaawlj763L1796OPPqKgkMPh 9Pm8PP0LJAECMKBXs2fPysrKkl2l/5vAbAgMAKlAgwtfRcyfP0/NqdBqtZJ+geRA AAb0aty4nj2RFBT66U8vvfLKK/v8Fl3QAJAKNLjwlfD666/9/e9/V1Cora2tu7ub AAwkBwIwoGPTp0/Py8uVXSUQCNbV9X0T2OPxuN1u2RMAACSQBhe+iliwYH5mZqbs KuK3b7VaLRar7EIA1CAAAzpm6LkHXKpg6cszzzxz9epb+vwWXdAAkMQOP/prNGpt 7/eNGze+//57CgqJ9BsMBrn9CyQNAjCgb5WVU0eMGCG7Sj9PAttsNvFd2RMAAKgX Sb9mszmkvZ/zam7/er1eZ8/Dz6RfIHkQgAHdO+GEOQpuAp9yytfWrl177NfpggaA ZKXNR3+FDRs21NXVyq4S2fHebGbrIyCpEIAB3Zs0aeLo0aNlVwmFQjt39n21QRc0 ACQfbe76G7Fw4YKMDOl7/3Z2dra3t3P7F0gyBGAgGcyZU5Oeni67ykknfemBBx44 9ut0QQNAktHso7/Cww8/vHfvHtlVxG+8tbWV9AskHwIwkAwmTJhQWDhGdpXj3QTu 6upqb2+XXR0AoIaWH/1NU3X71+1u7+rqJAADyYcADCSJmppqBRcEJ5747+vXrz/2 63RBA0DS0Oyjv4I4B+3f/4nsKodu/1paWnj6F0hCBGAgSYwfXzF27FjZVY53E9hq tYpvya4OAJBNy4/+pqm6/etyuTweD7d/gaREAAaSR3X1bAV7QlRXVz/66GNHfbGz s7Ojo0N2aQCAVFp+9Fd44IH7Dxw4ILtKKBSyWCykXyBZEYCB5FFeXl5cXCS7yvFu AtMFDQC6Fkm/rS0tgUAg0XPpm5rbvw6Hw+fzEYCBZEUABpLK7NmzsrKyZFeZMWPm E088cdQXLRaLNu8YAACi4XS5TCaTz+tN9ET69oc/3Pf555/LrhIMBq1WK+kXSGIE YCCplJWNKykpkV2lz5vAHR0dnZ2dsksDAGSI3P7tefRXkx9livPO4sWLFNz+tdvt fr+fAAwkMQIwkGxmzpyRk5Mju8qxN4HD4bDFYpFdFwAQd5H022I2a3ZTdzW3fwOB oMXSarFYZRcCkEAEYCDZGAylBoNBdpU+bwLTBQ0AeqTx5mdxxlmyZHF6errsQjab LRAIcPsXSG4EYCAJzZgxPTc3V3aVyZOnPPPMM0d+pb29vaurS3ZdAEAcHW5+bm5O 9ESO65577jEapU9P/Dm0tbWRfoGkRwAGkpDBUCoMGyb3H/ixN4GDwaDNZpNaFAAQ R5H0azabQ1ptflb29K/VagsGuf0LJD8CMJCcpk+flpeXJ7vKCSec8NBDDx/5FTZD AgAd0Xjzs7B+/Z/2798vu4rf77fb7aRfIBUQgIHklKibwE6n0+fzSS0KAIgL7Tc/ K7z9aw0GgwRgIBUQgIGkNW1a1fDhw2VX+frXv3733ff0/qe4nLLb7bKLAgCGSPsr PwuPP/5YfX297Crc/gVSCgEYSFpqbgKLK6fa2rojv0IXNABon/abn8X5ZcmSxdz+ BRBfBGAgmam5CXz22WevWHF973/a7fbu7m7ZRQEAMdN+87Pw/PPPvfPOO7Kr+P3+ 3bv3yK4CQDsIwEAyKykpGTfOIPsmcCAQrKv74iaw1+t1uVxSKwIAYna4+bmlJRgI JHouxxUMBhcvXpSZmSm7kMViDYW4/QukEAIwkOSqqirz8/NlV7n44kuuuuqq3v+k CxoANMvpcpnNZq/Hk+iJ9Gfr1q2vvLJVdhWfz7dnz17ZVQBoCgEYSHIJeRLYZrNp eVUVAEhZkdu/JqMxHA4nei7Hxe1fAPIQgIHkp+Ym8NVXz7vooosiv+7q6mpvb5dd EQAwWE6Xy2g0+rW9X92777773HPPyq7C7V8gNRGAgeSXkJvAdEEDgNb03P51OEQA TvRE+hMKhRYtWqjm9q/JZJJdBYDWEICBlFBZWTlihPSbwCtXrjrrrLMiv7ZYLFru rwOAVBNpfjabzSFtP6JSX1//+OOPya7C7V8gZRGAgZSg5iZwKBTaubM28uv29vau ri6p5QAA0dP+xr9ph84jixcvUrD3r8ViMZnMsqsA0CACMJAq1NwEfvTRx6qrq9MO dUTbbDbZ5QAA0dDF2ldCU1PTunVrZVfh9i+QygjAQKpQcxNY+OijjyO/4DFgANAI Xax9FQqFli5douA8ZbFYRC0WfwZSEwEYSCHTplUNHz5caolwOLxt22ujR48Wv3Y4 HH6/X2o5AMCAIrd/jc3NiZ7IANxu96pVK2UHYHFi2r17j9QSALSMAAykEDU3gXNz c9955920Qz1mTqdTai0AQP8i6bfFbNb49uyhUOjGG2/0ej2yC1mtVqORxZ+B1EUA BlLL9OnT8vLypJYIh8Mff7wz8mu6oAEgsZwul9ls9nqkB8sh6u72L1++XPZHtN3d 3bt27ZZaAoDGEYCB1GIwlBoMBtlVKioqNm16QfzCZrNp/J4DACSxw1sfmUyhUCjR cxnA7bffbrVaZFexWm0a3wYZgGwEYCDlzJgxPTc3V2qJ3v2Qurq62tvbpdYCAByP LrY+Sjt0+/eaa66RvftRIBCor98ltQQA7SMAAylHzU3gU0899c47f59GFzQAJIhe tj4SNmzYUFdXK7uKzWZrbub2L5DqCMBAKpo5c0ZOTo7UEsFgsLa2Lu3QbhPav/YC gOSji62P0g7dmF2yZHFmZqbUKuKsZLVa2foIAAEYSEXjxo0rLS2RXeXyyy+/7LLL 3W63R/OLrwBAktHL1kfCtm3bNm9+SXaVtra2piYd/GkAkI0ADKSoWbNmZmdnSy0R uQkcCATEZYfUQgCAo3D790jc/gXQiwAMpKiysrKSkmLZVdatu/fkk0/mMWAAUElH t3/37dv30EMPyq5it9sbG5tkVwGgCwRgIHXNnj0rKytLaonIctDiykNcjUktBADo 1XP7t7nZ7/cneiIDEOeIpUuXyN77V1SxWCzc/gUQQQAGUldFRXlRUZHUEuFweNu2 13Jzc10ul9RCAIAIHd3+dTgct9yyWnYAdjicDQ0NUksA0BECMJDSamqqZe+7mJ8/ 4s0336QLGgDUcLpczc3N3Xq4/bty5U1dXV1Sq4TDYbO5xWKxSK0CQEcIwEBKmzBh fGFhodQS4uLj4493Wq1Wca0jtRAAQEe3f71e73XXXZueni61Snt7+4EDB6WWAKAv BGAg1c2ZUyP7+uOrX/3q7353W2dnp9QqAAC93P4VHn744b1790gtEQ6HW1stLS0t UqsA0BcCMJDqpkyZXFBQILVEIBDcubPnJrDUKgCQ4nR0+7e727906VLZux91dXV9 8sl+qSUA6A4BGEDaCSfMkb0GybJly7/+9a9LLQEAKU5Ht3/fe+/dZ599VnaV1tZW s5nbvwD+BQEYQFpVVWV+fr7UEqFQ6LXXXvf5fFKrAEDK0tHtX3FGWLx4kewlGMUZ Z8+evVJLANAjAjCANIOhVJB9E3jz5i3hcFhqCQBIWTq6/Wu322+99RbZJx2r1Wo0 mqSWAKBHBGAAPWbMmJ6bmyu1xPDhw595ZqPUEgCQmvR1+/fGG2/wer1SqwQCgfr6 XVJLANApAjCAHoYepVJLhMPhrVtfCQaDUqsAQArS0e1fj8ezYsV1sncfsNnamvXw cQAA9QjAAA6bPXtWVlaW5BLVa9askVoCAFKNjm7/CuvX/2n/frkrMweDwbq6eqkl AOgXARjAYeXlZcXFxVJLiIuSl1/eKrUEAKQap8tlNBr9elhl0OfzLVt2jezdjxwO R0NDo9QSAPSLAAzgCzU11bKX5bz88l+ec845UksAQOo4fPvXaEzTwyqDb7755osv viC1RDgcNpvNFgs7zwPoGwEYwBcmTpwwZswYqSVCodCWLS9LLQEAqcPpcplMJp/k NaXiIhAIXHPNUtlP/7a3tx84cFBqCQC6RgAG8C9OOGGO1K0pwuHwCy+8KPthYwBI BZHbvyajURebzLlczptvvln2Kaa1tbWlpVVeCQB6RwAG8C8qKytHjMiXWmLMmDFP PPGk1BIAkAqcLpfZbPZ6PImeSFRuvfVWh8MutYTP59uzZ6/UEgD0jgAM4F8YDKUG g0FqCbqgAWDoIrd/zSaT+KGa6LkMzOv1XnvtctnLTFitVqPRJLUEAL0jAAM42syZ M3JycqSW+OlPLz3//POllgCA5Kav27/btm3bvPklqSUCgWB9PbsfARgAARjA0crK ykpK2A8JADRNBODm5uZuvz/RExlYKBRavHiR7Nu/dru9sbFJagkASYAADKAPsvdD CofDGzc+O3z4cHklACCJHd79qLk50ROJioimt956C8tfAdACAjCAPkyYMKGwUO5+ SKNGjfrzn/8itQQAJCuny2U0Gv0+X6InEpVbblntdDqllmD3IwBRIgAD6Jvs/ZBY CgsAYqOv3Y88Hs91110ru6uotdXS0tIirwSApEEABtC3ysqpI0aMkFriRz/68UUX XSS1BAAkH6fLZTKbfTpZ/mrr1q2vvCJ30Qev17t37z6pJQAkDQIwgL6VlJSMG2eQ ehM4EAiI6yJ54wNAUhIBuKmxUfwITfREBhYKhRYtWpSZKXf5K4vFajKx+xGAqBCA ARyX7P2QWAoLAAZLX8tftbW1/e53t8r+LLW+fpe88QEkGQIwgONSsB9SQUHBX/7y V6klACCZ6Gj3I2HVqlXt7W6pJdj9CMCgEIAB9Ef2fkgshQUA0Tt8+9doTNPD8ldd XV0rVlwnf/krdj8CMAgEYAD9mTx50qhRo6SWuPzyX55zzjlSSwBAcuhZ/spk8nm9 iZ5IVF5//bW///3vUkt0dnbu3/+p1BIAkgwBGEB/DIZSgf2QAEAL9LX81ZIli9PT 06VWaW21mM1mqSUAJBkCMIABzJgxPTc3V9744XB48+Yt8sYHgOSgr+Wv3G73qlUr Wf4KgNYQgAEMQMFSWFVVVXfffY/UEgCgd06XS6Rfv06Wv7rvvnsbGhqklmD5KwAx IAADGJjspbCCweDLL2+VNz4A6F3k9q/JaAzrYfkrn8+3bNk1mZmZ8kqw/BWA2BCA AQxssvylsO677w+TJk2SWgIA9MvpcpnNZq/Hk+iJROXAgQMPPHC/1BIsfwUgNgRg AFE54YQ5Uh/lys7Oef755+WNDwC61rP8VVNToLs70ROJyooVK3w+uUtVt7a2ms0t UksASEoEYABRkb0UFmtBA8Dx6Gv5q46OjhtuuF7qgzMsfwUgZgRgAFEpKxtXUlIi tQQbAgNAn/S1/e+2bds2b35JagmWvwIQMwIwgGjJXgqLm8AA0CcRgBsbG4M62f53 6dIlUh+ZYfkrAENBAAYQrcmSl8JiQ2AAOJa++p9dLufNN98sNQCz/BWAoSAAA4iW wVAqSL2s+dKXvnTTTSvljQ8AutOz/a/R6Pf5Ej2RqDz88MN79+6RWoLlrwAMBQEY wCDMnDkjJydH3vhsCAwAR9LX9r9itkuXLpG6/W8gEKyvr5c3PoCkRwAGMAjl5eXF xUXyxhdXeC+88GJWVpa8EgCgI/ra/tdisdx++xqpjUIOh7OhoUHe+ACSHgEYwODM mVOTnp4ub/yysvL169fLGx8AdKSn/7m52e/3J3oiUbnjjjssFolrU4XDYbO5RcRs eSUAJD0CMIDBqaysHDEiX974gUBg69ZX5I0PAHqhr/5nr9e7fPkyqf3PosTevfvk jQ8gFRCAAQyOwVBqMBikltiwYUNh4VipJQBA+/TV/9zY2LBu3Tqp/c9Wq81oNMob H0AqIAADGLTq6tlSP+MfObLgr3/9q7zxAUAXRABubm7u1kn/86pVK9vb2+WNHwqF amvr5I0PIEUQgAEM2qRJE0ePHi1vfNaCBgB99T93dnZef/2KjIwMeSU6Ojo+/fSA vPEBpAgCMIBBU7Ah8D33rK2srJQ3PgBonL76n/fu3fvwww9JLcH2vwDiggAMIBaz Zs3Mzs6WN35ubt6zzz4rb3wA0Dh99T/fcMP1HplZPRgM1tWx/S+AOCAAA4hFRUVF UZHEdaroggaQynTX/7xixXVS14ZwOl2ff/65vPEBpA4CMIAYnXDCHKld0Hfe+fsZ M2bIGx8ANEtf/c+7d+9+9NFH5I0fDodbW1tbWiTuMAwgdRCAAcRo+vRpeXl58sbP ycl97rnn5I0PAJqlr/7nFStW+HxeeeN3d3fv2rVb3vgAUgoBGECMysrKSkqK5Y1P FzSAlCUCcGNDg/gxmOiJDEzB+s92u72xsUne+ABSCgEYQOzmzKlJT0+XNz5d0ABS UOQBYGNzc6InEpX6+vrHH39M3vj0PwOILwIwgNhNm1Y1fPhweeOzFjSAFOR0uYxG o9/nS/REonL99Su8Xon9zz6fb8+evfLGB5BqCMAAYjduXM+OwPLGpwsaQArq6X9u bAwGAomeyMAU9D/bbG3NOrkZDkAXCMAAhkR2F/SGDRsKCyXutwQAmqKv/ucDBw48 8MD98sYPh8M7d9bKGx9ACiIAAxiSysqpI0aMkDd+YWHhhg1PyBsfADTF6XKZTCaf zKbiOLrlllucToe88b1e7969++SNDyAFEYABDInBUGowGOSNHwgEtm59Rd74AKAp IgA3NTUFursTPZGBeTyea69dnpmZKa+E1WozGo3yxgeQggjAAIaqpqZa6gNgmza9 kJWVJW98ANAIffU/m0ymu+76/bBhsi4m6X8GIAMBGMBQTZ06deRIiV3QEydO+sMf /iBvfADQCKfLZTabvR5PoicSlbvvvktkYHnjezyeffs+kTc+gNREAAYwVIYerAUN AEMlAnBzc3O335/oiQzM5/MtW3YN/c8AdIcADCAOpHZBh8PhzZu3SBocALSjZwOk hoZgMJjoiQzMZrPedttt9D8D0B0CMIA4kL0W9Le//Z0rrrhC3vgAkHD6egD46aef /uCD7fLGp/8ZgCQEYABxIHst6FAovGULN4EBJDOny2U0Gv0+X6InMrBQKLR06RJ5 t3/T6H8GIA0BGEB8zJlTk56eLmlwcbG1ZcvLkgYHAC3o2QCpsTEQCCR6IgNzOByr V98s72c+/c8A5CEAA4iPqqqq/Pzh8sZfuXLVSSedJG98AEggffU/b9++/ZlnnpY3 vs/n27Nnr7zxAaQyAjCA+CgrG1dSUiJv/Ly8vI0bn5U3PgAkkL42QFqxYoXP55U3 fltbW1OTPj4LAKA7BGAAcXPCCXPkPRLGZkgAkpiONkDq7Oy8/voVUlf+b21tbWlp lTQ+gBRHAAYQN9OnT8/Ly5U3/qZNL2RlZckbHwASRUcbIImgfs89d8v7uNPv9+/e vUfS4ABAAAYQNxUV5UVFRfLGnzPnhFtvvVXe+ACQEPp6APj+++8/ePCAvPEdDkdD Q6O88QGkOAIwgHiS2gXNWtAAkpLT5TKZTD6vxKdq40Vk9WuuWUr/MwD9IgADiKdZ s2ZmZ2dLGlxcGG3ezG7AAJKNjh4Abmtru/XWW+RtgBQMBuvq6iUNDgBpBGAA8TVx 4sQxY0bLG//662/4yle+Im98AFBPRw8Av/3225s2PS9v/Pb29gMHDsobHwAIwADi yWAoNRgM8sZnMyQASUZfDwDL3gCptbXVbG6RNz4AEIABxFlNTbW8x8MCgcDWra9I GhwA1NPRA8CdnZ0rVlyXmZkpafxQKFRbWydpcACIIAADiLPKyqkjRoyQNDiPAQNI Mj0PADc1dXd3J3oiAxNB/a67fi9vpUOPx7Nv3yeSBgeACAIwgDgbN85QWloqb/xv f/s7V1xxhbzxAUCZSP+zyWgMh8OJnsvA/vrXv3744Q5549tsbc06aQUHoF8EYADx J3UzJOGllzbLGxwAlHG6XGaz2evxJHoiAwuFQkuXLpH3s50NkACoQQAGEH8zZ87I ycmRNDi7AQNIGjp6ANjtdt90043ylnjo7u7etWu3pMEBoBcBGED8TZgwvrCwUN74 zzyzcfjw4fLGBwA1RABuamoK6OEB4IMHD95//x/lje9yuT777HN54wNABAEYgBT/ 9m8nyBt89uzZa9bcLm98AFBDBOCGhoaQHnYAvvfedY2NjfLGb+lB/zMA6QjAAKSQ uhkSXdAAkoCOdgAWU73mmqVSf6qzARIANQjAAKSoqqrMz8+XNDgBGEAS0NEDwHa7 ffXqm+UFYDZAAqAMARiAFGVlZSUlxfLG/8tf/lpQUCBvfACQrWcH4Obmbr8/0RMZ 2CeffPLgg+vljd/WZm9qapI3PgD0IgADkEXqZkhVVVV3332PpMEBQAERgBsbGoJ6 eAD4nnvuNhqNkgZnAyQAKhGAAcgye/asrKwsSYPTBQ1A13T0ALDf77/mmmsyM2X1 PweDwbq6ekmDA8BRCMAAZJkyZbK8LmUCMABdc7pcZrPZ6/EkeiIDa2tru/XWW9LT 0yWN39nZuX//p5IGB4CjEIAByGLoUSpvfHYDBqBfOnoAeP/+/evX/0ne+FarTV5/ NQAchQAMQCKpjwFXV9fcdtttkgYHAKlEAG5qbAwEAomeyMDuu+/ehoYGSYOHw+Gd O2slDQ4AxyIAA5Bo1qyZ2dnZkgYPhcJbtmyRNDgAyKOjB4DFVJctu0Ze/3MgEKiv 3yVpcAA4FgEYgESTJ08aNWqUpMGDweDLL2+VNDgAyKOjB4CdTueqVSvl7QDc3t5x 4MABSYMDwLEIwAAkMhhKDQaDvPFfemmzvMEBQBIRgE0mk8/rTfREBtbY2LBu3Tp5 D7NYrVaj0SRpcAA4FgEYgFzV1bMzMzMlDX7JJZdccMGFkgYHAEl0tALWhg0b6upk PaPLA8AA1CMAA5CrqqoqP1/WWs2FhWPFxZmkwQFAEhGAGxsagsFgoicysBtvvLGr q1PS4J2dXfv375c0OAD0iQAMQK4JE8YXFhZKGpzdgAHojo5WwBIWLlwg7wFgu93e 2NgkaXAA6BMBGIBcUh8DZh0sALqjoxWw0iQH4JYerZIGB4A+EYABSFdTUy3v+unB Bx8aN26cpMEBIO5EADYajX6fL9ETGVhbW9ttt/1O0uDBYLCurl7S4ABwPARgANJN nz4tLy9P0uBf+cpXr7/+ekmDA0DciQDc1NQU6O5O9EQGtn79+v37P5E0uMfj2bdP 1uAAcDwEYADSTZw4YcyYMZIGz87Ofv75TZIGB4C409EKWEuXLgmHw5IGdzgcDQ2N kgYHgOMhAAOQjseAASCCFbB68QAwgIQgAANQYc6cmvT0dBkjh8PhzZu3yBgZAOJO XytgLV68aNgwKdeKoVCotrZOxsgA0D8CMAAVZs6ckZOTI2nw+fPnn3ba6ZIGB4A4 0tEKWB98sP3pp5+WNLjP59uzZ6+kwQGgHwRgACpMmTKloGCkpMErKioeeOBPkgYH gDjS0QpYt956i8PhkDS4291+8OBBSYMDQD8IwABUqKgoLyoqkjf+Sy9tljc4AMSL jlbAkvoAsM1ma242ShocAPpBAAaggsFQKkh6lox1sADoAitgRYTD4dbWVlbAApAQ BGAAilRXz87MzJQxsriW2rjx2eHDh8sYHADiRUcrYHm93hUrrpP0qWUgEKiv3yVj ZAAYEAEYgCLTp0/7/+3dCXhc1Z3nfbtUUmnfLFuyFkveZBskGQbm9fA8k6GhJ29C JzTwkicDTYcw0CymQxMClhcWY4LZwhoYzBIIAdNmCLRpHMCyTYCkJ3l4GzpYkjd5 U0lVWmxZVdpVVbeq5qgKC2FslSzVv+6tut/PkyiyLX73GEd1z8/n1jlpaWlC4Rdd 9De33nqrUDgARIUqwG1tbZ7hYb0HEtlbb/32888/FwofGhrat69JKBwAxkcBBhAj FRXlubm5QuF5eXmbNr0hFA4AUaEKsMPh8Hm9eg8ksvvuu29oaFAo3O12NzfbhcIB YHwUYAAxUlw8e9asWULhgUBg27btQuEAEBUjO2C1tPg1Te+BRCa6A9aRI0fa2tqF wgFgfBRgALGzdGkN+2ABMCd2wAoLBoM7d9ZLJAPARFCAAcROdXWV3IzqvffeF9pk CwCmLo52wPL7/XfeuUbu7ysbGholkgFgIijAAGJnwYL5mZmZQuHXXHPNFVdcKRQO AFM0sgNWe7snHgrwhx/uUITC+/v7Dxw4KBQOABFRgAHETllZ2YwZ+ULhJSWlL730 klA4AExRHO2A9cgjj7hc3ULhx451t7a2CoUDQEQUYACxUzSiUCh8+vTpH3ywVSgc AKZIFWBV/DSfT++BRLZyZa3FYhEK7+jo7OjoEAoHgIgowABiqqamWmhexT5YAIxs ZAtou129Uuk9kMjkdsAKBAL19Q0SyQAwQRRgADFVVXWm0FZVwWCwrm6bRDIATFF8 bQG9atVKoR2wNE1rbNwlkQwAE0QBBhBTCxcuyMjIEApft+6+ZcuWCYUDwKTF0RbQ u3fvfu21V4XCBwYG9u8/IBQOABNBAQYQU+Xlc/Ly8oTClyxZ8sQTTwqFA8CkjWwB 3dbmGR7WeyCRPfPM006nUyjc5XLZ7S1C4QAwERRgADE1e3ZRYaHUPlgpKSnvvrtF KBwAJk0VYKfD4Y2HLaDvvHNNIBAQCu/s7GxvZwcsAHqiAAOItaVLa+TeXbZjx4cS yQAwFSNbQLe0qNcovQcS2YoVd8jt1LBzZ71EMgBMHAUYQKzJ7YMVCAS2bdsukQwA UxFHW0DLnYHEDlgAjIACDCDWKisXpqenC4X/9rdvZWVlCYUDwCTE0RbQg4ODP//5 fXLhTU37hcIBYIIowABiraKiPDc3Vyj8hz/8H9dee61QOABMQhxtAf3ee+/927/9 USjc7XY3N9uFwgFggijAAGKtpKR45syZYuGlL730klA4AExCHG0B/cgjj7hc3ULh R48edTrbhMIBYIIowABirWhkH+hCoX2wkpKS3nvvfYlkAJgcVYAdDocvHraAXr16 lVByMBjs7Ozs6OgUygeACaIAA9BBdXWVaqoSyWwEDcBoRraAbm3VfD69BxKZ3BbQ fr+/oaFRIhkATgsFGIAOlixZbLPZJJLZCBqA0bAFtOLxePbs2SuRDACnhQIMQAfz 58/PysoUCmcjaACGogqwvbk5EAjoPZAIRLeA7uvrP3jwoFA4AEwcBRiADubMmZOf nycUzkbQAIwjjs5AEt0Curvb1dLSIhQOABNHAQagg+Li2bNmzRIKZyNoAMYRR2cg iW4BfeTIkba2dqFwAJg4CjAAfSxdWsNG0AASnirATqfT6/HoPZDIRLeA3rmzXigc AE4LBRiAPtgIGoAZxNEZSGwBDcAMKMAA9MFG0ADMYOQMpJYWTdP0HkhkbAENwAwo wAD0sWDB/MxMqY2g//Vf3xVq1wBwWuLlDCSfz3vPPfcIhff39x84wBbQAAyBAgxA H+Xlc/LypDaCvv766y+//AdC4QAwQXG0BfTHH39cV7dVKNzlctntbAENwBAowAD0 IboR9JIlS5544kmhcACYoDjaAvqZZ552Op1C4WwBDcA4KMAAdCO3EXRGRsbbb/+L RDIATFwcFeB77rnb5/NJJLMFNABDoQAD0I3cRtDB4LS6ujqJZACYuDg6A6m2tjYp SWQHLLaABmAoFGAAupHbCJqTkAAYAWcgTWMLaAAGQwEGoJuFCxdkZGRIJHMSEgAj GDkDqbVVk3m0OLrkzkAaGBjYv/+ARDIATAIFGIBu5s6tyMnJEQrnJCQAuuMMJKWn p+fw4WahcAA4XRRgALopLS0tKJghFH7jjTdddtllQuEAMBGqANubmwOBgN4DieAP f/jDBx+8LxTe1XXMEQ8HQQEwCQowAN0UjSgUCq+qqn700UeFwgEgojg6BPjZZ59t bZU6p7ejo7Ojo0MoHABOFwUYgJ7kTkLKzMx86623JZIBYCLi6AyktWvv8crs1MUZ SACMhgIMQE+SJyEF6+q2SSQDwESoAtzW1uYZHtZ7IJHV1q4QeinmDCQARkMBBqAn TkICkKji6BBgzkACYB4UYAB64iQkAIkqjg4B5gwkAOZBAQagp7liJyHxCDQAfY0c AtzSomma3gOJbNWqlULbMXAGEgCjoQAD0JPoSUhr19573nnnCYUDwPji5RDgXbsa N27cKBTOGUgAjIYCDEBPoichnX/+X61evVooHADGFy+HAKv2qzqwUDhnIAEwGgow AJ3JnYRUXFz88su/lkgGgPHF0SHADz/8kNvtlkjmDCQABkQBBqAzuZOQkpNTtmzZ IpEMAOOLo0OA16xZEwyKLFNzBhIAA6IAA9BZVdWZQsdvsBE0AL2MHALc3u6JhwIs dwiwpmmNjbskkgFg0ijAAHS2aFFlWlqaRDJHAQPQC4cAK0NDQ/v2NUkkA8CkUYAB 6Gz+/HlZWVkSyawAA9ALhwArfX19Bw8ekkgGgEmjAAPQWXl5eV5erkQyRwED0MvI IcCtrZrPp/dAIpM7BNjlctvtdolkAJg0CjAAnZWWlhQUFAiFP/jgQ2effbZQOACc SrwcAtzU1PTrX78sFN7V1eVwOIXCAWByKMAAdFZUVFhUVCQU/u1vf/v22+8QCgeA U4mXQ4D/9/9+44svvhAK7xjRKRQOAJNDAQagP7mjgEtKSl966SWJZAA4lTg6BPiR Rx52uVwSyRwCDMCYKMAA9Cd3FLDNZvvXf31XIhkATiWODgG+8841QsvUHAIMwJgo wAD0J1eAA4Hgtm3sgwUgpuKoAK9YscJqFXn5pQADMCYKMAD9yR0FrGZg27fvkEgG gFNRBbitrc0zPKz3QCKrrV0h9PePHAIMwJgowAD0N3/+/KysTIlkCjCA2FMF2Olw eOPhEGC5AtzX13/w4EGJZACYCgowAP1VVJTn5nIUMIAEoQqww+HwxUMBljsE2O12 NzdzCDAAw6EAA9BfWVnpjBkzhMK3bq0TSgaAk1IFuLWlRdM0vQcS2erVq4SSjx07 1toaB/tgAzAbCjAA/RUXz541a5ZQ+Lp19y1btkwoHAC+SRXgFrvd7/frPZAIdu/e /dprrwqFHzlypK2tXSgcACaNAgxAf0VFhUVFRULhF130N7feeqtQOAB8kyrAdrs9 YPgC/NZbv/3888+FwjtGdAqFA8CkUYABGMLSpTVC70NbuHDh008/I5EMACc1UoCb m4XO142ip556UpVUieRgMLhzZ71EMgBMEQUYgCHIHQWcnZ3z5ptvSiQDwDf5fD6X 2+10xMHbX++9916PR+SsJg4BBmBYFGAAhiBXgFXse++9L5EMAN/k7ulpb28fHhrS eyCRye2ARQEGYFgUYACGsHjxotTUVInkQCCwbdt2iWQA+KY4KsArVtxhtVolkoeH h/fu3SeRDABTRAEGYAgLFy7IyMiQSNY0bceODyWSAeCbVAF2Op1ej0fvgUQmV4AH Bgb27z8gkQwAU0QBBmAI8+bNzc7OlkhmBRhALI0UYIfD6/XqPZDIVq6stVgsEsm9 vb2HDh2WSAaAKaIAAzCE8vI5eXl5EsnBYLCubptEMgB8kyrAjtZWn8+n90AiW7Vq pdD2+y6Xy25vkUgGgCmiAAMwhJKSkpkzC4TC3313S0pKilA4AIylCnBrS4umaXoP JAJV0e+5526h8KNHu5xOp1A4AEwFBRiAIRSNKBQKX7v23vPOO08oHADGUgW4xW73 +/16DySCXbsaN27cKBTe0dEpdMIwAEwRBRiAUSxdWiP0MN4ll1yyfPnNEskAcAJV gO12e8DwBfiddzZ/+umnEsnBYHDnznqJZACYOgowAKOQK8DV1TW/+MUvJJIB4AQj Bbi5ORAI6D2QCDZs2NDSYpdIpgADMDIKMACjqK6uSkpKkkieNWvWq6++JpEMAGP5 fD6X2+10OPQeSGQPPLC+r69PItnv9zc0NEokA8DUUYABGIVcAU5LS9u8+R2JZAAY y93T097ePjw0pPdAIrv77ruEduqiAAMwMgowAKNYsmSxzWaTyZ6+detWmWQA+Eoc FeDa2tqkJJFDgD0ez549eyWSAWDqKMAAjKKycmF6erpEciAQ2LZtu0QyAIylCnBb W5tneFjvgUS2YsUdVqtVInlwcLCpab9EMgBMHQUYgFHMnz8/KytTIlnTtB07PpRI BoCxVAF2Op1ej0fvgUQmV4D7+voPHjwokQwAU0cBBmAUc+dW5OTkSCT7/f7t23dI JAPAWKoAOxwOn9er90Aiq61dIbTtQk9Pz+HDzRLJADB1FGAARjFnTll+fr5EcjAY rKvbJpEMAGOpAtza2qr5fHoPJLJVq1YKnTzX3d3d0tIqkQwAU0cBBmAUJSUlM2cW SCRTgAHExkgBbmkR2l05uuQK8NGjXU6nUyIZAKaOAgzAKIpGFAqFP//88+XlFULh ABCmCnCL3e73+/UeSAQdHR1PPfWkWHinyhcKB4ApogADMJCzzloqlHz99ddffvkP hMIBIEwVYLvdHjB8Af7444/r6qQOh/vii51CyQAwdRRgAAaydGmN0CN5F17417W1 tRLJADBqpAA3NwcCAb0HEsGmTf9cX18vkRwMBnfuFEkGgKigAAMwkJqaaovFIpG8 ZMmSJ56Qet4PABSfz+dyu50Oh94DieyZZ54WepuuKv/19Q0SyQAQFRRgAAZSVXWm 0LmUs2bNevXV1ySSASDM3dPT3t4+PDSk90Aie+CB9X19fRLJmqY1Nu6SSAaAqKAA AzCQ6uoqoXMp09PT/+VfNkskA0BYHBXgu+++S2irar/f39DQKJEMAFFBAQZgIIsX L0pNTZVItliS3n//fYlkAAiLowIsdwbS8PDw3r37JJIBICoowAAMpLJyYXp6ukRy IBDYtm27RDIAhKkC3NbW5hke1nsgkdXWrhB63GZwcLCpab9EMgBEBQUYgIEsWDA/ MzNTItnv92/fvkMiGQDCVAF2Op1ej0fvgUS2YsUdQhsu9Pf3HzhwUCIZAKKCAgzA QObNm5udnS2RTAEGIG2kADscXq9X74FEJrcC3Nvbe+jQYYlkAIgKCjAAAykvL8/L y5VIpgADkKYKsKO11efz6T2QyOQKsMvlttvtEskAEBUUYAAGUlZWNmNGvkRyMBis q9smkQwAYaoAt7a2avFQgOU2wTp2rFv9S5BIBoCooAADMJCSkpKZMwskkinAAKSp AtzS0uKXOV4ouuQK8NGjXU6nUyIZAKKCAgzAQIpGFAqFb978TlpamlA4AIwUYLvd 7/frPZAIPB7PvfeuFQrv6Ojs6OgQCgeAqaMAAzCQgoKC0tISofB16+5btmyZUDgA qAJst9sDhi/Au3fvfu21V4XCHQ5nV1eXUDgATB0FGICxLF1aI/Rg3o9+dPVVV10l kQwA08IFuLk5EAjoPZAItm3b9tFHv5dIDgaDO3fWSyQDQLRQgAEYS01NtcVikUg+ //y/Wr16tUQyAEwLFeDm5uag4Qvwxo0bd+1qlEhW5b++vkEiGQCihQIMwFiqq6uE Duc444wzH3/8cYlkAPD5fC632+lw6D2QyP7X/3rGITNOv9/f0CBSrQEgWijAAIyl qupMq9UqkVxcXPzyy7+WSAYAd09Pe3v78NCQ3gOJ7OGHH3K73RLJmqY1Nu6SSAaA aKEAAzAWuRXg7OycN998UyIZAOKoAN97770ez7BEMivAAIyPAgzAWJYsWWyz2SSS U1Js7777rkQyAMRRAV6zZk0wKPJGZY/Hs2fPXolkAIgWCjAAY1m0qFLotN7p06d/ 8MFWiWQAUAW4ra3NMyyyshpdK1fWCu01ODQ0tG9fk0QyAEQLBRiAsSxcuDAjI10i ORAIbNu2XSIZAFQBdjqdXo9H74FEVlu7QuidJgMDg/v375dIBoBooQADMJb58+dn ZWVKJPv9/u3bd0gkA4AqwA6Hw+f16j2QyFasuENor8G+vv6DBw9KJANAtFCAARjL vHlzs7OzJZI1Tdux40OJZACgACu9vb2HDh2WSAaAaKEAAzCWiory3NxciWRWgAHI GSnAra0+n0/vgUQm9wi02+1ubrZLJANAtFCAARjLnDll+fn5Esm8BxiAHFWAW1tb tXgowHKbYHV3d7e0tEokA0C0UIABGEtpaUlBQYFEcjAYrKvbJpEMACMFuKVF0zS9 BxLZqlUrp08XmQF2dXU5HE6JZACIFgowAGMpLi6eNWumRDIFGIAcVYBbWlr85i7A R44cbWtrk0gGgGihAAMwlqKiwqKiIqHwrVvrhJIBmNxIAbbb/X6/3gOJbPXqVULJ HSM6hcIBICoowACMpaCgoLS0RCj8+eefLy+vEAoHYGaqANvt9oDhC7BqqE899aRQ uMPh7OrqEgoHgKigAAMwnKVLa4Qez1u5ctUFF1wgkQzA5EYKcHNzIBDQeyAR/Md/ /Mdvf/umRHIwGNy5s14iGQCiiAIMwHDkCvDf/d1VV199tUQyAJOLlwJcV1f38ccf SSRTgAHEBQowAMOpqakWOqLjwgv/ura2ViIZgMmpAtzc3Bw0fAHetOmf6+tFaqoq //X1DRLJABBFFGAAhlNdXZWUlCSRfNZZZz300MMSyQDMzOfzudxup8Oh90Aie/75 51RRl0j2+/0NDY0SyQAQRRRgAIZTVVVltYoU4IqKiueee14iGYCZuXt62tvbh4eG 9B5IZI899qjQPlWa5m9spAADMDoKMADDqao602q1SiQXFMzcuHGjRDIAM4ujArx+ /fr+/j6JZE3TGht3SSQDQBRRgAEYjlwBzsrK+u1v35JIBmBmcVSA1669x+v1SiRT gAHEBQowAMNZsmSxzWaTSE5OTtmyZYtEMgAzi6MCvGbNmmBQZKcuj8ezZ89eiWQA iCIKMADDWbSoMi0tTSLZYrG8//4HEskAzCyOCvCqVSuFzpkbGhrat69JIhkAoogC DMBwKisXpqenSyQHAsFt27ZJJAMwM1WA29raPMPDeg8kshUrVgjtMjg4ONjUtF8i GQCiiAIMwHAWLJifmZkpkez3+7dv3yGRDMDMVAF2Op1ej0fvgUS2YsUdQpss9Pf3 HzhwUCIZAKKIAgzAcObNm5ednSWRrGnajh0fSiQDMDMKsNLb23fo0CGJZACIIgow AMOZO7ciJydHIpkCDECCKsAOh8Mns7tydMkV4J6ensOHmyWSASCKKMAADKeiojw3 N1cimQIMQMLICrDDIXS8UHTJFWC3293cbJdIBoAoogADMJzy8jl5eXkSybwHGICE OFoBrq1dkZQksgmWy+Wy21skkgEgiijAAAynrKxsxox8ieRAILBt23aJZABmNlKA W1t9Pp/eA4ls5cpai8UikXzsWHdra6tEMgBEEQUYgOGUlpYUFBRIJAeDwbo6jkEC EGWqAKvup8VDAZY7B7irq8vhcEokA0AUUYABGE5JSfHMmTMlkinAACRQgJWjR486 nW0SyQAQRRRgAIYze/bswsJZEskUYAASRgpwS4umaXoPJDK5AtzZeaS9vV0iGQCi iAIMwHCKRhQKhW/dWieUDMC0VAFuaWnxx0MBXr16lVByR0dnR0eHUDgARAsFGIDh 5ObmVFRUCIX/+tevzJ49WygcgDnFSwHu6up67LFHhcKbm5vd7h6hcACIFgowACM6 66ylQslr19573nnnCYUDMKeRAmy3+/1+vQcSwa5djRs3bhQK/+KLnULJABBFFGAA RrR0aY3Qu9Suv/76yy//gUQyANOKlwL88ccf19VtlUgOBoM7d9ZLJANAdFGAARiR XAG+5JJLli+/WSIZgGmpAmy32wOGL8DvvLP5008/lUimAAOIFxRgAEZUU1NtsVgk ks8//69Wr14tkQzAtOKlAG/cuHHXrkaJ5EAgUF/fIJEMANFFAQZgRNXVVUlJSRLJ /+k/nfPAAw9IJAMwrZEC3NysSqDeA4ngxRdfOHTokESy3+9vaBCp1gAQXRRgAEYk V4ArKyt/+cunJZIBmFa8FOCnnnqqo0PkqF4KMIB4QQEGYERyBbi0tPRXv3pJIhmA acVLAX7kkYddLpdEMgUYQLygAAMwIrkCXFAwU+4UEADmFC8FeP369f39fRLJFGAA 8YICDMCIqqrOtFqtEsnZ2TlvvvmmRDIA04qXAnzvvfd6PMMSyZqmNTbukkgGgOii AAMwoiVLFttsNonktLT0zZs3SyQDMC1VgJubm4OGL8B33XWX369JJHs8nj179kok A0B0UYABGNHixYtSU1MlklNSUt59d4tEMgDTGinAhw8Hg0G9BxLBnXeuEVqmHh4e 3rt3n0QyAEQXBRiAES1aVJmWliaRbLEkvf/++xLJAEwrXgrwqlUrp08XmfsNDQ3t 29ckkQwA0UUBBmBElZUL09PThcK3bq0TSgZgTvFSgGtrVwjtLzg4ONjUtF8iGQCi iwIMwIgWLFiQmZkhkRwIBLZt2y6RDMCcfD6fy+12Ohx6DyQyuQLc3z9w4MABiWQA iC4KMAAjmj9/XlZWlkSy3+/fvn2HRDIAc3L39LS3tw8PDek9kMhWrLhDaIP9vr6+ gwcPSSQDQHRRgAEY0bx5c7OzsyWSNU3bseNDiWQA5kQBVnp7ew8dOiyRDADRRQEG YERz51bk5ORIJLMCDCC6KMBKT0/P4cPNEskAEF0UYABGVFFRnpubK5FMAQYQXXFU gOXeA+x2u5ub7RLJABBdFGAARlRePicvL08imUegAURXHBVguRVgl8tlt7dIJANA dFGAARjRnDll+fn5EsmsAAOIrjgqwHIrwN3d3S0trRLJABBdFGAARlRWVjpjxgyJ ZI5BAhBdcVSAV66stVgsEsnHjh1rbY2Dg6AAgAIMwIhKS0sKCgokkinAAKKLAqx0 dXU5HE6JZACILgowACMqKSmZOVOkAAeDwbq6bRLJAMwpjgrwqlUrp08XmfsdPdrl dFKAAcQBCjAAIyouLp41a6ZEMgUYQHRRgJUjR462tbVJJANAdFGAARjR7NlFhYWF EskUYADRRQFWOjs729s7JJIBILoowACMqKCgoLS0RCh869Y6oWQAJhRHBXj16lVC yQ6Hs6urSygcAKKIAgzAiGbMyC8rKxMKpwADiCIKsNLa2nrsWLdQOABEEQUYgEGd ddZSoeSNG18X2mIagAmpAtzW1uYZHtZ7IBH09PQ89NCDQuFffLFTKBkAoosCDMCg li6tEXqv2qOPPlZVVSWRDMCE4qUAHzp06MUXX5BIDgaDO3fWSyQDQNRRgAEYlFwB vuOOO/77f/+2RDIAE4qXAvzZZ//+9ttvSyRTgAHEEQowkOBmzZqVnJxss6UkJSVZ Q8b+qsViOVXJVBOa8MdAIKC+RtM09Ynf7w99DISFfjGofkli7xO5Anzttdf98Ic/ lEgGYELxUoA/+uj327aJ7IEvVIALCgrUPSt0m7KEJSWFP478j/oldd3Ru9g49zJ1 oxr7M1qIup15PF6fz3fkyJGojxyAkVGAgURTXDxbNd6UlBT1MTR1sMTmumMKc1DN Q8YW5tHOHJqHBNSEYyJ7pdTUVAsN/rLL/r8bb7xRIhmACcVLAX733Xf//Oc/SSSr F/b6+oaIXzZjRr66MYUq61dt9uuFdlqoz45XaKNODV7dsNSNyesd6cNtbe2xuS4A vVCAgbhXVFSoCq/NZktLSx1nRddoRguzouYc/uO+XFoOBgoKCoQK8IUX/nVtba1E MgATUgXY6XR6PR69BxLBpk3/XF8v8qCyetXu6uoK1drp4UIbpuru9OmxLrRTFF4x Hhoa9ng8qhR3dHTqPSIAURYfL0YAThAuvarxqt6rJhl6Dyc6wpU4/KyapmkpKSlC E6Zly/7LunXrJJIBmFC8FOCXX355//4miWT16u31esNvsQn/xWW81N2IQk9Ke1Qf pgwDCSNBXp4Ak5g9uyg1NS0jI12V3oSZXsReVVX1o48+qvcoACSIeCnAzz77bGtr i96jiFeq5KsyPDAwODw81N7eofdwAEweE2ggDsyaNSs9PS0rKythFnv1NXfuvA0b Nug9CgAJIl4K8OOPP370KBs+RYFqwn19fYODQ2ygBcQjCjBgaGVlpRkZGTabjfXe KEpOTrnkkksKCgoKCwtLS0uLi4v5mwUAk2bYAhx+a64qvd3drp6enj/96U/BYCDy P4aJCQaDHo9nYGCgtdWh91gAnAam1IARFRUVpqamsuQrJPwkW3hrltA2LSlpaWnp 6WmpqWmZmZnZIQUhJSUlqh7n5+frPWQAxqVjAe7t7e0Kcbvdvb09AwODytDQkFeN xjPyX79fGz0EiPfOCAkvCA8PD/MmYSAu8DoIGM7cuRWq+sbs+CKMFTwu/MPjDTlZ dePUVJvqyRkZmepPJycnR7XimTNnFhYWqpI8e/ZsfYcNQEdyBThcbl0uV6jf9g4M DAwNhfvtyJE9quWq6hV+yRrdaXl012XEWCAQUDX48OFmvQcCIAJeIgEDKS8vz8nJ pvoa1tijm8KfhM+dSkqyJidbbTZbyshxVLaMjPTMzKzcXFWTc/Py8lRPnj27qLS0 LDMzU+/fAYDom0QBViX2yJEjx44d6+lxq9bU36+6bf/g4JDHM6yabehUWl/4WLjw q83YfjstgfZYTjzqj6ynp9dut+s9EACnxAsoYAglJSV5ebnhMyQQ18aW5NGV5OM9 OSlclVNSUlJD0tMzMjPVfzLHVuVZswp56BqIIyMF2OHwer29vb0ul2tsrR0aGhwO Ca3ZejVNC7Xar5pt2NiVW8ptAlB/0C6X2+l06j0QACfBiyygvwULFmRkpDPpMZXR ue/Yqjw6/bWMUG3ZYg1JTk62hajCnJ7+5WPYqjDr+RsATEY1W9Vpw+u0g4MDnhCf z6eqjmq2/pBpoe9o9S08+h099oFkXuRNRf1/YGBg8MCBA3oPBMCJeC0G9FRSMrLB EjtdYXxj2/K0LzvzNObSQCyFv+lOWKSl02J8fr+/u7vb6WzTeyAAvsILN6Cb8vLy 3Nwc5k8AACSqYDDodvfwrmDAOJh5A/pYuHBBejqPPQMAkOBUBx4cHNy/n8ehAUNg 8g3EWlFRYUFBAftdAQBgHpqmdXV1cVYwoDsKMBBTs2cXqfbLm34BADAbv9+vOnB7 e4feAwFMjQIMxA7tFwAAM6MDA7qjAAMxQvsFAAB0YEBfFGAgFmi/AAAgjA4M6IgC DIgrKiqcOXMm7RcAAISpDnz06FH2xAJijwIMyCopKcnPz6P9AgCAsVQH7u52OZ1O vQcCmAsFGJBVU1NtsVj0HgUAADCcQCBQX9+g9ygAc6EAA4IWL16Umpqq9ygAAIBB DQ8P7927T+9RACZCAQakzJlTlpeXN30632UAAODkgsGgy+VqaWnVeyCAWTA1B0QU FRUqtF8AADA+1YE7OzvZEAuIDWbngIglSxbbbDa9RwEAAOKAx+PZs2ev3qMATIEC DERfefmc3Nxcln8BAMBEBINBt9ttt7foPRAg8TFBB6KMh58BAMDp4kFoIDaYowNR Fi8PPwdD1Cdjuzq9HQAQ78J3t7GfTw/Rb0QTxYPQQAzEwWsBEEdKS0tmzJhhtLus uv37/X6LxWK1WtPT01NSbGqAGRkZxcXFPp/W19c7HOIN0TR/IKC+XH0MjJbkUSfM IYz2OwUAJJ4TCu1Jb0zqHpeUlKQ+WK1JKSGpIVlZ2cnJ1ra2toGBAfXPeb2ewcFB TdPUPU59vdHuYuq3duzYMYfDqfdAgERmrG97IN5VV1epG6reo/hSuPf+5//8/6xd u1b1W5/Pq2YGs2bNKigoGP8fVJODnp4el8t19OhRl6v72LHu7u5jPT29qir39fUP DPSrL/CEaCHhtkxhBgBMxAQLbbjTWkNsIenp6RkZmVlZ6j/ZOTnZ+fkzZszIz8vL nzlzZl5eXk5OjvqC8S/d1dV15MiRQMCfnDzSkNetW/fv//7/G6oJq1tqQ0Oj3qMA EplRvtuBBDB3bkV2dra+N9Fw6c3Nzfvbv734uuv+IT8/PwYXHVuY1dzC7XaHC3NP j3tgYFAV5oGBgaGhYVWYfT6fpvlUXw4GA9O+PgeiKgNAXBun1oZf0lWrTUqyWK3J imqzaWmpGSMyMzLSc3Jyw4U2Nze3oKBg4oU2Krq7u1966VfvvrvF7XbpXobVv7fe 3t7Dh5t1HAOQ2JhiAlGzdGmNXnfN8FTjnHPOXbt2bXl5uS5jmDhVmNVso7Ozs729 /UiIqs0uV7dq0YODQ4OqMg8MeL1emy01KytLtWhVm9Xvbvpxeg8fAEwteJx6QVZV VnXXvr4+j2c4JSVF1dn0dPWfNNVd8/LyVZWdFTJ79uzCwsL8/PzYFNqpsNvt69at +/zzz3S846h/tzt31utyacAMmEoC0bFoUWVaWlrsr6tpWkVFxWOPPV5ZWRn7q8de Q0PD9u3b1Een0+l2uz0eT3iRwWKxhL+AhgwAUzG6chsIjDyqo15UbTZbbm5uSUlJ dXX1t7/9/6qPug4wRpqamm6//WfNzc1WqzX2Vx8aGtq3ryn21wXMgJkiEAWhv94u inH18vv93/3uRWvXrs3IyIjldQ2rq+vou+9u2bnzCzVf6erqUrMHTdPUTE51Yx6u BoCwEx5UVi1XvSqqjpeWllZQUFBRUbF06Vl/+7cXFxTM1HGQxjEwMLBu3bqtWz+I 8QYf6o+mvb3jyJEjsbwoYBJMBIEoqKo6M5Z/Q6zui3PnznvxxReYoEzc559//skn H+/evaetrc3lcnk8w36/f/TJ6hO+mJIMIB6dsJvUtOOPK6vXNNXfbLbUvLy84uLi M85Ycv75f3XOOefoMsh41NV19Prrbzh8+FAs7w6apjU27orZ5QDzYJIHTFVJSXFB QUHMboqqtt1+++0//vE1sbmcSTQ1Nf3xj39saGiw2+0uV/fAwED4jceBQOCEBeRR lGQAsfTNcjvt+BJu+GUqOTk5IyMjLy+/vLy8urr6W9/6lkneGhMzv/nNK4899ljM loLVH25XV5fT2RabywHmwQQOmKoYH330q1+9xF/bx97u3bv//Oc/q49Op+Po0a7B wQGPxxNeQ572jS2sx6InAxjfSZvttDEbKR9fv7Wlp2fMnFlQUlJ6xhlnnHfeeepj bEeKkYeJ/uEfrovZ5TgSCZDAzAyYkjlz5uTl5cas5NB+jezzkKampra2Nrfb3dfX Fzp+2RcIfO1Za6oyYAbj1NppY55MtliSkpOTU1NHNr3Pzc0tLi6urKw8JyS248VE xbIDq/+TuFzulpaW2FwOMAnmW8CUxGz5V9P8P//5fZdeelkMrgVRavK0e/fu5ubm 9vb2Y8e63O6ewcFBj2dYU3/Gfv+04/NjNu4CjO+EDaWmHf9uVfcFq9Vqs6Wmp6fn 5ubMmFEwe/bsioqKM844g2abAN55Z/Pdd99jtcbi7s8iMBB1TKqAySsvn5ObG6Pl 3x/96Oqf/exnMbgQDEVV5aamfXZ7S0dH+9GjXd3d3QMD/UNDQz6f5vN59R4dYCLJ ySnJySNbJWdkZObn58+cWVBUNFvdBSorF/Eosgk9/vjjr732agwuFAwG3W63ugvE 4FqASVCAgcmL2fLv7NnFGzduVFOuGFwLAACMr7u7++///u/b22OxQxWLwEB0UYCB SSorK1WNNAbLv+rO98ADD37/+9+XvhAAAJig3/3ud2vWrI7B34MHg0HVt1tbHdIX AkyCAgxM0pIli202Wwwu9L3vff/++++PwYUAAMDE3XXXXe+997sYXMjj8ezZszcG FwLMgAIMTEZRUaESg+Vfmy319ddfnz9/vvSFAADAaTl48OBVV13l8QxLXygYDHZ2 dnZ0dEpfCDADCjAwGfPmzc3KypIuwIFAYNWq1VdeeaXoVQAAwORs2rTpoYcetFgs oldRBbivr+/QocOiVwFMggIMTMbSpTUxWP4955xzn3vuOavVKn0hAAAwCZqm3XTT TZ9//pn0hVQH3rmzXvoqgBlQgIHTtmDBgszMDOmrBAKBF154cdmyZdIXAgAAk/bp p5/ecMP10ovASn//wIEDB6SvAiQ8CjBw2qqqqqxW8V0fr732ultuuUX6KgAAYIqe fvrpl19+SfoqmuZvbOQ8JGCqKMDAaYvB88+5ubmbNr1RVFQkehUAADB1HR0dV155 hdvtFr0KT0EDUUEBBk6bdAFWd7jbbrvtxz++Ru4SAAAgin7zm1eeeOIJ6ekBBRiY OgowcHoqKxemp6eLXiI7O/v11/+5tLRU9CoAACBaHA7HVVf9XW9vr+hVBgcHm5r2 i14CSHgUYOD0VFdXJSXJvgF4+fKbb7jhBtFLAACA6HrhhRc2bHhW9BJ+v7+hgbcB A1NCAQZOTwyef/71r185++yz5S4BAACi7i9/+cv//J/X8BQ0YHAUYOD0SBfgc889 99FHH0sKsVgs4U9icOYwAACYon/8x3/805/+j1w+BRiYOmbVwGlYsGB+ZmamXH4g ELj11p9+73vfO9UXqCY8thiPisHxgwAAYBzqJv7WW2+tX3+/6E25v7//wIGDcvlA wqMAA6ehqupMq9Uql69umb/85dMLFiyYYsgJ3ZhlZAAATlfgZPx+f/iTYMgJ/8iB Awf+6Z9uUb8qNypN0xobd8nlAwmPCTFwGqSff/5v/+38NWvWyOWHsYwMADAbVVZP WmjHisqFHnjggT/84ZOoRJ0UT0EDU0QBBk6DaAGO+PxzLLGMDAAwsoht9pvLs7Hx 3nvvPfXUk3J/p0wBBqaIuSwwUUVFhYpoA3zyyScXL14ilx9dY4vx2MJMSQYAnJZT NdioL8/GwN69e37605/K5at/LZ2dnR0dnXKXABIb81RgoiorF6anp8vlV1fXPPTQ Q9KHDMfY2GJMSQaAhBdureM/b6zX2mxs+P3+VatWNTQILtIODg42Ne2XywcSG3NQ YKKqqqqsVql2qmYDN9xww+WX/0Ao38jC70kebchjP9KTAUBH4/TY0V9K7DY7OW+/ /dYLL7wgdwvTNH9jY6NQOJDwmFwCEyX6BmBN0x566OFzzz1XKD8BWELoyQAwCWOr 7Am1duwP9R5mgvjss89WrVopd2wEbwMGpoJZIzBRogU4Ozv72Wc3FBQUCOWbx+ge 16MNeewnVGUA8W4iPZZVWX11dXXdfPPy3t5eoXwKMDAVzAWBiRItwN///vd/8pNb hMJxUupP86QlOfwJVRmAnBMeIT7pc8X02Lj2zDNP/+53vxMKpwADU8EMD5iQhQsX ZGRkCIWrO9ny5TdfeumlQvmYOkskFGbAVE7Y6mmcH1Jizemdd97ZsOFZuVvDwMDA /v0HhMKBxMaMDZiQqqoz5d7M4/f7H3zwId4AnEgozIBhBY8b21FP+sPRz/UeMuLP Z599tnr1KrmTHTRNa2zcJRQOJDZmYMCEiD7/nJub++yzG/Lz84XyERemh4xtyKf6 XO+RAvoYraNja+r4DVbvIcO8uru7b755udvtFsrnKWhg0phIARPCG4BhWNOPC9fj CX6i96iRyIKnNra4nvSHeo8diBreBgwYE3MgYEJEC/CPf3zNlVdeKRQOTNw3u/RY Y79g/F/V+/eBrxl9iHds1Yz48+PQ97cDxItNmzb95jevCIVTgIFJY5oCRDZ37tyc nGyhcL/ff8cdK77zne8I5QPGNNqZo/LxhNiTXmtyP3lC3/tm/Rv/C076w4l8nMgX ADCyurq6Rx/9hdzbgHt6eg8fPiwUDiQwCjAQ2ZIli202m1C4mss+9dRTixcvEcoH AACxt3fvnltvvVXuoRiPx7Nnz16hcCCBUYCByKqrq+T+BvfMM8988MGHUlJShPIB AEDseb3e1atX7doltVez3+9vaGgUCgcSGAUYiEz0DcA/+tHVV111lVA4AADQy+uv v/7aa68KhfM2YGByKMBAZKIF+JprrrniCnbAAgAg0bzxxqZXXnlFKJwCDEwOBRiI oLh49syZM4UKsN/vv+uuu88//3yJcAAAoKNPPvnk/vt/LvQuKlWAjx492tbWLhEO JDAKMBBBZeXC9PR0ofCcnJwNGzbk588QygcAAHrp7j62fPnynp4eofzBwcGmpv1C 4UCiogADEVRVnWm1WoXCL7zwr2tra4XCAQCAvh555JHf//5DoXBN0xobpTbZAhIV BRiIoKam2mKxCIXzBmAAABKY6NuAA4FAfX2DUDiQqCjAQARyO2AFg8Hly2++9NJL JcIBAIDu3nnnnQ0bnpWbSLAPFnC6KMDAeIqKChW5HbDWrLnzggsukAgHAAC6++ij jx54YL3cPlidnZ0dHZ0S4UCiogAD4ykrK8vPzxMqwDk5uU8//fSsWbMkwgEAgO6O HDlyyy239PS4JcJVAe7udrW2tkqEA4mKAgyMZ/HiRampqULh//W/fuuuu+4SCgcA AEZw//33/9u//VEofHh4eO/efULhQEKiAAPjqa6uEnpsSfnxj6+58kp2wAIAIJFt 2rTpN795RSjc7/c3NDQKhQMJiQIMjEduByzl+uuvv/zyHwiFAwAAI3j77bdefPFF oXD2wQJOFwUYGE9VVZXVKrVxxW233fbd714kEQ4AAAxi69YPnnjiCaG/T9c0f2Mj K8DAaaAAA+ORWwHWNG39+geWLVsmEQ4AAAzi008/vfPONVarVSKcFWDgdFGAgfHI FeCqquoHHnggJSVFIhwAABiE1+tds2ZNY2ODRDgFGDhdFGBgPHIFmB2wAAAwCbl9 sCjAwOmiAAOnVFFRkZubIxR+zTXXXHEFBRgAgMT3xhubXnnlFaFwt7unublZKBxI PBRg4JQWLlyQkZEhkRwMBn/yk1suvvhiiXAAAGAoW7ZseeaZp4WeKRsYGNi//4BE MpCQKMDAKS1Zsthms0kka5p/7dq13/rWtyTCAQCAofzxj39ct26d0LkSHo9nz569 EslAQqIAA6dUXV2VlCRyr/L7/U888WRVVZVEOAAAMJTGxsbbbvup3KSioYGTkICJ ogADpyS3A5bVat2w4bmysjKJcAAAYCitra3Ll9+kaZpEOPtgAaeFAgycklwBZgcs AABMRW4fLAowcFoowMApUYABAEBUUIABg6AAAydXUVGem5srFH7jjTdddtllQuEA AMBoNm/e/PzzzwmFu93u5ma7UDiQYCjAwMktWDA/MzNTIjkQCNx++x3f+c53JMIB AIAB1dXVPfbYoxaLRSK8v7//wIGDEslA4qEAAye3ePGi1NRUiWS/33/ffT8/77zz JMIBAIAB/fnPf77nnruFNoIeHh7eu3efRDKQeCjAwMnJnYEUCAR++cunFy9eLBEO AAAMaO/evf/0T7cIrQBzEhIwcRRg4ORqaqqF7lKcgQQAgNmInoQUCATq6xskkoHE QwEGTk5uC+hrr73uhz/8oUQyAAAwrDfffPPll1+SSGYjaGDiKMDAyVGAAQBAFFGA ASOgAAMnMWdOWV5enlABvv766y+//AcSyQAAwLDefvutF198USJZFWCXy9XS0ioR DiQYCjBwEvPmzc3OzpZIVreo22677bvfvUgiHAAAGNbWrR888cQTQn+93tvbe+jQ YYlkIMFQgIGTqKxcmJ6eLpHs9/vvuuvu888/XyIcAAAY1ieffHL//T8XOmNicHCw qWm/RDKQYCjAwEksWbLYZrNJJKsC/Mgjvzj77LMlwgEAgGH95S9/qa1dIVSAPR7P nj17JZKBBEMBBk6iqupMq9UqFP7cc89XVFQIhQMAAGNqbm6+6aYbhcI1TWts3CUU DiQSCjBwEnJbQKenZ7zwwgsFBQUS4QAAwLC6urpuuOGGwcEBiXA2ggYmiAIMnARn IAEAgKjjJCRAdxRg4CQowAAAIOoowIDuKMDAiebMKcvPzxcKv/HGmy677DKhcAAA YGSbN29+/vnnhMK7u7s5ChiIiAIMnGju3Lk5OVKHAP/kJ7dcfPHFEuEAAMDgtmzZ 8swzTws9ZdbT03v4MEcBAxFQgIETLVy4ICMjQ/QSwZBAIGCxJGVmZhYWFt55552l paWiFwUAALHhcDjWr1/f2dnZ398fCPgtFsv0ENGLDgwM7N9/QPQSQAKgAAMnOuOM JSkpKbpcOtyK1SfJySk5Odnr1t1XWVmpy0gAAMBENDU1rV17T09Pr8/nVT8Md11d RuL1enfv3qPLpYE4QgEGTlRdXSV0SP2kqVasurG6odpstpyc3LvuunPx4iV6DwoA ABPZu3fP/fev7+lxezye8E1ZdV29B/U1fr+/oaFR71EARkcBBk4ktwV01AVC1GhT UlIyM7PuvPPOmpoavQcFAEAcq6+vX79+fX9/n9frVUXXEqL3oCaEjaCBiYiPWT4Q S3FUgE9l9FFqdc9OTU3Ly8v92c9upxsDABCmWu7jjz/mcrmHh4dG75gJcPenAAMR xff3OSAhAQrwOL7ejVOzs7NvvfWn5557rt7jAgAgyj777LOnnnqyt7d3eHg4YVru OCjAwEQk7EsAMGmJXYDHETxu2sguXMnp6em5ubk33bScegwAMCZVcZ97boPb7R4c HPT5fOpnph+n99B0QAEGJsKMrw7AOCoqKnJzc/QehREFx7BarTZbalZW1nXXXXfB BRfoPTQAQML66KOPXnrppb6+Po9nWNO06WPoPTQjcrt7mpub9R4FYGi8dgBfU1m5 MD09Xe9RxKXRh6uVpKQkm82Wlpb2ox9d/b3vfU/fgQEADOu999577bVXh4aGPB6P 3+8P/2RiP6gsanBwsKlpv96jAAyNFxfgawx4BlLCGLuGrGY26t9zSkpKWlr6FVdc cdlll+k9OgBAlG3evPmNN94YGhr0er2q3IZf/Fm/FcVJSEBEvPoAX0MB1t3YtyKH T1lMTk5JT0/LzMy69NJLL774Yr0HCACmtmXLlnfeeae/v29wcMjn84ZPqp9m7jff GgcFGIiIFynga0y7A1bcCc+3Qs9dB8N/YqosJydbQ205PTMz46KL/oaFZQCYiM2b N3/wwfv9/QOhraS8Pp+mXlynjbzGTgs9jDzyIsvNMS6wDxYQEa9lwNdQgBPV2IXl MIvFYrVaU1JSwm9XvuCCC6+++modRwgA0fLqq69+9NHvw2+s9Xq9mqaN7tEwjaXa hEYBBiLitQ/4GgowRo0uMo+tzaGnspPCS82pqbbU1LRly5bdeOON+g0TQMJ6/vnn P/300+HhoeFhT3hhNhDwn/CKxPIsxqIAAxHxcgl8DQUYUTG2PI/OVsP7moZXnpOS rDabLVShU88666zly2/WdbwAom/Dhme/+OKL4RGe0BbHWnglduye+WMXY7n7YOoo wEBEvNQCX0MBhnGMtuhpX1+IDk+XLSFJqklbk5Xws9yLFlXW1q7Uc9BAnHvkkYf3 7WsKPzns8/k0zef3+wMh3/w2nHa8tXLjgEFQgIGIeL0GvlJePicvL0/vUQAAAEyS y+Wy21v0HgVgXBRg4Cvz58/LysrSexQAAACT1NfXd/DgIb1HARgXBRj4yqJFi9LS UvUeBQAAwCQNDQ3v27dP71EAxkUBBr5SVXWm1WrVexQAAACTpGlaY+MuvUcBGBcF GPhKTU21xWLRexQAAACTFAgE6usb9B4FYFwUYOArbAENAADiGhtBA+Njrg98hQIM AADiGgUYGB9zfeBL5eXleXm5eo8CAABgSlwut91u13sUgEFRgIEvzZ8/PysrU+9R AAAATElfX//Bgwf1HgVgUBRg4Cvz5s1NTk5OSUmZPn06u2EBAIB4EQgEgsGg1+v1 +XyHDh3WeziAcVGAgfHMmVOmKrHVaqUVAwAAIxjtupqmqbrb0tKq94iAeEIBBk4b rRgAAMQAXReIOgowEB2qFVutI7043IrD9B4UAACIA8HjQs8wj7Rdui4ghAk6IGvu 3IrwcnFSUpLFYqEVAwBgZqrlBgIBv98fXtQ9fLhZ7xEB5sJcHNBBeXl5cnK4F1t5 iBoAgIQUfoA5VHRHui5HEwFGQAEGjKKsrCxciVkuBgAgjoxd1A3X3dZWHmAGDIrp NWB0o3tuqY/h5WKKMQAAsRcuuuqjL/w+XXalAuIQ02ggXoW33QqtFieFV4x5lBoA gKkLhPhDNM3PllRAIqEAAwlozpw5oUXjJBaNAQA4qa8v5/pDy7kteg8KgDjmxIC5 jHbj0UVjTmwCACSk8MFCo8u5tFwA0yjAAEaVlZVarcmqF6turEqyen043o55oQAA GNHxihtUn6pyG3pmOaBpvtZWh95DA2BQzGsBTEhpaWlystVi+fIdx1arVf0kD1cD AESFl3DVJ5qmqXI7UnADfp9PcziouAAmg5krgOgY05BH/htuyNOns4YMADi54HHT vuy3oXpLvwUgiVkpgNgpLS1JTk62hFuy5WvLyJRkAEgko++/nRYqt+F34aqPPp/P 4XDqPToA5sWME4DhhHpyiurFx5vyyP9MYz0ZAPQ2ds32y+Xa0IdAIOjzeWm2AIyP eSSAOFZSUpKS8uVRT6NoywAwcd/stKPUT3q9PqeTWgsgcTA1BGAixwvzlydAjRZm NckbW5ipzQDiUbjEjhZa9VI2ptCGz7wNUGgBmByTPACIYHSdeWxzVj+gOQOQcNIe e/w82y97LGuzADA5zNUAQFBxcXFKSkqoOn9ZoEcLs9VqDU9zT3hamxYNxK/wN/W0 rz9XrL6pNU0b/Znwo8WhD6rEetva2nQdMgCYC9MsAIgDxcWzU1JsqhofL8tjq/T0 8HL0tNCcm+VoYBLGLrqGv3fCi65jWmswvO4abrVer6etrV3vUQMAThvTIwAAAACA KVCAAQAAAACmQAEGAAAAAJgCBRgAAAAAYAoUYAAAAACAKVCAAQAAAACmQAEGAAAA AJgCBRgAAAAAYAoUYAAAAACAKVCAAQAAAACmQAEGAAAAAJgCBRgAAAAAYAoUYAAA AACAKVCAAQAAAACmQAEGAAAAAJgCBRgAAAAAYAoUYAAAAACAKVCAAQAAAACmQAEG AAAAAJgCBRgAAAAAYAoUYAAAAACAKVCAAQAAAACmQAEGAAAAAJgCBRgAAAAAYAoU YAAAAACAKVCAAQAAAACmQAEGAAAAAJgCBRgAAAAAYAoUYAAAAACAKVCAAQAAAACm QAEGAAAAAJgCBRgAAAAAYAoUYAAAAACAKVCAAQAAAACmQAEGAAAAAJgCBRgAAAAA YAoUYAAAAACAKVCAAQAAAACmQAEGAAAAAJgCBRgAAAAAYAoUYAAAAACAKVCAAQAA AACmQAEGAAAAAJgCBRgAAAAAYAoUYAAAAACAKVCAAQAAAACmQAEGAAAAAJgCBRgA AAAAYAoUYAAAAACAKVCAAQAAAACmQAEGAAAAAJgCBRgAAAAAYAoUYAAAAACAKVCA AQAAAACmQAEGAAAAAJgCBRgAAAAAYAoUYAAAAACAKVCAAQAAAACmQAEGAAAAAJgC BRgAAAAAYAoUYAAAAACAKVCAAQAAAACmQAEGAAAAAJgCBRgAAAAAYAoUYAAAAACA KVCAAQAAAACmQAEGAAAAAJgCBRgAAAAAYAoUYAAAAACAKVCAAQAAAACmQAEGAAAA AJgCBRgAAAAAYAoUYAAAAACAKVCAAQAAAACmQAEGAAAAAJgCBRgAAAAAYAoUYAAA AACAKVCAAQAAAACmQAEGAAAAAJgCBRgAAAAAYAoUYAAAAACAKVCAAQAAAACmQAEG AAAAAJgCBRgAAAAAYAoUYAAAAACAKVCAAQAAAACmQAEGAAAAAJgCBRgAAAAAYAoU YAAAAACAKVCAAQAAAACmQAEGAAAAAJgCBRgAAAAAYAoUYAAAAACAKVCAAQAAAACm QAEGAAAAAJgCBRgAAAAAYAoUYAAAAACAKVCAAQAAAACmQAEGAAAAAJgCBRgAAAAA YAoUYAAAAACAKVCAAQAAAACmQAEGAAAAAJgCBRgAAAAAYAoUYAAAAACAKVCAAQAA AACmQAEGAAAAAJgCBRgAAAAAYAoUYAAAAACAKVCAAQAAAACmQAEGAAAAAJgCBRgA AAAAYAoUYAAAAACAKVCAAQAAAACmQAEGAAAAAJgCBRgAAAAAYAoUYAAAAACAKVCA AQAAAACmQAEGAAAAAJgCBRgAAAAAYAoUYAAAAACAKVCAAQAAAACmQAEGAAAAAJgC BRgAAAAAYAoUYAAAAACAKVCAAQAAAACmQAEGAAAAAJgCBRgAAAAAYAoUYAAAAACA KfxfCytbFgrLEfIAAAAASUVORK5CYII="/></symbol><use xlink:href="#c" width="1280" height="1280"/></g></g></svg>')} +.is2d .king.white {background-image:url('data:image/svg+xml;base64,<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="614.635" height="614.635" viewBox="0 0 460.977 460.977"><mask id="b"><use xlink:href="#a" width="1280" height="1280" transform="rotate(.193) scale(.36014)"/></mask><symbol id="a" viewBox="0 0 1280 1280"><image width="1280" height="1280" xlink:href="data:image/png;base64, iVBORw0KGgoAAAANSUhEUgAABQAAAAUACAAAAAA9j6ArAAAACXBIWXMAAA7EAAAO xAGVKw4bAABWO0lEQVR4nO3dB3gUdeLG8fxDCCEiAiJFQUQUrChWrNiwYT+xl7Od vZ6eXVFR8fTsvSv2clbwFBuKihWwiyAoICC9hyQkf4pgNtnd7MzOzPsr389zz3N3 Sma/QvKa7M7O/F8BAHjq/9QBAKDCAALwFgMIwFsMIABvMYAAvMUAAvAWAwjAWwwg AG8xgAC8xQAC8BYDCMBbDCAAbzGAALzFAALwFgMIwFsMIABvMYAAvMUAAvAWAwjA WwwgAG8xgAC8xQAC8BYDCMBbDCAAbzGAALzFAALwFgMIwFsMIABvMYAAvMUAAvAW AwjAWwwgAG8xgAC8xQAC8BYDCMBbDCAAbzGAALzFAALwFgMIwFsMIABvMYAAvMUA AvAWAwjAWwwgAG8xgAC8xQAC8BYDCMBbDCAAbzGAALzFAALwFgMIwFsMIABvMYBI WGnrMbX/UmGHiWWKFHiPAURS1t2hW5cOnTP+7R/G/vjVh78m2AMwgIhd4UY7bL5+ u3Y5/uqx477/4oORsQYByzGAiE/LXbfr2nHNUB86evSwDwfPjbgHqIUBRBya9dy5 W8fWeR9m/M9fvP0BTw8iNgwgItaqd8+uHSM94vdfDnhtfqRHBJZhABGhrf++w4Yx HXrom/1Hx3Ro+IsBRETanr3vBjE/xEdPPcp3gogSA4gorHvFUck80C9P3DIzmUeC DxhA5K340n+0SfDhvu73dIKPBqcxgMhTy7t7J/6Yl/dN/CHhJAYQeWnx2D6Sx736 SsnDwjEMIPJx3cWqR57yj5dVDw13MIAIr/M7ub7BLQ4D968UPjqcwAAitDNv1z7+ pAOHagNgPQYQYT1xpLqg4JT71AWwGwOIkN7dWV2wWJ+r1AWwGgOIcAbtpi5Y6tLr 1AWwGQOIUB4+Tl3wp2P6qwtgMQYQYZxyj7pguWm7fK1OgL0YQITQ8ecG6oQVvo/r +jPwAAOIEH4Nd5nnWFQ9eYw6AdZiABHcJdeqC2qa2etjdQJsxQAisJKZjdQJKT7Z Vl0AWzGACOyh49UFqeadxPWxEA4DiMDmN1YX1PK+Cedkw0YMIIJSvwW4Lk6FQUgM IIIap7wETFpV/f+uToCdGEAE1PZ3dUFdo9ZVF8BODCACuvlcdUFds44YqE6AlRhA BDRmLXVBXYseOlmdACsxgAimsKJQnZDGV5urC2AlBhDBHPCSuiCdid0mqxNgIwYQ wTxzqLognXlnPqJOgI0YQAQzem11QTqLHjhVnQAbMYAIZkGJuiCtd3dVF8BGDCAC aTFNXZDeyC7qAtiIAUQghz+lLkhv0lbj1AmwEAOIQO44Q12Q3qyjX1MnwEIMIAL5 YAd1QXoLr7xBnQALMYAIxMT3gSyx6MFT1AmwEAOIQGavrC5Ir/r1/dQJsBADiEAW mfhGuCWGbqMugIUYQARROk9dkMmP66sLYCEGEEFs/oW6IJOxHdUFsBADiCCOflxd kMmk7r+qE2AfBhBBXHWFuiCT6fsPUSfAPgwggnj8aHVBJnNO5t6YCIwBRBDv7KIu yKTsklvUCbAPA4gghm+iLsik4qZL1AmwDwOIIH5dU12QCW8FQQgMIIKY1kJdkEn1 c4epE2AfBhBBVKsDMvt+Q3UB7MMAIggGEE5hABHAkO3UBZlxQSwExwAigAmrqwsy q3rkRHUCrMMAIoD5jdUFWQzYR10A6zCACMDYi2Et8cm26gJYhwFEAAa/BlJQMLyb ugDWYQARgNED+LWx71KBsRhABGD0AH7TVV0A6zCAyJ25l0JYYsElt6oTYBsGELkz 953ASyx64FR1AmzDACJ3c1dSF2T16v7qAtiGAUTuKhuoC7L6cEd1AWzDACJ3Rr8G UlDw5RbqAtiGAUTuDB/AEZuqC2AbBhC5YwDhGAYQOXvN8Dfbzjv3AXUCLMMAImej OqkLsqu881x1AizDACJns5qqC7KrfrG3OgGWYQCRs4oidUE93jP6nSowEAOInFWZ /tny2dbqAljG9E9pGMTwF4ELCoZtpi6AZRhA5Mz4AeSKgAiIAUTOjB9ATgREQAwg cvX9+uqC+lT852J1AuzCACJX05urC+pT/dRR6gTYhQFErsobqgvqNWh3dQHswgAi V8afBVNQMHQbdQHsYv7nNExh/GsgBQVfba4ugF0YQOSKAYRzGEDkyoIB5ExoBMMA IkfDLbjtbvn1fdQJsAoDiBxNaakuqF/VY8erE2AVBhA5KmukLsjBAMOv2QrDMIDI kQVnwRQUDNlBXQCr2PBJDSNY8BpIQcHnW6kLYBUGEDmyYgC5MyYCYQCRIwYQ7mEA kZtPrfjhsqzPDeoE2IQBRG4mtVYX5KLqwZPVCbAJA4jcLChRF+TklQPUBbAJA4jc LCpUF+Tk/Z3VBbAJA4jcWPEaCBfEQjAMIHJjyQByIiCCYACRG0sG8Ist1QWwCQOI nLzfQ12Qo5H7/KxOgD0YQORkXDt1QY5m7zRMnQB7MIDIydyV1AU5qtx5iDoB9mAA kRNLngJcbJ8B6gLYgwFETuwZwP1eUxfAHgwgcsIAwkUMIHKx9VB1Qc4uvKlKnQBr MIDIxe9t1QU5m7vL5+oEWIMBRC4qitQFOaveY5A6AdZgAJELe54C5GVgBMAAIhc2 DSCvgiBnDCByYdMAHvCKugDWYACRg93fVBcE0PeqSnUCbMEAIgcvHqQuCOCrg35V J8AWDCBy8Oua6oIAZu36pToBtmAAkYOyRuqCAKp2f0edAFswgMhBlVWfJ5wHg1xZ 9YkNFZteBC4oOPBldQFswQCifoc+oy4I5LaLytQJsAQDiPoN2FtdEMi3B4xWJ8AS DCDqZ9GlEJaYu9un6gRYggFE/RYWqwsCqe7Jy8DIDQOI+tn1IjAvAyNnln1mQ6Go Ql0Q0N/+qy6AJRhA1OvEB9QFAd3/z7nqBNiBAUS93tlFXRAQN0dHjhhA1GtyK3VB QPN3tecWJpBiAFGv8obqgoCq93xLnQA7MICol11vhFuCa6IiNwwg6lOyQF0Q2GHP qgtgBwYQ9Tn3ZnVBYE+eMVOdACswgKjPx9uoCwIb2+t7dQKswACiPlNXVRcEVtZz iDoBVmAAUR+Lboq+Qq+B6gJYgQFEfex7EZhroiJHDCDq0WyGuiCEvz+mLoAVGEDU o8+V6oIQXj5pqjoBNmAAUY8vN1MXhDBhz2/VCbABA4h6zFxFXRBCec8P1AmwAQOI elQ2UBeEwcvAyAUDiHrY+CIw10RFbhhAZNdhrLoglNPvVhfABgwgsrv1bHVBKG8f M1GdAAswgMju2w3VBaFM3nO4OgEWYACR3Zwm6oJQKnd/T50ACzCAyG5RobognP1e UxfAAgwgsrPzReCCgt4vqAtgAQYQWW06TF0Q0kU3qAtgAQYQWT18nLogpI8PG6dO gPkYQGQ1qpO6IKTpu3+pToD5GEBkNb+xuiCkRXsNUifAfAwgsqqy9jOEW2OiftZ+ eiMZtr4IzMvAyAUDiGx6vqUuCK3f5ZXqBBiPAUQ2Lx6kLght+EFj1AkwHgOIbMa1 UxeENmf3oeoEGI8BRDZljdQFoVXv/T91AozHACIbe18E5pqoyIHFn9+IX1GFuiAP RzytLoDxGEBkcebt6oI8PHHmTHUCTMcAIosh26kL8jB2X26NiXowgMhiWgt1QR4W 7jFYnQDTMYDIoqJIXZAPromK+jCAyMLeN8Itccjz6gKYjgFEZmuMVxfk5Yy71AUw HQOIzCy9JeZy7x7FrTGRHQOIzL7bQF2Qlyl7cU1UZMcAIrO5K6kL8sI1UVEfBhCZ 2fxGuCV4MxzqYflnOGJl94vABQWHPasugOEYQGS076vqgjzdemG5OgFmYwCR0cC9 1AV5+uGAkeoEmI0BREaTWqsL8rRgzw/UCTAbA4iMyhuqC/JUvT9vhkNWDCAysv01 EF4FQX0YQGTSepK6IG+n360ugNkYQGSyqFBdkD/OBERWDCAysPpy+Msd019dAKMx gMjgmsvUBREYeNwf6gSYjAFEBr90VBdEYNae3BwYWTCAyMDuq0Evd+DL6gKYjAFE BvafBLPEkU+pC2AyBhDpnXuzuiASz506XZ0AgzGASG/kuuqCSEzvxZOAyIwBRHrW vw9umeqDeBIQmTGASM+NpwALCo5+Ql0AgzGAqOn9Di0aF7n3SVG9aOGsKSd/qs6A cdz7XEcIn6++SqMGPnwuVFeVz5150mB1Bkzhwyc9MninQ4vShg684TeU6sqyWVPO ZQo9xwD6Z3iblYu9+HYvR1UV82af84q6AhJ8HfjimnXatWnepJg/8Iwq58+cMmHC /cPVHUgQXw+O69OlQ9sWpU68qy0xVQtnTR7360PD1B2IHwPoqFvXad+6aQl/vHmp mDvt93H3DlFnID58hTjmjvU6tGzixjnM5qhaMOP3sXfzgomDGEBHXLxxp3bN+Y4v XpWzJ48d+eTn6gxEh68Y29244Vqtm/IcX5KqF0ybMPqh99QZiAADaK0rN+ncdpUG 6gqPVZdNGfvjk9x52GoMoIWe6LKFOgF/mTNp3P3cftNSDKBNbtp0V3UCMho+8rGB 6gYExADa4aENt1YnIDdvPfq0OgE5YwANd+FWXTZUNyC4Id89y6skFmAAjdV3s73U CcjTVz88+5q6AdkwgAa6ZdOd1AmI0Hc/P8OLJIZiAA0zZDt1AeJxxTXqAtTFAJrF lQvRo653dlMXoA4G0CiX8V2Cw7b7WF2A2hhAozxxpLoA8Tmmv7oAtTGARvmct3g4 rO/l6gLUxgAahacAXfbE0eoC1MYAGoUBdNngndQFqI0BNMk/b1IXIE5bfKkuQC0M oEluP1NdgDjtx9tCTMMAmuTN3dUFiNO5t6oLUAsDaJIfu6gLEKfbzlEXoBYG0CS8 BuK2F3qrC1ALA2gSBtBtH22vLkAtDKBBzr9RXYB4bcUd5QzDABrkpn+qCxCvvf6n LkAqBtAg/z1QXYB4nXKfugCpGECDDOW+H467qo+6AKkYQIPwGojr7j1VXYBUDKBB GEDXPX+IugCpGECDMICu46LQpmEADcIAuu7zrdQFSMUAGoQBdN13G6kLkIoBNMfF 16kLELdthqoLkIIBNEe/C9UFiNvug9QFSMEAmuOBE9UFiNshz6sLkIIBNMczh6oL ELcTHlYXIAUDaI7Xe6kLELez7lAXIIVVA9i+8Uh1QpwG76guQNwuuV5dEKPOC8ap EwKzagAdx1uB3Xf1leoCpGAAzcFd0d137WXqAqRgAM3xVTd1AeLW72J1AVIwgOb4 emN1AeJ20wXqAqRgAM3xDe+Tct5/zlcXIAUDaA4G0H0MoGEYQHMwgO5jAA3DAJqD 5wDdx3OAhmEAjdH5J3UBYscFAQ3DABqj6wh1AeLHF5xZ+PMwBgPoA77gzMKfhzE6 jVIXIH58wZmFPw9jdBirLkD8+IIzC38exmj7u7oA8eMLziz8eRij2Qx1AeLHF5xZ +PMwBgPoA77gzMKfhzm4K6b7RnZRFyAFA2gOBtB9DKBhGEBzMIDu+3F9dQFSMIDm YADd9/2G6gKkYADNwQC6jwE0DANoDgbQfQygYRhAczCA7mMADcMAmoMBdB8DaBgG 0BwMoPsYQMMwgOZgAN3HABqGATQHA+g+BtAwDKA5GED3MYCGYQDNwQC6jwE0DANo DgbQfQygYRhAczCA7mMADcMAmoMBdN+33PvZLAygORhA943YVF2AFAygORhA9321 uboAKRhAczCA7vtiS3UBUjCA5mAA3Td0G3UBUjCA5mAA3ffJtuoCpGAAzcEAuu+D HuoCpGAAzcEAuu/9ndUFSMEAmoMBdN87u6kLkIIBNAcD6L4391QXIAUDaA4G0H0D e6kLkIIBNAcD6L5XDlAXIAUDaA4G0H3PH6IuQAoG0BwMoPuePkJdgBQMoDkYQPc9 fqy6ACkYQHMwgO67/2R1AVIwgOb4YT11AeJ22znqAqRgAM3xBZdKct71l6gLkIIB NMeH26sLELfL+6oLkIIBNMfAvdQFiNu5t6oLkIIBNMczh6oLELcTHlYXIAUDaI5b eILcefsMUBcgBQNojnNuURcgbpsNUxcgBQNojgNeUhcgbm0mqwuQggE0x0bfqAsQ N77eDMMfiDmKF6oLELORXdQFSMUAGoT3wrmOeyKZhgE0CAPoOq6GZRoG0CAjuqoL EK8b/6UuQCoG0CDPH6wuQLxOelBdgFQMoEEuuVZdgHhtM1RdgFQMoEG6jlAXIF58 uZmGPxGT8CqI2z7cUV2AWhhAkzCAbrvrDHUBamEATfIod4xw2hFPqwtQCwNokt3f VBcgTs1nqgtQCwNoksJF6gLEaOg26gLUxgAa5euN1QWID6dBm4cBNMq/blAXID5b fa4uQG0MoFFK56kLEJsRm6oLUAcDaBZOhHHXvaeqC1AHA2iWy69WFyAu232sLkAd DKBZuCiqs3gN2EQMoGE+6a4uQDy4J7qJGEDD7PmGugDx4CxoEzGApuFlEDe9dJC6 AGkwgKa5/Ux1AeLALdGNxACapskcdQFi8PlW6gKkwwAa56MtZpQ1W6lInYGIVJfP KmtRefM16g6kwwAap7j8z/9xe6c1V2tawp+QpSrnzZg07sVnl/2fwsJKbQ3S48vL fJd16dhm1SZ8S2iH6rJZf4wf88ogdQdywgBa5JZ12rdapaRQnYF0KuZOnzj+qdfU GQiGAbTQhet3XH3VJg3VGVisasGsyeN+eXGIugPhMIA2u3GdNVs3a8y3hMmrrpgz bcK4J/hB13YMoAvOX2/tNVZduSF/mLFbtGDGpF/HPseF/VzB14xTrl+nQ5vmjRuo M5xTXT57yoTfHuUHXef4MoBFbQvLpnl0JsK9ndZo2bTYlz/d2Cw5leX3O99TZySn aNWSqokefZ34MIB7H9p99dKlz5NVLZj81RsvzFYHJemqLh3aNl+JbwmDqS6bNeW3 3x4Ypu5IUrPee3ZrvewUg6r5vw/15Qatrg/gtv261361dMq7t3t4Zco712m3WtNG rv9x56li3rSJ42/9VJ2RuMLtz9ypZepfqhh6kRdfJW5/RRxxU9u0f332K5eOSzjF IA+svXrLlRupKwwydtLv/Tx+WaPjdb1WTvfXJ57/VNIpyXN5ANd9Zf3Mf/PHi15J rsREnU5ovvIqK69UWlpS3KioQQOXPxHS+KOsbP68ubPmzH3tw/L6f7XDCv923ToZ /+YP+/+cYIqEw5/3fS7PfoLctL63JlRigy0/Uxck5NZz1QUGKbrguqx/v+qaPsmE yDg7gIVv7Vrvr5l97b8TKLHD/i+rCxLyyGll6gRTFF12Zb2/5p3dqxIo0XF1AEu+ 7ZTLL5t53iNxl1ji5HvVBQl56cTp6gQzFJ18Zy6/bPRGTv8Lw9EBLPpp7Rx/5fij BsdaYqyi1LO9vLkf59vHTKz5f4uq3P4OJ5PCvV7P8Vf+0sXl8wIdHcDPt8j91w49 YHJ8IaZqNrfWZ/WtZ2tCEjf0iDEp/7+wSZmHL4N0emHTnH/tF1vGGKLm5gDee3KQ X73o/jM8+y6g6fw6/1Lvf5QiRODrQ3+s9VcKS8tc/h4njdJ7jw7yy+87Ja4QPScH sOebAf+xph/m02U9ms1Os/ev7ZN8iMSo3sPr/sUm5R59F1h40PPBPqB6D3e/PFwc wKJpTQN/zLv7zo+hxEjFlem+3x2yXeIhGhP+lu6dHul/U5zU+uXuQT9k9qrOfovs 4gA+GuZ9jGX/6B95iIlazE7/ufzBDgmHqIw/OO1b3Qqbzvfim8Ci024L8VGP/T3q DlM4OIAtpoS7Quine86MuMREhRm+03m/R7IdMuP+lv5db5l+Y9zS4fWNwnxY1Wqu njvk4AA+f3DID1x4kvvfBBZl+lnG+wEsKCxwfgKLT7sl5Ee+0DvSEHO4N4BNZoa/ +NMHezn+TGBJxpNaB+2WZIfQ2IO/zPB3nH8esO3rm4X90EXN5kZZYg73BvDG8/P4 4HkHvRVZiIFaTk//JV5ywjFbeHNnkd+evufX9H+nWZnLb3ooOiyfH3BuuiCyEKO4 N4CTWuf14U8EOkPKMsXpnucvPuukdd37NMhq6gv/HpPmLzv9rpCmT/XK58Mnt4kq xCzOfeav90OeB5i4w+hIQgzUekqdL/DC40/v6s33fjVU/97/9ol1/mqL+c5+C9j9 kzwPsH7t88fd4NwA3vePfI+w6Nw7oggxUJPaz+N0vWXHIkmJCapH9Xmh1nfEJZWO nu9Wcull+R7i/kDvrrKGcwM4rl3+x3h/DzdPCav1E/Dp/1pTFGKKOU/2nVDz/7v6 M3DrN7rlfYzx7SMIMY9rA1hUHsU/0Yydvo7gKMapeQ5My9sPLNGVGKPqywtqXA3I zTNhCnd/I4KjVBc7+d2xawO476uRHKbqX/+J5DhGaTV1xZd364f39PGZv7RGnT1w xf928UnA0qvyOS/iL/u9FslhDOPaAIZ6G1w67+7h3L/wmi1/p0vrx3oyfzWMPnvA n//LwYsitB4Y+uS/VG6+Hc61ARy+SVRHmrqtazeEKV12lnerp3Zx7U89b7+euezb G/deBenxflRHGpH7FQQt4tqXwrQWkR2q8h+OXS5/2dtAbjqH26Sn8fEJS07zcO3N ICUXRHeh7+mrRnYog7g2gJVRfnU/c3iEB9Nb8hrInk84+WkcgYo7r5jr2qsgLZ6r /85gOVvk5BlTjg1gUUWkhxu1pUsXiCmsavVK4EvBeeSPMwJeKNR0G3wX6eEauvb0 wBKODWDEf+QF83t+HO0BhVpPOf1mJ/8lHp0BJ80rd+Zl4KJDnoz2gBt+H+3xjODY AB4c9b/Dqy68KeIjynR4dmt1gvGmnufMFdFK+50Z8RF7vxDxAU3g2ABecm3kh3x9 fzeeFtrxjVJ1ggWq7jnfjW8BW78S+b/uLr0u6iMawLEBfODE6I/52+ZToz9o4q65 1LE/6rgMPcaF0582/yL6Yz54UvTHlHPsq+KpOF63XbD7kBiOmqy3eqoLrDHx6HfU CfkqOvLRGI769BExHFTNsQF86YA4jlp17u1xHDY5Tb5aV51gkXlnPaxOyE+Ta86J 47AvHxjHUcUcG8ABe8dzXLvPCGz1PSf/BVF52Q3qhHy0ei6e+7sMzOuKqoZybABj u7PF91vae7eQNb4Pfp9kvy3q20edEF7Up4Kt8LaLT6M4NoDx3dts5la2Pjfe4buV 1AnWqbrxInVCWHsPqP/XhDN4p7iOLOTYAL67c2yHruj9SmzHjlOrUSurEyxUdU0f dUIoxWfdGNux39sltkPrODaAr8f4NEX1VVfFd/DYNB0T3eUhfFJ56b/VCSE0veOY +A4+YJ/4ji3j2ACGvil6Tix8Gaxw9FrqBEstOOtBdUJgbV+K880+Tt4c3bEBfCzG fwEu9sMWtr0Uwvl/oU0+xrZ7RHcdEevhH4/qYsMmcWwA7zkl3uNP3yLd/WTNdd3F 6gKLfXOIXXeC7PV6vMe/99R4jy/h2ADG/gVfvrdNbxPYdohjf77JeuFwiy4AVXTa bTE/wvWXxPwACo59gZx2V9yPUH22PXcNLvmDF4DzUdXnGnVCzpr0Oz3uhzj97rgf QcCxAYz7p4Al7LlD9OAd1QWWm3acLXdCa/VE/E/27hPbGYZCjg3gRt8k8CAf7WjH BbIOelFdYL13DpqtTsjJuiMTeJCNv03gQZLm2ACWzkviUX7d1IYr5RdP5x0g+bLk fOhtP0riUVay7RSIXDg2gAVVifwDzdrSgvfFPefiaVtJG3/UYHVC/SK/Dnpa1U7e S9q1AVxQksjDWPBicIdfnPyETZr5twMvPjOZuzaUNU7kYRLm2gBOaZnM41Sdfm8y DxTaZ1uqC5zw+Vbqgnqcck9CDzR1tYQeKFGuDeBPnZN6pNtiuehkZLp/oi5wxDZD 1QVZ3Xp2Uo80sktSj5Qk1wbwgx0Se6g390zsoUIY0VVd4IivN1EXZPO/PRJ7qA+d PKnKtQF8/OjkHuvHbubeQGzTYeoCZ3Qbri7IqGTYesk9WP9432cv4toAnh/f5dDq mrLx5AQfLZCh3AM4Kp92Vxdk0vqbJJ+Wu8CZO2TX5NoA9ng/yUdbsK2h3x20mOra H6xOdcvp6oT0Ev4ufycLTggKzrWvk2TOhF6h8iAz3yv14AnqAoc8FMPNpiOw76vJ Pp6T50E7N4AFFUWJPlz1ebcm+ng5msubQKIzr4m6IJ1zbkn28SobJvt4CXFuAKcl fQX4e05L+AFzkMQ1ITxi4lUA7k764nzT3by1qnMD+M1GST/iW8mdiZCrIdupC5zy 0fbqgjre3D3pR/x246QfMRHODeB/k79vx/ebG3Y6TOHCZJ8HcF1lI8Mu/1Py5QaJ P+ZLByX+kElwbgAvvzr5x5y80dTkHzSLox9XFzjmmP7qghQtv22d/INeYc/FYYNw bgB3flfwoHO3NOruEVwINWIf9FAX1LTeD4pH3eU9xaPGzrkBLF6oeNSKPUz69Jjv 5HU7hBaUqgtqkPwrvqCgUbnkYePm3ACKvvqrjn9M8bBpdftKXeCczcx5Z+Gxj0oe 1qh/B0TIvQEcs5bmca/qo3ncuu6M/fY43rnrDHXBcn2u1Dzu2I6ax42bewMouxW4 MZfO/NHJ6xZJ/ZTgRQeyelR1c/JBiZ93kwz3BvD6i1SPPHgXM86WKHfznH2limJ1 wVKF78pejekX9x23RdwbwF3flj30yE1MOCEwkTuE+aazCTeBKRmR2OV+69jN+HtA hOPeAGpeBl7GiBMCL3PzhC2ty/uqC0Sn/y3n6IvADg5gwTzh61VzN9d/+/XuzuoC B723i7qgoPNPwgef7+rVNRwcwFGdhA9evusQ4aMvNWF1dYGDfl9DXbD9h8pHH72O 8tFj5OAAvrqv8tGrjnhW+fCLLTTjCXu3lDcSBxz6jPThX9tP+vDxcXAAL75O+/ji S4c3myF9eFc1nyl9+ERv9ZDGJddrHz82Dg6g/H5Ad56pfPSDn1c+urN6v6B89DvU J2IbfGeo/Dg4gAVV6n+oV/cXPvh1jp6wJXb9JcIHf0X9A2h1oTggNuqtiMOMZuqC z7etlD32SwfIHtplLyd/ncnlij7eUvbYf5rZXF0QFxcH0IB7go/ZSHYHmWGbqh7Z acO7qR659Fv923DNvjt8PlwcwP5HqQsKCqZtqLpl8Lh2ogd22/j2ogduPUn0wDU9 cbS6IC4uDuCJD6gLFpu3hegaqbOaah7XcbNX0Tyu5uqntZ30oLogLi4OoBH/ziyo 6Km5kTSXQoiF6HIIPd6XPGxtbVQ/z8TOxQE0ZAOqjnpa8rBO/pHKaV4HPfwpxaPW YcjFcOLg5FeLKU+DKU6JLqpI/jG90FDwwr769OflZE+Axs/JAXx7V3XBn247J/GH XGN84g/ph3YTEn/IW89O/CHTe2c3dUFsnBzAq65QFyz3Qu+kH3HroUk/oie6f5r0 Iz5/cNKPmMnVouvwJ8DJAez+ibpghU+2T/gq0T3fSvbxvLH7oGQfr3DINsk+YBbb uPtvVScHsLDSnH+sn7sme5Xog15M9OH88bf/JvpwJV+vm+jjZVNdZMa9HuJgzlJE Sf9muL/8senEJB9OdNdE9/090fueth3eKsmHy87dN8K5OoBfbqYuqKF68yQvT3Pc wwk+mE+OfyTBBzPr1s5fba4uiI+bA3jfP9QFKZL86Ul84Ux3HZbghW4Nex7j/pPV BfFxcwAN+wRK8oRALgcYkwQvCGjK6X/LJfz0Z6LcHMDSeeqCWm5I7GbFew9I6pE8 02tgUo/U78KkHilHK8kubRQ/NwewYK5pN7FK7N3knAYTk8ROgzHiWh41zWuiLoiR owP43Qbqgtr6XJXM42hvHuawHRK63d+VfZJ5nNx9v6G6IEaODuBjx6gL6kjomWTe CRKThN4JYtjrd0s8fqy6IEaODqCJr4Umc6cQM64F5qBkrgglv/tHGkm+/p04Rwew ZIG6II2h2yVxQn11Ao/hoyS+Ugo/6p7AowTVONn3MiXL0QE05JKAtYzcJIFPpUXO 3sBLqqpB/I9RMqJz/A8SmMMXAyxwdwB/0d9IJo1JG06P/THKGsX+ED5aWBL7Q7T4 rk3sjxHCmLXVBXFydQDvPlVdkNasTX6N+yFmim5e4bhZsb+9vMPYuB8hnHtOUxfE ydUB3PYjdUF6C7YdHvMjGPnDv/1i/0Fw0yTfMR7Edh+rC+Lk6gAa+1pAxV7vxPsA PAcYi7ifA9z17XiPH56zE7GUs/90C+J/ziacqqPjvdFNRVGsh/dVZbzfWB/xZKyH z0NZY3VBrJwdwO/XVxdkdN4tcR59vtufsCoLSuM8+rk3x3n0vPxg3JuqIuXsAF5+ tbogsxv/FePBTboYrENivSjovy+I8eB5uuIadUGsnB3AkrkJnLgVVv8Y36k3fo34 ju2xCTHeavXxo+M7dr4WNXH5NGiHB7Dg97bqgize7hnboYdtGtuhfTa8W2yHHmTy TScnrq4uiJe7A/jOLuqCbEZsEdd9to25KbJbYrs1btEXm8R05Ei86/ink7sDaN5l hVKM3TCmq0z2Pyqe43ruiZh+TC39bq14DhyRpC7jpuLuAK73g7ogu6kb/hHLcQ0f flvFNAStvmsZy3Ejs/6P6oJ4uTuAxp8QN3fT0XEc1rT7oTginvtidBoVx1EjFPPp j3oOD+C4GF+3i8TCHT6P4ahrjI/hoGg3IYaDbvlZDAeN1Pj26oKYOTyAr/dSF9Sn cv84brRTafD5P9ZaFMePExbcwGrAPuqCmDk8gOfE+oaLSFQd/1j0B53WIvpjem/6 qtEf89hHoz9m1M69VV0QM4cH0IqfBS/8d+SHHG70aRWWGhH92ZX/uiHyQ0Yvlp/8 TeLwANpxadBbz436iA8fF/URUfDI8VEf8ZZzoj5iDBK4DKyYywM4qpO6IBfPHB7x AQ9+PuIDoqCg9wsRH/DpwyI+YCxGr6MuiJvLA/jsIeqCnLwX8VtWistc/kPVqC4p j/aA7+4c7fFi8tyh6oK4ufy1clR/dUFuvt482rfF8SpI5CJ+DaToy66RHi82Rz+h LoibywNo5L0x0/ltw7lRHm7wjlEeDYt90CPKozX5bs0oDxcjp++IuZTLA2jPpfGm bRDl2+IMvrqmrSK9hm2rRG6xHoVYL4JoBqcH8ONt1AW5mrvZz9EdrNmM6I6FpZrP jO5Y646M7lgx+2RbdUHsnB7Aay5TF+RsYY9PozvY1BjO2vXatAivWLD10OiOFbe+ l6sLYuf0AHb+SV2Qu0UHvhbZsV7ZL7JDYYlX94/sUPu+Gtmh4tfFnm9Ww3J6AAsW xn0z1whV/+PBqA5l1ReZDfaL7F9OJz4Q1ZESUG7DOwny5PYA2nEq9HLR3X6Gm6NH Krqbopt8q6663D8N2vUBfOJIdUEg954a0YG+2DyiA2GJL7eI6ED3nBLRgZLxpAcX F3d7AA94SV0QzCsHRHOc0++M5jhY6oy7ojnOy9E9lZiIA19WF8TP7QEsKrfsn2/o dlVRHKZ4QWEUh8FSVY0jeR9c4UfdozhMcqqL47pxl0EsG4igJrVWFwQ0cpNIzr3/ ZqMojoKlvt04iqOUjOgcxWESNLmNuiABjg/gwL3UBUFN2nB6BEc58/YIDoJlzroj goO0+M66OXljb3VBAhwfwFPuURcENnvTMfkfpGiB4XeEskhl4wh+Euz4S/7HSNqp 96oLEuD4ADadpS4Irmz7L/M/yIfb538MLDVkh/yPsfkX+R8jcavMVhckwPEBLJi5 iroguMp9/5f3MXZ9O4IQLLHbO3kfYs83IuhI2ixbLiWSF9cH8CMb385ddeIjeR/D xuU3UgQ7cNzDEXQk7uPt1AVJcH0A7Tr1foXL++Z7BO4MEpH87wZyWWTv8ElUdG9M MpnrA9j+N3VBOPefnOcB2k5w/Y82GdVrTMzzCPf9I5KQxK05Tl2QBOe/SuaVqgvC GZjvbd25O2Yk8r4f5gBLTyaZv5K6IBHOD+BX3dQFIQ3bKr+zL3gZJBJ5vgRS9Jm1 n3+bqQsS4fwAXn+RuiCsfO8UMtG6M28NNKltXh9uz90/6uh3sbogEc4PYKdR6oLQ pm+U19NP/7wpqhCPnf+ffD667e9RdSRvndHqgkQ4P4AFC+y9uf2C7l/n8dGF8+z9 JzdF2Ur5XJyi64jIQhJX1lhdkAz3B9DmFwPyOyXasqvPmSivKzRaefrzcnm/+GMJ 9wfwpn+qC/JQfep94T+4eI5FdwQwUvnKeVwI62Sr30r7n/PVBclwfwDX+0FdkJfr Lwn/sXwLmKd8vgG8zu4XEdb/UV2QDPcHsKDM7lu7PHN46A8tmsOzgPkoWzn8mUhP HxZhSPIW+vKZ48EA2n5x0I93CP1EfJ8rowzxzlV9wn5k4Yc2vge9hmguAmsBDwbQ 6icBlxjddX7YD53hxRU9YjKzediPLP3aqtsRpuHLU4A+DKBNt0dPb9omE0J+5MHP Rxril94vhPzANcZH2qHgwS3Rl/FgAAvmW39K04LthoX8yBFdIw3xyddhz5/q9lWk HQoLLH0HfXA+DOCX9r+rsfLgV8J9YIdfuD9cOFVr/xruA/d34GaSX3lzY2kfBvCa y9QF+as+79ZwH/jvC6IN8caN/wr3cefcEm2HRN/L1QVJ8WEAbb0mYKo7zwz3cePa RdvhifHtw33cHWdE26Hhx7UAl/BhAAvmNFEXRCHkXQrX+44fgoOr2jDcicD23Yc1 nbkrqwsS48UAftJdXRCJHzcPdTrM+TdGHeKBC0JdSqf0y/WiDpEYuo26IDFeDODF 16kLojGtW6ifTKy8MZRWuBsCufFcy2KXXK8uSIwXA9hyirogImU7Dw3xUSUTWkRe 4rbpa5SF+Kjun0QeIrLaVHVBYrwYQHfeEFH19/4hPqrjTw0jL3FZRZcxIT7q6Mcj DxEJ/xYY+/gxgO/soi6IzLVhzunp9Zoff87RqN53QIiP6ntp5CEq7+6qLkiOH18Y dl+aLdWr+4f4oNPuirzDXaffHeKDXtkv8g6ZU/K4CKVt/BjA0rkO/XOGejHYldeB EhDmFQBXXv5dqrpJ6Itv2MehYchmUmt1QYSmbxHiKSqHfkKLV5jnGDr+En2HzmSf bifoyQD+90B1QZTK9w5xs1on3qIVu1BvOXTsFswvHaQuSJAnA+jCG9RrqD77juAf dOgz0Ye4puqIZ4N/0Jm3Rx+idEDIC29YyZMBLKxw7P1gjxwf/GO2/Cz6DrfM2fXz 4B/08HHRhyhVNcznVqC28WQAC8aspS6I2FfbBL9hWZMhFt8iNAEjtp8b+GOKP7H/ YmupxnZUFyTJlwF8KMR3TGabukWI69X1uzD6EFdU3XhR8A/q8EXL6Eu0Hj5BXZAk XwZw6zDvITNb+YEDg39Q+/9tEH2JE77fM8QbrfcOc8q04bp/qi5Iki8DWLDQvZuE V18T5qZvLp0UHp3Z/wpz8u9VV0QeIldu911kg/JmAIe7+PTX23uEeb76XzdEHmK5 2df+O8RHFb65W+QleiM2VRckypsBdPFf1gUFv28xMcyHnXLeulGXWOznm0N9U9z2 i9WjLjHB1X7dS9qbAWw9SV0Qi4X7vRXmw7qOiDrEYpt8Heajdn8z6g4ztJmsLkiU NwPoziWxUlXfcHGIj7o+xAuezurH7+BffLoU1hL+DOAgF5+wWeKTnYKfEejITQKi EeIC8MXvu3rR+Ld7qguS5c8AHvuouiAuM7b/PuiHzFwljhBLzQr8s8EG38XRYYS/ P6YuSJY/A1hc5uw/66IzAj6L32xGPCGWaj4z2K8/5Z54OgxQXRL8xwmrOTsKdbl8 g9w39qsM8su5MkyKcwNdAaboVSdufZle2NshW8ujAXzsGHVBjKbsGOQ+tu/3iC3E RoN3CvCL1/tgtbg6DPD4seqChHk0gO7ctCudRRf+J/dfzFOAKYI8CfjPUDcMtsY2 7r1lNDuPBrCgzO03+XzcM9crmbeYFmuIfVadnuMvLB3k9j2WF5aoC5Lm0wB+1U1d EK95Bw7K7Rdecm28Ida5NMc7pvQMdda5RYa5dm2vevk0gJddoy6IWfWTx+b03mAn 3xedj9ze/1r42FFxh6hd3lddkDSfBtCDn/ym7DEsh19Vzn3SU1Xkcqmgbm+6/OrH Mjk/F+AMnwawYOqq6oLYVT90Ur2/5uDnEwixS+8X6v0lD5yYQIfYNOeu7lovrwbQ pZtXZzTlgI/r+RWDd0wkxCYf1Hde0LYvu//tX0HBq/urCxLn1QA6dm+4DKpfPizr 2fyFZfwEXFtFSdYnT4ufceq2qhl5dT+4ZbwawMLyBuqERMw7tX+Wv8slodM4JdsF oY9+PLEOqUXFPt0PbhmvBrDgp87qgoR8f+DIjH/PuRvkRWH0Ohn/VueXfLmNysgu 6oLk+TWAN5+rLkhK9UtHZzgt2uErmeRjwwxX1Cntf1CyIUK3nKcuSJ5fA9hhrLog OeW3X5j2BxouBZhW+osCFt5wftIhQmuFuNGq7fwawIJZTdUFCZrXL81prXwDmF71 Rmm+BbzsopWSL5GZ7eM7xD0bQGcvC53e3Lsuq32ZrGpJiAV+XL/WXyjqe3oTSYmK bxeDXsqzATziSXVBwipePzfl5xquBJhR6lUBO9yyj29nCx35lLpAwLMBLKwoVCck buxdd5Yt/99uXxIsP1XbrbgUVMkZp68lLNGoaujfSTDeDWDBqE7qAoHqX/731NK3 h5x0vzrFZJWnPbDkv7Y9Ys+1ffuyWCLLmUAO8+1P+vYz1QUiVQsa+/fNb1AVs6ob l/r623THWeoCBd8GsNModQFgpHVGqwsUfBvAgtkrqwsAA83x6Qyxv3g3gO/soi4A DPTuruoCCe8G0Jc3tgOBHJPtAhru8m4Aixb6+iQ3kFlVo0B3lnaGdwPo54kwQHZ+ ngTj4wDeera6ADDObeeoCzT8G8COv6gLAOOsPUZdoOHfAPp1RRggF15eCWYJDwfw LR8vegFkM2h3dYGIhwN4uI8XvQCyOeJpdYGIhwPoy62RgFz5eDukZTwcQH9ujQTk xsfbIS3j4wDe6NN9HoD63XSBukDFxwFs/5u6ADDKmuPUBSo+DmDBjGbqAsAgM5ur C2S8HMDXe6kLAIMM2EddIOPlAO7/sroAMMgBr6gLZLwcwIKKInUBYIxK3+5/V4Of A/jNRuoCwBjfbqwu0PFzAPtcqS4AjHFVH3WBjp8D2HKKugAwxmpT1QU6fg5gwR+r qQsAQ0xppS4Q8nQAnz1EXQAY4rlD1QVCng7gjoPVBYAhenygLhDydAALyhqpCwAj LCxRFyj5OoCfbakuAIzw+VbqAiVfB/Cs29QFgBHOvl1doOTrAJbM9/WfHKipurRM naDk7Qz8uqa6ADDAbx3UBVLeDuDdp6oLAAPcc5q6QMrbAVx3pLoAMEDnn9UFUt4O ILcHBjy+IfCf/B3A/+2hLgDk3txTXaDl7wAe9KK6AJD723/VBVr+DiBXRQV8vhbq Uh4P4NceXwYSWOqbruoCMY8H8PKr1QWA2BXXqAvEPB7AZjPUBYBY85nqAjGPB7Bg Yht1ASA1qa26QM3nAXzsGHUBIPX4seoCNZ8HcNNh6gJAqttwdYGazwNYMHcldQEg NK+JukDO6wF8byd1ASD0/s7qAjmvB/CIJ9UFgNCRT6kL5LwewMLyBuoEQGZRcZU6 Qc7rASz4fn11ASDzwwbqAj2/B/Cay9QFgEzfy9UFen4PYMsp6gJAZrWp6gI9vwew YHIrdQEg8kdrdYEBPB/Apw5XFwAiTx+hLjCA5wO49VB1ASDS/VN1gQE8H8CC+Y3V BYDEglJ1gQl8H8APt1cXABJDdlAXmMD3ATzuYXUBIHH8I+oCE/g+gEULC9UJgEBV o0p1ggl8H8CCnzqrCwCBkV3UBUbwfgD7XaguAARuuEhdYATvB7D1JHUBINBmsrrA CN4PYMGUluoCIHFTV1MXmIEBfK63ugBI3POHqAvMwABu+5G6AEjcdh+rC8zAABYs KFEXAAkr4x1QyzCABUO2UxcACfuId0AtwwAWnPiAugBI2EkPqgsMwQDyZhB4h7eB LMcA8mYQeIe3gSzHABYUXM858fBLv4vVBaZgAAsKWnFOPPzS+g91gSkYwMX+4Kx4 +GQKt8JZjgFc7OnD1AVAgp7hVjjLMYAF3BkEnuFuICswgEtwZxB4hLuB/IUBXGLw juoCIDEf9FAXmIMBXOLYR9UFQGL+/pi6wBwM4BL/ukFdACTmwn+rC8zBAC5RvFBd ACSmUbm6wBwM4FKcCQhvcBZgDQzgUpdcqy4AEnLpdeoCgzCASxVVqAuAhDTkSjB/ YQCXmd5cXQAkYkYLdYFJGMBl+l6qLgASce1l6gKTMIDLFC5SFwCJaFClLjAJA/in WU3VBUACZq+iLjAKA/in4x9SFwAJOOFhdYFRGMA/FVZwZxC4r6ohPwHXxAAuN6Kr ugCI3debqAvMwgAud/hT6gIgdkc8rS4wCwO4QhW/F3BdNU/0pOKLfoXf26oLgJhN XF1dYBgGcIUL+6kLgJhdxIXfUjGAf6lWBwAx4+u9Fn5D/sKdQeA47gZSGwP4lzd3 VxcAsXprD3WBaRjAv/R4X10AxGqnweoC0zCANVQ2UBcAMVpUpC4wDgNYw5i11AVA jMZ2VBcYhwGs4Ykj1QVAjJ48Sl1gHAawhr0HqAuAGPUaqC4wDgNYA1eEgcu4Ekxd DGBN49qpC4DYjG+vLjAPA1jTc73VBUBsnj9EXWAeBrCmA15SFwCxOfBldYF5GMCa isr5/YCrqou5IXAdfMGnmMDVguCq39dQFxiIAUzx0gHqAiAmLx+oLjAQA5ji0GfU BUBMDntWXWAgBjAFTwLCVTwFmA5f76m4Lj4cxdXw02EAU81eWV0AxGIQl7tMgwFM xQVh4KbqJvPVCSZiAFPdco66AIjDtJbqAiMxgKnWGK8uAOLwdk91gZEYwFqmrqou AGJw+t3qAiMxgLU8yxvG4aJVZqsLjMQA1rL1UHUBEL0ZLdQFZmIAa+PuwHDQ4J3U BWZiAGt7v4e6AIjc+f9RF5iJAaztqP7qAiByq05XF5iJAayNG4PAPbNXURcYigGs 46fO6gIgYh9try4wFANYx43nqwuAiF1yvbrAUAxgHbwZBM5p/Ye6wFAMYF2zmqoL gEjN5SJHGTCAdb27s7oAiNTQbdQFpmIA6zrpfnUBEKnL+6oLTMUA1lUyn98VOGX1 ieoCU/GlnsYfq6kLgAjxFGBGDGAaA/ZWFwAR4inAjBjANE58QF0ARIinADNiANMo nacuACLUZrK6wFgMYDrTm6sLgMjwRuDMGMB0PthBXQBEZgifzhkxgOlccq26AIgM 1wLMjAFMh7cDwyHNZ6oLzMUApsV18eEMbgeSBQOY1jcbqQuAiAzaXV1gMAYwrbtP VRcAETnhYXWBwRjAtLb/UF0ARKO6pFydYDAGML3KBuoCIBKT2qoLTMYApje2g7oA iMQLvdUFJmMA03vqcHUBEIn9XlMXmIwBTG/fV9UFQBSqGlapE0zGAKbH3YHhhjFr qwuMxgBm8Ft7dQEQgYdOVBcYjQHM4OnD1AVABLp/qi4wGgOYwe5vqguA/JU3UheY jQHMpKJIXQDk7duN1QVmYwAzGbmuugDI2w0XqQvMxgBmcvuZ6gIgb2uPUReYjQHM ZL0f1AVAvuY1URcYjgHMaF6pugDI00fbqwsMxwBm9El3dQGQp7NvVxcYjgHM6Pwb 1QVAfqqbzlUnGI4BzKjpLHUBkJ8prdQFpmMAM5vJ7VRht8+3UheYjgHM7PmD1QVA Xnq/oC4wHQOYWc+31AVAXhpwKax6MIBZLOKSWLAZZwHWiwHM4tc11QVAHt7dVV1g PAYwi2suUxcAedjqc3WB8RjALFpNVhcA4VXzFE69GMBsFharC4DQZjZXF5iPAczm i83VBUBozx2qLjAfA5jNQS+qC4DQVp+oLjAfA5jVlJbqAiCkqgbqAgswgFm9eJC6 AAhpcht1gQUYwKwOfl5dAIR0J9c0rx8DmFVROb9BsFTjMnWBBfj6zm7C6uoCIBTe B5cLBjC753qrC4BQnj9EXWADBjC7A15SFwChHPiyusAGDGB2hRW8nQg2qmrIpbBy wADW47f26gIghHFcyigXDGA9njpcXQCE8PQR6gIrMID12HuAugAIoddAdYEVGMD6 VPKGIthnUZG6wA4MYH3GrKUuAAIb21FdYAcGsD6PHaMuAAJ7/Fh1gR0YwPrs+ra6 AAhst3fUBXZgAOtVwbMpsE1lQ3WBJRjAeo3qpC4AAhq9jrrAEgxgvR48QV0ABPTQ ieoCSzCA9dr+Q3UBENAOQ9QFlmAA61fO8ymwSwW3M8wRA1i/nzqrC4BARnZRF9iC AazfPaeoC4BA7j1VXWALBrB+W36mLgAC2epzdYEtGMAcLOQZFdikvJG6wBoMYA6+ 20BdAATw/YbqAmswgDm45Rx1ARDAreeqC6zBAOZgvR/UBUAA6/+oLrAGA5iLBSXq AiBnZY3VBfZgAHMxbFN1AZCz4d3UBfZgAHPR91J1AZCzay9TF9iDAcxF+9/UBUDO 1hynLrAHA5iTuSupC4AczWuiLrAIA5iTT7qrC4AcDd1GXWARBjAnF1+nLgBydMn1 6gKLMIA5aTVZXQDkqPUf6gKLMIC5mbmKugDIyaxm6gKbMIC5eb+HugDIyeCd1AU2 YQBzc+bt6gIgJ2fdoS6wCQOYm6az1AVATlaZrS6wCQOYo6mrqguAHExrqS6wCgOY o//toS4AcvDmnuoCqzCAOTruYXUBkIPjH1EXWIUBzFHJfH6rYL7q0jJ1glX4qs7V xDbqAqBek9qqC+zCAObqxYPUBUC9/vs3dYFdGMBc7f+yugCo1wGvqAvswgDmqrCi UJ0A1KOqYZU6wS4MYM7GrKUuAOoxtqO6wDIMYM4ePk5dANTjkePVBZZhAHO2/Yfq AqAeOwxRF1iGAcxdeUN1AZBVRbG6wDYMYO6+X19dAGT1wwbqAtswgLm79Wx1AZDV beeoC2zDAOZuvR/UBUBW6/+oLrANAxjA/MbqAiCLBaXqAuswgAF8uZm6AMjiq83V BdZhAAPoc6W6AMjiqj7qAuswgAG0/V1dAGSx+kR1gXUYwCBmr6wuADKa01RdYB8G MIgPdlAXABl9uKO6wD4MYBBn3aYuADI6m3u3BsYABsHNMWEwbogZHAMYyBTuOQhT TV1NXWAhBjCQ13upC4AMBuyjLrAQAxjIEU+qC4AMjnxKXWAhBjCQonJ+w2Cm6uJK dYKF+HoOZlw7dQGQ1vj26gIbMYDBPHGkugBI68mj1AU2YgCD2fVtdQGQ1m7vqAts xAAGVFGkLgDSqOSGDWEwgAH91FldAKQxsou6wEoMYEB3nKEuANK480x1gZUYwIA2 +kZdAKSx8bfqAisxgEEtKFEXAHWUcbuGUBjAoLguPgzE1fDDYQCD4rr4MBBXww+H AQyK6+LDQFwNPxwGMLBZXHgcppm9irrAUgxgYIO58DhM80EPdYGlGMDAzuTC4zDN WXeoCyzFAAbWZI66AKhl5bnqAksxgMH9waXHYZYprdQFtmIAg3tlP3UBkOLV/dUF tmIAgzv4eXUBkKL3C+oCWzGAwRVWFKoTgBqqGlapE2zFAIYwZi11AVDD2I7qAmsx gCE8dLy6AKjh4RPUBdZiAEPYeqi6AKih+6fqAmsxgGEsLFYXACuUN1IX2IsBDOPr jdUFwArfdFUX2IsBDOP6i9QFwAr9LlYX2IsBDKPDWHUBsMJav6oL7MUAhjKniboA +NPcldUFFmMAQxmynboA+NNH26sLLMYAhnLOLeoC4E/n3qousBgDGErTWeoC4E+r zFYXWIwBDGdKS3UBsNRUrs6WBwYwnFf3VRcAS73G1dnywACG0/s5dQGw1CFcnS0P DGA4XBILZuBSWHlhAEMa20FdACz261rqAqsxgCE9fJy6AFjsEa7Nlg8GMKTun6gL gMW24dps+WAAw+KSWDAAl8LKDwMY1giuQQS9rzdRF9iNAQzrOq5BBL3rL1EX2I0B DGuN8eoCoKDdBHWB3RjA0GZzFSKozWmqLrAcAxja+z3UBfDe4J3UBZZjAEM77S51 Abx3+t3qAssxgKGVzuU3D1rVTearEyzH13B4k1qrC+C5yW3UBbZjAMN78SB1ATz3 37+pC2zHAIbX63V1ATy3zwB1ge0YwDxUNlAXwGuLitQF1mMA8/DzOuoCeG3UuuoC 6zGAebjzdHUBvHbXGeoC6zGAedjoG3UBvLbxt+oC6zGA+ZjfWF0Ajy0oVRfYjwHM x+dbqAvgsS+2VBfYjwHMxyXXqgvgsUuvUxfYjwHMR8sp6gJ4bLWp6gL7MYB5md5c XQBvzWihLnAAA5iX/+2hLoC33txTXeAABjAvR/VXF8BbRz+hLnAAA5iXonJ+A6FR XVypTnAAX7/5+a29ugCeGremusAFDGB+HjtGXQBPPX6susAFDGB+tv1IXQBPbfex usAFDGCeFharC+Cl8kbqAicwgHn6ZiN1Abz07cbqAicwgHm6/iJ1AbzU72J1gRMY wDy1/01dAC+tOU5d4AQGMF+zV1YXwENzmqoL3MAA5mvwjuoCeOiDHuoCNzCA+Trt LnUBPHT63eoCNzCA+Sqdy+8hklbdZL46wQ188eZtYht1Abwzqa26wBEMYN6eP1hd AO+80Ftd4AgGMG97D1AXwDu9BqoLHMEA5q+ygboAnllUpC5wBQOYv586qwvgmZFd 1AWuYADzd/uZ6gJ45o6z1AWuYADz1/kndQE802WkusAVDGAE5pWqC+CV+SupC5zB AEbgk+7qAnhl6DbqAmcwgBH4503qAnjl/P+oC5zBAEag6Sx1Abyyymx1gTMYwChM aakugEemrqYucAcDGIVX9lMXwCOv7q8ucAcDGIWDXlQXwCN/+6+6wB0MYBQKKwrV CfBGVcMqdYI7GMBIjOqkLoA3Rq+jLnAIAxiJe05RF8Ab956qLnAIAxiJriPUBfDG Jl+rCxzCAEZjQYm6AJ4oa6wucAkDGI3Pt1AXwBNfbKkucAkDGI1LrlUXwBOXXqcu cAkDGI2WU9QF8MRqU9UFLmEAIzKthboAXpi+qrrAKQxgRAbupS6AF97YW13gFAYw Ikc8qS6AF458Sl3gFAYwIkULeTcc4lfVqFKd4BQGMCpjO6gL4IFf11IXuIUBjMqD J6gL4IGHTlQXuIUBjMrmX6gL4IEtvlQXuIUBjExZI3UBnLeQt1xGiwGMzFfd1AVw 3rDN1AWOYQAjc/nV6gI474pr1AWOYQAj02qyugDOa/2HusAxDGB0pjdXF8BxM3jD ZcQYwOj8bw91ARz35p7qAtcwgNE5qr+6AI47+gl1gWsYwOjwbjjEi/fBRY4BjNCv a6oL4LTfeLtl1BjACD10vLoATnuYt1tGjQGM0JafqQvgtK0+Vxc4hwGM0iKeBER8 qhqoC9zDAEZpwurqAjjs9zXUBe5hAKPU70J1ARx2w0XqAvcwgJGa0lJdAGdNXU1d 4CAGMFIvHaAugLNePlBd4CAGMFL7vqougLP2e01d4CAGMFqVvFCHeCwqUhe4iAGM 1o9d1AVw1E/rqQtcxABG6+Zz1QVw1C3nqQtcxABGq+Mv6gI4au0x6gIXMYARm72y ugBOmtNUXeAkBjBi7/dQF8BJg3dSFziJAYzYSferC+CkfzygLnASAxix4jJ+SxG9 6pJydYKT+GqN2rh26gI4aHx7dYGbGMCoPXaMugAOevxYdYGbGMCobT1UXQAHdf9U XeAmBjByZY3UBXDOwhJ1gaMYwMh91U1dAOcM20xd4CgGMHKXXaMugHMu76sucBQD GLkW09QFcM6q09UFjmIAozethboAjpm+qrrAVQxg9AbsrS6AYwb2Uhe4igGM3qHP qAvgmMOeVRe4igGMXtFCbg+MKFU1qlQnuIoBjMGYtdQFcMrYjuoCZzGAMXjwBHUB nPLQieoCZzGAMdj8C3UBnLLFl+oCZzGAceDdcIgQ74OLDwMYh2GbqgvgkOG8uTI2 DGAc+lypLoBDruqjLnAXAxiH1pPUBXBIm8nqAncxgLGY0UxdAGfMbK4ucBgDGIu3 eqoL4IxBu6sLHMYAxuLYR9UFcMbfH1MXOIwBjAX3hkNUuB9cnPg6jQf3hkNEuB9c nBjAeDx+tLoAjujPbQZjxADGY/sP1QVwxA5D1AUuYwBjUt5QXQAnVBSrC5zGAMbk m43UBXDCtxurC5zGAMak34XqAjjhhovUBU5jAGPSYay6AE5Y61d1gdMYwLhUqwPg BL5CY8Vvb1w+3kZdAAd8sq26wG0MYFz+eZO6AA44/z/qArcxgHFpNkNdAAc0n6ku cBsDGBueBET++AKNF7+/sRm4l7oA1ntjb3WB4xjA2BzVX10A6x39hLrAcQxgbIoq 1AWwXsNKdYHjGMD4jF9DXQDLTeCqajFjAOPz9GHqAljumcPVBa5jAOOz5xvqAlhu r/+pC1zHAMaIE2GQH74848bvcIxGdVIXwGqj11EXOI8BjNEDJ6oLYLUHT1IXOI8B jNGWn6kLYLWtPlcXOI8BjBNPAiIffHXGjt/iOH27oboAFvuO2yrEjgGM043nqwtg sZsuUBe4jwGMU6dR6gJYbJ3R6gL3MYCx4klAhMcXZ/z4PY7VJ93VBbDWUG6qED8G ME4tH9lHnQBrvX7cVHWC+xjAWJ11m7oA1jr7dnWBBxjAWO09QF0Aa/UaqC7wAAMY q67/5e3ACGf0QV+rEzzAAMaq6X1cExDhPHPybHWCBxjAeJ10v7oAlvrHA+oCHzCA 8dr9TXUBLLXHW+oCHzCA8VrvBd4OjDC+O/hHdYIPGMB4Fd9+sjoBVrrvrHJ1gg8Y wJgd/bi6AFY6httKJ4EBjFmP99UFsNJOg9UFXmAAY9bx6a3VCbDQp4ePUSd4gQGM 2/UXqQtgoX4Xqwv8wADG7dBn1AWw0GHPqgv8wADGrfsrrdQJsM4f+w9VJ/iBAYxb 6/491QmwzqCjJ6sT/MAAxu78G9UFsM4FN6kLPMEAxm7fV9UFsM5+r6kLPMEAxo5L YiEoLoWVFAYwdqX3Hq1OgGX6nzJfneAJBjB+J3JdIwRz0oPqAl8wgPE77S51ASxz +t3qAl8wgPFjABEQA5gUBjB+DCACYgCTwgBGpeluPTfr1KyBOgMO++yrQW9zo5BI MYARKNroyJ27NFFXwA9fvvfkt5XqCGcwgPnqePp+66ob4JmfX72Lq2VFggHMR/Fe p/NGX2gMuusNLpqfNwYwvK5991UnwGuvXcYbRvLEAIbU4rKjVlM3wHtTnug7Xd1g NQYwlM538qMvzDDojJHqBIsxgCF0fnAHdQKwwocnMoFhMYCBtXqQp/5gltdO/EOd YCkGMKDSC/qoE4A6+tzI9WPCYACD4eJ+MBOXEAyFAQyi5Pxr1AlABpffVKZOsA8D GECLx/ZRJwAZvX4sp8QExQDmrtOgjuoEIIsxPUerE2zDAOZs7wHqAqAevQaqCyzD AOao6JiH1AlAvU54nCvFBMEA5qbw7+wfbHDCo1XqBJswgDlh/2ALFjAIBjAX7B/s wQIGwADm4oCX1AVAzg58WV1gDwawfiXnXatOAAK49GZOic4RA1i/riPUBUAgm/C2 uBwxgPVq/5u6AAhozXHqAkswgPVpctcx6gQgoMdPn6tOsAMDWJ/d31QXAIHt8Za6 wA4MYD06jFUXACGs9au6wAoMYHZN7j1SnQCE8OQp/BCcAwYwu31fVRcAoez3mrrA BgxgVmuMVxcAIbWboC6wAAOYTfGlV6gTgJCuvrZcnWA+BjCbdbndIOzV+Wd1gfkY wCyaPr23OgEIbeDhs9UJxmMAs9h6qLoAyEP3T9UFxmMAM2v9RTt1ApCH8VtMVieY jgHMjPeAwHK8H6Q+DGBGnAID63EqTD0YwEyKzrxZnQDk6bw7uEdSVgxgJh1/URcA eVt7jLrAbAxgBqV3HK9OAPL28Jnz1QlGYwAz6DRKXQBEYJ3R6gKjMYDpld53lDoB iMATJ/MtYBYMYHpcBhCO4MKA2TCAaRX3vUCdAETixsu4JkJmDGBarSepC4CItOHt IJkxgGnxJhA4g7eDZMEAptP0v7uqE4CIvHMQF4XJiAFMh3Ng4BDOhMmMAUyj2fub qBOAyIzYaaY6wVgMYBpcBgFO4ZIIGTGAafA2YDiFNwRnxACm0e0rdQEQoc2GqQuM xQDW1eLTddQJQIRGbT1dnWAqBrAungKEY3gSMBMGsC7eBwzH8H7gTBjAurqOUBcA kdrka3WBqRjAOpoO2kqdAETqs568GSQ9BrAOLoQA53BBhAwYwDra/6YuACK25jh1 gaEYwDp4DQTO4VWQDBjAOnZ+V10ARGyX99QFhmIAa2s2tIs6AYjYT925HkJaDGBt bX9XFwCRW32iusBMDGBtvAYCB/EqSHoMYG28BgIH8SpIegxgbbwPBA7ivSDpMYC1 NP2Aq0HDPSN25L0g6TCAtfA+EDiJ94KkxQDWwrWw4CSuiJUWA1gLLwLDSbwMnBYD WAsvAsNJvAycFgOYqvS5XuoEIAYDDpmvTjARA5iq5ferqROAGEzZYKo6wUQMYCre CAdH8Wa4dBjAVLwIDEfxMnA6DGAqXgOBo3gVJB0GMEXhoU+pE4BYHPFslTrBQAxg iqafbKBOAGLx/Ta8Ga4uBjBFK94vBFe1/kNdYCAGMAUvAsNZvAycBgOYgheB4Sxe Bk6DAUzR4311ARCTnQarCwzEANZUfPWF6gQgJjdcUa5OMA8DWFOLb1ZXJwAx+X3j 6eoE8zCANfEiMBzGy8B1MYA18SIwHMbLwHUxgDXxHSAcxneAdTGANfEdIBzGd4B1 MYA1cRogHMaJgHUxgDUxgHAYA1gXA1hDyWOHqBOA2Dx3bJk6wTgMYA1NB2+qTgBi M7wH14OpjQGsocWP3BAE7pqyHmdC18YA1sBZMHAa58HUwQDWwFkwcBrnwdTBANbA i8BwGi8D18EA1sAAwmkMYB0M4F9KHjlMnQDE6JnjOA+mFgbwL03e2UqdAMTos13n qhNMwwD+pdk37dQJQIzGbzxTnWAaBvAvLaeoC4BYrTZVXWAaBvAvrSepC4BYteFM 11oYwL9wGiAcx4mAtTGAf2EA4TgGsDYGcIXifueqE4BY3XIRN4ZLxQCuUPpcL3UC EKsBh8xXJxiGAVyh6UcbqROAWH27HRfESsUArtDsp1bqBCBWf3ThRMBUDOAKnAYI 53EiYC0M4AqcBgjncSJgLQzgCpwFA+dxHkwtDOAKDCCcxwDWwgAuV9z3AnUCELMb L+NEwBQM4HIlz+yvTgBi9sphXBEwBQO4XJMPuScmXDd8B64ImIIBXK7ZDHUBELvm nAiYggFcjtMA4QFOBEzFAC7HaYDwACcCpmIAl2MA4QEGMBUDuBynAcIDnAiYigFc jgGEBxjAVAzgn0oePlydAMTu6eM5EbAmBvBPTYZuqE4AYvddd04ErIkB/BOnAcIL nAiYggH8E6cBwgucCJiCAfxTK04PgA9a/6EuMAoD+CdOA4QXOBEwBQP4JwYQXmAA UzCAf2IA4QUGMAUD+CcGEF5gAFMwgMsU33y6OgFIwF3ncU3oGhjAZUpf31mdACTg vX3mqxNMwgAu03TY2uoEIAG/dJutTjAJA7gMbwSBJ3grSE0M4DK8EQSe4K0gNTGA y/AiMDzBy8A1MYDLMIDwBANYEwO4VPHtJ6sTgETcdxbnwfyFAVyq9I0d1QlAIj7Y i/Ng/sIALlPy6DrtWqsjgHgtnDl+1N+5JHQNDGBNJedt0nmN1dQVQNQqZk4YOeJm pq8OBjCNkgs3Wnd1dhAOqJj5+8/f3sDyZcIAZlZ6wYbrtuXnYlipfMbEn7+7kaf7 6sEA1q/FPR3XWF0dAeSkumzGhDGnTldn2IIBzFmL69fp0EkdAWSwaO7UX0ddzPIF wwAG1ezc9TuuzjeEMMXib/l+H/PDLbzDNxQGMKyWF667VhueIYRK9cJZk8b+fAPv 7M0LA5ivVhesvWabduoKeGPRgpmTfvvlRm7uFgkGMDJr9Gm/xmp8S4h4VC2cPWXC uD4T1B2OYQCj1+GKdm1Wa6uugBMWlc2eMmn81b+qO1zFAMao/Wnt27VqwTeFCGpR 2dzpf4wfd/c4dYjzGMBEtD+xXbvWq/JMIbKorpw/Z9rk8eMfZPaSwwAmrdNJq7dZ rdla6gyYoap8/uyZUyb9/sBodYmfGECl9U5o1XrV5iu3UncgSdWVC+fPmTFt8h8P /ahOAQNojK7Hrdpy1WZNOMfaQYsqyubPnTlt6rRHvlanIAUDaKhND2veskWzlVdq ow5BCNWLKhcumDdn5vSpM54Zro5BFgygJbbt3bRFs6YrlzZu1LBY3YJaqqsWVSxc MH/O7JnTZz//sboGATCA1upxYJOmzZs0WTyJxQ0bNOAPMinVixZVlC+eu7lzZ8ye +9JgdQ7ywteNU3r2LF2l6cqNF4/i4lUsWjyL/PmGV7146ioXb93isVswZ/as+YMG qYsQOb5AvLD/do1LV1pppcYli4exUdHibxgLCwvVTYaoqqpa/C1d5cLFQ1e2YN68 efMXfPSKugmJYQC9d0C3RiuVlpY0blSy+LvG4uKioqKl++jIN4/V1UsXrrKysrx8 8XdzZQsXlM2fP2/hsJfVYTCCG5/liNfh6zQqLSlevJBFJcVFDRst/g5y8X8Wz2SD wv9bupRJfxZVL9216qpFi6dt8bdvi/+zsKKyvKxy8b6Vl81fOOrphHtgLQYQ0Tu9 RePCksLG/1dSWPJ/BRVbF9X4NPu/lP9aorrWfy/5X5WfNiyoLqsqq15QVVa1YPpd CTTDSwwgAG8xgAC8xQAC8BYDCMBbDCAAbzGAALzFAALwFgMIwFsMIABvMYAAvMUA AvAWAwjAWwwgAG8xgAC8xQAC8BYDCMBbDCAAbzGAALzFAALwFgMIwFsMIABvMYAA vMUAAvAWAwjAWwwgAG8xgAC8xQAC8BYDCMBbDCAAbzGAALzFAALwFgMIwFsMIABv MYAAvMUAAvAWAwjAWwwgAG8xgAC8xQAC8BYDCMBbDCAAbzGAALzFAALwFgMIwFsM IABvMYAAvMUAAvAWAwjAWwwgAG8xgAC8xQAC8BYDCMBbDCAAbzGAALzFAALwFgMI wFsMIABvMYAAvMUAAvAWAwjAWwwgAG8xgAC8xQAC8BYDCMBbDCAAbzGAALzFAALw FgMIwFsMIABvMYAAvMUAAvAWAwjAWwwgAG8xgAC8xQAC8BYDCMBbDCAAbzGAALzF AALwFgMIwFsMIABvMYAAvMUAAvAWAwjAWwwgAG8xgAC8xQAC8BYDCMBbDCAAbzGA ALzFAALwFgMIwFsMIABvMYAAvMUAAvAWAwjAWwwgAG8xgAC8xQAC8BYDCMBbDCAA bzGAALzFAALwFgMIwFsMIABvMYAAvMUAAvAWAwjAWwwgAG8xgAC8xQAC8BYDCMBb DCAAbzGAALzFAALwFgMIwFsMIABvMYAAvMUAAvAWAwjAWwwgAG8xgAC8xQAC8BYD CMBb/w8BjFfiVF8wdQAAAABJRU5ErkJggg=="/></symbol><g mask="url(#b)"><g transform="rotate(.193) scale(.36014)"><symbol id="c" viewBox="0 0 1280 1280"><image width="1280" height="1280" xlink:href="data:image/png;base64, iVBORw0KGgoAAAANSUhEUgAABQAAAAUACAIAAACXhmigAAAACXBIWXMAAA7EAAAO xAGVKw4bAAEz2klEQVR4nOzdCZxcVZn//6S7et/3rt47TUggJEHceMko/hQUcQN1 nD8KyjLzg98oOC8cUCFMEIFBMUxgUGAMCANhkzVsWVDAGGIka8dg0IHupNd07ft2 69b/dBW0mZil07mnzr1Vn/draBOWp59Jd1ffb59znjN7FgAAAAAAeWC26gYAAAAA AMgGAjAAAAAAIC8QgAEAAAAAeYEADAAAAADICwRgAAAAAEBeIAADAAAAAPICARgA AAAAkBcIwAAAAACAvEAABgAAAADkBQIwAAAAACAvEIABAAAAAHmBAAwAAAAAyAsE YAAAAABAXiAAAwAAAADyAgEYAAAAAJAXCMAAAAAAgLxAAAYAAAAA5AUCMAAAAAAg LxCAAQAAAAB5gQAMAAAAAMgLBGAAAAAAQF4gAAMAAAAA8gIBGAAAAACQFwjAAAAA AIC8QAAGAAAAAOQFAjAAAAAAIC8QgAEAAAAAeYEADAAAAADICwRgAAAAAEBeIAAD AAAAAPICARgAAAAAkBcIwAAAAACAvEAABgAAAADkBQIwAAAAACAvEIABAAAAAHmB AAwAAAAAyAsEYAAAAABAXiAAAwAAAADyAgEYAAAAAJAXCMAAAAAAgLxAAAYAAAAA 5AUCMAAAAAAgLxCAAQAAAAB5gQAMAAAAAMgLBGAAAAAAQF4gAAMAAAAA8gIBGAAA AACQFwjAAAAAAIC8QAAGAAAAAOQFAjAAAAAAIC8QgAEAAAAAeYEADAAAAADICwRg AAAM09raIr63jo+Pz+w/nDUrNT6+T0ZjAABgFgEYAICZaW1tLSgoKCwsSL8trK2t i8dj4hepNPEvzJ49O/N2/98eIPOPpv4FQdf14uISj8ednKRnzCBRAwCAv0UABgDg cFpbW0QuLXg354q/bFVVlSKbit9kpwERj8W7s9lsgUAg+S49ldLHxkjFAAAcHQIw AAB/JeJuJuvabCLh2iorK3Rdz1rWnT6RikVjotFgMKhp2tRiMTuoAQA4DAIwACB/ ZeJuYVpRUVFpaan47UH3KluCCMDibSgUTkdijUgMAMABrPo9HgCAGRCJN512bUVF tsrKylmHOJqbM0QAFv8PBgKBROLdSEweBgDks1z+rg8AgGC3t9omFVVXV83K9cR7 eJmzxB6PR5uUZLYWACDf5O9DAAAgh7W2itBbWFxcXFlZWVBQoLodM8osDvt8vkQi IYIxK8MAgHxAAAYA5A6Re4uLi1paWmKxGLl3+kQADofD4g9N0zSSMAAghxGAAQCW 19raYrPZSkvLKirK83mH87ETSTgYDMVi0dHRMdW9AABgPJ4SAAAWJqJvcXFxdXW1 CMCqe8kdqVSqsLBw376JkZER1b0AAGAkAjAAwJJE9C0pKRHR14SX9OYGEYPFW5fL NTxMDAYA5AgCMADAejo62mtra1n1zQIRg8PhcCgUYlM0ACAHEIABAFZit7eWl1dU VVWqbiS/JJNJv98fi8UYkQUAsDQCMADAMtrb2+rr69nzrEQqlQpNCo+NsRQMALAq AjAAwBq6ujrr6uoY8qyWrusul2tkZFR1IwAAzASPEQAAC+ju7q6rq1XdBSZpmubx eBkQDQCwIgIwAMDsuru76urqVHeBv0omk263hwwMALAcAjAAwNQ6OzsbGupVd4ED pVIph8M5OspeaACAlRCAAQDm1d7e1tDQUFBQoLoRHEQoFAoGg2Nj46obAQBgugjA AACTam1tbWioLyoqUt0IDsnv97/zzoDqLgAAmC4CMADApPr6+rjv1+Q0TfP5/END Q6obAQBgWgjAAAAzam9vb2pqVN0FjiwcDgcCQS4HBgBYAgEYAGA6ra0tdXV1JSUl qhvBkaVSKZ/PNzi4R3UjAAAcGQEYAGA6TH62lkgkEggERkdZBAYAmB0BGABgOvPn zystLVXdBaZL13Wfz79nD4vAAACzIwADAMylvb2tqalJdRc4OqFQOBgMcCUSAMDk CMAAAHNh+LMVJRIJvz/AOGgAgMkRgAEAJtLa2trc3FRQUKC6ERw1EYDfeecd1V0A AHA4BGAAgIl0dHQ0Njao7gIzwX1IAADzIwADAEykr29OVVWV6i4wE+ld0P6hoWHV jQAAcEgEYACAWbS2tjQ2NtpsNtWNHAVNSxYWFlRUVIjOW1tb9/9Huq7Pmrwmd/Km 3FRKn/xL19/77aT0vzX1i3dVV9cMDw+7XK5IJCz+/cLCwuz9P3PMfD7fwMCg6i4A ADgkAjAAwCza2uzNzc2quzgkTdOKioqqqqoaG5t6enpOOOGEk08+ubOzU957FAF4 z54927Zt2717t/iFwzERDIZEjjZtKg6K/kIhZkEDAEyLAAwAMIuurs76+nrVXUzK rNCWl1e0tLTMmTPnfe87+SMfOa2vr0/8I4/HE4/HFfYmcvjbb//P5s1b3nzzzaGh vW63OxaLmSQSRyKRQCA4OjqquhEAAA6OAAwAMAuFB4CTyWRxcbGIu/Pmzf/Qhz70 yU9+8lB3ETudTvEvZ7m9w9N1fWxsbP363/b39w8MDIhILNK7kknaHAMGAJgcARgA YBYnnDC/pKQkO+8rs8bb2mo/5ZT3fepTnz799NOnmRj37dsnu7djFw6Hf/vb19av /91bb+32+XxZWx8WUdzn8+/Zsyc77w4AgKNFAAYAmEJra4swe7bcb0zJZNJut59+ +sfPP//8rq6uGVSwRADen6Zpu3fvfvrpp7ds2RIMBm02uWHY7/e/886A1HcBAMCM EYABAKYgdQKWruuNjU0XXnjh17/+9WPcG2y5ALw/j8ezcuXKNWtWJxIJSe8iOCk0 Ps4cLACAGRGAAQCm0NnZ0dDQIKn4xRdfcvnllxtSytIBOEPE4BtvvHHXrj/KKB4O h0UCHh0dk1EcAIBjRAAGAJhCT093bW2tjMq6rr/++saKigpDSjkcjmOvo9xTTz31 X/91j4zKsVjM7w+MjIzIKA4AwDEiAAMATEHeCOiCgoItW7YaUiqRSLjdbkNKqbVh w4brr18qYzgWg6ABAGZGAAYAmMK8eceXlZXJqNze3v788y8YUioajfp8PkNKqfXm m29+//vfj8djhldOJpMiAO/Zs9fwygAAHDsCMADAFBYsOLGoqEhG5f/zfz5x2223 GVIqFAoFg0FDSqk1MjKyZMm1Y2NSTup6vb7BwUEZlQEAOEYEYACAelLvQLryyisv uOAbhpTy+/2RSMSQUmqJGH/zzTdv3bpFRnFuQgIAmBYBGACgnt0+mYAlFX/ssceO P36eIaU8Hk88HjeklHL33HPP008/JaNyIBB4++13ZFQGAOAYEYABAOq1tbU1NzfJ qKzr+rZt24/x7t8pTqczmUwaUkq5Z5999q67fi6jMlcBAwBMiwAMAFCvo6O9sbFR RmURgHfs6DeqWg5cAjzl5ZfX3XLLj2024wdBh0KTVwFLOmAMAMCxIAADANTr7Oxs aKiXUdlms73xxmajquVSAJZ3E1IkEgkEAqOjBGAAgOkQgAEA6nV3d9fV1cqoXF1d /dprvzWqWi4F4M2bNy9Zcq2MytFoNBAIjoyMyCgOAMCxIAADANTr7e2pqamRUbmr q+vZZ1cZVS2XAnD6KuDvyZjpJWr6/f7hYQIwAMB0CMAAAPX6+uZUVVXJqHzKKafc e+99hpRKJpNOp9OQUmYwMDBwzTU/8Hg8hldOJBIiAA8NDRteGQCAY0QABgCoN3fu 3IqKchmVzz777JtuutmQUvF4XEZcVGV8fHzJkmuHh42PqZqmiQC8d++Q4ZUBADhG BGAAgHqLFy+aPVvKt6QLL7zoO9/5jiGlIpGIyHWGlDIDt9v1ox/96E9/+pOM4uIP 6p13BmRUBgDgWBCAAQDqnXzyYkmVr712yVe+8hVDSk1ebhsKGVLKDMLh8I9//ONN m34vozgBGABgTgRgAIBiPT3dtbVSRkALd999z4c//GFDSvl8vmg0akgpM9B1/Y47 7li9+iUZxWOxmN8fYBA0AMBsCMAAAMWOO66voqJC0hbo1avXtLS0GFLK7XYnEglD SpnEAw888MgjD8uozBwsAIA5EYABAIrNnz+vtLRURuVUKrV9+w6jqjkcDl3Xjapm Bk899dR//dc9MiqLPyifz7dnz14ZxQEAmDECMABAsQULTiwqKpJRub6+4de//rVR 1XLpEuCMLVu2XHfdEkmp3uv1Dg7ukVEZAIAZIwADABRbtGhhQUGBjMqnn3768uW3 G1Ut9wLwnj17RACemJiQUdzn8w0MDMqoDADAjBGAAQCKybsD6dJLLxOMqpZ7Adjj 8dx444927dolo7jP5x8YYBA0AMBcCMAAAMXkBeBt27YbVUrXdYfDYVQ183jiiV+t WLFCRmUCMADAhAjAAACVuru7a2trZATgZDLZ37/TqGrxeNzj8RhVzTyefvrpe+65 W0blaDQaCARGRkZlFAcAYGYIwAAAlfr6+iorpdyBZOwI6Egk4vf7japmHuvWrfvx j2+x2WyGV+YmJACACRGAAQAqzZt3fFlZmYzKouzrr280qlogEAiHw0ZVM4+NGzcu XfpvMoaQJZNJn8+/dy83IQEATIQADABQSd4dSJ2dnatWPWdUNa/XG4vFjKpmHjt3 7rzmmmsSibiM4tyEBAAwGwIwAEAleXcgfeQjp/3sZz8zqprT6Uwmk0ZVM489e/aI AOxyOWUU5yYkAIDZEIABACrJGwF94YUXfec73zGqWu7dgZThdruuv/6Hf/7zWzKK E4ABAGZDAAYAqGSJO5Bm5W4AFh5//PH77rtXRmUCMADAbAjAAABluru7amtrCcBq yQvAkUgkGAxyExIAwDwIwAAAZfr65lRWVsoIwLqu79jRb1S1VCo1MTFhVDWzWb36 pWXLlhUWFhpeOR6P+/2B4WFuQgIAmAUBGACgjLw7kIqLSzZt2mRUtUQi4Xa7japm NuvXr//Rj26QdhOSb+/eIcMrAwAwMwRgAIAyJ554QnFxsYzKdnvbiy++aFS1aDQq gpxR1cxm+/btS5Zcq2ma4ZVTqZTX69uzh5uQAABmQQAGACizcOFJMnbeCu9//wdW rFhhVLVgMBgKhYyqZjZvv/32tdde4/V6ZRQXAXhwcFBGZQAAZoAADABQRt4I6PPO O+/qq79nVDWfzxeNRo2qZjYOh2Pp0qXvvPO2jOIMggYAmAoBGACgjFXuQHK5XDJ2 CJvHY4899stf3iejMgEYAGAqBGAAgDJWCcATExOpVMrAgmZDAAYA5AkCMABAjTlz equqqmQE4GQy2d+/08CCOXwJcMbzzz9/xx23yxgEnb4JyT88PGJ4ZQAAZoAADABQ 4/jj55aVlckIwDZb0RtvvGFgwZwPwK+++spNN90kYyCZpmkiAHMTEgDAJAjAAAA1 5N2B1NTUtHbtOqOqpVKpiYkJo6qZ0+bNm//t3/5N15OGV07fhOTds2ev4ZUBAJgB AjAAQA15dyAtXrz4/vsfMKpaIpFwu91GVTOnt97afd111/n9fhnFRQAeHOQqYACA KRCAAQBqyJuAdc455y5dutSoapFIRFIyNI/x8fHrrlsyNCRlozJzsAAA5kEABgCo YZUR0IFAIBwOG1jQnB555JEHHrhfRmUCMADAPAjAAAA1rBKAPR5PPB43sKA5EYAB APmAAAwAUKC3t6e6utoSdyA5HA5d1w0saE7PPPPMXXf9XMZHJBaLBQIBbkICAJgB ARgAoMDcuceVl5fLiFsFBQVbtmw1sGDO34GU8fLL62655RabzWZ4ZU3TfD6/pAPG AAAcFQIwAECBE06YX1JSIqNyXV39b37zGwML5kkA3rRpU3pyWMrwyrqu+3w+bkIC AJgBARgAoMBJJy2QsdgozJ9/wiOPPGJgwTwJwG+++eaSJUvC4ZCM4tyEBAAwCQIw AECBRYsWFhQUyKh89tln33TTzUZV0zTN5XIZVc3MRkZGrrtuyejoqIzizMECAJgE ARgAoIBVRkBHo1ER3gwsaGYrV6588MH/llGZAAwAMAkCMABAAasE4GAwGApJ2RVs QgRgAEDOIwADALKtp6enpsYadyB5vd5YLGZgQTN78sknfvGLX8ioHI1GA4HgyAg3 IQEAFCMAAwCy7bjjjquokHIHkqi5des2Aws6nU4Rqg0saGarV7+0bNmywsJCwysn Egm/3z80NGx4ZQAAjgoBGACQbfPnzystLZVRuaqq6re/XW9gwTwZAZ2xYcOGG274 oYwfTOi67vX69u7lJiQAgGIEYABAtsm7A6mvr++JJ540sGBeBeCdO3cuWbIkFovK KO7xePfs4SYkAIBiBGAAQLbJuwPpE5/45LJlywwsmFcBWATUJUuudTgcMop7vb7B wUEZlQEAmD4CMAAg26wyAnpWngVg4cEHH1y58iEZlRkEDQAwAwIwACDbrBKAE4mE 2+02sKD5EYABALmNAAwAyKqenu6amhpL3IEUCoWCwaCBBS3hzDPPkDEIWvD7A+Fw eHx8XEZxAACmgwAMAMiqvr6+ysoKGQE4lUpt377DwIJ5dQnwlM9+9mxN02R8gMLh SCDgHxsjAAMAlCEAAwCyat68eWVlUu5AKi8v37DhdQMLOhwOXdcNLGgJX/vaeU6n U8aUsvSWcs/Y2JjhlQEAmCYCMAAgq+SNgO7u7n7mmWcNLJhvE7Ayrrjiit27/yTp YzQxMTE6SgAGAChDAAYAZJW8CVinnXbanXf+zMCC+RmAly376erVqyUdAyYAAwDU IgADALLq5JMXS6p80UUXX3HFFQYWzM8A/Mwzz9x553/abDYZxQnAAAC1CMAAgOyx 21tbWlokFecSYKOcccYnJQVgh8OZTGrj43n6BwsAUI4ADADInuOO66usrJRRWdf1 HTv6jS3ocDgMLGgh8gJwJBLx+xkEDQBQhgAMAMieE088obi4WFLx3/52fVVVlVHV otGoz+czqpq1yAvAyWTS6XQxCBoAoAoBGACQPQsXniRpupJIVv39Ow0s6Pf7I5GI gQUt5Mwzz5D0YZrFMWAAgFIEYABA9sgbAW34Fuj8vAQ446yzPp1KpSR9pAjAAACF CMAAgOyRNwK6qKj4D3/4g4EF83YClvDlL38pGAwSgAEAuYcADADIkrY2e3Nzs6Ti XV1dzz67ysCC+RyAr7jiit27/1RQUCCjuNPp1DQGQQMA1CAAAwCypKurs76+XlLx H/3oxs997nMGFsznALx9+/arrvpXSceAfT5fJBIdH2cQNABAAQIwACBL+vr6qqqk 3IE0y+gR0LPyOwDPkjkIOhwOBwIBbkICAChBAAYAZMkJJ8wvKSmRUdnwCVipVGpi YsLAgpZz9tmfSSaTMo4Ba5rmcrm5CQkAoAQBGACQJfLuQKqsrFy//ncGFozFYl6v 18CClvO1r33N6XRIOgbMHCwAgCoEYABAlsi7A2nevHmPPvqYgQUDgUA4HDawoOV8 //vf27Jli6QfWBCAAQCqEIABANkgdQT0Oeecu3TpUgMLOp3OZDJpYEHLeeCBBx58 8EGbTUoAdrlciUSCQdAAgOwjAAMAsqG7u6uurk5S8Vtv/ekZZ5xhYME8n4Al7N69 +/LLvy1tELQ/EokwCBoAkH0EYABANhx3XF9lpawR0Bs2vF5eXm5gQQKwcOaZZ0gK wCL9+v1+BkEDALKPAAwAyAYLjYCeRQBO++xnP6tpCQZBAwByCQEYAJANMkdAV61f v97YmgRg4YILzhd/DgyCBgDkEgIwAEC61tYWQdII6BNOOPHhhx82sGAymXQ6nQYW tKglS67dtGkTg6ABALmEAAwAkK6tra25uUlS8a9+9R9+8IMfGFgwHA4HAgEDC1rU o48+smLFvQyCBgDkEgIwAEC67u7uurpaScWXL7/99NNPN7Cgx+OJx+MGFrSot99+ +7LLLpW0Auz3+8NhBkEDALKNAAwAkG7u3OMqKipkVNZ1/Y03NhcXFxtYkwPAU+QN go5Goz6fnzlYAIAsIwADAKQ78cQTjM2oU1Kp1PbtO4ytSQCe8vnPfy4ej8s4vJ1M Jl0uF8eAAQBZRgAGAEgnbwR0bW3tK6+8amxNAvCUiy66cGRkhEHQAICcQQAGAMjV 2trS2toqqfjixYvvv/8BY2sSgKdcf/31Gzb8jkHQAICcQQAGAMjV3t7e1NQoqfj5 55//3e/+q7E1CcBTnnzyibvuustms8ko7na74/E4g6ABANlEAAYAyNXT011bK2sE 9F133X3qqacaWDAWi3m9XgMLWtrQ0NDFF18kaQU4EAiEw+GxMQZBAwCyhwAMAJBr 7ty5FRXlMionk8nt23cYe0KVO5AOIG8QdPpnDT4GQQMAsokADACQS94IaGHbtu3G FmT/8wE+//nPx+MxGYOgdV13OJwEYABANhGAAQByLVq0UNIY4fr6hl//+tfG1iQA H+CSSy4ZGtrLIGgAQG4gAAMAJJI6AvqUU0659977jK1JAD7AjTfe+Nprr0obBO0Y HR2VURkAgIMiAAMAJOroaG9slDUC+qKLLr7iiiuMrUkAPsBzzz13++3LpQ2C9sTj MQZBAwCyhgAMAJCot7enpqZGUvFf/vKXJ5/8PgMLJhIJt9ttYMEc4HA4zjvv/5MU gIPBYCgUYhA0ACBrCMAAAImOP35uebmsEdD9/TuNrZnJY8bWzAGf+tSZks4AMwga AJBlBGAAgEQLFpxYVFQko7KIZFu2bDW2JncgHdQ553wxEokwCBoAkAMIwAAAieSN gG5qalq7dp2xNR0Oh4hkxtbMAZde+n8HBgYYBA0AyAEEYACALK2TWiQVP/XUU++6 625jazIB66B+8pOfrFu3VtIgaIfDMTLCIGgAQJYQgAEAsnR2djQ0NEgqftlll116 6WXG1iQAH9Tq1S8tW7ZMUgD2eDyxWHx8nDlYAIBsIAADAGTp7e2tqamWVPyxxx47 /vh5xtYkAB9UMBg899xzJAXgUCgk6jMIGgCQHQRgAIAs8+YdX1ZWJqOyjBHQmqa5 XC5ja+YMeYOg4/G4x+NlDhYAIDsIwAAAWU46aYGk+2NF2Tfe2GxszWg06vP5jK2Z M7785S8Fg0EZg6BTqZTD4WAOFgAgOwjAAABZFi9eJCMyCXZ724svvmhsTS4BPoxv fetbf/7zW5J2QTMIGgCQNQRgAIAUdntrS4usEdAf+9jHbr/9DmNrer3eWCxmbM2c sXz58hdeeF7aIGjnyMiIjMoAAByAAAwAkKKzs7OhoV5S8SuvvPKCC75hbE2n05lM Jo2tmTNee+21G2/8kaQA7PV6o9EYg6ABAFlAAAYASDFnzpzq6ipJxZ9//oX29nZj azIC+vDOPPMMSQE4HA4HAgEGQQMAsoAADACQYv78eaWlpTIq67q+Y0e/4WUJwId3 1lmfTqVSMg51JxIJt9vDIGgAQBYQgAEAUsgbAV1cXLJp0ybDyxKAD+8f/uGrHo9H 0mVIzMECAGQHARgAIIW8EdA9Pb1PP/20sTW5BPiIvvvdK/v7+xkEDQCwNAIwAMB4 dru9paVZUvHPfOYzN9/878bW5BLgI1qxYsWjjz4iaVXf6XRqmjY+ziI8AEAuAjAA wHhdXZ319bJGQC9duvScc841tiaXAB/Rtm3brr76KkkrwD6fLxKJMggaACAbARgA YLy+vr6qqkpJxV999bWamhpja3IJ8HTIGwQdiUT8/gBzsAAAshGAAQDGO+GE+SUl JTIqSxoBzSXA0/HZz56taZqMo92irNvt5hgwAEA2AjAAwHgLF54kaamwsrJy/frf GV6WEdDTcf75509M7GMQNADAugjAAACDtba2CJJGQM+bN//RRx81vCwBeDquvfba P/xhE4OgAQDWRQAGABisvb2tqalJUvGvfOUr1167xPCyBODpeOSRR+67715JAdjt dsfjcQZBAwCkIgADAAzW09NdW1srqfjy5ctPP/3jxtbkEuBpGhgY+Kd/+kdJNyEF AoFwODw2xiBoAIBEBGAAgMHmzp1bUVEuo7Ku62+8sbm4uNjYslwCPH3yBkHHYjGv 18cgaACAVARgAIDBFiw4saioSEblVGrW9u3bDS/LJcDT94UvfCEWi8o44K3rutPp 5BgwAEAqAjAAwGCLFi2UNCi4rq7+N7/5jeFluQR4+v7xHy/Zu3cvg6ABABZFAAYA GKl1Uouk4qeccsq9995neFkuAZ6+m2+++ZVXfiNpF7TD4RgZGZVRGQCADAIwAMBI nZ0dDQ0NkopffPEll19+ueFlGQE9fS+88MLy5f8hKQB7PJNL8ePjzMECAMhCAAYA GGnOnN7q6mpJxf/7vx9cuHCh4WUJwNPn8Xi++tW/lxSAQ6FQMBhkEDQAQB4CMADA SPPmHV9WViajsqZpO3f+UUZlAvBR+dSnzpR0BjiRSLjdHgZBAwDkIQADAIx00kkL JN0TW1hYuHnzFsPLJpNJp9NpeNkc9qUvfSkUCsoYBD2LOVgAAMkIwAAAIy1evEhS NLLb21588UXDy6avn/UaXjaHffvb33rrrbck7YImAAMApCIAAwAM09Zmb25ullT8 Yx/72O2332F4WS4BPlq33377c889Z7NJCcBOp0vTEuPjbEoHAEhBAAYAGKa7u6uu rk5S8Suv/O4FF1xgeFkuAT5a69evv+GGH0paAfb7/ZFIhDlYAABJCMAAAMPMnXtc RUWFpOIvvviS3W43vCyXAM/AmWeeISkAR6NRn8/PHCwAgCQEYACAYU488YTi4mIZ lXVd37GjX0ZlRkDPwNlnfyaZTMo47C3KulwujgEDACQhAAMADLNo0UJJF+SUlZW9 /vpGGZUJwDPw9a9/3eGYkPSxZg4WAEAeAjAAwBh2e2tLS4uk4vPmzXv00cdkVCYA z8C11177hz9skrQL2uFwjIyMyqgMAAABGABgjAULTiwqKpJU/M47f3baaacZXlbT NJfLZXjZnDc0NHTxxRdJCsCpVEpkYBaBAQAyEIABAAZonVz9bZF0A3Aymezv3ymj ciQS8fv9MirnvLPO+rS84hMTIgCzCAwAMB4BGABggI6O9sbGRknFKyur1q9fL6Ny IBAIh8MyKue8b37zG2NjY5KOAXs8nlgsxm3AAADDEYABAAbo65tTVVUlqfipp556 1113y6gsglY8HpdROectW/bTl15abbNJ2QUdDocDgSCXIQEADEcABgAYQN4FSML1 1//wi1/8oozKDodD13UZlXNef3//d797paRjwOKD4nQ6OQYMADAcARgAYIDFixfJ OwC8efMWSemaEdDH4lOfOlPSFuhZHAMGAMhBAAYAHKv29vamJlkHgEX03bTpD5KK E4CPxT/8w1c9Ho+kDOx2u+PxOMeAAQDGIgADAI7VnDlzqqtlHQA+8cQFK1eulFFZ 13WHwyGjcp5YunTp669vkLQLmmPAAAAZCMAAgGMl9QDw5ZdfcfHFF8uoHI/HPR6P jMp54tVXX7nxxhttNpuM4slk0uVycQwYAGAsAjAA4FjJOwAs/OY3r9TV1cmoHAqF gsGgjMr544wzPikpAM/iGDAAQAICMADgyHp6ugsnibBTWFAgflEgL/Hur6CgYMuW rZKK+3y+aDQqqXie+NKXzg2FQln4ZEilUrquJ/cjPnZjY+Oy3y8AIMcQgAEA7+rt 7Sncjwif2Um5h9HT0/v0009LKu5yuTRNk1Q8T1x99dXbtm2VdAx4mjLZeL94rEci EQ4PAwAOigAMAHmku7vbZjsw4ipPuYdx4YUXfec735FUnBHQx+7555+//fblagPw YaTSdD21/+JxNBojHgNA3jLvQw8AYGZ6Jxdyben9ypMR1wwLuTP24osv2e12ScUJ wIaQegxYqkw8nlwy1nVNE2+TkUiEsVsAkNus+kgEAPmso6O94F2Zg7nps7lmXYU7 Ftu2bZdXnABsiC9+8YvRaMS6P2Q5qHQkFtI7qidXj/VUavLvcOoYAKwup75dAUAu mUq5U9OnxF/it6r7yp6urq5nn10lqXgikXC73ZKK55XvfvfK/v7+nPz5y0FlFo21 9/Jx5vgx2RgArIIADACKdXZ2/O+13KKszVg2ufPOO+/qq78nqXg4HA4EApKK55Wn nnrqrrt+nj8B+DDeWzfWMhuqxW8TCY3zxgBgKjxgAUCWZILu1Fpuvi3nzsCzz67q 6uqSVJw7kAxk3WPA2ZFZNBZhOL1yPJmNCcYAoAoBGAAM1t7enp6v/O7R3KKiIhbH ZkBkhu3bd8irzx1IBvrCF74Qi0XZtnC09lsx1t6bxcVWagCQi+9VADBzHR0dIutm TuiyqGssu73txRdflFefCVgG+pd/+c6uXbv4QY8hps4YZ1aM2UcNAMYiAAPAtGTW dTNRt7i4SLxlvUuqL3/5K0uWLJFXnwBsoEcffeTee+8lAEuV3kQ9KXObsaYlScUA MAM8vQHAQXR1dYqn+cbGpsz9LqzrZt/jj/9q7ty5koqnUqmJiQlJxfNQLBb77GfP 5hhwlolPY13X4/F4eq1YxOM4lxgDwBERgAHku/Q25sKOjvZAICAeKFnFMgPxWL9j R7+8+iIzeDweefXz0Oc//znxp8q2COUyqbi4uNjtdmcmb7FQDAD74xsVgPzS2Tm5 tNvUxNKuqbW0tK5evVpe/VAoFAwG5dXPQ9/+9rfeeustfn5kQplDxTabrbq6Zs+e wUQiwUIxgHxGAAaQs6ZO7dbV1cbjcfZnWsgXv3jO9ddfL6++1+uNxWLy6uehlStX 3n//LwnAVqHrunhbXl4+Pj7OiWIAeYUADCBHdHSIuFvY1dXt9/vEsx0P4pb2yCOP zp8/X159h8ORCQAwSjgc/sIXPs+Pmawrs1BcWlrqcrkyY6hZKAaQkwjAACwpc3C3 vb09GAyI37KTOZfIPgA8ixHQcnAMOMdkInFxcbHH401HYvZOA8gFfJcCYBk9Pd2V lZUi9/KEndtkHwCeRQCW4/LLv7179242X+SwzIStoqKiiYmJ4eER1e0AwEzwEAnA GhYtWigevNhgmQ9kHwDWNM3lcsmrn7c4BpwnxEuxSMJ+f2DPnj2qewGAo0YABmAB 7e3tTU2NqrtAlsg+AByJRPx+v7z6eYtjwHmlsNA2OjrK6CwAlkMABmABXV2d9fX1 qrtANiSTyf7+nVLfhUi/IgNLfRd56zOfOUvXdQ4p5ImJCYfIwKq7AICjw7coABbQ 29tTU1OjugtkQxYOADudThGzpb6LvHXFFZf/6U9/Yhd0PhBfRB6Ph5PAACyHAAzA Aj70oQ/F49zamhdkHwCexQQsmR555JH77ruXAJwPRAD2+Xx79w6pbgQAjg4BGIAF LFx4Eo/UeUL2AeBZBGCZIpHI5z//OY4B54NUKiUC8OAgc7AAWAwBGIDZtbe3NTY2 cqowH2iatnPnH6W+C13XHQ6H1HeR5z7zmbNENFLdBbKhqKhoeHh4bGxcdSMAcBR4 oARgdh0dHY2NDaq7QDaUlJT+/ve/l/ouGAEt2/nnnz8xsa+goEB1I5Bu9uzZ+/bt Gx1lEDQAKyEAAzC77u6uuro61V0gG5qbW9asWSP1XTACWrbLL//27t27ObOQD3Rd d7lcIyMMggZgJQRgAGY3Z05vdXW16i4gi3iGrqqqbmpqam9vu/POn8l+d4yAzoJb b731L3/5s9vtDgaD4uPLanCu0jTN5/MNDQ2rbgQAjgIBGIDZvf/9p5BYcoD4IJaW ltbU1Njt9jlz+mSPej4UJmCpct999+3atUv8+ft83mg0KlIxB/utTtOSfj+DoAFY DN97AJgdI6CtRTwTFxYWVFRUNDU1dXR0HH/8vCuuuEJ1U39FADaVp59+eufOnSMj w06nMxQKaZomvtgJxlbBIGgAVsT3GACm1t7e3tjYwAOxOem6XlJSUldX19bW1tPT u3TpUtUdHRkB2BIefPDBnTv7xQfL4/FEozERtdhHbU42m21kZIRB0AAshGdKAKbG CGgz0DStuLi4srKyqampu7tn2bJlqjuaoXg8LgKV6i4wc/fcc09/f7/T6QgEgvF4 jOVi5QoKCsbHxxkEDcBC+LYBwNS6ujrr6+tVd5EvkslkUVGRCLqNjY2dnZ19fcdd fvnlqpsyEiOgc9ILL7ywY8f2kZFRl8vp9wcSibhIxawYZ4eup8QfO4OgAVgIARiA qfX09NTW1qjuItfoum6z2aqrq0XQ7ejonDt37j//8z+rbiobGAGdV9asWbNt27bR 0RHxcff7/bFYjGBsOPEF5fF4hodHVDcCANNFAAZgah/96N8FAgHVXVhSZp5QWVl5 XV1dS0tLZ2fnDTfcoLopxTgAjIzHHntsy5YtLpfL43GHw2GR4phKPTPij87r9XIT EgAL4bUegKl98IMfSCQSqrswu8zW5b6+vvb2jjlz5uTYvmUDEYBxeC+/vG7z5i0T E/vefvudcDjEivERaZrm9/u5CQmAhRCAAZja4sWLWJbJyCxSlZWV1dTUNjc3dXV1 33jjjaqbshgCMGbmySef+P3vN7lcLq/XK4Ix1zVN0XXd5/Pv2cNNSAAsg9duAKZ2 0kkLbDab6i6ySjxQirelpaW1tXVtbfbu7p7rr79edVO5IJlMOp1O1V0gpzz33HOv v75h374Jt9sdiYSTSb2wMO+2Uvt8voGBQdVdAMB05ddrNADLWbRoYQ5vQRSRTDwr V1VVNTU1d3d3zZ9/wmWXXaa6qZwVDoc5T44s2JC2d++eiQlHIOBPJBK5vVzs8/kH BgZUdwEA05WzL8cAckB7e3tTU6PqLgyj63pZWVlTU1NPT8+CBSeRdbPM4/HE43HV XSBPbdy4cf363w4O7tm3bzwYDOl6UqRi1U0Zo6CgcCxNdSMAMC0EYADm1dHR3tho yQCc2cZcXV3T3t42f/4J7GE2g4mJiVQqpboL4K/WrVu3du3akZFhj8ejaZpFJ1GL tsfGxgnAAKzCeq+zAPJHZ2dHQ0OD6i6OLJmcXMypqanp6OhYsOCkH/zgB6o7wkEw AQvm9+qrr6xb9/LQ0F6Xyx2Px6wSiScmJkZHCcAArMECr6oA8lZXV2d9fb3qLg6k 67p4JK2rq+vp6Vm4cNGVV16puiNMCwEYVrRx48Y1a9YMDg6KkCkisQmPE6dSKYfD OTo6qroRAJgWc72GAsD+uru7RM5U24N4thOJt6Kisr297cQTF9xwww1q+8HMiA+i w+FQ3QVggFdeeeWFF14YHh7yeDziE1v5WWLRg8vlGhkhAAOwBgIwZrW2ts6ePWts bFx1I8CBenq6a2trs/xOk8lkcXFxc3PL8ccfv3z58iy/d0gSi8W8Xq/qLgApVq9+ 6dlnV42PjweDgdmzZ2d5cn46ALtHRkay+U6BI7LbW1OpWeLrQnUjMB0CMADz6unp qa2tkfouMtOqRMzu7e09+eT3/cu//IvUdwdVQqFQMBhU3QWQDZs3b37ppZfefvvt iYmJRCIu+yBxMpn0eDzDwwRgANZAAAZgXr29PTU1xgdgEXpLS0vPOOOMm2662fDi MCefzxeNRlV3AaixcePGFStW7N27R8Z+aQIwAGshAAMwr145AVjTtDPP/NRtt91m eGWYlsvlEh931V0AymzYsGHZsp+GQiHDV4PFV5bX6yUAA7AKAjAA8+rt7a2pqTa8 bDKZPOusz/zkJz8xvDJMixHQyHMbN24UAdjv9xt+Qji9AiwC8LCxZQFAEgIwAPOS F4DPPvvsW275seGVYVoEYOQ5EYBvu22ZCMCGrwATgAFYCwEYgHkRgGEUAjDyHAEY ADIIwADMiwAMQ4iPuNPpVN0FoBIBGAAyCMAAzEtSANY07dOfPuunP/2p4ZVhTlwC DIgAfOutt4ZCQQIwgDxHAAZgUnZ7a1NTk+HzWoRUKvXxj398+fLbDa8McwoGg6FQ SHUXgEobNmy45ZZ/TyQShlfWdT0QCAwMDBpeGQBkIAADMCkRgFtaWmRUFgH4Ix85 7ec//7mM4lAu+Tc0TRMfdNV9ASq99tprt976E0mXgZWXl7/++kYZlQHAcARgACYl NQB/8IMf+sUvfiGjOGTTdf1vI66gui/A1H7961/fdtttySQBGEC+IwADMKnWSbIC 8MKFCx988CEZxWEITdMSiYSWRr4Fjt1LL730n/95h67rMopXVFRs2PC6jMoAYDgC MACTkheAhblz5z7++K8kFcd0iEw7FXGFzHM5G5UBSZ599tm77pJ17oMADMBCCMAA TEpqAO7q6nr22VWSimNKZiE3niZp6QnAdDz++OMrVqwoKJDy4FdVVbV+/e9kVAYA wxGAAZiUSL8iAUsq3tzcsmbNGknF80dmFXfqrcASLmBOK1eufOCB+2XM1Z81GYCr 169fL6MyABiOAAzApKQG4JqamldffU1S8ZwxtT85s37LQVzAulasWPHYY48WFhbK KE4ABmAhBGAA5nXyyYslVa6srGTDXuZ+oETa1ClcADnp7rvvfuKJX9lsNhnF/f7A O++8I6MyABiOAAzAvOQF4JKSkt//fpOk4iYxNWUqE3HZnAzks//8zztWrVolaQWY AAzAQgjAAMxr8eJFs2dLeZmy2WxvvLFZRuWs0XV9KtwKrN8COIxly5atXv2StADs f+edARmVAcBwBGAA5rVo0UJJI1tE2S1btsqobJRUKjWVbxmhDOAY3XLLLS+//LLN RgAGkO8IwADMK4cD8NT528yUKeZLAZCKAAwAGQRgAOZloQCcSstcBZQZmDz1VuD8 LQC1CMAAkEEABmBeagPwVHyd+sX+yLQALIQADAAZBGAA5iUvAM+ePXvDhtf/dqlW xvsCAOUIwACQQQAGYF7yArCwevUaSZUBwGwIwACQQQAGYF4EYAAwBAEYADIIwADM iwAMAIYgAANABgEYgHkRgAHAEARgAMggAAMwLwIwAMxMNBp1e71Tv73r5z/f+Prr BGAAIAADMC8CMAAcygER96/S15LHYrFEIpG5s028/e8H7t+6dRsBGAAIwADMiwAM IJ8dIeJGo3FNS70XcVOZ/znELeUrVz60ffsOAjAAEIABmNfChScVFkp5XBPPiGvX rpNRGQCm7+gi7nvruQeNuIf3wAMP7Nr1R0mvqD6ff2CAAAzAGgjAAMxLXgBOJpPn nfe1iy++WEZxAJgyzYj71yXcmUbcw9i7d+/KlQ95PB5pAdg3MDAoozIAGI4ADMC8 pAbgM8/81NVXXy2jOIC8cviIK/5pIpH4X7uUJUTcw9u9e/ejjz4aiYQlHSohAAOw EAIwAPM66aQFNptNRmVNS37wgx/493+/RUZxALnkkPl2Vjri6no0PW7qvRO4f92o nN02D2fr1q1PPPEr0dfs2VIe/AjAACyEAAzAvOQFYPEg2NfXd9ddd8soDsAqDhdu 0ybzbTQaj8f1/UZMTS7eZt5axO9+97vnnlslaflX/Dn4fP7BwUEZxQHAcARgAOYl LwALjY1NDz30kKTiAMzgCIu36buCJsPte8u2745QtlS4nY51k9ZKOlGSDsC+wcE9 MooDgOEIwADMS94ZYKGiouLJJ5+SVBxAFhw+34o0m7kLNylibTL57tJtdg/fmsSq VavWr/+tpJ8nEoABWAsBGIB5Sb0HuLi4RDwUSioOwCiHGTGVmS81uXKbTIpkm0wv 5KbS/yjbXZrbk08+uWnT7+XdKufz+ffsIQADsAYCMADzkhqACwoKX3zxRUnFARyt gwddkXLTu5Qn820ymdmrnMq5LcqyPfbYo1u2bCEAA8AsAjAAM1u8eJGkmaWz0tv2 1qxZK6k4gIM63HJu5jiupmUWcvW83KssyUMPPdjf3y/vVjm/XwTgvTKKA4DhCMAA zOvkkxfLKy4e2r7ylb+/9NJL5b0LIA8d/lLcWDQa17SU/t5M5cyiLkFXpoGBdx5+ +GGfz0cABoBZBGAAZnbKKe/Tpd2lqWna3/3dR6+//npJ9YFcdVQRd+pSXFKuKv39 /b/61eOJRELShhoRgH0+/969BGAA1kAABmBeH/jA+0VMlVRcPJbPnXv8z372M0n1 AeuaZsR991JcIq65bdiw4bnnVsk7TiJepf1+EYCHJNUHAGMRgAGY1wc/+MFEIi6v PlcBA/ubzL0eDxE3x6xdu3bdurXy7lRPrwD7CMAArIIADMC8Tj31w+KJXF798vLy p556Wl59wFpGx8b2jY+r7gIGW7Xq2fXr18sLwJqm+Xz+oSECMABrIAADMK/TTvtI KBSSV7+oqOi5556XVx+wltHx8X1jY6q7gMEef/zxN974g+QA7BsaGpZUHwCMRQAG YF5z5vRWV1fLq6/rqbVruQkJeJcIwBP79qWkTZ6DEg888MCuXX+UNAJ6FgEYgNUQ gAGYV29vT01NjdR3kUqlksmkeDQsKyurq6traWnp7u7+f//vn6W+U8CcRAB2TkyI rwjVjWCGdu3atXnzZrfb7ff7otGoiKYFaVLfaSKREAF4eHhE6nsBAKMQgAGYV09P d21trZJ3/V4wtolgXF9f19ra2t3dw6XByG0iALucTi2RUN0IjkAE3a1btzqdThF0 I5FoMpmNoHsoImZ7PN6REQIwAGsgAAMwr+7urrq6OtVd/C+ZgbjiQbOionJqxZhg jNwgArDb5UrEJY5ex1HZuXPn9u3bXS4RdAPhcCiZTCoMuociunK73SMjo6obAYBp IQADMK+urs76+nrVXUxLJhgXFhaWl5fX1dXb7a29vXMuueQS1X0BR0EEYI/bHY/F VDeSd0TQ3bFjh8vl8vl8IuhqmiZeTMwWdA9FBGCXyz06SgAGYA0EYADm1dHR0djY oLqLY5LZSm2z2SoqKurq6tra2ufMmXPhhReq7gs4CBGAfV5vNBJR3UjO2pnmcDj8 fhF0w9k5oyubrutOp3N0lPnhAKyBAAzAvNrb25qamlR3IUVmxVgE4/Ly8oaGBru9 TQTjb37zm6r7Ql4TAdjv80XCYdWNWF5/f/+uXX8UsdDr9WaC7uzZs+XNYVZu3759 Y2PcIA3AGgjAAMyrrc3e3NysuousmgrGFRUVU8H4G9/4huq+kBei0ejI6KjIwKob sYwdO3a8+eabTqdDBN1IJJJIJHI76B5UQUHB2CQCMABrIAADMC+7vbWlpUV1F6bw 3hljW2XlZDBubbX39vaylRqGGx4ZcUxMqO7CdLZu3bp7926XK19WdI+KzVa0efNm 1V0AwHQRgAGYV+tk/m0RD5qqGzGv/bdSn3POuRdccIHqjmBto6Oj+/btU92FYn/8 4x9feulFl8ut9nohq/D7/e+8M6C6CwCYLh4rAZjaSSctEOlOdRdWoqeVlpbW1k7e 0tTb2/vtb39bdVOwjNHx8X1jeTTNaMOGDX/605tutycQ8MfS469F3OWHbtOXSqV8 Pt/g4B7VjQDAdPESD8DU3v/+U5LJpOouLC8zjLqoqKiqqqqhobGzs/Oaa65R3RTM SATgifFx8QmjuhHjrV279s9/fsvj8YZCQXNeqGtFmqb5/f69e4dUNwIA00UABmBq vb29NTXVqrvIWSIGzJ49u6ysrL6+3m5v6+vr4+7iPCcCsGNiQrfyT502btz45z// 2el0+Hy+aDQ6i0VdmTQt6fV6hodHVDcCANPF9wMAptbV1Smymeou8ktmubikpLSm ptput6c3UV+uuilkiQjALodD0zTVjUzLq6++8pe//MXlcvn9/kQiwaJu9ul6Kn0J 8KjqRgBgugjAAEytvb29qalRdRd4d9pWZhN1S0tLT0/vlVdeqbopGE8EYLfLlYjH VTdyoHXr1oms6/F4QqFgPB4vLCwk65pBYaFNpN+xfDo3DsDqCMAATI2bkEwumUyK bFxSUlpdXWW32y+++JL6+vqGhoaSkhLVrWEmRAD2uN3x9DioLBOfS4FAIBqNrlmz Znh4KBQKJxIih88WUZcNzKZVUVGxYcPrqrsAgKPAdxQAZrdw4Unct2lRmQFmBQUF NputsNBWVGQrLi4+5ZT3X3XVVapbw8GJAOz1eGLpo7OGe+mll7Zt2xaLRTVNfGpo mW0FItxyRteiGAENwIr4fgPA7D760Y8GAn7VXcAwpaWlzzzzrOoucHAiAPt9vkg4 LKP4Lbfc4na7+HlWzkgmk16vd2hoWHUjAHAUCMAAzK6zs7OhgTlYuaO4uGTVqlWq u8DBiQAc8PvDoZCM4jfffLPP5+Xsbi6ZmJgYHeUAMAArIQADMLu2Nntzc7PqLmCY mpqaxx57XHUXOLhoNDo6NubzemUU/4//+I+xsVFWgHNGaWnp4ODg+Pg+1Y0AwFEg AAMwu9bWlqamJh6ac0ZPT8/dd9+jugsc0sjo6MQ+KZHml7/85Ztv7rLZbDKKI/u8 Xp8IwKq7AICjQwAGYAG9vb01NdWqu4AxPvzhU3/4wx+q7gKHNDo2tm98XEbl559/ 7rXXXiMA54ZkMunxeIaHR1Q3AgBHhwAMwAK4DTiX/P3ff/WSSy5R3QUOaXR8fGJ8 PJVKGV75jTfeePzxxwjAuUF8HEdGRsbGpPysBADkIQADsIDW1pbGxiabjV3QueDS Sy8799xzVXeBQxIB2LFvn67rhlfevXv3vfeuIADnBp/PNzAwqLoLADhqBGAA1vB3 f3daMBhU3QUMcO21Sz760Y+q7gKHJAKw0+FIaprhlcfHx5ct+ykBOAdwARIA6yIA A7CGjo72xkZ2QeeC5ctvnz9/vuoucEgiALucTi2RMLxyJBK57rolRUVFhldGlhUW 2kZHR8fGuAAJgPUQgAFYA7Ogc8bKlQ83NDSo7gKHJAKwx+2Ox2Iyil911b+yApwD mP8MwLoIwAAso6enu7a2VnUXOFarV69R3QIORwRgr8cTi0ZlFCcA5wBd110u98gI 858BWBIBGIBltLXZm5ubVXeBY5JMJtete1l1FzgcEYB9Xm80EpFR/Oqrry4sLJBR GVlTWlo2ODgwPi7lsmgAkI0ADMBK3ve+k2XczoKsIQCbnwjAfr8/EgrJKP79739v 9myePSxMfAn7fL69e4dUNwIAM8Q3IQBW0tHR0djI8VEL0zTt5Zd/rboLHE40Gh0d HRUhR0bxa675ga7rZGDrKigoGB8fHx1l/BUAq+I7EAArYRRWDuAMsPmNjI5O7JOy wXXp0n8TAVuEKBnFkQVc/wvA6gjAACymp6e7rKwskdBSKV0k4aKiIvGW52mrKC4u XrXqOdVd4AhGx8b2jY/LqHzTTTf6/X6+YC0hJV5kdV1LE7+w2Wzi74TD4eFhxl8B sDACMACLaW1tOdTwlY6OjnQWFom40GYT/2dj3qzZVFZWPvHEk6q7wBGMiq8xOVe8 Llv203379rGJw1SmUm4yLfPbg25yFi+/4i3jrwBYGgEYQO5rb29PB+N0Mi58Nxiz BqVEY2PTQw89pLoLHIEIwI59+0QQMrzynXfeuXfvHgJw9qVSKRFup3KurmeCbnJM zk86AMC0CMAA8tp7i8YFU8FY/IIJPfJ0dnb+4hcrVHeBIxAB2DkxIWKS4ZXvvXfF 7t272Zohz9Ryrgi376Xcgy/nAkB+4iEPAA6ivb09nYon30ztpmbR+NjNnz9/+fLb VXeBI5gMwA5HUtMMr/zwww9v376NFeBjlFnOTSS0ZFJ7b9uyLv6H5VwAOCICMAAc nY6Ojkw2zmyozkzhYtF4mj7wgQ/ceONNqrvAEYgA7HI4NAkB+Jlnnt6wYQMrwNO0 36ZlLZNyxW9IuQBwLHhiAwBjpBeNZ6c3Uxek91MXZjZUq+7LXD7xiU9cffX3VHeB I5gMwE6nlkgYXnndunVr164hAO8vlUrtv2k5vZ6bEol3bEzKIG4AyHMEYACQrqMj s6G6cP8N1fm5aHzuuV+69NJLVXeBIxAB2O1yJeJxwytv3LjxqaeezMMAvP+VQvsN W2bTMgBkWz4+fsHq0tcwTH7qivggHim4jwGW1tnZccB46txeNL744ku++tWvqu4C RyAvAO/atev++3+ZwwH4b1NuIsGmZVibeO6aPXt2KpX5Hc9dsDwCMCzAbreLp6Wi SbYDzlu+t3MsqWkJIbN/jJdm5IDMonFm2dj2nhxYNL7qqqs/+clPqu4CRyACsMft jsdihlceGhq6447brR6AD3GlEJuWkQtE3J2acCEevjK7lvZ/7koPYJt85hJ/ia9o td0CM2D5ZynkMJF7S0qKy8vLi4uLp/9fiaeQSCQSi8X4oTtyVWbROLObOvOMIn6T /vF8yvwJ+Sc/uXXRokWqu8ARyAvAgUDghz+8XnzSGl7ZQKn0Upf4ajrYcm6ClIvc k17jLRCBt6SkpKysbPpXHsTj8XA4HIvFeeKChZj9UQn5qa2trby8rKKi4lie5sUT TCQSFWFYPK+Mj/O8gjySTsiZWVym21Z9//0PtLa2qu4CRyACsNfjiUWjMopfddW/ mmQFWE8Tadzv95NvkZ/EC3JxcVFZ2oyLiCeuUCgUDkdGR0cN7A2QhAAMcxEvxCL6 VlVVGbiQJZ5pgsFgNBodHeXHk8hT4itLpODZB5dZP56dXlWe/JXUW52ef/4Fk4Qf HIYIwD6vNxqJyCguLwBnBk1lfi0+o8XnfCAQ0PXJv53638S/oGlJ8fc5MoP81Nra Il7wS0vLKisrjLriXnxlia84EYNZdYDJEYBhIh0d7bW1tfIejMJpIyP8eBI4HLu9 taWlRUblZDK5bt3LMirnm0QiIXUXsdQAfPXVV0nakuB0uoaHh2VUBnJG+oivTbzI 63pSRn1N07xe7/DwiIzigCEIwDAF8XJcUlJaW1uThROM4XAkFAqNjPDSDBxcW5u9 ublZRmUzBOBYLDYxMeFMc7mcXq8Iet70qoV4YQilJwjE4/HJIQLJpJZZPFTb8EGJ AKnr765qFrxr8jR4cXFxaWlJaWlpRUVFeXlFVVWVeF2tra2rr69vTBMf2elsdBQB 2O/zRcJhGc1///vfnzVLynl1l8udSMRZ1AUOSjxr2Ww28Tog+x2J1yXx0hqLRfli hDkRgKGeeEUWD2rV1VXZfKfhcDgYDHFYBfhb7e1tTU1NMiqLyLZ27dqj+k9EInW7 3Vu3bq2trRW5LhQKhkLhaFREs8ysu7jH4xFfy8FgIBqNir8p/o5IsLr+7sgiwWYr 0rTE1M5Y8xyHViXzxyJ+kbl+S/xBFRTMnpo3ng7RxQXpA+SlJUKpSNHFxZPhuqRE /JPJdC0itKZpPp+vt7e3oaFB/J2jamDJkmvFfy4jAItPlXicAAwcKDPYWdIL+6H4 /ZM/WOTrESZEAIZi4kW5omJymSL77zqVSonnZpGEGV2InCe+0Kb/FNLR0S5viWD1 6jXT+dcuuuhCl8slAq3Nlu951fzSEbqwoqL8n/7p/05nwtnSpUuj0YhRxw735/F4 YrH4NM8fpq+Un8XTOXJb5qxve3tHImH8td5HFAgEQiEyMEyHAAzFent7ampqFDag 67rf74/FYkz+RE6awVN+Z2dHQ0ODtI4AWbxebzQam/4AnsxXxyxiMHJUa2trWVlp dXW1whvyfD7fwMCgqvcOHBQBGCqZ5zk7kUiIGJy+MInHIOSIGS9wdXV11tfXS+gI kMvn80ejkaP9aSYxGLlHfFYXFRXX1taY4dCHy+UaGmI6HUyEAAxl7HZ7Y2ODGV6a p4RC4WAwyI5oWN0x7u3s7u6qq6sztCMgG/z+QCQSnvF2HjZFIwdk9jw3N4tP5pTq Xt6VTCadThcPVzAPAjDUEC/QNTU1x3LruiS6rvt8fkYXwrqO/SG+p6e7trbWuI6A LAkGg6FQ6FjOs5CBYWl2e2tJSWlNjco9zwcViUR8Ph9fWTAJc315IH90dnY2NJh3 j2U0GvX7A8yIhrUY9exOAIZFBQLBcPiYAvAsdkTDmjJznuvr6021sW5/Lpd7aGhI dRfAJAIwFBAv0w0NDUVFRaobOZxUKpU5TsYzEKziqEY9HwYBGBZlSACeZdyXEpAd 6WFXZTU11aobOZxEIuFyufjKghkQgKGAhUbsxGIxEYNZCob5GfjITgCGRRkVgGex FxoWkVn4raurs9lsqns5MrfbvXcvi8BQjwCMbLPE8u/+0kvBvmiUU8EwL2MXrBiC BYsKBALpq92NudOODAyTy9xypPYuyaPCIjBMggCMbOvo6GhsNMXVR0clEokGAv7R UWYYwnSMekzPrCQUFRVXVlZYYjEBOICu66FQKBaLaVpy+rcBHwYZGOaUHvVcKJ6m CgoKVPdydJxO1/AwVyJBMQIwsu24444Tj9equ5iJZDLp8/nYvQOzOcbl33TutZWU FJeXl5N7kRtEEo5EItFoNJHQjiUJE4BhQuLTsqSkpLa21myjnqcjGAz9z//8j+ou kO+s95UDS7PbW5ubm634kj0lOClkyNoCcOzE11QqlZrBA3pmASGTey10JAE4Kslk MpOEZ7wmTAaGqdjt9rY2u/jEVt3IDIlvWBMTE0adUwBmxsI5BFbU2dnR0GC9/c8H SCQSXq93ZITJWFBvBsu/IjMXF5dUVJQXFxdL6gowGxGAw+GwSMK6njyqLxkCMExC fCrabLa6ujrTXnQ0TS6Xa2iIXdBQiQCMrOrr66uqqlTdhQFSqZTX64vFmIwFxY4q ALe3t5WWllZWVlp6FwZwLCKRiEjC098aTQCGGdjtreLV20Lzrg4jEAi+/fbbqrtA XuMZCNkjHiMaGxtz6ZCheIoKBALs5IFC0wnA4t8pLp7c6iyen7LTFWByiUQivSAc Gxs7wmhDAjDUSh9XKWhqas6Zn1tqmuZ0OvmagkK58sUEK2hrszc3N6vuwmBsh4ZC R3w0T+92Lq6qqsqlHzwBRtF1PRgMRSKRw8dgMjBUSW97Lqqrq7X6tucDTExMcK0G FCIAI3s6OzsbGupVd2E8tkNDlcMs/xJ9gWnKXJ4kYvChnsgJwFAil7Y9H8Dlcg8N cacGlCEAI3t6e3ty8nU8Qzw/BQJBpkMjmw4agNM3ZJRWVVUSfYHpS6VSwWDwoDGY AIzss9vtLS25tmluis/nGxgYVN0F8hcBGNkzd+7ciopy1V1IlEgkPB7v6CjboZEl fxuAOzo6amqqudYImBld1/1+fywW23+4AwEY2ZSZ9lxbW5vDP8QMhcJ/+ctfVHeB /EUARvYsWHBizj+Xi4cnr9e7dy8be5AN+wfgtjZ7RUVlbv+MCcgOEYADgaCmJTJf XwRgZE1mC09dXa3qRuRKJBK7dr2pugvkLwIwskS8pgt5cvmK3x8Ih0M8LUG2TAAW b0tLS6urqwsKClR3BOSOUBqjepA1dntrZ2dnPB5X3Yh0qVRq3759PCZBlbxIIzAD 8bIuArDqLrInEon6/f4jXrABzJj4mhLPEIWFhTU1NcXFxarbAXKQrus+ny8WE4Ek NYtFYEiTvuuosL6+Loe3PR9ABGBukYQqBGBkSU7egXR4mqZ5PN6RkRHVjSA3tbZm BoRW58nGCkCV9EpwmPkOkCRz15FIv3m1i4ebkKAQj03Ikvb29qamRtVdZFv6hiRv LBZj3QDGstvt1dXVZWWlqhsB8oKmaT6fL5FI8GIOY9ntrSUlpbW1OXtHxqE4HE5W CKAKARhZ0tnZ0fD/s3ce8FGVWf8PkN5nMkmmpJDQEd3i66qL/l1fO4iCYIFdFGys vRIQbAgigiIoIF0QsKMLqKhrwwYoHaRKSULatDu9l/+ZGTdvNqRMZu65z52Z8/34 4YPJveceZu69z/k9z3nOKSjAsNy9e/fhw0d89NGHoDYx7EeP2Wy2WmlLMMEbJSWq /HxJcnIP1o4QRGJhMBgdDge1uyP4AtSvUqn0er2sHWkDiKm6det29dXXfPbZZ6Et APyi0+lqa0/zbpYgwoEEMCEQZWWlUqkUw3Jubu6WLd/BX+bPn79q1RsYl4geiJmM RtoSTPBAeXlZfn4+pT0TBBMsFovVaqOXORElYt70G5K+t9wyety4cR6P56abbrTZ bLxfRa/XU8sMghUUQhECUVZWBi96DMsKhfLTTz8N/d3n882cOfP9998T4Uaa4JZg rq6OdpEREQIBU2ZmVm5uDmtHCCKhsdvtZrOFtgQTESPaTb/+INddd/39998f+gmE LiCDtVoN79fS67mamhrezRJEOJAAJgSivLxMIkERwD17Vnz00Uctf2K1Wh988IFf fvmlRw9x5YjCuAIamKY8iQiAgCknJycrK4u1IwRBJLlcLqPRRDsYiQgINa7Lzxdd p1+Px/vnP/95+vTpaWlpLX7oufvuuzCmeyAcqq4mAUywgQQwIRB4ArhPnz7vvff+ mT8/fPjwhAl3m0wmjItGA7hks9loSzARPnK5PDc3NzMzg7UjcYLf7/f5fPCXbt26 JQdJC5CekZGelZWVmZmVEwQ+87y8PIhTpVIpUgmDiCksLNTpdFqtFoJIQxCzGV4t ZsBmC9YsttldLqfTCUrN6XZ74B/dLYjYVpxiF7fbbTQaT58mDUx0AYVC3rNnT7vd ztqR/wJeifCqmzNnTnl5eatfgQC+555/1tbyP3FPAphgCAlgQiB69ixHmu/s16/f O++8295vFy1atGTJYrHFfCCAIVSlSipEOID6BRlGBZ87xuv1hsrghXZHB/8EsRfQ e1deeZVEIpEGKQyCNBknTuobGzmdzu3x+IOa32KxgGwDwWwKYrfbtm/f7vP54MPz +30tTwypZdpt3gGgDeCTJA1MhIlCoSgslIkqIAnlPI8ff/vo0aPbPABu8vvuu7e6 upr3S8Ozc+oU/2YJIhxoYCMEory8XCJBEcC9e/d+//0POjiA47jx48edOnVKVJGc y+WCtz81wSM6Ri4vDqrfhFv7BUELYSIIM3hs09LSsrOzZTKZVFoAnwboWFCw8L8g ZYuLA58Pa2dFjcPh0BsMgb/5/fB3l9vt83rhg4VP2Bde7Vm73a7Xgw0DKOfAErPZ ZLFYLRYzxxngVxAfByvEdgP93KNHD1G9ZgWA1oGJcIA3eY8eyfDqEtXOLHgP9OzZ c968+ZmZme0dAw/4P/854fRp/ss1wwsEQ1cTRDgk1kBFMAQvBRqk9b/+taHTw957 772ZM58XVXAGAahez9EuMqI9gvt+c7Oy2g1N4oOQ1gUdC2q2V6/eZ5111rnn/hm0 Lmu/4pD/E8MhgpLY6XR6PQGi7yQHevjYsWMnThyvq6vX6XRWqwVsxv0yMu0HJjoG 3uQpKamgfsXzIATXfZMee+yxq666quMj4c1w5513YCSsUQo0wRCxPIpE3IPXBkku V2zevDmcI41G47hx406ePCGqQYjjDFQIkTgTiJmysgKbUVk7wjMQTqWkpIC+LS8v HzBgwHnnnde/f3/WTiUuLSVxYH0YxHBwfTi0SszLJSB0Pnz4cHV1dUNDPbyE4QaI v4Vi+OhMJjPVhSbORC6XB0teiShRBR7tXr16zZs3v2Wxq/aAB/bWW8fq9Xre3aA2 SARD4moEIsRMaWlpQQGKAIZI+quvvgr/+LfeemvWrBdElYZEZbGIM8FLmhAYCLby 8/PLy3sOGjToggvO79eP5K5Iab0+nBSYooOvz+l0htaH/fBtegOrxQFtHMVysVqt PnjwYGih2Gw2xUdpLmsQ2tVCtEShkJeVlcETxNqR3wkt/D7yyCPXXHNNmKfA8z5m zGiMeqI6nR6jthZBhAMJYEIgSktLkMqopqenb926rUunaDSaW265Ra/XYfgTGVQW i2hJSYkKnpcYXSXzer0ymaxPn77nnXfeJZdckpuby9ojIiraEMZJSRDTw8/dLpc3 sAc4KiDCPnDgAEjimppqvZ6Duz5G9bDRaHI47A0N9BonAiiVCngTiudmBu0rkxUu WbIkOzs7/LPcbvfIkTe4XC7e/dHpdLW1/G8tJohwiMnoiohFIKCHkQDDcrdu3Xft 2hXBiTNmzHj33XeSk5N5dykyIKA0GIwNDbSAkOgoFApQv8nJIkpS6BhQvFlZWX36 9LnooosvuugisXUMIjD4r9xpu91us/2+MsyH5d27dx84sP/06dM2my228qX1ej1I BUrnSXCCJa96SKVS8eSaweN54403TZgwoasnggAeNuxaDJe0Wi1VjyNYETODChHr qFTKwsJCDMsQcu3duy+yc0E533nnna2afzAEhiiO4+rqaCNZ4hIrZZ/hXs3JyTn7 7LOHDbtuyJAhoYrNENBEX0iJiDlaieHAynCw1jQvxo8ePfrzz9t/++241WoRvxim xkhEsORVikQiEcnaL7yTk5NT5s+f37t37whOh2d5yJBrMJS8RqOhaIdghagHEiKe UCoVRUVFGJa9Xu++ffsjPh1itVtvHQsxlkjiKlARoIEpLyhhweuYHT2hir79+vUf NWrUsGHDUlNTm38Fcb9eryf1SzSLYfgLiGEelTBw6NChH3744eTJE6FKWnyZ5Rfa DJzIgPpNS0sTT/kGiCj69x/w6quvRmzB6XQOHToEI1dOrVbTY0KwQhQRP5EIKBTy 4uJiDMsQc//4409ZWVnRGFm8ePHChQvEkw5tMBggeqQ8ukRDqVQUFhaKZC6mGQih cnJyLrzwr3fddWffvv3OPAAiJLPZDJpEbJ4TDPk/JRxaE3a5+CornRQs6b9ly5a9 e/eYTCbxvLeb4TiD00kv8IRDLpf37dvXZDKydiQAhEZer/eee+4ZOXJUNHY4jhs9 +ha+vGpJU1MTbZgnWEHBCiEQ8oD+LUaKjxcvXnL++edHaeTgwYO33XarJ+qCLnwB isJqtVIIlTiILfkZ4qf09PTLLrvswQcf6mD2CrSNxWIh9Uu0x+9K2O+3B3HzWk3H 7XZ9/fU327ZthbeleNaEKRE6AVEE8fl4y3eIBnh7p6amLV68WKVSRWlq+/btzzzz NC9etQQ8BAFMEQ7BCopXCOEYNOgspKn6Rx99dOzYW6O343K5br117OHDh0USylNp 6IQCr1d2V/H5fBdffPGjjz5WWVnZ8ZHwyECgD8eL5JEhxExICQfKR9vtLqeTxwXh pMDb0vrFF19AsA5mxbD30mKxWK02KmqYICiVgcqFIpmCgUdg0KBBc+e+woupd999 d/XqVdGbakWw9vuvvJsliDChkIUQjv79+6Wnp2NYHj58xDPPPMOXtfnz569YsVwk IxmVhk4Q5HK5TFbANpkTYp3c3Lw77rh93Ljx4RwPEYxWqyXpS3SJ5tRouw1Eq5X3 pJsDBw58+umnGo2aeWo0tTlNBMRW8Nnr9d5xxx233DKaF2swKLz00ktff/0VL9Za Au+Bw4eP8G6WIMKEAhdCOPr06R3lTt32+OMf//jGG6t4NLhz58677rpTJBV9qDR0 IlBR0TMvL4/V1SHK6dmz5wsvzBo4cGCYp5D6JaIkpIQddjvIYLfbza9xUJ7r1q2F NyfD1WCj0Xjy5ClWVycEQKVSikf6ArNnzznnnHN4NPjIIw8fOnSIR4PNWK3WY8d+ w7BMEOFAsQshHJWVFbm5uRiWi4qKPv/8C35twtv5hhtGqNVqfs1GBpWGjm8UCkVh oYxJpB6SvnPmzGmzulV7OJ1OCO4p85mInmYZDK9cD98yuK6ubs2aN1nJYHhANBot 5e/EK6WlJeLpdQQ6fPnyFZmZmfyaHTNmtF6v59dmCJPJdOLESQzLBBEOFLsQwoHX 3yUlJeXnn3/BsPz444//+99fiGGE8/v9BoOhurqGtSME/1RUVOTlocwNdQDcUfA8 LliwcNCgQV060eVymc1mt9tN6pfgi2YZbLFYvHwnRdfU1KxYsdzpdAp/xxqNppMn KcqPQ8rLy+D9KYZ3YLBkw/976qmnMIwPHTrEy18bs5ZAPHPqVDWGZYIIB/aPLpE4 lJaWFhSg1PiBAWDv3n0YloH169dPm/asSHKcTCaTzWajwonxhEIhLywsFHiSBR6Z Rx55JMy9vi0B2azX60n9EhgEer+p1YG2SXY77ztQvv76682bPxV4Y3BwEVhDvV7i Cbm8ODMzEymdrat4PJ5HHnl06NChSPavuOJypOCHdsgTbKEIhhAOlUpVWCjDsAyh 0k8/beU9+aeZY8eOjRkzWiQdkqxWq8VioYgqbujZs2d+vnC7fyEiP+ecc5YtWx5Z RTqI5vkt3ksQLWmuFG2zWl1OJ7/G3W7XokWv19fXCTnfZDAYT506JdjlCFQUCnl2 djZSNZOu0r17j4ULF1ZUVCDZt9vtw4dfjzTXqdFo6+qoTxjBDBLAhHAoFIri4iIk 43PnvnLppZciGU8KhmUjR95QXy+KSlTgjNFoJA0cB8jlxTKZTLBVKdCuzz47bcSI EZGdHlr75dclgjiT0FKw0+Gw22y8LwVv27Zt/foPBHvoQuXiKG0nDmCSrdMeRUVF y5YtT0tLw7vEjz/+OH36c0jGm5rUtD2eYAgJYEI4INYHkGYTR48eXVU1CcNySyZP nrR582YxjH+h/qv19TR+xDalpSUFBQXCXCs1NfXDDz9SqVSRnW61Ws1mM2U+E8Lw +1KwwwF3He+7gnU63UsvzeHXZseXoxKGsY5SqZBKpcx7ayUF5zH/9re/TZkyFftC ixYt3LhxI4Zlv9/f1NREs0IEQyiUIQRl4MABEIVjWP7Tn/68cuVKDMuteOedd2bO fF4MW4K9Xq9er6f2SDFNv359MzIyBLiQTCbbtOnjiBtxgxph21GGSEzgxmtoakJK h37hhRfsdju/ZtsErnLkyFEBLkQgIZ52RzDu33//A9dff70A13r00UcPHvwVw7LL 5Tp4EKW7EkGECQlgQlD69OmTlYWyU7egoODLL/nv1d4m+/fvv+22W8XQJZjaI8U0 SqWiqAhrU0BLSkpKNmzYGLF8hWDFZDJ5PB5a/iWEJ5QObbfZHHyLVXh/vvjiLLi3 +TXbJmq1mhJ2YhRRtTuaN29+//79hbnWLbfcbDAYMCxbrbZjx45hWCaIMKFohhAU vHYvMDjt3LkLw3KbGI3GESOGg/gU7IrtQe2RYhe8xmAtKSws/Oyzz6OJ3uA+BxEi kviPSEB+18B2u8Nm49cyaOAZM2bY7TybPRNq+hKjiKfdUW5u7vLlK4SsPn311Vch Wab2YARz2D/SREJRVlYqlaJ0QvJ6vfv27cew3AHjx4/fvXuXGIZGao8Uc8jlxfAs IO0IaAbsb9nyXcSZz0nBwN3Jd/YpQXQVvHVgt9v19NNP82vzTFwul16vp1d0DCGe dkd+v/+ss86aO/cVga+L1wMJnoWaGuqBRLCEfeBOJBQlJSqZDKUTErBmzdpBgwYh GW+PuXNfXrVqlRi2BoVqFFGAFSsolcqiokLUS3i93k8++bS0tDRiCx6PByIVn88n hlkeIsEJaWCb1ep0OPi1rNVqX3xxFnZ9I7VaI5I+AkSngPrNyckRQ7sjeI2PGnXj hAkTBL7ukSOHH3roISTj8MSdPk09kAiWUExDCApqJ6S77rr73nvvRTLeAZ9//llV VZUYEkTtdrvJZKL2SDEBdv6z3+9/7LHHx44dG40RCFMg/OLLJYKIkpAGNptMHr7b cX377beffbYZdaKHsqBjBYUi0LKCtRcB4PU7derUv/0NscVje6xevfrtt99CMk49 kAjmkAAmBEUuLy4qKkLSin/5y1+WLFmKYblTjh8/ftNNN/p8PiZXb4nL5eI4Aw0t 4qd//37RZCZ3ikql+vjjT6KxAGIDQnZa+yVERagutNFg8PP9vp05c6bZjFgQCzw/ fPgInn2CFxQKhUxWIIasLnj3Ll68pLy8nMnVq6qq9u3bi2EZIiW1Wk3ZagRbKLIh hAYv7pfJZP/+95cYlsPBbDZfd911BgP7sljBtFWOcu3EDPYKg9fr3bz5s4hb/iYF F5A1Go0YSp0TRCtASdbV15uMRn7N6nS6F1+chap8mpqaKENHzCiVyoICUbQ7ysnJ feONN7Kzs1k5MHr0LUhlPmkmiBADJIAJoenVqzInJwfDssCFoNtk3Ljb9uzZw3zR DPQPDF20x0a0lJaWFBQU4Nk/99z/Wb58eTQW7Ha7wWAQQ2I/QZxJfWOjXqdzu1z8 ml20aFFtLWJFfdDY1LVOtJSUqCQSCXP16/f7BwwYMG/efLZu4JWANpvNx4+fQDJO EGFCApgQmvLyMhhjMCyD6tuzZy/zkH3mzJnvvvsOczdgENXrudpaKrQoRiorK/CK i8KD8M0330YjsMGC0Wh0uVzMp3IIok0CidCNjYFEaF6TFCA0nz79OTwJZDKZTpyg 7i9ipLS0VCqVMH/j+Xy+YcOGPfDAg8zduOqqK5EeBI7jqHEjwRwKbgihQS0EvXjx kvPPPx/JePisX79+2rRnmU8kJwXLrgTKxtBmG5ExcOAAvAZIFRWVH374YTQWrFYr ROrMJ3EIogPqGxsNHMd7RejZs1/Ea/DucrkOHjyEZJyIDLm8OD09XYCW7J3i9Xof fviRoUOHsnYkaffu3U88MRnJOJWAJsQACWBCaFALQY8ZM2bixCok411iz57d48aN Yz6dnEQtgsWHHAKu4iKke8Pv9y9ZsjTKaSCDwWC320kAE2Lm92pYHMfvIvDRo0dX rlyB93g2NakbG2kbsFgQT7Nfn883d+4rwrdybJPXX1+0YcMGJONUApoQA+yjcyLR QC0EPXDgWevWrcOwHAEajWbYsGFOJ88LFBFALYJFhUqlKizESoKIfie83WazWK1e r1cM0zcE0QFIi8CTJiG2tdNotHV1tPwlCsTT7DclJXXVqlWohSG6xP333/fbb79h WKYS0IRIoPiGYEC/fv0yMlAKQWdn53z//fcYliPD5XINHz68oYF9QWZqESweysvL JRKsdLvBgwcvWLAwGgt6vd7pdNLyLyF+HA4HaGAj3xnLy5YtO3HiOL82m+E4Q3U1 dQNmj3ia/RYWFq5c+UZKSgprR/6PESNG2O02DMt2u+PIESoBTbCHBDDBgMrKytxc lELQPp9v7959GJaj4e677/r555+Zr6eBqjEYjJR6xJzevXshNbfw+/0QSP35z3+O xoJOp/N4PMxvV4IIBxDAOq3W43bzaPP48ePLli1FegQsFstvv2GpayJMRNLsF963 f/jDH2bPnsPWjTO58sorkOZATSbziRNUAppgD4U4BAPwCkHDcLJly3d5eXkYxqNh 9uwX161bx3xVze12cxxXX08amCUDBvRPS0vDsBz9BJDdbocAnfKfiVgBBLDZZLJZ rfyanTjx8eTkZH5thnA6nYcOHcawTISJUqmQSqVI32/4wOt6+PDh9957H1s3zsRk Mt144yikIYBKQBMigUIcggGoeyCffvqZESNGIBmPhg8++GDatGeZD7qgbfR6jjah sSJQAKu4GCm2gCfr448/icYCRCcuvnurEgQeSKWwZs6caTabeDTYTLAOVhPtgWQF vCSlUvbNfj0ez8MPP3LttdeydaNNNm/ePH/+PCTjtAeeEAkkgAkGoO69ufzyK+bM EV1CUYidO3feccftzNfWfD4f6Jza2tNs3UhMlEpFURFWFfSbbrr5iSeeiMYChOYQ oDO/RQkifOobG/U6nZvXiZv169fv2PELjwZbolarKQ2HCaWlJRKJhHkqls/nf+ml l8455xy2brTH9OnTf/zxByTjMMRQLRJCDFCUQ7Bh0KCzkNZCS0pKNm36GMMyL9TV 1Y0YMcLtZrzIBiKH4ww1NZSJJDSofbDffHPN2WefHfHpcFdAaE4CmIgtMLKgq6ur Fy9+nUeDLaE+qEwoKyuTSPKZv9x69EhesWKFXC5n60YHjBt3G1KnLo/Hc+DArxiW CaKrUJRDsKFv3z6ZmZkYllNSUn7+GWvmnhdsNtuwYcP0eh1rR5KMRqPdbqdkPCGB IEwqRdkA7/V69+3bH42FYJk0A1/+EIQwhLKgDXo9v2bxtgHr9RxNPgqJXF6ckZEh huIgubl5q1evBmdYO9IRQ4cOgdEEwzIEP0ePHsOwTBBdhQQwwYaKioq8PJTW89HL AAHw+Xxjxow5fPgQ89los9lstVpJAwtGRUVPpDgs+qkfi8Vi5buYEEEIQH1jo1aj 8Xo8PNqcPHkS0vvZaDSePHkKwzJxJqB+s7KycnJQGk+Ej9/vr6zstXDhQuYJ2J1y xRWXI+2RNhpNJ0+exLBMEF2FBDDBhrKyUqlUimR8zZq1gwYNQjLOIxMnTvz3v79g roFB84DyoW05wtCrV6+cHJQeSNFXwDIYDE6nky9/CEIwQAAbOM7pcPBoE68Oltls OX6cOiEJgUIhVyqVSOuZ4QPq96KLLn7qqafYuhEOR44cfuihh5CM6/X6mppaJOME 0SVIABNsgDGpqKgQyfi4cePx3uD88tprry1btpR5RUq73W4ymUgDC0Dfvn0zM1Hy 3y688K+LFi2KxoJGo/H5fHz5QxCC4XA46urrTUYjjzaXLl2CtFpls9mPHj2KYZlo CajfoqIi5lPMIL9Hjx5z++23s3UjTJYvX/7BB+8jGVerNfX19UjGCaJLkAAm2IA6 Mv3xj398441VGJYx2LRp09SpU5hr4OD+T2NDA9UmxWXgwAGpqakYlseOHfvoo49F Y6GxsZF5sEgQkVHf0NDEa+WejRs3bN26lUeDzbhcroMHD2FYJppRKBQFBeyb/YL6 raqadMUVV7B1I3weeeThQ4dQbs5QkUWaZydEAsU6BDPwlEBubu6WLd9FcKLP52Oy P2fXrl3jx49jvjXI7XZzHEf9OVA5++xBSJMd06fPiLKrZENDA/ObkCAio76xUdPU xGMKw44dv6xfv54vay0BUbR//wEMy0QIpVIhlbJXv3A3vvzy3Ggq8wvPyJE3IFWC oHkfQlSQACaY0bt3r+xslM2QMOrs3bsvsnPVajVem9YOqKurGz78eg+vRVwiACIz vZ6jPvVIyAMNsIuRVlnfe+/9Pn36RHw6PDVNTU0kgIkYJdANWKt1u918GWxoaHj1 1fl8WWuJ3++HZ41KDyKhUqmkUgnzpKru3XusXLlSzO2O2uTKK69AGgUsFstvv9HW d0IskAAmmFFeXi6R5GNYhvDiyy+/lMki2WMMcQnoEyYa2Gq1DhlyjcmEUnYlfEAI cRxXW3uarRtxiTxAMYZluOd37dodTeDi9XrVajUJYCJG4b0OFrwJp0x5Amm6CtQv UqvVBKe0tEQikTB/j2VlZa1Zsxap1yMeer1u9OjRSPc8xxmqq6sxLBNEBJAAJphR UqKSyWRIxh9/fOLf//73CE4M1QFipYHh0iNHjjx1inGfAFBToIGpWiPvKBSBJWAM yx6Pd//+qLp/kQAmYhoQwCaTyc5r9ubEiROTk1EWEpuammgzJO+UlZWC+mVeyECl Klm2bFksvks//PDDpUuXIBnXarWnT1NyGSEWSAATzFAoFMXFWCLzr38dvHDhwghO NBqNjuAaAisNDNx7770//fQj81HcYDDAR0F5ejyCd89H3/6aBDAR08DLqr6hwWgw 8Ghz4sTHkfaRNjWpqeIgj8jlxenp6fn5KDll4eP3+88999yZM19g60bETJkyZdeu nUjG6Z4nRAUJYIIZMGIVFhYibdQpKCj48suvIjjRZrOZzebm/0Var+uUmTNnvvvu O8zViMlkttmspIH5QqlUIM2qRLPvPQQJYCLW4b0QNJ4AhmeNyg3yBcQSmZlZubk5 bN2Al/CwYcMeeOBBtm5Ewy233GzgdQqpGRhfNBoNxRKEeCABTLCkb98+SJtk/H7/ nj17IzjR7Xbr9fqWP2HVSHDNmjWzZ7/IvI6l1Wo1my20XY0XUNtf7969J5rTSQAT sU59Y6O6sRFe/nwZrKqaiDRFSw1R+UIul+fkZGdlZbF1w+Px3HPPPSNHjmLrRpTg VcCy2WxHjx7DsEwQkUECmGBJRUXPvLw8DMsQA23Z8l1kxpuaWk9SstLAX3311SOP PMy8miUM7TqdjnasRQ+eAIb7c9eu3dFYgEemsbGRBDARu/DeCYkEsMhRKOQFBQXM p4lhiHzmmWcvvvhitm5EiclkuvHGUUihjtFoPHnyFIZlgogMEsAES0pLS2D0QjI+ cWLVmDFjIjjxTAEMFBYWMtEGBw4c+Mc//s58PzDElFqtlnL2ogQvBTop6hXgJOoD TMQ4IIC1Go2Xv2ZymAKYUqCjBV6nMpmM+SsLBsfXXnutX7/+bN2Ino8++mjJksVI xnU6HbWWIEQFCWCCJah64IILLnj99Uje5hCatJlEB2Mtk8VYEOTDhg1zu13CX7ol 8JlotTpqERwNeDd8xDn/LWnvzieImAAEsE6r9fDXCpgEsGhRqVQyWQHzqeEePZJX rVpVWIi1sUVIJk+etGdPtLOo7UE3PCE2SAATLJHLi0EPIM3g5udLvvnmmwhONBgM TqezzV+xyray2WxDhlxjNBqFv3RLQB3pdDrqZBAxeFWgoy+ClRRoAql38yceCEJg QADrdTq3i7e5QqoCLU5KSlQwFjNXv9nZ2WvWrM3IyGDrBl/ceOONZrMJwzIMTyCA qQIWISpIABOM6devL9L4EbEksFqtFoulvd9KJJLU1NQo/IoQkbQI9ng8ej1Hu9ci Q+QC2Gw222w2XvwhCOEBAczpdC4SwHGNUqmUSiXM9/3GbrPf9sCrgGW3248cOYph mSAihgQwwZjKyorc3FwMy36/f9Omj0tLS7t6IsRPHMd1cEB+fn5aWloUrkXO3Xff 9fPPP7Od+fZ6vaCBKRc6AsTcBzgpGKaYTCgrAAQhAAEBrNe72snfiQASwGJDpVKB +mVbGBJCiz/84Q+zZ89h6APv1NfXjx8/Dim0gGHlxAnGc/cE0QoSwARjQKAWFEiR jI8ff/uDD0bSlK/NOlgtycvLS09Pj8ipaHn22Wc/+uhDthPPEAHo9XqqadFVFAo5 UmdpXgSwz+fTaDTw5TLPLSSICOBdAOPtAYYhhurqd5XS0hKpVMr27QQvyauuuvqx xx5j6AMGK1aseP/995CM63QQLdQiGSeIyKAoh2AMah2siFVBpwIYyMnJQWpi3CmX XXaZXq9jculmQCZxnKGmpoatG7EFngCGr2Pbtu3RT8rAnU8CmIhR+BXAbrfrqaee QnoWSAB3lbKyMokkn/mrKS8v/91332XrAwaXX34ZXlY5VcAiRAhFOQRj5AFFUIw0 qkEov2vX7ggWS8Msh5udnZ2VlRWRa9Hyj3/8/cCBA8yjAYPB6HDYqbhF+JxzztlI q/fvvfd+nz59ojTCcRyPWygJQkj4FcANDQ2vvjqfF1Ot8Pl80edrJA4QJKSnZ+Tn 57F1A0KCvn37vvbaArZuYAA35DXXXI0XhjU1NVGQQIgNEsAEewYM6I+3pfb11xdf cMEFXT0rfBmQmZmZk5PTdb94YOrUKZ988glzDWwymW02Kw1vYXLWWQNTUlIwLM+d +8qll14apRGn02kymbxeL/P7iiC6Cr8CeP/+/W+9tY4XU61wu92//noQw3L8Aeo3 MzMrN5fNINsMqLhLL/3fyZMns3UDiZ07d0I4gWQcxpRDhw4jGSeIiKEQh2BPr16V eBpy6NBrZ8yY0dWzOi4E3YqMjAykOl6dsmLFildfnc+8EKUlCGngcMCb7nn00cfG jh0bvR2dTgcBOglgIubgVwB/++23n3/+GS+mWkGSIExA/WYHYeuGz+cbP/720aNH s3UDj9mzX/z666+RjJvN5uPHTyAZJ4iIoRCHYE9paUlBQQGS8X79+r3zTpd37HRa CLoV6enpeXlsErS++eabhx56kG1VzKRgp2KTydzYSLvaOqFv3z5IW8f/938ve/nl l6O3YzQa7XY7CWAi5uC3DdKqVauOHEGRqfC2PHr0GIbleEIulysU8nD2IqHi9Xqf fXba4MGD2bqByj33/PPkSawqzTqdjuplEiKEQhyCPXi9YZKC0nTr1m0RnBhOHayW pKamSiSSCC4UPUePHhk5ciTzvogOhwO0E1V26ZiBAwcg9ZEuKir6/PMvorcDAR98 j6AiSAMTsQUIYL1O5+ZJAE+f/hxSW2x4uA4ePIRhOW4A6VtYWMg8ucnj8SxZsrRX r15s3cDmuuuG4ZV+oI5fhDih+IYQBXiVgVALQbciJSVFKsVq6dQxHMf97W+XMA8X givnBhrtOgBvD3BaWvq2bZHM9ZyJxWIxm83MbyeC6BIggHVarcft5sXalClT/H4f L6ZaQXuAO0ahUMhkBczTmnw+3/vvf8Aqt0tIrrjicqRPm+q9EaKFBDAhClDrYK1Z s3bQoEFdPSvMQtCtSE5Oxkvn7hgQn4MH/9Xj8TC5ejPggF7P1dfXs3VDtOCtAMPd umfPHl5MwZdoNBppJzARW4AA1mo0Xp7egRMnTkxORlEFtALcAUqlsqBAylz9du/e Y8OGDUiTlaLiyJHDDz30EJJx2u5OiBYKbghRUFlZgVdHavTo0VVVk7p6lsFgcEZU TAVGbplMFsGJvHDppX8Dz1ldPYTX6wUNXFdXx9YNcdK/f7/ou/W2ScTJDm3icDg4 jqNFYCKGAAGsaWry+fhZtp048XGkfSXwcB0+fATDcqyjUqmkUglz9ZuTk/P++x+w 9UEwFi1auHHjRiTjJpPpxAms3cUEEQ0kgAlRUFKiwhONvXv3jmAws9lsZrM5siuC bCgsLIzs3OgZNWrk8ePHWV09BMSger3+9GnSwK3BK4Ll9/u3bPmOx4Q96glMxBYg gJt42n9hs1mfe+45pAwIKoLVJhAGSKVS5pNuZWVlS5cuY+uDkEyYcHd1dTWSca1W S2EAIU5IABOiQC4vLigoQEo3ArM///xLV89yu90g4SK+KFsN/MAD93///fds81dB j+n1XG1tLUMfREjv3r3wuno8/fQzI0aM4MsafINNTU2UBU3ECvUNDU08FaLftm3b hg3/4sXUmVgslt9+YzxHKTZKS0ulUgnzMeu8886bMeN5hj4Iz9ChQ7xeL4ZlCKJ0 Oh31RyTECUU2hFjAEwYej2fv3n0RzCtHUAerJTCWFxVhVbfulDlzZq9bt465euE4 rrq6hq0PoqKioideVZXLL79izpw5PBq02+1ms9nn8zG/kQiiYxwOBwhgI08bQFav Xn34MNY2XaPRePLkKSTjsUh5eRmrHgrNgPodPnz4Pffcy9YNgYF3+5VXXoGU6k8T PYSYoZiGEAvl5eUSST6S8Xnz5l9yySVdPStKARyCYS+H99577/nnZzDPKAv1laVp 4BCo93lpaenGjZv4tRnxZniCEJL6xkYTvGp4alw0a9YL8OLixdSZcJwBL+k0tpDL izMyMphXWgYd+MADDw4bNoytG8KzdevWadOeRTJO9zkhZkgAE2JBpVIVFmJtAx46 9NoZM2Z09SytVstLalBBQQGrJr3btm27++67mNcUMZvNVquVNHBSYINZKV6vrMiy /TsFNLDdbmc+k0IQHQAC2MBxToeDF2tPPDGZFzttotfra2pob0hA/WZlZeXk5LB1 A0b5WbNePPfcc9m6wYTZs1/8+uuvkYxrNFqqhUmIFhLAhFhQKOTFxcVIxkFdf/zx J109y2g0OngKpyQSCVLzm045derUsGHXslLgzYAABhlMGhh1ogciuR07dmLcaSaT Cb5B0sCEaAEBrNdq3Xw0AfZ4PFOmPIE3b0jCICmofkH6ggBm6wZ812+8saq0tJSt G6y47bZbecl0axOw3NDAz558guAdEsCEiMBrkQqB+86du7p6lt1uh7ifLx/y8vKQ +t90CijPiy4azFy9wOdpNJoaeapSE6MolQrUneHTp8+49tprMSzDs2Cz2WgzMCFO eOyBtGPHL+vXr4/eTnuo1er6en6qVcco8gBY893hA3fLhx9+hFeVUPxcffVVSJap 2TUhciiUIUREr169cnJQhiIY5376aWtXJ5u9Xq9Wq+XRDRhoWU14ezye88//C18d MiPG6XQaDIZEnhXGjvwGDx68YMFCJOOgge12O5JxgogGHktAL1u27MQJxOI9jY1N iTwPqFDIGZbGaKZbt26bNn3MPDeKITabbfjw65G+CLPZwrwdI0F0AAlgQkSgloJ8 4okpN910U1fP4j07KDMzk+GWp4svvthiibC5MV+4XC6OAw2cuAsgZ501EKnjV1Iw 0eDbb7cgGU8KprIDVBeaEBUOh6Ouvt7EU9mqZ555Gq8Dttvt/vXXg0jGxY9CoSgo kDKXnZmZWR9++CFbH5izadOmhQsXIBmnBhCEyKEIhhARKpUSr3fuX/7ylyVLlnb1 LIztMenp6QyLXl5//XXV1dVs1YvH49Hrufr6eoY+MKRPnz5ZWZlIxr1e7759+5GM h4Cvz2QygUIgDUyIBH4rYE2c+DieQrNabceOHUMyLnKUSiWoX7ZFGf1+P7jxxhur GPogEqqqqvbt24tkXKPR1NUl6BBPxAQUvhAiIpAbWlyEFFVnZ+d8//33XT1Lr9fz UlWlFampqQzbHs6ZM3vt2rVsM9BAp4EGTsxKMBWYrYCTAk2/5l1yyd/w7IcIVTUj DUyIARDAWo3G6/FEb+rAgQPr1q2N3k57JGwTYJVKJZVK2Kpfn883YsSIRGv22yYO h+Pmm29CanHn9/ubmtSJnOdPiB+KXQhxMWBA/7S0NAzLka2MWSwWCPQx/ElJScFr h9Mpa9a8OXv2nORkxrEIaODTp08z9IEJpaWlBQWIX31kyQ4RAFGOXq/38KE6CCJi IJRvaGoy6PW8WFu8+HXU5qU6nb62NuF6IJWUlID6ZTvr6vF4//nPCaNG3cjQB5EQ 2jIw4e67kDIdQFcfOnQYwzJB8AUJYEJcVFZW5uZibZF98801Z599dpdOCW5Y5ZD8 6dGjh0yG1RGnUz77bHNVVRXzbDT4eBOtJSZ2IejU1NTt23/Gs98KiKUsFgvIYFoN JphQ39gYKM/G00wlagfgpIQsAV1WViqRSNi+H7xe75QpUy+99FKGPogHeGR27tix cMFrSPZNJvOJEyeQjBMEL1C8QogLGCnx1kVHjhz15JNPdvUsvC55ScH+THjbnjvl l19+ufPOO5hX4+Q4A+qSi9iQy4vhS8ebevD5fN9+u0XgHHuQwWazmXmZcSIB4bED sMVimT79ObxXIsgwjUaTUO3Qy8vLJZJ8tj7Axz5nzkt//OMf2bohEuBdXd/QsHzZ sl27diJdQq/XJ9q8NhFzkAAmxIVSqSwqwhKEZWVlGzZs7OpZqAI4KdiMAeQQq9nx 48ePjxo1ksmlW2I0mux2W+LEhX379snMxKqDBfzjH/947LHH8ey3h8vpNJpMJIMJ wfg9/5njkvz+6K1t2LBh27at0dtpD5vNdvRoolTAksuLMzIy8/Jy2brh9/uXLl0G OpytG+KhvrGR0+ufm/askaeq6WeiVmsStsglESuQACbEBQyZRUVFSBPwYHbnzl1d PUuj0QgQ0MtkMlbZyPAPHDp0qNuN1fYjTMxms9VqTRAN3LNneX4+4qoIdjOkjvF4 PBaLBam8CkG0JJD/bDTabTZerKE2QAIMBsOpUwmR7QJDeVZWFsOefyF69Eh+8803 CwoK2LohHpo3zE+aVIUUaEG8pFarE2QoJ2IXEsCE6MBbHIP38g8//NjVIdloNDp4 6q7RMRKJJDU1VYALnQkoz6uvvpp5i+BQYeFEGDhVKlVhIeL2b6/Xu2XLdwwrjYew 2WyghP18LM0RRJvwWP8Z7tXnnpuGOhGp0WgTofQ9qF94xcFbiK0bmZlZa9euRc21 iTkCDcMAvf7ZZ59BEsAJleZAxC4kgAnRgbo49vDDD99227gunWK3200mE447rcnN zc3IyBDmWq3weDzXXXddQwPjtCX4tI1GU9y3T0DNdAhx4403TZkyBc9++Ph8PpAW DoeDlDDBL6HdjEaDgRdr69d/sGPHDl5MtUmCrIzJAxSz9iJJJitctWoVXj/nWCS0 /AvPy9dfffnFF18gXSVx0hyImIYEMCE6SkpUeLWRzz777DffXNOlU7xer1arRfLn TLKysrKzswW7XCtGjx59+PAhVlcP4XQ6YQRtaIhzDdynT2/4rvHsw330ww8/4NmP AHiUQkqYtSNEnFDf2KjTaj08tWp/8sknvV7Enl5Wq/XYsd/w7IsBhUJeWFjIvLBi ZWWvRYsWsfVBhDTXS3/11fkNDVilyCFeOn06/tMciFiHBDAhOmAELSoqQioKlZaW tm3b9q6ehV0HqxXp6el5eXlCXrElDzxw//fff8+2ZYXb7eY4Lr6bhZSVlUmliCnK Pp/vo4/+VVlZiXeJiAElDGLA6XRSuSwiYvhd/m1sbHzllbmoyk2v52pqavDsM0ep VBQUFDBvrXfeeefNmPE8Qx9ES/N+gSlTnkDKxwGzarU67ueviTiABDAhRgYM6A9K FcOyx+PdvXt3V9OiBBbAScFWrgw3cE6fPv2DD95nO4vv8XggXozjSpLY3YCBc8/9 n+XLl6NeInpsQZhvFyRiC1C/jWq1yWjkZfcvsGjRotpaXHUa3x2AlUqlVCphm3Ls 8/mGDBn68MMPM/RBtDRPGMHLdvLkycnJKPMUTqfz0KHDGJYJgl9IABNipLKyMjcX q3rk88/PHDJkSJdO4TgOtTRom0AkwbB25eLFixctWsh2Lh/Gafjk4ziZauDAAahl zyAc3LlzV6zsgvN4PI4gJIaJTuG3+HNQEkxCfVJgBDl4kPHuEjxKSlQSiYT5eDF2 7K0AQx/ETKBdtk7ndrl27tz5wQfvI13FZDKfOHECyThB8AgJYEKMlJWVSqVSJOOD Bw9esGBhl06xWq0WiwXJnw7o3r17YSFWV+ROWb9+/bRpzzLPZ9Pr9bW1pxn6gEdF RU/sXPexY8c++uhjqJfAANQCKGH4M7C+xzQbnxAhgbUsEMAGA19pnBs3bti6FbH9 b1Kwm8DJk6dQL8GK0tISGK/Z7poB9fvww48MHTqUoQ9iJvTIGDkO/r5s2bITJ44j XQjG65qaWiTjBMEjFFgQYgQ1OzQ3N3fLlu+6dIrb7YbXOpI/HQNRBXaibAds2bLl gQfuZ66BOc4Ql3vnVCol9gQHfHc7duxEvQQ2ENqGVoY9PCW7EjFNqJKtxWzmq/YV MHnyJGz9ptFo6uricENHWVmZRJLPVv3Cm2H69BkXXnghQx9ETqD7Ecc5gwUIn376 KTd/z04r4jvPn4gnSAATYkQuL5bJCpH2qPh8vr1793X1LOG3AbdEJpOxUqEHDhz4 +9/HMK/qaTAYArv+4quDSPA+l2GnKD/++MS///3vqJcQEud/oAJaCUho66/NanXy V0v8u++2bN68mS9rbQIKTavVxt/rKz09Ha9nYZjAe+C1117r168/WzfEzO/djzgu lDFRVTURKZzweLxarSbO7nMiXiEBTIgU1CYxK1as/POf/9ylU9gKYADiDKTCYJ1S W1t7/fXX+/2M9YbJZLbZrHE2uFZUVOTl5aJeIjk55ZdffkG9BCsgngMl7HK5SA8n CM19XHi0OXnyZOz1S6PRdPLkSdxrCAuo38zMLLxSHWHTbeXKlUqlkrUboiaQ/Gww OOx2+Pvx48eXL1+GdKFEaPRFxA0kgAmRUl5ehlcG+Zprrpk584UunaLT6ZhnYObk 5GRmZjK5NMdx8KE5nYw7uFosVovFHE8aWIAsaODOO++67777sK8iBkJiOLB52OtF 6vNBsMLhcNTV15uMRh5tbt68+bvvtvBosE3iLP8Z1G92dk52NmIb83BISUldu3Yt w5aBMUFo+ddkMISmCOET+/XXA0jXgjihujoONysRcQkJYEKkoAqDgoKCL7/8qkun mM1mG08VR6MBBDDIYCaXhnEUNLDBwDG5ejM2m91kMjU2xkmbQQgl4W5MSUlBvQpI wW3btqenp6NeRYSADAYx7Ha7Q5KYtTtEhMDLR28w2G02ftUv3BdTp07F3l0Ct59O p4ubaTt5EHipsHUjJycXtByrrKgYor6x0Wwy2f6TNDFt2rMO/rYPtCLOJnqI+IYE MCFSQBgUFRUhbT2NYBuw0+k0GAwYznQVGPJZbbuCz+2GG0ZUV1czuXozMH4bjcaG hjjRwD17lgvwhf7lL39ZsmQp9lXED0nimCO07xf+5DfzOSnQ7O11Ad5mMHCcOsX4 nckXCoW8sLCQeUkIpVK5fPkK5m7EBCCAdRpNc/7axImPI1WdgPBArVbHzUQPEfeQ ACbES9++ffAyft98c83ZZ5/dpVOYbwNuJiUlBa9NVKeMHz9u9+7dbMt+gnqBsDI+ qk0qFIqiokLszxPE3tKlyy644ALUq8Qifr8/JIkBCBNpL7GoCKlfu80W2sHII0eO HFmxYjn28i/cXWq1pqEhHt5USqUCxh22fcXh8xw4cOArr8xj6EMMEeh+1NBg/M/c fXV19eLFryNdy2azHT16DMk4QfAOCWBCvKCujA0deu2MGTO6dIp4BHAS6xbBjz/+ +Jdf/pt56wu9nquvj4eEK9S5nma6dev+008/JWAidAR4vd6QHg4JY9pOzITQ9kWr 2cx715Zg8vOTPXqgLyHGjSpQKpUFBVLmLfEuuujip556iqEPsUV9Y6Nep3O7XKH/ feutt/bv73ILjDCJp0wHIhEgAUyIl5ISlUwmQzIO6vGLL/7dpVM0Go2oVofYtgie NWvW22+/xTYJDVQKaOC6ujqGPvBCaWkpBJfCXGjjxk0CXCgugcff3UIWi+ptEGeE Nv067HazyYTxOc+a9YKR1+3E7aHT6WtrawW4ECoqlUoqlbBVv3AbXHfd9ffffz9D H2KLwPxRsP1v80+ee+45ux2rlIlWqz19OubHYiJxIAFMiBe5XF5cXIS0zBjBNmAI mPCqR0RMQUEBq5y0lStXzpv3CvM1Ab0eQszTDH2IHrjVCwsFavU8ePDgBQsWCnCh BAHuQM9/CKljWi6OktDCr91m47HZb0uWLVt24sRxDMut8Hq9Go021iv2lZaWSKVS tvk+8Enecccdt9wymqEPMUd9UP22fIjwNgDDS6+pSR3rtzqRUJAAJkRN//798DI2 1617a+DAgeEfH6q9hORMNOTl5bHKa92wYcOTT05lvivMYDDEeveFioqewvTzgI/r 8suveOmllwS4lqgI9qg8eurUqZqaWq1Wy3F6s9lssVjsdrvT6QxpV4izfUHgUwr9 GbGaDZ7X+bkhXRGlZg4Z6Rake/fuoT+7d++RnNwjJSUlNTUV3g+ZmZnZ2dl5efkg ZlQqZUlJaWVlJau2au3x+8KvzQZfjA+nRNnq1asPHToojJyD8eLkyVMCXAiP8vKy /Px85rtdJk6suuqqqxj6EHOEZpGMHNf8bqmtrV20CGvqEy53+PARJOMEgQEJYELU VGCqgmHDrnvuuefCPx4CYo1Gg+RMlGRlZUF0y+TSP/7447333sO8ICfEmqBkYrcE pTClsEJASNSnT591694CaSTA5aIB4iq1Wg3PnVar4TgDYDabHA6n3W4DxQqq1ev1 gMSDI50uJ0R68E9LTUmBj/Ho0aMgcZtLPcPDG1KGrP9BIiIk8oOfSbcePbqDVIaX bWVlr2YVHToMPkCPx90D1HSQjIyMtLRUeN/kBciVSgsAmUwWZUOakPR1Op02q9Xl dPLx72sN6Kh5817RarWCPWUxXf5KLi+G75p5l124/WbOfOG8885j60bMUd/YaIIx sUXvxrfffnvfvr1Il4uDuR4i0aBogBA1qNuAi4qKPv/8iy6dIqo6WK1IT09nFawc PHhwzJjRzNWF2Wy2Wq2xq4F79+6dnZ0l2OVA5MyePeeyyy4T7IogcnQcp9Pp6uvq mtRNIA9sFrPJZDYYOIifrFabzWaFY4Ky1hvSZmwT7Inwga8MJF/oKwOdDHo4IyMz MzMjJycnLy8fXk3wJodXbnFxsUqlAs3cfGKz9HXY7U6HAymBfN++fevWrRVyns5i sf7222+CXY5fQP1mZWWx6jnfDLwEFixY2LdvX7ZuxCIggLVqdctOb9OnP2ez0QZg gvgdEsCEqBHbNmC1Wi3mDX4M2yPV1dVdd90w5mWBQESBDI7RnUgqlVLgyt5wMxcU yB577LEhQ4aEf1ZIx4b+XiCRhNLv4Qb48st/79ixw253lJeXa7UavT6QYwz6Fv7w BgktwzJPFiCYE8ozD60zd+vWPT1AWnp6RnY2iK5cCKZTU1N69ep1zjl/aCmVI2Pn zp2bNm1yOOwCz9BpNJq6upisUQ/DrlKp9PkYd8mG7+uNN1aBM2zdiEXgFV1XX2/6 7x1btAGYIFpCApgQO6jbgLvaDdgQXKlAcoYXGLZH4jhuyJBrmNcJC23VbmiIvcFY Li/Oz89nsp0b1EhFReX5559/+eWX/+lPf2qOk1wuV21tbU1NTX2AOojpa2tqIbSy Wq1utys0GfQfGUOjCcE/oW3YoZk1uMeSk1OCebm58KTk5uZKpVKJRApvPJlM1nzT er3ekydP7t2799ixYzqdlkmFAngLwWARi9koCoUcPk/ms1Spqalr1qxlnoAdo9Q3 Nuq0Wk+L5mGoHYBpAzARi1DIQoidCsxtwEOGDHn++ZnhH2+zBRYYkZzhCwgTIYJh IkhgIBw6dKherxP+0i0B2QbRZ3197O2+Ky0tiX7JK0qaKz81l1Zi6w9BdErojm2+ b5nftDqdLhZL0yuVCqlUyraoIZCbm7dmzZood5UnLDAKgwA2tuh+lBQo+bn2wIED SFekDcBELEKRDSF2SkpKZDIsSSCVFnz11VfhH+/xeCCyQXKGXyCOSUlJEf66Pp/v hhtuqK4+JfylWwLfFMdxMZeCKJcXSyQSivwIInZxOp3w8om55V+VSgkvH+bqV6lU LV++nPkSdOwC6pfT61tVkps2bZrDYUe6olarO3069qZ7iASHBDAhdhQKeVER1jZg r9e7b9/+Lp0i5jpYrcjJyWHV5uT222/ftWsn23UYkOJ6vT7mKnOIYRGYIIiIicXl 35ISlVQqZSs7/X7/WWcNmjt3LkMfYp1Q9yMDxyX9d7ES1A3AarU6FvccEQkOCWAi BhgwoD/emtjixUvOP//88I+PIQEMZGRk5ObmMrn05MmTPvvsM7YaGMZmjuNqamoZ +tBVGO4EJggiSmJx929ZWalEImH+rr7kkkumTJnK0Ic4IJD8bDA47P+12Hv06NE3 3liJdEWn03no0GEk4wSBBwlgIgaoqKjIy8NScf/7v5e9/PLL4R+v1+vdLWpLiJ/U 1FQIbphceu7cl1evXs08mQ3iUYhKYygkRe3+RRAEHrHVD0YuL05PT8/Pz2frhs/n Gzly1IQJE9i6EeuEln9NBkOrdgyrVq06cgRLoxqNppMnTyIZJwg8SAATMQDqNuC8 vLxvv90S/vFWq9VisSA5g0SPHj1YCao1a96cPXtOcjLjbq4mk9lmi6UWwX379mGV vk4QRGTYbLajR4+x9iJcQP1mZmbl5jJu9uvxeP/5zwmjRt3I1o04oL6x0WQy2a3W Vj9/5pmnXS4X0kVpAzARo5AAJmIAUW0Ddrvder0ewxNUGJaG/uyzzVVVVSDChb90 S2KrRbBSqWD1fREEEQF+v1+j0cRK8Xm5XK5SqbxeD1s3YPydMmXqpZdeytaN+AAE sFaj8Xpaf6e0AZggzoSiKyI2QO0GPHfuK10agGNrG3BLJBJJamqq8Nfdvn373Xff xTwXOrZaBKNm/hMEwS8xlAsqkma/oH5nz57zpz/9ia0b8UGg+1F9PQxwrX6+f//+ t95ah3dR6gBMxCgkgInYoAKzG/Bf/zp44cKF4R8fuwI4iV1p6GPHjt10001JSf7O D8XE7XZzHBcTqzRyubyggE0vK4IgugS8WHQ6fUwkmCiVioKCAuYpOX5/0uLFiysq Kti6ETfUNzbqtdozC5QsW7b0xIkTSBelDsBE7EICmIgNUMsCgSD88cefwj9ep9N5 zsgyiiHS09PxZhM6QKPRDB06hHkJMa/Xq9frY6JFMFXDIoiYIFZqX6lUSqlUylz9 ggNvvrmG+r3xRWD5t7HRyHFn/mrq1Kk+nxfpurFy2xPEmZAAJmIDuVxeXIy4DXjH jp3h5wZbLBbrGXUmYouUlBQIg4S/LnxuQ4ZcYzKZhL90S3w+H8dxMdGrs1evXjk5 2ay9IAiiXcxmy/Hjx1l70TmlpSUSiYR55nNWVtaaNWupyB+PgPrl9HqX09nq5x6P Z8qUJ5DmO/x+f1OTOiayHgjiTEgAEzFDv359MzIykIxXVU0aPXp0mAe7XC6uranW 2ALCoMLCQuGvC0Py8OHX19UxnjaGwdtgMFRX17B1o1MUCrlUSonQBCFSQmURxV9Z oLy8LD8/n3ldveLi4hUrViLVZEpMQt2PjBwHg1qrX33//feffvoJ0nXtdvuRI0eR jBMENiSAiZihZ89yvHaFAweetW5dFwpFxPQ24JbIZDIm6XDjxt22Z88e5tGYyWSy 2Wwib4+kUqlksgLmnxVBEK0AyaHV6phP53VMsN1RZm4u44p68FkNGDBg3rz5bN2I PwLJzwaDw24/81fz5r2CF6sYDIZTp6qRjBMENhRRETEDyIDCQqz9kCACd+zYGf7x cSOAk4KdkPEqbHdAVVXVF198zlzXWa1Ws9ki8jwu1NkfgiAiQ/waINjuSOn1Yu0C DRNQvxdf/P+efPJJtm7EH6HlX5PB4PP5zvzt5MmT8EZYjUYr8qkfgugAEsBEzCCX FxcVFSHtX4LB4+uvvwm/JodWq2UeUvBIRkYGk/WBuXNfXr16NfM9acH2SKaGBvGW hoabPycnNyuLds0RhFgIthY3iTl/RKFQFBbKmL9gYXgdOXLUhAkT2LoRl9Q3NppN JltbRUnMZvOMGdPxQia1Wi3mm58gOoYEMBFL9O3bB69yxvjxtz/44INhHgxDi81m Q/KECazKYq1bt27WrBeYbwkLtkcy1NeLtzS0XC6XSPLT0tJYO0IQRJLT6YQ3hpgz R5RKpVQqYf5q9Xg899573w033MDWjXgFBLBWo/G21Zbik08++eGH75GuC/HP0aPH kIwThACQACZiifLyctAAeMb/9a8NYR4M0Y/BYEDyhBWsymJ99dVXjz76CPNlCq/X y3GcmJs6iKSBJ0EkOPCu0Ol0Ym4nXlKikkgkzN8V8EE9/fQzF198MVs34pVA96OG BmM7ociLL87Ci1I4zlBdLerkf4LoGBLARCyhUinxFJrf79+zZ2/4B6vVaiRP2MKk LNa+fXvHjh3LXAPD1wrjek2NeEtDi6SNJ0EkLOJvJF5WViaRsC/47PP55s2bP3Dg QLZuxDH1jY16nc7tcrX526qqiXgjhUajEfMjQBCdQgKYiCXk8mIQwHhN7d55593+ /fuHeXw81cFqRW5uLl7Hqfaora0dPvz6Nit5CIzIS0OrVKqCAinzyQKCSEDgBaXT 6UVb+0ckBZ8BkN8rVqxUKpWsHYlbAsu/jY3Gdjoynj59esGC15AmQbxeLwhg0Q6R BBEOJICJGKN3797Z2VlIxocMGfL88zPDPBgGADGoNSSYlMUyGo1Dhlwjhs3V4IPJ ZBbtBr+SEpVUShqYIAQFXvh6vV60uyREUvAZSEtLX7NmjRh0eBwD6tfAcU6Ho83f rlu39sCBA0iXtlisv/32G5JxghAGEsBEjFFWVopXqyk/X/LNN9+EeTCoNUc7Y098 kJycHH5ZbL5wuVzDhl0rhvTy4DZvo2hLQ1MuNEEIicgznxUKhUwmigIB8F5avfrN lJQU1o7EM6HuR0aO8/v9bR7wzDPPuFxOpKvDg1BTU4tknCCEgQQwEWMolYqioiIk 4xDi7NmzN8yFtWDvHCOSJyKhW7dueJ92B9xyyy1HjhwW/rqt8Hg8HMeJNuSFZwFi TeZVXgki7glWiedEW/VKpVJKJOwLPgMVFZWvv/46ay/in0Dys8HgsNvb/K3P55s0 qQrvflCr1aJ9FggiTEgAEzGGXF5cUFCAN7v8wgsvXH31NeEcCWOMRqNBckNUQGiV mpoq8EUfeeSRb775Wgx1XDjOUFsr0tluhUJeXFzM2guCiGfsdrvJZGpoEOmGiNLS Uokkn/mGCL/ff8EFF06bNo2tG4lAaPnXZDC0twlr165d77//HtLV3W63TqejDcBE rEMCmIg9evWqzMnJQTJ+7rn/s3z58jAPjuM6WK3IysrKzs4W+KJz5768atUqMST1 GY1GCILFOeTL5cUZGRl5eXmsHSGIOISe/XDwer2jRt04YcIE1o4kBPWNjWaTyWa1 tnfAokWLamuxehmYzebjx08gGScIwSABTMQepaWlBQVY24BTU1O3b/85zIPVanV7 O3DiD/hkJBKJwBd9++23X3hhphg0sNVqNZstYi6LlZ+fL4YcSIKID9xuN6hfMZe8 ysnJzsrCKgkZPqB+77vv/uHDh7N2JFEAAazTaDweT3sHPPHEZLyr63R60aZEEUT4 kAAmYg/UtE+fz/fdd9+HOaduMBicTqw6EyKke/fueH2Y22PLli0PPvgA8wS/JNGX xYKAODMzIycnh3neOEHENH6/32w222x20U54iafkFajf556bfuGFF7J2JFEIdD9q aDAaDO0dYLNZp02bhjdiNjU1iXY7AEGED8VJREwyYED/tLQ0JOMTJvwTCOfI0N4w JDdEi1QqFbjC5+HDh2+55RYxyDqI9jiOE+2iUFKwHE5hYRHE8KwdiXn8/6HlT5KC leGa/wzTTqu/tDod/h5+IkkHRkKEaYdoD9C9VqtFtKXvkoLpHhKJRAzq1+fzL1q0 qHfv3qwdSSDqGxv1Op3b5WrvgM8///zbb8NtZtFVnE7noUPs61MSRPTQYEnEJBUV PfE2PvXsWfHRRx+FcyTIIa1Wi+SGmMnOFjr1TqPRXHvtUFf7o75ggAIJrfyLc1tg CJVKFVyrTywZDF8NPJIhHdijR3JqakpKSiqQnp6WEQTu2/T0jMxM+C8zKytwD4cI 3c8h4DD4bU5ODl9LKB6PR6fT8WKqU3w+n8VisdvtDocD/rRarbYW2O02+IE9iNPp gJ84gsDN7P4dj8/nDVXWAX2VaHI6KH2tdXXind6Sy4vT0tLy8/PF8NUkJyevXv2m 8K3yEpnA8m9jo5HjOjhm9uzZHKdHcsBoNJ48eQrJOEEICft3KEFEQEmJSiaTIRmH MHrPnr1hHpw4dbBaIfyWYIjXhw0bptcLpCU6xhLAKtoMyRAqlTItLT0nJ1sM4XJk gBiD5xH8By0LoT/IV/jngDoFDVBQICsKUhikuLhYVLF4SIKKYcomYjiO02g0uv+g 1WohsDaZTIFb3xoQz263C+R96AsSwyaFyAgmPFucToeYV32TgnscsrMZFCNsk9zc vNWrV2dkZLB2JLEA9WvgOKfD0cExVVUT8bID4CUg5gQoggifWI2KiARHoZBD4IsU 1kM89NZbbw8cODCcgxNWACex2BIMcmjMmDGHDx8Sg6JzOp1Go1Hk7RDF3CcpJG6T k5NB2UJYn5OTK5VKZbICuVyhVCrLysoqKipE63ybwC0RXFxNoLoAzYBUrqmpqa+v b2pqVKvVej1nMHDWIC5XQCd3D8LazbYR/7ZGpVIhk8nE8AHCM1tZ2WvhwoVicCah CHU/MnJcBzsmamtrFy5cgBcawaMt8ieFIMKEfRBJEJHRt2+fzMxMJONXXXXVrFkv hnMkx3ExvcgTPcJ3CZ44ceK///2FGDSw+LcEo+ZKdAxESyBxu3fvkZGRDvoWxG1h YaFCoQBl27NnRd++fWNL3LYHPP4h0Zs4BeEj5sCvv+7buxcUcnAx2WAyGUEew0fn crnhfmGYdC3ydS3xbPqFm/yiiy5+6qmnWDuSiASSnw0Gh93ewTFr1qw5ePBXJAds NtvRo8eQjBOEwLCPIAkiMsrLy/BScHNzc7ds+S6cIyGAs1gsSG7ECqE9k0Je8bXX Xlu2bKlIIkKj0ehwOMS5Jbhnz575+Vi75Zslbnp6el5erlRaAPq2pKSkshL0bb/e vXsLPDMiGG63O7TPlkRvlwi0b9FqPW53m7/1eDwNDQ319XVNTWqdTmcwGCwWM3zM bje6PDYYjKdOnUIyHg1yeXHw4coTyXzf6NFjbr/9dtaOJCK/L/8aDP7gFv32ePrp p9ztPF/Rw3FcdTVWe2GCEBj2r1SCiAylUllUhJV/CyP9rl27w+mqKmSFGzGTkpIi lWI1Z26TTZs2TZ06RQwaOCk4NW42m0WYG4aXKAHPyNat28TQhlQY4N8bKh/l6zAA JTognB2M7QECAIJ7pOddnEtbCoVcoVD6fF7WjgSA+7+qatIVV1zB2pEEBZ4ds8lk s1o7OAa+oyeemIw3JqrVmvp6Ue+TJ4jwIQFMxCpyebFMJgtHo0bGk08+NXLkyHCO TORtwC3p1q1bYWGhkCsVu3btuv328WJYG0kKrgoaDAZR1dGBZ6SoqAhpqx48er/8 sgPDsngArRta6fV4PKx9iQcgiDcZjXabLbLTJ0+ehPSwwxetVqtFlcShUimlUqlI Jvh8Pv/LL7989tlns3YkcYFnR6tWg8Tt4JitW7du3LgByQF4B2q1WlE9IwQRDaII HAkiMnr16pWTg1USc+DAs9atWxfOkSSAW5KXl5eeni7Y5erq6oYPH+7xYCV9dQmx dUgK9gTGypKorKxcv/5DJONsCa304mUSJiyBJi4NDUaDIbLT58yZrddj9XfRaDQi mb0SVa+jpECxwx4rV66Uy+WsHUlc4MGpq683GY0dHzZv3it40YjZbDl+/DiScYIQ HlG8XgkiMkpLSwsKsNJuu3fvvnPnrnCOhJiMYuWWhKI3wS4nqvZISf/ZFi6GdOie PcvxvogxY8ZMnFiFZFx4ErmAs5CAAG6KtHnYv/710fbt2/n1pxmDwXDqVDWS8fBR KOTCd1nvgLy8vFWrqN0RYwLLvxqNt7M8lEmTqvBKc+t0+traWiTjBCE8JICJGEah UBQXFyEZ9/v9mzd/Bpfo9MhgV8yOduYkIMJ3SPrHP/5+4MABkayZiCQdGrVS+rvv vtu3bz8k48JAtayEB0J5jVrt6zCTsz3q6uoWLHiNd5dCiGEbsKjSnuGh6Nu372uv LWDtSKITZt4Ex3EvvjgLbwRsalI3NIi65x9BdAlRBIsEETEDBvRPS0tDMn7TTTc/ 8cQTnR7mcrlg7EHyIaYRuEPS008/vWHDv0TSnZJ5dWjUDcA+n2/v3n0YlrEJbesF Ot5NRyABAliv07kjbR03ceLjSHUf2G4DFlW156Tgp3HFFVdOnDiRtSNEJ7XTm1m/ fv2OHb8g+eB0Og8dOoxknCCYIIpXLUFETEVFTwgakIyDfvj88y/COZK2AbdHRkZG bm6uYJdbvXrVSy+9hFcarauA0DKZzEwmzlUqVWEhVgfg8PuEiQSHwwHfRYK37BYD 4fQy7QDULi8ajbaujkE3YIVCUVQkaPnAjvF4PHffPeGmm25i7QgRXP6FRyaMGfbp 05+zRVperlOMRuPJk6eQjBMEE8TywiWIyECN8r1e7759+8M5kgRwB/To0UMmw/qO zmTLli0PPHC/SNIIk4J3EUQPIL0EXlyqwJwbuvDCvy5atAjJOF9QhrMICbOcT3ss Xbrk5MmT/LrUjPBRvlxenJqaCs+peN5XoH6nT59x4YUXsnaECBB+xgReckQSu7kh gsCDBDAR26DmeSYF6o6+dPnll3d6mFarpYzKjpFKpSkpKcJc68SJEzfddKOovhHh K2MNHDgAL//8hRdeuPrqa5CMRwNoXRC9NptNVN8+0ZJo6mDt2rXr/fff49efZlwu 18GDh5CMn4nY6l0lBWs3vP764vLyctaOEAHCX/7du3fvO++8jeSGCJuEEUT0kAAm Yp4+fXrjxRDnnvs/y5cv7/Qwk8lkjzSpL3EQMh0aBOd1110nntLQSYGlFa/RaKit PS3AtZRKRVERVn040JZ79uwVyV7rECBdQou9rB0hOidQB6upCaLqCM6FsyZPnoS3 XgqBfn29EBsWSktL8vLyk5PFsvCbFCz4/MYbq/DK5hFdBZ4UTq93hVGaftGiRbW1 NUhuwGB67NhvSMYJghUkgImYp6ysTCqVIBlPSUn5+efOC0tA5G2MNKkvoRA4HXr8 +PG7d+8Sz+a6pN+Xgq3Yu4JRGyBlZ2d///0PSMbDx+/322w2KmcVcwSyOrXaiLfy PvXUk57O+sFEjADNkBQKRXDdV0QLv/AonXXWWXPnvsLaEeL/gKCioanJEF7j68mT J+ENc3o9V1ODpa4JghUiigsJIjJQF7t8Pt/XX39TUFDQ8WEQQKjVaiQf4g/QZni1 u1sxa9ast95aJ54tdkn4u4Ll8mKpVIqX//zXvw5euHAhkvFOAeEEupcWe2MXEMAG jnNG+g0uW7b0xIkT/LrUDDyVer0e78EU247fpODr6Prrh99///2sHSH+i8DyL8e5 wnhMzGbzjBnT8VJyBEuLIAghIQFMxDwQVYBAxdtfOnbs2EcffazTw6gOVpcI9fwQ 5lobNmx46qknRRV0JgUKRDsgcKmv579XsEqlRG3C/OKLs6+88ko8+20S2tmLt/RH CEaUdbD27Nnz7rvv8OtSSzQaDUYHb6Uy8FSKKRklAKjfxx+feNVVV7F2hPgvurT8 u3Hjhq1btyJ54na7dTodbQAm4g+RvYwJIiIqKyvwNpcqFMpPP/2008PUajUVm+0S 3bt3R9VpLTlw4MDYsf8Q5lrhAzcMaGCQdvwWx+rdu1d2djaPBlsi5AZg+HysVit8 PpHtFyVESzR1sLC3AcMjefw4nyvMCoU8IyMjJydHVHsxkoLP16uvvtqvX3/WjhCt CWRJGAzO8AqLPP/88xaLGckTk8l04gRW3XWCYIi4XscEERklJSUyWSdZyhED8dbe vfs6PSwwXIVRrIJoRW5uLkSHAlzIaDRed90wGM4FuFaX8Hg84BVfGdEQbRcWFuIJ VAE6AIPGDule1KsQDAnUwVKrfZFu3kbtBgwvfI1Gw8ucVCjnGR4Z8XQmbyYrK+uN N1YJ2aSdCJMuLf8mITdA0mp1p08LUbiRIASGBDARD8gh0Cguwptff/XV1y6++OKO j7HZbGYz1ixsfJOSkiKVSgW4EIS2t9469sCBA2JbigGcTqfZbPF43FHKYNTyV8C1 1w6bPn06hmXa3Js4hN/dtE3efvutffs6n5SMmOhLYcGIlJycIpHki23nRVJw4bdv 377z578qqkLuRDOB1kcGgyO8GcCDBw+uWfMmkidwqzQ1qRsjTdYgCDEjuiiQICID RvTMTKyFxAsuuOD11xd3fIzX69VqtUgOxD2gSEEDC7NOMnv2i2vXrhVhYJoU3Bhs sVjq6uoiO12hkMtkMrx/GsRDGzduKisr49Em6F6r1UrZEwlFIMQ3Gh02W2SnazSa l19+CW8aK/Qyj3gRWKVSZWdnZ2Sk8+sVL8A/bcSIEffeex9rR4i26ery75Ili0+d OoXkjM1mP3r0KJJxgmALCWAiTigvL5NIsJohpaambd++vdPDqA5WlAjWKPiLL76Y OPFx0S6A2O120IQej6erq8GXX34Z6iwMSOsdO3byYgr+dfBvpPXexAS+9/qGBqPB ELEF1L4vSRFtfQyu+iZnZWUJs6cjAkD9PvnkU5dccglrR4h26erc0JQpT+AVH+E4 rrqaGiAR8QkJYCJOUCqVRUVYFZV8Pt+3327pVGCTAI4ewRoF19TU3HjjKFekSZgC 4HQ6QSK6XO4wM9BUKiV8dKiqIJxUiI6BWM1isdgiXfoj4gYI9NWNjRHH7qgLX0nB G1Wr1YZZDloul6empoD0Fay7WwSAOF+yZKlKpWLtCNEuoeVfI8eF+VzAu3T69Ocw GyBpMPoUEIQYIAFMxAnYzZBuu23cww8/3PExer0erzRLQpGTk5OZmYl9FVC/N998 88mTJ0S4JbgZn88XXCl1er0dLQgrFIqCAtwccojJ3nzzzXPO+UNkp9vtdgjXqJ4z EQIEsE6r9UT6wgT1u3jx66hPLrzM9XquoaHdDqgw6PTokZyengbSV7TpJEnBJ7ek pHTx4sV44yPBC/BQmIxGe9jzgx9/vOnHH39EcoYaIBHxjXjDPoLoKpWVlbm5OUjG w2mGBPE9aBUkBxIN0HIFBViVvVsybdq09es/EOeW4JZ4PB7QkCDaPR5vq6BcpVJK pVLsfwKE+Dt37urqWV6vN1TjGsMlInbpUqWfNpk0qQpbdsJ9azQaW60DKxSK5OQe qampGRkZIizv3Ap4AK+5Zsijjz7K2hGiExwOR6NabdDrw0+LeP75GRB1IPljMplP nOCzHxhBiAoSwET8wLwZEkRLHMchOZCY5OXlpaej15L57LPNVVVV4tfAzYAYdrvd WVlZEH+DKhbG88GDBy9YsDD84202GwRn1BybaJPotwEvW7bsxInjPLrUHk6nE564 pOAcUEpKivhFbzPg9tSpT1566aWsHSE6p6vLv0nUAIkgooAEMBE/YDdDmjdv3iWX /K3jY2gbMO8I0ySprq5u1KhRDgf1nm0bn8+3YcPGnj17hnOwyWSiLr5Ep0S5DVit Vr/88ktizj1mS2pq2tKlS2FYZO0I0Tm/L/9ynD/sTSIHDhxYt24tkj/UAImIe0gA E3FFv3598Spw/s//nLds2bKOjyEBjER+fj52gRmPx3Pbbbf9+qsYuwQzJzMz88cf f+r4GPgAQfrSNngiTKLsBgxMnTrV5/Py6FJ8AOqlT58+8+bNj6HF6gQHngWzyWTr yhaq119/vaYmqm7VHWC3248coQZIRDxDcR4RV5SXl0sk+UjGU1JSfv75l46P0Wg0 VOYHCWGWgpcsWbxw4cIYSocWhjvvvOu++9rtHQrS12AweL0kRYguEEHOZys2b978 3XdbeHQpDoDH8NZbbxs7dixrR4guAM+CpqmpS8EDaicwjjNUV2Opa4IQAySAibgC uxnSV199JZN1ZD/QwY9am2IiwK7g/fv3jxt3G01kNAMfxe7de9rMNSXpS0RMoOlL Y6MhiroJcGdOmlRF65zNgCJ65ZV5/fv3Z+0I0QXgQairrzcZjeGfYjKZnn9+BjVA IoiIIQFMxBVyebFMJsOLh8aMGTNxYlUHB9jtdhiZkK5OhBBgKRgiktGjR4u8Q5Jg tNf+l/p+EVFS39io1Wi8wRJTkYHdEDhWCPU6WrRokZh7ERNtElj+Vat9XZlG/Ne/ Ptq+fTuSPx6PR6vVUgMkIr6h2I6IN3r1qszJwWqGVFRU/Pnnn3dwgNfrhZED6epE SwToFTxv3ryVK1ckeDo0BENff/1NYeF/JT5QpgPBC/XBFWBnFPcS3IozZkxP8EVg GHduvvnmO++8i7UjRJeJrBz69OnTbTasnotms/n4cWqARMQ5JICJeKO0tASvfyzE Gfv27e/4GKqDJRggTeG7Rl2k3b9//+23j///7N15fJxlvf//NE3aJG2WJpOZyd4m 6crBI+rxyFePy/GgcjxH9KsihQeHo+jPg0ePqCRd2FpogbK0IGUtLULLUkBaCm26 sCir+BUpSumaLllm7tyz3TNZZpLZfncaTqndk9yfuWd5Pf/g0Sbt+77QhJl37vu6 PpFR3KFKdTNmzHziiSeO/FZ/u+YfzqN6wCmMfhiSbunSpS6XatSSUk529lj9fwEe e05RI3sIQnQAksfjaW9nABLSHAUY6UZ6GNItt9zy1a9+7RR/gAKcYPn5+UVFRXL5 mXw6dDQafeGFjbW1tUO/1d8YZfLPAiBhsACo6mi2kbtcrttuuzUDn9TgtOdUN/gD IEXxD3Mb/LvvvvvUU2uFlsQAJGSIjHs/h0wgOgzp4x//+MMP/+YUf4CNkYmnV9OS kpJx48bJXeLxxx9fsuSWTBs6On369CefHHynxeZ2CBksAJoWGt3g6KVL79BrsFFL SgnRaPQnP/nvb33rW2YvBCOnf/F73O7IMN8wLF9+d2dnp9CSGICEDEEBRhqqq6ud NGmSULhegd5558+n+AM9PT29w5nmB6Pk5OTIPf2edfhG00UXXeT1euQukVT0d9gv v/yyxVLOz3QgZ/As6K4uzesdTUggELjxxhsy50ZocXHJvffeK/qfO0gb8Snoc+Y0 y/0o1ufzHTrUJhQOJA8KMNJQZWWF1WoVCo/H488//0JNTc3J/sDAwIBvFIM9MEoF BQVyp6BlHX4G/vHHH8uE5y3PO+8rN910k8eTKYUfZnEoitfjCQ8MjCbk0Ucf2blz p1FLSlrRaPSCC77505/+1OyFYLRG9mXvdrtvv/02uf04qqo6HE6hcCB5UICRhux2 W1lZWW5urlD+BRdcsGDBwlP8AbYBm050XPDevXu///3/TO/7/PobrJdffqW/v9/s hSD9GXIUlt4M582bm94/mdL/m7Zs2Z1TpkwxeyEYrRE/+LB27ZPbt2+XWJIuHA57 PB4GICETUICRnurr64uKpG4DlpSUvPLK707xByjAySA7O3vSpElyT0Ved91169ev S8s33LFYbOHCG84991yzF4JMMfqBwLq//OUvjz22Ji036uv1/itf+WpTU5PZC4Ex Bm//er3h4f+E8frrrxsY3bMSpxAIdO/fzwAkZAQKMNJTdXW1xSI4DOnPf373FM1K VdV4PC50dQyL/n9TaWmp0ANju3bt+tGPftjT0yMRbqJZs85aunSp2atABgmFQp0O R2DUE7aWL1/e2ZluE1zy8/Nvu+32xsZGsxcCY4z49q/0Yw5ut6ejI92+fYATogAj PUkPQ2pqar744otP9llN03h2NKmMHz++pKREKDzNdgVnZ2c/99wGuR0EwAkNnojr co1yzpb+16+55uq0mVjGjt+05Dh89lV/KDTcv/jqq6+2tGySWFIWA5CQYdLkRQI4 3rRpUwsKCoTCGxsbn376mZN9tre3N/3uCqaBvLy84uJiiWSn03n55Zc7HJ2p/s5b f8N9//0PNDQ0mL0QZBxDdgLrOjs777xzWaqfCK23kfJy6x133GGz2cxeC4w0mmPP b7/9NrlTCfv6+vbs2SsUDiSb1H6vBpyC6DCkrMFh9Cc9iCIcDntHN9UDcvLz84uK iiSS161bd8MNpzodLcnFYrGf/ex//v3f/93shSBDORTF5/UOjPrxmTfeeGPDhudS dzOw3n6vvPIX559/vtkLgfFGM/i6ublJ7lEjBiAho1CAkbakhyGtXr3m7LPPPtkf 4BysJCdUgyORyJw5c7Zt25pyT0TrX9Jf/vKXm5vnmL0QZK6hm2MBTYvFYqOMevzx x//yl/dS7omMaDT6T//0+fnz56f6HWyckP4Vrqiq5vWO4JSQQ4cO3XffvQxAAgyR Yq8NwLDMmjVz3LhxQuFf/OKXli1bdrLPUoBTgtDeYKfTecUVVxw4sD9V7kHp78bO Pff/LFiwwOyFINMZ9SC07uGHH969e1eqdGC981dX19x8880885zGHIoS8PuDfX0j +LurVq3au3eP4UsaMjAw8MEH6T9GGzgiNV4YgJGZMmVKcbHIw65Zh28hvvnmWyf7 rMvlGv1NDCRGbm5ucXGx4fds//CHPzQ1NXV3B5L8Lbjefj/5yU/edNPNZi8EGDSa knCMBx98YP/+/cn/DThhwoSrr75G/zY0ey2QpX9tu7q6Rvbe4Oqr58u9qfD7AwcO HBAKB5JQUr8qAKNUXV1lsViEwqPR6BtvvFlYeOJpwxwEnXKys7P1/zfz8vKMjV23 bt0tt9wsN7lxlPR3VP/0T5+/9tprzV4I8KGhx0T7entHcEzu8R555JEPPtiRtM9i 5OTk/Pd//5TtvplgNLO+gsHg9ddfJzkAyd3R0SkUDiQhCjDSmd1us1qtcm99fvCD y3/2s5+d8FN9fX3d3d1C14WogoKCk/1cY8RWrlx53333RqNRY2NHSV/PD3/4o+99 73tmLwT4G0MduLenZ/QHYulefvnlzZtbkm1bvv7CdOml/zF79myzF4IEcSiKW1VH 9iqwcePG119/zfAlDYnFYqqqKgr7tpBBKMBIc1OnNk6YMEEovKKictOmEw/l4yDo VJeTkzNx4sTx48cbmLlq1aoHHnigvz+UDM9kxuPxW25Zcs4555i9EOAEjO3Ae/bs eeihFcnQgfXvu3Hjxl1yySUXXUT1zSCDm9sVxe/zjeyvL168SG62Ym9v7969+4TC geRk/pswQFRtbU1paalQeCwWe++9v5zss5yDlR70Dqw3YQMPZX3++eeXLVvq8XjM eixT/7qdMWPGkiW35ufnm7IA4EwMdeBgX9/IZsYco7+///7773c4Ok38vispKfnR j/6/8847z5QFwER6+/W4XJFIZGR/vanpKrmDwb1eb1tbu1A4kJwowEhzFRUVNpvU MCTdbbfd/i//8i8n/BQFOM0UFBRMmDDBqHfPu3btWrhwYeJ3J44ZM+a6664/99xz E3lRYGSGOnB/KKTX4BFMjjne+++/v3r1own+potGo9OmTf/FL37R2NiYyOsiSYzy 9u9777335JNPGLuko3V1qU4nA5CQWSjASH8zZ84w9kHWo51zzidWrVp1wk9xEHS6 ys/P18uwIT+P179CVq5c+cQTj7vd7gQ8n/md73znBz+4PGkPBAKOp5cHr6bp/+zp 7o6O9Aba0fRvuk2bNr722mvS3wh67500adIFF3xz9uzZfNNlMr39+rzeET/Mf889 yzs6Ooxd0hH9/f07d+4SCgeSFgUY6W/KlMnFxcVC4Xpp+dOf3jnhpzgIOu2NGzdO L8OGHBzd1dW1fPny3/3ud36/ZmwTjsfjele/6KLZl156qYGxQCLpBdjZ1RUKBg15 HHrIli1bXnnl5azDj0UYlZl1uPcWFhZ95jOf+f73v19eXm5gMlLR0JeuNoozQebO nSN3bITf7z9w4KBQOJC0KMBIf1VVlXLvQvR28fzzL9TU1Bz/qd7eXrlTK5Bsxo8f r5fh0T9roH/ZrFq1qqWlxel06F9dI37fM9R7P/7xc/R34Tx4iTRw5Faw/h/WSDhs VGxHR4f+7bZ/f+sov930f1qt1i996Z8vuuiigoICo5aHVOdQFM3nG/FML7fbffvt t8kVYJfL1dnpEAoHkhYFGOnPbrdZLOU5OVLPl15wwTcXLFhw/McHBgZ8I93zg5Sm N8/xh+Xm5o4mx+12Pfvsuldf/X1bW1uP/qY/EjnFzWH9LXgsFtNLeE1N7TnnfPy8 875SV1c3mqsDSejIruBQMGjsHhNFUf70p/+3d+8+l0sNh8P699opWkc0GtU/O3Fi YVVV5Wc+c+7553+ttLTMwMUgPXx4+1d/JzDSHexr167dvv1dY1d1RCQS1V9lGICE DEQBRkZoaKg3fLLrESUlJa+88rsTfopzsJB1eODnuHHjcg/Tu/Fofpavv1n561/f 9/u13t6+3t7eYDCof2FXH1ZXV9vT02vgsoHkNHQruL9/sAX3B4OGHI51PD1fVVXP IHcwGNK/hfPyxh8+E75wSn19aWlpcVFRZWWlxKWRNgbPvtK00Ty3f/311w0MDBi4 pKN1d3e3tu4XCgeSGQUYGaGmprqsTOrH89Fo9E9/ekd/e3T8pyjAOBm9Bo89TK/H Q7/QP6L/esxhR47MObotD73Rj59EOBwOGrc9EkhyH9XgYFCvwkI1OOuo79PxegfO z8/632/J0pISQ/b/I10NPa2g+XzxkT6qEIlE5s+fJ3c+osfjaW+XOl4LSGYUYGQE u91us1nldtH88pe/vPTS/zj+4xRgAJAzVIOz4nG9BvcFg3phGHHZ0A3+5Omwocab qzfe8eNpvBgZh6J0BwJ9vSN/MOd3v3tly5YtBi7paPF4vKtLVRRFKB9IZhRgZIpp 06YVFOQLhU+ePGXdunXHf9zr9YaNO6wFAHBCHzbhrMH39fqvB8JhvQnHD++MH3pw YvAf//uHx/yt3NxcvdkO/oT0b39ISuPFaOgF2KWqsWh0xAm33rpE7iSRvr7gnj17 hMKBJEcBRqaoq6udNGmSULj+Lmv79veO/3h3d3dfX5/QRQEAx/uoDJ8Zii4Mp38R OhwOv98/mpDm5ia555/1an3oUJtQOJDkKMDIFJWVFVarVS7//vsf+Md//MdjPqi/ BI7y9Q8AAKQWh6K4Xa5oJDLihD179jz88CoDl3QMVVUdDqdcPpDMKMDIILNmzTzh UVWGOPfcc++9975jPhiNRt1ut9AVAQBAshm8/et0+ofzGMLxHnzwgQMHDhi1pGMM DAx88MFOoXAg+VGAkUGmTJlSXFwkFK5X67ff/uPxH+ccLAAAModDUbxu9yhPAJk3 b65R6zme3x+Qa9dA8qMAI4NUV1dZLBah8Fgs9uKLL5WXlx/zcQowAAAZIhQKORVF G93hVX6//6abFh+Zh2c4t9vd0dEpFA4kPwowMojdbtMLqtyREt/97oXz588/5oMu lys2irEcAAAgVTgUxef1DvT3jybkt7995k9/+pNRSzpGNBrV35koCj+dR+aiACOz NDY2TJw4USi8tLTspZdeOuaDmqb1j+6FEAAAJL/B279dXZrXO8qcBQsW9PeHDFnS 8Xp6evbtaxUKB1ICBRiZpaampqysVCg8Go3++c/v5uTkHP3B3t5e/cVG6IoAACBJ OBTF7/eHRjf+UH8vMW/eXLmn1Tweb3t7u1A4kBIowMgsFRV2q9U6ZozUV35z85zZ s2cf/ZGBgQG5QfYAACAZhEIhRVU1rzcej48m57XXXtu0aaNRqzqGvjZVVZ1ORSgf SAkUYGSc6dOn5efnC4U3NjY+/fQzR39k6MVG6HIAACAZOBSlOxDo6+0dZc7tt9/m 8XgMWdLxgsHg7t17hMKBVEEBRsapq6ubNKlEKFyvu9u3v3fMBzkIGgCA9KYXYJeq xqLRUeY0NzfJPf/s82mHDh0SCgdSBQUYGaeystJqPXZYkVH0Arxq1cOf+MQnjv4g BRgAgDQWCoUcTqdf00aZ09raumLFg3IbtVTV5XA4hMKBVEEBRsax221lZWW5ublC +Z/73Ofuvnv50R9xu93RUf9IGAAAJCeHonjc7kg4PMqchx5aoXdgQ5Z0vHA47PF4 GIAEUICRierrpxQVFQmFjx8//g9/ePvojzAJCQCAdDV4+1dR/EYceDl//rxRnqF1 CoFAYP/+A0LhQAqhACMTVVdXWSwWofBYLPbyy6+UlZUd+QiTkAAASFd6+/V5vQOj /kl3d3f3okU3ZmdnG7Kq47nd7o6OTqFwIIVQgJGJ7Hab1WqVe425+OKLm5qaj/y2 v79fG/W+IAAAkGxCoZCzq0vzekcftX79urfffvv0f25EYrGYqqo8/wxkUYCRsaZO bZwwYYJQuMVi2bbtxSO/1V91XC6X0LUAAIBZBh9+1rRQMDj6qBtuWBg0IueEent7 9+7dJxQOpBYKMDJUbW1NaWmpUHg0Gt2+/b2j7zBzEDQAAGnmw9u/Pl/WqDfuxmKx OXOac3JyDFnY8bxeb1tbu1A4kFoowMhQFRV2q9UqN2ngmmuu/fa3v33ktxRgAADS jENRAn5/sK9v9FFvvfXWhg3PjT7nhOLxuKqqTqcilA+kFgowMteMGdPz8vKEwqdP n/7kk2uP/NblcsViMaFrAQCAxNMLsKury5DX96VL75DbLRUKhXbt2i0UDqQcCjAy 1+TJdSUlJULh8XjW9u3bj/zW5/MNDAwIXQsAACSY3io7HY6A329IWlNTU07OWEOi jqdp2sGDh4TCgZRDAUbmqqystFrLhcLj8fijjz76sY/9/dBve3p6ent7ha4FAAAS zKEoHrc7Eg6PPurgwYP333+f3LYsVXU5HA6hcCDlUICRuex2m8VikTtw4gtf+MKd d9419OtQKOQ36IfEAADAXPrLusPp9Bs043DVqpV79+41JOp4kUjE7XYzAAk4ggKM jFZfX19UVCgUnpeX99Zbfxj6tf7y4/F4hC4EAAASyaEoPq93oL/fkLSrr54vd1BI INC9f/9+oXAgFVGAkdGqq6ssFotQuP5i9vLLr5SVlQ39loOgAQBIAx9OP/J6DUnr 7u5etOjGo0cnGsvtdnd0dAqFA6mIAoyMVlFhLy8vl3vVufjii5uamod+TQEGACAN OBRF07T+YNCQtPXr17399tuGRB0vFou5XC4GIAFHowAj002d2jhhwgShcIvFsm3b i0O/pgADAJDqPrz96/MNznswwg03LAwa1KWP19vbu3fvPqFwIEVRgJHpamtrSktL hcIjkch77/1l6A6zx+PRfyt0IQAAkAAORQn4/cG+PkPSYrHYnDnNcudxer3etrZ2 oXAgRVGAkekqKipsNqtc/rx58y+88EL9F36/PxQKyV0IAABI0wuwW1Wj0aghaW+8 8cYLLzxvSNQJdXWpTqdTLh9IRRRgIGvGjOl5eXlC4dOmTVu79qmsw48h9fT0CF0F AABIG5x+5HAYONfwjjtud7vdRqUdQ1/trl27hcKB1EUBBrImT64rKSkRCo/H49u3 v6f/YmBgwOfzCV0FAABIcyiK1+0Oh8NGBTY3N40dO9aotGNomnbw4CGhcCB1UYCB rMrKSqu1XChcL8CrVj38iU98YugkRqGrAAAAUYO3fxXFb9zPsltbW1eseHDMGKl3 46rqcjgcQuFA6qIAA1l2u81iscgdQfG5z33u7ruXZ3EQNAAAKUtvvz6vd6C/36jA hx5aoXdgo9KOEYlE3G63ovDGAzgWBRgYVF9fX1RUKBQ+btz4oRF/FGAAAFLRh9OP vF4DM+fPnxc3aJbS8QKB7v379wuFAymNAgwMqq6uslgsQuGxWOyll16yWMpVVZV7 qQMAAEIGH372+0MGTT/KGiyogcWLFw0NSpTgdrs7OjqFwoGURgEGBtntNqvVKvc6 dOGF35s3b57X6zXw5AwAAJAYegF2qWrMoOlHut/+9rd/+tP/MyrtGLFYTFVVnn8G TogCDHxo6tTGCRMmCIWXlpa99NJLgUAgGAwKXQIAAEgIhUKdDkfAuOlHuoULF+ix BgYerbe3d+/efULhQKqjAAMfqq2tKS0tFQqPRCLvvrt9YGCgu7tb6BIAAECCQ1E8 bnfEuGe4otHo3Llz5E7f9Hq9bW3tQuFAqqMAAx+qqLBbrVa5aQTNzXO+/e1vMwoY AIAUYvj0I91rr722adNGAwOPFo/HVVV1OhWhfCDVUYCBj8yYMT0vL08ovLGxce3a pxgFDABACjF8+pHu9ttv83g8BgYeTW/su3btFgoH0gAFGPjI5Ml1JSUlQuHxePyN N97s6ekRygcAAMYamn7k9/mMHeLQ3Nw0duxYAwOPpmnawYOHhMKBNEABBj5SWVlp tZbL5d96620f+9jH5PIBAICBDJ9+pGttbX3ooRUGBh5DVV0Oh0MuH0h1FGDgI1VV VeXlUtOAdfX1Dffee69cPgAAMJDh0490S5cudblUAwOP4XK5OzuZAAycFAUY+Ij0 NGA9edOmFqFwAABgoMHjrxwOv6HTj3Rz586RO3GTCcDAaVGAgb8hOg04Ho/fddev Z8yYIZQPAACM4lAUr9sdNm76ke7QoUP33XevXAFmAjBwWhRg4G9IPwX9sY/9/a23 3iqXDwAARk9i+pHu/vvv0zuwsZlH4/ln4LQowMDfkH4KWrd58xa5cAAAMHp6+9V8 vv5QyNjYOXOa5d5j8PwzcCYowMCxpk2bWlBQIBQej8dvv/2Os88+WygfAACMktD0 o9bW1hUrHpR7/rmvr2/Pnr1C4UDaoAADx6qurrJYBJ+CPuuss+64Y6lcPgAAGA2H ogT8/qCh049099xzT0dHu7GZR3O73R0dPP8MnAYFGDiW9FPQsVhs69ZtQuEAAGCU 9ALsdrmikYixsTz/DCQDCjBwAtOmTSsoyJfL/8UvfvnVr35VLh8AAIzM4PFXTqdf 04yN/eMf/7hu3bPGZh6try+4Z88euXwgbVCAgROorKy0Wsvl8j/72c9de+21cvkA AGBkBqcfeTzhgQFjYx955JFdu3Yam3k0VXU5HA65fCBtUICBE7DbbRaLJScnRyhf L9irVj0sFA4AAEZm6Pgrzes1PHnJkls0o+8qHxGJRNxuN88/A2eCAgyc2JQpU4qL i4TC4/H4li1bhcIBAMDIDM7+1bRQMGh4cnNz09ixYw2PHeL3Bw4cOCAUDqQZCjBw YpWVFVarVShcL8CPPrraZrMJ5QMAgBHQC7BLVWPRqLGxPp9vyZJb5AYgqarqcDiF woE0QwEGTurss/9O7oe13/nOd3/4wx8KhQMAgOEKhUKdDkfA7zc8+YUXXnjjjdcN jx0SjUb/+tf3hcKB9EMBBk6qsbFh4sSJQuFVVdUrV64UCgcAAMM1ePyV2x0Ohw1P vvXWJT6fz/DYIT09Pfv2tQqFA+mHAgycVFVVVXm5RS5/8+YtcuEAAODMDU4/UhS/ TE0VnQDscrk7OzuFwoH0QwEGTuXv//5jQjt24vH4k0+unTRpkkQ4AAAYFr39aj5f fyhkeHJ3d/fixYvk3k68995fJJKBdEUBBk5lxozpeXl5QuGzZ1982WWXCYUDAIAz NDT9yO/z6X3S8PCWlpZXX/294bFD9JXv2rVbKBxISxRg4FTq6mrlbtLW1dU98MCD QuEAAOAMORSlOxDo6+2VCL/99ts8Ho9Ectbh86UPHWoTCgfSEgUYOJWKigqbTWoY 0pgxY1paNguFAwCAM6QXYI/bHRE4/ipLeANwV5fqdDIACRgGCjBwGmedNSs3N1ci ORaLPfPMb4uKiiTCAQDAmRA9/qqvr3fhwoVCBTgcDu/Y8YFEMpDGKMDAaTQ01BcW FgqFX3rpf1xyySVC4QAA4LTkjr/Sbdu27eWXX5JIzjp8vFZr636hcCBdUYCB06it rSktLRUKnzKl/r777hMKBwAApzZ0/JVegLMEjr/SLV261OVSJZJ1Xq+3ra1dKBxI VxRg4DREtwFnZ4/dtGmTUDgAADg10eOvdHPnzhEagJTFBmBgRCjAwGnY7TaLxZKT kyMRHovF1q9/rqCgQCIcAACcmujxV6FQ6PrrrxPaAByJRNxut6J0SYQDaYwCDJxe Q0NDYeFEofAf/ODyCy+8UCgcAACcjOjxV7pXXnl569atQuHd3T2tra1C4UAaowAD p8c2YAAA0o/o8Ve6ZcuWqarUHVo2AAMjQwEGTq+yssJqldoGHI/Ht2yR+vEwAAA4 IenjryKRyLx5c4W2UOlUVXU42AAMDBsFGDg90W3AegFet24924ABAEgk6eOvXnvt tU2bNgqFswEYGDEKMHBGGhsbJk6U2gb8/e//4Hvf+55QOAAAOJ5egN0uVzQSEcpf vHhRT0+PULievG8fG4CBkaAAA2ektra2tHSSUHhZmeWxxx4TCgcAAMeQPv5K19R0 ldzzz16vr62tTSgcSG8UYOCMiG4Djkaj27a9KBQOAACOMXj8lab1B4NC+for+9VX z5ebAMwGYGDEKMDAGZHeBrx+/XP5+fkS4QAA4Bh6AVYVJS5z/JXu7bf/sH79eqFw NgADo0EBBs6U6Dbg88//15///OdC4QAA4IhQKNTpcAT8frlL3HLLzX6xfDYAA6NB AQbO1PTp0+Ru0ubmjnv++eeFwgEAwBEORfG43ZFwWO4Szc1NY8eOFQr3+XyHDrEB GBghCjBwphoa6gsLC4XCc3JyXnhBalgCAAAY8uH4X69X7hKxWGzu3DlCBTgajbpc Lp5/BkaMAgycqerqaoulTChcf7F88sknS0ul8gEAQNbQ8Vc+X38oJHeJv/zlL088 8bhQeG9v7969+4TCgUxAAQbOlN1ut1rLs7OzhfK/8Y1v/OQn/y0UDgAAsg4XYFdX VywWk7vEqlUr9+7dKxTO88/AKFGAgWGYOrVxwoQJQuGlpaWPP/6EUDgAABgc/+t0 +jVN9CrXXXdtWGyDscvl6ux0CIUDmYACDAxDbW2NXlOFwpkGDACAKIeieD2e8MCA 6FWamq4SmpsYi8VUVWUDMDAaFGBgGCoq7DabTS7/2muv++xnPyuXDwBAxkrA8Ve6 HTt2rFmzWii8r69vzx6ph6uBDEEBBoZnxozpeXl5QuHnnHPOzTffIhQOAEAmcyiK 3+8P9fWJXmXVqlV79+4RCtc07eDBQ0LhQIagAAPDM3lyXUlJiVD4uHHjN2zYIBQO AEAmGzz+SlVj0ajoVa6//roBsUes2QAMjB4FGBieyspKq7VcKDwajW7Y8Hx+fr5Q PgAAmWnw+CtF8ft80hdiAzCQ5CjAwPDY7baysrLc3Fyh/P/6ryu++c1vCoUDAJCZ 9Pbr83jk7s0O+eCDD1avflQovK8vuGeP1MPVQOagAAPDVl9fX1RUKBQ+c+bMZcvu FAoHACADhUIhRVV9Xm9WPC56ITYAA8mPAgwMW3V1tcVSJhSem5v7/PMvCIUDAJCB HIrSHQj09fZKX0h4A7C7s7NTKBzIHBRgYNjsdrvNZh0zRuTbJxqNbtrUIveINQAA mUYvwG5VjQoff5UluQE4Ho93dXWxARgYPQowMBLTpk0rKJA6qurKK6/82tfOFwoH ACCjJOz4q/fff/+xx9YIhQeDwd272QAMGIACDIxEXV3dpElSw5CYBgwAgFESc/yV 7qGHVrS2tgqFa5r/4MGDQuFARqEAAyNRVVVZXi41DKmgoODZZ9cJhQMAkDmGjr/S vN648PFXumuuuSYajQiFswEYMAoFGBgJu92mF+CxY8dKhEej0W3bXpRIBgAgoyTs +KtYLDZ37hyhNwaHNwCriqJIhAOZhgIMjNDUqY0TJkwQCr/11ts+9rGPCYUDAJAh 9ALsUtWY/PFX77zzzjPPPC0UzgZgwEAUYGCE6upqJ02aJBT+z//85ebmZqFwAAAy QSgUcnZ1aV5vAq513333tbVJDellAzBgIAowMEKVlZVWq9Q2YIulfM0aqZMkAQDI BAk7/ko3f/78eDwmFM4GYMBAFGBghOx2m9Vqzc7OlgiPxWJbt26TSAYAIBMk8vZv ODxw9dVXy20AVlXV6WQDMGAMCjAwctOmTS0oKJBI1l/tHn10tc1mkwgHACDtORQl EAgE5Y+/0r366qstLZuEwtkADBiLAgyM3OTJdSUlUtOAv/Od7/7whz8UCgcAIL0l 7Pgr3Z13Luvq6hIK1zTt4EGp3cVABqIAAyNXVVVVXm4RC69euXKlUDgAAGksFArp Bdjv8yXmcnPnzhkzRupNtcvl6ux0CIUDGYgCDIyc3W632axCr3l6bEvLZolkAADS m95+vR5POCHHX3V3dy9adKPcmSCqqiqK1O1lIANRgIFRmTFjel5enkSy/pq3du1T cpOWAABIS4k8/kq3cePG119/TSi8r69vz569QuFAZqIAA6MyZcqU4uIiofDZsy++ 7LLLhMIBAEhLgw8/+/2hvr7EXG7JkiWaJvWstc/nO3SoTSgcyEwUYGBUamqqy8rK hMJra2sffHCFUDgAAGlp8Pirrq5YTGoq7zGamppyckQGIOlU1eVwsAEYMBIFGBiV iooKm80ql7958xa5cAAA0szg8VcOh9/vT8zlFEW5885lQqeBRKNRl8vFBmDAWBRg YLTOOmtWbm6uRDLTgAEAGBaHonjc7kg4nJjLPfXUU++++2eh8J6enn37WoXCgYxF AQZGq6GhvrCwUCj8ggsuuOKKnwiFAwCQThI8/Uh344039IltNvZ6vW1t7ULhQMai AAOjVVtbU1paKhReXl6+evUaoXAAANKJ3n41n68/FErYFZuarsrJyREKV1XV4XAK hQMZiwIMjFZlZYXVKrUNOBqNbtv2olA4AABpY2j6kd/ni8fjibninj17Hn54lVB4 OBz2eDxsAAYMRwEGRstut1ksFrkfAN922+1nn322UDgAAOnBoSiBQCDY25uwK65a tWrv3j1C4d3d3a2t+4XCgUxGAQYM0NDQUFg4USj8//yfz1533XVC4QAApAe9ALtd rmgkkrArXnPNNdGo1OU8Hk97e4dQOJDJKMCAAUS3ARcUFDz77DqhcAAA0sDg8VdO p1/TEnbFaDQ6d+4cuee/urq6nE5FKBzIZBRgwACi24AjkUhLy2ahSUsAAKQBh6L4 vN6B/v6EXfHNN998/vkNQuH9/f07d+4SCgcyHAUYMIbcNGDdFVf85IILLhAKBwAg pQ0df6X5fFmJOv5K9+tf3+V0Sh3R7PcHDhw4IBQOZDgKMGCM+vr6oiKpacD19Q33 3nuvUDgAACltcPavpoWCwURedO7cOWPGSL2RdrvdHR2dQuFAhqMAA8aorq62WMrk 8jdv3iIXDgBA6tILsEtVY9Fowq7Y3d29aNGN2dnZEuHxeLyrS1UUNgADIijAgDEq KuxWq1Xoh8H6a+GqVQ9XVVVJhAMAkLpCoVCnwxHw+xN50Y0bN77++mtC4cFgcPdu qelKACjAgGFmzJiel5cnFP6Vr3z1l7/8pVA4AAApyqEoHrc7Eg4n8qJLltyiiZ04 rScfPHhIKBwABRgwzOTJk0tKioXCi4tL1q5dKxQOAEAqGpx+pCh+ny/B121ubho7 dqxQuMvl6ux0CIUDoAADhqmqqiovtwiFR6PRLVu2Cm03AgAgFentV/P5+kOhRF60 o6Nj+fK7hTY96S/3egFWlC6JcABZFGDAQHa7rby8XO5HwlddddW//Mt5QuEAAKSW oelHfp8vnsDpR7rHHlvz/vvvC4X39vbu3btPKBxAFgUYMNa0aVMLCgqEwqPR6LZt LwqFAwCQWhyKEvD7g319Cb5uU9NVOTk5QuF+v//AgYNC4QCyKMCAsWpra0pLS4XC 4/H4unXr5Qo2AAApRC/AbpcrGokk8qLBYHDhwgVyE4BVVXU4nELhALIowICxKioq bDarXP4PfnD5hRdeKJcPAEBKGDz+yun0ix3FfDJr1qzesWOHUHgsFtMLMBuAAVEU YMBgf/d3Z8k9GdXQ0HjPPfcIhQMAkCociuL1eMIDAwm+7vz58+S2HAeDod27dwuF AxhCAQYM1tDQUFg4USg8O3vspk2bhMIBAEgJQ8dfaV5v4i8tOgDJ59MOHWICMCCL AgwYrLq6ymKRGoYUi8XWr3+ObcAAgEw2OPtX00LBYIKv6/f7b7nlZrn8rq4up1OR yweQRQEGDGe323Ryx2OwDRgAkMmGbv8GNC0WiyX40qtXr/7gA6kNwNFo9K9/lZqu BOAICjBgvJkzZ4wfP14onG3AAIBM5lCU7kCgr7c38ZdetmyZqkqdUNXX17dnz16h cABHUIAB402ZMrm4uFgonG3AAIBMphdgj9sdCYcTf+m5c+fIPeHl9Xrb2tqFwgEc QQEGjFdZWWG1Sg1DisVizzzz26KiIqF8AACS1uD0I0Xx+3yJv3RfX+/ChQuzs7Ml wuPxeFeXqihsAAbEUYABEVOnNk6YMEEo/NJL/+OSSy4RCgcAIGnp7dfn9Q709yf+ 0tu2bXv55ZeEwiORyPvvS+0uBnA0CjAgora2prS0VCh88uTJ99//gFA4AADJaej4 K7/PJzeJ9xTuuON2t9stFN7b27t37z6hcABHowADIkSfgh4zZkxLy2ahcAAAkpND UQJ+f7Cvz5Srz5nTLPT8s87j8bS3dwiFAzgaBRgQYbfbLBZLTk6ORHgsFlu79qlJ kyZJhAMAkJz0AuxW1Wg0mvhLd3d3L1p0o+QG4C5FkTpfGsDRKMCAlMbGhokTJwqF z5598WWXXSYUDgBAshk8/srp9GuaKVdvaWl59dXfC4UHg6Hdu3cLhQM4BgUYkCK6 Dbi6uvqhh1YKhQMAkGwciuL1eMIDA6Zc/dZbl/jEjp5mABKQSBRgQIroNmDd5s1b 5MIBAEgeQ8dfaV6vWQsQ3QCsqqrD4RQKB3AMCjAgRXQbcDweX7PmsfLycolwAACS yuDsX00LBYOmXF3TtFtuuXnMGJG3zZFIxO12swEYSBgKMCCooaGhsFBqG/B3vvOd H/7wR0LhAAAkiaHbvwFNi8VipizghReef+ONN4TCu7t7WltbhcIBHI8CDAgS3QZc VVW9ciXbgAEAac6hKN2BQF9vr1kLWLJkiaaxARhIExRgQFBFRYXNJrUNOB7P2rKF bcAAgDSnF2CP2x0Jh81aQHNz89ixUhuAu7pUp5MNwEDiUIABWWedNSs3N1ciOR6P P/LIo3a7XSIcAIBkMDj9SFH8Yicwn5bH47nttluFNgCHw+EdOz6QSAZwMhRgQFZD Q31hYaFQ+De+8Y2f/OS/hcIBADCd3n59Xu9Af79ZC1i3bt0f//i2UHh3d3dr636h cAAnRAEGZNXU1JSVSW0Dttvtv/nNI0LhAACYa+j4K7/PF4/HzVrDzTffFAgEhMI9 Hm97OxuAgYSiAAOyRLcBx2KxrVu3CYUDAGCuwYef/f5QX5+Ja2hubho7dqxQOBuA gcSjAAPiRLcBP/jgirq6OolwAADMpRdgt6pGo1GzFqAoyp13LmMDMJBOKMCAONFt wOef/68///nPhcIBADDL4PFXDoff7zdxDc888/Q777wjFM4GYMAUFGBAXE1NdVlZ mVC4xVK+Zs0aoXAAAMziUBSvxxMeGDBxDYsWLert7REK93g87e0dQuEAToYCDIhj GzAAAMMyePyVomjmTT8a0tR0VU5OjlA4G4ABU1CAgUSYNWvmuHHjhMLvuuuu6dNn CIUDAJB4jsPttz8UMnENbW1t9913r1D4wMDABx/sFAoHcAoUYCAR6uvri4qktgF/ 8Ytfmjt3rlA4AAAJ9uH0I02Lx2ImLuOxx9a8//77QuGBQPf+/WwABkxAAQYSQXQb cHFxydq1a4XCAQBIMIeiBAKBYG+vuctYuHBhKBQUCmcDMGAWCjCQCBUVdpvNJhQe iURefPEloXAAABJML8Ael0t/dTN3GcIbgLucTkUoHMApUICBBJk5c8b48eOFwhcv vumTn/ykUDgAAAkzOP3I6fRrmrnL2L17929+87BQeH9//86du4TCAZwaBRhIkPr6 KUVFRULhn/nMuQsWLBAKBwAgYRyK4vN6B/r7zV3Gww8/vGfPbqHwQCCwf/8BoXAA p0YBBhKkurraYpHaBlxQMOHZZ58VCgcAIDE+PP7K54vH4+au5Nprr41EwkLhbren o4MNwIA5KMBAglRU2K1W65gxIt90kUhk69Zt2dnZEuEAACSGQ1H8fn+or8/cZcRi sTlzmoU2AOvdXlVVNgADZqEAA4kzY8b0vLw8ofB58+Z/4QtfEAoHACAB9ALsUtVY NGruMrZv37527ZNC4aFQaNcuqYerAZwWBRhInClTJhcXFwuFn3POOTfffItQOAAA 0gaPv3I4/H6/2QvJevDBBw4ckNqjq/8LHjhwUCgcwGlRgIHEqa6uslgsQuHjx+c9 99xzQuEAAEhzKIrX4wkPDJi9kKyrr746FpO6C+12uzs6OoXCAZwWBRhIHLvdbrPJ bQOOtrS05ObmSoQDACBq8Pavovh9PrMXMnisxrx583JyxkqEx+Pxri5VUdgADJiG Agwk1PTp0/Lz84XCf/az//n6178uFA4AgBy9/Wo+X38oZPZCst56660NG6SeqAoG g7t37xEKB3AmKMBAQk2ePLmkRGob8KxZs5YuXSYUDgCAkA+nH2laPBYzey1Zy5cv 7+yUmlGkaf6DBw8KhQM4ExRgIKGqqqrKy6W2Aefk5LzwwkahcAAAhDgUJRAIBHt7 zV7IoHnz5sqFu1zuzk42AANmogADCWW326xWq9DA3mg0umHD83KPWAMAIEEvwB6X KxKJmL2QrP7+/muvvWbsWJENwLFYTFVVRemSCAdwhijAQKJNmza1oKBAKPwHP7j8 wgsvFAoHAMBwg8dfOZ1+TTN7IYNeeeXlrVu3CoX39fXt2bNXKBzAGaIAA4k2eXJd SUmJUHh9fcO9994rFA4AgOEciuLzegf6+81eyKClS5e6XKpQuKZpBw8eEgoHcIYo wECiVVVVlpeXC4WPGTOmpWWzUDgAAMYaOv5K8/my4nGz1zJozpxmoW1KWYMbgF2d nQ6hcABniAIMJJroNuBYLPbkk0+WlpZJhAMAYKzB2b+aFgoGzV7IoEAgsHjxIrkX aDYAA8mAAgyYYOrUqRMmSG0D/u53L7z88suFwgEAMJBegF2qGotGzV7IoI0bN77+ +mtC4b29fXv3sgEYMB8FGDBBXV3tpEmThMKrqqpXrlwpFA4AgFFCoVCnwxHw+81e yIeWLFmiaT6hcJ/Pd+hQm1A4gDNHAQZMUFlZabVKbQOOxeJyJ1gCAGAUh6J43e5w OGz2Qj7U1NSUkyMyAEmnqi6Hgw3AgPkowIAJ7HZbeXm50JjBeDz+0EMra2pqJMIB ADDE4PQjRfH7pO64DpeqqkuX3jFmjMh742g06nK52AAMJAMKMGCOxsbGiRMnCIWf f/6//vznPxcKBwBg9PT2q/l8/aGQ2Qv50DPPPP3OO+8Ihff09O7bt08oHMCwUIAB c9TW1pSWlgqFWyzla9asEQoHAGCUhqYf+TUtHouZvZYPLVq0qLe3Ryjc6/W2tbUL hQMYFgowYI7Kygqr1SoUHo1Gt217USgcAIBRcihKIBAI9vaavZCPNDVdlZOTIxSu qqrD4RQKBzAsFGDAHHa7raysLDc3Vyh/6dJls2bNEgoHAGA09ALsdrmikYjZC/nQ wYMHH3jgfqHwcDjs8XjYAAwkCQowYJqGhvrCwkKh8M9//gvz588XCgcAYMQGj79y Ov2aZvZCPrJmzeodO3YIhXd3d7e27hcKBzBcFGDANDU1NWVlUtuACwuLnn76aaFw AABGzKEoPq93oL/f7IV8ZMGCBf39UsdxeTze9nY2AAPJggIMmKaiosJmYxswACCD DB1/pfl8WfG42Wv5iOgG4K4u1elkAzCQLCjAgJlmzZo5btw4ofDrr19w7rnnCoUD ADACg7N/NS0UDJq9kI/s2LFjzZrVQuEDAwMffLBTKBzACFCAATPV108pKioSCv/U pz61aNFioXAAAEZAL8AuVY1Fo2Yv5CMPPbSitbVVKDwQCOzff0AoHMAIUIABM9XU VJeVlQmF5+Xlr1+/XigcAIDhCoVCnQ5HwO83eyF/45prrolGpc6j9ng87e0dQuEA RoACDJiposJutVrHjBH5ToxGoy0tm+U2NQEAMCwORfG43ZFw2OyFfER/rZw3b+7Y sWMlwuPxuKqqTqciEQ5gZCjAgMlmzJiel5cnFH7llVd+7WvnC4UDAHDmBqcfKYrf 5zN7IX/j7bf/IPe0lP6vvGvXbqFwACNDAQZMNmXK5OLiYqHwWbPOWrp0qVA4AABn Tm+/ms/XH5KaNjQy99yzvKND6hFlv99/4MBBoXAAI0MBBkxWXV1lsViEwnNycl54 YaNQOAAAZ2ho+pHf54sn0/Qj3bx5c+XC3W53R0enXD6AEaAAAyaz2+02m+A24Oee 21BQUCARDgDAGXIoSsDvD/b1mb2Qv6HX8uuuu1ZuA3BXl6oobAAGkgsFGDDf9OnT 8vPzhcIvu+w/Z8+eLRQOAEhjeoUz6uezegF2u1zRiNRhyyPz4osvvvTSi0LhwWBw 9+49QuEARowCDJhv8uS6kpISofC6uskPPPCAUDgAAKc1ePyV0+nXNLMXcqw77rjd 7XYLhWuadvDgIaFwACNGAQbMV1VVWV5eLpe/efMWuXAAQFoy9vavz+MZGBgwJM1A c+Y0Z2dnC4W7XK7OTodQOIARowAD5rPbbVarVeg1WH8H8+ijq202m0Q4AACnNnT8 lebzZSXZ8Vc+n2/JkluEzuCIxWKqqipKl0Q4gNGgAANJYerUxgkTJgiFX3DBBVdc 8ROhcAAATmFw9q+mhYJBsxdyrPXr17399ttC4b29vXv37hMKBzAaFGAgKdTV1U6a NEko3Gq1PvroaqFwAABOQS/Arq6uWCxm9kKOddNNi7u7u4XCfT7foUNtQuEARoMC DCSFyspKq1VqG3AsFt+6datQOAAAJxMKhTodjoDfb/ZCTqC5uUloAJJOVV0OBxuA gWREAQaSgt1us1gsOTk5EuHxePzuu5dPmzZNIhwAgJNxKIrH7Y6Ew2Yv5Fjt7e33 3LNcaANwJBJxu91sAAaSEwUYSBYNDQ2FhROFwr/4xS/NnTtXKBwAgOMNTj9SFL/P Z/ZCTuCxx9a8//77QuHd3T2tra1C4QBGiQIMJIva2prS0lKh8KKi4qeeekooHACA 4+ntV/P5+kMhsxdyAgsWLOjvl1qY1+tta2sXCgcwShRgIFlUVFTYbFah8Gg0um3b i0LhAAAcY2j6kd/niyfZ9KMhohuAu7pUp9MpFA5glCjAQBKZNWvmuHHjhMKvv37B ueeeKxQOAMDRHIoS8PuDfX1mL+QE3n///cceWyMUPjAw8MEHO4XCAYweBRhIIvX1 9UVFhULhn/zkpxYvXiwUDgDA0fQC7Ha5opGI2Qs5gRUrVuzfL7VHNxDo3r9/v1A4 gNGjAANJpKamuqysTCh8/Pi85557TigcAIAjBo+/cjr9mmb2Qk7s6quvjsWiQuEe j6e9vUMoHMDoUYCBJFJRYbdarXJTGVpaNufm5kqEAwBwhENRvB5PeGDA7IWcgP5q OG/eXLm5g6qqOp2KRDgAQ1CAgeQyY8b0vLw8ofCf/vRn//Zv/yYUDgBA1v8ef6V5 vWYv5MTefPPN55/fIBSu/7vv2rVbKByAISjAQHKZMmVycXGxUPi0adN//etfC4UD AJB1+PavX9NCwaDZCzmxX//6Lrkjmv1+/4EDB4XCARiCAgwkl+rqKovFIhQ+duzY jRs3CYUDAJB1uAC7urpisZjZCzmxefPmyoW73e6Ojk65fACjRwEGkovdbrfZpLYB 629Hnn76Gbk7zACADBcKhTodjoDfb/ZCTqynp+fGG2/Izs6WCI/H411dqqKwARhI ahRgIOlMnz4tPz9fKPyii2b/53/+p1A4ACDDORTF43ZHwmGzF3JiLS0tr776e6Hw YDC4e/ceoXAARqEAA0ln8uS6kpISofCqquqVK1cKhQMAMtng9CNF8ft8Zi/kpG69 9VafT+p0Lk3TDh48JBQOwCgUYCDpVFVVlpeXC4XH4/EtW7YKhQMAMpnefjWfrz8U MnshJ9Xc3DR27FihcJfL1dnpEAoHYBQKMJB07HabXoCFXqH1Avzggyvq6uokwgEA GWto+pHf59NfaMxey4kpinLnncuETtmIRqN6AVaULolwAAaiAAPJaOrUxgkTJgiF n3feV371q18JhQMAMpNDUQJ+f7Cvz+yFnNTatWu3b39XKLy3t3fv3n1C4QAMRAEG klFtbW1p6SSh8EmTJj3xxJNC4QCAzKQXYLfLFY1EzF7ISd1www3BoFQ/93p9bW1t QuEADEQBBpJRZWWF1WoVCo9EIi+++JJQOAAgAw0ef+V0+jXN7IWcSlPTVTk5OULh qqo6HE6hcAAGogADychut1ksFrnX6UWLFn/qU58SCgcAZBqHong9nvDAgNkLOald u3Y98shvhMIjkYjb7WYDMJASKMBAkmpoqC8sLBQK//SnP33DDTcKhQMAMsrQ8Vea V2q8kCFWrnxo3z6pPbrd3d2trfuFwgEYiwIMJKmampqyslKh8Ly8/PXr1wuFAwAy yuDsX00LBYNmL+RUrrnmmmhUan+yx+Ntb28XCgdgLAowkKQqKuw2m00oPBKJbN68 Re4RawBA5nA4nS5VjcViZi/kpKLR6Ny5c+Re9bq6upxORSgcgLEowEDymjlzxvjx 44XCf/az//n6178uFA4AyBChUKjT4Qj4/WYv5FTeeuutDRueEwrv7+/fuXOXUDgA w1GAgeQ1ZcqU4uIiofAZM2bceeddQuEAgAzhUBSP2x0Jh81eyKncffevHQ6HULjf Hzhw4IBQOADDUYCB5FVdXWWxWITCs7PHbtq0SSgcAJAJBqcfKYrf5zN7Iacxd+7c MWLved1ud0dHp1Q6AKNRgIHkZbfbbTbrGJkX7Vgs9vTTzxQXF0uEAwAygd5+NZ+v PxQyeyGn0tPTc+ONN2RnZ0uEx+Pxri5VUdgADKQMCjCQ1KZPn5afny8UPnv2xZdd dplQOAAgvQ1NP/L7fHoJNHstp9LS0vLqq78XCg8Gg7t37xEKByCBAgwktcmT60pK SoTCq6qqV65cKRQOAEhvDkUJ+P3Bvj6zF3Iat956q88nNaNY07SDBw8JhQOQQAEG klpVVWV5eblQeDwe37Jlq1A4ACC96QXY7XJFI1LDdY3S3Nw0duxYoXCXy9XZKXW8 FgAJFGAgqdntNr0AC71y6wX4wQdX1NXVSYQDANLY4PFXTqdf08xeyGkoinLnncuE TtOIRqN6AVaULolwAEIowECymzq1ccKECULh5533lV/96ldC4QCAdOVQFK/HEx4Y MHshp7F27drt298VCu/t7d27d59QOAAhFGAg2dXV1U6aNEkovKSk5Mkn1wqFAwDS 0tDxV5pXamOtgRYuXBASO6Ta5/MdOtQmFA5ACAUYSHaVlRVWq1UoPBKJvPjiS0Lh AIC0NDj7V9NCwaDZCzm9pqarcnJyhMJVVXU4nELhAIRQgIFkZ7fbLBaL3Ov39dcv OPfcc4XCAQBpZuj2b0DTYrGY2Ws5jR07dqxZs1ooPBKJuN1uNgADKYcCDKSAhob6 wsJCofBPfvJTixcvFgoHAKQZh6J0BwJ9vb1mL+T0VqxYsX9/q1B4d3d3a+t+oXAA cijAQAqoqakpKysVCh8/Pu+5554TCgcApBm9AHvc7kg4bPZCTu/qq6+OxaJC4R6P t729XSgcgBwKMJACKioqbDapbcDRaHTTppbc3FyhfABA2hicfqQofp/P7IWcXiQS mT9/ntwE4K4u1elkAzCQeijAQGqYOXPG+PHjhcJ//OP/+ta3viUUDgBIG3r79Xm9 A/39Zi/k9F599dWWlk1C4f39/Tt37hIKByCKAgykhilTphQXFwmFNzQ03nPPPULh AID0MHT8ld/ni8fjZq/l9JYtW6aqUidU+f2BAwcOCIUDEEUBBlJDdXWVxWIRCh8z ZkxLy2ahcABAenAoSsDvD/b1mb2QMzJnTnN2drZQuNvt7ujoFAoHIIoCDKQGu91u s1n1pioRHovFnnjiybKyMolwAEB60AuwW1WjUaljpQzk9/tvummxUAGOx+NdXaqi KBLhAKRRgIGUMX36tPz8fKHwb33r//74xz8WCgcApLrB46+cTr+mmb2QM7Jhw4a3 3npTKDwYDO7evUcoHIA0CjCQMiZPrispKREKt9lsjzzyqFA4ACDVORTF6/GEBwbM XsgZuemmm7q7A0LhmqYdPHhIKByANAowkDKqqirLy8uFwmOx+NatW4XCAQApbej4 K83rNXshZ6q5uUluAJLL5ersdAiFA5BGAQZSht1u0wuw3Cv6XXfdNX36DKHwxOvr 6ysoKDB7FQCQDgZn/2paKBg0eyFnpK2t7b777hUKj0ajegFWFKnzpQFIowADqaSx sXHixAlC4Z///Ofnz79aKBwAkKKGbv8GNC0Wi5m9ljOyevXqDz7YIRTe09O7b98+ oXAACUABBlJJbW1NaWmpUHhhYeHTTz8jFA4ASFEORekOBPp6e81eyJm6/vrrBsT2 Knu93ra2dqFwAAlAAQZSSWVlhdVqFQqPRCJbt26Tm5oIAEhFegH2uN2RcNjshZyR WCw2Z05zTk6OUL6qqg6HUygcQAJQgIEUc9ZZs3Jzc4XC58yZ+6UvfUkoHACQcgan HymK3+czeyFn6s9//vPTTz8lFB4Oh3fs+EAoHEBiUICBFFNfX19UVCgU/nd/d/bt t98uFA4ASDl6+/V5vQP9/WYv5Ezde++97e1tQuGBQPf+/fuFwgEkBgUYSDE1NdVl ZWVC4bm5uc8//4JQOAAgtQwdf+X3+eLxuNlrOVPz58+TW63H42lv7xAKB5AYFGAg xVRU2K1W65gxIt+80Wj0uec2MD0IAJB1+PZvwO8P9vWZvZAzpTf26667VmheoN6r VVV1OhWJcAAJQwEGUs+MGdPz8vKEwi+99D8uueQSoXAAQArRC7BbVaPRqNkLOVPb tm17+eWXhML1dr1r126hcAAJQwEGUs+UKZOLi4uFwmtqalaseEgoHACQKgaPv3I6 /Zpm9kKG4bbbbvV6vULhfr//wIGDQuEAEoYCDKSeqqqq8nKLUHg8Ht+yZatQOAAg VTgUxevxhMUG6kpobm4Sev5Z53K5Ozs7hcIBJAwFGEg9drvNarUKDezVC/BDD62s qamRCAcApISh4680sbupElRVXbr0DqEzMmKxmJ6vKF0S4QASiQIMpKRp06bKHVX1 ta+df+WVVwqFAwCSn0NRNE3rDwbNXsgwPPXUU++++2eh8L6+vj179gqFA0gkCjCQ kurqaidNmiQUXlpa+vjjTwiFAwCS3NDt34CmxWIxs9cyDDfeeEOf2IHVPp/v0CGp 8cIAEokCDKSkyspKq7VcKDwajW7b9qJQOAAgyTkUpTsQ6OvtNXshw9PUdFVOTo5Q uKq6HA6HUDiARKIAAynJbrdZLBa5V/obb1z0D//wD0LhAIBkphdgj9sdCYfNXsgw 7Ny589FHHxEKj0QibrebDcBAeqAAA6mqoaGhsHCiUPinP/3pG264USgcAJC0Bqcf KYrf5zN7IcOzcuVD+/btEwrv7u5pbW0VCgeQYBRgIFXV1NSUlZUKhefl5a1f/5xQ OAAgaent1+f1DvT3m72Q4bnmmquj0ahQuMfjbW9vFwoHkGAUYCBVVVRU2GxWofBI JNrS0pKbmyuUDwBIQkPHX/l9vng8bvZahiESicybNy8nR2oCcFeX6nQ6hcIBJBgF GEhhM2fOGD9+vFD4FVf85IILLhAKBwAkIYeiBPz+oNhZykJef/31jRtfEArv7+/f uXOXUDiAxKMAAylsypQpxcVFQuGNjY3Ll98jFA4ASEJ6AXarqtyzxELuvHNZV5fU CVV+f+DAgQNC4QASjwIMpLDq6iqLxSIUnp2dvWlTi1A4ACDZDB5/5XT6Nc3shQzb 3LlzxoyRek/rdrs7OjqFwgEkHgUYSGF2u91mswq96sdisSeeeLKsrEwiHACQbByK 4vV4wgMDZi9kePx+/003Lc7OzpYIj8fjXV2qoigS4QBMQQEGUtv06dPy8/OFwr/1 rf/74x//WCgcAJA8ho6/0rxesxcybBs2bHjrrTeFwoPB4O7de4TCAZiCAgyktsmT 60pKSoTCbTbbI488KhQOAEgeDkXRNK0/GDR7IcN20003dXcHhML1/00OHjwkFA7A FBRgILVVVVWWl5cLhcdisa1btwmFAwCSxNDt34Cm6f/ZN3stw9bUdFVOTo5QuMvl 6ux0CIUDMAUFGEhtdrtNL8Bjx0oNP1y6dNmsWbOEwgEAycChKN2BQF9vr9kLGbaD Bw8+8MD9QuHRaFQvwIoidb40AFNQgIGU19jYOHHiBKHwz372c9dee61QOAAgGegF 2ON2R8JhsxcybI888siuXTuFwnt6evft2ycUDsAsFGAg5dXW1pSWlgqFFxRMePbZ Z4XCAQCmG5x+pCh+n8/shYzEtddeG4lI9Xav19vW1i4UDsAsFGAg5VVUVNhsVqHw aDTa0rJZbnsVAMBcevv1eb0D/f1mL2TY9FeoefPmym0C6upSnU6nUDgAs1CAgXRw 1lmzcnNzhcKvvPLKr33tfKFwAICJho6/8vt88Xjc7LUM29tv/2H9+vVC4eFweMeO D4TCAZiIAgykg/r6+qKiQqHwmTNnLlt2p1A4AMBEDkUJ+P3Bvj6zFzISy5ff3dnZ KRQeCHTv379fKByAiSjAQDqorq62WMqEwrOzx27atEkoHABgIr0Au1U1Go2avZCR mDt37hixd7Jut6ejo0MqHYB5KMBAOqiosFut1jEybwRisdjatU9NmjRJIhwAYJbB 46+cTr+mmb2Qkeju7l606Mbs7GyJ8Hg8rqqq06lIhAMwFwUYSBMzZkzPy8sTCv/u dy+8/PLLhcIBAKZwKIrX4wkPDJi9kJHYuHHj66+/JhQeCoV27dotFA7AXBRgIE1M nlxXUlIiFF5RUfHww78RCgcAJN7Q8Vea12v2Qkbolltu9vv9QuGaph08eEgoHIC5 KMBAmqiqqiwvLxcKj8ViW7duEwoHACTe4OxfTQsFg2YvZISamq6SG9Hncrk6Ox1C 4QDMRQEG0oTdbrNarXK7oe6+e/m0adMkwgEACTZ0+zegabFYzOy1jER7e/s99yyX O/lCVVVF6ZIIB2A6CjCQPqZObZwwYYJQ+Oc//4X58+cLhQMAEsmhKN2BQF9vr9kL GaE1a1bv2LFDKLy3t3fv3n1C4QBMRwEG0kdtbW1pqdRZzYWFhU8//YxQOAAgkfQC 7HG7I+Gw2QsZoeuvv25A7Owur9fX1tYmFA7AdBRgIH1UVlZYrVah8EgksnXrNqFH rAEACTM4/UhR/D6f2QsZoVgsNmdOs9wGYFVVHQ6nUDgA01GAgfRht9vKyspyc3OF 8puamr/85S8LhQMAEkNvvz6vd6C/3+yFjNA777zzzDNPC4WHw2GPx8MGYCCNUYCB tNLQUF9YWCgUftZZZ91xx1KhcABAAgwdf+X3+eLxuNlrGaF77rmno6NdKLy7u7u1 db9QOIBkQAEG0kpNTXVZWZlQeE5OzgsvbBQKBwAkgENRAn5/sK/P7IWM3Lx5c+XC PR5Pe3uHXD4A01GAgbRSUWG3Wq1ykyGeeea3RUVFEuEAAGmhUEhRVb/Pl6LTj3R9 fb0LFy6Um/mnqqrTqUiEA0gSFGAg3cyYMT0vL08ofPbsiy+77DKhcACAqMGzrzQt FAyavZCRa2lpefXV3wuFh0KhXbt2C4UDSBIUYCDdTJkyubi4WCi8qqp65cqVQuHA /9/encDJVdb5/u+luquX9F7ddao7KwEUAgg4ine83qtCEMVlXLno4OD1f2XmP/Ma HZQAIiK4hEUZdAZZFImjF2QLf0C2JID35d8FGYksCRoIISRdXfvS1V1L1zmn7lN1 kqYJSXqrX52qOp/3C4pKdfM7T3eSOs+3nw2AKBWAQ4FA7a7+Va666qpEQmr/6mQy uWvXK0LFAVQJAjBQb0ZGRgYHPULFTdPctGmzUHEAgJzi6Ud+v8p4djdkUdatu6C5 uVmoeDgcGR0dFSoOoEoQgIF6o2neoaEhufVRP/zhDatXr5YoDgCQ4w8EwqGQaRh2 N2ThVDr9t3/7gdw+F6FQiAOQgLpHAAbq0NFHH9XR0SFU/L3vfe+6dRcKFQcASCgO /46NJRMJuxuyKLfddttzzz0rVDydTu/Y8aJQcQDVgwAM1KEVK5b39fUJFe/q6r7r rruEigMAJPgDgVgkks/n7W7IonzjG9/I5bJCxePx+O7drwoVB1A9CMBAHRoeHh4a GhQqbhjGo49uEppiDQAou2w2OxYMJmIxuxuyKKZpXnjhOpfLJVQ/FAr7/X6h4gCq BwEYqEOa5vV4PHK9hIsuuujd736PUHEAQHn5A4FEPJ7LSo2dVsbWrVvvvPMOoeK6 rkciERYAA05AAAbq0+rVR3R1dQkVP/74E6655hqh4gCAMrKGf5PxeE2ffqTccMMN r766W6h4KpXaufNloeIAqgoBGKhPy5YtHRgYECre0tLywAO/FCoOACgjfyAwnkxm 0mm7G7JYX/3qxXIZPhqN7tmzV6g4gKpCAAbqk8+neb1eoeKGYdx77/+3ZMkSofoA gHIpnn4UDJqmaXdDFiWTyVx22dflTgAOBoNjYwGh4gCqCgEYqFvHHPNmt9stVPyc cz77mc98Rqg4AKAs6uP0I2XTpk1PPPG4UPFcLvfCC38WKg6g2hCAgbq1atXKnp4e oeJLly798Y9vESoOACgLfyAQDYd1Xbe7IYt19dVXxeNxoeLJZHLXrleEigOoNgRg oG4tXTri8XiEiptmYdOmTULFAQCLVxz+DQSSYrmxki644AKXS2r+cyQS2bt3VKg4 gGpDAAbqlqZ5h4aGhA7sLRQK73rXf/va174mURwAsHgq/cZjsalczu6GLNZ//MdP t2/f3tgo0ms1TTMUCnEAEuAcBGCgnh199FEdHR1CxVW0fuihh4WKAwAWo25OP2oo Hj5/oVD6VdLp9I4dLwoVB1CFCMBAPVuxYnlfX59QcdM0H3nkUaERZgDAYhQnPycS 2UzG7oYslrrXXHzxRXL3mng8vnv3q0LFAVQhAjBQz4aHh4eGBuXqf/nLX1m7dq1c fQDAAljDv+OJRK2ffqQ89dRTGzfeI1c/FAr7/X65+gCqDQEYqGea5vV4PC6XS6i+ Ctg/+cmtQsUBAAvjDwTGk8lMOm13Q8rgqquuTIgd46TreiQSYQEw4CgEYKDOrV59 RFdXl1BxwzA2b94iVBwAsDAqAEdCIfUWbXdDyuCCC74i92PcVCq1c+fLQsUBVCcC MFDnli1bNjDQL1S8UCjcfvvt/f0DQvUBAPNVPP3I708mk3Y3pAzGx8e/851vy+2A FY3G9uzZI1QcQHUiAAN1zufTvF6vXP0PfvBD//RP/yRXHwAwL/5AIBqJ6Pm83Q0p g40bNz711B/k6geDwbGxgFx9AFWIAAzUv+OOWyM3f8ztbrvvvvuEigMA5qU4/BsI JONxuxtSHpdccolpSk3k1nX9+ee3CRUHULUIwED9O/LI1UuWLBEqrjoQW7Y8JlQc ADAvKv3GY7GpXM7uhpSH6ALgiYmJl17aKVQcQNUiAAP1b+nSEY/HI1d//forTzrp JLn6AIC5sE4/SsRidjekPHbs2HHrrT+Rqx+JRPbuHZWrD6A6EYABRzjqqCM7OzuF ir/97W+/4opvChUHAMyRPxBIxOO5bNbuhpTHLbf8+KWXXhIqPjk5+eKLUsUBVDMC MOAIy5cv7+/vEyrOMmAAsJ01/JtMJAqmaXdbykN0AXAsFn/11VeFigOoZgRgwBGG h31DQ0NCxQ3DuP/+B9rb24XqAwBm5Q8ExpPJTDptd0PKI5fLXXrp15qbm4Xqh0Ih v39MqDiAakYABpxizZpjW1pahIp/7nP/86yzzhIqDgCYlQrAkVDIMKSGTCvs8ccf 37x5k1DxfD6/bdt2oeIAqhwBGHCKI45Y1d3dLVR8+fLlN9/8I6HiAIDDy2azo37/ eDJpd0PK5pprronFokLFx8fHX355l1BxAFWOAAw4xdKlSz2eAaHihULh0UelflQP ADg8fyAQjUT0fN7uhpTNunUXyM1/jkSie/fuFSoOoMoRgAGn0DTN6x1qbBT5W68C 8M03/2jFihUSxQEAh5HNZlUATsbjdjekbAKBwHXX/avcDSsYDKlLSBQHUP0IwICD vOlNR8ttVfXe9566bt06oeIAgENR6Tcei03lcnY3pGxuv/22Z599Vqh4JpP5y192 CBUHUP0IwICDrFy5ore3V6h4V1f3XXfdJVQcAHBQ1ulHiVjM7oaU02WXXTY1JZXn E4nEK6/sFioOoPoRgAEHGRkZHhwcFCqu6/qmTZubmpqE6gMA3sgfCKhEl8tk7G5I 2ZimeeGF61wul1D9cDg8OuoXKg6g+hGAAQfRNK/HM+hySW0r8qUv/csZZ5whVBwA cABr+DeZSBRM0+62lM0f//jHu++Wmk+k60YkEg4EgkL1AVQ/AjDgLKtXr+7qWiJV /Mgjr//364WKAwAO4A8ExpPJTDptd0PK6frrr9+7d49Q8VRqYufOnULFAdQEAjDg LMuWLRsY6Bcq3tTU9NBDDwsVBwAcQAXgSChkGIbdDSmniy++SK54NBrbs0cqXQOo CQRgwFl8Ps3r9QoVN03z7rvv6e7uFqoPAJhWPP3I708mk3Y3pJzS6cnLL79cbjuJ YDA4NsYBSICjEYABxznmmDe73W6h4p/+9Gc++9nPChUHAEzzBwKxSCSfz9vdkHJ6 9NFHf/WrJ4SK53K5F174s1BxALWCAAw4zqpVK3t6eoSKj4wsveWWW4SKAwAsxeHf QCAZj9vdkDK7+uqr43GpI52SyeSuXa8IFQdQKwjAgOOMjIwMDnqEihcKhUcf3SRU HABgUek3HotN5aQOy7XLunUXNDdLHVUQDkdGR0eFigOoFQRgwHE0zTs0NCS0wkoF 4BtvvGnVqlUSxQEADdOnH8Xj6i3X7raU09jY2Pe/f11jo0jv1DTNUCjEAUgACMCA Ex111FGdnR1CxU899bQLLrhAqDgAoDj5OZHIZjJ2N6TMbr/99meffUao+ORk+sUX XxQqDqCGEIABJ1qxYnlfX59Q8e7unjvvvFOoOAA4nDX8O55ImKZpd1vK7Bvf+EYu lxUqHo/Hd+9+Vag4gBpCAAacaHjYNzQ0JFTcMIzNm7cIFQcAh/MHAqnx8fTkpN0N Kb8LLviKy+USKh4Khfz+MaHiAGoIARhwIk3zejweuX7GJZd87V3vepdQcQBwMhWA o+Gwrut2N6TMnnnmmV/84nah4urbFYlEWAAMoIEADDjW6tVHdHV1CRU/4YS3XH31 1ULFAcCxiqcfjY0lEwm7G1J+N954w+7du4WKp1KpnTtfFioOoLYQgAGHWrZs6cDA gFDx1tbW++9/QKg4ADiWPxCIRaP5qSm7G1J+l1zyVblVzdFodM+evULFAdQWAjDg UD6f5vV6hYobhnHfffd3dEhtNA0ADlTc/ioQSMTjdjek/NSX9vWvXyp3AnAwGBwb CwgVB1BbCMCAcx1zzJvdbrdQ8b/7u3PPPvtsoeIA4ED+UvrNZaX2SbbRli1bHntM avfEXC73wgt/FioOoOYQgAHnWrVqZU9Pj1Dx5cuX33zzj4SKA4DTWKcfJePxQqFg d1vK75prronFokLFk8nkrl2vCBUHUHMIwIBzLV064vF45Oo/8sijcsUBwFH8gcB4 MplJp+1uiIh16y6Qm/8ciUT27h0VKg6g5hCAAefy+bTBwcGmpiaJ4oVC4cc/vmXZ smUSxQHAaVQADodCpmHY3ZDyC4VC1177vcZGkU6paZrhcJgFwACmEYABRzv66KPk tqo644z3f+lLXxIqDgDOkc1mR/3+8WTS7oaIuPPOO7dufVqoeDqd3rHjRaHiAGoR ARhwtBUrlvf19QkV7+/vv+2224WKA4Bz+AOBaCSi5/N2N0TEN795RVpsanc8Ht+9 +1Wh4gBqEQEYcLTh4eGhoUGh4oZhbN4stasnADhENptVAThZj6cfWS644Csul0uo eCgU9vv9QsUB1CICMOBomub1eDxyPY/166886aSThIoDgBOo9BuPxaZyObsbImLH jh233voToeK6rkcikUAgKFQfQC0iAANOt3r16q6uJULFTznlHZdffrlQcQCoe9bp R4lYzO6GSPnJT37y4os7hIqnUhM7d+4UKg6gRhGAAadbtmzZwEC/UPGOjo6NG+8V Kg4Adc8fCCTi8Vw2a3dDpFx66dd0XRcqHo3G9uzZI1QcQI0iAANO5/P5vN4hoeKG YTz88CNyU6wBoI5Zw7/JRKJgmna3RYS6R1x88UVyJwAHg6GxsTGh4gBqFAEYQMMx x7zZ7XYLFf+Xfzn/fe97n1BxAKhj/kBgPJnMiO2QbLs//OEP9967Uah4Lpd74YU/ CxUHULsIwAAaVq1a1dPTLVR8zZo13/vetULFAaCOqQAcDoVMw7C7IVKuv/76vXul pignk+O7du0SKg6gdhGAATQsXTri8XiEirtcrl/+8kGh4gBQr7LZ7KjfP55M2t0Q QRdffJFc8UgksnfvqFx9ADWKAAygQdM0r3eosVHkDcEwjPvuu7+jo0OiOADUK38g EA2H5TaIsp1K+F//+qVCC4ALhUIwGAoEAhLFAdQ0AjCAore85QShAKz83d+de/bZ ZwsVB4D6o8Khf2wsmUjY3RBBW7ZseeyxLULFVQB+5plnhYoDqGkEYABFK1eu6O3t FSu+8sYbbxIqDgD1xx8IxKLR/NSU3Q0R9L3vfTcSiQgVTyQSr7yyW6g4gJpGAAZQ NDIyPDg4KFS8sbHx4YcfESoOAHWmOPwbCCTjcbsbIuvCC9c1NTUJFQ+Hw6OjfqHi AGoaARhAkaZ5h4aGhPoihULh5z//33IBGwDqiUq/8VhsKpezuyGCEonElVeuF1p6 Y5pmKBQKBIISxQHUOgIwgH3e+ta3GobUbisf/ejHzjvvPKHiAFA3stnsWDCYjMcL hYLdbRF0//33/+53vxUq3tzs+uMf/yhUHECtIwAD2GfFiuV9fX1CxTXNt2HDBqHi AFA3ipOfE4lsJmN3Q2RdeeX6pNgJT/F4fPfuV4WKA6h1BGAA+wwPDw8NSc1SNk1z 06bNQsUBoD7sG/5NJAqmaXdbZK1bd4HQAUhKKBT2+1kADODgCMAA9tE0r8fjcblc EsULhcKNN960atUqieIAUB/8gcB4MplJp+1uiKyxsbHvf/86oQXAuq5HIhEWAAM4 FAIwgNcceeTqJUuWCBVfu/b0L3/5y0LFAaDWZbPZQCiUTCRMw7C7LbLuuOOOP/1p q1DxiYmJl17aKVQcQB0gAAN4zfLly/r7+4WK9/X13X77L4SKA0Ct8wcCqfHx9OSk 3Q0Rd8UVV2QyUqPcsVjs1Vf3CBUHUAcIwABeMzzsGxoaEipuGMbmzVuEigNArVMB OBIOG7rUbvzV44ILviK03KahuAA45PePCRUHUAcIwABe5/jjj5PbmOTKK6868cQT hYoDQO3KZrN+v19uY+Tq8dJLL91yy4+FihuG8dxzzwsVB1AfCMAAXmf16iO6urqE ir/znf/10ksvFSoOALXLHwhEIxE9n7e7IeJ++tOf/vnPLwgVT6VSO3e+LFQcQH0g AAN4nWXLlg4MDAgV7+zsvOeejULFAaBGFYd/x8aSiYTdDamEr3/90rxYzo9Go3v2 7BUqDqA+EIABvI7Pp3m9XqHiuq5v2rS5qalJqD4A1CJ/IBCLRvNTU3Y3RJxpmhde uE5uAXAwGBwbCwgVB1AfCMAADiS6DPiiiy5697vfI1QcAGpOcfg3EEjG43Y3pBK2 bt165513CBVnATCAuSAAAzjQqlWrenq6hYqfeOKJV155lVBxAKg5Kv3GY7GpXM7u hlTCTTfd+MorrwgVTybHd+3aJVQcQN0gAAM40NKlSz0eqWXAra2t99//gFBxAKgt jhr+Vb761YsLhYJQ8UgkuncvC4ABzIIADOBAmqZ5vUONjSLvD4ZhPPTQwy0tLRLF AaC2OGr4V9d1FYCFltioXB0MhgIBFgADmAUBGMBBnHDCCU1NUu8Pf//3//A3f/M3 QsUBoFZks9mxYDARjzeIDYpWlV//+tcPPfSgUHHTLDz77LNCxQHUEwIwgINYuXJl b2+PUPEjjzzy3//9eqHiAFAr/IGASr+5bNbuhlTIddf9azAYFCqeSCTlVhcDqCcE YAAH0jSv2+3u6+uTKG4YhgrAN9xwo0RxAKgV1vBvMh6XWxNbba699nuBQEBoCnQ8 Hs/lcoGAVMAGUDcIwAAOYmRkeHBwUKg4+2ABQHHvq0Qim8nY3ZDKEd0BKxwOj476 hYoDqCcEYAAH4fP5PJ4Bua1Krrjim6eccopEcQCofg4c/t2+ffuGDbcK3VYMw4hE omNjYxLFAdQZAjCAg/D5tI6Ojq6uLoniqqeydu3p69atkygOANXPgcO/t99+29at W4UCcCqVSqfTY2NsAQ1gdgRgAAehad7W1tb+/n6J4qZpDg+PbNiwQaI4AFQ5a/h3 PJFQb4Z2t6VyrrxyfTweb2pqkigei8WmpqZYAAxgLgjAAA5OdBlwc3Pzgw8+JFQc AKqZPxAYTyYz6bTdDamoiy66UOh4+QYWAAOYDwIwgIMbHvZ5PB6hn9abpvnFL37p zDPPlCgOAFXLmcO/v/vd7zZuvMflckkUV9/JSCTi97MAGMCcEIABHJzPp7W1tff0 dEsUNwzjlFNO+da3vi1RHACqljOHf3/84x/t2LFDaAFwMjmezWZYAAxgjgjAAA5O 07wtLS0DAwNC9Xt6eu+44w6h4gBQhfYN/yaTpmHY3ZaKuvzyy1VGFSoejUbz+TwL gAHMEQEYwCENDw8PDnqEVm01NTXdeusGr9crURwAqpA/EEiNj6cnJ+1uSEXF4/Gr rrpS6FZSKBTC4YjfzwJgAHNFAAZwSD6fT9O8QsdUGoZxzjmfVSSKA0C1yWazgVBo PJEwHDb8++ijj27ZslloAbDK1YFAkBOAAcwdARjAIWma1tbW1tvbI1FcdQGPOeaY H/zg3ySKA0C1cebwr/L9739/dHSv0ALgRCJZ/MlCgAXAAOaKAAzgcJYuHfF4PELF 3e62++67T6g4AFQVFYAj4bCh63Y3pNIuueQS05Qa9I5EInv3jgoVB1CXCMAADmd4 2Nff3y80da1QKFxxxTdPOeUUieIAUD2y2eyo3z+eTNrdkErbvn37hg23Cg3/6roe i8U4AAnAvBCAARyOz+dbsqRTkShuGMbatWvXrbtQojgAVA9/IBANh3XnDf/edttt W7c+LfRT1MnJyYmJSRYAA5gXAjCAw/H5tNbW1r6+PonihULB6/X+x3/8TKI4AFSJ bDbr9/uTzhv+Vb7znW+Pj48LbQEdj8enpqY4ARjAvBCAAcxiZGRkcFBqGXBzs+vu u+9ub28Xqg8AtisO/0Yiej5vd0MqLZfLXXbZZTLhtygcjoyOsgAYwPwQgAHMQnQZ sGmaX/jCFz7xiU9KFAcA2xWHf8fGkomE3Q2xwa9+9cSDDz4odPtgATCAhSEAA5iF z6e1t3d0d3dJFFc9mBNPPOm73/2uRHEAsJ1jh3+VH/7wh7t2vSwUgMfHU5lMmvnP AOaLAAxgFprmbWlpHRjoF6rf0dG5ceNGoeIAYCMnD/8ql156qa5LJf9oNJbPTwUC QaH6AOoVARjA7IaHhwcHPUK7mCjXXPPd448/Xqg4ANjFHwjEIpG8I4d/d+7cefPN NzU1NUkULxQK4XDE7/dLFAdQ3wjAAGY3MqIC8KBQcV3XP/ShD3/xi18Uqg8AtnD4 8O/dd9/15JNPCs1/bijugBUeHSUAA5g3AjCA2YkGYNM0h4eHN2z4aS6Xa2lpsV4U GjQAgIopDv9Go/mpKbsbUiHqzdx6Yhh6S0vr+vXfSSQScm/mBGAAC0MABjA70QDc UOo2ve1tb1eX6O/v93q9Q0ND3d3dS5YsaW9vd7vdzc3NVheKVAygVtT38K+VdQuF gmka+Xw+l5tKp9OTk5Mq8cbj8fHxcfVkx46/yA3/NhCAASwUARioT5rmVXGxucjV 0uJqbW2dHlytQqoXZRhGY4nqMLW0tLa3t6kA3NfXr1LxSNGwpvn6+vpUJFZfiJWE c7mceqI+ze7mA8CB6mb4N5PJqJxr3UFMU71X6yruqogbi8UiReFEIplKjatPm5rK q4+qN3Prf1S3H7mdIxZPtVPdGaPRmNVmFenZTwtwiOp9YwIwLyrxqq7GdNx1u921 OF6qkvAbH9UXokJxR0d7T0/vwEB/f/9Ad3eX6qy0tbUdddTRPp9vYGBAZeNa/HoB 1KXi8G8gkIzH7W7Iwqn32JTKtePj0Wh07949KvSq99h0elK9kkpNTE5OqFdM01Bv 0VbKfeNjbVFfr/oCk8lkPq/ysK6+LvIwUK9q7x0KwEyaprlcxcSr8qHoZDMbTSfh mZHY+pA1DU/90vpoS0tLe3tHb2+PCsk+n7Z06bIjSlRCtrH9AJymVoZ/Vd7z+/1j Y2PhcCgajVkDudlcztB1a0qO9R47HWhnxt3azbpzoet6Op2ZmppSTwIBjhoG6kp9 vm0B9c2a3qzCXl9ff6Fg1mv/4zCsJDzt8N+B0iq1Yh/Omlnd1dXd398/NDQ0MjKy cuVKFY+9Xm+9/uwAQOVVz/CvYRixWExFXBXhSnOVE6lUKp1Oq1xnrTpRt5JZ3z9n /tKZtxv1fYrHY/l8nmnSQH1w3BsZUNN8Pq21tbW3t9eBvRA5qk9jjSq3tro7Ozt6 enoGBgaGhrzDw8PLli1btWqVSsvMrwYwRypuxqPRKfnhX/XeFY/HrfHbSCSqQtr4 +Pjk5GQuN6XreettjfeuMlLf0kQioX5nx8YYEwZqGH1ooAZomtflamlvb+vo6CD6 Vp6VkBsbm9zu1vb2jq6urt7eXo/HMzg4qGna0qVLly9f1t/PLGsA5Rz+VWk2VBKL xVTuSiaTKtyWxm9z+byu4hj51hbqdqB+FzKZrK7nGRAGahE9aaCqWUO+3d3dzc3N drcFhzMdkltbW9ra2jo7O5csKebk/v4+lZS93iFN8y1btozNuoD6Vhz+jcWmcrlD fYK1uVQ4HI5GI7FYfHw8OT6empiYyGQyuVy2tOjUaGxssOYnV7LlmC/DMMbHxxkQ BmoOARioUir6ut3urq4uom89MUtKB1QVV3G73Soqd6iw3N3d1d3d09/f7/EUZ18r mqZ1d3fb3V4Ac6KCUCAQ2LNnz4s7XwqOjalMWzoWN53NqlirIlJOhSVrrz6GbeuM +p1NpVK5XI4YDNQKAjBQdTTNa0VfdmZyOGtUuaG4zXWzy6X+UYHZ3dbm7ugoZmZF JeSenuJDX8ng4ODAwAAHIwOLMTExEY1Gw+FwvGR8PJlMqng7rl6fnJxIp1WmVWEn p+t5XTdMs3jmLaO10HXdisFMigaqHwEYqCIq+jY3u/r7+xj1xYJZg8wNpdOhSppb WlwtLS2tRcX83NbW1t7eXgzRnZ3d3V0qS6tEvaSkq0RFavUhfv6C2qISyOSkdUpt 0URJujgOO6FeK62enSye8VOUm5oqDsvmi3QVYg/4W2P3l4JaVdp2O24YOjEYqGYE YKBa+HyayiEqftjdEGDfqcsqEsw487N4YMq+SF1iRWv1RIVr9cRVTNnqly63u1U9 t46nbil9QEVut9utnpf+2+ZyNVt5fPpz1P+i/kcVy1U19aguptI4OaS2qD8tKnCq PzYqZKoYUHrUc7liyLQOUy0FzuIC11yuGEHV67nSM/Wh6c9RT9X/ov5HlUtLL6t/ iwf2WDHVYu5T/BM682zw6ZNpAXtZZ00xIxqoWtwqAPtZA799fb2MuQEzWTm8YcZh pKWdxhqnHxsOcTBpGYOQKjX9g4BqYwW/A05qXWTBQ70489s+/d2Y8fORavz+AHbR dT0eTzAUDFQn7liAzawVv319fXY3BAAAlE08HmdVMFCFCMCAnTRN6+xk2jMAAHUo lUpNTqYDAaZDA1WEAAzYxufzDQ56WOgIAEC9Mk0zHI6MjY3Z3RAA+xCAARtomrep qbm/v49FvwAA1Ddd12OxuGkaTIcGqgEBGKi0/em33+XirCMAAOqfrhuxWIwMDFQD AjBQUaRfAAAciAwMVAkCMFA5zHwGAMCxmAsNVAMCMFA5w8O+0tgv6RcAACcqZeCY 38+eWIBtCMBAJWiat7nZ1d/f19zMzGcAAJzLMIxYLG4YOuPAgC0IwEAl+Hza4OAg Jx4BAIDS2UjhsTHOBwZsQAAGxGmatnz5sqmpKbsbAgAAqoLL5dq7dzQQIAMDlUYA BmRpmrelpXVgoN/uhgAAgCoSjcby+SkmQgMVRgAGZA0P+4aGhuxuBQAAqDqhUIgN sYAKIwADgjRNUwHYNE27GwIAAKpRIBBkIjRQSQRgQIqmeVtbW/v762fyc6FQUGFe PTY2Ft861CPbegEApFm3nobSbci69Vi3ofoQi8WmppgIDVRO/bx9ANVmeNg3ODhY ozdpK+u2tLT09PR4vdpRRx118sknnXLKOzRNMwxDfUg9ZjKZHTt2bNu27cUXX9y7 d284HEomx7PZrPpgnfVOAADSrPtOc7Oro6O9t7e3tH/kiqOPPvr4449Xj62trdOf OTY29uSTv3/66a3q7hMMBpLJZD6fr937jvrCw+EwE6GBiqnJdwqg+qk799KlI7qu 292Q2Vl9DrfbrbLu0qVLV68+8sQTTzz55JNHRkYWXDMajT777LPbt2/bufNllY0j kXAqlZqamlLX4iRkAHAywzBUUm1ra+vq6hocHFq2bNnq1Ucce+ya4447rq+vb8Fl R0dHn3766T/96U87d76k7jsqFedyuVpJxU1NzX6/n4nQQGXUwJsCUHM0zetyuTwe j90NOYhCSXd3j8q3b37zm0466eS//uu/HhwcrMzVVdIOBoPPPvvMCy/8+ZVXXlH9 lUgkMjGRUt0U9VGyMQDUByvlut3uJUu6PJ6B4eGRlStXHnPMm0844S1er7diy2fC 4fBvf/vbrVuf/vOf/6LuOOPjycaSylx9XtTdUNd1JkIDFVCNbwFArdM0Td3vVQa2 uyFFVuL1eAaPO27Nf/kvf33qqadWLO7Oi8rGqnfy3HPP7dixQ2XjsTF/JBJNpcZV NjbNgstFNgaA6qLrRlNTMeV2dXWru57PN6xSrjVpeWRkpDo3iVCR+LHHHvvd7377 /PPbIpFw9eRhlX7VXY9BYKACquLvPFBPNM2regOLmce1eFboXb58+Xve896PfOQj q1evtrExZaG6Kdu2bfvLX1Q23uX3+0OhcDKZyGQyqsfAXlwAIMTafcrlcrW3t/f0 9A4NDQ4Pq5S76k1vOnrNmjUeTzX+OHVedu7ced999z3xxOOvvvqq7WE4Ho/ncjkG gQFpBGCgzHw+zev12nJpa5PMt73t7eeee+473/lOW9pQedls9uWXX37hhRdefnmn 6sEEAoFYLG5Nq1Zdt1pZAAYAtrC2gVBvldZ05f7+vtLuU8uPOGL1Mcccc8QRR7S1 tdndxgr5zW9+s2HDhqee+kND6ZgDW9oQDAbHxhgEBmTRLwTKSaXfjo7Orq4lFb6u rhsrViz/+7//hw9+8IMVvnSVm5ycfPHFHTt2vPjKK7tGR0dV3yIWi6VSE9lsxlqi xugxgPpmjeI2Nze3tbWr21N/f7/X6x0ZGVm5ctXRRx911FFHd3Z22t3G6vLLX/7y xhtv2L371cqvvlG3p3R6kgwMiCIAA+U0POwbGhqq5BVV9F2z5tgrr7xq5cqVlbxu fdB1fWxs7C9/+cuuXbus0eNIJJJMJlVsnpqaMk2jobg5JwkZQPVS+bahtI1wa2ur irI9PT0ej8caxV21atWb3vQmn89XJXtS1JZXXnnloosu3LZte4VjcCgU4kgkQBQB GCgb1eHw+TRrHnIFqAu53W0/+MEPTjnllMpc0YGsbatfeukl1RPau3dvMBgIBkOl hDyRyWSnpoqzrBlGBiDEGrxV7zCtre729rbOziWls9mHvF5t6dKlK1euPPLIIyu5 qbIDPfnkk//8z/+cy2UrOSk6EAiyGxYghwAMlIemeZubXYODFTr6yDCMNWuOu/32 2ytzORyG6qFGo9GdO4srkFVIDoWC0WgskYiPj6fS6bTqNlkHIFu9WBYkA7CW3Vpb LrWqaOtu6+jo6O7u6u3tGxjoHxryqnC7fPny1atXDwwMEG6rwdlnn71t2/MVO6sv HI4YBkciAVLoigHloWmaSr+VuTuq9Hv22Z+++OKLK3AtlFEymVQheXR0byAQCIVC kUi0lJOVVCaTzmaLUVnXdWsSAWkZqCFWpm0obZ7kcrlUrG1ra2tvL8ba7u5ulWw9 noGhoSF1pxgZKYbbnp4eu5uM+Vm/fv3tt99Wsbu8ysAMAgNC6F0BZaBp3paW1oGB /gpcS90XzzrrrEsu+VoFrgUbpdNp1fsJFgVUTygaLaZlFaETiaRKy5lMRgXmXE4F 5rz6I2GWWJmZ2AwshjVfw/oLpajA43K1uN1WoFU6entVeu0pjdYODA56vN7izv8q 2XZ0dNjddsj69re/dccdd1QmA0ejsXx+ikFgQAL9JKAMKjb8q6LOkUcetXHjRukL oUapVKyisgrNkUgkFoupvKwycyo1kUqNT0xMqlCtknNO5eYp9c9UPl8Mz7pulHr7 5vTydQafUaOmh2EbSiOxpT/JTS6Xem9ubmlpaW0tTTd2u4sptqNjyZLOrq7urq7i qlqVZ/v7+z0elWa9KtY65+AfzNfHPvaxl156sTK3ewaBASF0cYDF0jSv6lWpzlMF rqX6c3/849MVuBAcTkXleDyeSqVUfp6YmFC/VI+ZknRaBWmVoovjz9YKZxWks9mc rudVllaP+byuYrUK1Oq5SiO6XnxumoaVTKykPR22rSfqUcUV9VTl7ulBbEJ4bZn+ rbR+e9XvnvXb2jDjt9L6zbUWtVrDqyqiulwu9czlalHPm5tdLS3qBfVvcdy1rc1t BVe3u83tttbKquzaWRqJbV+yZEkpxxYTbFdXV19fH2OwqIC3vvXk6Z+ziIrFYuoN lkFgoOzoXgCLVcnh3x/96Mfs+QznmJycVPlZpSOVwFVHUL2iAriK2Q2lsW4VtdUT a+H0Af3RfF6F86mytEH91f7Tn/6kwnxZqpWXiognnniiemcoSzWVMFXYnPlKKZcW l7Oq5yqIWuOiKpq2txdzpnpdBU71nVefw0GycI4nn3zyf/2v/6cCN331zhaJRBkE BsqOAAwsiqZ5VefP4xHf/Fn1cY899thf/OIO6QsBAIDD+B//46zt27dXIANHIhEV gxkEBsqLAAwsis+njYyMqPuT9IUKhcKf/vSM9FUAAMCs3vKWEypwQpXL5RodHR0b YxAYKCcCMLAow8O+oaEh6asYhnH++eefe+7npC8EAABmtWHDrddee20FBoFDoZDf PyZ9FcBRCMDAwmma1+1u6+vrFb2KaZoDAwOPP/6E6FUAAMDcvfe974lGo9LjwPF4 IpfLMgsaKCMCMLBwWpFX+ioqAD/22GMez6D0hQAAwBxFIuFTTz21AhOhVfplKyyg jAjAwAKp6Nve3t7T0yN6FcMw1q49/Xvf+57oVQAAwHx9+ctf3rx5k/RE6GQymclk GAQGyoUADCxQZU4/amxsfPrpraKXAAAAC3PyySdNH2wuxDCMcDjCIDBQLgRgYIEq MP9Z1/XvfGf9hz70IdGrAACAhXnggQe++tWLXS6X6FWYBQ2UEQEYWCCfT/N6BQNw oVBoa2v//e9/L3cJAACwSO94xzuy2Uxjo2CnOhgMchgSUC4EYGAhNM3b0dHZ3d0l dwnDMC6//IqPfvSjcpcAAACLdO+991522ddFl0SNj6fS6UmWAQNlQQAGFkLTNI9n QG7KU6FQULfSP/7xaaH6AACgXN761pMNw5AbBNZ1PRKJMgsaKAsCMLAQ0guA1X30 tNPWXnbZZc0lTU1N1hPRGVYAAGCaeTDqBm09KZRYn7l+/frHH39MdBCYZcBAudCZ BhZCegGwruv33LPxMGcsqSQ8MxhPq8CBhAAA1BwVVg8aaGdacPFkMvnxj39MdCss lgED5UIABuZN07xtbe29vVInAKt7cE9P71133bXIOgfEY4aRAQB1Y9Y0K3060QE+ +clPJpMJuR9DJxLJbJbTgIEyoB8MzJvPpw0NeeVSpK7rH//4x//hH/5fqQvMMDMY zwzMhGQAQMUcKsGWZXi2Mm644Yf33HOP5OYgDaEQg8BAGdDHBeZN01QAHpT7Ka9h GI8+uql6JjPPDMaEZADAYVip9fDzjSs8NlsZ6ut63/tOl1sGrOqHQmGWAQOLR/8V mDfRHbDKNf+5wqw1ydMJeeYjORkAatRhcuz0h+oyzS6M9Cxo9sECyoKOKTBvPp/P 6x0SKq7rxgc+8IHzzz9fqL69mkrIyQBQYTOj7AGxduYv7W5mbbv22msfeughl0tq EDgYDI2NjQkVB5yDHicwP5rm7ejo6O7uFqpvGMbPf/6/RbeYrn7Te1xPJ+SZT4jK AJxsLjmWUVlbBIPBv/3bz8jNgh4fH0+n0+yDBSwS/UhgfjRNGxz0CN3eVJfF5Wp5 8MEHJYrXJRWGDxqSrSdEZQDV6YApxAedV0yOrUVnnnmmrueF7j6GYYTDEWZBA4tE 7xCYn+LyX++Q3L3t+ONPuPbaayWKo2k2BGYAc3TAVk+H+SUh1lHOP//85557Vu6n 5MFgiAAMLBK9PWB+RHfAUgH4S1/6lzPPPFOoPuaFwAzUpcJ+MzPqQX85/dzuJqNm PPjgg9dd969ys6DZBwtYPHpvwPz4fJrcAl1d17dseUyoOCqgsWRmQj7Uc7tbCtSe 6Tg6M6YePsHa3WQ40WmnnSp3GnAwyFHAwGLRCQPmQdO87e3tPT09EsVVd62lpeWX v2QBsBM17mfF4zk+sbvVwMEVDm1mcD3oL+1uO7BYH/zgmfm81DLgZDKZyWTYBwtY DPpPwDz4fNrg4KDQEX+GYaxZs+a6674vURzO8cYsPdPMTzj8R+3+OlA205N4Z0bN WV8/DHu/HKDKfelLX9y2bZvQLGjTNMPhMIPAwGLQxQHmQdO0oSHBAHzhhReedtpa ieKAhOnMXJbHA8oe9FoLe/GAzPbGCHf4TzjoLw//uBjTFeQuAUDOli2br7rqKrkA HAqFWQYMLAYBGJgH6R2wNm/eIlQcAABUxtq1p7EPFlC1CMDAPIgGYNMsbNq0Sag4 AACojNNPP72pSaqPTQAGFokADMyVir5ut7uvr0+iuGmaqvIdd9wpURwAAFTMWWd9 Kh6PCy2YUpVzuRz7YAELRgAG5koF4K6urs7OTonihmH89//+7q997WsSxQEAQMV8 61vf+j//51dCs6AnJydTqRQBGFgwAjAwV5qmDQ56hO5nuq7feuuGZcuWSRQHAAAV s2fPns997lyh04ANwwiHI8yCBhaMAAzMVXH5r3dI6HgYFYC3bHlMojIAAKiw0047 VSgAFwqFYDBEAAYWjAAMzBU7YAEAgLlgHyygahGAgTlR0bepqWloaEiiuGmaXq/3 Zz/7uURxAABQYeec87fBYFBoH6xQKKR6DiwDBhaGAAzMiQrAHR0d3d3dEsUNw/jK Vy543/veJ1EcAABU2KOPPvrd714jtG/I+Ph4Op0mAAMLQwAG5qS4/teryaz/LQbg zZu3iJQGAAB2WLv2NKEAXCg0BIuToAnAwEIQgIE5Ed0CmgAMAECdkQvAbAQNLAYB GJgTuR2wCoWCukE+9NDDEsUBAIAtPvCB96ukKnR4BPtgAQtGAAbmxOfzeb1SO2B5 PIO33XabRHEAAGCLT3/605FIWGgfrGAwNDY2JlEZqHsEYGB2muZ1uVwej0eiuGEY 55//5fe///0SxQEAgC0efvjha6/9ntAs6Egkous6y4CBBSAAA7NTAXhJiURxFYDv v/+B9vZ2ieIAAMAWmUzmwx/+kFAAnighAAMLQAAGZqcCsMfjcblcEsV1Xd+y5TGJ ygAAwEannXaqXOchEokQgIEFIAADs9M0bWhoUGgZj2mamzZtlqgMAABsdPrpa+U6 D6FQmH2wgAUgAAOz0zTv4OCgxCymQqHgdrvvv/+BslcGAAD2+vCHP5TL5SQ2gi6d hBRmBBhYAAIwMDu5EWDTNFetOuKmm24qe2UAAGCv8847b9eul4X6D4wAAwtDAAZm J3cIsK7rt9zykxUrVkgUBwAANtq9e/fnP/8/hZYBcxQwsDAEYGB2cgHYMIzNm7dI VAYAALZbu/Y0oY2gCcDAwhCAgVmo6Nva2trf3y9RnC2gAQCoY3IbQcdisampKZYB A/NFAAZmoQJwe3t7T09P2SsXCoXGxqZHHnmk7JUBAEA1OOOMMwoFU2IfrGQymclk CMDAfBGAgVmoANzV1dXZ2Vn2yqZper3en/3s52WvDAAAqsE55/xtMBiU2AdrcnIy lUoRgIH5IgADs1AB2OPxSMxfMgzjpJNOvvrqq8teGQAAVIN169Zt3fq0xDJgXdcj kQgBGJgvAjAwi+L+V94hiclLum588pOfPO+888peGQAAVIObbrrprrvucrnKH4AL hUIwGGIfLGC+CMDALNgCGgAALBgbQQNVhQAMzIIADAAAFowADFQVAjBwOKJnIJmm uWnTZonKAACgSpx++lqJTbAaOAkJWBACMHA4KgC3tbX39oqcgaQq33fffWWvDAAA qsdHPvKRbDYjsZlIIpFUlQnAwLwQgIHDUQG4s3NJV9eSslc2TXNkZOTWWzeUvTIA AKgen/vcuaOjoxKDwKnUxOTkBAEYmBcCMHA4xR2gvZrAD22LC4D/6q/+av36K8tf GgAAVI2LL77oP//zPyWWARcKDcHiKmACMDAPBGDgcHw+bWBgQOgQ4E98gjOQAACo czfddNPdd98ldBRwNBodG2MfLGAeCMDA4bAFNAAAWCQ2ggaqBwEYOBwCMAAAWCQC MFA9CMDAIano63K1eDwDEsUJwAAAOIRcAI5EorqeZxkwMHcEYOCQVAB2u919fX1l r1woFFwu14MPPlT2ygAAoNqceeYHdF2XOAkpHo/ncjkCMDB3BGDgkFQAbm/v6Onp Lntl0zRVrr7jjjvLXhkAAFSbs876lEqqEichJZPjmUyaAAzMHQEYOCQVgLu6ujo7 O8teWQXgo446+vrrry97ZQAAUG3+8R//8cUXd0gE4MnJyVQqRQAG5o4ADBySCsBD Q0MStyvDMN773lMvvvjislcGAADVZv369Y8//pjEMmDTNEOhEAEYmDsCMHBIPp/m 8XiEDu77whfO+9SnPlX2ygAAoNrceeedN998k8vlKntlwzAikQhHAQNzRwAGDokz kAAAQFlwEhJQJQjAwCERgAEAQFkQgIEqQQAGDq50CLDL4/FIFDdNc9OmzRKVAQBA FTr99LUSu4o0FI8Cjui6zjJgYI4IwMDBqQDc2uru7xc5BLixsfGRRx4te2UAAFCd zjjjfVYHoOyVY7H41BRHAQNzRQAGDq50CHB7T0+P3CXUjdA0zebm5iVLlng8nqVL l61Zs+ajH/2o3BUBAICoe++9d9u2bXv37olEIhMTE4ZhNDU1SeTeaclkMpPJEICB OSIAAwenAvDIyIi6b1X+0ioVq0e3u623t8fr1Y455pjPf/7zlW8GAAA4jFtuueWF F14IBgOJRDKXy6pXhCY5H15zc/Po6CgBGJgjAjBwcCoADw4OCu1XsQDWcLG6s3Z2 Lunr6/N6vSoYn3POOXa3CwCAOvezn/2sFHSD8Xh8cnLCuh2LDurOi2EY4XCYAAzM UbX81QWqjc+nqQBsy49y58UKxo2NTR0d7b29fUNDg8ceu+bcc8+1u10AANSYDRs2 bN++LRQKJxLxdDqjbrBVFXQPRXUDVADmKGBgjqr9rzRgFxWAvV6RM5AqY38wbmxt be3q6urvH9A07dhjj/n4xz9hd9MAALDNPffcvX37C4FAIBaLplKpqakpdcesiaB7 GMFgkAAMzFEN/1UHRMkdAmw7dae39uRwu90qG/f19auor7LxJz7xSbubBgBAGdx9 910q5ZYmLcdUys3lctaukzWdcg+Do4CBuavPdwFg8eo4AB+eWdLa2tre3t7d3T0w 4FHx+Ljjjnv/+99vd9MAANjn4Ycffv7551XEjUYj4+PjmUxmamqqqcTuptmAAAzM HQEYOIjSIcCt/f39djekuljTqtWTlpaWtra20uhxn0rIKh5zehMAoLzuvfdeFXFV vo3H46lUKpvN5vP5htJOy/U6kLtgsVhM5X/2wQLmgrcP4CBKhwB39PR0292QGjO9 8NjlamlvVwm5u7e3p7e37/jjj2PtMQBgpnvuufu5555PJOKJRDKVGs9ksrqer4Pl uLZIJtU3ME0ABuaC9xfgIFQAHh4eMU0bDgGue9YU6+bmZmuWdWdnZ09R71ve8paP fexjdrcOAFAGGzdufOaZZ5LJRDKZnJyctOYnW9tPOHOKsrSmpma/n6OAgTkhAAMH UW2HADvN9Fxrl8vV0tLa1ta2pKSvREXl97znPXa3EQAc54knnlCxNl4yUVKaljyl 63oDM5NtxVHAwNzxPgUcBAG4VqicrNJyadK1isotra3ujo72zs5iWu7t7e3u7jrp pJPf+c532t1MAKhSv/nNb7ZufXp8PJVIJFSgnZycSKczU1O5fD6vYq31BsuYbfUj AANzRwAGDqLWDwHGQVlpuaE0TLF/bNnd3t7e0dGpdHV1qce3ve1t73rXu+xuKQAs 0K9//eunnnpqcnIylUqpx3S6OP04m81Z47TW5BoybV3iKGBgjgjAwEEQgGGxzkxu KGXm5hIVnN1F+xYwd3R0LFnSpZ6/4x3vOOWUU+xuL4A68eSTT/7+979X2XViIpVW Kba0jDaXm8rlcrqeN0qsNFvHZ9tiXgjAwBzxjgkcBAEYi1TYr2H/YEsxO7uaS/O0 Fbc1+Nze3qH+7erqUon6ne/8ryeccILdDQdQBs8+++xvfvP/q7yaSqUyRWlrGHZq Sv0zVZpdrAKsPj0tpXE/uxuOGkYABuaIt1rgIAjAqAbTm4HtPxek+GCNQ7e0FNc8 lxQ3CVNxuq2tXf2no6OjtbXl1FNPO/bYY+1uPlBjtm/f/thjW1Q+TafT2aJiZLU2 ecrvo2KrXhp6tf52mlZkZfMnVAMCMDBHvF8DB9I0r0oVAwMDdjcEKLPpRG1Ridoa dFKR2prjrXK1ReVqK2OX5nu7rZitnrS3t6lPPOOMM1asWGHjFwJn2r179yOPPGKa RiaTzeX2RdNciZVOrWWuSimpFmcIq8f9szFe+5NPXkVdikaj6q8B+2ABs+IGABxI BWC3u62vr9fuhgC1Z+bcb4uVNKx54JZS5C5OCC8F7+KDlbdLO3mrV13FNdZF6iVr xniLqvDxj3+CeRnVIxgM3nPP3erJ1FR+akrFzrz1RGVRw9BL+wfvS6T7c6hhTfrd N3JaYv05OeBPCzOBgYWJxxO5XJYADMyKewxwIBWArT2B7W4IgHkrvKbBilEz11g2 lEb/GvaPAU7vhatyuDW9XH2i9cR6paG0w9DY2NjMkfN5mTXLzYx/86Ua7/P5rH3a VJy0cqZ6oqpaT9QrDfv3P58e/5+eVz/9nSn9svjtIn8Ctcva95sADMyKmxxwIBWA NU2zuxUAAADzECgiAAOzIAADB1IBeHBwsDQWBAAAUAMMwwiHwwRgYFYEYOBAbAEN AABqDhtBA3NBAAYORAAGAAA1hwAMzAUBGHgdzkACAAC1iJOQgLkgAAOvowJwW1tb by9nIAEAgFqSSCSyWU5CAmZBAAYOpDJwa2tr8YjSZldHR3vD/nNTAAAAqodpmvki 3TCKB21PTU2RfoFZEYCB2alIrMJwc3NTMRO7XG63u6nE7nYBAABHsLKuXmKUzvxW oZe4CywAARhYoANScVtbm4rEjY38nQIAAAtXKBTy1sAuWRcQQGcdKKc3pmIViRkr BgAAb8S4LlB5BGCgEmasK27u6OgoFArqid2NAgAAFaLS7YxBXdbrArYhAAO2sY5c aiqOFjf39HSrmyKTqAEAqGmFQkHd0EtZtzSkaxocTQRUFbraQHVRqdjlcjVZsbg0 XGyapnrF7nYBAIDX0fezBnXV/Vo9J+sCVY4ADNSGUjBuKQXjJut8JuZRAwBQAftn Lxul04bMUtBlUBeoVQRgoLbtD8aNKgyrdNzVtUTdn5lKDQDAvFhTl60BXdO0RnQL BF2g/tBFBuqWpmktLa7SicXWbGoGjQEATjdz2rIKuqV9mPVAIGB3uwBUCAEYcKJS Ni6OG5eycVNnZ6fqATBuDACoA9NjuftX5hbHcks7UZFyARCAAbyeysYuV3PTa5pL 8Zhp1QCAarE/4r42imtRr5ByARwe3VkA82DF48bGptLocTEed3d35fN5lY2ZXA0A KJfiflOvG8JVVOwl4gJYLAIwgHJ6Q0Ju6unp1fW8NcVasbuBAACbmdYeU68Lt+Rb ABVCAAZQaT6f1tzsaiym5FJQbmyy1iGrrpD6KHOtAaBGFSPs/nBbemKWXrDCbcEw 9LExwi0Am9HLBFClZubkxn3DyY3d3d26rquOlPWS3W0EAEeYGWutQFsKtSRbALWH AAyg5pWicnPjPk3Tgdk6FVl1zhoYWAaAGQr7R2b3Z9qZgbYUaoux1iDWAqg/dAcB OI7P55sRmKdHmBunly67XK4GMjOAGjGdZmcupp3xWJgRaMfsbiwA2Iy+HQDMiYrN Lldxp+vp4Lw/PDfO3PTLWtJMcgYwX6WMas4Is/sGY/eH2H3/UZ+p60RZAFggumgA IK405rwvK7+WoF83BP2GCdyMPwO1ozBjr6eZo64zB2D3x9fp8ViTEAsAlUfvCgBq xvCwb38wLj7MfHIoTTMHqUnUQMnMmGq+MaQekFgbXvdEfb7fT3AFgFpFZwgAHM0K 1Q0Nr8XpmY8zhqxfi9kHS90qXbNqGuWxP5Q2TE/6fUMW3ffLGQOq1odmPhb/Q1gF AByAngoAoBKmk/b+gP26tP3G7P3GUe6G6SzeMDONHzgAbsPXVl8ONQB6kMHQA184 8PENr+57kVwKALALHQUAgBONjAxPp2X1RGWzmbHcern0WGhpaZl/rj7w81WBUvzb dxXr+Rsc/NVDUakyn89Pt3P6Rat+6YqvvTg66p9XcQAA6hIBGAAAAADgCARgAAAA AIAjEIABAAAAAI5AAAYAAAAAOAIBGAAAAADgCARgAAAAAIAjEIABAAAAAI5AAAYA AAAAOAIBGAAAAADgCARgAAAAAIAjEIABAAAAAI5AAAYAAAAAOAIBGAAAAADgCARg AAAAAIAjEIABAAAAAI5AAAYAAAAAOAIBGAAAAADgCARgAAAAAIAjEIABAAAAAI5A AAYAAAAAOAIBGAAAAADgCARgAAAAAIAjEIABAAAAAI5AAAYAAAAAOAIBGAAAAADg CARgAAAAAIAjEIABAAAAAI5AAAYAAAAAOAIBGAAAAADgCARgAAAAAIAjEIABAAAA AI5AAAYAAAAAOAIBGAAAAADgCARgAAAAAIAjEIABAAAAAI5AAAYAAAAAOAIBGAAA AADgCARgAAAAAIAjEIABAAAAAI5AAAYAAAAAOAIBGAAAAADgCARgAAAAAIAjEIAB AAAAAI5AAAYAAAAAOAIBGAAAAADgCARgAAAAAIAjEIABAAAAAI5AAAYAAAAAOAIB GAAAAADgCARgAAAAAIAjEIABAAAAAI5AAAYAAAAAOAIBGAAAAADgCARgAAAAAIAj EIABAAAAAI5AAAYAAAAAOAIBGAAAAADgCARgAAAAAIAjEIABAAAAAI5AAAYAAAAA OAIBGAAAAADgCARgAAAAAIAjEIABAAAAAI5AAAYAAAAAOAIBGAAAAADgCARgAAAA AIAjEIABAAAAAI5AAAYAAAAAOAIBGAAAAADgCARgAAAAAIAjEIABAAAAAI5AAAYA AAAAOAIBGAAAAADgCARgAAAAAIAjEIABAAAAAI5AAAYAAAAAOAIBGAAAAADgCARg AAAAAIAjEIABAAAAAI5AAAYAAAAAOAIBGAAAAADgCARgAAAAAIAjEIABAAAAAI5A AAYAAAAAOAIBGAAAAADgCARgAAAAAIAjEIABAAAAAI5AAAYAAAAAOAIBGAAAAADg CARgAAAAAIAjEIABAAAAAI5AAAYAAAAAOAIBGAAAAADgCARgAAAAAIAjEIABAAAA AI5AAAYAAAAAOAIBGAAAAADgCARgAAAAAIAjEIABAAAAAI5AAAYAAAAAOAIBGAAA AADgCARgAAAAAIAjEIABAAAAAI5AAAYAAAAAOAIBGAAAAADgCARgAAAAAIAjEIAB AAAAAI5AAAYAAAAAOAIBGAAAAADgCARgAAAAAIAjEIABAAAAAI5AAAYAAAAAOAIB GAAAAADgCARgAAAAAIAjEIABAAAAAI5AAAYAAAAAOAIBGAAAAADgCARgAAAAAIAj EIABAAAAAI5AAAYAAAAAOAIBGAAAAADgCARgAAAAAIAjEIABAAAAAI5AAAYAAAAA OML/BX0Yiq0T6k2tAAAAAElFTkSuQmCC"/></symbol><use xlink:href="#c" width="1280" height="1280"/></g></g></svg>')} +.is2d .pawn.black {background-image:url('data:image/svg+xml;base64,<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="614.635" height="614.635" viewBox="0 0 460.977 460.977"><mask id="b"><use xlink:href="#a" width="1280" height="1280" transform="rotate(.193) scale(.36014)"/></mask><symbol id="a" viewBox="0 0 1280 1280"><image width="1280" height="1280" xlink:href="data:image/png;base64, iVBORw0KGgoAAAANSUhEUgAABQAAAAUACAAAAAA9j6ArAAAACXBIWXMAAA7EAAAO xAGVKw4bAAA+xElEQVR4nO3dB5RV5b2G8QGlDnUARRBRUbDGgjFiN7GQa4kNQekg KIgGVCygFAVjwa5BRKKCYu8dRRERlGoDRCkCUqRMgRmaIncGQTpM2Xu/3/f9n9/N MusmZnjXyT3PPXN2K5YCAEYVUw8AABUCCMAsAgjALAIIwCwCCMAsAgjALAIIwCwC CMAsAgjALAIIwCwCCMAsAgjALAIIwCwCCMAsAgjALAIIwCwCCMAsAgjALAIIwCwC CMAsAgjALAIIwCwCCMAsAgjALAIIwCwCCMAsAgjALAIIwCwCCMAsAgjALAIIwCwC CMAsAgjALAIIwCwCCMAsAgjALAIIwCwCCMAsAgjALAIIwCwCCMAsAgjALAIIwCwC CMAsAgjALAIIwCwCCMAsAgjALAIIwCwCCMAsAgjALAIIwCwCCMAsAgjALAIIwCwC CMAsAgjALAIIwCwCCMAsAgjALAIIwCwCCMAsAgjALAIIwCwCCMAsAgjALAIIwCwC CMAsAgjALAIIwCwCCMAsAgjALAIIwCwCCMAsAgjALAIIwCwCCMAsAgjALAIIwCwC CMAsAgjALAIIwCwCCMAsAgjALAIIwCwCCMAsAgjALAIIwCwCCMAsAgjALAIIwCwC CMAsAgjALAIIwCwCCMAsAgjALAIIwCwCCMAsAgjALAIIwCwCCMAsAgjALAIIwCwC CMAsAgjALAIIwCwCCMAsAgjALAIIwCwCCMAsAgjALAIIwCwCCMAsAgjALAIIwCwC CMAsAgjALAIIwCwCCMAsAgjALAIIwCwCCMAsAgjALAIIwCwCCMAsAgjALAIIwCwC CMAsAgjALAIIwCwCCMAsAgjALAIIwCwCCMAsAgjALAIIwCwCCMAsAgjALAIIwCwC CMAsAgjALAIIwCwCCMAsAgjALAIIwCwCCMAsAgjALAIIwCwCCMAsAgjALAIIwCwC CMAsAgjALAIIwCwCCMAsAgjALAIIwCwCCMAsAgjALAIIwCwCCMAsAgjALAIIwCwC CMAsAgjALAIIwCwCCMAsAgjALAIIwCwCCMAsAgjALAIIwCwCCMAsAgjALAIIwCwC CMAsAgjALAIIwCwCCMAsAgjALAIIwCwCCMAsAgjALAIIwCwCCMAsAgjALAIIwCwC CMAsAgjALAIIwCwCCMAsAgjALAIIwCwCCMAsAgjALAIIwCwCCMAsAgjALAIIwCwC CMAsAgjALAIIwCwCCMAsAgjALAIIwCwCCMAsAgjALAIIwCwCCMAsAgjALAIIwCwC CMAsAgjALAIIwCwCCMAsAgjALAIIwCwCCMAsAgjALAIIwCwCCMAsAgjALAIIwCwC CMAsAgjALAIIwCwCCMAsAgjALAIIwCwCCMAsAgjALAIIwCwCCMAsAgjALAIIwCwC CMAsAgjALAIIwCwCCMAsAgjALAIIwCwCCMAsAgjALAIIwCwCCMAsAgjALAIIwCwC CMAsAgjALAIIwCwCCMAsAgjALAIIwCwCCMAsAgjALAIIwCwCCMAsAgjALAIIwCwC CMAsAgjALAIIwCwCCMAsAgjALAIIwCwCCMAsAgjALAIIwCwCCMAsAgjALAIIwCwC CMAsAgjALAIIwCwCCMAsAgjALAIIwCwCCMAsAgjALAIIwCwCCMAsAgjALAIIwCwC CJFi69QLAAKIxB1XKfcv+9SaOyf3n9LHqtfAMgKIZDRM+Ue18gekVKy97b81Oyvl x+W/fLJuWPKrYBwBRLyqHnN03bqVDs7f3zwlY9oPE8ZnxrsI+BMBRGwa/mP/A/5S iP9c9o8/Tv/ok8jnANsggIhDwwsOP6Ba0X7ELz989cqn0awBdoAAImJ1L65ffztf 9BXOjHHjXp4T1Q8DtkYAEaG6F596ZBE/+G1rwfhPXp4b9Q8F8hBARKTqJedHH7+N Fox76bWcuH447CKAiMJxF52dzwO9hTfp9Ve/i/vPgDEEEEV2eoeTYvvot6V5Hz46 Ppk/CTYQQBRNx/PPSPTPyxjx4vOJ/oEIGQFEEZze4ULBn7r09f4TBH8sAkQAUVhH dPm/hH7z3dbclx7k7BgUHQFEoVTo1D6yk/0KZ/KDT6/RLoD/CCAK4fQbkv3ib/vS h935tXoD/EYAUVD6D3+bfPfAED4GovAIIArmiB6K4x47tvjlHkvUG+AtAoiCaNLh ZPWEbT33+Aj1BHiKACL/OnaK/XKPwhl951vqCfASAUR+dessO+tl1364/Rn1BHiI ACJ/nM5fnh96D1VPgHcIIPLD+fzl+aHXc+oJ8AwBxK55kb8803qTQBQEAcSueJO/ PNN6casE5B8BxM416eHokd8dGXHzF+oJ8AYBxM4c8Zxn+csz7OLl6gnwBAHEjqUN Pls9oVCyBtz8u3oDvEAAsUP3XK9eUGhzbhukngAfEEDsQJM7nbnlQWF80WqaegLc RwCxXWmvOXjRb4EsH9xJPQHOI4DYnm591QsiMOOGV9UT4DgCiG3VecvDY7/b806T bPUEOI0AYhsD2qsXRGbuPQ+rJ8BlBBBbOf0Jrw9+bG1k44XqCXAXAcSWnm6hXhCx RVe9rJ4AZxFAbC6Yb/8291LrHPUEOIoAYjNBHPzd1o9tRqknwE0EEH9KG1ZfPSEm 2c+Fc1wHUSKA2KjJQx7d9qqgxjWZqZ4ABxFAbBDc0Y8tLez4mnoC3EMAsV7aqACP fmxpSNiFR2EQQOQ5/UP1ggRMPHOpegIcQwCR62Eb9w2Y23q4egLcQgARwJ1f8itj 4I3qCXAKAUSd4UFd+7Zz7124Sj0BDiGA5pn4+m+TcQ3T1RPgDgJo3e23qBckbGaT ceoJcAYBNO5tPx97VBSLrxuingBXEEDT7Bz+2Fz6gG7qCXAEAbQsbaKhwx+be+1C 9QK4gQAaZurw75bearRaPQEuIIB2HWP5YMAX/5ehngAHEECzjJ3+sjUKiBQCaJe5 01+29uOlE9QTIEcAjTLfPwqIFAJoFf3L9cOlE9UTIEYATaJ/61FA8wigRfRvAwpo HQE0iP79adqlk9QToEQA7aF/m6GAthFAc+jfFiigaQTQGvq3lWlNvlJPgAwBNIb+ beP7SymgWQTQlo6Pqhc46NsLp6snQIQAmmL6/gc7NvK8LPUEaBBAS+jfDow8d5l6 AiQIoCFpPBd8R945R70AEgTQDrP3f86PZ5qrF0CBANrxE/3biUeuVi+AAAE041OL zz/Kv8XXPqOegOQRQCuebqFe4LhZl3+snoDEEUAjuvVVL3De5Eu/VU9A0gigDZwA kw/DL+RkGGsIoAlp31dTT/DBC03UC5AwAmgCB4Dz54Eu6gVIFgG0gAPA+bSoy1D1 BCSKABrAAZB8+/ay79QTkCQCGD4OgBTAhxctV09Agghg8LgCrkD+e5V6ARJEAIM3 vr56gVfSu/5PPQHJIYChu+d69QLPTG3JVwZ2EMDA8QVggQ27mK8BzSCAYeMLwEJ4 +Br1AiSFAIbt7bPVCzw0t+Pb6glICAEMGs9AKpRxjWarJyAZBDBk3AO/kLg/tBUE MGScAVNI6dc+rZ6ARBDAgPELcKGNvYRfgk0ggOHiF+AiGNxSvQBJIIDh4hfgIlja mUeEWEAAg8UvwEUyttEc9QTEjwCGil+Ai+ip1uoFiB8BDBU3QS2ihVe9qp6A2BHA QDV5Tr3Ae59duEQ9AXEjgIFaxFOQiuy+69QLEDcCGCYegx6Baa3HqCcgZgQwSEd8 pV4QhFcarVNPQLwIYJCmHKxeEIRl1w5ST0C8CGCIOAISkZEXcRwkbAQwRBwBiUq/ ruoFiBUBDBCPAYnMty34NjVoBDA8XAMSoYHt1QsQJwIYHm6DH6HZ7T5UT0CMCGBw OAUmUi824VSYgBHA4HARcKTmd3hTPQHxIYChOZ1f2aL1RpNV6gmIDQEMDedAR2zZ NTwfJFwEMDCcAx259y7LVE9AXAhgYPgAGLllnYaoJyAuBDAsfACMwbtN+QgYKgIY Fj4AxoCPgOEigEHhA2As+AgYLAIYFD4AxmLZVTwjM1AEMCScAxiTV5tyLmCYCGBI uAgkJvOueEc9AbEggAHhKuDYPNtMvQCxIIABGXaGekGw5rV/Vz0BcSCA4aiQpV4Q sIevUS9AHAhgOAZw7874TG41Xj0BMSCA4eBJIHG6vYd6AWJAAIPRra96QdBGNp+j noDoEcBgcBJ0rLI6DlVPQPQIYCg4CTpmL7XgZOjwEMBQcA5MzOa1e089AZEjgIHg HJjYPdhZvQCRI4CB4BBI7DgMEiACGIifaqsXhK/Nk+oFiBoBDAOXASdgcEv1AkSN AIbhlQvVCwyY0fZT9QREjACGgatAktCrt3oBIkYAg9DxUfUCEz5osUg9AdEigEHg JMBE/Nx2mHoCokUAg7BOPcCIO7qrFyBaBDAEnASYkBEt5qonIFIEMATj66sXGLGo 3ZvqCYgUAQxA1cXqBWY82km9AJEigAHgN+DEfNKS34GDQgADMLqBeoEZiy5/Sz0B USKAAeAYcHL63qJegCgRQP9xFnSC3mvJF64hIYD+4yzoBM1t85F6AiJEAP3HdcBJ 6n6HegEiRAC9d9wY9QJTBrdZq56A6BBA7/E89ERNaDFFPQHRIYDe43GYicps97J6 AqJDAH3HZSAJe+jf6gWIDgH0HSfBJOzdVvy/nHAQQN9xM/yEfd98vHoCIkMAfcfj 4JLW7Fn1AkSGAHqOrwATxwPSA0IAPcedYBL3ccuf1RMQFQLoOb4CTNz3zSaoJyAq BNBzfAWYvKZD1QsQFQLoN74CFHigi3oBokIA/dbkOfUCg15ps0w9AREhgH57qqV6 gUFfNf9OPQERIYB++/ov6gUGZbZ5TT0BESGAfuNu+Aq9eqsXICIE0Gt1p6kXmNS/ o3oBIkIAvcadECTeabVEPQHRIIBe4xiIBEdBgkEAvcYxEAmOggSDAHqN5yFp3Hi3 egGiQQB9xnUgIvddp16AaBBAnzV8T73AqGcvX6WegEgQQJ/dc716gVGjWsxST0Ak CKDPuBeWyNRmE9UTEAkC6DMOAotktn5dPQGRIIA+4yCwyg33qBcgEgTQZ1wJrNL3 FvUCRIIAeuy4MeoFZg26Yq16AqJAAD3GWTAyz7TjPJggEECPDWivXmDWuBbfqycg CgTQY9wKQWZS88nqCYgCAfTY6AbqBWbNv+xT9QREgQB6jNMAZTJav6GegCgQQI9x GqBO137qBYgCAfQYpwHq9LlVvQBRIID+4mZYQvdyH4ogEEB/cRqgECcChoEA+osA ChHAMBBAfzV5Tr3AsBcvX66egAgQQH9xIYjQuOY8kjkEBNBfXAgixKUgYSCA/iKA QgQwDATQX1wJJ8S1cGEggP7iSjihpZcNU09ABAigvwigEAEMAwH0FwEU4m4IYSCA /lq4p3qBZdffq16ACBBAf/EJUIhPgGEggP4igEJ8BxgGAugvAihEAMNAAP1FAIUI YBgIoL84EVqIE6HDQAD9xaVwQlwKFwYC6C8CKEQAw0AA/cXtsIS4HVYYCKC/uCGq EDdEDQMB9Be3xBfilvhhIID+IoBCBDAMBNBjPBdYh+cCh4EAeowA6hDAMBBAjy2q pl5gV9d+6gWIAgH0GNfCyXAzmEAQQI9xLZwMV8IFggB6jEtBZLgQJBAE0GP3XK9e YNaoFrPUExAFAugxTgSU4TTAQBBAjx03Rr3ArEFXrFVPQBQIoM84EVCl7y3qBYgE AfQZJwKq3HCPegEiQQB9xomAIpmtX1dPQCQIoM84D0aEs2BCQQB9xnkwIpwFEwoC 6DPOgxF59nLOggkDAfRZ1cXqBUbdd516AaJBAL3GYWCNG+9WL0A0CKDXOAwskdnm NfUERIMAeo3DwBJfNf9OPQHRIIBe6/ioeoFJ77Raop6AaBBAr9Xl4bQK/TuqFyAi BNBvXA2s0Ku3egEiQgD9xlEQAY6BhIMA+o2jIAIcAwkHAfRbk+fUCwx6pc0y9QRE hAD6jWtBBB7ool6AqBBAz/1UW73AnqZD1QsQFQLouVcuVC8w5/tmE9QTEBUC6DlO hU7cu6343iEYBNBzfAmYuAc7qxcgMgTQd3wJmLRmz6oXIDIE0Hd8CZiw75uPV09A ZAig7/gSMGF8BRgSAug7vgRM2EP/Vi9AdAig96YcrF5gSma7l9UTEB0C6L0B7dUL TJnQYop6AqJDAL133Bj1AlMGt1mrnoDoEED/8WSkJHW/Q70AESKA/ht2hnqBIXPb fKSegAgRQP9xIkyC3mvJUfeQEMAAcF/85PS9Rb0AUSKAARjdQL3AjEWXv6WegCgR wAB066teYMYnLeeqJyBKBDAAXAySmEc7qRcgUgQwBOPrqxcYsajdm+oJiBQBDAG/ AydkRAt+Aw4LAQwCx4GTcUd39QJEiwAGgXOhE/Fz22HqCYgWAQwC50In4oMWi9QT EC0CGAauB05Cr97qBYgYAQwDN8ZPwIy2n6onIGIEMAxHfKVeYMDgluoFiBoBDAQP h4tfmyfVCxA1AhgITgWM3cjmc9QTEDUCGIgKWeoFweOB6AEigKHgVMCYzWv3nnoC IkcAQ3H6h+oFgXupxSr1BESOAAZjxv7qBWFr/ZR6AaJHAIPBYZBYcQgkSAQwHBmV 1AtC9p9u6gWIAQEMB09Ij9HkVuPVExADAhgObgwdo/9epV6AOBDAgHx6snpBsOa3 f0c9AXEggAHhguDYPNtMvQCxIIAh+exE9YJAzb+Sp2GGiQCGhJOhY/JqU06CDhMB DMq0uuoFQcq++in1BMSDAAalyXPqBUF6t2mmegLiQQDD8uMB6gUByr6GGwGGigCG hY+AMeADYLgIYGCm11EvCE+7J9QLEBcCGBg+Akbuvcv4ABgsAhiamfupF4TmisfV CxAbAhgazgWM2BtNOAcwXAQwOF8doV4QlPRrnlVPQHwIYHC4IjhSLzZZp56A+BDA 8HBTmAgt6PCGegJiRADDU32BekFAnm6lXoA4EcAAvX22ekEwZrcfpp6AOBHAEE05 WL0gEMu6/E89AbEigCHibOiIfNg4Qz0BsSKAQeJUmEhkXPOMegLiRQCD1PA99YIg vNM4Rz0B8SKAYRrdQL0gAIs6vaSegJgRwDA1GK1eEIDXGv+qnoCYEcBAfXCmeoH3 fu7wtnoC4kYAA7XXfPUC7w1poV6A2BHAUA1or17guR9a8zVC+AhgqFJ/qqqe4LdH O6kXIH4EMFjd+qoXeG1S06nqCYgfAQxWsan11BM8ln1Df/UEJIAAhuvMD9QLPPZu oxXqCUgAAQzYu/9UL/DW3I6cAmMCAQxYlRkV1RN89WQb9QIkggCG7Jbb1Qs89fVl U9QTkAgCGDTuClMomdcPUk9AMghg0PafoV7gpZcv4UFIRhDAsN1zvXqBh6a2HKee gIQQwLAVn3yQeoJ3sm9+RD0BSSGAgTvwB/UC77x6yVr1BCSFAIbutlvVCzwzuRlP lreDAAZvfH31Aq+kd+VBcIYQwODVmMLp0AUwtKl6ARJEAMPX9gn1Ao+MbTRHPQEJ IoAGvHKheoE35lzJ8/RMIYAGlPiurnqCL66/V70AiSKAFtT5qpx6gh9ebfS7egIS RQBNuHygeoEXxl/EF4DGEEAbhjRTL/DArMs/Vk9AwgigDcXGcTbgrmTc9Lh6ApJG AI2o/F0N9QTXDbpcvQCJI4BW1BtXXj3BbR+ct0Y9AYkjgGZcOlS9wG39bl2lnoDE EUA77rxRvcBlb7Rdqp6A5BFAQ169QL3AXWMvma2eAAECaEjxL49RT3DVT+d9q54A BQJoSflv9lVPcFPm+Z+qJ0CCAJpSe2KaeoKTrurPU5BsIoC2HMPjfrbjrh6cAWMU ATSm2RD1Avc80SVbPQEiBNCaHr3VC1zzantOgDGLAJrz2BXqBW75pOVc9QTIEEB7 Xv+XeoFLJjX+UT0BOgTQnuIjT1BPcMeMRpPUEyBEAA0qNf4w9QRX/NLoM/UEKBFA iypMrKOe4IbMJh+oJ0CKAJpUfQJ3B8y1osUr6gnQIoA27T+2inqCA27sxzOQjCOA Rh05kvuj3nczF4BYRwCtOv819QK1JzrnqCdAjQCa1fFR9QKtFzpkqCdAjgDaZfui uHfbLlRPgB4BNOz+zuoFOiNa8gx0EEDbJhytXqCyoDEnQCOFABr3+fHqBRpzmoxR T4ATCKBpxUaeqJ6gMPtS+of1CKBtu39+rHpC8uY1G6GeAEcQQONKjzN3Y4TFrd5V T4ArCKB1FSYcoJ6QrGVtX1ZPgDMIoHlVJ9ZST0jSiiueUU+AOwggao6vrp6QoB63 qxfAIQQQKQd8YefWMA9d95t6AhxCAJGScvioCuoJCXn8mtXqCXAJAUSu44ycF/fs lTwBGJsjgMjT+Hn1giS80o4bwGALBBDrXf2QekH83m/1i3oCHEMAsd5+M9UL4vfw NeoFcA0BxHoWbo/6Vpsl6glwDAHEeh+fpl4Qv9ktP1VPgGMIIPLsO0u9IAn9uqoX wDEEEHle/5d6QRK+bzFOPQFuIYDI1WC0ekEyHrua60CwOQKIlJTi3x6inpCM9FZv qSfAKQQQKSlDL1UvSMo3Lb5WT4BLCCBSLh+oXpCct1tzKgw2IYA4emSqekKCBnVa pZ4AdxBA8+qOtnMzrDwPdOVACDYigNbVGb2HekLC7r75d/UEuIIAGldvpLX+paT0 6/aregIcQQBt++sHldUTBPpfv0I9AW4ggKa1fUK9QOPFjkvVE+AEAmjZw53UC1RG tvxJPQEuIIB2lX7n7+oJOtObf6GeAAcQQLMOeL+OeoJSZp8HOR0GBNCqq+8op54g 9lJHLgoxjwDalPpyQ/UEvSktx6snQIwAmnTOgBrqCS7IeeA/OeoNkCKABpUa0kg9 wRVjW09RT4ASAbTnvEdqqSe4Y9mDd/Eh0DACaE25oeeqJ7hlYhtuEWgXATTmqp7V 1BOc0797hnoCRAigKUcNrK+e4KKfeg3l9gg2EUBDyg5qop7gqlFtflRPgAIBtKPT rfbufJV/D9+apZ6A5BFAK/7+wOHqCW6be+eg1eoNSBoBtKHG06erJ7jv6xuHrVNv QLIIoAVl771SPcEPw9rNUU9Aoghg+Ip3v6aqeoM3Bt6Urp6ABBHA4F1+S231BJ8s /S+XhhhCAAP3z3sOVU/wzew7/7dGvQEJIYBBO6HfceoJPpp62yucGG0DAQzYUfed qp7gq0ndP+DhwRYQwGDVe4B7nhbBFzd9RgLDRwADVed+bvpSRCNv/JLTAkNHAIO0 7/3nqyeE4OMbJpLAsBHAAFXrf5F6Qig+7PoNCQwZAQzOvn2aqieEZNhNX5HAcBHA wNS591/qCaEZ3pUEBosABqXevWerJ4RoxI3jSGCYCGBAjrjrLPWEUI3sNpoEhogA BuO4O05TTwjZmFtGcF5geAhgIE7rc7x6Qugm9HqXBIaGAAbh/O7HqCdY8PVdL5DA sBDAALS+jju+JGTaQ4+RwJAQQN8V73zV/uoNlswe0I87xYSDAPqtVPe2NdQbrPnl qdtWqDcgIgTQZxXvaJKm3mBR5os3c+P8MBBAf9XteZl6gl0v9J6qnoAIEEBfNbiN B11KDe8xWj0BRUYA/XRe92PVEzC275vqCSgiAuihYpd3PkS9AXmm3D+IK+S8RgC9 U6Jre55z6YzZA+75Tb0BhUcAPVPhtqY85dwpi4f0zFZvQGERQK/U7XF+qnoDtrb8 1d6z1BtQOATQIyf1/Id6Arbvg15fqCegMAigN5pcX189ATv25Z2vqyeg4AigH4r/ u+MB6g3YuakP91dPQEERQB+k3tqyunoDdm3uoP+sUW9AgRBA9+3T8+IK6g3In6XP 9chQb0ABEEDX1e/TUD0BBZD9Zh+uEvYHAXTbOd0aqCegoIb3GaGegHwigA4r1u7f XPLmpQn9nldPQL4QQGeVuqltLfUGFNaPjz7EVcIeIICOqtyHe536bf6TfVapN2BX CKCTDu7ZWD0BRZbx4i1L1BuwcwTQQaf0OlU9AdF4oe+36gnYGQLonMZdueQtIJ/0 +Vg9ATtGAN1S7Kqr66o3IFoT7npJPQE7QgBdUvKmdnurNyB6U+8fqJ6A7SOA7ih3 ezPudRqon/r3+129AdtBAF1Rq/fF5dUbEJ+Fg+7gceruIYBuOOSuc9QTELOlQ3ty owTXEEAXNOjzd/UEJCDrlVsWqDdgCwRQr2HP49QTkJDsd2+eqd6AzRBAtQu7H62e gCS93ne8egL+RAC1mt10qHoCkvZxj8/VE7ABAVRqfx1nPZs0qvdH6glYjwDKFLvy Wp5zZNbo3sPUE5BCAGWKdbxuP/UGKI3pRQL1CKBEsX93rq3eALUve72vnmAeAVTo 0JVPf8j1+a2fqCcYRwCT1/YmvvvDBiOu/k49wTQCmLTLenLkF5t5+9of1RMMI4DJ anjnEeoJcEz2m13nqzeYRQCT1OBenvKLbWU+3z1dvcEoApicuo+coZ4ARy164rbV 6g0mEcCklB9wqXoCHPZTv0fVEywigMko3rMTj/nFTn19y9vqCfYQwEQ068N5z9il D6/kXlkJI4AJOOqxY9UT4IXMwd2z1RtsIYCxKzvwMvUEeGNW30HqCaYQwLi1u31P 9QT4ZGTb6eoJhhDAeO3zAre7R8GkD+yxRr3BDAIYp2J9b1ZPgIe+bfeleoIVBDBG 9Qcfop4ALy1/9joeIpwIAhif+zurF8Bb37Ydp55gAgGMy15v87Q3FF76gO7r1BsM IIAxafZQZfUE+G14y3nqCeEjgLEoPripegK8N/2Kj9UTgkcA41D5I379RdGlP3ib ekLoCGAM6g2vqZ6AMAxtw12yYkUAo3fhU+XVExCK95stVU8IGgGMXKeH1QsQkJHN 5qonhIwARu3ae9ULEJRRTeeoJwSMAEbs6ofUCxCYkZdxOkxsCGC0znlLvQDBefey LPWEYBHASO07qZJ6AsIzqB0XhcSEAEap5HcHqicgQNldnlBPCBUBjNIb56kXIEgz 23FNSDwIYIQufkm9AIEadilPTo8FAYzO7tN59Bti0uN29YIwEcDo9OmuXoBgTWg+ VT0hSAQwMrvP20M9AeHqc6t6QZAIYGS4BAQx+rj5fPWEEBHAyHxzuHoBApbR4QX1 hBARwKjsN1O9AEEbdLl6QYgIYFRu5d6ViNPIFrPVEwJEAKPy9tnqBQjazJaj1BMC RACjMplnACNOyzs8q54QIAIYlaVp6gUI22091QsCRAAjUmqVegEC92Bn9YIAEcCI 7LlQvQCBe6yDekGACGBE+ASImD30b/WCABHAqHDLSsSrX1f1ggARwKhwEATx4iBI DAhgVMbXVy9A0NKveFk9IUAEMCpPt1AvQNC+azFJPSFABDAq7R5XL0DQ3m+xWD0h QAQwKqUXlVdPQMg4BhIHAhiZVy5UL0DAZrYdoZ4QIgIYmdN4cBfi82KL1eoJISKA 0Rn7V/UCBGvxFa+pJwSJAEbn2C/VCxCsZ1r/pp4QJAIYoecbqxcgUNNaj1FPCBMB jFDJb+uqJyBI2Z0HqScEigBGqfZXldQTEKKBV3CpeTwIYKQajFYvQIDebrpMPSFU BDBafx+uXoDgvN98iXpCsAhgxI55v4p6AsLycpvl6gnhIoBRqzm8nnoCArKs/818 /xcfAhi5EkM4GwZR+aEDFxjFiQDG4J8PHaCegCBkv3BDunpD2AhgHIp178L9oVFk o6/8Vj0hdAQwHmVvb0UCUSQTbntTPSF8BDAupbq22U+9Ad5aMeL+j9QbLCCAMTqv Q0P1BHhpzkv3zVdvsIEAxir1qkbHqDfAM7988tQH6g1mEMC4pbU541iuEEY+zfr0 xfc57y85BDABxc761wmHq0fAeUsmffLqNPUIYwhgQkqfe9qRh1ZQr4Cr5n819p3x 6hEGEcAkHXNG/QP/oh4Bxyz5Yeqo4XPVK4wigEkrdvTJRxy4bw31DDhg5dzZU8eN nKOeYRkB1Ej9W/2D99ubK+asypo7Z8Z3477+Xb3DPAIodeCRh+xfs/peXDRixi/z F/z843dfLVTvwB8IoAtSDz1ov1p77Vm1aqp6CeKxbPGiXxbMnjl5Bg/3dQsBdEql gw7YZ+8909IqVS6vnoKiy8zITF+68Oeffpieo56C7SOAjiq93/4196xWpVLlihUq lVOPQf4tz1yWkZm5ZPEvP0+f86t6DHaFAHqgxF619qpetUrlCuXLp5YrX1E9B1vK XJ6TvTw7K2Pp4oUL5ixcq56DgiCA/qm05x7VKleuVLF8+bKpZcuklk7lE2KCsnNW 5axckbNi+fKszIyMxYt+yVQvQhEQwBBUTEurXLlixXLly6WWLlu6TOlcpTiyXGRZ K1evXJX7PytXrsj7iLcsIz1jKbkLCwEMV2qVihUq5TYxtUyZ3CaWKVWqVMlSpcrU Vs9yzy8Za9aszrVqVV7scnJ/oV22LDN9OSfpGUAArSldvly5cqnlypYtk9vE3E+K uVUs9w/1qORM+WHt6jV5qcv9cLci94Nd7j+Wr+D2K2YRQKTceaN6QXKGt+HKM2xC AGEqgJ+0IoDYhAAi5f7O6gXJGdVilnoCHEIAkdKzl3pBcj5sPU89AQ4hgEgZ0ky9 IDmTmk5VT4BDCCBSPj1ZvSA5cxp/oZ4AhxBApPxk6dzAC19TL4BDCCCKm7p89aa7 1AvgEAKIw79RL0jSQ5057Rl/IoBoP0C9IEmvXp6hngB3EEA83Em9IEmft5ipngB3 EEC8+0/1giT9cOlE9QS4gwBi6kHqBUla1vRt9QS4gwCaV8zYbZ+69lMvgDsIoHnH jFMvSNYjnU2d9oOdIoDmdblPvSBZb16+WD0BziCA5j3VUr0gWeObTVNPgDMIoHmj G6gXJGtBs4/VE+AMAmje4qrqBQnr9Kh6AZxBAK2rM129IGl3G7oBNnaBAFp3ZX/1 gqS93J6L4bABAbRuUBv1gqSNbfajegJcQQCtG3OcekHSFjblKAg2IIDWZVVQL0jc NQ+rF8AVBNC4Y79UL0jeQ9dyLQj+QACNu+V29YLkPd1KvQCuIIDGvXGeekHyJh2t XgBXEEDjTD0QaaMyq9QL4AgCaNte89ULFP71pnoBHEEAbbvqEfUChf4d1QvgCAJo 2wuXqBcojP+regEcQQBtm7mfeoEEXwLiDwTQtFpz1As0Ln1evQBuIICmdb1bvUDj mebqBXADATTN1hMxN5m1v3oB3EAATVtSRb1ApN4P6gVwAgG07NRP1AtUehi8AhDb QQAte+wK9QKVUSepF8AJBNCyaXXVC1Sy91yhngAXEEDD9p2lXqDT+in1AriAABrW q6d6gc4756gXwAUE0LCJR6kX6GTuuUY9AQ4ggHbZvBPMRi0HqxfAAQTQrp691AuU +B0YKQTQsklHqhcoLauZrZ4APQJo1oHGL4bo8oB6AfQIoFkPXqNeoDWxvnoB9Aig WbP2VS8QO3SKegHkCKBVDd9TL1D771XqBZAjgFa9ea56gdrCmr+rJ0CNABpVIUu9 QK/Nk+oFUCOARt1xs3qBHodBQABtKja7lnqCA07+TL0AYgTQplb89pfrtQvVCyBG AG2yfB+ETbIPXKieAC0CaNJJI9UL3DCwvXoBtAigSSO5I/x6mXXS1RMgRQAtqj9e vcAVj1ytXgApAmjRR/9QL3DF0gMz1BOgRAAN4gPgJo+bfTAe8hBAg/gGcJPMgzkQ bBkBtOeUEeoFLhnaVL0AQgTQnvFcAbaZnL9OVU+ADgE057Jn1QvcMoovBAwjgNYU m76/eoJjLnlJvQAyBNCaHr3VC1zzw0Hr1BOgQgCNSZtRST3BOXfdpF4AFQJozDv/ p17gnqVHzVVPgAgBtIUngWzPyFPUCyBCAE3ZfRpHQLanY3/1AmgQQFMGcPun7fr5 MB6RYhMBtISLgHfk/X+qF0CCABpSfPJB6gnO4pdgmwigIfwCvGPzj1ysngABAmgH N0HYGa6IM4kAmlF62j7qCU67o7t6AZJHAM14+2z1Ardlnj5BPQGJI4BWdHxUvcB1 Px6drZ6ApBFAI+p8VU49wXnDT1cvQNIIoA2lvjtAPcED/bqqFyBhBNCG989SL/BB 1kXD1ROQLAJown+44VO+zD1xjnoCEkUALTjnLfUCX3x97Br1BCSJABpQ8+sq6gne +PBM9QIkiQCGr/Q3B6oneKR/R/UCJIgABq/YyBPVE3ySfe1A9QQkhwAG76WL1Qv8 ktH8HfUEJIYAhu7+zuoFvll4DtfEmUEAA9f5fvUC/8w6lZNhrCCAYTv3TfUCH00+ KUM9AckggEE75HOeAlwYE09aoZ6ARBDAkO07tpp6gqfGnPi7egKSQAADVn1CDfUE b404Tb0ASSCA4ao8YT/1BI/xnDgTCGCwUifUU0/w2usXqBcgfgQwVKW/OEI9wXND m6oXIHYEMFClxxypnuC9e25QL0DcCGCYSn5+jHpCAChg8AhgkOhfNP7TTb0A8SKA ISox8jj1hEBQwMARwACV/JT+RYXnJIWNAIaH33+jdN916gWIEQEMTulR9dUTgvL8 peoFiA8BDA3nv0TtjfPVCxAbAhiY1NF/UU8IzjvnqBcgLgQwLOXHHKqeEKAPGqoX ICYEMCgVvzhIPSFIH52hXoB4EMCQVP6SB2DGg7tjBYoABqTKOO5/FZdRJ69TT0AM CGA49vyytnpCwD4/7Vf1BESPAAaj5uh91BOC9sXJFDA8BDAUNb+sqZ4QuLGnrFJP QNQIYCD2+WIv9YTgjT81Rz0BESOAYdj/8+rqCQZMPCVbPQHRIoBBqDN6D/UEEyad TAHDQgBDQP+SQgEDQwADQP+SQwHDQgD9R/+SNPH41eoJiA4B9F6tsRz/SNIXx3NN SDgIoO+qTailnmDMyFPUCxAZAui5ihPqqCeYM+ws9QJEhQD6LXXsIeoJBr35L/UC RIQAeq3kF0epJ5g0sL16AaJBAH1WbMTJ6glGXTlAvQCRIIA+e76xeoFVmc3eUU9A FAigx+66Qb3ArkX/nKiegAgQQH+1fUK9wLLZJ81VT0DREUBv/XWseoFtk4/iBqn+ I4C+qv5NNfUE43hUXAAIoKdKfMUJgGr3XadegKIigJ56+2z1Aiw/+zP1BBQRAfRT 5/vVC5CSMveopeoJKBoC6KV636sXIM/nJ6oXoGgIoI9KTDlAPQHr3d5DvQBFQgB9 9GIj9QL8IfOEKeoJKAoC6KFGL6oXYKNv/6JegKIggP4pO51HALvj7hvVC1AEBNA/ r52vXoBNso6eqZ6AwiOA3mn4nnoBNjfmePUCFB4B9E3xaRwBdkuHx9QLUGgE0Dd9 u6kXYEs/11mjnoDCIoCeqTKrvHoCtvJAF/UCFBYB9Myb56oXYGuZhyxQT0AhEUC/ HDdGvQDbGtpUvQCFRAD98hkXnzoo52DuDu0pAuiVE0apF2B7nrtMvQCFQwC9wgdA N/ER0FcE0Cd8AHTV85eqF6BQCKBP+ADoqpwDORDsJQLokWPGqRdgRx7tpF6AwiCA HuE2gO5aXOM39QQUAgH0R/kFqeoJ2KEuD6gXoBAIoD/u5M5zDpvKY0p9RAC9UWzO 3uoJ2Il/vq9egIIjgN5o+ZR6AXbmlYvVC1BwBNAbnAPjtsw9flVPQIERQF+k8Qxu x7UfqF6AAiOAvujWV70AO/fRGeoFKDAC6ItJR6oXYBcqLlMvQEERQE/sx7PHnHfT XeoFKCgC6Il7rlcvwK6MPEW9AAVFAD3xzeHqBdiV7Kqr1RNQQATQD1UXqxdg15o/ o16AAiKAfvg3V5p64MXG6gUoIALoh3f+T70Au7aghnoBCogAeqHY0srqCciHv41V L0DBEEAvnPmBegHyo3cv9QIUDAH0wr3XqhcgPz5oqF6AgiGAXhh5knoB8mPRnuoF KBgC6INi6ZXUE5Avf/lWvQAFQgB9wOMwfdHtP+oFKBAC6IO+3dQLkD+vXqRegAIh gD7gLEBfTD5MvQAFQgB9MHM/9QLk026/qxegIAigB0qvVC9Afp0wWr0ABUEAPXAW zxvzBvcE9AsB9MBtt6oXIL+ev1S9AAVBAD3w6gXqBcivLxqoF6AgCKAHJhytXoD8 WriXegEKggB6YHFV9QLkW+oK9QIUAAF0X6UM9QLk34mfqxegAAig+zgI7JPOD6oX oAAIoPtu4MwKjzzaSb0ABUAA3fd4O/UC5N/rHLL3CQF039tnqxcg/8Ycr16AAiCA 7ht3jHoB8m/GAeoFKAAC6L6faqsXIP+yy6sXoAAIoPvWqQegIKotUS9A/hFA5+01 X70ABcGjMX1CAJ130kj1AhREkxfUC5B/BNB5zYaoF6AgrrtPvQD5RwCdx3nQfrnr JvUC5B8BjN5ue5Srd2jGokWLl2ZGcX/0ftdF8EOQmCfbRPWTdktL22PPPcp9NX35 Eg6ExYQARqj0UafXql659LqUYrU2PiB7eU7O8uVZmUuXLl68cHF6xtpC/NTBzaPc iLi9cX5h/5O7VU6rtle1alWqVKpYoVxqarkN//K8ebnv0pVL508f9j0PHIkaAYzG wSccVa9urV3/fdkbg7hk0S+L0jN/zcePfuucIq9Dgj7+R37/zrzgVd+jal7wypcv 92fwdmLq9CnjP19QlHXYEgEssopnnHrEYZUK+R/OXrF8ycKFk35akpm9Ys2a7f6i 88mphd+G5I39247/vZIly5SrWGXfo/aqXq18amHPmJ7/9fgPx/xWyP8wtkQAi6T4 eeedeGDRf8yy7OVZS5fM/2RWzspVv/62PoPF/owhV8L5ZatHA2/4L3L3EqXKlK19 cq1qVXM/7RX2/11usmzyiJcmFfmngAAWwb6XnV6/QpQ/cOaczMkzflmSmbP6993X ZG0s4NSDovwzELfZ+27xv5Yr83tKybIVqu5R5/CK+9SL8g+a9/kbr3P76SIigIVU sn3zY2P4sTkrcrLSM39ML5FT5rflOXMyVq78dSJPmfBKepXcv5QqW6ZMmcq1UiuU LLtuRYU6ldMqliv0r7w7sXj4wI+j/6mWEMBCObf13yvG+fMz11Ve/09ZWVkrz4zz D0L0WpUpX6Vq5UoVK1Za/yyXZWtL5OPwRqHNfPXhOTH++NARwIIrfk2HuuoNcFdO arJ/3rJPb/062T8xIASwwG64em/1BGALH97wlXqCpwhgAbXvxt354J63rp2unuAl Algghz5dXz0B2J4lz/RYrt7gIQJYEI9cpV4A7MjkDp+pJ/iHAOZfvdc5Iw8OWza4 6yr1Bt8QwHy74Ik09QRgp4a34ZSYgiGA+dWrp3oBsCuT249WT/ALAcynyunqBcCu LWz3tnqCVwhg/hw8Rb0AyJc7b1Yv8AkBzJczP1AvAPLpnQvyc5tJrEcA86N3D/UC IN+mnM49U/OLAO5aiUHclB4+WXzSNPUEXxDAXSrxv2bqCUCBLD2BAuYPAdwVPv/B PxQwnwjgLtA/+IgC5g8B3IXH26kXAIWw5Mh56gk+IIA7lfZoY14heGneZSPVEzzA 23un7rlevQAopGWVeY76LhHAnfnXY9XVE4DC+qKBeoH7COBO7PPsieoJQOHdfKd6 gfMI4E70v1K9ACiKvTkQsgsEcMca9a+ingAUxddHqhe4jgDuUO2hx6snAEVzax/1 AscRwB0a0F69ACiidQfOUE9wGwHckQsGVFNPAIpqwjHqBW4jgDtQeWhD9QSg6Bq9 rF7gNAK4Az16qxcAEVhYY516gssI4PYdPIQnoCMID3RRL3AZAdy+B/6tXgBEo3Km eoHDCOB2nTGolnoCEI2P/6Fe4DACuF2cAoNw1OZp6TtEALen0WNp6glAVL47XL3A XQRwO1KHnqeeAESnIU913RECuB233K5eAERoQU1OhdkBAritWs+crJ4ARKnLA+oF riKA2+rZS70AiNTi6twcevsI4DZqP3uCegIQrRvvVi9wFAHcxs13qBcAEZtXi28B t4sAbi3t6XPUE4CotXpavcBNBHBr5wzkQUgIzti/qRe4iQBu7bEr1AuA6O0/S73A SQRwK4c9fbR6AhC9/h3VC5xEALfS7zr1AiAOvNW3h1dlS3976iD1BCAOzzRXL3AR AdxS17t4RRCkufuoF7iIt/uW7rpBvQCIB+/17eBF2dKD16gXAPGolKVe4CACuIVT /re/egIQj9cvUC9wEAHcwg13qRcAMZm3t3qBgwjgFu68Ub0AiAtv9m3xmmzh/s7q BUBcyuWoF7iHAG7u8MFHqicAcflfW/UC9xDAzTV6vJJ6AhCXb/+iXuAeAri5225V LwBik1NOvcA9BHBz91yvXgDEh3f7NnhJNtf/SvUCID48IX0bBHAzfx3MnRAQsFcv Ui9wDgHcTLPHy6gnAPGZU1u9wDkEcDN9uqsXADFaV1y9wDkEcDPcCgZh4+2+NV6R zXAdCMJWYbl6gWsI4CZHDjlMPQGI09Cm6gWuIYCbNH28rHoCEKfpB6oXuIYAbsJ1 IAjcilT1AtcQwE04BoLQ8X7fCi/IJlwIh9Dt9rt6gWMI4J/2H3yCegIQr7u54++W COCf/m9QdfUEIF6jTlIvcAwB/BPPA0HwFu6lXuAYAvgnLoRD+HjDb4nX408cA0H4 OAqyJQK40W5PtFJPAOL2t7HqBW4hgBvVH3KwegIQt5cuUS9wCwHc6OInKqonAHH7 7nD1ArcQwI1uvU29AIhdZmX1ArcQwI3uuFm9AIgf7/gt8HJs9N8O6gVA/Pb7Sb3A KQRwg7SnzlVPAOLX5kn1AqcQwA1OGsIDY2DA8NPVC5xCADdoOpAnwsGAmXXUC5xC ADfo3UO9AEhAdnn1AqcQwA3aPswnQBgw4wD1AqcQwA169VQvABLAJ8AtEMAN7uRO kTCBt/zmeDU2IICwgbf85ng1/rDP06eqJwBJ6N1LvcAlBPAPRwz+i3oCkIRnm6kX uIQA/uHUZ2qqJwBJ4LEgmyOAf+A8aBgxdx/1ApcQwD/cfot6AZAM3vOb4cX4AweB YQXv+c3wYvyBAMIK3vOb4cVYr9ZTf1dPAJLRk3ufb0IA1zts8FHqCUAynmqtXuAQ ArjeCUP2U08AkvHhmeoFDiGA6100iEfCwYjJh6kXOIQArtetr3oBkJD0KuoFDiGA 6/FIONjBm34TXov1OAsGdvCm34TXIk/VJ89RTwCS0uEx9QJ3EMA8+w8+QT0BSEq/ ruoF7iCAeY4acqh6ApCUFxurF7iDAOY55Zm91ROApHx2snqBOwhgnsZPlFNPAJLy Qz31AncQwDy3cnUk7FheQb3AHQQwD6cBwhLe9X/ipchDAGEJ7/o/8VLkqvLkueoJ QHLaD1QvcAYBzLXf0zwnBobcdZN6gTMIYArPxIQxQ5uqFziDAOY6e9Ce6glAcsYc r17gDAKYq8u9vAwwZPa+6gXO4J2fq2cv9QIgQStS1QucQQBz9e2mXgAkibf9RrwS KZwGCGt422/EK5FCAGENb/uNeCVSUvZ+mocCwxQeDbwRAeRugDDnpUvUC1xBAFNS zvlfNfUEIElj/6Ze4AoCmJLS5T71AiBRs/dVL3AFAeRugDAnu7x6gSsIYErK7beo FwDJ4n2/AS8E50HDHt73G/BCpKT06a5eACSL9/0GvBB8AoQ9vO834IVI2ePJ/1NP AJLV+UH1AkcQwJS6Q45VTwCS9d+r1AscQQBT/vbMAeoJQLLePVu9wBEEMOX8/1VW TwCS9c0R6gWOIIApN9+hXgAkLL2KeoEjCCBnwcAg3vh/4HXgLBgYxBv/D7wO1Z9s qJ4AJO36e9UL3EAADxr8V/UEIGmPX6Fe4AYCmHLYNTX33jtNvQJIys9z587ge58/ EMAN6p13QO29a1ZSzwDiM3/u3JlTn1KvcAoB3NIh59apXZMOIizz5/486/tB6hUu IoDbdcg5dfapwe/F8N3PeeV7Ur3CYQRwp05tUqPG3nuqVwAFlL1gwc+zuNHvrhHA /Dj+gr33rl6jrHoGsCuL58+fO+Nu9Qp/EMACOOrMfWvWqLGXegawjayFC+fP+ZGv +QqKABbCsQ33qVl9L34zht7yXxYumDPzv+oZ3iKARXDsWTVr7Fltj1T1DtizeNEv C3/+qb96hvcIYBROO2uv6tWqV+fFRMwyFi9aNH/OPeoZ4eA9G6nTz6q2xx5p1cqp dyAsixYvXbTw57vUMwJEAOPR4OTqe1atklaVFKLQFi1dunTRgrlPqHeEjADGrUGD PapXS0tLq6oeAi8sy0jPWLJowbyn1UNsIIAJOuW4qtXSKleqWJnPhdjCkvTMrPQl i+cPVA8xhwCKnHZs1SqVKleoWIl7k9u0LCtrWWbm0iULH1cvMY0AuuCs+pUrp1Uo X75chYrqKYjNimXZy5cvy0xPX8xpe84ggO4567BKlSpVKFe+XGp5nlfns+XLc7Jz m5eV2zx+t3UUAXTfuYeVr1ihXLnU1LJly3KjLndlZ69ckbMiN3lZWRmPqscgfwig jy6sV7ZC+dwglilbukzZsmXUcyzKylm5asXKFStycn+rzSJ33iKAAbhwv9TyuTUs UzpXqVKly5Tnv9WIZa9ctXr1qlWrV+ZWL/cjXvZj6kGICG+VgDWumfcJsUxuFHOz WLJUyZIlS3MCzo7lrFqTa3WeVatX5X7Cy1nBtbahI4BGXbxH6dJl8j4w5oWxRKkS JUvk2r1EqXBverhiza+5flvz65pfV/+aG7o1uZVbtXLlCu6XbBkBxI40rlimVG4Z S5XIq+PuJXffrUSJ3XYvkftPu63/x+4ufPe4cu2va/P+sSb3r7+t/fXXtbmB+y03 cb+uzs3c6lUruZ4CO0UAEZXWpUoXL5VSbLfdcv+Parfdc/9SfPfif/w76/78e/78 v7d1W/8L2/H7b7/n/o2/rc39y9q161JW/75qLaeTIFIEEIBZBBCAWQQQgFkEEIBZ BBCAWQQQgFkEEIBZBBCAWQQQgFkEEIBZBBCAWQQQgFkEEIBZBBCAWQQQgFkEEIBZ BBCAWQQQgFkEEIBZBBCAWQQQgFkEEIBZBBCAWQQQgFkEEIBZBBCAWQQQgFkEEIBZ BBCAWQQQgFkEEIBZBBCAWQQQgFkEEIBZBBCAWQQQgFkEEIBZBBCAWQQQgFkEEIBZ BBCAWQQQgFkEEIBZBBCAWQQQgFkEEIBZBBCAWQQQgFkEEIBZBBCAWQQQgFkEEIBZ BBCAWQQQgFkEEIBZBBCAWQQQgFkEEIBZBBCAWQQQgFkEEIBZBBCAWQQQgFkEEIBZ BBCAWQQQgFkEEIBZBBCAWQQQgFkEEIBZBBCAWQQQgFkEEIBZBBCAWQQQgFkEEIBZ BBCAWQQQgFkEEIBZBBCAWQQQgFkEEIBZBBCAWQQQgFkEEIBZBBCAWQQQgFkEEIBZ BBCAWQQQgFkEEIBZBBCAWQQQgFkEEIBZBBCAWQQQgFkEEIBZBBCAWQQQgFkEEIBZ BBCAWQQQgFkEEIBZBBCAWQQQgFkEEIBZBBCAWQQQgFkEEIBZBBCAWQQQgFkEEIBZ BBCAWQQQgFkEEIBZBBCAWQQQgFkEEIBZBBCAWQQQgFkEEIBZBBCAWQQQgFn/D0mQ GKZW59+EAAAAAElFTkSuQmCC"/></symbol><g mask="url(#b)"><g transform="rotate(.193) scale(.36014)"><symbol id="c" viewBox="0 0 1280 1280"><image width="1280" height="1280" xlink:href="data:image/png;base64, iVBORw0KGgoAAAANSUhEUgAABQAAAAUACAIAAACXhmigAAAACXBIWXMAAA7EAAAO xAGVKw4bAACylElEQVR4nOzdi3dc1WHof1mS9bSMeZiYtNRNCaFNAvySxpfmUqdN 6kBKkybkSYFSei9r3ZW/9t4ATsDS6GlZr5E0b817fkdWSii25Rl59pkzcz6flUUJ Hu2z09ixvt777H1uDAAAAFLg3KAnAAAAAHEQwAAAAKSCAAYAACAVBDAAAACpIIAB AABIBQEMAABAKghgAAAAUkEAAwAAkAoCGAAAgFQQwAAAAKSCAAYAACAVBDAAAACp IIABAABIBQEMAABAKghgAAAAUkEAAwAAkAoCGAAAgFQQwAAAAKSCAAYAACAVBDAA AACpIIABAABIBQEMAABAKghgAAAAUkEAAwAAkAoCGAAAgFQQwAAAAKSCAAYAACAV BDAAAACpIIABAABIBQEMAABAKghgAAAAUkEAAwAAkAoCGAAAgFQQwAAAAKSCAAYA ACAVBDAAAACpIIABAABIBQEMAABAKghgAAAAUkEAAwAAkAoCGAAAgFQQwAAAAKSC AAYAACAVBDAAAACpIIABAABIBQEMAABAKghgAAAAUkEAAwAAkAoCGAAAgFQQwAAA AKSCAAYAACAVBDAAAACpIIABAABIBQEMAABAKghgAAAAUkEAAwAAkAoCGAAAgFQQ wAAAAKSCAAYAACAVBDAAAACpIIABAABIBQEMAABAKghgAAAAUkEAAwAAkAoCGAAA gFQQwAAAAKSCAAYAACAVBDAAAACpIIABAABIBQEMAABAKghgAAAAUkEAAwAAkAoC GAAAgFQQwAAAAKSCAAYAACAVBDAAAACpIIABAABIBQEMAABAKghgAAAAUkEAAwAA kAoCGAAAgFQQwAAAAKSCAAYAACAVBDAAAACpIIABAABIBQEMAABAKghgAAAAUkEA AwAAkAoCGAAAgFQQwAAAAKSCAAYAACAVBDAAAACpIIABAABIBQEMAABAKghgAAAA UkEAAwAAkAoCGAAAgFQQwAAAAKSCAAYAACAVBDAAAACpIIABAABIBQEMAABAKghg AAAAUkEAAwAAkAoCGAAAgFQQwAAAAKSCAAYAACAVBDAAAACpIIABAABIBQEMAABA KghgAAAAUkEAAwAAkAoCGAAAgFQQwAAAAKSCAAYAACAVBDAAAACpIIABAABIBQEM AABAKghgAAAAUkEAAwAAkAoCGAAAgFQQwAAAAKSCAAYAACAVBDAAAACpIIABAABI BQEMAABAKghgAAAAUkEAAwAAkAoCGAAAgFQQwAAAAKSCAAYAACAVBDAAAACpIIAB AABIBQEMAABAKghgAAAAUkEAAwAAkAoCGAAAgFQQwAAAAKSCAAYAACAVBDAAAACp IIABAABIBQEMAABAKghgAAAAUkEAAwAAkAoCGAAAgFQQwAAAAKSCAAYAACAVBDAA AACpIIABAABIBQEMAABAKghgAAAAUkEAAwAAkAoCGAAAgFQQwAAAAKSCAAYAACAV BDAAAACpIIABAABIBQEMAABAKghgAAAAUkEAAwAAkAoCGAAAgFQQwAAAAKSCAAYA ACAVBDAAAACpIIABAABIBQEMAABAKghgAAAAUkEAAwAAkAoCGAAAgFQQwAAAAKSC AAYAACAVBDAAAACpIIABAABIBQEMAABAKghgAAAAUkEAAwAAkAoCGAAAgFQQwAAA AKSCAAYAACAVBDAAAACpIIABAABIBQEMAABAKghgAAAAUkEAAwAAkAoCGAAAgFQQ wAAAAKSCAAYAACAVBDAAAACpIIABAABIBQEMAABAKghgAAAAUkEAAwAAkAoCGAAA gFQQwAAAAKSCAAYAACAVBDAAAACpIIABAABIBQEMAABAKghgAAAAUkEAAwAAkAoC GAAAgFQQwAAAAKSCAAYAACAVBDAAAACpIIABAABIBQEMAABAKghgAAAAUkEAAwAA kAoCGAAAgFQQwAAAAKSCAAYAACAVBDAAAACpIIABAABIBQEMAABAKghgAAAAUkEA AwAAkAoCGAAAgFQQwAAAAKSCAAYAACAVBDAAAACpIIABAABIBQEMAABAKghgAAAA UkEAAwAAkAoCGAAAgFQQwAAAAKSCAAYAACAVBDAAAACpIIABAABIBQEMAABAKghg AAAAUkEAAwAAkAoCGAAAgFQQwAAAAKSCAAYAACAVBDAAAACpIIABAABIBQEMAABA KghgAAAAUkEAAwAAkAoCGAAAgFQQwAAAAKSCAAYAACAVBDAAAACpIIABAABIBQEM AABAKghgAAAAUkEAAwAAkAoCGAAAgFQQwAAAAKSCAAYAACAVBDAAAACpIIABAABI BQEMAABAKghgAAAAUkEAAwAAkAoCGAAAgFQQwAAAAKSCAAYAACAVBDAAAACpIIAB AABIBQEMAABAKghgAAAAUkEAAwAAkAoCGAAAgFQQwAAAAKSCAAYAACAVBDAAAACp IIABAABIBQEMAABAKghgAAAAUkEAAwAAkAoCGAAAgFQQwAAAAKSCAAYAACAVBDAA AACpIIABAABIBQEMAABAKghgAAAAUkEAAwAAkAoCGAAAgFQQwAAAAKSCAAYAACAV BDAAAACpIIABoM9m5+Y+//tr57/+5gv/8KhSiW9OAIAABoBezc3NjX2WtZ1j0f89 Nz7+2GOPnWG06MsLhUKn3T4e5Nzd35fP/fF3Z4UMAP0lgAHg/k4Wck9CN8rU8XPn Lp4pcR9F9NxiodDudM79VxVH/+jo6CjmaQDAaBDAAPBHc3Nzx7l7d1F3fHw8/tzt RjS3fD4/dpLEd6vYQjEAdEkAA5BeJ8UbJWX02+Fjly4NejpndLyJOp/v/NcOaj0M AA8igAFIkdnZ2eNV004n+uvZXtlNvpNd0527/xnH9DAAfI4ABmDE/Sl6h3mZ92xO FoeP/04MA4AABmAkzd49qDmd0fsgn4/h6O+rTtICIH0EMACj46R7o9/bknl+VXIc b5MuFk8ucLIsDEB6CGAAht5x91rsPZPPLwsrYQBGngAGYFiddO+5QVzPO3pOblc6 /rZACQMwugQwAENG9wb1xzVhh2YBMIoEMADD4bNzrexzjsdxCRcKJ3+vhAEYDQIY gESbmJiYmp6O/mZUr+1Nvj9eLDw21qjXm83moKcDAGcngAFIKFudE8VxWQCMAAEM QLJY8k04C8IADC8BDEBSWPIdIp+dlVWv1Vqt1qCnAwBdEcAADF6UvuPnzi1cvDjo idCzKIOjGLYvGoChIIABGKQofaPfiiz5DrvjfdHFYvRXGQxAkglgAAbjZMOzO41G yWevB8tgAJJJAAMQN+k72mQwAIklgAGIj/RNDxkMQAIJYADiIH3TSQYDkCgCGICw pC8yGICEEMAAhOKEZz6v3W6XS6W2k6IBGBwBDED/SV8epNPplIrFarXaarUGPRcA UkcAA9BPk5OT09PTCxcvDnoiJFoulzt37pylYABiJoAB6BsLv2N3Vzi7/3AUgeFm knz5fH7Mi8EAxCjVv+8C0C/HJ12NjT2WpvQtFYsnqX/56aejvz55+fLMzEz0N197 4YUHfUmj0chms9Vq9eTfRqm8tbkZRXC9Xi8VCtE/yedy0V8r5XJ6/hDh+HysYrFm RzQAsRDAADySlOx5brXbc3Nzly5dOgndUyr3vo5ffC2V9vf3u1wfjj52Z3OzUa8X C4VyuVyr1Wamp8808eFgRzQA8RDAAJzdqO55Plndvfz001HuPn7p0rNXrz7KaM1m M5vNHh0dPcogURJnd3ejGI6SOJ/LRaNdHLk/dCjk865KAiAoAQzAWUxOTk5NTY1S +rba7ctPPfX4k09+5a/+6qnLl/s17MnCb7vd7teAJ6IejjJ4b3e3VDh2svt6BJxc lVSr1ZrN5qDnAsAIEsAA9GxkFn7Hx8cvP/30nz377J/9+Z/Pz8/3d/BWqxWlb7lc 7u+w94piuFqt7u/tHezvF/L58+fPh35iaA7HAiAQAQxAD0bgsKtatfrMl7985c/+ 7LmvfrXv0fuZSqWSzWbjP9gpiuGjo6Odra3Dg4PDw8MLwf4DhnZyXbClYAD6SwAD 0K0oF4f3sKup6ekvXbnywl//dR+3N99Xu93e398vlUpBn9KNqCFzh4d3NjcLudz4 +Pigp3MW+VyuXq87IBqAfhHAADzc8L7xG3Xvs3/xF1//5jfDLfZ+3tHR0d7eXtKC LSrhSqVye319f29vYmJi0NPpzfHJWJ1Oo9GwFAzAoxPAADzEML7xG3P3jt1d+D04 OCgWi/E87myOS7hcvr2xMXQlHGVwvV7XwAA8IgEMwAMdL/xOTw/RdTvj4+Nfee65 OLv3RLVa3dvbG6I8OynhjfX1vZ2dqampQU+nK+4KBuDRCWAA7u/4vKtO57FLlwY9 kYerVat/8Zd/+eLLL4d+v/dex+/Z3hXzc/ul3W4fHhxsrK3tZ7MXLlwY9HQeIvr/ drFYrDsZC4CzEsAA3MewnHcVzfOFr3/9ay+8MJCn1+v1vb296K8DeXp/tVqtzY2N O5ubyf/O4PhkrEajpYEB6F3yf5sDIFZDcd7VAJd8T5wsRR4cHER/M5AJBPLHBeHV 1ez+/kKCF4SPT8ZyUTAAvRPAAPxJ8s+7OnnL99orrwxwDs1mM5vNHh0dDXAOoTUa jaVbt/Z2dqanpwc9lwcqFAq1ajVpZ24DkGQCGIA/mr9wYWFhYdCzeKCp6elvvvTS oHY7f6ZcLkf12263BzuNeERtubG2trmxMTk5Oei53F/+7unQtkMD0CUBDMDxtufp 6enEvvQ7Pz//3b//+0Htdv5MFL37+/ulUmmw04hf9B88u7eXWVwcP5fEbxucDg1A 95L4OxkAcYrq9/zU1GOJ3PackPQdG8KLjvouyRnc6XRKxWLVdmgAHiZxv4cBEKfE vvSbnPQd9ouO+uuPGXzr1vj4+KDn8kWFQsENSQCcTgADpFcyX/pNTvqO3T0Lam9v r1arDXoiyXKcwbu7x6vBCcvgfD7fqNc1MAAPIoABUiqBN/0mKn0jxWJxf39/xC46 6qMog/d2d5cTlsHHtwTX6/ZCA3BfAhggdRJ45FVUUP/f3/7twE94/szxCmc2Wy6X Bz2RIdBsNtdXVzfW12cSc2FS1MBjjsUC4H4EMEC6JO3Iq1q1+q1r1156+eVBT+RP arXa7u6ubbQ9aTQamVu3NtbWEvI++cmxWP4IA4AvEMAAKZKo+o365Lnnn//+jRuD nsifRNWUz+cPDw8HPZFhVT06uvnhh1EMn0vASdGOhgbgXoP//QmAeExMTExPTydk gW5qevoHN25cevzxQU/kT6JM2tvbOzo6GvREhlu73d7Z3s7cunX+/PlBz+WYo6EB +DwBDJAKybnuqFatfvf69eS87nuiUqlE9RvF26AnMiKi4FzJZFaXly8m4FVzDQzA ZwQwwOhLznVHl59++n9evz47OzvoifxJp9M5PDzM5/ODnsioOdmB/Onvf5+EHciF fL5WqyVhJgAMlgAGGHEJqd9Wu/29f/iHZ69eHfRE/ptms7m7u+ua33Ci5lxfW1te WrowPz/YmWhgAMYEMMBoS0j9Xn766X967bVBz+KLbHuOzVGl8tHvftcZ9P+rjxu4 Xm/ZCw2QYgIYYGQloX6TufBr23P8jpeCV1eXM5nBLgVrYICUE8AAoykJ9ZvMhV/b ngcoCUvBGhggzQQwwAgaeP3WqtUf/PCHSVv4HbPtOQFardZKJrO3szM+Pj6oOWhg gNQSwACjZuD1Oz8/f+NHP0rUUc9jd7c95+4a9EQ4tre7e+sPf5icnBzUBDQwQDoJ YICRMtj6LRWLL3/729deeWVQE3iQVqu1t7d3dHQ06InwJ7Vq9ZObN6P/Us6dG8x3 IxoYIIUEMMDoGGz9ttrtf/rhD68888ygJvAgtVptZ2fH/TcJFP2XsraysprJRD91 BzKBqIHr9XpTAwOkhgAGGBGDrd9kbnuOFAqF/f39Qc+C0xzu7//+448HtR1aAwOk igAGGAWzc3OPPfbYoJ7+leeee+W73x3U0x+k3W5H6VsqlQY9ER6uWq3+4eOP6wM6 mlsDA6SHAAYYehMTE9PT0xcHEcClYvH1N95I4GnPjUZjd3c3qppBT4RutVqtpVu3 cgcHA3l6sVCIItw+eYCRJ4ABhtsA67fVbv/8V79K4Lbno6OjqH7ddTSM7ty+/fub NxcG8UqwBgZIAwEMMMQmJyenpqYGUr+Jfek3n88fDGgVkb7Yz2Y/uXlzIK8ERw1c Lpfjfy4AsRHAAMMqKoTzU1MDefX38tNP/9Nrr8X/3NN56XdklEuljz/8cKzTifm5 nU6nVCxqYIARJoABhtWgDr5K5pFXzWZzZ2fHS78jo1qt/v6jjxqx/xcaNXChUDiq VGJ+LgDxEMAAQ2l+fn7h4sWYH5rYI6+iWIrq10u/I6bVai1++mn+8DDm5+ZzuXq9 7mVggJEkgAGGz6Dq98c/+9mVZ56J+bkPVSwWs9nsoGdBEANr4Hy+4WIkgFEkgAGG zEB2PifzwOdOp3N4eBi1yqAnQli319c/+f3vFxYW4nxoIZ+v1WrWgQFGjAAGGCYD ufQomfXbbrez2azzilJi686dmx9+GHcDFwo1FyMBjBYBDDA0jo99Pn/+sUuX4nxo MuvXkVcptLW5efOjj+JsYIdCA4weAQwwNOLf/Dw1Pf3PP/5x0uo36t7t7W3rcim0 t7Pz+48/npmZie2JDoUGGDECGGA4xH/wVfTEn7z5ZpxP7EalUtnd3e3EfkMsCZE7 PPzo//7fqenp2J7oUGiAUSKAAYZA/Gu/yaxfBz4TOchmP/7d76ZjXAd2IBbAyBDA AEkX/8FXyazfw8PDXC436FmQCFubm4uffBJnAxcLhaoDsQCGnwAGSLTjg6+mpuJc /k1g/XY6nf39/WKxOOiJkBSNen13ezuzuBhbA7fb7ehnoJeBAYadAAZItLn5+Ysx vvrbarffee+92B7XjSg8dnd3j46OBj0REuT4fOZCYT+bXbx1K7ZfIF4GBhgBAhgg uWJ+9TeBNx5FsbG9ve26I+5Vq1ajf+3u7q5kMrE1cCGfj342NpvNeB4HQN8JYICE ivnV3wTWb5QZUf02Go1BT4QkarfbpUIh+pvdnZ2V5eXYGtjLwABDTQADJFHMr/4m sH6j7t3a2pIZnOKoXD7585E4G9jLwABDTQADJFGct/6WisUf/+xnV555Jp7HdaNW q21vb0elMeiJkGitZrNcKo3d3Sq/vrZWjetF8Xw+X3crEsBwEsAAiRPnq78JrN9q tbqzs6N+6Ua5WDwJ0eiva6urtWo1nucWCoXjm4G9DAwwbAQwQLJMTk5OTU3F9urv 11988aWXX47nWd2oVCq7u7udTmfQE2E4NOr1z3Yj12u1leXl2P7oJJ/LOZwcYOgI YIBkifPeo68899wr3/1uPM/qRrlcjup30LNgmJzch/TZn5hUq9WVTCaeR7sVCWAY CWCABIlz8/P8/PxP3nwznmd1o1Qq7e3tDXoWDJ/q0VG9Vvvs3+bz+eWlpZmZmRge bSM0wNARwABJEefm5/Hx8V+//XYMD+qS+uXMPrsP6TMH+/uZpaULFy7E8HQboQGG iwAGSIrYNj8n7dIj9csjqpTLzf9+X/TO9vbqykoMv6BshAYYLgIYIBFi2/yctGOf 1S+PLqrfqIE//0/iPBS6UCjUa7WmjdAAw0AAAwxenJufE3Xss/qlLzqdTrlY/ML5 z7VabSWTiedEcRuhAYaFAAYYvPn5+YVYNj9ffvrpf3rttRge1A1nPtNH9Vqtek+C lkql5aWl8+fPh366jdAAw0IAAwxYbJufE3XwVaVS2dnZGfQsGB2dTqeYz9/7z/ez 2eVMJoYDsYqFQrVa1cAACSeAAQZsdnb2sUuXQj+lVCy+8/77gQ6+itrj3LkefkOJ OmF7ezuevamkx1Gl0qjX7/3nG2trpVIp9NOjn8+FQiGaQ+gHAfAoBDDAIMW2+fnb 16597YUXYnjQQ9Xr9a2trS+8rgmPrtVslu8Xuo1GYyWTiWFttpDPH18LbBEYIMEE MMDAxLb5OTmv/kYpEtWvQiCQUrHYvt/PruifL2cy8bwM7DQsgCQTwAADMzc3F8PJ z8l59bfZbEb167YYwrnvUVgn9rPZzNLSwsJC0AnkcrmG07AAEkwAAwxGPMu/pWLx l2+9denxx0MM3tOrv1ESRPXbaDRCzAROPOgorJMfWl1ZeVAe95HTsACSTAADDEY8 Z18l5NbfqD22t7ejKhj0RBh9DzoKa+zkZuClpdBnrzkNCyDJBDDAAMSz/Ds1Pf3z X/0q9FMeKuqBbDYbwzG8MHZ3r0G5WHzQjx7s769kMnPz80HnUMjn6/W63f4ACSSA AeI2OTk5NTUV+u3f5Nx7dHh4mMvlQkwD7isK4FN2IK+vrd33sOj+yufzFoEBEkgA A8QtnquPwm1+7ql+S6XS3t5eiGnAg5xyFNbY3Y3Qy0tLoecQBXDdlUgAySOAAWKV qs3P1Wp1a2tr0LMgdU45CutEPBuhXYkEkEACGCBWMSz/Bt383L1Go3Hnzp12uz3Y aZBOpxyFdWJtdbVSLgedQxTAdVciASSMAAaITzzLv0nY/Bx1b1S/Lj1iUJrNZuXU F31j2ghtERggYQQwQHzm5uZCn301Pj7+67ffDvqIh4o6eXd3t+IEIAaqVCicvgEh u7e3nMksLCyEm0Mul2tYBAZIEgEMEJMYln9LxeIv33rr0uOPB33KQ0Xf9B8eHg52 DlCLnLr62ul0VpeXQ19PbREYIFEEMEBMYlj+/dKVK9+/cSPEyN1vfo6+19/e3g4x B+hJu90uFQqnf6ZYKKxkMuenpsJNwyIwQKIIYIA4xLD8W6tW/+ODD0KM3H39NpvN zc1NB1+REJVyufmwF9E3b9/O53Ld3+x1BhaBAZJDAAPEIYbl329fu/a1F14I+ojT RZ18586d+qlH70Kcovp96FHPjUZjeWkp6J/aWAQGSA4BDBBcDMu/4S7+7X75N5vN FovFEHOAs4l+9pYKheivp39sP5tdXV4Oei2wRWCAhBDAAMHFsPx74/XXn7p8ue/D dl+/lUplZ2en7xOAR1Q9OqrXaqd/Jvp5vry0FHTzgkVggIQQwABhxbD8e/npp//p tdeCPuJ00bf1t2/f9uovCRT95Cx3sTEhhtOwLAIDJIEABghrfn5+4eLFcOOXisV3 3n9/dnY23CNO1+l0dnZ2fGdPYkW/RtpdLL2urqwchby8OgrgeqPRajbDPQKAhxLA AAHFsPz77NWrr16/3vdhu9/8nM/nDw4O+j4B6JeHXgh8olwqLWcyk5OT4WZiERhg 4AQwQECzs7OPXboUbvxwVx91qV6v37lz56GHDMEAdXMh8InbGxuFfD7clUgWgQEG TgADhDIxMTE9PR30+Kvnnn/+2iuvhBv/dFH3bm5uNh52zyoMXKVUanaRnUeVSiaT mRgfDzeTfD4fdKM1AKcTwAChhN7/HGj5t/vNz4eHh7lcru8TgL5r1OtdZmfoReBo 8Fqt5jhogEERwAChhN7/PNjl33q9vrm5OainQ086nU4xn+/mk6EXgaOZFAoFi8AA gyKAAYIY0uXfLkXfxG9tbdUedr0qJEelXG52t11/Y329WCiEWwTO5XJVR2EBDIgA Bghibm5uhN/+dfIzQ6fRaByVy918slKpLIdcBI4CuFGv2wUNMBACGKD/Rnv5NwqJ zc1NJz8zXI53QRcKY939vA29COw+JIBBEcAA/TfCb/9GFbGzs+N7d4bRUaXSqNe7 +WToReB8Pl+v192HBBA/AQzQZ6FvPxrs8m+pVNrb2xvU0+FRNBuNSne7oMdiWAR2 HxLAIAhggD4Lvf95gMu/7Xb79u3b3l1kSHU6nVKh0OXu/eNF4KWliYmJQJNxFBbA QAhggD4LGsClYvGd99+fnZ0NNP7pXPzLsOt+F3RkZXk5XKO6EBhgIAQwQD+FXv79 0pUr379xI9z4p3D2FSOgp13QUaOuZDJT09OBJuMoLID4CWCAfgp9/NVP3nxzfn4+ 3Pin2N3dLXddDpBMPe2CjmSWlurB7ru2CAwQPwEM0E9BAzhK3yiAAw1+uqOjo+3t 7YE8Gvqrp13Q+/v7q8vLc3NzIWYSdXihUHAUFkCcBDBA34Te//zq9evPXr0abvwH ib5Nv3PnTr3rZoAkazQaR13vZWi1Wku3brXb7UCTsQsaIGYCGKBvgi7/ttrtd957 L9Dgp3P1EaOk0+kU8/nuP397YyPK1PEwdwIfXwhsFzRAjAQwQN/Mzc2Fu/53ULcf RbVw+/btZrMZ/6MhkEq53Gw0uv1w4PuQXAgMECcBDNAfoW8/+uC3vw00+OmKxWI2 mx3IoyGQRr3eU3OuraxUgjWqXdAAcRLAAP0xNz9/8eLFQIM/8cQTr73xRqDBT2H5 l5HU6y7ow8PD1eXlmZmZEJOJArher9sFDRAPAQzQB6N6/FWhUNjf34//uRBauVRq df0nO8GPwrILGiAuAhigD4IG8KCOv4q+3b99+7aFKUZSrVqN/tX958MehWUXNEBc BDBAH8zMzl4Kdv7zs1evvnr9eqDBT2H5lxHWarXKxWL3ny8WiyuZzPnz50NMxi5o gNgIYIA+CHr+80/efHN+fj7Q4A/i7V9GXrFQ6PSyq3lpcbER7DZsu6AB4iGAAR5V 0P3PU9PTP//VrwINfgp3/zLyouDsKWj3dnfXVlbmL1wIMRm7oAHiIYABHtXs7Oxj wfY/D+r6383NzXqwxS5IgmajUSmXu/98FMxLS0uTYS4Ezufzx7ug7bkACEwAAzyq oAE8kP3P1Wp1a2sr5odCzHq9DCmydOtWo9EINJlCoWAXNEBoAhjgkYzk/uednZ2K b8RJgUqp1NOL7ru7u+t2QQMMMwEM8EiCBvBA9j83Go3bt2/H/FAYiHqtVu2lOY93 QS8uTk5OhphM7vCw2svNTACcgQAGeCSjd/5zNpst9nI9DAyvXi9DGgu5C9plSAAx EMAAZzd6+5/b7fb6+nqn04n5uTAQ0U/1UqHQ00/43Z2d9dXVULugXYYEEJgABji7 0dv/XCwWs9lszA+FAaqUy81eVnQrlUom2C5orwEDhCaAAc5u9M5/3tra8hYiqdLr a8CRpcXFni4Q7p7XgAFCE8AAZxduBbjVbr/z3nshRj6F469IoTO8Bryxvl7I58fH x/s+mUKhUKtWvQYMEI4ABjijoPufv3Tlyvdv3Ag0+IMcHBzke7wWFYbdGV4Dzudy q8vLU9PTIebjNWCAoAQwwBkFDeBXr19/9urVQIPfVxQAGxsblp5IoV5fA45+mSx+ +mmgs+K8BgwQlAAGOKNwLwCXisUPfvvbECOfolwu7+7uxvxQSIIzvAa8srzc65d0 yWvAAEEJYIAzCrcCPD0z8+Yvfxli5FNE9Rs1cMwPhSQ4w2vA4S5D8howQFACGOAs RuwCJNf/kmbRz/xij2+/h70MyWvAAMEIYICzCBrAN15//anLlwMNfl/2P5Ny5VKp 1Wx2//momRc//TTQOq3XgAHCEcAAZxEugGvV6n988EGIkU9h/zMpVz06qtdqPX3J 2upqlM3nzvX/WymvAQOEI4ABzmJmZubS44+HGDn+F4Dtf4ZGo3HU458BhXsNOJfL RfPpaUUagC4JYICzmJubuxhmBfjZq1dfvX49xMgPUqlUdnZ24nwiJE273S4VCj19 SalUyiwuTk1NhZiP14ABAhHAAD0LdwHS2CBuAN7b24u+lY/ziZBAxXy+p30QYW8D FsAAYQhggJ4FPQHrrXffDTTyfUXfvq+vr7fb7TgfCglUKZWaPe46ziwt9frmcJec gwUQiAAG6Fm4AB4fH//122+HGPlBarXanTt34nwiJNMZzsHaunNnY319YWGh75Nx DhZAIAIYoGfhTsD60pUr379xI8TID5LLRd9pH8b5REimRr3e667jQj6fWVqK/geh 75NxDhZAIAIYoGfh3gH++osvvvTyyyFGfpCtrS0LTTB2953ecrHY05dEv3aWbt2a mJjo+2Q6nU6hUPAaMEDfCWCA3gR9AfjG668/dflyoMHv5QIk+Ez0C6GYz/f6JYuf fNIK8wq9c7AAQhDAAL0JdwFSqVj84Le/DTHyg7gACT4v+jXYbrV6+pKV5eVqmNOq nIMFEIIABujNKJ2Atb+/X+jx7lMYYZVyudlo9PQlAc/ByuUCpTVAmglggN6EewH4 iSeeeO2NN0KM/CCbm5v1ej3OJ0KS1arVWo+vxB8eHq5kMtH/LPR9Mg6CBghBAAP0 JtwR0M9evfrq9eshRr6vdru9trYW2+Mg+c5wEHSpWMwsLk5NT/d9Mg6CBghBAAP0 JtwK8LevXfvaCy+EGPm+qtXq1tZWbI+D5Itqs1wq9fQlUTMv3rp17lz/v6FyEDRA CAIYoDdXnnkm0Mg/efPN+fn5QIPfK5/PHxwcxPY4SL4zHAQdWfz002aYdVoHQQP0 nQAG6EG4E7DiPwJ6d3e3XC7H+URIviiAe70YbCWTCfSyrgAG6DsBDNCDcHcgxX8E 9MbGRqBlKxheZ7gJaevOnfX19YsBDoJ2ExJA3wlggB6EWwG+sLDw45/+NMTI9xWl bxTAsT0OhsUZbkLaz2ZXlpdDvL/gJiSAvhPAAD0IF8BfunLl+zduhBj5viqVys7O TmyPg2ERBWe9VuvpS/L5/PLS0szMTN8n4yYkgL4TwAA9mJmdvRTmCOjnnn/+2iuv hBj5vnK56Fvrw9geB8PiDFcBV8rlpaWl85OTfZ/M4cFBrccaB+B0AhigB+EuAY75 DqS9vb1Sj9e9QBqc4Srger2+FOYmJFcBA/SdAAboQbhLgG+8/vpTly+HGPm+Njc3 o+/aY3scDItms1np8c+GOp3OrU8+abfbfZ+Mq4AB+k4AA/Qg3CXAb737bqCR7xV9 V722ttbrXS+QBq1Wq1ws9vpVmcXFQH+i5CYkgP4SwADdGplLgBuNxu3bt2N7HAyR TrtdLBR6/arlTKbXN4e7JIAB+ksAA3RrZC4BdgQ0PEin0ynm871+lauAAYaFAAbo 1sgEsCOg4RRRAPf6gsD21tbaykqI/30QwAD9JYABuhVuC/SFhYUf//SnIUa+r2w2 W+z9LUdIiVKh0OuJVvvZ7Mry8vz8fN8nI4AB+ksAA3QrXAB/6cqV79+4EWLk+9rZ 2al4qxAeoFwstlqtnr4kn88vLy3NzMz0fTK5XK4qgAH6RwADdGtkAtgdSHCKcqnU 69W7AQP48LAa5ngtgHQSwADdChfAz169+ur16yFGvq+1tbUQd5bCaKiUy81Go6cv KRWLmcXFqenpvk9GAAP0lwAG6NbM7OylS5dCjPzta9e+9sILIUa+V6fTWV1djedZ MIzOEMD1en3p1q1z5/r/bdXhwUGtVuv7sACpJYABujUzM3Pp8cdDjBxnALsEGE53 VKk0enxHQAADDAsBDNCt0Qjgo6Oj7e3teJ4Fw6haqfT6krwABhgWAhigW6MRwOVy eXd3N55nwTCqHh3Ve2zOcAGcy+UajUavh3IB8CACGKBb09PTjz/xRIiR4wzgYrGY zWbjeRYMo0QFcKfTKRYK7i0D6BcBDNCt0VgBzufzBwcH8TwLhlGiAtgKMEB/CWCA bo1GAB8eHkbfUsfzLBhGiQpg7wAD9JcABuhWuACO8x7g/f39QqEQz7NgGJ0hgMPd AyyAAfpLAAN0K1wAf+nKle/fuBFi5Hvt7e2VSqV4ngXD6AwBnM/nl5eWov+J6Ptk BDBAfwlggG7NzM5eunQpxMhxBvDOzo4DdeAUAhhghAlggG7Nzs099thjIUa+sLDw 45/+NMTI99ra2qpWq/E8C4bRGQJ4P5tdWV6en5/v+2Ryh4d+wQL0kQAG6Fa4AB4f H//122+HGPled+7csaAEp6hWKvV6vacv2d7aWltZuRjgfx8EMEB/CWCAbglgSIOj SqXRYwBv3bmzvr5+cWGh75PJ5XLVo6O+DwuQWgIYoFvhArhULH7w29+GGPleAhhO VymXm41GT1+ynMnUwqzT5nO5IwEM0D8CGKBbc3NzIbY4nnjr3XcDjfwFm5ubvW7v hFSplErNZrOnL8ksLgb6ZSWAAfpLAAN0K2gA33j99acuXw40+OcJYDhduVRq9RLA nU7n1ieftNvtEJMRwAD9JYABenDlmWcCjfzta9e+9sILgQb/vNu3bzd63N4JqVIq FtutVvefr9frS7dunTsX5HuqfD5/5N4ygP4RwAA9CBfAzz3//LVXXgk0+OcJYDhd qVDoaTm3Ui4vLS2dn5wMMRkBDNBfAhigB7Ozs49duhRi5C9dufL9GzdCjPwFAhhO V8znO51O95+PGnV5aWlmZqbvM4mmUSgUBDBAHwlggB5E3+NeevzxECNfWFj48U9/ GmLkL/AOMJwias4ogHv6kv1sdmV5eX5+vu+TyeVyjUajpxeSATidAAbowczs7KUw K8CxXQW8tbVVDXNfC4yATrtdLBR6+pJwlwAfHhy4tAygvwQwQA9G4Crg7e1th8rC g7RarXKx2NOXrGQygf5QKXd46I+rAPpLAAP0IFwAR37y5pshdlF+wc7OTsUrhfAA zWazUir19CWLn37a673BXcrlclV/XAXQVwIYoAdBrwKO5yak3d3dcrkc+ikwpBr1 ek+HTkWfXwx3B5JLgAH6TQAD9CDoCvCzV6++ev16oME/s7e3V+pxgQvSo1at1nrZ dVwqFjOLi1PT0yEm4w4kgL4TwAC9CXcV8BNPPPHaG28EGvwz2Wy22OMrjpAe1aOj ei/nTh0eHq5kMrOzsyEmI4AB+k4AA/Qm3FXA8RwEHX2/nsvlQj8FhlSlXG72clH2 1p07G+vrCwGOgHYJMEAIAhigN+GuAo7nIOjoW+r9/f3QT4EhVS4WW61W959fWV4O dE6VS4ABQhDAAL0J+hrwjddff+ry5UCDnyiVSnt7e0EfAcOrmM93Op0uPxx9cvGT T1rtdoiZuAMJIAQBDNCboAH89RdffOnllwMNfuLo6Gh7ezvoI2BIRUEbBXD3n48C denWrYmJiRCTcQcSQAgCGKA3QW9C+tKVK9+/cSPQ4Cfq9frm5mbQR8CQarVa5V6O iCvk85mlpZmZmRCTcQcSQAgCGKA3QVeAYzgHq9lsbmxsBH0EDKlGo3HUyy3Z4U7A GnMENEAYAhigZ+EOgo689e67gUY+0el0VldXgz4ChlSvlwBnlpZ6ujOpe46ABghE AAP0LNxB0JFXr19/9urVQIOfWFtba4c5tgeGWhScjXq9yw+3Wq3FTz/t/sSsnjgC GiAQAQzQs6C7oKP6jRo40OAnNjc3611/lw/p0dMdSKVSKbO4ODU1FWImjoAGCEQA A/QsaABPz8y8+ctfBhr8xO7ubrmXFx0hJXq6A2l3Z2d9dXX+woUQM3ECFkAgAhig Z0HfAa5Vq//xwQeBBj9xcHCQ7+WuF0iDdrtdKhS6//za6mq5VDp3Lsi3Uk7AAghE AAOcRdDLkG68/vpTly8HGjxSKBT29/fDjQ/DqNlsVkqlLj/c6XQWP/20+/3SvRLA AIEIYICzCHoOVujXgCuVys7OTrjxYRjVa7Vq17uOw74A7AQsgGAEMMBZDPVrwPV6 fXNzM9z4MIx6OgI66AvATsACCEcAA5xF0AAuFYsf/Pa3gQYfu/uu49raWrjxYRj1 dAT0yvJy98vFvXICFkA4AhjgLIIG8Fj424A3NjaaNljCf+l0OsWuT4YLegPwmBeA AUISwABnFLSBv3Tlyvdv3Ag0eGR7e9sSE3ym3WqVisUuP5zP5VaXl6emp0PMpFAo 1KrVcMdrAaScAAY4o6CXIbXa7Xfeey/Q4GNuQoL/rlGvd7/ourG+Xsjnx8fHQ8zE C8AAQQlggDMKvQs66GVIxWIxm80GGhyGTvXoqF6rdfPJ4BcgeQEYICQBDHBGoQP4 ueefv/bKK4EGr9Vqd+7cCTQ4DJ1yqdTltUOVSiWzuDg5ORloJl4ABghKAAOcXdAG npqe/vmvfhVocAdBw2c6nU6pUOjyUKugFyB5ARggNAEMcHZBXwOO/OTNN+fn5wMN 7iBoONHTCVhLt241Go1AM/ECMEBoAhjg7IZ6F/TOzk7FTkvo5QSs6GNLQfc/ewEY IDABDHB2oQM46C7ow8PDXC4XaHAYIt2fgLW7u7u+shJo//OYF4ABwhPAAI9kbm7u YsgGDrcLulKp7OzshBgZhku5WOzytdug+5/zuVy9XvcCMEBQAhjgkQzvLujo++z1 9fUQI8MQ6XQ6xe7uxD7e/7y0NDkxEWgmXgAGiIEABngkQ70L2jlY0Go2y6VSN5/c 291dC7r/2QvAAOEJYIBHNbxnQe/u7pbL5RAjw7Co12rV7rJzaXGxUa8Hmkan0ykU Cl4ABghNAAM8qtAB/OzVq69evx5i5Fwud3h4GGJkGBaVcrnZxWu9xWJxJZM5f/58 oGnk8/njF4DtyAAITAADPKrQu6Bb7fY7770XYuSjo6Pt7e0QI8OwKBYKnXb7oR+7 vbGRz+XGx8cDTcP+Z4B4CGCAPgh9FvSr168/e/Vq34dtt9tra2t9HxaGRfRLoFQo PPRjrVZr6datdhedfGYuQAKIhwAG6IOZ2dlLIXdBX7hw4cc/+1mIkTc3N+vBXmuE hGvU691k5342u7qyMjc3F2gaLkACiI0ABuiD0Lugi4XCu//5n7Ozs30feX9/v9DF ChiMpKh+uznXajmTqYW8oMj+Z4DYCGCAPggdwJH5+fmfvPlm34ctl8u7u7t9HxaG QqlYbD9s3XV/f391eTnc8u+Y/c8AMRLAAP0xNz9/8eLFcON3Op1fv/32xMREf4dt tVrr6+v9HROGQvRrqpjPP/RjK8vLXd6TdDb2PwPESQAD9EcMi8Bf/vM//94//mPf h719+3aji2tgYMREP+2PHnYPdrFQOL79aGoq3DTsfwaIkwAG6JvQZ0GXyuUP/s// 6fuw2Wy2WCz2fVhIuOrRUb1WO/0za6urlYdF8iOy/xkgTgIYoG9mZ2cfC3kWdOTr L7740ssv93fMUqm0t7fX3zEh+R76AnC1Ws0sLY2fC/jNUlS/UYTb/wwQGwEM0Dcx 7IKOvld+73//7/6O6TVgUqibF4A31teLhcK5oAFs/zNAvAQwQD/FsAj8nVde+erz z/d3TLcBkzYPfQG42Wwu3boVdXK4OUSDFwoF+58B4iSAAfophgCOvPXuu/0d8ODg IN/FcbgwMh76AvDO9vbqykrQo90L+XzN/meAeAlggH6KYRd0p9N57Y03nnzyyT6O eXR0tL293ccBIeFKhUK73T7lA0uLi43A2yLsfwaInwAG6LMYGnhycvKXb73VxwGj ElhfXw+62xOSI/oJHwXwKR/Y291dXVm5cOFCuDlY/gUYCAEM0GcxBHCxUHj3P/9z dna2j2Nub29bjCIlGvX66W/eriwvVwP/csjlcqEfAcC9BDBAn01MTExPTwe9EDhy 5ctf/scf/KCPA+bz+YODgz4OCIkV1e8p25uLhcJKJnN+airoHFz/CzAQAhig/2I4 CqtcLr/3v/7X+fPn+zVgvV7f3Nzs12iQZMV8/pQN/2urq5VTD4h+dPlcrt5otJrN oE8B4F4CGKD/YtgFHbn6la9899VX+zjgxsZG03fkjLpWq1UuFh/0o+VyeTmTmZyY CDoHx18BDIoABggihgau1Wrvvv/+RP++U9/f3y+cejIQjIB6rXbKy7cb6+vFQuHc uYDfIDn+CmCABDBAEPEsAj//wgt/e+1av0ZzGRJpUCmXm43GfX8o+iWwvLQ0Pj4e dAKOvwIYIAEMEEoMbwI3Go1333+/X6tVnU5nbW3NZUiMsOind7FQGHvAT/LN27fz uVzQ5d8xx18BDJQABgglnkXgr3/jGy9961v9Gm1nZ6fiW3NGV7PZrJRK9/2hWq2W WVwMXb/2PwMMlgAGCCUK4IWFhdDbKVvt9tv//u/9+q69WCxms9m+DAUJVKtWo3/d 94e2t7bWVlcvXrwYdAKWfwEGSwADBDQ/P78Q+PvpyDdffvmbL77Yl6Fardb6+npf hoIEKpdK9718qF6vZxYXQz/d7UcAAyeAAQKKZxd0u93+t/4tAm9tbVUfsEQGQ+34 BeB8/r4/tLO9vbq8fDHwr1a3HwEMnAAGCGvoFoELhcL+/n5fhoJEadTr991+HN/y b73u7V+AwRLAAGEN3SJws9nc2Nh49HEgaaL6jRr43n9u+RcgPQQwQHBzc3Ohv7eO fOOll1586aW+DHXnzp1ardaXoSAhOp1OqVC495av6Kf68tJS6KfncrmG5V+ABBDA AMHFswjcbLXeee+9viwC5/P5g4ODRx8HkiOKz3KxeO8/v7O5eXhwEPq0dsu/AAkh gAHiEM8i8PMvvPC31649+jh2QTN67nsBUvXoKJPJjAe++9fyL0ByCGCAOMSzCFyv 1d55//2JiYlHH8ouaEbMfS9Aur2xUcjn+3WC+oNY/gVIDgEMEJN4FoGvfuUr3331 1UcfJ5fLHR4ePvo4kAT3vQCpUqksLy315Q+MThEFdq1Ws/wLkBACGCAm8SwCR9/T v/Mf/zE9Pf2I49gFzSi57wVI62tr5VIp9KMt/wIkigAGiE88DfzUU0/d+NGPHn0c u6AZGfdegFQsFJYzmampqaDPLRQKtWrV8i9AcghggPjEE8CdTuf1N9544sknH3Gc 6Hv3/f39vkwJBquYz3/hAqSV5eVq+IVZy78ASSOAAWI1Nz9/8eLF0E+Zn5//yZtv PuIgrVZrfX29L/OBAbr3AqTDw8OVTGZ2djboc6P6rTv8GSBhBDBArGJbBP4f3/3u c1/96iOOs729bf2KYfeFC5Cazeby0lIMXWr5FyCBBDBA3Obn5xfCLwK32u1/e/fd 8fHxRxmkWCxms9l+TQkGolwsfj53d3d2VjKZ0EeyHy//Nhr3XrwEwGAJYIC4zc3N RQEc+urRsX5cidRut9fX17/w8iQMkU67XSwUPvu3x1cfZTITj/YHQ93I5/P3njsN wMAJYIABiGcRuFQqvfXOOxcWFh5lkN3d3XK53K8pQcy+cAHS2upqJfzP56h+6+7+ BUgkAQwwGHNzc6E3YUZmZmZ+9stfPsoIlUplZ2enX/OBmEW522w0Tv7+8OBgOZOJ fukFfWIul2s4+wogqQQwwGDEcxpW5Bsvvvjiyy+f+cs7nc7Gxobv5hlG0c/e4/3P d/fw12q1lUwmhv38zr4CSDIBDDAw8VyJVD06euvf/31mZubMI+zv7xc+9xYlDItm o/HZhueN9fUohkO/e2/5FyDhBDDAwMR2Glb0oH/9+c/P/OX1en1zc7OP84F4VI+O 6rVa9De5w8Pl8Bf/jln+BUg8AQwwSPEsAke+/o1vvPStb535y6MAjjK4j/OBGJQK hXa7fbz5eWkphqPMj68+svwLkGwCGGCQZufmLsayCFwul3/99tsLZz0ROp/PHxwc 9HdKEFS71SoVi9HfrK+tlUulGJ5o+Rcg+QQwwIDFcyVSZHJi4hdvvXW22G61Wuvr 632fEoRTq1ajf+3v768sLc1fuBD6ca4+AhgKAhhgwCYmJ6enpmK4Eily5ctf/scf /OBsX7uzs1P53H2qkHDlUqmQzy9nMpMTEzE8LgrgI79AABJPAAMMXmxXInU6nVe+ +92/+upXz/C1LgRmiEQ/1Q/391eXlxv/dQlwUFFp1yz/AgwDAQwweJOTk+fPn3/s 0qUYnlWtVn/1b/82Pz/f6xe6EJgh0qjXFz/9NOrSGF6wj35pFAoFy78AQ0EAAyRC bIvAkYmJiV/85jfj4+O9fuHBwUE+nw8xJeivjdXVKIBjePU3EtVvvVZrNpsxPAuA RySAAZJibm4unjeBI08++eQP//mfe/2qRqNx+/btEPOBPsodHn78//7f+ampOJ6V yzVcfQQwPAQwQFLEdiXS2N1Nmy/8zd98+zvf6fULt7a2qtVqiClBX1SPjm5++GFs 67GuPgIYLgIYIEFiuxJp7G4D/8/r16/+5V/29FXFYjGbzYaZETyqqHs/uXkznlt/ x1x9BDCEBDBAgkxMTJyfmroUy2lYY3fXyn7+m99c7CW52+32xsZG9Ndws4IzW7p1 K7u7G882ijHLvwBDSAADJEucp2GN3Q3aX7711lQvb0tms9lisRhuSnA2dzY3f//R RwsLC/E8ztlXAMNIAAMkztz8fE+rso9oembmZ7/4RfeLZvV6fXNzM+iUoFfZvb2b v/vdzOxsPI9z9hXAkBLAAIkzOTk5NTUV24nQkSefeuqHP/pR95+/c+dOrVYLNx/o SSGfv/nhh2e42evMbH4GGFICGCCJYt4IHfmrr371f/zd33X5YUdhkRxHlcrvP/oo zq3IUW/X63WbnwGGkQAGSKg4rwUeu3so9Le+852//pu/6ebDjsIiIaIQ/eTmzaiB Y3uizc8AQ00AAyTUxOTk9PR0nC8DF4vFn/zsZ1eeeaabD+/v7xcKhdBTglNEFfrp H/5QzOfjfKjNzwBDTQADJFf8G6ErlcrPf/WrS48//tBPOgqLwep0OouffnqQzcZ2 6dGYzc8Aw08AAyRazCdCRxr1+i9+85vouQ/95NbWVrVajWFKcK/V5eWtzc2YD76q 2/wMMOQEMECiTUxMnJ+aunTpUszP/fmvf/3Qy4FLpdLe3l4884HP29na+vjDDy9c uBDnQ/P5fJwvGwMQggAGSLrZubmLFy/Guc8zEtXvT3/xiyi/T/lMp9PZ2NiwIEbM 9vf2Po7xyt8ThUKhXqvZ/Aww7AQwwBCYn59fiHcjdOTCwsK//Ou/nh7eh4eHuVwu tilB7vDw5ocfTk5OxvnQ/N1Xf1vqF2D4CWCAITB5/vzU+fNx3op04smnnvrhj350 ygeazebGxkZs8yHlioXCxx9+OB7vbohCPl+r1ex0ABgNAhhgOExGzp+P/2XgP3v2 2ev/8A+nfGBnZ6fixUjCq5TLUf12Yr992r1HAKNEAAMMjYG8DNzpdL76ta9de+WV B30gaoPt7e04p0QKVavVP3z0Ub1ej/m5Xv0FGDECGGCYDORl4KiBv/nSSy++/PKD fnRzc7PRaMQ8K9Ij6t5Pbt6M/wTmfD7fcOsvwGgRwABDJv6bgcfuVu7fXrv2tb/+ 6/v+aNQJBwcHMU+JlIj689ObN0ulUszPzeVyDbf+AowcAQwwZO6+C3z+sdhfBo4a +OVvfevr3/zmvT/UbrfX19ejD8Q8JUZeo9H45ObNSrkc83Ojn8yFQsGtvwCjRwAD DJ+JiYnzU1PxH4gVVcFfXL366ve+d+8P7e/vR8EQ83wYbdWjo5sffdQcxO76YqFQ 8+ovwCgSwABDaSAHYp2YmZ390b/8y8zMzOf/YaPRuH37dvyTYYRlFhfXV1bm5ufj f3Q+n7f8CzCSBDDAsJq/cGFhYWEgj64eHX3n7/7umy+++Pl/uL297bYY+qJcLv/h o4+azeZA/oinWChUq1Vv/wKMJAEMMMQGcij0Z6ZnZv7+e9+7/PTTJ/+2Uqns7OwM ajKMhlazmVla2lxfH8jC79jde49qtVrL5meAEfX/s3cn7G0cd57HQZzEQZA6bMlO bFmyZdlSJFuSJfmObzs+YkeOJ5nEmUwyeXZf4z4zmczszs7sZCaJHMu6T97gBXQ3 jj4A9BbQFEyTFMWjq8/v55EpkBarihLY7B+q6l8EYAAIN1+KQg/Ytr179+5X33hD RHHxeHJykm2T2B7x/Jm4e/fu7dvZbNavMSiKYor0y9wvAEQXARgAwi2VSmVzudHR UR/HoGnaEwcPnjl3biiZ5DwkbFW3250cHxfpVzyZfVnz7FBqNZNzjwAg6gjAABB6 qXQ668fBSKvYtl0oFh/ev3//I4/4OxKEhd5q3b1zZ3ZmZjiX83cknHsEADFBAAaA KEilUrlcruzrPPCASDV79+17/MABH/cnI8g67fbMzMz05KRSrQbkSatpmqHrLOAH gMgjAANARPh4MNK6bNsWcWL33r2PPPrort27/R4O/GdZ1uz09FylUqvVSj7VuFoX 6RcA4iMo90kAgJ0rlnqCk4EHms3m6Ojo2O7d+/bvF4P0ezjwTqfTWVpcnJ+bqy0t Ner1gMz3rsShRwAQK4G7SQIA7ISPhwNvUqvVEkMUQWjX7t279+xJpVJ+jwguazWb iwsLtWpVZMtGoxHkJ6SqqqZhMPcLAPFBAAaAqPH3cOAtcZZJFwqFYj8Si0ScGx72 e1DYmm63W9c0J+7W6/VWozGczwdwGcJaHPkLADEUgp9PAICt8vdw4J1o1OsiA+eF Yk9vOrtczmQyfo8LPbZt662W2g+6zXpdPBYMXQ/gwuYHUhXFME3SLwDEDQEYACIo UEWhd0iErmajkclms7nccC6XHe7l44JIyIWC+EU2dp34CzdNU/ydt5pNkW91XRcR 1+izDCMaT6rekb+WRfoFgBgiAANANEUpA29AVZS0yMYiB/ffZPoPluX6hofFw1Cs yPVAt9s1nSzbz7Qi6FqCeNt/1BZv2u18SBYwb1sv/ZomVa8AIJ6i/BMOAGIunU6L PDg6Nub3QHxm23a9Xk8mk+IvJCUs/5ZK9t+mlt/rfbj3f/rvDh6n+4+TganUJWJb u93u/Sfernj87bv937ribbfbufdR54PiIyMjI9EOtw9Uq1ZF5Cf9AkBsxfqnIABE HhnYFSJCa5omfmQODSR7Bu+JPyPe7f3Re+/2/siGUbNr9ziNJ/oPut2u865DvCv+ W37c/zMjQTrnOYzE36Sqqq1m0++BAAB8w89RAIi4dD8Ej5GBEXuaphm6zqFHABBn BGAAiL58oTAyMrI8RQnEEukXAJAgAANATBRLPSygRTxp/SN/Sb8AAO6EACAuyMCI J9IvAGCA2yAAiBEyMOKG9AsAWIl7IACIl0KxWC6X/R4F4IXekb+W1SH9AgDuIQAD QOyQgREHiqKYhsGRvwCAlQjAABBHZGBEG+kXALAuAjAAxFE2m01nMmRgRFJv5bNp kn4BAGsRgAEgplKpVC6XK4+O+j0QwE3s+wUAbIAADADxRQZGxNRqNYu5XwDA/RGA ASDWRAbO5nKjZGCEX61atSyL9AsA2AABGADirpeBs9nRsTG/BwJsn23bqqq2mk2/ BwIACDQCMAAgkU6nM5kMGRghJdJvvV63zB6/xwIACDQCMACgJ5VKZbLZMTIwQkjT NL3VYvEzAOCBCMAAgGWpdHo4lxvhbCSEiki/hq63KfsMANgEAjAA4Fv5QmFkZCSZ TPo9EGBTNFU1DIP0CwDYJAIwAOA7isUik8AIBdIvAGCrCMAAgO/I5/NUw0IoKIpC 2WcAwJYQgAEA35EvFDgWGKGg1GqtVsvvUQAAwoQADAD4jkKxWGYJNMJAURTTMCj+ DADYPAIwAOBbFMFCuLAKGgCwJQRgAMC3qICFcFEVxTRN6mABADaJAAwAWJYvFMrl 8tCQrB8NdiKRSaebzWYmk5HXCwLCtu1mo1EoFsU/d73RGM7lJHXEJDAAYPO4/wAA LCuIACyz/NUj3/ve4088IR50O52aUK3WNa3VaumtVi6XIxKHnaZpw8PD+Xy+UCqN lMu7du0qlkri47quX/zqq460SVqlVjNNk53AAIDN4G4DANDjweLno8eP36+Lbrer qaqqKI1GQ282dcMwdD2bzbIbOYBs2643Grlsdng57xZKIyPl0dFCoXC/T/n6woVm oyFvSCyEBgBsEgEYACB98bPQarXeeOedbXxWo14X2Uk8EJFYhBzTMCyh3S4Vi0wa yyNSbqvZTGcymWxPThgeFhG3UOwRH9xSazdv3JifnZX676Wpqq7rzAMDADbGrQMA xF0q3Ys5Y2NjUnsRIerkmTMuNtjtdFp9eqtl9lmm2e5FY/HG6oi37bZ4OyI52IdO b/62Xu/9o6dS4h8+3ScCrRN0s72c2wu64jcX/94W5ucvX7yY3WJs3ipN08STgQwM ANgA9wQAEGupVErEklHJ6VfY/+ijBw4elN3LWiLvGf0F1dY9Ih+LjCSycf9NWwTp TrfrfKTb7dricbfrPLATiVKpFKj8LL4c8VYkWDGmZDI5JP79kvek7kmn7/2e7gXd /gsc6f5Ubi6XE795/xX1tgFfuCA7mjrZ3uq/GiK1IwBAeAXohzoAwGPpfjTyIP2K ZHLyzJmctDrAUonBL+fkjhONu4MHzqNEfw9zoh9Ne8m5/0C87fb/1/304ms/iIq3 y1ud7z1YlWqT/XedD4p/L/lfsRSXL15UFUV2L04GbtTrsjsCAIQUARgAYsqzuV9B BLuzL73kQUcIrMrMzJVvvhnO52V35GRgwzDaliW7LwBA6BCAASCO+vs+pe/7HXjs wIFHv/99b/pCMJmmefHCBcuTUEoGBgDcDwEYAGInXyiIq7/UI39Xajabb7zzTqB2 0sIXN65eXZif9+yZQF1oAMBa3I4AQLwUSyWPCzuVyuVjx4971h2Cybbt+bm5a5cu bfUIpZ0gAwMAViEAA0BcpFKp4eHhkXLZy041TfvhW295mXkQTCKFNjTt9q1beqvl Zb+qohim2Wm3vewUABBYBGAAiIV0Op3NZj1b9jxQGhk5duKEx50imAxdn5+bu33z puwDgVdRarWhoaF2u83xSAAAAjAARF++ULBt27OSVwP1ev31N99k+hcO8SRs1Os3 r1/3eBLYwXJoAECCAAwA0ZZOp3O5XGlkxJcaVKO7dj1z9Kj3/SKwRP6cnZq6ffOm Ly+L9JZDGwYZGADijAAMAJGVLxQStu3NSb9rWZb18uuvJ5NJX3pHYOmt1s3r10UW 9eW5Uesvh7ZMs82uYACIJQIwAESQU+/Kr4nfRH+x67PHjo3u2uVL7wgy8dyoLS1d u3LFxzGoqmoaBhkYAGKIAAwAUdOb+E0kRj2vd7VSqVQ6ceoUa02xrk67PX7nzp3b twv956ovmAoGgHgiAANAdPi743dA1/Ufnz+vKIqPY0DA6a3W1cuXW82mv89VpoIB IG4IwAAQEf7u+B2wbfvMiy+O7dqlaZq/I0GQBWEhtENVFDuRYCoYAGKCAAwAoSei 79DQULlc9nsgPQ/v2/fmO++Mj493u12/x4JA67Tb05OTd27dyuZyfo8l4SxYsCyr bVl+jwUAIBEBGABCLJ3J5LJZ39c8DySTyZ/+/OetVmtubs7vsSAE9Fbr7u3bE+Pj IyMjfo+lR1XV3jlJTAUDQHQF4oYJALANhULBDsCa5wFD10X6LZZKlUql2Wz6PRyE gHgCNzTtxvXrIgkH5EUcZ0W0yXHBABBRgfhhAwDYkt6a50Si7Gud51U0Tfv0/PmH 9+0TsWF8fNzv4SA0Ou22yJw3rl0L1Jp5Z0U0MRgAoocADABh4vsBv+uybfvUCy8c efbZRD85LC0t+T0ihIneammqeuvGDb8HspqqquK53WI5AwBESIDunwAAG0hneoJT 7GpAJITDR468cPas8+7k5KRFGSFsRW8hdL3eaDRuXL2aTqf9Hs53iLHVNc3gqCQA iAoCMACEQECOOFpLxIMDBw++/Oqrzru6rs/MzPg7JISReCK1LWuuUrl940Ymm/V7 OKtxVBIARAYBGAACrRd9E4nRIG33HRCh5bEDB159/fXBR+bn5+v1uo9DQqgZur4w N3fr5s1s8DKwoNRqiaEhYjAAhBoBGAACKoCVrlZam347nc7ExIT4uI+jQtjpzebi wkJgM3BicGIwMRgAwokADACB04u+Q0MjAat0tdKqlc8Oyl9h55yiU9WlpWCuhR5Y XhRtWW12vANAqAT01goA4klE3+TQUNCKPK8iIsrTzzxz+syZVR+cnJxkTgw7J55L zXpdU9WbN24ErSbWKpSJBoDQCe4NFgDESiiir1DXtNfefPPIM8+s+niz2axUKr4M CdFjd7uNel0Eyxs3biSD/R2RIAYDQKgE/YcKAEReWKJvol+j6IOPP963f//a/zUz M6PruvdDQlR1RQbWNMuybl6/3ul0Av7d4ZyW1CUGA0DgBfrHCQBEmxN9i6VSMpn0 eyyb8vGnn4qgvvbjhmFMT097Px5Em8i9jXpdhMtbN2/OVyqBLQg3QAwGgOAjAAOA D1Kp1PDwcIiir8i9H3z00f02ZM7NzTUaDY+HhDhot9vN/sFaszMzkxMTxWLR7xE9 GDEYAIKMAAwAnuqd62vbQ8lkuVz2eyybIu7mH3/iiVdee+1+f8A0zampKS+HhFix TNNJkqqi3L55M5vL+T2iTSEGA0AwEYABwCOhW/Cc6G/6ff2ttw4eOrTBn2H6F7KZ hqG3Won+qy03r18X2TLgW4IHiMEAEDTh+PkBAKEWojJXK2VzuR999FFvyvr+mP6F NwxdN+5VWbt7587c7Oy629GDiRgMAMERplsxAAidkEbf3rLnAwdefu21Bw6b6V94 RqRHyzSdx7Va7e6tW2FZDu0gBgNAEITphgwAQkREX5EeR8IWfYVOt/vGW2997/vf f+CfpPgzvOSctdu2LOddy7Ju3bjRbrdDtKcg0f8qNE3j3GAA8EvIbssAIPjCG33F TfnevXvfevfd1H2qPa/C2b/wmHiKNhuNTrs9+MjszMzU5GRhw4X6waSqKjEYALwX spszAAiy8EbfRH8+7ZXXXz/05JOb/PPNZrNSqUgdErBWLwPX651OZ/ARwzBu3bgR ospYKxGDAcBj4ftRAQAB1Iu+iUR5dNTvgWyHuP/es2fPm+++m8lkNv8pU1NT1r3F qICXxNOvUa93V2RgYXp6emZyshCGg4LXUhXF7m9y9nsgABB9BGAA2BGnSPJoOKNv or/j99XXXz/wxBNb+ixFUZaWluSMCHiwbrfbFBm42135QcMwbt+8KT4YxqngRP/b KtFfi9HmpSUAkCaUPyEAwHepVKpXgda2R8fG/B7LNomc8L3HHhPpV3wtW/rEdrs9 OTlp27akgQGbsW4GFuYqlanJyeHhYV9GtXNKrZYYGiIGA4AkBGAA2JoIRN9E/4zf H7755p69e7fxuZVKpclaTQSASL+NfkXlVR/vdDp3bt9eWFgoh+es4FWWY7BptldU /AIA7BwBGAA2K5/PJ/prK0O619dhmubps2eP/eAH2/t0al8hULqdTqNeX3c9gvj4 7du3k0NDIV0RnXD2BosvbWiI7cEA4Jaw/kgAAC/lCwVxG10KZ3nnAXEnvf+RR157 44305k45WqvT6UxNTXW+W3wI8Jd4Qjbvk4ET/XOSpqemeq9ehRZHBwOAi0J8JwcA Hgj1yUYr5YaHX3/jje2teR6Ym5trNBpuDQlwy8YZuNNu37lzZ2F+vlwuezwwFxGD AcAV4b6fAwB5Qn2y0UqdbvfM2bNPP/PMDtsR0VcEYFeGBLhu4wwsNBuN27dvi2/q sL+YxZlJALAT4f4ZAACuS2cyznG44T3ZaEDcIh87ceLMuXM7v+Nvt9tTU1NrK+4C wfHADCwszM9PTUxkstmwx2DnzKROu22apt9jAYAwCffVHwBcFI3yzg6RAfY+9NDr b76ZE1+RG63Nzs7qur7zpgCpNpOBhcmJicrMTKFY9GZU8lAsGgC2igAMAAmnQI64 ZR6LRPQtlUovv/baDrf7rlStVmviPhsIg01mYJEYx+/eXZifHwntUUkD4tuzN6Ft 261Wy++xAEDQEYABxFpkalw50pnMuZdeeuzxx11sk3OPEDq9s5EaDXsTK/YNXb97 +3a1Vgt1fSxH71Tker1LlSwA2FAUbvgAYBsiFn3Fve/ps2eP7LjS1Sps/UVIiSdt U6TBzT11RW68c/v2UJhPDB6gWDQAbCz0F3oA2KrIlHd2WKZ5/Pnnnzt50vV7dxEe ZmZmKLGDkOpl4Eaju+ljqxcXF6cmJtLpdERisKpSLBoA1gr9JR4ANknc12ay2WjU uHIYun70+PFTL7yQSqVcb1zcQM/NzTW5e0aY2f0M3Nl0BhbmKpWZqakIlIlO9L+L VVVN9F8mo0oWADhCf3EHgAfKFwqJ/r1gBGpcOVrN5pGjR8+++KJI9ZK6WFpacs5Z AUKttxi40dhq/JudmZmenh7O5SISg8X3MsWiAaAv9Jd1ANiAiL7JoaFiqZRMJv0e izvqjcbTTz/94iuvZLNZeb1omrawsCCvfcBLIgHqzaZlWVv9xKnJSZGE8/l8BGJw YlAsmnXRAOItChd0AFgrYjWuhLqmPXXkyIsvvzw8PCy1o0ajMTc3J7ULwGMiAxu6 bhrGNj5xcmJibnbWuaTIGJvHqJIFIOaicCkHgJUiVuMq0Z+Pferw4RdfecU5r1iq VqtVqVQeeIYqEEYiA4tf2/jEbrfrxOBiqeT6qHxBDAYQWwRgABGRSqWyuZx4MBqt 6Pvkk0++9OqrzjZm2QzDmJmZIf0iwizT3Hbk63Y6ExMT85VKpGIwxaIBxAwBGEDo Ra+8c6K/4PmQh9E30U+/s7OzHPmLyGu3281GI7HdF3oGMbhQLEZmUbRTJcs0jC1V zAaAMIrChRtAbPXCoW2Le9AoLXiuNxpPPfXUuZdf9mDB8wDpF7EiYp7IwPYOnvDL i6JFDI7Q3mBFUYaIwQCiLgqXbAAx5JR3LkWoxlWiX33q8NNPn33pJdllrlYh/SKG xBO+tcUjgtdtZGpyMkolsgRVUXr7IIaGWBcNIJIicrEGEB/RK+8sNJvNp48cEdFX 6uFG69J1XaRf9v0ihpwSUO2tH4+0th0RgysiBkflwKQEVbIARFdELtMA4qDQ3w0b pdXOiX7+PPLssy+cPZvJZLzvnZrPiDnx5DcNY3ulodc2NT01JWLw8PAwMRgAAisi F2gAEbZc4ypa5Z0Fcdv9zLFjp194IZVO+zKAer0+Pz/vS9dAoOykNPRaM1NTs7Oz uVwuUjGYYtEAoiIil2YAkRTJ8s6JfhHaZ48de/7UqVQq5dcYarVatVr1q3cgaDr9 0tAuroaYnZkRv7LZbJRisKqqCWIwgJCLyEUZQMQ45Z3FrehYtKKvcOzEiR8cP+7j PbH4e11cXNQ0za8BAMHkSlmsVebn52emptLpdKRicP/MJMuydr59GgC8F5HLMYDI cMo7F0ulZDLp91jcJO6AT5w8+fSRI/4OQ9zcz83N6W7seASiR6Q7vdWyTNPdZqtL S1NTU+LKFpkYLCi1Wi8Gm2a73fZ7LACwBdG5EAMIu0iebCTup8XXdeqFFx4/cMDv sSRM06xUKtytAhsT3ym6hFW+qqpOTUzY/aPLXW/cL7VarXd0sGl2uLAACInoXIIB hFevvHPkTjay+1uXXzh79uF9+/weS0+j0Zifn6fgM7AZvS3BzaYt4XDsZqMxOTFR XVqKUkH7XgxOJHqLoonBAAIvOveaAMIokof61uv1Q4cOnT53LiBlq0XorVariqL4 PRAgTHpbgptNSRObIitO3L27sLBQKpUic/VTFaX3EtvQEFWyAARZRK65AEKnF32j eKjvU08/ffbcuWwu5/dYlrXb7fn5eTb9Atvg4inB6+p0OpMTEwtzc85LgZJ68Vi3 223U612ODgYQVBG52gIIkUhGX6vdfvbo0ZOnTvl1qO+6ms2mSL9dCcs4gfhoW5bI cvK2D4iWp6emKpXKcISODhaXnXq9bhODAQRPRK6zAEIhktF3qH+y0TFfTzZaS9x9 VqtV59BOADskdTn0gMjAlenpdCYTqIvJTogArGkaMRhAoETkCgsg4Hrn+iYSAdkT 6wpxS5fL5U6cPPnU4cN+j2U10zTn5uYsjugE3CO+5Q1dNw1DdkdLi4vTU1PJZJIY DAAyROTaCiCwIhl9R0ZGTp058+j3vuf3WFYTY1MUpVqt+j0QIJosy9JlLoce0Ppn JnUjdGaSE4PFb01iMABfReSqCiCAohd965r2xKFDL5w9O7Zrl99jWYdpmvPz8+Kt 3wMBoqy3HLrR6HQ6HvTVarVEDF5cXCyXyx505wFmgwH4jgAMwH3R2+ur6/rhp59+ 4dy5XGDKO6/ExC/gJdnVoVdpt9tOsehiqeRNj7I5laLFddWb1xEAYCUCMAA3RS/6 drrdZ5599vlTp1KplN9jWZ+4D19YWGDiF/CYyKWtRsOD5dAOERpnpqcrlUp+eNib HmVzzg02LUt2dTEAWIkADMAdhUIhMTQUmXV6gki8P3juOZF+A7sHT9wQ12o1RVH8 HggQU3a322q12h4WnBOJcX5ubnZmJpPJeNapVOIiJq6xpmEwGwzAGwG9qwMQIr1Z 36GhkZGRwAbFLRH3l4Vi8dTp048dOOD3WDbSbDYXFxfbzJwAfhPhTW+1PO60Wq1O T04O9XnctQxODLZMk2saANmicNEE4Jd8Pp9MJktRib6aqh44ePD0mTN79u71eywb ETeIIvpSSRUIjk6n02o0ut2ux/026vXJiQlxTRCXYo+7lkGp1RLMBgOQLAr3rAC8 l0qlhoeHi6VSNO66RJh86vDhMy++KCK932PZiFPsqlarebbtEMAmeXZQ8FqGYYgY vLiwMDIy4n3vrnO2dVAmGoAkBGAAW9Y738i2R8fG/B6ICyzLeubo0ZOnT6fTab/H 8gAipS8tLVke7jYEsFVty2p5clDwWp1OZ2pycr5SKRSL3vfuLk5LAiAPARjAFkTp aN+hoaFjJ04c+8EPgr9+W4ReEX1Z8wyEgveVsVbqdruzs7Nzs7PBPLNtS5zTkgzD YGMwABcF/bYPQEA4la4iUOTZtu3hfP65kycPPfmk32N5MKfOs6qqrHkGwsU0Td2/ F63EFWNxYWFmejr4a1seiPpYANxFAAbwAOlMJpfNRqDSlbgjHB0dPXX27P79+/0e y4M5KwCr1ar3ZXUAuKLb6bSaTR/rOYnLiKoo05OTdn/Ni1/DcAUbgwG4JdxXQwCy RWO7b73ROHTw4Olz58KyeJvtvkA0iAhqGoah6/6OQeTGyYmJarUa6lU84gupaxor ogHsEAEYwPrS6XQ2lwv13ZIg7jsPHznywrlz2WzW77Fsiri3E9FX9/V2GYC7Ov2p 4K7fR/tYpjkxPr4Q8mLRzlFJrIgGsG0EYADr6O34TSTKIZkvXVen23326NHnTp5M pVJ+j2VTLMuqVquNRsPvgQBwn4+HJK3SabenpqbCXixaVRTDNDtkYABbRwAG8B0R iL4i8R5/7rkjzz4blj1v7Xa7Vqtpmub3QADIJQJbbyo4ABv7I1Aserk4lmX5VXAb QEiF4+4QgDeKpVKxWEwmk34PZDuc8s4nT59+4uBBv8eyWZ1OR1EUijwD8RGcqeBE PwY7xaIzmYzfY9kmVVFMlkMD2AoCMICeVDqdC+2OX3FDKUZ++uzZ/Y884vdYNktE X5F7Rfol+gIxJAKbHoyp4ET/ElqrVqemppJDQ2FZOLOSsyuYAtEANil8lzkArssX CuIGaCyEpZ41VX3i0KEXzp7dtXu332PZLHHL68z6BuTeF4AvAjUVnLhXY3lyYkI8 CF0Mdgav67qPh04BCIuQXeAAuK5Y6gnd7U6j0Xjy8OFzL72Uz+f9HstmicTrzPoS fQE4AjUVnOgnyWazOTk+LgYWuu0wLIcGsBkhu+UF4KKQHnSk9082OhOek40SRF8A K6yaYg3aVLBDXGlFDF5cXAzXzwiWQwN4IAIwEFOpVEoEyNFQLXu2TPOZY8dOvfBC WE42Stzb68uCZwArrV1mHLSpYIdlWb2jg+fnQ3R0MMuhAWyMAAzEUeg2/Yr7mGPH jz938mSIlmoTfQFsLBRTwYl+OJ+cmFiYmyuWSn6PZbM0VSUDA1hXaG4lAbglZGcd 2fYPnntOpN8QRV9xs+hEXyo8A9gqkdl6ZwUHL7mJK9v01NR8pVIoFv0ey6aIDGwY BluCAawSmhtKAK4IUckrEdFPnDz5zLPP+j2QLbAsS1GUer1O9AWwbeICYoroput+ D2QdIp/PTE/PVSqhKECoqqpJBgbwXSG4CQbglmKxWBoZCX76FdH3+dOnnz5yxO+B bIFpmrVardFo+D0QABHR7XRarVYnkOFNxODZmZnK7GzwYzBroQGsEvT7YABuyRcK IyMjAV/5nEqlTr7wwlOHD/s9kC0Qt1Yi+or7VL8HAiBqbNu2TFNcZBKBXFQSlhhM BgawEgEYiIXg13wOXfR1TstUFMUIXsUaAFHS7Xb1VqttWX4PZH2hiMHiWs3ZSAAc BGAg+nrn/Waz5dFRvweyvqGhIRF9Q7TgWdyM1ut1cTvFvjIAnhEBuNVq2UGtKt9p t6enp+dmZ4NZIqtWq1mmySQwgAQBGIiDYrE4Ui77PYr1PX/q1DNHj/o9is0SiVfT NE42AuCLwJ6TNOBUip6rVIrBi8GKoogMzAuXAAjAQMQVCgWRfoNW+Krd6Tx/8uQP TpzweyCbZRiGyL31et3vgQCIu8CekzRgWdbkxMT83NzIyIjfY/kODkYCkCAAA9GW zWZT6fRokBY/m4bxg+eeO3n6dNAy+brsvk6feNDtW/Vg5duV7/o9dgCRFfyp4ET/ aj8+Pr64sFAOzBIkcXHWNI3NwEDMheAGFMC25QuF4KTfZqt19NixM+fOpVIpv8ci nZOc7xeP75eiBw/8Hj6AEAh4cSyHrut3b9/udDoBedGTk4EBBOJiBECG3vRvKhWE ys+aqh5+5pmXX31VDMnvsYTDAwPzBtHa77ED8JTIcnqzGfDvffFTYHx8fKhf9dDf kYhLpcjATAIDcUYABiIrCNO/4lajXC7/8O23S6WSvyOJjwcm5A3itN9jB7Ady8cF B/s0cjHIpcXFyYkJ318JVTi5HYg3AjAQWYVCwd+jj1Kp1Euvvvr9xx7zcQzYkvsF 5gcGab8HDsRap9MRAVhIBL76QLfTmZmZmZ2e9vG0pN6RSJbVYRU0EFcEYCCa8vm8 SL9+LTYzDePkCy8cf+45X3qH9zYIzBu8S6kwYNt630Qi91pW27JC9yKUyOoTd+8u +FcfS1EUVkEDsUUABqLJr/XP4p7s4X37Xn/zzUwm433vCJf7zTavsur/+j1qwE/i 26Et9HNv2F9Cqmvandu3fSmLWKvVAr5iHIA8BGAgmvL5vPflr9Kp1OtvvSUCsMf9 IlY2iMr3y89+DxnYEWeyt90XsYW74ju0MjMzPTXl8YroWrWq67qXPQIIDgIwEE3D w8Nju3Z51l2z2Tx5+rT45VmPwCZtML3c6XTWvuv3eIGeQejtnULebkf7dRzDMO7e utX28Kik3jZg0xR/td50ByBQCMBANHk5AyzuzPY+9NDTzzzz2OOPJ5NJbzoFJFk3 Ht/vsd+DRaSIa6kzz+uEXr+H4x3TNBcXFhbm59PptGedsg0YiC0CMBBBhUJhpFz2 vgJWXdN27dmzZ+/eRx55RIRhH4t8Ah5w5padPLzy7doP+j1SBJQzzbus3Y7PSyri C282m0qtVlfVRrOZy+W8/4FFAAZiiwAMRJAvG4BX6VVqsayxXbtEJH7ooYf2P/qo 74cSA74YrMEe5GHH4LHzINprXOHozfGKf/HBcyA2L46IJ7lIvJqIuw0ReJt6qzUy MuLvkAjAQGwRgIEI8v0E4HWJ+55y3+iuXbv37Nn/yCN+HYABBNDahLxKfKYHo2T5 n/Ve3I3JP6L4MkW21DSt1WqJrCtYphm0n0oEYCC2CMBANO3bv9+vQ4A3r65pxVKP eDs61pstFsFYPAj+yAHvDVZcL+8RJSEHz8oJXmfSP/IT+07WFZysa5g9+eHh4F/G CcBAbAX98gRge4KwCnp7nFMuC8ViIZ8v9OPxSLm8qxeOd3tZHwUIHSd93dtP2l71 gK3IrhtURRvM3Uc47oonUqufco0+qx90LcsqFArBz7rrIgADsRXKaxaAB/L4GCQP iDtLce817BDZWCj2lEb6yuVMJuP3GIHg2iAet+NUfml7vj1M697UbvSOmBbPA13X RbgVybYXcYV+xBXEM0RcZUMadNel1GomxyABcRWdaxmAlcI7A7w94k600Wxms9nh XC437LwZFv+JmCyysrPKWkilUn6PFAgiZ+XFqlQ8eBuxpLcxu29V1g37CwRi/L1k 2w+31j3tfrJ1iH/poO3RlapWrYq07/coAPiDAAxEk0h9VF1epReSG41MJiNycjaX y4oHuWXZfmAezvc4mVl80O/xAoHgpMFBHl71INTZeDnrrjjYOVx1qsQ/gTNPa65I s50V/0bOCxjii/LlYLwgU2q1Vqvl9ygA+IOrIRBNqVRK5LyxOE0Cu0vcFuutViqd FoE5Ld6KzNyPzoMHud5083D/TT879zNzMpn0e+CApwaTxiuDcQCz8WANs71yJXNg sq4zA+8sNha/ib89qx9fB2vWvy111t9vLL6KYqlEpt02NgADccalE4isuK2C9p24 ha1rmsjMvVcfMpnltyI8i484bzOZQZzuhej+FHR/NjrnTEoz7YwoWbmOelVCltrv d4KuV/t111k4vqIc9HJR6P5e67Yzts69CN7piJFFbIdtwIn0axoGG4CB2OJqC0RW vlAos+wtVJwFma1WK5VMOkFaSPez9OAj6X6cdh45cdpJ1+kV6To/PCzepvv8/pqA 1QbluNorDGLjltr5Nt9+u4h5U5O697Jnpzfdeu+o3pWx9DslrwbuHUXlPO49ELna tllgHC6sfwZijus1EGWFYlFkYL9HAU85W52TQ0NJkZpFTO5l52Sq//jeo+WHyeWE vZy0l9O1E6374Xk5YzvBekXG9vtLRGQ5z15hZersLQo2zd7iYNN00rJ43O2n5e4a TkS17z22naR6bwH0tx/p/xl7aKhULA71+f2lwyO9+s+W1ZG8DAFAkHHFB6KMSWC4 zllK2mg2k4lEL0WLnJxcprdaQ8lkL0z0N0OLtxRjwyriWWHouqoolmXZTjTtzwg7 +wV6U7L9ueDled3+2uDeZ3ERg0uY/gXATxQg4orF4giTwACA2FMVxWD3LxB7BGAg 4tLpdDabjdUBjwAArFKr1SzTJP0CIAAD0ZcSGTiToSI0ACC2OPoIgIMADMRCKpXK 5XLMAwMAYkhTVV3Xmf4FkCAAA/HBWmgAQAyRfgGsRAAGYiSVSokMzFpoAEAc2LZd 1zTSL4CVCMBAvLAWGgAQB7VabWhoiH2/AFYhAAOxk85kctlsaWSEozUBAJGkKopp mu122++BAAgcbn+BmMoXCuL7n6lgAECUOBO/FukXwH0QgIFYEzE4YdvsCgYAhJ1t 25qmGez4BbAhAjAQd+lMDzEYABBSTvQVb9nxC+CBCMAAenoFonM58WCURdEAgJCo Vau9ehYUuwKwaQRgAN/hLIoeSibL5bLfYwEAYB22bauqKh6YhsGCZwBbQgAGsI50 Op3JZoeGhkYoFg0ACAylVuv9xpQvgO3ivhbARvL5vLjPSNi2eMwmYQCA95bne8VP InIvgB0jAAPYrEKhYPevGqWRkWQy6fdwAACR1Qu9itJ71F+FRO4F4BYCMIAtW54W 7t+giLdjzAwDAHaM0AvAAwRgADvVq5uV6N+52HYymSxTRxoAsAlO4u2tLepXm7AJ vQDkIwADcNlyHu7f2YhLjMjDlNECACT6pxYl+nE3ce/nAokXgMe4KwUg13A+vxyA ++ule7PEqRRnLAFAtImrvaIovXP1iLsAgoQADMAHg1niQSoWd0jMFQNAGC2vZF6R dZ1LeZO4CyB4uNcEEBTfzhU7+puKnb1h1NkCAH8NZnQTzpV6xeV6iKwLIDwIwABC YFB3etm9eWMnHo8ydQwAO+ZM5Hb75RuWL6orLq3i/+qtlm+DAwCXcMsIIPRWx2OH fS8lE5IBxJ4zf+vUJkwMroZrrors0QUQedwOAoiFwa5j56pnO+/Yg99t54NEZQAh snLONrHyyrXmImZ3u7quezo4AAgkbvIAYLX1p5Qd96LyygdDySSxGcBOLM/Qdrsr p2fvN087+JwWa5IBYIu4XQMAd/QmmfvlYQYfGRpMNSe+nW1OrMnP4k0qlRopl4nQ QEg5NftUVV0/wd57d4PPJ8oCgDe42QKAoFhdB3sDg8XbK951JqLlDA2IMqVWc/ZB rDzC51sbf1f2X/ZKJZP1el3W+AAA7iEAA0B09BZvO7YYpEV4HhkZYQoa4eWcQ9t7 JJ7G312LsdJ3qgD03+1S3BgA4oR7HQBAb/12WdoabNH48PBwNpt1pbVOp8Ni0ZAa SiaVajWVSsloXKnVeGIAAB6IAAwA6GVUScun0+n06XPn9uzZIwK2Kw2KkDM7O+tK U/DeXKVy+ZtvhnM511smAAMANoMADACQGIDHdu364KOPXGyQABxq83Nzly9ezEkI wLVajZXMAIAHIgADACQG4Gaj8dv/+T9dbFDTtIWFBRcbhJeuXblSXVyU0TIzwACA zSAAAwB61bNGx8ZktCx+zPzsyy9dbLBardZqNRcbhJcm7t69evnyyMiI6y3XqlVd 111vFgAQMQRgAEDvBKYxOQG4VCp9/NlnLjY4Pz/PeTPhNV+pfPP119+WK3dPtVo1 CMAAgAchAAMAJC6B3rd//5vvvONigzMzM0z0hVetWr341VeZTMb1llVFMUyz0267 3jIAIEoIwAAQd6VSqVAsJpNJGY0fPnLk9JkzLjY4Pj7e6XRcbBBeajYaX3/11eAA ancpitJqNmW0DACIDAIwAMSdvOlf4dzLLx88dMit1mzbvnPnjlutwXvtdvvrv/zF NE0ZjROAAQAPRAAGgLiTGoA/+eyzYqnkVmuWZU1OTrrVGnxx8auvGnJ2cVMIGgDw QARgAIg7eQG40Wj8g6tnIDWbzUql4mKD8N7Vy5drS0syWuYoYADAAxGAASDu5J2B JPzc1TOQVFVdlHOKLDzDSUgAAB8RgAEg7oaHh8d27ZLRsgg5H336qYsNLi0tKYri YoPw3vzc3Dd//auMk5BqtZplmtRIAwBsgAAMAHFXKBbL5bKMlr/32GOv/fCHLjZY qVSaVDkKOVVRLn71VSqVktE4dbAAABsjAANArEmtgHX8ueeOHT/uYoNTU1OSCgjD M7quX7xwQdI8LQEYALAxAjAAxJrUAPzO++/vfeghFxu8c+eOLecIWXhG/Av+9S9/ kVStikLQAICNEYABINbkBeBut/u3v/rV0JBrP2ja7fbExIRbrcFHl7/5Rq3VZLRM IWgAwMYIwAAQa8P5/JicEtBd2/7Fr37lYoOtVmt2dtbFBuGX8Tt3rl66VJbwyotS q1mW1W63XW8ZABANBGAAiDV5ZyC5XgJa07SFhQUXG4Rf5iuVb77+WkYhaNu2VVVl GzAA4H4IwAAQX1I3AD/2+OOvvP66iw1yBlJkUAgaAOAXAjAAxJfUAHzy9Okjzz7r YoOcgRQZpmH89cKFjpyFytTBAgBsgAAMAPElNQB/+OMfu3u88OTkpGVZLjYIH319 4UKz0ZDRMnWwAAAbIAADQHzJq4DVbDZ/+z/+h4sN2rZ9584dFxuEv65evlxbWpLR MnWwAAAbIAADQHzJC8DpdPqnP/+5iw2KSDM5Oelig/DX5MTEtcuXi8WijMbZBgwA uB8CMADElNT1zw8//PBb773nYoPNZrNSqbjYIPy1uLBw+eLFTCYjo3ECMADgfgjA ABBTUgPw0ePHTzz3nIsN1mq1arXqYoPwlwjAN65eldQ4ARgAcD8EYACIKXknAAvv /ehHu/fscbHB+fn5er3uYoPwV6fT+ef/9b/Kcl6CqVWruq7LaBkAEHYEYACIKXkz wK1m8zeuVsASpqamTNN0t03469/+8IdMNiujZVVRDMMQGVtG4wCAUCMAA0AcifRb LpeHhqT8FMhms+f/5m9cbNC27bt374q3LrYJ3134058MafO0rIIGAKyLAAwAcSR1 A/D+Rx994623XGyQEtCRdPvmzbnZWUmNE4ABAOsiAANAHEndAHzy9Okjzz7rYoON RmNubs7FBhEEmqpe+vprSY3XajW91ZLUOAAgvAjAABBH8maAbdv+9PPPC4WCi21W q1WRZ1xsEEEgnir/8o//WJBzFDDbgAEA6yIAA0DsSN0A3O50vvz1r91tc25urtFo uNsmguA///3fE9K2drMKGgCwFgEYAGJH6gZg0fKPPvnE3TYnJycty3K3TQTB5W++ UaXN7Su1WotV0ACA7yIAA0DsSN0AfPjIkdNnzrjYoG3bd+7ccbFBBMf83Nyt69cl Nc4MMABgLQIwAMSO1AD87gcf7Nm718UGDcOYnp52sUEER6fT+cM//uPIyIiMxm3b VkUGZhIYALACARgA4kXq+mcRVn/9D//gbpuqqi4uLrrbJoLjP/7t35JytqMnmAQG AKxBAAaAeJEagEsjIx9/+qm7bS4sLGia5m6bCI5LFy9qiiKpcQ5DAgCsQgAGgHgp FAplaQH4ycOHz5w7526bU1NTpmm62yaCQ+o2YBGA2wIV1AAA9xCAASBGpB6AJLzz /vt7H3rIxQapgBV5vW3A//RPI6WSpPZVRWmyChoAcA8BGABiROr6Z9M0/+63v3W3 TSpgxYHc04A5DAkAsAIBGABipFAslstlSY2P7dr1wUcfudsmFbDi4PrVq0sLC5Ia FwHYsqx2uy2pfQBAuBCAASAuZK9/PnbixPETJ9xtkwpYcaCp6qWvv5bXPrWgAQAD BGAAiAup659t2/7spz/N5/PuNksFrDgQT57//fvfD7v95BlgFTQAYIAADABxIXX9 89DQ0M9++Ut32+x2u3fv3nW3TQTThT/9ydB1SY33akGzChoA0EcABoBYkL3++XuP PfbaD3/obpu6rs/MzLjbJoJpZnp6/PZtee2zChoA4CAAA0AsSF3/LLzx9tv7H3nE 3TZrtVq1WnW3TQRTp93+w+9/L/EwJFVtNhqSGgcAhAgBGABiIXQHIAmzs7Ns3YyP //qP/+h2u5IaFy1rmsYkMACAAAwA0VcoFMoyp3/37N377gcfuNumbdvj4+PyEhGC 5s6tWxWZK95ZBQ0ASBCAASAO8vn86NiYvPZfOHfuqcOH3W3TNM2pqSl320SQmYbx r7//vbxXaqgFDQBIEIABIPJSqVRueFhe/We91fr1737nenktTdMWFhbcbRMB95// /u8J25bUuG3bqqoyCQwAMUcABoCIk13+atfu3e9/+KHrzc7Pz9frddebRZDdvnVr TuYqaEphAQAIwAAQcbIDsIz1z8Lk5KRlWa43iyAzTfNf/+mf5K2CZhIYAEAABoAo k13+StL6506nMz4+7m6bCAWpq6AT7AQGgNgjAANAlBWKRXm7f4Xdu3e/J2H9c71e n5+fd71ZBN/4nTszMouf1Wq1tmW12215XQAAgowADACRlS8URPp1fXp2pRdfeeWJ gwddb5YNwLEl0um//vM/l0oleV1wHhIAxBkBGAAiq1gsjsic/rUs61e/+Y2Mlicm Jpiji60//9d/WaYpr30mgQEgzgjAABBNHkz/PvK97/3wzTddb1bk6snJSdebRVjM zc7evnlTahdMAgNAbBGAASCaZE//2rb93o9+tGfvXtdbVlV1cXHR9WYRFt1u9//8 y78M53LyulBqNYtJYACIJQIwAESQB9O/6VTqp3/7tzJanpuba3BYa7xd/uYbtVaT 2gWTwAAQTwRgAIgg2dO/wtEf/ODE88+73qxt2+Pj491u1/WWESLNRuOrP/85mUzK 64JJYACIJwIwAESNB9O/zVbr17/9bSqVcr1lwzCmp6ddbxah81//7/91Ox2pXTAJ DAAxRAAGgKiRffav8PC+fW+9+66Mlmu1WrValdEywsWDUliUgwaAGCIAA0Ck5AuF 0dFRqV3Ytv3+hx/u3rNHRuPT09OGYchoGeHS7Xb/77/+azabldqLpqpsOAeAWCEA A0CkeBCAh/P5zz7/XEbLnU5nfHxcRssIoxvXri3Oz0vtwrZtVVVZCA0A8UEABoDo 8CD9CmdfeunQk0/KaFnTtIWFBRktI4ws0/w/f/hDsVSS2ouqKE0CMADEBgEYACIi nU5nMpnRsTHZHf38yy8ltVypVIgiWOnCn/5k6LrULpgEBoBYIQADQER4cPSRcOTo 0ZOnTsloudvtjo+PizQio3GEVG1x8b/++EfZRd04EgkA4oMADABRUCgURiQffSSY hvHLv/97GacfCc1ms1KpyGgZ4WXo+tcXLnQkn4eUoBoWAMQGARgAQi+bzabSaQ92 /x48dOjcyy9Lanx+fr5er0tqHCHVbrcXKpXbt24lk0mpHbEQGgBiggAMAKFXLJVG RkZk99JqtX71m9+k02kZjYv4MT4+3u12ZTSO8BJPDE1Rrly65MHaeEVRTMPwYLYZ AOAjAjAAhFu+UBDpV/b8mPDYgQOvvPaapMZZ/4z7qWuaqijjd+7IXuGfYCE0AMQA ARgAwq1QKJTlL34WAfXLv//7bDYrqX3WP+N+Ws2mZZpXL1/2YIGA6ELTNBZCA0CE EYABIMS8WfwsPH7gwMvSpn9Z/4wNmIaht3r+euGC7HLQiX5FaNM0WQgNAFFFAAaA sMoXCmX5lZ8Tknf/Jlj/jA112u1Gf3XA9atXvTmpSFXVJguhASCiCMAAEEqpVCqb y3lQ+Vk49NRTZ198UV77c3NzbLzE/Th1sBL9I5EuXLhQlr/kgYrQABBhBGAACKVi sTgifzmoYBjGl9LO/hU6nc7ExIQHNX4RXg1Nc9Yk3751S2+1POixVqtZLIQGgCgi AANA+Hi2+Fk4dvz48eeek9e+qqqLi4vy2kcEiNBrGoZ4YFnWXy9cKBQKHnSqKopp mt4sugYAeIYADAAhkxYymbGxMW+6+/mXX0ptf3p62uhnG+B+LNMcLEienppSajVv +uVUJACIHgIwAIRJKpXK5XIenHuU6O+EfPm11w488YS8LkzTnJqaktc+oqHb7dZV dflxp3Pxr3/NSDuRayU2AwNA9BCAASBMPNv6KwwPD3/2059K7WJxcVG9F2yADWiK MtgoXl1ampme9mYLQG8zsGV1WAgNAFFBAAaA0PDs1F9B07Sf//KXUsN2t9udmJjg +F9sRrPRaFuW81gk4WtXrnj2zFEUxWIzMABEBQEYAMLBy8JXwv5HH33jrbekdiEy 9sLCgtQuEBmGrotfg3d1Xf/6q69KpZI3vauqahoGGRgAIoAADAAh0Dv1N5sd9arw lWmav/i7v0un01J7ofwVNk+Ez2a9vvIjkxMTmlfr523brmsaBbEAIAIIwAAQdF4W vkr07/WfO3Xq6LFjUnvRdX1mZkZqF4gS8bTUFGXlRzqdzqWLF2W/TLNyABTEAoAI IAADQNB5Wfgq0a999ennn8teaz03N8d8GrakoWki9K78iKIok+PjyWTSmwH0CmKZ 5qoxAADChQAMAIHmcfptNhpf/OIXsktttdvtiYkJqV0gevRWy1yzZv7WzZsr9wbL RlFoAAg7AjAABJeXZZ8dB5988txLL8nuZWlpSfnuclbggUTybK1ZNSA+eOnrr7O5 nGfDUGo1k3lgAAgtAjAABJRIv4JnZZ8T/c3G5//mb8Rbqb10u93x8fHBma7AJtnd 7rpVr6rV6szUlJffKRyMBADhRQAGgCDKFwojIyOebW4UGo3Gp59/vnfvXtkd1Wo1 kVhk94JIqmtad72p19u3bumtlpcjURXFJAMDQAgRgAEgcNLpdCaT8ezQo0S/wu3B p556Uf7i5263Ozk5yfJRbM+624AT/V3lly5eFN81no2kV5Va03oZ2LI86xQAsHME YAAIFo+P/HVkstlPz5/34EQZVVUXFxdl94KoWncbsKOuad9cvFj2sGKck4GbFDMH gFAhAANAgHg/95voz6r9+PPPd+/eLbsjERgmJiaY/sW2rT0NeKWpyUnV2+JqYjwi eHOgFwCECAEYAIKil36z2dHRUS87FXfwx44fP/H88x70xfQvdu5+24AF8fGrV654 PB4yMACECwEYAAJBpN9sNlv2Nv0Kosf3P/xQduXnBLt/4ZL7bQNe/r+6funixXw+ 7+WQyMAAECIEYADwn8ifueFhL7cvOrq2/en588Vi0YO+KP4MV7Qta+Ntt4uLi5WZ GS9PRUr0X9/RNK3VbHrZKQBgGwjAAOAzv9KvSBHvffjh9x97zIO+Op3O5OSkCAke 9IVo23gbsGP87t1Gve7NeAZURTEMgzUOABBwBGAA8FNv5XMu5336FSni8JEjp8+c 8WaibHFxUVVVDzpCHIhw29nwAF6RQq9fvSqe5J4NySGe5Iauk4EBIMgIwADgG7/S rzA6NvbO++97c26qZVmTk5MedISYECFT/HrAnzGMy998k8vlvBnSABkYAAKOAAwA /khnMr2qV36k36Fk8pPPPisUCt50V6lUmuyNhHs67fZmVjhrmiYy8MjIiAdDWom1 0AAQZARgAPCBj3O/umF8+MknDz/8sDfdtVqt2dlZb/pCTPSqLqvqZlY4z87MLC0u elwQK0EGBoAAIwADgNd8TL+apv3wrbcOP/20N5FARJTp6WnTND3oC7HSajatTTyv xDPwzu3beqvlwZBWYS00AAQTARgAPOVXzedEPwwcfPLJsy++mEwmvelRZIDFxUVv +kKsWJbV2ty5u512+8b1675UIBfPf7vbbfkRvwEA90MABgDv+Jh+hbFdu95+7z1v Cl8lOPoIMm3mMKQB0zCuXL7s2TN/JfH8b9Trjc1ldQCABwjAAOCR3srnbLY8OupL 75ls9sNPPsnn8571OD8/X/f8LFbER7PRaFvWZv9ws3nl0iUvn/8DZGAACBQCMAB4 oTf3m8v5lX67ti3S79jYmGc9UvsKspmmqW+lurimqlcuXy6VSvKGdD9kYAAIDgIw AEjnb/oVOeH9jz7at2+fZz2K2/2pqal2u+1Zj4ghu9sVmXZLn7K0uHj92jW/duDX NY0MDAC+IwADgFz+rnxuNZtvvf/+448/7uVJMIuLi+oWkwmwDY16vbPF11lmpqer S0veH4yUIAMDQDAQgAFAolQqlc3lRn1Kv5qmvf7mm08fOeLl7b6u6zMzM551hzgz DWOrRxx1u92J8fGmTymUDAwAviMAA4As6XQ6k836lX7FrfZTTz99+swZzw49SrD4 Gd7axiroRL8++Z1bt/w6nrpXv1rTRO+br+AFAHARARgApPB37lfcZD/6/e+/+vrr Yhhe9kvlZ3isWa9v4wUX8Sm3btwQSVjGkB6IDAwAPiIAA4D7fE+/ex9++M23306n 017222g05ubmvOwRsEyztZVa0Cs/8eaNG+KbxfUhbYaTgQ1d9yuEA0BsEYABwGW9 lc+ZzKiHZw6tUh4be/f998UYvOy03W5PTU11u10vOwV6SVJRtve5hmHcuHbNyz0C Ky3PAxsGWwYAwEsEYABwk+/pt1As/ujjjz1Ov+JWvlKptLZYjghwRavZtLa7odfQ 9WtXr3q8VmKADAwA3iMAA4BrfE+/2Vzu408/zWazHverKMrS0pLHnQIOkR6bO9h5 3mq1rl2+LL53XBzS5pGBAcBjBGAAcIfv6TeVSv34/Pmc5/fxnHsE39VVdSfL75uN xrWrV73/3nGQgQHASwRgAHCB7+l3KJn89Cc/Gc7nPe630+lMTU1RyAf+MnRd/NpJ Cw2Rga9cGR4edmtIW0IGBgDPEIABYKd8T7+JoaFPz5/Pe55+2fqLgNjegcCrNOr1 a1ev+puBqQsNALIRgAFgR2KbfoVqtVqr1bzvF1hrJ6WwBuoiA1+54st3U+JeBm42 Gr70DgAxQQAGgO3z97xfwU4kPvv8c1/u11ut1uzsrPf9AuvqdDoNTdt5O3VNu3b1 qo8ZWAygQQYGAGkIwACwTSL95nK5sq/p9yc//akvKzYty5qenubUXwRKo17vuLGH tpeBr13L+7cWmgwMAPIQgAFgO9LpdDabjWf6FblXpF+Rgb3vGthA27LcWj9MBgaA qCIAA8CW9dJvLlcul30cw0+++MKXU1sofIUgE7mx61IRKdHU9WvX/KqJ1e12NU1r NZu+9A4AEUYABoAtKxaLI/6l36GhIZF+s9msL70vLi6qOy63C0himaaLodHfutCq ohiGQVFoAHAXARgAtsbn9JtMnv/ii0wm40vvmqYtLCz40jWwGbZtNzTNxd3p/p4P rNRqpmW5srEZAOAgAAPAFhRLPUND/lw8k6mUSL/pdNqX3in7jFBwdxI40c/A169e 9WXHQYIMDABuIwADwGblC4VyuexX+hW597Of/tSv9Gua5szMDGWfEXy9SeB63a2d wI5msykysF/7DhRFEam+TQYGADcQgAFgU/wtfJXL5T79/PNkMulL75ZlifTLXkSE hYvloAdaIgNfu+bX7gNVUUzLalN6HQB2jAAMAA8m0q+48R0dG/Ol9+F8/tPz5/2a eRa5V6RfDj1CuLh1JvBKrVbrxvXr6VTK3WY3g4ORAMAtBGAAeACRfbOZjF9H/pZK pY8+/dSv9NvtdmdnZw3D8KV3YNs6nU5D01xvVtd1kYFTfqzFEBlYVVUORgKAHSIA A8AD+Fj2WaTuH338sV/plyN/EWp6q2VKeO3G6GdgX/Yj1Go1i4JYALAzBGAA2IiP ha/Gdu364KOPvO/XIdLv/Pw8Sy4RXr1lw6oq3rresmEYt65fT/hxWVAUxeRwYADY AQIwANxXKpXK5XK+LH7es3fvux984H2/DpEZFhYW6vW6XwMAXOH6kUgDvQx844aM lh9IVVXXS3wBQHwQgAFgfT5u/X1o3763333X+34HFhcXxU22jwMA3CKyoqTiyabI wDdvyphh3hibgQFgJwjAALA+v7b+7nvkkTffftv7fgeWlpYURfFxAICLut1uQ9Mk xVTTNG/duOF9Blb6m4E5GRgAtoEADADr8Gvr7/5HHnnD1/RbrVZrtZqPAwBcJ28h dMK/DKwqSpNJYADYOgIwAKzWO/M3nfb+1N/9jz76xltvedzpSqRfRFWr0ZB3lrUv GZiF0ACwPQRgAFjNl8XPpF9Anl5FaE2zu11J7fuSgcU3bJuF0ACwRQRgAPiOQqEw 4vniZ9IvIJsIik2Zhc1FBr55/bq89tdFRWgA2CoCMAB8hwjAHld+fujhh99+7z0v e1yF9IuYMHRd/JLXvmkY169dSyaT8rpYhYXQALBVBGAA+Fa+UBj1Nv3u2rXr/Y8+ 8rLHVaj5jPgQcVFkRUmnIjlEwL529Wo6nZbXxSri+9cyTRZCA8AmEYABYFkqlcpk s2Me1r4aKZc//OQT72tNO0QYEOmX834RK3a326jXu9I2Awu6yMCXL4uLibwuVmIS GAC2hAAMAMs8rn2VLxR+/JOf+Jh+FxYW6jK3RALB1Ol0GpomtQsRRy9fvpwfHpba y4BSq5mW1WESGAA2gQAMAD0eH/ybSqfPf/FFKpXyprtVRPqdn59vUDsHcWVZVkvy 87+uaVcuXSqWSlJ7GVAUhUlgANgMAjAA9BSKxbJX07+dbveLn/0sm8t5090q3W5X pN8m98qIN9kFsYRatXr18mVviupxJBIAbBIBGAA8nf7VW63Pf/7zkZERD/paS6Tf SqWiS77vB0Kh2WhILYhl23ZldnZpcdGba4tSq7VaLQ86AoBQIwADgHfTv1q9/tn5 8w89/LAHfa3V6XRmZ2dN0/SldyBoREDtFcTqdOR10e12J8bHvTmql0lgANgMAjCA uPNs+lfcbT9/+vSzR4/K7mhd4rZYpF9L5nwXEDoioDY0TXxvyuui0+lcv3pVahcD TAIDwAMRgAHEnWfTv/sfeeSNt9/2oKO1RO4V6ZepIWAtD4pCm6Z56euvc/KLQtdq NYty0ACwIQIwgFjzbPo3k82e/+ILXw49MgxDpF+pB58Coda2LNmrlDVNExnYg4JY lIMGgI0RgAHEWj6fHx0bk92Lrus/++UvRV+yO1qr1WpVKhVvll8C4WUahi558fDU 5KSqKFK7SPRXQXc6Hbb6A8D9EIABxFcqlcpks2OSA7AIn+deeunQU09J7WVdzWZz bm6O9AtshgjAIgbLa7/b6Vy9ckVe+w7x/a6qKpPAAHA/BGAA8ZUvFEblr0h86KGH 3n7/fdm9rFWv1+fn573vFwgpER1FbpR6MJKu619/9VWpVJLXhaAqCgd9A8D9EIAB xJcHAbjdbv/tl1+m0mmpvaylquri4qLHnQJh58HBSNPT00q1Kq/9RP+r0FSVDAwA 6yIAA4gpD9KvuA196dVXnzh4UGova1Wr1Vqt5nGnQDTIPhhJtH/p4sVUKiWpfQfn IQHA/RCAAcSUB6cflUdHP/zkE6ldrCLu2peWllRV9bJTIGI67XajXpfXvqaqE+Pj UmvC12q1tsC53wCwBgEYQBzl8/mRcjmZTMrrol6v//LXv/ay8rNIvwsLC3WZN+5A TFimKbWO1LUrVzoyF1pTCgsA7ocADCCOPFj//PiBAy+/9prULlYS97vz8/MNyWeZ AvEhtSi0aPkvf/lLeWREUvsJVkEDwH0QgAHEkez1z4auf/mb38je5jcg0u/c3Bw1 bwAXiW+rZqPRabcltX/z+nWpp/WqimIYhtR5ZgAIIwIwgNjJ5/Pl0VGpG/AOPfXU 2RdflNf+SuI2vVKpMNUDuE5qQSyRfv/y5z/LnQRWFFZBA8AqBGAAsSN7/bOX07+k X0CqdrvdlLav/uaNG/JWWSf6pbB0Lg4A8F0EYACxUygUyjIDsGfTv6RfwAPyNgP3 JoH/+7/lXY5EALZMk1XQALASARhAvORF+i2X5a1/bjWbf/fb36bSaUntD1D1CvCG +F5r1OtdOTHyyqVL8s4cTrAKGgDWIAADiBfZ65/37d//5jvvyGt/YGFhQdM0DzoC IO9kYFVRpiYnZbTsoBY0AKxCAAYQL/l8fnRsTFLjtm3/6OOPx3btktT+QLVardVq snsBMCBpIbS4aHz91VeZTMb1lh0EYABYhQAMIF6G8/kxaQE4Xyh8ev68pMYH6vX6 /Py87F4ArGR3u3U5FaGnJidVRXG9WYcYsKqqrIIGgAECMIAYkb3++blTp549elRe +4Ku67Ozs1I3DQJYl2kYMooqt9vtP/3xj/JKYbENGABWIgADiBGpAVjcYv76d79L JpOS2k/0b5Snpqa63a68LgDcj23bdVWV8fLTpYsX5VXmYxU0AKxEAAYQI1LXP+/e vfu9Dz+U1Hiif/M9MzNjyDw1FMDGxDegISFMzlUqiwsLrjfrIAADwEoEYAAxIrUC 1ouvvPLEwYOSGheWlpYUaRsFAWyGbduahG/DTqfz33/8Y7lcdr3lBNuAAeC7CMAA 4kLq+me91fr1734nbxGjruszMzOSGgeweSJJWqbperMXv/46JW0DBduAAWCAAAwg LqQG4PLo6IeffCKp8W63OzU11W63JbUPYPMknQk8OTGhqarrzTpYBQ0AAwRgAHEh df3zsRMnjp84IanxxcVFVdqdMYCtqquq67XodF2/deOGpFUktWpVtC+jZQAIHQIw gLiQNwNs2/ZPvvhieHhYRuOmaU5NTcloGcD2GLpuuJ0nxWXkwp//LOkyoqpqs9GQ 0TIAhA4BGEAs5PP58uiopNmVZDL5N7/4hYyWhZmZGaZugEDpdDoNTXO92WtXroiW XW/WwTZgAHAQgAHEgtQNwA/v2/fWu+/KaLnZbFYqFRktA9gJTVVtt1dBz0xP16pV d9scIAADgIMADCAWpAbgk6dPH3n2WdebtW17enralFBvFsAOyagFbRjGzevXJS1U oQ4WADgIwABiQV4FLHkbgBuNxtzcnOvNAtg5kX5dn1AVF5M//+lPhXze3WYdtVpN JwADAAEYQEyIgDq2a5eMlru2/Ytf/UpGy9PT04ZhyGgZwA51u926hNrsly5eZAYY AKQiAAOIBXkzwKOjoz+ScAKwruszMzOuNwvALTIOQ7pz+7aknbq2bauqyjZgACAA A4g+qSWgDx46dO7ll11vdm5ursGxJUCAydgGvDA/Py9t4wN1sAAgQQAGEAdSK2C9 +MorTxw86G6bnU5nYmLCtm13mwXgItMwXN9Va5rmjWvXZK2CJgADAAEYQBzIC8Ai o37+s59ls1l3m9U0bWFhwd02Abir02436nXXm/3v//zPYqnkerMJAjAA9BGAAUSf vABsmubf/fa3rjc7OztLuRog4Gzb1hTF9Wb/+pe/ZNx+Tc1BHSwASBCAAcSBvApY 2Vzu/BdfuNtmp9MZHx93t00AMtQ1rdvpuNvm1cuXXa+t5eAkJABIEIABxMFwPj8m JwDv2bv33Q8+cLdNjv8FwqLVaFiW5W6bd2/fbspZqFyrVnVdl9EyAIQIARhA9OWG h3fJOQT44JNPnnvpJXfbnJ+fr0vYWAjAdcb/b+/OnuO67juB94ZesBGkREqyZGts LZZESpRUSioaRxOPEzuVVPIwVXnIPORlHvJP5SGpmqk8TFVSldTE5ZRVsWPLtuyS Y2kkWdY4sbhpoUQRjaWxo3vOvRcAQRAAQaBPb/fzKeLi9oLTFyDZ93zxO/eclZXV bkfK69ev34wzBYAKMEBBAAbyYHx8fDrONcAvvvTSk0891d02r169urGx0d02gRjW 19eXu71c2fz8/IdXr3a3zYylgAEKAjAw8qKugfSNb37z3AMPdLHBEH2vxun7Al23 ubnZWljobpvhTeDX77/f3TZ3mAgaQAAGRlzUNZD+7M//fGxsrIttLi4ufvbZZ11s EIgn0kTQP3399empqa43WxCAAQRgYOTFC8BLS0v/4y//srtt3rx5cy5CfxqIZGF+ vtPtSZt/8cYb9Uaju21mBGAAARgYcVErwP/9L/6iu21+/PHHpmmFIdJaXNzs9kX7 b7/1VqVS6W6bGQEYQACGXCuXy9Va7ba7Op1w5yjNQhwvANfq9f/2Z3/W3TYvX74c aQlQIIaQJ9fX1rrb5nvvvtvdBnfMNZvLozsRdL1eLxaLhWLSuQ0fnfTOtdXVzW6v 1QwMNQEYRlyj0ch6A4lOp3P7o+GBU/stkBueODc312m3i9nXFrebKBb3PC/cE542 yEXLeAF4+tSpP/7TP+1ig6GXduXKlS42CMS2srwcIlZ32/z1++9Hmgp+uAJwEmhL pexEsxNoE+mpLP3I9jrhaeF9vljc263NJr7ec+pL8/HWM9XDIYcEYBg1Ie9t7aWd hunp6dAn2H36v7OLcHJ3Dcy3+i7pUfWyz9FoNPYN+Sd37ty5b3zrW11sMHRMP/nk ky42CMQW0m/XF9f94De/ibRgb38D8O5Ae9sDuwJtujkw0J7cnrPh/NxcOztzbWds kRhGngAMQy8k3uy0nZ3XI3Uauuu2wJwdbrEYaaBavAD8pUcf/c+vvNLFBhcWFm7c uNHFBoHYYiwFfO3q1YX5+e62mWk2m5Gi9W5bF9ek56RkEzPQdldSMc6mIUwPdXNj Y63b49uBvhv0dyLgIEmlN/QqisWptMbb78M5kSy63xmJC924fKveaMzECcBPPvXU iy+91MUGZ2dnQ/e0iw0CsYWM1Or2pAmffPzx7M2b3W0z05yd7e4VK5VKZaxaTfa2 RyOHbWn7xDTU56bsF7WF7SFNKsMwMob4jQlyaGt4c9rDGIrfpp9c0v9Iu1Vra2vH S8L1en3m9OluH1fiuRdeeOb8+S42+Nlnn43S9GOQB+12e7Hb1drPb9z49Pr17raZ mZ2dXe1GAE5qvGnuHY1fwt7V7srw+vr6xvp6v48IOL4Rf8OC0VCpVJKuRrE4OTlZ KpX6fTg9tXO9VlYfzn4Vn3W2diLxnrmsdxeNk+rE2FikIdC//fLLX3nssS42+NFH H612ezYdIKrwHrXQ7bW7w9vdR9eudbfNrZYPvQa4nJ1r7phCeSfudnZdozu9nXtH Pv3utjsJqwnDkMrRexYMo2ycc+hxRBrEO6SyTtjC/PxWAK5Upqamsk5Y1jtph/5Z IemglEuliWi/Nfj67//+gw891MUGr1y5YrkOGDohAN8xxf6JLC0tXf7ggy42uCOp Vy8u3na0t0YuJ1F2entsUSeVTKHcbuc27h4i++GEnfW1tUhTdgOReBeDAZVNbZWH oWXD64/+5E+6WFsO3alLly51qzWgZxbn57u7fHcIVL9+//0uNrjbXLM5nY8raHqj 2WwW07nQxGAYFt7+YOBkF/pOi74D7/e/9a2pqalKOsz65K2FztPVq1dP3g7QY62F he6O3eh0Ou+9+65TwBCZT0cBiMEwFLy3wgARfYdI6OuMT0yMZarV7HPIwhMTE/V6 vZLeLFduCTcPH4m9urr60Ucf9ez4gW5ZarXudVakbIBxiM3tIPu0mQjxKYSosLMw P+9EMHTEYBgK3lthIISkVKvVdi5kZUiFrk+r1aqUy+U0DYfPIfhWsu12DC6n25CT ayEnbwt3rq+tzTab5VTepjqDoba8tLSerhYb3gHaO7JUu2s/C7dbcTe7c9f+5vbX hTeHYV9AKOfmms14K9sDJ+ftFfovu9x3+tSpfh8IPZLk5MXFUpp1K2lODkKHKfSd S2n6TT/KpSwKp/OvhtBcLqV3bCfk5EuObGJyMt63A8Pr6Ev4dgqFrEi7FVfTvZBo V1dX19bWwk6WY7MMHB7aFYXTrNvphP/5pnXIj/m5ufAvY1MpGAaPd2Hop5BhksKv LhEHSxZZWVgI/0JK4U8afUvJjSQBH72RLDBv5ebtyL2Vv7NK9e79tF59TwEbBkE2 hDjIPmVDim/duWNjI4uvWZo9evtJvg1flUbcTvq1HZmWgyXzYykFw+Dxlg19k6y4 GG2JWjih7BrF1tJSKZwqtoP3Vvoul4vpElNZEi/uyuRZUE/2b3+0nD5UzIrb6Z3F 4q2v29lmlfAse4cQ3u+fAfcmq3NmsTDbz6qgnZ07020nTZ63jRa+/Tk7T2unl8nu fnh3lbWzfVMQZWBlv8EMGdhVwTA4nCqgP7Lar2HPcLidBUvn5uayHmRp+/LILEUX 0oVJ77xq2lWUxxAC5Z7VbLMgurVQbGb7aWNjY9PT0zvP9NOGgyTDodWBYWA4XUEf VCqVLz766FKrpctIzu3k28WFhWwnKxRv7e3cUyzuPLOw/byS/z49lF3Ceuf92d9L lpALWTbeftrk1FS2440OspmxlpeW+n0ggAAMPRfS7/3nzu3blQQARlKn01lcXDz6 vGtAJAIw9FS5XD41M1OtVvt9IABAry3Mz6+m04b3+0AgvwRg6J3G+HilXLYgDQDk lhWSoL8EYOiFythYrVabnJx0LRwA5Nxcs7kWMrBpsaAf9MUhuiT9VquTU1PSLwBQ kIGhf3THIS61XwDgTjIw9IUeOUQk/QIAB5GBofd0yiGiiclJ6RcAOIgMDD2mXw5R VCqVWq0WAnCpVOr3sQAAgyvJwOvr5oWG3hCAIYrG+PipU6f6fRQAwBBoNpsry8v9 PgrIBQEYuq9cqVTHxk7NzPT7QACA4TA/P7/UavX7KGD0CcDQZZWQfmu16enpfh8I ADBMFhYWWouL/T4KGHECMHSZwc8AwDG02+2QgZeXlvp9IDDKBGDopnK5XK1WDX4G AI7BQGiITQCGrimnMz+P0uDnTqfTWlwslcthv725OWFJJwAGQDg9LadTRoWd8fHx ETs3GQgNUY3U+wX011APfg59iLXV1fGJicmpqanp6ZmZmfvPnr3v/vvHxsZ2nrO2 tjbXbM7Ozi7MzydjtFqtpeXlpaWl1eVl2RiA7spOTPVGOLuOh49wogmnp3CePXPm TNjf/cy5ubnPPv109ubNcJJaXFxcWlxsLS2Fs1m/jvyEDISGqHRYoTuGaObn0KXY WF8PvYetzsTMTAi6oT9RrVaP3War1QrJOPzJfm+dxOKlkI6XQ5uCMQAHyWq59Xo9 jbmN8cns17DTp8+cCWG3nA5BOp6Qij//7LPZ2dn5ubnFcG5KTUxMdPHg4zEQGuLR MYUuqKSDn6cGcvBzu90uFIszp06FnsTMmTNnz549c999u+u6sV89ROIQjOfS/sfS 4mISi5eWVkI2rtVkY4A8CCl3aWmpEWJulnJDDE1/AztzOtGzU1IhHV386fXrNz// fC4E42Burt5o9OzV70k4tiVFYIhA7xO6oDE+Pj09PSBxLmTOUrF45v777z979gsP P7xnGPPg2NzcXJifbzaboQfSyurGqZCNx9SNAYZNUstdWUlSbiORpNyJieyamhB0 TzLIKKoQiT/68MPPrl+/ceNG8+bNwcnDc81mdp0z0F26mHBSg7Dwb+h2hND74MMP f/FLX3r4kUdqtVofD+bkssm3smyc1I1braW0aLyS5OOV0ZvvBGBYtNvtzY2NkBK3 Bi1ntdypqRByT83MnGTE8oD4/PPPr1y69NG1a9evXw/fX38PxmxYEINOJJxUH+e+ Ch2RWr3+2OOPP/bEE8M728e9Wl9fn2s2szHVoWcQ4nGai1fCx+rKyqTpuABOIJt6 Kpxc6mktdzydfWpye8Ry3zNhz4Sfw9UrV/79/ffDNvw0+nIMyWVE8/PqwNBduolw IsnCv7Va7wPw+sbGVx577PyFC6E70uOXHnAhCWeXdYVsnMTjpaWVJBwvr6YajYZ4 DOTc4sJCNYTb2nbI3VXIDaczs/rvEZLwr//f/3vv3XeXWq3e/2RCAG6ZDQu6yhsc nEjvy78bm5sXnn32wnPPVSqVXr7uaNjc3Aw9v2RkdRqPl9OpqleTiLyytrYmIQPD LrmEZGmpWq3Wwp8s5Y6PN+r18ayKGyLuzMxgTgwx+D6/ceP1H/0onEF6eZoIf6Hh FS2JBF2knwfHl5R/q9WeLX20sLDw+BNPvPy7v1vv01isPGi3261WayFNyNng6tDt CMl4ZXU1ycdra+tra0Iy0BdJuG21qqkQbmvJp9rOjFOT2wu5+/VoVFcuX/7h97/f y6udTQcN3aUPB8fU46WP1tfXX/7a1x5/8snevByHCCE5pOKF7SHWIRL/6pe/zCKx YAycXAi6YRveXi48+2ySb7dGKCcF3BGYZWoEbGxs/PM//dPCwkJvXk4RGLpLXw2O qZdLH4Uez+994xvnHnigB6/FSSQF43TO6mw9p+Sy45WVtdXVtfX1kJPDNuyH3WwO VWkZ8iNbCLdSLo9Vq2NBdVuttjVWeWfGqYmJ8OH9YfD96Ic/vHLpUm/+piyJBF3k 7RWOo5flX+l3VIVEvLP0cXIdcjrKei29FjmE5I2NjWy7sb2/ubmZzb+qZwx9lF1k WymVyiHHVlJJok12w8dYrZZG2iTY1rZSbZJrXboykn70gx9cvXKlN681NzenCAxd oRcFx9Gz8m/IQi+/8soTRj6zLSThbNaubF7rtdR6Ul1e39gJzJuJsJt92tzWTj7a 2TXMUjR5k40rDtm1XCyWyuVyCKzlLaX0ViW7Mw20WaqtpqXasSzNplfbhhwbwm2/ vxUGyD/+/d/35gJdRWDoFh0guGfltPw73ZPy78Nf/OIrv/d7PXgh8mZrUHaanLdK zanNrU9pWs5ic7udBelO+3adzq7dTvKEVHh2yBnhy8KrhP0QO8LDO9udsZ0SeN5k +TMZCZyu6VIqlW5t00mbytv3lMI/jlIqRNNsN93ZunPbTnZNttnNLL5m2TZNsNvV 2bEsxPbz+2dEhX/Sf/NXf9XoyfLIisDQFfofcM96Vv6dnJz85h/9kU4bIyxk7ywX baT5eWsnDc8hdG/dE3bSe3bb3O9O4immCfPOOyvpneH9sLy9U0mX2Anvj5XttXaU TBltly9d+vEPf9iDXoEADF0hAMM9azQaPVj6aH1t7eVXXnn8iSdivxAAcBL/5x/+ YbEnk0LLwHByAjDcm56t/fvAgw/+1z/4g9ivAgCc0Orq6v/867+enJyM/ULz8/PZ RQTAsQnAcG8a4+OnTp2K/SrVWu0b3/zmTPyYDQCc3FtvvvneO+/EfpVkTeC5ObNh wUkIwHAPyuVyrV6PPf1Vq9X67d/5nWcvXoz6KgBAF/3vv/3bdvy5CRYWFlqLi7Ff BUaYAAz3oDfl3zNnznzrj/849qsAAF108/PP//nb3+7BbFiffPxx7JeAESYAw1El qx9Vq9PxA/ArX//6w488EvtVAIDu+t6rr17/5JPYr2JNYDgJARiOqjE+PjU1la1a Gc8XHnnkv3z961FfAgCIoTfLApsLGk5CAIaj6sH453qj8Qd/+Ic9mEYSAIjh/ffe +8XPfx71JULM7kGdGUaVAAxHFTsAh/PZf/rKV17+2tfivQQAENv/+pu/qVQqUV9C ERiOTQCGI0mW/63V4laAi8XnX3xxcmqqvK1UKpVvF3sANgBwQu+8/fY7b70V9SVc BgzHJgDDkTTGx6enp+NN7djpdE6dPv30+fOHPy0cwL7BeHdg7sH8kwBA+wAbGxv/ +Hd/Nz4xEe+lBWA4Nh1lOJLY45/DyfLpCxfO3HffyZvaE4+VkQHgrjqpgzLtjs3N zWwne/5Brb337rvzzWbUo3UZMByPAAxHEjsA12q15196KV77uykjAzDyjpJm9+ji q7cWF99+882oJ9Nms7miCAz3Th8XjqRer8+cPh2p8YXFxSeefPLRL385UvvHcEgZ OdsPWyEZgJ651zR7SHm2N378gx+E02W89s2DBcej/wp3l8yAVa2empmJ1P7m5uaz zz8/NT0dqf1IdgfjOxOykAzAvnZqs4cXafc82u+jvmf//v77n9+4Ea/95uzsyspK vPZhVOmbwt3FHv9cbzQuvvhivPb7aN9gvLuMbLg1wFDbN8TeNdn2+6h7YXVl5Rdv vBHvHGcINByPfifcXdQAPIDjn3ssuyZ5TyrevVVMBuiNu2bXOyNuTtLs8UQdBW0e LDgeHUq4u6gBeGNj48LFi/HGV4+MUkpOBrirPRMa78m0h9zs94GPmvffe69582a8 9l0GDMegpwh3F3UGrGq1+vxLL4lt3bIzx/VONt69Y+g1MER259hs54ixVlV2QCzM z//y7bfjtW81YDgG/T+4i5CUxsbGIgXg0EeZOXPmqWeeidE4hwsBeN+QvG9s7vfB AkNsz4Dhg3buvFOOHQH/+uqr9UYjUuMqwHAMAjDcRdTxz6urq1995pkHHnwwUvt0 S+nIstqy8jKMjJ0y7EHbw28KsTn31r/9W7ypqsI/sE+vX4/UOIwqXTS4i7hTQBeL F194Id7vhumXu+bkrP68e19mhq7bnV33hNKj3NzZ7/f3wRC7duXKh1evRmrcPFhw DPpbcBdRA/AIL4DEvcrqxock5D37u3f6fezQNZ1ddvLnnTf33b8zwfb7u4HC+vr6 z3/603hv1C4Dhnul2wR3EW8GrNA/O33ffV99+ukYjZMfxW1ZGL7XnT37/f5uGAKd OxS2F4Pd99EjZlqRlVH1r//yL/VaLVLjLgOGe6WvA4eJOgPWyurqU08//cBDD8Vo HI5h30i8OxvfeefxHu3z9zkSdifPwq7YeZT93TcPuv8Q/fumYSi9+fOfr66sRGq8 OTu7Eq1xGEl6IXCYqOOfQ8i4+OKLtWi/FYZBtpOKu7Ld0+y+r3W8O/fkvTvj3+FP 2PfmUbZHeQIwFD768MOrly5FalwAhnslAMNhXAAMAJxE1MuAO+bBgnskAMNhogbg icnJCxcvRmocABgQ3/32t6ejdScWFxYWFxcjNQ6jRwCGw9QbjZmZmRgttxYXH3vy yUe//OUYjQMAg+Mnr71WijcRtHmw4F4IwHCgcqVSHRs7FScAr6+vn3/uudNnzsRo HAAYHO+988783FykxpvN5oqVkODIBGA4UGN8fHp6OtJFO2NjYy/81m+ZDhcARt5c s/mrd9+N17ilgOHodL7hQFEvAG5MTDz3/PORGgcABsrrr70W6bfe7Xb70+vXY7QM I0kAhgOZAQsA6ArzYMGAEIDhQI1GI9IFwEut1hNPPfXIl74Uo3EAYND87Cc/6bTb kRo3DxYcnQAMB6rX6zOnT0dpuli8+OKLof0ojQMAA+bDa9euXb4cqXGXAcPRCcCw v3K5PFatRloDqVarPf/SSzFaBgAG0Orq6ptvvBGp8ebs7MrKSqTGYcQIwLC/qBcA j09MPGsGLADIk3jzYFkJCY5OAIb9xQvAnU7n1OnTT58/H6NxAGAwff/VVxuNRoyW Q9fi+iefxGgZRo8ADPuLF4BbrdYTX/3qFx99NEbjAMBg+umPfxyiaqTGzYMFRyQA w/7iTQFtBiwAyKEPr169duVKpMYFYDgiARj2V6vXT8eZArpaq71gBiwAyJkQUP/v L34RqXETQcMRCcCwj2QK6LGxSGsgNcbHn3vhhRgtAwCDLN48WLOzs6smgoYjEIBh H1GngJ6cmjr/3HORGgcABtar3/nO1NRUjJZv3ry5troao2UYMQIw7KNarZbL5RjX AM/PzX3liScee+KJrrcMAAy4H37ve6GPEaNlSwHDEQnAsI94FeCl5eWnz59/8KGH YjQOAAyyf/vZz9bX12O0bClgOCIBGPYRLwCPjY09/9JLpVIpRuMAwCCbazZ/9e67 kRr/5OOPI7UMo0QAhn3EC8D1RuPiiy/GaBkAGHCdTudnP/5xpMYFYDgKARj2EW8R YFNAA0CexZsI2lLAcBQCMOyjXq/HWAOp0+mEXP30hQtdbxkAGArf/+53G+PjMVq2 FDAchQAM+6jV66cjBOClVuvxr371i48+2vWWAYCh8LOf/KTTbsdo2TxYcBQCMOxV LpfHxsZiVIDXVleffvbZ+8+e7XrLAMBQePvNN5darRgtGwINRyEAw17xZsDa3Nx8 9oUXpqamYjQOAAy+//j1r298+mmMljudzvVPPonRMowSARj2MgU0ABDPT3/0o0gt mwga7koAhr0EYAAgHgEY+kgAhr3irYE0MTV14bnnYrQMAAyLV7/znUjXQ7kMGO5K AIa9Iq2BND8399iTT37l8ce73jIAMERe+973xqrVGC1bCQnuSgCGvSKtgdRqtZ46 f/4LDz/c9ZYBgCHyxuuvb25uxmhZAIa7EoDhNskaSNXqTIQh0Gurq888++x91kAC gHx75623WouLMVpuzs6urKzEaBlGhgAMt2mMj09PTxeL3f+vkayB9PzzU9PTXW8Z ABgi8VZCUgGGuxKA4TamgAYAYos0EbSlgOGuBGC4jQAMAMRmJSToFwEYbhNvDaTx iYlnn38+RssAwHB5/bXXYlxvVbASEtyNAAy3qTcaMWbA6nQ6M6dPP3X+fNdbBgCG zr+++mrocsRoWQCGwwnAcJtIiwAvLi4+/uSTj375y11vGQAYOhErwObBgkMJwHCb SIsAh1PRMxcunHvwwa63DAAMnTffeGN1dTVGy81mc0UAhoMJwHBLuVIZGxuLMQR6 fX39wsWLMWrLAMDQ+dUvfzk3OxujZUsBw+EEYLgl3hTQnULhuRdeGB8fj9E4ADBc rly69PGHH8ZoWQUYDicAwy3WQAIAesNSwNAXAjDcIgADAL1hKWDoCwEYbom3CPDE 5OSFixdjtAwADKNXv/OdqampGC1bCQkOIQDDLfEWAZ6anj7/3HNdbxkAGFLf++53 I00OIgDDIQRguCXSIsA7QhJeXl6u1Wrhherj441G477775+OM+gaABgEH167ttRq hUS6srKyurwctrFP/QIwHEIAhi3lSqU6NhZpCPQhQipeXFysbcXier3RuP/s2TP3 3dfjwwAATujSb36zFILu8vJqyLqrq+GsXiz2obNtImg4hAAMWxrj41NTU6VSqd8H siUpFy8tVdNcnGXj+8+ds5IwAPTd5Q8+WF5eToJuELJu/KLuPZmdnV21FDAcQACG LfGmgO6uLBiPVatZMA4J+dwDD5w+c6bfxwUAo+aD//iPEHRXs6C7urq2ujpQQfcg zdnZFQEYDiAAw5ZhCcAH2RpKXa2O1WrZgOrw5+zZs0NxqgaAfrl6+fLy9qDlsF1f W6s3Gn0ZutwtlgKGQwzx/23ormEPwIcIJ8LW0lJ1bKwagnG1mtWNz547JxsDkBNX Ll1aSccqZ4XckHLDqXBwrnvqOksBw0EEYNgywgH4EFndeCxk40wIyGn9+L6zZyMt TggAMXx49eqtiLu2th5S7vp6OLkPdS332ARgOEge3xFgX41Go/dTQA+4nXg8llaP sxpyyMrnHnhganq630cHQL5kVdysfrsW0m2+I+7hrIQEB/F+AVtiLwI8krIZucoh GG+l5GryZ2wsJGTjqwG4J5d+85sQbG/l27DZ2NhYW3NCOYa5ZnPZSkiwHwEYEuVy uVqtqgB3XUjIC/PzlUolBONKmpMr1a2w/MCDDyojA+TEByHcpsl2PbWRbjc3NsYn JtRvY7AUMBzEOw4kBm0R4LxJpulqtSqZNB5nmTmLyvefOzcxMdHvYwRgr2tXrmTF 2pBsk0y7sbGzDeFW5baPLAUMBxGAIZHPGbCGTlJPXlgol0ohFZcrlfBnLN3ujs1n z50Lf5v9PlKAYfXRtWtru+q0IccmNjc3k4ptYlLNdhioAMNBvH9BQgAeSVlhuVxO MnL6kewlmzQqZ3c88OCDAjMwwq5evpwVZZMYu7MNQXY71m6221NTUzLtiLEUMBzE mx0kBGAyycTXITMXi1lUvs12tTm79cBDD9Xr9X4fL5AX165c2UiHFm9l142NdlqP DTfb6XYz3RkfH3c5DxkrIcG+BGBICMCcUEjOO/ulcrleq5V2YnOqlFaba7VaHw8S GBAfXr2ajStup2E2i7LBjU8/3ZkdUEmWk1ABhoN4b4WEAExfZFc1l0I/t1RKAnMp lX7eubW1v6sUHZ7+0MMPV6vVfh8+5MvVy5ezmNpubyXWdrrfzu5Kd27dTDedQmFy clKUpS9UgGFf3pEh0Wg0rIHECMjWncoCdTHE5nQnc2svubH9wE7oTp+fJe/w6INf +EKlUun3dwP35qNr13YCapZDO+1t4c7O1q3waTPdbknv76RPCFwNy8iYm5tbXlrq 91HAwPEWD4l6ozEjAMMRpBkhmV0s7CdBOkgz81bqTj/t5OutJ9y6Xdq9vzuJF4rF hx95JGTwfn9/dMe1K1e2smVIoZ0sYnayFNrZTqHZfrLZfsLWQ9v3b2b/2tKvCm1O pJMPS6dwRAIw7MtZBBL1en3m9Ol+HwVwd9nl1gsLC2EvC9vhTBZCeNhmc/+EuwrF XbI7wzOzr8/y03aIKhZ2XWp5585QSX4u6Q9nz86ty9Oz/e2HQtRMdrLAmSqkWbSQ PhQ+heTZyX7lEZ5ZLE5NTRWG9WcDeTTXbC5bCQnu4DQGhXK6iKwKMAAwMpqzsysr K/0+Chg4AjAkM2BNT08rawAAI0MFGPalxw+mgAYARo2VkGBfAjAIwADACLISEtxJ AAZrIAEAI2h+bm7JRNBwOwEYrIEEAIwgKyHBnQRgKJTL5Wqtli1vWiwWp0+dMiEW ADB0Qk9mfn4+6c8UklXLpF+4k14+7KMxPr61JxUDAIMnybpzc51d65kb7QxHoUMP RyUVAwC9tyfrho3SLhybvjuciFQMAHTLnjHMBVkXuk03HaLYCsZSMQCwn2azmXUS ioIu9JAeOfTOrVScbsNm5vTp/h4SABDV1gDmNOsq6kLfCcDQZwZRA8AICCfxubm5 QhZ0CwYww4DSyYYBJRgDwGBqNpvJSK7srCzowlDRmYYhc1swTjfh/HtKNgaArrpz 6HJB0IXhp8cMo2PnGuPCdjCemp4ulUp9PiwAGFQ745aVcyEnBGDIhT0DqpO1BNWN AciHnVqulAvo+0Le7c7GhSwgi8cADJV9I25BygXuoHcLHOZWPC7cWsDJjFwA9FI2 UDm5uqdQ2D3HckHEBe6R/itwIvsmZDVkAI5ub/22IN8CseibAtHtGWVd2E7KKskA o2135XbP4OSCcAv0g34nMCj2FJOTTUE9GWDgJLG22dxaH6hQULYFhojeJDB8QlQu ZvG4sKuqXLgtLRd2dckAONxWqbbd3qnT7sm0BbEWGAl6h8Dou7O2XNgOzOmmUyqV pmVmYFQcmGYLAi2Qd7p6APvbNzYXdifndKdYKhmeDcTQbrfn5+dDjt097/GdhdmC KAtwZHpsAF1w26jszO5Sc2FvZp6eni6menuYQH/sLclm9rwFyLQA8el7AQyQ28rO O/arP+/ez6rQBUO4oUtu5dXC3rrrIZE1+y2Y4AowyHSVAEbc+Ph4Z98HOnvv3nde sWw/mVpsZqYgYzMAdqYg3rq9Xyg9JKbuJqwC5I1+DADdsX/5escdeXvr7v2e0Lnj HlXuAZHFzrm5uXa7vWdepb1/MfveWTgsju6QSwGIRDcCgNF0l0DOLgInADkhAAMA AJALAjAAAAC5IAADAACQCwIwAAAAuSAAAwAAkAsCMAAAALkgAAMAAJALAjAAAAC5 IAADAACQCwIwAAAAuSAAAwAAkAsCMAAAALkgAAMAAJALAjAAAAC5IAADAACQCwIw AAAAuSAAAwAAkAsCMAAAALkgAAMAAJALAjAAAAC5IAADAACQCwIwAAAAuSAAAwAA kAsCMAAAALkgAAMAAJALAjAAAAC5IAADAACQCwIwAAAAuSAAAwAAkAsCMAAAALkg AAMAAJALAjAAAAC5IAADAACQCwIwAAAAuSAAAwAAkAsCMAAAALkgAAMAAJALAjAA AAC5IAADAACQCwIwAAAAuSAAAwAAkAsCMAAAALkgAAMAAJALAjAAAAC5IAADAACQ CwIwAAAAuSAAAwAAkAsCMAAAALkgAAMAAJALAjAAAAC5IAADAACQCwIwAAAAuSAA AwAAkAsCMAAAALkgAAMAAJALAjAAAAC5IAADAACQCwIwAAAAuSAAAwAAkAsCMAAA ALkgAAMAAJALAjAAAAC5IAADAACQCwIwAAAAuSAAAwAAkAsCMAAAALkgAAMAAJAL AjAAAAC5IAADAACQCwIwAAAAuSAAAwAAkAsCMAAAALkgAAMAAJALAjAAAAC5IAAD AACQCwIwAAAAuSAAAwAAkAsCMAAAALkgAAMAAJALAjAAAAC5IAADAACQCwIwAAAA uSAAAwAAkAsCMAAAALkgAAMAAJALAjAAAAC5IAADAACQCwIwAAAAuSAAAwAAkAsC MAAAALkgAAMAAJALAjAAAAC5IAADAACQCwIwAAAAuSAAAwAAkAsCMAAAALkgAAMA AJALAjAAAAC5IAADAACQCwIwAAAAuSAAAwAAkAsCMAAAALkgAAMAAJALAjAAAAC5 IAADAACQCwIwAAAAuSAAAwAAkAsCMAAAALkgAAMAAJALAjAAAAC5IAADAACQCwIw AAAAuSAAAwAAkAsCMAAAALkgAAMAAJALAjAAAAC5IAADAACQCwIwAAAAuSAAAwAA kAsCMAAAALkgAAMAAJALAjAAAAC5IAADAACQC/8fO3B23f74RIoAAAAASUVORK5CYII="/></symbol><use xlink:href="#c" width="1280" height="1280"/></g></g></svg>')} +.is2d .knight.black {background-image:url('data:image/svg+xml;base64,<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="614.635" height="614.635" viewBox="0 0 460.977 460.977"><mask id="b"><use xlink:href="#a" width="1280" height="1280" transform="rotate(.193) scale(.36014)"/></mask><symbol id="a" viewBox="0 0 1280 1280"><image width="1280" height="1280" xlink:href="data:image/png;base64, iVBORw0KGgoAAAANSUhEUgAABQAAAAUACAAAAAA9j6ArAAAACXBIWXMAAA7EAAAO xAGVKw4bAABJTklEQVR4nO3dd4BU5f228f3BsrSlFxEFsaGiQbBEbEHsigV9rYnG xK6oEWMviSaWaFRULGgsscWCDQULCHYsWEApgiBVpHcWWHZ3XkGFBbZMOefcz/N8 r88fiQVmb2b2XO7uzJzzf3kAYNT/qQcAgAoBBGAWAQRgFgEEYBYBBGAWAQRgFgEE YBYBBGAWAQRgFgEEYBYBBGAWAQRgFgEEYBYBBGAWAQRgFgEEYBYBBGAWAQRgFgEE YBYBBGAWAQRgFgEEYBYBBGAWAQRgFgEEYBYBBGAWAQRgFgEEYBYBBGAWAQRgFgEE YBYBBGAWAQRgFgEEYBYBBGAWAQRgFgEEYBYBBGAWAQRgFgEEYBYBBGAWAQRgFgEE YBYBBGAWAQRgFgEEYBYBBGAWAQRgFgEEYBYBBGAWAQRgFgEEYBYBBGAWAQRgFgEE YBYBBGAWAQRgFgEEYBYBBGAWAQRgFgEEYBYBBGAWAQRgFgEEYBYBBGAWAQRgFgEE YBYBBGAWAQRgFgEEYBYBBGAWAQRgFgEEYBYBBGAWAQRgFgEEYBYBBGAWAQRgFgEE YBYBBGAWAQRgFgEEYBYBBGAWAQRgFgEEYBYBBGAWAQRgFgEEYBYBBGAWAQRgFgEE YBYBBGAWAQRgFgEEYBYBBGAWAQRgFgEEYBYBBGAWAQRgFgEEYBYBBGAWAQRgFgEE YBYBBGAWAQRgFgEEYBYBBGAWAQRgFgEEYBYBBGAWAQRgFgEEYBYBBGAWAQRgFgEE YBYBBGAWAQRgFgEEYBYBBGAWAUTuWjz+8R1F6hFA5gggctZ6dOO8H7dfrJ4BZIwA Ilebj2nw0//O3pYCwjsEEDna6uv6a/5/9vYLxEuATBFA5Kb9iLq//NW8bSkgPEMA kZMdv6i99q/n7TBHuATIHAFELjp9WlDu7xa2p4DwCgFEDtbvHwWEbwggsrfjlwUb /BMKCK8QQGSt/M//fkUB4RMCiGxV1D8KCK8QQGSp4v5RQPiEACI7242suH8UEB4h gMhK27H1Kv13FBC+IIDIRosJDav4txQQniCAyELD75tV+e8XbsW74uADAojMFUzc vJpfMW8rzg0DDxBAZO7r31T7S2ZtxRlS4T4CiIy9fUAav2jG1itiHwLkiAAiUw+f kdYvm9K+OOYhQK4IIDLU6840f+GEHUpiHQLkjAAiM4e+nvbnzJjflMW5BMgZAURG 2o+qlf4v/nz3+IYAESCAyESdGU0y+eVD03m6BJAhgMjEF7tk9utfOD6eHUAkCCAy cP95mf6Oh8+KYwcQDQKI9B3XL/Pfc9O10e8AIkIAkbaW0zY8A346LuoT+RAgIgQQ aZuwdTa/K3ViFl83AokggEhXmu8A2UjZge9EOwSICgE0o0XJopxel3zA4Gw/WVb9 ZlwuHxiIDQE045EuD/fO4bcXzG2Q9e9dtiUnSIWTCKAVe71TsKL/tROy/v2DDsrh g8/eglPDwEUE0IjWr+/80/+Ou/aFLH//yf/L6cOP3y6n3w7EgwDaUHjzBWse6qKB d36WzU8C68yvm9uAd/bP7fcDcSCAJtQ5/abGP/9V6fCbX8viBt48JNcJD52T6y0A kSOAJhzwcLtf/7Js8v39pqUy/P0HDcp9w2W3534bQLQIoAn9jyr3N2XvXTsss99e Y17j3Dekjnsp9xsBIkUADah3wXWF5f++bOz1mT0X8sC5Ucwo3W1EFDcDRIcAGnDq jW02eJxXvXLB7PR/f+tpNSLZUbRlBh8USAABNGBUh40e5tTk3o+nfeXeLztHNGRW W66TBKcQwODVOKNvRV/ALXzykjSvWXT0K5Ft+aZjZDcFRIAABu+gh9pV+M+Lv+w7 YF46NzC7RXRjXj06utsCckYAQ1fvzX0qe5BnP3JHGgW84l9Rzrn1yihvDcgNAQxc zZMfr/wZjMXP/3va8mpuoGBRnUgHnf5YpDcH5IIABm6PRztU9a9XTvrHM1XfwCOn RzknL6+s64fR3iCQPQIYtpZ3nVj1S1hSE8+u8nSljebmRzooL694h+8jvkUgWwQw bBfdVFjdLykZcEwV//blHhGu+dmiLRZFfptAVghg0HZ9avvqf1HJm9d/Udm/a/VD NK+BXs/UrdN8AQ4QMwIYtKdOqpnGryoddlFlb1J7+4Ao5/zqsz3iuFUgYwQwZEc+ 1TCtX1f6zb/6V3jK5tbT4/kEef7EWG4WyBABDFiT17uk+0vn3/hIRe+Mi+cLwDwu lw5HEMCA/fsvtdL+tUVP3jx1o38Y1xeAP/nT43HdMpA+Ahiu1iMyeQ/bqscv3Oi7 4AHdI5yzPi4WDBcQwGAV3HFBZr9hymFj1/8HDeen8xRKllbtPLb6XwTEiwCGqtaJ dzXL8LeMOuuT9f7+iVOjm7Oxoq1nxnnzQBoIYKh2emy3TH9L6vMjyp+xtGBJQYR7 Njav3dJYbx+oFgEM1c2XZf4ettSYk0at+7sbr4lwTkWmbsv5UaFFAAPV6eV2Wfyu 1Dc9152qYH6TyNZUYuxO2VyjGIgMAQxTo4ePyeoJjNTwM379GvDYFyPcU4lP036h IhAHAhimnjc1yu43lr53/rif/+rb7aKbU6lBOV9wHcgBAQzTiI7ZPrKpwedMXv3/ UVwLPQ0DjkzkwwAVIoBBOvnpHB7Y4aetfoVelFcCqcpL/y+ZjwNUgACGqO0bVZ4G uhqpd376LrhgZWRrqtHvhKQ+ErAhAhigujdfmNNbOFLP/77sn8mdrYACQoYABqjz gNY53sKXXSdn+jaSHFBAqBDA8DS67axcH9bUhG0jmZImngmBCAEMz/H3N1dPyNTg g9ULYBMBDE6T5w/w71H9ZG/eEwIB/w4VVOP8W6u9EJyDRnfiQklIHgEMzebPd/Hy QZ28Y5F6Auzx8lhBFa6/oo56Qnbm7DBPPQHmEMDQTGmrXpCtJR0nqyfAGgIYlhqH DvD3IV3xu+HqCTDG36MFFfi/7e/dX70hB6UnvaCeAFsIYFDqXXapj08Br5W68jb1 BJhCAIPS6akOnj+iD56rXgBLPD9csL5et2V+IRDH8KYQJIgAhqThoD3UE3I3ZteN LtAOxIQAhuTim+qpJ0SgdOysmT9Omzjh+1XqJQgeAQxIs0Gdg3o8y4qLFs+fNWPK xHFjeZcIYhHUAWPdaX09fRNI9VKripbMn/PDxLFfT+CsCYgOAQxHo6e7qyckoaRo 8dwfpn43esRs9RL4jwCG4+Q+CZ7F2QGp4mULf5w07qvP5qiXwFsEMBh1Xzi0hnqD RtmKhbMmjfniI0KITBHAYLT/tLF6glhZ0bwfxn3x7mj1DviDAAajZx8ezDVSRXMm j/psyAz1DniAYyYU7Z7eSz3BLaULp436ZPB49Qw4jQCGouet9dUTXFS2eNrId17j p4OoGAEMxaCD1AscVjzr22GvfaFeAfcQwEC0Gt1UPcF1ZfO+ff+FEeoVcAoBDETP 3rXUE7xQOmfMu09/r14BVxDAQHywj3qBR1ZO+eSFN7gMJwhgKDb/lqdAMpOa+80b j3EdOusIYBBqnvaIeoKXFo18+bFF6hEQIoBBaHHvCeoJ3low4sXHl6pHQIQABmH3 F7y9GrATZr3X9x31BigQwCCcdb/31wJRWzXm5Xv5kaA5BDAIT5yqXhCEee/f+aF6 AxJFAENQ+GkH9YRQLB/+4LOcc9oOAhiCE//TQD0hIKWjn76Xa5AYQQBD8NTJRk+F GpfUxMfu5OKcFhDAEHzZiccxamVjH7qfN4sEjwMnAHW+3UI9IUilI+99nJ8Hho0A BqDbsy3VE0K16r2rh6s3IEYE0H81z7mNNwLHZ+7Tf+fdcsEigP6rdcUNPAcSp9So 255Sb0A8CGAA/n2pekHwVrzai4sshYgA+q/whUPUEwxIjb62v3oDIkcA/bfHk9uq J9iw8LFreYF0YAig/068exP1BCtKP/jL1+oNiBIB9N+xjxeqJxjyXa+B6gmIDgH0 X9fBXA8pSbP+cb96AqJCAP13Vl9eBZOsJfddx7vkwkAA/dfnfAKYtOJnLuA0+iEg gN6reVdPHsXklfQ7mwT6j0PHe7Uuu0k9wSYSGAAC6L26t16onmBVyf/O44WBfiOA 3tvkoaPUE+wigZ4jgN6r9+wRPIo6q+6+gnMG+otDx3/vdlUvsG3xXx9WT0C2CKD/ PttdvcC6aae+p56A7BBA79Uc1I1HUe3L479XT0A2OHT89/4+PIpyqVd/z7MhHuLQ 8d9XndQL8JMVV9yjnoCMEUDv1Xz2OPUErDGpB+fK8g0B9F7tf16mnoCfpV75PZdT 9wsB9F5h7zPVE/Cr5Zf0VU9AJgig9+rextlgHDLhsAnqCUgfAfTfbXwL7JKyOy5X T0DaCKD/7j2fR9Ep0w8eq56ANHHo+O+Wv3JKfLeU3c8JejxBAP134dWt1BOwgZmH 8IoYLxBA/+247cvqCdhQ6lGem/cBAQxBSj0AG/ux2zj1BFSLAIaAALqo7Pp/qieg OgQwBATQTV/vt0A9AVUjgCEggI5accJr6gmoEgEMAQF01hOnqRegKgQwBATQXVP3 mKmegMoRwBAQQIcVn/ySegIqRQBDQACd9vBZ6gWoDAEMwdQ26gWoyrd7LFZPQMUI YAgKVqoXoErLun6hnoAKEcAg8D2w48ou7qOegIoQwCCU8Ti6rt8J6gWoAAdOEIo5 IZbzvt19qXoCNkIAg7CkUL0A1Vq4x3j1BGyIAAZhYSP1AlSv5PhX1BOwAQIYhJUF 6gVIQ+qaW9QTsD4CGIKdvlEvQHoeO129AOshgCF48Gz1AqTpw65l6gkohwCGYFI7 9QKka2LHIvUErEMAA5C/kiuj+2POjnPUE7AWAQzAKU+qFyADS3fl5TDOIIABGHSQ egEyUdz1E/UE/IIABoBXAXqm9Ig31RPwMwLov7ZT1AuQobJTnlFPwBoE0H+9L1Yv QKZSF9yvnoDVCKD/Jm6lXoDMXXmregHyCGAACpbzIhgf/Y3LpjuAAHrv3AfUC5CV G69TLwAB9N+wPdULkJ1br1QvAAH03vI66gXIEgWUI4C+2+cD9QJk7R9/Vy+wjgD6 rv9R6gXI3vU3qBcYRwB9t6ihegFycMVt6gW2EUDPdRypXoCcnPugeoFpBNBzz5yk XoCcpE5+Tj3BMgLouXlN1QuQm7LunBlBhwD6bZvv1AuQq5K9hqsn2EUA/fbon9UL kLOVHb5XTzCLAPqN74BDsGTLeeoJVhFAr3E9zDDM3mKFeoJRBNBrLx6rXoBITNiO q2VKEECvLSlUL0A03ttPvcAmAuizru+qFyAqj5ypXmASAfQZl4MLCG+KUyCAHqux vEA9AZFJHfuKeoJBBNBjnAs6KCUdx6on2EMAPTauvXoBorS4zWL1BHMIoL9azuTR C8uEbdULzOEQ8td/T1MvQMQGHqFeYA0B9NfiBuoFiBrXykwYAfRW9wHqBYhc6pDB 6gm2EEBvjdhZvQDRW9lupnqCKQTQV61m8NiFaEYb3hWcIA4iX/U7Tr0AsXibt/ck iAB6ineBBOvKW9ULDCGAnrr6JvUCxKSsC6fITwwB9NSsluoFiMvSTZeqJ5hBAP10 8FvqBYjPNx3VC8wggH4au716AWJ0x6XqBVYQQC91/lK9AHFKdXtPPcEIAuilz3dV L0CslrXix4CJIIA+2moCj1vgvuQ/cYngQPLR0G7qBYjbP/6uXmACAfRQi1k8bMEr 6/y1eoIFHEkeev0w9QLEb15L3hQcPwLon7aTedQs6N9DvcAADiX/DNtTvQCJOOk5 9YLwEUDvdBypXoBkrNxkkXpC8Aigd77ZSb0ACeG1MLEjgL7pNlS9AIm5pLd6QegI oG8mb6FegMSUbDFDPSFwBNAzZz2kXoAEcaXgmBFAv9RYVKiegCTdeJ16QdgIoF8e PFu9AIkq23qyekLQCKBXNp9SQz0ByZq4jXpB0AigV7gWsD03XK9eEDIC6JOT/6de gMSVbjVVPSFgBNAjdebWV09A8sZx+YP4EECPvHqkegEUeDl0fAigP7q+q14AiVWb LFBPCBYB9Eb+7CbqCdD4tIt6QbAIoDf6HadeAJU/8OxXTAigLw54W70AMsuaFqsn BIoAeqLeLN4DZ9gLx6sXBIoAeuLDvdULIJTaZYR6QpgIoB8uvEe9AFLT26gXhIkA eqH9mJrqCdC6/gb1giARQB/k/9hcPQFivBgwFgTQB4MOUi+A3Hv7qReEiAB64Kqb 1QvggP3fUS8IEAF03z7v8yghL29WK/WCAHFoOa/ZtLrqCXACp8ePHgF0Xf6U1uoJ cENJcy6UHjUC6Lphe6oXwBVDDlQvCA4BdNzDZ6gXwB27faFeEBoC6Larb1IvgEMm b6leEBoC6LRTnuABQjk971cvCAzHl8u6vc1VMFFeUaMS9YSwEECHdRqer54AxzzK z4QjRQDdtc2o2uoJcE3ppnPUE4JCAJ3VejwXwcRG3u+qXhAUAuiq1t82UE+Ai3gp TJQIoKPoHyo2cRv1gpAQQDe1HUX/ULHfP6NeEBAC6KT2IzgBAioxv5l6QUAIoIs6 fcLzv6jUNZwfMjIE0EHd3qqlngCHLW/Iq6GjQgDdc/yzvP8DVXnoHPWCYBBA5/Ts w4OCKnFiwMhwrLnm9r+qF8B5/XuoF4SCADqm/1HqBXBf2aaz1RMCQQCdUvDZzuoJ 8MHbXCg1GgTQJa1GtlRPgBdSW01WTwgDAXTIXkPqqCfAEx/vpV4QBgLojvP78PIX pGun0eoFQSCAznjyFPUCeGRkJ/WCIBBAR9T7bEf1BHily6fqBSEggG7Y6cNG6gnw y/jt1AtCQACd0PMefvyHDB0ySL0gAATQATVe5tXPyNjULdQLAkAA9Vp/url6Anx0 1GvqBf4jgHI9nitQT4CX+BIwdwRQ7f7z1Avgq8PeVC/wHgHUavbh9uoJ8NakrdQL vEcApXo8y7nvkb0Dh6gX+I4AKj31B/UCeO279uoFviOAOm0/4tlf5GbfD9ULPEcA Zc66P189Ab77dgf1As8RQJGCAZzSErnjHcG5IYAa+wzgvb+IwOid1Av8RgAlHj6d Ox6R2OUr9QKvcRwKbPPuZuoJCAXnBcwJAUzetTdw6hdEZrvx6gU+I4BJa/JuR/UE hOS9/dQLfEYAE3b6A5z6AFFKbTJHPcFjBDBRhW/urZ6A0LxwvHqBxwhgko5/vK56 AoJT0mCFeoK/CGBy6rzKa58RgwfOVy/wFwFMzOHPFaonIEjLC8vUE7xFABOS36+H egJC9bd/qhd4iwAm4+B+DdUTEKyFTdQLvEUAk1DwUnf1BITsjEfVC3xFABNw5P/4 6R/i9ANnlswSAYwdT/4idgcPVi/wFAGM23GP11NPQPC+3lm9wFMEMF6FA3+nngAD Uu2mqif4iQDG6vT76qgnwIQBR6oX+IkAxqjZW7uqJ8AI3g+XHQIYn1631lJPgBl3 XKpe4CUCGJfNB3HBLiRnMReZyQYBjMkN19RUT4Apf3pcvcBHBDAW7d9qp54AYyZv qV7gIwIYh3t6ctUPJK3zCPUCDxHA6HV6o5V6AgwaxtnGM0cAo1bjsVO5UyFQ1nyB eoJ/OFYj1vWlpuoJMOqJ09QL/EMAI1Xw7DHqCTBrOe86zxgBjFL3ZxqoJ8Cw8/qq F3iHAEanXv8D1RNgGq+EyRgBjMzJj3DNS2h1GKte4BsCGJFGb+ypngDzBh2iXuAb AhiNc+6urZ4AlNQvVk/wDAGMAue9ghtuula9wDMEMAIX3sF5r+CEuS3UCzxDAHPW cnBH9QTgFwcOUS/wCwHM1aW35KsnAL/6fHf1Ar8QwNy0HtxBPQFYJ9WMNwRnggDm 5PKb+PIPTnn0DPUCrxDAHLQcspN6ArC+ZYXqBV4hgNnjyV846IR+6gU+IYDZavL2 LuoJwMa+3lm9wCcEMEtn3legngBUgKdBMkEAs9LwrS7qCUDFHjxXvcAjBDAbRz/D iV/gqkWN1Qs8QgAzV+PFHuoJQOUOe1O9wB8EMGOdBzdTTwCqMPy36gX+IICZuvNi 7jM4razRUvUEb3AwZ6b1+1urJwDV6H2JeoE3CGBGzu3DW9/gvHnN1Qu8QQAzkP8G Vz2CD/b9UL3AFwQwfZ2GNlFPANLx4b7qBb4ggGn7+99qqCcAaSmpW6Ke4AkCmKbC d3ZTTwDSddnt6gWeIIDpOaB/ffUEIG0Tt1Ev8AQBTEvvv3BHwSebzFYv8APHdRoK P+QMQ/DLw2epF/iBAFZvj7c5yS48s6CpeoEfCGC1rrqJOwne2fMT9QIvcGxXo8Yb B6snAJkbwov200EAq9Z6eGv1BCALq+qUqSf4gABW6aDXaqsnAFk590H1Ah8QwKrw 4z94a8yO6gU+4ACvQv+j1AuAbKWaLFJP8AABrFThl9uqJwDZu6uXeoEHCGBlthnO tWXgs5mbqhd4gABW4tBXa6knADnZ+nv1AvcRwIpdeDf3DDz31KnqBe7jMK9QnwvU C4BcLeQEvtUigBV58xD1AiB3u32hXuA8Arixgi92Uk8AIjDwCPUC5xHAjTQavZl6 AhCF5fXUC5xHADe0+Te8/AWBOOo19QLXEcAN7Di8rnoCEJGP9lEvcB0BXN+uwwrU E4CocEqY6hDA9XR9O189AYjO2f9RL3AcASyve/+a6glAhL7majZVI4DlnPwUlz5H UMrqr1BPcBsBXOesB7k3EJgrblMvcBuH/FoX3cWdgdCM7aBe4DaO+V+d+4B6ARA5 vgeuGgH8xTkPcFcgQHwPXCWO+p/9+RHuCYSI74GrxGG/xqmPc0cgSHwPXCWO+9VO fpr7AYG6pLd6gcs48H9y3PPcDQjVaE7uVgWO/Ly8bm/z+mcEq6xusXqCwwhgXsfP ufwRAsb3wFUggG3H1VFPAGLE98BVMB/AZt83VE8A4sT3wFWwHsB6k1uoJwDx4nvg yhkPYP537dQTgJhxTqzKGQ/gp79VLwDiVlrAeaErYzuAz56oXgDE70+Pqxc4y3QA b/ibegGQgGF7qxc4y3IAT3nC8p8edqzklV6VMZyALh/xBhDYcNib6gWushvAtuNr qycAyXjjcPUCV5kNYJ0fmqonAAlZ2kC9wFVmAziC10bBjs4j1AscZTWAT5yqXgAk 57mT1AscZTSAPe9VLwASNK+5eoGjbAaQJ4BhzBZT1QvcZDKALabUVU8AEtX3PPUC N1kMYI2pm6knAMma3ka9wE0WAzigu3oBkLBUw6XqCU4yGMBed6oXAIm77Hb1AifZ C2Dnz3kCBPZ8uat6gZPMBbBwBi+Kh0GrCtQLnGQugLwDBDZxQoSKWAtgnwvUCwCJ 145SL3CRsQAe/KaxPzDwi4VN1AtcZKsHDWfyCmhYxZtBKmArgPwAEHbdfbF6gYNM BfCWK9ULAJlJW6kXOMhSAPf42NKfFlhfqk6xeoJ7DCWhzqyG6gmA0Hl91QvcYyiA H+yjXgAofbyXeoF77ATw/PvUCwCp5fXUC9xjJoCtp+SrJwBavxmlXuAcMwGcyFNg sO6hc9QLnGMlgPdcqF4AqE1pp17gHCMB5BUwQF5Z7RL1BNfY6EL+nMbqCYDe6Y+p F7jGRgBf7qFeADhg6AHqBa4xEcDDB6oXAC5YwnsBNmAhgHXmFKonAE7gjDAbsBDA QQepFwBuuONS9QLHGAjg8c+rFwCOGL+deoFjwg9g4WxOggr8rLSgTD3BLeEH8N2u 6gWAM455Rb3ALcEH8NgX1QsAd/TnFWHrCT2AdebWV08A3DF7E/UCt4QewIGHqxcA DkkVFqknOCXwAB78lnoB4JSe96sXOCXsAObPbaSeADjl3W7qBU4JO4DPnqheALhl MV8TlBd0AHcdHvQfD8jCJrPVC1wSdCF+bKVeALjm+hvUC1wScgBv/6t6AeCcL3dV L3BJwAFsN7GGegLgnBW8NbScgAP4Le/7Bja202j1AoeEG8CLe6sXAC66lwuErRNs ABvOKVBPAFzEKbHKCTaAQ3m9J1CRklrqBQ4JNYAHDVIvABy19zD1AncEGsAac5qq JwCOeugc9QJ3BBrAB85VLwBcxQ8B1wkzgFt9x0sAgUqs4vnBtcIM4Jgd1AsAd3X5 VL3AGUEG8Mz/qBcADut7nnqBM0IMYJ35vNkHqNy47dULnBFiAF88Vr0AcBk/BFwr wAB2+jLAPxQQod2+UC9wRYCtmNJWvQBw230XqBe4IrwAXvEv9QLAcWM7qBe4IrgA chIEoDrFtdULXBFcAD/nfLdAdTqPUC9wRGgBvPxW9QLAfb0vUS9wRGgBLOU9cEC1 RnRWL3BEYAEcvpt6AeCBZYXqBY4IK4Ctf1AvALzQco56gRvCCuDHXdQLAC9ceod6 gRuCCmD3AeoFgB+GHqBe4IagAjiP00ADaZnbQr3ADSEF8MZr1AsAT6QKStQTnBBQ AAvn8R4QIE3Hv6Be4ISAAvjK0eoFgDeePVm9wAnhBLD1NF4DDaRr0lbqBU4IJ4Dv 76teAPiDy6OvEUwAdxgdzB8FSADnQ1gtmGrwJjggE3dcql7gglAC2P7bUP4kQCKG /1a9wAWhZOPDvdULAK8sbqRe4IJAArj51ED+IEBS6hepFzggkG7wGkAgQ3/4n3qB A8IIYH4Rz+kDmeGl0HmhBPDv16sXAL6ZuI16gQPCCOBsTm0BZIhLw+UFEsAdR6kX AP7ZYqp6gV4QAex3nHoB4J+rb1Ev0AsigEu4wguQMc4KHUYAuw1VLwA8NHsT9QK9 EALId8BAFspqlaknyIUQwJn8hwzIwv7vqBfIBRDAwsUB/CGA5N19sXqBXADtuOhu 9QLAS5/toV4gF0AABx+oXgB4aQHXkQ0ggNM3Uy8AvJTKN/8sSAABLOZECEBWDhyi XqDmfwDbTlEvADzFsyD+B/DCe9QLAE/xLIj/AXzgXPUCwFM8C+J/AAd0Vy8APMWz IP4H8Itd1AsAX5l/FsT/AE5pq14A+Mr8syD+B3B+E/UCwFfmnwXxP4ALGqsXAL4y /ywIAQTsMv8sCAEEDOvyqXqBFgEEDLvxOvUCLQIIGDbE+LmU/A/gj63UCwBvTW+j XqDlfwAnbK1eAHjL+tXR/Q/gJ9ZfyQTkoOUc9QIp/wP4zEnqBYC/znpYvUDK/wBe 9w/1AsBfT52qXiDlfwC7fKxeAPhr1G/UC6T8D2CNEv//DIDK4kbqBVIBxGOh7UcQ yIXxN8MFEECeBgayt9976gVKAQTw5qvUCwB/3XqleoFSAAFsN0m9APCX7TfDBRDA vCWF6gWAt6a0Uy9QCiGA7+ynXgB4a0Vd9QKlEAJ4XD/1AsBfdVeoFwiFEMC84lrq BYC3DhmkXiAURADf31e9APCW6aeBgwhg13fVCwBvDT1AvUAoiAByaUwga1O3UC8Q CiOAt/9VvQDwlemngcMIYJ2lNdUTAF9Zfho4jADmDTxcvQDwVffX1Qt0AglgqxmB /EGAxP37cvUCnVC68W5X9QLAU5afBg4lgG0nh/InARI2eUv1Ap1gsvH6YeoFgSv9 7vkOx6lHIA7LDJ9NJJgANpvFE8HxmTvs0dfK8r7srN6BOKRqqBfoBBPAvL7nqBcE atmo/n0XrPmreU3FUxCPnUarF8iEE8Aaiwx/IR+XFeNe7zt17d+VGv5KIWgX9VEv kAkngHmnPKleEJZlYwf/d3z5f9B+nGoK4vXEaeoFMgEFMO/zXdULQpFaMOr1x2Zv +E8v7q3Ygvh9Zve6YiEFsMWMfPWEAKya9tlL/Ysr+jfPH5/0FiRj5qbqBTIhBTDv 8lvVC/xWNnf00GcnVPqvR3dIcAsStLKOeoFMUAHkEM1aavH4D18YVvWvWVo/mS1I nN3TIYQVwFZTOTl+5pZO+WzAgAq/6V1PvWUJbIHE/u+oF6iEFcC8sx5SL/BKatH3 w994o/r2rfH7p+MdA53rb1AvUAksgHlDu6kXeKJ03viPB35QlsHveOLU2MZA7JVj 1AtUQgtgwUzOjl+d5TNGffjq+Op/3QbG7BDDFjjh653VC1RCC2Bex694u0KlSuZN /GLI4KLsfvOyetGOgTvmtFQvUAkugHmX/lu9wEWpRVO/+eC1GTncQrO5kY2Ba4pr qxeohBdATo+/gaIZY4a98XXON9Przgi2wFH5peoFIgEGsMaUzdUTHLFi5vjh73yQ 5pO81Xlnv2huBy767XD1ApEAA5jXcrLl6/ytsWrexM/fyfaHfRXjXFgh63WXeoFI iAHM22OY4SdClk79+t2cfthXMV4GHbTHTlcvEAkygFZfD1005pNBb0X0He+GTn8k ntuFEz7aR71AJMwA5vW+OOIbLC0pLk7l5RXk13b1zPuzbnqgJMabH9A9xhuH2pR2 6gUigQYwwmskLZoy5uPPRi5f+/e1Oh6wR+c2jp14a+Wzf1kU70eY2yze24eU2esi hRrAvFE7RnAj8z5+/sWKn0k4tFdXd146Ne+umzN5T1s2Wmx0elSEpMzVb2ziFmwA Cya0yfEWpr9w85wq/nWNXtc1yvEjRGPyZS/E/0Gu/3v8HwNCbaarF2gEG8C8hpNy ed3Gslcvr/4z4p4L9Hff6J7vJfFhRnZM4qNA5qTn1As09EdwbFpNyPoEntP/8Z+0 ft3hr2q/c0h9emZCFzQs5kSLYbvlavUCjYADmLfd1wVZ/b5xZ36Y7i897b9ZfYSI fHJa5ud0yU63oQl9IIj0O0G9QCPkAObt9V4WT9ZO+mPa+fvJ9M0y/wgR+fyPYxP7 WC+ZPV+cFVYvDBd0APO6Dsn0W9QFPZ/J6Nfff16GHyAqY05I6JvfNRY0TvCDQWDq FuoFGmEHMO/g1zMqYOk9l2T4AUTfG845q3+SH45LogdvsRsvaUhc4AHMO/KVDN4W /PnhVb3upUL5qzL9HRFY8Y9bkv2Aj1h9p6gdpY69tD8poQcw7+iX0/0jLj/nySxu f1XynzivnZD0RQznNE/4AyJxdVaqF0gEH8C8459N72vATw9enM3NJ36x3Jk9Pk34 I/IdsAVdEv+0ckL4Aczr3j+NnwOWXJblCdGWJPsmytI7L0/0463x1B+S/5hIWM/7 1QskDAQwr9ugar9NnfS7bN8JlGwAZ3SdkOSH+8WihoIPimTde6F6gYSFAObt8UHV 72NI3X9B1red5LfAqSf+lNwHW4dXQVvwus3znZkIYF6nT6o6dcvK/zcw+5tO8D1i y44ZnNjHKo+rgVjwjc13e9sIYN52X1T+hdrk32b84pdyShM7+/7ovbJ6liZn+cuN vkLClpmbqhdIGAlgXqvRlZ0b5tmTc7nd2om9IuWRM5P6SBu4+ibRB0aSjJ4S1UoA 8xp+07aif1x61mM53ewen+T029OW+kufZD7QxqZxlVELjL4S2kwA8wqGV/BDjiX7 5HjF8J735vb701Ry5JuJfJwK7PSN6iMjUTavjW4ngHl5Q/bf8J+M3z3XH6v1PSfH G0jLij1HJPFhKvT2AbIPjSRtb/Ll7pYCmPfon9f/+wjOgTZsz5xvonrLOn6fwEep WJ2lVq8WYc3xCVxZwT2mAph36W3l/rypv/bO/RZnbpL7bVRnSQfh9Rpuu0z3sZGk a25WL1CwFcC87q+s/VFv8RFRvKougZcBFu0wNfaPUTneBWKF7GUGUsYCmLfDZ788 2z9vlyiy0vqHCG6kait+o3j3269Of0T4wZGkQYeoFyhYC2Beo2/WXC7zm99G8gK+ XndGcStVKd51VNwfoiq8BsaMkZ3UCxTMBTCvxuD980pfOCmaG3vtiGhup1Ilew2P +SNU6aBByo+OJE3P9ULaXrIXwLy8my//3bCIbmpKha+ujk5Zd9nr/9YY11764ZEg myfFtxjAvHaTo7qlkphfI3LWw/HefjWSep8LHLAqu4vIes5kACMTdyD+8fd4b786 I22eIcSmVGKn9XAJAcxFzBfFfOK0WG++WnwBaEqDpeoFAgQwF6N2jPPW3+8a562n YXQH8QAkaZev1AsECGAuVsb5Y5NJ25TFeOtp6PKx9uMjWSf0Uy8QIIA56BTnfzIX tdWc/3SdCVuLByBRl92uXiBAAHMQ548Ai3fQnQDhZz1eFg9AsvpcpF4gQABzMH7b 2G667FDN9T/KSeI8D3BIBCdH8g8BzEGMrwI8r29sN52mC+9RL0Cy3ttPvUCAAGbv 6Fdiu+m7esV202nKX1RPPQHJMnldOAKYvf5HxXXLbxwe1y2nbcOTxyJ4U7dQLxAg gNmb2yymGx4T68sL09LqB5PvCzBtQWUXTgwZAcxai9kx3fCctolda7NSw3dTL0DS llv8oQcBzNotV8Zzu8u2iqus6TvyVfUCJM7khTEJYNa+3S6Wm13VeXQst5uR+U3U C5A4k2dDIIDZyl8Zy+dL2cFD4rjZzPS5QL0AAgWr1AuSRwCzddp/47jV1B+eieNm M7PVdxa/FsDm8V/hxjkEMFvv7xvHrV7UJ45bzRDngbZpT4OnPyOA2VoWx3NmV94a w41mKv4rPcFJFi+NTgCztOvnMdzoDdfHcKOZavZj/Nc6hosuuE+9IHkEMEv/Ozn6 23Sif3lfdlYvgIb6CgwKBDBLs1tEfpNX3xL5TWah573qBRB54Hz1guQRwOy0jvwJ s9SFTnwDwjfAdj0X0dWyfUIAs3PPhRHfYNlJbpyQnOuA2DXoEPWC5BHA7ER9RfQV B0R1rfbcXG/wx0D4xSd7qhckjwBmpdGCaO+4mTvr3/+72nZjeAm0XRZPCEgAsxLx F0pDDymJ9PayVeOHVuoJ0Bkfz7vbnUYAsxLpeyVKe7nw9o/V+h2nXgAhi2dEJYDZ KFgR4f02+aAJ0d1YTk7+n3oBlGZuql6QPAKYjYvujuymSm+5LrLbylHLaXFe5x3O m9dcvSB5BDAbCxpHdUsfHevGsx+rTWqnXgCpxY3UC5JHALOw14cR3W2Tfu/Q+Tfi eHMffFJUX70geQQwCxF9ATjp/DcjuZ1o/P5p9QKIFddWL0geAczcyz0iuJHUFxc6 9NVfXl7bCbwFzroSg58CBDBjbSfnfqfNf/5vcyKYEp38H1qqJ0CtrKZ6QfIIYMb+ fWaO3wHPH3TL19FMic6He6sXQM7iVZEIYBYa/blHx8bZ3XNLvnvtfnee913rtsvU C+AAgzUw+EeORv6BR3TZqmEG3zOULZ05/PVXiuJblIMeL/F5gJ8+qUvVCxLHJ35O Wuy/5zabN9+sil+RWrl84ewfJw1/b0ZiozLWfpTBn35jY40WqxckjgBGoKofnZQl tiJrhdMie103vNZkoXpB4gggvjV4EhBUxOCFgQmgea8crV4AR7Sdpl6QOAJo3Q1/ Uy+AK3b4Vr0gcQTQuBOf4VMAvyCAMKbzcIOv/kclfjtcvSBxBNC0FpPrqSfAHXu7 cWWuJBFAy+pM4R3AWOcwl05PlAwCaBkvgEF53V9XL0gcATRsaDf1AjiFAMKQR05X L4BbCCDsiPjaxvAfAYQZZz2kXgDX7PeeekHiCKBR3V/joccGeBkMjNj1U14AjQ3x QmjYsM0ogxcAQ3U6jVQvSBwBtKjlxEL1BDiI9wLDgoaTmqonwEUEEAYUfF/VOfxh 17YT1AsSRwDNqTG2vXoC3MQZoRG+LzurF8BRmzh4xdaYEUBr3t9XvQCuqrNSvSBx BNCYgYerF8BZBmtg8I9s2jMnqRfAWamqru8aKAJoyn/OVC+Au8oMvjuIAFrS+2L1 AjispJZ6QfIIoCE3XqNeAJcVG3x/JAG046qb1QvgtOUGr5BFAM246G71ArhtSUP1 guQRQCt63qteAMfNb6ZekDwCaMQ5D/BQo2qzWqkXJI+jwobTHuORRjWmtFMvSB6H hQmnPs4DjeqM2VG9IHkcFxYc/xyPM6r1yZ7qBcnjwDCgx0s8zKjeW4eqFySPIyN8 R79k8D2eyNwzv1cvSB4BDN7Bb9A/pKPPReoFySOAoTv4dYNvcUc2/vZP9YLkEcDA 0T+k6+z/qBckjwCGjf4hbUcMVC9IHgEMGv1D+jqPUC9IHgEMWdch9A9pa7JQvSB5 BDBgXd/OV0+APyyeEZ8ABoz+IROrCtQLBAhgsOgfMrK4kXqBAAEMFf1DZmZspl4g QAADRf+QIYsngyGAgaJ/yNT7XdULBAhgkHj9HzL23EnqBQIEMET0D5m741L1AgEC GCD6hyxccJ96gQABDA/9QzYOGaReIEAAg3P4q/QPWWg+T71AgACGhvM/IytlJv+7 SQADQ/+QnaL66gUKBDAs9A9Z+rG1eoECAQzKcc/RP2RnZCf1AgUCGBKu/4usvXaU eoECB0xA6B+yd1cv9QIFjphw/P4pHk1k7ayH1QsUOGSCcerjPJjInsUrghDAcNA/ 5CS/VL1AgYMmEKc/zEOJHKyso14gwVEThnMe4JFELmy+DJAAhoH+IUef7aFeIMFx EwL6h1w9cZp6gQQHTgDoH3L2l3vUCyQ4cvxH/5C7nb9WL5Dg0PEe/UPuUvll6gkS HDu+o3+IwPJ66gUaHDyeo3+IwrS26gUaHD1+o3+IxDv7qxdocPh4jf4hGv++XL1A g+PHZ/QPETl4sHqBBgeQx856kIcP0ahdrF6gwRHkL87/gqgsK1QvEOEQ8hb9Q2S+ a69eIMIx5KuTn+axQ1RePVq9QISDyFNc/wMRuvJW9QIRjiI/0T9Eyeg7gQmgp7j+ OaJUVlO9QIUA+oj+IVKzWqkXqBBADx35Cv1DlN7tpl6gQgD9c8BbZr9hQTxuuF69 QIUAeqfLB/nqCQjMTqPVC1QIoG86fVZLPQGBKbH7KUUAPbPjlwXqCQjNjM3UC2QI oF+2+cbm9asRp0GHqBfIEECvtB1r9MzliJPZ94EQQL+0/raBegIC1Ga6eoEMAfRI i/GN1RMQIKsXRFqNAPqj0cRm6gkI0chO6gU6BNAb9b7fRD0BQep9iXqBDgH0RcF3 Ri9ciLj9ZpR6gQ4B9ESN0durJyBMqyy/spQAeuLzXdULECizp8NfjQD64Z391AsQ qkfPUC8QIoBe6HecegGCdeAQ9QIhAuiDB85VL0CwDJ8JIY8AeuH6v6sXIFzjt1Mv UCKA7jv/PvUCBKzPReoFSgTQeVwADnHafpx6gRLHluv2eY8LgCA+lt8InEcAnbfD SNM/o0bcPttDvUCKALqt1UTb/4FG3K6+Rb1AigA6rXBKU/UEhK35PPUCKQLosvyJ nAABsZrXXL1AiwC67LPd1QsQuH4nqBdoEUCHvXisegFCt+cn6gVaBNBdt12mXoDQ rairXiBGAJ117gPqBQjesL3VC8QIoKsOfpPHBnE7+z/qBWIcZI5qP4oXQCNuZbVL 1BPECKCbGk1tqJ6A8Jk+GfQaBNBJ+d+3UU+AATddq16gRgCd9HEX9QIYkGqySD1B jQC66GHLV2lAYiZtpV4gRwAd1PNe9QKYwHfABNBBnAEQieA7YALooFaT6qgnwAS+ AyaA7imYuol6AmzgO2AC6J5he6oXwAa+A84jgM7pfbF6AYyYuI16gQMIoFuOf169 AFZceod6gQMIoFPaj85XT4ARJXWtvw94NQLokoKZTdQTYIX5M2GtQQBdwjvgkJju r6sXuIAAOuTmq9QLYMayQvUCJxBAdxz0Fo8GkvL8ieoFTuCQc0az6bwDBInZdoJ6 gRMIoDO+42VZSMzULdQL3EAAXdH3HPUCGHJJb/UCNxBARxw+gIcCiSmuW6ae4AaO Ojc0+cH6BVqRpAFHqhc4ggC6YXQH9QJYst149QJHEEAn3HKlegEsmdJOvcAVBNAF Hb/iHNBIUK+71AtcQQAdUGN2M/UEWLKyHk+B/IIAOuClY9QLYMrTp6gXOIMA6vV4 Wb0ApqRazFNPcAYBlKs3u756Akz5lJMOrUUA5Ybsr14AW7p8ql7gDgKodlw/9QLY Mr2NeoFDCKBYvbm8BQSJuuA+9QKHEECxod3UC2BLET9yLocAah0+UL0AxtzVS73A JQRQqsb8RuoJsGVVYbF6gksIoNQTp6oXwJin+JQrjwAq7fQ19z8SVdZ0kXqCUzgA lSa1Uy+AMW8crl7gFgIodNHd6gUwJtV2unqCWwigTp0FXAYOyfp4L/UCxxBAnZd7 qBfAmNT2nAl6fQRQhmdAkLRP9lQvcA3HoMzY7dULYAxfAG6EAKoc+6J6AazhC8CN EECVOc3VC2AMXwBujACKXPtP9QJYwxeAGyOAGvlLeAkMkpVqP0E9wT0EUKPvOeoF sGbIgeoFDiKAEvUW1lJPgDFlreaoJziIAEo8c5J6Aax5js+5ChBAhWazaqonwJhV jYvUE1xEABVePVK9ANb0uUi9wEkEUKDJ3BrqCTCmqFGJeoKTCKBAv+PUC2DNpXeo F7iJACav0Tx+AohkzdxUvcBRBDB5T/1BvQDWHDxYvcBRBDBxBUt5DSCS9cVu6gWu IoCJu5PrsiJZZVtOVU9wFQFM3NL66gUwhtdAV4oAJu3i3uoFMGZFkxXqCc4igEmb uYl6AYzpdZd6gbsIYMK6DVUvgDFTt1AvcBgBTNjnu6oXwJbULiPUExxGAJPVYhb3 OBI18Aj1ApdxOCbryVPUC2DLyuZL1RNcRgCTVVRXvQC2XHa7eoHTCGCiTn1CvQC2 TN5SvcBtBDBRY3ZQL4ApqR3GqSe4jQAmqeVM7m8k6ZEz1QscxwGZpEf/rF4AUxY0 L1NPcBwBTNKCxuoFMIWzYFWHACZoj0/UC2DK2wepFziPACbo9cPUC2DJ8uZcCK46 BDBBy+uoF8CSP/xPvcB9BDA5x/VTL4AlH++lXuABApicD/ZRL4AhKzdZpJ7gAQKY nJUF6gUw5KyH1Qt8QAATc/zz6gUwhOsgpYUAJobvgJGc4lYL1BO8QAATw3PASM6f Hlcv8AMBTMpeH6kXwI4Pfqde4AkCmJR+x6kXwIyiFrwEOj0EMCnzmqoXwIyjXlMv 8AUBTEirH9ULYMarR6sXeIMAJuTGa9QLYMX8TUrUE7xBABPyzU7qBTAitetX6gn+ IIAJKa6lXgAj/nWVeoFHCGAyDnhbvQBGjO2gXuATApgMrgeMZBS3nqee4BMCmIxJ 7dQLYAMnAcwIAUxGSU31Apjw0v9TL/ALAUwEPwJEIma04TJwGSGAieB6mEhCydZT 1RM8QwATMa69egEsOP0x9QLfEMBErKitXgADXjlGvcA7BDAJ7SapF8CAmZvxA8BM EcAkXPcP9QKEr2TbyeoJ/iGASRiyv3oBwnfGo+oFHiKASfixlXoBgjfgSPUCHxHA JPAyaMRtVmt+AJgFApiAjiPVCxC6ku2+V0/wEgFMwN+vVy9A6HgFYHYIYAJeP0y9 AIF78o/qBZ4igAngVDCI1/jt1At8RQATwCXREatlmy1ST/AVAYxfvWXqBQha2V6f qid4iwDG7/CB6gUI2hW3qRf4iwDG719XqBcgZG8crl7gMQIYv7cOVi9AwDgHai4I YPwmbK1egHAVbzFTPcFnBDB+ixqqFyBYqSP5CXMuCGD8eCcwYnP7ZeoFfiOAsWu0 UL0AwfpwX/UCzxHA2B38lnoBQjWzTYl6gucIYOyuvkm9AIFa2Y4nQHJEAGP31B/U CxCm1EFD1BO8RwBj93EX9QKE6epb1Av8RwBjN6WtegGC9OrR6gUBIICxW9xAvQAh mriNekEICGDsVuWrFyBAnAIrEgQwdin1AASobLev1BOCQADjtvk09QIE6Oz/qBeE gQDGjddBI3qPnKleEAgCGLcL71EvQHC+2E29IBQEMG539lIvQGjmbF6snhAKAhi3 fsepFyAwxVtPV08IBgGM24d7qxcgLKlDBqsnhIMAxm10B/UChOVv/1QvCAgBjBvv hEOk3tlfvSAkBDBuc5qrFyAkc1qqFwSFAMZtSaF6AQJS0mSpekJQCGDcVhaoFyAg 249TLwgLAYxbaQ31AoSDd8BFjADGjXMhIDLHv6BeEBoCGLMm89ULEIy+56kXBIcA xqzjSPUChGIsLymNHAGMWbeh6gUIxPJNOQVq5AhgzI59Ub0AYeAdcHEggDE7/RH1 AoTh7ovVC0JEAGP219vVCxCE79qrFwSJAMbshr+pFyAExW1mqycEiQDGrDffuCAC pz6lXhAmAhizh89QL0AABh2iXhAoAhizZ09UL4D/ljTnHPjxIIAxe7mHegH8d+AQ 9YJQEcCYDTxcvQDee55vI+JCAGM2+ED1AvhuSdMS9YRgEcCYvb+vegF8d9Rr6gXh IoAxG7GzegE8995+6gUBI4Ax+3Y79QL4raTlAvWEgBHAmE1qp14Av93VS70gZAQw ZjM2VS+A1xY1LVNPCBkBjNksrmKIXPS8X70gaAQwZvOaqhfAZ/ObqReEjQDGbGEj 9QL47C/3qBeEjQDGbHED9QJ4bEVd9YLAEcCYLa2vXgCPPXWqekHgCGDMltdRL4DH Np2pXhA4AhizFbXVC+CvGZupF4SOAMZsZYF6Afx13wXqBaEjgDErrqVeAH9tP069 IHQEMGar8tUL4C2eA44dAYwZAUTWvumoXhA8AhgzAoisPXGaekHwCGDMSmqqF8Bb f3pcvSB4BDBmBBBZazNdvSB4BDBmpTXUC+CrFJ87sSOAMSOAyNbyeuoF4SOAMeO9 wMjW3BbqBeEjgDGb01y9AL6avKV6QfgIYMw4ISqyNbKTekH4CGDMFjRWL4CvPt5L vSB8BDBmBBDZemd/9YLwEcCYcUp8ZGvgEeoF4SOAMVtSqF4AX71yjHpB+AhgzAgg skUA40cAY0YAka2Xj1UvCB8BjBkBRLb4CjB+BDBmBBDZIoDxI4AxI4DIFs8Cx48A xowAIltvHapeED4CGL3N99596yM4ETSiUTJg4vCPODFgTAhghOrt/bvO27Yq5ARY iFrZ0pnfffX+R0XqHcEhgNHodNheHVrXUa9A4FbMGDPsjRHqFSEhgDlrctyRu2zK V31IStmPX772wgL1ikAQwJzkn3rqbg3UI2DQks+ffLJEPSIABDB77S/q3pav/KBS NnXgPePVI3xHALNU76o/b6beAPN+eOwWnhjJBQHMyqmXdORrP7ig7Os7n1Rv8BgB zFz+P89vqN4ArLX4/uv4cWCWCGDGep/Ly13glhV9e6kneIoAZujaq+uqJwAbWX7z jeoJXiKAGTnoiVbqCUCFZv5xsHqChwhgJl49gvsLrkoNOEo9wT8c0Onr+gpXeIPL FvZ4Tz3BNwQwbddeX1M9AahS6fX8JDAzBDBdAw/jvoLrUm90V0/wCwd1ehqNaKee AKRhcqdF6gk+IYBp2eZLTnkAPyzZZYJ6gkcIYDq2+YoT28MXSztTwLQRwDTQP/iE AqaPAFZvmxH11ROADCzrRAHTRACr1WQqX//BL0vbcsbo9BDA6hz6bCP1BCBDi056 Uz3BDwSwOkWc/AD+WV5PvcAPBLAaX3VSLwCyMKKzeoEXCGDVevbhHoKPUhfep57g Aw7vKhUsraWeAGRlVWGxeoIHCGCVxm+rXgBk6bv26gUeIIBV+eu/uX/gq9Rld6gn uI8DvAqN5vANMPy1qgXnRagOAazCmB3UC4AcjO2gXuA8Ali57q9y7V/4rOyogeoJ riOAlVvIW0Dgt0VcxKEaBLBS//4rdw78lrrjMvUEx3GMV6qYZ0Dgu1UF6gWOI4CV +biLegGQs0/2VC9wGwGsRL0lPAMC/5U1KFJPcBoBrMSkduoFQAQmb6le4DQCWLG9 PuALQISgbN9h6gkuI4AV4yUwCAQvhakKAazQxXdyxyAMqUvuUk9wGMd5hZZwGRCE YinXtK4cAazIVTdxvyAUqWtuUU9wFwd6RRbwYxOEY2ET9QJ3EcAKnPIEdwvCkfrj U+oJzuJIr8BoziKEkIzZUb3AWQRwY43m8xpAhKSsKWdGrQQB3Fjfs7lXEJLUQ+eq J7iKQ31jpXwBiLCU1VQvcBUB3Ej/o9QLgIi9erR6gaMI4Ebm86IBhGZBU/UCRxHA jZTw7QJCU5qvXuAoArgRfgSI4PBDwEoQwA2921W9AIjce/upF7iJAG6IE2EhQJwU q2IEcEP8CBAB4oeAFSOAG+JHgAgQPwSsGAHcQL/j1AuAGLxwvHqBkwjgBmZsql4A xODH1uoFTiKAG+By6AgSl0ivEAHcAD8CRJD4IWCFCOD6Gi7kHkGIUo0Xqye4iMN9 fUO7qRcAsXiXT+0KEMD1cSYEBIrzIVSEAK5vFa8XRZhKeHqvAgRwfTwHgkDxLEhF COD6CCACRQArQgDX8/ph6gVATN44XL3AQQRwPXObqRcAMZnPJ/fGCOB6eB8IgsV7 QSpAANfDjwARLH4IWAECuJ4y7g+EKsV/3TfGAV/evedzfyBY912gXuAeDvjyxm6v XgDE5tsd1AvcQwDLW9xAvQCIzZKG6gXuIYDl8UY4BIw3w22MAJbHk8AIGM+CbIwA ltNhFHcHwpXaaYx6gnM44st5+wD1AiBGQw5UL3AOASyHCyIhaDP5BN8QASxnRW31 AiBGK+uoFziHAJZTwnuFEDLeDLcRArhOk3ncGwhZqtkC9QTXcMiv8+dHuDcQstQZ j6knuIZDfp0RO6sXALEa2Um9wDUEcB2uCIfALeRTfAMEcB3OhorAcU7UDRHAdeZx 4VSEjWsDb4gArsNXgAgcXwFuiACuw6kQEDheCLghArgOAUTgCOCGCOBa/7qcOwNh S912pXqCYzjm1xrIdaMRute7qxc4hgCuxQVBEDwuC7IBArgWr4NG8Hgl9AYI4Fpc EATBK+WTfH0EcC2eBEbweBp4AwRwLQKI4BHADRDAX910FfcFQpf619XqCW7hoP/V Sz24LxC8l49VL3ALB/2vvuysXgDEbgSf5ushgL/iknAwgAvDrY8A/qqornoBELvl 9dQL3EIAf8WTwDCAp4HXRwB/RQBhAAFcHwH8xXn3cVcgfKkL7ldPcApH/S8eOIe7 AuFLPXieeoJTOOp/MfgA7goYMORA9QKncNT/YnQH9QIgAWP5RC+PAP5idgv1AiAB c/lEL48A/mIl18uCBcW11QucQgB/watgYAKvg1kPAfwFAYQJBHA9BPBnZ/flnoAF qXMfUk9wCYf9z+66iHsCFqTuvUg9wSUc9j8bcDj3BCxIvcGVMcvhsP/ZuPbqBUAi vuNTvRwC+DOuiQkjuDJmeQTwZ7wMEEas4lO9HAL4M14FAyN4HUx5BPBnBBBGEMDy CODPCCCMIIDlEcA1bryaOwI2pG65Rj3BIRz3aww6kDsCNqSGHKSe4BCO+zUmbK1e ACTkez7Z1yGAayxorF4AJIQXApZDANdYwUnSYAVnBCyHAK5RwjNjsKI0X73AIQRw DV4FAzN4HUw5BHANvgKEGQSwHAK4Bl8BwgwCWA4BXK3XHdwPsCJ16Z3qCe7gwF/t v3/kfoAVqSdPU09wBwf+ah/tyf0AMz7eS73AHRz4q01to14AJGY6n+5rEcDVltZX LwASU8Sn+1oEcDVeBQNDeBp4HQK4Gq+CgSEEcB0C+JPL/8XdADtSV92qnuAMjvyf PPkH7gbYkfrfKeoJzuDIX63PTm1b1OfbYIQvtXTu1FEXqFe4gwCuc85u27VtXo97 BCFKFc2b+u3nD6pnuIbDfSPn7N6+TQs6iECkiuZOGz+8r3qGozjOK3PW7tu1ac73 xfBWWdGc6eOGP6Se4TYCWJ3bOrdp2YBTSMIfpUtmT/vqMvUKPxDANF2125abNq7N 3QV3pVYu+nHS5zerZ3iFIzozp+++TZsWDWqpZwDlrFoyZ/qE4Y+oZ/iIAGbn3N9u tXmzQr4zhlLJsrk/TBz+gHqGzwhgbs7co91mzRvwrTESlCpePO+HSZ8+rN4RAo7c iFy05+abNimsxf2J2KxaOn/mtE/uVs8ICgds1P7SZbNNmhbyNSEiklq5dP6sGR/T vVhwnMbm5D03b928cf0CXkqIzKVWFi2YO2P6x8+ohwSOACbg2C6bt27ZpLAOz5mg aiUrli6Y88MPn7yoHmIGAUzW8Xtv0qp5owZ1a/F1IX6WKl6+dOHcmbM+6qdeYhEB 1Dnmd5u0bNqksF5BTR4FW1KlxcuXLJw/a9b7L6unWMeh54ge+zdv3rRRYb3a+Zyu N0SlJSuLli6eN3fu0FfUU1AOAXTSIQc0ad6kcWH9egW1avAQ+ShVtuqnb22XLlww d8HQN9VjUCmOLi8cemijJo0aNqhXt3Z+PkV0UKqspGTl8qIlixctWPQmwfMHB5On uh1dv1HjBoX16tSpVSufHyImKlVaWrxqxYqipUsXLFrW/x31HOSAIycgux9f96cv E+vWrVundkGtWjVr8LVijlJlZaWrVhWvXLF8+fKfvrhb3m+4ehEixiFiwE5/LCis V79+nTp1ateuVVCrZv5PaeSB/1VqdeZKfupc8crlK1YsW1a0tPiJUepRSAjHgXHt /pRfv169erXr1q7905eNBbXy82v+9KXjT4EM5TMjtTpwZaWlJSWrin/6Ym7lyuUr i4qKlpX8d7J6GRwQyqc5fNCsmn8/L5EVwFoEEIBZBBCAWQQQgFkEEIBZBBCAWQQQ gFkEEIBZBBCAWQQQgFkEEIBZBBCAWQQQgFkEEIBZBBCAWQQQgFkEEIBZBBCAWQQQ gFkEEIBZBBCAWQQQgFkEEIBZBBCAWQQQgFkEEIBZBBCAWQQQgFkEEIBZBBCAWQQQ gFkEEIBZBBCAWQQQgFkEEIBZBBCAWQQQgFkEEIBZBBCAWQQQgFkEEIBZBBCAWQQQ gFkEEIBZBBCAWQQQgFkEEIBZBBCAWQQQgFkEEIBZBBCAWQQQgFkEEIBZBBCAWQQQ gFkEEIBZBBCAWQQQgFkEEIBZBBCAWQQQgFkEEIBZBBCAWQQQgFkEEIBZBBCAWQQQ gFkEEIBZBBCAWQQQgFkEEIBZBBCAWQQQgFkEEIBZBBCAWQQQgFkEEIBZBBCAWQQQ gFkEEIBZBBCAWQQQgFkEEIBZBBCAWQQQgFkEEIBZBBCAWQQQgFkEEIBZBBCAWQQQ gFkEEIBZBBCAWQQQgFkEEIBZBBCAWQQQgFkEEIBZBBCAWQQQgFkEEIBZBBCAWQQQ gFkEEIBZBBCAWQQQgFkEEIBZBBCAWQQQgFkEEIBZBBCAWQQQgFkEEIBZBBCAWQQQ gFkEEIBZBBCAWQQQgFkEEIBZBBCAWQQQgFkEEIBZBBCAWQQQgFkEEIBZBBCAWQQQ gFkEEIBZ/x8scL61A2PdwgAAAABJRU5ErkJggg=="/></symbol><g mask="url(#b)"><g transform="rotate(.193) scale(.36014)"><symbol id="c" viewBox="0 0 1280 1280"><image width="1280" height="1280" xlink:href="data:image/png;base64, iVBORw0KGgoAAAANSUhEUgAABQAAAAUACAIAAACXhmigAAAACXBIWXMAAA7EAAAO xAGVKw4bAAD6FElEQVR4nOzdiZ9TVZ7//yKVfa2iAFFREQSlcQNRXLDdWu12V1yx 7db+177f7unp/k1/p6fnO/Od7hkRQUBANkHZl6KW1JJKUqkkN7nb7yRRmoYCUsk9 d8l9PR89DGByzqkUlTrvOud8zqI+AAAAAAB8YJHTAwAAAAAAwA4EYAAAAACALxCA AQAAAAC+QAAGAAAAAPgCARgAAAAA4AsEYAAAAACALxCAAQAAAAC+QAAGAAAAAPgC ARgAAAAA4AsEYAAAAACALxCAAQAAAAC+QAAGAAAAAPgCARgAAAAA4AsEYAAAAACA LxCAAQAAAAC+QAAGAAAAAPgCARgAAAAA4AsEYAAAAACALxCAAQAAAAC+QAAGAAAA APgCARgAAAAA4AsEYAAAAACALxCAAQAAAAC+QAAGAAAAAPgCARgAAAAA4AsEYAAA AACALxCAAQAAAAC+QAAGAAAAAPgCARgAAAAA4AsEYAAAAACALxCAAQAAAAC+QAAG AAAAAPgCARgAAAAA4AsEYAAAAACALxCAAQAAAAC+QAAGAAAAAPgCARgAAAAA4AsE YAAAAACALxCAAQAAAAC+QAAGAAAAAPgCARgAAAAA4AsEYAAAAACALxCAAQAAAAC+ QAAGAAAAAPgCARgAAAAA4AsEYAAAAACALxCAAQAAAAC+QAAGAAAAAPgCARgAAAAA 4AsEYAAAAACALxCAAQAAAAC+QAAGAAAAAPgCARgAAAAA4AsEYAAAAACALxCAAQAA AAC+QAAGAAAAAPgCARgAAAAA4AsEYAAAAACALxCAAQAAAAC+QAAGAAAAAPgCARgA AAAA4AsEYAAAAACALxCAAQAAAAC+QAAGAAAAAPgCARgAAAAA4AsEYAAAAACALxCA AQAAAAC+QAAGAAAAAPgCARgAAAAA4AsEYAAAAACALxCAAQAAAAC+QAAGAAAAAPgC ARgAAAAA4AsEYAAAAACALxCAAQAAAAC+QAAGAAAAAPgCARgAAAAA4AsEYAAAAACA LxCAAQAAAAC+QAAGAAAAAPgCARgAAAAA4AsEYAAAAACALxCAAQAAAAC+QAAGAAAA APgCARgAAAAA4AsEYAAAAACALxCAAQAAAAC+QAAGAAAAAPgCARgAAAAA4AsEYAAA AACALxCAAQAAAAC+QAAGAAAAAPgCARgAAAAA4AsEYAAAAACALxCAAQAAAAC+QAAG AAAAAPgCARgAAAAA4AsEYAAAAACALxCAAQAAAAC+QAAGAAAAAPgCARgAAAAA4AsE YAAAAACALxCAAQAAAAC+QAAGAAAAAPgCARgAAAAA4AsEYAAAAACALxCAAQAAAAC+ QAAGAAAAAPgCARgAAAAA4AsEYAAAAACALxCAAQAAAAC+QAAGAAAAAPgCARgAAAAA 4AsEYAAAAACALxCAAQAAAAC+QAAGAAAAAPgCARgAAAAA4AsEYAAAAACALxCAAQAA AAC+QAAGAPSCRCIRDIVMo2Fubs7p4QAAADciAAMAPC+ZTEai0VAoJH5fF2o1MjAA ALgWARgA4G1Xpt8WMjAAAJgXARgA4GHXpt+WRgRWlHK57MioAACAOxGAAQBeJdJv NBYLBoPz/lcyMAAAuAoBGADgSTdOvy1kYAAAcCUCMADAe9pJvy2qqirVKhkYAAD0 EYABAJ7TfvptIQMDAIAWAjAAwEsWmn5byMAAAKCPAAwA8JDO0m8LGRgAABCAAQDe 0E36bSEDAwDgcwRgAIAHdJ9+W8jAAAD4GQEYAOB2VqXfFjIwAAC+RQAGALhaI/1G o8FQyMI2ycAAAPgTARgA4F6JRCIai4UsTb8tZGAAAHyIAAwAcKlkMhmORMLhsKT2 ycAAAPgNARgA4EaN9CtEIlJ7qQu12tzcnNReAACASxCAAQBuNDA4GI1GbeiIDAwA gH8QgAEArpMZGIjFYrZ1JwKwSMFkYAAAeh4BGADgLulMRqTfRYts/Q5Vq9VUMjAA AL2OAAwAcJFUOh2Px21Ovy1kYAAAeh4BGADgFqlUKhaPBwIBpwZQUxRVVcnAAAD0 KgIwAMAVksmkSL/9/f3ODkNRlEI+7+wYAACAJARgAIDzRPqNRCIhaVf+Lki1Wi0W Ck6PAgAAWI8ADABwnm2XHrWpWqkUi0WnRwEAACxGAAYAOCydycTjcadH8Q9M06xW q7NkYAAAegsBGADgpFQqFU8kHCn7fGONDFypzM7OOj0QAABgGddNOAAA/pFMJqOx WDAYdHog8xMZuFKplMjAAAD0CgIwAMAxg4sXRyIRp0dxI4ZhVEUGLpWcHggAALAA ARgA4AwXHv2dl67r1Wp1jgwMAID3EYABwJNEdDT7+voDgbm5OafH0olkKiU+hEAg 4PRA2qJpmiIysDdfagAAcBkBGAA8KZ3JiPSr6boXT6g2bv2NRkOhkNMDWQBVVUUG LpfLTg8EAAB0jgAMAN5zuXaUpmlqva7rurcWJzMDA7FYzOlRLFhdqNW89VIDAIAr EYABwGNE+g2GQtFotPVH0zRFKhNJ2CuFmlx771E7aoqSz+edHgUAAOiQJ+cfAOBb Iv0G+vtF+r3y9KzIwLqmqaqq67r4o5uXKBtr19Fo0FObn69SrVaLhYLTowAAAJ0g AAOAZ4j0uCgQCIdCoXD42v8q0m9rO7Sbl4I9uvn5SqZpigw8Wyw6PRAAALBgBGAA 8IxkKtUMv+Hr7R82RAbWGkzDcOE6sBh/wrObn68kMnClUvFi+TEAAHzO87MQAPCP zMBANBq9aYAUMbhWr+ua5qoM3Kj8HInMu3btRYZhVEUGdvFiOwAAuBYBGAA84IfN z+Fwm1cHiQxcV1XdTZWx0plMPB53ehRW0nVdZGBX/ZQBAADcGAEYADwglUoFQw1X 1r66KfdckiQCfCwe7+/vd3YYltNUVVEUx19eAADQJgIwAHjAwOBgOBxeUPptMQxD VVXHTwWL8V++t6nHcDkwAAAeQgAGAFdrbX4W6bHj5VPTNLVmCDYcWgr29MW/7VAU pcDlwAAAeEHPTkcAoDfctPJzOxoXBeu6pmni/wzDKJfLFo7wphYPDYXtqn0lPkxH NlpzOTAAAJ5AAAYA90omk8FgMByJdLD5eV71el1TVZESbcvAqXQ6kUjY05f46J55 7rmdO3aIF82eHi9rXA5cqcxyMRIAAO5GAAYAl4pGo6FQKBaLBaxb0mxsh9YaG6IN XTdMsyI5BosAH43F7Imj4uP6xWuvDS1ZcuH8+V0OZWDxerqn7DYAALgWARgAXEqk RxGAI3JqR7W2Q2uS70my7eojXdcfePDBBzdsaP3x5IkTB77+2v690IauV7gYCQAA FyMAA4AbifQr8ptIv1Ztfr5Wq0C0MCcnAycSiXgiYU8KDQaD73744ZV/c/TQoW+P HrU/A2uaplSrZGAAANyJAAwAbpRKp8PhcCgUktqLaZoiBtfrdRkFnDIDA7FYzPJm ryXG/8HHH0cikav+fu9XX509c8b+DKyqqsjANlcaAwAA7SAAA4DrtDY/hyMRe64O 0nVdZEhd0yxctxQfQjyRkLd8fZkY/M9efvmW5cvn/a+f/+1vE9ms/Tcw1Wo1tV5n HRgAALchAAOA62QyGZF+7Vy6FDFSBDbNugxsz/KvaZq33nbbsy+8cIPH/N9/+7fZ YtH+DMzlwAAAuBABGADcJZVKifQbDAZtzmyNDKyquqaJVNllDLZt+VcM+JPPPrvp w37/v/+37JHMq1qpFItFR7oGAADzIgADgIskEolQWORfmzY/X6ter4tUaRpGNxnY nuVfkdhffuWVJUuX3vSRtVrtD7/7newD1dficmAAANyGAAwALpJOp1uVn50KwH3N ZdXWRcGdZWDbln+TqdRrb77Z5oOr1eof/+mfwuGw1CFdi8uBAQBwFQIwALiFiI7h SMT+kHYtTdPq9XpnGdie5d/rVX6+gWKx+Od/+Rf7X97G5cDVqqS7pgAAwIIQgAHA FUT6DfT3i+jo4NrvVTooZSw+ilg8Lrt8l67rTz799N2rVi30iRPZ7N/+3/8LBoMy RnUDuqZVuRwYAAAXcMs0CwD8TITGYH9/KBx2w/LvZa0rgjVVbT+5pTOZeDwudVQN pvnhJ5909tQzp059vWePI5cD1xSFDAwAgLMIwADgvGQyGQyFHKx9dT0LysDio4jG YrLXVzVNe2vr1mQq1XELB/btO/n99/ZnYPFK1ms1MjAAAA5y10wLAPypVfvK/kjW jvYzsPgo4omE7PEsqPbV9fzPX/86OTFh/48bOthVDgAALEQABgCHJZPJ1tVHTg/k utrMwENDQyHJW7g7qH11PX/4p38ydL37dhaqpijqQnaVAwAACxGAAcBJiUQiGAyK +OvO5d/LbpqBU6lUIpmUOgbTNO9dt27jpk2WtFar1f74u98Fbb8cWFAUpZDP298v AAAgAAOAk1LpdDgcFhnYbad/r6XrusjAuqbNm4EHBwcj0ajUAYjef/Wb31jYoFOX A7e6LhYK9vcLAIDPuX2+BQC9bWBwUASwQCDg9EDaYhhGrVa7NgMnU6lEIiE1w5um uXHTpnvXrbO22Xw+/+//+q8hJ9aBycAAANiPAAwAjkmlUrF43Cvpt0UEUZGBr9oL vXhoSPY6qqqqn3z2mYyWR4aHv/j8c/svBxaqlUqxWLS/XwAAfIsADADOaNS+CoVk bxuW4ap1YPGBJJJJ2cu/m598ctXq1ZLa//bIkaOHD9t/DFt8XEq1SgYGAMA2BGAA cEC8Wfsq4vraV9fTyMCKouu6yMA23H4kb/n3sp07dowMD9t/EpsMDACAnQjAAOCA ZDIZDjfuPnJ6IF1RFEVTVfFRSN3/LHv597L/++c/z87OkoEBAOhhBGAAsFsikegP BqPRqLdO/17LMAxVBOBwWGpotGH597Lf/a//FXCoHDc1sQAAsAEBGADslkqlQo31 Xwdu37GcaZqyT/8+uGHD+vvvl9fFlWq12j//9rdOfWrIwAAAyEYABgBbJRKJYCgU iUS8vvxrD8vv/r2pubm5P/3hD05l4Nau8nlvWgYAAN0jAAOArVLptAhXjlw860XL b7312RdesLnT3PT0f/zlL059jsjAAADIQwAGAPskk8lgMBhm+bc9qqq+v21bxIlS YRcvXNi1Y4dTNbprtZpar5OBAQCwHAEYAOyTTqfDzauP7C817EXRWOytrVud6t2p y4Fb6vV6TVHK5bIjvQMA0KuYgQGAfQYXL5ZdM9k0TfFrDwRsXdff3Lo1mUw6OIZd O3ZccuJy4BZVVUUGZh0YAAALeX6GBACe0AhyixbF43HZm59FbmwFNq/vstY07Zef ftrBE0VuLJfL0Wg0Eol0n13/8y9/KRQKTmVg8SIo1SoZGAAAqxCAAcAOIgD3B4Ox WEx2R7F4/J61ay8ND+emppzavmuJRzdvXr1mTQdPnJycbO0cDgQCt9xyi0jCXY7k n3/729a6uiN0XRcZuFQqOTUAAAB6CQEYAKQTobRR+0p+8WfDMNY/+GA6kxG/H710 6dLFi33e3A7dzfLvyMjIlX+TyWQGBwe7eRFqtdoff/e7oHOFu8WntSoy8OysUwMA AKBneG9WBACe0yj+HAqJACx1W7KISeFI5JHHHrv8x+zY2MULFwIeDMCZgYFfvPZa B0+cmZkpFotX/WUkElm2bFkwGOx4PCID//Nvf+vU5cB9zaPdIgPPXvOhAQCABfHe rAgAPCeVTkejUakbklt7dO9cufK2FSsu/6XIwPlc7uyZM6ZhyOvacmLYWz/4oIPb j8SLMDw8bMz3wQYCgSVLliQSiY5HNTc396c//MHZDKwoSrFQcGoAAAD0AAIwAMjV Wv7t/iTqjem6PrRkyeq1a69d55yemjp35oyuaV4piyU+lo9//esOnlgulycnJ2/w gHQ6vXjx4o63Qxfz+T//n//jYAYWaoqiqiplsQAA6AwBGADkSqXTNpz+7Vu06OFH HrnequlkNnvu7Nk+03T/eWDTNF946aVlt9zSwXMvl7+6AfG5WLZsWcefjumpqf/8 93+X/tm8IV3XRQZurPmbTX19rd/ohlGtVBwcGAAA7uf2mRAAeFoikWic/ZV8+lck oqW33LLm3nuv9wDDMMZHRz1RE0tEu08++6yDJ4oEePHixXbKNXe5HXp8bOx//vrX bk4US9IIweIz/cMvf9f3429IyAAAuHoaBABel0qlItGo1LAk0k4wFBLpd2Bw8MaP HBsZuXj+/KImeePp0uKhoZd+8YsOnlipVCYmJtp/fDfboS+cP79rxw4XZuAba8Xg Vjy+MiRfTsh9zaPOTg8TAACJ3DsHAgCvSyQSIppGIhGpy78iyty6YsXtd9zRTh7L TU+fPnnStXuhOy5/JUxPTy/0stxutkOfPXNmz65dnsvAN9YKxi3XriGTjQEAPcCN EyAA6A2pVCrUPP0rNW2m0ulVa9a0X2RrbHR0+Pz5PlfuhRa5a9uvftXZc4eHh3Vd X+izAoHA0qVL4/F4Bz2ePHHiwNdfSy3u7So/BOMfV5AbvzSzsfiLmx69BgDAJVw3 +wGA3hBPJET0jYTDAZkBSWSPBx5+OJlKLehZoyMjw+fOSR1YZ55+9tnbr7jGqX21 Wm1sbKzjfjOZzODgYAc/ETj5/fcH9u3zTwa+HvHvUNf1K7OxSTAGALgSARgApEgm k5FIJChz+VcEjHA4/MjmzR08t1gofH/smKsWgTu+/UgoFAr5fL6b3sUna9myZR1s aT5+7Njhb74hA8+rEYuvXDduxmK2UgMAHOSiqQ8A9JJUOh2LxeSd/m2liTtXrrz9 jjs6e/pMLnfm5EnTNeeBO67/LIyPjyuK0uUAxCdLZGDxWVvoE/22F7pLreXiv580 bv5KKgYA2MMVkx4A6DHJZDIYDEYXHqXaJ8KDyNhr160Lh8MdtzA+Nnbp/PlFMmt0 tU+8aK+99VYHTxQfyMXmDU+WGGha6A8FyMDdaO2XbqXiy/uoicQAABkIwABgPRFN w83yV/K6EFnh3nXrhpYs6aoRXZ/IZoebdyNZNbCO3f/AA/c/9FAHTyyXy5OTkxaO JBqNLl26dKHboXuyLrSDWpH48tFi8QdOFAMAuuf8jAcAek9mYECEKKmnf+OJxEMb N1rS2ujIyKULF/ocrQutadp7H31k2wVIN9VZdWiP3g/sCaZptvLwD6vELBEDADpC AAYAi7XKX4U63ZncDhEAVq5evfy226xqcHxs7OK5c33OZWBd0z7+9NPOnnvp0iWR ny0dzg86qA49OjLy+d/+JnXxHy0iA4vPu/HjcWLyMACgHQRgALBYKp2ORqPyjoOa pplKpe5dv97ClUZd10eGh8dHRhoJ2IkMvOKOO7Y880wHT1RVdUQMW5pwOLxs2bIF BdqJbPav//EfUn8CgmvpP2J9GABwAwRgALDYwMBAOBKRV/9ZTO7vuffepcuWWd7y +bNnx0dH7a/k1M3+59nZ2VwuZ/mQrrRo0aKhoaHUQi5bzudyf/nznzuuT4YuXd4v 3crDVJkGAFxGAAYAKzX2P0ejwWBQ0jqqSL+xePy+9euj0aiM9ifGx8+dOSMvvc9L BOBfdrr/OZvNVqtVS4czv0QiIWJw+z8dmCuV/vTHP5KB3aC1WfqHu5copgUA/kYA BgDLiFAaCofj8bjE8lemueLOO29fsUJeRh0bGbl44cIiG88DDw4Ovvzqqx08UcSZ 4eFh0zQtH9K8RPpdsmRJ+5WxRDL//37/e84Du4r419IIw+J/hGEA8CUCMABYRkQj kXZiCywdvCCi8TX33iu1C+HCuXPjo6P2rAOrqvr+tm2d7X+uVCoTExOWD+nGUqnU 4sWL23xxarXan/7whz5HK2zjehphWFW1HytLs00aAPyA78cAYJlkMhkKhzvLcu0Q 0/TVa9cuu+UWSe1fNjYyMnzhgj2Z7dbbbnvm+ec7e24ul5udnbV2PO0IBoNLliyJ xWJtPv7f//VfS6USGdjNftgm3VwZnrP6Vi0AgHvwzRgALCO1/rPZ3On7xJYtMhq/ qqO9u3bZs/xbr9c/+Pjjjn9kIO8CpHYsaCn4i//5n9GREfsLjKEDWlPjzDB7pAGg 5xCAAcAy6Uym/QOiCyWm4wODgz954AFJ7V928vvvCzMzsnvpaybthzduXLd+fWdP F+F5dHTU2iEt1IJOBR88cOD748fJwB4i/omqqqo3wzAbpAGgNxCAAcAajf3PoVBE TnFmwTSM++6/X2RgSe23VCuVwwcOBGwJaSJafPLZZx0/PZ/PFwoFC8fTMRGAFy9e 3E6xqzOnTu3dvdvCC5xhm8aisAjDus6lSgDgaQRgALBGKpUKRyLySv5GIpGHN22S 1Phl+/fsMQxDdi99zQXtZ557bsWdd3bcwujoaL1et3BI3Vi0aFE6nR4YGLjpjujs +Pjf/vM/Q1yP5Fnin67aSsLUzQIADyIAA4A1MpmMCMCSNriK2fatt99+9+rVMhq/ bPjChbGREXtqNZmm+dEnn3T8dJFARkZGLByPJcRnf/HixYlE4savYbFY/PO//AtX BHudYRji36GmaSRhAPAQAjAAWGNgcFBEGlm1o0xzzbp1i4eGpDTeVFOUb/bts+eE qsgMr7/9diaT6bgFkSFnbDmo3IFQKCRi8I0PBler1X/5/e+DXBHcE0QSrtfrrAkD gCcQgAHAAq0LkAQZy6emaabT6XvuvTcs7YIlYd/u3c0603aIxeNvvvNONy2MjY3V ajWrxiOD+McwMDAgYvD1/kmI8f/bn/6kaRrXI/WMH3ZHaxrnhAHAtfimCwAWSKZS zfwrZVOroetr1q1bsnSpjMZbThw/XrSroJRar7/fxdVHfW7d/zyvYDCYyWSSyeT1 tgZs/+//HhsdpTR0jxEZuN5MwsRgAHAbAjAAdCsajbaWfyVVwNINY/OTT8rLSNnx 8Qtnz9p29HfNvfdueuyxbhpxT/3nNonXNpFIpFIpEfuvfZ0PHzx4/NtvycC9p3WL UuNKYU3jPmEAcAkCMAB0KxaPB4PBWCwm4wCwmEMHQ6FNmzdb3nJLqVT69tAh29JX l1cftYyMjIh2LBmPzcTrHI/HRRiORqNXJuGLFy58uX27vBLicNYPh4Q1TXy5OT0W APA7AjAAWCCdTotYI6NlMXVetnz56jVrZDReU5SD+/bZc+tvX/OE5HMvvHDbihXd NFKr1cbGxqwaklMCgUD0R62j4/lc7i9//jOloXtb4y7hZrkstkYDgFMIwADQrXg8 HgqHY7GYjMbFXPmhjRsTyaTlLddrtW9E+pVUtno+/cHgex9+2GUj09PTPbaMJj4F rf3zIgPv27vXMIxWNbJFTf39/VTJ6jEsCAOAg/ieCgDdapWA7qaq0w2ILPT4li2W N9tIv/v3B2xMVqqqvvvhh13+mEAkh+HhYduqVdtPZN3WRydScX+Tpqoi888Wi+W5 OUVRWsHpqpDcyslOjx0Lptbr4uvC4PIkALARARgAupVKpULNFTzLV+rEzDgajT60 caO1u5RLs7PHDh+2bedzXzPGr7///gc3bOiyndnZ2VwuZ8mQeokIUfmZGfFpLZfL dUVp3MSj62ZT42ccixYFmlhJdifxyWr9XIMYDAA24HshAHRLBOBwJCKjgpGYGQ8u XrzmvvuCwaBVbU5ms2dOnbJ5wVAk+W2/+lX37Xi3/JXjlGp1Ipstz81Vq9XWXbWt ZeRWMGajtePE50LEYE1V2RcNAFLx3Q4AupVMpWKxmIxIKQLw8ttuW3n33Vat1n53 7NhsoWBz1NE07a2tW8Wr1GU7iqKMj49bMiRcpV6rTU5MzBaLIh6L3zcWkA2j74r9 1cRje7RuThJKs7NOjwUAehPfzwCgW6l0WtIdSIZh3H3PPctvvbX7pspzc0cOHrT/ pKiY0N+7bt3GTZu6b2piYqJSqXTfDhaqWqlkx8ZKpZLSXD0W/yzFXy5qrh1z9liS Rgiu1zkeDACWIwADQLfSmUw0GpURgHVdf3DDhu7XTk9+911+ZsaRRTyrNj/X6/XR 0dHu24GFREbLTU4WCgUR0uqKoreCcfPIMcHYEpqmiX/5BtcmAYB1CMAA0JXGPa6R iKQAbJrmxkcfDXdRX3pqcvLMyZN23nV0JTF93/rBB5ZcEDU5OVkul7tvBzYQwXh8 bKyQz1crFbVeF/+MScXdaFTJau5LJwYDQPcIwADQlVg8HgwGE4mE5S2L2CACw/0P P9xZgCyVSiePHxcR1KnTm2L8jz3++Oo1a7pvSgSqkZGR7tuBg35IxblcuVLRVdVs rhWLrx1OF7eJGAwAluC7DgB0JZ5IiEl8PB63vOVGhd7+/g2bNi20vnR5bu7Ed9+p 9bqz0SKRSLz+9tuWNDU9PU1p3J5ULpeHz58vzc6KaGc0S1ITiW9MBOCaeK2IwQDQ Kb7HAEBXRPQNhcPRaNTyWXtj42hf3+YtW9p/iggSp0+cEPNjp/Y8X6ap6i8/+8yS pjj96yuVcvnCuXOzs7NqvS7+2N/k9KBchxgMAB0jAANAV2LxeDgcjkQilmfOxhbo YPDRxx9v58G56elzp0+LabEbVs8Mw3j1jTcyAwOWtJbNZqvVqiVNwXNUVR0bGZme mlKqVZH3Av39Ft6J7XW6pjViMJWiAWAhnJ8nAYDXDQwMRK2o83QVMa+NRqPrH3zw BkWwREgevnBhvLlA6obo29cc0tr77nvk0Uctaa1SqUxMTFjSFHpA6yDxVPNnIq1D 8qwPN+9LqnNvMAC0yRWzJQDwtIHBwUgkImMLtGj2gQ0b5l3yqtdqZ06dKuTzbgsA Ysxvv/eeJU2JV2B0dFTM7y1pDb1H/NsYHR6enJio1Wp+LqklvlJEBhavxhxH5QHg Zvz4fQIALBSNRiPifxK2QPc191c/uGHDVX85NTFx8fx5Mdl1/KDvtTRN++Wnn1rV 2uzsbC6Xs6o19LxSqXT21Kny3JxhGD5cHBYxuFaraSIGsyMaAK6PAAwA3RoYGAjL OQMcTyTuW78+HA73NZd8z54+XcjnXZh7WxpHf998M5PJWNKayNKjo6OiTUtag9+I r5dzZ87M5HK6pvUHg/4Jw+JLRsRg8VETgwFgXgRgAOiWpC3QQigcXnf//bmpqfGR EU3XXRt9+5pxffOTT65avdqq1iYmJqh9BUvUFKXxw6OZGV3XfRKGtWZ9LA4GA8C1 CMAA0JVoc/9zNBaTEYBNwzD7+tyce1tEXr1n7dpHN2+2qkE2P0MSEYZPnThRLBTE 73v7zPAPB4PrdZaCAeBKPfu+DwD2iMfjYhodTyScHoiTFi9e/NIrr1jVWqOy0eio mL5b1SAwr3wud/rkSRGJe3hZuLEjWlF0bgwGgB8RgAGgK40AHArF5KwAe0I4HH7n /fetak3k3mw2qyiKVQ0CN9WqqT7T3HTQk8vC7IgGgMt67S0eAGwWTyTEjDkajbp/ o7IMiwKB9z/6yMLAkM/nC83tqYAjxsfGzp85o+t6KBTqpSTMjmgAaOmdd3YAcEo6 nY7F4700V27f+9u2WZj8y+Xy5OSkVa0B3cjn86e+/76mKOFwuGe+ukWwFx/RLEvB AHysR97QAcBB6UzGhyvApmmK9Gvhycl6vT42NsbRX7hNsVg8ceyY+PfZM2vCtVqN pWAAvtUL7+MA4Kx0Oh2JRnu1iM68REj9wNK1X13XRfrVNM2qBgHLzeRyJ7//XlPV HkjChmEoijJbLDo9EACwm7ffvgHADVLptJgQh8Nhpwdik/5g8L0PP7SwQW79hbdM TkycOXFC/LsNhkJOj6UrdaFWYykYgK8QgAGgW8lkctGiRYlk0umBSCdm/Ol0+tU3 37S2zenpaabg8BxVVU+fOJGbnu5vcno4HWIpGIDfEIABwBrLb73V6SHIJZLqrbfe +uzPfmZts7lcjpI88LRKuXzs6NGaonh3azRLwQD8w5Nv0wDgQr0dgA3DWLd+/YZH HrG2WS49Qi+ZyGZPnzgRCAS8uCBMgWgAPkEABgBr9HAA1jTtpV/8Ytktt1jbbLFY nJmZsbZNwHFKpXL0yJG6ooS8VhfANM1Wgehyuez0WABAFgIwAFijVwOwmA2/+9FH sVjM2mZnZ2dzuZy1bQLuoarq2VOnJicmgsGgtxaENU2rKUqpVHJ6IAAgBQEYAKzR ewHYNE0xcX9z69ZIJGJty4VCIZ/PW9sm4E7FfP740aN9ixZ5KAaLr/1qtUplLAA9 iQAMANbosQCs6/p9P/nJI48+am2zYmItom+RiTV8RqlUjhw+rNXrHro5qbUdmspY AHoMARgArNFLAVjMen/++utLly61tlmRfnO5HFsr4Vuqqn57+HB5bs4r14azHRpA 7yEAA4A1eiMAi4waCATeevddy7c9G4YxNTVVqVSsbRbwnMsXCHvi2iS2QwPoMW5/ 2wUArxhcvNjy0GgzMS9/eOPGBx56yPKWNU2bmJio1+uWtwx41/CFCxfPn/dEDK4p inh/YDs0gB7g9jdcAPCKZDKZSCbdP5Gdl9n0xjvviI/C8sZrtZpIv7quW94y0ANE BhZJ2P0xWARgEYPJwAC8ztVvtQDgLbcsX+7yKey8xLx2/QMPbNy0SUbj5XJ5ampK pGsZjQM9Q8Rg8b9wOOzm9xBD16uKUpqddXogANA5977JAoDnLLvllkAg4PQoFkDX dTHhfvWNN+KJhOWNU/AZWKjzZ8+OXLwYcnEMFl/XSrXK1zUA73Lp2ysAeNGSpUuD waDTo2iLmMWK9Pviz39+y/LlMtrXNG1qakpRFBmNA73txPHj01NTIRdfmMSRYADe RQAGAMsMLVni5jlri4i+Yua64ZFHZBS7aqlWq5OTk4ZhSGof6Hn1Wu3wwYNqve7a n6lxJBiARxGAAcAyLg/Arej78IYND27YIK+LQpOk9gFfqVYqhw4cEL/p7+93eizz 0HVdqVa5JRiAtxCAAcAyrt0CLXKppqobH310/QMPyOtFpOupqalarSavC8CH8vn8 8SNHxHuLCw8GG4ZRFRmYslgAvMN176QA4FHuvAZJ13UxpKd++tO7Vq6U14sI2KVS aWZmhmrPgCSt25LC4bDTA7ma+KoXGXiWslgAPMJdEzUA8K50JhOPx50exQ9au50H Bgeff/FFGVf7XknTtOnpaTEDltoLAPFFfWj/fvEV58Id0Uq1KgbGkWAA7kcABgBr DC5eHIlEnB1DY6uzpoWCwceefHLV6tU2dMfCL2CzYrF49ODBUCjktv0mtVpNrdfJ wABczl1vnQDgUclkMp5IOHUJcCv39vf3b3jkkXXr19vTab1en56e5sQv4IjzZ8+O Dg+HXLYjWrwt1BSlXC47PRAAuC4CMABYIJVKJSTvNL6W3hSLxR59/PGVd99tW7+t Us/FYpGFX8BB9Vrtm337xJehq3ZEcz0SAJcjAAOABTIDAyKI2tBRq55zoL9/6bJl jz/1VDqdtqHTK1Wr1VwuJ+a4NvcLYF7jY2NnTp50VXEsTdOUapUMDMCdCMAAYAGp NwCL0Nsq5rx4aEiE3sHBQUkd3ZiY1M7MzLC5EXAbVVW/+fprwzDcsxTMFcEAXIsA DADdknoBkki/jz3++Oo1a2Q03v4YisVioVBgzzPgWhPZ7Knvv3fPUnDjiuBKhQwM wG0IwADQLakXIGma9stPP5XUeDvK5fLMzIwYhoNjANAOVVUP7t+vu+aepEYGrlZL s7NODwQA/o4ADADdknoBkoMBWFEUEX2p8wx4S3Zs7LRrTgWTgQG4DQEYALoi+wKk VDr96htvSGr8elRVzefzHPcFPKpeqx3YuzfQ3++Gu4JN06xWKrNkYADu4PzbIgB4 mgioiURCUuNi4vjz116zs+qVruuFQoGpKtADzp4+nR0bCwaDTg+EDAzARQjAANCV gYGBqLQLkOr1+q9+8xtJjV/FMIxiE5WugJ5RKpUO798flnZGo31kYAAuQQAGgK4s WbpU4gKLaX74ySeyGv+RiL5iViqir/iN7L4A2ExV1UP792suqIxFBgbgBgRgAOhc Ukil5LV/x513PvXTn8prXyTeUqkkoq+u6/J6AeC44QsXLl286Ph2aDIwAMcRgAGg c5mBgZi0/c8ilL774YeS6kuLaaiIvoVCgegL+MRcqXTowAHHq0OLN59KpUJdaABO IQADQOeGliwJhUKSGldV9ZPPPrO8WcMw5ubmiL6AD4l3lQN79y5qcnAYZGAADiIA A0CHkslkIpmUN48Ujb/+1lsWNshZXwDCye++y01PO3skmPuBATiFAAwAHcpkMrF4 XFLjYnb4i9dft+oCJF3XZ5uIvgCEyWz21IkT8jawtKORgSuVUqnk4BgA+BABGAA6 tHhoSN5pOqsuQNI0rRV9udwIwJUq5fI3+/Y5eyTY0PXGOjAZGICNCMAA0AnZ+58D gcD727Z104KqqsVicW5ujugLYF7iXWLf7t39/f0OHgnWRQauVMQ7lVMDAOA3BGAA 6EQ6k4lL2/8sIuvmJ59ctXp1Z0+v1+ut6GvtqAD0pCPffFMulx08EqxpmlKt8pYF wB4EYADohNT9zx3Xf1YURUTfSqVi+ZAA9LCzp09PjI87mIHFm57IwCKHOzUAAP5B AAaABZO9/1nX9Y9//ev2H2+aZrVaLRQKtVpN0pAA9Lbs2NjZU6eCzpXFqgu1GuvA AGQjAAPAgkmt/yzcvmLF088+284jRfQV88VisaiqqrzxAPAD8U5y9OBBB8ti1Wo1 tV4nAwOQigAMAAs2tGSJvOtDNE1776OPIpFIOw+uVqvZbFbSSAD4jVKp7P/6awcz sNLczOJU7wD8gAAMAAuTTKUSiYS8/c+aqv6y7QPAU1NTrJYAsFC9Vvt6926nMnDr QMdssehI7wD8gAAMAAuTGRiIxWLy2l+6bNkLL73UziPFTHF4eNgwDHmDAeBDqqru 37MnEAg4cj2SeGerVCql2Vn7uwbgBwRgAFiAZDIZjcWCwaCk9nVdf+f999sM2Ox/ BiDPga+/1lTVkQxsGEZVZOBSyf6uAfQ8AjAALEAqnU4kEvLaX9AFSLlcbpZFEgDS HD5wQFEURzKwrusiA3PEA4DlCMAAsACDixe3WZ6qMwODgz9/9dV2Hmma5sjIiKZp 8gYDAMeOHp0tFBy5IlhV1ZqikIEBWIsADADtSiaT8UQiEAhIal/X9bfffTfe3gqz oijj4+OSRgIAl31//Hg+l3MkA9dqtfzMjP39AuhhBGAAaFc6k4nLvP5X07Rffvpp mw+emZkpuqlQ6tTk5MT4+P0PPeT0QABY78Tx4zMOZeBqtVrkYiQA1iEAA0C7pF7/ Kyy75ZbnX3yxnUe6bf+zSL9ifqzW6wOLF2989FGnhwPAeqdOnJienLQ/AzcuRqpU qHcAwCoEYABoSyqVSiST8toXafa9jz5q84Cxq/Y/z83N7du9uz8Q6Fu0SNf1+x98 cNny5U4PCoD1nMrAhmFUKpU5ikIDsAIBGADaMjA4GI1G5bWva9rHHtz/fOTgwdz0 dCv9ij+aRsPzL7/s9LgASHHyu+8aX/K2Z2BN05RqlYJYALpHAAaAm5Nd/kq4a+XK J7ZsaeeR7tn//OX27bqqBn5Mvy0iAwdDoS3PPuvcuABI5FRNrHqtVq/XycAAukQA BoCby2QyMZnlr1RVfX/bNg/tfy4WCgf37xe/mfeHAoaub9y8Wbxoto8LgB2Of/tt qVi0/35gCmIB6B4BGABuIplMRmOxYDAorwvTND/65JM2H+z4/udLFy+ePnlSRN/r Tn9Ns3EY+KGHOAwM9Kqjhw5VymWbM7B4q6xUKiUKYgHoAgEYAG4ilU4n2rubtzNi SvfU00/fuXJlmw++dOmSiJfyxnNjJ777bvTSpZv/OMA0xS/P/OxndowJgBMO7t9f r9VszsCNgljlMhuhAXSMAAwAN7F4aCgcDstrX63XP/nNb9p8cLVazWaz8gZzY0cP HZqemmrz7J+Ypw4MDm7YtEn2qAA4Zf+ePbqu25yBVVWtKQoZGEBnCMAAcCOpVCqe SEid3iWSydffeqvNB09PT5ccugtkz86dSrV6VcmrGzN0fWjp0gc3bJA6MAAO+mrH DqknROalKEohn7e5UwC9gQAMADcyODgYkXr7ka6/uXVrsr0bhk3THB4eNgxD3njm lZ+ZOXbkiKZpHdTBFs9ac999d951l4yBAXCcqqp7d+2Suk1mXpVKZdYdt8EB8BYC MABcl8iliWRS6vLvgq7/FRO+iYkJeYOZ12Q2+/2xY4ZpdnYLlAjtpmE8+sQTyVTK 8rEBcIOaouzbvTvcXh17qzQOA1cqcw7tiAHgXQRgALiugcHBqMzlX5ENH9ywYf39 97f5+MnJyXK5LG8818rlcocPHAj29ze2PZtm+5uff9B8igjAoXD4qWeekTNGAM6r VioHvv7a5nVgDgMD6AABGADml0wm44lEZ8uebVpQ+SvDMIaHh81mdWV7nDt9+sL5 822WvLoxMfglS5c+8PDD3TcFwJ2KhcKxI0dsPg/MYWAAC0UABoD5ZQYGYrGY1C7C kcg7773X5oPn5uampqakjudK+3bvLs/NBaxIvw2mqRvGXStXrl671poGAbhPdmzs 3JkzlvzUrE2maVYrlVluBgbQNgIwAMwjISSTUpd/dV1//e230+l0m4/PZrPValXe eK701Y4d9VrNsvT7I/Ehb9i0aXDxYmubBeAeZ0+fnhgftzMDczMwgAUhAAPAPGxY /hVp8ONf/7rNB2uadunSJanjaZnMZi+cOydmk4tkhH/TFKH66eees75lAK7x7eHD Io/aeTlwXajVyMAA2kEABoCr2XD61zTNJ7ZsWXn33W0+vlAo5OWfczt3+vTF8+cX dNPvQhm6HovHH9+yRVL7ANxg95df2rkILFSr1WKhYGePADyKAAwAVxsYGIhKXv6t 1+u/arv8lTAyMqKqqrzxCGdPnbrYKnkled1G17Q7Vq5cc++9UnsB4CDxfrVn586I jRcjmaZZKZdL3IoE4GYIwADwD2y4+1dYumzZCy+91OaDa7Xa2NiY1PEcP3p0Ipvt l7n2+3fNu5GeeeEF6R0BcI5Sqey392IkTdOqlYrNd8UB8BwCMAD8A9l3//Y110be 37at/bWR6elpqcsae778UlEUqTufr2Iahujr2Z/9zJ7uADhiJpc7cexYv40XI3Er EoCbIgADwN8lU6lEIiF7+TcUCm394IM2H2ya5vDwsCESoxySCj7fVONm4GXLHnjo IZv7BWCnc2fOZMfGbDsP3NgIXamUuBUJwPURgAHg7wYXL5Z9aG2htx/Ju/63VCwe OXRIrdftT78NzZuBf3L//ctvu82B3gHY5eD+/fVazbai0OI9tlqpUBEawPUQgAHg B6l0Oh6P2zBL+/CXv2z/wZKu/y0Wi0cPHjR03bZtz/MSU9XHnngimUo5OAYAsu3a vj1k42HgWq2Wn5mxrTsA3kIABoCGZDIZiUZDoZDUXgzDePmVV4aWLGnz8ZKu/52b m9u/d+8i05Ry2e+CmGYgGHz62WcdHgYAmRRF2b9nj50FsSrl8iwboQHMhwAMAA3p TCYej8vuRQTgbb/6VfuPz+fzBatvtizk8wf37QsEAs6n3yZD1weHhh5+5BGnBwJA ounJyVMnTth2GJiN0ACuhwAMAI3l31g8LntmJiZkz7/44q1tH3k1TfPSpUviWRaO ITs+/v2xY+Kt3yXpt0XTtJV337167VqnBwJAohPHjxfyedsOA7MRGsC8CMAAYMfV R4Kmqr/87LP2H18ulycnJy0cwNTk5LGjRxvB19Fzv/MSL87Dmza1vzkcgBft/vJL 2xaB+9gIDWA+rpsDAYDNUqlUXP7VR6ZpPrFly8q7727/KZaXv9q5fbvjVa+uxzQM c9Gi57gZGOhpqqru2blTdrH9y9gIDeBabpwGAYBt7Kl91dec9n2ykOVf8fiRkREL B/D5X/8aECnfTTufr2IYRiKReOzJJ50eCACJ8vn8999+a9s6cE1RRI/29AXAEwjA AHwtMzAQi8Vk9yKi3ZNPP72g5d+ZmZlisWjVAL7cvt3QNDen3xZD1+++556Vq1Y5 PRAAEp06cWJmetqew8CmaVYqlRIboQH8iAAMwL+SqVRC/uZnQde0jz/9tP3Hixnb 8PCwiM2W9L53505FUdyffvuaH7hpGM+99JLTAwEg1+4dO/qDQXv6Eu/AIgOXy2V7 ugPgcgRgAD7V2PwciYTk30u50OLPfc17eqempizpff+ePXOlUsDGqjNdMnR93f33 L1/IywXAc+q12te7d9t2M7CiKAU2QgNoIgAD8KlMJhOTf/GvYJjmtk8+WdBTxsbG arVa910fP3p0Mpv1UPptME3xeeEkMNDz7LwZuLERulwulUo29AXA5QjAAPwomUrF 4/GA/F3Buq6/8tprg0ND7T9FUZTx8XFLev/8r3/tFx+jK8s+X5dp6obxPLugAR84 euiQyKX2HAZWVbWmKFSEBuCpWREAWMG2ys9CYNGi9z/+eEFPmZyc7P6smpjkHfnm G01VPZZ+m0zDuPX22+/9yU+cHggA6XZu327bRuhqpWJhcUEAHuW9iREAdGlgYCAq v/KzoGnaG++8k06nF/SUS5cudd/1gb17S6WSDUvckvQHAluee87pUQCQrjw3d/ib b4K2FMQyDKNSLrMIDPgcARiAv6TS6Xg8bs+Ou2g0+ta77y7oKZbcfnTh3Lmzp0/b M6GURNf1TZs3pzMZpwcCQLozJ09OT03Z87Zcq9XyMzM2dATAtQjAAHwkmUzG4nF7 aq6oqvr+tm2RSKT9pxiGcenSpe5vP9r+t7+JN3dP3Hs0P9PUdP2Fl192ehwAbPLV jh22/cyuXC5zLTDgZwRgAH4h0m84ErHnsJlpmqvuuWfzE08s6Fmzs7O5XK7Lrocv XDh76pTHKj9fxTR1XX/sqafEp8zpoQCwg6IoB/butac0g3h7aVwKzLXAgF8RgAH4 RWZgIGbL0d++5vLvJ599tqCniMw8Ojoqnthl1zu3bzd03Yu1r65kGsbDjz46MDDg 9EAA2OTSxYvif/bs0FGq1UKhYENHAFzI2zMkAGiTnUd/dV3f8swzd61cuaBnlcvl ycnJLrseGxk58d139swgZXto48aBwUGnRwHAPnu+/NKe3SumaYq33DmuBQZ8iQAM oPclk8l4ImFbSWQRsz9Y4NVHwujoaL1e77Lr744dmxwf9/Dp38tM8/Y77rjn3nud HgcA+9RrtX179tizEVq83850feQEgBcRgAH0uEQiEYvHbSuvoqrq2++9t9DDq9Vq NZvNdt/75//1X/1eLv58mWEYa+67b8Uddzg9EAC2unTx4sjwsD0/r6yUy7NUwwL8 hwAMoJc1Cl8JCynF3A3TNFeuWvXEU08t9Inj4+OKonTZ+5lTpy6eP+/p248uEwH4 uRdfdHoUABywe8cOe36QRzUswJ8IwAB62cDAQNSuwld9HdW+6muWPxUBuPve9+/Z M1cqebv+848MXX/upZecHgUAB9QUZb9dFaGr1WqRaliAzxCAAfSsdCYTj8dt607X 9ZdeeWXp0qULfWI2mxWTsO4H8OXnn+ua1gsB2DTFL8/87GdOjwOAMy6cO5cdG7Oh bKFhGJVyeW5uTnZHANyDAAygN9lZ9rklkUi8/vbbC31WvV4fHR21ZADb//Y38att tb7kMXQ9nkhsXvhOcgA9Y9cXX9izCFyr1fIzMzZ0BMAlCMAAelAqlYrF43ZGQZFj P/j448jCDxtPTk5acgItn8sd/uabvkWLeiAA67q+/LbbfnL//U4PBIBjKuXyoQMH bChqYJpmpVIpUQ0L8A0CMIBekxTpNxaz8y5cEdiee+GF21asWOgTLVz+zY6NfX/s WCP92rjoLYl4PR/auHFoyRKnBwLASSe/+y4/M2PDRh5NVRVFYSM04BOenycBwJWS yWQsHrcz/QrxROKNhW9+FiYmJiqViiVjGL106dSJEwExU/R6ADZN8Xo++sQTTo8D gPN2bt8eDodt6Ei8Fc8WizZ0BMBxHp8nAcAVRPqNxmI23wPU8ebnWq02NjZm1TCy 4+Mnjh9vvKd7OgCbpm4Yz1P/GUBTMZ8//u23NvxMkyuRAP/w8jwJAK4g0m8kGrWn aMplYs70s5dfvmX58g6ea1Xx55axkZEzp06ZhuHpAGwYxuKhoYc2bnR6IADcYt+e PY13NvmUarXAlUiAD3h4ngQAlzmSfk3TvOOuu7b89KcdPFdEXxGALRxMsVA4euiQ Ycs0URIxxzX7+p578UWnBwLARVRV3btrlw0bocVbeuNCJE4CA72OAAzA8xxJv33N 5d+Pf/3rzp47NjZWq9WsHc+BvXs9vX9PU9XVa9euXLXK6YEAcJfRS5cuXbxoQzUs rkQC/IAADMDbnEq/qqq+/d57ovcOnlupVCYmJiwfUm5q6uihQx4tBG3o+p0rV4oA 7PRAALiRPdcCN65EKpdLpZLsjgA4yHuTJAC4rFH1KhoNOrH2+/iTT65es6aD54oJ 1tjYWL1et3xU+Vzu4IEDwf5+zwVgwzDS6fQjmzc7PRAALlUulw/bci2weHOeyeVk 9wLAQR6bJAHAZY7UfO5rJthlt9zyQqeVikul0vT0tLVDuuyL//5vG3YJWsvQ9Xgi sfmpp5weCABX+2bfPk1VbehIhO3S7KwNHQFwhMfmSQDQkkylYrGYzff9tuia9vGn n3b2XMMwRkZGdF23dER/9+3hwzMiXXslA5umeCnEp/KxJ590eigA3K5RDWvnzvDC 75xbKE3TlGqValhAr/LIJAkArpBKpaIOpd96vf7O++93dvRXmJmZKRaL1g7pKp// 13/1u38XtGkahmGa5q0rVty1cmU8kXB6QAA8YGxkZPjCBRv2uVQqlVnJ79UAnOLu GRIAXCOVTsdisUapJ9vpuv7Mc8+tuPPOzp6uquro6KhIfdaO6iqHv/mmmM+7NwA3 P3zdMKLR6JMd3SAFwM/sqYYl3u0r5bKn6+oDuB63zpAAYD7pTEakX0eOuYrges+a NY8+/njHLUxMTFQqFQuHNK9Ssbh/717XLgIbuh4MhVavWXPbihVOjwWA95RKpW8P HuyXX/2hWq0WCwXZvQCwnxunRwAwr8zAQDQadarIUygU2vrBBx0/XcylstmsheO5 gXOnT188fz7gxBbxGxDRV2TyBzduHBoacnosADzs6927+yRvpelrlmyolMucBAZ6 DwEYgAckk8lgKCTSr1MDUFX1/W3bIp0WXzFNc3R0VLWlfmnL3p07q4riyEbxq5iG 0djwHIncfscdK1evdno4ADyvXqvt27PHho3QLAIDPYkADMDtRPoNRyLhcNipAYjJ 1rsffthNoabZ2dmc7RdLfrVjR71edywDt8pcNSuWDS1ZsqqjO5MBYF6nT57MTU3J 3hDEIjDQkwjAAFzNqct+L9NU9eevvbZk6dKOW9B1fWRkREykLBxVO8Sk7eD+/Yam LbIzA/+Ye/sDgYHBwRV33SXSr329A/CNnZ9/bsOVSEq1WmARGOgtBGAA7uVgwecW kV03P/HEPWvXdtPI5OSkU6VERQY+tH+/bkMGbuZe8f8N0xRT0jvuvHPlqlVyewTg b5PZ7JlTp2Tfh8ciMNB7CMAAXCqTyUQdKvjcItLvuvXrN27a1E0jlUplYmLCqiF1 5tyZM+fPng1KqAttNrX+XzgavX3Firs55QvALvZciaQoSiGfl90LANsQgAG4juMl r/qa0e62229/5vnnu2nEMIyRkRERpK0aVce+O3YsOzq6KBBY1PqJQjdJuFl81WxW txKvUjyRuHPlSu40AmC/uVLpyMGDss/IiDe6xhIwi8BAryAAA3AXkX4j0agNP9S/ ATHdSafTr775ZpftTE9Pl0olS4ZkiW++/rpYKIgYvLBd5VdcN9KIvIbRHwwuW758 3fr11g8RABbCniuRaoqSZxEY6BUEYAAukkqno9Go7DNdNyYinhjD2++912U7iqKM j49bMiRrjQwPnz11Std1s7ES/ONa8D+uCQeu+KPRXOkNhcPis3PP2rXJVMrW4QLA 9dlzJZJ4D6yUy676gSaAjhGAAbhCMpnsDwZF8nTw0G+LSHvbPvmky0bsv/h3Qebm 5sZHR0uzs5VKRavXW3WbG6+8aTYicX9/sL8/EomkBwZuX7FC/Afx2RFPEb86PXAA uNqhAwdEDJbdS61Wy8/MyO4FgA0IwACc17jpV5B/ocVNaar63rZtka5Hks/nvXhz xmQ2K0J7f1MwGBwcGnJ6RABwE+Jda++uXbLvimcRGOgZBGAADkulUpFo1MGbfi+r 1+sffPxx9+m3VquNjY1ZMiQAwE2dO3NmMpuVvYGIRWCgNxCAATgpnclEo1EHb/q9 TKTf9z76KBaLddmOYRijo6OaplkyKgBAO3Zu384iMIB2EIABOCORSDR2PTt619Fl VqVfYWpqitsyAMBmYyMjwxcusAgM4KYIwAAc4J5tz32Wpt9yuTw5Odl9OwCAhbJn EVi8z8+xCAx4GQEYgN0ymUw0FnO82nOLqqrvfvihJelX07TR0VHDMLpvCgCwUJMT E2dPnZJ9poZFYMDrXDEBBeAT7qn23GJVzee+5rJANptVFKX7pgAAndm1fXvIhkXg uTmOugDeRQAGYJNUOh2NRvv7+50eyA90XX/3ww8tSb9CsVicYU0AABw1k8udOH5c 9jeamqLk83mpXQCQhwAMQLpkMtkfDIr065Jtz6ZpBgKBt95916r0y71HAOASu774 IhQKSe2CRWDA01wxGQXQw0T6jUSjsqcj7RMTl3Q6/eqbb1rVoK7rIv1y7xEAuEGx WDx+5IjsRWBFUQosAgPeRAAGIJF7rvltEWH11ttue/7FF61qUMTpiYmJarVqVYMA gC599eWXQckBmEVgwLsIwACkcFu9K8HQ9bvvueeJp56ysM18Pl8oFCxsEADQJRFN jxw8yCIwgHkRgAFYz231rvqadxQ98uij69avt7DNSqUyMTFhYYMAAEvs2blT9uYj FoEBjyIAA7BSIpEINdZ9Iy6pd9Wi1usvvPTSbStWWNhmvV4fGxsTEyAL2wQAWKJa qRzav78/GJTai1KtsgkI8BwXzVABeF0qnRbRNyh5wrFQIqm++fbbmcFBC9tsp/CV yMau+ikAAPjKnl27ApLfhA3DKM/Nlctlqb0AsBaTMwAWSCaTIvdGXHPRUYuIoGJ2 8s7778diMWubzWaziqLc+DGueikAwG8ai8AHDsg+jCN6KRaLUrsAYC3mZwC6lUql RPR128Jv47qjTObVN96wvOXp6elSqWR5swAAa9lwEljXdZGBOQkMeAgBGEDnkslk fzAYddnCb19zRrJq1aonnn7a8pYLhUKesp8A4AWVcvnwN9/IXgSuVCqzLAID3uGu OSsAD0mmUpFIJBQKOT2Qq6mq+uSWLavXrLG85bm5uampKcubBQBIsvvLL2UHYE3T lGqVRWDAKwjAABbMtQu/fc2SV6+//fagpSWvWqrV6sTEBGWfAcBD7LkTuFIuz87O Su0CgFVcN3kF4HKpVCrsyoXfRt2pvr63338/EolY3nitVhsfHyf9AoDnfPXll0HJ AVit13O5nNQuAFiFAAygXW5e+NV1fcUddzzz/PMyGldVdWxszDAMGY0DAKQqlUrf HjokexG4XC6XWAQGvMB1s1gA7uTahd++ZkB96qc/XbV6tYzGNU0bHx+/8ZW/AAA3 +2rHDtlXFdRrtZmZGaldALAEARjATbh54dc0TV3X39q6NZlKyWhfNC7SrwjYMhoH ANijWCweP3JE6iKw+H5ULpfnuCQPcD3XTWcBuEqqWeo56MqFX5FOBwcHX5Fw0+/l 9km/ANAbdn3xhexNTIqiFLgnD3A9AjCA+SWTyWAwGHHlwm9fc2fyQxs2PPDQQ5La F+k3m83W63VJ7ctmGEYgEHB6FADgFvlc7vvjx6UuAos33kq5zH1IgMu5cV4LwHGp dLqx8Cv5xFTHRC595fXXlyxdKql9r6dfAMC1dm7fHg6HpXZRrVaLhYLULgB0iQAM 4B8kEolQOCzSrzsXfk3T7O/vf3PrVhl3HbWw8xkAelJ2bOzCuXNSv7uJ7yDVSoVF YMDN3DjBBeCUVDodjUZl3xXRMU3T1j/wwIZHHpHaRTabJf0CQE+yYRG4UqnMFotS uwDQDQIwgIZkMhkKhcJuXfjta257fv3NNweHhuR1IXKvSL/ceAQAverCuXPZsTGp 3+nEt5Lc9LS89gF0yaUzXQB2SqfTERcv/Oq6nkgkfvH66/K2Pfc1A7ZIv6IveV0A ABxnwyJweW6uxH1IgFsRgAFfayz8Nk/8Oj2Q61JV9bEnnrj3vvuk9qIoysTEhGEY UnsBADju6KFD1UpFahe1Wi0/MyO1CwAdIwAD/pXOZKLRqGsvyzFN09D1N7duTaZS UjuqVCqTk5OiO6m9AADcQFXVr7/6SuqdwOIbSuM2JEphAa5EAAb8KJlMhiMR2XvA uqHr+oo77njm+edldzQ7O5vL5WT3AgBwjwNff61LLvegVKsF7kMCXIkADPiLiL6B /n43L/z2NY/jvvSLXyy/9VapvZimmc/ni9TqBACfqddq+/fulXrXvWEY5bm5crks rwsAnSEAAz6STKUi4XDI3Qu/sXj81TfekH0sWUxNpqene2xqIiK9a4t4A4Cr7P3q K9lvl9yHBLgTUyXAF5LJZH9/f8TdC79qvf7Eli33rF0ruyNN0yYmJur1uuyOAADu VK1UDh04IPX6A/G9ZnpqSl77ADpDAAZ6XyqVCkciUgt+dKlVgOrNd96JJxKy+1IU ZXJysveuO2L5FwAWZNcXX8j+zlgul0uzs1K7ALBQzJaAXtZY+A0Go9Gom6ORpmn3 /eQnmx57zIa+SqVSLpej4DMAIDc9ffrECanfH7kPCXAh986JAXQplUpFIpGguxd+ dU17/a23MoODNvQ1MzMzy0/iAQA/2vn552GZJSe4DwlwIQIw0IMSiUQoFIq4fuH3 7lWrnvrpT23oS9f1qamparVqQ18AAK84f/bsxPi41O+V4ltPkfuQADdx7+QYQGdS 6XRj4Vfm7Q5dMk3z/2fvTvyjKvL9/2frpJfT3QlJAFEEkUV2FAUX3K86Ojqj39Fx HHXuvfNf3u/j+xNRcRmVJRAIm8oSIEknnfR+tj6/SnqGy7CEdPf5VJ/T/Xo+vFwm pKsOJDmn3l1Vn1Lp990//GFoeFhDd5ZlTU1NOcJHPgIAwujrw4f7JQ9HcF23XCox CQwEBwEYaB+LE7/9/Sr9BnniVw0FHlm//uXXXtPTnRpzZDKZNt70S+0rAGjGzz/8 IP0OaalYZAMOEBwMm4A2EY6JX9t+6/e/X71mjYbuqtXq3NxcPp/X0BcAIKTMSuWn H34QfXpaljU3OyvXPoC6EICB0DMMoy8SCf7E75q1a//jrbf0dGfb9vT0NCf9AgAe 6LuvvuqRPBB4sRRWsVjgDVkgGII7XAawEslUKhqN9ko+uZtUm/h94+231z70kJ4e 1ThjZmamjZc9AwB8lF9YOHXypOiTtFKpzGezcu0DWDkCMBBWhmFEIpH+wE/8rl23 7vU33tDTnQq9s7Ozbb/smX2/AOCvb778MiJ5amC1Wi0WCsViUa4LACvEEAoIpXBM /DrOW++8o2fHbxfLngEAjbo+OXnl119F31sslUq5hQW59gGsEAEYCJmw7Ph9+JFH Xnn9dW095vP52dlZlj0DABrz9Rdf9A8MyLVv2/ZsJiPXPoAVCu4AGsDdwjLx+/a7 746MjurpUYXtTCZTKpX0dAcAaEvHfvzRFl5DVCwU2n6TDhB8BGAgHEJxxq+Kvo9u 2PDSq69q67FcLs/MzKgMrK1HAEBbskzzx++/Fz0PiVJYQBAEdyQN4JZQnPGrUujv 33tvaHhYW49zc3O5XE5PdwCAtvftkSO9ko9aSmEBQUAABgJtccdvX99ANBrwid8t W7cefP55bT1aljU9PW3btrYeAQBtLzs7O3HmTE9Pj1wXlMICWi64Q2oAyWRSRd+A T/xWq9X3PvgglUpp63FhYWF+fp56VwAA31EKC2h7BGAgiAzD6O3riwZ74lc9xXft 2fPk/v3aerQsK5PJmKaprUcAQEcZHxsrCNepohQW0FrBHVsDHUul3/6Bgf7+/lZf yH1Vq9Wenp53339fXaqeHj3Py+Vy2WyWiV8AgBzbtn84ejQSich1QSksoLUIwECw pFKpaCwmugGpSZZlPXPw4PadO7X1qIYjMzMzTPwCADT4/uhR0fFxtVotFYuFQkGy EwD3RQAGgsIwjNpBR62+kPtyXVdd4Xvvvx+LxfT06HlePp+fm5tj4hcAoEexWDz5 88+9vb1yXagAzCkGQKsQgIFASKZS0WhU9HHbJMuyXnjppcc3b9bWo23bmUymUqlo 6xEAAOWbw4cjkhuR1CN1bnZWrn0AyyAAAy0W/HpX1Wo1Gov9/g9/0DY7TalnAEAL TV69evXyZbnnsnq6La6BZhU00AoBHXADHUKlX5UqRd9mbpJlWa++/vr6DRu09Wia ZiaTUf1q6xEAgDt8ffiwaDXKSrk8Pz8v1z6A+yEAAy2TTKViAa535bquusK33nlH 58RvNptdWFjQ0x0AAPfzj2+/FV2FpB6y5VKJSWBAPwIw0AKGYfRFIipYBnPZs3rk O7b95jvvrFm7VlunlUolk8nYtq2tRwAA7qdULJ4QLoVVLBbzlMICtAvi4Btob0Yy ubjsWfKMwWa4rvvw+vWvvPaath6r1erc3Fw+n9fWIwAADyS9Cto0zezcnFz7AO6J AAxolUqno9FoMJc9e56n0u/b7747PDKirdNisTg7O6v61dYjAAArce7MmflsVq59 DgQGWoIADGhSW/as0m+rL+TeHMfZtHnz84cO6exRRd9SqaStRwAAVs627R+OHhVd saUegjkqXwB6EYABHRarPUejwVz27Hle1XXf/eMf00ND2nrM5XLZbJZTjgAAQfb9 0aOiY2XbsmY5EBjQiwAMiAtytWfHtrdt3/7Ms89q65FTjgAAYZHP508dPy5XCosD gQH9CMCAIMMwevv6otFoAKs9L078VqvvffBBKpXS06Pqbn5+nlOOAAAh8tUXX4ge B1gulxc4EBjQKHCDcqBtqPTbr+g6RLcutm3v3L37qaef1tZjqVSanZ11HEdbjwAA NG98bKwgeU6BejJWymUmgQFtCMCACCOZjEajfX19rb6QO3lL/vDBB+oK9fRIsSsA QHhpKIXFgcCATgRgwH+B3fSrnuJ79u7d+9RTerqj2BUAoA1899VXPWLbgBWzUslK nrcE4HYEYMBn6cHBAG769ZYy6OLEr2Ho6ZFiVwCA9jA3O3v+7Fm5J3u1Wi0WCsVi Uah9ALcL1hgdCDWVLSOLe34Dt+nXtu1de/Y8uX+/nu7UgzybzeZYzQUAaBfSpbA4 EBjQhgAM+COYJ/3qL/VcLBZnZ2dd19XTHQAAGvz0ww+uZB1Hy7LmOBAY0IIADPgg mUwOBK/kleM4W7dtO/Dcc9q6o9gVAKAtVUqlYz/9xIHAQBsgAAPNCmDJK/UcdV33 vT/+MT00pKc7il0BANrb14cP9/f3y7VfLpUWWAUNyCMAA01JpdMq/Qaq5JXjOJs2 b37+0CE93VHsCgDQCSbGxxfm5+Xat217NpORax9ATYBG7UDoBLDgs21Zb7/33sjo qIa+KHYFAOgc0gcCswoa0CNAA3cgRAzD6ItEVPpt9YX8r6rrGqnUW++8o6cMNcWu AACd5tsjR3ol632Uy2XRSWYAXQRgoAGJREKFzP4gHXdkWdbLr722YeNGDX1R7AoA 0JkyMzMXz52TW/mlnrCqC6HGAdQQgIH6BO24I9d11cX88U9/0jDx63lePp+fm5uj 2BUAoDNJl8IqFgrqUSvXPgACMFAHlX6jsVhwjjuybfvJ/ft37dmjoS/LsjKZjGma GvoCACCYfvz++6rk9p9KuTzPKmhAEgEYWKlApV/P89QD+I9/+pORTGroa36JdEcA AARcqVg88fPPcgcCu65bLpUohQXIIQADK6JyZiwWk3vg1UU9HR9at+61N97Q0Fel UslkMrZta+gLAIDgE18FXSzmOWEBEEMABh4smUxGA5N+tdW74pQjAADuNnbsWLlc lmu/UqnMZ7Ny7QMdjgAMPIBKv7F4vKenp9UX0lUrPfX+hx/GYjHpvtSjPZPJOI4j 3REAAOFimeZPP/wg97Z4tVotFYusggaEEICB5SRTKZU2g5B+XdfdtHnzcy+8oKGj ubk5nrsAANzPN4cPR1gFDYQTARi4r+CkX8uy3nrnnTVr10p3pJ64s7OzrmR9SwAA wu7s6dO5hQW59s1KJcsqaEAGARi4t4CkX8/z1E/pB3/+s/Qxvyr0quirArBoLwAA tAHbtv/x7bdyB0OwChqQQwAG7iEg6VeF0o2PPfbCSy9Jd8TELwAAdfnmyy8jkYhc +6yCBoQQgIE7BaTqlW1Zr7z++voNG0R7YeIXAIAGTF69evXy5e5uqbE0q6ABIQRg 4N8EIf16nqdy6fsffmgYhmhHpVIpk8kw8QsAQANEJ4FZBQ0IIQAD/ysI6VfF0aFV q9557z3pXij1DABAM7776qsescOQulgFDcggAAP/FJD0u2379qcPHBDtpVwuz8zM MPELAEAzMtPTF8+fl1sFXalU5lkFDfiNAAwsMlT6jcXkDrVfCdu2X3ntNdFNv57n ZbPZBcmTGwAA6BxfHz7cL3YgcNV1S6USy7UAfxGAgS7DMGLxeGvTr2VZ73/4YSqV Eu1iZmZG/SrXBQAAHeX7o0dFB9OsggZ8RwBGp1PpNxqLyR3l90Ce56lf/4/kSb+q i3w+Pzc3V+sLAAD4YiGbPTs+zipoIEQIwOhoiURCpV/Rc/yW57ru6Ojom++8I9rF zMxMuVyW6wIAgI7FKmggXAjA6FyGYfQPDMg9tB5IRdOt27Y98+yzcl2op6ZKv9Vq Va4LAAA6GauggXAhAKNDqfQb6e+XW3X8QI7jHHzuuS3btgm1T70rAAA0YBU0EC4E YHSowaGhaDTaqt5ty3rj7bfXPvSQUPsqXU9PT5umKdQ+AAC4RXQVtOu6ZVZBA/4h AKMTpdPpWDzeqt4ty/rjBx+kh4aE2mfZMwAAOomvgi4U8vm8ZA9AByEAo+OkUimV fuWWKi1Ppd8PP/44nkhINM6yZwAA9BNfBV0uz8/PCzUOdBoCMDpLMplU6benp6cl vTuO89EnnwhtPGbZM9BOzErlyuXLC/PzTx882OprAfBgoqug1SM+MzMj1DjQaQjA 6CCGYaj029vbq79r6cN+K5XK1NQUy56B9qDS74/ff69uVurW0d3d/dyLL7b6igA8 AKuggbAgAKNTqPQbjcX6+vr0d62GsNFo9IOPPhJqP5fLzc7OCjUOQDPXdX/87jv1 m9pySvU/e3p6nj10qNXXBWA50qugy+XyAqugAT8QgNERVPodGBiItOLIX5V+jWTy vfffl2i8Wq2q6EtlSKBtzM/NXb1yJZ/L3b5WRWVg9T8PvvBCCy8MwAOJroK2bXs2 kxFqHOgoBGB0hFYdeqTS79DQ0O/efVeiccdxpqamLMuSaByATrl/TexklwJwJBK5 4xNUBn74kUc2bNqk/dIArJToKmg1oigWCrzlDTSPAIz2l0qn46049Eg9q1avWfP6 m29KNF6pVKanp9WYWKJxANrkblvTaNv2+KlT96wUoO4njuMcfOGFu7MxgIDIZrPn RFdBl0oc9AA0jwCMNpdMpeKtOPRoMf2uXfv6G29INM6mX6AN5O7aznd6bKynp+d+ 96taBj70yiviVwagUaKroC3LmuPpDzSNAIx2ZhhGPJHQf+iRXPrlpF+gDdwdfZWJ M2dUvl2+TL3ruuseeWQjC6GBoPru66/lRh2sggZ8QQBG20okErF4XH/ZZ/V8Gh4Z efPtt31vuVqtZjKZYrHoe8sA9Lhn9FU/2ir9ql9XckibY9svMAkMBNXUzZu/Xrwo t+6sVCrleBMcaA4BGO3JMIx+RebQ3WXIpV/XdaempkzT9L1lABrcM/rWTE9PZ6an VzhiVjeZZDq9c/du/y4NgJ+++fJLub36ahiQnZsTahzoEARgtKf04GAsFtPcqVzN Z9u2b9686TiO7y0DkLZM9O1aKud+9vTpvhUPl9V9Rt0QXnz1VT8uDYD/jh45Irf6 rFqtlopFVkEDzSAAow21pPCVGpWm0+l3/vAH31uuVCpTU1Pqmed7ywBELR99a04e P15vyZxahflNW7Y0el0ABJ2fmMhKlqoqFov5XE6ufaDtEYDRbhYLX8XjPSvYSucj NR6NRqMffPSR7y2r59zMzIxq3/eWAYhaSfqdzWSmbt6s99262iTwoVde0V/fHsAD qR/Pf3z7rdwkcKVSmc9mhRoHOgHPTrQVlX4HolH952RWq9W//u1vvjfLcUdAGK0k +taMnTjR2P1K3XOe2L59aGSkgdcCkPbN4cMRscOQHMfJzMwINQ50AgIw2srg0FA0 GtXcqW3bf/7rXwf8Lrg1Pz+f5S1eIFRWHn2Vs+Pjnuc1NourXtjT2/v0wYP6j3kD 8ECnT54sSm7TVY3n83m59oH2RgBG+0il0/F4XHOnlmV99Mkn/hbc4rBfIIzqSr+m aV44d24l5x7dk7pLOI6zecuWtQ8/3FgLAORYpvnTDz80/AP+QOVyeaGeGw6A2xGA 0SaSyWQsHtc8GaLS7//56CMjmfSxTTWunZ2d5Z1dIETqir41J44da37ZSCQS2fPU U/pPOwfwQF8fPlxvfbuVsy2LHVJAwwjAaAeGYUSj0ZWfI+IL27bf/cMfhoaHfWxT pd+ZmZlisehjmwBENZB+r16+nM/nmy9hpe5CT+7fHzcMqmEBQXP8p58s0xRqXI0W Fo9C4jAkoCE8MtEO9G/9dR3nxVdeeXTjRh/brFar09PT5XLZxzYBiGog/XY1Ufvq DqZp7nvqqVg8LlduB0BjyqWSysByq6BLpVKOrVJAQwjACL1UKhVPJHT26Lrunn37 du/d62ObKv1OTU1VKhUf2wQgp7Hoa9v22fHxvr4+X+ZsVWu79uxRrSWSSSaBgaD5 6osvfC+QeYtpmtm5OaHGgfbG8xLhtnjqbyKhc+uv53mPPProiy+/7GObpF8gXBpL v8qpEyd83KxRC8DqBsgkMBBA3x89KjfOViOHUrHIKmigAQRghJj+U39V+k0PDr7z 3ns+tkn6BcKl4fRbKZd/uXTJx6lax3ESicSmzZt7ensT7AQGAmY2k7kwMSH3g1ks FvO5nFDjQBvjYYkQGxwcjPp6/tADVT3vr59/7meDpF8gVBpOvyqsjp865W9VWNd1 4/G4CsDq9/FEQnMhQAAP9M2XX8q9TV8pl+c5DAmoHwEYYZVMpdTIT+eMh2VZH3/6 qY/7eVT6vXnzpilWJRKAjxqOvjUXL1ywLcuvi6nxPC8ajdYCcF9fX9ww/G0fQJOO Hjkid1CZY9uZTEaocaCNEYARSoZhxOJxueKKd1s89Oj994eGhvxqkPQLhEiT6bdY KPz6yy++37JuD8CKkUz2aLwrAnigifHxBbFJWg5DAhpDAEYoDa1aJVdZ8W6u6z53 6NCmxx/3q0HSLxAiTaZfx3FOj41J3LLuCMD9AwOad4UAWJ5t2z9+9x2HIQGBQgBG +KTS6Xg8rq07NcR8bNOmZ194wccGVfpl3y8QCk2mX+XCuXMqA/tyMXe4fQ+w0t3d baRSlMICAuXrw4f93fx/Ow5DAhrAYxIho/ncIxVWk8nku++/72OD09PTpVLJrwYB yGk+/arhqQrAQvM/tm3v2bfv9o9QCgsImp//8Q/HtoUa5zAkoAEEYITJ4rlHAwM6 j7t0HOez//ovv1pT6XdmZqZYLPrVIAA5zadfZezECbkasCpd73vqqds/ovqKJRJC 3QFogHron/z5Z7lV0Cr+5vN5ocaBtkQARpikBwdjGne42Zb1wUcfGcmkXw1mMhme UkAo+JJ+c7nctStX5NYkW6a5998DMKuggQD6+osv+sUKl5TLZbk6W0Bb4hmJ0FBB NJFIaBvYua77wksvbXzsMb8anJubW6BSBRAGvqRf5eSxY3KjXqWnp2fb9u13fDBu GHLHrgBowHfffNMjNnqxbXuWw5CAehCAEQ6Li5+jUbmVhHfwPO/h9etfeuUVvxqc n5/PZrN+tQZAjl/pN5/LXZWc/nVd9/EtW+5eFEMtaCBopm7e/PXiRaG7AYchAfUi ACMcNC9+Vo+TTz7/3K/Wcrnc7OysX60BkONX+nUc58ypU6IFC+7eAFzT09vr48YN AL745siRiNjSDA5DAupCAEYIJJPJuMbFz5ZlffTJJ37l7WKxOD097UtTAET5mH7P jo9Lr0NW6Xrzli33/KNkOs02YCBQvvnyS8F6eJUKq8yAleMBiaAzDCMai2nb0uY6 zhtvv716zRpfWqtUKjdv3vQ8z5fWAMjxK/0qhXz+yuXLohHUtu0du3bd78bIYUhA 0Bz/6SfLNIUad123XCqxChpYIQIwgm5wcFDbfjaVVDdt3nzwued8ac2yrBs3blSr VV9aAyDHx/SrnDh2bECy9lXN9p077/dHA9Go+k/6AgCsXKlYPMFhSEAwEIARaJoX Pyt/+ewzX9pxHEelX/WrL60BEOVjAL508aJZqbRw+lfpi0TinAYMBMzXhw/3i9UF 4DAkYOUIwAguzZWffdz6W61Wr1+/rgapzTcFQJqP6Xd+fv7alStykzw16q64eevW ZT6hp6fHSKVErwFAvb776qsesZuDGsPMUW4TWBkCMIJLZ+Vn13Vfff31dY880tjL Hce5NRvjed7NmzcrlYp/VwdAio/pV90Hxk+dkpvhqbFMc+eePQ8si0AdLCBoLpw/ PzczI9R4tVotFYtsAwZWgqcjAkrn4mcVWddv2HDopZcaeO3t0bfW1MzMTLFY9O/q AEjxd+vvqRMnpEtPqTvMyOpFD/xMI5Xq6ekRvRgAdbFt+x/ffitX1FONPfK5nFDj QDshACOINC9+dl330//8z3pfdUf0rclms/NswgHCwN/0e31ycj6blX7P7n5n/94t YRi9uornA1ghtgEDQUAARhCl0+lYPK6nL9u2P/joIxW563rVPdNvoVCYEVvdBMBH /qbfSrl84fx56dPaPM/buHFjfGU3K05CAgLopx9+cMWqY6rxzGwmI9Q40E4IwAgc lUXV0E3P4j3XdZ96+ullThNZubqO/FWfxvY8oFX8Tb9dus49Wvn0rxKLxyPCu5EB 1Cufz4+fPCk0AFBDi8VNwGwDBh6EITgCZ9XwsHQVmVv6+vo+/Mtfmm/Htu3r169z 5C8QfL6n3wvnzqk7gPRbWq7rPrphQyqdXuHnR2OxfvlMDqBeoqug2QYMrAQBGMGi hndxXYufLcv6+NNPVz5vo/LtPeelOfQICAvf0+/c3Nz1a9ekzz2qqWutCgEYCKaj R47IbZeoVCrz2axQ40DbIAAjQAzDiMXjeoaSTZ57dIvneVNTU+VyubHXshAa0Mb3 9Gvb9tnxcQ3l+lRHGx97bOXTv10EYCCoxk+elFul7DhOhlokwIMw+EaADA0NDUSj GjpSyXN09er/eOutlb/knlWvlEwmk8/n/bs0ACJ8T7/KyePHNezXUPereCKhAnBd ryIAA8FkVio//+MfQu/1sw0YWAkCMIIimUrF43E9M6K2ZX3+9783304ul5udnW2+ HQCiJNLvpYsX1UBWwy3LNM2tTzxR794QAjAQWF9/8YXcj2epVMotLAg1DrQHAjAC wTAMNVyTPkSkxnXdN373u9Vr1jTZTqVSuXHjhi+XBECORPpV48trV69qSL+e56XS 6UfWr6/3hVSBBgLru6++6hHb7WVWKlm2AQPLIgAjENKDg7FYTENHajT50MMPv/La ayv8/PutfFYfn5yc9KXs8/1qawFonkT6tW373NmzeqoVWJb1xPbtDewNiRuGnrcU AdTr/MREVmz5mOu6M9PTQo0D7YEAjNYzkslEIqFp8bNtf/7f/91kIyqy3rhxQw1M fbkkAEIk0q/jOOOnTuk5qk31NTo6unbdugZem0gm9UR0APVSQ5F/fPut3FtUhXye bcDAMgjAaDHDMAYGBvQs1VOjyd+/997Q8PBKPnmZidnp6elisejrpQHwmVD6PT02 tvKz05pU9bztO3Y0tkLESKVYWgIEluhpwGwDBpZHAEaLaTv41/O8hx955KVXX22y nfn5eXbXAAHXBunXsqxH1q8fHhlp4LXd3d3Jes5MAqDZD0ePyjVummZ2bk6ufSDs CMBoJcMw4omEnmmKuhY/32/rb6lUmpqa8vW6APhMKP1OnDmjbVGx53mxWOyxxx9v 7OXqOhPJpL+XBMBH01NTv1y4ILT5i23AwPIIwGglbQf/qofBm++8Mzo62kwjKkJf v3694cJXV3777cbkpIrQt38wHo8PDQ8/8uijeqbBgbbXBum3q4naVzWR/v4YtxQg 2L758stIJCLUONuAgWUQgNEy2g7+9Txv9dq1r7/xRjONNFP46vhPP2VnZ72urt6e nu5/n+72qlW3WlWPwM3btq17+OFmrhCARPpVfrl0yaxUJFq+J9u2R1evfqih2lc1 HAIMBB/bgIFWIQCjNRYP/o1G+8Te+7ydbVmf//3vTTYyMzPTwJup0zdvnjt71nXd B+R8z1Ofk0qnH9+6dWjVqsavEuhUQtHXcZyFbPbGjRt6pn89z1O/9vX1bX3iiWba SRhGL2cgAcH20w8/uI4j1DinAQPLIACjNdLptJ4VeipYvvbGG83MpSi5XG62ziP7 bNv+5vBh9ZvFHc4rnOX2PMd19+3f31jZG6BjCaVf5cbk5LxY43dT96tIJPLoxo1N noueTKf1HCwHoGEqoJ4bH5faBuw4MzMzEi0DbYAHJFpAZ+2raDT6/ocfrvCT71n7 yjTNGzdu1GZmVmj65s3xsbGe+qeMvGpVPQs3bdmyfsOGel8LdCa59DubyVyfnJQ7 q/NulmnufeqpJhvp7etLGIYv1wNAFNuAgZYgAKMFhlat0nOUiBpNfvzZZ8305bru 9evXnXoWKV357beL5841vP6wp6fHdZx4InHg+ecbawHoEHLRt0v7oUddS8tGtm3f 3nyPA9GonuKCAJrENmCgJQjA0C2ZSiUSCQ0dqez67PPPP75lywo/v1qt3jEp7Xne 1NRUuVxeeac/ff99LpdrfruguvhNmzdv3LSpyXaAdiWaflUWHT91Smf6VT/yo6tX r1m7tvmm2AAMhIUaM6iffaHG2QYM3A8BGFot1r6KxfQsKezu7v7400+baUE9Oera /nfi55+zc3N+Le2uuu6rb77pS1NAOxGNvjUnjx3TXEXZq1Z37N7dfDvqvmekUmwA BkJhbnb2/NmzQj+wjuNk2AYM3AvPSGg1ODQU1bI2z7btP/35z/EmpprL5fLNmzfr 6vHbr75quLu7VavVhGEceO45H9sEwk5H+j1+PBKJ6MyQlmnu3LPHl3cGOQEYCJej R47IzQqwDRi4JwIw9NG2+NnzvO07d+5ropaM4ziTk5Mqgq7w86du3Dg9Nub7M0z9 RXbt2TOyerW/zQJhpCH6qh/8s6dP9/b16Uy/qtPHt2yJ+5Ra44mEnuPlAPhCdhtw sZjL5YQaB8KLAAx9Vq9Zo6fys+s4n/7XfzX8chU7b968WalUVv6SL//f/1v8WRIY NKtQ/cLLL/veLBAiGqJvzcXz523b1tNXjY9bf7tY/wyE0D+++85b8bvt9VIjmXm2 AQN34TEJTbQtfnYc5/d//OPQ0FDDLdS79ffH778v5HINHHq0Euqv8/pbb0m0DISC tvT72y+/lEolnenR87xIJLJl2za/GuwfGIg2d4AwAM1mM5kLExNCdx7btlX7Ei0D oUYAhg6GYSQMQ8/IMpVOv/Peew2/vN6tvz99/31epd+eHv+nfz1PtVmtVh/dsOHx rVt9bhwIPG3RV7l08WK5VGq+fntd1Nh0z759PjaYSCY1/xUANE/uNGDP8wr5fLFY lGgcCC8CMHTQNv1rWdbHn37a8OEl9W79Pf7TTwvZbLfwum71AHvlP/5DtAsgUHRG X2Xy2rWF+XnNK4dN09y5e7ePo14VfVUA9qs1ANqIbgNW6TfPNmDg3xGAIS6ZTMYT CQ2DS9d1X3z55Uc3bmzs5fVu/R07fjw7Oyux7/ffeF5fJMI2YHQIzdFXuXb1am5h QXP6tW17y7ZtMV+XK8fi8YjYGBqAHNFtwOVyeUH7fRUIOAIwxK0aHpZ7a/N2Pb29 f/7kk4ZfXtfWXzV+/ebwYaF9v//G89TQ/KXXXxfvCGgp/dG3q0Xp13XddevWrRoZ 8bFNyl8B4TU9NfXLhQtCP7+WZc3Nzkq0DIQXD0vISqVSzRzGu3IqkX74l780PKNS 79bfr7/4oup5jfVVr6rr7n7yyZHRUT3dAZq1JPoqV377LZ/P6ylNf4tKv4NDQ4+s X+9vswPR6ICWbSYAJBz98kuhA8yq1WqpWOQ0YOB2BGAIMgwjGovJnfB+i+d5W7Zt e/rAgcZeroakk5OT6tcVfv7szMypEyekt/7eogLwnqeeGvZ1vghouVbl3hqVftWI UPOUqe9ln28xUinNSR6Aj2S3ARcK+XxeqHEgjAjAEJQeHPR3k9v9OI7zWRMH/05N TZVKpZV//hf/8z+98ql+Ua0QtOuuW79+2/btOnoE5LU2+na1Lv16XV07d+3yvWVO PwLC7rtvvukRuyOVS6WFhQWhxoEwIgBDimEY8URCw6SE67pv/O53q9esaezluVxu tp7tMafHxmanp8VrX92mWq1u27Fj3cMPa+sRENLy6Kv8+ssvZb3n/dZYlrX3yScl Wmb6Fwi7CxMTcjt1TdPMzs0JNQ6EEQEYUgYHB/VMSgwMDHzw0UeNvVYNSa9fv+6t eDevvtpXt3Ec5/W33tLZI+C7IETfrqX0WywU9B+Wa5nmzj17JPaDRPr7Y/G4780C 0EndIn764QehW5PrujPT0xItAyFFAIYIbdO/zRz8W61WVfpVmXblLzl65IiKow30 1TjPWzUysnvfPq2dAj4JSO6t+eXSpUq53IK5X9N8YufOhs8nXx7Tv0B7EN0GXMjn qYMF3EIAhojBoaGofElSz/N27927a8+exl6eyWTuKAuhIvEyQ8mWTP+6rvvam2/q 7BFoUqBC7y0XL1xQQVR/+rUta+sTTwgth2H3L9A2jh45Ilc0tFQq5dgGDPwLARj+ 07f713E+bbT2VbFYnK5zRdDP//hHQXMdRc9To9uDL7ygtVOgTsFMvLe7cO6cbdst SL+2vXnz5rhhSDTO2b9AOxk7frxcTz3OulQqlflsVqhxIHR4cMJ/enb/ep73u3ff HRoaauC1juNMTk5Wq9W6XvXF//2/mrcOVl334KFDcTb4IXiCH3pvmThzRv2w6w+K 6j6z4bHHUqmUUPsDsZjQsmoA+pWKRZWBhe5Utm3PZjISLQNhRACGz7RN/6oR7V// 9rcGXqiS882bNyuVSteD1jzfQXcA9rw1Dz30xM6d+noE7i9Eifd246dOdS/R3K9K v4+sXz+0apVQ++rGlUgmmf4F2sk3X34ZiUQkWlYjn2KhwDZgoIZnJ3ym5+xf13U/ /MtfGpv9WFhYmKv/PADTNL/76qtubcVmPC8Wjx94/nlN3QH3EtLQe8vJ48fVaLIl 6Xfdww8Pj4zIdRFPJPpkBsoAWuWbw4cjYnWwVADOa97GBQQVARh+MgxDpd9esSoO NZ7nPbZp07MN7Yyt99yjrn/NEs/Nzp46caKBHuujLkwN1qn8jBYJe+K93dkzZ7wW rXxe+9BDo6tXy3Whoq8KwHLtA2iJn374wRU7aaJcKi1QBwtYQgCGn5KpVEJ+WKbG l581VPtK5d7Jycm6zj26ZT6bPXnsWAMvrJvnJQzj6Wef1dEX0F6ht0bdIsbHxiL9 /frTrxq8jq5Zs2btWtFeOPoIaEtzs7Pnz54VunGZppmtf/kb0JYIwPDTquFhuVPs atTQ9r0PPkin0w28dnZ2NpfLNdavis3fHjnSJTyerrru2nXrtu/aJdoLOlz7Jd7b qVvE2fFxudNEluG67ujq1dLpdyAaHZA/ZA5AS8htA1b3xszMjETLQOgQgOEbwzAS hiE95ZJKp995770GXlgul2/evNlM14f/7/8VPATY89Toefe+faNr1kh1gU7V3on3 dqZpqvTbktrI6ud3ZGRk7bp1or309vbG5W+zAFrl68OHhSYSqIMF3MJDFL5Jp9Mx 4QN7LNP8+LPPGhjdqrHp5OSk+rWZ3uWqQKsLi8fjzx46JNE4OlDnJN7bzc/PX/nt N6HJk+XpSb9KIpnUfBgbAJ2+++orubfai8VivtF1cEA7IQDDN8MjI6JDT8/z9jz5 5M6GlgdPT0+r+36TF/D//c//+L6uslZha9/TTze2qBuo6czEe7vLv/6az+dbEg61 pV8WPwNtb3xsrCBWq7lcLi90/MMC6CIAwy9GMmkYhmgXDde+KhQKM37se/FnCXSt zrP6/yr7et7mrVsf3bix+WtDpyHx3mLb9plTp1pS8qpLV9WrLhY/A52hUiqdOHZM 6Cfdsqy52VmJloFw4VEKf0ivf3Zd9+VXX33k0UfrfaGKzZOTkypsNn8Nk1evXjx/ vvHX/yv6di0Vu1q/YcPmbduavyp0CBLvPZXL5fMTE9K19+5H3V5Wa0m/XSx+BjqG XB0sNRYqFYtsAwYIwPCHdP1nFYA//c//rPdVnudNTU2pIbIv12Db9tEvv+xu7vQR r1pVo9g9+/ez5hnLI/EuT4XPK5cvq6FcSwo+d2k57/eWaCzW34rKXgD0k6uD1bW0 Jk5uiTUQFgRg+MAwjHgiIXcupUq///HWWw1Ms+RyuVlfV/t8e+SIXe8h9bcmfpfq PG/fteuhhx/28ZLQHoi7dSmVShcmJlqYCVX6fWjdupHRUQ19qYQfSyRY/Ax0iH98 +62nRg4y1M0zt7Ag1DgQFjxQ4YNkKpVIJOTadx3n0/p3/9q2PTk56e9TZHZm5vTJ kw2cBlx13ZHVq3fv2+fjxSCkyLrNUMnzt19+qVQqLVwPrK5h3cMPD4+MaOhL5V4j mWxy4QmAEPnl4sWZqSmhxtXNcz6bFWocCAsCMHyQHhyMxWJCjasEe+ill9Zv2FDv q27cuGGapu/XU18pLM9zq9VUOv3Ypk3DWiaLEChkXR+p2Hnp4sVyqdSSY35vv4yH 169ftWqVnu7ihtGqNd4AWsK27R+/+07oPT7bsvxdGQeEEQEYPlBjQbm1iOpJ8Pl/ /3e9r8pms/My2ePrw4dXVFJrKfqqgfK27dslLgNBQ9YVNXn1aiaTaVWxq1vU7Wjj xo2pwUE93XHuEdCZ5LYBUwcL6CIAwxejq1fLLUdcvXr1a2++WddLTNO8fv260PWo EfA3X3557w3PS8utXdeN9Pfv2LVrIBaTPhoKLUTi1WMx+s7MtOqUo9upn/1Njz9u JJN6uuuLRGLxeMv/1gD0O3rkiNzSD+pgATxZ0SyV8RJip1M6jvPRJ5/UteLR87zJ yUk1VJW4nprxU6cyd+3PcavVWCy2a9++pK7xMTQj8eq0uNf311+L+XwQom/X0rrB zVu2xHW9pdXT05NIJoPwFweg3/GffrIE9nDVUAcL4OGKZolWwGrg9KO5ubkF+Tv7 lcuX7/jIo3XuUkZYkHs1M03z0oULKgALnYTZAMuytmzbFpc86vwOnPoLdLJsNntu fFzoLTDqYAEEYDQrlU7LjQvXPPTQq6+/vvLPF138jI5C7tVvbm7u6uXLPT09gSr7 ZJnmEzt36qy8FYvHI63e7Qygtb758kuhNwGpgwUQgNEsuRLQrut+8OGH8RVPL2tY /IxOQPTVzDTNXy5eVDkzIKudb6eubbve9EvhKwDKV198IXTnoQ4WEKyhBsJocGgo KjNcsyzrb3//+8o/X8/iZ7Qxoq9OjuNcuXw5t7DQ19cXzOW+Kv3u3L1b50ps1VdM 8kx1AGFBHSxADgEYzRpatUroTUrXcT79r/9a4SdXKpUbN25IXAY6AdFXm1ruzS8s 9PT2Bmqp8x0slX737NF5hb29vXGxgoIAwoU6WIAcHrRo1vDwsNB2tUgk8qePP17J Z1ar1evXr7P4GQ0g+uphmuaV335To66gbfG9m+d5KqXv2LVL53WqfxaVfu99vhqA zkMdLEAOARjNkgvAqXT6nffeW8lnzs7O5nI5iWtAGyP6alAoFFTutSwrsOuc7+At 2bl7t85O1Rg3odJvGP59AGhDHSxACAEYzZILwGsfeuiVFZSAZvEzGkD6lWPb9tXL l/P5vMp1KveGaE2vir49PT1P7NihuV+VfnuDPSsOQD/qYAFCQjMuQWC1NgCrm/jk 5KTjOBIXgLZE9JWgfgZvXL8+n826rhuWyd47qPQbiUS2bNumud94ItEXmBOPAQSH bB2sfJ4AjI5FAEaz5ALwquHhN99+e/nPYfEz6kL69ZEKvTNTU+pn0HUclXhDPYep cnvCMB7btElzv7FEQmeVaQAhIlsHq1hk+ISORQBGs+QCcDQaff/DD5f5BBY/Y+WI vr5YnOmdnJyfn1eJsTfYZZxXTv1dBoeGHlm/XnO/sXhc6OYJoA2I1sEql8sLPBbR qQjAaNaq4eF+mTGc53mffP75/f6Uxc9YOdJvMyqVyrWrV0vFolet9oZzefMyVPod GRlZu26d5n6jsVi/zO4+AG1Drg6WaZrZuTmJloHgIwCjWXLnAFuW9be///1+f8ri Z6wQ6bdetbXN2WzWtu3QFbKqi0q/ax96aGR0VHO/pF8AKyFXB0vd5zMzMxItA8HX nmMa6DQ4NBSNRiVaVnfnjz755J63/nK5fPPmTYlO0U6IviuXW1i4fv26Wamo3/cu afUViVN3mPWPPqruYJr7HYhGB2TumQDajFwdLM/zCvl8sViUaBwIOAIwmpVOp2Px uFDjW7Zu3X/gwB0fZPEzVoL0u7xSqXT92jX1q/qB6unpaeNp3ntSN5DHHn/cMAzN /fYPDERjMc2dAgipn3/4QW60o9JvnpV06EgdNNyBkFQqFU8k5Nr/y2ef3fGRTCaT z+flekQbIP3erZZ4y0uJt7vzEu/tbNvesm1bTHsQZe4XQF0u//rrzevXhRpXj4OF hQWhxoEg69DRD3xkKMmkUONqnPrnv/719lXQLH7G8oi+NY7jzM3OZrNZs1LpzDne +7Eta9uOHULb6pbBvl8A9VKjoB+/+05oT0qlUpnPZiVaBgKOwRCapfJvPJFQw2uh 9tc/+ugLL71U+z2Ln7G8Tk6/apx0c3IyXyiogNfV3d0h+3jrZZrmzt279R+9S/oF 0JivDx8WOmtDPTVmMxmJloGAIwDDB8MjI3IDSnWD/vy//7v2eyo/YxkdlX4dx5mf m5vLZs1yubakWcVdufeh2oNKv7v27NF/djHn/QJomFwAVs+OUrFYKBQkGgeCjAAM H8gVgu5aKlT4wosvPrpxY6VSuXHjhlAvCLu2T7+Vcll9/6uhius4TPDWS91GHMfZ sWtXC9JvIqF/whlA2/j+6FG5wbpKvwWKqqDzEIDhA+k6WGrk+te//Y3Fz7intoy+ i+uZb9zI53LqNyq8sYO3GbV/wCd27NDftbox9pF+ATThzKlTcrWaS8UiC+vQgRhO wQeGYSQMQ250rsavO3btSg0OCrWP8GqP9Os4zszU1EIuZ5mmx3pmX6m7R//AwOYt WzT3q+6HKv32ap9wBtBmVEYdO35caIhVLpcX2uIxCtSFAAx/iG4DVizLevHVV+Xa RxiFN/0W8vkb169XymV3qT5zz1LibfVFtSfLNPc+9ZTmTtUXNG4YvIUBwBffHDkS kXk3zTTN7NycRMtAkBGA4Y/04KDooZqe560aHt66fbtcFwiXEKVfNcK4ef16oVCo reGvxV3WM+uh/s13792rs8fevr54IsHXF4Bf5OpgqTtkZmZGomUgyHhCwx/JZDJh GKJdOLa9/8CBaDwu2gtCIeDpV2XdG5OT5XK5tp6Z7bstpP7lde7+jfT3R2MxvtwA fHT0yBGhAn6e5y2WgaYQNDoMD2n4ZnR0VHrDm+M4L7z8smgXcmzbzi0sFItFs1yu VCq14ka3/lSNmNXjrb+/PxKJxBKJ0dWrqRx7T0GLvup78tqVK+oLV1pSXVrSTOIN DhVHH9u0SU9fA9Fo/8AAX3oA/vrx+++rrivUeHGxDjSFoNFZeE7DN4ODg1HJVdBd S29Vrl23bqOu4WzDKqXS5d9+U3HXXKpptJhuu7vr2uepcpR62nlLEVm9UA2sh4aG 1m/YoIbXolcecIFKvyruXjh3rld9Wfv61BeK2BNMo6OjI6tXa+goGo8LrVEE0MnU 8+XCxITcTl0KQaMDMWKDb4xkMiG/881eWggdC9hC6Eql8suFCwvz847j1OZyJf4d XNdVuVg9DOOGsWXr1mQ67XsXQRaQ9Guapsq96gvBNG/wqR+ZJ3bskD77V30bxBIJ /ScMA+gEtmXlc7mJM2eEaiVSCBodiNEb/DQ8PByRnwNRD4NDAagIraL4pfPnZ2dn q67bu0Rn757nLYbtnp7HNm1a98gjOrtuiSCkXxV9a0MQKjaHhfoh3bNvn2gX6ptB pV8KPgMQUi4W1a1s7MQJoY1RFIJGByIAw0+pdDouPzersp+RSu3as0e6o3uqlEpn xseL+XxvX18QgtA/k3B397YdO0ZGR1t9OSJann7Vv7CKvl1Laae1V4K6WJa198kn 5dqn5BUAUeoRX8jl1K8njx0T2gNFIWh0IB7b8JNhGLF4XENIcF1389atq9eule7o FrNSGT91Kji5927qAWnbdu2wqHYqoNXa9Kv+SRcXPLuudIE3SDBNc5/YIcAq+nb4 nnwA0lQ6LS2VaD514kSfzJOdQtDoQARg+Ez6QOBbbMt6+uBBDaciXZ+c/OXChbpK WLWWymyxeHzPk0+2QQxuYfqtVCoq+qrfsLczvISWQLPpF4AelXLZMk31m3MTE3KF oBfjL4Wg0UkIwPCZYRhxXTviLMt6UWwzsHrknB4bKxYKKkaGcYmj+sdZu27dlm3b Wn0hDWph9FVf9EsXL4boLQ/cj+d5O3bt8rdNNv0C0KaQyy0Wv+zqmrpxY45C0IBP wjesR/BpOA+pRo1u+yKRpw8e9LdZ9SQ4efx41XXDPsNTWxS9dfv2NRrXivuiVelX jQB+vXSJMldtw/dDgPsHBgai0TC+IwYgdNQ45NbEbK0UBYWgAV/wFIf/dE4Cq4w3 tGrVth07fGmtWCiMHTum2mynDZ+u60YikX1PPx2WFdEtSb9qkHHp4kWir35yRyir ljds3JgwDH+a6+6OxeNh+SEC0AbMSkX9d+t/Ugga8AsBGCK07QTuWgp4G5s+CqhU LJ74+eeu9i3za5nmnv3704E/Olh/+i0WChcvXCD6aqZ+bB3bVr92LwVLiS4cx9m9 d68vTfX09sbj8R6+QwBoVMjnb9/3e+LYsQGZwnu2bc9mMhItA8FEAIaIRCIRTyS0 JQo10t2xZ8/Q0FADrzUrFfVQcR2n7fOPChsPPfzwY48/3uoLuS/N6bdUKl08f569 vtrU1uSr70M1pFs822Op6Ojg0FA0GpXozq8KWP39/QOcdQRAL3WTzC8s3P4RuULQ 1Wp1empKomUgmHiiQ4qeM4FvsSzrqQMHVPBe+UvU+Hh8bKyQz3fOskaVPYZWrdru d1kgX+hMv+pLf+7s2a72nfAPjto51e4SlXuLxeIdn7BqeFglTImuLdPc2+QZSN3d sVgsInN5ALAM27LKpdLtH5EtBJ3PcxISOgcBGFIMwxiIRnVmS9M0Dzz//Apnk27e uHH+7Fmh1URBpgKJ+ls/+cwzrb6Qf6Mt/aowduniRatSEXofHV1L32OLK5wdR43V qtXq8oOq0dWrhd6GaHIGmGrPAFqoWCio2+jtH1HjFrmdusViMU8haHQMAjAEJZPJ eCKhc+mgysDPvfji8qm7Uir9/OOP6qo6dvZvsexQT8/B559v9YX8k7b0O3ntWmZm Rmi+scPdmuldSei9xVCSSblLavgMpIFotH9ggGXPAFri7vXPXcKFoEulUu6uHoF2 xdMdsuQ2+N2PbVkHDx26Xwa+MDExffMms3/q4RqNxfbt39/ay9AWfdWj/cK5cyE9 0jmwVNCtTfOqyOutOPTeLplK1bVtoS6xeHzjY4/V+6qenh71wnaqAw8gdNSttXSv O6pcIehKpTKfzUq0DAQQY0HI0lwNq0YNyJ9/6aU7PlgsFI79+CMR6Bb1rzS6Zs2W bdtadQF60q8aRlw4f961bSJN8zzPU3HX+dc0761CVg1Lp9NCJaDVtT32+OP11qKP 9PdHqXcFoNXKpZJtWXd/XK4QtGVZc7OzEi0DAcRjHuKSqVQ8Htc5prx7ie+Fc+cW J36JQP9OZeBNmzevXbdOf9d60u9cJnPlypUO3Onto9o0r1tLvA1N8y5jaGhoICAl oKl3BSAw8gsLaiRz98dPHj8utItH3eczMzMSLQMBRACGDnLD3PtRT47evr5nnn22 Uqn8/MMPvb29zOrck8oJ+w8cEJqFux8N6Vf9vSbGx7s54qh+KujeKtq88t28jRke GRFazldXCei+vr5oPE69KwBBoG6/xXz+nn80fvp0j8xgRo2aioUChaDRIYgE0MEw jMVtdXqjSG25ZtXzOueUo8Y4jvPCyy9r605D+p3LZK5evUqxqxX63/pVS3O8zS9s XiF1W0gYhtA7UysPwNGliV/eIAMQEPdb/6z8eulSpVIR6ncx/t4neANthkc+NNG/ EBorpALPw+vXr9+wQUNf0ulXBbnzExMqyDHxu4z/nePVm3jvkEwmVQAWanwlJaAX DzqKx3v4VgEQJPdb/9y1VNDxt19+ERpKcRISOgdpBPqkBwfrrUkDPSzLevb+pbP9 Ip1+i4XChfPn2fF7t9uXNKu829WixHuHVDodF1t7H08kNmzcuMwncNARgABSN+rl p2FPnTwpVNCkXC4v6DqaAWgtnv3QxzAMFU4oMxNQ3d2iJwNLp9/Lv/6ay+Woc9a1 NPl5a4JXonKVX+RKA6h/gce3bLnfWyE9SxO/rBEAEECVctkyzWU+Qa4OFichoXMQ gKGVysBx1hwGkuM4Tx88KBRIRNOvuvKzp0/39vV15mze4l73pSXNtR3vLVzSXK+R kRGhE7mXKQHdr2JxNNqZ3yoAgm+Z9c81nIQENI9BAHRjM3BgqQypMrC/bUpP/JZK pfMTEx217PnWDl6vdhRvUCd4l5dIJIxkUmcFrMWJ31iM46ABBNZi4f0H7cIdO3FC aL8SJyGhcxBC0AJsBg4m27IO+roTWDr9zmUy165da+8q37USzdV/CWncvVsylVIZ WKhx9S+2e+/e2z/CxC+A4KuUStZ96j/fMnHmzPJTxA1TzS7Mz8tVmQaCg9EAWsAw jEh/f0fN2oWFiiU7du/2pSnp9Hv1yhX1qG6znZy3b9/1glSwynei74KprLvp8cdr v2fiF0BYPHD9c9fSs0/usCLVcls+cYA7EIDRGioDR2MxShYFjWWaL772WvPtSKff 8xMTlmWFPf2Gd/tu84aHh4Xq4al/w02bN0eXdrNT6hlAWDyw/nONaZqXLlzgJCSg GQwL0DIUxAogFcb2HzjQZCks6fQ7fvp092LV6vDdvv65nvlfxxG1zXrmei3+7CcS PT09Eo3XKmBR6hlAuJRLJftB659r5E5CKpVKuYUFiZaBQAnfCBLthIJYARRLJO5X QXclpAs+j586FYlEwvI9U0u8t5Y0d84E7/JENwCbpnnw+eeZ+AUQIurpsDj1urLN vWPHjwutoKmUy/McBYwOwPgALZZKp2OxWOcMVWurXr1/ufXx7qV/gu6eRa3917At 69Crrzb2Wun0e/rUqYEwnCOtvrL2ko6d412e6AZg9fP13IsvCjUOABLUA6604ofF yWPH+mWqqJimmZ2bk2gZCJROSR0IsjYuCn1rAvDWiTXq11KxuMxLFtdtqgy8lIN7 env7+vo0L+N0bPuFV15p4IWi6VeFyXGVfgNfOE19uS3Lch2nuOxXucOtGh7uF3sj Y3DVqm3btws1DgAS1MBAPXxX+Mknjx8XuoWqR+1sJiPRMhAoBGAEwuDQULS5fafB UZv9q1U28mXJazKZVEk4EonoqRmmrnnr9u0qotT1KtKvyr1M+a6E6AnA6ufu6YMH heZGAEDC4vrnenbejp8+3SNzC61Wq9NTUxItA4FCAEYgtMHBSIu517IWZ3tlZv/U P1F3T09/f7+GY28HotF9+/ev/PPFVz6PjQX2e0N93VX0dWw7L3YuRZtJpVJxsQ3A fpUxBwBt1OChXCqt/PMvXbjwwOOCG8ZJSOgEBGAEhQp4KuQI1XUQZdu2szTlq+eZ kUqno9GoUAXdmqrrPvfSSyv8ZPGqV2NjwZzQU9HXNE11hXJHMrYl0eUeruM8//LL Qo0DgIRioaDuXSv//OmpKbmFyupieD8XbY8AjABZzMDRqIYZTl/8c+rPcfQfmmck k7FYTG5v8Mqn0TTUfJbbLNqwarVam/XlbfIGjI6O9oot5lf3kJ179wo1DgC+Uw+U Qp2jCPVwnDhzRmgMUCoWcxwFjHZHAEawqPFrNBbTs9m1YYvR1zTtluafZDIZTySE NlKqv9qhB9XBkj7sVxk7cSJo74YQfZtkJJPqZ1yocdd1nzpwoG2qCQDoBGo4USmX 632V3POxXCotcBQw2h0BGIGjxseLlZD1lj5eodqsr21ZQcg/q1atElob7DjOC8uu I9WQfsdPn+5eOh1KuqMV+ueCZ6Jvc9LptPrpFmpc/Wy+2OgJXgDQEoV8vuq69b5K 7iSkSqUyn81KtAwER1AGl8DtpJf4NkblXiU4e2NS6XRcJkuosLf/4MH7vbusIf2e n5hQITwg6TcIE/5tY3h4WG6f/wPfuAGAQHFdt9jQoELuJCSOAkYnCMT4ErhbMpmM BiYDq0eUWakEbVeM6GrSxzZvXr1mzd0f15B+f/vtt1KhEJD0W5vwD867HqGmvl0T hiH3lU2mUjt27xZqHAB8VymXLdNs4IWnTpzok1kCzVHA6ASBGGIC95RcmgfuaWkG ri18VRFI4mSjJonGCZV+VQa+44Ma0u/N69czmUwQ3vhwHEd96fVXOGtjcmsWujgB GEDYqAFGIZ/3qtUGXnvm9Gm509RnpqclWgaCgwCMQFvMwPG46JE/y1iMQJVKkGf/ RlevFsqKd0+maUi/c3Nzk1evtrwEWrVaVdHXdRzWPPtr1fCwXE1vNgADCBc1xig1 +pT55dIlNT7x93pqVCzP53Kles4lBkKHAIyga0kGDkvFo+GREaE6kHcEYA3pt1go XLp4seVlnxf3eZtmwL/uYSS9/lm1fOD554UaBwDflUsl27Iae63oUcCFfJ6HINob ARghoHk/sOu6lUolFGtf9QRgDenXNM2JM2dae+RvMHd6tw3R+s+e523dvn3V8LBQ +wDgr9pEq/p/jb3ccZzzExNCbykWi8VQDIGAhhGAEQ7a6kLXdvyG5b1PDQFYQ/pV D/LTY2MDLd29aZmmFZ6vexjJfa92rezkagAIDjXSKDe3zFjuKOBSqZTjKGC0NQIw QmPxfGCVgcU2iFar1UqlEq6bvnQA1pB+uySf4isRxq976BjJZCKRkFv/TAAGEC6l YtGx7WZakDsJqVwuL2h5+gOtQgBGmKgMHI3FJIokBb/e1T2Njo4KvSOgAvAj69dL tHyHc2fPuq7bqkOPVHAyTbMQtq976KQHB2OxmFz7HIAEIES8arX5NcYnjx0Tqntf qVTms1mJloGAIAAjZFQGHohG/Z0wVBHIMs0AHnT0QKvXrBEqD5ZKpR6WD8CXf/1V /bO3Kv2qZ3zw65y1gcW1G/G43P4F13Wfee65lpdPA4AVUkOOSrncZCNyAdiyrLnZ WYmWgYAgACN81Hha3fR9WfnjeZ56CC2Ec/lrPB5PplJC6XF09eqR0VGJlm+ZnppS /7XkyF/1dS+Xyyx71kN9lyYSCbn2OQAJQLgU83nXdZts5NTJk0KnBtq2LVdiGggC AjBCSWXgSH9/k2WTFqs9l8uhW/Z8i/pHMJJJiZZVPtyybZvolFoul7v8668tOfK3 Wq2q9EuJS21WrVolNE1RE4vF9jz1lFz7AOCjquv6su9m4uxZr1ptvp27qdHRzPS0 RMtAQBCAEVYq/fVFItFotLGXL27+rFRCvfxVbmJNPfx27dkj0XJNpVI5f/ZspBWH HoX9XY/QkT7+V31B9x84MNDofQAANFNjD/Vf8+1c/u23kszWLc/zFubnK35cJBBM BGCEW2PFddSzxw7/5s9UOh2XOVhV/ePs2bdPouVa4+OnTrXk0CPHcVT6DfvXPVyk y1+x/hlAuBRyuaofM7ezMzPTYvO0hXyeZyXaGAEYoadyoBphr3CKKdSbfu8wODgY lYkWKlTsffJJiZZVBB0fGxNdEHs/bTDnHzrS5a8U1f4eme9VAPCd67pFn5Ygqefp +YkJofU1xUKBpVJoYwRgtINkKqUy8APrIbfZ5s9Vw8NCZwBaprlXZlOlXNGO5ZF+ WyKVSsUly1+p8d8zzz7bkvdTAKABlXJZPWH9au3UiRN9MtU6isVi2wyWgLsRgNEm kslkNBZbZq5pcfmrikBt9I7m6OrVQnNrQjPArTryl/TbKsMjI6Kl1GzLOsT6ZwAh 4XmeGoT4WLlq7MQJoXtsqVTioAS0MQIw2scyRwSrRGeZZjtFINHaQhJFsC5dvKhS qP70y77fVpE+/UgZHBratmOHaBcA4Bf1PCr5+jA6ceyYUEGNcrm8MD8v0TIQBARg tBU14F48HOnfnweVSsUJf8mrO4imi/7+/se3bPGxwd9+/bWQz+s/8pf020JDq1aJ ljqzbfvgCy+IzjADgI/KpZJtWT42KBeA1cBpPpuVaBkIAgIw2o1hGL19fdFotLu7 23VdyzTbo+TVHeSK63qet2HjxoRh+NXgld9+y+Vy+tOv+uqr0QbptyWMZDKRSIhO +Kuv7/MvvSTXPgD4aHH9cy6nfvWxTbkl0KZpZufmJFoGgoAAjPaUSqUGotE2zj9y 02uO4+zeu9ev1lo197tY8KxUoohlq0hP/6pB5Nbt21cND8t1AQA+cmzb92N7T4+N CT1ebduezWQkWgaCgACMthWPx0ulUquvQkooKmBdunhRpVD96VelI/Wlp4Jlq4hu UK/h+F8A4VIuFlWq9LfNibNnfSypdTvXdWfEDhkGWo4ADISPChhGMinUuGlZ+/wI wGfPnFEPZv1Vr1T6Vak7R/ptncGhoWg0KtpFNBYTOqkLAHynHkx5gd1Yv/3yS7lc 9r3ZrqVVVNNTUxItA0FAAAbCJ5VOx+Nxocarnrdz165mWjBNc2J8PNLfrz/9dnF4 Q6tpmP7l+F8A4WJbVllgSZrKqHILldWTtI2X0aHDEYCB8BGdYTOSyfWPPtrwy9Xz +OaNG62qzVspl+c5uaGlhoaGBoSnfyl/BSBcSsWi4/f6566lnboXzp0TesOxkM+3 axUVgAAMhM/I6GhfX59EyypabNu+vbH4WqlUzk9M9PT06N/0W2Oapm1ZPLBbSMP0 r/oW3bl7d3poSK4LAPCRV63K1aQ4dfKk0HigWChQSBLtigAMhIzoBuDGKmBVyuUL 58+r3wg9hlfCtm2zUiH9tpZ08eeupbc5XnrtNdEuAMBHlmlWZHbqdkmehFQsFqkl iXZFAAZCRnQDsG1Ze1YcgFXmvHrlSi6X6+vtbdWsb43jOGp4QfptrWQyGRc++9fz vDVr1z62ebNcFwDgr2Kh4DqOUONjx49H+vslWqagBtoYARgIGdFJtr5IZP+BA7n7 b6M1TfPG5GRh6XG+mHpbN+V7S7VaVc/pAiu1Wm3V8HC/zDjsFk4/AhAu6glVkJxH PXHsmNCQoFwqLRCA0aYIwEDIyJ0A7Hled3e319Xl2HYylRro7y+XyyrxqqxbXTpp sHtpf29PT49E743hyN+AUN8wiURCupfaGzTSvQCAX0TXP3dJBmCKSqKNEYCBMEkm kwnDaPVVBMXikb/lMmu0Ws4wjGg02idc+pvTjwCETjGfd11Xrv2Tx44J3RUrlcp8 NivRMtByBGAgTNKDg7FYrNVXERQq/S7w/nQAiO5Lv8XzvGcPHZLuBQD8Ir3+uUuy CJZpmtm5OYmWgZYjAANhomGbZViYlUqWN6cDwDCMWDwuXQXNcZynnnkmJh+zAcAv 6jml/hPtYvzUKaF9SbZlzc7OSrQMtBwBGAiNRCJhJJOiVXbDwlJMk7LPQTA4NBSN RqV7cV33+Zdeku4FAHwkvf5ZOXf2bK1Ih+8cx8nMzEi0DLQcI2kgNFKpVFy+zlDw ceRvcGg4+qhrKf3uefJJueOvAcB3VdfVcDzBr5cuVWQmmdWNd2Z6WqJloOUIwEBo DA0NDchPtQWceiSXSyXSb0AMDw8LHUF5O8dxXnj5ZeleAMBHGtY/KzcmJ4VqNVer 1empKYmWgZYjAAPhoGenZcBVXbdULnPkb0DoqX3luu7OvXvT6bR0RwDgI/Woqgqv f1ay2ezN69clWvY8L5fLlUslicaB1iIAA+HAAUjValU9ifOk32AwDEOl3x75d2SY /gUQOq7rFrU8rdQd8vzEhNA+FBWAS8WiRMtAaxGAgXAYHByMdvABSJ7nlVT6FT5P Ais3tGrVgPyRvGoQufvJJ5Ps/gUQKnrWP9ecHhsTWh1WyOfZcIS2RAAGwmFkZKRP 5qy/4CP9Bk0ylYrH4xoKkjP9CyCMCrmcUHHmu506ebKvr0+i5WKhwKortCUCMBAC hmEkDKMzD0BS6bdcKuVIv4GRSCRi8bjQeOt2Kv3u27+/w1f+Awgdbeufa8ZOnIjI vD9eLBZ56xltqRPH00DopNPpmHy1oQAi/QaQnoN/u5a++s8eOqShIwDwUaVctkxT W3djx48LVeMvFYs8f9GWCMBACKwaHu6XP2wmaFj5HEA6Fz/vP3hQT9IGAB/pXP+s nDx+XGiEoB7BuYUFiZaB1iIAA0HXmeufF2s+l8uk30DRtvhZ6e3re/rgQQ0dAYCP XMcp6i0cdeLYMaGShOVSaYEAjHbUWUNqIIz0nLYaKK7rVlT6pfZGwAwNDQ1omZK1 LOvZQ4eEdrUBgBzN65+7RANwubwwPy/RMtBaBGAg6PScNxMcjuOoAQRHLwRNKpWK aVn87Hne6Jo1j2/ZIt0RAPhL3b4K+byncf2zcvLYsX6ZQUKlUpnPZiVaBlqLAAwE WkIxjJ6enlZfiCaWYpqk36AxDEOlX6GjJu+gvgFefO01DR0BgL8cxylpf37JVYEm AKNdEYCBQEulUvFEotVXoYPneepZ6zoO6TdoVPrtHxjQU4bNdd2tTzwxsnq1hr4A wF/61z93SZ4DbJpmdm5OomWgtQjAQKBp23XZWoubfisVSl4Fk85TuFzHef7ll/X0 BQA+Wlz/nMupXzX3O37qlNAyMQIw2hUBGAguwzDiiUTbr39Wj1jbspj4DaZkMqm+ CfUUIV88+uiZZ6IdVvINQHtoyfpn5czp00K3aMuy5mZnJVoGWosADARXMpVKtPX6 Z9d1zUolx8RvUBmGEY3F9Jx75HleanBwx65dGvoCAN+VSyXbsvT3O3H2rFDZLQIw 2hUBGAiu4ZGRdj0JRqUdFX0ddvwGm84K5Gqk9eKrr+rpCwD81ar1z8r5c+dcx5Fo 2bbt2UxGomWgtQjAQEC16/pnNT5QUYc1z8Gndeuv62554olRal8BCCfHtkvFYku6 vnTxolDlLfWXyhCA0Y4IwEBADQ8PR7TU3dWmFn3VAzWfz7f6WvAAOrf+1hx84QVt fQGAv1q1/ln57ddfVe8SLTuOk5mZkWgZaC0CMBBE6cHBWCzW6qvwTbVarUVfZn1D Qeepv4oaNar022Zv9wDoHJ7nLZ5i0Ir1z8rVK1cKMm8ru647Mz0t0TLQWgRgIHDa ZvGzGhPYtu04jus4xRatDUO9dJ7627X0TbL1iSdWjYzo6Q4AfKeedOXWPeNu3rgh dFhRtVqdnpqSaBloLQIwEDipVCoSifRFIjoXoPqolntV6HVdlynf0BkcHIxqXH2g BlhvvvMOq+IBhFepWHRsu1W9z87MTMvM0xKA0a5CObwGOkEikejp7e3tWfylt68v 4BPCKvQ6S4m3qv6rVsm9IZVKpWLxuLZ3Xmzb/uDDD+eyWfWdo6dHAPDX4vrnhYUW XkBuYWHy2jWJltVfbermTYmWgdYiAAMhYBiGyiTdPYt6F/9v8ZfWzg9X3aWku/SL sngCBKE35JLJpEq/2t5qUd8z27Zv37l79/Xr1/X0CAC+sy1LqAbVCjmOc35iQmhI MJ/NVioViZaBFiIAA6GUWNok3L0UgxejcXe3RA0hFVEWw20t4Nb867fE3TajufBV 19Liur/+7W/ZbHZ+fl5bpwDgr9auf645c/q0UADOLSyUWhrvAQkEYKBNqADje5uk 3A6hvnkGotFIJKKtx9riZyOZnJyctFp0dggANKnl659rxk+dElq8QwBGWyIAA0Cn GxoaUgFYW3dqyLhj5869Tz2lYvA1ma1rAKCBZVmVAOTD02NjQut3crlciUMc0HYI wADQ0fQfOq0ePB9/9pn6zfz8fDab1dk1APioVCg4jtPqqyAAA/UhAANA59Jc9rlr acLko08+qUXu69evm6aprWsA8NHikQe5XKuvYtGpkyf7+vokWiYAoy0RgAGgQ2ku +6y4rvvs888/vmVL19I2YNY/AwgvyzQr5XKrr2IRARioCwEYADqR/rLPSiwW++Of /lT7/cLCwtzcnM7eAcBHxXw+IGeYE4CBuhCAAaDjJBIJlUX7NJZ97lpa/Pzxp58O DAzU/ifrnwGEV9V1C/l8q6/in+QCsPo7ch4E2g8BGAA6i2EY/QMD/QIHRy/DcZzf //GPQ0NDtf/J+mcAoWZWKuq/Vl/FP42dOCF0jl2xoCJwUHI+4BcCMAB0Fs2HHnUt bf3dvWfPniefvPWRbDY7Pz+v8xoAwEeFXK5arbb6Kv5JLgAXCoXgTHQDfiEAA0AH 0X/okaJGZn/6+OPbP3Lt2jXbtjVfBgD4wnWcYpAWBhOAgboQgAGgU6TSaZV+dR56 1HXX1l/FNM3r16/rvAYA8FGlXLaCVMKAAAzUhQAMAB1B/5G/XUt7ff/w/vvpf239 rclkMmwqAxBSnucVcjn1a6sv5H8RgIG6EIABoP0lU6m49vTruu7+Z555YseO2z+o Ro1XrlwJzt45AKiLY9tBOxmIAAzUhQAMAG0umUzG4vGenh6dnaqgOzwy8ubbb9/x 8WKxOD09rfNKAMBHKv06ASthwDFIQF0IwADQzgzDUOm3t7dXc7+u6376n/9598en pqZKpZLmiwEAX3iel19YaPVV3EkuAOdyuaBNdwPNIwADQNtS6TcaiwkNjJZhWdaH H38cTyTu+LjjOFevXtV8MQDgF8s0K+Vyq6/iTgRgoC4EYABoTyr9DkSjQhvDlqFS 7hu/+92atWvv/qP5+flsNqv5egDAL8V83nXdVl/FnQjAQF0IwADQhlT67R8Y6O/v 19yvGhru2r1771NP3f1Hnuddu3ZNxWPNlwQAvlD3t2IgK0IRgIG6EIABoN0spl/l tqN39bhf4auaUqk0NTWl+ZIAwC9BO/73FgIwUBcCMAC0FZV+I5HIQDSqv2sVgD/5 /PP7/SnlrwCEVwCP/73l9NiYUKVDAjDaEgEYANrK4NBQtBXp17Ksjz/9dOA+086U vwIQagE8/veW8VOnhA66IwCjLRGAAaB9DA4ORmMx/f3atv2H999PDw3d7xMofwUg 1AJ4/G+N4zjnJya6u0WG9LmFBVbuoP0QgAGgTaQHB2OtSL+u6x56+eUNGzfe7xM8 z7t69WoAS6cCwEpUq9VC7v9n706c27jOfO9TXEDsIEVSkmUn8RIvseN4i53Ekxk7 seN4i7fxrjjj+B+8d6rem6q5NW+9U/dWzdwkN5SozVosWxJJACRA7L0veA8Bi6El ghv6dDe6v59SZEqintOkHXT/cM55Tivoq9hZs14vFosyKouX7rVyWUZlIFgEYACI gkKhkEylJE0C7ELE2scef/zJndo+b2m329Vq1bdLAgBvGboufgR9FTurViqV9XUZ lUXsX6dzIaKIAAwAIy9fKKSCSL/dbveukydffOml3T9tdXXVNE1/LgkAvCVe6JR2 W6TBoC9kZ6VisSFngwkBGFFFAAaA0RZg+s1kMm+9997un6ZpWplFdABGlm3baqcT 9FUMtHzzZkfO6cSO40iaWwaCRQAGgBGWz+dT6bT/6VdwbPvU55/v+WmcfgRgpGmq aoV4Dcv1r7/WNE1GZZH8q5WKjMpAsAjAADCqcvl8OqD0a5rmB598smfPLcuyVlZW /LkkAPBct9ttN5tBX8Vurl29KmmPiW1ZtG9AJBGAAWAkBZt+33n//Xw+v+dnioen tpy1eQDgA9MwdDnzq165cvmyY9syKluWtUEARhQRgAFg9Ij0m0qlxsfH/R/atqxX Xn/92PHje36m4zjLy8vdbteHqwIAGTqtVmjbX/VdunhR0susZZobGxsyKgPBIgAD wIgJMP2KTPuLX/7y/gce2M8n12q1ZriXDgLALkLe/qrvwvnz43KWApmmWSMAI4oI wAAwSnK5XCqdDir9/vjxx5/Y9cjf7Z/M9C+AkaYqim1ZQV/FHs4tLU1OTsqobBhG vVaTURkIFgEYAEZGgOnXdd1777//+V/+cp+fX6/XG42G1EsCAHnEi16n1Qr6KvZ2 9syZqakpGZUNXa/LOWEYCBYBGABGQ4Dpt9vtzi8s/ObVV/f5+eLBcXl5OeQb5wBg F7qmmYYR9FXsbWlxMTE9LaOy+A7wPiYiiQAMACMg2PSbyWbfevfd/f8V8czEvAGA 0SVe9zqt1khs4jizuDgtJwBrmtYkACOKCMAAEHab6TeVGp+YCGR08Qj4yWef7f/z mf4FMOos09RUNeir2BeJAVhVaWSISCIAA0CoifSbTKUmAkq/tmV98OmnB3q6YvoX wKhT2m3HcYK+in1ZOn06kUjIqKyqaosAjCgiAANAeAWbfk3T/OCTT1Kp1P7/CtO/ AEadY9tK6E8/2iKvCZaqKK1RaAMGHBQBGABCKvD0+96HH2az2QP9LZo/Axh1I3H6 0RZ5AVhRlDYBGFFEAAaAMAo8/b797ruF2dkD/S3O/gUw6kbl9KMt8s4BVjqddrst ozIQLAIwAIROsOnXsqzX3nxzfmHhoH9xY2OD9XIARtqonH7UJ16ur16+fOSIlOd5 EX87o7MUHNg/AjAAhEu21/M5wK5XL/32t3edPHnQvyiew1ZWVmRcEgD4o9vttkeq 7dP62tpGtSqpeKvZVEekFTZwIARgAAiRgNOvbf/Tiy9+/957D/F319fXFUXx+ooA wD+GrosfQV/FAdy4fl2V88Lruq5I1zIqA4EjAANAWASbfh3H+fnzzz/w4IOH+LuG YRSLRc8vCQB80+12O63WaHUxuHLpkqTjmhzbrlQqMioDgSMAA0AoBJ5+n3zmmcd+ /OPD/fVSqaSP1LQJANzGMk1t1Fb8Xjh/flzOBmDLsuQtrgaCRQAGgOAFm35dx3ns 8cefePrpw/11RVHW19e9vSQA8FO321Xa7ZE7w1zeGUimYdRqNRmVgcARgAEgYIHP /T78ox/99LnnDvfXxfPi6uqqbdveXhUA+MmyLG0EuxgsLS4mpqdlVDZ0vV6vy6gM BI4ADABBCjz9PvDDH/78H/7h0BXEE1Kj0fDwkgDAf0q7LWkzrVTyArCuaby2I6oI wAAQmGDP+3Vd9/s/+MEvX3jh0BVs215ZWRmtnjEAcBvbsiT1UpZt6fTpRCIho7Km qs2ROhEK2D8CMAAEI9j0K1LrybvvfuHXvx6myNraGqdEAhh1SqfjjOY+Dnl7gMVr e4sAjIgiAANAAAJPv8dOnHjpN78Zpoh4PFrjlEgAI862bbXTCfoqDkNc+aWLFyXd RxRFabdaMioDgSMAA4DfAk+/8wsLv3n11WGK0PsKQDSI9DuiL2W1jY21cllScaXT abfbkooDwSIAA4Cvgu16JdLv3Pz8K6+9NmQdel8BiADHcZSRjXnXv/lG3sHF7VZL Gc190cCeCMAA4J9cL/2OB5d+Z2ZnX3vzzSHrmKa5urrqySUBQIBURbEtK+irOKRL Fy9K6kHouu46O1wQXQRgAPBJ4Ok3n8+/8fbbw9cpl8u6rntyVQAQlJGe/hXOLS1N Tk7KqGxZ1ka1KqMyEAYEYADwQzTSr9But6s8GAEYfSM9/Tsm8xBg0zRrGxsyKgNh QAAGAOkCT7+ZTOat994bvhQH/wKIBse2ldFs/rzlzOLitJwArOt6o16XURkIAwIw AMi1mX7T6fHx8UBGF2FVjP7OP/+zJ9XK5bKmaZ6UAoAAjfr075jMQ4DF63yTNoeI LgIwAEgUePpNJpPvfvCBJ9U6nU6lUvGkFAAEKALTv2My9wCrqtpqNmVUBsKAAAwA skQp/dq2vbq66rquJ9UAIEARmP4VAf7G9etHjkh5klcUpd1qyagMhAEBGACkiFL6 HWPxM4CoiMb07zfXrsnrxt9ptzuj/y0CBiEAA4D3IpZ+6fwMIDJE+hUZOOirGNbF c+eOyLnFiDtIs9HgrDtEGAEYADyWy+c3ez5HJf1alrW6ukrnZwARYNu2Gom5zaXT pxOJhIzK4ltUpd0DIo0ADABeilj6FQVLpZJhGF4VBIAAKe224zhBX4UH5J2BxCHA iDwCMAB4JmLpV6jX6w0OwwAQCZZlaYoS9FV4Q94ZSBwCjMgjAAOAN6KXfsVjUKlU 8rAgAARFvEgq7XY0Wtnbtn3p4sWJiQkZxTkDCZFHAAYAD0Qv/YrHxNXVVXv0W8UA gGCZpqaqQV+FNyrr6/K26XIGEiKPAAwAw4pe+hXW19eVqKwVBBBz4nWy0253IzH9 K1y5fFleI2vOQELkEYABYCiRTL+tVmuDJigAosI0DD1CJ5mfO3NmUs4GYNd1VUUh ACPaCMAAcHiRTL+maRaLRc49AhANm9O/rVaUXtOWFhcTclpA25bFqe+IPAIwABxS JNOv67oi/VqW5W1ZAAiKoeviR9BX4SV5LaANw6jXajIqA+FBAAaAw4hk+h1j6y+A aHFdtxOtlk6WZV3+8ktJLaA1TWty9B2ijgAMAAcWePrNZDJvvfee55XZ+gsgYjRV tUwz6Kvw0urycktapFcVRV5xICQIwABwMFFNv4ZhFItFz8sCQFAcx1Ha7aCvwmNf Xrggr3hHiNx3DLgNARgADiCq6Vc8Jor0y6m/AKJEVRQ7ch0Nlk6fTiQSMiqLW8xm A2haQCPqCMAAsF+5XC6VTkcv/YrK5XJZj1aTGAAxZ9u2GsUsJy8AW5a1QQtoxAAB GAD2JfD0m83lfvfOOzKK12q1ZrMpozIABKI/mek6TtAX4jGR6i9dvCipAxYtoBET BGAA2Fvg6Tefz7/x9tsyinc6nUqlIqMyAATFMk1NVYO+Cu+VSyV5GZUW0IgJAjAA 7CHC6dcwjFKpJIaQURwAAiFe0zqtViRf2aR2wFIUpU0LaMQAARgAdhPh9EvjKwCR ZOi6EdGmBkuLi4npaUnFO+02HbAQBwRgABgo8PQ7Mzv72ptvSipO4ysA0dN13QhP Y8rrgOU4TmV9XUZlIGwIwACws830m0qNy+k1siep6VeoVqttDnsEEDlqpxPVhS1S O2CZplnb2JBRGQgbAjAA7CDa6bfZbNZo9QkgchzbVqK7iHd1ebklbXKbDliIDwIw ANwu20u/kt5l35NIv7Ozs69KS7+qqq6trUkqDgABajebkex91Xf+7Fl5NyZVUeSl ayBUCMAA8B3ZbDaVTgeYfufm51957TVJ9U3TLBaLEX5ABBBbhqBpQV+FRHTAAjxB AAaAv4t2+qXtM4Cocl23E/UJzLNnzkxNTcmoTAcsxAoBGAC+JdJvMpWanJwMZHTZ 6Vc8HZbLZcMwJNUHgAApnY4T6Xf3Go1GcWXlyBEpj+6mYdAYAvFBAAaATdFOv6J+ pVJRFEVSfQAIkGVZWtRf3768cEFecTpgIVYIwADQS7/J5KScpWV7kp1+hXq93uDh BkAUiZfQdrMZ9FVIJ+8EYEFRlAgfngzchgAMIO5E+p1OJiVtrNqTD+m30+lUKhV5 9QEgQJqqWqYZ9FVIJ28DsLgNKZ0OHbAQHwRgALGWyWSSqVSE06+maeVyWV59AAiQ bdtqDJKbCKg3rl+XtAHYtqxqtSqjMhBOBGAA8SXS73QyKW9R2e58SL+maZZKJdd1 5Q0BAEERr6KdVisO57pJ3QCs63qjXpdXHwgbAjCAmMpms4np6QinX9u2i8Wi4zjy hgCAAMVk8bNwZnFxWtoJwKqitNgAjDghAAOII5F+pxIJec8Tu/Mh/bquWyqVzHg8 GgKIoZgsfh7rfaVfXrgg75CCTrvNBmDECgEYQOxspt+pqelkMpDRfUi/Yoi1tTVN 0+QNAQABis/iZ6FULMpboizSdZUuiYgZAjCA2JmZnU1GN/0KlUqFt/MBRJiuaaZh BH0VPjl/9uzExISk4oZh1Gs1ScWBcCIAA4iXwsxMKpUKZGh/0i9H/gKItvgsfu6T uwFYVVsxOEUZ2I4ADCBGCoVCKp0OZGiRfmdmZ197802po7TbbU6zABBhm4fWttvx aW5vWdblL7+UNwO8ef5vuy2pOBBOBGAAcZEX6TeVknSO4u78Sb+qqq6trUkdAgCC patqrNr7ff3VV4a0xd6O41TW1yUVB0KLAAwgFvL5fCqdDir9itHfePttqaOIJ6RS qRSTljAA4ilui5+FpcXFhLT1z4au1zkBGPFDAAYQfbl8Ph3p9GtZVrFYjM+aQAAx tNn5ud3uxuyF7uyZM1NTU5KKswEY8UQABhBxuVwulU6Pj4/7P7R4XMvmcr975x2p o9i2XSqVxM9SRwGAYGmqasVp8bOwUa2ulcuS3r3d3E29uQM4XjPqwBgBGEC0ZbNZ kX7ltQ/ZhXi2yGQyb733ntRRXNcV6TdWO+IAxJBtWaqiBH0Vfju3tDQ5OSmpOCcA I7YIwAAiS6TfZCol7+lhF/6kXzFKuVzWdV3qKAAQrM3Fz61WDHscLJ0+nUgkJBUX 944GG4ARSwRgANEk0u90Milv69QuxFNaMpl894MPZI9SqVSU+E2JAIibGC5+Hutt 0L3+9dfyuleI20e71ZJUHAgzAjCACBLpNzE9Le+N8z10ux9/9pnsQarVapvDGwFE nWVZWizf6bt4/ry89NvvKMZbqIgnAjCAqBHpdyoh8q+scyN25zjO+x9/LHv0er3e aDSkDgEAgeu67mbn5/gtfhbOLC7Ku5WYplnb2JBUHAg5AjCAqJmZnU0mk4EMbdv2 B598Ijv9tlqtDR5cAMSAqii2ZQV9FQFQVfXrr76S18FRU9UmByAhrgjAACKlUCik 0ulAhrYs68NPP5WdfhVFWV9flzoEAISBZZoipwV9FcGQuv5Z6LTbHICE2CIAA4iO fD4v0q/Uh4ZBTNP86NQp2elX07RyuSx1CAAIA9d1lbgufh6TvP6ZA5AQcwRgABGR y+fTwaXfDz75JJVKSR3FMIxSqRTbx0EA8SFe6DRFETkt6AsJhuz1z7qm0UUCcUYA BhAFuVwulU6Pj4/7P7RIv+9/9FE6k5E9iki/rutKHQUAwsA0DBHSgr6KwMhe/8wB SIg5AjCAkZfNZlOp1MTkpP9Di1z63gcfZHM5qaPYti3Sb2wnQwDEius4nXif8SZ1 /bP49qqqygZgxBkBGMBoy2QyyVRqamrK/6FF+n3n/ffz+bzUURzHEenXimUfVABx 0+12RTgTr3tBX0hg2q3W8s2b8maADcOo12qSigMjgQAMYIQFeOSvZZpvvvvu7Oys 1FFc1y2Xy+J5ReooABAShq6LH0FfRZDOLS1NylzQpCpKi/XPiDcCMIARNjMzk5Tc empHlmW9+uabCwsLUkfpdrtra2tajDfCAYgVx3GUeC9+Fs6eOSNvTdNmb+1OR1EU SfWBkUAABjCq8oVCOogjf23b/vXLL5+85x6po4j0W6lUeEwBEBPiRU+k35i3+iuX y7VqlfXPgFQEYAAjKahDj0T6/eULL9x7332yB6pWq+3Yz4QAiA9d08zYb/dYWlxM yNzUw/pnYIwADGAUZbPZdCbj/6FHjuP89LnnHv7Rj2QPVK/XOaQRQHzYtq3Gvi+x ZVmXLl6UtwGY9c9AHwEYwIgR6TeZSkntEbIjkX4fe/zxJ59+WvZArVZrY2ND9igA EBJd1+20291uN+gLCdjlS5dcme2vWf8M9BGAAYwSkX4T09OJRMLncUX6vf/++3/x j/8oe6BOp1OpVGSPAgDhoSqKzUlvko//HWP9M3ALARjAKAmk7XO32z1x112/evll 2QOpqrq2tiZ7FAAID8s0NVUN+iqC16jVisWivMYWrH8GthCAAYyMfKGQSqV8bnwl 0m+hUHj9rbdkD6TrerlcZhEggPhwHadDt78eqacfjbH+GdiGAAxgNORyuVQ67X/j K5G3Pzp1SvYopmmWSqWYn/8BIFa63a7a6Tgyd72OCtntrwRFUdqsfwZ6CMAARkA2 mxXpd2Jiwudxbcv64NNPpW7KGuu1Py0WizwFAogVQ9fFj6CvIhSuXLok9RYgimuq 2ol9n22gjwAMIOxE+hURdMr3xlemaX506pTs9CueS0qlkkUDGABx4ti2Qh67RXb7 K13TOFoP2EIABhB2M7OzyWTS50FF+n3vww9F9pY6iuu6Iv2KsaSOAgCh0u12lXab TR99tWq1XC5LbW/REdhrDdxCAAYQavl8PpVO+9z4yrKsN996a3ZuTuoo4hFQPPTo rAAEEDOaqlq88XfL0uJiQub0r7ijbVSr8uoDI4cADCC8srlc2vfGV7Ztv/jrX9/z /e9LHUWk30qlwokUAOKGc4+20zTt2tWrUjtciO92s9mUVx8YOQRgACGVyWRS6bTU rph3chzn6Z/+9EePPSZ7oI2NjRYNOQHEjOu6m2txOe/tlvNnz0pNv5urzTcXQLPd Gvg7AjCAkJo9elR2A6rbiPT7w4ce+tkvfiF7oEajUa/XZY8CAKHCuUe3sW37ywsX pL7Py/G/wJ0IwADCKF8opNNpP0cUT2Zz8/OvvPaa7IHa7XaV7VgA4odzj25z5fJl x7alDsHxv8CdCMAAQieQrb9Hjhz56NQp2aOoqrq2tiZ7FAAIG9u2VRbiftfS6dMJ mSf8ie+5rmmsfwZuQwAGEC6BbP21LOvDTz+VveJa1/Vyudxl8xuAmOn2tv7y6rfd 6spKs9GQesaBpmlNjv8F7kAABhAus7Oz0/6e+msaxvsff5zOZOSOYpqlUolzLwHE kKootmUFfRXhcmZxUeq7rrS/AgYhAAMIkXw+LzuI3sayrNd/97u5+Xmpo9i2XSwW af0CIIZMw9A1LeirCJfK+rr4IXX6l/ZXwCAEYABhkc1mRfr1c+uvSKQ/f/75Bx58 UOooruuWSiXTNKWOAgAhJF5mlXY76KsIHdnTv2O0vwIGIwADCAWRfhPT01Lbgdym 2+3ee//9v/iHf5A9Srlc1ml8CiB+Nlfhttts/bhNo14vrq5Knf6l/RWwCwIwgFAo FAopH889Eo9l+Xz+jbfflj1KpVJRFEXqKAAQTpqqWix+ucPS4mJC8vSv+M43m02p QwCjiwAMIHi5XC6dyUh9O/w2jm2f+vxz2aPUajUeQQDEk4i+IoYFfRWh02o0bt68 OTExIW8I13WVTof3XoFBCMAAApbNZqeTyampKd9GNE3z/Y8+kt1tq9VqbWxsSB0C AMLJdZzN9bece3QHH6Z/dV1v1OtShwBGGgEYQMAKMzOpVMq34WzbfuW1144dPy51 FEVR1tfXpQ4BAOHUP4DHpe/9HXyY/uX0I2BPBGAAQfJ58bPjOD958snHn3hC6ii6 rpfL5S5THwBiSVdV+t7vyIfpX9Mwapx+BOyKAAwgMNlsNplKTU5O+jOcSKTzCwu/ efVVqaNYllUsFul6CiCe2Po7iA/Tv2OcfgTsAwEYQGB8XvwsQumnf/iD1CEcxymV SiIDSx0FAMKJrb+78GH6V9x9NqpVqUMAEUAABhCMbC6X8XHxs2maH3zyidS8zZG/ AOKMrb+7qFWrpVJpfHxc6iiqqrY4egDYCwEYQAB87vzs2PavX3nlrpMnpY5SqVTo OwIgttj6uwsfpn/FnU7TNG5DwJ4IwAACkC8U0um0P2N1u90HH374p889J3WUer3e aDSkDgEAocXW312Ui8VarSZ7xZP4/nPyPLAfBGAAfstms+lMRvZKsC2Tk5Pvf/yx 1CE6nU6lUpE6BACEFlt/d3dmcXFa9vSv46jKJqmjANFAAAbgt9mjR2U/CmwxTfOj U6ekDsehRwDijK2/u7t540an3ZY+/atpTVYhAftDAAbgq1w+n8lk/BnLtu1X33hj fmFB3hAcegQg5jRVtdj6O4C4DV04dy6RSEgdRdyDVEVh9y+wTwRgAP7x8+BfH7b+ imcOkX459AhAbLH1d3dfXrjgwyi6ptGEAtg/AjAA//h58O+RI0c+OnVKXn0RsNfX 11We/ADEleM4Srsd9FWEl2EYVy5dkv2eL9O/wEERgAH4xM/eVz6c+lur1ei3CSC2 Nrf+tttsANnF2TNnfDjtT9f1Rr0uexQgSgjAAHwyOzs7nUz6MJDjOP/4wgvfv/de eUPQ9hlAzLH1d3etZvPmjRsTExNSR2H6FzgEAjAAP+RyuXQmI7sN5lhvUmJ+YeE3 r74qbwjDMEqlEm2fAcSWaRi6pgV9FaHmw9FHY0z/AodCAAbgh6Nzc7LbYPZZlvXZ H/8or75t28Vi0eHADwBxxdbfPZWKxXqtJvs9X6Z/gcMhAAOQzrejj0Q6fe3NN+fm 5yXV73a7pVLJMAxJ9QEg5MTLYKfd7rL1dzB/jj4aY/oXOCwCMAC5fDv6SDyWfe/7 3//lCy/IG6JarbaZ9wAQY6qi2Jz9tquL58/7sN+H6V/g0AjAAOTKFwrpdNqHgWzb /v3nn8urL6KvCMDy6gNAyLH1d09qp/P111/L7n0laJrW5Oxf4FAIwAAkymazqXTa h0cBkX7fePvt2dlZSfUNwygWi5KKA0D4ObatMN+4l6XFxYT83leO46jKJtkDAZFE AAYgUaFQSMmf/u12uyfvueeFX/1KUn3xqLG6ukrjKwCx1XXdTqfD1t/d+dP7aqx3 BhUH0QOHRgAGIEsmk0lnMj5M/1qm+dkXX0gqLtL12tqaxqo/AHElXgZF4mLr7+4s y/ry/Pkp+b2vHNsWtyR2/wKHRgAGIEthZiaVSskexXWcF1966eQ990iqX6/XG+yz AhBjhq6LH0FfRdidP3vWhzd8BVVVW0z/AkMgAAOQwrfp36lE4p8//FBScU3TyuWy pOIAEH62batMNu6l0Wis3LzpR8MLy9J1nelfYBgEYABS+LP71zLND0+dmpbTcUQ8 9q2urrrseQMQV5tbf9vtbrcb9IWE3ZnFRUl3otsoitJutXwYCIgwAjAA7/kz/Sue yR559NGnnnlGUvFyuayz6g9AXG1u/VUU27aDvpCwu/bVV4au+9D7yjTN2saG7FGA yCMAA/CeP9O/Ug/+ZesvgJhj6+9+aJr21ZUrk5OTsgfqdruKonTabdkDAZFHAAbg MX/O/nUc5+Xf/vb4iRMyirP1F0DMsfV3n5ZOn07I7/ws6LreqNd9GAiIPAIwAI/l 8/l0JiN7lPGJiQ8/+URGZU79BRBzrusqbP3dh5vXr3c6HR8WP4t/I6qi0PsK8AQB GIDH5ubnp6ampA5h2/Y777+fzWZlFF9fX1cURUZlAAg/tv7uk65pV31Z/Cxoqtrk 6CPAIwRgAF7K5fMZ+dO/+ULh9d/9TkbldrtdrVZlVAaAkcDW331aWlxM+NL52bZt EbaZ/gW8QgAG4KWjc3Oyd0OZpvmRnKOPLMtaXV1l1R+A2HJsWyFo7cPyjRvtdtuH xc9jHH0EeI0ADMAz2Vwuk8lIfSAQ6fShRx555tlnZVQulUqGYXheGQBGgngZ3Dz1 l8PP96Lr+tXLl/1Z/CzuSvVazYeBgPggAAPwzMzsbDKZlDqEaZp/+OILGZUbjUad BpsAYkxVFNuygr6KEeDb4md6XwEyEIABeCMjZLPj4+Pyhuh2uz958snHHn/c88oi VxeLRRY/A4gt0zB0TQv6KkbA9a+/VlXVn8XPmqY1OZEe8BoBGIA3CoVCKp2WOoRl mp9JmP5l8TOAmHMcR2m3g76KEaB2OteuXfNn8TO9rwBJCMAAvDG/sCD1mUDE1Kef ffbhRx7xvHKz2ayxwwpAXIlXV5F+Xbb+7oNvi5/H6H0FSEMABuCBXC6XkXMq7xZJ 0790fgYQc5qqihfYoK9iBFy9fFncMvxZ/EzvK0AeAjAAD8zOzk7LbH8lAuqTTz/9 o8ce87xyqVTSOfESQFyJ6CsCcNBXMQIatdrKysrExIQPY9H7CpCKAAxgWNlsNp3J SG1/Jan5s3i8qFQqnpcFgJEggpbSbrMEZk+WZV08f172KfdbVFVtNZv+jAXEEAEY wLDyhUJaZvsr8XD2yKOPPvXMM96WdRxnZWWFbW8A4km8tKqK4th20BcyAs6dOTM5 NeXPWJZpGobB9C8gDwEYwLDm5uenZD4ZSJr+rVarbbqeAogrQ9cNNoDsw+rKSrPR 8Gfr72ZDMkXpcG8CZCIAAxhKNpvNZLNSnwxmZmdffeMNb2sahlEsFr2tCQCjgnOP 9knXtKtXrvhz7tEYB/8CviAAAxhKYWYmlUrJq29Z1oeffjrt9bETIv1y8C+AeOLc o32ybfv82bOe34B2GY6DfwEfEIABDEX28b+i+Psff+xtTXpfAYgzkbJM3gHch4vn z/uz8nns1pZsNuYAPiAAAzg82cf/Oo7z+ltvzc7OeljTdd2VlRVR2cOaADAqbMsS QSvoqxgBa+VyZX3dn3OPxnrvSjRY/Az4ggAM4PBmZmaSMtc/27b9+88/97ameMKo 1+ve1gSAkdDtdjvtdpfFz3vRdf3KpUtS+ztuJ252mqoqvDEB+IIADODwpK5/Fg9q Tz/77MOPPOJhTY4+AhBnImVZphn0VYyAM4uLvm393Vz8rKrtVsuf4QAQgAEckuz1 zzJOP9rY2GjxkAEglizL0phj3IfLX37pOI5vu391XW+wLgnwEQEYwCHJXv8sir/z z//sYUHbtldWVrrdroc1AWAkuK6rtNu8AO5pXSiXfdv6y+JnwH8EYACHJHX9s+M4 v3v33Xw+72FNpn8BxJbIWLZlBX0VYefz1l86PwOBIAADOIyskMvJq+95+yumfwHE Fouf92np9OlEIuHbcHR+BgJBAAZwGIVCIZVOy6t/8u67/+lXv/KwINO/AOKp67od Fj/vw5VLl2zb9m3rr2VZhq53Oh1/hgOwhQAM4DCOzs3Je5tcPIJ88MknHnbgdBxn eXmZ5z8AMaQpisXi5734vPWXxc9AgAjAAA4sm81msll5b5OLJ4NPPvvMw4K1Wq3Z bHpYEABGAouf90PTtKuXL/u29bc/YpPFz0BACMAADiyfz6czGUnFRfr96XPPPfjw w14VdF13eXmZs38BxI14Oe20Wix+2Z1t2xfOnk34deqvYJmmYRgsfgaCQgAGcGAz s7PJZFJSccuyPvvjHz0s2Gq1NjY2PCwIACNB1zSRtIK+irA7d+bMpI9zv67rqopC +gUCRAAGcGALx47J2yjl7fpnUW1lZcW2ba8KAsBIcGxbIWXt5fo334g46lvjq7He eVR0ZASCRQAGcDDZXC6bzUoq7vn6Z1VV19bWvKoGACNBvJaK9Os6TtAXEmq1Wq24 suJb4yvB0PV6ve7bcAB2RAAGcDBSD0DyfP1zuVzWNM3DggAQfiJoiR9BX0WoGYZx +eLFKR9P/bVtW1NVhZ5kQNAIwAAOZvboUQ8PKLqN4zin/uVfvKom4vTKyopX1QBg JLiu22GR7a5EFj1/9qy8e9mdOPcICA8CMICDkboB+MRdd7340kteVeP0IwAxxMG/ e7pw/vy4j/t+BU1VuR8BIUEABnAAUjcAO47z3ocfplIpT6p1u93l5WWHLXAA4sS2 bZXeV7taXV5uNBrj4+O+jWgahmmadH4GQoIADOAA8oVCWt4GYNP87IsvvKpG+ysA cbPZ+6rd5tjzXbRarRvffDM5OenbiI7jaKpK+gXCgwAM4ABmZ2enpZ0AnEwm33n/ fa+qra+v02sEQKyYhqHT9m8wy7Iunj+f8LHxFVt/gRAiAAM4gPmFBUlvnIunhBdf eumukyc9qeY4zs2bNz0pBQAjoeu6m0Gr2w36QsJraXEx4WPjK0HTtGaj4eeIAPZE AAawX9lsNpPNHpHTOMTbA5DEU2C1WvWqGgCEn65ppmEEfRXhdeniRdd1Jd3CdmQK hsHiZyBsCMAA9iufz6czGUnFbdv+/eefe1WtVCrpnIEJIDZcx+mwznaw5Rs32u22 n+mXrb9AaBGAAexXYWbGqxbNd8rmcm++/bYnpVj/DCBuVEWxOfpogEattry87Gfj q82tv6ra5jRmIJQIwAD26+jcnKTeIeJZ4Tevvjq/sOBJtVartbGx4UkpAAg/jj7a hWEYl7/8cmpqys9B2foLhBkBGMB+LRw7NjExIaOytxuAy+WyRh9UAPGwOdnY6XDm +Y5s2z5/9uy0v42v2PoLhBwBGMC+ZIVcTlJxDwOw67o3btzwpBQAhJ94/dQ48m2A c0tLfq58HmPrLzAKCMAA9iWXz2ekdcBKTE+/98EHnpRSFGV9fd2TUgAQct1uV2m3 XdcN+kLC6JuvvxZZ1M/GV5z6C4wEAjCAfZHaAevBhx9+5tlnPSlVqVR46x1ATFim KTJe0FcRRtVqtVwsStq2M4iqqq1m088RARwCARjAvswePSppG5XjOO9//LEnxbvd 7vLyMnvhAMQB07+DiCD61ZUrPje+MnS9Xq/7OSKAwyEAA9iX+YUFSTupTNP8wxdf eFVqdXXVk1IAEHKmYeg0/LuDZVkXzp3zufGVGFT8u1DYjA2MAgIwgL1ls9lMNitp J5Vj26c+/9yTUs1ms1areVIKAMKs2+122u0u0793WDp9WtKJfYO4rqsqCrtvgFFB AAawt2wuJzKwpOKpdPrt997zpBQHIAGICXb/7ujyl186juN34ytVbbdavo0IYEgE YAB7y+fzaWktoB986KFnnntu+DriKeTGjRvi5+FLAUCYsft3RyvLy4163efGV5qm NRsNP0cEMCQCMIC9yWsB7TjOex9+6ElxwzCKxeLwdQAg5Dj7907nlpaOHDnic/o1 DcM0TRY/A6OFAAxgb/JaQIvHuM/++EdPSrEBGEBMKO027e63++baNU3T/Fz5LNi2 rWsa6RcYOQRgAHubm5+XdJ6EhwF4bW1NZUccgKgTuUsldG3TqNVWV1fHx8f9HNR1 XU1V2+22n4MC8AQBGMDeFo4dk7eu7OPf/96TOjdv3mRKBEDkqYpiW1bQVxEWhmFc uXRJ0il9g3S7XZF+WzS+AkYTARjAHjKZTDaXk7S0LJfPv/HWW8PXsW17eXl5+DoA EGau63bIXbeIV/7zZ8/6fOSvoGtag8ZXwMgiAAPYQy6Xy0g7A+nhH/3oqWeeGb6O oijr6+vD1wGAMBPRyzSMoK8iLM4tLfk89yuYgmGw9RcYXQRgAHvI5fMZOWcgdbvd d95/35MW0PV6nffjAUSbeM3stFoc9tZXLpWqlYrPbZ9pfAVEAAEYwB4KhUIqnZZR WTxJ/P7zzz0pVS6XNU3zpBQAhJNpmjqt/npUVb129arP07+u64pxOzS+AkYcARjA HmZmZpJyDgEWD3N/+OILT0otLy+LOO1JKQAIJ04/6gtk62+32xXpt80GbGD0EYAB 7CH8hwC7rnvjxo3h6wBAaInoqzD32BPI1l9N05pstAEigQAMYA/yDgF2u91PP/ts +DqGYRSLxeHrAEBo0f6qb2V5udVsSjqYYBBxl6nXan6OCEAeAjCAPcg7BHg6mXz3 /feHr9Nut6vV6vB1ACCcaH/V1+l0vrl2zefpX8uydE1TFMXPQQHIQwAGsIfjJ05I eq/92LFjv37lleHr1Gq1ZrM5fB0ACCfLNLXYt78KZOuv4zjiO0/bZyBKCMAAdpMV cjlJxR9/4onHHn98+Dq0gAYQbSKB0efP/62/NL4CIokADGA3uVwuk83KqOzhIcC0 gAYQYa7rdmKfwUrFYm1jY3x83M9BRfptsbwIiBwCMIDd5PL5TCYjo7JXhwCLIH39 +vXh6wBAOJmGocd7kYv48q9evjwppx3jwEF1vVGv+zkiAH8QgAHsJp/Pp+UEYK/O QBJ1VlZWhq8DAOGkdDpOvBe5LJ0+nUgk/BzRFAyDrb9AJBGAAeymUCik0mkZlcXT xR+++GL4Opqmlcvl4esAQAix/vnaV18Zuu7nuUe2beuaRvoFoooADGA3MzMzSS+2 6d7JMs3PvAjAnIEEIMIMIcbrnzvt9jdff+1n7yvXdVVVFeP6NiIAnxGAAexmdnZ2 OpmUUdmx7VNe7AGu1+uNRmP4OgAQQkq77ThO0FcRDP/PPep2u5qqtuI95Q5EHgEY wG5mjx6V9PBx5MiRj06dGr5OpVJhoRqASIr5+ueL58/7ufJ5rLenpsk7qkDUEYAB 7Obo3Jyk1iMiV7/7wQfD1ymVSrquD18HAMImzv2fW63WzevXJyYmfBvRNM3axoZv wwEICgEYwG7m5uen5Jw8kcvn33jrreHrrKysWJY1fB0ACBu104ntIedLi4sJHxc/ O46jqSrriYA4IAAD2M38woKk7iPHjh379SuvDF/n5s2bsd0gByDCut1uu9kM+iqC 8fW1a7qm+bb+WXyrlU6H9AvEBAEYwG6OHT8+Pj4uo/K999//8+efH7KIeGq5fv26 F5cDAOFimaamqkFfRQA0TfvqyhXfOj+7ritGbMd4rzUQNwRgALs5fuKEpPfgf/LE E48+/viQRRzHuXnzpifXAwChItKvyMBBX0UAlk6fltR74k7dbldVlDaHHgFxQgAG MFAqnS4UCpKK//KFF+753veGLGJZ1srKiifXAwCh0m42RTwL+ir8tlGtlopF33pf qaraius6cyC2CMAABsoKuZyMyo7jvP/xx8MfsKTreqlU8uSSACA8xIukEstpyTOL i74d/Gvoer1e92csAOFBAAYwkEi/IgLLqGzb9u8//3z4OoqirK+vD18HAELFEOJ3 ANKN69eVTsef3lfiNqSpqriJ+DAWgFAhAAMYKJfLZcIdgNvtdrVaHb4OAIRKDA9A El/vxfPnJR28dxvXdVVV7cRyjh0AARjAQLl8PpPJyKhsWdZnf/zj8HVardbGxsbw dQAgPOJ5ANKlixd92/PM1l8gzgjAAAYKfwBuNBrs4AIQMbZtqzE7k9bP6V/DMOq1 mg8DAQgnAjCAgfL5fFpOADZN8w9ffDF8HZF+RQYevg4AhIeh6+JH0FfhK9+mf0XS 1jWtE7P3FwBsRwAGMFC+UEin0zIqW6b5mRcBeGNjo9VqDV8HAMIjbhuAfZv+5dRf AGMEYAC7kBeAvZoBrlQqvJEPIEpiuAH4yuXLji+BX9O0JouGgNgjAAMYqFAopMI9 A7y+vs4hFgCiRERBJWbv6/lz9q9lWYau854pAAIwgIEKMzOpVEpGZa+aYK2tramq OnwdAAiJuJ0AXKtWy+Wy7LN/OfcIwBYCMICB5AVgr84BFo9NWpyeFAFEnqootmUF fRX+WTp9OpFIyB5FU9VmzBaWAxiEAAxgIIkB2LI++PTT4de8lUolPWa9UgFEW7vV 6rpu0FfhE8Mwrl6+PDExIXUUFj8D2I4ADGCgmZmZpJwALPzs+efvu//+IYsQgAFE ieu6nTh1tr986ZLrOFKHoPMzgNsQgAEMNDM7m0wmZVQWTyTvffjh8DPAxWLRMAxP LgkAAmdZlhanxn4+tL/SNY3j4gFsRwAGMNDs7Oy0nADsOM6pf/mX4eusrq6apjl8 HQAIA5HWzNi8qefD+mdxr1EVhcMCAGxHAAYw0OzRo5Lem3ds+5QXTbAIwACiROl0 /DkRNwx8WP+sqmqL3lcAvosADGCgo3NzkppzetUFmgAMIErazWa32w36Knwie/0z va8A7IgADGAgAjAA+CZuHbDOnjkzNTUlr76iKO04fT8B7BMBGMBABGAA8E2sOmDV arVysXjkiKwHUXFrqG1sSCoOYKQRgAEMNDc/L+ntefGc99kf/zh8HQIwgMgwdN2I zbluF86dGx8fl1ef6V8AgxCAAQxEAAYA36iKYltW0Ffhk6XFxYS0DcC2bVcrFUnF AYw6AjCAgeQFYJFa//DFF8PXIQADiIxOq+W6btBX4ROpG4A1VW3S/BnAAARgAAPN LyxMTk7KqOxVAC4Wi0ZszswEEGHdbrcdm8wmXrevXb0qaQOw+E4qnQ7NnwEMQgAG MJC8AGyZ5mcEYAC4xbFtJYqZzbbtO+8j33z9ta5pkkY0DaNWq0kqDiACCMAABgr/ DHCpVNJj0zMGQISJV0VdVYO+ir+zTPPI+Phtfaq2/9J1XfHL236+rYj4HfGgOXHH feT82bMTExOSrlxV1VZs5tIBHAIBGMBAC8eOSXpG8aoJFgEYQDTommYGtJ5FxFTH trdiqtTmzH1Lp09LOmOP9c8A9kQABjCQxADs0RLocrmsSVtHBwC+UTsd27aDvgqf nFlcnJbTApr+zwD2RAAGMFD4Z4DX1tbUMC0aBIDDoQW0J3Rdb9TrMioDiAwCMICB wh+A19fXFUUZvg4ABChWLaBt27508aKkmwsbgAHsiQAMYCB5AVg8AP3+88+Hr1Op VNjrBWDUOY6jtNtBX4VPahsba+WypOJKp9OOzXcSwOEQgAEMRAAGAB9YlqXFZjHL 8s2bHWkZVVTmpgBgdwRgAAOFPwBXq1Xe7Acw6gxdN2LT0P7a1aumacqo7Lru+tqa jMoAooQADGCgY8ePSzoPw7HtU14E4Fqt1mS7F4ARp6mqJScThtClixe73a6MyrSA BrAfBGAAA83Nz0tq1Dk5Ofn+xx8PX6derzcajeHrAECAYnUG0vmzZyWtLTJNs7ax IaMygCghAAMY6OjcXCKRkFE5l8+/8dZbw9cR6bfOiRcARlyszkA6d+bMpJy3Vg3D qNdqMioDiBICMICB5ubmpuQE4MLMzGtvvjl8nVartcH7/QBGWazOQBrjEGAAQSMA Axgo/AG43W5Xq9Xh6wBAUFzX7bRaQV+Ff5ZOn5a0tkjXNDbFANgTARjAQOEPwJ1O p0LLEwCjzLZtNU4n9ywtLiamp2VU1jStSQAGsBcCMICB5DXBmj169Levvz58HVVV 1zj0AsAos0xTU9Wgr8I/ZxYXpwnAAIJDAAYwkLwALCr/5tVXh68jHnfK5fLwdQAg KLE6BHiMAAwgaARgAAPJC8C/evnl4ydODF/HMIxisTh8HQAISqwOAR4jAAMIGgEY wEDhD8CWZa2srAxfBwCConQ6TmwOAR6TGoBVtRmnftoADocADGCg8Adgx3Fu3rw5 fB0ACEq71erG5hDgMWaAAQSNAAxgoPAHYNd1b9y4MXwdAAhE3A4BHiMAAwgaARjA QOEPwMI333zjSR0A8F/cDgEeIwADCBoBGMBAIxGAb9y44cZp9SCAKHFsW4nTIcBj BGAAQSMAA3GUzWaPCOPj4qdEIjExMeHzBXgYgG/evOk4jielAMBnlmVpihL0VfhK XgC+k7g7mKbZFVxX/NSJ2XsNAHZEAAYiTmTdMRF1e3G3T8TdIz0BXpWHAXhlZUU8 QXpSCgB8ZhqGrmlBX4V0W+t0xAfnz571LQBv1+0Rkdjt6W7+rztGKgbihwAMRM3m 7O62rNuPu0Ff1O2eeuaZ7/3gB5sX17tK8Tvin4crVSwWDcPw9OoAwCci/ZqReAXb HnFdx+nNufY+FP+zbcveZAq6+Iq1qUQi2Kvd0o/E21MxeRiIvNA9FgM4qEwmM94P kuLH5OR4b2Fz0Be1B/HMkS8UUqnUdDKZmJraXIY9OTk5NTV9S6JHBOTJvTYhl0ol Xdf9uWwA8JamKCO3hqWfdbcmVEWytcxetjUMS/ywLPFbTm9ytdv/WTxuiruS+Gdv 8ZF4sQ/tTaqf2zev/9v47igxW6AOxEFIX4AA7K6/iVfk3sme0D5MDOL05gfGek8b /aei/u+P974o8VWJBJxK92QyvZ8y4pfJVGqqZ/t08draWqfTOfQEMgAESOl0RNwK +ip2JgKgSLNbb6r2w6FtWZquG5r4SQReoz93Kv6o/zlHbtkqcueOmxG6YYmvqzd1 bffntJkcBqJhZF6DAIz1cm9/WbMIgYHv4/VKPwlv13+cGrs1w9CP+uJLTiWTmWw2 J+TzIhJPJ5PiyaxaqYhHtLT4zpCBAYyaTqsVwj72ItZqqmpalqoo4od4dRXZ17Lt ftzdmsvdug1tf/mNxo3pNv2b0ebktvgOOA5JGBhpEXyRAqIn20t3k71FwnGLeVvx +O+pWDx+HTnS394sgrFtWZv7nMfHxUOJ+GUylZqenp4S36pEYnNpdW85dT8qB/p1 AMAOWgEd2yOyXL1WUxTF0HXx8dYsbp94Ue3P925/h/LId0PvWESz7p760+Cb08Js GAZGUxxfuYARksvlJiYnEyL3+n5SUZj1H8m+nTbpzUVsX6T37fpq8fTW+7TxfgPs ycnJXjxO9ILx1NSUyMaJW1uOiccA/CciZrvVklRcJNvaxobaa7LVT2vbZ2730x/x tuU58Yy7u3Adx+xteG6320FfC4AD4LUMCKP+lK/IaaO4vzfM+m1N+qvZRDw+0p/T uNUvu998q7/NeKo3eTzdn0/eqxEXAByC4zjKYbOTYRgi3+qaZpim3ZvC7b8nOC5u GbeOveP24YP+PmHLNJkQBkYFr4xA6OQLhX4DZJ5dfPb32eNtUx+bIbnXZFvoJ+RJ kY57CXkzIieT4p/JZDLQCwcwkuzeJts7f980jEajoYlwaxh2f9/prT0g/eUq5Nuw 6d8+TNNsNZtBXwuAPfDSCYRILp+f7h0IxGNNOPXj8XcadI3d2hjXexrtL67u79bu 70PenFK+tQ9Z/HbQXwGAIOmatr6+rvV23oqw1G+q1L3VBOsI4XbEbcZg2zZMU97K dgDD4+UVCIVsLtdffMtDz0jrt43ZHpK3/mBr6514sBXxePPHxK1jrL4blRMsugZG h97baisybf9YINu2nd6G227/peC7vaNItnHQ7xdtmmaHvcFAKPEqDASvMDNDH6ZY +U5OFk/D2wLz1pTyt/8cG5voTSn3el6Pi8D898x8kJB88p57JH0tQDSIxNJutQwR YvVNpmXZvf5Gm4uPt1Ygbwu0Y99Z/MHTFG4n/psxDKMZUJdvALvgJRsIUjaXE9GX TlfYxXcOI+kF5q0H8QNVGdt2csm3T+0iUfdD9cREfzq63/2r3yI7XygwEY2RILJr q9k0DcPqzbtZveC6eWSt0Euw3V6DqK2lGZu2FmX0f3mra1RgXwOiqN8fS8RgpoKB UOGZGwhMLp9PJpMTnG+EUPo2ePcXcvdOCB3btq67f2To1gdH+n/a/0BkibHNRPHt 8VS9nY39WbJvI3cve/d/Z7zXgrvfh3vzaJbJyc0l4pOT4u8mEglRJpVOk8NDS0RN TVXFB6ZpjvWe9d3eHsh+QyB329xpf0mw0/vR3fY73f55Zv1zy8a+3Vu/9UbPbf+Z jW2dxHNk84+31kowB4swE/9f0HWdXcFAeHDDAILBsmdgP7am7NxbjYLG7jietP9b t/8Gx5YewvZv4x3fve3fz63XLr7JwJ5YDg2ECvctwG+ZTCbRa3XEgyMAAHHQ7XZN wTCUnQ6+AuAnnr8BX2Wz2f5xOKRfAADi49stwbre6XSCvhYg1ngEB/xD+gUAILbI wEAY8BQO+IT0CwBAzJGBgcDxIA74gfQLAADGyMBA0HgWB6TLZDLJVIr0CwAAxm5l YF3T6IkF+I/HcUCuXC6XmJ4m/QIAgC39DGwaRrvdDvpagHjhiRyQa35+fnJqKuir AAAAoWNbVrVaDfoqgHghAAMSzczOTk9PM/cLAADu1O12DcNo1OtBXwgQIzyXA7Lk 8vlUKjU+Ph70hQAAgJByXVfTtHarFfSFAHFBAAakyGaz/cZXQV8IAAAItX5DLJpC A/4gAANSzB49mkgkWPwMAAB21+12TdOs12pBXwgQCzydA95j8TMAANg/FkIDviEA Ax7LZDLpTGZiYiLoCwEAACPDcRxVUTgZGJCNAAx4bHZ2NjEinZ/FvXbr5/3odrub X1e3u/mL3he49WUeufXL8fHxkfjaAQAjoX9e7uZHd9xddr7dbLszub0bnPiNkXhX enMhtGHU6QgNSMZzKuClXC6XSqfDufhZBF3XdcUHiampbD5/4q67Hnn00Uwmc+iC 4lYtCvbLOrfour6yvLxRqXTabcMwNtO1iM3jm0bi+QMA4D9xQxH3i27P+JEjk5OT yXS6UCgcO378vgceSKVSw7y1qijKpYsXy6VSp9UyLUv8TmhvSZsLoVW13W4HfSFA lBGAAS/Nzc+L23ZIpkD7iXRifDyby93z/e8PGXcPpx+S+3f05Zs3S6VSq9EQIVn8 zo4PHyH51gEAPLd5R3Act9vdXEnUS7nTyWQul5tfWHjokUf8vEP1I/HKzZuddtvp 3Y9Ckof7090b1WrQFwJEGc+agGfy+Xwy6N5X/dA7PT199z33/OSpp8QlBXgxu1NV VTx8rK2tNRsNVVEs0xRPIf0V1Dt+D8nGABB+/fc9e//r9tcei1tSJpudPXr0kUce KczOBn2BO2i1WmdPn15dWTEMI/AwLL5zuqa16IYFSMMDJeCZhWPHgrprbq5Ddpy5 hYVfPP/87NxcINfgIRGJl2/erFYq4glAU1XLstzeorhB2XiMeAwAPtq+Ynl7yp2Z nX34Rz+aDWXK3af6xsZ//ed/blQq48ElYfG9rayvBzI0EAc8MgLemJmZmU4m/Y9h pmnmcrl/fPHF+YUFn4cORL1eL66ubvSysSqysWlu9jg58q2xsbGtD7aQjQHgEL6N uK7b7W2a3dyXm0xmc7m5+fkHH3pIfBD0BcpVrVT+93/8R7vdTiQSPg8tvuuGrjca DZ/HBWKC50LAA9lsNpVO+/xWsYi+d99zz8+ef16M7ue4oWX0+m9VKpVmo6F0OoZh 2OLprb+seuzbttVjdyRk4jGA2NqayO1vyhV3MRH20plMoVBYOHbsB/fdNz09HfQ1 BqzT6fz5P/9zdWXF5xgs/r1oqipG93NQICZ48gM8MHv0qLg1+halxH1RhN4XX35Z PKP4M2IEbFSr5XK5trHR7i2rNk2z37+6v6Z6e0Ie6811bH1MQgYwurbP4m6uVZ6c TExNpdLpfD4/t7Bw3/33p1KpoK9xBDSbzf/4938XcdS3d7o3j0QyzXqt5s9wQKzw YAcMS2TRdCbjW+8rcUd87uc/f+TRR/0ZLibazeba2poIyZsrqxVFNwzbtt1bZzht fdqRnUIyCRlAIL5tN9XTn8IVr0tTk5PTqZS4Mc3MzMwfO3birruYxfXKpYsX//J/ /o9vU8HiX664HzEJDHiO5zZgWH4efWRZ1su//e1dJ0/6MBa2azYalfX1Wq3WabUU VTUMo7/9ePNo5VuLqru3PpmcDGBI28PtZqMp8RrSO7pWpK/pZFLk28Ls7AM//GGY W/1HUqlY/Pd/+7epqSkfxuJIJEASHsiAoeTy+VQqtdV+SepYpN+QE48p4oeIyp1O R9M0Q9fFvzK716B7c37m1n8hk5OTQV8pgMDclmzHem+TbbaYmpiYmp5O3gq3999/ f+S7TI0oPzOw+E9F3E3aHIkEeIoADAylP/279Ut5Gdgyzef/6Z8e+OEPJdWHPwzD OP23v3Xaba03jWzbtmPb7tZzsPjv59ZpT8wYA6Oin2nFP7b+v9yfsO3H2slEYnp6 OpVMpnvLkn9w331sux1117766j//1/+akr8WmklgQAYesIDD2z79u0VGbhG3wEcf e+yJp5/2vDLCSSTkG9ev9zckb7bssizbNO3eiut+M5uxbe2sCcyAV7amZ/sf99ce 9zvkif+P9Q+GnZyaSkxNTYtAK2SzhXz+7u99j322cbO0uHjxwgUfXniZBAY8xwMT cHhzc3OTOy2C8vyOmEgk3nj7bR6wMIjIyasrK61mU1VV8ahkGoZl27Zl9aeXN9dg 9z5ta25q7LvHJt95eDIwWvr/bW9l129/Z+sX/ZdlkWDFByLC9poh921Ozk5P93fV ZnO5u06e5JUW+2EYxv/41381TVP2QJuTwJa1sbEheyAgPnjiAQ4pl8ul0ulBscHD OCHur//44ov33X+/VwWB24gnueLqqq6qumHoIj+bZi8+W5sR2nG+nXnu/eyKp7He Us/urYAh/lvfljL+fqDU1v8F7mwPdmdjsP5JLdsz+Rhtw0bK9inTrV8O+rStP976 b+POQ7qP9BY1jPeXN/SI3Cr+dyu3Tk5NTU32pmH7Tt59N8EVPvvm66//93/8hw9N oTcngVW13W7LHgiICR4vgEOanZ1N7PW85ckT/PETJ3718svD1wFCRaTuRr3e/3hm dva29LL1p5qm9X/HNIx+WNqccukFKBHR+zN+355Z9V39c57lfg2Rs72vTz9t9hPo t79/5Ej/WV+8rm29+vW3s975bxCIg//v3/99rVyWPcrmmcCGUb/1gglgSARg4DAy mcw+z/4dMgOLJ/jfvv763Pz8MEUAAIDnNqrVf/vTn/bzMDAkx3FUZZPsgYA4IAAD h5EvFJLJ5D7D7aEzsG3bP/vFLx58+OHD/XUAACDV1cuX//xf/yX7fDvXdXVdbzWb UkcBYoIADBzGsePHDxRrD5eBCzMzv339dR/eWgYAAIcgoum//elPzUZD3hBbW+vX 19bkjQLEBwEYODCRS6enpw+RaQ/0VyzTfOmVV07ec89BRwEAAL4prqz8v//zf8o4 Fnh7PznxsWEYUpM2EBMEYODABp1+tE/7icHiPvfjn/zk8SeeOPQoAADAH+eWls6f Peth7/odW6lzHhLgCQIwcGALx44NuSx5z3ukqP/mO++k0+lhRgEAAD5QVfX/+e// 3avO84MOEhP1K+vrngwBxBkBGDiwg24AHmRQEcdxnnn22UcefXT4IQAAgA8uXbz4 t7/+dWJiYpgig6Lv1p+yDRgYHgEYOJiZmZnpZNKrajtm4PEjR958912mfwEAGBWb k8D/7b+5uybY3e2efvsMXW+wDRgYDgEYOJi5+XlvTzu4LQO7rvvEU0899vjjHg4B AABku3Du3NLp04fbJLWf9DvWOx9xo1o9RH0AWwjAwMEMvwF4R1sx2LKsN95+++jR o54PAQAA5KnVav/jX/916uBtMveZfsfYBgx4gQAMHIxXG4Dv1C+bTqef/cUvJnpE 0p74Ls4EBgAgtP7tT3+q12r7//z9R9+tz2cbMDAkAjBwAIVCYTqZlBSAx3rtrx54 8METJ08O+gQx9I7BeHtglnd5AABgi3uHb65dWzp9ej9bpQ4afbf+lqHrzWbzEH8X QB8PysABHD16VMZJ91ts2376ueeGbH91WzxmGhkAgD11e+7MtLdxHKf/Qf/zbyui quriX/6y5yrow6XfPss0aweZZAZwGwIwcADzCwtDnnCwu2wu9+MnnpBXv49pZABA 5O0nzd7Gk3HPLy0pnc7uFzZMfZHAq5XKMBWAmOMZFziAY8eOHZE2ferY9gMPPbTL +mc/7TKN3P9Y/ExIBgD45qBpdsiceWjlYvHa1auDVkEPf1VsAwaGxPMrsF/ZbDad ychLfbZlPfXss5lsVlJ9z20PxncmZEIyAGBHW3Ozu0/S3vanQV/1fimdzum//nXH DVOeZHJRRFXEILtNMgPYBc+mwH4VZmaSyaS8+tOp1BNPPRWxDbo7BuPt08gstwaA kbZjiN0z2QZ91RKJL3Dp9GlT17f/prdfsq7rzUbDw4JArPDcCezX3Nzc5MEP99sn cb+89/77T95zj6T6Ydbfk3xbKt7+M5PJAOCPPbPrnRE32mn2cIorK9e//nqraYjn 3yLbsjY2NrytCcQHD5TAfi0cOyZvetayrCeeeSafz0uqHwHjPeRkANjTbQ2Nb8u0 u/wy6AuPiFartfS3vyUSCUnvDoh/U5X1dRmVgTjgSRHYL6kdsMQ98unnnpuenpZU Pz62elxvZePtH7D0GsAI2Z5j+x/sM9YyKxsswzAW//IXeXcZ+mABw+D5D9ivY8eP y7uZzczOPvLYY5KKY0fi3+aOIXnH2Bz0xQIYYbctGB70wZ2/SY4dXZcuXGjU65KK E4CBYRCAgX2R2gFLPOXc+8ADJ+++W1J9DG983/pzy0wvA5GxNQ076Ofdf0mIjafi 6ur1a9fkvX9KHyzg0HhEA/bl6NzclLQOWKZpPvnTn7IBOEr2zMn9+eftH5OZAc9t z663hdL9/HLr46C/DoyeVqt15v/+38ROhyF5wrKsGn2wgEPheQvYl4WFhfFb7Rxl eOZnP5MXsDES+vPGuyTk2z7e/kHQ1w54prvNVv6885c7fnxngg36q0F8iYD6tz// WV59+mABh8ZjE7AvUjtgsQEYwzhySz8MH/SD2z4O+qvBCOjeYezWYbA7/uk+My2R FRHDNmAgnHjWAfZFagesuWPHHnzoIUnFgf3bMRJvz8Z3/ubh/jTgrzMStifPsW2x cz8fb//loN/fRXBfNDBKrl65siFtkpYADBwaTyHA3vKFQjKZlPTUbtv2g488cvzE CRnFgdDaSsWe/Hxb2R3HOtxv3pb37ox/u3/Cjr/cz8/7+QQAYbZWLl+9dGlyclJG cfE6oOt6q9mUURyINgIwsLfZ2dmEtBN6Lct6+tlnM9mspPoAAMB/Sqez+Ne/Suyg aRh1aUusgQgjAAN7m5ufl/QOrjCdTD7x9NOcNAsAQJS4rru0uGjouqT6tm1vVKuS igMRRgAG9rZw7Ji8gDq3sPDgww9LKg4AAIJy9fLljUpFUnEaQQOHQwAG9ia1A5ZI 1w/QAQsAgMi5duWKvIxKHyzgcAjAwB6y2Ww6k5HVAcuyHv7xjxcWFmQUBwAAAapU KpfPn5+Usw1YBGBVUTqdjoziQIQRgIE9FGZmpqen5c0AP/Ozn8nrkAEAAIJiWdb/ /fOfJT1AiABsGEaz0ZBTHogsAjCwh6NHj04lEpKK5/L5x37yE0nFAQBAsC6cPdtu tSQVt0yzVqtJKg5EFQEY2MP8wsLExISk4mwABgAgwqRuA3YcpyqtyRYQVQRgYA/y WkC7rnvfD39418mTMooDAIDAlYrFb776St6DBI2ggYMiAAO7yQjZrKwOWLb96E9+ cvToURnFAQBA4Gq12sWzZycnJ2UU73a7SqejKIqM4kBUEYCB3eRyuVQ6LSkAd8fG nn722enpaRnFAQBA4AzDWPzrX+X1wdJUtd1uyykPRBMBGNjNzOxsIpGQFIAz2ezj Tz4pozIAAAiJc2fOKNIOKxIBu1GvSyoORBIBGNjN0bk5eWcUzR079iAdsAAAiLSr V65sSNupa1lWbWNDUnEgkgjAwG6ktoD+/r33nrznHknFAQBAGBRXVm5evy6puOs4 FRpBAwdBAAZ2I28G2LbtR3784/n5eRnFAQBASFSr1cvnz0/I6YPFDDBwUARgYDfy ZoAt03zi6afzMzMyigMAgJBoNRpLi4tTiYSM4hwFDBwUARjYjbxDgKeTSRGAJRUH AAAh4bquCMCGrsso3u1219fWZFQGoooADOxGXgCmAxYAADEhrw9W13XXpXXYAiKJ AAwMlM/nk6mUpDOQRLR+gAAMAEAMXLtypSIpAHe7uqa1Wi0ZxYFIIgADAxVmZqan p2UEYNd173vwwbvuusvzygAAIGxKpdI3V6/KWFMmArBhGM1Gw/PKQFQRgIGBZmZn E4mEjABsWdbjTz4p6nteGQAAhE2jXj9/5syknHMlTMOo1+syKgORRAAGBpJ3BpJl mk8991w2m5VRHAAAhEqn0zn9l79IagTNSUjAgRCAgYHkdcByHOfp555LpVIyigMA gFDRNG3xL3+RdLCi67qSNhgDkUQABgaSF4DpgAUAQKxI7INFI2jgIAjAwEASA/Dx 4w88+KCMygAAIISuXb1akXNgLwEYOBACMLCzXD6fknYG0g/uu++uu++WURkAAIRQ aXX1xjffyKjc7XY1TWtzEhKwPwRgYGeFQmE6mZQRgG3bfvTHPz46P+95ZQAAEE4b 1eqX589PTk56XnnzJCRdbzabnlcGIokADOxsZmYmIecQ4M0zkJ56StT3vDIAAAin RqNx7vRpGadLiABsmmaDk5CA/SEAAzubPXpU3KVkBGBxl3qaM5AAAIiTTqez+Je/ JCSdhGSatVpNRmUgegjAwM7m5ucnJiZkBGDOQAIAIG6knoRk2/ZGtSqjMhA9BGBg ZwvHjh3p8b4yLaABAIgfeY2gOQoY2D8CMLCzfgAWH3iegY+dOHH/D3/obU0AABBy 1776qlIuy6hMAAb2jwAM7CCXyyW3nYHkbQY+fuLEfQRgAABi5puvvlqTE4A3T0JS 1Xa7LaM4EDEEYGAH+Xw++d09ul5lYNd1H3joIZGBPakGAABGhUi/165cGR8f97yy CMC6rrc4CQnYBwIwsIP/v737fWrjuhc4vCASXGqBwbiNQ1I7ed3pdKad6f//MjO9 d+507stOYjchTmNsbOxifuhHV7tokYSQhJB2JX2fZ2xMbCEpJ450PpzdPTuPHm1u bt78/ftncKPR+OOf/vRob++e9wMALJd3b9/+/z/+Ma+tgM/P3797N/N7htUjgGGI R7u7IzYquE8GX15c/Pmvf61vb099DwDAMjo5Ofm/v/99Hjsh2QoYJieAYYi9vb2N cVvVT5fBl5eXf/nb37a2tqZ6XgDAsjo9Pf3f774bO8GYQhrAjUbj7Zs3M79nWD0C GIbY399fn2CnvikauNVqpQE89PhqAGCFnZ+f/893383jHOBUs9k8ev16HvcMK0YA wxDFHkiTuFMG2wQYAMKa01bA7YydkGASAhiGuFMA5ya8vU2AASCs7//5z19nuhNS 2r3FJwIYJiGAYdDAJsCTm+RLnn3zzdODg6meFwCw3F4dHr784YdZ3VtRv/k/fPr0 yVbAMJYAhkHb29ubDx5MfannEV/YarW+PDjY29//zdbWZ3O4BgYAsJguLy8/nZ6+ PTr6+fDw/qcB96Vv19mnTycnJ/e8Z1h5AhgG7ezsfL65eZ+9jsZ+basrvV1tYyN9 uD88f767t6eKAWDZpa17/Pbtv168uDg/bzYaaaqud83k/ofWb+r87Oz9+/czeQhY YQIYBo3eBHhyUyR0I32bTN/V2u219fWNzz57/u23W1tblosBYAHli7qpF99/37i8 bLda6Xv/+tpabWNjTo94W/rmbAUMkxDAMGjv8eONGb113WcZudBqtdqdnx21LIyf PX++9fChMAaAElyF7sePL1+8aDQazWZzLQvdtdkt6k5idP0m2bfRbQUMYwlgGDTh JsCTm0kG35QfRJ3vfJC+Adc2Np59881DYQwAU8lD92Mauj/80Dl0OVvR7XZueaF7 09j0zaWzAlsBw1gCGAbtP3ky8/e5OTXwbZrNZvpm2TnHeG0tXzT+6tkzbQwAReX+ 9PJl4/KymX0rOX3f77xjzvTb37MyYf0mdkKCyQhgGPTkyZO1+Xyjt+QMvqlTxWkb Z98kztu4lrbx11/Xt7e1MQArI6/cDycnP/34Y7O3crNrT1b97CY1efoWtxfAMJYA hkHzC+BkARp4hHzduLgK13otrePPvjw4kMcALJoicX8+PEw/73x7t3vE8sKu5d7J Xes3EcAwmcWdi0Ml0th7cI9NgCexyA08QprH6VtrK3s/Xst2dKhtbDw9OHi0u5v+ jkIGYIbyvk0/eXd8/OrwsNlodC57kf3Revo2uhKJO8IU9Zt/1dnZ2QdbAcNISzkR h/m5/ybAE1rSDL5Nfsrx9QJyfsmQWu2Lp0/39vcThQxAj6Jv3x4d/fLqVecQ5ewo pFVawp3OdOlbfO3F+bmtgGG0lZqCw/092t1NO620Ol2xDB4tv2x1kr+7Z5GcTnDS TP79F1/sP3mS30YnAyy1omxTR69f//uXX1r9cZtkxxBVe1HlxXSf9C1cXlwc2woY Rgo0+YZJ7D1+XKvVSu7SUBk8Vn4qcpIvJmeDk5+QvFGrPfnd7/L15EQqA5SoN2vf Hh29/vXXRrOZn3ZbvFYnsVdu72Mm6ZuzFTCMZdoNfR7v79fW15MqilQG30l+xPXV acn51KHYrTGr5TSVLSwD3GZgqTbN2rxpW92mvTpUp1u21mznYYbpm2s2m2+OjmZ7 n7BiTLihT2cT4CJEZfAKyS/i1U7ypeV2Z5TzKV36o1ZLf+zu7v7+6dPi9poZWCK9 NZv696tXx8fHrTxou1dnaCfdE2yzT9ZHHu408zBjwJxGuNVqHb1+PY97hpVhqg19 0gBeG5gRyOBVNHaE+y7rVWRz9lWduWNnN8mrc5h3dnaeHhwUX6icgakNdOyrw8P3 79/n59C2slelvJnaxdpst2nz16SZPAfpO29zHWE7IcFYJtnQJw/g/PPr/z0qylEZ XIKZD3I+sxmI5+LP8sdby6aq6cdadiWYh/X6l1991XsnKhqWzkC7pn7+6aePHz6k rwadSxznrwl5wWYvBfltBiI2qe6VX/eWoIRBtgIMY5leQ5/eAE40cBiLNs69FZ2f 4dy+EdJJcTTj1anPnare+u1vv3727OYdKmoYcLNXcz++fHn6n/+08mNAut/JKs6J 7Q3Xns8qbtd7kr7lKGec07+0rwUwjLSUr9QwJ/V6/cGDBzdbVwYHscLj3FfU+fGT WVQn3X/O/25fHVeZdNu6Z7E6P8Ay/R/kD8+fD30Ijc0M3VanqX+9eHF2dtbuDdRs WbU4zbU4W6E45iL/2O5Zbl3qXp0t9VuCMgc5fayzT58+fPhQ2iPC0vHSD9e2t7c3 0wAexlnBQRjnqRWNXfUTKdu8p7YB/06q03JI33KUPM7pw52fnZ2cnJT5oLBcvLvA tZ2dnc83N0fcwFJwEMYZWGHStxyVjHP6oBcXF+/fvSv/oWFZmOTBtUe7u2OP4bQU HIehBlaP+i1HNeOcPWrj8vL4+LiCR4clYXoH1/YeP67VapPc0lJwEMYZWBnStxyV jXP3iomtZvPNmzfVPAdYBuZ2cG3gEtCjWQqOw1ADS036lqba+k26WwbYCQlGMKuD a3cK4GQBGjjRZiUy1MDSkb6lqTx9k/za/gIYxjGfgyv1en3zwYMpIkcGR2O0gQWn e8u0OOlb/P7Z2ZmdkOA2pnFwZXt7+/PNzanbpvKzghNhVjoDDiwU3VuyKge855jn m+yEBCOYvcG1+vb2eto061futRosgyMx5kCFdG/5Fi190+fTynR+abc/qF+4nUkb jPKwXu8U8R2rWAaHZdiB0ujeSlSevunPZrOZdW47z92PjnaGuzBXgztLq7jTwSOr eBFODE70WHWMPDAnurcq5Y98p3Cz1m1pXZgdUzSYjaFVvCAZnOix6hh5YCZ0b4VK GPz0IazrQjnMzGC+bp5XXGERibGqGHlgatK3QvMY/FaX83WhEuZkUIF6vb623tvF 01xwa2pirCpGHrgT6Vuh+w/+wIWp0o+2JoJFYDYGi6LvIOr0Q62WfpzTgdNKrEIG HxhL+lZoisHvXdRtZ7QuLCzzMFh09exK1AMrxjO5ZyVWLeMPDNC91Ro7/n0ruhZ1 YTmZfsGyuloxzsO4G8fT7F0swypl/IFE+lZtYPybzWb3WlRCF1aNiResoOtzjHtW jUfcXoNVzn8CCEv6VmLwBF2VC2GYckEsRRt3zzVeK9aNNVjl/CeAaNTvXF0lbu9i rsqF8Ey2gCvXV+Hq9nGRx8KsNIYagpC+M9F7jeV2l010gRHMtICJ5Hmc9AVy3wIy M2RIYYVJ38l1V217DlROR89lloF7MMcCZuNmIfdGctXPbomJYVgBoneoYvH2evU2 61tLuMD8mFcB5cm3dBqIZAdaT84QwRKJHL3XK7f9LN4ClTOXAhbOkMXk9NWq59pd VT/BhSCGYQGtfPTebNqrss3+yLItsPjMn4Aldp3KSXJzYbknn1fZyv8LwuJb3u4d WrP5v44FW2AlmTYBgfQeg50UyZwMieeqn+mUlveZw9JZwOgdcrxx9zcTQQuQMVUC GGNwnTnpBnOyuOW8OM8EVkwJ3XtbxybXIZu4UhTAdMyQAObo4cOHnZOWe9s56avo ZFhNz/AJKGGYiQm7d+AQ4r6l1557ufo1u0zUx48f5/WkAbjBxAhgCfSFdOdn/ycD i9PJ8Lqu6snDYhqxvloEam+19n4iXAGWlPkQQFBXUZ305HRyI62T4Y1986PAZrb6 lk9v/zi0Tjsfej4XqwAUzFcAYHpbW1tzvf/T09O53j8AhCKAAQAACEEAAwAAEIIA BgAAIAQBDAAAQAgCGAAAgBAEMAAAACEIYAAAAEIQwAAAAIQggAEAAAhBAAMAABCC AAYAACAEAQwAAEAIAhgAAIAQBDAAAAAhCGAAAABCEMAAAACEIIABAAAIQQADAAAQ ggAGAAAgBAEMAABACAIYAACAEAQwAAAAIQhgAAAAQhDAAAAAhCCAAQAACEEAAwAA EIIABgAAIAQBDAAAQAgCGAAAgBAEMAAAACEIYAAAAEIQwAAAAIQggAEAAAhBAAMA ABCCAAYAACAEAQwAAEAIAhgAAIAQBDAAAAAhCGAAAABCEMAAAACEIIABAAAIQQAD AAAQggAGAAAgBAEMAABACAIYAACAEAQwAAAAIQhgAAAAQhDAAAAAhCCAAQAACEEA AwAAEIIABgAAIAQBDAAAQAgCGAAAgBAEMAAAACEIYAAAAEIQwAAAAIQggAEAAAhB AAMAABCCAAYAACAEAQwAAEAIAhgAAIAQBDAAAAAhCGAAAABCEMAAAACEIIABAAAI QQADAAAQggAGAAAgBAEMAABACAIYAACAEAQwAAAAIQhgAAAAQhDAAAAAhCCAAQAA CEEAAwAAEIIABgAAIAQBDAAAQAgCGAAAgBAEMAAAACEIYAAAAEIQwAAAAIQggAEA AAhBAAMAABCCAAYAACAEAQwAAEAIAhgAAIAQBDAAAAAhCGAAAABCEMAAAACEIIAB AAAIQQADAAAQggAGAAAgBAEMAABACAIYAACAEAQwAAAAIQhgAAAAQhDAAAAAhCCA AQAACEEAAwAAEIIABgAAIAQBDAAAQAgCGAAAgBAEMAAAACEIYAAAAEIQwAAAAIQg gAEAAAhBAAMAABCCAAYAACAEAQwAAEAIAhgAAIAQBDAAAAAhCGAAAABCEMAAAACE IIABAAAIQQADAAAQggAGAAAgBAEMAABACAIYAACAEAQwAAAAIQhgAAAAQhDAAAAA hCCAAQAACEEAAwAAEIIABgAAIAQBDAAAQAgCGAAAgBAEMAAAACEIYAAAAEL4LyMC H4FMU3sLAAAAAElFTkSuQmCC"/></symbol><use xlink:href="#c" width="1280" height="1280"/></g></g></svg>')} +.is2d .bishop.black {background-image:url('data:image/svg+xml;base64,<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="614.635" height="614.635" viewBox="0 0 460.977 460.977"><mask id="b"><use xlink:href="#a" width="1280" height="1280" transform="rotate(.193) scale(.36014)"/></mask><symbol id="a" viewBox="0 0 1280 1280"><image width="1280" height="1280" xlink:href="data:image/png;base64, iVBORw0KGgoAAAANSUhEUgAABQAAAAUACAAAAAA9j6ArAAAACXBIWXMAAA7EAAAO xAGVKw4bAABGJUlEQVR4nO3dB3xUdaK38bzZiDRDMTQREFFU1EVlEUXE3kBpXiys YFlRirpi74Bi7wqCveBacFWwN1REXRQLFhCQ3kvoJVERXwwgKZNk5sw55/cvz/fe z91dN0yezzDzu8nMmXP+XwYAeOr/qQMAQIUBBOAtBhCAtxhAAN5iAAF4iwEE4C0G EIC3GEAA3mIAAXiLAQTgLQYQgLcYQADeYgABeIsBBOAtBhCAtxhAAN5iAAF4iwEE 4C0GEIC3GEAA3mIAAXiLAQTgLQYQgLcYQADeYgABeIsBBOAtBhCAtxhAAN5iAAF4 iwEE4C0GEIC3GEAA3mIAAXiLAQTgLQYQgLcYQADeYgABeIsBBOAtBhCAtxhAAN5i AAF4iwEE4C0GEIC3GEAA3mIAAXiLAQTgLQYQgLcYQADeYgABeIsBBOAtBhCAtxhA AN5iAAF4iwEE4C0GEIC3GEAA3mIAAXiLAQTgLQYQgLcYQADeYgABeIsBBOAtBhCA txhAAN5iAAF4iwEE4C0GEIC3GEAA3mIAAXiLAQTgLQYQgLcYQADeYgABeIsBBOAt BhCAtxhAAN5iAAF4iwEE4C0GEIC3GEAA3mIAAXiLAQTgLQYQMapca+/qjSrWL/6o +2N+/uyVE5eulzTBZwwg4tF4rzr1d9o5p3HF6gn/65X5M3PnLZi/+KeZMXfBawwg IpfTrGGtRv/YPbtiuV+Zv/rnr2YvnTMpN4YqgAFExKo3brL7gQc0TOnPzPnmy5+n z1wZURGwDQOI6DRosOcRBzYN9EenfvnR5LlzQ+4BimEAEZH6jfc5pXnNNG5g+Xcj fpw5P7QeoCQGEFGoXbdVt8NDuJ2Pn/ti0ZIQbgdIiAFE6CrXa9arTXZIN7b602GT FnKADKLBACJk2Tv1OG/HUG9x2SPPLFgd6i0CmzGACFNmhf3uODSC2x17xYRfN0Zw u/AcA4jwZGadOrBxRLc9s/+LG5hAhIwBRGhqXtKnRoQ3v+Khe5ZHePPwEQOIkFS+ +6zyP+qRnvynLuXtEISJAUQ4hvaK5dsM6x3Lt4EnGECE4aYLEp/jIHwrB18f03eC BxhApO/UIeEe91K2ZX1fjPG7wWkMINLVcvgeMX/HKd3Hx/wd4SgGEGka2VHwTUd1 EnxTuIcBRFo6PZoj+b65PUdKvi/cwgAiDbVfPCjqQ19Kkz/uVM6SgHQxgAiu2/2a H/82y/33c8LvDicwgAgq+9WDK0kD8v7XmXMkIC0MIALqeHcTdULG9EtHqRNgNQYQ wdx3zg7qhE3WPHGxOgE2YwARRNNH26oTtvik51R1AuzFACKAk+4KdqmjKEy97HV1 AqzFACJlFS66vLa6oZAldz7wq7oBlmIAkaqat3bXvvtbXN7wqzlRIAJhAJGixvcq PvtWtlH9ZqoTYCUGEKlpe08LdUICX1/yiToBNmIAkZKWI3ZRJyQ06xROEIPUMYBI xVFP7axOKMW8s0arE2AfBhApOP3RKuqEUq3r+bw6AdZhAJG8rk9VVieUYf1ZL6kT YBsGEEnr8h/Vua+Sk//PV9QJsAwDiGSd9Jq6oFwd+FAIUsIAIknt31AXJOHEN9UF sAoDiOQc/7a6ICknvKMugE0YQCRlnx/UBUna90d1ASzCACIZNafHdeHzdK1swueC kTQGEEnImVZNnZC0VbvlqhNgDQYQSZi+q7ogBTP0p+qHLRhAlCvzm+bqhJR8d8BG dQIswQCiPJk3X6VOSNFt17KASAoDiPJYcQBgURwOiOQwgChHk2nqggB2m64ugBUY QJSt9g8mXf8jWUv2XaJOgA0YQJSp5oij1AmBjD6FwwFRPgYQZcm6rr86IaCBgzao E2A+BhBl6fS82WfAKl3+6SPVCTAfA4gy7PlWY3VCYDPbTVYnwHgMIEpXeWgPdUIa num9Xp0A0zGAKF2/e9QFabnkXnUBTMcAolStX66rTkjLopM/VyfAcAwgSpP97Enq hDS9fsZqdQLMxgCiNJfdqS5I2+V3qQtgNgYQpdj/habqhLRNPe1bdQKMxgCiFCO6 qgtC8NIp6gIYjQFEYqcPqaFOCMGKvs+rE2AyBhAJVf2wpTohFOOPXKtOgMEYQCR0 25XqgpDcbtvZXBEnBhCJ1BvXUJ0QkjkHLVQnwFwMIBJ5pru6IDTDbf44HyLGACKB NqNqqhNCs7zjp+oEGIsBRAIf2HkW1MRGH60ugLEYQJR00FsuHAKz1Yp249QJMBUD iJI+OlxdEKqPj1AXwFQMIEpo+X41dUKoVh0zXp0AQzGAKGFMW3VByD45TF0AQzGA KG7/T6qqE0K2ti3nREBCDCCKe+50dUHonu+mLoCZGEAUk7ncrVcA/7Sq5kZ1AozE AKKYBy5UF0TgwYvUBTASA4hiFtdWF0RgSR11AYzEAKKojm5eT7zTKHUBTMQAoqhv 9lcXROLbA9QFMBEDiCKqL9penRCJX+quVCfAQAwginj4PHVBRB45X10AAzGAKCJ3 R3VBRJblqAtgIAYQhTWbqC6IzN6T1AUwDwOIwl7uoi6IzCsnqwtgHgYQha1x7WPA 26zdQV0A8zCAKKTNWHVBhA7l1PgojgFEIaM6qAsi9FpHdQGMwwCikOUunQq/uBXu XOgJYWEAsU2DOeqCSDWcqy6AaRhAbDO4r7ogUkMuUBfANAwgtvl5N3VBpKbtri6A aRhA/KXCL+qCiG3/q7oAhmEAsVVmmzHqhIgd9iknhkYRDCC2ynq8hzohYs/8a4M6 AWZhALFVhamN1AkRm92U34FRBAOIraquURdEboe16gKYhQHEVq0/UxdE7pDP1QUw CwOILSo+eK46IXKPXZivToBRGEBskf1Jc3VC5L5ru1qdAKMwgNii5vTq6oTIrWyy XJ0AozCA2KL2YnVBDOosURfAKAwgNss8yc0LAhfV6XUOhUYhDCA2q3jD1eqEGNx6 I++CoBAGEJtVf+UIdUIMPurC5YFRCAOIzep/78P5Qpf/fb46ASZhALFZo8kV1Qkx yN9ztjoBJmEAsVmTaeqCWOw2XV0AkzCA2Oywj9UFsTjc9VN+ISUMIApk/WuYOiEW vR7njFjYhgFEgcrXXKtOiMXNt6xXJ8AgDCAK5Dx5ojohFm+cnatOgEEYQBSoN6ql OiEW4zsuVCfAIAwgCjQeW1+dEIv5h85UJ8AgDCAKNPvah8MAMzLyW0xSJ8AgDCAK 7PlVFXVCLNb9Y7I6AQZhAFFgnx/UBTHZ90d1AQzCAKJAyy/VBTE5cLy6AAZhAFGg 1Th1QUwO+kJdAIMwgCjAAMJHDCAKMIDwEQOIAgwgfMQAogADCB8xgCjAAMJHDCAK MIDwEQOIAgwgfMQAogADCB8xgCjAAMJHDCAK8FE4+IgBRAFOhgAfMYAowOmw4CMG EAWafVVJnRCLvH9wQlRswwCiQOMxDdQJsZh7GKfExzYMIArUe7WVOiEWX3TmokjY hgFEgZzHOqoTYjHqXC6LiW0YQBSofEV/dUIsBt7BhdGxDQOIAllnPapOiEXPpzao E2AQBhCbtRmrLojFoZ+qC2ASBhCbNZ6hLojFrrwJjEIYQGzW6CcfDgTM22u2OgEm YQCxWb3vaqkTYrC0OUfBoBAGEJtlv3CCOiEGb5+2Wp0AkzCA2KzClTeqE2Jww+2/ qhNgEgYQm2Ue/a46IQbHfbBRnQCTMIDYouYydUEMdlyuLoBRGEBsUXNKjjohcrl7 MIAojAHEFtnvH6hOiNyXx/AeCApjALFFhVsuVSdE7u5reA8EhTGA2Orv36kLItf8 e3UBzMIAYquKeeqCyFXKVxfALAwgtqowYS91QsR+2o/fgFEEA4itsu7op06I2L1X cC4sFMEAYqvMfVx/EbD5jxwGjSIYQGzzhzogYjzaUQwPCWzzzf7qgkh9e4C6AKZh ALHNNTerCyJ17S3qApiGAcQ22avUBZGqxsdAUAwDiELm76QuiNCC+uoCGIcBRCFD e6kLIjSst7oAxmEAUcjuU9UFEWr6s7oAxmEAUdiiOuqCyCyuqy6AeRhAFHbnZeqC yNx1uboA5mEAUVjOUnVBZGrlqgtgHgYQRUxroi6IyPTd1AUwEAOIIvrdoy6IyCX3 qgtgIAYQRa3KVhdEYnU1dQFMxACiqFc7qQsiMbKzugAmYgBR1D7jK6oTIpDf8kd1 AkzEAKKYSS6eF/qnZuoCGIkBRDHnPK4uiMC/nlAXwEgMIIqb1UhdELrZu6gLYCYG EMX1H6AuCN2AgeoCmIkBRHF1vnPtA8GLmy9WJ8BMDCBKeMi180YN7aMugKEYQJRQ +xu3Th06/4Al6gQYigFESQ9eoC4I1eAL1QUwFQOIkup84dIbwbNb8QogSsEAIoH7 /q0uCNH9F6sLYCwGEAnU+2gPdUJophyxUJ0AYzGASKTvnZXUCSHJu3yIOgHmYgCR SNaY1uqEkHx+2AZ1AszFACKhLo/WVCeEYnnPV9QJMBgDiMSeOlNdEIqnz1IXwGQM IBJr9vKe6oQQTD55kjoBJmMAUYorblcXhODKO9QFMBoDiFLUfLKDOiFtr529XJ0A ozGAKM1hz+2kTkjTgm5j1AkwGwOIUl1zs7ogTdfeoi6A4RhAlKr2s8eoE9Ly/hmc BQZlYwBRulYv7KJOSMOs075QJ8B0DCDKYPUFkrgQEsrFAKIMVR/qrk4IbHifteoE GI8BRFkajNpfnRDQtx3nqhNgPgYQZWr7qp2fCV7e+RN1AizAAKJs5w9TFwTS62F1 AWzAAKIcVl4jjuvAISkMIMrznn1HA75/rLoAdmAAUZ6a/2uqTkjR1IP5CDCSwgCi XC0+rqpOSMnaw79WJ8ASDCDK1/OBiuqEFORf9Kg6AbZgAJGEq206q8A1t6oLYA0G EMm48zJ1QdLuulxdAHswgEjK4L7qgiQNuUBdAIswgEjOyI7qgqSM6qQugE0YQCSn 6nAbpmVkd86AgBQwgEhS9qjD1Qnl+rjjanUCrMIAIlkW/BLML8BIDQOIZOWZfzBg fiV1AezCACI559y3gzohCWsu5jTQSAEDiGQc8czO6oQkzevxkToB9mAAUb76L7dS J6Tgi5PnqxNgCwYQ5cl67Ex1QoqePneDOgF2YABRjr53VFYnpGz9FUPUCbACA4gy tX6hgTohkLmnfa5OgAUYQJSh9stt1AmBfXryEnUCjMcAolSZQ3qpE9IyrO9GdQIM xwCiNB2fqq5OSNPKs0apE2A2BhCJ1X7NpkNfSvNFB34PRhkYQCR025XqgpDcfpW6 AAZjAJFAy9fqqhNCs6jDeHUCjMUAooSs/5yiTgjViH9yXDQSYwBRXKfhdl0Fs3xr u49UJ8BMDCCKqvzWYeqECIxpt16dABMxgCji1CfdPKVe3tkvqhNgIAYQhbj5499m /BCIkhhAbNPlWTd//Nss74xX1AkwDQOIrbJe7qBOiNhrJ/N2MIpgALFFq7drqBMi t+KEL9QJMAoDiM0euFBdEIsHL1IXwCQMIP6U81lTdUJMph6Sq06AORhAbNLpVXVB jDpzVDS2YgCRkfFMd3VBrIb3UBfAFAwgan/ZSJ0Qs9kHcpIsFGAAvXfUGxXVCbHL P3G0OgFGYAB9N6C/ukBi4AB1AUzAAPot6/3D1QkiHx/DQdFgAP1W+9ud1AkyC/bn hUAwgD5r8Yl91zwPz/q2X6sToMYAeuyM4eoCse7PqgsgxgD6687L1AVyd12uLoAW A+itEV3VBQZ4ya2rnyBVDKCnMse2VicY4fNDN6oTIMQA+qnid76c/KA8U5vnqxOg wwB6qeakOuoEYyxutlydABkG0Ee1J7t/7tPkrdiTAwK9xQB6qP7EauoEo6zae746 ASIMoH8a/bCDOsEwa/adrU6ABgPonUYTq6gTjLNubxbQTwygb+pPYf9KWrcHvwV7 iQH0TM3p1dUJRlrZhPeCfcQA+qXyzNrqBEMtabxenYD4MYBeqfBzQ3WCsebs/qs6 AbFjAL3y497qAoNN3EddgNgxgD4Z1UFdYLTXOqoLEDcG0CO3XqUuMNxtV6sLEDMG 0B9nPqUuMN5ZT6sLEC8G0ButxqkLLHDQF+oCxIoB9EXVhVXVCRZYW2+tOgFxYgB9 8f2+6gIr/PB3dQHixAB6YnBfdYElhlygLkCMGEA/dBypLrBGp1HqAsSHAfRCzlJ1 gUVq5aoLEBsG0At8AiQFfCLEIwygD/oPUBdYZcBAdQHiwgB6oNEsdYFlduH0qL5g AD0whUtgpmbqHuoCxIQBdF+/e9QF1rnkXnUB4sEAOq/qGnWBhXbgAyF+YACd985x 6gILvXu8ugCxYABdt88P6gIr7fujugBxYABdN2kvdYGVfmqmLkAcGEDHHfOeusBS x76vLkAMGEDHzWisLrDUzF3VBYgBA+i2Y99VF1jrOH529gAD6LaJvJQV1CQ+P+0B BtBpzSaqCyy29yR1ASLHADrt3WPVBRZ7jwMo3ccAuizrN3WB1bbboC5A1BhAl115 m7rAalfdri5A1BhAl03dXV1gtZ85i47zGECHZa9SF1iu2mp1ASLGADrs+hvVBZa7 4SZ1ASLGADrsm/3VBZb79gB1ASLGADosf3t1geV+qaguQMQYQHc1naIusN4eU9UF iBYD6C5eAkwbLwK6jgF014dHqAusd9fl6gJEiwF01+yG6gLrvXGSugDRYgDdtbaK usB6vA3sOgbQXX+oA+w3r4G6ANFiAJ3FmRDSt3xHdQGixQA6q/48dYH9VtZQFyBa DKCzWn6pLrDf6jr56gREigF0FgOYPgbQdQygszgdfvpWVVcXIFoMoLMazFEX2I/X AF3HADor83d1gf2W1lYXIFoMoLs4DjBtU/dQFyBaDKC7ltVUF1jvszbqAkSLAXQX 50NN2+PnqgsQLQbQXff9W11gve7PqgsQLQbQXa0/UxfYbnX9teoERIsBdBjvgqRp GpcVdR0D6LBxrdQFlhvWW12AiDGADjvncXWB3da3+VadgIgxgA7jUOj0cBSg+xhA lz37T3WB1S65V12AqDGALqu5TF1gs4U7qQsQOQbQaW+doC6w2M3XqQsQOQbQadVX qAvsNXNXdQGixwC67Q4ubBvUaS+qCxA9BtBx83khK5gPjlEXIAYMoOOaTFMX2Gn+ zuoCxIEBdN3FHMsRwPp2Y9QJiAMD6LzhZ6gLLMQhgJ5gAN336SHqAusMuUBdgHgw gO7L/G4fdYJlnu+mLkBMGEAffNZaXWCVoX3UBYgLA+iFUR3UBRa5sb+6ALFhAP1w 9S3qAlus7vamOgHxYQA90frdquoEK0w9dIk6ATFiAH1R8b/t1QkWuP0qdQFixQD6 o91wLhRcth9PnqpOQLwYQJ/0v3p7dYLBFl/4kjoBcWMAvVLxvvPVCaZaNug+dQLi xwB6JmtQ72x1g4HmDHxCnQAFBtA/Hfvvr04wzOv9ufybpxhAH1W9skdDdYMxJjzI D3/+YgA9Vbtfl6bqBgOMG/5EvroBQgygv7JOOfWg2uoIoVkfPjda3QAxBtBvFU7u 2GoXdUT88maM/S/jBwYQmzQ4+fAW/pwBfuoX77+5XB0BQzCA+NMz3dUFsbl+kLoA 5mAA8aeFddUFsfmylboA5mAAsUn2KnVBfNZwIDj+wgAiw7PTBXYeqS6AMRhAbDKh ubogRq92URfAGAwgNvlDHRCnxf683onyMIDIyOjo1y+Fe3DWP2zBACIj460T1AWx uv9idQFMwQAiI2OVX2+MTt5LXQBTMIDIaDJNXRCvvMrqApiCAUTGQ73VBTG76EF1 AQzBACJjViN1QczGHK4ugCEYQFTMUxfEbWUNdQEMwQDiwgfUBbE79n11AczAAGKc f2cHeNafk9+gTAwg8v27WPAc3171RCkYQO+1GasuEKiVqy6AERhA743oqi4QGHS9 ugBGYAC9tzRHXSDwTQt1AYzAAPqu9mJ1gcK6quoCGIEB9N2tV6kLJHoMVxfABAyg 7ybvoS6QeKu9ugAmYAA9l/WbukAjt5a6ACZgAD135lPqApEDx6sLYAAG0HNj2qoL RB7rqS6AARhAv/UdrC6QOfIjdQH0GEC//bSnukDmjZPUBdBjAL2W+bu6QGdpbXUB 9BhAr53h89FwB3yrLoAcA+i1z1qrC4SePEddADkG0GteXRC9uLkN1QWQYwB91v4N dYHUbtPVBVBjAH32/tHqAqnBF6oLoMYA+myd3xfInb6bugBqDKDHDvtYXaCVv4uX pwJDIQygx95spy4Qu/sydQHEGECPra2iLhCb6uepwLANA+iv1p+pC9Ty6y9XJ0CL AfTX6yeqC+TuvEJdAC0G0F9ruC7GFH/PBYECDKC3Wo1TF+jl1V2tToAUA+itkR3V BQa49Rp1AaQYQG+t3kFdYIBJe6sLIMUA+qrFV+oCE+TlrFcnQIkB9NUrndUFRhh0 vboASgygr/gNuAC/A/uNAfRUm7HqAjPk7cyx0D5jAD3l/eeAt7rrcnUBhBhAT62v pC4wxLTd1QUQYgD9dPzb6gJT5Dedq06ADgPopw+PUBcYY8gF6gLoMIB+8vpqSEXN aqwugA4D6KX/e0ldYI78/SerEyDDAHrJ6+sBF/f4ueoCyDCAPsr8XV1gknkN1AWQ YQB91PMRdYFRDubEYN5iAH30wz7qAqP8t6u6ACoMoIeqrlEXmGVZjroAKgygh265 Wl1gmG7PqwsgwgB6aF59dYFhxhyuLoAIA+ifxjPUBaZZk60ugAgD6J9nuqsLjHPl HeoCaDCA/llZTV1gnO+bqwugwQB6p+0YdYF58hrmqhMgwQB654Oj1AUGuv9idQEk GEDf8DG4RGbvoi6ABAPom15D1QVGOvRTdQEUGEDfTGmqLjDSax3VBVBgAD1Te7G6 wEwraqoLoMAAeuZRTn6X2EUPqgsgwAB6ZkV1dYGhJuyvLoAAA+iXIz5UF5hqfeMl 6gTEjwH0y9g26gJjDeutLkD8GECvZP2mLjDX/J3VBYgfA+iVq29RFxis/VvqAsSO AfTK7IbqAoO9f6y6ALFjAH2y+1R1gclW8Qa5fxhAn4zqoC4w2qDr1QWIGwPoEc6D ULaZu6oLEDcG0COX3qUuMNyx76sLEDMG0CNzGqgLDPfBMeoCxIwB9Mc+P6gLTLem +kZ1AuLFAPrjXQ7zKM9dl6sLEC8G0Bt8CqR8cxqpCxAvBtAb192kLrBAh9fVBYgV A+iNhXXVBRYYc7i6ALFiAH3R4it1gQ3W1spXJyBODKAvPjlUXWCFIReoCxAnBtAT 2avUBXZYVE9dgDgxgJ4Y2ktdYIleD6sLECMG0BNrqqoLLPF9c3UBYsQA+uHsJ9QF tsg75Ft1AuLDAPphRmN1gTXeOEldgPgwgF7Yj59qkrYqZ4M6AbFhAL3AxeBSwJEw HmEAfVB9hbrAJhwJ4xEG0AdPnK0usMpFD6oLEBcG0AOZ6yqqE6wyeS91AeLCAHrg ytvUBXbJ7/ieOgExYQA9sDRHXWCZzw9RFyAmDKD7urysLrDNuubT1QmIBwPovp93 UxdYZ2RndQHiwQA6j4OgU8fB0L5gAJ33v4PUBRYa1ltdgFgwgK6rP09dYKOltdUF iAUD6Lo32qsLrDToenUB4sAAOo4zQQczr4G6AHFgAB331JnqAkvxeTgvMIBu42ro Qa3dQV2AGDCAbrvzMnWBtUacqi5A9BhAp2WuqaxOsBfPDQ/wl+y0/gPUBRYb3kNd gMgxgE5bzQtZaeDJ4T7+jl3W7x51gdUeP1ddgKgxgC5bVlNdYDeeHc7jr9hhfYao Cyz3yPnqAkSMAXQYPwCmi6eH6/gbdlfPR9QF1hvaR12AaDGA7uJM+Onj+eE4/oKd de6j6gIH8COg4xhAZ/EDYBh4griNv19X9R2sLnACxwK6jQF01Yrq6gI38AxxGn+9 jrridnWBI95upy5AhBhAR62pqi5wxd82qgsQHQbQTQP6qwucMZ3LKjuMAXRS1upK 6gR37D1JXYDIMIBOmtVIXeCQPE4q6y4G0EV7/qQucMrAAeoCRIUBdNGSWuoCp/xR d4k6ARFhAB3Uapy6wDHf7acuQEQYQAdxDHTYznlSXYBoMIDuOf5tdYFz8ndcr05A JBhA96zjXcvQjT5aXYBIMIDO4TyoUTjhHXUBosAAOucPdYCTVuVsUCcgAgygawZd qy5w0/Pd1AWIAAPomMzf1QWO+qPl1+oEhI8BdMyLp6gLXLWonroA4WMA3VJ9hbrA XXdfpi5A6BhAt3zZUl3gro27zVQnIGwMoFOaTVQXuGzqHuoChI0BdMq8+uoCp/V9 SF2AkDGALjn1BXWB08acuFadgJAxgA7JXMt5oKOz5p+vqxMQOgbQIQ9cqC5w1x8j zuCjIA5iAN2Rs1Rd4K5FHcarExAFBtAdY9uoC1y18f5L1AmIBgPojLZj1AWumno8 BwC6igF0xqI66gI3/XblveoERIYBdEX/AeoCN41rv1ydgOgwgI7gQ8CRWPevF9UJ iBID6IjRR6oLXPRa11/VCYgUA+iGNmPVBQ5a2uVTdQIixgC6YWFddYFzNj54sToB kWMAnXDTdeoC50xux7EvHmAAXVB7sbrANb9cOkSdgDgwgC4Y/w91gWM+6rRanYBY MIAO4CxY4Vp+2vvqBMSEAbRf1soq6gSXbHyIk+r4gwG0HxeCC9OPJ85WJyA+DKD1 Wn6pLnBIXt8n1QmIEwNoPU6CEJo/RnbLVzcgVgyg7e7ppy5wxuwTf1QnIGYMoOUa z1AXuGLjlXepExA7BtByM3dRFzjif4dz3gMPMYB2u5SfWkKxpjW//XqJAbQan4EL xR8DB6oToMEAWm36ruoCF0xoyRUvfcUA2qzfPeoCB6w/+Ht1AmQYQIvVXKYusN8f t1+tToAQA2ix+TupC6w3uTnv/XqNAbQXZ0FN17wO36oToMUAWot3gNN1Y391AdQY QGut3kFdYLev2i9RJ0COAbRV38HqAqut6/m8OgEGYAAtVWeRusBqr57Gmx/IYACt 9ePe6gKLLek4Tp0AMzCAdrryNnWBxe7jDGLYggG0EifBCm7KCVzwF1sxgFaa1Uhd YK1/P6AugEEYQBs9eIG6wFZjO6xUJ8AkDKCFWvESfjBruo9SJ8AsDKB9spbUUCfY 6YXunPYKRTGA9hnZUV1gpQUn8sFfFMcAWqfLy+oCK93Gaa9QEgNom+oLK6oTLDTp +LnqBJiIAbTNhObqAgtdMERdADMxgJbpP0BdYJ9PT+LYFyTGANplnx/UBdZZ1+MV dQKMxQBaJXNRLXWCbUaeynlfUCoG0Covd1EXWGZ550/UCTAZA2iTriPUBZZ58tyN 6gQYjQG0CFcBSc3CdhPUCTAcA2iRqburC6zCaf9QLgbQHoP7qgtsMvO4n9UJMB8D aI0jPlQX2GTQ9eoC2IABtEXVRVXUCRZZyzVDkQwG0Bbj/6EusMkPf1cXwAoMoCUG 9FcXWGVUJ3UBrMAA2qHFV+oCu9x9mboAVmAArVBhSTV1gl0uelBdACswgFYY01Zd YJlTXlIXwAoMoA363aMusM2RH6kLYAUG0ALNJqoLrHPop+oCWIEBNF/Woh3VCdbp xPUvkQwG0HwfHKUusM95j6oLYAUG0HgX3a8usNDtV6kLYAUG0HScBD+I/3ZVF8AK DKDhshbXVCfY6HuunYdkMICG+/AIdYGVVqj/38ZlG+4TFyAZDKDZLr1LXWCp7aO7 FFJm+afZP2jofrnHfx1ZAULDABptv2/VBbbq9nx0t521oZwveKj3pv8zcZ/oChAW BtBkFRZXVyfY6s0TZd+64o9NCv6VM9JYgAE02Wet1QXW0r0I+Pevttvy764fpGpA shhAg11/o7rAYrtNj/DGy/gluNCJG5d1+DzCBoSBATRXq3HqAps9fm6Ut17aAmZ+ tX+h/zS5eXRvxSAUDKCxKi/iuhZpkPwOXH9y1SL/WfhKJJLCABrrqxbqArsJTgjT 6ZXizycuTmc4BtBUt12pLrDc54dEevMV80v8o6d7lPhHK7qOjrQCaWIADcVVgNNW bXWkN198AatObJjgq34+YG2kFUgPA2im6gsqqROs98j50d5+0QVsMS4r4Vd9cEy0 FUgLA2imn/ZUF9gvv0r5n1kLzcAbSvtvuECdyRhAIw2L+IcXP9x8XbS3X/Wv324z vyz9HatVZ42MNgNpYABN1JGnTBjWRn0cUfaWVxnrTM0u46tmHrQk4g4ExgAaqM4i dYEjBg6I+Btsfhnw2HfKfhp9cljEGQiMATTQrEbqAkesy47jVcDBfcv7iqF9YshA EAygeZ4/TV3gjDuviPgbVF9Z4Yem5X7V2t7PRtyBgBhA43R/Rl3gkEolD1cO1/89 u30SXzX3sJkRdyAYBtA0jWeoC1zyfLdobz/ZE5aNOzjaDgTEABomc35ddYJTGs6N 8MYrzs1J9kufPCfCDgTGABrmzXbqArd8E+EpJXaflPjDH4msv3RYdCEIjAE0S9/B 6gLXnPhmVLd85lOpfPWCYyZF1IE0MIBG4SrooVuRE9GhMAnO/VKmr/8RTQfSwQCa pMJC9eVsHfRYz0hudtJeqf6JF06PogNpYQBNMraNusBFTX8O/zYrL6mS8p/Jv+7u 8EOQHgbQINfdpC5w0owmod9ky3GZAf7U4o5fhF6C9DCA5uAiSBEZMDDkG7zi9mB/ 7vsW5V1SHTFjAI1RdQEXQYrIzvNDvbm3Tgj6J0d2DrMD6WMAjfHN/uV/DQKZvluI N5Y1e6fgf/gGXuUwCwNoijs5cXB07r84tJuqP6NCGn96WdePQitBCBhAQxz1gbrA aQeH9frq/41I7ykzqRUXSTIJA2iGmvO4CFKUVtb5NZTbGdor3Vt4q30YHQgJA2iG KeWfVA7peO+4EG4k85vm6d/I7VelfxsICwNohEfPVRc475wn076JnBlhvE+/4szX Q7gVhIMBNEGnV9UFHkj7AyFtPwpy9HNJP7fhIknGYAANUHuxusAHufXSOwq5/4Bw OjIy3j82rFtCuhhAA8xorC7wQnoXZxvTNqwOrpVuEAZQL9XzKiGgNC6RlPNT0ud+ TsLKf70S4q0hDQygXNcR6gJvdA56wfnWY5I/93MyprXhVQ8zMIBq9RaoCzyy74+B /thld4bckfHBMWHfIgJhANVmN1QXeGTdLrmp/6HMtyN40+K+fuHfJlLHAIo9x2mC 47SgccqfCKnzXZ0IQlb1fCmCW0WqGECt059TF3jmp2Yp/oFj39gukpDphy6M5HaR EgZQqv48dYF3Pj00pS+/4/KIOjJGHx3VLSN5DKDU3J3VBf559/jkv7bi2Agv5Rbi OboQFAOoNKKrusBHb5yU7FfuNyY7wo5V578Y4a0jKQygUPdn1AV+ertdcl936R3h fPi3NNOPmBvp7aN8DKBOo1nqAl+NTeZjbVlvR/4i3YdHRf0dUA4GUGdefXWBtya1 yC/vS/YcG+aH30rB0YBqDKAMRwAKLdmvnINQLrrnbzFk8KFgNQZQpcvL6gKv/dJ+ dBn/bdY7Mf1yOvkwzg0oxQCK5CxVF/iujHPD7D+6RlwVr3eI6zshEQZQZPIe6gLv TTyylJ++Bl4X7bu/Rb/ZgPi+F0pgADXu+7e6ABkZ/34gwT/M/iSEKx8lb+mpXClY iAGUOOxjdQH+NO2kycX/0fGvxHyB0m9bl/uONCLDACpUXVRFnYDN3j5jeZH//MTZ sSe8wOEAOgygwhcHqgvwl1HnbXspsMnHgg9n511zX/zfFJsxgALX3aQuQGGfXzpu 87+59PY4Dv4rYV6HbxXfFhkMoMJ+PNxNs2T4oJUZVT9oJfr2nx8i+sZgAGOXtbim OgElzR7fPuZ3Pwp5uJfsW3uOAYzde1wPB8Ws+feT6gRPMYBxO3+YugDmmX7MTHWC nxjAmDWYoy6Aid47Tl3gJwYwZrMaqQtgpFuvURd4iQGM18PnqQtgpqVnvKdO8BED GKsjPlQXwFTfHLpeneAhBjBOlRdXVSfAWM+cqS7wEAMYp0854BWlWncZBwjEjgGM 0YWJzr4EbDH9hJ/VCd5hAOPDETAoW7LX60RoGMD4zGisLoDhbuyvLvANAxibey9W F8B0i7p+qk7wDAMYlxZfqQtgvs/aqAs8wwDGJHMp54BB+QZfqC7wCwMYk1c7qQtg gxXn/Ved4BUGMB4dR6oLYIfvjlxe/hchLAxgLCrn6k62CbsM76Eu8AkDGItPDlUX wBZr+z2mTvAIAxiHM59SF8AePx0zX53gDwYwBtVXqAtgkxdPUxf4gwGMwVct1AWw Sd7lQ9QJ3mAAo8c5EJCaacdPVyf4ggGMXJ1F6gLYZmRndYEvGMDITWymLoBt8q+7 W53gCQYwapfepS6Afaa3m6pO8AMDGDF+AUYQr3ZRF/iBAYzYD/uoC2Cj/GvuVSd4 gQGM1sU8jBHItHacHz8GDGCkai9WF8BW/+2qLvABAxipCc3VBbBV3lUcPxo9BjBK fTiiH4FNOWGmOsF9DGCEslepC2CzZ7urC9zHAEZoTFt1AWy25sKn1QnOYwCjc9Jr 6gLY7esjV6sTXMcARiZr+Q7qBFhuyAXqAtcxgJF54VR1AWy39Ky31AmOYwCj0vJL dQHsN+ZwdYHjGMCoLKyrLoADBl2vLnAbAxiRQdeqC+CCWZ0nqBOcxgBGg8/AIRwv naIucBoDGI0vDlQXwA3rLuYqmRFiACPR5WV1AVzxzTHL1QkOYwCjkLkiW50AZ9x/ sbrAYQxgFJ7uoS6AOxadMVqd4C4GMAJNp6gL4JK32qsL3MUARoDrwCFM+VdyZsCo MIDhO/05dQHcMuGYXHWCqxjA0PEOCMJ27yXqAlcxgKEb3FddANfMO/VzdYKjGMCw cSFghI/Pg0SEAQzb5werC+AeTg4dEQYwZEd9oC6Aiz47Ol+d4CQGMGTzd1IXwEnX D1IXOIkBDFffweoCuGlSu9nqBBcxgKHKXF1FnQBH8ZHgKDCAoeIQGERl7inj1AkO YgDDVHOZugDu4jrpEWAAw/TOceoCuGt5z1fUCe5hAEPUbKK6AC7jrDDhYwBDNKG5 ugAuW9fvUXWCcxjA8LQZqy6A28YcvUGd4BoGMDzTmqgL4LZfrrpPneAaBjA0HUeq C+C6ccetVic4hgEMDR+CQ+SuuVVd4BgGMCxnP6EugPsmHL9YneAWBjAsy2qqC+CB QderC9zCAIbk4nvVBfDBxJNmqhOcwgCGZEV1dQG8cPN16gKnMIDh6DNEXQA/fH/i XHWCSxjAcOTuqC6AJwYOUBe4hAEMxbl8RgkxmdBuoTrBIQxgKBbXVhfAG5wcP0QM YBjOGK4ugD++Pj5XneAOBjAMfAgEMbrqdnWBOxjAEBz/troAPvn0uPXqBGcwgCGY tJe6AD7J6/ewOsEZDGD6OBE04vXmieoCZzCA6fvkUHUB/LLyvJfUCa5gANOWs1Rd AN88301d4AoGMG0vnqIugG8WnTFaneAIBjBdFX5RF8A/Q/uoCxzBAKbrJs7OgdhN 7TxJneAGBjBdS2qpC+Cha29RF7iBAUzTER+qC+Cjj4/7VZ3gBAYwTV8cqC6Aj1b3 fk6d4AQGMD3VV6gL4KfhPdQFTmAA0/PweeoC+Gn2aePUCS5gANOzpqq6AJ7i4iBh YADT8n98JAki/2u3Up3gAAYwLV+1UBfAV2v6PKtOcAADmI6KeeoC+OuxnuoCBzCA 6eBTINCZ0oVPg6SNAUzHvPrqAnjsknvVBfZjANOw+1R1AXw2srO6wH4MYBo4ERaU FpzxkTrBegxgGjgIEFKDrlcXWI8BDK71Z+oC+O2D4zaqE2zHAAY3sqO6AH5b3OM9 dYLtGMDgVmWrC+C5gQPUBbZjAAPb71t1AXz3Vnt1ge0YwMBeOFVdAN8t6DZGnWA5 BjCw5TXUBfDe9YPUBZZjAIPa8yd1ATCqk7rAcgxgUA/1VhcAM04br06wGwMY1LQm 6gIgv98wdYLdGMCAMn9XFwBcIT1dDGBAXUeoC4CMjM9O5LzQ6WAAA3qDI7BggCVn vqNOsBoDGNCymuoCYJNrblUXWI0BDCZnqboA+NPz3dQFVmMAg7n6FnUB8KcfOk9X J9iMAQxmbBt1AfCnFee+ok6wGQMYzMpq6gKgAJ+GSwcDGEj2KnUBsNnwHuoCmzGA gZz7qLoA2OzLDovVCRZjAAN5uYu6ANiMSyOlgwEMZOYu6gJgMz4OnA4GMJA/1AHA VndeoS6wGAMYRJ1F6gJgqxdPUxdYjAEM4pzH1QXAVl90WKJOsBcDGMQz3dUFwFZz Tv9cnWAvBjCICc3VBcBWa3s/q06wFwMYRO6O6gLgL1feoS6wFwMYBG8CwyD39VMX 2IsBDIA3gWGUunwWJCgGMABOhw+jnPKSusBaDGAAt1ytLgAKufUadYG1GMAAXums LgAKeZWPpgfFAAbw9QHqAqCQb1qoC6zFAAYwd2d1AVDIvAbqAmsxgAFwOmgYZVV1 dYG1GMAAOAwQZuFpHBT3XAAMIMzC0zgo7rnUVcxTFwBFVMpXF9iKAUzdnj+pC4Ai 9pqsLrAVA5i6oz5QFwBFHD1aXWArBjB13f6jLgCK+Odz6gJbMYCp6/mIugAo4jwu 0xoQA5i6fveoC4AiLrlXXWArBjB119+oLgCKuOEmdYGtGMDU3XqVugAo4jbOTxQQ A5g6BhCGYQCDYgBTxwDCMAxgUAxg6hhAGIYBDIoBTB1vgsAwvAkSFAOYOg6DgWE4 DCYoBjB15w9TFwBF9HpYXWArBjB1p/O5I5il2/PqAlsxgKlrO0ZdABRx2CfqAlsx gKlrMk1dABSx23R1ga0YwNRV+EVdABSx/a/qAlsxgAFwSnyYhadxUNxzATCAMAtP 46C45wJYwVUIYZKVNdQF1mIAA5jDdahhkrkN1QXWYgAD+LKlugAoZPyB6gJrMYAB jOiqLgAKeekUdYG1GMAAbrpOXQAUMuh6dYG1GMAAOr2qLgAK6TxSXWAtBjCA6ivU BUAhNVaqC6zFAAbBgYAwCc/iwLjrgsjdUV0A/GVZjrrAXgxgEOP/oS4A/vIVh2UF xgAGMbivugD4y5AL1AX2YgCDaPemugD4S/u31AX2YgCDyPpNXQD8ZbsN6gJ7MYCB rMpWFwBbrK6mLrAYAxjIhObqAmCL7/ZTF1iMAQzk0XPVBcAWj/VUF1iMAQzk2HfV BcAWx72nLrAYAxgMnwWBKXgOp4E7L5iZu6gLgAKzGqsLbMYABjP8DHUBUODZ7uoC mzGAwfAiIAzBS4DpYAAD4kVAmIGncDq49wLiRUAYgZcA08IABjTsfHUBsMnDvdQF VmMAA2oyTV0AbLLbdHWB1RjAoLg6OgzANdHTwwAGNbKjugDIGNVJXWA3BjCoIz5U FwAZR36kLrAbAxhYXkV1AbyXX0ldYDkGMLDPWqsL4L3PD1EXWI4BDKzLy+oCeO/k V9QFlmMAg1vPrx/QyqusLrAdAxjcayepC+C51zuoC2zHAAa337fqAnhu/wnqAtsx gGlYmqMugNdya6kLrMcApuGh3uoCeG1oH3WB9RjANNRerC6A1+osURdYjwFMxw/7 qAvgsR/3VRfYjwFMR6dX1QXwWOeR6gL7MYBp4ZQwkOFEMCFgANNy78XqAnjrvn7q AgcwgGmpvE5dAG9VWa8ucAADmJ4xbdUF8NQnh6kLXMAApmf/b9QF8NQBfBApBAxg mqY0VRfAS1P3UBc4gQFMU7s31QXwUvu31AVOYADTtaCeugAeWriTusANDGC6zn1U XQAP9XxMXeAGBjBtHAyN2HEQdEgYwLRdf6O6AN654SZ1gSMYwLRlrq6iToBn1mVv VCc4ggFM3zU3qwvgmWtvURe4ggEMwcpq6gJ4ZRUvO4eFAQzBhQ+oC+CVix5UFziD AQxD7o7qAnhkGdeiCQ0DGIYzn1IXwCNnPa0ucAcDGIr5HJePuCyory5wCAMYimPf VRfAG8e9py5wCAMYjq8PUBfAE9+0UBe4hAEMR+MZ6gJ4YteZ6gKXMIAhGdFVXQAv vHSKusApDGBIuDoIYsGVQELFAIZlQH91ATwwcIC6wC0MYGgW1VEXwHmL66oLHMMA hqbNWHUBnHfop+oCxzCA4XnnOHUBHPfu8eoC1zCA4am6Rl0Ax+2wVl3gGgYwRJwV BpHiLDChYwDD9PNu6gI4bNru6gL3MIBh2vMndQEcttdkdYF7GMBQPXiBugDOGnyh usBBDGC4FnKcFqKxqJ66wEUMYLj2+1ZdAEftP0Fd4CIGMGSPnqsugJMe66kucBID GLYltdQFcNDS2uoCNzGAYWv5pboADjpwvLrATQxg6Ib2UhfAOcN6qwscxQCGb04D dQEcM7ehusBVDGD4OD0+QsZp8KPCAEbgsjvVBXDK5XepC5zFAEaBa8QhRFwHLjoM YBSqL6yoToAz8uutVCe4iwGMRMeR6gI4o9ModYHDGMBoPHG2ugCOePIcdYHLGMCI zGisLoATZu6qLnAaAxiRegvUBXDCTgvVBU5jAKNy6gvqAjjgtBfVBW5jACPz/Gnq AljvhdPVBY5jAKMzq5G6AJabvYu6wHUMYHRqz+ZoQKQjv9ESdYLrGMAIHfOeugBW O/Z9dYHzGMAoDbpWXQCL3XydusB9DGCkPmutLoC1Pj9EXeABBjBSFRbsqE6ApZbt 9Ks6wQMMYLR2n6ougKWa/qwu8AEDGLEuL6sLYKWTX1EXeIEBjNotV6sLYKFbr1EX +IEBjNwHR6kLYJ3RR6sLPMEARi5z9s7qBFhmXqON6gRPMIDRy5lTSZ0Aq+Q1zFUn +IIBjMFB/1MXwCoHj1MXeIMBjMOZT6kLYJGznlYX+IMBjMUdl6sLYI07r1AXeIQB jMcb7dUFsMSbJ6oLfMIAxuSnPdUFsMLkvdQFXmEAY1J5bk11AiywvMF6dYJXGMC4 NJjK6VFRnvymc9UJfmEAY9PyS3UBjHfgeHWBZxjA+HBeBJSDMyDEjQGM0cX3qgtg tH73qQu8wwDG6YEL1QUw2IMXqQv8wwDG6rWT1AUw1usd1AUeYgDj9VULdQEM9fU/ 1AU+YgDjlTW5iToBRpq+5wZ1go8YwJhVnlFHnQADLd6VA6AVGMC41ZyZrU6AcVY3 Xq5O8BMDGLtGk/lICIrK33O2OsFTDGD89vtWXQDD7D9BXeArBlDgiA/VBTDKkR+p C7zFACp0HKkugEE6jVIX+IsBlDhjuLoAxuj+rLrAYwygRp8h6gIYou9D6gKfMYAi 19ysLoARrr1FXeA1BlDltivVBTDA7VepC/zGAMoM7qsugNyQC9QFnmMAdR4/R10A sSf+pS7wHQMo9Ow/1QWQ+s8Z6gLvMYBKL3dRF0DolZPVBWAApd5spy6AzFvt1QVg AMVGH6kugMiHR6kLwADKfXKougASn/IXbwIGUI0F9BL7ZwYGUI4F9BD7ZwgGUI8F 9A77ZwoG0AAsoGfYP2MwgCZgAb3C/pmDATQCC+gR9s8gDKAZWEBvsH8mYQAN8QGH xfph9NHqAhTCAJqCBfQC+2cWBtAYfC7YA3z+1zAMoDleO0ldgIi93kFdgKIYQIO8 eIq6AJEacaq6AMUwgCZ56kx1ASL09FnqAhTHABrlod7qAkRmaB91AUpgAM1y16Xq AkTk7svUBSiJATTMwBvUBYjEjf3VBUiAATTNlbepCxCBq25XFyARBtA4fYaoCxC6 vg+pC5AQA2iebv9RFyBk/3xOXYDEGEADnfSaugCh6vC6ugClYABNdMSH6gKE6MiP 1AUoDQNopJZfqgsQmgPHqwtQKgbQTM2+qqROQCjyOy+uklE1s+J2W//B+t8zfsvL 2LA+I+/XX/M2rFW2gQGM1D6tD9ijYa0d1Bmw2Nqlc6Z8/fmP6gxXMYCRyDmy9d93 rVVZnQFnrF868/vPPsxVZziHAQxZVttjD2xaX10BR82f+uV7n2xQVziEAQxRw38e u0+OOgLOy/3xvedmqyMcwQCGpPr5XZvxvgXikjfppYdXqiMcwACG4eB/H1ZX3QDv LB5z3//UDbZjANNW96YuNdUN8NTyV25YqG6wGgOYnsxLz2+iboDXpj9890Z1g70Y wHTUvIdz2EPvmX7L1Qm2YgCDqz6Ma9zADCPO5x2RQBjAoDIHc/0OmGNYX34RDoAB DKjHA9XUCUAhqy98Rp1gIQYwkBpvt1InAMV80Y6XAlPFAAZxOif4hYm6Pa8usA0D GMAQLvAKM3Ht4RQxgCmrOOZAdQJQivFt89UJVmEAU9X0M853AHPltpmiTrAJA5ii Qz9RFwBlOoyHaPIYwNSwfzAeC5g8BjAl7B8s0HasusAaDGAq2D9YgQVMFgOYgmYT 1QVAUvaepC6wBAOYvO581Ai26DFcXWAHBjBpWb+pC4Ckbcelk5LBACZtGmc+hT1m 8HBNBgOYrIE3qAuAFNzEAzYJDGCSGs1SFwAp2YVLZ5aPAUzSPC52Drss4CFbPgYw ObdcrS4AUnQbD9pyMYBJ2WOyugBI2V48bMvDACZl5i7qAiBls3dRFxiPAUzGWU+q C4AAzuGBWw4GMAmZv6sLgED+xqXiysYAJuGRnuoCIJDHeOiWjQEs34656gIgoJxl 6gKzMYDlm9BcXQAE9D0P3jIxgOXadbq6AAhsNx6+ZWEAyzV/J3UBENhCHr5lYQDL 0+lVdQGQhs4j1QUmYwDLwSEwsByHwpSBASxH/wHqAiAtAwaqCwzGAJaN00DDepwc unQMYNk4Cwysx1lhSscAlilz5Q7qBCBNa6vxKmBpGMAy9R2sLgDSdiEP49IwgGWa uru6AEjbNB7GpWEAy9J0iroACMEeU9UFpmIAy/J0D3UBEILhPJBLwQCW5Q91ABAK nuel4I4pwzvHqQuAULx7vLrAUAxgGVZlqwuAUKyupi4wFANYBn4Dhit4oifG/VK6 6ivUBUBIavJgTogBLN1nrdUFQEj+x4M5IQawdPwGDHfwTE+Iu6V0DCDcwTM9Ie6W Uu2wWl0AhCZ7jbrASAxgqUZ2VBcAoXmNh3MiDGCpFtRTFwChWcTDOREGsFS8BAiX 8FRPhHulVAwgXMJTPRHuldI0nqEuAEK060x1gYkYwNKMaasuAEI0lgd0AgxgaZbX UBcAIVrJAzoBBrA0vAQIt/BcT4A7pTQMINzCcz0B7pRSZK9SFwChqsZHm0piAEvx NqfQhVs4K3QCDGApcndUFwChWpajLjAQA1gKXgKEa3iyl8R9UgoGEK7hyV4S90li mb+rC4CQ/W2jusA8DGBiQ3upC4CQPcyDugQGMLGJzdQFQMh+4kFdAgOYGC8Bwj08 20vgLkmMAYR7eLaXwF2SEO+BwEG8C1ICA5jQwZ+rC4DQHcLDujgGMKH3j1YXAKEb zcO6OAYwoXn11QVA6ObvrC4wDgOYEO+BwEU83YvjHkmIAYSLeLoXxz2SyK7T1QVA BJpwpa9iGMBEeg1VFwAR6MMDuxgGMJGvD1AXABH4lgd2MQxgIks5dSRcxDlRi2MA E+E9ELiJ53sx3CGJLKmlLgAikMsDuxgGMBF+AoSbeL4Xwx2SCAMIN/F8L4Y7JBEG EG7i+V4Md0gCt12pLgAicecV6gLDMIAJjOqgLgAi8ToP7aIYwAS+31ddAETiRx7a RTGACXAcNBzFkdDFMIAJ8B4IXMUTvijujwQYQLiKJ3xR3B8JMIBwFU/4org/Srr5 GnUBEJFbeXAXwQCWNKKrugCIyH95cBfBAJY0rpW6AIjIlzy4i2AAS5rdUF0ARGQu D+4iGMCSeA8E7uIZXwR3R0kMINzFM74I7o6SGEC4i2d8EdwdJfQdrC4AInMhD+/C GMASHrhQXQBEZjAP78IYwBLeaK8uACLzFg/vwhjAEr7ZX10AROa7/dQFRmEAS5hX X10ARGYBD+/CGMASeBMYLuMpXxj3RgkMIFzGU74w7o0SGEC4jKd8YdwbxZ0/TF0A RKg3D/BCGMDi7rpUXQBE6N5L1AUmYQCLe7mLugCI0MjO6gKTMIDFffd3dQEQIa6M WRgDWNzi2uoCIEJLeYAXwgAWx5vAcBvP+UK4M4pjAOE2nvOFcGcUxwDCbTznC+HO KI4BhNt4zhfCnVHMgP7qAiBSN/IQ34YBLGZUB3UBEKk3TlIXGIQBLOaHfdQFQKQm 8hDfhgEshsMA4TgOBCyEASyG90DgOp7023BfFMMAwnU86bfhviiGAYTreNJvw31R DAMI1/Gk34b7ohgGEK7jSb8N90VRF92vLgAidjEP8r8wgEUN7aUuACL2yPnqAnMw gEW9f7S6AIjYaB7kf2EAi5rSVF0AROxnHuR/YQCL4j0QuI9n/V+4K4piAOE+nvV/ 4a4oigGE+3jW/4W7ooh+96gLgMhdysN8KwawiEd6qguAyD3Gw3wrBrCoW5ruUr+u OgKIzKIFs6ZerY4wBwOYSI+9m+6ynzoCCNV3s6dMfFodYRoGsAxnN2vaqLk6AkjT 97OnTnxSHWEoBrB8ZzVr2nCnOuoKIEWLF875meUrGwOYvJt3b7TTzuoIoFzzFs7+ +Rp1hB0YwJRd2bRxfT5LBBP9PH/m1NvUEVZhAIM6Z89dG9RtqK4ANpm7aO6MyY+r K2zEAKarT9PGDWrXV1fASwsWz58xdYi6wmYMYFh679aofp3G6gp4Ydbi+bOnM3wh YABDd1XjnevV4s0ShG/+0k2/6vIaX5gYwOhc27B+3ZxG6gpYb/ayRfNn36yucBMD GIPzGm36mbAmb5ggFXOXL104f9bD6gzHMYCxOrvRTvVq16xWS90BQ+WuWr5k4fw5 T6g7vMEAqvRqUKd2To3sndQdkFu4amXukkXzhqo7fMQAmqDPTnVq1ai5A68X+mPO 6hUrlixe8JC6w3cMoHEuqpuTs2P2DlX59LFbFq9bvXp57tLFXJTXJAyg4frk5NSo UX2HqlXYQ9ssXr929aoVK3KX8mOeuRhAy/TbsUb1atlVq1SutKM6BUUsy8tbt2nx Vi5fdq86BUljAK13SY3s6tk7VKlSsdL2vLscl9z8/Lz1a9euWrV6OdfXsBkD6KSL qmVv2sTKlSpX3H77CsxiOpb+9sufY5e3bs3qVat5/c41DKBXLq5atXLlqpUqVto0 jNtvVyGrhjrIECt/++3XX375c+ny1q3LW7uWX2J9wQBii95VKleuXGn7SttvX7HC Jtttl5WVVV0dFZKVG37/bdPGbfJLfsEPdOvXr+OwOzCASMX5m36nrlhh02/V2236 3+22z/rbdtv9LSvrb5nbZWqWcuXGDb//vmHDxl9/+33DL5sW7pfffs3/5dc/B45P kCEpDCCi8+/MSn+rmFGp4H8y/sjY9nDb/K+ZBf/mr/8t/mDMz8gr+J/83/M28uIb IsEAAvAWAwjAWwwgAG8xgAC8xQAC8BYDCMBbDCAAbzGAALzFAALwFgMIwFsMIABv MYAAvMUAAvAWAwjAWwwgAG8xgAC8xQAC8BYDCMBbDCAAbzGAALzFAALwFgMIwFsM IABvMYAAvMUAAvAWAwjAWwwgAG8xgAC8xQAC8BYDCMBbDCAAbzGAALzFAALwFgMI wFsMIABvMYAAvMUAAvAWAwjAWwwgAG8xgAC8xQAC8BYDCMBbDCAAbzGAALzFAALw FgMIwFsMIABvMYAAvMUAAvAWAwjAWwwgAG8xgAC8xQAC8BYDCMBbDCAAbzGAALzF AALwFgMIwFsMIABvMYAAvMUAAvAWAwjAWwwgAG8xgAC8xQAC8BYDCMBbDCAAbzGA ALzFAALwFgMIwFsMIABvMYAAvMUAAvAWAwjAWwwgAG8xgAC8xQAC8BYDCMBbDCAA bzGAALzFAALwFgMIwFsMIABvMYAAvMUAAvAWAwjAWwwgAG8xgAC8xQAC8BYDCMBb DCAAbzGAALzFAALwFgMIwFsMIABvMYAAvMUAAvAWAwjAWwwgAG8xgAC8xQAC8BYD CMBbDCAAbzGAALzFAALwFgMIwFsMIABvMYAAvMUAAvAWAwjAWwwgAG8xgAC8xQAC 8BYDCMBbDCAAbzGAALzFAALwFgMIwFsMIABvMYAAvMUAAvAWAwjAWwwgAG8xgAC8 xQAC8BYDCMBbDCAAb/1/jtkupgjlrUMAAAAASUVORK5CYII="/></symbol><g mask="url(#b)"><g transform="rotate(.193) scale(.36014)"><symbol id="c" viewBox="0 0 1280 1280"><image width="1280" height="1280" xlink:href="data:image/png;base64, iVBORw0KGgoAAAANSUhEUgAABQAAAAUACAIAAACXhmigAAAACXBIWXMAAA7EAAAO xAGVKw4bAAD1TUlEQVR4nOzdiX9bxbn/cVvW7iPJ2UjSha2hXC4QoKUEKC1roXAD bVhLW7h/84+GLXu8L9qls2+/kQS5iePYss/M0ZHO5/1KjUnsZyaWqPX1zDwzPwcA AAAAQArMT3oCAAAAAADEgQAMAAAAAEgFAjAAAAAAIBUIwAAAAACAVCAAAwAAAABS gQAMAAAAAEgFAjAAAAAAIBUIwAAAAACAVCAAAwAAAABSgQAMAAAAAEgFAjAAAAAA IBUIwAAAAACAVCAAAwAAAABSgQAMAAAAAEgFAjAAAAAAIBUIwAAAAACAVCAAAwAA AABSgQAMAAAAAEgFAjAAAAAAIBUIwAAAAACAVCAAAwAAAABSgQAMAAAAAEgFAjAA AAAAIBUIwAAAAACAVCAAAwAAAABSgQAMAAAAAEgFAjAAAAAAIBUIwAAAAACAVCAA AwAAAABSgQAMAAAAAEgFAjAAAAAAIBUIwAAAAACAVCAAAwAAAABSgQAMAAAAAEgF AjAAAAAAIBUIwAAAAACAVCAAAwAAAABSgQAMAAAAAEgFAjAAAAAAIBUIwAAAAACA VCAAAwAAAABSgQAMAAAAAEgFAjAAAAAAIBUIwAAAAACAVCAAAwAAAABSgQAMAAAA AEgFAjAAAAAAIBUIwAAAAACAVCAAAwAAAABSgQAMAAAAAEgFAjAAAAAAIBUIwAAA AACAVCAAAwAAAABSgQAMAAAAAEgFAjAAAAAAIBUIwAAAAACAVCAAAwAAAABSgQAM AAAAAEgFAjAAAAAAIBUIwAAAAACAVCAAAwAAAABSgQAMAAAAAEgFAjAAAAAAIBUI wAAAAACAVCAAAwAAAABSgQAMAAAAAEgFAjAAAAAAIBUIwAAAAACAVCAAAwAAAABS gQAMAAAAAEgFAjAAAAAAIBUIwAAAAACAVCAAAwAAAABSgQAMAAAAAEgFAjAAAAAA IBUIwAAAAACAVCAAAwAAAABSgQAMAAAAAEgFAjAAAAAAIBUIwAAAAACAVCAAAwAA AABSgQAMAAAAAEgFAjAAAJFomjb4x/z8/F1vj1IoDMO73oo3/X5f2iwBAAABGACA wxok3jtxd2RuLrOwIP6ZyWRGb49QNggCEX5/euv74TALD+Lwz5GYPAwAQEQEYAAA DrAr8YqMK+KuSLkLw9CrdGgRfn3fF6lYROKAPAwAQDQEYAAA9nB36M0MZbPZ0QLv BGc1WiL2PC8YIgwDAHAoBGAAAP7PT7n352VeEXoXFhYmPakH8n1/EIbvWhwmCQMA sA8CMAAAd+Xe4cbmfD4/6RkdmuM4o83SJGEAAB6EAAwASK+7c2+hUDha86qkERnY tm2SMAAA9yMAAwBSZ3Rx0fzPm5xzudykZ6SE67qjDdIhlyoBADBEAAYApMhoyTcz Pz9IvbncZDtaxUOk30ESdt2ABWEAQOrN/jd+AABGS74i+maH53szCe5rpU7g+47j eL4/x4IwACCtCMAAgFl2Z7fzaMl3Nk75RhEEwWhBmH3RAIAUIgADAGaWSL8i8Yrc m03HbufxifQrMrAg8jAZGACQHrwaAADMoEH0He52zmazIuyRfu83+rJ4nuc4TuD7 xGAAQBrwggAAMGuqtdqdO42IvvsbbYQe3ZzU7XQmPR0AANTiZQEAYHZUq9VcLreQ zXLW97BEBva9wbbobrc76bkAAKAKARgAMAsqlUpuuOF5fmjS05lK4ZAnYrDj9Hq9 SU8HAAD5eIkAAJhumoi+IvgOOzwTfaMTGTgIgsFasOf1icEAgNnCCwUAwBSrLS0N 7vUl+so2isGO43Ta7UnPBQAAaXi5AACYSnf2PHPcV53BUjA7ogEAM4QADACYMpqm LQy2PA82Pk96LqngDZtj+Z7HVUkAgGlHAAYATBMWfieCpWAAwGwgAAMApsNPC7/D fleTnktKjTpjsRQMAJheBGAAwBSoVCqDTc/DVs+TnkuqBUEwSMGuy1IwAGAaEYAB AElXrdWG4ZeF36Rwh7qdzqQnAgDA4RCAAQDJpVUq2YWFXD6/sLAw6bngHoNLkmzb 833uCgYATBECMAAgoQbbnrPZfKEwPz8fhiE3/SbH6OEQbwcZ2PPYDg0AmBa8mAAA JI6mafOZTC6Xy+fzk54LDuA4juu6YRDQGQsAkHwEYABAsoj0m1lYyA/vOpr0XDAW z/NEDA58nwwMAEg4AjAAIEFGdx3lp/PQbxiGIrRrlcqpU6eKpdIz58+P+Yn/+X// r76z0263LcsKg2AaO137vi8yMDckAQASjgAMAEgKbXToN58XCXAqDv0GQVAsFmtL S6fPnBk/7u4i/qYbGxu2bd/9myu3b3fabcMwPNdN/s8CRg/WoC2W43giA3MkGACQ VEl/bQEASAmRfnO5XKFQmPREDjAKvQ+dPn3ut789c/ZsxGoiOt64fj2zb8Rtt1qb 6+vdbtf3vOQvDosk77ouGRgAkEwEYADA5In0m8/l8glOvyL3ikk+8+yzj587J6um CIpbW1vi7fifsrWxsbq8LEJmkpeFHdt2yMAAgEQiAAMAJqwi0m+hkMvlJj2RPajI vaOyzWYzyu1BCU/CItWLGMz1SACApCEAAwAmSaTfQqGQTVj6He1z/u1//deRT/Y+ SBiG/X5fpF8xhJSCK7dvb6yvJ3B3tOe6NhkYAJAwBGAAwMQM0m+xmKjrjkQuPX3m zEuvvCLmJr2467rb29uO40ivbJrm9StXup1OohaEPc+zLYsMDABIDgIwAGAyRMIs lkqJCmznnnjixQsXVFQWubrVanW7XRXF7yZi8PbWVnJWg8nAAIBEIQADACYgaen3 mfPnpe92vkPX9Uaj4fu+ovr3W7l9e3V5OSExmAwMAEgOAjAAIG4i/ZbK5YTEM6XR 13VdEX1N01RUf3/JicEi/FumSQYGAEwcARgAECtNpN9krP0qjb5hGHY6nXa7Ld5R NMSYEhKDRQY2TZO7kQAAk0UABgDER9O0Uder+fmJfQMKguC3Tz6p6KzviG3bOzs7 h7rgV7XrV65sbW5O8OcOYRiO9kL3+/1JzQEAAAIwACAmSUi/taWl115/XUWH55HY ml0dgWEY31++7E0ulpOBAQATRwAGAMTk2PHj+Xx+gun3jbffPnP2rLr6ImE2Gg2R 8dQNEZHI55tra7du3pzUUrDIwI7jtJrNiYwOAAABGACgnKZp2VyuUChMJP2OrvZ9 +9131Q3h+36z2ZyKhU3XcUzDuH7tmmWaEzkYLDKwbdue607FlwsAMGMIwAAAtUT6 FUGrVC5Pau1X9cKvCHKNRkPEbHVDyGXquuu6vV7v9oSWgkUGFiFcfMXIwACAmBGA AQBqTfDSo1MPPaR64VdEX13X1Q2hQiiSZ683ak99/do1x7bjn4NIvyIDczESACBm BGAAgEKaphVLpWw2G/O4It1deOWVx8+dUzeEYRj1el1kYHVDqOO5rvFzbm82Gutr a/EvBXueZ5kmi8AAgDgRgAEAqoj0my8U8vl8zOOKLPfXixeVtnpuNpvTvnppGobr OKP3bdu+duVK/Kv0jmDbZGAAQGwIwAAAJUT6XchmS6VSzOOq3vZsWdbOzk6SWz2P KQzDwUbou44uT2Q7tGmavueRgQEA8SAAAwDkGzW+KpZKcS4qBkFw/vnnnzl/XlF9 kRhbrVan01FUP34ixhv3Js+tzc36zk7Mj5plmjTEAgDEgwAMAJCvUqkUisU4j/6K BPXyq6+qO/QrsuL29rY9iX5RSonwuWvVN/4jweJra1vWtG8pBwBMBQIwAEAyrVLJ DW/9jW3EMAwv/v3v6g796rper9en6KKj8Ykvnd7r7fqriZx/9ccf48zAYkTXdftk YACAYgRgAIBMg83PCwulUim2W3+Vpl9RvNlsdrtdFcUT4v6N0HOxZ+DBzcCmGfg+ G6EBAEoRgAEAMlWq1WKxGFtwyufzH3/+uaLirutub287P7dKnmGWYez51/zu229j e6Hg+75lWb2Z/lkDAGDiCMAAAGm0SiU/FIZhDCvAStOvrus7OzviL6KofqLc3xH6 jngy8OgJ4wyxERoAoA4BGAAgR8z3HqlLv7PX7Xkcnusaur7nH8W5DsytSAAApQjA AAA5KtVqoVCIp/OzuvQbBMH29raIYSqKJ5yp667r7vlHsWXgQUdo22YjNABAEQIw AECCODs/LywsfPbllyoqi/i3ubkpMpiK4skXBsFgI/QDdn1/+5//xHM/MB2hAQDq EIABABLUarViLJ2f1fV8tixLpN+UHPp9ENdxTMPY849i6wstHgLLNNO2BR0AEA8C MAAgqsqw91Uun1c9kLr02+v16vW69LLTyOj3H7QGHlsGdofdsHosAgMAZCMAAwAi 0TQtm8sVi0XVAwVB8NZf/nLm7Fm5ZUWobg/JLTu9BpfxPjh5ilC6fOtWDHuhLcvy XJduWAAAuQjAAIBIqtVqXn3vK5F+X3711cfPnZNbVqTfRqPBSuMutmWJXw/602aj sbG+rjoDe57n2HaXblgAAKkIwACAo7vT+0r1xb+/+vWvX3v9dbk1xZzr9TprjPcT Xxm91wv2uhZ45NbNmw86KixrAuLpRDcsAIB0BGAAwNFVazWRflUfCi0vLn506ZLc miJi7ezs6A+4+RYieZr7fnF++O471Q3DfN8XGbhLNywAgDwEYADAEWnD3ld5xb2v RMr68quvpNdk7fdAer/v73sj1OVvvlH9s49hMyyHRWAAgCwEYADAEdWWlgqFgtKz oEEQfHjpkty2zyL9NptNDpceyPd9fd/kadv2tStXVD8BxCgdWpQBACQhAAMAjkKr VArqrz4698QTL164ILdmu91utVpya84qyzAcx9nnA9ZWVlT/KMF1HJtFYACAJARg AMBRxLD8q+Lor2EYW1tbcmvOsCAIBslz37O+qg8DswgMAJCIAAwAOLTB8m+hkMvl 1A2hYvOz4zjr6+uqWzfNmP2vRJobboS++uOPSg8Du64rRmERGAAQHQEYAHBoS0tL ecXLv8+cPy9+SSzo+/7a2pp4K7FmGoRh2O929/+pwdbmZrPRUDeHIAgc226zCAwA iIwADAA4nBiWf6Vvfhb5bWtryzRNiTXTQ4RP66AvneqN0CwCAwCkIAADAA6nVqvl Vd79q2LzM42vohDJVu/1xOOyz8eo3gjt+77I4R3uBAYAREMABgAcgqZphWJR6fKv 9M7PlmVtbGxILJhCruOYhrH/x6juCD1YBLYsbm8GAERBAAYAHEK1ViuoXP4V/vHv f0usFgTB2tqa53kSa6bQOIvAwuVvvlG6CGzbdpdFYABABARgAMAhHD9xIpfLzc+r +vbxxttvnzl7VmLBRqOh+qLalBhnEbjX660uLyuagAjhrusq7bYFAJh5BGAAwLgq lUqxVFK3xFdbWnr/4kWJBdn8LNGYi8BXfvzRV7be7vu+ZZo9WmEBAI6KAAwAGNfS sWP5fF7R7UfSe1+x+Vm6cdpB27Z97coVdU8Sx3Ha9DMDABwVARgAMBZN04qlUjab VVRf+vJvq9Xi5li5xrkTeE7xIrDneSKE0woLAHA0BGAAwFiqtVqxWJyW5V/XdVdX V2VVwx22ZYlfB3yM4kVgy7JohQUAOBoCMABgLErbX0lf/t3c3DQP2qyLIxD5sz9G UzF1i8C0wgIAREEABgAcTKtUSsraX0lf/tV1fXt7W1Y17GIahus4+3+M0kVg3/dN 0+zTCgsAcHgEYADAwWq1WkHZ/me5y79hGK6trbmuK6sgdvE9Tx/jCK66ReAgCGzL 6rALGgBweARgAMDBTpw8mc1mVex/lr782+12G+yPVazf6wW+v//HqFsEDsPQ87xG vS69MgBg5hGAAQAH0CqVcrmsaPk3n89//PnnsqqJOL26uuoflM0Q0Tj3IQnfffut otcZ4oE2DINd0ACAwyIAAwAOUFtaKhaLitpfvfH222fOnpVVrd1ut7gkVr0wDHtj 7EDu9Xqry8uKJmBZVodrrgAAh0QABgAc4MSJE1ll/Z//8e9/yyoVBMHKyop4K6sg 9mHoujfGQevL33yjonfaYBe067LXHQBwWARgAMB+NE0rLy4q2v987oknXrxwQVa1 TqfTbDZlVcP+XNc1df3AD1tbWemOcW3SEQx2Qet6f4x2XAAA3EEABgDsp1qrlUol Re2v/vn117KqhWG4srLC6d/YDHZBi2Qbhgd+5Lf/+Y+iVlimaXbpBQ0AOAwCMABg P8eOH8/n8yoCcHlx8aNLl2RV6/V6ddoCx2ucC4GFH777LhwjJx+WqOk4Tos1fwDA YRCAAQAPpGlaqVxWcYZTeOnllx8/d05WtbW1NWeMMAaJxtwF3Ww0tjY3VUzA930R wtkFDQAYHwEYALA3kX7n5ucXFxeTv//ZsqyNjQ1Z1TCmMXtBz6lshaWLBB6GZGAA wJgIwACAvYkAnFlYUHQAWO7+5+3tbX2MpUhIZ/T7nucd+GHqdkGbphn4PgEYADAm AjAAYG8iAOfyeUUHgCXufxYBbGVlRUopHJZj25ZpHvhhinZBj44Bu45DAAYAjIkA DADYm7oDwHL3P7fb7VarJasaDmWw+trrjfORinZBcwwYAHAoBGAAwN60SmVwDFgB ufufV1dXXdeVVQ2H1et0xtnerGgXtCDS75ghHAAAAjAAYA+jA8DlcllF8XNPPPHi hQtSStm2vb6+LqUUjsbU9XF+ALG2stLtdlVMwDAMjgEDAMZEAAYA7EEE4GwuVywW VRT/x7//LatUo9FQFKswpjGPAQvff/utiglYluW5LgEYADAOAjAAYA8iABeKxVwu p6K4rAAchuHKyorv+1Kq4WjE11+f6DFg13VtyyIAAwDGQQAGAOxBBGCtUlFRuba0 9P7Fi1JKcf1vEox/G/CVH3/0x7gz6Qj6vR4BGAAwDgIwAGA3EX7n5+cX1XTAeub8 efFLSqlms9kZL3pBKb3XG2cdfmtzs9loKJlAvy9yOBkYAHAgAjAAYLdBB6xMpry4 qKK4xAPAKysrnpoVRRyKZZqObY/zkYqOARu6HgQBARgAcCACMABgNxGAF7LZUqkk vXIYhl9+9ZWUUq7rrq6uSimFiMbvg6XoGLBpmr7nEYABAAciAAMAdht0wCoUcvm8 9Mr5fP7jzz+XUqrb7TbU7KfFYXmeZ4wXPr/79lsVrzxcR2RwmwAMADgQARgAsJsI wMVSKZvNSq986qGH3n73XSmltra2DMOQUgoRjd8H6/q1a2Nulj4UkcAt0yQAAwAO RAAGAOwmAvDisA+W9MqyOmCJxLW8vBwEQfRSkEIEYPGgHPhhivpgiaH1fp8ADAA4 EAEYALCbVqloalpA/8/f/laRcbuS4zhra2vR60CWMRtB27Z949o1FRMYxN/xriMG AKQZARgAcI/BHUiZzKKCFtBBEPzz66+llOr1evV6XUopSGHouue643zkt//5TyaT kT4BXddDGkEDAA5CAAYA3GMq7kDa2dkh6iTK+DchKWoEzU1IAIBxEIABAPdQdweS xBbQq6ur7njrjYjH+DchKWoEzU1IAIBxEIABAPfQKpVsNlssFqVXri0tvX/xYvQ6 YRjeunUreh1I5DqOOV5T7is//iiSqvQJWJbliQDMMWAAwL4IwACAe2ialhcKBemV Zd2BZNv2+vp69DqQaPyrgBXdhCRqOo7DCjAAYH8EYADAPbRKpVgsqrgEWNYdSCLk 7OzsRK8DiXzf18dbfVV0E9LgKmDLYgUYALA/AjAA4B4iABcKhVwuJ72yrADcbDY7 nU70OpAoDIJetzvORyoKwK7r2rZNAAYA7I8ADAC4hwjApWJxQcEK8Btvv33m7Nno dba3t3Vdj14HEoVh2BvvpxK9Xm91eVn6BHzPM1kBBgAchAAMALiHCMCapqmoLOsO pPX1dVvBIVJE1BUBOAzH+cjvv/1WxQT6AgEYALAvAjAA4B7JD8DLy8u+70spBYl6 nU5IAAYAJBsBGABwj4QHYO5ASqx+txsEwTgfSQAGAEwKARgAcI+EB2DP81ZWVqLX gXQifAbjrcwTgAEAk0IABgDcI+EB2HGctbW16HUgnd7rjbk1nQAMAJgUAjAA4B4J D8CWZW1sbESvA+n0ft/3vHE+kgAMAJgUAjAA4B4JD8CGYWxtbUWvA+kIwACA5CMA AwDukfAArOv69vZ29DqQjgAMAEg+AjAA4B4JD8Ai4+zs7ESvA+kIwACA5CMAAwDu QQDG0RCAAQDJRwAGANwj4QG41+vV6/XodSAdXaABAMlHAAYA3EME4MXFxfl5+d8g vvjXv6KXZQU4scYMwGEY/vDdd9JHF2V1XScAAwD2RwAGANxDBOBisZjNZqVXfv2t t87+4hcRi9AFOrFE+AzGCMC9bnd1ZUX66J7nWZZFAAYA7I8ADAC4hwjAhUIhl8tJ r/zM+fPiV8Qipmlubm5KmQ/k6ne7QRAc+GHi4Ws1GtJHd13Xtm0CMABgfwRgAMA9 1K0AP/3ss88+91zEIiLkrK+vS5kP5Op1OmEYHvhhmxsbrWZT+uisAAMAxkEABgDc Q9O0XD5fKBSkVz556tQ7770XsYjruqurq1LmA7m67fY4H3b96lXHcaSPbtu26zj9 fl96ZQDALCEAAwDuoVUq2Wy2WCxKr1yr1d7/8MOIRcIwvHXrlozpQCbxuPQ6nXE+ 8soPP4zZLPpQLMvyPI8VYADA/gjAAIB7aJq2kM2WSiXplfP5/Meffx69zu3bt8c5 a4o4hUHQ63bH+cjvLl9W0WPcNE1fBGBWgAEA+yIAAwDuIQJwJpMpLy6qKC7lKuDV 1VXXdaPXgUS+7+vjrb5e/uabhYUF6RMwdD0IAgIwAGB/BGAAwD1EAJ7PZBYVBGCR T7786qvoq39bW1uGYUiZEmTxPM8YI3yGYfjd5cuZTEb6BHRdDwnAAICDEIABALtp lYqIwSoqv3/xYm1pKWKRVqvVHq/fEmLjuq6p6wd+mGWaN2/cUDEBEX05AAwAOBAB GACwm0i/i5qm4qDmU08//dwLL0QsIpLOzs6OlPlAFse2Rbg98MM21tfbrZb00cMw 1AcJmOVfAMABCMAAgN1EAC6WSiquAj5x8uRf/vrXiEW4CjiBRPoVGfjAD7t29aqr 4A6kwSXApkkABgAciAAMANhNq1TyQ9IrZ3O5T7/4ImKRMAxv374t3kqZEqQwDWOc ZKuoBbQzxBZoAMCBCMAAgN3U3YQUBME/v/46ep319XV7jPVGxEbv933PO/DDFLWA 5g4kAMCYCMAAgN2U3oT0yRdf5HK5iEUajUZ3vFtnEY9+t3vg5cy+71/54QcVo3MH EgBgTARgAMBu2rAD1qKaRtBPPvXUC7//fcQiuq5vb29LmQ+iC8Ow1+kc+GEba2uK 2nfr/b6YAwEYAHAgAjAAYA/qGkFrlcrFv/0tYhHf95eXl6XMB9ENVl/HWJD/8Ycf At+XPjotoAEA4yMAAwD2IAJwvlBQ0QdLxJUvv/oqep21tTVHQT9hHIHnecYY+fM/ 33yTVXAAeND/yrYJwACAcRCAAQB7EAE4m8sVi0UVxf/+6afRK3MMODnGuQRYhOSr P/6oYnTLsjzXJQADAMZBAAYA7GHQB2thoVwuqyj+60ce+eOf/hSxiGEYW1tbUuaD iMa5BPj2rVuGrqsYXTwTAt8nAAMAxkEABgDsTatUFhcXVRwDLhQKlz77LGIRbgNO DqPf9w66A+n7b79VMfTgALCucwMwAGBMBGAAwN40TSuWStlsVnrlwPc//+c/s5Ev Q9re3tbVLCriUHrdbrjvHUi+7//w7bcZBQeARfC2TJPlXwDAmAjAAIC9iQCcy+Xy hYKKReBnzp8XvyIWEbFnZ2dHynxwZOPcgbS1udlsNFQM7di2ywFgAMDYCMAAgL0N jgFnMqVyWUUAzufzH3/+ecQiQRAsLy+zC3qyxmkB/d3lyyqeReKhNw1jcAkTARgA MB4CMABgbyIAz83PKzoGLELLZ19+mWMX9PQ7sAX0YP/zd99lMhnpQ48OAIt/EIAB AGMiAAMA9nPy1KmFhQUVGfjpZ5999rnnIhahF/TEmYbh7nsh8+bGRqvZlD6uSL8i WtfZAw8AOAwCMABgP0vHjhXUHAPO5nKffvFFxCIiBS0vLwf7dmCCUv1ud/+v/7eX L2fU7H+2bbvdakmvDACYYQRgAMB+KtVqWc0xYBFg/vbxx+XFxYh1Go1Gt9uVMiUc 1oEdsBzHuXbliqLnj2EYPR56AMBhEIABAPvRNK1ULmcyGRUZ5syZM2+8807EIiJi ra2tSZkPDstzXWPfM9g3r1+3LEv6uCL9BkFgGganfwEAh0IABgAc4Pjx47l8XlEr rC/+9a+FyNfDrq+v27YtZUo4FNuy7AfnW/H4fnf5cvTH934iALuO01RwtBgAMNsI wACAA1RrtVKppCIAC8+98MJTTz8dsUiv16vX61Lmg0Mx+n3P8x70p9tbWw01j8vg AiTT7B50/zAAALsQgAEAB9A0rby4qOIaG0Hk6i/+9a+IRYIgWFlZoRVWzA48AHz5 m29ULP/ODR9xQ9fZ/wwAOCwCMADgYMdPnMjlcopaGf3p9dd/9fDDEes0m80O64Hx 8jzPeHAE7bTba6urip4zrus2Gw3plQEAM48ADAA4WLVaLZZKihaB8/n8x59/HrGI CGMrKytS5oMx7X8A+LvLlxVtmw+CwDJNWn8DAI6AAAwAONigF3SptJDNqigehuEf //znhx95JGKd7e1tfd+OxJBL7/V839/zj9qt1vramqIA7HueaZrsfwYAHAEBGAAw lmPHj+fV9IIWcrncJ198EbGIbdvr6+tS5oMDhUGwzx286pZ/wzB0HKdF/2cAwJEQ gAEAY6lUq6ViMaOmp9FgEfhPf3r40Ucj1tnY2FBx6yzu5zqOaRh7/pHS5d/A903L 2id7AwCwDwIwAGBcJ06ezGazioJNNpf7NPIisGmam5ubUuaD/Rm67rnunn+kdPnX 8zxFVysBANKAAAwAGFdtaalQKChqhSWyzauvvfbIY49FrLO2tuY4jpQp4UEGFyB1 u+If9/9Rq9ncWF9X1/7Ktu1Ou62iOAAgDQjAAIBxaZVKsVjMqmmFJSwsLHz8+ecR b47VdX17e1vWlLAn13XNvfqNiYD6/bffKvoRydyw17dlWf1eT1F9AMDMIwADAA7h 2LFj+UJB0fqecO6JJ168cCFKhTAM19fXWQRWSqRfd6/9z2srK+puJxq0v7LtVqul qD4AIA0IwACAQ6hUq8ViMeIi7T6CILj4t79Va7UoRVgEVmqw/7nTuf/3Lcu6duWK uueG7/sW7a8AANEQgAEAh6P0PiShVqu9/+GHUSqwCKzUg/o/X/nhhwddCxwdtx8B AKQgAAMADieGReA/XLjwxJNPRinCIrA6er/ve96u36zv7Gxtbqo7/cvyLwBACgIw AOBwtEoln8/ncjl1i8Ci7sW//31R06IUWV9ft21b1pQwEgRB/74U6jjO1R9+UHRH 9Nxw+dd1XTEK7a8AABERgAEAh1at1QqFgrpF4LnhRuv3PvggSgXuBFbBMk3nvh8r XL1y5UF3Akvh+75t2929Dh4DAHAoBGAAwKFpmjZYBFZ5EjgMw9+9+OKTTz0VpcjG xoZlWbKmBPGg9Lvd8N7rf3e2t8Uvpc+EweKv4/T7fUVDAADSgwAMADiKGBaB5+bn //rBB0vHjh25gEhNa2trEmeUcve3vzJN8/q1awvKjv7OsfwLAJCKAAwAOAqtUsnl ckrbQQvlxcWPLl2KUmF7e1vXdVnzSbl+rxfc2+f5h++/D4NA3Yij5s+u63L6FwAg BQEYAHBEcSwCz8099vjjF1599cif7vv+8vKyxPmklue6xr0/SlhZXladS1n+BQDI RQAGABzRYBE4m80XCkoXgYMguPDKK7954okjV2i1Wu12W+KU0mnX7UeNen1zY0Pd vUdzo+Vf23Y9j+VfAIAsBGAAwNFVqtVCoZDNZkVWUdoG6e13333o9Okjf/ry8nKg cqfuzPM8z7irB5VIpLdu3lS3+D96OolBbdvm7l8AgEQEYADA0Wmalv15EVjpOnA+ n//go4+KxeLRPl3X9e3tbblTSpW7l39FLr3y449KX0CEQ45ti7Fo/gwAkIgADACI pFKpDHph5fOqB6rVan95/32Rt4/wuSJNra+vO44jfVZpcPfp3yAIrl+54t3bCkuF Qe8rx+mx+RkAIBUBGAAQVbVWKxYKGcXdsIQzZ8++8fbbR/tc13VXV1flzicNwjA0 +n3/58R78/r1GK5WDnzfovcVAEABAjAAIKpRN6zCUfcnjy8IgocfffS1P//5aJ/e aDS6HCg9pLvv/r1982a/31fa+GrEtix6XwEAVCAAAwAkuNMNS/VAIgM/8eSTf7hw 4QifG4bh7du3xVvps5pV4mslUujopt/VlZVOux1D+qX3FQBAHQIwAEACTdMWslmR gWMISCIDn3/++WfOnz/C5xqGsbW1JX1Ks8q2LHu44Xlzc7O+va36zue54YMr0q9P 7ysAgBoEYACAHFqlks/l8oVCDGOJmPTsc8+JX4f9xDAMRZaL4RTrDAh8f7QJeXNj o76zE0P6FRzbdlyXzc8AAEUIwAAAaSrVarFYFElJ6bXAIyIDP/Pcc+cPn4F9319e XlYxpRlj9Pue58WTfkdPGPHQWJbF5mcAgDoEYACANKON0KPbelUH4LlhBn762Wef e+GFw35it9ttNBoqpjQzRr2vNtbXG/V6DGu/o4PZIv2y+RkAoBQBGAAg06AjdC5X iGUj9NwwAy9q2ptvv12t1cb/LK4F3p/4qjZ2dm5ev+77fgyHukds23bZ/AwAUIwA DACQLLaO0HeEwwXEcql06qGHHn388V/88pcHrj+LuCUycDzTmwriS9hqNne2tnrd ruM4IvfGsIZ/B52fAQDxIAADACTTNC2zsFAsFmNbPNwlCIKFhQUxjVOnTz/8yCOn z5zZM8u1Wq12ux3/9BJCJN5Ou13f2el1OpZti3+f4ONlWdag5xabnwEAihGAAQDy ifCZzeVGh4EnTuQrEe3EZCrV6vETJ86cPfvQ6dOjTl3p2Qgtvggi7nZarV6/bxmG 53niNyeVeHcR6ddzXdIvACAGBGAAgBJapVLI53P5/KQnsodwaCGbzefzIgSWygOL IrVXKnHu3FZBJNt+r6f3+4ZhmIYxulN39COAOLc0j891HNtxOPoLAIhHEr8XAgBm w51bkSY9kXGFPxuExUxGJGQhNySicq4gEv1AoVAQ/x7n38v3/UFQtEVUHHCH77hD IvGKiBuKjDu8SWgktolFxL1HAICYTc33SADANKrWaqVSaYoi2fjupOW50XfT0d/x rgAqIvT8QddBjT5fxNfB+6PbgIYFf7oX6Od6s/oFNE2z2+lMeiIAgBSZwW+oAIBE qS0tiQw86VkgcUT67aS4CRkAYCIIwAAAtTRNG9wMnIyGWEgI27JcGl8BAGJHAAYA KDdoiFUoiBg86YkgEUT0tW2bxlcAgPgRgAEAcahUqyIDT3uPZUTneZ5IvzS+AgBM BAEYABCTqWsKDelo+wwAmCwCMAAgPtVqtUAGTiuRfm3L6pJ+AQCTQwAGAMRqhi9G wj649AgAkAS8/gAAxK22tFQsFsnA6SHSr2VZXHoEAJg4XnwAAOKmadpCNlsoFDKZ zKTnAuWCILBt2/c8Lj0CAEwcARgAMAGjDFwqlSY9EShnmibpFwCQEARgAMBk1JaW CMBpIAIwm58BAAlBAAYATMbJU6e4FjgNPM+r7+xMehYAAAwQgAEAcatUq/l8PpfL TXoiiInruo7jcP0vAGDiCMAAgPholYrIvSL90gI6bcIwFBlYJOF+rzfpuQAA0ovX HwCAOGials3lCoUC0TfNRAy2bdsTMZieWACASeBVCABALRF9MwsLxUJBvJ30XJAI ge9bti3eEoMBADEjAAMAFKpUq4V8PstxX9zHc12bg8EAgHgRgAEASoyO+xYKhUlP BIlm2zYHgwEAsSEAAwAkGxz3zWYLxSLHfTGOwcFgy/I8jx3RAADVeGkCAJBmdNy3 UCgscNwXh+T7vs3BYACAYgRgAIAclUolXyhwuy+iGNwYbNs9dkQDANQgAAMAouKK I0jEVUkAAHV4pQIAiKRarRaKRfY8Q67BjmjL6tIjGgAgFQEYAHBEWqWSH5r0RDCz nCF6RAMAZCEAAwAOTdO0hYWFQrGYyWQmPRfMuCAIbMvyaY4FAJCBAAwAOByaXSF+ NMcCAEhBAAYAjGtKL/gNwzAIgkwmI96ZH5r0jCZm9KUYvbOwsDBdXwquCwYARDdN 3/kAABNUqVRE9BUBeNITOQQRmXK53EuvvPLwI4+Mfse27Z2trUaj0W639V7Psm3X cXzfF380M9k4/Jl4P7OwkF1YyOXzxWKxXC4vDn+EMfqwdqu1tro6dX9rEYBFDGYp GABwNNP0PQ8AMBHTuPAr4p+Y84svvfTYb34z5qe4rttqNjudTr/XMwzDMk0RtFzP E78f+H4giEg5TJUTCY13x9rRBOYzIt4OZHO5vAj6+Xxmfj5fKJRKpfGbcjcbjY31 9emKwSwFAwCObGq+2wEAJmIaF35Flvvdiy8+8eST6oYYrUOalmUPf7Xabb3f931/ sMdYpOXhTuPB/4b7jfeXyWRElB0QkXa4LVnEV/FOTnzRc0P5QbwdJ9OOkqFj24f9 69R3djY3NqbrLiuWggEAR0AABgDsbdDqOZstTtvC77PPPffM+fOxjajreqPRGG2i TgjPdU3DGK0VH8rW5ubO9vYUxWDxd7Qsy2cpGAAwtql5TQMAiJNWqRTy+dz03PEr stCTTz31uxdfjG1E13VF9DVNM7YRxxcEgcjAIhke4XPXV1ebzeYUxWDXcWzuCgYA jIcADADYrVqrFafnjl8R9n5z7twfXn45tgmLsN1utzudzhFWWWMj5ubYtm1ZR/vc 1ZWVTrs9LTFYPAcsy+p2OpOeCAAg6QjAAID/o2laLp8vFAqTnshYROz59cMPv/La a3EeUTZNs16ve0daXI2fmKep60cL6uLLu3z7dr/Xm5YYbA97erMdGgCwDwIwAOAn lUqleJgGwhMkstnpM2f+9MYb+Rg3aYsw2Ww2dV2PbUQpBqujhnHkxO573q2bNy3L moodAb7vW6ZJZywAwIMQgAEAA9VarVQqJb/fVRiGtVrt9bfeWtS0OAftdrutVivJ e573EWU79IjjOLdu3BApeiqeIaZpsh0aALCnpH8bAwCoNi3bnkWwKRaLf3rzzZMn T8Y5rkiO9XpdJMA4B1UhynboEV3Xl2/dEhWSH4PZDg0A2FPSv4EBAJTSKpXiNFzz m1lYePnVVx9+5JE4B/V9v9VqzdJ+2nDYHTriAeZ2q7W2upr8HdHir2lZFt2hAQB3 IwADQHpVq9ViqZTwJBOG4XO/+91/P/10zOP2+/1GoxEEQczjqhZ9O/TI9taW+JXw E+OD88+m2e12Jz0RAEBSEIABII00TVvIZovFYpL3sor0cu63v/3DhQsxT9JxHBF9 rcgRMcl8zzMMI4wW70WWXltZaSf7tiQxSfFQir8v26EBAHMEYABIIZF+8/nBqd9J T+SBRk2eX3/zzWwuF/O4nU5HJLo4B52UwXZo0/RcN2Id3/cHbaJNM8lbCRzbdjgS DAAgAANA2gwO/RYKMQfL8YVhWCqV3nznndrSUsxDG4bRaDSm5YJfKWRthxZEAL55 40aS+2OJqG/ZNkeCASDlEvpdCgCgQsJv+hXfk1565ZXHfvObmMed0gt+ZZGyHXqk 2WhsrK1lkvoE45ZgAAABGADSolqtlsrlZC7QjY77vvTyyzGPG4ahiEMi/U7pBb+y yNoOPbK6vJzYg8GDW4INg7ZYAJBaSXwZBACQrlarFUulBKZfEX1Pnjr1+ltvxX8R 8cxc8CuFxO3Qc8NF9Zs3boiCCTwYPGiLZZqdTmfSEwEATEDiXgkBAOTSNC2bzYr0 O+mJ7CZySL5QeOOtt06cPBnz0CJ1t1otlgHvJ4Krqeuy1sMNXb9186Z4J4E/eREZ 2KM1NACkT+K+IQEAJBLpN5fLFYrFSU9kNxFBn3vhhaeffTb+oXVdbzQavu/HP/RU GGyHNgyJzcC2Njd3trcTuCPatizXdcnAAJAqBGAAmFmD644KhXw+P+mJ3ENE31MP PfTm22/H34lahDoRfQ3DiHncqSN3O/TcsPvUzRs3RMGk7Yh2BNsmAwNAehCAAWA2 ifRbKBRyCUu/mYWFN95666HTp2MeVyS6brfbarVS3uzqUORuhxZEzrx982bSMrA7 iMBkYABICwIwAMygQfotFnNJuux3Un2e52h2FUEw3A7tS70bOYE9ol3XtS2LDAwA aUAABoBZk7T0G4ZhqVz+y3vvLWpazEPT7Co68fCJcOjYtsSajuNcv3YtDILkNMci AwNASiTlGw8AQIqkpV8RQX/3hz/811NPxT+0YRiNRkNiM6c081zXNAy5G8h3tre3 NjeTsxRMBgaANCAAA8DsSFT6FWGpUq3+5a9/jf+CXxF6m82mrusxjzvbBtuhdV1u 92zxSF2/elXUTMhSMBkYAGZeIr7fAACiS1TXKxGWfv+HPzwZ+8KvSN29Xq/VaokJ xDx0Ggy2Q5um9NPUiVoKpicWAMw2AjAAzILk3HgkMtLi4uK7H3xQjP3yYRHM6vW6 LfW0Ku4nIqIp+yopz/OuXbkSJONUMHcjAcAMm/y3GQBARCL95vL5+Hca308EmKef ffa5F16IeVyRuttDMY+bWr7vm7oufZl9Y329Ua8nYSnYtm2R88nAADB7CMAAMPWW jh2Lf7n1ftls9r0PPqhUqzGPa1lWvV53XTfmcVMuDEPTMDzZX3bbsq5dvZqEu4LF 86rdak16FgAAyQjAADDdaktLpVJpsnMIguDhRx997c9/jn/cZrPZ6/ViHhd32IJp Si97++bNfr8/8RhsmmaHbQUAMFsIwAAwxarVaqlcnuyxySAMRfR9+JFHYh7XMIx6 vS63KTGOwPM8U9fl3pAktNvt1eXlyW6HHq1yc480AMwSAjAATKtKpVJeXJxs+i0W i3+9eDHmDdgi9DYaDW45Sg4VNyTNDaP11R9/lFvzsEQGNnSdXQYAMDMIwAAwlbRK pVQqTXB9TASDRx977JXXXot53H6/L9IvtxwljaIbkoTl27f7vd4Ef9Az6Phlmn0y MADMBAIwAEyfwZW/xWIul5vUBET+fOWPf3zsN7+Jc1CRQ+r1uiH7Ah5IJAKwpeAB ajYa62trE/xxj+u6tmXRFBoAZgABGACmz2TbPs9nMh9cvBhzt2cWfqeF73mGYYSy HymRP69evbowubZYNIUGgNlAAAaAKVOt1crl8qRGr1Qq73/4YZzteTnxO3UGR4IN QyRhuWXDMLzyww8T/CGICPbdTmdSowMApCAAA8A0EfmzVC5P5HoYET8efuSRP8Z7 15HIvfV6nYXfqaPuSPDtW7f0fn8iR4JHwZ6GWAAw1QjAADA1NE0T6XciJyHFS//n f//7/3766ThHbDQanLqcao5tWwpuCd7e2trZ3p7Ij4EGDbEMg6clAEwvAjAATI1J Hf0VWfTNd945+4tfxDaiZVk7Ozue7D20iJ+iW4K73e7yrVsT+WEQh4EBYKoRgAFg OlSq1XK5HP/OTxFd3r94UWTv2IZrtVodTlrOkCAIDF0PZN8SbJrmtatXs7Fn4MHN wIbR63ZjHhcAIAUBGACmwKQ2P4u8/dGlS6W4em65rru9va3i4CgmS4RGU9elL+mL J8yP338f/38XbIQGgOlFAAaAKXDs+PFCoRDzoNlc7u8ff5yN67ZhESfq9br0vbJI iEFbLMtybFtuWZFFRQaOf2eEbdutZjPmQQEA0RGAASDpKtXq4uJizIMW8vmPPvkk nrW1IAiazSbNddNARVss8fz58bvv5mLPwLqusxEaAKYOARgAEm0im5+LxeJHH38c T5ddx3F2dnbY9pweruOYhiG3ZhiGP4gMHC82QgPANCIAA0Ci1ZaWSqVSnCOKvP3R pUvx7CnVdV2kX7Y9p42K1tCDDPz993PxPpdM0+y023GOCACIiAAMAMmlVSrlcjnO +06LxeLfPvkkhvRLt+eU833f6PflZ+B414EHDa4No8/ufQCYHgRgAEiuY8eOFWK8 +Deby1369NMYtluL2LC9vW3KPguK6SKeBrrIwEEgt6bIwHH2xLItq8W1wAAwPQjA AJBQWqWyuLgY20v5TCbz8WefxdDz2XXdra0t8Vb1QEi+wQpqvx9IzcC+74sMHNu+ iTAMdV1nERgApgUBGAASKuarjy599lkMw1mWJdKv3MCDqaYiA3ueJzJwbK3juBIJ AKYIARgAkqhSqZTjWv4V2eN/PvqotrSkeiBu+sWeVGRgyzSvXb0aTwYWT2lD17nH CwCmAgEYAJIottO/InW8/tZbv/zVr1QP1O12G42G6lEwpVRk4G6ns7K8HM9eaE4C A8C0IAADQOLEdvo3DMPnf/e7p55+WvVA7XabeID9qcjA21tb9Z2deP5T4iQwAEwF AjAAJE5sd/+eOXv2jbffVj2KiL5t7krFGAZ9oXs9uZvkb16/blmWxIIPwp3AADAV CMAAkCyappUXF2PYt5nL5T754gvVo5B+cSi+5+n9vtya312+HMMi8GAFWxdzlzx5 AIBcBGAASJZKtbq4uKh6lCAML33ySalcVjoKO59xBJ7riiQpsaDruj9+/30MDbF0 Xe91u6pHAQBEQQAGgGSJ4fajMAz/+Kc/Pfzoo0pH6fV69Xpd6RCYVY5tW6YpsWC7 1VpfW1O9Dsx9SACQfARgAEiQePY/nz5z5s133lE6hGmam5ubSofAbDMNw3UciQVv XLsmAqrEgvdjFzQAJB8BGAASpFqtlhXvfxb/v//5v/6ldCnMdd319XW57XyRNoO+ yv1+4PsSC373n/9kFG+EFgG4yy5oAEgwAjAAJMjSsWNFldf/igzw5zffVHrrr8i9 Iv2KDKxuCKSESL+D1VR5TaG7nc7qyorSn/5YltXm3DsAJBgBGAAS5OSpU9lsVl39 Wq32/ocfqqsv7OzssAUUsriOYxqGxIJXfvjBl7eqfD/P8+o7O+rqAwAiIgADQFJo lYqmaerqB0Hw8WefFVXeMCyi7w6v/iGVoeuevA0FMXSEFv8V9Hs9dfUBAFEQgAEg KVQfAP7FL3/55zffVFff87y1tTWO/kKuMAhEngzlbYS+eeOG3BbTu3AMGACSjAAM AElRW1oqKVueFbn08y+/zOZyiuoLW1tbhtTdqsCI67qmvJuBG/X61uamopPAvu/b lkUABoDEIgADQFIovQH41EMPvf3uu4qKC7qub29vq6uPlJO4EdoyzZs3bkgpdb8g CGzb7rTbiuoDACIiAANAUpw4eTKnZoU2DMMPL11Sd8BYvOhfXV1V2lsIKSeeY315 y6pbm5vNRkNWtbuJ/9ZEAKYRNAAkFgEYAJLiodOnM5mMisrZXO7TL75QUXmk3RYv +HnFD7VsyxK/pJTq9Xq3b95U1ArLse1ms6miMgAgOgIwACSCpmmLmqboXOJjjz9+ 4dVXVVSeGx56XFlZkdijCNiTeI4NumHJ6LLmOM6tmzd9z4teas/iipaXAQDREYAB IBFEANYqFUXF3/vgg2PHjysq3ul0er2eiMH0f4ZqEq8F3lhba6s5qSsm2SAAA0BS EYABIBHUXQIscuk/v/5aReVdwjAUY/k/u/P+6J07/xrDTDCrxHNM7/cDGc+iRr2+ vbUVvc79XNe1Lavf76soDgCIiAAMAIkwAwF4THfn4X3esqcae/Jc15BxJVKz0djc 2FBx6IAADABJRgAGgERQF4BFknz3gw9OnDihorg6wdD9wfj+f530TBE3fbjlPmIR hVugXbdRr6uoDACIjgAMAImg9AywyMAX//73irL6E3Rn3/WBbyc9U0gTfRG4vrOz ubGhqAs0Z4ABIMkIwACQCEq7QM8NF1TPP//8M+fPK6qfcKOc/KBjyawnT50jLwJ7 nreyvCzys6Irx+boAg0AyUYABoCkOPXQQ4qWpO4Q9V986aXHfvMbpaNML5GT7w/G u9p6EZKTwHVd85CLwOKx29rcFNFU6X9l4ikkAnCLe4ABIKkIwACQFMdPnMjn8zEM JP6v/7Fz557/3e/iGW7G7ArJ9ydkgQ5eqg3aQfd6Y/4wwjLN9bU1wzBU/4BpbrjV wrFtRaeLAQDREYABICmWjh0rFouxDSdeqRdLpUceffTpZ54R78Q2bho8KB57nkdC lkXkTJFs9/kA0zC2t7b6/f78UDyzEg+ubdvdTiee4QAAh0UABoCkqNZq5XI5/nFF GMtkMsdPnHj08ccfe/zxbDYb/xzSZtch5FEwJiEfivgS9bvdXV+oUQdmkT8dxxHP 6thy7x3isROxvNfrxTwuAGBMBGAASAp1NyGNT2SwhUxGzOTU6dO/+vWvz/7iF/FH CMw9YA35biRkwbYsQ9dF3BW/TNN0PW9hEqH3blwCDAAJx8saAEiQh06fVtec9ghE DBNxolgsVmu14ydOiOmdPnOGJeIkuHu5eBfx+7Paqct1nHarJeKuSJiWZQW+H+f2 5gPRAQsAki8p3zMAAHOxHwM+gtF9QiID5/P5UrlcqYpoXBPTPnnqVMJnniqjTl27 UvG0LCCPYqRIuXq/bxqGbVmO6w7mHAQT2dU8Pg4AA0DyJfe7CACkkMiTi4uLk57F EY1WHUVEWVhYyOVyBaFYFCFZBOPy4sDormPxR5OeKfZeQL7zO4oWkEWyFUNYlmUP fzm2LZKtyLqe+OV5gRj351ieqH0Q4xvsf7btPgeAASDBCMAAkCAiIorEGMNlLRMU DheRRdCZn5/PDIl3stns/DA5Zwf/G70ZvBX/yIl3stlRrhbEOyJCZ4b/Pnone2+i 5m6nowtDkUhH74zysDOMpoO3Itt5nkird7ZYDx7GYVYerc0GP7/jD98Ph2vQ4fDh Fv+bGy7bJmq7snSDhWvbbrVak54IAGA/M/t9CACmVK1WK02iFzSAKALfNy2r1+1O eiIAgP0QgAEgWTRNKy8uTukWUCC1HMdpNhqTngUA4AAEYABInNrSUqlUmvQsAIxr 0P7Ksros/wJA4hGAASBxWAQGpgi3HwHAFCEAA0ASVavV8tS2gwZSxfd9yzR7NH8G gGlAAAaAhDp+/Hi+UJj0LADsJwgC27Y77fakJwIAGAsBGAASKg1XIgFTLQxD13Ga bH4GgOlBAAaA5KpUq+VyeYavTgWmmue6lm332fwMANODF1UAkGhcCwwkUxAEpmly 8S8ATBcCMAAk3dLSUpFbkYAkGdx7ZNvdTmfSEwEAHA4BGACSTtO0bC5XLBYnPREA A4PGV5bVIf0CwBQiAAPAdGAdGEgC1n4BYKoRgAFgatREBi4W6YkFTEoQBJZpdjn3 CwBTi1dRADBNKtVqqVTKZDKTngiQOq7rOrbdo+czAEwzAjAATBmtUikUCrlcbtIT AdIiDEMRfUUA7vf7k54LACASAjAATB9N0xayWbZDAzHwPW9w6JdtzwAwE3jlBADT arAUnM/n8vlJTwSYTUEQOI7jeV6fbc8AMCsIwAAw3SrVaqFQyGazk54IMDvCMHQH R34dTvwCwIwhAAPA1NM0LbOwkM/nicFARD9FX9ftsecZAGYRARgAZsQgBmcyuXye /ljAEQw6XQ03PBN9AWCGEYABYNZUKpWFbDafz3NbEnAgkXtHZ3193+esLwDMPAIw AMym0YKwSMK5XI4kDNxPJF7XdcVblnwBID0IwAAw435KwgsLIgqLt5OeDjBJo/Xe Ue4V73GvLwCkDQEYANJCJOH5+flBFBZhOJtlWRgpMQq9nueJ0CveYZ8zAKQZARgA 0uinMDxcGs5ls+I98a+TnhQgjQi9Iu6K0BsMEXoBACO83AEADPNwZhiHM5l8oTDp 6QBHMdjb7Dh+EITiVxiyvRkAcD8CMADg/1RrtXK5POlZAEfh+75lWXS0AgDsgwAM APg/x0+cyOfzk54FcBSj24zardakJwIASC4CMADgJ5qmlRcX1TXHCsOQk8YpJ54D 4q26p4Hruo16XVFxAMAM4IUIAOAnlWp1cXFRUfEgCD79xz/EW0PQdduy7CGRWBzH 8VzXGwqGjXpHV9QEw+a9IjOJdwbJaWhUbfTO8H/h3aMQsKMK7/2CDr+ko59czI/+ Rfzr8KG587Ue/t786B+Zn1qrDZqqDfqND2+iHnUdF/L5fC6f7/d662triqY/2AVt mj1aXgEAHoAXCgCAnywdO1YsFhUVF3Ho8y+/lFjQsqyNjQ2JBTEOkXBdxzF0/cgV TMO4fu2aoiupRTa3LavT6agoDgCYAQRgAMBPTj30kKJYIpz95S9ff/NNiQWbzSY5 ZyI8zzMiNFh2XffW9eue70uc0h1hGIr6zUZDRXEAwAwgAAMABiqVyqKmKSouYslf 3n//5MmTEmuurq6KqCOxIMYkHs1etB89bG9vN3Z2ZM1nF9/3TdPk4l8AwJ4IwACA gdrSUqlUUlQ8DIIvv/5aYkHP81ZWViQWxKH0u93B8eyj0nX95vXrqnZB+75l2112 BwAA9kIABgAMnDh5MpfLKSperVY/+OgjiQV7vV6dZr+TY+p6lOV327ZvXL06p6Zj WRiGjm23uAwJALAXAjAAYHAB0qKmqWuh/MLvf//kU09JLLi9va1H6MOEiAb9u03z yJ/u+/762pq6Xcqe59WVbbEGAEw1AjAAYK5aq5XLZUXFgyD4x7//LfF64TAMl5eX o2zBRUQR+2AJvW53ZXlZ0c9cBpchWZYYQkVxAMBUIwADAOaOHT9eKBQUFc/n8x9/ /rnEgrZtr6+vSyyIw4reB8syzWtXr6q7DMmx7Xa7raI4AGCqEYABIO00TSsvLkpc od3lsccfv/DqqxILdjqdZrMpsSCOIGIfLM/zbt+6JWKqxCndzXXdBqfEAQD3IQAD QNpVqtXFxUVFxcMw/PDSJU3qBUtbW1uGYUgsiCMwdN2Ldg1Vs9HY2tyUNZ9dRDgX TxIuQwIA7EIABoC0Wzp2rFgsKiouvs188e9/SyzIAeCEsC1L/IpSQUToG+ouQwoC Mb0OlyEBAO5FAAaAtDt56lQ2m1VX/J333pNYkAPACeG5rhGtEbfjOCIAh2p+ljG4 DMlxWmyVBwDciwAMAKmmVSpy9yfv8tqf//yrhx+WWJADwAkRvQ+WqLC5sdFWdmGv 7/umYfSjdasGAMwYAjAApFqtVispuwBJJJB//e//yq3JAeDk6HW7Eddv+73e7Vu3 FDVgE08/27K6XIYEALgLARgAUu34iRP5fF5R8fLi4keXLsmtefv2bQ4AJ0T0PliW ZV2/elVRAA7D0LZtdSvMAIBpRAAGgPTSNG1R0+bnVX0v+O9nnjn//PMSCzqOs7a2 JrEgoojeB8v3vJWVFVPZkj6XIQEAdiEAA0B6VavVsrILkIIg+OzLL3O5nMSavV6v Tp5JjOh9sIROu72u7Icavu9bptnjMiQAwM8IwACQXseOHSsouwBpYWFBBGC5NXd2 duhplBxhEPQin7A1DOPGtWsKL0OybZGxVRQHAEwjAjAApJSmaaVyWVHwEH7561// 6fXX5dZcXl72fV9uTUTR73YjHsl2XffmjRu+58ma0i6O4zQbDUXFAQBThwAMAClV qVQWlV2AFIbhe//zP8ePH5dYUySl1dVViQURXfQ+WMLO9nZ9Z0fKfO43uAzJNPvs ggYADBGAASCllpaWiqWSouIiAH/51VdyaxqGsbW1JbcmIoreB0vo9/u3btxQtwva sqxutCuLAQAzgwAMAGlUqVYXlbW/EorF4t8//VRuTQ4AJ5DneUbkB8UyzevXrim6 DGluOEmRgVkEBgDMEYABIJ2Utr8SXnzppXO//a3cmhwATqAwDHuRF1eDIFhfXVXX q5lWWACAOwjAAJA6qttfibzx5Vdfyb1e2BteGCuxIGSJ3gdL6HY6ayoPeNMKCwAw QgAGgNRR2v5KmM9kvvjnP+XW7HQ6zWZTbk1IYeq6G7kPlqHr169fzyr7oQy7oAEA IwRgAEgdpe2vhMfPnXvp5Zfl1tzc3DRNU25NSGELkR8aEVBv37rl2LaUKd2PVlgA gBECMACkzslTp7LZrKLiYRj+/ZNPSuWy3Jq3b98WbyXWhCxS+mAJzUZja3Mzep09 iSeP4zgtNhEAQOoRgAEgXVTvf1ZxAZJpmpvKohEiktIHa07xZUhzo13QpkkjcQBI OQIwAKRLbWmppHL/88lTp9557z25Nev1uroWwYhOSh8s27ZvXr+ubp3f930xBLug ASDlCMAAkC4nT57M5nLq6r/5zjunz5yRWFAkopWVFS5ASjLTMFzHiVhEPNBbm5vq dimzCxoAMEcABoBU0SoVTeX+5yAI/vn113JrWpa1sbEhtybkcmzbktGirNftriz/ f/buw72t48z3OMWGQgAEqGL1LlHFcW6c5CbuJY7tuBdVt5vsn5pknbjLkiyJYic6 CZAg6um4Q2pXq1WlqJnBwcH38/jx1rxzJBwA54eZeWdB7gFad6IXNACAAAwAPUTp +ud2uz0Si33w8cdyy5bL5Wq1Krcm5JLVB0uk6Ompqf7+/icvdV+sggYAEIABoIds 3bZtSNn6Z/GNcubiRblNjESozmQyIl9JrAnpZPXBEuq12tzsrKJWWKyCBgAQgAGg V8Ti8ZGREXXrS5/aufO1N96QW5P1z91CBFdPxj5tEVBnZ2aklLovekEDQI8jAANA r1C9/vmNt97avmOH3LJLS0tkla4gpQ9W3/qNtFgsLpfLT17qvtZWQRsGi+oBoGcR gAGgVyhd/6zi+F9Rc35+Xt25OJDIsiyj2ZRSSumBwGuroE1zZWVFRXEAgP8RgAGg J6he/yzS9Z/ffltuTRGElpaW5NaEIq7rNiR1V1Z9IDCroAGglxGAAaAnKF3/LDz3 4osHDh6UW7NQKLRkHK4DDST2wRKlCrlcpVKRUu1erIIGgF5GAAaAnqB0/bPjOGcv XAiFw3JrptNpiQWhWqNedyX1667VavNKe0GzChoAehUBGACCT/X6Z9d1P/9//09u TZFP1M0BQgWj1RLBUkop0zBmpqellLovx7YNw2AVNAD0IAIwAATf6OhoJBpVV3/P 3r0vvfqqxIIc/9uNbNtuNRpSSnmel8/lqpLWVN+LVdAA0LMIwAAQfF23/rnVahUK BYkFoYFIrXV5kbJWqy3MzfX398sqeCdWQQNAzyIAA0DAKV//7Dif//WvcmsWi8Wm pDN1oFNtdVVW92bDMGaVroKmFzQA9CQCMAAEnOr+z7v37Hn5tdckFnRdd2FhQWJB aNNsNBzbllJqbRV0NqtulTKroAGgNxGAASDgtm3bNthV658rlQprU7uUiJTiH1nV atXqwvy8wlXQlrWyvKyiOADAtwjAABBk8Xh8JBZTV1/6+mcRS9LptOu6EmtCG8e2 m5L6YPWtr4KemZ5W96TCKmgA6EEEYAAIMtXrn3ft3v3K669LLCgyTz6fl1gQOrXb 7Zq81s2e5+UymVqtJqvgXdZWQZumul7TAAAfIgADQJBt2759cHBQUXHXcc5IXf8s Ak+xWDTkraGFfvVqVbyOsqpVq9U0q6ABAPIQgAEgsFSvf3Zs+4u//U1iwXq9vrS0 JLEg9Gs1m7ZlyapmtFprq6CV9TBfWwVtGHVlk8wAAL8hAANAYCWTybDK9c9P7dr1 2p/+JLFgoVBotVoSC0I/yzQNeS+i53nZdFrdNl3PdQ1WQQNALyEAA0AwxWKxSDQ6 MDCgqL70/s+cfhQM4nVsSJ1QZRU0AEAiAjAABFM8kRgZGVFXX3r/Z5FzyuWyxILo iLU+WNWq+C+yCuroBc0qaADoGQRgAAimZCoVlno871327tv34iuvSCyYz+dpfxUM zXpdpEpZ1TzPy2ezVRGq1RD1TcNYZRU0APQGAjAABFDXrX8WBdPptKxq6CyRJ02p v2XUqtX5uTl197NlWcusPgCA3kAABoAASiQSUZXrnz3P++yrryQWrFQqKysrEgui gxzbbjYaEgua66ugJRa8i7u+ClrdgcMAAP8gAANAAI2NjQ2HQurqHzpy5A/PPSex YCaTsW1bYkF00No2YKkrikXBfC63WqlIrHknz/Ms06woqw8A8A8CMAAETSwWG4nF 1B2dKpLquYsXJa5/tiwrm83KqgY/qFerIlVKLFir1eZnZ9WtghZ3dblUUlQcAOAf BGAACJrE6Gg0GlU6xIUvvpBYbXl5mRZEAdNqNm3LkljQNM3Z6em2vObSd3Fdd20V tLJWWwAAnyAAA0DQbN22bWhoSFFxkUBOnD79m2eflVgwnU6L+CGrIPxApF+RgeXW LBQKK8paVYn7UGTsChvRASDoCMAAECixeHxkZETh+mfLOvfZZxLXP7daLRFsZFWD T3ieV5c9m1qv1eZUroJ2bHvtQOB6XVF9AIAfEIABIFBGk8lIJKKufv+WLec+/1xi waWlJSJHINVWV+WuWLYsa3Z6Wu7W4ju5rmuaZpXV+AAQaARgAAiOWCwWjkQGBwcV 1Rd55uVXX92zb5+sgiLMLCwsqNvYiQ5qNhqO7M7eS4uLpaUluTVvE/ehyNgry8uK 6gMA/IAADADBEU8kRlQe/yviwVf/8R8SCzYajcXFRYkF4R+WaRqtltya9Xp9bmZG 4Sro9QOB6xwIDADBRQAGgOBIpVISd+feKxwOf3TmjMSCxWKxKbtVEnzCdd2G7CRp 2/b83Jzc/tJ38jzPNE11Bw4DADqOAAwAARGLxSLRqLrJMZFn3vvgg9FUSmLBhYUF WdXgN+12e+1UIdnr25fL5aLKrmkiXZeV9ZoGAHQcARgAAkL18b8iGHwpdf1ztVol aQRbs153HEdyzWZzZnp6oL9fbtnbOBAYAIKNAAwAAaH0+F8hmUq9/e67Egtms1lL 2VpW+IFpGOIfuTVdx0kvLLRk7y6+jQOBASDYCMAAEASqj/91XfeTc+ckHrAkoq8I wLKqwZ9EWG0oOONqtVLJpNP9yiaBORAYAAKMAAwAQZBMJsMqj/8VSebzv/5VYsHl 5eVVDlwNurVtwApeZaPVmpmeVvpzDwcCA0BQEYABoOupbn8l7Nu//4WXX5ZVTeSi dDotYoasgvCtRr3uyt4G7HlePputKtumK+5P27KWORAYAIKIAAwAXU/18b+2bZ+7 eFHiAUvNZrNYLMqqBj9TsQ24b72D2sLcHAcCAwAeFwEYALpeamwsFAopHKDdvvDl lxLrLS4uNhoNiQXhWyJJNhVspjVNc3Z6ui37jKXbOBAYAIKKAAwA3S0Wi43EYur2 Q4qM8fxLLx04eFBWQREtFhYW1EUX+IqibcBCsVBYVnmMlm3b5VJJXX0AQEcQgAGg u40mkxKbM99L+vG/tVqtRK7oJSq2AQv1en1uZkbdKui1VliGoW6nMQCgIwjAANDF YrFYOBIZHBxUN0Q0Gv3gk08kFszlcqZpSiwIn1O0Ddi27YX5eUvZvdRuty3LWqEV FgAECwEYALqY6vZXrut++MknsXhcVkERWjKZjKxq6AqKTgMWRDrN53Lq1v/TCgsA gocADABdTHX7KxEAvpB6/O/KykqFxkI9pt1u16tVFbu+W83mzPR0f3+/9Mq30AoL AIKHAAwA3SoWj4+MjKib/urj+F9I0mw0HNuWXlYE1Fw2W1O5Tde2bdMw6mpmsAEA +hGAAaBbKW9/xfG/kMQyTaPVUlFZ9YHAtMICgIAhAANAV4rFYpFoVN1zv9Df33/u s88kFuT4354lYmRDzU5a0zTnZmY8z1NRvI9WWAAQOARgAOhKqttfiUTx+ptv7ty5 U1ZBEYEWFhZkVUPXqVWrbTUxdWlxsbS0pKLyLY7jmIZRoxUWAAQCARgAutLY1q3D w8Pq6luW9ZXU439XV1eXmUbrYa1m07YsFZUbjcbc9HS/stUQnudZpknzNgAIBgIw AHQfDe2vRpPJv7z3nsSCmUzGVtAGCd1CvPotNQvgHcdJz88bCo4avo1WWAAQGARg AOg+yWQyrLL9lUgUn54/L7HDlmmauVxOVjV0o3a7XVtdVVR8tVLJpNPqzkNaa4Vl mlVl1w8A0IYADABdRkP7K5FVLn75pcSCpVKJLZRo1Ouu46iobBjG3MyMiqOGb7Ms a7lcVlcfAKAHARgAukxidDQajaqrL1LEi6+8sm//flkFPc9Lp9Pq+vSiW5iGYSpb qFwsFpdLJUXF+261wjJNpWcOAwA0IAADQJfZum3b0NCQuvrS21/V6/UllU160S3U HYbUt36bzc/OqlsF3W63RQCurKwoqg8A0IMADADdJB6Pj8RiSodIplJvv/uuxIL5 fF5pgyJ0EXWHIbmOk0mnm82miuK3OI4j7uQ6i/kBoJsRgAGgm6TGxkKhkLr60ttf 2badyWRkVUO3M1otyzQVFVfdCsvzPNM0VzkPCQC6GQEYALqGhtOP+trtC1LbXy0v L6/SOxf/zXGcprLDhEzDmJub81xXUf0+zkMCgO5HAAaArqH69KN2u/3Ka6/t3rtX YsGFhQXaX+E2cUvUq1V17ZpLpdJSsaioeB/nIQFA9yMAA0B30HD6Ee2voEGr2bQt S1HxRqMxPzOzRdkq6D7OQwKALkcABoDuoPr0o771/tJ/fvttiQVpf4V72bbdajQU FXddN5fNKu1T5TqOwXlIANC1CMAA0AVisVg4EhkcHFQ3hOM4Zy9cCIXDsgrS/gr3 1W63ayqXENdqtfnZWXVrJcT1W6a5wnlIANCdCMAA0AXiicTIyIjSIbZs2XL+888l FqT9FR6k2Wg4tq2ouGmaC/Pz6ur3rf9aZBpGjfOQAKALEYABoAuMbd06PDysrr7r um++/fb2p56SVZD2V3gI27JaKg/sXVlZKeRy6uqLG9syzQrnIQFAFyIAA4DfxePx qOLTj2zb/vJvf5NYkPZXeAjVq6Cbzeb8zEyf4rcM5yEBQDciAAOA36XGxkKhkLr6 Io0cPHz4uRdekFiT9ld4uFajYStbpSxu6cVCYXl5WVH9vvVJYNM0V5kEBoBuQwAG AF+LxeMjiqd/Lcs6/9lntL+CTkp7Qfetn4c0NzPTr/I8JCaBAaAbEYABwNeSyWQ4 ElE6hAjY73/8scSCtL/CI7Xb7Xq1Kv6tqL5Ip9lMRulOY9d1TdOscqsDQFchAAOA f8VisUg0qu5Al771frafnD0blddi2vO8dDpN+ys8kkintmWpq1+v1ebn5pROAluW tVwuq6sPAJCOAAwA/jWaTEYUT/8KF774QmK1Wq1WKpUkFkRQOY7TVLl+2DCMhfl5 13HUDbE2CWwY1WpV3RAAALkIwADgUxqmf8Xj+5/ffnuHvNOPhGw2a6mc1kNgqF4F 3af+PKS+9WOHV1R22wIAyEUABgCfSoyORqNRpUNIP/3IMIx8Pi+xIILNaLUs01RX v9VqzU1PKz0PyXEckYFrTAIDQJcgAAOAH8VisXAkMjg4qG6Idrt95Nix//vHP0qs ubi42FDZ2hcB47luvVZTV3/tPKRiUek2XTGEyMBllv0DQJcgAAOAHyUSCYmNqe7L Ms3zn38u8fQjEQPS6bSsaugRjXpd6TbdRqMxOz2tdCtB33pDLzqfA0BXIAADgO+s Tf+Gw4NDQ0pHSY2NvfXOOxILrqysVCoViQXRC2zLUnpYkeM4+VxO6Txz3/p2+qXF RaVDAACkIAADgO/EE4kRxdO/tm2fu3hR4vRvu91Op9MiBsgqiB6hoRVWrVabn51V PQncbDY5ExgA/I8ADAC+s3XbtiHF078i+n585ozEgo1GY5EZMGyK6lZYlmVlFhZM lUP0MQkMAF2CAAwA/qJh+lc8qX/46aexWExizXw+bxiGxILoHeKGbCheory6uioy cH9/v9JRmAQGAP8jAAOAv2zdunVoeFjpEOKj//wXX0gsaFlWNpuVWBC9RgRgpevn DcNYmJtTvUSfSWAA8D8CMAD4iJ7p3zffeWf79u0Sa5ZKpZriGTwEm2VZhspWWEK5 XF4sFJQO0cckMAD4HgEYAHxkbOvWYcXTv67jfP7Xv8os6LrpdFppEyMEnoZWWCKa zs/Oqqt/C5PAAOBzBGAA8AsN078iYDz/0ksHDh6UWLNSqaysrEgsiN6kuhWWUCwU lstlpUP0MQkMAP5GAAYAv9Aw/Wvb9pd/+5vEgpx+BFk8z6tXq0qHaDQac7Oz/VvU PvwwCQwAfkYABgBf0DP9+3+effbk6dMSa9ZqtVKpJLEgelmr0bBtW1198RbIZbMa pmeZBAYA3yIAA4AvaJj+tSzrq//4D7k1s9msKCu3JnqWhvOQarXa/NzcgOLzkJgE BgDfIgADQOdpmP4Vdu7a9eqf/iSxYKvVKqhvq4ue0qjXXcdRV3+tZ9vCQktxx+k+ JoEBwK8IwADQeRrO/rUs6/xnn4XCYYk1RfoVGVhiQcCx7WajoXQIkUtFBu5nEhgA ehIBGAA6TM/079Zt2/789tsSC4pEnc1mJRYEbqnXap7Ktmqu40zevKnh4K5Wq7Va qageBQDwWAjAANBhIpoODQ0pHcK2rHOyp39LpVJN8XZN9CZxu6peoixyaTaT2aK4 HbTI2I36GqWjAAAeCwEYADopkUhE1U//JkZH33n/fYkF1zZSptMa5tDQg9ZyY63m eZ66IRzHmZyYUFf/NtM0V5aXNQwEANggAjAAdEwsFgtHIoODg0pHsW373MWLcqd/ K5XKysqKxILAnTRMAot7OKdnErjRqLNWAgB8gwAMAB2TGhsLhUKqR4lGox988onE guKZPp1Ouyp3aaLHaZgEtm17amKiT3EA7lufbS4tLakeBQCwQQRgAOiMWDw+MjKi egJKPOWfuXAhEolIrFmr1UqlksSCwL00TAKvLC/ncznV70Gh2WhUq1XVowAANoIA DACdMbZ167Dio4/61Ez/ZrNZkasl1gTuFaRJYPGnEBmYblgA4AcEYADogO6d/m00 GoucbgotgjQJbBhGhW3zAOADBGAA6AANRx8J4Ujko08/lVszm81aliW3JnBf7Xa7 Wa8r3W0ubuapyUkND0Nrf5ZGg5PDAKDjCMAAoFs8Ho+qn/51bPtT2dO/rVarUChI LAg8nLiNRW5UOoS2SWDHcYxWi4XQANBZBGAA0G3btm2D3Tn9m8/nDcOQWxN4uGa9 LqKjouLtdnvq5k3btjUE4L71n5BWKxUNAwEAHoQADABaxROJkZER1aOo2P1rmmYu l5NYENgI13UbalYOL5fLuWx2YGBARfH7YiE0AHQcARgAtNqxY0e/+gdukbHf//hj uTUXFxcbihejAvfVajZtqTvPbduenJgQ/42eid+7hjYNg4XQANApBGAA0CeRSES1 TP+eu3gxFA7LrZnJZCQWBDbO87y6vHN00wsL1dXV/v5+WQUfl8jzq6urnRodAHoc ARgANInFYpFoVMN6y8To6Dvvvy+3ZqlUYt0mOsg0DPOJ95/X6/XZmZlBjWue72vt WOBms84bCgA6gQAMAJqMjo6KAKx6FNuyzn32mdzpX8dxMplMu92WWBN4LOL2a9Rq Ijpu7j8u/oOTExOu6+pf83xflmUtl8udvgoA6EW++BoAgMCLxWLRkRENqy7Htm59 8y9/kVtzeXmZFZvoONu2W5vahV7I58ulUgfXPN9Xs9ms8rYCAO0IwACgQzKVCkud lb0vFbt/XddNp9NM/8IPHvdIJNM0JycmdPZ53jjxzmo1m3TDAgDNCMAAoFwsHh8Z GdGw9nLb9u1vvPWW3JorKysVTi6FP3iuu/Gts1OTk5Zp+mTN832ZhiHeX52+CgDo Lf79VgCAwBgbGxsOhVSP4jjO2QsXpE//ZjKZTW+8BKQzWi0Rax/+/1MulfK5nD8n fu+0dixws1mT1+AaAPBIBGAAUCsej0e1TP8eHx9/9ve/l1uT6V/4zcO7YTmOM3H9 +pZ1mi/scYk/iGkY4oJZBQ0AOvn96wEAulosFgtHIoODg6oHsm37y7/9TW5NkTHS 6TTTv/Abx7ab9+uGNTs93Wq1/B99+9bfsJZpcrQYAOjXBV8SANC9EqOjUfVHH7Xb 7f/z7LMnT5+WW7ZSqbBBEf7UajREhrz9P64sL2fT6QH1vzQ9Oc/zTMNwXZeJXwDo CAIwAKgSi8Ui0aiGjYiO43zx17/Krcn0L/xM3JmNWu1Wc/LMwsLq6qrfTjm6L2vd xvt4AQCkIwADgCrJZDIciageRWSAF15+ef+BA3LLMv0Ln7Mta7FYXJib64ro67qu aRhV+l0BQKcRgAFACW1HHzH9ix4k8uS1K1fqtZr/02+73bZM07Zt1jwDgB8QgAFA ibGtW4eHh1WPIp6t33jrre07dsgty/Qv/CyXyczPzvo/+vat/z5lmiYHHQGAfxCA AUC+eCIxMjKiYSDP8z776ivpNZn+hT8ZhnH1558d2/Z/q2dOOQIAf/L79wcAdB1t va/EE/Zf3n8/mUzKLcv0L/xpenKymM9reGc9OU45AgDfIgADgGSjyWREfe8rYUt/ //nPPpNbk+lf+FCtWr12+XKf72d9+26dcmSaLhO/AOBXXfBdAgBdRFvvK/Gc/f5H H8UTCbllV1ZWKpWK3JrApon7/MYvv6xWKl2x45dTjgDA/wjAACCTnt5XfetJ+70P P5Rb03XddDp962xVoONKi4uTExNdEX3XTjkyzerqaqcvBADwCARgAJAmkUhEtfS+ ch3n/OefDw4NyS27vLy8yhM8fMBxnKuXLhmG0RXNrjjlCAC6iN+/VwCgW2jrfSXs 2r37lddfl1tTRI5MJsP0LzouvbCQnpvrimZXnHIEAF2HAAwAciRTqXA4rGEg8cz9 2VdfSV8XWiqVaFqLzmq1WlcvXXJdtysmfg3DoNkVAHQdv3/BAEBXiMfjUS29r4SD hw798YUX5Na0bTuTycitCTyWyYmJpWKxKyZ+aXYFAN2LAAwATyoWi4XC4SHZO3Lv y3Xdz776SnrSXlxcbDQacmsCG7RaqVy/etX/s759NLsCgO7XBV82AOBzo6OjkWhU z1gnT5/+9W9+I7emeKDP5XJyawIb4XnetStXatWq/1s9t9tt8U5xaHYFAF2OAAwA TyQWj0ejUW2P7xe++EJ6zUKh0Gq1pJcFHm5p/ZSjAd9HX0Hk3rVmV6x5BoDuRwAG gCei7eDfdrv9x+efP3TkiNyyhmHk83m5NYGH66JTjjzPMw3DdV0mfgEgGPz+xQMA fqbt4F9hcGjozPnz0svmcjnTNKWXBR4km07Pz852RbMr89YBv0z8AkCAEIABYJN0 HvzbbrffeOut7Tt2yC3baDQWFxfl1gQeROTJK5cuObbdFRO/rVaLA34BIHj8/g0E AL6VGhsLhUJ6xhJh+72PPpJbU4TqbDZr27bcssB9zU5P57NZ/0/8rjW7MgyHA34B IKAIwACwGfFEYkTX4mfXdT8+ezYqu9F0tVotl8tyawL3ajYaV37+WSTLTl/Io9nr za5Y8wwAAUYABoDHFovF1jo/65rL2r1nz8uvvSa3pud5mUxGRGu5ZYG73Lxxo7y0 5P9TjljzDAA9ggAMAI9N5+Jn8Vx+4YsvpOeHlZWVSqUityZwp+rq6rUrV/y/3ZcD fgGgp/j9awkA/Ebn4mfxaP7s7343fvKk3LKO42QymXY3LElFNxK31o2rVyuViv8n flnzDAC9hgAMAI9BZ+dnYWh4+NNz56SXLZVKNZ74ocZyuTxx7Zr/o6/neUarVWXN MwD0GAIwADyGsbGxYY2Ln99+7z0xotyylmVls1m5NYG+9Tv22pUrtWrV5+m33W5b tw74Zc0zAPQeAjAAbFQikYjqWvws7Ny169U//Ul62UKh0Gq1pJdFjysvLd28ccPn 0VcQ0dcS0ZcVEADQqwjAALAhsVhsJBbT1tGn3W6f//xz6XGi2WwWi0W5NdHjXNf9 5fLlZqPh835X4jpNw2DNMwD0OF9/VwGAf2zdtm1oaEjPWCL9/vH55w8dOSK9bDab tW1bbln0sqVicXJiQtuu+M2hzzMA4DYCMAA8WjyRiEaj2ia4RmKx9z/6SHrZarVa Lpell0Vvcl33yqVLRqvl84lf27Yt06TrGwDgFl9/aQGAH8Ti8Ugkom2OS+SKMxcu SD9n2PO8dDot/i23LHrTYqEwffNmv78nfsXdbhqGeEMx8QsAuI0ADACPkEylwuGw nrHWDv79/e/HT5yQXrlcLrP7EU+uWyZ+rXU0uwIA3MXX314A0HG6Fz+PjLz/8cfS y3L0EaToionftWZXplldXe30hQAA/IgADAAPFIvFItGotsXPnueduXBheHhYemWO PsIT6oqJXw74BQA8kn+/xgCg41JjY9L34j6IeHb/w3PPHT56VHrlRqOxuLgovSx6 R1dM/DqOY5pmjXX+AICHIgADwP0lRkej0ai24ZKp1Nvvviu9rMjVmUxGZAPpldEL XNe9+vPPrWbT5xO/pmGIm5yJXwDAI/n3+wwAOkhz52fxBH/+88/7+/ulV65UKisr K9LLoheUFhdv3rjh8zN+OeUIAPBYCMAAcLdYLBYKhYYU7MW9L8/z/vTmm0/t3Cm9 suM4mUxGpGvplRFs4p785fLlRr3u54lfTjkCAGyCf7/YAKBTRpPJSCSibbg9e/e+ 9OqrKiovLi42Gg0VlRFg5VLp5vXrKtYjSGSZpmXbnHIEAHhcBGAA+F/i8Xh0ZETn xNeFL75QUbbVahUKBRWVEVTtdvva5cu1Ws3PE79rpxwZBodaAwA2x7/fcACgXywW C0cig4ODeobzPO+jM2dUtNoSSSabzdq2Lb0ygmq1Url+5coWH0/8csoRAODJEYAB 4H8kU6lwOKxnLPE0//Svf/2rZ55RUZzeV3gsE9euLZfLfl72zClHAAApCMAA8F/i iUQ0GtW2+HNoaOjT8+dVVKb3FTauUa9fvXSpz8drnjnlCAAgkX+/8ABAJ83nHrmu +9lXXykK2/S+wgZNT04u5vP9Pj7oiFOOAAByEYABYG3r73AoNKzr3KN2u/3SK6/s 3b9fRfFms1ksFlVURpCYpvnzjz+2Pa/TF/JAa6ccmabLxC8AQCoCMAD0jY6ORhR0 onrIcH95/30VlUVmyGazjuOoKI7AyCwsLMzNaVvvsAnWOk45AgBIRwAG0Os0n3tk 2/aXf/ubouLLy8urq6uKiiMAXNe9/OOPpmn69qAjz/MMw/Bcl4lfAIAKPv3+AwA9 NJ97JNLvh59+mkgkVBS3LCubzaqojGAoLS3dvH6diV8AQC8jAAPoaamxsVAopGes drt94tSp3/z2t4qKFwoFwzBUFEe3E7fHtStXatWqzyd+q6xfAAAo5tMvQgDQIDE6 GtW49VeEkItffqmoeK1WK5VKioqjq4l74+rPP/f7Nfr2rXfksi2LNc8AAA38+3UI AEppPvfItu2Pz56NxWIqiruum8lkPB939EWnzE5NFfL5/v7+Tl/I/bXb7VazWa1W O30hAIBeQQAG0ItEEA2Fw0NDQ3qGEwH12d/97uTp04rqc/Av7mVb1qUff3Qdx7fL nvvWfxgqs3IBAKCRf78UAUCdZCoVDoe1DTcwMHD24kVFxTn4F/daLBSmbt70c7+r WwzDqKysdPoqAAA9hAAMoOckEolINKptWswyzfOffx5Sk7c5+Bd3EbfEL5cvN+p1 P0/83tZqtVYrlU5fBQCgh3TBtyMASKR566/rui+/9tq+/fsV1efgX9xprd/VpUu+ 3fF7r2azSednAIBOBGAAPUTz1t92uy1GfP/jjxXVN00zl8spKo6uMzc9nc/luij9 Co1Go0YHLACARgRgAD0kmUyGIxFtw1mWdf6zzxQtfhbpWqRfMYSK4ugujuP8/OOP tmV1xbLnOzXq9Vqt1umrAAD0kC77pgSATYsnElGNW39FJvnLe+9t3bZNUf1KpbJC 9yD09ZVLpYlr1/zf7+q+6vW1BNzpqwAA9BACMICeoHnrb7vdPnb8+O/+8AdF9S3L yuVyYhRF9dEtRPRdLpe7a9nznQjAAADNCMAAgi8Wiw2HQsPDwzoHvfDFF4oqi9yb z+dN01RUH11B3AA///BDt/8IwhJoAIBmBGAAwTeaTEb0bv09e/GiuhFXV1eXl5cV FUdXWCwWpyYmunTZ851oggUA0IwADCDgNG/9dV33+ZdfPnTokKL6tm1ns9lun/fD k7h29Wq1Uum6flf31Ww0qgRgAIBGQfj6BIAH0b/1V+m5R6J+oVAwDENRffhcMJY9 36nVbHKQNQBAJwIwgMDSv/VX6blHfSx+7m2BWfZ8J8MwKjQzBwBoRAAGEFiat/46 tv3+Rx+NplKK6rP4uZddv3p1NSjLnu9kW1a5XO70VfS0eCIh/s1ObAC9I2hfpQBw i+atv57nPf2rXz3zm98oqk/n554lIuJPP/zQ9rxOX4gS4o3TbDTq9XqnL8RHYrGY nr+QWDw+ODgYDoetdZxHBaBHEIABBJDmrb+CGOvsxYvq6rP4uTeVS6WJa9cCtuz5 LpyEdC8NGTgxOio+JG//RMhadAC9gwAMIGjEs2MoFBoK0NZfUT+Xy7H4uddMTUws LS729/d3+kLUarVaq5VKp6+ih4hPSPHxKD4k7/xfep5nmiYvBIBeQAAGEDTJZDKs ceuv67p/euutnTt3KqrP4uceJG6qSz/8YFtW8Db93ottwDo9ZHWMuOsMw2AzMIDA C/43K4CekkgkIhq3/op0evDgwedeekndEJVKZYWlib1EJJCrP/8c+Inf28SbaG0T MNuA7yF9IfQjPx7ZDAygFxCAAQSH/q2/Xrv92ZdfqqtvmmYul1NXH36TXlhIz835 bdOvyKie56m7qmazWeU04PuRlYFFncGhoVAo9MgfB03DsG2b3yMABBgBGEBArG39 DYeHhoa0jWhZ1tmLF9WdtCQih0i/4mFUUX34zdWff67Xan5b9uy67lM7d9aqVXXr 8FkFrdRjfTayGRhA4PnrWxYANi2ZSoWVtaG6l0gFL7/22r79+9UNISJBlf14vcEy zZ9++KHPh33O2u2j4+MiO5WWlpYWF5UN0m40Gqy8VSEej0ei0cdaUS8+3EzD4MMH QFARgAEEgf6tv6mxsbfffVfdEK1Wq1AoqKsP//DnWUee5yVTqT179976H13Hmbhx Q91bzGi1Ksw6PsCmF0LfddbRxtmWZbIZGEBAEYABdD39W38dxzl74YK6c49c181m s+LfiurDP2anpgr5vN9aXrmed/jIkWg0euf/8urly+reZSJvNxsNtp4+yONm4Pue dfRYTNMUMZhXBEDwEIABdDfxnBcOhwc1bv0VD4Wfnj8fHRlRN8Ti4mKj0VBXH37Q brcv//RTq9n01aZfcVXiDXXoyJF7r2p6ctKyLHVD0wrr4TaegaX8JijuBMMw2AwM IHh89KULAJuQSqXUzcTey3Pd5158UcQDdUOIZ9ylpSV19eEHIkn+9N13nb6Ku7mu u2fv3tTY2H3/r8vlclHlsnzHcYxWiynHJyRxP8jaZmDT5FcJAAFDAAbQxRKjo3et 0lSq3W6LEd/94AN1Q9i2nc1m2z5shgR5ViuVa5cv9/tp06+45fr7+48ePz44OPiQ /59frlxRuteg2WjQe+khHj4JvPGzjjZOfCJZplljMzCAACEAA+hWm+hu+oQc2z57 8aK6CWcRMPL5vLrDZuAHmYWF9Py8rzb9uq67ddu2Xbt3P/L/88b1623PU3clIm6V SyV19QPgQRk4Fo+L6KviHDg2AwMIGAIwgK4knvbWtv4+eLZKOvEI+PG5c+LpU90Q KysrNMINtmtXr1YrFV9t+hXp98jRo5GNraRYLBZVB1QmgR/p3gys9NfAdrttGgYf TQACw0ffwQCwcamxsSdpcPq4PNf9wwsviJygbgjDMPL5vLr66CzP8376/nvHtjt9 If9DBJvhUEjc1RsP5BpWQdu2LeIW840bt+mzjjaOzcAAgoQADKD7jIoHPr1bf+OJ xHsffqhuCJGOstms4zjqhkAHifDw03ff+W3id+euXdu2b3/c/+DEjRue4gO6mAR+ pFuTwGtnHQ0N6ekCyGZgAIHhoy9jANiIeDweHRnRmSXEk985lVt/haWlJaa8gmq1 UvlF5Qm6m9But48ePz48PLyJ/2xlZSWfy0m/pDuJcN5qNnlHPJz4JAzp3QbCZmAA wUAABtBNYrFYJBrVmSVE+v347FmlW3859yjActns/PS0fxo+e543EosdPHToSYpc uXx5UPGfSATgVRbcPlgymRTpV/OaAjYDAwgGAjCAriFS6HAotLlpq83xXPf1N9/c uWuXuiE49yjAJicmyktL/ln57Lru3n37kqnUE9aZnZkxWi0pl/QgIqg3Gw0mG++l /2PwTuIj0WAzMIAu55dvZQB4pNFkMhKJaBtOhNLTzzzzzK9/rXSIXC5nWZa6IdAp ly9datbr/km/4m47Oj4u5Zgc27Zv3rih+iQnwzAqKytKh+g6+pfA3GttM7Bl1dik DaBr+eaLGQAeKp5IRKNRnXEimUq9/e67SodYXl5mnWfweJ7347ffuoo7RW2cuJ5Y PH7g4EGJNSeuX/dUHgjct/7zULPRoOvSbfpPPn8QyzQt267z0gDoTgRgAF1APL5H IhGd8x4iaZ+9eFHps2ar1SoUCurqoyNENvjx++/98+Uqcvi+/ftHk0m5ZUUuTc/P q/5ByrbEX6fJQug+LWcdPRbm5wF0L798kgLAg8RisVAoNKRz66/nvfP++0++VfIh RCzJZrP+mSSEFPVa7fJPP/mq4fOx8XFFjYJ/uXJFw2xks9lkx2kqldJz1tHGiQ9J 0zBYwAKgGxGAAfhdMpkM6936++tnnz11+rTSIYrFYktxGyFoVi6VJq5d80n6FffY yMjIgSfr9vxw4s+7WCyqq39Lj3fDWvv5LxyWsnNbOsdxTNNkMzCArkMABuBr+rf+ bt2+/c9vvaV0iEqlssLqwWDJ53Jz09N+2J/Zt76+YPeePWNbt6oe6KqW841FylpZ XlY9ig/F4vGoPzb9Poi1js3AALoLARiAf+nf+ts/MHD2wgWledswjHw+r64+9Juf nc1lMj4JKp7nHRsf13NMTiGf1xNNG41Gr8006v/tb3PEB5pj2z07RQ+gG/n9gxVA z9K/9k8kh/c//jgej6sbwnXdXC7nOI66IaCZfw77bbfb4i1z+MgRnRdz9cqVAfXJ X7xxWs1m76Ss0WQyHA774aZ6pLXNwKa5Wql0+kIAYKO64LMVQG9KplJhjX1fRHj4 v3/845Fjx5SOUiwWm82m0iGg0y8//1yr1fwQVERE3PHUU+IfzeMWC4XlclnDQD2y EDoWiw0LoVCnL+QxOI5jmWa1x6boAXSvzn9nA8C9EolEdGRE54i7du9+5fXXlQ4h HhDLWqIC9Lj0/fcilXX6KtaI9Hv4yBHNb5nb9OwE7uuBjtAi/YYjEUVdu5ViMzCA LkIABuA7+rf+Dg0NfXr+vNIhRFLK5/PtdlvpKNBDvI4/fvutX5ayb9lyfHy8g92n S0tLi8WihmnwtY7QzWZQU1ZcfO75u+XVw5mGYbMZGEA3IAAD8Bf9cyDiqfrjM2fE o6fSIbLZrF/yEp6MeDV/+OYb8e9OX8j6WUex2IGDBzt9IZrOBBZExBJBK3gpKzE6 GolE/LCWftPE3WgYBpuBAfhfF3/UAgikVCoV0rj1V8SYF195Zf+BA0pHWVxcbDQa SoeAHq7rfv/vf3f6KtaIK9m1e/fWbds6fSFrqqurmXRaT35rtVpBSlmxWGxwaEhn vwN1xD1pGgabgQH4HAEYgI8kRkejKmdi73Xg0KHnXnhB6RBs/Q0M27J++PZbP0zT ea575NixcCTS6Qv5HzeuXdOzwl+M0mw0aoFYCK2/171q9vpm4GC8OgCCqvPf4gBw Szwej46M6EwX4XD4ozNnlA7B1t/AsEzzR5F+fbBFU7xHjp844bfNokarNT01peeq gnEqkv5mB3qIDz0Rg7v91QEQYARgAL6gf+uvCKWfnj8/PDysdIhMJsPW3wAQ6feH 777r7/Tcr7ijoiMjBw8d6uxlPMjM1JS2tthr84ym2b0pK55IRKNRP6wmkI7NwAB8 LoCfvAC6UWpsLKTx6EvP8157441du3crHaVcLrMdLgB8kn5d131q587tO3Z09jIe Qrytrl29qm1K02i1Kt2ZspLJZCgcDmT6vWVtM7BpBvvMKgDdK7AfvgC6iOatv+12 +/iJE7/9/e+VjtJsNovFotIhoIFP0q+zftLvSIdO+t24YqFQLpX0RDvxRm41m931 G1MsFhsOhZQuPPEJNgMD8C0CMIAO07/1V4z47ocfKh3CcZxMJsPW327nk/Tred74 yZM6Nwg8iWtXr2p7O4u/GZGBuyVlBXXT74OsbQa27aCe2wygexGAAXSSeCIMh8Oa n+zPXLigdES2/gaDbVnff/NNZ3tNiXtJ3KvHxse7aLlsq9Wa0dUNq+9WQ6xWy/8p K8Cbfh+EzcAA/KmHPogB+JDurb+u+9a77yo9OlXk3lwuJx7K1Q0BDcQr+N2//tXZ uCLyQyweV31ItQpzMzMilGobzrZt0zB82xArFosNDA6GA73p90HYDAzAh3rusxiA f4yOjkb0bv19+plnfvXrXysdIp/Pa2uEC0U8z/tWpN/OXoPr7vB3y6uHEG+Ea1eu 9Gtc62uZpuXLo3di8fjwuk5fyH9pr9O5rsG2bfHqdMsydQC9gAAMoDP0b/1NplJv v/uu0iFo+xwAIv1+/803bc/r4DW4rnvg0CHxHungNTyh6upqJp3W+QY3DWNlZUXb cBshXsGwnzb9int79549W/r7xUszoDEDsxkYgK8QgAF0QCwWi0ajOieIxDPf2QsX lM57NBqNxcVFdfWhh0i/bkf3b4v0e2x8XOfWAEWmp6YsvashfHUwUiKRiPhp06+4 r8ZPnhwaGhL/fSGfLy0taUvmbAYG4Ct++VwG0FPGxsaG9Z76++4HH4wmk+qGsG07 m83S9rnbXfr++86uYBe30PiJEwNd0vD54TQfC3xLq9XqeNCKxWKDQ0PhcLizl3En cV+dPH36zjQ+NzvbbDS05XM2AwPwDwIwAN30b/199ne/Gz95Ut0Q4kE/l8uJDKxu CGhw7cqVWkdXsIus2F0Nnx+pWq2m5+c1d9LubAaOxeOhUOjWRKsfiA/ASCRy6MiR u/734vNqdmrK1bjUn83AAHwiON+yALqC/q2/23fs+NObbyodYnFxsdFoKB0Cqk3f vLm0uNip8LmWUqLRQ4cPd2R0pebn5pra3x2dysDxREKkzc4enXUncV+JD8AHtVKr rq6mFxZ0Xu3aZmBf9ioD0FMIwAD0Wdv6OzKi83lrYGDgzIULSlNNtVotl8vq6kOD bDqdnp/vYPodTSb37N3bkdE1+OXKFf2ZUPN+YB+edeS67pGjRx++3KZYKCwtLrIZ GEBP8cvHNIBeoHnrr3j+++jTT0diMXVDiIe5fD6vrj40KC0tTd640alZO8/ztu/Y seOppzoyuh6maU5OTOhvhmwaxlrzYfXzjX4766hv/dPv1NNPb+Sunp+ba9TrbAYG 0DsIwAA00b/194/PP3/vzjeJxJNcNpsV/1Y3BFSr12qXf/qpUwfViJtnz969qbGx joyuU7FQKJdK+mdHrXVKD+CJJxLhcNg/Zx31rTe9P7HhrgeO48xMT+vsfG6vvyhs BgbQKQRgADro3/q7e+/el199VV19EbCLxWKr1VI3BFSzbfu7f/9b54GodwrAYb+P ZeL6da8TpyuLgGcYhooM7MNlz+JzKRaP7z9w4LH+UyKLLszNad0MrGtyHgDu5ZeP bAABJh4TI9GozhmS4eHhT86dUzrEysqKf04cxSaIqPDtv/7V16GTq0QqO3b8eDgS 6cjoHSEC/7VffhnsxEypCN5Gq1WV2uJ7rdvz8PCQn5Y9iz/m7j17NregYGlxsVgo sBkYQC8gAANQLpVKhTQeiem125+cOaM0WjSbzWKxqK4+NPj5xx+NDk3giyh4bHw8 pHE/vE/on2m8k0hcjqRZx0QiEfZTt2fBdZxjJ048yU2VXliorq5q+0M5jmOZptxf JQBgIwjAANRKjI5GNW799TzvxVdeedwVgI/Ftu1cLteRxZyQZermzVKHDj0S6Xf8 5En/nBOrWS6braysdGrNsPjLFzH4SU57jsVig0NDImf6Z9lz3/rn3snTp58wu4q/ nJmpKUfjZmANO7QB4F4++vgGEDyxeFykX53zJPsOHHjhpZfU1RcPmvl8Xjy0qRsC qi0WCtOTkx2ZvhP3z4mTJwcGB/UP7R83b9zoYOu4drst3r9rG1AfP3fF4/FQODzo p5dP/HFEID8+Pi6lWr1eX5ib05ntJU7LA8AGEYABqBKLxcTDos6ZrlAo9PHZs0qH WFpa4lmtq7VarUvff9+R9CuyyolTp3y1brYjPM+79ssvneo9dvsaTNN0HWfjb+fE 6Gg4HPbVy6fiBOm1zcD5vLbfaNZeCMNY5VQkABoRgAGokkylwpq3/p49q3TEWq1W KpXU1YdqIjB88/XXHfnmI/3eqVMnA9/FdV3Lsh4Zg2Ox2Nohvz7bsy2i4959+0QA ll5Z/2ZgcT88ybp0AHgsBGAASsQTiWg0qm0pnXgWfPnVV/fu369uCPGIls/n2x1q GgwpOtX4ivR7r9VKJZNO++HvRHx6WKbpuO59F0X78JjfPsV91NY2A09PO7atovh9 ib9/a1OL0gFgEwjAAOTTv/X3wMGDz734orr64okwl8vpbA8D6ebn5vKZjP7eRaTf B8nncivLyz7pJiVeJtu2xXvcE0l4fULYn/2u+iS1vHq4RqMxPzurdTNwq8XBcgD0 8NdnOoAAWFsuGAoNazweMxwOf3TmjLr64sm4WCy2OnRkDqSoVatXf/5Zfwol/T7c 7MxMpw6jehARL0USFjF4aHjYV/2u+tZvJxHIjxw7pmEs/ZuBDcOoshkYgHoEYACS jSaTEZVn8N5FPBF+cu6c0iNVV1ZWmJroauLZ+pv//E/Srz9NXL/OoWIbIW6nsa1b d+7apW1EzZuBbdu2TLPGQmgAihGAAcjUga2/r722d98+dUM0m81isaiuPjS4culS s9HQPKiGdarBIHLdtatX+Yt6ONd19x88mEgkdA4q7uHpqSmdm4FN07Qti077AJQi AAOQJhaLRaJRnd1iDhw69NwLL6irb9t2LpdjeqqrFfP52elpzds4RVw5eepUj5/3 u3Gu49y4dq3fZ42m/EPcTsdPnNC5r+Q2zZuB2+22YRirrLgBoBIBGIA0qbExpUuR 7xKORD769FN19UXuzefzlmWpGwKq2Zb13b//rbmFr4gr4ydP6jwBOwDEG23ixo1B MvD9iNupgzPkpaUl8Umo7aURbx/TMKqcigRAGQIwADkSo6PRaFTbcG3P++T8eaV5 e2lpiZV43e77b75x9fbudhxHxJWOTNZ1u1arNT056bcDhzqo3W6LD9WDhw93+kL6 Fubna9WqthBuWZZtWWwGBqAIARiABJrPPfI875XXX9+zd6+6IarVarlcVlcfGqQX FrILCzoXP7uue+To0YjGX4ICptlozExPk4H71j/ltu/YseOppzp9IWvExdy8cUPn KeiGYTi2zU+QAFQgAAN4UrFYLBQO61zwefDw4T8+/7y6+qZp5nI5dfWhgW3b3/3r XzqjlAgJ+/bvT4yOahsxkBqNxmzPZ2DXdQ8cOhSPxzt9If9DvC7Tk5PaPuc5FQmA OgRgAE8qmUyGNZ57FAqFPj57Vl198eiZzWbFv9UNAQ1++u47nfu3xfP6zp07t27f rm3EAKvXarMzM347g1cb1/PGT5zw4R7yQj6/tLio7XVZOxXJsmpsBgYgGwEYwBPR f+7RJ2fPqsvb7Xa7UCgYhqGoPvTQ3PlZ3DbJVGr3nj16husFPbsWur+///iJE5qb lm/c7MyMeGm07XbhVCQAKvj0ExZAV9B87pGIGc+9+OLBQ4fUDbG8vLzKorsu57ru N//5nzqzUyQS8UOnooAxWq2pmzd75ygp8fkWi8f3HzjQ6Qt5GNdxbt640cepSAC6 GQEYwOZpPvdo1+7dr7z+urr6jUZjcXFRXX3oce3yZZ39Y7ds2XLi1Cltw/UU0zSn JiZ64Xxg13V37drVFUvoq9Xq3PT0kK4+5yJyi9uAU5EASEQABrBJms89GhgcPHvh grr6lmXlcjmdbU6hQqvZvPTDD9qWaIrccurppzt4Rmvgib/hievXfbskWArxZzx8 5Eh0ZKTTF7JRuWy2XCpp2wxsratzKhIASYL8jQJAHf3nHn3wySexWExdfZF+bdtW VB/a6Dz4V+SWY+PjOhdB9KZ2uz05MeE4TiBjsPjTHT9xous6fk1PTpqmqe0VMVqt CguhAUgSwO8SAKqJIDocCg3rWgInHhCf/f3vx0+cUFd/cXGx2Wwqqg9tSouLUzdv 6nko59AjzTILC6urq0GabBefPKFQ6MixY52+kM2wLGtyYkLfb6Cua5gmpyIBkIIA DOCxjSaTEY3nHm3dtu3Pb7+trn6lUllZWVFXH9r86x//0PNELqKLeBfs2btXw1i4 bWV5OZvJBKM1tOd5Y1u37tq9u9MXsnnic3N+bk7bL6H2+kJondv7AQQVARjA44nH 49GREW0r38RAZy9eVJdqWq1WoVBQVBw6zc/OFnI5PWOJG3L85Ek9Y+FOpmlO37y5 pcvngV3X3bd//2gy2ekLeVKZhYVKpaLtJwnDMBzb5lQkAE+IAAzgMcRisXA4PDg0 pGc48Zj4zvvvp8bGFNW3bTuXy3mep6g+dPr6H/8Y0JKLPNc9SeOrjpqdnm61Wl26 Jdj1vGPHjwdm6/jkjRuO6+oZS3xWiwzMQmgAT6grvzwAdEoymQzrWvzcbrdPP/PM M7/+taL64lkqn89blqWoPnSam54uapnJd133yLFjOrcA4L5Wlpczmcxgty2H7u/v PzY+HqRfT0QiFRlY26+itr22FLrGqUgAngABGMBGaV78nEgk3vngA3X1l5aWWEoX DO12+1//+IeGdZhioNTYWFfv2wwSz/Omp6ZEHuqKqWBx84zEYgcOHuz0hci3tLiY z+WGdGVg0zBsFkIDeAJd8J0BwA9isVgkGtW210s8LJ69eFHd0SDVarVcLisqDs1m JifFI7iGgbb0959g66/PVFZWsul0v7+ngl3X3blr17bt2zt9IarMz87W6nU9exDE t4PRaq2yEBrAZhGAAWxIMpUKh8N6xvI87/U//1k8LyqqbxhGPp9XVBz6ff33v2v4 aUZkmJOnTg1023mtvUAkooX5+Vq16s8G0eLOOXTkyMjISEdGHwqFbNNUPYp4CW5c vy7+i+qBbnFs22QhNIDNIgADeLR4IhGNRrWtMzxw8OBzL76oqLjjOLlcztXVtQWq ZRYWsum06lHE8/3uPXuSqZTqgbBptm3PTk05ruurFdHizjl+4oS6xSwPMTAwEIlG +wcGjFbLUp+B67XazPS0voXQpmlbFguhAWyCj74kAPhTLB6PRCLaplbE89On588r Ki4eRvP5vKn+WRDafPPPf/apDzwiwBwbH1c9Cp6EyEJzMzP+mQQWnzahcPjI0aMd GT0UiQwPD9/6LUBcSbNe1/CrXy6bLZdKetL+2kJow1itVDSMBSBgCMAAHiGVSoU0 Ln7+8JNPRmIxRfVpfBUwK8vLE9euqZ7xW1v8fPq0f5IV7pXP5ZbLZf90VxYfZWPb tu1Sto/jIcSNGr6nX4O4nnqtpmGJ8vTNm6autmSO45imyUJoAI+LAAzgYXQufm63 27/57W9PnDqlqD6Nr4Ln+2++cR1H6RDittzx1FMBbl/U7dZ6Qd+8aTuOf1Y+u667 /8CBxOio/qFD4fBwKHTfvwrbslrNpuoLEIl0cmJC269FawuhbXst2wPAhvnl2wKA D2le/DyaTP7lvfcUFafxVfCIZ98fv/1W9aQfnZ/9rNlszk5N+aoFtAjkx0+c0LYV 9rb7TvzeRQRgW/3J5+VSKZvJ6PkboCM0gE0gAAN4IJ2dn5Wee0Tjq0C6/ssvVcU7 AEWYOXr8eCgUUjoKNqdYKCwtLvpnabr4EBscGjp2/Lj+ueiHTPzeSVxho1YTd7Xq 69F5KhILoQE8LgIwgPvTufhZPJC99sYbu3bvVlGcxldB9a9//EP19G8kEjl4+LDS IbAJ4k09NTlp69pruhHiQyyZSu3Zu1fzuBuZ+L2T67oN9QuGxd/GxPXrqke5jY7Q AB6LX745APhKLBaLjoxo6ygjnhpfevVVRcVpfBVIy+XyzevXleYfERVOPf20f/oq 4RbDMKYnJ331uohbZd/+/aPJpOZxNzjxexfTMMQ/ii7pturq6tzsLAuhAfgQARjA fehc/DwwMHD24kVFxWl8FVQ/ffedpXg3Y2psbGcnuvjiIZYWF4uFgn+WPfetz3Ye Gx8fHh7WOejjTvzeae1UpEZDdfc4IZNOV1ZW9LxYLIQGsHEEYAB307n42XXd9z78 UNHMSavVKhQKKiqjs0Tk+Pc//6n0wVrcmU8/84y6+nhcIrZNT01ZpumfZc/ikoYG B4+Oj2u+pHAkMvTfZ/xujngHNWq1tvpTkW5OTGhI2reYhrHWEZr1PgAexS/fIgB8 IhaLRTY7sfC4xOPXiVOnfvPb36ooLp6EcrmchnYv0C+Xzabn5pQOsXXbth1PPaV0 CGyc0WpNTU3paaq0QR3Z9DswOBiJRKR0vRafkK1G48nrPFyr2Zy8eZOF0AB8hQAM 4H9JJpPhSETPWCJpf/jJJyoqi2fTfD6veoksOkX1+memf31lsVgU//hq2XNHNv0+ +cTvXfScilTI55eKxUEtGVikess0axwLDOChCMAA/kc8Ho+OjGjr/PzJuXMqdhq3 2+2lpaWG+skNdMrXf/+70jjE9K9P+LDbc18nNv2uTfxGo9L7fmk7FWl6aso0DD0v omEYDguhATyUj75RAHRWLBYLhcPa1qo9+/vfj584oaJ4pVJZWVlRURl+sFwuT964 oa6+47q/YvrXB5rN5szUlK8mftc2/Q4PHz12TF8g37IlHImoC9uu4zTUZ0XLsiau X1d0zPtdRJ4XGbjKQmgAD0YABvBfRkdHI9GonrHi8fi7H36oorJ4aC4Wiyoqwyeu XLrUVDm9PxKL7T9wQF19bEQ+l1sulaRsdpVFJKuxrVsVHVd+X4NDQyL9qj7wSc+p SMVCQfyj5wdWa12dhdAAHoAADGBNLB6PKlhid1/tdvvMhQsqnoTEQ08ul9PQ2hQd 9K9//EPdjeq67snTp30169hrxEswNTnpOo6vlj2Lqzpw8GA8kdAz3Jb1id8hLaus tZ2KNDM9LQbS8+YyWq1KpaJhIADdyEffLgA6aGzrVj1b2sTD1h+ff/7QkSPSK4sn VJF+HV1HbqAjxKv87ddfqwvA4un8uJqV+diIarW6MDfntx8gxKfWsfFxPbOXgsi9 4XB4i8aW157nrc2XKv7pUHw4T1y/rudnVvFBYRpGlWOBAdwPARhAXyKRiI6M6Bkr NTb21jvvSC8rnlALhYKhfiEfOiuXyaTn5xUVF3fR3n37EqOjiurj4dILC9XVVT0B aYPELSGy6OGjR/UMJ0JvJBLR0zD5LrZltZpN1aMsl8uZhQU9M9umaa4dC8xCaAD3 IAADvU7zwb9nL15U0QqlVCpx9EUvULoBmNOPOkUElcmbN/32RCLuhx07d+7YsUPP cMOhUCgc7uDC71ajIV4I1aPMzsw0Gg0NRzpzLDCAB/Hb1w0A3ZKplIqziO4lHkde ePllFe2FqtVquVyWXhY+9O9//lNdQghHIocOH1ZUHA9SWloq5PN+W/Ys0u/ho0ej WvoC9g8MRCKRAS1Nkh9CfETXq1XVPRTEX+zE9et6cv7ascCWVWMhNID/jQAM9DSd B/9u3bbtz2+/Lb1sq9UqFArSy8Kf1HXAEs/9Iv1qa4SOvvWtp9OTkyKl+KrfVd/6 UuRjx4/ryeShcHg4FPLJ34Bj20pbrN+icyE0xwIDuJcvPnABdITmg3/PffaZ9AdK 8eicy+XEY7TcsvCnWq127fJlRcVZ/6yZeDXnZ2f9NvErPkwSo6P79u/XMNbA4GAk EvHVUU996/2TLdNUPcraQuh6XcOrz7HAAO5FAAZ6l3jO07PAb23x80sv7T94UG5Z 8WQj0q+GTWvwibmZmWI+r6j40PDw0WPHFBXHXRbm52vVqq/6XfWt/wiyd9++ZCql eqAtW7aEIhE9jfcfl/i4btRqqn9VdB3nxo0b/VrmvTkWGMBdCMBAj9J58O/Y1q1v /uUvcmuKp7RisdhqteSWhZ8p7YD11M6d4kZVVBy3mYYxNTnpt+jbt/6D2vETJzSs iBFDiPTrw7+B21zXbaiPizoXQotvilWOBQbw3wjAQI9KpVIhXb2vVHR+LpfLnPHY a779+mtFHXpE+Dn19NM+2YcZYPl8vry05Ldlz9rOOurgKUePyzQMU/2pcrPT02sd odXfD47jmKZJNywAt/BlD/Qibb2vxJPlcy++ePDQIbllafvcm77++98VPSuLAHz6 V79SURm3iAQydfOm+Hv2268Mrus+tXPndvVnHXX8lKPHIj66m/W6+MtROoq4Kyau X9czGU43LAC3dccHMQCJdPa+Gh0d/cv778utSdvnnqUuAIu3w9Hjx1VURt/6Ytdc Nuu3id++9fR75NixSCSidBTxBw/rOmtdIs91NeybLS0tiXtDw/fRWjesVot1QwD6 CMBAD9LW+0o8cJy5cEFuoxfaPvcsx3G+//e/FU2gjSaTu/fsUVG5x4mEOT015fjv oKN2uz00OHjk+HHV04/hSGRoeNhvf/wNskzTUN9nYWZy0jBNDX9FpmmKbxC6YQHo yk9kAJsWi8cjkYiGuQjxfPnrZ589dfq0xJriYVqkXxGEJNZEt6isrExcu6ao+L4D B2KxmKLiPWtleTmTyQz6b+bT87yxrVt37d6tdJTBoaGwv5tdPdLaQuhGw1X8kWsa xs0bN/RsjW41m6sciQT0PAIw0FuSyWRY8Xq/W8Lh8EdnzkgsKB7FCoWCob4vC/wp s7CQTadVVKYDlnTir3RmetrSMq33uFzXPXTkyMjIiLohtvT3r038dkOzq0cSL+Xa lKma5nO35bLZcqkkvVfivWzbFrdljUlgoLf57psJgDqxeHxES+8r8cz04SefjEid UltaWqJ/SS+bnJhYLpVUVBaJ6OlnnlFRuTetVirphQUfbnltt9sDg4PHFC977q5m VxthWZbRbKoe5ebEhOqp5luMVstxHL5NgF4WnA9oAI80NjYmHs40DHT02LHf/eEP EgtWKpWVlRWJBdF1bly7tqrmHiAAy+J53uz0tOnLiV9xbalUavfeveqG6NJmVxvR rNdV7z0RiXRmakrDtLl4vxuGwZFIQC/z3VcUAEXiiYTSVX+3iee/sxcvSizYaDQW FxclFkQ3+uXyZXXda05K3azemyorK5l02p/xT2SeA4cOxeNxRfVF4F9rrd+1za4e yfO8Rq2m6BTu29ILC6uVioZbyDQMmyORgB4WzE9qAHfRdvSReE564623djz1lKyC pmnm83nVD17wvyuXLjUbDRWVt/T3nzh5UkXlHiHe9dNTU7Zl+TD+rS17Hhg4evy4 ulglcq/4dO3qZlcbIV7fluKF0OLFuqGs0d2d1o5EMowq3bCAXuW77yoAKmg7+mjb 9u0iAMuq5jhOLpdzXVdWQXSvSz/8YKppgSai0fETJ1RU7gXL5XI2k9HQvmgTRM5J plJ7lC17FqE3HI3688+uQrPRcGxb6RDidsosLAxJPTzvvjgSCehlBGAg+GKxWETL zjSv3T538aKsx0Hx8CrSr634eQvd4sdvv1V0MwwODR07flxF5WBzHGdmakr824cT v33ry54PHj6s7nSrUDg8HAr588+uiJ6F0NNTU0arpXpGXfwpxCgciQT0ph764AZ6 1mgyGVF/9JF4nvg/zz4ray+lqFYsFlutlpRqCIBL339vmqaKygODg8fHx1VUDrBi obC0uOjPHb+3uj0fPXZM0eUF4IDfTdPQEXrtWOCJCQ3z6uLPYlsWRyIBPYgADARc LB6PRqMantVCw8Mfnzsnq1qpVOK5BHf6+ccfDTU/iAz09x9nD/CGiXwyMzXVXu/8 1OlruY+1bs9jY7v37FFRPEgH/G6aho7Q2UxmuVzWkIFbrdZqpaJ6FAB+48dvLwAS JVOpcDisehTx0PnuBx+MJpNSqq2uri4vL0sphcC48vPPTTVdW0WQO3HqlIrKwZNe WKhWKv2+nPjtW1/2fPjoUUX9DoJ3wO/miE/7uvozhG5cv972PNWj2LZtWRZHIgG9 ptc/x4Fgi8XjIyMjGp7Ydu3Z88prr0kpxaFHuC91xyCJB/rTv/qVispBsrq6mp6f 9+ea5771Zc/Dw8NHjh1T8XE3ODi4tubZr392/SzTVLQc47ZKpbIwN6dhsl38QRzH 4UgkoKcQgIEgS42NhUIh1aOIR8/zn38uZZU1hx7hQW788ouixYqu6z79zDMqKgeD z5td9a2/gjt37dq2fbv0yuKPvLbmWX1T4u4iPqKbjYareCH0zPS0GEX1by7ixhbf O0wCAz3Fp19mAJ5cPB6Pqp/+FU9Cz/7ud+MytlBy6BEeYm5mppjPq6hMAH6IXCaz vLzs24nfvvUJ/KPHj6v4pY81zw/hua7qM4RELr1544aGncCGYTi2zSQw0Dv4WAcC a2xsbFj99O/w8PAnMnpfcegRHm6pWJyZmlJU/NDhw2H1ndK7S61aXZif93OvY/Gh MRKLHTx0SHplEbpCkYifY78faFgInUmnV5aXVWdg13VFBmYSGOgdBGAgmOLx+Iiy AzBvEw+gb7/3nkjaT1iHQ4/wSM1m88pPPykqnhob27lrl6LiXce27dnpaT+veRYc 1z1w4EBidFRuWfo8b9zaQuh6XfWanRu//KJhS8zaJLDjqJ7TBuAT/v1uA/Aktm7d qmHf2vYdO/705ptPXodDj7AR//7nPxVFsoGBgeMnTqio3F1EpMmk06uVip8nP8VF Dg4MHDl+XPpFsub5cYn021D80b1cLmcWFlR/nYk/iGkYVSaBgd7ApzwQQPFEYmRk RPUonuedu3hx8ImnSiqVysrKipRLQrB9/fe/KwpmbAPuW08auWzWz9G3b/2V2r5j x1M7d8otS5/nTTNaLcs0lQ4xPTlpmqbqHybYCQz0DgIwEEB6pn/HT578zW9/+4RF OPQIG/fNf/6nosrtdvvAoUMafjbyJ/E2XJidba83Pe70tTzMWr+rY8dCUg827+/v D7Hm+QmI906jVvNUntnbbDSmJidVv0ZMAgO9w9dfdQA2Qc/0r3hQPv/5509YxDCM QqHAoUfYoJ9//FFd051bp8gqKu5btm3PTU9btu3nZld969E3Fo8fOHhQblmRpYdD IZ/Hfv9zHKepeOJ0bna2XqupXp7AJDDQI/jQB4JmbOvWYcXTvyKy/vH55w8dOfIk RcSTdy6XUzpvgICZmZxcUrZewHXd07/6Ve9kIfHWm5+ba9TrPl/z3Lf+0hw4dCge j0usOTQ8LNKvz2N/F2k1m7Zlqasvvi8mrl0bUN8OmklgoBf0yjc90CP0TP+Ghoc/ frKjj8Rzhki/juPIuiT0gsrKingIVld/NJncvWePuvo+0W63s+l0xd+drm4Rlzoc Ch05elTiDxPiTx2ORFRHqV7T9rx6raZ0OY+eI5FoBw30AgIwECgapn89z3vrnXe2 btu26QriIalQKIjnDIlXhV4g7px//eMf6mJbL7TCyudypVJp0PfRt2/95di9Z4/4 TJNVUKRoEX0Hh4Z6Z55fJ8uyjGZT6RDXf/lFaf0+zgQGegPfAUBw6Dn7dzSZ/Mt7 7236Py4yzNLSUqPRkHhJ6B3ffv210lmmxOjonr171dXvoKXFxcVCoSsaHYuXWFzn 0WPHJE73ccSRamvHAjcarsp1PaWlpVw2q7obFjuBgcDjmwAIjrGxMfGQp3QI13U/ OXs2Eo1uusLy8vLq6qrES0JPuXHt2qrKQ7PE4/v4qVMB6wm8WCyKf/y/4PkW8SGz 46mnxD+yCg4ODYXD4a5I/t1Ow7HAEzdueK6rdAgmgYHAIwADARGPx6MjI6rnN3bu 3PnqG29s+j9eq9VKpZLE60Gvqa6uXr96VekQ4k104tQppUNoUywUSouL3ZL92u32 lv7+o8eOyfoBor+//9aaZynVsBGqjwVeWV5Oz8+rPudP/CnWdgIzCQwEFAEYCIhU KiX3eMx7eZ539uLFTT+btlqtQqEg95LQg77++9+VTmaKGDaaTHb1Qui1bfa5XHl5 eaB7uhy7rrvt/7N3J0xuXfed99EAGvvWC3dKFHdRKyWKuyU79iRTSSrlTGI7i+OZ 9zZVeeZ5JslTk5p6nql6RvZEXuNxLFEkm7tIimRv7B07cLfnALcbAnvFcs+59wLf T8ltdLNxzm10A/f8cM79n337Dh465EhrIyMj4vVQxCTWPCsm/vaK+bzU6xQePnig 1etSf7O6ptXqdSaBgUHFiQEYBKl0Oil/+ve111+//sknvd23Xq/PzMyw5S/6d+Pf /q0mc4op0Hyv58hrr+VyOam9yCBi5Itnzwryd0x1mGWdPHPGqQJ+XO7rLpFOKzKr Ya2trn799Kns6xQqlYroSGoXANzC6QEYBGKkHovHpXYhIsFf/fjHvY2qdV0X6deQ fOEWhsTiwsJXDx7I7qWx9+wbb6QzGdkdOaVWqz1/9qxaqfgr+orHeWJy8tDhw460 xuW+HlEqFqVWw/rq4UPxBy/1PQ4R44UC+yEBg4gADPheKpVKJJNByWsdT54+ffHy 5R7uKJLz7OysGEk4fkgYWr/5+c8VhByRzV57/fWs5+eBl5eW5ufmxBNN9ouAsxpX /I6MiBcWRyZ+ReyPxuOyN4lFh2RXwyoWCo+/+kr6JHC5TMlGYCARgAHfy2az/ZRl 7oQYqv713/1dD2+3izvOz89XKhUZR4WhdfPGjYqSnbREqpzct+/AwYMK+uqWoevT 09P5tTV/TfnaREDat3+/Iw/sSDAYi8XY3ddrZFfDEgG4XCpJ/eNvzgHXi0wCAwOH swXgb2qmf8+eO/fBhQs93HFxcZElZHBcIZ+funlTTeCxLGs0Ejl1+rR38tXiQoNp GP6a8rXZe/yePHXKgem7kZFoNBqJRr3zq0GL7GpYpVLpq4cPpU4Ci4OvVCp5JoGB gcM5A/C3TCYjArDULnqe/l1bW1teXpZxSMD//vWvVdZUMwzjyNGjY+PjynrcqlAo zM/N+e4q33biYTxw8OC+/fv7byoixGJ+fAtgeNTr9arMaliPHz0ql8tSnw61alXT dSaBgQFDAAb8bXxiwqnSqTs5ffbshYsXu71XqVR6+fKljOMBhLmZma+fPFHZo71L 7evHjiUlv+W0SSv3irDn36nOxkT66OiJU6f6jytUuvIL8UsvFYumtPKHxWJRZGCp k8CGYVSrVfZDAgaMX0+lAAJKdj+yTPOvf/KTbruo1Wqzs7NsegSpfvPLXwaVB0K7 dNOBgwfHJybk9SKG3YsLC2srK7V6XSRG/+Zem1PlxELhsIi+ISpd+Yeu6+ViUV77 IgBXmu8NyetCtG/oelHmTwFAMX+fU4EhlxsbE8NBqV2cOHXq0pUrXd1F07SZmRnT NCUdEmB78ujRy/l5t3oXoS4ej+8/eDCdTjvToK4vLy/n19aq1ar4dDAW94rXgWQy eez48T4zvHg0ovG47Kq/kKFSKomTgqTGC4XCE8nloMXB12s1ilkAg4QADPiVgvJX pmX99Y9/3FUXYrwr0q+84Q7Q7je/+IW7QdGyLPE3HwoGxZMxnclkstnOd+KpVipr a2vlUqlaq4n06+sVztsSD84bJ04k+qtRLx4TO/oO2IMzPMQTpChzCbGCPYHL5TKl sIBBwukE8Csx1O5zZLknMXi9cu1a59/PpkdQbObFi2dPn3onGtl5WNxoZNlgw0gz wlnNt5PEv1n2x+YXB2OOd1uGYUzu23fw0KF+GhEPUSQWi0Qi3vn9ojdSt0TK5/NP Hz+WOgksAramaZTCAgYGJxXAryYmJ6We8sU4/kd/+7edT2cF2PQIbvjXX/2KM5l3 rBe7Onmyzyt1oyL6sr/RoJC9JdLDBw+0el3eX4s4G4oMn6cUFjAoOLUAvpROp5Op lNQu9u3f/70/+qPOv391dXVlZUXe8QDbWl5aenD3LknJCwzTfP3YsUwm008jkebW vgM8PT6c6rVaVdrioKXFxekXL6S+IywOXqcUFjAoGDEAviS7/JVpmn/+gx90vsSa TY/goi8//1ze2BqdMAxDvCgdfe21fhoZjUSibO07oBqTwIWCJa044v07d0yZ+w5Q CgsYJARgwH8a5a8SCanbYKbT6T/9/vc7/OZqtTo3N8emR3CLSF+//dWv+t9gFj0w TTMSjR4/caKryyU2aUTfaJStfQebVq9XymVJjc/Pzb2cmwvLnASmFBYwMAjAgP9k MplEMimvfRFl/+iP/3hicrKTb2bTI3jBwvz8Vw8fshBaJfs9r2PHjyf7eDkSiSUa i/HmxTAQfzClYtE0DEnt37l9W+orQK1a1XSdUljAAGCsAPjP+Ph4JBqV175o/C9+ +MNOvpNNj+AdN7/4Qt78EjbRDePgwYP79u/vuQWi7xDSNa1cKklqfPrFi5WlpT6r r+1C1/VarVagFBbgfwRgwGdSqVQylZL6PvfFy5dPnj6957dZljU3N1etVuUdCdA5 8Qf5v3/1qwCTwJIZhpHOZF4/dqznVyGi7zArFQqGnElgTdPu3bnTz1L8PVUqlbXV VXntA1CDgQLgM9lsNi5z+1+RIv7mJz/p5DvZ9AheU6vVfv/b35KsJOn/cl+iL3Rd L0urpfz40aNypRKSVketXqvV2RAY8D8CMOAzsrf/fe3Ysesff7znt7HpEbxpaXHx wd27VBJ2lmVZIyMjx44f77wy/CZEX7SUikVD12W0vLa6+vXTp/JOkWwIDAwGAjDg J6l0OplMylv/LM7uf/lXfxXd6wJjNj2Clz19/HhuZoaCWE4RLwuHjxwZGx/v7e5U eMYmIv2WpE0C3797V2pRxkqlYrAhMOBzjA8AP8nmcvF4XF77nex+VKvVZmdn2fQI XvbowYPFly/JwH0yDePAoUOT+/b1dncRfMV/zMZjq3KxqMuZBG7shzQ/L+9K4Hq9 rtXrXP4D+BqDA8BPpK5/Fpn2O9/73qHDh3f5HjFkmZmZkVTCBHDQvamp1ZUVMnBv xHNc5N6Dhw71cueRkUgkQvTFLuRdCWya5p3bt+UttmcVNDAAGBkAviF7/bNo+a9+ /ONdvkGc+GdnZ+v1uqQDAJw1dfNmIZ8nA3fF0PWx8fHDR4/28LiNBIPRaHQ0EuEx x57kXQn85PHjUqkkrxQWtaABv+MUBfiG7PrPx44fv3r9+k7/alnW/Py8OPHLOwDA cffv3l1ZWiKPdUI3jPGxsd6ibzAUEtE3PDrKQ40OyZsEzq+tPX3yRN5qKWpBA37H iQrwjYmJidFIRFLjpmn+xY9+FIvFdvqGpaUlFn3Bj75+8mTmxQuW4+7CENF3fPzQ kSM9xNdwOBxpRl8ZB4bBJm9P4Ht37sgrVCGOuVqtFjghAr5FAAb8Qfb652g0+h9+ +MOd/lVEXxGAJXUNyPZybu7RgwfswbNVI/pOTBw+cqTre9oX+kYilHdGz7R6vVIu y2h55sULcc6SVwqLVdCArxGAAX/IZLM978DZifc++OCtt9/e9p/K5fL8/Ly8rgEF CoXC1I0bI8wDN1lNBw4e7KHCczAYjHChL5wg/ghLhYKMXYuqlcqD+/flrYKu1Woa q6AB3+LsBfjD2Pj4ntvz9kyMP/7mJz/Zdjhbr9dnZmbY9AgDQPyd3/ziCzEyHubk Jp7LI8HgkaNHM5lMt/cNj4rYGwmFw8P8AMJZ9VqtKqe0xMMHD7R6XdLfqq7rIgOz ChrwKc5hgA+kUql4IiFvAWc2m/3jP/uzrV83DEOkX0m7NQKuePb06Ytnz4ZwObR4 Okdjsddeey3W5V7iIjCL3CuyL9dRw3GWZRXzeRnvsb6cn5+bnZU3CVwul/Nra5Ia ByAVARjwgXQ6nUyl5LV/5fr1N44f3/RF0zTn5uZqtZq8fgFXVKvV219+qWvaMMxk imghnstj4+OHDh/uNsEy5QsFqpVKXcKJRtO0e3fuyLsMWBy2rutFOYWsAUjFKQ3w gWwuF+9y0qZzYnD8t//xP276ohg0LywslEolSZ0CrpudmXny6NEATwWLp7bIriL3 ZrPZru4oHpPR5pQvuRcKiD/Uopy1xI8ePKhLWwUtWtbq9QKXAQM+xLkN8IHxiYmI tA2Q0un0n37/+5u+uLKyskqJSww6MfK+NzW1urIySDHYLnAlQu+hI0e6+rmCwWAj 946OUtgZipVLJV3THG92fm7u5fy8pElgNkMC/IsADHhdKpVKplLypmIuXr588vTp 9q8Ui8WFhQVJ3QFeo2na/ampfD7v9xgsRuTxeFzk3q4qxtu5Nzw66vcfH/6l63pZ wlrier1+/+5diZshlctrXAYM+BABGPC6dCaTTCYlNb61/nO1Wp2dnZXUHeBZjbHy nTsFH8ZgkXsj0ej+/ftzY2Od3ysYCo2OjpJ74QXy9kN6eP++Ju1qf3G61DWNy4AB 3yEAA16Xy+W6rdrauWQq9Wd//uetT8VAYWZmRsYoBPAF8cf/9ePH83Nz4raXr4C1 S1tFo9F9Bw6Il4jO7ygSb1gYHaWkMzylVq2K/xxvdm52duHlS0mTwFq9gcuAAd/x 7tkdgG1iclLeRg7n3n77/Q8+sG8bhjE7O6tJuBAL8J2V5eWvnzwpl0qemiC135xK plL79u/vfGGI+BEaM73hsLjh5VSPYSapFJZ4Cj96+FDSOZTLgAGf4kQIeJrUC4At y/qLH/0oGo3at+fm5qoS3oAHfG1pcfHFs2elYjEYDLqSHkUwsAKBaCQyNj4+PjHR 4cytHXfD4iObGMEnJJXCunfnjox9hm3sBgz4ESdFwNOkXgAshsV/9eMf27cXFxdZ xwXsQox0Z6enV1dWatWq1DBsL28OhkLxeDwnjI110peIu+IuoWbqdSurA/3QNK0i Ye+9r588EWc3SUs5GpcB63qRsyfgK5wgAU/LZrPxbgq6dmXf/v3f+6M/EjfW1taW l5cl9QIMnlqttrSwIJ445VJJq9cbebWnzGln3YBdinl0VDzZU+l0JpPZfZpXdCS+ QcTdYND+/9AIiRf+J54OjeXETs/Wiqfq9PS0pFXQ9VqtrmkEYMBfOF8CnjY2Pm4v UZbh6vXrx44fL5fL8/PzkroAhkRjFiifF8+mSrks4rGuaY1wa+/J24y4I82I3Eir IrKGw+J5LeJuPB7fGlwbX2l+1Y61dtxd/9hMvGRdDCrx9NHqdWfbFM/Nu1NTkupg icbF853LgAF/4SQKeNq+/fslLdyyN0Cq1+uzs7Pyro8C0K7xXNvu+dY4GY/YHzgv Y3jpmlaWsAr6wb17hmE43myg+YwWoT1PAAZ8hRMt4F2pdDqZTEoaEIfD4T//wQ9m ZmYkDQsAAOiKyJPFfN7x92SfP3u2troq6d1kEYDXqIMF+AoBGPAuqRWwDhw4cOat t+pOLzYDAKBnMlZBLy8tvXj+XNJlwI06WJpWLBZlNA5ABgIw4F2ZbDYhrQLW2XPn cuPjkhoHAKAHMmpBizbv3bkj6TLgWq2mUQcL8BUCMOBdubGxWCwmo2XTNC9duyZp PRgAAL1p1IKWsKJY3m7AIv3WazX2EQR8hAAMeNf4xEQkEpHRsgjAVz/+WEbLAAD0 o1QsGrrubJtPHz8uFosy3vY1DKNarVIIGvARAjDgXfJKQIdHRy9cuiSjZQAA+lGr VsV/zrY5OzOzuLAgYxV0oxB0pZKnDhbgHwRgwKOkloDOjY2dfestGS0DANAPXdfL EmpK3b51KxQMOt5soJmBS6USlwEDfkEABjwqLQJwKiWp8eMnT+4/eFBS4wAA9EzS ZcBPvvqq6vTEckupWOQyYMAvCMCAR2UymYScPZDE2OKjK1ck1cMEAKBPMi4DFun3 8aNHktZVlUulPJcBAz5BAAY8KpvNxuXsgWQYxrVPPpHRMgAA/atWKvVazfFmb964 IWk34Eq5vMZlwIBPEIABj5K3B5IVCFy5fl1GywAA9E+r10WkdLzZL7/4QtLeCtVq dXVlRUbLABxHAAY8amx8PBqNymh5NBL58OJFGS0DANA/0zSLElYUywvAtVptZXlZ RssAHEcABjxqYnJS0kqtVDr99nvvyWgZAID+SaqDdevGjbCcE6umaUuLizJaBuA4 AjDgUfv37w/K2QR434EDJ06dktEyAACOKBYKpmE42+bdqSlnG2zRNW2RAAz4BAEY 8Kj9Bw4E5exYeOzEiYOHDsloGQAAR1RKJU3TnG3z8Vdf1eTshGQYxsLLlzJaBuA4 AjDgRSkhnZbU+FvvvpvOZCQ1DgBA/2QUgp6dnV2VdqVusVAoFouSGgfgIAIw4EUi /YoILKNly7IuXbsmaW4ZAABHiPQrMrCzbRby+efPnknaClikX5GBZbQMwFkEYMCL 5AVg0zSvfvyxjJYBAHCKrmnlUsnhNnX93p07ITn1NQjAgF8QgAEvSqfTSUkB2DCu fvKJjJYBAHCKoeslCSuK5RWCLjXyLwEY8AECMOBF6UwmmUzKaNkwjGsEYACAt0na CvjmjRuSthgslUoFCQcMwHEEYMCL5AVg07KufutbMloGAMApkrYCJgADIAADXpTJ ZBIEYADAsJIUgL/84otIJOJ4s0K5VMoTgAE/IAADXiQvAFuBwJXr12W0DACAg/Kr q463SQAGQAAGvIgADAAYcgRgADIQgAEvIgADAIYcARiADARgwIsIwACAYcY1wAAk IQADXiSxCJZpXv34YxktAwDgFAIwAEkIwIAXsQ0SAGCYsQ8wAEkIwIAXyQvAhmFc ++QTGS0DAOAUcbYqFQqON0sABkAABrwonU4nUykZLbMEGgDgfbqmlUslx5u99eWX 4XDY8WaFUrFYkJDYATiOAAx4USqdThGAAQDDql6vV8tlZ9vUdf3enTuhUMjZZm3F YiMBy2gZgLMIwIAXifQrMrCMli3Lunj1qqTTPwAAjqhVq+I/Z9vMr629eP58ZETK 6FekXxGBZbQMwFkEYMCL5AVg4a13301nMpIaBwCgf5VSSdM0Z9ucnZlZXVlxts0W AjDgFwRgwKP2HzgQDAZltHzs+PGDhw/LaBkAAEeIPGkahrNtPv7qK8dnlW2GYSy8 fCmjZQCOIwADHrVv/35JC5Un9+07eeaMjJYBAOifpE2A79y+LWn9s65pi4uLMloG 4DgCMOBRE5OTkrZqSCaT75w/L6NlAAD657s9kDRNWyIAAz5BAAY8amx8PBqNymg5 FA5/dPmyjJYBAOifjBLQwo3PP5d0Yq3VaivLyzJaBuA4AjDgUbmxsVgsJqNly7Ku fOtbMloGAKB/lXJZq9cdb/bLL76IRCKONytUq1V55bUAOIsADHhUNpuNJxIyWmYr YACAlxXzeXGqcrbNxibAU1OhcNjZZm0isa9JuGgZgAwEYMCjMplMIpmU0bJlWR9c vChpGRgAAP0Q0VcEYMebXV5ampudlVQEq1wq5SUcMwAZCMCAR6XT6WQqJanxo6+/ fuS11yQ1DgBAz+q1WrVScbzZh/fv67rueLO2UrFYkFC1C4AMBGDAo1KplAjAkt6r Fo2//f77MloGAKAf5WJRRlKVVwLasiwRgAUZjQNwHAEY8C55WwGPBIOXrl6V0TIA AD2TtANwQGYFLMMwFl6+lNEyABkIwIB3jU9MSDpbUwcLAOBBWr1ekbABUkDmDHC9 Xl9eWpLRMgAZCMCAd0ndCenDS5ckpWsAAHpTLpV0TXO+2XL56ePHkq4qYg8kwF8I wIB3ZbLZhJydkISDhw8fO35cUuMAAHTLMs2CnFrK9+7etZzeV6lFpOs8eyAB/kEA BrwrlU6npBWCjkQiH1y8KKlxAAC6Jan+s/Dl559HpG3+16h/RQlowD8IwIB3ifSb SCaDwaCMxrkMGADgKcV83pQzTyvvAmDTMMrlMiWgAR8hAAOeNjE5KW/bBi4DBgB4 hK7rZTkxUuoFwJqmLS0uymgZgCQEYMDT5NXBCnAZMADAMySVvwpIvgCYCliA7xCA AU+TWgcrPDp64dIlSY0DANAh0zSLcspfBWTuABygAhbgQwRgwNPS6XRSWh0s0zCu fvKJpMYBAOhQtVKp12oyWtZ1/e7UVDgcltG4UGoUwKICFuAnBGDA6/bt3x8KhSQ1 fuL0adG+pMYBANiTZVkFaZOoT588qZTLkho3DGPh5UtJjQOQhAAMeN3Y+HhU2uYN sXj8/Q8/lNQ4AAB7qlWr4j9JjUtd/1yr1VaWlyU1DkASAjDgddlsNi7tMmDDNK+x GRIAwCWWZRXzefFRRuO6rt+5fVvSZgpCpVxe4wJgwG8IwIDXSb0MWIw5zr3zTjaX k9Q+AAC7kDr9Oz09vbayImkDpAAXAAP+RAAGfEDqZcCsggYAuELq9G9A8vpnLgAG fIoADPiA1MuAxSn8GrWgAQDKySv+HJBf/5kLgAGfIgADPiB1N2Dh2IkTBw8dktc+ AACbSN37V3j81VfyFlcH2AEY8C0CMOADqVQqmUrJu4opPDp64dIlSY0DALBVpVzW 6nV57d/4/HN5i6csyyoVGyS1D0AeAjDgDxMTE6MyL2S6fP26vMuMAQBoJ847JZnl o2q12sP79+Wd10R0X1paktQ4AKkIwIA/ZHO5eDwur/2JfftOnTkjr30AAFpKxaKh 6/Lav3P7trxlU0KlUllbXZXXPgB5CMCAP6TS6ZS0zZAEyzSvsCEwAEA+rV6vlMvy 2m9s/3vrlrxlU0Jj9TMbIAH+RAAGfGNy3z551Swtyzp19qzoQlL7AAAE5G99JHz9 9GmpWJQ3AywC9uLCgqTGAchGAAZ8I5fLxWSugg6Fwx9dviyvfQAApG59ZJNa/irQ /BFWWf8M+BYBGPCNdDqdlLkK2jTNC5cuRWQOGgAAw0x27atA8+riJ48fSy3rWGos f2b9M+BXBGDAT6Sugg40rzR++7335LUPABhalmWVi0WRgaX2cuvGjfDoqLz2Wf8M +B0BGPAT2bWgTdO8fP16MBiU1wUAYDjVa7VqpSK1C9m7HwWo/wz4HwEY8JNUOp1M JqVu7TA2MXHmzTfltQ8AGEKmaRbzedm9TN26JfU9XMuySqUS9Z8BXyMAAz4zPjER kbm1g2kYVz7+WGrGBgAMm3KxqMvc+FfQNO3e1JTU9c/1en15aUle+wAUYIwL+Ewm m00kElK7OHDo0BsnTkjtAgAwPGRv/Gu7d/euZZpSuyiXy/m1NaldAJCNAAz4TCqV SiSTcpd4meaVjz+W1z4AYHiYplkqFKRu/Bto1qa6c+vWqMwVUoZhiBhfLBbldQFA AQIw4D+5sbFYLCa1i8NHj7527JjULgAAw6BcKumaJruXB/fuya4vXa1WV1dWpHYB QAECMOA/sjcEDjTfsL/KJDAAoD9qFj83pn9v3x6VefVvgO1/gUFBAAZ8aWJyUvaZ fv/Bg8dPnpTaBQBggDUqP4vEKHnxs3D3zh3ZvWiatrS4KLULAGoQgAFfUlAKi3LQ AICeWZZVLpUMyZWfA0qKPwcofwUMEIa2gC+lUql4IhEKhaT2MrFv36kzZ6R2AQAY SPVarVqpKOjozu3bst+rpfwVMEgIwIBf5XK5WDwutQtxyr98/brsmA0AGDDi9FFS crlsrVZ7cO9eOByW2otI8qurq1K7AKAMARjwq1Q6nUwmZb/tnUql3n7/faldAAAG iWVZpWLRlFyT2Xbzxg3ZFTEaP06pVKT8FTAoCMCAj42Nj0ejUaldmKZ5/sKFuOTr jQEAA6NaqdRrNQUd5VdXnz17JnuZUq1WW1leltoFAJUIwICPqZkEDofDFy5fltoF AGAw6JpWLpXU9HXj889lvwvM9C8weAjAgL+NT0xEIhGpXYjT/+k335yYnJTaCwDA 70zTLBUKlvx9j4S5mZnl5WXZbwHX6/XlpSWpXQBQjAAM+Fs6k0kmk7J7EWOZK9ev y+4FAOBfIvdWSiVd/r5Hguhl6tYt2e//CqVSqZDPy+4FgEoEYMD3JiYnZZcAEfYf OHD81CnZvQAAfErZvkfC3akpBb1omra0uKigIwAqEYAB38tkMgn5k8CGYXx05YqC t9sBAL5j6HpJ1Ta55XL58aNHCrboK5dKeaZ/gYFDAAZ8L5VKRWMxBZPAIv1+cPGi 7F4AAP7SqBRVKJimqaa7Lz//PCK59lWgOf1bq1aLqlI9AGUIwMAgUHQlsGWdOnt2 ct8+2R0BAHykXCrpmqamr5np6dWVFdm1rwJc/QsMLgIwMCDUXAlsWtaV69cVjDwA AL6g8tJfTdPuTk0pONlx9S8wwBjFAgNCzSSwkMnlzr39toKOAAAeZxhGSeEeubdv 3lRw6W+A6V9goBGAgcGhYE/gQHObx3fef1/kbdkdAQC8TPGlv0tLS7PT0woCMHv/ AoONAAwMjnQ6nUylFHTEtsAAgEqppKm69FfZxr9CqVgsKJzWBqAYARgYKOPj4wpq Ywpj4+Nnzp1T0BEAwINUXvorTN2+HVRSfkL8XMvLywo6AuAWAjAwUNLpdCKZVFCk yjTNd8+fT6XTsjsCAHiNyl1/hZWVlennzxUsfrYsq1wqMf0LDDYCMDBocmNjsVhM TV+XWQgNAEPGMs1isWipuvS3sfj55k01i5uq1erqyoqCjgC4iAAMDJpUKpVIJoPB oIK+cuPjZ1kIDQBDw7KsSrmsbNffgMLFz4ZhiB+tqHBmG4ArCMDAAMpms/FEQkFH pmmee+ed3NiYgr4AAK6rVaviP2XdLb58OTc3p2brI5F+19bWFHQEwF0EYGAApVIp EYDVjBhMy7p87ZqaCWcAgIt0XS8rnCDVNO3u1NTo6KiCvsSPVq1UmP4FhgEBGBhM mUwmkUyq6UuE7fc++EBNXwAAV5imWSoULMtS1uPNGzfUpF+hXCrl83k1fQFwFwEY GFjjExNqtkwU46HjJ08eOHRIQV8AAPUa5ZGLRcMwlPU4/eLF2uqqgk0NhHq9vry0 pKAjAF5AAAYGViqdTirZEinQrB3y0ZUravI2AECxaqVSr9WUdVcplx89fBgOhxX0 JbJ9qVQqsvURMDQIwMAgy+Zy8XhcTV/BkZGL166p6QsAoIxWr4tEqqw7lfseCZVK ZW11VU1fALyAAAwMMpXVsISx8fEz7IoEAAPEMIyS2tlRZfseBah9BQwlAjAw4NKZ TCKRULMQ2jRNEYAnJicV9AUAkK2xPLhQEK/tynqcn59fmJ9X875t48LmcrlA7Stg yBCAgcE3Nj4eVbWWzDSMi9euqblwCwAgj8iHlXJZ1zRlPVYrlYf374dVVX6u1Wor y8tq+gLgHQRgYPCl0ulEIqFsq95QOPzR5ctq+gIASFKrVsV/yrrTdf32zZvK3q41 DKNSqVD7ChhCBGBgKGSyWZGBlXU3Pjl5+uxZZd0BAJylaVqlVFLZ452pKZWj0nK5 nF9bU9ghAK8gAAPDQtm2wIHmxcCnzp7dt3+/mu4AAA4yDaNRF8qylPU4Mz29srQU VFWykY1/gWFGAAaGheKF0IZhfHjpUiwWU9MdAMAR6gtfFfP5J0+eKCseweJnYMgR gIEhonghtBUIXL52TU0BagBA/9QXvtI07c7t28oWKAVY/AwMPQamwHBRuRBaiMXj 73/4obLuAAD9UF/4aurWLZVnJRY/AyAAA8NF8UJoy7IOHj78xokTaroDAPRMfeGr +3fvGoahbKEQi58BBAjAwBBSvBDaNM0z585NTE4q6xEA0C0RDktqC1/Nzc4uLiyE VBW+CrD4GUATARgYRmPj48r2WgxQEAsAvG3gC18JtVptZXlZWXcAPIsADAyjVCoV TyRUvu8uRleXrl1TtvQaANChRuGrUknXdWU9iix6784dlZf+NhY/l8uNvZ0ADD0C MDCk0plMIpFQWaJ5NBL58OJFZd0BADpRrVTqtZqy7tQXvhIJv1wuF/J5ZT0C8DIC MDC8cmNjipcl58bHz547p7JHAMAutHq9Ui6r7FGkX8WrgarV6urKisoeAXgZARgY XqlUKhaPq7wEy7Ks195448jRo8p6BADsxND1ktpVwU+fPCmXSioXH+m6Xq1UWPwM oIUADAy1dDqdSCZVjkVM03zz7bfHxseV9QgA2Eq8GpcKBUth2ef5ubmFly8Vl58Q ebvAvkcA2hCAgWGneFekQLMYyQcffRRX2ykAoKWRDItF8WqsrMf86urXX3+tcs1R gH2PAGyHAAxA9a5IgmWaH129qngkBACwVcplrV5X1l21Wn1w9+6owsJXAfY9ArAD AjCAQCqdjsfjKpelCSPB4KWrV1X2CAAINJNhrVJR1l2j7PPNmxG1b7M2Lv2tVoss fgawBQEYQIP6i4GFWDz+/ocfquwRAIacrmnlUkldd8o3PQpw6S+AXRGAAazLZrOK r8sVY5SxiQk2RgIANUzDaNRDVlj46vatW8GREcXvrlbK5TUu/QWwAwIwgG+4cDGw ZR06cuTY8eMqOwWAISReb0uFgmmaynp89PBhvVZTnH659BfA7gjAAL6hfmfgQHMr jpOnT+8/eFBlpwAwVOxVwYauK+vxxfPnqysriqtLsOsvgD0RgAG8IpVOJxKJYDCo slPDMN5+771sLqeyUwAYHtVyua6w7PPCy5fzc3OK0684lVRE+uXSXwC7IgAD2CyT ycQTCcWL1tgcGAAkqddqVYVln13Z8teyrEq5nM/nVXYKwI8IwAC2kcvlYvG44k5N 0/zo8mXFG0UCwGBTXPa5XC4/evBgdHRUWY82kfBXV1cVdwrAjwjAALaRSqUi0aji jSsCzbfwL169qnjVHAAMKtMwSsWiparsc61Wu3fnjvpzR12o1bj0F0AnCMAAticy cCKZVHwxsDASDF68ckXxAmwAGDyKyz5rmjZ165birQQC9qW/5TLpF0CHGGIC2FE6 nY4rL4glhEdHL1y6pLhTABgkiss+67p+++ZN9enXbBa+KlD4CkDHCMAAduNKQSwh Fo+//+GHijsFgIFRKZc1VWWfRfqdunXLlatmKHwFoFsEYAB7yOZyceUFscSwJpPL vfXOO4r7BYABoLLss0i/d6amwqGQ+rdKK5XKGoWvAHSJAAxgD6lUajQSUb+wTWTg iX37Tp89q7hfAPA1xWWfp27fFqNJ9em3Vqtp9TqX/gLoFgEYwN5EBo7FYmHl21qI DHzg0KHjJ08q7hcAfMowjJLCC2If3r+vaZr69CtCfrVaJf0C6AEBGEBHUul0PB5X v0GRyMBHXnvttWPHFPcLAL5jmmZj0yNVZZ+/evSoVq2qT79Gs/BVkcJXAHpCAAbQ qXQ6nUgm1Y91xJDu2PHjh48eVdwvAPhIo+xzsSjCoZruvn7ypFAouPKuaLlUouwz gJ4RgAF0wa2i0CIDnzxzZv+BA4r7BQBfELGwWi5rmqamu+nnz1dWVlxJv5R9BtAn AjCA7rhSFDrQXPN29q23JiYn1XcNAB5Xq1bFf2r6mpuZWVxcVJ9+A5R9BuAEAjCA ro2NjUVjMfX9igx87p13xsbH1XcNAJ6l1euVcllNX/NzcwsvX7qSfkXCX1lZUd8v gAFDAAbQtVQqFYlGI5GI+q5FBn7r3XdzY2PquwYAD9J1vayqGPJLYW7OlfRbF2o1 yj4D6B8BGEAvGhsjxePhcFh916ZpigyczeXUdw0AnmIaRqPss2Up6GthYWF+dtaV 9CtCfrVSIf0CcAQBGECP3NoYKdCcB373/Pl0JqO+awDwCJF7S4WCqWTTo6XFxZnp aVfe9GTTIwDOIgAD6F1aZOBEIhgMqu9aDIne++ADEcLVdw0ArrN3AzJ0XUFfy8vL 08+fu5V+q5UKmx4BcBABGEBf0plMwo2NkQJkYABDrFIua/W6go5cTL+NkF8uF9j0 CICjCMAA+pXJZuPxOBkYANRQtumRu+m3Uqnk19bUdw1gsBGAATjArc2BA80MfP7C hUQy6UrvAKCYsk2PVldXn3/9tSvpN8CWvwCkIQADcEZubCzmxubAgWZd6Pc//JAM DGDgGbpeUlIM2d30W61WV9nyF4AcBGAAzkilUqORSDQadaV3MjCAgSde6EqFgoJN j9xNv7VaTavX2fQIgCQEYACOERlYJOBIJOJK72RgAANM2aZH7qbfulCrkX4ByEMA BuAkkYGjsdjo6KgrvVMTC8BAUrbpkYtVrwRN02rVKukXgFQEYAAOExk4Fo+7NX4i AwMYPGo2PXI3/eq6Xq1USL8AZCMAA3CeyJ+JRCIYDLrSu8jA754/n85kXOkdAJyl ZtOjpcXFmelpF9+7rIj0Wyi40juAoUIABiCFyMDxeDwUCrnSOxkYwGBQs+kR6RfA 8CAAA5AlLTKwq/PA77z/fiabdaV3AOifrutl+UuCXU+/1UqlQPoFoAoBGIBE7mZg 0zTPvfNObmzMld4BoB+mYZSKRdmbHr0U5uZcXK1D+gWgGAEYgFzpTCaRSIyMuPNq I0ZXb7799vjEhCu9A0BvLNMU6Vf2pkdzs7OLCwtupd9GaetyuZDPu9I7gKFFAAYg nesZ+My5c5P79rnSOwB0S82mRzPT08tLS6RfAMOGAAxAhUwmE3cvA5uGcfLMmf0H D7rSOwB0TiTDarmsaZrUXl48f766suJi+q2Uy3nSLwA3EIABKJLJZuPxuGsZ2DSP nzx58PBhV3oHgA4p2PTo2ddf59fW3Ey/lYo4AFd6BwACMAB1XM/Arx8/fuToUVd6 B4A91ev1quRNj54+eVIsFEi/AIYWARiAUtlsNuZqBj782mvH3njDld4BYBe6ppVL JaldfPXwYbVadasyf2N1d6WyRvoF4CoCMADVRAaOJxJu9S5GYPsPHjxx6pRbBwAA WxmGUZK8G9CDe/d0XXfr/UehUi6TfgG4jgAMwAXZXC4ej7vVu8jA45OTZ958060D AIB2pmmK9Ctvy1+Re+/fvTvSJKmLPVUqlbXVVbd6B4AWAjAAd7iegTO53FvvvOPW AQCATbwcNbb8NQxJ7Yv0e2dqKhwKkX4BIEAABuCiXC4XjcXcGpOJQWcynX73/fdd 6R0AAnZRqFJJl7blbyP93r4dDoddTL/VSmWV9AvAMwjAANxkZ2Bxw63Bmej9/IUL rnQNAJVyWavXJTUu0u/tW7eikYik9jtB+gXgNQRgAC5rZeCASzE4PDr64cWLLk6P ABhOUrf81TRtSqTfaFRS+50g/QLwIAZ8ANzXnoEDbsTgUCj04aVLbm0NAmAIafV6 RdqWv7Va7d7UVIT0CwBbEIABeMKmDBxQH4NHRj66fFkkYaWdAhhKuq6Xi0VJjYv0 e3dqirlfANgWARiAV2zNwDZlSdgKBEQGDofDaroDMJwaW/6K9Ctn0yORPO/fuxfh ul8A2AEBGICH7JSBA6pisGmaFy5dcnfdIIAB1tjyt1i0TFNG46LlRw8fkn4BYBcE YADesksGDiiJwYZpnr9wIZFIyO4IwLCRuuXv2urq10+fjo6Oymi8Q6RfAN5HAAbg OdlcLrZzBg7Ij8GGYbx7/nw6k5HaC4ChInXL36XFxZnpaXev4KhUKmukXwCeRwAG 4EV7ZuCA5BhsmubZt94an5iQ1wWAoSJvy9+5ubnFly/dreFH+gXgFwRgAB7legY2 DOPU2bP7DxyQ1wWAISFvy9/p589XVlZIvwDQIQIwAO/qJAMHZMZg0zRff+ONI6+9 Jql9AMNA3pa/Tx8/LhaLLqZfy7Kq1SrpF4CPEIABeFo2m43F43t+m9QMfOjIkTdO nJDUPoDBJm/L34cPHtRrtWAwKKPxTjTSb6Wytrbm1gEAQA8IwAC8LpPNxjvIwAFp MVgM8sYnJ8+8+aaMxgEMMMMwRPq1nN7yV4Tq+/fujSjcJn2rRk2vSiVP+gXgNwRg AD7ghQycTKXePX9eRuMABpJpmiL9mk5v+SvS793bt0PhMOkXAHpAAAbgD51n4IC0 GBwKhT66ckVGywAGjIiIIv0aTm/5K9Lv1K1bo6OjpF8A6A0BGIBvZDKZeCLR1V0c HyOapnn5+nUXL7oD4H2NiFgu65rmbLOapon0G41GnW22K/aPls/nXTwGAOgHARiA n6RFBo7He4i1DiZhwzDe//DDZCrlVIMABky1UqnXas62WavV7k1NRVxNv6ZpViqV AukXgJ8RgAH4TM8ZOOBcDLYs6+jrr4v/HGkNwCARSbVWqTjbpkjU9+/edTf9GoZR rVZJvwD8jgAMwH/S6XQ8keg5zToSg0UGTqRS777/votX4gHwGhlb/haLxccPH45G Is4225VG+q1UCoWCi8cAAI5g3AbAl0QGjsXjfV6L2392FTH4/EcfxWKxPtsBMABk bPm7urz87Nmz0dFRZ5vtCukXwCAhAAPwq1Q6He87Awf6jsFiaHjy9OkDhw71eRgA fE3Glr8vX76cn50Nh8MOttkV8ePY1/0WSb8ABgUBGICPOZWBbT0nYTFGzORyb73z jiOHAcB3REosifTr6Ja/0y9erCwvh0IhB9vsUCvG29f9kn4BDBICMAB/Exk4Fo2G nJsh6efS4vMXLrhbpQaAejK2/H369Gkxn1effttnsMVPVKtWW5+LV0arg4HjjjPg dsviBbZ5o+j0WnEA6BABGMBmIlKKl4aRYFAkumAbt49Lqd5isBgvnnnzzcn9+x0/ HgDe1NgXt1TSdd3BNh8+eFCv1dS/6jq7fttdZhuruZJb/GxMZQMIEICBIZdKpUZs Gyk3FApR1tjW2+MgBlvjk5Nnz51z/HgAeFClXNbqdadaE0H6/r17I45uXd6JQYq+ u9gmFVsWc9HAsGGYCwwREXfFqKo1sRsOh4dtXrcHvQ1DxQN7/qOP3C3cCkC2WrUq /nOqNZF+79y+LV6ZVabfIYm+uzAMw2z8z7SasThAJAYGHQEYGHCNOd6NqV3F46pB 0sPjJoZSZ996a3xiQsbxAHCds1v+ivR7+9atqNrNfkm/W4mXbqPJbEZiwjAweBgK AwPIDr0h8V847OL+GQOmtwy8b//+U2fPyjgeAC5ydstf8Vpx88aNqMISekTfDhni N93Mw4RhYGAQgIHBkUqnGwubQ6Hw6CgzvZL08MCGwuHzFy7wTgQwMEQcKoks5FyG fPb118VCQc3rNtG3N+Jx0zVNb84MU0wL8DWGyIDvpVKpYMie62WFsyLdPs5ixPTW O+/kxsYkHQ8AZfrZ8lfX9Uq5XKlWF+bnNU0baaNgxyOir1PE7078KknCgE8xVgb8 yl7nHA6FRl+9ZowMrFLnj7YYKh08dOj4qVNSjweAVCJDivRrbmz521gIXSpVq9Va raY1Gc1cZF8+asdNO9+2bgSbO8wpPmaV3Q0P8cBq9brO6mjAbxgoA/5jT/lGotHg zqMoYrBiHT7ghmmm0unI6GgkEonGYuK/WLxBweQPgF2I7Lq6vFxpVnUWqWY9zTbr A7en2cay57ZA6+V948i9yhi6Lv5ixJ8KMRjwBY++agPY1nr0jUQ63L7IsyOzAdbD Y2412TfsCaKQbXQ0HA6LX7eIy9FmYI41MzObVwFbibyaX1urVir1psbUXNP6Djfi Q3OHm005tjUzq35iVhJyr3r2Y26apvjDIwYD3jcIr/XAMGhE32CwMevbffgZjFGd 70h62K0NgY0VlfY0lB2awy2jzVlm8SEqsnOkt78cQCoRWculkvjYWD/cnHQ17Gsr RWRtW0jc3Jx1I7s2g2t7fLWaHwcpwfaG3OuKrQ97IwbXaiaLogEPG95TBeAj6XRa hJk+ywgP89DQXR555O0UsX4ozewgIkdgpP0LzQixsYFWqJWoR5saIToqPkskk+Iz 934OKGKnUxFE7UzaYjTzqT2t+k1GFTHAbFaFst+daQur9rqGwMYT4ZU/uA3u/ZS+ R+51y+6PvHimiBfYAiWyAE/irAN4WjKZFPHD2c0hGW66ZQAe+Ua4aV4MuR5y7Lm4 QKB9CXfrxkjbTJ342JiAtm+ImC1uBoP2lJ0due3boWYCDzZXga9fYNms9CZuN4qc B4N29h6AEG7Hy8BGHZ1Ac8TcfHQb0dJqXlUYaG63YzXfuTCaVZfWP9qXpG78Luzg 2fi4kTzXfxnNTwP2p82vND7aibR5I2APAuw/y5HGPwTakqq9ZGAA/mgHErnXRZ0/ +LVaTTyRmQoGvIYTG+BdqXRaRF9J5ZEY17qFR75/rQGo2bYVzTaj0u3GqZZDj//I toPgHRpv/6W31qLzl4AeEH1d1MODbxiGiMHslgR4CmdfwKMymUw0FpM9RGYI7hYe eQBdIfq6qJ8HX9y3Vq3m83kHjwdAPxiBAZ6TSqVC4bCzy553QRJzEQ8+gD0RfV3k 1IPPcmjAOxh7Ad4i0u9oo3av6usbSWLu4vEHsAm5112OP/66ptXrdTIw4DqGXICH iPQbjcUkXfTbCWKYu3j8AQSIvm6T9/ibhlGtVsnAgLsYbAFesZ5+g8Gd6uioQQZz Hb8CYGgRfV0n+1dABgZcxzAL8IRv0q/N7QhEBnMdvwJg2JB+3aXs8ScDA+5igAW4 z06/67tutv+D2xGIDOYuHn9gSBB9Xaf4V0AGBlzE6ApwWXv6bfFODCaDuY5fATDA iL6uc+tX0NgimAwMuIFxFeCmVDodiUR2qnrlnRgcIIZ5A78FYAAQer3A/d+CZTUy cL1eLBRcPhJgyDCWAlyTSqVi8fiekcZTMThABvMMfhGAj7gft7DB/d9F2wGYllWt VJgHBlRi/AS4Jjc21vl+v8Rg7IJfB+BB7gcttPHEr6PtGFq3NE1bXVlx5XCA4cSY CXBHOp2OxePd3osYjN3xGwFc54mghTae+I1sF31bqtVqIZ9XeTjAMGOoBLggmUrF O1j8vBNiMDrB7wVQxhMRC1t44veya/Td+BarUqmUWAgNKMHwCHDB2NhYuOPFzzvx WgwOkLi8it8LIIkn8hW28MrvpYPo26Jr2goLoQElGBUBqvW2+HknHonBpmmKAYcI WsFgkLjlWfxqAEd4JV8NAbPJarJfv8TrmPg8uGHT93vlV9NN9G1hITSgBoMhQKk+ Fz/vRFkMFmMLeywihh3RaDSTzR46fPj4yZOjo6NGU6VSef7s2eLCQqlYrFWruq43 xgEjDaFQiADmEfwigB54JVwNkMYJpXlSsT8VZ5ZwOByJRhOJRDabHZ+cFKcYcdK0 s+6mFy5xinl4//7M9PTa2lqtVhPNeOJN2J6i78ZdqQgNqMAYCFCqq8rP3XI2BotB idHMuuFQKBqLZXO5Q4cOnT57Vtzurp1mZhYK+fzDhw+XRTYulcRgRaRla+d38aEA MRjoENG3N+351k6n4gwoTiLJZFKcU/bt2yfybbfnlN3ZqXh2dnZtdbVxotH1gLK3 X/uIvi1UhAYUYPQDqJNKp+PiTC/5NNxbDLYzqhidxKLR7NjYkSNHTp4+7ey4ZCdi vCIGK/Ozs8tLS41543qdbKwSMRjYBdF3J60FQfZDFBQ5MxwW+TYWi4mT3djY2MS+ BjXnkd2Js8xXDx9OT0+LbGnPFTt/ctn4O+n/z6VSqRQLhb6bAbAjxj2AIqlUKhKN huwzrgcycCPvGsZoJJLN5d544w1lcbcrjWw8MzM3P78qsnHbvLE9k0A2dhZJGGgh 9247edtYnByPp7PZsfHx48ePe/Cs0SE7Ej99+nRtdVWr14OhUO8nFCcmftuJ01y9 VmMhNCAPwx1AkXQmE41GVdas2tqXPc0rovix48ffefdd/45dAs3hy8LCwsv5+eWl pWKhUK1WdU2zx2rr14oRj3tCDMaQG4boKyKW+Dnbw204HB6NROIi3KbTubGx8YkG X58juiJOKLdv3fr6yRMRO7t4d9Xp6NtCNSxAKgY6gArJZFIMLFqJ95snnvywITow mqVBjr7++uWrV+POFaD2MjGa+frp05cvX+bX1srlcr1t6tgTVVI8j8cHQ2gAom8j 2TYrONg/SSgYDIVC4Ugk2iwrlc5kcrncsTfeGJ5k24NKpfKvv/719PPn4u9BPHo7 fp9za563a9uqlMulUklC2wAIwIAS2Vxua+0rBTFYDIb2Hzjw7e9+d0hyb4fE+ObJ 48dLCwv5fF7cbsXjQHP22E7Ibh+jJxCDMSQ8Hn1bl9pabXO2IpuNimQbiSSSyXQ6 PTY+/trrr5NsHSTODp/97Gcv5+c319CSNvHbrl6vr62uSmseGGoMbgDpGtO/icS2 /yQvA+u6fvX69TNvvulss8PALsq1uLCwurLSuPC4WtU0bX2jY/GLGr6ETAzGoHIx 94qXlNZH+0jE00yE2nCzjlQkEhFnjVQ6nc1mM9nsUK1G9qD79+799le/Er+b9pdC 2X86jUngSqXElcCABAxrAOlyY2NiTLPLNzgbgw3DeP3YMZF+GTBJIiLxy/n5xaWl tZWVYrFYFQm5Xjd03Z6dGdkwwCGZSAyfkpd4G1HWvqp2o4/Gi0CzMPL6VG1zEXIy JVJtWmTa8fFxXqJ9RLzs/+bXv3729Kn4dap416T5R6Tr+gpbIgESMIgB5EqlUrHO lh87Uh9LxLDv/+VfZnO53u4Op9g1upZFSF5dbYTkSqXe3N5p/Qq9jauRByYnE4nh Qb3FXTvK2u9ntVqwL44INS6oDY/a9aJisXgz0IpEe+TIEdLsMBCv5//8T/8U2vUd 7X69emmxOHdQDhpwHEMWQCJ766OuEk4/MTgUDP6HH/6QcZiPiJy8vLwsBlVCuVis VKu1Wk1rRmWzeVlyayrJX2mZPAxXWG1an9r/1PiLbE7JimdRozSUvdR4dDTalNiI sh7ZtxaeJV60/+9/+IfW2nXH7HBdseiILZEAxzFGASQSw6lYT2OpHmKwiEZ/Qfod dGLs9fz580KhINJyuVwWn9Y1Tdc0OzBvWn5pp1AvxGbyMHbRCKnNqsWt1Bpom3pt /Rk3rsBvFiNq1jVuLCwON6+VjYr/4k2JBi6XhWwOZ+C9SmqJ7sRrvjN9AWhiUALI 0sP07yadx2ARgf767/6OYR+21SjrNTNTbKo1J5nrtZreZIj/7PjRNmlm36sVoQOO pmjCsO80/0DMwKsrijf9tQQ2plhb77sEW4uGm/WK7cXD9mazEbvKUyQSi8djMfEh nsvlePmCj4gX0v/z7/9+9+oee+usmjSTwIDjGIgAsqTTaUeGdHvGYHF2/Msf/SiR TPbfF7ATMeBbXV0tlUrVZoQWn+pag75hfRa6yWrbtiWwcS2lXed2fYK67UZgY4pv 236/mQDc9dt8bdN63VdS5cjI1tj56q1vHsxA6+WibdY00Nr72r4ZbCbT5sdmOP1m PbA9pyo+RqJRO6BGmqWbSKfAVuVS6Z/+63/t8Z3BLjdSYhIYcNYAjiQAL0ilUmIE KcaXTjW4Sww+dPjwd//wD53qCPAmO4Hbtyvl8voXazV7+FgXN+y6qc09qxo3moF8 UyNGM6I7cjxbd/YWRIAMtj097QrAjRvNbBloPpFFpLT/tbU7GgkT8KOfffrp7PR0 d/fpaQ9h8cKl1etMAgNOIQADUnRe/LkrWzdM0nX9r3/8Y0bPAACo1PVC6FcrPHeF ctCAgwjAgBTZXG5UnBTlLNdsNWpZ1r//kz/Zd+CAjF4AAMAuXs7P/3//43/sfWlG H9HXpmtaawkMgD4RgAHnJZPJWDy+dbbWWaLRZCr15z/4gYzGAQDAnv7bP/5jqVTa 8Z/7jr4tlXJ5t44AdIwADDgvnclEI5HNX3U6Bhu6TuVnAABctONC6J4u992to1qt kM870RIw7AjAgPMmJicD2z67HM3AV65dO3XmjIMNAgCAbj168OBff/3rbxZCOx19 WxYXFhxtDxhSBGDAYZlMZrRt+ldSDA6OjPztf/pP/bcDAAD69H/85/9s7/rW+oqz 0ddWr9XyTAIDfSMAAw4bGxsLvrr70U7bm/bchTjLsvEvAAAesb4tcPPMLiP6NliW YZory8uSmgeGBwEYcJi9/nkrB6eCxycm/uTP/qy3+wIAAMf9v//9vy8vLclqvTm3 LP63tLgoqwtgaBCAASclEol4IrHLN/Qfgw3DYONfAAA8pVat/l9///ebloA5wHpl RrlSqVALGugTARhwUiabHR0d3fPb+onBY2Njf/r973d3WAAAQLL/55//eWVlxbHm rM2LqcXnmqbl19Yc6wIYSgRgwElbLwDeRQ8x2DTNH/7N38Tj8a6PDAAAyFSpVP7h v/yXYDDYb0PbRV+byWXAQN8IwICTxicmRrq/srerJPyt73wnFAqJ82toO/bXezgG AADQLfNV/+0f/1F87L25naNvC5cBA31ilAw4JplMxnqdm+2oUrRlHT127Njx43u2 tikeb03LDrw/DQDAYLGazL0YhmHfsL+/vYWvnzx58exZb31v/sIO31jlMmCgPwRg wDHpTCbStgNwD3aPwbquX/vkk06uMd67o5ERppEBAIOtkzS7SZ89apr265//PBwO d36I23xt13vU6/UCuwEDfWCACzgml8uFOj/n7WynGCxy6dWPP+6//Q7tMo1s3xYf CckAAGW6TbPWdvFStt/88pemYez9fd1HX5uh66urq10fFoANDF4Bx4yPj484t7R4 05NTnBTffu+9sfFxp9p3RHsw3pqQCckAgG215mZ3n6Td9K9uH3VHVpaX79y6tcc3 dbzgebu7WhI3HAaGAANTwDETExON/3M077Xa0g3j29/7noMtK7NtMG6fRma5NQD4 2rYhds9k6/ZRS/TZT3+64yroPqJvC3WwgH4w6ASckUgm47HYN587HYNHgsFrn3zi YJueYl+TvCkVt39kMhkA1Ngzu26NuIOdZnvw65//fJvHxInoa6tUKmXqYAG9YjQJ OCOTyWwuT+VoWjty9OjxU6ccbNCPgk3kZADY06aCxpsy7S6fun3gg+DJo0cz09Pf fO5c9LVp9XqeOlhArxgmAs7IjY3ZewttflI5EcbEiOTqxx87Uv95GLRqXLeycfsN ll4D8JH2HGvf6DDWMivrIk3TfvOLX4izTM+VrnZnGMbqykrfzQBDisEf4Izx8fFW 1nU8A4uhzCff/W6fjWCrkWZt7V3ScntsdvtgAfjYpgXDO93Y+kVyrE/9/Gc/C205 cTj1u6QOFtAPAjDgjHG7AlYbB2NwIpn88OLFnu8ORwQ7Zs8tM70MDIzWNOxOH3f/ lBA7hD7/3e8qbZfpOvwXYFlLBGCgV4zPAAckEolYPL7169s8wXoKRWfOndt/4EAP d4SL9szJ9vxz+20yM+C49uy6KZR28mnrtts/B3zm5fz8g7t3RxyPvoH1K4obdbDK ZcfbBoYBgy3AAemtFbBe1c9ssGkYVz/5hAuAh4E9b7xLQt50u/2G28cOOMZq08qf Wz/d9vbWBOv2T4MhZV8G7PDlM21vxNQ1rUAdLKAnjJkAB+RyuWAotOe39RaDuQAY exrZYIfhbm9suu32TwMfsLYIbGwGu+2/dphpiawYJD//2c8cC8CvrkGwmmMD6mAB vWGgAzhgbHy889jQbQxOpdPnL1zo5bCA7m0biduz8dYv9vavLv+cA6E9eQbaYmcn t9s/3enru3DvhwZ848bvf18sFPptZUv03fiytbK83G/jwFBiCAI4YGsFrD11HoO5 ABiDqpWKHfm4qdlt++rti5vy3tb4t/s3bPtpJx87+QYAnmVfBtz7/XeIvi0UggZ6 QwAG+pVKpSLRaG/33TMGi2HulW99iwuAAQDwF03T/vWXv+xlwcte0ddWr9WKxWIv RwYMNwIw0K9UOh2JRPppYZcYrOv6d/7dv+uncQAA4Ip/+fTTcDjcxR06i762er3u wBJrYPgQgIF+ZbLZcCjUzza/tp1i8Le+850+WwYAAOr98rPPAh1esNBN9LXpup5f W+vlsIDhRgAG+tUoAd0q89hfDN5654NHjpw6c6afNgEAgCsePXgwNzOzxzdtLSvQ WeMUggZ6QwAG+tUoAb3pSw7FYHEKfO+DD7K5XD+tAQAAV6ytrt66cWPHf+41+m7c m0LQQC8IwEBfUqnUaPMCYGczsN1gowLWxx9TAQsAAD/asQ5Wf9G3hTpYQA8IwEBf EslktK0EtLMx2DAMKmABAOBfn336aai9DpZD0ddWq1ZLpVIfDQDDiAAM9CWdToe3 zNA6FYNT6fQHH33U230BAIDrvvi3fyvZk7SORl+bpmmFfL7vZoDhQgAG+pLJZkOh 0NavO5KBT505c+jIkV4OCwAAeMDs9PRXDx/2UOR5b5ZlmOba6qojjQHDgwAM9CU3 NrbLHvd9xWAuAAYAwOfWLwNu+4oD6XcjTpuWRSFooFsEYKAvY+Pje35PbzHYNM1v f+97vRwTAADwjJ//9Kf2dokORt/1zwIBCkED3SIAA73bVAFrd93GYCpgAQAwAD77 9NPgdldLdWeHRdS1Wq1MHSygGwRgoHfJZDLScQC2dR6DU6nUBxcv9nJYAADAM774 3e/62qxo1+uH67UahaCBrhCAgd6lM5lw+94GHeskBh8/efLo66/3clgAAMAzXjx7 9uSrr3q5Zwels3RdpxA00BUCMNC7bDbbz6Km3WKwZb334YfZXK7nxgEAgBesra7e /OKL7u7TcdVok0LQQJcIwEDvGiWg7Vu97vQb2PZJODJimebVTz6hBDQAAH6nadpv fvGLXfaMeEWXGyZZFIIGukQABnrXmAFu1nVc51wMNkyTClgAAAyGvetgWZujbocl o03DWFtb6/GwgKFEAAZ6l8vltnlD14kYbFoWeyABADAYPtvYCWkbvUbfjXszAwx0 hwAM9O6bJdCb9JGBA82n5aGjR0+dOdNPIwAAwCMePXgwOz29+av9Rd8WtgIGukIA BnonArB9w/EY/N4HH7QaBwAAvra6snLrxo1vPnco+toIwEBXCMBAj5Kp1KYiVQ7G 4PcpAQ0AwKBoFIL+/PPGkMDR6Nu8v1XXtFI/+wwDQ4YADPQolU5v3QR4x2dUNzHY Ms1r3/42JaABABgMmqb9+uc/D746GOg3+gbWZ5I1XS8WCv03BgwJAjDQo3QmE9qh omOfU8EmJaABABgs//Lpp6GNOlhORV+bbhiFfL7/JoEhQQAGepTZtAfSFj3HYPEd H3/3uz0eFgAA8J5f/OxnAaejr800TXZCAjpHAAZ6lMvl9kyzva2IjkYil7/1rR4P CwAAeM9vf/nLWr3eVxNbou/6l5tFtvpqGRgmBGCgR51Xae42BlMBCwCAAbO2uvrl 55/3eOedo6+NAAx0jgAM9KjbbYo6j8EEYAAABkyPAXiv6GsjAAOdIwADvUgmk40q zT1tcbT7tcGWZV375BNKQAMAMEjsQtAjnY8cOou+rcbZCQnoEAEY6EUqlXplD6Tu k/BOMdgwjD/4wz/s+cAAAIA3/cv//J/BHfaPeMV20Xf36lm6phUJwEBnCMBALxqb AG86hzk0G2xaFnsgAQAweP7l00933z+ih+hrM3S9wFbAQGcIwEAvGpsA73QO6282 eCQY/PgP/qDHwwIAAF71i//1v6xtFzZ3s9p5W6Zh5NkKGOgMARjoRWMT4F2Cbh+z wZFY7Mr16z0eFgAA8Kp//eUv65t2Quo7+q5/P1sBAx0jAAO9aFVp3u0p1FMMPn/h AiWgAQAYPK8UgnYo+rZaW11d7e2uwLAhAAO92JRRHYzBBGAAAAbSegB2Ovra/08A BjpEAAa6lrD3QHrVHs+ljmMweyABADCQ1ndC2vL1PqOvra5p5VKpt5aAoUIABrqW TCbDO2TUPmOwZZrfYQ8kAAAGVGMnpLYimo5EX5um62wFDHSCAAx0LZVKhdo3Ad6i 5xhsmiabAAMAMKhaAdjB6GvTdZ2tgIFOEICBrqXS6VAHG9n3FoO//b3v9XJMAADA 8z776U97vOfO0TfQjNOmYbAVMNAJAjDQtXQms8dG9m26isHhcPj6t7/d42EBAABv +9Vnn+m63vXd9kq/geYisgJbAQMdIAADXctks41nTsd1rTrPwKlU6sLlyz0fGAAA 8LLf//a33S1U7iD6tr6TrYCBThCAga5ls9lvPnE0BrMHEgAAA2xtdfXG73/f0bd2 Hn3bGu/lmIAhQwAGuvZKALZ1s9nvLt96/qOPCMAAAAyqjgLwztF399JZBGCgEwRg oDuJRGLHfXr7i8HirHb9299mE2AAAAaVpmm/+uyzkW0HDN1P+W5tnK2AgT0RgIHu JJLJcDi82zOn1xhsWtaHFy/aXRCDAQAYJK10+sXvfjeyqZRm39HXpmtaiQAM7IUA DHQnmUy2NgGWEYMDzVOdZZojI+L8GByNRGKJxImTJ0nFAAD4gp11nzx6VKlUxG3T NC3LGmna/K0ORV+7Kd0wSmwFDOyFAAx0J5VKBV/dBFhSDN7KbJ4mxekzHA5Ho9Ez 584FmC4GAMAlrUnd+3fv1qtVwzDEmVqczTdP8G7L0ehr/79hmkW2Agb2QgAGupNO p7c9sSmLwZtas5rEjWAwaAfj02++GSAYAwDgkFbQfXjvXq1W03XdNE3xaVCckbs5 xTfsmnsDvUZfm4jfbAUM7IkADHQnk8nscrZzKwZvw7LsGWNxeg6Fw5Fo9CwzxgAA 7OyVGd1azdB1+y3mkWCwddLtLqC2kxl9Wy3k2QoY2AsBGOhOZuseSFt4KAZvx540 Xr/GeHRUZONTZ84EyMYAgCHQSrmPHjyoV6taczp3/bS461nVy9G31Q4BGNgTARjo TicB2ObxGLy1cauZje3bjWwcDo9Go6fPng2QjQEAvvLNouX79+tti5YDzVIaXe1C 1Hvu3bnNHhvvYH9gAjCwJwIw0J3OA3BgzyeYJ2Pw9s1aVuti45Hmmmr7euMTp08H iMcAAOVaEffxo0e1alVEXMMwrGbKHWmuceq0oQ5SZS9URd9NTRGAgT0RgIEuJBIJ Efy6jZoOxmDHW+u05d2bbY/HwYZwKNSaPQ6QkAEAXWrl20BzFler1/WNtcqBXWZx uzJY0dcmHqUyWwEDuyIAA11obALc2gPJveDq2mxwry03xiuvJmTxMIZHR+26XAES MgAMmfZ8++DuXfFpYw+hVr51qu7UTgYx+toMtgIG9kIABrrQ2AR406oqYrBD1ueQ xX8j9uK1ZkgOh8++9Vbre8jJAOBx7clWuH/njr04eT3cNmtNrc/ftp9Kdqhp7DAH t97tpuWuG+/jOE3DKBKAgV0RgIEupNLpbUpEdp8G/RKD92jf6Ri8fXNtvVhta62b /7Kek0VQFsH4ZPOCZBtRGQActCnWfvXwofhKY03yq9O2gVa47RzRt+PWOmnKMs1C odBVn8CwIQADXUhnMjtvAexmDN67te4b7LRxCbPBeybhPW2NypvS8olTp1rfTFoG MIQ2ZdrHjx411iG3zdZa9pKcjYU5Dlxz205N7t2hI2e6czZUO9Sa+K0V8vluOweG CgEY6IIIwAFvB1c3J4T7bryL7pweh9lZubEPZHOcEWyuzVu/WLm5EtveKrmFzAzA Uzal2UBzk1t7htYOtOIFzmwuP7baFyFvvMxKSZ5bydhnqMu+HOjO2SnfvRrsobU8 ARjYFQEY6IIdgG2OR0Ev5+ru2lc2Jyynr056t1qVvezYLMaUdtWWjanm9eQcCp0k OQPo2NYc+5XIsSLBbuTY9rUt60UTArsuPJa39Ldz5F61DRKAgd0RgIEutAdgGzFY XuPddaokCe/Ye+eHsZGZ7Rv2+LVV+sseyDbrZAfF/4XD4VAweKLt2mYbKRrwoK3Z VXj88KHezK6Wue6bFwHbxtM/4NTWPgFvhN6dD0Nx7nWgR49P+W5pkAAM7I4ADHRh awBucXZGVHUM7r7N7roYxCS84wF8888Sj6Q9QrcPfOwl3Os7iGxMR69vPRUMntrY mXkTEjWG0LZ51fbowYP16dZmZLXarL9ptaEVXFsfXeOR0BtQeHHvDn051uleubeX LiRHXxsBGNgdARjoVDyRCIfDu3+Pl2Pw3g321GZ3XahMwtK66+4Y1v/Z6y+26zl6 I063Pl0/8ler4NjXSK+n6+b/hUIiXwfbS4ttQsZGV3ZJp4FmuSaRS+1pVWsjodrX uAbaNx5vT6qB9afhNzdeDaxKI6JTvB165R6DvKXOuzbeey9Koq9N0/VKudxDk8CQ 8PqYDPCORCIR2isA2xy/PtZ3E8J79CItDXohCe92GOv/7NcX3n6O29o0V936pO1G 65HZ+L+2Ij0jr2gFb/FhU32yXRDCO7R7+Nzk0YMHjazZDKFbJ0u/eT/Fjqatu238 urfmUltHi4E7SCk73rXne7rL8bW4ffJS7nWmX+9f6LtXm+LfDF0vE4CBnfl1HAao J0bPoWCw8/Ti8Ri8d4M9tdldF4OehANKHmR39f0nourH33Th5cYXA60B6A4JrWVk 42pt2Ufar+ZBbvOTtr+/sOW9hvbvbV2QKvlAO9ZH0A34N+u2885M73qXQ5d7e+nF jehrMw2j1PF7WMAQ8szpDfC8ZCoVtEeEjmTgbtqR2qb7E8JOtN91v24M7gc+DNuc +RkG4qFAd/oLuutt9N+EF3htpne914HLvXt10WMvMg67mzYt0ywWi731AwwDRhhA p1Kp1CtL8ojB3XMxAbqyJHvHDjv6poF6fXbshxmsh2VIORF0AwOTdVtkTEI6wmO5 15muJT3abkff/7+9e1lOIwfAMKpUVrYn7/+gSWY1qYwTMNcG972l/s9ZJMSFJQFV 0F/UwMdv/P7x/fu42SCBIwno69u3bx0/rTmDhw+7Wpht+C7Zqkq4RMbwyfy3aqd3 VHtmStzzePMOV4/WorcsvZ4KtnxHTlRH+p5890HQ8JhjBeirO4APhhx2r/3e4FHD KuHl5n02ba8r7f95e9lbGHAHLmvuuL0ae7mh61Ft9JZKu3ee2bfo3pFjfjZsnzEF MDzhOAB6eXl5OXwE9CzV1MRucK8xRw07ZqKwEi5iuMvqp6on3b1LZm3HbGtOVoOa o7fsunt7zDJyolrT9+A/34QEjyW9usMEL6+vX79+Pf1TBk8fdsxcCwdJnSVcxHAP ld74dR6Uddu1v0qXtZrKo7ds171Pp55z9sj0PYzz69cv34QEj1R6zAAVem/gL4ev Qrn8etJHdpfBvYYdO/LgiVJLuIjhUdwdC0lP3Hv1R2+pt3tnW0C//xLaW/qev4D7 z0Xbv/CEowIY7+Xl5RDD5zC+ucamGfz5sKNG7n2T9lDCn6yhgs5c8+GIEnh/bR9m zVkutGa3YfQ+nX3ONTTXvZ+N/PgxO4fu4cvN5S4MEvgSD8t6r+JTDB/reK6PyCoN bgiPHXzwXKsEXuUxXAY9p9exYC4dHpIqeol7vU81r+UR3DZ6ny5gzmUs+t8QW2z5 3gx73tnVujATB0CwhqFV3NCGcK9hJww+ZrrNY3itNfQx8Iuwalk2bGnI26pryd2y 1htrJ6xh5mUsd8L5Flu+v7UurMWxDmzp9fX1SRW3lcG9Rp4w+ObTPZukgjX0J4nh SqO5e1BD9H62jNJK9/YYfJaRb1rXp1XByhzZQHX+VPFFEn+5f2vxjcpKeP13pdZT wqW1GC4jXgbquwkwwMAPza6ueEsz0VtW797xMy52qvPv6/fral2ogeMYaMPNZ1Af L1+qb9s2vIRLgzF8MOrBrvS2EG34F0TVmLsHlURvyere/iOfT13+KF4nMEO1HLJA 205hfG7jyjaEe408bfyRk67bbLWtZ5CxD3y9t4i9GfVlyPXmbln3pOI+9tS9Pcb/ 5BOYbepCyxydwD6dzqM+VXHPMF50E7XSEp57xs9n+/waDTw5j19iC7eOSo0K3VJ5 656ER2+/GSdN2vsWXe3o/v230IXdcBQCcY6fvHX59cVdQbL9hvCEKcbPu3qb7SOG D6YutJ1byuLGhm5ppXVPaoveUm/3Tpq3a4qbvdz3C//+/Dl6BqAVjjaAs/c2vvy6 pl4fwVV2WsJzT9prwl5Xaux5e46vgW7sJjPAhNA9DjDLMta0fl72sfTW64RJJ817 d8ayygUcVQC9XH5j082FowmVooQ75ux1pVafw2d9FFu9E1JMTtzzSHMNtL4Kt3mP E7ffvXd9e/iJM5aBRxw3ADM45fF503j4J3JtlcEDpt6otSpf3ozmvwHt3ycNmC9x j+PNO9wmNgnL/rZa3qj0vXkvrsQFJnJkAKzh9e3tWMWXf35cuLnyhiU8YPbtymrf m8OdFr8x+7q7ZjN32d4Ov+jo66vz3Obz3Ns1+eOpfz/qWycqA4vxkg/U4nkkr/+d uvWXcGlkkYva9N5v515dOGWfzbzVxCuofJv3OP1mm70dZyYXcQtsr50Xb4C/uju5 PNtSnqiVyGxlnWsKuqnb2XPi3ljhQ5vmslj3noL2vmzf//ipbIHqOTYAdusmlcvf p7zzZ3cNfIvywbanZw/V1morEX5HbF9u9Wgod8uk1XZu0spaYK/CX+gBzt7e3v78 dRnMNxvM5SoUW8zLFte8SyPu3Coqa8fayt2DuzU/ithTyh4uCFogmeMbgEn+ZPPH 9vL5vcqdZ2iffqemthy2lJpWDiMNeUf0Jrl77tbLgi1SFmAGDmUANnMTz90Xbup6 lQQdfmq4VxPqM/Cjv+Zp3Y9YvUrXm4ItIhZgMw5ZAJr39s8/5fIJ/WIjuvSo6z7G vFqoYlYz/GOuz7/QuctaumL1+vLPHz9GrhaA7Tg6AaDDfVQf/774Z9/MvhlaGNPP 59undz8s16VaxCoA1xyFALClR6VdrgO78yeParx0dTiD3ZdnuY7P8nB3tPvKRZcC sDHHBABwdhvkZZF+XuLVt+Mk4Mtu/fun4AQgnAAGAAAgggAGAAAgggAGAAAgggAG AAAgggAGAAAgggAGAAAgggAGAAAgggAGAAAgggAGAAAgggAGAAAgggAGAAAgggAG AAAgggAGAAAgggAGAAAgggAGAAAgggAGAAAgggAGAAAgggAGAAAgggAGAAAgggAG AAAgggAGAAAgggAGAAAgggAGAAAgggAGAAAgggAGAAAgggAGAAAgggAGAAAgggAG AAAgggAGAAAgggAGAAAgggAGAAAgggAGAAAgggAGAAAgggAGAAAgggAGAAAgggAG AAAgggAGAAAgggAGAAAgggAGAAAgggAGAAAgggAGAAAgggAGAAAgggAGAAAgggAG AAAgggAGAAAgggAGAAAgggAGAAAgggAGAAAgggAGAAAgggAGAAAgggAGAAAgggAG AAAgggAGAAAgggAGAAAgggAGAAAgggAGAAAgggAGAAAgggAGAAAgggAGAAAgggAG AAAgggAGAAAgggAGAAAgggAGAAAgggAGAAAgggAGAAAgggAGAAAgggAGAAAgggAG AAAgggAGAAAgggAGAAAgggAGAAAgggAGAAAgggAGAAAgggAGAAAgggAGAAAgggAG AAAgggAGAAAgggAGAAAgggAGAAAgggAGAAAgggAGAAAgggAGAAAgggAGAAAgggAG AAAgggAGAAAgggAGAAAgggAGAAAgggAGAAAgggAGAAAgggAGAAAgggAGAAAgggAG AAAgggAGAAAgggAGAAAgggAGAAAgggAGAAAgggAGAAAgggAGAAAgggAGAAAgggAG AAAgggAGAAAgggAGAAAgggAGAAAgggAGAAAgggAGAAAgggAGAAAgggAGAAAgggAG AAAgggAGAAAgggAGAAAgggAGAAAgggAGAAAgggAGAAAgggAGAAAgggAGAAAgggAG AAAgggAGAAAgggAGAAAgggAGAAAgggAGAAAgggAGAAAgggAGAAAgggAGAAAgggAG AAAgggAGAAAgggAGAAAgggAGAAAgwv/T1VqQkYjt1AAAAABJRU5ErkJggg=="/></symbol><use xlink:href="#c" width="1280" height="1280"/></g></g></svg>')} +.is2d .rook.black {background-image:url('data:image/svg+xml;base64,<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="614.635" height="614.635" viewBox="0 0 460.977 460.977"><mask id="b"><use xlink:href="#a" width="1280" height="1280" transform="rotate(.193) scale(.36014)"/></mask><symbol id="a" viewBox="0 0 1280 1280"><image width="1280" height="1280" xlink:href="data:image/png;base64, iVBORw0KGgoAAAANSUhEUgAABQAAAAUACAAAAAA9j6ArAAAACXBIWXMAAA7EAAAO xAGVKw4bAAA+HUlEQVR4nO3dCXhV5Z3H8YiKyCqyiyK4IIpSXFoVrVXrUqxarda6 DLWoba1bpy6tj3bqNtXHvVO3Ota1jEuttG7VultFrBWRIiCbskNYAwkRUJMhrEm4 977vSc45//f//r+f55lnHHNGf+eG8/UmuTl3szIAMGoz6QEAIIUAAjCLAAIwiwAC MIsAAjCLAAIwiwACMIsAAjCLAAIwiwACMIsAAjCLAAIwiwACMIsAAjCLAAIwiwAC MIsAAjCLAAIwiwACMIsAAjCLAAIwiwACMIsAAjCLAAIwiwACMIsAAjCLAAIwiwAC MIsAAjCLAAIwiwACMIsAAjCLAAIwiwACMIsAAjCLAAIwiwACMIsAAjCLAAIwiwAC MIsAAjCLAAIwiwACMIsAAjCLAAIwiwACMIsAAjCLAAIwiwACMIsAAjCLAAIwiwAC MIsAAjCLAAIwiwACMIsAAjCLAAIwiwACMIsAAjCLAAIwiwACMIsAAjCLAAIwiwAC MIsAAjCLAAIwiwACMIsAAjCLAAIwiwACMIsAAjCLAAIwiwACMIsAAjCLAAIwiwAC MIsAAjCLAAIwiwACMIsAAjCLAAIwiwACMIsAAjCLAAIwiwACMIsAAjCLAAIwiwAC MIsAAjCLAAIwiwACMIsAAjCLAAIwiwACMIsAAjCLAAIwiwACMIsAAjCLAAIwiwAC MIsAAjCLAAIwiwACMIsAAjCLAAIwiwACMIsAAjCLAAIwiwACMIsAAjCLAAIwiwAC MIsAAjCLAAIwiwACMIsAAjCLAAIwiwACMIsAAjCLAAIwiwACMIsAAjCLAAIwiwAC MIsAAjCLAAIwiwACMIsAAjCLAAIwiwACMIsAAjCLAAIwiwACMIsAAjCLAAIwiwAC MIsAAjCLAAIwiwACMIsAAjCLAAIwiwACMIsAAjCLAAIwiwACMIsAAjCLAAIwiwAC MIsAAjCLAAIwiwACMIsAAjCLAAIwiwACMIsAAjCLAAIwiwACMIsAAjCLAAIwiwAC MIsAAjCLAAIwiwACMIsAAjCLAAIwiwACMIsAAjCLAAIwiwACMIsAAjCLAAIwiwAC MIsAAjCLACIvm7dutUXbLVoV+eiKL6q+WFH9Za6LYB4BRCY69+zerXOnju3atj58 i8T/zzUfVldXV1UuWbSwfN7shRmsA9YigEhN55127Nm9a8djkxevtJoxSyuWzJ83 e/onxBDpIoBonhbb9+29Q4+u38npX/fxooXz586cNmlWTU7/QkSNAKJJWu+2W5+e 3U7cXGxA7fhF88tnfzpxYrXYBOhHAJFEm/59+2zf4zjpGQ1MWbhg7qxPJ41bLj0E +hBAeGi9W7+dtu+R15e5TTVlwfy5sz75mOeE8EYA4fTd+7eRnpBIxdnDpSdACQII p1rpAUmd8aj0AihBAOGkLoD7jZJeACUIIJzUBbAN3wWEHwIIJ3UB5E81PPFHBU7a AljbQnoBtCCAcNIWwGUdpBdACwIIJ20BXNhFegG0IIBw0hbAudtJL4AWBBBO2gI4 Y0fpBdCCAMJJWwCn7Cq9AFoQQDhpC+DHu0svgBYEEE4Vyn6qOnaA9AJoQQDhpuwp 4JiB0gugBQGEm7IAjtpPegG0IIBwI4CIFAGEGwFEpAgg3AggIkUA4UYAESkCCDcC iEgRQLgRQESKAMKNACJSBBBuBBCRIoByOnTo0H6bdm3bbb3VVi3rbLl52RYtyso2 37ys7Msvy8pWlZV9/sWqVStXrf6fzyqrKpYuXVyxUmYpAfSy1TbbduiwTd0ndPVn c/X/bLFlWVnLjZ/Qmi/Kvvx8VZ2VdZ/QyoplS5culVmK9QhgfrbZYbtuXTt3bNe2 7WHN+KfUjK9eXr28csniBQtmzy6vSW1dKQSwkBbdevbs0mXbju3atD5k82b8c8Yt X15VVblk4fzyOTMrUlsHLwQwUy167NirR7euHY9rzgVS2oSKpUsWLSyfO2P64sz+ HcoC+P5XM/tHb1v3+ezcqeO3Mvs31HxUsXjJ/LrP59x8/utmGwHMQKtddt5h+25d vp37v3jCkiULF8yd+cmkynT/ucoCOHJQuv+8dn132qFHl875fz4nLVq8oHzWzKlT VuT+r7aCAKan++479erZ9TjpGWvUjFn9rHDOp5MmpnLpmAxgq9369tmu28lbpPHP arYpCxfMnz3jkwnzpIfEhgA2W+f+u/Te/j/CuE4KmLxw9ZOIGZM+bs4XyJYCuG2/ vr2273Z8amNSVvPh/Hmzpk0Zt1B6SCQIYFNt1XePnXttF8bzPS+rL53VTyKmjJub /P/VQAB79N9l9dP37L61l7pPF5TPmTF1/CShFwbEggAmtc1e/Xbe4XTpFc2xuoRz Z0+bNM7/OWG8Ady2f9/ePXso6t6mxpXPmzn147H8/LhJCKCvnnvt1qfnydIrUjVt /oI5sz55udx5YHwB7HbkTttvl/9PNbI0uXze7E8njp0tvUMXAujW6bqewX5LKAW/ vs55SHwBVHZGScycO2/2fy2SXqEFAXSL+GKpM2SY8xBlj4DtANbZZ7T0Ai0IoFvk F8sJTzsPUfYIEMBD3pJeoAUBdIv8YjnyFechyh4BAkgAfRFANy4WZY8AASSAvgig GxeLskeAABJAXwTQjYtF2SNAAAmgLwLoxsWi7BEggATQFwF042JR9ggQQALoiwC6 cbEoewQI4NEvSS/QggC6RX6xEMD4DH5ReoEWBNAt8ovloHechyh7BAggAfRFAN0i v1g8fm1K2SNAAAmgLwLoFvnFQgDjQwB9EUC3yC8WAhgfAuiLALpFfrEQwPgQQF8E 0C3yi2WPCc5DlD0CBJAA+iKAbpFfLLtNch6i7BEggATQFwF0i/xi6TPNeYiyR+Cf BzgPUXZGSRFAXwTQLfKLZTv328QpewRG7ec8RNkZJUUAfRFAt8gvlh7uN9tW9ggQ QALoiwC6RX6xtK90HqLsESCABNAXAXSL/GIhgPEhgL4IoFvkF8sWXzoPUfYIEEAC 6IsAukV+sXj8EVD2CBBAAuiLALpFfrEQwPgQQF8E0C3yi4UAxocA+iKAbnFfLNVt nIdUdMhhR4rGDHQeEvfnlAB6I4BucV8sS7dxH9I+hx0pGjvAeUjcn1MC6I0AusV9 sSzu5DyEAGpDAH0RQLe4L5by7s5DCKA2Jw2XXqAFAXSL+2KZvb3zEAKozclPSS/Q ggC6xX2xTOvjPIQAakMAfRFAt7gvlsl9nYdoewA+3t15iLZTSogA+iKAbnFfLOP7 Ow/R9gAQQALoiwC6xX2xfLi38xBtD4BHALW9tDEhAuiLALppu/6T+dfXnIdoewA8 AqjunJL53p+lF2hBAN3ivlZGHOw8RNsDMLGf+xht55TMkGHSC7QggG5xXyuvH+48 RNsD8MnO7mO0nVMyBNAXAXSL+1p5cbDzEG0PAAEkgL4IoFvc18rTJzgP0fYAEEAC 6IsAusV9rfzp+85DtD0A03u7j9F2TskQQF8E0C3ua+XhHzoP0fYAzOzlPkbbOSVD AH0RQLe4r5V7znMeou0BIIAE0BcBdIv7Wrn1Uuch2h4AAkgAfRFAt7ivlWuvch6i 7QGY18N9jLZzSoYA+iKAbnFfK7+8yXmItgfA4xaH6s4pGQLoiwC6xX2tnH+38xBt D8DCLu5jtJ1TMgTQFwF0i/taOeNR5yHaHoAl27qP0XZOyRBAXwTQLe5r5bjnnIdo ewAqOrqP0XZOyRBAXwTQLe5r5aB3nIdoewCq2rmP0XZOyfzoD9ILtCCAbnFfK/3H Ow/R9gB4vNWxunNK5tx7pRdoQQDd4r5Wupc7D1H3AHj8qVZ3TokQQF8E0C3ua2WL L52HqHsACCAB9EQA3aK+VmpbeByT/Yx0EUAC6IkAukV9rUT5E9NWK52HqDunRAig LwLoFvW1Mqen+xh1D0DHCuch6s4pEY9Xt2MNAugW9bUyZVf3MeoegO3mOg9Rd06J /Py30gu0IIBuUV8rYwa6j1H3AOw2yXlI3O+LSQB9EUA3ddd/EiMHuY9R9wAMHOM+ Rt1JJUEAfRFAt6gvlVePcB+j7gE48F33MepOKgkC6IsAukV9qTzzHfcx6h6Aw95w H6PupJIggL4IoFvUl8qjZ7iPUfcADH7RfYy6k0ri4tulF2hBAN2ivlQ83hJE3wNw 8lPuY9SdVBJX3CC9QAsC6Bb1pXLj5e5j1D0AZz7iPkbdSSVBAH0RQLeoLxWPO+Lr ewB8Xges7qSSIIC+CKBb1JeKz53j1D0Al93iPkbdSSVBAH0RQLeoL5WThruPUfcA XHWt+xh1J5WEx1v9YQ0C6Bb1pXLwCPcx6h6AKL+xmQQB9EUA3aK+VDx+a0zfA3DH Re5j1J1UEgTQFwF0i/pSaV/pPkbdA3Dfj93HqDupJAigLwLoFvWl4vMHQN0DMGyI +xh1J5XEzb+QXqAFAXSL+VLxuR+qvgfgz99zH6PupJIggL4IoFvMl8qsHTwOUvcA vDjYfYy6k0qCAPoigG4xXyoT+3kcpO4B+Mc33MeoO6kkbrlMeoEWBNAt5kvlg309 DlL3AIzaz31M1HdE/d3PpBdoQQDd1F3/CcT5XGnCHh4H6TstfwTQFwF0i/lKeeEY 9zH6zn96b4+D9J2WPwLoiwC6xXyl/On77mP0nf+Crh4H6Tstf3ddIL1ACwLoFvOV 8uBZ7mP0nX91G4+D9J2Wv//9ifQCLQigW8xXis9TBYXnv8WX7mMUnpY3AuiLALrF fKVEetuA7uXuYxSeljef3wVEHQLoFvOV8l//7T5G4fnvM9p9jMLT8vbwD6UXaEEA 3WK+Ui66w32MwvM/7jn3MQpPyxsB9EUA3WK+UoY+5D5G4fmfe6/7GIWn5c3nbhCo QwDdYr5STn/MfYzC84/0K3tvj58mvUALAugW85US6RtI/s9/uo9ReFreCKAvAugW 85US6VuIW78h4F++K71ACwLoFvOVctgb7mMUnv/zx7qPUXha3gigLwLoFvOVcuC7 7mMUnv/bX3cfo/C0vPn8BwB1CKBbzFeKxwvmlrbPYUfKxg5wHxPzp5UA+iKAbjFf KR4B1Hj6c3q6j9F4Xr5ePkp6gRYE0C3mKyXSANa28Dgm+xliCKAvAugW85USaQDL ui5wHqLyvDy9eaj0Ai0IoFvMV0qsATzkLechKs/Lk8+NvlGHALrFfKXEGkCPX/FT eV6eRg6SXqAFAXSL+UoZNNJ5iMrTv+pa5yEqz8vTe/tLL9CCALrFfKUc/ZLzEJWn 73FHUJXn5cnnbfFQhwC6xXylePwusMrTf/oE5yEqz8uTz+sgUYcAusV8pcT6vbJ3 DnIeovK8PI3bU3qBFgTQLeYr5fy7XUfoPPvpvZ2H6DwxPxP7SS/QggC6xXylXHaL 6widZ+/xSmidJ+bnk52lF2hBAN1ivlJu/oXrCKVnv8tU1xFKT8zL9N7SC7QggG4x Xyn3n+M6QunZf+/PriOUnpiX2dtLL9CCALrFfKW4bxyn9Ox/fZ3rCKUn5qW8u/QC LQigW8xXyuuHu45QevYPDXUdofTEvCzuJL1ACwLoFvOV8sG+riOUnv2rRzgOqOiQ yw4ZVe2kF2hBAN2UJsDLrB0cB2g9+Ql7OA74rFUuO2T43A4MdQigm9YG+HBeKVpP vtJ1H2utJ+aH69oTD5Rb1JfKdnNLf1ztye82qfTH1Z6YF65rTzxQTlutkF6QpeOf Lf1xtZ045/7SH1d7Yl5arZReoAQBdGq3THpBln71m9IfV9uJOy8s/XG1J+alfaX0 AiUIoFOPOdILsuR6C3G1nXC9LYbaE/Pi+s4G1iGATjvMkF6QpX8eUPLDejMxrU/p j+s9Mx+9ZkovUIIAOvWdKL0gS4s6l/yw4ky0/LzURxWfmA/Xj4CwDgF02nOs9IJM lb5rgOJOHPROqY8qPjEfe30kvUAJAui09wfSCzJ14Z2lPqq4E6Xv9KX4xHx4vNkV 6hBAp8gD+NjppT6quBOPn1bqo4pPzAcB9EQAnSIP4NRdSnxwmeLfKR3fv8QHq9rk tkMEAfREAJ3i/iFI6VdMaH6eVLvllyU+mN8OEfwQxBMBdOo1XXpBtn55U/GPqe7E YW8U/5jqE/OwY9Sv3UoRAXSK+4XQZWWvHFn8Y6o7ce1VxT+m+sQ88EJoTwTQqfVy 6QXZWt6p+O+Nqu7Es8cX/ZDq8/LRplp6gRIE0C32q+WCu4p9RPeZf7pT0Q/pPjEP XNeeeKDcYr9aiv82nPIzL35HAOUn5rS8rfQCLQigW+xXS/FfBlF+5kOGFfmA8vNy m9dDeoEWBNAt+svlvh8X+YDyM3/wrCIfUH5ebhP7SS/QggC6RX+5VPQofM/XSuVf SBV7KXT0n1DXPX6wAQF0i/96ueGKgn9b/YkX+Vmo+vNyev5Y6QVaEEC3+K+XRb0K lkL9iZ/6RKG/q/603O4+X3qBFgTQzcAF84cfFfq76k+88Dc31Z+W28W3Sy/QggC6 Gbhgancv8AvPmu+EsNa/v1Lgbxr4dJYd8pb0Ai0IoJuFK+bdAzf9e/rPu7b1pj/d 0f6THR/V7WqkJ2hBAN0qOkgvyEGBWyLoD2DZaY9v8rciOCunMQOlF6hBAD1YuGaq 9p7S+G9FcNqPnNn470RwUm5//IH0AjUIoAcTF83UAY1+EhzDWU/ZtdHfiOGk3E55 UnqBGgTQg42r5t2DGn7jKIqzbnRbqNhvBL1WVccvpCeoQQB9RNECp0avno3ipBu9 HiSKc3J69QjpBXoQQB82rpuyZ75T//+K4qQbRj2KU3IrehMIbIIA+jBy4ZS9fvTG NxOP45zLu2/8a/2va/Qzb7s4Pne5IIBerPyJGvPNRev/MpJT3v+99X+1sqXkjhzd eaH0AkUIoJdIauBWPvSFdX8VySn/z3+u+4tIzsetYocq6QmKEEA/Zi6fsj+eteZH iLH8vPSjvdb8ry0+dxwXj9svll6gCQH0YyeAZZ9c/HRZRCfcdUFZRGfjVt678M0d URAB9GToEip7/aKP4jnfS28t23Os9Igc8SPgRAigr2iK4OO5SwrcHUanN34Szan4 eOlo6QW6EEBfpgIIpebsvkx6gi4E0BsFROiq9h8vPUEZAuiPAiJwQx+SXqANAUyA AiJo11wtvUAdApgEBUTA6F9yBDARCohgXXm99AKFCGAyFBBhWnzmc9ITNCKACZn5 lXqoMvGoGdITVCKASRn6rVKoMWwoN4FuEgKYHF8GIyzTf/a09AStCGATbLlKegGw 0QPn8lVJUxHAJtljnPQCYK03zue3P5qOADbRZ62kFwBlZaOveFF6gmoEsMlWbCW9 ANb9+5rh0hOUI4DN8K0X3McAWXnnOp79NRcBbJa9P5BeAKOqnr9xtPSGCBDAZmpb Kb0ABn3y+A289VEaCGDz8ZUwclX16u/52jclBDANrZbwM2Hk5INH7+Jtj1JDANOx tL30AtgwZqD0gqgQwHQs2UZ6AWwYOUh6QVQIYDoWd5ReABsIYKoIYDoIIPJBAFNF ANNBAJEPApgqApgOAoh8EMBUEcB0EEDkgwCmigCmhLukIhcEMFUEMCUEELkggKki gCkhgMjF21+XXhAVApgSAohcvHmo9IKoEMCUEEDk4tUjpBdEhQCmhAAiFy8fJb0g KgQwJQQQufjbt6UXRIUApoQAIhfPHyu9ICoEMCUEELn4y3elF0SFAKaEACIXw0+S XhAVApgSAohcPH6a9IKoEMCUEEDk4tEzpBdEhQCmhAAiFw//UHpBVAhgSgggcnH/ OdILokIAU0IAkYu7LpBeEBUCmBICiFzc/AvpBVEhgCkhgMjF1ddIL4gKAUwJAUQu LrtFekFUCGBKCCBycd490guiQgBTQgCRiyHDpBdEhQCmhAAiFyc8Lb0gKgQwJQQQ uTj8dekFUSGAKSGAyMV+o6QXRIUApoQAIhe7TJVeEBUCmBICiFx0WSi9ICoEMCUE ELnYvEZ6QVQIYEoIIPJQ1U56QVwIYEoIIPIwr4f0grgQwJQQQOTh052kF8SFAKZk aXvpBbDgo72kF8SFAKaFp4DIwT8PkF4QFwKYFgKIHLz2TekFcSGAaSGAyMEz35Fe EBcCmBYCiBwMGyK9IC4EMC0EEDm45zzpBXEhgGkhgMjBjZdLL4gLAUwLAUQOLrlN ekFcCGBaCCBywA2h00UA00IAkYMjX5FeEBcCmBYCiBzsMUF6QVwIYFoIIHLQdrn0 grgQwLQQQGSvtoX0gsgQwLQQQGRvYRfpBZEhgGkhgMje1F2kF0SGAKalooP0AsRv 9D7SCyJDAFPDU0Bk7h/fkF4QGQKYGgKIzHEzmJQRwNQQQGTuoaHSCyJDAFNDAJG5 Wy+VXhAZApgaAojMXX6j9ILIEMDUEEBkbuhD0gsiQwBTQwCRuaNfkl4QGQKYGgKI zPWbKL0gMgQwNQQQmWtTLb0gMgQwNQQQWeNeCGkjgKkhgMjcIW9JL4gMAUwNAUTm +BI4ZQQwNQQQWZu7nfSC2BDA9FBAZGzkIOkFsSGA6SGAyNjjp0kviA0BTA8BRMau vUp6QWwIYHoIIDJ20nDpBbEhgOkhgMhY1wXSC2JDANNDAJGtBV2lF0SHAKaIAiJT 7+0vvSA6BDBFBBCZeuJU6QXRIYApIoDI1FXXSi+IDgFMEQFEprgbYOoIYIoIIDLF bwKnjgCmiAAiS9N7Sy+IDwFMEwVEhl4+SnpBfAhgmgggMvS7n0kviA8BTBMBRIbO eFR6QXwIYJoIIDLUabH0gvgQwDQRQGRnWh/pBREigKmigMjMs8dLL4gQAUwVAURm +D2QDBDAVBFAZGbQSOkFESKAqSKAyErFtvzpSh8BTBd/RpGRNw6TXhAjApguAoiM XH+l9IIYEcB0EUBkZL9R0gtiRADTRQCRDW6HnwkCmDIKiEy8OFh6QZQIYMoIIDJx 6a3SC6JEAFNGAJEJfhE4EwQwbRQQGfhgX+kFcSKAaSOAyMB1v5ZeECcCmDYCiAz0 mSa9IE4EMG1L20svQHw+3l16QaQIYOp4CojU3Xi59IJIEcDUEUCkrsc86QWRIoDp o4BI2YiDpRfEigCmjwAiZUMfkl4QKwKYPgKIdC3oXiM9IVYEMAMUEKl6+IfSC6JF ADNAAJGq/uOlF0SLAGaBAiJF7xwkvSBeBDALBBApOuFp6QXxIoBZqN5aegHiMb6/ 9IKIEcBM8BQQqTnzEekFESOAmSCASMuk3aQXxIwAZoMCIiW8CDpLBDAby1tLL0Ac xg6QXhA1ApgRngIiFcc9J70gagQwKxQQKXjrEOkFcSOAWSGAaL7afpOkJ8SNAGaG AqLZHjhbekHkCGBmCCCaa/qun0tPiBwBzA4FRDMd+7z0gtgRwAxRQDTL0ydIL4ge AcwQAURzTO+3QnpC9AhgliggmuGwN6QXxI8AZooCosnuuEh6gQEEMFsUEE309tel F1hAALNFANE0M/tXSk+wgABmjAKiKaoOGCc9wQQCmDUKiCYYMkx6gQ0EMHMUEInd eLn0AiMIYPYoIBIaNkR6gRUEMAcUEInwGyC5IYA52KxGegE0eflo/pOZFwKYhxZf Si+AHi8N5j+YuSGAueA5IHz97Vie/+WHAOaEP9Tw8tTJ0gtMIYB5oYDwcOeF0gts IYC5oYBwuuIG6QXGEMD8UECUtviHz0pPsIYA5ogCopRJh8+WnmAOAczTVtzhF0W9 dPxK6Qn2EMB88SQQRdx+sfQCiwhgvgggithvlPQCiwhgvgggiuAdQCQQwHwRQBRx 3HPSCywigPkigCjitMelF1hEAPNFAFHEj/4gvcAiApgvAogizr1XeoFFBDBfBBBF EEAJBDBfBBBFEEAJBDBfBBBFEEAJBDBfBBBF/Py30gssIoD5IoAoggBKIID5IoAo 4qI7pBdYRADzRQBRxDn3Sy+wiADmiwCiCH4TRAIBzBcBRBH8LrAEApgvAogiuBuM BAKYLwKIIrgfoAQCmC8CiCJ2myS9wCICmC8CiCK6LpBeYBEBzBcBRBFcihJ41PNF AFFYRUfpBSYRwHwRQBQ2Y0fpBSYRwHxVdJBegDCNGSi9wCQCmDOeAqKg174pvcAk ApgzAoiCnjhVeoFJBDBnBBAF3X6x9AKTCGDOCCAKOv9u6QUmEcCcEUAUdPAI6QUm EcCcEUAU1Ha59AKTCGDOCCAKmd9NeoFNBDBvFBAFjBwkvcAmApg3AogChg2RXmAT AcwbAUQBV9wgvcAmApg3AogCBo2UXmATAcwbAcSmqtrz50IEAcwdf9KxiQ/2lV5g FAHMHQHEJh4aKr3AKAKYOwKITZz+mPQCowhg7gggGqttvUJ6glEEMH8UEI1wN1Qp BDB/BBCN3HaJ9AKrCGD+CCAa2We09AKrCGD+CCAamt5beoFZBFAABUQDvAhGDAEU QADRwEHvSC8wiwAKIICob+ou0gvsIoASKCDqufVS6QV2EUAJBBD19JopvcAuAiiC AmKDNw6TXmAYARRBALHBMS9ILzCMAIoggFhvcl/pBZYRQBkUEOtccJf0AssIoAwC iLWm9+HPgiACKIQ/9VjjktukF5hGAIUQQNSZvlON9ATTCKAUCojVhj4kvcA2Aiil qo30AsjjzZCEEUAxPAVE2aFvSi8wjgDKoYDmPXWy9ALrCKAcAmjd3F2qpSdYRwAF UUDjhgyTXmAeAZREAU3727elF4AASiKAls3YjTcDFkcARVFAw/gJcAAIoCwKaBb3 gQ4BARRGAY16cbD0ApQRQHHVW0svgIRxe38uPQFlBFAeTwEtmjdggfQE1CGA4iig PUv2nyw9AWsQQHkU0Jrlh74vPQFrEcAAUEBjTnlSegHWIYAhoICW1A59WHoC1iOA QaCAdlSf+WfpCdiAAIaBAlpRNfht6QnYiAAGggLaMO+IcdITUA8BDMXKltILkL2J 3yiXnoD6CGAwWn0mvQBZe+sobgATFgIYEL4MjtwdF0kvQCMEMCQUMGYLzn5WegIa I4BBqWwrvQBZ+eexC6UnYBMEMDA8CYzT8ht+Iz0BBRDA0HzWSnoB0jf2uOnSE1AI AQzOZjXSC5CyZbdexzP7MBHAAHXmXnFRefl0vvsXKgIYJJ4vxGPy5cOlJ6AoAhgm vg6OxLxbbuO/ZgEjgKFquVJ6AZqt4v4rVklvQCkEMFxtqqQXoFkW//HK5dIbUBoB DFlrrh+9Fj54dbX0BrgQwLBtyVdQOk2573be91IBAhi8E/4ivQBJvXPzX6UnwAsB VKDvROkFSGDe07dNkt4ATwRQhc3O+KP0BPgZ8fv/43UvehBALbrN4JbRwRs7/B7u +KwKAVRkV76yCtnk5+6ZLL0BCRFAXfh2YKAW3/cA/3lSiAAqwy1TwzR6H+kFaAoC qAzfYA/TjB2lF6ApCKAyBDBM1W2kF6ApCKAyBDBQnRZLL0ATEEBlCGCgBo2UXoAm IIDKEMBADRkmvQBNQACVIYCB+hXv+qYRAVSGAAbq7vOlF6AJCKAyBDBQw0+SXoAm IIDKEMBA/eMb0gvQBARQF/oXqvH9pRegCQigLgQwVAu6Si9AExBAXQhgsDbnnUwV IoC6EMBg9ZkmvQDJEUBdCGCwjn5JegGSI4C6EMBgnX+39AIkRwB1IYDBuvFy6QVI jgDqQgCDNWyI9AIkRwB1IYDBevko6QVIjgCqUtFBegGK4ab4GhFAVXgCGK45PaUX IDkCqAoBDFdtC+kFSI4AqkIAA7b9bOkFSIwAqkIAA/bN16QXIDECqAoBDNi590ov QGIEUBUCGLDrr5RegMQIoCoEMGCPnCm9AIkRQFUIYMBeHCy9AIkRQE2WbCO9AMV9 sK/0AiRGADXhCWDIZm8vvQCJEUBNCGDIeCW0QgRQEwIYtO7l0guQFAHUhAAG7bA3 pBcgKQKoCQEM2jn3Sy9AUgRQEwIYNF4JrQ8B1IQABo1XQutDADUhgEHjntD6EEBF uB902MYMlF6ApAigIjwBDFt5d+kFSIoAKkIAA7fFl9ILkBABVIQABm63SdILkBAB VIQABu7Ev0ovQEIEUBECGLhf3iS9AAkRQEUIYODuukB6ARIigIoQwMD99UTpBUiI ACpCAAM3cpD0AiREAPWgf6Gbsqv0AiREAPUggKGrbC+9AAkRQD0IYPA6LZZegGQI oB4EMHiHvim9AMkQQD0IYPB+fJ/0AiRDAPUggMG74QrpBUiGAOpBAIM3bIj0AiRD APUggMF75UjpBUiGAKqxlNdYBG/sAOkFSIYAqsETwPAt6iy9AMkQQDUIoAJbr5Be gEQIoBoEUIH935NegEQIoBoEUIGzH5BegEQIoBoEUAFeCKgMAVSDACrw6BnSC5AI AVSDACrwxmHSC5AIAdSC/mnw8e7SC5AIAdSCAGpQ0VF6ARIhgFoQQBU6VkgvQBIE UAsCqAJ3BNSFAGpBAFU47x7pBUiCAGpBAFW49VLpBUiCAGpBAFV48hTpBUiCAGpB AFUYcbD0AiRBAJWgfzrw1sC6EEAlCKAOVe2kFyAJAqgEAVSixzzpBUiAACpBAJUY /KL0AiRAAJUggEpcfLv0AiRAAJUggErcc570AiRAAJUggEo8f6z0AiRAAHWo6CC9 AH4+3Ft6ARIggDqsbCm9AH4WdJVegAQIoA58BaxGm2rpBfBHAHUggGocPEJ6AfwR QB0IoBrcEEsTAqgDAVTjf/5TegH8EUAdCKAafz1RegH8EUAdCKAa//qa9AL4I4Aq rNhKegF8zd1OegH8EUAVeAKoSMvPpRfAGwFUgQAqss9o6QXwRgBVIICKDH1IegG8 EUAVCKAiN14uvQDeCKAKBFCRP31fegG8EUAVCKAi7xwkvQDeCKAGy1tLL4C/mb2k F8AbAdSAJ4CqbF4jvQC+CKAGBFCVPSZIL4AvAqgBAVRlyDDpBfBFADUggKrwOhg9 CKAGBFCVp06WXgBfBFADAqjKe/tLL4AvAqgA94LRpby79AL4IoAK8ARQGd4XSQ0C qAABVObQN6UXwBMBVIAAKvPz30ovgCcCqAABVObec6UXwBMBVIAAKvP3b0kvgCcC GL5l7aQXIJnx/aUXwBMBDB9PALVZ1kF6ATwRwPARQHV6zZReAD8EMHwEUJ2Tn5Je AD8EMHwEUJ1rrpZeAD8EMHwEUJ1Hz5BeAD8EMHwEUJ0RB0svgB8CGLzqraUXIKlZ O0gvgB8CGDyeACrU8nPpBfBCAINHABXa/z3pBfBCAINHABW68E7pBfBCAINHABXi dghKEMDgEUCFXjlSegG8EMDQVbWRXoDkPt1JegG8EMDQ8QRQo9otaqQnwAcBDB0B VGmf0dIL4IMAho4AqnTePdIL4IMAho4AqnT3+dIL4IMAho4AqvTS0dIL4IMABq6y rfQCNMXUXaQXwAcBDBxPAHXix8A6EMDAEUClBoyVXgAPBDBwBFCpH98nvQAeCGDg CKBSd1wkvQAeCGDgCKBSLw6WXgAPBDBs/BBYqwl7SC+ABwIYNp4AalXNTSw0IIBh I4Bq7TFBegHcCGDYCKBaZz8gvQBuBDBsBFAtfgysAQEMGwFUi98G1oAABo3bQes1 rY/0ArgRwKDxBFAx3htYAQIYNAKo2CFvSS+AEwEMGgFU7Jc3SS+AEwEMGgFUbNgQ 6QVwIoBBI4CKvXug9AI4EcCQrWwpvQBNt6Cr9AI4EcCQ8QRQte7l0gvgQgBDRgBV O/UJ6QVwIYAhI4Cq3fwL6QVwIYAhI4CqPXu89AK4EMCALWsnvQDNMW5P6QVwIYAB 4wmgbtVt+QyGjgAGjMtHuX1GSy+AAwEMGAFU7sI7pRfAgQAGjAAqd/850gvgQAAD RgCV+8c3pBfAgQCG67NW0gvQPHN6Si+AAwEMF08A1eu0WHoBSiOA4SKA6p3ypPQC lEYAw0UA1bv1UukFKI0AhosAqvf3b0kvQGkEMFi8I5x+03tLL0BpBDBYPAGMQJtq 6QUoiQAGiwBG4JgXpBegJAIYLAIYgeuvlF6AkghgsAhgBJ75jvQClEQAQ1XZVnoB mm/KrtILUBIBDBVPAKPQ8nPpBSiFAIaKAEbh0DelF6AUAhgqAhiFX/1GegFKIYCh IoBRePIU6QUohQAGqqKD9AKkYcxA6QUohQAGiieAcVjejs9kyAhgoLhsIrHfKOkF KIEABooARuKS26QXoAQCGCgCGIlhQ6QXoAQCGCgCGIlR+0kvQAkEMEz0LxZV7flc BowAhomLJhoHviu9AMURwDARwGhceb30AhRHAMNEAKMx/CTpBSiOAAaJe2HFY3Jf 6QUojgAGiSeAEdl6hfQCFEUAg0QAI8L7ggSMAAaJAEbkxsulF6AoAhgkAhgR3h09 YAQwRNVbSy9Aemb2kl6AoghgiHgCGJUuC6UXoBgCGCICGJUhw6QXoBgCGCICGJV7 zpNegGIIYIgIYFTeOkR6AYohgAGif3FZ2EV6AYohgAEigJHpO1l6AYoggAEigJG5 4C7pBSiCAAaIAEbmjz+QXoAiCGCACGBkPthXegGKIIDhoX+xqW5XIz0BhRHA8BDA 6HzzNekFKIwAhocARocbwoSKAIaHAEbn5aOkF6AwAhgc+hefeT2kF6AwAhgcAhih nT6VXoCCCGBwCGCELrpDegEKIoDBIYAReuJU6QUoiACGZlk76QVI38R+0gtQEAEM DU8Ao9SmWnoBCiGAoSGAUTppuPQCFEIAQ0MAo3THRdILUAgBDA0BjNLbX5degEII YGDoX5yWbCu9AIUQwMAQwEjtM1p6AQoggIEhgJG68nrpBSiAAAaGAEbq6ROkF6AA AhiWqjbSC5CNaX2kF6AAAhgWngBGq8tC6QXYFAEMCwGM1tCHpBdgUwQwLAQwWo+c Kb0AmyKAQVnaXnoBsjK+v/QCbIoABoUngBHjfggBIoBBIYARO/UJ6QXYBAEMCgGM 2P/+RHoBNkEAg0IAI/b+V6UXYBMEMCT0L2bVHb6QnoDGCGBICGDUjn1eegEaI4Ah IYBR+93PpBegMQIYEgIYtZGDpBegMQIYEPoXt6oONdIT0AgBDAgBjNzgF6UXoBEC GBACGDm+CRgcAhgQAhg5vgkYHAIYDvoXO74JGBwCGA4CGL1jXpBegIYIYDgIYPTu vFB6ARoigOEggNF790DpBWiIAAaD/sWPXwcODQEMBgE04PhnpRegAQIYDAJowO9/ Kr0ADRDAYBBAA8YOkF6ABghgKOifCbwxSFgIYCgIoAmnPya9APURwFAQQBMeGiq9 APURwEAsaye9AHmY2E96AeojgIHgCaARHSukF6AeAhgIAmjEj/4gvQD1EMBAEEAj Hj9NegHqIYBhqGojvQD5mNZHegHqIYBh4AmgGTvOkF6AjQhgGAigGb+8SXoBNiKA YSCAZrxwjPQCbEQAg0D/7FjQVXoBNiKAQSCAhhz4rvQCbEAAg0AADbnlMukF2IAA BoEAGjLiYOkF2IAAhoD+WcJ98QNCAENAAE05+SnpBViPAIaAAJry8A+lF2A9AhiA yrbSC5CnKbtKL8B6BDAAPAE0ptdM6QVYhwAGgAAac/mN0guwDgEMAAE05uWjpBdg HQIoj/5Zs6QTn/NAEEB5XAzmfOvv0guwFgGURwDN+f1PpRdgLQIobml76QXI2/j+ 0guwFgEUxxNAg7oslF6ANQigOAJo0EV3SC/AGgRQHAE06NnjpRdgDQIojf5ZNL+b 9AKsQQClEUCTBo2UXoA6BFAaATTp9oulF6AOAZRGAE36cG/pBahDAIXRP6PaV0ov QBkBFEcAjTrnfukFKCOA4gigUU+eIr0AZQRQGv2zak5P6QUoI4DSCKBZX31fegEI oDQCaBYvhAkBAZRFAM0aO0B6AQigMPpnGHeECQABFEUADfv5b6UXgADKIoCGvThY egEIoCj6Z1nFtnz+xRFASVwAph33nPQCEEBJBNC0B8+SXgACKKiqjfQCSPpkZ+kF IICCeAJoXN/J0gvMI4CCCKBx1/1aeoF5BFAQATTuX1+TXmAeAZRD/6yrbVstPcE6 AiiHAJp39gPSC6wjgHIIoHnDT5JeYB0BFEP/MK+H9ALrCKAYAoiyg0dILzCOAIoh gCi780LpBcYRQCnL2kkvgLyJ/aQXGEcApfAEEKvtOEN6gW0EUAoBxGpXXyO9wDYC KIUAooxfBpFGAIXQP9Sp7VApPcE0AiiEAGKN8+6RXmAaARRCALHG374tvcA0AiiD /mGtik410hMsI4AyCCDWOWm49ALLCKAMAoh1Hj1DeoFlBFAE/cN6s3aQXmAZARRB ALHB/u9JLzCMAIoggNjgjoukFxhGACUsbS+9AOGYsIf0AsMIoASeAKKeXjOlF9hF ACUQQNRz1bXSC+wigBIIIOrhhghyCKAA+of6uCGCHAIogACigZ/+XnqBWQRQAAFE A9wQQQwBzB/9Q0PcEEEMAcwfAUQjpz4hvcAqApg/AohG/vR96QVWEcDc0T80Vt5d eoFVBDB3BBCbOPol6QVGEcDcEUBs4sGzpBcYRQDzRv+wqem9pRcYRQDzRgBRwH6j pBfYRADzRgBRADcFlEEAc7asnfQChGhiP+kFNhHAnPEEEAXtMlV6gUkEMGcEEAVd f6X0ApMIYM4IIAoaM1B6gUkEMF/0D0V0XSC9wCICmC8CiCIuv1F6gUUEMF8EEEWM HCS9wCICmCv6h2Jq2y2XnmAQAcwVAURR590jvcAgApgrAoiiXjhGeoFBBDBP9A/F Lev0hfQEewhgngggShgyTHqBPQQwTwQQJfz1ROkF9hDAHNE/lLK4M39C8kYAc8Qf b5R08lPSC8whgDkigCiJN4fLHQHMD/1DafO7SS8whwDmhwDC4ZgXpBdYQwDzQwDh MGyI9AJrCGBu6B9c5vSUXmANAcwNAYTToW9KLzCGAOaGAMLp/nOkFxhDAPNC/+A2 vbf0AmMIYF4IIDx89X3pBbYQwLwQQHi4+3zpBbYQwJzQP/iYsqv0AlsIYE4IILz0 Hy+9wBQCmBMCCC+3Xyy9wBQCmI+l7aUXQIcJe0gvMIUA5oMngPC0y1TpBZYQwHwQ QHi68XLpBZYQwFxUdJBeAC3G7Sm9wBICmAueAMLbjjOkFxhCAHNBAOHt+iulFxhC AHNBAOFtzEDpBYYQwDzQPySw/WzpBXYQwDwQQCRwzdXSC+wggHkggEhg9D7SC+wg gDmgf0ike7n0AjMIYA4IIBL59XXSC8wggDkggEhk1H7SC8wggNmjf0io6wLpBVYQ wOwRQCR0xQ3SC6wggNkjgEjovf2lF1hBADNH/5BYp8XSC4wggJkjgEjsslukFxhB ADNHAJHYPw+QXmAEAcwa/UNytR2XSk+wgQBmjQCiCS6+XXqBDQQwawQQTfDOQdIL bCCAGaN/aIraDpXSE0wggBkjgGiSi+6QXmACAcwYAUSTvPZN6QUmEMBs0T80TXWn FdITLCCA2SKAaKIL7pJeYAEBzBYBRBO9cqT0AgsIYKboH5qqetuV0hMMIICZIoBo sp//VnqBAQQwfd0H7nmz9AZEY9H/zfzow3nSK2JFAFPUau999/ip9AhEafzMT8aP Gs0PhtNGANOx+0F7nye9AdGbOWni6BETpFfEhAA2W4cjDz1fegMMqRj34Rsvc7OY dBDAZmlx/F+kJ8CkyW8/80yN9IgIEMCm633Gf0tPgGHLRr36f9OkR2hHAJuo5Y/5 ZXWI+9cj/7tKeoNqBLBJjntGegGwxtLXHnxWeoNiBDC5Fl9KLwDqmXTP7/h2YBMR wMT47Q6EZtYdN0lPUIoAJkT+EKLpN9wrPUElAphI/4+kFwCFjTpznPQEhQhgEjz9 Q7iqH7xAeoI+BNDfsnbSC4BSPj7xY+kJ2hBAbzz9Q+gWX8F3ApMhgL7oH8JX+/BQ 6Qm6EEA/rZdLLwB8jDiqWnqCJgTQC0//oMXkr5dLT1CEAPqgf9BjysEU0BsB9ED/ oMnUgyigLwLoRv+gCwX0RgCd6B+0mTKQH9r5IYAulW2lFwBJTfzeWOkJOhBAB57/ QaPpvaUX6EAAHQggVPrLd6UXqEAAS6N/0Knquy9LT9CAAJZE/6DVvB2+kJ6gAAEs iQBCrZeOll6gAAEshf5Br+Xff156QvgIYAn0D5qV78R9EVwIYAkEEKr97dvSC4JH AIujf9Ct8pAPpSeEjgAWRwCh3MR+0gtCRwCLon/QrvayW6UnBI4AFkP/oF95d+kF gSOAxRBAROCx06UXhI0AFkH/EIOKbqukJwSNABZBABGF1w+XXhA0AlgY/UMclu03 WXpCyAhgYQQQkRi3p/SCkBHAgugfYlF98gvSEwJGAAuhf4gHr4YugQAWQgARj+rT n5aeEC4CWAgBRETGDpBeEC4CWAD9Q0yqjxohPSFYBLAAAoioPH+s9IJgEcBN0T/E paInd0YtggBuigAiLrVXXys9IVQEcBP0D7FZ1kF6QagI4CYIIKJz54XSCwJFADdB ABGdf39FekGgCGBj9A/xWdRZekGgCGBjBBDx4ZuARRDAxgggIvTImdILwkQAGyOA iBA3xSqMADZC/xAjvglYGAFshAAiRpXtpReEiQA2QgARpdsvll4QJALYCAFElEYO kl4QJALYEP1DnOb0lF4QJALYEAFEnJZuI70gSASwIQKIOFV1WSE9IUQEsCECiEg9 NFR6QYgIYEMEEJHifgiFEMAG6B9iNb+b9IIQEcAGCCBixU9BCiGADRBAxKqqnfSC EBHABgggonXvudILAkQAGyCAiNbofaQXBIgA1kf/EK95PaQXBIgA1kcAES/uCl0A AayPACJe/BSkAAJYHwFExH71G+kF4SGA9RFAROzFwdILwkMA66F/iNnHu0svCA8B rIcAImYLukovCA8BrIcAIma8L8imCGA9BBAxq+47W3pCcAhgPQQQUXvwLOkFwSGA 9RBARO3dA6UXBIcAbkT/ELcZO0ovCA4B3IgAIm5LtpVeEBwCuBEBRNyquy6XnhAa ArgRAUTcak8eLj0hNARwIwKIyD19gvSC0BDAjQggIjd2gPSC0BDADegfYsc9URsj gBtRQESO9wZujABuQP8Qu7nbSS8IDQHcgAAidtwOoTECuAEBROy4K35jBHADAojo XXKb9ILAEMANCCCix5ujN0IANyCAiB5vC9IIAdyAACJ6H+0lvSAwBHA9+of4Leos vSAwBHA9Aoj48WPgRgjgegQQ8VveVnpBYAjgegQQBvz8t9ILwkIA1yOAMOCOi6QX hIUArkcAYcBfT5ReEBYCuB4BhAHv7S+9ICwEcB36Bwum95ZeEBYCuA4BhAXLOkgv CAsBXIcAwgJeB9MQAVyHAMKC2jMek54QFAK4DgGECVdfI70gKARwHQIIEx48S3pB UAjgOgQQJnBDrAYI4DoEECaM3kd6QVAI4Fr0DzbwxnANEMC1CCBs4IZYDRDAtQgg bKhuI70gKARwLQIII059QnpBSAjgWgQQRvzqN9ILQkIA1yKAMOK+H0svCAkBXIsA wohXj5BeEBICuAb9gxXj+0svCAkBXIMAwor53aQXhIQArkEAYQUvBKyPAK5BAGEF AayPAK5BAGEFr4SujwCuQQBhxsW3Sy8ICAFcgwDCjIeGSi8ICAFcgwDCjDcPlV4Q EAJYh/7Bjo93l14QEAJYhwDCjnk9pBcEhADWIYCwg7cGrocA1iGAsIO3Bq6HANYh gLCDV0LXQwDrEEDYwSuh6yGAdQggDDn7AekF4SCAdQggDLn5F9ILwkEA6xBAGPLk KdILwkEA6xBAGPLugdILwkEAy+gfbJmxo/SCcBDAMgIIW3gdzEYEsIwAwhZeB7MR ASwjgDDm3HulFwSDAJYRQBhz2yXSC4JBAOtctdtp0hOAXEyfOXPiNdIjwkEANzpt z52/L70ByMisGTOnfvSY9IrQEMBNnLbXTnQQ8Zg5Y9YnYylfYQSwmFP36sPXxdBs +oxZn459XHpF2Aigyy/6/0B6ApDIhDmzx90kPUIHAujp3D1/soX0BqCk2g/mzPjo 99IrVCGAyZy8145nEEKEpXbc3DnTx/5ZeoZGBLBpTttrx9OlN8C8CfPmTufnG81B AJvnewO2/w+eESJftR/Onzvr309Kz4gBAUzJD77S45TNpUcgarXj5pfPHfOI9Iyo EMC0/eAr3U/hOSHSU/vhwgXz6F42CGBmvj2wW7fvkkI0Tc3YRQvLyz98XnpH5Ahg Do4a0K37qaQQbjXvL144r/zfL0nvMIMA5uvofTp16fQtvlmIjWrHV1QsWrDog79L D7GIAMo5Yt/OnToeRwwtqhmztGLJooWjXpEeYh0BDMThB3Ts2PF4vk6OV82/Kpct WbLk3dekh6AeAhikgw5o37FD+2PpoWY171dWLlu6ZNm7I6SXoCgCqMJBB7dv367d cS34ejlcNbXvVleuTt6ytwmeHgRQqa8d1rpthzZtBm9GEyXU1P7zs+rly5dWVb/+ nvQWNAMBjMheR7Zq27Ztq61bHUEWU1NT+6+Vn634bEVVVdWKl8dKr0HKCKABfY/d svXWq23VquVhpLGgmtr3V65ctWLlZ6tVf/7cJOk9yAkBNK7ndzZfncZWLVttudVW Lbf8xmabtZBelImastr3V636fNXKlZ+vWLVideW+fHq29CYEgAACMIsAAjCLAAIw iwACMIsAAjCLAAIwiwACMIsAAjCLAAIwiwACMIsAAjCLAAIwiwACMIsAAjCLAAIw iwACMIsAAjCLAAIwiwACMIsAAjCLAAIwiwACMIsAAjCLAAIwiwACMIsAAjCLAAIw iwACMIsAAjCLAAIwiwACMIsAAjCLAAIwiwACMIsAAjCLAAIwiwACMIsAAjCLAAIw iwACMIsAAjCLAAIwiwACMIsAAjCLAAIwiwACMIsAAjCLAAIwiwACMIsAAjCLAAIw iwACMIsAAjCLAAIwiwACMIsAAjCLAAIwiwACMIsAAjCLAAIwiwACMIsAAjCLAAIw iwACMIsAAjCLAAIwiwACMIsAAjCLAAIwiwACMIsAAjCLAAIwiwACMIsAAjCLAAIw iwACMIsAAjCLAAIwiwACMIsAAjCLAAIwiwACMIsAAjCLAAIwiwACMIsAAjCLAAIw iwACMIsAAjCLAAIwiwACMIsAAjCLAAIwiwACMIsAAjCLAAIwiwACMIsAAjCLAAIw iwACMIsAAjCLAAIwiwACMIsAAjCLAAIwiwACMIsAAjCLAAIwiwACMIsAAjCLAAIw iwACMIsAAjCLAAIwiwACMIsAAjCLAAIwiwACMIsAAjCLAAIwiwACMIsAAjCLAAIw iwACMIsAAjCLAAIwiwACMIsAAjDr/wF2yDi1UaI7JgAAAABJRU5ErkJggg=="/></symbol><g mask="url(#b)"><g transform="rotate(.193) scale(.36014)"><symbol id="c" viewBox="0 0 1280 1280"><image width="1280" height="1280" xlink:href="data:image/png;base64, iVBORw0KGgoAAAANSUhEUgAABQAAAAUACAIAAACXhmigAAAACXBIWXMAAA7EAAAO xAGVKw4bAADuE0lEQVR4nOzdh38UV5rvf+UcO0iIKHLOYMBgG3Bgwp3Znblzd3d2 Zvb+dl939+5feR3GZEw2UYCEcu5UHao6/I7UtoYBGUvqek6lz/vFgKxlnz5Iperz rZOqqwAAAAAACIBqpxsAAAAAAIAOBGAAAAAAQCAQgAEAAAAAgUAABgAAAAAEAgEY AAAAABAIBGAAAAAAQCAQgAEAAAAAgUAABgAAAAAEAgEYAAAAABAIBGAAAAAAQCAQ gAEAAAAAgUAABgAAAAAEAgEYAAAAABAIBGAAAAAAQCAQgAEAAAAAgUAABgAAAAAE AgEYAAAAABAIBGAAAAAAQCAQgAEAAAAAgUAABgAAAAAEAgEYAAAAABAIBGAAAAAA QCAQgAEAAAAAgUAABgAAAAAEAgEYAAAAABAIBGAAAAAAQCAQgAEAAAAAgUAABgAA AAAEAgEYAAAAABAIBGAAAAAAQCAQgAEAAAAAgUAABgAAAAAEAgEYAAAAABAIBGAA AAAAQCAQgAEAAAAAgUAABgAAAAAEAgEYAAAAABAIBGAAAAAAQCAQgAEAAAAAgUAA BgAAAAAEAgEYAAAAABAIBGAAAAAAQCAQgAEAAAAAgUAABgAAAAAEAgEYAAAAABAI BGAAAAAAQCAQgAEAAAAAgUAABgAAAAAEAgEYAAAAABAIBGAAAAAAQCAQgAEAAAAA gUAABgAAAAAEAgEYAAAAABAIBGAAAAAAQCAQgAEAAAAAgUAABgAAAAAEAgEYAAAA ABAIBGAAAAAAQCAQgAEAAAAAgUAABgAAAAAEAgEYAAAAABAIBGAAAAAAQCAQgAEA AAAAgUAABgAAAAAEAgEYAAAAABAIBGAAAAAAQCAQgAEAAAAAgUAABgAAAAAEAgEY AAAAABAIBGAAAAAAQCAQgAEAAAAAgUAABgAAAAAEAgEYAAAAABAIBGAAAAAAQCAQ gAEAAAAAgUAABgAAAAAEAgEYAAAAABAIBGAAAAAAQCAQgAEAAAAAgUAABgAAAAAE AgEYAAAAABAIBGAAAAAAQCAQgAEAAAAAgUAABgAAAAAEAgEYAAAAABAIBGAAAAAA QCAQgAEAAAAAgUAABgAAAAAEAgEYAAAAABAIBGAAAAAAQCAQgAEAAAAAgUAABgAA AAAEAgEYAAAAABAIBGAAAAAAQCAQgAEAAAAAgUAABgAAAAAEAgEYAAAAABAIBGAA AAAAQCAQgAEAAAAAgUAABgAAAAAEAgEYAAAAABAIBGAAAAAAQCAQgAEAAAAAgUAA BgAAAAAEAgEYAAAAABAIBGAAAAAAQCAQgAEAAAAAgUAABgAAAAAEAgEYAAAAABAI BGAAAAAAQCAQgAEAAAAAgUAABgAAAAAEAgEYAAAAABAIBGAAAAAAQCAQgAEAAAAA gUAABgAAAAAEAgEYAAAAABAIBGAAAAAAQCAQgAEAAAAAgUAABgAAAAAEAgEYAAAA ABAIBGAAAAAAQCAQgAEAAAAAgUAABgAAAAAEAgEYAAAAABAIBGAAAAAAQCAQgAEA AAAAgUAABgAAAAAEAgEYAAAAABAIBGAAAAAAQCAQgAEAAAAAgUAABgAAAAAEAgEY AAAAABAIBGAAAAAAQCAQgAEAAAAAgUAABgAAAAAEAgEYAAAAABAIBGAAAAAAQCAQ gAEAAAAAgUAABgAAAAAEAgEYAAAAABAIBGAAAAAAQCAQgAEAAAAAgUAABgAAAAAE AgEYAAAAABAIBGAAAAAAQCAQgAEAAAAAgUAABgAAAAAEAgEYAAAAABAIBGAAAAAA QCAQgAEAAAAAgUAABgAAAAAEAgEYAAAAABAIBGAAAAAAQCAQgAEAAAAAgUAABgAA AAAEAgEYAAAAABAIBGAAAAAAQCAQgAEAAAAAgUAABgAAAAAEAgEYAAAAABAIBGAA AAAAQCAQgAEAAAAAgUAABgAAAAAEAgEYAAAAABAIBGAAAAAAQCAQgAEAAAAAgUAA BgAAAAAEAgEYAAAAABAIBGAAAAAAQCAQgAEAAAAAgUAABgAAAAAEAgEYAAAAABAI BGAAANaiqampunrxbbRa7M20VFr8rZTNZqVeAgCAICEAAwACrbmlZZnPLibPBdUL VARdiKHq08VidU1NR0fH4qf1vYeqFy8Wi8lkUn2w9MLlJv6tEcu1J5NOa2kgAADe QAAGAPjWMuF2MUAu/rmQHzs6O3XmWP3UPzMRj5c/+KnxakIyACA4/PyuDwDwt7a2 tkKx+HefKpVqamuLhYKKeeVxWoea5iULITmRKKmvZPnr9fdftNqamlQq5VDTAACw GT0DAICrvT2KWyotJLTF8cx2Iq688hhyafHL/m48ZvQYAOAt9BsAAM5ram7+uyir 8m1NTalYLFVVdfp9lrJ3qVQcj8erlsvGCxt3ZTLONQ0AgOXRpQAAaPLuWC4p16/e k42rGDcGADiH3gYAQFxtbW1DQ4Pvd5zCSpTnVJumWSgUnG4LACBw6IgAAMSFwmEV gJ1uBVwkHo8zDgwA0I8ADAAQF+3pqa2tdboVcBECMADAEQRgAIC43nXrmPyMNxGA AQCOoDsCABDX09tbvcjphsAVSqXS5MSE060AAAQRfREAgLjuUKi+vr6mpsbphsAV isXi1OSk060AAAQRARgAIC4UDqfT6a6uLqcbAleIxWKcEgwAcAQBGAAgLhwOG4bR 1d3tdEPgCvNzc7lczulWAACCiAAMABBHAMabCMAAAKcQgAEA4sKRSDqd7uzsdLoh cIX5+flcNut0KwAAQUQABgCIi0SjacPoIABjUWx+PksABgA4gQAMABAX7ekxUikC MMoIwAAApxCAAQDiurq7TdPs6OhwuiFwBQIwAMApBGAAgA4tra0EYJQRgAEATiEA AwB0aG1tbScAYxEBGADgFAIwAEAHAjCWEIABAE4hAAMAdCAAYwkBGADgFAIwAEAH AjCWEIABAE4hAAMAdCAAYwkBGADgFAIwAEAHAjCWEIABAE4hAAMAdCAAYwkBGADg FAIwAEAHAjCWEIABAE4hAAMAdCAAYwkBGADgFAIwAH2aW1qW/by6E5Xe/Wxpmc+t VPWKb26lUnV1dTqdXvtrYWX8F4BLi5dosVhMJpOlYrFq4bqz4V21VPXDxV9dU9Pe 3l5TU2NXZfcgAOvR0tKycJWu5n649hd751WWv7EvynDLBeAcX72hAtCsubl5ma7V j10o1X0v/Uj9pc6uLtd24lUL4/F4OQyX+4t/a+ibH/7Yn6utqUmlUtqb6W1uDsCF QiGVTC5836vVZVtTo36vXaA+rK2rq6utrauvV3/Wq9/V/xoWdHZ2NqnrX55lWapt pmlauZxpLcgri38ULEu1XCXw8u+lhf+VSou/qX/LUnh2IQLwGrS1tRXKz1neCpZL qXXxxlW+5aqP1SXq6ltuLLbwkWrhT99yl/52JpPR2DoAPufSOyMAZy31tP7O0kjC Yn+rw8W9K2k/BOaqqr/rui39+eMgHp22N7W2talIpv911Tcrob5ZKtNWVy+m2tpy iG1sbGxqamppbQ1HIj81N8G7VEBOJhKZdNowDHUdmtlsOTkX8nmVj1ViLjn6UxyL xbL8dLyh/DDx75Ltj7MAFp5oLH7CzYFWWvmn+IfJEeWvwjtfCp5LAlihgN5JASz1 t6qWulylUrmzpT7f0dER2J6WjQqFgpFKFRe/pMv02AKWkOUC8ELnOJFQX9waFW5/ zLcL4batLRqNBvlJzfuZpjk/N5dKJlVIVnHUMs03E7L6orWL3QeCFoCXmSzz4/1W fYXbXDxW7yE/hOS/T8h/e48L2P0WwHvQJwD8bGEB2Jv/vRRxgz1+6x6x8iTAxanX Cx+8+R3xXXdNLgD3rFu3dft2icpB9uzx44nx8cbGRoni/gvAb0fcxZut+r24OJDb 1dXlWMuwaNl4XKY+YhsIIFDo/gKe99bszaVY29bWxqiCd/3UaIZ3hzLkAvC69eu3 bN0qUTnInj15MjE2RgB+09sTlXmk6BcLuwCkUuXtKt4aq2e/LsB/uFkD3rA0lrsU gZbWhjG2EEALQ8fLLT+ucnF3jQDsLYENwH/3SPHHhbjFxZTLzTaA/u5m+8bjD8aN Ae8iAAPu8tY8utqamkKhwKJcrNxPDmU4PW5MAPYWfwfg5WcsM3EGK7Y0SWfhrdlN d1oAP4v+NOCM5paWt+fRLWKEAXLeGsoof7K89ZGGVycAe4s/AvDC4VUNDT/8BxNn oMW7d9ry271rp+cAQUMABnSora1tUP1IBhngPvF4XE+3jADsLf4IwF3d3U1NTRpe CPhZb03PMXO5hRleALQjAAM6RHt6VAZ2uhXAMgjAWJY/AnAoHG5YGgEG3ETbvRfA WwjAgA6RaLSurs7pVgDLSMTjerZyIQB7iz8CcDgSqa+v1/BCwGoRgAGnEIABHQjA cC1GgLEsfwRg7r1wLQIw4BQCMKADnTC4FgEYyyIAA6IIwIBTCMCADnTC4FoEYCyL AAyIIgADTiEAAzrQCYNrEYCxLAIwIIoADDiFAAzoQCcMrkUAxrIIwIAoAjDgFAIw oAOdMLgWARjLIgADogjAgFMIwIAOHMUB1yIAY1kEYEAUARhwCgEY0CESidQRgOFK BGAsiwAMiNJ2BjuAtxCAAR0IwHAtAjCWRQAGRBGAAacQgAEdCMBwLQIwluWPABzt 6amtrdXwQsBqEYABpxCAAR0IwHAtAjCWRQAGRBGAAacQgAEdCMBwLQIwlkUABkQR gAGnEIABHQjAcC0CMJZFAAZEEYABpxCAAR0IwHAtAjCWRQAGRBGAAacQgAEdCMBw rXgsltESRQjA3kIABkQRgAGnEIABHQjAcC0fjAD3bdiwub9fonKQPX/yZNz7Abin t7empkbDCwGrRQAGnEIABnQgAMO19AXg1tb2jg6Jyhs2bdq4ebNE5SAbePZsfGSk QSgAz89ns1mJym8hAMO1CMCAUwjAgA4EYLiWtk4YAdhbCMCAKAIw4BQCMKADAbis VCoVi8VkMqk+qqpepG5DNTU/fKB++/GDHz75xmeWipQ/+UM5VUf9Wf546TXUq6j/ KhZ//D//8Pd++PON/1SlOjs73yweQPrWABOAPcUfAbh33bqA/4CrG108Hl/2lvu3 +23Z4ufLd9c377rv3nKr3rzrlm+55fttsfjDJ378v/7trrv4GVWno6Pjx4YEHQEY cAo3IEAHHwdg1bFR7+JVi52q2poFtbW1C/+rW1CvfjWoLvSCrlCota3NVf0ey7LS hmGaZjaTyWWzuVxOfVzILygsUr26ovp9sWNXztWq9Z1dXa76V1SIAIxlEYBdaCHN xmJVi/fbmsXIWlu+55a9ccttaGpqbm5WN6uGhgY9DTOSyeJiAH4/dXdNJZPqTmvm cuoOnP/xfrt4ry38cL/98Zar/n6Hf59REoABp/jzngK4jUcDcDnclkcGFnpXNTXq X1HuXTU1NbW0tYXC4ZaWFqebqZXqtsXm5gzDyKTTqgev/jNvWT/02xZ5rtOmLYoQ gL2FAKzZDw8T1e1W/Vq83y48Rly44zaoG66604Yikfb2dtfO6LZM0/bdBFQ2VhEx l8lkczl1waiX+CEtl++3izlZfX/bF0eV7X1pDQjAgFO8d78AvMi1AVh1I1KGofpb qqdVHkBQna3m5uaW1tZob29bW5vTDfQklYrn5+ZSyWS562aWO235vOqulcc31N9x z9TrifFxPS9EAPYWfwTgdX19Gl5lJX6YilxVVfvjkK2KtuqG29TYqO63kWjUQ0/N lrUwCJxKqVuc5tdVd1f1uulFP4wq/5iQF6ZkV1erNzJ3PjUgAANO8fCtFvAQBwNw uddVniVXr/Lt4khCe3t7KBzu37q1s6tr6W/Oz8/HFifXQVoul5uZmkomk5nFHptp WQX1a3EKoObumro8Jicm9LwWAdhb/BGAe3p7da44LRQKhmGoF/thDcjifBl1yw33 9HR1danP6GmGU1T4zBiG0634OwtjyIax8CudzmWz5UnX5ek6C7OsHX0WSQAGnEIA BnSQDsBvptyG+vryfDkVbvu3bVvX11e/spcmALuB6p+pXlFKheNEYiEemyodW6qj 1tLaKvFyBGD8FH8E4O5QqKGhQSjhZDOZWnW/bWxsbm5ua2+P9va2yvyceoVTg8Br pu6u6lJUbf5hPUs+v7gQWVM2JgADTiEAAzrIBeC0YVz8/PO+DRsaK+6nEoDdaWZ6 +vmTJ0Jjwuo7ntWyA1ZXd7fqX3bIBGCVflUGlqgcZC+ePx9TAVhmCyVtATgUDquM 0fXGVBcbHTl+vLGpSaKyd7lwEHhtyitZxsfGctlsR2enxEsQgAGnEIABHeQCcKFQ +NP//t+2lCIAu9PUxMTAs2e1tbUSxVUPL5fLSVR+i2gA3tTfv37DBonKQfZyYGB0 eNgPAdgw1OUnUfzAkSMBH/J918q3g/aE+3fvZtJpAjDgMwRgQAcCMNZsYmxMRREC 8HsQgCX4JABHIulUSigA7zt4UGhWv6ctHCznl1xHAAZ8iQAM6BCORFa4EHe1SqXS H//yF1tKEYDdaWxk5NWLF0Lb5xCA8VP8EYDD4bAhNgK8Z//+TpnJ1Z6m3pVSiUT5 QDivEw3A8Xjc9oOjAKwEARjQQS4AK//y5z/bUocA7E4qhAy+fCkVgOfnc1pyCAHY c/wRgBdGgFUAlompO/fsCYXDEpW9Tt1V9NxYpN2/dy9jGARgwGcIwIAOBGCs2fDQ 0OtXr4Sm0BOA8VP8EYDVvTedTnfKBJjtu3ZFolGJyl5XLBZTiYTTrbABARjwJQIw oAMBGGs2+PLlyOvXQtePthwS7ekxUimhfuSWrVvXrV8vUTnIBl+8GH792usBWAXU tFiA6d++vXfdOonKPqCinWWaTreiUgRgwJcIwIAOBGCs2auBgRHvD8RFenrSYgG4 f9u23r4+icpBxpOXn7W5v7+PqQc/IZ/Pqx95p1tRKQIw4EsEYEAHAjDWbODZs/HR UQLwexCAJfgjAHd1d1umKbRX84ZNmzZu3ixR2R9SiYTXz0MiAAO+RAAGdCAAY82e P3kyPjbW2NgoUVx9x7OZjETltxCAPccfAVhpbWtrb2+XqNy3YcPm/n6Jyv7gg62w RAMwxyABTiEAAzqEwmGhEbyampp/+td/taUUAdidnj56NDkxQQB+DwKwBALwz+pZ t27r9u0Slf3BB1thPbh3T2VUod37GAEGnEIABnQgAGPNHj14MD011dTUJFE8Hotl 9ARgyb2Itu3cGe3pkagcZK8HB9UvHwRgFX/b2tokKoej0R27dklU9g0jmSwUCk63 Yu0IwIAvEYABHQjAWLPv792bnp5ubm6WKO6PAMxpNBJEz9/SGYDb29tbZQJwVyi0 e+9eicq+YeZyeuaYCCEAA75EAAZ0IABjzR7cuTM7O0sAfg8CsAQC8M/q6Orau3+/ RGXf8PosaAIw4EsEYEAHAjDW7N53383NzbW0tEgU1xaAw5GI6kd2EoC9QwXgoVev hKZAq7uNtu2RVHppaW2VqNza3n7g0CGJyn6SSiaLnp0FTQAGfIkADOhAAMaa3bl5 U31fpAKwrh5YJBJJGUZXV5dE8V1793aHQhKVg2x0eHjw5cu6ujqJ4loDcGen0I9P c2vroSNHJCr7iaf3giYAA75EAAZ0IABjzb67fl31k1plhrAIwPgpvgnAnV1dQisI Ghobj544IVHZTwr5vJFKOd2KNSIAA75EAAZ0IABjzW5evZpMJIQWMRKA8VMIwD+r rr7++AcfSFT2k1KplEok1O9ON2QtCMCALxGAAR0IwFizG1euJJNJoXNctPXAwuGw oQJwd7dE8d379glVDrKxkZFXL15IBeC5uVwuJ1H5XeraEDpFrKa29uTp0xKVfSZt GHnLcroVa0EABnyJAAzoQADGml27fDmVTLa3t0sU90cA3nvggND+0kE2Pjb2amCg trZWorjOANwdCjU2NkpULlVVnT57VqKyz3j3MCQCMOBLBGBABwIw1uzqX/9qpFLt Hu+BiQbgfQcPCn19gmxibOwlAfi9CoXChx9/LFHZZ9QXykgmnW7FWhCAAV8iAAM6 EICxZpe/+SadSgmNcGrrgakfgbRYAD5w+LDQGukgm5qYGHj2zAcBWO72a5nmuQsX JCr7TKlUSsbjTrdiLQjAgC8RgAEdCMBYs2+/+kruBF1/BOCDR44IHfQaZFOTkwNP n/ogAIcjEaHTjDPZ7PlPP5Wo7D9GKlXI551uxaoRgAFfIgADOsgFYNU9/V9//KMt pQjA7vTtl1/KTR7WGYBVD1hor+Yjx483yuxyFGQz09PPnzypqamRKK4zAEeiUaGt vNQP5sUvvpCo7D/ZTMbU9R230cP799OG4fUVKADeQgAGdAiFQg0yi9BUx+4P//Iv tpQiALvTX7/8Mp1OCx0gpHUEWOxfceTECaFFnkE2Oz39TCwAq1uNtl2Roj09QuPY yWTys1/8QqKy/1im6cWwJxqAE/F42oNfE8AHCMCADgRgrI1lWbeuXateJFE/Hotl tOSQbvUj0NAg9K84fuqU0BBfkM3PzT199EjoW1YqlSYnJiQqv6unt1coxqt/xelz 5yQq+0+xUEh5cB8sAjDgSwRgQAcCMNZGOoSoAJzNZiWKv4UA7Dm+CcDRnh4VgLn2 nOXRfbAIwIAvEYABHQjAWJvpqamBp0+Fxq+KxeLU5KRE5Xf19PbKjWOf4ixWAap3 /vjhQ6HiOgNwdyhUX18v9EN06OjR5pYWicr+YySThULB6VasDgEY8CUCMKADARhr MzY6+mpgQGiISdv8Z6V33Tq5sUSmoUqQnn6vrfcfikQyYvuo79m/v1NmZbv/qO+C ZZpOt2J1CMCALxGAAR26QyGhTXrqGxr+5z/9ky2lCMAuNDw09PrVqzqZQ1x07sTb 29tbzTpMr/nm//0/uYnr2p6/hCMRI5US2kd9+65dkWhUorL/5LLZnJYFFzZaCMDp dHt7u0RxdoEGnEIABnSQC8CNTU2/+8MfbClFAHahVwMDI8PDQmdoxebn9SwArpLc iCiRSHz+y19KVIY/diBXATVtGB0yI8Cb+vvXb9ggUdl/LMvKGIbTrVid7x88MAyD AAz4DAEY0IEAjLV5/uTJxNiY0Px5nQGYo2i8aCEAy51BrWsEWLXfNM0OmVmsfRs2 bO7vl6jsP4VCwfDaRtAEYMCXCMCADgRgrM3jhw+nJiebmpokivvjLNZUKvXppUsS lfHtl18acgFYY++/ta1NKMNEenq279wpUdl/vLgRNAEY8CUCMKADARhr8/29e9PT 083NzRLFdW6CFYlGhbbyUt3Ti198IVEZvgnAKv62tbVJVO4KhXbv3StR2ZdUAFYx 2OlWrAIBGPAlAjCgAwEYa3Pv9u252dkWmXNW/BGA1T/h/GefSVTG5a++SqkA7PE1 wIoKMK0yAbito2P/wYMSlX3JcychEYABXyIAAzoQgLE2t2/cUDG1pbVVorjO7lck EhHayzqXy3188aJEZVz++mu57aN0ngGj/glCT5GampsPHzsmUdmX1OWUtyynW7EK BGDAlwjAgA5d3d1CyzibW1r+4fe/t6UUAdiFbl27pnKC0OCVzu5XOBKplwnApml+ dOGCRGWIBmCdl19nV5fQOoL6hoZjJ09KVPalbCZj6jp6zRaPHjxIEYAB3yEAAzrI BeCWlpbfEoD968bly8lkss373a9QOCx0mJNlWefOn5eojCvffGOkUj4IwHJ34Jqa mpNnzkhU9iXPHQX8aHEE2Ad3YABvIgADOhCAsTbXvv02lUr5YPxBbhVAoVD48OOP JSrj6rffGslku8wBQv64/Iql0plz5yQq+5Jlmt6KfARgwJcIwIAOBGCsjW+G4OQS SKmq6vTZsxKVce3y5ZQKwN7v/QtOQDDNc8zAX7G8ZaUNw+lWrAIBGPAlAjCgg1wA bmtr+x//+I+2lCIAu5BvtuFlDqoX3bhyZWEGPkvQfxqbkK9KoVAwkkmnW7EKjx4+ VIndB7swAHgTARjQQTAAt7f/j3/4B1tKEYBd6K9ffZVNp30wAiz3I1BXV3f81CmJ yrh59WoykfBB759jqF2iWCymEgmnW7EKBGDAlwjAgA4EYKyBZVkqgdTU1FRXi9yr dZ4DLLcNb0NDw1G24ZXx3fXr6iLxQe8/2tNTW1srUblUKp1mDfCKqS9XMh53uhWr QAAGfIkADOhAAMYaxObnn3z/vVD6rdIbgDmI1Yu+u3Ej4YtjqHvXrZP7OTpx+rRQ uvalhKfeZQjAgC8RgAEd5Ia/VK741W9+Y0spArDbTE1ODjx9KjdyNTkxIVF5WR0d HUI5SpU9eOSIRGXcvXVrfm5OKgBrfP7S09tbvUiiuLr8hL5EvpSMx9XNx+lWrNTj 7783UikCMOAzBGBAB7kA3NnZ+UsCsE+NjYy8evFCaO2izvihtHd0tMqEBFV538GD EpVx//btubk5oXuXziswFA6r1+qUWUu/e9++ru5uicq+lEokisWi061YKQIw4EsE YEAHAjDWYOjVq+GhIaHda9W3O5fNSlReVnt7u1AnsrO7e8++fRKV8fDu3ZmZGR8E 4EgkIreb+tYdO3p6eyUq+1IqmSwWCk63YqUIwIAvEYABHQjAWIMXz5+PjYwInV8a m5/PagzAqgcpdJxsKBLZuXu3RGU8un9/enpaaP8CdbfJagvAPT1psfO0N27evGHT JonKvqTyZCGfd7oVK0UABnyJAAzoIBeAu7u7L/3617aUIgC7zdPHjyfHxxsbGyWK 64wfSmtra3tHh0Tl3r6+/m3bJCpD9grU+Aimq7vbsiyhRzBcgauSTqXy3gnATx49 SqkA7P194AC8iQAM6CAYgEOhS7/6lS2lCMBu45vxt2hPjyE2/rZh06aNmzdLVMbA s2fjo6PMQXg/5iCsStow8pbldCtWigAM+BIBGNBBLgCHQqEvCMA+9eDu3VlfrMAM RyLpdFpoC6L+bdt6+/okKmPw5cuR169Zhf5+HV1de/fvl6jsSyryWabpdCtWigAM +BIBGNBBLgBHotHPLl2ypRQB2G3ufffd3Nyc0PG5WgNwOGwYhtBOuTv37AmFwxKV MTo8rDKw0D7k83NzuVxOovKy5A7iamtv33/okERlX/JWAH76+HEqmfTBUdgA3kQA BnQgAGMN7ty8GZuf90HfqzsczogF4H2HDglNbcXk+PiL58+FTqLWPAW6o7NT6FmS urcfOnZMorIvZTMZU+ODjwoRgAFfIgADOsgF4GhPz6dffGFLKQKw23x3/Xo8FvPB BqTqKq2pqamuFnnHOXriRIPMLk2YnZl59vix+t5JFC+VSury1paB5W7C6vJTF6FE ZV/yVgB+9uRJUgVgoWk4BGDAIQRgQAe5wYfedesufPaZLaUIwG5z8+rVZCLhgwDc 09srF6JOnT0rFK1hmebNa9fkHl7onIff1d0ttJ9cXV3d8VOnJCr7krcC8PMnTxIE YMB36DQAOhCAsQbXL19OJpNC83s1jwALTaNNJBKf//KXEpVR9tcvv0yn011dXRLF dV6EcgG4qrr61IcfilT2IwLwEgIw4BQCMKCDXABet379+YsXbSlFAHaba99+m0ql fBCAw5GI0E7CRip10aY18FjWt19+KbeBmdaF6KGQ0IHGxVLpzLlzEpV9KZfN6tz9 u0LPnz5NJBIEYMBnCMCADnIbkK7fsOHjCxdsKUUAdpurf/2rCnjtHR0SxRPxeFpX 3ysUCgkt083lch/b9AAIy7r89ddpwxA6w1nrRRgOCx1oXCgUPvz4Y4nKvuStADzw 7JkKwD44iw7AmwjAgA4EYKzBlW++UQFYKHv4Y/Yp2UOa6FMYnRehXAC2LOvc+fMS lX2JALyEAAw4hQAM6CAXgDdu3nzOpgBAAHYb0cE3ndlDbgPempqak2fOSFRG2Y3F hehtzMP/aaZpfmTTU8gg8FYAfvH8ubpKCcCAzxCAAR3aOzpaZQLwpi1bzn70kS2l CMBu45vZp3IPgDiBRprsWVwaA0AkEqmTCcDMw18VAvASAjDgFAIwoAMBGGtw+auv Uobhgw1429vbhRKUKnvg8GGJyii7+91383NzUpsA6QzA0WhdXZ1EZfVPOG/TVvxB QABeQgAGnEIABnSQCwD927adtukEDgKw2/hmA1518QvtZd0VCu3eu1eiMsq+v3dv enpaKACoG07W+wFY/ZBe/OILicq+5K1jkF4ODKirlAAM+AwBGNCBAIw18EcAVu03 TbNDZhelnnXrtm7fLlEZZU8ePZqamBA6QCg2P5/VNRgodxg1Z3GtCgF4CQEYcAoB GNBBLgBv27Hjg9OnbSlFAHYbfwTgSCSSzmSEAvCmLVvWb9woURllL54/HxsZEdo/ Wec0BAKwS3grAL968UK9LQptYk8ABpxCAAZ0kAvA23fuPHnqlC2lCMBu448ArIJH dXV1TU2NRPHtu3ZFolGJyigbHhoaevVKaP/kYrE4NTkpUfldBGCX8FYAHnz5Ur0z EoABnyEAAzq0tbUJnSOyc/fu4ydP2lKKAOw2/gjAPb29QulX2X/4cJvMoyWUTY6P v3j+XCg6VmnMAARgl1C3Hcs0nW7FShGAAV8iAAM6yG0CtHvv3qPHj9tSigDsNv4I wHKbD5VKpQ/OnKkRy2ZQzFzu1vXrNTU11dUiHQadMxEIwG7grQA8NDg4NzsrFIB1 bgIH4E0EYEAHuQC8b//+Q0eP2lKKAOw2/gjAoXBYaAUpu+/q8devvsqm014/j5oA 7BIZw7Asy+lWrNTroSEVgKU2gSMAAw4hAAM6CAbggwcP2XQOKgHYbfwRgFX7hcZP TNP86MIFicp40+Wvv04bhlAA9sFMBB7ErIq6lvIE4EUEYMApBGBAh9bW1naZXXAP Hjmy/8ABW0oRgN3m26++SqfTnR4PHp1dXUKHiJSqqk6fPStRGW+6fvlyMpkUeoSn 7ToMRyJCW3llMpnzn30mUdmXjFSqkM873YqVGhkenpme9sExYADeRAAGdGhpbRU6 BubIsWN79u2zpRQB2G38MfImtwV6Q0PDUZt2gMN73Lp2LRGPC30Tte0DJBeAzVzu o4sXJSr7kpFMFgoFp1uxUioAz87MCC3iIAADTiEAAzq0tLQIxZhjJ0/u2r3bllIE YLe58s03Rirl9bWXcvP/2zo69h88KFEZb7p3+/bc7Ky6iUkU1zYLVG4tumVZ586f l6jsS6lksuidADw6MjIzPU0ABnyGAAzoIBeAPzh9etuOHbaUIgC7zdVvv1UB2NNT TyPRqIrZQtMfwtHojl27JCrjTY8fPpyanJQ6CUbXTITuUEhoImuhWPzwo48kKvtS MpEoFYtOt2KlxsfGpqemhOYOEIABpxCAAR3kAvDps2f7t261pRQB2G2uXb6c8vja y2hPT3V1tdA5wBs3b96waZNEZbzpxfPnYyMjQoNgxWJRpWuJym+RC8CsRV+VZDxe KpWcbsVKTYyPq+uTAAz4DAEY0KG5pUVoK6OzH3+8afNmW0oRgN3mxpUryWSyTWjt pa4ALHT2jLJzz55QOCxUHEtGXr8eevVKaAvlKl2XotxmbDU1NSfPnJGo7EsJT73L TCrj40IBWL3n5gjAgBMIwIAOTc3NXV1dEpU/uXixb/16W0oRgN1GdvMhLalDbuch 5eiJEw0yY3p40+zMzLPHj4WG8at0LUfv6OwUWsasrvBjH3wgUdl/SqVSMh53uhWr MD01NTE+LvT0hwAMOIUADOjQ1NQkdJrrZ5cuRaJRW0oRgN3mzq1bsfl5oV67nt13 5Q4BTiaTn/3iFxKV8RbLsm5evaq+4EJP8fQ8i2nv6GhtbZWo3NzaeujIEYnK/lMs FFLJpNOtWIXZmZnxsTGhaSzzc3O5XE6iMoD3IwADOsgF4Eu/+lV3KGRLKQKw2zy4 e1d1v4TmbeoJwHLDbpZpnrtwQaIy3nX5m2/SYhuS6wnAbe3tQqsJOru69uzfL1HZ fwr5vJFKOd2KVZibnR0bHSUAAz5DAAZ0kJsC/evf/rbdpi12CcBuI7r7rp7jZ+RS h+qSnjh9WqIy3iW7HF3+WUxXd7dlWUL7yUV6e7fbtBW/7+UtK20YTrdiFWLz86Mj I0Lz/7WdAQbgLQRgQIee3l6hd9Df/v73do2wEYDdZuDZs/HRUaHddzUMu0V7euTO MW5taztw+LBEZbzr7q1b82Kz8TXshasCsGmaQsdxbdi0aaNNOxH6nmWaek69sks8 FhsZHhZ6+9a2BTqAtxCAAR16162rrhb5cfv9P/2TXQGJAOw2rwcH1S+hTaQ09L1U AJZbOBrp6dm+c6dEZbzL65MRRI/j2rZzp6ovUdl/coqnxjyTicTw69dCb9+lUmly YkKiMoD3IwADOsgF4H/+05/sqpzJZCYnJz10QqPvTYyNvRwYkDtGSHoQWPQMpC3b tq3r6xMqjrcMvngxMjwst6G39CxouTk4yr6DB+1ah+J72UzG9NSqVyOVGhocJAAD PkMABsS1tLQIzQJVb59//MtfbCxYKBQSi4rFoo1lsTa5XO6769dVx12o+yUdgEPh sND8beXAkSNCm/riXVMTEwPPnnn3WYzccVzqJnzi9Gm5Q5J9Rn2XLdN0uhWrkM/n nz5+XL1Ior6eM8AAvIUADIhrbm7ulJkFansALlPpN5lMqi6pysO2F8eq/PXLLzOZ TKc3d99Vl73QFtbqEj197pxQlxTvUqHlxtWrNYsk6ktfinLHcRmp1MVLlyQq+1La MPKW5XQrVufu7dsNDQ1STyG17MYP4C30HgBxzS0tQgEmlUr9n//+b4nKVYvpOpfL zc7Omp56YO8zl7/+WnUZpY6fEe57tbe3t8rsG6yuzI8vXpSojJ/y7ddfq4wqtI+U 9KWomt0iM19A3R4/4jiuFTOSSc89V1UBWF2cnj4EG8BbCMCAOI8G4CX5fF69SScS CekXwruuX76cTCaFjm8R3XwoEo2qjp3Q2siampqTZ85IVMZPubF4KbbJXIrSE0Fb 29qEfoiqqqtPffihSGU/Ssbjnttm4t6dO0Yq1R0KSRQnAAOOIAAD4uSmQKcN4z/+ 7/+VqPwu1WsxDGN2dpblwTrduXlTxVSh42dEh92i0WhNba3QvEGVZvYfOiRRGT/l 3nffzc3NCV2K6vaSSCSEkoC6FA2xaRTNra2HjhyRqOw/6rusArDTrVg1FYDVW21X d7dEcaZAA44gAAPi5EaA0+n0f/zXf0lU/imqB2Oa5vz8PO/Zejx68GB6akpo+WKV 5PhDJBqV2xmob8OGzf39QsWxrOdPnoyPjTU2NgrVl7sURXcjD0ejO3btEiruM8Vi MeXBmUSyAZgRYMAJBGBAnFwAzmYy/99//qdE5Z9VKBTKG2UxICxq8OXLkdev5Y6f kZt62h0KyYWlvQcOCA3o4aeMj46+evHCixtBh0KhBrFLsX/btl6O41qZQj5vpFJO t2LVCMCA/xCAAXG+DMBlpVJJxSf1Fp7z1NGOHqI6Xndu3aoVm0ssNwFPbtshtoB2 hPhG0B68FNUN8OiJE41iEzR8Rl1CXgx7BGDAf+hAAOLkArDqL/67owF4iWVZiUQi lUoxIGy7bxdPQhIa8BQaAVadxbxlCW2YpC62c+fPS1TG+13+5puFjc08tQ+WuhTV BSPUZpWLLnzxhURlXzJzObld9+Tcu31bXZkEYMBPCMCAOH9sgrUS5Y2ykslkNpt1 ui3+ce3y5ZTYRtBCmw9FolG5ocL6+vpjH3wgURnvd+vaNRVThY62KhaLqrjttw51 KcpNoChVVZ0+e1aisi+p9Gt6cK4Qm2AB/kMABsQJHoNkGP/HTQF4iWVZyUUMCFfu 7q1b83NzQnM4q2SGIER3wFI90d379gkVx3s8vHt3ZmamublZqL7EpSi6Fl39VB5k C+gVUzEyb1lOt2LVOAcY8B8CMCBOLgCrePmv//ZvEpVtUV4hnEgkGBCuxPMnTybG xuR28ZEYglAZVW7n6k1btqzfuFGoON7j5cDA6PBwQ0ODUH2JMNDe3i40ZF3FbuSr lEomi4WC061YNRWA6+vrpZa+E4ABJxCAAXFyAVglzH/+05+E3phtVB4QTqVSBQ/2 fhw3NTk58PSp3O67sVjMMk17vzVyqUNd80eOH28SG4TEe3huS7ZINKpuO0Jjd8rB I0fkpmb4TyIeVz/ATrdidfL5/JNHj9SbrNQ1TwAGnEAABnToXbdO6O3zN7/7XatH emDlAWGVhFnytCqWZd28etVIpeQO/rG3E6ZSh/pGd3R02FXwTaqd5z//XKIyVuLb r75S3wKhS9H2MCA6/1ld5Be4FFesVCwmPXgIcDwWGxkeFnrKrN4TJycmJCoDeD8C MKBDU3Oz0CjE+c8+W7dunURlOfl8vrxCmAHhFbpx5Yr6crWJzeRMJBJpw7CrWrSn R27ApKa29uTp0xKVsRKil+LClmwqA9v3gKy9o0Pu+WBtbe0JLsUV8+ghwDPT0+Nj Y0I7GsRiMS9uiw34AAEY0KGpqUloD8mjx4/v3rtXorI01dlVPV3VmZY4+8RnHj14 MD01Jbeq1t69oEPhsNwy0c6urj379wsVx896cPfurEf2wRLd/1kJRyI7du8WKu4/ Hj0EeHRkRGVgoRva/NxczoPbYgM+QAAGdGhpaRGaNLi5v//Dc+ckKmszNDTEZtHv NzY6+mpgQG5f5Spbg4e61NUFb0upd23Ztm1dX59QcfyswRcvRoaH6+vrhep75TpU 9uzfL3S+nS/lstmcB3dDfPH8ubomhZ74xObn2SEScAQBGNChta1N6BzXpqamf/zD HyQqazM4OFjy2s4omlmWdePKlbRhCC4DjsVMO7bC6uruzltWm9ipxcdPnZJLX/hZ qr9++8YNuSnuiXjclikhkWjUMAyh3QerFvcDu/DFF0LFfSljGJYHz0D6/sGDTCYj NJGeKdCAUwjAgA6im+Ke//TTvvXrJYrr8erVK6eb4AG3rl1T2UDuQJcqmwbfROed 5nK5jy9elKiMlbv89ddym5zZNRtf9CAupaGh4ejJk3L1/cfw4KYP6pb76uXL+vp6 r2x7DmCFCMCADp1dXXKr5gzD+OTChR27dgnVF6X6u4ODg063wgMGnj0bHxmROw24 arE3ZuXz+cpGaUQXANc3NBwjdThN+llM5Q9iIpFIWmyr6rINmzZt3LxZrr7/JONx b830mZ2ZeT00lM1m5Y7R4gwkwCkEYEAH0dM4qhZjZDgcPv/ZZ3LZQ0ixWBwaGnK6 FR6Qy+VU8KhZJPcqyWSywp1aRRdehiKRnWw75LRH9+9PT0/Lja9Wngqkh3/VXevk mTOia/J9Rn3FUt45A8k0zRfPn6cNo7mlRW4TtSoCMOAcAjCgQyQa1dBbymWzh44c OXL8uOh7tr0KhcLr16+dboU3XL982TAM0WOfVT914aDmtfbJOru6Cvm80AJgZeee PaFwWKg4Vmjk9euhV6/kbmgVLgMORyK1tbWiz4mqqqtPffihYH3fyVuWjQetycnn 8yPDw3MzM5Zlic4gKCMAA07xTC8Z8DQVgFPJpNBJSG8pFIsHDx06ePiwJ2Kw6nAM Dw873QpvePr48eT4uOhUgqrKzgRW17ncGLVK5p9euuSJq9rfLNO8cfVqKpUSmhq6 8BQmkVjb2shQOKyii+hDIqW3r69/2zbRl/AZM5dz+W5P6p1odGRkthx9Zda3v4Ut oAEH0ZMAdFDR1zRNPW+rZepdfPfevUePH3f5lrmqnSMjI063whty2eyt69elZ0FX VTAuIboAmGE397h++XIymRTa2b6qgitQerFJFfOf10R9Ny3TdLoVy1NvzcNDQ7FY TGVgne/RBGDAQQRgQBPpQymXZRjGlv7+w0ePRnt6NL/0CqnOx+joqNOt8IybV66k UqkW4QGuhb6gtbAf1mr/H1X3Ua5tnd3de/btEyqOVXlw9+7szIzcxn5r2x03FA6n 02m5LYvKamtrT5w+LfoS/uPOLaBTyeTrwUF1zaibnfRl8y7mPwMOIgADmoQjEacG Y0ulUl19/Y5duw4cPOi2AeFcLjc2NuZ0Kzzj1cDAyPCwhq3OEvG4qTLwanaEjvb0 qK6k3Kjg9l27ItGoUHGsyvDQ0OtXr+rEbiZrWAYsffkt2dzf37dhg/Sr+Il6A0rG 40634m8WnrqOjMzPzalM3tra6tSqCgIw4CACMKDJwjJgsVVzK6QasHHjxh27d2/f scMlaymz2ez4+LjTrfCM8vJLuVNY37TaxcCiJwCrxnx66ZL03G+skIoQNyWXAa/2 NODuUCifz0sv/VUymcwnn37qkpunVxQLhVQy6XQrFlb5Tk1MzExP53K5fKHg7Htx LBZTXxbTrdPCAd/jJg7o09be3iZ2eOaq5LLZDYtJeEt/v7OdOdWhnJiYcLABniM9 +/RNyUTCWHEGFl1+qRLR6XPnhIpjDa59+60KwC5ZBqxtgUlHV9fe/fs1vJCfWKbp 4FCnyr3TU1Mq92azWZU5NeztvBJrm+QPwC4EYEAf2S2C1iSXy23YsMHBJJxOpycn J/W/rnelDeP2zZviB738aOUZWGWhVrHnO6rbuvfAAaHiWIP7d+7Mzc66YRmwtvRb LBaPnjwpesKwL2UzGTOX0/yi7sy9S5j/DDiLAAzoE4lGVXpx2ztxmUrCfevXb9u+ fduOHTonmqpwNTU1pe3l/OG769cTiYS2PdVUBs6Z5vvXA0d7eoxUSu7a3rp9e8+6 dULFsQZDr14NDw3J7SmwkgDc1d2tso30nnBLGhobj544oee1/ETdGQqr31FvbSzL mpqcnJudVam7WCy6892W4V/AcQRgQKvOri49k1fXTCXSvr6+zf39O3fvlj5QpGrx cNeZmRnpV/EZ1X96cPduXV2dtkF7lbdz2ex79nGNRKNyB8Mk4vFPf/ELFgC7ipnL 3bx2TfR48/ePknWHQirtaFtUUiqV9h086M5A5WYLO2AlEuoP0VcxTXN8bCw2N6c+ cHx9789i+BdwHAEY0ErlBJUwO73QiyoWi80tLRs3bdq9d6/clksqWc3OzgoV97Eb i+chadj1Z4lK3VXV1T/Vb5N9ssMJwK7k4GnAKv3mslmdcbS6puaDM2e0vZxviO6A pS6P0ZER9SZSKBRaWlo88YxM3UitNR0yB8BGBGBAN/cPAr+lVCrVVFev37hxx65d fevX21tc9XHn5ubsrRkEsbm5h/fv6xwErlq8ElTqtkzzrc1L1SWtOqByY3FdodDu vXuFimPNvr93b3p6Wu5utuw+5A0NDc0tLU1NTZqv/D3798uNdfuY7Ttgqeg4Pzc3 Mz1tGIZK123t7d7alJvhX8ANvHTXAPzBzSuBf9auPXuO2boKLhaLzc/P21gwOG5e vZpMJnUOApclFo/0fPOYVtEDkBSVPTrdPacxmMZGR18NDMhNfV84DEmlhTdWS4ZC oZxpajjs9y21dXUnTp3S/KL+kE2n7T3sZ+jVq7m5OY9uRRaPxdRX4z1rSQDoQQAG HNAdCjU0NHjruXXZhk2bPvrkExsLqvSrMrCNBYNDZYP7d+5oHgQuW1jXl0yq38tD GaIHIKmkfeHzz4WKoxKWZd28elV08zN1kZcftTS3tKhLvaWlxZGrff+hQ+3yJ2/7 UiqZLNqa9waePUskEt6aRVW22tOtAcjxXv8b8IeOjg5tm5fayPYAPDc3F18cUcQa 3Ll5Mx6LNevaDvotCzOiVe+2WKyvr5e7mBsaGo6ePClUHBW6de2ayqhyx18lE4ny BdbsRPQta2puPnzsmCMv7XULT8rsvr17NwCv6lh1AKIIwIAzIpFIOpOR21xKiO0B eHZ2VvVmbCwYKNlM5rsbN5ydUV9a3N9VLpz0rl/fv3WrUHFU6NnjxxPj43Lj/9JX 188yUqmPL16sEzvtyd/y+Xw6lbK3pkcDcDweN3M5Jj8DLkEABhwTCofT6bTLD2x4 y6YtW85+9JGNBWdmZpJie4QGwdPHjyclE4izVP45evKkX/91PqDuYHdu3hRdAe6s 3r6+/m3bnG6FV+WyWfXL3povnj9XYdJbATgWi+XZ+RlwE3++YwFe4bnFwLYH4Onp 6ZTdQwSBYlnWd9evG4ah7UBUnVSX8aytMw5guyvffJNJp9u0b0ylQbFYPGPr7S5o 0qmU7anPcwG4fBJymqW/gJt4ptsN+FVXd3djY6NXMrDtAXhqaoplURVSvat7331n eG02wUq0dXTsP3jQ6Vbgfe7dvj03O9vi0EJ0OYlE4twnnzi1wN4HJBYAV3ktAJeP jjN4yAu4jDf63IC/eSgDb9m69czZszYWnJyc5NF45R4/fDg1OenRo0HeY/uuXZFo 1OlW4H2Gh4aGXr2q990q2Uhv7/YdO5xuhYcV8nmJ4PdyYCAWi3kiAJN+AdfyQIcb CAKvZOD+bdtOf/ihjQUnJibePOcTa2NZ1u0bN1Rny08ToQ3DuPD55+7/oQg4yzRv XLmSTqc9erb5skpVVadtfdIXQBILgKu8E4BJv4Cb0bEA3KI7FFLdBZd3Im0PwOPj 41mBTlIAqQSiMnDGRzmEA5C8QvowJM3ShnH2/Hl1+TndEG+TWABc5ZEAHI/Fqqqr OfIXcC0CMOAiKgNbpunm7WRsD8Cjo6OmadpYMMhmpqcfP3hQ76lt1d6jb+PGzVu2 ON0K/LznT5+Oj476Y7PuUqm0Y/duJt5XSGgBcJUXAnAiHldvauz5DLiZHzpJgJ80 NDQ0NS9wZ4bZvnPnyVOnbCw4MjJiWZaNBQPu0YMH01NTPlgMrDrQx0+d8t/KUl/K ZrPfXb/uj8OQusPhXXv2ON0Kz5M4Abhs8OXL+fl5d97iFqY9J5PqHY2nuoDLef69 CvClUCiUzeU6OjqcbsjbbA/Aw8PDPCm3kep73b99O5lIeH33WhZhesu1b7/1wVlc DY2NR0+ccLoVfpDNZMxcTqKyawNwPB6vXlyK4nRDAPw8AjDgUnX19S0tLeptvqam xum2/I3tAfj169eFQsHGgjBN8/aNG6of1tra6nRb1o6BOG/5/v79melpF8aSlStV VZ368EMfDGK7gZFMCt3YXRiAi8WiYRi5XC7PbCbAI7jRA67W3NJSV1enkrBLumU7 du068cEHNhYcGhpSvQcbC6Jqcf/VWzduZNNpN68nf49SqXTg8GGPNj6YFg6jvn1b 3axccqdaLcs0z3z0UW1dndMN8QN1S08lEkLFXRWAy3Oei6US+10B3uLJNyogaLq6 u/P5vBumF+7eu/fo8eM2FhwcHFR9CBsLokx1yG7fvJnJZNo9GCMtyzp3/rzTrcDq XP76a49eb2Yud/rcuXq2fbaJZZpygXBocHBudtYNATihQn6pxJxnwIsIwIBndHZ1 FVQMdrR/aXsAfvXqlY3V8Ka0Ydy5dWvhgFb3LSZ/v7aOjv0HDzrdCqzO/du3Z2dn W7y2+Dyby505e7bBF1tYu4S688hNBnZDAE7E46XFh4wOtgFAJQjAgMeo/mVNbW1r a6sjUw3tDcClUmlwcNCuanhXOQN7blxu19693aGQ063A6owODw++fFnnqVnEZi53 ivRrq4VZwYmE3LweBwPwwtlOySSjvoAPEIABT1pYG1xba+XzXV1dOl937/79h48e tasaAVgDlX7vLM6FdsMU+pXIZLPnP/3U6VZg1SzLunn1qmEYXplxUCgUTp45w1Fb 9pI7AKns9dCQCsCaD52OxWIL3eXqakZ9AX8gAAMeVldX19rWpjoc2sb39h08eOjw YbuqEYD1MHO5hbnQhtHihX2hm1taDtn3kAU63bl5MzY/74nLrKam5vipU67aY98f 5A5AKtMcgMuznS3T5Lg+wE8IwIAflOdF5+UHhAnAHqU6cN/fvz8/P9/c3OzyfXr7 t2/vXbfO6VZgLQZfvhx5/drlY6rqtqNumAePHnX5D4JHJROJkuTG/noCcHnIV10h zHYGfIm7P+AftbW1zYs70MitELY3ABeLxaGhIbuq4WeNDg8PPHuWzWY1z5xfOSOV uvDFFyQTj7JM88bVq2nD6OjsdLoty0skEnv379+4ebPTDfGnQqFgJJOiLyEagJdW +eZyOQ6oB3yMTgbgNwubRRcKQgs+CcBeF4/FHty9m8lk3LlQs6Gh4ejJk063Amt3 69q1RDze6soF55ls9sQHH3C+tJxcNqt+ib6EaABOJBJpw5CoDMBVCMCA36gALLcq mADsA7lc7uHduyqlNLe0uG2sddOWLes3bnS6FVi7lwMDo8PDDS47U7dUKjU0Nh4+ dqy2ttbptvhZKpEoSs5/rhIOwLFYLJvJSFQG4Cru6voAqJyHAnChUHj9+rVd1bAq E2NjTx8/NnM598xWTaZSFz//nH2JPM00zZtXr6ZSKfdMs1eN2XfgQN+GDU43xOc0 zH+uIgADsAMBGPAbAjBWKJNOP7x3L5VMumQouL6+/tgHHzjdClTKPbOgS6VSXV3d 4ePHXb4vlz9I7/9cRgAGUDnnezwA7OWhAKzaOTw8bFc1rM3M9PSjhw+tXM7xtZEb N2/esGmTs21A5V48fz42MuL4LOhcNrv34MFoT4+zzQgO6f2fywjAACpHAAb8xkMB 2LKskZERu6phzSzTfP706eTERN6ynJoRnUwmL37xBfOffcDM5W5eu+bgLGiVxDb3 9+/cs8cN8xoCopDPG6mUhhciAAOoHO8NgN8QgLE2uWz2yaNHqnNpmqb+6FJXX3+c +c9+cfPqVZVC9c+Cjsfj6zdu3LtvX21dneaXDrhMOm2ZpoYXIgADqBwBGPAh1e/0 RABWQWt0dNSuarBFJpN58vDh/Py8ZVk6Y/CGTZs4ndU3Bp49Gx8d1TkLWkXf3r6+ fQcOsNxXv1KplEok1O8aXosADKByBGDAh7wSgHO53NjYmF3VYKNsNvvs8ePZmRk9 k6ITicSnly4x/9k3dM6CTiYSfRs37t67t45RX4dYlpXRdXwuARhA5QjAgA/JBeA9 +/YdOXbMrmoEYJdTMebFwMDk+HghnxfdIktFl+OnTsnVh34aZkGnDWPjli3bd+7k 0Ymz1Dcib1l6XmtocHB+bo4ADKASBGDAh9ra2oTiyu69e48eP25XtWw2Oz4+blc1 CLEsS2XgkdevDdXNzeclxvTWb9y4acsW28vCQQNPn46NjkoEFZVSOjo6tu/a1dPb a3txrFaxWEwlEtpeTgXgudnZpqYmieLxWCxDAAYCgAAM+JBKv20yAy87du06Yd9O RaqrMTExYVc1SMtlsy9fvJianMxbVmtrq11b7CYSiYtffFFbW2tLNbhELpe7Zess 6FKppGqu37hx2/bt7HHlHuq2oH5pe7nBly/n5+cJwAAqQQAGfKi9vV1o5uH2nTtP 2jdVNZ1OT05O2lUN2qQN4/nTp/Nzc/l8vq2trcIkrMLMB2fOFOVPEIVmN69cSSaT Fd6LVO7NpNO9fX3bduxoam62q22whfruGMmkzh9eAjCAyhGAAR+SC8Bbt2079eGH dlUzDGNqasquatBPJeEXz5/Pzc6qJNzS0rK2pZjMf/ar50+eTIyNNaxpFrTKVDnT XNfX1791K7nXtdQPflrL8b9LXg4MxONxAjCAShCAAR+SC8D927adti8Ap1Kp6elp u6rBQblc7vXg4MzUVDqdVtFFXYErHBZWf/nkmTPs3+tLuWz21vXrNYtW8vcXTtNJ pVpaWjZs2qR+cVW4X8YwLF3bX5WpAByLxZplnokQgIGAIAADPtTe0dHa2ipRedOW LWc/+siuaslkcmZmxq5qcIlUMvnq5cv4/LzKP8VS6f1huLa29sTp0zqbB51uXLli qEz707ejcuhtbGyM9vaq24vQjQsSNG9/Vfbi+fN4PE4ABlAJAjDgQ4IBePPmsx9/ bFc11Y+Zm5uzqxpcKG0YQ4ODsdnZTDZbyOdVHn5rS6T+7dt7161zqnmQNj42phJL 3jSbW1qWPhmLxepqa9Vnevv6Nm7a1CgznRXSNG9/VUYABlA5AjDgQx0dHe8ZcqnE +g0bPr5wwa5q8/PzqitsVzW4nGWaU5OTM9PTqWQyl8s1NTd/aN9sAriWZVnfXb9u GEZjY2N7R8eGTZvCkYhdW4jDKQtD94mE+l3z6w48e5ZIJAjAACrBOxDgQx2dnS1v jLfYqG/Dhk/sC8Bzc3PxeNyuagAAPSzTzKTT+l9XBWD1riH0BqcqO/KPAqAZARjw IbkA3Ltu3YXPPrOr2szMTDKZtKsaAEAPI5ksFAr6X/f5kyeJZJIADKASBGDAh+QC cCQa/ezSJbuqTU9Pp/QeoQEAqJD+04+WPHv8OKkCsMwaHwIwEBAEYMCHOru6hJZI dXd3X/r1r+2qNjk5maa3AQCeotKvysCOvPSTR49SqZTQLo8EYCAgCMCAD8kF4I6O jl/99rd2VRsfH89q30QUALBmhULBcG7pyuOHDw3DEDrongAMBAQBGPChru7uJpmT RVpbW3/zu9/ZVW10dNQ0TbuqAQCkZQzDsiynXv3RgwdGOt1GAAZQAQIw4EPdoVBj Y6NE5campt/94Q92VRsZGXGwIwUAWJVioZBydOfC71UANoz29naJ4gRgICAIwIAP hUKhBpkAXFtb+7/++Ee7qg0NDRWLRbuqAQBEqXxoOTpt5+H9+2kVgDs6JIon4nG2 pQCCgAAM+FAoHG5oaJCorG4Z//znP9tVbXBwsFQq2VUNACCnWCymEgln2/Dg3j0V gDs6OyWKMwIMBAQBGPChcCRSX18vUVl1gP713/7NllIq+qoAbEspAIA0x4d/lft3 76pmCAVgRoCBgCAAAz4UiUbr6uokKpum+W//8R+2lCIAA4BXOL76t+z+nTtGOt3V 1SVRnBFgICAIwIAPRXt6amtrJSpnMpl//8//tKVUsVgcGhqypRQAQJSzmz8vuXf7 dloF4O5uieIEYCAgCMCAD8kF4FQq9X/++79tKZXP54eHh20pBQCQ4+zZv2+6e/t2 JpNhBBhAJQjAgA/19PbW1NRIVC6VSv/y5z9XV9tw67Asa2RkpPI6AABR6VQqn887 3YqFx6ZPHj1S7262vAe9iwAMBAQBGPChaE+PXBfht7//fUtLS+V1TNMcHR2tvA4A QI6KnSoAO92KBfFYbGR4WO7xrpFaIFEcgKsQgAEfCoXDabFtQj7/xS/CkUjldbLZ 7Pj4eOV1AABCyrGwWCg43ZAFszMz42NjQgt8YrFYNpORqAzAbQjAgA+Fw2HDMIS2 CTn3yScbN22qvE4mk5mYmKi8DgBAiJnLuScWTk5OTk1MCJ1xMD83l8vlJCoDcBsC MOBD4Wg0YxhCJyWeOHVqx86dlddJp9OqN1N5HQCAhFKplEok1O9ON+QHY6Oj01NT DQ0NEsVj8/PZbFaiMgC3IQADPtTV3W3mckIB+MDhwwcOHqy8DgEYANwsm8mYbhoU HX79enZmprGxUaI4ARgIDgIw4E+tbW3t7e0SlXfu3n385MnK6xCAAcC13HP00ZLB ly/n5+ebmpokirMGGAgOAjDgTyr+trW1SVTesnXrmbNnK69jGMbU1FTldQAAtjNS qYILjj5608uBARVTm5ubJYrHY7EMARgIBgIw4E/t7e2tMgG4b8OGTy5cqLwOARgA 3MkyTReeiDvw9Gk8kbDlHL53EYCB4CAAA/7U0dHR0toqUTkciXz+i19UXocADAAu 5La9r5Y8ffw4lUwKvbURgIHgIAAD/tTZ1SU0T6y9o+PXv/1t5XUIwADgQpl02jJN p1uxjMcPH6o3DqHJTfF43IWD3gAkEIABf+rq7hbaKaSxqel3f/hD5XU4BxgA3CZv WWnDcLoVy/v+wQMVgIX2dyQAA8FBAAb8qTsUEjororq6+p//9KfK62Sz2fHx8crr AABs4drJz2UP7t1Lix1xTwAGgoMADPhTKBxuaGiQqGxZ1l/+/d8rr5PL5cbGxiqv AwCwhWsnP5fdu3Mnk8l0EoABVIYADPhTJBqtq6uTqKy6CP/+X/9VeR3TNEdHRyuv AwConGVZGbdOfi4jAAOwBQEY8KdoT09tba1E5VKp9Me//KXyOvl8fnh4uPI6AIAK FYtFI5l07eTnqsW3jKePH1cvkqhPAAaCgwAM+FPvunVCvQTlt7//feUnMar+1tDQ kC3tAQBUIm0YectyuhXvE4/FRoaHa2pqhOrHYrEsxyABwUAABvwp2tOjArBQX+Gz S5ci0WjldQYHB9084AAAQWDmcu7PfrMzM+NjY0Izm4rF4tTkpERlAC5EAAb8KRwO ZzIZod0yz5w7t6W/v/I6r1+/LhQKldcBAKyNugkbyaTTrfh5kxMT6ld9fb1E8Xgs lnH9IwAAdiEAA/4UiUbljos4fOzY3n37Kq8zNjaWy+UqrwMAWINSqaTSb7FYdLoh P29keHh2ZkbodIPY/Hw2m5WoDMCFCMCAP3V1d1um2d7RIVF81549x06cqLzO1NSU 4e5NRwHAx9y/9HfJ0KtXc3NzTU1NEsUJwECgEIAB32pta2tvb5eovGnLlrMffVR5 HdWbicfjldcBAKyWJ5b+Lnnx/Ll6v2hubpYozg5YQKAQgAHfUulXZWCJyj09PRe/ +KLyOslkcmZmpvI6AIBVyefz6VTK6VaswrMnT5KJREtrq0Rx1gADgUIABnyro7Oz 8sOKltXZ2fnL3/ym8jqqwzExMVF5Hfz/7N2HdxvH3e9/kmhEJbrcZMXdkS23xLEd dydxiR332I5rnifOzb3/5z3nd+/5/U5sWVa3bIm9gCgL7GI7fgMsxYePCsWygwWw 79dRaComZ0ewuDsfzMx3AGDvRv/U3+udPX1a7XQkvavLIcBAqBCAgYk1l89LWi02 Ozv7/scfH74dx3Hm5+cP3w4AYI/6ha86HXfcKvCfPnVKVVVJ+3oIwECoEICBiVUo FhOJhIyWp6enP/3iC1+a4iQkABgakX5F0huXwlc7nTp5Ut7RBgRgIFQIwMDEKpZK kk6MMHT9m2+/9aWp1dVVdl4BwHDo3a45nofPnfzuO13a4fZKq6URgIHQIAADE6tU LsdiMRkt93q9v331lS9NNRqNZrPpS1MAgF2MV9nna3z/73/H4/HpaSkDV2aAgVAh AAMTq1KtRiIRGS2LAPzpF1/MzMwcvilN09bW1g7fDgBgF5Zldcf23HXx0BEBOJFI EIABHB4BGJhYR267TdJYQYxF3vvoI19KTLuue+XKlcO3AwC4mbE79Ogahq5fOH8+ EokQgAEcHgEYmFgiAIuk6ss87fXe/fBDv85YWlxctMawIgsAjAXHcVSRfsfq0KNr tJrNxYUFSY8z13XXWYgEhAkBGJhY5UolGo1KavyZ3//+nnvv9aWper3earV8aQoA sJM7SL/jdeTv9VZXVkRGlVTVYooZYCBkCMDAxKpUqzMzM5IWjN3/4IO//d3vfGmq 2+2urq760hQAYJvruv3067pBd+SwLv/8c6PRmJ2dldF4r9dTFIUADIQHARiYWOVy WdM0SYdGiMb/+OabvjQlBh/z8/Pu+A/RAGB0iJuq1ulMxq31/NmznXY7lU7LaLzV bHIaHxAqBGBgkqUzmWw2K6PleDz+4Sef+NXa+vq6OrblSQFg1ExS+hV+PHVKU1VJ j7Nmszm+p0MBOAACMDDJcrmcpLfMDV3/5ttv/WpNpF+Rgf1qDQDCbMLSr3Dyu+9E RpW0oIkZYCBsCMDAJMsXCvI2TX3w17/61bgYqM3Pz497mRYACNzkpV/TMC6cPy+v pAUVsICwIQADk6xULssrm/ns88//6p57/GqNVdAAcEiTl36nKAENwG8EYGCSlSuV SCQi6V3ze++//3fPPutXa5qmrXESIwAcVP/EI1WdgJrP1/jl0qVmsymxBLQIwCyB BsKEAAxMslKp1JW2byqfz7/5zjt+tSZGIYuLi7Zt+9UgAISH4zja+J/3e0PnTp/u dDrpTEZG42wABkKIAAxMOHmFoIXPvvzSx9YajUaz2fSxQQAIA8e2NVWdyPQrnDp5 UmRUSkAD8AsBGJhw8gpBu64rAvDMzIxfDdq2vbCw4FdrABAGtmVpk1tAQTwXzp4+ PTMgo31mgIEQIgADE05eIWjhpVdfvePOO31skFJYALB3pmnqE13AaWN9fXVlJRqN SmqfClhACBGAgQkntRD0fQ888PQzz/jYoK7rKysrPjYIAJPK0HXxK+heyHX5558b jYa8t3EJwEAIEYCBCVepVuUdnzg3N/fWX/7ib5vLy8uGYfjbJgBMkl6vp3e7lmkG 3RHpzp4+rUqrgNUvAa0oBGAgbAjAwIQrVyqapuVyORmNO677xddf+9umqqrr6+v+ tgkAE0PENk1VnXDUzP/h++/7ZxnIeYQx/QuEEwEYmHzZbFbe2+cf/PWv/i5OE20u LS1ZluVjmwAwGVzX1Todd+IO+70h0zAunD8vbxETFbCAcCIAA5NvLp9PJpOSGn/y N7956Ne/9rfNdrtdq9X8bRMAxp1t293JPe7oekuLi7WNjXg8Lql9ZoCBcCIAA5Ov WCrJG0BUq9XXXn/d3zbF8G5xcdEOxwI/ANgL0zDCdmLthXPn2ooi6SS/KQIwEFYE YGDySa2DJXz25Ze+t8kkMAB4wlPy6hqnTp7sdrvZbFZG4/0KWCIAh+w9BQBTBGAg DKTWwRJjiPc//tj3JdZMAgPA1GDTb1fTQlLyaifDMC6cOxeJRGRtAGb6FwgrAjAQ CvLqYAmPPf748RMnfG+WSWAAIRe2Tb87LczP12u1eCIhqX0qYAGhRQAGQiFfKPhb q/m/NZ7Pv/nOO743SzloAGEWwk2/O507fboj7QTgKWaAgRAjAAOhUK5UotGopMa7 3e7fv/1Wxio1zgQGEEK9Xk9kMzvEb//Ztn329GlNVXNzc5IuQQAGQosADISCCMAi TM5JG0n87rnn7r3vPhktLy8vG4Yho2UAGEGO43RVNSQn/d7MyvLyxvp6LBaT1D7r n4EwIwADYZHJZjPS1pKJgP3HN96Q0bIYo6yurspoGQBGTciXPW+7cPZsu92WeAAS ARgIMQIwEBZStwEbhvH1f/6npFqda2trGgvVAEw0lj1vs237zI8/ileD9c8AZCAA A2FRqVYjkYi89p96+ukHH3pIRsuWZS0uLspoGQBGQb/as6b1wr3sedvy0tLG+no8 Hpd3CQIwEGYEYCAsRABWOx15b6in0+m/fPCBpMY3NzcVRZHUOAAEpdfrGbpuUulg B2/6l/XPACQhAAMhIvU0YDGMe++jj1KplIzGHcdZXFwMeVUYABPGdRyR9MT9LeiO jBBD18+fOxeNRiXtqZkiAAOhRwAGQqRQLCYSCXnt/+ree5/9/e8lNa4oyubmpqTG AWCYer2eZZrUu7rezz/91Gw2k8mkvEsorRZ1JYAwIwADIVKpVGYiEXlvq5uW9dXf /y6pfTFeXFpasqgQA2DMua6ra5pt20F3ZORsHf+rablcTtIlxKNEBGBmgIEwIwAD 4SL1MCThsccfP37ihKTGORIJwLjzJn5FDAu6I6NoYX6+XqvFZa5UUhRFU1V57QMY fQRgIFykHobU1+t99tVX8ppfX19XGbsAGEP9id9ul4OObsa27XNnznQ1LZPNyrsK 9Z8BEICBcClXKhGZq6CFJ3/zm4d+/WtJjYsR0uLiIpMnAMYLE7+3tLS4WNvYkHr6 UX/9s6IQgIGQIwAD4ZIvFGzLkvr+uuu6f/vqK4kFPFuter0uqXEA8Bc7fvfC2/3b 7XazMh9PlL8CMEUABkJI+iroqamHHn74yd/+VlLjVMMCMBYo9bx3Vy5fbmxuJiQ/ m1j/DGCKAAyEULlcjsg8YlEQI4wvvvlGXiETXddXVlYkNQ4Ah+c4js4Zv3tjGMaF s2f7xZ/n5uRdpdfrtRWFGWAABGAgjLK5XDqdlnqJQqHwxttvy2u/Vqu122157QPA wYigZei6aRhBd2RsnD97ttPppFIpqVeh/jMADwEYCKNiqSS10MjUYAj43Asv/Oqe eyS17zjO4uKi67qS2geAA7BtW9c0bk1716jX569cicViUtclTbEBGMBVBGAgjCqV iqqqUhebCaZp/u2rr8SwRlL77Xa7VqtJahwA9kWEXqPbpTzBvojHxHlv8XMuJ/VC rWazy2ZsAAMEYCCkRPqVvd5MyGSz77z3nrz2V1ZWdF2X1z4A3BLFrg7Gtu2L589r qpqSvCVnivJXAHYgAAMhVSqXo5JLYXnue+CBp595RlLjlmUtLS1xtCaAoDi23WXN 84Fc/vnnZrOZkFYucRvH/wLYiQAMhNcQSmFNDUYev3/xxWO/+pWk9sX4qdFoSGoc AG6mf8Bvt2uz5vlAxI378i+/xOPxIbwPS/krADsRgIHwKpXL8jbo7qRp2seffipp y7EI2MvLy6ZpymgcAK4nbjumYRjsvzgoVVV/unBB73Zll6LwUP4KwE4EYCC8RAAW A7hMNjuEa1mW9fFnnyWTSRmNi4GoyMAyWgaAa4i7ma5p7Lw4MJF7L5w/3xXpV3Lh Kw/pF8A1CMBAqA3hPKRtPdf96LPPJF2uXq+3Wi0ZLQOAx3UcEaXEx6A7MsZMw7hw 7pxIv8N573WK8lcArkMABkKtcuRIV1WHNhARGfiDTz6ZnZ31v+Veb2lpiQNIAMgg 7l1dtvsemqHr58+dG9rKoymmfwHcCAEYCLthTgJPDc69+ODjj9OZjO8t67q+srLi e7MAwqzX64nAZhpG0B0Ze11Nu3jhwtBWPnsIwACuRwAGwm6YO4E9erf73kcfFYpF 31ve3NxUFMX3ZgGEk8i9nO7ri3a7/fNPPw2t6pWH9AvghgjAAPqTwLFYbAhnUWwT g6FX/vCHBx580N9mXdddWlqybdvfZgGEjbiN9A/OodKVHzZrtfkrV3Rdz+fzQ7so Z/8CuBkCMIC+XC6Xkn8m8E5idHLnXXe99Oqr/jbb7XZXV1f9bRNAeDiO01VV13WD 7sgksG17/vLlZrM5Ozs7zPdYhbaiqJz9C+BGCMAA+krlciQSmZmZGfJ1o7HYO++9 529ZrFqt1m63fWwQQBj0XFdTVYcizz7Rdb1/2K+up4f77urUYDWQCMBdlq8DuBEC MIAtc/m8pHN6d6dp2kuvvHK/f8uhWQgNYF96vZ5lmoauc7qvX7xlz6ZhDHPT77Z2 u612OsO/LoCxQAAGsKVSraqqOsz6nNvEoFNc909vveVXPWoWQgPYC9d1RUgT6Zfo 6xfTNC9duKBpWjKVGvKyZ0+r1bIsizOrANwMARjAfxl+NaydOp3O08888/iTT/rS GguhAdyMiLu2bVuGwVIRH4kXc2V5eWN93TLNQCZ+p6h9BWAPCMAA/pu5ublkKhVg B6ZnZl557bUjt912yHZc111eXraYBACwg7gziHgm9Chz5at2u/3LpUuGYWQkHPO+ j25Q+wrArRCAAfw3AS6E3tbr9bLZ7B9ef/2QUZyF0AC2eVO+vCnmO73bFdE3wDXP 21qtlmkYlDEDsDsCMIBrFYvFWDwe7DhGaDWb99x//0uvvHKYGtGbm5uKovjYKwDj xStwJXIRJxv5ztD1X375pdNui1c4XygE2xkWPwPYIwIwgBsQQxl/jyY6sFardc+9 9z73wgvZbPYA385CaCC0HMfxClwF3ZEJ1O12r4jo2+mIu2s+nw+6O31UfgawRwRg ADeWy+VSQz+88WZEjk1nMs+/+GK5Utnv9+q6vrKyIqNXAEaQN+UrfrEUVgYRei// /LO4ryaTyeEfHX8zbP0FsHcEYAA3JqKmpmnBbga+Rr9wq+M88eSTjz722L5WaNfr 9VarJa9jAEYBU77y2La9urJS29iwLCudTge+R2Yntv4C2JcRun8BGDWFYrHb7Y7I 8radOu32sXvuefqZZ/a460wk5+XlZZNhMTCJtnb5mqZLBJJA07SFy5fbnY5j20Ed brSLZrMpMrnDcVYA9owADGA3IgPHR6Ag1g31R722ffyRR5546qloNLr7FxuGITLw cDoGYAjEHcBxHAo7S2KZ5tLSUqNet2171KZ8t1H4CsABjOLtDMBIERk4kUgE3Yvd tFqtXC732BNPHH/00V1GaY1Go9lsDrNjAGTgLF95vKXOmxsb4uW1HWcEVwDtROEr AAdAAAZwa3P5fDKZDLoXt+Yl4eMnTjzy6KPXzwn3er3V1VVd1wPpG4BD6lcBsPrJ l/WuvrMsS+Te+uamaRijn3s9FL4CcDAEYAB7Mjc3l0ylgu7FXomBsgi6Dz700FNP P70zuouh8/Lysvi3AfYNwL70lzrbIvlaVLfynWEYS/PzjWZTvMKZbHY01znfEOkX wIGNzZ0OQOBG6mCkPRJD5067XSqXf/vMM3cfOzY1qJjSaDSC7heAW+tv8R0caMSb Vj6ybbtRr6+vrWmq6rpuNpcbo9zrIf0COIwxu+UBCNY4ZuBt/X2Dtv3gQw/ddvvt U+M24APCw9via1kWVZ19pHe7y8vLzUbDcZxUKjU6R/juF+kXwCExBASwP7m5udT4 rIW+oV6vJ4ZQyWTyjqNH7zp6ND7aJb6AkOjXdR+sc2aLr18Mw1hdWWnW6+ITt9fL jeFk7zVIvwAOb7zvgwACMV77gXfnheHZZLJQKt197NgInnIJTDavtJVgc5rRodm2 LW5ojUaj3WoZgyrZ47jC+WZIvwB8MSH3RABDNpfPz87OTsy4apvSasXj8XQ2e9fd d1ePHBnfVYLAiPuv0lYi97LF9xDEC7hZqzXq9W63KwKwCL2T90Zev5pDp8OJRwB8 MWmDVwBDky8UEonE5GXgba7rapom/oxiNCnycLFUCrpHwNjr595BaSuRfSltdTAi 5bYG1fzanY41mOZNZzIT/G4d6ReAvyZ25ApgCArFoqHrkzfbcENiwBmNREQezuRy d9x1V7lSmeARJ+AvkWFckXsHW3zJvfslXrZGvS5uQV1VFZ87juP2emNxVO/hiag/ NT3d1bSgOwJgchCAARxKqVwWGTiTzQbdkWETg3gxJpsrFMSfXYxEC6VSLBYLulPA yNk6ysiyeq4bdF/GhmmaG+vrSqul67q3RHy8Dun1i3gFDMNwKAYOwFehu5kC8F0k Ekmn0+N7PJIvRB7Wu93ZVEq8DkJubq5QLEaj0aD7BQRje52zS+69FRF3N2u17bjb z3u93iQVrzqYtqKIF4T0C8B3ob63AvBRvlCYnZ0NuhcjpB+JdX02mRSROJPJZLPZ XD6f4MglTLTtdc7k3huybVsdbGdtt9vE3V2I14dNvwAk4W4LwB+VajUSiQTdi1En hnSJ2VmRipODqWIx6s3NzTFRjHEn4q63ztllvu6qaCwm4u7a8rIism632z/f2HHE C9UbnCQXdO9GXavVYt8vAEkIwAD8Ua5UCHIH0N9L3O32U/EgGKeuBmPxedBdA26h n3styx5Eu6D7EiQRdL0yxeKXruvit/2sO3hNmNo9GAIwAHm4KQPwR6lcpgqUj5RW S6TifjBOJGZTKW/GOJPNsogagRO51x6scw5n7jVNs60o/VOI2m3xOjiu2xO/er18 oRB01yYHARiAPARgAP4olkrxeDzoXkw+r/p0TEj00/EgFveJjyxBh1RbuVdEPtsO ui/SiT+s+EHTul3xUe92zcECb/EHFz9xzOgOAQEYgDzcxAH4gwAcLBGMVVWNi2Ac H+jPHA+2G6f6xEdG7TiYSc294kfGMAwRbo0Br3ZXf0V3/392JpPhRyZABGAA8nBz B+CPYrEYZ3XuqPLmjaNePPY+Jga2CnKl+G+Ha/QG+3vHOveKzuu6bui6N3/rHcsk wq09qL3MXO4oU1otjQAMQA5u/QD8QQAea67riqgQjfYz8pZEYisme2Wrk0mKnIVB r9fz6lrZo517RSz3Zm63wu1g5ta+SvzbZCo1MzMTdDdxQARgAPIQgAH4gwA88bZC ciQSGQTkfloeTCdvLbu+OqUsPjCxNnZGJPf2u+El2u1Y6xnM2XrJVnxCuJ14BGAA 8jBGAeAPAjA8IsN0Op3IzEw0FouIkBzti3iBeVt8KzKL/1G7K0DiP5Z9dfpU0iVc 1zW399ZeDbSOd1LQ4IPjRVvbdnu9bDbLuyeYIgADkInHDAB/FIpFTujBAYgMpqnq dCTSn1vuZ+XBh8Ev7/Po1fAcvVrhS/yDCcDDOFju7VfDGkzGejl2a0p2m0iw/dNv Xe9z73CgNKWkcCAUwQIgD48lAP4gAGNoegNifCzClYjIIgxvfRS8f/Szc//zrU88 0asRO+rNSke87wr6TyOdCK5eVBXZtb9rdlAUyu1nVXc7sroD4svEC7v1+8En3peI V9wrGUWaxXAQgAHIw5MMgD8IwBhHXpZWVVU8DkW6E+FZ/GNm8GvKC3wzM/1/dTUn zwx+KzJkIL1NzM72BoF2q/MipXofez3xJ3EHv6YGwbX/p5qaSpNaMZ4IwADk4aEI wB+cAwwA8AUBGIA8BGAA/iAAAwB8QQAGIA8BGIA/SuVyLBaT0XKv12MNJwCMGnk3 ZwIwAHkYUwLwR7lSiUajMlpWO514ImEYhrehUcYlAAB7JHKvPtgGb5lmbm5OxiUI wADkYSgJwB+ValXSga5ipPX3b78V46H/7//8n8XFRcuySMIAMGT90uvdbrFUuvOu u+Lx+Ml//1vcnAnAAMYOI0gA/pAXgF3X/fzrr7d/KwZG/8///t8ry8uzs7PEYACQ TUTfeCJx97Fj24UebNs+d+bMoEq6lIPEWs2mCNsyWgYAxo4A/FE9ckTekaoffvLJ NRW2NE07+d13ly5eFJ+4jpMvFCRdGgDCqdloiNx7+x133Hb77dfc3tuKsjA/L+8t SAIwAHkIwAD8IQKwvBNHX3/rrWKpdMN/ZRjGzz/9dObHHxv1uuu62VyOaWEAOJhe ryfCbSqdvuvuuws3f2Oxvrm5vLQkadWP6MPa6qqMlgFgigAMwC8ioHa73Tk5+8Ge /f3vf3Xvvbf8MqXV+n//7/9dXFgwDSOTzZKEAWAvRObUVLVcrd5x5517OdBudWVl fW1NUuV/pn8BSMXoEIA/SuWypmmSAvAjJ06cePzxvX+9GDydOXXqp4sXO+224ziS yrQAwFhTWq3ZZPL2O+4oVyr72sMyf+VKfXMzkUjI6FWj0TAGVaYBQAYCMAB/5AsF 0zRzuZyMxo8eO/b8iy8e4BsNw1hcWLh08eLK8rJlWalUSt5GZQAYfa7r9qs353Ii 92ay2YM1Im6qrVYrmUz62zdPs9HQCcAApCEAA/CNGEtlMhkZLRcKhTfefvuQjfSn hX/88fLPP7eaTcdxWCMNICR6vZ7a6cwmk0duu22/k703dO7MmU6nk06nfeneNVgC DUAqBn8AfJPL5VJyxkOxePyjTz7xsUGl1fr+3/9eWlxUVdVljTSASSRudPFEolSp 3HbbbXvZ2bt3P/7wg6Zp2YNOIO+OAAxAKgIwAN/M5fOSVsQZuv7Nt99KadkwLpw/ /9OFC0qzaVmW67qEYQDjS4TeWCyWyWZvu+MOSXtShJPffad3u5Lulq1Wq6tpMloG gCkCMAAfFYpFSTVRer3eex9+KGl6WajVau12WwTg2sbG2sqKGEFapkkYBjAW/iv0 3n77EO5auq5fPH8+EolI2kVCAAYgFQEYgG/KlUo0GpXU+FNPP/3gQw9JalwE7NXV 1Z1lV0QY3tzoazUahmH0XJc9wwBGhLen1wu91dtukzfTe0PLS0sb6+v+rqneiQAM QCoGcwB8U6lWZ2ZmJKXEO48effHll2W07HEcZ3l52bbtG/5bkYGXFhZqGxuaqtqW JUaf2VyOPAxgOMQ9p60o0Wh0NpkUd9pSuRyJRILqTH/PiKJI2vAi/qQiAOvsAQYg DaM3AL4plUpdabvCErOzH3z8sYyWt5mmubKy4rruLb9S/DGX5+fr9bqmaSIPuyIP Mz8MwD/9xNtux6JRcesTcVf8isViQXdqy+lTp1RVpQIWgDHFcA2An9KZjKRRUafT +ce//iU7ZOq6vrq6Koae+/ou0zDWVlcb9bra6RiG4di2SNEiFefzeUn9BDBJms3m zPR0NBqNJRLJZFLEXXH3GM1Dy23bPnv6tLghS7q/iZeC6V8AUhGAAfhJ3klIwnMv vHDsV7+S1Pi2brcrMvAhG7Esq9loNOv1drstBnPityIVOyIUi19TUwRjIJxEuhMD r5lIJCp+xWLxRCKdShXLZUkH6sqwtroqfsmbjmYGGIBsBGAAfsoXCrOzs5Iav+32 21/5wx8kNb6Tqqrr6+syWhZJWAzvOorS6XQMXTdN0x5wB3qD1de5uTlWUwPjqNfr Ka2W+PmdnhEhNxIRH6N98Xg8mUoVCgXxMeg+HtbF8+cVRUlJ+4NQAQuAbIyxAPhJ aiFoERE///prSY1fQ14G3p1IyG1F0btd0QHxUSRkS4Rkx+lPIDuOF5LdXk/cuzPZ 7MzMjBgsTjGlDMjRbDbFx7m5OfFj12m3e1NTM9PT/WQbjUYGU7jidpdIJGaTItim iqWSl29FDBY/tl71+KD/BP774fvv+7UepNWdJgADkI0ADMBPIgDL2xsmhpV/eOON arUqo/HrBZWB98ULzGqnIz6KUakYc9uWtTWl7DjT09NUqwZ20Z+zVRTxE+Jl2lgs JgKtyLGZbLZcre53nlMkXtPsZ9/91hEYF+12+5dLl0Tsl3RXYQMwgCFgVATAZ/Lq YAlHbr/91aGsgvaIDLyxsTG+Y9mtFdftttbpdHVdjMtZcY1QuXZN8iDixhOJ2dlZ cacSETeTyfhyIfEDJX6+xC9fWhtZF86fb8tc/0wABjAEDHoA+EwEKnnDI13Xv/nH P4YZ2Lrd7tra2vhm4N2ZptlsNFQRjzVNvLaWYViDtdb9QtY9b7V1f7k1IRkjyAu3 4iczMjMj8u1gUXK0X1kqHhcBV9yFSpXKEM4nEz8upvjZsSypVxkFtm2f+fFHca+Q dNbdFOufAQwFAxoAPiuWSmIAKq/9E48//siJE/Lav55hGKurq3s5H3giWSIkN5ua qmqatlW4y7JESna9X71+UO5/GETluXyeqIzDEH+XWoOdtyLTzngzt+KTaHSrbPJ2 uC2X05lMsH/ZRCAU0Vd8DLAPw7QwP79ZqyUSCXmXIAADGAKGKQB8Vq5UZgYktS+G vJ9+8YWkxm/GsiyRgcMz0j2Y/nxyvS5yshjCbpXvGnAcp7e16npgcBbU1KC2EGk5 DPqZdlCtTQTa/g/w9HQ/03orkqPRWH/WNhafnZ1NJoulUnZQ3S3oLu9G/HG86Cv+ Ygfdl+ERf+RzZ892VTUjbYeLuEN4tQwktQ8AHkYeAPwnRkh+7ay7oaefffa++++X 1/4NicHu2tqaMel7/IbGK99l6LpXu8v0Vl9vV/AaFPHyJpa9GebeIHiI7ERsDtBW lBX/NaanZwZR1punnRr805up9eZpvalaoVAs7jz7R/z39oonB/inODCvvLP4uxrC 9SAry8sb6+vyjv8VFEXRVFVe+wDgYQwBwH9z+XwymZR6ic++/FJq+zckhr+1Wq3T 6Qz/0vCI2Nxpt0Vg1gc1vayr67G3j4naru/V2zaozdufc76aoqe8IB2m1driT91W lK3U6kXVQXrtDabdxOszvf3/D3hzs96q42g8Ppvo65/yfaOfa/GfoKtp8URC/JrU l9SrcSX+vk1qOYDdDWH6d4r1zwCGZTIfVACCValWxfhZ6iUeOXHixOOPS73EDXkz YI1GY/iXho9EkNZUVQzrxSf98OyV/nLdnUF6e/55yvtkavCfv9cTf7el7nLfpc+i w9PeKuLBFtnp7Y2yU1Mis/Zj69Xs2g+xUW86NpZKpURy29nUYM1x3MfDbLzJeV+a GjXir4R3uljQHQnS4sLCZq0m+689ARjAcEzm4wpAsKpHjnQ6nVwuJ+8Suq5/8c03 Utfj7ULTtPX19XDOBWHs9Kd/B1tw+7k3FhMfJzWs+qi/0deyTMMI1UbfG7Is69yZ M+KmJ/WWTvoFMDQ8AgFIIfUwJM9cPv/WO+9IvcQuTNMUGTgMZ59gAti2HYlEyL17 0XNdc7DRl3e4PD+dP6+027J3tRCAAQwNz0IAUpQrFdl1bsTw9LfPPPPAgw9Kvcou XNfd2NjQGLQBE6F/ou9go2/QHRkhIpde/vnnmPxVAwRgAENDAAYgRfXIEVVVszIr pkwNFkJ/9Omnsq+yCxHCFUWp1+tBdQDAIYmfYse2RfTlnLNrmKZ5/uxZ2YufBaXV 4p1EAENDAAYgyxBqQQuRSOSDv/412FNVRA7f2Nhg9AyMF2+1s2WaITzW6JbEDe3C uXNdTUul07KvxfQvgGEiAAOQpVwuR/wrM7uLfLH4+ptvzszMyL7QLhzHqdVqTGIA Y4HVzrd06eJFRVFmZ2dlX8hbR0MABjA0BGAAEuVyuSHMHojx01133/3CSy8FXuPH Ww5N7RxgNFHbeY9WV1ZWlpcTQznYua0oqqrKvgoAbCMAA5CoVC4P56QiMa6978EH f/fMM0O41u5M09zY2DCZWQJGies43mpn3p+6pY319aXFxXg8Ppy3FFn/DGDICMAA JKoeOaKpamYoRarEuPaBhx/+7dNPD+Fat+xJo9FoDU5eBRCgrSlf03TYor83/fS7 sBAfytzvFOWvAASBAAxArkKxmEgkhnMtMdi99/77n3nuueFcbnfdbrdWq1EZCwgE U74HsNZf+Dyklc8epn8BDB8BGIBclWpVVVXZp2hsE4NdccU/vvHGcC63O9d1G42G oihBdwQIC6Z8D8a27Su//CLi6OzsLOkXwGQjAAOQbpiTwB4xhnvn/feDPRtpG1PB wBA4jmMx5Xsg4kW7cOGCPpQTj3YiAAMIBAEYgHRDngT2WJb1lw8+yOfzw7zozTAV DEgi4q6XeynsfDCdTufSxYuGYWSHUqxhG+kXQFAIwACGoVgqxePxIV9UDLCe+u1v nx6B0tAeXddrtZpI5kF3BBh7Ivc6tt2PvvxAHZRt20uLi5u1mki/w3+vkPJXAIJC AAYwDKVyWYyxMpnM8C8di8XeeuedIS/tuxkxahexvNlsskoTOBjXdft7fE2z57pB 92WMdbvdSxcv6rqeDuLeqCiKxtm/AAJCAAYwJMVSSWTRoZVX2UkMth49ceK5F14I 5OrXE2P3zc1NMfQMuiPA2KC6lV9s256/fLnRaIgXM5BNIuI/pbgns/4ZQFBGYiwI ICTm5uaSqVRQVxej5+dffvmee+8NqgM7iSFgp9Op1+sus1jAzfWXOl+tbhV0XyZB o16/cvmyiL5D3vG7U1tRVKZ/AQSHAAxgeMqViqaqubm5oDogBtPRWOyV116rVKtB 9WEnMbJvNBrtdjvojgAjZ+sgX8tiqbMvOu32L5cu6YaRTqcDXAvTajYt27bZuQ0g OARgAENVKBbj8XiwS5FFDE4mky+8/LII5AF2Y5uu65ubmyYTXID48XRdEXqp6uyj Tqdz+eefxX0mlUoFfu9l8TOAwBGAAQxbbm4uFdxC6G1iKJaIx5978cXb77gj6L5s jQubzSYrohFO3hZfgblBHymt1pVffjFMM/Do62HxM4BREPzdEEDY9BdCa9qQjwW+ mf4horb9xJNPnnj88cAHiI7j1Ov1TqcTbDeAodne4ityL6XR/WLb9srycm1jQ3wS 7ILnnVqtlmkYTOwDCNxI3BMBhE2AFaFvRsTOe++77+lnnw2wNoyHFdEIg63SVmzx 9VW32124cqXdbovoOyJvMnpY/AxgdIzQ6BNAqOQLhdnZ2aB7cS0xSnNd9/Enn3zk xIkA8zkrojGpvFN8Re51mQn0j4i7qysrmxsb4pUdnSnfnUQmV1nbAmA0jNwtEkB4 5HK5VDoddC9uTGm1iqXSE7/5zf0PPBBUH6gRjYnR32swyL2c4usjkXs3a7X1tTVD 18XtIsAC+7tj6y+AkUIABhAYkTBNw8gEveR4d2LoViiVHnviiQcefDCQeRXDMOr1 uq7rw780cEhbpa1M0yb3+ke8mBvr6yL6ituCY9sjm3s9SqtlUtsMwCghAAMIUqlc 7mraiA/gPGIYJ/p5/NFHf/3II7FYbMhXV1VVxGBSBMZCP/fatlfaKui+TA7xeq6u rjY2Nw3TdEd4vnenVrNpcqIVgBFDAAYQsGKppHe7YzGY87iDc0qrR448/uSTd9x5 5zCv2xqgWC5GlvjRMHSd/b1+sW1bZMjaxkan0xF3gFQqNTMzE3Sn9qqffln0DmD0 EIABBK9QLHa73Xw+H3RH9q2tKOlM5t7773/k0UezQ6m5KgbEjUaDo5IwOnq9nmkY pmlSz9kv4n64srystFqWaYrcO0bvD25rNpsWc78ARhIBGMBIEBk4FouN0eTGNUQG UFU1lUrddvvtjz72WPXIEamXMwxjc3NTfJR6FWAXItuYum7bNksSDk+8jG1FadTr iqL0Q2+vl81mR7CY8x6J0N5utzn0CMBoGtd7K4DJM+4ZeCcxlp1NJoul0sPHj//q nnsikYiMq3Q6nUajwcZgDI1X1Kq/q5O/dYdmWdbm5mazXhdBUfwUj+lM7/XEH0QV WKUCYFQRgAGMkPFdC70LMRzUu91UOl2uVn99/Pgdd97p48SOaNw7MZhZOMjjOI5l GCKw8dfsMETKbTYarWaz0+l4K8bTmcxkvOW3TdyLZqanNeZ+AYwwAjCA0VIoFLq6 PmEZeCcxQIxFoyIPF0ulBx9++O5jxw4/P8yJwfCd67r9E4woYnQI4tVr1OviR15T VfG56zhurzfZNzfxd4Y1KQBGHAEYwMgpFIuGrk/GasBb6vV6nU4nHo+nM5lyuSwi 8e133HGwKWLTNOv1erfb9b2TCImeCL2OYw9ObWWyd7+8CV5FUdTBBK9j2+IVHOut vPtCzWcA4yIUN2UAY6dYLIoRZCabDbojAXBdV1PVWCyWTKXyhcJ9999/1913JxKJ PX67pmkiBlucv4q9EUFXhBYPxxftXf/9plqt3el0NW17nnzyljTvkdJqiReEuV8A Y4EADGBERSKRdDqdSqeD7kjwRERpK4oYWIsYLFJxbm6uUq3ee//9czeZJO9/fbvd aDRcjqXBjfRDryDyikhuhN5diRdJU9WOqqrttq7rXtbtv2jT07lcLiSzu7sTdyfx yvAXCcC44MYNYKTN5fOzs7OMMm+o2WxGZmZisVhcBONkMpvLFUule++7L18oTA1m ksUXKIrCWlZMDUKv62zN9bJO9XriZVE7/Zwr4q4hgq43JT7Qm+iNu4fh7eCg4DOA 8cKYEsCoC9WWYF80G43pmZlIJBKLRmOJRDQaTSQS6UymeuRIJjQ7EjHlhV7X3V7h PMVbIYPXxDTNbrerd7vra2vbtan6yyVE0B28eYS9aDWbU9PTHPYLYOwwDAIwBkQG FsP3NMuhD02M/pVWS2RgkZCjIiKLcBzrEwk5lUqVyuXc3NyMnFOLMTQ7Z3rDNv8v cqxhGKb4NeAVsrYGpYm99d6pdJr3gA5PURSDZc8AxhPPAABjYy6fF0Nb1iJKJfJS q9USn8wMQnJkZjCVLHKy+BCLiV+JeN9sKlUoFkVmDrq/2LJzprc3cXu/RXY1B7Wp ravB3gu0W5873oe+8FRdDkqz2Zxm4hfAOOMhAWCc5AsFMeoNZ3XoEbSVlns9EZX7 ebkfmWf6/xt8jAw+iQzy839NNg/yczyRyM3N7b20NW6of2rR1UA44gXP+vnci6mD pOrlVXdw6pI7+MT76Ax+2//D2N4HW/ypspkMmXZEKK2WMTjhKeiOAMDB8UQBMH6Y Cp4MXgUd8Rzqh+dIxJtznpnZ+qf3+dXf9D9MDT4R39jP2/1/THu/9Q6e8UL49m/3 aytAentBB33zFg/v/K23pVb8LxnQ1HdX06av/um21zZv/3mv+eMf5nXY/uNvfRR/ 6sFv3O3/03spdr4s2/+P9/nVT0J1Fu4EY+IXwMTggQRgLEUikVQ6nUqlGFgDgDz9 N6oGR0Cx4xfAZGDgCGCMFYpFyzRZEQ0AMiitVm+w9CDojgCAbwjAAMZePp83TZNz kgDAL63BmmeN6Atg4hCAAUyCaDSaSqcty5ojBgPAIXgH/FqmaVPsCsAkIgADmBxe DLYti9lgANgvoi+AMCAAA5g00VgslUoRgwFgj7ai7+Cw5aD7AgByEYABTCYRg9Pp tG3bWUpkAcBNeGWuiL4AwoMADGDCJVOpSCQiwjAHJgGAp9frtdtt8ZEKzwDChuEg gFBIJpPRWMyxbdZFAwgzb7WzSMDdbjfovgBAAAjAAMKFCWEAIcSULwB4GP8BCKNk MjkTiYg7YDqTIQkDmFT93KsovcFnTPkCwBQBGEDIJVOp2GBpdCabJQkDmAz/lXun ppjyBYCdGO0BQF8ymYzF4xyeBGCsscUXAHZHAAaALXP5vAjA2Vwu6I4AwAE1Gw1d 14PuBQCMLgIwAGwplcuaps0xAwxgbDUaDYMADAA3RwAGgC2VarWtKPlCIeiOAMAB MQMMALsjAAPAluqRIzMzM0H3AgAOpdVssgEYAG6GAAwAW8qVSjQaDboXAHAorVaL ys8AcDMEYADYUiyV4vF40L0AgEMhAAPALgjAALAlXyjMzs7KaLnX65/HyTnDADxS 7wkEYADYBaMxANgyl88nk0kZLUei0bvvvntlZaWtKKZhuK6bzmTYbwyEh+M4IpRG IpHE7GyxVNrY2DB0PZPJyLgWARgAdkEABoAt2VwunU7LaHlubu6tv/xl+7e6rl/5 5ZelxcXNzU1NVS3L6hGJgQki4q740RZxN5ZIpFOpSrUqbi8753vPnj6tdjppSQGY IlgAcHMEYADYIgaj2WxWRsu33X77K3/4wy5fICLxwvz88tJSvVZTVdU0DNtxpnq9 awbNAEZNr9drK8qMyLrRaGJ2NpPL5efmxK1k95/ci+fPK4qSSqVkdKnZbOoEYAC4 CcZVANBXqVbVTic3Nyej8Xvvv/93zz673+/qatovv/yyurLSajQ0TfNSses4YsDN YcXA8DUbjRlBZN1YTGTddDp95PbbS6WS+H+2v8axbXEnuWVTv1y6JGKqpKIDHAUM ALsgAANAnxjFdrtdSQH4xBNPPPLoo740ZRjGytLS+vp6fXOz026LYa5lmlvBeGoq n8/7chUgzEQ0nZmeFrE2Go3GEyLqzmZzuSO33SY+3vJ7xc/jXvbfLi4s1DY2EomE H/29FkugAWAXBGAA6KtUqzMzM5LWGz//0ktH775bRsvbRDDeWF9v1kUu3lQURQzB xf9jW5bIxj3XFV+QyWbZYwx4XNfttNviEy/l9md0E4lkKiV+TMrV6mFWJhu6buxh 9nVNWFkR1z3whXbR6/XUTp+MxgFg3BGAAaCveuSIvHz49rvv7mXuSB4RhsVou9ls Nur1drvd7XbFGN2yLNdxHNcVCbl/KMv0NBPImAzir7pIgd5y5Yj4KCLuYC43mUym 02kRcSVVnxL0btc0jFv3sNFYWlyUd8+hEDQA3AwBGAD6SuWyvNmYz778ctRqWS0u LooAvP1b8bna6YhgrKmqrusiMPdXVtu2Y9vuQM8dpGTxYfDkEHme+WQMk+M4nXZb /PXrr9MYrNbYyrfRvlg8nojHZ5PJVDpdKBYl7a3dC/ETZO/4yboZ8cN17swZeatO CMAAcDOjNSADgKCIQbOk/XiGrn/z7bcyWj4wEXFXVlYO/O1eWrYMQxvMJBum2U/L lmXfKC33rn4y+KxPBJe5ublRe0cAson/9CKVib8M0ztMiRx7NdAOEu0g0w6qTHnL kkWUTSST+UJB0o+n70RKdx1nL1958rvvdGl1BwjAAHAzjD8AoE+MsCXNGon77Kdf fimj5QOr1WrtwQbIQHj52RSxWWRmy3L6E819ruP9w3UHH9yra7O9NN1fpD0IUf2P VxN1/8P2J4OPOz/Zu+00fs0nW7/1otrWP6fdQQ8P9xochMiH6UwmGo1uvxr9V2zw 6nlvPRz+ddj+8+/yOux8Kf5bcL2aXr0E64nGYtFIJB6PZ+fmApyVHSal1Zra2yt/ 6uRJTVUJwAAwZARgAOjL5XKpdFpGy8lk8r2PPpLR8sGIpDQ/P3+QdIT925r0vpob D8k0DL3bFRnYW/croiYT6SOlfyawCMB7c/rUKRGAM3LOHqcQNADcDA9OAOjLZrOS 6uIUS6XX33pLRssH0263a7Va0L0IHW8q+5B7Pr23LQi9I8txHHXPayvOnz0rfhjT ct53IwADwM3wEAWA/vpnyzQlFWo+evfdz7/0koyWD2Z5ednYQ5VayODvhDBGjWVZ XVXd4xdfunix1Wolk0kZPWk2GvoeTmMCgBDiAQwAU+VyWet2c3IC8MPHjz/x1FMy Wj4A0zSXlpaC7gX6C9GJwZPHW6O+xy+ev3y5Xq9LKu7FHmAAuBkevQAwValWvVI+ Mhr/3bPP3nv//TJaPoDNzU1FUYLuBbawpHnC7PEQYM/K8vLG+rqk09dc111fW5PR MgCMOx66ADBVPXJE3qm2f3rrrVKpJKnxfRFxa35+vl8uGKPEOylqWtqRsBiaPR4C 7KnXasvLy5FIRFJnmAQGgBviWQsAU+VKJRqNymhZRJtPPv9c3hh3X1RVXV9fD7oX uDG2B0+AvR8CPDXYMHz+7NlD1kXbBQEYAG6IpywATBWLxbicnXh6t/v3f/5TRssH sLq6SmHYEUcMHmvtVmtfB4yd/Pe/dV2XdBSw0mppBGAAuA7PVwDoV4GenZ2V0bIY Df/tq69ktLxflmUtLi4G3QvsCTF4HO3rEGDPDydPdlVVUgBmBhgAbognKwBM5XK5 lJzTOGeTyfc/+khGy/vVaDSazWbQvcA+EIPHy74OAfacPnVKVdVsNiujPxwFDAA3 xDMVAKbEADSdychouVgsvv7nP8toeV9EjlpYWHD2vDsRo4MYPC72dQiw59yZM51O Jy3n3TcCMADcEE9TAGGXLxTEyFXSJMxdR4++8PLLMlreF03T1jgTZZxRKXr07esQ YM+lixdbrVYymZTRn2azud/+AEAY8BwFEHalcrnb7eZyORmNP3T8+JNPPSWj5X0R 6ZdyOBOAc4NH2b4OAfZcuXy5Ua8n5FTgYw8wANwQD1EAYVepVkWikHQO8G+feeb+ Bx6Q0fLe2ba9sLAQbB/gI2LwaNrXIcCelaWl9fX1eDwuoz+u666z7gMArsPjE0DY VY8ckZR+hT+9+WapXJbU+B41m81GoxFsH+A7EW/YGDxS9nUIsGezVltZXpZ3Tjjb gAHgejw4AYRduVKJRqMyWu71en/9298kNb73PiwuLtq2HWAfIAlTwSNlv4cATw3q Zp0/e3ZG2tZuVkEDwPV4agIIu2KpJGkJYrfb/Y9//lNGy/vqw+rqarB9gFQ9151i KjhoBzgE2HPyu+/0bpejgAFgaHheAgi7fKEwOzsro2UxJv7bV1/JaHnv1tfX1X0e zYKxw1Rw4BzbVjudA3zjD99/LzIqARgAhoaHJYCwy+VyKTnncIpc/f7HH8toeY8c x5mfnw+wAxgmpoIDZJnmwaLm6VOnVFWVdAwbe4AB4Ho8JgGEnRh6pjMZGS0XCoU3 3n5bRst71Gq16vV6gB3AkDEVHBRD18WvA3zjuTNnOp1OWs57cARgALgez0gAoZYv FEzTlHQI8J1Hj7748ssyWt4LkYWWlpasfZ7LgglAgejh62qaZZoH+MafLlxQFCWZ TPreJaHZaOgHiuUAMMF4OgIItVK5LG8D3kPHjz/51FMyWt4Lyl+FGRl4yNROxzlQ rfUrly836vVEIuF7l6aYAQaAG+HRCCDUKtWqvDNIfvfss/fef7+MlveC8lchx3Lo YWorSn8P9v6tLC9vrK/HYjHfuzQ1+DsgMjCTwACwE89FAKEmAnAkEpHU+Bt//nOh WJTU+O4ofwWPiEBkYNkOfAaSUN/cXF5akncXYhIYAK7BQxFAqJXKZXlzL59+8cXM zIyMxm+p2Ww2Go1ALo1RQ3Vo2VzH6bTbB/te27bPnTkjbx0KJyEBwDV4HAIItUKx KGn3nWEY3/zjHzJaviWRvRcXF+0D7UjERGJLsFS2ZWmH2G7ww3ffdbtdjgIGgOHg WQgg1ObyeUn1V2dmZj75/HMZLd8S5a9wPbYEy2Mahn6IZcanTp7UNE1SLXoCMABc gwchgFDL5nKSTuDMZDLvvP++jJZvifJXuCEysCQi/YoMfOBvP/Pjj5qqSjqNnD3A AHANnoIAQk0MOrPZrIyWq9Xqa6+/LqPl3dm2vbCwMPzrYlxQFst3Ir7ahzhw+8K5 c21FScl5J67ZbB5mdhoAJg+PQADhVa5UxMhV0ta7e+6775nnnpPR8u4ajYYY8g7/ uhgjZGB/ddpt13EO/O2/XLokfmZnZ2d97NK2ZqPBMUgAsBPPPwDhValW2+12Pp+X 0fjjTz7560cekdHyLkSwWVhYcA4xFkdIkIF91G61vOXlB7O4sLBZq8XjcR+7tI0Z YAC4Bg8/AOFVPXJE3jFFL7/22u133CGp8ZtRVXV9fX3IF8WYIgP74jCHAHs21tdX V1ai0ahfXboG24ABYCeefADCq1ypyBt0vv/xx5LWNO5idXWVkS72jgx8eI5tq53O YVpQWq2F+Xl5b8ZRCBoAduKxByC8iqWSpGWHHVX99l//ktHyLizLWlxcHPJFMe7I wIdkmeYh46Vt2+fOnJG3HYMADAA78cwDEF75QkHSJK3rup9//bWMlndRr9dbh1uK iXAiAx+GoevGoatM/fD99yKjSirIRwAGgJ144AEIr1wuJ+nokcTs7Acffyyj5ZsR kXthYUF8HOZFMTHIwAfWVVXrEGcgeU6fOqWqqqQj2dgDDAA78bQDEF5iuJnOZGS0 XCgU3nj7bRkt30y73a7VasO8IiYMGfhg1Hb78HXXz5050+l00nLejyMAA8BOPOoA hFS+UDBNM5fLyWj8rqNHX3j5ZRkt38zS0pL44wzzipgw3kE+ZOD9UlqtqUOcgeS5 dPFiq9VKJpO+dOkaHAUMADvxnAMQUqVSqdvtStp09+tHHnn8ySdltHxDYnS7srIy tMthUpGB98t13Y6iHL6d+StX6pubiUTi8E1djxlgANiJhxyAkKpUqzMzM5LG+s/8 /vf33HuvjJZvaH19XVXVoV0OE0wkuumBoDsyHmzb1g53BpJndWVlfW0tFosdvqnr 9Xo9pdUiAwOAhyccgJCSegjwm2+/nS8UJDV+DTEEX1hYGM61EAaO48h7b2jCmIah +xEsG/X60uJiJBI5fFM3RCFoANjG4w1ASMk7BLjX63325ZdDyw+NRqPZbA7nWggJ 13VFBg66F2NApF+RgQ/fTv8o4NOnZyIRSfcNpdXSCMAAMEAABhBS8g4Btizrq//4 DxktX0+E7fn5eU4/gu8oCr0Xmqrahz4DyfPDd991dV1SWT5mgAFgG882ACGVm5tL pVIyWo7F4x998omMlq/H6UeQhwx8Sx1F8evtpx9/+EHTNFlHAROAAeAqHmwAQiqT zWbkHAKcz+fffOcdGS1fj9OPIA9FoXcnXp92q+VXa+dOn+4fBSznpkQhaADYxlMN QBhVqlW105F0BtKdd9314iuvyGj5GmJEu7q6OoQLIbSYBN6FX2cgeX66cEFRFI4C BgDZeKoBCKPi4BDgOTkB+OHjx5946ikZLV9DpF9mdSAbGfhmbMvS/Dt+bP7y5Xq9 zlHAACAbjzQAYST1EOBnn3/+V/fcI6PlnUzTXFpakn0VYIoMfBN+nYHk4ShgABgO nmcAwkjqIcBvv/tuVk4p1502NjY6nY7sqwBTbAa+Cb/OQPI0G42lxUV5p09RBwsA PDzMAIRRsViMy1lq6Lru519/LaPlnWzbXlhYkH0VYFvPdac5Gfi/0zod8ZPoV2v9 o4DPnJmenpaUgTkKGAA8BGAAYTSXz0sqNmM7zpfffCOj5Z3q9XrLv/KzwF6wEPoa bUXp+XoE9w/ff9/tdjkKGACk4kkGIIzEEDOVTstoOZ5IfPjXv8poeZvrugsLC36d PgrsEQuhd/L3DCTP6VOnVFWVdRQwdbAAYIDHGIAwSmcykkaZhWLxjT//WUbL21qt Vr1el3oJ4IaYBN7m2Lbq9yb8c2fO9I8ClvPeXLPZ9LFkFwCMLx5jAEKnXKloqirp EOCjx449/+KLMlr2iASysLDgOI68SwC7IAN7LNP0fUXxpYsXW60WRwEDgFQ8wwCE TqVabbfb+XxeRuOPnDhx4vHHZbTsET2v1Wry2gd2x0Joj78loD3zV67UNzclHQXM DDAAeML+AAMQQtUjR+SdNfL8Sy8dvftuSY2L7LG0tGRZlqT2gb1gEljQVNX2+ydx bXVV/JJ0FPAUhaABYCDsDzAAIVQul6PShpjvfvhhKpWS1Liqquvr65IaB/aODNxR FN8L0bWazcWFBXlvzxGAAWCKAAwghArFoqRFhp1O59v/+T9ltOxZXl42/F51CRxA yBdCyygBPXX1KGB5GzQ4CQkApgjAAEJI3iHArut+/vXXMloWdF1fWVmR1DiwXz3X nZY2VzniHMdR220ZLfePAtY0SSX6CMAAMEUABhBC2Ww2ncnIaHk2mXz/o49ktCys rq5yjCdGSmgXQssoAe3hKGAAkC2Mzy0AYZYvFMTgNZvLyWi8VC7/6c03ZbRsmubS 0pKMloED67lufxl0+DKwjBLQnnNnz6rtdkrSUcCchAQABGAAYVMoFAzDkLTC8Ng9 9zz3/PMyWt7Y2Oh0OjJaBg7DdV15RZtGlowS0J6ff/qp2WxK2qPBDDAATBGAAYRN pVoV43VJc1aPP/XUr48f971Z27YXFhZ8bxY4vHBWw5JRAtqzuLCwWavF43EZjYv/ WIqisA0YQMiF64kFAOVKJRqNSmr8tddfr1arvje7ubkphq2+Nwv4ImzVsCSVgPbU NjZWlpfl3aOogwUABGAA4VIsFuNyzkASw+JPPv88Eon426zjOAsLC948GzCaQlUN y7FtVdp+BMuyzp89K2+VCkcBA0BYHlcA4JF3BpJpml//53/63myz2Ww0Gr43C/go VAHYNAxd5k7aH777rtvtchISAEgSlscVAHiyuVxaToXVaDT68Wef+dumyBULCwuO 4/jbLOC78GRgeSWgPT/+8IOmqpIq1VMHCwBC8awCgG3pTEbSGZv5QuHNt9/2t812 u12r1fxtE5AhPNWw1E7HsW157Z87c6bTbks6q7zZbEqdvgaA0Tf5DyoA2Cb1DKSj x449/+KLPjYoEsXS0pIl57QVwHchORKp3WpJ3ZN/6eLFVqvFSUgAIAkBGECISD0D 6dHHHhO/fGxQ07S1tTUfGwSkCsMksAj5Hckl2Rfm5+u1mrxafZyEBCDkJvkpBQDX EAHY9yrN21569dU77rzTxwZXVlZ0XfexQUC2iZ8Etiyrq6pSL7Gxvr66ssJJSAAg CQEYQIgUS6V4PC6j5V6v99Gnn/rYuGEYy8vLfrUGDMfETwIbum5IflvKNM0L585x EhIASDKxjygAuF6+UJidnZXRsq7rf//2Wx8b3NjY6Eg7axSQZ7IngTVVteVvyz/5 73+LWwonIQGADARgACGSy+VScs5AEiP+Tz7/3K/WbNteWFjwqzVgyCb4SKSOooiE L/sqp06e1DQtx0lIACDBZD6fAOCG5J2BJIaqf373Xb9aq9frrVbLr9aAIZvUSWAR 7NtD+cE8e/q02ulwEhIAyEAABhAW+ULBNE1Jkyp33HXXS6+84ktTIjwsLCwMYZYJ kGciJ4Ft29aGsjHhpwsXFEWRdRISS6ABhNukPZwA4GbKlcrMgIzGjz/yyGNPPulL U2Lgu7m56UtTQFAmchLYNIzhzJ3OX7lS39xMyDkJSfyn0VSVEgMAQosADCAspJ6B 9PyLLx49duzw7fR6vaWlJUt+lR1AtsmbBO5qmmWaQ7jQ2urq+upqNBaT1D6TwADC bKKeTACwC3lnIAnvffSRL+sVNU1bW1s7fDtA4CZvEng4FbCmBicVLczPy3v1CMAA wowADCAs5J2BpKrqP/71L1+aWl1dlVegdXp62jumFRiOSZoEHloFrKnBZuNzZ860 2+18Pi+jfQIwgDCbkMcSANxSNpdLyzkDSfjsyy8P34hlWYuLi4dv54ZIvxi+SZoE dmxbHeK+2f5JSKoq6yhgTkICEGIEYABhIe8MpEwm88777x++nVqt1m63D9/ODRGA EYiJmQQeWgUsz5kffxQBmJOQAMB3k/BMAoBbKhQKhmFImk65/c47X3711UM24rru /Py8pIxK+kVQJmYSeGgVsDw/nT/fUpRUKiWjcWaAAYQZARhAKFSqVTEKlzQT9etH Hnn80GcgtVqter3uS3+A0eG98zIBk8Cddtt1nKFdTupJSOI/iqIobAMGEE5j/0AC gL0oVyrRaFRS4y+8/PJdR48epgUxHl1cXLRt268uAaNjAiaBh1kBy7O2ttY/CUna XYs6WABCiwAMIBQKxaK8uZQPP/nkkI1z+hEm2ARMAtu2rQ2xApZgmuaFc+fkrVsh AAMIrTF+GgHA3s3l876c03s9Q9e/+fbbQzaysrKi67ov/QFGkOs4M5FI0L04OEMY +qbZk999p3e7sgpBE4ABhBUBGEAoZLNZSfVUo7HYx59+epgWTNNcWlryqz/ACBr3 SWBNVW3LGvJFf/zhB03TJNWupw4WgNAa10cRAOxdvlAwpZWALhQKb7z99mFa2Nzc VBTFr/4Ao8lxnMjYTgK3FaXnukO+6LkzZzqdjqTTy5uNBqtOAIQTARjA5KtUq+12 O5/Py2j82D33PPf88wf+dqmnHwGjY3wPBBY/pJ0g3qL6+aefms2mpL0bHAUMILTG 8lEEAPtSPXJEXhHaJ5566uHjxw/87YqibG5u+tgfYGSNaQa2LKurqsO/7tLiYm1j Ix6PS2qfbcAAwmn8nkMAsF+lcjkWi0lq/E9vvVUqlQ72vSIPLC0tWUPfWwgEYkwD sN7tmoYx/OvWa7Xl5WV568YJwADCafyeQwCwX/lCYXZ2VkbLruv+7auvDjym73a7 q6ur/nYJGGXjmIHVTscJ4oxu27bPnj49MyCjfQIwgHAas4cQABxAbm4ulUrJaNlx 3S++/vrA3762tqYxAEWYuK4rbz+CDCKxtxVlKqBd+j98/323283lcjIaJwADCCcC MIDJl85kJB0lkkyl3vvww4N9r23bCwsL/vYHGHFjdx6S4zhqux3U1c+cOtVRVUm3 L+pgAQinsXkCAcDB9M9AMk1JUyjVI0de+9OfDva99Xq91Wr52x9g9I3XJLBpGAGm xAvnzrUVJSXnJCRmgAGEEwEYwISrVKtitC1pxumBhx76zdNPH+AbRQZYWFhwh36y KBC48ZoE7qpqgGXqLv/8c6PRkFTCQPyHUBSFDAwgbMbj8QMAB1auVKLRqKTGn33+ +V/dc88BvrHdbtdqNd/7A4wFx3HkFTf2V1tResG9UbW6srK+tiaviD2TwABCiAAM YMIVi8V4IiGp8Xc//PBg5bWWl5eNIA5WAUbBuNSCdl23oygBdqDVbC4uLMhbMa60 WtThAxA2Y/D4AYDDmMvnk8mkjJa7mvYf/+N/HOAbRfQVAdj3/gBjZCwysGWawU6Q 2rZ97syZTqczNzcno31mgAGE0Kg/ewDgkLLZbDqTkdHyzMzMJ59/foBv3NjYECNa 3/sDjJGxKIWld7tm0Cs1Tp08qWmarJOQms0uhaABhAwBGMAkk1oCem5u7q2//GW/ 3+U4zsLCQi+gY0WBETEWpbA67bbrOMH24ezp02qnI+ldPGaAAYTQSD94AOCQypXK zICMxo8eO/b8iy/u97uazWaj0ZDRH2C8iGw5M8KlsEREb4/AQWWXLl4UMVXSPg7X dTVVZUEKgFAhAAOYZJVqVV6x2Seeeurh48f39S1iSL24uGjbtqQuAWNkxLcB25Yl wmHQvZhaXFjYrNXi8bik9pkEBhA2o/vgAYDDk1oC+o0//7lQLO7rWzRNW1tbk9Qf YOyMcgYehQ3AQn1zc3lpSd4beRSCBhA2I/rUAQBfyCsB3VaUb//X/9rv2H11dZWS M8C2US6FpbbbTtAbgKcGhaDPnj7dabfzhYKM9pkBBhA2BGAAk0xeCWjhsy+/3NfX W5a1uLgoqTPAmBrNSeAR2QDs+eHkya6q5iSdhEQhaAAhM3KPHADwS75QEJlTZGAZ jWdzubfffXdf31Kv11sjM6QGRsRoTgKPyAZgz9kff1RVVdJ7eSyBBhA2BGAAE0tq Ceg7jx598eWX9/71vV5vfn5ejPVldAYYX6M5AzwiG4A9P124oCgKhaABwBcj98gB AL9ILQF94oknHnn00b1/vRhfbmxsSOoMMNZGMAOPyAZgz+LCQm1jIyGtnh/bgAGE ymg9bwDAR8VSSd7ZIX98441ypbL3r19eXjZGZkIJGCmjtgp6pDYAC5u12srysry3 8wjAAEKFAAxgYskrAS3G63/76qu9z1mJ6CsCsIyeAJNhpCaBLcvqjswG4KmrhaDl beggAAMIlVF52ACA7+SVgBYB+POvv97719dqtXa7LaMnwGQYqUngkdoA7Pnh+++7 3W4ul5PROIWgAYQKARjAZMoXCmIIK+ngkEwm88777+/xi8XIfn5+vtfryegJMBlG aga4oyijVq/uzI8/atIKQTcbDV3XZbQMACNoVB42AOCvSrXabrfz+byMxu+4886X Xn11j1+sKMrm5qaMbgCTZEQysIi+IgAH3YtrSS0E3Ww2dWaAAYRG8E8aAJBBagno Rx577MRjj+3xixcXFy3LktQTYGKMyCpo0zT10dsQuzA/v1mrUQgaAA6PAAxgMkkt Af3qH/945Lbb9vKVuq6vrKxI6gYwSbxtAoFPAndVdQTfsaptbKwsL0ejUUntK62W RgAGEA4EYACTSV4JaDFM/+Tzz/c4vby+vq6OUjlZYJS5jjMjbeHGXoif7o6ijOCO fZHJz589OzMzI+kNAmaAAYQHARjAZJJXAtpx3S/2VgLacZz5+XkZfQAmUuDbgMXP rDqqBdspBA0AviAAA5hA+ULBMs2snJFiKp1+94MP9vKVzWaz0WjI6AMwqYLNwIau G6NaD/nMqVOqpmXkvK/HEmgA4UEABjCBKpXKTCQiaRh92x13vPLaa7f8MjGOX1xc tG1bRh+ASRVsKSy103FG9Wf24vnziqKkUikZjYv7lWicVdAAwoAADGAClSsVedVi fv3oo48/8cQtv0zTtLW1NUl9ACZVgKWwxKXbrdbwr7tH81eu1Dc3KQQNAIdEAAYw gQrForxh4it//ONteygBvbq6yp464AAcx5F3htkuLNMc5QQouxA0ARhASBCAAUyg XC6XSqdltLzHEtCWZS0uLsroADDxgloFLeKfyMDDv+4eibvKuTNnItI2d1AHC0BI EIABTKB0JpPNZqU03et99tVXt/yqer3eGuG1lMCIG34prJE9AGmnH77/Xtd1STe3 ZrOpE4ABhAABGMCkKRQKhmHk5uZkNJ7L5f787ru7f40YQ8/Pz7uuK6MDQBgM/0Dg UT4AadvZH39UVVXSAW/MAAMICQIwgElTrlTkrRI8euzY8y++uPvXdDqdjY0NGVcH QmL4M8CjfADStksXL7ZarWQyKaPxfiHoVosMDGDiEYABTJpiqRSPxyU1/tRvf/vg ww/v/jUrKyv6yI+kgRE35AysttuO4wztcgeztLhY29iQd3+jDhaAMCAAA5g0c/m8 pBkS4e333tt9A55pmktLS5KuDoTHMEth9Vy3rSjDudZhNBsNkYHlvSwEYABhQAAG MGlEQJW0R67b7f7HP/+5+9dsbm4q4zCSBkbcMGeATdPUxyH42bZ97swZtdORVOOA bcAAwoAADGCi5AsFU1oFrGg0+vFnn+3yBa7rLiwsUP4K8MXQMrCmqrZlDeFCh/fj Dz+I3mZzORmNNxsNtm8AmHgEYAATpVypdNptEYOlNF4u//HNN3f5gna7XavVZFwa CKHhrIIWMbs9PoeWnT97VtziJJ1zTgAGEAYEYAATpVKtRqSdnvLAQw/95umnd/mC paUl0zQlXR0IG+9UXtmTwJZldVVV6iV8dPnnnxuNxuzsrKT22QYMYOIRgAFMlGKx GE8kJDX+/EsvHb377pv9W8MwlpeXJV0aCCfHceS9peURec8an/et/n/27sS7jTO9 8z2JhQSxAwQoy5JlWbZsy5JlW5ZsyfLWdiwnnWQ6k3QyPVlOcubeOTP/30yS7pub mTM55870alsbRS2WbUkUKZIigVqwVqHuC5QIsSmKAkk8qCrg+zk0BZLyU68ksvD+ 8G4PlIWFaDQqVF8rlysEYABDjQAMYKikM5l4PC5R2XGcn/7sZ9v0O5eXlw3DkLg0 MLKkZ0Grn2tD09yh5kBoNpvXr11TfydCA+OMAAMYegRgAEMlkUxuf0zRrlm2/bd/ //dP+6pt23fv3g1QNxoIBOlZ0JZlVYL2utXFb76pVatpoX2wSqUaG0EDGGoEYADD I5fL1RsNoX5hIpH403//75/21XK5vLq6KnFdYMS1bDskNgtahb1GvS5UXMjs5ctm pZKUOeyNEWAAQ48ADGB4FGdm5GYGHjh48KNPP33aV+/du9cMyDEqQLDIHYbUnv+s 607Qzi27deOGpmlTU1MSxdXfiaYyMIPAAIYXARjA8JguFOT2hnnz7bePnzix5ZdU Z3FxcVHougCEMrBtWWbQ5j8r9+7eXVlenhTb7Y9BYADDjQAMYHhkslmhURHlyx// OJfPb/mlpaUlMzjHqACBIzQLOojzn5XVhw/vz8/LbY5NAAYw3AjAAIZHKpVKyKyL Mwzj//6v/3XLL9m2fefOHYmLAnAJjQAbmtYK2vznsc7GXXOzs7quZ7NZifrlUokp 0ACGGAEYwJDI5nINsR2wQqHQX/31X2/5pVKptLa2JnFRAF19z8C2bZu63seCg3T5 4sVKpSJ0u2MEGMBwIwADGBKiO2Dl8/kLP/7xk59XnfJ79+5ZliVxUQBdfT8QOKDz n11zs7OGYSQSCYni7X2wNI0MDGBYEYABDAnRHbBeefXV0++99+TnK5XKgwcPhC4K oKvvI8ABnf/s+v727bW1tVgsJlSfQWAAQ4wADGBIZHM5ue7gR59+euDgwSc/r9Jv hW4iMBB9zMCBnv+sLKlbz+JiJBIRqk8ABjDECMAAhoTcDliq2/1Xf/3XT+65alnW 3bt3Ja4I4El9nAUd6PnPSrPZvD47GwqHhRZ9sA8WgCFGAAYwDLK5nOoRqgwsUt1x fvZ3f/fkp9fW1kqlksgVATyhjyPAgZ7/7Lp08aKK8UI3Pa1cZm4LgGFFAAYwDArF YqhDongmk/mjP/3TTZ9UffG7d+/ati1xRQBb6ksGti3LNIy+tMdDc1evtvfBkpn2 0mq1dF1nFjSAoUQABjAMVACWWw730ssvv3/u3KZPmqa5tLQkdEUAW+rLLOigz392 ffftt6VSiX2wAGCnCMAAhoHoDlhnz58//NJLmz65uLjIGjlgwPY+AqwqGJqm3ver SV5ZXFhYevBAbut7AjCAYUUABjAM0ul0XOxIzL/4D/9hYmJi4yebzea9e/ckLgdg e3vMwFazWTHNPrbHK41G48bcnNzh5+yDBWBYEYABBF42l1N9QZWBJYrbtv03f//3 mz65urpaLpclLgdge3ucBV2tVJqNRh/b46FL33yjMqrQra+0tlar1SQqA4C3CMAA Aq9QLBqGkc1mJYonU6k/+clPNn7GcZw7d+4EfQtZIKDc2cu7G/ZU/6+uaWPBn//s unblimmaQvtglUqlGiPAAIYRARhA4BVnZp48pLdfDh0+/MGHH278jArby8vLQpcD 8Ey2be/uR77ZaAzTutZvb94sl8tTU1NC9VkGDGAoEYABBF4un5+cnBQqfvr99185 enTjZxYWFpgZCHho17OgK6ZpNZt9b49X7s/PLy8tbdqhoI8IwACGEgEYQOCJ7oD1 Zz/96cYBFra/Ajy3u1nQKjYbmibTIm/U6/Ubc3PhcJh9sACgdwRgAIGXSCRSMtvA NBuNv/tP/2njZx4+fKgNVx8aCKJdzIJu1OvDt6j10tdft/fBymQkirMPFoChRAAG EGyiO2DF4/F/9+d/3v2w1WrdvXuX7a8Az+1iFrSh6y3bFmqPV2YvXzZNM5lKSRRn HywAQ4kADCDYVACORCJCxQ+88MJHn3zS/VDX9ZWVFaFrAejdTmdB27Zt6rpki7xx 68YNTdPYBwsAekcABhBsuVxuMhYTKv72qVOvv/FG98P79+/X63WhawHYkR3Ngq5V q41h/OGdv3dvZXlZbh8srVyuEIABDBcCMIBgS6XTCZkdsJQ//slPUutzCxuNxvz8 vNCFAOxU77OgHccxNM0ZluN/NyqtrakMvLs9sXvBPlgAhg8BGECAZXM5q9kUWv9W q1b/4T//5+6HKysr+jBOoQQCqvdZ0OouUTFN+RZ5wLKsa1evqj+d0D5YjAADGD4E YAABViwWQ2JHgMRisT/76U/dx61W686dO0M5ggQEV4+zoIfs+N9Nrl66ZFYqKZnX AdVNT2VgBoEBDBMCMIAAmy4UotGoUPHnDx78+NNP3ceapj18+FDoQgB2p5dZ0MN3 /O8m7IMFADtCAAYQYNlcLia2A9ap06dfff119/H8/Hyj0RC6EIDdcRznmRNA6rVa fagPs5XeB4sADGDIEIABBFgqlUokkxKVVcf6J3/xF/F4XD2u1+v379+XuAqAPXpm BjY0bbjP7lbx/sb162GxxSDsgwVgyBCAAQRVNpdrNBrpdFqieNOy/u4f/sF9vLy8 bBiGxFUA7NH2s6Aty6qMwA/vxa+/rtVqQjdDRoABDBkCMICgKhSLcoMeyVTqT37y kzG2vwL8bfsRYJXcmiOweOHalSumacpNh9E0jQwMYGgQgAEEVX56Wm7Z24svvXTu /Pkxtr8CfO9pGVh9Xi+XB9+ewbt961apVGIfLADoBQEYQFBlslm5Dt/Z8+cPv/SS enDv3r3m8B6gAgyBp82CbtTrtdFYvLq4sLD04IHclvgEYADDhAAMIKiSitjRlz/9 2c9Ub7JWqy0sLEhcAkC/PG0E2NR127YH357Bazab169dC4VC7IMFAM9EAAYQSIVi sWKa6UxGqP7P/vZv1fulpSXTNIUuAaBfnszAtmWZI7D9Vdelixdr1WpK5jVBAjCA YUIABhBIxZmZcDgsVDyXy335x39s2/bdu3fZ/grwvydnQY/I9lddc7OzhmEkEgmh +syCBjA0CMAAAimXz09OTgoVP/raa++eOaM6fKurq0KXANBHm0aAR2f7q67vb99e W1uLxWJC9QnAAIYGARhAIKUzmXg8LlT8088/3/fcc/fu3bMsS+gSAPprYwYene2v ulaWlhYWFiKRiFB9AjCAoUEABhBIifYGWCKr3QzD+L/+y3+p1WqLi4sS9QFI2DgL 2tA09aG37Rkwy7KuXb2qbl/ZbFaifqlUGrXXFAAMKwIwgOApFIuGrmdzOYni4XD4 L//jf2T7KyBYuiPAKgpWRmn7q64rly5VTDOVTksUL62t1Wo1icoAMGAEYADBowKw 3Ey/mZmZjz/77O7du0L1AQhxM7AKgdZInt19Y25O17Q4+2ABwLYIwACCJ5vLye31 cvzkyRcOHVpbWxOqD0BIy7bHxscNTfO6Id64e+fOw5UVud0BCcAAhgMBGEDwpFKp RDIpVPzLH//YME22vwICx3GcRr1eH9WZumurq/P37smdD8dpwACGAwEYQMAUZ2ZM w0hnMhLFa9XqX/3N3zx48ECiOABRKgAbmjayZ3dbljU3Oyt3eyQAAxgOBGAAATMz MxMSG+KIxWLnPvqowjQ/IICajcaIz9G9eumSWakI7ZA/RgYGMBQIwAACJpfPyy1y 23/gwKHDh4WKAxBl6rpt2163wku3btzQNG1qakqoPsuAAQwBAjCAgEmn03LbnB47 cUJo9iAAUbZlmSN5+tFGC/PzS0tLExMTQvUZAQYwBAjAAIIkm8tZzWZSZoKf4zjv nz/vHiUKIFhG9vSjjRqNxo25uVAoJHQf08plVogACDr6eQCCpFgshsJhob6dCsBn P/xQojIAUa1Wa2RPP9rk8sWLtWpV7lVCTdOYBQ0g0AjAAIJkulCIRqNCxRPJ5Im3 3hIqDkCOinyNet3rVvjC3LVrpq7LrRNhGTCAoCMAAwiSTDYrt7/Lvv37Dx85IlQc gJARP/1okzs//LD68KHcToEEYABBRwAGECSJZFLuhI8Tb72l6gsVByCkUa/X2Jlp 3drq6vy9e2Gxs+JKpRJ/2wACjQAMIDCKMzOmYQjt0lytVD794guJygDkOI5j6nqr 1fK6IX5hWda1q1crpil0q2QjaABBRwAGEBgqAMsNa6jKp8+eFSoOQEiz2ayaptet 8JfZK1dM00yKzWdhFjSAQCMAAwiMXC43GYtJFc/nXz12TKg4ACGmrtu27XUr/OX2 rVulUkluuwQOQwIQaARgAIGRSqXk1ui+/OqrhWJRqDgACbZlmYbhdSt854GysCC3 YT6zoAEEGgEYQDBkc7lGo5FOpyWKt1qt98+fD4VCEsUBCKmYptVset0K32k2m3Oz s6EOifpMgQYQaARgAMFQKBbD4fD4uMhdSwXgcx99JFEZgBD1Y2tomtet8Kkrly6p jJqU2TPfcRxN08jAAAKKAAwgGPLT0xMTE0LFE8nkibfeEioOQEKtUmk0Gl63wqdu XL+ua1o8HheqzzJgAMFFAAYQDOl0Op5ICBU/cOjQwRdeECoOoO8Y/t3evbt3H66s yL1oyDJgAMFFAAYQANlczmo25abzvXPmzOTkpERxABJq1WqjXve6Ff5Vr9VuXL8u t2yEEWAAwUUABhAAxWIxJNaTq9frH3/2mURlABIcx9E1Tf3idUN87dI331SrVaGN A1kGDCC4CMAAAkB0AbCq/M6ZM0LFAfRdvVZTb163wu/mrl41DEPu6Dj2ggYQUARg AAGQyWanpqaEihdmZl4+elSoOID+chzH0DSH4d9n+f727bW1tVgsJlSfAAwgoAjA AAIgkUymZBYAK68fP64CtlBxAP3VqNdrbL/Ug5Xl5YX79yORiFD9UqnEPwSAICIA A/C7QrFo6Ho2l5MobhrGZ19+KVEZQN85jmPqeqvV8rohAWBZ1tzsrLrFpTMZifql tTX1D8FJVAAChwAMwO+mC4VoNCpUfDwUeu/cOaHiAPqr2Wgw7bZ3s5cvG6YpN32G WdAAgogADMDvRBcAZ/P5144dEyoOoI8Y/t2p27dulUolufsnARhAEBGAAfid6ALg l199tVAsChUH0EcM/+7UA2VhQW4GDcuAAQQRARiAr7UXABtGVmaTKk3T/uAP/1Do eGEAfdQe/jWMlm173ZAgsSzrWucwJKFbKAEYQBDR7QPga4VCISI2fKG61Gc//FCo OIA+ajabVdP0uhXBc+Xy5YrkMmCtXK4wLA8gUAjAAHxNdAFwKpN548QJoeIA+sjU dZvh3527deOGpmksAwaALgIwAF8TXQB8+MiRffv3CxUH0C9Ws1lh+HdXFu7fX15a YhkwAHQRgAH4l+gCYMdxzpw7Fw6HJYoD6COGf3et2WzOzc6qG53QZgcEYACBQwAG 4F+iJwCr/vQHH38sVBxAvzD8u0eXL12qVSpJTgMGgA4CMAD/El0AnEilTpw8KVQc QL8w/LtHN69f1zQtHo8L1ScAAwgWAjAA/xJdAHzo8OH9Bw4IFQfQFwz/7t39+fnl paWJiQmh+syCBhAsBGAAPiW9APj02bORSESiOIB+Yfh375qNxvVr10KSy4Bbtt1o NCSKA0DfEYAB+BQLgIERx9m//cIyYADoIgAD8CkWAAOjzHEc0zBaDP/2A8uAAaCL AAzAp5LJpNx4BQuAAZ9rNhpkqn6RXgaslcsV/rEABAQBGIAfFYrFUIdEcRYAAz7X Hv7V9Var5XVDhoT0MmD1L6XrOi9YAAgEAjAAP8pPT8sNVrAAGPA5hn/7jmXAAOAi AAPwo3QmI7dcjQXAgJ8x/CuBZcAA4CIAA/CdbC5nNZssAAZGU6Ne51zZvmMZMAC4 CMAAfKc4MxMKhYTWqjmOc+bcuXA4LFEcwB6pn1BD09R7rxsybJrN5tzsbFhsGbD6 J1MZuMorFwB8jwAMwHdEFwC3Wq1zH30kVBzAHtVrNfXmdSuG05VLl6osAwYw8gjA AHwnnU7HEwmh4qlM5o0TJ4SKA9gLp7OZ8BjDvzJu3bihaZrc+erlUokRYAD+RwAG 4C/ZXK7ZaKTSaaH6L73yysy+fULFAexFrVpt1Otet2JoLS4sLD14EI1GheqzDBhA IBCAAfhLoViUW6WmadrnX34pdLwwgL1otVqGpnndimHmLgM2DCObzUrUby8D1jRm QQPwOQIwAH/J5fOTk5NS1cfH3//gA6niAPZABadmo+F1K4bc1cuXTdNMsQwYwAgj AAPwF9UzSySTQsWz+fxrx44JFQewa7Ztm7rudSuG3+1bt0qlEsuAAYwyAjAAHykW i6ZppjMZofpHX389Pz0tVBzArlVM02o2vW7F8FteWlpcWIhEIkL1CcAA/I8ADMBH CsWiXM/MNIwfXbggtLoYwK5ZllUxDK9bMRLUX/W1q1crkq8zMgsagM/REQTgI5ls Vm5uXjgcPn32rFBxALvjOI5Kv7Zte92QUTF75YppmkmxlSYEYAA+RwAG4COJZFJu d5bpYvGVV18VKg5gd5qNBnlpkL6/fXttbS0WiwnVL5VKNWZBA/AxAjAAvygUi3Ln cyhvnDwpl64B7ILjOIauO62W1w0ZIasPH96fnw+Hw0L1VQBu2XaDDb0B+BUBGIBf TBcK0WhUqHi1Vvv088+FigPYnbrCaOFgWZY1Nzvb3m4wnRa6BLOgAfgZARiAX6Qz mXg8LlR8YnLyndOnhYoD2AWn1WoP/zqO1w0ZOSoAG4aRSCSE6hOAAfgZARiAL2Rz uWazKTdFef+BA4cOHxYqDmAXatVqo173uhWj6O6dO6srKxOTk0L1tXK5QgAG4FcE YAC+UCgWw+Gw0BlFjuOcOnNGrrcHYKds2zZ13etWjKh6vX5jbk70lqtpGoPAAPyJ AAzAF3L5/KRYQLUs6/wnnwgVB7ALFcNQP5het2J0Xb54sVatJsUm3TALGoBvEYAB +EIqlUqInUupKp946y2h4gB2ymo2K6bpdStG2o3r13VNk9t2oVwqVdneDIAvEYAB eK9QLKrecDqTEar/4pEjz+3fL1QcwI44jmPqeoujjzy1MD+/vLwst/E+ARiAbxGA AXhP9AAk1c9+/4MPQmKHXgLYkUa9XiMaea3ZbM7NzoY6hC7BLGgA/kQABuC9TDY7 NTUlVNwZGzt7/rxQcQA7wtFH/nH18uVKpZIUW3tCAAbgTwRgAB7L5nJWsym3F0su n3/12DGh4gB2hKOP/OP2rVulUknuxUcOQwLgTwRgAB4TPQBJOXbihNzqYgC94+gj X3m4srJw/35YbHkIhyEB8CcCMACPiR6ApPpen37xhVBxADtiGobN0Ue+YVnW3Oys +keRe4mQWdAAfIgADMBjogcgqWj99unTQsUB9K7ZaJCF/EYFYMMwEomEUH32ggbg QwRgAF6SPgDp+YMHX3jxRaHiAHrkOI6haex95Tf37t5dWV6Wm4NDAAbgQwRgAF5S ATgSiQgVV73td99/X+6AJQA9Yu8rf2o0Gjfm5kKhkNwuDMyCBuA3BGAAXhI9AKnV ap376COh4gB61LJtg72v/OrKpUsqoMrtw08ABuA3BGAAXlK9LrlTKNPZ7LHjx4WK A+hRxTStZtPrVmBr3968qTKq4GFImqa+AYSKA8AuEIABeEb6AKSjr7+en54WKg6g Fyr6kn/8bPnBg8XFRdGlKFq5zEpgAP5BAAbgGZVOJyYmhIqbpvnZhQtCxQH0QoUf U9dbrZbXDcFTtQ9DunrVlNyMkFnQAHyFAAzAM+l0Oi52/EY0Gj313ntCxQH0ol6r qTevW4FnuKYCsGHIHUfHXtAAfIUADMAbhZmZ9gFI6bRQ/X379x8+ckSoOIBnYu+r oLjzww+rDx8KHobECDAAPyEAA/CG9AFI75w5I9efA/BMpmHYluV1K/BstVrt5vXr ojsykIEB+AcBGIA3RA9Asizr/CefCBUH8EzNRoPAEyCXL16sVaschgRgFBCAAXgj qYh1tlTl4ydPChUHsD3HcQxNU++9bgh6dfP6dU3T4vG4UH2tXK4QgAH4AwEYgAek D0B66ZVXZvbtEyoOYHu1arVRr3vdCuzA4sLC0oMH0WhUqH77MCRNYxAYgB8QgAF4 IJfPyy3Q1XX98y+/lEvXALZhW5ZpGF63AjtjWda1q1cNw8hms0KXYBY0AJ+ggwjA A6lUSu7IjXA4fPrsWaHiALbRPvjXMFq27XVDsGOzly+blUqSw5AADDsCMIBBKxSL pmlmMhmp+jMzLx89KlQcwDYa9XqNkBNM39++vba2FovFhOoTgAH4BAEYwKBNFwqi K81OvvNOPJEQqg/gaVqtlqFpXrcCu1StVG7dvMlhSACGHgEYwKClMxm5vUabzeaH n34qVBzANiqGYXHwb5Bd6hyGlOIwJABDjQAMYKCyuZzKqHIdLA5AAjzBwb9DgMOQ AIwCAjCAgZI+AOnI0aPFmRmh4gC2xMG/w+HB4qJ64zAkAMONAAxgoLK5nNwmK6Zh /OjCBQ5AAgZMRZpmo+F1K7BX7mFIFdNMi21SyCxoAJ6jmwhgoJKplNwxG9Fo9NR7 7wkVB7AllZoqHPw7LFQANg1D7pg6TdNUwBYqDgC9IAADGJxCsRjqEKq//8CBQ4cP CxUH8KT2wb+63mq1vG4I+uPunTurKysTk5NC9dW3iq7rDAID8BABGMDg5KenJyYm hIqrjvi7770XFasP4Em1arVRr3vdCvSN+te8cf16KBSSW0vCVlgAvEUABjA4qXQ6 IXZCb8txzn34oVBxAE+ybdvUda9bgT67culStVqVW6tSLpVUfaHiAPBMBGAAA1Io FkX3Vsnm868dOyZUHMAm7cnPhtGyba8bgj67fetWqVSampoSqk8ABuAtAjCAAVEB OBKJyNU/duKEXLoGsEm9VlNvXrcC/fdwZWXh/v1wOCx3CfaCBuAhAjCAAclks3JD CrVa7ZPPPxcqDmATJj8PMcuy5mZnTdNMp9NClyAAA/AQARjAIGRzOavZTKZSQvVV tD556pRQcQAbOY5TMQybyc/D6/q1a4aux8W2bGAfLAAeIgADGIRCsRgOh+W2FT30 0kv7n39eqDiAjRr1eo01nEPt/vz88tKS6Kb9mqYxCAzAEwRgAIOQzeVisZhQcV3X P7twQe54YQBdLds2mPw87JrN5tzsrGEY2WxW6BLMggbgFQIwgEFIplJyh2qEwuEz Z88KFQfQ1Z78bJq2ZXndEIibvXzZrFTk7tuapqnvJaHiALANAjAAcYViMdQhVL+4 b9+RV14RKg6gi8nPo+OH775bXV2Vm7nTarV0TeM8JACDRwAGIC6fz09MTgoVdxzn 7XffjYntLw3AxeTnkVKrVm/euCG6dwNbYQHwBAEYgLhUKpUQm0dnWdb5Tz4RKg7A xeTnEXT54kUVg+V27y+XSowAAxg8AjAAWYVi0TTNTCYjVD+VTr/x5ptCxQG4mPw8 gm7duKFpmtz57QRgAJ4gAAOQNV0oRKNRufpHX389Pz0tVx8Ak59H0/KDB4uLi5FI RO4S7AUNYPAIwABkpTOZeDwuVLxSqfzoiy+EigMYY/LzCLMs69rVq+pfPy02hYcA DGDwCMAABBVmZtqdp3RaqH4sFnvr3XeFigMYY/LzaLt+7Zqu64lEQqg+ARjA4BGA AQgqFIui0+deOHz4+QMH5OoDI47JzyPu/vz88tLSxMSE3CXIwAAGjAAMQFAmm5Xb QEXX9c8uXJA7XhgYce3Jz4Zh27bXDYFnms3m3OysYRjZbFboEgRgAANGAAYgJZvL Wc2m3BEa4Ujk9PvvCxUHUK/V1JvXrYDHZq9cqZim3FF2nAYMYMAIwACkFIrFcDg8 Pi51n9m3f//hI0eEigMjzrZtk8nPGBu788MPqw8fTk5OCtV3HEfTNAaBAQwMARiA lGwuF4vFhIqrPtOp994TXZkGjCz186XSb6vV8roh8F69Xr8xNyf6aiazoAEMEgEY gJRkKpUUmzXXcpxzH34oVBwYcbVqtVGve90K+MWVS5eq1arc/VzTtIppChUHgE0I wABEFIrFUIdQ/dz09Kuvvy5UHBhllmVVDMPrVsBHbt+6VS6X5Wb0tFotXdOqnLYF YCAIwABE5PJ50TVjJ95+W244AhhZTH7GkyqmeevmzUgkwixoAEOAAAxARCqVkts1 tNlsfvjpp0LFgVGmQkiz0fC6FfCdS998U6vVUmK7+pdLJUaAAQwGARhA/xWKRdM0 M5mMUP1kKnX85Emh4sDIajabVZZiYis3r1/XNC0ejwvVJwADGBgCMID+y09Pi+7P /Mprr00XCnL1gRHUarVMXXccx+uGwI8ePHiwtLgYiUTkLsEsaACDQQAG0H/pdDqe SAgVr1QqP/riC6HiwMiqmKbVbHrdCviUZVnXrl5V3yRpsak9DAIDGAwCMIA+KxSL op2kyVjs7XffFSoOjKZGvV4je2Bbc7OzhmEkxF7cJAADGAwCMIA+my4UotGoXP0X Xnzx+YMH5eoDo6Zl24aue90K+N38vXsry8uiy1uYBQ1gAAjAAPosncnIbZSi6/pn Fy7IHS8MjBrHcSqGYdu21w2B3zWbTXcQOJvNCl2CAAxgAAjAAPqpPf+5Ukmn00L1 w+Hw6bNnhYoDI6heq6k3r1uBYJi9csU0Tbkz2AnAAAaAAAygn4ozMyqjytWfee65 l15+Wa4+MFIsy6oYhtetQGDc+f771dXVyclJuUuQgQFIIwAD6KdMNjs1NSVU3HGc U2fOTEj2vYDRoX6gDF13Wi2vG4LAqNfrN+bmwuHw+LhUB5IADEAaARhA32RzOavZ TKZSQvVbjnPuww+FigOjhnOPsAtXLl9WAVVuFrRWLlcIwAAkEYAB9E2hWBQdGcgX Ckdfe02oODBSGo1GjZiBnfvu229LpVIsFhOq7ziOpmkMAgOQQwAG0DfZXE60V3Ty 1Cm5/aWB0cG5R9g1FU1v3bzJLGgAwUUABtA3yVRKbl6cZVnnP/lEqDgwOhzHMQ2j xblH2K3LFy/WqlW51S6aplVMU6g4ABCAAfSH9PznTDb7+vHjQsWB0aGiS6Ne97oV CLBvb94sl8ui+x1q5XK1WhWqD2DEEYAB9Ecunxc9G+PYiRPpTEauPjAKrGaTsTXs 0cOVlYX790VPvGMWNAA5BGAA/ZFKpxOJhFDxer3+8WefCRUHRkSr1TJ13XEcrxuC YLMsa2521jTNdDotdAlmQQOQQwAG0AeFYjHUIVQ/kUqdOHlSqDgwIjj3CP1y8/p1 lVHldiVstVqqfo1Z0AAEEIAB9EE+n5+QnP/8ymuvTRcKcvWBodeo14kT6JelBw8e LC5GIhG5S3AgMAAhBGAAfZBKpRJi+z9XK5VPv/hCqDgwCmzbNjn3CP3zaBa0Ycht zVAuldgHC4AEAjCAvSoUi4ZhZLNZofqxqam3Tp0SKg4Mvfa5R7rearW8bgiGyvVr 1wxdj4tt/VAqlVq23Wg0hOoDGFkEYAB7lZ+enpiYkKt/+MiRffv3y9UHhlutUiFF oO8W7t9fXlqKRqNyl2AvaAASCMAA9kp0/2fTMH504YLc8cLAcGs2m1V204UAy7Ku Xb1aMU1mQQMIFvqUAPakUCyKdoCiExOnzpwRKg4MN849gqi5q1cNw5DbAIIADEAC ARjAnkwXCqJT4A4cOnTwhRfk6gPDSuXeimnaluV1QzC07t29+3BlRXQJDLOgAfQd ARjAnqTTablNUDRN++zChXA4LFQfGGK1arVRr3vdCgyzZrM5Nzsrugkig8AA+o4A DGD3ijMzosdgqOh7+uxZoeLAELOazQpLfyFv9soV0zSTzIIGEBwEYAC7Jz3/ed/+ /YePHJGrDwwllv5iYO788MPqw4eTk5Nyl2AWNID+IgAD2D3R+c+q+/7ue+9FJVeX AcOHpb8YpEa9fmNuLhQOy+3VzyAwgP4iAAPYpfb8Z9NUGViovjM2dvb8eaHiwLCq 12rqzetWYIRcvXy5UqkIzoJmBBhAXxGAAexSoViMRCKC9WdmXj56VK4+MHwsy6oY htetwGj5/vbttbW1WCwmdwkyMIA+IgAD2KV0JhOPx4WKO47zzunTk5I9KmDIOK2W wdJfDFytVrt5/XpYdBY0ARhA/xCAAezGzL59hmHIzX9utVrnPvpIqDgwfFTuVQnB aja9bghG0ZVLl9S3XzKVEqpPAAbQRwRgALshPf85Xygcfe01ufrAkGnU6zU2CoJH vvv221KpxCxoAIFAAAawG5lsdmpqSqi44zgnT52Sm18NDBnbskyW/sI7KpreunmT WdAAAoEADGDHCjMzqiOSEpvtZtv2Bx9/LFQcGDKO45i63mq1vG4IRtrlixdr1arc LGitXK4QgAH0AwEYwI5NFwqRSETulf5sPv/asWNCxYEhUzFNlv7Cc7dv3SqVSqIz gzRNYxAYwN4RgAHsmPT85xNvvSU3jAAME5b+wicqpnnr5k3R10aZBQ2gLwjAAHYm m8tZzaZcQFXFz3/6qVBxYJjYtm3qutetAB5hFjSAQCAAA9iZQrEoutNJOps9dvy4 UHFgaLD0F37z7c2b5XKZWdAAfI4ADGBnsrmc6FkXx06cSGcycvWB4VA1zSZLf+En D1dWFu7fD4fDcpdgFjSAvSMAA9gB6fnP9Xr9488+EyoODA2W/sKHLMuam501TTOd TgtdglnQAPaOAAxgB6TnPyfT6eNvvilUHBgOnPoL37p1/XpZ0+ROcWcWNIC9IwAD 2AHp+c+vHjuWy+fl6gNBx9Jf+Nny0tLiwkIkEpG7BLOgAewRARjADiRTqWQyKVS8 Wqt9+vnnQsWB4cCpv/CzQcyC1jT1UyBUHMAoIAAD6JX0/Od4IvHm228LFQeGAEt/ 4X835uZ0TVP3c6H6zIIGsEcEYAC9kp7//PKrr6qMLVcfCDSW/iIQHiwuqrdoNCp3 CWZBA9gLAjCAXonOf65UKj/64guh4kDQOa2WoeuO43jdEOAZLMu6dvVqxTTlDrRj FjSAvSAAA+iJ9Pzn2NTUW6dOCRUHAk3l3qppqlzhdUOAnly/ds3QddlZ0OVyleUA AHaFAAygJ9Lznw+//PK+556Tqw8EV71WU29etwLo1cL9+8tLS8yCBuBPBGAAPZGd /2yan37xhdzwMhBclmVVWPqLQFHftLNXrqiAyixoAD5EdxPAsxUKhXAkIhdQJ2Ox t999V6g4EFytVstk6S8C6PrsrG4YCWZBA/AfAjCAZxOf/3zkyL79++XqA0GkuvgV 07RZ+osAYhY0AN8iAAN4NtH5z6Zh/OjCBeY/A5uw9BfBxV7QAHyLHieAZ5De/3li cvKd06eFigMBZTWbdO4RaHOzswazoAH4DwEYwDPk8vnJyUm5+odeemn/88/L1QcC h6W/GAL35+eXl5YmJibkLsEsaAC7QAAG8AypdFruJXzmPwObtJf+GoZt2143BNgT dxa0aZoZZkED8BM6nQC2UygWQx1C9ScmJt45c0aoOBBEtWq1Ua973QqgD+auXm3P ghbbQqLVaum6ziAwgB0hAAPYjvT85xdefPH5gwfl6gPB0mw06M1jaMzfu7eyvMws aAC+QgAGsB3R+c+6YXz2xRdyw8tAsNi2beq6160A+qbZbLpbYWWzWaFLMAsawE4R gAE8lfT852g0euq994SKA8HiOI5Kv61Wy+uGAP3UXgYsPQta09gLGkDvCMAAnkp6 /vPBQ4cOvPCCXH0gQKqm2Ww2vW4F0GfMggbgNwRgAE+VTKWSYi/b67r+2YULzH8G lEa9XmMIC8NoALOgy6USI8AAekcABrC1QrEo2mWJRKPvMv8ZGBuzLcs0DK9bAUi5 duWKaZpys6BLpVKz0eDkMAA9IgAD2Jr0/OcDL7xw8NAhufpAIDitlmEYDkt/Mbzu 3b37cHl5QvIJhVnQAHpHAAawtVQqJfeCvaZpn124EA6HheoDgeA4TtU0LcvyuiGA IGZBA/AVAjCALUjPfw5HIqfff1+oOBAU9VpNvXndCkAcs6AB+AcBGMAW8tPTopt2 7j9w4NDhw3L1Af+zmk3OL8WIuHvnzsOVFdFlNbqus5YeQC8IwMAoisfj6r0zNhaN RCzLSmcyA27Au++/H4lEBnxRwD9arZap647jeN0QYBB0TVMZeHx80N3Ocqk01rmo e+EK64QBEICBoTc1NTXW6XSojnY4FLJtWz3IZDKD74hs9P758x5eHfCWyr0Vw2C6 JkaHaZp3vv/e2zaon7tyuax+aT/9rT8tqg9ZPAyMGgIwMGymOqO7SigUUs/3qVTK 26y7pTffeScajaoWum0b7/C6UcCA1KrVRr3udSsAQU6H+6DVahm6fn9+3ocHv6vm aZqmfhlbfw5iN2lg6NHjBAJPJV73lWyVIVVHI+316G4vQuHw1NTUxOSkisGRSCQc iaiOkXrfFg67nwmHw92EDAyNZqNBDxtDw823iq1Ylt150LKs9mdaLavzSfU9XzFN 9bg9I8nf2nm4XHafT90nVn5ageFDzxIIKpV7VVBUfY2kL8d4t1cqldxX3MfdfkYn 6IY6VO5VqXhSdZRisclYTIXkiY6IG5WfSMXuIEPg/gYwmlQcMHXd61YAz/bkrXVj 1rWaTfWmNNSbUq+rd+pD9/c46x4X6tzw5U4WEKLarmuau1KfJAwMDbqMQJC405tV /rNbLc/X8fbLk/sAlUsl9cluKnbHhKOTk/GO2NSUCsYqJKsw7HRWc6l4HJ2YGI6/ DQwx9e2q0q+KB143BHgG9b2q0qxlWY/Sa6tldbJuvfaIirtuGnY6X3Xfq5tw5omI Oxx3Znf9sLtiZ4wwDATcMNyVgKGn4p/KeKFwWMU/H66hEtWNx6rz4cbdsIrE7hxp 9VehEnK4rd33CoWm4nH1FzXZGTRuT652f5mYUL9/ODphCLT2LNBm0+tWAG3qdmrb tpty1bdle6KybTc64bbVibLqN6ivuFu1tXdP7AzsPhrd7dxvM+vHB4za3bW9pNkw 1N9go9FQf0VeNwfAjo3WPQsIHJXoVLpTT7GBmzkmyk3F7Ujc6Yel0+nuNlrdFVzt 2dTunOpOWlbibjyOxaKdYEw8xiDVFTabxQBtirhWR6PeHsS13Whr2+6U5u6sZXUf 7O4i4U5m1nV9Y9zlVrlRqVRyx4QZEAaChRsZ4FOZbFZ1WYK4vtfP2v05TWuPG29Y chzqxGMVjCc78djNxW3rI8mjNuqOvlNxo2IYXrcCw0bd0DrZtrMcV0Xazvv2gtzO KK7tRlz15q7H7YRc9X+l0mnuaX3UXSdMDAaCgo414DvpTEb1afx5fNFwezx63N2S yx1G7my+Fetk44n1VNyOx50BZEV91eu2w79UFDF1/cm17sD2Ho3frg/eumO5jfZc gnp3Myp3/LYdb92I2+nYBeIsgCHz6DglYjAQBNwfAR/JZLOqi0P09S3V3TRUkukm 5I05ORx2T3Vqh+L1B5HoOkaSR5XqFldM02ahIDZoZ9dOoG0P21q/p7OlcqO737Kz vqPyxnzLEK5vuTFY/RtViMGAj9HJBnwhHIlMTU0lEgmib6C5O4W6B36E3GXJ7oPQ Y9HuFOtOQm5vcE1UHl61arVRr3vdCgyCOyHZ2hBrHy217bxrnxG0nmy7E5LdZDu2 fmRQd7UtTwSB1p4Urev1ep1XvgB/4g4LeC+dyTQaDba5Gh1uTnZPDRlfz8nj65l5 fD0wq1/dPbpC4fBEJyi7gdkV6nnedTweTySTon8ibElFnqppet0KbK1aqdRqtR5/ sztm624cZa//2uzE3e6Zt91M2/7967F2bOxRvCXZjpr2FlnsjwX4EjdiwEvpdNpu tZLJJL0iPE13L1Z3YHl8fSPW8Z2MEj9O16ENk7bdLbI7xyy337uD0pHI5ORkKpOJ xWJif6aR0OpMmPe6Fb6jvvFanZN1+kjl0Fq12lxfK7tx3NXurJRtrdsYU52tDiHf TjfQdh6qH6aN+88DT3L3x+K0JMBvuGsDnsnmco16Pb1+lCLgK08G78fv13v93bHr 8U4gH99kfRw7tPFBOPz4g84xzu778c5+Y2H3N4QfmYrHVSb3+m9iN9Tfnqnr6i/Q 64bIUt36emeCd+tR0rQ3Ll5trc/3bXWHRjsDoY8GUTcscN1obH0y8OPh07FHUbX7 1TGCKIKj3BkKZlUw4B88WwDeSHdG2FjqCWyvO0bXPZJ041cfZ56twg/PcL3beiR0 Q9rcSIXYVCrVvX2RPIHttbeCNwyTBRGAP/CkBQxaJBpV0Zf9rgAAGBHuzljt6dDN ptdtAUYd/W9goLK5XLPRSHLQEQAAo4QlwYBP0AUHBifbOeaX9AsAwAgiAwN+QC8c GJBMNmuRfgEAGGFkYMBzdMSBQSD9AgCAMTIw4DX64oC4XC7XYN0vAADoIAMDHqI7 DshKpdMt2yb9AgCALjcD1+t127a9bgswWuiRA4IKxWKlUkmn0143BAAA+E65XK5W Kl63AhgtBGBAUCqVinPeLwAA2IrjOJrKwNWq1w0BRgj9ckBKNput1evqvdcNAQAA PlUqlZqNBhOhgYEhAAMi8tPTtWo1ncl43RAAAOBr5VJJBeBGo+F1Q4CRQAAGRCST yUQyyeRnAACwPSZCA4NE7xzov0w2W2fyMwAA6E17InSzaXMqEiCPAAz0WT6fr9Vq TH4GAAC9K6sMbFlWs+l1Q4AhRwAG+iyZSiUCsvOzbduqnSquO46zxZe3+qTTeRtz /4dWy3346DOOo6plstlA/NkBAD6knkpUDnQfj4dC6ukkFAo9erz+5LL+y/jYkx3Z Db+n5TjqaW5qakr9j24Rn2MiNDAY9FOBfvLz5OdSqRQJh2OxWDyZnJ6ePvraa/ue ey4cDu+umnqebrVaqm/hvnepLL28tLS2ulpeWzMrlUa9blmW+rz6rU5nW+z+/okA AAGlnpJCbjDtJFvVHw1Ho7HJSZVX1fPUVCKRTCbT6fRzzz/vJthdX0jlyTvff7+4 uLi6smKapnqOti1LZWN/PiWpvxar2R4G9rohwDAjAAP9lFDP2amUT4ZA1fNoNBpV fYjizMzrb7zx3P79A34J3A3JSrVSefDgwcrKytrDh4bepp7gt5wl7pO/OgDArm05 q0grlyPRaDgcnpiYUJlWPTeplKuk0ukDBw+qzwyseW4knr93b3lpqWKazWbTP3lY /dXpmlapVLxuCDDM6GsCfaOePicmJ72dZ1VaW4tNTRWKxTdOnHjx8OFdD/BKsyxr bXV1cWFhZXlZ9YpM06zVauqT7lhxhmwMAP62Zcotl8vjnenKkXBYxd3Jycl4PJ7O ZguFwktHjsQTicG385lU2rx969b33333cGWlXq+3bDuby3nYnlarZeg6GRiQQ4cS 6I/p6emqdwf/qj5HOp0+/uabx44fj0ajnrShXxqNxsrSUnu62uqq+0J4/VnZeIx4 DAD9tvX2EOspNxQOh1XQ7aTcqampVCYzXSi8/MorCV+m3B6ZhnH50qXvvv1WPbBU EvZoWLhcKrESGJBDlxHoj1QqFfdi7ysVDl8/fvydd9+dmJgY8KUHr16vrywvLz14 sKaycecFcvXHb89e6yxFVn/5qXR6fHx8078C2RgAnmZTynU/1Mrlsc5Abqgzlhud mHDHctU9drpYPHLkyFQ87k1zB8XQ9a9++9vvbt9uNhrJVGrAV2c3LEAU/UKgD3LT 07Vq9WmDk0Isy3rv7NlXXn01EJtbSrNtu1wqLS4urj18WHbnVFerjUbD3ezE6WxY rTpzqc4K7Y2RmHgMYLhtjLiP8q2mOZ0XDcc6u1CFw+F2yp2cnIrFEslkJpudmZl5 /uBBFXq9a7UvqAh6/dq1K5cu1Wq1ZDI5yEuXO8cCsxsWIIGeH9AH6nlRdRoGFqUM XX/n9Om333knHIkM5opBp/oua6urD1fajO7QcaNhdXaoVgm5e+aTO4y88TUFEjIA P9uUb7Vy2f2Me+9qb7Tcmausni+iExOxycl4IpHN5fLT04defDEWi3nW7uBQTxlf //a3N2/caNTrA1voxCAwIIeOHbBXgz76aHz8D3/8Y2+36BgyKgmXy+XV1dVyqaTe dE2r1etN9dZsts9wco2NPS0kk5AByOnm22647d5z1BdCjw4SaudbZWJiQuXbdFrF tEw2n39u/35Gcftl6cGDf/n5z1UiHdhQcKkzCGwzCAz0G/02YK/cZVGDSUHqQp99 8cUgj4vAWGdfLq1UWltb0zRNxWPDMCqVikrIjc78tI1jyORkAD3aJtk+osLtxvFb 95jczgG5qUzmxcOHfXJyz+gol8v/7y9+oZ4OBrMEWn1LlEulWq02gGsBI4UOGbAn yXTaajQGMx6bSqU+u3CB9OtPqo+ieioqIRvqzTSrpqlCcnskudGwVE7uzLXeNJLs avd6Q6H0htdQiMpAcP1erO0utd2o87E7bhvuLMCNuOF2qs09F/eFQ4eY5uNPbgZW d/v4QDJwaW2taVkMAgP9RTcL2L1cPl+v1QYz/Kv6Un/yk5+oa0lfCHLq9fp3t2/r mtaOx9Wq+uapNxpuQlbhuLXVdGvH7U8/mZnHx3e0FI2d0oAntTrb4/XoaYO0Y+t9 qfb2euonbXy8M2TbPh9IJdvJWMw9JSjeGbl9/uDBAW+XiL57uLLy83/8x2qlMoDd oRkEBiQQgIHdG9jwr3oK/PTzz/c//7z0heAHql+1uLjYjsf1esUwquoXlZY7Udnd FNTuHPvU/q2dtPzkyU+bqK8N/ZklwC6on7WNry25L0A92jlqE/c0IGViYnJiYiLm jte2B2yfe/751MCPyYG3Fubn/+UXv1DfDgN4+ZtBYKDvCMDA7g1s9e/LR4+eOn06 HA5LXwhBVKtWlx48UDG5oXT27mqn5PYv7d1T3MCsaVprndM5F8p5YtHyo1A9Pu6O UDETG8HifkuXy2X3W7o962HDZOPuZlHtJbWdWceRaPTQoUMq0KoH7Uw7OVkoFtky Cr1QN9X/79/+7bvbtwfwDcMgMNB39G+AXUpnMipuDGAPEtVr+/Gf/ikjDBCikvPy 0pK7UNlaH2FW7xudRP1ozLnz2ZZtu4PPj4O043QfPJq+/fuzuJ2NCyI3TeRe//zY hmWTG5dDk8CDZf2f/dHCV/eTj/4R1/9BNy5zdw+hHV9/vGm4tZNY2/s/dXeB6gZX 9d9ENBru7HjcHo+dnNy3b18imSS7YpBWHz78+T/+Y6VSGcCm0KVSyeJMYKB/6F4A u5RMpRKJxAD66Oc+/PDFw4elrwIMkkrdpbU193E2l9sUXbpftTpD2e0HnVCuAlar E87HOg/ah1R1Bq7bX/r9dN1aT+YD+vMEn7qVRTbMMRl/FEAf7dKkbnMhlTw7Y6pu ClW/J9J5pB4UZ2YInxhBl7755uLXX0ejUekLcSYw0F8EYGA3cvl8rVYbwF4mxX37 Pvrkk4mJCekLAQCA3hmG8b/+9V+Xl5djsZj0tcqlUnP9BUEAe0QABnYjk81OTk5K 76xbr9f/7C/+IsNJjwAA+M/K8vI///f/Xq1W08JnNLRaLV3Xq5WK6FWAEUEABnYs Pz1dqVQGsPr3nXffffX111kJCQCADzmO89tf//ra1asDmKhVKpVqzIIG+oGONbBj g1n9G4/Hv/ijP5qamhK9CgAA2LVyqfT//PM/65oWTyREL+TuMMcgMLB3BGBgxwZw +pF6nvvRH/zBc/v3y10CAADs3eLCwr/8/OeRSES6Y8B5SEBfEICBnckXChXDyOZy old54cUX3z93zt1qFQAA+JZlWf/2P/7HnTt3pHfDWltdrdfropcARgEBGNiZASwA VvX//C//UjpjAwCAvlh68OAX//RP1UolLXk8BMuAgb4gAAM7k0i2iU5zevGll868 /z7DvwAABIJlWf/rX//17t27ooPAHAgM9AUBGNgZ6QXArVbrD778cmbfPqH6AACg 7x4sLv7in/4pEonIHZHIMmCgLwjAwA4MYAFwOpP57IsvpNcRAQCAPqrX6//83/7b 6upqPB6XuwrLgIG9IwADOzCABcCvvPrqocOHw+FwKBQK/z65F5UBAMAeffWb31y5 fFn0TGCWAQN7RwAGdkD6BOBqtfreBx887cVjdd0tg3E3Hqv30qcTAwCAsc6SpU0e rqz82//8n+qpPJ1OC12U04CBvaOvDOyA9A5YU4nEGydO7GX7q03xmGFkAACeyel4 MtNuYtu2+8D9/ZuKWJZ16euvy6WS3Czo9jLgcplBYGAvCMBAr6YLBVN4AfBLr7wi vf0Vw8gAgKHXS5rdpC/X/eG77+7+8EM0Gu1LtS2xDBjYI7q5QK/aC4BNUy4AV2u1 986dE908o0fbDCO7j9V7QjIAYGB2mmafHJ4dDF3TLn71legsaAIwsEd0YYFe5fJ5 9ZQmtwPWZCx2/ORJ0ZeN+2hjMH4yIROSAQBb6o7Nbj9Iu+mrXre6V81m89JXX2nl cjyRELpEqVRqNhq2bQvVB4Ye3VOgV9I7YL3w4ov7DxwYptC4ZTDeOIzMdGsACLQt Q+wzk63XrRak/nS3b926f++e3F7Q7IMF7BFdT6BX8Xg8lU4LBTZd1899+GEimZQo 7mfumuRNqXjjewaTAWAwnpldn4y4w51md0crly9+9ZXcoYntfbBKpVqtJlEcGAX0 KYGeTE9Pm5ILgFXAe/v0adHDAwMt1EFOBoBn2rSh8aZMu82HXjd8SDQaja9+/WvV Z0iKvajNMmBgL+gsAj2R3gErl8+//OqrKsUJ1R8R3T2uu9l44wOmXgMIkI051n3Q Y6xlVNZbtm1fu3z54cOHsVhM6BIEYGAv6AICPWkHYLHpTMorr702XSgIFceTVADe MiRvGZu9biyAANs0YfhpD578JDk2uO7dufPDd99FIhGh+qVSiaOAgV0jAAM9Ed0B y9D1cx99JLdjJPYo1DN3bJnhZWBodIdhn/Z++w8JsaPJXQZcrVYzmYxEffbBAvaC XhrQE9EdsMbGx99hAfAQeWZOdsefNz4mMwN9tzG7bgqlvXzYfez1nwPB014G/Ktf tZcBp1IS9dkHC9gLulzAs0nvgJUvFF4+epSptqPMHTfeJiFverzxgddtB/rG2aCb P5/8cMvHTyZYr/80GF3q22/u6tXlpSWWAQM+RM8JeLa8CsCGkcvnheqzABi7Nr7O DcM7fbDpsdd/GgSA84Sx9cNgt/xqj5mWyIohI70MmAAM7BrdHeDZpHfAev348YxY caBHW0bijdn4yU/u7qse/zmHwsbkObYhdvbyeOOHT/v8Nrz7QwNBcn9+/rtbt9gH C/AhOiLAs6XS6Xg8LtRxr9Vq7507NxWPSxQH/KmbivvyflPZLa+1u09uyntPxr/t f8OWH/byvpffAMDPdF2/+LvfVavVdDotUd9hHyxgtwjAwLMlEolkKiUUgCcmJk68 /XY0GpUoDgAABq/ZbKoArDJqQuaIh3YALperDAIDO0cABp4hn8/XajW5LaAPHjr0 /MGDzAsFAGBoqID67c2bC/PzQkc8OGwEDewWfW7gGaS3gGYBMAAAw+f+vXvfffst +2ABfkMABp5BegvoYydOpDMZoeIAAMATC/PzKgCHw2Gh+gRgYHcIwMAzZHO5Wq0m tAV0s9E4ffZsbGpKojgAAPCKYRgXf/tb1YVIplIS9UulkupF2LYtURwYYgRg4BnU 81YikRBao5svFF4+ejQUCkkUBwAAXmm1WteuXFlZXo7FYhL12Qga2B0CMPAMU/F4 WmwHrCNHjxZnZiQqAwAAb935/nv1JnTQQ3sfrHKZ04CBnSIAA9tJZzKNRiOTyQgF YBYAAwAwrESXAasAXCqV6mwEDewQARjYTn56uiK2BbSmaec//jguc0IgAADwllYu X/zqq0qlIrSTCPtgAbtAAAa2k8vnq9Wq0PNWo9E4c+6c0NIgAADgrVqt9ttf/rJa qQjN9iqVSlazaVmWRHFgWBGAge2ks9nY5KTQJlW56emXjx6VOyABAAB4yLbta1eu PFxZEXqxu9Vq6brOPljAjhCAge0kEolkKiW0APilV16Z2bdPojIAAPCDH7777u4P P8jtg6WVy1X2wQJ2ggAMbCcej6fEtoB+/fjxjMzkagAA4Af35+e/u3UrEolIFG9v BF0q1dgHC9gJAjDwVNPT06bYDljqSeuNN99kC2gAAIaYVi5f+vprFYCFXkxnHyxg pwjAwHbkRoArpnn2ww+n4vG+VwYAAD5RrVZ/87//t8qoEi95MwIM7AIBGHgq0RHg luO8e+bMxOSkRHEAAOAHjXr9d7/+tepOpFIpifqMAAM7RQAGniqvArBh5PJ5ieIH X3zx+QMHhCZEAQAAP3Ac5/atW/fv3ZuYmJCoTwAGdorON/BUKgDLHV7PDlgAAIwC 0X2wSqVSjV2ggZ0gAANPlUqnp6amhA4BPnbiBDtgAQAw9BZUAP7223A4LFGco4CB nSIAA0+VTKUSiYTELGVN085//HE8keh7ZQAA4CvqSf/i734nNKesfRSwphGAgd4R gIGnUulXZWCJANxsNs+cOzfJDlgAAAy7er3+m1/+UmXUdDrd9+LtAFwuV5kFDfSM AAw8ldwZSOFw+K13341Go32vDAAAfKXZbH7161+bhpFIJvtenJOQgJ0iAANbyxcK FcMQOgMpkUq9/sYbQvthAAAA/7As68o335RKpampKYn6bAQN7AgBGNia6BlI7IAF AMDoEN0HiwAM7AgBGNia6BlIBGAAAEaHaADmJCRgRwjAwNZS6XQ8HpdYAOw4zvGT J1MCO2EAAAAf0srlS19/HYlEhPoVbAQN9I4ADGxN7gykSqVy9vz5qXi875UBAIAP 1arVX/2f/9Oo1STmfxGAgR0hAANbkzsDybKs02fPcgYSAAAjol6v//ZXv6qapsT8 L05CAnaEAAxsbSoeT8ucgRSJRE6eOsUZSAAAjIhms/n1b35j6LrUSUjlMsuAgR4R gIEtZDKZeqOh3ksEYM5AAgBgpIiehKQCsKpc5yhgoDcEYGALnIEEAAD6aOH+/e9u 3eIkJMBzBGBgC5yBBAAA+kg0AHMSEtA7AjCwBRVQY7FYKBSSKE4ABgBg1Czev39b LAC3Wi1d19kIGugFARjYgtwhwIauf/Dxx5yBBADASNE17eLvflepVjOchAR4igAM bEHuEOBGvf7eBx9MxmJ9rwwAAHyrXqv9+pe/rFUqHAUMeIsADGxB7hDgsfHxd06f npiY6H9lAADgV41G46tf/co0TdXB6HtxjgIGekcABrYQj8dTMocAx2Kx42+9xRlI AACMFMuyLv7udyqmxhOJvhdvHwVcKtU4CQnoAQEY2Gx6eto0zWwuJ1E8k8sdfe01 oT0wAACAP9m2fe3SpZWHDyWOAh7jJCSgZwRgYDMOAQYAAH3HUcCAHxCAgc04BBgA APQdRwEDfkAABjaTOwTYcZzjJ0+m0um+VwYAAD6nlcuXvv46EolIbDLCUcBAjwjA wGZyhwCrZ7433357uliMRqN9Lw4AAPyp2WyqaKrebs7NVSqVjMAsM05CAnpEAAY2 kzsEuMu2bdM0Q6GQSsKTk5PZXO7Q4cNT8bjcFQEAwACorKtr2vKDB+W1tXqjoT5U T/rq88lkUmJyWRcBGOgRARjYTPAQ4G25T12h8fFIJBKdmEhns88fOJDOZBguBgDA b9xBXfV+YX6+XCq1g65lqayr+g9CJyluj6OAgR4RgIHfk5+erlWrnjx1PU2r1TIM Q7Un6gbjTOa555/PZLMEYwAApD0Kuo3G4sLC46Dbao3JD+ruCEcBAz3ySxcf8AnR Q4D7Sz3V6Zo23hkxjqhgnE4/f/AgwRgAgF1wg26j0ViYn9fKZXfqcntEt7M5iH9e Ft8GJyEBvQjADzMwSKKHAA+GOwlKPVWHIhF30Fg9cz+3fz/ZGAAw4rop98HiorZh OLfVWaabzmQCEXSfhgAM9CLAP+SAhCEIwNtwlxmrH/twpCMaTafT+/bvz+ZyZGMA wHB4lHLr9cXFRd0dy11PuV4t0B0MAjDQi+H8+Qd2TQXgSqWSFTifwOfaa4fK5VB7 4DgUCYdVNnbjcXHfPuIxAMBXuhF3aWnJjbhWZwMqFXId9TY2lgn4WO7ulEqlGptg Ac8ycrcGYHtyhwAH2sZ4HA4/Gj9OJJP79u+fUuJxEjIAoF/cfKseqDj3YHHR0HU3 3xJxt8dJSEAvuHEAv2cAhwAPpe7CYzchtyNyOOwm5Hg8TkIGAHR186167+Zbe52b b4d7orIcAjDQC+4swO+JJxIpLw4BHnruGLJ6EFIZORwOqZzczsjhRCKhQrJ6r75E TgaAQOsmW6VimosLC+q9ZVmd5bePB2/HGL+VwVHAQC+49QCP+fAQ4FHjPnmr7lGo oxOUH025ViG5UCzGicoAMFgbY616sLy0ZJqmbVluslXRtuU47XDrOOPB30g50DgK GOgFdyjgsQAdAgzbtg1dHxt3p12HQp33KiqHOnk5Ho9PF4sMLAPAljYN1a4sL1cq Fbu7zta2VZRqJ9pOrFV32lQqpe6x3rYZvWAjaOCZCMDAY8N9BtIo2zgBezwUepSZ O6PLnSXL4djUVKFYVD089/eTmQEEyMY0qxi6rgJttVq11+cet8dn3SFaN9N2fhuT kIcSARh4Jm58wGO5TgDOE4DRzcydoY/Q+jjz+nBzJzl3fonFYtOFQjqTcf8vkjOA XduUY3VNW1lZqasc21k9242y6zG286Bzs1J3JtIsXKurqw0CMLAt7pXAY4wAY+86 PdKxjeH50TztboYOhTaOP09OTuampzPrEXqMFA0E0Kbsqmjl8urDhyqKPNra2N0C yg2unTFYZ32CcfuW0blduPcBciz2ghFg4Jm4yQKPqRxSZQ0wfGBTih7v9InHOwvw 3OHo7lj04zgdCkUnJnL5/JOv4JCogU2ezKuu0tpaO7U2Giqauqn1cWR1ucFV/brh w3GyK3xDfQ+zCRawPe7UwGPpdFpFBXowGD7dRO0esNkN1eqTm3L1WHeydzdjrw9a qxSdzeW2nCJBxkYfPS2djnVGt1T/3urs1eSsL2vtvle/of3+yaQ6Nvb4vcqroRB5 FcNKfYfrmlbhKGDg6bj1A48lU6lEIkGXCNgFN1+o+KHrutOJIsBOqWja3W2YWzGw C+3TBDXtaS8hARgjAAMbJZJt9LoAAEAQtQNwuVytVr1uCOBfdPSBx6bi8XQ6TQAG AABB5B5hUCMAA09HRx94JJ3JNBoNTpIAAAABpQJwqVSqsw8W8HR09IFHOAMJAAAE HSchAdsjAAOPcAYSAAAIOk5CArZHAAYe4QwkAAAQdJyEBGyPvj7wCGcgAQCAoOMk JGB79PWBx6bicfW8Md45gjKZTLpnUQIAAPjZozPYVR9mrH2INukX2AYBGNhOOxKP jXVTcSqVYogYAAB4xR3g7WZd9Y64C+wIXXlgx0jFAABAGlkXkECvHeiPbioOhUIt lYqTyfEOr9sFAAB8TUXcVqtlGIZ61P6YrAtIoncOyHLXFYfDYdu21dNaJpMhFQMA MJpU1i2Xy+1JZG5ngPW6wMDREQc84A4Xt5/8Oq/1ptJpUjEAAMOkPYG5XHbcrMug LuAb9LkBv4jH452ZT+0fS/V8qZ4s0wRjAAD87cmgq/7jGF7At+hbA373aHXx2Fg4 FLJtWz1IM48aAIDBejLojjGoCwQQfWggqLrBuPtjzFRqAAD2iKALDDf6ysAQenxQ 0/i4+xRONgYAoOv3Uu4YGy8DI4QOMTBaNo0bO+vnGBOPAQDDpHu2kPqFsVwAXXR5 ATzSzcbd4xlanU2qOboJAOBD7pFC7VFc92CFsTFSLoBnolMLoCeb4/H4uNNqsVU1 AEDOo4nKncePnmmIuAD2hm4rgP7YmJDb7zuxmDFkAMCWNo7fjnWfJMi3AITRJQUw OI9D8tjjidZOJyRzthMADI3HI7e/v8uUi3ALwEN0NwH4jsrJ450Nuto2zLh2Ovcs ojIAeKIba91b9MYxW/czJFsA/kcnEkCAbYrKY+40ug1p2T3/icAMAE9yOnRN25xp x4i1AIYWnUIAI+T35mCPrR+V7HbyOlOxycwAAurRqT+67mw46G7TwloXgRbAKKOH BwDP8GRsHusMNW9Mzk4nS7PdF4A9creGat9n1u8mTw7MdhFlAWCn6KgBgCA3PD+e pz22vkv2xgg9tj4T0U3R2SwpGgiidnYtldwf5O5PsbOps9Xd7Xj9tkCIBYBBoo8F AAEwNTU1tmUqXo/TGxfsjW0YlE4zoxt4CnfOsK7rG4dbx9Zz6dMGXbv/c7VaFW8i AKDf6BIBwIjaPLV7I8fZ+JE7WD22PuV7bMOo9XgoRMaGhG46Vb+4m9ttTKSPDo/d 5OnfhIyyAgBc9FcAAAAAACOBAIz/v/06EAAAAAAQ5G89yGURAADAggADAACwIMAA AAAsCDAAAAALAgwAAMCCAAMAALAgwAAAACwIMAAAAAsCDAAAwIIAAwAAsCDAAAAA LAgwAAAACwIMAADAggADAACwIMAAAAAsCDAAAAALAgwAAMCCAAMAALAgwAAAACwI MAAAAAsCDAAAwIIAAwAAsCDAAAAALAgwAAAACwIMAADAggADAACwIMAAAAAsCDAA AAALAgwAAMCCAAMAALAgwAAAACwIMAAAAAsCDAAAwIIAAwAAsCDAAAAALAgwAAAA CwIMAADAggADAACwIMAAAAAsCDAAAAALAgwAAMCCAAMAALAgwAAAACwIMAAAAAsC DAAAwIIAAwAAsCDAAAAALAgwAAAACwIMAADAggADAACwIMAAAAAsCDAAAAALAgwA AMCCAAMAALAgwAAAACwIMAAAAAsCDAAAwIIAAwAAsCDAAAAALAgwAAAACwIMAADA ggADAACwIMAAAAAsCDAAAAALAgwAAMCCAAMAALAgwAAAACwIMAAAAAsCDAAAwIIA AwAAsCDAAAAALAgwAAAACwIMAADAggADAACwIMAAAAAsCDAAAAALAgwAAMCCAAMA ALAgwAAAACwIMAAAAAsCDAAAwIIAAwAAsCDAAAAALAgwAAAACwIMAADAggADAACw IMAAAAAsCDAAAAALAgwAAMCCAAMAALAgwAAAACwIMAAAAAsCDAAAwIIAAwAAsCDA AAAALAgwAAAACwIMAADAggADAACwIMAAAAAsCDAAAAALAgwAAMCCAAMAALAgwAAA ACwIMAAAAAsCDAAAwIIAAwAAsCDAAAAALAgwAAAACwIMAADAggADAACwIMAAAAAs CDAAAAALAgwAAMCCAAMAALAgwAAAACwIMAAAAAsCDAAAwIIAAwAAsCDAAAAALAgw AAAACwIMAADAggADAACwIMAAAAAsCDAAAAALAgwAAMCCAAMAALAgwAAAACwEHSwM +X++pF0AAAAASUVORK5CYII="/></symbol><use xlink:href="#c" width="1280" height="1280"/></g></g></svg>')} +.is2d .queen.black {background-image:url('data:image/svg+xml;base64,<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="614.635" height="614.635" viewBox="0 0 460.977 460.977"><mask id="b"><use xlink:href="#a" width="1280" height="1280" transform="rotate(.193) scale(.36014)"/></mask><symbol id="a" viewBox="0 0 1280 1280"><image width="1280" height="1280" xlink:href="data:image/png;base64, iVBORw0KGgoAAAANSUhEUgAABQAAAAUACAAAAAA9j6ArAAAACXBIWXMAAA7EAAAO xAGVKw4bAABGnUlEQVR4nO3dd2BUZcK28VmEJIRQAlKkqYAgRcWCYi+gvouiqKu4 rhVXxb67oq5trWvFde2ou6jgqlhRVv1WQRSxi4pSpEoXCJ2QRvskIWSSzCRTznnu 55zn+v31vkpmrp3h3CaZmXN+EwEAR/1GHQAAKgwgAGcxgACcxQACcBYDCMBZDCAA ZzGAAJzFAAJwFgMIwFkMIABnMYAAnMUAAnAWAwjAWQwgAGcxgACcxQACcBYDCMBZ DCAAZzGAAJzFAAJwFgMIwFkMIABnMYAAnMUAAnAWAwjAWQwgAGcxgACcxQACcBYD CMBZDCAAZzGAAJzFAAJwFgMIwFkMIABnMYAAnMUAAnAWAwjAWQwgAGcxgACcxQAC cBYDCMBZDCAAZzGAAJzFAAJwFgMIwFkMIABnMYAAnMUAAnAWAwjAWQwgAGcxgACc xQACcBYDCMBZDCAAZzGAAJzFAAJwFgMIwFkMIABnMYAAnMUAAnAWAwjAWQwgAGcx gACcxQACcBYDCMBZDCAAZzGAAJzFAAJwFgMIwFkMIABnMYAAnMUAAnAWAwjAWQwg AGcxgACcxQACcBYDCMBZDCAAZzGAAJzFAAJwFgMIwFkMIABnMYAwqH7zHk12zWpT 9W/d1sVF89dMySuUNMFlDCDM2K1byzat2+68e1aTmP96TdHPKxYtWbxs2jyzWXAb Awjf5XbfrfmuB+zRKKvWP1m0btY38/PmTV1toApgAOGzRh067XHgfi0zk/iS4mXf fjVr9tx1vjUB5RhA+GeXXbsdfWDnlL505lfjp83/xeMeoAoGED5p2XHvM/ZpmsYN rJr8yg9zlnnWA1THAMIPzXY5+KyjPLidj178/JeVHtwOEBMDCM/V36X74MMaeXRj 6yYOm/oLb5CBPxhAeCynzXkXN/P0Flc+/fzifE9vESjDAMJLder1fOBwH273k2u/ 37jFh9uF4xhAeKdO3YG37+7Tbf9866hNTCA8xgDCM7nXXJbr482vfuJB3iANbzGA 8Ej2g+fX/lGP9BQ9d02Bz3cBtzCA8MaTFyTzaY9UFT97qYF7gTMYQHjhzitin+PA e2seu8XQPcEBDCDSN/Bxb9/3UrOVl48yeG8INQYQ6dr/P10M3+OMP0wyfI8IKQYQ aRr9fyZ++VdZ8f8bYPw+EUYMINIy4JmdJfe74qLRkvtFuDCASEPzV3r7/daXeIq+ OCNPdNcIDwYQqTvrYc23f2VWXP2i8N4RCgwgUtXozYPrSwMKPz+F00YjLQwgUnTy gx3VCZE517ylTkCgMYBIzT8HNVQn/Gr98D+pExBkDCBS0fmZI9QJ2024aKY6AcHF ACIF/YemdqkjP8wcMkadgMBiAJG0jKuubaFuiLL8gUdK1A0IKAYQycq99xztq79V FY78KycKREoYQCRpt3+erE6o5q0/zVMnIJAYQCTnsH/ur06IYdKfJqoTEEQMIJKy /2u7qRNimvc7ThCD5DGASMbRI9qqE+JYdO54dQKChwFEEn7/TAN1QlwbLnpJnYDA YQCRuNOfy1Yn1KDg/FfVCQgaBhAJO/U/qnNfJaboD2+oExAwDCAS1f9V86d+Tk7x 6XwoBElhAJGgE/6rLkjAie+oCxAoDCASc9z/1AUJOf59dQGChAFEQrpPURckqMdU dQEChAFEInLnmrrwebrWdOBzwUgYA4gENJvTWJ2QsLUdV6oTEBgMIBIwp4O6IAlz 9afqR1AwgKhVnW/3USckZfJ+W9QJCAgGELWp8/e/qhOSdO9NLCASwgCiNoF4A2Bl vB0QiWEAUYsOc9QFKeg4V12AQGAAUbPmU2y6/keilvfIUycgCBhA1Cj31T7qhJSM O523A6J2DCBqUvfmW9UJKbr9rk3qBNiPAURNBrxk9xmw4iv6/Wh1AuzHAKIGXd7b XZ2Qsp9/O0OdAOsxgIgv+8lz1QlpGHFpgToBtmMAEd+f/6EuSMtfHlIXwHYMIOLq /WYrdUJalp7yhToBlmMAEU+jF/qrE9I05ux16gTYjQFEPEMeUBek7dqh6gLYjQFE HD1HdVYnpG3mwO/VCbAaA4g4XjldXeCBV89QF8BqDCBi+/3jueoED6y+/CV1AmzG ACKmnA97qRM88fUx+eoEWIwBREz3Xq8u8Mh9QTubK0xiABFLqy/bqxM8suCgpeoE 2IsBRCwjzlEXeGZkkD/OB58xgIjhkDFN1QmeWdX/M3UCrMUAIoaxwTwLamzj+qoL YC0GENUd9F4Y3gJTbvVvv1QnwFYMIKobf5S6wFMfHa0ugK0YQFSz/7jG6gRPre0z SZ0ASzGAqObjI9QFHptwpLoAlmIAUVXPT3LUCR7LP5xzIiAmBhBVvfh7dYHnXjpL XQA7MYCoos6qcP0GcJu1TbeoE2AlBhBVPHKlusAHj16lLoCVGEBUsayFusAHy1uq C2AlBhCVnRzO64kPeEtdABsxgKjs233VBb74bj91AWzEAKKSxssy1Qm+KG65Vp0A CzGAqOSpi9UFPnn6EnUBLMQAopIVzdQFPlm5s7oAFmIAEa3rNHWBb7pNVxfAPgwg or1+qrrAN2+cpi6AfRhARFsfto8BV8hvqC6AfRhARDnkU3WBjw7l1PioigFElLdO Uhf46O2T1QWwDgOIKKvCdCr8qlaH50JP8AoDiAptF6oLfNVukboAtmEAUeGxy9UF vnr8CnUBbMMAosKsTuoCX83eQ10A2zCA2KFeibrAZxkb1QWwDAOIcr859BN1gs8O /3SrOgF2YQBRbqfh56oTfDZi0GZ1AuzCAKJcvVm7qhN8Nn8PfgZGJQwgymVvUBf4 rkGBugB2YQBRrvfn6gLfHfyFugB2YQCxXeZjf1Qn+O5fVxSrE2AVBhDb5UzcR53g u8mH5asTYBUGENs1+bmJOsF3a3Zfo06AVRhAbNd8ubrAgBZ56gJYhQFEmTr9w3lB 4MoGjNmiToBNGECUybz1BnWCAffczqsgiMIAokyj0UerEwwYP2CdOgE2YQBRpuU0 F84XuqrbMnUCbMIAokyb2VnqBAOKOi1WJ8AmDCDKtJ+vLjBi1wXqAtiEAUSZIz5W Fxhx5AR1AWzCAKLUTn8cpk4wYvC/OCMWKjCAKFX/ppvUCUb8/e+F6gRYhAFEqdwR J6oTjPjvuavVCbAIA4hSLf7bS51gxNcnuvCJPySKAUSpdp+3UScYsfjgcF/7GMlh AFFqjx9ceBtgJFK09yx1AizCAKJUp+8bqBOM2NBztjoBFmEAUarzDHWBIV1mqgtg EQYQpfb5Xl1gSM/J6gJYhAFEqZ7fqQsM2deVpUciGECUYgDhIgYQpRhAuIgBRCkG EC5iAFGKAYSLGECUYgDhIgYQpRhAuIgBRCkGEC5iAFGKAYSLGECU6jZVXWBI92nq AliEAUSpTj/UVycYUbg3J0NABQYQpTpNzlYnGFGwDwOICgwgSnX4trE6wYi1+81V J8AiDCBKtfywmzrBiGnHLFMnwCIMIEq1eHd/dYIRk/pxTRBUYABRKueBweoEI4Zd m69OgEUYQJTK/Mvd6gQjbvxHsToBFmEAUebk0eoCIwa8pS6ATRhAlOk+RV1gRA9X 3vCNhDCAKNNmkbrAiLaL1QWwCQOIMi1/aqJOMGDNnrwLBlEYQJRp9kUndYIBs3uv VCfAJgwgymQPO0edYMDIwQXqBNiEAUSZnc4drk4wYNCIzeoE2IQBxHY9flQXGLCX G691I1EMILZrslpdYEDuGnUBrMIAYrtGM1qpE3y3tMs6dQKswgBiu/qvnqBO8N07 pxeqE2AVBhDb7XTlQ+oE3/35UV4DQTQGEOWah/9EUS3y1AWwCwOIcpnLG6kTfLau BaeCQSUMIMrV++gQdYLPPjtqozoBdmEAUa7OXx5QJ/js2n9sUSfALgwgdshdpS7w WVMX3uqIZDCAqLA+R13gq/yG6gLYhgFEhQ/6qgt8NfZYdQFswwCiQv+31QW+OmmM ugC2YQARpThDXeCjkkx1AazDACLKjM7qAh/N7KIugHUYQES5/W/qAh/dcau6ANZh ABFtqzrAR/xdRzX8pUC0OR3UBb6Z21FdAPswgIg26N/qAt9c6MIp/5EkBhCVFIX1 pdLiLHUBLMQAopKJh6oLfPLpYeoCWIgBRCVHfqQu8MlRH6sLYCEGEJUtbaku8MWy 8F/wBClgAFHZE5eqC3zx5GXqAtiIAURlzRZkqxN8UNB+pToBNmIAUcXHR6gLfDDh SHUBrMQAoopDxoXvDSNFfT5TJ8BKDCCqmr6nusBzP3VVF8BODCCquvIRdYHnrnpU XQA7MYCoZkE7dYHHFrZXF8BSDCCqufU2dYHHbrtdXQBLMYCo7ufd1AWemre7ugC2 YgBRXcjOi8qZUBEPA4gYZnVSF3ho9h7qAliLAUQMd14bnrNiFT9wizoB1mIAEcuk /dQFnvl2f3UB7MUAIpaLHmyoTvDI+mueUSfAXgwgYppwuLrAI5+E8aPN8AoDiJiO fLG1OsETS87iRKiIjwFEbCE5LyDnAURNGEDE1vyDfdQJHph8bJ46ATZjABHHVXc3 UCekbcON4TuxA7zEACKe0SerC9L21gB1AezGACKeg14I+udBZp/9pToBdmMAEdeN f1cXpOmmu9UFsBwDiLiyRv5OnZCW184pUifAcgwg4uvxcnd1QhqmnjlFnQDbMYCo wdnPBPcCSUUXvaBOgPUYQNQge2hw3w795JACdQKsxwCiJru9eLA6IUWfnzVPnQD7 MYCo0SGvt1InpGTpaVwJGLVjAFGzPwbzbFIX/UtdgCBgAFGzug9doU5IwWN/3qRO QBAwgKjNh0erC5I2/hh1AYKBAURtsqcE7bKSP/fgBWAkhAFErfb8Kljnx19/4E/q BAQEA4ja5J446Ch1Q1Kmvfe/CcXqCAQCA4ga9Drx4C4tg3iFzK0FC3/8+L256gzY jgFETBn9Tjxg18YB/+uxacXMT1+fpK6AxQL+Nzz4WvzhyA7NG9Tdurlw9cLv3v5s i7rnV3X6DujdsZG6wjNb8qZ+9MZUdcWv6hxy0r7tcuvv9JtNG/Lmfvyf5eoeRBhA rUNuOrzKywtzPnhkuqalTI/zjtijSQj/Umxa9sM7ryonp+tVx3as/E/Wf/J3Pqwi F8K/64Ex5Lrmsf7xqnevX2I6ZZu6A07t3bae4p5N2fDThy99p7jj1vf1axrrn+fd P9R0CipjAFUGPRT/p8xpt7xhsORXzS747d7NnPi7sGn+56+9Y/ZTIqfe2S3uv1v3 5+EGS1CNE3/pLdRqXPyDYpu8Ox81VBLJueC0no1N3ZkVtiz6+Nnxpu7syltifp+/ w7Q+Sw2VIAYGUOL0V2r9I6uvN3AWgqyzzjigmf93Y6FN88Y+Z+CKSRfdl1vrnznj Vf87EAcDqDD0mkT+1NLz3ve14pArj2rp9PNf8tOrw339detxzyd0LrEHh/gZgZo4 fQCovHRmgn9w8oB5PiU0unjgXkF8g7PXtq4c/9Q4n257t9H7JPgnX/69TwmoDQNo 3ssDE/+zIy704Rf2B13R1+1v/Srb+v2LI7x/h0zdf5+b+B8eleh/EuExjgPjhjyQ zJ/O/+Mob+++/9UHZ3t7iyGwdfGoJ7z93NzAf+Uk88ev5f0wGgygab0/T/ILvumX 59V91zln8H4ZXt1YyGxd8dbDnl1Gs/m7ByT5FQd/4dV9IxkMoGGNlyT//df193tx zxmXnd9jJy9uKLzW/O8hT14Zvu6+pL+koPVaL+4ZSWIADZta8/v/YpvZZ1Gad1vn wsv3qpPmbThh7VsPpPt9YNtxnVP4qmlBvgZ9cDGAZl2Q4hv/b7wnnXs94aZeddP5 eresGPmPdP57c8PdqX3doGfTuFOkiAE0qu6aBil+5U9Hp/qBgS53H5/qnbpqy9yH nkvxpPqtxu+Z4p1uaMJ1nMxjAI16Pom3RlSV0guFWTf8sXXqd+mwkgm3T0zhy5J7 ib+yEeel/rVIEQNoUuM16Xz15KNXJ/kVR9zXi5c9UrZy2EMrk/uK3PGJvvU5pia8 DmIcA2jSC39I68uLLxqZxJ/O+ttFO6d1d9j06c3JfBt4zjPpfbjmP2en9eVIAQNo UEbaV+oZ368owT/Z6fE+fPPngV/u+ldJYn8y6920r5+cmeBdwTMMoEEPpP+h9/xT P0jkjw24t0vad4UyG0bckcjrT8e+kdRHP2Iaem3aN4HkMIAGrYx5WuAkjTqrtuuG 1BlyLT/7emnTB9fV9t7AOi8m8QHvuFa5eWoyJQbQnP2/8eRmVvT5oaZ/nTV0UH1P 7gcVtkz+04Sa/v3e47z5T84BXMLOMAbQnHd/69EN1XD+uEaPDwz1ZT1kts76yztx /2Vi53dMwHv9PLohJIgBNKfIsxPwzT16Qcx/nju8P698+Gb+kNdi/vP24zt4dRfF WV7dEhLDABrTZ6yHNxbr/AiN/nUq8+eruX8aU/0fpnDmg/j6+nV2VsTGABrzdn8v b21ynypv0s166iw+7+u7GZdWuZpSs3Fpvfe5qjEneXlrqBUDaMwajy+9VunD83Xu u4oT/Zmw9etLvo/6f1M9uUU8a5t4e3uoBQNoStuFXt/iZ79dV/5/XnkP5zswZct7 V8zb/n82eu8Qr2+9XbonPkNSGEBT7rzZ85ssurjso3FHv8AJD0wqfvLW0v/0nPO0 969Z3HWL5zeJGjCApkzaz4cbnfjb/EiLMQf6cMuoyaohz0Zy3jvMh1v+dn8fbhRx MYCmFPjy9uSii/b5My/9Cnz9+m2+vGWlkCtWGcUAGuL9rwARSvwS0CgG0JBUT5QO x6R38QMkiQE05Nt91QUIhO/8+F0x4mEADdmqDkBAcEiaxKNtCAOIxHBImsSjbcax 76sLEBDHJXTKW3iDATTjoyPVBQiIj49SF7iEATRjXUN1AQJifSN1gUsYQDP4FSAS xTFpEA+2EV1+UhcgMPacoS5wCANoxPAL1AUIjGcHqQscwgAaMaOzugCBMZNLmprD ABrBrwCROA5Kc3isTegX/4JiQFUnvKsucAcDaMIrp6sLECCvnqEucAcDaMIvrdQF CJClu6gL3MEAGpC9QV2AQGlQoC5wBgNowGWPqwsQKJc/oS5wBgNowMRD1QUIlE/9 uNoIYmEADdjAdR6QjAIucmoKA+i/rtPUBQiYbtPVBa5gAP335GB1AQJm2KXqAlcw gP77eTd1AQJm3u7qAlcwgL6ru1FdgMCpt0ld4AgG0HcXDFcXIHAGPasucAQD6DvO ho+kcV58QxhA3+XzngYka0OOusARDKDfevyoLkAA7TVFXeAGBtBvnAwaKeC00GYw gH5b3FpdgABa0kZd4AYG0Gc569UFCKKtjfLVCU5gAH123X3qAgTS9ferC5zAAPps 8t7qAgTSD/uoC5zAAPqrzmZ1AYJpc8YWdYILGEB/nTNCXYCAOnekusAFDKC/OBcq UsRZUU1gAP1VlKkuQEAVZ6kLXMAA+qrPWHUBAqvvOHWBAxhAX73TT12AwHr3BHWB AxhAX3E1EKSMK4MYwAD66egP1QUIsGPGqwvCjwH00wd91QUIsLHHqgvCjwH0U0F9 dQECrJBfoPiOAfRRv3fUBQi0E95VF4QeA+ij8UepCxBoHx2tLgg9BtA/fA4Y6dmY xeeBfcYA+mfwk+oCBNylw9QFYccA+mdqN3UBAm5ad3VB2DGAvmm8Rl2AwGuyVl0Q cgygb/7xZ3UBAu+hv6gLQo4B9M2yFuoCBN7yluqCkGMA/XLQF+oChEDvL9UF4cYA +uUTzmeJ9E08XF0QbgygT7I3qAsQCg0K1AWhxgD6ZOg16gKEwoND1AWhxgD6ZFWu ugChsLqpuiDUGEB/cB4EeIQzIviJAfTHT13UBQiJGXuqC8KMAfRFjx/VBQiNvaao C0KMAfTFZwerCxAanx+iLggxBtAPLZapCxAiLZerC8KLAfTDmwPUBQiR0aeoC8KL AfRB7ip1AUKl6Wp1QWgxgD54u7+6AKEy5iR1QWgxgN7jN4DwGL8F9AsD6L2xfdQF CJlxXGDaJwyg59rPVxcgdHZdoC4IKQbQc9/uqy5A6Hy3n7ogpII1gB3+b+9OuTkN 6tfbuHFj8epFc6Z984M6qZoT/qsuQAidaN+Hy/c+oFvHtrmZ9erV21i4IX/17B/+ 31x1UvICM4B1TjvzwLYx/vn6xdPHv5xnPCeuOnmcvQPeW9XcoksENz/z6K5tGsb4 F4u+evl1izoTEIwBzL729zWeXKBo/hcvjrXjgX/iUnUBQunJy9QFper0Pav3rlk1 /YkZLz0QoHO4BmEA+9/RM5E/tuTrV14r8bulNp1nqAsQUl1mqgsyfndGr9aJ/MHv /zbG7xavWD+Adf52dZPE//QvX7745ib/Ymo3v73y3hFiC3ZV3nvdU846aJfE//ia h++w4yey2lg+gHXvH1w/2a9Z9MmzH/jRkoiH/qS6Z4TeP2UXmj72gsNj/f69RoXD rpN+K5IgqwewzsMXZ6T2lbPeH6Y4iRqXwoSPJJfI7DH4uD1S+8qSp6+2/7tAmwdw 8JPpfHXRtNHDDL86nP1LI7N3CKes28XwqwvNBw/oVuMLHrW5dJhXKX6xdwAPeS2J XznEsebr//zH4Pfh3+9j7r7goMkJvRrojbp/+EOvJH77Hscvv/vMgxYf2TqA2W8c 79EtLfjgse89uqlajDjHzP3AWSPPNXM/Pa841qtX8/53qtVvirF0AP/4aFrfeVdR 9MPrT6318PZiu+UO3+8Crvvbnb7fReNLTtvb06Pvyn95eGtes3IAW4zdy/PbzPvk qfc9v9FoVz7i680D21z1qK83f9wlhzf3/EZ/7Gvv2bxsHMDLH/PphqePfmSpTzcd uexxv24ZiHL5E37dcqurBnT16aavsPbosG8AG489wM+bn/bo0368Nn/9vT7cKFDd X+/z4UbrXHxlNx9udodv+vr/O6iUWDeAp4/M9P0+fn5x2CJvb3Hk2d7eHhDXCx6/ 2NZ28Fm7e3uLMRSf86rv95EKywawzqunGrqn+ZPHveLVz8O5X3T26JaA2s3s7dVF klqd0WcfU5+we+N0G98WbdcAdv3Y+9/A1qB48eSxr6X/+9k/Pp7i51WAlJRcnv4L qy1+13efNv7/tBUl78jpJu8uMVYN4DVDBXf66wqOe3NJ6l/f5Q1ff3kCxDDt1DRO O9T6lD6Gt2+7IQ8K7rRmFg1gxtjDdXe+aPqnb3+Xwtf1eKa35y1A7b64KJVPu+97 0qFdkz6vgXc+6Ss/YV0V9gzgvuMbqxPWLJj8yZgkfjGYcc3Fu/kWA9Rs3tMPJjEn rfofvk/79D/blqa1R6fybYaPrBnAG+5WF5RbvWTmtx99XVzbH+t88UkpniUD8Mis t5+u9TSpmb2O2q9z61wTOYm48R51QSWWDGDGB0eoE6panbdw1s+zp8/cXO3fZB90 xH49JL9DAaoqXjzl2wlfVv+87U6du3bafY92za1ZvnITjrXpx2A7BrDNj9Y9TRWK SoqLCwq3bvs/f5OV1SA7Wx0EVFNQsKGoqOwvaf3szMwMLz/N67HVey1WJ1SwYwCz V1r8fAHwUFEzi84PY8UA7vT/+qoTABgy9v+q/15JxYoBzF7eQJ0AwJANLez5FtCK AYwc+ZG6AIAhR32sLqhgxwBG/nm1ugCAEQ/bdOlESwYwMn1PdQEAA37y66SDKbFl AHOX8DowEH5Frb06lY0nbBnAyMmj1QUAfDfgLXVBJdYMYOS589QFAHz2/Pnqgsrs GcDIPFNnZgSgMX83dUEVFg1ga4s+IAPAB23SOPOmLywawMjZI9UFAHx0zgvqgqps GsDImwPUBQB8M/oUdUE1Vg1gnSUt1QkAfLKstX2XRbJqACOdZqkLAPhkj9nqgurs GsDI5Y+pCwD44orH1QUxWDaAkbF91AUAfDDOynPe2TaAOevVBQB80DBfXRCLbQMY ue4+dQEAz11/v7ogJusGMDKrk7oAgMdmW3oJRfsGMLJpJ3UBAE9trqsuiMPCAWy7 UF0AwFPtFqkL4rBwACP3X6suAOChB65TF8Rj4wBGfmmlLgDgmaW7qAvisnIAI1vs zAKQvK111AXx2bk03aeoCwB4pMdUdUF8dg5g5Plz1QUAPDHC5nO9WzqAkdVN1AUA PLAmV11QE1sHkF8DAmFg8y8AIxYP4BEWXT0eQIqOnKAuqJG1Axj533HqAgBpev94 dUHN7B3ASEF9dQGAtBRmqwtqYfEAZhSrCwCkJbNEXVALiwcwct5z6gIAaTj/eXVB bWwewMik/dQFAFL27f7qglpZPYCRknrqAgAp2pihLqid3QOYu0pdACBFTVerC2pn 9wBGbrhbXQAgJTfeoy5IgOUDGPl5N3UBgBTM211dkAjbBzCy2e5P0gCIZUswrmxh /QB2mKMuAJC0jnPVBQmxfgAjT1yqLgCQpCcvUxckxv4BjOTtrC4AkJQVzdUFCQrA AHJmLCBYLD8HVpQgbEuvr9QFAJJw4NfqgkQFYQAjo09WFwBI2FsD1AUJC8QARvIb qAsAJGhDjrogccEYwMhWdQCABAVkVEoFpPXU19UFABJy2hvqgiQEZAAjnx2sLgCQ gM8PURckIygDGCkOwKl1AOeVZKoLkhKYAcxZry4AUKuG+eqCpARmACPXDFUXAKjF kAfVBckJzgBGZndUFwCo0ZxO6oIkBWgAOTMWYLeAnAMrSpAGkDNjAVYLyDmwogRp ACNPXawuABDX05eoC5IWqAGMrMpVFwCIY3VTdUHygjWAnBkLsFVwzoEVJWCDcsTH 6gIAMR05QV2QgoANYGTcMeoCADF82EddkIqgDWCkMEtdAKCaovrqgpQEbgAzitUF AKrJLFEXpCRwAxi5ZJi6AEAVg59SF6QmeAMY+amLugBAJTP2VBekKIADGNkUuM/b AKG2ua66IFVBHMC2C9UFAKK0W6QuSFUQBzDyz6vVBQB2ePhP6oKUBXIAI8uDct15 IPzyWqgLUhfMAeQjcYAtAvkRuHIBHZJeX6kLAJQ68Gt1QRoCOoCRMSeqCwD86r/9 1QXpCOoARgqC+ckbIFwKs9UFaQnsAPKROMACAf0IXLnADmDkvOfUBYDzzn9eXZCe 4A5g5Ie91AWA437cW12QpgAPIB+JA7SC+xG4ckEeQD4SB0gF9yNw5YI8gJFHr1AX AA577Ep1QdoCPYCRlQG8DBUQEquaqQvSF+wBjGxVBwDOCvh4lAr4/4Z+76gLAEed 8K66wAMBH8DIxEPVBYCTPj1MXeCFoA9gpKSeugBw0MYMdYEnAj+AOevVBYCDGuar CzwR+AGM3HarugBwzu23qQu8EfwBjCxurS4AHLOkjbrAIyEYQE4PDZgV6JNAVxKG 7eD00IBRgT4JdCVhGEBODw2YFOyTQFcSigHk9NCAOQE/CXQl4RhATg8NGBPwk0BX Eo4BjFz2uLoAcMTlT6gLPBSSAYzM6qQuAJwwew91gZfCMoCRzaF5YR6w2JZwnYc9 NAPY5Sd1AeCAPWeoCzwVmgGMPH+uugAIvRHnqQu8FZ4BjKxrqC4AQm59I3WBx0I0 gJweGvBZmPaiVJj+Bw18WV0AhNqZo9QFXgvTAHKpdMBPgb8MenWhGkAulQ74J/iX Qa8uXAPYYY66AAitjnPVBd4L1wBGRp6tLgBC6oVz1AU+CNkARvIbqAuAUNqQoy7w Q9gGkPPCAL4I0zlgKoRtACOXDFMXACE0+Cl1gS9CN4CR2R3VBUDozAnp6ZbCN4Cc FwbwWsjOAVMhhAPYfYq6AAiZHlPVBT4J4QBGRp+sLgBC5a0B6gK/hHEAI4VZ6gIg RIrCe9GxUA4g74UBPBTOd8CUCuUARq67T10AhMb196sL/BPOAYwsbKsuAEJiUTt1 gY9COoCRLWH9HwaYtTXUbysL6070+kpdAITCgV+rC/wU1gGMjDtGXQCEwId91AW+ Cu0ARooz1AVA4JVkqgv8Fd4BzFmvLgACr2G+usBf4R3AyN03qAuAgLvnRnWBz0I8 gJHlzdUFQKDltVAX+C3MA8h7YYB0hPsdMKVCPRH93lEXAAF2wrvqAt+FegAjk/ZT FwCB9e3+6gL/hXsAuVAwkKowXga4mpAPYJef1AVAQO05Q11gQMgHMPL6qeoCIJDe OE1dYELYBzBSFPJ3sgO+KHbjrMKhH0A+EAKkIOwfAdku9APIB0KA5IX+IyDbhX8A IyubqguAgFnVTF1giAMDGNmqDgACxoVdKOXC/9CzR6oLgEA55wV1gSkuDGBk5h7q AiBAZnVWFxjjxABGNof/Q92AV7Y49PkpNwaw53fqAiAw9v1eXWCOGwMY+fBodQEQ EONdupyOIwMYKamnLgACYaNTF9NxZQBbLFMXAIHQcrm6wCRXBjDy1MXqAiAAnr5E XWCUMwMYWZ+jLgCsl99QXWCWOwOYUawuAKyXWaIuMMudAYxc9bC6ALDc1Y+oCwxz aAAjC9uqCwCrLWqnLjDNpQHkMplATRy4DGZVTk1Cn7HqAsBifcepC4xzagAj3zhw nT8gRZMOUBeY59YAclYEIB6XzoGwg2MD2H2KugCwVI+p6gIBxwaQsyIAsTl1DoQd XBvAyEYXLncPJGuTm6cLcW4A2y5UFwAWardIXSDh3ABGXj9VXQBY543T1AUa7g1g pNip850BCSjJVBeIODiAuavUBYBlmq5WF4g4OICR4ReoCwCrPDtIXaDi4gBGCuqr CwCLFGarC2ScHMCc9eoCwCIN89UFMk4OYGToNeoCwBoPDlEX6Lg5gJF1jp34G4hr fSN1gZCjA8j58YHtXDsLfiWODmDkhrvVBYAVbrxHXaDk6gBGVjZVFwAWWNVMXSDl 7ABGtqoDAAu4uwCl3P2ff8kwdQEgN/gpdYGWuwMYWdxaXQCILWmjLhBzeAD5IRjO c/n4L+XyA3Dq6+oCQOq0N9QFai4PYGR2R3UBIDSnk7pAzukB5ErpcJmD10Gvxu0F 4ErpcJiD10Gvxu0BjPzYQ10AiEzZS11gAccHkB+C4Sp+AN7G9eP/iI/VBYDEkRPU BTZwfQD5IRhu4gfgUs4PID8Ew0X8AFyGo58fguEgfgAuwwBGfuqiLgAMm7GnusAS DCA/BMM5/ABcjmOft0PDObwFuhwDGOGHYDiGH4B3YAC34YdgOIQfgCtw5G/DD8Fw CD8AV2AAS/FDMJzBD8BRGMAy/BAMR/ADcDSO+zL931YXAEacNEZdYBMGcLv57dUF gAELdlUXWIUBLMclkuACjvhKeDjKDfq3ugDw3YXD1QV2YQB3WNZCXQD4bHlLdYFl GMAK/BCMsON4r4IHpMI1Q9UFgK+GPKgusA0DGGV1E3UB4KM1ueoC6zCA0fghGGHG 0V4ND0m0u25SFwC++fvN6gL7MICV5DdQFwA+2ZCjLrAQA1hJRrG6APBJZom6wEIM YGXDL1AXAL54dpC6wEYMYBUl9dQFgA82ZqgLrMQAVtF2oboA8EG7ReoCKzGAVY07 Rl0AeO7DPuoCOzGA1WzmhJEImy07qQssxQBW0+srdQHgsQO/VhdYigGsbmo3dQHg qWnd1QW2YgBj4AIhCBUuAxIXh3oMA19WFwAeOnOUusBaDGAsv7RSFwCeWbqLusBe DGBMnBYG4cFBHh+PTUy33KEuADzytzvVBRZjAGPbkK0uADxRwBmOasAAxpazXl0A eKJhvrrAZgxgHK+fqi4APPDGaeoCqzGA8Wziw0MIvq29JqkTrMYAxtN9iroASNtN d6sL7MYAxvVjD3UBkKa87nnqBLsxgPHxiTgE3ZET1AWW4xiP7+yR6gIgLSMu2KJO sBwDWIMVzdQFQBqKus5TJ9iOAawJn4hDkJ00Rl1gPQawJv+8Wl0ApGzi8QXqBOsx gDUqylQXACnasvdUdYL9GMAacY04BNZVj6oLAoABrNlXvdQFQEqW9FitTggABrAW vBkQwXToZ+qCIODwrgVvBkQgPX/hZnVCEDCAtVndRF0AJK14z3nqhEBgAGuTUawu AJJ2+mvqgmBgAGs18mx1AZCkyYfwFsCEMIC148yACJitPX9QJwQEA1i7nt+pC4Ck 3H6buiAoGMAEzOqkLgCSsKbLcnVCUDCAieCkCAiSY8arCwKDAUzEdfepC4CEvXPK RnVCYDCACSnMUhcACdrcbaY6ITgYwIS0WKYuABI0+Cl1QYAwgImZtJ+6AEjIsq6c BCFxDGCCOCkCgoGTICSDwzpBVz2sLgAS8OZAXgFJAgOYqIL66gKgVps7z1UnBAoD mCheB0EAXPyMuiBYGMCEfXmgugCoxS9d16oTgoUBTByvg8B2B3+hLggYjunEXTJM XQDUaNQfOA10chjAJGzIVhcANdjUcYE6IWgYwCTkrlIXADU4/3l1QeAwgMn4vLe6 AIjrlz3XqRMChwFMCq+DwF69v1QXBA8HdFI4LxasxVmwUsAAJqcoU10AxLRlDz4D kjwGMDkd5qgLgJiGPLRFnRBADGCS5nRQFwAxrGvPZ0BSwAAmi+uDwEZcByQlDGCy nrhUXQBU8/WhvAKSCgYwaVwnHdbZ2nWGOiGYGMCkHfKpugCo4oG/8gpIShjA5K1o pi4AKilus1KdEFAMYPIyitUFQCWnjFYXBBUDmIL/HacuAKLM61qkTggqBjAVfCQY Ntn3e3VBYHEkp+KaoeoCYIcxp/EWmFQxgCkpqacuALbb2n6ROiG4GMCU9PxOXQBs d/sdvAUmZQxgapY3VxcApYpb8iHg1DGAqeGtMLAEb4FJBwOYogmHqwuAXy3pyFtg 0sAApoqzwsAGB0xSFwQaA5iq225VFwCR8cdyJeB0MIAp21hXXQDnbd2NKwGnhQFM GWeFgdzQ63kLTFoYwNStbqIugOM2NuctMOlhAFOXs15dAMf94WW+AUwPA5iGn7qo C+C0ta14C0yaGMB08FYYKB0+UV0QeAxgOkafrC6Aw2bvyVtg0sUApoUTA0Knx1R1 QfBxAKflljvUBXDWuON4BSRtDGB6uEYmRDgNoBcYwPT0GasugKMeu5pvANPHAKZp Q7a6AE7a3Iz3QHuAAUxTi2XqAjjp0qf5BtADDGC6FrdWF8BBhU1K1AmhwACmjXdD w7zjP+DvnRcYwLR93ltdAOcs34UfgD3BAKaP/xTDNM4D7REGMH18IA6GzenMN4De YAA9wLeAMKvbdHVBWDCAHnj0CnUBnPLNQXwD6BEG0AucEwEm7T5PXRAaHLleuO4+ dQEc8v5v+QbQKwygJzgnAsxpuVxdEB4MoCcGvqwugDNeOI9vAD3DAHqjpJ66AI7Y mstZELzDAHqj11fqAjjivhv5BtA7DKBHOC0WjNjSgCvBeYgB9EiHOeoCOOH6oXwD 6CEG0CvrGqoL4IBNmeyflxhAr3BmVBhw+TAG0EsMoGfWNFYXIPT4BtBjDKBn+BYQ vhv8DAPoKQbQO6ty1QUIuY0Z6oKwYQC9k7tKXYCQG/Q83wB6iwH00Ipm6gKEGt8A eo4B9FDOenUBQu3c//ANoMcYQC/l7awuQIiVZKoLwocB9BLfAsJH57ygLggfBtBT S1uqCxBaxVnqghBiAD3Ft4DwzVkvqQtCiAH0Ft8Cwid8A+gHBtBbfAsIn5w1ipeA vccAeoyPg8AXvAfQFwygx/hEMHxx6TB1QSgxgF5bn6MuQAhtrqsuCCcG0GucGho+ uP5+dUE4MYCeK+TVOnhtCxee9gcD6DkuEAfP3fdXdUFIMYDeK+b1Onhra13eAuMP BtB7/d5RFyBknr5EXRBWDKAPNvKKHby0NatEnRBWDKAPzh6pLkCovDJQXRBaDKAf NtdRFyBMGhSoC0KLAfTDLXeoCxAiH/ZRF4QXA+iLLTyu8EyLPHVBeHGg+uL1U9UF CI05ndQFIcYA+mOrOgCh0W26uiDEGEB/TO2mLkBIrG2iLggzBtAnfAsIbxwzXl0Q ZgygT7hCJjzBtTB9xQD6hBOjwhOcCNVXDKBfCuqrCxACnAfLXwygXw75VF2AEHj0 KnVBuDGAvtnEf7uRNg5Qf/H4+uaaoeoCBN4Hx6kLQo4B9A+fh0O6mqxVF4Qcx6h/ /sd/vZGeBbuqC8KOAfQRb4ZGevb9Xl0Qdgygj5a2VBcg0Iq5wKDfGEAf8WZopIU3 QfuOAfQT14dDGrZyYnHfMYB+4uIgSMOoM9UF4ccA+op3wiB19YvUBeHHAeqr0Ser CxBYczuqCxzAAPqLd8IgVT2mqgscwAD6a3FrdQECqojTCRnAAPord5W6AAF14XB1 gQsYQJ8VcUJfpIL3wBjBAPps0L/VBQikV89QFziBAfQbL4MgFQ0K1AVOYAD99l1P dQECaCUX1TKCAfRbRrG6AAF0wrvqAjcwgL4r5JQeSBbXQjKEAfQdHwhG0l46S13g CAbQf7wMgmTxMWBDGED/fbO/ugABs6K5usAVDKABfAuI5PQdpy5wBQNoQAGf6kQy eAnEGAbQgIEvqwsQKLwEYgwDaALnRUUyMkvUBc7gyDSBl0GQhLwW6gJ3MIAm8GkQ JOH499UF7mAAjeDycEgYJ8IyiAE04oa71QUIjHF91QUOYQDN4K2ASNTOK9UFDmEA zfillboAAcG1QExiAM3oMEddgIC4/n51gUsYQEN4KyASw18Uk3i0DZl4qLoAgbCk jbrAKQygIbwVEAnhPAhGMYCmlNRTFyAAeBOgWQygKUOvURcgAL44WF3gFgbQGN4K iNrtukBd4BYG0Jj8BuoCWG8TvygxiwE0ZtC/1QWw3qtnqAscwwCaw8/AqE3DfHWB YxhAc1blqgtguZJMdYFrGEBz+oxVF8Byj16lLnANA2gQPwOjZhyOpvGIG7S4tboA VivgjQKmMYAG9fxOXQCr3Xa7usA5DKBJ/AyMmnA0GsdDbtLCtuoCWGxDjrrAPQyg Sd2nqAtgsRvvURe4hwE0ip+BER8Ho3k85kbxMzDi4idgAQbQKF4HRly8BizAAJrF z8CIh2NRgAfdrJVN1QWwVHGWusBFDKBZp76uLoClnr5EXeAiBtAwfgZGbJkl6gIX MYCGcV5oxMS5oCUYQMPuukldACuNPVZd4CQG0DR+BkYs7RapC5zEAJq2sa66ABbi esAaDKBpHx6tLoCFfu6gLnATA2haRrG6ABY6/n11gZsYQOO28JijGv5SaPC4G8eJ 8VFNfkN1gaMYQOO4OByqGXqtusBRDKB5vBEGVe20RV3gKAbQvCKufo3KtuykLnAV A2jeywPVBbDM5J7qAlcxgAL8DIzKDpikLnAVAyjAG2FQGX8hVHjkBZa1UBfAKlwN RIYBFDjvOXUBrDL8QnWBsxhABX4JiGiN16kLnMUAKmziXQ+owJlgdBhAhand1AWw yPKW6gJ3MYAK3aeoC2CRvzykLnAXAyjBLwFRgYNQh8deooQr4KAcn4MTYgAlvtlf XQBrLGqnLnAYAyjRYY66ANa4+Bl1gcMYQA1+CYhyHINCPPgaK5qpC2CJlTurC1zG AGpwSixsN+pMdYHLGECN1ovVBbBEmyXqApcxgCL8EhBlOASVePRF1jZSF8AK6xqr C5zGAIq8f6y6AFb44Dh1gdMYQJG9J6sLYIV9flAXOI0BVOGXgNiGI1CKh1+Fi2Pi V8VZ6gK3MYAqMzqrC2CBmV3UBW5jAFXuvFldAAvcdYu6wG0MoEpWoboAFqhfpC5w GwMow6sg4ABU4/GX4a3Q4G3QagygzCeHqQsgN/FwdYHjGECZ/m+rCyB30hh1geMY QB1+CQiOPzGeAB0GEBx/YjwBOotbqwsgtqSNusB1DKDOiHPUBRAbea66wHUMoE7X aeoCiHWbri5wHQMoxC8BXcfhp8YzIMQAuo7DT41nQGhZC3UBpJa3VBc4jwEUeve3 6gJIvddPXeA8BlDo2PfVBZA67gN1gfMYQCV+Ceg2jj45ngIlBtBtHH1yPAVKazgZ ksvWNlEXgAFU+ry3ugBCXxysLgADqHTJMHUBhAY/pS4AA6hUd6O6AEL1NqkLwABK 8SqIyzj49HgOpAq5LLa7iuqrC8AAai1opy6AzML26gIwgFqjT1YXQOatAeoCMIBa XBjJYVwQyQIMoBavgriLY88CPAlaDKC7OPYswJOgVZSpLoBIMe8AsAADqLWwrboA Iot4B4AFGECtMSeqCyDy3/7qAjCAar97VV0AkdNfUxeAAZTjVRBXcejZgGdBjAF0 FYeeDXgWxIoz1AWQKOH1fxswgGJ5O6sLILGiuboAEQZQ7usD1AWQ+KaXugARBlDu H39WF0Diob+oCxBhAOW6T1EXQKLHVHUBIgygHi8Du4kjzwo8DWoMoJs48qzA06DG +2CcxLtg7MAAqvE+GCfxLhg7MIBqvA/GSbwLxg4MoBrvg3ES74KxAwOoxvtgnMS7 YOzAAMrxMrCLOPDswPMgxwC6iAPPDjwPcgygizjw7MDzILc+R10A4/IbqgtQigGU +3k3dQGMm7e7ugClGEC5sX3UBTBuXF91AUoxgHK33aougHG336YuQCkGUK7zDHUB jOsyU12AUgygHi8Du4fjzhI8EXoMoHs47izBE6HHALqH484SPBF6+Q3UBTBsA+/9 tAQDqLewrboAhi1qpy5AGQZQ75PD1AUwbOLh6gKUYQD1HrtcXQDDHr9CXYAyDKDe gDfVBTDslNHqApRhAPWyCtUFMKx+kboAZRhAC/A+GNdw2NmCZ8ICDKBrOOxswTNh AQbQNRx2tuCZsEBBfXUBjCrMVhdgOwbQAsu5SLZb8lqoC7AdA2iBqd3UBTBqWnd1 AbZjAC3wdn91AYwac5K6ANsxgBa44W51AYy68R51AbZjAC3QfYq6AEb1mKouwHYM oA14H4xbOOqswVNhAwbQLRx11uCpsAED6BaOOmvwVNiAAXQLR501eCpsUJSpLoBB xVnqApRjAG2wuom6AAatyVUXoBwDaIP57dUFMGjBruoClGMAbfD1AeoCGPRNL3UB yjGANhh1hroABr0yUF2AcgygDW6+U10Ag265S12AcgygDXp/ri6AQQd/oS5AOQbQ CrwR0CUcdPbgubACA+gSDjp78FxYgQF0CQedPXgurMAAuoSDzh48F1ZgAF3CQWcP ngsrFPLpUHcUcRFAezCAVljTWF0AY9byyW97MIBWWNxaXQBjlrRRF2AHBtAKXBjT IVwU0yIMoBXGHaMugDEf9lEXYAcG0ArDL1AXwJhnB6kLsAMDaIUhD6gLYMy1Q9UF 2IEBtMJhn6gLYMzhE9UF2IEBtEJmkboAxmQVqwuwAwNoBz4K4g6OOYvwZNiBAXQH x5xFeDLswAC6g2POIjwZdmAA3cExZxGeDDswgO7gmLMIT4YdijPUBTCkJFNdgAoM oB3yG6gLYMiGHHUBKjCAdljZVF0AQ1Y1UxegAgNohwXt1AUwZGF7dQEqMIB24HxY zuBsWDZhAO3w8RHqAhgy4Uh1ASowgHZ4eaC6AIaMOlNdgAoMoB3u+au6AIbce4O6 ABUYQDsM+re6AIZcOFxdgAoMoB32/VZdAEP2+05dgAoMoB04IaAzOB2gTRhAS/Bh YFdwyNmEZ8MSDKArOORswrNhCQbQFRxyNuHZsAQD6AoOOZvwbFiCAXQFh5xNeDYs wQC6gkPOJjwblmAAXcEhZxOeDUsUcZ5gNxRnqQsQhQG0BKeEdgQnhLYKA2gJTgnt CE4IbRUG0BKLW6sLYMSSNuoCRGEALTG7o7oARszppC5AFAbQEt/voy6AEZN7qgsQ hQG0BOfEdwRnxLcKA2iJt/urC2DEmJPUBYjCAFri34PUBTBi+IXqAkRhAC3BRUEc wSVBrMIAWuLKR9QFMOKqR9UFiMIAWqLfO+oCGHHCu+oCRGEALdF1mroARnSbri5A FAbQEjttUhfAiLqb1QWIwgDagvNhuYEjzio8HbZgAN3AEWcVng5bMIBu4IizCk+H LRhAN3DEWYWnwxYMoBs44qzC02ELBtANHHFW4emwBQPoBo44q/B02IIBdANHnFV4 OmzBALqBI84qPB224LqYTuCqmHZhAG1RUF9dAAMKs9UFiMYA2mJdQ3UBDFjfSF2A aAygLbgwsBO4LLBdGEBb/NJKXQADlu6iLkA0BtAW89urC2DAgl3VBYjGANpiWld1 AQyY3k1dgGgMoC0m7acugAHf7q8uQDQG0BafHKYugAETD1cXIBoDaIt3+qkLYMC7 J6gLEI0BtMXLA9UFMGDUmeoCRGMAbTHsEnUBDHhqsLoA0RhAW9zzV3UBDLj3BnUB ojGAthjygLoABlw7VF2AaAygLc57Tl0AA85/Xl2AaAygLfqMVRfAgL7j1AWIxgDa Yo+Z6gIY0HmWugDRGEBbZG9QF8CABgXqAkRjAK3BOfFdwAFnF54PazCALuCAswvP hzUYQBdwwNmF58NDzf54bsucGNc2Ki7OX7N00ayfps8uruGrGUAX1HTAZXbquuce bVs1ycmM9Zcof9mIf630rctVDKA3fn/+Pk3rJfqHi0vyV+ctmPPrIEb/RpwBdEH0 AZf96+B1bN88Nycj4SsCblw1+bmXfMhyFgOYtg63HdcyrRsoWp+3eM7Mn9/0qAc2 O2X3zh3bNG+Y3sUxl71/21yPelzHAKYl6/FTcj26qZIMj24INvPsaV795uVFHt2U yxjA1B374F7qBDjtx2s+UCcEHQOYomajOYMz9CYO4IWRdDCAKRl2bn11AlCqcASn GEwdA5i8rPG91QlAlC+O5teBKWIAk/btvuoCoIrvuKZgahjAJI3toy4AYhjXV10Q SAxgUq6/V10AxPHX+9QFAcQAJmNpeu94Bvy0rJW6IHgYwMRd9bC6AKjR1Y+oC4KG AUwYv/2D9fhNYJIYwEQtb64uAGqV10JdECwMYGLaz1cXAAnZdYG6IEgYwIRwyTYE BheeSwIDmAj2DwHCAiaOAUwA+4dAYQETxgDWjv1DwLCAiWIAa9VhjroASFJHzhid GAawNjffqS4AknbLXeqCYGAAa8O1ihBEHNkJ4WGqRQFnPkUQFWarCwKBAazZqDPU BUBKXhmoLggCBrBGOevVBUCKGuarCwKAAaxRScIXOwcss5ELrdaOAazJ2/3VBUDK xpykLrAfA1gDzoCAQOO8CLViAGtQlKkuANJQnKUusB4DGN9tt6oLgLTcfpu6wHYM YHy8BRpBx/FdCx6guL7qpS4A0vT1geoCyzGAcfENIIKPA7xmPD7xrM9RFwBpy2+o LrAbAxhHsxXqAsADO69UF1iNAYyDH4ARDhziNeHRie2yx9UFgCcuf0JdYDMGMDa+ AURYcIzXgAcnpjcHqAsAj4w+RV1gMQYwJr4BRHhwkMfHYxPL/45TFwCeef94dYG9 GMBY+AYQYcJRHhcPTQxPDlYXAB4adqm6wFoMYAycBguhwmmx4mIAq+M8qAgZzowa DwNY3dRu6gLAU9O6qwtsxQBWx0sgCBuO8zh4YKr5pZW6APDY0l3UBZZiAKvhG0CE Dwd6bDwu1TCACB8O9Nh4XKphABE+HOix8bhUtaaxugDw3Nom6gI7MYBV8Q0gwogj PSYelqoYQIQRR3pMPCxVMYAII470mHhYqljYVl0A+GBRO3WBlRjAKvgGEOHEoR4L j0oVDCDCiUM9Fh6VKhhAhBOHeiw8KpW1XqwuAHzRZom6wEYMYGWreb8owmlNrrrA RgxgZfwEjLDiWI+BB6UyBhBhxbEeAw9KZQwgwopjPQYelMoYQIQVx3oMPCiVLG+u LgB8ktdCXWAhBrASvgFEeHGwV8djUgkDiPDiYK+Ox6QSBhDhxcFeHY9JJQwgwouD vToek2g/7KUuAHzz497qAvswgNGKM9QFgG9KMtUF9mEAo/ETMMKMo70aHpJoDCDC jKO9Gh6SaAwgwoyjvRoekigD3lQXAD46ZbS6wDoMYJRVnDENYba6qbrAOgxgFH4C RrhxuFfFIxKFAUS4cbhXxSMShQFEuHG4V8UjUqHDHHUB4KuOc9UFtmEAKwy/QF0A +OrZQeoC2zCAFQqz1AWAr4rqqwtswwBW4FeACDuO9yp4QCowgAg7jvcqeEAqMIAI O473KnhAKjCACDuO9yp4QCowgAg7jvcqeEAqMIAIO473KnhAdvjyQHUB4LOvDlIX WIYB3IGLoiP0uDh6FQzgDlwQBKHHZUGqYAB34FeACD8O+Mp4PHZgABF+HPCV8Xjs wAAi/DjgK+Px2IEBRPhxwFfG41Hu897qAsB3XxysLrALA1jul1bqAsB3S3dRF9iF ASxXwKnSEH6F2eoCuzCA5fgVIFzAEV8JD0c5BhAu4IivhIejHAMIF3DEV8LDUY4B hAs44ivh4dhu1BnqAsCAVwaqC6zCAG43rau6ADBgejd1gVUYwO1W5aoLAANWN1UX WIUB3I6TYcEJnBCrEgZwO14DgRs45KPxaGzHAMINHPLReDS2YwDhBg75aDwa2zGA cAOHfDQejTIv/l5dABjx0lnqApswgGV+2EtdABjx497qApswgGVWNFMXAEas3Fld YBMGsExJPXUBYMRG3vEahQEsw2sgcAXHfBQejDIMIFzBMR+FB6MMAwhXcMxH4cEo wwDCFRzzUXgwyjCAcAXHfBQejFJcFBjO4NLAURjAUqubqAsAQ9Zw6ssKDGApfgKG OzjoK/BYlGIA4Q4O+go8FqUYQLiDg74Cj0UpBhDu4KCvwGNRigGEOzjoK/BYlGIA 4Q4O+go8FqUYQLiDg74Cj8U27/RTFwDGvHuCusAeDOA283ZVFwDGzN9NXWAPBnCb /AbqAsCYDTnqAnswgNvwK0C4hKN+Bx6KbRhAuISjfgceim0YQLiEo34HHoptGEC4 hKN+Bx6KX43toy4ADBrXV11gDQbwVwvbqgsAgxa1UxdYgwHcZlo73hgAV+Qv7KZO sAcDWGHU/i3ZQYRX/rJJA9UNtmEAqxl1QAt2EGGSv/wbli82BjCelw/g+0EEXP6y b85UN9iNAazNtx2y66kbgKRsLJi7n7ohGBjABI3r3jhL3QDUomjtVN7TlQwGMDkj DmrRgG8IYZuNG5Z/ea46IogYwNSMOqB5Q3UDEFmfx+sb6WAA0/PCgc2zM9QRcE5J Qd5XZ6sjwoAB9Mjo/ZvwojH8lr9m0gB1Q6gwgF4bvX/jLH5LCC9tLFrL7vmDAfTN Y0c0b8iZppG6DevzJlyhjgg5BtCAoUe2aJLFbwqRiJKiNcs/HqKucAYDaNY/jmna KCtTXQHLFBetW/XhX9QVLmIAde4/tmnDrPrqCogUFq1f9cF16grXMYCWuKdfk5z6 dXn1JMw2birMX/PuDeoMRGEArXTzSY0b1c9gDwNu46aSwnVr375L3YG4GMBAuPm0 hg2yMhlEy23cVFy0Yf3rDF5wMIAB9edzs7OzM+ruxCaqbNy8qaSgoGDEQ+oQpIEB DJFBl2TlZGfW22kn3nLjrZLNmzcWF+QXPTVcXQKPMYAO+N21GdmZmRm/LmMdvmGM b+OWX3eupLi4oOSB19QtMIQBBOAsBhCAsxhAAM5iAAE4iwEE4CwGEICzGEAAzmIA ATiLAQTgLAYQgLMYQADOYgABOIsBBOAsBhCAsxhAAM5iAAE4iwEE4CwGEICzGEAA zmIAATiLAQTgLAYQgLMYQADOYgABOIsBBOAsBhCAsxhAAM5iAAE4iwEE4CwGEICz GEAAzmIAATiLAQTgLAYQgLMYQADOYgABOIsBBOAsBhCAsxhAAM5iAAE4iwEE4CwG EICzGEAAzmIAATiLAQTgLAYQgLMYQADOYgABOIsBBOAsBhCAsxhAAM5iAAE4iwEE 4CwGEICzGEAAzmIAATiLAQTgLAYQgLMYQADOYgABOIsBBOAsBhCAsxhAAM5iAAE4 iwEE4CwGEICzGEAAzmIAATiLAQTgLAYQgLMYQADOYgABOIsBBOAsBhCAsxhAAM5i AAE4iwEE4CwGEICzGEAAzmIAATiLAQTgLAYQgLMYQADOYgABOIsBBOAsBhCAsxhA AM5iAAE4iwEE4CwGEICzGEAAzmIAATiLAQTgLAYQgLMYQADOYgABOIsBBOAsBhCA sxhAAM5iAAE4iwEE4CwGEICzGEAAzmIAATiLAQTgLAYQgLMYQADOYgABOIsBBOAs BhCAsxhAAM5iAAE4iwEE4CwGEICzGEAAzmIAATiLAQTgLAYQgLMYQADOYgABOIsB BOAsBhCAsxhAAM5iAAE4iwEE4CwGEICzGEAAzmIAATiLAQTgrP8POqwLpgeK9FUA AAAASUVORK5CYII="/></symbol><g mask="url(#b)"><g transform="rotate(.193) scale(.36014)"><symbol id="c" viewBox="0 0 1280 1280"><image width="1280" height="1280" xlink:href="data:image/png;base64, iVBORw0KGgoAAAANSUhEUgAABQAAAAUACAIAAACXhmigAAAACXBIWXMAAA7EAAAO xAGVKw4bAAEUI0lEQVR4nOzdh5sc1Znv8Qmd00RJgwJBgaQAxiYajDGYXe+yYLCR jdf2f3mf3efhXt+7tgFjMNhKKIFGk3PoVF2x79td0ng0oWOd6p6u7+eRxVjqOXWm e1Rzfn3OeU9/HwAAAAAAAdDf6Q4AAAAAAOAHAjAAAAAAIBAIwAAAAACAQCAAAwAA AAACgQAMAAAAAAgEAjAAAAAAIBAIwAAAAACAQCAAAwAAAAACgQAMAAAAAAgEAjAA AAAAIBAIwAAAAACAQCAAAwAAAAACgQAMAAAAAAgEAjAAAAAAIBAIwAAAAACAQCAA AwAAAAACgQAMAAAAAAgEAjAAAAAAIBAIwAAAAACAQCAAAwAAAAACgQAMAAAAAAgE AjAAAAAAIBAIwAAAAACAQCAAAwAAAAACgQAMAAAAAAgEAjAAAAAAIBAIwAAAAACA QCAAAwAAAAACgQAMAAAAAAgEAjAAAAAAIBAIwAAAAACAQCAAAwAAAAACgQAMAAAA AAgEAjAAAAAAIBAIwAAAAACAQCAAAwAAAAACgQAMAAAAAAgEAjAAAAAAIBAIwAAA AACAQCAAAwAAAAACgQAMAAAAAAgEAjAAAAAAIBAIwAAAAACAQCAAAwAAAAACgQAM AAAAAAgEAjAAAAAAIBAIwAAAAACAQCAAAwAAAAACgQAMAAAAAAgEAjAAAAAAIBAI wAAAAACAQCAAAwAAAAACgQAMAAAAAAgEAjAAAAAAIBAIwAAAAACAQCAAAwAAAAAC gQAMAAAAAAgEAjAAAAAAIBAIwAAAAACAQCAAAwAAAAACgQAMAAAAAAgEAjAAAAAA IBAIwAAAAACAQCAAAwAAAAACgQAMAAAAAAgEAjAAAAAAIBAIwAAAAACAQCAAAwAA AAACgQAMAAAAAAgEAjAAAAAAIBAIwAAAAACAQCAAAwAAAAACgQAMAAAAAAgEAjAA AAAAIBAIwAAAAACAQCAAAwAAAAACgQAMAAAAAAgEAjAAAAAAIBAIwAAAAACAQCAA AwAAAAACgQAMAAAAAAgEAjAAAAAAIBAIwAAAtCWRTA709/f191d+pt7/vZWGyuXy tt+dcrlYKHjZUQAAAo8ADABAc1Kp1D/jrquvb2BwUP47MDDg/t5Cs44jmbd873fb LlezcCUO34/E+Xze468EAICAIQADAFBHPJEYrCZbN/HKRxJ3JeUOVkOv0ktL+LVt W1KxRGJnKw/LHzqOViwqvTQAAL2HAAwAwB4SicTA/dA7UDVYpTrx1ubm4XuR2HHc MCwfFAnDAAA0gAAMAMA/uRt63aXMEnlDoZCE3k53al+ShC3Lujc5XF08zbZhAABq IAADAHB/vvf+TG8kEul0j5pmGIY7M1yuTg4zJwwAwG4EYABAcG3PvdFotLXiVd1G 0q+u6yRhAAB2IwADAALn3jrn+4ucw+Fwp3ukhGma7gLpMocqAQBQRQAGAASIO+Ur Kqk3HO5sRSt/SPqtJGHTdJgQBgAEXu//4AcAIJVKSfar5N5QKBKJDHRxXSt1HNs2 DKMyJ1x9KjhVGAAQQARgAEAvk+grv/f397tTvr2xy7cdkn7dCeHKkcJ9fcRgAECg EIABAD0rmUwODg5K7g0FY7Vz4yT9SgYWtm0X2BsMAAgMRgMAgB6USqUGqqcZhUIh CXuk393cp8WyLMMwHNtmKhgAEAQMCAAAvSYzNCTRd7C60ZfoW5u7ENqubg/Obm52 ujsAAKjFsAAA0DsymUw4HB4Mhdjr2yzHcWyrsiw6m812ui8AAKhCAAYA9IJ0Oh2u Lniunu/LT7dWlKssicGGkcvlOt0dAAC8xxABAHCwpVIpt8zVwMAA0bd9koEdx3FL ZLExGADQYxgoAAAOsKHh4cqa58FBoq+3JAbbti0ZeHNjo9N9AQDAMwwXAAAH0taa Z7b7qlOZCmZFNACghxCAAQAHTDKZDIUrJP12ui+BYFWLY8n/ODEYAHDQEYABAAcJ E78dwVQwAKA3EIABAAdDKpUaDIUq077hcKf7ElDViWDLtiyKYwEADigCMADgAEin 0+6yZyZ+O8txHHc5NFPBAICDiAAMAOh2maGhavhl4rdbVM9IMrObm53uCAAAzSEA AwC6VyqVCoVCkWiUid9u4ziOoesWy6EBAAcKARgA0KUqy56r6be/v79cLnPSb/dw Xw753c3ALIcGABwUDCYAAF0nlUr1DwyEw+FIJNLpvqAOwzBM0yw7DlPBAIDuRwAG AHSXZDI5GApFqmcddbovaIhlWRKDbcvioGAAQJcjAAMAuoh71pGk38HBwU73pWnl cllCeyqdPnToUCweP3fhQoOfeOXSpZKmLS8v53M5CZMHcbG3bdtuBmYeGADQzQ7e j1gAQK+qlLyqLnseGBg4EJt+HceJxWJDw8NHJiYaj7uNkEi8uLCwubFRKpW6vwCY +2JVymIZhmWaZGAAQNfq9rEFACAgJP1K9o1Go53uSB1u6D185MiZJ56Q3OvDFSUJ 37pxY2lx8UCEYV3XTcMgAwMAuhMBGADQeal0OhIOR7o4/UrulU6eO3/+5OnTHezD 1cuXb1y/rpdK3bxE3NB1wzTzlIYGAHQfAjAAoMPSkn6j0XA43OmO7KEbcq/bjVwu t7GxIR+4f7I4Pz8zNaXrencmYdM0JQZzPBIAoNsQgAEAnSTpNxqNhros/brrnB9/ 8klvd/a2oFwuu9HXtu09HzB99+783JxtWd22OtoyTZ0MDADoMgRgAEDHVNJvLNZV xx1J9D0yMfHiyy+n0unO9kSib6FQWF9ftyyr7oNLmnb75s3s5mZXTQhLz/VSiQwM AOgeBGAAQGd0Yfo9febMD158sdO9qNA0bW1tzTCMZj/x25s3lxYXu2c2mAwMAOgq BGAAQAdI+o3F490zXXnuwoWOr3Z26bou0bdUKrXTyPTduzNTU10Sg8nAAIDuQQAG APgtlU4nEokuiWfdE31N01xfXy8UCl412D0x2LZtTdOoCw0A6DgCMADAV6lUKp5I dMPcb/dEX8uyNjY2FM2RdkkMrmTgYpHzgQEAnUUABgD4J5lMxuLxUCjU39+xH0CO 4zz+xBNdstdXOpPNZiX9lstlpRf69ubNxYWFDr7vIF+g5PySpnk4xQ0AQLMIwAAA n3RD+h0aHn7t9dc7XuG5736R57W1tf3ON/KcVixeu3LFMk1/LrcbGRgA0HEEYACA T0ZGRyORSAfT7xtvvXVkYqJTV9+uVCpJ9NV13efrOo6zMDc3+d13nZoKlgxsGMb6 2lpHrg4AAAEYAKBcKpUKhcPRaLQj6dc92vfNt9/2/9K7WZYl0beDU6CmYWjF4re3 b5c0rSMbgyUDS/K3TJP9wAAA/xGAAQBqSfqVoBVPJDo199slE7+SwzerVG/3rUsr FEzTzOVyd+/c6chUsDwDEsLlCSEDAwB8RgAGAKiVTqfjHTr06NDhw10y8VsoFFZX V33b7ltbWZJnLufm8G9v3zZ8X4ndV307QDIwhwMDAHxGAAYAKNSpQ48k3b348ssn T5/2+bq7maYp0VfTtE535AGWaRbvL8NeW12dm531/zVyC2IxCQwA8BMBGACgSjKZ jMZikUjE5+tKlvvZO+90vNSzhPDNzU0fjjhqjVYsmobhfqzr+u2bN/2fpTcMQy+V KAoNAPANARgAoISk31A4HI/Hfb5ulyx71jRtdXXV7NyZQ3VJLK8shHacrT/pyHJo eaIs0yQDAwD8QQAGAHjPLXwVi8f9nFR0HOfCs8+eu3DBtyvuybZtib4HItFZllV8 cAXy4sLCyvKyz69aSdMoiAUA8AcBGADgvXQ6HY3FQqGQb1eUBPXSK690fNNvLpdb W1tztk2rdjkJnztmff3fEiw5XC+VKIgFAPABARgA4LFUKhWORKLRqG9XLJfL//Hz n3d206+kuJWVlW4rdlWXPHWFXG5HYtd1/daNG35mYLmiaRhMAgMAVCMAAwC8VFn8 PDgYj8d9O/W3G9JvLpdbXV3tzmJXde1eCN3newaunAysaY5tk4EBAEoRgAEAXkpn MnEft/5GIpEPLl7051p7sm17ZWWlWCx2sA/tKxWLxv2K0Ntdu3rVt4GCPJOlUimX zfp1QQBAEBGAAQCeSaVSkWhUQmm5XPZhBrjj6Vdy7/Ly8gHa8buf3RWht/iTgd1v GKNyLJLOJDAAQB0CMADAG5J+B0Mh38496mz6ldC7trbWS3WbLNMs7lO52s95YE3T bMsiAwMAFCEAAwC8kc5kYrGYP7tGO5t+DcNYWlrq5jN+W6MVCvt9Ub5l4EpFaF1n ITQAQBECMADAA35WfpaM/eFHH/lwoT3l8/mVlZUDWu+qtrLjVBZC7/OlXb182Z+t 3VSEBgCoQwAGAHhgaGgo5kvl5w7WfJZLr66u9tKy590keWr7FPTyrS60PM8lTdvc 3FR9IQBAABGAAQDtSqfTkUgkHImovpBTLr/bofRrWdbS0pKEQP8v7bNiPi9f7J5/ 5VsGNivlsIzefq8BANARBGAAQFtSqVQoHI7FYqov5DjOm2+/fWRiQvWFdiuVSpJ+ bdv2/9L+qxzGu3/ylFA6NTnpw1poec4t02QhNADAWwRgAEBbMplMVH3tK0m/L778 8qkzZ5ReZU8S+VZWVvy/bgfppZL82u9v11ZX5+fmVGdgy7IMXc9SDQsA4CkCMACg dVu1r1Qf/Hv02LEfvfGGuvb3JF/URpXP1+04+cILuVyN840n79zZb6uwVx2Qbyeq YQEAPEcABgC0LjM0JOlX9fRvNBZ7/5e/VHqJ3SSDLS8vF/Y5Grfnmaap1fzar1+7 proUtm3bkoGzVMMCAHiHAAwAaFEqlYpEoxHFta8cx/nN73+v9BJ7XnRxcbG0/zLg ICjk8/Y+1bBcVy5dUv3eR6UWlq4zCQwA8AoBGADQoqHh4Wg0qnQvqATRf3v33eHh YXWX2M227YWFBUlefl60C8nzUKhZh1nX9ds3b6r+BpCrbAZvFToAQBECMACgFalU StKv6qOPHn7kkVdee03pJXawLEvSr2mafl60a5WKxdpvBMxOT6uuU2VW5oCZBAYA eIMADABohQ/Tv5Kuf3Hxorr2d5P0Oz8/v98puAHkOE7lSKSae31VbwZmEhgA4CEC MACgaZXp31gsHA6ru4Rt2//27rsjIyPqLrED6XdPtY9E6qsuhL5144bSzcCmaUof mAQGALSPAAwAaNrw8HBE8fTvyTNnXnjxRXXt7yB5W9IvK593K5fL+Wy29hzv4sLC 2uqquj44jmPoegDPowIAeI4ADABojg/Tv6Fw+IMPP1QasLeTfCXpl6pX+5HwWdK0 2o9RvRCaSWAAgCcIwACA5gwNDUVUnv1r2/ZP//VfDx85oqj9HSS2LSwsBPzEo9rk KSrkco7j1HiM6oXQ8l0hOXyTM4EBAO0hAAMAmuDD9O/E0aM//slP1LW/nUS75eXl QqHgz+UOLtMwtGKx9mNUV4RmEhgA0D4CMACgCZmhoajK6V/HcX75619HFJ+utGVt bY1JxUY0Mgksrly6pHQSWNf1LK8XAKANBGAAQBNGx8bC4XB/v6ofH9/7/vefeOop RY3vkM/nl5eX/blWD2hkEjiXy81MTSnqgIRw0zSVVtsCAPQ8AjAAoFHpdDqeSKir TRWNxf7j5z8PhUKK2t9O1/X5+XmldZt6TIOTwDdv3LCVHSUlV5cQLjFbUfsAgJ5H AAYANGp4ZCQSiSgKwJJtfvTGG8dPnFDR+A62bc/OzsrvPlyrlzRSDlrX9ds3b6r7 JjEMY2N9XUXjAIAgIAADABqSTCbjiYS66dloLPbeBx/4cPRRuVxeXFzU6gU57NbI mcB9iieBLcvSikXqlgEAWkMABgA0JDM0FIvF1M3svf6Tnxw7flxF4ztsbGysM4XY Kr1U0usdGaV6ErhUKlEKCwDQGgIwAKAhSstfRWOxd99/X10B4S2Snebn51VfpYdJ /sw3cNaRuklgSmEBANpBAAYA1JdKpeKJhKKA6tvuX7nQ7OyspWx1bkBoxaJpGLUf o3QS2LZt6QMHAgMAWkAABgDUNzQ0FFW2/tm36d/V1dVsA7OXqM22rEID4VPdJLDj OHqpxAHOAIAWEIABAPWNjY+HQiEV658lzLz24x+fePhhz1vegcXPHsrnck69Gtrq JoHL5bJlWasrK563DADoeQRgAEAdqVQqkUwqmv7tHxj44MMPw+Gwisa3sPjZW42c hySuXb2qaJwhL2ixUGAVNACgWQRgAEAdQ8PDsVhMUfmrC9/73tNnz6poebv19fWN jQ3VVwmOcrmca2AFci6Xm5maUtSBUqm0yWsKAGgSARgAUMfY2FhITf1nx3He//DD eDzuecvbmaY5MzOj9BIBVCwULNOs+7Arly6p2N1dWQVtmqvUggYANIkADACoRen6 58MTE2+8+aaiueUtCwsLWgPrddEU0zS1QqHuw2anpxUVHmMVNACgBQRgAEAtmaGh eDyuaPr3nZ//PJPJeN7ydoVCYWlpSeklgqmyClqSbblc95FXL19WVApL07QstaAB AM0gAAMAahkZHY1EIioCcCgc/uDDDxXNLbskI83OzpoNrNRFCxo5EFhcv3at3EBO bpa0aRjG+tqa5y0DAHoYARgAsK94IpFKpRSd0Pvk008/+9xzKlreks1m2SaqToOr oNdWVxcXFlR0wLbtfD4vOVxF4wCAnkQABgDsS9JvMpVSMf0r0eWDixeVlr9yHGdm Zsaud1wtWtZgLeg+laWwKpuA2QYMAGgYARgAsLdYLBaJRhVtAA6Fw7+4eFFp+auN jY319XV17UMU8/lGTldWtwpa07TKocSlkueNAwB6EgEYALC3eCJRycBqNgCfPX/+ /DPPeN7sFsdxpqen5Xd1l4CohM8GKmwrWgXtbgOW9MsqaABAgwjAAIC9qdsAbNv2 xd/8JhwOe97yls3NzTXKI6nn2HY+l2vkkYpWQbMNGADQFAIwAGBvkn5T6bSKlsOR yC8uXlTRsqtcLk9PT7P71x+5zc1GljcrWgUtJIGzDRgA0CACMABgD4lEIhQOy+8q Gj9+4sSrr7+uomVXLpdbWVlR1z620wqFRg6amp2ezmazKjpQLBYt0ywyCQwAaAAB GACwB4m+kWg0FoupaPyDixcjkYiKll2zs7NGA+fTwhMNbgMW31y9qqIDpVJJ+kAA BgA0ggAMANiDBOB4IqFim27ZcT76/e89b3aLxKH5+Xl17WMH27YLHd0GXDmOuFgk AAMAGkEABgDsIZlMpjMZFS0nksl3339fRcuupaWlQqGgrn3s0PhpwDdv3LAbODOp BblslhcdANAIAjAAYKdUKtXf359MpVQ0/uTTTz/73HMqWhaWZU1PTytqHPsp5HKN lBxbXFhYW11V0oF8XnI4pbAAAHURgAEAO1UqYIVCiWRSReO/+s//VHGwsGtjY2N9 fV1R49hPSdMMXW/kkYq2ARcLBcuyWAUNAKiLAAwA2EkCcDgSicfjnrfsOM5vVG4A npmZaaQiMbzVeB0sRduANU0zDYMADACoiwAMANipUgErHg8rKNQcCod/+atfed6s S9f1ubk5RY2jhsrsa2PLj69dvapi5CHpVzIwARgAUBcBGACwUyKZdFdBe97y2KFD P/2Xf/G8Wdfq6qqik2ZRW+N1sL69fbvBxdJNcdc/F6mDBQCohwAMANhJ0m86k1Gx U/fchQvyy/Nm+6oZbHp6upFSTFBBArC8BHUfpqgOViWBZ7PMAAMA6iIAAwB2Sol0 WkXL77z3nqKWOf63sxosBK3r+ne3b6voQD6Xowo0AKAuAjAA4AGxWCwciSQVlIBW WgFrbW1ts7FVuFChUoe5sfJjVy9fHhgY8LwDhULBNIxSqeR5ywCAXkIABgA8IJFM hgYHlZyBVC7/+ne/877ZqunpacuyFDWOuho/CUlRIehKArdttgEDAGojAAMAHhBP JCJqzkCSZj+4eNHzZoVpmjMzMypaRoMaPwlJUSFoTRK4YWhsAwYA1EQABgA8IJFM SlKNxWKetzw0PPyzd97xvFmRzWZXFZRWQuPMhsPnzRs3bAVz9aVSSQIwM8AAgNoI wACAB0gAjkWjkWjU85YPHT785ttve96sWFxcpAJwZzV+FLCik5AqU9C6TgAGANRG AAYAPCAhkkkVhwArOgOpXC5PTU05juN5y2icbduFXK6RRyo6CamSwAsF3gcBANRG AAYAPEDSbzweD4fDnresKAAbhjE7O+t5s2hK2XFy2Wwjj1QUgE3T1DSNGWAAQG0E YADAAyQAp5LJAQV1et94660jExOeN5vL5VZWVjxvFk0pl8u5xo6hktdrZmrK8w44 tp0vFAjAAIDaCMAAgAdIAM5kMipa/vVvf6ui2eXl5Xxju0+hVFYCcLncyCO/uXpV SQeyWQIwAKA2AjAA4AHJZDJ9oALwzMyMaZoqWkZTcpub5Y4G4Fw2WyAAAwBqIgAD AB5wsAKwJK7JyUnPm0UL8tlsg6XICMAAgE4hAAMAHnCwArCu63Nzc543ixbkcznH tht5JAEYANApBGAAwAMOVgDO5/PLy8ueN4sWFHI5mwAMAOhuBGAAwAMOVgBeW1vb bKz4MFQr5PO2ZTXySAIwAKBTCMAAgAccrAC8tLRE5ukSBGAAQPcjAAMAHnCwAvDc 3Jyu6543ixYQgAEA3Y8ADAB4gLoA/MJLL508fdrbNqemphrcdwrVGgzAa6uriwsL KjpAAAYA1EUABgA8QF0APnfhgvzysEHOQOoqDQZgSb+SgVV0gAAMAKiLAAwAeEAi mUylUgMDA5637HkAtixrenrawwbRjgarQCsKwI7j5PP5IgEYAFATARgA8AAJwIl4 PBQOe97y0PDwz955x8MGDcOYnZ31sEG0o8EAfPPGjQa3CjfFMs2iphGAAQC1EYAB AA84QAG4VCrNz8972CDakc/lHAIwAKC7EYABAA+QAByPx8MKAvDg4OCHH33kYYPF YnFxcdHDBtGOfDbrOE7dh129fFnFAnvTNDUCMACgHgIwAOABiUQiKmIxFY17exJS oVBYWlrysEG0I7e5WS6X6z7syqVLg4ODnl9dL5V0XS8Wi563DADoJQRgAMADEslk JBKJHYQAnM/nl5eXPWwQ7chubDTyMEWHAJdKJcMwmAEGANRGAAYAPCCRSITCYfld ReNvvPXWkYkJr1ojAHePcrmc29ys+7BcLjczNaWiA8VisbINmBlgAEBNBGAAwAMk +g6GQslkUkXj3p6EJGlqZWXFq9bQjrLj5LLZug9TdwhwoVCwLYsADACojQAMANgp nU4nUykVLXtbCJoZ4O5h23Yhl6v7MEUloEUhn8810AEAQMARgAEAO6VEOq2iZW8L QVMFuntYllXM5+s+TFEJ6L7qIUz5BjoAAAg4AjAAYKdEskJFqV7HcX7z+9971Zqm aQsLC161hnZUTiFqoACVohLQlfnnQoEKWACAugjAAICdEolEPJFQcRSweOe997ya XtZ1fW5uzpOm0CZD10uaVvsx8np9d/u2iqtX4nexyAZgAEBdBGAAwE6Vo4BjsWg0 qqLx02fO/ODFFz1pSmLPzMyMJ02hTZJ+JQPXfszs9HS2gUJZLZBorZdKBGAAQF0E YADATu70r6KTkBLJ5Lvvv+9JU+VyeXJy0pOm0CatWDQNo/Zjrl+7Ji+ZiqtL9HUn gVU0DgDoJQRgAMBOsVhMArCiQtASgT763e+8au3u3buO43jVGlpWyOfrlndWtAHY vboE4FKppKJxAEAvIQADAPagrhB0n6fbgGdmZiT5eNIU2pHPZmu/E6FuA3AfJaAB AA0jAAMA9pBIJJKplKL5uuMnTrz6+uueNLW4uMjOz44rl8u5zc3aj5m8c0fREuVK Ceh8nm8DAEAjCMAAgD1IAI7F45FIREXj0uwHFy960tT6+vrGxoYnTaFljuPk61W3 unb1qqIxh2EYJU0jAAMAGkEABgDsIZFMhsPheDyuonEPTwPO5/PLy8ueNIWWWZZV rLcC+erlywMDAyqurmmaaZocAgwAaAQBGACwh0odrEgkmUwqat+rw5A4Crgb1D0E WN0BSKJQKJiGQQUsAEAjCMAAgL1J+k2l0/39Sn5SeLUKulwu3717V9HhOmhQ3UOA 1a1/lpc+n8sVmP4FADSGAAwA2FsikYgnEqFQSEUG9nAV9NzcnF4zfUG1Yj5v1TwD SdH6Z0m/ct3K9l82AAMAGkMABgDsTdJvNBKJxmKKJoG9WgW9urqqbnktGpHLZsv7 n4Gkbv2zBGC9VNINQ1F9aQBA7yEAAwD2lkql+gcGEolEl6+CLhQKS0tL7beD1tQ9 A0np+udisSjZm0OAAQANIgADAPaldBuweOe996T9NhuxbXtqasqT/qAFtUtA67r+ 3e3bii7NBmAAQLMIwACAWsbGxxVtAxbHT5x49fXX229ndnbWMIz220ELapeAnrxz R9H6ZHcD8OrKiorGAQC9igAMAKhlaHg4pmwbsFelsNgG3EGSb8393324cunS4OCg iutKAC6VSpsbGyoaBwD0KgIwAKCWdDqdSCbVrYI+d+GC/GqzkWKxuLi46El/0Kx8 NuvsUwFrcWFhbXVV0XUrG4ALhVwup6h9AEBPIgADAOoYP3RocHBQUQaWlj/86KM2 G+E04E6pXQFL0elH7nVt215ZXlbROACghxGAAQB1jIyMRKJRdZPAb7z11pGJiTYb WVpaohiS/yzTLO7ztOdyuRllxckkABu6vr6+rqh9AECvIgADAOrIZDKxeFzRVF6f R+ch5fP5ZeYDfVc5hrdU2vOv1J1+1FfdPV7SNDZ+AwCaRQAGANR36PBhRaWMXO1P AksimpqaYhW0z4r5vGVZu/9c6fRvX/Xsq2UOfwYANI8ADACob2R0NBKJqFsF7ckk MKugfVZjA7DS6d/K+mfDWF9bU3YFAEDPIgADAOpLZzJxlaugHcd58+2325wEpha0 zyzLKubzu/88l8tNTU4q/W7RNC3H+mcAQPMIwACAhowfOhQKhdS13/4kcLlcnpqa 2u9IHnhuvw3ASqd/+6rBm/rPAIDWEIABAA0ZHh6ORKPqpvX6vNgJvLq6SmEk3xRy Odu2d/yh6t2/juMYur6xsaHuEgCAHkYABgA0JJVOJ+LxAZWlsNo/E9gwjNnZWa/6 gxrKjrPnImR1Z/+6HNsualo+l1N3CQBADyMAAwAaNTo2Fg6H1ZXCEucuXJBf7bQw Nzen67pX/cF+TMPQisUdf7i4sLC2uqruouVy2TRNpZcAAPQ2AjAAoFGZoaFYLKZ2 fs9xfvP737fTQi6XW1lZ8ao/2E+xULBMc8cfXrl0SelxWZXjf0ul7D6lpwEAqIsA DABoVDKZjMfjoXBY6VWGhod/9s47LX+6ZKTp6WlKYSlVOQApm+178NTlmzdu2Hud CewhidyapnHYFQCgZQRgAEATfCiF1f6RSGtra5tMEqpkShB9MIWqPvqoj/JXAAAv EIABAE1IpVKxeFzpeUiuX//2ty1/rmVZ09PTHnYGO0j6NR9c/6x68XNf9WUtaVp+ r5OHAQBoEAEYANCckZGRSDSqtBSWOHT48Jtvv93ypy8tLbFQVpHK+ucHJ9i/vX3b UFx4TC4ql1hfX1d6FQBAzyMAAwCak85k4rGY0vOQ+tpeCK3r+tzcnLddgmtH/Wcf Fj/3VU8/0kqlPQ9eAgCgcQRgAEDTRkZHo9GoDxdqZyH0/Px8qVTysDNwFfL57cWu fFj83Fd9R2N9bU31VQAAPY8ADABomj+TwH3tVYTWNG1hYcHb/sBxnPy2aVgfKj/3 Mf0LAPAOARgA0ArfJoFfeOmlk6dPt/a5s7OzhmF425+AK2na1nbftdXVRV/eYmD6 FwDgFQIwAKAVmUwmGov5sPbVcZx3338/lU638LmFQmFpacnzLgVWuVzOZ7Pl6vG/ Ekpv37ypeutvX7X4s0TuLNO/AAAvEIABAC3ybRK4r9XNwBLV5ubmmAT2yvbyV/5s /e1j+hcA4CkCMACgRZlMJhKN+nAmsEgkk+++/34Ln8gksIfyuZxj2/LB9WvX3Hlg 1Zj+BQB4iwAMAGjd8MhILBbz51rHT5x49fXXm/0sJoG9YplmsXq08uSdO9uPQVKq VCptcPYvAMA7BGAAQOvSmUwkEgmHw/5c7tyFC/Kr2c9iEtgT7ulHiwsLa6ur/lzR NE3DMCj+DADwEAEYANCW4eHhWDzuz7Ucx3nplVdaKAo9Nzen369djBZYllXM5yX6 zs/N+VD4ylXStI2NDX+uBQAICAIwAKAtqXQ6Eg5H/KqGJRn4zbffPjIx0dRncSZw mwr5/Mb6+tTkpG/p19B1wzTzuZw/lwMABAQBGADQrszQUCwW8y0alcvl//j5z5s9 GGl+fr5UKinqUm+zTHN9be3WjRv+lH3uq77NIS9WdnPTn8sBAIKDAAwAaFcymQxH Ir5Vw+prKQPruj43N6euS71Knur11dXr1675ln77qrWvTMMoVGtuAQDgIQIwAMAD PlfD6mspAy8tLZGpmpXLZi///e9+pl9qXwEA1CEAAwC8MTQ8HPerGpar2QwsyWpm ZkZpl3qMVix+/eWXfqbfvuqG7U1qXwEA1CAAAwC8kUqlwpFI1K9qWK5mM/Dq6mqW qcXGlDTtqy++8Dn96rpuGkY+n/fzogCA4CAAAwA8k85kYrGYz5GpqbORbNuemZmR T1Hdq4NucX7+u9u3fSts5pJXp1QqsfgZAKAOARgA4JlUKiXpN55I+HzdpjLw5ubm 2tqa6i4daB1Jv33VFdeSgZn+BQCoQwAGAHhJMnAoHI7FYuVyub/f158yx0+cePX1 1+s+TDo2OztrmqYPXTqIrl+96vMWXPdbpVQqWaZJ+gUAKEUABgB4LJ1OR2OxUCjU kUv/+3vv1X1YsVhcXFz0oT8HzldffGEahv/XtSxLL5VyuZz/lwYABAoBGADgsVQq NTA4GI/HfZ4BdjVYFmthYUHTtNYu4X5dcqHtf2iapqQ427LkA/m98nGVc+8/1f+a 5kB1g3T/gPx3cLD6e/WjilAoJP8Lh8OVj6oftNa91pQ07esvv/R/2XNf9ZmU18Jh 8TMAQD0CMADAe5WF0KFQzN9TkbY4jvPcD37w5NNP13iMYRizs7N7/pVkV0mDpVJJ 13VDfhmGVQ23ktOkZfmffCAR175fSav/Pm+/ivJ9967R1zcgvw8M3AvP1cAcrp69 HI3FotGoPNstVyCbnZ6empzsSPrtq2ZveXpJvwAAHxCAAQBKSAaORKORSKQjV5fc mEgm3/vgg+1/aJpmVmxs5HK5QqGwsb7uVl2SNOvcj5oSAjsyce2J7Zm5v/qVSFYO V3Ny5XyqaDQej8vTIr8PbMvJX37+uST8Tn3VhtB10i8AwB8H9Wc8AKD7deRUpO0c xwmHw051BXLf/anaTnWme2zlZAnJ8n86NfHbx7lHAADfMQ4AAKjS2c3A6HJs/QUA +I8RCQBAraHh4XiHNgOjm0n69fm8JQAACMAAALVSqVS4ugW10x1BF9F13TQM5n4B AD4jAAMAlEul0xKAfT7XB13LNE0JwHlO/QUA+I4ADABQK5lMDgxUju6RDNzBekvo Eo7jmIZhO1W2XSwWO90jAECAEIABAB6r1L6qHlc7cP/EWopgYU/VCGw7djUOV89Z ZlE0AEApRiQAgLZI3K0cLuTGXfkVCjHNi9ZUI/C2SEweBgB4jQAMoGMqwamamtz0 dO+MVhkCu+eU3p8RcqonuDIO7h7ywvXdC7z3JnhJvFBhKw+LMnm4y1TuA31999Z6 VG/i907Z7u93T5neuoUzsQ+gqxCAAfhNhk2DoXsaXBkrw1/Lstx5IQZSHeGuah6o hl3meNER9/Kw3AqqYZhY1RHu4d5CbuDyeyOfIi+cVSWvHS8ZgI4jAAPwTzqTCVe1 vCO0MpAyTTcMM5BSyl3Y7Ibexke6gG/cWLW1XpobglKVNy6rt4JQezdwsyqXzXrb PQBoHAEYgB8k+kYiEQ9PwXELycrwN8dJKt6plGuurmd2R7pM8+KgcCeH5YbghmH5 v+Rhr6TT6UrsjUQ8vCFIBjYMgxgMoCMIwADUSqVSknsj0aiKOsDMJ7TP3YntLmxu fFE60M3+uWnCcThtuGXtr9mpQe7ehq7L3Zu3KgD4jIEOAIXS6XQsHvdh9WxlNoEY 3LCt8mPy0iga3QLdYGtmmAoCTams2am8cxlRfSF5XUqaxkIeAH5i0ANAlczQUDwe 9zNcGVVM+OzH3cXnzvSyvBlBI2F4a2aYAlr7SaXTkSrfriivi6Zp2c1N364IIOAI wACUGBoaivmbfl0yltJ13WJZ3X33Vjjfi72hTncH6Ar3poWrBaV5y8wl94pQOBxV s12lNrlvlzRtkwwMwBcEYADe61T63SKj21KpFOQVj0z2Ao1gWrjv/slGsVisg/cK MjAA3xCAAXgsnckkEolu2FZaKTSq64HaXZZOp2UgG64eVdLpvgAHTKW2vGkGbbew 3DQi0aiHJfpbJhm4WCxSygGAap0foQLoJalUKpFMds+Uo7si2jSMQqHQ6b6o4h7Y W5nuDYdZ5Ay0z10g7R6q1MNJOJlMhiORjqx53o8888VCoYefcwDdoFtueQB6gAyn YvF4N8wk7CCDKk3TemxiYWtzrzzhPtTZBgKoXC5XcnB1WrjHUlk6k4nH493zZuUW 0zRLmtbDb1kC6DgCMADPjIyMRGOxTvdibz1z5iS5F/Cfm4TlBtIDc8JKz2b3hF4q ra+vd7oXAHpWl977ABw46XQ6kUx27YjKVTlzslQ6oFPB8gxXcm8kQu4FOkWSsMRg icLOwayYlc5kYrFYl99DKpuBC4VAlW8A4KeuHqoCOChSqVQ0FuvCxc+7HbipYLee cygcPhBPLxAQbsUsy7IOSu3o7p/43U6eW71UOhBPLIAD5wDcBAF0v8zQUCKR6HQv mtD9U8GVg0kGBirlnCORAzFgBYLJXRptW1Y3p7UDMfG7Q7FYzHIqEgAFGFQBaFcy mUwkkwdraNXXxQWiJfq6uffAPaVAYG0tjbZtu6tuKV1Y6rlB8kwWC4WuejIB9IYD djcE0IWGhobiB2r6dzvLsvRSqRs2m92b8q0udT5wQ1UALoltpmFY3TEhnE6no7HY wT0dTSsWN5kEBuA1xlgA2iKxTdLvgZ6rLJfLpVKpgysYK7t8Q6EIU75Ar3AnhEWn dgi7d5VYLHag302zbVsycDe8lQCglxzg2yKAbpDJZBLJZKd74YFKzRVdz/s7FZxO p0MSfQ/g6kTsyXGcvmr42foT95XtHxjor/4u5G/lY0f+4zjyuPI+n9KFB7SiBW4M 9vnwpFQ6HY1Ge6NsXrFQyHZxsQYABxFDLgBtGR0bi0Qine6FNypTwZpmqx+qumf5 hlnt3MWq+dSRV6caWgcGQ6FwdWO2qJzAHAoNVP9OHhmqVtaNRiLygYep1S0ybOi6 UWVV95datu2mKfdj+UAeVq7qq2Zmvp26k9xV5EX0YZmJWzQ+Fo/3zHeCPG9rq6ud 7gWAntIj90cAHSGDraRkuV4ZabkqaUPXFY1TKxt9BwclQoV6YnLmIPpnXJSgUH0b QtJrNBaLJxLy6qRFJuNOoG3/LMmZuq6XquSD7RO2XUXisVYslrQK6W7lxK9qkeJK VK5+4f33dbqnQSTfRe57GepuL5HKWzE98o6kS75pC/k8q6ABeIgfgQBaNzQ8HI/H O90L78k4VXKOtydwuDMzMjxlo69q9yJuf3/lCQ+FJNwmkkl5/uXbdWR0VH41+BLY tr099Krutm8qaxxyOUkUWqGgV780S/7Istx4zNJr1Spz+9UqWd7W3ssMDcVisZ58 +TRN29zY6HQvAPQOAjCA1o0fOnRw64vW5R6S1P7MQzKZrKySpcaV19xVyvKsVmZw 4/F0JjM8PDw2Pi7fli3vfnQPiHYZhuFthw8E0zSzm5u5bLZYLOqaZlbP9ZGnmvXV 3pKn1J0Nbj8Gp1Ip96AjTzrWhSzLWlle7nQvAPQOfpgBaFEqnZaBV6d7oZYbh3Kt lmBh1tcrjm1Xlo5HIolkckhS7tiYpNyR0VFPIpkMr7dCr+S99hvsSfISSFSTfwvu 1HFlR6ttM2PcpvZjcDqTicViPX+HqayB7oLD6gD0BgIwgBb16vrnHWSE6k4FFwqF xj/L3esbJfo2z3EcyVTy1CVTqeGRkfHx8YmjRxNeHzQtQXcr9EoA9rbx4JB/HVqx uLG+LvmtsqC6WueJVNysSgyu7tZuKuMlk0l34jcIM/Osggbgod6/aQJQZGx8vDeO 2WhEZSpY0xqZpalE34EBGZb28OJwr7ibdQdDoXg8PjQ8fOjQoWPHj8sHii63FXq1 aq1vRVeB4zgS5NZWV/PZ7L1J9XJ5gHeC6mmqRFY6nY7F48F5f02+i1ZXVjrdCwA9 ggAMoBU9Wf+5tspUcHW2sMbwNJ3JuMfk+NmxA8Sd3ZXvnNHR0YmHHjp24kQsFlN6 RXd5syReZno7yD1gTALM5sZGsVAwLaufg4734di2XvPAJLn3hqql3YJ2+6UWNACv BOjuCcBDmUwmkUx2uhcdICFKYvDuqeBUOh2pngfbkV51J/e4oUgkMjQ0NH7o0MOP Pjo2NubDdW3bdhOv/E7o7U7yGkkYlkicz+XkH5T7zkigEl1t8n1rGIaz60zydDot 0TeYq0uKhUK21XIMALAdP2wAtGJ4ZET13F3X2jEVXJmQqZ4ly/DdXdIs3xgjo6NH jx179LHHon59k7gnV1WPv9UoZHXguHuJFxcWJBXL6yjBLziLe2swK4eSG+7bbcGc +N1OvjE21tc73QsAvSCgt1EAbVJ6AJKbo7p8haQ7FSyD0WgASrDWIMkzEokMj4w8 dPToY6dOeV6tqga3gq4bemVw7Nt1oZq8svlcbmlhIbu56b6yXX43UMctwmfbdrTr ywpUjsvq6wspuxlyGBIArxCAATRN9Qbgl3/4w+MPP/zVl1/evnmzm6c7ZGzazd1T pLquubLbeWJi4tTjj4+MjPjcAbeWlZt7JX77fHX4z7Ht9fX1xYUFScWWaQZwsXSX 32os25b7wNFjxzY3Nhbm5xVdhW3AALzSvfdTAF1Lwk9S2QZg27Z//dvfunOqMuL5 6osvbly/Htj5ny4hOTMcDg+Pjp44ceLk6dORSMT/Dmj3sa034CQFLc7Pb2xs6MGe HO4Gcrt29zts5fMrly6pWxFTKBRaPpUdALYQgAE0TekG4EQy+fKrrx46dGjrTyTw /Pl//mdudpaRrp/c0CsvxMkzZ048/HBHJqBM0yxWscIZezJ0fXFhYXV5WdO0/qpO 9ygo5P6QSCQeeeyxHbflb2/flhdF0UXZBgzAE/yoANC0Q4cPq3uP//QTT4yNjz/0 0EM7MnY2m/3Dxx9rxSJjXHVkUBsKheT5f+zkyUdPnuzIOw6VI3NKJQm9lLNCU+Tb ZmFubm11VZcwHLxl0r5x12M/durU7rdB5c+1UunO7duKLm3b9vLSkqLGAQQHPx4A NO3IxISiwaUEsJdfe00+CIfDx7Ytq9ty68aNLz//vJ+pYO+4e3qHh4dPnjlz6vTp ThXakaGtO9krudftEtCyYqEwOzOztrJiU1DaU7ZlTRw9Or5thc52g6FQMpX67E9/ UvTemdwZFhcWVLQMIFAIwACak0qnU6mUosZl2PT8yy+7H4+MjEgq2/0Yy7L+8PHH qysrzPC0o1K9ORp96OjRc+fPD+31PPtD13U39xqG0ak+oFdVSihrmkSmlZUVvVQK YPUsD8mTGYlETp4+vV+4lec2nkyGQqEvPvtMXXW6ShWsXcewA0BT+EkAoDkSSmPx uKLGR8bGHn/ySfdjGU4dO3YsHA7v+ciZ6ek//b//x3C2WTKKlbgro9gzjz/eqZmx rUXOgopWUM22LK1YdOuorSwv57LZsuMMMC3cDNu2Tzz8cI13yrbSr3x88/r19dVV RT0padrGxoaixgEEBGNHAM0ZGx/fL5S276lz5zJDQ1v/Nx6PT0xM7PdgGZP94eOP ZURLDK7N3bM3fujQuQsXJh56qIPdkARSKBSK1TTSqW4ggCrvuRSLW1vKLctaXVlZ W11lgXRdlYnfaPTkqVO1VzW7i5/dj7Obm99cuaKoP/IiymunqHEAAcGoEUBzDh85 omh/lwxGX/nRj3Ze7vDh2kcuTd29+8kf/0gG3k1GrgODg5J4Lzz7rP+n9W7vBrkX 3cAwDInB2/9E7jkba2srq6umYZCEd5Pn5/jDD++5FWW77dO/rk//+EdFz6fcQ5YW F1W0DCA4GDICaEJKpNOqWi+XX3z11R1/JqOo48eP147c7AreTgKnPGnHTpx49rnn 1B3X3Eg3yL3oNpLoKsuhbXvHn8u368b6+vLSkkESrpInJByJnNp/x++W3elXfP7n P/cpuxvnc7l8Pq+ocQBBwGARQBMyQ0OJREJR43vOAFcumsmMjY3V/fQ73377l08/ DWwGrqxzHhh46OjR733/+/KMdbAbpVKpUEXuRReqfItqmrlP0TX5pl1fW5MkbFlW YJOw3IqPHjs22sBdt+/Bxc9b1M0Ai2KxmN3cVNQ4gCAI6EgRQGtGRkej0aiixgf6 +59/5ZU9/+ro0aONXNcwjI//67+y2WygYrCMVsfGxyX3Htl/v7QPdF3P5/OSe+1d 02tAtzFNUysW+/Y/cEsCsMTg9dXVcrU6vZ9966DK+pFQ6PTp04ONHYe25/Sv+OLT Tx1lh5nJrWZ9bU1R4wCCIEBjRADtO3T4sLr39Y8eP37ikUf2/KtIJCIZuMFY+83V q1//7W89P2Z1HCcWjz/51FNPnT3bwcAvOSFftVVhCDgQKnWhG3i/RnLywvy8fId3 6ohs38hTcfjIEfnV+KfsOf0rpu/enZuZ8a5rD5B+Li8tKWocQBAQgAE0SukJwOVy +YVXXqmRWkdHR4e2FYiuTcas//2//peu6x71rrvIwP3YiRPPv/iiuuXojfShWCzm crlSqdSpPgBtqhwUXCoZDdwo5JFrq6tLi4vynd+rb66dfvzxpir87zf921e9P/xV 5YYUTgMG0A4CMIBGSf6M+74BeEvtY4H39LcvvrjxzTc9M1qVIXgsFjt7/vzWUckd IYlXcm+hUCgrW+II+KnucujtSppWmRDO5RpcJNz9JKwOj4wcO368qc+qkX5dSrcB y+u1yTZgAK0iAANo1OjYWCQSUdX6XiWgd5D491CTx9iur69//N//vbvo68EiI9RD hw+/+MorHaxuZdt2ddIlx1Jn9J4Gl0Nvf/zy0pJ7CPmBrjggX8jJU6daeGdzv8XP W5QWgjYMY211VVHjAHreAb5rA/BTKpVKJJPqZlMffvTRh44dq/uw8fHxdPPnMP3x //7fmenpgzgVXC6XT5058/3nn+9gQVpN0yT3FotFpnzRwxpfDr1ddnNzbm7OtqwD d3uR6Cu39MdOnmzhc+tO/4r52dmpyckWO1dPZQtGocBhSABaQwAG0JB0JqPuUNm6 65+3yCjz2LFjLVSjmZ+b+58//KH5rnWGjMXlazz/zDNPPv10p/ogQ0wZX2azWaZ8 ERxNLYfeIp8yOztb0rSDcnKS3HIfefTRdEsrShpJvy6lq6ALhUIum1XUOIDeRgAG 0JDh4eFYPK6o8cFQ6AcvvtjggxOJxJFm6pRukUT3fz7+eGVpqZuXLEr0jUaj8mw8 vE9BbB8YhiG5V9IvU74IIMe2i8ViC/sm5B/O7MxMIZ/v5hgs/6gjkcipM2davg3W Xfy85cvPP7ctq7Wr1FXStI2NDUWNA+ht3TsKBNBVxsbHmypA1ZTDR448dvp0449v bSG0uHr58j++/ro7Fyu6Na5efvXViSb3OXvYAU3TNjc3KeyMgJN/C5KvTMNo4XMt y5IYnMtmuzYGR6LRhx95pLX7eePTv+LO7dtLi4stXKURpmmurqwoahxAbyMAA6gv lUolUylFE6cy1nzu+edlTNb4p7S2EPqvf/nLt7dudeH0b8ejL6udgd0kAFeWQ7f2 uaY5JzE4l+vOGCy9euSxx6LN3HX7mky/wtD1r774Qt0PjkL1BHIVjQPobV03EATQ hTJDQ+qOnHXK5Zfr1X/eLR6PT0xMNP74v3z66Z1vv+229Ovu9X3ltdeaPYPEK5Zl Se6VYbpk4I50AOhmtm1rhULL/zokBk/fvVssFrswBg8MDDwqGTgWa/xTGl/8vOWz P/95QNldV57YLIchAWhed40FAXSnkdHRZucKGheLx5957rkWPrHxhdDdmX7F959/ /swTT3Tk0jI039zcZKMvUFtla0CxaLWxOKKkaRKDDdPsts0XlQx88mSD9/Zmp39d //jqK/nyW+pdfbqur6+tKWocQA/ruuEggG6j+gCkE488crSl+U8ZkB07dqzuTrZP /vSnqcnJrkq/juM8/sQTjdf98paMGiX6FgqFjlwdOIj0Uklvb298NpudmZ6WPN1V 9yK5sT/y2GOxevPAraVfMTczI+G/1d7VwWFIAFrTRXdhAN0pnU43u+ytcTKCefGH P2w5XUej0YceeqjGgPKTP/5x6u7d7hlxytd7ZGLi9TfeCCmrKFZDqVTa2NjQlE3I AD3Mqp6Q1OaKiSWxuDjYTVPBjWTgFhY/u+SO9/knn6h7/1Tiby6XU9Q4gF7VLYNC AF1L6QFIMpZ86Yc/bKeFkZER6eGef9Vt6TcUCr3x1ltj4+P+X1qi7/r6OuWdgXa4 U44tnJC0nW3bU5OThUKhezYG194P3PL0r+svn3yi7hbMYUgAWtAt40IAXUvpAUiZ oaGnzp1rs5GjR4/u3sb25eef37p5s0vSr4ybz54//8z3vuf/pYm+gIcqJyQVi+3X S8/nctNTU+WuWRE9GApJBo5EIjv+vM30K765ckVdqSoOQwLQgq647QLoWkoPQBKS fiUDt9mI5HPJwNtX2V29fPnS3//eDSNLGeCOjI7+5Kc/3T2yVI3oCyhi6LontZ3m 5+dXlpdD3TEVHI1GH3700R1Zt+XFz1sk/UoGbq9r++IwJAAt6PzoEEA3U3oAkm3b r/zoR540JUH90KFD7sd3vv32M5W7zhong7MfvvaajCl9vq5hGBJ9i60eYQqgLsuy tEKh/SLq8q9VblnSWjfcshLJ5PETJ7bWZrc//ev69I9/VLfem8OQADSLAAygltHR 0YiyA5BC4fD3X3jBq9YkAEsMnp+b+8PHH3d8c50Mi8fGx3/y05+2P3ZsimmaGxsb zIcAPnBsu9jGKcHbLSwsLC8tdXwqWG5cQ0NDR48f76/yJP2Kv/31r+2cI1Wboetr HIYEoBkEYAD7Un0A0sTRo4889phXrclwLZFI/O//+q+BLhhE+j/xa9v2+vo6BVEB P1VOCS4ULMtqv6nKVPB331mdPi5Y8vzY+PhDR496lX7F3Tt3FubmPGlqNw5DAtAs AjCAfaUzmWQyqahxGTj+4MUXPTwNSAaOX/zlL50dO8oXNTw8/NOf/czPiV8Z/2Wz 2Y2NjfZXYwJolvy700slQ9c9aW1+bm51ZaWza1hs2z524oSH707KzfnLzz9XV5Sh UCjksllFjQPoPQRgAPsaHhmpfThkO2TU+NKrr3rY2l8/+6yvowlQRo3nn332wjPP +HbFSgGYQmF9fd2TCSgALfOqLFZftUD03clJdxGyJw22wHGcJ8+eHRkd9arBv/z5 z+q+nMoJ5+vrihoH0HsIwAD2lkql4omEuomIVDp99sIFr1r7x1dfeTX6bNm//Nu/ eTherEvGfGtra7pH804A2uRVWay+6ntbt2/dklDdwSUt/QMDZ8+fb7ME9Jarly7l lW3QsG1bKxZZBQ2gQQRgAHtLp9NeDX329MTTTw+PjHjS1Lc3by4vLXVqtsQ96Ojt n/3Mt6GqjPYk+jLaA7qNh2Wx+rpgOXQsHn/q7FlP6iBurK/fuHat/Xb2U8jnqYAA oEEEYAB7Gx4eltGPosY9PABpaWHh21u3OjVPIiPds+fPP/O97/lzOQnb2Wx2fX2d 7b5Ad5J7glYoyC3Ok9Yk1E1NTnZwHnhkdPTU4497EsKVHoZU0rSNjQ1FjQPoMQRg AHsbP3RIXSWncCTy3PPPt9+OVix+/eWXnZohkZHu6z/5ybHjx/25nKZpq6urprLT RAB4olIaulj06uAf+Sd/++ZNabMji1zkuscfflh+td/UV198YRpG++3sybKsleVl RY0D6DEEYAB7SKXTKZXrn4+dONH+iEpGZp9/8kmnVj4PDAz8+3vvqauSvZ1t2xJ9 C4WCD9cC0L5KaWhNM7zLe7dv3dJLpY5MBXtVEGtmamp2etqTLu0pn8+r22YMoJcQ gAHsYWh4OK5s/bMMp1545ZX2p20vff21Vix60qVmpdLpn73zjg8zzzKMzuVy6+vr Xu0qBOAbiazyy6vWZqanN9bXO7LgRYL32QsXEu2932fb9l8//VRdhtc0bZNV0AAa QAAGsIfx8XEPT+jdqb//xVdeabON6amp2akp/6d/JZFOPPTQG2+95cO1DMNYWVmh zjNwcHl4PJJYWlyUXx3JwOlM5vEnn2zz54LSw5As05QbpqLGAfQSAjCAnVSvfx4d Hz/zxBPttFDI5//x1Vf+jwIl/Z46c+aFl17y4UIbVaovBEA10zQ17/YvrK+tzc7M dOTud+zEiROPPNJOI9cuX85ls151aTdWQQNoBAEYwE5K1z/LKOp7P/hBNBZruQXH cT7/5BP/98LJdS88++w5784u3o+u6ysrKx7uHgTQWZZpFr3LwJLyJr/7zv8MbNv2 U+fOtbMZuFAoXP76a3WTwKyCBtAIAjCAnZTWf3bK5ZdffbWdFq784x8F34/AdWxb uv3YqVNKr1Iul9fX1zc3N5VeBYD/LMuqZGCPDjArlUrf3brV7/v7gIOh0Nnz5+OJ RMstfPanP6l7+5Ja0AAaQQAG8ADV65/TmczT58+3/OkyuLl944bPW38l/f7wRz96 5LHHlF5F1/Xl5WVOOQJ6lV3NwF4d4m3o+q2bN/1fCzN+6NBjp0+3fN1LX32lebcp ejdWQQOoiwAM4AGq1z+fvXBBMnBrn27b9ueffOLzwj/HcX742mtK0688LZubm+vr 6+ouAaAbyE2smM97m4H7qzxpsBHyJTzx9NNj4+OtffrSwsJ3t2+zChpABxGAAfxT KpVKJBIDyhKmDPteamP989//9jcPzxRphKTfH73xxvETJ9RdwqxWLi35+3UB6BRv M7DcQG5ev+5zBh7o7z/7zDOtnYqkuoShbVmSgfO+b5MBcIAQgAH8UzqTSbZ30mNt Q8PDT54929rnLszPT377rc8THa//5CdK06+M0iT9ejUUBnAgyL2lUsjA0wzs81ro kbGxU2fOtJBj5Qu/fu2apXKvR6FQUFprGsBBRwAG8E8jIyPt1Geu6/mXXmptetn/ xc+O47z0yisnT59W1/7q6irTFEAw2ZblYTG/Uql0+9atQR8zsNyTH3/qqfFDh5r9 RPmq11ZW5mZnVfTKpZdK7CgBUAMBGMA9SZFKqZtGKJfL//H++8stlei89PXXWrHo eZf2I109/8wz6k48MgxjaWmJeldAkFXqQnuXgfO53OSdO36+SyjXOnvhQrMVoSUA S/i/cumSuq46jiNXKXh37hSAHkMABnBPJpNpbU9Xg0ZGR19+9dXV1dVmP3F9be3G tWu+LX6W9HvqzJkXXnpJUfvZbHZtbY1lzwC8PR9YbpUz09PqDrHb7fDExKMnTzZ1 c3YD8K2bN5WugpZnNcsqaAD7IAADuGd0bCwSiahr/0dvvCEBu4WVaZ/9+c8DPm79 nXjooR+/+aaKlln2DGAH0zA8XN6ytLgov3ybB5Z72tPnzw8NDzf+KW4Azm5uzs7M qOuYYRhrzb/ZCiAgCMAAKlKpVDKVUjfLWi6XP/rd7yT+Nfuu/M3r19d9HMdIRH/3 /fdVtGya5tLSkgzLVDQO4OAydL3k3dG4U5OTcpv1LQPH4vGnzp6NRKMNPt4NwPLB 5UuXQipPHChUTgTm3UYAeyAAA6gYHh6OKTv+V4yNj//0X/91eXm5qRGJDAq/+uIL 30Zy/QMDv/zVr1RcrlgsytfuOI7nLQPoAXKvkxjsVWu3btwwDMOfutASNR85efKh o0cbfPxWAL5965ap8g1BeUo3OBAYwF4IwAAq07/xREJdzpQR0ps//enhiYnFxcVi M4v9/vb551Z1qOQDSafv/eIXKk6BkkEYJUkB1CA3yVKx6GFhvG+uXpU2fSudcO6Z Z5KpVCOP3ArA+Vxu6u5ddT20bVsrFpkEBrAbARhAX2ZoKNFkJc+muOuf5YO5uTm9 4VmO1ZWVW9ev+zOAk/T7xltvNT6J0SD5wldWVhiBAahLbhcS1yS2edKaZVk3vvnG t8OBDx858uipU43crrcCsFBaC7qvuvQmu7mprn0ABxQBGEDf2NhYWGX5q4mJiR+/ 9ZZ8MDMz0/gUx18++cSfO5SMO586e/bZ557ztlkZyC4uLjYe+AEEnHt+T9mjvRKS /e7evatun+12crs7/+yz6Uym7iO3B+A7335bKpXU9co0jBbOHQDQ8wjAQNCl0ulk Mqm0/NW/vfvu0NCQfCyjsQb3wU5NTs7Pzirq0g6ZTEZ66G2bhmFI+vVt/TaA3iBJ spDLedXa9N27m5ub/pRRSA8NPf7kk3UPYZK7olYouOfASfr97vZtpT99CoVC3rvn E0BvIAADQTcyMhKNxdS1L2OvDz/6qK86FpmcnGzkUyQkf/7JJ74t3pPueTtAlFGd pF9KXgFogWmamneHA9/85hvTsny4nUp0f+rcuZHR0bqP3D4JfPXyZaV900slSjAA 2IEADASa6tOPxOkzZ37w4ot91Tf+p6enG/mUb65c8WfjlmPb//LOO2NjYx62WSgU lpeX3fkNAGiBxDbdo7XBjuN8c/WqP+8nRqPRp86fj9Y7Eml7AJ6dnm72bLymcB4S gN0IwECgqT79SMZeH370UTgc7quuCp5tYFWz5OS/fvqpD2v2VGz9lZEcW84AtEnu TlqxaHlUFHpzc3N6cnKw3uLk9skN/8yTT44fOlT7YdsDsG3b169dU5rPOQ8JwA4E YCC4UqlUIplUOvKIJxLvffCB+7GmaQsLC3U/5eo//uHPu/WxWOznv/ylhw1y3BEA r1SmLnM5r3ZS3PnuO4mdPryxGI5Ezp4/X3tbzfYALL65dq1P5ZIZeQ6LhQKTwAC2 EICB4BoaHo6rnP4V33/hhTOPP+5+LOOP5eXl2o83TfOLzz7zYZTm2Pb7Fy96+OVL 9GWSAYCHvC2Ide3KFfld9cFykttPP/74+OHDNR6zIwCvLi8vLS0p7ZWmaZvcnwHc RwAGAiqZTCaSSaVR03Gc3/z+91v/d3Nzc21trfanXP7734veVX/ZjwzRnn3uuafO nvWqQfm6NjltEoDXDF0vaZonTeXz+TvffefDqUiDodC5Z56J7T8JvCMAi8v/+Efd 8tHtsG1bfrIU1P9wAXAgEICBgPJh+vfo8eM/+vGPt/5v3ZQoQ72//fWvPhRrSaXT 77z3nletkX4BqKMVi6ZheNLU3cnJXDareolNuVw+eebM4SNH9nvA7gA8+d13mkc5 fz9MAgPYQgAGgsiH3b+O43xw8eL2SYClpaXab8D/46uvvJrrqN2xX1y86NXJT6x8 BqCUt5uB/VkIPTA4eP6ZZ/arsLg7AJumefP6ddU/ktgJDMBFAAaCyIfp3+3lr1zz 8/Ol/Q/2MAzjb59/7sP075NPP+1V5WeqXgHwgcTFgkfJbXNjY3pqyodJ4Bo7gXcH YHH92jXVp8cxCQzARQAGAseH6V/xymuvPfzII9v/ZHp62to16Nly9dKlvHflXvYT Cod/+atfedIUJx4B8I2HJwPfvnVLmlL9IyAciZy7cCGy15nA8oNAKxR2xN2N9fX5 uTmlXWISGICLAAwEzvDISI3yJF759W9/u+NPJicn93uD37btzz/5RPWkhIx+/vXf /310bKz9pgqFguqypQCwRW6eEt52T5y21tTVy5d9uN8+efbsyOjonn9bzOd3vx96 5dIl1b0qlUobLNsBAo8AjIpUKtU/MNC/XV91k5D8txpZ3NxS3s5xeBv1IEqn04lk UvUGsJOnTr3w8svb/0QGQ3fv3t3v8Te++WajXoHo9h2ZmHjjrbfab0eGUAsLC6pX 6wHAdnIXrSyT8eLOMz83t7qyojptxuLxp8+fD4fDu/9qz1XQM1NTOcXrgNz3EVRf BSrsHqn2uQPV6n8qP5Hvj1cZqaIuAnBAVe4j/XInGZCff4OhUGs/BeWHsW3b8j/5 wJH7jG1zxkCXk9c9Go2GIxGlV5Fvh1/953/u+KYyDGN2dnbPx8sPqc/+9CcfpiMu /uY37Z+0YZrm3NycVwVpAKBxpmFoxaInTX1z9arce5W+GSojhHPPPJMZGtr9V3sG YLmvXrtyRfXPAnkOdV0nF3W5ZDIpI9SB6ki1OlQdbG3RvnwTyneaXR2pyjc8rztc BOBgcd8/k7wbCoc9/xkjd5Z7N5pKIHb6uNF0HxmIJBIJ1VeZmJj48a6J1mKxuLi4 uOfj79y+vbTPX3noiaee+t73v99mI/KNLelXMrAnXQKAZu25eLgFGxsbM+qrYaUz mceffDK0axJ4zwAs7nz7bY1aiV6Rn0dZzq7rMjJA7XMnZuRXdWLG83dnKkNU05Q0 zMwwCMBBkU6n5YYSiUR8qLLrkqggNxq7Ok3Mu27dwJ/aV7tPP3LVKBn12Z//PKB4 Sbb8UP3Vb37TZiPybfz/2TsP9zauY2+zoIMobCCpQrFT7JIoUs1d7pbjFPc4yf/2 PU+uEye5JXGPc51YEsUiqrD3Dhb0QvTCb4C1eRlWcLE7WzDvI8sShd1zsHvK/M6Z M2Oz2YIcbb8QBEGwgENH6JmpqVgsxm/yoUSi4/LlIoNh38+PEsAI+ZDyKBqWaPjR GzG9vatQKjEN1Gg0Ci2QnOFzFhLAMgcGFxhQlADPXq/HkxLDjAsKiWHhKC4pUR8W kJNbTCbTG2+/ffDnLpfLe9iKu9PhmJ2a4tUND5rcrWefra6pyfI+lPSIIAgxEI1E OEmZHolEZqen+d4ErqiqulBbu2+QP0oAAzAjgLnAa5Xy0t/dzX/gCeIg/yd6Uyfw FGii91Bi0WgsFkvShnDuQQJYtjDSV6VWZ3/okVtgoEkNN+kDGQhpbwgGHOdnkJpv 3LljLi4++E82m+3QI+IPBwY4iWt6DCD7f/Hee1neJBwOb2xscFIfgiCIbOAwIvTC 3FwoFOJbhHRevqz99wnoGAEM9Vmcn+c7UmMeOULjUmQwFKZP8yoRd3ozJB6PRyMR ksE5BQlgGZKSvoWFKpVKbNL3IOkjwz/uDNO4wx84zs+ARqP5+bvvHvpPVqs1Go3u +2EkEnk0OMhrxcBSvP3qq5aKimxuAvMi1J+Tc3cEQRDZk5o0uVhBhjl4cmKC703g uoaG8n8fhI8RwHnpAF281oeBHKH5hjFHmZ1evttY9qRkcDRK5miOQAJYbhiMRhAh 4h9o9sEE0ILRJ7UzTNGkOSUV+VmjOTQRBbfAS3zplVcqKisP/dfl5eWDkZPHR0b4 9gLQaLU//9WvsrzJUdvXBEEQQhEJhyNcxItanJ8PBoO8LkSqVKq2zk7VnjM4MN2H AoGjksn5/f7V5WWETeBYLAbPkAQPh+j1+tSR3p9EL8JL5BYwQcPhsN/nE7oiBL9I rF0SxwA6B2YXlaBnfTkBZkQmTB8dGOYEc3HxwZBUfHCM1IQZZWVlZd8PEbIfQRGv vvlmaWlpNjcB6QsCmKsqEQRBcAKMbwG/P/uUbAjJh2A2bzuQD0kMm8B56eMtHgru kB27x3qZJCOSE70HiUZTybLI/pQxkm+jRF566ClUKEDkyGDQ2QdzYJh8pFmDc/Q3 7ySpeegBWuvq6toBVcwt+qKit3/+82zuAG3ParUm+I/IQhAEcVrisViQC+eUpcVF 0NIFfGrg4tLS+sbGvTL7eAEM3wtqhWPV0GFgdux6OIvwWG/2gFUDpgs0UTI+ZYnc 9FIOYjAa1eKLdMU5uz7SjBgmf9RMMBqNWp0Ox4A4Xmr6/X6Hw7Hvh4MPHuxkvXdx DJxs/9rtdpr8CIIQLSAU41lnJkfYBIYBufPyZZ1ev/uT4wUwMD05mf3+diZA3UKg gcnrNQP0ev3eY73y23fZB5idkUiEPKLlh8wbrrwpKipSKJWgfmU/AO0D5qrUtjCI YYojfTQGo1GHpX7BRnnrZz8zmc1HfeBgDiSE8FfHROTKEIr8TBCEyEmFruXCOkcI B13X2Fhusez+9UQBHA6F5ufmcLYWU4G1g0HSOUfBxHAG1auUhYfzqYC2ARZLPBaj 1XA5kVuNWE6AvNFqtfLzOTktqW1hxkea4tfvAbl5GE2mNw/L/bvL1tYW2BZ7fzIx Nubn0+UMZqznX3rpzNmz2dxhfX39YORqgiAIUcFJNKxYLDY1OangcxNYrdG0dXbu RmQ8UQADM1NTaCdQwIoIhUKkgXdhsmkWpo/1Si60KudQ85AZJIClh16vV6pUObjx ezwgV3bSB4bjicRObothZPULs8LPfvGLIoPhmM+srq7uyyHUd/duIZ81LFQo3vvw w2zucKjbNkEQhNhIRYv0+Y6KqJw5s9PT0WiUv7kDpGzn5cu7k8XxgaAZIpHI3MwM 5nSW4yInFc6qoECRPtYLfyA7cy/MVnAsGqVTeDKAWrbEMBgMao1G9id+sySthZOp A8PxeK7tDJtMJo1WizlpVVZVvXD79jEfgFewvLy89ycOm21+dpbXWvVcu1bf2Mj6 cqjz2toaxb4iCEISgFEe+ncvGxYEg8GFuTle9/oqqqou1NbuzlCZbAIvzs+Hucj2 lCGp0EehkDeXYmL9uNOrSFFAovckUqeCw2E/nb+TONTKJUMq1HNhIbK2kQG7YjiZ Rsabw3q9PuUYsCfRIgLJnZ0PPv74eIPp4Enaxw8fRiMRXiv24SefZHM5WD8ul4ur yhAEQfBK6ggriMms1+ymJiZgouTPzAB91Xnlyu48lYkARgjQdZBIJAKTlFw3+pht XgYSvSxgVkkSlJ1EylCLlwayyfErOEw0aSaUdDItjuUxfgkVDLy9sxN+Hf8Zn8/n dDp3/wpPvf/ePV5d2mrq6q7fvMn6crC3VldXcaKPEgRBcAIoyUDW05nDbt/c2OBP bcK42t7VBRMW89dMBDCwubnp3jOJ4CCn8L8/Kt50ql4GUrzZQ7mCJQ11AAkAU4VG o6EIBHwgAz0ME5tSqVQJcSYcyv3VBx+c+DGHw7HXWWjdal1dWuKvVmBgvf/RR4qf 4qywgLZ/CYKQIpykRBofHeV1gbK0vLyuvp7JOZyhAM5Lx03En+PAKACFE5Ng+F9S vDiA9RgOh+WxSpJrUH8QNalERwqFWqOhkQsHJpJWPJ1gSfz+0kweLJVKJUgwcHg+ b9y5U1xScuIn19fXI3scnh8ODGRo8bDDZDZDxVhfDk1gdXWVTv8SBCE5kolE9qkB V5aXfV4vj2vu+fmXrlwBwybvNAI4FAwuzM8LNdlFo1GRZ8HZ9WouTHs1U/wqNFKR scJhsBvF3DyIg1D3EC8wnMEMocxiI4vIHpj5ftwiTiZ3xLFF/GOQRoUCpK+AM1zV mTPPv/TSiR+DZ7a8vLwb5xMeY/+9e/yZVlDQa2++WVJayvoOFPyZIAjpAkIxll3y NhhFx0dHeR2lWzs6jCZTXmaBoHdZWlgIhUI81epEUrvBIIPjcfGYAWAAMGmKAEqK KSyxWAxksOANg8gcEsAihdL8ihMmpFYyLYh3GE2c3isOZh1+80RScRrT85xSqRS8 YcC8+/7HH2civ8FisFqtu39dXlra3PNXzoHn895HH2VzB6gt5f4lCEKipBIfZO2Q OTM1BQY9fxONubi4obm58JRe0Hwr8wxJphMuMienEASPTqdL+TIX/Kh3C9OSl8JW iRDKoSUtqP+IDnJ7lhy7qji586MoTq1np3+Px+Ps8jdodTrm0A4Tp1FUZ3jgO778 2muWiopMPrwvAtZQf3+ST+/iposXr1y9yvrygwGrCYIgpEUkHI5klzfI7XKtra7y F1VxJy/vUne35pRe0MC237+8tCT4EjDD/8UQYc5Mpf/KLhmVJp3eMjXF5/9IwU8n eEnrSghyh5YQ1KnEhU6v12o0Sor2LBd29kjiH4Vx+ocHP5nqintnPhHPeWfPnXv2 hRcy/LDdbt+dCfj2f4b7f/DrX2dz/721JQiCkCIwxWz7fBn6FR8Fr6Gw9npBn0oA A0uLi9lnPOaJn3zC9qyDH/YxZnLP34OYZ3zitKSScofDQZnm0JIN1N/ERVFRkUar xU9mQxAZclof47W1tdhPUUnXVlasq6v81CuF0Wh882c/Y305WC0rKyvsrEa41uV0 Oh2O4PY24x2385N9U1hQoNZo9Hq9pbJyN/kHQRA5jt/ns21uBgKBSDic+Eky5afH WKVSqSsqKi0rKyktZadCs98EXl5aAhVdwNt6ZUlZWV1DA3zZ0wrgPP7jVBNENqRc /0IhWkwXOSSARYRGowFDWUPOz4RYAZn39s9/nrmKAx0IknL3r8MDA3He4j+D7fjC 7dtVZ86wvgOL8FeRSGRpYcHjcsGTycQggwei0WrPVVdn6EBOyA8mwLjg5xgJobBt ba2trIB9nEkbYAYWc0lJTV2dWq3OvJTsN4Fjsdj05CR/DRXsnK50LOhTxcFiAG0/ OzNDnYgQJ9CYw+kVKHYn4AgcSGiJCK0uBYV9JsQJjOmXrlxpaWvL/JJgMLi1tbV7 +YO7d3k1WT785JNsLt/Y2Mh8unI5nQtzc7FolN1GRCKZLLdY6hsbaR9D3kCzt9ts 9vRGHxj6jK9jXlrYwD8pFAq9Xl9eWQmNgdY95Q288fnZWWgMhay6PFyuVKnqGhoy D3Gf/Sbw5Ph4alOan5YJ36i9q4tZTmWxCWzb2nLY7dRrCHESi8XA/hGtrz6RRwJY bBQZDEzEP6ErQhD7qaisfPHll091idPp9P0UEXHDal1ZWuK+Wj9RWVn5wimrtxcQ J6uZuWfbt7bm5+byuLALE4lE1dmztfX1Wd6HEBsgG6yrqxvr67FoNJNFH2gJIG+q zpw5e/482fTyY3F+HgbA7Jf/Utuk+fn1DQ3lGbiQZL8JDHWGMZy/Vctyi6Wmrq6A lRc0sDA3tzfDPEGIBCYzSPYZuQleoYlWdBhNJtDAQteCIP4NlUr1y/ffP+1Vew8A PxkeznI74hjAyHvz7bdNZjPrO+yLVn0ofr9/amwMtArHEmVnp7Wry2AwcHlPQiCg eczNzLgcDnbrmGA5lZSVNTQ1kXunPIBBY+Lp0zxORwwY7qB5XGxvP3HQyH4TeHRk RMFbU4Rv0Xn5skqtZieAgYmxMVowIsQGqF+f1yt0LYgToIFDjBQXF6vT6QEIQgyA vfXL9947bZvct6fa98MP/Nn0IDbe//jjbO6wubkZCoWO+leQJZOjoyCSefLOgPtb KivrGxv5uDmBA7zEmakpkL7Zt3NQ0SCDmy5eJG8gSTM/O2vb3ORv0DAajS0dHcfc P/tN4OmpqThvCYGhnXdduaIvKmJxDJgBLpyamKDVIkI8RMJht9stdC2IkyEBLEb0 er1Wp6NY0IQYADPrzbffNhcXn/bCvTGlAtvbo0+e8LdUf6Gm5sYzz7C+/Pj4z7at rbnpab5tLChdrVZ3dXeT5pEia9CAlpa4bSQgD6pras5VV3N4TwIHGFKeDg9HIhG+ 9yehkTQ0Nx8TVC/LTWAY/eAXf6NfTV1dRVVVHqtjwAyhUGh+dpY0MCEGUks5wWCA EiBJARLAIsVgMOj0evLtIYQFzLjnXnzx3PnzLK612Wy708DUxISXtzVRkI7v/OpX 2RwcgHpCbQ/+HL7+2NOnMJuh9USQ4FeuXlWdJtwrISzRaHTk8eN4LMZHI0kFylIq U26ilBxeOkQjkUcPH6JN3tBIwFpo7+o6dO0M/tXv8+VlsQk8NjLCn7zU6vWtbW3Q yFkLYMDr8aytrtLSISEs0NfAWvDT0V+JQPpKvNBhYEJYQP519/Y2X7zI4lqYCVZW VuAOzF8H7t/ntGr/Rvb+zw6H4+Ck5XG7J8fG8I2qRDJ5ubtbS31fCmxYrYvz83zv PiUSidr6+qqzZ3ktheCEUDD4eHiYXajnbIDBtqW9/VBXnSw3gXn1goZqX756VaPV svaCZnDY7Vu8eZsTRCbQ0V9pQQJY1BSXlJwq9R9BcAUYIh1dXe2dnewuD4VCm5ub zJ/BfB/s6+PPNDl3/vwzzz+fzR1WV1f3JSiemZx0so1jlD1gFHZduaLT6wUpnciQ idFRMHdwvAOgPxpNptaODoSyCNYEA4Gnjx4JOG6UlpU1tbTs+/lOMun/KRo/C2Ak d9hsPK3yQMOGVg1tOy8LL2gGqKfL4SC/OUIQIpGI2+USuhbEKaCRQtQUFRWlsiLR 4RYCFzBKmltarly9yvoOe/dUrWtra8vLHFVtP1DVt955x5hOJsmOfcG6YBp7Ojyc TdgYTtjdGBG2GsShxGOxR0ND+I0EjPsrPT0KyhUvSsKh0OOHDwXfhIRG0tXdvW/p HOoWzSJj0OjTp/wFJSkrL6+tr2edDGkv61arx+0mDUwgk0wkUnmPtreFrghxCmiY EDt0GJhABqRXe1dXZ1cX6zvs83/mNQESdIwPPvkkmzvApGW325k/b6yvL83NiWTJ CR7g1evXlaR2RIbgu3zkHSBCYrHYw/5+wdUvA5jjNQ0NVWfO/N9PksntLDaBpyYm 4A482SGFCkXnpUsqtTpLL2iGzY0NAZ13iByEjv5KFJJVEsBkNmtpI4hAIZk+gNrS 1pbNTfb6PwMP7t7lzxypqKx88eWXs7kDs1kNX3z0yZNQMCiqxSawBHtv3CBjTjy4 nM6p8XFhQ84mEomLbW0lpaUC1oHYC4wegw8eiGjgSBvlWp2u49Kl3dEDBrdYNMru butray6Xi6dmD+358tWrTNSD7DeB89KRq+02Gw2bBA5g8Hg9HqFrQZwaUY3YxOEU FRWp1GqKAkrwDZhxt5599kJtbZb32ev/HIlEHg8N8acqQf2CBs7mDmtraw67fWJs rEBM0ncXhVLZ3dsrdC2IFDgJsTLhxOQ3BCbDg4PxWEzoWhxCcmentb3dZDbnpdtM gO0mVSwWm56c5K/lQ2MuLSvL40gAA26Xy7q2JoauSsibKBCJkPOzFBGjwUccBDSw VqeT+mi+69okqk02ggHezut37hSfPt/vwfvs9X9emJuzb21lXbvDgVI+/u1vs7zD t1995XI6xbxdAPbrxez25InsWbdalxcWxNNOoOleqKs7Q6GhhWZqfFzM+z/QTkpK S5tbW/PS3vushfr42Fg+b3O30WRqamkBC4cTL2iGUDA4PzcndatJlsjGFEwkEiE6 +itZpN34cgqD0ajT6aQ+XuSl5+PU/3Z28tOmpAy+kQxQq1RvvfMOJ+ln9x6pBR4O DHCyon8oRQbDnXfeYX25x+3++1dfJX7S6qIFzAWTydRCEYCFw7q6urK0JB71ywBj aXVNzVlWaboJTpgcHfViRQLPkvauLrVGE2RrrC8uLIB+5qsL5Odf7u5mJiCuNoHz 0gEOZ6em8qTwdmQPI3p3ksmdtNUntrGUBamjv8FgNvHVCWGhcUFKyOkwMJhuoOeL S0pcTmcoFMr7SQlLwpKQEzCIn6+uzjKN0F42NjbCe0Je9f3wA39r8B1dXW1sZeFA X9/83JxUpmF4Tb03b0qltjIjFRptfl6cDx8G0pr6+r3hjgg0Ukd/+/qkMmdBbcss ljNnziQSCRaX+7ze5aUlnmJBQ5W6rlzRFxXlcSqAGZYWF0G6S+U1yYYfFW+awoIC jVYLhgE0QnEOpCygo79Sh0YEKVFUVAQzhJzGcRgZDUbj62+9BfMfzK+2ra2tjQ2X 2x0Jh2GUlNM3FSfw/G/culVTV8fVDaPRqNVq3f0rmB0jjx/z9B5hKn3/449ZGGSp jd+vv2ZnBQoI9BRKA4vP5sbGorgXSqAj1DY0VFZVCV2RnGNidFRy+z8w5tfW17Nb SR8bGeFvNbOusbHcYslLb9ty5QW9Cx0JxgHeGkysBYWFWo1Gn7ZXNRoNDJ6z09Pw czlZdPBNA9vb5PwsaeTTHHMEMIL1skuAAUMJjJJv3LmzN+spSCkwPTesVqfDAaMM TIr5aQSsp5xIedWaza+8/jq3WXacTqdvj0U4PzPj2OMOzS1gzbz30UenverB/fuL Yt3NOx7QOZe6u5lYqQQOMPjMTE6Kv7VA22hqaWHCCBE4hILBJ8PD4m8bB4HWAoZE 9YULp70Q+kIsHufpKxuNxqbWVkajcr4JnJfeZJ6fnWUMCW7vnLOAFcEkxwIrQqvV QqMyGAyFe5akY7HY3PT0jhw9+wKBgOQWv4h9yK1R5gLFJSVqLs5qig0YTBVK5Wtv vgkT4aEfCIVCK8vLm+vrdpsN5DHpYdak/GmvX69vbOT2tjAXrq6uJvccqR0eGIjz dgC4sqrqhdu3M/88iPP//fZbyW387gVsi6vXrgldi1zB5/WOPX0qlV0jaNjtXV1G k0noiuQKvEY3QCDlOFBXd6qE0utWq8vp5KlH5BcUXLpyhTkGzMcmMIPT4dhYX5dK pxYbu4pXr9cXGQwms/moBfRwODw/OytXIy0SibhdLqFrQWSLDJtmLlBusch1BIcR tqCg4Parr5aVlx//SRiIlxcXJ8bGwE5l5kkpLsYjk0wkqmtqbj77LB/Pyufzgcjc +xNeMwA/+8ILZ8+dy+ST0Kh++P5769qa1FsIfJGG5uYTuwaRPaFg8PHDh9IaZvfm UyV4xWG3z01PS924hzkUlMyF2toMv0g0EpnhLQ0YtN5L3d27gpyPTWAGGEWXl5YC fn+BpHq3IEALSS1D7OwoVSowO4tLSk5sKoFAgPGxknrvOApoqHabTehaEBwgzwYq e+R3GHgfMObCtwOdlrmbFlyysb6+srwMYxPMnXKKtcAJ8ECKi4ufe+klnlzo4fmv rq7u3V8Nh0JPhof5OwCcYQKktdXVe//6Fx91EAT44jeefVboWsiceCw21N8vxQEE mkfP9esKTs81EAfhdWkPGRi0z1dXM7mCT2R8dJS/bb36pqbd1T3+NoEZotHo8sJC NBaTzXvkBEbxKpVKnV5vMpkMRmPm79rj8aytrMhY+ubR0V95IdtmKnuMRuOpnJck Cgw3V3p6mi9ePO2FMI6vW62ghx12ezAQyGU9DN/dbDY/88ILR/mWc8LB7d/F+Xnb 5iZPxalVql+8//7xnwET5x/ffutxu2U2H5dbLHVcu68Tu0B/Gerrk3DqlJ2dHgoY zicLs7My2wJizh/V19cXnhRTcG5mJhKJ8NS6TMXFjc3NuzvM/G0C7xIOh1eWlmI5 LIMZxatQKHQ6nclsNppMLKZLsLI2Nzak5S/DDjAmfXT0Vy5Ido4n8vJKSktVKpXQ tcAAxui2jo6uy5ezucPa6urqyorT4cgdPQxfs+rMmWs3b+p49oo8uP0LPB4aAgnK U4kXamtv3Lp1zAfGRkZGnjyR5VuG59x78yZP+UiIR4ODYBALXYusUCqVV3p7ha6F PInH44N9fbK09WFgKbdYKiorj/mMbWsLfvH09QsKC7uuXNm1avjeBN4lFo2CbRAM BmX5Wvexq3i1oHgBszmbBeKN9XWwqXLhueWll9Rd/77KT0gaEsDSxlJRIUsT/1Bg 4K5raLh+8yYnt1q3Whk9nFpmTiTk9Bjh26nV6oamps5Ll3A2Pw9u/wL9d+/m8/ZU X3n99aNi3nrc7v/9+98jkYjMNn73ArZLZxbrQcRRTI6OymOB32g0tlDSLB4Yefw4 FAwKXQu+YNTmMXmSYK6cHB/nSfAkE4nLPT17k0EgbALvAt99c2PD7XIxgUhwCkXg R69mlQreKQhednu8BwHzyevx5Ij0zUs/RtvWltC1ILhEtgZijiD7w8AHYXY1X3z5 ZW5va7fZlhcXHQ6H3++PSTPENDwZhVJ59ty5K7jJcg7d/oW/Dvb18WRGgJ308e9+ d2hN7v7zn2urq3IyXw4F3nX7pUsGg0HoisgKGAE2rFbJdfxDgb5QdfbshdpaoSsi K2B2GJOpX8leYHjR6fU1RwTH4vUYcGtHh2HPUR20TeC9xGKxdat12+/Pk2Bkzd1A zSqVKuXVXFwMViK3RSzMzYVCIck9mWygo7+yRA4zfY5jNJn4dnAVITDEl5SWvvrG GzyNwtFo1Lq6ur6+7nG5AsFg6oyQKCXxThowVqqrq9s6OtQaDX4d3G63x+PZ98PN jY3lhQWeSlSr1b947719P1ycnx948ICnEkVIfkFB740bQtdCPkgl5W/mUHJgzhl8 8GBnT5o3eZNIJM6cPQvz7L6f83oMuKKqqrqmZu/NMTeB9wHy27a56fV6GR8xcRoA jNxVKBQardZgMJhMphMPcrMua3ZmJhaNymmQzJBgMOjzeoWuBcExouvPBAtKS0uV uXEYeB8wIuuLit58+22E85AwBW6sr29tbrqczm2/HyyAZCKRL8SkyBxghi9usVia Ll4sLilBrsBeYrGY1Wo9uEI/PjLCrKDzAZhlt557btf5KhQMfvftt1CcCA0U/oBn DpbimcwSQRHHEw6FHg0Nyc+dD0atK//uU0qwZn1tbWVpKdcGmYLCwvqGhr3pXjc3 Nx02G0+dRa3RtHd27g1jLsgm8EFglnHY7YFgMB6LQRvAF4EprZtI5OXnw5Nn/JmL DCkQagImx8z0dMrgyaXGvwto/oMnvAgZkIutWZbk1GHgfcDEALPmG2+9hZ8AEyYG p8Nht9ncLpff7w+Hw9FoFIxOZqrI/o0k07sNMOGp1WqD0VhSWlp15kxFZaV45iEw hkKh0MGfD/b18WeyXGxrM5nNKTtAqZyZnFxbXZWfdMkEaGnXn3kmZzs+V0AvG+jr KxBNn+KW5M7ONQoKnTXQSPrv3cvZccZsNp+rrmb+Cop0amKCp0cBs8blnh6Y7/b+ UMBN4EOBSm77/fArGApFIxHm+A9XMz4zb6buVlioKCxUqdWgdXX6FPjzfiwWm52Z yUunpUQuWiTQ0V8Zk6NtWn7k4GHgfTCBDV99440M8xkiEAmHfT5fMBAIRyLwZ0Ye x6LR5GFOdDB3qlQqpSoFTHUgd8Xv3B4IBGxHpAPp++EHniwksDZuPvdcnhx9Vllg NJtb2tqEroW0eTQ0FOMtXLkYgFHlSk+P0LWQNpPj474DBz1yir3pgsdGR3k6EwSl XL56dd9atkg2gU8EhhGY5WG2B90Iij2RTMLvh1Y6P72uXcgs4ioUzKauRqMRT2z/ cCg0PzcnxWAoHEJHf+VN7rZs+QEz01GRG3MHJn7ji7dvW47N5UBkTyqz1NravthX DDB3Phke5m/ivNzTM/70qbzjPGdIKm5qb69GiLPf8mBmasqdA+5txaWlTafPpk4w gKp5PDhYkJPbv3tJrTIXFtY2NCzOz/OXO7ehufngwXWpaGAZsO33Ly0uivPMMzKh UMib28te8ibX27fMKCsvF88KooAw0+StZ5+trqkRui6yxW63H7Uyury4uLm+zlO5 MDGD7SVmX0QmLFk8FsNJJ6tQKrsp6SsrtjY2wJTPBTsP2mRtfX1FVZXQFZEkw4OD cZS+zCzgMmGNEIpjRyKRUKpUsWiUp0G4uLS0vrHx4M3F5ggtPzxuN5NDQczND414 PO6w24WuBcEj1MplBTlC7yO5s3Olu/tia6vQFZEbxzg/A08fPQofdjA4FwDjtfPS pfbOTrBl/+P//T8EoQ4FNTQ3l5WX812QzAgFg48fPhTzSgq3HOpcSpwIGMFz09MI syoY3DBuQEFbm5t23qJMccUOb+dClUplx+XLe8NuMdAmMH/AbG7b3BR5k8OEnJ9z AVJKcsNgMOi5TvsmdZKJxMW2titXrwpdEZmQSpO4vn7oSWaG/vv3c3NkUSgUb9y5 s9sBnQ7Ht199hWA6J3d2bjzzDN+lyIlU4Kv79wU5QM4kKRFkLwu+9bVbt3L82Pxp eXDvHkKANDC4a2prdXo989doJDI7M5Obbwpa6ZWenkNT+pEG5px1q9XlcPCUOUm6 gPr185bGghAJuWmmyhxzcTGdCTwITKsXamtvPfus0BWRNvAYNzY2oscGDeIvApZo gcdy/sKFZ59/ft/Pv/7iC4/bjVCBsvLy+qYmhILkweOhoePbMB+A4W4wGts6O/PS ecL8Ph++t45KpbpMAbEyZn5mBscNUqFQNDY37/vh0uIiGOK5JoNhLO26cmV3LWAf 5AjNFctLSzAE5dpMnQnhcBhn1iaEhQSwPCm3WGhcOxSYXCsrK1969VWhKyJVbDZb IBA45gNgoIw9fYpWHzEAwua5F188e1hK3kQi8cff/x7BhIWCem7cOOg3SBxkcW5u a3MTWXxCIyktL98rcmanp512O341KioraxsaMAuVKLFYbOjBA4SZFDpva3v7oaOE z+tdXl5W5NhsXtfYCDbMof9Em8DZszA3FwqFcm1hJUOgM9qPPt5FyAkSwPJEr9cX GQx0GPgoQAYXFxe/9tZbNAecCrfb7TkpKOLSwsLWxgZOfQSH2dN77c03j1GeYyMj 8AuhMmq1+hL5+Z+Ex+2eHBtD7vhHyU5BpDiMfi3t7ebiYsxCpciThw8jkQhCQcWl pZVHpy0Ai3xudjYRj+fOhF5cUlLf1HTU0gNpYHbAE5ubno7yFr5bBjAZno9f4idk Q66MpzkI2OX6I5yICAYmWu+bb79N+2aZ4Pf7HQ7HiR8befw4FAwi1EdwQEh0dHXB rxM/+adPPz00XxS3QHtubm0F25HvgqRLPBYbRNnT2wu8l/KKivrGxkP/dX521r61 haxtoDX23rihoHHvaNwu1/TEBMYB/mSyraPjxI9tbmw47PYccexSqlQdly4dMy+T Bj4V0N9np6dFHl1cDID09ft8QteCQII6g5wBU1itVgtdC7EDkyg8pTfu3KH4qMdw fNjnvQzcv893ZcRAoULx2ptvGo3GTD4Mxuv3332HYHxAY75O0bCOZujBg2OCt/EB vJEyi6Xh2OPZczMzDpsN2TYtKCjouXEDs0Rp0X/vHk6HPV9dbchsGAmHw/Ozs7mw fZdK39DTc7z1Qho4E2KxGEhf+ANJ3xOJRCJul0voWhB4UJeQORaLpSA31oyzBOZR kDSvvP56MXkGHiBz9ZuXAxGwQEHV1tWdNuryl3/9qw9ladlSUUEnPA9lanzce5ID P7fAqGIym1va20/85OTYGNQN2UiFul1sa8MsUSoszs3ZtrYQCoKhsunixVNdsrK8 7Pf55C2DUym7enq0Wu3xHyMNfAyhYHAhneScpG8mJBOJzI0cQh5Qx5A5lBn4VMBU WpCf//zt25VVVULXRSycSv1GI5FHQ0Mybm/w1W6/+iqLpLuhUOi//vQnBLM1mY6G Rd6t+wA9szA7i9wytTpd5+XLGX4Y/+wADHd1jY2WigrMQsVPPB37CmHhGGRec0sL iwM4ge3txYUFea8zNre2ZnJMnTTwQfw+38rSUn5BgYwnYm6hrL+5CXUP+WM0mXTk 3HsamNn0+s2btfX1QtdFYHw+n9PpzPzz1tXVtZUV/uojIMlk8uz588+98AJrq+LB vXvLS0ucVupw1BrNpe5uhIKkQiQSGR4YQBYMhQrF1WvXTnXJw4EB5BQvoMG6r12j kzJ7eTI8HAmHEQrSFxVVX7jA7lqYpJYWF4OBgFy3gsssFph/M/l2pIF3cTmd61Zr AUnfUxIMBn1er9C1ILChTpITlJSWqlQqoWshPZI7O5euXGnNSS9BsCfcbrf3lLPC +MjIthzTx4M98eLLL2e5VwaP9I+//z1XVTq+oJb2dpPZjFCWJBjo68tDto93dnpu 3jytOEkmk0NQVWTjNT//2s2bqCWKGK/HMzk2hqAfEolEW0dHlgXBYAsyWJZbwWqN pr2zM0NPFtLAtq0t+CXLlsA30WjUdZpVfkI2kADOFcB2l+tSMd+AVdrc0tLd0yN0 RfBIpcKz20Oh0GkvBPM9KS8rBN7+uerqZ59/nhObeH52drC/HyO4Tl7e9Vu3+C5F EkyOjuKcvt4Fus/V69fZrTmCNfawvx/ZkDUajS0ZBCLOBfrv30ewipi0WKVlZZzc anlxMSC/reCdncs9PaqMfRNyVgNb19bcLhdJX3bA/I5z2p8QISSAcwX8w8AwFcnJ DwcGyuqammeee07oivAOmOBbW1txVq6YD374QU5B18CmfOmVV1ic+D2G//7zn8Mo DpblFRV1OR8Na2tjYzEdCQatRFC/nZcvFxkMrO+w7fePPH6MadHCWF1bX1+R84EP Fubm7FjWcAunjkUggJcWFuSkgZPpOFiak+Jg7QXmrEg4DBfmiAxeXlz0+/1ykr7I RiMd/c1x5KNPiBMxmc0nhlXkFoPB4PV6ZTUrJ5OWioqXX3tN6IrwAswHPp/P7Xaz MyDA9B968EAeqx6pUM/19Td42ET1uN1f/u1vCJ0im31IeYB/9BeaTV1DQ/ZKEnQ7 iDHMkZMOA6PtvTONhI+5WGYBols7Ow2nX0jKha3g+dnZcDgsmxedlx5/YKqC3zEL DYVCyHkBCFEhB1OVyJzSsjIWMSdZA5PQux9+ODE2Nj46KqfBGiyYIoPh9TffzNxB S/zEYjGHw5HN5qRtc3Nxfp7DKgkFzMQvv/56hjl+WfC/336Lk3FBqVJdySXX/X0g p6SG4a7cYqk/NuVv5szPzNjRkwNfy2G3+UdDQ7FoFKEgtVrNn2sGDOCp5Dc83R2X qrNnz1+4wKILyFUDw/eam51NxONysqZA9IJdaqmomJ6cxBzuwOBxOhxoxREiRB7j JHEKKiorMUcZ0Iof//a38IfZ6emHAwP5Mhq4U6mDCwtfeOklS2Wl0HXJCvgiXq/X 4/FkaTHABOaReB55aK4dXV3wi9dSwI757D/+A8GIgRfa0NRUZrHwXZAImRgd9eMe /eU8+DZaOOJdDEZja04eBnbYbHMzMzixr1rb2/nu+5sbGw67XerOsUVFRRfb29l9 C5m5Q2/7/ctLSzJL6gtKvvLMGeaE0djICPKhj63NTbTiCHEin75EZIjBYNDp9ZjD aJHBcOedd5g/r62u3vvXv+R0PHgnPcG2tbd3ZZzwU1QEAgG32x2LxbK/1aPBQU7u IwjwGk1m88uvvoqzqz/y5MnE2BhCQcmdneu3bsmmu2WIbXNzYW4O9Vvv7PRy/Zyh TQ7ev48ZFDqVGbihQeoreqcFvnX//fsFKM/ZXFJShXLWGhQgdAH4Xbp9HxRRV3d3 Nj5rMtgK3lhfdzoccspsBK8jmUyev3DBZDIxP5menISfYFYgGAj45ZiugjgVMulR xKkwm82nii2RJTDc3Lh1q6aubvcnDrv9H3//ezKRkM2YnpcO2lFeWXn7lVek4p4U CoVA+kYiEa5u2H/vnlRfaH7+zWeeYZ2Tkx1/+vRTnCNPpuLii62tCAWJhGgk8hD3 6G/quPW1a3wsncjpu4iWqYkJr9uNUBBY+W24G+wej2dtdbVQIlPSPuBxXentzfJc ukS3gqG283NzkVBITkElU9J3Z6e2rk6v1+/+0O1ygcjHtBzCoZCHjv4SJIBzlrLy coVCgVYcDHwf/eY3+37o8/m+/fLLWCwmVdV0GPBNNRrNK6+/nk0YWL4B0etyuTiP Rdz3ww+Sc7pjgnvfevZZ/EZo29r6x7ffIpQL3/FSd7dWp+O7IJEw2NeHaeym0qS1 tpaUlvJ0f5fTOT0xgbmsBm2yN2cyA4eCwSfDwzjnEaovXMCfF6DclaWl7e1tqazM 7pIauK5e5SRamIRkMMzOC3NzcvKSy2Mc5XZ26hsbwTra908TKGm3d4GW4LDb0Yoj xIx8OhhxKgTJinRQA+eltzi+/NvfQqGQzIb7n/3iF/CEha7Iv5Hy/AkGfT4fH2l4 YNp+PDQkoZfILFXcfu01/oJdncjXX3zhQdl6Atu358YNhIIEZ3JszOf1ohXHJHSt 5Tnd1OLc3NbmJmbnMppMLe3taMUJyNCDBzjulwqForG5GaGgQ4Exf3F+XnKyqrm1 1VxczNXdxC+DwRyam52V1js6HqbJQcs/dMcF/+gv5T0idpFPNyNOi8Fo3OuIgkBl ZeULL7986D/BzPTNF1/IKWcSM8U2X7x4+epVweczeLz+NDz53MJtnz56hBNDlRPg 7cB7udjSImw1otHonz/9FMHJDb7vuepq+MV3QcJi39qaxzUfOQ98dRTIAbGY7Zry igq0EgVhbWUFfmHEvorHW9raChG9rg7FbrNtbW5KyE8Hnhj0L2691RgZnJc+tSQS JQzV2LBaXekQkhJ6O8eTTCYVSmVjU9NRRt3i/Dwfa/HHEAgEkCMjEmKGBHBOU1xS gpn4EUb5V994o7Ss7JjPfPvVVw67XTYyOC8dhejChQu9N25gJqD6sehkMhQKbW9v B4NBnopIHVWanbVJx6iCZ1JRWfn8Sy9hHgE4hkcPH85MTSEUlEgkem/eFMm35oNI JPJocBA5d+71Z57BKRHabf+9e8g5jbM/gSlmQAgN9vXhPFKT2Xzm7FmEgk4EXuvi wkI4FJLKJAu9zFJZWd/YyPk6hRg2hOHbra2ugiqTygSaCdDGYNxoODYhXDAQWFpc xFyshAnCLfEsFQS3kADOdSwWC2aUhd2sSMfzw/ffr66syGxKKCkt7b1+nb+zgrvA nBpMA+qX16l9aX5+3WqV0GsC+ffC7dtM3gXx8NmnnyZRomGhbVcKwlBfXxLRkIWe 1XHpEuYxh8D29uiTJ5gmY0F+fo98DwOjbarjx746kQDIj4UFqWjgvPSkdubs2Zr6 es7vLNSGMEzQ1tVVUGUSmkBPBF4TDIm1eyKeHsX46Chm84OXa7PZ0IojJAEJ4FwH /zAwDPfvffRRJp8c7O+fm5mR0CR9IjC/ggarb2zsvHSJ2704sLEiaUD0IrgVrS4v r62sSOjVwPNp7+yExy50RQ5hc2Pj++++Q+iD0PwaL1483gVDoizOzdm2tjBLrDp7 trqmBrNEYGVpacNqxSzRUlHB9wlnQXA6HLNTUzid7nx1tUG4QAPHsLGx4ZRUumAY xs9VV5/nJ1w/jhKGr7C5vu52u+WW1DeRMJvNGZ6yQVa/dPSXOBT5dD+CNUaTSYcb Ibaxqam7tzfDD4+NjIw8eSIhrZUJMFsYDIamlpbmixdZz4IwYUej0XAaDrMZHc/s 9LTDZpPQ6wCDo6y8/MWXX8Z3Qc+cr/72Ny9K6CZ4Gtdu3ZLQ68uEYCDwZHgY045X qVSXe3rQitvL46GhKOJhexipLnV363CjRfAN9IKB+/dxeoGisLDx4kWEgtgB73dh fj4aiUhoTEgN6RYLfxHFdpVwHndiGG7isNudDgfcXEIrDpkATQheR2XGycOta2uY cQrz0pvtyCUSkoAEMJGitLRUqVKhFQeTwS/fe099ICD+MczPzg729+elU3TwVi8B gLm8qKiotr6+pbVVcbRCgycWTxOLxaJp4A+YuePz0ptsG+vr0pq8obYv3L5dbrEI XZETAHvrL599hmODFhkMbZ2dCAWhAWIGszgwh6/fuoVZ4j76799HHgSvCfp9OWd8 ZGTb70coCLTBRRjYRX/wfnt7e3lxUUIaOC/9bKvOnOHbPWGvGM47vR6GStptNo/b LT/dC88hkUyeOXPmVC5F8BxmUDwvdgGDyel0ohVHSAhZaQkiGywVFahHMjI7DLwP EGD/+v77nWRSZjI4L/1AlEqlpbKyobERJAr8NZEGJgzmDwLWLRwOPx4akpZ5lPJ5 7urq7OoSuiKZMjw0NDs9jVAQPJnWjg6T2YxQFgLTk5MexNAm0BOvXr+uQlwuPEg0 Gn3Y349pT5tLSpqFDpnOFV6PZwLLA9NoMp09dw6hIE7Y3NhwSMojOi89ml3u6TmY XZYn9unhH+twQBWHgkGbzcYsskhr3swE+LLJdFJrFhkEkfMeQfNAPhpDSAi5qQiC NfiHgUHm3XnnHRYXul2uv3/9NVii8pPBeczskkxqtdrS8vIzZ88esy2MQCwWmxof h4lcQrM4PD1LRcULL70k7KNjAVo0LDBfrt+6JYPu4/N6x0dG0Bon9M2G5mYxBFED oTI3PY32BlNhnDo7Qc7hFMcf8Ab7798vQHluIox9dSIwqy4tLITDYWkN+GBLXGxr E+qQC6OK4ffUZq/LFYlGCwsKZDC6HmQnTV19vZbVobnpyUlMtzU6+kscjwy7KMEa k9kMugutOBiebj37LOtAMqDKvv7yy1g0KsuZhiG1rryzo9HpSkpLK6uqVIgpSWBG h+kK5g8JWULwuNRq9Qu3byOE2uYD29bWd998g7Q3ZTa3tLUhFMQfKTFz7x5m+zQV F19sbUUr7nimJia8bjdacWC5Xn/mGakPtpPj4z6PB6EgeFwXampAmCGUxTnBYBBk cJ6kDhzBA9cXFTW3tJzqaFWWRCORzY0Nl9MZDgbz5BXUah/MFnd9YyPrvGget3vd asV8RKFQyIvS2QmJItvuSrCjrLwc88ASO0fovcAM9OXnn4eCQRnPPQzMzjBoYJPZ XG6xwO88fWWH3Q7WTywalZD0BeDpXOrulrqo+/vXXzsdDoSCZLCnh3aScxexHYVF Pvws9dPjmP4CSpWqobERoSD+sG1tpRK8i/4A815SJ4lUqpq6Op7cNGAWBk1lt9ng dyZyWC4YHvkFBY1NTVlahsiRn+PxOFgyaMURUkTmXZc4LfiO0Hn5+R/++tdZ3gOm va8//9zj8UhLs2UD40qk1mjAKjWbzSWlpVl6/IJ1uLK46PP7C6S2kg2P4uy5c888 /7y0Tq8dSjwW++zTT3GasaQdoZF9gBOJRO+NG2JzqofWMvjgAVqzF48HOAswnZ+h tbS0tclgOIKhdXlxMRgMSmtiZQ6pGg2G6traLNf4oIu5nE4wLbb9fub0r7QeRTYw cUkam5uzH2bHRkcLKe8RITIkafoQvGIwGvW4SS/OV1ffeu45Tm713Tff2La2cmeK 2oXZHy4oLIQZS61Wa3U6Zi0D/nCUHRYOhZxOp9fjCW5vR6NRKZpr8K3hC770yiss onGIlomxsaePH+NIO7AOW9rbEQriFhAYA/fvYwq/ppYWcfrVg3U+MzmJuRBw7dYt KY4Vk2NjOKlQoLWUlZdbKioQysIhHA4vLixINPYktFiVSgXToclsLi0t1RxxyAs+ FgoGGdUEf4hEIqk8C4lELuzxHgRsCY1GU8+RC8Py0lIwEODkVhkSCAT8Ph9miYQU ybmOTWRCcXEx5kEasBjeeucdDjXM3X/9a3V5OQdl8KHAZMYc4GEm8t0/y+D5XLtx o7a+XuhacM9/fvYZTq5XaBsggM3FxQhlcciThw/REl8DBpOpVcTLBBNjY37ELJdq tfrS1atoxXGCx+0GAYwz4sHw2irxgxiH4nI6161WKa597EXGsyEnJBKJIoOhpraW qxuGw+GFuTnMRYRIOOxGDI5ASBcSwMThlFssmFMdDLu//t3vuL3n8NDQ9OQkTWzy A4yY+oaG3hs35Lo2D/b6l3/7G5oj9LWbNyXUTcAKX1lcRHv1YCJff+YZnLJY03/v HuYDqa6tPXP2LE5x2QPDxUBfH1rk57qGBsxYkpjAq19bXfV6PFKXwcRBwAYrLinh PGsXct4jJvEyWnGEpJGn+UhkD/5hYI1G8/N33+X8thPj408ePcKxfgi+AQvMZDa/ 9MoraIkfheJf33+/YbXilKXT6zsuXcIpK0uQU+CCnum5fl1sR38PEo/Fhvr70VYx xJAMOXNGnzxB88DUaLW1dXU4ZQlFLBZbnJ+Px+NyXX/MNaA7Wyoq+HDanxwf5/ye x0BHf4lTQeMXcSRGk0nHKtsbay5fvdp88SIfd4YJu7+vL09SeR2IfYDsefaFFyqr qoSuCAYgvf74+9/jNFewG+obG8ulcGoRZB5OquS89GOpa2iwVFbiFJclts1NTFfD gsLCnuvXccrKBvvW1vzsLM5jiScS7R0d3JYFgx4T34HDe3KC3+dboXNGUgbaVSKZ PHv2LE/RDRx2O/JmbDAYxDnnT8gDEgPEccDIiLnMDyPy+x9/zN/2zubGxr/+8Y/k zg7JYGkBr6y9s7Ozq0voiqCyvLjYh+XaKs4ox/tYnJ/f2thA67xqjeZSdzdOWZzw ZHiYCVSLAIzVFVVVIj+BjxklGx5I1ZkzxSUlHN6zUKHQpQNSxmKxSCjEHFgVFTCl gs4hj2hpsZNeU6muqTHwFjwymUxOTUxgGlrRaNTldKIVR8gAkgHECVgqKjBXeWFc /ii7zMAn4na7//711wny4JICMI9WVlU99+KLmOmpWbDDz6rKF//zP36sVLdgbV+9 dg2nLBYEtrefPnqE5/ycSNzgKDQ9Jg9++KEA6xElEomuK1f0RUU4xbHg4cAAjPM4 ZcFj59Z9CZq6bs8pJJgZw+FwDCU23qmAIXppYSEUCtFusPjZSVNXX6/l2blv7OlT zAzS0AhtW1toxRHygAQAcQL4h4EtFstLr77KdymhYPCrzz+PRCIkg0ULTNVvvv22 yWwWuiLHATLA5XLB7xUVFZy3pWgk8uc//AFH0oh5Tw/qNtDXh9ZRobjLPT1qtRqr QM6AAe3x0BBeQKy8vGs3b4pzCMX0F0gmEs2trRwu0u1Tv7vAOBMOBhNYpwAyJxwK LczPi7MlEHk/xbtubG5W8u/mszA3hxmln47+Euyg0Yo4GVAgmGEtYTh7/a23uPUl O4pYLPbl3/4WDARo5hYb0AxuPfdc9YULQlfkOAKBgNPpZOxRvV5fXl7OeUMaefp0 YnSU23seBdjx7ZcvGwwGnOIyB54AWl5HaHhnzp2rrqnBKY5zVpaW1tfW0AY0g9HY 2tGBU1bm+P3+sceP0TbDYbbiMDbBUeqXAdqnOD2iPR7P6sqKgtyhRQa0k4KCApC+ OO4zoWBwcWEB06AKhUJejwetOEI2kNFPZERZWRnm+cBkMvkxz47Q+4r75osv3G43 OXGJASbL0bWbN4WuyHHE43GQvsFgcO8Pi4qKoKdwPvf/8fe/RzN2d5LJ3lu3RNUR HHb73PQ0mkUFL7FN4qfNx58+RdsPgZbZ0NxcVl6OU1wmwAAyeP9+PmJM7PbOTq7u xpz7PbG1i9YjenV52efziWoAyVmgI6iUSuiemHJ0fHQU8+3HYzGHw4FWHCEnSAAT GYHvCK1QKN798EO04hj+9+9/39zYoMlbKMCYNhqNt197TcxZjqCSoC5cLtehoVkN BkNpaSm3PcXv833+P/+Tm8GfMOMY5aV1xbVnnpG6P0jKY/zePUwFKKoIasjBwOob GtQcjVfwDLU6XebNLxGPh0MhsXlEx2Kxhbk5qJXU+5F0gblJq9XWNTQgl4usfsn5 mcgGGp6ITAHLHjneSUtbW9fly5glMjx6+HBqYoJkMDJgr7/w0ksV4s46E0uvN4eP Na/50MDffPml2+Xi8IbHAFbF2fPnz4vD+RwzjhFYjW2dnUaTCac4XvF5veMjI2iD mHgiqK0uL1tXV9GkF0jWxqYmTm6lVKk0Wu1pa57yiI5GQfCLzSPa7/cvLy0V0jSK SyKRKCkpOXPuHH7RG+vrHrcbs0RQv2hBIgn5QQKYOAXm4mLMrTmY0d/98EOEmA2H AqP5D99/DzYxLWPzTSqc7OXLHLoR8gG0Rq/X6/F4MjE0+fCF/tMf/oAmBeGNdIjg MPD87KwDMZMkjG/Nra1oxfHN9MQEpj1aZrHUNzaiFXcoYA2PPn6MFyo8mWzj6Pyz Sq1WazSsRwzRekRvbW7atrZEHsNfBjDJoqtraoy8ZTY6HpgypicnMY0laPDIepuQ GWTZE6ej3GLBTPqHfBj4IDDIfv3FF8FAgDaE+QDe7/kLF249+6zIH28kEnE4HNHT 2Jc6nc5isXBoELhdrq8+/xztQcGr6b15U8AMn16PZwLToW5n59ozzyCVhcXAvXt5 WCYpNJjWjg4BY7aDCT7Y14fZQbhKJ6PRalVchBwXp0c0aLPlpaXA9rbIB3mJAu2w oLCwobFRqK0ChrGREczJAhq5HXFtlJAlJICJ04F/GBgsqjfu3EEr7ij++Y9/rFut NIVzBVhF8GZfeuUVMR/3zUubF26328cqBLFWqwUNzGGbeXD//vLiIld3OxGFUtnd 24tW3F7i8Xjq6C/iKdZL3d06vR6nODSCgcCT4WE0wzSRTKYOAwu03Tc8OBiPxdCK g3mQkxj1Wr2eQ+kiWo/oWCy2OD8P/Zo8qrgCRi29Xi+GxHVzs7OY3gd09JfgBBqJ iFNjNJl0PGdR3wsMdi/cvl115gxaiccwNTHx6OFDksHZAC8UlOHzt28XFxcLXZcT CAaDTqcznoXjsVqtrqio4FCB/OnTTzF3eExm88W2NrTidkEWM5aKilr0gDE4LM7N 2ba20IoTatFkanwcMxUKJ87PIAV1en0hD+sFovWIDgWDS4uLMAWQDM4GmAIslZUW i0XoiqRc94OBwMzUFOYLhXnZ5/WiFUfIFRqDCDaUlJaqVCq04gR3hN7HYH//3MwM yWAWFBQWXr95U+TZffPSO5AulysQCGR/K6VSCRqYq00eZEdoMFWra2qQQ6pA53LY bGgWFTzMnhs3cMoShKEHDw6NWM4H0GDKLJYGjuJCZcj62trK0hJag+HE+RlGQlC/ vHZkcXpE56UzBltXV2kCZQG0PZPJdK66WuiKpGK2qTUaeIkP7t7FfJXRaNTldKIV R8gYEsAESywVFZijHhg3H/z612jFZcL05OTw0BDN4hkCY82l7u7mlhahK3ICYMH7 fD63282hD2FhYSFoYDUXx/yAgb6+xYUFTm6VCak0p11daLGRHXb77NQU5knO7t5e Tk5gipZoJDI8OIj5SBsvXkTLDOzzeseePsU8f1hUVJRljPTTpjtijWg9ogG7zWbb 3CwQLsqAtIBxuKKyslwEu74p6atWMy/uwb17BYh7vzC2YPqzEPKGBDDBkiKDQa/X Y/q91DU09F6/jlZchqxbrXf/+U8KFn0MYHt1dHWJPMgzA4tgVxkCzcNisXB1duDP f/wjpocwNO8rvb1cCfhjgOc/PDCAl/V3ZweUzNnz53GKExDr6urq8jLaGAXGeve1 azgN5hGits9Lt5nW9vZs7qDWaEBAYM4XovWIBjY3Nx02m4DB9kTOj+GdL1wQQ3o2 hVIJrXf3Zc3NzDjtdrTSU0d/A4FtyntEcASZ7AR7zGazRqtFKw6Gv1++955alDGT Atvb//zHP7xeL20I7wXs4Ja2titXrwpdkZPJJthV5pSUlJi4sGP8Pt/f/vu/ke3+ nhs3eLVT4RUM9fWhRS0GVCrV5Z4etOKE5fHQEB8rO0cCDebmTX5dfBOJoQcPMJUk lNjY1JTNHKTV6ZSIp4f2IlqP6Lz0OrLL6SQZvBcYD5UKRU1dnRj8U/ZJ37x0VLPh gQHUvEehkAfxnD8he0gAE1lRXl7ORwyPoxDbYeB9gEgYefJkHDN3i1hJRbrS6e68 844kMkBub2+7XC4c09BgMJSWlmZvNzx59GhyfBzT/gDrp/vaNf5KfPLwYSQS4enm B0kmEqDQJNE+OSEejw/19WF6nKrV6ku8LX7BCAP2N6acgxKLS0pYh2PMLyhIhbwS VOOJ2SMaJvfpyUmKj5WXXmcpLSurrKoSw6M4KH0ZkI/+JuJxO+JuM5ELCN+7CEmD nxXJaDK9+fbbaMWxI5DOPrK2upqDrtFgwShVqrfefpuTDJl8E41GnU5nOBzGLFSj 0Vi4yKf933/5SzgU4qRKGcLfluns9LTTbkfrLNBK6xsbyysqcIoTCfatrfnZWcyH XFpe3tjczMfNsTe007SwjYheqFDodLp8cSyMitkjOhaLzUxP56fPjAhdF1QYV2eD 0Vh15gxmhNFjOEr65qEvVlLeI4IPcmuIIfjAaDRi5s8UVVakE/G43U8fP97c2MgF JQyvBuy8V19/3Sz6/EZ56Q0Hj8fjFSibgkKhqKioyNLQASv2Pz/7DNndQFdU1NHV xe09kaP4AjBkdVy6hFaceBh98iTIRWzzDOEpivjo06dBXGs4kUg0t7Swi+WeChmk 0Yht/IdvFA4GxekRHQqFFubm8tMIXRd+YXRvUVFRRVWVFvFA2fGkpK9afZRzn9vl mp6YQM17FAjwfTqJyEFkPrgQOJSUlGAeUxG5I/ShwPANpue61RqLxeTnIJ2SvoWF L73yClro1ywJBAIulyubBL/ZAwZEeXm5PrvFo/nZ2cH+ftSAOjs7RpOpNeskqLu4 nE4wpzA7BQwg127dkl83zAT47gP37yM/7ebW1pLSUq5uODE66vN6kdt8RWVlaVkZ i2sFPPR7IimP6FgsEgqJ0CM6Lx1ZY2lxUZYymElLVmQwQLvSiCmsyfHSlwE771Ek ApM1WnFE7iC3YYUQCuSsSAWFhe9/9BFacRwSjUYnx8eXl5a2/X4ZmOCMw/OLt2+z sw7xSWURdLlCuJ7Dx2BOk42F9/dvvsEMxZnHaGCzOctYuAxg4z599AjzYCSYnu1d XQajEa1EseH3+caePkU9v5dIdF25oi8qyv5WE2NjPo8HWRHBENfQ2Hjaq+AJa4U+ 9JsJ0J1BA+P7k2dIMBBYBBksC6do6AigME0mU+oIjMiiDxzj8LyX/vv3MV8D5T0i +EPyAwohEvAPAze3tFzu7kYrjg/sNtvUxMTW5iYYH5ITwynHLYPh+RdfNJnNQtcl I3DiPLNAq9WmgsmxNZThe332H//BbZVOJKWBjcbW7FJbhUOhx0NDyIlAy8rL65ua MEsUIfMzMw7cRZNkInG5pyfLrAETIyPQf5GFEIiWto6O0xaKlumXK8TsEZ2XHiuW lpYS8bgUJ0r4HawjGHmKuFgD4hylUqnKQPoCS/PzYK4gVImBjv4SvCKZ0ZkQPyCE MA+xwOD47ocfsjuUJTbguywtLCzMz7ucTvH7SIMte6G29pp0IujC42XiPDO2iAiB J2mxWFjnTYVm8/XnnyMrSQD0TNeVK+yujUYiw7gZXPPSm3I9N25glihahh48QO4O UFx3by/rwzJPHz1CDvmWlx7rahsaTpu+W63VIuRA5hyRe0TnpZvQ6sqK3+sV2/bp PpieBcNjMVBSItp1EKUqdT49w4kjHo8/xD1uEwqFvJT3iOANkXZLQqKUlZdjiiIp HgY+ETA+rGtri/PzDrsdJgDxnICCpw2z5Y1bt85yHdKGV8LhsNPpFK2D3y7wlktL Sw0GA7vLnz5+PDE2ht9UwBK90tNzWh2bUr9DQwXoW3lXr18XSYRVwYEeAeYssoNu cmenu6fntBoYRp5HQ0MJ9BP7LPIeQQfU6vVSWRk8lJRHdDgcRYzxywKf17u2ugpV FcliMRPLqjDt9A6a12gyiWTWPoqU9NVoTvX0+n74AXO4AL2N7KVC5Bqi7qKE5MB3 hC4pLX31jTfQisNn2+9fXFjY3NjwejxglOQXFCBHf8lLn1OtqKy8wk/+G/6AGdTl cgUQY95mD/QgkMHsrLov/ud//H4/51U6EWgkl3t6Mt/yAvMa9Ayy5QqVrGtosFRW YhYqcmybm0ysXcxCQSfASKLOOPBPJBJ5PDQkiJwAPdPU0pL550H3anQ6kUiyLEl5 RIdC+IsOp2V9bW17e5s5Q4Q8MyYTCZiOoSXDoF1cUiKNPf/8fJUqte172lY68vhx KBjkqVIHIednAgESwATHGIzGLAPbngoYKEEASyUCU/aAHl5dWbHZbF63OwQGSiLB ub3FiF59UdHZc+cutrRwEroGGTCyvWlE68t3DEql0mKxsNioBMH/5z/8gY8qnQi0 w8bm5kzS6uJHYGIAI7WN6+xNMmD86VN8KzPzOGT2ra3Z6WlB4khBk25tb8+8oYIQ Al0h8n2/0xKLRsMi9ojeSzQSsdvtMLzE0+eEOX8RzOlohUIBLxosHJPZLA3F+xPw QKB9smui8FTHR0Yw23YgEPCLL1oHITNkNVgTIgF5NVSWjtCZEwwGbZubLqcT9B7Y suG0Kk6dQdrZOXG7eCcNfAZEFwjd0rKyyqqqM2fOKCR7spo57ut2u0UbzSUTWLtD QzP46vPPBREM8ORNJtPF9vZjmtzmxsbC7Cx+9cB+v3bzpszECSfAWxvo68N/LtA9 6xobYbQ56gNQsamxMS9uuqNdUtXL+OivDNyej0ESHtH7gNcH8mnb7w+GQqDhGQF/ oireSfsxM1ofPgkvFKZFjUaj1emKiopEm8vqRFLb1Go11J91V0LOexSJRNyU94jg HzIICF6wWCyYIXlgpnr3gw/QipMQII+3fb5wJJKIx3cX8uHV6IGiIq1WKydVEAqF XC6X+I/7Zgg7d+jx0dGRJ0+Eeq3Qwlrb2oyHBQafHB0VRM+ANXz56lXtKeMY5Q6h YPDxw4cCrEqkV0xaDkso7XG7J8fGhPIlhoqVlpVVZOYtDzIpFe1ZFm7Px5BMJMLh cDwWE7oi7IHXCvWPRKO7kpgBZkNFYSEjEQWsHh8UpL8XWEfZjLoDfX15iC4A0NJs NhtacUQuIx/blxAV+IeBOy9fBssbrThCVKTWjNM+4UJXhGOUSmV5eflp/Sm+++Yb AcOHgHGp1+ub29p2vbh9Xm8qQJdAlamurT1z9qwQhUuGdat1ZXFRkEWT1IpJe7vR ZGL+GgwEQPrGYjEBF+ag3dZnlvVXlm7PxwACMhwKiTaWPrGLQqFQaTTZeyWsraxY V1c5qVIm0NFfApNcGbgJfMCmOW32iGyAofP9jz8WxPmTEBCwlUH6SivS1akA8zoV VtRozNzOhr7wlz/+MS5oABuwkpUqVUNT08LcXCQcFmo3T6fXd1y6JEjR0mL0yZOg QJ0ImgooyeqaGmgqgid6hcq0HuvGz5BfUACzm8iT8fABjC3RSArMXUEic5TpGFec GELQFwb7+jDXd4LBoM/rRSuOyHFIABM8UlpWhpmnN8cPA+caiUTC4/H4/X5JxGjJ Eq1WW15enrlZEw6H/+uzzwT3zGROmAtYfO+tW7mzQZcN8KYG79/PE+5ZCdxU0oD8 bm5tPXHOSh0N1ekEr62AwFQbCYdjcjlsIgOYGFegfjlcP0LOexSLxZwOB1pxBJG7 IziBQ0VlJaahUFlZ+cLLL6MVRwgCSF+fzyfRIM+sAVukrKwsc68K29bWd998I4+k LCyARtLd25t5uh0CJM3w4GDOOtGAqLtQU1N0UuQ5rU4nv8Oi7JBKqiR5U1BYmJK+ 2R30Pcj4yMg2YlI9mMq3NjfRiiOIPBLABN8YDAbMPDowjL5x5465uBitRAITMFIZ 6Zuz59CgQ5WUlGQoayfGx58+epSDW1XQPBqbm8ssFqErIjEcNtvs9HQOLprAxFFW Xm45No9XYWEhqF/M4I6SIHUwOBxOSjnqvkRRKJUgffkIPx7Y3h7FjaQIJQqSxJ7I ZXLOMCLwATmqQdyHSSQSv/7d79CKI3AASQMTpMfjyVnpuwtYPOXl5Rn2qft3764s LeWUBk5F8S0vBwEsdEUkCQhgp92eaw1GX1R0oabmmM+A0lBrNDn1WDKHCbAMMngn 5wdnBPjwdt4HsvMztByP241WHEEw0GhOYFBusWCOp6ANfv7uu2jFEbxCu76HYjKZ iouLM7HIv/r8c6/Hg1AlkaBUKq/09gpdCwnzaHAwJuWEN6elUKFoOnq5JL+gQKvT yTXNL4ek4mMBIINz6WQKJtBQVSpVlmmNTmTowQPMqTaRSNgp7xEhBCSACQzwsyJd 7e1taGpCK47gA5K+xwNKr6ys7MStYLBH//NPf8qRiDXwZXtv3sxBJ14OwY/+KiDQ YFra2o76skqVSiOvZOl8w4SJhl8kg7kCml8qtrNKheB+v7m+vry4yHcpu1DeI0JA aFgnkDCZTFrcrEgf/eY3rK8FEzBng8GIASbMFUDS90SMRmNxcfHxki8ajf7Xn/4k e5M0Ffjq2rXTpk0mDhKJRIYHBmQ/BkKDaWltPTSbEagOkL4U74odJIM5AWfLdy/9 9+5hLveEgkEv5T0iBIIEMIEHclYk4MNPPmF3Idh/gUAARLvsTUCxEYvFQPfmSHIj rlAoFGVlZVqt9pjPgKnx33/5i4z3spLJ5MW2tuKSEqErIhPcLtfU+LiM99LjicTF lpZDpyQQHql4V/L97jiQUzQ78gsKoFnibPnu5cHdu5htnvIeEcIiW2OIECH4jtDn q6tvPfccu2udTifIMIPBADKYDoAhEIlEvF5vIBAQuiJSBdpqcXHxMUs2Xo/ni7/+ VZZmPVjY1TU1Z86dE7oismJ9bU2uEdQSiURDY6PmsDUjZuNXlt9aEKBvgtQBGUzu PCcCDQ9+wRiO3/ymJyYwI1GR8zMhODTEE6gYjEa9Xo9WHAyyP//Vr9i5XsNsbbVa 4+kkh1BnkMHkWskH8I6CwaDP5wuHw0LXRfKAuC0pKSk6epnJtrn53bffykwDQxOy VFTUNTYKXREZsjA7a9vakpkaBPVbU1t7MOUvJTrij1Sk6Hg8GolQ3uCDKBQKJa6r 8z7gvTwaGkLNexQI+H0+tOII4iCymtUISVBcUoKpJEHHfvzb37K7NhQKbe5Jzq7R aIxGo06nk5k5KBRghvrTxMkk4hRoqKWlpaojji9urK9//913ctLAoGTaOjuFroVs GR8Z2ZZRik4Ydi7U1BiMxn0/p41fHOD5x1KO0dG8nPeLLgTdq1TCf4KPxsjOz5FI xO1yoRVHEIdCYz0hAJaKCszR1mQ2v3HnDrtrHQ7HvvzsCoXCZDIVFRUJPmlJF5j/ fD5fIBCgs2H8Aa3UbDYf2krlpIHVGs2l7m6hayFzngwPR2ThoHGo+k2d+NVqaeMX k5RfdDQKv+CNCF0XbMSjexmQe3cymbRtbaEVRxBHQQKYEADkw8Aw17782mvlFguL a2GwXltbOzhJQ+X1er3RaCS/6MyBh5lyfPL7QQALXZecoLCwsLi4+FCP6LXV1R++ /14kFhhrFApF97VrQtciJxgeGJC6pwYM4+cvXDCZTHt/SBu/wsJsCMMv2S+GKhRp 4atU5otp1PV5vROjo5jGGB39JUQCDfqEMJjM5uOD1nJLNo7QwWBw6+gFS5VKZUwf bJa6luAPmPPC4TDMebTlKwjQREtLSw+mC97a3Pzum2+kG+cc7Mie69dJuuAAPXeo v39HsnGMQL3X1NUZ9pz7BT2ioVDP4gBaVyIej8Vi8J+c5ggYnUD0MtJXnCMVsvNz KBTyejxoxRHEMYixQxI5Qll5OWZ0ZZABv3z/fXbX2u3249csmQ3hoqIikBninOcE AQwaZstX6ntHMgDaZ3Fx8b6kLy6n8+svvyyQYIsF9Xv12jVSL5gkk8mHAwNS1MCJ RKKuoUH3UzREyvErWuShhAsVP1IgRDznzBl88ACzO4MZ4LDb0YojiOMRb88kZA9+ VqSrvb0NTU0sLgT7yWq1ZnJaqbCwsCjNUSGIcgGY5wJpyNVZbBgMBrPZvHfhye/z ffHXvwpYJRZAL7vS20vqFx/QwI8GB6V1bhNq29jUpP7JAwJ0b2qZkhqPuAH1m0yA Fk4hicDRMCgxuhd+F7Po3WVzfX15cRGtOHJ+JsSGBHopIWPwsyJ99JvfsLsW5JzN Zsv88zAR6tOocuaAGeleSQCt0ZRmV0BGo9G//dd/xWIxYSuWIWBfdvf25kifEiEw ig6DBpaCJslL17b54sXC9IpPQWGhVqstpKTuUoPZFmaUsHgWX2AIYkRv6pe4d3oP pf/ePcp7ROQyEuuxhPwoKSlRIcaRghb/wSefsLsWBDAM4qe9CqZGkME6nU6W3tFg moDcDaaRioIi8tIZg0EDG41GRgbDe/z6iy88breYmyhUUqPVUsxnMfBkeDgcCom8 tSiUysampvw0ao2Ggl3JgNTOcDIJMhjEcPp/eHoYhsqClOQt/PF3KTsR9N+9i+kE EY1EXJT3iBAZNBkQwoOcFamhsfEqq8ixMNeura0l2Z6ZSR0804ABn0LqDtKgdcNh MIBTsH4ghOBAvzObzQaDgemAA31983Nz4jTswPAtLi1tbmkRuiLEj0xPTrqdTnFK ShiUjEbj+QsX4M8qdQryeZYlO2lACSf3ABI5m/PDqfUSGASZ39JCl0GcTZ0F87Oz jtO4s2UJ5T0ixIlM+jMhafCzIr374Yf7ogFlyPb2tp2LKA6FaWc80MNgmSnFGh9y H7uiF34Xjx8akT17d4NT6ZH++U+xhcUCE+rchQvnq6uFrgjxb6yurKwtL4ttxSSV 7qi62pQ+667WaqUb55zIhrQyTu7skv7Rvs8wMy/jIwD/K0j/LonpmDXxePxhfz/l PSIIOfdzQkJIKCvS1tZWMBjksDJgPjJKGFCpVOIx12CmjEQi0Wg0koZ2euUNtENj mlgs9uVf/wrvXega/QjomZb29uKSEqErQhyC2+WaHBsTz6gFEqexqSk1omq1mFkG CEIS9P3wA2ZvpbxHhGghAUyIBeSsSOUWy+1XX2VxIchCq9XKnxqEyUn1E8p0CkGc 6SqeTj6xCyne3CQ/P99gMJhMpkcPH85NTxcILWwKFYpL3d2kZMQMDB1PhocFD4uV TCRMZnN1TQ0jfeW9j0cQLBh9+jSIuBlLeY8IMUMzBCEW8B2h37hzx1xczOJav9/v cDg4r9JRwDNhlDAjhvfCnE3K5CZM7BCGdOiQVFjN3d9jUk66SPAB9Ef4/V//+IdQ OZyhoZZXVLDLW0bgMzczY9/aEsodGloLNBUYzxUSOVFCEMgEtrdHnzwh52eCYKB5 ghARRqNRh5gVCYTfr3/3O3bXbm5uhkIhbuvDGuYIExOlg5ne9qrZH+OCkL4lTo9W q11eWBAgMlZ+fntnpz4twgmpAPbu2MjIwZOWvALDeGlZWV1jI+36EsQxIDs/BwMB H+U9IkQMzRaEuCgpLcWMkKzT6X72y1+yuDAWi1mtVlKVRC4AumJ6YsLpcCDIYNAz Z86eramv57sggieW5ufXrVYEUzuZTGp1upa2NrVGw3dZBCFpHg4MYB5SiEajLqcT rTiCYAEJYEJ0YGZFAgV767nnqtPZMk6Lz+dz0hBP5AyhYHB2aioQCPDUPUHPFBkM za2tUk8SRoD5Oz0xse3389dUVEplU2urwWjk4/4EISccdvvc9DSafwTlPSIkAQlg QnSAEazX6zEHa3YRoUE8b25uhsNhzqtEEKIlEg7PTk/7vF4Ot/hI+soSPmRwIpHQ 6XTNbW2YWQMIQtI8uHsXc1MhEAhAr8cpjiBYQwKYECPm4mINoldbQWHh+x99xOJC coQmcpN4LLa0sJAKBbezw3qtKtVxdnbMpaV1DQ0kfeUKyOCFuTmP05lNhlUmj2tZ WVltfb2CVQp3gshN+u/fxzT0w+Gwx+1GLJAgWEICmBAp5RYLZsCGto6Ojq4uFhd6 vV6Xy8V5fQhCEoSCwcX5eZ/Pt5NMZh6QHD6s1etBzJjMZr5rSIgEr8cDTSUUCOSn w/VlckkqE1s6L1ddQwNmfESCkAcrS0sbVitacYlEwm6zoRVHENlAApgQKfhZkd7/ +GMWkhsu3NjYiEQifNSKIKRC6tzX5iZYP8FgMBGPM2HJmX/a2WE28FIxpc0lJVVn z6rVakErSwgJjJZglHtcLiaQfv6enWEmXj20HI1GU2axQFPBXAYlCDkBvWmwr4/y HhHEoZAAJsSLyWTS6nRoxcHw/dFvfsPiwmg0ur6+To7QBLGXUDDo9/mKDAboxZSf hjgKGDmhqWz7/QajEZoKM5BSgyGILEHOewS92Ov1ohVHEFlCcwwhasrKyxUKBVpx 586ff+b551lc6PF43HTuhSAIgiAIoZkaH/d6PGjFxeNxh92OVhxBZA8JYELU4DtC //xXv2Kx7QwXrq+vR6NRPmpFEARBEASRCdFI5NHQEDk/E8QxkAAmxI7RaMQMf8I6 KxI5QhMEQRAEISzIzs/BQMDn86EVRxCcQAKYkAAlpaWYWVKKS0pee/NNFheSIzRB EARBEELx9NGjcDq8HA7RaNTldKIVRxBcQQKYkAYVlZWY/jxv3LljLi5mcSE5QhME QRAEgU9ge3v0yRNMY2lrcxOnLILgFhLAhDQwGAz6oiK04rJxhLYipt0jCIIgCILI Q3d+Br3t9/vRiiMIDiEBTEiG4pISzPShILnfeucdFheSIzRBEARBEJg8GhyMxWJo xUUiEbfLhVYcQXALCWBCSlgqKgoKCnDK2tnZefm118otFhYXkiM0QRAEQRA4+Lze idFRNOfnZDJp29rCKYsg+IAEMCElkLMikSM0QRAEQRAi58Hdu5jbA5T3iJA6JIAJ iWEym7VaLVpxGo3m5+++y+JCt9vtQUxDTxAEQRBEDvKwvz+RSKAVFwqFvGTeEBKH BDAhPcotFrQwDzs7O7eee676wgUWF5IjNEEQBEEQ/OGw2+emp9E840Bp2202nLII gj9IABPSgxyhCYIgCIIgyPmZIFhAApiQJEaTSafToRWnUCrf/eADFheSIzRBEARB EHww0NcHqhStuGAw6PN60YojCP4gAUxIldKyMqVSiVbc1d7ehqam015FjtAEQRAE QXDO5vr68uIiWnGxWMzpcKAVRxC8QgKYkCpScYSORCKggTmvD0EQBEEQOQs5PxME a0gAExLGYDTq9Xq04goKC9//6CMWF5IjNEEQBEEQXNF//z6mBR8IBPw+H2KBBMEv JIAJaVNSUqJSq9GK6+jqauvoOO1V5AhNEARBEAQnrC4vr6+toRUXjURcLhdacQSB AAlgQvJYKiowvYA++s1vWFxIjtAEQRAEQWRP/717mOe/bFtbOGURBBokgAnJU2Qw 6PV6tMkAivngk09YXEiO0ARBEARBZEP/3bv5mEd/A4Ftvx+nOIJAgwQwIQfMxcUa jQatuKaLF69cvXraq8gRmiAIgiAI1izOzWHux4bDYY/bjVYcQaBBApiQCeUWS2Fh IU5ZIGXf//hjFsWRIzRBEARBECxIJpODfX1o/m6JRMJus+GURRDIkAAmZAJyViTW h4HJEZogCIIgiNPS98MPmAv9lPeIkDEkgAn5YDKbtVotWnE1dXXXb9487VXkCE0Q BEEQxKmYnZ52ORxoxYVCIS8t1hPyhQQwISuQHaHf/fBDpVJ52gtB/VqtVj6qRBAE QRCEzPj/7N3pexvXle97igRAEhNJgJPsSHE7nmNbtiJL1JjEcZyk0yfuTI4tD/lf z5vb5znn9rnmKIo0JXEGOGKoCajhFi2HUSyJAEGsXVXA9/Oo3R6ItXf0QsAPe9da tm3/n//6Ly4/A+1CAEZHUXwR2vW8uy1dhD48PDygsQQAAGiEy89AexGA0WmGhoYG k0lly51/4YWff/jhaV/FRWgAANDQwsxMuVxWtpyh66VSSdlyQCAIwOhAo2NjsVhM zVp+lP3PP/+5hcjtp18/A/svl9gVAACIuppl/ff//t/K7rXZtr27s6NmLSBABGB0 oFQqlc5k1F2Edt27X3/dwgu5CA0AAJ5H8eXnaqWiaZqa5YAAEYDRmbJDQ0mFF6En Jyd/8dFHp32V/2aztbVlWZbElgAAQHTNTU/7iVTZcrqul7n8jO5AAEbH4iI0AACI Ii4/A3IIwOhYqjtCt3oRulQq7e/vt30/AAAgouj8DMghAKOTcREaAABEC5efAVEE YHS4/OhoPB5Xs1bLF6Hr9frGxgYXoQEA6HKKLz/7n0D2dnfVrAWEBAEYHY6L0AAA ICq4/AxIIwCj82Wy2VQqpWy5li9Cb29vm6YpsSUAABB+ii8/a5pWKZeVLQeEBAEY XSGXzycSCTVr+VH2T3/9a//AwGlfyEVoAAC6lv8x4P/9X/9L2Z21Wq22v7enZi0g VAjA6BYTk5PhvwhdLpf3eDcCAKD7KL78XNjeVrMWEDYEYHQLxRehz7/wws8//PC0 r+IiNAAAXWhhZqas8DYyl5/RzQjA6CK5XC7R369mLS5CAwCAZqi+/GxZ9N1ENyMA o7uMT0z09vaqWYuL0AAAoCGVl5/9DyfFQkHNWkA4EYDRXTKZTCqdVrbciz/60e1f /OK0r+IiNAAAXWJhbq58eKhsOa1arShsNA2EEAEYXWckl+tXeBH6L599Fo/HT/tC LkIDANDxbNv+P//1X8ouP1uWdcDlZ3Q9AjC6kcqL0J7rft7SRehSqcQjOgAAdLD/ 53/+z14uPwNqEYDRjdKZTCqVUvaF68uvvHJ1auq0r/I8b2try7IsiS0BAIBgLS0u 7u/uqlnL/1ChaVqVy88AARhda3hkZOD0LZpb47/rfHr3bgv9LbgIDQBA53Fd1zSM 6f/7f5V9F2+a5uHBgZq1gJAjAKN7qbwI7fvsyy9beBUXoQEA6CRH6VfX/7///m86 PwOBIACje6XT6VQ6rezL1zd/+tNL779/2ldxERoAgI7hZ1G9Wt1YX1d2Hnt0+bl6 RM1yQPgRgNHVFF+E/vyrr1p4Ya1W29zc5CI0AACR5jqOn0X9N/T52VkuPwNBIQCj 26m8CO2/2/3tiy9aeOHhof/mxbsXAACR5LpuvVazTNP/+9npaS4/AwEiAKPbKb4I /d7ly2+89dZpX+V53ubmZq1Wk9gSAACQ87jllV2v+39fLBb3dnbUrMvlZ+CZCMBA z8jISH/oL0JbluVn4LbvBwAAyPHTr6FpjuM8/keVl58t0+T6GPA0AjBwROVF6Fhf 318+/7yFF+7v75dKpbbvBwAASDh+6PfxP87PzJxT9WGDy8/A8xCAgSPpTCaVSin7 Unbqxo2XXn75tK/y38w2NjZs25bYEgAAaCPHT7+VyvE/Huzvb29tqVn66PKzplWf WB3AMQIw8D2VF6H9KHv3669beKFhGNvb223fDwAAaBf/Xb5mWbV/HWE4NzOj7K4Z l5+BExCAgX9SeRF6YHDwP//85xZeuLOzQ0MLAADC6ajlla7/4LrWwtycyg1w+Rk4 AQEY+CeVF6E9z/v4d7/Lj46e9oWO42xsbBy30wAAACHhh0+9WvX/+uS/1DXt4YMH yj5dcPkZOBkBGPgXKi9C+yH2i7//vYUX+u9txWKx7fsBAAAt+0HLq2MqB/9y+Rlo iAAM/JDKi9DDIyO//f3vW3hhoVDQdb3t+wEAAKflum69VvPD59P/6f7ioqOqeyWX n4FmEICBH8pkMql0Ws1anuf94Y9/bGE527bX19ef/poZAACodPTQr2HY9frT/6lm WctLS8pmTGjVaoXLz0AjBGDgGUZyuf7+fjVruY5zt6WL0OVyeW9vr+37AQAATfLT r6Fpz2vMMfvNN32xmJqdWJZ1sL+vZi0g0gjAwLOpvAj9wosv3vnlL0/7Ks/ztra2 rH+dsgAAANTw0+/RQ7//2vLq2IOVFdMwlO2Ey89AkwjAwLNlstlUKqVmLT/K/uWz z+Lx+Glf6Kffzc1NiS0BAIATOI6jPf++sf9fFxcW1F1+1rRKuaxmLSDqCMDAc+Xy +UQioWYtPwN//tVXLbxwb2+vzHseAACqnNDy6tjM9HRMVefnWq22zyNRQNMIwMBJ JiYnlX19++prr/3s6tXTvsp/G15fX2csMAAACpzQ8urYxvp6uVRSsx/P8wrb22rW AjoDARg4ieKL0K0dAjMWGAAABfz0q2ua2+hL5/nZWS4/A6FFAAYayOfzcVUXoc/1 9v7t7t0WXri9vW2o6rQBAEAX8nPvUcurRgMIZ2dm+lQ10azXasyDAE6LAAw0pvIi 9NSNGy+9/PJpX1Wv1zc2NhgLDACAhJNbXh072N/f3tpSsJ8eLj8DrSIAA41ls9mk qovQruve/frrFl54eHh4cHDQ9v0AANDN/PflmmXVmhs6ODczo2yGoq5pdMEEWkAA BpqSHx1tYUxRa1Lp9P/4z/887as8z9vY2Kif2JYDAAA076jlla7btt3MD99bWHje TOC289/u93Z31awFdBgCMNCUdDrt51I1F6H9KPv7Tz7JZrOnfaFhGNvchgIAoB38 9GtoWpNzFkzTXFleVvY5QaseUbAW0HkIwECzskNDyWRSzVotX4Te2dnhHREAgDNq suXVsdnp6T5Vg391XVc2ZgnoPARg4BRGx8ZisZiatV548cU7v/zlaV9l2/b6+jrd sAAAaFmTLa+OPVhZMVXNYvDf6Hd3dtSsBXQkAjBwCoovQn96924LXyfTDQsAgNa4 rluv1SzTPNVL7s3Pc/kZiAoCMHA6Q8PDg4ODypb77MsvT/sS/91xfX29yY4dAADg saOWV4Zhn7KdpMrLz4ZhlA4P1awFdCoCMHBqY+Pjyt7q3n3//bd++tPTvkrX9UKh ILEfAAA60qlaXh0rFgrKujH7e9spFtWsBXQwAjBwaiovQrfcDWt7e9tQ9TwSAACR 5r/b6tWqe/ohRsoG/3L5GWgXAjDQipGRkf6BATVrJRKJP3366WlfVavVNjY2JPYD AEAnOW3D52Pzc3PKPklbpkmDD6AtCMBAi8YnJpR96fvx736XHx097Qv39/dLjEkA AOD5Ttvw+ZiuaQ8fPFB2HazIk01AmxCAgRZlMplUOq1mrdYuQvuvWltba+FCFwAA Ha+Fhs9PUtn7SqtWKy2ldABPIwADrcvl84lEQs1ak5OTv/joo9O+yn+/3FXVnAMA gKhoreHzsQfffmu2mpxPq1ar7e/tqVkL6AYEYOBMJiYnwzwW2H/V5uam/94ptCsA ACLnqOGzrjutzgtUPPi3sL2tYCGgexCAgTPJZrPJVErZci2MBTZNc2trS2IzAABE TssNn4+pvPysa1q5XFazFtAlCMDAWeVHR+PxuJq1fvbBB6++/vppX1UoFHRdl9gP AAAR0nLD52O7OzvKhvHW63VlQ4aB7kEABs4q/GOB/XfQ9fV1if0AABAVLTd8fhKD f4GoIwADbTA0NDSYTKpZK5lK/eGPfzztq3Z3d2kgCQDoTmds+Hzs3sKCp2q2gqHr zDIEJBCAgfYYGx9X80SQ53m//+STbDZ7qlc5jrO2tnaWS18AAESRn3796Fs/cz/I er2+tLio7MKXrmkc/wISCMBAe6i8CO2n2S/+/vfTvurg4ODw8FBiPwAAhNMZxx09 SengX02r0PsKkEEABtpmeGRkYGBAzVovvfzy1I0bp3qJ/yFgfX3dD89CWwIAIFTO OO7oSVubm4cHB2ev04zad7e1/QysZjmg2xCAgXYan5hQ1hvj86++Ou2ryuXy3t6e xH4AAAiVs487etL87Kyywb/0vgJEEYCBdspkMql0Ws1aftL+9O7dU73Ef1vd2Nio t+MmGAAAoeXnXq1SaVfnC2Xp16fruus4BGBADgEYaLNcPp9IJNSs9fMPPzz/wgun eommaUVVAwwBAFDv+wDZpvRr6PqDlRU1Adi2bdMwSL+AKAIw0H4Tk5Nh7oa1ublp WZbEfgAACFZbhv0+SVnvK8/zdE1jZiEgjQAMtF92aCipaizw5OTkLz766FQvMU1z a2tLaD8AAASl7el39dEjTdV57FG3atvm+BeQRgAGRIyOjcViMQULeZ736d27p/1y ent72zAMoS0BAKCY67o1y6q19X6T/w67MDen7EqXoeukX0ABAjAgQuVYYH+Vv33x xaleYlnW5uam0H4AAFCpjcN+nzQ3M6NmskMPg38BhQjAgBSVY4Fv3L598cc/PtVL CoWCrutC+wEAQI2j9KvrdjuG/T7JT6SPHjxQ80V2zTrC4F9ADQIwIEjZWGD/7f/u 11+f6iW1Wm1jY0NoPwAAKOC//Rm67rQ7/fao7X3F4F9AJQIwIEjlWOCx8fFfffzx qV5SLBb5vhkAEFF++tU1zXWctld+9OCBsktS/kI1yzJNU81yAAjAgKx8Ph9XMha4 hW5YHAIDACLqKP1Wq/5f215ZZe8rBv8C6hGAAVkqu2H5Pvvyy1P9PIfAAIDI8XOv Vqn4SVWiuLLeVwz+BQJBAAbEDQ0NDaoaCzx148ZLL7/c/M9zCAwAiBbXcbRqVSj9 ViuVtdVVicpPM03Trtc5/gUUIwADKoyNj6vppdFCNyzaQQMAosJPv0eJUSb99ijs ffX4AWbSL6AeARhQQeVF6Fw+//Hvftf8zzMTGAAQCUfpV/LC8MOVFcMw5Oo/yU+/ ZQb/AkEgAAOKjORy/f39ChZqoRvW9va2srd8AABa4DiOJpl+Vfa+qtfrlmly/AsE ggAMqDMxOanmndVf5W9ffNH8z5umubW1JbcfAADOQjr99qjtfaVpmuhRNoATEIAB dTLZbCqVUrPWzz/88PwLLzT/85ubm5Zlye0HAIDWKEi/hq4/WFlR8yW1YRi1Ws2g +wYQEAIwoNTo2FgsFlOw0Gm7Yem6XigU5PYDAMBp+e9l9VrNMk3phWa++UbNu7Mf 5v3oy+VnIEAEYEApld2wLly8ePPOnSZ/2PO8jY2Ner0uuiUAAJrkp18/+voBWHqh zfX1UqkkvcpjmqZV6H0FBIoADKg2PDIyMDCgYCE/037+1VfN/3ylUtnd3ZXbDwAA TVKWfnsUPv1b++4028/ACtYC8DwEYCAA4xMTat5r44nEnz/9tMkf9gPz2tqa4zii WwIA4GQq0++9+XlPbKrwk456X1WrXH4GAkcABgKgrBuW/3b7+08+yWazTf58qVTa 398X3RIAACdQmX7r9frS4qKi3le6XqvX6X0FBI4ADAQjnN2w/B9eXV1V8104AAA/ oDL9+mamp2N9fQoWovcVEB4EYCAYKrthvfX22+++916TP7y3t1emPwcAQDnF6Xdv Z6dYLKpZi95XQHgQgIHAKOuGdapD4Hq9vr6+LrofAAB+QHH67aH3FdCtCMBAkJR1 w0pnMv/xySdN/nChUNB5SAkAoMpR+jUMlaP4lu7ft5UsR+8rIGwIwECQVHbD+stn n8Xj8WZ+2DCM7e1t6S0BANDzXfo1DUNNHD1e8d78vLLeV5ZlmaapYC0AzSAAAwHL j442mUvP6ty5z774osmf3djYqCm8hwYA6E7qz357FF5+pvcVEEIEYCBgqVQqncmo +R76lx99NDE52cxPlsvlvb096f0AALqZ+ud+e747kn2wsqLgbdfzPF3TKpWK9EIA ToUADARveHh4YHBQwULNd8Pyf3Jtbc3/q/SWAADdKZD065udnu5TMvqodtT8yuL4 FwgbAjAQCsq6Yb32xhuXr1xp5ieZhwQAkOOnX0v5k7HFQmFvd1fBQvS+AkKLAAyE grJuWM0fAjMPCQAgxHEcLYi7wcqe/jUMo1arGYxUAMKHAAyExejYWCwWU7BQNpv9 9z/8oZmf3N7e9t/CpfcDAOgqQaXfb5eW1PR3dF1X1zSOf4FwIgADYZFOp1PptJq2 HJ/evdvME1C6rhcKBen9AAC6R1Dp13/vW5ibU9NyUtM0z3UJwEA4EYCBEBnJ5fr7 +xUs5H8C+FsTI5H8jwtra2v+hxUFWwIAdDzXcaoBdUVWdvm5Xq+bhuFnYAVrAWgB ARgIl4nJSTXfT//6t7/Nj442/LGDg4PDw0MF+wEAdLYA069pmivLy2ruWPnRN6j/ mQCaQQAGwiU7NJRMJhUs1GQ3LNu219bWFOwHANDBAky/PQpHH/lJ27Isel8BYUYA BkJnbHxczfv0W2+//e577zX8MVphAQDOwnVdrVLxPC+Q1fd2dorFooKF6H0FRAIB GAidtC+TUbBQk4fAtMICALTsKP1Wq57rBrUBZU//+unXpfcVEHoEYCCMcvl8IpFQ sFB+bOzXv/nNyT9DKywAQGuODkWrVTe49PtwZUXNJSbbtg1dp/cVEH4EYCCMVI5E +vyrrxr+2P7+fqlUkt4MAKCT+LnX0LRgvz+dn51V82bqZ98Kva+AKCAAAyE1NDw8 ODioYKH+ROKPn3568s/U6/X19XUFmwEAdAY//Zq6btt2gHtYXFhQc/hsWVa9VuPy MxAJBGAgvMYnJhQ8tuR53l8++ywej5/8Y5ubm/4bvPRmAAAd4Cj9GoZdrwe7h3vz 84pGH1WrpF8gKgjAQHhlstlUKqVmrc++/PLkHyiXy3t7e2o2AwCILj95WqZZr9WC 3Yay3leGYdRqNUYfAVFBAAZCbWxsrC8WU7DQr3/72/zo6Ak/4H+gWV1dDWqIBQAg Kvz06/8Kdg+maa4sLys4/mX0ERA5BGAg1EI1EqlYLNLfEgBwAsdxtBD0gpr55puY kq+PGX0ERA4BGAg7ZSOR3r9y5fU33jjhBxgIDAA4ges41RCk34P9/e2tLQULMfoI iCICMBB2ykYiNTwEZiAwAOB5/DcRrVIJw5Mys9PTfX190qsw+giIKAIwEAHDw8MD SkYiXbh48eadOyf8AAOBAQBPe/worBuCb0g31tfLSt6napZVY/QREEEEYCAalI1E +vyrr074Af/NfmNjQ3obAIAICcPI32Nqmj8z+giILgIwEA3ZbDapZCRSJpP5/Sef nPADDAQGABwLydCjx5aXltTsxDAM/3+1GXSzawAtIAADkTE2Pq7moaaTD4EZCAwA OBaGoUfH5mdnGX0E4GQEYCAylI1EisVif/nss+f9V8dxVldXFWwDABByIWn7/NjC 3JyahRh9BEQaARiIknw+H5cfieR5nh+A4/H4835ge3vbMAzpbQAAwiw8bZ97vtvM vfl5Bce/jm3rjD4CoowADESJspFIvs++/PJ5/6lare7s7CjYAwAgnI6uAVer/l+D 3sj31PS+8mnVqp/5Of4FoosADETMyMhI/8CA9Cr+u/vvP/kkm80+87/6n3hWV1dD 8q0/AEAx/13A0HUnHG2fffV6fWlxUcG3w/5ClmmSfoFIIwAD0TMxOammycfdr79+ 3n8tFotcAAOA7mQaRi1M4wDmpqd7lTSJZPQR0AEIwED0DA0PDw4OKljoVx9/PDY+ /sz/5KdfPwMr2AMAIFQcx9FC0/iq57uJRA++/VbB98KWZRm6zugjIOoIwEAkjU9M KHjYyf+U88Xf//7M/+R53urqanie/gIAKBCqts+PzXzzTSwWk16F41+gYxCAgUjK ZrPJVErBQlenpl5+5ZVn/qednR0+CgBA9zhq+1ytemH66rNcKm2srytYyDAMx7Z5 1wM6AAEYiKqx8fE++UeeTngS2P80sL29Lb0BAEAYhK3x1WNqjn+PWl5rGukX6AwE YCCq0plMOp1WsNCbP/3ppffff/rfcwsaALpH2Bpf+XaKxV0lM/l0XT+6+00ABjoC ARiIsPzoaDwel17lhEPgvb29crksvQEAQLDC1vjqsdnpaQU3ofz/7bqmMfgA6BgE YCDC0ul0Kp1W0PrywsWLN+/cefrfm6a5tbUlvToAIEBHj/5WKmGb/b6xvl4ulRQs 5Edfz3U5/gU6BgEYiLZcLpfo75de5XmHwP7nobW1NcdxpDcAAAjE48df3fD9OT83 M6NgGoJt26ZhkH6BTkIABiJvYnJSwSHw5OTkLz766Ol/zy1oAOhgIXz017f66JEm H0qPRh9pWtjGPgE4IwIwEHnDw8MDg4PSq/ifAz7/6qun/z23oAGgU4Vw6u9jao5/ az7L4vgX6DAEYKATqDkEHhsf/9XHH//gX3ILGgA6Ujgf/fU9fPDA0HXpVY6Of6tV 0i/QeQjAQCcYGh4eDO4QeHd3txLKIwIAQGtC++hvj6rjX8uy6rUaARjoPARgoEOM T0wo+ECQHxv79W9+84N/aRjG9va29NIAAGXC+eiv78HKir836VU4/gU6GAEY6BDZ oaFkMim9yjMPgf1/ubq66rqu9OoAAAVC++hvj6rjX9M07XqdAAx0JAIw0DnUHAKP 5HK/+fd//8G/3NnZ4YMCAHSA0D7663vw7bd+NJVeheNfoLMRgIHOkclmU6mU9CrP PATWdb1QKEgvDQAQ5adfU9dt2w56I8+m5vjXMAzHtgnAQKciAAMdZWx8vK+vT3qV oeHh3/3Hfzz5b/xU/OjRo3CeGAAAmmSZpiV/xNqaleVlS/6x5Mfdv0i/QAcjAAMd JZPJpNJp6VWeeQhcLBY1TZNeGgAgxM9+R4/+hvKrTP99Z352VsXxr647jkMABjoY ARjoNKNjY7FYTHqVpw+B/fTrZ2DpdQEAEvz0a2haaIe6Kzv+1apVvswFOhsBGOg0 aV8mI73K04fA/ueG1dVVbkEDQBSF+fKz/86yMDd37pz4p9aj0ceuy/Ev0NkIwEAH Gh0djcXj0qtkMpnff/LJk/+mUCjoui69LgCgvY5SX7kc9C6ea3lpqV6rSa/iOI6h 66RfoOMRgIEOlE6nU+m09JflTx8CVyqV3d1d0UUBAO31uO2TG9bLz8qe/tU0zeP4 F+gCBGCgM+VHR+Pyh8C5fP7j3/3u+B8dx1ldXZVeFADQRmG+/Ox7uLJiGIb0Khz/ At2DAAx0pqAOgTc3NxX0KQEAtEXILz9z/Aug7QjAQMdScwg8ef78L371q+N/LJVK +/v70osCAM4u5J2ffasPHyroyczxL9BVCMBAx1JzCOx/frr79dfH/1iv19fX10VX BAC0RcgvP3P8C0ACARjoZPl8Pp5ISK/y0ssvT924cfyPfgD2Y7D0ogCAswj55Wff 5vp6qVSSXsVxnB2G2APdhAAMdLJUKpXOZBQfAu/v7yv4yAIAaNnR5Wddd2w76I08 l+d5czMzfX190gtp1aq/Fse/QPcgAAMdLpfPJ+QPgV9/8833f/azx39vmubW1pb0 igCAltUsy5RvrXwWhe3t/b096VVs297d2ZFeBUCoEICBDqf+SWDP89bW1sLcVQUA upn/J7ZWqfh/Vge9kefi+BeAHAIw0PnUHAK/d/nyG2+99fjvd3d3K5WK9IoAgBaY hlEL97y6vd3dYqEgvQrHv0B3IgADnU/9IbCu6wX5zy4AgNNyHaca7i8oVR7/8l0t 0IUIwEBXUHMIPHXjxksvv9zzXRheXV0N8/06AOhC/h/Ouqa54X5EpXR4uLmxIb0K x79A1yIAA11B/SFwoVDQdV10OQDAqYR88G8Px78A5BGAgW6h5hD417/9bX501P8b /4PF7u6u9HIAgCaFv/eVT9e0Rw8fSq/C8S/QzQjAQLdQcwjsf7T6/Kuver77eLG2 tia6FgCgeeHvfUXzZwAKEICBLpLP5+PCh8D+R4o//fWv/QMD/t9vbGzUajXR5QAA zXBdt1ouB72LBur1+tLiovQXtY7j7BSLoksACDMCMNBF1BwC9/b1ffr55/7fHBwc HB4eiq4FAGjIT7+GpoV8PLvneffm5xUspGlaJfTfBQCQQwAGukt+dDQej4sucXwL 2rKszc1N0bUAAA3VLMs0jKB30YCf0v0AzPEvAGkEYKC7pH2ZjPQqyVTqD3/8o5+E 19bWQn7mAACd7Wj0UbXq/zXojTRwf3HRsW3pVTj+BUAABrrO6NhYLBYTXeL4EHh3 d5c5EwAQoPCPPur5LqUvzM319vZKr1IsFESXABB+BGCg66g5BD7/wgs///BDXdcL fNoAgIBEYvSRb/XRI02+J7OuaWWOf4GuRwAGupGCQ2D/U9fdr7/2/7q6uhr+z14A 0JHCP/qo57v3i/nZWenpR0dXwTWN0UcACMBAN0pnMul0WnqVn77zzjuXLm1vbxuh b74CAJ0nEqOPfMVicW9nR3oVXdfLpZL0KgDCjwAMdKmx8XEFX7ff/frrcrm8t7cn uhAA4Gkc/z65Cse/AB4jAANdKpPJpOQPgX/+4Yd+0l5bW5NeCADwpKgc/1bK5XX5 9whD10sc/wL4DgEY6F4qDoE97+5XX62vr9frddGFAABPMnW9VqsFvYsGPM+bm53t E27+7K9ydPjL8S+A7xCAge6VzWaTqZToEv7Hjj/99a8aX70DgEJROf71I/ry/fvn zsl+HDUMo3R4KLoEgAghAANdbXxiQnruYl9f3//44x+3trZEVwEAHDN0vR6F4997 8/MKVqlWKpqmSS8EICoIwEBXGxoaGkwmRZfwP3x89uWXq6urruuKLgQA6InO8a/j OIsLC9LHv5ZlHezviy4BIFoIwEC3m5iclP78MT4x8falS3wBDwAKROL41/fwwQN/ q6JL8PQvgKcRgIFuNzIy0j8wILqE67p/+NOfduTHPAJAl4vK8a+a6Uf1en1vd1d0 CQCRQwAGoOIQ+PKVK/H+ftElAABROf71c2mxUJBe5ejwt1KRXgVAtBCAAfTk8vlE IiG6hOu6v/joI8uyRFcBgG4WlePfo+lHMzPSx7+2be9y8wjAUwjAAHrS6XQqnZY+ BP7w4495DBgA5ETl+LdmWctLS9JvOv47TiUKXwcAUIwADODI6NhYLBYTXaK3t/eD 69dFlwCArhWh4997c3M9wunX/91QcMUaQBQRgAEcSfsyGdEl/A89N3/+c8dxRFcB gO4UleNfx7YX792TPv7Vdb1cKokuASCiCMAAvjc2Pi79RFYylXrnvfdElwCALhSV 41/fw5UVwzBEl+D4F8AJCMAAvpfJZlOplOgS/oeS67dviy4BAF3INIxaFLoMOo6z MDcn/WWrH7BLh4eiSwCILgIwgH8an5jo7e0VXeLCSy+98OKLoksAQFc5Ov6tVHo8 L+iNNLa7s7NTLIou4Xme/7tBz0UAz0MABvBPQ8PDg4ODoks4jnPjzh3RJQCgq1im 6f8KeheN+UF9fnZW+vjXsqyD/X3RJQBEGgEYwL+YmJwU7U3ied7VGzekz5kBoEv4 qVKrVLwoHP/Wa7Wl+/el32K06hG5JQBEHQEYwL/I5fOJREJ0CeYhAUC71CzLFO4p 1S6L9+65woMAbNve3dkRXQJA1BGAAfwLNfOQpm7dEl0CALqB67p6ter/NeiNNOY4 zr35eenrP5qmVSLSDRtAUAjAAH5odGwsFouJLvHihQs/unhRdAkA6HgROv4tFot7 wmezTD8C0AwCMIAfymQyqXRadAlaYQHA2Rm6Xq/Vgt5FY57nzc7MxKSnH+l6qVQS XQJAByAAA3gG6XlI/oehK1NT0ufMANDBjqYfReS6b82ylpeWaH8FIAwIwACeQcE8 pN5z5z64cUN0CQDoYKZh+MEy6F00ZXFhQfpBZaYfAWgSARjAsymYh0QrLABoTYSm Hzm2fW9hQfpWEce/AJpEAAbwbLlcLtHfL7rE+RdfvPjSS6JLAEBHsnwRaX9V2N7e 39sTXYLpRwCaRwAG8GypVCqdyYgeAtMKCwBao1erfuoLeheNHbW/mp6W7vjA9CMA zSMAA3gu6XlItMICgBZEqP2VZVnfCre/YvoRgFMhAAN4rkw2m0qlRJc419t79fp1 0SUAoMNEZfqR7978vPSDykw/AnAqBGAAJ1EwD4lWWADQvKPj30qlJwrtr2zbXqT9 FYCQIQADOMnwyMjAwIDoEhdeeumFF18UXQIAOoZlmv6voHfRlJ1iUbo3Va1Wk+6w BaDDEIABnCSdTqfSaVphAUBIRKj91dzMTF9fn+gqR4e/lYroEgA6DAEYQAMKWmFx CxoAmhGh9lf1en1pcZH2VwDChgAMoIFMJpNKp0WXGBgcvHT5sugSANABTF2vRaT9 1crysmVZokvQ/gpACwjAABqTboXluu7127fl6gNAB/D/qNQqFemmym3hOM7C3Jzo /WfaXwFoDQEYQGMKWmG9femS9DkzAERazbJMwwh6F02pViprq6uiS9D+CkBrCMAA mjIxOSn6KJfX0zN186ZcfQCIOl3T7Ho96F00ZX5uTvojJu2vALSGAAygKbTCAoAA Rav91f1796QfnKH9FYDWEIABNEVBKywGAgPA80Ro/G+xWNwTHv9L+ysALSMAA2gW rbAAIChateow/vcfS9D+CkDLCMAAmiXdCotb0ADwTFG6/1yrLd2/L9ozgvZXAM6C AAygWel0OpVOi36syWSzb73zjlx9AIgi0zBqwjN12+XhgweGrosuQfsrAGdBAAZw CtKtsBzHuXHnjlx9AIicCI3/9bc6Pzsrev+Z9lcAzogADOAUMtlsKpWSq+9/wrt6 44bok8YAEC0RGv9rmubK8rLoRSHDMEqHh3L1AXQ8AjCA05EeCBxPJC5/8IFcfQCI FlPXa7Va0LtoytLioi3ZqcvzvGqlomma3BIAOh4BGMDp5PL5RCIhV59e0ABwLEL3 nx3HWZibE73/7KfrXeEBSwA6HgEYwOmkfZmM6BLvX7mS6O8XXQIAIiFC9591TXv4 4IHoFSFN0yoR6YYNILQIwABOTXog8Lne3qvXr8vVB4CoMHS9HpH7z/fm50VPqv3i he1tufoAugQBGMCpDQ8PDwwOytXnFjQA9ETq/rNt24sLC6LfjdYsa39/X64+gC5B AAZwagoGAv/03XelL1oDQMhF6P5zuVzeWFsTXYLxvwDaggAMoBVj4+OinU68np6p mzfl6gNA+EXo/vPC3Jxofcb/AmgXAjCAVmSHhpLJpFx9bkED6HLcf36SaZqHBwdy 9QF0DwIwgBZJDwR+6513MtmsXH0ACLMo3X8ulTbW1+Xqe56nHV2ArsotAaB7EIAB tCg/OhqPxwUX8Lxrt24J1geAEIvQ/ef5uTnRD5SO4+wUi5IrAOgiBGAALcpks6lU Sq4+t6ABdDOtUvGDX9C7aEzB/WdD10ulklx9AF2FAAygddyCBgAJrutWy+Wgd9GU 0uHh5saGXH3uPwNoLwIwgNbl8/l4IiFXn17QALqTaRg1ywp6F01ZmJ3tkfwm1Lbt 3Z0dufoAug0BGEDr0plMOp2Wq88taADdSatWHdsOeheNKbj/rOt6mfvPANqHAAzg TKRvQb9/5Uqiv1+uPgCETYTuP1crlbXVVbn6nucVtrfl6gPoQgRgAGeSy+VEA2pf X9+VqSm5+gAQNpZp+r+C3kVTFu/dcyU7ddn1+u7urlx9AF2IAAzgTNK+TEauPreg AXQbXdP84Bf0Lhqzbfve/HxfX5/cEpqmVSJyGA4gKgjAAM5qfGJC9AGwD65fF60P AOERofvPhq4/WFmRewqG+88AJBCAAZzVSC7XL3kL2i/+3pUrcvUBIDxqlmUaRtC7 aMry/ft1yZNqv/ge958BtBsBGMBZSd+Cdhznxp07cvUBIDwMXa/XakHvojH/T+aF uTnuPwOIHAIwgDYQvQXted7UrVtCxQEgVLRKxZFsK9Uulml+u7zM/WcAkUMABtAG 0r2gR8fHf/Lqq3L1ASAMIvQA8MbaWllyq9x/BiCEAAygDbgFDQBnZxpGzbKC3kVj nufNzcxw/xlAFBGAAbTHxOSk6F04bkED6Hh6tWrbdtC7aKxWqy3fv8/9ZwBRRAAG 0B65fD6RSMjVf+3NN0dyObn6ABCsCN1/3t/bEw2otm3v7uzI1QfQzQjAANojk8mk 0mnRJa7dvClaHwACFKEBSPNzc6KfIHVdL5dKkisA6F4EYABtI3oL2nXd67dvCxUH gMBFZQCSbduLCwuinf+16hGh+gC6HAEYQNvkR0fj8bhc/Q+uX5f7yAUAwYrKACRd 1x+urMh93en/JuwUi0LFAYAADKBtstlsMpWSq59Kp9++dEmuPgAEJUIPAD/49lvT NOXqG4ZROjyUqw+gyxGAAbST6C1ohiEB6FSWaVqSqbJd/KA+PzPTF4sJ1ef+MwBp BGAA7TQ2Pi43GZJhSAA6VVQeALYs69ulJdF2D8VCQag4APQQgAG019Dw8ODgoFz9 V994I5fPy9UHgEBE5QHgvZ2douQDun7APtjfl6sPAARgAO2U9mUyokswDAlAh4nQ A8DSA5CObj9XKpIrAOh2BGAAbTY+MSHXq5lhSAA6T1QeALZt+978vOhzLoXtbaHi APAYARhAm+VyuUR/v1BxHgMG0HkMTavX60HvojFD1x9IDkDyfxP2dneFigPAYwRg AG2WzmTS6bRc/dHx8Z+8+qpcfQBQyXVdrVLxPC/ojTS2vrpakbyfrGtaOSJXwQFE FwEYQPuJDkPiFjSATlKzLNMwgt5FY35En5uZEb3/zAAkAAoQgAG03+jYWExySiS3 oAF0jKg8AFyv1+/fuyfX4sFxnB3J/tIA8BgBGED7DQ0NDSaTcvV/du2aXMAGAJV0 TbOj8ABwtVpde/RIrr5pmocHB3L1AeAxAjAAEZPnz8sVT6ZS77z3nlx9AFCmWqm4 UZgA/O3SUq1Wk6vv/z5w/xmAAgRgACJEhyE5jnPjzh2h4gCgTFQmAPv7nJudjTEA CUD0EYABiMjl84lEQqg4jwED6AxReQC4ZllL9+/Lfa3JACQAyhCAAYjIZDIpyWFI l69ejcfjcvUBQAFD1+uS94rbpVIur6+tydXXdb1cKsnVB4BjBGAAUkSHIQ0MDl66 fFmoOACooVUqThQeAF5eWpIL6gxAAqASARiAlLHxcbmJkTwGDCDqIvMAsOMcPQAs 1nvf/30oFgpCxQHgBwjAAKSMjIz0DwwIFecxYABRV7Ms0zCC3kVjlmV9u7Qkd6On Vqvt7+0JFQeAHyAAA5CS9mUycvWZBgwg0iLzAHClsr66Kldf07RKFE7CAXQGAjAA QaKPASfT6XcuXRIqDgDS9GrVtu2gd9HYyvKyZVlCxRmABEAxAjAAQTwGDADPFJkH gF13fnZW7k9yHgAGoBgBGICg4ZGRAbHHgP2PTddv3xYqDgCiovIAcK1WW1pclJsA bFnWwf6+UHEAeBoBGIAg6ceAr928KVccAORYpun/CnoXjema9vDBA7mHWXgAGIBi BGAAssYnJuSODl64cOHCxYtCxQFATlQ6YK0+eqSJTejlAWAA6hGAAcjK5fOJREKo eG9f3wdTU0LFAUCOVqk4jhP0LhpbmJuTK84AJADqEYAByBoaGhpMJoWK8xgwgCiK Sgcs3+z0tFwHLEPXS6WSUHEAeCYCMABZoo8BE4ABRFFUOmD55mZm5B5jqVYqVbH7 1QDwTARgAOJEHwO+dPnywOCgUHEAkOCn35rYZN02sixrZXlZqDgDkAAEggAMQFx+ dDQejwsVzwwNvfX220LFAUCCrml2vR70Lhp7sLIid1Jdr9f3dneFigPA8xCAAYgb Gh4eFDuk9Xp6phiGBCBSotIBS/T+s2EYpcNDoeIA8DwEYADiRB8D9j9E3rhzR6g4 ALQdHbAe4wFgAIEgAANQYWJy8tw5kT9wPM+bunVLojIASIhQB6z52Vm5P7qZAAwg EARgACqMjo3FYjGh4v/2k5+MT04KFQeA9opKB6z9vT25jGrb9u7OjlBxADgBARiA CiO5XH9/v1DxRCLx/gcfCBUHgPaKSgesxYUF13WFiluWdbC/L1QcAE5AAAagQjab TaZSQsUd173BNGAAERGVDliiDwDrmlaOyIPQADoMARiACul0OpVOCz1L5rrudQIw gCiIUAcsuRbQnudp1SodsAAEggAMQJHxiQm5z1JXpqbknjEGgHaJSgcsx3EWFxbk vrUsFgoSlQGgIQIwAEXyo6PxeFyq+NjYK6+9JlQcANrFMk3/V9C7aGx9dbVSqQgV r9fre7u7QsUB4GQEYACKDA8PDwwOChXv7e394Pp1oeIA0C6GrtdrtaB30djC3Jxc cdMwDg8P5eoDwAkIwAAUyWQyqXRaqLjrONfv3BEqDgDtolWrjm0HvYvGZr/5pk/s uRL/N0HueBkATkYABqDOxOQkfbAAdC06YPV817VBbrwwADREAAagztj4uNBQDf8T 1dUbN4Q+rgFAW0SlA5b/J+rC3JzQ95WO4+wUixKVAaAZBGAA6uRyuUR/v1DxFy5c uHDxolBxADg7yxeFAFzY3t7f2xMqXrOs/f19oeIA0BABGIA62aGhZDIpVDyeSFz+ 4AOh4gBwdlHpgLV4757rOELFdV0vl0pCxQGgIQIwAHXSvkxGqDiPAQMIOV3T7Ho9 6F00Njs9LfS4iq9aqVSrVaHiANAQARiAUoJ9sGgEDSDctErFETtZbaO56elesX4N dMACECwCMAClRPtgTd26JVEZAM4uQi2g52dn6YAFoFMRgAEolcvnE4mEUPFX33jD ry9UHADOIiotoMul0sb6ulDxWq0m114LAJpBAAag1NDw8ODgoFDxwWTy3fffFyoO AGdhmab/K+hdNLa8tCTXqcswjNLhoVBxAGgGARiAUulMJp1OCxXnFjSA0DJ1vRaF FtBzMzNyM9WrvkpFqDgANIMADEA1uT5YjuPcoA8WgFDSq1XbtoPeRWNyLaDpgAUg DAjAAFSjDxaALhSVFtB0wALQ2QjAAFTLj47G43Gh4j+7ejUmVhwAWhOVFtC2bS8t LgoVr9fre7u7QsUBoEkEYACqDQ8PD4j1wZo4f/6ll18WKg4ArYlKC+itzc3DgwOh 4v7vwCEdsAAEjQAMQLVMNptKpYSKxxOJyx98IFQcAFoTlRbQi/fuuWL3tDVNq0Th GBxAZyMAA1AtnU6n0mmhZ8w81526fVuiMgC0zNB1udlCbTQ3Pd0r1qNBO+oBXZUo DgDNIwADCMD4xITQmA0aQQMIIV3T7Ho96F00JtcC2nXdYqEgURkAToUADCAAo2Nj sVhMojKNoAGEEC2gbdve3dmRqAwAp0IABhCAkVyuv79fqDiNoAGETbVcdl036F00 INoC2rKsg/19oeIA0DwCMIAADA0PD9IIGkB3iMoMJNEW0IZhlGgBDSAECMAAApDJ ZFLptFBxGkEDCJWozECSbQFdrVYqFaHiANA8AjCAYExMTtIIGkA38NOvn4GD3kVj oi2gC9vbEpUB4LQIwACCQSNoAF0iKjOQaAENoBsQgAEEg0bQALqEXq3ath30Lhqj BTSAbkAABhCMXC6XEGsEfWVqSugcAwBOKxIzkFzXXVxYECpes6x9WkADCAcCMIBg iDaC/tHFiy9euCBUHACaF5UW0MVicU/skJYW0ADCgwAMIBiijaAHk8l3339fqDgA NC8qLaCXl5bkHlSmBTSA8CAAAwiMXCPonnPnrt24IVIZAE4jKgFY7gFgWkADCBUC MIDA0AgaQMeLygykmenpGC2gAXQBAjCAwMg1giYAAwgJZiDRAhpAqBCAAQQml88n EgmJykxCAhASuqbZ9XrQu2hM7gp0rVbb39uTqAwALSAAAwjM8MjIwMCAUHEmIQEI A2YgmaZ5eHAgVBwATosADCAw2Ww2mUoJFb/w4x+/8KMfCRUHgCZVy2U/Xga9iwZ2 ikW5W8q6ppWjMAgKQJcgAAMITNqXyQgVT6bT71y6JFQcAJoRlSHA3y4vy3XqqlYq 1WpVqDgAnBYBGECQ5CYh+WWvMgkJQKCYgcQMJABhQwAGECQmIQHoYJZp+r+C3kVj zEAC0D0IwACCxCQkAB0sKkOAmYEEoHsQgAEEiUlIADpYVIYAMwMJQPcgAAMIktwk JAIwgMDp1apt20HvojG5AMwMJABhQwAGECTRSUivvP56fnRUqDgANBSJIcClUmlz fV2oODOQAIQNARhAkEQnIQ3ncq+/+aZQcQBoKBJDgB89fOjHVKHizEACEDYEYAAB k5uEFI/HL1+9KlEZABqKyhDgxYUFoZTODCQAIUQABhAwuUlIPAYMIEBRGQI8NzMj 9IcwM5AAhBABGEDAxsbHhcZv+J+9rt++LVEZABqyfFEIwHIzkBzH2SkWJSoDQMsI wAAClh8djcfjEpUZBQwgQAwBrtfre7u7EpUBoGUEYAABG8nl+vv7JSpzBRpAgBgC bFnWwf6+RGUAaBkBGEDAhoaHBwcHJSoTgAEESNc0u14PeheNyQVgwzBKh4cSlQGg ZQRgAAETHQX8+ltvDY+MCBUHgBNEYghwpVxeX1sTKs4QYAAhRAAGEDDRUcC50dFX X39dqDgAnCASQ4DXVlerlYpQcYYAAwghAjCA4DEKGECHYQgwQ4ABhBMBGEDwBEcB 9/RM3bwpURkATsAQYIYAAwgnAjCA4MmNAmYSEoBARCUAz3zzTSwWk6jMEGAA4UQA BhA8RgED6DCWafq/gt5FYwwBBtBtCMAAgic3Cth13eu3b0tUBoATmLpei8IQYLkr 0AwBBhBOBGAAwRseHh5gFDCADmLoej0KAVhuCLBpGIcMAQYQPgRgAMHLDg0lk0mh 4tdoggVAOb1atW076F00tjA3J1RZ1/VyqSRUHABaRgAGELxMJpNKp4WKv/rGG7l8 Xqg4ADyTVqk4jhP0LhrwA+rG+rpQca1arYhNGAaAlhGAAQQv7ctkhIrnx8Zeee01 oeIA8Ex++HNDH4DXV1flMqr/O1CtVoWKA0DLCMAAQmFiclLoObSBwcFLly9LVAaA 56mWy67rBr2LBpbu37frdYnKnucVtrclKgPAGRGAAYTC+MSEUCfSc729V69fl6gM AM/kR18/AAe9i8bm5+aEPgj6vwPFQkGmNgCcCQEYQCiMjY8LzaL0XHeKSUgAFKpZ lmkYQe+isbnp6V6ZP3gdx9kpFiUqA8AZEYABhMLo2FgsFpOo7H8Ou3HnjkRlAHim qATg2elpoW8ebdve3dmRqAwAZ0QABhAKuXw+kUhIVCYAA1DMT79+Bg56F43JBeBa rba/tydRGQDOiAAMIBRGRkb6BwYkKnueN3XrlkRlAHgmU9f9BBj0Lhqbn50V6j5o mebBwYFEZQA4IwIwgFAYGh4eHByUqEwABqCYoWl1me7K7SUXgA3DKB0eSlQGgDMi AAMIhUw2m0qlhIp/MDUl1OgFAJ6mV6u2bQe9iwZc111cWBAqrmlaJQp9sAF0IQIw gFBI+zIZoeKvvP56fnRUqDgA/IBWqTiOE/QuGiiVSpvr60LFq5VKtVoVKg4AZ0EA BhAWE5OTQpfxxiYmXn7lFYnKAPA0P/65oQ/AG+vr5VJJorLneYXtbYnKAHB2BGAA YSEXgFPp9NuXLklUBoCnVctl13WD3kUD3y4vC7WqJgADCDMCMICwGJ+Y6O3tlajc F4tduXZNojIA/IAffatRePz13vy8n1QlKvu/A8VCQaIyAJwdARhAWIyNjwtNpPRd u3lTqDIAPKlmWaZhBL2LxuZnZs7JfOfoOM5OsShRGQDOjgAMICxGx8ZisZhEZdd1 r9++LVEZAH4gKgF4dnpa6DtH27Z3d3YkKgPA2RGAAYRFfnQ0Ho9LVHYc58adOxKV AeAHLNP0fwW9i8bkAnC9Xt/b3ZWoDABnRwAGEBYjuVx/f79EZQIwAGVMwxBqLtVe cgHYsqyD/X2JygBwdgRgAGExPDIyMDAgUZkr0ACUMXS9XqsFvYvG5mZmhPoOmqZ5 eHAgURkAzo4ADCAshoaGBpNJicqe503duiVRGQB+QNc0u14PeheNzc/OCk2eM3S9 JDNhGADOjgAMICwy2WwqlZKoTAAGoIxerdq2HfQuGpMLwJqmVaIwCApAdyIAAwiL tC+TESr+znvvJWXSNQA8SatUHMcJehcNmIbxYGVFqHi1UqlWq0LFAeCMCMAAQmTy /Hmhyj+6ePHFCxeEigPAMT/+uaEPwMVicU9sUtH21pZQZQA4OwIwgBCZmJwUupI3 ks+/9sYbEpUB4EnVctl13aB30cDqo0eazCGt53mF7W2JygDQFgRgACEiF4AHk8l3 339fojIAHPOjbzUKj78uLy0JtaomAAMIOQIwgBAZn5gQGsvRF4tduXZNojIAHKtZ lmkYQe+isXvz835Slajsum6xUJCoDABtQQAGECJj4+N9fX1Cxa/dvClUGQAei0oA lhsC7DjOTrEoURkA2oIADCBERsfGYrGYRGXPdadu35aoDADHIhOAp6d7Zb5ttG17 V6y9FgCcHQEYQIjkR0fj8bhEZddxrt+5I1EZAI5Zpun/CnoXjc1+802fzLeN9Xp9 b3dXojIAtAUBGECI5HK5RH+/RGXXda9zAgxAmGkYNcsKeheNzU5PCz1v4v/P39/f l6gMAG1BAAYQIiMjI/0DAxKVCcAAFDB1vSbTXbm95J4Btkzz4OBAojIAtAUBGECI DA0PDw4OSlQmAANQwNC0er0e9C4akwvAhmGUDg8lKgNAWxCAAYRIdmgomUxKVPY8 b+rWLYnKAHBM1zQ7CgF4fnZWaOi6ruvlUkmiMgC0BQEYQIhkstlUKiVRmQAMQAGt WnVsO+hdNCYXgDVNq5TLEpUBoC0IwABCJO3LZISKX5makhsyDAA+rVJxHCfoXTTg 7/D+vXtCxauVSrVaFSoOAGdHAAYQIslkMjs0JFT81TfeyOXzQsUBoOe7+OeGPgCX S6WN9XW54rquCxUHgLMjAAMIl4nJSaGLeedffPHiSy9JVAaAx6rlsuu6Qe+ige3t 7YO9PYnKnucVtrclKgNAuxCAAYSLXAAezuVef/NNicoA8FilXPZCH4AfPXyoa5pE ZQIwgPAjAAMIl/GJCaHhHMlU6p333pOoDAA9341bq0ah/9Py0lJdZlix/ztQLBQk KgNAuxCAAYSLXACOx+OXr16VqAwAvpplmYYR9C4aW1xYELqnTQAGEH4EYADhMjY+ LtSr+Vxv79Xr1yUqA0BPdALw/Nyc0Oc/x3F2ikWZ2gDQHgRgAOEyOjYWi8UkKns9 PVM3b0pUBoCe6ATguZkZoYs2tm3v7uxIVAaAdiEAAwiX/OhoPB6XqOy67vXbtyUq A4DPMk3/V9C7aGx2elrook29Xt/b3ZWoDADtQgAGEC65fD6RSEhUJgADEGUaRs2y gt5FY3IBuFar7csMWAKAdiEAAwiXkVyuv79fojIBGIAoQ9eFuiu3l1wAtizrYH9f ojIAtAsBGEC4jIyM9A8MSFR2HOfGnTsSlQGghwD83SXwg4MDicoA0C4EYADhMjw8 PDA4KFGZE2AAogxNq9frQe+iMbkmWKZhHB4eSlQGgHYhAAMIl6GhocFkUqKy53lT t25JVAYAn65pdhQC8Pzs7LlzIp8ADV0vlUoSlQGgXQjAAMIlm80mUymJygRgAKL0 atW27aB30ZhcANY1rVwuS1QGgHYhAAMIl0w2myIAA4ggrVp1ujsAa5pWIQADCDcC MIBwSfsyGaHi127eFKoMAFql4jhO0LtobGFuTqhytVKpVqtCxQGgLQjAAMIlmUxm h4aEir/z3ntC96sBwI9/bugDsGkYD1ZWhIqXSyVd14WKA0BbEIABhM7E5KTQ9byX X3llbGJCojIAVMtl13WD3kUDB/v721tbEpU9zytsb0tUBoA2IgADCB25ADz54os/ fuklicoAEIkA7KdfPwNLVCYAA4gEAjCA0JELwCP5/GtvvCFRGQAq5bIX+gC8+uiR JvOYLgEYQCQQgAGEzvjERG9vr0TldDr900uXJCoD6HKu61aj0AB5ZXnZsiyJyv7v QLFQkKgMAG1EAAYQOnIBuL+//70rVyQqA+hyNcsyDSPoXTR2/949oVbVBGAAkUAA BhA6Y+PjfX19EpX7YrEr165JVAbQ5aISgBfm53s8T6Kyn6t3ikWJygDQRgRgAKEj F4DPnTt39cYNicoAulxUAvD87KxQkwUCMIBIIAADCJ3RsbFYLCZR2fO8qVu3JCoD 6HJRCcBzMzNCz5jYtr27syNRGQDaiAAMIHTyo6PxeFyisut51wnAAAREJQDPzsz0 yQTger2+t7srURkA2ogADCB08vl8PJGQqOw4zo07dyQqA+hylmn6v4LeRWMz33wj dMWmXqvt7e1JVAaANiIAAwidXC6X6O+XqEwABiDENIyazHih9pqdnhZqsuD/z9/f 35eoDABtRAAGEDojuVw/ARhApBCALcs6IAADCD0CMIDQGR4ZGRgYkKhMAAYgxND1 eq0W9C4akwvApmkeHhxIVAaANiIAAwid4eHhgcFBicqu616/fVuiMoAuZ+p6LQoB WK4LtGkYh4eHEpUBoI0IwABCZ2h4eJAADCBSonICLBeADcMoEYABhB4BGEDoZIeG ksmkRGXmAAMQYmhavV4PeheNzc/Onjsn8vFP1/VyqSRRGQDaiAAMIHSy2WwylZKo TAAGIETXNLvLA7CmlctlicoA0EYEYAChk8lmUwRgAJFCANY0rUIABhB6BGAAoZPO ZNLptERlAjAAIXq1att20LtoTC4AV32VikRlAGgjAjCA0PHTr5+BhYpfu3lTqDKA bqZVq04UAvDC3JxQZT/9+hFYqDgAtAsBGEDoDAwMDI+MCBV/9/JloRbTALpZJAKw ZVkry8tCxQ8PDkzTFCoOAO1CAAYQRpPnzwtVfuX11/Ojo0LFAXQtrVJxHCfoXTRQ KpU219eFim9vbQlVBoA2IgADCKOJyUmhp9R+dPHiixcuSFQG0M0iEYCLxeLezo5E Zc/zCtvbEpUBoL0IwADCSC4Aj01MvPzKKxKVAXSzaqXihj4Ab6yvC43qJQADiAoC MIAwkgvAw7nc62++KVEZQDeLRAB+9PChrmkSlQnAAKKCAAwgjMYnJnp7eyUqpzOZ n777rkRlAN2sWi67rhv0Lhp48O23Qn2q/P/txUJBojIAtBcBGEAYyQXggcHBS5cv S1QG0M0iEYCX7t+363WJygRgAFFBAAYQRnIBOJFIvP/BBxKVAXSzSATgxYUFoU0S gAFEBQEYQBiNjY/39fVJVO6Lxa5cuyZRGUA3i0QAXpif7/E8icqO4+wUixKVAaC9 CMAAwkguAJ/r7b16/bpEZQDdLBIBeH5uTuiTHwEYQFQQgAGE0ejYWCwWEyp+7eZN ocoAulalXPZCH4DnZmaEni6xbXtXZsIwALQXARhAGI2OjsbicYnKnudN3bolURlA N6uUSp7M7eI2EgzA9fru7q5EZQBoLwIwgDDKj47GhQKw607dvi1RGUA3i0YAnp7u lXm6pF6v7xGAAUQBARhAGOXz+XgiIVHZcd0bBGAA7RaJADw7PS3UXqFeq+3t7UlU BoD2IgADCKNcPp+QCcCu614nAANoK/8Plmq5HPQuGpMLwLVabZ8ADCAKCMAAwmgk l+vv75eo7DjOjTt3JCoD6Fo1yzINI+hdNCYXgC3LOtjfl6gMAO1FAAYQRiMjI/0D AxKVCcAA2o4AbJnmwcGBRGUAaC8CMIAwGh4ZGSAAA4gIArBpmocEYABRQAAGEEbD w8MDg4MSlV3HuU4ABtBWUQnAcl2g/f/5h4eHEpUBoL0IwADCaGh4eFAoANMEC0C7 RSYAi80BNgyjRAAGEAUEYABhNDQ0NJhMSlQmAANoOwKwoeulUkmiMgC0FwEYQBhl h4aSMgHY87ypW7ckKgPoWlEJwPOzs+fOiXz203W9TAAGEAUEYABhlM1mk6mURGUC MIC2IwDrmlaOwiRkACAAAwijTDabIgADiAgCsKZpFQIwgCggAAMIo0wmk0qnJSoT gAG0HQFYq1YrlYpEZQBoLwIwgDBKZzJpAjCAiCAAV6tHCViiMgC0FwEYQBglk8ns 0JBQ8Ws3bwpVBtCdohKAF+bmhCqXSyVd14WKA0AbEYABhNFgMjlEAAYQEQTgUqlk EIABRAEBGEBITZ4/L1T5vStX+vv7hYoD6EKWafq/gt5FA/VabXlpSaj49taWUGUA aC8CMICQmpicFHpW7c2335a7Xw2gC0UiAFer1bVHjyQqe55X2N6WqAwAbUcABhBS cgH4337yk/HJSYnKALpTJALw/t6eUEwlAAOIEAIw0OFSqVRvX1+sr+9c75Fz3zn+ rz/4xyf5H2iO/+afXPfoL//4p57v/50r0ftELgC/eOHCjy5elKgMoDtFIgAXC4W9 3V2JykIBOJlMPn7b+v696ty579/D/vFe9uRb2AnvZcdvZ8f/6L9t+f9nO47rOJqm tX3nAMKMAAx0mkwm4yfex77/6KDEswPzv2bmx//Ncd1meqXIBeDxycl/+8lPJCoD 6E6RCMCbGxulw0OJyk0G4MFksu+JQPvMNNsw0Lbd4zzsfMf/f0wzBjoeARiIvHQ6 fXTGG4spTrxn9M/AfPRV/Pffxz95tpxMpYT+t4zk86+98YZEZQDdyTSMmmUFvYsG Vh890qpVicr+H9q6pv3LOW3vPy4d9fY+/pkIvTc9zsO2bfv/ryrzOwYgQNH4wwjA DzwOvXE/9MZivf/4eBF1jyPx4/TrJ2E/zwt9YMoMDb319tsSlQF0p0gE4AcrK0Kz mo6u9jhO7z+OdnuiE3cbOgrDtl0nDAMdpEP+eAK6RDqTicVi8Xg8Qie9IZRMp9+5 dCnoXQDoHJEIwN8uL4d/k6H1+GS4XvezsF3lmjQQZXyABiIglUr5oTeeSPT19QW9 l07QPzDw3s9+FvQuAHSOSATg+4uLjm0HvYtO4DhOvVbzwzANtIAoIgADoZYdGkp8 l3s5720jz/Mmzp/3Y3B/f/9gMjk4OMhvL4CzCGcA9v+ss77jpzXfwf7/396dOEd1 JYYebnVrV2tHYgcz2Bgbe+yxJzXlSl5VXt64MuX8vXFNyvPypuol5ZpK7PGGjbEZ zA4C7WjvJUfdSDSS0Eafvq2+31dYbgQ+92Kg7/npLmeqZW6ZaQbVC7/D/9i52dmk 9wU4AHM+aEb5fL69vb2zq8tkJYbNB1RnqgtBZbPrTw+rPDe7vXJbdeV0e2c1j7u7 u8OrpHcZaGpJBfDa2lro27Dp1bW1wupqofjMs8cKVh4sWP2ZW56xTB2F/8/ht2D9 0mg3CcNR4H0Qms7Q8HBIL9OURNQ+iCuzuRpH9pnthdwV+rhnXaJ7DSQsUgDXnr8t hMTdWKrnWdrW9m0m03oPoDpaqufbZ6ank94RYA/eIqGJDA4NhZ4yd2latWsd1353 /dmnG2t+rHdye3v1WWXVO7fXM7kSyeFTie06ENNBA7hQKFTP3K4/VKlatuFT1bjd LNvw742J2paydZhoWuE3bnl5OdJ6y0BdeAOFptA/MBDS1zOuWsDLIjlTcwnis7PJ lVSunlWuTeXw0UXXcLQsLy6uVp6KtH6u9sWsLVZWlS1VbhgtbbwtlGtmYOK29YTf +ZDB83NzSe8IsANvspC8kdHRkD8mPalSG8ZbUjn8SQivspnnxbx+arlyo3I1mDfP MCey55BO1fVv1oN2I2s3b7ItV8/Zvvjzt1+N7E0+VcIfivBnZmpyMukdAbbyXgxJ 6h8Y6Onp8aQrdldby9u/CzTMlojVtOyuVCotLS05FQxNxRs3JMYdvwDQ2twVDM3G zBuS4bJnAEgDl0NDUzH5hkbL5/M9vb2edwUA6VEsFpcWF60VDIkTwNBQ+f7+3t5e N/0CQNqUSqXF0MDz80nvCKSaAIbGUb8AkGYaGBIngKFB1C8AoIEhWQIYGkH9AgBV GhgSJIAhunw+39vXp34BgKr1Bl5Y8EwsaDwBDHH1Dwz09PSoXwCgVmjgpaWl+bm5 pHcE0kUAQ1zHT5yw2C8AsF25XH708GHSewHpYl4OER0bG2tvb096LwCAJlUoFJ48 fpz0XkCKCGCIZXBwsLunx+lfAOBlyuXy8tLS7Oxs0jsCaWFqDlHk8/m+fF79AgC7 Cw28/jgsD8SChjA7hyhc/AwA7JMLoaFhBDDU3+DQUHd3t9O/AMB+rF8Ivbw8OzOT 9I5A6zNBhzpz8TMAcFAuhIbGMEeHOjsqFz+HA+32T+p2AI66o3uAcyE0NMAReC+A I2RgYKCnt7fZjrLlivAim82259aFiUB7R0dfX1/4/OrKSqFYLBYKxVKpVCyWws8M Lyo/f/scYssvrdl+pQC0ni0Ho5cdm7LhYzjOtbVlw3Eum821t4dDXmdXV/jRhYWF wtpa+C/XD3fF9cNd9b9qtqNY+KUtLS7Ozc0lvSPQyprrrz0cdePHj4eDb9J78Uy1 e8eOH//dRx9V+zZMC0Kf9/T07P4frq2thSoOFhcXV5afCZ9ZDdbWCuFDoVCqzCHK pXVhJlKuTCYEMwB72mfQtoWYrXzptq3y1duQtR2haTs7Ozs6wodQtt0V4V+9vb1d XV3hMx0dHbtveilYXCyVy9VC/svnnz9+9KipSjgcVScePUp6L6CVNcvfdmgBQ8PD XZWvNCe4D2EaEY6dYTcuXLx45d13w8ygARutDeblpaXwohrMQUjlajCHAg9K1f2r 1PIWUhngSNszazMbNZtta1s/O9veXg3a8LGar+s1Gz729Ow/aOsiHLOufvvtzRs3 wmGrsncJH8fDbsxMTye4D9DaTDGhbo6fOJHUUbP2ZO/AwEAi+7B/IZhDIi8urAvN vBS+LS+vVJp5PZjX1sK3YqmUy+U6OjvDJzevVcsIY4CklWvukQm5GDJ1bXW1WCzm stn2jo7wLQRt53rIdveEb73r+vr6wj/hM40J2lcxNzeX+Gnh8P/20cOHiWwa0sBU Eupj9NixRI7rIQ7z/f3/6x//cXh4uPFbb7wnjx/fvnVr8smThadPV1ZWQidnKpOw zWmKQgZ4FZtnbp+9aGsLZRt6ti+fD0e6c+fPHxsbS3L/GmV6evr///nPT+fnE7mz aW1tLRzpGr9dSAMzRaiDvr6+UKENTq9SsXjuwoXfffRR839BvTGWFhf/duNGKOS5 ubnlpaVCoVB+sY2rFDKQZjteqNxWuSa5u6dnYGAg9O2vLl7s6e1NaAebSwjRv3z+ +e2bN7O5XCO3G35fQnsvLCw0cqOQEiaCUAdj4+O5Bh4aw3ExzFH+6eOPTVD2b+Lh w7t3705PTT2tnjp+SR5XiWTgKNrxttvN97pc5VbbfD4/PDJy5syZ8RMnGr6DR9XS 4uK/f/bZ3NxcI48OxWLx8cREwzYH6WGSB6+qf2Cgt4FLH5VKpfc//PDtK1cas7mU mJ6evn/37pMnT57OzS0vLxfW1koba0e97HdWJAONtGPcZmr6NltZ3667uzs/MHDs 2LFTZ86k5NaYhvn+6tWvvviiYVdEh9/ZxcXFeUsiQb2ZwMGrauTSR+Fw+H8+/tiX 7RtvcnLy4f37U5OTT+fnl5eW1p9rXSxuzkd3iWGdDOzuZWVb+0Pr528riwB19/Tk +/tHRkdPnDo1OjraqH3kmYmHD//vZ5818kvelkSCujMzg1cyODTU3d3dmGOh+m1y YWI0MTExPT1dfUDX6upqsVBYXyd54/zM7n9OpDK0kl2yNrPx6P5M9cxtZUHayrq2 6w+aGh4eHg+81TerRjZw+EOyvLw8OzPTgG1BephvwStp2Onf0FG/++iji2+80YBt EVWYPE1NTc3NzYVOri6bXKicT95M5So9DEfLlr+/61mbC2HbXl3YNpTtwMDAyMiI sm0BN3766S+ff96wo7+TwFBfJlhweI08/Xvp8uUPfvvbBmyIpjI5OTlTqeXFxcVQ y+tXX6+tFSq1XCoWk967etj1LNm+BqjLbsRR57cGXxNJVMjZEDztuVxHR0cI2vCt t7c3NO3QyIhLkVPoy//+7+vXrjVgQ04CQ905msLhNez0b5hn/fMnn4TYbsC2AIDd hSj9t08/XVpcbMC2nASG+hLAcEgDg4M9PT0NOP0bjnwf/f3fX7h4MfaGAIB9unnj xuf/+Z8N+Dp4uVxeWlqam52NvSFICQEMh3RsbKy9vb0BGzr/2msf/cM/NGBDAMD+ ff4f/3Hrl18asKFCofDk8eMGbAjSQADDYeTz+b58vgGnf7PZ7D9/8sng0FDsDQEA BzI7M/Nvn35aKpVib6hcLi88XRd7Q5AGAhgOY3h4uLOrK3YAhwPeB3/3d29evhx1 KwDA4fx47dqX//VfDZgPrK6sTE9PR90KpIQAhsM4fuJEA07/jo2P/+/f/74xz9kC AA6qVCr9vz/96fHEROwNhQZ+9PBh7K1AGghgOLCR0dHOzs7YWwnH1H/6+OMTJ0/G 3hAAcGgPHzz4988+a8BXq1dXV6cmJ2NvBVqeAIYDa8zqR29dufLeb34TeysAwCv6 +q9//eHq1dhbsR4S1IUAhgNrwPXPHZ2df/iXf+nr64u6FQDg1S0sLPzxX/91bXU1 6lZcBQ11IYDhwGIHcDjCvffBB29fuRJvEwBAHX1/9erXX34Ze3oggOHVCWA4mNFj xzo6OqJuor2j4w+ffJLv74+6FQCgXp7Oz//x008La2tRt7K2tjb55EnUTUDLE8Bw MA24AfidX/86fIu6CQCgvr775pvwLeom3AYMr04Aw8FEv/65VPr9H/4wNj4ebxMA QN09npj40x//2Bbzq+SugoZXJ4DhYGIH8MDg4G9++9tcRTabzb3ImsAA0LT+/Kc/ PYwZqAIYXp0AhgMYGRnp7OqKN344sL32q1+dOHXqZT8htPeOYVwbzLGfUA0AZCoX JG9x88aN7775JuqBeHVlZWpqKt740PJMlOEAxsbHQ2HGGz8cO999//1XfPzVljx2 GhkA9lSu2N60WxSLxeqL6s/fMsjT+flvv/oq6nE27MDjiYl440PLE8BwALGvfx4a Hn7z7bfjjV/lNDIALW8/NbtFXbb74/ffz0xP12WoHbkKGl6ROS4cQNQA3vP650ba 5TRy9XX4KJIBaJiD1uz207ON8fD+/V/+9reoswUBDK/C/BX2K5/P9+Xz8Q5pxVLp 3ffe6x8YiDR+3dWG8fZCFskA7Gjz3OzuJ2m3/GjSe71f83Nz3379dS7aVdDhf8vC 03WRxoeWZ24K+zU6OtrR2Rlv/FDXV3796xYrxh3DuPY0ssutAY60HSN2z7JNeq8j Cr+6q998sxAzUNdWVycnJ+OND63NvBP2a/z48XiPtQjHy7Pnz58+ezbS+M2sek/y liqu/ehkMkBj7Nmu2xO3tWv2cO7duXPn1q14h63wv33i0aNIg0PLM6GE/Yp6A3Cx WHzrnXeGR0Yijd8CshU6GWBPWx5ovKVpd/lu0jveIqanpn747rt4y0a4DRhehZki 7FfUAG7LZt/74IOumIsMp8TmM64327j2hUuvgSOktmOrL/aZtc7KJmtlZeXrL78s R/uCggCGV2H+B/sVNYCPjY1dvHQp0uDsKPxu7hjJO2Zz0jsLHGFbLhh+2Yvtn9Sx R9eN69efPH4caXABDK9CAMO+jIyOdkZ7AlY4kp27cOHU6dORxufVZfetem7Z6WVo GZunYV/2cffvith0un/v3u2bN+MdC1ZXV6c8BwsOxRQN9iXqE7DcANx69uzk6vnn 2teaGequtl23ROl+vrv5OulfB0dP7NuAPQcLDs18C/Yl6vXP2coNwJ1uAE636nnj XQp5y+vaF0nvO9RNucZmf27/7o6vtxds0r8a0mu1chtwvD+EroKGQzNtgn1xAzBN q21DNYYP+mLL66R/NRwB5W0yG4vB7vij+2xayUqLcRswNCdzHdiXqAF86syZs+fP Rxoc9m/HJK5t4+2fPNyPJvzrbAm15Zmpyc79vK797ss+v4vkftFwlNy5dev+3buR BhfAcGhmIbC3oeHh7u7uSIOXSqVfvf768ZMnI40PzWmziuvyccuwO27rcJ/c0nvb 82/3n7Djd/fzcT8/AWhmjx48+NvPP8d7gMjy8vLM9HSkwaGFCWDY27Gxsfb29kiD l4rFd95/v39gINL4AEDjzc/NfffVV9loz8EqFArxLrGGFiaAYW9RHwHd29d35d13 4x0gAYDGKxWLV7/9dnFhIdb4HgQNhyKAYW9RbwA+efr0uddeizQ4AJCU27/88uDe vUiDuw0YDkcAw97iPgHr7Nmz585FGhwASMqd27fv37kTaXABDIcjgGEP/f39vX19 kQK4VCq98eabx8bHYwwOACToycTETz/+GOkuqhDAiwsL8/PzMQaHFiaAYQ+jo6Md nZ2RBs+2tb334YedXV2RxgcAkrK6svL1F1+Uoj25fW11dXJyMtLg0KoEMOxhbHw8 F+0JVcOjo5cuX440OACQrOvXrk1Ha9Risfh4YiLS4NCqBDDswQ3AAMDhuA0Ymo0A hj3EC+Bw3Dp34cKp06djDA4AJO7+vXu3b96MN5EQwHBQAhh2k8/n+/L5eE/Aev3S pbHjx2MMDgAk7vGjRz9fvx7vOVgLT9fFGBxalQCG3QwMDvb09EQK4HA4/PVvftPV 3R1jcAAgcSvLy9/89a+lUinG4CGAl5aW5mZnYwwOrUoAw26OjY21t7dHGnxwePjy 229HGhwAaAbXvv9+dno60uCFQuHJ48eRBoeWJIBhN+PHj0e6bCk4debM2fPnIw0O ADSDO7du3b97N9LgpVJp4tGjSINDSxLAsJuoj4A+c+7c6bNnIw0OADSDe3fu3L19 O9LgnoMFByWAYTfxzgCHI9ZrFy+eOHkyxuAAQJN4+ODBLzduxHugpjPAcCACGHYT 7wxwsVi8fOXKyOhojMEBgCYxNTl57erVXC4XY3BngOGgBDDsJl4A9+bzV955Jxvn cAgANIlSsXj1u+8W4yxWJIDhoAQw7CZeAHsCFgCkRLznYAlgOCgBDC81NDzcHW2R 3lNnz549dy7S4ABA87hz+/b9O3ciDb68vDwTbZklaD0CGF5qZHS0s7Mzxsjlcvn8 hQsnT5+OMTgA0FQe3Lt36+bNSNeUra6uTk1OxhgZWpIAhpc6NjbW3t4eY+RSqfTG 5cth/BiDAwBN5cnjxz9duxZpXYlCoRDGjzEytCQBDC8Vbw2kYrH4znvvDQwOxhgc AGgqc7Oz3339daQHQVsJCQ5EAMNLxXsCVqlcfu+DD3p7e2MMDgA0lcXFxa+//DIb Z1LhOVhwIAIYXiriI6A9AQsA0iTec7AEMByIAIaXEsAAQF0IYGgSAhh2NjQ01N3T E2nws+fPnzpzJtLgAECzuX/37p1btyINvry0NDMzE2lwaDECGHYWdQ2kCxcvHj95 MsbgAEATevTgwc0bN6yEBIkTwLCzqGsgXXrrrdFjx2IMDgA0ocknT67/8IOVkCBx Ahh2Nj4+no2zXEGxWHz3/ff7BwZiDA4ANKH5ublvv/oq1kpIxeLExESMkaH1CGDY mTWQAIB6sRISNAkBDDuLF8Cnz5494xHQAJAyd2/fvudB0JA0AQw7E8AAQB0JYGgG Ahh2MDg42N3TEymAQ/2GBo4xMgDQtEL9hgaOMXII4OWlpdnZ2RiDQ4sRwLCD4eHh ru7uGCOHQ9RrFy+esAYSAKTMwwcPfom2EtLK8vL09HSMkaHFCGDYwejoaEecRYBL pdIbb755bHw8xuAAQNN6MjHx048/RloJaW11ddJSwLAPAhh2EG8R4GKx+Pa77w4N D8cYHABoWjPT099/+22klZAsBQz7JIBhB+PHj0f6Am2xVHrvgw/6+vpiDA4ANK2F hYWvv/wyF2eCUSqVJh49ijEytBgBDDuI9wjoTFvb+x9+2NXVFWVwAKBZraysfPXF F5lyOcbgHgQN+ySAYQfWQAIA6s5KSJA4AQw7EMAAQN0JYEicAIatBgcHe3p7Iw1+ 9vz5U2fORBocAGhm9+/evXPrVqTBlxYXLQUMexLAsNXQ8HB3tEWAz1+4cPL06RiD AwBN7sG9e7du3ox0ldny8vKMpYBhLwIYthoZHe2MswjwpnLlARilUil8zOVyXd3d b771VrzTzgBAIy0tLv74ww8ry8vFYjF8t7q0RKzna25YXV2dshQw7EUAw1Zj4+OR 1ujbU3lDtq0t195++Z13+vv7E9kTAGA/5ufnr333XbFQKJXLbRsS2ZMQ248nJhLZ NBwhAhi2ircI8KE9D+Nstr29/c233+4fGEh6pwAgRebn5n78/vtCCN1SKdnQfRlL AcN+NNffW2gGERcBrrctZ4wvvfXW4NBQ0jsFAEfY7MzM9R9+aIYzugflQdCwH0fj 7zM00hEK4JfZDOPwOpfNtnd2vn7pkjYGgKpQuT9fv15YXS1WnsdxtEL3ZQQw7MfR /nsOMbRAAO+ito2zuVx7e/vFN94YHhlJer8AoM6mp6Zu/PTT+kXLlSdRtUbl7kIA w3607FsAHFprB/AuqlVczeO2bDaXzXZ0dLx28aI8BqA5hcT95caNtbW1YqlU3rg1 NxP/ecvNSQDDfqTx3QF2EW8R4KPuhTxua6vedXz+woWx48eT3jUAWtbjR49u3bxZ vSO3vHFTbiatibsnSwHDnrx3wAtGR0c7Ii8C3KqeXVldCeX16UnlHPLZ8+dPnDqV 9K4B0KQe3r9/59at6vnb9b7NPL9SOeldO5LWVlcnLQUMu/LmAi9IcBHglld7DjlT E8mnz549deZM0nsHQJ3dv3v33p07m3Gb2WjbjPO30VgKGPbk3Qde0ISLAKfNDp3c 1hY6OdfRcfLUqZOnTye9gwCp9uDevQf37xert92++F6dUbZJsxQw7MmbFLwgtU/A OnKqU65MTSoH2fB7F1I5l2vP5Y6fPOnEMsB+3L9799GDB4XiuvWE2nhTrb0U2cHx SPAcLNiT9zJ4gQBuVZsnljM18ZytXIa9Lpc7Nj5+/rXXEtxDgHq59csvTyYmSsVi qXL5cW3QbvlIixHAsCfvffACAcym2pPMmx83J47VG5hDOQ+PjFy4eDHB/QRa1c0b N6anpkLH1t5Gu+W9qPozHbmoEsCwJ2+X8AIBTF3sGM+Z6ntu9ZLCyo3N1ZPPg0ND v3r99aR2FYjkbz//PDszUz0NG/7J1Dwqv0rEUncCGPbkrRZeIIBpHjXz5G0h3dZW rryDP1stJPtMPp+/9NZbyewutITrP/zw9OnTUkV54yFP1b9u5Z0uJK79DCROAMOe vF/Dc4NDQz09PUnvBQDAIS0tLc3OzCS9F9C8BDA8Nzwy0tXVlfReAAAc0srKyvTU VNJ7Ac1LAMNzo8eOdXR0JL0XAACHtLa2NvnkSdJ7Ac1LAMNzY+PjuVwu6b0AADik YrH4eGIi6b2A5iWA4TlPwAIAjjTPwYLdmevDcwIYADjSBDDszlwfnhPAAMCRJoBh d+b68Iw1kACAFmAlJNiFAIZnrIEEALQAKyHBLgQwPDc8PJzN5bIVroUGAI6Kcrlc qioWp6enk94daF6m+LCbwcHBzSRWxQBA4p63biV3Z2dnk94jOErM5uHAVDEA0ABa F+rOxB3qY0sVh88IYwBgP0Loho9aFxrABB3iGhoezlXCuG1D0nsEACSmvKHSucUZ 9+tCY5mLQwIGh4ZyNU/bUsUA0Ho2Q7faupYmgmZg2g3NYmBwcL2JnS4GgCOl9qTu eumWSnMuYIZmZXoNza727mJhDABJeSF03akLR5NpNBxVz8I41LBLqQGgfjYrt/JP WehCKzFdhhY0ODRUu0qTNgaALbaezi2V3KMLaWBODOmyvY0zVmwCoBVV1xZSuUAt s17gmYHBwc0wlscANL8tibsZup5BBbyMeS2wL9U83mzj8E/GxdUARFaN2/Cv0ouV K3GBwzFzBepjYGAgm8vVnj12DhmAXdSev33hLG6xODc3l/TeAa3JrBRonOeRXAll kQzQqrbGbTVtxS2QNDNOoOlsdvLzVM5kMlIZIGmbWVt9tZm1yhY4KswjgSOsf2Ag F1I5vJfVXnedUcsA+7W1aWvO2YbvFovFeVkLtBBTQyBFngVzTSq3bTzNK1NTy7IZ OIqqKZvZ0rQvZq2gBVLOJA9gD5vnmTNtL8hspLJyBupoh4598UlR1U9JWYBDMFcD iKgaz5nNds5svTx7+6XaKhqOrs12zWzL18y2y4wzIhag4UyzAI6A/v7+XHt7pvqu vf0EdPXfldcZCQ2H9SxfNyp2s1c3q3Xzh4qFwvz8fGI7CsBhmSQBAACQCgIYAACA VBDAAAAApIIABgAAIBUEMAAAAKkggAEAAEgFAQwAAEAqCGAAAABSQQADAACQCgIY AACAVBDAAAAApIIABgAAIBUEMAAAAKkggAEAAEgFAQwAAEAqCGAAAABSQQADAACQ CgIYAACAVBDAAAAApIIABgAAIBUEMAAAAKkggAEAAEgFAQwAAEAqCGAAAABSQQAD AACQCgIYAACAVBDAAAAApIIABgAAIBUEMAAAAKkggAEAAEgFAQwAAEAqCGAAAABS QQADAACQCgIYAACAVBDAAAAApIIABgAAIBUEMAAAAKkggAEAAEgFAQwAAEAqCGAA AABSQQADAACQCgIYAACAVBDAAAAApIIABgAAIBUEMAAAAKkggAEAAEgFAQwAAEAq CGAAAABSQQADAACQCgIYAACAVBDAAAAApIIABgAAIBUEMAAAAKkggAEAAEgFAQwA AEAqCGAAAABSQQADAACQCgIYAACAVBDAAAAApIIABgAAIBUEMAAAAKkggAEAAEgF AQwAAEAqCGAAAABSQQADAACQCgIYAACAVBDAAAAApIIABgAAIBUEMAAAAKkggAEA AEgFAQwAAEAqCGAAAABSQQADAACQCgIYAACAVBDAAAAApIIABgAAIBUEMAAAAKkg gAEAAEgFAQwAAEAqCGAAAABSQQADAACQCgIYAACAVBDAAAAApIIABgAAIBUEMAAA AKkggAEAAEgFAQwAAEAqCGAAAABSQQADAACQCgIYAACAVBDAAAAApIIABgAAIBUE MAAAAKkggAEAAEgFAQwAAEAqCGAAAABSQQADAACQCgIYAACAVBDAAAAApIIABgAA IBUEMAAAAKkggAEAAEgFAQwAAEAqCGAAAABSQQADAACQCgIYAACAVBDAAAAApIIA BgAAIBUEMAAAAKkggAEAAEgFAQwAAEAqCGAAAABSQQADAACQCgIYAACAVBDAAAAA pIIABgAAIBUEMAAAAKkggAEAAEgFAQwAAEAqCGAAAABSQQADAACQCgIYAACAVBDA AAAApIIABgAAIBUEMAAAAKkggAEAAEgFAQwAAEAqCGAAAABSQQADAACQCv8DRMCa nmMbZ5EAAAAASUVORK5CYII="/></symbol><use xlink:href="#c" width="1280" height="1280"/></g></g></svg>')} +.is2d .king.black {background-image:url('data:image/svg+xml;base64,<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="614.635" height="614.635" viewBox="0 0 460.977 460.977"><mask id="b"><use xlink:href="#a" width="1280" height="1280" transform="rotate(.193) scale(.36014)"/></mask><symbol id="a" viewBox="0 0 1280 1280"><image width="1280" height="1280" xlink:href="data:image/png;base64, iVBORw0KGgoAAAANSUhEUgAABQAAAAUACAAAAAA9j6ArAAAACXBIWXMAAA7EAAAO xAGVKw4bAABWPElEQVR4nO3dB3gUdeLG8fxjCCEiAlIVRETBimLFXrFXTuzlbGev p2dXVGynZ+9dsZezgqfYUFSsgF0EAQHpvYUkJH+KYDbZ3ezMzsz7K9/Pc89zd0pm v0LymuzOzvxfAQB46v/UAQCgwgAC8BYDCMBbDCAAbzGAALzFAALwFgMIwFsMIABv MYAAvMUAAvAWAwjAWwwgAG8xgAC8xQAC8BYDCMBbDCAAbzGAALzFAALwFgMIwFsM IABvMYAAvMUAAvAWAwjAWwwgAG8xgAC8xQAC8BYDCMBbDCAAbzGAALzFAALwFgMI wFsMIABvMYAAvMUAAvAWAwjAWwwgAG8xgAC8xQAC8BYDCMBbDCAAbzGAALzFAALw FgMIwFsMIABvMYAAvMUAAvAWAwjAWwwgAG8xgAC8xQAC8BYDCMBbDCAAbzGASFhp 61G1/1JhhwllihR4jwFEUtbdoVuXDp0z/u2fRv/8zcdjEuwBGEDErnCjHTZfv127 HH/16LE/fvXR8FiDgOUYQMSnxW7bde24ZqgPHTlyyMcD50bcA9TCACIOTXvs0q1j 67wPM+7Xr979iKcHERsGEBFr1atH146RHvHHr/u9MT/SIwLLMICI0NZ/32HDmA49 +O2+I2M6NPzFACIibc/Zf4OYH+KTZx7nO0FEiQFEFNa98uhkHui3p26bmcwjwQcM IPJWfNk/2iT4cN/e+GyCjwanMYDIU4t7eyX+mFf0Sfwh4SQGEHlp/sR+kse95irJ w8IxDCDycf0lqkee8o9XVQ8NdzCACK/ze7m+wS0O/Q+sFD46nMAAIrSz7tQ+/sSD B2sDYD0GEGE9dZS6oODUB9QFsBsDiJDe30VdsFjvq9UFsBoDiHAG7K4uWOqy69UF sBkDiFAePV5d8Kdj+6oLYDEGEGGcep+6YLlpu36rToC9GECE0PHXldQJK/wY1/Vn 4AEGECGMCXeZ51hUPX2sOgHWYgAR3KXXqQtqmrnvp+oE2IoBRGAlMxuqE1J8tq26 ALZiABHYIyeoC1LNO5nrYyEcBhCBzW+kLqjlQxPOyYaNGEAEpX4LcF2cCoOQGEAE NVZ5CZi0qvr+XZ0AOzGACKjtH+qCukasqy6AnRhABHTreeqCumYd2V+dACsxgAho 1FrqgroWPXKKOgFWYgARTGFFoTohjW82VxfASgwggjnoFXVBOhO6TVInwEYMIIJ5 7jB1QTrzznpMnQAbMYAIZuTa6oJ0Fj10mjoBNmIAEcyCEnVBWu/vpi6AjRhABNJ8 mrogveFd1AWwEQOIQI54Rl2Q3sStxqoTYCEGEIHcdaa6IL1Zx7yhToCFGEAE8tEO 6oL0Fl51kzoBFmIAEYiJ7wNZYtHDp6oTYCEGEIHMXkVdkF71mweoE2AhBhCBLDLx jXBLDN5GXQALMYAIonSeuiCTn9dXF8BCDCCC2PwrdUEmozuqC2AhBhBBHPOkuiCT id3HqBNgHwYQQVx9pbogk+kHDlInwD4MIIJ48hh1QSZzTuHemAiMAUQQ7+2qLsik 7NLb1AmwDwOIIIZuoi7IpOKWS9UJsA8DiCDGrKkuyIS3giAEBhBBTGuuLsik+oXD 1QmwDwOIIKrVAZn9uKG6APZhABEEAwinMIAIYNB26oLMuCAWgmMAEcD41dUFmVU9 dpI6AdZhABHA/Ebqgiz67acugHUYQARg7MWwlvhsW3UBrMMAIgCDXwMpKBjaTV0A 6zCACMDoAfzW2HepwFgMIAIwegC/66ougHUYQOTO3EshLLHg0tvVCbANA4jcmftO 4CUWPXSaOgG2YQCRu7krqwuyev1AdQFswwAid5UrqQuy+nhHdQFswwAid0a/BlJQ 8PUW6gLYhgFE7gwfwGGbqgtgGwYQuWMA4RgGEDl7w/A328477yF1AizDACJnIzqp C7KrvPs8dQIswwAiZ7OaqAuyq365lzoBlmEAkbOKInVBPT4w+p0qMBADiJxVmf7Z 8sXW6gJYxvRPaRjE8BeBCwqGbKYugGUYQOTM+AHkioAIiAFEzowfQE4EREAMIHL1 4/rqgvpU/OcSdQLswgAiV9ObqQvqU/3M0eoE2IUBRK7KG6gL6jVgD3UB7MIAIlfG nwVTUDB4G3UB7GL+5zRMYfxrIAUF32yuLoBdGEDkigGEcxhA5MqCAeRMaATDACJH Qy247W75Db3VCbAKA4gcTWmhLqhf1RMnqBNgFQYQOSprqC7IQT/Dr9kKwzCAyJEF Z8EUFAzaQV0Aq9jwSQ0jWPAaSEHBl1upC2AVBhA5smIAuTMmAmEAkSMGEO5hAJGb z6344bKs903qBNiEAURuJrZWF+Si6uFT1AmwCQOI3CwoURfk5LWD1AWwCQOI3Cwq VBfk5MNd1AWwCQOI3FjxGggXxEIwDCByY8kAciIggmAAkRtLBvCrLdUFsAkDiJx8 uJO6IEfD9/tVnQB7MIDIydh26oIczd55iDoB9mAAkZO5K6sLclS5yyB1AuzBACIn ljwFuNh+/dQFsAcDiJzYM4AHvKEugD0YQOSEAYSLGEDkYuvB6oKcXXRLlToB1mAA kYs/2qoLcjZ31y/VCbAGA4hcVBSpC3JWvecAdQKswQAiF/Y8BcjLwAiAAUQubBpA XgVBzhhA5MKmATzoNXUBrMEAIgd7vK0uCKDP1ZXqBNiCAUQOXu6pLgjgm55j1Amw BQOIHIxZU10QwKzdvlYnwBYMIHJQ1lBdEEDVHu+pE2ALBhA5qLLq84TzYJArqz6x oWLTi8AFBQe/qi6ALRhA1O+w59QFgdxxcZk6AZZgAFG/fvuoCwL5/qCR6gRYggFE /Sy6FMISc3f/XJ0ASzCAqN/CYnVBINU9eBkYuWEAUT+7XgTmZWDkzLLPbCgUVagL Avrbf9UFsAQDiHqd9JC6IKAH/zlXnQA7MICo13u7qgsC4uboyBEDiHpNaqUuCGj+ bvbcwgRSDCDqVd5AXRBQ9V7vqBNgBwYQ9bLrjXBLcE1U5IYBRH1KFqgLAjv8eXUB 7MAAoj7n3aouCOzpM2eqE2AFBhD1+XQbdUFgo/f9UZ0AKzCAqM/U1dQFgZX1GKRO gBUYQNTHopuir7Bvf3UBrMAAoj72vQjMNVGRIwYQ9Wg6Q10Qwt+fUBfACgwg6tH7 KnVBCK+ePFWdABswgKjH15upC0IYv9f36gTYgAFEPWauqi4IobzHR+oE2IABRD0q V1IXhMHLwMgFA4h62PgiMNdERW4YQGTXYbS6IJQz7lUXwAYMILK7/Rx1QSjvHjtB nQALMIDI7vsN1QWhTNprqDoBFmAAkd2cxuqCUCr3+ECdAAswgMhuUaG6IJwD3lAX wAIMILKz80XggoJeL6kLYAEGEFltOkRdENLFN6kLYAEGEFk9ery6IKRPDx+rToD5 GEBkNaKTuiCk6Xt8rU6A+RhAZDW/kbogpEV7D1AnwHwMILKqsvYzhFtjon7Wfnoj Gba+CMzLwMgFA4hseryjLgjtxisq1QkwHgOIbF7uqS4IbWjPUeoEGI8BRDZj26kL Qpuzx2B1AozHACKbsobqgtCq9/mfOgHGYwCRjb0vAnNNVOTA4s9vxK+oQl2QhyOf VRfAeAwgsjjrTnVBHp46a6Y6AaZjAJHFoO3UBXkYvT+3xkQ9GEBkMa25uiAPC/cc qE6A6RhAZFFRpC7IB9dERX0YQGRh7xvhljj0RXUBTMcAIrM1xqkL8nLmPeoCmI4B RGaW3hJzufeP5taYyI4BRGY/bKAuyMuUvbkmKrJjAJHZ3JXVBXnhmqioDwOIzGx+ I9wSvBkO9bD8MxyxsvtF4IKCw59XF8BwDCAy2v91dUGebr+oXJ0AszGAyKj/3uqC PP100HB1AszGACKjia3VBXlasNdH6gSYjQFERuUN1AV5qj6QN8MhKwYQGdn+Ggiv gqA+DCAyaT1RXZC3M+5VF8BsDCAyWVSoLsgfZwIiKwYQGVh9Ofzlju2rLoDRGEBk cO3l6oII9D9+sjoBJmMAkcFvHdUFEZi1FzcHRhYMIDKw+2rQyx38qroAJmMAkYH9 J8EscdQz6gKYjAFEeufdqi6IxAunTVcnwGAMINIbvq66IBLT9+VJQGTGACI9698H t0x1T54ERGYMINJz4ynAgoJjnlIXwGAMIGr6sEPzRkXufVJUL1o4a8opn6szYBz3 PtcRwperr9pwJR8+F6qryufOPHmgOgOm8OGTHhm816F5aQMH3vAbSnVl2awp5zGF nmMA/TO0zSrFXny7l6Oqinmzz31NXQEJvg58ce067do0a1zMH3hGlfNnThk//sGh 6g4kiK8Hx/Xu0qFt81In3tWWmKqFsyaNHfPIEHUH4scAOur2ddq3blLCH29eKuZO +2Ps/YPUGYgPXyGOuWu9Di0au3EOszmqFsz4Y/S9vGDiIAbQEZds3KldM77ji1fl 7Emjhz/9pToD0eErxnY3b7hW6yY8x5ek6gXTxo985AN1BiLAAFrrqk06t111JXWF x6rLpoz++WnuPGw1BtBCT3XZQp2Av8yZOPZBbr9pKQbQJrdsups6ARkNHf5Ef3UD AmIA7fDIhlurE5Cbdx5/Vp2AnDGAhrtoqy4bqhsQ3KAfnudVEgswgMbqs9ne6gTk 6Zufnn9D3YBsGEAD3bbpzuoEROiHX5/jRRJDMYCGGbSdugDxuPJadQHqYgDN4sqF 6FHXe7urC1AHA2iUy/kuwWHbfaouQG0MoFGeOkpdgPgc21ddgNoYQKN8yVs8HNbn CnUBamMAjcJTgC576hh1AWpjAI3CALps4M7qAtTGAJrkn7eoCxCnLb5WF6AWBtAk d56lLkCcDuBtIaZhAE3y9h7qAsTpvNvVBaiFATTJz13UBYjTHeeqC1ALA2gSXgNx 20u91AWohQE0CQPotk+2VxegFgbQIBfcrC5AvLbijnKGYQANcss/1QWI197/Uxcg FQNokP8erC5AvE59QF2AVAygQQZz3w/HXd1bXYBUDKBBeA3Edfefpi5AKgbQIAyg 6148VF2AVAygQRhA13FRaNMwgAZhAF335VbqAqRiAA3CALruh43UBUjFAJrjkuvV BYjbNoPVBUjBAJrjxovUBYjbHgPUBUjBAJrjoZPUBYjboS+qC5CCATTHc4epCxC3 Ex9VFyAFA2iON/dVFyBuZ9+lLkAKqwawfaPh6oQ4DdxRXYC4XXqDuiBGnReMVScE ZtUAOo63ArvvmqvUBUjBAJqDu6K777rL1QVIwQCa45tu6gLE7cZL1AVIwQCa49uN 1QWI2y0XqguQggE0x3e8T8p5/7lAXYAUDKA5GED3MYCGYQDNwQC6jwE0DANoDp4D dB/PARqGATRG51/UBYgdFwQ0DANojK7D1AWIH19wZuHPwxgMoA/4gjMLfx7G6DRC XYD48QVnFv48jNFhtLoA8eMLziz8eRij7R/qAsSPLziz8OdhjKYz1AWIH19wZuHP wxgMoA/4gjMLfx7m4K6Y7hveRV2AFAygORhA9zGAhmEAzcEAuu/n9dUFSMEAmoMB dN+PG6oLkIIBNAcD6D4G0DAMoDkYQPcxgIZhAM3BALqPATQMA2gOBtB9DKBhGEBz MIDuYwANwwCagwF0HwNoGAbQHAyg+xhAwzCA5mAA3ccAGoYBNAcD6D4G0DAMoDkY QPcxgIZhAM3BALqPATQMA2gOBtB933PvZ7MwgOZgAN03bFN1AVIwgOZgAN33zebq AqRgAM3BALrvqy3VBUjBAJqDAXTf4G3UBUjBAJqDAXTfZ9uqC5CCATQHA+i+j3ZS FyAFA2gOBtB9H+6iLkAKBtAcDKD73ttdXYAUDKA5GED3vb2XugApGEBzMIDu67+v ugApGEBzMIDue+0gdQFSMIDmYADd9+Kh6gKkYADNwQC679kj1QVIwQCagwF035PH qQuQggE0BwPovgdPURcgBQNojp/WUxcgbnecqy5ACgbQHF9xqSTn3XCpugApGEBz fLy9ugBxu6KPugApGEBz9N9bXYC4nXe7ugApGEBzPHeYugBxO/FRdQFSMIDmuI0n yJ23Xz91AVIwgOY49zZ1AeK22RB1AVIwgOY46BV1AeLWZpK6ACkYQHNs9J26AHHj 680w/IGYo3ihugAxG95FXYBUDKBBeC+c67gnkmkYQIMwgK7jalimYQANMqyrugDx uvlf6gKkYgAN8uIh6gLE6+SH1QVIxQAa5NLr1AWI1zaD1QVIxQAapOswdQHixZeb afgTMQmvgrjt4x3VBaiFATQJA+i2e85UF6AWBtAkj3PHCKcd+ay6ALUwgCbZ4211 AeLUbKa6ALUwgCYpXKQuQIwGb6MuQG0MoFG+3VhdgPhwGrR5GECj/OsmdQHis9WX 6gLUxgAapXSeugCxGbapugB1MIBm4UQYd91/mroAdTCAZrniGnUB4rLdp+oC1MEA moWLojqL14BNxAAa5rPu6gLEg3uim4gBNMxeb6kLEA/OgjYRA2gaXgZx0ys91QVI gwE0zZ1nqQsQB26JbiQG0DSN56gLEIMvt1IXIB0G0DifbDGjrOnKReoMRKS6fFZZ 88pbr1V3IB0G0DjF5X/+jzs7rdmySQl/QpaqnDdj4tiXn1/2fwoLK7U1SI8vL/Nd 3qVjm9Ua8y2hHarLZk0eN+q1AeoO5IQBtMht67RvtWpJoToD6VTMnT5h3DNvqDMQ DANooYvW77j6ao0bqDOwWNWCWZPG/vbyIHUHwmEAbXbzOmu2btqIbwmTV10xZ9r4 sU/xg67tGEAXXLDe2mustkoD/jBjt2jBjIljRr/Ahf1cwdeMU25Yp0ObZo1WUmc4 p7p89pTxvz/OD7rO8WUAi9oWlk3z6EyE+zut0aJJsS9/urFZcirLH3d/oM5ITtFq JVUTPPo68WEA9zms++qlS58nq1ow6Zu3XpqtDkrS1V06tG22Mt8SBlNdNmvK778/ NETdkaSmvfbq1nrZKQZV8/8Y7MsNWl0fwG1v7F771dIp79/p4ZUp716nXcsmDV3/ 485TxbxpE8bd/rk6I3GF25+1c4vUv1Qx+GIvvkrc/oo48pa2af/67NcuG5twikEe Wnv1Fqs0VFcYZPTEP270+GWNjtfvu0q6vz7hgmeSTkmeywO47mvrZ/6bP1/8WnIl Jup0YrNVVl1l5dLSkuKGRSut5PInQhqTy8rmz5s7a87cNz4ur/9XO6zwb9evk/Fv /nTgrwmmSDj8ed/7iuwnyE3rc3tCJTbY8gt1QUJuP09dYJCiC6/P+verru2dTIiM swNY+M5u9f6a2df9O4ESOxz4qrogIY+dXqZOMEXR5VfV+2ve26MqgRIdVwew5PtO ufyymec/FneJJU65X12QkFdOmq5OMEPRKXfn8stGbuT0vzAcHcCiX9bO8VeOO3pg rCXGKko928ub+3G+e+yEmv+3qMrt73AyKdz7zRx/5W9dXD4v0NEB/HKL3H/t4IMm xRdiqqZza31W336OJiRxg48clfL/CxuXefgySKeXNs351361ZYwham4O4P2nBPnV ix4807PvAprMr/Mv9b5HK0IEvj3s51p/pbC0zOXvcdIovf+YIL/8gVPjCtFzcgB7 vB3wH2v64T5d1qPp7DR7/8Z+yYdIjOg1tO5fbFzu0XeBhT1fDPYB1Xu6++Xh4gAW TWsS+GPe339+DCVGKq5M9/3uoO0SD9EY/7d07/RI/5vipNavdg/6IbNXc/ZbZBcH 8PEw72Ms+0ffyENM1Hx2+s/lj3ZIOERl3CFp3+pW2GS+F98EFp1+R4iPeuLvUXeY wsEBbD4l3BVCP99rZsQlJirM8J3Ohzsl2yEz9m/p3/WW6TfGLR3e3CjMh1W1dPXc IQcH8MVDQn7gwpPd/yawKNPPMt4PYEFhgfMTWHz6bSE/8qVekYaYw70BbDwz/MWf Ptrb8WcCSzKe1Dpg9yQ7hEYf8nWGv+P884Bt39ws7Icuajo3yhJzuDeAN1+QxwfP 6/lOZCEGajE9/Zd4yYnHbuHNnUV+f/a+Men/TtMyl9/0UHR4Pj/g3HJhZCFGcW8A J7bO68OfCnSGlGWK0z3PX3z2yeu692mQ1dSX/j0qzV92+l0hTZ7ZN58Pn9QmqhCz OPeZv95PeR5gwg4jIwkxUOspdb7AC084o6s33/vVUP1H3zsn1Pmrzec7+y1g98/y PMD6tc8fd4NzA/jAP/I9wqLz7ooixECNaz+P0/W2HYskJSaoHtH7pVrfEZdUOnq+ W8lll+d7iAcDvbvKGs4N4Nh2+R/jwz3dPCWs1k/AZ/xrTVGIKeY83Wd8zf/v6s/A rd/qlvcxxrWPIMQ8rg1gUXkU/0Qzdv42gqMYp+Y5MC3uPLhEV2KMqq8vrHE1IDfP hCnc460IjlJd7OR3x64N4P6vR3KYqn/9J5LjGKXV1BVf3q0f3cvHZ/7SGnFO/xX/ 28UnAUuvzue8iL8c8EYkhzGMawMY6m1w6by/p3P/wmu6/J0urZ/owfzVMPKcfn/+ LwcvitC6f+iT/1K5+XY41wZw6CZRHWnqtq7dEKZ02VnerZ7Z1bU/9byNOWvZtzfu vQqy04dRHWlY7lcQtIhrXwrTmkd2qMp/OHa5/GVvA7nlXG6TnsanJy45zcO1N4OU XBjdhb6nrxbZoQzi2gBWRvnV/dwRER5Mb8lrIHs95eSncQQq7r5yrmuvgjR/of47 g+VskZNnTDk2gEUVkR5uxJYuXSCmsKrVa4EvBeeRyWcGvFCo6Tb4IdLDNXDt6YEl HBvAiP/IC+b3+DTaAwq1nnLGrU7+Szw6/U6eV+7My8BFhz4d7QE3/DHa4xnBsQE8 JOp/h1dddEvER5Tp8PzW6gTjTT3fmSuild54VsRH7PVSxAc0gWMDeOl1kR/yzQPd eFpox7dK1QkWqLrvAje+BWz9WuT/urvs+qiPaADHBvChk6I/5u+bT43+oIm79jLH /qjjMvhYF05/2vyr6I/58MnRH1POsa+KZ+J43XbBHoNiOGqy3umhLrDGhGPeUyfk q+iox2M46rNHxnBQNccG8JWD4jhq1Xl3xnHY5DT+Zl11gkXmnf2oOiE/ja89N47D vnpwHEcVc2wA++0Tz3HtPiOw1Y+c/BdE5eU3qRPy0eqFeO7v0j+vK6oayrEBjO3O Fj9uae/dQtb4Mfh9kv22qE9vdUJ4UZ8KtsK7Lj6N4tgAxndvs5lb2frceIcfVlYn WKfq5ovVCWHt06/+XxPOwJ3jOrKQYwP4/i6xHbqi12uxHTtOrUasok6wUNW1vdUJ oRSffXNsx/5g19gOrePYAL4Z49MU1VdfHd/BY9NkVHSXh/BJ5WX/VieE0OSuY+M7 eL/94ju2jGMDGPqm6Dmx8GWwwpFrqRMsteDsh9UJgbV9Jc43+zh5c3THBvCJGP8F uNhPW9j2Ugjn/4U26Vjb7hHddVish38yqosNm8SxAbzv1HiPP32LdPeTNdf1l6gL LPbdoXbdCXLfN+M9/v2nxXt8CccGMPYv+PJ9bHqbwLaDHPvzTdZLR1h0Aaii0++I +RFuuDTmB1Bw7Avk9HvifoTqc+y5a3DJZF4AzkdV72vVCTlrfOMZcT/EGffG/QgC jg1g3D8FLGHPHaIH7qgusNy04225E1qrp+J/sne/2M4wFHJsADf6LoEH+WRHOy6Q 1fNldYH13us5W52Qk3WHJ/AgG3+fwIMkzbEBLJ2XxKOM2dSGK+UXT+cdIPmy5Hzo bT9J4lFWtu0UiFw4NoAFVYn8A83a0oL3xb3g4mlbSRt39EB1Qv0ivw56WtVO3kva tQFcUJLIw1jwYnCH35z8hE2a+bcDLz4rmbs2lDVK5GES5toATmmRzONUnXF/Mg8U 2hdbqguc8OVW6oJ6nHpfQg80tWVCD5Qo1wbwl85JPdIdsVx0MjLdP1MXOGKbweqC rG4/J6lHGt4lqUdKkmsD+NEOiT3U23sl9lAhDOuqLnDEt5uoC7L5356JPdTHTp5U 5doAPnlMco/1czdzbyC26RB1gTO6DVUXZFQyZL3kHqxvvO+zF3FtAC+I73JodU3Z eFKCjxbIYO4BHJXPu6sLMmn9XZJPy13ozB2ya3JtAHf6MMlHW7Ctod8dNJ/q2h+s TnWL6eqE9BL+Ln9nC04ICs61r5NkzoReobKnme+VevhEdYFDHonhZtMR2P/1ZB/P yfOgnRvAgoqiRB+u+vzbE328HM3lTSDRmddYXZDOubcl+3iVDZJ9vIQ4N4DTkr4C /H2nJ/yAOUjimhAeMfEqAPcmfXG+6W7eWtW5Afxuo6Qf8Z3kzkTI1aDt1AVO+WR7 dUEdb++R9CN+v3HSj5gI5wbwv8nft+PHzQ07HaZwYbLPA7iusqFhl/8p+XqDxB/z lZ6JP2QSnBvAK65J/jEnbTQ1+QfN4pgn1QWOObavuiBFi+9bJ/+gV9pzcdggnBvA Xd4XPOjcLY26ewQXQo3YRzupC2pa7yfFo+76geJRY+fcABYvVDxqxZ4mfXrMd/K6 HUILStUFNUj+FV9Q0LBc8rBxc24ARV/9VSc8oXjYtLp9oy5wzmbmvLPwuMclD2vU vwMi5N4AjlpL87hX99Y8bl13x357HO/cc6a6YLneV2ked3RHzePGzb0BlN0K3JhL Z/7s5HWLpH5J8KIDWT2uujn5gMTPu0mGewN4w8WqRx64qxlnS5S7ec6+UkWxumCp wvdlr8bcGPcdt0XcG8Dd3pU99PBNTDghMJE7hPmmswk3gSkZltjlfuvY3fh7QITj 3gBqXgZexogTAi9384QtrSv6qAtEp/8t5+iLwA4OYME84etVczfXf/v1/i7qAgd9 sKu6oKDzL8IHn+/q1TUcHMARnYQPXr7bIOGjLzV+dXWBg/5YQ12w/cfKRx+5jvLR Y+TgAL6+v/LRq458Xvnwiy004wl7t5Q3FAcc9pz04d84QPrw8XFwAC+5Xvv44kuH N50hfXhXNZspffhEb/WQxqU3aB8/Ng4OoPx+QHefpXz0Q15UPrqzer2kfPS71Cdi G3xnqPw4OIAFVep/qNcPFD749Y6esCV2w6XCB39N/QNodaE4IDbqrYjDjKbqgi+3 rZQ99isHyR7aZa8mf53J5Yo+3VL22H+a2UxdEBcXB9CAe4KP2kh2B5khm6oe2WlD u6keufR7/dtwzb47fD5cHMC+R6sLCgqmbai6ZfDYdqIHdtu49qIHbj1R9MA1PXWM uiAuLg7gSQ+pCxabt4XoGqmzmmge13GzV9U8rubqp7Wd/LC6IC4uDqAR/84sqOih uZE0l0KIhehyCDt9KHnY2tqofp6JnYsDaMgGVB39rORhnfwjldO8DnrEM4pHrcOQ i+HEwcmvFlOeBlOcEl1UkfxjeqGB4IV99enPy8meAI2fkwP47m7qgj/dcW7iD7nG uMQf0g/txif+kLefk/hDpvfe7uqC2Dg5gFdfqS5Y7qVeST/i1oOTfkRPdP886Ud8 8ZCkHzGTa0TX4U+AkwPY/TN1wQqfbZ/wVaJ7vJPs43ljjwHJPl7hoG2SfcAstnH3 36pODmBhpTn/WL92TfYq0T1fTvTh/PG3/yb6cCXfrpvo42VTXWTGvR7iYM5SREn/ Zri/TN50QpIPJ7provv+nuh9T9sObZXkw2Xn7hvhXB3ArzdTF9RQvXmSl6c5/tEE H8wnJzyW4IOZdWvnbzZXF8THzQF84B/qghRJ/vQkvnCmuw5P8EK3hj2P8eAp6oL4 uDmAhn0CJXlCIJcDjEmCFwQ05fS/5RJ++jNRbg5g6Tx1QS03JXaz4n36JfVIntm3 f1KPdONFST1SjlaWXdoofm4OYMFc025ildi7yTkNJiaJnQZjxLU8aprXWF0QI0cH 8IcN1AW19b46mcfR3jzMYTskdLu/q3on8zi5+3FDdUGMHB3AJ45VF9SR0DPJvBMk Jgm9E8Sw1++WePI4dUGMHB1AE18LTeZOIWZcC8xByVwRSn73jzSSfP07cY4OYMkC dUEag7dL4oT66gQew0dJfKUUftI9gUcJqlGy72VKlqMDaMglAWsZvkkCn0qLnL2B l1TVSvE/RsmwzvE/SGAOXwywwN0B/E1/I5k0Jm44PfbHKGsY+0P4aGFJ7A/R/Ic2 sT9GCKPWVhfEydUBvPc0dUFaszYZE/dDzBTdvMJxs2J/e3mH0XE/Qjj3na4uiJOr A7jtJ+qC9BZsOzTmRzDyh3/7xf6D4KZJvmM8iO0+VRfEydUBNPa1gIq934v3AXgO MBZxPwe427vxHj88ZydiKWf/6RbE/5xNOFXHxHujm4qiWA/vq8p4v7E+8ulYD5+H skbqglg5O4A/rq8uyOj82+I8+ny3P2FVFpTGefTzbo3z6Hn5ybg3VUXK2QG84hp1 QWY3/yvGg5t0MViHxHpR0H9fGOPB83TlteqCWDk7gCVzEzhxK6y+Mb5Tb9wa8R3b Y+NjvNXqk8fEd+x8LWrs8mnQDg9gwR9t1QVZvNsjtkMP2TS2Q/tsaLfYDj3A5JtO TlhdXRAvdwfwvV3VBdkM2yKu+2wbc1Nkt8R2a9yirzaJ6ciReN/xTyd3B9C8ywql GL1hTFeZ7Ht0PMf13FMx/Zha+sNa8Rw4Ikldxk3F3QFc7yd1QXZTN5wcy3ENH35b xTQErX5oEctxI7P+z+qCeLk7gMafEDd305FxHNa0+6E4Ip77YnQaEcdRIxTz6Y96 Dg/g2Bhft4vEwh2+jOGoa4yL4aBoNz6Gg275RQwHjdS49uqCmDk8gG/uqy6oT+WB cdxop9Lg83+stSiOHycsuIFVv/3UBTFzeADPjfUNF5GoOuGJ6A86rXn0x/Te9NWi P+Zxj0d/zKidd7u6IGYOD6AVPwte9O/IDznU6NMqLDUs+rMr/3VT5IeMXiw/+ZvE 4QG049Kgt58X9REfPT7qI6LgsROiPuJt50Z9xBgkcBlYMZcHcEQndUEunjsi4gMe 8mLEB0RBQa+XIj7gs4dHfMBYjFxHXRA3lwfw+UPVBTn5IOK3rBSXufyHqlFdUh7t Ad/fJdrjxeSFw9QFcXP5a+XovuqC3Hy7ebRvi+NVkMhF/BpI0dddIz1ebI55Sl0Q N5cH0Mh7Y6bz+4ZzozzcwB2jPBoW+2inKI/W+Ic1ozxcjJy+I+ZSLg+gPZfGm7ZB lG+LM/jqmraK9Bq2rRK5xXoUYr0IohmcHsBPt1EX5GruZr9Gd7CmM6I7FpZqNjO6 Y607PLpjxeyzbdUFsXN6AK+9XF2Qs4U7fR7dwabGcNau16ZFeMWCrQdHd6y49blC XRA7pwew8y/qgtwtOviNyI712gGRHQpLvH5gZIfa//XIDhW/LvZ8sxqW0wNYsDDu m7lGqPofD0d1KKu+yGxwQGT/cjrpoaiOlIByG95JkCe3B9COU6GXi+72M9wcPVLR 3RTd5Ft11eX+adCuD+BTR6kLArn/tIgO9NXmER0IS3y9RUQHuu/UiA6UjKc9uLi4 2wN40CvqgmBeOyia45xxdzTHwVJn3hPNcV6N7qnERBz8qrogfm4PYFG5Zf98g7er iuIwxQsKozgMlqpqFMn74Ao/6R7FYZJTXRzXjbsMYtlABDWxtbogoOGbRHLu/Xcb RXEULPX9xlEcpWRY5ygOk6BJbdQFCXB8APvvrS4IauKG0yM4yll3RnAQLHP2XREc pPkP1s3JW/uoCxLg+ACeep+6ILDZm47K/yBFCwy/I5RFKhtF8JNgx9/yP0bSTrtf XZAAxwewySx1QXBl23+d/0E+3j7/Y2CpQTvkf4zNv8r/GIlbdba6IAGOD2DBzFXV BcFV7v+/vI+x27sRhGCJ3d/L+xB7vRVBR9Jm2XIpkby4PoCf2Ph27qqTHsv7GDYu v5Ei2IHjH42gI3GfbqcuSILrA2jXqfcrXNEn3yNwZ5CI5H83kMsje4dPoqJ7Y5LJ XB/A9r+rC8J58JQ8D9B2vOt/tMmoXmNCnkd44B+RhCRuzbHqgiQ4/1Uyr1RdEE7/ fG/rzt0xI5H3/TD7WXoyyfyV1QWJcH4Av+mmLghpyFb5nX3ByyCRyPMlkKIvrP38 20xdkAjnB/CGi9UFYeV7p5AJ1p15a6CJbfP6cHvu/lHHjZeoCxLh/AB2GqEuCG36 Rnk9/fTPW6IK8dgF/8nno9v+EVVH8tYZqS5IhPMDWLDA3pvbL+j+bR4fXTjP3n9y U5StnM/FKboOiywkcWWN1AXJcH8AbX4xIL9Toi27+pyJ8rpCo5WnPy+X94s/lnB/ AG/5p7ogD9WnPRD+g4vnWHRHACOVr5LHhbBOsfqttP+5QF2QDPcHcL2f1AV5ueHS 8B/Lt4B5yucbwOvtfhFh/Z/VBclwfwALyuy+tctzR4T+0KI5PAuYj7JVwp+J9Ozh EYYkb6EvnzkeDKDtFwf9dIfQT8T3virKEO9c3TvsRxZ+bON70GuI5iKwFvBgAK1+ EnCJkV3nh/3QGV5c0SMmM5uF/cjSb626HWEavjwF6MMA2nR79PSmbTI+5Ece8mKk IX7p9VLID1xjXKQdCh7cEn0ZDwawYL71pzQt2G5IyI8c1jXSEJ98G/b8qW7fRNqh sMDSd9AH58MAfm3/uxorD3kt3Ad2+I37w4VTtfaYcB94oAM3k/zGmxtL+zCA116u Lshf9fm3h/vAf18YbYg3bv5XuI8797ZoOyT6XKEuSIoPA2jrNQFT3X1WuI8b2y7a Dk+Max/u4+46M9oODT+uBbiEDwNYMKexuiAKIe9SuN4P/BAcXNWG4U4Etu8+rOnM XUVdkBgvBvCz7uqCSPy8eajTYS64OeoQD1wY6lI6pV+vF3WIxOBt1AWJ8WIAL7le XRCNad1C/WRi5Y2htMLdEMiN51oWu/QGdUFivBjAFlPUBREp22VwiI8qGd888hK3 TV+jLMRHdf8s8hCRllPVBYnxYgDdeUNE1d/7hviojr80iLzEZRVdRoX4qGOejDxE JPxbYOzjxwC+t6u6IDLXhTmnZ983/Phzjkb1/v1CfFSfyyIPUXl/N3VBcvz4wrD7 0mypXj8wxAedfk/kHe46494QH/TaAZF3yJyax0UobePHAJbOdeifM9SLwa68DpSA MK8AuPLy71LVjUNffMM+Dg1DNhNbqwsiNH2LEE9ROfQTWrzCPMfQ8bfoO3Qm+XQ7 QU8G8L8HqwuiVL5PiJvVOvEWrdiFesuhY7dgfqWnuiBBngygC29Qr6H6nLuCf9Bh z0Uf4pqqI58P/kFn3Rl9iNJBIS+8YSVPBrCwwrH3gz12QvCP2fKL6DvcMme3L4N/ 0KPHRx+iVNUgn1uB2saTASwYtZa6IGLfbBP8hmWNB1l8i9AEDNt+buCPKf7M/out pRrdUV2QJF8G8JEQ3zGZbeoWIa5Xd+NF0Ye4ourmi4N/UIevWkRfovXoieqCJPky gFuHeQ+Z2coP7h/8g9r/b4PoS5zw414h3mi9T5hTpg3X/XN1QZJ8GcCChe7dJLz6 2jA3fXPppPDozP5XmJN/r74y8hC5crvvIhuUNwM41MWnv97dM8zz1f+6KfIQy82+ 7t8hPqrw7d0jL9Ebtqm6IFHeDKCL/7IuKPhjiwlhPuzU89eNusRiv94a6pvitl+t HnWJCa7x617S3gxg64nqglgsPOCdMB/WdVjUIRbb5NswH7XH21F3mKHNJHVBorwZ QHcuiZWq+qZLQnzUDSFe8HTWjfwO/sWnS2Et4c8ADnDxCZslPts5+BmBjtwkIBoh LgBf/KGrF41/t4e6IFn+DOBxj6sL4jJj+x+DfsjMVeMIsdSswD8bbPBDHB1G+PsT 6oJk+TOAxWXO/rMuOjPgs/hNZ8QTYqlmM4P9+lPvi6fDANUlwX+csJqzo1CXyzfI feuAyiC/nCvDpDgv0BVgil534taX6YW9HbK1PBrAJ45VF8Royo5B7mP74U6xhdho 4M4BfvF6H7WMq8MATx6nLkiYRwPozk270ll00X9y/8U8BZgiyJOA/wx1w2BrbOPe W0az82gAC8rcfpPPpz1yvZJ582mxhthntek5/sLSAW7fY3lhibogaT4N4Dfd1AXx mnfwgNx+4aXXxRtinctyvGNKj1BnnVtkiGvX9qqXTwN4+bXqgphVP31cTu8NdvJ9 0fnI7f2vhU8cHXeI2hV91AVJ82kAPfjJb8qeQ3L4VeXcJz1VRS6XCur2tsuvfiyT 83MBzvBpAAumrqYuiF31IyfX+2sOeTGBELv0eqneX/LQSQl0iE1z7uqu9fJqAF26 eXVGUw76tJ5fMXDHREJs8lF95wVt+6r73/4VFLx+oLogcV4NoGP3hsug+tXDs57N X1jGT8C1VZRkffK0+DmnbquakVf3g1vGqwEsLF9JnZCIeaf1zfJ3uSR0GqdmuyD0 MU8m1iG1qNin+8Et49UAFvzSWV2QkB8PHp7x741cO8EQW4xcJ+Pf6vyKL7dRGd5F XZA8vwbw1vPUBUmpfuWYDKdFO3wlk3xsmOGKOqV9eyYbInTb+eqC5Pk1gB1GqwuS U37nRWl/oOFSgGmlvyhg4U0XJB0itFaIG63azq8BLJjVRF2QoHk3pjmtlW8A06ve KM23gJdfvHLyJTKzfXyHuGcD6OxlodObe8/ltS+TVS0JscDP69f6C0V9zmgsKVHx 7WLQS3k2gEc+rS5IWMWb56X8XMOVADNKvSpgh9v28+1soaOeURcIeDaAhRWF6oTE jb7n7rLl/9vtS4Llp2q7FZeCKjnzjLWEJRpVDfw7Cca7ASwY0UldIFD92/+eWfr2 kJMfVKeYrPL0h5b817ZH7rW2b18WS2Q5E8hhvv1J33mWukCkan4Dty+HGIWKWdWN Sv37GWGZu85WFyj4NoCdRqgLACOtM1JdoODbABbMXkVdABhojk9niP3FuwF8b1d1 AWCg93dTF0h4N4C+vLEdCOTYbBfQcJd3A1i00NcnuYHMqhoGurO0M7wbQD9PhAGy 8/MkGB8H8PZz1AWAce44V12g4d8AdvxNXQAYZ+1R6gIN/wbQryvCALnw8kowS3g4 gO/4eNELIJsBe6gLRDwcwCN8vOgFkM2Rz6oLRDwcQF9ujQTkysfbIS3j4QD6c2sk IDc+3g5pGR8H8Gaf7vMA1O+WC9UFKj4OYPvf1QWAUdYcqy5Q8XEAC2Y0VRcABpnZ TF0g4+UAvrmvugAwSL/91AUyXg7gga+qCwCDHPSaukDGywEsqChSFwDGqPTt/nc1 +DmA322kLgCM8f3G6gIdPwew91XqAsAYV/dWF+j4OYAtpqgLAGO0nKou0PFzAAsm t1QXAIaY0kpdIOTpAD5/qLoAMMQLh6kLhDwdwB0HqgsAQ+z0kbpAyNMBLChrqC4A jLCwRF2g5OsAfrGlugAwwpdbqQuUfB3As+9QFwBGOOdOdYGSrwNYMt/Xf3KgpurS MnWCkrczMGZNdQFggN87qAukvB3Ae09TFwAGuO90dYGUtwO47nB1AWCAzr+qC6S8 HUBuDwx4fEPgP/k7gP/bU10AyL29l7pAy98B7PmyugCQ+9t/1QVa/g4gV0UFfL4W 6lIeD+C3Hl8GEljqu67qAjGPB/CKa9QFgNiV16oLxDwewKYz1AWAWLOZ6gIxjwew YEIbdQEgNbGtukDN5wF84lh1ASD15HHqAjWfB3DTIeoCQKrbUHWBms8DWDB3ZXUB IDSvsbpAzusB/GBndQEg9OEu6gI5rwfwyKfVBYDQUc+oC+S8HsDC8pXUCYDMouIq dYKc1wNY8OP66gJA5qcN1AV6fg/gtZerCwCZPleoC/T8HsAWU9QFgEzLqeoCPb8H sGBSK3UBIDK5tbrAAJ4P4DNHqAsAkWePVBcYwPMB3HqwugAQ6f65usAAng9gwfxG 6gJAYkGpusAEvg/gx9urCwCJQTuoC0zg+wAe/6i6AJA44TF1gQl8H8CihYXqBECg qmGlOsEEvg9gwS+d1QWAwPAu6gIjeD+AN16kLgAEbrpYXWAE7wew9UR1ASDQZpK6 wAjeD2DBlBbqAiBxU1uqC8zAAL7QS10AJO7FQ9UFZmAAt/1EXQAkbrtP1QVmYAAL FpSoC4CElfEOqGUYwIJB26kLgIR9wjuglmEAC056SF0AJOzkh9UFhmAAeTMIvMPb QJZjAHkzCLzD20CWYwALCm7gnHj45cZL1AWmYAALClpxTjz80nqyusAUDOBikzkr Hj6Zwq1wlmMAF3v2cHUBkKDnuBXOcgxgAXcGgWe4G8gKDOAS3BkEHuFuIH9hAJcY uKO6AEjMRzupC8zBAC5x3OPqAiAxf39CXWAOBnCJf92kLgASc9G/1QXmYACXKF6o LgAS07BcXWAOBnApzgSENzgLsAYGcKlLr1MXAAm57Hp1gUEYwKWKKtQFQEIacCWY vzCAy0xvpi4AEjGjubrAJAzgMn0uUxcAibjucnWBSRjAZQoXqQuARKxUpS4wCQP4 p1lN1AVAAmavqi4wCgP4pxMeURcACTjxUXWBURjAPxVWcGcQuK+qAT8B18QALjes q7oAiN23m6gLzMIALnfEM+oCIHZHPqsuMAsDuEIVvxdwXTVP9KTii36FP9qqC4CY TVhdXWAYBnCFi25UFwAxu5gLv6ViAP9SrQ4AYsbXey38hvyFO4PAcdwNpDYG8C9v 76EuAGL1zp7qAtMwgH/Z6UN1ARCrnQeqC0zDANZQuZK6AIjRoiJ1gXEYwBpGraUu AGI0uqO6wDgMYA1PHaUuAGL09NHqAuMwgDXs009dAMRo3/7qAuMwgDVwRRi4jCvB 1MUA1jS2nboAiM249uoC8zCANb3QS10AxObFQ9UF5mEAazroFXUBEJuDX1UXmIcB rKmonN8PuKq6mBsC18EXfIrxXC0IrvpjDXWBgRjAFK8cpC4AYvLqweoCAzGAKQ57 Tl0AxOTw59UFBmIAU/AkIFzFU4Dp8PWeiuviw1FcDT8dBjDV7FXUBUAsBnC5yzQY wFRcEAZuqm48X51gIgYw1W3nqguAOExroS4wEgOYao1x6gIgDu/2UBcYiQGsZepq 6gIgBmfcqy4wEgNYy/O8YRwuWnW2usBIDGAtWw9WFwDRm9FcXWAmBrA27g4MBw3c WV1gJgawtg93UhcAkbvgP+oCMzGAtR3dV10ARG616eoCMzGAtXFjELhn9qrqAkMx gHX80lldAETsk+3VBYZiAOu4+QJ1ARCxS29QFxiKAayDN4PAOa0nqwsMxQDWNauJ ugCI1FwucpQBA1jX+7uoC4BIDd5GXWAqBrCukx9UFwCRuqKPusBUDGBdJfP5XYFT Vp+gLjAVX+ppTG6pLgAixFOAGTGAafTbR10ARIinADNiANM46SF1ARAhngLMiAFM o3SeugCIUJtJ6gJjMYDpTG+mLgAiwxuBM2MA0/loB3UBEJlBfDpnxACmc+l16gIg MlwLMDMGMB3eDgyHNJupLjAXA5gW18WHM7gdSBYMYFrfbaQuACIyYA91gcEYwLTu PU1dAETkxEfVBQZjANPa/mN1ARCN6pJydYLBGMD0KldSFwCRmNhWXWAyBjC90R3U BUAkXuqlLjAZA5jeM0eoC4BIHPCGusBkDGB6+7+uLgCiUNWgSp1gMgYwPe4ODDeM WltdYDQGMIPf26sLgAg8cpK6wGgMYAbPHq4uACLQ/XN1gdEYwAz2eFtdAOSvvKG6 wGwMYCYVReoCIG/fb6wuMBsDmMnwddUFQN5uulhdYDYGMJM7z1IXAHlbe5S6wGwM YCbr/aQuAPI1r7G6wHAMYEbzStUFQJ4+2V5dYDgGMKPPuqsLgDydc6e6wHAMYEYX 3KwuAPJT3WSuOsFwDGBGTWapC4D8TGmlLjAdA5jZTG6nCrt9uZW6wHQMYGYvHqIu APLS6yV1gekYwMx6vKMuAPKyEpfCqgcDmMUiLokFm3EWYL0YwCzGrKkuAPLw/m7q AuMxgFlce7m6AMjDVl+qC4zHAGbRapK6AAivmqdw6sUAZrOwWF0AhDazmbrAfAxg Nl9tri4AQnvhMHWB+RjAbHq+rC4AQlt9grrAfAxgVlNaqAuAkKpWUhdYgAHM6uWe 6gIgpElt1AUWYACzOuRFdQEQ0t1c07x+DGBWReX8BsFSjcrUBRbg6zu78aurC4BQ eB9cLhjA7F7opS4AQnnxUHWBDRjA7A56RV0AhHLwq+oCGzCA2RVW8HYi2KiqAZfC ygEDWI/f26sLgBDGcimjXDCA9XjmCHUBEMKzR6oLrMAA1mOffuoCIIR9+6sLrMAA 1qeSNxTBPouK1AV2YADrM2otdQEQ2OiO6gI7MID1eeJYdQEQ2JPHqQvswADWZ7d3 1QVAYLu/py6wAwNYrwqeTYFtKhuoCyzBANZrRCd1ARDQyHXUBZZgAOv18InqAiCg R05SF1iCAazX9h+rC4CAdhikLrAEA1i/cp5PgV0quJ1hjhjA+v3SWV0ABDK8i7rA Fgxg/e47VV0ABHL/aeoCWzCA9dvyC3UBEMhWX6oLbMEA5mAhz6jAJuUN1QXWYABz 8MMG6gIggB83VBdYgwHMwW3nqguAAG4/T11gDQYwB+v9pC4AAlj/Z3WBNRjAXCwo URcAOStrpC6wBwOYiyGbqguAnA3tpi6wBwOYiz6XqQuAnF13ubrAHgxgLtr/ri4A crbmWHWBPRjAnMxdWV0A5GheY3WBRRjAnHzWXV0A5GjwNuoCizCAObnkenUBkKNL b1AXWIQBzEmrSeoCIEetJ6sLLMIA5mbmquoCICezmqoLbMIA5ubDndQFQE4G7qwu sAkDmJuz7lQXADk5+y51gU0YwNw0maUuAHKy6mx1gU0YwBxNXU1dAORgWgt1gVUY wBz9b091AZCDt/dSF1iFAczR8Y+qC4AcnPCYusAqDGCOSubzWwXzVZeWqROswld1 ria0URcA9ZrYVl1gFwYwVy/3VBcA9frv39QFdmEAc3Xgq+oCoF4HvaYusAsDmKvC ikJ1AlCPqgZV6gS7MIA5G7WWugCox+iO6gLLMIA5e/R4dQFQj8dOUBdYhgHM2fYf qwuAeuwwSF1gGQYwd+UN1AVAVhXF6gLbMIC5+3F9dQGQ1U8bqAtswwDm7vZz1AVA Vnecqy6wDQOYu/V+UhcAWa3/s7rANgxgAPMbqQuALBaUqguswwAG8PVm6gIgi282 VxdYhwEMoPdV6gIgi6t7qwuswwAG0PYPdQGQxeoT1AXWYQCDmL2KugDIaE4TdYF9 GMAgPtpBXQBk9PGO6gL7MIBBnH2HugDI6Bzu3RoYAxgEN8eEwbghZnAMYCBTuOcg TDW1pbrAQgxgIG/uqy4AMui3n7rAQgxgIEc+rS4AMjjqGXWBhRjAQIrK+Q2DmaqL K9UJFuLrOZix7dQFQFrj2qsLbMQABvPUUeoCIK2nj1YX2IgBDGa3d9UFQFq7v6cu sBEDGFBFkboASKOSGzaEwQAG9EtndQGQxvAu6gIrMYAB3XWmugBI4+6z1AVWYgAD 2ug7dQGQxsbfqwusxAAGtaBEXQDUUcbtGkJhAIPiuvgwEFfDD4cBDIrr4sNAXA0/ HAYwKK6LDwNxNfxwGMDAZnHhcZhm9qrqAksxgIEN5MLjMM1HO6kLLMUABnYWFx6H ac6+S11gKQYwsMZz1AVALavMVRdYigEMbjKXHodZprRSF9iKAQzutQPUBUCK1w9U F9iKAQzukBfVBUCKXi+pC2zFAAZXWFGoTgBqqGpQpU6wFQMYwqi11AVADaM7qgus xQCG8MgJ6gKghkdPVBdYiwEMYevB6gKghu6fqwusxQCGsbBYXQCsUN5QXWAvBjCM bzdWFwArfNdVXWAvBjCMGy5WFwAr3HiJusBeDGAYHUarC4AV1hqjLrAXAxjKnMbq AuBPc1dRF1iMAQxl0HbqAuBPn2yvLrAYAxjKubepC4A/nXe7usBiDGAoTWapC4A/ rTpbXWAxBjCcKS3UBcBSU7k6Wx4YwHBe319dACz1BldnywMDGE6vF9QFwFKHcnW2 PDCA4XBJLJiBS2HlhQEMaXQHdQGw2Ji11AVWYwBDevR4dQGw2GNcmy0fDGBI3T9T FwCLbcO12fLBAIbFJbFgAC6FlR8GMKxhXIMIet9uoi6wGwMY1vVcgwh6N1yqLrAb AxjWGuPUBUBBu/HqArsxgKHN5ipEUJvTRF1gOQYwtA93UhfAewN3VhdYjgEM7fR7 1AXw3hn3qgssxwCGVjqX3zxoVTeer06wHF/D4U1srS6A5ya1URfYjgEM7+We6gJ4 7r9/UxfYjgEMb9831QXw3H791AW2YwDzULmSugBeW1SkLrAeA5iHX9dRF8BrI9ZV F1iPAczD3WeoC+C1e85UF1iPAczDRt+pC+C1jb9XF1iPAczH/EbqAnhsQam6wH4M YD6+3EJdAI99taW6wH4MYD4uvU5dAI9ddr26wH4MYD5aTFEXwGMtp6oL7McA5mV6 M3UBvDWjubrAAQxgXv63p7oA3np7L3WBAxjAvBzdV10Abx3zlLrAAQxgXorK+Q2E RnVxpTrBAXz95uf39uoCeGrsmuoCFzCA+XniWHUBPPXkceoCFzCA+dn2E3UBPLXd p+oCFzCAeVpYrC6Al8obqgucwADm6buN1AXw0vcbqwucwADm6YaL1QXw0o2XqAuc wADmqf3v6gJ4ac2x6gInMID5mr2KugAemtNEXeAGBjBfA3dUF8BDH+2kLnADA5iv 0+9RF8BDZ9yrLnADA5iv0rn8HiJp1Y3nqxPcwBdv3ia0URfAOxPbqgscwQDm7cVD 1AXwzku91AWOYADztk8/dQG8s29/dYEjGMD8Va6kLoBnFhWpC1zBAObvl87qAnhm eBd1gSsYwPzdeZa6AJ6562x1gSsYwPx1/kVdAM90Ga4ucAUDGIF5peoCeGX+yuoC ZzCAEfisu7oAXhm8jbrAGQxgBP55i7oAXrngP+oCZzCAEWgyS10Ar6w6W13gDAYw ClNaqAvgkakt1QXuYACj8NoB6gJ45PUD1QXuYACj0PNldQE88rf/qgvcwQBGobCi UJ0Ab1Q1qFInuIMBjMSITuoCeGPkOuoChzCAkbjvVHUBvHH/aeoChzCAkeg6TF0A b2zyrbrAIQxgNBaUqAvgibJG6gKXMIDR+HILdQE88dWW6gKXMIDRuPQ6dQE8cdn1 6gKXMIDRaDFFXQBPtJyqLnAJAxiRac3VBfDC9NXUBU5hACPSf291Abzw1j7qAqcw gBE58ml1Abxw1DPqAqcwgBEpWsi74RC/qoaV6gSnMIBRGd1BXQAPjFlLXeAWBjAq D5+oLoAHHjlJXeAWBjAqm3+lLoAHtvhaXeAWBjAyZQ3VBXDeQt5yGS0GMDLfdFMX wHlDNlMXOIYBjMwV16gL4Lwrr1UXOIYBjEyrSeoCOK/1ZHWBYxjA6Exvpi6A42bw hsuIMYDR+d+e6gI47u291AWuYQCjc3RfdQEcd8xT6gLXMIDR4d1wiBfvg4scAxih MWuqC+C033m7ZdQYwAg9coK6AE57lLdbRo0BjNCWX6gL4LStvlQXOIcBjNIingRE fKpWUhe4hwGM0vjV1QVw2B9rqAvcwwBG6caL1AVw2E0XqwvcwwBGakoLdQGcNbWl usBBDGCkXjlIXQBnvXqwusBBDGCk9n9dXQBnHfCGusBBDGC0KnmhDvFYVKQucBED GK2fu6gL4Khf1lMXuIgBjNat56kL4KjbzlcXuIgBjFbH39QFcNTao9QFLmIAIzZ7 FXUBnDSnibrASQxgxD7cSV0AJw3cWV3gJAYwYic/qC6Ak/7xkLrASQxgxIrL+C1F 9KpLytUJTuKrNWpj26kL4KBx7dUFbmIAo/bEseoCOOjJ49QFbmIAo7b1YHUBHNT9 c3WBmxjAyJU1VBfAOQtL1AWOYgAj9003dQGcM2QzdYGjGMDIXX6tugDOuaKPusBR DGDkmk9TF8A5q01XFziKAYzetObqAjhm+mrqAlcxgNHrt4+6AI7pv6+6wFUMYPQO e05dAMcc/ry6wFUMYPSKFnJ7YESpqmGlOsFVDGAMRq2lLoBTRndUFziLAYzBwyeq C+CUR05SFziLAYzB5l+pC+CULb5WFziLAYwD74ZDhHgfXHwYwDgM2VRdAIcM5c2V sWEA49D7KnUBHHJ1b3WBuxjAOLSeqC6AQ9pMUhe4iwGMxYym6gI4Y2YzdYHDGMBY vNNDXQBnDNhDXeAwBjAWxz2uLoAz/v6EusBhDGAsuDccosL94OLE12k8uDccIsL9 4OLEAMbjyWPUBXBEX24zGCMGMB7bf6wugCN2GKQucBkDGJPyBuoCOKGiWF3gNAYw Jt9tpC6AE77fWF3gNAYwJjdepC6AE266WF3gNAYwJh1GqwvghLXGqAucxgDGpVod ACfwFRorfnvj8uk26gI44LNt1QVuYwDj8s9b1AVwwAX/URe4jQGMS9MZ6gI4oNlM dYHbGMDY8CQg8scXaLz4/Y1N/73VBbDeW/uoCxzHAMbm6L7qAljvmKfUBY5jAGNT VKEugPUaVKoLHMcAxmfcGuoCWG48V1WLGQMYn2cPVxfAcs8doS5wHQMYn73eUhfA cnv/T13gOgYwRpwIg/zw5Rk3fodjNKKTugBWG7mOusB5DGCMHjpJXQCrPXyyusB5 DGCMtvxCXQCrbfWlusB5DGCceBIQ+eCrM3b8Fsfp+w3VBbDYD9xWIXYMYJxuvkBd AIvdcqG6wH0MYJw6jVAXwGLrjFQXuI8BjBVPAiI8vjjjx+9xrD7rri6AtQZzU4X4 MYBxavHYfuoEWOvN46eqE9zHAMbq7DvUBbDWOXeqCzzAAMZqn37qAlhr3/7qAg8w gLHq+l/eDoxwRvb8Vp3gAQYwVk0e4JqACOe5U2arEzzAAMbr5AfVBbDUPx5SF/iA AYzXHm+rC2CpPd9RF/iAAYzXei/xdmCE8cMhP6sTfMAAxqv4zlPUCbDSA2eXqxN8 wADG7Jgn1QWw0rHcVjoJDGDMdvpQXQAr7TxQXeAFBjBmHZ/dWp0AC31+xCh1ghcY wLjdcLG6ABa68RJ1gR8YwLgd9py6ABY6/Hl1gR8YwLh1f62VOgHWmXzgYHWCHxjA uLXu20OdAOsMOGaSOsEPDGDsLrhZXQDrXHiLusATDGDs9n9dXQDrHPCGusATDGDs uCQWguJSWElhAGNXev8x6gRYpu+p89UJnmAA43cS1zVCMCc/rC7wBQMYv9PvURfA Mmfcqy7wBQMYPwYQATGASWEA48cAIiAGMCkMYFSa7N5js05NV1JnwGFffDPgXW4U EikGMAJFGx21S5fG6gr44esPnv6+Uh3hDAYwXx3POGBddQM88+vr93C1rEgwgPko 3vsM3ugLjQH3vMVF8/PGAIbXtc/+6gR47Y3LecNInhjAkJpffnRLdQO8N+WpPtPV DVZjAEPpfDc/+sIMA84crk6wGAMYQueHd1AnACt8fBITGBYDGFirh3nqD2Z546TJ 6gRLMYABlV7YW50A1NH7Zq4fEwYDGAwX94OZuIRgKAxgECUXXKtOADK44pYydYJ9 GMAAmj+xnzoByOjN4zglJigGMHedBnRUJwBZjOoxUp1gGwYwZ/v0UxcA9di3v7rA MgxgjoqOfUSdANTrxCe5UkwQDGBuCv/O/sEGJz5epU6wCQOYE/YPtmABg2AAc8H+ wR4sYAAMYC4OekVdAOTs4FfVBfZgAOtXcv516gQggMtu5ZToHDGA9es6TF0ABLIJ b4vLEQNYr/a/qwuAgNYcqy6wBANYn8b3HKtOAAJ68oy56gQ7MID12eNtdQEQ2J7v qAvswADWo8NodQEQwlpj1AVWYACza3z/UeoEIISnT+WH4BwwgNnt/7q6AAjlgDfU BTZgALNaY5y6AAip3Xh1gQUYwGyKL7tSnQCEdM115eoE8zGA2azL7QZhr86/qgvM xwBm0eTZfdQJQGj9j5itTjAeA5jF1oPVBUAeun+uLjAeA5hZ66/aqROAPIzbYpI6 wXQMYGa8BwSW4/0g9WEAM+IUGFiPU2HqwQBmUnTWreoEIE/n38U9krJiADPp+Ju6 AMjb2qPUBWZjADMovesEdQKQt0fPmq9OMBoDmEGnEeoCIALrjFQXGI0BTK/0gaPV CUAEnjqFbwGzYADT4zKAcAQXBsyGAUyruM+F6gQgEjdfzjURMmMA02o9UV0ARKQN bwfJjAFMizeBwBm8HSQLBjCdJv/dTZ0AROS9nlwUJiMGMB3OgYFDOBMmMwYwjaYf bqJOACIzbOeZ6gRjMYBpcBkEOIVLImTEAKbB24DhFN4QnBEDmEa3b9QFQIQ2G6Iu MBYDWFfzz9dRJwARGrH1dHWCqRjAungKEI7hScBMGMC6eB8wHMP7gTNhAOvqOkxd AERqk2/VBaZiAOtoMmArdQIQqS968GaQ9BjAOrgQApzDBREyYADraP+7ugCI2Jpj 1QWGYgDr4DUQOIdXQTJgAOvY5X11ARCxXT9QFxiKAayt6eAu6gQgYr9053oIaTGA tbX9Q10ARG71CeoCMzGAtfEaCBzEqyDpMYC18RoIHMSrIOkxgLXxPhA4iPeCpMcA 1tLkI64GDfcM25H3gqTDANbC+0DgJN4LkhYDWAvXwoKTuCJWWgxgLbwIDCfxMnBa DGAtvAgMJ/EycFoMYKrSF/ZVJwAx6HfofHWCiRjAVC1+bKlOAGIwZYOp6gQTMYCp eCMcHMWb4dJhAFPxIjAcxcvA6TCAqXgNBI7iVZB0GMAUhYc9o04AYnHk81XqBAMx gCmafLaBOgGIxY/b8Ga4uhjAFK14vxBc1XqyusBADGAKXgSGs3gZOA0GMAUvAsNZ vAycBgOYYqcP1QVATHYeqC4wEANYU/E1F6kTgJjcdGW5OsE8DGBNzb9bXZ0AxOSP jaerE8zDANbEi8BwGC8D18UA1sSLwHAYLwPXxQDWxHeAcBjfAdbFANbEd4BwGN8B 1sUA1sRpgHAYJwLWxQDWxADCYQxgXQxgDSVPHKpOAGLzwnFl6gTjMIA1NBm4qToB iM3QnbgeTG0MYA3Nf+aGIHDXlPU4E7o2BrAGzoKB0zgPpg4GsAbOgoHTOA+mDgaw Bl4EhtN4GbgOBrAGBhBOYwDrYAD/UvLY4eoEIEbPHc95MLUwgH9p/N5W6gQgRl/s NledYBoG8C9Nv2unTgBiNG7jmeoE0zCAf2kxRV0AxKrlVHWBaRjAv7SeqC4AYtWG M11rYQD/wmmAcBwnAtbGAP6FAYTjGMDaGMAVim88T50AxOq2i7kxXCoGcIXSF/ZV JwCx6nfofHWCYRjAFZp8spE6AYjV99txQaxUDOAKTX9ppU4AYjW5CycCpmIAV+A0 QDiPEwFrYQBX4DRAOI8TAWthAFfgLBg4j/NgamEAV2AA4TwGsBYGcLniPheqE4CY 3Xw5JwKmYACXK3nuQHUCELPXDueKgCkYwOUaf8w9MeG6oTtwRcAUDOByTWeoC4DY NeNEwBQM4HKcBggPcCJgKgZwOU4DhAc4ETAVA7gcAwgPMICpGMDlOA0QHuBEwFQM 4HIMIDzAAKZiAP9U8ugR6gQgds+ewImANTGAf2o8eEN1AhC7H7pzImBNDOCfOA0Q XuBEwBQM4J84DRBe4ETAFAzgn1pxegB80HqyusAoDOCfOA0QXuBEwBQM4J8YQHiB AUzBAP6JAYQXGMAUDOCfGEB4gQFMwQAuU3zrGeoEIAH3nM81oWtgAJcpfXMXdQKQ gA/2m69OMAkDuEyTIWurE4AE/NZttjrBJAzgMrwRBJ7grSA1MYDL8EYQeIK3gtTE AC7Di8DwBC8D18QALsMAwhMMYE0M4FLFd56iTgAS8cDZnAfzFwZwqdK3dlQnAIn4 aG/Og/kLA7hMyePrtGutjgDitXDmuBF/55LQNTCANZWcv0nnNVqqK4CoVcwcP3zY rUxfHQxgGiUXbbTu6uwgHFAx849fv7+J5cuEAcys9MIN123Lz8WwUvmMCb/+cDNP 99WDAaxf8/s6rrG6OgLISXXZjPGjTpuuzrAFA5iz5jes06GTOgLIYNHcqWNGXMLy BcMABtX0vPU7rs43hDDF4m/5/hj10228wzcUBjCsFhetu1YbniGESvXCWRNH/3oT 7+zNCwOYr1YXrr1mm3bqCnhj0YKZE3//7WZu7hYJBjAya/Ruv0ZLviVEPKoWzp4y fmzv8eoOxzCA0etwZbs2LduqK+CERWWzp0wcd80YdYerGMAYtT+9fbtWzfmmEEEt Kps7ffK4sfeOVYc4jwFMRPuT2rVrvRrPFCKL6sr5c6ZNGjfuYWYvOQxg0jqdvHqb lk3XUmfADFXl82fPnDLxj4dGqkv8xAAqrXdiq9arNVullboDSaquXDh/zoxpkyY/ 8rM6BQygMboev1qL1Zo25hxrBy2qKJs/d+a0qdMe+1adghQMoKE2PbxZi+ZNV1m5 jToEIVQvqly4YN6cmdOnznhuqDoGWTCAlti2V5PmTZusUtqoYYNidQtqqa5aVLFw wfw5s2dOn/3ip+oaBMAAWmungxs3ada48eJJLG6w0kr8QSaletGiivLFczd37ozZ c18ZqM5BXvi6cUqPHqWrNlml0eJRXLyKRYtnkT/f8KoXT13l4q1bPHYL5syeNX/A AHURIscXiBcO3K5R6corr9yoZPEwNixa/A1jYWGhuskQVVVVi7+lq1y4eOjKFsyb N2/+gk9eUzchMQyg9w7q1nDl0tKSRg1LFn/XWFxcVFS0dB8d+eaxunrpwlVWVpaX L/5urmzhgrL58+ctHPKqOgxGcOOzHPE6Yp2GpSXFixeyqKS4qEHDxd9BLv7P4plc qfD/li5l0p9F1Ut3rbpq0eJpW/zt2+L/LKyoLC+rXLxv5WXzF454NuEeWIsBRPTO aN6osKSw0f+VFJb8X0HF1kU1Ps3+L+W/lqiu9d9L/lfl5w0KqsuqyqoXVJVVLZh+ TwLN8BIDCMBbDCAAbzGAALzFAALwFgMIwFsMIABvMYAAvMUAAvAWAwjAWwwgAG8x gAC8xQAC8BYDCMBbDCAAbzGAALzFAALwFgMIwFsMIABvMYAAvMUAAvAWAwjAWwwg AG8xgAC8xQAC8BYDCMBbDCAAbzGAALzFAALwFgMIwFsMIABvMYAAvMUAAvAWAwjA WwwgAG8xgAC8xQAC8BYDCMBbDCAAbzGAALzFAALwFgMIwFsMIABvMYAAvMUAAvAW AwjAWwwgAG8xgAC8xQAC8BYDCMBbDCAAbzGAALzFAALwFgMIwFsMIABvMYAAvMUA AvAWAwjAWwwgAG8xgAC8xQAC8BYDCMBbDCAAbzGAALzFAALwFgMIwFsMIABvMYAA vMUAAvAWAwjAWwwgAG8xgAC8xQAC8BYDCMBbDCAAbzGAALzFAALwFgMIwFsMIABv MYAAvMUAAvAWAwjAWwwgAG8xgAC8xQAC8BYDCMBbDCAAbzGAALzFAALwFgMIwFsM IABvMYAAvMUAAvAWAwjAWwwgAG8xgAC8xQAC8BYDCMBbDCAAbzGAALzFAALwFgMI wFsMIABvMYAAvMUAAvAWAwjAWwwgAG8xgAC8xQAC8BYDCMBbDCAAbzGAALzFAALw FgMIwFsMIABvMYAAvMUAAvAWAwjAWwwgAG8xgAC8xQAC8BYDCMBbDCAAbzGAALzF AALw1v8DAYRX4soBezsAAAAASUVORK5CYII="/></symbol><g mask="url(#b)"><g transform="rotate(.193) scale(.36014)"><symbol id="c" viewBox="0 0 1280 1280"><image width="1280" height="1280" xlink:href="data:image/png;base64, iVBORw0KGgoAAAANSUhEUgAABQAAAAUACAIAAACXhmigAAAACXBIWXMAAA7EAAAO xAGVKw4bAAEJ3klEQVR4nOzd6XscRZrvfak21V4lyZJss5ulG2gaDHQDZh3o6YVu uj0MewPzN54Xc2bOzHnmug4Gs0MDxgs22JK1b7WolszKpZ6oSlsIG9taIiojM7+f i1YbY24FtiorfoqIO4aHAAAAAACIgGG/BwAAAAAAwCAQgAEAAAAAkUAABgAAAABE AgEYAAAAABAJBGAAAAAAQCQQgAEAAAAAkUAABgAAAABEAgEYAAAAABAJBGAAAAAA QCQQgAEAAAAAkUAABgAAAABEAgEYAAAAABAJBGAAAAAAQCQQgAEAAAAAkUAABgAA AABEAgEYAAAAABAJBGAAAAAAQCQQgAEAAAAAkUAABgAAAABEAgEYAAAAABAJBGAA AAAAQCQQgAEAAAAAkUAABgAAAABEAgEYAAAAABAJBGAAAAAAQCQQgAEAAAAAkUAA BgAAAABEAgEYAAAAABAJBGAAAAAAQCQQgAEAAAAAkUAABgAAAABEAgEYAAAAABAJ BGAAAAAAQCQQgAEAAAAAkUAABgAAAABEAgEYAAAAABAJBGAAAAAAQCQQgAEAAAAA kUAABgAAAABEAgEYAAAAABAJBGAAAAAAQCQQgAEAAAAAkUAABgAAAABEAgEYAAAA ABAJBGAAAAAAQCQQgAEAAAAAkUAABgAAAABEAgEYAAAAABAJBGAAAAAAQCQQgAEA AAAAkUAABgAAAABEAgEYAAAAABAJBGAAAKTJ5/PiY6PR2N2/uLt/FwAAbBMBGACA 3RCRdTgWG+4T/5dKpdxuNxaLiX/U7XbFR/Hz2yy19dd3XVf8yOp0RDXx424fqRgA ACkIwAAAXE9vbXZ4eDPoitCbSiZFYPWy7gB4GVh8RtuyRCS+lIlFKt7YGMwAAAAI DQIwAAA/6q3r9lPupaybSnUvr+tq5XIK7tq23QvFrBUDALANBGAAQHRtjbuxeDyR SHgrvX6Pa5f6m6ZdIjEAANcS1Pd4AAB2wTu460mmUsM7OakbRJcisWU5lyMxeRgA EGVhftcHAEDIFwpe4h1JpYaCvMC7dyIMi48d03T7CMMAgKiJ7iQAABBivdA7PByP x5OplIYneHXQ7a8Odzodb3GYMAwAiAICMAAgPPL5vAi92VzOdd0or/TulPjtsizL 6R8eJgkDAEKMyQEAIPBE7o3FYolkD7l3L1xvTdi2N7hjCQAQRswSAAAB5i35pkZG xEe/xxIe3rXD7VZro173eywAAMhEAAYABFIv+iYSIyMjHPFVxOsgbRpGnRgMAAgL AjAAIHiKxeJIOs2q7wCIGGwJnQ6bogEAIUAABgAESb5QSCaTIyMjfg8kWnpLwabp 2DYtsgAAgUYABgAERqFYTLPw6xNvKbjT6TRYCgYABBYBGAAQDKVSKZ3J0OTZX67j tA2D5lgAgIBiGgEACIBSuZzJZPweBXocxzHIwACAYCIAAwB0R/rVDRkYABBQBGAA gNaKpVI2m/V7FLhSby90u01raABAsBCAAQD6KhSLIv1y7ldPnT56YgEAAoQpBQBA U/l8PpPN0vNZZ6ZhVCoVv0cBAMB2EYABAJoaHRvjvl/NuY5jmGa9VvN7IAAAbAsB GACgo0KxmMvl/B4FbsyyLNM02QgNAAgEAjAAQDv5fD6dySQSCb8HghvrdrumYVSr Vb8HAgDAjRGAAQDaofNzsFiW1TFNOkIDAPRHAAYAaGffxATLvwHS7XYNw6ixCAwA 0B4BGACgF07/BhFXIgEAAoEADADQC82fg8hxHJN20AAA7RGAAQAayRcKuVxueJi3 p+ARAbiyvu73KAAAuB5mGAAAjRSLxSz7n4OJ+5AAAPojAAMANML+5+BiFzQAQH8E YACALvL5fDaXi8Vifg9kB1zX7Xa78Xg8lUqNpNM/8yvEP978gfjh8HC3/+NLP7fl x55EMmm0Wh3L6jqO+MXB+t0wDKNaqfg9CgAArokADADQRaFQyOXzfo/imkTWHR4e jidERE2KoC5GWxodVXpfsQjMrWazWq026vV2q2WapuM4wxqnYnpBAwA0RwAGAOii VCplVObJ7esv1nZF0hX5tlgqTUxMHLzpplK5LP7R3NycyHg+jk3k8GajUVlfF6m4 1W5bltV13Xg87uOQNonBdExzgwAMANAVARgAoAsfDwCLVBmLx7OZTHlsbP/+/Tff euu1lnZnZmYcxxnw8K5PZHWj3V5dXa1Xq61mU6TQWCzmSydtjgEDADRHAAYA6GLf xEQikRjM5+qfxx0SiXdiauq222676ZZbtpkYz58/r3pse2fb9urKyvrKSqPREKF0 YFume1HcMGrV6mA+HQAAO0UABgBoIZ/P5/J51euWrutms1kRd395772FYnGn/7oI kzMzMyoGpo74T25sbMzNzopc2nVd1WHYNIwKfbAAALoiAAMAtKC0A1a3202PjNz7 q1/94t5795KxO53O3NycxIENmBj/xenplaUldd9o6HXBMs1Go6GoPgAAe0EABgBo oVgqqeuofO/99z94+PDe67Tb7cXFxb3X8ZeIqGdOnmw1myqK0wcLAKAzAjAAQAvl cjmdyaio3O12X3njjWQyufdSjUZjZWVl73V8Nzc7Ozs9raKybdumCMD1uoriAADs EQEYAKAFpS2g33j7bSl1arXa+vq6lFL+WltZ+e70aRXngWkEDQDQGQEYAKCF8X37 pCzSXi2by/31X/5FSimRfmuhiHYioJ48cULFJMB1XRGAaQQNANATARgAoIWJycl4 PK6i8sGbb37mueeklFrpXywkpZS/2q2WCMC2ZakobhhGlUbQAAAtEYABAP5TegfS g4cP33v//VJKLS4uttttKaX8Zdv2mZMnG2paVXETEgBAWwRgAID/8oVCXtkdSH94 8cXRsTEppebm5jqdjpRSvjv//ffLajpam6ZZCcVJaQBA+BCAAQD+U3cJcLfbfePt t2WtLc/MzDiOI6WU7+ZnZy+qaQTNVcAAAG0RgAEA/isWi9lcTkVl13XfevddKaVE lr5w4YKUUjpYXlz8/uxZFY2gO32K9lcDALAXBGAAgP+KpVI2m1VRWbzPvS7pDiTH cWZmZqSU0sHaysqZU6dUNB6zLKtjmhsEYACAfgjAAAD/lcrlTCajonIimXzl9del lOp0OnNzc1JK6aCyvn76229VrADbtm2KAFyvS68MAMAeEYABAP4rj46m02kVlXP5 /EtHj0op1W63F9V0jfKFuquAnX4ArhOAAQD6IQADAPw3OjY2MjKiovK+iYnf/eEP UkptbGysrq5KKaWDZqNx8ptvXNeVXtlxnF4ArtWkVwYAYI8IwAAA/42Nj6dSKRWV b7399iNPPSWlVLVaDdP1tka7ferECRW3OolQbRpGjQAMANAPARgA4L+p/ftl3VR0 hV/ce+/hRx6RUmptbS1M23o7pnn65Ml2q6WiuAjAYfpmAQAgNAjAAAD/7T9wQFHl R37727vvuUdKqeXl5WazKaWUDmzb/u706Q0167QEYACAngjAAACflcvltJoW0MJz L7wgK10vLCwYhiGllA663e73Z8+urayoKE4jaACAngjAAACfjY2NJVMpRVug//ov /5LN5aSUmp2dtSxLSilNTJ8/vzg/r6IyfbAAAHoiAAMAfLZv375EMqmicrfbffOd d2RVm56eVtEz2UdzItNPT6uoLH7nDcOoVasqigMAsGsEYACAzyYmJ+PxuIrKqZGR l199VUopEX2n1WRFH1XW109/+20sFlNR3Gi3qwRgAIBmCMAAAJ+pawF94ODBZ59/ Xkopy7JmZ2ellNJHq9k8eeKEY9sqihuGUaUPFgBAMwRgAIDP1AXg+x544NcPPiil VLvdXlxclFJKH51O58zJky01ra0JwAAADRGAAQA+UxeA33j7bVmlGo3GipqGyf6a u3hxdmZGRWUCMABAQwRgAICfSuVyOp1WEYBd133r3XdlVatWq6G82HZ+dvaimrPN tmWZnQ43IQEAtEIABgD4aXRsLKXmDiS3231LXgvotbW1ehiz3PLi4vdnz6rog8VN SAAADRGAAQB+Gt+3L6nmDqR4PP7qm2/Kqra0tNRqtWRV08fa6up3J0/GFHThdl1X BGBuQgIAaIUADADwk7o7kHL5/EtHj8qqNj8/L+KcrGr6EAH11IkTis5gcxMSAEA3 BGAAgJ/UdcDav3//c7/7naxqMzMzjuPIqqaPVrP57TffuGr+0+iDBQDQDQEYAOAn dQH4F/fee/iRR6SU6na7Fy5ckFJKNx3TPPXtt0a7raI4ARgAoBsCMADAT4G4A8m2 7YsXL8qqppvZmZk5Nf91BGAAgG4IwAAA36i7A2lIagAWQW5hYUFWNd2oC8CWZXW4 CQkAoBMCMADANwrvQJJ6CXCz2VxeXpZVTTeLCwvnz53jJiQAQBQQgAEAvlF3B9Jw LPb6W2/Jqlar1dbX12VV083qysp3p06p6MXduwnJMGoEYACANgjAAADfqLsDKZPN /u3ll2VVE+k3xCmuWqmc+vbbmIJ1+G63a4gAzE1IAABtEIABAL6ZnJpSsfN2qB+t X/j972VVW15ebjabsqrpptFonPrmG9d1VRSnDxYAQCsEYACAb9S1gL77nnse+e1v ZVVbWFgQQU5WNd2YpnnqxAlTzX8gARgAoBUCMADAN4G4A0m4ePGibdsSC+qGm5AA ABFBAAYA+CYQAbjb7U5PT4uPsgpqiAAMAIgIAjAAwB+jo6OpkRH970ByHGdmZkZW NT0tzM9P//CDij8Lx7Z7NyFxFTAAQA8EYACAP8bHxxPJpP4rwCK/zc/Py6qmp5Xl 5bOnT3MTEgAg9AjAAAB/TExMxBMJFZXT6fTRV16RVa3ZbC4vL8uqpqfK+vqZb78d VtCRm5uQAABaIQADAPyh7g6ksfHx3//pT7Kq1Wq19fV1WdX0tFGvn/r2266im5Da 7SoBGACgBwIwAMAf6jpg3XHo0GNHjsiqtra2FvojrCKjnjpxotPpKClOHywAgDYI wAAAfwSiBbSwtLTUarUkFtTTxenp+dlZFZUJwAAAfRCAAQD+CEoAnpubU7Q0qhUC MAAgCgjAAAAflEdHR4JwB5IwPT3tqjkcq5X5ubmZ8+dV/InYtt3hJiQAgB4IwAAA H4yNjyeDcAeSiL4iAMuqprPlxcVz332n6CYkwzDq3IQEANAAARgA4IN9ExMJNXcg pVKpl197TVa1TqczNzcnq5rO1tfWzpw8qaIvNzchAQD0QQAGAPhA3R1IpXL5T3/5 i6xqrVZraWlJVjWd1Wu1UydOKCrOTUgAAE0QgAEAPlDXAevW228/8tRTsqrV6/W1 tTVZ1XTWbrVEALYsS0Vx+mABADRBAAYA+CAoLaDX19drkTm8SiNoAEDoEYABAD4I SgBeXl5uNpsSC+qMAAwACD0CMABg0AJ0B9L8/LxpmhIL6mzu4sXZmRkVlW3bFr+N G9yEBADwGwEYADBo6u5A6na7b77zjsSCMzMzjuNILKizxYWFH86eVXETkvg9FAGY m5AAAL4jAAMABk3dHUiJZPKV11+XVU3E6QsXLsiqpr+1lZUzp06pCMDchAQA0AQB GAAwaJOTkzEFKUsoFosv/vWvsqo5jjOjZkuwnkRAPX3ixJCas9ntdpsADADwHQEY ADBo6jpg3XTzzU8/95ysap1OZ25uTlY1/bWazZMnTji2raI4fbAAADogAAMABi0o LaBbrdbS0pLEgvqbuXBhQU3mJwADAHRAAAYADFpQAnCtVltfX5dYUH8EYABAuBGA AQADVS6XR9LpQNyBtLKy0mg0JBYMhOPvvaeiD5ZgmqbV6UTwtxQAoA8CMABgoEbH xlKpVCDuQIrUJcCbPjx2bLhPemXLssTvZ2NjQ3plAAC2iQAMABio8X37ksmkisrx ePzVN9+UWHB6etp1XYkFA+Gzjz6ybVtFAHYcp91uE4ABAD4iAAMABkrdAeBcPv/S 0aOyqkXtEuBNX33xRbvVUvRn1GyI/EsABgD4hgAMABgodQF4/4EDz73wgqxqrutO T0/LqhYgZ8+cWV1ejsViKooTgAEA/iIAAwAGSsRURZV/ed99Dz38sKxqlmXNzs7K qhYg83Nz0z/8QAAGAIQSARgAMDj5QiGfzysqLvcOJMMwFhYWJBYMEHWNoJvNZtd1 aQQNAPALARgAMDhj4+OpVEpFZektoEVIW1lZkVgwQNQFYBpBAwD8RQAGAAzOxOSk omQlvPzaaxLT9fr6eq1Wk1UtWNQFYNd1W60WARgA4BcCMABgcCanphQdLhXJ6q13 35VYcHFxsd1uSywYIB++915M2fcpOAYMAPARARgAMDjqWkBLD8DRvATY8+GxY8N9 KooTgAEAPiIAAwAGR10LaJHWXv/732VVi+wlwJ6Pjx/vui4BGAAQPgRgAMCAFAqF nLIW0KLyS0ePyqoW2UuAPV998UW71VIUgFvNpksjaACATwjAAIABKZVKmWxWUfHH nnjijjvvlFXNtu2LFy/KqhY41Url1IkTik5rG4ZhWxYBGADgCwIwAGBARsfGRkZG FBWX2wLaNM35+XlZ1YKIm5AAAKFEAAYADMi+iYlEIqGisvQOWM1mc3l5WWLBwFHX B4ubkAAAPiIAAwAGRN0dSIl4/JU335RYsFKpVKtViQUD59OPPnJsmz5YAICQIQAD AAZE3R1IpVLpTy+9JLHg0tJSq9WSWDBwvv3qq3q9rugbFgRgAIBfCMAAgEFQ2gL6 jkOHHjtyRGLBmZkZx3EkFgyc6fPn52dnFQXgVqvlOg59sAAAg0cABgAMQqlczmQy ioofefrpW2+7TVa1iF8C7Nmo10989RWNoAEAIUMABgAMwtj4uMQuzVd45fXXE8mk rGoRvwR4E42gAQDhQwAGAAyCwhbQ3e5b77wjsaCIZ7OzsxILBhSNoAEA4UMABgAM gsIW0InEK2+8IbFgu91eXFyUWDCgPvv4Y9uyaAQNAAgTAjAAQLl8Pp/L5xVFqfLo 6B///GeJBUUwW11dlVgwoE5+802tWqURNAAgTAjAAADlCsViLpdTVPyuu+9+9LHH JBYU6ZdsJlycmZmdnqYRNAAgTAjAAADllLaAfurZZ2++5RaJBefm5jqdjsSCASXS 6TdffqkoAJuGYdEIGgAwcARgAIBy6lpAd7vd1956S2KzYu5A2urDY8cUBWDbsgwa QQMABo4ADABQbmJyUtGFOl3XffPddyUW5A6krT56/33xUVEj6HarxVZzAMCAEYAB AMqpawGdTKX+9bXXJBa0bfvixYsSCwba5598YnU6NIIGAIQGARgAoFZeKBQUFR8b H//9n/4ksaBhGAsLCxILBtqpEyeqlQqNoAEAoUEABgCopbQF9D2/+MXDv/mNxIKt VmtpaUliwUCbu3hx5sIFRQG43Wo5NIIGAAwWARgAoFa5XE4rawH97PPPHzh4UGLB SqVSrVYlFgy0Vqv11WefxdSc3zZNs9cImkVgAMAAEYABAGqpawHtuu6b77wj94Qq dyBd4fh77ylqYGbbtmEYBGAAwCARgAEAailsAd3tigAstyB3IF1BXSNo8bvdbDYJ wACAQSIAAwDUmtq/X1Eb4dTIyMuvviqxIAH4al98+mnHNGkEDQAIBwIwAEAhpS2g 901M/O4Pf5BYkEuAr3b65MnK2hqNoAEA4UAABgAoVCwWs8paQP/yvvseevhhiQXb 7fbi4qLEgiGwMDd34YcfVDWCbrcd26YRNABgYAjAAACFyqOj6XRaUfEXfv/7iclJ iQVrtdr6+rrEgiFgmubnH3+s6BR3xzQ7NIIGAAwQARgAoND4vn3JZFJFZdd133r3 Xbk1l5eXm82m3JohQCNoAEBoEIABAAqpawEtvPH223ILcgfSz/r4/fe7NIIGAIQC ARgAoJC6FtDpdProK6/IrTk9Pe26rtyaIfDlZ5+ZhkEjaABACBCAAQCqKG0BPTk1 9fw//7PEgtyBdC3fnT69trKiqhF0s7lRr6uoDADA1QjAAABViqVSNptVVPz+Bx54 4MEHJRa0LGt2dlZiwdBYXFg4f+6cwkbQjsMuaADAYBCAAQCqKG0B/YcXXxwdG5NY kDuQrsW27U+OH1fVCLqPAAwAGAwCMABAlWC1gK7X62tra3JrhsaHx44pWgF2HKfd bhOAAQCDQQAGAKgyOTkZU7NsKN69XpfdAnp9fb1Wq8mtGRofHz/edV1FjaBbzSZ9 sAAAg0EABgCooq4FdCab/dvLL8utySXA1/GPzz9vt1qq+mDRCBoAMCgEYACAEvlC IZ/PKyp+4ODBZ59/Xm7N+fl50zTl1gyNc2fOrCwv0wgaABB0BGAAgBJKW0A/ePjw vfffL7fmzMyM4zhya4bG6vLy2TNnFAVgo922bbvRaKgoDgDAVgRgAIASo2NjIyMj ior/5ehRucvLrutOT09LLBg+x997T1EjaKvTMWkEDQAYCAIwAECJffv2JYLTArrT 6czNzcmtGTIfHjs23Ce9Mo2gAQADQwAGACgxOTWlaMfscCz2+ltvya3ZarWWlpbk 1gyZT48fd9Q0gh6iDxYAYFAIwAAAJdS1gM4XCn/529/k1uQS4Bv65h//ECGVRtAA gEAjAAMA5FPaAvqW22578umn5dbkEuAbOv/994vz84oCcKvZdF2XPlgAANUIwAAA +UqlUkZZC+jfPPbYnXffLbcmlwDfULVSOfXNNzE1fbAMw7AtiwAMAFCNAAwAkE9p C+h/efVV6cW5BHg7FDaCtizx+08fLACAagRgAIB8+yYmEomEisoqWkAPcQnw9nx0 7NiQmkbQ4o+13WpxDBgAoBoBGAAgn7oW0Il4/JU335Rbs9vtXrhwQW7NUPrs449t y6IRNAAguAjAAADJ8vl8Lp9XFJNK5fKf/vIXuTUty5qdnZVbM5ROfv11rVajETQA ILgIwAAAyQrFYi6XU1T80F13/fbxx+XW5BLgbbo4PT07M6MoALdbLcdx6IMFAFCK AAwAkKxcLqczGUXFn3r22ZtvuUVuTS4B3qZmo/HVF18o6oNlmqZlWfTBAgAoRQAG AEg2Nj6eSqVUVO52u6+99Zb0AMYlwNunrhG0bduGYRCAAQBKEYABAJJNTE4qykiK WkBzCfD2ffTBB0PdrooD3t1ut9VscgwYAKAUARgAINnU/v2KOmClUqmXX3tNelku Ad6+Lz/9VPxe0QgaABBQBGAAgEx5oVBQVHzfxMTv/vAH6WW5BHj7zpw8ub62pqoR dLO5Ua+rqAwAgIcADACQqVgqZbNZRcXvvf/+Bw8flluTS4B3ZHF+/vz336tqBN1u 9xpBswgMAFCGAAwAkGl0dHQknVZU/Hd//OO+ffvk1uQS4B3pdDqfffSRojPenT4C MABAHQIwAECm8X37ksmkisqKOmC12+3FxUXpZUPsw2PHFK0AO44j/jgIwAAAdQjA AACZJqemFKWjoeHhN/7+d+lVNzY2VldXpZcNsY+PH++6Ln2wAABBRAAGAMikrgV0 Jpv928svSy9bqVSq1ar0siH21RdftJpNVX2wCMAAAJUIwAAAaQqFQi6fV1T8wMGD zz7/vPSyXAK8U+e++25laUlRAG61Wq7jNBoNFcUBACAAAwCkKZXLmUxGUfGHHn74 l/fdJ70slwDv1OrKytlTp2Jq+mCZhmHZNseAAQCKEIABANKMjY+nUilFxV86elTF 8jKXAO/C8ffeU9QI2rYswzQJwAAARQjAAABpJiYnFeUiRS2gRdnp6WnpZUPvw/ff H+51JZM/ixB/Iu1Wi2PAAABFCMAAAGnUdcASufrVN9+UXrbT6czNzUkvG3qffvSR Y9s0ggYABA4BGAAgR75QyCvrgFUqlf700kvSy7ZaraWlJellQ+/k11/XajVVjaCb zY16XUVlAAAIwAAAOdTtfxae+ad/OnjTTdLL1uv1tbU16WVDr9Vq/eOzzxT9cXe7 3ZbIwCwCAwAUIAADACTI5/O5fF7RnlhFB4AFkX7rLDbuyvFjx+JqVoCH2AUNAFCG AAwAkKBYLGZzOUXF44nEq2+8oaLy0tJSq9VSUTn0Pv/4Y8uyFH3Lo91uO7bNbcAA AOkIwAAACUbHxkZGRhQVn5yaev6f/1lF5bm5uU6no6Jy6J09c2Z1eVnRMWARrU0u QwIAKEAABgBIoPQA8G8ff/zQXXepqDw9Pe26rorKoVerVr/9+muOAQMAgoUADACQ QN0FSCKgvv73v6sIWo7jzMzMSC8bHcffe0/ddz04BgwAUIEADADYq0KxmFN2AFjk ahGAVVQ2TXN+fl5F5Yj49Phxx3VVHQNutRzH4RgwAEAuAjAAYK+UHgAuj47+8c9/ VlFZhKuVlRUVlSPi5IkTtUpF1THgTsfsdDgGDACQiwAMANgrpQeAH3jwwfsfeEBF 5Wq1WqlUVFSOiJXl5bOnTyv6o3ddt91qsQsaACAXARgAsFfqDgALR195JZ1Oq6i8 srLCDts94hgwACBYCMAAgBsrl8vDsT6RdPsf1CXeK7zx9tuKKi8sLBiGoah4RHz8 wQfdbncAXwzdy1zX7f+va9s2G6QBADtFAAYAXFIeHfXybexyxB1Yyr2WQqHw57/9 TVHxixcvihClqHhEnPjqq416XdEx4G3qbtGPxl3LssjGAICfRQAGgAgplcubq7je /w/12yz7Pa5r+sW99x5+5BEVlUVMunDhgorKkbIwP3/h3LmYsl3QeyT+lIcuJ2SW jgEAQwRgAAif3kLu5ZCryULurr109Ggun1dRudPpzM3NqagcNUqPASvlxWNv0dj7 aFsWp44BINyCOiUCgCgrFouXcu2Pq7kxf7ehqiACyZvvvKOoeKvVWlpaUlQ8Uj5+ //2u3vsIdsGLxJ6t+6tZOgaAoAvV2xUAhMnWlLspZDHj+nL5/EtHjyoqXqvV1tfX FRWPlG/+8Q8RC8P3/ZdruRSGHce9vG5MNgaAAInQRAoA9FQsla7IuYHetCzR3ffc 88hvf6uo+OrqKptdpZibnZ354QdtjwEP0qV143427vazsUMwBgDNMMECgAHxgq4X cEVaiNpy7i78+a9/LRSLiopzB5JEwT0GPBjeKrHjON3LB44JxgDgF+ZeACCZyGyb Hai8oBud3aESKT0APMQdSFJ99MEHQwO5DThkflwxvryXmq3UAKAa71UAsHu9Y7pe 0BVY1JUqk83+7eWXFRXnDiS5vv7yy2ajwTd6pNg8Y+z0721iHzUAyMVEDQC25cd1 3V7UJesqd+jOO3/7xBOKinMHklwXZ2Zmp6cJwEp5a8XO5duMWSsGgN1h9gYAP6NU KomsOzIyImaZZF1f/PHPfy6Pjioq3mw2l5eXFRWPIJHLPv7gA44BD9jm0eJL9zU5 Dn3dAOCGmNIBiDqvN1Umm3Vte6i/xOv3iNBb7Hrr3XfV1a9Wq5VKRV39CPro/feH QncbcBB5B4nFH0Sn06HbFgBcjTcqANEi4m6sv7QrpobDLO3qKp3JHP3Xf1VXf2Vl pdFoqKsfQV998UWr2eT7RxryFoq7Q0OJREL8GbFQDCDimPkBCK3NU7upVEpM/9if GSB3HDr02JEj6urPz8+bpqmufgRdnJ6enZkhAAeFt1Acj8UMw+BEMYBIIQADCAmv IXM2l7Mta5idzAH3+xdfHBsbU1d/enpazPjV1Y8g27Y/OX6cbzMF16W907FYxzT7 tzO5LBQDCCUCMIBAunRwN5NxHIcmVSGj+gCw+JqZmZlRVz+yOAYcMj+JxP2bmYjE AEKAdykAgVEul5OpFHE39FQfAG6324uLi+rqRxbHgEPv0mni4WGj1arX634PBwB2 g0kkgGCYnJoSH5lbR4HqA8Bi4r62tqaufmT1jgFPT8fYBR12Xgw2TbNWrfo9FgDY MQIwgAAoFIu5XM7vUWBAVB8AFumXxSsVOAYcKa7rtlotWmcBCBwCMIAAKJVKmWzW 71FgEFQfABYWFxfb7bbSTxFZHx47Ntzn90CgnOO6RqvFqWAAgcNbFIAAKI+OptNp v0eBQVB9AFiYmZlxHEfpp4gsjgFHh3gRmYbBZgoAgUMABhAAUwcO8LSKCNUHgF3X nZ6eVlc/4jgGHB3ipSQCcK1W83sgALAzTCkBBMDE5CQHCyNC9QFg0zTn5+fV1Y84 x3E+/uADXq1R0OuDZRhV+mABCBoCMADdFYrFbDbLqcIoEPHp7//2b0o/RaPRWFlZ UfopIu7DY8fYAh0RIgM3m036YAEIFiaUAHRXLJWydMCKBhGcXnvrLaWfghbQqn32 0Ue2bfMdqyhwXbdNHywAQcP7EwDdlcrlTCbj9ygwCOl0+ugrryj9FLSAVo0+WNHR C8Dt9gbfUQIQKARgALobHR0doQV0eLndbjKRyGSz+Xz+uRdeUP3paAE9AN+dPt3c 2LAsy3acGLcihVevEbRp1umDBSBQeE8CoLupqalhVpOCz3XdeCyWGhnJ5fOlUklp q+dr6Xa7Fy5cGPznhXDhhx826nWRl2zLEl8MsViMYBx0NIIGEES89wDQ3eTUFNsp A0TMicVbSyKZTGcyhUKhPDr60MMP+z2oSyzLmp2d9XsU+NH87KyIT0a73el0XMfp drsE4wChETSAIOI9BoDWaAGts96ibjw+0l/ULRaLvizq7kir1VpaWvJ7FLixmQsX 6tWqaZqWbYtgTCrWltvttmgEDSBQeDsBoDVaQOvA6SeQZCqVzWQKxeLTzz3n94h2 qVqtVioVv0eB3Tv//fe1atUyTfE16bJcrAHxp9BuNmkEDSBAeNsAoLVSqZQhAA+K dzIzkUxm0ul8f/fyg4cP+z0omWgBHUqL8/MiFYs/WavTsW17qNsdJhgPiuM4hmHQ CBpAgPD2AEBrIoOlaQEtmxd0k6nUZtD99UMP+T2oQaAFdKQsLSxUq1WjH4wt2+7S eUuBXiNow+BubQABwtsAAK0duOkmMW31exSB1GtGNTwcTyRGRkay2awIuk88+aTf g/ITLaCxaXZmplqpdEQw7nTEK4XmW7vGTUgAAodnPQCtHTh4UMxN/R6F7rwV3WKp lM/nS+VyyPYtyyJm6jMzM36PAlpbXlysVCoi0bUbDYcV423gJiQAgcNjHYDWpvbv ZwLqERPNoeHhRDye6q/oFgqFJ556yu9BBYlINfPz836PAoE0d/FiZX3dWzEWwXiI FePLut2uIQIwNyEBCA6e3QC0NjE5GY/H/R7FQIkJZdd1va3LQbleKBA2NjZWV1f9 HgVCZWFubn1tzTRNkY27jjM0fInf4xooEYCrNFcHEBzRekYDCJxwrwB7i7rJRCLT X9EdHR//9YMP+j2o0BLpl8taMABrKytra2vtVksEY8e2Q3/AmAAMIFhC+zgGEAKF YjGXy/k9CmlE3E0kEulMplgsju3bR9YdsLm5uU6n4/coEFFrq6siGLcup2KRh0Uq 9ntQcognm/jvavDdJQABQQAGoC8RFLPBDMDdvmQqlc/lxsbH2cPsO/HHMT09TUM1 aGV5cXF5aal3UZNlib8N6PZpAjCAYAnecxZAdBRLpWw26/cobqx34dDQUGpkJF8o jI+PP/rYY36PCFcSf0YiAPs9CuAGVpaXVxYXW/27i4Oyd1q8uNqtFucLAASF7k9V AFFWKpUy+gVgbxVRxN1isTi+b9/Djz7q94hwY51OZ25uzu9RADu2trq6LCJxq9Ux TT0jseM4hmFs1Ot+DwQAtkWvZygAbFUqlzOZjL9j8DYzJ5LJfC43Oj7+xJNP+jse 7E6j0VhZWfF7FIAEK0tLi4uLRqtlWZYOZ4l7K8DtNgEYQFAQgDGUz+eHhoc5vQMN lcvl9MADsJjMiQllJpstj44++0//NODPDkUqlUqVq0oRUosLC4vz86ZhOI4z+CVi VoChp3yhMNTtNhoNvwcC7RCAAehLRNB0Oq30U3gLvN5+5onJycOPPKL008EvKysr TIMQEZX1dRGJW82mZZpd9b21RAAW2btOAAYQEARgAPpSFIC9c3S33Hbbkaeekl4c elpYWDAMw+9RAP5YW12dPn9exFQV+6UJwACChQAMQF+KArCYron0+8xzz0mvDG1d vHjRtm2/RwH4Zm1l5dx333W7XemrwQRgAMFCAAagL0UB2HXdW2+//alnnpFeGXoS k/4LFy74PQrAT2urq99/913vzjbZAVjUNNptAjCAoCAAA9CXugB82+23P0kAjgzL smZnZ/0eBeAntQHYMOq1mtyyAKAIARiAvgjAkKLdbi8uLvo9CsBPBGAA8BCAAeiL AAwpNjY2VldX/R4F4CcCMAB4CMAA9KWuCdatt9/+9LPPSq8MPXEJMCACcK8JFmeA AUQeARiApvKFQjabVXFpR7fbPXjTTc8+/7z0ytDT8vJys9n0exSAn9ZWVs6eOaPi QmDxRDVNs1qpSK8MACoQgAFoSgTgfD6vorKYru0/cOCffvc7FcXhC/Fn6rqubdvO zxE/L36B32ME/LS6vHz2u+9iCgKwZ3FhQVFlAJCLAAxAU0oD8OTU1Au//72K4lDk Z5PtVn4PENDa8tLS9yIAK9hT4yEAAwgKAjAATYn0KzKwisoiAI+Nj//hxRdVFMfu dPtc191cs7Usy+4j3wJ7tzg/f/6HH1StAA8Pi/pKKgOAbARgAJpSF4CFYqn04ksv KSqOn+VtQnb7RKC1+uzLxE9u/hoA0s3Pzk6fP69qBZgADCA4CMAANKVuC7SQy+df OnpUUfEo+9mF3E6fF3EB+GJ2ZmbmwoV4PK6i+PDw8AIBGEBAEIABaErpCnA6nT76 yiuKiofV5hKu+MHmyVuRbzc/CizhAnoS6VdkYFUBOBZbmJtTURkApCMAA9CU0gCc TCb/9fXXFRUPqK1blL0l3M39yd76LQdxgeA6//33IqMSgAGAAAxAX/sPHFBUORGP v/Lmm4qK66m7xdb7gTbP4rJFGQix8+fOLczPKwrApmlW1tdVVAYA6QjAAPSlLgDH YrHX3npLUXFfeOu33vnbzRtxvWTrRVw2JwNR9v133y0tLhKAAYAADEBfU/v3D6u5 tEMUff3tt1VUVuSKfHvF+q3A+i2A6zh75szq8rKiLtCmYVQqFRWVAUA6AjAAfakL wCJJvvnOOyoq785mvr26hbLXRZl8C2Avzpw6tb66SgAGAAIwAH2FKQBvnr/19id7 Ni/Cpb8UAKUIwADgIQAD0JfOAXhzN/LmtUCbzaW8JdzNj94vkDVyANgFAjAAeAjA APQ14AC8uf1485ztFT/YikwLIEAIwADgIQAD0Je6ACzy6x9efPHqpVoVnwsAfEcA BgAPARiAvhQGYNd94umnVVQGAA0RgAHAQwAGoC8CMABIQQAGAA8BGIC+CMAAIAUB GAA8BGAA+iIAA4AUBGAA8BCAAeiLAAwAUhCAAcBDAAagLwIwAOxUd9PlO9vExx/O navXagRgACAAA9AXARgArvZjvu1/3Pxh99q3lM9cuLCxsUEABgACMAB9TU5NKZqu EYAB6OznI+6Wv91pwQvnzzcbDUVPVMMwqgRgAAFBAAagL3UB2HGcgzfffPuhQyqK A8ANXRFxf1zC3W3EvY5WszkzM+PYNgEYAAjAAPSlNADvm5y855e/VFEcAIYuR1xv 5fYnu5QVRNzrq9frsxcvigEpOlRCAAYQIARgAPqamJyMx+MqKospaLFUuv/Xv1ZR HEBEXL1LeetGZb9H96PK+vr83Nxwn4r6BGAAAUIABqAvdQFYzE7T6fRDjz6qojiA 0PAyres4P9mo3O16y7t+j267VldWFhcW1D1OTdMkAAMICgIwAH2pC8CCqPzo448r Kg5Acz9eFSTC7eVl20stlAMVbrdjaXFxZXlZYQA2jGq1qqI4AEhHAAagL6UBeGh4 +LEjR1QVB+CrrWduRcDteku4Az98q4n5ubn11dV4IqGiOAEYQLAQgAHoS2kAFlPg x598UlFxAKptvRnIdZxLQVf81f9nfo9OL3MXL1YqFXUrwIZh1AjAAAKCAAxAX+q6 QAtiovw4VwEDevNWbR0v317eq9wN3RZl1S7OzNSr1RgBGAAIwAB0pnQFWEymjzzz jKLiAHZkM+i6tu0t5LqR3KusyPSFC42NDUXfTxR/UqZpEoABBAUBGIC+lK4Ai6n2 gYMH77jrLkX1AWx1ueXUTy8N8hZ1CboqNRqN2ZkZ8cQjAAPAEAEYgM5UB+DRsbF7 f/UrRfWBqPnZiLv1b/0eYERVq9W5ixfVXQJMAAYQLARgAPqa3L8/pmbGNuRdBZzJ PPTII4rqA+FzRcTdbLNMxNXZ6srK0sKCogPAQ14ANoxaraaoPgDIRQAGoK+p/fsV LVl4uAoYuAIRN3wWFxdXlV0CPEQABhA0BGAA+tq/f/+QygAsPMZNSMBlIt9uEGNC Z352dn19XWlDQdM063zlAAgIAjAAfe0/eFDpfZ5iuv/4U0+pqw8ETp2TnKEzOzNT rVYJwADgIQAD0Nfo6OhIOq2uPjchAVfYqNe7ruv3KCDThfPnm42G0oaCBGAAAUIA BqCv8uhoWmUAHrp84lH8n5gdJlKp9MhIJpc7xN1IiKrmxobIM36PArtUq9Uq6+tW p2NbVu/g9tCQeLIp7aQg2LbdEQG4Xlf6WQBAFgIwAH2Vy+V0JuPLp+5eFovHU8nk SDqdzWa5NBih12o2RXbyexS4ARF0q5WKiJ3iD8vpr9gPIOhei+M4hmFsEIABBAQB GIC+SuVyxqcAfC2bwTgejydTqZGRkWwud8edd/o9LkCOdqtldTp+jwKX1Ko9vaBr 272V+f635PwKutdCAAYQLHo9QwFgq1KplMlm/R7FtnhXxXSHh+OxWDKZTGcyIhjf fuiQ3+MCdsZot0Xc8nsUkXMp6Pa3Los86X2LTbegey0impsEYADBEYxnK4BoKpZK 2YAE4GvxrlAVE1lvK3U6nc7m87fdcYff4wJ+nki/IgP7PYrQEkG3VquZ3tbl/llr H7cuy9JbAW63NzY2/B4IAGxLsJ+5AMKtUCzmcjm/R6HEFcF4JJMR/6UEY/jO6nTa rZbfowi8arVar9U6pmldDrq9F7uyPsz+Ev+B7Xa7QQAGEBAEYAD6KhQKuXze71EM 1GYw9s4YX1oxvv12v8eFqLBtu9Vo+D2KwKhWKvV6/VLQdV3xAg5x0L0W8chqtVoE YABBQQAGoK98oZCPWAC+liuC8Ug6zYoxVHAcp0mSuUplfX1jYyMiK7o75Xa7y4uL fo8CALaLAAxAXyL95vL5oB+QU2rrVuoDBw/eylox9kZ8PdHNqFatLi0sdPrXQYXg jK5qpmFUKhW/RwEA28UzHYDWJiYn4/G436MIkkuROBZLJhK964tzuTvvvtvvQSFI 6tWq30MYnNWVFRH4RdZ1LMt74Qz3+T2uwBAPHBGAq1H6mgEQdDziAWhtcmqKfYZ7 9+MO6kQilUplMplf3Hef34OCpjZqNfEF4/co5FtcXGxsbFidTmjaL+tAPFhEAK7V an4PBAC2i0c/AK2VR0fT6bTfowgtMXkVUScWjyf7VzTl8nnuLoZIiW4/IgbU2uqq d17Xtu3e933EXIesq4z4HTba7Xrkt80DCBDeDwBorVQqZQJ+FXDgbC4Xi1Tc20Sd zd55zz1+DwqD02o0RHT0exTbsry01Gw0zE7Hse3et3IIugPXuwTYMDg3DiBAeJ8A oLUQXwUcLJtHixOxWKp/tPjuX/zC70FBiXarZXU6fo/iSkuLi41Go9PfwCy+FuPx OFlXB9yBBCBwePMAoDVuQtKct4laRJFEIjGSydx+xx3JVA+ty4LLaLc7pjn4zyu+ kCzLch1ncXFRjKEXdPtfWnSl0trw8OL8vN+DAIAd4B0FgO4mJydjpKlgEvF4qN9P KSYCTH97qvhfaXT0nl/+0u+h4ZpMwxB/qai8MD9fq1a9b5ps9tki4gYXLaABBBHv NwB0d+Cmm7oiRyE0ut3HnnrK70HgmqxOp91qqah85tQp27bp6x4ajuOYplmnBTSA QCEAA9BdsVTK0gcrRLpDQ48/+aTfo8A12ZbVajZVVD598qTXX01FcQye47pGq7XB AWAAgcKbEADdFQqFHMeAQyQ2PPybI0f8HgWuyXGcpppIc/bMmU6nwwpweHS7jT6/ xwEAO0AABqC7fD6fyWZpqhQaIyMjDz36qN+jwDW5rttQc6vNhR9+aDabBODQMAyj Wqn4PQoA2BkCMIAAKI+OptNpv0cBOQql0n2/+pXfo8A1dbvdDTWnOhfm5tbW1vhm Vji4rmu023VuAAYQNARgAAHAbcBhMnXgwO2HDvk9ClyPCMCbXZolWl9bm5+bIwCH g9vttppNbgAGEDgEYAABkM/ns7kcOyfD4Zbbbjt4881+jwLX06jXXQWt1+v1+syF CwTgcGD/M4CAIgADCIYDBw+qWJLC4N15zz37Jib8HgWup9loOLYtvazRbp87e5YA HAJcgAQguAjAAIKhWCxm2QUdCvc98EChWPR7FLieVrNpW5b0siJUn/z220QiIb0y Bsx13Varxf5nAEFEAAYQDPSCDo2HHn10ZGTE71Hgeox2u2OaKiqf+PprXsUhwP5n AMFFAAYQGOVyOZ3J+D0K7NVjTz7p9xBwA6ZhiL9UVCYAh4DjOCIAb9D/GUAwEYAB BEahUMjl836PAnviuu4TTz/t9yhwAx3TNNptFZW/+frrBAE44LpDQ82NjUaj4fdA AGA3CMAAgmRyaope0IHmOs4Tzzzj9yhwA5ZltZtNFZVPfPNNnJdwkLmuaxpGjfZX AAKLAAwgSIqlUjab9XsU2D3HcY4QgLXn2HZTzfret998M9ynojgGwO12283mBu2v AAQW70AAgqR3IXA2G2MLZWA5rnuELdDac123oeaE58kTJ8RHAnBw0f4KQNDxDgQg YMrlciKZFBP0brcbu4z5dFCIP7XHn3rK71HgBsQf04aaPa6nT54UL15esIHQ7XP7 vOet+Emr06nT/gpAkPEOBCBg8vn8tZqvFEslb3dlbIsBDw/XJ/50fnvkiN+jwI3V q1UVZb87fdqyLF6YWtlMub2g28+64gc/u8k5329DSPsrAIFGAAYQfoViMbaZjMWH eJxFY7/E4/FHH3/c71Hgxhr1ukhB0sueO3vWNAwC8OBtXc71VnS9v21wmhdAxDD/ AxBpP1k07mdjOvQolUqlDv/mN36PAjfW3NhwHEd62fPff99qtQjA6lxKuY7jreRe ZzkXAKKJSR4A/IxCsdhLxZuLxkI/G/s9rsDLZLO/PnzY71HgxpqNhmPb0svOTE9v 1OsE4D3y1m8dx+luLuaynAsA28NkDgB2piiycX8HtReP4ywa70ShWLzvgQf8HgVu rNVo2AoC8NzsbGV9PU4j9+3ZejTXJeUCgAzM2ABADm/R+Md1Y7pw/ZzRsbF77r3X 71HgxlrNpm1Z0ssuLS6uLC8TgLe68miut2+52yXoAoAKBGAAUK7oZePYT6JxNBeN J6em7rjrLr9HgRtrt1pWpyO97Nrq6sL8fAQD8E+uFGI5FwD8E8XpF4LOu4ahR+SH bpf7GBBoXheu6Cwa33TLLTffeqvfo8CNKQrAtVrt4vR0iAPw1VcKOaRcBFxv3tWf cXl/y7wLQUcARgDkC4V+B6Le1TXif8Nbls62TjU2m17yaEYIhHXR+I677pqcmvJ7 FLgxo93umKb0sq1W64dz54IegLlSCCEm4u7WKwOvePfxvtadS9Mup16r+TtaYBcC P5dCiIncm4jHk6nUjqZK4slsWZZj23zTHWH1k6ubLk9NBPHFr39C/uX995fKZb9H gRtTFIDF8/n0yZOJREJ6ZYm6/ZUu7zV1xZVCvLMglLw1XpF344lEMpnc/luJyMBW p2M7Dq8LBIjuUyVEU6FQELl3R4/gq4mZim3bYrIl5i6sCSNSdN5W/eDDD6czGb9H gRszDUP8paLyia+/1mQF2Mu34oUi3inIt4gmEX3F67GXepPJXRfx1h5EEubGaQQC ARh6EQ9i8QhOjYxIXMgSz+WOaYowzHMZkSVeWb0M7L2urvi49QdbKBrJb554Qp80 jusQj02j3VZRWV0Avnwh7qWTisOxmC2Srfhb76e2fuzfMEQXCURWb5/z8LDIvalU StYD35tuiSDMywqaIwBDI8ViMZ1Ox5RNjKy+jXpdRX0gNPKFwo+t5qQSkeOJp59W UTlqxO+k6u8jBDEAt1otTiQC1+cd8c1mMsNqniGu4xiGUWeuBY0RgKGF3g6cREKk 3wGcYOxv0ukQg4FrKRQKOTUB2HGcI888o6LyjsZgmman/5fZ6djicWBZjmXZ4h/0 ewf0ehp5Zz6Het850/NYtUi/P1nt7I+yt+n9crNA8UTd3NaY7C/ypEb60ulthk/x oGy3WioGLwKwoo5uIgBz5gW4Fm8r0EgmE1f87TPxXBIZWDxReTFCTzq+ryNqetue +3OzQX7SXgjmsArwcwrFYi6XU1F5FwFY/CsiqVYrFfGUEFM3x4upl/V2dogQ29dr SNrPrk5/y+vmftehfisjr5p3LFr+f1igeAdfvR9v9k77cRt8P5v2QrIXquPxZCIR 67ff96J1ryN/PO7tqRFfJ+LZvdPl3G+/+UbRNnuR2B0CMHAVb9U3k8kM8gFomqZ4 PvN6hIYIwPCZL+nX0zus0lv7sWh5gtATL7Ttz0KKxWJWTQDe/hbozz/5xOtLRF7V n3cPkIjBdxw6tJ0OZydPnBi6fAhdrna77Wy7G623z5/ZOcLNO+srHum+bGYhA0NP BGD4rDw6mk6nfRyAmLeZhkEHf4TVLmb5xVIpm80qGxGgitFu2zvZdbl51p0JOkJJ fIUnkskRqY1Fd8owjGql4tdnB34WARh+0mee7R0L5PAYwmTXC1ylUimjxwsT2BEx 1e4F4B1+N5MYjPDpHfeNx3uNRTXYREN3OuiGAAzf5AsFkX51eDRv6p8L7rAUjKDb 497OUrmc4apeBJDpXcGy22c4m6IRAt6e54xO8yvXdUUGZnIFfRCA4Q/xgB5Jp/dy 67oitC5E0O19El8ul7dzkhPQTa+5997aOpCBEWj5QiGRSPi75/lnWZZlGgavLGhC r5cHokOfzc8/y7Zt8aSmRzSCRdbcnQCMgNrjCrCHHdEIIq/Pc3rb95wNHhuhoQ8C MHwgHtOZbFbbZ7Sn1xzLNG0xl2IOhIDYUavn6yAAI6CkBOAheS8lYDC8Zlf+thS9 Icdx2q0WryzogAAMHwSoxQ5LwQgKiVN2AjACSlYAHmIvNAJC/4XfrUQArrEIDA0Q gDFogVj+3erSPUmcCobG5C5Y0QQLASUxAA+RgaE978Sv5gu/W7EIDE0QgDFoxWIx m8v5PYodE5OqjmmyFAwNyZqmeysJ8Xg8lUrp0z4U2L5ut9vpdBzbdl1XyiSbDAw9 ea2e05lMgJYTPK1ms16v+z0KRB0BGIM2Nj4uptd+j2I3xIzKNAx270A3e1z+9XJv Ih5PknsRFiIJW5ZliyS8t9vdCcDQkPiyjPcXfnVr9bwdnU5nfW3N71Eg6oL3ykGg 5QuFXC4XxEf2pt5NwabJfAiaEK8pMdnfxRfk5npvMpkM3BoCsE2u69peEhYvk11t 4SEDQyu9eVQ2OxzYb1Z2u91ms8mdwPBXgHMIgkjz24+2yXEcwzA22MMDDexi+VfM n7x9zuReRIdIwr01Ycvq7vAbRgRgaEJ8KcZisXQmE/StOtyHBN8RgDFQo2NjIyMj fo9CAjGFEhnYoTMW/LajAFwoFhOJhIi+gd6FAeyF1bf9rdEEYOggcP2ursM0zcr6 ut+jQKQxB8LgiGlENpcL+ncut7I6HbPTYScPfLSdANw7MNY/4ivmT4MZFaA5x3G8 Q8I3fIATgOGv4Pa7uhbXdVvNJq8p+IgAjMEpFAq5/kwiTNgODR/dcGru7XYeGRkJ 0zeeAFm8rtE3vDmJDAy/hGbb8xVE/OVaDfiIAIzBCccB4KuxHRp+uc7yL9EX2CYv BtuWda0ZOQEYvgjTtucrcAwY/iIAY3DKo6OhfI576A6NwfvZAOzdkEH0BXbkOjGY AIzBE+k3m82G9TFuGEa1UvF7FIguAjAGJ7g3AG9Tbzt0u82uHgzM1QG4WCqJ6Bua o2LAgIkYbBqG7ThbN0UTgDFIYd32vBW3AcNfBGAMzsTkZOjn5b3t0O12jY09GIit AbhQKCRTqXB/jwkYDNu2O6bpuq73+iIAY2C8LTyZTMbvgajlOM7K8rLfo0B0EYAx IOKZnut3MvR7IINgmqbV6TBbgmpeABYfE4nESDodkdcXMBi9/lidDpt6MDD5fq/Q KDzHu91urw000yT4JAqvMmhBPNbzoWsBfR2WZYkYzA1JUEe8psQkYjgWS6fTod9b AfjiUo9DxxE/GmIRGMqE766jG+rFX+ZI8AkBGAMSyjuQrs913Xa7zQ1JUKS38JtM joyMsPALKMVSMJTqHfqNxzOZTKQe5tyEBB9F6JUGfxWKxVwu5/coBo0bkqBIvlAQ 0TeZTPo9ECASXNcVD3PXcXiYQ64Q33V0fc1mkxUC+IUAjAFRegnwobvu+v7sWW2/ dcqRYMhVLBbD3SAU0JPIwLZl8TCHLDrfddTtm5iaWllaUjFCrgKGjzQNDAifUqmU UROAE8nkK6+/Ln7w5eefnz55Us8YbNu2mDlx3AV7VyqX0/S7AnzS6eNhjj3S+dCv F30P3nzzbXfc4brupx9+qOKztFstrsyAX5hCYUDErF1RW3+Rq//28svej8Uj+9OP Pjp39qyG30/lSDD2SEyYkqnUyMiI3wMBIs2yLJGBeZhj17Q99CsmUWKuMnXgwJ13 3+39jPjbLz75pNcHTjYxI6pVq9LLAtuh1wsPIaYuABcKhT//7W9bf0bMTv7f//zP sppNO3vBLcHYNTFhEtmXa34BHYg8YBgGGRi74F1cl9bvpl+RdQvF4r2/+tXWRWnx k//47DMxrZL+6QjA8BEBGAOiLgAXS6UXX3rp6p9fX1//n//+b1vBU3uPTMOwOEWG nRATppF0mpZXsngb/LwfDQ0PD8disf4HMe2LJxK9D8mkmKGKj+L/UqlUMtVbefd7 1D8xMjLSMU1vO64l/rIsu/c/2xEfRDgTP3B7uo4j/kvF/4b7N2YN9/k99pAQv83i YV4nA2Mn9LwSUjwlxOPvV7/+dfaqZqXiMfLV55+L54z0T0oAho94I8SAlMtlRd/v LJVKf/q5AOz5+h//OPHVVzHNztiICWvvlmAyMLaB9LsdYpY21J/Gbf3JXtgbHp6Y mOglWE86PRK9hXSj1RLZuNv/LbJtu7d/1wvMliVSXGV9Xfx896cTAi8nE5ivr9ca ut0mA2ObRPrNaHbo19vzfMttt4m/fvYX9ALwF1+IKYv0Ty1eO1UCMHzCGxsGROEK cLH44l//ep1fYBjGf//nfzY2NrSayfV20LXbXIKH64ts+t08cuZlMDFlTI2MiBwr fitS/Y+9HJvuxdlkxNLsrnkz3R7H6X9w3O2d63Nsu+NlZvGhF6B7i8xekO6vMneH L+fn/lK6Ro/ZAWAdGNvRa3kVi2U0694vngniQfrA4cOJROJav4YVYIRStN6o4CN1 ATiXz7909OgNf9nZM2c+/eSTmE6TM9pi4foicu63n6G6iX6mFS/nYrFYHh3Vbctx KHmRuLdf2u65Yv18F0SdjUaj2WgY7baYMYtwOHyZlAHrifPAuD4NW155r/077757 6sCB6/9K8cu+/OwzFafJCMDwkS4vRYSeumuQ0pnM0X/91+38StM0/+9//me9Xtfq TUjMnHgPwNXC2vPZ26ss4m42my0Ui6NjY+Kj34NCz6Uw3F8f9laJpZTtbRLe2Gg1 m94lukNhXCi2bVu8v5CBcbV8odBreZVO+z2QH4mJhxjPA4cPb2cztsIu0FyDBP+E 6h0IOiuWSlk1AVhEhJdffXX7v/7MqVOfffKJVodwaIuFq6nbNDFgYua0GXfHxseJ uwHiLRP1VoYv9w1z+5ufe9l4D8vFRn/PcKvRaLfb4ssjHHnY60bGqRZsJdJvLp/X 54vbe0Ufuuuu/QcPbvNfEb/+s48/7kr6dthWrVarTgCGT/R5VSLk1AXgWDz+2ptv 7uhfEY/d//Pv/24qaOqwa7TFwlbFYjGTzQY0FYgJUzKZzOVy5bGxfZOTETzAHAVi Jm3178MVgXiPpcQXjJgH9yJxq2VbVnDzcG+J27YbZGD0FQoF8RjX59CveM3GE4nD jz56nRO/VxMvz0+OH1fxkiQAw0eBfI9BEIkJ/dXt9WV54+23d/FvffLhh+fOntXn zUnMnMT8ickT8oVCVqdp0w2JGVIimSyVShOTk9l8PnzbtnF9juNYpnlpZVhGtWql ImbG7XZbFAxWHm63WmL8fCsz4i61vEqn9bmBQnxZHjh48I677trpvyhegx9/8IGK 96NWs0n3OPglMG8qCLpCsZhTE4DF0/mtd9/d3b+7vLT0P//933LHsxe0xUJQ2j57 y7zj4+N33Hnn7YcOiZ9pNpurq6t7b6SEQOtdQty/YGmbLaZvaGNjY31tTXx1uUHY LO32G2IxrY8y3VpeeccXHnjooXyhsIt/XTzqP3r/fRWnxsSLmtkO/KLFixNRUOif hFFReS8BeKi/7vpf//EftWpVn/cqkYHZFxRZ6m7M3jsv3I6Ojd11990i926dEokZ //r6OukXm8ST2erdnSQtCQviwbi2utpstbwrl2SVlYvDwFEm0m88kdCnfYN4Jmey 2QcffnjXFRzH+eT4cRUvt2ajwcsEftFixo8oyBcKeTUBWDzfX3njjT2umH391Vff /OMf+nTGMtrt3lky9tFFTKFQyOZymnwvZlPvjqJE4sDBg/c/8IBIv1f/gkqlIuYx 4itWt5FDByIAe6eFZbWVFkS9leXlWrUqZuf6PLc39Zp78QCPHjHJKZRKKvpF7YLX 7+q2O+646ZZb9lKn0+l8+emnska1lXiBcOYLfmGyggERbwy9Xohq5sfPvfDC/hvd ZXdDa2tr//c//kOfBSzTNMWUkSlUdOi2+bnXMSUev/nWWx86fPhaB/jFrxHpV3yV kn5xfeJLpXdUuL86KrGsmOIvLy1V1tbcblefNWExqt7lT2zvjJJew+dsdliPL0Jv M86DDz+89+sn19fWzp4+LWNQPyFG2OwlYGY48AfzFQzO5NSUognKg4cP33v//Xuv I+Zn//W//3dVm+3QlmWZhsE7RESouyt7p0SWOHjw4OFHHimVy9f6NeI1IkLvxsaG eL2I6b4mLxnor9c+utPrei9xQXiof5hlaXGxsr6uyTlh8R/YsSwWuCKiUCikMxlN NiOIl1g2n//1Qw9JKTU7MzM/O7v3UlfwvnUlvSywTf6/SSA69k1M7Kj5/vbdcejQ Y0eOyKr25eefn/r2W00WE2gNHRH5fD6by/n7VSfmOslk8r5f/Ur8df1f6aVfr+uV DmEDQSS+hDr9e4Pklq1Vq4uLiyJj+55GuOUlCi41fM5kNJkzOI5zy+2333LrrVKq iTeFs2fOVNbWpFTbSrzwV1dWpJcFtomJCwZnbHw8lUqpqDy+b98///GPEgsuLy39 f//1X5rM7GkNHQXl0dF0Ou3XZxeznHyhcOTpp8fHx7f56zc2Nki/2DsxXxcx2LIs uWVF+JyZnnYdx8cvUcMwqpWKX58dA1AoFjWKvq57/wMPXGfbzi58/eWX7VZLYsFN nU5nXUGuBraJuQsGZ3R0dETNFF8kh6OvvCK3ppiQ/fv/+l9iBiO37O7QGjrceofH fOp95UXfp5555me7W11LpVKp1WrsfIYs3u1BtuwYLObu0/7F4N4px2aT/TthVSyV 9LnrKB6PP/Too9I32X320UeOvC7uW5mGUeHbQ/CPFq9bRIS6+13EO9Drf/+7isrH /t//m52Z0eEdTsylxASxVq36PRDI58vyr/iKSqVSz73wwvi+fTv6F6vV6sbGhmVZ OrwuECZiqm30+yfLLdtqNi+cPz/Uf6eQW/mGWAQOq5KYz6TTOjwDxZO8NDoqpQ3K 1T48dkzR+rZ4pVeZz8A//r90ER3FUimrpseP6zhv/du/qagsnPvuu08++kiTPU5m f68gbbHCxJflX7fbfejw4Rue9b2CmGm1Wq319XXSL9SxOh0xOZZ+p/Ty0pL4a8AH g1kEDp98Pp9MJhVtZ9spx3EO3XXX/oMHFdX/8L33YmpeMpyQh7+YwWBwCsVi7hqX qeyRmGS8+sYbCWX3x1Qrlf/z7/+uyQ1JnT5mVKEx4OVf8WIZGx9/4fe/38VmOdM0 FxcX5TbvBa4mvkpNw+iYptyy4kv3+3PnRMAe5LdvWAQOk3yhkOrzeyA9Xdd94PDh XD6vqL5I159++KGiF0uz2aSzCXxEAMbgiHeO/P/P3p34tXFk+wIHjATaJUACJ463 eHfifZlsM5k4yTiTm8ROvMfO/e/eu5/77p04eyYzuXPjyepJJrEBAzYYBJhVgJDU 3dr1jqSEIWwWUp+uaun3/Xg8BKRSWbS663RVncN2pn72t7/dpFPawxWl0+mP339f 5ckGsV7pVCqeSCAGrgIGJ3+mAODkU089vnPnep9IYyBN00KhkO7JigBWQyc6TVV1 nwqeCYXGx8YMmwqmD52qKFi2UwVoDGO32ZhmRNdrQ2Pj4WPHWA/jmenp/rt3mRrP lwDGGAbEQQAMxqGxvsPpZLqbuHPXrqMnTnC0vNhXN24MB4MyLP4sbpaL4vphcnz7 Apaj4/bVN94o4yYUPTEej0ciETreZDj4oXbkKHpUVd13BScSiXt9fYbFwFjtWQXk qfSby+V8LS279+3jfqH79+5NT01xtJzfGpCPgHFXCITBUAYM5Q8EmK4frX7/S3/4 A0fLS9zt7f3+5k0ZtgSjPFIVaG1rs7At3V+sqanptbNny8sRSoOVuQIZDnuoNXzL oft6evRtczWpVGomFDLmtYCDPOWOMpnM1u3bH9m0yYDX6vzpJ1VROFqmfwVTaA1Q IgTAYCi+UsA0vj97/jxHy8uFQqG/fPKJDFNhKI9kai6Xi2/71mJ2h+O1M2fKO2Lp WRT6RiKRdDotwzEPtYkC4Lim6dsmnT/7entzhuxpV/LrPbFgx5TkKXeUyWafPHiQ onFjXu4f33zDlPEBRYBBOPGfZ6gpfPl+aChz+do1jpZXlEgkPnrvPTqJG/aKq0F5 JPPiKwy2GH3i3njrrbJHb3R0zczM0N8yzH5ALaPzbVzvLAx0/uy9c0ffNleEoi8m JU+5o/qGhsPHjhmzYqiIsQYSMsOBaOI/0lBTPB6PjakSUjZ75Z13OFpew18+/TQ0 PS3DpRHlkUzH6XTSZ4F7RxkdnG9dvFjeyue6wsdqYmIioffqU4DycMwD00F+p6uL +5OYyWQ0VcUp2kTkKXeUy+XsTueBQ4cMfl2+AJg+C/NYuQZCiR+4Q01xu912nkpI 5KXTp1vb2pgaX80/v/++984dGSbH8sWREgkMsMzCgPXPNLJ/7exZeqEynkuRMw3Z 6XCanZ2ldmS4ywNQV7jZR390btOQnFhYBW0iFP1am5pkKHdEp9+OjRu37dhh8OtG I5E7nZ1MjauKEkH6EhAKYxowFGslpH1PPGH8LVISHBz8iu1G6bqkUqkEyiOZBPf6 51wud/jo0T3lZgqliLdY9ZfCYH07BlAhGj2n9S7HNTU1FZqaYr3Rg1XQZkEDlfzy HAmu6RT97ti92x8IGP/SNLCZGBtjahw1kEA4BMBgKNZKSIFA4IWXX+Zo+aHmw+FP PvxQyEsvkUmntXgclxb5tfn9Za9MLoXd4Xj97Nnynkuf0FQyGYlGabyOuV+QTS6X o1Oc7smreu/c0b3m8GLpdDo0Pc3XPuhCnmK/FP0ePHKEb9Hc2rpu3VJ4FpShBhLI ACMbMBrfuN/IRNDLJZPJD69flyEtVr48kqpirZ3MWJdC1BWOgdfffLPsl2hoaKDj Z3p6mjUeACgbBZOq3gPoRCLRf/cu61oeTHxJzlWY+5VhPVd9Q8OR48dZb5KujS8F NO4EgQwQAIPRfC0tFKlytGxwIugVffbJJzOhkPBJM7puxTUNe2yk5fZ47DzZ4Ir8 gcCpClZD0ABlfn4+HA7LMBAEWJGmqim9bzgO9PfrXnB4MVVVUbVOWm63u1mCYr/5 lFcOx4HDh8V2gy8DViKRmJud5WgZoHQIgMFoHq/XxrP1kaI+CoCFB5//+O67/rt3 hXcDJYJl5vP5+JKL0gfhzfPny95gTIduJEIHznwymRR+GAOsJpfN5hdC67pIIZVK 3e3t5QuBEvH4HKq/SEmSYr90PPsDgcd37RLejW+//JIrBbSmoXAjCIfBDRiNNRH0 86dOdWzcyNR46SgAvvntt8JvJNcV0q6k02lstpGN3+/fwLa2zeVyvfrGG2U/nYY+ oVCIYmAZDmCANXBkhO7r6WFa+VlXyNEwjcWfknE6nY2NjQaUZH+oTCazfceOjkce Ed2RuvDcXB9bfWykgAYZIAAGo7Hufty5e/fR48eZGl+X6ampv376ab0EIQRKBMuG NRUcha+/f/HFSm4DqaoaDoc1TUMADJLLZ8OKRPSdBI5GoyPBIN/HE+l/pCJPsd9s JrP/4EG3xyO6I3n3+/unJyeZGsdOeJABAmAwGuvo3+vznX71VY6Wy0CBxIfXr/NN JpQOJYKl4nK7HZyJPS9dvVrJ02dCoZiiZDIZ4asBAR6KYxK46/ZtvprAiqJEMf0l B3mK/ear1h0/zpQepQy3/vnPuKZxtIx7QCAJjG9AgNa2NovFwtHyhsbG85cucbRc HooiPnzvPU1VRXcEJYIlwrcNnnRs3Pj8qVNlPz2bzY6NjdGhgulfMAU6YmN6x5OD AwNxvYPqBdgAKQl5iv3SuOXI8eNSnXK/++orppZpKDITCjE1DlA6BMAgAF8iaBoM XXnnHY6WK/H5Z59NTU4Kn09Lp9NxlAiWQEtLi5UtEfqpl18OtLeX/XRVVWdmZuhQ EX64ApRIVZR0KqVjg7FYbHhoiOkjkEwkZpECV7R89Guz8c3zl4hOuU6n84lDh8R2 Y7mvb9xgenOQAhokgSEOCMA3A0aXkzcvXJBnHdGCH27evNvXJzyoyGQycU1DiWCx +EphZ3O5K+VWAqODkw6Pubk5Gv1j/TOYCEW/FAPr2ybfKmgUQRXO5XI1yxH9Btrb t+/cKbYby6VSqR+++47pEoAVECAJDHFAANY9kMdPnnxcvisKuXf37s1vvhF+0c1m s3QFwiY0UVj3wNsdjtfPni3vudQlGppPTEwk9a6tCsCKIxVW7507+ja4AHsgxaLh h02CYr+ZTGbbjh0bJUj4vNzE2FhwcJCpceyBB0kgAAYBWBNBb3rssWd/9zumxis0 NTn5188+axA9t4YSwQK5XC4H28G/Y+fOYydPlv30VCo1OjpKhwemf8FcNFVN6Xrj 5sHICF+lFiWfBBfLcASQpNgvRb/7DxzweL1iu7Ga3u5uvklapIAGSWCUA2IE2tuZ bsFWMglmADr5f/Tee0xzC6WjDsTjcaxEMh5rHewXT59ua2sr77nFpQFTU1MIgMF0 dF8FrSjK8NCQjg0uhjqoQlDA2dzcLPzkRmfaw8eOyVB2eDU/3Lyp76b6BfRvn2Kr rgSwLhjlgBitra0WntoDdExfrKwMDDe6tLx//XoykRDdkTqKgdMoEWwsvg3wlWSA o0FhKpWKRqNh3BMBE8rlclG9l7TwbQPGNkiDOZ3ORoulWYJiv/UNDUdPnBC+E2pt 3/797/U88xOpZHJmZoajZYD1QgAMYnh9PqarkZyJoJeg4dqnH30UnpsTfjc6kUjQ NQkxsGH4jnw6li6+/XbZz00mk3Nzc4reyYQAjKHEYpl0WscG+QLgeDxOJ3+OlmE5 in4tVqvw1Jh00W+22Q4eOSL8ov9Q3/z970wL9HDkgzxk/xxCtfJ4PDa7nanxl06f bi13IaiRvvzii5HhYeGXw2QBtuUYg68GWIUZsBKJRCgUSkiwMAGgDIl4PKFr8V6+ PFioBGMYp8tlt9uFp7yiA8nr8+3Zv19sN0oRjUTudHYyNa6p6jySj4AcEACDGKyJ oHfv3Xv46FGmxvV168cfuzs7hV+eU6kUjckQAxugta3NYrFwtNze0fH7F18s77kU AGuaNjk5mc1m9e0VgDHS6bSq60qW+/39TPeD6Hw7EwpxtAyLSVLsl06qGx99dOv2 7WK7UaLBgYGpiQmmxpECGuSBABjEoCsTBcBMk58UY7x0+nQZT6RxCVNwsga63nzz 1VfCY2AaPsbjccTA3Px+/waeIsC79uw5cuxYec+lw4+GJuPj48LXIwCUR/dtwGOj o0yzVZl0ehqlgJlJEv1mMpkdu3YFOjrEdqN0t3/8UVNVjpbzBcAUBWMMkATGOiAM XyTQaLGcu3ixjCfGYjG6XjLlKFqDJOWR6FId1zTU52DFl//85FNPbXv88fKeS3Fv MQAWfiMGoGyxSETHJQyzMzOTPFNhyIXLzeVyNcsR/cpc7mhF3339dR3Pyn/c9wGp IAAGYVpaWqw8myHLzoMVj8cnJiba29uNj4Hz5ZGuXxdcHOmXWjhYpMTE6XQ6nE6m WdbTr77q9fnKfjodgZOTkwiAwbw0RUnpV76FzoRD9+/r1dpi+amwfDlUpB5k4XK7 6Qou/FSWy2YPyV3uaEVf37jBdOMgmUjMYus7SAMBMAjDVw+Ghhdn3nqrjCRbmUxm uJCVSkgMTEO39/70J6b6e6Wjd49GfhFkqmBAAbDT5eJomX5rl65eLTu0pqfTcHxq akr4qBGgbPrmwaIPRU93N9Ptqlg0igCYg9vjoWu3+K0c9fVHT5xo5Fnjxodi1H/+ 4x9M7x6qf4FURJ8joIa53W47Wx6sQ0eP7tm7t4wnBoPBbDYrKgamIdfH778vfBEy dSNO1yrEwHqj6JdCYI6WK6z+hQAYqkAqldJ0rePFl6EwP/8r+jxffTweT7ME0a/F aj187JjwbpThwejoaDDI1LiqKBEsLgNpmO/zCVWDLxggHR0dz5eVEXd8fDxemEOg q1cgELCz1Wpaw9/++tcJCdIRUQycTqcxTaEjBMAAfDKZjKJrVMlXChgBsL7ovNrY 2Ch8vTGdSF1u9/4DB8R2o2zdt2/zHZY45kEqCIBBGLpi2R0OpgF3U1PT2fPny3hi KBRaPAHb3t4uJAb+x3ff9d+9KzwGTiQSqWQSMbBeXC6XAwEwAA/dE0HzBcBKPhZA MKAPGktYrFam+uqlo8PPHwg8vmuX2G5U4h/ffMNUCY+aVRUFYwmQBwJgEImvJmou m71cVjwwPz+/JE9DIBDgK1m8ht47d/75/ffCA5JkAW7c6oIvAC77gP/56QiAoSpQ AJzTL4dt161bTKUKEADrxelyWQvEdoMCvM1btz762GNiu1Ghb27caOC544Pa1yAb BMAgktfna25u5miZxkBvXrhQxi1hTdMmlpW+EBUDDweDX37xhfCYJH/vVlURA1eO MQDO5S5fu1b+8+vraUROR77wgw2gEvpWQsIMsOQo+rXb7cLPWplMZtfevW1+v9hu VIhi1B+++45p3Vk8Hg/PzXG0DFAeBMAgktvj4VtgfPjo0d3rz4OVTqdHRkaWf9/v 9/PtWF7DTCj02ccf14u+wFN8pSoKRmwVknYGmEaQiqKMjY0JH0oCVIICy0w6rVdr mAGWGZ1O7Q6H8I1C2UzmiUOHXG632G5Ubmx0dIQvA5aqorQESAUBMIjEFw+QQHv7 Cy+9VMYTh4aGVlxE19bW5uKpYbM2ijw/uH5dx3V95cnHwKqKEsGVkHYGmOJe+uVO TEwIP8wAKkFnSx0ryWEGWFoUcNrtdvHRbzZ75MQJ4duPddF96xbfHl0c8CAbBMAg ktPppHiA6RpmtVrfvHChjCeOjY0lEokVf9Ta2uoWcaM3XSgRnJKhRLCqopJB2aTN Ak2fwXg8Pj09LfwYA6gEnaBSyaRerSELtJzoKmyTIPqlDhw9eZLpCDHezW++yfFk wKKRQz7/FTJggUwQAINgfHmwyg4JKAxY40zt8/m8Xm8F/SoTXUI+ev994WMmelc1 TcM8cHlkDoATicTc3Jyqqjr2CsBgcVVNIgCuai6Kfm024Zs1zFvsdzVf37jBdLQj AxZIqHo+umBSFE82seXB+rczZ8pYtBwOh+fWzNZAATB1u4Kule/zzz6bmpwUe9FF DFw2mQNgGqPMz89jeh9MLa5pyVXW75QBAbBsZIh+aWhBp/EnDh0S2Afd0TX91g8/ MA0tEvH42mMqAOMhAAbBWPNg7dm379CRI+t9lqqqk5OTaz/G4/FQDCwkEP3u66/v DwyIjYHza6E1DTkt1kvaALjul1zf09PT9MutpmkNqCn6BsDdnZ1MsRYC4DLQaIGi X+HXvla/f+fu3QL7wGHo/v3J8XGmxpEBCySEUQ4IxpoHq7yoIJVKjY6OPvRh1PPW 1lYhF+N3/9//W22XsmFoHBCPx+fDYbHdMBe+AJh+HecvX26sLGNt8chHAAzmpWMA TJeP3jt3mD4LCIDXy+P1Njc3Cz81NTQ0HH/qKbF94MC3/rkOGbBAShjlgGCsebBo KH/p6tX1Nk7PCgaDpaTDpc63tbUJuST/+eOPZ2dmhI8GKAZOp1JIblG69o4Opt/a 6Vdf9VawMp96lU6nJyYmdNxCCWAwHQNgTdOG7t/Xpakl6OIyuazaPKyGrrONFksz z1ap0tFvzWa3H1z/mjL50T/tu6++4huGIQMWSAgBMIjX5vdXOHO1ht+98MLGRx5Z 77MePHhQYhhgt9sDgYCQQPTrL78MDg4Kj4ETiUQqmcTlrUT+QIDpRvuzv/3tps2b y346HUiZTKa4DZi+EH5cAZRBxwB4Phwee/BAl6aWoM/X9NQUR8vVh6Jfi9UqvM4Q RXG+1tbde/eK7QaTudnZuz09TI2n0+nQ9DRT4wBlwxAHxPO1tPBd3rZs3frUs8+u 91lrJ4JewmazUQwsJC1Hd2fn7Z9+Eh6rJEkigRi4FHy3ew4dObJn375KWqBBXiKR KBZDEn5QAZRBxwB4ampqhmfgjpCgRBT9UuxrtVrFdoNOjI8+9thjW7aI7QYfin4p BmZqPF9fgK1xgLJhiAPisebB8ng8r7z22nqf9dBE0Es0Nze3t7cLiYFHh4dv/O// Cq8JQSFTIh5HDPxQfHW/Ht206bnnn6+wERrqTUxMaJqGABjMSMcySEODgxpPVTBU hSkFRb92h0P4pS2bze7as6fV7xfbDVY/ff89X1YRZMACOWGIA+LxZQaqK6SsuHDl ynqfVUoi6CWsVmtHRwdfGok1zM3OfvzBB0JeerF0Oh2nGBi5LtbEtwS6ubn5zLlz lbcTjUbn5+cpikAMDKZDIWtKpwC4p7tbl3aWwxLoh6JRgd1uFx790m/qwJEjfOMT SXz75Zd8Z3vkewM5YXwDUuDLDFReImiK5UZGRtb7LIvFQjEw337mNVDk+af//E8Z hguapuFqtwa+ALi8ez3L0S9xZmaGwmDhhxPAeqmKkk6ldGmKrwYSAuC1yRP9Hv/N byyiF2AbgC8FNPK9gbQQAIMUWPNgvXT6dGtb27qeUnoi6CXoX7Fx40YhMTBdrf/r //7fdfdYb9lCDIyaB6vhC4ArLwVcVF9fP1+AncBgOkoslkmndWmq89YtpjM5AuA1 uFwum83WIHpBUy6bPfHMM8KDcANEI5E7nZ1MjWO7O0gLgxuQgs/na2IrcrBz166j J06s91ljY2Pl7Yqh8IZiYKZ9ng/13//5n3qtACwbRWL5GDgSEdsNOfHd69ErAK4r DNApAJ6bm6uF8R9Uk1gkQh8EXZrqun2b6V4VooLVuNzufPQr+rRTX19/4umnxfbB MPfv3eO7HZOIx9eVTgXAMAiAQQput9vucPA1/sfXX1/vs0KhUNnTmHT97ujoEFW5 4eP334+IDj5zuZymqsK7ISG+JFj0nr954YIuRx2N/1RVnZ2dRU1gMJdIOKxLOxSj 3u3tZVoBgSRYK6Irtc1uF77qxGq1Hj5+XGwfjPTj99/rlTh9OVVRMAwAOSEABik4 nU668jHdbqcL6sW3317vs+bn52cryN1PMXB7e3sz27T22v7388/Hx8bEjiTyMbCm If3jEi0tLVa2OyPHT558fOdOXZqiX18xFZzw8ShAieigjep0wqEAdWqdeRBLR/FG JReXquT2eGw2m/BrFnVj35NPCuyD8b75+9/59rprqoraECAnjGxAFi2trUzl/rLZ 7OVr19Z7ZaXgbaKy5A30ioFAgK/C09p++Mc/+GYwSkdv47xOczLVwevz8d0W2fTY Y8/+7ne6NEVHTjqdDofD0WiUPkHCDySAh6IBt6JT9gG+Gkh1hZyFYawLXcTj9VL0 K7YPFP0GOjq279ghthsGo3/1t19+yRQAJ5PJ2ZkZjpYBKocxDciC9RJIUQHFBut6 Co2lhoeHK39pv98vqojCvb6+72/eFB660GgvnUrhNnAR63HucDpfO3NGxwYp9J2Y mOArEQmgo1QyqVfU2tvTk9NpL/FyuC24gC6OjRaLqKVSCygO3LJt28ZHHxXbDePN hEL9fX1MjeM4B5khAAZZuNxuB9s24C1btz717LPrfRYFwBQGV/7qra2tbre78nbK MD429re//lV4ThGKoGhsihiYeDweG9uiADqhX7x6Vd82U6nU9PQ0DWWEH0UAa0vE 4/RHl6a6b9/mS0RMUfo89oYUol+L1SoqWcaCbDa7Z/9+X0uL2G4IcbenZ45tNb6i KMiFCdJCAAyycLpcfDOldofj9bNn1/us8fHxuE7DKZ/P5/V6dWlqvSLz8x9cv860 v7p0SZJIIAZmvdFDI7mLb7+t++86v2IzHKbRDGJgkJmmKCk9igDT56inu5vvaEdg UFeIfin2Zdr3VLpMJnPo2DFRO5WE++G779I6lQ1bji73MRREBFkhAAaJ8JVIzeVy l69dW++zZmZmdExg6PF4KAwWsiCZYs//+o//EB690Ng0EY/XeAzscrkcnEviTz71 1LbHH9e3TTpoNU2jGFhVVeEr6gFWo1cNpNmZmcnKEkCsTcnHBTUdGOTTXjocG0Rf kij6PfH000x16UyBNQMWil2DzDCUAYn4WlqYVkNRAHzu0qX1lp+hMUpI12IVdNVv a2sTEkLQuPA//8//Mf51l0in03GKgWt48EfHgNPl4mu/Y+PG50+d0r1ZOmjjicTc 7CxFwro3DlA5HVNADw4M6LX2Z0V0Aqzl+4B0ArTZbMIXJdE18eQzzwi/LywQXY6/ //ZbpgFJonC94GgZQBcIgEEirPmBjh4/vnP37nU9hc7gY2Nj+nbDbrcHAgFR02j/ 9R//wbfeqUT50giaVssxMN9KB2KxWN66eJGpcfrdzc7OKoqCvNAgGzqzqTpFlXe6 uvgO7xqfGZMk+iUU/YrugmDjDx4MDw0xNY4MWCA5jGBAIqzbIynsfOHll9f1FBrl B4NB3XvS3Nzc3t4u6sbzB9evU/ApNnqhN1ZT1ZpdBMhX8auu8N5eeecdpsbrivNs 0WgkEkkmk4iBQR46ZsDqun2bL0Kr5dowLop+7Xaxk650BrNYrUdPnBDYB0l03bql sK1EwEZ3kByGLyARp9PpcDqZRtWNjY3nLl1a77NGR0d1yaqyBMU/HR0dou6Cy1Ai OB8Da1ptXiBZSwHXlVX0a13yy6HjcYqBo6LvpAAsoKF8Ro/lLfPh8NiDB5W3s5qa LQLscrttNpvw6LcGi/2u5ruvvmJqmd5nJZ8Cq3bX+YP8MHYBubT5/UwZKcqbGZua mlIUhaM/Foulvb19vduS9dLT3f3jDz8IH4tQDBypvXIgbo+HNeloGYsdylC8hTE7 Oyt8UT2AjhuA7/f3sxa+VlW1Nk96FP0Kv+u6eevWRzlvDpoInbdvfv010114ajw0 Pc3RMoBeEACDXPjyYJEXT59ua2tb11PC4fAc2916uvZ0dHSIqgMxNDj4NVsGyBLR sDWuabVWEpM7ETSNMi++/TZf+4tlMhn69cViMRrxYDYYREmlUppOdypZ1z/X1WQK aI/H0yw6+qUz1c7du/3t7QL7IJXpycn7/f1MjSMDFsgP4xWQC10pbWyTY9sff/zE U0+t6ymqqk5OTjL1h1D82d7ezrogdg2TExOff/aZ8DSYtZYtw+l02h0Ovrc9l8ud PX/eyIOKwo9ogS5FaADWS68KwOl0mnV7CH1AVEWpqaWhrLktS0TR774nn/T6fGK7 IY9sJtPb3c13I0ZT1Vq7rw2mgwAY5MI6OUYtv3bmzLqeQuOhkZERpv4U0WDL7/fz Zf9aG0WeH3/wgfC5u3g8nk6lamdc2NraauGc+d+1e/eR48f52l8RfVhi0ei8TrVY AUqUX/8cidD/Vd7U2Ogo68A9lUzO1EwGLKfT2WixiLq9u4Ci30NHj9oFXWHlFNe0 2z/9lGM7UdfgMgcwHQTAIBfWPFg0Trp87dp6nxUMBg0Y0Le1tbk4y8OuQVXVD959 N6fH8LESiUSCRoc1EgN7vd5mzlkR1mJIa6MPSyH7SYx1IyXAAjpvaKqqS1OsBZDq CoFHuDZWu9Cl3GK18m1oKhGdjo6cOCG8G1IpbpjnW+qPDFhgCgiAQTp8k2N0Xqao YL17bsfHx+M6VddYm8/no7jIgBdaLpVKvfff/y08m1GSJBK1cOFkrfhVVxj2vXnh gti5FwqAo9Eo/TaF31uB6qZX/mc6Afb19LBuCamR2jDcuzxKd/TkSaa0muZFZ2Y1 Gu1jW+pfU8scwLwQAIN0WCfHDhw+vG///nU9hU7lEaOGLG63u6WlRciCZAqZPrh+ Xa+JlLJRKJ6Ix6s+BmZd6VD0+M6dx0+e5Gu/RJlCzWf6hcbjcUTCoLtMJqPotNhy dGSENTqtkZkxOrnZHI4NoqPfDY2NR44flyEIlwodhLFodHJ8fCYUYnqJ2lnmAKaG ABikQ0Eg33adltbWl195ZV1PiUajIbZLxXIOh8Pv94valPvJhx8Kz0eVTqcpWIpV +w4iOhRZE4Bv2LDh/OXLfO2vF/1aNU0rRsKi+wLVQ1WUtE6l2rs7O1njpWQyOVvt M2NOl8tms4kqcb+gqbn50NGjYvsgp2K+9Ht37+r1qVmOPpKGzRkAlA0BMEiHrqAU BDJFgDS+uXDlyrqekkgkxsbGODqzmubm5vb2dlG3rv/388/Hx8aEl6yIa1p1Z9Hg To6ay+X++NprHkGL6tdQjIQVRaFPFtJlQSV0nP6lE879gQHW817Vp7t3uVzNoqNf Ou+5PZ59Tz4psA8yK+4X4LvXk1/moChVf/8aqgACYJBRm9/PtG+HBtyXrl5d16mf TuhDQ0McnVmD1WqlGFjU5qWb3347cO+e2BiYflM0Xqzi/XLc1YCJPxA49fLLrC9R CfoVJ+JxRc2jSEZ0d8B89Nr9Swb6+5PMaduqOzWuy+222WzCC8u3BQI7du0S2AeZ FW8Y0bt0p6uL6TeVTqdD09McLQPoCwEwyMjX0sKXtvE3Tz+9dfv2dT3lwYMHyWSS qT+roei3o6PDYrEY/LpFt2/d6rp1S+xohgKkuKZV8WIqv9+/gfMeRzaTuXTtmvy7 4GhAlkql4r9AMAyl0DH5Mx2B3bdvs34YKVCfrt7AwO12N4uOful68chjj23ZulVg HyRHnxf61MzNzk6MjzO9RCKRoPaZGgfQEQJgkJHH47HZ7UyNd2zc+PypU+t6Cg1c hGQuofEExcCiSjj0371789tvhd/R1ygG5qzMKZDX5+NO1Lxrz54jx46xvoS+aBSb 36WmaRQJJ5PJ/Pye6CLVICE6TopzWbq0xl3+t65Q6jw8N8f6EqK46XptswlfMbTt 8cc7HnlEYB8kly9QV7ibPDgwwJeIgWJs7o8SgC4wsAAZsa4ObbRYzq2zRCqd0GcF 3dSkUUUgELCz3Q5Y2+jIyI2//U14DExX66rcO8ddDCmvvv7S22/zvgSb4sxwIpEo zgwLL9MFksjfF1NVHbP4dHV2cmctrtYCSB6vt7m5WXjOiN379rW2tQnsg/zoNJoo xL2sxa6re50/VBMEwCAj1iqC2Wz2yjvvrOspmqZNTExwdKZEbW1tLpdLyEvPhEJ/ /uSTBtGzcHFNo/inyiqIGFMt89DRo3v27mV9CWPQAVAoFP0zJNCqWQtDeV1MT01x 71qkY1VVlOo7fTU2NvLVLCwRRb9PHjrkcrvFdkNy+epHkUhxxUTX7dtMicqq8jiH aoUAGCTFWiTmhZdeCrS3l/54usQODw8zdaZEXq/X5/MJeeloNPrRe+8JeenFKOZJ JZNVdnE1YBU0uXT1KvdLGC+VShXj4eLfiIdrRLGOi44N8sUDC6pv/TNFvxarVdT2 nAX0qT907BhrOv3qQKfIuKbRF3QBHQkGuV6lBgp9QdVAAAySYi0S89iWLc8899y6 njIyMiJ8BabL5WptbRWy2IwGcO//6U/CY4xkIdapphjYiFXQdXV79+8/ePgw96sI lMvl6OO5OCTOZDJ6bRAFedBvWdX14z8+NmZAaFpl658p+qXYl7WMeSnoA370xAmL 6G7IL1+aKBotXr6DQ0OqrvePFqv6Ql9QTRAAg6RYA4Ompqaz58+v6ymTk5OqThlH K2G32/1+v5BNuTT0pBjY+GzYS+Q3hcbjVRMD01DSZrdzT0DRAOj85cuiqmoJQQFw cck0KQbGSC5tdrpHvxQS3Onq4v700YGnqWo1nbIM2LjxUPUNDRT9iq05bBbpVGoh 6O3p6uJLK1hlN3qguiEABknRVdbhdDLNdmYzmSv//u/resrc3FxYjlubFL23t7cL ufBTHPXhe+8pokdyNA6OUwxcLZk2vF6vAfvoAoHACxLXBDYAxSGpAoTEZqT7ymdy v78/wVz7t66Qv0CSa0flnC6XzWYTHnZaLJbDx4+LzbxlImostrB+revWLaZyX/l5 5lisam70QNXD6QPk1drWxlcF98XTp9vWkzRSVdXJyUmmzqwXvS0UA4sqEfyXTz8N TU8LT/tJw8rqyDZJY0qHw8H9fmaz2d+/+OJGlAlZhN6ThYXTxdiY/lP4On9YbmEH o46ikchwMMg9k5mPChSlOu7WuVyuZtHRL72fdofjQFVv6NAXXSuVXw4/OhSHh4aY XojOnzOhEFPjALpDAAzyYp0Z27J161PPPlv642lkPDIywtSZMogtEfz3L74YHR4W XvhRU9XqiIFZ7/Usdu7SpZpaCL1eNLwuFiJeiIeLX2A7sSj5KmiqmtKv4lGRMYuf 66ooKqDo12a3Cy+J5/H59u7fL7APpkNXydQvG5eGg0G+BVzVtNIBagECYJCX2+22 s20Dbm5uPnPu3LqeEgwGpZodElsi+Pvvvrt39674GFjTqmDTkdvjMeb36HA6Xztz xoAXqjLF5dM/x8O/hMVSnQ2qUn73rKJwvM+9PT05Q359qqpG5ucNeCFWLrfbZrMJ j3797e2P79wpsA+mQwf54utjT3c332upihIx/7UYagcCYJAX7zbg9VcDHh8fj+tX fFIvra2tbkElELs7O2/9+KPwURHFwGYfYjpdLrtRsysdGzc+f+qUAS9U9RZWUKd/ Ufwa08WVo/cwn86b53w7ODBgzJk8XxZVVc2+/tnt8VD0K/xe56YtWx7bvFlgH8xo ScVsvopf2AAMpoMAGKTW1tbWyLY09KVXXqHosfTHz87OzksZaHk8Hp/PJ2SAcr+/ /5uvvhK+K4yGs2avvmBMQeC6wtu1afPm5373OwNeSyoUnYbn5iLz89FoVNM0Ghcm k8l0IWTNkGw2R38WKT6rvGg2V3hmiQ+mT27lMXOxkYWTQH3xq4aGBvqioWED/Wks sFisVmuzzWYnDoec6+Ez6TT9grI8KcqGBgdVRTHmbFkF5X89Xi+dl4RnfHh85872 jRsF9sGM6IQQi0QWzi2qqgYHB5lei06koapY6g+1AwEwSI01KtiybdtTzzxT+uNj sdj09DRTZyrkcDj8fr+QYcrYgwf/+/nnwqti0FiTrsHmvQNtTCqsovxWOo/nD6++ Kjyb60NRdKqpKoVD9Hd+RjCRSBWyN+f35Wazxai1YcOGhsL7Vgw7c4W/KPCgx1MQ RUFtfeE79fX1SBu72EKc//Ob09BA8TBFxfn3qPBG1S9+GP28GEvTu10Ipy30x/qL piZdjiV6ofyNCZ7MzNlstv/uXTqiDPuUmTr9ldPpbLRYjLkrtwb6re3et69lPbeq oYhOldqi2o28G4DNf68Hag1GAyA1qbYBJ5PJBw8eMHWmcvTPCQQCQkKamZmZzz7+ WHh0kShER+aNgWmQR6GEka/49HPPbd6yxchXrCtMRFBUQEMxCg/o6/wivUSCYp5k cTK2kIe5GHQVAi7BN1agRMXfWv6r+mI0XZh23rCBgij6YynOPDc3N9H/bLbl2fvo ufThpYOBaQF5OBweHR428vRI14vZmRnDXk5fFP1a8rc1xCRZXEAH1ROHDrlcLrHd MCklGl1c6Q0bgAEWQwAMUpNqGzCNzILBoMwb/ASWR6Kw88Pr141/3SWSBSaddXG5 3Q622z0rooOZApIjR49u3b69wqboABgOBqcmJmjIRf8QTVXjhTXGqcJvZCE6Kq7J 1aPvYGLFbNt1vyzVpkA5HzE3NDRu2ECnr0QySUcJnfk9Xm/lMdjc7Oz4+HjdovXh xlAUxaT5+YxMSbAGOkIOHztmQI30qpROp9Vf3wvGBmCAxTAQAdm1+f18G9XWWw14 bGwswbM8Ty80aqEYWMi6NQp43n/3Xaade6VLp1LxRMKMMbDT6aTRnpBtmTTWdHs8 HR0dj23Z4g8EFsa+FM3SO0nj+Px0bTRvfn4+EY+n83tms/U/z/YV18ziagL6W1ik XVyu3VCYW87vZC5MLP+y/rqJ/rdw0Oa3PsZikXCY/k6lUkIWxVD4Edc0M4YE+ejX ZmsQvTmCftdHjx+3GLsippqoipJeVDyMtQIwHe0hWXeHAawGQxaQHes24M1btz69 nmrAoVBI/sKzFIr4/X6D5xKL6EJIMTDTFr7SUdhGo0/5f1PLGVYPaQ1L1jggsgX5 yXbQmrT6kcvlarbZhKcGqG9oOHrihPBumFc2m439evUBRb8UAzO9HDYAgxlhZAOy Yw0Jmpqazp4/X/rjI5HIjEm2dbW0tHg8HuNfl0aiH73/vvAJWJOWCBY4CQwAujDp 9K8MxX6JxWo9fOyY8FsYpkaH35Lb0LwbgM15uwdqHE4xIDvW7Ljr3QacSCTGxsY4 esLB5XK1trYKGUn85c9/Dk1NiR3E5EsE04XZbDGwDJPAAFA2M8YDbop+7XbhZ2yH 0/nkoUMC+1AF6G3M3/n99ZoI3g3AZs52DjULATCYAOs24OdPneooucAgBczBYJCp JxxsNltg0ZZOI31148ZwMCh8RBXXNDmrN68Gk8AA5mXG6V+Px0PnHOHnal9Ly+59 +wT2oTokEwk6Ahd/JxqNjg4PM70cNgCDSSEABhNg3Qb86KZNzz3/fOmPHx0dTS3K LSE/q9Xa3t4uJKD65/ff9/X0CF/MRqMBukibaEjKWv0LAPiYqx5MvthvY6PwTMsU /bZ3dGzbsUNsN6pAfj42Gi2mWF8wNDi4uCCwvrABGEwKATCYAOuiUIvF8tbFi6U/ fnp62kShVNGGDRsoBhZS1LGnu/vHH34Qvq/MdCWCW9vahJSzAoCypVKpmVBIdC9K JU+x381btz762GNiu1Ed6AjUliW7utPVxXcb2owL/gHqEACDKUi1DXh+fn52dpaj J6wEpoYeGhz8+u9/Fx4D58vRJhJmiYFdLped7ZgHAN3lcjm1UCxMdEdKQtEvnWGE n5YzmczO3bv97e1iu1E1lFgsk04v+SY2AAMsh9EVmAPrNuBnf/vbTZs3l/hgTdMm JiaYesLN5/N5vV7jX3difPx//vIX4YOt/Pa8eNwsV2vWlf8AoC8TrQXNF/u124Wf kCn63ffkk3SiE9uNqkGhr7LsDu98ODz24AHTK2IDMJgXAmAwB9ZgoKOj4/kXXyzx wabLg7WEqNTQNDT85MMPhU9pmqhEsNPptNntKIYJID86sWiqaooFJpIU+6V37OCR Iw6nU2w3qommKMsTlAwODMTjcaZXNNFNH4AlEACDObCmBaKhwPnLl0t//MjISHrZ KiMTaW5uDgQCxg+AVFX94N13c78uz2A8E5UIRjYsAFMwS+4rSYr90kn4yIkTwrcf VxN6S2MrHYHdnZ18v26zHPYAyyEABnNwOp0Op5NvG/DFt98uPSCcmppSluWZMBeL xdLe3m58mqVUKvXen/6UFp1GO18iWNNMkbrD19KCYSKAzBKJxJwZEkO4PR6b6HJH efX1R0+cQKU3fcU1LZlILPkmjW16uruZAuD8BuBYzBSrHgCWE30eBCgZa17cw8eO 7d6zp8QHh8PhOfMv+6GLYiAQsBleAIMuyR++954q+g5CvkRwPD4fDovtxkM5XS6b BOsVAWBF+cXPmiZ/ZgGP19vc3Cw8+qW49/Dx48KnoKsMXc5ikcjy1VWh6enpqSmm FzVXznOAJRAAg2l46frNFq15fb7Tr75a4oNVVZ2cnGTqicHa2tpcLpfxr/vZJ5/Q tVP4aCwRj9NVXPJ72C632263C3+vAGCJfOZnVZV8P0W+3JHF0iQ6ox69V3aH48Dh w2K7UZWSiURc05Z//15fH992LXrFsPR3kAFWgxEVmAaFAaxVfC5dvVriIzOZzPDw MF9PDObxeHw+n/Hx1Zc3bowEg8LjOlOUR2K9+wMA5ZE/BpCk3BFFv96Wlj379ont RlXKL0WORrPZ7PIf8RVAIoqiSH7rB2ANCIDBNFi3AdMl5Oy5c6XHGBQAUxjM0RMh bDZbIBAwfpD0z++/7+vpER4Dy18eiQ5+a1OT1WoV3REA+Jn8984k2UBBl9f2jo5t O3aI7Ua1SqdSK24pSqVS9/r6+IZM2AAMpoYAGMyEdRvwnn37Dh05UuKDJycnVVVl 6okQotJi9fb0/PMf/xA+QSF/eSSKgZttNmSOAZBB/q6ZpskcAEhS7iibzW7etu3R TZvEdqOKUSCaWWmd8/jYGF+NImwABrNDAAxm4vF6+ZI2OZzO186cKfHBc3Nzkq98 KwNFoRQD89VbXs1wMPjlF18Ij4FpoEYjWpmLOtCI1ma3C3+jAGpcvpSaqsp8v8zt djdLUO4ok8ns2ru3ze8X240qRu+wsspx2NfTs+K6aF1omiZ/CkmANSAABjNh3Qac y+UuX7tW4oMVRZliS64olpC0WKHp6c8+/bRB9Fpo+VNDS1LGE6BmyV9IXJKEzxSb PXHwoNvjEduN6qapaiqZXPFH2AAMsAYEwGAmrPk8KPj5w6uvtrS0lPLgdDo9MjLC 0Q0ZuN1ueh8MHj9Fo9GP3nvPyFdcjeSpoZEUGkAUydM+S5Lwua5wm+DQsWPGl9mr KfQmx1Y5FOkoHbp/n+kyQa+rKoq0l0iAUmAIBSbT0trKlwpo89atTz/7bIkPDgaD fOuLhKOBi9/vN3j/WCKReP9Pf5Ihu1gqn91G3vQ2brfbhhgYwFgU/WqqKu0uiXye SIejXoblIbnckZMnjc8oUWsS8Tj9WfFHw0NDykqZsXSRTCZnZ2aYGgcwBsZPYDIe j4eG/kyNU2j95oULJT54fHw8vsq1pzo0Nja2t7cbnHmYot8P3n1XhjdW8tTQWAsN YCTJVz5LkvCZUB+OnDiBUxO3XC4Xi0To7xV/eqeri+8Oqaaq8/PzTI0DGAMBMJiM y+VyOJ1MjdMQ5/K1ayVeNmZnZ6v+GkBvRSAQsLPdcVjNJx9+KMNGXMmHvJJkeQWo epJniZfndlhTc/Oho0dF96ImJBMJOiZX/BFFxd2dnYwbgGMxaT8LACVCAAwm43Q6 bXY735n9N888s3XbtlIeGYvFpqenmbohFZ/P5/F4DF5we+Nvf3swOip8lW9+0aOm RWS90+F0uezICw3AKZVK5TdEyDrid3s8FP3KcKp0e737nnhCbDdqRL4MbzS62ias udnZifFxppfOZDKaqkq7PwigRAiAwXx8LS1NTU1MjfsDgVMvv1zKI5PJ5IMHD5i6 IRuHw9HW1mZwoPXP77/vvXNHhuguHo+nZU2L5XQ6Gy0W44tXAdQCfPZLQZFYx8aN 23bsEN2RWkHHpLr6Ft+B/v5kIsH00olEggJspsYBDIMAGMzH7fHwLcqtr6+/+Pbb pTwyl8sFg8HVduBUH6vVGggEDM5r0tfb+8PNmzLEwMlkPi+WnOPgukJarKbmZiyH BtBLJpNJxOMyp7yyNjUZnKNhRRT9btm+/ZFHHxXdkRqixmLpdHq1n7IWQFJVVdol UQClQwAM5uN0uZxs24ApoH3zwoUSZ5jHxsYSbPdZJUSBKMXABle2GB0ZufG3v8kQ A0ueFqtYAYXGxMIXQwKYGl0FkomEzLXQ5El5RdHvrr17W9vaRHekhmQyGWX1yxBd p+729vJdBehDIe1FEKB0GCeBKbX5/Y2NjUyN73vyyQMHD5byyJmZGWnnB/i0tLR4 PB4jX3F2dvbTDz+UIQam0V5c02T+pcuTDsfsios7/rXE45ev1juyLD6PnrV4tUh9 4Vt1vzRYYkG1tRspo2+wHMW9yWRS2tR3dYXlHs1yfMYpEjtw+DBF46I7Uls0VaVj dLWfToyP8y1Rpug6VBupT6Dq4WIJpuT1+fg2PrlcrlffeKOUR0aj0VAoxNQNmTmd ztbWViNHYKqqfvDuuzIsOKc+xOPxTDot7exQXa2GwbmC/Ff19Q30p2AD/WnMo78t Fkv+q8LflkV+/g+rtfDj/M+sVqsuwWR+rkZRZoyqmUn/fBqh0otmM3nFrzPFv//1 33k5+q/iw7JZ+jqb+5e6QiBdZEy3JSF/6EsnXjqM6donw6+Gjpkjx4/z5eOAFWWz 2diah2hfby99rplena594bk5psYBjCT+HApQBrfbbXc4mBqnIeDla9dKeWQikRgb G2PqhuSM3xKcTqXev36dL7fHulA3kqmU5CvBKAymaE6vWE6In0OyQjRLoexCdErD borwbXZ7/k/hC4fd3mzs4vzV5JcJFGiallx9okZ+hW3vifyhXviK/qIAkaLEzC8x dpZ+QYW5a/rtmPoYo39aOp2WOfStKyx7thb2OIjuSB59II+eOCHDGuxak4jH6c8a D+DdAKwoMi+AAiidWa9YUONoKOBwOJiGXDQeevmPf2xtbS3lkUNDQxx9MAXjtwTT G/7pRx+F5+ZkGG3TiJkGIpKXQ2TdMF+hYnBLv8r83GwhUKcItrm52e5wUJ+p5x6P h+8+l76K6wKKQW9N5QVYQP9qGhzTvz8/QC/cHkoXospMNo/eIJmDZPm3NcpT9JsO derJwSNHpP1tVjF682ORyBoroVRVHbp/n29opCiK5J8UgBLh/AVm1drWxjf9+Njm zc/89relPPLBgwemnuSpnPFVgr/84ouR4WEZhl/ybwlmXSuxtoX1tMX1xhTZ2ux2 6gwN5d0eDx02ZgluV0P/Oor0FoJeGdbnS47epdDUlKaqxRRT+cnkTDFAztYXJvlF fagln9eSZ9MvHeRen2/P/v2iO1Kj6INDp5s1HhAcGlqjPFKF6AM7U5N7vqAqiR9B ApTH4/XyzT3SgP3cxYulPHJ6elrmvaDGoLjG7/cbOT679eOP3Z2dkowIKQZKy7ol mHW3/OIQtzh/W5y89Xg83pYWr9crw4SVvujfS6NArYBCXwS960Wj83QqteKPikvH KTz+ed11Ya21MeGxtDsb85V+GxubJNn0m81ufPTRrdu3i+5IjcpP/0ajuTUT5t3p 6uI7VOikNx8OMzUOYDDxp1SA8rhcLgfb2k660l+6erWU+CoSiRiW4UZmFoslEAgY WZRycGDgm6++kiEGJqlkMpFMSrg2jG+hBH1Gzl++bHBdaFEo6C3O9JISMzbDih66 g3E1mUym984dps+7nFNb+Z0+dnu9HKc4ev937NoV6OgQ3ZHalU6l1p7dpQiZAmC+ a6KS3ygg3TUOoDwIgMGsnE6n3eHgO9cfO3GCrvcPfRgNi8fHx5n6YC719fV+v99h 4LrWqcnJv372WYMEcyN1hQEiHQxS5dGhz4jD6WSaEKBGL169ytGyJOgXujDTm06n RXenSqSSSU1Vy3tu9+3bDTxrCvKbG/P7gCVaxOFyu5ubmyVZQ0Gfhf0HDni8XtEd qWlKNJpZM73zTChE10SmV89msxR+S/UZAaiEFANHgPL4Wlr4ajB4fb7Tr7760IfR VSEYDDL1wYw8he2dhi3Yo+vxh9evG/NaDyVbhSQaQ/Pdjyi9WpiJ/LwKtyC1ykpd qES+LlS5k0h3e3oybNPviqJIcvdKqlpHdYUPxeFjxyRJsV6z0um0+rDLyr2+Pr5b dYlEgq+8MIDxpDi9ApTH7fHY7Xa+9i+VNsE1OjqKsfJiTU1NgUCgsbHRmJdLp1If vPtuQppUZMkCGZZDe71evmHrzt27jx4/ztS4kYq5rIpBb20mcDYSvdvR+fnynvtg dDRS7nMfKq5pYQn2N+ZrHRWI7sjPGurrj5w8KclEdC1TYrHMw4Jb3gJIqsr36QMw HgJgMDHWEi80UHv97NlSthlPTU0pbHkXTcr4Ckl//vjj2ZkZSeZMJFkOzZop/Q9/ /KOvpYWpcW7IZSVQLBrNrrmSczWaqg4NDurenyIZtgFLteyZPhQ2u/3gkSOiOwIl rZtIJpP9d+/yXQHlLxUGsC5SDBYBytbm9/PNNO7YufPYyZMPfVg4HJ6TMoOocAZX SPrmq6/4SiCul/Ds0KwbgLPZ7JV33uFomdXCtl6y9m464ENxbKrc9Rp8c1xitwFL le25rvButLS17dqzR3RHIG+N3OkLHoyM8JXyogtZaHqaqXEAIaQ41QKUjbXKC7V8 5ty5hz5MVdVJtswTZmez2fx+v2FzGne6u3/64QdJUkPXFaaVEomEkBvnrBuAS68T JhzF6gsrnGu8ZLckHlrLdA2sVV5EbQN2ulx0npRk4reu8JF5bMuWTZs3i+4I5NGv I1bCYdnT3c3XB2nrhAGUDQEwmBvrKL/Eaa5MJjM8PMzUhypAA7tAIMB3n2KJ0ZGR L/7nf6QaTSbicTpIDJ5cYr031N7R8fsXX2RqXBcU62KFs5xKSeezmvv9/Xz7tI0f 5efzXW3Y0NTcLM89OzpT7d63r7WtTXRH4Gclrphg3QAsT4o4AL0gAAZzY13nSZ5+ 7rnNW7Y89GEUAGNF5dpaWlrcbrcxC/zmw+FPPvzQgBcqnfGZsfyBAN946DfPPLN1 2zamxsuWzWaLQa+qqvg8SquSPFhzs7MTbGXn6JiZnppianw52fJd1RU+QQePHLEb WMoO1lbi9G94bm58bIypDxIWCQOoHAJgML2W1la+MQRFEadefvmhD5uYmNDKXdRX O4xcDp1KpT6UKTV03S8ldoxJpOlyuUrJ31Ye+odcvnZNns2Kiyd7RXcHSkJj+mxZ BY3o132nq4tvvlTJJ/ox4i6V2+Nplmnit66Q8PnwiROGZe+HUsQ1LVnCkoeB/v5S HlYeOsHOzswwNQ4gihQjGIBKeLxevmzDNMq/+PbbD33Y7OzsPCoElICiX4qBDcsO /ZdPPw1NT0sSqhUZMxXMWgCpccOGc5cvMzVeouJkr6qqSGdlRpqilF067k5nZz1b 3GhAMSQJJ35zuZzd6Txw6JDojsCvlL5WgnX9M51j5yWoEAagL4nGhQDlYZ3soivQ 2XPnHhpLKIoyZeDaObPzFhgTl37/3Xd3+/qkmmnh3hXsdDrzOXXYZnI6OjqeF7QB mKImtQCTvaZGx3+i3N/g4MAA328/k07TcJ/vgynbjt+6wuko0NHx+M6dojsCS9Fx nizhUKez4r2+PsbkcEYtiwAwEgJgML38cN9u57v9uWvPniPHjq39GLoCjY6OMnWg KjU3N/s5S1gtdr+//9uvv5Zq0FlXOGaSiQTHwII1Mxx5+tlnN2/dytf+ErlcjgaC xbg3nU4b9rrAp5I8WKzbHevY8v24XK5mmVI9F2UyGQp92zduFN0RWKr06d+x0VG+ BWj50nGqig3AUH0QAEM18Pl8TWwJbym6fuPNN9d+DF2rgsEgks2uC0WkFAPb7XYD XmsmFPrsk0+kWgtdV9y/mkik0ml9V0T7Wlqampp0bHCxbCZz+Z13DHgni4ucKRqh v8vbLwrSqiQPVn4bcGdnA1skmUgk5mZndWzQ6XJZGhutTU2ynX8otnny0CGX2y26 I7CCRKF6WymP7Llzp45t7JGIx+dQAAmqkVynY4DyuN1uvsSVNOK/8u///tCHjY2N 8dXnqGL0u/P5fAZMz9Jv54Pr19Pl7jzko++KaBptOxwOvqE2dwVgeh9UVS3GvXyv AsLFotFsuZu3WasB53PeKoou96TkXPP8s/r6I8ePWywW0f2AFazrDlHXrVt8G17o XBxBASSoRgiAoRpwF0N67vnnH920ae3HhEIh7JMpDw3CAoGAAVlhaFTx2SefzM7M yDYVU1dYFJpMJPJFLyoLg1nTX5Et27Y99cwzujdL/3yKOrC5t3aUWN10RcPBoMK5 JrPyVFh0SaKgl0Jf2dY81xVOgza7/cDhwxKeBqGIrgXx0u4ARubnH7Btv0IBJKhi OP1BlWhta+O7mR1ob3/hpZfWfgxFvxQDM3Wg6tFQrKWlxeVyGTAm++Hmzb7eXhnn ZIobg5PJsrcgOl0uu93O90+j8dC/vfGGjmsmi3EvweqJWkPHeVxVy3tuIh4f6O/n O1dks1lVVcueBKYPiNVqlXNylf5p7R0d25HySmLrmv6939/Pd/Kk69EMRjVQpRAA Q5XgLYbU0HDxypW1H0MXoTHO1Cy1wLBCwcNDQ19+8QXfNsIKpQpxcBmzwVu2buWN JOvrL5VQFeyhMplMMe7FfG/NymYylSwz7urs3MB5D6uMrY/FWV+LrKFvXeE937ln T1sgILojsJZ13Rti/SCgABJUMQTAUCXYiyGdP9+8Zp4tCleCwSBTB2oHRb9tbW0G ZMaKRiIff/CBzHnL0uk0hcGl7w12ud30vrFOoZeyFGIN9G6rhYSiarlTf1BNovPz ZX8AWSe+6n45Vktci1Hc60uhrzFp7cuTzeUOHTliMyTpIJSNDrxYJFLi54KuEXd7 e1EACaAMCIChSnAXQ9q9d+/ho0fXfszo6GhKvhxLZuRyuVpaWrhXKVNs+emHH0Yi EZn3wuUzRSeTNNDJrTkh7HS5bMxFVqgnL50+3eb3l/FcilUKW8liyOcMC1RFKTsp naIowcFB1k9uvgCMpq0xTU0XnfqGBgp6rVar5OcQ6uGhY8fk3PcBi6WSSa3k+4Pj Dx5UuFl9DSiABNVN3lM2wHqxVn8ppRjS1NQUDcuYOlBraFjp9/vXnnXXxXdffz3Q 3y//0JBCx1QqRYOS/NLoXw/KXW43Rb/c/wQaRl++dm1dT6GuKoUkosly0x1BFSs9 08+Kum7f5t4uQR+3eDy+ZB7Y6XLRZy0/5WuxmOK80RYI7Ny9W3RHoCTrWhbRe+cO 3yIm3euBAUgFATBUD7fHw7d0loYRV955Z+3HhMNhVMzTl8fj8fl83LMrQ4ODX924 IWG+1tXQ0UhD88bGRhp/p9NpY3resXHj86dOlfhgingp7o3FYjIvMgex8lvBK1hg OTgwYMwecvqIFVcu0ImIPmvyB70L6B2m0Nff3i66I1CSdU3/1jHfA1JVNVJusW4A +SEAhurBXQzp2d/9btNjj63xALpgTE5OMr16zbJYLH6/n29uv4hCtY8/+KDswqRV j+LYV19/3e3xPPRhmqZR6IsqvlCKSrYBU/R7nzMXtNnR23royBHWomigr2gkkit5 k8h8ODz24AFTT1AACaoerhxQVViLIfkDgVMvv7zGA9Lp9MjICNOr1zhvAetgN5vN fvbJJ3OzsxhSL7dhw4bzly+v8YB86Y4ojd8i2AYPpaukGjDp7uw00XysYYqVfp88 dAhvjomkUyl1PVuoBvr7kyiABFAujPOgqvAWQ6qvv/iwGjDBYBBpfpgYMxXceetW 508/SVshSZS9+/cfPHx4xR8VQ99wOJzB/Dms03rXfC4xPjYWxq6TX8tmMo9u3rx5 61bRHYH1iUUi6xo8sK5/RgEkqHoIgKGqcBdDOvPWW2uXkRgfH0dpU1YG7AoOhUJ/ /fRTvvZNh4Zll69dW/6eI/SFCuWy2RJLDa389Fyuu7PTRLv3udFH9YmDB11ut+iO wPqk02l1PeuNU6nUvb4+FEACKBsCYKgqTqfT7nDwrfvauXv30ePH13jAzMxMpILx HJTCYrG0tbWxJoim4cifP/pI8gpJhlmx/K+qqrOzs1jwDBWioXYmnS776dwFgc0i X+uoqengkSO4HWBGFG6uKwPFg9FRvgxV2WxWVRRsAIbqhrEdVBvWYkgUdJ05d26N B0Sj0RB2zhjCgFrBP/7wQ093d43vo6PBEB3zi/OrJ5PJmZkZrHQAXSTi8UQFx1Iq lbrb24sP6cZHHtn6+OOiOwLloNB3jXLTK6ILE1Nn6lAACWoDAmCoNmKLIdGVY2xs jOnVYYkNGza0trY6HA6+lwiFQp9/+mktV/LxeL2v/Nu/Fb+m4z8cDs+jNgbop4zR /xJ3+/oqmUM2u1w2ux/Lns2sjEUQKIAEUCEEwFBtuIshPfXMM1u2bVvtp7lcbmho iOmlYUU2m43CYL7s37WcHZr+7a+dOVMcW2uaFgqF0jUcaQATJRqtZBt5Ih7vv3ev BieBke25CtA5NrbObVN0MZoYH2fqDwogQY2oufEc1ALWYkjU+EunT6/xgNHRUWyM NBiFpl6v1+Px8MWofT09P9y8WWvZoektfeW112iINjc3h83twCSZSMQrKxx9r7c3 XWOZ2LKZzJbt2x/ZtEl0R6AiqqKk1zlg6L93r5LiYWtDASSoEQiAoQqxFkMil65e XeOnU1NTynqq+YFeGhsbW1tb+RbAq6r6548+qp2MOxT3nj13jmL+6elp3NMBPvl0 4pUtuaTjs6+np3byPzU0NBw4coS7JhxwKy8LOgogAVQOATBUIe5iSP925gy9xGoP CIfDcyhNKQ4FwC0tLXxLAL7/7rt80p0aGGpv2rz5wKFDMzMzojsC1U9T1QontYKD g2oFJYXNIpvJBDZufHznTtEdAR2UcdgnEomBe/dQAAmgQgiAoQo5nU6b3c53i3Tr 9u2/efrp1X5Kg7DJyUmml4YSeTwer9fLtDUuPDf3l08/re7it7lc7vcvvaRVtjAV oET0aVIqG3bXRE3gXO6JQ4f4bu+Ckcpb+DAyPFxh0rg10MeQYnJsAIZagAAYqhNr MSSL1frWhQur/TSVSo2OjjK9NJSOol+fz+dyuZhuln/z1VeDAwNVmX6GRmZ79u3z trSI7gjUkAoLAtcVVt+MjY5WZbK6bDbb6vfv2rNHdEdAN5qmpda/oeZOVxffEY4C SFA7qvA6AUDcbredrToOjUUuXb26WuRDwUMwGKS/mV4d1qWxsbGlpYWpVNLs7Oz/ /PnP1Zd9hz47Tx46JLoXUFvS6bRa8dQTa34ggfYfOOBcfd8NmE5507/0LAqA+e66 qoqCZIdQIxAAQ3XiLoZ0+OjR3Xv3rvbTsbGx2kmVZApNTU0+n48pNVp+V3BfX9VM BWdzuZNPP101/xwwEQqAK6yzlc1m73R3b6iWozeTybRjx281SsTj9Ge9z5qemgpN T3P0pw4FkKDGIACGqpWvDWu1MjXudrv/+Prrq/10enoaVxEJNTc3UxhMf+veMo0b /vrZZ6qimH35JQ24Dxw54sQmQxCh8p3AdYXEQgP9/WbfDEzRSKPF8sTBgxznKxCr 7LTnd3t7+XJPpJJJpDyE2mHusRrAGliLIeWy2cvvvLPaT+fn52exkUZWdFR4vV6O YeXAvXs3v/3WvDEwDcu2bNu28dFHRXcEaldc05IVL58JTU9PTU6a95NIQc72HTs6 HnlEdEeARdmFr7tu3drQ2Kh7f4pQAAlqilkvDwAPxV0M6aVXXmlra1vxp3QhmZiY YHpp0AVTGJzNZr+6cWMkGDRdnSQ6pFtaW3etvrAfwAD5dZjRKH2OKmxnOBiMRaOm i4GzmYy3tXX33r3Yg1DFovPzZWQJURQlODiIAkgAujDZtQFgXfyBAN9CuEceffS3 v//9ij9Kp9MjIyNMrws6ampq8hZWCug7qqCRxN8+/zwaiZhl/E2jMY/Xu/eJJ0R3 BECfhdBk6P59VVVN9Bm0NjXte/JJrHmubqlkUiurYPXg/fvlzRuXgj5001NTTI0D SMgcFwaA8nh5NnwWUWh9/vLl1X4aDAYrn8QAY1gsFo/H43A49J11GR8b++rGjVQq JfkQnEbeLrd7/4EDojsC8LOyg4Ql7vf3x+Nx+T+A1MNde/f6UHisBsQikfLGBt2d nXzrAuhjEp6bY2ocQEJSXxUAKsRdDOncpUvWVfJsIRG06dDYwuWiSNDdqOsmq4F7 976/eVPaslj5uV+fb+/+/aI7AvAr5aXJXW5ocFDm7HTZXG7b9u3Y7lsjyq71lUmn e3t6UAAJQC+SXhIAdMFdDInChoOHD6/4o1AohO00JmW32ykS1ndddHdnZ+etW3q1 ppdsNvvYli2bNm8W3RGAFeiSEItMTU5OT03JtquWPn300aMPoOiOgHGUaLS8NM7j Y2N8M7QogAQ1CAEwVLmW1tbVJmkrZ7Pb33jzzRV/hETQZtfY2OgssFgserVJYXBX Z2c2k5FhPoq6sffJJ70+n+iOAKxKrxg4Go0G79/ny6BbuuJikEcp9MWNpxqTzWZj 5c6y9t65w7eMKJlMzqIAEtQY8YMwAFYej4fCVKbG6Xp2ZZViSEgEXTWamprySwkc Dr0Sqg0ODPz4ww+JREJUGEwDKfpQPHHwoNlrpUItKLtmzBKZTOb+wEAqmRT4uWvY sGHrtm2Bjg4hHQCx1FgsnU6X99yu27f5Tteaqs6XVZcYwLwQAEOVc7pcTrZiSOTp 557bvNIaNiSCrj52u53CYPpbl7WUs7OzN7/5ZnZmxuCVmdlsdtfeva2rVPACkFA6 laIxui4zYPPh8MjwsMG3fuhDZ7Pbd+zaRdcjI18X5FHJ9G94bm58bEzf/iyWX/2M HVtQYxAAQ/Vr8/v1TWu0WKvf/9If/rDij5AIulrZbDSazav8uKIxfXdn593e3ng8 zh0J09G48ZFHtmzfLsMCbIB1oaOXYuBMuRNoi9GHbmJsbGZmhjsMpj5vaGykD92m zZvxoatxlSzm7793L5VM6tufBel0OjQ9zdQ4gLRwRobqx1oMiVy6enXF7yMRdNWz Wq22gqampgrDV1VRbv3004ORkWQyqW8knCt49LHHNm/dqmOzAAajw5jCAB1LoU6M j9PQnz5u+kanFPdSm77W1i3bttGZQceWwaTo0I1WsMaYdf0zCiBBbUIADNXP5XY7 2Ioh0YXt386cca20sG16ehppFWsHjXQpEm5ubqaouJLBSiqVutPVla/dQgdPfX3Z Q/P8etFczu3xbN62DQsvoWpQeEkxcDqV0qtBVVUnx8fzpZIqiITzN5myWUtTU5vf v2nzZr41R2BGldT0SiQSA/fu8a0gUBQligJIUHsQAEP1czqddoeDb33ptu3bTz79 9PLvh8PhOdxYrUk0/G36hcViKTse1lR1oL//wehoNBpNJZM0wm5YvanCCDz/AArC vV5voKODrwg2gFgUAFMYrO8eE2pwbnY2GovlP2u53Nozw9lMJldXt6GxkT5uvpaW jo0brZjshZXkp38pwix3B/vI8DDfBl36BKmKgjv1UIMQAENNoAEK31I0i9X61oUL y7+fn1iYnGR6UTARGklbrVZLQeMvyouKKSSeCYUSiUQqnaYYgFDLLpfL4XJRg7jh ArUjvyI6lUpoGlN5mEwmQx+0ZCKPvm6gD1hDHp3wXW63zWajj3O9ZLWFQUIVpjG/ 09XFN/1Lx/Yc6jVCTUIADDXB7fHYOYshXXz77eXxDA3ORkdHmV4UzI7GNBsKaEhd /IK+U5x0Kn6x8LCFpxQH+rlV0PGm6bc9EsAUihuDE/E4V5XUX39OGwqfU5YXgioV jURy5S5VoNFFT3c33/o1VVUjKIAENQnncagJ+TquTiffwOXg4cN79+9f8k0akA0N DTG9IgAAFOXX/2cyyWQynU6XHWyQ+oaf/TzdWwh3EfFC2dKplKooZT99anJyJhTS sT+L0acmv/oZ65+hJuG0DrWita3NYrEwNe5yuV59443l3x8dHU3pl6wFAADWVtwM T+j/irmpigsn8n/98pj6JQpBL2Jd0F0sGs1mMmU/va+nh6+YIg1O+KJrAMnhXA+1 wuP12mw2psZpnHXl2rXl35+cnFRVlelFAQAAQE6ZdFqpbH6VtQCSpmnz4TBT4wCS QwAMtSKfKMjp5Gv/+VOnOjZuXPLN2dnZeWywAQAAqDEU/VIMXPbTo9Ho6PCwjv1Z groXZcsvDSA5BMBQQ/yBAN/N1PaOjt+/+OKSb9LVJYQlRgAAALUkm8lUWL7ofn9/ IpHQqz9LZDKZ6akppsYB5IcAGGqI1+drbm5mary+vv7i228v+WY8Hh8fH2d6RQAA AJCQpigVZgBhXf9Mg5MwyuZBDUMADDXE7XbbHQ6mxnO53BtvvbWk2FImkxnmXMIE AAAAUslls9FIpJIWKHi+19fHl5VNVZRIZT0EMDUEwFBDnE4nBcB8JfUe37nz+MmT S74ZDAb5sjgCAACAVOKalqxs9fLoyEiFIfQaaExCATAKIEEtQwAMtaWltdVqtTI1 bm1qevP8+SXfHBsb49vGAwAAAPLI5XLRipNf3unu5hugJ5PJ2ZkZtuYBTAABMNQW t8ezZJWyjrKZzKVr15bMME9PT+M+KwAAQC2g8DJeWflDCqHvdHY2sG0AVlU1gvoU UNsQAENtcbpcDoeDb1/N4WPHdu/Zs/g74XB4DqkmAAAAakB0fp4i2EpaCE1P86Vo pr4pilJhhmoAs0MADDWnta3NYrEwNe52u//4+uuLv0NXmikUGwAAAKh26VRKVZQK G7nb25vJZHTpz3KpVGoG1Rmh5iEAhprj8XptNhtT47lc7vK1a4u/k0gkxsbGmF4O AAAAJBGLRrMVx66sBZA0TZsPh5kaBzALBMBQc1wul8PpZGqcAuBTL78caG9f+E42 mw0Gg0wvBwAAADLIZDJKxUuLY7HY8NAQ30YtJUZBOtY/Q61DAAw1x+l02ux2vtur HRs3Pn/q1OLvDA8P8y1nAgAAAOFURUmnUhU2MjgwEI/HdenPcjQU0VQViTkBEABD LfL5fE3NzUyNNzQ0XLhyZfF3UAkJAACgimWz2ZgelXu7OzuX1JLQUSIeR1ZOgDoE wFCb3G633eFgajyXy509d6550TZjVEICAACoYnFNS1Z8pzuVSt3r6+Nb/6wqSkSP KB3A7BAAQy1yOp0Op5PvGrNz9+6jx48v/Ofc3FwYOScAAACqUS6Xi+pRWffB6Chf hd58AaRYDLfjAeoQAEPNamlttVqtTI03NTWdPX9+4T/pejM9Pc30WgAAACBQMpGI a1rl7fR0d1feyGqSyeTszAxf+wAmggAYapTH47HZ7UyNZ7PZy9euLcwwoxISAABA VcpP/0Yi9H+Vt9Pd2clYAElV59mmlwHMBQEw1Ciny+VwOPhWQR87cWLHrl3FrzOZ zPDwMNMLAQAAgCipZJJiy8rbmQmFpiYnK29nRfn1z4oSQwEkgAIEwFC72vz+xsZG psY9Hs8rr7228J/BYDCbzTK9FgAAAAgRi0R0ub7f6+1Ns1VMTKfTIWzFAvgFAmCo XV6vd3GuZn3R5fDKO+8s/OeDBw+SySTTawEAAIDxKLBUdUor1XnrFt9N+bimIRkn wAIEwFC7XC6Xw+lkajyXy710+nSb31/8z6mpKUVRmF4LAAAAjKcqSjqVqrwdGiEE Bwf5tmUpsVgU658BfoEAGGqX0+m02+0NbAknNj7yyO9eeKH49ezsLJJPAAAAVI1s JqPXrtqh+/c1PfJIr4j6qaoqCiABLEAADDXN19LS1NTE1HhDQ8OFK1eKX0cikRmU HwAAAKgWcU1LJhK6NNXd2UljBl2aWi6RSMzNzjI1DmBGCIChprndbrvDwdR4Lpc7 e+5ccZuxpmkTExNMLwQAAABGylc/0mlhVyqVutfXx7f+WVWUSCTC1DiAGSEAhprG XQxp5+7dR48frytc3kZHR5leBQAAAIyUIDotWn4wOhph2ySFAkgAyyEAhlrX0tpq tVqZGm9qajp7/nxd4Qo0NDTE9CoAAABgmPz0byRC/6dLaz3d3bq0s6JkMjmLHVgA v4YAGGqdx+Ox2e1MjWcymSvvvFOcYR4ZGUmn00wvBAAAAMZIJZOaqurSFMXS3Z2d G9jycVI/kYMTYAkEwFDrnC6Xk60YEjl6/PjO3bvpi/Hx8Xg8zvdCAAAAYAAlGs1k Mro0FZqenp6a0qWpFcViMax/BlgCATBAXZvfz1d93uPxvPLaa/QFXeNQhAAAAMDU Mum0ot/V/G5vr16x9HLpdJoCbKbGAcwLATBAndfrLeZq5pDLZi+/8w59EQ6H5+bm mF4FAAAADKApSiqV0qu1rlu3NrDdgo9rGo09mBoHMC8EwAB1LrfbwVkM6dTLLwfa 22Ox2DRuxAIAAJhWNpuN6VdSiAYGw0NDfKUoFEWJogASwDIIgAHqnE6n3W5vYEtB 0bFx4/OnTsXj8fHxcaaXAAAAAG5xTUsmEnq1NjgwwJccJJvJqKqKvVcAyyEABsjz tbQ0NTUxNV7f0HDxypV0Oj0yMsL0EgAAAMAqX/1I14zKXZ2dGxoadGxwsUQiMTc7 y9Q4gKkhAAbIc7vdds5V0GfeeqvZZgsGgzmdygYCAACAkZLJZFyn6kcklUrd6+vj W/+sKkoE658BVoIAGCDP6XQ6nE6+69COnTuPnTw5OjqqY+YMAAAAMEwsGs3ql7H5 wcgIX4Cay+WUfAUkrH8GWAECYICftbS2Wq1WpsabrNazFy5MTExomsb0EgAAAMAk nU6rusaTPV1ddWy33ZPJ5OzMDFPjAGaHABjgZx6Px2a3MzWeyWQuX7s2OzsbRT16 AAAAs1EVJa3fGq5cLtfd2bmBLfumpqrzum5XBqgmCIABfuZ0uRwOB98q6MPHjrV3 dKAUMAAAgLnoW/2IhKanp6emdGxwsfz6Z0WJ4YY7wCoQAAP8S1tbW6PFwtS42+3+ 7QsvoBQwAACAuehb/Yjc7e3N6LedeIl0KhUKhZgaB6gCCIAB/sXr9TbbbEyNZ7PZ l155BRkpAAAATCSXy8UiEX2LOHTdvs23/pnC9XA4zNQ4QBVAAAzwLy6Xy+F08rW/ Z/9+j9fL1z4AAADoS9/qR3WFbNIjw8M6NriEEosh4QjAGhAAA/yLy+12sFUDJk3N zYeOHuVrHwAAAPSlb/UjcrevL5NO69jgEoqiRFEBGGB1CIAB/oW7GnA2l3vq2WeZ GgcAAAB9UaSq6L13qauzc0NDg75tLkAFYICHQgAM8Cus1YDpsrT/wAGX283UPgAA AOhIU5SUftWP6grTs8HBQb5b7agADPBQCIABfoV7FbTD6Xzi4EG+9gEAAEAXulc/ Ivf7+xO6JpReAuufAR4KATDAr7Cvgs5mn3ruOabGAQAAQC+JeJz+6Nsma/5nrH8G KAUCYIClWltbLZyroPc+8QRyQQMAAMiMo/oRhabDQ0N8N9lTyeQM1j8DPAwCYICl 3G63nXMVNDX+5KFDfO0DAABAhSiY1HStfkQG7t1LJpP6trmYqigRrH8GeBgEwABL ca+CzuVyv0EuaAAAAIkpsZjuxYrudHWxji6w/hmgFAiAAVbQ2tZmsVj42t+6fXv7 xo187QMAAEDZMpmMEo3q2+bszMzkxIS+bS6WSqVmQiG+9gGqBgJggBVw54L2eL17 9u/nax8AAADKpqlqSu+1ykODg7qvqV4M+Z8BSoQAGGAFTqfTbrc3sOVptFgsR06c YGocAAAAypbL5aLz87o329fTk81mdW+2KJvJqKqK9c8ApUAADLAyr8/X3NzM1Hgm k3n6t79lahwAAADKlkwk4pqme7Odt283st1Yj8fj4bk5psYBqgwCYICVuVwuh9PJ 1Hgulzt07BhfgA0AAADliUWj2UxG3zaTyWT/3bt8GbCUGPVa503LANUKATDAqgLt 7Q0NDVyNd3Rse/xxpsYBAACgDOl0WmVYSDz24MF8OKx7s0XZbHZqcpKpcYDqgwAY YFUtra3W/8/enT05da1vns9UatbemnIAYzDGxmBjYzMlSTJ1VEfURUVXRV3XRdU/ Vxd9XVHVURcV0RVdER1R3dE3JjMhk8nAARJyVEra89RLEsbYB0MOerW3pO8nOHn4 4fN7tBLb2nrY+10rmxUKZwwYAICksQzD87y+x4oOALuuu7O9LRQOjB4KMPC3RPeC VhfCxTt3hMIBAMBBqUtzW2Yj5eV796bEBoDZ/xk4EAow8CnHjh8XmtiJoujK9ety d5gBAMCBOLatfvQ91vO8R2trch8nRI8XBkYPBRj4lJnZ2XQ6LRR+/MSJ02fOCIUD AID9U02y3Wyqr31PXl9fb+zs9D22x/f9rc1NoXBgJFGAgU+pVKuFQkEoPJvLXb52 TSgcAADsn+95pmFIJD9cXQ36va30e5ZlyW2vBYwkCjDwKZqua2KHITEGDABAQqj2 6wtsfzUhPADcbndOQBIKB0YSBRj4jNm5OaHrVhRFVxcWMpmMRDgAANgnue2vfN9/ uLoqNAAcBMHmxoZEMjDCKMDAZ9Tq9VwuJxR+4uTJU6dPC4UDAID9ENr+Snn75o3c GUWO4+yKTRcDo4oCDHxGpVIpFItC4bl8/tLVq0LhAADgs6Io6hwjJLD9lfJwbS3w fYlkxTLNvb09oXBgVFGAgc8QHQOOwvAGY8AAAMRHbvsrZeXevRQDwECSUICBz1Dt t1gsCl29oii6duOG3ElLAADg0+S2vwqCYO3BA6EB4DAITNNUFVgiHBhhFGDg80TH gL88derkV18JhQMAgE+Q2/5K2Xj7dntrSyicAWDgcCjAwOcxBgwAwEiS2/5KebS2 5jMADCQMBRj4PF3XS3KnAQfB4t27QuEAAODviG5/FYbh/eVluROAjc78LwPAwIFR gIHP64wBl0qpVEoinDFgAABiIbr91dbmptwhvapdq5UzAAwcAgUY2Jd6vZ5lDBgA gBGiGqTcGUWr9+9HMveWFddxdhgABg6FAgzsS6VaLRQKQuGpqan5GzeEwgEAwD8T 3f5KWb53T+75Z8uy9hoNoXBgtFGAgX2RHQMOw0VOAwYAYIAcxbKEwqMoerCyInQA 0gQDwMARUICBfZEeA55fXJT7c2IAAPAXrb09uUeUt7e2Nt6+FQpnABg4CgowsF/1 6elsNisUPj07e/bcOaFwAADwId/3TckCufrgQRSGQuGu6+5sbwuFAyOPAgzs1/TM TCaTEQqPoujG7dtC4QAA4EOmYfieJ5fPADCQWBRgYL9q9XpObCPoMIoWKcAAAMjr HP+7tyeaf39pKSVTgHn+GTgiCjCwX+VKpVgsCoWri+WV+Xm5k5YAAECPY9vqh1x+ o9FYf/VKKJznn4EjogAD+6VpWknT5HZ0nJ2b++a774TCAQBAT7vZDMUGdJVnT59a YvtL8/wzcEQUYOAARPfBmpqausZpwAAASAqCwBA+QOj+8rLgAUiG0ZI8vhgYeRRg 4AAqlUpB7ClodUm+efeuUDgAAFAs0/RcV/Ql5HbAiqKoM/7LADBwBBRg4AA0Xdc0 TS7/7Llz07OzcvkAAIwz6e2vlL29vdcvXwqFq+q+zQAwcDQUYOBgZmZm0mKHIamC /ePPPwuFAwAw5lzXtU1T9CV+e/rUFhsAVskNBoCBo6EAAwdTrVbzhYJQeDQxcePW LaFwAADGXLvVCoNA9CUYAAYSjgIMHIyu6yWxp6DDMLx+86bQ4BAAAONMXWTb8u2R AWAg4SjAwMFomlYoFuU66qmvvz7x5ZdC4QAAjC3bNF3h7a+ae3uv5AaAPW97a0so HBgfFGDgwGr1ei6XEwpX7frny5eFwgEAGFuqnU5EkehLMAAMJB8FGDiwcrlcLJWE wqMounH7tlA4AADjyfc80zCkX4UBYCD5KMDAgWmaVtI0oStcGIYLt26lUimJcAAA xpPRagXC219NMAAMDAMKMHAY0zMzGbHDkE5/883xL74QCgcAYNwMZvurvUbj9atX QuEMAAP9QgEGDqNSrRbEDkPiNGAAAPpoANtfKb89eWLbtlC4Sm7s7gqFA2OFAgwc hl4ul8TGgJUFTgMGAKBPWnt7kfD2V8rK0pLcBBMDwEC/UICBw9A0rVgqCV3ngiC4 efeuRDIAAONmMNtfqYJ9f3lZ6INBZwDYMNqtlkQ4MG4owMAh1aens9msUPj3P/5Y qVaFwgEAGB+qN4by21/t7uy8WV8XCmcAGOgjCjBwSKJjwLXp6XPffy8UDgDAmIii qLW3N4AXevL4ses4QuEMAAN9RAEGDkl0DHgqnb62sCAUDgDAmBjM9lcTDAADw4MC DByS7GnAQbDIGDAAAEcwsNu/YRg+WFlhABgYChRg4PCmp6czMmPA6mp36dq1fD4v EQ4AwDjwPM+S3/5K2dzY2NrcFApnABjoLwowcHjVajUvNgY8d/z4mW+/FQoHAGDk DWb7K+XR2prv+0LhtmU1Gg2hcGAMUYCBwxMdA85kMleuXxcKBwBgtIVh2B7U3OzK vXupqSmhcAaAgf6iAAOHJzsGHIaLd+5IJAMAMPIs0/QGsv2V53mP1taEPgx0BoDb HRLhwHiiAANHMjM7m06nJZLVNe/K9etyRw0DADCqBrb9lbL++rXcGUWqw29vbwuF A+OJAgwcSbVWk9uq6viJE6fPnBEKBwBgVLmua5vmYF5rbXVVbtLYsqw9BoCBvqIA A0dSrlSKxaJQeDabvTw/LxQOAMCoajebYRgO5rWWfv1V6FmwCQaAAQEUYOBINF3X NE0onDFgAAAOKvB9Y1BDs7ZlPX3yRG43ENMwGAAG+osCDBzV7NzclMzej5wGDADA QanS6HveYF7r5YsXrVZLKNx13R0GgIF+owADR1Wr13O5nFD47LFj35w9KxQOAMCI GeTpR8qDlRW5cMs09wa1lRcwPijAwFFVKpWC2BjwVDp9bWFBKBwAgBHj2Lb6MbCX W/711ym5AeB2W+72MjC2KMDAUem6XhIbAw6C4Obdu0LhAACMkiiK2s2m+jqYl1Pt 9OWLF0Lh6gOAZZoMAAN9RwEGjkrTtGKxmJIZA1a+//HHSrUqFA4AwMjwPM8yjIG9 3G9Pn9qWJRTuOM7uzo5QODDOKMBAH4iOAZer1R9+/FEoHACAkWG024HvD+zlVpaW UqmUULhpmk0GgAEBFGCgD0THgJWFW7fkwgEAGAFhELQHODEbRdH95WW5Atxutwf5 7QDjgwIM9IHoGHAYhqoAy11iAQAYAbZluY4zsJfb3tzc2NgQCvd9f2tzUygcGHMU YKA/5E4DVk6dPn3i5EmhcAAAhl0URa1mc2JQ218pjx4+lDtt2Lbtxu6uUDgw5ijA QH+IjgHn8vlLV68KhQMAMOxcx5Hbj+qjVu7dk9v/0jSM5gBPMwbGCgUY6I9ypVIU GwMOw3Dxzh2hcAAAhl271QqDYGAv53neo7W1yUmRD9JRFBmdCWAOQAJEUICB/tB0 vVQqyV0Lf7lyRXSfLQAAhpTv++Zg6+L669dyjyirdr29tSUUDoACDPTNzMxMOpMR Cq/PzHx3/rxQOAAAw8s0DLlx3I9ae/AgDEOhcNuyGo2GUDgACjDQN9VaLZ/PC4Wn Uqn5xUWhcAAAhpQqou2Bj8su37snt/OlYRgtBoABMRRgoG/0crlUKgmFB0GweOeO 0CPWAAAMKce21Y9BvqJpms+ePhW6Iqs+bxoGA8CAHD5MA32jaVqxVJI7sPfMt9/O HT8uFA4AwNCJoqjdbEYDPP1IefHsmWEYQuGu6+5sbwuFA5igAAP9NT0zkxEbAw6C 4Obdu0LhAAAMHc91LdMc8IuKPv/MCcCANAow0E+VSkVur+Yoiq7duJFOp4XyAQAY Lka7Hfj+IF9Rvdza6qrcRJL6jlqtllA4gAkKMNBfmq5rmiaX/+WpUye/+kouHwCA YREEgTHwrvj82TNT7PlnTgAGBoACDPTZ3LFjcmPAuXz+0tWrQuEAAAwRyzQ91x3w iy4vLU2JXeU5ARgYAAow0Ge1ej2XywmFh2G4eOeOUDgAAMMiiqLW3t7gX3dlaUnu j7kty9rjBGBAGAUY6LNyuVwUOwyJMWAAABTXcWzLGvCLep73+OFDufzO088MAAPC KMBAn2maVtI0ue0xGAMGAIy5zqxsqxWG4YBfV3QAWH07G2/fCoUDeI8CDPTfzOys 3E1axoABAGPO9zy5IvoJj9bWfLFNpxkABgaDAgz0X7VWy+fzQuFRGN5gDBgAMMZU +1UdePCvu3LvXkrsBGDLNPfimGoGxg0FGOg/XddLYochRVF0dWEhk8kI5QMAkGRh GLabzcG/ru/7D8VOAO481G0YDAADA0ABBkTUp6ez2axQ+ImTJ0+dPi0UDgBAktmW 5TrO4F/37Zs3O9vbQuEMAAMDQwEGRFQqlUKxKBSey+UuXbsmFA4AQGJFUdRuNtXX wb/0w9XVIAiEwl3XlWvXAD5EAQZEiD4FzWnAAIDx5LmuZZqxvPTyvXtTYgPApmk2 GQAGBoICDIjQNK1YKqVSKYnwKIquXL8u94g1AADJZLRacrdhP8HzvEdra4IDwJ0j gNsS4QD+ggIMSKnX69lcTij8+IkTp8+cEQoHACCBVPU1Ytoman19vbGzIxTOAUjA IFGAASmiY8DZbPby/LxQOAAACWSZpue6sbz02oMHYRgKhXMAEjBIFGBACmPAAAD0 SxRFrfhaougAsNFutzgACRgUCjAgpTMGXCymZK6X6nPA5fn5nNgj1gAAJIrrOLZl xfPSrvv44UOhAeAwCEzTZAAYGBgKMCCoVq/LddRjx49//e23QuEAACRHZ5uoVkvu IeRPW3/1qtFoCIU7jrMrNl0M4J9RgAFBomPAmWz2CmPAAIAx4HueaRhxvfra6moo tvU0A8DAgFGAAUGarmtiY8BBENy8e1coHACA5FDtV3XguF596d69tNgAcOf4IwaA gQGiAAOyZufmhLbNiKLo0tWr+UJBIhwAgIQIw7DdbMb16o7jPHn0SGgAOAiCzY0N iWQAf4cCDMgSHQNW7fqb774TCgcAIAlsy3IdJ65Xf/XyZVPsEWUGgIHBowADssqV SlFsDDidyVy9fl0oHACA2EVR1G421de4FrD64EEktvmWaZpy7RrAR1GAAVmiY8Cc BgwAGG2u69qmGeMCRE8AZgAYGDwKMCBOdAz458uXi6WSRDgAALEzWq1AbAfmz7It 6+mTJwwAA6OEAgyIEx0Dnp6dPXvunFA4AAAxCnzfaLdjXMDLFy9aYndoGQAGYkEB BsSJjgFPTU1du3FDKBwAgBhZpum5bowLeHD//oTY+DEDwEAsKMCAOE4DBgDgoKIw bMV3+lEPA8DA6KEAA4MgNwasXLh4US+XhcIBAIiFY9vqR4wLMA3j+bNnQuEMAANx oQADgyA6Blyt18//8INQOAAAg9c5/ajVkjt/aD9ePHtmGIZQOAPAQFwowMAgiI4B p1Kp+cVFoXAAAAbP8zxLrHzu04OVFblwBoCBuFCAgUFgDBgAgP0z223f9+NdAwPA wEiiAAMDMjM7m06nhcLP/fBDrV4XCgcAYJDCIIi9HLaazZf/+IdQuOr2W5ubQuEA Po0CDAxIrVbL5fNC4eVK5YeffhIKBwBgkGzLch0n3jU8e/rUsiyhcMe2d3d3hcIB fBoFGBgQ0THgicnJhZs3pcIBABiUzvZXzWYkdvruPq0sL6cmpT4nMwAMxIgCDAyI puulUmlS5moaBMHinTtC4QAADIzrurZpxrsGVb9XlpaEBoBVuGEYsT/jDYwtPi4D gyM6Bvztd9/NzM0JhQMAMBiqGYZBEO8aGru7669fC4UzAAzEiwIMDE61VsuLjQFr uv7jzz8LhQMAMACB7xvtdtyrmHj6+LEjNoRs23aDAWAgPhRgYHDK5XKxVJJKj6KF 27elwgEAkGeZpue6ca9iYmVpKZVKCYWbhtFsNoXCAXwWBRgYHE3TSpomNKkbhuHC rVtyF2wAAESpC1k7Ac1QLePByorQ9bQzANw5Ajj+u9zA2KIAAwM1PTOTyWSEwk+f OXP8xAmhcAAARDm2rX7EvYqJ7a2tjbdvhcI9z1P5QuEA9oMCDAyU6BhwoVT6+dIl oXAAAOR0Tj9qtaIwjHshE48fPZJ7DJsBYCB2FGBgoPRyuSQ2BhxG0SJjwACAIeR5 nmUYca+iY/nePaEDkBTDMFoJeMwbGGcUYGCgpMeAr9+8KXfZBgBAiNlu+74f9yom giBYvX+fAWBghFGAgUETHQP+8tSpk199JRQOAICEMAjarVbcq+jYePtWbkaXAWAg CSjAwKBVq9V8oSAUnsvnL129KhQOAIAE27JcsXN3D+Th2logdiNafZuNRkMoHMA+ UYCBQZMdAw7DxTt3hMIBAOi7KIo6Y7FRFPdCOhgABkYeBRgYNNExYPUx4sr8fDaX kwgHAKDvXMexLSvuVXR4nvdobU3uAs0AMJAEFGAgBvXp6Ww2KxR+7Isvvv7mG6Fw AAD6q91qhUEQ9yo61l+/ljujyHXdne1toXAA+0cBBmJQqVYLYmPAmWz2yvy8UDgA AH3k+76ZmJuia6urclXcsqw9BoCBBKAAAzHQdb2kaULhQRDcvHtXKBwAgD6yDMPz vLhX8c7Sr7+m02mhcKPdbiVjp2tgzFGAgRhomlYsleSOGfz5ypVisSgRDgBAv4Rh 2E7MplC2bT99/FhoAFh9p6ZhMAAMJAEFGIiH6Bjw9Ozs2XPnhMIBAOgLx7bVj7hX 8c7LFy/k7tAyAAwkBwUYiEelUimI3aSdmpq6duOGUDgAAEcXRVG71YrCMO6FvPPg /n25o5gs09zb2xMKB3AgFGAgHowBAwDGmed5lmHEvYo/yJ4AzAAwkBgUYCAemqYV ikW5a+0PP/1UrlSEwgEAOCLVCQPfj3sV7xiG8eLZM6HwIAgs02QAGEgICjAQm1q9 nsvlhMKrtdr5CxeEwgEAOArVCY0k3RF9/uyZKXY72nGc3Z0doXAAB0UBBmJTrlTk 9mqeTKWuLy4KhQMAcBS2ZbmOE/cq/nB/ZUXuM7Fpmk0GgIHEoAADsdF0XWMMGAAw ZqIoajWbcjtOHYLoAHC73ZkAFgoHcFAUYCBOs3Nzclfcs+fPT8/MCIUDAHA4ruPY lhX3Kv6wt7f3+uVLofAgCDY3NoTCARwCBRiIU61Wy+XzQuF6uXzh4kWhcAAADqfd aoVBEPcq/vDbkye22HHEjm3v7u4KhQM4BAowECfRMeBoYuLGrVtC4QAAHILv+2bC 9kNeWVpKpVJC4QwAA0lDAQbipOl6qVSanBT5NzEMw4Vbt+Qu6gAAHJRpGL7nxb2K P0RRdH95WehaqcINw2AAGEgUCjAQs5nZ2XQ6LRR++ptvjn/xhVA4AAAHEoZhu9mM exV/sr21tfH2rVC47/tbm5tC4QAOhwIMxKxaq+XFxoCLpdLFS5eEwgEAOBDHth2x advDefzokee6QuG2bTcYAAYShgIMxKxcLquaKhQeRtHi7dtC4QAA7F8URe1mM0rS 6UcTwgcgmYbRTNgdbwAUYCBm0mPA84uLco9YAwCwT57rWqYZ9yr+JAiC1fv3GQAG xgoFGIjf9MxMJpMRCj9x8uSp06eFwgEAI0xVuD7++azRbge+36+0vnj75s3O9rZQ uOd521tbQuEADo0CDMSvWq3mCwWh8Fwud+naNaFwAAD2IwgCI3n3Qh+urgZiJxLb ltVoNITCARwaBRiIn14ul+TGgMNw8c4doXAAwKjq7+1f2zRdsb2mDk10ANgwjBYD wEDyUICB+GmaVtI0oTFg9Qnm0rVrchtNAwDwaepK1KmCCdv+ShXyxw8fyl18jXaH RDiAo6AAA4lQn57OZrNC4bPHjn1z9qxQOAAAn+Y6jm1Zca/ir169fNnc2xMKV+1a broYwFFQgIFEqFSrBbEx4Kl0+trCglA4AACf1m42wzCMexV/tXr/vtyZTJZl7TEA DCQSBRhIBF3XS5omFB4Ewc27d4XCAQD4BN/3zUQ+CSw7ANxut5K36ReACQowkBCa phVLJbmjCH/85RfVsSXCAQD4BNMwfM+LexV/ZZrms6dPhQaAwzBU3zUDwEAyUYCB pKjV67lcTii8Wq+f/+EHoXAAAD5KVcF2IndCfvHsmWEYQuGO4+zu7AiFAzgiCjCQ FJVKpVAsCoVPplLXFxeFwgEA+CjHttWPuFfxEfdXVuQ+BFumuSe2vRaAI6IAA0mh 6brGGDAAYFREUdRuNuU2mjoK0QHgzvFHDAADSUUBBhJkdm5O7np89vz56ZkZoXAA AP7Cc13LNONexUfsNRqvX70SCg+CYHNjQygcwNFRgIEEER0D1nX9ws8/C4UDAPAX Rrsd+H7cq/iI3548scUezGYAGEg4CjCQIOVKpSg2BjwRRQu3b0uFAwDwgSAIjKQ+ BryytCR07MJEd3/pJgPAQIJRgIEE0XS9VCrJncqwcOuW3CUfAID3LNP0XDfuVXyE uho+WFmRO3fQMAwGgIEkowADyTIzO5tOp4XCvzpz5osTJ4TCAQDoUT2wldS7oNub mxtiM7q+729tbgqFA+gLCjCQLNVaLZ/PC4XnC4VfrlwRCgcAoMd1HNuy4l7Fxz16 +ND3PKFw27Ybu7tC4QD6ggIMJEu5XC6WSkLhURjeuHNHKBwAgJ52sxmGYdyr+LiV e/dSYgcumIbRbDaFwgH0BQUYSBbRMeAoiq5ev57JZiXCAQCY6D4GbLbbca/i49Ta Hq6uyl1kGQAGko8CDCTO9MxMJpMRCj9+4sTpM2eEwgEAMA1D7hnjI1p//VruEWXP 87a3toTCAfQLBRhInGq1mi8UhMIz2eyV+XmhcADAmAvDsJ3gZ4DXVlfDIBAKty2r 0WgIhQPoFwowkDh6uVwSGwNWF/7Fu3eFwgEAY86xbfUj7lX8reVff50SO2rBMIxW gss/gB4KMJA4mqYVSyW5Iwp/vnxZbp8tAMDYUpeYdrOpvsa9kI+zLevpkydCA8Bh GJqG0U7q8DOA9yjAQBLVp6ezYltV1Wdmvjt/XigcADC2PNe1TDPuVfytf7x4IbdD leu6O9vbQuEA+ogCDCRRpVotiI0Bp1Kp+cVFoXAAwNgy2u3A9+Nexd96sLIiF25Z 1h4DwMAwoAADSaTreknThMKDILjJGDAAoK/UxcVI9glAy/fuTYmdAKzKfyvZ3z6A HgowkESdMeBiMSV2nT73ww+1el0oHAAwhizT9Fw37lX8rWaz+eof/xAKD4PANE0G gIGhQAEGEkoV1FwuJxSul8sXLl4UCgcAjJsoilp7e3Gv4lN+e/LEFtue2nGc3Z0d oXAA/UUBBhKqXKkUi0Wh8Ghi4satW0LhAIBx4zqObVlxr+JTVpaWhI5XUEzTbCa7 /wN4jwIMJJSm65rYGHAYhgu3bsl9FAAAjI8oioxWS11Z4l7I31IrvL+8LHfVa7fb cvtLA+gvCjCQXDOzs+l0Wij89Jkzx0+cEAoHAIwP3/fNZI+/bm9tbbx9KxSuvv2t zU2hcAB9RwEGkqtaq+XzeaHwQrH48+XLQuEAgPFhGobveXGv4lMeP3zoia3Qtu3G 7q5QOIC+owADyVUul4ulklB4GIaLd+4IhQMAxoS6mrSbzbhX8RmiByCp/t9M/O8A gPcowEByaZpW0rTJSZF/T6Mounr9eiablQgHAIwJx7Ydsd2V+8L3/Yerq3IXU6Mz AZzoJ8ABfIgCDCTa9MxMJpMRCj9+4sTpM2eEwgEAI0/Vv3azqb7GvZBPWV9fb4id UeR53vbWllA4AAkUYCDRqtVqvlAQCs9ks1fm54XCAQAjz3NdyzTjXsVnrK2uhkEg FG5bVqPREAoHIIECDCSaXi6X5MaAg2Dx7l2hcADAyDPa7cD3417FZyz/+uuU2JEK hmG0GAAGhgoFGEg0TdOKpZLQ0YVRFP18+bLcPlsAgBEWBIGR+MNvbct6+uSJ0ABw GIamYTAADAwXCjCQdPXp6azYVlX1mZnvzp8XCgcAjDDLND3XjXsVn/GPFy/aYi3d dd2d7W2hcABCKMBA0lWq1YLYGHAqlZpfXBQKBwCMqiiKWnt7ca/i8x4sL0/I3P5V LMvaYwAYGDYUYCDpdF0vaZpQeBAENxkDBgAckOs4tmXFvYrPEz0B2Gi3W4l/CBzA X1CAgaQTHQNWzp4/Pz0zIxQOABg9ncNvW60wDONeyGfs7e29fvlSKJwBYGBIUYCB IVCr13O5nFC4rusXfv5ZKBwAMHp8z1PdL+5VfN5vT57Yti0U7jjOrtjxwgDkUICB IVCuVIrFolR6FC3cvi0VDgAYOar9qg4c9yo+b2VpSe75KdM0m8MwBQ3gLyjAwBDQ dF0TGwMOw3Dh1i25jwgAgFGirhrtYTj5Vq3zwcqK3NWt3W7L7S8NQA4FGBgOM7Oz 6XRaKPzU6dMnTp4UCgcAjBLbslzHiXsVn7e5sbG1uSkU7vu+XDgAURRgYDhUa7V8 Pi8UnsvnL129KhQOABgZURS1m031Ne6FfN6jtTVVU4XCbdtu7O4KhQMQRQEGhkO5 XC6WSkLhYRgu3rkjFA4AGBme61qmGfcq9kX0ACTTMJrD8Bw4gH9GAQaGg6ZpJU2b nBT5dzaKosvz83IbTQMARoPRagVBEPcqPs/zvEdra3IXzc7xRxyABAwnCjAwNKZn ZjKZjFD43PHjZ779VigcADACVPU1hmTbp9evXu01GkLhql1vb20JhQOQRgEGhka1 Ws0XCkLh6XT66sKCUDgAYARYpum5btyr2JfV+/flBpVty2qItWsA0ijAwNDQy+WS 2BhwEAQ3794VCgcADDvVJ1vDc+yt6ACwYRgtBoCBoUUBBoaGpmnFUknuSMMLFy+q ji0UPni+78sdHAUA48Z1HNuy4l7FvpiG8fzZM6HwMAxVPgPAwPCiAAPDpD49nc1m hcKrtdr5CxeEwgEAw6uz7VOrpbpf3AvZF9V+VUcVCnddd2d7WygcwABQgIFhUqlU CsWiUPjk5OT1mzeFwgEAw8v3PLlK2Xf3l5eF9n+e6A5C7w3Po+AA/hkFGBgmuq6X NE0oPAiCxTt35D40AACGlGq/qgPHvYp9iaJoZWlJcAC43W4NyVbYAD6KT7rAkJmd m5O7rn9z9uzssWNC4QCAYRSGYXt49nza3dl5s74uFB4EwebGhlA4gMGgAANDplav 53I5ofCipl385RehcADAMLIty3WcuFexX08eP5ZbreM4qmALhQMYDAowMGTKlUpR bAw4iqIbt28LhQMAho66LrSbTbkzdftueWlpSuy4BNM0mwwAA0OOAgwMGU3XS6WS 0KRuGIbzi4ucHgQA6PFc1zLNuFexX0EQrN6/L3ReYGcrbMNoMwAMDDkKMDB8ZmZn 5TrqiZMnT50+LRQOABguRqulWmXcq9ivt2/eyJ1R5Pv+1uamUDiAgaEAA8OnWqvl 83mh8Gw2e3l+XigcADBEVPU1huqG58MHDwKxw4pt227s7gqFAxgYCjAwfPRyuVQq CYWrjzs3794VCgcADBHLND3XjXsVB7B0715a7gAkw2gNz27YAP4OBRgYPpqmlTRN aAw4iqKfr1yR22cLADAU1OWgNVQbPtm2/fTxY7mLo9HukAgHMEgUYGAoTU9PZ7JZ qfDZ2bPnzgmFAwCGgqNYVtyrOICXL160xB7Y9lx3W2y6GMAgUYCBoVSpVguFglD4 1NTUtRs3hMIBAMnXueHZaoVi87QSHqysyIVblrXXaMjlAxgYCjAwlHRdL2maULj6 xLN4545QOAAg+XzPMw0j7lUczPK9e1NyA8DtttztZQCDRAEGhpKmacVSSeioQ+W7 77+vT08LhQMAEk61X9WB417FATT39l69fCkUHoah+g1hABgYDRRgYFjV6vVcLicU rpfLFy5eFAoHACSZ6nvtYdvu+LcnT2zbFgp3HGd3Z0coHMCAUYCBYVWuVAT3ao6i hdu3pcIBAAlmW5brOHGv4mBWlpbknooyTbM5VBtiA/gECjAwrDRd1yTHgBdu3ZL7 MAEASKYoitrNpvoa90IOQF2zHqysyF2zOscfMQAMjAoKMDDEZmZn0+m0UPip06dP nDwpFA4ASCbPdS3TjHsVB7O1ubm5sSEU7vu+yhcKBzB4FGBgiFVrtXw+LxSeLxR+ uXJFKBwAkExGqxUEQdyrOJhHa2uqpgqF27bd2N0VCgcweBRgYIiVy+ViqSQUHkbR ImPAADBOVPU1hvBZ3+WlpSm5AWDDaA7blmAAPoECDAwxTdNKmjY5KfIvchRFl+fn 5TaaBgAkjWWanuvGvYqD8Tzv0dqa3KWwc/wRByABI4QCDAy36ZmZTCYjFD53/PiZ b78VCgcAJIoqe60h3Ov49atXe42GULhq19tbW0LhAGJBAQaGW7VazRcKQuHpdPrq woJQOAAgURzFsuJexYGt3r8vt2e1bVkNsXYNIBYUYGC46eVySWwMOAiCm3fvCoUD AJKj86xvqxWGYdwLObDle/empqaEwg3DaDEADIwWCjAw3DRNK5ZKcocf/vDTT+VK RSgcAJAQvueZhhH3Kg5MFdQXz54JhYdhqH5PGAAGRgwFGBh69enpbDYrFF6pVr// 8UehcABAQqimpzpw3Ks4sGe//SZ3arHrujvb20LhAOJCAQaGXqVSKRSLUumTkws3 b0qFAwASIAzD9nA+6LuyvJyS2f95orsn9t4Q7goG4NMowMDQ03Rd0zShcPWpaOHW LblHrAEAsbMty3WcuFdxYFEU3VcFWOwK1Tn+aAhPRQbwaRRgYBTMzs3JbQFy+ptv jn/xhVA4ACBeqka2m025jZTlbG9tbbx9KxQeBMHmxoZQOIAYUYCBUVCr13O5nFB4 oVj8+fJloXAAQLw815UboxX1+NEjtXihcMdxdnd2hMIBxIgCDIyCcqVSFBsDDsNw 8c4doXAAQLyMVisIgrhXcRiiByCZptlkABgYRRRgYBRoul4qlSZlNgKJoujK9ety G00DAOKiqq8xnGOunuc9WluTu/AZhsEAMDCSKMDAiJiZmUlnMkLhx7744utvvhEK BwDExTJNuaeIRa2/ft3Y3RUK9z1va2tLKBxAvCjAwIioVqv5QkEoXFXrq9evC4UD AGIRRVFraJ/yXX3wIApDoXDbshqNhlA4gHhRgIERoZfLpVJJKDwIgpt37wqFAwBi 4TqOanpxr+KQRAeADcNoDefByAA+iwIMjAhN00qaJjcN9eMvv+i6LhEOABi8zphr qxWK3UQVZZrms6dPBQeAO0cAtyXCAcSOAgyMjvr0tNxWVdVa7fyFC0LhAIAB8z3P NIy4V3FIz589k1u867o729tC4QBiRwEGRkelWi2IjQFPTk5ev3lTKBwAMGCqQKoO HPcqDun+8rLQ7V/Fsqw9BoCB0UUBBkaHruslTRMKD4Jg8c4duQ8cAICBCcOwPbQz rlEUrSwtCQ4At9stDkACRhefZYHRoWlaoViU+0xw5uzZuWPHhMIBAANjW5brOHGv 4pB2d3berK8LhQdBYJkmA8DACKMAAyOlVq/ncjmh8GKpdPHSJaFwAMBgRFHUbjbV 17gXckhPHj1yxc4udhxHFWyhcABJQAEGRkq5UikWi0LhYRQt3r4tFA4AGAzPdS3T jHsVhyd6AJJpms2hPRsZwH5QgIGRoul6qVSSOxni6sJCJpORCAcADEa72RzS048U 3/cfrq4KHoBkGG0GgIGRRgEGRs3M7Gw6nRYKP37ixOkzZ4TCAQDSXMexLSvuVRze +vp6Q+wRZdWutzY3hcIBJAQFGBg11Votn88LhWey2Svz80LhAABprb294Z3+VdZW V8MgEAq3bbuxuysUDiAhKMDAqNHL5VKpJBSuPnYs3r0rFA4AEBX4vjHk+xsv//rr lNhTToZhtIb2dCgA+0QBBkaNpmklTZObj/rp0iVN7LRhAICcdqsld/t0ACzT/O3p U8EB4HabA5CAkUcBBkbQ9PR0JpsVCq/V6+d++EEoHAAgRFXfYd/e6cXz53J3sD3X 3d7eFgoHkBwUYGAEVarVQqEgFD6ZSl1fXBQKBwAIsQzD87y4V3Ek91dW5D65Wpa1 12iIxQNICgowMIJ0XS+JPaUcBMHinTtCT6ABACREUdQa8uNt1bewsrQkdwKw0W63 hvwOOYD94CMsMII0TSuWSqlUSij/m+++m52bEwoHAPSdY9vqR9yrOJLdnZ036+tC 4WEYmobBADAwDijAwGiq1eu5XE4ovKRpP/3yi1A4AKC/oihqN5tDffqR8uTxY9dx hMIdx9kVO14YQKJQgIHRVK5UisWiULj6FHXj9m2hcABAf3mua5lm3Ks4quWlpSmx J5tM02wO+SPiAPaJAgyMJk3X5Q4rCsNwfnExLXYSIwCgj9rNpnrfjnsVRxL4/uqD B3KjPZ3jjxgABsYDBRgYWTOzs3Id9Ysvv/zq66+FwgEA/RIEgTH81e7Nmze7YmcU +b6/tbkpFA4gaSjAwMiq1mr5fF4oPJvNXp6fFwoHAPSL2W6rghf3Ko5q7cEDuZvY tm03dneFwgEkDQUYGFnlcrlYKgmFB0Fw8+5doXAAQF+o0thuNuNeRR8s/fqr3DNN pmE0R+J3CcB+UICBkaVpWknThA7sjaKoWq9/f+GCRDgAoC9sy5LbOXlgnv/2m2EY cpezzvFHHIAEjA0KMDDKpqenM9msUHgYRYvsBQ0ASTUapx9NCO//7Lnutth0MYAE ogADo6xSrRYKBaFw9aFq4dYtoT+SBwAckes4tmXFvYqjUteaBysrctcay7L2Gg2h cAAJxCdXYJTpul4SOwxJOfPtt3PHj8vlAwAOp/Nkb6s17KcfKTvb22/fvJHLNzrn Hw39LtkA9o8CDIwyTdOKpZLcwYmZTObK9etC4QCAQ/Nc1zLNuFfRB6L7P6tk0zAY AAbGCgUYGHG1ej2XywmFsxc0ACST0Wqpt+i4V9EHy/fuTU1NCYU7jrO7syMUDiCZ KMDAiCtXKsViUSg8iqIr8/NZsYINADiEwPeNkbir6Xneo7U1uQFg0zSbe3tC4QCS iQIMjDhN1zXJMeCZublvv/tOLh8AcFCmYfieF/cq+uDVP/4hekJv5/gjBoCBMUMB Bkbf3LFjcmPAE1G0wGFIAJAYYRi2JUvjIK0sLcldv9Rv1Mbbt0LhABKLAgyMvnq9 LveUsvoAsXjnjlA4AOCgbMtyHSfuVfSHaAFWv0s7DAAD44cCDIy+crlcLJXk8s9f uFCt1eTyAQD7FEVRa1SGWlut1ssXL+TyTcMQfb4aQDJRgIGxUJ+ezmazQuF6uXzh 4kWhcADA/jm2rX7EvYr++O3JE1vse3Fdd2d7WygcQJJRgIGxUKlWC4WCVDpjwACQ AFEUtVutSOzU3AETff7Zsqy9RkMoHECSUYCBsaDreklsL+gwDK/fvCl3TiMAYD88 17VMM+5V9EcQBKv378sVYKOz/TP7PwPjiAIMjIvZuTm5jvrlqVMnv/pKKBwAsB9G q6V6Y9yr6I+Nt2+3t7aEwtXv0ubGhlA4gISjAAPjolar5fJ5ofBsNnt5fl4oHADw Wb7vm+123Kvom4erq3Jl3rHt3d1doXAACUcBBsaF6F7Q6mPKzbt3hcIBAJ9lGobv eXGvom+W7t1Liz21xP7PwDijAAPjQtO0kqZNTor8Wx9F0c+XL4setgQA+DthGLZH qNHZlvX0yRO5C5bR7pAIB5B8FGBgjEzPzGQyGaHw2vT0ue+/FwoHAHyCaoyu48S9 ir558fy5IVZQPc+Tmy4GkHwUYGCMVKvVvNhhSJOp1PXFRaFwAMDfiaKotbcX9yr6 6f7ystDt34nuHxY0OAAJGGMUYGCM6OVySXIMePHOHbmPLACAj3IUy4p7FX2j+vzK 0pLcsQWGYbRG6HFxAAfFR1VgjGiaViyV5I5VPHP27NyxY0LhAIB/pupiu9WKwjDu hfTN7s7Om/V1ofAwDE3DYAAYGGcUYGC81Or1XC4nFK7a9cVLl4TCAQD/zHNdyzTj XkU/PXn0yHVdoXDHcVTBFgoHMBQowMB4KVcqxWJRKDyMosXbt4XCAQD/zGi15M7L jcXyvXtyzz+bptkcrXlpAAdFAQbGi6brmqYJhUdRdHVhQW6jaQDAhwLfl9stORa+ 7z9cXZXbTqJz/FGrJRQOYChQgIGxMzM7m06nhcKPf/nl6a+/FgoHAHzIMgzP8+Je RT+9WV+Xe0RZteutzU2hcADDggIMjJ1qrZbP54XCM9nslfl5oXAAwHthGLZHbjfj tdXVUOyJbtu2G7u7QuEAhgUFGBg7oochqQ8ui3fvCoUDAN6zLct1nLhX0WfLv/46 JfaMEgcgAZigAANjSNO0kqYJTVhFUXTx0qWS2JgxAGCid/pRs6m+xr2QfrIs67cn T+QuT53jj0ZrZBrAIVCAgXFUn57OZrNC4bXp6XPffy8UDgBQXMexLSvuVfTZi+fP 5fb0cl13Z3tbKBzAEKEAA+OoUq0WCgWh8MlU6vriolA4AKBzM7PVCsMw7oX02f2V FbkPppZl7TUaYvEAhgYFGBhHuq7LPaUcBMFNxoABQIzveaZhxL2K/hM9AdjonH/E AUgAKMDAWNI0rVgqpVIpofxvz52bmZ0VCgeAMWe2277vx72KPmvs7q6/fi0UHoah aRgMAAOYoAADY6tWr+dyOaHwkqb99MsvQuEAMM6CIDBG8U7m08ePHbFNrVWy3PHC AIYLBRgYU+VKpVgsCoVHUXTj9m2hcAAYZ5Zpeq4b9yr6b2VpSe65JNM0m3t7QuEA hgsFGBhTmq5rYmPAYRjOLy6mxc5yBIDxFIXhSJ5kGwTB6v37cgW4c/zRKN42B3AI FGBgfM3Mzsp11BMnT546fVooHADGk2Pb6kfcq+i/t2/eyJ1R5Pv+1uamUDiAoUMB BsZXtVbL5/NC4dls9vL8vFA4AIyhKIrazab6GvdC+u/h6moQBELhtm03dneFwgEM HQowML7K5XKxVBIKD8Lw5p07QuEAMIY817VMM+5ViBA9AMk0jOYoPjcO4HAowMD4 0nS9VCpNToq8D0RR9POVK3L7bAHAuGm3WqHYbdIY2bb99PFjuYuRYRgMAAN4jwIM jLXpmZlMJiMVPjt79tw5oXAAGCu+75sjeoztyxcvWmIF1fO87a0toXAAw4gCDIy1 SrVaKBSEwqempq7duCEUDgBjxTQM3/PiXoWIBysrcuGWZe01GnL5AIYOBRgYa7qu lyQPQ1pkDBgAjky9nbZHd4pVdADY6Jx/xPPPAP5AAQbGmqZpxVJJ7ujF8xcuVGs1 oXAAGBO2ZbmOE/cqRKh2+vLFC6HwMAxNQ1Xg0Xx0HMDhUICBcVer13O5nFC4Xqlc +OknoXAAGAdRFLX29uJehZTfnj5V9V4o3HGc3Z0doXAAQ4oCDIy7cqUiulfzwq1b cuEAMPIc21Y/4l6FlJWlJbmnkEzTbI7unx0AOBwKMDDuNF3XJMeAVQGW+3ADAKMt iqJ2qxWFYdwLEaG+u/vLy3LXiHa7zQFIAP6CAgxgYmZ2Np1OC4V//c03x774Qigc AEab57qWaca9Cik729tv37wRCvd9f2tzUygcwPCiAAOYqNZq+XxeKLxYKl28dEko HABGW7vVCoMg7lVIefLokeu6QuG2bTd2d4XCAQwvCjCAiXK5rGqqUHgYRYu3bwuF A8AI833fHOkdjEUPQDINozm6Z0cBODQKMIDOYUglTZucFHlDCMNwfnFR7hFrABhV qv2qDhz3KqQEQbB6/77QAHAURZ3jj0b6jw8AHA4FGEDH7Nyc3B/Dnzh58tTp00Lh ADCSVD80RnoDp7dv3uxsbwuFq9+9zY0NoXAAQ40CDKCjWq3mCwWh8Fwud+naNaFw ABhJlml6YvOxSfBwdTUQG2+2LavRaAiFAxhqFGAAHXq5XJIbAw7DxTt3hMIBYPSo t832qM+vig4AG4bRGvXfQACHQwEG0CE6BhxF0eX5+VwuJxEOAKPHtizXceJehSDX dR8/fCh30WEAGMDfoQADeGfu2DGhzUg64cePn/n2W6FwABglqr+1m031Ne6FCHr9 6tWe2CPKYRhuvH0rFA5g2FGAAbxTqVYLYmPA6Uzm6vXrQuEAMEpcx7EtK+5VyFp9 8CAKQ6Fwy7Lk2jWAYUcBBvCOruslTRMKZwwYAPajc/u31ZIrhwkhOwDcVr+Fo7yB NoCjoAADeEfTtGKpJHck48VLl+QKNgCMBs91LdOMexWyLMv67ckTucPnTcNgABjA 36EAA/hDvV7Pim1VVZ+Z+e78eaFwABgN7VYrFDscKCH+8eJFW+wOres4Ozs7QuEA RgAFGMAfKpVKoVgUCk+lUvOLi0LhADACfM8zDSPuVYh7sLIiF26Z5t7enlw+gGFH AQbwB9kx4CBYvHtXKBwARoDRbge+H/cqxC3/+utUOi0UzgAwgE+jAAP4k9m5ObmN Sc5fuFCt1YTCAWCoqeprjMHkqmqnL1+8EAoPgmBzY0MoHMBooAAD+JNavZ4TGwMu V6s//PijUDgADDXTMHzPi3sV4p799pvcLl+O4+wyAAzgkyjAAP6kXKkUxcaAJyYn F27elAoHgKEVBIExHg/u3l9eFtr/WTFNs8kAMIBPogAD+BNN1zWxMWD1CW/xzh25 jz4AMKQs0/RcN+5ViIuiaGVpSW7Qpt1uy+0vDWA08DEUwF+JjgF/8913Kl8oHACG URiG7WYz7lUMwu7Ozpv1daFwBoAB7AcFGMBfVWu1fD4vFK5p2o+//CIUDgDDyLYs 13HiXsUgPH382BH7Tm3bbuzuCoUDGBkUYAB/VS6Xi6WSUHg0MXHj1i2hcAAYOuNz +1dZWVpKpVJC4aZhNMfmdxLAoVGAAfyVpmklTROa1FUf9RZu3ZL7AAQAw2V8bv+q 9/8HKytC7/9RFBmdCeDRP0cKwBFRgAF8hOgY8Kmvvz7x5ZdC4QAwRFRtazWb6r/i XsggbG1uys3oMgAMYJ8owAA+QnQMOF8o/HLlilA4AAwRx7bVj7hXMSCP1tZ83xcK ZwAYwD5RgAH8laZpU+l0oVCQCA/DUCVfunZNIhwAhkgURe1mMxqP27/Ko9VV1/OE HoG2LCvwfR6BBvBZFGAAH6GXyyX2wQIASa7j2JYV9yoGR3QHLMMwWuyABWAfKMAA PkLT9UKhIDQGHATB9z/+WJ+elggHgKEwbrd/m3t7z58/T4tdVizLardaEuEARgwF GMBHqAKcyWRyuZxEuPqkMjM3d+777yXCAWAojNvt3xfPn6sOLPTnqo7jeJ5HAQaw HxRgAB/RGQOemioUixLhURRlstmr169LhANA8nXO7Gm1wjCMeyGDs/rgQRgEQgfs WaYZBAEDwAD2gwIM4ONEx4DVx77FO3eEwgEg4TzXVZ0t7lUM1PK9e3Kn6zEADGD/ KMAAPk7X9UKxKLRhSRAE35w9e/zECYlwAEiyMbz9u721tf76tVABVr+Tlmm2eP4Z wP5QgAF8nKbr6XRa6DTgMAgqtdqFixclwgEgycbw9u9vT56YhpGSKcC2bfu+zwAw gH2iAAP4OE3T1IeVoswYsJJKpeYXF4XCASCZOrd/2+0wCOJeyEA9WFmRCzdNM2QA GMC+UYAB/C1d14ulktCeJWEUXb52TegOMwAkk+95pmHEvYqBcl334dralMxATRRF 6veT558B7B8FGMDf0lQBlhwD/vKrr05//bVEOAAkk+pqwZjd/n2zvr61uSk3AGya Js8/A9g/CjCAv6VpWjqTkRoDDsNiqfTLlSsS4QCQQGN4+1d59PCh6zhCf5baGQD2 PJ5/BrB/FGAAn1Iul4tihyFNRNHC7dtS4QCQMEa7Hfh+3KsYtJWlJaH2q5iG0eQA JAAHQQEG8CnShyF9/+OP9elpiXAASBTf983xu1HZ3Nt7/vx5mgOQACQGBRjAp2i6 nu2SCFcFeGZ29twPP0iEA0CiqPbrj9/t3xfPn6sOLDQA7HYxAAzgQCjAAD5FFWD1 waVQKEiER1GUzmSuLSxIhANAcgS+b4zf7V9l9f79MAyFThOwLCsIAgowgAOhAAP4 DL1cLomNAasPRtdv3hS6OQAACWEahu95ca9i0FQ7fbCyIvcObxhGiwFgAAdEAQbw Gbqu5wsFoU8w6uPR6TNnvjx1SiIcAJJAvdEZY3mXcuPtW/VD7vJhWxYDwAAOigIM 4DM0Xc9kMrlcTiI8DEOtXL74yy8S4QCQBON5+1d58vix6qhC2yg6juN5Hs8/Azgo CjCAz9A0LTU1VSwWpV5gcnLh5k2pcACI1dje/lVWlpdTMtO/immaYRBwAjCAg6IA A/g8vVxWBVhoF5MwDC9cvFipViXCASBelmF4Y3n7V1XTZ0+fCj3/HEWRKsAMAAM4 BAowgM8T3QcrCIK548fPnjsnlA8AcQnHeI/ily9eNBoNdsACkDQUYACfJ1qAoyjK ZLNXr19XTfj9qJjQ3WYAGCTLND3XjXsVA6LezN//RL2Zrz54oPq/3Js5BRjA4fAR E8DniRbgie5N4Gq1ms3lMrlcPqf+k09nMul0empqSn2KmuyaoBUDGCojfPv3w64b dgW+7weBavuK73Wogip6xB0FGMDh8GkSGE2apnVaY+qdqa64F/W3oq7eTya7d4HV ilUBzmSzqhUXCoW8+pHPq/+zV4l7/1/qI5f6FtX/LNa1A8DHjcbtX9Vs1btz7423 916t3ntVv3UdR3Xd3lbMqvGqth/+/j4+0f3zyvd/dplMQffutPoW1LejviW1dvbT AsZEct+YAByIarzqE0dK/eh2XVULk/zJ4++8v6vw/uedStz9RjrfVCaT7Z7IlEmn 1a+rX9F0XfXjbNcwfr8ARpWqVe1hvj+p3mN93+8VXdXk1bejLjFB91d81R19v/Mr Xf/8hM4wvht3in0UeaoPd5v8BH0YGF3D9w4F4EO9M4p6jTfJ93iP4sNn7f5Ukbt6 Nxl69yUmu/1f1ePOo9T5fKFQKJZKJU0TOsQYAP7OUNz+VW1WrdO2bad7O9fv1lrV AHtvp+/fWj/8f3lXdn+vuMPYdfej2/E7TZ+TloDRM5pvW8Bo6z3erJqe6nUJf8ZM yF8/kH3ydyD6XWeYuPsnBdnfn6zu1ONSSXXl949VA8DRJeT2r3rf69y/tSxVcTtP LHtep+KqfhuG0f6eUj7Qm+1I6l0+HMfp/bkAZRgYAWP3RgYMNU3Xp1TvzWZTI3qz Nxa9kbaJ7pDbuwetOwU5172DXOw15DH82Afg0GzTdOVv/3b6revaltW5f/v7LdzO w8ndp3knu+9pvHf1kerA6nc5GN29zYAxwdsiMAQ6zzmnUqqYKXyaGbwPG/K73blU Sc7lVE/ulOROTS5mecoaQFe/bv96nte5c2vbqnT1NprqPJIbBL1Nm3q7HHJFGDx1 RXi375f6G80NYWAI8b4JJFrvlm+2u/tx3GvBp7wvyeoz6VRv2+10urdlV+d+cr5D FWU26wJGnm1ZruP83V/tbS71xzPJvR+9cdOud9sZUG4TT/0tc7khDAwh3luBhFLV N62qby7HeOoo+aMn/35IVe+EKtWUe3tcd5+9zvcKs/rFuNcLYF96d2sd9R/Lajeb XvdRZP99pw3D98O0NNsRo/7+uo7jU4OB4cFbMJA4mqZNpdM5qu/Ye7f/aveDc6q3 WU33GOR09/byVPdJ7Ez3gexsNpvpzi2r/3AwMnAUqrd2Drd1HM/t6B770/kSfNBp o+5+SL0524l9bCWFkaf+qVD/zKh/QngoGkg+3q+BBOls75xK5fN5HnjGob3f9Xri /fmc3VtOnS/dx7Pf3XTutuhMt0j3tv5K93RLtfpF/vwFw6VzfI9qqt2za/0e1Vq7 p9n07scGvQHa7qPG0funjbtPZLz/94Uqi6NQ/3DZth0xGwwkG+/yQFJout6dGGUv JcSv1wfena6sftL9xXfNoPe1+xin+s/E78OK76cWU93/6u4Y1vvp5FT3xvW7n0xN /f70d+r9T97/1d5XlamaOD1kuPRGW9V/Bd27o72v4e/e/7zzk24R7f3Kh/+zie5f fv8/7v3j1/n17r3Wzj+T3cN7ev90vqus3X8437dW/plBEnQeH/A8nogGEotLBRA/ bvwCH/V+bPJPh5H++WRS1Xn+clTp+1/v1yImknpXsPeE/ESf1vZ3v40f/nqvZX74 V//yEwAT3AoGko0rFhCz3sRvoVCIeyEAAKBvLMtiKhhIIAowECfVfnt7F8W9EAAA 0Ge93dTowECiUICB2Gi6XiwUUjz2DADAiAqDwLQsRoKB5KAAAzHoDf0WVPtlo10A AEZaGIaWZTESDCQEBRgYNNovAABjhQ4MJAcFGBgo2i8AAGOIDgwkBAUYGBzaLwAA Y4sODCQBBRgYHF3XC8Ui7RcAgPHU6cCm2WJPLCA+FGBgEHr3fvP5/BR7PgMAMMaC ILBtm/vAQFwowMAgaLpeKpUmJ/k3DgCAcRdFkWEYnI0ExIKP44A4TdP0clld7eJe CAAASIQwisx2m5vAwOBRgAFZqv2mpqaKxWLcCwEAAAlimmYYBHRgYMAowIAsXddL mhb3KgAAQOIY7TYbYgEDRgEGBGmaptovo78AAOCfhWFoGgY3gYFB4nM5IEW136mp qcIIPfwc/U79fPJ3cS8KADDi3l961NfRu/pYphnwIDQwQKPz9gEkja7rxaHd+bn3 aSOVSmWzWdXhK9XqjDI7m8vn1XU6DEP11fO8RqOxt7vbajZN03QcR/2S+mvqG55M pYb0GwcAxKJz1VFXkFQqnU7ncjl1AVWX0Wq9ri4+1Vrtw0MEjXb7zfr6xsbGXqNh GobruuqqNLytWH3f6rvgQWhgYIbynQJIvs7Oz7o+FPs+97rulOq6uVxJ09TnjFnl 2DHtgKPLvVbc+2pZ1vbWVmN3t6m6sWE4tu37fu8DiirVQt8IACD51LVAfVWFNpvN 5gsFvVyuVCr16enpmZl8Pn/o2Ha7vfn27ebmprr0qIbsOk4wPK1YNX+DB6GBQRmC NwVg6HR2fk6liqVS3Av5iF7dVR87VNet1etzc3PHT5wY2CbV6qXVBX7j7dvd7e1e N7ZVN+7dN6YbA8CoeNdyU6lMt+WqK065XK7X6zOzs4N8Nso0zTevX29sbOzu7HRa sesmthKrC6L6TaMDAwOQxLcAYNipAlwoFj98XitGvcarPn9MT09/ceLEya++SuaZ TL1uvL25udu9b6w+qdiW1XuwTf1VujEAJM37e7mq5Rby+WK35dZqtenZWS2pG0Cq SvzyxYv116+3t7fVVSY5fbjz8JRpUoCBAUjEv/PAKOnsfZVOFwqFGNfQK72arp88 derbs2cr1WqMi+kL9bFAfVhp7O7u7e2pbmypbuw4vu+/3xAl7gUCwAjqXU3Ue2w6 nc7mcoXuvdxKpVJVLXd6egR2edxrNJ48fvzyH/9ot1qxX03UpS3wfTowII1PjUCf qdp50OnZfultkjl37NgPP/544ssvY1nD4KkarFrx7va2+trqjRw7Tu/WMfUYAD7t fcXt7Xr4bvep7lyu6rjqq6q+ca9xQF6/evVgZWXj7duJ7kkHsaxBtd82u2EBwvhc CPSTar+ZTEZ9gBjw66qyp1764s8/n/n22wG/dMJ1tqre3e1sx7W3pz5XvKvHnhdw 9xjAeHhfcafS6Wz3CqUqrqZp5e6NXPVDXbbiXmOy/PbkydK9e6qIDn76Rl2h1GWL DgyI4pMf0E+6rpcGe/tXVd9arXbr7l31UWaQrzsawu7Gm7s7O6oet1qtzqZcltX5 /OH7YRDQkAEk3x+3cKemMt0DhPKFQu8MIXVdqNXrpVKJbRQOQV0X/u//8T92d3cH /LtndO4BU4ABQXywA/pG07TSALf96JzTOzX1v/yLf3H8iy8G84pjqHc8Y6PRaDWb 6iOJastWryF37yF3SnL3STlKMgAJ78rtxIR6t59Kp3tPGHUGcUulzlF75XK1Wh3e A+eHwpv19f/rv/939W4/sN/kIAwtjkQCJPGOCfRHZ8fLVKo0qKOPOjd+6/V/9a// 9WBeDp+gPp6qVrzXaHT+0L7VskzTtm3Htl3X9X0/6B6A3DsRmqoMYOL3WjvR/RCW SqVUs+1sMZXN5vIdhWJRdVvVbyvVquq6vGkkwX/9L/9ld2dnYLeCDcOIOBIJEMO7 KtAfqgAXB/WYmSpU586fv7awMIDXQh85jqMacrv7rLXqyVavJ3dnkt9X5d6xIhO0 ZWCovO+0E91O+0etzWQ6+0qpWttttsXenVtdH/xWETii/+//+X8erq0N5irPkUiA KD5dAX2g2m9qamow5+uqgnT23LnrN24M4LUQI9/zDMMwle5z173h5N4G170HsP0g CNWPMIy6+11Hv5+WTG0GjqLXY9W/WZO9P4d6V2en0r8/hNzbKrk3alvoTtt2i20p zVZSo+7//Z//8/HDh4PpwOq9X73D04EBCXxOAvpgYLd/1WeySqXyv/3bfyv9QhhS qhfbtt3bzavzJLYqzN07zL1jkz9szkH3bvO78vz7Q9o93HzGkPrwNuxE9yOOqq/v S+zUn3ts72Dbd3doc92nj7ttVv33+Bz8g4P6P/7Tf9rb2xvM5d5kEhiQwUcc4KhU +1UfqAoDuf2rPtv9u3//7wfwQhhzqivb3bvNbverqs2d57S7j2r73Sb9rkV3qQ9q 6td6XfqPXt39ANf9T/eWWvdXOj9RPyYnP2wpE91ff1+5//knGArv/55++JO//E3s /J/dfwDe/RFLt52mJt49NNzrq72m2mutqoh2S2tHr7umu8W1QxXXTGaqOzrb6bHZ bD6X4x4sBuB//4//cTDvTpZpBtwEBgTw8QI4qkHe/v1f/+W/ZM9njA/P8zpPok5O qsoddKej1U/Cbr/qjUxPdIflok7n/lOj7rTwIOjLGtSrb25s/CU/IVRNnJ2bi/q0 NtUw//I+1q2nnf458fteTb1f7PVM9b9WP+lsR59KcZAsxseb9fX/87/9twFc9JkE BoRQgIEj6Uz/plJF+c2fe+f9/qt/82+kXwgAAHzCf/3P/3kw5wObhhGyHTTQbxRg 4Eg0XS8N5AzGKAz/3X/4D9KvAuD/b+/en9u6CgSOS7Ysv5M+aRpooU07LCzQsn2n KcO/sDsDs8Pwz/ELP5QZ9l9gmjTpcyksS7fTpoW2pClNH3Hit+/VHunasiLLtiTr WJLP5zPBXDvulTyTSPebc+45AIf67W9+M9GYHBFV3tiL/vatW7EfCJIigOFIFkMA LyzEfpQ8y5586qkf/uhHsR8IADjUX//yl3fefvsYGnj5dn2P+diPAkkRwNC/+vJX lcrs7GzUR6nVatPT0//xy19GfRQAoHu/f/nl9fX12FPAVldXs60ts6BhgAQw9C8E 8MLiYuxHybPs33/xi+NZZRoA6Mbqysp//e53xzAIfPvWLQEMAySAoU8hfitTUzMz M1EfJc/zhx5++KWf/zzqowAAvbr4hz988vHHsVfDWltb29rc1MAwKAIY+nQ8ux/Z +BcARtYxbAuc53l9KSwBDAMigKFPxzD/Ocuy8xcuPHLuXNRHAQD689HVq5cvXZqM PBHaLGgYIAEMfQr1uxBz/edarRbeUH/5q1/FewgA4Ihe/u1vsyyLOg4c6tdmSDAo Ahj6EdJ3qlqdnp6O9xB5lj13/vy5xx+P9xAAwBFdff/91y9fjroa1vr6+ubGhkFg GAgBDP0IATw7NxdvylOtViuXy//5619HOj8AcET5jt+//HLxxh3pgbIsW11ZEcAw EAIY+hH7BuDwbnrft7714yeemGyYmJiYvFPsxbcAICm1hvwwoUWLg+L7i//2vXff /erGjahvzW4DhkERwNCP2DcAh/fXZ55/fqpa3e8byuVyxzBuDebY61ICwMjqpmbb 9P1Ymxsbb772WtSlsNwGDIPi+hh6FnsH4PCeHfr12RdeOOJ52vK49dPiOHwUyQCM hV5rtjk8ezzeuHIlj7kUlt2AYVBc+0LPFhYXZ2dn4/1Db3jbfuDBBx997LFI52/V GsZ7C1kkAzBwzbHZgwdp23532M/6EB9+8MHnn30WbxZ0/Tbg1VWDwHB0rmuhZwsL C/MLC/GyMLzNP3/hwuhkZ8cwbh1GNt0aIFkdI/bQsh32sx688EO9dulSvAAO51+u T4M2AgxH5ZoVehZ1BaxBzX8+ZsU9yW1V3PrRYDLA6Du0Xfcm7oms2f7EngVtHSwY CBej0LOoK2DljfWfH//+9yOdf7gmGnQyQFRtCxq3Ne0Bnw77iY+3999778Y//xlv ENg6WDAQrjKhNyF9p6ampqOtgJVl2b89+2y8FbbGQnON62Ybtx6Yeg0korVji4Mu s9ao7FCsra399xtvxFsiZH1tbdM6WHBkrh2hNwuLi3OzsxNx3t6Ka50XXnopxslP pBDAHSO5YzYP+8kCiWqbMLzfwd4v6tixc+XixXJDjJPnWbZiHSw4MgEMvYm6Ala4 3AmB/eMnn4xxcia6VowtG14GSi3DsPt9PPhTEZuU/3nnnRCokf7J1TpYMBAu76A3 UVfACpdKj5w7d+bs2UjnpyeHdnIx/tx6rJlhpLS2a1uUdvNp83jYPwdj4/q1ax9d vRrxNmDrYMGRuVaD3kRdASvLsvM/+1mkk3MMinHjAwq57bj1YNjPHUZCrUWzP/d+ 2vF4b8EO+6chRZdfeSXebcDWwYKjc8kFPQjpW5mairRCVTHK8MKFCzFOzogr7yhi uNeDtuNh/zSccLU9SjubwXb83S6bVrJyMly5dKnceFWPcfK1tbUt62DB0bhOgh4s LC7Ozs5G+pfdcOU3v7Dwk5/+NMbJSUfHJG5t471f7O93h/xzJq+1PEst2dnNceun +339AMP7oWEM/PmPf1y+fTvSLOgsy1atgwVH4woGehB7Baxzjz/+rTNnYpwcYmhW 8UA+tp2242P198W2ZtubcAd/Q8dPD/54FM0zxHsIIJ5/Xr9+9f33rYMFI0sAQw+i roDlBmAAOAHi3gZsHSw4GgEMPRDAAMDBBDCMMgEM3QrxO1mpzM7Oxjh5rVabnJh4 5vz5GCcHAI7Nm5cvZ3ke6Yap1dXVbGtLA0PfBDB0KwRwdXq6Wq3GOHme53ffe++/ /PCHMU4OAByb//vrX7/+8stItwFvBOvrAhj6JoChW1GXgM6y7Mmnn56bm4txcgDg 2KysrLzz1lvxLhgsBA1HIYChW1GXgHYDMACcGPFuA7YQNByRAIZuWQELAOiGdbBg ZAlg6MpCY+x3fmEhxslrtVplaurp556LcXIA4Ji99frrW5ubkWaNLd++Ha4cNDD0 RwBDV0IAT01NTc/MxDh5nuePPvbYAw8+GOPkAMAx+/yzzz784INI62Ctr61tbm4K YOiPAIauhACenZuLt6CF+c8AcJLEmwVdXwdrZUUAQ38EMHRlYXFxbm4u0j/lCmAA OGHiBXCe5yshgC0EDX0RwNCVeCtg1RpeeOmlGCcHAIbiysWL5YYYJ7cOFvRNAENX Qv0uRFsBa7JSeeb552OcHAAYijdfey3b2ooVwIERYOiLAIbDhfSdmJiYm5+PcfI8 zx85d+7M2bMxTg4ADMX1a9c+uno10s1TK8vL4frBIDD0QQDD4UIAV4Pp6Rgnz7Ls uRdfjLdbIABw/ML7++uvvhrp/X1jfX1jY0MAQx8EMBzOEtAAQK8sBA0jSADD4RYW F+fn5yPdxpPnuRWwAODkuXLxYqQp0LVabXl52W3A0AcBDIeLNwIc3sBK5fLzL744 8DMDAMP12quvhnf6GP+AbgQY+iaA4XDxRoBDAM/MzDz59NMDPzMAMFzvvPXW2tpa pOsHI8DQHwEMh4u3CXCWZU8+9VSk9aUBgCFaWV5+5+23I90GbCtg6I8AhsNFDWAr YAHASRVvHSwBDP0RwHCIEL/hrWt2bi7GyQUwAJxg8QJ4dWUlXEVoYOiVAIZDhACu TE3NzMwM/My1BktAA8BJdeXixXLDwM+8tra2tbkpgKFXAhgOEQK4Oj1drVYHfuZQ vyGtn37uuYGfGQAYBW+9/nrI1BgBvBGsrwtg6JUAhkPE2wMpz/PFU6d+9MQTAz8z ADAK/vKnP91aWoqxG7CdkKA/AhgOEW8PpBDAZ86efeTcuYGfGQAYBR9dvXr92rUY AWwnJOiPAIZDWAIaAOibhaBhpAhgOIQABgD6JoBhpAhgOEjUPZDyPLcENACcbFcu XowxBbpkJyToiwCGg0TdAyn89XvuwoWBnxkAGB2vX7pUC9fcdkKC0SCA4SAhgKeq 1enp6YGfOQRwOPNTzz478DMDAKPj7Tfe2NzYiBHA6+vr4cwCGHoigOEgUfdAOnX6 9L/+5CcDPzMAMDr+989/Xrp5005IMCIEMBxkYXFxbm4uxptWfQ+kBx985LHHBn5m AGB0fPTBB9c/+yzStcRKCGA7IUEvBDAcJATwwsJCjDNbAhoAEhFxIehAAEMvBDAc RAADAEckgGF0CGDYV0jfiYmJufn5GCfPs+wFAQwACbjyyisTcQJ4ZXk5z3O3AUP3 BDDsq74JcKUyOzs78DPXarXwv+dtAgwACXjt4sX6PkgRFoJeXV3NtrYEMHRPAMO+ om4CPDkx8cz58wM/MwAwat68fDnLc1sBwygQwLCvEMDV6elqtTrwM4cAnpmdffKp pwZ+ZgBg1Lzz9ttrq6sxAngjWF8XwNA9AQz7iroJ8D333ff9H/xg4GcGAEbNe+++ +9WNG7YChlEggGFfUTcBfui73/3Oww8P/MwAwKj59OOPP/n7320FDKNAAMO+7IEE AAyEnZBgRAhg2JcABgAGQgDDiBDA0FnUTYAFMAAkJV4A2woYeiKAobOomwAHL9gE GACSceXixbKtgGEECGDoLN4mwE1FCYeDycnJarU6Mzd36tSps9/5TrxHBACiuvbp p0tLS2srKxsbG1mWha9E6t4mWwFDTwQwdBYCeG5+PsaCjYcKVZzneXjoUODTMzOL i4vfe/TR438aAMAB/vbhh7du3Vpv9Gfxxh01dPdTXwh6eVkAQ5cEMHQ2xADuqLZj cnJyqlqdnp5ePHXq4e99b9jPCwBOuI//9rdbS0vr6+ubjUHd8o5hP69tAhh6Mip/ dWHULCwuzs/Pj87b2352w3hiohLCuFpdPH36u488MuznBQBj5u8ffXTr5s31jY2t ELp5Pmqhu59wDbAcAthC0NCdUf8rDcMSbw+k49EM43II42LQeGbm1KlT337ooWE/ NQAYmn988snS0tL62tpmCN0sq41P6B7ATkjQvTH+qw5RjXsAH6C5+FZ4s68EjTuN tTEAJ0azcrc2N7e2tprvemNduQcQwNC9k/kqAEd3ggP4YMUSXOESYWJyMtRx/W7j 6emQx2fOnh32UwOAbdevXVtq3Je7sb4eEjfPsvD+NaxlqIZOAEP3UnyNgEPVNwGe nJydmxv2ExktrdOqJxqjx1PVavh1+vRpuzcBMFjXPv305s2bmxsb9bnKIXEb/0B7 AqYrx7C6spJlmXWwoBtePqCDY9gE+ESqNa5Oao1pZsUA8lTDqdOnza8GoFV9lnLo 24bmEG64MC2nOop7FLYChu55fYEOQgDXl4AemT2QTpJiinU4mAgm60Ihh1A+fddd 3zaMDHAi/OPTT29+881WI26zLAtx23zlF7cxhHfWZTshQXe8BkEHo7YJcGp251rX h5LrKpVKsQFytZHK9z/wwLCfI0Byvvj885C1GyFqG9vh1odt87w+8ad4uTYzeXhs BQzd8zoFHQjgcdEcTy6mzNUHlcOvSrG49VT4eNfdd997//3DfpoAI+rLL7745uuv Q8oW85BD1NbHahtNWzNmOz4EMHTPKxp0kOwS0Cdbc2C5VGyG0ajlYhp2I5kr4f/u vuee+wQzMLZufPHF1199VR+cbSimH2c747Slna2ANO3JYyFo6JKXP+hAAFNoa+bi yjFkc7kI52JmduPDPffeG34N+/kCJ8RXX34ZfmXFPOPGx/AhRGxWdGzrv+WpWRoE MHTJKyZ0IIA5ouLatD6BsFwu7o4rNeZpTzTmabcOPtcLemoqfHbvffedvuuuYT9x YABufvPNlzdu5Hm+1VgCqnUYdnt6cWN28faLQ2NvuVLxr2zQLwEMXfJSCx0IYEbB 9uBzEdMNxSj0xM49z9tFXWR0UdSVSvjK/Q88cOr06WE+dRhDSzdvfvH556FOs8aW PKFXt5cvLjZ4ay45sDP6WiquoozBMhoEMHTJ6zW0C+kbQmJubm7YTwQGrDmdu9hs s7iE3x6dLtK6uJBvrLy98/8TEztTvovEDl9/4MyZufn5of4opGhlefnz69fDn95G nObFlOCmok+LUs1bJglvTxVu/IFv/mnXq5w8Kysr4W+FdbDgUN4AoF0I4MlKZXZ2 dthPBMZPa3I0M7u8Mw+8iI+iQrYjpNwcyd49aA3vYtJ4+O/OPvTQzMzMcH86mtbW 1q598kmpsfbsdnq2hWit1jy442b6nUkNxR+J1j8kpTs/Aj1ZXV3NtrYEMBzKewy0 CwE8Va1OT08P+4kAPWst8NbZ46Uiq3ZvyG69ObvxobnO2c4NmaWdb1xfX+/2zfKO BzyC7gowPFh4pWr+sKXGbee14sds/uyNg+KHbR4Xt6bvPlpp94ct6U8YT+GVanNj QwDDobzJQTubAAMA48VWwNAlAQztBDAAMF4EMHRJAEM7S0ADAGPHQtDQDQEM7QQw ADB2BDB0QwDDHeyBBACMIzshQTcEMNwhBHClUpmxBxIAMFbWVle37IQEhxHA0K6+ D/DkZLEVaTgoNiYd9pMCALhDrVbLsmx7C+48zwz/Qhdc1sPhQhKXiw5WxQDAsWtr 3Tx8nudyF/rgCh761FbFlcagsSoGAI6i3rY7sat1YeBcrMMgGSsGALpkXBeOn+ty OA679xWXy5WpqfCVcDjsJwUAHJOicvOQu43Kdb8uDIsAhqEptlwqRounpqbCG6Lh YgAYa4283VXMZ9a6MDpcasNoqVdxI4O3h4srlVLjcNjPCwC4w/aI7s7U5SJ9tS6M OAEM42E7jHfuL57cGToe9vMCgBOubUS3GOEVujCmBDCMt9YR43Jxg7Gp1ADQo9ap yzUjunByuUSGE6t5j3ExVlyfTW3xLQDS1j6c6x5dSIwAhhS1tfHk5GSp0cbGjQEY d82x3OJA5QKtXOwCd9idU73Tx/IYgJHSmri1ncQ1YxnohstZoAdFHpd2+7hcbOBk RS4ABmjvEG5QkrjAkQlgYJD2K+SSMWQAGppZ2xq3+hY4Hi5GgeO2sLgYUrg1koPJ SqV4PSo+HfJTBKB3rVORa3eqx22tdvvWrWE/RyB1rjKBEVXv5Ma06t1KLpUq1Wq4 sCoZTwY4Rnc0bThoad1SY7qysgXGhctHYOztDimXWnO5XKlUiouzloIGoFTbX6l4 3TRgC5xQLgeB5LSOLZeaeVwqtc3K1szAWNgvYpsjtMZpAZpc2wF0ZTebS9upXGq5 Y1k5A0fUoWPbIrY4krIAR+ASDSC6tknapZbB5+Jja0OXzNmGcdMhWXfGYEt3fjTB GGC4XF0BjI3FxcVyI6RLOwPRzYNOVd1hjHpoTx1GyUHjqx2a9c6DWu2WcAUYWy6G AJK2HdWlUltXtx6X95R2ad/o9rbCUbXdudpx+LRWKrV/sVS643jnG8UqAK1cqQBw HHZLu9QS26UOvV3aM77d+aD5zXtSnKM4aAS044ho28Ge4/qHluOSLgVgeFwoAJCi xVOndt8CW7K5/Yu12sTkZHnPtw3ZTlXmWdZ8ntu/s+fbii/eWlo61mcIACNpZN7L AQAAICYBDAAAQBIEMAAAAEkQwAAAACRBAAMAAJAEAQwAAEASBDAAAABJEMAAAAAk QQADAACQBAEMAABAEgQwAAAASRDAAAAAJEEAAwAAkAQBDAAAQBIEMAAAAEkQwAAA ACRBAAMAAJAEAQwAAEASBDAAAABJEMAAAAAkQQADAACQBAEMAABAEgQwAAAASRDA AAAAJEEAAwAAkAQBDAAAQBIEMAAAAEkQwAAAACRBAAMAAJAEAQwAAEASBDAAAABJ EMAAAAAkQQADAACQBAEMAABAEgQwAAAASRDAAAAAJEEAAwAAkAQBDAAAQBIEMAAA AEkQwAAAACRBAAMAAJAEAQwAAEASBDAAAABJEMAAAAAkQQADAACQBAEMAABAEgQw AAAASRDAAAAAJEEAAwAAkAQBDAAAQBIEMAAAAEkQwAAAACRBAAMAAJAEAQwAAEAS BDAAAABJEMAAAAAkQQADAACQBAEMAABAEgQwAAAASRDAAAAAJEEAAwAAkAQBDAAA QBIEMAAAAEkQwAAAACRBAAMAAJAEAQwAAEASBDAAAABJEMAAAAAkQQADAACQBAEM AABAEgQwAAAASRDAAAAAJEEAAwAAkAQBDAAAQBIEMAAAAEkQwAAAACRBAAMAAJAE AQwAAEASBDAAAABJEMAAAAAkQQADAACQBAEMAABAEgQwAAAASRDAAAAAJEEAAwAA kAQBDAAAQBIEMAAAAEkQwAAAACRBAAMAAJAEAQwAAEASBDAAAABJEMAAAAAkQQAD AACQBAEMAABAEgQwAAAASRDAAAAAJEEAAwAAkAQBDAAAQBIEMAAAAEkQwAAAACRB AAMAAJAEAQwAAEASBDAAAABJEMAAAAAkQQADAACQBAEMAABAEgQwAAAASRDAAAAA JEEAAwAAkAQBDAAAQBIEMAAAAEkQwAAAACRBAAMAAJAEAQwAAEASBDAAAABJEMAA AAAkQQADAACQBAEMAABAEgQwAAAASRDAAAAAJEEAAwAAkAQBDAAAQBIEMAAAAEkQ wAAAACTh/wHKaXFT997P+gAAAABJRU5ErkJggg=="/></symbol><use xlink:href="#c" width="1280" height="1280"/></g></g></svg>')} diff --git a/public/piece-css/monarchy.external.css b/public/piece-css/monarchy.external.css new file mode 100644 index 0000000000000..4f8779b0e84fe --- /dev/null +++ b/public/piece-css/monarchy.external.css @@ -0,0 +1,12 @@ +.is2d .pawn.white {background-image:url('/assets/piece/monarchy/wP.svg')} +.is2d .knight.white {background-image:url('/assets/piece/monarchy/wN.svg')} +.is2d .bishop.white {background-image:url('/assets/piece/monarchy/wB.svg')} +.is2d .rook.white {background-image:url('/assets/piece/monarchy/wR.svg')} +.is2d .queen.white {background-image:url('/assets/piece/monarchy/wQ.svg')} +.is2d .king.white {background-image:url('/assets/piece/monarchy/wK.svg')} +.is2d .pawn.black {background-image:url('/assets/piece/monarchy/bP.svg')} +.is2d .knight.black {background-image:url('/assets/piece/monarchy/bN.svg')} +.is2d .bishop.black {background-image:url('/assets/piece/monarchy/bB.svg')} +.is2d .rook.black {background-image:url('/assets/piece/monarchy/bR.svg')} +.is2d .queen.black {background-image:url('/assets/piece/monarchy/bQ.svg')} +.is2d .king.black {background-image:url('/assets/piece/monarchy/bK.svg')} From 0b44d019240e08fd56b4773828cfc781207bbdc8 Mon Sep 17 00:00:00 2001 From: Thibault Duplessis Date: Sun, 16 Jun 2024 00:48:51 +0200 Subject: [PATCH 064/168] broadcast card css tweaks --- ui/bits/css/relay/_card.scss | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/ui/bits/css/relay/_card.scss b/ui/bits/css/relay/_card.scss index a461e6cdcce13..ad1b0d43eca4b 100644 --- a/ui/bits/css/relay/_card.scss +++ b/ui/bits/css/relay/_card.scss @@ -57,7 +57,7 @@ &__body { @extend %flex-column; - padding: 0.3em 0.5em 1em 1em; + padding: 0.6em 0.5em 0.6em 1em; } &__info { @@ -78,10 +78,10 @@ .relay-cards--tier-best & { font-size: 1.4em; } + padding: 0.2em 0 0.3em 0; } &__desc { @extend %roboto; color: $c-font-dim; - font-size: 0.9em; } } From ed021f2194783741bf49f287b5e3a06fdaf0029f Mon Sep 17 00:00:00 2001 From: Thibault Duplessis Date: Sun, 16 Jun 2024 01:10:56 +0200 Subject: [PATCH 065/168] remove confusing abstraction in relay model --- modules/relay/src/main/RelayTour.scala | 3 +-- modules/relay/src/main/ui/RelayTourUi.scala | 2 +- 2 files changed, 2 insertions(+), 3 deletions(-) diff --git a/modules/relay/src/main/RelayTour.scala b/modules/relay/src/main/RelayTour.scala index 1f3b1ccd1cc25..21e72c6fba25f 100644 --- a/modules/relay/src/main/RelayTour.scala +++ b/modules/relay/src/main/RelayTour.scala @@ -84,8 +84,7 @@ object RelayTour: display: RelayRound, // which round to show on the tour link link: RelayRound, // which round to actually link to group: Option[RelayGroup.Name] - ) extends RelayRound.AndTourAndGroup: - export display.{ hasStarted as ongoing } + ) extends RelayRound.AndTourAndGroup case class WithLastRound(tour: RelayTour, round: RelayRound, group: Option[RelayGroup.Name]) extends RelayRound.AndTourAndGroup: diff --git a/modules/relay/src/main/ui/RelayTourUi.scala b/modules/relay/src/main/ui/RelayTourUi.scala index 78df22aa49466..ecde8f219cc3e 100644 --- a/modules/relay/src/main/ui/RelayTourUi.scala +++ b/modules/relay/src/main/ui/RelayTourUi.scala @@ -22,7 +22,7 @@ final class RelayTourUi(helpers: Helpers, ui: RelayUi): val selected = active.filter(_.tour.tierIs(selector)) selected.nonEmpty.option(st.section(cls := s"relay-cards relay-cards--tier-$tier"): selected.map: - card.render(_, ongoing = _.ongoing) + card.render(_, ongoing = _.display.hasStarted) ) Page(trc.liveBroadcasts.txt()) .css("bits.relay.index") From c07aa1e39644ff1652ef7c974a7ebd8594608740 Mon Sep 17 00:00:00 2001 From: Aaron Leslie Date: Sat, 15 Jun 2024 21:49:23 +0000 Subject: [PATCH 066/168] Allow voice and keyboard input of 'next' to start new puzzle streak game --- ui/puzzle/src/ctrl.ts | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) mode change 100644 => 100755 ui/puzzle/src/ctrl.ts diff --git a/ui/puzzle/src/ctrl.ts b/ui/puzzle/src/ctrl.ts old mode 100644 new mode 100755 index 8e97d8d1ac15c..f80f878802edc --- a/ui/puzzle/src/ctrl.ts +++ b/ui/puzzle/src/ctrl.ts @@ -428,7 +428,10 @@ export default class PuzzleCtrl implements ParentCtrl { private isPuzzleData = (d: PuzzleData | ReplayEnd): d is PuzzleData => 'puzzle' in d; nextPuzzle = (): void => { - if (this.streak && this.lastFeedback != 'win') return; + if (this.streak && this.lastFeedback != 'win') { + if (this.lastFeedback == 'fail') window.location.replace('/streak'); + return; + } if (this.mode !== 'view') return; this.ceval.stop(); From f442db7347f25e4cfecb95b8783cef6bd75cb820 Mon Sep 17 00:00:00 2001 From: Thibault Duplessis Date: Sun, 16 Jun 2024 09:33:06 +0200 Subject: [PATCH 067/168] show ongoing broadcasts in /broadcast WIP --- modules/relay/src/main/RelayApi.scala | 11 ++++++---- modules/relay/src/main/RelayListing.scala | 25 ++++++++++++++++------ modules/relay/src/main/RelayRound.scala | 2 ++ modules/relay/src/main/RelayTour.scala | 1 + modules/relay/src/main/RelayTourForm.scala | 1 + modules/relay/src/main/RelayTourRepo.scala | 4 ++-- 6 files changed, 31 insertions(+), 13 deletions(-) diff --git a/modules/relay/src/main/RelayApi.scala b/modules/relay/src/main/RelayApi.scala index f115665a50419..d95cdc03c88de 100644 --- a/modules/relay/src/main/RelayApi.scala +++ b/modules/relay/src/main/RelayApi.scala @@ -76,9 +76,12 @@ final class RelayApi( def withRounds(tour: RelayTour) = roundRepo.byTourOrdered(tour).dmap(tour.withRounds) def denormalizeTourActive(tourId: RelayTourId): Funit = - roundRepo.coll.exists(RelayRoundRepo.selectors.tour(tourId) ++ $doc("finished" -> false)).flatMap { - tourRepo.setActive(tourId, _) - } + val unfinished = RelayRoundRepo.selectors.tour(tourId) ++ $doc("finished" -> false) + for + active <- roundRepo.coll.exists(unfinished) + ongoing <- active.so(roundRepo.coll.exists(unfinished ++ $doc("startedAt".$exists(true)))) + _ <- tourRepo.setActive(tourId, active, ongoing) + yield () object countOwnedByUser: private val cache = cacheApi[UserId, Int](16_384, "relay.nb.owned"): @@ -251,7 +254,7 @@ final class RelayApi( _ <- roundRepo.coll.update.one($id(round.id), round).void _ <- (round.sync.playing != from.sync.playing) .so(sendToContributors(round.id, "relaySync", jsonView.sync(round))) - _ <- (round.finished != from.finished).so(denormalizeTourActive(round.tourId)) + _ <- (round.stateHash != from.stateHash).so(denormalizeTourActive(round.tourId)) yield round.sync.log.events.lastOption .ifTrue(round.sync.log != from.sync.log) diff --git a/modules/relay/src/main/RelayListing.scala b/modules/relay/src/main/RelayListing.scala index a2642aece2164..165e5b05e9dd4 100644 --- a/modules/relay/src/main/RelayListing.scala +++ b/modules/relay/src/main/RelayListing.scala @@ -43,7 +43,7 @@ final class RelayListing( ) -> List( Sort(Descending("tier")), PipelineOperator(group.lookup(colls.group)), - Match(group.filter), + // Match(group.filter), PipelineOperator(roundLookup), UnwindField("round"), Limit(max) @@ -149,18 +149,29 @@ private object RelayListing: def lookup(groupColl: Coll) = $lookup.pipelineFull( from = groupColl.name, as = "group", - let = $doc("id" -> "$_id"), + let = $doc("tourId" -> "$_id"), pipe = List( - $doc("$match" -> $doc("$expr" -> $doc("$in" -> $arr("$$id", "$tours")))), + $doc("$match" -> $doc("$expr" -> $doc("$in" -> $arr("$$tourId", "$tours")))), $doc: "$project" -> $doc( - "_id" -> false, - "name" -> true, - "first" -> $doc("$eq" -> $arr("$$id", $doc("$first" -> "$tours"))) + "_id" -> false, + "name" -> true, + "isFirst" -> $doc("$eq" -> $arr("$$tourId", $doc("$first" -> "$tours"))) ) ) ) - val filter = $doc("group.0.first".$ne(false)) + val filter = $doc("group.0.isFirst".$ne(false)) + + def groupOngoingTourLookup(tourColl: Coll) = $lookup.pipelineFull( + from = tourColl.name, + as = "ongoingTour", + let = $doc("tourIds" -> "$tours"), + pipe = List( + $doc("$match" -> $doc("$expr" -> $doc("$in" -> $arr("_id", "$$tourIds")))), + $doc("$match" -> $doc("ongoing" -> true)), + $doc("$project" -> $doc("_id" -> false, "id" -> true)) + ) + ) def readFrom(doc: Bdoc): Option[RelayGroup.Name] = for garr <- doc.getAsOpt[Barr]("group") diff --git a/modules/relay/src/main/RelayRound.scala b/modules/relay/src/main/RelayRound.scala index 7b3f59ac7f79e..75505b7cb08e6 100644 --- a/modules/relay/src/main/RelayRound.scala +++ b/modules/relay/src/main/RelayRound.scala @@ -51,6 +51,8 @@ case class RelayRound( case Some(at) => at.isBefore(nowInstant.minusHours(3)) case None => createdAt.isBefore(nowInstant.minusDays(1)) + def stateHash = (hasStarted, finished) + def withSync(f: RelayRound.Sync => RelayRound.Sync) = copy(sync = f(sync)) def withTour(tour: RelayTour) = RelayRound.WithTour(this, tour) diff --git a/modules/relay/src/main/RelayTour.scala b/modules/relay/src/main/RelayTour.scala index 21e72c6fba25f..249357726b7c8 100644 --- a/modules/relay/src/main/RelayTour.scala +++ b/modules/relay/src/main/RelayTour.scala @@ -15,6 +15,7 @@ case class RelayTour( createdAt: Instant, tier: Option[RelayTour.Tier], // if present, it's an official broadcast active: Boolean, // a round is scheduled or ongoing + ongoing: Boolean, // a round is ongoing syncedAt: Option[Instant], // last time a round was synced spotlight: Option[RelayTour.Spotlight] = None, autoLeaderboard: Boolean = true, diff --git a/modules/relay/src/main/RelayTourForm.scala b/modules/relay/src/main/RelayTourForm.scala index a7c2e04b9afab..63418a328e515 100644 --- a/modules/relay/src/main/RelayTourForm.scala +++ b/modules/relay/src/main/RelayTourForm.scala @@ -82,6 +82,7 @@ object RelayTourForm: ownerId = me, tier = tier.ifTrue(Granter(_.Relay)), active = false, + ongoing = false, createdAt = nowInstant, syncedAt = none, autoLeaderboard = autoLeaderboard, diff --git a/modules/relay/src/main/RelayTourRepo.scala b/modules/relay/src/main/RelayTourRepo.scala index d3a0fd8af7202..abd5be9668fea 100644 --- a/modules/relay/src/main/RelayTourRepo.scala +++ b/modules/relay/src/main/RelayTourRepo.scala @@ -11,8 +11,8 @@ final private class RelayTourRepo(val coll: Coll)(using Executor): def setSyncedNow(tour: RelayTour): Funit = coll.updateField($id(tour.id), "syncedAt", nowInstant).void - def setActive(tourId: RelayTourId, active: Boolean): Funit = - coll.updateField($id(tourId), "active", active).void + def setActive(tourId: RelayTourId, active: Boolean, ongoing: Boolean): Funit = + coll.update.one($id(tourId), $set("active" -> active, "ongoing" -> ongoing)).void def lookup(local: String) = $lookup.simple(coll, "tour", local, "_id") From 1beb12ecbd29f2b9e5e271d3d79988870132125e Mon Sep 17 00:00:00 2001 From: Thibault Duplessis Date: Sun, 16 Jun 2024 09:54:34 +0200 Subject: [PATCH 068/168] remove transitive dependencies --- build.sbt | 34 +++++++++++++++++----------------- 1 file changed, 17 insertions(+), 17 deletions(-) diff --git a/build.sbt b/build.sbt index 0249ad11ed20a..bb26114807e4c 100644 --- a/build.sbt +++ b/build.sbt @@ -136,12 +136,12 @@ lazy val rating = module("rating", ).dependsOn(common % "test->test") lazy val cms = module("cms", - Seq(memo, coreI18n, ui), + Seq(memo, ui), Seq() ) lazy val puzzle = module("puzzle", - Seq(coreI18n, tree, memo, rating, ui), + Seq(tree, memo, rating), tests.bundle ) @@ -161,7 +161,7 @@ lazy val video = module("video", ) lazy val coach = module("coach", - Seq(memo, rating, ui), + Seq(memo, rating), Seq() ) @@ -181,7 +181,7 @@ lazy val feed = module("feed", ) lazy val ublog = module("ublog", - Seq(coreI18n, memo, ui), + Seq(memo, ui), Seq(bloomFilter) ) @@ -191,7 +191,7 @@ lazy val evaluation = module("evaluation", ) lazy val perfStat = module("perfStat", - Seq(ui, memo, rating), + Seq(memo, rating), Seq() ) @@ -221,7 +221,7 @@ lazy val timeline = module("timeline", ) lazy val event = module("event", - Seq(memo, coreI18n, ui), + Seq(memo, ui), Seq() ) @@ -241,7 +241,7 @@ lazy val game = module("game", ) lazy val gameSearch = module("gameSearch", - Seq(coreI18n, search, ui), + Seq(search, ui), tests.bundle ) @@ -257,7 +257,7 @@ lazy val bot = module("bot", ) lazy val analyse = module("analyse", - Seq(coreI18n, tree, memo, ui), + Seq(tree, memo, ui), tests.bundle ) @@ -267,7 +267,7 @@ lazy val round = module("round", ) lazy val pool = module("pool", - Seq(coreI18n, db, rating), + Seq(db, rating), Seq() ) @@ -282,7 +282,7 @@ lazy val lobby = module("lobby", ) lazy val setup = module("setup", - Seq(lobby, ui), + Seq(lobby), Seq() ) @@ -292,12 +292,12 @@ lazy val insight = module("insight", ) lazy val tutor = module("tutor", - Seq(insight, ui), + Seq(insight), tests.bundle ) lazy val opening = module("opening", - Seq(coreI18n, memo, ui), + Seq(memo, ui), tests.bundle ) @@ -307,7 +307,7 @@ lazy val gathering = module("gathering", ) lazy val tournament = module("tournament", - Seq(gathering, room, memo, ui), + Seq(gathering, room, memo), Seq(lettuce) ++ tests.bundle ) @@ -332,7 +332,7 @@ lazy val irwin = module("irwin", ) lazy val oauth = module("oauth", - Seq(memo, coreI18n, ui), + Seq(memo, ui), Seq() ) @@ -362,7 +362,7 @@ lazy val title = module("title", ) lazy val study = module("study", - Seq(coreI18n, tree, memo, room, ui), + Seq(tree, memo, room, ui), Seq(lettuce) ++ tests.bundle ++ Seq(scalacheck, munitCheck, chess.testKit) ).dependsOn(common % "test->test") @@ -412,7 +412,7 @@ lazy val mailer = module("mailer", ) lazy val plan = module("plan", - Seq(coreI18n, memo, ui), + Seq(memo, ui), tests.bundle ) @@ -422,7 +422,7 @@ lazy val relation = module("relation", ) lazy val pref = module("pref", - Seq(coreI18n, memo, ui), + Seq(memo, ui), Seq() ) From 23c88e3b104f0191de755cb3e7cf71eb3c35813e Mon Sep 17 00:00:00 2001 From: Thibault Duplessis Date: Sun, 16 Jun 2024 10:00:37 +0200 Subject: [PATCH 069/168] more search .ignore --- .ignore | 3 +++ 1 file changed, 3 insertions(+) diff --git a/.ignore b/.ignore index 09f3c819eec4d..bda35ecf32bd5 100644 --- a/.ignore +++ b/.ignore @@ -6,3 +6,6 @@ public/sound public/piece public/piece-css public/flair +public/images +public/cursors +*.png From 6c20d4977672b7c5fbc269af72c9563b7c8de600 Mon Sep 17 00:00:00 2001 From: Thibault Duplessis Date: Sun, 16 Jun 2024 10:06:31 +0200 Subject: [PATCH 070/168] better redirect to new streak --- ui/puzzle/src/ctrl.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ui/puzzle/src/ctrl.ts b/ui/puzzle/src/ctrl.ts index f80f878802edc..7b5ccfc82f2ed 100755 --- a/ui/puzzle/src/ctrl.ts +++ b/ui/puzzle/src/ctrl.ts @@ -429,7 +429,7 @@ export default class PuzzleCtrl implements ParentCtrl { nextPuzzle = (): void => { if (this.streak && this.lastFeedback != 'win') { - if (this.lastFeedback == 'fail') window.location.replace('/streak'); + if (this.lastFeedback == 'fail') site.redirect(router.withLang('/streak')); return; } if (this.mode !== 'view') return; From 4bb02c8215a363787406df1a9dfa236e389c65eb Mon Sep 17 00:00:00 2001 From: Thibault Duplessis Date: Sun, 16 Jun 2024 10:50:59 +0200 Subject: [PATCH 071/168] user profile mod zone button and actions dropdown tweaks --- app/views/user/show/header.scala | 111 ++++++++++++++++--------------- ui/bits/css/user/_show.scss | 35 +++++----- 2 files changed, 77 insertions(+), 69 deletions(-) diff --git a/app/views/user/show/header.scala b/app/views/user/show/header.scala index fdf75ef45443d..f8ae017695850 100644 --- a/app/views/user/show/header.scala +++ b/app/views/user/show/header.scala @@ -89,63 +89,66 @@ object header: (ctx.isAuth && ctx.isnt(u)) .option(a(cls := "nm-item note-zone-toggle")(splitNumber(s"${social.notes.size} Notes"))) ), - div(cls := "user-actions dropdown")( - a(cls := "text", dataIcon := Icon.Hamburger), - div(cls := "dropdown-window")( - ctx - .is(u) - .option( - frag( - a( - cls := "text", - href := routes.Account.profile, - dataIcon := Icon.Gear - )(trans.site.editProfile.txt()), - a( - cls := "text", - href := routes.Relation.blocks(), - dataIcon := Icon.NotAllowed - )(trans.site.listBlockedPlayers.txt()) - ) - ), - isGranted(_.UserModView).option( - a( - cls := "text mod-zone-toggle", - href := routes.User.mod(u.username), - dataIcon := Icon.Agent - )("Mod zone (Hotkey: m)") - ), - a( - cls := "text", - href := routes.User.tv(u.username), - dataIcon := Icon.AnalogTv - )(trans.site.watchGames.txt()), - ctx - .isnt(u) - .option( - views.relation.actions( - u.light, - relation = social.relation, - followable = social.followable, - blocked = social.blocked - ) - ), - a( - cls := "text", - href := s"${routes.UserAnalysis.index}#explorer/${u.username}", - dataIcon := Icon.Book - )(trans.site.openingExplorer.txt()), + div(cls := "user-actions")( + isGranted(_.UserModView).option( a( - cls := "text", - href := routes.User.download(u.username), - dataIcon := Icon.Download - )(trans.site.exportGames.txt()), - (ctx.isAuth && ctx.kid.no && ctx.isnt(u)).option( + cls := "mod-zone-toggle", + href := routes.User.mod(u.username), + dataIcon := Icon.Agent, + title := "Mod zone (Hotkey: m)" + ) + ), + div(cls := "dropdown")( + a(dataIcon := Icon.Hamburger), + div(cls := "dropdown-window")( + ctx + .is(u) + .option( + frag( + a( + cls := "text", + href := routes.Account.profile, + dataIcon := Icon.Gear + )(trans.site.editProfile.txt()), + a( + cls := "text", + href := routes.Relation.blocks(), + dataIcon := Icon.NotAllowed + )(trans.site.listBlockedPlayers.txt()) + ) + ), a( cls := "text", - href := s"${routes.Report.form}?username=${u.username}", - dataIcon := Icon.CautionTriangle - )(trans.site.reportXToModerators.txt(u.username)) + href := routes.User.tv(u.username), + dataIcon := Icon.AnalogTv + )(trans.site.watchGames.txt()), + ctx + .isnt(u) + .option( + views.relation.actions( + u.light, + relation = social.relation, + followable = social.followable, + blocked = social.blocked + ) + ), + a( + cls := "text", + href := s"${routes.UserAnalysis.index}#explorer/${u.username}", + dataIcon := Icon.Book + )(trans.site.openingExplorer.txt()), + a( + cls := "text", + href := routes.User.download(u.username), + dataIcon := Icon.Download + )(trans.site.exportGames.txt()), + (ctx.isAuth && ctx.kid.no && ctx.isnt(u)).option( + a( + cls := "text", + href := s"${routes.Report.form}?username=${u.username}", + dataIcon := Icon.CautionTriangle + )(trans.site.reportXToModerators.txt(u.username)) + ) ) ) ) diff --git a/ui/bits/css/user/_show.scss b/ui/bits/css/user/_show.scss index b6ed004f1b19e..6fe8b52163c85 100644 --- a/ui/bits/css/user/_show.scss +++ b/ui/bits/css/user/_show.scss @@ -33,23 +33,25 @@ } .user-actions { + @extend %flex-center-nowrap; flex: 0 0 auto; margin: 1em 1em 1em 0.3em; - form { - display: inline; + .mod-zone-toggle, + .dropdown > a { + display: block; + font-size: 2em; + height: 1.5em; + color: $c-font-dim; + padding: 0 0.7em; + } + .mod-zone-toggle:hover { + color: $c-font-clear; } } .dropdown { position: relative; - font-size: 2em; - > a { - display: block; - height: 1.5em; - color: $c-font-page; - padding-left: 0.5em; - } .dropdown-window { @extend %dropdown-shadow; @@ -58,14 +60,17 @@ background: $c-bg-header-dropdown; border-radius: 3px 0 3px 3px; position: absolute; - top: 1.5em; + top: 3rem; right: 0; a { - width: 16em; - font-size: 1rem; + width: 20em; display: block; - padding: 0.6rem 1rem; + padding: 0.7rem 1rem; color: $c-header-dropdown; + &::before { + margin-inline: 0 1rem; + font-size: 1.4em; + } &:first-child { border-radius: 3px 0 0 0; } @@ -83,9 +88,9 @@ } &:hover { > a { - border-radius: 3px 3px 0 0; + @extend %box-radius-top, %dropdown-shadow; background: $c-bg-header-dropdown; - box-shadow: 2px 5px 6px rgba(0, 0, 0, 0.3); + color: $c-font-clear; } .dropdown-window { visibility: visible; From f6f784824a60947ab8cc032af9ea1295ae22cf6d Mon Sep 17 00:00:00 2001 From: Thibault Duplessis Date: Sun, 16 Jun 2024 11:03:40 +0200 Subject: [PATCH 072/168] hide broken user actions in blocked list - closes #15529 --- modules/relation/src/main/ui/RelationUi.scala | 11 +++++++---- 1 file changed, 7 insertions(+), 4 deletions(-) diff --git a/modules/relation/src/main/ui/RelationUi.scala b/modules/relation/src/main/ui/RelationUi.scala index 08517bf5db7bf..8a3a39a07fbec 100644 --- a/modules/relation/src/main/ui/RelationUi.scala +++ b/modules/relation/src/main/ui/RelationUi.scala @@ -126,7 +126,7 @@ final class RelationUi(helpers: Helpers): trans.site.friends() ) ), - pagTable(pag, routes.Relation.following(u.username)) + pagTable(pag, routes.Relation.following(u.username), withActions = true) ) def blocks(u: User, pag: Paginator[Related[UserWithPerfs]])(using Context) = @@ -136,7 +136,7 @@ final class RelationUi(helpers: Helpers): h1(userLink(u, withOnline = false)), div(cls := "actions")(trans.site.blocks.pluralSame(pag.nbResults)) ), - pagTable(pag, routes.Relation.blocks()) + pagTable(pag, routes.Relation.blocks(), withActions = false) ) def opponents(u: User, sugs: List[Related[UserWithPerfs]])(using ctx: Context) = @@ -177,7 +177,9 @@ final class RelationUi(helpers: Helpers): .wrap: body => main(cls := "box page-small")(body) - private def pagTable(pager: Paginator[Related[UserWithPerfs]], call: Call)(using ctx: Context) = + private def pagTable(pager: Paginator[Related[UserWithPerfs]], call: Call, withActions: Boolean)(using + ctx: Context + ) = table(cls := "slist slist-pad")( if pager.nbResults > 0 then @@ -189,7 +191,8 @@ final class RelationUi(helpers: Helpers): td(trans.site.nbGames.plural(r.user.count.game, r.user.count.game.localize)), td(r.user.seenAt.map: seen => trans.site.lastSeenActive(momentFromNow(seen))), - td(actions(r.user.light, relation = r.relation, followable = r.followable, blocked = false)) + withActions.option: + td(actions(r.user.light, relation = r.relation, followable = r.followable, blocked = false)) ), pagerNextTable(pager, np => addQueryParam(call.url, "page", np.toString)) ) From e64b23b205e5a19b7c08aacf2a65ea196e76aaa5 Mon Sep 17 00:00:00 2001 From: Thibault Duplessis Date: Sun, 16 Jun 2024 11:41:47 +0200 Subject: [PATCH 073/168] set initial tour.ongoing --- modules/relay/src/main/RelayApi.scala | 8 +++----- 1 file changed, 3 insertions(+), 5 deletions(-) diff --git a/modules/relay/src/main/RelayApi.scala b/modules/relay/src/main/RelayApi.scala index d95cdc03c88de..8b3735f5e4564 100644 --- a/modules/relay/src/main/RelayApi.scala +++ b/modules/relay/src/main/RelayApi.scala @@ -194,10 +194,9 @@ final class RelayApi( def create(data: RelayRoundForm.Data, tour: RelayTour)(using me: Me): Fu[RelayRound.WithTourAndStudy] = roundRepo .lastByTour(tour) - .flatMapz { last => + .flatMapz: last => studyRepo.byId(last.studyId) - } - .flatMap { lastStudy => + .flatMap: lastStudy => import lila.study.{ StudyMember, StudyMembers } val relay = data.make(me, tour) for @@ -226,10 +225,9 @@ final class RelayApi( ) .orFail(s"Can't create study for relay $relay") _ <- roundRepo.coll.insert.one(relay) - _ <- tourRepo.setActive(tour.id, true) + _ <- tourRepo.setActive(tour.id, true, relay.hasStarted) _ <- studyApi.addTopics(relay.studyId, List(StudyTopic.broadcast.value)) yield relay.withTour(tour).withStudy(study.study) - } def requestPlay(id: RelayRoundId, v: Boolean): Funit = WithRelay(id): relay => From cc93e452796bf76de63a99e617e65b9e60e338f0 Mon Sep 17 00:00:00 2001 From: Thibault Duplessis Date: Sun, 16 Jun 2024 11:52:23 +0200 Subject: [PATCH 074/168] fix relay_tour compat --- modules/relay/src/main/RelayTour.scala | 2 +- modules/relay/src/main/RelayTourForm.scala | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/modules/relay/src/main/RelayTour.scala b/modules/relay/src/main/RelayTour.scala index 249357726b7c8..aa544c263cdb0 100644 --- a/modules/relay/src/main/RelayTour.scala +++ b/modules/relay/src/main/RelayTour.scala @@ -15,7 +15,7 @@ case class RelayTour( createdAt: Instant, tier: Option[RelayTour.Tier], // if present, it's an official broadcast active: Boolean, // a round is scheduled or ongoing - ongoing: Boolean, // a round is ongoing + ongoing: Option[Boolean], // a round is ongoing syncedAt: Option[Instant], // last time a round was synced spotlight: Option[RelayTour.Spotlight] = None, autoLeaderboard: Boolean = true, diff --git a/modules/relay/src/main/RelayTourForm.scala b/modules/relay/src/main/RelayTourForm.scala index 63418a328e515..2bd953d351c43 100644 --- a/modules/relay/src/main/RelayTourForm.scala +++ b/modules/relay/src/main/RelayTourForm.scala @@ -82,7 +82,7 @@ object RelayTourForm: ownerId = me, tier = tier.ifTrue(Granter(_.Relay)), active = false, - ongoing = false, + ongoing = none, createdAt = nowInstant, syncedAt = none, autoLeaderboard = autoLeaderboard, From 8d63e1cd70b8c15ff9741ea01a347d69504bad36 Mon Sep 17 00:00:00 2001 From: Thibault Duplessis Date: Sun, 16 Jun 2024 11:56:32 +0200 Subject: [PATCH 075/168] rename relay tour "live" --- modules/relay/src/main/RelayApi.scala | 6 +++--- modules/relay/src/main/RelayListing.scala | 8 ++++---- modules/relay/src/main/RelayTour.scala | 2 +- modules/relay/src/main/RelayTourForm.scala | 2 +- modules/relay/src/main/RelayTourRepo.scala | 4 ++-- modules/relay/src/main/ui/RelayTourUi.scala | 20 ++++++++++---------- ui/bits/css/relay/_card.scss | 4 ++-- 7 files changed, 23 insertions(+), 23 deletions(-) diff --git a/modules/relay/src/main/RelayApi.scala b/modules/relay/src/main/RelayApi.scala index 8b3735f5e4564..739a7ef4d14d5 100644 --- a/modules/relay/src/main/RelayApi.scala +++ b/modules/relay/src/main/RelayApi.scala @@ -78,9 +78,9 @@ final class RelayApi( def denormalizeTourActive(tourId: RelayTourId): Funit = val unfinished = RelayRoundRepo.selectors.tour(tourId) ++ $doc("finished" -> false) for - active <- roundRepo.coll.exists(unfinished) - ongoing <- active.so(roundRepo.coll.exists(unfinished ++ $doc("startedAt".$exists(true)))) - _ <- tourRepo.setActive(tourId, active, ongoing) + active <- roundRepo.coll.exists(unfinished) + live <- active.so(roundRepo.coll.exists(unfinished ++ $doc("startedAt".$exists(true)))) + _ <- tourRepo.setActive(tourId, active, live) yield () object countOwnedByUser: diff --git a/modules/relay/src/main/RelayListing.scala b/modules/relay/src/main/RelayListing.scala index 165e5b05e9dd4..cb9382c327953 100644 --- a/modules/relay/src/main/RelayListing.scala +++ b/modules/relay/src/main/RelayListing.scala @@ -56,7 +56,7 @@ final class RelayListing( yield (tour, round, group) sorted = tours.sortBy: (tour, round, _) => ( - !round.startedAt.isDefined, // ongoing tournaments first + !round.hasStarted, // ongoing tournaments first 0 - ~tour.tier, // then by tier 0 - ~round.crowd, // then by viewers round.startsAt.fold(Long.MaxValue)(_.toMillis) // then by next round date @@ -162,13 +162,13 @@ private object RelayListing: ) val filter = $doc("group.0.isFirst".$ne(false)) - def groupOngoingTourLookup(tourColl: Coll) = $lookup.pipelineFull( + def groupliveTourLookup(tourColl: Coll) = $lookup.pipelineFull( from = tourColl.name, - as = "ongoingTour", + as = "liveTour", let = $doc("tourIds" -> "$tours"), pipe = List( $doc("$match" -> $doc("$expr" -> $doc("$in" -> $arr("_id", "$$tourIds")))), - $doc("$match" -> $doc("ongoing" -> true)), + $doc("$match" -> $doc("live" -> true)), $doc("$project" -> $doc("_id" -> false, "id" -> true)) ) ) diff --git a/modules/relay/src/main/RelayTour.scala b/modules/relay/src/main/RelayTour.scala index aa544c263cdb0..f0c106eed16e5 100644 --- a/modules/relay/src/main/RelayTour.scala +++ b/modules/relay/src/main/RelayTour.scala @@ -15,7 +15,7 @@ case class RelayTour( createdAt: Instant, tier: Option[RelayTour.Tier], // if present, it's an official broadcast active: Boolean, // a round is scheduled or ongoing - ongoing: Option[Boolean], // a round is ongoing + live: Option[Boolean], // a round is live, i.e. started and not finished syncedAt: Option[Instant], // last time a round was synced spotlight: Option[RelayTour.Spotlight] = None, autoLeaderboard: Boolean = true, diff --git a/modules/relay/src/main/RelayTourForm.scala b/modules/relay/src/main/RelayTourForm.scala index 2bd953d351c43..b5bbc133ed8b3 100644 --- a/modules/relay/src/main/RelayTourForm.scala +++ b/modules/relay/src/main/RelayTourForm.scala @@ -82,7 +82,7 @@ object RelayTourForm: ownerId = me, tier = tier.ifTrue(Granter(_.Relay)), active = false, - ongoing = none, + live = none, createdAt = nowInstant, syncedAt = none, autoLeaderboard = autoLeaderboard, diff --git a/modules/relay/src/main/RelayTourRepo.scala b/modules/relay/src/main/RelayTourRepo.scala index abd5be9668fea..fed24b208718d 100644 --- a/modules/relay/src/main/RelayTourRepo.scala +++ b/modules/relay/src/main/RelayTourRepo.scala @@ -11,8 +11,8 @@ final private class RelayTourRepo(val coll: Coll)(using Executor): def setSyncedNow(tour: RelayTour): Funit = coll.updateField($id(tour.id), "syncedAt", nowInstant).void - def setActive(tourId: RelayTourId, active: Boolean, ongoing: Boolean): Funit = - coll.update.one($id(tourId), $set("active" -> active, "ongoing" -> ongoing)).void + def setActive(tourId: RelayTourId, active: Boolean, live: Boolean): Funit = + coll.update.one($id(tourId), $set("active" -> active, "live" -> live)).void def lookup(local: String) = $lookup.simple(coll, "tour", local, "_id") diff --git a/modules/relay/src/main/ui/RelayTourUi.scala b/modules/relay/src/main/ui/RelayTourUi.scala index ecde8f219cc3e..d0dd6ab58a424 100644 --- a/modules/relay/src/main/ui/RelayTourUi.scala +++ b/modules/relay/src/main/ui/RelayTourUi.scala @@ -22,7 +22,7 @@ final class RelayTourUi(helpers: Helpers, ui: RelayUi): val selected = active.filter(_.tour.tierIs(selector)) selected.nonEmpty.option(st.section(cls := s"relay-cards relay-cards--tier-$tier"): selected.map: - card.render(_, ongoing = _.display.hasStarted) + card.render(_, live = _.display.hasStarted) ) Page(trc.liveBroadcasts.txt()) .css("bits.relay.index") @@ -40,7 +40,7 @@ final class RelayTourUi(helpers: Helpers, ui: RelayUi): h2(cls := "relay-index__section")("Upcoming broadcasts"), st.section(cls := "relay-cards relay-cards--upcoming"): upcoming.map: - card.render(_, ongoing = _ => false) + card.render(_, live = _ => false) ) ), h2(cls := "relay-index__section")("Past broadcasts"), @@ -146,24 +146,24 @@ final class RelayTourUi(helpers: Helpers, ui: RelayUi): ) private object card: - private def link(t: RelayTour, url: String, ongoing: Boolean) = a( + private def link(t: RelayTour, url: String, live: Boolean) = a( href := url, cls := List( - "relay-card" -> true, - "relay-card--active" -> t.active, - "relay-card--ongoing" -> ongoing + "relay-card" -> true, + "relay-card--active" -> t.active, + "relay-card--live" -> live ) ) private def image(t: RelayTour) = t.image.fold(ui.thumbnail.fallback(cls := "relay-card__image")): id => img(cls := "relay-card__image", src := ui.thumbnail.url(id, _.Size.Small)) - def render[A <: RelayRound.AndTourAndGroup](tr: A, ongoing: A => Boolean)(using Context) = - link(tr.tour, tr.path, ongoing(tr))( + def render[A <: RelayRound.AndTourAndGroup](tr: A, live: A => Boolean)(using Context) = + link(tr.tour, tr.path, live(tr))( image(tr.tour), span(cls := "relay-card__body")( span(cls := "relay-card__info")( tr.tour.active.option(span(cls := "relay-card__round")(tr.display.name)), - if ongoing(tr) + if live(tr) then span(cls := "relay-card__live")( "LIVE", @@ -204,7 +204,7 @@ final class RelayTourUi(helpers: Helpers, ui: RelayUi): def renderPager(pager: Paginator[RelayTour | WithLastRound])(next: Int => Call)(using Context): Tag = st.section(cls := "infinite-scroll relay-cards")( pager.currentPageResults.map: - case w: WithLastRound => card.render(w, ongoing = _ => false)(cls := "paginated") + case w: WithLastRound => card.render(w, live = _ => false)(cls := "paginated") case t: RelayTour => card.empty(t)(cls := "paginated") , pagerNext(pager, next(_).url) diff --git a/ui/bits/css/relay/_card.scss b/ui/bits/css/relay/_card.scss index ad1b0d43eca4b..7f046141c6538 100644 --- a/ui/bits/css/relay/_card.scss +++ b/ui/bits/css/relay/_card.scss @@ -29,7 +29,7 @@ 0 0 20px $c-link; } - &--ongoing { + &--live { outline: 3px solid $m-bad--alpha-50; &:hover { box-shadow: @@ -42,7 +42,7 @@ width: 100%; height: auto; opacity: 0.7; - .relay-card--ongoing & { + .relay-card--live & { opacity: 0.9; } @include transition(opacity); From 30d1b9ac080bd6bb5d111170787dc73f07c67db2 Mon Sep 17 00:00:00 2001 From: Thibault Duplessis Date: Sun, 16 Jun 2024 14:13:55 +0200 Subject: [PATCH 076/168] Revert "add monarch piece set" --- COPYING.md | 1 - bin/gen/piece-sprite | 1 - modules/pref/src/main/PieceSet.scala | 1 - public/piece-css/monarchy.css | 12 ------------ public/piece-css/monarchy.external.css | 12 ------------ public/piece/monarchy/bB.svg | 1 - public/piece/monarchy/bK.svg | 1 - public/piece/monarchy/bN.svg | 1 - public/piece/monarchy/bP.svg | 1 - public/piece/monarchy/bQ.svg | 1 - public/piece/monarchy/bR.svg | 1 - public/piece/monarchy/wB.svg | 1 - public/piece/monarchy/wK.svg | 1 - public/piece/monarchy/wN.svg | 1 - public/piece/monarchy/wP.svg | 1 - public/piece/monarchy/wQ.svg | 1 - public/piece/monarchy/wR.svg | 1 - 17 files changed, 39 deletions(-) delete mode 100644 public/piece-css/monarchy.css delete mode 100644 public/piece-css/monarchy.external.css delete mode 100644 public/piece/monarchy/bB.svg delete mode 100644 public/piece/monarchy/bK.svg delete mode 100644 public/piece/monarchy/bN.svg delete mode 100644 public/piece/monarchy/bP.svg delete mode 100644 public/piece/monarchy/bQ.svg delete mode 100644 public/piece/monarchy/bR.svg delete mode 100644 public/piece/monarchy/wB.svg delete mode 100644 public/piece/monarchy/wK.svg delete mode 100644 public/piece/monarchy/wN.svg delete mode 100644 public/piece/monarchy/wP.svg delete mode 100644 public/piece/monarchy/wQ.svg delete mode 100644 public/piece/monarchy/wR.svg diff --git a/COPYING.md b/COPYING.md index 6531d7f304a28..0362eaf249abe 100644 --- a/COPYING.md +++ b/COPYING.md @@ -59,7 +59,6 @@ public/piece/disguised | danegraphics | [CC BY-NC-SA 4.0](https://creativecommon public/piece/kiwen-suwi | [neverRare](https://github.com/neverRare) | [CC BY 4.0](https://creativecommons.org/licenses/by/4.0/) public/piece/mpchess | [Maxime Chupin](https://github.com/chupinmaxime) | [GPL3v3+](https://www.gnu.org/licenses/quick-guide-gplv3.en.html) public/piece/cooke | [fejfar](https://github.com/fejfar) | [CC BY-NC-SA 4.0](https://creativecommons.org/licenses/by-nc-sa/4.0/) -public/piece/monarchy | [slither77](https://github.com/slither77) | [CC BY-NC-SA 4.0](https://creativecommons.org/licenses/by-nc-sa/4.0/) public/sounds/futuristic | [Enigmahack](https://github.com/Enigmahack) | AGPLv3+ public/sounds/nes | [Enigmahack](https://github.com/Enigmahack) | AGPLv3+ public/sounds/piano | [Enigmahack](https://github.com/Enigmahack) | AGPLv3+ diff --git a/bin/gen/piece-sprite b/bin/gen/piece-sprite index cf2f374d4c976..afcb9537bb27c 100755 --- a/bin/gen/piece-sprite +++ b/bin/gen/piece-sprite @@ -44,7 +44,6 @@ themes = [ ['kiwen-suwi', 'svg'], ['mpchess','svg'], ['cooke','svg'], - ['monarchy', 'svg'], ] types = { 'svg' => 'svg+xml;base64,', diff --git a/modules/pref/src/main/PieceSet.scala b/modules/pref/src/main/PieceSet.scala index 38874ecf48c98..55178a1e70e5f 100644 --- a/modules/pref/src/main/PieceSet.scala +++ b/modules/pref/src/main/PieceSet.scala @@ -47,7 +47,6 @@ object PieceSet extends PieceSetObject: PieceSet("tatiana"), PieceSet("staunty"), PieceSet("cooke"), - PieceSet("monarchy"), PieceSet("governor"), PieceSet("dubrovny"), PieceSet("icpieces"), diff --git a/public/piece-css/monarchy.css b/public/piece-css/monarchy.css deleted file mode 100644 index 87558a658876f..0000000000000 --- a/public/piece-css/monarchy.css +++ /dev/null @@ -1,12 +0,0 @@ -.is2d .pawn.white {background-image:url('data:image/svg+xml;base64,<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="614.635" height="614.635" viewBox="0 0 460.977 460.977"><mask id="b"><use xlink:href="#a" width="1280" height="1280" transform="rotate(.193) scale(.36014)"/></mask><symbol id="a" viewBox="0 0 1280 1280"><image width="1280" height="1280" xlink:href="data:image/png;base64, iVBORw0KGgoAAAANSUhEUgAABQAAAAUACAAAAAA9j6ArAAAACXBIWXMAAA7EAAAO xAGVKw4bAAA+UklEQVR4nO3dB5SV5b228XFmGBjKSEdALESN0ZgTv8RgieYQDYqC EcGuiAUrKAgiWMCGAcWKLYpii1GwxY5BMaICcmJMscSCiEiHoQ3T93xDZ6izZ973 vZ/n+V+/s1bOSuKBe23Y19mz37ZTBgAYtZN6AACoEEAAZhFAAGYRQABmEUAAZhFA AGYRQABmEUAAZhFAAGYRQABmEUAAZhFAAGYRQABmEUAAZhFAAGYRQABmEUAAZhFA AGYRQABmEUAAZhFAAGYRQABmEUAAZhFAAGYRQABmEUAAZhFAAGYRQABmEUAAZhFA AGYRQABmEUAAZhFAAGYRQABmEUAAZhFAAGYRQABmEUAAZhFAAGYRQABmEUAAZhFA AGYRQABmEUAAZhFAAGYRQABmEUAAZhFAAGYRQABmEUAAZhFAAGYRQABmEUAAZhFA AGYRQABmEUAAZhFAAGYRQABmEUAAZhFAAGYRQABmEUAAZhFAAGYRQABmEUAAZhFA AGYRQABmEUAAZhFAAGYRQABmEUAAZhFAAGYRQABmEUAAZhFAAGYRQABmEUAAZhFA AGYRQABmEUAAZhFAAGYRQABmEUAAZhFAAGYRQABmEUAAZhFAAGYRQABmEUAAZhFA AGYRQABmEUAAZhFAAGYRQABmEUAAZhFAAGYRQABmEUAAZhFAAGYRQABmEUAAZhFA AGYRQABmEUAAZhFAAGYRQABmEUAAZhFAAGYRQABmEUAAZhFAAGYRQABmEUAAZhFA AGYRQABmEUAAZhFAAGYRQABmEUAAZhFAAGYRQABmEUAAZhFAAGYRQABmEUAAZhFA AGYRQABmEUAAZhFAAGYRQABmEUAAZhFAAGYRQABmEUAAZhFAAGYRQABmEUAAZhFA AGYRQABmEUAAZhFAAGYRQABmEUAAZhFAAGYRQABmEUAAZhFAAGYRQABmEUAAZhFA AGYRQABmEUAAZhFAAGYRQABmEUAAZhFAAGYRQABmEUAAZhFAAGYRQABmEUAAZhFA AGYRQABmEUAAZhFAAGYRQABmEUAAZhFAAGYRQABmEUAAZhFAAGYRQABmEUAAZhFA AGYRQABmEUAAZhFAAGYRQABmEUAAZhFAAGYRQABmEUAAZhFAAGYRQABmEUAAZhFA AGYRQABmEUAAZhFAAGYRQABmEUAAZhFAAGYRQABmEUAAZhFAAGYRQABmEUAAZhFA AGYRQABmEUAAZhFAAGYRQABmEUAAZhFAAGYRQABmEUAAZhFAAGYRQABmEUAAZhFA AGYRQABmEUAAZhFAAGYRQABmEUAAZhFAAGYRQABmEUAAZhFAAGYRQABmEUAAZhFA AGYRQABmEUAAZhFAAGYRQABmEUAAZhFAAGYRQABmEUAAZhFAAGYRQABmEUAAZhFA AGYRQABmEUAAZhFAAGYRQABmEUAAZhFAAGYRQABmEUAAZhFAAGYRQABmEUAAZhFA AGYRQABmEUAAZhFAAGYRQABmEUAAZhFAAGYRQABmEUAAZhFAAGYRQABmEUAAZhFA AGYRQABmEUAAZhFAAGYRQABmEUAAZhFAAGYRQABmEUAAZhFAAGYRQABmEUAAZhFA AGYRQABmEUAAZhFAAGYRQABmEUAAZhFAAGYRQABmEUAAZhFAAGYRQABmEUAAZhFA AGYRQABmEUCI7FShXgAQQCTusKaV/9K+3fczKv/XoinqNbCMACIZXTM6tWxxYEbd 3C3/q8Liik8WzP9r6vXkV8E4Aoh4tTi4w//8Irdx9f7h/MLp/5w6NT/eRcAGBBCx 6dpp/wOrWb4qKvI//s8bb0U+B9gCAUQcup59aIvs2v0SpfMnP/J2NGuAbSCAiNi+ Zx568Fa+6KuZlR++96eZUf1iwOYIICK075mdDqzlB78tlXz0xlOzov5FgdUIICLS oucp0cdvvZJpTzyzMq5fHHYRQEThsPNPqMnhjrTMH/fIP+P+PWAMAUStdb7y8Ng+ +lVV/NYtU5P5nWADAUTtDDjloER/v/LJY59I9DdEyAggaqHzlR0Fv2v5KyOmCX5b BIgAoqYOvPGYhH7y3VLRuGEzVb83AkIAUSMthlwU2cl+NbPk1nsKtQvgPwKIGuh8 Q7Jf/G1d+duD/6HeAL8RQKRL/+Fvo8Uj7uNjIGqOACI9B96uOO6xbWUvDPxevQHe IoBIR88+Lvzsu5m3bpuongBPEUBU37UDYr/co2a+u+ZP6gnwEgFEdd3RV3bWy44t v/o+9QR4iACiepzO32rLh9yvngDvEEBUh/P5W235VQ+qJ8AzBBA75kX+Vls2mAQi HQQQO+JN/lZbdtUf1RPgEQKI7btwhKNHfrfloys+UE+ANwggtqfDm57lb7XJ3Rar J8ATBBDb1vpPbl31UV2pxy4oV2+AFwggtmlsL/WCGiscOko9AT4ggNiGC+905pYH NTHrrPfUE+A+Aoitav0XBy/6TUtq/KnqCXAeAcTW3NFfvSACBX0eU0+A4wggtuTl sd+tmdQ9Xz0BTiOA2MJz3dULIlM08nr1BLiMAGIzJzzt9cGPzU0/dYZ6AtxFAFFV QB//1iq98Wb1BDiLAGJTwXz7t6m3eyxVT4CjCCA2EcTB3y2tuJgbRmOrCCA22PWj 1uoJMal4MbQf7BENAoj1LrzXo9tepWvOCdPVE+AgAoh1gjv6UVXp0BHqCXAPAcQa u/47wKMfVb3WRb0AziGAWO2EF9ULEjCvwyz1BDiGACLD6xtfpaPosofVE+AWAogA 7vxSXeWPn6eeAKcQQHSYFNS1b9v3ty4r1RPgEAJonomv/zaa02G2egLcQQCtC/Ti j20rOMtW8bE9BNC4d/x87FFtlI0aop4AVxBA0+wc/thU+aMXqCfAEQTQsl2/NHT4 Y1NvHa1eADcQQMNMHf6t6u3jV6knwAUE0C5jh3+rmnXIHPUEOIAAmmW6fxQQaxBA q8yd/rK5FWe+rJ4AOQJolPn+UUBkEECr6F+l5We8qp4AMQJoEv1bgwKaRwAton/r UEDrCKBB9G+DZWe8pp4AJQJoD/3bBAW0jQCaQ/+qoICmEUBr6N9mlp32hnoCZAig MfRvC0tPp4BmEUBbrr1JvcBBi4/+u3oCRAigKcav/92W6Z2WqidAgwBaQv+2Yfrv lqknQIIAGrLr9+oFzpr0W/UCSBBAO8ze/7k6XjxRvQAKBNCOVfRvO545Tb0AAgTQ jI8sPv+o+spuu1o9AckjgFY81129wHEF/caoJyBxBNAIToDeoSXd31VPQNIIoA2c AFMNUzpzMow1BNCEXb/NVk/wwatd1QuQMAJoAgeAq+eps9QLkCwCaAEHgKupdOR1 6glIFAE0gAMg1bb4xPfUE5AkAhg+DoCk4YNjl6snIEEEMHhcAZeWcaeoFyBBBDB4 c1qrF3il/K6B6glIDgEM3dhe6gWeWXrG6+oJSAwBDBxfAKZtche+BjSDAIat9Td8 AZi2P5+uXoCkEMCwvdNRvcBDRVffqZ6AhBDAoPEMpBqZc8y/1ROQDAIYMu6BX0Nv HKtegGQQwJBxBkwNlY8arJ6ARBDAgPEDcI390Jkfgk0ggOHiB+BaeK2LegGSQADD xQ/AtVB+K48IsYAABosfgGtl9jGfqicgfgQwVK3nqBd47pXj1QsQPwIYKm6CWksl N9yinoDYEcBAXfigeoH3vunIUaTgEcBAlfIUpFp74mz1AsSNAIaJx6BHYFmvl9QT EDMCGKQOU9ULgjDpyAr1BMSLAAYpv7F6QRBSt/CQuMARwBBxBCQi049bqJ6AWBHA EHEEJCqPnaNegFgRwADxGJDILDr1bfUExIkAhodrQCL04onqBYgTAQwPt8GPUOEl j6knIEYEMDgHfqxeEJSJnTgVJmAEMDhcBBypkivuU09AfAhgaHgQcMQmH7NKPQGx IYCh4RzoiKVuuFE9AbEhgIHhHOjITe26SD0BcSGAgeEDYORS13Nv7WARwLDwATAG U47nI2CoCGBY+AAYAz4ChosABoUPgLHgI2CwCGBQ+AAYi9Swm9UTEA8CGJLOr6sX BGpSF84FDBMBDAkXgcSk+LKH1BMQCwIYEK4Cjs2bndULEAsCGBA+AMaGj4CBIoDh aLFAvSBgfz5dvQBxIIDh4FGYMVpy5hvqCYgBAQwHTwKJ0wOXqBcgBgQwGHf0Vy8I 2ve//4d6AqJHAIPBSdCxSl0zQj0B0SOAoeAk6Ji9fTwnQ4eHAIaCc2BiVtxnjHoC IkcAA8E5MLH705nqBYgcAQwEh0BiN+sEDoMEhwAGYlWuekH4bhymXoCoEcAwcBlw Al7rol6AqBHAMLzTUb3AgILznlVPQMQIYBi4CiQJIwerFyBiBDAIA0apF5gwrfsP 6gmIFgEMAicBJqLokrHqCYgWAQxChXqAEQ9dqF6AaBHAEHASYEK+O+ET9QREigCG YE5r9QIjSvvfp56ASBHAAHAZXGKePVW9AJEigAHgJ+DEzOzGz8BBIYAB4CfgxJRe /oB6AqJEAAPAMeDk3DFAvQBRIoD+4yzoBE3tPkc9AREigP7jLOgEFV34hHoCIkQA /cd1wEkafq16ASJEAL132PvqBaa8dkKZegKiQwC9x/PQE7XotInqCYgOAfQej8NM VGrQ7eoJiA4B9B2XgSRsTG/1AkSHAPqOk2ASNqUHJ8KEgwD6jpvhJ2xlr+fVExAZ Aug7HgeXtGtuUS9AZAig5/gKMHE8ID0gBNBzN1+jXmDOt93+qZ6AqBBAz/EVYOJW nP2iegKiQgA9x1eAyRsyQr0AUSGAfuMrQAEejRQOAui3no+rFxg0qXu+egIiQgD9 9koX9QKDlpw+QT0BESGAfuNCYIHUFXerJyAiBNBv3A1fYeRg9QJEhAB6bd/P1QtM euwc9QJEhAB6jTshSHzYY656AqJBAL3GMRAJjoIEgwB6jWMgEhwFCQYB9BrPQ9K4 /gb1AkSDAPqM60BEHrxYvQDRIIA+6/qyeoFRb3ZfpZ6ASBBAn43uo15g1Owe09QT EAkC6DPuhSWyoudL6gmIBAH0GQeBRVL9RqsnIBIE0GccBFYZdqN6ASJBAH3GlcAq dwxQL0AkCKDHDntfvcCsp3uWqycgCgTQY5wFI/NGD86DCQIB9NgTZ6kXmLXwlEnq CYgCAfQYt0KQWXLaW+oJiAIB9Nic1uoFZpVe9Kh6AqJAAD3GaYAy5f3uVU9AFAig xzgNUGfoTeoFiAIB9BinAercPlC9AFEggP7iZlhC91+qXoAoEEB/cRqg0HNnFakn IAIE0F8EUIgAhoEA+qvn4+oFhk08aal6AiJAAP3FhSBCC09+Vz0BESCA/nr2ZPUC wxafzqUgISCA/uJKOCECGAYC6C+uhBPiWrgwEEB/cSWcENfChYEA+osAChHAMBBA fxFAIQIYBgLoL+6FoHTdzeoFiAAB9BefAIX4BBgGAugvAihEAMNAAP1FAIUIYBgI oL8IoBABDAMB9BcnQgtxInQYCKC/uBROiEvhwkAA/cXNEIQIYBgIoL+4HZYQt8MK AwH0FzdEFeKGqGEggP7ilvhC3BI/DATQXwRQiACGgQB6jOcC6/Bc4DAQQI8RQB0C GAYC6DFuB6Mz9Cb1AkSBAHqMa+FkuBIuEATQY1wLJ8OVcIEggB7jWjiZJadxIUgQ CKDHRvdRLzBrdo9p6gmIAgH0GCcCyrzRY5V6AqJAAD122PvqBWY93bNcPQFRIIA+ 40RAlTsGqBcgEgTQZ5wIqDLsRvUCRIIA+owTAUVS/UarJyASBNBnnAcjwlkwoSCA PuM8GBHOggkFAfQZ58GIvNmds2DCQAB91mKBeoFRD16sXoBoEECvcRhY4/ob1AsQ DQLoNQ4DS6SuuFs9AdEggF7jMLDEktMnqCcgGgTQawNGqReY9GGPueoJiAYB9Nq+ n6sXmPTYOeoFiAgB9BtXAyuMHKxegIgQQL9xFESAYyDhIIB+4yiIAMdAwkEA/dbz cfUCgyZ1z1dPQEQIoN+4FkTgoQvVCxAVAui5VbnqBfYMGaFegKgQQM+901G9wJwV Z7+onoCoEEDPcSp04qb0mKOegKgQQM/xJWDi+AowIATQd3wJmLRrblEvQGQIoO/4 EjBhK3s9r56AyBBA3/ElYML4CjAkBNB3fAmYsDG91QsQHQLoPS4HTlRq0O3qCYgO AfTec93VC0xZdNpE9QREhwB677D31QtMee2EMvUERIcA+o8nIyVp+LXqBYgQAfTf RwepFxhSdOET6gmIEAH0HyfCJGhqd06CCQkBDAD3xU/OHQPUCxAlAhiAOa3VC8wo vfwB9QREiQAG4I7+6gVmzOz2iXoCokQAA8DFIIl59lT1AkSKAIaAn4ETUtr/PvUE RIoAhoCfgRPy3Qn8BBwWAhgEjgMng3uhhoYABoFzoRNRdMlY9QREiwAGgXOhEzGt +w/qCYgWAQwD1wMnYeRg9QJEjACGgRvjJ6DgvGfVExAxAhiGAz9WLzDgtS7qBYga AQwED4eL343D1AsQNQIYCE4FjN2sE/6hnoCoEcBAcDlc7P50pnoBIkcAQ8GpgDEr 7jNGPQGRI4Ch6Py6ekHg3j5+lXoCIkcAg7GygXpB2K6/Qb0A0SOAweAwSKy+/z2H QAJEAMNRnqleELKHL1AvQAwIYDh4QnqMlpz5hnoCYkAAw8GZMDEad4p6AeJAAAPC mTCxKb7sIfUExIEABoQLgmPzZmf1AsSCAIbkm/bqBYEq6cfTMMNEAENywovqBYGa 1IWToMNEAIOyLE+9IEgVN3ASdKAIYFAufFC9IEhTjl+knoB4EMCwLG+kXhCgipu4 EWCoCGBY+AgYAz4AhosABoZbIkRv+LXqBYgLAQwMHwEjN7UrHwCDRQBDw0fAqP3h avUCxIYAhoZzASM2+RjOAQwXAQzOghbqBUEpH3qLegLiQwCD02GqekFQJnaqUE9A fAhgeLgpTIRKBtyrnoAYEcDwtJ6jXhCQV7uqFyBOBDBA73RULwhG4aVj1RMQJwIY ovzG6gWBSN05UD0BsSKAIeJs6IhMP26hegJiRQCDxKkwkSi//mb1BMSLAAbppHHq BUH4sPNy9QTEiwCG6bvd1AsCUHr1KPUExIwAhunIieoFAfhbpxL1BMSMAAbqvcPV C7xX1J9jScEjgIHa6yv1Au+91kW9ALEjgKF6rrt6geeW9+K+OuEjgKFqvDBbPcFv z56qXoD4EcBg3dFfvcBr87tNUU9A/AhgsDKX7Kye4LGK+/uoJyABBDBc3V5QL/DY lE4r1ROQAAIYsHd/o17gLU6BMYIABqztrEz1BF+9crx6ARJBAEN21+XqBZ5a2O0D 9QQkggAGjbvC1Ejq7ivUE5AMAhi0gz5SL/DSO0fxICQjCGDYxvZSL/DQ0jNeV09A Qghg2LIWcXf8dFX88WL1BCSFAAbuUL7NT9ekTmXqCUgKAQzd/XycSc+Sk99WT0Bi CGDw5rRWL/BK+V08CM4QAhi8n/yH06HTMOEY9QIkiACGb+Bt6gUe+aHTZ+oJSBAB NODNo9ULvFF41Wj1BCSJABpQd0GeeoIvHjtHvQCJIoAWdJjCn3O1TDoqpZ6ARPHG MGHQSPUCL8zp9Kl6ApJFAG14oZt6gQcK+o1RT0DCCKANmbM5G3BHyu/tp56ApBFA I9rMqKue4LqX+JRsDwG04ohJnA+9XZOPKlFPQOIIoBkXPaBe4LZ7ryxST0DiCKAd 916qXuCyiactUk9A8gigIRM6qRe464fO/1ZPgAABNCRrVhv1BFet6vaWegIUCKAl LWbWV09wU+q8x9QTIEEATTlwepZ6gpOuG85TkGwigLac8KJ6gYvuu4IzYIwigMb0 vUe9wD3P9F6pngARAmjNrVeqF7hmwpmcAGMWATTnqTPUC9wy7aTv1RMgQwDt+etR 6gUumd91unoCdAigPVlf76Ge4I6CU15TT4AQATSo4cxm6gmuKD3vSfUEKBFAi1rO aKCe4IbUZfepJ0CKAJq0z7+4O2CliuuGqydAiwDadNAULgnJyLhtMM9AMo4AGtX5 Ve6P+lBfLgCxjgBa1fNx9QK1Z84vUE+AGgE0a+Bt6gVar/bMV0+AHAG0y/ZFce+e Plc9AXoE0LCHz1cv0Pno5O/UE+AAAmjZvFbqBSolZ45XT4ALCKBpM3dXL9AoPPcZ 9QQ4gQCalvn1nuoJCvQP6xBA23JmtFVPSF7xxWPVE+AIAmhc3gxzN0YoG8BdsbEO AbSu5TcN1ROSlRp2s3oCnEEAzdvj83rqCUmqGHG1egLcQQCx/z/qqCck6O5+6gVw CAFExsHv27k1zCMXlaknwCEEEBkZnd6wcmuYp88tVk+ASwggKp38rHpBMl46iycA Y1MEEKv1fki9IAlvns4NYFAFAcQaV41QL4jf5JPmqyfAMQQQa+z1lXpB/Mb0Vi+A awgg1hgwSr0gfu+fzC0AURUBxBpTO6gXxK/wHCPHelBtBBCrtf9GvSAJj52jXgDH EECs9tej1AuSsPSM19UT4BYCiEpHTlQvSMZzp5eqJ8ApBBAZGVkLm6gnJKP8qtvV E+AUAoiMjJe7qhckZdHJk9QT4BICiIxBI9ULkvPOqQvVE+AQAoguL1v6W/DsOYXq CXCHpb/62Kpfv2vnZlirjbmYG2JhPQJoXYfJlm6Hutr9fVPqCXAFATTuiInW+peR 8eBlnAyDtQigbd3G2/r5d60nL1qlngA3EEDTBt6mXqDxWq9F6glwAgG0bGwv9QKV 6b3/qZ4AFxBAuxr+9WD1BJ0V549TT4ADCKBZB09soJ6glBo5lNNhQACtun6o9T/7 1y7+Xj0BatbfBFY1fvlw9QS9/HNfUk+AGAE06bSxddUTXFDx0OCl6g2QIoAG1R93 nHqCK344i7vDmEYA7TnroXrqCe5I/fFqPgQaRgCtaTL+SPUEt8w/e4J6AmQIoDFD r8tWT3DOuMt4YLpVBNCUQ59rrZ7golXXPFCs3gAJAmhI3lNmbn2frm/P/FA9AQoE 0I5h19i781X1/bnfAvUEJI8AWnH8o83UE9xWNPwObpJlDgG0Ye/HDlVPcN/Ci1+o UG9AsgigBXmP9FBP8MPkiz9VT0CiCGD4sm6/lFNfquuFPnPVE5AgAhi8Qdfnqif4 pOxhLg0xhAAG7uQHmqon+Kbw5jt5dLAVBDBonca0U0/w0dLBj3FitA0EMGC/uP9X 6gm+mn/Z8+XqDUgAAQzWfg9yz9NamHXRBJ6fHj4CGKi9H+CmL7U0vf+HnBYYOgIY pPYPdFJPCMHUfh+RwLARwADt9sdj1BNC8UHfT0hgyAhgcNrfR/4iNLn/xyQwXAQw MHvff5R6QmimXP5/JDBUBDAo+93bUT0hRNP6TyWBYSKAATnwbk58icn0Qe9xUkyI CGAwDru9g3pCyGb1fY1To8NDAAPRZfQe6gmhmztgHAkMDQEMQs8/tFFPsGDh0IdJ YFgIYAAGXM0dXxKybNQfSGBICKDvsm68vIF6gyWF91/DnWLCQQD9Vn/UeTnqDdaU Pj5guXoDIkIAfdZydPcs9QaLUi/25cb5YSCA/tr3rqPVE+ya2I/HJ4WAAPrq8BE8 6FJqyuD31BNQawTQT2fdsqt6An4Y8qR6AmqJAHoo88qrmqg3YLX8EaO4Qs5rBNA7 df9wEc+5dEbh/UNK1RtQcwTQMy3uPIWnnDul7Ol++eoNqCkC6JV97zyaPzHnpF7v /7V6A2qGt5NHOg4/RD0BWzd5yAfqCagJAuiNC6/fRT0B2zb7mifUE5A+AuiHrBsu a6TegO1bOmq4egLSRQB90HjUWVzx64GiMYMK1RuQFgLovj3u6pqp3oDqKR/fb756 A9JAAF3X4dYj1BOQhoq3BnCVsD8IoNtOG7GbegLSNWXoRPUEVBMBdFjmoEFc8ual edf/UT0B1UIAnVV/5Pn11BtQUyvuvIGrhD1AAB3V6h7udeq3krEDV6o3YEcIoJP2 v+so9QTUWvmLV3yv3oDtI4AOOnI4jzgPxMQrP1FPwPYQQOf0vpFL3gIybdgE9QRs GwF0S+Z1V+SpNyBa864bo56AbSGALskd2ZsDvwFaOmKkegK2jgC6o8k9p3Kv00Ct um9IuXoDtoIAumK3e4/jit+AlYwdxOPU3UMA3XDAXb9VT0DMysb350YJriGALjj8 1oPVE5CA1CsDuXe+Wwig3km3t1NPQEIq3ubEQKcQQLVeI1qpJyBJ7101VT0BGxBA rUtvbKqegKRNHfKuegLWIYBKg4dw1rNJ317xknoC1iCAMplDBjdUb4DKzCteVE9A BgGUybx2UAP1BijN6kcC9QigROYNA3LVG6A2+4rx6gnmEUCFa4bw6Q+VZvZ9VT3B OAKYvIHD+O4P63x05XvqCaYRwKRd8geO/GITH/Sfrp5gGAFM1kn3tVBPgGMq3ur7 lXqDWQQwSUc+ylN+saXUC5fNVW8wigAmZ98xh6knwFGlY/uvUm8wiQAmpdnYruoJ cNiqkTeqJ1hEAJORdc+FPOYX27Xw8j+rJ9hDABNx6W2c94wd+qAP98pKGAFMwKHj 2qonwAupZ/rkqzfYQgBjl/fE79UT4I2C60epJ5hCAON21U111BPgk+kX/109wRAC GK+fvcrt7pGe8sf6Fqo3mEEA45T5YG/1BHho0SXcJiYhBDBGv365iXoCvJR64Twe IpwIAhifh89XL4C3Fl3A7VKTQADj8uN3d1FPgMfKH72wQr3BAAIYk753cuUHamVK ry/VE8JHAGOR9dwJ6gnw3op+j6onBI8AxqHN3/nxF7VXfv9l6gmhI4AxOOKtuuoJ CMNLpxarJ4SNAEav1yOZ6gkIxeQTF6knBI0ARm7QSPUCBGR6zy/UE0JGAKN27U3q BQjKt10/VU8IGAGM2FUj1AsQmOknzlZPCBcBjNZpT6sXIDjvdluqnhAsAhipX3zE 8Q9E7qUTuSgkJgQwSrnzG6knIEAVd12hnhAqAhilvx6lXoAgFVzAVyvxIIAROvcR 9QIE6v3fL1FPCBMBjE6dZTz6DTG5u596QZgIYHQevFC9AMGad+IU9YQgEcDI1Cng 6UeIzYMXqxcEiQBGZvjV6gUI2MwuXBASAwIYmUXN1AsQsPIht6knhIgARmWvr9QL ELSXuqkXhIgARuWWIeoFCNr33XhgevQIYFQ+OFS9AEErvOgJ9YQAEcCoLMtTL0DQ Utfdop4QIAIYlTKeAodY3TZIvSBABDAidYvUCxC4hzjRPnoEMCKt5qkXIHCP91Iv CBABjAifABGzMb3VCwJEAKPCLSsRr/svVS8IEAGMCgdBEC8OgsSAAEZlYXP1AgSt /Krb1RMCRACj8upx6gUI2rKz/6KeECACGJW+96gXIGjTTpyjnhAgAhiVhst4IBxi xDGQOBDAyLzTUb0AASvo/Wf1hBARwMh0mqBegIBNPL5QPSFEBDA6P7RRL0Cwygbe rZ4QJAIYnd+8q16AYL3x+1L1hCARwAi90kW9AIFa1usl9YQwEcAI5c7jnoCIQ8Vd V6gnBIoARunA/+NUGMTghR5cah4PAhipUzlVAdF758Rl6gmhIoDROv9h9QIE570e C9UTgkUAI3bC+Gz1BITljVOXqyeEiwBGbf8PdlZPQEBSY3vz/V98CGDk6j7H2TCI yvIBY9QTgkYAY3DymEbqCQhCxV8umaveEDYCGIfMO/pwf2jU2swL31JPCB0BjEfe 6DNIIGpl7lVPqieEjwDGpf4tveurN8BbFVNvekO9wQICGKOTBnRQT4CXCscN/0q9 wQYCGKvGV5/BPbKQntJJo19VbzCDAMat2SVdfskVwqimVW8/8kpKPcIQApiAzON6 dmymHgHnlf3jjWc/U48whgAmJPfE449oySdBbEPxx++9NFU9wiACmKSDOx9+YGP1 CDimbMFHE16fpV5hFAFMWuZBRx7y/5rnqGfAARWrPvvntIkz1TMsI4AaDQ/r8Muf teBEQatSKz779D/vf1Ku3mEeAZTa56ADfvqT5g24aMSM0uVffv3VJ//HFb6OIIAu aHjAAe3b7bl3oxz+OAKVKl725YxZX/7ry2L1ElTBO84pTfb7cfu2u7fPq1+HA8YB SJUULJsx8/tvPvtqpXoKto4AOiq3/d67t2rRbJc9GtSrwx+SR1KlRStnzl2yYN53 /53Jo3ydx3vLA3Xa7tGmbfPmjVu2a1AvJ5vPho5JlRUXFXy/IH/xwtlzZs7huIZX CKB/mrRu1bJ508aNGzZs1rZeTk52Fn+ICaooLyspKfph8cqVS5cuWbRg/tx89SLU Au+dEDRu3qxp0yaNGzZqWL9es9Z169apk5XFB8VaS5Wvid3c/MJVBcsre7d4yeJF 5C4sBDBcDZs3btw4L69hg9zc3Hr16jVulZNTJzs7Vz3LPaXFZaWlJfOWFhcVFRat KihYvnzp0mWLlnNPAgMIoDW5jfIqPyk2atCgfr3KLNatm1M3J+8Q9ajk5P97ZXFJ ZenWtG7lijVWkTqzCCAy7r5MvSA5M3r8Qz0BDiGAMBXAmScSQGxEAJHxxwvUC5Iz u8c09QQ4hAAiY8RV6gXJ+fi0L9UT4BACiIzXO6sXJGfxKW+rJ8AhBBAZs9qpFySn +Jw/qyfAIQQQGassnRvY7271AjiEACLT1OWrNw5TL4BDCCB+burEkDEXVKgnwB0E EJffpV6QpEmnLFRPgDsIIB45V70gSXO68/RJbEAAMeVg9YIkFZz5knoC3EEAsbyR ekGSUpc+qJ4AdxBA82wdBM7IGHqTegHcQQDNO3iKekGyHr3AWPGxHQTQvKuHqxck a/Kpc9QT4AwCaN4rXdQLkrXw5HfVE+AMAmjenNbqBckqOedp9QQ4gwCaV5qtXpCw K0epF8AZBNC6vc3dH+/evuoFcAYBtK7fneoFSXvnVC6GwzoE0LqXfq9ekLT5J01W T4ArCKB1c3dRL0gaR0GwAQG0rjxTvSBxV92qXgBXEEDjDvlQvSB5Yy7iWhCsRQCN G361ekHyXu2qXgBXEEDj3jtcvSB5S5qpF8AVBNA4Uw9EWq/RSvUCOIIA2tZ2tnqB wsnj1QvgCAJo28Db1AsUxp2iXgBHEEDb/nqUeoHCwpbqBXAEAbRtZQP1Agm+BMRa BNC03b5TL9A4+wn1AriBAJo29Ab1Ao03jlUvgBsIoGm2noi50SqbP/ljCwTQNHM3 Q13vJ1+oF8AJBNCyo/6qXqBydz/1AjiBAFo2vod6gcrsduoFcAIBtGxZnnqBSkXj 5eoJcAEBNKz9N+oFOhc/qF4AFxBAw+69VL1A58PD1AvgAgJo2LxW6gU6qYaF6glw AAG0y+adYNa78CH1AjiAANo1uo96gRI/AyODAFo23/Q9UVLN89UToEcAzdrnv+oF Wjdfp14APQJo1p9OVy/Qmm/ugcjYEgE0q6C+eoHYz/6tXgA5AmhV15fVC9S4MT4I oFmTf61eoFaay/PRzSOARrVYoF6gN/B29QKoEUCjHuqtXqDHYRAQQJsyC+qpJzjg t5PUCyBGAG3qf4d6gQve7aheADECaJPl+yBsVLHXDPUEaBFAk45+U73ADS+eqF4A LQJo0tc/Ui9wQ2rXueoJkCKAFnWYql7gimdOUy+AFAG06MND1AtcUd52vnoClAig Qb+erF7gjufNPhgPqxFAg/gGcKPU3hwItowA2tP5dfUCl0w4Rr0AQgTQnjmt1Qtc UtHxb+oJ0CGA5lxyn3qBW2bwhYBhBNCazOUN1BMc03uMegFkCKA19/RVL3DN8iYp 9QSoEEBjWs/OVE9wzhhuDWYWATRm0v+qF7in/KdfqCdAhADactI49QIXTf+VegFE CKApdfI5ArI11w5XL4AGATTF+rOAt6Vodx6RYhMBtISLgLdl8hHqBZAggIZkLWqs nuAsfgi2iQAawg/A21a8HzdFsIgA2sFNELbn2/bqBRAggGY0XJCrnuC0hy5UL0Dy CKAZ7/AMyO1KdXtZPQGJI4BWXHuTeoHrVuyer56ApBFAIzpM4Y96R6Ycql6ApPGu sKH+/IbqCR547Bz1AiSMANrw3uHqBT5IXfSwegKSRQBNGN1HvcAPRYd8op6ARBFA C057Wr3AFwt3L1RPQJIIoAH7/zNLPcEbH/xavQBJIoDhy5vdSD3BI+NOUS9Agghg 8DK/4iKvNFTc0089AckhgMF7vbN6gV/KB96lnoDEEMDQPXy+eoFvSk7imjgzCGDg rrlZvcA/Bb/mZBgrCGDYznhKvcBHSw6Yo56AZBDAoHWcyFOAa2LevsvUE5AIAhiy X0zNVk/w1Kz25eoJSAIBDNg+/6qrnuCtaQerFyAJBDBcbb6qr57gMZ4TZwIBDFaT b3dWT/DaW0erFyB+BDBUeV+3UE/w3IRj1AsQOwIYqLyvWqoneO+1LuoFiBsBDFP9 r9qoJwSAAgaPAAaJ/kXjpW7qBYgXAQxRvf/upp4QCAoYOAIYoPqf07+o8FNw2Ahg ePj5N0pvHKtegBgRwODkfdFaPSEonA8YMgIYGs5/idrE36kXIDYEMDBNvmyunhCc Sb9VL0BcCGBYWnzRVD0hQFwXHCwCGJRdPm+snhCkDw9TL0A8CGBI2nzBAzDj8VEH 9QLEggAGZLfPGqgnBGvG3in1BMSAAIZjr3/lqicEbOZPitQTED0CGIz9p9O/OM36 MQUMDwEMxf5/5/738fphv+XqCYgaAQzEz6flqCcEb85P89UTEDECGIaD3qd/8Zu/ /2L1BESLAAahw+Q66gkmUMDQEMAQ0L+kUMDAEMAA0L/kUMCwEED/0b8kzdt7pXoC okMAvffTj+lfkr7fg2tCwkEAfdf+03rqCcZM/5V6ASJDAD23y1cN1RPM4e5Y4SCA fmvyTRP1BIO4R3QwCKDXcr9tpZ5g0gvd1QsQDQLos52mHaSeYNToy9QLEAkC6LNX eGitSGrAXeoJiAIB9Nh9l6gX2FV64qvqCYgAAfTXwNvUCywr/NV/1BNQewTQW91e UC+wbUmbYvUE1BoB9NU+n2arJxjHo+ICQAA9VXcuJwCqPXG2egFqiwB66p2O6gVI 9XpSPQG1RAD9dNO16gXIyCj68Sz1BNQOAfTSEX9TL8BqM/dUL0DtEEAf1V3EHRDc 8ACnYvqNAPro1ePUC7BW6qhJ6gmoDQLoofMfVi/AeotaqBegNgigf/IW8ghMdzx6 nnoBaoEA+mdCJ/UCbJQ6eLp6AmqOAHrnpHHqBdjUrN3VC1BzBNA3WfmN1BNQxTW3 qBegxgigb/54gXoBqipqWqiegJoigJ5pOytTPQGbeeos9QLUFAH0zMQj1QuwudSP v1ZPQA0RQL90fEe9AFuacIx6AWqIAPplBhefOqhivy/UE1AzBNArnSaoF2Br3jpa vQA1QwC9wgdAN/ER0FcE0Cd8AHQVHwE9RQB9wgdAV1Xsw4FgLxFAjxw8Rb0A2/Ls qeoFqAkC6BHOAXRXWf1S9QTUAAH0R7OF/Gm56+br1AtQA7yl/DGGO885bCmPKfUR AfRGZkE99QRsx/GvqBcgfQTQG/3uVC/A9kz6rXoB0kcAvcE5MG5L1S9WT0DaCKAv mi1SL8D2DR6pXoC0EUBf3NFfvQDb981e6gVIGwH0xfyW6gXYgZYL1QuQLgLoib2+ Ui/Ajoy6Ur0A6SKAnhjbS70AO8Lz4fxDAD2xsLl6AXakouEq9QSkiQD6ocUC9QLs 2HmPqhcgTQTQD4P/oF6AHZv4O/UCpIkA+uHDQ9QLsGMlddULkCYC6IXMkiz1BFTD odyx0TME0AvHvqZegOq49Sr1AqSHAHrh8Z7qBaiOaQerFyA9BNAL3++qXoDqKM1R L0B6CKAPMksz1RNQLQd+ol6AtBBAH/zvJPUCVM+Nw9QLkBYC6IM7+6kXoHq4K6pn CKAPOAvQF8saqxcgLQTQBwX11QtQTdnl6gVIBwH0QC7X2HvjN++pFyAdBNADXXje mDc4CuIXAuiB2waqF6C63jpavQDpIIAeePc36gWornmt1QuQDgLogUXN1AtQXdwQ xi8E0AOl2eoFqLYGHLHyCQF0X5Ml6gWovo7vqhcgDQTQfRwE9smQEeoFSAMBdN+w 69ULUH2PnqdegDQQQPc9eaZ6AarvPQ7Z+4QAuu+DQ9ULUH2cB+MVAui+BS3UC1B9 hVy37RMC6L4iTi3zSAX3rvUJAXRfhXoA0tFyoXoBqo8AOq/tbPUCpINHY/qEADqv 4zvqBUhHzyfVC1B9BNB55z6iXoB0XDtcvQDVRwCdx3nQfrnncvUCVB8BjF6dvZvt 33rJ3HnzFuenIvjl7rskgl8EiXnmtKh+paxmzVu1bt1w1ueLZkTxFwlbQQAjlPvL zu322HP1s7Eb11n3H6VSpYWrvpu3ePGC+XPnLV5SkwdGjO8R4UTEbvIRNf2/zGra bJc2rVo2b7rLbg3q1cla/94sXpqZkVE4Y8ZXr33GA0eiRgCjsX/Hw3/Zpt6O/7mK 8tKiglnzlixaNHfu/EX5pdX4pd8/rNbrkKBv21f3n1wdvNa7tGjWbJfd6+duDN52 rPjnx9P+9kNt1qEqAlhrjY89/teta3r2a2UQl3/57Zw5s+d9v6ykZKtn/M3cvRbj kLj5u2z7v8vJyWvXsm3bNnv+eOe6mTX9O1Py8fuvv1+d/9eJHSOAtZLV/cz/bVT7 XyZVXlzw7ew5//x61vKi0rI1GdxpQwy5Es4vy3eu8m/X/UFm16mb2+Tn/9Ou3Y8a 1Muu/cUiqfmvPjy91r8KCGAttO/TbbdIr3sqWPTdrHlzfpg3a2Uqu2TZ+gIuj6Cw SE5RbpV/2zA3lZHTZO9d27Ru0Wqfnbfxf1MjxZOffn55lL+gRQSwhnIH9W4bwy9b kSotXDZzfnH2ohWlywtWrFi+fOWnOTH8PohN+eoHGNTNa5mXl9ew4c51GrTMyGq0 y571c2r8I+92lL1zx4Tof1VLCGCNdO9zRKzXvKcy1vzyqZLCgtkHx/kbIXp96uQ1 a9Zmj0b1c9Y8yyWVsVOc77KC8bd9FuMvHzoCmL6s6y/LU2+AuyoSflOlPhg2Kdnf MSAEMG239q3G6S5AgqYPeVs9wVMEME2Dh+bu+B8CEja5/9/VE7xEANNy5FPbOckL 0Cl7pt9i9QYPEcB0PHOKegGwLUv6cSOutBHA6jviL43VE4BtS407t1C9wTcEsNoG 35ylngBs15Ten6oneIYAVtdjZ6sXADuypM+f1RP8QgCrqdU89QJgx0p6UcB0EMDq +c276gVAtdzbV73AJwSwWi65T70AqKZJnYvVE/xBAKuDu9LDI/mH/Fc9wRsEcMfq PHOiegKQhrIj31NP8AUB3KE6z3ZTTwDSQgGriwDuCJ//4B8KWE0EcAfoH3xEAauH AO7A05E95RVIUNnPuSikGgjgdjV9rAuvELxUfMET6gke4O29XWN7qRcANZSqW6ae 4D4CuD2Dbq6jngDU1CyeKL1DBHA79n9lT/UEoOZuvk69wHkEcDvG91AvAGpjz5nq Ba4jgNs2dCg3AITXFrZUL3AdAdymA17eQz0BqJ0RQ9QLHEcAt+m57uoFQC1V7P+5 eoLbCOC2XD4qWz0BqK25bdQL3EYAt6HJXw5XTwBq77xH1QucRgC34R7uq4sQlNZL qSe4jABu3SHPt1ZPAKLw8AXqBS4jgFv31BnqBUA0muarFziMAG5VrwfqqScA0Zh6 iHqBwwjgVnEKDMKx99fqBe4igFszcATXgCAYi5urF7iLAG5Fg5eOUk8AotPjefUC ZxHArRh+tXoBEKGSXE6F2QYCuKV2zx+kngBEiftibQsB3NLoPuoFQKTK6pWrJziK AG6Bu8AgOLcNUi9wFAHcwg1D1QuAiBXX51vArSKAm2v5wmHqCUDU+t+lXuAmAri5 i+7hQUgIzux26gVuIoCb40EgCBGXg2wVAdzMEeNaqScA0Xuyp3qBkwjgZh47W70A iANv9a3hVamq6xON1ROAOLxxrHqBiwhgVUOv5xVBkIpy1QtcxNu9Kq4CQah4r28F L0pVfzpdvQCIR5Ol6gUOIoBVnPJIA/UEIB7v/Ua9wEEEsIph16sXADEp5jEPWyKA Vdx9mXoBEBfe7FviNaniyTPVC4C4NFqpXuAeAripzk81VU8A4vKXE9QL3EMANzVw ZKZ6AhCXpU3UC9xDADd120D1AiA2Ffy/9y0QwE1xGjRCxrt9C7wkm+JWWAjZnjPV C5xDADdx0qMN1ROA+Ez6rXqBcwjgJq69kZcDASusr17gHN7xm7j9CvUCIEYcBdkC AdwEx0AQNt7um+MV2QTXgSBsOy9XL3ANAdyo65M7qycAcZpwjHqBawjgRlffzKuB oK3ibm+b4S2/EdeBIHAcBdkcAdyIYyAIHe/3zfCCbDS2l3oBEK+slHqBYwjgBgc/ 30Y9AYjXo+epFziGAG5wwegc9QQgXrPbqRc4hgBuwPNAELySuuoFjiGAG3AhHMLH G74qXo8NOAiM8HEUpCoCuF72C13VE4C4HTpFvcAtBHC9bo83Uk8A4vb2UeoFbiGA 6w24lbPkEbxljdUL3EIA17tliHoBELtUlnqBWwjgenddrl4AxI93fBW8HOtxIRws +NEM9QKnEMB1Wj53uHoCEL+Bt6sXOIUArtPrgXrqCUD8ZvxIvcApBHAd7oYKE3gy XBW869e59Ur1AiAB3BO1CgK4Dp8AYQKfAKvgXb/OyEHqBUAC+ARYBQFc5+7L1AuA JPCW3xSvxjpjuFUuTOAtvylejbUOfHF39QQgCbdepV7gEgK4VpcnuUgcJrzZWb3A JQRwrfPv44EgMIHHgmyKAK7FWTAwoihXvcAlvO3XGjVAvQBIBu/5TfBirMVZMLCC 9/wmeDHWevh89QIgGbznN8GLscbPX9xDPQFIxgjufb4RAVzj6KebqicAyXj2VPUC hxDANc56iLsBwojpv1IvcAgBXKP/KC4RhxE8GG4TBHCNm65VLwASUp6tXuAQArgG j4SDHbzpN+K1WIPTAGEHb/qNeC1Waz3+MPUEICn971IvcAcBXO3g59uoJwBJuf9S 9QJ3EMDVfv9EnnoCkJSJv1MvcAcBXO3cB7gZFszghlgbEcDVrhzJ6wAzChqqF7iD N/5qt3B1JOxIZakXuIMArsZpgLCEd/0GvBSrEUBYwrt+A16KSq3GH66eACTnstHq Bc4ggJU6PLeregKQnHv4iWc9ApjBMzFhzIRj1AucQQArXXBvHfUEIDnzWqsXOIMA ZvBMTBjDkzE34J1facRV6gVAgiq4/e96BLDSnf3UC4Ak8bZfj1cig9MAYQ1v+/V4 JSo91Fu9AEgSb/v1eCUyMv7npT3UE4Ak8Wjg9QggdwOEOW8fpV7gCgKYkXHRaB6T BVMWtFIvcAUBzMi4erh6AZCo4nrqBa4ggNwNEOZwIuB6BDAjY9QA9QIgWbzv1+GF 4Dxo2MP7fh1eiIyM269QLwCSxft+HV4IPgHCHt736/BCZLQdf4h6ApCsISPUCxxB ADOOGMdJUTBm7LnqBY4ggBmnPFpfPQFI1pRD1QscQQAz+t7JY1JhTH5T9QJHEMCM G4aqFwAJK+fqz7UIIGfBwCDe+GvxOnAWDAzijb8Wr0O78R3UE4CkXXezeoEbCGDH Z1uoJwBJe7KneoEbCGDGEb1/tG8eB4JhRlH+p5/yvc9aBHCd/Xrstc++jbhLEAJW kv/pZ58+qF7hFAJY1QE92u/zYzqIsJTkf/bpF/epV7iIAG7VASf+qLKD/FwMzxXl f/b5Zw+oVziMAG7XUWe133fnOuoVQJoqVi3+/FNu9LtjBLA6jjhpn/2a5vJawXll K/771Tc3qFf4gzd1Gn5x/O4/2jcvRz0D2EJq1ZIvvviSr/nSRQBr4JDj2+21dyN+ MoZeqij/i//OuF09w1sEsBYO6dp2z312rstriMSVFeT/96sZd6pneI83bxQ6Hdd6 970a1uHFRMzKi5Z++e13N6pnhIP3bKQ6H9tyt70a8pkQ0SotXPr1zNnD1DMCxFs1 HocftUvLtu0bkELUXGnRsm+/mzvrXvWOkPEGjdvhR7Tcpd2ejepyB0pUR6pk1bJv Zs2d9ZB6iA0EMEFHHtG8eZs9GuXyZSGqKisu+G7O4oU/jFYPMYe3okinw5o2b71H w/o5XG9nU6q0qOC7eYsXzbtbvcQ0AuiCLh0aN22zW4P6dbO5DUO4KspKCwu+n7t0 8UJO23MGAXRPl583bpLXql2DejnZfDz0Waq8pHjV9wuWL1uyiJ9tHUUA3df9Zzvn NWrZtn69unWy+ITororyspKiwtmLVixfmj9KPQbVQwB9dMp+DXZu2KBZm3p1cyqb yJ+hQKqydiVFcxavWrFixVJy5y3ePAE4Ze8GDRvWr5fbuHXdOnWyK4vIn2rEKip7 Vxm84rlLigoLKpN3l3oQIsJbJWBn7Va/Xv3c3Lp1G++Sk5NdJysrk0+L21GRSqXK Vndu3rLi4qJVhYUFBVxrGzreEEad3rpebuX/5NTNycnJa5mTnV35yTFrp5A/PFZU VBauvHz1R7n5K0oqP84VlxQVVlaO+yVbFu7fd9TWWU0rPzzWyamXXSenTnZ2TnaD lnUys7IzM7N3qvwkWVlKF/7uVKztWkX56rSVl5UuWllSVlZaUlpaUlxaUli0iusp sF0u/CVGGC6uWy8rJyMzK6vyL1XW6jMaM9ef1pja8M9sOIqd2vw/2IpUWWr1v5Sv PsBansooKS8q53QSRIoAAjCLAAIwiwACMIsAAjCLAAIwiwACMIsAAjCLAAIwiwAC MIsAAjCLAAIwiwACMIsAAjCLAAIwiwACMIsAAjCLAAIwiwACMIsAAjCLAAIwiwAC MIsAAjCLAAIwiwACMIsAAjCLAAIwiwACMIsAAjCLAAIwiwACMIsAAjCLAAIwiwAC MIsAAjCLAAIwiwACMIsAAjCLAAIwiwACMIsAAjCLAAIwiwACMIsAAjCLAAIwiwAC MIsAAjCLAAIwiwACMIsAAjCLAAIwiwACMIsAAjCLAAIwiwACMIsAAjCLAAIwiwAC MIsAAjCLAAIwiwACMIsAAjCLAAIwiwACMIsAAjCLAAIwiwACMIsAAjCLAAIwiwAC MIsAAjCLAAIwiwACMIsAAjCLAAIwiwACMIsAAjCLAAIwiwACMIsAAjCLAAIwiwAC MIsAAjCLAAIwiwACMIsAAjCLAAIwiwACMIsAAjCLAAIwiwACMIsAAjCLAAIwiwAC MIsAAjCLAAIwiwACMIsAAjCLAAIwiwACMIsAAjCLAAIwiwACMIsAAjCLAAIwiwAC MIsAAjCLAAIwiwACMIsAAjCLAAIwiwACMIsAAjCLAAIwiwACMIsAAjCLAAIwiwAC MIsAAjCLAAIwiwACMIsAAjCLAAIwiwACMOv/A4mbFKbCN8B7AAAAAElFTkSuQmCC"/></symbol><g mask="url(#b)"><g transform="rotate(.193) scale(.36014)"><symbol id="c" viewBox="0 0 1280 1280"><image width="1280" height="1280" xlink:href="data:image/png;base64, iVBORw0KGgoAAAANSUhEUgAABQAAAAUACAIAAACXhmigAAAACXBIWXMAAA7EAAAO xAGVKw4bAADLWUlEQVR4nOzdeZCc5WHgf10MSMg2cTQjzYi/FhBH7AKcMv/Yv6o4 v98u5dQ6VdmqlMvBSVWc/WurnD3idZKtWlflIs4mYIOFQQIkAcYCDNg4OizAmGCw LXEKYsfm0mgOzdEzfcxMd09PX79XGq9CQEf3qJ+3u+f9fMpF6eh+3idkpujvvM/7 PCtXAAAAQAKsbPcEAAAAIA4CGAAAgEQQwAAAACSCAAYAACARBDAAAACJIIABAABI BAEMAABAIghgAAAAEkEAAwAAkAgCGAAAgEQQwAAAACSCAAYAACARBDAAAACJIIAB AABIBAEMAABAIghgAAAAEkEAAwAAkAgCGAAAgEQQwAAAACSCAAYAACARBDAAAACJ IIABAABIBAEMAABAIghgAAAAEkEAAwAAkAgCGAAAgEQQwAAAACSCAAYAACARBDAA AACJIIABAABIBAEMAABAIghgAAAAEkEAAwAAkAgCGAAAgEQQwAAAACSCAAYAACAR BDAAAACJIIABAABIBAEMAABAIghgAAAAEkEAAwAAkAgCGAAAgEQQwAAAACSCAAYA ACARBDAAAACJIIABAABIBAEMAABAIghgAAAAEkEAAwAAkAgCGAAAgEQQwAAAACSC AAYAACARBDAAAACJIIABAABIBAEMAABAIghgAAAAEkEAAwAAkAgCGAAAgEQQwAAA ACSCAAYAACARBDAAAACJIIABAABIBAEMAABAIghgAAAAEkEAAwAAkAgCGAAAgEQQ wAAAACSCAAYAACARBDAAAACJIIABAABIBAEMAABAIghgAAAAEkEAAwAAkAgCGAAA gEQQwAAAACSCAAYAACARBDAAAACJIIABAABIBAEMAABAIghgAAAAEkEAAwAAkAgC GAAAgEQQwAAAACSCAAYAACARBDAAAACJIIABAABIBAEMAABAIghgAAAAEkEAAwAA kAgCGAAAgEQQwAAAACSCAAYAACARBDAAAACJIIABAABIBAEMAABAIghgAAAAEkEA AwAAkAgCGAAAgEQQwAAAACSCAAYAACARBDAAAACJIIABAABIBAEMAABAIghgAAAA EkEAAwAAkAgCGAAAgEQQwAAAACSCAAYAACARBDAAAACJIIABAABIBAEMAABAIghg AAAAEkEAAwAAkAgCGAAAgEQQwAAAACSCAAYAACARBDAAAACJIIABAABIBAEMAABA IghgAAAAEkEAAwAAkAgCGAAAgEQQwAAAACSCAAYAACARBDAAAACJIIABAABIBAEM AABAIghgAAAAEkEAAwAAkAgCGAAAgEQQwAAAACSCAAYAACARBDAAAACJIIABAABI BAEMAABAIghgAAAAEkEAAwAAkAgCGAAAgEQQwAAAACSCAAYAACARBDAAAACJIIAB AABIBAEMAABAIghgAAAAEkEAAwAAkAgCGAAAgEQQwAAAACSCAAYAACARBDAAAACJ IIABAABIBAEMAABAIghgAAAAEkEAAwAAkAgCGAAAgEQQwAAAACSCAAYAACARBDAA AACJIIABAABIBAEMAABAIghgAAAAEkEAAwAAkAgCGAAAgEQQwAAAACSCAAYAACAR BDAAAACJIIABAABIBAEMAABAIghgAAAAEkEAAwAAkAgCGAAAgEQQwAAAACSCAAYA ACARBDAAAACJIIABAABIBAEMAABAIghgAAAAEkEAAwAAkAgCGAAAgEQQwAAAACSC AAYAACARBDAAAACJIIABAABIBAEMAABAIghgAAAAEkEAAwAAkAgCGAAAgEQQwAAA ACSCAAYAACARBDAAAACJIIABAABIBAEMAABAIghgAAAAEkEAAwAAkAgCGAAAgEQQ wAAAACSCAAYAACARBDAAAACJIIABAABIBAEMAABAIghgAAAAEkEAAwAAkAgCGAAA gEQQwAAAACSCAAYAACARBDAAAACJIIABAABIBAEMAABAIghgAAAAEkEAAwAAkAgC GAAAgEQQwAAAACSCAAYAACARBDAAAACJIIABAABIBAEMAABAIghgAAAAEkEAAwAA kAgCGAAAgEQQwAAAACSCAAYAACARBDAAAACJIIABAABIBAEMAABAIghgAAAAEkEA AwAAkAgCGAAAgEQQwAAAACSCAAYAACARBDAAAACJIIABAABIBAEMAABAIghgAAAA EkEAAwAAkAgCGAAAgEQQwAAAACSCAAYAACARBDAAAACJIIABAABIBAEMAABAIghg AAAAEkEAAwAAkAgCGAAAgEQQwAAAACSCAAYAACARBDAAAACJIIABAABIBAEMAABA IghgAAAAEkEAAwAAkAgCGAAAgEQQwAAAACSCAAYAACARBDAAAACJIIABAABIBAEM AABAIghgAAAAEkEAAwAAkAgCGAAAgEQQwAAAACSCAAYAACARBDAAAACJIIABAABI BAEMAABAIghgAAAAEkEAAwAAkAgCGAAAgEQQwAAAACSCAAYAACARBDAAAACJIIAB AABIBAEMAABAIghgAAAAEkEAAwAAkAgCGAAAgEQQwAAAACSCAAYAACARBDAAAACJ IIABAABIBAEMAABAIghgAAAAEkEAAwAAkAgCGAAAgEQQwAAAACSCAAYAACARBDAA tFhvb+/Kd/wHduXx30T/q0dO/mH0y1Qq1YbJAUCCCWAAaE5fX++K41m7KsrYNWvW XHjhhdFvV61adcEFFyxhtKiKS6VSrVaLfp3P5yuVSjR2vX78t5OTChkAWkkAA8Cp bdiwYdWqlVHorlmzeu3atVHirlu3LuY5RHlcLBajPI7+GbVx9NtqtTY9PR3zNABg eRDAAPBLfX29i7l74YUXnn/++atXr273jE7hRANXS6WFQiFfqVSjNraUGgAaJIAB SK6oeM8777y1a9f2nNDu6SxRlMTlcjlK4vn5YvQLC6cB4HQEMAAJ0tvbu2rV8Xu8 73vf+5b2yG7ni3p4fn5+bm6uUqmcuD881e4ZAUCnEMAALHMno/cDH/hA997mXZoo hhcWFmZmZiqVamRqSgwDkGgCGIBlaMOGDatXR9G7JoHRezrviOHKiRi2kxYAiSOA AVg+ent7e3rOu/DCC+Pfrrm7LG4rXSgUFhbK9tACIDkEMABdb3EvKzd7l+DkbeHo n54WBmDZE8AAdKuNG/vWrFnzwQ9+sDPPK+ouUQlXKpVsNlsuVyYnJ9s9HQAIQgAD 0GUW7/fq3kBOlrDV0QAsPwIYgO6w+Hyvdc6xiUq4VCrNzs5aHQ3AsiGAAehoGzZs OP/8nmV8bG/ni0q4UCgWCnklDEC3E8AAdChLnTuKpdEALAMCGIDO4pZvhztxhNJ8 Pp8vl90QBqDLCGAAOsXiU75u+XaFer1eLpdzuZwbwgB0EQEMQPv19fWdd96aKIDb PRGaVq1W0+m0DAagKwhgANpp8+aBCy+8cN26de2eCOekVqvl8/lCoTg2NtbuuQDA aQlgANojSl9nGi0z9Xp9fn5+dnb22DEZDEAnEsAAxE36Lm8yGICOJYABiI/0TY4o g4vF+bk5GQxABxHAAMRB+ibTiQwuzs3NyWAAOoEABiAs6YsMBqBDCGAAQhkY6F+/ fr0dnllUrVanp9PlsgOTAGgbAQxA623atPH973+/9OW9arXa1NT0wkIp+me75wJA 4ghgAFqpt3dDT09Pb29vuydCR6tUKplMJp/PZ7O5ds8FgAQRwAC0zObNAx/84AdX r17d7om0U61Wa/zFq1atCjeTzjc/Pz8zM3vs2LF2TwSApBDAALTAwED/+9///gsu uKDdE4lPtVpd3NnrQx/68Pnn9/zar33oV3/1g9Fvb7jhs2d4Vy6Xi6pv8ddRKj/6 6KOrVq1MpzOvv/6LhYWF119/PfrzcrmcnB8iRP8S8vlCPp8fHx9v91wAWP4EMADn JCFrnuv1+rp167ZsufwjH/lIFLpnrtxTOrEF1HQ0ToMv/va3v53JpP/5n//5yJHB +fni8r5XvLgienTUrWAAwhLAACzdcl3zvHh390Mf+nCUu5dffvn1119/jgPOzMwU i8VznNLTTz/91ltvvfbaq2+88Wa1Wll+/9qjf0Wzs7OOSgIgHAEMwFIsv32e6/X6 li1bouj91Kc+de2117Zq2FqtNj093dSDwQ0Oe/jw4ccff/yNN14fGhpaNveHo85P p9Pz86XoX1q75wLAMiSAAWjasrnxG/2fEBXvv//3/99v/ub/29/f3/Lx5+bm8vl8 y4d9lyiGx8bGnnnmmeeee+7NN98IfbkYzM/Pz87OWhENQMsJYACa0N+/6QMf+EBX b3ZVrVavuOKKj3/8//nd3/3dENF70tTUVHStcOOfUhTDIyMje/b84/PPPx/9ont/ SLF453xhYSGVmmr3XABYPgQwAI3avHmgeze7Wrt27Uc+8ut/9Ed/1MLlzaeTz+fn 5uZCX+Wsovx+8cUXH3rooX/5l5/Fn+ItEQVwLpdzKxiAVhHAAJxd9z7xG3Xvb/zG Jz7/+c8Hvdn7Tm258XtmtVptaGho584dzz//Qq3WWXM7q8Wngt0KBqAlBDAAZ9GN T/zG372RQqEwOzsb2+WWICrhwcHBe+7Z1XUlXCwWZ2Zmx8ZsEA3AORHAAJzWpk0b 15/Q7ok0Kqr0//Afro+5exdNT09XKpWYL7pkUQkfOXJk586dzz///Mou+SzgrGAA zl2X/EcPgNgNDPRfdNFFPT097Z7I2VWr1Y985Nf/63/9rzE83/tepVIpm83Gf92W KJfLhw4duvfee95+++3Ov8lfr9cXn68eH59o91wA6EoCGIBT6Jb9rgYGBn7v937v hhs+264JZDKZhYWFdl29hQqF/H333bd3776FhVK753IWpVIpl5s5dsytYACaJoAB +De6Yr+r9t7yXVSpVNLpdL1eb9cEQiiXyz/5yU/uvfeewcHBTr4hvLgzluXQADRL AAPwr/r7N23YsKGTy2fxKd8bb7yxvdOYmZkpFovtnUNQUV7+/d///YsvvrBq1ap2 z+W05ubyc3OzlkMD0DgBDMAvdfiy57Vr1/7n//yfP/e5P2rvNOr1+tTUVK1Wa+80 4lEo5Hfs2LF3796OvdE9Pz8/MzNz7JjdoQFoiAAGYEVv74aenp6Ord+BgYG//uu/ aeNq55MWd2Bq9yziVi6Xn3jiidtv/3r0i3bP5RSiWWWzWcuhAWiEAAZIuk2bNl50 0UUXXHBBuydyCp2Tviu67aCjluvkDK7VatH/d0ql0tTUdLvnAkBHE8AAidaxD/12 VPp29UFHrRXV74EDB+644/YO/FnA3AkeCQbgDAQwQHJ15kO/HZW+kSh9owBu9yw6 y4kM/t4dd9zRaRlcLBZnZmbGxsbbPREAOpQABkioDqzfTkvfarU6PT3dsfs/tV2U wfv379+27Y7oX1S75/KvFhYWcrmcR4IBOCUBDJA4Hbjl1erVq//Lf/kvbd/h+Z3m 5uby+Xy7Z9EFZmZm7rzzzgMHDqxa1SkfKmyLBcDpdMp/qwCIR6dteVWtVj/72d// 4he/2O6J/BsJ3+9qCdLp9E033XTo0MEOeZ58cVssDQzAuwhggATpqPqN0vcjH/n1 Xbt2tXsi/8bCwkImk2n3LLrV0aNHv/Sl/z0+Pr5yZfs/YCw28Pz8/PR0ut1zAaBT tP+/TwDEo6M2fF67du0tt9z60Y9+tN0T+TdmZmaKxWK7Z9HdKpXKt7/97bvuurMT GjgyOzuXz9saGoBf6oj/OAEQWufUb7Va/W//7b911OO+i1KpVK1Wa/cslomZmZmv fe3Wp59+uhO+5DQwACcJYIDlr3M2fL766mv+9m//tr+/v90T+Tfm5+dzuVy7Z7Hc 1Ov1Q4cO/cM//P3s7Gy75+J4JAB+SQADLHMdUr9RDv3VX/31pz71qXZP5N0c8xtU VJ533nnnP/7jd9t+K1gDA7BCAAMsbx1Sv1dffU2nbXa1yLLneLz55ht/+qd/2vZj pTQwAAIYYNnqhPrt2Bu/lj3HLIrP7du37dmzp723gjUwQMIJYIDlqRPqt2Nv/Fr2 3C4///nP/9f/+l+FQjtvBRcKxdlZDQyQUAIYYBlqe/1Wq9W/+ZsbO/DG7wrLntut WCzedtvWAwcOtPFWcKFQmJmZHR/XwACJI4ABlpu21+/AwMBdd93daVs9R0qlUjab bfcsOO7xxx//6le/0safRGhggGQSwADLSnvrt1qt/sf/+Kkbb7yxXRM4g5mZmWKx 2O5Z8K9GR0f/+q//6u233165sj2fRjQwQAIJYIDlo73127H7XUWmpqaiOG/3LHi3 +fn52267bf/+fWvWrGnLBDQwQNIIYIBlor3127HLniuVyvT0dLtnwZl873vfu+WW r9br9bZcXQMDJIoABlgO2lu/n/zkb3Xmsud8Pj83N9fuWXB2w8PDf/VXfzk0NNSW q0dfJ9lsLpVKteXqAMRJAAN0vf7+TRs2bGjLnrqdvNtzJpNZWFho9yxoVKlU+j// 5++ee+65tlw9qt90Ol0szrfl6gDERgADdLc21m+9Xt+zZ+/FF18c/6XPyllHXeob 3/jGPffsasvX84kGztgpDWB5E8AAXWzTpo29vb1tqYWOfei3XC6n0+l2z4Kl27Nn z223bW3LI8FRA4+OHov/ugDERgADdKuofi+66KILLrgg/ktfffU1u3btiv+6Z+Wh 3+Xh1Vdf/dKX/vf8fNwLkmu12vR0enR0NObrAhAbAQzQra644vK21G/Hbnnlod/l ZGho6C//8i9GRkZivq4GBljeBDBAV2rLts+dvOWVh36Xn/n5+S9/+W9/8pOfxHzd hYWFXC5nLTTAsiSAAbqP+n2naGJTU1PtngVBtKuBi8X5mZmZsbGxmK8LQGgCGKDL tKV+O3bD5yiQcrlcu2dBWLt27bz//vtj3uwtny9ks1mHAwMsMwIYoJu05dCjjq3f ubm5fD7f7lkQh507d37zm3E3sIORAJYfAQzQNTZt2vjBD36wp6cnzot2bP3a8ipp 7r777gce2B1nA0df/FNTUx4GBlhOBDBA14h/2+e1a9c+9NC3OrB+oyypVqvtngVx 2717986dO1atWhXbFW0KDbDMCGCA7hD/o78DAwN79+6L84oNmpycrNfr7Z4F7bFn z55bb70lzga2KTTAciKAAbqA+l1kw2eyudyePf94z65dca6Fzufz2WzOhlgAy4AA Buh08W981Zn1WyqVstlsu2dBm5XL5dzMzHcfe2z37m/G+U0R1W8mky0UCrFdEYAQ BDBAR9u0aeNFF10U56O/nVm/UXjMzs62exZ0hGwuNz4+/sNnnnnooQdja+BqtZpO py2EBuh2Ahigo1166SXr16+P7XL1ev2VVw7HdrkGzczMOIqGk8rlctTAoyMjTzzx xIEDB9asiamBj183m9XAAF1NAAN0rpgf/e3ME48cd8R7RQF87Nix0vz8d7/72A9/ +MM1a9bEc91CoRA18OSkh4EBupUABuhQMT/625n1m06ny+Vyu2dBx4m+KjLZ7OjI SPTrxx577Nln42vgqH6jBvYwMECXEsAAnai3d8Ov/uqvxvbob2fWr8N+OYNsLjcy PLz485HHHvvOs88+G08DexgYoKsJYIBOFOfi5+gD/d/8zY2f+tSn4rlcg1KpVK1W a/cs6FxRAE9OTubn5lac2CF8166dg4OD8Vx6fn5+Zmb22DENDNB9BDBAx1G/6pez WjwP6djo6OIygaiBd+7ccfTo0XiuPjc3l8vlUimnUgN0GQEM0Fk2bdoY1W9sj/5+ 5jO/98UvfjGeazVocnKyXq+3exZ0gcXzkIr/93HcdDp95513ZrOZeK6eSqUshAbo OgIYoLPEee7RJz/5WzfeeGM812pE1L1R/bZ7FnSNk+chnfyJSfT1s3379nx+Lqar OxUJoNsIYIAOEufi54GBgb1798VzrUbUarVUyukyNOd4AI+OLpRKJ//khRdeePDB B+M5HNhCaICuI4ABOkWci5+jq7zwwosxXKhB6peleed5SCc9+eSTBw58L55NoS2E BuguAhigU8S2+LnTDj1Sv5yLbC43PDxc+bfnRT/66CM//vFPYrgPbCE0QHcRwAAd IbbFz5227bP65RxFATwxMVHI59/5h6VSaceOu4eGhmKYgIXQAF1EAAO0X2/vhk2b NsWz+Lmjtn1Wv5y7xa2wjo2OvuvorHQ6vX379lwuG8McLIQG6BYCGKD9Yrv9e/XV 1+zatSuGCzXCns+0ShTAY2Nj88Xiu/78Zz/72X333RvDBEqlUi43c+yYBgbodAIY oM0GBvr7+vpiuFCnbXw1MTHR7imwTCzeBB4ZHn7vXz3++ONPPPF4DBtizc7OzszM WtEA0OEEMECbXXXVlT09PaGvUq1W9+3b3zkbX01OTp48uxXO3fEAHhkpLyy896/u u+/en/3sZ6EnEH09T01NWQgN0OEEMEA7xbb4+fOf//znPvdHMVyoEalU6l2Pa8I5 igJ4cnIyPzf33r+anZ3dtm3b9HTwTaoKhUI2m52cdBMYoHMJYIC22bRp46ZNm2K4 UEc9+js1NVWtVts9C5abcrmcm5kZHR2tneqr66c//ek3vnFfDNOwGxZAhxPAAG2z Zctl69atC32Vjnr0d3p6ulKptHsWLE+n2wpr0fe+973vf//J0A8DR1/eUQNPTNjd DaBDCWCA9ohn76tqtXr33Ts++tGPhr5QI9LpdLlcbvcsWLbOsBXWihNnbt11151H jhwJPY0ogKMv9WJxPvSFAFgCAQzQHvHsfdU5p/7mcrn5eUlAWGfYCmvFiQUI27Zt m52dCToHu2EBdDIBDNAG8ex9tXbt2h/96Mehr9KIfD4/d6rdiaC1yuVyOpM5Njp6 uhf80z89vWfPntALoaMv+NzxTbnshgXQcQQwQNx6ezds2rRp9erVQa/SOecelUql bDbb7lmQFNlcbujo0TNstLZr185f/OIXoaeRSk2Nnr7DAWgXAQwQt3hu/3bI4uda rZZKuQ9GfM68FdaKXy6EvmN2djboNObn5zOZjN2wADqNAAaIVZS+UQCHvkrnLH6e mJho9xRIljNvhbXo6ad/sHfv3tALoR2JBNCBBDBArGK4/ds5i5+jAKjVau2eBYlz 5q2wFu3YseONN14POo1SqZROp90EBugoAhggPv39mzZu3Bj6Kh2y+NmhR7RLFMAT k5OFM+67NjU1tW3bHaH3ZjtxJFKmePr12ADETAADxGfLlsvWrVsX9BKrV69+4YUX g16iEbOzs4VCod2zIKHK5XJuZmZ0ZOTMCxAOHDjw5JNPBF0IXalUUqkpDwIAdA4B DBCTgYH+vr6+oJeoVqt3373jox/9aNCrnNXCwkImk2nvHEi4bC53bGysdMZbr1Ee b9++7ejRo0Fn4iYwQEcRwAAxieH279VXX7Nr166gl2iE+120XblczmSzoyMjZ37Z 4cOHH3hgd9CZnLgJnPIkMECHEMAAcYjn9u+rr74W9BKNsPEVHSKbyw0PD1fO9iD6 gw8+8PLLL69cGfATkZvAAJ1DAAPEIYbbv5///Oc/97k/CnqJs8pkMgtn3HoXYnN8 K6yJiUI+f+aXzczM3H7717PZbLiZuAkM0DkEMEBwMdz+7YSDfwuFwuzsbHvnACct Hgg8OjJSr9fP/Mqnnvr+/v37g+6G5SYwQIcQwADBxXD7d/v2O9u+95VHf+k0xwN4 dHShVDrzy6JC3rr1a8eOHQs3E9tBA3QIAQwQVl9f78DAQNBLdMLeVx79pQOVy+V0 JnNsdPSsrzx8+JXdu3d7Ehhg2RPAAGFt3jzQ29sbbvxqtXrgwOP9/f3hLnFWMzMz PtbTmbK53NGjR2vV6llfedddd7311pvhZlIqldLptCeBAdpLAAMEFKVvFMBBL/Gx j31869atQS9xZsdvsqXTbZwAnEEjBwIv+pd/+Zf77rv3rA8Mn4tUKjU6GnChNQBn JYABAorh9m/bjz6anJwM2gxwLho8EHjRN7/5zVdfPRxuIbSbwABtJ4ABQtmwYUN/ /6bVq1eHu8QnP/lbN954Y7jxzyr6NF8+2zmr0F7HDwQeGqpUKmd95dtvv71z545G XrlkbgIDtJcABghl2d/+LZVKQU9PhZaIAnh8fLxYKDTy4m9+8/5XX3013E3gQqEQ fddMTqYCjQ/AmQlggFCuuurKnp6ecOO3/favM13oCosHAo8MDzfy4tA3gev1+tTU lJvAAO0igAGCWPa3f7PZbOlsx6tChzi+Cnp4uNLYcv377//Ga6+9Fu4m8Ozs3MzM TCrlJjBAGwhggCC2bLls3bp14cZv7+1fOz/TXY6vgp6YKObzjbz4rbfe2rlzR7WB k5OWplKppFJTFlAAtIUABmi9vr7egYGApx+1/favnZ/pLr9cBT0ysqKxr9vQN4FT qVQ6nXF6NkD8BDBA64Ve/9ze278zMzM+uNN1FgO4vLDQyItD3wR2HhJAuwhggBYL ffpRe2//1mo1zy7SjaIAnpiYKDS2CjryjW9845//OexNYFthAcRPAAO02PK+/Ts1 NRXuthiEs7gKenRkpMHV+2+99daOHTtqtVBf7bbCAmgLAQzQYldccfkFF1wQaPAo Pg8ceLy/vz/Q+Gfm4F+6WlOroCPbtt0xODgYaDLR9/Lk5KRV0AAxE8AArdTb27t5 c8Dtr66++ppdu3aFG//M7H1FV2t2FfRLL7304IMPrFq1KtB8rIIGiJ8ABmil0Ouf 9+3b367bv3Nzc/mGywE6ULOroCNbt24dHR0JNJ9isZjJZCcn3QQGiI8ABmilq666 sqenJ9DgAwMDe/fuCzT4WTm2lGWg2VXQTz/9g717965ZsybEZKIOHx+f8J0FECcB DNAyGzf2Bb09++Uv/931118fbvwzyGQyCw03A3SsKICj5Cw2vJahWCx+7Wu3Rl// geaTSqWmp9Pz8/OBxgfgXQQwQMsEXf9cr9dfeeVwoMHPzNFHLBuLq6BHhocbf8vD Dz986NDBQAeblUqlKICtggaIjQAGaJkPf/hD4Y7/bePpR9PT05VKpS2XhpaLAnh4 eLhSLjf4+jfffHPnzh21Wi3QfGyFBRAnAQzQGkFv/1ar1VdffS3Q4Ge99NTUVFsu DSEcXwU9Pl4sFBp/y9133xVlcKD5zJ4wOWmRBUAcBDBAa1x66SXr168PNPhll132 0EPfCjT4mbn9yzKzhFXQzz333He+8501a4Ks71hYWIi+yxwIDBAPAQzQAhs2bLj4 4s3hxm/X9ldR+kYfzeO/LgQVBfDQ0FC14Z/sFIvFW2+9NZsNuBWWVdAA8RDAAC2w XLe/mpqaqlarbbk0hBMF8LFjx0rN7L38rW996/nnDwV6yN8qaIDYCGCAFgi6/vlj H/v41q1bAw1+Bm7/slyVy+V0JnNsdLTxt7z22mv333//yjCfm6yCBoiNAAZogaD7 P+/btz/o8cKn4+lflrFsLjc4OFhvZm/nW2+9ZWxsLNB8xsbGJyYmAg0OwEkCGOBc bdzYFy5Q165d+6Mf/TjQ4Gfg7F+Wt+P7YI2MlBcWGn/L/v37n3rq+2vWrAkxn+jb LZ3OFIvFEIMDcJIABjhXQR8Abtfxv5lMZqGZNoDuEgXwxMREIZ9v/C1vvPHGzp07 6vV6iPnMz89HATw5aRU0QFgCGOBcXXXVlT09PYEGb9f6Z6sxWd6WcBhS5JZbbhkf D7IKOurq8eOLoH3fAYQlgAHOSW9v7+bNA4EGb9f659nZ2UKhEP91IU5RAA8PDTX1 oPu+fft+8IOnwq2CzuVyc3NN3JQGoFkCGOCcLMv1z25DkQRRAI+Njc0389jtiVXQ O+v1JrbOalw+n89mc569BwhKAAOcky1bLlu3bl2gwduy/rlQKMzOzsZ8UYjfEg5D WhFyFXQ0n6mpKYchAQQlgAGWbsOGDRdfvDnQ4O1a/zw5ORlomx/oNJls9ujgYFNf 8Hv37n366R8EWgXtMCSA0AQwwNIFPQCpLeufq9Xq1NRUzBeFdjn+GPDwcKVcbvwt r7/++q5duwKtgnYYEkBoAhhg6YI+ANyW9c+5XG5+fj7mi0K7LOEx4BUhV0FH6ZvJ ZB2GBBCOAAZYuiuuuPyCCy4IMXK9Xn/llcMhRj4zyy9JlKU9BvzQQw++8MILq1ev bvl8qtXq5GTKtyFAOAIYYImCPgB89dXX7Nq1K9DgpzM/P5/L5WK+KLTXEh4DPnTo 0COPPLxq1aoQ80mlUqOjx0KMDMAKAQywZBs3buzv3xRo8C9/+e+uv/76QIOfztTU VLVajfmi0F5LeAy4WCzecstXA/20aHZ2dmZm1mFIAIEIYIAlCvcAcFShr776WoiR z6Ber3vykARa2mPAO3bseOON10PMx2PAAEEJYIAlCvcAcFsOQJqbm8vn8zFfFNpu aY8B79mz55ln/sljwABdRwADLEXQB4DbcgCS439JrEw2O3jkSFNvef311++5Z1et FuQwJKcBA4QjgAGWoq+vb2Ag1BlFO3bsvPbaawMNfkrWP5Nk2VxuaGioWqk0/pYo fW+66aZ0ejrEfFKp1PR02oFkACEIYIClWGYPAFv/TJJFATw6OrpQKjX1rnvvvfdn P/vpypWt/yhVKBSy2ezkpH2wAFpPAAMsxZYtl61bty7EyG15ANj6Z5IsCuDxiYli kz8DCvcYcLlcnpqampiwKAOg9QQwwFJ8+MMfCvHBN/Kxj31869atIUY+Aw8ckmRR cGay2dGRkabedfjw4d27vxniDvAKjwEDBCOAAZrW29u7efNAoMHjPwE4n8/Pzc3F eUXoNNlcbvDIkabWQRSLxa9+9SszMzMh5iOAAQIRwABN27ixr78/1A5YL7/8SqCR TyeVSgXazBa6RRTAw0NDlWb2wYrcccftR48eDTGf6Lsync4UmzydGICzEsAATQu3 A9bq1atfeOHFECOfgRtNsLR9sB555JGDB38S4mkI+2ABBCKAAZoWbgesq6++Zteu XSFGPp2FhYVMJhPnFaEDHd8Ha3y8WCg09a6DBw8++ugjq1atavl87IMFEIgABmja VVdd2dPTE2LkP/zDz/3xH/9xiJFPJ5fLOW4UouBMZzLHRkebetfQ0NCdd25vduF0 I+r1ehTkAhig5QQwQHM2bNhw8cWbAw2+Y8fOa6+9NtDgp+QAJFiUyWYHjxxp6i21 Wu2mm25Kp6dDzMc+WAAhCGCA5vT19Q4MBNkCulqtvvrqayFGPgOfsGFRNpc7evRo rVpt6l133XXXW2+9GWI+9sECCEEAAzRn48aN/f2bQowc/w5Y0WfrQIe4QNc5vhH0 8HClXG7qXeH2wZqbm8vlZqIMbvnIAEkmgAGaE24L6Msuu+yhh74VYuTTyWQyCwsL cV4ROlYUwMeOHSs1+Uj8M888s2fPP4YI4GKxGH2H2ggaoLUEMEBzwm0B/YlP/ObN N98cYuTTsf4ZTlraRtCHD7+ye/fulStb/4HKRtAAIQhggOaE2wL6C1/4wg03fDbE yKcjgOGkKIAnJyfzc3NNvSuVSm3d+rUQKylObAQ94ZsUoLUEMEBzrrnm6kAj79u3 v7+/P9Dg73X83Jd0OrbLQYeLviOiBh4ZHm72jTfffHMqFeQ+rY2gAVpOAAM0obe3 d/PmZbIF9NzcXD6fj/OK0OGiAB48cqTZg8HCbQQ9NjZmCTRAawlggCaEOwMp/i2g p6enK5VKnFeEDre0k5DCbQTtJCSAlhPAAE3YuLEv0CrlqKv37t0XYuTTsbQS3mVp JyEdOHDgySefWLNmTcvnk8/nc8efTLYRNEDLCGCAJoQ7A+m6667btm17iJFPRwDD u0QBPDo6ulAqNfWugwcPPvLIwyHuAOfzhWw26yhggBYSwABNuPTSS9avXx9i5N/5 nf/0pS99KcTIp7SwsJDJZGK7HHSFpR0F/POf//zee+9p9snhRkTfp9PT0x4DBmgh AQzQhHCHAMd8BlI+n59r8rgXWPaWdhTw5OTkbbdtDXESkqOAAVpOAAM0IdwhwDt2 7Lz22mtDjHxKmUwmxOd16GpRAE9MThaa/NlQrVb7h3/4+xBLKk4cBTwugAFaSAAD NCHcIcAvv/xKoJFPaXJyMsSKTehqxw/HzmSOjY42+8avf/224eYPEG6Eo4ABWksA AzRqw4YNF1+8OcTI8R8C7CM1nFImkxkcHGz2XXfeuf3tt98OMB0BDNBiAhigUcvp EGAfqeGUMtns4JEjzb7r4YcfPnToYIiNoMfGxiyBBmghAQzQqGUTwLaAhtPJ5nJR ADf7gIAABugWAhigUX19fQMD/SFGjrp67959IUY+pUKhMDs7G9vloItEAXx0cLBW qzX1rgMHDjz55BNr1qxp+XxSqVQ6nS4WmzuZCYDTEcAAjdq4sa+/P0gAX3fdddu2 bQ8x8ilF9Vto8qAXSIgogIeOHq1Wq0296+DBg4888nCIO8D5fD6bzUUZ3PKRAZJJ AAM0atkEsDOQ4HSOB/DQULVSaepdIQO4kM1mBTBAqwhggEZt3jzQ29sbYuRPfOI3 b7755hAjn1L0YbrZFZ6QEFEADw8PV8rlpt71yisvP/DAAytXtv5jlQAGaC0BDNCo Sy+9ZP369SFG/sIXvnDDDZ8NMfIp2QIaTmdpATw5Obl169fKTb6rEaVSKZ1O2wcL oFUEMECjtmy5bN26dSFGFsDQIaIAHhkZKTf5jEC4AI7GnJqaEsAArSKAARolgGHZ iwJ4dGSk2YfkBTBAtxDAAI1aHgFcr9ejD+vxXAu6zvEAHh1dKJWaepcABugWAhig UVdddWVPT0+IkeMM4Gq1Gn2ejuda0HU6LYDr9fr4+IRVGwCtIoABGrU87gBHn9HT 6XQ814Ku02kB7A4wQGsJYIBGLY8ALpVK2Ww2nmtB1xHAAMubAAZoVLgAjvMc4GKx ODMzE8+1oOssLYDDnQMsgAFaSwADNCpcAF933XXbtm0PMfJ75fP5ubm5eK4FXWdp AXzw4MFHHnl49erVLZ+PAAZoLQEM0KhLL71k/fr1IUaOM4BnZ2cLhUI814Ku02kB XCqV0um0AAZoFQEM0KjNmwd6e3tDjDwwMLB3774QI79XLpebn5+P51rQdZYWwAcO HHjyySfWrFnT8vnk84VsNptKpVo+MkAyCWCARm3c2Nff3x9i5NWrV7/wwoshRn6v 6MN0qckP95AcxwN4ZGRhYaGpdz388MOHDh0McQdYAAO0lgAGaJQAhmUvCuCRkZFy BwVwPpvNCWCAVhHAAI3q6+sbGAgSwNVq9dVXXwsx8nsJYDiDKICHh4crTR5odOed 299+++0Q84nSN51OF4seWwBoDQEM0Ki+vt6BgYFAg7/88iuBRn6XTCbT7PJOSI7j ATw0VKlUmnrX179+W5TNIeYzNjZmByyAFhLAAI0KGsA7duy89tprAw3+TgIYziAK 4KGhoWozAVyr1f7hH/4++s4KMR8BDNBaAhigCddcc3Wgkb/whS/ccMNnAw3+Tul0 utzk8k5IjiiAjx49WqtWG3/L5OTkbbdtDfRzpbGx8YmJiRAjAySTAAZoQrgA/p3f +U9f+tKXAg3+TgIYzuB4AA8O1mq1xt/y85///N5776nX6yHmI4ABWksAAzThqquu 7OnpCTHyddddt23b9hAjv4sAhjOIAnjwyJGmavbgwYOPPPJwiC2go2mMj49bAg3Q QgIYoAlbtly2bt26ECMPDAzs3bsvxMjv4hlgOINMNhsFcFNvOXDgwJNPPrFmzZqW T6ZcLk9NTQlggBYSwABNuPTSS9avXx9i5NiOAs7lcvPzjlSBU8tkMoODg0295ZFH Hjl48Cch7gAvLCxMT08LYIAWEsAATdi8eaC3tzfEyLEdBTwzM1MsFmO4EHSdcrmc zmSOjY429a677rrrrbfeDDGffL6QzWZTqVSIwQGSSQADNGHjxo39/ZsCDb5v3/7+ /v5Ag580OztbKBRCXwW6UTaXm5icLMzNNfWum2++OZUKcpN2bm4ul5sRwAAtJIAB mhD0KOB4TkKKPlLn8/nQV4FuFAXw+Ph4sZmfEEV1unXr1wI9Vx8Nnk5nLNkAaCEB DNCE3t7ezZtDBfAnPvGbN998c6DBT4rqd67JG1yQEFEAHzt2rNTMQ/KHD7+ye/fu lSuDfKAaGxvzADBAawlggOaEOwr4sssue+ihbwUa/KRCoTA7Oxv6KtCNogAeHR1d KJUaf8szzzyzZ88/htgBa4VDgAECEMAAzQl3FHA8G0GXSqVsNhv6KtCNogAeHh6u NHNQdrgtoE8cAjwhgAFaSwADNCfcUcDxbARdqVSmp6dDXwW6URTAQ0ePRt+Jjb8l 3BbQDgEGCEEAAzQn3ElIkR07dl577bWBBl9Uq9VsKgunFAXw4JEj9Xq9wddH3003 3XRTOh3kJ0rOQAIIQQADNCfoSUh/+Ief++M//uNAg59kUSWcUiabjQK48dcPDQ3d eef2SqUSYjLOQAIIQQADNCfoSUhXX33Nrl27Ag1+kgCG9yqXy+lM5tjoaONvOXjw 4KOPPrJq1aoQ83EGEkAIAhigORs2bLj44s2BBo9nHywBDO91/BDgiYliM6dkh9sB a4UtoAHCEMAATQu3EXTk5ZdfCTTyST5Vw3st4RDgO+64/ejRoyEmc2IL6HE7YAG0 nAAGaFq4jaAjX/7y311//fWBBl+USqVqtVrQS0DXiQJ4ZGSkvLDQ4OuLxeJXv/qV mZmZEJOxBTRAIAIYoGlBN4L+2Mc+vnXr1kCDL8pkMgsNf8qHhGj2DKTDhw/v3v3N lSuDfJQqFI5vAT05aQcsgBYTwABN27ixr7+/P9Dga9eu/dGPfhxo8EVzc3P5Zh50 hCRo9gykPXv2PPPMPwV6ANgOWACBCGCApvX29m7eHGoj6Gq1+uqrrwUafNH8/Hwu lwt6Cegu5XI5k82Ojow0/pZ77733Zz/7aaA7wHbAAghEAAMsxYc//KFAd34iO3bs vPbaawMNHqlUKtPT0+HGh66TzeUmJicLc3MNvr5Wq910003pdKjvIwEMEIgABliK oPtgxfAYsM/W8E5RAI+Njc03vOT48OHDDzywO9Bk7IAFEI4ABliKoPtgxfAYsACG d2p2C+igDwDbAQsgHAEMsBR9fX0DA6H2wYrhMWABDO/U7BbQO3bseOON1wNNJpVK TU+n55s5kRiABglggKXYsGHDxRdvDjd+6NOAp6enK5VKuPGhu2Sy2cEjRxp8cbFY vOWWr4bbSc4DwADhCGCAJbriissvuOCCQINfffU1u3btCjR4ZGZmxgkrsOj4FtCZ zOjoaIOvP3To0COPPLxq1aoQk6lWq5OTKQEMEIgABliioI8B1+v1V145HGjwFU5C gnfI5nLj4+PFQqHB1z/00IMvvPBCoAeAi8ViJpOdnLQDFkAQAhhgiTZu7OvvD/UY 8IrAhyFVq9WpqalAg0N3iQJ4dHR0oVRq5MW1Wu3mm2+eng717ZNKpdLpjAUaAIEI YIAlCv0Y8Cc/+Vs33nhjuPGtsYRFx3fAGhqqNvZU/Ouvv75r1656vRZoMh4ABghK AAMsXdDHgEMfhuRDNizKZLNHBwfr9XojL967d+/TT/9gzZo1IWbiAWCA0AQwwNIF fQw4sm/f/nCrrG0EDSua3wHrlltuGR8fCzQZDwADhCaAAZYu9GPAQVdBz87OFhre 9QeWq6Z2wHrjjTd27twZbv2zB4ABQhPAAEsX+jHgoKugS6VSNpsNNDh0i6Z2wNq3 b98PfvBUoPXPKzwADBCeAAY4J1u2XLZu3bpw4wddBe2jNhzfAevo0Wq12siLg65/ LpfLU1NTExPWPwMEJIABzknox4CDroIWwCRc1JxRAI8MDzfy4hPrn3c0uFfWEuTz +Ww2l0qlAo0PwAoBDHCOovqNGjjc+EFXQdsHi4SL6ndycjI/N9fIi/fv3//UU98P t/45St9cLjc3lw80PgArBDDAubvqqit7enrCjR9uFfRc9Fk779M2yRUF8NjY2Hxj m07deust0YsDzaRer48ff/7XogyAsAQwwLkKvQr6Yx/7+NatW0OMvLCwkMlkQowM XSEK4OHh4Uq5fNZXvvbaa/fff//KYJ+b5ufn0+mMA5AAQhPAAOcq9GFI9Xr9lVcO BxrcHSeSLArgwcHBeu3sxxp961vfev75Q6tXrw40EwcgAcRDAAO0wIc//KFwn4wj X/7y311//fUhRhbAJFa5XM5ks6MjI2d9ZdSlt956azYbcLmEA5AA4iGAAVrg0ksv Wb9+fbjxBwYG9u7dF2LkTCazsLAQYmTocNlcbnx8vFgonPWVTz311P79+8JtfxV9 D05PTzsACSAGAhigBUI/BlytVg8ceDzEQutisTgzM9PyYaHzHT8AaWSk3MAPgG6/ /etDQ0PhZjJ7wuSkA5AAghPAAC2wYcOGiy/eHPQSgW4C1+t1++6QTFEAHz16tFat nvllTz/9g71794a7/bvixAPAo6PHwo0PwEkCGKA1Qq+CrtVqhw49f/7557d8ZE8e kkDlcvn4HeDh4bO+ctu2OwYHB8PNxPpngDgJYIDWCL0KOnLddddt27a95cOm0+ly A8fAwHJy/AHgiYni2c7BPnz48AMP7A46E+ufAeIkgAFaJvRe0JVK5bXX/rnlwxYK hejzd8uHhU4WBfDo6OhCqXTml+3YseONN14POhPrnwHiJIABWiaGm8Cf+czvffGL X2ztmLVaLfoI3toxocM18gDwyMjI9u3bgq6PKJVK09Npz+EDxEYAA7TMxo19ITZq fqcoVg8ffrXlw3oMmERp8AHghx568KWXXlq5MuCHpVQqFQXw/Px8uEsA8E4CGKCV rrrqyp6enqCX+B//409+//d/v7VjOg2YRGnkAeDZ2dnbbtuay+XCTaNer49H8/Dj J4AYCWCAVophFfSqVatefPGl1o45Pz8f9IM+dJRGHgB+7LHHnn32h0FPPyoWi5lM 1vpngDgJYIBWiuo3auCgl6jX6zt37rr22mtbO6zbUCTH8QeABwdrtdoZXnPLLbeM j48FnYbtrwDiJ4ABWuyKKy6/4IILgl6ip6fn4MFDrR1zcnIySuvWjgkdqFwuZ7LZ 0ZGRM7xm//79Tz31/aC3f6vVavRN5/hfgJgJYIAWi2EVdPTRef/+723evLmFY87M zBSLxRYOCJ3p+APA4+PFQuEMr7njjtuPHj0adBqzs3PRN50N2AFiJoABWmzDhg39 /ZuCHggc+chHPnL33TtaOGC5XE6n0y0cEDrT8f2fR0bKp9/17fDhV3bv3h108+cV 1j8DtIkABmi9eG4C//CHz37gAx9o4ZgeAyYJogAePHLkDAv+d+zY8cYbrwedQ6lU SqfT1j8DxE8AA7ReX1/vwEDYrbAiv/Ebn/jKV77SwgGnp6crlUoLB4ROc3ylQyZz bHT0dC/4xS9+cc8999TrZ9of69ylUql0OuOhA4D4CWCAIC6/fMvatWuDXqJWqx06 9Pz555/fqgGjj+MzMzOtGg06UDaXGxsbmz99ed5//zdee+21oOufbX8F0EYCGCCI GFZBR377t3/7L/7iL1s4oFXQLG9RAA8PD1fK5VP+7eDg4N13312pnPpvW8X2VwBt JIABQvm1X7vqvPPOC3qJWq320ksvt3DDLYchsYyVy+XFHbBWnOaL/MEHH3jppZdW rVoVdBq2vwJoIwEMEEo8N4E//elP/9mf/XmrRpudnS2c8XgY6F5R/U5MThbm5k75 t1EY33nn9oXT7w7dEtH3VzabnZx0+xegPQQwQCjxnIdUr9dfeunlVt2zqlarU1NT LRkKOk0UwMeOHSvNz5/yb7/zne/86EfPhf6GdfsXoL0EMEBA8dwE/oM/+IP//t// R6tG8xgwy1UUwENDQ9VTbXU+PT19xx23z53m5nCrOP0IoO0EMEBAUf1GDRz+Oitf fPHFVt0EzuVy86e5RQbd65cPAA8Pn/Jvv/vd7z777A/d/gVY9gQwQFiXXPLv3ve+ 94W+SgtvAlcqlenp6ZYMBZ0jqt/x8fHiqR5xd/sXIDkEMEBY/f2bNm7cGP46rbwJ bBU0y8/i/s/lU+1xFdvt33Q6Uzz9EcQAxEAAAwR3+eVb1q5dG/oqn/3s7//Jn/xJ S4bKZrOlUqklQ0GHyGSzRwcH33vK19TU1LZtd4S+/VupVKIAdvsXoO0EMEBwAwP9 fX19oa/SwjOBy+VyOp0+93GgQxz/ks5kjo2OvvevHn744UOHDrr9C5AQAhggDvHc BP7t3/7tv/iLv2zJUFZBs5yc7gCkoaGhu+66M8rjoFd3+xegcwhggDjEdhP4Jz85 2JLStgqa5eR0ByDt3r37lVdadoz26bj9C9A5BDBATOK5Cfwbv/GJr3zlK+c+zsLC QiaTOfdxoO1OdwDSm2++uXPnzlqtGvTq1Wp1cjJlSQVAhxDAADGJ5yZw9Gn7+99/ qre399yH8pGd5eF0ByDdc889P//5v4S+utu/AB1FAAPE5/LLL1+79oLQV/nQhz50 333fOPdxrIJmeTjlAUiHD7+ye/fulSvDfhBy+xeg0whggPjEcyZwrVa79977rr76 6nMcp1KpTE9Pt2RK0EZRAA8eOfKuA5DuuOP2o0ePhr60278AnUYAA8TqsssuvfDC C0Nf5Vd+5VeeeuoH5z6OO1d0u1MegPTcc8995zvfXrNmTehLT01N+yYC6CgCGCBW mzZt3LRpU+ir1Ov1//k/v3jDDTec4zgzMzNuXtHV3nsAUj6fv+OO26empkJfOpVK jY4eC30VAJoigAHitnnzQEs2qTqrQ4eeP++8885lhGq1GkMnQDjHD0A6ejT6Sj75 J4899p3nnntu9erVQa9bKpXS6bSzfwE6jQAGiFtv74aBgYHQu++saNGRSJOTk+96 eBK6xfEDkLLZkZGRk3/y1ltv7dy54509HIjbvwCdSQADtEE8N4ErlerDDz98+eWX n8sgc3Nz+Xy+VVOCOL33AKQdO+5+4403Ql93fn4+nc5MTrr9C9BxBDBAe2zZctm6 detCX+XCC9c/++yz5ziIXXzoUlEADw8PV8rlxd/+8Ic//O53Hwu991WlUslkMm7/ AnQmAQzQHgMD/X19fTFc6IYbPvuFL3zhXEaYmpqKYckotNbx9c8nTgBecWINfzqd 3rbtjpmZmdDXPXH0UbpYnD/7SwGInQAGaJt4jkSK2vV73zswMDCw5BGKxWIM2QCt FdXvxMRE4f8u4L///m+89tproZ+9d/QRQIcTwABt09+/qa+vL4bdsC666KIf/ODp cxnBB3q6ThTAo6OjC6VS9Osf//jHjz76SOjFzytO3P7NZLKFdzx1DEBHEcAA7XTJ Jf/ufe97XwwX+vSnP/1nf/bnS357JpNZWFho4XwgtCiAjw4O1mq1qamp7du3z84G X8UQfY9MT6f9tAigkwlggHaK7SZwtVp96KGHrrjiyqW9vVwup9Pp1k4Jwom+Yk/s RDUa/XrXrp2/+MUvYrhoKpWanp6eny/FcC0AlkYAA7TZwMBAX1/wI5EiPT09P/rR j1evXr20t7uvRRfJ5nLHjh0rzc8/8cQTjz9+IIbFz6VSKZ1OT0w4+gigowlggDbr 7d2wadOmJXdpU6677rpt27Yv7b2zs7OebKRbRAE8NDT0s5/+9J577qnXazFcMZVK OfoIoPMJYID227x5oLc3jpvA9Xr9T//0zz7zmc8s7e1uAtMVFg9Aev0Xv9i+fVs8 X7SFQjGbzU5Ouv0L0OkEMED79fZuiAK4p6cnhmvVarVHH/32JZdcsoT3OhCYrhDV 7/j4+N133fnqq6/G8IB9vV6PvjXc/gXoCgIYoCPEdhM4ct55Pc8999x5553X7Bvn 5+dzuVyIKUELRQG84+679+3bG8Ojv5F8Pp/N5lKpVAzXAuAcCWCAjrBp08b3v//9 69ati+dyV1555Te/uXsJb7QKmg5XLpe//9RTX7n55vC3fo+rVContpt2+xegOwhg gE4R25FIK04s2vz0pz/953/+/7N3L/Bt1/X+x7v03vSepE3SyW3gJgwUDyiofxWP /z8o6hyCV7wiAh7lgOIRhsBQBozbuINcRS5bBwwGTA6KXJzcNm7C5kAE1m1t0tyT 5p78kv+3+W1lbF3XbvndX8/Hg5Kl6ff76Zamv3e+t3lT/cJ4PJ7NZpUoCaiKN//1 r/Pnn6faqV0cfQQAxkIABgAdUXMidKlUmj///Llz507pqyRJCoVCCpUE7KZ0On3W WWe9+eYb6nSXzWaj0ShHHwGAgRCAAUBHXC5nb2+vOgsXaypp9u677znwwAOn9FXB YFCEZ4VKAnbHRRdd+NRTT6kzjaKGo48AwIAIwACgL2oOAteMzoWueeKJJ7q7uyf/ Jel0emRkRLmSgF1zyy03L1myRLX3j9j7CgCMiAAMALqz33772u121bpraWn5299W 1tbWTv5L2AoLerN8+fLrrrvWZrOp093oUcOxGMO/AGA4BGAA0B23u9flck0pke6m /fff/+6775n848Wlfy7Hrj/Qi9WrV8+ff56ah1Qz+RkADIoADAB6pPJEaOHoo4++ 4IIFk3wwW2FBP4aGhubNO8vv96vWYzqdjsVigQCTnwHAeAjAAKBHnZ0dPT09qh0L XFPZFPqUU3568sknT/LxbIUFPRBB9JxzfvPWW2+p1iMH/wKAoRGAAUCn3G63y+VU cyK0JEkLFlz45S9/eTIPzmQyiURC6ZKACWSz2fPPP/+VV15Ws9NgMBiPx5PJlJqd AgCqhQAMAPql/kToYrF42223H3rooZN5MFthQUOlUmnhwovVPPSoZnTn53Q8zuRn ADAwAjAA6Nq++85obW1Vs0eRKx58cPnee++900fG4/FsNqtCScD2rrvu2gcffFDN KRLs/AwAJkAABgBdc7vdTqdDtaNNZTab7S9/eXynhwOLqMwhqNDEnXfeeccdf1D5 54KdnwHABAjAAKB3Xq/X5XKqOc9TaGpqfuqppxobGyd+WCgUUvPsGUB46KGHrr32 GtWO/JUlk8l4PME7PgBgdARgADAA9RcDCx/4wB7Lly+fOHjncrlYLKZaScBTTz21 cOHF5XJZzU6z2WwikRga8qnZKQBACQRgADAAp9PpcHQ3Nzer3O8BBxxw1113T/wY tsKCalavXvXb3/62UCio2akkSZFIhMnPAGAOBGAAMAa3u1fEYJUXPQqf/OSnrr32 2gkeMDIykk6nVasHlvXmm2/Om3dWKqX2+UMs/QUAMyEAA4BhaLIYuFwuz5kz5/zz fzvBYxgEhtLEc+zss+dt2rRJ5X4rS3/jwWBI5X4BAAohAAOAkfT19YkMrHKnIgP/ 6EcnnHrqqTt6QCQSUXlWKiwlFoudc85v3nrrLZX7zWRGl/76fCz9BQDzIAADgJG4 3b2tFSr3KzLwL395xne/+91xPyvSr8jAKpcEi0ilUvPnz3/99ddU7pdTfwHAlAjA AGAwIgN3dXXt9ICiqhMZ+KSTTj7llFPG/WwgEFB5Y15YQSIRP/fc8954Y53K/ZZK pXA4TPoFAPMhAAOA8bjdbqfTof6GWCLifvazR1x55ZXbfyqTySQSCZXrgbkNDg7O m3eWJivMg8GgCMDZbE79rgEAiiIAA4Aheb0ep9Nps9nU77q1ta2/v9/r9W5zP1th oboWLlz4+ON/qa2tVb9rn8/P8xkATIkADABG1dfndblcmnQtSdIPf/jD00//xdZ3 JhKJTCajST0wmXXr1l144YJAIKDynueyYDAYiUR5MgOAKRGAAcDANMzAQktLyxVX LPr4xz8+dg+DZthNyWTyiisu/9vf/qb+DP+xAjj3CABMjAAMAAbW2dnhdDrV3xR6 TKlUmjVr1sKFl+y1117ij+FwuFgsalUMDE2SpFtvvfX+++/TZNRXls1mRfr1+fxa FQAAUBoBGACMraenp7u7q6mpScMaRHTZf/8Dfve734kYzHlImKp8Pv+HP/zhgQeW lUolDdNvoVCIRqNDQ5z6CwBmRgAGAMNzu3sdDkd9fb22ZYj00tnZ+a1vfWvu3GO0 rQRGMTAwcOuttzz//As2m8YXJJx7BAAWQQAGADPweNxOp1OT/XK3J0nShz/8kRNO OOFDH/qQ1rVAj5LJ5LJlyx544IFkckQnT1rOPQIAiyAAA4BJaHgw0rjK5fK0adMO OuigY4897mMf+5jW5UB7ImE++uijf/nLn4eGhnSSe2XBYCgcDpF+AcAKCMAAYB59 fV6RgTVcRbkjxWJx+vQPfOxjhx511Bf22WcfrcuBejKZzHPPPffnPz/22muvFwp5 XeVeGYceAYCl6O4iCQCwO7Q9GGkyJElyu92zZx946KGHfuITn9B2+y4oYePGjX// +99feOGFf//7rWw2q9WBRpNRmfkcEUVqXQgAQCUEYAAwG/1n4DHyrr8ej3e//fab PfuAww47vLe3V+uiMDWFQuFf//rXqlWr1qx5/e23306lUjabTYfTELYnSo3F4iID a10IAEA9Bvj9BACYks7ODofD0dbWpnUhu6JYLDY0NPT09O6555577bXXzJkzDzjg gI6ODq3rwihJkoaGhtauXSsS79tv/3vjxo3JZLJcLutwYvNOZTKZeDzh93PkLwBY CwEYAEzI7e5ta2u321u0LqQKRL4SuUtErJaWlt7eXrfb43a7P1AhEnJ7e7vWBZqN fCDQu+++u2HDhk2bNgUCwyIlBoPBXC5fLpeMmHW3l8/no9GYz8eRvwBgOQRgADAn kYE7Ojqam5u1LkRZIhuLj/X19Y2NTQ5Ht9DR0dnV1elwOF0uV2+FuFM/m2Nrq1Ao hEKh4VEi04YikUgsFovHY+FwJBqN5HK5YrFoq9C6UgWJv4RoNDo0RPoFACsiAAOA aYkM3NXV1djYqHUhGpPHkKdV1NXV1dbWNTTUd3Z2trTYm5ubmptbhObmZrvd3loh bre1tYkb9gpxu6GhQetvYrNsNptMJlOp1JaPI6lUOjlq9EYmk0mnRz/mcqMPi8fj hVHFUkmSl1sbZXWucsQzQaT9oaEhrQsBAGjD0r8FAcD0RAZ2OBz19fVaF2JsIkKL ACnfkO+Rx0i3ipTixrSxeyoPmVZbO9E4qiSJBkdbEy3LzYr/V3oob3VPSX6wnFqJ r7tJ/K2GQqHBQdIvAFgXv0cBwOTcbrfT6dDzUTSAOiqHHoWz2ZzWhQAANEMABgDz 83o9DofDHNsXAbsmGAxV0i9H/gKApRGAAcASvF6v0+kw9+ZGwI5Uxn4jpF8AAAEY AKyir09kYCeLSGE1Iv1GItFMJqN1IQAA7XEZBAAWQgaG1QQCwWiU9AsA2IxrIACw ln333be11a51FYAacrlcOBwJBAJaFwIA0AsCMABYzowZ+7S1tWldBaCsbDYbjyd8 Pp/WhQAAdIQADACW43b32u12MjBMjPQLABgXARgArEhk4NYKrQsBqi+Xy8VicdIv AGB7BGAAsCiRgdva2u32Fq0LAaopn8+L9Ds0NKR1IQAAPSIAA4B1iQzc0dHR3Nys dSFAdRSLxWg0OjhI+gUAjI8ADACWJjJwZ2dnU1OT1oUAu0uSpEgkQvoFAEyAAAwA Vud2u7u6OhsbG7UuBNh1pVIpHA6TfgEAEyMAAwBGM7DD0V1fX691IcCuKJfLoVAo Ho8nkymtawEA6BoBGAAwyuMRGdhRV1endSHAlAWDoWAwmM/ntS4EAKB3BGAAwGYe j8fpdNTW1mpdCDAFIvqGw+FsNqd1IQAAAyAAAwDe4/V6HA4yMAyjkn4j2WxW60IA AMZAAAYAvE9fn9flcmldBbBzpF8AwFQRgAEA7+NyOfv6+rSuAtg5n88/PDysdRUA ACMhAAMA3qe3t8fj8WhdBbBzwWAwEolmMhmtCwEAGAYBGADwPkyBhlFks1kRgAOB gNaFAAAMgwAMAHiPy+V0u91sggWjCAaDg4NDWlcBADAMAjAA4D0M/8JY0ul0LBYL BIJaFwIAMAYCMABgM4/HLdKvzWZTqP3Gxsa2tvbKhNWycr1AJ8rlsiRJzc3NHR2d 4h/dZlPqkoOVwACAySMAAwBGdXZ29PT0tLS0KNfF3LlzTzrpZHEjn8+/+OKLr776 yj//uW7jxo2ZTFrcSSQ2umKxWFdX19vbu9dee3/oQ7M+9rGP77PPPuL+TZs2nXXW mSKmKtRvoVCIRmNDQ0yEBgDsHAEYADBKhcnPV1551axZs8b9lMgwa9euXbNmzTvv vLNx4wa/fziXy5bLZVYj65D4dymVSuKfpqXFLp42e++9z8yZMw888MA99thjR19y xhlnrFnzunIlpVKpeDzORGgAwE4RgAEANV6vSL/OadMU/KUgSdJf/vL4VL9qcHDw rbfeWr/+XZ/PHwwGKpNdIyItiwxms9kULdjiRMSV/5IbG5ucTkdPT29PT8/06dNn VHR2dk6ptauvvvqRRx5WdJBffm5kMlnlugAAmACXDgBgdR6P2+Fw1tUpO9YqstMt t9xaxQbz+fzGCp/PFwqFotFoIpGIRiPiRi6XKxSKpZIkEjI5eRvy+K24UVtbW19f 39TU1NXV1d3t6Ojo6O7udrmcXm/fnnvu2dvbW8W8umLFiquuukq5ZcAykYGj0Vg6 nVa0FwCAoXFNAACW5naL9NstgpDSHR133NdPOOEEpXvZniRJIhcNDw/HYrF4PC7i cSqVTCZTIiZls9lMJiP+KJKziNMiM4sHV8JhWSZ+S4rMpqvFyXJhokg51U+rEBWK NFtXV9/W1tra2tbU1Njc3NzU1Nzaam9psYs7Ozu7Ojs7Rb7t6ekRcVf97+idd975 9a//Z2RkRNFexN9MKBQS/8ri31fRjgAAxkUABgDrcrt7RShqaGhQuiMR2O65Z7HT 6VS6IyWI4kVyy1bkcjkRlUV4rgwy5yt35EQgFXeK8Fwzupi5KN8oFsWN4gTNjibW urqazSOxm2+IfwuRZ0V8FTcaGxvFx5aWFvmGuFPcaG9vV+Wbrr4zz/z1q6++qnQv 4h8rHA5zMjAAYEcIwABgUW63u7u7S4X0K9jt9vvvX6ZCR9CtpUuX3nzzTSrsaiZn YA5GAgCMiwAMAFbk8Yj0q8bMZ9nxx3/3+OOPV6cv6FMoFDrjjF/6/X4V+pLnQpOB AQDbIwADgOV4vV6Ho1u1E4aKxeJjj/2ZA40srlAoXHrppU8//ZRqe5JV9oUmAwMA 3ocADADW0tfndTqVPfFoG7NnH3jZZZep1h30KRqL/WnFij/+8Q41n3siA+fzBfFR tR4BADpHAAYAq3A6HY2NjS6XS81Oi8XikiX9Bt3+ClUUjkQ2DAz8/vc3rl+/Xs1+ M5lMIjHi8/nU7BQAoFsEYACwBLfb3dHR3tzcrHK/BxxwwOWXX6Fyp9ChWDw+NDT0 /HPP9fcvUflk5kKhIB+CxfFIAAACMACYX1+ft6urSz50R00M/2LMaAqtZODrr7t2 YGBA/QKYDg0AqCEAA4C5uVzOhoYGlRf9jjn44IMvuuhi9fuFPokMHIlGH/3Tn5Ys WaxJAel0emRkxOdTYydqAIA+EYABwLQ8Hk9nZ0djY6MmvZfL5eXLH2pqatKkd+hT LB4fHBy89ZZbXn/9NU02Bi8WpWg0ks/ng8GQ+r0DADRHAAYAE3I4ukXy1Grgt6aS fk899dSjj/6SJr1Dt+SJ0G+sW3f11VeNjIxoVUYymUylUgwFA4AFEYABwGw8Hk9H R7u2Q6/Tp0+//fY/SJKkYQ3QJxGAA4HAww8tf/TRR9Vflz6mWCxGo1GGggHAagjA AGAeDoejqalRw4Ffmci9f/rTo/X19RrWAN0qFArxRGJ4ePjqq65cv369ts/Vykhw kqFgALAOAjAAmERfn7ejo6OhoUHbMsrl8i9/ecbXvvY1DSe4QufGJkJfddWVyWRS 22IkSYpEIrlcPhRiKBgAzI8ADACG53a7W1vtra2tWhcy6uCDD77tttuDwWCpVNK6 FuiXPBH6qSefvO++e202m9bl1GSz2URiJJ8nBgOAyRGAAcDAnE5nY2ODw+HQQ4QQ 6urqnn32OfFRZButa4GujU2EvvOPd7z00kua7Ai9vZGRkVQq7fczIxoATIsADABG pZM5z2MkSVq27IF9991XpIh0Oq11OdA7eSL00ODgtddeu2HDgLaLgcfIM6Lz+UIw GNS6FgBA9enilw0AYEo8Hndra6vdbte6kPeI2HDppZcdeeSR4vbw8LDW5cAY5InQ 4VDommuuFrFT63Lek81mR0ZGxMdwWEdVAQB2HwEYAIxEnvOs+T7P2yiVSv/1Xz/7 yU9+UlMZ1tNVkoGejU2E3rhh4Prrb8jnc1pX9D6jO0Qn2SMaAExFR9dPAIAJyNG3 u7tbJ6slx5TL5blz55533nz5jyL9ilSjaUUwks0ToYeG3nhj3R1/+IPe9k4TT+9g MFQocFwwAJgEARgA9K6zs8Nut+tque8YEQ/+8z8/f/nll4/dw/xnTJWcgcPh8HPP Ptvfv0TrcsaxZWEwMRgADI8ADAC65vV629vbmpqatC5kHCL9fvazn73yyqvG7pGn jGpYEgxKngsdCASefeaZe+9dqqsZ/mNGg3osRgwGAEPT4y8YAEDN6E5XnspOVy1a FzK+7dOvIAKMuF+rkmBom9cD+/3PPvvsfffdq88MXLPlxGAmRQOAQen0twsAWJnH 425psYvwq9sMIFLu5z//+csuu3zrO9n+CrtJngvt9/tXr1rV379Et89/IZ1OJ5PJ fL4QChGDAcBI9PurBQAsyOVy1dfXu1z62uR5G6VS6dhjjzvnnHO2uT8cDheLRU1K gmnIGdg3NLR27do//vEOnU8oqMz5T2Uy6VgsrnUtAIBJ0e8FFgBYioi+DQ31DofD ZrNpXctEJEn6+c9PPfHEE7f/FNtfoSrkpbZDQ0MbNmy46abf639T8ZGRpEjCfj+n JQGAARCAAUBj8vlG+o++NZX0u3DhJV/4whe2/1Q8Hs9ms+qXBFMSoTcqMvDgoHhe 3XjjDZFIRM9zImoqiwJCoVA+XwgGg1rXAgCYiK5/nQCAublczoYGPR7tOy6Rz++5 Z/HMmTPH/SzDv6iu0SXl0ejQ0JAIlzfccP27776r/x8TYjAA6B8BGAA0II/6GiX6 CtOnT1+8eElra+u4n00mR6eAqlwSTC8Wjw8HAunKwVr33XffCy88X1dXp3VRO0cM BgA9IwADgKqMNepbU9ny6nOf+89FixZN8BiGf6EE+WAkESYz6bT44wsvvLBs2f36 XykgEz84oVBYfAvEYADQFQIwAKjEcKO+NZVFv+ecc+5xxx03wWMY/oVy5AwsMmQ2 kxF/FDduvvnmRCKu8yXBY0QMDofDjAYDgH4Y4/cHABiaUXZ43kZTU9OSJf177rnn xA9j+BeKkjNwIBDIbdll7bbbbl23bp0hpkPLmBQNAPpBAAYABRk0+pZKpSOO+NwV V1yx07IZ/oUK5Azs9/sL+bx8z7PPPrN8+XJj/ViNxeDaWpvfz9tGAKANAjAAKEKO vk6n0yhzNceIy/SFCy858sgjJ/Nghn+hjtHDgeNxkYGLW44FjsfjN910UzAYMNCa gprKz1cymUyn05lMJhaLa10OAFiOwS7LAED/PB53S0tLa2urEaPv/vvvf8stt4r6 J/N4zv6FmuQM7PP5pGJx7M6HHlq+cuVKA02HHlOZPSFicJoYDABqMtjFGQDomdfr EdHRbrcbLvrWVKY9n3XWvG9+85uT/xKGf6GyzRl4aEiSpLE7RSS+7bZbE4mEsWZE y1IV6TQxGABUYrxLNADQIa/X29pqn+TAqd6Uy+VZsz508803t7W1Tf6rIpFIYctk VEA1cgYeGhoqbZWBhWXLlj333LNGHAoWRACWkzAxGACURgAGgF3X2dlht9tbW1ub m5u1rmUXifR73nnz586dO6WvEiFEBGCFSgImJp5+0VjMJzJwqbT1/cPD/ttvvz0a jRpxKFjIZrMjIyO5XD4UCmldCwCYFgEYAHaFw9Hd1NTU3t7e2NiodS27SJKkT3zi k1ddddUufAuBQEAkZyWqAiZjRxlYeOyxxx5//PG6OiPtjLW1fD4fj8eJwQCgEAIw AEyNvL1zZ2dnfX291rXsOpHer7vuuo9+9D924WtHRkbS6XTVSwKmRM7AQ4OD278X k0qlbr/99g0bBoy1QfTWRmd6x2IiDAeDxGAAqCYCMABMlhx9u7u7jXtVXVMZ+P3x j0889dRTd7kF9r6CToxm4Gh0aGho3PkIa9euWbJkiciQBp0RXVP5aY1EIsRgAKgi AjAA7FxPj6u+vt7hcBj3Srqmss/zIYccctVVV7e2tu5yI6FQSHr/5kOAhkaXo0ej vh1k4JrKOUl///vfDf2mlfjJDYfD+XwhGAxqXQsAGB4BGAAm4vF47Hajnmy0tZaW lmuuuWbX5jyPqZxcmqpWSUBV7DQDyzOiBwbWG3SPaJn47uQjk3w+n9a1AICBGft6 DgAU4nb31tbWitxr0JONtiaum3/+81NPOOGE3W8nEAhUpSSgunaagYU33njjnnvu zuVyhp7HUVM5MymZTJVKkt/PYgQAmDICMAC8j9PpbGxsaGtra2pq0rqW3VUsFo8+ +ugFCy6syvzPYDC4/Y67gE5MJgMLTz755KOPPmqzTTP6nA75zCTxMRzmQDIAmAJj v/oDQBXJ0bejo6OhoUHrWnaXSKoHHnjgokVXulyuqjQYj8fFpXZVmgIUMskMLCxe vPjll18y9IxomXxmUjabC4fDWtcCAMZAAAaAzds7d3V1G/fs0DHi0r+7u/uyyy7b zeW+W8vlcrFYrFqtAcqZfAZOJBJ33XXX+vXvGnp/LFmxWIxGo2wWDQCTQQAGYGnm 2N55TEND43nnnffFL36xus1y7hEMZPPZSD5feRIz9oeGhu6+++5gMGCCGLzlzCQ2 iwaAiRCAAViU1+tpaTHD9s5bTPvpT3964oknVr1dlv7CcEYzcCzmGxqa5FN3zZo1 /f39+bzh98eqqcwBSSZTmUx6aIjNogFgHOa47AOAyers7BCht7W1tbm5WetaqkNc 4h933NfnzZunxLW7PK+y6s0CStucgX2+0qSPrV65cuWKFY+IAGmOGJzJZEQSHhoa 0roWANAXAjAAq3C5nA0NDe3t7Y2NjVrXUh2SJH3xi0eff/75Cn1HIyMj6XRaiZYB FYgMHKtkYGnSGVh47LHHnnjir9OmGX6b6JpKDM7lcuIHmeXBADDG8C/uALBTcvTt 6uoywaavsmKx+LnPfW7BggtbW1sV6iKbzcbjcYUaB9QxmoHjcb/PJ35kpvSFy5cv f+aZv9sqxyUpVJtqRAwW334sFhdhOBQiBgOwOsO/rAPABOTtnbu7u02ww41MXMge fvjhl1xyaWdnp3K9SJLEhTLMQc7Aw36/uDHVr+3vX/Liiy+KVw8TxOAaNosGgAoz vKADwPY8Hk9LS3Nra6s5rlxrKqH00EMPveiii3t6ehTtqFwuBwIBRbsA1CRnYPGs zudyU/1aERpFDH711VdNE4NLpVI4HGazaACWZYaXcgAY43b32my1ra32lpYWrWup GhF9Dz74oxdffLFI9Sp0J3LCTs9QBYxFZOB4IiGe27lsdhe+PJ/PL1my+PXXXzfN MgrxM55KpdJpNosGYDkEYAAm4XB0NzU1tbW1iY9a11I1Ivp++MMfvuiii6dPn65O j6RfmJWcgUOhUGZXt3bLZrP33HPPunX/NFMMFt9UMpkULzV+P8d9A7AEAjAAw3M6 nY2NDZ2dnfX19VrXUjXqR98ajvyF2ckZOByJpFOpml19o2csBptmUrSIwfl8PpFI VHbJCmtdDgAoywwv3AAsS97e2Ux7XNVU1hz+x38cctFFF6kz4XkM6RdWIDJwKp0W Sc/n85V34wkvWliyZPGaNWvMFIMrm0XHWB4MwNzM8JINwIJ6elz19fUOh8Nms2ld S9VIknTYYYddcMECpbe52h7pF5YiYnA0FvNP8Yjg7eXz+f7+/tde+4dpYnBN5YUo EomIv6JAgBgMwIRM8mINwDq8Xk9LS4vdbjfN5WZNZdT3U5/6PwsWLOju7la/d9b9 woI2HxHs9xenfjzSNsTP79Kl/a+88oqZYrC8WTQxGID5mORlGoDpud294uKytbW1 ublZ61qqSVxlHnHE584///yOjg5NCiD9wrLkDBwMBndta+htiJ/l++67d/Xq1SaL wel0OpVK+3xsFg3AJEzyAg3AxOSFvu3t7Y2NjVrXUk3iyvKoo44677z5Wp3YJApg pR8sbve3ht7esmX3P//88zabzTQxuFwuZzKZVCo1ODikdS0AsLtM8tIMwJQcDkdT U1NHR7sIwFrXUk3ianLOnDnz5p2tYaTP5/PRaFSr3gH9kDNwpLI1dBVnQzzyyMMr V66cVlGtNrUl/nJyudzIyIhIwrFYXOtyAGAXmeRFGYDJyCcbdXV1mea8TZnNZvv2 t79z+umna7t3VzqdFlexGhYA6Iq8NXQ+n9/9bbG28fjjj//1r4+L6GimGLzlzKR8 KBTSuhwAmDKTvBwDMA1TnmwkiG/q5JNP+eEPf6h1ITXxeDxbjRWPgMnIS4KHh4cL +Xx1W37uuedWrFhRLBZME4Nr5L+uWIwYDMBwzPNCDMDoTHmyUblcbmtr/9WvfvWV r3xF61pGhcPhYrGodRWATsnToYOhULZ6S4LH/POf/3zggWWJRMJML3Hi9SQajebz +WCQGAzAGAjAALTn8bhbWuytraY62ahUKu2zzz7z5p196KGHal3LKBHFg8EgGz4D E3tvSXA6XVbgcOwNGzbce+/S4eFhM01ykWMwZyYBMATzXGsCMKLKob52u73FTNG3 WJQ+8pEPz59//owZM7SuZbNsNhuPs2kNMCnvLQn2+yVlZkyIgL148eKBgfVm2ixa kiTxfTEaDEDnTPKaC8BwRPS121tF9NW6kGoS13+f+tT/+e1vf+t0OrWu5T0s+gV2 QXVPCR5XJpMRMXjdun+a6ejgLTG4wClrAPTJJK+2AAzE6/W2tra2tDRrXUg1lUql L33py2effbZWh/ruiLgGLSkwjROwAnk6dDgczqTTyi0fKBaLy5Yte/HF1SYbDU5X +Hx+rWsBgPcxyessAP1zu3ttttq2ttbmZlNFX3HN+p3vfOe///s0va3oy2QyiURC 6yoAY1NhOvSYRx/909NPPy1umCYGl0qlVCpFDAagKyZ5hQWgZyL6inDY2trW3Nyk dS1VUy6Xm5qaf/7zn33nO8drXcs4IpGIuHDXugrAJOTp0IFAIJ/LKd3Xs88+s2LF nySpSAwGACWY5LUVgD7J0betra2pyTzRV1zM7bHHHmec8avPfOYzWtcyjnw+H41G ta4CMBt5OnQoHM4qOR16zLp16x544IF4PGaaM5MqMVik4BQxGIC2CMAAlOL1ekX0 NdOoryRJs2fPPu+8+TNnztS6lvHJB3JqXQVgTu9Nh/b5xKuBCj36fL7+/iWDg4N1 dXUqdKcCRoMBaI4ADKD6KtHXVGt9xUXbpz71qfnzz3e5XFrXMj4GfgF1qLA79DYS iUR/f/+//vWmaWKwJEnh8OgyDXaKBqA+AjCAavJ6Pa2tbWba4blcLs+ZM+fMM8/S c55n4BdQ0+bdoSORTCqlwnRomfgZf+CBZS+99JLe9tvbZRyYBEATBGAA1eHxuFtb W+12u9aFVE19fcMPfvCDk08+Wc9r8LLZbDwe17oKwHLk6dCFfN4/PFxUccO5Uqn0 2GOPPf3002bZIWv0FKhoNJrL5UOhkNa1ALAEs7x8AtCOiL4tLS0i/Zpjz9JyudzR 0XHGGb/68pe/rHUtOxEOh4sKn8sCYALyUHAwGMxmMip3vWrVqocffrhQyJvjhXd0 Ynksls/ng0FiMABlmeFFE4BWXC5XQ0O90+k0xxWYJEmzZs0655xzDzzwQK1r2YmR kZF0Oq11FQA2DwXncjm/z1cqlVTu/Z133rnvvntDoZA55kWLAByPx7PZbDgc0boW AKZlhmtWAOpzOh2NjY3d3d3muOoqFouHH374eefN7+vr07qWnRAXiLFYTLVlhwAm Q82DgrcXDAb7+/s3bBgwxwuyCMAjIyODg0NaFwLAnAjAAKams7PDbrd3dnbW19dr XUsVlEqlL3zhi7/5zW9aW1u1rmXnIpHRfVO1rgLAODbvjBUOZ1Q5KHh7qVTq3nuX rl271gSbRYu/wHQ6nUymfD6f1rUAMBsCMIAp8Ho97e3tTU1mONrXZrMdf/zxp576 34YYM2HOM6B/Wu2MtU0NDz/88AsvPK/n3fsmSd4mWnxHgQDbRAOoGgIwgElxu92t rXZDDJNOrFwui+/i5z8/9Rvf+IbWtUxKNptNJBLMeQaMYvPOWKFQVrs3rUql0tNP P/34439Rf1ly1VX2x5IXBoe1rgWAGRCAAeyE0+lsbGxwOBxGH08QF4J77733mWee ddhhh2ldy6TIp4OY4PoVsBp5KDify/n9fkmStCpDvHqsXbtm+fLlyWTS6FsVZjKj C4OHhlgYDGB3GfvVEIDS+vq8HR0dDQ0NWheyW0SS/MhHPjJ//vkzZszQupbJYrkv YHTyzljBYDCXzWpYRrlc3rBhw733Lg0EAoZY8bEjIs+Hw+F8viD+SrWuBYCBEYAB jM/t7rXbW9vajD3nWZKkz372iPnz53d3d2tdy2TJp4BoXQWAKnjvkCS/v6TdULBM pMclS5asX/+uoXfJ4sRgALuJAAxgWyL61tbWGv2Io3K5PHfu3DPPPKuxsVHrWiYr mUymUimtqwBQZdoekrQN8SJz3333rlmzxtAxWHwX4gXT5/NrXQgA4yEAA3gft9vd 3t7W0tKidSG7rq6u/kc/+tFJJ51koEXL6XR6ZGRE6yoAKEXeGSsSiWTSaT0s7M/l citWrDD0ZtHyLgm5XD4UYigYwBQQgAG8p6/Pa9yB33K53NbWdtppp3/ta1/TupYp YJNnwCI2H5I0eqiPLoaCayolyZtFG3eLLIaCAUyVUV/vAFRX5ZQjwa51IbuiVCrt ueeeZ5017/DDD9e6linI5XLxeJzoC1iKPBQcjkSy+hgKrqkMpb744osrVjwiajNi EpZXBQ8OskE0gEkx3sscgKrzej1dXV319fVaFzJlkiTtv/8B8+fPnzVrlta1TIGI volEQifXvgBUpsOh4JrKO4lvvvnmsmX3i1cnw82LLpfLoVCIDaIBTAYBGLC0zs4O u93udDoN966/iL6HHHLI7353QV9fn9a1TEE+n4/H40RfADocCq6pJMmBgYGlS/tF njTccphMJpNIjPh8Pq0LAaBrBrvkBVBFbndva2ub4aY9i+j7mc98RkTfzs5OrWuZ AqIvAJkImfJ7jvocCpb5/f4lSxYPDg4aa7NopkMD2CkCMGBRbre7q6vTQEcE1VRm 6H3xi0efe+65zc3NWtcyBUx4BrCNsQxco9ehYFkkEunvX/LOO+8YKAaLv8NwOBwM hvL5vNa1ANAjAjBgRV6vp7u720AXNOJi8dhjjzvrrLOMNSWP6AtgAoYYChbE69jS pUvffPMNA/3WCAaDkUg0k8loXQgA3SEAA5bj9XodDsOcdSSuDo8//vjTTjvdWJuy cLgRgKmSY3Aul/P7/SVJ0rqcbY2MjCxbtmzNmteNEoNFBmZbLADbIwAD1tLXJ9Kv wxBhUkT0H//4xJNPPlnrQqYmnU4nk0miL4BdM7qKNR4XsS2XzWpdyzhSqdTy5ctf eeVlQ8RgEdoTiUQwGNK6EAA6QgAGLMQo6VdcV51yyik/+tEJWhcyNSL3iktDrasA YHjyUHA+l/MPD0vFotbljEO81j3yyMMvvfSS/icTBYPBcDiS1eW7CQA0QQAGrMLj 8TidDp1frNTV1Z966qnf/e53tS5kahKJBCvNAFSXPBQcCoVGw5suJ5WIGLxixYrV q1fpfDS4sh44ksmQgQGMIgADluB29zocjvr6eq0L2SEjRt9yuRyPx3P627EGgDls HgrO54eHh4uFgtbljE8eDX7xxRf1HINFBuZsJAAyAjBgfi6Xs7u7W7dHB9lstv/6 r/8y1oTnYrEoom9Rl1MTAZjM5nOSwuFMJlPW667yIgY/+OADr776qj5jsHi5jkaj ZGAANQRgwAr6+rwul0vrKsYxbdq0E0/8ySmnnKJ1IVPAyUYA1Kfzc5LGiJfHBx5Y tmbNGh3G4EwmE43GxF+g1oUA0BgBGDA5j8fT0+OSj5rUDxEgv//97//iF7/UupAp SKVSyWRS6yoAWJfOz0kaE4/H+/uXvPXWW3qLwZUNscLZrH7fQQCgAn1dEwOoLoej 2+VyNTU1aV3Ie0T0PeaYY37zm3N0vh3XuMrlsqhf/jh2Y0d3al0sAHOSN8fS+VCw ICpcsmTxxo2b6ur08movSVIkEmEiNGBxBGDAzHQ1+Vlcefzf//v/LrjgAt2uRlba 9jl5R/lZ60oB6JohNseSbdy4ccmSJaFQUCcn8CWTyXg8EQwGtS4EgGYIwIBpORzd vb29DQ0NWhcyGn0PPfTQSy+9rLu7W+tajGqSyZnwDFjH5s2xIpFsOq3zn/21a9f0 9/eLxK75ehzxUhkKhRgEBqyMAAyYlh6Gf8Wlxh577Llo0aIZM2ZoW4mVbROVJxiI 1rpSAFMztjnW6HHB+j6NXLzCPPPMMytWPKJ5Bh4ZGUkkEsFgSNsyAGiFAAyY1n77 7Wu32zUsoL6+/vzzf/uFL3xBwxqwmybIzAw7AxqSo698O5fLiQCcz+drdL/7QDab feih5atWrdLwXHr5/YLhYbaDBiyKAAyYk8vl9Hq9Wr3RLhLRd7/7vTPOOEOT3qG5 ckVpK+P+ka3CgKkay73iRjQaFR+LhYLh3oQS+XPx4ns2btyo1W6IwWCQWdCAZRGA AXPq7e31eNzq9yuuww4++KPXXHNNW1ub+r3D6Erj2SY8a10joLatB3vF7XAkUqzk XqO/hfTaa6/19/eXShqc5zQykqzMgmYrLMCKCMCAOWmyALihoeHKK688/PBPqNwv rGzczLxNfta6RmDKtgm90Wi0WCEVi9oWVl35fP6RRx5+9tlnVZ4Rnc1mI5FoIMAs aMCKCMCAOc2c+UE1TxuSJOnYY48799xzVesR2DVbjyeL5+3WUVn+o9YFwrrGDb3i aSlCr7nfx/H5fHfffVcoFFJt2Y74iw0GQ8PDw+p0B0BXCMCAOR1wwP6qvaEursw+ 9KH9v/3tbx111Bc03NcEqLqxtLx1VN76ttYFwti2TrzyHyORyFjo1bAwlcVisb/9 7W/PP/+cmjnf5/MTgAFrIgADJuR0Ovv6NNgBS1yzNTe3zJ59wKc//emjjjqqt1eD RciAJuSoPJaN5RtjH7WuDnqxfeKNRqOSrFi0zlsq4jvdsGHDq6++8tZb/w4EAjbb NJvNpnINBGDAsgjAgAmJADx9ep+2Ncj7AHd2dh5wwOyPf/xjn/rU/+EoYKCm8j6R TM7GYzfMPcfVssYZ441GS2PPAcu8OSK+8YGBgXXr1r3zzjvDw37xx7q6Om1L8vl8 nIQEWBMBGDAhPQTg7YmrvcbGxj322GPmzFmzZ88+7LDD9tlnH62LAvRIGo91hgeN a5u4W1PZ5Gks8ZYs848o/h42bdr0xhtvDA4O+v3+RCJRU1PW6sSjHWEEGLAsAjBg TgcddKD6M8qmSlwRikui9vb2vfba64Mf/OCsWR866KCDZsyYof/KAW2RkPVg+7i7 9QCvPBXe9AP7IuGLlDswsH5wcMjv90Ui0Xw+Z6vQurSdIAADlkUABsxJzU2wqku+ iG9qana73dOnT+/r6xPxeObMmfvvv7+a+1oDhrZ5I6XRhaXFsYSsdVHGNu7objQW K1WGdiWzx91UKrVhwwaRdUOhUDgcjkajqVRSPLsMkXXHRQAGLIsADJjTfvvta7fb ta6imuRNhmpra5uamlyuHq939KBjEZA/8IE9hH322aelpUXrGgFj2CYeF620/dJk bJ91xevPe3G3knXNd8R0JpPx+/2BQEBE3EgkEo/HY7GYnHLFZ8Vrr/obKypH/BOL b5M1wIA1mee1DMDW+vpG86HWVahHXImK63ibzVZfX9/c3OJyOXt6eru7u51Oh9vt 6evrmz59usjJBh0VB1QjfpTGUvHYR5Mlva2Nm3VHN2d+f9Y1+hsE4jsKBoPh8Ojg rYi1icSITORbEezFdyfCrd7W6CoqnU7HYnGR9rUuBIAGCMCAOfX29ng8Hq2r0JdK SBbXeTV1dXX19Q3NzU0ul8vhcLa3t3d2dnZ1dbpcPUJvb6/b7e7o6NC6XkB3ihVy MDZcNt5h1o1Gxw52NtY+ValUKrZFIpFIJpMi14lMKxPfmvwPJMKtzWYz0/jt7gsG g5FINJPJaF0IAA3wagiYU2Xk0635ORPGJV8My8vbRFpubGzorLDbWwWRmdva2rpE aO7s7K4QsVl8tNQQCrC1rYOxttl4+6Bbs9Uc5vJWQVc/WVdUIiJrPB7fMjA7mmKz WRHQxH9p8T+RbLPZbKFQFKXLf7HGXXyrBywABqyMAAyYltVmQWtOXqUs37bZRBYe nY8twnNnZ4fIzC0tLU1NzXa7vbl59KO4p62ttaOjs6OjQyRnEaflgK3ttwAoYetU LN+oVsvjZt33BV211uuKjCpSq4ip8jCsUAmuIrRmRT0iyubzhdwoEWiz8gnQlaJG XzEYoVWZ+MeKRmPMfwYsi1dbwLRE+vV6PVxUGcjWEbpyTVwrropH52vX1wnt7R0i OTdt0Txq9KO4KdK1SNTis+KGyNKVdN0mD1Nr+x0BE5DXG2+djXe0VfVEg7qVCczv xd3JDeqKL5SHVTNySM1mx9Jpfgvx58JmefkBokCRXcd6kWcX11QGY3mlNZBgMCgC cHq7ZxQAi+D1GjCzffedIbKQ1lVAVZWL87K4OJ9WYXtPbV1drSCisYjKIlE3NIxO 7RYfRMIey9WNjY1ytG5p2TxYLefqsYzNYVRQlHj6plIp8VEEzpFkUtwQWTQej/uH hzOVvFoJrqlcNlcZXBWPyssZNZ8viAgtbokPW25I4n7xiC3znUvl8uahYPkj8dWC xBMlHA6z/zNgZbziA2bm8bhdLhfrxFBF5Qp5BGzaFnKE2Hpqq3y/3d46Y8YMEbO1 qxf6YrPVhkLBgYENIqJuk0Vra2vlWcFbj+KOPcc0qxjmwvZXAPiNApgcK4EBAKjZ fPpRLBAIal0IAC0RgAGTc7mc3d3dTFsFAFhZsViMRqODg0NaFwJAYwRgwPzc7l6H w1FfX691IQAAaCMYDJJ+AdQQgAGL8Hg8TqeDU2oBABbE0l8AYwjAgFWQgQEAFlRJ v5FMJqt1IQB0gQAMWIjH4+7u7mYuNADACsrlcigU4tRfAFsjAAPW4na729vbWlpa tC4EAAAFsesVgHERgAHLcTqdjY0N4iNHawIATCmTySQSIz6fT+tCAOgOl7+ARXk8 nvb2No5HAgCYiTzwm8/ng8GQ1rUA0CMCMGBdbndvbW1tZ2cnq4IBAEZXLpeTyWQ6 nfb5/FrXAkC/CMCA1ckzoonBAACDKpVKIvemUmnmPAPYKQIwgFEOR3dTU1Nra1tz c5PWtQAAMCmSJEUikUKhEAgEta4FgDEQgAG8T09PT319XXd3NycGAwD0qVwu53K5 kZGRXC4fCrHWF8AUEIABjMPlcjY0NDQ3N7e0tNhsNq3LAQBgVD6fj8fjDPkC2GUE YAATcTodtaPqurpYJAwA0ECpVMrl8snkSKFQtNmm+f3DWlcEwMAIwAAmxe3uFZcg IgO3tLQ0NTUxQRoAoJxyuVwoFOLxeLFYLJXKwSDjvQCqgwAMYMpcLue0abb6+rrm 5mYRhuvq6rSuCABgeCL05vP5RCJRLEqlksRBvgCUQAAGsLtEHrbZbCIG2+32xsZG BocBAJMhD/OK0JvJZIoi9UoldrQCoDQCMIBqcrt7xRVMJQ/XNjc319fXNzQ0TJvG Sw0AYPTUIhF3k8mkSLsi/5ZKJYZ5AaiMq1IAynI6HSIPT5s2Gokr86VFJK5nlBgA zK1cLstxN5VKbYm75UIhH4vFtS4NgKURgAFowOVyTauQU3FtbV19fZ3AWDEAGE6p VCoWi4VCMZ0WWbdYU0m/AqO7AHSIa00AeuF0OqZNGx0trrw0lUUebmlpER9FPBYf tK4OACxNHtEtVlSW7EqV+8R/JfGRtbsAjIIADMAAHI7RedRbsnHNlnHj9zB0DAC7 ScTZyk5UQqlUkrLZbCXlbh7OFUE3FAprXSMA7C4uGQEYnsvlFB/lOdVbXtZGB5Cb m5tFNha5mZAMwOLk8VtpS7qVd12Wp9vIny2VRj+EwxGtKwUAZXE5CMASHI5ukYTf i8mjNk+0bmpqsm0hB+bKIwFA70YHaiuBdkwmk5Wk4thbgeXN8baG3acAQEYABoBt yTOuKzl567RcI19H1teLzNwsPi9H5WmVhcuMMAPYHfIIbUkeh92snM1mCoWi/Fok P6rySPnho+k3HGZOMgBMDZdrAFAd8kzsLZl52lbXrLLRi1Z5wLkyCi1n52ljEVq+ oUHdAHabnFrH/VhZSVvc8sDNU45r3sux8j5SZaIsAKiDiy0A0IvKPtijxAXx+1N0 eevxn5rKpXNlIFrO0u8R92hWPWBY+XxekqTyVkRq3TL0Khv7AZy2ZV5xzdgEY/Ff bW2t3z+sfuUAgKkiAAOAeVRGoUcv0N8/mDzt/VMot83SgojTTqeTIWgYVzqdTqVS 7x9rlZW3+uN7a2LHPivU1dURXwHAIrjWAQDU9I7qUWj3r/3226+9vb2KjWez2Wo1 BTWJ2Llu3T8lSVKi8ZGRkURiJBgMKtE4AMA0CMAAgNEA7PG4lWjZ7Xb/4Q93OByO urq6arU5PMxgnVEtXrz49ttvU+KtFgIwAGAyCMAAAAUD8N57771s2QPVbZMAbFwP PfTQtddeo0QATiaT8XiCAAwAmBgBGACgYAAuFouvv76mig1KkhQKharYINS0cOHC J598QomWxbNiZGREZGAlGgcAmAYBGABQ09fndblcSrRss9leeunlKjaYy+VisVgV G4Sabrzxxvvvv6+2trbqLadS6Xg8FggwAgwAmAgBGABQM2PGjLa2ViVa7urqeuKJ J6vYYCqVSiaTVWwQalq6dOktt9ysxBToXC4XDkcCgUDVWwYAmAkBGABQM2vWTIXO ED7ooA/fcccdVWwwHo+zC7RxPfHEXy+99NKtjyGqFkmSRPodHiYAAwAmQgAGAKtz u3tdLpcSs1KF4477+rx586rYYCgUUugcHahg7dq1Z589T6G3MHw+HwEYADAxAjAA WF1Pj8vr9SrU+Pz558+ZM6eKDbIFtKElEonTTz99cHCTEo37fH6eHgCAiRGAAcDq ent7PB6PQo0/8siKvr6+KjZIwjG6//mfX7322mtKtBwMBiORSCbDDHkAwA4RgAHA 6pQ7A0mSpNdee726bRKAjW7BggUrV/5NiZYrRwHHg0FOyQIA7BABGACszkBnIBWL xXA4XMUGob7rr79u2bJldXV1VW85k8lEo1FOQgIATIAADABWN3PmB5ubm5Vo2evt W7FiRRUbzGaz8Xi8ig1Cfffdd99NN/1eiZOQisViMBhkHywAwAQIwABgaYpuAf3p T3/mqquuqmKDIyMj6XS6ig1CfStXrrz44osU2sqbjaABABMjAAOApblczupuUrW1 n/zkJ6ec8tMqNhiNRvP5fBUbhPrWr19/xhm/TCaTSjTORtAAgIkRgAHA0pTbAUu4 7bbbDz744Co2GAgEyuVyFRuE+sS/4E9/esq7776rROOVjaCjmUxGicYBACZAAAYA S1NuByxJkl599R/VXerJ4J45zJ8///nnn1Oi5VQqFYvFRQxWonEAgAkQgAHA0vbd d0Zra6tCjb/yyqvVbZAAbA7XXHPNQw8tV2LleS6XC4cjgQDLgAEA4yMAA4Cl7b// hxoaGpRouepbQEuSFApxxKsZLF269JZbblZiI+hyuewfXQXMGyUAgPERgAHAupxO 5/TpSu2AdcQRn7viiiuq2CBnIJnGs88+e8EFF5RKCm0EzT5YAIAdIgADgHUpugPW aaed9v3v/6CKDXIGkmkEg8Ff/OJ0hVbqVvbBimQyWSUaBwAYHQEYAKxLuR2whPvv X7bPPvtUsUGRagqFQhUbhIZ++ctfrF27VomWU6lUPB4PBNgHCwAwDgIwAFjXvvvu 29pqV6LlYrH4+utrqtsm81rNZMGCBStX/k2JltkHCwAwAQIwAFjX7NkH1NXVKdFy Q0PDCy+sqm6bBGAzueWWW/r7lyixEXQNy4ABADtGAAYAi3K5XH19XoUanz179p13 3lXdNok0ZvLYY/+7aNEihRonAAMAdoQADAAW1dvb4/F4FGr8hz/80amnnlrFBvP5 fDQarWKD0NYzzzzzu9/9VqHGg8Hg4OCQQo0DAAyNAAwAFqXoDlh33nnX7Nmzq9hg KpVKJpNVbBDaSqdTc+bMUWgKdCqVfuutt5RoGQBgdARgALCoWbNmNjU1KdGyEjtg RaPRfD5f3TahraOOOlKhliVJ8vl8oVBYofYBAMZFAAYAK3K5nF6vd9o0RX4LiFz9 3HPPV7fNQCBQLper2ya0ddJJPxkYGFCo8aEhHxtBAwC2RwAGACvq7e31eNwKNf7R j3701ltvq26b7GlkPjfccMPy5Q8q1DjLgAEA4yIAA4AVKboA+LTTTvv+939QxQbL 5TKjeebzxhtvnHbafyvUeCqVeuutfyvUOADAuAjAAGBFM2fObG5WZAGwCKt//vNf enp6qthmLpeLxWJVbBB6IEnSUUcdqdA+WCwDBgCMiwAMAJbjdDr7+pRaAFwqlf7x j9eq22YymUylUtVtE3rw1a/OyWazCjXOMmAAwPYIwABgOYouAN5jjz2XL19e3TYj kUihUKhum9CDefPOevnllxVqnGXAAIDtEYABwHIUXQB87LHHnn32b6rbJjtgmdUT TzxxySULFWo8k8m++eabCjUOADAoAjAAWM4BB+xfX1+vUON//OOdBx54YHXbJACb VTqd+spXvlJXV6dE46VSyefzB4NBJRoHABgUARgArMXlcvX1eRVqXIkFwMViMRxm KyPT+vKXv6Tc/HZmQQMAtkEABgBrUXT+s9frXbHiT9VtM51Oj4yMVLdN6MeZZ/76 1VdfVajxZDL573+/rVDjAAAjIgADgLV88IMfbGlpVqjxuXOPOffcc6vbZjQazefz 1W0T+vHEE3+95JJLFGq8WCz6/cOhUEih9gEAhkMABgALcbmcXq9SByAJf/jDHR/+ 8Ier2yYLgM0tnU7NmTNHodOABZ/PNzzMYUgAgM0IwABgIYrOf1ZiAXANAdgC5s79 aiaTUahxlgEDALZGAAYAC9lvv33tdrtCje+9997Llj1Q3TbZAcsKFiy4YOXKlQo1 XigUAoFAMMgsaADAKAIwAFiFy+X0eDw2m02h9k844cc/+9nPqtsmO2BZwbp1604/ /TTl2mcWNABgDAEYAKxC0fnP5XL5L395vOrtswOWFZRKpSOP/H/KLQNmFjQAYAwB GACsQtH5zzab7aWXXq56sywAtoiTTvrJwMCAQo0Xi0Wfz89cegBADQEYACzC5XJ5 vR7l9n/++McPu/HGG6veLAHYIpYvf/CGG25Qrn0GgQEAMgIwAFhCX1+fy+VUrv1r r73uk5/8ZHXbzOfz0Wi0um1Cn5LJ5Ny5X1VuFnQymfr3v/+tUOMAAAMhAAOAJcya NbOpqUmhxhU6ACmRSCh3Og705phjjkmnUwo1LkmS3+9nL2gAAAEYAMyvp8fl9XqV a3/mzFlLliyperPBYFBE66o3C3265pqrV6xYoVz7zIIGANQQgAHAChTd/1k466x5 X//616veLAuALUX8cx9//HeUmwWdy+V8Pl8sFleofQCAIRCAAcDknE6nx+NWLldI kvTKK69WvX3RbCjEhFVrmTNnTi6XVajxcrkcDIaGhhgEBgBLIwADgMkpPfw7Y8aM ++67v+rNplKpZDJZ9WahZ1dfffWf/qTgLGi2wgIAEIABwMzc7t7Ozk7ltr+qUWz+ cyQSKRQKVW8WehYMBr/97W8pN1uhVCr5/f5AIKhQ+wAA/SMAA4CZeb3enh4Fh38V mv9cwwJgq/rqV+dks0rNgq5hKywAsDwCMACY2X777Wu325Vsf7+lS++terOlUkkE lao3C/37/e9vfOCBB5Rrv1gsDg8Pcx4SAFgWARgATMvjcff09EybpuBL/e9+d8GX vvSlqjfLAmDLisVixx13rHKzoGtGB4FDg4ODyrUPANAzAjAAmNaMGfu0tbUp136p VPrHP15TouVwOFwsFpVoGfr3wx/+wOfzKdd+oVAIBAIMAgOANRGAAcCcXC6X1+tR dPj3kEMOufnmW5RomQXAVvbYY/+7aNEiRbtgEBgALIsADADmpPTpR+Vy+c477zrw wAOr3nKxWAyHw1VvFkaRzWa/8pWv2GwKXqIUCoXh4QAHTQOABRGAAcCE3G53T4/L ZrMp10V9ff2qVauVaDmZTKZSKSVahlHMm3fWyy+/rGgXbAcNANZEAAYAE1J69a/w zW9+69e//rUSLYtkUiqVlGgZRjEwMPDjH5+g6FZYrAQGAGsiAAOA2bjd7t5eZTd/ liRp9eoXGxsblWicBcAQjjlmbjqdVrQLBoEBwIIIwABgNvvuO6O1tVXRLg466KA7 7vijEi3n8/loNKpEyzCW/qVLb7/tVkW7KBalcDjk8/kV7QUAoCsEYAAwFa/X09PT o2gX5XL5rrvunj17thKNx2KxXC6nRMswlkAwePx3vq3oOnZhZGTk7bffUbQLAICu EIABwDzc7t6Ojo7m5mZFe2ltbVu5cqVCjTP/GbJYPH755ZevXvWCor2USqVgMKTo scMAAF0hAAOAeSh99JHs178+85vf/KYSLUuSxMk0kBUKhYENG04+6Sd1dXWKdpRO ZxKJuN/POy8AYAkEYAAwCZfL2dPTU19fr2gv06ZNe/nlVxRqfGRkROl9j2AgsXj8 V2ecsXHjBkV7KZfLoVCI3bAAwCIIwABgEuoM/x5zzNfOOecchRoPBAIijSjUOAxH BODVq1YtXLiwrk7B85BqNh+JFBQU7QUAoAcEYAAwA4/H3dOj7NFHNZUFk6tWrVbo 9KMaFgDj/UQAHhoaunDBBSpMjOdIJACwCAIwABiew9HtdDqV3vtK+PznP3/ppZcp 1HgqlUomkwo1DiMSAXg4EFi3du11111bW6vsIHCpVAqFwiJvK9oLAEBzBGAAMLy+ vj6Xy6l0L5IkPfvsc8qdMBwMBkUIUahxGFGhUBAZeNPGjRdffHE8HlO6u1wuJzIw E6EBwNwIwABgbG63W6RfpcfHhE9+8lPXXnutcu0z/xnbEwF4YGDgrX/966abfq/0 mcA1TIQGAAsgAAOAgXV2dvT09LS0tCjdUbFYXLny752dnQq1z/xnjGt0BHjTpkI+ v3DhxbGY4oPAkiSFwxEmQgOAiRGAAcDA1Jn8LHz605++6qqrlWuf+c8YlwjAPp8v m8msX7/++uuvU2GmQy6Xi0ajHAsMAGZFAAYAo3K73T09LhXmhSq9+reG+c/YARGA A4FAqjI74IorrggGAyp0OjIy8vbb76jQEQBAfQRgADAkp9PhdDqbmppU6OvII4+6 +OKLlWs/mUymUinl2odxje2DJW4PDQ1deeUiFQaBS6VSOBxmMTAAmBIBGAAMqa/P 63K5VOhIkqTVq19U7uxfIRAIlMtl5dqHoYkAvGFgQDwPxe3f//7G9evXq9CpCN6R SMTn86vQFwBATQRgADAekX6dTue0aWq8hn/ve987/fRfKNd+sVgMh8PKtQ+jEwF4 cHAwn8uN3o7FFiy4oK6uToV+M5lMKBTmyQkAJkMABgCDcbt7RfpVJwOIXlavflHR LkSkyVWyDTAuEYD9fn8mnZb/eP/99734orLPyTGcigQA5kMABgAjcTi6Rfptbm5W oa9yubxgwYKjj/6Sor2w/RUmVigUorHY4KZN8h+z2ez8+eepM/2BxcAAYD4EYAAw EtWW/lb66nvkkRWKdpHJZBKJhKJdwARi8fj6d98dWyj+3HPPLV/+oDoZuFgsRiKR oSGfCn0BAFRAAAYAw1Az/RaL0sMPP7zXXnsp2gvH/2IyRADeuHFjsVCQ/yiS8CWX XBKLRdXpPZvNxmIxTgYGAHMgAAOAMXg8HpfLqcKpv7JPf/rTV111taJdSJIUCoUU 7QLmIALw0NBQLpsdu2dwcPDKKxepsxJeSKVSIgMHgzxdAcDwCMAAYABut9vh6K6v r1enu3K5vHr1i0p3x/ZXmCQRgIcDgXQyufWd99xz9+uvv65OAeInIhQKsRgYAEyA AAwAeud293Z0dKiz8VVN5Vr/zDPP+uY3v6l0R2x/hUkqFAoiA2/auHHrO1Op1IIF F6h2gjQbYgGAORCAAUDXRPq12+1tbW2q9bjnnns++OBypXtJJpMiwCjdC0xDBOAN AwOSJG195z/+8Y+7776rtrZWnRqKxWI0GiUDA4ChEYABQNfU3PiqprIu94knnnQ6 nUp3xPAvpkQE4MHBwfx2c+ZvvPGGgYEB1coYPZMpGhsaIgMDgFERgAFAv1ROv8K3 v/2dX/3qV0r3ks1m4/G40r3ATEQA9g8PZ7abNSCeSBdeuEC1zeGEXC4Xi8V8Pr9q PQIAqogADAA65fWK9OtU57BTWXt7+9NP/02FjgKBgGpLN2EOo8uAY7FNmzZt/6lV q1bdf/99ambgTCYbj3MwEgAYEgEYAPTI4/E4nQ7VFjfWVCY/r1ix4gMf2EPpjvL5 fDSq0gmuMJNYPD4wMFB6/zJg2U03/f7dd99Vs5h0Op1IJMjAAGA4BGAA0B2Px93d rd6hRzWVnZ+/973v/eIXv1Shr1AoJI2XYYCJ7WgZsCCy6IUXXqjibInRH5lUSmTg eCAQVK9XAMBuIwADgL643b0i/TY0NKjZqdfrXbHiTyp0VCwWw+GwCh3BfHa0DFj2 2muv3XnnH+vq6lSrR2TgZDIpns+xGAvaAcAwCMAAoCMi/XZ1dTU2NqrZqSRJTz75 lMPhUKEvhn+xy8Y9DXhr/f1LXn31VTVLEhlYPKU5GAkADIQADAB6IdJvR0dnc3OT mp2WSqV5887+xje+oUJfDP9iN02wDLimsj/z5ZdfNjIyomZJ4idIPKvJwABgFARg ANCFnp6ezs6OlpYWlfs9+OCDb7vtdnX6YvgXu2mCZcAy8dkrr1yk5kToGjIwABgK ARgAtOd297a1tdntdpX7ra+vf+6559XZa5rNn7H7RAAeHh5O72AZsGzlypWPPPKw mqci1VTWEUQiETIwAOgfARgANKZV+hWX7EuW9O+///7qdBcMBkulkjp9wax2ugxY duedf/znP/+pTkljyMAAYAgEYADQkki/rRUq91sul3/+81NPOOEEdbrLZDKJREKd vmBuIgBv2LBBKhYneEwul7viisvVf8qRgQFA/wjAAKAZrdKvcMghh958882qdTc8 PKxaXzA3EYCHhoZy2ezED/P7/YsWXaHyROgaMjAA6B4BGAC0IdKv3d7a1qZB+rXb 7X//+zOqdTcyMpJOp1XrDuYmAnAgEEglkzt95CuvvLJ48T3qLHHfGhkYAPSMAAwA GtAw/ZZKpcce+7Pb7VatR4Z/UUXyMuDBTZvK5fJOH/zQQw89++wz06apfbVDBgYA 3SIAA4DaNJz5XCwWFy268vOf/7xqPUaj0Xw+r1p3sILRfbA2bSpM4nklgujtt9/+ 9tv/VqGq7bsmAwOADhGAAUBVGqbfcrn8gx/88LTTTlOtR5G3w+Gwat3BIkQA9g8P ZyY8DGlMJpO5+uqrYrGY0lVtjwwMADpEAAYA9Wh14pHssMMOu+GGG9XskaOPoIRJ HoY0JhAILFp0haIl7QgZGAD0hgAMACrp6enp6GjXKv329fU98sgKNXtMpVLJSexU BOwCEYA3btxYLBQm+fg333zzllturqurU7SqcZGBAUBXCMAAoIZK+u2w21s06b2+ vv7JJ59SOXuz9xWUIwKwz+/PTmV38RdffLG/fwkZGAAsjgAMAIpzu3vb29tbWrRJ v+VyzYoVK/r6+tTsNBwOF4tFNXuEpYzOgo7FNm3aNKWveuKJv/7v//6v+gcj1VR2 Xxc/FGRgANAcARgAlCXSb0dHR3Nzsya9S5J0xx1/PPjgg9XsNJPJJBIJNXuEBcXi 8Q0bNkhTfJ/lgQeWvfDCC+ofjFRTycChUHhoiAwMAFoiAAOAgirpt7O5uUmT3ovF 4sKFl3zxi19UuV8mP0MFo7Ogfb5sJjOlrxI/FHffffcbb6xTqKqJiQycqvD7+RkB AG0QgAFAKSL9dnZ2NjVpk37FpfbPfvazE0/8icr9MvkZ6ti1WdBCLpe7+eabBwen /IVVQQYGAG0RgAFAEW63u7OzQ6v0Wy6Xv/rVr86ff77K/bLzM9Q0uhf0hg278IaL eKLeeOMNoVBIiap2Svx4JpOjPytkYABQHwEYAKpPpN+urs7GxkZNeheX10ccccSi RVeq328gEFC5U1iZCMB+vz8zlb2gx8Tj8euvv06rxerih0V+t4gMDAAqIwADQJW5 3b1dXV1apV/hox/9j1tvvVX9foPBYKlUUr9fWNboLOh4fNPGjbv25cPD/muvva5Y nOxhwtUlZ+BEYoS3jQBATQRgAKgmzdPvrFmzFi9eon6/iUQiM8XtiIDdNxqAN20q 5PO79uXia6+//jqRRatb1SRVMnBa/OyQgQFANQRgAKgakX7/f3v3Ah9XWed/fJKZ SWYmt0kyl1xKLZZaWIQCCrLrH1RoQQVBXou6+lqR/y6goqvorgKKXBRdEJCirvQC 0kKRi4qK/kUXUJEVb6u20NLSNqWXzEwyM0lmkrlmbv9n5jTTIU3TtDnPOTNzPu+X DqfT5PecpMmc5zvPc56nq6urqalJrxNYsGDBT3/6M+3bzWQyo6Oj2rcLiAA8HAwm 5nHn+cDAwJo1qxsbG1U8q7kTGTiRSESjZGAA0AgBGADUoXv6bWtr+/Wvf2M2m7Vv mn2PoJdMJhMdH/cNDs5n+v22bdseeOC7ZGAAMAICMACoQPf063C0PPvss7osOh0O h3O5nPbtAopINOr3+9Op1HyKvPzyy+vWrTObycAAUOcIwAAwX7qnX5F7n332Vw6H Q/umufUXujvqDYGn2bx584MPPqhjBo7HE7HYBOtCA4BUBGAAmBfdV73SMf2m02kR PLRvF5hmnkthlW3e/FIpA+twH4GJ/YEBQBMEYAA4eiL9Op1OXSYeK5qamp555tm2 tjZdWufWX1SJ4jJsY2N+n2/+pV588cUNGx7SMQOHw2Gfz69L6wBgBARgADhKIv12 dHTY7Xa9TkDf9Muuv6gqkWh07969uWx2/qX0zcDi1yocHvH7ycAAIAUBGACOhsfj cTo7dJl4rNA3/Y6OjmYyGV2aBmZU3A9peDgRj6tSTfcMPDIywjgwAMhAAAaAI+Z2 u5xOZ0tLi14noG/6ZeErVKH9+yH5fHmV1iTXNwPncrnR0VEyMACojgAMAEesv7/P 7Xbr1Xpzs+3pp5/WK/2K6CsCsC5NA7OLRKNDQ0PJREKtglu2bF6/fj0ZGADqCQEY AI6MvunXZrM/++yzek29Fj3ycDisS9PAYRX3Q4pG/T6finenl/YHfkCvDCy+orGx CPcDA4CKCMAAcARE+nW5XA0N+rx42u32Z57RLf2aWPYZVU/1QWBh69atIgM3Nuqz P/Dk5OTY2FggMKRL6wBQfwjAADBXfX19brdu6belpfWZZ57Rccslln1G9ds/COz3 q3UnsOKVV1554IHv6vW7n0qlIpEImwMDgCoIwAAwJ729PS6XS6+ZkE6n85e//O+m piZdWhfC4XBO1UQBSKLuctBlAwMDa9eu0SsDx+OJsbExbkAAgPkjAAPA4fX0eLu6 uvTKnwsWHPPjH/9Yr+xtYtMj1BRlOWi/36/KnsCVdu3add999xUKOsyDKBQKIv2y IBYAzB8BGAAOw+VydXV16nXn7bHHHvvDHz6h17iTEIlE0um0Xq0DR0Fk4NGxMb/P p3rlPXv23Hff2qza0Xou2BwYAFRBAAaAw9Bx2eelS49/5JFHdEy/bPmLGhWJRn0+ 36SE924GBwdXr16dzeowJ0IE75GR0UAgoH3TAFA3CMAAMBsdl30+8cQTN2x4WPt2 y2KxWFztGykBbSirYfkGBwuFgurFRQS9//77dPntYEEsAJgnAjAAHFJPT4/brc/C V8uWnbJu3Trt2y0TnXsRgHU8AWCeZGyJVDYyMrJ69aqJiQkZxWcnGh0Y2KV9uwBQ HwjAADAzl8vV3d1lt9u1b/rNb37z2rX3ad9uWTKZHB8f1/EEgPlTVsMKBAJZOUu4 jY6OrlmzOhqNyig+C24GBoD5IAADwMz0uvX3LW85c9WqVdq3W5ZKpbTv0wMyiAw8 Fon4fT4ZE6FNpSXiVq26V/vfl+IqX6OjgcCQxu0CQB0gAAPADHp7ez0et/a3/uqe ftPptOjT63gCgLqkToQ26ZeB4/H4jh07NW4UAOoAARgApnO5XG63q7m5WeN2Sb+A 6pSJ0EOBgLy9rHXJwOwMDABHhwAMANPpMvmZ9AtIsn9FaJ+vkM9LakKXDJzNZkUG ZkVoADgiBGAAeI3e3h6Px6Px5GfSLyCVCMDDwWBC5sLm4jfo29/+djyu6drprAgN AEeKAAwABzidHV6vV+OVn0899dTvfvcBLVuchvSLuqdMhA4Gg+lUSl4rov63vvWt bFbWXOuD5fP5cHjE72ciNADMFQEYAA7QfvLz0qXHP/roo1q2OA1rPsMglInQQ0ND knZFUgwODt5773fy0uZaHyydTofD4VAorFmLAFDTCMAAsJ/b7fJ6vRaLRbMWFy1a 9MQTP9J+reky9vuFoRQzcCTi9/ulBtQ9e/aIDKzZ73VpNawRn8+nTXMAUOsIwACw n8bDv06n85lnnjWbzZq1OE08Ho/JvCUSqELFHXTHxvyS4+LAwMDq1as0++0WX1Qw GGQQGADmggAMAEW9vT0i/TY2NmrTXFNT83PPPWez2bRp7mAi+ooArFfrgI6KE6GH h5OSf/43bdr08MMbNMvAoVCILZEAYC4IwABQtHjx69va2rRpq1AwPfPM0y6X1jst lU1MTCQSCb1aB/SlzYJYwvPPP//Tnz6pTQbOZnPDw8MiBmvQFgDUNAIwAGi69VEu l3v88cePP/4EDdqaUTQaTUnu9wNVTsnAgUBA6oJYhUJBBOAXXnhBm9cWBoEBYC4I wACg3fBvNpu7++67ly9frkFbMxobG5ucnNSrdaB6KItCFxfEyuXktZLNZh966KHt 21+R10RFWwwCA8DhEYABGJ1mw7+FQuGqqz569dVXy27oUEZHRzMyx7uA2iJ+HcYi Eb/PJ3435bWSSqVWrlwZjWqx1TaDwABwWARgAEan2fDvGWecsXr1Gg0amtHIyEg2 m9WrdaA6abMotMild9zxdQ1uBi4NAg+xHDQAzIIADMDQ3G5XX1+fBsO/Npvtd797 QbNVpqcR/W+pG58CtSsSjQ4PDyckLwq9cePG733vYQ0yMIPAADA7AjAAQ9Nm799c Lvfznz+1YMEC2Q3NKBgMSp3hCdQ0ZUEskRtTyaTUhh577FERg6U2IUxOToo8PzIy KrshAKhRBGAAxuVydff09FoscsdkRPi89trrPvjBD0pt5VBIv8BhKRlY5MbJdFpe K+l0+s4774jFYvKaMJVecMLhMIPAAHAoBGAAxqXN8O/JJy9bv3697FYOls/nWQ8W mCNlUeihoSGpGyP5fL6VK++2WCzymhASicT27TukNgEAtYsADMCgenq8nZ2dzc3N UlsRKfT3v/+Dw+GQ2srBstnsyMiIxo0CNU2bjZGeeOKJP//5T/Lqm0ovOyLJB4O8 /wUAMyAAAzCovr4+j0fu8G+hULjhhi9deumlUls5WDqdjkS02HMFqDMabIwkfj2/ /OVbZC9Kx1JYAHAoBGAABqXB7keLFh37ox/9SGoTB0smk+Pj4xo3CtSNSDQaDAbj Mu/U3bJl84MPPih1TXiR5IeHg+Ew+yEBwHQEYABG5HJ19/b2St2SJJvN/vd/Py1a kdfEweLxuOwldoD6piyIJaJjMpGQ18pdd90pNZ2yFBYAHAoBGIARabD81Vlnnf3N b35TahPTiOgbl7yXKWAEGiwKHQwG77zzDqnvwU1MTAwM7JJXHwBqFAEYgBEtWXJc S0uLvPq5XO6Pf/yT3W6X18Q0orObkDlgBRiKsiBWIBDIZbOSmvjWt77p90scoRWv QoHAELOgAWAaAjAAw3G7XX19fQ0NEl8AzzvvvNtv/7q8+tOMj48nk0nNmgOMQPaC WKFQ6I47vi51EJilsADgYARgAIYje/6zxsO/pF9Akkg0OhwMJqTdV//tb3/L5/NJ Km4qTgyJDQwMyKsPALWIAAzAcGTPfz7//PNvu+12efUrkX4BeWTfDCx7EDibzQYC gZGRUUn1AaAWEYABGIvL5err65W3AYnocf7xj39yOByS6ldi1StANuVmYL/fn8/l ZNS/7bb/jEajMiorRAAeHg7Kqw8ANYcADMBYvF5vb2+PvPonn7xs/fr18uqXJRKJ iYkJDRoCDE7qzsBbtmzZsOEhGZUV3AYMANMQgAEYi9QbgAuFwmOPPb506VJJ9cvS 6XQkEpHdCgCT5InQ+Xz+C1+4Xt6afOK1YuvWbZKKA0AtIgADMJCeHm93d7fVapVU v62t7be/fV5S8TLRYw6FQrJbAVBWnAgdifjkrAj9+OOP/e1vf1O9rEKcsN8f4BUD AMoIwAAMxONx9/X1yat/5ZVXXX311fLqK4LBoKR9WQAcirItcErCmnPj4+O33voV eUthcRswAFQiAAMwEKnzn7PZ7F//+jd5w8uKUCiUz+elNgHgYMpqWL7BQRlvP910 042Tk5Oql1VwGzAAVCIAAzCQxYsXt7W1Siq+ZMmSxx//vqTiikgkkpazHQuAwyou Bx0IpCUMAv/iF7947rnfqF5WIaL1yy9vlVQcAGoOARiAUci+AfiWW7580UUXSSou pFIpqdulAJidMgg8uG+f6pWTyeSNN37JYrGoXtlUug04EAgEg9wGDABFBGAARuF2 u/v7Zd0AnMvlNm7cJG97YWF4eFhecQBzUQzAg4MZCdOVb7jhhlwuq3pZBbcBA0AZ ARiAUUjdAfiYYxY++eSTkooLIyMj2ayszjGAOZK3J/Ajjzzy4oubVC+r4DZgACgj AAMwCqkrYP3rv17xyU9+UlLxZDI5Pj4uqTiAuVP2BPYNDqq+Ft3w8NDdd98taUPg RCKxffsOGZUBoOYQgAEYxdKlS+12m4zKoiv861//pqurS0ZxE5OfgWpSXArL70+n UuqWFS8j1113raTNkHK53L59+yIRFhEAAAIwAGNwu129vb2S7tG1WCx//vP/yqgs RKPRlNpdbQBHLZPJjI6N+X0+1SvfeecdIyMjqpdV+Hz+UIh1sACAAAzAGDwed1+f rBWwTj755PXrH5RUnOFfoNpEotHdu3cX1J4F/bOf/ex3v/sfdWuWsQ4WACgIwAAM wev19Pb2Sip+zTXXfOQjl8uoPDY2NilhvVkA8yFpLehQKHTXXXdKug2YdbAAQEEA BmAI8lbAKhQKv/rVr2XcACwqB4OM2ABVRwTgoaGhZCKhbtl8Pn/ttZ+XtBtwLBbf uXOnjMoAUFsIwAAMYcmS41paWiQV/9vfNsooG4lE0um0jMoA5iOTyYxFIr7BQdUr 33zzTZJ+60XZrVu3yagMALWFAAzAEP7u705oamqSUXnhwtf95Cc/kVGZu3+BqhWJ Rvfs3q36Zkhr167dtWtA3ZqKQqEwODg4MjIqozgA1BACMID6193dvWBBv6Q76y64 4MJbb71V9bKxWCwej6teFoAqJN0G/Pzzz//85/9P3ZplLAQNACYCMAAjkLoE9Fe+ cuuFF16oetlgMFgoFFQvC0AVIgAHAoFUMqlu2Wg0+p//+TVJ79YFAkPMKwEAAjCA +idvCWiRUZ9//n/a2trULZvL5cLhsLo1AahIBOBgMBiPxVSv/LnP/YekdbAIwABg IgADMAJ5ATifz2/a9KLqZcfHx5NqjywBUFEmkynOgt63T/XK1113LTshAYA8BGAA 9U/eHkjNzbY//OEPqpdllAaofsV1sPbsyedy6pa9/fbbIpGIujUVsVhs504pK2wB QA0hAAOof/L2QHrDG5Y+9thj6tZk+1+gJigjwJlMRt2y69ev37Ztq7o1FalUatu2 V2RUBoAaQgAGUP9OOOH45uZmGZVlLAEdj8djEm4sBKAuEYD9fn86lVK37NNPP/2r Xz2rbk1FNpvdvHmLjMoAUEMIwADq30knvdFsNsuo/NnPfvbDH75M3ZojIyOin6pu TQCqEwF4aHg4qfZ2ZS+//PJDDz2obk1FoVDw+fwssAfA4AjAAOqc2+3q7++XVHzN mrWnn366ujW5ARioCZlMZnRszO/zqVs2Ho/feutX1K1ZxlbAAEAABlDn5G0CXCgU Xnjh9w6HQ8Wa+Xye7ilQK8Yikd2vvqp62c9//nOSJq34/QGWGABgcARgAHVO3h5I 2Wz2pZc2q1szlUpFo1F1awKQJBKN7t69u5DPq1tWXgAOBALDwwRgAIZGAAZQ5+QF 4IaGhr/+9W/q1hTpN6X2mjoAJBEBeO/evTm1b9r/4he/kFc7VCsCgSFusgBgcARg wIi6u7saG80NDcUIpzxTKFIO8haLZWiofnpIXq+3t7dHRmW73f7CC79Xt2YoFJLU 8QWguuJOSIODmclJdct+9au3SloKvr4DsNPZYbU2mYrvTpYeStc3cWkT1zVxYDab 6+nSBuCoEYCBOud2uxqKGkU3QCRbkdnKoVewis5CU9PBn5V/rVwun0olS0sTVwbm gnKQzWYikeqdtStvBPiYYxY++eST6tas474pUH9EAPb5fJPptLpl77ln5dDQkLo1 FaFQyOfzy6gsgwi0Fou1YSrOTl27GsqXs8aDTKsgrlCTk5OV6+rn84XS5SxXOs5l MlV9/QIgAwEYqDci8YpOgOgc2Gw2Jd+KP5bzakNFJ0JF+YMkk+XArOTk0kNB+eDc yMio6udwKP39fW63W0bl00477f77v6tuTQIwUENEAA4EAqlkUt2y999//86dO9St qZiYmBgY2CWj8lzMFGiV61GhdM2ym82HCbTzN+1qmMvlREKOxWIiEpf+Jh8KsU0U UOcIwEDNK43xNlqtxbfDm5ubRTdCRsRVV2VUFt2OZDJRej9+f1QWfRDRS1PrVtjF i1/f1tamSqlpzj13+Z133qliQdEVY4tOoIZI2gr4+9///l//+hd1ayri8fiOHTtl VBYXoNbW1oo7axosFrN40my2VMZaGU2rSBkxHh8fz2az4li8Jmv5di0AbVR7LxnA jJzOjqamJqvVKjocIvRWf69idspb8qW51jklFScSifIAcj5fiMUmksmjzMNLlhzX 0tKi7gkrPvCBf7ruuutULJhOpyORiIoFAUglAnAwGIyrfb/uU0899dvfPqduTUUi kdy+fbta1ex2W1tbuxJ4lTnJ5teO4Vb/u7GzUAJwKpVKJpOTkxk2qAPqRg2/MAEG 5Ha7RO612WxKP6Om+xZzpEylFl2Q8k1cyvy1uUfipUvfIL5dMs7t6quvvvLKq1Qs GI/HJa18A0CGTCYzFon4BgfVLfvCCy/89Kcqry+gSKfTW7duO7rPrYy7ChF6W1pa xCWp1t+EPazyyHAmk83n80zVAWpa/feegTqg5F57iaTNIatWeamtfL74oAwRK+/K V9xjvP8usqlP2f95yg1m3d1dzc3NMs7tpptufu9736tiwUgkklZ7NR0AUokAvPvV V9WtuXnz5ocf3qBuTYVI7Fu2vFz5jIi1ra2tU2smK3fnmipeWg+8rlqtFofDUR7j LS6uWMq9RngrtkxcWsT3MBqNisdgkDFhoCYZ6DULqEUej0f0OTo7Oy0Wi97nUkUK FUyl7ld5rl1pVeqsEpJFWE6nU+K7J+ldg29/+7/e+ta3qlgwHA6Lk1axIADZItGo CMD7l/hTyeDg4H/917dVLFhWuql1RLw2Tj2hrD5lK0XaYrYVf1RirXJbSvnraqgg 48RqjvjOpFKpWCzG7Gig5vAqBlQjp7OjpajVbrfR26haP/jBDxcvXqxiQZaABmqO CMB7du9Wd/vueDx+661fUbFgpWw2a5A7aLQhvp+jo2PZLAPCQM3g5Q+oOv39fe3t 7U1NTXRQqtyqVauPPfbYtrY2te4xJgADNUcE4L179qg7d0PE6S984XouATVE/ACM jo4yLxqoCby2AlWkr09E37bm5mb6PdWvUCi0t7c7nZ0dHcXheofDUX4URCpuLREH 4sO6urrEwWHnsROAgZojAvC+ffuymcwRfZZyK2kymZyYmBCPpZWGxf8TqaJ0PB7b tGlT3a8sVX+UbZPEvyyTooFqRicbqAq9vT1KfKLHU9NK22bkGxuLL63mIovVamlq anI6ne3tHXa7TQTk0lpm+w/Ev3lLS6v4d1fSsug2dXZ2iufFp+j9pQCYExGABwcH M5OTpqlYKyKsEmtLyTaVTqeVx8nJ4kP5QDwqW+xM7QBXvOvW9NpFDVCLxD9tNDou /tnD4RG9zwXADHh5BfTX39/X1dVltOWdjUxZXUY53r/yTKO5tPZMQ1tbm8jGymZX VqtVeRSRuLlERGVxXH6ce4unnHKKnC8FqG0bN26c40eKX9tESXK/hJJtRdQZGxsT UTYzRUm85VXrTVOr2ZNsDUX8qExMxAKBgN4nAmA6XoUBPfX09LS3F+8gpUuEQymn ZXGgLMFaXq917kVEum5tbRXR2jalnKJbW1uUidvK/G1l2rZ4lLR5MiCPsipvWSIR j8eLkVUci6NiZk0oc4yLxN+K58sbjM+FEmgr10Y2ld7D4gUcMxI/XWNjkbGxMfGD p/e5ADiAl2xAN319fZ2dTqvVqveJADOoHKY2TW2ComRvJX9bLGYRmJubbSJdW0ua mqzKUHZzc7P4mNIzTcrf2mzNpf9abLbiaLb4dGsF8THiI8WTIpkrjyJTiDyu45eP ozA5OZnNZlKptLJTt3gUz2ReK5fLlu59TYm/Uj6sdJAVH6g8U/4wQRyIR/FXqVQx u2az4u+L/1d+OJUgqrwxZCKIoiqJn89wOCx+tkOhsN7nAmA/LhWAPrxej8C0Z2B2 5d2eK8fcyhNKywcHf6JI6+IDtTrN+lH5fVa+w5XfZCVtljNn+TvP9rDALOLx4jQE pkMDVYLLFaADl8t17rnnbN26lSWvYHDk29rRoCzRNM0s/1jlkEw2BtLpdCQSJQMD 1YBrEqC13t6eRYsWJZNJvU8EAABoJJ/Pj4yM+Hx+vU8EMDoCMKCpvr5el8utbJMD AAAMJRQKpdOT4TC3BAO6oRcOaKe/v6+zs9Niseh9IgAAQB+JRGJ8fGJoaEjvEwEM igAMaMFut3d1dbpcLu6FAwDA4CYnJ0dHx8jAgC7oiwPSldJvl8vVTfoFAABCJpMZ GRklAwPaozsOyMXYLwAAOBgZGNAFPXJAItIvAAA4FDIwoD065YBE/f19pF8AAHAo 3A8MaIx+OSCFzdbc3d3d1dVlNpv1PhcAAFC90ul0NBr1+wN6nwhgCARgQIr+/j63 2633WQAAgBqQzWbD4fDQ0LDeJwLUPwIwoL6+vr6Ojvbm5ma9TwQAANSGiYnYwMCA 3mcB1D8CMKAyt9vV3t7e1tam94kAAIBaEgqFfD6/3mcB1DkCMKAyJj8DAICjkMvl RAZmIjQgFQEYUJNIv06n02q16n0iAACg9sTj8R07dup9FkA9IwADqqm/yc+FQiGf z5f/2NjYyJZOAADdiWuTuEIpx+LCJC5P+p6PupgIDUhFXxZQTU1PflY6Ezabva+v 99hjX3/ccceddtppJ510Umtra/ljJiYmtm/fvm3b1t27d4trs8/nGxoaSqdT4nPJ xgAAdSlvwlqtVnEl6u/vX7jwdQsXLhSXpxNPPFH8sfIjBwYG/vKXv7z88svbt7+y b98+cbUSn1i72xCWJkKH2RkYkIQOK6AOr9fT3d3d1NSk94kcnjKoa7fbjznmGCXr nnzyyaI/MZ+x60AgIIKxiMd79uzds2e33+8X/Y9MJmMqjRurduoAgPqipFyz2eJw 2Ht6esSFacGCBeLadMIJJyxZsmQ+txSJVLxx48bStWnH7t2viqtSNputlVQci8V2 7mRFaEAKAjCgApvN1t3dVZ3Dv7lcTlzvRX/iuONEX2LJm970ppNOOsnhcGjW+u7d u7dt2yY6IoODg3v37vX7fbFYPJvN1N+kNQDAjJSUK17zbTZ7b29vf39fX1//okWL 3vCGNxx//PGVU41kE5ehP/3pT1u2bN66dduePbvj8XjVRuLh4WAgEND7LIA6RAAG VCCu5d3d3VUS50TmtFgsIuueeuppZ5111qmnnqpZ3D0imUxGZONXXnll165dSjYO BPyiL8K4MQDUoqmxXLPdXhzL7e9fILKuSLnieiRSbtUukCGuPs8995sXXvj95s0v RaPR6snD6XR6bGyMFaEB1RGAgflyu90dHe1avoF9MGX+2JvedNoFF1z49re/3el0 6ngy8ye+HL/fX8rGA4ODvuHhYfHHUCiYTCa53xgAdJTL5cQrcFNTU0tLS19f34IF x/T1iZR77HGlWUbNzc16n+B8iRj8858/9dxzz+3du8diseh7MqyGBchAJxKYLx3X vhIdEdEFEaH3sssuW7hwoS7noL1YLDYwMLBjxw7RO/H7A4ODg4GAP5FITE5OFgoF 4jEAzIeyJqLVarXZbF6vV6Tc3t5e5b7c448/3uPx6H2CGhHfh1/+8pff+97DmzZt 0mtYWFzlxWVuZGREl9aBekU3EZgXr9fT2dkpegkatysuzGefffYnP/lvS5cu1bjp Kjc6Orpr165XX3113769ot8QDodDoaB4TKfTjB4DgGlqFFdEXLvd0dvbI4ig29+/ 4HWve92SJUtE4uUmlEri2rF+/fp16x6IRqPaX0EYBAZUR0cQmBfth3/Flfh973v/ Nddco++k6xqVyWT27t0r4vGePXsCgUAwOCwMDQ0lk6nJybSyYBgJGUDtKhQK4qVM JFiLxeJwOFwutwi3LpdLWWB50aJFixcv5vJxdF566aUvfvGLe/fu0fIyIf5BS9cp 7gQGVEM/Dzh6pV5F93w2aTgiok9z6qmn3XHHHcaZgaY98U32+Xy7d+8uzawOhEKh kZFwaRg5nEols9ksw8gA9FIKt+IlqEGE26amJhFru7q6u7qKexCI69GCBcUhXMFu t+t9pvXsySefvPHGL2l5FYjHEzt27NCsOaDu0YcDjpLGWx+J3PUv//Ivn/70Ndo0 h1mIkDw0NLRv3z4RksWBSMg//vFP8vnilEKCMYD5K0w577zz+vr6Sjfi9i9cuFBE 3DpYZaoOxGKxD33og+IqoE1z4ichGAwGAkPaNAfUPfpqwFHyej2iU6LNjVJWa9NX v/rVFStWaNAW5iMcDgdKSjcej4yNjUWj0YmJ8dHR0ZGRkVQqnclMivysDCNzlx1g HMoWQaV3yRqtVqvIsV1dXZ2dne3t7R0dHU5nR1dXt8fjKS86xetD9fvMZz7z61// Spv3PdkSCVARARg4GloO/4qu0le+cuv555+vQVvQ0sTERDAYDIVCIjaPjIRF52Z8 fCISicTjMWFiIiaemZyczGYzIjMrw0ENU/Q+d8C4lJtsi0G2sdFsNiuzkZ1OZ2tr a0tLi3hsaxOZtt3p7BQR1+VyeUrEsd4nDvVdc801zz33G23aYjUsQC30ooCj0d/f J7o1GuSQfD5/+eWXf+Yzn5XdEGpFIpEYHR0VPaFIRATkyHhJrCQ5JZVKJRLxSCSa yWRKA845JUKbSn138chtzDAg5V0kZRhW/FE8mqdYLFYRWUV6bW5uttttdrvDbrcr gbatra2jpLOzs7u72+12i2f0/lJQRd7+9rdFo1ENGpqcnPT7/eKFXYO2gPpGBwg4 Ym63q729XZs+0FvecuaqVas0aAhGUxpknhCPIj/HS0rZOSHis8jYIkJnMqK7lUmn 08X/FP+QzhblxHHpIJtOp0SFfDFe50uKWVukDHFkmkraymP5oBw8GMc2oPJ9raaK H4zyj0T5UXl3RkmnDQ2NZnNxnFW84jY1NVtKrFarxbJ/3FU8Kf6vzCgWBzabyK7i weZwtIgEK+Krw+EQr9WlUdlijtXvq0fdEi+Gp556iviB1KAtBoEBVdD/AI6YZnf/ Lliw4KGHNjidTtkNAXoRCVzJQiJ8iwBtKg1xKxFahHDRszSVbn5TDirN+CTkEf37 g5dfKj8pDpTt0MULo8icpYMGkUKVD2PIFPXtRz/60S233KzBm3rcCQyoggAMHBnN 7v4VGeATn/jkVVddJbshAAAwH+95z4WDg4MaNBQMhvx+BoGBeSEAA0fG6y2uZaLB RhTLlp2ybt062a0AAIB5CoVC55xzjsVilt1QLBbbuXNAditAfSMAA0emv79Pg+Ff u91+772rli1bJrshAAAwf7ffftujjz4qu5VCoeD3+0OhsOyGgDpGAAaOgIi+HR0d ra0tUlvJ5XIXXXTRrbd+VWorAABARW9+85uUtQykYiksYJ4IwMAR0Gb4d8mSJY8/ /n3ZrQAAABVt2rTpsss+rMEamRs3bpLdBFDHCMDAXHk8bqfTqSxwKo+4cN54400X X3yx1FYAAIDqrrjiir/85X9lt8IgMDAfBGBgrrxer8jAZrPcJS7OOOOM1avXSG0C AADIkMvlTjllmextgVOp1LZtr0htAqhjBGBgrkQA7u3tkdpEa2vbunXrFi9eLLUV AAAgyZo1a+699ztSmygUCps2vSi1CaCOEYCBuerv73e7XfLq5/P5c8459+6775bX BAAAkO2UU5Y1NMjtY/t8PtaCBo4OARiYE4/H09nptNvt8pqw2ewrV65csmSJeUpj Y6NyIPs6CgAA1PKd73xn7Vq5dzNxGzBw1OhVA3Pi9Xq8Xq+8pR0LhcKpp5522223 zf5hIglXBuPKqCzpxAAAwFzkp2Qymb//+zOlLhqSTqe3bt0mrz5QxwjAwJzIvwG4 4XOf+9y55547/0LT4jHDyAAAHIX8THK5nHJQKDnU51533XUbN/5N6rm9+OJL8uoD dYwOMTAnsm8APuaYY9auvU9e/UoMIwMAjEaE1RkDbSUVmxsYGLj66o9Lfet5cHAw HB6RVx+oVwRg4PBk7wCcy+UuvPDCT3/6Gkn1jwLDyACAanbYNDvL8Kw23v3ud+fz OXn1uQ0YODr0ZYHD83q9Lle31WqVVN9stnzpS18688wzJdWXpDIYVwZmQjIA4Igc KsFKGp7Vxte+9rXf/vY5efUTicT27Tvk1QfqFf1U4PC8Xk9vb6+8+scee+y9966S V19HlcGYkAwAdU9JrbPPN9Z9bFYbw8PDl132YXnXu2w2t3nzZknFgTpGHxQ4PKkr YFXh/GeNKfcklxNy5SM5GQB0NEuOLf+VQdLs0bngggtyuayk4uI7v2nTi5KKA3WM ziVweP39fW63W1JxkfSuv/76s846W1L9utFYQk4GgKNQGWWnxdrKP+p9mvXmpptu /OMf/yivvs/nC4XC8uoDdYleI3AYHo+ns9Npt9sl1e/v77/vvvuJcGopr3FdTsiV B3yfAdS6ueRYRmWrxNatWz/zGYkzvFgHCzgK9AWBw/B6vR6PW9J29qKb8n/+z1k3 3nijjOKYnQjDM4Zk5YCoDECeaVOIZ5xXTI6tDytWLJfUhRBSqdS2ba9IKg7UK3p4 wGFIvQFY9G+uuuqjl156qaT6UEvj4RCYAUOZttTTLH8kxBrcxz/+sVdffVVS8Vwu 99JLrIMFHBl6bMBhSA3ANpvtrru+sXjxYkn1oRcCM1C1ClMqM+qMfywf633KqGGP PPLI+vXrJBVnHSzgKNADAw6jv7/f7XZJKl7HGyDhSDWUVCbkQx3rfaaAPspxtDKm zp5g9T5lwDQ+Pv6+910q76V7cNAXDrMOFnAE6EgBs/F43E6n0+FwyCguOmdnn/22 G264QUZxGEfDFCUez/FA77NGPSscWmVwnfGPep87oL7zzjtPvPRKKs46WMCRog8E zEb2ClhXXHHl+9//fhnFgaNwcJauVPkBs/+t3l8HXqM8ibcyah72+Vno++UANeej H71qz549koonk6lXXmEdLOAI0E0BZiPyb29vr6TidrvjnnvuWbhwoaT6QDUrZ2ZV HqeVnbGto3tyWt47OP7N/gEz/nEuj3P5AAA14YknfrhmzRpJxVkHCzhSBGBgNlJX wOIGYAAA6p7U24ALrIMFHCECMDCb/v4+t9stqfiyZafcfvvtkooDAIAqIXU34KGi YUnFgfpDAAYOye12dXR0tLa2yiiezWYvuujiT33qUzKKAwCA6vGe91yYyWQkFWcd LOCIEICBQ/J6PV1dXc3NzZLq//u//8eKFSskFQcAAFXiuuuu3bhxo6TisVhs584B ScWB+kMABg5JBGCv19vY2CijeE9P73333WexWGQUBwAA1WPTpk3XXvt5ScXT6fTW rdskFQfqDwEYOCSpK2CdcMIJd9+9UlJxAABQVc4//zxJ62CxEDRwRAjAwCFJDcCs gAUAgHGwDhZQJQjAwMxaW1s6OjokLQGdy+UuvfR9H/3oR2UUBwAA1eaSSy5JJhOS ivt8/lAoJKk4UGcIwMDMPB5PZ6fTbrfLKC7K3n33ykWLFskoDgAAqs3DDz/80EMP SirOQtDA3BGAgZl5vR632y1pkaqFCxeuWbNWRmUAAFCFREb98If/WVLxRCKxffsO ScWBOkMABmYm9QbgE09841133SWpOAAAqELnnbdC0tYSmUxmy5aXZVQG6g8BGJiZ vABcKBTOPPPvb7nlFhnFAQBAdVq+/FxJM8tE12LTphdlVAbqDwEYmJm8AJzL5S65 5JKrr/6EjOIAAKA6XXzxxel0SlJxn88XCoUlFQfqCQEYmIHNZuvq6vJ4pCwBLYp/ 4xt3v/71r5dRHAAAVKeHHnro4Yc3SCoeDIb8ftbBAg6PAAzMwOv1iADc3Nwso/iC BQvuu+9+GZUBAEDV2rdv35VXXiGp+MTExMDALknFgXpCAAZm4BUJ2OOWtGH98ccf v3LlPTIqAwCAanb++ec1NEjpfqdSqW3bXpFRGagzBGBgBlKXgD7llFNvu+02ScUB AEDVWrFiuaS313O53EsvbZZRGagzBGBgBvJGgMX16Zxzzr3++utVrwwAAKocI8CA 7gjAwAxE/u3t7ZVRWQTgf/7nD3/kIx+RURwAAFSzyy+/fGgoIKNyNpvdvHmLjMpA nSEAAzOQNwW6p6dn7dr7rFarjOIAAKCabdq06dprPy+p+MaNmyRVBuoJARiYQX9/ n9stZQ+kpUuPv+ceVsACAMCI8vn8u9/9LknFCcDAXBCAgelE9G1vbxNkFGcJaAAA jEzebcCBQGB4OCijMlBPCMDAdB6P2+l0OhwO1SsXCoW3vOUtX/7yV1SvDAAAaoK8 haBDoZDP55dRGagnBGBgOq/X09XV1dzcrHrlXC73j/946cc+9jHVKwMAgJpwySWX JJMJGZVjsdjOnQMyKgP1hAAMTCdvD6RCofDxj1/93ve+V/XKAACgJvzbv31yx44d MiqzExIwFwRgYDp5S0CbzZabb7759NNPl1EcAABUv3vuWfnUU0/JqJzP51988SUZ lYF6QgAGppMXgI899th7710lozIAAKgV73zn+ZIqsxA0cFgEYGA69kACAADyEIAB HRGAgdfweNxtbbL2QFq27JTbb79dRmUAAFAr5C0EzU5IwGERgIHXEAG4o8PZ0qL+ Hki5XG758hXXXnut6pUBAEANkTcCTAAGDosADLyGx+Pp6uq02WyqV85ms//0Tx+8 4oorVK8MAABqyPved+nExISMymwFDBwWARh4Da/X43a7LRaL6pXz+cInPnH1xRez BxIAAIZ2zTWf3rZtm4zKiURi+3YpeywBdYMADLyGCMA9PT0NDer/apjNlptuuumM M85QvTIAAKghK1eu/MUvpOyElMlktmx5WUZloG4QgIHXYA8kAAAgm6TbgAuFwqZN L8qoDNQNAjDwGvIC8BvesPSb3/ymjMoAAKC2sBMSoBcCMHCA3W7v6uqUtAnwiSee eNdd35BRGQAA1JbzzlvR2Ngoo3IgMDQ8PCyjMlAfCMDAAW63q6Ojo7W1VfXK+Xz+ H/7hrTfffLPqlQEAQM0hAAN6IQADB3g8HqfT6XDYVa+czWYvuujiT33qU6pXBgAA Neeii94zOTkpozI7IQGzIwADB3i9nq6urubmZtUr5/P5yy//vx/60IdUrwwAAGrO lVdesW/fPhmVJyZiAwMDMioD9YEADBwgbxNg8bv2+c9/7pxzzpVQGQAA1Jgvf/nL L7zwOxmVk8nkK69sl1EZqA8EYOAAeUtAW61NX//610844QQZxQEAQG1Zt+6BRx99 VEblbDa7efMWGZWB+kAABg5gE2AAAKANtgIGdEEABg5gE2AAAKANtgIGdEEABvaz 2WxdXV0ej5RNgE866aQ77rhTRmUAAFCLli9fbrGYZVQOBALDw0EZlYE6QAAG9nO7 3e3t7W1t6m8CXCgUli1b9vWv36F6ZQAAUKOWLz9XzrqbbAUMzIYADOzn8bhLmwA7 5DUhknAul2tqavZ4PAsWLOjv7z/rrLPe+MY3ymsRAADo6wc/+MGuXbv27Nnt9wfi 8XihkDebpQz8lrEVMDALAjCwn9fr6e7ubmpq0rhdJRWLa2FLS2tvb8+CBce84x3v OPPMMzU+DQAAME+rV6/et2+f3+8LBoOpVKqxRPvTiMViO3eyFTAwMwIwsJ9XJGCP W/absnMngnE+n7dam0QsF8HY6+1529ve9uY3v1nv8wIAwOjuv/9+X9Hg0NBwMpkQ l+zq6T8I6XR669Ztep8FUKUIwMB+8paAVpdIxeJCa7FYWlpaent7+/r6ly9ffvrp p+t9XgAA1Jt7773X7/cHAn5lRLfagu6h5HK5l17arPdZAFWKAAzsVysB+FCUEeOG hka73eZ2e0Q2drvdb3/7208++WS9Tw0AgOr10EMPipA7OLhveHg4FotnMpMN4mqq x9RltbAVMDALAjCwX60H4Fko2dhsNttsNo/H09PT093d/Y53nEM2BgAYxLp1DwQC Q+FwOBgcHhkZFSlXPFkTw7lHh62AgUMhAAP79ff3ud1SNgGuZsoSXI2NjU1NTZ2d xW2QXS7xv+6zz37b0qVL9T47AADm6rHHHgsEAqFQcHh4WATdVCqlXOAaGozY3SUA A4dixFcE4GClTYDbBL1PpLpMTatusFqtXUXdnSIld3WtWLHihBNO0PvsAADG8sAD DwSDwdHR0XA4FA6PpNOpbDar10rLVS4QCAwPB/U+C6AaEYCBIo/HU9oE2K73idQY ZUWuxkZzU1MxIYt47HR2tre3n3/++SeeeKLeZwcAqCVr1qwZGRmJRCIjI2FxkEoV 862pricqy8NWwMChEICBIr02Aa57yhiysmy1+PYqIbmjw9ne3vaud72bYWQAMIhV q1aNjY0p4XZ0dKwUbjPK+hTGnKIsWzwe37Fjp95nAVQjXnGAomrbBNho8iWNjY1K Tu4saWtrdzpFVG4/99xzFy1apPc5AgCme+SRR8bGRkWwjUYjIt+Ojo6m0+lMJpvL ZUWs5aqqI7YCBg6FAAwU1fES0PWkPJ4sOlVKVO7o6BA5ubW1pbW1TRy3traKtHzM McfofaYAUKsef/xxEWWj0ejExEQ8HhMHIt9mMpOZTCaXy4kPMOyyUrUlm81u3rxF 77MAqhGvX0ARAbgulQeWBWuJCMnt7R0tLY6Wlta2tja73fbOd76LwAygjm3YsGF8 XKTZmJBIxKMl6fRkNpsRGUlZ6ZBMW3/YChg4FF7sgCICMBTKCLM4UCbvWSwWEZtF Zm5ra7XZbA5Hi8PhEMfNzbYLLrigp4efGQAaefjhDbFYXITYeDyeSCSSyWQsNiGi 7OSkiLI5IZ/PiZcvJh6jjJ2QgBkRgIEiAjDmSYnNymNLS2tfX29LS4vIzHa7w263 t7Q4mpqaRWZ2uVx6nykA/T322GNKlE2WpIpEoI3t2bOnocRUehtO79NEDWMEGDgU XluBIgIwdFG+q7nU420U3V1ziTLyLCK0w+Fo3k9kabv4j3gUf3vJJZd0dXXpffqA sWzYsCGZTIi4KiJrOp0WkTWdnpycFIeT4nmRZ3O5bDZbHIktzyURD42NDexSC10w AgzMiAAMmGw2W3d3l9vt1vtEgPlSEnX5j8pQkuh8i1BdWmRbhGqHzWa3TmlqEv9r Fgfit0B5FBnbYjFffPF7W1tbdfxCgKPw+OOPF2NpUTqTEcF0srQi8WRJRhDxVCTV eDyeyylzhvcrlJTHXcmrqA+BwNDw8LDeZwFUHQIwYBLR1+nsaGlp0ftEgBowNWot csL+Kd9KWlAW0RHZoZS1G0vD2GaHo6WpqUkZ0C4/CiJmlwK4RXxYc3OTOBKf+IEP fEAkcL2/Pqjj4Yc3lAJnbnIyPXVQjKPFEdJcVjyRyexPpOLHSaTWUijNl8ZOlR8x JZSKn7H9Q6mmqWjKxGBgjgKBwPBwUO+zAKoOVxHA5PF4Ojs77XZ63kANKFQwlUJR 5didqSKQiydKcamxNAfVrOSmyhBVGu62lkf8GiqID6m1S2RhaiDzwDdHiZHZbEYk T1PFlPvSsakibRZKn55XPsVUcU+78u01vfabo+MXCWDuQqGQz+fX+yyAqsNlDDB5 vR6Xy2W1WvU+EQAAAHUkEont23fofRZA1SEAA8UA3NPTw7AGAACoG5lMZsuWl/U+ C6Dq0OMHWAIaAADUG3ZCAmZEAAYIwAAAoA6xExJwMAIwjI49kAAAQF1iJyTgYARg GJ3H4+7oYA8kAABQb9gJCTgYARgo7gPc2NhgsVhEDFb2KWVBLAAAUHPy+byyyXYy mcxmcwz/Agejlw/MoBSJG02mAqkYAABUoamsm00mEyLrik4Lg73AXNChB+bK7XaV UrHJbLa0tpKKAQCAFsi6gIrouwPzUk7FjBUDAIB5mjaHmawLqI5uOiCFMonaYjE7 HA4lFSs5GQAAQMhms5mMeMimUtyvC2iHAAxop5yK7Xa7iMQiGJvNZr1PCgAASFQo FDKlpBuPx8WjeIZBXUBHBGBAZ8oa1KbSJGqHw6EEY4aLAQCoLSLo5nI5JeumUikm MAPViQAMVKnKYNzS0mIpIRgDAKA7ZfZyLpflTl2g5hCAgRoztUWTyWw2t7Q4xKPF YjWbG1l5CwAAFZWnLudyOUZ0gbpBjxmoH+Xti0UoLg0ai2xs4TZjAAAORaTcbIlI uVPDuSbWowLqGAEYMASPx93QUMzGyp3GpXHjYjZm3BgAUPfy+fxUyM0pSy4zlgsY Fn1fwOhK2bih9GpAPAYA1CQl4uZKSgO5WeW6RsoFMA29WwCzmRaP7XYRjxuVhMyK XAAAbSgLLAsi5Obz5TtyTURcAEeKAAxgXg5KyHYRjM1TGEMGABxWefxWHCQSianx WxP5FoDq6JsCkG5qSydlVyezzWarDMmMJANAvSqP3CrhtnJysqm41hThFoDWCMAA qsW0wWQlJysYTwaA6iFirUizU6m2qLSyFMO2AGoAvUkAtWdqUWvF9LSsBOaGEj3P EgBqhzJUW4q10zKtiQFbAPWE3iGA+ufxeEpZeH8fTgnMIh4raVk5IDMDqBvlNFui jNfmSwtHVQbaBna7BWBAdPUAYGYVsblIdCGtViU5K6m5oXLMmeQMQHUixO4PrweC bCGVSmYy2amXnP3/IcoCwBzRYwMAFZTS8v5BldITxaHmQsFUysx2JTA3TEXnykd9 TxuANiqHYpUcKx4KJRUDs6aKFxCGZwFACvpeAFBFpoadTZVB2nQgS9saDlIZp0nU gCrKcVXJqJXHSmTNZIqR9aDf1gbWfwKAKkdXCQDq3EGhWnEgWgsHp2vxwaXNq0zl aF3xV4CelGw6K5MyT9h0IKOaDvr5J6wCgBHRjwEAqOO1i41VTgg3lfO2aSpymypS dzGkNJiUaF3O2JV5mwRePSpDZqGQLz9T8VfTnxP/KQ+Zml6TSE0H/YSwiQ4AQC66 EQCA+uT1eqbNJC+ZlswNpfzGRBmBEwBgLMbsAQAAAAAADIcADAAAAAAwBAIwAAAA AMAQCMAAAAAAAEMgAAMAAAAADIEADAAAAAAwBAIwAAAAAMAQCMAAAAAAAEMgAAMA AAAADIEADAAAAAAwBAIwAAAAAMAQCMAAAAAAAEMgAAMAAAAADIEADAAAAAAwBAIw AAAAAMAQCMAAAAAAAEMgAAMAAAAADIEADAAAAAAwBAIwAAAAAMAQCMAAAAAAAEMg AAMAAAAADIEADAAAAAAwBAIwAAAAAMAQCMAAAAAAAEMgAAMAAAAADIEADAAAAAAw BAIwAAAAAMAQCMAAAAAAAEMgAAMAAAAADIEADAAAAAAwBAIwAAAAAMAQCMAAAAAA AEMgAAMAAAAADIEADAAAAAAwBAIwAAAAAMAQCMAAAAAAAEMgAAMAAAAADIEADAAA AAAwBAIwAAAAAMAQCMAAAAAAAEMgAAMAAAAADIEADAAAAAAwBAIwAAAAAMAQCMAA AAAAAEMgAAMAAAAADIEADAAAAAAwBAIwAAAAAMAQCMAAAAAAAEMgAAMAAAAADIEA DAAAAAAwBAIwAAAAAMAQCMAAAAAAAEMgAAMAAAAADIEADAAAAAAwBAIwAAAAAMAQ CMAAAAAAAEMgAAMAAAAADIEADAAAAAAwBAIwAAAAAMAQCMAAAAAAAEMgAAMAAAAA DIEADAAAAAAwBAIwAAAAAMAQCMAAAAAAAEMgAAMAAAAADIEADAAAAAAwBAIwAAAA AMAQCMAAAAAAAEMgAAMAAAAADIEADAAAAAAwBAIwAAAAAMAQCMAAAAAAAEMgAAMA AAAADIEADAAAAAAwBAIwAAAAAMAQCMAAAAAAAEMgAAMAAAAADIEADAAAAAAwBAIw AAAAAMAQCMAAAAAAAEMgAAMAAAAADIEADAAAAAAwBAIwAAAAAMAQCMAAAAAAAEMg AAMAAAAADIEADAAAAAAwBAIwAAAAAMAQCMAAAAAAAEMgAAMAAAAADIEADAAAAAAw BAIwAAAAAMAQCMAAAAAAAEMgAAMAAAAADIEADAAAAAAwBAIwAAAAAMAQCMAAAAAA AEMgAAMAAAAADIEADAAAAAAwBAIwAAAAAMAQCMAAAAAAAEMgAAMAAAAADIEADAAA AAAwBAIwAAAAAMAQCMAAAAAAAEMgAAMAAAAADIEADAAAAAAwBAIwAAAAAMAQCMAA AAAAAEMgAAMAAAAADIEADAAAAAAwBAIwAAAAAMAQCMAAAAAAAEMgAAMAAAAADIEA DAAAAAAwBAIwAAAAAMAQCMAAAAAAAEMgAAMAAAAADIEADAAAAAAwBAIwAAAAAMAQ CMAAAAAAAEMgAAMAAAAADIEADAAAAAAwBAIwAAAAAMAQ/j+1V7oo1AKKCgAAAABJ RU5ErkJggg=="/></symbol><use xlink:href="#c" width="1280" height="1280"/></g></g></svg>')} -.is2d .knight.white {background-image:url('data:image/svg+xml;base64,<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="614.635" height="614.635" viewBox="0 0 460.977 460.977"><mask id="b"><use xlink:href="#a" width="1280" height="1280" transform="rotate(.193) scale(.36014)"/></mask><symbol id="a" viewBox="0 0 1280 1280"><image width="1280" height="1280" xlink:href="data:image/png;base64, iVBORw0KGgoAAAANSUhEUgAABQAAAAUACAAAAAA9j6ArAAAACXBIWXMAAA7EAAAO xAGVKw4bAABJOElEQVR4nO3dd4AV5d238Q3LLrCsVAEFRUQFUeNjSV5LFCtWrCgW IpZYsJcYY2I3atTYO/YoFhAVRUURRBF7bIkgIkoRkbbSWdh2XkGlLFtOmZnvfd+/ 6/PH8yQKZ7/sMld2z5kz85s8ADDqN+oBAKBCAAGYRQABmEUAAZhFAAGYRQABmEUA AZhFAAGYRQABmEUAAZhFAAGYRQABmEUAAZhFAAGYRQABmEUAAZhFAAGYRQABmEUA AZhFAAGYRQABmEUAAZhFAAGYRQABmEUAAZhFAAGYRQABmEUAAZhFAAGYRQABmEUA AZhFAAGYRQABmEUAAZhFAAGYRQABmEUAAZhFAAGYRQABmEUAAZhFAAGYRQABmEUA AZhFAAGYRQABmEUAAZhFAAGYRQABmEUAAZhFAAGYRQABmEUAAZhFAAGYRQABmEUA AZhFAAGYRQABmEUAAZhFAAGYRQABmEUAAZhFAAGYRQABmEUAAZhFAAGYRQABmEUA AZhFAAGYRQABmEUAAZhFAAGYRQABmEUAAZhFAAGYRQABmEUAAZhFAAGYRQABmEUA AZhFAAGYRQABmEUAAZhFAAGYRQABmEUAAZhFAAGYRQABmEUAAZhFAAGYRQABmEUA AZhFAAGYRQABmEUAAZhFAAGYRQABmEUAAZhFAAGYRQABmEUAAZhFAAGYRQABmEUA AZhFAAGYRQABmEUAAZhFAAGYRQABmEUAAZhFAAGYRQABmEUAAZhFAAGYRQABmEUA AZhFAAGYRQABmEUAAZhFAAGYRQCRu9a3fdy/VD0CyBwBRM7aj22R98PmC9QzgIwR QORqg3Hr/PR/Z21GAeEdAogcdf5v0xX/f9bmc8VLgEwRQOSmy2dNfvlPJZtRQHiG ACInW37caOV/Luk2W7gEyBwBRC62+aBwtf82rwsFhFcIIHKwZv8oIHxDAJG9LT8p rPZPKCC8QgCRtdWf//sVBYRPCCCyVVP/KCC8QgCRpZr7RwHhEwKI7HT9vOb+UUB4 hAAiKx2/LKr131FA+IIAIhttJjar499SQHiCACILzb5tXee/n9eZd8XBBwQQmSv4 doN6fkVJZ64NAw8QQGRuzB/q/SUzOy9JYAiQGwKIjL14UBq/aPomS2MfAuSIACJT 9/ZL65dN6VIW8xAgVwQQGTrn9jR/4cRuFbEOAXJGAJGZfV5N++/MuN9WxbkEyBkB REa6fFGQ/i8etWd8Q4AIEEBkotEPLTP55UMPjmsIEAUCiEy8uVtmv/6JP8azA4gE AUQG7jg7099x7xlx7ACiQQCRvsOey/z3XH1F9DuAiBBApK3td9WvgJ+OM++JfAgQ EQKItE3cJJvflTry2aiHABEhgEhXmu8AWUvVnm9FOwSICgE0o3mDealcfv8eI7P9 y1L+269y+cBAbAigGfft2v+OHH57Qck6Wf/exRtzgVQ4iQBa8fsxhUufuXxy1r9/ yCE5fPBZG3FpGLiIABrR8oVdf/q/X/3t+Sx/f++BOX34CV1z+u1APAigDY3+ed6K L/WS566emM0zgY3mNsltwEvpXEMQSBgBNKHgpOtb/PyfKkfdMCKLB3jusFwn3HNm ro8ARI4AmvCHAZ1+/Y9Vk+8cUJLpN4F7ZRPNai64NffHAKJFAE0Y2Hu1/1L1ytUf ZfbbG5S0yH1D6vAhuT8IECkCaEDh2VcWr/7fq768LLPXQjK/BkJNKn/3WRQPA0SH ABrQ57oNq32dywdekMGZee2mN4hkx5KNZ0XyOEBUCKABX2yx1pc5NfmmR0rT/f1v dY9oyMwNyyN6JCASBDB4vznxgZq+gZv3yIVp3rGj59DItryzS2QPBUSAAAZv18c6 1fjPy0bfP2xROg8wq010YwYdFd1jATkjgKErfGHf2r7Is/rfmEYBL/xXlHOuuyTK RwNyQwAD1+CoAbW/grHgiZt+qO+ZwIIFjSMddPxjkT4ckAsCGLhtB2xR179eNumK QXU/wH2nRTknL69qtzHRPiCQPQIYtua39a37FJbUNyfXebnSZiUNIx2Ul1fW7duI HxHIFgEM25nXF9f3SyoGH1PHv33q6AjX/Gz+RvMjf0wgKwQwaP/39Ob1/6KKIRdN qu3ftf0hmnOg1zC1c2X0DwpkgQAG7eG++Wn8qsrX+02p5V+9GMtVrEbuHcejAhkj gCHb+9lmaf26ynduerXG92i0+yGevyCP943lYYEMEcCANR2S9ndaP171QE3nw8Tz DWAet0uHIwhgwK6/oCDtX7vkkSvnrPUP4/oG8Cd9H4/rkYH0EcBwtftfJu9hK3/w /GXV/9ngXhHOWRM3C4YLCGCwGv7rvMx+w5QeX6/5D4rnpfMSSpbK/+/L+B4cSA8B DFX+wQ+0zvC3vHPimgV86KTo5qxtySYz4nx4IA0EMFQb/nuPTH9LatTRq18mtWBR YYR71lbSKa2L0QDxIYChuvpvmb+HLTXuiPGr/ttVl0c4pyZTNyuL+SMAdSOAgdry pU5Z/K7UO6esKuCPLSNbU4svt0rzmqxAPAhgmIruPzqrFzBSb5z43S//8dDMbpyU Fd4SAi0CGKYTbmue3W+sfKXf9J//0/iu0c2p1ZCcb7gO5IAAhmn0Ltl+ZVMvnLri lZAo7oWehsFHJvJhgBoRwCD1fjqHL+wbfb/Pi/ZOIHV5sk8yHweoAQEMUYfhdV4G uh6pl376KbggsRdoBxyX1EcCqiOAASq87ryc3sKRGnB86oorIxpTPwoIGQIYoN++ 2j7HR3ir5+RM30aSAwoIFQIYnqJ/nZ7rlzU1cbNIpqSJV0IgQgDD0/ORddUTMvXC oeoFsIkABqfpkwf591UdsS/vCYGAf4cK6tH37npvBOegsdtUqCfAIAIYmlZP7+3l F3XylkvUE2CPl8cK6nDpJY3VE7Izu1uJegLMIYChmdJRvSBbC7eerJ4AawhgWH6z +0h/v6RLu3+kngBj/D1aUIPftL83rhtZJqHyyAQuwQWsQgCD0ujCi318CXil1F9u Vk+AKQQwKFsO3MLzr+jdZ6kXwBLPDxes6dS7M78RiGN4UwgSRABD0mToXuoJuRu3 /VL1BJhBAENy8u1F6gkRqHz/uzmzvp8yZUq5egmCRwADUvxS96C+nlVlSxZM+W7m tMmTvuZdIohFUAeMdUc+5umbQOqXKl+ycPK0mVMmjJ/MVRMQHQIYjqLHeqknJKFi yYJvJ0+fNP7L2eol8B8BDMchDyV4FWcHpMoWz/t6wjdffMZ7iJEtAhiMwicPa6De oFG1dN7Er77+738IITJFAIPR+eMW6gliVUtKvhr733cnqHfAHwQwGCc8zBdzhdSS 2WM//2TMTPUOeIBjJhRtBuyjnuCWynk/ZXD0t+oZcBoBDMUJdzVVT3BR1YKxn7wz gmcHUTMCGIohh6gXOKxs5idvj/hcvQLuIYCBaPtlK/UE11WVfDzq5bHqFXAKAQzE CfcXqCd4oXL2R288N1W9Aq4ggIEYtp96gUeWTRk9cFSlegUcQADDsP7XvASSmdSc 918ZOFe9AmIEMAgNjnxaPcFL8999btAC9QgIEcAgNL/zOPUEb81959lBXG3LKgIY hG1e8PZuwE6YOfze99QboEAAg3Dsv72/F4ha+fvPP8pTguYQwCA8dJJ6QRBKht/+ gXoDEkUAQ1D00RbqCaEoffP+F7nmtB0EMAQHPbGOekJAKt978tFS9QgkgwCG4M4z jF4KNS6pbx68bZl6BBJAAEPw1q58HaNW9eW99/FmkeBx4ASg0VcbqScEqXLMPYN5 PjBsBDAAOw1pq54QqvJhV3ym3oAYEUD/NfjjPbwROD5zHruKd8sFiwD6L/+sW3gN JE6pd29+Xr0B8SCAAbjsavWC4C195i/cZClEBNB/TZ44TD3BgNS7Vw9Xb0DkCKD/ th24mXqCDfMeuIITpANDAP130APt1BOsqHz1onHqDYgSAfTf/oOK1RMM+frcYeoJ iA4B9N+Oo7kfUpJmXtFfPQFRIYD+O/ZxzoJJ1sLbr+RdcmEggP679mICmLSyf5/H ZfRDQAC91+Aff+OrmLyKAWeSQP9x6Hgv/4w71BNsIoEBIIDeK7j8UvUEqyoePYcT A/1GAL3X7LYT1RPsIoGeI4DeK+x/PF9FnfJb/s41A/3FoeO/QUeqF9i24LxH1BOQ LQLov6E91Qus++6Po9UTkB0C6L0GTxzFV1Htrb5T1ROQDQ4d/w0+nK+iXGrQibwa 4iEOHf8N20+9AD9ZeuHd6gnIGAH0XoN7T1VPwAqTDv2vegIyRAC91/Cv16gn4Gep p0/kdup+IYDea3TNheoJ+FXpuQ+oJyATBNB7BVdyNRiHTNx/onoC0kcA/XcJPwK7 pOqGv6snIG0E0H/Xcjkst0zb50v1BKSJQ8d/f7uKS+K7peqO89UTkB4C6L8Tr1tP PQHVzNiXM2K8QAD9t8F2L6gnoLpU/9PVE5AGAhiClHoA1vbDHl+pJ6BeBDAEBNBF VZddp56A+hDAEBBAN405aJ56AupGAENAAB219IiX1RNQJwIYAgLorAdPUS9AXQhg CAigu6buMEM9AbUjgCEggA4rO2qIegJqRQBDQACddu8Z6gWoDQEMwdQN1QtQl/E7 LFBPQM0IYAgKuQyn2xbv9rF6AmpEAIPAz8COqzr7HvUE1IQABqGKr6PrBhynXoAa cOAEoYwLYjlv/O8XqSdgLQQwCAuL1QtQr3k7TFBPQHUEMAjzmqsXoH4VvV5UT0A1 BDAIywrVC5CG1MU3qidgTQQwBJtzDwpP3H+aegHWQABDcDdvNfDFqwdWqSdgNQQw BJM6qRcgXd9svUQ9AasQwADkl3FndH/M3nK2egJWIoABOOw59QJkYNH2nA7jDAIY gCGHqBcgE2W7va+egF8QwABwFqBnKg8Yrp6AnxFA/3WYpl6ADFUdM0g9ASsQQP/d 9Gf1AmQqdXp/9QQsRwD9901n9QJk7i83qRcgjwAGoGApJ8H46BJum+4AAui94x5T L0BWrrxKvQAE0H/De6gXIDvXXaJeAALovdLG6gXIEgWUI4C+24GTav11xdXqBdYR QN8N7K1egOxdeq16gXEE0Hfzm6kXIAcX3qxeYBsB9NwWY9ULkJNTHlQvMI0Aeu7R 49ULkJPUUc+oJ1hGAD1X0kq9ALmp2p8rI+gQQL91mqRegFxV7PyReoJdBNBv/U9V L0DOlm3xrXqCWQTQb/wEHIKFG5eoJ1hFAL3G/TDDMGujpeoJRhFArz1xrHoBIjGx K3fLlCCAXltYrF6AaLxyoHqBTQTQZzu+p16AqNx3unqBSQTQZ9wOLiC8KU6BAHqs QWmhegIikzr0RfUEgwigx065X70AEarYmtf0E0cAPfZVF/UCRGnBhgvUE8whgP5q M5OvXlgmbqZeYA6HkL/uP0W9ABF79gj1AmsIoL8WrKNegKhxr8yEEUBv7TVCvQCR S/UYqZ5gCwH01uhd1QsQvWWdZqgnmEIAfdV2Bl+7EE3fkHcFJ4iDyFcD+qgXIBYv 8vaeBBFAT/EukGD95Sb1AkMIoKf+er16AWJStSOXyE8MAfTUzLbqBYjLonZL1BPM IIB+6sGdxAL2zi7qBWYQQD99ubl6AWJ041/VC6wggF767X/VCxCn1O6j1ROMIIBe GrW7egFitbgtTwMmggD6qONkvm6Be2t39QIbOJB8NLSnegHidsXV6gUmEEAPtZ7N ly14VdvyPG8COJI89Ozh6gWIX0lb3hQcPwLonw7f8VWzYODR6gUGcCj5Z3gP9QIk ovcz6gXhI4De2WKsegGSsawtN0mKGwH0zpg/qBcgIZwLEzsC6Jvd3lQvQGLOvUO9 IHQE0DeTN1IvQGIqNpqunhA4AuiZkx5SL0CCuFNwzAigXxrML1ZPQJKuvEq9IGwE 0C93n6FegERVbTJZPSFoBNAr609roJ6AZH2zqXpB0AigV7gXsD2XXaNeEDIC6JPe A9ULkLjKzlPVEwJGAD3SqKSpegKS9xW3P4gPAfTIoCPVC6DA6dDxIYD+6P6WegEk ytvOU08IFgH0Rv7sluoJ0Bi5t3pBsAigNwb0US+AyjFPqxeEigD6Yo831Asgs7hl uXpCoAigJ5rM4j1whj3xR/WCQBFAT7y6r3oBhFLbfaaeECYC6Icz7lYvgNS0DdUL wkQAvdBlXL56ArQuvVa9IEgE0Af5M9ZVT4AYJwPGggD6YMgh6gWQe+VA9YIQEUAP XHSDegEcsDvvBIoeAXTfLqP5KiEvb+Z66gUB4tByXuvvmqgnwAlcHj96BNB1+VPb qyfADRWtuVF61Aig64b3UC+AK4YerF4QHALouHv7qRfAHb/7WL0gNATQbX+9Xr0A Dpm8sXpBaAig0455gi8QVtOvv3pBYDi+XLbbG9wFE6tb0qxSPSEsBNBh23zUUD0B junPc8KRIoDu2vSLRuoJcE1luxL1hKAQQGe1n8BNMLGWYQeoFwSFALqq/fh11BPg Ik6FiRIBdBT9Q82+2VS9ICQE0E0dv6B/qNlRg9QLAkIAndTlMy6AgFr82Fq9ICAE 0EXbvM/rv6jVxVwfMjIE0EG7vV6gngCHla7D2dBRIYDu6TWI93+gLvecqV4QDALo nH738EVBnbgwYGQ41lxzw0XqBXDewKPVC0JBAB0zsLd6AdxXtd5s9YRAEECnFIzc VT0BPniRG6VGgwC6ZL3P26onwAupjb5TTwgDAXTIziMbqyfAE6/vo14QBgLojtPu 4fQXpKvrBPWCIBBAZzx0knoBPPJ2d/WCIBBARxR9uKV6Aryy4wfqBSEggG7Yakxz 9QT4ZUJX9YIQEEAn9Lubp/+QoX1eVy8IAAF0QIOnOPsZGZu6kXpBAAigXvsPNlBP gI96vqxe4D8CKHfwM4XqCfAS3wLmjgCq3XG2egF8te9w9QLvEUCt1mM2V0+AtyZ1 Vi/wHgGUOngQ175H9vYcpV7gOwKo9PCJ6gXw2tdd1At8RwB1Or7Dq7/Iza5j1As8 RwBlTurfUD0BvhvfTb3AcwRQpOAZLmmJ3PGO4NwQQI1dXuK9v4jA2K3UC/xGACXu PY1PPCKx9f/UC7zGcSiw6Zsd1BMQCq4LmBMCmLyLr+XSL4jMJt+qF/iMACatxdBd 1BMQklcOVC/wGQFM2An9ufQBopRqU6Ke4DECmKii5/ZVT0BonvijeoHHCGCSej3e RD0BwakoXqae4C8CmJxGAzn3GTG48xz1An8RwMTsO7hYPQFBKi2uUk/wFgFMSP6A o9UTEKpLrlMv8BYBTEaPwc3UExCseS3VC7xFAJNQ8FQv9QSE7MRH1Qt8RQATcODT PPuHOH3PlSWzRABjx4u/iF33t9ULPEUA43bYgCL1BARvzK7qBZ4igPEqGry/egIM SG34vXqCnwhgrE64t7F6AkwYfKR6gZ8IYIxaPre7egKM4P1w2SGA8TnnpgL1BJhx 41/VC7xEAOOywXBu2IXkLOAmM9kggDG5/PJ89QSY0vdx9QIfEcBYdHmtk3oCjJm8 sXqBjwhgHG45l7t+IGlbjVUv8BABjN42w9ZTT4BBw7naeOYIYNQa9P8Tn1QIVLWe p57gH47ViHV/vpV6Aox68BT1Av8QwEgV/PsY9QSYVcq7zjNGAKO0/8B11BNg2KkP qBd4hwBGp8nTB6snwDTOhMkYAYxM70e55yW0unytXuAbAhiRZoN7qCfAvCGHqRf4 hgBG4+S7GqknABVF5eoJniGAUeC6V3DD1VeoF3iGAEbgjNu47hWcMKeNeoFnCGDO 2jy3i3oC8Itd3lEv8AsBzNX5NzZUTwB+NWpP9QK/EMDctH99C/UEYJVUK94QnAkC mJM/X8+3f3BK/37qBV4hgDlo8/wf1BOANS0uVi/wCgHMHi/+wkEHvaRe4BMCmK0W Q3ZTTwDWNmZX9QKfEMAsnXhfoXoCUANeBskEAcxK8fN7qycANbv7LPUCjxDAbPQc xIVf4Kr5LdQLPEIAM9fgiaPVE4Da7fGmeoE/CGDGtn29tXoCUIc39lIv8AcBzNSN F/I5g9Oq1lminuANDubMtB+9iXoCUI9/XaRe4A0CmJFT7uGtb3BeybrqBd4ggBnI f467HsEHO36gXuALApi+bd5oqZ4ApOPV/dULfEEA03bJ1Q3UE4C0VDSuVE/wBAFM U9FLe6gnAOm64Fb1Ak8QwPTsMbSpegKQtm82VS/wBAFMy00X8ImCT9rOVi/wA8d1 Gope5QpD8Mu9Z6gX+IEA1m+HEVxkF56Z20q9wA8EsF4XXc8nCd753cfqBV7g2K5H g2cPVU8AMjeUk/bTQQDr1v6j9uoJQBbKG1epJ/iAANZpr5cbqScAWTnlQfUCHxDA uvD0H7w1bkv1Ah9wgNdhYG/1AiBbqRYL1BM8QABrVfzJZuoJQPZuvlC9wAMEsDab fsS9ZeCzGeurF3iAANZin5cK1BOAnGw0Vb3AfQSwZmfcxWcGnnv4T+oF7uMwr9Gt 56kXALmaxwV860UAa/LcYeoFQO62+Vy9wHkEcG0Fo/6gngBE4Nkj1AucRwDX0nxs B/UEIAqlReoFziOA1W3wP05/QSB6jFAvcB0BrGbLj5qoJwAReW0/9QLXEcA1bf9u oXoCEBUuCVMfAriG7iMbqicA0enzpHqB4wjg6vYfmq+eAERoDHezqRsBXE3vp7j1 OYJSVbRMPcFtBHCVkx7ks4HAXHizeoHbOORXOvNOPhkIzZdbqBe4jWP+V6fcr14A RI6fgetGAH9x8v18KhAgfgauE0f9z/o+ymcCIeJn4Dpx2K/Q53E+EQgSPwPXieN+ ud5P83lAoM69Q73AZRz4PznsWT4NCNXYrdQLXMaRn5e32xuc/4xgVTUuV09wGAHM 2/o/3P4IAeNn4DoQwI5fNVZPAGLEz8B1MB/A1t82U08A4sTPwHWwHsCiyW3UE4B4 ncabnGplPID5EzupJwAx45pYtTMewBF7qRcAcass5LrQtbEdwMeOUy8A4tf7GfUC Z5kO4OVXqRcACRi+r3qBsywH8JgnLP/pYccyzvSqjeEE7PgObwCBDXu8qV7gKrsB 7DihkXoCkIzneqkXuMpsABtNb6WeACRk0TrqBa4yG8DRnBsFO7Yaq17gKKsBfOgk 9QIgOY/3VS9wlNEA9rtXvQBIUMm66gWOshlAXgCGMRt8r17gJpMBbDOliXoCkKg7 z1EvcJPFADaY2kE9AUjWtA3VC9xkMYCDOSkK1qSKl6gnOMlgAM+5Xb0ASNzp96kX OMleALf9Dy+AwJ63dlcvcJK5ABbN4KR4GFReqF7gJHMB5B0gsIkLItTEWgBvPU+9 AJB4prd6gYuMBbDHa8b+wMAv5rVUL3CRrR4Uz+IMaFjFm0FqYCuAPAEIu275s3qB g0wF8B+XqhcAMpM6qxc4yFIAd3jP0p8WWFOqUbl6gnsMJaHRrGbqCYBQ38fVC9xj KIDD9lMvAJRe30e9wD12Anga74WEbaVF6gXuMRPA9lMaqicAWt3Gqxc4x0wAv+El MFh3z5nqBc6xEsBbzlcvANSmdFIvcI6RAHIGDJBXVVipnuAaG13In9NCPQHQO2qQ eoFrbATwqaPVCwAHDD1YvcA1JgK476vqBYALFvJegGosBLDRnGL1BMAJXBGmGgsB HHKIegHghhv/ql7gGAMB7DVYvQBwxISu6gWOCT+ARXO4CCrws8rCKvUEt4QfwJcP UC8AnLHfa+oFbgk+gIc+r14AuGMgZ4StIfQANippqp4AuGNWO/UCt4QewMG91AsA h6SalqonOCXwAPYYrl4AOOX4x9QLnBJ2APNLmqsnAE55uad6gVPCDuBjx6kXAG5Z wPcEqws6gNt/FPQfD8hC29nqBS4JuhA/rKdeALjmglvVC1wScgBvuEi9AHDOW7ur F7gk4AB2+qaBegLgnKW8NXQ1AQdwPO/7BtbWdYJ6gUPCDeDZd6gXAC66jRuErRJs AItLCtUTABdxSazVBBvAoZzvCdSkokC9wCGhBnCvEeoFgKP+30fqBe4INIANZrdS TwAcdc+Z6gXuCDSAd5ytXgC4iicBVwkzgJ2/5hRAoBblvD64UpgBHNdNvQBw13af qhc4I8gAnviwegHgsDvPUS9wRogBbDSXN/sAtftqc/UCZ4QYwCeOVS8AXMaTgCsF GMBtPgnwDwVEaJvP1QtcEWArpnRULwDcdvt56gWuCC+AF/5LvQBw3JdbqBe4IrgA chEEoD5ljdQLXBFcAEftrl4AOG+rseoFjggtgH++Sb0AcN9VV6oXOCK0AFbyHjig XqN3Uy9wRGABfGMP9QLAA4uL1QscEVYA281QLwC8sG6JeoEbwgrg63urFwBeOO1+ 9QI3BBXA/V9RLwD8MPRg9QI3BBXAEi4DDaRlThv1AjeEFMCrLlcvADyRKqhUT3BC QAEsmst7QIA0HcjzRcsFFMCnj1IvALzx7xPUC5wQTgDbTeccaCBdkzqrFzghnAAO 20+9APAHt0dfIZgAbvZVMH8UIAFcD2G5YKrBm+CATFxxtXqBC0IJYOeJofxJgES8 sZd6gQtCycar+6oXAF5Z0Fy9wAWBBHD97wP5gwBJKSpVL3BAIN3gHEAgQ4cNUS9w QBgBzC/lNX0gM5wKnRdKAC+5Rr0A8M03m6oXOCCMAM7i0hZAhrg1XF4gAezylXoB 4J8Nvlcv0AsigAP6qBcA/jn7LvUCvSACuJA7vAAZ46rQYQRwp3fVCwAPzWqnXqAX QgD5CRjIQlVBlXqCXAgBnMH/kAFZ2Pk99QK5AAJYtCiAPwSQvH9wF50A2nHSQ+oF gJdGch/tAAL4Aq9lAdmYy31kAwjgtA7qBYCXUg3NvwoSQADLuBACkJVd3lEvUPM/ gB2mqRcAnuJVEP8DeOLD6gWAp3gVxP8A/vNi9QLAU7wK4n8A/91XvQDwFK+C+B/A N3dTLwB8Zf5VEP8DOKWjegHgK/OvgvgfwB9bqhcAvjL/Koj/AZzbQr0A8JX5V0EI IGCX+VdBCCBg2HafqhdoEUDAsIv+pV6gRQABw6zfF8T/AP6wnnoB4K1pG6oXaPkf wImbqBcA3rJ+d3T/AzhiL/UCwF/rlqgXSPkfwLvPUC8A/HXsU+oFUv4H8Lxb1QsA f915jnqBlP8B3P4/6gWAv97ZRb1Ayv8ANqjw/88AqCxorl4gFUA85tn+CgK5MP5m uAACyMvAQPZ2el+9QCmAAF78T/UCwF+XXqteoBRAADecql4A+Mv2m+ECCGDewmL1 AsBbUzqpFyiFEMCXDlQvALy1tIl6gVIIATzgZfUCwF+Nl6kXCIUQwLyyAvUCwFu7 jVYvEAoigMP2Uy8AvGX6ZeAgArjje+oFgLdMvwwcRAC5NSaQtakbqRcIhRHAGy5S LwB8Zfpl4DAC2GhxvnoC4CvLLwOHEcC8wb3UCwBf7TlKvUAnkAC2nRHIHwRInOWX gUPpxssHqBcAnrL8MnAoAezwXSh/EiBhkzdWL9AJJhvPHq5eELjKr5/q0kc9AnFY bPhqIsEEsOVsXgiOz5w3HhpRlfdWd/UOxCHVQL1AJ5gA5t11pnpBoBa/P2TAvBX/ qaSVeAri0XWCeoFMOAFsMN/wN/JxWfrRK49/v/K/VRr+TiFoJz2iXiATTgDzjnlS vSAsiz8cPujb1f9B529UUxCv289TL5AJKIB5o3ZXLwhFau4HLw+aXf2fnvyAYgvi N3Jv9QKZkALYekZD9YQAlH/39uDXymv6N4//MektSMaM9dULZEIKYN6fb1Iv8FvV nA9HvDC51n89dovkpiBJyxqrF8gEFUAO0aylFnz89ssf1f1rFjVNZgsSZ/dyCGEF cL2pXBw/c4umvDNkRI0/9K6hyZIEtkBiZ7OXFA4rgHknPaRe4JXU/M8/GDmq/vat cOjz8Y6BzgW3qheoBBbAvKE91Qs8UVnyyZiRH1Zl8DseOim2MRB76GT1ApXQAlgw k6vj16d0+n/eHP5t/b+umnHdYtgCJ4zZVb1AJbQA5m39KW9XqFVFyecfvv12aXa/ eXFRtGPgjtlt1QtUggtg3vm3qBe4KDX/i8/eHzEzh0do+WNkY+CaskbqBSrhBZDL 41ezZPono0eNy/lhTu0fwRY4qmGleoFIgAFsMGUD9QRHLJ3x2XvvfJjmi7z1eenA aB4HLtr2M/UCkQADmNd2suX7/K1QXvL5h2OyfbKvZlwLK2SnPKheIBJiAPN2eNfw CyGLpn70ek5P9tWM06CDdusF6gUiQQbQ6vnQSz54b9RbEf3EW91RT8fzuHDCa/up F4iEGcC8m/4c8QNWVpSVpfLyChs2cvXK+zOv7h/nE9m8tBS0KZ3UC0QCDWCE90ia /7//fvz5uFVPpxVssfMuO23o2IW3lj124YJ4P8Kc1vE+PqTM3hcp1ADmfbFlBA9S MurpV2p+JWH3c/d359SpkptuzOQ9bdloPSfmDwCpKld/sIlbsAEsnLhhjo8wbeA/ S+r41w3OubJ5jh8hGpMvSOAqBVxqMXDtf1Av0Ag2gHnNJuVy3sbiZ/5e/9+IW87T f/rGnjE6iQ/z9i5JfBTIHDxUvUBDfwTHZr2JWV/Ac9oVD6f16/Z9WfuTQ2rkmQnd 0LCMCy2G7W/XqxdoBBzAvK7/Lczq93118ph0f+lxj2X1ESIy4rTMr+mSnZ3eTegD QaR/P/UCjZADmLfzW1m8WDupb9r5+8m0Dpl/hIiMOu3rxD7Wk8ck9qEgYfXGcEEH MK/7G5n+iDq336CMfv0dZ2f4AaIyrvfYBD/a3BYJfjAITN1IvUAj7ADm9RiWUQEr b7koww8g+tlw9kkvJfnhuCV68Ba4cUpD4gIPYN6BL2bwtuBRR9Z13kuN8isy/R0R WHrFjcl+wPtOS/bjIXGVjp3an5TQA5jX88V0/4ilpzyRxeOXJ/8X55njkr6J4ex1 E/6ASJzRO2MGH8C8XoPS+x5w5KGLsnn4xG+WO+PQDxL+iPwEbMF2n6oXSIQfwLz9 h6bxPGDFBXdm9+gLk30TZeWNf0/0463w8InJf0wk7HjpGV0yBgKYt9uIen9MndR9 WpYPnmwAp+82MckP94v5zQQfFMm67hL1AgkLAczb4e2638eQuuO8rB87yR+BUw+e mtwHW4WzoC14vK96gYSJAOZt835dl25Zdtiw7B86wfeILT5kZGIfa3XcDcSCd2y+ 29tGAPO6flz7N2qT/9/sHB65MrGr74/dOeZL/tUif6nRMyRsmbG+eoGEkQDmrTe2 tmvD/PuEXB630dJcfncm7js9qY9UzV+Nvk3eGKOXRLUSwLxm/+tY0z+uPCm3F7+2 /SSn35621Fn3JPOB1vYddxm1wOiZ0GYCmFfwRg1Pcizc5b+5PeoJj+T2+9NUceDw RD5ODTb/UvWRkSib90a3E8C8vBcPqv5PJvw+16fVbsj0zcNZWbqT7r7Va3/WEKTN FGdYyVkKYF7/ameRDDgu54cc3iPnh6jf4q2Tuu7f2hottnq3CGsOfEW9QMFUAPPO v3m1P2/qvDtyf8QZ7XJ/jPos3CLbs7QjcN3fdB8bSTony/dC+c1WAPP2f3HlU71l B0RxVl0CpwEu6TY19o9RO94FYsXNF6oXKBgLYF63D395tb9kuyiy0m5GBA9St6W/ VT43k9CLPNB7so96gYK1AOY1/9+K22W+s1ckV/85tX8Uj1KXsu2/iPtD1IVzYMx4 u7t6gYK5AOY1GHJQXuWTEb3x8ZkjonmcWlXs/FHMH6FOe41QfnQkaVquN9L2kr0A 5uVd/ffuUb29f0qNZ1dHp2p/2fl/K3zVRfrhkSCbF8W3GMC8TpOjeqSKmM8ROUn7 FFxS73OBA8qzu4ms50wGMDJxB+KKq+N9/Pq8bfMKITalErush0sIYC5ivinmg6fE +vD12uF97cdHotbJ6p4QniOAufhiyzgffdgBcT56GsZuIR6AJG39P/UCAQKYi2Vx Pm0yadOqGB89DTu+p/34SNZBid5r2hEEMAdbxnmK3vyOmuufrjJxE/EAJOr0+9QL BAhgDuJ8CrCsm+4CCD87+AXxACTrmsvUCwQIYA4mbBbbQ1fto7n/x2qSuM4DHNK/ n3qBAAHMQYxnAZ76QGwPnaYz7lYvQLKe6a1eIEAAs7fPa7E9tP7KHPkLitQTkCyT 94UjgNkbGNv/Yj7XK65HTlv1i8cieFM3Ui8QIIDZm9M6pgceF+vphWlp+4PJ9wWY Nre2GyeGjABmrfWcmB54dsfE7rVZqzf2UC9A0kotPulBALP2j0vjedzFnWfF88AZ ONDiObHWmbwxJgHM2viusTxs+bZjY3ncjPzYUr0AiTN5NQQCmK38slj+vlTtPSqO h83MreepF0CgsFy9IHkEMFtHDorjUVNHx/Kwmen8tcXvBbDB9+oFySOA2Rq2XxyP euY9cTxqhrgOtE2/+1i9IHkEMFuL43jN7C83xfCgmTrndvUCSFi8NToBzNL/fRbD g152TQwPmqmWM+O/1zFcdOKj6gXJI4BZeuSE6B/Tif7lvWXy9ohw5OePhBHALM1q E/lD/vXGyB8yC/3uVS+AyPV/Uy9IHgHMTrsZUT9i6gwnrkfZ+gd+ALbq3jPUC5JH ALNzy/kRP2BV72cjfsTscB8Qu57so16QPAKYnajviL50r6ju1Z6bS/+hXgCZFw9R L0geAcxKs3nRfuJm/J/+/b/LdR3HKdB2WbwgIAHMSsTfKA09rDLSx8tWg+/XU0+A zoR43t3uNAKYlUjfK1F5jgtv/1hugMEngbCSxSuiEsBsFCyL8PM2ucfE6B4sJ70H qhdAacb66gXJI4DZOPOuyB6q8h9XRfZYOWr7XZz3eYfzStZVL0geAczG3BZRPdJr x82O6qFyNqmTegGkFjRXL0geAczCzmMi+rRNOvb9aB4oCnG8uQ8+WdJUvSB5BDAL EX0DOKnf8EgeJxpHP6VeALGyRuoFySOAmXvq6AgeJPXmX5y6+lrHibwFzroKg38F CGDGOnyX+yftxyeuKolgSnTyp7dVT4BaVb56QfIIYMYuuyDHn4B/HHrjuGimROfV fdULIGfxrkgEMAvNeh+2U4vsPnMLPxn6mDuv+650ncELIWEtBmtg8I8cjfxde+z8 f80y+JmhatGMd158rTS+RTk4eAh/D5CX19CNd2Qmib/4OWm98+832rhzhzp+RWpZ 6bxvJ0/79P2ZiY3KWJcvDD77jbU1X6BekDgCGIG6njqpSmxF1oq/i+y8bnit5Tz1 gsQRQIw3eBEQ1MTgjYEJoHlPH6VeAEd0/E69IHEE0LrLnbkYA9S6jVcvSBwBNO7I gfwVwC8IIIzZ9iODZ/+jFv/vI/WCxBFA09pMLlJPgDsIIExpPIV3AGOVPd5UL0gc AbSME2Cwuj1HqRckjgAaNrSnegGcQgBhyH2nqRfALQQQdkR8b2P4jwDCjJMeUi+A a3Zy6BY1CSGARu3/Ml96VMNpMDBi+w84ARrVEUDYsOkXBm8Ahvps87l6QeIIoEVt vylWT4CDeC8wLGg2qZV6AlxEAGFA4bd1XcMfdm02Ub0gcQTQnAZfdlFPgJu4IjTC 91Z39QI4qt0s9YLEEUBrhu2nXgBXNV6mXpA4AmjM4F7qBXCWwRoY/COb9ujx6gVw Vqqu+7sGigCacs/p6gVwV5XBdwcRQEtu+rN6ARxWUaBekDwCaMhVl6sXwGVlBt8f SQDtuOgG9QI4rdTgHbIIoBln3qVeALctbKZekDwCaEW/e9UL4LgfW6sXJI8AGnHy /XypUbeZ66kXJI+jwobj/s1XGvWY0km9IHkcFib0eZwvNOozbkv1guRxXFjQ6xm+ zqjXiB7qBcnjwDDg4CF8mVG/AcepFySPIyN8PV8w+B5PZO7us9QLkkcAg9fjVfqH dFxzmXpB8ghg6HoMM/gWd2Tj/NvUC5JHAANH/5CuPk+qFySPAIaN/iFte49UL0ge AQwa/UP6thqrXpA8Ahiy7m/QP6St5Tz1guQRwIB1H9lQPQH+sHhFfAIYMPqHTJQX qhcIEMBg0T9kZEFz9QIBAhgq+ofMTO+gXiBAAANF/5AhixeDIYCBon/I1LAD1AsE CGCQOP8PGbv3DPUCAQIYIvqHzF1xtXqBAAEMEP1DFk58VL1AgACGh/4hG7uNVi8Q IIDB2fdl+ocstJqrXiBAAEPD9Z+RlSqT/7tJAAND/5CdJU3VCxQIYFjoH7L0Q3v1 AgUCGJTDBtM/ZOft7uoFCgQwJNz/F1l79ET1AgUOmIDQP2TvqivVCxQ4YsJx9JN8 NZG1Y59SL1DgkAlGn8f5YiJ7Fu8IQgDDQf+Qk4aV6gUKHDSBOOFhvpTIwbLG6gUS HDVhOPl+vpLIhc3TAAlgGOgfcjRyb/UCCY6bENA/5Or289QLJDhwAkD/kLM/Paxe IMGR4z/6h9xtOU69QIJDx3v0D7lLNaxST5Dg2PEd/UMESovUCzQ4eDxH/xCF7zqq F2hw9PiN/iESLx2kXqDB4eM1+odoXHqteoEGx4/P6B8i0v1t9QINDiCPnfQgXz5E o7BcvUCDI8hfXP8FUVlcrF4gwiHkLfqHyHzdRb1AhGPIV72f5muHqAw6Sr1AhIPI U9z/AxE66271AhGOIj/RP0TJ6DuBCaCnuP85olSVr16gQgB9RP8QqZnrqReoEEAP Hfgi/UOUXu6pXqBCAP2zx+tmf2BBPC68Wb1AhQB6Z8e3G6onIDBdJ6gXqBBA32zz YYF6AgJTYfevFAH0zJafFKonIDTTO6gXyBBAv2z6P5v3r0achhymXiBDAL3S8Uuj Vy5HnMy+D4QA+qX9+HXUExCg9j+oF8gQQI+0mdBCPQEBsnpDpOUIoD+af9NaPQEh eru7eoEOAfRG0bft1BMQpKuuVC/QIYC+KPza6I0LEbdu49ULdAigJxqM3Vw9AWEq t3xmKQH0xKjd1QsQKLOXw1+OAPrhpQPVCxCq/v3UC4QIoBcG9FEvQLB2eUe9QIgA +uCOs9ULECzDV0LII4BeuPQf6gUI14Su6gVKBNB9p92nXoCA3XqBeoESAXQeN4BD nDabqF6gxLHlul3e4gYgiI/lNwLnEUDndfvc9HPUiNvIvdULpAig29b7xvb/QCNu Z9+lXiBFAJ1WPKWVegLC1mqueoEUAXRZ/rdcAAGxKllXvUCLALps5J7qBQjcgOPU C7QIoMOeOFa9AKH73cfqBVoE0F3X/U29AKFb2kS9QIwAOuuU+9ULELzh+6oXiBFA V/V4ja8N4tbnSfUCMQ4yR3X5ghOgEbeqwkr1BDEC6KbmU5upJyB8pi8GvQIBdFL+ pA3VE2DA1VeoF6gRQCe9bvsNmkhGqsUC9QQ1Auiiey3fpQGJmdRZvUCOADqo373q BTCBn4AJoIO4AiASwU/ABNBB601qrJ4AE/gJmAC6p+C7duoJsIGfgAmge4b3UC+A DfwEnEcAnXPTn9ULYMQ3m6oXOIAAuqXXYPUCWHH+beoFDiCATukytqF6AoyoaGz9 fcDLEUCXFMxsqZ4AK8xfCWsFAugS3gGHxOw5Sr3ABQTQIVdfpl4AMxYXqxc4gQC6 Y6/X+WogKY/3VS9wAoecM1pP4x0gSMzGk9ULnEAAnfE1p2UhMVM3Ui9wAwF0xV1n qhfAkHPvUC9wAwF0xL7D+FIgMWVNqtQT3MBR54aW31u/QSuSNPhI9QJHEEA3jN1C vQCWbPKteoEjCKAT/nGpegEsmdJJvcAVBNAFW3/KNaCRoHPuVC9wBQF0QINZrdUT YMmyIl4C+QUBdMCTx6gXwJRHTlIvcAYB1Dv4BfUCmJJqPVc9wRkEUK7J7KbqCTBl JBcdWokAyr14kHoBbNnuU/UCdxBAtcOeUy+ALdM2VC9wCAEUa1LCW0CQqNPvUy9w CAEUG9pTvQC2LOEp59UQQK19X1UvgDE3X6he4BICKNXgx+bqCbClvGm5eoJLCKDU Q5yRimQ9/Cf1AqcQQKWt/svnH4mqarlAPcEpHIBKkzqpF8CY53qpF7iFAAqdeZd6 AYxJdfhBPcEtBFCn0TxuA4dkvb6PeoFjCKDOU0erF8CY1KZcCXpNBFCGV0CQtBE9 1AtcwzEo8+Xm6gUwhm8A10IAVQ59Xr0A1vAN4FoIoMrsddULYAzfAK6NAIpc/E/1 AljDN4BrI4Aa+Ys4BQbJSnWerJ7gHgKocdeZ6gWwZujB6gUOIoASTeYXqCfAmKq2 JeoJDiKAEo8er14Aax7vq17gIgKo0HJ2vnoCjClvXqqe4CICqDDoSPUCWHPrBeoF TiKAAi1KGqgnwJglzSrVE5xEAAUG9FEvgDXn36Ze4CYCmLxmP/IMIJI1Y331AkcR wOQ9fKJ6AazZe6R6gaMIYOIKFnMOIJL15h7qBa4igIm78S/qBTCmquP36gmuIoCJ W9RUvQDGcA50rQhg0s6+Q70AxixtsUw9wVkEMGkz2qkXwJhz7lQvcBcBTNhO76oX wJipG6kXOIwAJmzU7uoFsCW13WfqCQ4jgMlqPZvPOBL17BHqBS7jcEzWQyepF8CW Za2WqCe4jAAma0kT9QLYcsGt6gVOI4CJ6jNAvQC2TN5YvcBtBDBR47qpF8CUVLev 1BPcRgCT1GYmn28k6b7T1QscxwGZpP6nqhfAlLnrVqknOI4AJmluC/UCmMJVsOpD ABO07SfqBTDlxUPUC5xHABP07OHqBbCktDU3gqsPAUxQaWP1AlhyzNPqBe4jgMk5 4GX1Aljy+j7qBR4ggMkZtp96AQxZ1naBeoIHCGBylhWqF8CQkx5RL/ABAUxMz6Hq BTCE+yClhQAmhp+AkZyydvPUE7xAABPDa8BITt/H1Qv8QACT8vsP1Qtgx6v7qxd4 ggAmZUAf9QKYsWRdToFODwFMSkkr9QKY0ZNTTtNEABPSdqZ6AcwYdJR6gTcIYEIu ukG9AFb82LZSPcEbBDAhY/6gXgAjUtt/qp7gDwKYkLIC9QIYcc1l6gUeIYDJ+MMY 9QIY8eUW6gU+IYDJ4H7ASEZZ+xL1BJ8QwGRM6qReABu4CGBGCGAyKvLVC2DCk5xv nxECmAieAkQipm/IbeAyQgATwf0wkYSKTaaqJ3iGACbiqy7qBbDg+MfUC3xDABOx tJF6AQx4+hj1Au8QwCRsyA8miN+MDjwBmCkCmITzblUvQPgqNpusnuAfApiEFw9S L0D4TnxUvcBDBDAJP6ynXoDgDT5SvcBHBDAJnAaNuM1szxOAWSCACdhirHoBQlfR 9Vv1BC8RwAScf4t6AULHGYDZIYAJePZw9QIE7uE/qRd4igAmgEvBIF4TuqoX+IoA JoBboiNWizvMV0/wFQGMX5Ml6gUIWtXOH6gneIsAxm+PN9QLELQLb1Yv8BcBjN8l 16gXIGTP9VIv8BgBjN/zh6oXIGBcAzUXBDB+EzdRL0C4yjaaoZ7gMwIYv/nN1AsQ rNSBw9QTvEYA48c7gRGbGy5WL/AbAYxdM87RQlxe3V+9wHMEMHbd31IvQKhmbFCp nuA5Ahi7s+9QL0CglnXiBZAcEcDY3XmWegHClNprlHqC9whg7F7fW70AYfrrjeoF /iOAsZvSUb0AQRp0lHpBAAhg7Baso16AEH2zqXpBCAhg7MobqhcgQFwCKxIEMHYp 9QAEqOp3n6onBIEAxm396eoFCNCfHlYvCAMBjBvnQSN6952uXhAIAhi3E/mfakTt zT3UC0JBAON25RXqBQjN7A7l6gmhIIBx63+qegECU7bJNPWEYBDAuL26r3oBwpLq MVI9IRwEMG5jt1AvQFguuU69ICAEMG68Ew6Reukg9YKQEMC4zV5XvQAhmd1WvSAo BDBuC4vVCxCQipaL1BOCQgDjtqxQvQAB2fwr9YKwEMC4VTZQL0A4eAdcxAhg3LgW AiJz+PPqBaEhgDFr+aN6AYJx5znqBcEhgDHbYqx6AULxJaeURo4Axmynd9ULEIjS 9bkEauQIYMz2f0W9AGHgHXBxIIAxO+pp9QKE4ZY/qxeEiADG7NT+6gUIwtdd1AuC RABjduG/1AsQgrINZ6knBIkAxozroSIKxz6lXhAmAhizm3jmBrkbcph6QaAIYMzu 4e41yNnC1lwDPx4EMGYP/km9AP7bc5R6QagIYMweO069AN57vK96QbAIYMyePEa9 AL5b2LJSPSFYBDBmg3upF8B3PV9WLwgXAYzZ6F3VC+C5Vw5ULwgYAYzZ+K7qBfBb RZt56gkBI4Axm9RJvQB+u/lC9YKQEcCYTV9fvQBem9+qSj0hZAQwZjO5iyFy0Y+r acSJAMaspJV6AXz2Y2v1grARwJjNa65eAJ+ddbd6QdgIYMwWrKNeAI8tbaJeEDgC GLNFTdUL4LGHeSt5vAhgzEobqxfAY+24DGq8CGDMljZSL4C/pndQLwgdAYzZskL1 Avjr9vPUC0JHAGNWVqBeAH9tNlG9IHQEMGblDdUL4C1eA44dAYwZAUTW3tlFvSB4 BDBmBBBZ4ynA2BHAmFXkqxfAW72fUS8IHgGMGQFE1tr/oF4QPAIYs8oG6gXwVYq/ O7EjgDEjgMhWaZF6QfgIYMx4LzCyNaeNekH4CGDMZq+rXgBfTd5YvSB8BDBmXBAV 2Xq7u3pB+AhgzOa2UC+Ar4Ycpl4QPgIYMwKIbA08Wr0gfAQwZlwSH9l67Hj1gvAR wJgtLFYvgK8eOlm9IHwEMGYEENkigPEjgDEjgMjWA6eqF4SPAMaMACJbfAcYPwIY MwKIbBHA+BHAmBFAZItXgeNHAGNGAJGt5w9XLwgfAYze+r/bttsRXAga0agY/OWn /+HCgDEhgBFq8rsdd/jtesVcAAtRq1o0438fvP+fUvWO4BDAaGy5x27btW+sXoHA LZ3+yVujxqpXhIQA5qzFAYfuvD7f9SEpVT+8O+SVeeoVgSCAOcnvddxu66hHwKCF bz3+bKV6RAAIYPY6n3NIR77zg0rV1Bfu+FY9wncEMEtNLjqlg3oDzPv+gRt5YSQX BDArvc7Zhe/94IKqMXc8q97gMQKYufwrz2mm3gCstOCOK3k6MEsEMGM3ncnpLnDL 0rsvVE/wFAHM0MWXN1FPANZSevX16gleIoAZ2WvAeuoJQI1m/HGkeoKHCGAmBh3B 5wuuSg3urZ7gHw7o9HV/gTu8wWXzDhmtnuAbApi2i6/JV08A6lR5Kc8EZoYApmvw 4Xyu4LrUc0eoJ/iFgzo9zT/rpJ4ApGHyNvPVE3xCANOy6Sdc8gB+WLjdRPUEjxDA dGz6KRe2hy8WbUsB00YA00D/4BMKmD4CWL9NP2uqngBkYPE2FDBNBLBeLafy/R/8 sqjjXPUETxDA+uwzqLl6ApCh+b2Hqyf4gQDWZwkXP4B/SovUC/xAAOvxVnf1AiAL o3dTL/ACAaxbv3v4DMFHqTPuU0/wAYd3nQoXFagnAFkpLy5TT/AAAazThM3UC4As fd1FvcADBLAu593C5we+Sl1wm3qC+zjA69B8Nj8Aw1/lbbguQn0IYB3GdVMvAHLw 5RbqBc4jgLXb/yXu/QufVfUcpp7gOgJYu3m8BQR+m89NHOpBAGt1/UV8cuC31I0X qyc4jmO8VmW8AgLflReqFziOANbm9b3VC4CcjeihXuA2AliLooW8AgL/Va2zRD3B aQSwFpM6qRcAEZi8sXqB0whgzXZ+m28AEYKqXd9VT3AZAawZp8AgEJwKUxcCWKOz b+cTgzCkzr1TPcFhHOc1WshtQBCKRdzTunYEsCYXXc/nBaFIXXyjeoK7ONBrMpen TRCOeS3VC9xFAGtwzBN8WhCOVJ+n1BOcxZFeg7FcRQghGbeleoGzCODams3lHECE pKrlAvUEVxHAtd11Bp8VhCR1z1nqCa7iUF9bJd8AIixV+eoFriKAaxnYW70AiNig o9QLHEUA1/IjJw0gNHNbqRc4igCupYIfFxCayobqBY4igGvhKUAEhycBa0EAq3tl f/UCIHKvHKhe4CYCWB0XwkKAuChWzQhgdTwFiADxJGDNCGB1PAWIAPEkYM0IYDUD +qgXADF44o/qBU4igNVMX1+9AIjBD+3VC5xEAKvhdugIErdIrxEBrIanABEkngSs EQFcU/ECPiMIUarZIvUEF3G4r+klzhdFmF7uqV7gIgK4Jq6EgEBxPYSaEMA1lXO+ KMJUwct7NSCAa+I1EASKV0FqQgDXVMUnBGFK8b/tNeB4X8Ozh6sXADF5rpd6gYMI 4BpKeKIYofqxtXqBgwjgGngNBMHivSA1IIBr4DUQBItXQWpAANfAayAIFq+C1IAD fnW3nateAMTm9vPUC9xDAFc3vqt6ARCb8d3UC9xDAFe3sFi9AIjNwmbqBe4hgKvj fiAIGG+GWxsBXB2vgSBgvAqyNo741XQZz6cD4UptPkE9wTkc8at58SD1AiBGQw9W L3AOAVzND+upFwAxmsEdv6ojgKtZ2ki9AIjRssbqBc4hgKvhjXAIGm+GWwsBXKXF j3w2ELJUq3nqCa7hkF/lqKf4bCBkqWMGqie4hkN+lbd3US8AYjVmV/UC1xDAVea2 UC8AYjWPmx5WQwBX4WqoCBzXRK2OAK7CPYEROO4NXB0BXKWM94ojbHwHWB0BXIVL ISBwnAhYHcf8KgQQgSOA1XHMr3TJP/hkIGypy65VT3AMx/xK3BQdwXv2CPUCxxDA lbghCIL31ebqBY4hgCvNa65eAMSMM6GrIYArcUMQBK+Sk/3XRABX4kVgBI/bglTD Qb8SAUTwCGA1HPS/+tt16gVA3FJ/v149wS0E8FcP/km9AIjdQyerF7iFAP5qNJdK Q/hG76Ze4BYC+KsZ7dQLgNhxY7g1EcBflXLHLIRvaRP1ArcQwF/xIjAM4HIIa+Ko /xUBhAEEcE0c9b84/hE+FQhf6oTH1BOcwlH/ixv/ol4AxC9148XqCU4hgL8Y2lO9 AEjA0IPVC5xCAH/BxbBgwvhu6gVOIYC/KOF+WbBgThv1AqcQwF9wSziYUNZIvcAp BPAXnAUDEzgPZg0c9r8ggDCBAK6Bw/5nx/2bzwQsSPUdoJ7gEg77n137d/UCIAmp 6y5VT3AJAfzZ84eqFwCJeK6XeoFLCODPJm6iXgAkYuJm6gUuIYA/m99MvQBIBHfG XB0B/Fk5twuEDeWF6gUuIYA/4ywYGMF5MKvjuP8ZAYQRBHB1HPc/I4AwggCujuN+ hb9fq14AJINbA6+OAK7A1QBhRWroIeoJDiGAK0zeSL0ASMikzuoFDiGAKyxYR70A SMj8FuoFDiGAK3A1QJjBFQFXQwBXqGygXgAkpJKT/lchgCtwFgzM4DyY1XDgr0AA YQYBXA0H/goEEGYQwNVw4C93+t18HmBFqt/96gnu4MBf7s6z1AuApKTuPFc9wR0E cLmRe6oXAIkZ0UO9wB0EcLnp66sXAImZtqF6gTsI4HKljdULgMSUFqkXuIMALseL wDCEl4FX4chfjgDCEAK4Ckf+T865jU8D7Eidc5d6gjM48n9ybz/1AiA5qXvPVE9w BgFc7vptu7VuwqcC4UstnjP+07+rV7iDo36Vvttu1a11Iz4jCFGqdM74Lz57XD3D NRzuazl+2y03b92YTwzCsLx84z59TD3DURzntem7zZb8XAyPVS1ZXr4B6hlu4wCv z5W/79qmmOulwh+Vi2Z99dHV6hV+IIBpOm/rLl2aF6pXALVLlc2b8PXnd6hneIUA ZubY7Tbvum4x1xSHSyoWzp7w5adPqWf4iABm5/htN+/aqiln1EOpclHJhK8+4fWN HBDA3PTZvstm6xbzozESlCpbOOfrCZ88qd4RAgIYkVO277xpy6bcXRPxKV/848Rv P35QPSMoBDBqp2zfaZNWTQv5xCIaqWWLf/x20icPqHeEieM0Nof+vt3GnVoWkUJk IVW2eN6kyTM/GqIeEjiOzgQc8Lv1fkphcWNeM0HdKpYtnDf525n/eUU9xAwCmKye O6zbcaMWxU0K+MTjZ6ny0oXzp0yd88FL6iUWcRzq7L9T69btOxYXFXBaoTUVZaWL pk4vKXn3VfUS6wigI/bt3qJlhw7FTRoV8La7EFWVL1uyeNr0uXPffk09BashgE7a fdfmLZu169C0SaOGPHHopVRVxbLSxd/PnD9v/ttvqsegVgTQC7vvuU7z4nbtixo3 KshvwNfMPamqyvJlpUumz1o0f+Ebb6rXIG0cTJ7aaf+i4mZNW6/fuHFhQX4+X8Yk pSory8uWLv2hZPGCRUuGvaeegxxw5ARkmwOLiouLmrRq17iwsLDhT1nkq5ub1E+p qygrK1s688fSJYsWLXn5M/UiRIxDxIDNezUqalzUpHHLNo0KCwsKGuY3aEAbV0ql qqoqK8rLy8qWzZ67tHTJ0iXLnh2vHoWEcBwYt2Hv/KKixo1/KmOjFusWFBY0/Ok7 xwbLAxnK34zU8sBV/fSdXEV5Wfmcect+6tzSpUuWVA76Tr0MDgjlrzl80Lqef1+S yApgJQIIwCwCCMAsAgjALAIIwCwCCMAsAgjALAIIwCwCCMAsAgjALAIIwCwCCMAs AgjALAIIwCwCCMAsAgjALAIIwCwCCMAsAgjALAIIwCwCCMAsAgjALAIIwCwCCMAs AgjALAIIwCwCCMAsAgjALAIIwCwCCMAsAgjALAIIwCwCCMAsAgjALAIIwCwCCMAs AgjALAIIwCwCCMAsAgjALAIIwCwCCMAsAgjALAIIwCwCCMAsAgjALAIIwCwCCMAs AgjALAIIwCwCCMAsAgjALAIIwCwCCMAsAgjALAIIwCwCCMAsAgjALAIIwCwCCMAs AgjALAIIwCwCCMAsAgjALAIIwCwCCMAsAgjALAIIwCwCCMAsAgjALAIIwCwCCMAs AgjALAIIwCwCCMAsAgjALAIIwCwCCMAsAgjALAIIwCwCCMAsAgjALAIIwCwCCMAs AgjALAIIwCwCCMAsAgjALAIIwCwCCMAsAgjALAIIwCwCCMAsAgjALAIIwCwCCMAs AgjALAIIwCwCCMAsAgjALAIIwCwCCMAsAgjALAIIwCwCCMAsAgjALAIIwCwCCMAs AgjALAIIwCwCCMAsAgjALAIIwCwCCMAsAgjALAIIwCwCCMAsAgjALAIIwCwCCMAs AgjALAIIwCwCCMAsAgjALAIIwCwCCMAsAgjALAIIwKz/DwAPu7XAD5+RAAAAAElF TkSuQmCC"/></symbol><g mask="url(#b)"><g transform="rotate(.193) scale(.36014)"><symbol id="c" viewBox="0 0 1280 1280"><image width="1280" height="1280" xlink:href="data:image/png;base64, iVBORw0KGgoAAAANSUhEUgAABQAAAAUACAIAAACXhmigAAAACXBIWXMAAA7EAAAO xAGVKw4bAAEgIUlEQVR4nOzdd4BU5b3/cbawvU3dmd2NURBbRL1Xo9FITDSJLbnX Fu9VY4t41XiDLfkpokCugoCxYgVir1gApamAShHQqKhEIygQhWXZKTtnZqefmfN7 2Em4XOrszGkz8379sSE453m+u8Ds+ezznO9TNgAAAAAAgBJQZnQBAAAAAADogQAM AAAAACgJBGAAAAAAQEkgAAMAAAAASgIBGAAAAABQEgjAAAAAAICSQAAGAAAAAJQE AjAAAAAAoCQQgAEAAAAAJYEADAAAAAAoCQRgAAAAAEBJIAADAAAAAEoCARgAAAAA UBIIwAAAAACAkkAABgAAAACUBAIwAAAAAKAkEIABAAAAACWBAAwAAAAAKAkEYAAA AABASSAAAwAAAABKAgEYAAAAAFASCMAAAAAAgJJAAAYAAAAAlAQCMAAAAACgJBCA AQAAAAAlgQAMAAAAACgJBGAAAAAAQEkgAAMAAAAASgIBGAAAAABQEgjAAAAAAICS QAAGAAAAAJQEAjAAAAAAoCQQgAEAAAAAJYEADAAAAAAoCQRgAAAAAEBJIAADAAAA AEoCARgAAAAAUBIIwAAAAACAkkAABgAAAACUBAIwAAAAAKAkEIABAAAAACWBAAwA AAAAKAkEYAAAAABASSAAAwAAAABKAgEYAAAAAFASCMAAAAAAgJJAAAYAAAAAlAQC MAAAAACgJBCAAQAAAAAlgQAMAAAAACgJBGAAAAAAQEkgAAMAAAAASgIBGAAAAABQ EgjAAAAAAICSQAAGAAAAAJQEAjAAAAAAoCQQgAEAAAAAJYEADAAAAAAoCQRgAAAA AEBJIAADAAAAAEoCARgAAAAAUBIIwAAAAACAkkAABgAAAACUBAIwAAAAAKAkEIAB AAAAACWBAAwAAAAAKAkEYAAAAABASSAAAwAAAABKAgEYAAAAAFASCMAAAAAAgJJA AAYAAAAAlAQCMAAAAACgJBCAAQAAAAAlgQAMAAAAACgJBGAAAAAAQEkgAAMAAAAA SgIBGAAAAABQEgjAAAAAAICSQAAGAAAAAJQEAjAAAAAAoCQQgAEAAAAAJYEADAAA AAAoCQRgAAAAAEBJIAADAAAAAEoCARgAAAAAUBIIwAAAAACAkkAABgAAAACUBAIw AAAAAKAkEIABAAAAACWBAAwAAAAAKAkEYAAAAABASSAAAwAAAABKAgEYAAAAAFAS CMAAAAAAgJJAAAYAAAAAlAQCMAAAAACgJBCAAQAAAAAlgQAMAAAAACgJBGAAAAAA QEkgAAMAAAAASgIBGAAAAABQEgjAAAAAAICSQAAGAAAAAJQEAjAAAAAAoCQQgAEA AAAAJYEADAAAAAAoCQRgAAAAAEBJIAADAAAAAEoCARgAAAAAUBIIwAAAAACAkkAA BgAAAACUBAIwAAAAAKAkEIABAAAAACWBAAwAAAAAKAkEYAAAAABASSAAAwAAAABK AgEYAAAAAFASCMAAAAAAgJJAAAYAAAAAlAQCMACgGNjttsrKSkUZkE6nPB6v0eUA AAAzIgADAAqey9Xa1NRUV1cnft3bp6tri9FFAQAA0yEAAwAKm0i/zc3NtbW1234n HA6HQiEyMAAA2AEBGABQwPrSb0ttbc0Ovy8ysCQFu7u7DakKAACYEwEYAFCoRPpt aWmpqdkx/WaEwxFJksjAAABgGwIwAKAguVwui6Wlurp6D68hAwMAgO0RgAEAhcfl arVYLHtOvxmRSCQQIAMDAICtCMAAgAKTffrNIAMDAIAMAjAAoJBks/N5Z2RgAAAw gAAMACgguaXfDDIwAAAgAAMACkM+6TeDDAwAQIkjAAMACkD+6TeDDAwAQCkjAAMA zE6t9JtBBgYAoGQRgAEApuZytba0tNTU1Kg4JhkYAIDSRAAGAJiX0+m0WFpqa2tV H5kMDABACSIAAwBMyuVqbWxsqq+v02h8MjAAAKWGAAwAMCObzWqxWBoaGjSdJRyO hELBrq4tms4CAABMggAMADCj9vZ2h8Ouw0ThcDgUCpGBAQAoBQRgAIDpdHS02+16 pN+M3j5kYAAAih4BGABgLu3tIv3aysp0/Q4VCoXC4TAZGACA4kYABgCYSFtbm8Nh 1zn9ZgSDoUiEDAwAQDEjAAMAzMLtdtnt9oqKCqMKCAaDkUiEDAwAQLEiAAMATMHl arVarVVVVcaW4fV6N27cZGwNAABAIwRgAIDx7Ha71Wqpq9PqyN9+IQMDAFCsCMAA AOPp3PZ5r8jAAAAUJQIwAMBguh35mz1FUXw+HxkYAIAiQwAGABjJ7XY5HI7y8nKj C9mRyMBer3fTpk6jCwEAAKohAAMADONytVoslurqaqML2bV0Oi0ycGfnZqMLAQAA 6iAAAwAMM3jwoMbGRqOr2JNUKiUy8ObNXUYXAgAAVEAABgAYw4SP/u5SMpn0+/1k YAAAigABGAAKUm1tbV1dnc/nM7qQHLndLrvdXlFRYXQhWYnH4z09ga4uMjAAAIWN AAwABamjo72qqioWi3d2Fl6XJpvNKtKvyPBGF9IP0WhUZODu7m6jCwEAALkjAANA 4XE4HHa7rbq6Oh6Ph0Ih8dHj8RpdVD+Y7dTfLIXDYfHV7uraYnQhAAAgRwRgACgw NTU1Nptt29Oz6XS6t7c3Go0WykOqbrdbFG/Cc4+yEQwG161bb3QVAAAgRwRgACgk VVVVDofDarVs//SsyMCJRELEYJ/PF43GDCxvr+xb2USGN7qQ3Hm93o0bNxldBQAA yAUBGAAKRm1trcXS0tDQUFdXt/N/TSaTkiTF4wmPx6N/bVkq0M3P21MUxefzkYEB AChEBGAAKBgOh6OpqbG+vn53+4dlWY5uFevp6RH/o3N5e+V2u8SnUKCbn7cnMrDH 4y3E9mMAAJQ4AjAAFIyOjnar1brXAClicCAQMNtSsMvV2tTUtMu160KUSqW8Xm+h PHcNAAAyCMAAUABqaqqtVltjY0OWRweJDBwOR2IxE3XGam9v39a4qzgkk0mfz0dT aAAACggBGAAKgNvtrtuqdvveV3uVOSQpFot7vQYfkmS321tbnQMHDjS2DNXFYrFA IEAGBgCgUBCAAaAA7Lfffg0N9f1KvxmpVCoSiUSj0UBAEr/QorZsFEHvq90Jh8N+ v9/n8xtdCAAA2DsCMACYndvttlotOS+fKooiAnA4HNm0yZjGxW63y+l0lpUV7Xcc j8dr1NcWAAD0S9HejgBAcXA6HY2NjQ0NDfkESJGBE4lEKBRKJJLBoBSLxVWscK+G DNm/vr5en7lkWa6srNRnru1xODAAAAWBAAwA5lVTU2232y0WSw6bn3cpHA5HIhGf z6dbBm5raxMZXp+5Kisqnn32ubPPOVv/DKwoisjAmzZxMBIAAKZGAAYA83K73Tab VcU4l06n4/G4iMHi44C+vbtqjbxLoniHw1FTU6PpLBmyLL/99jt2u/3TTz+94ILz 9c/A4msrMnBn52ad5wUAANkjAAOASYno2NjY0NTUpMXg8T7RaGzzZg0Dm269r1Kp 1IQ77jjt9F9k/u+ypUuvuuqqikp1ls2zJ0K41+vr6jLL0VMAAGAHBGAAMKPa2lqb zdrS0qLdSqYIjeFwJBqNaHRWsJ5HHx115FFTp03b/nfmzpl90003Vei+DhyPx3t6 ejgYCQAAcyIAA4AZtbW5GxsbRQzWdBZFUZLJZDAY1KKBk27Lv9VVVStWvr/z7z/5 +ON33XO3Wo9PZy8SiQQCge5uj87zAgCAvSIAA4DpZDY/iwCsz9FBiURCZGCv1xeL xdQaU3wKra1OHR7ElWV53rz5HR0du/yvd4wf/8KLL5SXl2tdxg5CoV6fzxsISDrP CwAA9owADACm09HR3tzcrM/m4YxkMilJks/nj0ajqgyoz/KvoigXXXjR9TfcsLsX iGB/3XXXffjhX/Q/hZiDkQAAMCECMACYi8PhsFotNTU1Ome2TAbuOy64N88YLKKv y9Wqw/Kv1WJduGjRHl4gPinxuVw+/LI1a9dqXczOyMAAAJgNARgATETkXrvdZrVa 9d+1mxEOR8LhcCAQiEQiOQ+iz/KvCLcL3lrgcruzefHJP/9Zt0fvh3I5HBgAALMh AAOAibS3t2U2P+u/ZXebaDTW29vr9+e4HVq35d/jjvvhHXfckeUxUel0+gc/OEZk Zq2r2nlej8er6VlTAAAgewRgADALER0tlpb6+nqjC9l6lk8oFIrF4l6vt7/X6rP8 O3DgwAULFtbW1mb/pHQ4HD7uuOPKy/X+xifLss/n0+isKQAA0C8EYAAwhYaG+ubm FrvdZuDa7w5EBpakYL8ysKi/tbVV6/ZdqVTq6aeePvyII/p74caNG0899RQdVqd3 kEgk/P6eri4yMAAABjPLbRYAlDin09nc3FxfX2d0If9L5EwR2/x+XzSa7fFI+iz/ HjDkgBenT8/t2pUrVwwfPlz/DCy+hpIU6OraovO8AABgewRgADCe4b2vdkdk4J6e niz3QttsVhHjq6urNS0pmUyuWLGyoaEh5xGmv/ji7eNur6ioULGqbITDkVAoSAYG AMBABGAAMF6m91VVVZXRheyCLMsiufX29nr21kVZfBYOh0PrevrV+2p3xo8bN/2l 6frvNg+FQuFwmAwMAIBRCMAAYDCHwy7iXGNjo9GF7FZmHdjn20tf6AMOGFJXp/EW bkV5d/GSfvW+2p1LL7l41SefqFJUvwSDwUgkQgYGAMAQBGAAMJLIcjabNXP0kdG1 7EkmA3u9vlhs188Du92u1tZWTWtQFGXM6DFnnnWWWgOecvLPt3R3qzVa9rxe78aN m/SfFwAAEIABwEitrVt7X4kYbJ7mz7uTTCYlSdrdOvCgQfvluS15r6qrqlesXKni gOl0+pijvy+nUiqOmSUyMAAAhjD7/RYAFLf29nar1aJ/Q6bc/HMv9I59od1ul9Pp 1DTDi7D64AMPHj9smLrDikg/bNiwigoDeo+RgQEA0B8BGAAM43a7bTar/kfy5ENR FBGAd9gLPWTI/vX19ZrOa7VYFi56W4uR13z55Vlnn2XIFnQyMAAAOiMAA4AxHA57 Y2Oj1tuGtSDLciAQ2LYXWmT4jo4OrZd/n3rq6cMPP1yj8d+YP/8Pf/h9he4/icj8 NIEMDACAbgjAAGCAmppqm83e0mL23le7k9kLnUluOpx+ZLVYFy5apOkUkyffP23a NP3PYSYDAwCgJwIwABjA4bA3Nzc3NDQYXUhevF6vLMuNjY2a7n/Wevk3IxgMXnvt tR999KH+3cjIwAAA6IYADAB6yxx9ZLEUTO+r3UmlUuFwpLGxQdPQ2NLc8vY772g3 fkYymYxGoxdfdNGGv2/Qeq5d4nlgAAB0QAAGAL05nY7m5matu0bpI51Oa7ptWFGU +++7/0cnnKDdFDv48QknSEFJt+m2RwYGAEBrBGAA0FVNTY3dbiuC5V99VJRXLF+x Qs8npZPJ5DHHHKMoad1m3F5mV3lX1xZDZgcAoOgRgAFAV06n02Jpqa2tNbqQwnD2 2eeMGDFC517ZIoWeeOJPjPoJhSQFo9EIGRgAAC0QgAFAPzU11Xa7vaXFUlnJ8u/e pdPpJUuW1tbW6t8re/Xq1eed959GHdEcCoXC4TAZGAAA1RGAAUA/7e1tjY2N1dXV +rcaLkQ/+fGP777nXqNmnzd37o03/j/9DwfOEAFYkoLd3d2GzA4AQLHiDgwA9DN4 8KCGBm17JiuKIj4WQcCWZfmjjz429pzkByZPnjptqv6HA2dEo1FJklgHBgBARQV/ hwQAhcLpdLS2tmr9ZGkqlRo4sCqZTBR6ky0ROz/88KPcrk0kElVVVfnXEAwG//CH P6xcucKoHyjE4/Genh4yMAAAaiEAA4AeMs2f7Xa71hMNHTp0xIhrnn/++TfffMOo R1hV8eADDx73wx/mcGFvb284HB7QF6EdDkc+NWQOB77yiiu++NsX+YyTZw1+v3/z 5i6jCgAAoJgQgAFAc1VVVSL6NjY2aN38OZVKTZ78wEEHHSR+/eqrrz7++OPxeMyo Hbz5yGf/85Yt/2e9tLm5uaamJs96Tjv1lM1dhkVQ8cfq8/k7OzuNKgAAgKJBAAYA zTkc9oaGxoaGek23JctyatCg/aZMmfrP/yvPmTNn6tQp4hfaTaqRY475waRJk3I4 /SgWi0mStMNvVldXt7S05FnSD487LhKN5DlIzhRF8Xp9mzZtMqoAAACKAwEYADTX 2uq02WyqPJW6O+l0WsS8q6767WmnnbbtN0X0/eCD9++++55QKKjd1KpLpVJLly7L 7fQjj8cjvhQ7/355ebndbs/nUd5EInHssT/Y5eD6EBnY5/Nt3EgGBgAgdwRgANBW XV2d1WrR+ulfkXV/9rOfX3PNNTtv9126dOl9990XCPQUSlssm9W2YOHCHC4UEXHP 5wY1NTXlsws9FAwO+9GPjG2wHQwGI5EIbbEAAMgNARgAtNXa6mxpsdTW5vsY6p7V 19dPmTLVZrPt8r8uWLDggQceiEYj5j8eSYTYefPmu93uHK7d1v5qD6qqqiwWS06l bSUC9s9+elK5oT9KSCaTgYCUSm3d2d536JWSkU6nfT6/gYUBAGB+Zr8TAoCCVlNT bbfbReLSdPU1lUqdeupp119//e5eIMvya6+99vjjjyUSCZNnYPG5fPjhR7m1vxLp NHMM8p7luR16w4YNv/zlL0zYYVt87uKrJ/6sUymRhVPxeDzz+Lf4koh0LD6K3yQh AwBKnKlvgwCg0DmdTqvVkn8X4j0Qmec739ln1KhRgwcP3vMrZ82aNWXKoyIUmTkD n3TST0ePHp1D+6sBO/V/3rN8tkN/+umnF1xwvgkz8J5lEvI/pWOx2LZl5L6ErFRU VLC5GgBQ3Mx7DwQAhU7kK5vNqvXyb3l5xcUXX3zGGWdUV1fv9cUrV64cN25cPB4z ZwYW4XzZsvdya38ViURCoVC/LslnO/SHf/nLxZdcnNtKtWml0+m+BeSU+CD+kvxz AVlJb03HitfrNbpAAADyZcYbIAAoDk6ns7m5qa6uTtO0eeyxx15zzbXZH/Pz2muv TZ06JR6Pm/B8YLfLPXfevNyuFfFMJLf+XiW+CA6HI7cZly1deuVVVxbcOnDO/rm/ eqvM/uptzx57vT6jqwMAICsEYADQRObpX5FLNQ1IIopMnTpt33337ddVM2fOfOih B00YgF99dcZ+++2X27X92v+8g+bm5ty2qS9dsuS3v/1tRWVhtNfWjgjDyaTIxnIs FusLxgP6cjHBGABgOgRgANCEw7G191Vtba12y78i/YroKwJwDtd+9tmno0aNSiQS qleVs5Qsf/rZ6tyuFZ9IT09PPrNXV1dnv4q+vYULF1537bVk4F3qC8ZJ8XHbinE6 rXg8HqPrAgCULgIwAGiitdUpaPf0b6Zl0dVX//fpp5+e2+UrVqy48847w+FekzwP PHBg1bJly3J7qlaSpFgslmcBOW+HLrW90HlKpVKJhEjFyUwqFpG4b62YB4wBAHow xU0PABSZ2toam81mt9u1m0Ikh6OPPnrUqFvq6+tzHmH27NlTpkxJp/v96KwWjjv2 uDsmTNCh//OetbS0ZNNObAdk4HwoiiL+NopUHI1G/rlQnPZ4iMQAAPURgAFAfa2t TpGjcj5lJ0u33z7uqKOOymeERCIxf/78qVOnJJNJtarK2Z2T7jzhxz/OYQVY5KXu 7m4VK6mpqWlubu7vVR/+5S+XXHoJGVgtfZE4EQ5HUqnMKnGKJ4oBAPkjAAOA+jo6 2q1Wq3ZdplKp1NChQ++++x5VRps5c+af/zzN2L7QIu18lusDwDkcgLRXuW2HLtDz gQuCoiiJrZLxeCyZTPIsMQAgNwRgAFCZCE4WS0tdXZ12U1RUVNxwww0nnniSWgPO nTv34YcfEvHCqOeBnQ7H7Dlzc3sA2OfzZU6sVV0O3aG/+mrtWWedpenJz8jI9NaK RqPJpJxOp9gyDQDIBgEYAFTW2uq02WxVVVUajZ9Op48++phbbrklt5N7dklE3xf6 pFKyIRn44osv+c1vfmP4A8A7E3+OFoulX5ds3Ljx9NNPM+EpU8UtmUzG44lYLNp3 IFOKrloAgF0iAAOAyjo62kVk0m4NUATUW28dfdxxx6k+8rRp06ZPn15erve3hpQs L132Xm1tbQ4rwLIs+3zaPhoqvuA2m61ff6A9fv+JJ500YICiXVXYg8x+aZGHt36I J5LJRCAgGV0UAMAUCMAAoCaHw261WmtqajRaR02lUt/73vfGjv1jbofW7tVbb715 111365zcRIj96KOPc9v/HAwGo9Go6iXtrL6+vqGhIfvXx2KxE370o0TSRCctlyxZ TsXjsb7N0knxa61/YgIAMDMCMACoyel0ut0u7XYRl5eX/9d/XfHLX/5SuxXmWbNm ZfpC67YX+qSTTho9ekxu+5+7u7sVRae4Lr7m/TraKp1On/zzn3t97MU1EfGHEovF IpGI+BueSnH+MACUHAIwAKimtrbWZrNqevzv0KFDb7zxJk2nEJ544vFnn31Wn05O KVl+d8nShvr63FaANX0AeJcaGxv71eHsrDPPWLd+vVHdxbAH24fhvr30fqMrAgBo ju/HAKAap9PR2Eej8VOp1OjRY4YNG6bR+NvMnv365MmT9cls5577H1dffXVuy7/R aDQYDKpe0l5VVlbabLYsXywqHDFixMcff0RbLDMT/7iiURGHo/F4ggOWAKCIEYAB QDVOp9Nu16r/s6IoAwcOnD17jhaDby+dTp922qlaz5IhkuTChYtya381QMsDkLKR 5VJwMpkUQf3RRx55+pmnOR6pIMTj8WAwJMs8MAwARYgADACq6eho125zskh6w4YN GzNmrEbjbzNp0qRFixZqPcuAvkh/7z33/vgnP8l5BP33P++gX08Fv/LKy2PHjhWZ X9OSoKJ0Oh2NxqLRCMvCAFA0CMAAoA6bzdrc3JzbVt5slJdXiGh66KGHajR+xqZN my655GJ9FiqtFsvCRW/nfHk8Hg8EAirWk7O6uros972vXLli+PDhZOBCFIvFent7 E4lEeXl5V5fBP3kBAOSMAAwA6nA6HRaLpba2VqPxhwwZMnnyAxoNvs155/1nT0+P 1rMM6DuZZuaMGYP33z/nEUSdIo2oWFI+ysrKmpqaampq9vrKb7/55pf/9kt6YhWu ZDIpSZL4mE6nPR6aSANAgeEbMACow+VqtdlsuT3LuleyLF988cUXXniRFoNv8+yz zz711JP6ZLMh++8//aWX8xnB8P3PO6uoqLBarXttdhUOh3/y4xOSxj29DFWkUqlw OBKPx+LxBMcpAUChIAADgDo6OtotFotGm4dramrGjv3jEUccocXgGd3d3eeff54+ u3NFnl+58v1+HSa0g2Qy6feb9NCagQMHihi859ek0+nTTzu1y3wZHjkQf58zSTgS iQQCktHlAAD2hAAMACqw2+3NzU319fVaHHWjKMqxxx57ww2/1+6AJeFXvzonFApp N/72fnrSSXf+6a58RggEAvF4XK16tFBVVdXS0rLn5fTLfvObDz/6kO3QRSOzO5rn hAHAzPimCwAqcDgcLS3NIgBrMXgqlRo3bvzRRx+txeAZ48ePX7z4Xe3G357I86tW fZLnICbc/7xLlZWVzc3Ne1hX/9Oddz751FOVlRyPVFREBg4Gg+Jjdze9owHAXAjA AKACp9NpsbRo1wHrtdde1+h4YeHNN9/805/u1GLtemci/d488uZz/+M/8hnEPP2f s1RWVlbfZ5f/9bVZs0bdMorW0MVH/G2PbBUVf2N5SBgATIIADAAqaG11OhwOLTKM uIf+znf2mTZtmuojZ6xZs+bqq3+rz7lHA7aeGFS/bNmyPAfx+/3JZFKVenQmvs51 fXb4/dWrV59//nm6/SlAZ7Kc6unpEX9pu7u7ja4FAEodARgAVNDa2up2u7QYWdw6 n3feeZdddpkWg4vb8Qsv/LVuz6CmZHnmzFmDBg/Oc5xC2f+8B+Xl5TV9trUN7/H7 TzzpRGOrgtYyhwnHYiwIA4BhCMAAkK+6ujqr1WK327UYPJ1OT5v253322Uf1kf1+ /wUXnK8oiuoj786R//qv0/78WJ6DRCIR3Zp16UOE4aqqKpGEv1q7duzYMaGteuPx mJxKD1DS5RUV+uxOh25SqZTfv/UUa4+HJ4QBQG8EYADIl8PhaGxsbGrSpEXzwIFV r7/+uurD+v2+X//61yJdqz7y7oi5Pv54Vf5Zrru7W8/QrrOysrLMZye+UBV9fF7v qk8/3bRxY6+Ixb0hEZkCfYLBUCKZkGVZvF5cxfbpQhSJRMLhSCIR93hYEAYAnRCA ASBfTqejubm5rq5O9b3EqVTqgAMOuPfe+7ZtlFXF3/72txEjfqfnuqIIaePHjTvt 9F/kOY7Iez6fT5WSCkUymQxHIuIX9XV1u/tr4PF6//rXvwYlSerp6erq8vm8ASkY CPSIxCwnk6m+H3OIhMx5S+aUOTwpHmdBGAD0wPdCAMiXCMAWi0WLFtAi75188skj RlxTXV2t1pgLFiyYOHGCzguG+31331dnzsx/nMJtf6WpTEjeQ0IWNm7cuGLlynAo JLKW1+vx95GkYCKZVJR0eR89a8YO0ul0b6/4Y4x0dXUZXQsAFDMCMADky+GwOxwO LY4pEvfE559/wa9//Wu1+kvffvttixcv1jnqiBj/l798qEqGL4L2V0bZc0gWX9j3 P/igx+cTqbira7PH4+np6YlEY+LPboCSrqisZPVYH4qihLem4HBn52ajawGA4sT3 MwDIl3MrTc5ASqVSI0fefOKJKjQH3rBhw+WXD9f/SVFxQ3/rrbeeffY5+Q8VCoUi fZuBobo9x+OgJH366adff/31t99807Wly+v1SlIwKSfFXURlJc8eayIajfb29obD 4UBAMroWACgqBGAAyJfL1Wq32zUKwI8+OmXQoEF5jjNhwoRFixYassf1u/vsM3PW a6oMxfKv2Xi83lUff9y9ZcvmzZs3bvxW/AEFAoGkLNOUSy3xeDwUCokw7PP5ja4F AIoEARgA8tUXgB1aLIUNHDjwiSeetNlsOY+wePHi8ePHDxhgTNtkWZY/+eRTVYJ3 ZjUs/3Ggot2tG4tgvGzZsq7Ozq7Nm//+7TcejycWi5GKc5bpkkUMBgBVEIABIF+t rU632636sIqiWK3Wu+++J7fB16xZM3bsGJ/PZ9TTm6L+Rx5+5AfHHqvKaCz/FpBd BuNMKt74zTednZu+/Xaj1+dNJBKVPF2cNWIwAKiC7zoAkC+Xq9Xlcqk+rAiQzc3N 06b9uampqV8XfvPNN+PHj1u3bp2xfX0POeSQhx9+pL/F71IkEgmFQvmPAwPtnIoD kiT+lv71s8/+vmHD1+u+3tLtSSTi9KPes0QiEQwG43GODgaAHBGAASBfIgA7nU7V 79pFAK6pqZ01a1b2l3z11Vd/+tOfvv76K8P3mippZfGSJbW1taqcYMzyb1HaZSRe v2HDpx9//NXatevWr/N4fel0Soun6wsdMRgAckYABoB8iQDscDhUz5zpdLqj4zuP PfZYNi9evnz5fffd6/f7zbB6lkqlli5dpsraryBu9KPRqCpDweR2jsQer/fdd99d ++WX69et29i5SUQ+VX6kUhxEDJYkSfxz6+riJ0QAkC0CMADkS6Mt0LKcOuyww267 7bb6+vrdvUaE5Gefffall6aLYGCSZykVRbn+uusvuvhitQZk+beU7RCJMw8Sf756 9Vdfre3c3CUnk5UDS319OBqNBoOhzZs5NxgAsmKKuyUAKGitrSIAt6qeP0WS/N73 Dr3jjjuqq6t3/q9+v3/y5PtFGDDDku/2hgwZMn36S2qNJj5NEYHUGg2Fboc8LP7v BytXLnp70V//+leRjSsqKkzyYyCdifeKvi7p4a6uLqNrAQCzK8XvEwCgLhGAnU71 t0ALRx555Lhx43f4TRF6//znP3/77TeGP+i7M3EjvmrVJ2qNJsuyz+dTazQUt4Ak fblmzYqlS0UY/mbjxpScrCixh4fT6bTf74/F4l4vDwYDwG4RgAEgXxo9AyzC5FFH HXXzzaMyW6DFre1DDz20dOkSdWdRUSqVeuedd61Wq1oDejwecU+v1mgobjssDsdj sfnz5i1YuHDd+nWJeLx0wrAspwKBHvpjAcDuEIABIF+tW6nfBVoYNGjQmDFjFy9e /PLLL4kAbMIl321EUn3ggQeHDRum1oD0voJaxF+keXPnLFq0aN269YlkohTaSosA LElSZycPBgPAjgjAAJAvl2trAtbi4cPy8opkMmHm3JuhKMrll//X1VdfrdaAbH6G RkQYfvWVVxYtWvjtt9+WlZcX8TPDfQ8G9/Y9GEwbOQD4X0X7vg8AuhHp1+1Wvwt0 ATn+h8dPfuABFQfs7u4Wt+8qDgjsICBJn3zyydzZs//25d9ESizWZeFUKtXT08OD wQCwDQEYAPKl3QpwQdh3331nzJip4oCSJMViMRUHBHa2/TPD8VhszpzZc+bM+fs3 31ZUFOGysPgHFQwG2RENAAMIwACQPxGA7XZ7sa4g7VlDQ8O77y5W8fnneDweCATU Gg3ol4Akvfvuu/PmzF63foNIwcWUhBVFCYV6IxF2RAModcXzzg4ARtGuCZbJVVdX L126TMXkL+7Ru7u71RoN6K9ty8Li46efffbajBmff/GFLCeL5l+3+AQDAWnTpk1G FwIAhiEAA0C+SnMFeODAqqVLl1ZVVak4Jo/+wiS2T8IiA7/y0vS/rv5rWkkXRxIO hTLNsbqMLgQADEAABoB8tba22mxWdaOgyam+9iv4fD5ZllUcEMjf9kl41apVr7z0 0pdr1hTB7mjxb62nJ8BSMIASVNhv3wBgBk6ns6mpqaGh3uhCdNLe3jF79mx1x+TU X5jc9kl4xYoVr7780rr16wt930dvb7i3N8RTwQBKCgEYAPJVU1NjsbS0trYaXYjm FEU56sgjp/35MXWHDYfFXXivumMCGtmWhMWvZ82Y8dLLL/n8/sJNwqlUyu/vYSkY QOkgAAOAOo444nCjS9CWSL///u9n/PGPf1R32Gg0GgwG1R0T0E1AktZv2PDi88+t WrVK/Bsp0K3RvVvxVDCAklCQb9MAYELFHYBTqdTIm0aed/756g7LoUcodNtvjV62 bJlIwp2bNxfigrD4RHp6Ap2dnUYXAgDaIgADgDqKOACLO+N58+Z/5zvfUX1Yv9+v 7piAUbYl4Xgs9qc//Wn58vfKCq1ltKIoPp8vHo97PF6jawEArRCAAUAdxRqAKyoq 3n//A9VPf5FlWdxqqzsmYB4iD8+dM+eZZ54JSAHxj8jocvohFosFAhLboQEUKwIw AKij+AKwoigHH3jQ8y++qPrIiUSip6dH9WEBswlI0urVq5964vHCahmdTqf9fv/G jXTGAlCECMAAoI4iC8CyLI8ZPeacX/1K9ZFjsZgkSaoPC5jQ9vuiJ0yYsPL9lQW0 GhwK9YbDvRySBKDIEIABQB3FFIDLy8vnzp2nxcFOkUgkFAqpPixQEEQefmDy5Plv zC+UZtGZNnWbN7MdGkDxKIz3XwAwv+IIwOl0euihhz7z7HNaDC6irwjAWowMFBAR g199+eWnn3k6KcvmT8JshwZQZMz+tgsAhWLw4MGNjQ1GV5GXVCo1ccLEU087TYvB e3p6EomEFiMDhSggSXNmz37u2WflVAHE4GAwGIlE2A4NoAiY/Q0XAAqFy9XqdDpV 75asj3Q6PWi/QdNfemngwIFajO/1ekW61mJkoEBlHg8W//Ref/21F194QfwDMXkM jkajkiSRgQEUOlO/1QJAYTnssKGFGIBlWR47duzZZ5+jxeCKong8HvFRi8GBQrd9 DH7h+efFL8wcg8V7hd/v7+zcbHQhAJA7877JAkDBGTr00AJq8Tqg73b26O9/f8rU aRqVTcNnIBvbYvCMGTNenj49rZg3BiuK4vP5eCQYQOEy6dsrABSigw8+qLq62ugq siJutV2trU88+ZTb7dZoChF9RQDWaHCg+GyLwY8/9tj8+fPM/NM0HgkGULgIwACg mgMPPKC2ttboKvZCUZSBlZW33z7u5FNO0W4Wj8cj7uO1Gx8oVpkYXFleftdddy1e slijx/LzJwKwiMFkYAAFhwAMAKo54IAhdXV1RlexWyL6VldXjxk9+rTTf6HdLJmD Q7UbHygdQUkaOXLkl2u+rKysNLqWXUgkEj09PZwSDKCwEIABQDWm3QKdTqfr6+pu u+32k376U00nEtFXBGBNpwBKSkCSPv3ss4cm3+/v6TFhj71UKuXz+Ts7O40uBACy RQAGAHU4HI62NrfZWtfIsrz/4P3H33HHwQcfrPVEfr+fbs+AurZvE/3M089UVJgu A4t/9V6vb9Mm2mIBKAzmulEDgMLV0dFut9uNruIfxC1peVn5ySf//H9uu12HZwiD wWA0GtV6FqBkZWJw1cCB48eNW7FyhQl3RHu9XlmWeSQYgPkRgAFAHYMHD2psbDS2 BpF70+n0IQcfPPLmUYcffrgOM7LwC+gpIEmff/HFfXffJX5htv0moVAoHA6TgQGY nLneOgGgQLW0NHd0dBi1LCPyZyqV2n/w/jfccMPxw4bpNi9P/AI62/7E4Beef85s RyWJACxJwe7ubqMLAYDdIgADgAqcTmdbm1YH6u6OCL1VA6sOP/zwG37/+0MOOUTP qUXulSSJhV/AENuOSho1atTnX3xuqhgcjUbFmwPrwABMiwAMACrQ7QHgdDpdVlbm druP/NcjR1xzjQjeOky6A7/fL+6/9Z8XwA4CkvT2228//NCDpmoQHY/He3oCXV0c jwTAjAjAAKACTU8AzuxwFqH3iCOOGDHimo6ODpE/o9FobW2tDg2uttfb2xsOh/Wc EcAebGuONfrWW1d98kllpVmWgkVhfr+fI4IBmBABGADy5XDY29raNGpII9LvtKnT jvr+940KvRmJRCIQCLDnGTCngCQtWbLkgcn3m6czlizLPp/IwJuNLgQA/g+zvEsC QOFqb28XGVijwcVN5GefrdZo8GyI0Ov3+0UZBtYAYM+2LQXfdtttH3zwvknOSUql Uj6fr7OTDAzARAjAAJAvTQ9Aslos899405BV3wH0eQYKTUCS3n33nQcmP1BRYYqn gvsysL+zs9PoQgDgHwjAAJAXm83qdru1W2/5yU9OHDt2bFNTk0bj7w6P+wKFaFuD 6D/84Q9fr/vaDM2x0um01+sjAwMwCQIwAORF0wOQxI3jnDlzW1tb9VwBjkajwWBQ t+kAaCEgSdNffHH6iy9UGrR/ZHvirczn823aRAYGYDwCMADkResDkD7+eJV2g++A 032BopFMJqVQ6Kuvvhp32/+Y4dwy8cbi9XrJwAAMRwAGgLwcdNCBNTU1Gg2+3777 vjj9JR2WfxOJhIi+6XRa64kA6GZbZ6zx48atfH9lRYXBhySRgQGYAQEYAHLncDja 29u0G//SS39zySWXaPoA8NZlIklKpVLaTQHAWAFJmv36648//phR7fS2IQMDMBwB GAByp+n+ZxFN33tvuXYH/8qyHAgEiL5A0ctsh/76669vGztWThl8pBk9sQAYiwAM ALk78MADREDVaPCG+oZFb7+tRfol+gKlZtt26FE3j/zr558b2x2aDAzAQARgAMiR w+Foa3OXlWn1Rnr88cPGjRun7v5nnvUFSlxAkh577LG5c2Zrd3hbNlKplMjAmzdv NrAGAKWJAAwAOdJ0/7O4O5w7d56KByDF4/FgMEj0BUpcZjv0yhXL77n7nspKI9ti 9WVg7+bNXQbWAKAEEYABIEdDhgypr6/TaPCysrKPPvpYlaFisZiIvhxuBCAjk4G/ +eab0bfcIstGnpAky7LP5yMDA9ATARgAcuFw2Nva2rTb/3z4YYc/8eSTeQ4SiUR6 e3uJvgB2sO2R4Buuu27dhvXavZVlU4nIwF1dW4wqAECpIQADQC7a29tFBtZocBFZ n3zyqcMPPzznEcLhsIi+KpYEoFhNmjTxrbfeMvCU4Hg83tPTQwYGoA8CMADkQtP9 z7Kc+uyzz3K7NhQKRSIRdesBUMQCkvTC88+//PJLBrbFikajPT2B7u5uowoAUDoI wADQb1r3f3a1ul57/fX+tr8KBALxeFyjkgAUq8wjwcuWLrn/vvs0OnU8G+FwOBQK sQ4MQGsEYADoN037PwsXXnjR8OHDszwAKZVKSZIkbmG1qwdAcctk4C+//PJ/xo4x 8HngYDAUiYTJwAA0RQAGgH478MADamtrNRpcTiaXvbdcjJ/lUsyWLdwsAshXpi1W WpYvvfTSeMKwvSRer3fjxk1GzQ6gFBCAAaB/tO7/bLVY57/xRpbpl2ZXANQVj8Uu v3x4t8djyOyKoni9vk2byMAAtEIABoD+0Xr/85lnnnXttddmuf/Z4/Gk02ntigFQ gpLJ5PXXXbdm7RpDtkOLDOzxeDs7O/WfGkApIAADQD+4XK0Wi6W6ulqj8WVZXrJk aX19fTYrwGx+BqCdW2655YMP3jckA6dSKa/Xu3lzl/5TAyh6BGAA6Ie2NrfT6dRu /KbGxgULF/H0LwAzmDhhwsJFC8vLy/WfOpFI+P09XV1kYAAqIwADQD8MGjSoqalR u/FPPvnkm28eleX+ZwIwAK098MADs2bNrKio0H/qSCQaDEo0hQagLgIwAGTLbre7 3S7tbgRlWV68eElDQwMrwABMIiBJU6dOffON+YZk4GAwtG7dOv3nBVDECMAAkC2t 21+1NDe/+daCLNNvLBaTJEm7Yvrr22+/Xbp06XnnnWd0IQDUlDki+MnHH58/f54h GZiDkQCoiwAMANnS9Phf4ZxzfvW73/0uy/3PPp9PlmXtiumXtWvXPvTQQ2vWrDn9 9NN/+9vfGl0OADVlMvBzzzzz+uuv6Z+BaQoNQF0EYADIitPpaGtr0258OZlc9t5y EbALbv+zx+M5//zzQqFQWVlZZWXlQw89PHToUKOLAqAmYzMwTaEBqIgADABZ0Xr/ s9PhnD1nTsHtf37kkYeffvoZcXuaOSolnU5bLJb5898wui4AKstk4GeeemrOnNn6 Z+B4PN7T00NDLAD5IwADwN45HA6Xq1XTe77hwy+/8MILC2v/84gRI95//33xi+0P Ck2l0ieccMKdd95pWFkAtJHJwI8/9pghPbF6+5CBAeSJAAwAe6f18q8sp5YtW1ZA +5+9Xu911123du3asl19G1EU5eWXX+no6NC9LgDaEhk4HIm88Nxzr854Vf/zgWmI BSB/BGAA2AuXq9VisVRXV2s3xZD995/+0stZvtjw/c+rVq2666671qz5cne3v4oy QHy5Hnnk4YMPPkTn2gDo49577pk7b67OGZiGWADyRwAGgL1ob29zOBzajZ9Op198 8cWDDjo4y9d7vd5UKqVdPXv2+uuvP/zwQz09PXt+mbhPPfzwIx599FF9qgKgv9tu u23p0iVlu9wHohlZlsV7IBuhAeSMAAwAezFkyP719fXajV9eVrZi5ftZbn4eYOj+ 56lTpz7xxBPpdFbxW2TgSy659Morr9S6KgBGuenGGz9e9bHOGTgajYoM7PP59ZwU QNEgAAPAnrjdLqfTqent3THH/GDSpElZtr+KRCKhUEi7YvZg9OjRb775xtaOV1l/ McrLy6+44sqLLrpIy7oAGOmqK69Yv2GDzpN6PN5Nm3gYGEAuCMAAsCeDBu2XZTTN jSzL77zzrpgiyxVgj8eTTqe1q2eXurq6Jk6cuHz5ezn8IKC+vmHs2LHHH3+8FoUB MFwymbzk4ot8fr3XY8nAAHJDAAaA3XI47G63W9MuL21u95y587J/vf77n7/44ot7 7rnnk09W5fZ1EHG9tdX12GOPadpGG4CBotHof5z7q0QyqeekqVRKZOCuri49JwVQ BAjAALBbWp9+pCjK/ffd/6MTTsjy9b29veFwWLt6dtbZ2XnppZdKUqCsrExRBvR3 AThzicjAJ5300/Hjx2tTIwDj+bze884/T+em0DwMDCAHBGAA2DURfd1uV0VFhXZT iAC8atUn2b++u7tbXKJdPTtYvHjxLbfckkwm8h8qnVYuv/zy4cOH5z8UABMKSNLq 1avHjL41+35+quBkYAD9RQAGgF3TevlXOO7Y4x586KEsX5xOpz0ej6b1bG/ChAmz Zs0SIV2V0URsr6qqGjdu3LBhw1QZEICpJJNJKRRatnTJ5Pvvr6ys1G1eRVFEBt60 iZOBAWSLAAwAu2C321wul6a3cbIsv//+B7W1tVm+PhgMRqNR7erZ3k033bRkyWLV u20NGXLApEmTxBdW3WEBmEEmA7/y8ksvv/SSpntndsDJwAD6hQAMALugw/Lvdzo6 Xnt9dvav16f91RdffD5r1mszZswoL1f/G4SiDPjBD35w7733qj4yADMQGTgciTzx 5z/Pe2O+nocDh8PhUChEBgaQDQIwAOzI4bC3troqKzVcwUin088//8IhhxyS5esT iURPT4929WTMnz//oYce6u7eot2dq8jAp5566pgxYzQaH4AZjPjdf69Zu1bPGXkY GECWCMAAsCMdln8rKiqWL1+RfbcYv9+f1PiIkXnz5k2cODEWi2m9bFNdXTNy5MiT Tz5Z22kAGEe8X11w/vnBUFC3GTNdEjZv5lQkAHtBAAaA/8PhcLjdLq0P8/jlL3/5 +9//oampKcvXa73/+emnn3744YfT6ZQOuxYVRTnyyKMefPBBrScCYKAev//c/zhX z4eB4/G4x+MVdJsRQCEiAAPA/9He3u5waLv8K8vysmXv1dbWZrkCHIlEQqGQdvXc csstixYtTKcV3R7ZE3MdfPDBTzzxhE7zAdBdQJI++uij8eNu17MpNBuhAewVARgA /pfb7XI6nVqvgh591PcfnTo1+9d7PB7VGzJvc9NNNy1e/K6exwtniAmvuOKKSy+9 VOd5Aegj0xR6xiuvTJ/+om7rwOKtzOPxdnZyKhKA3SIAA8D/Gjx4UGNjo6ZT9Pf0 I+2O//X7/XfccceSJYv1bNa6TeZk4KlTpx544IH6zw5AB5mm0Pfdc897y9/T7X0m kUiINzc6QgPYHQIwAPyD2+12Oh1a36UddOCBz7/wYvav1+j4X5/Pd/vtty/X8a50 l9zutilTpmjdcgyAsS789a89Xk1+kLdLwWBo3bp1uk0HoLAQgAFgK5ertbm5OfuF 2dyk5NQ7775rtVqzv0SL9lci/V533XVffvk3rXt97ZWiKD/84fF33XWXsWUA0JQk Seecc05FhX5vOB6PZ9MmNkID2AUCMABspcPRR8J399ln5qzXsn99PB4PBALq1vD3 v//9qquuEhm4vNwk3wLKLrvssuHDhxtdBgCtBCRp5cqVd06aqFtDrGQyKd7l2AgN YGcmufsBACM5HHan05n9qby5SaVSs2fP2WeffbK/xOv1iqtUrOHzzz8fNWpUZ+cm w9d+t1dbW3vLLbeceOJJRhcCQBOZhlhPPv74G2/M1+3Nh43QAHaJAAwAehx9JLQ6 nfPfeDP71yuK0t3drWIB3377rUi/a9Z8aexzv7vU2Nj06KOP7rfffkYXAkATmYZY o0aO/Hrd17pNykZoADsz3T0QAOhMn95X6XT6+edfOOSQQ7K/RPX2V9dee+2KFctN mH4HbF0eTx900EFPPfWU0YUA0FAkEjnrrLMGDNDp3DU2QgPYmRlvgwBAN3a73Waz 1dbWaD2RpcWy6O23+3WJuu2vTj/9NI/Hq2cTmv5SFOWMM8686aabjC4EgFYCkvTJ J5/c9j9/1O1h4GAwuG7den3mAlAQCMAASpo+va9SqdQLL7zYr+XfWCwmSZJaBYwY MWLlyhWmeu53lxRlwPjx43gYGChWmYeBn3vmmdmzX9fnHUlRFI/H29nJRmgA/0AA BlC6XC6X0+nQ4SbM7XLNnTe/X5d4PJ50Oq3K7H/84x/nzp1rmp7PeyI+ZZfLPWvW LKMLAaCVzMPAI2+8cf0GnRZmE4mEZyuvPtMBMLkCuB8CAC20tDQ7nc66ujqtJ5Jl ec6cuf1q/ixyoLhZU2X2SZMmzZw5U1HUydL6ePTRKYcddpjRVQDQUG8odPY5Z+vW ksDr9W7cuEmfuQCYHAEYQInSZ/OzMGi//V55dUa/LgkEAvF4PP+pn3766QcffNCU Ta92S1EGnHbaaaNHjza6EAAaypwMPGniBK3Pn8voa6rv2bx5sw5zATC5grotAgCV uN0ukX4rKiq0nkiW5SWLl7RYLP26Sq32Vz/84Q9TKdmcbZ93RwTghob6BQsWGl0I AA1lNkI/Nm3aG2++oc97VDQa83o9Pp9fh7kAmFkh3RUBgCocDrvVaq2trdVhrqHf O/SpZ57p1yW9vb3hcDjPeSVJGj9+/LvvvltQ4fcf0un07beP+9nPfmZ0IQC0JWLw eef9p3jT02c6NkIDGEAABlCCdNv8LO7tPvjgL/1N2qos/957770vvPB8Ya39bu/f //0MzkMCil5Akr766qubbvx/+pyKlEqlPB4PxwIDJa5Q740AIDdtbW6Hw6FPMjxh 2I/uvf/+fl2iyulHS5YsGT36VjFUnuMYaMiQA+6++259fk4BwCiZU5Gmv/jCzBkz 9DkVKRTq/frrr3WYCIBpEYABlBCXq9Vms+nTcyWdSn3y6Wf9vUqV048uvPDCNWvW FMS5R7ukKAPq6moXLXrb6EIAaC7zMPDvr79u4yadNid3d3s4FhgoZYV6ewQA/dXS 0uxwOOrr63WYS1GUG66/4cKLLurXVbIs+3y+PKd+7733rr/+usLd/DygLwALs2fP ZgUYKBGSJJ1z9lkVumyE5lhgoMQV8B0SAPSLbo/+CtXVNStWrOjvVX6/P5lM5jn1 Nddcs3LlykLOv1ul0+m5c+fZbDajCwGgh4AkzZ075/HHHtOhOf8AumEBpa3Ab5EA IDttbW0Oh12fddFUKvXcc88feuih/bqq75jK7jynXrVq1YgRI5LJRJ7jmMHy5f3+ CQKAApXZCH3LzSO/0uUB3XQ67fF4Nm/u0mEuAGZDAAZQ/Fwul91u06fLqHDIwQc/ +9zz/b2qp6cnkcg3uM6YMWPChDv06SWjKUUZMHHixBNOOMHoQgDopzcUOvOsM/VZ BA6Hw2vXfqXDRADMhgAMoMg5nU6r1VJTU6PPdLKc+uijj3Los6XK6UdnnnlmV9fm /McxXDqdfuihh4888kijCwGgH503Qns8nk2b6IYFlBwCMIBi1tLSbLfbGxoa9JlO UZQRI675zW9+098LJUnK/9Sit9566447xkej0TzHMYN0Wlm5cqXRVQDQVWYj9M03 3bRu/TodpkskEt3dHq+XblhAaSEAAyhmeja+EqwW68JFi3K4UJXl37vuuuvVV1/J /xQlcyhbvny50TUAMEAwGDzrrLMqK+mGBUATBGAARau9vd3h0C/9yrK8YMHC1tbW /l4o7vZUWba94oorPvlkVUEfgJShKAMOO+ywKVOmGF0IAAMEJGnmzJnPPfuMDu0M UqmUx+Pp6lLhR5AACkXB3ycBwC61t7fZ7Tq1fc449eRTxk+YkMOFqiz/Cmedddam TZvKywv+jV1RlH/7t3+/+eabjS4EgAGSyWSot/ea3/23R5fNyaFQ6Ouv9dhxDcAk Cv4+CQB25na77XabPm1UMqoGVq18//0cLuzt7Q2Hw/kXsGHDhquvvtrr9RRBC+iB A6tGjBhxzjnnGF0IAGMEJGn9hg2/v/66HBoK9peiKB6Pp7OzGNoHAsgGARhAsXG7 XVarVYfbpm1kWZ41c9agwYNzuFat5d9PP/305ptHer3eItgCvf/+QyZOnNjW1mZ0 IQCMkUwmpVDoqSeffGP+PB3e02KxWFdXVyAgaT0RADMo+PskANiey9Uq0m9VVZWe k55y8sl3TJiYw4WhUCgSiahSw8cffzx27NgtW7oKPQAryoALLrjgd7/7ndGFADBS ZiP05ZddFo6osEdmr+iGBZSOwr5PAoDtifRrsViqq6v1nLSmumb5ihW5XavW8u+A vi3QY8aM+fLLLws6/yqK0tjY+NZbC4wuBIDxApK0evXqsWNGV1ZWaj2XyNviDdnr 9Wk9EQDDFfKNEgBsR6Tf5ubm2tpaPSeVZXnevPkdHR05XKtW8+eMv//975MnT166 dGlBB+B0Wrn00kuuvPIqowsBYLzMscB33XnnB3/5QIfpWAQGSkQh3ygBwD8Zkn4V RbnqyquuuPLK3C5XcflX6Onpefjhh19//TUVx9RZOp0eMuSAZ555xuhCAJhIJBI5 88wzdHi4Q7wFdXd3cyQSUPQIwAAKniHpV/hOe8drs2fndm0gEIjH4+rW8+KLL957 7z3qjqmnxsbGW28dPWzYMKMLAWAiAUl68403pk2bqkOLe45EAkoBARhAYTMq/aZS 6Q8//DDnXtPqLv9mbN68+Ywztq6TFOIuaEUZMH78uBNPPMnoQgCYS6Yb1rUjRnR7 urWeS1GU7m6PeC/VeiIABirAuyQA+CeRfltaWmpqanSeNyXLjz32+FHf/35ul/f0 9CQSCXVLGtDXB+uyyy4Lh8MFF4DFTef5518wYsQIowsBYEYBSVq3bt0ffn+DDufb hcORtWvXaj0LAAMV2l0SAPyTIT2fB/SltXN/de7No0bldnkqlfJ6veqWtM211167 cmWOLamNUl5efsopp956661GFwLApDLdsB595OG3335bh+k8Hs+mTZ06TATAEARg AAXJ7XaJ9Kvzeb8ZbW73nLnzcr5cpF+RgVWsZ3uvvPLKnXdOKpQ90IqiVFfXnHLK KSNHjjS6FgBmF4lEzjrrTB0misViXV1dgYCkw1wA9FcYN0kAsD2Rfq1Wqw574XYm MtsHH/wl56nFfZUkaXtT9fOf/zwYDJo8AivK1g/iD/Hiiy859dRTm5qajK4IgNkF JGnBW29NmfKoDt2wOBIJKGLmvkUCgJ20tbltNltFRYX+U8uy/MrLrxxw4IE5j9Dd 3a30hT/tPPjgg08//ZRpF4Ezn315edmwYT+aOHGi0eUAKBiZblgj/vtqr8+nw1xb tnRr97gKAAOZ9A4JAHapvb3dZrPq8OP/naXT6RtvvPH88y/IeYRQKBSJRFQsaZe6 urouueSSQKDHnBlYBOCjjjpq+PDhRxxxhNG1ACgwAUn6cs2aUSNvqqys1HouFoGB YmXG2yMA2KWODpF+bUbluh8cc8zDjzyazwhaHH20S/Pnzx87dqzZ8q/4g/uXf/nX W2+91eVyGV0LgIKU6YY1acKEjz7+SOu5ZFnu6trCIjBQfEx2fwQAu2KzWWtra+12 u1EFOB3ON958M58R/H6/uHVTq569EgF4/vx5ZlgETqfTjY2NP/7xT372s58dc8wx RpcDoOD1hkJnnnlGBYvAAHJi/L0RAOyZy9UqElR9fb1RBZSXl7///gf5PHUsy7JP +4fWtidi58033/zOO28blYEVZevXbfDgwUcdddTQoUNPPPFEQ8oAUHwCkvTss8++ Nmum1u9vqVSqq2uLx+PRdBYAOiMAAzA1l8tlsbTof9jvNiK7Lly4yOl05jOIuH8S iVStkrIhpguFQrfeeuuKFSsqKvR7ZDrT3nngwIEHH3zIMcccc9ppp7ndbt1mB1AK Mt2wLrrw1+L9Weu5WAQGig8BGIB5tbW5rVarDs1OdkfcXU2bNu2YY36QzyC9vb3h cFitkrIkAnB5ebkkSWPGjFm+/D2t24b9s7V1WW1t7dChQ88999zjjz9e0xkBlLKA JC1btvTee+7R+kQAFoGB4kMABmBSHR3tIv0a0vA5Q9z3iPR49tnn5DmObr2vtpcJ wJlfL1265NZbR0ejUdV3C4pZ+rY6l1VX1/zLv/zLmWeeecIJJ6g8BwDsJLMIfO2I Ed2ebq3nYhEYKDIEYACm43K11tbWNTc3GViDiHYXX3TR9Tf8Ps9xxJ2TCNKqlNQv iqJs/3Tc888/98QTT0hSUFHSZWXl+SThzGJv38cy8Wd09NHHnHPOOZxpBEBnAUla s3btyBv/38CBAzWdSHw76O7u7uoy4EeZALRAAAZgLiL9NjU11dXVGViDSHdHHfX9 u+++W1SSzziRSCQUCqlVVf4mTZq0YMFbkiT1a109E3gz3y9Efq6pqT3ggANOP/30 M844Q6tCAWBvMkciTRg/ftUnq7SeKxgMrlu3XutZAOiDAAzARNra3BaLResf5++Z SL8i4D3y6JTGhoY8K+nv5uft9y1rZ/Xq1U8++eRXX30lknA8Hu9boN66oJtZ2s0s DvetHme+QShlZeXNzc3777//EUccIUKvgYdRAcAO4rHY6b/4RWWltk8Ci7fH7u7u zZu7NJ0FgD4IwABMweVqraystNlshh9du+93933yqadqa2vzTL86H/zbLyL6rlix Yt26dWvXrl2/fn0kEpZlWQRd8UdQVVVl79Pa2nrAAQcce+yx4vXi/wYCgZaWFqML B4AdTb7//jlz52g9SygU+vrrdVrPAkAHBGAAxhPpt6GP0YUMcLW2zpv/Rv7jxONx kRjzH0dnX3zxeSwWF0G3qo/D4TC6IgDYi0gkcuaZZ2j9w1NFUbZs6e7qYhEYKHgE YAAGc7tdInEZeNLvNpaWlkVvv6PKUNlvft6hWxUAoF8CkvTS9Okvv/yS1u+lLAID xYG7LgBGam9vt1otWh/kmI2WZpF+31bl/snn88mynM0rxcsMPOUYAIpA5kikiy68 UJa1feqEJ4GB4kAABmAMp9PZ0FCfZ5tltaiYfsPhcG9vb/7jAACyFJCkBQsWTHn0 Ea37CLIIDBQBAjAAA5hn2/MAVdNvZn0g/3EAANnLLAJfPvyycDis6UQsAgNFgAAM QG8dHe1Wq1WH836yYbVYFyxcqNaTYx6PJ51OqzIUACB7gb7m9nf96U6tn6kJBkPr 1rEIDBQwAjAA/Zin23OG2+WaO2++WqNJkhSLxdQaDQCQvcwi8G+vvEIkYU0noh00 UOgIwAB04na7LZat5+sYXcg/7Pvd786YOUut0cS9l9/vV2s0AEB/iei7atWqcbff pv0icHDduvWaTgFAOwRgAJqz2ay1tbU2m80k5/0oivK9Qw559rnnVRwz+3OPAABa yCwCXztiRLdH214M6XS6u7u7q4u3faAgmeJmFEARc7lcTU2NdXV1RhfyD+LG5f+z dx/wTZX7/8DbdO82oxktBZmK3nu9Io7rvk5ArygbFQfDxVDZlCXIXoIDFSeKUhAB RYYCKojiBFxAgTKbtBlt0jSz55z8H5r7748LpaTJeZ6cJJ/37/W/L/8l+T6Hlp7z fPKszp2vWrhwoYgbUAd+7hEAANBjtdn+2r9/8sRi2ifM2Ww1R49iEBggIiEAAwBF 0jnm14/n+X59+z09dGhaWlpSUpIoNWtqalwulyilAAAgFP5B4NGjRpaXl1NtSBAE g8FgMpmptgIANCAAAwAVUtvviuA5/plnn33sscdErOnxeKxWq4gFAQAgFFab7fDh w+PGjqE9CEzSL+2YDQA0IAADgPh0Ol1eXq5YQ6yi4DjupSUv3XzLLeKWveDSX9Iu 7U4YAAA0qKurczidUyZNOlh6kGpDGAQGiFAIwAAgJpVKmZKSIp39rvxIN2XtJ2tb t2kjblmj0ejz+Zp4Ac/z0pn+DQAQO2pstvt73E/780ez2XzqFAaBASKMhHqoABDp dDptTk4OCcDhvpD/kZSUtG3rtizxtrzyu+DGVyQbS+pTAACAmDJq5Mg//vyDahPk KVBRUWE2W6i2AgDiQucMAEQgtYOO/EgEbVFYuP7Tz2QymbiVbTab2+1uumlJfSsA AGINBoEBoFHonwFAqLRaTU5OTmpqargv5H8IgnDllZ0XLVok4nFHfk6n0263i1sT AADEVVdXN2LE8LKyMqqteL1eo9FEYjDVVgBARAjAABA8pVKZmpoil8tFH2INEcdx w4cO69Ovn4jHHfmRvk51dbWIBQEAgAarzXb02LHRI5/DdtAAcCYEYAAIklaryc7O Jgkz3BdyNp7n337r7Ss7dxa9siAIJpNJ9LIAACA6/5nA48aMOXHyBNWG3G631Wqt qLjAoQAAIBEIwADQbLm5OZmZmRIc+CWSk1O++OKLnJwcGsUvuO0zAABIh/9M4LFj RtM+ls9oNOn1eqpNAIBYEIABoHkkO/BLommH9h1KVq2iVB/pFwAgsvgHgUePGkl7 irLT6SwtPUS1CQAQCwIwAATKv9WzNAd+OY4bNHDgiGeepVTfZDIJgkCpOAAAUGK1 2Q6WlhaPH0d7JbDRaNTrDVSbAABRIAADQEA0Gk1OjhQHfgmB5995970rrriCUv0L HvkLAADS5B8EHvnss4YKuum0trb28OEjVJsAAFEgAAPABUh2q+e4+mnPSoXy840b U1JSKDVRVVVF+k+UigMAAG1Wm+2v/fsnTyymOghMnkcGg8FoxEaJAFKHAAwATZHm Gb9+PM9fc8018+cvEP2k3wYXTL+CIEjwcwEAAGjgHwR+Zvhwo8lItSGz2XzqFM5D ApA6BGAAaJyUV/zG1affGTNm3HTTzaKf9Nugurra6/U28QKfzxcfj7soAIDUWW22 ffv2vTB9WkJCAr1WyIOpoqLCZDLTawIAQoeuGwA0QqfT5uTk0JtXHCKSeDds+Dw/ P59eExdMvwAAECn8g8BPDBlcY7dTbQiDwADShwAMAP9DoVCkpaWS/5Xm2KYgCP+8 /J/vvvce1Vaw7hcAIMpYbbadO3e8tGQJ1WlNXq/XaDSRGEyvCQAIkRQ7uAAQLjqd Ljc3Jzk5OdwX0jiO46ZPf6F79+5UW0H6BQCIPv5B4AEPPcRxdO/wJpOZ9rHDABAK BGAAOE2jUaenp2dlZUlz4JdIT0vfsGFDnlxOtRWceAQAEK2sNtu6des++nAF1Sed y+U6eLCUXn0ACJFEe7oAwFJBgS43N5fSVlKh4zj+tn//e9HixbQbMpvNPM8H8Uby LqobqwAAQOjq6uocTme/Pn18cT6qDVVWGg0GuscOA0DQEIABYppGo87IyMjKygr3 hZyXIAivvvLqdddfT7shk8lE2gr67VLYEVoK1wAAIHFvLlv28ZqPqTZht9uPHCmj 2gQABA1dJYDYVVBQkJeXm5iYGO4LaRyJczqtdu269Qw2ozYajaQ52q3QhgAMAHBB dXV13bp2kdGctkPuxnq9HuchAUgTukoAsUijUWdmZmVmZoT7Qs6L47hBAweOeOZZ Bg1ZLBbarbCBAAwAEIg5s2d99fXXVJvAeUgAkoWuEkBsIdE3MTExLy9PymtWk5KS 1ny8pkVREe2G3G63zWaj3QozCMAAAIHwuN3d7u5GdQIUx3GVlZUYBAaQIHSVAGKI RqPJzs5KT08P94WcF8fxN95wwyuvvsqgrdraWofDwaAhZhCAAQACNHbMmH2/7aPa BAaBAaQJXSWAmKBQyNPS0iQ+8Evy2+uvv3711dcwaKu6utrr9TJoCAAAJKjGZru/ x/1UB4HdbveBAwfp1QeA4CAAA0Q/jUaTk5NNAnC4L+S8BEFo367dypJVbPJ50Mcd SRmGfwEAAldXVzdo4MBKYyXVVoxGo16P85AApAW9JYBoplIpU1JS5HK5TCYL97Wc F8dxkyZO6t2nD4O2SO61WCxRsOEzAACEwmqz/fLrL3NmzaL6fMR5SAAShAAMELW0 Wm1OTnZqamq4L+S8SBDVqNUff7wmk8lBxC6Xq6amhkFDZxEEQcofQAAAxKC6ujp7 be0jAx7y1tXRa4Xc//V6g9mMrbAAJAQBGCAKKZXK1NQUhUIh5TmxHMcNGzpsyOOP s2mORF8SgNm0dS7MTwYAkBqrzbZmzZpVJSup3p+xFRaA1KBDBhBttFptbm5OSkpK uC/kvEgaVMgVpNuRm5fHpkWLxULyNpu2AAAgItTV1Tmczt69elKdpOP1eisrKy2W KnpNAECzIAADRA+FQpGWlir9gd9BAweOeOZZNs0JgmA2m6N40S/GlgEAQjF3zpzt X22n2oTJZCov11NtAgACh24TQJTQ6bQ5OVIf+M1IT//44zVanY5Ni06n0263s2kL AAAikcvluueeu6meh+RwOA4dOkyvPgA0CwIwQMSLlBW//fr2m1BczKxFnPQLAAAX VFdXN3zY0KPHjtFrwufz6fUGk8lErwkACJx0u8sAEAidTpebm5OcnBzuCzkv8uBP T08vWVnSoqiIWYuknxHF054BAEAsVpvtwIEDE4snUB0ExlZYANKBAAwQqTQaNQmW WVlZEh/4feCBB8eNG8esxViY9ox1vwAAYvGfh/TUE4+TJEyvFfI0rKysNJlwHhJA +KELBRCRdDpdXl5uUlJSuC/kvE6v+M3I/Hj1amYrfuMw7RkAAJqPRN+vv/566auv 4DwkgFiAAAwQYZRKZUpKilIp9RW/jz7y6HMjRzJrked5i8WCac8AANBc/vOQ+vXt Q/Uh4nK5Dh4spVcfAAIk3Q40AJxLp9Pm5uZKfMWvPE++atUqpUrFrFG73e50Opk1 R1vDDGdBEKieTgkAAA0WLVy45YstVJvQ6/VGI7bCAggzBGCAyKBSnR74lf5Wz48P GTJ02HCWjZrNZp7nWbYIAADRx+N2d7u7G7bCAoh60u1JA0ADrVabmyv1M37V+fkl Jaty8/KYNepyuWpqapg1BwAAUayuru6pJ588eeokvSY4jq+srMBWWADhhQAMIGlK pSI1NVX6A7+jR48ZMGAAy0arqqpIZ4VliwAAEMWsNtu+fftemD4tISGBXisk/ZaX YxAYIJyk26UGAK1Wk5OTQwJwuC/kvARBaFnUsmTVqrS0NGaNer1eq9WK/a4AAEBE /q2wHh7wkMfjodeK0+ksLT1Erz4AXBACMIAUaTTqxMREuVwu5T2QBJ5/ftr07t27 s2yURF+qXRMAAIhlH37wwfIP3qfaRHm53mTCVlgAYYMADCA5JP1mZWVnZKSH+0LO i+f5Sy6++IMVH7I8iLiurq66uhoDvwAAQA951nTt2oXqLGhshQUQXgjAANJSUFCQ l5dLdRfKEAmCb/GLL958yy0sG8XALwAAMEAC8JjRo/cf2E+vCY7jDAaDxVJFrwkA aAICMIBUaDTqjIyMrKyscF/IefE83+mKK956+x2WE7NJR6GqqgoDvwAAwIDVZisr KxszehTVT6KxFRZAGCEAA0iCTqfNzc1NTk4O94WcV3x8/LI3lnW68kqWjdpsNrfb zbJFAACIZXV1dfba2qeeeJwkYXqtOByOQ4cO06sPAE1AAAYIs9zcnMzMTCkfdMRz /I033vjyK6+wbBRbPQMAQFiQ6Lt169Zlb7xO77lMnm56vQFbYQGEhUQ73AAxQqNR Z2dnp6dLd7+rpKSk5e8tv/iSS1g2Wl1dTQIwyxYBAAD8/Och9e7Vk+p6H2yFBRAu CMAAYaPT6eTyPMnud8Vx3N3dus2aPYdlo26320Zz1hkAAMAFkQw8sbh432/7qDZR Xl5uteKRB8AaAjBAGCgU8rS0NMlOe/b5fJkZGStLVhUWFrJst6qqinQIWLYIAABw LqvNdvTYsdEjn6P6IbXRaNLr9fTqA0CjpNj5BohuWq0mOzsnLS013BfSOI7jHnv0 sWefe45lo06n0263s2wRAADgfPyzoJ964vGq6mp6rZAH35EjZfTqA0CjEIABmCoo KJDL8xISEsJ9IY3w+XwqpbJk1Wq5XM6yUYvFwvM8sxYBAAACsXHDhiUvv0SvPnn2 GQwVZrOZXhMAcC4EYABGFAp5amqaSqUM94U0juO4EcNHDBo8mGWjdrvd6XSybBEA ACBAdXV13bp2kdH8zBpbYQGwhwAMwIJGo87JyUlLSwv3hTTC5/MV6HQlJasys7KY NUp6FdXV1TjlCAAAJIs8qkaPGnXg4AF6TTidztLSQ/TqA8C5EIABqJPybs8cx40f P75//wdYNopTjgAAQPqsNtvB0tKJE8bTW7iEA4EB2EMABqBIo1GT3CvN3Z4FQWhZ VFSyajXLcWmccgQAAJHCvxXW4IED7bUUt2nELGgAxiTXKQeIGiT9ZtYL94U0guP4 qVOn9OjRk2WjFouF4ziWLQIAAIRo1cqVb7/7Dr36Ho+nurq6oqKSXhMAcCYEYAAq tFpNbm5uSkpKuC/kbIIgtL6o9cqSEpbXhs2uAAAgQtXV1XXp0iUxkeJWWJWVRoPB QK8+AJwJARhAfPWLfuVUH5bB4Xl+1oyZ3e65h1mL2OwKAAAiGnmQjRg+rOzoUXpN 1NTUlJVRrA8AZ0IABhBZYWGBBBf9CoLQtk2blSWrkpKSmDWKza4AACDSWW22vXv3 zpzxgkwmo9QEDgQGYElafXSAiKbRqNPTM7Kz2R0mFCCO46dPn969e3dmLbpcrpqa GmbNAQAAUOLfCqt/v36CwNNrxWQyl5djKywAFhCAAcRB0m92dnZ6enq4L+R/+Hy+ osIWJavZbfVMWrRYLDxPsZcAAADA2JzZs7/6+it69WtrHYcPH6ZXHwAaIAADiECa W15xHDdu7LgHHnyQWYvY7AoAAKJSrd3evXv3xKRESvUFQdDrDZgFDcAAAjBAqHQ6 bf2WV7QeikHw+XxajWb16o8zsxjNx8ZmVwAAEN0e6N/fUmWhVx8HAgOwgQAMEJKC ggKFQk5vY4wgcBw3YviIQYMHM2sRm10BAEDUW7927dLXX6NX3+l0lpYeolcfAPwQ gAGCJ8ENn9PT0teuW5efn8+mOWx2BQAAMYL2gcA+n0+vN5hMJkr1AcBPQh13gAii UMhTU9NUKmW4L+T/8BzfrVvXWbPnsGkOm10BAEBMIQF46FNPHT95gl4TmAUNwAAC MECz5eersrOzMzMzw30h/yc+XrZ8+fLLLruMTXPY7AoAAGKN1Wb7+aef5s6dQ2/d k9vtPnDgIKXiAOCHAAzQPFI77ojn+Sv+ecW7773HpjmO46qqqrDZFQAAxBr/gcD9 +vTxxVF8CJaX6zELGoAqBGCAZtBoNLm5OampqeG+kP8i6XfB/AW333EHm+asVqvH 42HTFgAAgNSQDDx16pRffvmFXhOYBQ1AGwIwQKA0GnVeXp5EDvv1H3S0bv2nbK6H 5F6Sfhk0BAAAIFlWm+3osWOjRz5H7+xDr9dbVVVVUVFJqT4AIAADBESj0cjlecnJ yeG+kNM4jhvw0IDRY8awaY48ievq6ti0BQAAIFn+WdCDBw6019rptaLXG4xGI736 ADEOARjgwkj6VSjkSUlJ4b6Q/3r//Q/Y7HeFU44AAADO8s5bb5WsXkWvPmZBA1CF AAxwAVqtlqRfepOdAicIQru2bVet/pje/pNnslgsHMcxaAgAACCCeNzubnd3o9cx IA/fiopKEoMp1QeIcQjAAE0h6VepVCQk0Dr1PnDkcfjss8899thjDNpyOBy1tbUM GgIAAIhEDz34oMlMca9mo9Gk1+vp1QeIZQjAAOel02kVCkmkX5ksYf369YWFhbQb 8vl8FouF53naDQEAAESutWvWvL7sDXr1a2pqysqO0qsPEMsQgAEaJ5H0KwjCJRdf vLKE4lqjBrW1tQ6Hg0FDAAAAEa2urq5Ll7swCxogEiEAAzRCIjOfeY4fOnTokMcf p90QBn4BAAACRwLw4EEDKyopHlaEWdAAlCAAA5xNImO/JJSu/GjlxZdcQrshDPwC AAA0i9Vm27p167I3Xo+Pp9WXxixoAEoQgAH+hxTGfkn0ValUGzduYnDwktlsxsAv AABAs/gPBO7ds4eMWocBs6ABKEEABvg/Uki/JI5effU1CxYsyM7OptoQtnoGAAAI GsnAw4Y+fez4cXpNYBY0AA0IwAD/pdVqFApFeM/75ThuwvgJ3e6+Oy0tjerwLwZ+ AQAAQmG12X788ccF8+fRmwVts9UcPYpZ0AAiQwAGOI2kX7lczmDKcRMEQShZWUJ7 0a/b7bbZbFSbAAAAiHr+WdB9eveiF4A5jjMYDBZLFaX6ALEJARggTqNRk/SbnJwc xmtIS0vbunVbeno61Vaqq6u9Xi/VJgAAAGIEycCjR406cPAAvSYwCxpAdAjAEOtI +s3NzU1NTQ3XBfh8vrZt2ny85hOqrXAcV1VVRdqi2goAAEDssNpsf/zxx7Tnp8pk MkpNYBY0gOgQgCGm5efn5+XlpqWlhesCeJ6/6aabZ8yYQXXLq5qaGpfLRa8+AABA DPLPgu7bp09cHK3PlzELGkB0CMAQuzQadVZWVkZGRrgugDzVxowec2/37lS3vDKZ TIIgUCoOAAAQy0gGHjN69P4D++k1QQJwZaWRXn2AWIMADDEqNzdHoVCQAByuCyDp d9kby6659lp6TWC/KwAAAKoYzII2m82nTpVTKg4QgxCAIUYVFhYolcpwte7z+T77 9LMWRUX0mrBarR6Ph159AAAAYDALmjRhsVgqKiop1QeINQjAEIvCm34TEhK/2r49 i+aiX0x7BgAAYIPBLGi93mA0YhY0gDgQgCHmFBToSPqld2pf03Jzcrdu25aQkECp PqY9A0QH/7BSRnp6eM8nB4ALwixogMiCAAyxRavVKpUKevmzaQW6gg2ff06vPqY9 A0SN8vLytWvXnjp1cvbsOeG+FgBoCoNZ0OThvn8/xdOGAWIKAjDEEI1Go1DIwzKc wuCwX0x7BogatbW1Q4YMJr/U5L/btW376tLXwn1FANAUBrOgy8v1/nsCAIQIARhi hUajzsvLS0lJYd80Sb8dOnRYtuxNSof9chxnsVhoVAYAlvzjSMlJSc9PmbJn317/ dEqe5y/u0OGll18J99UBwHlhFjRABEEAhpigVCrl8rz09HT2TZP0e/nl/1y4aFFW ZiaNwWeHw1FbWyt6WQBgxp97yX9wPH/86NEfvv/+k3VrExMTG15AMvCll1469flp WBIMIE0MZkG7XK6DB0spFQeIKQjAEBMKCgpUqjBs+ywIwnXXXf/CjBmU0m91dbXX 6xW9LACw4e80k9x78vhx/1eMFRXzFixITDx7nwKO4/r179+jR8/cnBzmlwkAF0Z7 FrTP59Pr9SaTmVJ9gNiBAAzRL1yHHpH026tnr+EjRqSlpdFIv2azmed50csCAAPn Rl/C6XTOnDGDFxr5vSZ9X5KB161bn5WVxfAyASBQVpvtt99/f2Ha85gFDSBxCMAQ 5XQ6LUm/9J5G50PSb79+/ceNG0ejOBb9AkSuRqOv36uvvnL8+PHz3a/IXUWpULz6 2uuYCA0gQf5f7T69e9E7Z9HhcB46dIhScYDYgQAM0Uyj0SiVijOX0rFB+qm9e/cp Li6mURwn/QJEqCaiL/HB++/v+21f0/crnucfePCh7t27YyI0gASR3/ERI4aXlZVR qo9Z0ACiQACGqJWfny+X56WmpjJul6Tfm2++Zfr06TT2fK6trXU4HKKXBQCqmo6+ 5Kbx3rvv7j+wP5AjyjmOW7X6Y0rbCgBAKKw2265du5YsfpHeIDBJv+XlmAUNEBIE YIhOGo06sx7jdv3pd8rUqTS6p1ar1ePxiFsTAKhqOvr6lR058vobrwe4UoPcZG64 8aZhw4ZhEBhAavy/77169gjkw6zg2O21R44coVQcIEYgAEN0CsvGVz6f71//uo7S ns8Wi4XjOHFrAgA9gUTfuPoR3fHjxiUmBbpSg9xneJ7HIDCAZD0+ZPDxEycoFSe/ /nq93mKpolQfIBYgAEMU0ul0KpWS3gSkRpFe6VVXXTV7zlwavVKTySQIgrg1AYAe kn5tdnvT0ddv/ry5lqrm9WXJ3eD++3v07dcPg8AAErRl8+ZFLy6iV99gMFRWGunV B4h6CMAQbTQatVKpZLzxFUm/HTp0WPra66KnX1KZpF/yvyLWBAB6Ahz49Tt18sRL L7/c3G3qyQ0hKSn5veXLs7OyMAgMIDXkJtCly130+iE4DAkgRAjAEFUUCjlJv2lp aYzbLSoqev/9D0Q/7xfHHQFEkGZFX78xY0YHt1aQ5/nJk6f87e9/xyAwgAQ9POCh SiOtQVqPx7N//wFKxQFiAQIwRJWCggKVivXSX6VC8eXWbaKX9Xq91dXVopcFABoC n/Pc4P3l7/3511/BLdbw+XyXXXbZ+AnFOdnZGAQGkJoPV6xY/v5yevXLy/Umk4le fYDohgAM0SMs6Tc5OeX7779v7gzGC8JhvwCRIoiBX8LpdE6ZMjnoSZKnt8LiuDFj x1119dUYBAaQGo/b3e3ubpgFDSBNCMAQJbRajVKppHfwQKPi4+O/++570Y8aJj1j u90ubk0AoCGIgV+/4uJiQeBDbP3O2+94YMCAvNxcDAIDSE2f3r1tNbQ+yCb9hNLS Q5SKA0Q9BGCIBkqlgqRf0YNo0wSe//rrb/LkcnHL1tbWOhwOcWsCAA1Bp9/d3323 dv260GeOFOgKRjzzTIuiIpKBQywFAOJa+uor6z/9lFJxn8+n1+tNJjOl+gDRDQEY ogH7yc8cx5WsLOl46aXilq2pqXG5XOLWBADRBTftucHo0aNEmRuZkJDwwgszNJrT 818wCAwgKTU2W4+ePehNTCPpt7wcs6ABgoEADBGvoECnUqlYtshz3Jw5c7t07Spu WZvN5na7xa0JAKILeuA3rn5zuwkTJiQmJohyUDnH8bNnzybRt6hlSwwCA0hNt25d eT7UlQ7nY7fbjxwpo1QcILohAENkqz/1V0V6k8xaFARh0KBBw4YNF7cs0i9ARAgl /RKvvvrKyZMnxboYro6bPWdOQkICBoEBpIbcK8aMHr3/wH5K9TmOMxgMFksVpfoA UQwBGCIY6fApFHKWp/76fL7Ona9asGBBdna2iGWRfgEiQojpt8ZmmzFzhoibxpMe 8B23k/+7Q5aQUISVwABSYrXZfvn1l7mzZ4sy3aNRer3BSO20YYAohgAMEaywsIBk YJYttmrZ6r3ly0nkFnGkBekXQPpCXPQbVx9WJxYXx8vEfOySml3uvOvft90Wd3on fK1CocAgMIBE+G8avXr0SKA2SQ2HIQEEBwEYIpVOp1WpVPQ+WD1XSnLy7h9+FLem 1Wr1eDzi1gQAcYU48Ou3fevWL7dtFeuS/ARBuPP2O/wBODExsUVREc4EBpCUIYMH nRBv1cNZ3G73gQMHKRUHiGIIwBCRNBq1XC5PTk5m1iLP8zt3fpsjaucS6RdA+kRJ vyaTad68uaLvB+vz+e647XZ/AI6r3w8/Ly8Pg8AA0rF+3bqlry2lVLz+MCQDub1Q qg8QrRCAISK1adM6KyuLWXMcx7333vIrrrhCxJpIvwDSJ0r6JTeQSZMmkc6qWFfV 4MwRYCI5JYVkYAwCA0gHuYd06XKXKMeeNQqzoAGCgAAMkYfxqb+kizl82PCBgwaJ WBPrfgGkT5T0S2zetOmbHd+Ickln4Xn+9ttuv/2OO/z/3/j4+JatWmErLABJ6dO7 t63GRqk4DkMCCAICMEQYjUatUqnonSx/Fp/Pd/nl/1yyZImI2z6Tx5XT6RSrGgDQ IFb6dTgcU6dOoTT+Qy5y/vwFZ34FW2EBSAr5JV2wYP7XX39NqT7HcadOnbJaaQVs gKiEAAyRJDc3Jz8/Pz09nVmLSqVyzZpPRNz2uba2lnSIRSkFAJSIlX6JJYsXGyoM oddpVHy8bObMmWd+hdypClu0wCxoAImw2mxlZWVjx4ym98G9Xq83GrEMGKAZEIAh kjA+90gQhB9//CklJUWsgk6n0263i1UNAGgQMf2SjunixS+KePDvWRRy+ajRY878 CmZBA0iK/zCkfn37+Hzi7wLgh2XAAM2FAAwRQ6vVqFQqel3Js3Act2LFh3//+9/F Kuh2u202TFICkDQR0y8xZfIkb12dKKUadcP113ftdvdZX9TqdCQYYxY0gESQu8rI 554rPVRKqb7L5Tp4kFZxgKiEAAyRQalUKhTytLQ0Ns35fL7BgwY9PXSYWAW9Xm91 dbVY1QCABnHTr8FgWLz4RXpnlfM8X1w88dyz2bAXNICkWG22Xbt2LaF2N6g/DElv MplpFAeISgjAEBkYT35u17btqtUfi1WN4ziLxSJWNQCgQdz0S37rJ0wYT3W7voSE xBdeeOHcr8sSElq2bIkADCAR/lnQPXvcT+8wJJJ+y8sxCxogUAjAEAEYT36WyRJ+ +uknsZrz+XxGo1GUUgBAibjp1+v1vv32W8dFqnY+t/371ltvv73RP2p10UVYBgwg KQ89+IDJTGuQtqampqzsKKXiANEHARikTqGQk/SbmprKpjmO477Y8oVWpxOrIEm/ 9La+AIDQiZt+4+p/6xcuXEBv8jPBc9zMWbPPN6CEw5AAJIXcZJYsWfzll1/Sq2+x WCoqKinVB4gyCMAgdSwnPwuCMGrkqIcGDBCroMlkIjXFqgYANFhttqNlZSIWfGH6 NAfls76vuOKKXr16n+9PU1JTdTodZkEDSMTpm8yxY2NGjcRhSABSgAAMksZ48vPF HTp8tLJErGoWi4XjOLGqAQANog//btq48Zsd39Ad/uX5mTNnNbGeMDEpqQVOAwaQ DP8y4L59+sTF4TAkgPBDAAbpYrzzsyw+/qeffxErbFdVVdXRPP4EAEInevq1mM2z 55x3ZrJY/n3zLbffeWcTLyD3sZatWiEAA0jKiOHDDpbSOq/I4XAcOnSYUnGAKIMA DNLFcvIzx3Hr161v3aZNcG/nef7MeU02m83tdot0aQBAhejpl9xGJk4spjr26zd9 +gsXzNjYBwtAarZt3Tpv/jxKxUk/pKKiAochAQQCARgkiuXkZ5/P9+QTTz7+xBNB vPes6EvU1tY6HA6RLg0AqBA9/RJLX331xMkTIhY8F7lZDRk8JJCP6lq2aiXPy6N6 MQDQLOS206XLXfRmiOj1Bpw6ARAIBGCQotzcnPz8/PT0dDbNtSgs/PSzDc1917nR l/B4PFarVaTrAgAqaKTf3/btW/HhCvqf2cXPmjUrkNcVFRUpFArKFwMAzdOnd29b jY1ScSwDBggQAjBIEdOdn3n+519+be55IY2mX0EQTCbswQggaTTSr72mZtq0aYlJ dJf++ny+0aNGKwK7N7Zo0YLZXRQAAkFuPnPnzNn57U5K9Z1OVym1NcYA0QQBGCRH o1GrVCp6RwWcieTYJYuX3HzLLaJUC/zIXxKVmW1tDQANaKTfuNPnHk13OKkvfEhP z5g0aVKALy4sLCQ3UqrXAwDNYrXZDpaWTiqeQKkDQHog5eV6sxnLgAEuAAEYJKdt 2zaZmZls2rqyU6dlb74lSikc+QsgcZTS77q1a3f/sJv23lc8z08snpgd8MbOBQUF +fn5VC8JAJrFfxhS7169ZDJatwuDwVBZiWXAABeAAAzSQjptKhWjaXsJCYk///xz 4K9vYtgWhx4BSByl9Gsw6BctWsRgxkqnKzr17NUr8NcjAANI0+NDBh8/QWu3PCwD BggEAjBIiEajVigUzV2OG5wQzz06U01NjcvlCuKNmAgNwAal9Ov1eicWT0igfOov wXP8xInNGP6NQwAGkKqVH3307nvvUirudrsPHDhIqThA1EAABglp3fqi7OxsBg35 fL7evXpPKC4O/C0kMDd6dIHT6bTb7eJdGgCIjFL6JRbMn2e2WEQvexZyv7rrzrua u1UBAjCANLlcrnvuuZvSYUjkdqHXG7AfJ0DTEIBBKnQ6rUqlor2Ozi89LW3Xd9+H XoekYgv97i8ABI1e+t2yedNXX3/N4JZFmnjuuZHN3dIZARhAsrp168rzPKXiJpO5 vByzoAGaggAMkqBUKkj6TUlJYdAWSa1fbPlCq9OFXqqysjL0IgBACb30a6uunjl7 FoMlDIIg9O7Zq1Pnzs19I3aBBpCsZ0YMP3CQ1kTlmpqasrKjlIoDRAcEYJAEZgf/ +ny+hwc8/OxzzwX4+kbP+/UTa9tnj8fDJvkDxBR66dfr9U6YMJ7NbgVKheLxJ54M YmP8FkVF5L00LgkAQrRl8+ZFLy6iVJzcoP76az+l4gDRAQEYwk+r1ahUKjbbQcnz 5Nu2bw+9TnV1NXnGhF4HAGigl345jpswfnxCIouDysnfYvDAQR0uuSSI9xa1bKmQ y0W/JAAIHfnV7nLXXYlJtPbPKy/XYxkwQBMQgCHMNBp1dnZ2eno6g7ZIz3Xnjp25 eXmBvNjn851vdV9tba3D4RD10gBANFTT75Qpk5md+N2x46X9+/cP7oyllq1ayQO7 1wEAe/fee6/H46ZUHIchATQNARjCjNnBvyTQDho4cOiw4SHW8Xq91dXVolwSAIiO avqdNXOGM6gzz4JAblnDhw3TFRQG8d74+PhWF12U25xjkwCAGXKbGjdu7J9//kmp fk2NvaysjFJxgCiAAAzhpNGolUolpcMAzpKXm7v9q68DfPH5Dj2KC3bjK/K0czid GenpZ60bPN/XASAIVNPv+8uXlx4qFb1yowRBuOO222+9/fbg3p6QkFDUsiUCMIA0 WW223bt3L1q4gNI28lgGDNA0BGAIJ2YH/5LO69at29RqdYh1gt74ijztNmzYsG/v XpPReObXVfn5LVu17Nq1m1wuRwwGCAXV9Pvee+8dPnxI9Mrnk6/KHzxkSBB7X/kl JScXFhYiAANIk/+z7x7330fvoY9lwABNQACGsNFqtfn5LA7+9fl8ffv2GzduXIh1 mrvxVcPo7osLF2758kuPx+311slk//P3FQRfcnJSYWGLHr16/fuWW2QyGWIwQHP5 f9c4nqeRfolvd+78fOPnNCo3iuTtgY8+dnHHjkFXUKvVKpUKdxIAKevXt0+11Uqp OE4DBmgCAjCEh/I0RWpqKoO2UlNSv9+9O8QiDoejtra2WW+x2mw7d+4sWbny0KHS pve4JhFdJku48YYb7ujS5e9//3tOVhZ6rgABojfwG1efRWts1lmz5yQy2fZZEIT4 +Pirr7r6vvvvD6VOUVGRAmcgAUgYuXHNnjVr13e7KNXHacAATUAAhvBgdvAv6b9+ 9tmGVq1ahVjEYrEE+GL/YFRyUlL/fn31BgNJtgEOcvt8cQkJsomTJne+6ipkYIBA UE2/RNnhw8veepNS8XORW83l/7j87nvuyQlt9nKriy7Ky80V66oAQHRWm+2333+f MX0algEDsIcADGGg0Zyenhfc2R7NdfONNy1avDjAF/M83+hVGY1GH4mnAfB3x3/+ 6afJkyaRNNuMC60nCEJOdk7/Bx/s3r071u8BNIH2tGfi1MkTi5csYbNLn588N2/0 2LEhFklITCwqKsINBEDK/Hewnj160JtdgmXAAOeDAAxh0KZN66ysLAYNyWSyX375 NcQiFouF47gAX2y12TZv3vz+e+9VVVcF11x8vIzk8BtvuKF40iSsBwZoFO2B3zj/ kb+TJws+Rkf+nm6xjpv6/PMZGRkh1klJTdXpdAjAANLXv1/fKmoHK+I0YIDzQQAG 1kjPLD9fxaAhEiPffuvtKzt3DvD1Pp/v3JlINTU1ruYc+zmxuHjrtm2hT2jy+eKe Hjr0nnvuQS8W4EwMBn7j6mcPTnv+eV7g6TVxFnK/GjRwUPsOHUIvRe6xcrkcn50B SBy5m82aOfO777+jVB/LgAHOBwEYmFIqFSqVKiUlhUFbl3bs+MGKD0Op4PF4rM3Z oXHhggUlq0qa3u8qcEql8pNP1qIXC9CAwcCv36yZM2rsdtqtnKnjJR0fGjAg9Drx 8fEtW7XCAmAA6bPabHv37iV3G0rLgEkfZv/+AzQqA0Q6BGBgitneVzwv7NmzJ8Rl xpWVlYG8rGHXq3//+98iPsUEQbjxxhuLJ2IiNACjgV+/F6ZPr3XUMjihrQH5BZ88 eYooi41xAjBApPj/y4Dvp7fRQHl5uclkplQcIHIhAAM7zCY/k+g4fdr0/9x7byhF TCYTqRPIK6022/bt2xcumM/zIk+Y9Pl8L8yYeeWVV6I7CzGLZfTlOG7ZG28cP3Gc Zfrl6rgJxcV5eXmiVNNqtQqFAh+ZAUQKqqcBV5wW0Ef5ADEFARjYueyyS9nsp6rT aj/fuCmUCjabze12B/hi0kHv0qVLbW0tjT5zpys6LXrxRXRnITYxm/Pst/XLL7dt 38amLT+O4wcPEmfpbxzmPwNEGnKLmz5t2o8//UipPvbBAmgUAjAwwmzyM3mcfPPN DoVCEXSF5i79HT9+/Pbt28Ra+nuWhISEDZ9vxCxoiDUsB379vtq+ffOWzZR+kRvl 8/muufqa7vfdJ1bB5JSUgoICTBgBiBRWm+2XX3+ZO3s2pVknLpf74MGDNCoDRDQE YGCBRN+CAh2bWYU33njT9OnTs7Ozg64Q4NJfv+enTt20eVP90EvQDTbO5yNFT+8N O+TxJ3r27IlOLcQI9tGX2Lxp0/avtrM5nLxBvkr17HMjRSyoKyiQ5+XhwzKASEF7 GbDP5ysvLzebLTSKA0QuBGBggdnwL+n5bd26LS0tLeguYOBLf4n58+atWr06IYHu kFHbNm3ffucddGoh6oUl+hJ79+z5aOVHLMd+4+o/M5s69fnk5GSxCpL0XtSyJT4p A4g4ffv0ttpslIobDIbKSiOl4gARCgEYqNNoNPn5KgadS47jSlaWdLz00qArNGvp 70tLlqz4cAXtYW2fL+7qq65avGQJ1VYAwitc0Zf46ccfP17zMeP0S25WxcUTc0Vd rEvutEqlEp+UAUQWcvd7/vmpP//8M6X6WAYMcC4EYKCuXbt2GRnpDBq6/B//eOfd 94J+e7OW/pIn1o033hB0W4Hz+XwXXXTR0tdexzJgiEphjL5x4Uu/z454RldYKGJN bH8FEKGsNtvu3bsXLVxA6fN0h8Nx6NBhGpUBIhcCMNBVUKBTqRgdfbRnz95QOrLN OvV33Jgx+37bF3RbzUIy8OSpz//r2msxuRGihv/3iPxHuKIvsevbb9d/up7xul+e 5/v06t2pc2dxy6akpup0OtwiACKO/2bY4/77KH3GTe45J0+etFppTbEGiEQIwECR QiHPz89PSUmh3RCJiBPGT+jdp0/QFcxmc4Cn+Fpttp9//rl4wnhmo0Y8L7wwc+ZV nTujdwtRILxDvg1I+v30s08Zj/2SO9W111x7b/fuolcuKCzMy83FJBGACHXvvfd6 PIGuwGouvV5vNJooFQeIRAjAQBGzva+UCsWXW4M/vdNutzvrB6MCQbrvt99+m8fj Cbq5wDVsBP3Agw89/PDDCMAQ0SQSfePCl37btm03aNAg0Svj9COASDdq5Mg//vyD UnEsAwY4CwIw0EKir0ajprSz/5k4jtv65Va1RhP02y2WZpwQsOyN1996+x0mJzr9 F88LY8aNu+3WW9HBhQglnehLbN+2bcsXWxinX0Ihl48aPYZGZQz/AkS6LZs2LVr8 IqXidrv9yJEySsUBIhECMNDCbPj3huuuX/Lyy0G/3Wg0+ny+AF9M+vE33HA9mwON G5B+7aefbcAmWBBxpLDQ9ywk/W7espnxut+4+t/iyZOn0PhAMCk5ubCwEJ+OAUQ0 j9t9993dEuiMGXi93r/+2k+jMkCEQgAGKkj01Wo1LHqZPt+evcFvRlVVVUX66IG/ fuSzz363+/ugmwsCCeePPPzwE08+xbJRgKA1hN44KeVevy+/2LJ12zb2Y78ESb9p aWk0KmP4FyA6dOlyV+AfxzdXeXm5yWSmVBwg4iAAAxVshn8FQZg/b/7td9wR3Nud Tqfdbj/zKzzPNxHaSc/++uuvl8nY/tb4fN/v/oFpiwDNcWbijZNe6G2w4bPPvt31 LePpG4TA88XFE7PpjNBi9S9A1Hji8SHHqN08K04L6KgLgFiAAAziU6mUGg2L4d8C nW7D5xuDe6/P5zMajc16y9JXXln+wfvBNRccny/uhuuvnzd/PstGAS5IysO8jVq3 du3uH3azT78cx40bO05B59NA8tcpaNEiNzsbw78AkY7cVJctW/bpp+sp1cc+WABn QgAG8TEb/t2589vs7Ozg3m4ymUiFZr3lvu7dKyorgmsuOOQK161br9VqWTYKcK5I GeZt1Afvv//Hn3+EIf3Wcc8+95xOp6NUPyUtTafVYvgXIApYbbajx46NHT2K0hoN p9NVWlpKozJAJEIABpExG/5t1bLl2nVBflZqs9nc7tMH7pGEGfjD5pprrmHZhfb5 4nr17j1w4EB0cCEsIm6Yt1Gvv/ba0WNHwzL2O3rkqPxgd6e/IHLj0hUWYvgXIDr4 77e9evag1H0ivR2DwYBlwAB+CMAgMjbDv6Rz+fvvQZ6YRx4zVVVVzX2L2WLpfu9/ mG2f4/P5brrxpvHFxdj8GZiJ6GHeRs2eNdNqs4Ul/T4zfERBixb0mtBqtQqFAjcH gGjy0IMPmswmSsX1er3RSKs4QGRBAAYx5ebm6HS65ORkqq2QcPjsiGcefvTR4N7e rHOP4uo/N62x20tLS0cMHxZci4Ej10X66tj5GZiJjmHeRr2/fPmff/3JPv2Sb+nQ p55u1bo1vSYSk5JatGiBuSEA0YTcOubOmbPz252U6mMZMEADBGAQE0m/+fkq2q1o 1OpNm7cE997mnnvkZ7XZjhw5MvRpFomUZODbbr31hRkzGLQFMSj6hnnPxXHcwgXz q6qrwzL2O3jQ4PYdOlBtBUcfAUQf0tPYu3fvrJkzKN24amrsZWVlNCoDRBwEYBBT u3ZtMzIyqDZB+pfffrsrJ6ihD5fLVVNTE8QbSWYgT6Z77u5Guz8tCELv3r0HDhqM sR0QSywk3jORW8Q7b79ddjQM/Tw26TclNVWn0+EWARBl/Pfqnj3uT0xMpFHf4/Hs 33+ARmWAiIMADKJRqVQ6nZZ2RLzpxpumTZ8e3ObPlZUhHYJ3zTVX0/vb+Xy+zMys kaNGdb7qqpysLIztQNBiLfGeyel0zps71+1xs2+apN9HHn7k0ssuo9pKQkKCtqAA e18BRKv/3HOPt85LozLpZuj1euyDBRCHAAwiYrD9FcmfX3/9TVpaWhCdP7PZzPN8 KK1fe801lH5jyGPp2mv/NXfuXJJbsOsVNFcsJ94zWczmOXNmJ9AZPGkam/RL6AoK 5Hl5uEUARKtnRgw/cPAgpeIGg6Gy0kipOEAEQQAG0XTo0J5EU3r1BUFYuHDRrbfe GsR7a2trHQ5HiBdwww3Xk25uiEXOQv5S7du1f2ro0EsuuQRzGiFASLzn+nbHjvWf fUpp6mDTmKVfTH4GiHqrVq58+913KBXHPlgAfgjAIA6VSlVQoKPbhFL5xZdbg3gj CZkmU6hb/5PI0ad3b0OFIcQ6/n2e/VeVnZX98KOPdu3aVSaTYeAXmoDE2wSv1/vi ooWWqipmp5Sdic263zhMfgaIDbV2+/097qd0N3M4HIcOHaZRGSCyIACDOGjPf+Z5 fu0na9u0bRvEe0n6JWkzxAuw2my7d+9+fuqUoCs0RN/6//Y9/PAjffr2RfSFRiHx Bshqtc6ePYv9bs9+5Mc0ZPAQBuk3DpOfAWLGHbffJktIoFGZ4ziz2VxREdJ+KABR AAEYxEF7/+cWhYWffrYhiDfW1NS4XK7QL8C/EfTd3brJZCH91vC88LfLLhs0ZEi7 9u2x2RX4nRV345B4A0B6cru//37d+nXh+iUiF/D0k09RPe+3gVqtVqlUuF0AxIIH +ve3VFkoFS8v14c+Jw4g0iEAgwgUCrlOp0ug84FlXP3w75YtX2i12ua+kfRQLRbR niIkpYx87rmffv6pWe9qGPj1+XxpqWnDn3nmpptuwsBvzDo368Yh7jZfdXX1668t tQV1qpkoyM9x2NBhLVu1YtBWYmJiYYsWebm5DNoCgLB7Yfq0b3ftolS84jSMAEOs QwAGEajV+UGk08DptNrPN24K4o1Go5HETrEuw2qz/frrrxPGjw9iuqUg+AY89OCQ x5/APs+xA1mXBo7jvtq27YutWxMTaX3iFsg1PDN8REGLFgzaio+PLygoyM3NxU0D IEZ8u2PHCzNnUCqOfbAA4hCAQRRUFwALgvDx6o/btW/f3DdarVaPxyPilfjzzF13 3hH4gkP/8O/d3e6+5l//6tSpE7ZvjVbIugyQ2Llp48bvd38v4qdawV3GyOdGamh+ 5HcmrU6nkMuRfgFiB3mgdLnrrsQkKnvaO53O0tJDNCoDRBAEYBBB27ZtMjMzKRVP SkretWtXc/t/JPqSAEzjeoY9/fTPv/5ywZfVR9/4fv37DxgwICM9HQO/UQabVDH2 y88/r1q9OsQV+KHj6uqKJxTnyuVsmsO5RwCxqUuXuyh90sfzvMlkwixoiHEIwCCC jh0vSU5OplT8P/+5d+TIkdnZ2c16V2UlrZs7ST7XX39do0cU1D+tfAkJiR07duzb r59GoykoKEDujQ5IvOFCou+aNWsEnxCurZ4bcBw/auRItUbDprnEpCSNVotzjwBi 0JBBg06cOkmpOPbBAkAAhlCpVEqdTkepb8px3K5d36WlpTWrC1hVVUXiCo3r8Xvj 9dfffufsc+rJN+Daa64dNXo0+W74wxKibxRoyL1IvIyR3/1vvvpq6/ZtPp8v7NGX EHh+zJixCpqHvZ1JJpPpCguRfgFiEHnuLFm8+MutX1Kqj32wAMLfq4BIl5+fr9PR Wg6n0Wg+/fSzZnUB3W63zWajdD1+Vpvt888/P+uL3bp1w0zFqIHcG0Yul2v9unW/ /PprGLe5OosgCOPGjc/Ly2PWIk79BYhZpI/x2++/z5g+jdJnf9gHCwABGEKl0ag1 1OYE9urdZ+jTTzdr/jO9yc8NGt3xCOO90cH/w0XuDQvyy7vig/f1BoPUfpWKiyfS 2+bgXOSOqlQqpfZNAAA2/I+hHvffR+kmgH2wABCAIVT0AjDHcTt27CT9zsCfAbQn P0MUQ/QNF4fD8fnnG/bu2SuFhb5nkckSJk6cmJaWxqxFbHwFAHGnp5V15XmeRmXs gwUgra4GRCKaZyDF79mzJ/BXM5j8DFEJ0TcsOI776Ycftn+13WqzJSZSOfAjROlp aWPHjae3w9+5kpKSNDpdTlYWhn8BYtwTjw85Ru2RhH2wIMYhAEOo2rRpnZWVRaNy gU634fONgb+eweRniDKIvuydzr0//rhjxzdmi0WaudcvNydn5KjRLK8wISFBW1CA ja8A4PQ+WEsWf/kl9sECoAIBGELVvn279PR0GpWv7NTp1aWvBdgXxORnaBZEX8Zc Ltf3u3b9+NOPlqoqKefeuNPnmfk0avXQYcNZXqdMJtPqdHm5uUi/AIB9sACoQgCG UNELwLfdetukyZMD2QGL9K1rampoXANEJZJ+bXY7oi8DJpNpy5bNB/Yf8Hg9Es+9 fiT9tm7desiQx1k2Svq4OpJ+se0zANTDPlgAVCEAQ6joBeA+ffo+9dRTgQRgTH6G AGHglwGv1/vzTz/98MMPhgqDTCaT2r5WTSDp92+X/e2BBx9k3C5Jv3K5HOkXAM5E bx8sjuPNZuyDBbErYvolIFlhD8AWi4XjOBoXAFEGA7/0kN/BQ6UHd+3aVXb0KPk+ R8Rg71kEQfjXtf+6t3t3xu1qtVqFQoH0CwBnwT5YAJQgAEOo6AXgbl27jRk7tukA jMnPEAgM/NJAQu+J48d37NhxpKzM5XJGdITjef6uO+/69623Mm5Xo9UqkX4B4By0 98EyGCowew5iFgIwhIpeAL7h+hsWLFzYdNcQt2+4IAz8ioiE3gP79+/e/f2xY8cj ZVnvBZG/VO9evTtfdRXjdjUajVKpRPoFgHNhHywAehCAIVRt27bNzMygUrlNm9Uf r2niBZj8DBeE9Bu62traX37++bff9hkMFd46b5QFNvIvZOCjj11y6aWM21Wr1SqV Ksq+mQAgFtr7YNnttUeOHKFRGUD6EIAhVK1bt87OpnIOcHJy8g8//Hi+P8XkZ2ga pj0HzT+3+ddffz10+FBVVbVMFi+TycJ9UVSQv+nQp4e2bNWKcbtIvwAQCHr7YHk8 nv37D9CoDCB9CMAQqsLCAqVSSaMy6Zv+/vsf5/tTTH6GJmDgt7lqbLZd3367/8B+ o8lEfvViIZuRv+bYMWOVKhXjdlNSU3U6XW5ODuN2ASDiDBk86MTJkzQq+3y+8vJy s9lCoziAxCEAQ6g0GrVGo6FUfO6cubffcce5X8fkZ2gC0m8grFbr3l9//fOvP/V6 g381bwSdVxQ68o9kzJix+fn5jNtNTkkhd8ycrKxY+IgBAEJBblPz5s7dsXMHpfrk 5m80GikVB5CyGOruACVqtVqrpRWAL+7Q4aOVJWd90el02u12Si1CRMO05yZUV1fv 27Nn/4H9ekOF2+VMiLHEeyby72TixEm5ubmM201JTc1Xq5F+ASAQVptt69atby57 g1L9itMwmQ5iUYz2fkBEKpWqoEBHqTjP899+uystLe3M/iImP0OjMPB7Jo7jLGbz 3r17Dh4srTRWer3ehISEmE28ZyJ3lalTn6e0d30T1Gp1ekZGRno60i8ABII81EgG 7te3D6X99k0mc3k5NoKGWITOEIRKozm9mwvpW1Oq/8gjjxINpwFj8jM0CumXRNzS /fv3Hzxw9OgxS1WVIPDRcUaRuOLj4qc+/3xycjLjdrHrFQAE54477pDJqHTXXS7X wYOlNCoDSBwCMIiA3lHARFZm5rbtX/k7jtj5GRoVg+mX4zhrVdW+334rLT1YUVHh dLni4+PpfQ4VHcjNZMzYcew/F8B5vwAQtAf697NUVdGozPO8yWTCLGiIQQjAIAJ6 G0ETgiCUlJRcfPElcZj8DOeInUW/9pqa/Qf2HzpYevLUSavNRjouGOANnM/n02l1 Tz39dBjSr1arVCiQfgEgOJOKi3/65WdKxcvLy00mM6XiAJKFAAwioLoPFpGvUm35 4ktMfoazRPHAr9frPVRaeuDAgWPHTs9nrvN6ExKxgjdIJP3+7bK/PfDgg+yb1mq1 CqRfAAgWecx99OGHH370IaX6BkMFhhYgBqE7BSJQqVQ6nZZe71wQhCWLl1x8ySWU 6kMkiqb0y3HcqRMn/vzrryNHjphMJpfbLZNhPrM4SPq94fobut19N+N2yf2QpF+5 XI70CwBBs9psR48dGzt6lEwmo1HfbDafOoV9sCDmIACDODp0aJ+WlkavfnJS8vIP PsAGquAX6enXaDT+8dtvR48eLdfr7bWnz/TCfGZKyDd2+vQXGDdKuqpanS4vNxf3 KwAIhX+ZT88e91N6Rtjt9iNHymhUBpAyBGAQB9VlwHH1wzhdunR95NFHc3Ny6LUC ESHi0q/T6Ty4f//+AwdOnDhebbX6l+9iPjMbF7W6aMjjj7NsMSExkaTf3OxspF8A EMV//nOP1+ulUdntdh84cJBGZQApQw8MxJGfr9LpaJ0G7Mdx3OpVq/Pkcqqt0OP/ HJf8R9Pj2P6XYay7UZGy5ZXJZNpXfwBvRUWF2+OW1Qv3RcWo6679193/+Q+z5pKS k9UaDdIvAIjoiceHHKPz1BMEQa83mM3YBwtiCwIwiKZjx0ton67Zsqhozrz5ERoO TWbzoUOHjEYj5/W63a7q6mqeFxr+NCkpMTMz6/T4dnx8cmrqlVdeqaI5oh6JpDnw y3Hcvj17srKySNbd99tv5H89Xg8GeKWjV89eV3TqxKatlNRUVX4+0i8AiGvJiy9u 3LyJUvHycr3JZKJUHECa0EUD0dCeBR1X/1Fl/wce7N69u8QnQtfa7Tu++Wbfvn1H ysosFrPL7eY5nvy2Bb6tEc/zPsGXkJiQkpyiUavbd+hwxRVXXHfddaSHHReTo8QS TL/V1dVvvbmsorKS/BR8Ph8SrzSNfPY5ZX4+g4bUGk16enpM/VYCAANer3frF18s efklSvWxETTEIPTYQDQqlVKn09GOARzHlawsUUhsdNThcGzZvGnnzp1HjpQ5XU5K U15JKibfXJ1W17FjxxtvueXiiy8mve1YSMKSSr/kZ12ycuVf+//CMK/0kV+ZmTNn 0d5gjPwz0Gi1Cmz4DABiI4+/+o2aT40fP47SrQwbQUMMQu8NxNS+fbv09HTarajz 899b/j7tVi6IPJY2b9y4afPmI2VHBEFgfGiNjxCEoqKW3e6555ZbboniJCyd9Eui 79JXXzGaTDigKFKQfzzz5y+g2gT5x0DSLzZ8BgAarDbbqZMnya1s9OhR2AgaQCwI wCCmgoIClYr62CyJfvf+597+Dz4YlrxXa7cvW7Zs584dNXa7FI6uOR2Eeb6oqKhf /weu7NxZ4pPDm0si6ZfjuHfeefvQoUOIvpGF/HbMnj2HXn1seQUAVFVbrcePHSO3 silTJmMjaACxIACDmJRKpVqdz6AvSHLRcyNHXnfd9bTzXsNqWxKBXlu69Jtvvq51 OKSQe88lCEJqSmrv3r379O0bHd1xKaRf0uFYvXr1nj2/Rse3NNZkZmQUT5xEqbha rU7PyIjKaRcAIAXkIWipqjLo9eS/l776yomTJ2m0go2gIQYhAIPIGGyF5cfz/KqS VbRPRbLabF9//fWa1asNFQZp5t5z8bxw1513PvnUU966ugjtnUvhuKPa2toPV6wo PVQaid9A8GtZ1PKJJ58UvSwW/QIAA6QHUl5e7vV4yH9/sWXLV19/RakhvV5vNGIj aIghCMAgMpVKpVbns8mKCrlixYcfiluzYchX4PnXXntt0+ZNEbrBL4nB3e+7r1+/ fjKZLLJicNgHfs1m84crPjh56lSkfOQB59P5ys739+ghbk0s+gUANkgAPn7smCCc PjGx/NSpl195mVJD2AgaYk3kdetB+pgNApNoSjq4o8aMESXg+aMvedIcP3HinTff 9G/zK8p1hgv5/pDO+pNPPX3DDTdEytrg8KZfg8HwwfvLjSZTpP/owe++++676qqr RSyYnJKSr1Zj0S8A0EaehtXV1eXl/92fmeM4bAQNIBYEYBCfSqVUq9VsIgTJq127 dntwwICcrKygu6QN0besrOytN944dORwNOUf8tS8/rrrxowdJ/0Z0WFMv0aj8b13 3zGZzdjmijHye0fjzLC4+g+ARo0aLdqHcfHxGo0mLS1N4r9EABAdrDabXq/3uN0N X8FG0ABiQQAGKpgNAsfVp6Ynn3r65ltuCToDk8fM0WPHXnvl5SNlZdEUfc9E/l7j iyd26NAhlE8KqApX+jWbzST6VlRWRuuPXprIj9vlcnk8nvj4eEr3Co7j5s2bL0op WUKCVqPJy8uT5u8OAESf0/Ofjx8XeL7hK1MmT/bWUdkImtyNDx4spVEZQJoQgIEK hUKh0aiZdRZJZ3rylKmXXnZZEOmO3PenTZv2008/Rn3+IXmgX/8HevToIcHp0GFJ v1ar9Z2339IbImZ7s0gnCIKrnsfjTUiQVVScXnJG78Mynufnzp0Xep3k5OR8nHUE AGxVW63Hjh498yv0NoImd8vff/+DRmUAaUIABlrYnAncgOf4WXPntm3TJpB055/z nJyU9O7bb3+ybl1iYqzMeiUZuG/vPoOGDAn3hfwP9unX6/W+v3z5gYMHEH1p8/l8 brfH4aglP2USgE2ms0/aaNeuXUZGOo2mSV6dNm16SCXi4zVqdVp6OqY9AwBL5IZp NpsrKirO/CLVjaDLy/UmEzaChliBAAy0aDTqnJyctLQ0Zi3Gx8WvLCnJCSAAW222 b7755vXXlvo3V4wp5K988003TyguDveF/Bfj9Mtx3KaNG3fs3IHoSw8JvR6Pp7aW hF5OEPhzQ++ZLr20I6VsSbLriGeeDfrt2O0ZAMKF9FJOnDjBc9yZXyw/efLlV1+h 1KJebzAajZSKA0gNAjBQpNVq8/NVLM8Qys7KXvHhh+frsPoHfn08P27c2LKjR2N2 uyOST/72t7/Nn78gvJfB/rDfvXv2rCxZGYmHWklf/Uiv2+FwBBJ6G6hUyoKCAkqX dGWnK3v07Bnce1NSU1X5+Zj2DABhce7857j6D3AnTBhPqetScRpOQoJYgY4g0MVy Nyw/jVq97M23zuq2Nuzz/OGKFevWrcXoH4krt9xyyxNPPhWuuZ2MB36rq6uXLn21 pqYG6VdEPM+73R6Xy0l+mjwvmM0Bhd4zqdX5Wq2WxrURPXv07HTllc19l0wm02g0 JABj2jMAhAW5o1qqqgx6/bl/NGrUSEr3JZyEBDEFfUGgS6lU5OfnJycns2y0fbt2 S176v/Pi/Vnr2NGj8+bMttpsiEB+JL10v+/+Pn37st8XmmX65Thu7dq1P/ywG2Em dD6fj/zsPPW8Xi/5J2SxVIVSkN4HZORSx4+fEMiCiDMlJSersd8VAIQV6aicOnWq ztvIhs8TJxbzZ+wLLaLa2trDh4/QqAwgQUgCQJ1Op1OplCxj51lTfMmzZMWKFWvX fJyITu3/IuFw2PDhN910M8t9oVmmX/2pUy+98gr5F8GgrWhF/pGQuOtyuc63i1Uo Wre+KDs7W8SCDcjVNm+SP/a7AgBpIJ2WY0ePkp7MuX+0YP58s0XMm3ADcp/fv/8A jcoAEoQADCzQ6+aeD3lyXNmp04yZsxwOx4jhw06cPCmTyVheQKTg6riSkhIFw0Ob 2aRfr9f75pvLjh07FrMrvYPG8zzpCTmdThJ9eV6gui9ohw7tKe2TFx8XP3PWrABf nJiYqNZosN8VAIQdeUpWVVfryxufjVyycuXefXtptCsIgl5vCGIlC0AkQgAGFjQa tVwuZzwRmmTg1he1PnLksAwRqEmFBYXzFy5kMPDFLP3qT51a/NISfOQRINLvqZ/S XOcl/69OhInNAVKplFqtltKPSSGXjxo9JpBXqusHfjMzMpB+ASDsmpj/TPyw+/t1 69dTahonIUHsQAAGRtjvCA0BIvnnkUcf69q1K9WJ0GzSL8dxq1ev+vXXX7HPWRPO GuMVBEaJ9yzkhqDT6SgVv+Kf/+zVu0/Trzl90JFGk5eXh+gLABLRxPznuPoNHefM mU2pK2UwGCorcRISxASkEWCH/Y7QECCSiNav/zQ9PZ1SfTbp12QyLVm8mOO5C780 xpDvv9frrV/He/qMIhL8pHDcBdUbQt8+ff9x+eVNvAAHHQGA1JB7NYm45eeZ/+w3 evQoSp/w4iQkiB0IwMCOQiFXKBT0UhaEotMVnWbMnEmjMpv0++2OHes/+xQDv3H1 Q/re00jo9dDYuUos9LYGIH/lKVOmnu9WI6sf+E1JScF+VwAgKVabjaRfr8fTxGvG jBmTkEBl5QhOQoLYgQAMTGk0aqVSiZQiQRzHffbZBnF3JPIfv8zxPNX0S678jTde P378eGwu+vUfTUS4XC7/lGbyNWkm3rNcfHGH1NRUGpW5urp559kCOjklJV+txsAv AEhQ0/Of/aY9/7zL7aLRusPhOHToMI3KAFKDAAyssT8VCQJ0y803jx03XqxqbAZ+ q6ur58+fLwhUzkWUJpJyvV6vfwWvIPgEQYjEfTsVCkVhYQGl+wAJt9OmTT/ri6cH ftXqlNRUDPwCgASdnv9stZafOtX0y15buvT4CSoPVpyEBLEDIQTCAIuBpYlkqQ2f bxQlG7BJv/pTpxa9uCi6j3eu36LZW7+I1z+f2Rcdu3Sq1flarZZS8VYtWz3+xBNn fgUDvwAgcafnP5865T3P/s8NNnz22a7vdtG4APK4OXHihNVqo1EcQFIQgCEMNBp1 RkZmVlZmuC8Ezvbow4/06dcvxCJs0u+Pu3evXvNxlE2n9y/fJd9Aj8dTv2FV2LZo po3qp2D/ufuea6+7zv/fGPgFgIgQyPxn4s8//vhgxQeUrkGv1xuN0fAZK0DTEIAh PEgGzs3NpbQCEIKWmpKybv2noVRgk37XfvLJ97u/T4jwE579y3dJ4HW7I2z5buja t29HaT88QRAmTZqcmXn68zVs9QwAESGQ/Z/9HA7H9OnTcBISQCgQgCFssCGWBPEc 92kIW2GxSb9vvfXmoUOHInEZef18Zo//UCKSeyN0+W7oVCqlRqOh9PkF+fbOn78A Wz0DQASx2mynTp2qu9D8Z79Ro0ZSuq3hJCSIEZHXg4RootVqSVc4NjfvlawH+vV/ 6OGHg3gjg/TLcdySxS8aTaZISb8+n8/t9jgctf4B3midz9xc+fn5Oh2tBcBpqWkz Zs3CwC8ARJBqq/XYsWNxF5r/7DdmzGhKHyDiJCSIEZHRiYQoVlBQoFQqIiXPhI4k ovrNe/+r4evx8TKZLJ480hITE8P73dDkq99dvry572KTfufNnVNjt9NrQizkJ+t0 upxOh9PpxIYi56K6APgff//7+OKJGPgFgEhBHqCWqiqDXh/g6ydPnkTeQuNK7Hb7 kSNlNCoDSEqspA6QsijeFJoEIbfb7T+xhkRfQfBdcJGnQiGXyRJIGCbd95SUlNTU VMb9eHKpH6/5pFn5gUH6JU3Mnj2LfCfpNSEKj8dDOhButyc25zYHqF27dhkZVBYA E8OHDe/arRul4gAAorPabCdPnuQCzrSLFi40mqis1HW5XAcPltKoDCApCMAgCRdd dFFOTna4r0IcJPS6XG6Xy+n11pHMG/qeRiqVKiUlOSsri+RhUa6waSSoj59QfPnl l+fm5ATyejbpd9asmeTBTK+J0DkcTofDIQg8FlA1TalU6HQ6SgsfeI7bsOHzFOyu BwCR4/T856NHA3/9yo8+2vfbPhpXwnHcH3/8SaMygKQgAIMkRMHBSPWzXp0k+no8 brPZInp98i2SyRIyMzMo7Z17pi533vXU0KGBjACzmfk8Z/asWoeDXhOh8Pl8tbW1 5EdvMFSE+1oiA9UTgEmu3rhxE6XiAACiI49Rs9lcUdGMJ8h3u3Z9tuEzStdTXl4e I4cRQCxDAAapIAEvOzubQboTHQm9Dketx+Nh88woKCjIy8tLTKR4AlD7du2WvPTy BV/GJv0umD/PapPiMlpBEOz2WpfL1ayOC1Bd8tCmdetXXl1KqTgAgOjIA+7EiRM8 xwX+lsqKihcXv0jpenAUMMQCBGCQEJKBc3Jy09IiY/pi/dCfo37oz8C4aa1WI5fL 6a0NTk9L+2TtuiZeQKIv+ZtzPM9gz2eT9BbT8jxfXV3t8XhNJvQSmq1jx0uSk5Mp FX/k4Uf69utHqTgAgOiqqquPHzvWrLeQh+OECeMpbQRtMFRUVmIhD0Q5BGCQFo1G k5eXy2axa9BI9LXb7U5nOIf+tFptfr6K0n7RPC98+eWX5/tTNof9Ei8tWaxn/uFC 0/5/9GU02h99VCpVQYGOUnHy01m3bn1GRgal+gAA4iLPU5PJFETgHD16VGJiIo1L wlHAEAsQgEFySAZWKCgOb4bCv+DT4XBKYdZr27ZtMjOprJrmOG7r1m2N/hGz9Pvm m28ePnxIOudjCYJQVVWF7Z1DRHX+M/n13LLlC0rFAQBEZ7XZjh8/LvB8c984Yfx4 X1xAhwY3F44Chlgglc4lwJmkmYGdTqfdXst+wvP5FBQUqFRUsgQJeys+/Cg3J+es HwGz9Lv2k09++PEHiaRfKQz4R4327dvRW+df1KLFG8vepFQcAEBc5JFaVV2tLw8m bc6aNbOmpkb0S4rDUcAQGyTRvwQ4F+1lrs1CnlJWq608qKcUPVRnk46fMOEf//if k5CYpd8d33zz+cbPKR2T01wOh6O2thY7PItCpVLqdDp6n2sMemxgz969KRUHABCX 1Xa6X+H1eIJ47xuvv3a0mSuHA4SjgCEWIACDdGk0GqVSQWmVS4B8Pp/FYnG7qZxs FKLc3JyioiJKQXHE8BG33X57wwcQzNLv/j//fPvdd8L7Q/cjP/Samv/H3p3Hx1Xf 9/63JVmyJEu2pRlpRnKT4JUdbkK2pg1beu+jaXOTNmlIfml/bZLbtOHX381tsQle 8L5v2BC2hLAGMCRhB7Nvsc2OwTZg403LLNKs54xmNMs5M3OPLOoSY8mydb5nfT3/ uA9K7M/3C+ZqznvO9/v59IVCIbM34hxCzz+rqvo4E4AB2EdSkjo7O8ul0in83gd+ //s33nxD9y2NOfJx/95774uoDFgHARiW5vf7mptNy8BaBJLllHXOPH+SuIa6P/nn f/7bb39n8K8NS7894fCGjRtMT7+Dna647qu7GTOmi+tQVVNd8/AjjwgqDgD60j5Y 44lE+FS/Y3391VcffHi4YQ2nrFwuB4MhPv7gbARgWJ0pGdjKL34/btasmbW1tSIq Hz1Nalj6jUaja9asGTfO5PSbTmfS6T56YOpO9Pnn8849b/mKFRa5NAEAw5NkORAI KIXCqf32nlBo83XX6rulo7QAzJA/OBsBGDZgcE+sQqEgSVIoZN0Xv0eJDsCGpd9s NrtkyWJzu15Z86a3Y4ju/zx33vzzz/+jW+sAYFlJSero6NB+eJ3ab1dVdf78eYLu QGnPP5FIRERlwCIIwLAHw3pi9fX1ZTIZu7wAFBqAv/k3f2NM+tU+yFeuXKFlYNEL DSN9hF3+3O1o5syZdXVC/lvVlIrF+3/3+/q6Ot4AA7A+RVFisdgoJwvMnn2FoJ94 jAKG4xGAYRs+X6uWgQVdeR3znzc/7TX+btasWbW1Qrr+/NM//tPX/sf/MCD9aq7d vCls3oQhO/65247X621r84t7w9/e1vbrW28TVBwA9CXJcnd3t6oooyly5ZVXVlYK eQNMAIbjEYBhJ1oGnjx5ck1Nje6V8/l8MinZbtCruCZY3//e98897zwRlY9x//33 vf3222Ydfs5ms6lUiilHogk9/zzmj3u2AYDFJZPJjlEPMbr66qtVdVQReijRaIzb QHA2AjBsxufzTZw4Ud/Xnn0D0na88XL22WcJag/24x/+aPrMmSIqf9y2l19+9PHH zBr5K8upbLaf77lFmzRpYltbm7izG6qqbt36JIefAdiCoijRaLS3d7QfPevXrY0n Erps6RjpdPrAgYMiKgMWQQCG/fh8rQ0NjfX1daMvVSqVEomETY+/ejye9nZRbXVn XzG7WeQrO83BAwduuvkmU4YeaX/u8XiCb7iNof1X6vV6xdVvbmq6+557xdUHAB1J stzV2VksFkdZ5/Zbb923/0NdtnSMbDa7b5+QyoBFEIBhS1oGrq+f0NAwYTRFFEVJ JpO26PZ8XFqo0KKFiMrlcnnp0mXiXtmNGWgyGbrmmo2mpF9VVROJhH3/3G1n+vRp EyaM6v+rDu+yv/vuD3/8Y3H1AUAvgw8eunz9uvXxx1/e9ofR1/kkbZPvvfe+iMqA RRCAYVfNzU21tbWnfLEwm83Ksmzr46+trS1+v19EZS0irlu3XkTlQX19fcuWLa2s rBS3xFAKhYL28MGlX8OIbn+l/bf66KOPCeqFDgD6kmQ5FArlc7nRl9qze9fd99wz +jqfVC6XOzs7JUkWURywAgIw7O3UmuukUqn+fttf/vT5Wn0+n4jKqqKuWy8qAGsR dOmSJcXSaE9/nYJcLidJkt3/3O1FdPurpsmT77l3i7j6AKAjLQB3dnSUSiUdSiUS a9atHX2d4woGg9FoTFBxwHQEYNhee7v2hN08wldM5XI5Ho/b9NLvMcRFC+2zec0a IR+rqqpuWL9OewIQUXx42WxOlkm/htL++2xtbRHanur7l33vH3/4Q3H1AUAviqIk ksmQTu0ntM/T+fPnCeoiGQqFIpGoiMqAFRCA4QRtbW3NzU0nPFJ75PJnUvuxbsyu RJs+ffqECfUiKlePG7dk6TIRlW+88Yauri4RlYfngBPvdtTe3u71Cnz9qyrq448/ XjNeyChsANCXJMvBYLCQz+tVcM6c2YJaaYTD4d5e+43GAEaIAAyH8Pl8TU2Th+nb lM/nJUly0uVPcUOAvR7Pf1wxW/ey923ZsvOdncaP/OXdr1lmzZop9HZui7flzrvu ElcfAHSUlKTOzs6yHuefB82ZM6eqSkg3jZ4BfGjCsQjAcI4jI4Ibj/vAncn09/Wl nPTTXOgMpLPPPOsH//AP+tbc+sQTL770ovEjf/P5fDKZdNIfvV20tflbWlqELvG/ /+3///pf/7XQJQBAF4qixBOJsK5n0ObOnTtmTFnHgkcRgOFsBGA4SkuLt6Gh8Zjx SNFoTEtBsZij2jmIawGt+fpffv3Pv/pVHQu++MILT2x9wvi2z6RfE02bNm2Ug8qG p6rq1q1PCr1gDAB6kWQ5EAgohYKONZcvW5bpz+hY8CjtwUmXWU2ANRGA4TQ+X2tV VVVz80BbLEVR5IGPHAf+EBfXAatcLs+ePUfH4tu3bXv4kYeNT7+FQiGRSJB+TeH3 +1paWoQed//Mpz993S+uJwADsIWB888dHdonrI41r7t2cygsZKZ9X1/64MGDIioD VkAAhjO1t7dNmjQpHtfyj3Mu/X6cuNdriqKsX79Br2ovvfji4088bnz6VVU1Ho87 6cq3vUydOrWxsUFc/VKpNG/+gvPPP3/SxIniVgEAXQycfx74SNI5rN515x3vf/CB vjUH9fdnP/zwQxGVASsgAMOxvF6Pg6fYnXXWmYLefek4A2nrE0+88OILxqdf7R9B +6PX/VEDI+T1ev1+n9D73uOqxt119931dXW8AQZgfQPnn7u7tRisb9mtjz/+8rY/ 6FtzUKFQeP99IdEasAICMGA/WsBob28TVLyxoWHuvPmjr3PXnXfueW+P8V2vyuVy LBYLBh0y7MqOxJ3PP+pb3/zmv/70cqFLAIBekpLUcfiw7mXfefvt+357v+5lNcVi cffuPSIqA1ZAAAbsR+h41fPOPe973//+aCpks9lrN2/SPu+Nn3ik0dKvI29924XP 19rS0iL0iw9VVR9/jPG/AOxBURTtg0nEhazenp5NmzfpXnZQIBCIxeKCigPmIgAD 9nPaaadNnNgoqPj/+/f/cMZZZ53ybz944MDNv7zZ+GPPg0i/pps69bTGRlH/cQ76 9Kc+/YvraX8FwB4kWe7u7lb1Pv885shB5auvXiDoC8dgMOjge2RwOQIwYD9nnHF6 TU2NiMqqWlyxYkV1dfUp/N50On3Lr34ZCofNSr99fX2ZTIa2zyby+XwtLV6hr3+L xeKixUvOPvts2l8BsIVkMtnR0SGo+OzZVwj6NjAUCkUiURGVAdMRgAGb8Xo97e3t gooXi6W1a0+6A1ZfKnXPvffs37/fxJdy/f39qVSK9Gsu0c2fNdXjqm+/886GCRN4 AwzA+hRFiUajvb2iPpvEBeBwONzbGxFRGTAdARiwGaEXgJsmT55z5c9H+IsLhcJb b7zx4ksvJpLJqqoqQVsaiXw+n0wmSb/mMmD2b7lc/u53L/v2d77D618AtiDJcldX V1FVBdW/8so5gk5d9QzgUxXORAAGbEboS7a/+Npf/OOPftTd2TnUL8hms+/v2fPO u+92dnZkczlzc+8gRv5axPTp0ydMqBe6hBaA77v/t0w/AmAXiWSyU9j5Z83cuXO1 H40iKhOA4WAEYMBmxE0A1tLFBZ+7oFQqJRKJL3zhC81NTcFQSPsATCTisVgslepT lMLYigqzrvgel7ZbbW+hECN/TdbW5m9paRG9yl987S+umD1b9CoAoAvR5581S5cs yeayIioTgOFgBGDAToROALadIyN/48EgbZ9NNmnSRJ/PN17wXCKmHwGwl4Hzz52d xWJR3BLXbNwQiQppVRWNxvh4hVMRgAE7mTKl3eMRdQHYdhh6ZBFC76Ufdd45565Z t070KgCgC0VRkpIUDASErnLzTTd2DH1raTT6+tIHDx4UURkwHQEYsJMZM2bU19eZ vQtLSKVShw4dNnsXGDiV0NLiFX0pV1XUBx54oJHeVwBsQpLlUCiUz+WErnLvvffs 2rVLROX+/v4PP9wvojJgOgIwYBseT3NbW5vQIat2kclk+vr6uJ5kBcacSvj0pz79 i+uvp/cVALsw4Pyz5smtW196+SURlXO53N69+0RUBkxHAAZso729zev1mr0L82Wz OVmWSL9W4PP5WlvFjj4ac+T278rVa2bOmMH0IwC2MHD+OZk04A7tG6+//sCDD4io rP0jvPfe+yIqA6YjAAO2MXXqaY2NjWbvwmSFQiGRSPb0MPTIEmbOnFFXJ/xMvhay N27a3DBhAm+AAdiCMeefNV0dHTfefJOIysVicffuPSIqA6YjAAP2MGnSxPb2dpcH AEb+Wooxva+0P/Sly1ececYZvP4FYBdaAO7s7CwJPv+syaTTy1csF1G5XC4HAoF4 PCGiOGAuAjBgDy0tLW1tfrN3YaZisRiLaemXkb+W4PO1ejyeqqoq0Qv5ff4N11zD 618AdqEoSiKZDBkyQ0hV1QUL5gu6hxIMBqPRmIjKgLkIwIA9uHwAUqlUisVioRDp 1yqmTp3a2NggehXt2W7FqtWzZs7k9S8AuzDs/POgOXNmC/ouMhgMRcUMGQbMRQAG 7OH002eNHz/e7F2Y40j6jWvPE2ZvBB9pa2vzej2ie18NLORvW79xI69/AdjIwPnn jg7tk8uY5cQFYO1jNxIhAMOBCMCADXi93rY2vwF5w4K0Z4h4PB4Mkn6torm5uaXF W1NTI3ohRVHWrF03ffp0Xv8CsAsjzz8PEheAw+Fwb29ERGXAXG58ngZsx7Xnn0m/ FmTYf41nn3X2goUL6+vqeP0LwC4kWQ4Gg4V83rAVr7xyTmVlpYjK4XBPby8TB+FA BGDABmbMmF5fX2/2LozGyWcLamvze71eAw4jqKr68MOPuPA/ewC2ZvD5Z81VV/1c 0M/kngEEYDgQARiwOo/Ho6WOiooKszdiqGKxGI/H6XplKS0tLc3NTQYcftZc+NUL 586bZ8BCAKCXgfPPiYTB39suWLCgWFRFVCYAw6kIwIDVGTNt1VIGnyGY92s1U6ee 1tjYaMBCxWLp4YcfrqurM2AtANCL8eefNSuWL0tnMiIqE4DhVARgwOqmTZvW0DDB 7F0YJ5fLSZKsfeqavRH8kfb2No/HiM7P5XL529/+zncvu4zeVwDsJSlJnZ2dZQPP P2s2rF8fiwuZ1ssdYDgVARiwNC1y+P0+Qf0tLCh9BF85W43P52tubjKmGVV1dfXt d9zJ6CMA9qIoSjyRCBvet+KG63/RHQiIqByNxoIGtrMGDEMABiytvb3N6/WavQsj lMvleDyupV9Jks3eC/6Iz9c6YYIWSI3oR1UsFmfPufKLX/wir38B2Isp5581t996 6779H4qonEr1HTp0SERlwFwEYMDSDLt1aS5FUZLJJC2vrMnIKVynfea0VWvWMPoI gO0MnH/u6CiXywave8/dv9m9Z4+Iyn19fQcPEoDhQARgwLqam5v8/raqKoeff9Y+ YjOZDMeercnv93u9HmOakKuq+tCDD01oaDBgLQDQkVnnnzW/++1v33r7LRGV0+nM gQMHRFQGzEUABqyrrc3f0tJi9i4E0p4YJEkKBpn0a1E+X+vkyZONmXtULpe/+93v /vjH/8uAtQBAX5IsBwIBpVAwfunHH3ts2/ZtIipnMv379+8XURkwFwEYsK6ZM2c4 dRJMqVRKJBK5XD4WE9K7ErqYNm1qg1HvYysrKx966GFOPgOwI7POP2uee/bZZ597 VkTlbDa7b5+Q28WAuQjAgEX5fD6v1+O8/s/a80E6nc5k+hl0ZHFGXv1VVfWK2XO+ /OUv0/sKgO0MnH+Ox8Nhc9pYvLJjxyOPPiKici6X27t3n4jKgLkIwIBFOe/172D0 7e/vD4eJvlZn5NVfzdlnnb1g4UJ6XwGwIxPPP2ve2bnzvvvvE1E5n89/8MFeEZUB cxGAASsy8uWbAYrFYjKZzOcL0WjU7L3gxHy+1qampurqamOWK5fLjz7yaLUhN40B QHdJSero6BhjxvlnzYf79t12+20iKiuK8t5774uoDJiLAAxYjtfr8fl8Djj8rAWb /v5sf39/Pp+LxeJmbwcjMmnSRK/XW19vxNTfMUdugy9dsvRLX/6yMcsBgL60lBiL x3tMOv+sCQUC113/CxGVVVXds+c9EZUBcxGAActpbW2dOLFx/Pjxhh1A1ddg7s1m +3nla0cGnz749Kc+dc+9W/r6+gxbEQB0JMlyd3e3qihmbSAlS6tWrxZRuVgs7t4t ZMIwYC4CMGBRWgiprKwYN25cXV1dTU2NxV8Il0qlfD6fyWQURSkWS/R2tqn2di39 No8da9BHg6oW33zzTS39ao9ZxqwIAPoaOP98+LCJG1ALhasXLRRRuVwuv/vuLhGV AXMRgAEbmDRp4rhx1VoerqqqqjvSKEj7C8NSynGpqvaZq6iqUjhC+5iMRgm99ub3 +4587WLQVy2lUmnhwoXf/vZ3ent7jVkRAPQ1cP45FjN3qIH2cbxgwXxBjwQdHR2S JIuoDJiIAAzYksfTXHHEmIEBqlW1teNFXNosfkw+n9c+ZccM5JayFl14x+swBje+ GnPk8PNDDz+i/XclSZJhiwKAjkw//zzo5z+/UtCdqUAgyMc9nIcADDiEFmB0r9nT w6s5V9D+42lsbDRy7Jaqqm+++VZNTU0ymSyYNDsEAEbJ9PPPg668co6gwzvBYJDj XXAeAjAAuN3UqadpAdiw5Uql0srlK/7qG9/Q/przzwBsSlGUaCzWa+r550EEYOCk EIABwNWMHzp9xumn33PvFu0vCoVCMpk0cmkA0MvA+eeursHLQeaaM2dOVZWgABxi mgOchwAMAO7V3t6mpV8jG6qVy+W33945eF1NkqR8Pm/Y0gCgo0Qy2dnRYfYuBsye fcW4ceNEVCYAw5EIwADgUga3fR5z5OrvbbfedsHnPz/4f3L+GYBNDZx/jkYt8kOM AAycFAIwALiRz9fa3Nws6JlpKJdefMn6jRsH/1p7fEwkEkauDgB6kWS5q7PTIjPM CcDASSEAA4DrtLS0NDVNHj9+vJGLTpo46YUXXzz6f3L+GYBNKYqSTCaDwaDZG/kI ARg4KQRgAHAXn6+1oaFBxODoYaiqun37jo/3mrbI0UEAOFmSLIdCoXwuZ/ZGPkIA Bk4KARgA3MXgoUeaYrG4etWqr//VXx/9O/l8XpIkI/cAAHrRAnBnR0epVDJ7Ix8R F4C1nB+JEIDhNARgAHAR44ceab5wwedv/tWvPv53EomEoigGbwMARm+wf4GWDM3e yH8hAAMnhQAMAG6hpd/m5mYjhx5p6mrrtu/Ycczf5PwzAJuSZDkYDBas1MKAAAyc FAIwALiC8SN/xwxc/S3u2L694Y9PXPf39/f19Rm5DQDQS1KSOjs6yuWy2Rv5LwRg 4KQQgAHA+fx+v9frqaioMHJRVVU3b9p8yaWXHvP3o9Gode7OAcDIKYoSj8fD4bDZ G/kjIptgBaPRmIjKgIkIwADgcD6fz+NprqqqMnLRcrl84YUXLVu27JiGW9rfj0Qi Ru4EAPQiyXJ3d7dqsRYGdIEGTgoBGACczOdrbW5uFvRsNIwp7e1333NvbW3tMUv3 9fX19/cbvBkA0EVSkjoOHzZ7F8ciAAMnhQAMAI6lpd/JkyfX1NQYvO7YsWPfeOPN ysrKT/5PtL8CYFOKomhp0II/xAjAwEkhAAOAM2npd+LEibW1tQavq6rq1q1PTpky 5ZP/U6FQSCaTBu8HAHQhyXJXZ2exWDR7I8ciAAMnhQAMAA6kpd+Ghsb6+jqD19Ue DZctXfrNb/3Ncf/XeDyuxWODtwQAozcw/jeZDAWDZm/kOAjAwEkhAAOA02jpd8IR Bq87VOOroyx4dBAARsKC43+Pogs0cFIIwADgKFr6raurGyqCCjX1tNNuu/2OTza+ GkT7KwD2ZcHxv0fNmTNbUJ9/AjAciQAMAI4yZUq7x+Mxft2a6ppXX3ttmF/A618A NmXN8b9HXXnlnOM2HRw9jkDDkQjAAOAcZqXfYrG0fdu2hqFfO9P+CoB9WXP87yBV VRcsmD92rJBH+kAgGIvxBhhOQwAGAIcwK/1qj1/33rvl7LPPHubXaI9QFmydCgAn pChKUpKCgYDZGzm+fDa7eOkSEZXL5fK77+4SURkwFwEYAJxAS7/Nzc2CXgIMQ1WL K5Yv/5/f/OYwv0aLvrxDAGBTkiyHQqF8Lmf2Ro5PSiTWrFsrorL2o3v37j0iKgPm IgADgO2ZlX5LpdLf/+Dv51x55fC/LJlMFgoFY7YEAPpKSlJXZ6f2487sjRxfoLvr +htuEFFZVdU9e94TURkwFwEYAOytvb3d4zEh/ZbL5XPOOef66284Ycdp2l8BsKmB 9leJRDgUMnsjQ/pw797b7rhdROVCofD++x+IqAyYiwAMADbW3t7m8XiMT78av8+3 5b77hxp6dBTTjwDYlyTLgUBAsfAZlnfefvu+394vonI+n//gg70iKgPmIgADgF21 tWnpt7miosL4paura1555ZWRLM3rXwD2lZSkjsOHzd7FcHZs3/7oY4+KqJzL5fbu 3SeiMmAuAjAA2FJbm9/j8ZiSfseUy9t3vFJXV3fCX9jf39/X12fAjgBAd4qiRKNR i3+L99yzzz773LMiKmez2X37PhRRGTAXARgA7EdLv83NzZWVlcYvrarq00897W9r G8kvjkQi5XJZ9JYAQARJljs7Oizb/mrQY488sv2VHSIq9/f3f/jhfhGVAXMRgAHA Zvx+v8djWvq94447P/vZz47kF+dyOVmWRW8JAESwfvurQVvuvffdXe+KqJzJZPbv PyCiMmAuAjAA2Im56Xf1ylV/9Y1vjPDX8/oXgH1Jstzd3a0qitkbOYFbb7ll/0Eh MbWvr+/gwUMiKgPmIgADgG2YmH6LxeLll1/+r//60xH++nw+L0mS0C0BgCCKoiQl KRgImL2RE/vFtdcGw0JeU6dSqUOHLN0ADDg1BGAAsAe/39fc3FxVVWX80uVy+aKL L1m6ZMkJR/4eFY1GLX5xDgCGIslyMBgs5PNmb+TE1q1dm0gmRFSOxWKBQFBEZcBc BGAAsAFz0++55563afPmhgkThh/5e1ShUEgmk6I3BgCCJCWps6PDFpc4li5Zks1l RVTuGWDpDtjAqSEAA4DVmZh+NVNPm3rb7bfX1taOMP2O4fUvADtTFCUWi2nhz+yN jMj8efNKZSE/bwnAcCoCMABYmpZ+m5qaRh4+9dXa0vLkU0+f1G/h9S8AW5Nkuauz s1gsmr2REbnqqp+PHSvkeZ4ADKciAAOAdZmbfmtra7dt215RUXFSv4vXvwDsS1GU RCIRsvz0o6PmzJlTVSWkM2I43NPbSwCGAxGAAcCizE2/FRWVr7zySnV19Un9Lpo/ A7A1u0w/Omr27CsEfUyEQuFIJCKiMmAuAjAAWJG56bdcHvOHl19uGHHP56OY/QvA vmw0/eioOXNmC+oQEQqFIpGoiMqAuQjAAGA55qbfUrH4zLPPtbS0nOxvzGazqVRK xJYAwAA2mn40qFAoLFx4taA7wNq/img0JqIyYC4CMABYi8/na242Lf2qqvroo499 5jOfOYXfy20xAPalKIqUSgW6uszeyEno7enZtHmToOIEYDgVARgALMT09HvflvvO POusU/i96XQ6k8noviUAMIYky6FQKJ/Lmb2Rk7B717v33HuviMrFYnH37j0iKgOm IwADgFWYnn5vu/W2Cz7/+VP77bz+BWBrSUnq7OiwVxeDZ55++vkXnhdRuVAovP/+ ByIqA6YjAAOAJZiefjdt2nzppZee2m+XZTlnq9cmAPBxiqLEYrGenh6zN3Jyttx7 77u73hVROZvN7tv3oYjKgOkIwABgPnPTb1Etrlq58q++8Y1T++3lcplRGQBsLSlJ XZ2dtpthftONN3Z2dYqonE6nDxw4KKIyYDoCMACYzPR3v1cvuPq7l112yhXi8bhW RMctAYCRBl7/xuM94bDZGzlpa9esTooZvZ5KpQ4dOiyiMmA6AjAAmMnkd7/F4hX/ /h//+MMfnnKFfD4viXn8AgBjSLLc1dmp/Tw0eyMnbeHVCxQx3z/GYrFAICiiMmA6 AjAAmMbceb/a095P//WnP7388tEUiUQi9uoZAwAfpyhKPB4P2/D1r+aqq34uaAhw zwBaG8KZCMAAYA5z02+pVPrRD3/4s//z76Mp0tfX19/fr9eWAMB4A69/u7qK9rzH MXv2FYI+RAjAcDACMACYwPT0+93vXjZ//vxR1mH0EQBbG3j9m0iEQyGzN3IqVFWd O3duVVWliOLhcLi3l+6GcCYCMAAYzfT0e+mlX1u8eHFjY+No6tD7CoDdSbLc3dVl 0x9lKUlatWa1oOLBYCgajQoqDpiLAAwAhjI9/V500cWLFi9umDBhNHug9xUAu1MU JZFMhoJ2bfX0zs6d991/n6Di3d2BeDwuqDhgLgIwABhHS7/Nzc1VVVWmrF4ul7/0 pS+vXLVqlOl3DIefAdjfwOvf7m5VUczeyCl67JFHtr+yQ0RlVVX37HlPRGXACgjA AGAQ09PvBRd8fu26daNPv7Is53I5vTYGAMaz++tfza233LL/4AERlbPZ3L59+0RU BqyAAAwARjA9/X72s59bv2HD6NNvsViMxWJ6bQwATGH317+atWtWJ8VcRUmn0wcO HBRRGbACAjAACGd6+j3nnHM2X3vd6NPvGAb/ArC/gde/iUTIns2fj1qwYH6xWBRR ORaLBQI2fjcODI8ADABimZ5+zzjjzOtvuEGX9JtKpbLZrC4bAwCzOOD1r2bOnNmC PlkYAgxnIwADgECmp99Zs2bdeNPNuqTfUqnEVAwAdueM17+a2bOvEDRQgAAMZyMA A4Aofr+/ubnJGelXo6VfLQOPvg4AmMgZr39jsdj69evGjhXyJB8KhSORiIjKgBUQ gAFACC39ejzNlZWVpqyue/rl8DMAB3DM69/XXnnloUceFlQ8GAxGozQ7hGMRgAFA fw5Lv3R+BuAMkix3dXUVVdXsjYzW/Vu27Hz3HRGVS6WS9q9IkmQRxQErIAADgM7a 2vzNzc5Jv2Po/AzAERRFiScSYfu//tVcs3FjJCrklHI+n//gg70iKgMWQQAGAD05 7N2vRpIk7XlIl1IAYKKB17+dnYJGBxlswYIFxaKQ99gMAYbjEYABQDfOS79a9NUC sC6lAMBEiqLE4vGecNjsjehjzpw5VVVCPmsYAgzHIwADgD6cl341vb1MwgDgBElJ 6ursdEYre1VV5869iiHAwKkhAAOADhyZfuPxuGr/VjEAMPD6NxbTgp3ZG9FHNBLZ eM1GQcXD4XBvLzOQ4GQEYAAYLUem33Q6nclk9KoGACZKSlJnZ2fZEa9/Nc89+8yz zz0nqHgwGIpGo4KKA1ZAAAaAUXFk+lVVNR6P61UNAEykKIqW6Jx0oePGG67v6u4W UblYLGr/rjgCDWcjAAPAqXNk+h3D3CMATqGlXymVCnZ3O+ln2qKFVxcURUTlXC63 d+8+EZUB6yAAA8Apcmr6TSQSiphHKwAwmCTLoVAon8uZvRE9zZkzW1AHrL6+9MGD zECCwxGAAeBUODX9cvUXgGMoipKUpGAgYPZG9FQoFBYsmC/o04cZSHADAjAAnDTT 0+8555yz+drrdE+/XP0F4CSSLAcCAaVQMHsjevpw797b7rhdUPFwuMdJl6WB4yIA A8DJcWr6HcPUXwAOoihKIpkMBZ32PvOhBx987fXXBBUPhUKRCC2g4XAEYAA4CQ5O v0z9BeAkkix3d3erjutosGH9+lg8JqJyqVQKBoPxeEJEccA6CMAAMFIOTr+yLOec 1SQGgJspihJPJMKhkNkb0d9VV/187FghD/DZbG7fPlpAw/kIwAAwIqan3/PP/28b r7lGRPrVoq8WgPWtCQAmSkpSV1dXqVg0eyM6U1V17tyrBLWATqX6Dh06JKIyYCkE YAA4MdPT72c/+7n1GzaISL+lUika5cYXAOdQFCUWi/X09Ji9Ef11dXbeeNONgorT AhouQQAGgBPw+33Nzc2CvnE/IaHpVxOJRLQldC8LAKbQ0q+USgW7ux35k01oB6xw ONzbGxFUHLAOAjAADMfZ6ZfGVwAcRpLlUCiUd2hTg3Vr1ySSSUHFg8EQB4LgBgRg ABiS6en3S1/68spVqwSlXxpfAXCYgde/khQIBMzeiCg///mVFRUVIipr/+ree+99 EZUBqyEAA8DxOTv99vf39/X16V4WAEw0MPqoq8upB1uEdsDKZDL79x8QURmwGgIw AByHz+fzeBybfhVFSSSY9AjAUQZ/soWcOPpo0L4PPrj9zjsEFacDFtyDAAwAx/L7 fU1NTSKS50iUSqWvfOUry1esFJR+Nb29vSLKAoBZtPQr9/UFuroc2ftq0O233bbv Q1FzeumABfcgAAPAH/H5fM3NZqbfiy66eNHixeLSL22fATjPQO+rcDifzZq9EYEW LVpYKBQEFacDFtyDAAwA/8Xna21qaqqurjZldQPSL22fATiPoihJSQo6t/fVoDmz Z1eNE3Ixhw5YcBUCMAB8xOfzTZ48qaamxpTVDUi/kiTl83kRlQHARJIsd3V1FR39 7Z6UTK5es3rsWCGP7ul0+sCBgyIqAxZEAAaAAT5f66RJk8aPH2/K6gakX+35JpPJ iKgMACZSFCUWj/eEw2ZvRKyHHnjgtTdeF1ScDlhwFQIwADg//ebzeUmSRFQGABMN DP5NpQJdXWZvRLhVq1amUilBxemABVchAANwOy39Tpw4sba21pTVDUi/2hK0NgHg SJIsBwIBRVhrKOuYM2e2oMl85XI5FApFozERxQELIgADcLWWlpZJkybW1dWZsroB 6XcMQ48AOJSiKPFEIuzcwb9HxWKx9evXCboAnMvl9u4VNV0JsCACMAD3amnxTpw4 qb7eyek3Go1qCwkqDgBmGTz8HOzudsNctwcfeOB1YReAo9FYMMgFYLgIARiAS/l8 rRMmaNmz3pTVjUm/sVisWCwKKg4AJnLP4WfNiuXL0sK6GPYM4KAQXIQADMCNtPRb X1/f0NBgyurGpN9kMllwx6MhALdxz+Fnjaqqc+deJegCsCYYDNEnAq5CAAbgOlr6 raura2xsNGV1Y9JvKpXKZrOCigOAiVx1+FnTefjwTb+8WVDxfD7/wQd7BRUHrIkA DMB1pkxp93g8pixtTPrNZDLpdFpQcQAwlyTLwWCwkM+bvRGD3Hbrrz/cv19Q8VSq 79ChQ4KKA9ZEAAbgLo5Pv4z8BeBgrjr8PGj+/HniehnGYrFAgA5YcBcCMAAXMTH9 lsvlL33pyytXrRKafovFovY0I6g4AJhr8PBzKBBwT3P7QqEwb95ccZ8aXACGCxGA AbhFe7uWfpsFzVEcnjHpdwwjfwE42sDh50DAVe39dmzf/uhjjwoqrv2bfP/9DwQV ByyLAAzAFdrb2zwej1np94ILPr923TrR6TcSibikJQwAF3Lh4WfN+nVrtX9qQcVT qdShQ4cFFQcsiwAMwPna2vxa+q2oqDB+aS2Rfvazn1u/YYPo9BuNRt1zJhCA23zU +TkQKLvsB93s2bPHjRM1ACkajQWDXACG6xCAATic3+/T0m9lZaXxS2vp9/zz/9vG a64RnX7j8biqquLqA4C5JFkOBAKKmw4/a0LBwLXXXSfo7JL2CRUKhbQMLKI4YGUE YABO5vP5mpubhIbPoWjPFuecc87ma68TnX6TyaSrbsQBcJuBw8/xeDgcNnsjRvvl zTcd7ugQVDyXy+3du09QccDKCMAAHEtLv5MnT6qpqTF+acPSryzL2kOMuPoAYK6P Dj93d7uwx8FVV/1cXOsKBiDBtQjAAJzJ52udOHFSbe1445fWntJmzpx10803i06/ 6XQ6k8mIqw8ApnPn4ecxR073rF69Slz3inA43NsbEVQcsDICMAAH0tJvQ0NjfX2d KavPmD7jll//ura2Vmj67e/v7+vrE1cfAEynKEosHu9x3+FnzT333L17925BxUul UjAYisfjguoDVkYABuA0kyZNbG5ubmhoMGX1z3z60w8+9LDoVfL5vCRJolcBABMN HH6WpGAw6MLDz5p58+aK+wfPZDL79x8QVBywOAIwAKeZMqXd4/GYsnSb3//4E1tF r6KqKl/bA3A8SZa7u7tVRTF7IybQkv/KlSvEzS/gAjDcjAAMwFFMTL8tXu9TTz8j epVyuRyJcGsLgMMNHH6OxXp6eszeiDmEnn/WBIOhaDQqrj5gZQRgAM7R3q6l32Zx PTOHMXnSpOdfeNGAhXp7ew1YBQBMpKXfpCSF3Hr4eYzg888MQILLEYABOERbm9/j 8YhrmDmM2trabdu2G7B0JBJx7eMgAPfQ0m+gu1tVVbM3Yg7OPwNCEYABOIHf72tu bq6qqjJ+6Zrq6m3bdxiwdDQaLZVKolcBAHMpiqL9uHPzaRfR559DoTBXaeBmBGAA tufztTY1NVVXVxu/dFVl1R+2bRs/Xvi04Xg87tqXIQDcY+DwczIZDLr6/eS8efPK ZVFfd2ofJYFAQJJkQfUB6yMAA7C3lhbv5MmTa2trzVh87Pbt2+vqhE8bTiQSiiv7 oAJwlYG5R6lUOBgsFotm78U0PT0911yzUdydmlSq79ChQ4KKA7ZAAAZgY0dG/noa GiYYv3S5XH7ppZcnTpwoeiFJkvL5vOhVAMB0kiyHQqF8Lmf2Rsx00003dnZ2iqsf jUaDwZC4+oD1EYAB2JhZQ4+KxeIzzzzb2toqeqFUKpXNZkWvAgCmUxQlkUyG3H34 WTNnzpyqKlHtr7QPr3C4JxaLCaoP2AIBGIBdtbe3e70mpF9VVR9+6OGp06aJXiid TmcyGdGrAIDpBg8/hwIBl7f6O7B//y2/vkXcML++vr6DBzn/DLcjAAOwJbOGHmlP affcc++5554reqH+/n7tSUX0KgBgBZIsB4PBguuve6xftzaeSIirz/lnYAwBGIAd +Xw+j8eEoUeqqt54w41/9ud/LnqhfD4vSZLoVQDAChRF0VJfOOT2YFYoFObPnyfu o43zz8AgAjAAm/H5WidPnlxTU2Pwulr6XbF8xf/85jcNWCgej4teBQCsYODwsyQF g8FyuWz2Xkz22KOPbt+xXVx9zj8DgwjAAOykublJU19fb/C6xWLx//zsZz/68f8S vVCpVIpGo6JXAQCLkGS5u7tbZdLbwPjfuUK/BeD8MzCIAAzATkxp+6yF0h98//+5 8qqrDFirt7fXgFUAwAoURYnFYj09PWZvxHzxaHTt+nXiGltw/hk4igAMwDba27X0 2yyuPeZxlcvlL3zhC+vXb2hsbBS9ViQS4RAgAJfQ0m8ymQy6fu7RoGs3bw73hMXV T6X6Dh3i/DMwgAAMwB78fp/H46msFDUdcShnnH7GTTffXFtbO27cOKELRaNRl8// AOAeg3OPwsFgsVg0ey/mKxQK8+bNFfopE4lEQ65vMwYMIgADsAGfr7Wpqam6utrg df0+3xNbnzRgoVgsxlMgAPeQZFnLY/lczuyNWMLjjz26bbvA9leKogSDQUmSxS0B 2AgBGIDVNTc3NTc319XVGbxubW3tjh2vGLBQIpFQaAADwDW0n3jazz1eSB4luv1V LBYLBDhqDnyEAAzA6kxpfFUxduwrr75mwDvnZDJZKBRErwIAFjF4+DkUCHDpY1BP KLTp2s1C21uEQqFIhPkCwEcIwAAsrb29TUu/Bje+KhWLL7740uSmJtELybKc4wQg ADeRZDkQCCh88fef1q5Zk5SS4upns9l9+z4UVx+wHQIwAOsypfGVqqq//93vZ86a JXqhdDqdyWRErwIA1sHco2PIsrx8+bKqqipxS3D+GTgGARiARbW0tDQ1TR4/fryR i2rp97prr7vo4otFL5TNZlOplOhVAMA6BuYeSdLA3CPmvf2nX/3ql0KnE5VKpXA4 HI0y/hf4LwRgABY1derUxsYGI1csFov/8e//8U8//KHohQqFQjIp8MAbAFgNc48+ SVXVuVddVTVO4Ovfvr6+gwcZ/wv8EQIwACtqb2/3eg1tfFUuly+88KJly5Y1NjYK XUh7+IvF+DIegLsw9+iTtj7++Mvb/iB0Ccb/Ap9EAAZgOaZc/T191qybf/mr2tra cePGCV2ot7dXaH0AsBpFUeKJRJgk9seuuuoqoR0e8/l8Mpns6eFDB/gjBGAA1mLK 1d/mpqZnn3vegIUikYjQYY8AYDUDh5+PXP3lp9/HvbNz55b7tgidcUD7K+C4CMAA rGXq1NNEH0I+RkVFxeuvv2HAC+doNMrcSwBuI8lyd3e3qihmb8RaFiyYL/Q6NO2v gKEQgAFYSHt7m9frNXJFVS2+8MILHo/w+8axWIzWLwDcRlGUaDTK1Y9jdHd2Xn/j DUJf/9L+ChgKARiAVfh8rVoQFToO8Riqqt52620XfP7zohdKJpOFQkH0KgBgKVr6 TSSToSCncI+1fNmyTL/YOfCRSCQUCgtdArApAjAAS9DSb0NDQ319vWErlkqlf/v/ /u2ff/IT0QvJspyj8SkAlxmcexQKBLj6cYxEPL5m7ZqKigpxS9D+ChgGARiAJUyZ 0m7AOeSjyuXyZz/7uU2bNom+b5xOpzMZsV/zA4AFSbIcCAQUDr98wto1q5OSJHQJ 2l8BwyAAAzCf3+/zer1Cvw4/dkWfb8t994seepTL5WRZFlcfAKxJURQtg/X09Ji9 EctJSdLylSuEtl1UVTUc7onH4+KWAGyNAAzAZF6vp6mpubbWuLlHY8eOfeONN0W3 fdYeQXj+AOBCWvpNJpPBUGgMc48+gde/gOkIwABMZvDhZy2XPv3U0/62NqGrlMvl SCQidAkAsKCPrv4GgyX63n+CAa9/tU+fUCgcjUbFLQHYHQEYgJkMPvxcLBZXrVz1 V3/916IX0tJvmVcfANxHkuVgIEDf++My4PVvOp0+cOCg0CUAuyMAAzCN1+tpbm4e P96gw89aIr3kkksXL14suvFVNBql6ykAF+Lq7zAMeP07hulHwAgQgAGYxuDDz38y Zcpv7r5HdOOrRCKhPQKKqw8A1sTV3+GtWb1aksW+/s1mc/v27RO6BOAABGAA5jD4 8PPYsRVvvvmm6OUY+QvAnbj6O7xQILDp2s2iX/9Go7FgkPZXwAkQgAGYwOdrbWxs rKurM2Y5VVUfffSxz3zmM0JXyWQy6XRa6BIAYE1c/R3eokULRf/L0er39vbG4wmh qwAOQAAGYAIjDz+XSqX58+Z/97LLhK6Sz+clwa1NAMCauPo7vA/ee++Ou+4cO1bs UzfTj4ARIgADMJrP1+rxeKuqxJ4EO+qCz33uV7f8WugSWsZm5gQAd+Lq7wnNnTt3 zBix/3K0P4Xe3oiWgYWuAjgDARiA0aZNm9rQ0GDMWtXjql97/XXRqzD0CIA7cfX3 hHbs2PHIIw/z+hewDgIwAEO1tflbWlqMWUtV1eeee170cgw9AuBakiwHAgGFq79D 0D6G5s2bV1kptv9isVjs6emJRnn9C4wIARiAcTwDDBr8a8zVX4YeAXAtrv6e0P33 37dz507Rq/D6FzgpBGAAxjGy99VZZ575m7vvEbpEX19ff3+/0CUAwJq09JtIJkMM 3RlaJpNZtGih0MnzY3j9C5w8AjAAg/h8rV6vV/QUxP809q233hI69TeXy8myLK4+ AFjWR1d/AwEugAzjF9ddO9AbTDBe/wIniwAMwCBTp57W2NhowELak9k9d99z7nnn iVuCts8A3IyrvyeUkuVly5dVVVUJXYXXv8ApIAADMILf72tpaRHdBlNTLpcvueTS xYsXCw3btH0G4FqKokSj0d7eXrM3Ymkrli9PZ9KiV+H1L3AKCMAAjDBjxvT6+noD Fpo0adLDDz9SW1sr7tqV9sBRZOAHAFfi6u9IvLd7952/uUvoNZwxvP4FThUBGIBw bW1tLS1eAxZSVfWll15uamoSt4QkSfl8Xlx9ALCswau/wUCgzNXfoRkz+mgMr3+B U0UABiDWpEkTfT6fAaOPyuXyv/zkX356+eXilujv7+/r6xNXHwCsTJLl7u5uldlv w/rNXXe99/57olfh9S9wygjAAMRqb2/3eo0YfeT1eJ5+5llx9bWnjViMRw0ALsXV 35FIxOOrVq8S3ftqDK9/gVEgAAMQSIu+Xq+3urpa9EKqqm7fvkNo4yse+wC41sDV 30QiJH6oj92tWrkiJf6gkPbHoX0kxWJx0QsBjkQABiDQlCntHo/w17/lcvlHP/zR //7Zz8QtQeMrAK41cPVXkoKhEFd/h2dM76sxvP4FRocADECU5uZmn69VXDfmo2rH j9/xyqvi6qdSqWw2K64+AFjWYOOrnnCYq7/DKxQKCxbMr6ysNGCh6ACu5ACniAAM QBRjXv8W1eJDDz00ddo0QfXz+bwkSYKKA4DFSbIcCoXyuZzZG7G6X99yy4GDBwxY SIu+QcZQAaNAAAYghNfraWlpMeD175e++KUbb7pJXH2u/gJwLUVR4olEmKu/JxKP xVavWW1A76tcLtfT0yNJsuiFAAcjAAMQwrDbv++88664+tFotMSdNwCu9NHV32BQ +0lr9l6sbsGCBcWiasBCkUiUVmTAKBGAAehPi76trcJf/2rPZIsXL/nWt74lqL4s yzlO/QFwpY+u/oZCqmpErrO1J7duffGlF8eOFf5QnU6nDxw4KHoVwPEIwAD0Z8zr X09z8zPPPieoOFd/AbgZV39HSJblZcuWGnDfp1QqRaPRcLhH9EKA4xGAAeisubmp tbVV9OxfVVWffvoZv98vqD5XfwG4Fld/R86Ywb9jGH0E6IcADEBn7e3tXq/w17/n n3f+bbffLqg4U38BuJaWfpOSFOLq7whs37bt0cceNeDws6qqvb29jD4CdEEABqCz WbNm1tbWCl1CexR47bXX6+rqRBRPp9OZTEZEZQCwOK7+jlxfKrV02VIDOj+P4fUv oCsCMAA9tbX5W1paRK/y1a9euGzZssbGRt0rF4tF7TlD97IAYAtc/R25NatXS7IR rSLy+Xw0GuOzCdALARiAnmbMmF5fXy96lZdeerm2tlZE05FIJMKpPwDupChKIpFg ys5IvPbqqw8+9KABh5/HHPlgCoXCBiwEuAQBGIBuvF5vW5tf6AOBlk4XzF/wnb/7 OxHFJUnK5/MiKgOAxQ0efg4GAmWGn59IOp1esnhx1TgjDj/39fUdPHjIgIUA9yAA A9CNAdOPxo0b9/rrb4ioXCgUksmkiMoAYH2SLHd3d6uKYvZGbMCwzs/FYjEajfb0 MJUA0BMBGIA+PJ5mn89fVVUpbolyubxh/YZLv/Y1EcU5/AzAtRRF0YIW499G4oXn n3/q6aeMOfxM7ytABAIwAH0Y8Pq3vq5u2/YdIipz+BmAaw1c/U0mQ0GC1onFY7HV a1Yb0/lZ+1SKRCLxeMKAtQBXIQAD0Mfpp88aP368uPqlUumG62/4yp/9me6VB/u+ 6F4WAKxv8OpvKBAocfV3BBYtvLpg1CnxSCRKQzJABAIwAB34/f7WVrHTj2pra3fs eEVEZQ4/A3AtSZYDgYBSKJi9ERt46MEHX33tVWMOP9P7ChCHAAxAB1OnniZiKu9R WkDddM2miy6+WPfKsiznmHgJwJUURYnFYj09PWZvxAaikciatWtEjN/7JFVVY7E4 fy6AIARgAKPl8Xj8fl9lpcD2V9XVNa+99pruZUulUjQa1b0sAFifln6TkhQKBjkC c0KFQmHhwquNeferiUZjQa5kA8IQgAGMVnt7u9crsP2V9nC2ePGSb33rW7pX1tIv 194AuNDg1d9wKFRUVbP3YgPXX/+LQCBgzFr9/f2pVIrRR4A4BGAAozVz5oy6ujpx 9bUA/MYbb+p+8Ex7yOgzZJAjAFiNJMuhUCjPBZAReGfnznu33FtRUWHAWoPnksJh Dj8DAhGAAYyK1+tta/MLPRh2ySWXLlq0SPc7xky8BOBOzD0aub5UaunSpVXjjJh7 NIbBv4AhCMAARkX0+F9VVbdv31FbW6vvG2AG/wJwJ+YejZz2AbRyxYpsLmvMcrlc Lh6PR6MxY5YDXIsADGBUzjjj9JqaGnH1L/jcBb+65RZ9a9L7CoBrSbIcDAYLfAM4 AnffffeePbuNWatcLkci0XA4bMxygJsRgAGcupYWb1tbm7j6RVXdtn2H7oefY7FY sVjUtyYAWJ+iKPF4nJQ1Eh/u23fLr28ROuDg4zj8DBiGAAzg1Ik+/+xrbd365FP6 1iwUCslkUt+aAGB9g4efg4FAmcPPJ5JOp5csXmzY1d98Ph+NahGYw8+AEQjAAE6d 0PPP5XL5lzf/8gtf/KK+ZRl9BMCdJFkOBAJKoWD2Rmxg+bKlmf5+Y9bi8DNgMAIw gFMk+vyzZufOd/QtmM1mU6mUvjUBwPoURYnF4z2krBG4//773n77baHTDT6Ow8+A wQjAAE6R6PPPF1900cZrNulbMxKJlMtlfWsCgMVp6TcpSaFgkB+AJ3To4MEbb7qp qsqgq7/5fF4LwHR+BoxEAAZwik4/fdb48eMFFVdV9fXX36itrdWxJq9/AbiTJMvd 3d2qopi9EasbuPq7ZHFVlUFXfzn8DJiCAAzgVHi93vZ2geefmyZPfvKpp/Wd/cvr XwAuxOHnkVuxfFk6kzFsOQ4/A6YgAAM4FaLPP//gBz/4yU/+RccBSLz+BeBCA52f JSnI4ecR+P3vfvfGm28YdvU3m80lEnEOPwPGIwADOBUzZsyor68TVFxV1O07dtTW 1ur4BpjXvwBcaKDzc3e3wuHnEzly9fdGww4/l0qlSCTa09NjzHIAPo4ADOCkeb1e v99XUVEhqP60qVN/9/sHdCyYy+VkWdaxIABYH4efR0iSpOXLl48zaurvGA4/A6Yi AAM4aa2trVoAFlS8XC7f8qtbLvj853WsyexfAG4zcPg5lQp2d3P4ZXiqqi5etKhY Khq2Yn9/fyQSkSS+lgXMQQAGcNLa29u9XlEXgIvF4q5du3UsqD3cxONxHQsCgPVJ shwMBgv5vNkbsbobb7ihq7vLsOW0j6RYLNbT02vYigCOQQAGcNLOPPOM6upqQcVn TJ9+/29/p2NBLf1qDxw6FgQAi1MUJZFIhEIhszdidS+9+OITW58Qd6Pnk6LRaDDI nwtgJgIwgJMjdACSiPPPvb180Q7ARQYPP4eCwVLRuGO9dtQTDm/YuMGwxleaVCp1 6NBhw5YDcFwEYAAnR+gAJFUt7t6t5/ln7Wkjm83qWBAALE6S5VAolM/lzN6IpfX3 9y9evKiystKwFfP5fDyeiEQihq0I4LgIwABOzrRpUxsaGgQV97W2PvLoYzpOP+L1 LwBXURQlKUnBQMDsjViaqqprVq9KZzKGrVgqlaLRWJiO3IAFEIABnJyzzjpTx4B6 jMsu+97ll1/e2NioSzWmHwFwGwb/jsQdd9yxd+8HRq7I3CPAOgjAAE6C0AvAqqr+ 4Q/b6uvr9QrY2gNHkStwAFxDy73xRCJM76thvf3WW1vu22Lk4ef0EXR+BiyCAAzg JAgdgFRXW7t9xys6FuT8MwBXSUpSV2cnY8+HEQqFNm7cIO4c0ycVCoVEIkH6BayD AAzgJEydeppe55M/6cI//+qma6/Vq1o6nc4YeL8LAMylKEo0GuWLv2FoWXTh1QvG Gjj0qFQqxWKxUIirv4CFEIABnIQzzji9pqZGROVyufzII49+6lOf0qsgT4EA3GNg 9JEkBYJB7Yep2XuxrtWrVsqplJErcvUXsCACMICR8nq9bW3+sWOF/NwoFou7duk2 AEmrpj126FUNACxOkuVgMFjI583eiHX95q679ry3R9BH2HFx9RewJgIwgJFqbW31 +32Cijc3NW198im97mXJspxjBiYAdxgYfZRMagHY7I1Y12uvvvrAgw9UGHj4mau/ gGURgAGM1JQp7R6PqA5YF371wqXLlul1wZjzzwDcQ5Ll7u5uldFHQ4hGImvWrjGy 8VW5XI5Go1z9BayJAAxgpKZPnzZhwgQRlbVnhQcfeHDKn/yJLg8oqqrG4/HR1wEA 62P00fAymcySJYuNHHo0hqu/gLURgAGM1FlnnSnoG3R9LwCnUqlsNqtXNQCwsqQk dXd1MfP8uFRVXbF8eS5v6I2YdDqTTvdx+BmwLAIwgBHxer3t7W2CijdNbnru+ef1 qsb5ZwAuoShKLB7vCXPU9vhuuunGzs5OI1cceCGv/YmQfgELIwADGJHW1ha/3y+o +CUXX7xh4zW6lCqXy5FIRJdSAGBxSUnq6uwslUpmb8SKnn/uuaeefsrIxldM/QVs gQAMYESEdsDasG79JV/7mi6lMplMOp3WpRQAWNnA699YrKenx+yNWFFXZ+e1111r ZOOrMVz9BWyCAAxgRKZNm9rQ0CCisqqqu3fv0aua9vzBXTgAbsDr36Ekk8mVK1ZU jasyctFUKnXo0GEjVwRwagjAAEbk9NNnjR8/XkTlsWPHvv32Tr2qcQEYgBsoihKN RvmJ90mFQmHxooVlYxfNZnPJZCISiRq7LIBTQQAGcGJer8fv9wu6SdXe1vbY40/o Ukp7IkwkErqUAgArS0pSZ2dnmde/n7B+3dq4sR8EqqoeOYvOlxGAPRCAAZxYS4u3 rU1UC+iv/+XXV6xcqUspBiABcANu/w7lvi1bdr6zc+xY455vy+VyNBoLMYcZsA8C MIATa21t9ft9goqvXbP2L/77f9elVCQS0Z5FdCkFAJbF7d/jeuP113/7u99WVlYa uSiNrwDbIQADODFxLaCLxeI777yr1+FqrsMBcDxm/x7X5s2bgsGgwek3fQSHnwF7 IQADODFxLaCLxdKuXbt0KcUFYABuIMlyV2cn7e4/7rlnn33m2WeMPPmsyefzyWSS 9AvYDgEYwInNmjWztrZWROW6uvrt27frUqqvr6+/v1+XUgBgTYqixBOJMDdOPyYa iaxbv87gd7/FYjEa5Ro2YEsEYAAndtZZZ44bN05E5amnnbblvvt1Kc4EYACOJ8ly d3e3qihmb8Qqstns1VcvEPQJNZRyuax94gSDfA0B2BIBGMAJeDye9vY2QUfLLrzw oqVLlzY2No6+FBeAATiboihJSQoGAmZvxCpUVV149dXlMUb3PqTxFWBrBGAAJ+D1 erUALKj4kiVL//Iv/3L0X96Xy+VIJKLLlgDAmiRZDgaDhXze7I1Yxc0339TR0WHw oul0JhaLSpJs8LoA9EIABnACra0tfr9fROVSqbRz5zu6tIDO5/OSJI2+DgBYVlKS Ojs6GPY2aO8HH9x6260GX/2l8RXgAARgACfg87X6fEKGAKuqunv3Hl1KpVKpbDar SykAsCBFUaKxWC9dl45IJBKrVq6sGldl5KKqWozHY+EwfwSAvRGAAZyAuCHAmp07 39GlTjwe1+K0LqUAwIKYfnSU9tN+8aJFxZKh/yrK5XI0GgvRfxuwPwIwgBMQNwR4 0sRJL7z4oi6l6IAFwMEG5pwnk6EgjZcGmHL1l8ZXgGMQgAGcgLghwLNmzNxy//26 lCIAA3Aw2l8d9cbrr//u97/TpXnEyPX19R08eMjIFQGIQwAGcAJnnnlGdXW1iMpf +dOvXLNp0+hbQBeLxVgspsuWAMCCaH81KBKJrF27xuCpv9lsNplMRiJRIxcFIA4B GMAJnHvuOYK+a//bv/32z372s9EPAc7lcrLMRAoAzqQoSiwW63F9+ytTpv5q//Lj 8ThtnwEnIQADGI7X62lvbxdUfOPGjX/2Z38++u/yaQENwMEkWe7u6qLP3y9vvvlw x2EjVyyVStFoLBwOG7koANEIwACG4/V629vbRFTWcQgwLaABOFgimew0vOeT1by3 e/cdd91p8NRfLf0GaTwGOA4BGMBwWlpa2tr8IioXVXWXTkOA6YAFwKkGxv9Goy7/ KdeXSi1dutTgqb+0fQacigAMYDg+X6vP5xNRWVXV3QRgABjWwPjfrq6iuw+5rFi+ LJ3JGLliJpNJJBLxeMLIRQEYgwAMYDjiArD282fnzp26FCIAA3AkRVGSkhQMBMze iJme3Lr1xZdeHDvWuEfWfD6fTCZpfAU4FQEYwHCmTGn3eDwiKtfW1u7Y8cro6zAD CYBTSbIcCofzLm7y19vTs279OiPnHg1+poTDbu+5DTgYARjAcKZOPW30Y4qOq83v f/yJraOvk8/nJUkafR0AsJqB88+dnVokM3sj5lBVdfGiRcWScf/45XI5Go2FQiHD VgRgPAIwgOFMmzatoWGCiMrnn3vebXfcMfo6mUwmnU6Pvg4AWI3L+z9vuffed3e9 a+SKNL4C3IAADGA4M2ZMr6+vF1H5T7/85U2brx39wTZZlnO5nC5bAgDrcHn/51Ao tHHjBiMPP2cymf37Dxi2HACzEIABDGfWrJm1tbUiKl988SWLFy8e/fnqRCKhPSbq siUAsA5Jlru7ulw75Hzh1VcrqnE/2wuFgvZpQuMrwA0IwACGc8YZp9fU1Iio/Ld/ ++2f/exnow/AsVjMtRfkADhYUpI6Dh82exfmeObpp597/jnDOj+XSqVIJNrTQ+Mr wBUIwACGc/bZZ1VVVYmo/K8/vfz73/ve6AOwa88HAnAwRVFisZg7I5ksy8uWLTXs 8PORts/xcDhszHIATEcABjCcc889p6KiQkTlTdds+tOvfGX0jzgEYADOI8lyIBBQ CgWzN2KCDevXxeJxY9YqlUrRaJShR4CrEIABDKm5uflP/mSKoOJPPflUS2vr6OsQ gAE4jxaAOw4fLpfLZm/EaMHu7s3XXVtZWWnMctFoLBik7TPgLgRgAEPyer3t7W0i KheLxV27dutSigAMwGEURUkkkyFXBrMF8+cbNvg3lUodOuTSW9aAmxGAAQxJYABW 1V2794y+TrlcjkQio68DANYhyXIoHM5ns2ZvxGjb/vCHxx5/zJjeV7lcLpFIRCJR A9YCYCkEYABDamnxtrUJCcCqqu7WIwAfaV4SG30dALAOdw5A0v55582ba8zh58HP Dq7+Au5EAAYwpJaWlrY2v4jKqlrcvVuHI9DaA1PcqF4pAGAMdw5AeuD3v3/jzTeM WYurv4CbEYABDKm1tcXvFxKAS8XSu7t2jb5OoVBIJpOjrwMAFqEoSjyRCIdCZm/E UKqqzp17laCpe8dIpfoOHTpkwEIArIkADGBIra2tfr9PSOlyeec7746+TD6flyRp 9HUAwCIGLgCHQvlczuyNGMqw17/ap0YymezpoXsi4F4EYABD8vlafT4hAbiiouKt t94efZ1sNptKpUZfBwAswoUXgA17/Xtk6m8sHA6LXgiAlRGAAQxJXAAeN27c66/r 8GV/JpNJp9OjrwMAFuHCC8Bbn3ji5T+8bMBCsVgsEODqL+B2BGAAQxIXgGtra3fs eGX0dbT0q2Xg0dcBACsYmACcSIRcdgF43rx55XJJ9CrZbFYLwPF4QvRCACyOAAxg SOICcNPkyc89/8Lo6/T19fX394++DgBYgQsnAPeEQpuu3Sx69i9zjwAcRQAGMCRx AbjN539869bR10mlUlk3PSkCcLaBC8Dd3aqimL0R42xYvy4mfpodh58BHEUABjAk cQG4taXlyaeeHn0dWZZzLuuVCsDBtADc0dFRLgk/D2wR2Wx24cKrRbe/0lbp7e2V JFnoKgDsggAMYEjiArDmwQce/Mxpp42yCAEYgJMkksnOjg6zd2Gcxx59dPuO7UKX KJVKkUi0p4fDzwA+QgAGMKQpU9o9Ho+IyuVy+R095gBLkpTP50dfBwBMpyhKLB7v cdOQnkULFxaUgtAlOPwM4BgEYABDmjr1tMbGRhGVi8Xirl27R18nmUwWCmIfngDA GJIsB4PBgmu+1DPg/LP2AREdEBO3BADbIQADGNK0aVMbGhpEVC6q6q7de0ZfhwAM wDG0ANzV1aX9eDR7IwZ5cusTL70sdvyvFn2DQV7/AvgjBGAAQ5o+fdqECRNEVFYV Zfee90ZfhwAMwDEGOmAdPlwul83eiEGWL1uW6Rc4yL2/vz+VSvX09IpbAoAdEYAB DGnGjOn19fUiKququps3wADwMW7rgDVnzmyh558jkUgo5KIL1QBGiAAMYEgzZsyo r68TUZkADAAf57YOWNFIZMPGDWPHinoQzWT69+/fL6g4AFsjAAMY0syZM+rqCMAA IJwky6FQKO+auW533Xnn+x+8L64+r38BDIUADGBIs2bNrK2tFVG5WCzt2rVr9HUI wACcQQvA3d3dqqKYvRGDLFp4dUHYP2wul9u7d5+g4gDsjgAMYEjiAnC5POadd94Z fR0CMABn0AJwZ0dHqVQyeyMGmTP7iqpx4wQVZ/YvgGEQgAEM6fTTZ40fP15E5bFj x7799s7R15EkKe+amZkAHCwpSR2HD5u9C4NkMpmlS5dUVFSIKF4qlcLhnmg0KqI4 AAcgAAMY0hlnnF5TUyOicmVF5ZtvvTX6OgRgAM4Qj8e7urrM3oX+CoVCdXX1MX/z 9ddfe/DBBwWtmE6nDxw4KKg4AAcgAAMYkrgAXFVZ+cabOgRgWZZzrukZA8CpFEWJ xmK9PT1mb+S/ZLPZysrKiiOO/s2P/3WpVNL+z2P+36P/a/mIYrGo/f1xnzjq/Js7 73xPWAcszj8DGB4BGMCQzjzzjE9+c6+L8TXjX3n11dHXIQADcABJloPBYMGk8yxa cM3n81pMHcy3gk4mf9zqVSvlVEpEZS11h0KhaDQmojgAZyAAA/+3vTuBbqQ8EDwu S7JkSZbvq213A+6DprvJwTJAuCEwMJBkXmbeZubNJjOZ3X3QOQgkNFdOQiBcYQIJ V9idSTLJ5s3Mzkw2CR1y00AaAi+EhPR9uJtu37Ily7pVVdJ+peoWwrZk2arSVf8f iVu25U/lPqTv76r6CnkZF8Bul2vniy+VPs7c3FwsFit9HACoIHUJ6GPHZFmu9IaU yR133CFa1YiRWf8ZwJIIYAB5GRjAbs/OnTtLHycUCkWj0dLHAYAKMtsS0Nu23bzw uGhd+HzTo6Mc/wygEAIYQF6bN28yaI7S3tb+q2efLX2ccDgciURKHwcAKshUS0DL snzHHbfb7XYjBp9QTRoxMoC6QQADyMu4AO7t6f3JT39a+jiifkUDlz4OAFTQjN9/ 7I03Kr0VZTI3O3vv/fcZNPjY2PjU1JRBgwOoDwQwgLyMC+BVfat+/MwzpY9DAAOo dZIkTc/MTIyPV3pDyuTA/v3f/NY3DRp8dHSUFbAAFEYAA8jLuAAe6B94evv20seJ RqOhUKj0cQCgUmaDwbGxsYRpFrTf+etfP739aSNGlmVl165dRowMoJ4QwADy2rJl s0Gnaa1ZveYHP/xh6ePE4/FgMFj6OABQKSKAR0ZGpGSy0htSJk//8Ic7X3rRiJFZ AhpAMQhgAHmdfvoGl8tlxMhnnXXWk09+o/Tdy4lEYnZ2VpdNAoCKMNs1kL77z/+8 e+8eI0aORCIHDx4yYmQA9YQABpDX+vXrPB6PESNfdtnld955Z0tLS4njJJPJQCCg yyYBQEWY7RpI/+upp4aPDBsxcigUOnzYkJEB1BMCGEBeGzasd7vdRox85ZVXfvaz nys9gGVZnpmZ0WWTAKAiTHUNJOHxRx89PjpixMhcBBhAMQhgAHlVfwArijI9zYKf AGqYPxB44+jRSm9F+Tz81a9OThlyqd7x8YnJSS4CDGAJBDCAvKo/gFOplM/n02WT AKAipmdmjh87VumtKJ8HH3jAH/AbMfKEigAGsAQCGEBexgXw1Vdffccdny49gAV+ 3g+gdqkXAZ6eFt1W6Q0pny/fc08obMjl6whgAMUggAHkZdwq0O997/u2bdtGAAMw ObNdBNhCAAOoNAIYQF7GBfCPfvR0b29v6ZdBshDAAGqZ2S4CbCGAAVQaAQwgL+MC +PnnnvfqsfvXQgADqGUigI8dO6aY5iLAFgIYQKURwADyIoABwFAigI8ePZo2zUWA LQQwgEojgAHkRQADgKHMdhFgCwEMoNIIYAB5EcAAYCizXQTYQgADqDQCGEBeNRHA Pp8vZaajBwHUk5mZmWNmugiwxcgAnp6eHhkZNWJkAPWEAAbMqLu7q6GhwWq12u32 1tZWXVZjXhYdA1jMeBRF0WUoACgzn2i248crvRVlZVwALyRJUjAYlGU5lUql02mf b7o8jwugmhHAQJ3TWlfUbmOj3eFwircid202m/hQBbdKxwD2+/1iiqPLUABQTuK5 y+fzmeE8juxxOqJFH7j/vkg0Wv5tEAGsKIqkkpPJhHibTlPFgBkRwEC9EcVrtYrc bXQ6Re42OhwO8W6lN2q+b33zW6v6+5ubm8VGapu34iCfnZ1NJBK6bh0AlMNsMDg6 Opqsi2cwLXG1yBTEu6J1RWvGYjHxDYrn+Xg87g8EJsbHXnnlFavNVuntPUFsZzKZ FNspXkfEW/EuPQzUPQIYqHmZfbxWh6OxqalJ9KTdbq/s3t1inLLmlJ7e3tWrV/f1 9XqbvW6P29XkcjY1eb3e1pYWm90uur2lpUV8R7al5knBYFDMq8qz2QCgIxHAI8eP 19wxLFrrpjLExotnYPE8nFKUQCDg9/tnZwOhUCgWEx+Oi6pMSkmthwXxq2hk8axe hT+W1YiAF90uNltsvOjidJoeBupQtc+SASyqra3VkeHxeLI7UWuImGGIeYYW6mLj xWyoIXNCsqOxsckluFtbW1cPDp5yyind3d2dXV39q1Y1Ohyih0UVi0/nFr6YaYXD 4Zr7HQAAEcDHjh1TZLnSG7I4kayxWEw8M2tPsNpOXfGRaCQiQndyctLnmwoG50T9 RmNR8V2ooZtOWxsa0pkvzz5RazfmvVsTxLcsYjgSiSQzZmeDld4iADqomecgAJbM zl5nhojAip/HqxdRwvNui7faHgbxDYpv0+lwuD3NXq+3s7NzaGho/bp1q/r716xe LVJZTE3CoZC4W0dnpzZFkyRp3tllHre7/Kt8AcCSRAC/cfRoFa5jL55Ip32+cCQy GwiMjIyIFx3xkVBItO5cIBAQuStLctpy4qm74aTsu5XbcKNoh3aL+E9ksFsYqGl1 +CQF1B/RvQ6Hw5Wx5CHBdSYnicUNMeNK2+x2p8PZ1tbqcnsyn0l3dXa53S7xSbfH 0+hobGiwuj3qf57mZvG/0049VdQyeQyg2ogAPjI8XJGHTiaTMz7f2MT4+Nj49LRv ZsY/NzeXSCZlWRYBK54wtR9EiprN/owyuyM3m7t12bpL0kpYPbc5maSEgVpkxmcu oIb09PQ4HI1tbW12u73S21JF0jksmUmYmK5pUzHtDC5tfmazqecSt7W2dHR0tAje lkanQ9xXVLHb7fZ6veLG2qGhwYEB8hhA+QUCgaNHjxo0eDgcnpo8wS8CNxAIhUOJ REJ7hizmGKLcw3MsZs3dAsTv5OzsbDIpTU1NVXpbACwDz2VANWpra/Woml2uJuYc OlIURZ3SpdNWdRUWm9PR2NLS2t7W2twsYtjTqK6YbXN7PGoeN4uPedeuXSvyuKmp SftyChmAjmb8/mNvvLGyr41EItMivHw+8cbvnwnOBoNzc9FoVJKldCot5nd1c5pM lROvKbFYPBIJiz8RThIGagLPjEDVGRgYaGnxOhwO5i5lpq1Tajm5S9lutzd7PNoi 1R6Px+VyNTrU9cbUdzxu9ejqlpbVg4OnnnKK1+vNDrIwki10MoAM7fkh+4QwPT19 /PjxhXeLxWKzfv/0jChcXyAQUE+9VVf7C0WiMUWR6dsqJDI4mUzOzYVGR0crvS0A lsBTJ1BF+vv7Rfo6nU6mNdXpxA7kDLWQbTaH05mpY5HHTa6mpmav12pTD1ZXP+Z2 aycii1Jes3q16GTxJ5s7GqkM1IF5TVvYyMjIb199NZFZSFnUr0hc/4w/FA5Fo9Gk JGWXxydua5T440skEiKDx8bGKr0tAPLi6RWoCqtW9WnFxOV8alpmpVD1Qpfauw0N VptVnctqF6xyudxNmUW8RRSLMLZkVpfR1jbLTWXxP/GRhYMvGsxFoquBwrL/vpb7 j2VsfPwPf/hDUr3qbWxmeiYwG5gLzoUjYVFBkUg4kRRZKymKYnnragWoY6lUKhqN RiKR8fGJSm8LgEXwLAxU3uDgQHt7u9mWdzYzbXlVbRGvk8uqWjMaxMw7sy9ZlLKj 0W53qJe8crvdLmdTU+bk5bT4lPiAeCum6cU/4ruvuKKttXXJu+U2Ns2MWqHL31vf 9PTw8PDs7GxaUST1iq+zc6E5kbKRqBhb1ExUNK34NZFMKhkLV+ADcom/JAH1IlIc EQ1UHZ6ygUrq6+trafG6XC7mT8gnt5Yt2rP2W6+6WQy7YLOr8ewSad3kdDia1B3P IrVdzd5md+YoblEO4mGUVMqjrv/lXb9+fXdXl1Hf1VsV2LlNh1ezKvmDE+168ODB UCgUCYdtmR6NZPa/iTfhUDgWj8VicfFGtGsiEVdvx+NKSo1Y8SatrXWcTouQ5aeQ 0FdmfazY3FxoYoJdwUAVYc4NVEx/f397exuTe1SnbHg3qLdPvFyou7qsNm2vl1oa 6mLaVrWnHc5G0diNjTZrg3jbaG8ULWGz2xyNDnvmE6K9G9UbIsJdTqfTbrM1Zjkc sUyhiNHE3cSITZkfCYkkt6jHRwyWrcOxXKI8R0ZGLJkVicVfFRGXSiol8lKEpUv9 aYtLSialk2RFSYgAjcdkWRbvibuJX8V/SSmpyGqOqu9IkpJKy+q9ZZGr8URSXZhO TdXUiR8DpcTnM6cYpC0NDerJBuyDRZUTf50DgVnOCgaqBy8YQGVw2DNQjOyu7+zy Y9r+OvWWGkDZG/O/UBRReuFHUVjub9iJn3y85fc525najeUeiQCYE4dDA1WF1y2g 3Hp6ur1er8fjYb0rAADMIJVKRSKRUCg0NeWr9LYAZkcAA2XV19fb2tra1NTEbhMA AMxDPU0gHg8GgxMTk5XeFsDUmIID5UP9AgBgWjQwUA2YhQNlQv0CAGByNDBQcUzE gXKgfgEAgIUGBiqNuThguJ6envb2NuoXAABYTjZwIDA7NTVV6W0BTIfpOGCsVav6 vF6vK3Nd00pvCwAAqAqigWOxWCgUGh+fqPS2AObCjBww1saNpzc1NVV6KwAAQNWJ x+P79u2v9FYA5kIAAwYaHBzo6Ojger8AAGChVCrl9/tHRkYrvSGAiRDAgFH6+1eJ +rXb7ZXeEAAAUKVkWRYNPDY2XukNAcyCAAYM0dfX297e7nQ6K70hAACgqiUSiUAg wKLQQHkQwIAhhoaGmps9HPwMAAAKS6VS4XBkeHi40hsCmAIBDOivv78/c/CzrdIb AgAAaoAsK5kDoccqvSFA/SOAAZ319HR3dXU5HI5KbwgAAKgZyWRyenp6aspX6Q0B 6hwBDOhsaOi05ubmmjj4WVEU8dZZdKun0ieeMtLq9QvTqZT4vyLeNFga0pmPNVhV XPEYAKAX8XKzZvVqu82enbRaG6w5E9jMS85bXnZOfES8GM3Ozo6Nj4sbNlsNHJOV ORA6PDx8pNIbAtQ55qmAnvr6+rq6Oqtz5WdZlkWddrR39Pb29q1addmll15z7bWN jY26DC4mKErG5NTUzp07R0eOT4yNj46NTU1NzgaDyaQk7lKdvy0AgIpTX0QyL1JO p7O9vV28mHZ0dvX09Jx//vmXXHJJiYNLkvTj7duf3bFjYnx8cnLSH/CL1KzOlyTx Sj09PTMxMVHpDQHqGQEM6GnDhvUul6tKdoHKsmKz2Qb6+9/2trddecUVF11yiZa7 YioQi8XEdupVv7nyDS5L0m9efvn5F56fHBsfnxjfu3evbbHJR5X81gEAdKceOqQo aUuDw9HY2tLa29Pd3il0nXvuOVdddfW8Vw19X6rmjSbefeG5537+i1+8/vrro2Nj iqJUybId4rdIbOeBAwcrvSFAPWOuCehmYEBd+6qyx1llXsUb161de/4FF/zN3/xN T09PBTdmnnnzj1AotOuPf3zpNy/t2bNn2ueb8fvD4bAsy+JT2gHk82KYNgaA6ney ci3ixaittbW7u6u1tbWzq2toaO173/OeVf39uXc29AeyxZuamvre97734s6dhw4f lmWp4q/jfr9/dJTVsACjMKEEdLNp0xmVWvtKkWW3233uee/advPNq9esqZIpRTEW 3VSfz/f711579dVX9x3YP+Pz+QOBWDQqybJ4wmrIObk6N4nJYwAoG+20F3HD0djY 0vJm5Z42tPbaa64ZHBzMvbP2PC9uVO2rUu4r0fFjx77y0EMv/+alaDS66JFKZZBM Jvfs2VuRhwbMgCkjoI/BwYGOjo7yr32VSqUvueiiz3/hC61tbbUSvUVatI2npqZe f/0Pr/3utf0H9k9N+YLBYCQSTiQSlpwG1m7MexcAsCwicUXo2mw2p8PR3t7e09PT 1tbe0dl51llnXXXVVU6nM/fO1V+5Rcq+9ARnZ+/64hefe+EFq7XcLyKpVMrv94+M jJb5cQGTYF4I6KCvr7ezs7PcL/lpy3vf974bb7xRPHRZH7cKLDrTikajf3z99f37 9+/Zs+fI0SOBQGBubi4eiysppUH93Vq8kMljAKYlQiulKA1Wq3gibW1p6erq8ra0 tLW1rVlzyrvOO++cc8+dd/8aOrxILzMzM4888siPfvjDMk+ZxW+1eOiJicmyPipg Dsz8AB2sXTvU3NxctpSSZfmqK//0c1/4gnhEU01EirToFG18fHz37l2vv/76gQMH fT5fKCTqOJRIxLWzjk9e3mmRNqaQAdQubS+u1WrVjlXu6ups9npbW9sGBwfPPvvs Cy+8cN6BS3WzI1cv2m+I+D380he/+NOf/6xsa0eLRwyHw4cPD5fn4QBTYWIHlKr8 lz565OFHLi75shDmlG9u5/f7D+zff/DgwX379x87diwSDodCoeBcUEomZUURMxH1 upLptIjhhZFMIQOoiOyJuFrfNjd729vbO9rbWlrbWtvazjzzzHP+5E8GV6+e91Uk 7oo9/9xzN950Y9kejksiAQZh3gaUqpyXPuru6vrf//hPa9asKcNjmVO+A/x8Pt/h Q4eGh4cPHjr4xhtvzM7ORjLisbgkS+mMbCdbFitkOhlA8TJxmxK/iqcOu93udDhb W1s6Ojo8qua+VatE315++eXiyWrh15rwQOWyOXbs2P/8H//dNz1dhsfikkiAQZiQ ASXp71/V2dlZnksmdHV2fee73+3r6yvDYyGfAjtPxsfHjx45IvL48OHDx0dGgsHZ cDgSi0WjkWgimZBlOZVKiRmNnSkpYGLZqwSJsrXZRNk6vN7mtta2lpYWl9vt9rj7 +tS4vfjii+etMqVh/23FTUxMfOiDH5yeKUcDK4oyMzMzNjZehscCzIMABkpy+ukb mpqayrBzT8yZvv2tb7/9He8w+oFQuuwM1bJgkjo3N/d/vve9yYmJqLr/OBwMBkPq 6cihcDiclKRUSj3cusGqYo8xUCuyTZu5Upu10W53OkXWekXTepu9TleTw+Hs7Ozs 6e3dvGnT+eefn+96AcRtrfjD73//dx/+u/K89Mfj8f37Dxj9QICpMMECVq6/v7+z s6MMu3/FS+A9X7r72ve+1+gHgtGKnOAmEokXX9y5d+8+n8/n988kE8lkIjGnrts1 J7pZfFZWlFQqpR16LSZhBDOgixNn1WZ+DiXetVmtdlWj2+3yeJo9bpeoWrujUV0z ubVNNO26des2btiwdv36AmMW+IkYatf2H/3oM5/7bBmeeDM7gf1jY2NGPxBgHkyY gJUr29m/7zrvXQ8/8ojD4TD6gVA9ljVpFjOkg/v379u/f/jIcMAfEJ2syIosS5mz lGOxeDwaFb/EJFmEs3oktnowtsWiLetloZ9R+7QfBml/sbWfCmk/GLJm3oiEFf+I mgSnSvzq9rhtNrvVZvU2e1taW1rb2tcNDW3YsGF1ESssELQQksnkTTfe+NJvXjL6 gTgTGNAdMx5ghVatWtXVVY6zf8Wc7lvf+vY73vlOox8Ita6UefnRI0cCfv/x0dHj x49HM2IxNZpFH4usSCYlKZlIiF8y/8mZkk6o4pld0Yr6Nn1ij3S2Q9RFs9OZw0Jz lgfLXRUsW93qxahOfjb7KZq8hmT/6LXbFu3PXZPz55j9Y7WqP3nJ5KnIVBGi6tmw VlGmok61Q4gbHY2NdnVHq8PhsDeqS0CJEcXfMpGwTU1qzLrdHpfbPTigamttPfW0 05a7zbn/XiykLJbv96+99uEP/11DngPadSSeYaenZ8bHORMY0AfTC2CFhoZOa25u zncql47e//6/uOmmm1paWox+IGBeElgMroLQ3Jx2w7vYX2/ts7OzsyfeDYW0rg6H w+nMDVHpopxD4fCUz6ddzzlXUl14TDFoy+uV2+3O3rbb7T3d3d7mZnFD+7iY6Isn PUvmojter1e7W1tbmyXPn6C+Fv7ltFCtqKi5ubmHH374+9//T6MfSDz1iee94eEj Rj8QYBIEMLASXV1dvb09ZZh4nXrKqY8+9lhPTzkeC6hFi3YRdEFeAgWIJ5+pqamP f+xjR984WobHmpycmi7L5ZeAukcAAysxMDDQ0dFu9PHPsiw/9dRT73rX+YY+CgAA WJmXXnrxuuuus9vthj6Koih+f2B0dNTQRwFMggAGVmLLls1Gv9oJl1562Z133tna 2mr0AwEAgBUIBoPilXrHjmeNfiBZlnft2m30owBmQAADyzY4ONDR0WH02b8ul+sb 33hq48aNHIIIAEB1kiRp3759119/ndHnYqRSKb/fPzLCTmCgVAQwsGxluPqReJ27 7977/uyaa4x7CAAAoItnfvzj2++43bifjGtLrHM9JEAXBDCwbJs3bzJ6r+zbtpz5 5FNPicw29FEAAEDpRJpuve6613f90YjB0yevKybL8u7de4x4CMBUCGBg2Yw+AVi8 wj355DcuuOAC4x4CAADoaOfOnVu3Xq/v9CCde0ntzFJYnAYMlI4ABpanDCcAn7l5 y5NPPZV7QU4AAFDNotHo1uuu++PuXXoNOK9+tY9wGjBQOgIYWB6jTwBWFOXrX/v6 JZdeatD4AADACM/t2HHDJ27Q5RKJC+tXw2nAQOkIYGB5jD4BuKO94//++793dHQY 9xAAAEB3k5OTH/jAf52bmytlkHzpq+E0YKB0BDCwPEafAPyea99z4003NTU12Ww2 q9VqyzB0xWkAAFA6kb733XffM8/8eMUjFK5fC6cBA3pgVg0sg9EnAEuSdNMnP3nR RRe3tbYuegdRwrlhnGX0RYkBAEBhiUTi2WefvWXbzfYVHSm2ZP1aMldJDAQCnAYM lIIABpZh3bq1Ho/HuP2xfb29d971pYH+/lKOsp6Xx+xGBgBgBVKLURRFu5HOmPcl ok4/9alPjo+PL/exiqlfTSQSOXTo8HLHB5DFhBhYhk2bznA4HMaN/5d/8Zcf/vu/ N/oiw+xGBgCYjSjMRYM2V+mPIknSt775zf/4z/9Y7rYVf+dkMrl3775lbheANxHA wDIYegKwLMs33nRTgeOfy4ndyACAarZkzS6rKvUyGwy+8MLzjzz8cPGzheVuJ6cB AyViLgsUq6urs6+vz7gA7uzovOvuu9esXm30HmC95IZxbjATyQCAZclXsPruni0D SZKOHT/++c9+dsY/U+SXrCCAJyYmpqeLHR/APMxTgWIZvQLWVX961Uc/9jGn02nQ +BWRG8ZEMgDUPa1aCx9vXJF9s2WTSCQef+yxn/7sp8XceQW/FeJL/H4/62ABK8Yc FCjWhg3rXS6XQeUmy/JHP/bxyy+/vBqOfy4z7ZzkbCHnvqWTAaCCCnRs9lP1XbMr MBsM/upXv3r8sUcLHzJWyu9bLBY7cODgir8cMDkml0CxDF0By26z3Xv/AxtPP71W jn8uP2sGnQwAK5CbsvOyNvfdSm9mPZAkad/+/XfcdqusKIveofQfGYiH2LNnb4mD AKbFrBEolqErYG0+Y9Ndd9/t8XgMGt88smtcZws59wapDKDWFdOx7JWtrEgk8vnP fnb33j3zPq7XnwvrYAGlYC4IFMvQAP7QBz/0gb/6K3b/lpOI4UUjWbtBKgMwzrxD iBc9rpiOrV2SJP3bv/7rd777ndwP6vinSQADpWCGBxTF0BWwxCvlDZ+48dJLLzXh CcC1wroUghkwlXlLPRV4l4g1odlgcMeOHV//2iPaz7V1/zvAOlhAKZixAUVZv369 223UClg2q/W+Bx7kBOB6QjADVSt9Um6jLvpu9nalNxk1RjsN+PZbb1EM+wlINBo9 ePCQESMDdY8ZGFAUQ1fAevuZb7vzrrtcLpdB46MmNGTkFnK+25XeUqAysjmam6mF C7bSmwzzisVid37+879//Q8Gjc86WMCKMZECimLoCcAfuX7rn7///QYNjrrXcJKW x0XeqPRWo56l88sN10XfrfS2A7r5wfe///iTTxg0OKcBAyvGHAgoiqEBvHXr1muv fQ/HP6PiFrZ0rtw7FP5spb8PvEX2IN7c1Fzy4wVU9tsBaoIkSdu3P/3EEwQwUHWY pgBLM3QFLFmSP3nzzRdccAErYMFUss2sy9t5wy76WCv74LzeW5h/he+w6LvFvC3m DgCq1mwwuHPnzq8+9JDNbjNi/FQq5fcHRkdZBwtYNgIYWNrQ0Gler9eg/VptrW33 3HvvmtWr2QMMAEB9kCTp2PHjn7njjsBswIjx0+l0OBweHj5ixOBAfSOAgaWdfvqG pqYmgwL4z9/3vuuu32qzGfITYgAAUBGKojz1jSf/3w9+YND48Xh8//4DBg0O1DEC GFja5s2bjNs9u+3mbVdceaVBgwMAgEr5xc9//uBXHjRocBaCBlaGAAaWZuwS0Fs/ cs2113L8MwAA9UQE6o+3b3/8iccNGp91sICVIYCBJXR3d/f19Rp0iLJ49dp2y63n nnsuK2ABAFBPZoPBl19++SsPPmDQIppiCjE5OeXz+YwYHKhjBDCwBEOXgN68afMt t93W2dHBHmAAAOqJJEkzfv+D99+/a/cuI8ZPp9MzM34WggaWiwAGlrBu3TqPx23Q Clj//cN//4G//msjRgYAABX3b//yL//4zX8yaPBIJHLo0GGDBgfqFQEMLOGMMzY6 HA6DApgTgAEAqFdGnwacSCT27dtv0OBAvSKAgSUYtwKWLMsfv+ETl156KScAAwBQ f4LB4LM7djz69a8ZtJKImEjs3r3HiJGBOkYAA4V0d3f19fUZ9rql3HbHHX9y9tkE MAAA9UcE8Cu//e39937ZuKU0Jycnfb5pIwYH6hUBDBTS09PT29tj0OvWpjM2fWrb tt6eHg6BBgCg/kiSNOXz/cNXHty125DrFaVSqcnJKcGIwYF6RQADhWhLQDdk6D74 B/+b+O+D4oZBJxgDAICK+953v/vt7/yzESOzEDSwAky7gUI2bFjvcrm027pn6vXX b7325ApYNDAAAPVHkqTt259+4oknDBo/FosdOHDQoMGBusScGyhk06Yz5h2frFep ptPp667fevnll2dPAKaBAQCoM8Fg8Je/+tU3njQqgEVg79mz16DBgbrEhBsoJHcP cJYupSrL8s3bbjnvvPMIYAAA6pUI4Bd/85uHHnzAoPVEotHYwYPsAQaWgQk3UMjC PcCa0mM1nU7f8enPvP3tb89dApoGBgCgnkiStHfv3ttuvTWVThkxfjKZ3Lt3nxEj A/WK2TZQyJYtm/P9yLbEWL3qqqs/9Ld/2+L1GnSINQAAqAaKojz+2GNPb3/aoMF3 7TJkiWmgXjHVBgopEMCW0mJ1283b3n3FFboPCwAAqs0vf/GLBx58wIiRCWBguZhn A3n19vb29HRbrdYC91lxrG69fus1J5eA1nFYAABQVSRJ+vH27Y8/8bgRg6dSqamp qclJLgUMFItJNpBX9iLAS95zub0qy8rHb7jhkksuyT0BuMQxAQBAFQrOze3YsePr X3vEiHWwRAD7/QEuBQwUjxk2kNfQ0GnNzc1FhuiyelVRlNs//emz3nlWgQBe7pgA AKAKiQB+9dVX7/3yPYWPKVuZdDodDoeHh4/oPjJQr5heA3kteg2kwopMVqfDcd8D D64dGsp3CPRyBwQAANVJkqTh4eFbb70lHo/rPrgIYDHsgQNcCQkoFnNrIK/NmzfZ 7fYVfOGS1bp6cPDBrzzUWnD3b/GjAQCAahYMBm/ZdvMbx44ZMbgI7D179hoxMlCX mFgDeRVeAnpJBcL11m23XPbud+syFAAAqH6/+uUv73/gfiNGZiFoYFmYVQN5lRjA lvzhWngJ6GUNBQAAqpwkSc9s3/6YMQtBE8DAsjClBhZXzDWQijSvXdPp9NatH7n0 sssKr4C15DgAAKAmBOfmnn322ccfe9SIl/LMlZB8k5OTuo8M1CXm08Di+vpEAPfo +EKVHUqSpFtuve3cc89dbgBbaGAAAGqQCOCXX375/vvuXdnaIoURwMCyMJkGFjcw MNDZWdRFgIunjSZeqG7/9Gfe+Y53rCCALTQwAAC1RgTwa79/7ct3323QHmAuBQwU j5k0sLh169Z5PG7dhxWvfE1NTffed38x10AqMIi+WwUAAIyjXgnpyJHbbr01Fovq OGw6ndZuRKPRQ4cO6zgyUMeYRgOL27jxdKfTacTIa1avLv4aSPnQwAAA1BDdr4SU rV8hmUzu27dfr5GB+sYcGlhc6UtA53P7bbdfetllpY9DAwMAUEN2PPvsvffdq8tQ ufVrySwEvXv3Hl1GBuoeE2hgcdUfwBYaGACA2qFXAM+rXwsBDCwHs2dgET09Pb29 PbpcA2mhGz5+w59eddWKTwCehwYGAKD6SZL0s5/97Gtfe6TEcRbWr+XkQtBTU1Ml Dg6YAVNnYBF9fb3d3fpcBHgeWZZv+uSnLrzwwpUtAb0oGhgAgCoXnJv79a9//dV/ eKiU48sWrV/t41wJCSgS82ZgEUZcA0mjKMptt99x9tln6xjAFhoYAIDqJgL41Vdf /fI9d684gPPVr/Ypv98/Ojq20q0DTIRJM7CIoaHTmpubjahKq9V6+6c/c+aWLe1t bfqOTAMDAFC1JEk6cPDgrbdsk2V5uV9bIH2zdwiHI0eOHFnp1gEmwowZWMT69evc bv0vAix0dXZ96Z57Bvr7GxsbdU9WGhgAgKoVCAQ+ccMNU75lnKm7ZPpm7xaLxQ8d OrTSTQNMhOkysIgzztjocDiMGPnMzVvuvOuubF3TwAAAmEQ0Gv3C5z73+q4/Fnn/ IutXI0nS3r37VrRdgLkwVwYWYdw1kG679bZ510CigQEAMIkir4S0rPTVcCUkoEhM lIFFGBfAH/3ox66++up510CigQEAqHuSJP3kJz959NGvF7jPCtJXQwADRWKWDMxn 6EWAr9/6kQsvvNBut3vc7twMpoEBAKhjon5D4fDzzz//xOOP5bvPiuvXcuJSwIJv xSMAJsEUGZivV+RvjyEXARYvTh//2McH16xxud19vb3ZKyGJF8VINCqSdV4Vl4gG BgCg/MTLejQWc7tcua/p0zMzI8LxYw8//PCiR5mVUr+WzBzD55vmUsDAkpgfA/MZ dxHgrFSGw+Foa23rX9XX3tF5wUUX9fb1rerrm1fF4kYpVUwDAwBgEC10xY2Frbtn 9+4XXng+MOMfGx+fnZ1NSknxipzvZ+slpq9GzCsCgQCXAgaWxOQYmG9oaKi52VOR dJRl2WazuZpcXZ2d7R3tV/3ZNZ2dnYODg91dXdn7LDeMaWAAAEpRIHRHRkZmZmZ+ sn37jN8/45+Jx2KKolhttuJffHWpX22cSCQyPMylgIElMDMG5tuwYb3L5ar0Vrwp lUqJVzW73e52ubu6utrb2999xRVd3d3FhzENDADAkgqH7rTP9/Of/Wx2dtbnm4pG Y5IsWTNKeUS96lcbKh6PHzzIpYCBJTAtBubbtOkMHU/ENY4axqmUzWZ3uZo6Ozpb 21qvvOrq3t7eeWFsyXlF1/ccYwAAak6+yrWcDN3JycmfPvPMXDA47Z+JxWKKrDRY 8x69XAp969eSOY6MSwEDSyKAgfmMuwaSERbu3RWvgoqiiI87HM621pburm5Pc/OF F1/c19e3aBuXfqYxAABVRa1c8erW0LBI5U5PH89U7gvPPx8Jh6Z808HgbDIppdOp cr76616/lsxPxrkSErAkAhiYr7YCWFPkQc7q0luija02h6OxrbWtq6vT7fZcdPHF q/r7F7axhTwGAFSrE4lrsbgXe4XSKnd8bExUbjQa8U3PzKmVmxQvg8s6QdcIRqSv hgAGikEAA/PVYgBbSj7RV9tvLG7Y7fYmp7O9vb27u9vtaT7nnHOWzGMLhQwA0FW2 by15Etc3PT2SSdxXXnklGgn7fL7A7Gw8FldSinhFq9rXcePq10IAA8UhgIG3MO4i wGVg3I+0c/PY6XC2tLR0dnY0NTWd967zTzn1VPHxRQvZwj5kAMBilnx10PpW3Hjj 6NHfvPRiPB73+/3BYDCRTMqyLF6WbHZ7uTe6NDqmb77RxAenpnxTU1M6PhBQfwhg 4C0GBgY6OtprNIA1FTmySzu4Wjy2mMc4HI4Wb4v4bWxu9l58ycU9vX2W/IVsYU8y ANSRIp/Ss307NTnx/HPPh8OhQCAwNzcXT4i+lUTJVfxAZR2VIX2zn+JSwMCS6uSZ BdDL2rVDHk9lLgKsu6r6LsSrcmbZajGnEf9ZnU6n19vS3t7W7Gm+8KKLVg0MaHcr 0MkWUhkAKqT4p99s2Qrjo6O/fuGFcCQcCMyGQnOJREJRf1qaEq9PNlsN/6B5WcpW v9pno9EolwIGCqui+TFQDTZsWN/U1FRV6Vii2vpeTizTpV5xosFuszudjuZmb1tr q7fF6232vvOss3pXrdLuWTiVLdQyABS0rCfJ3KydHB9/7Xe/C4VF0oZmg8FwOJRI JGVFTqsXrVeXmFr0KCp9O7AmlDN9T97HkkhwKWBgCbU0MwbKoFYuArxctZXBxVAU JZ3K7EawiumWvdHh8LhdXq/X4/E0i2hu9m7esqXIHcua3LmghWYGUFNW8Aw2b1ft 7l27RNOGw+FIJBIKhSLRmJRMKoqsiGfadLpBfaZd4bJSJkxfSyXqVyP+Juzbt1/H hwbqT73NiYESbd68yV5r62oUr/4yuEipDEvaou5atlrtajA3etwilcUsURBvXWec sem0tWuzX1JMM2soZwB6WfHzSW7NCkcOH967d080GotGxXhRtWqjESkpyYqsnY0i JoDWDP2/hxykb/lHUxRlz569Om4AUH9MOhsG8qnRayAti2kzeFlOLHwtZh4NajM3 qGes2cVM1O1qcrncLleT+L/Lrb43tHbtho0bs19YfDlnzZvyWqhooAbp8g95Xsce 2Ldv+PDhWDwmQjYaEzK3YnHxWIoia2sraE9TtipbMsqc6Wsx+CpHxSCAgSVV0XMl UA3MEMAWGthI6YzsrDTDarM22Oz2RrtdrWaX2+F0NAnOJrfbLX7tHxw8Y9Om3EFW UNGahVNwDUUNzKP7P5Z57Srs3bNnbGQkHo+Leo0nxK/xZCIZjaklK8myIv6XOWlW 7Zycn7XVwfOzOeu3sjt+swhgYEk1/yQL6MskAaypg2lWvXpLRavzYvEnJSbH6vzY liHiWQS0Q5S0o9HpbHI6xS2n0NPXe9Z/OXvhgCsu6nnyNYOFxoauyvA3bWGvan73 6m+nJiYTQlL7fzyZlJJJ0a8J8Z+SkTmpIq3+S828rad2LRHpW9kBxdelUgQwsASz P1MDuXp6enp7e2r6IsDLxXTNJE4WdWaynqH90atzdmumrG3qWmJaUtvt6jnSjepb R+a6zipR1+Kt1+s9+5xzFn0IvRobsOSvU+G3r7wSCoWSyUyeZkiSWqiSLKvnuMqy +Ggis3pTSsmc7aq2qvrXPicqGk7mKk+AeqJ+Kzha9uvEM73P55ua8um2TUDd4akf eFOvyN+eblMFsIZZIEqXzlHpbUENa8hR6W3BMpjzH3611W/mdmp6enpyckqfbQLq Ea8uwJsGBgY6OtpNGMAWGhgAsCKkb2UHzPm6E0c6BAKzY2Nj+mwWUI+Y8gJvWrdu rdvttpi4Bk37jQMAVoD6reCAb/2iN9+JRmPDw8OlbhNQv5jsAm/auPF0h8Oh3TZt Cpr2GwcAFM+c6Wup+voVksnkgQMHS9omoK4x0wXetGXL5tzjn82cgmb+3gEAhVG/ lR2tQP0KqVSKhaCBApjjAm+aF8AaM6egmb93AMBCpG/FB5x30u9CBDBQGLNb4ITe 3p7u7h6rdfF/FGZOQTN/7wAAi4m711JT6atJpdLT01wJCciLeS1wgnYNpMKxZ+YU NPP3DgCmRfpWw4CFj3le+Cg+3/TUFFdCAhbHjBZ4k2hgu93W1NRkt9sbGxvzXQ/J zClo5u8dAEyF9K2SAYvZ8ZtKpSRJVhQ5Ho/LskL9AgUwlwUK6enpEcknelhUcWOj WsXZAjR5Cpr82weAOkb6VsmAi+74FQNKInZl0boJ8Tazv5ejnYFlYAoLLJuoYqu1 wWYTVexszMi3r7jukcEAUDfM3L0WY779Eo95TqdT2dZVFDmVonUBHTB5BfSRW8Xa EdQ2m63SG1UmZDAA1DSTp6+lCnb8Zo5hVls3kVD369K6gHGYtgLGypxXbHc6Hdkq rtdcrNfvCwDqGOlb/h2/sqzIstq6yWRSvJ2c5HxdoKyYsAIV0NvbI/712e02l8s9 79TiWlc33wgA1DfS12Lwjl9xW86IRmOKIovPsDYVUA2YqgLVoqen22q12u12h0Pd XaypxZ6sxW0GAFOhfnX8HciGriwryeSJham4DC9QtZinAtUu9+xi8baxUQ3jSm/U 0shgAKhCpK9lpb8J4qsURdFKN3OmrpIJXXbqAjWGGSpQq7Qw1vYY20QZZ1TVetQ0 MABUFeq3mN+BVCqdOUdX1K62R1eEboo9ukDdYHoK1KFsGzudzmwbVypHyWAAqAbU 76In6IrKZXcuYCpMTAFzyR5QnWlja3n2G9PAAFBB5kxf8V2nUiktcTOVmzx5di6V C5gas1IAJ2ircIkb2vnGVqvNblf3H4tO1mV8MhgAyqy+0/etiZtKJBLaYsscsQyg AOajAIqSzWPtrGORxyKMteOrl1u2lDAAGK0+0lc7UFnbhStaV9uLm/k4iQtghZiG AtBHbiE3NjpEHlszlaxZ9EsoYQDQVw11r7b/VlGyeZuSpKQk0bcAjMXsE0D5ZCPZ 8uaB1m9GclUtYQ0ANaTauvdk2aq/iv/H4+rBydlPEbcAKogABlB1cjtZW8u6ocGq 7VLWgplUBgBNOdNXuxCuFreplLr/NnOVIMoWQC0hgAHUsO5uNZW1I6nFJFDUsrZX eR6OtQZQZ/Tq3lRGNmgz59mqTZt9XhUf8fnIWgD1g0khABMRwZy7qHVmQS8RzA1a JNPMAKpfgfRNvYV2jm06mUxIkpx9ShOpS9ACMDNmeACwhHnZnN3V3NCgVXNDtpm1 GxXcVAC1LjdeszfF/+PxN3fMakhZAFgBAhgADNTT0y26ODtnFfEsbmuXksr2c0PO LfY/A7UrW60n9r1mZAs2mVQv4aM9CZy8P8sdA0C5MccCgBqQe7Zzlpg9NzaqLZ25 pJRW0Q25slFNUQMLZTM1G6s5yZrOHGmsVmvu8cMnv5AzYwGgVjElAgCTykR1w8Lr MWdPMMwswe3IfFoLaktDfhz7DX3Ni9IFtFNh1VuJRDK7EPFif5nVoCVWAQAaAhgA gJXr6uo0dPzp6RlDxwcAwFQIYAAAAACAKRDAAAAAAABTIIABAAAAAKZAAAMAAAAA TIEABgAAAACYAgEMAAAAADAFAhgAAAAAYAoEMAAAAADAFAhgAAAAAIApEMAAAAAA AFMggAEAAAAApkAAAwAAAABMgQAGAAAAAJgCAQwAAAAAMAUCGAAAAABgCgQwAAAA AMAUCGAAAAAAgCkQwAAAAAAAUyCAAQAAAACmQAADAAAAAEyBAAYAAAAAmAIBDAAA AAAwBQIYAAAAAGAKBDAAAAAAwBQIYAAAAACAKRDAAAAAAABTIIABAAAAAKZAAAMA AAAATIEABgAAAACYAgEMAAAAADAFAhgAAAAAYAoEMAAAAADAFAhgAAAAAIApEMAA AAAAAFMggAEAAAAApkAAAwAAAABMgQAGAAAAAJgCAQwAAAAAMAUCGAAAAABgCgQw AAAAAMAUCGAAAAAAgCkQwAAAAAAAUyCAAQAAAACmQAADAAAAAEyBAAYAAAAAmAIB DAAAAAAwBQIYAAAAAGAKBDAAAAAAwBQIYAAAAACAKRDAAAAAAABTIIABAAAAAKZA AAMAAAAATIEABgAAAACYAgEMAAAAADAFAhgAAAAAYAoEMAAAAADAFAhgAAAAAIAp EMAAAAAAAFMggAEAAAAApkAAAwAAAABMgQAGAAAAAJgCAQwAAAAAMAUCGAAAAABg CgQwAAAAAMAUCGAAAAAAgCkQwAAAAAAAUyCAAQAAAACmQAADAAAAAEyBAAYAAAAA mAIBDAAAAAAwBQIYAAAAAGAKBDAAAAAAwBQIYAAAAACAKRDAAAAAAABTIIABAAAA AKZAAAMAAAAATIEABgAAAACYAgEMAAAAADAFAhgAAAAAYAoEMAAAAADAFAhgAAAA AIApEMAAAAAAAFMggAEAAAAApkAAAwAAAABMgQAGAAAAAJgCAQwAAAAAMAUCGAAA AABgCgQwAAAAAMAUCGAAAAAAgCkQwAAAAAAAUyCAAQAAAACmQAADAAAAAEyBAAYA AAAAmAIBDAAAAAAwBQIYAAAAAGAKBDAAAAAAwBQIYAAAAACAKRDAAAAAAABTIIAB AAAAAKZAAAMAAAAATIEABgAAAACYAgEMAAAAADAFAhgAAAAAYAoEMAAAAADAFAhg AAAAAIApEMAAAAAAAFMggAEAAAAApkAAAwAAAABMgQAGAAAAAJgCAQwAAAAAMAUC GAAAAABgCgQwAAAAAMAUCGAAAAAAgCkQwAAAAAAAUyCAAQAAAACmQAADAAAAAEyB AAYAAAAAmAIBDAAAAAAwBQIYAAAAAGAKBDAAAAAAwBQIYAAAAACAKRDAAAAAAABT IIABAAAAAKZAAAMAAAAATIEABgAAAACYAgEMAAAAADAFAhgAAAAAYAr/H3kHyEQ3 PuMGAAAAAElFTkSuQmCC"/></symbol><use xlink:href="#c" width="1280" height="1280"/></g></g></svg>')} -.is2d .bishop.white {background-image:url('data:image/svg+xml;base64,<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="614.635" height="614.635" viewBox="0 0 460.977 460.977"><mask id="b"><use xlink:href="#a" width="1280" height="1280" transform="rotate(.193) scale(.36014)"/></mask><symbol id="a" viewBox="0 0 1280 1280"><image width="1280" height="1280" xlink:href="data:image/png;base64, iVBORw0KGgoAAAANSUhEUgAABQAAAAUACAAAAAA9j6ArAAAACXBIWXMAAA7EAAAO xAGVKw4bAABGKUlEQVR4nO3dBZhVdcLHcQYpqVXXBVQ6RECwQERBFywwQEnFQrFY WUXsIk0MbF2xFSwMsMDAVxBEAaWlawABW0JC4EVCJu7M3HvuOef3j+/n3ed5d12Y +T5X72+Ze8/9n4xCAOCpDHUAAKgwgAC8xQAC8BYDCMBbDCAAbzGAALzFAALwFgMI wFsMIABvMYAAvMUAAvAWAwjAWwwgAG8xgAC8xQAC8BYDCMBbDCAAbzGAALzFAALw FgMIwFsMIABvMYAAvMUAAvAWAwjAWwwgAG8xgAC8xQAC8BYDCMBbDCAAbzGAALzF AALwFgMIwFsMIABvMYAAvMUAAvAWAwjAWwwgAG8xgAC8xQAC8BYDCMBbDCAAbzGA ALzFAALwFgMIwFsMIABvMYAAvMUAAvAWAwjAWwwgAG8xgAC8xQAC8BYDCMBbDCAA bzGAALzFAALwFgMIwFsMIABvMYAAvMUAAvAWAwjAWwwgAG8xgAC8xQAC8BYDCMBb DCAAbzGAALzFAALwFgMIwFsMIABvMYAAvMUAAvAWAwjAWwwgAG8xgAC8xQAC8BYD CMBbDCAAbzGAALzFAALwFgMIwFsMIABvMYAAvMUAIkZFS1Uoue++R+X8p27r+B9/ XLdi7SZJE3zGACIee5cvW7Vxub0q7Xlgwv96zh+Zv676atHvK3+JuQteYwARuZLl Kx22X51qe1cs8Fcu/WXhd99/m7lyXQxVAAOIiJXYp3Kzg+s2TOn3TJw5fcySn9dH VATsxgAiOv+o0OSoek0D/dYvZoz/csVvIfcAOTCAiEjZA4496ZAaaXyB+VM+Gr3s 99B6gNwYQESh1D9PatU2hK/z1ocf/bQ2hK8DJMQAInRF9zny7GMqh/TFlox95euf uUAG0WAAEbLi/7r43HR+8s1t/stP/7Ah1K8I7MAAIkwZe1S7t00EX3fYdQs3b43g 68JzDCDCk7HH2f85KqKvPf7xV5hAhI0BRGhKX3NBtQi//MIX7l8T4ZeHjxhAhKTY 3Z3LR/wtVg65cWPE3wJ+YQARjisejeXbdH8slm8DTzCACMM5vRKfcRC+Of0Gx/Sd 4AEGEOk75qm6MX63mZeOjfG7wWkMINJV8d6zYv6Or163NObvCEcxgEhT7z6Cb9qn r+Cbwj0MINLS6Ll6ku8748IJku8LtzCASEOp/pFf+pKXlUNu45QEpIsBRHDNntD8 8W+HGd3GCL87nMAAIqjid3TeTxrw/ZBbOCMBaWEAEVDDh5uoEwp9eeVEdQKsxgAi mEtuq6RO2Caz/yB1AmzGACKIfW/poU7Y6cE7flQnwF4MIAJo+EAzdcLfxvTkx2AE xQAiZXucfndtdUMWs298d7O6AZZiAJGqPbveUkHdkM2KO575Q90AOzGASNHeV/ZR J+TS5+Ff1AmwEgOI1NR94GR1QgIje85UJ8BGDCBSUuOtBuqEhKa2na9OgIUYQKSi wRDlh9/yM6PzVHUC7MMAIgVNXz1AnZCnZWd9oU6AdRhAJO/oN/ZXJ+RjeYdx6gTY hgFE0hoPU519lZyVbb5SJ8AyDCCS1dD8I0gb8aEQpIQBRJKOsGFcGk5SF8AqDCCS c9g36oKkHP6tugA2YQCRlMqL1QVJqrJEXQCLMIBIRulpVdUJSVpUf406AfZgAJGE kpNrqROSNvfQdeoEWIMBRBLeOlNdkIK326oLYA0GEAXKeOZCdUJKnuu6VZ0ASzCA KEjGeS+oE1J0wUssIJLCAKIgVlwAmB2XAyI5DCAKUH6FuiCACivVBbACA4j8lf3a pPt/JGv2kb+rE2ADBhD52vPF9uqEQIaez21CUDAGEPkp3GmIOiGgzq9tUSfAfAwg 8tNouFk3gEveitbmH14DOQYQ+aj43iHqhMCmnLZUnQDjMYDIW9GHuqkT0vDEVZvU CTAdA4i8tR6mLkhLm+HqApiOAUSear9zkDohLbPOmK1OgOEYQOSl+NPnqhPS9PLF G9QJMBsDiLyc8ba6IG1nvqMugNkYQORh/9eaqhPS9kWn5eoEGI0BRB5u7a8uCMFt t6sLYDQGEIk1fbGaOiEEC8//Qp0AkzGASKjYsJbqhFCMaLNRnQCDMYBI6ILn1QUh 6WLbaa6IEwOIRMqMaqhOCMnEFqvVCTAXA4hErhugLgjN9feqC2AuBhAJVP2gjjoh NN+dskidAGMxgEjg3mvVBSG67zp1AYzFACK3yh/ZeAx+XmaftESdAFMxgMjtgavV BaEa2FNdAFMxgMil4qha6oRQzW3B0ahIjAFELgN7qAtC9qBbf6JFeBhA5LT/mOrq hJAtaMaZCEiIAURON9ytLgjdjfeoC2AmBhA5ZMx26xXAv8ytvVWdACMxgMjhsifV BRG4/H/qAhiJAUQOU+urCyIwrYG6AEZiAJFdvenqgkgcPENdABMxgMju6a7qgkg8 c7G6ACZiAJFNifn7qxMisbzGenUCDMQAIpvuj6gLIvLfR9UFMBADiGxm1FUXRGRm PXUBDMQAIqtyK9UFkSm/Sl0A8zCAyOq2fuqCyPRy4TafCBkDiKwWuHAvzMQWuvYJ Z4SAAUQWVReqCyJUbZG6AMZhAJFFn97qggj17aMugHEYQGQxy6Wj8HOafZC6AMZh ALHbP35VF0Rqr9/UBTANA4jdOg9WF0TqnCHqApiGAcRub7RXF0RqaAd1AUzDAOJv RTapCyJW9E91AQzDAGKXjOM+UydErPnnHAyNbBhA7FL40W7qhIg90X2LOgFmYQCx yx5fNlInRGxCk83qBJiFAcQuxd0/Ma/EBnUBzMIAYpdjvlAXRK7pWHUBzMIAYqci 91+pTojcw9fwPjCyYgCxU/H3TlAnRO6T0/gZGFkxgNip9LSq6oTILaq/Rp0AozCA 2Kn8CnVBDCq4e+I1gmAAsUPG6cPUCTFo8y6XQiMLBhA7FLnV5bMAd+l7O++CIAsG EDuUGNxWnRCDt85x/2JHpIABxA5lv/LhvNBZjX9XJ8AkDCB22GvG/uqEGCyv5/aZ r0gRA4gdvHgTmLeBkR0DiB2aj1IXxKKF60d+ISUMILYr3PUpdUIsLn2GE7GwGwOI 7Yre3EedEIs+d7p+7DVSwQBiu5KDOqsTYjHkknXqBBiEAcR2ZV5vqU6IxYiOq9UJ MAgDiO32/uRwdUIsvjnhF3UCDMIAYrtykyqqE2Kx9IhV6gQYhAHEdv+aUEWdEIvF jX5QJ8AgDCC2q7xYXRCTKkvUBTAIA4jtGn2tLojJkRPUBTAIA4jtmoxTF8Tk6C/V BTAIA4jtGED4iAHEdgwgfMQAYjsGED5iALEdAwgfMYDYjgGEjxhAbMcAwkcMILZj AOEjBhDbMYDwEQOI7RhA+IgBxHZ8FA4+YgCxHYchwEcMILbjOCz4iAHEdhyICh8x gNhu748aqhNiMfEkjsTHbgwgtivz6inqhFh8cBY3RcJuDCC2K/nkeeqEWLx0ObfF xG4MILYret0d6oRY3HIvN0bHbgwgtit84dPqhFhc/NwWdQIMwgBih6Zj1AWxaPaF ugAmYQCxQ7mV6oJYlOcqGGTBAGKHvab5cCHg0vq/qhNgEgYQO5QZd7A6IQbTj+Yq GGTBAGKH4s+fpU6IwatdNqgTYBIGEDvscf2d6oQY3DxgszoBJmEAsUPGSSPUCTFo +dFWdQJMwgBip9I+vDpWZo26AEZhALHTnhPqqRMiN6PRH+oEGIUBxE7F326lTojc h2fyHgiyYgCx0x79blYnRO7OXrwHgqwYQOzSYIq6IHKHTFUXwCwMIHYpulFdELli HAWDbBhA7LLHqGPVCREb3YKfgJENA4hdCt9+kzohYnfdyllYyIYBxC4ZlVy/NWaV TC6DRjYMIHZzfR74px058I8Ednu6q7ogUs9crC6AaRhA7Hay2x8HbjlSXQDTMIDY rfh6dUGkSvAxEOTAACKLD1uqCyI0wv2P+iFVDCCyOPcldUGEzntZXQDjMIDI4p8/ qgsitO9P6gIYhwFEVp+2UBdEZtTx6gKYhwFEVu2Gqgsi0/5NdQHMwwAiq5Jr1QWR KbVOXQDzMIDI5s226oKIvNVOXQADMYDIpvkodUFEWnymLoCBGEBkN7emuiAS82qp C2AiBhDZ9eqrLohE737qApiIAUR25ScdoE6IwLIjVqoTYCIGEDkM7qwuiMCQc9QF MBIDiBwaj1cXROCor9QFMBIDiJyGtVYXhG54G3UBzMQAIqdT3lcXhO7UD9QFMBMD iJxKj22gTgjZ1GPWqBNgJgYQuVzxqLogZN0fUxfAUAwgcik1+nB1Qqi+OdbdTzgj PQwgcuv2uLogVP95Ql0AUzGAyK30qEbqhBBNaMErgMgDA4gELnlKXRCiSwepC2As BhAJlHnqLHVCaF69dLU6AcZiAJFIsyEV1QkhWdp5jDoB5mIAkUjhh7qrE0Ly6FVb 1AkwFwOIhOq/VkedEIrvOk1TJ8BgDCAS63m/uiAU1zygLoDJGEAkVm5oM3VCCMa0 X6VOgMkYQOShrQu3kWz3lroARmMAkYc9b+itTkhb33v+UCfAaAwg8lJ96GHqhDR9 236BOgFmYwCRpw6vqwvS1PENdQEMxwAiT6V6Xa9OSMuAfpwCg/wxgMhbpaFHqhPS 8HX7THUCTMcAIh8tPlUXpOH4UeoCGI8BRD6KXTVAnRDY9Q9tVCfAeAwg8vOPN05U JwT0cYff1AkwHwOIfNV9t7o6IZAFp89UJ8ACDCDyd/IIdUEgLUeqC2ADBhAFsPIe cdwHDklhAFGQ1zqqC1L2eid1AezAAKIgpf/vCHVCiib9m9sgISkMIApU/XO7zsdf ehwfAUZyGEAU7MSXyqsTUrDyvI/VCbAFA4gktLfpVIEOQ9UFsAYDiGRc9Iy6IGld n1UXwB4MIJLyH1uuK7nicXUBLMIAIjm9+6gLktKnr7oANmEAkZxiN9owLb3v5gQE pIABRJKKD2mrTijQW503qBNgFQYQyXrxPHVBgV46X10AuzCASNb3FdQFBVqxn7oA dmEAkZwu/SqpE5KQ2et5dQJswgAiGQe/Wk+dkKQZZ01XJ8AeDCAKts9Lp6gTUvDB eT+rE2ALBhAFKfzIf9QJKXr8v1vUCbADA4gCdLt1f3VCypbf/oQ6AVZgAJGv2kMP VicEMr39bHUCLMAAIh9lX2qtTghs+Hm/qxNgPAYQecq4/2p1QloGXrNVnQDDMYDI S8M3qqoT0rSow0R1AszGACKxsq/YdOlLXj44m5+DkQ8GEAn1u01dEJL+vdQFMBgD iARqvHeQOiE0s06br06AsRhA5FJ40EXqhFA9ewnXRSMxBhA5NXrThmMPUpHZboI6 AWZiAJFdsVfMP/c0dW+dzUnRSIABRDbHDDX/1L8gVrQfq06AgRhAZOHmH/924A+B yI0BxG6N33Hzj387rDjjK3UCTMMAYpfCL5yrTojYyxfwdjCyYQCxU82PqqkTIrfw pHnqBBiFAcQO91yvLojFgBvUBTAJA4i/lPnsCHVCTCY1X61OgDkYQGzT6Gt1QYyO 5Kpo7MIAolChJy5XF8TqyW7qApiCAUTZMQ3UCTGb2oxDsrAdA+i9BiNdvvgvsRUn T1UnwAgMoO9uvkNdIHHLneoCmIAB9FvhD09SJ4h81IqLosEA+q3sl3XVCTIzm/BC IBhAn1UfY989z8OzvNkCdQLUGECPHfu5ukDsuNHqAogxgP66/RZ1gdwdt6oLoMUA euv1DuoCA7zRUV0AKQbQUxmftFAnGGHUCVvVCRBiAP1U9EtfDj8oyKQmm9QJ0GEA vVR6Ym11gjFmN1yjToAMA+ijspPdP/s0eQsP5YJAbzGAHtpnUlV1glEWHfGzOgEi DKB/9v3GtRufpyvz8B/VCdBgAL2z7+QD1AnGWXYoC+gnBtA3+0ypqE4w0NJD+CnY SwygZ0pPq6pOMNKi+rwX7CMG0C/FpnL9S2KzG2xUJyB+DKBXinxTX51grGmH/6lO QOwYQK+Mb6wuMNhXR6kLEDsG0Cdvn6EuMNo7Z6oLEDcG0CN9e6kLDNevt7oAMWMA /dF8lLrAeC0+UxcgXgygN2rOVRdYoNY8dQFixQD6ovg8LoAu2NKaG9QJiBMD6Itx TdQFVvjyaHUB4sQAeuK+a9QFlrj/WnUBYsQA+qHhBHWBNRpNVBcgPgygF8pw5Gfy yq5WFyA2DKAX+ARICvhEiEcYQB/cdKe6wCo336UuQFwYQA/s+4O6wDL/4nhUXzCA HpjILTBTM6mhugAxYQDdd9WD6gLr9HhIXYB4MIDOK75eXWChEnwgxA8MoPNe7aQu sNBrZ6kLEAsG0HWVF6sLrFRliboAcWAAXff5seoCK40+Tl2AODCAjjtksrrAUodO URcgBgyg4yYfoi6w1JRD1QWIAQPotpNHqAus1XKkugDRYwDd9n+8lBXU5/9WFyB6 DKDTKvFeZnCVM9UFiBwD6LTXOqoLLPY6F1C6jwF0WeHN6gKr7bFFXYCoMYAuu/Ze dYHVrrtPXYCoMYAu++IYdYHVxjZVFyBqDKDDSq5VF1iu1Dp1ASLGADqMg6DTxNHQ zmMAHfbRieoCy318kroAEWMAHbaynLrAcqvKqwsQMQbQXbVnqQusd9BsdQGixQC6 i5cA08aLgK5jAN31Zlt1gfW6PqsuQLQYQHd93UhdYD0uhXYdA+iuBdXUBdZ75mJ1 AaLFALprqzrAft9wR2XHMYDOKrpRXWC/7+qqCxAtBtBZnAWYvjm11QWIFgPorEZf qwvsN6/On+oERIoBdBYDmD4G0HUMoLPqTVcX2G/ugeoCRIsBdFaVReoC+/EaoOsY QGdlcKB72qbXVxcgWgygu7gOMG1fNFMXIFoMoLtm1lEXWO+RK9UFiBYD6C7OQ03b hc+rCxAtBtBdd9+gLrBew0nqAkSLAXTXMV+oC2w3vy4fJ3QcA+gw3gVJE/fFdB4D 6LD3T1EXWK77Y+oCRIwBdFiX59QFdlvSZLk6ARFjAB3GpdDpGXOsugBRYwBd9r9L 1QVWazNcXYCoMYAuK71aXWCzyYepCxA5BtBpr5ylLrDYeS+rCxA5BtBppdaoC+w1 vom6ANFjAN3W/1Z1gbWajlUXIHoMoONmcFufYO69Xl2AGDCAjiu/Ql1gJ26I6QcG 0HWth6kLbLT8pBnqBMSBAXTek5epCyzEJYCeYADd98nx6gLrXPG4ugDxYADdlzHu KHWCZW68R12AmDCAPvi0hbrAKhwC4w8G0Atvn6EusMg5Q9QFiA0D6IfrBqgLbLGk Lcfge4QB9ETtTyqqE6ww5rTf1QmIEQPoi6LPd1YnWKDLC+oCxIoB9Mfhb1RXJxju s3M5AtozDKBPbupRTp1gsKndxqkTEDcG0CtFB/RQJ5hq5k18+MNDDKBnCve5oLK6 wUATbxilToACA+if1t1PVCcY5uVeC9UJ0GAAfVT8htMaqRuM8cng59UJkGEAPVX2 mubN1A0GeP/dZzepGyDEAPqrcKdTDqmvjhD6asI7n6obIMYA+q1Ih+MPbqyOiF/m vMnvM35gALFNldOPPLyeOiI2Y2aMe5ub5WEHBhB/eeJydUFsWo1QF8AcDCD+MvkQ dUFsnuymLoA5GEBsU3KtuiA+82uqC2AOBhCFPDsusP50dQGMwQBim49PUBfEqHc/ dQGMwQBim63qgDhN9ef1ThSEAYR3N0//14/qApiCAUShQq+cpS6I1VmvqQtgCgYQ hQot9uuErFe4OQB2YgBRqNYcdUG8llZSF8AUDCAK3d9TXRCz40arC2AIBhCFvvbt cMCBvi0+8sIAouhGdUHc5tRWF8AQDCCueFRdELsD56oLYAYGEO+foi6I3WVPqQtg BgYQK/27WfB7p6sLYAYG0HtNx6gLBEqtUxfACAyg9569UF0g0PpddQGMwAB6b9rB 6gKBpy9RF8AIDKDvyv6mLlBYWF1dACMwgL7r20tdINFooroAJmAAfTfaz/uj33Gr ugAmYAA9V3izukBjho+vfCIXBtBz57+gLhCptFRdAAMwgJ776ER1gciVj6gLYAAG 0G/dHlcXyNScry6AHgPoN0/fAvlLfz/f/kY2DKDXMraoC3Sm11cXQI8B9FrnweoC oQOWqwsgxwB6bbjPp6L0HKgugBwD6DWvboie00Tf7gSA3BhAn53m95ko//xZXQA1 BtBnb7RXF0h1fkVdADUG0GfL9lcXSL3p9/6jEAPoteaj1AVay2uvUSdAjAH02JCz 1QViHYaqCyDGAHps6QHqArHXO6kLIMYA+uuYL9QFaksP/EOdAC0G0F+DO6sL5Nq9 pS6AFgPor8yK6gK5V31/FdR7DKC3moxTF+gtrblBnQApBtBbL56nLjDAGcPUBZBi AL21pJK6wABDzlEXQIoB9FXDCeoCEyypuUmdACUG0FfPX6AuMEJrv8+D8B4D6Ct+ At6On4H9xgB6qukYdYEZuBbabwygp7z/HPAu7d9UF0CIAfTU8v3UBYYY2kFdACEG 0E8nj1AXmGJZvd/UCdBhAP30Zlt1gTHOGaIugA4D6Cev74aU3bAz1AXQYQC91P4N dYE5lh/6gzoBMgygl7y+H3BOVz2sLoAMA+ijjC3qApNMaqgugAwD6KOLB6kLjFJl iboAKgygj0Y1VxcYpVd/dQFUGEAPFV+vLjDLzHrqAqgwgB7q01tdYJjDv1UXQIQB 9NCkw9UFhhnYU10AEQbQP+VWqgtMM7+mugAiDKB/nrhcXWCcEz9RF0CDAfTPoirq AuO80EVdAA0G0Dv//kxdYJ4lddapEyDBAHrnjfbqAgNdyqXhfmIAfcPH4BKZcKS6 ABIMoG8ue1JdYKRqi9QFUGAAfTO6mbrASH37qAugwAB6piwHwCc0+yB1ARQYQM88 dKW6wFDHjVYXQIAB9MzCquoCQz3bVV0AAQbQLy0+VReYakndteoExI8B9Muw1uoC Y3V/TF2A+DGAXim8WV1grm+OUBcgfgygV64boC4wWJ1Z6gLEjgH0yteN1AUGG3CD ugCxYwB9UuF7dYHJ5h6oLkDsGECfvHSuusBo5w5WFyBuDKBHOAchf+ObqAsQNwbQ Iz0GqgsMd+BcdQFixgB6ZEJDdYHh7r1eXYCYMYD+qLxYXWC6+bW2qhMQLwbQH691 VBcYr+uz6gLEiwH0Bp8CKRgHQ/uGAfTGDXerCyxQb6a6ALFiAL3xHUd+FmxgT3UB YsUA+qLhBHWBDRbU/lOdgDgxgL54p426wApXPK4uQJwYQE+U5LjPpEw5VF2AODGA nnjganWBJY4Zpy5AjBhAT2RWVBdY4oUu6gLEiAH0Q5fn1AW2WNp4uToB8WEA/fDl UeoCa/TvpS5AfBhAL1RZpC6wx9yDODXMHwygF7gZXAq4EsYjDKAPSq1RF9iEK2E8 wgD64NEr1AVWOW60ugBxYQA9kLG8gjrBKq90VhcgLgygB669V11gl+XN56gTEBMG 0ANza6oLLPPof9UFiAkD6L62b6oLbLP48J/VCYgHA+i+L45RF1indz91AeLBADqP i6BTx8XQvmAAnffeqeoCC3V/TF2AWDCArtvnJ3WBjabXVxcgFgyg6wZzUVsQ5w5W FyAODKDjOAk6mEkN1QWIAwPouMf+oy6wFJ+H8wID6Dbuhh7UghrqAsSAAXTb7beo C6z1bFd1AaLHADotY+n+6gR78dzwAH+TnXbTneoCiz3ZTV2AyDGATltSSV1gM54c 7uPvscuuelBdYLVHrlQXIGoMoMvmV1cX2I1nh/P4W+ywy55UF1juoR7qAkSMAXTY PC5lSxNPD9fxd9hdFw9SF1jvgWvUBYgWA+iuObXUBfbj+eE4/gY7q+vT6gIH8EdA xzGAzuJWSGHgCeI2/v66qtvj6gIncC2g2xhAVy2sqi5wA88Qp/G311E971cXOOLV s9UFiBAD6Cg+BRyWwlvVBYgOA+imm+9QFzjj28PVBYgOA+ikwssqqBPccfAMdQEi wwA6aUoDdYFDVuynLkBkGEAX1ZuuLnDKLRwr6ywG0EV8CC5U68v/rk5ARBhABzUZ py5wzJdHqwsQEQbQQVwDHbYLn1cXIBoMoHtOHqEucM7KyhvVCYgEA+ieZdwKM3RD O6gLEAkG0DmcgxqBzY2+VScgCgygc/jkVhQWV9+iTkAEGEDX9O6jLnDToEvVBYgA A+iYDP6gEo319RaoExA+BtAxz1ykLnDVrDrqAoSPAXRLqTXqAnfdeYu6AKFjAN3y YUt1gbtW11ylTkDYGECnVFqiLnDZpIbqAoSNAXTKjLrqAqdd/j91AULGALqk06vq ApdtHtZ5g7oBIWMAHZKxnHOgo5PZdqI6AaFjAB1yz/XqAnetH3wpV1g6iAF0RxmO 7YzMrNPmqxMQBQbQHcNaqwtctfrRm9UJiAYD6Iy63LwsIpNO4QJAVzGAzphVW13g pp/6P6ROQGQYQFfcxK3LorB5xFl8utBhDKAj+BBwJJZ1GqtOQJQYQEcMbacucNDG 1y/8U92ASDGAbqgzU13goDlnfKdOQMQYQDd8d5C6wDmrH79RnYDIMYBO6NVXXeCc Cadx7YsHGEAXlP1NXeCaVX2eUCcgDgygC0Y3Uxe45c/h561TNyAWDKADOAUrXPPb TVEnICYMoP0KLzlAneCS1U9yqI4/GED7cSO4MI0//Ud1AuLDAFqvxjx1gUO+v/l5 dQLixABaj0MQQrPh1Us2qRsQKwbQdnfepC5wxtTTuamebxhAy5VbqS5wxZreD6gT EDsG0HJTGqgL3LDlgzM598BDDKDdegxUF7ghsyk//XqJAbQan4ELxR/971InQIMB tNq3h6oLXDD2WO546SsG0GZXPagucMDyVlPVCZBhAC1WerW6wH7rB/RWJ0CIAbTY jLrqAutNOJr3fr3GANqLU1DTNeP8b9QJ0GIArcU7wOm67XZ1AdQYQGstqaQusNvI jr+rEyDHANqq2+PqAqstO+sLdQIMwABaaq9f1AVWe+Fi3vxAIQbQWuMbqwssNvv0 ueoEmIEBtNO196oLLHYPN/zFTgyglTgEK7iJp3LDX+zCAFqJQ7AC6/6YugAGYQBt NOA6dYGthp2zVp0AkzCAFqrJS/jBZLadqE6AWRhA+xSeV02dYKdBl3PsFbJjAO3z 4nnqAivNPG2hOgHGYQCt03i8usBK/Tj2CrkxgLYpNb+8OsFCX536kzoBJmIAbTOu ibrAQv95Ql0AMzGAlrnpTnWBfYZ35toXJMYA2qXyYnWBdZa2/0qdAGMxgFbJmF1L nWCbF7ty7gvyxABa5bku6gLLzG89U50AkzGANjl6rLrAMo/9d6s6AUZjAC3CXUBS 810rXjFF/hhAi0w6XF1gFY79Q4EYQHvcd426wCZTWq5QJ8B8DKA1Dp6mLrDJvder C2ADBtAWxecfoE6wSGZldQGswADaYnQzdYFNRh2vLoAVGEBL3HyHusAqL52vLoAV GEA7VJ+vLrDLnbeoC2AFBtAKReZWVSfYhVsfISkMoBU+OlFdYJmOb6gLYAUG0AZX PagusM3xo9QFsAIDaIFKS9QF1mn2hboAVmAAzVd4Tg11gnXaDFcXwAoMoPk+aKUu sM8lT6sLYAUG0HhXPKousFD/XuoCWIEBNB2H4Afx3EXqAliBATQcLwAGwkfhkBQG 0HAjTlYXWGn2QeKAnvN4G8YGDKDZegxUF1iqaHS3Qsoo+Jj9Ws8dM7flgsgKEBoG 0GhVFqkLbNX5lei+duEtBfyC+3sULlTosxbRFSAsDKDJ+AhwYEPOkX3rouN33Lqg T19ZApLFAJrsU/4QEZTuRcDK3+6z8991el3VgGQxgAa76U51gcUqrIzwi+fzQ/DN fYru+rfzT50dYQPCwACaq+ZcdYHNHrkyyq+e1wJmjG6a5T+Nab45ygikjwE0VrF5 ldQJNltYXfBN95mc/e/Z7bcJIpACBtBY3AQkPYIDYdq+vGeOv3Lu4NgjkAoG0FT9 +MNDet5tHemXL5L7QsOXzs31lxaeMTXSCqSJATQUdwFOW6l1kX75nAtYfEL9BL9q bIuNkVYgPQygmUrN3U+dYL2HekT79bMvYPWJeyf8Vdyh3WgMoJm+bqQusN/K/Qr+ zFpobu1VNI//puuz8VUgVQygkQZG/IcXP0T9UYxif/90m/F53u9YLe4wIdoMpIEB NFFDnjJhyKwc8TcovmHH/99rSn7fafwJayPuQGAMoIH2+kVd4Ihbov4ozY6XAQ8d WzLfX/Xg1RFnIDAG0EBTGqgLHLGsUhyvAt53deECfgW3aTcWA2iepy5RFzgj8k9i lFhfZPwRBf6qzHNHR9yBgBhA4/z7M3WBQ4ptivgbtH+sXBK/avrxqyLuQDAMoGnK RXmKiXcGXRrt10/2wLL3T4u2AwExgIbJmKm+m4Vb9v0pwi9edGbNZH9pT+5tYCQG 0DBDzlYXuOWjCG8qVWFm4g9/JLK864joQhAYA2iWU95XF7im4aSovvL5g4ql8Ktn tsyMKgTBMYBG4S7ooVtYI6JLYRKc/ZKvkS2j6UA6GECTFJmtOMXTcQ9fFcmXTf3T 2jffFUUH0sIAmuTjE9QFLtpvRfhfs9j8iin/nhWXDws/BOlhAA1yw93qAidNPiz0 L1ljcukAv2v2afNCL0F6GEBzcBOkiIT+s2fPe4oE+n2jTizoluqIGQNojOJzuQlS RP75c6hf7t3AVzX37hdmB9LHABpjTNOCfw0C+abgj+smr/C0usF/81mvhReCEDCA prj9FnWBw+65MbQvtc/sfdP43fPPmB5aCULAABqiwRR1gdMODOv11fYvlUjr939+ EjdJMgkDaIbScyuoE5y2qFbuu1gGMejidL/CHbeG0YGQMIBmmBjmq1TI7fVOIXyR jLFN0v8iXV5I/2sgLAygER66Ul3gvONHpf0lyswI4336hR0nhvBVEA4G0ASNvlYX eCDtD4TUHV8mlJCxJ3OTJGMwgAYo+5u6wAdzD0rvKuSb+gW7+jm3ATeE9IWQNgbQ AJMPURd44eOT0vndH50YVgf3SjcIA6j3eDd1gSfSuEVSmUm1QgxZdNZXIX41pIEB lDt6rLrAG0cGveF87S+TP/s5GWNbrgn16yEoBlBt73A/p4r8VFkS6Lf1vCuVs5+T ce/1IX9BBMMAqk2try7wyNK6q1P/TRnvnRJ+ySVPh/81kToGUIy7oMdq5iEpfyJk r/G1IwhZdM64CL4qUsUAajUdoy7wzIQjU/wNh366TyQh41oG+MMowsYASu0T5V1r kcgnqV3O0v+GohGF3HddRF8YKWAApabXUxf4573Tk/+1RT9tFl3IpYOi+9pIEgOo 9OyF6gIfDTsj2V9ZZXTlCDsWn8MFUHIMoNC/P1MX+CnZPwP2uL1UpB1ftuIzkGoM oM6+P6gLfJXU64CF32sVdcf910b9HVAABlBnRhr3lkBavm66qaBfUvGzmtF3cDWg GgMowxWAQrOb/JL/L7jizrIxZPChYDUGUKXxeHWB11adODWf/zaGH393GNOKswGl GECRMr+rC3yXz9kw1T6tFldF/15xfSckwgCKTGioLvDeVyfl8T9Ct94Y7bu/2XR+ Jb7vhVwYQI27ORTYAN0fS/AXS358dJwNc9pxp2AhBlCiHv/QG+GbNktz/qXDPoj5 BqUfnxLOHTsRBAOoUHxeRXUCdnj1kuxHkz56SdhH/xXo5rvi/o74GwOo8H/HqQvw t5e6734psPyngg9nr7hsePzfFDswgAI33K0uQFbv3r3zbL4eff6h+P4zTl+o+LYo xAAqVFmkLkAOs9+8c22h4iNVfzB/t7XoG4MBjF3hOTXUCchtwvRWMb/7kcV/H5V9 a88xgLF7raO6AKbJ7DJKneApBjBuJ49QF8A837ZcpU7wEwMYs3/+qC6AiV7vpC7w EwMYsykN1AUw0vkvqQu8xADG68Gr1AUw09yOk9UJPmIAY3XwNHUBTPXRaQUe0orQ MYBxKjavkjoBxrr2fnWBhxjAOH1yvLoA5lp2MRcIxI4BjNEVXO6KfHx7ygp1gncY wPhwBQzy9+rZ6gLvMIDxmXyIugCGO2eIusA3DGBsOAQaBZnV9jt1gmcYwLhUn68u gPmGt1EXeIYBjEnGXM6AQcH+84S6wC8MYExeOF9dABss7Mz9ouPEAMaj4QR1Aezw Ses/1Ak+YQBjUWzRfuoEWOL6e9UFPmEAY/EOr20jSUu7fKpO8AgDGIfmnPeLpI0+ /feCfxHCwQDGoNSagn8NsMstd6oL/MEAxmB0M3UBbPL9xR+oE7zBAEaPMxCQmrGt f1Yn+IIBjNxev6gLYJve/dQFvmAAIze+sboAtll52TB1gicYwKj1GKgugH2+bM3Z abFgACPGD8AIgh+C48EARuzLo9QFsNGKy4arE7zAAEar+yPqAthpbJuf1Ak+YAAj VfY3dQFs1au/usAHDGCkxjVRF8BWKy59V53gAQYwSpc9qS6Avca04Q20yDGAESq5 Vl0Am3EwVvQYwAi9fYa6ADbLvOAzdYLzGMDocAo00jOyzQZ1gusYwMgUXlRJnQDL XfG4usB1DGBknu6qLoDt5p71jTrBcQxgVGrMUxfAfm+1Uxc4jgGMyncHqQvggHMH qwvcxgBGpHcfdQFcMLX1YnWC0xjAaPAZOITjuYvUBU5jAKPxQSt1AdzAXTIjxQBG ovF4dQFc8dEZf6gTHMYARiFjUWV1Apxx6SB1gcMYwCg83k1dAHfM6jRVneAuBjAC +y9TF8Alr3RWF7iLAYzAV0eqC+ASTgaMDgMYvrOHqAvglk/arFMnuIoBDB3vgCBs Fz+jLnAVAxi6+65RF8A1M9rNVic4igEMGzcCRvj4PEhEGMCwvXuaugDu4XDoiDCA IWswRV0AFw1v96c6wUkMYMhm1FUXwEmdXlcXOIkBDFc3zjBHJP7vzF/VCS5iAEOV kXmAOgGO4iPBUWAAQ8UlMIjK9LZz1QkOYgDDVHq1ugDu+t/l6gIHMYBherWTugDu mn/OV+oE9zCAIaq0RF0Al3EqTPgYwBB9fIK6AC5bduHH6gTnMIDhqTNTXQC3vdVh izrBNQxgeCYdri6A21ZdMlyd4BoGMDSth6kL4Lr3221QJziGAQwNH4JD5DoMVRc4 hgEMS5fn1AVw3ydnrlEnuIUBDMv86uoCeODcweoCtzCAIen+iLoAPvisHQfuhokB DMnCquoCeOG8l9UFTmEAw3HZk+oC+GFU29/UCS5hAMMxr4a6AJ7o/Iq6wCUMYCi6 Pq0ugC8+acuZQ+FhAEMxq7a6AN7gcPwQMYBh6My1CYjNyLbr1AnuYADDwIdAEKN2 b6kL3MEAhuDkEeoC+GR4+03qBGcwgCH4/Fh1AXzy/YUj1QnOYADTx0HQiNeQc9QF zmAA0/dOG3UB/LLonHHqBFcwgGkr87u6AL4ZdKm6wBUMYNqeuUhdAN9MaT9PneAI BjBdRXhHDrHr/pi6wBEMYLp69VUXwD9j2q9SJ7iBAUzXnFrqAnio4xvqAjcwgGlq 8am6AD56q+NmdYITGMA0fdBKXQAfLTl3jDrBCQxgekpxjxpIPNlNXeAEBjA9D16l LoCfJrTnA0ghYADTs6SSugCe4uYgYWAA09Ke9+Ig8l6H9eoEBzCAaRlxsroAvso8 d7Q6wQEMYDqKblQXwF8P8/pz+hjAdPApEOjwaZAQMIDpmHS4ugAeazNcXWA/BjAN Fb5XF8BnL16gLrAfA5gGDsKC0rcd5qsTrMcApiGzoroAXjuX27GmiwEM7pgv1AXw 29COW9UJtmMAg3vxPHUB/Da1wxx1gu0YwOAWV1YXwHOdX1EX2I4BDOywb9QF8N0r ndUFtmMAA3u6q7oAvvu2/QJ1guUYwMBm1VYXwHudXlcXWI4BDKpiproAeOl8dYHl GMCg7u+pLgDGd1iqTrAbAxjUuCbqAmBllxHqBLsxgAFlbFEXAIUKPXCNusBuDGBA HXj1GQYY3olzodPBAAY0mCuwYIBpHWarE6zGAAY0s466ANimw1B1gdUYwGDK/K4u AP4y6FJ1gdUYwGCuG6AuAP4yqsPP6gSbMYDBDGutLgD+MrvDNHWCzRjAYObUUhcA 2/FpuHQwgIGUXKsuAHZ4spu6wGYMYCBdn1YXADt82HGNOsFiDGAgz3VRFwA7cGuk dDCAgYxvrC4Adljecaw6wWIMYCDciwbGuOg5dYHFGMAguCM6zPHMxeoCizGAQXTh f3NhjA86ck1CYAxgEE9cri4AdpnYfrE6wV4MYBAfn6AuAHZZ0HGSOsFeDGAQHAUD g7R7S11gLwYwCN4EhkEe664usBcDGABvAsMo+61QF1iLAQyA4/BhlI5vqAusxQAG 0Ke3ugDIom8fdYG1GMAAnr9AXQBk8UIXdYG1GMAARp6kLgCy+OhkdYG1GMAAJh6h LgCymNRQXWAtBjAAjoOGUeYeqC6wFgMYAJcBwiw8jYPikQuAAYRZeBoHxSOXuhJ/ qAuAbPZcry6wFQOYunrT1QVANgfPUBfYigFM3fGfqAuAbE74VF1gKwYwdWcPURcA 2XR+RV1gKwYwdRcPUhcA2VzCbVoDYgBTd9WD6gIgmx4PqQtsxQCm7qY71QVANjff pS6wFQOYur691AVANv04nyggBjB1DCAMwwAGxQCmjgGEYRjAoBjA1DGAMAwDGBQD mDreBIFheBMkKAYwdVwGA8NwGUxQDGDqLnlKXQBkcynX5gfEAKaOj8LBMHwULigG MHX//kxdAGTT/P/UBbZiAFNXa466AMjmwLnqAlsxgKkrzumTMEuJDeoCWzGAAXAk PszC0zgoHrkAGECYhadxUDxyAczmLoQwyZza6gJrMYABTOA+1DDJxEbqAmsxgAF8 2FJdAGQxopW6wFoMYADPXqguALJ47iJ1gbUYwAB69VUXAFn07qcusBYDGEDbN9UF QBbt3lIXWIsBDGDvn9UFQBb7/KIusBYDGAQXAsIkPIsD46ELYmYddQHwt+/qqgvs xQAGMeJkdQHwt5FclhUYAxjEfdeoC4C/3X+tusBeDGAQp76nLgD+dtr76gJ7MYBB FN6sLgD+tscWdYG9GMBA5tZUFwA7zaulLrAYAxjIxyeoC4CdPjlRXWAxBjCQh65U FwA7PXyVusBiDGAgJ49QFwA7tRypLrAYAxgMnwWBKXgOp4EHL5ivjlQXANt93Vhd YDMGMJgnL1MXANv973J1gc0YwGB4ERCG4CXAdDCAAfEiIMzAUzgdPHoB8SIgjMBL gGlhAAMa2ENdAGzz4NXqAqsxgAGVX6EuALapsFJdYDUGMCjujg4DcE/09DCAQb14 nroAKPTS+eoCuzGAQbX4VF0AFDp+lLrAbgxgYCvKqwvgvZUV1AWWYwADG366ugDe e7e1usByDGBg3B4dctwSPU0MYHDf8+MHtFbspy6wHQMY3EvnqgvguZe5FCFNDGBw h32jLoDnDv9WXWA7BjAN3BoJUtwOKW0MYBru76kugNceuEZdYD0GMA1lf1MXwGv/ +F1dYD0GMB2jmqsL4LHPWqgL7McApoNLASHERYDpYwDTsrCqugDeWlRNXeAABjAt d9+gLoC37rlRXeAABjAtxTaoC+Ct4hvVBQ5gANPz9hnqAnjqnTPVBS5gANNTbYG6 AJ6qvlBd4AIGME1jmqoL4KUvmqkLnMAApunU99QF8NJp76sLnMAApmtmHXUBPPRd XXWBGxjAdHV9Wl0AD138jLrADQxg2rgYGrHjIuiQMIBpu+lOdQG8c/Nd6gJHMIBp y8g8QJ0AzyyrtFWd4AgGMH3X36MugGduGKAucAUDGIJFVdQF8MriquoCZzCAIbji UXUBvNL9MXWBMxjAMMyroS6AR+ZzL5rQMIBhOP8FdQE8csGL6gJ3MIChmMF1+YjL zHrqAocwgKE4lPuzIi6HTVYXOIQBDMfIk9QF8MRHJ6sLXMIAhqPcSnUBPFF+lbrA JQxgSJ69UF0ALzx3kbrAKQxgSLg7CGLBnUBCxQCG5eY71AXwwC0cvREqBjA0s2qr C+C82QepCxzDAIamzkx1AZxX9zt1gWMYwPC82kldAMe9dpa6wDUMYHiKr1cXwHEl eKstZAxgiDgVBpHiFJjQMYBhmnS4ugAO++YIdYF7GMAwVcxUF8BhlZaqC9zDAIZq wHXqAjjr3uvVBQ5iAMP1HddpIRqz6qgLXMQAhqvKInUBHFV1sbrARQxgyB66Ul0A Jz18lbrASQxg2ObUUhfAQXMPVBe4iQEMW4156gI4qOZ8dYGbGMDQPXC1ugDOGdhT XeAoBjB80w5WF8Ax0+urC1zFAIaP4/ERMo7BjwoDGIGe96sL4JRrHlAXOIsBjMKY puoCOOSLZuoCdzGAUSg1v7w6Ac5YWWOtOsFdDGAkGk5QF8AZjSaqCxzGAEbj0SvU BXDEY93VBS5jACMy+RB1AZww5VB1gdMYwIjs/bO6AE7Y5xd1gdMYwKgc84W6AA5o OlZd4DYGMDJPXaIugPUGXaoucBwDGJ0pDdQFsNxUXkmOGAMYnbJzuBoQ6Vh54O/q BNcxgBE6ZLK6AFY7dIq6wHkMYJR691EXwGJ9+qoL3McARurTFuoCWGvU8eoCDzCA kSoyq4Y6AZaaf9Cf6gQPMIDRqvC9ugCW2m+FusAHDGDEGo9XF8BKR32lLvACAxi1 Pr3VBbBQ3z7qAj8wgJH7oJW6ANb58BR1gScYwMhlTKunToBlZtTfqk7wBAMYvTKz 91MnwCrf116tTvAFAxiDWnPUBbDKgXPVBd5gAOPQfJS6ABZp8Zm6wB8MYCz636ou gDVuv01d4BEGMB7vtFEXwBLDzlAX+IQBjMnXjdQFsMKEI9UFXmEAY1JsJp8KRsHm 192oTvAKAxiXf87geFQUZGW9n9QJfmEAY1NjnroAxqs5X13gGQYwPpyLgAJwAkLc GMAYtR6mLoDR2gxXF3iHAYzTPderC2CwATeoC/zDAMaKywGRJy4AFGAA4zW6mboA hhpzrLrARwxgvApPPEydACN923CLOsFHDGDMik2trU6AgWY34AJoBQYwbqVnVFYn wDhL6q1RJ/iJAYzdvtMqqBNgmBX1f1QneIoBjF+VReoCGKbqYnWBrxhAgYOnqQtg lPrT1QXeYgAVGk5QF8AgjSaqC/zFAEoc+7m6AMY4brS6wGMMoEarD9QFMMQpH6oL fMYAinR4XV0AI3R8Q13gNQZQ5YLn1QUwQJcX1AV+YwBl7rtGXQC5+69VF3iOAdR5 /gJ1AcRe6KIu8B0DKDS4s7oAUkPOURd4jwFUeqO9ugBCQzuoC8AASg0/XV0AmXdb qwvAAIp92FJdAJERrdQFYADlPj5BXQCJT05UF6AQA6jHAnqJ/TMDAyjHAnqI/TME A6jHAnqH/TMFA2gAFtAz7J8xGEATsIBeYf/MwQAagQX0CPtnEAbQDCygN9g/kzCA hviAy2L98OEp6gJkwQCaggX0AvtnFgbQGHwu2AN8/tcwDKA53mmjLkDEhp2hLkB2 DKBBXu2kLkCkXjtLXYAcGECTvHieugAReul8dQFyYgCNcn9PdQEi8wA3gTEPA2iW i55RFyAiXZ9VFyA3BtAwnQerCxCJc4aoC5AAA2iatm+qCxCBdm+pC5AIA2icVh+o CxC6Uz5UFyAhBtA8zUarCxCyY8eoC5AYA2ighhPUBQhVo4nqAuSBATTRwdPUBQhR /enqAuSFATRSjXnqAoSm5nx1AfLEAJrpkJHl1QkIxapLlpYsVKpI8aK7/sK6LYX+ XFtoy5pC6zdu/OPP1co2MICROrhJvSr7laumzoDFFq5avmTGl/wQHREGMBLlmh9e s3L5SuoMOCNzRea8bz5bpc5wDgMYssLN/1232mHqCjjqm0UzPv9si7rCIQxgiKp2 bFK7jjoCzps5e/zri9QRjmAAQ1LqPyc24H0LxGXllI+fWKuOcAADGIZjujY6WN0A 70yb8Mw4dYPtGMC07d3vtKrqBnhq4Xu9f1E3WI0BTE/GNe0bqxvgtfFDH9iqbrAX A5iO0vddpk4ACj153Rp1gq0YwOBKPXKhOgHY7tkreUckEAYwqIyBV6kTgL892JMf hANgAAPq0r+iOgHIIvO2F9QJFmIAAyn9QTN1ApDD6FN5KTBVDGAQx36uLgASOI7D xFPEAAbwIK/+wUwPXq0usAwDmLKio5qqE4A8jDl+kzrBKgxgqiqO5nw/mGvBscvU CTZhAFNUj6MpYbaDZ6gLLMIApob9g/FYwOQxgClh/2ABFjBpDGAq2D9YgQVMFgOY gsqL1QVAUqosURdYggFMXotP1QVAklp8pi6wAwOYtMKb1QVA0vbg1knJYACTNrW+ ugBI2tRD1AVWYACT1beXugBIQe9+6gIbMIBJKrdSXQCkpNwP6gILMIBJmlNLXQCk ZPZB6gILMIDJueNmdQGQottvUxeYjwFMSiUuq4J9Ki1VFxiPAUzKzDrqAiBlMw5W FxiPAUzGxYPUBUAAFz2nLjAdA5iEDK4phZ0Kc6u4/DGASXjicnUBEMhj3dUFhmMA C1bmd3UBEFDZ1eoCszGABZvQUF0ABPTVUeoCszGABTpwtroACOzAueoCozGABZpX Q10ABDantrrAaAxgQTq8ri4A0tD+TXWByRjAAnAJDCzHpTD5YAALwClYsFyv/uoC gzGA+eMYaFiPw6HzxgDm764b1QVAmu64VV1gLgYwXxkryqkTgDSt2J9XAfPCAObr qgfVBUDa/vuousBYDGC+Jh6hLgDSNuFIdYGxGMD8VMxUFwAhqLhMXWAqBjA/r3dQ FwAhGHKOusBUDGB+eO0YbuB5ngcemHy800ZdAITirXbqAkMxgPnIrKguAEKxtJK6 wFAMYD74CRiu4ImeGI9L3vb5SV0AhGSfX9QFZmIA8/bxCeoCICQjWqkLzMQA5o2f gOEOnukJ8bDkjQGEO3imJ8TDkqd//KouAELzD+5tmAgDmKc32qsLgNC8dpa6wEgM YJ5mH6guAELzXV11gZEYwDzxEiBcwlM9ER6VPDGAcAlP9UR4VPLC/dDhFO6QnggD mJeRJ6kLgBB9cKq6wEQMYF44CQFOWVJFXWAiBjAvvAQIt/BcT4AHJS8MINzCcz0B HpQ87P2zugAI1d58tCk3BjAPw09XFwCherutusBADGAeFvGSMdyysLq6wEAMYB54 CRCu4cmeG49JHhhAuIYne248JokV3qwuAEK2xxZ1gXkYwMSevExdAITs0f+qC8zD ACY28Qh1ARCyrxurC8zDACbGS4BwD8/2XHhIEmMA4R6e7bnwkCTEeyBwEO+C5MIA JtR8lLoACN1xo9UFxmEAE/qwpboACN27rdUFxmEAE5pTS10AhG5WHXWBcRjAhHgP BC7i6Z4Tj0hCDCBcxNM9Jx6RRGrPUhcAEeDGSDkxgIn0GKguACLQ/TF1gWkYwETG NVEXABEYc6y6wDQMYCJLKqkLgAgsrqouMA0DmAjvgcBNPN9z4AFJZHFldQEQAU7F z4kBTIQ/AcJNPN9z4AFJhAGEm3i+58ADkggDCDfxfM+BBySBgT3UBUAkBtygLjAM A5jAMA7NgJuGdlAXGIYBTIAbgsBR47nEPzsGMIHMiuoCIBJLqqgLDMMAJsB7IHAV T/jseDwSYADhKp7w2fF4JMAAwlU84bPj8cjt/p7qAiAid9+kLjALA5jb0HbqAiAi r3RWF5iFAczti2PUBUBE/q+5usAsDGBu3BIOzvqurrrALAxgbrwHAnfxjM+GhyM3 BhDu4hmfDQ9Hbgwg3MUzPhsejlyuv0ddAESmJ3c8zIoBzOWpS9QFQGQe/a+6wCgM YC7vn6IuACLzzpnqAqMwgLl83UhdAETmy6PVBUZhAHNZUE1dAERmHle5ZsUA5sKb wHAZT/mseDRyYQDhMp7yWfFo5MIAwmU85bPi0cjp2nvVBUCErnxEXWASBjCnx7up C4AIDeS4yywYwJy4Jyac9kZHdYFJGMCcvjlMXQBEaMKR6gKTMIA5LT1AXQBEiDtj ZsUA5sSbwHAbz/kseDByYgDhNp7zWfBg5MQAwm0857PgwciJAYTbeM5nwYORw33X qAuASN15i7rAIAxgDpwGCMdxImAWDGAOkw9RFwCRmtRQXWAQBjAHLgOE4zIrqwsM wgDmwHsgcB1P+t14LHJgAOE6nvS78VjkwADCdTzpd+OxyIEBhOt40u/GY5EDAwjX 8aTfjcciu1v7qwuAiF3Poed/YwCze+F8dQEQsacuUxeYgwHMblRzdQEQsZEt1QXm YACz++4gdQEQsWkN1AXmYACz4z0QuI9n/d94KLJjAOE+nvV/46HIjgGE+3jW/42H Ipu+vdQFQORuultdYAwGMJvBndUFQOSe7aouMAYDmN0jVfcvV1EdAURmyfeZi65T R5iDAUzkyjpV9jtUHQGEasKyhbOeUkeYhgHMR4+DqlRgB2G7CcsXzXpSHWEoBrBg Vx1UuQI/F8M6S1ZsW77/qSvMxgAm7+EqFcpVVUcABZq/YvliXudLCgOYsjuqHfCv OuoIIIHpK5Yu7KeOsAoDGNTVtSqW37e6ugLYZu6qFUvmPa6usBEDmK4bq1cst28V dQW8tOCHFUsXPKCusBkDGJYbqu33r31rqSvghVk/rFy+aKC6wgUMYOju2Paj8T7V 1BVw0Lyffvx+aV91hVMYwOjctX+5f+7FnwmRrtk//7RyWW91hZsYwBhcW7HCP/fe q4Y6A1aZ+/OvP6zIfFid4TgGMFZXViz/r732KnuAugOGWvrrr7/8sHLZY+oObzCA Ktftv+/ee5Upw4uFWPD7b7/+/NOyB9UdPmIATXD9th+Ry5YtzeuF/pi9+vfffvn5 ey5hEWMAjXPzv/beq2zp0iW5ttAti9asXfPbr7+sGqAOQRYMoOGu2/ZnwzJlSpXc s6q6BClatHbtutWrf/v5Z/6YZy4G0DK37rVXmVKlSpYoWYLzacySuX7d+rVr12xb PA6ctwcDaL1b/1GmTMlSJfYsUbx4ZXWLNxZvWL9+/R/r1qxe+8td6hakgQF00o1l SpcuVaL4nsWLFytejFlMx+KNGzZuWL9t77b94W7NPeoahIwB9MpNpUqVKFFy2ywW K1602Lb/218dZIjlmzZu3PavbVO3Yd22qVvLD7G+YACxU8+Se+5ZokTREn8tY5Fi RfcotkfRIq4M5PI/N23euHnjpk2btu3cX3+iW/fHOs4SAAOIVPT464XGosWKFS1S pFiRIkX32KNIkT0KF/3rX5qlXL5505a//vXnn5s3b/rzz41/bvpzw6ZNGzas/4OL ipEUBhDRuX6PEoWLZZQoVKJQ8UKFthbK+o9bxt//qXCO//y3jYU2FFpfaP3WjVvW b+biOUSCAQTgLQYQgLcYQADeYgABeIsBBOAtBhCAtxhAAN5iAAF4iwEE4C0GEIC3 GEAA3mIAAXiLAQTgLQYQgLcYQADeYgABeIsBBOAtBhCAtxhAAN5iAAF4iwEE4C0G EIC3GEAA3mIAAXiLAQTgLQYQgLcYQADeYgABeIsBBOAtBhCAtxhAAN5iAAF4iwEE 4C0GEIC3GEAA3mIAAXiLAQTgLQYQgLcYQADeYgABeIsBBOAtBhCAtxhAAN5iAAF4 iwEE4C0GEIC3GEAA3mIAAXiLAQTgLQYQgLcYQADeYgABeIsBBOAtBhCAtxhAAN5i AAF4iwEE4C0GEIC3GEAA3mIAAXiLAQTgLQYQgLcYQADeYgABeIsBBOAtBhCAtxhA AN5iAAF4iwEE4C0GEIC3GEAA3mIAAXiLAQTgLQYQgLcYQADeYgABeIsBBOAtBhCA txhAAN5iAAF4iwEE4C0GEIC3GEAA3mIAAXiLAQTgLQYQgLcYQADeYgABeIsBBOAt BhCAtxhAAN5iAAF4iwEE4C0GEIC3GEAA3mIAAXiLAQTgLQYQgLcYQADeYgABeIsB BOAtBhCAtxhAAN5iAAF4iwEE4C0GEIC3GEAA3mIAAXiLAQTgLQYQgLcYQADeYgAB eIsBBOAtBhCAtxhAAN5iAAF4iwEE4C0GEIC3GEAA3mIAAXiLAQTgLQYQgLcYQADe YgABeIsBBOAtBhCAtxhAAN76f/jfNaaHYiHZAAAAAElFTkSuQmCC"/></symbol><g mask="url(#b)"><g transform="rotate(.193) scale(.36014)"><symbol id="c" viewBox="0 0 1280 1280"><image width="1280" height="1280" xlink:href="data:image/png;base64, iVBORw0KGgoAAAANSUhEUgAABQAAAAUACAIAAACXhmigAAAACXBIWXMAAA7EAAAO xAGVKw4bAAEWsElEQVR4nOzdC3zb9X3v/0g/WbLkS2I74MTkHkt22Nq15b+t6elO z7o91p6eraX0sZ718eg4oy0ZtGM7XU5pAozDrdwGpbRQSkdLgbJCWzr6gKZAGOFA uKxcSyGxJMd362bdZd1l6/+1RbPgOLZs/b4//SS9no/HPMWRP99vbFH77e/3+/ka 1gAAAAAA0AAM1Z4AAAAAAABaIAADAAAAABoCARgAAAAA0BAIwAAAAACAhkAABgAA AAA0BAIwAAAAAKAhEIABAAAAAA2BAAwAAAAAaAgEYAAAAABAQyAAAwAAAAAaAgEY AAAAANAQCMAAAAAAgIZAAAYAAAAANAQCMAAAAACgIRCAAQAAAAANgQAMAAAAAGgI BGAAAAAAQEMgAAMAAAAAGgIBGAAAAADQEAjAAAAAAICGQAAGAAAAADQEAjAAAAAA oCEQgAEAAAAADYEADAAAAABoCARgAAAAAEBDIAADAAAAABoCARgAAAAA0BAIwAAA AACAhkAABgAAAAA0BAIwAAAAAKAhEIABAAAAAA2BAAwAAAAAaAgEYAAAAABAQyAA AwAAAAAaAgEYAAAAANAQCMAAAAAAgIZAAAYAAAAANAQCMAAAAACgIRCAAQAAAAAN gQAMAAAAAGgIBGAAAAAAQEMgAAMAAAAAGgIBGAAAAADQEAjAAAAAAICGQAAGAAAA ADQEAjAAAAAAoCEQgAEAAAAADYEADAAAAABoCARgAAAAAEBDIAADAAAAABoCARgA AAAA0BAIwAAAAACAhkAABgAAAAA0BAIwAAAAAKAhEIABAAAAAA2BAAwAAAAAaAgE YAAAAABAQyAAAwAAAAAaAgEYAAAAANAQCMAAAAAAgIZAAAYAAAAANAQCMAAAAACg IRCAAQAAAAANgQAMAAAAAGgIBGAAAAAAQEMgAAMAAAAAGgIBGAAAAADQEAjAAAAA AICGQAAGAAAAADQEAjAAAAAAoCEQgAEAAAAADYEADAAAAABoCARgAAAAAEBDIAAD AAAAABoCARgAAAAA0BAIwAAAAACAhkAABgAAAAA0BAIwAAAAAKAhEIABAAAAAA2B AAwAAAAAaAgEYAAAAABAQyAAAwAAAAAaAgEYAAA1KYpisVhW8YHZbHZmZkb1+QAA gOMIwAAArNIJWbdYLM79X2tray6X27Fj+yqqDQ0Nm83m6elpw5w1pe/RpGIAAFRE AAYAoCwnLu3Ozs6KuGsymez2XqmDut2DhUJBBGKj0Vh6D5EYAIBVIwADAHBKx0Ov iLtdczpLi7PVIqYRCoVDoVBpGoRhAABWhAAMAMA7GI3G5ubmNfNps62tradnY7Vn dEoejzeRSJTCcCaTmZ2drfaMAADQNQIwAABzTtzh7HDYqzuZVXC53KUHLAsDAHAq BGAAQEP7be4ttre3b9iwodrTUYHP54vH4+JbPEkYAIAFCMAAgEZ0fJ+ziL4Oh6PK s5HD5XKVvtGzOxoAgBICMACgsRzf6my391a3o5U2isWi2z24hq3RAAAQgAEAjaO0 6tvcbNmyZUu151IFY2NjmUyW1WAAQCMjAAMA6l9Li212tqgoSm/vzmrPpcoGB4/N zMwYjYZkMlXtuQAAoDUCMACgbplMJrPZvKZhdjuX7/i+6FwuVygUqj0dAAA0wk8D AID6ZLPZRMzr63OIt6Tfk5U+LU6nS7xNpVgNBgA0BH4gAADUG0VRNm7c2NXVKR4T fZcmYrB4GwqFvV4vLbIAAHWPHwsAAPVDRN+mpiaj0ehw2Ks9lxozOHisUCjk83li MACgjhGAAQD1oBR9zWbz9u3bWPVdnWKxODw8ksvliMEAgHrFjwgAgJpnNBq7urp6 ejYSfSsnYrDH4w2FQtyWBACoP/ygAACoYYqi9PT0BIPBvj5HtedSV1wud1dXl8fj YSkYAFBPCMAAgJpkNBrNZnNTU9POnTuqPZe6NTw8ks1mc7kcq8EAgPpAAAYA1B5F UUT6ZdVXG06nS2RgloIBAHWAAAwAqCWlZlcmk6m3d2e159JAhoaGaY4FAKgDBGAA QM1g4be6WAoGANQ6AjAAoAYoitFstogAzMJvdQ0NDefz+VwuOzPDqWAAQO0hAAMA 9M5oNDY3WxwOFn71wuVyZTJZOmMBAGoOARgAoGuKYuzo6Ni0aVO1J4J38Pl8U1NT rAMDAGoLARgAoFOlbc/F4mx/f3+xWDQY+J6lF6Uvh9PpFD9IsB0aAFBD+GECAKBH iqJYLBaHw17tiWAZLpc7m83SGQsAUBMIwAAA3aHbc22hOzQAoFYQgAEA+iLSb1tb 27ZtW6s9kRWLRKLd3d3btm0788wzu7q69uzZU+YH3nXXXZOTk0ePHhkdHZuamurq 6pQ6TxlGRkYTiQQZGACgcwRgAIBezG97NhsMRru9tyYO/fp8/v7+/h07drz3ve8t P+4uYDKZ4vF4Nps98Z333HPPG2+8MTo66nK5eno2qjFZiUpfLLd7sFiczWZZCgYA 6Jfef7YAADQIRTE2N1tF9K32RJYxPDwi4u573vOes88+e/fu3RVWE+nX7/MZFWWJ 57z00ku/+MUv3nzzTRGJd+zYXuGIsokYnMmkaYsFANAnAjAAoPoURWluttjt+m15 5fP5Re4999xzzznnHFUKGubF4/F8Pl/+Rz366KMPPvjgr3/9az0vC7vd7kyGtlgA AD0iAAMAqkzPLa9Uz70lRqMxkUjkcrlVV9B5EqYtFgBAnwjAAIBq0mf6Le1z/tSn PrXqk72nIv696Xmzs+psEr7nnnseeeQRHe6OJgMDAHSIAAwAqBodpl+fz/+xj33s 6quvXr9+vbqVS3ueK1z4PZVQKHTttdcePHhQVwvCZGAAgN4QgAEA1aEoxo0be9av 76r2RN6WTmc+85nP7N+/X0Zxo9E4PT29oNWzDLfccsvPfvazlhab7IHK5PX6gsEp emIBAHSCAAwAqAJFUbq7u08//bRqT2SOiL5/93d/p/pu5xLxLxW5N5VKabkQes89 99x11106icEejzcUCrEODADQAwIwAEBrIhOuX79+48YN1Z6I3Oi7RsOF30XpJwZP TExGIhEyMACg6gjAAABNifTb1dVV9aOqsqOv+GeWom+xWJQ0RJl0EoPHxyei0SgZ GABQXQRgAIB2TCaT2Wy223sNhqp9A/L5/BdccIGks75r5ptdidAr0u+KLviV7eab b7777rs3bTqjWhMQnxO3ezCXyxUKhWrNAQAAAjAAQDvNzc19fY4qpt/Nm7d85zvf Ub3D83HV3fO8NL/ff9FFF8XjsWpNQGRgp9OVyWSqNQEAAAjAAACNiHBoNjf19/dX ZfR0OnPnnXfu3r1bUn2R6guFQiqV0vMKp8/vP/TUU9/4xjc6OtZVZQIDAwO5XF6t O5ABAFgpAjAAQAuKYmxqqk76HR4e+dSnPnXHHXfIG0Jk+3g8rqs9z4sS4dzj9YZD oVtvvfXw4cM7d+7Qfg4iA4tPFBcjAQCqggAMAJBOURSz2dzX59B+6HQ68+Mf/1he 8DYYDLlcLpVK1cqqpsjAY6OjsXh8fHz8a1/7WlWWgp1Ol/ik0RALAKA9AjAAQC6R fq1Wa2/vTu2H7u/fdc8998irbzQaY7GYnvc8L8rv9/t8vlJi/+d//udwOKT9HAYH j6XTaTIwAEBjBGAAgEQiInZ1dZ1xRo/G40Yi0euvv/6cc86RVL904jeZTNZihBMz 9/p8oWCwdEXT4cOHv//973d3n67xNCYnPaFQqFZWzgEA9YEADACQRVEUi8XicNg1 Hlek00cf/YXUVs+JRCKXy0mqrwGRgUfHxuKxtztCx2Kxyy//J5tN67uCXS53Nput xV8iAABqFAEYACCLCFTap1/Z255Ld/zW3Lbnk/kDgbmN0CeEz6pshxYZOJVKaTwo AKBhEYABAFJov/w7PDxyzTXX7NmzR1J98S+Kx+M1vfB7ormN0H5/aGqqtBG65MCB Az/4wQ+07A7NIjAAQEsEYACA+oxGo0i/WrZ99vn8DzzwgLxrfsW/aHp6WkQ1SfWr Yq4j9Ph4LBo98Z1Hjhy59tprN2/epNk0nE6X+MRyGBgAoAECMABAZYqiNDc32+29 mo0YiUSff/55SYd+DQZDPp9PJpN1mdD8gYDf51uwABuLxb785S9r2RbL7R7MZDKs AwMAZCMAAwBUZrPZRPoVuVGb4aSmXxHmE4lEnS38nmjRjdBrNM/AYnSRgTkMDACQ jQAMAFCTSIzr1q3dvHmzNsNZrbann35aUvE66PZcjrmN0GNjsd92hD7RV77yFZNJ 0WYa4+Pj0WiMRWAAgFQEYACAakRitFqb7XZ7sVjUYAVYavoVsXB6enrBumi9Orkj 9HHaZODSC8btdqfTmbrcag4A0AkCMABANVreeyQv/TbIwu+J5jZC+3yhYHDRwK/l OjC3IgEApCIAAwDUoShKR0fHpk1naDCWvPRb94d+T2VuI/ToaCweX/RvNcvAExOT kUiEjdAAAEkIwAAAdVitVm3uPTIYDC+++B8yKhuNxlgsJqKgjOL65/f75zZCn2IH 8j/8w9/bbDYNpuF0utLptAYDAQAaEAEYAKACRVGamkz9/f2yB5LX87lYLIr02yCH fhclkr/H6w2HQot+EjTrCz0wMJDPF1gEBgDIQAAGAFRKpF+LxaLB6V956TeXyyWT SdXL1hyRgUdHRuKJxKJ/q1kGdrnc2WyWDAwAUB0BGABQKZvN6nBI3/w8PDzyzDPP yFhkTqVSDXjo91R88061Ej4+Pr53796dO3fInobL5Uql2AgNAFAZARgAUBFtel+J 9Pvzn/989+7dqldOJpMN1fB5WYVCYXxiIhqJnOoJR44cueKKK2RnYLphAQBkIAAD ACpS6n0l++Lf//bf/viGG25Qvez09HQ+n1e9bK3zBwJ+n2+J8HnXXXcdOzYobwKl lxPdsAAAqiMAAwBWT1GUtra2bdu2Sh2lq2v9gQMHVC+bSCQatuHz0ua6Yfl84VNc C1xy2WWXzczI/eyNjIyKrxGLwAAAFRGAAQCr19zc3N/fJ3WISCTqcrlUL8va79JE Bh4ZGUmcohtWyec+9znZDbEGBpyZTEbqEACAhkIABgCskqIoIgDb7b3yhhgeHjly 5IjqbZ/pelUOr8/nP3U3rDXzTaHPP/98qYeB3e5BEYBZBAYAqIUADABYJQ2Wf88+ +5P79+9Xt2Y6nWZRsRyFQmFsbEyk3CWe88ADD/z6169LnQaLwAAAFRGAAQCrocHy r4yjvzMzM/F4XN2adczn989diTQ7u8RzZB8GZhEYAKAiAjAAYDVkL//6fP5XXnlF 3c3PBoMhEokssacXCyx7JdKa+Y3QX/rSlzZv3iRvGiwCAwDUQgAGAKyYohibm61S l38///kv7NmzR8WCiqJwr+wq+AMBn9c7u+Qi8IEDB5599hl5c5hfBE7PzCw1BwAA ykEABgCsmOzlX9U3PxuNxunpaRpfrUKhUJiYnIyEw0s/TfZGaBaBAQCqIAADAFZG UZTW1pbt27dLqi9j8zONryrhDwT8Pt/Si+eyN0IPDw9PTydZwAcAVIgADABYGdnL v6p3fi4Wi9FoVMWCjaZQKEx6POFQaOmnye4IzSIwAKByBGAAwAooitLW1rZt21ZJ 9dPpzBtvvKFiQaPRGIvFRIRTsWYDKmcRWLjgggs6OtZJmsPIyGgikWARGABQCQIw AGAFmpub+/ocBoOsbx/f+Matu3fvVquamGcymeTob+XKXAQ+evTovffeI2kOxWLR 6XSxCAwAqAQBGACwAl2dnZu3bJZUfPPmLT/96U9VLMjmZxWVuQh89dVXp1JJSXMY HxsPLdeOCwCAJRCAAQDlUhSjxdLscNhlFB8eHjly5IiKva/Y/KyuMttBi8/5+eef v3PnDhlzcLnc2WyG+5AAAKtGAAYAlMtiseza1S+puMPRd99996lYMJVKsflZXeXc CSzceOMNkUhE0hyOHh3gywoAWDUCMACgLIqiWK3W3t6dMorLWP4NLXdgFStVKBTG Jyaiy4VbqYvAg4PH0uk0rbAAAKtDAAYAlEVq+yt1l39FVk8kEqwTyuDz+31eb7FY XPpp8haBaYUFAKgEARgAUJa1a9du375NRmXVl38LhYIIwGpVw4nE53Z0bCweiy39 NKmLwOIFE1tuAgAALIoADABYnqIoFotFUvsr1Zd/RTrK5/NqFcQCHq/X7/Mt+zR5 i8DzrbCy7IIGAKwCARgAsDx5+59VX/4V0SiVSqlVDScLTE35fL6Z5dpry1sEZhc0 AGDVCMAAgOWJANzf3yej8rp1HY8//rha1YxGYzQaZW1QqjLvQxIuueSSYlHKlUUD A04CMABgFQjAAIBlzF3/a7Y4+hwyin/jG7fu3r1brWrpdJpcpAF/IOD1eJZthXX0 6NF7771HxgRcTlc2l+VCYADAShGAAQDLkLf/WcTVN954Q61qRqMxEokse0stKjfX Cmt0NB6PL/vMCy64oKNjneoTYBc0AGB1CMAAgGW0tLTY7b0yKp999if379+vVjUR h9LptFrVsLQJj2fK71/2aQ888MCvf/26jAm43YPJZFJGZQBAHSMAAwCWYTabzzxz l+plh4dHAoGAWtUURYlEIpz+1czcLmivt1jGevunP/1pGa2wjhw5msvlVC8LAKhv BGAAwFKMRqPZ3NTf36965Y0bex5++GG1qoksxHqglsq8EFi48sorMxn1V+YHBgZy uTw73gEAK0IABgAsZd26ddu2bZVR+atf3XfOOeeoUspkMsViMdYDNVbmLujDhw// 4hePypjAyMhoNBqVURkAUK8IwACAU7LZbHZ7r4z2Vz6ff3R0VK1qs7OzsTKWIqGu MntBC5/97Gc3b96k+gTE0G73INc+AwDKRwAGAJySvACs4v5nMb14PF4oFFSphvLN 7YIeGYknEss+U9IuaAIwAGClCMAAgFOyWq0Oh11GAFZx/7OYXjgcVqUUVmp8YiI4 NbXs0yTtghYB2OVy0/obAFA+AjAA4JQ61q3bKuEAsLr7n0X+4T7YavF6vT6fr5xn StoFPToyGuEYMACgbARgAMDibDabw2GXUVnF/c8mkykajebzeVWqYaUCU1Nej6ec VsySdkELLpebXdAAgDIRgAEAi5MXgM8++5P79+9XpVSxWKQPcBUVCoWx0dFYPL7s Mx944IFf//p1GXMgAAMAykcABgAszmq19vU5ZFT+j//4lSp1DAZDMpnMZrOqVMPq lHkMWNi/f5+MCTidLo4BAwDKRAAGACzCZDKZzWYZK8DpdOaNN95QpZSiKJFIZGZm RpVqWB2P1+sv7xjwBRdc0NGxTvUJuFzuXC5HG3AAQDkIwACARcjb/+xw9N13332q lOL6Xz0o/zbgG2+8IRKJyJgDu6ABAGUiAAMAFiEvAH/+81/Ys2ePKqWSyWQul1Ol FFatUCiMDA8npqeXfeaBAweeffYZGXMgAAMAykQABgAsQl4AVusAsMlkikQibHzV g9GxsXAoVM4zJR0DJgADAMpEAAYALEJSAI5Eoi6XS5VSBoMhHA6rUgoVKr8P1uc+ 97nu7tNVnwABGABQJgIwAGARzc3N/f19qpddt67j8ccfV6VUJpOh969OTHq9gfL6 YF1yySXF4vKXBq/UwIBTvB5ULwsAqD8EYADAIiwWy65d/aqXfd/7zrrjjjsqr2Mw GGKxGP2fdcLn93s9nnKe+c1vftPrLeuZK3L06AC3YQEAykEABgAsZDQazeam/n71 A7BaHbAURQmHw7Oz6q8lYhUCU1MiAJfz5ZDUB2tgYCCXy/N6AAAsiwAMAFhIXges n/zkJ1u2bFWllKQLdbAK5TeCDgQCt9zydRlz4BgwAKAcBGAAwEKSAvDw8IjIP6qU ymazpB1dGRkZKfNXEp/+9Kd37tyh+gQIwACAchCAAQALSQrA+Xzh1VdfrbyOwWBI JBL5fL7yUlBL+TchfelLX2pvb1N9AgRgAEA5CMAAgIUkBWC1WkCbTKZoNEoA1pXy b0KS1AiaAAwAKAcBGACwkM1mdTgcqpd1OPruu+++yusoihIMBiuvAxVNTE5Olbe/ /cYbb5BxftvlcqVSXIsFAFgGARgAsJDVau3rUz8Aq3UHUrFYjEajldeBisq/CljS TUhOp4t7oQEAyyIAAwAWknQJsFp3IOVyuWQyWXkdqMjj9frLC8CSbkLiKmAAQDkI wACAhZqbLbq9BNhgMIj0S9TRG5/P5/V6y3mmvKuAMxleFQCAZRCAAQDvoCjKunVr N2/erHrlb3zj1t27d1dYRATgeDxeKBRUmRLU4vP7vZ6yNjYfPXr03nvvUX0C4+Pj 0WhsZmZG9coAgHpCAAYAvIOkFtDCf/zHryovYjKZRABmBVhv/IGARwTgYrGcJ+/f v0/GHGgEDQBYFgEYAPAOLS02u13XATgcDrPQpzciAHs9nmJVA7Db7U4mCcAAgKUQ gAEA76DzAMwdSPokArDP652dLeuCXwIwAKBaCMAAgHfQeQA2GAzhcLjyOlBXYGrK 5/PNlHc2mwAMAKgWAjAA4B10HoCFSCSiSh2oqFAojAwPJ6any3kyARgAUC0EYADA O+g8AM/OzsZiscrrQHXDw8PRaLScZxKAAQDVQgAGALyDzgNwoVBIJBKV14HqCMAA AP0jAAMA3kHnATifz0+Xt88WGiMAAwD0jwAMAHgHnQfgXC6XTCYrrwPVEYABAPpH AAYAvAMBGKtDAAYA6B8BGADwDjoPwNlsNpUi5OjR8NBQtLz+ZARgAEC1EIABAO9g s4kA3GswqP8N4oUXXjQajRUWYQVYn8q/Bml2dvbSSy9RfQLFYtHtHuSXIwCApRGA AQDvoCjKunXrNm/epHrlm2/++gc/+MEKi9AFWp8CU1M+n2+mUFj2mW+++eb99/9Q 9QmMj09Eo9GZmRnVKwMA6gkBGACwUHOzpb+/X/Wyf/M351144YUVFhEJJx6PqzIf qMgfCPi83tnZ2WWf+eijjz733GHVJzAwMJDJZFUvCwCoMwRgAMBCFotl1y6dBuBi sVhmpyVoSQRgr8cjvjrLPlNSAD56dCCbJQADAJZBAAYALGS1Wvv6HKqXfc973nvn nXdWWMRgMITDYVXmAxWJAOyZnCznmbfeeqvP51V9Ak6nK51Oq14WAFBnCMAAgIUk BeDeXvv9999fYRFFUYLBoCrzgYp8fr/X4ynnmTfccL2MNXwCMACgHARgAMBCNpvN 4VD/JqT29rUHDx6ssIjJZAqFQuWcNYWWfD6f11vWuu6+ffsktBhf43K5aQENAFgW ARgAsJCkAJzL5V977bUKi4gAHI1G8/m8KlOCWjxer9/nK+eZF1544bp1a1WfAAEY AFAOAjAAYCFJAfjYsaGpqakKbxgWHx6LxbjtRm8mvd5AGQG4WCz+5V/+pd3eq/oE CMAAgHIQgAEAC0kKwMIPf3i/3V5p5WQymcvlVJkP1DLh8Uz5/cs+bXJy8rbbviVj AgRgAEA5CMAAgIWMRqPFYpHRB+uzn/3riy66qMIiIv2KDKzKfKCW8YmJ4NTUsk/7 +c9//uKLL6g+utPpymaznAwHACyLAAwAWISkq4Df9a5333XXXRUW4SpgHRodGwuH Qss+7ZZbbgkEll8oXikuAQYAlIkADABYRHNzc39/n+plW1pan3rqqQqLKIoSCoVE DFZlSlDF6OhoOfczX3zxxYpiVH30gQFnJpNRvSwAoP4QgAEAi5B0DDgUCg8ODlZY xGQyxeNxVvz0o1AojIyMJBKJZZ953nnnbdjQrfoEOAAMACgTARgAsAh5fbCefPLf 29raKqlgMBiSySQBWD8CU1M+r3fZ1tzpdPqqq66UMQECMACgTARgAMAi5AXg//k/ /+of//EfKyySz+enp6dVmQ8q5/P7vR7Psk976KGHXn75JRkTIAADAMpEAAYALMJk MjU1NcloBL1ly9af/OQnFRYxGo2hMlouQRten8/n9S77tGuuuSaZVP/XFk6nK5/P FwoF1SsDAOoPARgAsDhJfbDi8cTRo0crLCLyeSwW4zZgnZj0egM+37JP+8IXvnDa aetVH50OWACA8hGAAQCLs1qtMlaAhccee7yjo6OSChwD1pVyLgFOJBLXXvs1GaM7 na50Oi2jMgCg/hCAAQCLk3cM+E/+5E+vvfbaCosUCoVy2g5DA+VcAnz33Xe7XE4Z o3MAGABQPgIwAGBxIgDb7b0Gg/rfKTo6Oh977LEKi3AbsE4UCoXRkZH4cr+MuOSS S4rFWdVHFy8At3uQAAwAKBMBGABwSuvXr9+06QzVy46Pj4+MjJrN5kqKiGQej8dp fVR1gakpr9c7u+QdSPl8/txz/3rbtm2qjz4xMRkMBlUvCwCoVwRgAMApWa1Wh8Mu YxH485//wp49eyosksvlksmkKvPBqpVzB9KBAweeffYZ1YcuFosul5sDwACA8hGA AQCnJG8XdHv72oMHD1ZYxGg0hsNhdkFXVzktoPft2yfhRcT+ZwDAihGAAQCnpChK U5Opv79f9crj4+PDwyMWi6WSIuyC1oNlW0Dncrn/9b/OlbH/eWBgIJ8vzCy5+xoA gBMRgAEASznttNN6ejbKWAT+m78578ILL6ywCL2gq2uuA9bYWDwWW+I5jz766HPP HVZ96GKx6PF4p5a7fgkAgBMRgAEAS1EUY1NTk4xFYJut5dChQxUWURQlHA7Pzqrf XhjlCExN+bzepddgL774YvEqUn3o+eXf/MwMX3oAwAoQgAEAyzCbzWeeuUv1si6X e2hoqKOjo5IiBoMhmUxms1m1ZoUVWbYD1vT09LnnntvX51B96CNHjuZyOdXLAgDq GwEYALCMtWvbt23bJmMX9B/8wR9+61vfqrxOJBKpvAhWYdLjCfj9Szzh29/+9vj4 mOrjFovFkZGRWCyuemUAQH0jAAMAlmE0Gs1mKbugQ6HwwMCAyWSqpIj48Hg8ziJw VYyNj4dOfQ3vzMzMF77whQ0bulUfV7xscrk8W98BACtFAAYALM9isezapX4AFi64 4MLzzjuvwiJcCFwVcx2wRkbip25C9sQTTxw69JSMoY8eHeBXHgCAVSAAAwCW19ra 2tu7U0blYnHNr371qwqLGI3GSCTCeqDG/IGA1+NZ4h7miy66qLW1RcbQg4PHpqen ZVQGANQ3AjAAYHnydkG7XO5Dhw695z3vqbBOMpmkJZLGJr3egM93qr89duzYV77y FRntr9j/DABYNQIwAKAsNpvN4bDLqNzevvbgwYMVFjEYDOFwWJX5oExLHwDet2+f hL5pc1wudyqVklIaAFDvCMAAgLJ0dXVt3rxJRuWBgYFDh55+3/veV0kREYDj8Xih UFBrVlia+FSPDA8nTrEPeXBw8Ctf+T8ytgwI4+MToVBIRmUAQN0jAAMAyiJvF7TQ 1tb+5JNPVlikWCxGo1FV5oNl+f1+r9d7qgPA8pZ/2f8MAKgEARgAUK62tradO3fI qCxSzVNPHTrrrLMqKaIoSjwe5ySwNiYmJ6cCgUX/yu12X3zxVyT9ruTYsaHEqftO AwCwNAIwAKBczc3NfX0Og5ylvaYm8+HDhyssMjs7G4vFVJkPljB3AdLoaDweX/Rv 9+7dazY3yRi3WCw6na5MJiOjOACgERCAAQDlUhTFarVKuw+peMUVV37sYx+rpIjJ ZBIBmEVg2eYuQPJ6i4vtQ37ppZceeuinkn5LMjh4LJ1Oz8zMyCgOAGgEBGAAwApY LJZdu6RsbV0zf8z42WcPixBbSZFCocAWWdkmPJ4pv//k94tounfvP1qtVknjHj06 kM1mJRUHADQCAjAAYAVERhUZWMblriWf/OQ5+/btq6QCJ4FlKxQKY6OjscX2Pz/4 4IOvv/6apHGdTpdIv7S/AgBUggAMAFgZefchCT6f/1e/+lV3d3clRVgElmpu/7PH c3L/50gkctFFF8l7bXD7EQCgcgRgAMDKSL0PSejttd9///2VVGARWKpT9X++4Ybr 5V1Dxe1HAABVEIABACvW2dGxZesWScUHB4/97Gc/+9CHPlRJERaBJRGf2JGRkZM/ t2+88cZVV11lt/dKGndsdCwciUgqDgBoHARgAMCKWa3NDoes+5CETCZ76NChzs7O VVcwmUzxeJyGSarz+f0+r3fB/meRhy+++OJ169ZKGlQM53K50mluPwIAVIoADABY MUVR2tvatm7bKm+IM8/8nbvvvruSCtwJrLq59lfj47GT9jnffPPNweCUvHFHR0bj iQS3HwEAKkcABgCshtVqdTjs8haB3e7Bhx566I//+I9XXYGTwKrzBwI+r3fBQdzX X3/96quvFi8GSYPOL/+60+m0pPoAgIZCAAYArIYGi8DpdObAgQObNq2+q7DI5+Fw WMUpNbJCoTDp8YTf2Yc5GAxedtllHR3r5I3L8i8AQEUEYADAKsleBF4zd+XSepGB V/3hYm7xeFwkNxWn1LACU1M+n2/mnZ/Mf/qny6R+eln+BQCoiwAMAFglo9G4tr1d 6iKw8N//+8euuOKKVX+4mCSXx6pi0uMJ+P0nvue+++47cuQtqYOOjozG4nFuPwIA qIUADABYPREvLRZLX59D3hDDwyMPP/zwBz7wgVVXSKVStIOu0Mm3H7311ltXXnnl zp075A3qdLrEF470CwBQEQEYAFAREYB37eovFovy9kInk8mHH/55b+8q75hVFCUc DpOjKuHx+QI+3/HbjyYnJ6+88oquri5Jw5VeTkePDvCbCwCAugjAAICKGI3G5uZm u71X6mFgq9X26KOPtra2ru7DC4XCiauXWJEFy7/pdPryyy83mRR5I4oA7HYPZjIZ fm0BAFAXARgAUCkRgPv7+2SPsnnz5h/96IGmpqZVfCxXIlXC4/UG/P7S8q8Iw9dd d10qlZQ96MCAUwRg2aMAABoNARgAUClFMba2tm7fvl32QO9//+5bb711dR9LN6zV yefzoyMjienp0h/vuOOOsbFR2YMODw9PT0/PzLD8CwBQGQEYAKACq9UqtRVWyfDw yBVXXPHFL35xFR9rMBiSySRnSlekUCh4vN5wKFRa/n3kkUfuu+8+qY2vSpxOF1cf AQBkIAADAFSgKEpXZ2fPGT2yBxoaGr7llls++9nPruJjxSRDv81yKIc/EPD5fLMz M+Lxk08+eeedd/b27pQ9qGfSEwqHZ+YHBQBAXQRgAIA6FMVosTQ7HHbZA/n9gdtu u+3P//zPV/GxIlbF43HVp1SXCoXC+MRENBIRj1988cXbb79906YzZA/qcrmz2Qyb nwEAkhCAAQCqsVqb+/qkd8MSQqHwLbfc8hd/8Rcr/UCj0ZhIJOiGVQ7fvGKxKNLv nXfeuWFDtwaDOp3OdJreVwAAWQjAAADVKIrS3ta2ddtWqdcCl4gM/PWvf/3jH//4 Sj9QTDIYDMqYUj0pFAqjIyPxROKFF1747ne/Kzv9ll4woyOjYkQ2PwMA5CEAAwDU JOKlxWy2O+yyA/Ca+Qx80003nX322Sv9wGw2m0qlZEypPhzvffXcc8/9y7/8iwZr v3MX/7rc2VyO9AsAkIoADABQmTYdoUuGh0c+8IEP3HzzzTt3rqA5E9cCL83n97/2 6qvf+c53jhw5okHP5xI6PwMANEAABgCoTMTLjo4ODRomHVcsFiORqMPhePe73/3R j370v/7X/1rO+nNkvr0TSsTn8Pnnn//3f//3t956y+VynX76aRqs4R83MTEpvhws /wIAZCMAAwDUJzJwc3Oz3d5bldHHxsa3bNmyY8f23/3dd334wx9+//vfv2iWS6VS jXwtsEi8L7/88jPPPDMwcHRkZHRiYmLr1i1VmYnbPZjJZEi/AAANEIABAFJouRF6 aUNDw5s2bdq4caNIxQ6H4/d///d3795tMpkaaiN0oVB46aWXXnvttcHBwcnJSZ/P 5/V6d+zYXu15zWHzMwBAMwRgAIAUc92wLBYNrgVeBZfL3dXVtX79+tNOO62jo6On p2fz5s12u33Xrl2tra3Vnl1Fpqenjx496na7x8fHPR5PIBAIhULhebr9WmSzWZZ/ AQDaIAADAGQ5fitStSdSrmKxODY2LjJwe3u7eNs2Tzxeu3btunXrOjs7RWYWb7u7 u8UDEe81m5iIiMFg0O/3ixwrHoi30Wg0FovF4/HEPJF7xWPxdsuWzVqe3a0Q9x4B ADRWM98jAQC1qHQrkkMfe6HV5XK5m5qazGazSMJm89xD8X9Go9FkMom34h9e2mUt Hi9RZHZ2VsS/QqEg3orH4oF4m5+Ty+XyIvfO/b98Xp+LtxVyOV3cewQA0BgBGAAg l81mq8v8hgq5XG5uYwYAaIwADACQy2QyWSyWanWEhj653YPZbLZQKFR7IgCAxkIA BgBIpyiK2WzWSVNoVJ3T6cqx+RkAUA0EYACAFhTFaDZbyMCYT7/ZmZnZak8EANCI CMAAAI2IDNza2rZ9+7YqzwPVMzw8Mj2dIP0CAKqFAAwA0I6iKG1tbdtq52IkqGhk ZDTBpUcAgKoiAAMANMV54MbEuV8AgB4QgAEAWiMDNxrSLwBAJwjAAIAqEBnYYrFw P3AjcLsHM5kM6RcAoAcEYABAddhsVoeDReD653K5Uql0tWcBAMAcAjAAoDpsNhsr wI3A5XKnUqlqzwIAgDkEYABAdVitVo4BNwKn05VOswIMANAFAjAAQGs2m23NmiL7 nxuHy+USP3KwDgwAqDoCMABAO4qiNDc39/buNBj4BtRYisXi4OAxumEBAKqLnz8A AFpQFKPZbBEP2PbcyJxOl3iby2VnZmarPRcAQCMiAAMApLPZbE1Npu3bt1d7ItCF 4eHhfL7AjmgAgPYIwAAAiUT0LRaLrPriZE6ny2DgYDAAQFMEYACAFEaj0Wq12u29 1Z4IdM3tHkyn07Oz7IgGAGiBAAwAUJmiKBaLhYVflKm0FJzNZumPBQCQjQAMAFCT zWYzm83btm2t9kRQY0ZGRnO5HDuiAQBSEYABAOpQFKPF0uxw2Ks9EdQwl8udzWbo EQ0AkIQADAColKIoZrN5zZpiX19fteeCmud0OsXPJ7lcjh3RAADVEYABABWx2Wwt LS1nnNFT7YmgrkxOepLJJDuiAQDqIgADAFZJUYzNzc12O3ueIYvb7c5k2BENAFAN ARgAsBo2m81kMu3Ysb3aE0GdGxoaLhQKLAUDAFRBAAYArIzRaLRYLFxxBC05na5s Nst1wQCAChGAAQArYLNZ5y/4raVmV2LCgcBUe3t7JBLZuHGDwdC43/vEp2J8fKK1 tTWdTvf0bKytT4XT6RQTTqXS1Z4IAKCG1dJ3PgBAFZVaPdfWwq/Ie2az5bLLLvvo Rz9aek80Gn3llVfeeuutkZERn88XCoXC4XAsFhPv37Zta20FwlMR/+qhoeGWlhYR dNvmdXZ2dnd3b9261W63i3eWnvbyyy//67/+q9ncVFv/aqfTRYNoAMCq1dL3PABA tdTcwq+YrdFo3L//kk984hNlfkgikTh69Ojw8JDX6/P7/ZFIJB6PT09Pl3oRZzIZ 8SAzL5fLav+pcDqdTU1mi8XS3Nxss9lKb61Wqwi6IuKuXbvWJh60tHR0dm7evFm8 v8yyL7zwwgMP/Eg8v4ZiMEvBAIBVq5nvdgCAqqjFhd9cLn/xxRd/5jOfkTeEiMHB YDAUCkWj0VgsJgKziMfZbLZQKIi3uVxOPMjn8+KBiOJL1BFBTnx6m5qaTCaTeCDy rXhgmdfe3r52XmdnZ1dXl3jPsrMSI05MTsai0aUHPdnTTz/94x//eO3a9hV9VHWx FAwAWAUCMADglGw2m3jrcNTMRUcihf793//Dnj17tBlOURQRd1OplH5imAjeXp8v HAqtol/UgQMHHn7430TYljExGVwut3hLg2gAQPkIwACARRiNc3f81lD0jUSif/u3 f7t3717NRhSfounpaRGANRuxTCIDB0Oh6URCTG+lS8HCQw899Itf/KK7+3QZc5NB xOBMJkODaABAOQjAAICFauuO36mp4Lnnnnv55ZeLRKrNiIqiJBKJZbc3V1c+n5/0 eKKRyComKcLk/fff/+STT/b0bJQxN9VxVzAAoEwEYADAfyodQLXbe6s9kbJ4PN6/ +qu/uvbaa5uamrQZ0WAwzMzMJJNJEbe0GbESc9uh/f5wMLi61VHx4XfffffTTz+9 Zctm1ecmg9s9WDqGXe2JAAD0iwAMAHib0Wjs6elZv74GjoCOjY1/8pOfvOmmm0qn lLUh0m88Hq+tfFXaDp1MzO2HXt16tYiU3/3ud5977rnt27epOzcZgsGQx+NhOzQA 4FQIwACAOSJJioCn/7XfwcFjH/nIR2677bbOzk7NBlUUpXQHkp73PC+hku3QJSJB i8/5K6+8ov9XiNs9KP6ZbIcGACyKAAwAjU6ku+bmZv0HG5Fq2trav/e9723btk2z QQ0GgxhXpN9cLqfZoDJUuB26xOfz3XLLLQbDGv1fGixicCaT0U93bgCATuj9GxgA QKpauea3WFxz1VVXffSjH9VyUKPRWGp2peWg8ogMHJrvDr3q7dAlL7/88r333tvS ot3m89XhomAAwMkIwADQuGqi23Mymdy79/+cd955Wg6qKEomk0mlUvV3mrTy7dAl TzzxxE9/+hOdXxpMd2gAwAIEYABoUK2trTt37tDzXtapqeDnP//5Sy65RONJiuGm p6frZuH3ZCIT+vz+UCg0W9nqqIjQDzzwwGOPPabn25LEJI8dGxJf0GpPBACgC/r9 uQcAIMn8oV+L3W6v9kROaXh45JxzzvnmN79pNpu1HNdoNIqklM1mtRy0Kt7eDj09 tyG6wqXgfD5/xx13HD58eOfOHWpNT3VutzuTybIdGgBAAAaAxqLzQ78ijK1du+7e e+/duFHTRUWDwVDaK1tbtxxVSK3t0IKI0zfddFOxOKvbPQUcCQYArCEAA0BDEem3 o6Nj06Yzqj2RxWUy2auuuuoTn/iExuPW4gW/alFrO3TJCy+8cO+9965bt7byUjJM TExGIhEyMAA0MgIwADQKm81mNBp7e3dWeyKL8PsD559//qWXXqrxuIqipFKpdDpd oxf8qkLF7dAlP/rRjw4cOKDP37MMDh6bnZ2lLRYANCwCMAA0BN22vDp2bOjjH//4 t771rZaWFi3HrZsLftWi4nboNXOL+Zlvf/vbzz//vA7vl6YtFgA0Mt39JAQAUJ1I vzpc+BU5pLnZ+sMf/nDLli0aD904za5WpFAoeP3+cDCo1uVPgUDgxhtvNJkUHf7m ZXDwGBkYABqQ7r4hAQDU1dLSosNVuFAo/NWvfvX888/XeFyRxPL5fCqV4iDoot7e Dp1IJKan1doW/stf/vLHP/7xhg3dqlRTkds9mEwmqz0LAICmCMAAULdMJpPFYtbb dUeDg8fOOeec22+/XeMrjtbMp99YLEb0XZa626FLBcVX/PDhw3r7XYzb7c5mc43Z /wwAGhMBGADqk6IoFovF4dBX+hX+9V9/tHOn1vuxxWcjmUxmMplGbna1IqpvhxY8 Hs/111/f0mJTq6AqXC6RgbkiGAAaBQEYAOqQohgtlmZdpd/JSc+FF16ofZ9nml2t msjAwfnt0NPqbYdeM98j+pFHHtm6VeuD30uYz8CZmRnVoj4AQLcIwABQb4xGY3Oz xeFwVHsibxPZqaOjU8Sezs5OjYem2VXl8vn8xORkLBpVMQMnEonrrrtudnZGP82x XC5XJpNVcbkbAKBPevnGAwBQhYh8Foulr08v6TcYDP7f/3vFueeeq/G4IlkVCoVU KsXxzsrNbYf2+cKhkLr58Mknn/zhD+/buHGjijUr4XS6slkyMADUOQIwANQPRTGa zXpJv8Visbu7+4EHHtT4gt818+k3Ho8TfVX09nboeHw6mVRxKTiTyVx33bUidupk KVhk4Fwuy15oAKhjuvh+AwConMlkMpvNOjn3GwwGr7jiyr/+67/WeFxFUVKplIhV rOPJMLcdemIiFoup20tMV0vBLpc7l6MvNADULQIwANQJm82mh/QrolFX1/qf/OQn ra2tGg9tMBiSySQnfqUSydDj9YZDIXUzcDqd/trXrhHF9bAULDJwKpWq9iwAAFJU /9sMAKByLS0terhhdXLS89WvfvWiiy7SeFxFURKJBNFXGyKm+gKBcDCo+tVBP//5 zx988EE9NIh2uweTyWS1ZwEAUB8BGABqnk7Sb1OT+Wc/+9npp5+u5aAGg2F2dlZk lXw+r+W4DU5k4FA4PJ2Yo+5ScDQaveqqqywWs4o1V4cMDAB1iQAMALWttbW1t3dn decwOHjs/PPPv/766zUe12g0igDGBb/VImLwhMcTDYfVzcDC9773vV/+8pdV/7WO eGFPT09Xdw4AAHURgAGghtlsNhESqntsMhKJPvjgg+9973u1HLR0y1EymVR9Fy5W ZO6GJL8/HAyq3nVscHDw2muv7e7WdEPBAiLYu92DnAcGgHpCAAaAWqUoitVqre7y b1tb+8MPP6xxvyuj0RiLxejTqxOSbkhaM98Z68orr6xuV6zBwWNiGvyeBQDqBgEY AGqSCIEdHR2bN2+q1gREMLjwwguvueYaLQc1GAy5XC6VSnHLkd5IuiFJuOeeex55 5JEqboceH5+IRCK85ACgPhCAAaAmWa3Wvj5HtUb3+wMPPvjgH/7hH2o5qMj80WiU tTjdKhQKk15vRO0bkoSBgYFrr/3aGWecoW7Z8jmdrnQ6Xa3RAQAqIgADQO2pbtvn QmHml7/8pZbdnln4rRVzNyT5/aFQaFbt31NEo9HLLrusrU3ry6WPoyk0ANQHAjAA 1BibzeZw2Ks1+oYNG//t3/7NaDRqNiInfmvL20eCE4np6Wl1l4JnZ2evuuqqbDaj Ys0VcbncNMQCgFpHAAaAWqIoRqvVVpXGV06n88ILv3jddddpNqLBYMjn88lkkoXf miPvSPD3v//9Rx99pK+vT92y5ZhviJWameHVCAA1jAAMADXDZDJt2LBh/fou7Yce Gxv/wQ9+8JGPfESzEY1GYzweFzlKsxGhrrkjwR5PRMItwS+//PJNN920ffs2dcuW IxgM+Xw+9iMAQO0iAANAzajW0d+pqeCjjz565plnajaiiEzT09PEjFon75bg0dHR yy+/vKdno7ply8FhYACoaQRgAKgNNptNpF+D5peiJhLTTzzxxKZNGt23pChKPB7P 5XLaDAfZRAb2T02FgsEZtX+dEQwG9+/fr/2GiGKxKDIwh4EBoEYRgAGgBhiNxs7O zk2btL4GplCYOXToUHt7uzbDiX9mIpEg/dYZkYFD4fB0PJ5Quy2WSKEXX3yx9q2h JyYmw+EwR9MBoBYRgAGgBlRl83NTk/mpp54ym80ajFW66CiZTKp+XhQ6MdcWa3Iy Fo2q+yUWZfft22c2N6lYsxxshAaAGkUABgC9q8q9RzZby8GDB00mkwZjsfDbICS1 xZqZmdm/f7+iaHc1Vwm3IgFALSIAA4DenXFGz2mnnabliO3tax9//HFtLvs1GAzT 09Ok3wYhMrDH6w2HQqpfEXzppZeuWaPp9oGpqanJSY+WIwIAKkcABgBd0375d926 jscee0ybblsiDk2rfS4UOiepNbR4FYkMXCxqei6XRWAAqDkEYADQL0VRRADeuXOH ZiO2t6994oknNEi/bHtuZCID+wKB0NSU6hn4kksu0XId+NixIRGAZ2ZmNBsRAFAh AjAA6JfVau3rc2g2XFOT+emnn9bg3K8I9iL9ZrNZ2QNBt0rXIwVFBlY1PYosevHF F2vZE8vpdKXTac2GAwBUiAAMADolUmJTk6m/v1+b4YrF4uHDz2nQ89loNMbj8Xw+ L3sg6NzbVwRPTam7gipeWnv3/mNLS4uKNZcwMDCQzxdYBAaAWkEABgCd0vLqo3Q6 /cILL2qQGUTMFumXC1RRIikDZzKZ//2//6Gjo0PFmkvgSiQAqCEEYADQI5vNJtKv Np2opqaCzz///IYNG2QPlM/nuekXC0jKwOFw+Mtf/nJPz0YVa56KeEmLDEw3LACo CQRgANAjzU7/jo2NP/HEE+9617tkD5TNZkkIWJSkDDw8PLx///7t27epWPNUOAkM ALWCAAwAuqMoisVi0eD2I5fL/eCDD/7Zn/2Z7IFENshkMrJHQe2SlIFfeeWVr33t axr8Lkn8p5TNZjkJDAD6RwAGAN3R7O7f979/96233ip7lFQqRcNnLOvtvtCBgLpH xO+4446xsVEVC54KdwIDQE0gAAOA7nR3d2/cKP1ErtlsefbZZ2WPQvpF+ebuB/b7 g1NT6h4U37t3rwYXI3m9Yu5+2aMAACpEAAYAfdFm+Tccjrzyyivt7e1SR2HnM1ZK ZGCvzxcKBlXMwKlU6ktf+tKGDd1qFTwVFoEBQP8IwACgLxq0v3K7Bw8ePHjWWWdJ HSWXy3E3DFZBZOBJjycSDquYgd1u9759+2T/aolWWACgfwRgANCRpqYmEYB37Ngu dZTf//0/uO2226QOMTs7G4vFpA6BOiYy8OjYWFzVl9Dtt98+MTGuYsGTDQ0NiwCc z+eljgIAqAQBGAB0RIP9z5lM9vXXX5d6w7DRaIxEIuq2MkKj8QcCfr9/plBQq2Cx WPziF7+4bt1atQouil3QAKBzBGAA0BHZ+5/FT+fPPPOM1Ft/RfqNx+MsgqFCc02h A4Gpqamier9JGR4e3rt3r9T/xNgFDQA6RwAGAB2RHYB7e+3333+/vPoGgyGRSJB+ oQqRgT1ebzgUUvEw8A03XB+NRtWqdjICMADoHAEYAPTCZrM6HBLTr8fjPXLkSFtb m7whRPSdnp6WVx+NZu4w8OhoPB5Xq2AqlTr//PO3bNmsVsGTuVyuVIoMDAA6RQAG AL2QfQD4gx/8o5tvvllefYPBEI1GOfoLdfn9fp/Pp+Lr6rvf/e7w8JBa1U7GMWAA 0DMCMADohdQA7PP53W632WyWVF+k31gsNjMzI6k+GtbcRmifL6zezcBvvvnmFVdc Ybf3qlJtgclJTzgc5j8EANAtAjAA6IXUA8BnnfX/ffvb35ZUfM18SkkkEvLqo5Gp uxFa1Lnpppvy+Zwq1RYYGhpWccM2AEB1BGAA0IvmZkt/f7+MyoODx1wuV1dXl4zi a+Y7P0ejUVa9II/P7/d5vWotAh84cODZZ59RpdQCLpc7m83MzHAQAAB0igAMAHrR 0dGxdesWGZVttpZDhw7JqFySTqczmYy8+kChUBifmIhGIqpUGx8fv+aaqzs7O1Wp tgCNoAFAzwjAAKAL69at3bp1q8Eg5X+W/8f/+PPLL79cRuU188u/4XBYxYtqgEX5 A4G5blhqbDRIJpO3335bRKU4vcDAgJPfBwGAbhGAAUAXWlpsdrusDlg/+ME9u3bt klQ8nU7PzKP/M6QqFAqTHk84FFKl2kMPPfTyyy+pUmoBAjAA6BkBGAB0QV4L6OHh kUAgIKPycSaTSbwtzhMx+HgeFm9L7zQajeIJpfdLnQnqmz8Q8Pv9M4VC5aWeffbZ Awd+UXmdkxGAAUDPCMAAoAvyArDX6xsbG5NRuRylTd0iAB/f3S2C8fGcfPztgpxc ek+15gzdKhQKXp8vpMaVSK+99trVV18to+86ARgA9IwADAC6IG8L9MDAwJtvvrV5 82YZxdWyRE4+MSqvmV9nPjEns++60YgMPDI8nJierrAOW6ABoDERgAFAF+StAK+Z b/nz9NP/b/369ZLqa+bknHx83/WCnFzafW0ymY6/v5rzhqo8Xm/A769kEfiNN964 8cYbN2/epOKsjiMAA4CeEYABQC+kZmCfz3/ppZfu2bNHUn1dOR6PFUUpPSj+1onn k9fMrzOznlxzKlkETqfT991338GDB3t7d6o+sRICMADoGQEYAPSip6fn9NNPkzqE CHtf/eq+s88+W+ootWLR9eTS1usFfbzEAxaTdWXC45ny+1f0Iblc7pFHHnn88ce6 urokzWrN/EvI5XJzDzAA6BYBGAD0orm5ub+/T4OBstncpz71qb1799psNg2Gq3Wl eHziYvKJIfl4Qj6x0zUdvGSbawft85XZVDwUCv3oRz969dVXu7tPlz2xwcFjqVSK 35IAgG4RgAFAL6xWq4yetKcyPDzy3ve+98Mf/vAXv/jFtrY2zcatP6fq4DVzgtIG bJGiSciqKBQKE5OTkXB4ieeMjY0dPHjwN7/5jXig2X9ZY2Pj4SVnBQCoLgIwAOiF 1DPAS3C7B+12+7vf/e4//dM/OeecTzU1NWk/h7q3YBn5xLugBBHnSMgr5Q8EfF7v grXW6enpp59+WoTeoaGhrq7O47+S0EwoFB4fH9d4UABA+QjAAKAX1QrAJxocPLZt 2za7vfd3fud3P/ShD/3RH/2R9hGiMS2akBesIZeOIpOQSwqFwvjERMDvf/XVV996 6y0ROz2eyWAw2NenxTmCU6EDFgDoHD/WAICObNjQvWHDhmrP4j8NDQ2fccYZGzdu nE/F9rPOOusDH/gAS8RVcXJCPr6AfOI5ZPFAJMN6PYMajUZffPHFI0eODA0NTU5O TkxMhEKhqv/a6Dg6YAGA/hGAAUBHND4GvApOp7Ozs0tYv3796aef3tPTs2XLFofD 8b73va+jo6Pas2tcC84hn3g38vGO1rWygCzmFggEfvOb3xw7dkykXL/fFwyGwuFw MBjs6dmo5y0JExOTkUikzNZcAICq0O93EQBoQHrYBb1qw8Mj7e3tbW1ta9euFW/F 43Xr1omo3NnZKaJyd3e3SMubNm2i4VZVlLOALJ5T2nctaQFZFI/H4555U1NToVBI xEWRbBOJeCwWTyaTid+Sd0mvVAMDA5lMttqzAAAshQAMAPqiwW3A1eV2D1osFuuc ZrPZ0tzcLP4o3prnNM0/nHuP+EPp/aU/mkwm8aCpqUk8aGlpEQ/EU6xWm3jQ2tp6 Yn2Rwav1T6tlb/88kEql1vx2ATmfz4ssms1mRTTN5XLij+JBoVBIp9PisXiQEWnv t3Lzjj8WTxB/W3pPPp9LpzPio8Qfa/f3O8ti/zMA1AQCMADoS00vAgMNy+fzTU0F 2f8MADpHAAYAfTGZTG1tbVu3bqn2RACsgNPpYvkXAPSPAAwAusMiMFBbPB5vKBRi +RcA9I8ADAC609Rk6uzs2rhRR/chATgVTv8CQA0hAAOAHrEIDNSKYDDk9XpZ/gWA mkAABgCdammx2e1kYEDXhoaGk8kk6RcAagUBGAB0ymg0dnV1nXFGT7UnAmBxbH4G gJpDAAYA/VIUpanJ1N/fX+2JAFiE0+nK5XIs/wJADSEAA4CucRgY0Ccu/gWAWkQA BgC9a21t6e3trfYsAPyniYnJSCRC+gWAmkMABoAa0NLSYreTgQFdGBsbi8XipF8A qEUEYACoDa2trb29O6s9C6DRsfYLADWNAAwANUNk4J07dxgM/E83UB1ery8Y5Nwv ANQwfooCgFpis9kURRExuNoTARqOy+XKZun5DAC1jQAMADXGaDRaLJa+Pke1JwI0 CqfTJd5y4xEA1AECMADUJJvNViwWicGAbOPj49FojOgLAPWBAAwAtUpRFIvFwi3B gCSDg8dE7s3n84VCodpzAQCogwAMALWNpWBAdU6ns1hcI6IvC78AUGcIwABQD0QM bm1p6Tmjp9oTAWob0RcA6hsBGADqh4jBa9YUHQ5Wg4EVK214ptMVANQ3AjAA1JvS pmhFUXp7d1Z7LoDeif9Y/P5APB7PZrNEXwCoewRgAKhbpSRsMBholAWcbGJiMpVK ip+FUqlUtecCANAIARgA6lypWbRIwmZz0/bt26s9HaCaxH8IU1PBaDQqHpN7AaAB EYABoIHMHxJeMzs7azabd+wgDKMhiNA7OelJJpMGw9yPPeReAGhkBGAAaFClMCyy wdq17d3d3aVsANQHl8s9MzNjNBoJvQCAE/HjDgDg7TAsiLBgt3NgGDVpaGg4n88b 5qzJZnOFQqHaMwIA6A4BGADwn0QSpmMWatTExEQwGKr2LAAAukYABgD8J6vV2tfH NcKoSYODx1Kp1OzsbLUnAgDQLwIwAOBtTU1NFotF3u3BAwPO/v4+ScVRE4rFotPp kvcyEK+xTCYjqTgAoA4QgAEAb5O6/3lw8NjY2Fgul/POi0QisXnJeel0OjMvn89n s+JtIT+vUCjMzMyIBzPzZueIP869U0SpbDZbeufxUeb+emZG0j+h7hkMBkVRTmyH psxramoyGo1NTSZFMYkHpU++eJrJpBiNpacopjnimeameeZ5Vqu1ubm5paVFvLTW rl3b2dm5fv363/zmNw899FNJ/wSv1+f3+yUVBwDUAQIwAOBtUvc/i0x0+PBhFQuK rCvys4oFUQ6ReycmJwMVhMypqalLL72kq6tLxVkdNzQ0nEwm+SUIAOBUCMAAgLed fvrpPT0bJRX/L//lg1//+tdVLChyTi6XU7EgyjTp9QZ8vlV/eCaT+eY3b41EIipO 6bhisehyudJpdkEDABZHAAYAzJG6/1nEkn/5l7t+7/d+T62CJpMpGo3m83m1CqJ8 Pr/f6/FUUuHgwYNPPfXvas1ngWAwNDExIak4gP+fvTsPjLq69z7OLCHJTMIaBNkh CUHvre1tvc9Vu7nUrfbW9tbW2tZd+rhcq4KAKAKVfVFCccOqV1u1rnUDcUFaQcGK gqjILNm3mUySmcyWWTPz/ID7IGUNyTlntvfrv1r8noMzmfw+c875HiDTEYABAHtI DcBer89isQgsqNPp3G63wILoOVdbm9Ph6Ms2Y6fTOW3atLFjxwic1X719Q2SlpcB AFmAAAwA2MNkKpw0SdYB4NLSsmeeeUZgwUgk0tXVJbAgei4ejzfU13t9vl5XCAQC ixcvTiSknNS12ezhcJjLkAAAh0UABgDsWf4tLy87sP2vWP/93zdffvnloqpp8/T5 fFoME1UQx6uhqamjra3X/7r22v3lL3/58stdAqd0oN27LZFIRFJxAEBGIwADAOTu f25sbGxqatbr9aIKGgwGt9vNEl8K9bEPlqahoeHWW2+pqJByIXBzc0tbH/I5ACCL EYABAHIvQBo4cNDbb78tsGAymezs7BRYEMer732wvF7vnDlzTKZCUVM6UHV1TVdX F5chAQAORQAGAPQbMGDAxIkTJBW/6KIfaVFHYMFQKBQOc89NKvW9D1YkElmzZo3D 0acUfRQWi5U3CQDgUARgAMh1Uvc/W63W6uqaoUOHiiqo0+m8Xi+Le6kVj8fr6+t9 feiDpXn//ffXrVsrakoHaW11ORwOScUBAJmLAAwAuU7q/ud4vPuTTz4RWJADwGmi obGxo729LxVcLtcdd9wxfPgJoqZ0oLq6evbJAwAORQAGgFwnNQB/4xv/tmbNGoEF OQCcJppbWlytrX2pEAwG77vvXknXWVkslmg0xhclAICDEIABIKdJ3f+sWbRo8Tnn nCOwIAeA00Tf+2Bp6fTVV1/96KN/iJrSQTo63I2NjZKKAwAyFAEYAHKa1ADc2uqq q6sTWJADwOnD1dbmcDgSfXstmpubb7vtttLSiaJmdaCmpqb29g4ZlQEAmYsADAA5 raCgYPJkKXexak48ceQrr7wisKDRaOzo6GBfazoQ0gfL7/fPnz/fYBB2R/SBqqqq u7q6eLcAAA5EAAaA3GUwGPLz8+WtAF9xxZU33XST2Joej0dsQfRa3/tgRaPRJ598 sqamWtSUDmKxWMLhiKTiAIBMRAAGgNwldf9zTU1tU1OTFrAF1oxEIpJ6JqEX+t4H S7Njx47nn39OyHwO5XA4W/s8QwBANiEAA0Duktr/uaCg8L333hNYUKfT+f3+WCwm sCb6wul09v2uXZfLNWfO3YMHDxYypYPU1NQGAgF2QQMA9iMAA0DuGjp06JgxoyUV //73z1y2bJnAgkaj0e120wErfbja2rQE3MdXJBwOr1692u2W1a3KYrHSNhwAsB8B GABylNT9z8lk8oknnjz55JMF1tTpdFoAFlgQfSSkD5Zmw4YN7767QciUDuVytbX0 7bomAEA2IQADQI4qKjKXlZVJKu73B7788kuxNbW45ff7xdZEH/W9D1a/PSd1HTNm zBg9epSQKR2ktrY2EAiycQAAsA8BGABykdTlX01JybB169YJLMgB4PTU7HC4nM4+ FvF6vb///e/z8/sLmdKhmhqb2ju4EBgAsAcBGABykdT2V5rbb5/+85//XGBBDgCn J2drq6PPG4y1l/W55577/PPPhEzpUFVV1aFQV3c3rbAAAARgAMhJgwYNGj9+nKTi Wt5ob2/X6UT+iuEAcHoS0gdL89lnn/3lL88ImdJh0QoLALAPARgAco7s/c86nf7D Dz8UW1NLL6FQSGxN9F08Hm+or/f2uQ+Wy+W68847hw0rETKrQzU3t7S1tUkqDgDI IARgAMg5JlPhpEkS9z//+McX33XXXQILGgwGv98fiUQE1oQoDU1NHX3OltqLu2bN GodDVrvmmpraYJBWWAAAAjAA5J5hJSWj5HTc7bf3AqS1a9edcMIJAmtqAbijo0Or LLAmRBHSB0uzZcuW119/re91Dkt789hsdjYRAAAIwACQW2Tvf/Z4Om02m9ia3d3d fb9sFpII6YOlaWlpmT59+tixY/pe6gj1HS6XS1JxAECmIAADQG6RHYC/8Y1/W7Nm jcCCOp0uEAhEo1GBNSGQqD5YwWBwxYoV4bCsRdqa6hof90gDQM4jAANAbpF9AdKq VX847bTTBBY0GAwej4fTm2krHo/XNzT4vN4+1kkmk+vWrfvgg/eFzOpQFoslGo0l ElyGBAA5jQAMADlE9vJvS4ujsbFRbE0tsXj7HK4gVWNTU7uIHssNDQ1Tp04tLy/r e6nD2r3bQis1AMhxBGAAyCFSA3AymRw5ctQrr7wisKZOpwsGg4SWNCeqD5bP55s/ f77RaOh7qcNiFzQAgAAMADlE6v7ncDjyySefGI1GgTUNBkNnZ2c8HhdYE8KJ6oPV b8+Fvc2zZ88eMWK4kGoHYRc0AIAADAC5wmQylZeX6XSyPvlPPfXfH3jgAbE12f+c Efb0wXI6u0V8TxEMBleuXBkMBvpe6rDYBQ0AOY4ADAC5Qvb+54cfXvPNb35TYE0t q/v9/lgsJrAmZBDVB6vf3jfS+vXrN2/e1PdSh1VbW+v1cqUWAOQuAjAA5Aqp+5/9 /sCXX34ptqbBYOjo6NASkdiykKGxubld0C27LS0tM2fOHD16lJBqB7FabZFIhF3Q AJCzCMAAkBPMZlNZmcT9z//6r1977LHHxNaMxWKBgKytsBCrxeFoFdEHS6O96CtW rIhEwkKqHYpd0ACQywjAAJATZF+AdOdds39y8cUCV2sNBoPf7yeoZIpWl8vR0iLk DZBIJF5++eWPP97W91KHVVtbx8FyAMhZBGAAyAkmU+GkSbL2Pzc3t1itVrPZLLCm Tqdzu90CC0KqeDxeV1fnF3TJUFNT0/Tp08ePHyek2kHYBQ0AuYwADADZT3b/54ED Br79zjtia3Z1dbH8m1nqGxrcHR1CSmlBesmSJYlEt5Bqh7JYLOEw7y4AyEUEYADI frL3P19z1dX/94YbBBbk+t9M1NTS0tbaKqRUd3f3iy+++OmnO4RUOxS7oAEgZxGA ASD7yd7/XF1VlV9QILCmln98Pu6qyTAOp9PpcIiq1tjYOH369AkTxosqeCB2QQNA ziIAA0CWk73/eUBR8TvvviuwoDZVr9erZWCBNaGAq63N0dIiKlX6/f7Fixcnk7Iy Kr2gASA3EYABIMvJ3v98xW8uv+nmmwUW1Ov1HYKOkkKleDxeX18vaum+u7v7hRde 2LnzUyHVDlVbW+v1sssAAHIOARgAslxhYWFFhaz9z01NzTXV1WL3P4dCoXBY1h2w kKqhsbGjvV1YtYaG22+/vbR0oqiCB7JYLNFojF3QAJBrCMAAkM1kL/8WFhRu2LjR aDCIKmgwGDweD/ufM1RzS4tLUB+sfuyCBgBIQAAGgGwmOwBffPFPfnfrrcVmczKZ FFJQq9PZ2SmkFNRztrY6WlpEVevu7n7uuec+//wzUQUPUlNd4xN0cTEAIFMQgAEg mw0bNmzUqJGSijc2Nn7xxa4BAweKWgHW6/V+vz8ajQqpBvVcbW1Oh0PgAn59ff30 6dPZBQ0AEIUADABZS/byb37//I1//7vA/c+xWCwQCIiqBvX29MFqaPCJu2LX5/Mt WrRIWgtzdkEDQM4hAANA1pJ6/a/moh/959Rp00TtfzYYDH6/nzSS6Rqbmtrb2kRV 6+7ufvbZZ7/44nNRBQ9SW1sbCAQ5cw4AuYMADABZa+jQIWPGjJFUvLGh8Ytdgvc/ c/tRFmhxOFqdToEFpe6CTiaTNps9FArJKA4ASEMEYADITrL3PxcXFb+7caOo3lea SCTS1dUlqhpSpdXlcjgcSXEHa2X3gm5pbnGJW7IGAKQ5AjAAZCep1/9qrrn6mv97 /fWiqhkMBp/PR/urLLDnGHBdncDuyt3d3S+++OKnn+4QVfAg1VXVXaEQu6ABIEcQ gAEgOxUVFZWVlUoq7mhx2O32/IICUQV1Op3b7RZVDanV0NjY0d4usmBDw8yZM8eP Hyew5oEsFms4HJZUHACQVgjAAJCFZO9/Lhlasu6NNwQWDIVCJJCs0dzS4mptFVjQ 7/cvW7YsHo8JrHmgxsYmzp8DQI4gAANAFpK9//nOWXf+7JJL4vG4kGpGo7GzszMW kxVvoJiztdXR0iKwYCKRePXVVz/66B8Cax7Ibq8Kh8PsggaAXEAABoBso9fr8/Pz 5QXg1lZXbU2NTq8XWNPj8QishtRytbU5HQ6xebKxsXHWrFljxowWWPNA7IIGgBxB AAaAbCN7//OoE0f+9ZVXBBYMBoO0v8ome/pgNTT4vF6BNQOBwL333hsOy7qvqL6+ gW9hACAXEIABINuYTIWTJsla/k0mk8uXLT/nBz8Qtf/ZYDBowYPdp1mmqbm5zeUS W3Pt2rUffPC+2Jr7Wa22SCSSEHd7EwAgPRGAASCrmEym8vIynU7Wx3tHe4fdbhe4 /1mLvj6fT1Q1pAmH0+l0OMTWbG5unj179ogRw8WW3c9isYTDEUnFAQBpggAMAFlF 9v7n8WPHPffCC6KqaUHd7/fT/ir7uNraHC0tYhdUg8FgZWVlICDshuGD1NXV+3w+ FoEBILsRgAEgq5SUlIwePUpScYvFsmP7jtKysmQyKaSgXq93u92iqiF97DkGXF8v fG1/w4YN7767QWzN/bT3oc1mD4VkHTMGAKQDAjAAZA/Zy79dwa4vdu0SmFdjsVgg EBBVDWmlsampva1NbE2HwzFnzpySkqFiy+7X0uJwiT66DABIKwRgAMgesq///bev f+PhRx4RVU2n03m9XtpfZasWh6PV6RRbMxwOP/zww62tgsvuV1VVHQp1dXezCxoA shYBGACyhMFgKCgoKC8vk1RfywZWi6Vk2DBRBfV6fUdHh6hqSDetLpfD4UiKPlK7 devW1157VWzNA3EhMABkNwIwAGQJ2fufk4nkR9u2CSwYiUS6uroEFkRa2XMMuK7O 5xfcs8rlct1zzz3FxUViy+7X2NjE9zIAkMUIwACQJWQH4PPPPe+eBQtEVTMajV6v NxqNiiqINNTQ2NjR3i62pvaeeeKJJ2pra8SW3c9mtUWiEXZBA0C2IgADQDaQff1v Q31DTW1tYWGhwJoej0dgNaQhGceANTU1NTNmzJC3258LgQEgixGAASAbyF7+LTIX vbtxo8CCwWCQ5d+st+cYcEuL8GuuvF7v4sWLpX3b06+2ti4QCNCeDQCyEgEYALLB oEGDxo8fJ6/+lGuvu+63vxVVzWAweDweAkbWi8fjdXV1ftHHgLV3zosvvvjppzvE lt2PC4EBIIsRgAEg48le/nU6W21Wa35BgaiCWi4SHoqQnmQcA9bU19ffeeedY8eO EV55n+bmljbRlxgDANIBARgAMp7s639Hjjjx5VeFXTyj0+l8Pp+WgUUVRDprdjhc Eo4BBwKBe++9NxyWtUi790LgEJsUACD7EIABILPp9fr8/Hx5Adhisfzjw3+cdPLJ ok5yahN2u93Cz4UiPUk6BqxZv379pk3vCS+7HxcCA0BWIgADQGaTvf+5q6vriy92 CQww0Wg0GAyKqoY0J+kYsKalpWXu3LklJUOFV96nvq7e5/ezCAwAWYYADACZraSk ZPToUfLqn/Z//mPV6tWiqhmNRp/PF4lwx0wOkXQMOBwOP/LIIw5Hi/DK+9AKCwCy EgEYADKY7OXf2tq6Krt9wMCBogrqdDq32y2qGjKCpNuANXa7febMGRUVFTKK99uz yOxwuVySigMAUoIADAAZTHb7q4L8gvc2bRJYsKuri+XfXNPqcjkdjkQiIbxyZ2fn okWLDAa98Mr72O1V4XCYXdAAkE0IwACQqQwGQ16ecfLkyfKG4Ppf9F08Hq+vr/f5 fMIra++l559//rPPdgqvvB+tsAAgyxCAASBTyd7/3OZy7d5t4fpf9F1jU1O7nGt1 tWg9Z87dI0eOlFG8H62wACDrEIABIFMNGTx47Lix8upPHD/hL889J6oa1//mMnnH gIPB4KpVq/x+8cvL+9AKCwCyDAEYADKS7OVf7aH/888/HzNmjMDrfzs6OoSUQsZx tbU5HI6EnHXUDRs2vPvuBhmV92lpbnHJWb4GAKhHAAaAjGQ2m8rLJQbgeCy+fccO gdf/hsNhltFy1p5jwA0NPq9XRnGn0zl//vwBA4plFO9HKywAyC4EYADIPCaTln7L dDqJn+Hn/uDcBQsXiqpmNBo7OztjsZiogsg4TS0tba2tMipHo9HHH3+8vr5ORvF9 aIUFAFmDAAwAmUf2/ufGhsbqmprCwkJRBZPJpBaARVVDJmp1uRwtLQL3FByourp6 1qxZpaUTZRTX1NXV+2mFBQBZgQAMABkmLy/PVFgwYaKsZ33NCSXDXl+3TlQ1nU4X CASi0aiogshE8Xi8rq5OUhtwrezK++4LhSXusbdabezhB4AsQAAGgAwje/lXe9Df 9tFHkyoqBLa/8ng8iURCSDVkrobGxo72dknF17/55qb3/i6puKapsamdLm4AkPkI wACQYQoLCysqJsmrH41EP925U+BW1VgsFggERFVD5pJ3GZLG4XAsWLBAXissq9UW iUT4HgcAMh0BGAAyiezlX8355553z4IFoqoZDAafz8f+Z/STfBmS9h576qmn7Hab jOL77N5t0TKwvPoAAAUIwACQSWQv/zY3t9jtdoHtr3Q6ndvtFlUNGS0ejzc0Nnql tUOrqam56667xo8fJ6l+VVV1KNTV3c0iMABkMAIwAGQMg8GQl2ecPHmyvCFGnjjy 5VdeEVgwGAyy/Iv9mh0Ol7Rd0H6/f/X9q/0+n6T6/bgPCQAyHwEYADKG7P3PNpt9 +yefTCwtFXUAWEvsbrebY5PYr9Xlcjoc8t4SmzZtWr/+DUnF+3EfEgBkPgIwAGSG vDxjYaFp4sQJ8oaIRWMfffyx0WAQVpD2V/hn8Xi8vqHB5/VKqu90OhcuXFhUZJZU vx/3IQFAhiMAA0BmUND+6pxzfnDn7NnFZrOQFWDaX+Gwmlpa2lpbJRWPxWLPPf/8 ri8+l1Rf09jY1MF9SACQsQjAAJAZZLe/amlx7Ny5c8DAgaJWgGl/hcNqdbkcLS0C 79k6iNPhuH369DFjRkuqb7FYotEYG/sBIEMRgAEgAyhY/h07ZuyLL70kMJbQ/gqH tWcXdH29T1qrKu2N98ADD3g8Er984T4kAMhcBGAAyACyA7DdXrXriy9GjhpF+yso 0NTc3OZyyav/4YcfvvqqyGbmB7HZ7OFwmLc3AGQiAjAApDst/ZaXl+l0Ej+x84x5 H2zZInD5l/ZXOArZu6Db2tqWLl2Sl5cnqX6/vRuhw2EWgQEg8xCAASDdyT79q+WQ G2648eqrrxZVkPZXOLp4PN5QX++Vtgs6kUisXbt269Ytkuprqququ0Ih7kMCgIxD AAaAtKaFybw84+TJk+UN0enp/Oyzz/ILCkQVpP0VjklqL2hNR0fHrFmzhg4dIm8I i8UaDofl1QcAyEAABoC0pqD91Rmnn7GyslJgQdpf4ZhaXS6nwyHvGG0kEnnyySdr a2sk1dfU1dX7/X4WgQEgsxCAASB9GQz6wkJTWVmpvCEaGxqrqqpMZrOognq93uPx 0B8IR7enF3RDg8/rlTeEw+G45ZZbSksnyhuCRWAAyDgEYABIXwqWf0eNHPXXl18W WDAajQaDQYEFka2aHQ6X0ymvfiAQWL16tc8nMWPX1zf4fD4WgQEggxCAASBN5eXl mc3m8ePHyRvCbq/64vPPR40eLaofr9Fo9Hq97H9GT8jeBa35YMuWta+/Jq++xmq1 hUIhqUMAAAQiAANAmlKw/FuQn79p8/sCb6PRwoxX5qZWZJM9vaAbG72dnfKGaG9v X7x4cf/+Eu9Dampsau/okFcfACAWARgA0tSwkpJRo0fJq6/l3tmz7/6v//ovLYcI KajT6Xw+n6hqyAXOveRdCKxVXrdu3QcfvC+pfr+9FwJr731OAgNApiAAA0A6UrD8 G/D7v/hil06vF1WQ249wvOLxeF1dnd/vlzdER0fH7NmzBw0aKG8Ijc1m7+rqkjoE AEAIAjAApKPCwsKKiklSh7jw/Avm3XOPwIJaAIhEIgILIhc0NTe3uVzy6sdisWf+ 8hfL7i/lDaGpranx+iTGeACAKARgAEg7CpZ/W1tdVoslv6BAVEGDweDxeGiHi+Ol oBWW0+mcPn36aJkHCvqxCAwAGYIADABpx2QqnDRJ7vLvN075+po//lFgwXg8LnUj K7KVglZYoVDo0ccea2lukjeEpra2jg5wAJD+CMAAkF4ULP82NDTabLbi4mJRBQ0G g8/n4/Yj9I7D6WyV2QpL09jYOHXq1LKyUnlD9GMRGAAyAQEYANKLggA8auSov778 stiaHo9HbEHkjj2tsGpr/YGAvCECgcAfVq/2++Su0NbV1XfKXMoGAPQdARgA0oiC 9FtVVf3ll1+OGDFC1IKbTqfT0gXLv+iLxubmdpmtsDTvv//+unVrpQ7Rj0VgAEh7 BGAASCMKAnCRuWjj3/4mcLupXq93u91S968i6ylohdXW1rZixQq9Xu6TD4vAAJDm CMAAkC4UpF+b1bZ169aTTj5ZYF4NhULhcFhUNeQmBa2wNG+99dbf//43qUP0YxEY ANIbARgA0oWCAGw0GLds3Sow/XL7EURxtrY6HQ6pWwmcTueSJUsKC4Xd/nVYLAID QDojAANAWlCQfi0Wy9///t6pp54qMK9Go9FgMCiqGnLZnkXg+nqvzydvCC1dP//8 859+ukPeEPuwCAwAaYsADABpQUEADoXCn33+eT9xK2xGo9Hr9dL+CqKouQ9p0aKF gwYNkjeEpramxuvjWmwASEcEYABIPQXpV/Of//njW6dOLTabRQWMRCKhBWAhpYB+ ++5Dqqvz+yVGR22IJ554orq6St4Q+7AIDADpiQAMAKmnIAB7PJ1btm4dNGiQ0WAQ UtBgMGhBJRKJCKkG7NPc0uJqbZU6hJaxb7/99vLyMqmj2O1VnA4AgDREAAaAFFOz /Hv22efcdffdApd/++0J1R5RpYB9XG1tTqezOx6XN0Q0Gl28eHE4HJI3xD4sAgNA GiIAA0CKFRYWVlRMkjpER3vHR9u2DRg4UNTyr06nCwQCnP6FcPF4vLmlxd3RIXWU mpqa6dOnK2g7Fw6zRQIA0gsBGABSSdHy71lnL1m6VODar16vd7vdUpsVIWe1ulyt TqfUu7UikcjChQtjMenf4LARGgDSDQEYAFJJwfJvm8u1e7clv0Dk3aehUCgcDgss COynZhG4qqpqxowZsn/6ksmkNlAwyEZoAEgXBGAASBmz2Sy7E4/m9P84rfIPfxBY 0GAweDweqQt0yHEKFoHD4fD8+fMTCelvY6vVFgpJP28MAOghAjAApIbZbCorK9Pp 5H4OO52tFoulsLBQYM1oNMquTkilZhHYbrfPnDmjoqJC6ij96IYFAOmEAAwAqaHm 9O9p/+c/Vq1eLbCgwWDwer2xWExgTeBQChaBQ6HQggULFCwC795t0SI9myYAIB0Q gAEgBRQt/zqcFqtV7PKv9hzv9/sFFgQOS3untTgc7o4Oqb3WlC0CV1VVBQLsmwCA 1CMAA0AKqFn+/dY3v/XgQw8JLGg0Gr1eL7cfQY1YLFZfV+cPBOQN0dXVtWDBgmQy IW+IfbQYb7dXsREaAFKOAAwAqmnpt7xc+vKvw+G0il7+TSQSWgAWWBA4uhaHw9Xa KnUR+PPPP58zZ87kydIXgemGBQDpgAAMAKopuPqon4TlX4PB4PP5WP6FSvF4vL6u zidt130ikVi8eLHf75P9hdQ+dMMCgJQjAAOAUmo2P8to/pxMJjs7OwUWBHrCob2b nU4Zi8Bbtmx56KGHRo8eJbzykezevXtvMyy6YQFAyhCAAUCp4gHFpRMnyh7ljNPP WFlZKbCgTqfz+XzxeFxgTaAn9iwCNzT4hO697+rqmjt3rsGgV7PweyCbzdbVxUZo AEgZAjAAqKNm+bfN5dq925JfUCCwppYT3G63wIJAzzlbW50Oh6hF4D//+c+vvvpq eXmZkGq9wEZoAEghAjAAqDNw4IAJEybIHuXss85evGSJwIJa+g0EApz+RarE4/HG pqZOj6ePdaxW6/Lly4cNKxEyq17jWmAASCECMAAoomb5t6PDveuLL4Qv/3o8Hqmd eIGja3W5Wp3OXodGLXDOn39PJBJRv+f5sOx2ezDIIjAApEBa/BoAgKyXl2fMy+uv IAD/8MIfzp03T2zNYDDI8i9SS0uwLU6nu729F1/ErF279umnnxo/fryEefUeG6EB ICUIwACggslUOGmS9KuPOto7du3aJXb5V6/Xu91uln+Rcr24Esnn891xxx0DBw6Q N6tes1gs0WgskUikeiIAkFsIwAAgncFgyMszTp48WfZAF/3wojlz54qt2dXVFYlE xNYEese5Vw+/jlm5cuXmzZsqKipkz6rX7PaqYDCY6lkAQG4hAAOAdGazqbxc+ubn lhZHdVVV//x8gTX1er3H42GRCmkiHo83NDZ6j3Uf9ebNmx9++OGxY8eomVWvaUle y8BshAYAlQjAACCXyaSl3zIFrXdu+d0tl19xhdjWsiz/It0cvRtWOByeOXNGYWFh mjS7Oordu3cbDAbuBAYAxdL91wMAZDrtWbyiQvrpX1erq6GxUWz6ZfkXaSgejzuc zo7DdcN68MEHN2zYoODHre9sNlskEunu5ocLAFQjAAOARGquPtKSwOzZd1988cVi W1WFQqFwOCywICDEno3Q9fVen2//P7Hb7fPn3zNq1KgUzqqHdu+27F34ZdszAKQG ARgAZDEajVoAnjhxguyB3G5PVVWV2PTL8i/SmbO1tdXp3Pf+fPrpp19++eXy8rJU T+rYbDZ7JBJm4RcAUogADACyKFv+vX/1/f9x2mks/yJ37LkW2OH4bOfOJUuWFBWZ Uz2dY7NYLHo9C78AkHoEYACQQtnVR8FgcNeuL1n+RU6JxWLTpk1bt25d+i/8aj+b VVXVoVCIHygASAcEYACQQtny71N/fmqS6JtOWf5FOnvxxReXLl06dOiQVE/k2CwW q16vZ+EXANIHARgAxFOTfjWJ7sS2jz8WW5PlX6Qt7Z05ZcoUv9+XIbccGaPRaDwe T/VcAABfSfffHwCQcfLyjMVFxWPHjZU9kMVisdrsI4YPF1uW5V+kp8rKyscee2zU qJGpnsixWa02LfqKvZYMACAEARgABFO2/KsN9Pq6N4rNZoEHgFn+RRpqaGiYMuW6 9F/17cctRwCQ9jLgdwkAZBDt2bd///4VFZNkD2Sz2b/44ovhI0YYDQaBZbUH90gk IrAg0BeJROKuu+566aWXFFwn1nd7bzmKsPALAOmMAAwAIpnNpvJyFcu/k8onPfX0 08KbP7vdbrE1gV7buXPnTTfdWFRUlOqJHBu3HAFApiAAA4AwyjY/NzU11dXV5+Xl iS0bDAaj0ajYmkAvhEKhW2+95e23364Q3eFcOG45AoDMQgAGADEMBkNxcfH48eMU jHXWmWctXbZM7FKtTqfzeDws/yLl/vSnP61aVTls2LBUT+TYrFab9oPDwi8AZBAC MACIYTaby8vLFAzkdLbW1dWJbQikVQsEAiz/IrU6OjquvfbaUKgr/ftd7Wt2Fdsr 1XMBAByHdP8FAwAZwWQyaelXzVP7f/7oP2fffbfYmtrM3W632JrAcVm+fPkTT/zP mDFjUj2RY6PZFQBkLgIwAAhQWFiooPOzxu322Gw24cu/Pp8vHo8LrAn0XE1NzZQp U/LyjKmeyLHR7AoAMh0BGAD6SlnvK81VV119ww03CC/r8XiE1wSOKR6Pz5o165VX XiktnZjquRwDza4AIDsQgAGgTwwGfX5+gZoAHI/Ft+/YIbZPlcFg8Pv93P0L9Xbu 3HnDDTcMGFCc6okcG82uACBrEIABoE+UXfyr5d677pp98cUXCy/b2dkptiZwdBl0 y9G+ZldEXwDIGgRgAOg9lZuf8/MLNm3aJLam0Wj0+Xws/0KlZ599dsWKFSUlQ1M9 kWOz26vC4TDNrgAgmxCAAaCX9Hq9FoDLykoVjKU9iH/88ccTJwo+JxmPx/1+v9ia wJF0dnZed911fr8v/W85otkVAGSrdP8NBABpS9nFv5oJ4yc8+9xzYmsaDAav18st plDjwQcffOihh0aNGpnqiRzD7t279+55DqV6IgAAKQjAANAbKjc/NzY2Wq224mLB vYIikQgLXFDA6XRec801iUQGbCS22WyRSJQ9zwCQxQjAAHDcDAZDkdk0QfSG5CP5 7ne/t2LFCrE19Xp9Z2cnD/qQbcmSJU8++eS4cWNTPZFjoNkVAOQIAjAAHDeVm5+9 Xt+XX36p5VWxZbUHfXpfQar6+vprr73GaDSmeiLHkEwmq6urA4FgqicCAFCBAAwA x0fl5mft0fzmm393+eWXiy2r0+k8Ho/Y+4SB/bS31uzZs1944YWJEyekei7HwAW/ AJBrCMAAcByMRmNBQYGazs+agoLC9957T2xN7XE/EAhEo1GxZYF9LBbLlClTzGZT qidyDOx5BoDcRAAGgOOgPdaXlyta/q2pqd2+ffuYMWPEltUCsNvtFlsT0CQSienT p7/66qvKviHqnWQyWVVVHQyy5xkAchEBGAB6SuXmZ83pp59RWVkptqbBYPD7/Zz+ hXCff/759df/X+G9yoWz2+3JZD8WfgEgZxGAAaBHtOiYn5+vLAD7/YFdu3bpdII/ pbu7u30+n9iayHGxWGzatGlr165V+fVQLzQ3twSDQaIvAOQ4AjAA9IjJVDhp0iQ1 Y1mt1ldee/2s739fbJ8qLcN7vV4trgisiRz36aefXn/99YMGDUz1RI7GYrHo9Xou +AUA9CMAA0BPmEym8vIy4euxRzJq1OjnX3jBaDCILRuJRFj+gijRaPTWW29dv/6N ioqKVM/laKxWmzZVoi8AYB8CMAAcg8FgGDRooPBmVEfS1tb2xRe7tMgttqxer/d4 PIlEQmxZ5KZPPvnkxhtvHDx4UKoncjRVVdXaG54vfQAAByIAA8AxmM3m8vIyNWMl k8lbb73tV7/6ldiyOp0uGAzS+wp9lykLvzabPRwO840PAOAgBGAAOBrFm59POGH4 66+/LrwsVx9BiIxY+K2trY3F4iz8AgAOiwAMAEek1+sHDBgwfvw4NcN1dLg///zz wsJCsWW5+gh9lxELv/su+A2FQiz8AgCOhAAMAEekcvOz1Wpdv/7N008/XXjleDyu BWDhZZE7MmLht6mpuWuvVE8EAJDWCMAAcHgmk0nlvaYnn/wv//M//yO8rMFg6Ozs 1DKw8MrIBbFY7NZbb33jjXXpvPC795YjQywWjcV4nwMAjoEADACHodfrtQBcVlaq ZriurtCuXbtk7NsMhULhcFh4WeSCnTt3Xn/99QMHDkj1RI7GZrNFIpHubvY8AwB6 hAAMAIehcvm3qqr6o48+Ki0VH7Z1Op3H40kmk8IrI7vF4/Hbb7/9tddeU7kJ4njZ 7VXae5s9zwCA40IABoCDKd78fM45P1i0aJHwslr69fl8bH7G8dq1a9dvfzuluLg4 1RM5GrvdHg5Huru7Uz0RAECGIQADwD8xGAz9+/evqJikZrhEIrFjx6cyYqpW2ev1 Ci+LLJZMJmfOnPnXv/5V2eb/Xqirq49Goyz8AgB6hwAMAF/JyzMajXnK0m91dU1d XV1RUZHwylqM19JvLBYTXhnZqra29qqrriosLEj1RI6IW44AAH1HAAaArxQVmcvK FN17pD3N33jjTVrkkFGc3lc4Lvfcc89TTz01ceKEVE/kiJqbm4NBbjkCAPQVARgA /pfJZCovL9PpFH0wDh48eMOGd2Vsfqb3FXqupaXl6quvUva27wWrxarT67nlCAAg RPr+wgMAlQwGQ5HZNGHiRDXDNTU1OZ2tMlr40PsKPVdZWfnII2vGjh2b6okckdVq i0ajNLsCAIhCAAaAPVR2frZYLB9u/fCkk0+WUVyLCloAllEZ2aSzs/OKK66IRiOp nsgRccsRAEAGAjAAqL736NRvnbrmkUdkLNLq9Xqv18vyL47umWeeWbJkyciRJ6Z6 Ikdks9kjEW45AgCIRwAGkOsU33vk8/rsVVWSMmowGIxGozIqIztob49rrrmmrc2V tod+q6trtNzLwi8AQJI0/f0HAGpo6XfI4MGjRo9SM1xrq2vnzp0DBw6UUVyLNG63 W0ZlZIfPPvtsypQpgwcPSvVEjshut4fDLPwCACQiAAPIaWazubxc0b1HVqtt3bq1 3//+mZI2P/v9fpZ/cVjJZHLmzJkvvfSSsnf78aqrq4tGYyz8AgBkIwADyF2Kj/6e UDJs/VtvSdr8rEXfYDAoozIyXXNz8+WXX96/f16qJ3JEdntVKBRKJBKpnggAIPsR gAHkKIPBUFBQoGxBrL29fefOz4qKimQU1+v1Ho+H/IBD3X///Q888MC4cWl60VEy mayurgkEAqmeCAAgVxCAAeSowsJCZY2v7Paqd99999RTT+XiXygTDAavuOKKQMCf tv2u+u09FxAKhVI9CwBADknfX4oAII/Ko7+a8rLyvzz7rKTWPlz8i0Nt27bthhtu KCkZmuqJHAMBGACgGAEYQM4xmUxa+lW2LOb3+Xfs2JFfUCCjOBf/4iCJROL2229/ 5ZVXVJ5v7zWbzU7jKwCASgRgALnFYDCYzeaJEyeoGa62tu6D99+fVFGRTCZl1Ofi Xxyoubn517/+dUFBfqon0lMEYACAYgRgALlFZednLfR++4xvV65aJSn9ajwej6TK yDgPPvjg/fevHjs2TftdHRYBGACgGAEYQA4pKjKXlak7+huPxbds2SJp87PBYPD5 fCz/QhOJRK688gqPx5PO/a4OiwAMAFAsw35TAkCvKT7629Li+Pjjj4cPHy6pfigU CofDkoojg+zateuaa64ZPHhQqifSGwRgAIBiBGAAOcFgMBQXF48fP07NcFar7a8v vXTe+edLak+lxXiPxyNvZzUyxfz585988smystJUT6SXCMAAAMUIwABygsqjv5oT h49Y+8YbktKvFub9fn8kEpFRHJnC6/X+6le/6u7O7AbgBGAAgGIEYADZr6ioSOUS Waen89OdOwsLCyXVD4fDXJ2a47Zv3z5lynXDhg1L9UT6igAMAFCMAAwgyyk++ltb U/O3v7/3r//6r5L2J+v1erfbzebnXHb33Xc/88wz2rs61RMRgAAMAFCMAAwgmxkM hqKiogkTxqsZTva9R1r69fv9dH7OWdmx7flABGAAgGIEYADZTPHRXy0Bb9q0WdK9 R/3Y/Jzbsmbb84GsVhtvaQCASgRgAFlL8dFfp7N1+yefDC0pkVSfzc+5bM6cOU8/ /XR2bHs+kMVi5Tav1DKZTJFIpLu7O9UTAQBFCMAAspPio782m/3N9eu//Z3v0PkZ YgWDwcsuuywazc6X3m6v0v6CqZ5FjtLr9SZTYVlZmfbxRQYGkDsIwACy0N6jv+YJ EyYoG7GstOy555+XlH77sfk5V+3ateuqq64aOnRIqiciEceAU8JkMnV3x0866aR9 /5O96AByBwEYQBZSfPS3qyv08bZt8o7+6nQ6j8fD5udcc++9965Zs2biRHXf46QE AVg9s9l80HZ6LQBHo1EWgQHkAgIwgGyj+OhvY0Pjto8/Hj16tKSAyubnHKRFkcsv v7yz06NsD38KcQxYJe3zpH//vIqKikP/r9raukAgQAYGkPWy/zcrgJyi+OivxWJ5 5qmnL/7pT+Vtfg6FQsSDnNLQ0PCrX11WVFSU6okoov0QRaOxRCKR6olkv73bnrtP Omnykf6AzWbXPm14LQBkNwIwgOyh1+u12KByy+gJJcPWv/WWvPSr8Xg88ooj3WzY sOGWW343ZsyYVE/knySTydZW14gRwyXVZxe0Amazuays9JhfDnIYGEDWIwADyB4m U+GkSZOUDdfZ6f30008LCwsl1dfyvM/ni8Vikuoj3UybNu2ll16cPPmIC3Qp0dzc fMUVV+7atcvpdEgaggAslcGg798/v6KiR5+NFqstGomwCAwgixGAAWSJoiJzWZm6 W1Lr6urf37x5UkWFpKO/Op0uGAxy9DdH+P3+Sy+9NJFIu+OXiUTy7rvvLioq2rhx 4zvvvC1pFO2HyG6vIgPLYDab4vGjbXs+VE1Nrfbhw2FgANmKAAwgGyg++qs9r19w 3vnzFy6U15k5kUh4vV5JxZFW0vOuo7q6up/85KdaLN/3PyORyK9//euDWgcLZLPZ urrYeStYUVFRaenEXnwwcjMwgCxGAAaQ8QwGQ0FBgbxH80OZCk1vvvmmvHuP9Hp9 Z2cnT5+54IEHHli1alW63XXk9wfmzJlzwgknHPgPb7nlFpNJ1oZ/LW8Hg11s+BfI bDaVl/f+NjgOAwPIVgRgAJktL89oNOb18HibEO4O986dO01ms6T6Op3O5/NJbayF dJBMJn/72982NNSn1V1HWuw5++yzb7rppkNnpQV1eceA+3ESWByDwZCXlzd58mHu Ouo5i8Uai8X4Gg5A9kmjX7oA0Atms1nl2m9tTe3f/va3f/3a1+RtftYeOgOBgKTi SBPaS/yLX/w83VoNtba67rjjjiN1ktu6detrr70qb3SWHIU45l1HPVdVXRPq6iID A8gyBGAAGUx71Js0qfd7/I6XFnrPOvOsZcuXy0u/er3e7XbLq490UFNTc9lllw0e PCjVE/mK9pYzGvNmz55dcOSN/dqfufzyy8eMGS1vGiwC91FRkbm09Nh3HfWczWYL h2kKDSCrEIABZCqDQZ+fX6AyAPfP679hwwZ5R38NBoPf76fzc3Z79913b775v8eO HZvqiXylrq7+F7/4xU9/+tNj/sn58++RGlBZBO417dMjP7+/jHvgeFEAZBkCMICM pD3tDRkyZNSokcpG7Ohw79ixo7i4WN4QWrQg/Wa3u++++6mn/lxR0afDmWL5/YG5 c+cOGzasJ3/47bff/tvfNkqdD4vAvaB9HhqNRiHbng9lsVj2HgZmERhAliAAA8hI 6o/+bty48WunnCJvc7JWubOzU1JxpFw8Hv/1r3/t9abRS2y1Wr/3ve/fcsstPd8x m0gkfvOb34wbJ3H5mvXG47X30G/8pJNOkjdEfV29z+/nMDCA7EAABpB51B/9/f53 v7fivvukHv31er10fs5W2ov7X//1X3l5xlRP5CvNzc233z79lFNOOd5/ceHChYGA X8aU9mMRuOeUfRVotdqi0SgZGEAWIAADyDAGg6F///4q7z3KMxrffXejvKO/Op3O 7/dzA2q2qqmpufTSS4cOHZLqiXwlGo3Nmzevd/v5P/7445deelH4lA7U0uJwuVxS h8gCJpMpmUyq/CS026tCoRANsQBkOgIwgEyi1+sHDRw4VuYOzIN0tHfs+PRTqUd/ ufcoi73//vu//e2U9Gl5pWWYCy644LrrrutLkSlTppSUDBU1pcNiEfjoioqKSksn Kr5BWsvb2vuH1wVApiMAA8gkijc/NzY2btq0uaxM4g5D7j3KYkuXLl2zZo3Kd+zR OZ2td955Z3l5X+ej/aXq6mqFTOlI6urqfD4/i42Hpfhj8EC1tbWBQJCN0AAyGgEY QMZQf/T3yiuvuummm+QNYTAYfD5fNBqVNwRS5frrr6+trVG8RncU3d2JefPmaT9E fS/V1dV11VVXlZZO7Hupo6Ab1qH0en3//v0nT05lF3EOAwPIdOnyixkAjk7Linl5 xsmTpdzzcVhjx4574YUXpA4RDAZJv9knHo//8pe/lN0pqufs9qqLLrro6quvFlhz /vz5XV1BgQUPZbVao9EYQWu/vd2euyXddXRc7HZ7OBzhpQGQoQjAADKAln6Li4vH jx+nbETtyfuTTz7R6/XyhkgkEl6vV159pITf7//pT39qNBpSPZH/1drquuuuu0pL S8WW3b1795NPPiF7fZuTwPul5NDvUdhstq4u1ucBZKR0+SQFgKNQvPm5pcWxdevW 0aNHyxtCi/Qej4cllCzT3Nz8s5/9bNCggameyP9KJJLz5s0rLCyUUXzq1Kn5+f1l VD4QGbif8mvPe6KqqjoUCvEJBiATEYABpLuiIrPUNlQHsVgszz//wvnnny9vCL1e HwgEIpGIvCGg3q5duy677LKRI09M9UT2sNurLrzwwmuvvVbeEJs3b37jjXXy6u9T W1vn9+d0N6zCwkKVdx31HIeBAWQoAjCAtGYymcrLy1Ru/DvllK//8Y9/lDpEKBQK h8NSh4BiW7Zs0dLmOIUXdB1FS4tj1qxZCg7M33jjjQMHDpA9ihbmg0G5543Tk8Gg z8vLU9n44HjZbHbtoyyXv54AkIkIwADSl16vLyoqmjhxgspBP/zwH1LzdjKZ7Ozs lFcf6r3xxhu33HKL7K7IPRQKhebPXyD15ur9Xnvtta1btygYKAc3QqdPy6ujo1k3 gIxDAAaQvkymwkmT1O39a211ffzxxyUlJfKG0CK91+uNx+PyhoBiS5cuffjhhyoq UnkzzT5Wq/XMM8+6+eabVe6YuP766wcPHiR7lIaGRq+3s7s7V1Ya063l1VHY7VXh cJiN0AAySAZ8tgLITYr7vths9rVr137729+WN4T2OKulX54Us4mWNm02azoElbq6 +mnTpp166qmKx12/fv2mTe8pGCh3NkIr7vnXd83NzW43Lf0AZIzU/84GgEOpfwQ8 /fQzKisrpQ4RiURybRtndrviiitcrtZUz2IPt9s9f/6CE044ISWjqzkJ3C8HNkIb DPr+/fPTs+XV0Wkvjfb5RgYGkBEIwADSjsFgKCgoULn8qz10bt68WfYonZ2dyWRS 9ihQQHsdf/nLX3q9aXGWW6fTz5s3r39/6TcSHcnGjRvffvstBcvg1dU1wWAwW1su Zcqh3yPhMDCATEEABpBejEZjXl6eyjWQjg739u3bBwyQuITF0d9sor2OP/vZzyKR 1PfxttnsF1100TXXXJPqifS77bbbCgryFQyUrYvAGXTo90joCA0gU2TwRy2ArKT4 6G9VVfU777zzzW9+U94Q2kOtz+cj/WaHaDR68cUXJ5Opf8pvbGyaNWvWv/zLv6R6 InvU1tZOmzZVTSew7MvAiq86l6exsbGzkzYHANIdARhAGlF/9Pf88y+45557pA7B 0d+sEQwGf/zjH+flGVM9kX5azFi4cOGQIUNSPZGvzJs3T82quNVqjUZj2ZGyjEZj //55Knvdy7b3MHA4d/p1A8hEBGAA6UKv1xcUFKgMwAMGDHznnXdkj8LR3+zg9/sv uugik6kw1RPRflIMv//977XslOqJ/BO323399deruQy5oaFR+7HK9N22BoMhL884 eXKmHvo9Eg4DA0hzBGAAaUF7FhwyZMioUSOVjejz+T/55BOTySRvCO0vpT2ms/k5 C2jp94c//KHZLPHd0hNatNCmcd1116V2GkfywAMPNDU1qhkr0zdCZ3rLq6PQ3qXR aDQ7lugBZCUCMIC0oPjob21t3XvvvXfSSSfJG0Kn0wWDwUgkIm8IqJEm6be+vmHG jBnf+MY3UjuNo4jH41OmTBkxYria4aqqqgKBjLwZuKjIXFpamtEtr46uob7B6/OR gQGkp6z98AWQQRQf/U0mkz/72SUzZ86UOor28Ofz+aQOAQXSJP22t3fMnz9/xIgR qZ3GMb3xxhubNr2nJtppP8h2e1VmrQPvPfTbX3Gng5TgZmAAaYsADCDFDAaD9kSo 8t6j4cOHv/ba61KH0Ov1brebo7+ZLk3SbyQSXbhwYWFh6o8f98T06dONRoOasbQA HAqFMuUwsPaxoH3WTZ6sold2OuAwMID0RAAGkEp7jv4OHjxq9ChlI4ZC4U8++SQv L0/eEEaj0ePxcPQ30wWDwQsuuCC16TeZTJrN5tmz786g7bLt7e033nijmm5Y/fZe B9XZ2Zn+K41ZfOj3SCwWSywWT/+XBkCuyZhfqACykpYuysvV7QZsbGz88MN/jB07 Vt4Qer0+Ix7HcXTRaPTCCy9M7Y1HVqvtJz/5yRVXXJHCOfTOI488Ultbo2w47T9U TEtaafyVU1FRUWnpxAz6FkOU+rp6n9/HrUgA0krOfRYDSB/qj/5effU1N9xwg7wh DAaD3++n8VWm06LUj370I+0tk8I51NXVzZx5Rzq3vDoK7WftxhtvHDRooLIR7XZ7 MJiOh4G1z4SCgnyVX/MdncViGT16TFGRWdmIHAYGkG4IwABSQ3suzM/PVxmAx40b //zzz8urT9vn7JBIJH7yk59Eo6l8HZ3O1nvuuWfMmDEpnEMfaQH+9ttvV9na3W6v 0n4AlQ3XE3tv+s1Ln0O/1dU1Cxcu1D6pKisri4uLlI3LYWAAaYUADCAFDAb9sGHD VLa0jce7t23bptfrZQ4R9/v98upDjZ///JLUvo4eT+fSpUsHDlS3fCrJH/7wB4ej ReWIaXUxUrod+nU6W1evXl1UtCf3fvjhh/fff/+YMaPVDM1hYABphQAMIAUUH/1t aXFo6Vdq3qbtc3a44oorXK7WFE4gGo0tWrQoPz8/hXMQRQs8N954w5AhQ1QOWlVV HQgEVI54WIovNj8mLX8uX778wEPIr7766hNP/M/kyYryeX1dvdfny5R+3QCyGwEY gGqKj/5ardaXX37lrLPOkjeEln59Pl8sFpM3BBS47bbbdu/+MoUTKCgonDNnTja1 Sqqvr582bZriKJjaDLz3cEf/SZPU3et2dMlkcvjwEdp7+6B/HgqFKitXqryr3Gaz RSJR1oEBpFz2/JYFkBH23vqbV1Gh7lDct7516oMPPiivvhZXtIfIdO5Ai55YuXLl m2+uT1X4tFgsF174w9/+9rcpGV2qxx9/3G63KR40VRnYZDIlEon0OfRrs9lvuOGG H/zgB4f9f+vq6rQMrPJ+aQ4DA0gHBGAA6uj1e47+nniiuqO/2ohbtmyVmmoikUhX Vzq2n0XP/e1vf7vuuutStWdVSyn//d//LXWTQmpNnTo1P7+/4kHVZ+B0u+uooaGx srJS+8g9yp/Ztm3b/fffP3LkiWqmxGFgAOkgXT6mAeQCxUd/W1td27dvl3oEMZlM dnZ2yqsPBT777LNLLrlk4sQJKRm9urpm5syZ3/rWt1Iyuhper/fGG28cO1Z1U2tl faHV97Q/Jo+n84EHHtAmdsw/uXbt2scff7yiQtGebW4GBpByBGAAiig++qs9+77x xhunnXaavCG0h0uPx8NqRkZrbm6+8MILla2AHaS+vmHu3LkqTwSkyvr169977+/q V0cVXEKbbtueNUZj3vz583v4h6PRaGXlSu2jTOqUDsTNwABSiwAMQAUtKxYUFKjc Yvrd735vxYoV8urr9fpAIMCtvxmtq6vrBz/4wYABxSkZvaXFsXDhwtGjFV1Fk3Lz 5s2LRMLqx7VabVrGkxS30m3bczKZLC0tmzJlynH9W01NTffdd6/K3uMcBgaQQuny kQ0gixmNxhEjRpSUDFU2YmGh6e9//7vUIbTsRPrNaFpUuOiiixKJ1CxDuVxty5Yt GzpU3Q9FysVisRtvvFHl58B+1dU1WgAWe1Y/Dbc92+1Vt99+e++2vezYsWP16tXD h58gfFaHtfdbiQgboQGkBAEYgHSKr8R0uz3bt28vLpa4rKc9TKu8PgQyXHPNNS0t zSkZ2u12L1++YsCAASkZPYWampqmTp1aWjoxJaNr+TAcDgtZCk7Dbc/Nzc333/9A X95Ub7755qOPPqrss7qpqZkjJABSggAMQC7FR3+rqqrfeeedb37zm/KG0Ov12nOb 9vgrbwjIdu+997799lsp2bnq9fpWrFih/VyoHzodvPTSS9u2fZSqPcNaSgwGu/qy FJyXl9e/f/+ystL02fasCQSClZWVPWl5dRSxWEwr4nZ3iJrVMXEYGEBKpNHHN4Ds oz2Qmc1mlf11zznnB4sWLZJXX0u/fr8/Go3KGwKybdu27bLLLtMyjPqhtei1bNly lYct09A99/w+hec/k8lkVVV175aC915j3l9Zw+Se0P46ZnPR3XffLaSaw+FYsWJF //55Qqr1BIeBAahHAAYgUWFhocqHRe1BcOPGjfLq63Q6Lf3GYjF5Q0C2jo6Oc845 e8QIdZdR7xeNxpYuXWo0GtUPnVa05HnLLbcUFxelcA5aBk4kEtFoNB6P9/BfMZlM 2sxPOmmy1IkdF6vVeumlv7z00ksF1vz0009Xr159wglHuz1YIIH70gGghwjAAGQp KjKXlak7+uvxdG7fvr2oSOJTtfa4rOZaUUiSTCbPPfdco7FPO0V7Jx7vXrJkSR83 qWYNn8/3u9/dfOKJqbl9ar/a2rpYLHbMXbh6vb6wsEDlHeY9UV1ds3jx4tJS8RsZ 3nzzzccee0zZFgmpbboB4FAEYABSmEym8vIyZcfktGfBDRs2fOMb35A6Smdnp5ag pA4Bqa699trm5ib145J+D1VTU3PHHXekqiHWgfauBmvpS3fYs8Fp2O9K43S2VlZW Dhw4UEbxeDy+atWq9vY2GcUPy263h8McBgagCAEYgHjag/7AgQPGjh2rbMRzzz1v wYIF8uprfyMt/fZ8tyTS0KOPPvrCC8+r711E+j2SLVu2LF++bPLktNhUnEwm7faq fnt6QUVjsf/9SS8qMpeWple/K00kElm2bLnUvfROp3PFihV5eeq269tstq4uDgMD UCG9PtMBZAfFnZ+LiorfffddefX1en0gEODW34zW0NBw/vnnjxun7kuZfUi/R7dm zZq6utpUz+KfVFVVd3d3a6FXi8Rp1e+q396UPmTI0BkzZigYS/Fh4Nra2kAgyCIw AAUIwAAEU5x+PZ7OHTt2mM1meUN0dXWRfjNaIpE4++yzCwpU916ORmPLli0j/R7d 3LlzaKveEzab/corr/zxj3+sbMS33nrr0UcfVXYY2GazRSIcBgYgHQEYgEjas35e nlHZnsbq6pqNGzeecsop8obQnsZ8Pp+8+lBg6tSpX365S/GgwWDXfffdR8/nY0ok EtOmTVP/9URmqa9vWLx48bhx41QOqn36VVZWqj0MXBUKhbhlHYBUBGAAwuj1+pKS kpEj1XV2veCCC3//+9/Lq6/9jTweD09jGW3btm2XXnqpyl0JGq/Xt3Llyhy/77fn IpHIbbfdNnDggFRPJE253e4VK+4tLi5WP7Tiw8D7TmIfthsZAIhCAAYgjNlsLi9X d+/RwIGD3n77bXn1tfTr9/vZnJnRgsHg97///ZKSoSoH9Xg899230mQyqRw00wUC gVtvvXXYsJJUTyQN6RYsWJDCjfQ7d+5cvXq1spemob7B6/OxERqAPARgAGIoPvrb 2endvn27vKO/Op1OS7+xWExSfahxySWXBAJ+lSO6XG2VlZUpWazLdO3t7dOnTx8x YniqJ5IuksnkqFGjb7755lRPpN/69esfe+wxZd9v2mz2Y17ODAC9RgAGIIDBYNAC sLIrPWtqajdu3Pi1r31N3hDa4xfb8DLdn/70p6effkrlHTbNzc333nvfsGGKGudm H5fLpWVglcco0lZVVfWUKVPOO++8VE9kDy2L3nvvvR6PW9mIVqstFOJWJABSEIAB CFBYWKjyvpALL/zhvHnzpA7h8Xik1odsXV1d3/nOd5Rd4qKpq6tbtGjxhAkTlI2Y lZxO54wZ00eNGpXqiaRSS4tj4cKFo0ePTvVEvqK9LksWLy40FaoZTsv/oVBXdzf9 FwCIRwAG0FdFReayMnVHf2Xf+mswGLT0y+67THfdddc2NTUpG85ur5ozZ47UhuS5 o7m5edasWaNGjUz1RFLD7w8sWbKkqKgo1RM52CeffPKHP/xB2fq81WqLRrkVCYB4 BGAAfWIymcrLy5TtMu3ocO/YsUPeAUsaX2WHbdu2/eIXP6+oqFAznNVqve22qd/9 7nfVDJcLXC7XzJkzc/A8cP/++XPnztU+iFI9kcN7/fXXn3jiCWXtHrgVCYAMBGAA vaf43iPtYejtt98+9dRT5Q0RDAZJv5kuFot95zvfGTx4kLIRx40bf/311ysbLkd0 dHTMmDFD5Sb21LJabRdffPGVV16Z6okcjfbxuGzZsmAwoGY4bkUCIAMBGEDvKb73 6Iwzvr1y5Up59ePxuN+vtGMwZJg1a9aOHduVDWcwGBYsWKhsuJzi8/nuuOOOXLgf uK6uXnvfZsQW+vr6+mVLlw5Q9aI0NjZ2dnrZCA1AIAIwgF5SfO+R0Zj3wQcfyKuv 0+k8Hk8ymZQ3BBRob2//7ne/O27cWDXD+f2BVatWpfCO1qwXjUbvuusuozGb/wu3 t3csXLjwhBNOSPVEeurDDz984IEHRo9W1KjMbreHw9yKBEAYAjCA3tCe+M1m88SJ ihreOp2t27dvHzp0qKT6er3e5/Nx628W+M1vftPe3qZmLO1tqaXfAQOyf30ytZLJ 5IIF84PBoMobrZSJx7vnz59fUFCQ6okcnxdeeOGZZ56ePHmymuFsNjsboQGIkoW/ SwAooHL512q1vvLKq2eeeaa8IbT0y/JCFti5c+fFF/9YzUN5dXXN0qVLufRImWee eeavf/2ryjMXsmnBfsiQoTNmzEj1RHpDi6NLly5R1jGhtrY2EAjyKQ1ACAIwgOOm ePPzKad8/Y9//KO8+qFQKBwOy6sPZc4888yCgnwFA2nR5d/+7ZuXXnqpgrGwn81m W7BgfnZcEVxdXXPZZZf99Kc/TfVEes9ut69YsWLIkMFqhrPZ7JEIG6EBCEAABnB8 DAZ9fn6BsgAcj3dv27ZN3qUgiUTC6/VKKg6VHn300RdffEHNWNqPwLx589SMhQP5 fL65c+dk3Ibhgzgcjjlz5k6cODHVE+mr99577+GHHx4/fpya4axWWygUUjMWgCxG AAZwfAoLCysqJqkZq6mp+R//+Mfo0aMl1ddytcfj4ZLJ7HDGGWcMGCDrgugDeb2+ 1atX0/gqhR566KF33nlH2QeRWH5/YNGiRVlzdHzVqlVOp0PNWCwCAxCCAAzgOKjc /JxMJq+88qqbbrpJUn0t/fr9fm79zQ4PPvjga6+9qmCgurp6Lf2WlJQoGAtHYbPZ li1bNmxYhr0QeXn9586dm03fnng8nkULFxrzjGqGs1pt0aiWgfnWEkDvEYAB9JT2 0JaXZ1TW9nPkyJEvv/yKpOI6nU5Lv7R9zg7JZPL0008fNGigkoHOuPjii2UPhJ6I x+OrVq364IMPMmIpWEtuP/rRj6655ppUT0S8L774YlXlypJhw9QMx0ZoAH1EAAbQ I1r0HT58REmJrIuIDhIMBnfs+DQvL09S/UgkwqUaWUNLQevXv6FgIKPROH/+AgUD oeeqqqruvfdeBV9/9EV9fcPMmTO//vWvp3oisrz11luPP/64movx9i4CR9kIDaDX CMAAeqSoyFxWpugCkpqa2s2bN8tbak4mk52dnZKKQ73TTjtNQf5pbXU99NBD+fkq ukzjuGg/0U888cTbb7+trBvTcWlv75g/f/6IESPUD63T6YoGDAj4fNp/IqkDJRKJ 5cuXd3Z6pI6yHxkYQF8QgAEcm8lkKi8v056l1Ax37rnnLVgga51Nr9dr6Zcnp6zx 1B5/lj2K9sC9dOnS8nJ1t3/heAUCgZUrV27fvn3y5IpUz+Ur8Xi3ln7Vt63eE33N 5qLi4kGDBzscDm9np+wM3NzcvHTJEnORWeoo+7ERGkCvEYABHIPBYBg6dOjIkSeq Ga5///zNmzdLKq79Xfx+fyQSkVQf6p1//nkKvpoZMmTo9OnTZY+CvmhpaZk7d66y YxrHZLFYzjrr7N/97nfqh9Z+IgYNGTLqxBP3nSKJxWL1dXX+QED2uB9++OGDDz44 atRI2QP12/ufNxaL81UmgF4gAAM4BrPZXF6uaPOz09m6Y8eOIUOGyChO46vss3Xr 1nnz5soOwK2trjVr1sg7kY6+e+WVV5599tkJE8aneB7/X3V1za233nrGGWcoHnff wq+5uHhYSYnR+FVnZmdrq9PpTMq/8u355577y7N/UdMrkY3QAHqHAAzgaFRufrZY LC+++NK5554rqT6Nr7LP5Zf/pq2tTeoQyWTyggsuPPPMM6WOgl7T8s+iRYuCwYCy MxrH5HS2zp07d/z48YrH3bPwO3jwqJEjD/2yJh6Ptzgc7o4O2Ruhg8Gg9nIkEopC KRuhAfRCuvy2AJCGFG9+njSp4s9/lnWYk8ZX2Ud7Qf/93/+9tHSi1FHo/JzOXC7X vHnzBg4ckOqJfKWrK7Rw4cKioiKVgx5p4fdAWgaub2jweb2yJ7Nr167KlStLlFzR zEZoAL1AAAZwRCo3P0u994jGV1lp7ty5//jHh1KHqKurW7PmkQED0ihfYb9t27at XLly3LixqZ7I/0omk0VFxXfeeaf2gaNy3KMs/B6k1eVqdToVfBKuX7/+8ccfLysr lT1QPzZCAzh+BGAAh6dy83N1dc2mTZtOPvlkGcVpfJWtvvOd7xRJbjk7btz466+/ XuoQ6IVEIlFZWbl58yY1Z017oqqq+uc///kvfvELlYP2ZOH3QPF43OlytbtcsjdC a3F0+bJlXp/01eZ92AgN4LgQgAEchhYahw0rUXZx5fe+9/3ly5fLqEzjq2z1wQcf 3HPP76V+QdPa6vrjH/+o/SzIGwK94PF45syZI/u7j+PicDjuvntOaamKBc/9er7w eyAtAzc1N3d6PLIzcF1d3fLly9TsnmAjNIDjQgAGcBjaw2VZmaLNz3q9futWWRtZ aXyVraZMmdLY2CB1iG9/+zs/+tGPpA6B47Vjx44VK1aMHTsm1RP5SjDYtXDhwuLi YmUjHu/C70H23IpUX+/3+2XM7UCbNm16+OGH1exRZyM0gJ4jAAM4mMrNz01NzR9/ /PGJJ0rps5VIJLzyO75APe2V/frXvy71ulGPp1N7dpdXH8crmUxWVlZu2vRe+mx7 1qZkNhfdddddKg/9ap/Mg4cMGfn/7/jtHWfrnmuREvJvRVq5cqXL1Sp7lH3YCA2g hwjAAP6J9lA1fPjwkpKhCsbSHh9/+cvLpk6dKqO49kjq8XgUPOFBvRdffPHRR/8o dYizzjr7vPPOkzoEeq6jo2Pu3LnFxUpbKx9dVVX1JZdccumllyobcc/C714lvVr4 PdCeW5GcTnd7u+yN0G1tbYsWLSooyJc6yj4sAgPoIQIwgH9iMhVOmjRJzViDBg1+ 6623ZFTW0u//Y+9O4KOs7v2PJzPZZiYJSUggQNhCQnCp1q3Lrdpe622t/xavS2vV WrV1qeKCuLLJKogLSmtxoS6IghsqcEtBaV2qYqUVpQqZZLIvs2SZyWSyziT5n0ks tYgQkuecZ56Zz/t1L42Y/M6jkszznXOe36+1tVXcDMkoDt1deeWva2tr5dVvafGv Xr1aXn0ckV27dj300EMRdezZ5XLPmzdP5UO/mmz8fpGyqUh///vfH3744TFjVHSU KCkp6eoiAwM4DAIwgH8zm01JSUlFRUUK1mpoaNyzZ4+kaZki/YrbOxmVEQlOPvlk qYcUvvvd75111lny6mOQent7H3zwwXff/WvkHHuOUz7p9/ON37S07JEjh7nxewBl U5Fefvnl9evXFxWpeGtVZGDxH0jBQgCMiwAM4N+Ubf/29fXNnHnzxRdfLKN4R0dH Z2enjMqIBO+9996SJYvl1W9oaPzDH/4grz4GyePxLFy4cMSICBrCLH5wpaePmD17 tpoWCUK8yZSZlTVuzBhto++A8FQkt7uxoUH2Qei2tra77767r0/FAykOR5l4CWAT GMAhEIABfM5qtU6dWqhmrTFjxr722msyKov7Hr/fL6MyIsSsWbP27v1MXv1p0466 7LLL5NXHYLz66qsvvvjCpEmT9L6QfysrK7/ooovOPfdcNcuJjJ2WlmZLTdV84/eL lE1F+uSTT37721WjRo2SusqAkpLSrq4uMjCAr0IABhBmNptsttT8/MkK1vJ6ff/8 5z+Tk7VviyJuGb3y7+SgrzPPPDMhQdZs3urqmqefflqrxywxBMFgcOnSJSLAKNtl HQy3O7wdPWGCiok+cf1dDAae+JUXffdTNhVp06ZNzzzzjJq3WTkIDeAQIujVBYCO bDZrYaGK+xK73b59++vf/OY3Na9sNpt9Ph+P/kY3cbN+1FFHFRTIaj40cMBVUnEc lkhiS5cuVdOFfvCCwdDixYutVquCtcIbv+npqTbbSJkbvwdwhYciufok98zv6upa dvfd3UEVvQmrqqr9fj+bwAAOigAMQOnh56OPPuapp57SvCxtn2OE1AFIfX19F198 yXHHHSepPg5t3bp1mzdvlvfuxhDY7fbvf//MGTNmqFnOZDZnZWWNyc1VFn0HhKci OZ3NTU2yj8/s3bv3wZUrs3Oypa4yoLTU0dnZSQYG8GUEYCDWmftvucaNG6tgrUCg 7eOPP9b8fGl8fHwgECD9xoKZM2cWF++TVNzr9T366KOSiuMQxPfvokWL5J1sH5qq qupbbrnlpJNOUrCW+CGWPmKEzWYbmZWlOP0OEBm4uqqqRX4DhS1btjzzzDMK3uYQ YV5k4Pb2dtkLATAcAjAQ6ywWi6rpFKV/+ctfTjjhBM0rd3V1cZcTI370o7PkbVJN mjT5mmuukVQcX+WTTz554IH7x40bp/eF/Aev17d48WI1TZvMCQlZWVm5o0frEn33 c3s8LqezV/JB6GAwuOzuuzu7VDTqt9tLuru7enpUdJ8GYCAEYCCmmc3mpKRENYN/ jzvu+DVrtD+8Km7XWlpaNC+LyHTUUUdNnCilEZHI1dddN0NZlyPE9fdsX7ly5fvv vxdRY34FEUTvumuBgl5o8fHxIzIyrFarXhu/XxQKhZwuV1Njo+yD0MXFxQ888ICa J71FBu7ooBsWgP9AAAZimrLBv62tgT179mh+h2cymbxer+wtC0SIffv23XzzTEnF m5ubH3vscUnF8WW1tbVLly7JzMzU+0L+Q2mp45xzzrn00ktlLySib2q/7Oxs3aPv fuGD0DU1LT6f7IWUHYQuc5S1tbfzGgHgiwjAQOxS1vuqpKR0x44dmj9KZzabW1pa gsGgtmURsR5//PFXXtkoqfjo0bkzZ8pK1zjA2rVr//jHP06Zkq/3hfwHl8s9Z84c Bf3wTSZTRlbWOCVTjo6U2+Nxu1yye0d1d3cvW3Z3V1eX1FUGMBYYwAEIwECMEjde Nptt8uRJCtY65phjn3zySW1rijvIQCCg5v4JEUJqB6z/9/9+fOqpp0oqjv18Pt/i xYtkjAEfJvHDZPHiJampqVJXCTe7SkuzpqZmK5xydERCoZDL42n0eKKpI7TIwPSJ ALAfARiIUSL9FhYWKFjI72/ds2ePtk/TiZvItrY20m+sOffcczs6pNzFlpWVP//8 8yaTSUZx7Ld58+YXXnhhwoTxel/If7Db7Wec8f3rr79e9kJ6TTk6UiID19bV+bxe 2RlY/Hl45plnFLwS9XfD6mYTGMAAAjAQi6xWq7jnEDFS9kLiznLHjj+ffPLJ2pal 7XNs+s53vpOWJmWDrqure+XKlTIqY0BnZ+fSpUtDoaCCHztHpLq65tZbb5XRnf6L dJ9ydKSCwWBVZWVrICB1FRFKly5ZEgypeIylpKSkvZ1uWADCIut1CIAaynpfTZ1a tG7dOm1r0vY5Zh1zzNHjx0vZPMzJGTVr1iwZlRHXf9j1vvvuy80drfeFHKilxb94 8eLsbImncMPNrkTwTUvLiaRmV4Ph6id7E3jPnj2rVj2kYNxUeXlFW1uAkUgA4gjA QAxS1vuqqalZ3NyI5TSsSdvnmBUIBM4//zxJ+4cnn3zK+eefL6NyjAsGgw899NDO ne+rmbU2eCLX2Wypc+bMMZvN8lYRf1wzs7LGjhmjYKKS5kKhUF19vbe5WXYGfvml l9Zv2KBgHH1pqaOjo4OXDwAEYCC2iLu9zMzMvLxxshcS90zXXnvdFVdcoWFNcfE+ n0/clmlYE0axa9eu+fPnSSp++eVXRFpCiwKlpaUrVqzIUdLl6IhUVlb+/OcXnXPO OfKWENE3LS3NFsHNrgYjfBC6qqq1tVXqKqL+0iVLTGYVT+DTDQtAHAEYiDXKDj+n p4944403NCxoMpnEfVJ3d7eGNWEg69evf+aZtTIqOxxlL774YqQ9m2poPT09v/3t b//6178q2NY7Ul6vd+HCRbm5ufKWMJnN4Y3fiG92NRgutzt8EFryrukHH3zwyCOP jB07Ruoqcf1PAnd10Q0LiHW83gMxxGw2JycnKzj/XFdXv2fPnqysLK0KinAi0i8j f2PZfffd9+c/75BR2eVyP/XUUzIqx6by8vJ77lk+cuRIvS/kQH19feIH4Pz5d8nL pYZrdnVY4YPQTqe3qUn2QegHV670NHikLjGATWAABGAghih7+vd///fc2bNna1iw o6Ojs7NTw4IwnEWLFu3c+b6Myu3tHatWrZJROdb09PQ8/PDD77zzjpqfM0ekrKz8 p/0k1Tdus6vDEhm4qrLSL/kgtNPpXLZsWWqqTeoqcf19v1taWtgEBmIZARiIFcrS b3y86YMPPtCwoLj9kv0QGiLfnXfe+fHHu2VUFn9ixZ23jMoxpbS09N57783OjriN X6GxsWnBggV5eXmS6ptMpozMTIM2uxoMlzt8Elp2+6g333xzzZo1EydOkLpKXP9Y 4I4ORiIBsYsADMQKi8Wi4Hk8h6Psww8/nDJlioY1fT6f7NN3iHwzZ84sLt4no7LV ap0//y4ZlWNEKBRatWrVe++9F4FP/IofHUlJyfPnz5cUTcPNrtLTbTaboZtdHZb4 T1zvdDZLPggtii9bdndA8vDhuP7Xqfb2dtpBAzGLAAzEBGXbv1//+gmPPfaYVtVM JpNIv5xVg3DttddWVJTLqJyePkLbE/sxpbi4+L777hs1KkfvCzmIsrLyCy644Gc/ +5mk+uGm+iNHjhk9Ooqj737hg9BVVX6/X+oq+/bte3DlypHyzxEwEgmIZQRgIPqJ m7OsrCwFDTa9Xt9nn32m1U6LuLlsaWmh8RUG/PrXv66rq5VROTs755ZbbpFRObp1 dnY++OCDu3Z9GJkTpJqamhYuXDR27FgZxePj40dkZFit1qhpdjUYag5Cv/zyyxs2 bJD9jm1fX5/IwHTDAmITARiIfmq2f7Ud/GsymQKBQFdXlybVEAWuvfY3FRUVMipn ZmbdfvvtMipHsa1bt77wwgsK3lYbgv5uzynz5s2Tcew5Ogb8Do2ajtCtra1LFi82 J5jlLTGgpKRUvMRwwgiIQQRgIMqZzWabzZafP1n2Qlar7c0339SklLjFFOmXkb/4 ohtuuKG0tERG5fT09Nmz58ioHJV8Pt+yZctMpvjInJxcWVn5s59deO6558ooHk0D fodGTUfod9999/HHHx83Tsru/RcxEgmITZH46gVAQ2p6X1VX1+zevTs3N1eTap2d nbToxAFmzZq1d+9nMiqnpFgWLFggo3L0Wbdu3datf5w0aZLeF3JwLS3+hQsXjho1 SvPK0Tfgd8hcbrfL6ZTdmHDFihU+n1fqEnH97aC7u7t6engSGIgtBGAgmpnN5qSk RAVP6H3nO6euXLlSk1IMPcJByRuDJG5/7733XhmVo0l5efn9998/YkS63hdycHa7 /dRTT5s5c6bJZNK2cvjMc2pq+Mxz1A34HZrwQej6em9zs9QM7HA4xJ+3zMwMeUsM KCkpaW/n/VYgthCAgWhms9kKCwtkr+L3t3722Wda3Xcy9AgHtXDhwg8+2CmjckuL f/Xq1TIqR4eOjo6HHnpo165dETjlaEBtbd2tt956/PHHa15Z/FgLn3keM4bo+0XB YLCqqkr2O5Wvvfbas88+K/slrH8TuJsngYGYQgAGopbVahW3DrKf0xNh9YYbbrz0 0kuHX4qhRziExx9//JVXNsqoXFVVvX79ehmVo8BLL720efPmvLxxel/IV+rq6lq4 cFF6usZb05x5PjRXP6lvVra1tS1atMhs1nhL/8t4EhiINQRgIGrZbCIAS2/+bLFY 33rrreHXYegRDm3btm0PPfSgpOI33HCjpHk5xlVdXX3//feLHyN6X8hXKi11nHXW WVdeeaW2ZQfOPFtTU3M48/zV1ByEfuedd9asWSP7/Zfq6pqWFh9PAgOxgwAMRCc1 o4/Kyys++uij8ePHD7MOQ49wWBUVFdde+xtJxb/97f+aPn26pOKG097e/tvf/vbD Dz+M2DPPQmNj05w5cyZP1ri/PX2eBy98ELqysjUQkLrKsmXLWlv9UpeI40lgIMYQ gIHopCYAn3DCiY8++ugwizD0CIM0ZcoUSQ8EpqePmD17tozKxtLX1/fss89u27Zt woThvqslj7hIi8Uq0q+2Y3458zwETpfLLfkg9L59+1auXJmdPVLeEnHh99cqxcsQ D+AAMYIADEQhNem3qal57969SUlJw6zT0dHR2dmpySUhup188smS7oMbG5vWrFkj o7KB7Ny5c+3atQr67g5HdXXNJZdccvbZZ2tYkz7PQxYKhapralp8PqmrvNBP9nkE u72E8XtAjCAAA1FITQC+8MKfz5o1a5hFGHqEwZs+fXp3t5Rz8n19fVdeeVVBgfSW 6ZHJ5XKtXLnSZIqX3TNvmDo7uxYsWJCRoWVEN5vNGZx5Hga3x+N2uaTunTY3Ny9Z vDjFkiJvibj+hywCgTY2gYFYENEvdQCGQE367e4O7t493KGsInW0tLQw9AiDNGPG jLIyh6TiubljbrrpJknFI1Z7e/vDD//uww93KZiXNhwOR9mPfvSjX/3qVxrWFGl/ REaG+IHJmefhCIVCTre7qaFB6k/yP/7xj888szY/P1/eEnFsAgMxgwAMRBsFAVjc 6MydO++cc84ZThGTyeT1ent7abyJwVq1atWf/rRVUnGXy/3kk09G+Baohnp6ep54 4ok333xz0qSJel/LYXi9vrlz5w6/2d5+4TPP6ek2my175Eii7/CJDFxVXe1vaZG3 RGdn56KFC2XftFZWhocbswkMRL1YeaUHYoSa7V+r1Sbum4dTwWw2+3w+cduk1SUh FuzatWv+/Hny6n/jG98899xz5dWPEH19fc8///zrr7+emzta72s5DLu95LTTTrvp pptMJm2GwYromyqCb1oaI4605Xa7XS6X1Dc0//rXvz7++OOyRyLRDhqIBQRgIKoo CMAOR9nu3bsnTJgw5AriXra1tZW2zzhSIrkde+yx48fnSarv9XofffQxScUjxKZN m7Zs2ZKTk633hRyey+W+/fbbjzrqKK0Kip88mVlZY3JztW0fjbiBscBOp7epSepB 6KVLlrS1t8mrL1RVVfv9fjaBgehGAAaih5rt36lTi9atWzecCiL9sveLoTn33HM7 Otrl1f/610+48MIL5dXX0Y4dOzZu3JiRMULvCzk8EaISE5Pmzp2bkqJN3yNGHCkQ HgtcVSW1qeEnn3yyatWq0aNHyVsijk1gIAYQgIHoYbNZCwvlBuDa2rp9+/alp6cP uUJbWxt7vxiyRYsW7dz5vrz6dXV1jz76mNVqlbeEeq+//vprr702YsTQv21VEv8J Lr74krPOOkuTauHHfdPSwo/7cuZZPgVjge+///6mpkZ59YWamhqfr4VNYCCKEYCB KCFu2QsLC2S38PnGN775u9/9bshfLqKvCMAaXg9izSeffHLHHbdLXcJsTli6dKnU JZTZunXrli1bDLHrG9e/8WsymefNm6fVGxBms3ngzDPRVw0FY4FLSkpEBh45Mkve Ev2rlLa3SzxpAkBfBGAgSlgslqKiqVKXcLs9drs9OTl5aF/e29vbIrNNKGLEySef nJ09Ul59EcNOPPGkn/3sZ/KWkE38I7zyyitvvPFGZqaWI3Olqq6uufDCC6dPn65J NZPJNCIjQ/xU5MyzYm6Px+V0Su2G9dxzz7788svTpk2Tt4TdXtLd3c0mMBCtCMBA NDCbzSKXyn4A+Iwzvr98+fKhfW18fLzX62XkL4bv6quvrq6ukrqEw1Em/qgXFET0 aNyDEnft69ate/fddyO/w/MX9fT0zp8/Py0tbfileNxXX6FQqN7pbJbZDau2tnb5 smXpko/0swkMRDECMBANFLS/ampqLi4uHtoNpclk8vl8vJsOTbz55l9WrFghe5Xq 6hqRgYfT7VyxlpaWp556ateuXRMmaDYvVwHx7/mCCy7QZPoUj/tGCJGBKysrpXbD ev7551988UWph55EAO7q6uJlC4hKBGDA8MStnrjnmzx5ktRVzjnnf+fMmTOELzSb zX6/n8ZX0NA3vvGNrKxM2avU1NQuWrRoypQpshcapvfff3/r1q3FxcWFhUbasu7r 64uPN82dOzc1NXWYpQam+1rT0kYRfSOD7G5YHo9n6dKl4r+5pPoD2AQGohUBGDA8 Bdu/ra2Bzz77bAgdtkwmUyAQ6OrqknFViFkzZ84sLt6nYKGysvLbbrvtlFNOUbDW kRLfVs8///z777+XlSW3IZAMdXV1P//5RWefffbwS5nM5szMTKb7RhQF3bBeeeWV 9evXS33Tx24v6ehgHhIQhQjAgOHl5o7Ozc2VusSFF/581qxZR/pVIjCL9MveLzRX XV393e+eXlRUpGCt4uLiU0897eabbzaZTAqWG4y33nrrzTff3Ldv35Qp+XpfyxHr n/GbOHv2nOG3eo43mUaMGCHq8LhvBJLdDaupqWnJ4sUWq0VS/bj+7/1gMMQpaCD6 EIABY1Ow/ev3t+7du3cI27+dnZ28fQ5Jzj333I4OdacTxd32rbfeNnWq3EbrhyYS 7/bt2z/55BNjNbj6IpfLfckll5x55pnDrBPudJWebrXZskeOJPpGplAoVFtf721q krfExo0bN6xfXyjzFZBNYCAqEYABY1MQgM877/w77rjjSL9K3P1IbYKCGLd58+bV q3+vckW73f61rx137bXXyj5wcYCB3PvZZ5+NHJkle9C3PCJIfPvb377pppuSkpKG U4dOVwbi9njcbndPKCSpfkNDw9KlS7SaGn1QVZVV/tZWNoGBKGPUl1IAcf3pt7Cw QOo9sc/XUlxcPIQlfD4fQ48g1WmnnSa7C86XiSB39NFHn3322f/1X/8lb5VgMLhj x46PP97tcJTl5GQbN/cO8Hp9t99+e37+sA5shztdpabaUlNziL4GEQqFnG53U0OD vNeCl19+ecOGDVLfBS4pKWlvZxMYiCrGfk0FYpzFYpE6B0KYPv2cuXPnHtGXmEwm r9cr79EvYMDDDz/8f/+3Ra/VGxubjj322B/84AdHHXWUJgW7urr++te/fvbZZ1VV VTU1NQUFkd59ejDKysrPPPPMq666apgZ3mw2Z2Rljc3NJfoaS7gbVlVVi98vqb7b 7b576VJbqk1S/bj+ANzV1c0mMBBNCMCAUSUmJlitcqcfNTd77Xb7EfX+EfepLS0t wWBQ3lUB+5166neGP0RnOPr6+lwu17hxefn5+UVFRV//+tcHfz11dXV79uyprKwU FTz9h0Vlv5+lWHd38I477hg1atRwioifPyMyMy0pKXS6MiiX2+1yOuVtAr/QT/ZM YOYhAdGEAAwYlYKnf3/0o7MXLlw4+M9n6BEUEze+Tz75ROScEBZ3+fX19ampadZ+ iYmJCQlmobe3Lxjs7urqFtra2lpbW8X9tLHG9h6R+nrn+eefP3369OEUET9P0jMy rBYL0dfQZI9EcjqdS5cuTU9Pk1Q/jlZYQNSJlJsGAEdK9vlnl8vtcDgGP1qToUfQ xVlnnSWCp95Xgc+VlJR+61vfuvHGG5OTk4dcRPwwGSGiL/ONooXskUgPPvig2+2S 90ZYmaOsvaODU9BA1CAAA4akYPv3pJNOXr169eA/v6Ojo7OzU971AAe1d+/eH//4 x7K/HTAYra2B2267beLEiUOuEJ5v1D/al/lG0SQ8EqmuztvcLKn+Z5999tBDD2Vn j5RUP45WWEB0IQADhmS1WqSOJK2oqBSv9xkZGYP8fIYeQUfXX3+9w1Gq91XEtNra urPPPvuiiy4acoXwfKP0dBujfaNUeBPY5eqVtom6fPlyv79FUvE4WmEB0YUADBhS VlbmhAkT5NWfNGnyCy+8MMhP7uvra2lpYegR9BIMBk877bSMjBF6X0gsKi11fPvb 354xY0ZKSsrQKnwefa1WRvtGsVAoVFdf39zUJKn+3/72t0dWrx4zdoyk+nG0wgKi CAEYMB7Z55/Fy/wnn3wyyIDN0CNEgo8//vi8887jILRKfX19wWDotttuy83NHVqF cPRNS7PabIz2jQXu/lbnPaGQpPoLFizo7pbYgpFWWEDUIAADxiO7/VVGRub27dsH 85kMPULkuPHGG0tK7HpfRaxoaGj8+c9/fuaZZw7ty4m+MSgUCjldrqbGRknHhd58 880n/rBmvLSzUTU1tT6fj1PQQBQgAAMGYzKZUlJSpO503Xbb7RdccMFgrqS1tZW2 z4gQ4q76rLN+GDkjkaJVdXWNyL2XXXbZEU0I34/oG8tEBq6sqGgNBGQU7+jouOuu uxISzDKKD+AUNBAduFEADEb2+ee2trZPP/3ssJ/G0CNEIJ/PJ7KZ1GawsWzgcd/r rrvOYrEM4cuJvhDqXS6PyyVpE3jjxo0bNmyQN2Hbbrd3dDDsADA8AjBgMLLPP59x xveXL19+2E9j6BEi06effnreeefl50/W+0KiSn9ciZ81a9aoUaOG8OVEX+wX3gSu rJQ0NaC2tnbZsmUjRqTLKB7HQGAgWhCAASOxWq2FhQXyDnlWV9c4HA6bzXboT2Po ESLZli1bbrzxhqKiIr0vJEq0tbVfeumlp5xyyhC+lg7P+DKny+WWtgm8YsUKn88r o/IATkEDUYAADBiJ7PPPg5x+5PP5GHqESLZhw4bZs++cNm2a3hdibD5fy09/+tMz zjhjCF8rom/6iBHiRxZzfXGAUChUVVnpl/Mu6gcffPDII4+MlTYPiVPQQBQgAANG YrVapk6Vdf5ZZNqVKx889dRTD/E5JpOJNpgwhIULF+7c+T49sYamsbHpJz/5yfTp 04fwtfEmU3p6OtEXhyDvSWDx8jR/3ry+OFlv0VZUVAQCbbwIAobGnQFgGDabtaBA 4vnnYDD00UcfHeITzGaz3++n8RWM4qabbiou3kcGPiIeT8MPfvCDn/3sZ0P492Yy m0eMGGGxWEZmZRF9cQhSnwTesmXLs8+uy8/Pl1E8jlPQgPFxWwAYhuzzzz/84VmL Fy/+qr9rMpkCgUBXV5e8CwA0t3Tp0iee+APPAw9GQ0Pj//zP/wwt+poTEkT0TUlJ IfpikORtAtfX19+9dGm6tFZYnIIGjI4ADBiGuLmcNk3WfXx5eYWQmpp60L8rbojb 2tpIvzCirVu3zpw5k77Qh9DY2PSDH/zgggsuONLoG+5xlZqaYrUmJiZmZWYSfTF4 UmcCL1++3O9vkVFZqKysam1t5RQ0YFwEYMAYzGZzYmKCvKY+WVkj//SnP33V3xXR lxNfMK5du3ZdccUVeXnj9L6QiOP1+n74wx+ee+65R/qFnz/oa7HQ3hlDVltX1+Dx yKj81ltvrVmzZsKE8TKKx3EKGjA4AjBgDLLPP//mN9eKhHDQv9XT0+P3++UtDShQ V1d38cUXWywpel9IROjr6+vq6j7nnHO+973vHenXms3mdB70hRbcHo/b5ZKxlSpe sxYsWJCSkqx55QF2e0lHR4ek4gBkIwADxiBuN4uKZPV/drs9FRUVBz39KH7T6/Uy 9AhRoLe399e//nV9fV0st8UqLXUcc8wxF1xwwde+9rUj+sLwaee0tBSLRYReoi80 EQqFauvqvM3NMoo/9NBDLpdT0je7CMDd3d2cggYMKnZvAgBjGTkya/x4Wae5CgoK n3vuuS//vtls9vl84h5F0rqAek899dQDDzwQg8ehq6trTjrppMsvvzwrK+uIvtBk Nqenp1ssFsYaQXNuj8fldPb29mpeedeuXb///e/HjMnVvPIATkEDxkUABgxA9vnn efPm/+QnPzngN2n7jGjl9Xqvvvoqv98fC1vBfX19ra2B008//YILLjCbzYP/QrZ8 oUAoFKquqWnx+TSv3NnZedf8+eaEI/gzf0QIwIBxRf9rPxAFpAbghobG8vLyL/9+ a2sre7+IYq+++uo999yTmZmh94XIUlFRecwxR//4xz854YQTBv9VIvem2mzJFktS UhK5Fwq43G6X0ynjQZvnnnvu5ZdfktQ8srjYLjK2jMoAZCMAAwYgdQBSfn7+hg3P H/Cb7e3t7P0i6oVCobvuumvz5s3RdCLabrdPmjT5lFNOOf/880WIHfwXms3mtPR0 S0oKjZ2hkvg2rKqqktFqcc+ePStXrpR0Crqqssrf6u/p0f7wNgDZCMBApBN3ouIu Vt4O8G233X7BBRd88XeCwWBAzmxGIAK1t7eLGPynP22V95i9Gm635/jjj7/oootG jRo1+K8ayL3JycniRw2zfKGLOqfT43JpXnbgWzsxUdYfaU5BAwZFAAYindTzz1/u /9zX1+eT8DgWEOECgYC4V96xY8fYsWP0vpYj43K5jzrqqDPOOOPkk08e/FeZExLS 0tLIvYgE8uYhPfjgg263S14vaIYhAUZEAAYindQAPH78+Jdf3rj/L00mk9frldGQ EzCEUCj02GOPvfLKKwkJ5khukdXX1+fxNAzk3pNOOmmQXzXQ1yqpP/SazWZyLyKE +L6rqa31eb2aV965c+cjjzwybtxYzSvH8RgwYFiR++oOYIDUB4B/8YtLb7jhhoGP xQ1xS0tLMBiUtBZgIB988MHatWv//ve/jxx5ZEODpCorK584cWJRUZHIvfn5+YP5 koGmVkkpKeb+1EtfK0QmSa2wmpubFy1aaLVatS07oKKiIhBoYxowYDgEYCCiJfaT tANcWuqoqamx2Wxx/Xu/ra2t3d3dMhYCjOudd9556aWXdu3aNWJEui57wiL0jhkz Ji8v76STTvrud787mFFG4dCbmpqYlJTQj9CLyCevFdaSJUva29s0LzuAx4ABIyIA AxFN6vnn+HjTBx980P9BfCAQIP0Ch1BRUbFp06bdu3c7HKV1dXWSZqvE9T9YmJGR kZubO3HixBNPPFHkXpPJdOgvGdjmFYnXZP4coReGU1tf3+B2a152y5Ytzz67bpAn Jo4UjwEDRkQABiKa1AB8wgknPvroo+KDzs5OXsKBwfP5fNu3b9+7d29lZaXT6XS7 3X5/S1HRET+qYLfbrVZbWr+cnJy8vLypU6cef/zxh86uIg/brFYRd+NNYebw/5N4 YXhuj0d8N/Vp3YSipKTkvvvuy84eqW3ZAeJbuKODx4ABgyEAAxHNYrEUFU2VVHzB goVnn312T0+PjFNnQEzp7Oz8x0cfVVdX19fVNTY2Blpbg6FQV1dXqF9c/+MMSUlJ ycnJ4ps6JSVFxN0J/b68uxs+aB0fb4qPt1qtItOKvxRBt/+Xz38V6F+F6BM+BV1d 7W9p0bas+DacN29eQsLhnx0Ygn37ikV9GZUByEMABiLa2LFjR43KkVG5rq6+pqZG 3E/7fD7N+44AEHfzzV7vAd9c4b882Pdb+MU4fuCXz1+XxQekXMSauvp6j4RT0Pfd d19zc5PmZeP6j0B3d3fTBwswFgIwELmsVkthYaGkvjsWi/Wdd94R6ZdXbgBAJHB7 PC6nU/NRfNu3b3/66acnTZqobdkB9MECDIcADEQuqQ8Af+Mb37znnntofAUAiBCS TkGXlZWtWLFC0kgz+mABhkMABiKX1AB84403nX322ZKKAwAwBDJ6QYuAOn/evMSk RG3LDiAAA4ZDAAYil7wOWA5H2b59+xITpdwNAAAwNOFe0PX1mnemuPvuuwOBVm1r Digutnd20ggaMBICMBC5UlJSpk074sEqg9HZ2fXWW2/JqAwAwJCFQqHKysrWVo3D 6saNGzds2FBYWKBtWaGqssrf2ko3DcBACMBA5MrJyRk3bqyMyqNH565du1ZGZQAA hqO6pqapsVHbmv/4xz9WrVol4yW1r6+vrKw8EAhoXhmAJARgIEJJbQH9ne+cOn/+ fBmVAQAYjjqn0+NyaV724d/9rq6+TvOycf0ZuLS0tL2dJ4EBYyAAAxGKDlgAgBgk 6THgHW+88ee//FnbmvsxDAkwEAIwEKHkBeDi4mK7vSQ5OVlGcQAAhkPSY8Dd3d0X XvizadOmaVt2AAEYMBACMBCh5AXgxsamv//97zIqAwAwfFXV1c1NTZqXvfQXv8gb n6d52TgCMGAoBGAgQsmbgWQymbdu3SqjMgAAw1dbV9fg8WhedsaMGenpaZqXjWMa MGAoBGAgQskLwLm5Y55++mkZlQEAGD6ny+VyOjUvO3fOnN6+Xs3LxhGAAUMhAAMR St4Q4OOOO/7ee++VURkAgOFzud3O+nrNy967YoXX59W8bFy4uYa9s7NTRmUAmiMA AxFqzJgxo0ePklH57LP/34033iijMgAAw+dpaHC5XD2hkLZln3ryyZLSEm1rDqiu rmlubpZRGYDmCMBAhEpLS5syJV9G5euumzF9+nQZlQEAGL5QKFRdVdXi92tbdvu2 bW+9/Za2NQeUljra2tpkVAagOQIwEImsVsvUqVIeABYeeGDlMcccI6k4AADDJ6MR 9N69n61bt07bmvuVlJS0t/MYMGAABGAgEtls1sJCKTOQ+vr6Nm/ewhBgAEAkq6mt bWxo0LZme3v74sWL4uOl3P2Wlpa2tTEJCTAAAjAQieQNAa6oqLTb7TIqAwCglbr6 eo/brXnZn/70pwUFUzQvG8coYMA4CMBAJJIXgN1uz+7du2VUBgBAK/VOp9vl0rzs JRdfPGHiBM3LxhGAAeMgAAORSF4Abm1tfe+992VUBgBAK5JGAV9xxeW5ubmal40j AAPGQQAGIpG8ANzV1f3mm2/KqAwAgFYkjQK+6qqrsrNHal42jgAMGAcBGIhE8gJw b2/f66+/LqMyAABakRSAr/3NbzIyMzQvG0cABoyDAAxEInkB2GQyb926VUZlAAC0 4vZ46uvqNC97/YwZaelpmpeNIwADxkEABiIRARgAEMsIwAAkIQADkYgADACIZQRg AJIQgIFIRAAGAMQySc8Az5gxI50ADMQ2AjAQieQF4FCoZ8eOHTIqAwCgFUkB+DfX XJOZlal52TgCMGAcBGAgEjEGCQAQyyTNAWYMEgACMBCJ5AVgv9///vs7ZVQGAEAr 9U6n2+XSvOwVl1+eOyZX87JxBGDAOAjAQCSSF4Ddbs/u3btlVAYAQCt19fUet1vz spdcfPGEiRM0LxtHAAaMgwAMRCJ5AbiiotJut8uoDACAVmrq6ho9Hs3L/vSnPy0o mKJ52TgCMGAcBGAgEskLwH19fZs3b0lOTpZRHAAATVTX1DQ1Nmpbsy0QWLJ0SXy8 lLtfAjBgFARgIBKlpqZKeotauP/+B4499lhJxQEAGKZQKFRdVdXi92tbdu+nn657 7llta+7ncJQFAgFJxQFoiAAMRKj09PT8/MkyKl933Yzp06fLqAwAwPB5GhpcLldP KKRt2e3btr319lva1hxA+gUMhAAMRKi8vDxJoxp++MOzbr75ZhmVAQAYPklDgJ/4 wx8cZQ7Nywp1tXUNWh/YBiAJARiIUCkpKdOmFcmofOyxX7v//vtlVAYAYPgkzUBa cc89vhaf5mWF4mJ7Z2enjMoANEcABiKUxWIpKpoqo3JOTs66dbIeggIAYJgktYC+ 8847JHXAsttLOjo6ZFQGoDkCMBChrFbL1KlSAnBvb9/rr78uozIAAMMUCoWqqqv9 LS2aV772N7/JyMzQvGxcuAV0SXs7ARgwBgIwEKHkTUJyuVwff/yJjMoAAAxTuAOW 09nT06N55V9ccsn4CeM1LxvHDCTAUAjAQISSOgr42Wefy8nJkVEcAIDhcLpcIgBr Xtbtcj340IMMAQZAAAYilM1mLSyUEoCFX/7ysosvvlhScQAAhqymtraxoUHzsq++ 8sqHuz7UvOyA0tLStjYCMGAMBGAgQlmtFhGAJb1Xfdxxx997770yKgMAMGThB4Ar K/2trZpXvnfFCq/Pq3nZuP5zVSIA8wwwYBQEYCByjRo1auzYMTIqp6amvfzyyzIq AwAwZG6Px1lfLyKl5pVnzZqVnJykeVmhqqra65USrQHIQAAGIpe8UcBer+9vf/ub jMoAAAxZbV1dg4QBSMJlv/zl2HFjZVRmCDBgLARgIHLJm4Rkt9v/+c9PU1NTZRQH AGAIwuefq6r8fr/mlQOBwKWX/mLatGmaV45jBhJgNARgIHLJawQtXHDBT6+88kpJ xQEAOFJut9vpdMo4/7xh/fo9/9yjedkBtIAGjIUADEQuqY2gx4+fsGbNGknFAQA4 IqFQqLauztvcLKP4grvu6g52y6gcRwtowGgIwEBES01NLSiYIqNyR0fn22+/LaMy AABHytPQ4HI6e3p6ZBS/8sorc3KyZVRm+xcwHAIwENHk9cHiMWAAQOSoczo9LpeM ylIfAKYDFmA4BGAgolkslqIiKX2w4ngMGAAQGeS1v4qT/ACw3V7S0UEHLMBICMBA RJPaB2v06Ny1a9dKKg4AwCC53G6XnPZXwpzZs/vipFSO4wg0YEAEYCCiSQ3ALpfr 448/kVQcAIDBCIVC1TU1LT6fpPq/uOSS8RPGSypOAAYMhwAMRLrs7Oy8vHGSit96 621nnnmmpOIAAByW2+Nx1tdL2v59+803t72+XUZlobKyyicttwOQhAAMRDqpjwEX FBQ+/PDDkooDAHBooVCoprbW5/VKqr908eK2Dlk7tDwADBgRARiIdFJPQbe0+Hfu 3CmpOAAAh+b2eFxOZ29vr6T6v7riitG5oyUV5/wzYEQEYCDSSQ3AfX19y5ffc+KJ J0qqDwDAV5G9/fvJxx9veH5DfLys210CMGBEBGDAAKQ+BlxYOPV3v/udpOIAAHwV 2du/S5csaWtvk1ScB4ABgyIAAwYg9THgpqbmXbt2SSoOAMBByW7+LFz2y1+OHTdW UnEeAAYMigAMGIDUU9DCddfNmD59urz6AAAcQOrsX2H7tm1vvf2WpOJxnH8GDIsA DBiAyWRKSkqcNm2apPqjRo1+5plnJBUHAOAAoVCoqrra39Iib4nZd94p7z63uLi4 uzso7/A2AHkIwIAxpKSkTJtWJKl4TU3Nxx9/kpiYKKk+AABf5HS53C6XvO3fYDB4 6aW/mDx5sqT6xcX2zs5OScUBSEUABoxB9ino//mfH9xyyy3y6gMAMCAUClVWVra2 tspb4g9r1pSVl8mrz/lnwLgIwIAxyA7AHR2db7/9trz6AADE9affeqezualJ3vav cPVVV43MHimvPgEYMC4CMGAYUntBixuRO++887//+wxJ9QEAiJM/+kh49513/m/r H+WN/6X/M2BoBGDAMKxWy9SpsgJwXHjacM6zzz4rrz4AIMYpGH0k3HnHHfEmibe4 JSUl7e0EYMCoCMCAYcg+BV1eXvGPf/wjLS1N3hIAgFgmu/eV0NraesUVVxQWFshb gvPPgKERgAEjkXoKWvj610+455575NUHAMSsYDBYVVnZGghIXeX+++5ram6SV5/z z4DREYABI5G9Cex0uv7xj38kJCTIWwIAEINCoVBdfb23uVnq9q9Y5bLLLpswYby8 Jdj+BYyOAAwYic1mLSgokNfYQ/je9/77zjvvlFcfABCDXG63y+mUmn6FRx95pKq6 Sl59cf0Oh6OtjQAMGBgBGDAY2ZvAzc3ev/3tb1IzNgAgpoRCoarKSr/Mwb9x/en0 issvHzN2jLwl2P4FogD3uIDByA7AwrnnnnfNNddIXQIAECPUDP4Vnnv22U8/+1Tq EgRgIAoQgAGDMZvNIgNPmZIvb4n29o533nlHXn0AQOxwud1ul0vq4N8BV111VXb2 SHn1S0sdnZ2dPT098pYAoAABGDAe2b2ghYsuuviyyy6TugQAIOqFDz9XVfn9ftkL vfTiix/t/kjqEvR/BqIDARgwHpvNWlgo9xR0IBB49933pC4BAIhuyg4/C1f++lc5 o0ZJXaK0tJT2V0AUIAADhqTgSeDp08+57rrrpC4BAIhi4c7PLlef/MPPz6xdu694 n9QlePoXiBoEYMCQFARgr9f3wQcf0A4aADAEwWCwqqqqVXLn57iB5s9XXDFmTK7U VQjAQNTg1hYwqpEjR44fnyd1iTPP/J9bb71V6hIAgOgTCoXq6uu9zc0KDj+veeyx 8soKqUtUVFS2tLRIXQKAMgRgwKisVsvUqXJbYTU0NOzc+UFSUpLUVQAA0USkX5fH 0+jxKEi/3d3dV/76V+Py5L4dXFJS0t5O+ysgShCAAaMym81JSYlFRUVSVznuuOPv vfdeqUsAAKKJ2+Nxu909oZCCte5dscLr80pdori4OBgMMf0IiBoEYMDAFMxDqqio fO+997Kzs6WuAgCIDqFQqLqmpsXnU7BWY0PDtdddV1AwReoqTD8CogwBGDAwm81a UFAgu09VTs6odevWSV0CABAFRPp1ulxNjY0KDj8Ld955p+xGjeIfxOFwMP0IiCYE YMDYFMwEttvtW7b837HHHit1FQCA0bnc4cFHvfLnHgn79u6dM3fOtGnTpK7C7F8g +hCAAWNTMA8pLvymfs+OHTtkrwIAMK5gMFhdVeWXP/dowLXXXpuRMUL2Kkw/AqIP ARgwPDUZ+Mc//sn1118vexUAgBGpnHskrH366WJ7sexVSL9AVCIAA4anJgDX1zvf f//91NRU2QsBAIwlPPfI7W5saFCTfgOBwNVXXz1x4gTZCxGAgahEAAaigYJ20EJe Xt4f/vCE7FUAAMYSnnvkcikbFHTX/HlB+TOWaP4MRCsCMBAN1GwC2+32TZs2H3fc cbIXAgAYRSgUqqqq8vv9apb79NNP58+fJ7v3VRzbv0D0IgADUcJqtUydKn0TuK2t /Z133pE9eAkAYAiKH/0Vq1x91VXZOdJH05eUlLS3s/0LRCfuYoEooWYTWPjWt769 cOFCBQsBACJZ+NFfj6fR41GTfoXfrlrldDkVLMT2LxDFCMBA9FCTgcvLK/7yl7/k 5eXJXggAEMkUP/pbV1s78+abCwqmyF6I9AtENwIwED2UbQIzFhgAYlwoFKquqmpR 9eivcN21146QP/g3jgAMRDsCMBBVbDZrYaGKDHz66d+dM2eOgoUAAJFG8aO/wiOr V1fXVCtYqLS0tK2N9AtEMwIwEFXMZnNSUmJRUZHshaqqqnfs2DFu3DjZCwEAIori qb9x4UH09TfffHN+/mTZCxUXFweDIWWHugHoggAMRBs1M4EHbNu2Xc1CAIAI4Xa7 RQDuVZgSr79+RlpamoKFmP0LxAICMBBtTCaTuFGYPHmSgrVOO+30uXPnKlgIABAJ gsFgdXW1sqm/wurf/76mtkbBQg5HWXt7e29vr4K1AOiIAAxEIWXdsMrLK7Zu3VpQ UKBgLQCAvkKhUG1dnc/rVXb4ubK8/Nbbby8sVPEqQ+8rIEYQgIHolJeXl509UsFC bW3tb7/9tslkUrAWAEAvIv063e4mhY/+9vb2XnP11dk52QrWqqurb2hoULAQAN0R gIHopGwTWCgqmrZq1So1awEAdOEKP/vrUnlCeNndd7cGWtWsxfYvEDsIwEDUUpaB 7Xb7iy++dMoppyhYCwCgXjAYrKqsbA0ElK24+6OPFi9ZPG3aNAVrkX6BmEIABqKW 2Wy2WCwFBVMUrNXY2PTWW2+lpqYqWAsAoFIoFKqprW3x+ZQdfm4LBK697rpx48Yq WEuk366uLkYfAbGDAAxEM5UHoZOTUzZt2qRmLQCAGiL91judzU1NytKvcPPMmSmW FDVrsf0LxBoCMBDllHXDEk4//btz5sxRsxYAQDaRfl0eT6PHozL9PrJ6dXVNtZq1 6H0FxCACMBDlrFZrYWFBfLyKb/aysvLXXnvtmGOOUbAWAEA2t8fjdrlUHg+22+1z 58wpVHJ2SaT60lIH279ArCEAA9HPZrOpGaIoeL2+t956y2KxqFkOACBJMBisrq72 +/3KVuzs6PjNtdeOGZOrZjmRftva2tSsBSByEICB6Gc2m9PT0ydOnKBmubS0tJde elnNWgAAGUKhUG1dnc/rVXn4+bbbbk1ISFCzVnl5hUi/9L4CYhABGIgJKrthCf/9 32fccccdypYDAGgo3PjK5WpubFSZfh977LHKygply9H7CohZBGAgVths1sJCRRnY 4SjbuHHj8ccfr2Y5AIBWRPp1ezwNDQ19vb3KFv30n/9csHChsjdqS0tL29pIv0CM IgADscJsNttstvz8yWqWE7dPf/7znzMzM9UsBwDQhPrGVz6v94Ybb8zLG6dmOYej rKOjg8PPQMwiAAMxRPFB6N7e3u3bX1fTgBoAMHzqG1/19fVdP+O69BEjlK3I4Wcg xnFjCsQWxRl43Li8J554QtlyAIAh06Xx1cIFC7q6u5QtR/oFQAAGYovZbLLZUpUd hBZ3Ueeff8HVV1+tZjkAwNDo0vhq/XPP7fnnHmUHhUpLHZ2dHT096p5tBhCBCMBA zFG8CVxeXvHqq68ec8wxylYEABwRkX5dHk+j2sZXxfv2zb/rroKCKcpWZPsXQBwB GIhNNputsLBA2XKNjU1vvPEGDbEAIDLp0vjqxptuGjdurLIVS0sdbW1typYDELEI wEAsMplMI0eOVHnnEQyGtm/fnpCQoGxFAMBghBtfVVX5W1uVrRgKhW64/vqMzAxl K1ZWVvn9/l6F+9sAIhYBGIhRVqu1sLBAZYtmEbmfe269suUAAIclsmhNbW2Lz6fy 0d85s+9Ut1h/N4rSUgeHnwEMIAADsSs11VZQoO4gtHDaaafPnTtX5YoAgK8Sbnzl dDY3NalMv6sffrimrlbZcnHhwb+OQIDDzwA+RwAGYldiYkJCQmJR0VRlK5aUlD79 9FOnn/5dZSsCAA4q3PjK7Q43vlKYft97990HVq5U+bpjt5eEQsFgMKRsRQARjgAM xDSz2WSxWFU24ayqqn7ttdeKioqUrQgA+DKRft0ul8rHYktKSubPn69sDl//iqVd XZ3MPQLwRQRgINYpnooU198Uetu2bdnZ2SoXBQDsFwwGqyorWwMBZSs2NjTMuuUW lc0X45h7BOBgCMAAVE9FEtrbO954443k5GSViwIA4voPP1fX1PhbWpQdfu7u7p4x Y0Z29kg1yw1g7hGAgyIAA4gzm82jR48eNSpH5aJJScmbN29WuSIAQKTf2vp6X3Oz ykd/Z950k8VqUbacUFtb5/V6VU42BmAUBGAAYSIDJycnKz4LPW5c3hNPPKFyRQCI ZSL9Ol2upsZGlel34YIFXd1dypaL62981d3dTfoFcFAEYACfU/8wsLgDO+200+fN m6dyUQCITSL9uj2ehoaGPoWNr37/8MM1tTUqZ87H8egvgEMiAAP4N/UPA9vt9t// fvXZZ5+tclEAiEEi/bpdLpX7om+8/vrqR1ZPmzZN2YpxPPoL4HAIwAD+zWw2JyUl qZzQKJSXVzz33HOnnHKKykUBIKaE2z5XVbW2tipb8aN//GPZ8uXK31Tl8DOAwyAA A/gPIgPbbDaVcxrj+ruVbN68OT8/X+WiABAjQqFQTU1Ni8K2z5Xl5bPnzJk0eZKa 5QaUljo6OztJvwAOjQAM4EBWq7WwsEDxI1sMBwYAGUT6rauv9yps+6zLyF/xTycC MI/+AjgsAjCAg0hNTS0omKJ40UCgbfv27TabTfG6ABCt1Ld9bmtru+mmG3NylM7V ExyOskAgoHhRAEZEAAZwcOqbQsf136v96U/bEhMTFa8LANFnoO1zY0NDr6q2z8Fg 8KYbbxiRkaFmuf1o+wxg8AjAAA7OZDLl5OSMGZOreN2kpORNmzYpPoANANFHcdvn vr6+m2fOtFgtapbbr7q6xufzKQv5AIyOW0wAX8lsNlssFvVnoUeMyHjhhRcULwoA 0UR92+c7br/dZDYpW25ASUlpV1cXja8ADB4BGMCh6NIQSxg/fsKaNWsULwoA0SEU ClXX1PgVtn1etHBhZ1enmrX2o/EVgCEgAAM4DF0aYonbmmOP/doDDzygeF0AMDr1 bZ/vu/fepuYm9W+V0vgKwBAQgAEcns1mKywsULyouHU744zv33HHHYrXBQDjUt/2 +bFHH62orFCffktLHW1tbYoXBRAFCMAADi8hISExMbGoaKride12+4MPPvS///u/ itcFACMS6dfl8TR6PMrS79atW9eseXzatGlqltvPbi8JBoPin1fxugCiAAEYwKCY TKbMzMzx4/MUr1ta6li9evUPf/hDxesCgOG43GG9qjpC/eXPf374979X/95oRUVl a2srbZ8BDA0BGMBg6dUUury84sknnzz11FMVrwsABhJu+1xZ2arqmdgPdu68/4EH 1D8dQ9tnAMNEAAZwBPRqCl1RUblhw4YTTzxR8boAYAgi/dbW1LT4/WoOP3+ye/fS Zct06Y9I22cAw0QABnBkdGkKLdTU1LzwwovHHnus+qUBIJKFQqHaujqf16sm/e7b u3fR4kWTJ09WsNYBaPsMYPgIwACOmC5NoYXa2rqNGzcWFRWpXxoAIpNIv/VOZ3NT k5r0W1JSsuCuuyZNnqRgrQPQ9hmAJgjAAIbCarVOnVqoft26uvpXX321oECH+A0A kSY89MjtbmpoUJN+y8vK5s6bN2nSRAVrHaCkpJSTzwA0QQAGMBQmkyk5OVl980/B 6XS99tprupy+A4DIIdKv2+NpbGhQ0w+5qrJyzty5EyaMV7DWAez2kq6uLto+A9AE ARjAEJnNpqyskePGjVW/tMfTIDLwhAkT1C8NABFCpF+3y6WmH3JtdfXsuXPz8sYp WOsAlZVVra3+nh7SLwBtEIABDJ3ZbLbZbPn5OmzGNjY2bdq0adw4He7GAEB34aFH VSIZtipYq76u7s7Zs3V5u7O01NHZ2cnQIwAaIgADGBaRgZOTk3V5HpgMDCA2hUKh 6poaf0uLgkd/dUy/dntJd3c36ReAtgjAAIZLr+HAcWRgALFH5dAjHdMvI38BSEIA BqABvYYDx/Vn4K1bt44aNUqX1QFAJZVDjzwez6233qpL+o1j5C8AaQjAALSRmmrT azpRU1PzH//4RzIwgOgm0q/L7W5UMvRIpN/bbrtt7Ngxshc6KIfDEQgw8heAFARg AJqx2WyFhWRgANBeeOhRQ0Ojx6NgGpC+6be01NHWRvoFIAsBGICWrFarLg2x4sjA AKKasqFH+qbfkpJSnvsFIBUBGICWEhISkpISp06dqsvqIgO/9tpr9MQCEGWUDT2q r6ubPWeOfum3pLs7GAqFdFkdQIwgAAPQmMlkSk5OLirSJwPTFxpAlFE29EjHns9x /UOPurq6FBzwBhDjCMAAtGc2m7Ozs8eMydVldZGBX3vttby8PF1WBwANKRt6VFdT M3vuXL3Sb3V1TUtLCyN/AShAAAYghcjAmZmZeXn67MR6PA0iA0+YMEGX1QFAE8qG HtVWV4v0q9dP7MrK8Olu0i8ANQjAAGQxm02pqWmTJ0/SZXWRgV999dWJEyfqsjoA DJNIv063u0n+0KOaqqo58+bplX4djrKOjvaeHk4+A1CEAAxAIrPZbLPZ8vMn67K6 0+nauHGjXtOJAWDIwkOPPJ7GhgbZz8SWl5XNv+uuCRPGS13lq5SWOjo7O9n7BaAS ARiAXCIDWyyWgoIpuqxeV1f/wgsvHH300bqsDgBD4+4nOxkWFxcvWrRo0iR9TsqU lJR2dXWRfgEoRgAGIJ3IwMnJyXrNB66trVu/fv1xxx2ny+oAcKTUDD369J//vPvu uydNniR1la9it5d0d3eTfgGoRwAGoILIwImJCdOmTdNl9erq6nXrnj3ppJN0WR0A Bk+k39qamha/X+qjvx/v3r38nuX5+fnyljiE4uLiYDBE+gWgCwIwAEWsVmthYUF8 vD4/dioqKteuXfutb31Ll9UBYDDUDD3a9eGH9953n15Ppoh/tNJSR3t7uy6rAwAB GIA6qampU6bk65WBy8sr/vCHNaef/l1dVgeAQxPpt87p9EoeevTeu+8+tGqVjum3 rKw8EAjosjoAxBGAASimbwZ2OMoefvjhs846S5fVAeCrhIceuVxNjY1S0++fd+xY /cgjenVkIP0CiAQEYACqiQys1+ZDXH/f0fvvv/+8887T6wIA4AAi/bo8nkaPR2r6 /b8tW5586qmioqnyljg0h6OM9AtAdwRgADrQNwPb7farr75m9uzZel0AAOwXHvnb 0CDSr9SRv4+sXv36G6/r1YkwjvQLIGIQgAHoQ98M3NfXd+yxX3vggQf0ugAAGOD2 eMIjf0MheUvcd++9Tc1Nej17Ekf6BRBJCMAAdJOaaisoKNBrdZGB8/OnPPLII3pd AAAEg8Hqqiq/zJG/S5csCbQFdE2/jkCgTa/VAeAABGAAetI3Awu5uWOefvppHS8A QMwKhULVNTX+lhZ5j/7Onzcv1CNxb/mwSL8AIg0BGIDOdM/AI0ZkPP/88zpujwCI QbJH/oqyd95xh8lsklF8kEi/ACIQN3wA9Kd7BrZYrC+99FJCQoKO1wAgdoj0W+90 Nksb+Svq33H77UnJSTKKDxLpF0BkIgADiAi6Z2CTybxp06bExEQdrwFALAiP/HW7 mxoaJKXfYDB4y6xZtlSbjOKDRPoFELEIwAAihe4ZOBTq2bJli8Vi0fEaAES3z0f+ ivQrZ+hRZ0fHzbNmZWSMkFF8kEi/ACIZARhABNE9A3d2dokMnJaWpuM1AIhWn4/8 bWjo7emRUb+1tfWWW24ZOTJLRvFBIv0CiHAEYACRRfcM7Pe3btq0KScnR8drABCV pI78Fbn69jvuGD16lIzig0T6BRD5CMAAIk5qampBwRQdL6CpqXnjxo0TJkzQ8RoA RBmpI39rq6vnzps3dtxYGcUHyeEoCwQCOl4AAAwGARhAJNI9AzudrhdeeGHatGk6 XgOAqCF15G+J3b5o8eIJE8ZrXnnwSL8AjIIADCBC6Z6Ba2pq161bd+KJJ+p4DQCi gNSRv5/s3r18xYrJkydpXnnwSL8ADIQADCByiQw8ZUp+fLxuP6nKyysef/zx733v e3pdAACjkzry992//nXVb3+r43uF4h+qrKyc9AvAQAjAACKa7hnY4Si77bbbrrnm Gr0uAIBxSR35u23btjVr1kydWqh55UEi/QIwIgIwgEinewYWN3nf/Oa3Fi9erNcF ADCigZG/Iv32Shj5+9ijj27bvk3HPgWkXwAGRQAGYABWq7W3t0ffW73Jk/MfffRR vS4AgOG43G6P290jYeTvvStWNHubdXxbsLi42GQyt7e363UBADBkBGAAxmA2m5OS EouKinS8BovF+uqrr+p4AQCMIhgMVlVWtkrYIF20cGFHZ4e+6TcYDMkI9gCgAAEY gGGIDJycnKzjA29CW1v722+/bTKZdLwGABFOpN+amhq/36/to7+i2pzZd8bpF30F u72ku7ub9AvAuAjAAIxEZGCLxaLveKS6uvrt27ePHTtWx2sAELFCoVBNbW2Lz6dt +hVlb7v11hRLioY1j1RJSWlXVxfpF4ChEYABGIzIwDabLT9/so7X4HCULV68+OKL L9bxGgBEoPDI3/p6X3Oztum3s6PjlltuSR+RrmHNI1Va6ujs7CT9AjA6AjAA4xEZ OD09feLECTpew0BbrEceeUTHJ/EARBRJI39bWlpuvfXW7OyRGtY8UuXlFW1tbaRf AFGA+zYAhmQ2mzIzs/Lyxul7GeJ+96WXXs7MzNT3MgDoTtLIX2d9/ew5c8aMydWw 5pGqrKxqbfX39Gg/zAkA1CMAAzAqs9k8cuTIsWPH6HsZ9fXOJ5544pRTTtH3MgDo SNLI3/KysgULF+r7Tl91VXWL38/eL4CoQQAGYGBmsyk3NzcnJ0ffyygpKb344ouX Ll2q72UA0IvLHdaraUr85549y5YvnzRpooY1j1RdbV2zt5m9XwDRhAAMwNhSU1N7 e3v1nY00ICEhccOGDWlpaXpfCAClZIz83blz58qVK/XteG+3l5jNpt7ef5/ojo+P O+z57oGuCF/xaeHj4eITTCZzQMKEZAAYDAIwgANZrdZ/fRi+WRH/b7FY9O04ZRSN jU1PPPHE8ccfr/eFAFBEpN/ampoWTUf+btu2bc2aNZHwvp5ehv8vs6Kisru7Oz5+ oE3h57e77e3tw70yAMZHAAZims1m+9d9Rvh/e3t7k5KSpkzJ1/myjMzhKLv88svn zZun94UAkC4UClXX1PhbWjRMv489+ui27dumTZumVUHD0baL2BeJn8/iP5nJZNqf ikU+bmtrk7QcgMhEAAZiy792d8UNRt+IESNGjx7NFB8ZUlIs69ev/8JeOoBoEx75 W1fn83o1DGz3LF/ua/HF8o9leen3q5arq6trb2/v/3ce/tfOLjEQ9WL3JywQI6xW S/93el9vb19SUlJ+/mS9ryhWNDU1r1279uijj9b7QgBoT8bI3/nz5oV6QlpVMyjF AfjLHI6ynp4ek2kgD/e1t3foez0ANEcABqJQYmJCYmLSwG3E1KmFsbyZoK/y8opr rrnmlltu0ftCAGhJ85G/InHNufNOU4JZk2rGpXv6PYC4ntJSR1z/SelgsDsYjPW3 J4DowG0xED0GDtz29vYmJCQMPMdL9I0E6ekj1q1bl5ycrPeFANDAwMjfRpF+tRv5 u+vDD5ctX8Zzv5FMJGHx8moymeI4Jg0YHDfHgOGZzeaBcFVYWPDlv0sGjgQtLX6R gQsKDvIfCICBiPTrbmgQ6XfII39FdvK43a+//nqZwxEQf9He1tnZFezuLqTns0GI q3U4ysQHXV1dPZpOfgagBnfGgIFZrVbxSiwC8KH7NpOBI0F5ecVNN900Y8YMvS8E wNC5PSK9untC/z4KG2htFb/X2NDo9YUFAv2ptr29s7Ojo7Ozu6tbCP/S1dUdDCso mMLP5C8yVvr9otJSh7h48V+TDWHAWPgRDBhPQkJCUlJSVlbWyJFZg/wS7rcihN/f +o1vfCMjIyMzMzMnJ2fMmNxx4/ImTpzIAWlgmEKhkIigmRkZ4ifkEL5cRNMyh8Pl cjU0NLSIINsS1tbW1i7+r729Q6TZjk4RYzuFrq7w46DdQRFre3p6Ynla7/AZN/1+ UX29U/xREX88QiEeEgYMgHtiwEgGulslJiZOmjTxSL+WDByxxC1gRUWlzWazWq0W i8XaLzXVlpqalpqamtFvVL+xY8eOHj2atIzoINJCs9crPsjKzBxaav2iOqezqrKy LRAQUTacYL1ef2trIBDoaG9vC+/HDkTX8C/B/nZG3V1d4gJEiA3/ZTjKhmL5EVy9 REcAHlBZWdW/x0+vLCDScUMMGIYIRUlJSRMnThhyBTJwFBD3i+XlFSIDW/qlpKTs /8DWL7Vfenr6QHLOycnJ7jfM2KxtVkHkU/BfXERWj9sdaG0Nb50Fg36/P9Dqbw2E d1zb2to6Ojr642o4tPYfHv78EHEoTIQM8UtQpFbxQfg3xce9PSRYY4mm9LtfdXWN +DPLoWggknE3DBjAwLO+mhy0IwPHLIejLCkpqT85p4j/FR+LPJE0cKig//fFbyWn hFktFutAmLZaw3naZkvvP1YqPk/8URw1evS4MWPUX/9AHht44i4KQnjk/+MMpFOR QON6e/t6e9s7O9v6n25t6z8S3PWv7dTufuEt1ODnwvH0Xx/0iITa/z///vhfH4hf e3t7CwsL+KEUg6Iy+n5RSUkpzwYDEYtXHSCiidvilJTkKVOmaFiT200M2cBUTJPJ lBgOxIlmkykhwWwyJwx8YE5INAvhjxPCnyPSdYJZfJ6p/3fEXw58IPK2+Fxz+M92 ysDvp4Tzd7LJbE4SeTwpHMXFL6JOitUqPtNitSSYzOJ+uaOzUwRy8QdYrxCuoYF4 2TegpyfVZhPBMtTbE+wOimDZ29vT0d4R198xeCAodnSE/7Kjvb2vv/fs/pwp/q74 VXyCSKDi1/3BUnwgfhVJU3xi+H97egd+v/83v/DRvz4I/eszBrKpSLy9/W+68eMC mov69Dug/7ROeWdnFw8GA5GGFzYgcomMkJmZOW7cWM0rc1MLQysuLu7rDd9DixQ9 8Ec5XmTr/j/V4gNz/6DO8O/0f/BF4k/+l39zaA46/qTnP+90RaYcuE4RJgdmxvb0 76b2X14853URg2Ik/e5XV1fv9XqZlgREFG6CgQil4bHngyIDAwBUirX0O4Dj0ECk 4Q4YiEQ2m62gQMtjzwdFBgYAqBGb6Xc/h6Osra1N76sAEMbtLxBZzGZzcnJyYWGB muXIwAAA2WI8/Q4oLXV0dXVxHBrQHfe+QAQR6XdEevr4CeNVLkoGBgDIQ/rdr7q6 xu/3k4EBfXHjC0QKkX7T0tKGM+Z3yMjAAAAZSL8HIAMDuuOuF4gIOqbfAWRgAIC2 SL8HRQYG9MUtL6A/3dPvADIwAEArpN9DIAMDOuJ+F9CZSL/p6ekT1D73+1XIwACA 4SP9HhYZGNALN7uAnkT6zcrKHDt2rN4X8m9kYADAcJB+B6m+3tnc3EwGBhTjThfQ U3p6+uTJk3S+iC8hAwMAhob0e0QqKypb/H69rwKILdzmArqx2awFBYrm/R4pMjAA 4EiRfofA4Shra2vT+yqAGMI9LqAPq9VaWBih6XcAGRgAMHik3yErLXW0t7frfRVA rOAGF9CByWRKSUkuLCzU+0IOgwwMADgsou8wORxlHR0dvb29el8IEBO4uwV0EPnb v/uRgQHg/7d351GO3IWBx2uk1i313XP1TN/H+ILYjs1kgweDDXZeyEtimyMxyYId 7GxC8l7I4oRNNsk/a5KAwbxdB4LzNgkkJLA2JMDuI8AY4wMM+MBjbEt9TPccnj5m pi+11JL6mP2pqrtcLbXUVaUqXfX9jK1Rq0ulUk+3qr79K1WhCOrXEgwCA2XDpi1Q bjVUv4pdGzgWG3ELLtfGpUvr6+tDQ9U+sg0AsITd9Ts2Nu73+8V6MxgIeDwe8XCh UEiE4vz8/OLSUn9/n62PXmY0MFAeBDBQVqITfT5v9e/8nENtYLF6bmyMNDY2tbW2 Hjhw4PLLL7/5ppuuvvbaS3L6ulwuceWZH/zg2WefnZiYmJqaEtsoS0tL8eWslZXk kSNHKvtEAABWKb1+tX0rLhrF2qWpqb29vbOzc2ho6Lrrrjtw8KD8+9WsnN/GXtrY +NGPfnj8O8d/+vLLYnUzNze3uCSiOD4w0F/iUlWK+GqkUinOigTYjQAGyqqGhn8n JiYbIxF5W6Strb2jp6fn6NGjt95yi8/v107W0NCwtramfii2VHJW3mILaWNjQ1zG 4/HHHnvspRMnTp06NTMzs7CwEI8viTBOJBI9vb3saw0ANWTX+hUTTE6e8vt8ATlu Q6FgJNLY0tIiKrdj797LLrvsxmPHDnZ27nG5Cs0hZ/2iZ4J0KvXNb37zmR/+cHJy 8uKF8xcuXFxcXFyKx3t7e/Q/tQoaGxtLJBgEBuzFFidQPtVcv6dOnc52bnv7vn37 +vr7jx07dtPb3qa27tr6ejqd9vl8DW636YcQibvjBpPo4+np6SeeeOKll146ffr0 +fPn5+fn48vxRFayt7eHNgaAqiJezGOxmM/rC4aCAb8o3EAkHG5samqW7du//8or r3zLsWPien7fihVKKp0O+P0+r7d435qjzN+vWWGJKj5+/PgTTz45cfLkzMyMWMtc uHixu7vL8oe2BDtCA3ZjsxIon7bW1kOHD1V6KTaJ4hWt29PV9YY3vvG22267+uqr lc2UQq1bKF8tUejX/KKNz7322pNPP/3KT396+syZ2dlZ0cby/tTLyZUVsflCGwOA 5bKDtxOTflkwFAoFg5FIpKmxsU3+JWl/f//PXP0zV1x+xY6Dt3r61tYVyo7zz6li sXJ54YUXvvrVr774k5+cOn16emamenr47NnXLl68WOmlAOoZ245AmQSDwYGB/soG 2+Tkqa6urmuuvvqO229/+zveoW675PSn3ZsmhhRp44WFheOPPfaTn/xk6ty5+bm5 +YWFxaWl5Xg8mUwmkkmOxQUA+WKxEa/HEwgoA7eBUHbn5FCTPHib3QOot/eKK684 cuQyUbyuwrv8FN85uapWIqqcpdI+BbFC+c63v/3II488/8ILood7erortIybGAQG bEUAA+UgVrRer2dgILv/c/kb+MzpM8PDw2+7+ebf+d3f7WhrE1sAu76xqiaIZ5HO ZFZSKX/eeLXYmolFoz945ploNDo1NXXhwoXs0HFiOZlcSSQSqVRqeHioUosNAHbI lq3X4/eJP9m2DYq4DYUi4bBI23A43Nbe3j8w8Kaf/dnhI0eKvO1Wkl9aleMalm3J q4GyWhQr6PMXLnzmM585/u1vx2Kxw12HK7IwY2Pj6XS6DlbTQHUigIFyEFsh2rM1 lKeBxcq7v6//nb/4ix/9kz/xeL2lv4m3OhUaaigS+WLD7sSLLz7/3HMjo6Mijy9e zB4lZVl+z/GKSORUqnYPIgqgzojXt/Hxkz6vV0SteA0PyHEbCgXDoXBzS4tYubR3 dAwMDFx/3XXislDZ2v2223qi7iy9msl87P77v/GNb4yfHB8eHi7zYogGFqukMj8o 4BAEMGA7ZefnnBvtbuC1zOrnHn74uuuvV+OwOvdJq5QieawclOu7jz/+yiuvzM7O Ls7PLywuLi0tJUQbi/+EVKq/v4+3HwMwZ7NpfaJGPW6Xe2Njwy8fRKq5Obsnsvhf JG5La2tfX9+111zT1dVVZG9k/WXLKkA/7ddKXP/xj3507733uty552GylVgA0cDs CA3YgQ04wHY7BrBkWwNPTU1/8J57PvShD7W1trK5Y06RnasluZAvXrz4xFNPvfLy y7MzM4uLi9nDVsezh62W+zgrnU4TyYBDRKPRhgaPSFBvNmnFZTZts4ePkndCDsuH RxZ/tbS09PT0vPENb+ju7hbrhSLvsNVm7a57I1O2dhNfYfGa/9Df/M3n/vZvDxzY X7bH5Z3AgE3YOAPsVah+FZYH0mpm9Vvf+lYwHK7LvZ3LrMhmZfFClraO0SU2i0Uk T0xOnp+dnc+e9ziekI9fvZISd02nxf+ZTC/neQKqxkhsRHSpkrKeBo93M2azl8q7 aoPyu2rFB01NTZ2HDl11xRWHZMXfVSsZbFqJrK0yyj9fcnn51ltuafA0lOdBGQQG bMJWF2Cvtra2zs6DRSawMH72dux99NFH/YGAJK84rZotCim+hSoiWVwW3ylxY31d bNxMTEw8+/zzkxMTC/PziURiaWlpeXlZZLK4nhaZnM5eZNLiT2ZtbfXIkSPWPxOg Loifx9HRMZfL5REasrJXvPIfz2bN+v3+gHJqn1BIfBAOh/fv3z80MHDg4EHRsTue tzaftmal3X7MVTRtTVNW1ivJ5Lve9a7pmeny/OLy3Lmp8+fPl+GBAEchgAEbFR/+ VVmyHu1o7/jKV74itudKnxXKye12i2+A4uPJqksbG6KWz5w588orr5w5eza+tJTt 5K0TI6dSqUwm28mr4q/V1Uw6vSpbW18jm1G1cqrVLf40eMTPxVbDNoi/vEq+ysGZ LdhgMBQMiinEa+ze9vaevr59ezva28V/7cVP3pMjp2Ml3SkrUbOOpPyLp1OpO+64 Y/b8bHkelB2hAcsRwICNWltaDh0+pGfKEhs4tZL68Y9/TP3WNJ3b08rAss5gVohs Pvfaa2dfO/tKNDZ17txyPC7aWDRzInvG5ISYlajmdCqdWX2dyID19XXx1/rampzQ 62Img0OD7K3tQLHYiPh3F4EqLrM96s4Sf4vObFCuuV8nSlUedc3Gq1cZcvX5xDeq SFYxC3FDMBTqaGvrPHSouamptS37p7m5WUyjv1pV+flq4uQ9dCx00n6fiAZ+05ve JL6zy/C4Z8+cvTg3V4YHApyDTRnALjqHf1Wm02JycnLi5EQ4EmEzzlEMbbibyOYc G+vr6XT6gmxpaWlqenpmenpRHoIWAS22DZVDf4nropizl6Kc1zYv1tfFvbN/b8iy bb2+Jl+9JG7N/iW6ZW3tkvwokhw20tZYnPJZcSme71CdFng0GhXP0iWT5J0CxKVL JT9l0Yd7NDeKf/7sP6J8uUczpfK3SFLxDZKNUDlQxS2iS5VW3YxT+TIQCGS/MS5d cns8/kCgMRJpb2trbW1tamoSL1+NjeKGLHN1mk/pVXFFm6ySqWpVka8oj5xvM/GN F4/H+/v7enp6yvDoDAID1qrDLQmgSoiNy8HBAUN3Mbdx/85ffOcf3ndfOBhkQxC7 KiUYlL21letrctcqPWOuqI0SbZxKpST5KcxdvKjcuLC4eEnKPp34UlxEsriyHI+v y1fm5uZSKys5M8kWuzyT0ok+DG7f56LB09DS0irCUr3FL7/lNPupBncoHM4uvLSn ualJ+WxrW5vyb+H3+y0pTHNy/h2V35WoSqnTfMr3D69UqC3537HZAE4kPvXAA1// +tfK8Fu5kZHRlbxXMwCmEcCALYwO/6qMrkoz6cx3H3880tjIMZ9RfmXuGffWN7me H5Md38ypxl7pdsz+nHosTv26WViY5tClQCGFfi7Ei8nS4uLNN93k8Xp2nMBaDAID FiKAAVv4/f6hoUFz99XfwOPjJ186caLz0CG2XAGdrBqu4YcOqHvFf8zFi8lrZ8++ 4Y1v7O/vs3tJGAQGLEQAA9ZT3ms3PDxkeg46t9Gvvfqaz37uc2yIAwBgLT3rVrGy /i+//dvPPf+c3QsTjUblQxNWeG8RoD4QwID1wuFwX19viTPZtYHn5uZe/unLHPkZ AABr6f/NcjqVuuqqq1paW2xdHkne52t5ednuRwGcgAAGrPeGN1xlyXyKNHA0Gvve 449fc+21DP8CAGAhQytWsaZ+/rnn3vq2tw4PD9u3SIoXXzxh90MATkAAAxYLBAID A/1Wvc+w0HzaWlu/+R/fon4BALCQiRWrWFP/wq23Xpy7aMfyaHEoLMASBDBgMZ/P pxz+yr4GnpiYPDU5GQyFLJk/AABQmPvNcjKR6Ovv6+7utnx5tF59NZo97zqA0hDA gMXUAJZsa+C33vjWv/rrv7ZkzgAAQFHKflX/7aMfPf7YcQsXJl80Gk2nCWCgVAQw YCVl/2f1Q6sCWDur6anp0dFRjn0FAIBVSn9LUTqVGhoe3r9/nyXLUwjnQwJKRwAD VsoJYMmGBn7LDcc+/sADVs0TAACHs+qAGn90332Pf+9xS2ZVCAEMlI4ABqy0t6Nj X95vfy1s4NOnz5w7d87n80nyCntjY0Oybs0NAIDTWLgOFWna19fX1XXYqhnmO3du 6vz58/bNH3ACAhiwkt/vHxwcyL/dqgbev3ffF/75n91ut8vlEvMUAaxccW8R15Vb JAoZAICi9K8f1fW4upJV56CsbRW333bb9My09Qu6JRYbSaVS9s0fcAICGLBMKBTs 6+sr9FlLGvi+j9x389vfvutkYvWsxLBSyOIWt4YSycqURDIAwIGUlfIemXqjsirU Bq1K3C4uxafEalSdQKlf7d2Pf+c7H//Exy3c8yvf2NhYIsHJkADzCGDAMvlvAM5R 4hpxcWHxqaef9ng8pcxEXRKGkQEA9aH48GyRoBWrPOWK9nZzlLXk6urqsWPHmpub Sno+RXE2YKBEBDBgmUL7P2uV0sD9ff2f+exnTd/dqCLDyC6Z+otzIhkAYBVtzUrb 15vqoGuR4VlJE7SF1kqWr63UGa6trf3u7/zO6TOnrZ2/VjQaS6fT9s0fqHsEMGCZ cDjc29uz62TmGjgWGzn+ne8MDA6auK99tMPISg+rhax+ikgGAMfadWy2eM0qq4zS h2e17Ktf4fyFC6Ojo++789eHh4etfRTV2Nh4IpGwaeaAExDAgGWuuupKnVOaaOD4 UvwHzzxj9F7VQDuSnB/J2t2tJToZAKqYoT2N1ddzQ2OzdrO1fiV5BHhufv5XfvmX m5oarX0g7SOeOPGSTTMHnIAABqwRDAb7+wseASuf0QY+1Hnof//93xtcqJqhVrEk bx4pnawOI+cMJkt0MgCUplDKSvKLsKTjQFDaaWrlpdju+lVvvPeee86cPWPtY2nx NmCgFAQwYI1dj4CVz1AD//7v/f47f+mXDC5UvVHee2yikyVSGUCd0rmPcU7QKnvl 5KesVbsZV6Gy1a+4/H/f+Mb/+puHrH04rZGR0ZWVFfvmD9Q3Ahiwhs/nGxoy/AZd nQ187tzUCy+8YMnxn51APca1tNXJynaha0uRXa8lUhlA2RU57NOl7XJSVn2LrJKy StbW1qhseZSzfsVlIpF485t//uDBg9Y+qOrVV6OZTMammQN1jwAGrGF0F2itXTM4 4A/8+9e+Zm7mKEIdQBbX19fXlTyWtg7upaay9szJErUMII/2ZTx/p2Jp+37F2j2H 88djtU1Lx1rCjq9h/jzVW5R/63ffcUcyZdcg7ejIaJIRYMAsAhiwxpVXXiGVcJaj 4nf8+f/083/+F39hbs6wijqALMm1rFaxK8+eLcodCWagyuW8AucXrDoAK21PU+2h ntQr2p2KidiKK0/9qjeqr/Yfu//+p7//tOUPrT4Wx8ECTCOAAQsEg4G+vs3hXzsa +NMPfvqyyy83N1tUyq7BrO6VvUdDvXvOthQb0EC+XcNV2t6uOVGqrVP1Q0kuWDEf 7TgtP4A1qpz1m/N9EotGP/yHHza9SbCr0dHRZJJBYMAMAhiwQCAQ0O7/bG0DT0/P PPfcc7wB2AnU3a3V9wGq5Sy2q3SWs0I77KzeUr5nAuwkv1fzb5S2WkLKe/urNlyV 60qmqt/tDQ0NkqZy838K4Chlq98dz0qQTCaP3XDD/gP7LV8GBQEMmEYAAxbw+XyD gwPaW8w18I738vv8X/v6100uGZxBzWDtcbDX1takrTEx5ZacafITulBLS5qx6PxP oaYVerEqVKcKbaNqL9US2JE6rKpML3o1P3RJVliiPPWb84OQ447bbktl0pYvhiIa jabTHAcLMIMABiwQCoV6e3tybrSqgd/21rf98Uc/amaxAOPyW1rpFiWntROon8pP 6HzqfaUCmV2cduPSwkAyt4ls4T6N2oOrmZhtzi6XOS2aP44qbU9N5UPlcXNul7bq VB1izVHKswbsVrb6lfJ+DLU++cADj333McuXRDE2Np5IJGyaOVDfCGDAAsoRsPJZ 0sC8ARj1Su3hXS+V7Ut1ZFvNNu1lzmx3fKwcO262FhoD1z+Bng+Vp6Dusittf6bq XXKaNn8CADnKUL/qh8V/HzcSi/3Bh//Awl+Z5SwDx8ECzCGAgVKJddsVVxQM1BIb eHz8ZDQa5Q3AAADsyvL6LTTwK+nYGyWZTF577bWmT5G4KxHA/C4MMIEABkqVcwSs fKZ/+yvumFhOPP3975u7OwAAzlHO+tX5XoAbb7wxHA5Zu1Sq0dEx0dg2zRyoYwQw UCq/3z8w0F98GtMNvH/f/i/80z+Zuy8AAE5Q5jf96n/Eu++6a2Z2xvJlU8RiI6lU yqaZA3WMAAZK1dHetm+/rvMcmMjg97//A+9573sb3G7jywUAQP2r2voV/v3f/u3h v3vY2mVTvXb2tQsXL9o0c6COEcBAqXbdBVrLaAM/8MlPdXZ2trW2Gl8uAADqXDXX r5hydmbmrrvvsuk4WKMjo8kVTgUMGEYAAyURa7XL5UM061y7GVoLnjw58dTTT3d0 dDACDABAjmquX2XiRCJx3XXXcRwsoKoQwEBJAoFAX192xaY/bPU38Nrq2ncff9zU cgEAUM+qv36VK7fecovHa9epHDgOFmACAQyURA7gXuVHyfIGvvEtN/7Jn/6p6WUD AKAulfNkv6XUr/CJj3/8e098z4oF3MHo6GgyyV7QgDEEMFASn8+3dQjozZ8mC/eF vv9/3H/d9debXjYAAOqPTTv9amdrVf0KLzz//J/9+Z9ZsYA7iEZj6XTappkD9YoA BkoSiUS6ug5vfWRlA4+Pj8diIx6PXftNAQBQc2qrfoVEInHNNdcMDQ2WvIw7mJiY XFpasmPOQB0jgIGSaEaAFcYaWCqcwVPnzv305VdKWTYAAOqJ3fWbn8El1q9CBHBn 58ESFrCgaDSaTmfsmDNQxwhgwLxgMNDb25t3szUNnE6ln3jySdPLBgBAPbG1fnd8 A7Al9Su8/eab/QG/2QXcBW8DBowigAHzto6Alc+CBj52ww3//c/+3PSyAQBQN8pW v4Wu7zqTIj7+V3/1xFN2/UabA0EDRhHAgHl+v7/wyf1KbeD7PnLfW2+6iTMAAwAc zr5jPhc68rP+B9Uz2Q++//37P3a/wQXUKxYbSaVSNs0cqEsEMGCez+cdGBgo/Hnz DSxWqJ/81IOdnZ1tra2lLCEAALWrIgO/+h9X52SzMzN33X2XzjMgGvXqq9FMhrcB AwYQwIB5hXeBVpls4MnJU088+WRHRwcjwAAAZ6pU/ep8aP2Lt7y8fPTo0d7eHp3T GzI2OpZgF2jACAIYMC/vENA7MtPAcxfnnnv+efNLBgBALbNvt2epvPWrTPlzR492 7O3QeRdDOBA0YBQBDJgXDoe7u7v0TZv9WdPfwA3uhm/+x3+YXCwAAGpWBQd+dT66 0foVfvVXfmV9Y13nvQwZHz+5vLxsx5yBekUAA+ZdfvllUuET+eYx0MAf+MBd73nv e9n/GQDgKPbVr553+dpUv8LXv/a1h//uYZ13NOrFF0/YNGegLhHAgHlKAEs2NPAn PvHAocOH29vaTC8bAAC1pV7rV5iemrrn3nt03tcoAhgwhAAGTAoEAr29PeqH1jbw Jz/5qYOdnQQwAMAh6ql+8yeenZm5+7futulA0JwKGDCEAAZMyglgyboGPndu6vhj j3EIaACAQ9R3/QqJROKGG244dKhT/0z0Gx0dTSZX7JgzUJcIYMAkv9+ffw4kSxp4 fW39u48/XsKiAQBQM6q/fvVPVmTKX7j1Vo/Xo3MmhsRiI6lUyo45A3WJAAZM8vm8 /f07nAPJUANLO2Vwc1PzI48+WsqyAQBQE2yq342NDT2PVbb6Fd53551L8SWd8zHk 1VejmQxnQgL0IoABk/J3gVaV2MCDA4P/86GH2P8ZAFDfyjb2u+NjlbN+xafu+8hH YiMxnbMyZGRkdGWFXaABvQhgwCT1ENA7KqWBP/mpBw8ePMgRsAAAdcyO+tWZvjof 3ZL0VT87OzPzwXs+qHOGRnEgaEA/AhgwqXgASyU0MAEMAKhv5anfQo9S/vqVCGCg ahDAgBlF9n/WMtHAp06dfvKpp9rb29kFGgBQf2xK35w5F98bWc/cDD20ns8mEomj R4/mHz7TEpwJCdCPAAbMCAT8vb261mFGG3hxcfHZZ581u1wAAFQvy+s3P32LP4qF 9WtiVm9+85vb2lp1zt+QkZGRlRUOBA3oQgADZux4DqRCjDXwpUvHH3vM5GIBAFCV Kj7wq2cCW+tX+KV3vtPldul8CEM4ExKgHwEMmOHz+UQA6y7bLH0T72lrafnyI4+Y XjAAAKqNTQO/Uk3V78bGxgfe/58XFhd1Pooh0WgsnU7bMWeg/hDAgBlNTU0HDx6Q DIzuSjonHhoc4hxIAIC6YW397pi+eh6l4vUrbv/j++4bGRvV+UCGnDp1emFhwY45 A/WHAAbMuOyyI+p1axv4Uw9+urOzs63VlvcIAQBQNuUZ+NXzQNVQv+LK+dnZe3/7 Xp2PZYiY/4kTL9kxZ6D+EMCAGdoAlixtYAIYAFAHqF+FWr+SnQEscSYkQDcCGDAs EAj09HTn364/gwtNOT5+8pkf/pBzIAEAappNuz3nz7ls9Wt6VtoATiaT119//dDQ oP4H1Y8zIQE6EcCAYYUCWCq5gc/Pnj/xErswAQBqGPWr0tav4ueOHj0gH0PEcgQw oBMBDBjm9/t7e3sKfbaUBk6n0k89/bTJxQIAoNKoX1V+/Qq3vOMdoXBI/0Prx6mA AZ0IYMAwv9/X21vsJMCmGzgYCHz9G//X/JIBAFA55alfPY9Snvot8qkd63d1dfV9 v/7rq+tr+h9dP04FDOhEAAOG+Xzevr6+4tOYOyzW4UOH/+Ef/9H8kgEAUDkWBnD1 12+Rzxaq37W1tf/64Q9PzUzrXwD9otFoOp2xY85AnSGAAcMikXBn56FdC9dEA//s tdfe/7G/dHMELABArbGqfvPnU+j4zyYWo7L1K25/4BOfeOEnL+hfBv1OnpyIx+N2 zBmoMwQwYNiRI8PKz47lDfzgg58+yDmQAAA1pUrSt/hkZUhfabf6FdcX5uc/9Hsf 0r8k+nEqYEAnAhgwTA5gyY4GVgK4va3N9LIBAFA21ZO+xaeskvoV16dnZj76x3+k f2EM4VTAgB4EMGBMIBDo7u7a+sjKBj59+sy3vv3tcCTS1tLCXtAAgGpmX/pKlatf 00eWFumb/1mRu+KW9fV19fb48vJSPH77r/7qwEC/zkUyhDMhAXoQwIAx2wNYsrCB z52b+vKXvyym7Ni7d/++fertYt25uLTU1NhIFQMAqoEl9WtV+haZ2MKB3yIT7Drw q8hkMgsLC+l0+s477+zqOqx/wfQbGRldWVmxY85APSGAAWP8fn9PT/f22yzeF/r0 6TORSKS5qam5uXnfvn0HDhy4/Y472js6tFW8Jqp4cVFcaWpqaiCMAQBlUW0Dv0Um rmD9JhKJpcXFL37xi6+dPTt7/vz8wsLiwsJSPG7TwK+KUwEDehDAgDE+n6+3tyfv Zl0NLJVwiuCxsfFwKNQssripqbW1TfTwXXffLW7fu324WAljsSpuJowBAJayb+BX Mlu/haYvQ/2K9E0mk8vygZcfeuih6ampi3NzC6J1l5YSieXh4WH9C2AVTgUM6EEA A8Z4vd6+vt6dPmN7A+9ocvJUJBJpjEREGLe1tbW3t//m+98v7RTGYq0srjQ3NxPG AACjyrDbs4lHKU/9JoTlZXH9s5/9rAjdCxcvLsriy8t2D+oa8uqr0UyGUwEDuyCA AWNCodDhw4cKfHLzB8rC3aGNHER626NPTExGwllNTY0tLa2ije/+4AelvDCWaGMA wG5Kr9/yDPwanU/OxGroPvjgg+dnZ+fm58X6MR6PLycSVRW6hYyNjYtnUOmlAKod AQwYMzw8vFuT2nKKYJ0Tbk1fcIrR0THR8JFIWPxpamxslQeNf+3OO8WnOjo6Duzf r52YNgYA2F2/JuZfSv2qlfvwww9PT03Nzc0tLi2J/5az4keOHDG6MNWDUwEDehDA gDHKu3qqv4H1LEDO/LNvMxZEHofDEdHGWS13vu83xGc79u7NaWOJPAYAByixfnc9 O5Hp+l1dXV2SO7YxHPZ4PDmzen2n5c985vz583Pz80uLi0vyWK4wODhg/KnUBk4F DOyKAAaMGR4e0te3lXlLsPbRdS6AnvmPjIwG/P5IJBIMhbLH4soeiKu1pbX19ne9 S5J3qy6Ux2JzRMyWQgaAWlTB+s1kMqJvlZWISFyv15szz5nZ2ZmZGXHl37/61YX5 +bm5uYXFRRG38eVs5CaTiZoeyzWNAAZ2RQADBgQC/q4u5STAlWlgIxNb3MBFjI6O +f3+kBAMhsPhSCTc1NTc2NT0G7/5m8q2C4UMADWnlPotfl/x2bW1tfnFxfy+VU3P ZCkT/MsXv7i8tCT6Nh6PZ0d2Rd+K/1ZW5F9JYxtOBQzsigAGDBCZ193dtfWR3gbW MVkVNbDRhdFz35MnJwKBgPjqBYNBEcmikBsbxQZP5P133VWkkCVNJCtzppMBoAxK SV9RtnOa1+2WpqaGhob8mU9NT6t9+4XPf14E7ZL8Llx5D+WESLiVVKq/v6/EJ+JA nAoY2BUBDBjg8/l6ero1N1R/AxtYANMLU/p9Y7ERn9cr8lhEciCY/RMOhyKRxlAo dNdv/Za6IVWokyV5k0sZTJAKbHIBAPTYsX5zsra1ubnQa+y5qSmlbJUpP/8P/5CQ 4zYhj9kmk8ls3CaTmdVMRc6UW/ei0Vg6na70UgBVjQAGDPB6vb29Pdtv07mfcwUP iyWVv4FLv/uOxsfGxT+BXxlNlseTg/JO101NTcFQ6N3vfvfrqbxvX6FUlpRa1g5Q FN6SA4B6lW3a+fnXm7alRbwSFhr7fW1qalaTtV955BGRskvyiXCTspVUKrWykhLt lUoN1O8hpqofpwIGdkUAAwaEgsFDO5wEmAa25e6mZys20SYnJ70er09Usk/w+uVo DgSC4VAoHImIbL7tjju0tXywcC1L24NZopkBVB9tzUqaoC1yl5ym/eqjj66srChv sk0mE5sxm05n0mkRt6Kpenq6bXpVh4U4FTCwK17IAAN2GgFW0MC23L08cx6TB5Z9 4j/RyuI/+XpAln3TcigkOvo9v/Zr2i3LvXv3HjxwYNc5U84ADDHRsQptzSp3/NK/ /qto1+Xl5RV5eFbErQha0bHi/5QctEJ/fx9NW2ei0aj4d670UgBVjVc9wICiB5yk gW2cQzlnq8fo6FiD2+3z+z2eBq9H/PEq2ZzdQ1sm4lmUs8jpd7/nPSbKWZWT0BIV DVSrnHaVjOSrKr9j/8+Xv7yayYiOTcn7GCuDsSJixY2Z1VX1qnj0Oj63LQzhTEhA cQQwYMDQ0GDh6NLZlpU9N5JEA1dWLBZzu8X2cINIZU+D2+PxNniyvKKkGxp8MrWi g8GgSOvbb799Y/sm9b59+wxVtCK/pdU5FjmeDVCv8ntVYaJaFTntKm3tV7y6uppM JlOy9Bbx6OJ2UbDZv5T/Rciura2vr3FoKJRCfAeeOPFSpZcCqGo1tu0IVNbQ0JBF fWv9OLDB6fV2eCnLY+3dKzLnKiSebDQaVSpayHaziGf542xJK3/Jl15lp275MhAI uFwu7Y7c2hmaK+oc2oPE5j8EjQ1DCtWpVEKg5sjvVXX+X/qXf9nY2Hh9n2H5Ui5W zYVI1bXNDxW0K6oEI8BAcQ7aagRKFAj4Dx/OngS4nA0sMRRcBXOuQtY+WVHULpfb vVXVbpcreyl/uHmj/Je48Lwe2ZsD1x45sAWxTLfdfnuhYrGksfMVqe78ZSDCdSoS nzmsatF8hepU2hpWFZ9ShlKVPYEVa1vDqevrcp5uXmguNza2YlVcXadXUZdGRkZX VlYqvRRA9XLQ9iJQIr/f39V1WF+4GtgdWsdk1dXARpfH8rtXZM5Vq1aesmhssbDZ yJbr2uXKFnc2teUL9cPsRXYSl3Ip17ZbuVHN7uxwt9zebrm73qV5l3URyuG+O22I 8PpTJD5zZN+h+qUviSsiLpW9eUVZbrVoNjKV6hQfbojczDbnxuaN2fyUP8z+//qH a5tX1yXpEnUKmEMAA8XVxpYTUA22AlihN4NrZXdoPctQwkNYf/eKzLlqOfApGyVy TmwU7pFtJrdsjxLbeySR4uKLqP3Mnj3ZT2XvIH+0eZOs9OXR/pO5LPrnyxakTDxZ 9S9xIXpSvuHShjqBJInsFH9lP7XxunV5eqHo8Q5sp6e9ARQSi42kUqlKLwVQvdhm AvTyer09Pd2aG8rdwBJDwVUw52rmzGeNekL6AqWLRmPpdLrSSwFUL7aWAL2ampr2 7du7/bZqb2CD05PB9cCZzxp1gPoFLHHq1OmFhYVKLwVQvdhOAvQaHBzcqSwsbmB9 UzIUXPk5VznHPnHUItIXsIryLoaXXvpppRcEqF5sIQF6FQhgyeoxXofuDm3JHMo/ 52rmzGeNmkP9AhZSfqA4FTBQBJtHgC5+v//w4ewRsJzRwAaWoYSHsGUOlZp51XLm s0ZNIH0BC2l/oEZHxzgQNFAIG0aALnIAHyqahTXQwAanZyi4TjjzWaNq0b2A5XJ+ rAhgoAi2igC9RAMrKxhxKYqiu7srbxIa2MRD2DWHSs28ajnzWaOqkL6AHZTTvG1s bCgnaROv9tQvUATbQ4B5Ionlv7MbdZFIJB6Pd3dvnieJQ0PTwFXImc8a1YD0BawS i42Ew+Hl5bj8kp59VSd3AUPYGAIstlXF2Q0+pYq3nz1YRQOXbyZlnnOVc+wTR0WQ voBpauvKr9y0LmANNoOAcggE/MpGoHJ+Arfb3dV12AkNbPBR7JpD+edc5Rz7xFE2 dC9gyMjI6Pr6usvlkl+eaV3ARmwDAZWkhLFSxR6PRz7O1o709mcZGljPYpTwKHbN ofxzrn5Ofu6wD+kLFDc2Nr62trpnz2brErpAmbH1A1SdQCCgbEOK/4OBwN59e7dC xdFDwbwl2CZOfu6wFukLaImfiDOnzyRXVvZsSSaTlV4oAAQwUCPkKla2Ly9tbFzy +30HD3YWKRc7G1jiyFj1x8nPHaUjfeFk4vt/cnIync4olSvJr6i0LlC12OIBapsm jMXlhtfrPXTo9f2o2SO62mZe5Zz83GEa9QvnOHlyIpNJK3svi0txC6EL1By2dYD6 pISxuiu1+HBlZaW/v2/XO9bKULBVM6nIzKuck587DCF9UZei0WgwGBJlqwzoErpA nWErB3Ac9T3GkvyX3+/v7DyYM42JDK7IAaKtmklFZl79HP70URz1i5omvoFPnTqd Sq0ofetyUbmAU7BxA+B1W+PGmwemDgaDOseN63gouAzzr3IOf/rYEfWLmhCLjYgV WSKREK9jLtceZVVF5QIOx2YNAF20baxciq2K1MpK3+t5XMlzBVs1k4rMvCbwFYCC 9EVVGRkZFasnJXHVY1BJVC6AwtigAWABNY+lrUNViwuv19vVdVhnOFV/A5dh/tWP r4CTkb4oP/FdNzExmU6n5SHczRPnKp8icQGYw6YMgHIIBoPaNx4rFwG/P53JaHex rv4MpgAlvgjOQ/rCJiMjo36/f2sX5ey7cBnCBWA3NmIAVItgMCBelNRNbeVKJBJJ p1Jd3V2GoouhYLvxFXACuhemyYeYOuX1eJficeXNtwzeAqgSbMEAqDHawWRp+3uS V1dXe3t7lNtp4DLgi1CX6F4UIr43Tp6c8Hq9icSyeAHIGbOVKFsAtYBtFwB1S05l QSlk+dpWLYfD4XQ6LYJ5eHiolIegAPkK1BPS14Gi0ajH4/V5vcuJ5T17XOpPNFkL oF6x4QIAm7aCWaHG8uZlIBBYE8W8tpbfzEQgX4GaRvfWjVgs1uBu8GZrNqEdns35 CSVoATgZmywAUJKdslnSlnM4HM5kMuvra4ODg5VYwDKhgWsR6VudxsbGXXv2eOQ9 jffs2babMSkLACViewUAKmZ7PEvbe2QzocX/kXAks7q6vra2vrExNFTVFU0G1wS6 1z4jI6Nul8vd0ODxeJaX48qGlnr8J+2BoFRELACUE1sqAFDz8kJasS1ztj7I/h0K hdZFT2eD2q6ipoSrE+mbQ/Sqy+VqaHC73Q3Ly8vK8Yql7d/AO1arRLgCQG1iAwUA sIMCUZ2VH1GaW9TAzhKBLT4u8UhjsErN1a+oU+X0sG6ZfLZYSd10yf8lS5FfuxCr AAAFAQwAqKQipS3T7hSee3v+EHdjJLImwlv8d+mSkt/C0NCgw0ekTaSvuMvo6Nge mUhQl7h0uxvc7qV4XNphgFTSblFs/2IX+8rTpQCAMnP0BgEAADl2C/LaRnACAByO AAYAAAAAOAIBDAAAAABwBAIYAAAAAOAIBDAAAAAAwBEIYAAAAACAIxDAAAAAAABH IIABAAAAAI5AAAMAAAAAHIEABgAAAAA4AgEMAAAAAHAEAhgAAAAA4AgEMAAAAADA EQhgAAAAAIAjEMAAAAAAAEcggAEAAAAAjkAAAwAAAAAcgQAGAAAAADgCAQwAAAAA cAQCGAAAAADgCAQwAAAAAMARCGAAAAAAgCMQwAAAAAAARyCAAQAAAACOQAADAAAA AByBAAYAAAAAOAIBDAAAAABwBAIYAAAAAOAIBDAAAAAAwBEIYAAAAACAIxDAAAAA AABHIIABAAAAAI5AAAMAAAAAHIEABgAAAAA4AgEMAAAAAHAEAhgAAAAA4AgEMAAA AADAEQhgAAAAAIAjEMAAAAAAAEcggAEAAAAAjkAAAwAAAAAcgQAGAAAAADgCAQwA AAAAcAQCGAAAAADgCAQwAAAAAMARCGAAAAAAgCMQwAAAAAAARyCAAQAAAACOQAAD AAAAAByBAAYAAAAAOAIBDAAAAABwBAIYAAAAAOAIBDAAAAAAwBEIYAAAAACAIxDA AAAAAABHIIABAAAAAI5AAAMAAAAAHIEABgAAAAA4AgEMAAAAAHAEAhgAAAAA4AgE MAAAAADAEQhgAAAAAIAjEMAAAAAAAEcggAEAAAAAjkAAAwAAAAAcgQAGAAAAADgC AQwAAAAAcAQCGAAAAADgCAQwAAAAAMARCGAAAAAAgCMQwAAAAAAARyCAAQAAAACO QAADAAAAAByBAAYAAAAAOAIBDAAAAABwBAIYAAAAAOAIBDAAAAAAwBEIYAAAAACA IxDAAAAAAABHIIABAAAAAI5AAAMAAAAAHIEABgAAAAA4AgEMAAAAAHAEAhgAAAAA 4AgEMAAAAADAEQhgAAAAAIAjEMAAAAAAAEcggAEAAAAAjkAAAwAAAAAcgQAGAAAA ADgCAQwAAAAAcAQCGAAAAADgCAQwAAAAAMARCGAAAAAAgCMQwAAAAAAARyCAAQAA AACOQAADAAAAAByBAAYAAAAAOAIBDAAAAABwBAIYAAAAAOAIBDAAAAAAwBEIYAAA AACAIxDAAAAAAABHIIABAAAAAI5AAAMAAAAAHIEABgAAAAA4AgEMAAAAAHAEAhgA AAAA4AgEMAAAAADAEQhgAAAAAIAjEMAAAAAAAEcggAEAAAAAjkAAAwAAAAAcgQAG AAAAADgCAQwAAAAAcAQCGAAAAADgCAQwAAAAAMARCGAAAAAAgCMQwAAAAAAARyCA AQAAAACOQAADAAAAAByBAAYAAAAAOAIBDAAAAABwBAIYAAAAAOAIBDAAAAAAwBEI YAAAAACAIxDAAAAAAABHIIABAAAAAI7w/wGYryYX1pCKDwAAAABJRU5ErkJggg=="/></symbol><use xlink:href="#c" width="1280" height="1280"/></g></g></svg>')} -.is2d .rook.white {background-image:url('data:image/svg+xml;base64,<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="614.635" height="614.635" viewBox="0 0 460.977 460.977"><mask id="b"><use xlink:href="#a" width="1280" height="1280" transform="rotate(.193) scale(.36014)"/></mask><symbol id="a" viewBox="0 0 1280 1280"><image width="1280" height="1280" xlink:href="data:image/png;base64, iVBORw0KGgoAAAANSUhEUgAABQAAAAUACAAAAAA9j6ArAAAACXBIWXMAAA7EAAAO xAGVKw4bAABHbUlEQVR4nO3dBbxVZaKG8SMWQ4h0SSmSooKOChhYKHYnKBhjII5g jl5zxlZ0xBwDFOxOFAxUwiIU6S7pkDgiitwDBnX2/tY+Z631fvH8fzP3ej3r6juj PJ6z99rf2iIPAAK1hXoAAKgQQADBIoAAgkUAAQSLAAIIFgEEECwCCCBYBBBAsAgg gGARQADBIoAAgkUAAQSLAAIIFgEEECwCCCBYBBBAsAgggGARQADBIoAAgkUAAQSL AAIIFgEEECwCCCBYBBBAsAgggGARQADBIoAAgkUAAQSLAAIIFgEEECwCCCBYBBBA sAgggGARQADBIoAAgkUAAQSLAAIIFgEEECwCCCBYBBBAsAgggGARQADBIoAAgkUA AQSLAAIIFgEEECwCCCBYBBBAsAgggGARQADBIoAAgkUAAQSLAAIIFgEEECwCCCBY BBBAsAgggGARQADBIoAAgkUAAQSLAAIIFgEEECwCCCBYBBBAsAgggGARQADBIoAA gkUAAQSLAAIIFgEEECwCCCBYBBBAsAgggGARQADBIoAAgkUAAQSLAAIIFgEEECwC CCBYBBBAsAgggGARQADBIoAAgkUAAQSLAAIIFgEEECwCCCBYBBBAsAgggGARQADB IoAAgkUAAQSLAAIIFgEEECwCCCBYBBBAsAgggGARQADBIoAAgkUAAQSLAAIIFgEE ECwCCCBYBBBAsAgggGARQADBIoAAgkUAAQSLAAIIFgEEECwCCCBYBBBAsAgggGAR QADBIoAAgkUAAQSLAAIIFgEEECwCCCBYBBBAsAgggGARQADBIoAAgkUAAQSLAAII FgEEECwCCCBYBBBAsAgggGARQADBIoAAgkUAAQSLAAIIFgEEECwCCCBYBBBAsAgg gGARQADBIoAAgkUAAQSLAAIIFgEEECwCCCBYBBBAsAgggGARQADBIoAAgkUAAQSL AAIIFgEEECwCCCBYBBBAsAgggGARQADBIoAAgkUAAQSLAAIIFgEEECwCCCBYBBBA sAgggGARQADBIoAAgkUAAQSLAAIIFgEEECwCCCBYBBBAsAgggGARQADBIoAAgkUA AQSLAAIIFgFEWrYsVXKrMluVzPDVlb8u/3Vl/upUFyF4BBCJqFSzWtVKFcuXLVOq QMm6Of3/Tl2ZX2D5ssULF8ydM2tBMgOBPAKIGFXasU7NalXKb1+u3I6x/nEn//jj ksXz5syaNpkYIl4EEMVTYocGdWtVr1KpYqNU/nRjFy6YN3vG1PEzf0vlTwfPEUAU SamGDevVrFqlYlPZglEL582dNWXcuHzZAriPACIXpZs2qLdD9cqV6quHbGDigvmz Z04ZP2qFegjcQwARQamGjXbcoXqVyjZ1b3MT58+bPXPyWL4nRGQEEEYnPLm9ekJO lpz7mnoCHEEAYXTGs+oFOTrzOfUCOIIAwmiPb9QLcrTnUPUCOIIAwqiUa28vlOZV QERDAGG2Rj0gR/xdjYj4WwVmjgVwTQn1AriCAMLMsQAuLadeAFcQQJg5FsAFldUL 4AoCCDPHAji7hnoBXEEAYTattnpBTqbXUS+AKwggzCbY/RG4TU3cWb0AriCAMBuT zlFXcRnbWL0AriCAMPuumXpBTkbuql4AVxBAmI3YTb0gJ9/url4AVxBAmH2zh3pB TobuqV4AVxBAmBFAeIoAwowAwlMEEGYEEJ4igDAjgPAUAYQZAYSnCCDMCCA8RQBh RgDhKQIIMwIITxFAnXLlym23fdkyZf+27bbbrLX1lnlblcjL23LLvLzVq/PyVuXl /fLrqlU/ryr490/Lli/58cdFS37WLCWAkWy7fYVy5bZf+xe04K9mwb+32jovb5v1 f0F/+zVv9S+r1vp57V/QZUuW/vjjj5ql+BMBTM/2tWpUrVKpfNkyZUqXLl23qH+U yfn5K/JXLFu8aP78WbPm/hbjvswIYGFKVK1Zs3LlCuXLli5VulSpHYv6h5m6YsWK 5cuXLV4wb+4PM5bEORBmBDBRJarXqV29apXyFbbfrm5Cf4oxS35cvHDB3NnTpy1K 6M+Ql/e1Wz9TfvP3xP7QFdb+9axUsXy57ZM6cWbq0iWLFs9b+9dzdjr/dAsbAUxA yfo71dqhauUKFRuk/Cces3jxgvmzZ0wevyzeP+7glvH+8RI2pFW8f7yyDXasVb1y pfLl0z5ma/zCRfPnzpwxaeLKlP/E4SCA8anWeMfaNatUrmTD6aHTFhV8V/jDlPHj YvmlE2QASzZsUK9GwXd7FWw4X3rigvnzZk2fPGaOeohvCGCxVWpav+4O1apUrake UrgJCwq+iZg+fmxxfkAOKYAVGjWoXfDteyVLT5WeNXfenJlTJ45aoB7iCQJYVNs2 aLJT7RpVK9dTD4lq2sJ5Bd9ETBw1O/f/1wACWL1p/YJv36tUtOHbvUimzJ/7w/RJ o8eLbgzwBQHM1fbNGu1Uq1rVpuodRVfwTcTsWVPHj4r+PaG/AazQtEHdmtWt/fY9 ilFz58yYNHYk7x8XCQGMqmazhvVqVqtq6U9GRTJ13vwfZk7uP9d4oX8BrHrojjvU qFylbvJjUjNh7pxZU8aNnKXe4RYCaFbx3zWrVa+lXpGYG/5tvMS/AF5/Swo7NGbM njPr+oXqFa4ggGbNh6kXJKpDH+Ml/gWwfe8Udui0GK5e4AoCaLbfZ+oFiTruTeMl /gXw2DdS2KGz/+fqBa4ggGaeB/DQD42X+BfAQ/qnsEOHAEZFAM08D2CEXyz+BZC/ pliHAJrxi4UAOoYARkUAzfjFQgAdQwCjIoBm/GIhgI4hgFERQDN+sRBAxxDAqAig WdsP1AsSRQD9c1g/9QJXEECzw/uqFySKAPqn3fvqBa4ggGaeB7D1YOMl/gWw1aAU dugQwKgIoJnnAYzwsSn/Auj5xxsJYFQE0IwAEkDHEMCoCKAZASSAjiGAURFAMwJI AB1DAKMigGaeB7DJGOMl/gWw8egUdugQwKgIoJnnAWw43niJfwFsMC6FHToEMCoC aOZ5AOtNNV7yxd7Jz4jRl/sYL6k7JYUdOgQwKgJo5nkAa5gfE/fNHinsiM/QPY2X VP8hhR06BDAqAmjmeQCrmx+27V8AqxXh4aAOIYBREUAzzwO43TLjJf4FsOzSFHbo EMCoCKAZASSAjiGAURFAM88DuNVq4yX+BXDLX1PYoUMAoyKAZp4HMMLfAv4FMG9N 8jOECGBUBNCMABJAxxDAqAigGQEkgI4hgFERQDO/A5hf2nzNiN2S3xGjb3c3X0MA sRYBNPM7gD9ub77mu2bJ74jRyF3N1xBArEUAzfwO4KKK5msIoGMIYFQE0OyEV9UL kjS3mvkaAuiYE19TL3AFATQ78RX1giTN2sF8DQF0zEle/zM7TgTQzO8ATq1nvsbD AE6pm/gMIQIYFQE08zuAExqYrxnTKPkdMRrb2HzN+J2T36FDAKMigGZ+B3B0U/M1 HgZwVJPkd+gQwKgIoJnfARzR3HyNhwEcHuFeQXcRwKgIoNlJL6sXJOnrvczXeBjA r/6e/A6dk73+Z3acCKBZ+97qBUkatK/5mrENk98Ro3ERej2wdfI7dDr0US9wBQE0 8zuAnxxkvmbSjsnviNHknczXfHxg8jt0CGBUBNDM7wC+3858jYcB7Ht48jt0CGBU BNDM7wC+eZz5Gg8D+Maxye/QIYBREUAzvwP40qnma6bWSX5HjKbVNV/z4ilJr1Ai gFERQDO/A/h0R/M102slPiNOM2qbr+l1dvI7dAhgVATQzO8APnKx+RoPA/jwRcnv 0CGAURFAM78DeO8V5ms8DOA9lye/Q4cARkUAzfwO4C03mq9x7OiUOdXN19x8Q/I7 dAhgVATQzO8AXn2X+RrHAhjliMOr7kx+hw4BjIoAmvkdwM4Pm69xLIALKpuvufih 5HfoEMCoCKCZ3wE88znzNY4FcHEF8zVnPJv8Dh0CGBUBNPM7gEe/Y77GsQAuKW++ 5qi3k9+hQwCjIoBm5z2uXpCk1oPN1zgWwOVlzde0GpT8Dp3zn1AvcAUBNLvgUfWC JDUdbb7GsQBGedRxk1HJ79C58DH1AlcQQDO/A1htrvkaxwIY5e/qqnOSn6FDAKMi gGZ+B3Cr1eZrPAzglr8mP0OHAEZFAM28DuCaElEuSnxGvKL8Xe3af6acEMCoCKCZ 1wGM8o7ptiuT3xGrkj+bryGAyCOAUXh9z+wPNc3XbL84+R2xKr/EfI3XAYxydzvW IoBml92nXpCgiRGej1v9h+R3xKrGbPM1E+onv0Om6/3qBa4ggGZeB/DbCI+HbDAu +R2xajjefM2I3ZLfIUMAoyKAZl4HcEgr8zW7jUh+R6x2/9Z8zeCWye+QIYBREUAz rwP40SHma/YZkvyOWLX8wnzNhwcnv0OGAEZFAM28DuBbER4O1OaT5HfE6sAB5mve PCbxGToEMCoCaNa1u3pBgp4703zN4X2T3xGrdu+br3n2jOR3yHTz+Z/ZsSKAZv+6 Tb0gQVEeCXLiK8nviNVJr5qv8fqhINferl7gCgJo5nUA77zGfM1ZTye/I1ZnP2O+ 5o6rk98hQwCjIoBmXgcwyon4zt0JHuU+YK/PxCeAURFAM68DGOXkuCvuTn5HrK68 x3yN16c8EsCoCKCZ1w8QO/E18zU33Jz8jljdeIv5mhMivE7orCiP+sNaBNDM6wDu G+FkZOdeLovywmbrgcnvkCGAURFAM68DGOVTYw90SX5HrHpcar7Guc/35YIARkUA zbwO4HbLzNf87/zkd8Tq8X+Yrym7NPkdMgQwKgJodteV6gUJivI3QO/2ic+IV58O ES7y+Tysu69SL3AFATTzOYBRzkPNe/mkxHfE65WTI1xEAEEAo/A5gDNrRbio7+GJ 74jX++0iXEQAQQCjuPsK9YLkjGsU4aJP9098R7w+OyDCRWMbJr5D5h6P/5kdLwJo 9t8I7ym6atgeES76JspFNhm6Z5SLWiS+Q+aBf6oXuIIAmvkcwEjfK41unPiOeI1p EuEi576vzQEBjIoAmvkcwL5HRLhoap3Ed8RrWt0IF70X5YVCRxHAqAig2YOd1QuS 89KpES5y7u2C+VUiXPTiKYnvkHnoEvUCVxBAs8ci3Fbrqp7nRLjIuQDml45w0VOd Et8h878L1AtcQQDNfA5glG8Vtvw1+R0x22q1+Rqfv7EngFERQDPnPgmWgyjHBlSd k/yOmFWba77GuSMechDls4BYiwCa9TpbvSA51//HfE3zYcnviFmL4eZr/u/fye9Q ebqjeoErCKCZzwG8tIf5mqPeTn5HzI5+x3xNlweS36FCAKMigGbOnQWQg069zNdc 8GjiM+J24WPmazr2TH6HSqTTIJBHAKN4/jT1guSc8bz5Ggd/Vozyk/3pzyW/Q+WF 09ULXEEAzXwOYJQHSN7v3l21/73MfI1zD/vMAQGMigCavXa8ekFyojxC3MGXAKL8 COjc495z8PoJ6gWuIIBmPgfwwAHma945MvEZcXv3KPM1bT5JfocKAYyKAJo5GIDI Wn5hvubzfZPfEbOB+5mv2WdI8jtUovwDAGsRQDOfAxjlhrnvmiW/I2YjdzVf4+Dt jZERwKgIoFm/Q9ULkhMlgLNqJL8jZj/UNF/jcwD7t1UvcAUBNAs9gM6dhVAwuYT5 GgIIAhjFgCiHhjoqQgArz0thR9yqzDde4nMAP22jXuAKAmjm89HBEQK432cp7Ijb /p8bL/E5gJEO+kYeAYxicEv1guRECKCTHxmL8BE/nwM4pJV6gSsIoNmXe6kXJKeV +V6QG25OYUfcbrzFeEnLwSnsEPlqb/UCVxBAM+ceipaDw/oZL3HyPNgIJ4K2/SCF HSKRHouHPAIYhYP3wUUW4bPAbxybwo64vXmc8RKfPwsc5T5IrEUAzb5vql6QnAiv lQ1y8fWkwa2Nlzj52mZEo3ZRL3AFATQb21C9IDmdHzZe4txDMdeaVtd4ycUPJb5C Zlwj9QJXEECzSTuqFyTnynuMlzh4H3SkO6GvuDuFHSKTd1IvcAUBNHPyW6CI7r7K dMVOE9PYEbv6k0xX3HVlGjs0ptVVL3AFATRz8lugiJ48z3TFSS+nsSN2Jxvf4nji 3DR2aMzaQb3AFQTQzOcAmg+Ou958R52NbjCe4+/zMY9zq6kXuIIAmvkcwE8OMl3R s2MKM+LXq5Ppio8PTGOHxqKK6gWuIIBmPgdwmPEm7w8PTmNH7D46xHTF0BZp7NBY Xla9wBUE0MznAM6sZbpidOM0dsRuTBPTFTM8fp0synFgWIsAmvkcQPOvFEf/0y/b znSFo//BouHXdUT8F2Xm9a+UGrOzf73BuHR2xK7h+Oxfr/5DOjs0+HUdEf9FGW27 Ur0gSce8nf3r5z6Rzo7Ynfdk9q8f/VY6OzRK/qxe4AgCaFR2qXpBkv7v1uxf73FJ Ojti92CX7F+/7j/p7NDYbpl6gSMIoJHfPyuZHiHu7ANRTI/FcPBx7zkwvbKBPxBA o1rT1QuS9OU+2b8+pW4qM+I3tV72r3/h9ZmhtWeoFziCABo5+zZAJAsrZf3y1qtS 2hG/bX7J+mWv39oyvgWEPxBAo11GqhckKvupAa0GpbUjdq2zHnnv6BkPUTX7Xr3A EQTQyOeH5xTo8mC2rzp8ZlT2k74u6ZHWDokoz3tGHgGMwPMAPn9G1q+eltaO2L1w eravPpf1q84jgBERQCPPAzipfravjjJ+osxao7M+yWCi30eGEsCICKCR32+CZL9j Ystf09sRtzVbr878Rb/vbeJNkMgIoFHtaeoFybr6rsxfa/NJejtid+CAzF+76s7U ZkjU8frerRgRQCPfv1n4MMutzjffkN6O2N1yY+av9TeeluU2boSOiAAalVqhXpCs FRUzf270raNTHBK3t4/J+CW/P99doHS+eoEjCKCZ37fM5uVdkvn5kJMNH6ew2pTM T/PrnPXeHw/w6zoi/osy8z2AmT8N5/g5EJlPBPD7c3AF39WXUS9wBQE08z2AmT8M 0r53qjvi1qFPhi94/jGQvLw51dULXEEAzcY2VC9I2OP/yPCFp4xPFrJaz3MyfOF/ 56e6I33jGqkXuIIAmvn+81LekuoZ3hNw+DbotTLdCl3yp3R3pM90xg/+RADN3jlS vSBpt19b6O92/v3vDO+F3vavlHek7t2j1AtcQQDNHrpYvSBpC2sXWopTX0h7SMxO e7Gw3+t8180e7qxe4AoCaNa1u3pB4p4o9EUx518qK/zFzcfPS3tH6rrdp17gCgJo tt9n6gWJW9O4sA88f7tr6kPi9d1uhfzOhmNT35G6/T9XL3AFATQrkeVD9b74ouXm v8/99wrWlCrk3Z0h/r9BkF/2N/UEVxDACEYU9o2EZwo5EuG05wU74nX65q9i+n4M wlrf7q5e4AwCGMEzhien+WB5881uDn76LMWQWD1z9qa/p/4ExY6U9Xb/r1xaCGAE J7+kXpCCSbtu+k7whKxHpTph4s6b/I5S3/l9EOrvTnlZvcAZBDCCrbI/X8wTX7Te +IUjL44B2+RYqBKD/H8BsOC7+fIOn2ObMgIYxYcHqxekYZO7Z724+2eT+0H8v6d9 rY88P+wwTgQwCscPBYjqrWM3/L+8iMXGUX8z8wmBPsl4CAQ2QwCj2CKQuwo+OWyD H/a9OARnbrX1v731BwfqhqRoTg0v/tKlgwBG0uMS9YJ0fHvwwj9/c68vlUNis/dX f/5WxY8CuJtprQe7qBc4hABGUibj0Zqemdup7x+/df8/pUPi8t/L/viNdu9Jd6Rn Sa3l6gkOIYDRdO+qXpCW3uf8/hbiyF3EQ+LxfbN1/2urpwK4l/N393VTL3AJAYzG /Y+FRTa525sF/7PyPPWOmFSZX/A/ju2e+fkgnplb1/cHPsWKAEYUyBvB63xy6fd5 l9+jXhGTK+7N2+WBMN79WIe3gHNCAKP6oK16QYreufyxNuoNMRlwwb0hnQ7a7zD1 ArcQwKi2G1NDPQEw+KGx2w/ySx0BjKzJKPUCILvle49WT3AMAYyuY0/1AiCrTr3U C1xDAHNw043qBUAWN9+kXuAcApgLCgiL0b/cEcCcXHuregGQwXW3qRc4iADm5qi3 1QuAwiw6+x31BBcRwBzV7tdQPQHYzLi209UTnEQAc7VVz/bqCcAm+nTiEOgiIYC5 O/a/ddQTgA1M++eb6gmuIoBFsPWj56gnAH956sIgHlqTCAJYJE0eaqOeAKwzoDOf /ig6AlhEh9/WXD0ByBt+7fvqCU4jgEV2wo27qicgcN/d/Jp6guMIYDEcfn0r9QQE bPC/+e6vuAhgsTS/+lT1BIRp+bt3Dldv8AABLKYy/zotmNPWYY3JL9zOo4/iQACL 7/ALjzVfBMRl+UeP8rNvTAhgHEp2PqOFegMCMey5h3jsUWwIYExGBPLUbYh9u7t6 gVcIYEwGt1QvQBCGcOdBnAhgTAggUkEAY0UAY0IAkQoCGCsCGBMCiFQQwFgRwJgQ QKSCAMaKAMaEACIVBDBWBDAmBBCpIICxIoAxIYBIBQGMFQGMyef7qhcgCAP3Uy/w CgGMyYAD1AsQhE/bqBd4hQDG5MOD1QsQhI8OUS/wCgGMSb9D1QsQhP5t1Qu8QgBj 8u4R6gUIwntHqhd4hQDG5B3+vkQa3j1KvcArBDAmrx2vXoAgvH6CeoFXCGBMXuXv S6ThtRPVC7xCAGPy/GnqBQjCC6erF3iFAMbk2TPUCxCE585UL/AKAYxJr7PVCxCE pzuqF3iFAMbkiXPVCxCEJ89TL/AKAYzJg53VCxCEhy5RL/AKAYzJXVeqFyAId1+l XuAVAhiTG29SL0AQbrpZvcArBDAmV9ytXoAgXHmPeoFXCGBMLnpYvQBBuPgR9QKv EMCYtO+tXoAgdOijXuAVAhiTY99QL0AQjntTvcArBDAmB36sXoAgHPSJeoFXCGBM 9vhGvQBB2HOoeoFXCGBMdpqoXoAg1J+kXuAVAhiTSvPVCxCEygvUC7xCAGNSYrV6 AYKw5W/qBV4hgHFZox6AECwvq17gFwIYFwKIFMyprl7gFwIYl8n11AsQgCk7qhf4 hQDGZeQu6gUIwPfN1Av8QgDj8sXe6gUIwJf7qBf4hQDG5aOD1AsQgI8PVi/wCwGM y5vHqBcgAG8dq17gFwIYl97t1QsQgD4d1Av8QgDj8vBF6gUIwCMXqxf4hQDG5Y6r 1QsQgDuvUS/wCwGMS7d71QsQgMu7qxf4hQDGhSOhkQIOhI4XAYzLIf3VCxCAQz9U L/ALAYxL49HqBQhAkzHqBX4hgHEpvVy9AAEos0K9wC8EMDYcB4PErSmhXuAZAhgb AojELaisXuAZAhibiTupF8B7k+qrF3iGAMZmWHP1AnhveAv1As8QwNh8ur96Abz3 2QHqBZ4hgLHhOBgkjsNgYkYAY9Ozo3oBvNerk3qBZwhgbO65XL0A3rv3CvUCzxDA 2Fx9h3oBvHfNneoFniGAsenYU70A3uvUS73AMwQwNm0/UC+A9w7rp17gGQIYm4Zj 1QvgvUbj1As8QwBjU4qPqSNppfPVCzxDAOPDh4GRMM5CiBsBjM1+n6kXwHv7f65e 4BkCGBt+BEbi+BE4ZgQwPvwIjITNrqFe4BsCGJ/BLdUL4LkhrdQLfEMA4/P8aeoF 8NwLp6sX+IYAxufmG9QL4LlbblQv8A0BjM8Jr6oXwHMnvqZe4BsCGJ/K89QL4Lkq 89ULfEMAY8TbwEjU/CrqBd4hgDH6ci/1Anjtq73VC7xDAGP0wqnqBfDai9xnEDcC GKMbblYvgNduvEW9wDsEMEacCIhEcRpg7AhgjPg0MBLFJ4FjRwDjNLWOegE8Nq2u eoF/CGCc+h2qXgCP9W+rXuAfAhin/16qXgCPPfBP9QL/EMA4nfGsegE8duZz6gX+ IYBxqrBQvQAeq7hIvcA/BDBWU+qqF8BbU+upF3iIAMbqraPVC+Ctt49RL/AQAYwV nwVBYvgcSAIIYKxaDlYvgLdaDVEv8BABjNUWv6kXwFdLKnDcWvwIYLw+aaNeAE8N OFC9wEcEMF63XqteAE/ddp16gY8IYLz2+Ea9AJ7ac6h6gY8IYMx4nQaJ4Dj8RBDA mPU9XL0AXnq/nXqBlwhgzC6/R70AXrriXvUCLxHAmPFxYCSCDwInggDGbWgL9QJ4 aNge6gV+IoBxu+V69QJ46N83qBf4iQDGre4U9QJ4qN5U9QI/EcDYjWmkXgDvjG2s XuApAhi7O65WL4B37rxGvcBTBDB21WarF8A71eeoF3iKAMZvYGv1Anhm0L7qBb4i gPHr2FO9AJ7p1Eu9wFcEMH4lVqsXwC/zq3HOZEIIYAJ6na1eAK883VG9wFsEMAFN RqkXwCtNR6sXeIsAJmFQK/UCeGQw76olhgAm4dg31AvgkePeVC/wFwFMxKgm6gXw xuim6gUeI4CJOOtp9QJ44+xn1As8RgCTMa6BegE8Mb6heoHPCGAyuBkaMeEm6CQR wIR810y9AF4Yuat6gdcIYEKOelu9AF44+h31Aq8RwKR8tp96ATzw+f7qBX4jgElp ME69AO5b02i8eoLfCGBinjxHvQDOe+pc9QLPEcDEbD2hjnoCHDdt51/UEzxHAJNz JC9fo3iOele9wHcEMEFvHKteAKe9eZx6gfcIYIJKjuWHYBTdtEYr1RO8RwCT1OYT 9QI47MAB6gX+I4CJeqCLegGc1eNS9YIAEMBkfc7jvFA0A7mTPgUEMFllR9VST4CT ZjRdpp4QAgKYsKbfqxfARcv34cEyaSCASWvfW70ADurQR70gDAQwcXdcrV4A59x5 jXpBIAhg8nq3Vy+AY/p0UC8IBQFMAZ8IQU74BEhqCGAKtvjgUPUEOKT/YWvUE4JB ANNQom9b9QQ4o1+739QTwkEAU7HFO0eoJ8AR7x3F93/pIYApeeVE9QI44dWT1AuC QgDT0uMS9QI44EE+PZ4qApiaf92mXgDrXXu7ekFgCGB6jn5LvQB2W9SRh6mmjACm qObHDdQTYLHxB81STwgOAUzTtm9xOwwy6XfMz+oJ4SGA6ereVb0Alrqvm3pBiAhg uvb4Rr0AltpzqHpBiAhgunhKCDLgCSAKBDBdR/E2Hwp3NI+RFiCA6TrtefUCWOr0 F9QLQkQA03Xe4+oFsNT5T6gXhIgApuuCR9ULYKkLH1MvCBEBTBcBRAYEUIEAposA IgMCqEAA00UAkQEBVCCA6brsPvUCWKrr/eoFISKA6SKAyIAAKhDAdHV5QL0Alrq0 h3pBiAhgus7lZi8U7rwn1QtCRADTxSdBkAGfBFEggOnis8DIgM8CKxDAdHEaDDLg NBgFApguzgNEBpwHqEAA09VgnHoBLNVwvHpBiAhguirPUy+AparMVy8IEQFM2Rr1 AFiKX4oK/LeeMgKIQi0pr14QJAKYsmm11Qtgpel11AuCRABTNmI39QJY6dvd1QuC RABT9tFB6gWw0scHqxcEiQCm7IVT1QtgpRdPUy8IEgFMWfeu6gWw0n3d1AuCRABT dvFD6gWwUueH1QuCRABT1nqgegGstO8g9YIgEcCUlV6uXgArlVmhXhAkApg27oRG IeZVVS8IEwFM2+CW6gWw0JBW6gVhIoBp691evQAW6tNBvSBMBDBt/7pNvQAWuvZ2 9YIwEcC0tRysXgALtRqiXhAmApi2LX5TL4B9lm/Hm2MSBDB1Q1uoF8A6w/ZQLwgU AUxdz47qBbBOr07qBYEigKk7/Tn1AljnDJ4XrUEAU1fyJ/UC2GZNqZXqCYEigOnj TFRsgtNQVQhg+u7l4CNsrPvl6gWhIoDpaz5MvQCWaTFcvSBUBFBgKs+/wYam1VUv CBYBFOBGGGyEm2BkCKBAK86+xIZa8/FIFQKoMHEn9QJYZFJ99YJwEUCFe3jTD+vd e4V6QbgIoEKt6eoFsEjtGeoF4SKAEp+0US+ANQYcqF4QMAIo0e499QJY44i+6gUB I4Aa43dWL4AlJjRQLwgZAdTo/KB6ASxxyUPqBSEjgBpbTOHTIFhrWj3OghYigCLd 7lUvgBUu765eEDQCKFJiMt8CouAbwB15RowSAVTp2FO9ABbo1Eu9IGwEUIaHI4GH IakRQJkDBqgXQK7Np+oFgSOAOq+cqF4AsVdPUi8IHQHUKbVCvQBas+vnqyeEjgAK te+tXgCpDn3UC4JHAJXePUK9AELvHaleAAKoVHJcbfUEyExvyMOA5QigFO8EB4x3 gC1AALU4GzpYnANtAwIo1vdw9QJIvN9OvQB5BFBu6+FN1RMgMKr5L+oJyCOAepXn qRcgfXN2na+egLUIoNzO49ULkLbFe09QT8A6BFBvz6/VC5CuFW2+UU/A7wigBU5+ Sb0AqTrlZfUC/IEA2uDsXuoFSM+aTk+rJ+BPBNAKJ/EtQTDyz35FPQF/IYB22Pdz 9QKkY3m7geoJWI8AWqLp9+oFSMOcQ0apJ2ADBNAWVT9tqJ6AxI07YK56AjZEAK1R st9+6glI2OdtOQDGLgTQIg90US9Aonpcql6ATRBAmxz9lnoBkjP/3LfVE7ApAmiV Su/srZ6AhHx51AL1BGyGAFrmuv+oFyAJK26/VT0BhSCAtqnzdjP1BMRu5NHT1BNQ GAJonS2uv1k9AfFaeu+/16g3oFAE0EKVnjtUPQEx6n8Gr/7ZigBa6YQ7dlZPQEwm XPOaegIyIoB22qLbPeoJiMOce7rz06/FCKCttrmNB8Y5b8mT165Sb0A2BNBepW/9 p3oCimNR7+tWqDcgOwJos1I3XamegKJa0POmfPUGmBBAu23d9fz66g0ogomP38dz Lx1AAK133JWt1BOQo8F3v6GegEgIoAMadLtAPQHRzXmzO086dQUBdMIWZ17YWr0B kQx69Fnue3EHAXRF1YtO4EPCthv52iOc+OwUAuiQnS86ig+I2GvCO49MUG9Ajgig Wxqcc7V6Agqz6PGneOHPQQTQNcOaqxegEMNbqBegKAiga6bVVi9AIabXUS9AURBA 1/AWo5XyS6sXoCgIoGMqLFQvQKEqLlIvQBEQQMe0HKxegEK1GqJegCIggI5p31u9 AIXq0Ee9AEVAAB3DU+Ms9X889c1FBNAxD12sXoBCPdxZvQBFQAAd8+oJ6gUo1Gsn qhegCAigYz7dX70AhfrsAPUCFAEBdMyoJuoFKNTopuoFKAIC6Bjug7bU/CrqBSgC AuiWEqvVC5DBlr+pFyB3BNAtdaeoFyCDelPVC5A7AuiWth+oFyCDw/qpFyB3BNAt Fz+kXoAMOj+sXoDcEUC33MF5qLa68xr1AuSOALqld3v1AmTQp4N6AXJHAN3S71D1 AmTQv616AXJHAN3CgfjW4lB8FxFAt8yqoV6ADH6oqV6A3BFAt/BBEGutKaFegNwR QKfUnKlegIx2mKVegJwRQKcc9JF6ATI6+GP1AuSMADrlgkfVC5DRhY+pFyBnBNAp t16rXoCMbrtOvQA5I4BOefos9QJk9MzZ6gXIGQF0St/D1QuQ0fvt1AuQMwLolKHc bGuvYXuoFyBnBNApM7nZ1l6zdlAvQM4IoFO4D9pi3AntIALokqpz1AuQRbW56gXI FQF0SZtP1AuQxYED1AuQKwLoknOfUC9AFuc9qV6AXBFAl3AftNW4E9o9BNAl3Adt Ne6Edg8BdAnnQVuNM6HdQwBdMmI39QJk8e3u6gXIFQF0CbcBWm1uNfUC5IoAOmTL X9ULkNVWq9ULkCMC6JAG49QLkFXD8eoFyBEBdMhxr6sXIKvj31AvQI4IoEOuulO9 AFldfZd6AXJEAB3yYGf1AmT10CXqBcgRAXTI68epFyCrN45XL0COCKBDBrdUL0BW Q1qpFyBHBNAhE+qrFyCriTurFyBHBNAh3AdtuWXbqRcgRwTQHRUWqhfAoOIi9QLk hgC644AB6gUwaPOpegFyQwDdcf7/1Atg8I/H1QuQGwLojtv+pV4Ag9s5sdYxBNAd vdurF8CgTwf1AuSGALqj/yHqBTD4kBNrHUMA3fFdM/UCGIzcVb0AuSGA7uA2QOst rKRegNwQQGeU/Em9AEZ/W6legJwQQGfs9aV6AYz2/kq9ADkhgM44h8du2+/cp9QL kBMC6AxuA3QANwI6hgA649kz1Atg9NyZ6gXICQF0xidt1AtgNOBA9QLkhAA6Y0wj 9QIYjW2sXoCcEEBncBugA5aUVy9ATgigK7ZfrF6ACMovUS9ALgigKzgN0AmcCOgW AuiKix5WL0AEFz+iXoBcEEBX3HO5egEiuPcK9QLkggC64qWT1QsQwcunqBcgFwTQ FQNbqxcggkH7qhcgFwTQFTwU2Ak8GtgtBNAV3AbohOVl1QuQCwLoiGqz1QsQSfU5 6gXIAQF0xOF91QsQSbv31QuQAwLoiK7d1QsQSbf71AuQAwLoiIcvUi9AJI9crF6A HBBAR7xzpHoBInn3KPUC5IAAOmL47uoFiGREc/UC5IAAOoK7YBwxv4p6AXJAAN1Q aoV6ASIqna9egOgIoBtaD1QvQET7DlIvQHQE0A0chuUMDsRyCQF0w/3/VC9ARP+9 TL0A0RFAN7x+nHoBInrjePUCREcA3fDV39ULENHXe6kXIDoC6AbugnHG7BrqBYiO ADph61XqBYhsm1/UCxAZAXRC82HqBYisxXD1AkRGAJ3Qsad6ASLr1Eu9AJERQCfc cbV6ASK78xr1AkRGAJ3wIs8ac8dLp6oXIDIC6IRBrdQLENlgnt/nDgLohOm11AsQ 2Yza6gWIjAC6oMRq9QLkYMvf1AsQFQF0QePR6gXIQZMx6gWIigC6oH1v9QLkoEMf 9QJERQBdwF0wTuE+GHcQQBe8cqJ6AXLw6knqBYiKALrgSw4YcclXe6sXICoC6ALO gnHK3GrqBYiKADqAJyI5huciOYMAOuCAAeoFyEmbT9ULEBEBdMBl96kXICdd71cv QEQE0AGPXqBegJw8dqF6ASIigA54/zD1AuTkg8PVCxARAXTAqCbqBcjJ6KbqBYiI ADqAu2Acs7ScegEiIoD2qzVdvQA5qj1DvQDREED7nfiKegFydNKr6gWIhgDa76Yb 1QuQo5tvUi9ANATQfs+eoV6AHD13pnoBoiGA9hvIMyZcM2hf9QJEQwDtN2MH9QLk aCbPcHEEAbTe1qvUC5CzbX5RL0AkBNB6e32pXoCc7f2VegEiIYDWu6SHegFy1uVB 9QJEQgCtx1EIDuI4BEcQQOv1P0S9ADn78FD1AkRCAK03uZ56AXI2ZUf1AkRCAG1X YrV6AXK3Zqvf1BMQBQG0XfNh6gUoghbD1QsQBQG03UUPqxegCC5+RL0AURBA2z10 sXoBiuDhzuoFiIIA2u6DtuoFKIJ+PMbACQTQdhN3Ui9AEUyqr16AKAig5XgT2E28 DewGAmi5Zt+pF6BIdh2pXoAICKDlzv+fegGK5B+PqxcgAgJouQe6qBegSHpcql6A CAig5fryjG03vd9OvQAREEDLjW6sXoAiGcPT7F1AAC3HQ9EdlV9avQAREEC7NR6t XoAiajJGvQBmBNBu5zypXoAiOvcp9QKYEUC78Saws3gb2AUE0G58EthZfBrYBQTQ blPqqhegiKZykrcDCKDVeCaww3g2sAMIoNX2+0y9AEW2/+fqBTAigFa76k71AhTZ 1XepF8CIAFqtd3v1AhRZnw7qBTAigFYbso96AYrsi5bqBTAigFbjg3AOm19FvQBG BNBmVeeoF6AYqs1VL4AJAbTZqS+oF6AYTntRvQAmBNBmd12pXoBiuPsq9QKYEECb vXW0egGK4e1j1AtgQgBt9n1T9QIUw6hd1AtgQgAttgVPVnRafhnexbcdAbRY82Hq BSiWFsPVC2BAAC12SQ/1AhRLlwfVC2BAAC32xLnqBSiWJ89TL4ABAbTYp/urF6BY PjtAvQAGBNBis2qoF6BYfqipXgADAmivCgvVC1BMFRepFyA7Amivk19SL0AxnfKy egGyI4D2uudy9QIU071XqBcgOwJor/d5rJjrPjhcvQDZEUB7Ta2jXoBimlZXvQDZ EUBrlVqhXoBiK52vXoCsCKC12r2nXoBiO6KvegGyIoDWuvVa9QIU223XqRcgKwJo rTc5Tc59bx2rXoCsCKC1JtRXL0CxTdxZvQBZEUBbbb1KvQAx2OYX9QJkQwBtdcAA 9QLEoM2n6gXIhgDa6rr/qBcgBv93q3oBsiGAtnrpZPUCxODlU9QLkA0BtNWI3dQL EINvd1cvQDYE0FI8EMkPK8ryYCSbEUBL7fGNegFisedQ9QJkQQAt1e1e9QLE4vLu 6gXIggBaqnd79QLEok8H9QJkQQAt9c0e6gWIxdA91QuQBQG0E++B+GL5drwLYjEC aKd9hqgXICYtv1AvQGYE0E7X8gECX1x3m3oBMiOAdnr1BPUCxOS1E9ULkBkBtNN4 jlHyxYQG6gXIjABaqeRP6gWIzd9WqhcgIwJoJZ4H4hGeC2IxAmilO65WL0Bs7rxG vQAZEUAr8Ux0j/B0dIsRQCtNr6VegNjMqK1egIwIoI0qzVcvQIwqL1AvQCYE0Ebt e6sXIEYd+qgXIBMCaKOHL1IvQIweuVi9AJkQQBt9tp96AWL0+f7qBciEANqI80O8 sqCyegEyIYAW2nm8egFi1WCCegEyIIAW6vygegFidclD6gXIgABa6BlOUfdL77PU C5ABAbTQ0BbqBYjVMJ5vYCsCaJ8Sq9ULEK/8sjzhwFIE0D4HfaRegJgd/LF6AQpH AO3DUTDe4UAYWxFA+/Q7VL0AMevfVr0AhSOA9uE2aO/Mqa5egMIRQOvUm6xegNjt OEW9AIUigNbp8oB6AWJ3aQ/1AhSKAFrnhVPVCxC7F09TL0ChCKB1xjZUL0DsxjVS L0ChCKBtSq1QL0ACSuerF6AwBNA2J7yqXoAEnPiaegEKQwBt80AX9QIkoMel6gUo DAG0zef7qhcgAQM55NtKBNA23AbtpcUV1AtQGAJomebD1AuQiBbD1QtQCAJomWtv VS9AIq67Tb0AhSCAlnnjWPUCJOLN49QLUAgCaJkpddULkIip9dQLUAgCaJdK89UL kJDKC9QLsDkCaJeOPdULkJBOvdQLsDkCaJeneX6Yr545W70AmyOAdhnVRL0ACRnd VL0AmyOAVuEkBI9xHoKFCKBVTn1BvQCJOe1F9QJshgBa5bF/qBcgMf+7QL0AmyGA Vvl6T/UCJOabv6sXYDME0CZb/aJegOTkl/tVPQGbIoA2OfId9QIk6Kh31QuwKQJo k/9yaqbPHvinegE2RQBtMrilegESNKSVegE2RQAtUmK1egGStLzcb+oJ2AQBtMjh fdULkKh276sXYBME0CK8BOg5XgS0DgG0CC8Beo4XAa1DAO3BS4C+40VA6xBAe7R7 T70ACTuCV3ktQwDt0eMS9QIk7EGeem8ZAmiPIfuoFyBhX/Aqr2UIoDX4ILD/+Diw bQigNY5+S70AiTvmbfUCbIQAWuORC9ULkLhHL1IvwEYIoDW+a6ZegMSN3FW9ABsh gLbgcSBB4MEgdiGAtjj9OfUCpOCM59ULsCECaIueHdULkIJendQLsCECaIuxDdUL kIJxjdQLsCECaIntF6sXIBXll6gXYAME0BLnPa5egFSc/4R6ATZAAC3x/GnqBUjF C6erF2ADBNASU+qqFyAVU+upF2ADBNAOtaepFyAldaarF2A9AmiHq+5UL0BKrr5L vQDrEUA7vNdOvQAp6XuEegHWI4B2WKMegLTMr6JegPUIoBX2GaJegNS0/EK9AH8h gFa4+wr1AqTmnivVC/AXAmiFga3VC5CaQfuqF+AvBNAGnIYfEs7FtwgBtMGJr6gX IEUnvapegD8RQBv0Olu9ACl6uqN6Af5EAG0wob56AVI0cWf1AvyJAFqgFh+OCkvt GeoF+AMBtMDVd6gXIFXX8MFHWxBAC/Q7VL0AqerfVr0AfyCAelv8pl6AdC2uyEcf LUEA9Q57X70AKTv8A/UC/I4A6j1yoXoBUvboReoF+B0B1BvVRL0AKRvdVL0AvyOA cpXmqxcgdZUXqBdgHQIo1+UB9QKk7tIe6gVYhwDKvXW0egFS9/Yx6gVYhwDKcUdE gOZVVS/AOgRQreVg9QIItOIMcCsQQLXuXdULIHBfN/UCrEUA1Ybvrl4AgRHN1Quw FgEUK7tUvQAS2y1TL0AeAZQ79wn1Akic96R6AfIIoNxLJ6sXQOLlU9QLkEcA5WbV UC+AxA811QuQRwDV9vxavQAif/9GvQAEUI2bYILFjTA2IIBa3zVTL4DIyF3VC0AA xTgJJmCcCGMBAih12X3qBZDper96AQigVt/D1Qsg83479QIQQCkehxSyJRU4CEiO ACod9bZ6AYSOfke9AARQ6alO6gUQ6nmOegEIoNKkHdULIDR5J/UCEEChncerF0Cq wQT1guARQKFbrlcvgNS/b1AvCB4BFPrq7+oFkPp6L/WC4BFAnVIr1AugtaZMvnpC 6AigzjkciRm6c59SLwgdAdR59QT1Aoi9dqJ6QegIoA6fAwjenOrqBaEjgDKtB6oX QG7fQeoFgSOAMj0uUS+A3INd1AsCRwBlxjZUL4DcuEbqBYEjgCq1p6kXwAJ1pqsX hI0Aqtx4k3oBLHDTzeoFYSOAKnwMBHl8GESNAIqUXapeABusKbdMPSFoBFDkoofV C2CFix9RLwgaARR59wj1AljhvSPVC4JGADVKrFYvgB2WVOTBMEIEUOOEV9ULYIkT X1MvCBkB1Hj2DPUCWOK5M9ULQkYANWbsoF4AS8yspV4QMgIosdeX6gWwxt5fqRcE jABKPMBn4PGnHpeqFwSMAEqMbqxeAGuMaaJeEDACqFCLT8Bjvdoz1AvCRQAVbuAT 8FjvxlvUC8JFABU4CAEb4EAEHQIowEEI2BAHIugQQIEL+fw7NnTRo+oFwSKAAhyE gI1wIIIMAUwfByFgYxyIIEMA03fqC+oFsMxpL6oXhIoApu/FU9QLYJmXTlUvCBUB TN8a9QDYZm419YJQEcDUtf1AvQDWOayfekGgCGDqnuqkXgDr9DxHvSBQBDB1U+uo F8A60+qqFwSKAKZtj2/UC2ChPYeqF4SJAKaNowBRCA4F1CCAaRvbUL0AFhrXSL0g TAQwZTtNVC+AlepPUi8IEgFM2a3XqhfASrddp14QJAKYshG7qRfASt/url4QJAKY rsrz1AtgqSrz1QtCRADTdfUd6gWw1DV3qheEiACma3BL9QJYakgr9YIQEcBUlV6u XgBbrSm7Qj0hQAQwVRc9rF4Aa13MkxLSRwBT9V479QJYqy9PSkgfAUzTVr+oF8Be Syv+qp4QHgKYpva91QtgsQ591AvCQwDT9Ppx6gWw2BvHqxeEhwCmaAue/YUsFlXi aQlpI4ApOvEV9QJY7aRX1QuCQwBTxOPgkBUPh0sdAUwRP+Agq3lV1QuCQwDT0+49 9QJY7oi+6gWhIYDp6d1evQCW69NBvSA0BDA9s2qoF8ByP9RULwgNAUzNAQPUC2C9 Np+qFwSGAKbmiXPVC2C9J89TLwgMAUwND0SH0bS66gWBIYBp2fNr9QI44O/fqBeE hQCm5aGL1QvggIc7qxeEhQCmZUJ99QI4YOLO6gVhIYApaTJKvQBOaDpavSAoBDAl 3buqF8AJ93VTLwgKAUzJ6MbqBXDCmCbqBUEhgOnYaaJ6ARxRf5J6QUgIYDruuFq9 AI648xr1gpAQwHR831S9AI4YtYt6QUgIYCpqT1MvgDPqTFcvCAgBTMWt16oXwBm3 XadeEBACmIoRu6kXwBnf7q5eEBACmIaaM9UL4JAdZqkXhIMApuGmG9UL4JCbb1Iv CAcBTMOw5uoFcMjwFuoF4SCAKag6R70ATqk2V70gGAQwBdffol4Ap9zwb/WCYBDA FHyzh3oBnDJ0T/WCYBDA5FWep14Ax1SZr14QCgKYvH/dpl4Ax1x7u3pBKAhg8r7c S70Ajvlqb/WCUBDAxFVYqF4A51RcpF4QCAKYuCvuVi+Ac668R70gEAQwcV/w4wxy 9eU+6gWBIIBJK7dEvQDuWVP+R/WEMBDApHXtrl4AB3W7T70gDAQwaYNaqRfAQYNb qxeEgQAmrOxS9QK4aE25ZeoJQSCACevygHoBnHRpD/WCIBDAhH10kHoBnPTxweoF QSCAySr5k3oB3JRfcaV6QggIYLI6P6heAEdd8pB6QQgIYLL6H6JeAEd9eKh6QQgI YKK25ccYFFF+hZ/VEwJAABN1Gbezoqi63q9eEAACGL9qu+9S61L1CPhi4bMzvh/B U2USQgBjVLL5Hk12rNVEPQMeGj1j8uihw3lFJW4EMB6NWzdv2KCWegU8N2P8uOGD xqhX+IQAFlu5Q9vszgc3kZolo0YM6M9hMfEggMVS4phj9t1ZPQIBmjDwrbd+U4/w AAEsurpnHnygegPCtXToR89OVY9wHQEsom3+cdbf1RsQvK+f+d8q9QanEcAiObrT 8eoJwFo/ftzzbfUGhxHA3JW49KIG6g3AX8Y/8gAvBxYRAczZVV12UE8ANjKzx13q CY4igDm64F911BOAzUy7/TH1BCcRwJw0fXoP9QSgUEPPHqWe4CACmIsHO6sXAJnk 97xEPcE9BDC6Rq83Uk8Ashh7/Fj1BNcQwMgueFS9AMhu0bW8EpgbAhhVz47qBYDJ mqc7qSe4hQBGU6of5x3ABYPa5qsnuIQARlL1c448gBsm7DdXPcEhBDCKqgPrqycA EU3clwJGRgAjqDpoJ/UEILJJrSlgVATQjP7BLRQwMgJoVHoEP//CLRN3X6Ge4AgC aNLs5YbqCUCOxp08Uj3BDQTQZCqHH8A90+qqF7iBABq8xsmncNHrJ6gXOIEAZndo P/UCoCiWn9BfPcEFBDCrrX5RLwCKZk6tX9UTHEAAs/qgrXoBUET9DlMvcAABzObI d9QLgKJaceq76gn2I4BZlOJmKjhs7o6ci2BCALN49wj1AqAY3jtSvcB6BDCz3Yer FwDFsWz/EeoJtiOAmY3lIyBw2zge4mBAADO6/B71AqB41lx5r3qC5QhgRmvUA4Di mltNvcByBDCT505XLwCK7fkz1AvsRgAz2OZn9QKg+JZUXaWeYDUCmMHHB6oXADH4 5CD1AqsRwMLtPF69AIjD0j0nqCfYjAAW7vum6gVALEbtol5gMwJYqHbvqRcA8cg/ qa96gsUIYKG4Bxre4G7oLAhgYY59Q70AiEv+GW+qJ9iLABbmu2bqBUBsRu6qXmAv AliI1gPVC4D45LcdpJ5gLQJYiHc4RQg+efco9QJrEcDNcQ4q/LKkJiejZkAAN3fD zeoFQJzW3HSLeoKtCODmOAYGnllaTr3AVgRwMz0uUS8AYvZgF/UCSxHAzXzLTQPw zXe7qRdYigBuhp+A4Z2FldQLLEUAN0MA4R1eBMyAAG7q6bPUC4DYPXO2eoGdCOCm OAgLHuJQrMIRwE3xEzA8xIuAhSOAmyKA8NCy7dQL7EQAN9G9q3oBkID7uqkXWIkA bmJwS/UCIAFDWqkXWIkAboKfgOGlH2qqF1iJAG6CAMJLP26vXmAlArixkj+pFwBJ WF55pXqCjQjgxnp2VC8AEtGrk3qBjQjgxjgJAZ7iPITCEMCN8RIgPDWvqnqBjQjg xgggPMW7IIUhgBsjgPDU8rLqBTYigBt59AL1AiAhj12oXmAhAriRYc3VC4CEDG+h XmAhArgRfgKGt+ZUVy+wEAHcCAGEtzgVuhAEcCMEEN7iXZBCEMANXfcf9QIgMf93 q3qBfQjghvoerl4AJOb9duoF9iGAGxrTSL0ASMzYxuoF9iGAG+IlQHhsfhX1AvsQ wA0RQHiM54JsjgBuoOZM9QIgOfkNZqknWIcAbuApTkyDz3qeo15gHQK4gSH7qBcA CfqCJ35tigBuYFpt9QIgQdPrqBdYhwBugPdA4LXFFdQLrEMA1yu9XL0ASFJ+lRXq CbYhgOud8Kp6AZCkNSe9pp5gGwK43hvHqhcAiXrzOPUC2xDA9b5rpl4AJGokDz3c BAFcj/dA4DnORN0UAVyPZwLDczwbeFMEcD2+A4TnZtdQL7ANAVyPAMJzHIewKQK4 HgGE5zgVf1ME8C/d7lUvABJ2eXf1AssQwL/wUHR4j4ejb4IA/oUHgsB7PBZkEwTw LyN3US8AEvY9N/tvjAD+hfdA4L2FldQLLEMA/0IA4T3eBt4EAfwLAYT3VpRRL7AM AfzTZfepFwCJ63q/eoFdCOCfHuiiXgAkrsel6gV2IYB/ep2j0uC/N45XL7ALAfzT l3upFwCJ+2pv9QK7EMA/TeWJWfDftLrqBXYhgH/iTWAEYGk59QK7EMA/EUAEgPtg NkYA/3D6c+oFQPLWnPm8eoJVCOAfbrxJvQBIwU03qxdYhQD+4alO6gVACnqeo15g FQL4Bw7DQhA4EGsjBPAPw5qrFwApGN5CvcAqBPAPvAmMIPBguI0QwD8QQASBA7E2 QgD/QAARhPzS6gVWIYC/O/UF9QIgFae9qF5gEwL4u+v+o14ApOL/blUvsAkB/N3/ zlcvAFLx+D/UC2xCAH/34cHqBUAqPjpEvcAmBPB3o5qoFwCpGN1UvcAmBPB3vAmM QMyrql5gEwL4OwKIQHAj4IYI4O8IIAJBADdEAH9HABEI7oTeEAFcp2t39QIgJd14 AvZ6BHCdnh3VC4CU9OLoy/UI4DoDDlAvAFLyaRv1AosQwHXGNFIvAFIytrF6gUUI 4Dq8B4JgzKmuXmARArgOAUQweDTwBgjgOgQQweDRwBsggOsQQASDO6E3QADXIYAI BndCb4AArnXOk+oFQGrOfUq9wB4EcK27rlQvAFJz91XqBfYggGu9dLJ6AZCal09R L7AHAVxryD7qBUBqvmipXmAPArjWtNrqBUBqptdRL7AHAVyLN4EREO6DWY8ArkUA ERDug1mPABa44FH1AiBFFz6mXmANAljg3m7qBUCKul+uXmANArjWjQ1r1eKFYYRg 2owZ425Wj7AHAVzv9F12qlV7B/UKIBEzp8+Y9P3z6hW2IYCbOb3ZjjvUrqVeAcRk xvSZk0dSvsIRwExOa1Zvh9r8XAx3TZs+c8rIF9Qr7EYATa5qWrMGZ4jDJWN+mDXq LvUINxDAiC7cpXaNPdQjgKyG/jD9e+7pygUBzM1JzerUqL6LegWwke9n/zBt5Cvq FS4igEVzerM61avxkzG0xsyZPY33N4qDABbPybvuUL1Kc/UKBGb4vNkzv3tZvcIH BDAmZ+1WvWoVfjZGkr6fN3f2t8+oV3iFAMbtrN2qVa5UpaZ6Brwxa96C+XPoXjII YGKO3L1q1UoVy3PUIIpi+uKFC+bOHfGueofnCGAK2u5atVqlCuV3Vu+A9SYsXrRg ztzv+ql3BIMApuuwFhUrV9x++6bqHbDIqCVLFs5fOOwD9Y4QEUCdQ/Yo+Al5+3Lb 7aQegtRNWvrjkoKfcYd+qB4SOgJoiYP2KV++/HZly5blGAY/zVi2bNnSxYsXf/Gx egk2QACt1Hqf7cqXK8hhmdIcx+CqaSuWFyTvx8VLvxiknoKMCKATWu+73drvDkuV LvU3vkO004yf8lfkr/0ub+lAgucOAuiovQ4sVaZc6YIgFuC7xLRN+6lA/ooVPy7P /+Qr9RgUAwH0SLNDS5YpU6bk30r+bduSJUvWVc/xwtSVK1f+/NPKn1YuX758Zf+R 6jmIGQEMQIOjtl73neK2JbfZtsA22/Bj9MZmrFr1c4FVBalb+53dL++MVy9CSghg 4Goeu2VBGktuU3LrgjJuvU3Bv7beemvfAjnjl19+WfXLqoJ//fzzLytXrSyo3Oo3 Z6lXwQIEEECwCCCAYBFAAMEigACCRQABBIsAAggWAQQQLAIIIFgEEECwCCCAYBFA AMEigACCRQABBIsAAggWAQQQLAIIIFgEEECwCCCAYBFAAMEigACCRQABBIsAAggW AQQQLAIIIFgEEECwCCCAYBFAAMEigACCRQABBIsAAggWAQQQLAIIIFgEEECwCCCA YBFAAMEigACCRQABBIsAAggWAQQQLAIIIFgEEECwCCCAYBFAAMEigACCRQABBIsA AggWAQQQLAIIIFgEEECwCCCAYBFAAMEigACCRQABBIsAAggWAQQQLAIIIFgEEECw CCCAYBFAAMEigACCRQABBIsAAggWAQQQLAIIIFgEEECwCCCAYBFAAMEigACCRQAB BIsAAggWAQQQLAIIIFgEEECwCCCAYBFAAMEigACCRQABBIsAAggWAQQQLAIIIFgE EECwCCCAYBFAAMEigACCRQABBIsAAggWAQQQLAIIIFgEEECwCCCAYBFAAMEigACC RQABBIsAAggWAQQQLAIIIFgEEECwCCCAYBFAAMEigACCRQABBIsAAggWAQQQLAII IFgEEECwCCCAYBFAAMEigACCRQABBIsAAggWAQQQLAIIIFgEEECwCCCAYBFAAMEi gACCRQABBIsAAggWAQQQLAIIIFgEEECwCCCAYBFAAMEigACCRQABBIsAAggWAQQQ LAIIIFj/D6xRPrWuQLCxAAAAAElFTkSuQmCC"/></symbol><g mask="url(#b)"><g transform="rotate(.193) scale(.36014)"><symbol id="c" viewBox="0 0 1280 1280"><image width="1280" height="1280" xlink:href="data:image/png;base64, iVBORw0KGgoAAAANSUhEUgAABQAAAAUACAIAAACXhmigAAAACXBIWXMAAA7EAAAO xAGVKw4bAAEYb0lEQVR4nOzdCXxU9bnwcRIIS9ZJJisEEtQu96pordWPrdX2dtO2 Xvtau17bvq+1drO91harVq0IooJQrawCCgiiouACCCggSIBAWBIggQBJZjLZk1my J5OZef9hFBEQkjDPOTPn/L6tiKjPOcjh5PzmbFGDAAAAAAAwgSi9VwAAAAAAAC0Q wAAAAAAAUyCAAQAAAACmQAADAAAAAEyBAAYAAAAAmAIBDAAAAAAwBQIYAAAAAGAK BDAAAAAAwBQIYAAAAACAKRDAAAAAAABTIIABAAAAAKZAAAMAAAAATIEABgAAAACY AgEMAAAAADAFAhgAAAAAYAoEMAAAAADAFAhgAAAAAIApEMAAAAAAAFMggAEAAAAA pkAAAwAAAABMgQAGAAAAAJgCAQwAAAAAMAUCGAAAAABgCgQwAAAAAMAUCGAAAAAA gCkQwAAAAAAAUyCAAQAAAACmQAADAAAAAEyBAAYAAAAAmAIBDAAAAAAwBQIYAAAA AGAKBDAAAAAAwBQIYAAAAACAKRDAAAAAAABTIIABAAAAAKZAAAMAAAAATIEABgAA AACYAgEMAAAAADAFAhgAAAAAYAoEMAAAAADAFAhgAAAAAIApEMAAAAAAAFMggAEA AAAApkAAAwAAAABMgQAGAAAAAJgCAQwAAAAAMAUCGAAAAABgCgQwAAAAAMAUCGAA AAAAgCkQwAAAAAAAUyCAAQAAAACmQAADAAAAAEyBAAYAAAAAmAIBDAAAAAAwBQIY AAAAAGAKBDAAAAAAwBQIYAAAAACAKRDAAAAAAABTIIABAAAAAKZAAAMAAAAATIEA BgAAAACYAgEMAAAAADAFAhgAAAAAYAoEMAAAAADAFAhgAAAAAIApEMAAAAAAAFMg gAEAAAAApkAAAwAAAABMgQAGAAAAAJgCAQwAAAAAMAUCGAAAAABgCgQwAAAAAMAU CGAAAAAAgCkQwAAAAAAAUyCAAQAAAACmQAADAAAAAEyBAAYAAAAAmAIBDAAAAAAw BQIYAAAAAGAKBDAAAAAAwBQIYAAAAACAKRDAAAAAAABTIIABAAAAAKZAAAMAAAAA TIEABgAAAACYAgEMAAAAADAFAhgAAAAAYAoEMAAAAADAFAhgAAAAAIApEMAAAAAA AFMggAEAAAAApkAAAwAAAABMgQAGAAAAAJgCAQwAAAAAMAUCGAAAAABgCgQwAAAA AMAUCGAAAAAAgCkQwAAAAAAAUyCAAQAAAACmQAADAAAAAEyBAAYAAAAAmAIBDAAA AAAwBQIYAAAAAGAKBDAAAAAAwBQIYAAAAACAKRDAAAAAAABTIIABAAAAAKZAAAMA AAAATIEABgAAAACYAgEMAAAAADAFAhgAAAAAYAoEMAAAAADAFAhgAAAAAIApEMAA AAAAAFMggAEAAAAApkAAAwAAAABMgQAGAAAAAJgCAQwAAAAAMAUCGAAAAABgCgQw AAAAAMAUCGAAAAAAgCkQwAAAAAAAUyCAAQAAAACmQAADAAAAAEyBAAYAAAAAmAIB DAAAAAAwBQIYAAAAAGAKBDAAAAAAwBQIYAAAAACAKRDAAAAAAABTIIABAAAAAKZA AAMAAAAATIEABgAAAACYAgEMAAAAADAFAhgAAAAAYAoEMAAAAADAFAhgAAAAAIAp EMAAAAAAAFMggAEAAAAApkAAAwAAAABMgQAGAAAAAJgCAQwAAAAAMAUCGAAAAABg CgQwAAAAAMAUCGAAAAAAgCkQwAAAAAAAUyCAAQAAAACmQAADAAAAAEyBAAYAAAAA mAIBDAAAAAAwBQIYAAAAAGAKBDAAAAAAwBQIYAAAAACAKRDAAAAAAABTIIABAAAA AKZAAAMAAAAATIEABgAAAACYAgEMAAAAADAFAhgAAAAAYAoEMAAAAADAFAhgAAAA AIApEMAAAAAAAFMggAEAAAAApkAAAwAAAABMgQAGAAAAAJgCAQwAAAAAMAUCGAAA AABgCgQwAAAAAMAUCGAAAAAAgCkQwAAAAAAAUyCAAQAAAACmQAADAAAAAEyBAAYA AAAAmAIBDADAQFgsSdHRgwcNCkRFRcl8PQ0oarLf73O7PQLzAQAwHQIYAGBqVmvK mb4aHm/PD/8U/H4gKcni9XrVX6SmWqOjo493r0bUQv1+f2Njk1poTEyMx+NW63x8 +VEf/WnQGX8WTU1OzVYSAIDwRwADAAzr9Lj9KGh7JcTHJ6ekqJTVa/U0oLLZ6XS2 trZGRQVTOeq0bieSAQAmQgADACJVZmaG1+s96WtZb94G4zYxMfH4JcpGjttQUZHs dnuam5ujoj7K5JP+k8bExNTW1um4egAAhBABDAAIa6ecxQ18JKlXIokr7bQ8PvnI gbPHAIAIQwADAPSXnJx8csp+FLn+2Ni4tLRULe+2Rd+pX6GG+ob2jvaoqOhT2lhl s8vl0nHdAAA4Iw4pAAAa+eS53BOXK/tHjIhNT0+jco1E/brW1zd0fNzGg07+pee8 MQBALxxtAADEDRs2LC4udvTo0VQuVBtXVla2tbV3dXXpvS4AANPhQAQAIM5qtY4e na33WiCMVFY6mpqa9F4LAIDpEMAAAHEEME5BAAMAdEEAAwDEWa0po0eP1nstEEYq Kyu5ExgAoD0CGACghcsuG8cNwAgKBAKFhUV6rwUAwIw4FgEAaOHSSy8ZPHiw3muB sODz+fbvP6D3WgAAzIgABgBoISsrKyMjXe+1QFiw2ey8JRgAoAsCGACghZEjR6an p+m9FggLZWXlzc3Neq8FAMCMCGAAgBbGjBmdkpKi91ogLJSXl3s8BDAAQAcEMABA C0lJSWPH5uq8EggP5eUVHo9H77UAAJgRAQwA0ILFkpSbm6v3WiAsVFRUuN0EMABA BwQwAEALFoslNzdH77VAWKiosLndbr3XAgBgRgQwAEALBDBOIIABAHohgAEAWiCA cQIBDADQCwEMANBCcrIlJ4cARi+bzeZyEcAAAB0QwAAALRDAOIEABgDohQAGAGiB AMYJBDAAQC8EMABACwQwTiCAAQB6IYABAFoggHECAQwA0AsBDADQAgGMEwhgAIBe CGAAgBYIYJxAAAMA9EIAAwC0QADjBAIYAKAXAhgAoAUCGCcQwAAAvRDAALRjtaZ8 9N1P7HyiogYFAif/wId/8ckfPMM/cMadWNTHPxZ1/J88244uEAhER0c3Njae5Z9B SBgvgAMfqa+rV1tZVFT04MGDz//LqtpkfT5fIOBX30vPSI/6SAjWOGwQwNpITU31 +/3n2ngCH+0qj//Fmfe6Z9vlDjp1r/vxD5427cO/bmpynnWVAECQob6gAtBYSkry 8UOrU/YkgeMHPb3fBvMgPj6+p8ebmZkZtgfx6hixvr4hJmZIS0tL72Hbh7lxYn0/ +lPUhz+3mJiY2to6vdY2QoVzAKvg9Hiahw2NGT58hBIbq/4fFKf+UBtwgvp/YqLa IHp8vrj4XukZGbk5OZakJNEVc3s8tXV1rS0t7e3tLc3NQ1RgR0W1tbWp7ze3tLS1 tqrvq7+l/ujoaO/95rjOzo6ubq/FkqSCXHT1BowAHoDMzAyv1zvo+I7ppLAM7m0H ndjlqu8kJCT0eHvS0tOio6P1WtuzU+tZW1MzJGZoa2vrSZ/wfPjtaf9swOl06bGa AIwpTA9GAejr+JFWzyk/eOJ8V+8BVnx8ckpK2B5dSes96VffMGzYMLfbHTx0O/mD gOB5j+MHbZzl+FhycnJOzhjtl6t+IZqamlTWxsfFqTBITEhMsljUysQez9zejh07 9sILLuhLyqr8UKl54i9VHMfExEiu+wCXGMxmFclul0t1serk+oZ6Z5PTc1xLa4uq DpXOKpVTU1N1+VjKZrO7XCTNx1JSUoJ7kpPLNri7VX+ojbOruzs9PS1sP0OU5vf7 1e5UbbYffUB5hmsiYmKG8LkkgL4w6Z4UwPGTt9HBQ4hTTtiqSEhOtpg2bkPI5/O1 NLeoGjn5FMeJv2u2QpYLYPVf0uV0xcXHJ6q+TUxUW6/VmpqYlKS25As/c9G4S8dZ U1JO/7dObksNUlZLffmpqc2yprbW2dTU3tqqOrmmpqa+vt7lcro9veeWW1ta1AT1 X1KouMwWwMG+PekHPt7fqrhNSEwI23P1EURFssvlbmlpOe2UcvATST+nkQEEEcCA kaWmWj95PiF4yOWPi4vT68wPTlZbW9fR0REdHTxY+8Q5DeMdrskF8K23/uiOO+44 5QdPRKDB4jZUzvnfp7SkZOlLL+Xv2imxdOMFcPAjxRN/GbxSpndv6w+MGDEiMzND x3XDoOO/GI2NjW1tbcc/+f3Ex5Hq+42NTbquHQBNcfgLRLzjT5Y68Xs5WLn+6OjB I0dmcVYhcp3xcC2iL66WC+Cf//x/fvnLX0pMNrPSQ4deeeWVvO3bJIZHaAB/8kJl PlI0Dp/PV11d4/f7Prow6uMvqTyvCzAedtZAZFBHV71PhT0pgYIHXsOGDc/KytR7 7aC1mprazs7O4KnjTz6HLHwP1wjgyGLaAD7tI8UPT+QOH87O1ozUzrarq/OjDyI/ /vhD/QivDwAiFAEMhJdPXkf34YFXQkLCR89bBs7hk6cywuiWYwI4shg7gE+5KTcY uVw4g74LPpu6paXlxD0sH/240e5eAYyH42lAH1ar9cQDP0+czh0xIjYjI13vVYNh 1dbWdXZ2nHILXFtbW2dnpwZLJ4AjizECePjw4XFxcce/+/EVy8OHc1MuBNXV1Xd0 tJ84aTzoo1cDNDVxpzEQFghgQAvDhg2Lj48PZm50dDQnGRA+Kisd2hyWEcCRxRgB bLVaR4/O1mBBwDl9dHmOPxjGra2tXV1deq8UYEYEMKAFDsIQtghgnBEBDIjSbN8L 4BQEMKAFDsIQthwOhzavACGAI4sxAjg11Zqdzb4X4YgABvRCAANaIIARtjgDjDMy RgCz70XYIoABvRDAgBY4CEPYIoBxRgQwIIoABvRCAANa4CAMYYsAxhkRwIAoAhjQ CwEMaIGDMIQtAhhnRAADoghgQC8EMKAFDsIQtghgnBEBDIgigAG9EMCAFjgIQ9gi gHFGBDAgigAG9EIAA1rgIAxhiwDGGRHAgCgCGNALAQxogXdRImwRwDgjAhgQpdk7 2AGcggAGtEAAI2wRwDgjAhgQRQADeiGAAS0QwAhbBDDOiAAGRBHAgF4IYEALBDDC FgGMMyKAAVEEMKAXAhjQAgGMsEUA44wIYEAUAQzohQAGtEAAI2wRwDgjAhgQRQAD eiGAAS0QwAhbBDDOiAAGRBHAgF4IYEALBDDClt1e6XQ6NVgQARxZjBHAKSkpY8aM 1mBBQH8RwIBeCGBACwQwwpYBzgDfdtsvbrvtNonJZnbk0KFXly//IG+rxHDOAAME MKAXAhjQAgGMsFVZWdnUpM0ZYEtOTo7E5Ntvv/3HP/6JxGQzO1pa+vrrr23avFli uM1mc7ncEpNPYbWmjB7NGWCEIwIY0AsBDGiBAEbY0uwgjACOLMYIYPa9CFsEMKAX AhjQAgdhQYFAwO/3qy/5Q4YMjhkSEzN0aMyQIUOHDYsZPFh9f/DgwUPU31DfV3/q /SMoRv2L6kejo6ODQwYf/+eC43p6etTAwKBB6lufz9f7Y36/1+vt8fl6erw9vXzH v1X/mE/9sPpfd1e3+tbb7e3u7lb/SnpG+onJ5qThPcAEcCQxRgBzD7DaN9bXN6i9 5lC1v1W73SExw4YNVftV9X21J/3k/jb4p8FRUb27xBN73dN3ub3fVZPVDlR9PxBQ e9Suru6Ojo7g3tbnD/4dn9rVqh9Re9qeD3fHXvXDaWmpamxUFMefBDCgG3ZAgBYM HMDqYEjl0/Dhw0cMHxEXFxcbG5uQEB8XF9/7R4ISrw601NGTxWLJGjXqs5/5jDUl Re9V/pDb46mtq2tva+vq6nI5neqQTXWx+rm0HNfaprS2t6u/364O7Do61f96dXV3 Z2VlGenojQDGGRHAYSgQCNTW1AwdNkztb4PULlftd+N6xavdbmJiYm/HxsQkJiVZ rdaMzMxRI0dakpKkV8zldttttmAbn53q4KhAoLW11aW2AI+npaW5ubnlw/2s2uF2 tKvvdaq9rfq2q1PFs/pZGPUzSgIY0ItxjuGAcBahAayOZtxujzrGOl608Qnx8UkW S3JysjrkUodd6tBK9cyFF1549qMrr9fb1t4e/L7q45iYGE3W/dxOXrFBfVs3dbhW U1vb1NjY3dmp+rhOfb+pSR3GeZo9x5O5ta03mNvUgVxaWlqkRHJFRYX6VdZgQQRw ZDFGAFssSbm5uRos6PypuG1sbIxVTdv7UWKc2t+qmlW7XNXw6gdGxMXl5OZe/J// mWq1nn3OAPZs56/388Ta2o6TlhsSqpaHDB7c1tJS19BQX1+v9r29zayKubV3Z9sb zO3tXd3dat8SiZFMAAN6iYzjMyDShW0A+3y+9rb2hITjR1qJSepgy2q1qj/HJyR8 9rOf/Y//+I8zxm3YNq20Ez/xs/ysg5HsbGpqb21tbm6uralRB7W9kezxNLceP7nc 3NLe0ZGZmREmhbxvX6E2CyKAI4sxAli5/PLLtFnQ2am+raurj42NTUzovThG7W+T lZSU3vO2CQkXXHjBuEvHfdoFMn3Z8+hLraHa9VVXV/uP34qiJRXJg6OinE5npcNR X1fX5HS63e7eq3h6I7k3k9UXuMGDB2u8Vn1BAAN6CYvDL8DwdAxgddTV0NCojgAs qm6TkhJ6Szdp5MiRl1122de+9rXU1NQT/2RXV5c6bhgUCQdb4eyc//V6DxNramqr qz1ud/Px0yaNvaeRew/aPM3N6rBNy8M1v99fVLRfm2URwJHFMAE8btylmp0e9Pl8 bW3tib0fKSalqLy1WuN7L55JuPCii6644oqszMzT/xXD7G+DN5V0tLXpvSKf0HsO OTra5XLZKytra2oaGhpcbpenuaW196KdVpXH6em6Xa1DAAN6IYABLUgHsKrc+vqG xMQEVbnJyclJx40eM+brX//6F77whdjY2BP/pDrY6ujoUN8ZMWLEKQdbJwIYos5y vBs8glRV3NPd3VBfX1lZWV1dXVNb03syo61VYmUIYHwaAvicEhMSMzLS09LSe/e6 ycmf+/znP/fZz55y1Yxh+vacdDwJPGBqnbs6OhxVVVUOR319vdPl9HiaFbW/bWtr V7+4om1MAAN6IYABLcgFsPpqPX/+/CuvvDIxMfHED56lcs+CANbd6cfK6oDy8OHD FUePvrB4kcQSbTa7y+WSmHw6i8WSmysSwHfe+dtbbrlFYrKZHTtyZOXKFe9t3Cgx vKLCptneJiMjIyvrDKdez9+MmbMuuvDCQWaq3LMLz5PAA9Pd3d3e2lpWVjZv/nxL skViEQQwoBcCGNCCXAD7/f6Cgt0hOeQigMOQOqAsKS4+cvjwSy8vk5hfVlbe3Nws Mfl0cgH8xz/eddNNN0lMNrOyo0fffPPNde+ulxhujACe+tS0Sy+5RGJyhPrwJHBV VV8eBx0RKisqpk6bFhcfJzGcAAb0QgADWpAL4EBg0L59+0IyigAOQ+po8uCBA4cO Hly+4nWJ+QQwPo1hAjgrKysjI11i8sRJj33pyislJkeu4FMAO0P9OGi9EMCAIRHA gBasVuvo0SIBPHjwkIKCgpCMIoDDkNfrLT18eHdBAWeAz4IAlmCYAM7Ozk5NPcer gwZm8uTHr7jiConJkSt4ErjK4QgEAnqvSwioAJ729NMjRgwXGV7paGoigAEdEMCA FuQCOCZm6M6dO0MyigAOT1WVle+9++6yV1+RGF5eXuHxaPES4EEEcKQxTADn5uQI 3cM5ceKkL33pSxKTI1rwUVhdnZ16r0gIVNps/3r66WHDh4kMJ4ABnRDAgBYIYAyY OgJbt3btaytXSAwngPFpDBPASUlJY8fmSkx+8MEHr732qxKTI5rX63W53VUOh94r EgIEMGBIBDCgBQIYA1ZRVrZm9eq3Vq8SGV5R4XZHfAD/7//efeONN0pMNrOKY8fe fvvt1WvfERmuYQBbLEm5ubkSk//6179961vfkpgc6dwej8Ph8HZ3670i54sABgyJ AAa0QABjwMqPHn3rrbfeWb9OYri2HSIVwPfc89dvf/vbEpPNrKKsbPWqVW+vWS0y 3BAb3l13/en73/++xORI5/V6m5zOmupqvVfkfBHAgCERwIAWCGAM2NHS0pUrVmx4 f5PEcJvN5nJFfIcQwBIME8DJyZacHJEN7447fnPrrbdKTDYAt8djq6iI9PchEcCA IRHAgBbkXoNEABvekUOHXl2+/IO8rRLDCWB8GgL4nG677Re33XabxGQDMMajsEQD mNcgAXohgAEtyJ0Bjo2Ny8vLC8koAjg8HS4ufmnZsvxdofmY4xQ2m93lcklMPh0B HFkMFMDJOTljJCb/6Ec//vWvfy0x2QCM8Sgsh832zLPPDokZIjGcM8CAXghgQAsE MAaseP/+F5cs2Vu4T2K43W53OjULYKlnEf3jHw9+9as8jDfE7BUV69auff2NlRLD tXz6WkpK8pgxIgH8/e/fdNddd0lMNga3x2O32Xw+n94rMnAEMGBIBDCgBQIYA3aw sHDBwoXFJcUSw40RwLyNRoLo+7eMEcDf+MY3x48fLzHZGFQA19TUdHZ06L0iA0cA A4ZEAANaIIAxYPv37n1u/vwjx45KDLfbK51Op8Tk0xHAkcVAAZwyZsxoiclqq1Pb nsRkYzDAVdAEMGBIBDCgBQIYA1a4e/esOXNslXaJ4ZWVlU1NGgVwUlLS2LG5EpMf fPCha6+9VmKymakAXr9u3fIVr0sMLy+v8Hg0CmCrNWX0aJEAvvLKL02aNElismH0 PgvaZvNH7FXQBDBgSAQwoAUCGAO2d9euZ2fNrK6pkRhujAB+7LHJX/ziFyUmm1lV ZeXGDRuWvrxMYrgxAnjcuHFTpkyVmGwYkf4saAIYMCQCGNACAYwB252fP/2ZZ5qc IsdJWh6BEcCRxUABLLX7/cxnPvvss89KTDYMr9frdDpVA+u9IgNEAAOGRAADWiCA MWC7tm+fOn16c0uzxHACGJ+GAD6nMWNynnvuOYnJRuJyu20VFYFAQO8VGQgCGDAk AhjQAgGMAdu5bdsTU6e0yzxJVcsjsDGjs1OsVonJBHDIeb3e0sOHC3btWvbKyxLz y8vLPR6Rz3ROJ7f7zczMXLhwkcRkI3F7PJWVlT1er94rMhAEMGBIBDCgBQIYA7Yj L2/S5Mk9vh6J4VoegWVnZ6emigTwo49OvOqqqyQmm5aKlgMHDhw6cEDoKdBlZeXN zREfwMnJKcuWiZwhN5KIfhkSAQwYEgEMaIEAxoBt/+CDRyZOjIoW2V1reQQ2cuTI 9PQ0icmPTZ78xSs4AxxKKloOHjhwuLj41ddfk5hvjACOjY1dsWKlxGQj6b0N2OWq rqrSe0UGggAGDIkABrRAAGPA8rZsefDhh4cNHyYxXMsjsMxeGRKTp0x9atyll0pM Ni0VwCXFxaWHDgldAm2MAI6Kin7nnXckJhuMy+2uKC/Xey0GggAGDIkABrRAAGPA tr7//r0PPJCYmCAxXNMAzsjIzMqUmPzUtOmXXHyxxGTT6g3gkpKjhw8vXfaSxPyy srLm5haJyaeT2/12dXVv2rRJYrLBqM3Jbrf7ekTu4xBFAAOGRAADWpA7AktMTNy8 eUtIRhHA4Wnrpk333Dte6PFRWh6BpaWljho1SmLyjJmzLrrwQonJpqWK5fDhwxVH j76wWOQhT8YI4JaWlry8bRKTDUZtTlVVVd1dXXqvSL9V2e3PzpxpgDtQAJyMAAa0 kJpqzc4WOQKzWCybNr0fklEEcLjxer1t7e278/P/du+9GTIXD2t5BJaRkZElcwZ4 1uw5F4wdKzHZtFSxlKoAPnbs+UULJebbbHaXyyUx+XRyAdzQ0Lhjx46YmBiJ4Uai Nqfa2tqO9na9V6TfVADPnD1L6A1ODoejsZEABnRAAANaIIAxAL1HjXV1xw4dembG s9HR0RKLsNsrnU6nxOTTjRt3qdDPYsHzL4waOVJismmpbe/o0aOV5eVz58+TmO/3 +4uK9ktMPl1KSsqYMaMlJqufxavLX7MkJUkMNxKv1+tyuaoi8DlYBDBgSAQwoAUC GAMQjBCHzTbnubkS8wOBgM1mc7s9EsNPJxfALyxclJUpcm7ZtKS3PS0D2GJJysnJ iYoSOeBh2+ujCH0OFgEMGBIBDGiBAMYAqAg5dOjQscOHX3xpqcR8n8+3f/8Bicln dNll44Qi5OVXXuUsXGipba+8vLzW4XhmxrMS8wOBQGFhkcTkM7r00ksGDx4sMflf Tz/zH5//vMRkg+l9DpbNpvY5eq9I/xDAgCERwIAWCGAMgNfrLS0t3VtQsETmSbx2 u93p1Og+zNTU1OxskSdgqZR65dXlBHBonbj8/t8zZwh9bOFwVDU2NkpMPt2oUSPT 0kTeQf3EE09efvnlEpMNRm1Rqve83d16r0j/EMCAIRHAgBbknsKSnJyycePGkIwi gMNQpc22bu3a11aukBheXl7u8Wj0LtaUlOQxY8ZITPb7/atXr+FBRKEVfABbwY4d U6Y9JXb/uXafv+TkjElOTpaY/OCDD1577VclJhuMCuDq6uquzk69V6R/jgfw7MAg kQTmKdCAXghgQAtyAZyenrFu3bqQjCKAw1D50aNvvPnmunfXSwyvqKjQ7AZgqzVl 9GiRBxHV1dXv3btXYjI+2LTprrvvFnp2d2VlZVOTRg9gs1iScnNzJSb/8Y933XTT TRKTDSZ4TUFHW5veK9I/1ZWVs+fO7fGJvMGYAAb0QgADWiCAMTBHDh1a/tryLVu3 SgyvqLBp9isu9yTexsamgoICiclQAfynv/wlU+YVXFo+gdxiseTm5khM/uUvf/nz n/+PxGSD8Xq9TperOtIeBE0AA4ZEAANaIIAxMCUHDixZunT33j0Sw43xLlaXy52f ny8xGVs3bfrfv/0tLS1VYriWR//Jyck5OSJX4N988w9+//vfS0w2nkh8EDQBDBgS AQxogQDGwBwsLFywcGFxSbHEcC1Pwcn9FmhpacnL2yYxGSqA77l3fIrVKjFcy6N/ uQsQvvGNb44fP15isvG4PR4VwIGA0COlRBDAgCERwIAWCGAMTOGePXPmzi23VUgM N0YAd3R0bt68WWIy8t5//2/33ZdkEXnCtjEC+Oqrr54w4VGJycYTiW9CIoABQyKA AS0QwBiYPTt3/nvmjNq6OonhWj6FSO5NYD09Pe+9t0FiMvI2b77vH/+Ii4+TGK7l O2DknsF28cWXTJs2TWKy8agAVvucHq9X7xXpBwIYMCQCGNCCXACPHDlq9erVIRlF AIehgh07nvrXv9wekV8XLQ+/5H4LqC9ka9eulZlsdiqAH3j44REjhksMN8bml5s7 ds6cORKTjUcFcFVVVXdXl94r0g81lZVz58/v6hZZZwIY0AsBDGhB7vArOzv77bdX hWQUARyGdublPT51SofMyzONUSBDhsSsWhWa3wI4xbYtWx565JGYoSLvWDbG5pee nrF48WKJycYTia8CVgE87/kFBtgDAzgZAQxogQDGwOzYunXCpEmBQSKPjTFGgcTG xq5YsVJiMrZv3frIo49GRYscKhhj84uPT3jttdckJhtP76uAa2s72tv1XpF+IIAB QyKAAS0QwBiYbVu2/OPhh4cNHyYx3BgFYrEkv/zyyxKTsSMvb9LkyQa4AVJu84uK in7nnXckJhuPCuC6urr2tja9V6QfCGDAkAhgQAtyh19jx44N1ekvAjgMGeYxvHK/ BTIyMhYt4hpUETu3bXt8ypSOzg6J4cbY/HgIed95vV6ny1VdVaX3ivRDjcPx/MIX WmWinQAG9EIAA1qQO/y64IILXn99RUhGEcBhRR0strW379658+/335eamiqxCGMU yOjRY+bNmycxGbu2b586fXpzS7PEcGNsfi6Xa+vWvJgYkdukjUcFsK2iQu+16AcV wC8sXNjS1ioxnAAG9EIAA1oggNFfvffL1dUdLSn598wZ0dHREovQ9j3AUu+hufDC i2bOnCkxGbvz86c9/bTTJbKRaPkWLrn3APv9/leXv2ZJErlGw3hcbndFebnea9EP BDBgSAQwoAUCGP2lAvjYsWOOiorZz80VWoQxAvg///Pi6dOnS0zG7p07n50xo7Y+ 4l9DLRfAysJFizMzMoSGG4zarZWXlem9Fv1AAAOGRAADWpAL4M9+9nOvvPJKSEYR wGFFHSmWlJQcPXx46bKXJOb7/f6iov0Sk89ILoC/8IUvPP74ExKTsa+gYObs2ZVV DonhWgawMm7cpUJXUjw1bfolF18sMdl41G6torw8EBB5rL2E2qqqRYsXu5s9EsMJ YEAvBDCgBbkA/tznPh+qR+ASwGHF6/WWHj5csHPnsldD8wHHKex2u9Ppkph8RnKn 4K655sv//Oc/JSajaM+eOfPmlZWLnLLT8gIEZdSokWlpaRKTJ0167Morr5SYbDwq gG0VFX6/X+8V6aveAH7xRbdH5CsjAQzohQAGtEAAYwBs5eVr33ln5VtvSgwvL6/w eEROa5yRXABff/3X7r//fonJOLBv37znnz9celhiuMYBnJuba5F5mvrf/37f17/+ dYnJxtMbwDab3+fTe0X6igAGDIkABrRAAGMAjh05snLlivc2bpQYXlFh0/KXOzk5 OSdnjMTkG2648e6775aYjOKiooWLFxcdELlU3mazu1zaXYNgsVhyc3MkJt95529v ueUWicnGowLYbrf7ekTeLC2BAAYMiQAGtCAXwJdccumLL74YklEEcLg5XFLy8rJl 23fmSwy32Wwul5YBbMnJEcmPn/zkp//v//0/iclgC+wLtsC+UwFcabf3RE4A11VX v7h0aZNTJFMJYEAvBDCgBbkAvvTScYsXLw7JKAI43HD+rS/uuOM3t956q8RkHC0t XblixYb3N0kM5xoEE+oN4MrKHq9X7xXpKxXAS156qbGpUWI4AQzohQAGtCAXwOPG XbZo0aKQjCKAw83+ffvmzZ9fevSIxHCN78BMSkoaOzZXYvI99/z129/+tsRkVJSV rV616u01qyWGG+Yu9Ouuu+6BB/4hMdl4VAA7HA5vd7feK9JXKoCXvvRSAwEMGAsB DGhBLoC/+MUr58+fH5JRBHC4Kdy9e/bcuRV2m8RwjV9CM2rUqLS0VInJ//znI9dc c43EZJPzer2HDx3K37Fj+euvScwvKytvbm6WmHxGci/i+tKXrpo4caLEZOOJuACu r6lZ9sortXW1EsMJYEAvBDCgBQIYA7B3165nZswwxrFXRkZ6VlaWxOTJkx+/4oor JCabnGqV4oMHDxUXv/racon5Gt8DLLcTvvjiS6ZNmyYx2XjURlVVVdXd1aX3ivQV AQwYEgEMaEHu2Ouqq66aO/e5kIwigMPN7vz86c88Y4Dnr1gsSTk5OVFRIl9xZs+Z OzY3V2KyyalWKS0ttR07tmDhCxLzA4GAamC3W6OroOV2whdd9JkZM2ZITDaeiAvg htral199pbqmRmI4AQzohQAGtCB39d2Xv/yVmTNnhmQUARxudm3fPmXatJbWFonh Wh57yd1+qSJq2cuvpCQnSww3OdUqtbW1R0pKZsyeJfThhZY3ossFcHb26FBdhmN4 ERfAjbW1r77+WqXDITFc4/tQAJxAAANaIIAxAPl5eY898US3V+R+OS0DWK49amvr du3aFRMTIzHc5Lxeb1t7++78/HvGj8/KypRYhDE2Qqs1denSpRKTjYcAPhkBDOiF AAa0IBfA1113/TPPPBOSUQRwuNmxdeujj03yBwISw43RHm63Z8eOHRKTEbR106a7 //a3VJkHmBljI0xISFi+XOQ5YcajAri6urqrs1PvFemrxrq611esMMaTCAGcQAAD WpAL4K9//b+mT58eklEEcLjZ/sEHj0x8NCo6WmK4w+FobNSoPVJTrdnZIu3R09Pz 3nsbJCYjKG/z5vv+8Y+4+DiJ4cbYCEeMGLFy5RsSk40n4gK4qb5+xcqVZRXlEsMJ YEAvBDCgBbl7IAlgA9u2ZctDjzwSM1Tk+l5jnHyLjY1dsWKlxGQEHf8UZmJUtMjR gjE2wiFDYlatWiUx2XgI4JNp/DJ2ACcQwIAW5AL429/+zpNPPhmSUQRwuMnbvPmB hx8eMWK4xHBjtEd6esbixYslJiNoZ17e41OndMgUizE2QnUotXbtWpnJRhNxAexs aHjjrbeOHD0iMZwABvRCAANakAvgG2648fHHHw/JKAI43Bjm6lO5WwB4A4004Xdx aXcJKNfhh4NIDOC33n778JFSieEEMKAXAhjQglwA33jjdydPnhySUQRwuMl7//2/ 3XdfkiVJYrgxXoP0xS9+8bHHQrP944z27d49a/Zsu6NSYrgxXoPU0dG5efNmicnG E5EBvGrV4dLDEsMJYEAvBDCgBbkAuPnmHzzyyCMhGUUAh5utmzbdc+/4FKtVYriW AZycnJyTM0Zi8je+8c3x48dLTEbQwcLCBQsXFpcUSwy32ewul0ti8unkArilpSUv b5vEZOOJuNcguRobV69Zc1Bm+yeAAb0QwIAWCGAMQO8baMaPT02N+AC2WCy5uTkS k2+99Ud33HGHxGQEHSouXrZsWf6unRLDKypsmu1z5ALY42nevn27xGTjIYBPRgAD eiGAAS2kpCSPGSNyBuyHP7z1wQcfDMkoAjjcGCaA5e4B/t3vfveDH/wfickIOnbk yBtvvPHuhvckhmt5DzABHA4iLoDdTU3vrF1bdGC/xHC73e50anQFBICTEcCAFuQC +Cc/+el9990XklEEcLgxTABfeuklgwcPlph8//0PXH/99RKToXi93pLi4m15eW+8 9abEfJ/Pt3//AYnJpyOAw0HEBbDH6Vy3fv3ewn0SwwlgQC8EMKAFuQC+7bZf/PWv fw3JKAI43BgjgOU2fuWJJ6dcftllQsOhcqX44MHSkpKXl78qtAjNGoAADgdqi3I4 HN7ubr1XpK9UAL+3YUPBnt0SwwlgQC8EMKAFuYcA/epX//fuu+8OySgCONwYI4Dl wiMQCLy4ZGl6WprEcAw6nis1NTWlxcWz5s6JihI5YDDAdkgA913EBXCz273hvfd2 7i6QGK7lQ+AAnIwABrQgF8C33377n/7055CMIoDDjTECWO79q+rYcevWvJiYGInh GHT8Eui29vbdO3f+/f77UlNTJRah2fuoCeBw0BvAlZVqu9J7RfqqxeN5//1N23bs kBhOAAN6IYABLXAGGAMg/BokjZ4/JBce6kvY2rVrZSbjY3mbNz/w8MMjRgyXGK7h GWCpJ7HxGqS+UwGs9jw9ERXAmzdvztsu8utLAAN6IYABLSQnW3JyRF4Dc+edv/39 738fklEEcLjZ+v77995/f2JSosRwA1x6mpycsmzZMonJOFl+Xt7EyZN7fD0Sww2w HXZ2dr3//vsSk41HBbDdbvf1iGxLEtpbWz/44IP3t2yWGG6z2VwuvuYCOiCAAS3I vQf1D3/4429+85uQjCKAw03e5s33P/RgbGysxHANH4Il9RLsCy64cNasWRKTcbKC HTumP/200y1yqkqzV6HKBbDf71+//l2JycbTG8A2m8/n03tF+koF8LZt2zZs2igx XMv3YAM4GQEMaEEugO+++y+/+tWvQjKKAA4327ZseeiRR2KGitzjqtm9l3LX/199 9dUTJjwqMRknK9yzZ87cueW2Conhml0FKncv+pAhMatWrZKYbDwqgG02mz9yArij rS0/P3/du+slhhPAgF4IYEALcgF83333/eQnPw3JKAI43GzfunXCxEcH8fTdT3HT Tf/9xz/+UWIyTlZy4MDiF18UehWqAbbDuLi4119fITHZeFQAV1RUBPx+vVekr7o6 OnYXFLy9ZrXEcAIY0AsBDGjBYknKzc2VmPzQQw/fcsstIRlFAIebHXl5kyL/3stL L71k8ODBEpPvvPO3odr4cRbHjhxZuXLFextFrgL1+Xz79x+QmHwK7kUPB70BXF4e CAT0XpG+6u7s3Ld378q33pQYXlFR4XZ7JCYDODsCGNBCUlLS2LG5EpMnTXrse9/7 XkhGEcDhZue2bY9PmdLR2SExXJsAlnv0rvLww//88pe/LDQcQV6v91BJSf6OHa+t eF1oEdo8kFwugDMyMhYtWiwx2XhUAJeXlem9Fv3g7e7eX1i4XGbjLy+v8HgIYEAH BDCghdycHEuyRWLy1KlPffOb3wzJKAI43BTs2PHU9OnuZpEjJG2qQ+7GS2X2nLlj ZS6swAmqWEpLS23Hji1Y+ILQIrS5HV3us5jc3LFz5syRmGw8Lre7orxc77XoB5/X W1JcvPRlkTP8BDCgFwIY0IJqAFUCEpNnzZp9zTXXhGQUARxu9hYUPDtzRnVNjcRw bZ6+K3farb6+YeOmTZakJInhOEEFcG1d3dGSkoceeSQjI11iEdpcjCD3NPJx48ZN mTJVYrLxqH2OzWbTey36IeDzHT1y5PlFCyWGl5WVNzc3S0wGcHYEMKCFrKwsoWPH JUuWXnzxxSEZRQCHm/379s1fsODwkVKJ4Xa73ekUf/qu3Gm3QGDQqlWrYmJEHpGN E7xeb1t7+96CgkcnThw2fJjEIrS5GCElJXnMGJGnkV933fUPPPCAxGSDUduSCuDq 6mq9V6Q//P6K8vK58+dJzCaAAb0QwIAWMntlSEx+8823QnVURwCHm5IDB5a+9FLB nt0Sw202m8sl/sstd9otKyvrhRcWSkzG6XZu2/bkU1NVCUsM1+ZihORkS06OyKP4 f/CD//O73/1OYrLBuD2eurq69rY2vVekH6IHDXLY7c/OFnnfuGbvAANwCgIY0ILc g3DXrVufnh6ac8sEcLg5Wlq6YsWKje9vkhiuzXWnci8Au+KKKyZPflxiMk63r6Bg 5pzZlQ6HxHBtXgYjdzX+r399x49+9COJyQbTezl9bW2HzMcoQgZHRdXW1Ex/5mmJ 4Zo9Ah3AKQhgQAvjxl0aHR0tMXnLlg8SEhJCMooADiter7f44MG8rVvfWvW2xHxt jr2yMjMzZK594CXAWio5cODFJUv27NsrMVyb82Byn0KOH3/vN77xDYnJBqMCuLqm pqtD5LH2QmIGD25saHhi6hSJ4X6/v6hov8RkAGdHAANauOyycVFRIr/ddu/eE8K0 rq+vj6A3NBqbOlg8eODA4eLiV19/TWgR0vdeyl3/rPzpT38O1QvAcHZer/dAUdHm zZvXrl8ntAjpq6BFX8f12OTJX7zii0LDjUTt06qqqrq7uvRekX4YHBXlcjofn/Kk xHD11bawsEhiMoCzI4ABcampqdnZoyQmqy+f+/YVhnZmV1dXc3Oz3+8P7Vj0V/Bs yaEDB+bOe07o0xPpq6DlLjpVpj417dJLLhEajpOpTbGkuPjI4cMvybwMZlAkb4pq J7xw0eKszEyJ4QajNiSHw+Ht7tZ7Rfqhp6envqbm3zNnCO2EHY6qxsZGickAzoIA BsTJnQdTmSr0+bHX6/V4PD6fT2I4+iL49N3d+fn33n9fWlqaxCIitzrUlvnKq8tT kpMlhuMUwVs3S4uLn501U+gq4sjdFJ1OZ17eNp5G3hdqQ6qsrOzxevVekf6xlZXN mjtH6CYmbZ4AB+AUBDAgTu7qu/r6hqqqKonJJ7hcru6I+sDeYPI2b37g4YdHjBgu MVz+EmipF890d3vXrVtHdWgj+FnMnl27/jlhQlxcrMQipF/KJXkJdNTatWtlJhuN CmC7zRZxn6uqAP7no49mZYmc5NfmHWAATkEAA+LkTj40NDQ4HLIBHNTR0cHrCnWR n5f32BNPdHtFPoOQfvhQaqo1O1tky09Pz1i8eLHEZHyanXl5j0+d0tHZKTHc4XA0 NgqeAU5OTs7JEfksxmpNXbp0qcRk41EBXFFeHnGPmbCXlz/0yD9HjhwpMVybp/ED OAUBDIiTuwTa6XTZbDaJyWfk9/vVl2puD9bS3l27np01s7qmRmK46NV3VmvKqFGj hK4b/NKXrpo4caLEZHyawt27Z8+dW2EX2eGovUpVVZXcqbDRo0erDVJi8rhx46ZM mSox2XhcbrcKYL3Xot9UAP/z0UczZZ5mzyXQgC4IYECc3Blgl8tdUVEhMfnsmpub OyLqVRaRq3j//heXLNlbuE9ovtwFeKJPwLrttl/cdtttQsNxRkcOHXp1+fIP8rYK zZc7FSb6COjvf/+mu+66S2i4wThdLpseX7DOkwrgCRMnpmekSwznDDCgCwIYECdX Ai0trUePHpWY3Bfd3d0ej4cTwnJ6Xz+zf/+Wze+/s07q9TNyl56KBvCTT0657LLL hIbjdGpTPFJaumf37iUvSV3uK1cCcpfiK3/+8/9+97vfFRpuJGoTcjqd1dXVeq9I v6kAnjh5stqKJIYTwIAuCGBAnFEDOCgQCKgM7oqoVztGiuBDUw/s27fwxcVib0KS OgMsd+U/j4DWngYPgpa7FlTuDLDa+82cNfuiCy+UGG4wwU2oo71d7xXpNwIYMB4C GBAnF8AeT3NZWZnE5AHo6OhobW3lhHAIffj03fz8+x58MCVFpPfkzgCLvv561arV PAJaS8FNcW9BwcRJE4cOGyaxCLkXosqdAVZ74C1btrAp9oUK4Jqams4IvHfGXlb2 6OTJaWmpEsMJYEAXBDAgzjAPweoLFcAtLS2dMo+KNacdeXkTH3vM5xd5d4iKSdXA IT8JbLEkjR49WuhUYU5O7ty5cyUm4+wKduyYOn26p9kjMdzn81VWVrrdIR5utaao +hW6gCIpyfLKK69ITDYeFcBVVVXdEXitEA/BAoyHAAbEyV2A19jYpA4ZJSafP9XA qoQ5IXz+9hUUzJg10yF275zEKQjRG4C//vX/+vvf/y40HGdxYN++BS+8UHL4kND8 iNsUL7/88ieeeFJouMEEb+jo8Xr1XpF+s5WVPTJxolAA8x5gQBcEMCBOLoB9Pl9R 0X6JyaESCASam5s5ITxgXq937+7d69atzdu+XWgRdrvd6Qzx24BFq+POO397yy23 CA3Hp1GbYlFh4YYNGzZu2ii0CIkATklJHjNG5A3Ayv/8z//84he/FBpuMCqAbTab 3ydyJYsoFcAz58wWup6FAAZ0QQAD4kQfwbJ79x6hL8yhpRq4tbXVF4FHP/pSR40l JSVHDx9euuwloUXYbPa2trbu7u4QzpS77F9t8/9+dsbnPvtZieE4i+AZvKI9exYv XSJ0RXHILwcdOnRocnJyVlZmCGee7Klp0y+5+GKh4Qajtp/y8nL1G1jvFemfnp6e 2qqqGbNnRdxjCAGcBQEMaOGyy8YJffl8++1Vcm/4CDlVLy0tLbxDuO96H51aV3e0 pGTi5MnJyRahpYT8zJvok8/ff/99HjukvQ8fybZz5wMPPmiR2RQjaDscdPwJWO+s XWtJShKabzAul0uXt9afp4DPV308gEWGBwKFhUUSkwGcHQEMaCEjI0PoLMS//vX0 1772NYnJorq6ulQJc0L4nILVcWDfvn8983Sb2BtEqqqqGxoaQjUtJSUlO3tUdHR0 qAaeLDMzc+HCRRKT0Rc7t217YuqUdpnPsPx+v8NRFcKTwGlpaaNGjQzVtNOHP//8 C3wW0xeR+xJgf0/PoZKSF2Vef22z2V2uEN9+AqAvCGBAC2NGZ6dYRd4i+Kc//fn2 22+XmKwNlcHtEfhmSI0V79+/aPHiwv1S5wpUeFRVVYXqSjzR027XXXf9Aw88IDQc 57R/3775CxYcPlIqND+EJ4Gt1pRRo6Q+iFG++93v/fnPfxYabjCR+xLgjra27du3 v7vhPYnh5eXlHk+zxGQAZ0cAA1qwWCy5uTkSk2+88buTJ0+WmKyZhoYGHhZ9Fl6v t7S0dG9BwRKx24AHhfRWNNEA/tOf/vy9731PaDjOTm2KB4qKNm/evHb9OqFFhDaA hR6+EPTEE09efvnlcvONRAVwdXV1VwQ+DdHZ0LBq9WqhJ59XVNjcbrfEZABnRwAD WkhOTs7JEXkSaUZG5tq1ayUma6a+vj4QaU9G0VLwNuAjxcUTJ09OSUkWWordbm9t be3uDsFLSlJTU7OzR53/nNOp7WTB8y9kjxIZjnPqfZVrdXXJ/v3zFswXeqiBw1HV 2Nh4/nOGDo1JO+78R52Ry+Vet349NwD3kdpyHJWV3gh8B1J1ZeXcefO6vaF8RuAJ XAIN6IUABrQg91Bcv98/Z87ca665RmK4Nurq6vRehbAWvA24uKhoxsyZTrfg0VJI Tr6JXnfa7e1Zt3Ytd13qJbgp7t21658TJsTGxUosIlRX44tehqCMHpMza+ZMNsU+ UgFst9ki76EPfv+e3btfeW250A4t5I89B9BHBDCgBdGjMZfLPW3atB/+8IdC86UR wOekwmPf3r3vrl+3ZetWuaWoo7GO485niOimnps7ds6cOULD0UcFO3Y89a9/uT1S l26e/wcxI0aMSE1NtVpTQrVKp/vVr371s5/9XG6+wagArigvj6wrfbxdXZu3bFn2 8svp6VLXEUi8+BpAXxDAgBakT0eoA4vLLrt85syZ8fHxcksRQgCfU+8ddDU1h/bv n/3cXNHXPtfU1NTV1Z/PBNEbL2+44ca7775baDj6qLioaOHixUUH9gvNP//b0TMy 0rOyskK1Pqfz+XyLX1ySlSn1emGD8Xq9Lre7yuHQe0X6qru722G3r1i5srGpUehS /yACGNALAQxoQTqAg1pb2/7whz+oQhD9mh1yBPA5BS893b9379Rp04TuRgtSR/bV 1TXnc0wmdwOw8tBDD3/lK18RGo6+UJvioZKS/B07XlvxutAizvM2YLWzHTkyS/Rz oqQky5IlS7j+uY/cHo/aybe3tem9IufW09PjcbnWrFmzNS8vRfIKgiACGNBLJB0l AxFN+qTECYHAoN8eJ/f+j9AigPtChcfugoJ31qzJ37VTdEHn807glJTkUaNGCbVH fX3Dho0bky0WieHoo+D7bI6UlDw8YYLap0kswufzVVVVOZ0DvN1d9N2/QT/+8U8i +uVzGlPbTE1NTafMu6NDJZi+77777rYdO+Jk7m8/hc1mc7l4BDSgDwIY0Ijcm5DO SPXST3/6s7/85S9xcXGaLXRgCOC+CL5HpHj//rnznhM9uzXoPM5LiF7pwGm3cKDN xQjhuQUGqT5fuGjxqJGyjW0kvY+Adji83YKXrpyP7u7uhtratevX79m7JzExUbPl 8g4kQEcEMKAR6ZdSnlFTk/OGG77zhz/8MZzfV0kA90UwPA7u2zf9mafVd0SXZbPZ OzraOzu7+vsvim7k11//tfvvv19oOPpl/759859//nDpYaH5A7sNePjwYRZLcmZm hsQqnZCamvrCCwv5IKbvwvYR0NGDBhXs2rVh06bikhLpzeZ0IXz1OoD+IoABjWhz G/AZBQKBxMTEH/7w1t/85jexsVpc3NUvBHAfqQbeX1i4adOmdze8J70sh8PR1tbe 3ydCp6Zas7OlNvL77rv/a1/7mtBw9J3aDkuKi7flbX3jrbeEFqE2v8bG/p0BHjFi RFxcrNzmd8Lvf/+Hm2++WXopRuJyuyvKy/Vei491d3c3NTRs3Lix6MD+qON0WQ1u AAZ0RAADGomPj4uPT9D+Y+aTNTQ0XnfddT/60Y9+8IMfhM+DsgjgPjpx++UTU55M kL9Ur783A1utKSo/hLarmpraDRs3plqtEsPRL723dNbWlh48+PCECVlZIk9CDgQC qoH7dX5Mg1t/B/U+aLD17VWruRG973ofAe1yVVVV6b0ivXf5drS15eXlFezeffTY MaFNt49sNrvX293aGgEPBgMMKVyOgAEzSElJGTNG66ugz0h93b3++utuvfVH3/nO d3QvYQK4j9ShZEtra+GePa+9/vqxsmMaLLG6uqa+vq9vRRK9xiEuLv7ll1/mutNw ELwav2jPniemTvX7pa5r7df5sfT09JEjtXjE4FVXXf3QQw+xHfZd8GO7DuG7Ns5C dW9XR8fOnTt3Few6dqxMg2c794XdXul0cv0zoBsCGNCOjldBf5r29o6vfvVafUuY AO47dTRZWVmp2mPhi4ulH4UV1PcGFv185ytfuVaFh9BwDEDR3r3PzZ9/9NhRofl9 LwTN6tfn882aPeczF12kwbIMQ+2yqqqqurv6/UCB83Ry95aVlSenJGu8AmfH9c+A vghgQFNjx+YmJSXpvRZnoEr4y1/+8ve///2bb755yJAhmi03EAj0/RwjgieBd23f vnDxYpd7gO+J6a/q6uqWltZz3g+cm5NjSZa6NPQvf7nnO9/5jtBw9JfaDg8eOPDB li2r31kjtIi+BPCIESMSEuJHavVA5tFjcmbNnMnp337pfQKW3e7r6dFmcb2XJ7S2 7ti+fV9hYUVFRbh1bxCPvwJ0RwADmgrDk8CncDpdV111lYqNH//4xxq8E8Ln8zU2 NkovxUjUAWVZWVlBfv7rK1dodtK+qqqqubml69NP44hu2DU1Ne9t2JiWmio0H/0V fLNraXHxwxMekXu9+dnPkg0bNiwxMWHUqFFCSz9FIBCYOHGS2jdqszjD6H0CVkVF 7+vpJQWfa7UtL+9ASbHNZhd6Q3WocPoX0B0BDGhq+PBhKhXS0tL0XpFzU2mamZn1 X//1Xz/72c9ycqTeYNzT08OhQL8ETwLv2Lp17rx5Xd3aXVhot1eq3v60XyzRAE5M TFq6dCln3sLHibcBT3nqKW+PV2gpZ+kEtb0lxMfLXXFwOktyyouLF7MR9ov0E7A6 2tsrbbZt27eXHjnS4+vR5q6Q82S329vbB/KSOQAhRAADWgv/k8CnCAQCw4cPv/ba a3/4w1uvueaa0A5XR0g8C6S/3B7PsaNHd2zb9taqt7W8c9vv99fV1bW1tZ3+8NK0 tFS5c3Hf+MY3x48fLzQcA3awsHDBwoXFJcVC81U4NTScenlIfHyckpGRER0dLbTc 06l94IMPPvTVr35VsyUag8QTsHp6enxeb2FhYf7O/LKy8mHDh+n+HMd+4fQvEA4i aa8BGMPQoTEjs0Zqee4ihH7xi1/ec889IRzY3d3tcml0L6thBE8C5+flzX/++bZ2 rV+k4XA41Lcnv6Y1JSU5OztbLkieeOLJyy+/XGg4BkZthKWlpXsLCpYse0loEX6/ X21sTufH+4fU1N73YGnwst9TpKdnLFiwgNO//dX7BCyHQ+3kQzjT2dDw3saNe/ft DeFMzdjtla2tLd3dUhdNAOgjAhjQgdVqzc4eFVmfWwd961vfnjJlSggHdnV1ud3u EA40CXVkWV5eXpCfv/z117Q8FRYUCASqq2tUnwRPZagskWsSj6f5nbVrLWH56Dgz 6z25V1d3tKRk0uTJch/nqQAOftSi9plqOx85Mkv73abazh+b/PiXrrxS4+UagNpI bDab3xfKd2U11de/8dZbco8fl3P87dZVnP4FwkHkHX8DxpCenqbZw0tDKOQB3NnZ 6fF4QjjQJIIngXfn5y9esqShsUGXdVBhUFtb19PTM2TIYLmNmUfvhqfgbcDFRUUz Zs50ij2QvLq6uqfHN2TIkMxMTa95PtkFF170zNNPswUOQO8TsMrLQzszcgNYbcz1 9frsqwGcggAG9DF06NCEhITIuhl4kEAAd3R0NDc3h3CgeQRfsFmyf/+TT021Wq16 rYbKYPWtXJz8+Mc/uf3224WG43yoBt5TULBmzZr8XTuFFiG9dZ2T0+lc+caboyLw w0rdqc2jyemsqa4O7dgIDeDKSkdLS0torwYHMGAEMKCb4cOHWSzJmZkZeq9IP9xw w42PP/54CAe2t7erw4IQDjSP4EngkoMH165du6tgl96rIyIQCMyaPefCCy7Qe0Vw Bm6Pp9LhOLhv3wuLF0XiDR19cdNN/33nnXdy+ncA1OZRXV3d1dkZ2rHOhoa33n77 8JHS0I4VZbPZOzp48jMQRoz5FQuIFKmp1lGjIulm4JAH8PFHCreGcKCpBO/DLD14 cPbcObLv2dSJ+q3x1ltvkx/hKXgV9L6CgomPTYoZOlTv1Qk9teG9uGQp958PTO/n I3Z7T09PaMdGXAAHAoGqqqqTnxoIQHcRc9gNGFVGRnpmZmakNHDIA1jVr2rgEA40 FVUgnuZmh8NRtGfPtKefzsrK1HuNQuzqq6+eMOFRvdcCZ1O4Z8+cuXPLbRV6r0iI 1dbWLVmy5HOf+xyfvwyMxA3AgyItgFX91qotqa5e7xUB8AmRccwNGFsENfB///fN EyZMCOHAlpaW9pC+JdJsghdCHywqWrNmzd7CfXqvTojdf/8D119/vd5rgU+lNr+S 4uLt27atfPMNvdclxL7znRvuuusu6ndggi94rw71DcCKq7Fx1Zo1cm+fDiHqFwhb EXDADZiBauCMDN0ec9p3N9/8g0ceeSSEA5ubmzs6OkI40ISCF0IfKS6eO29ejy/E FxzqyOlyr1u3LtkSkW/MNoneba+2Vm17j06ebLWm6L06ITN8+IiFixZx8fOACd0A POh4AK9es+Zg2Aew3++v60X9AuGIAAbChdVqjR0xwpqq2+N8+yLkAezxeDoFDpJM JXghdE1tbdGe3f+eMTNZ7KWsGuMFSOFPm5chaczjaV6ydOmY0aPZ9gZM6AbgQRES wHa7PSoqmlf+AmGLAAbCyPDhw+LjE7KzR+m9Ip8q5AHscrl4M8T5CzbwsWPH8jZv Xvvu+vC/lKAvbrvtF7fddpvea4FzUNve3j171q1bl7ctT+91CQG/3/+/d//l29/6 FvV7PoRuAB4UCQHscFS1trbwzGcgnBHAQHiJj4+LjY3LygrTW4J/8pOf3nfffSEc 6HQ61QF0CAeaVvBm4AOFhW+88UbxoRK9V+d8qQ55/oWF2aPC98MgBPW+j7q6urio aN6C+Qb45OWr11137/h7qd/zIfQG4CCP07lu/frwfN5BIBCoqaltb29rbeXJjkBY C8cjbACpqdZAYNDo0dl6r8ipQh7ATU1NEpfJmVPwZuDy0tKly5Y1NjXqvTrnJTY2 9pVXXqVDwl/wKuiiPXuemDrF7/frvTrnZdSo7GnTp3Pr73nq/Uykqqq7S+QUaNgG cGWlIypqEK87AiICAQyEqREjRiQmJqSnpw8ePFjvdflYyAO4sbHR5/OFcKCZBS+E bmhsLD14cP7zz3t7IvjU+je/+a2//e1veq8F+kRteDu2bVuxcmVJJF96MCI2bu7c uckWCx+7nCcVwHabTWjHHoYBrH6m9fX1zc0tPNARiBQEMBDWrFbr4MHRWVlZYXJF 9M9+9vN77703hAMbGhoi/axRWAk2sDoaO1BYOOe5uUOHDtV7jQYiEAg88eSUL1x+ ud4rgj5RwVNRUbFn585XXlseJnuq/lIN88LCRRnp6dTveVK7IJfbXeVwCM1XAbz+ 3Xf37NsrNL9fjl/zXOPz+XneFRBZIvILFWA2qalWdVg5Kgzuh/zVr/7v3XffHcKB KtXUMUQIByLYwLW1tfv37p07f97w4cP1XqN+8wcCq1etJkUiRfAq6L27dj362KRh w4bpvTr9ptZ/3vwFo7Oz2eTOX/DNWB1ib3dvdrs3vPfezt0FQvP7rqqqSn3x4ppn IBIRwEDEsFp7M1jfZ0SHPIDr6upCOA1BH74YqaZGNfCcefNiY0fovUb9c/XVV0+Y 8Kjea4H+KdqzZ/bcueW2Cr1XpH86O7vmL1iQM2YM9RsSvS9AqqzsEXu0YTgEsMPR m76c9QUiFwEMRJjjZ4OjR47U56JoAjhSnNzAzy2YH1nngVX9qgbWey3QD2p7O3zo 0M78/FdfW673uvRDt9f73HPzqN8QcrndtooKuet6dAxg9ZOqrq4JBPyc9QUiHQEM RCSr1aq+HMfEDM3MzNByub/+9R133XVXCAcSwHI+vBa6ru5gYeELixbqvTp91dra umr1Gp7EG1mCTyA/WlLy+JNPJCQm6r06fTJ4yJCZM2eNGjmS+g0V0RcgBbV4PJs2 bty+M19uEaez2ezR0eqAOYqzvoAxEMBABBs+fFhcXHxU1KDsbI1emPTb3/5OCeFA AljUh8+Fbmg4fPDgi0uXtIndmBdCn/v855+a+hRNElmCtwGrzWzuc89V19bovTrn ZrFY/vX0M6lWK1taCIm+AClIBfDmzZvztm+TW8TJHA5HIDCora21s1PwJwVAYwQw YASpqVa/PzB0qPgJYQI44gQbuLGxsdpuf2nZssoqR5g/p/fuu/9yww036L0W6De1 pR3Yv/+DLVvWrH1H73U5m0AgcOGFF0149FFLUhL1G1rB54EHJB/sr00A22x2tZ+M jo7iamfAkML6MAhAvwwdGpOYmKi+bI8cOVIocgjgSBQ8OxcXG+uorHx+wfy3V6/R +Mr5vmtqalr/7nvJFoveK4J+Cz7+90hJyYRJE1NTU/VenTOrq6u/997xN373e+q3 A/UbWmo/43S5qquqRJciGsDH7/KtVt82Nzd3d0fwe9QBnB0BDBhQWlqq0DuTCOCI phKlrKxsd37+i0uXxsbF6r06ZzB6TM6smTMpk0gU/JyluKhoxsyZTrdL79U5g46O zmf+/e/LL7tM7xUxJrV7UfXY1dkpuhTRAK6qqmpoaJSYDCCsEMCAASUnJ+fkjJGY TABHtODl0PUNDeWlpYuXLHF73OF2OfSdd/72lltu0XstMEBqAysqLNywYcPGTRv1 XpdPCAQCo0ZlT5w0KT0tjY9XhKgAtlVU+CWvfx4kHMA2m93lCsfPbgCEVngd+gAI CQIYnyZ4mk4dpJYUF7+3fv3qd95JSUnWe6U+1NDQuG79+tTeJ5wjIqkEqqmtLT14 cIJKzfQ0vVfnQ06n669//et3briBy57laHP98yACGEAoEMCAARHAOLsP35BUW3vk 0P9n7z4AJK3KfP93zqFC51A9wwwzhEFQFxTDrrJ/wuoaEBcQVxEDe1nD4t27ot57 XS8qO+IKCIIkQUCERWAlzBBmGEkDk5jADGFSh8o5d+XwP9U1Ns3EDu+pt8L3AxTV PT3Pe7q6u+r99Tnvc96+/w9/CIVDxTAVPDg4dOuttxJRStf0Kugbb7rJHwyoPZzc xG93T+9PfvKTocFBvq+kKkD/5zwCMICFU/+MB4DiCMA4pump4L179z6/bt0zzz7T 0NCg7pC+9rWv/8M//IO6Y8ACie+rHdu3r1275vkXXlB9JP/6r//rQx/+MBO/BVCA /s95BGAAC0cABsoQARizNL1JktNme+SRR8RppVr9ex0O57Nr1nQXa/dgzFJuFbTN tufNN3989dW9KjUbF9/Pn/rUp//5m99ko6PCyK1/9nqtVmsBjkUABrBwBGCgDBGA MXvTU8F2u904NvbIo49seW1rb29PgYfRPzB4+223EVdKXf7b6Y0dO351003BULDA R3c4nH/7t2d993/+a6vAxG+h+AMBs9mcTCQKcCwCMICFIwADZYgAjLmajsFWm218 796HH31k+47XC7ld8GWXffWiiy4q2OEgj/he2r5t29o1a1546cWCHdRud3zkox/5 3veu6ujoIPoWkvhy5y4ANpuz2WwBDkcABrBwBGCgDBGAMT/TMdhmt5vGxv70pz9t 3b69AG2iRXpZs3Yt65/LQ34V9O433vj3q6/u7++TfTiv1/fxj3/829/5TltbG9G3 8MSX2+5wRCcnC3M4AjCAhSMAA2VIXgC+7LKvfuc731GwIAG4CE3HYPHVcdhsjz/+ +PYd26W2yOrr67/jjjuILuVhehX0DTfeGAqH5B0okUj87d/+f1//xjcaGxuJvmoR AdhkMqWSycIcLuj3r1u3buPmTTKKE4CBCkEABsqQTqc1GKQE4Esv/cqVV16pYEEC cNGajsFOlysZi23ZvPmpp5/es3evjHXRX/7ypZdcconiZaGW3CrorVufffbZl9a/ rHhxu91x2mmn/f2nP33Wxz9eU1ND9FWR+EL7/H6L2VywI4oA/NzatZte2yKjuNFo 9HoJwED5IwADZUin0xkMwzIqX3zxF6666ioFCxKAi1w+BouMIW6tVqvL4VizZs2W LZsz2azIHoocwmazP7tmTW9PodtuQR5/IGC12Xbv2vXjn/xEqVXQmUymob7hQx/5 yGWXXdal1+e/LYm+6sp9oa3WeCxWsCMGvN5nnn12247tMoobjSav1yujMoCiQgAG ypC8GeCLLrr4+9//voIFCcClYmYSNplMo3v3Pv/88zt27qyvr6uuXtBLSU9v7913 3V1bW6vUUKG6A6ugt2+//sZfhRd2dWg2m02nM6effvpXLrvsuMWLyb1Fxef3Gycm MvK3/50mOQAzAwxUBAIwUIbkzQCff/7nfvSjHylVTZzaOp1OpaqhMA5KwhOjoy+/ /PKO119PpVPzC7H/+I9f+sd//EfFxwl1ie+Tba+99swzT69/9dV5/PV0Ot3Y2PRX p5/+hS98gdxbnMSX2OP12gqy/e80n9u9+qmndr35hozizAADFYIADJQheQH4M5/5 7I9//GOlqmUyGZfLpVQ1FNi7VkfbbF63+7XNm7a8tnV0bKytrXWW08Ii5/zunnsH BwZkjxYFll8c++bOnbfdcfssfzOSzWaj0diSJUtOP+P088//HOuci1xu+1+TKVmo 9ld5IgCvWr36jbfelFGcAAxUCAIwUIbkBeDzzvu7//iP/1Cqmgg/brdbqWpQy3QS FkFFnBNPTEyM7d+/Y/v2N99+W5wft7W3HSUM6/X63/3uHhJO+RHfFaFweMPLL9/x 2zujR75GNBd6I9Gh4eETTzrps5/97CkrVsz8dirkgDEnhW9/led1uR5/4onde/fI KE4ABioEARgoQ/IC8Lnnnrdy5UqlqolTKM42ysxBYdhkMtksltd3bH/zrbeMJpPb 7ZnZRLqrq/vCiy769Kc+peKAIY/4Bti1a9f6l17auXOn2/POr7rsdsdAf9/g0NCJ J5706c98ZumSJYTeklP49ld5IgA/9vjje/btlVGcAAxUCAIwUIbkBeCPf/ys6667 Tqlq8Xjc7/crVQ3F5qAwbLfbU4nE6P7927Zt27N3TzAUuvt393R2dJB5ypX4BggE g26PZ3T37pt/c8vQ0LDwnlNP/ehf/7VWoyH0li7xtRM/0RazOZvNFvjQHqfz0f/+ 79HxMRnFCcBAhSAAA2VIr9eJE00ZlT/2sY9df/0NSlWLxWKBQECpaihmB6Udwk+F 4OtelvK/z4pGIoU/tAjAjzz66NjEuIziJpPJ4yEAA+WPAAyUIXkB+EMf+vDNN9+s VLVIJBIKhZSqBgAoABGAjRMT6XS68Id22+0PPfKwSc61xwRgoEIQgIEyJC8An376 6bfffodS1SYnJ8PhsFLVAACyqbL70TSXzfbgQw9Z7TYZxQnAQIUgAANlSK/XDw8P yai8YsUp9913n1LVQqFQRI1FdACA+ck1tzMaU6mUKkd3WK333X+/x+uRUdxkMns8 UioDKCoEYKAMyQvAS5ce/8c//lGpaoFAIFbwJqIAgPnJte73+awWi1oDsJvNd997 bzAUlFGcAAxUCAIwUIbkBWCDwfDYY48rVc3n8yUSCaWqAQCk8gcCZpNJxGC1BmAz me68+65INCqjOAEYqBAEYKAMyQvAPT29zzzzjFLVvF6viidSAIDZE0/XPp/Pot70 r2A1mX5z222ptJQF2ARgoEIQgIEy1NWlHxqSEoA7OjpeeOFFpaq5XK5MJqNUNQCA PLnpX7M5qeqyHYvReNPNN1fXSDl9FZ+d200ABsofARgoQ/JmgBsbmzZs2KBUNafT mc1mlaoGAJAkN/3r91vk7D80e+aJiet/9auGxgYZxZkBBioEARgoQ/JmgKurq7du 3aZUNYfDoVQpAIA8xTD9K5jGx//z+utaWlpkFGcGGKgQBGCgDMmbAY7HE2+++aZS 1QjAAFD8iuHq3zzT2Ng1116r0XRKKc4MMFAZCMBAGZIXgAOB4OjoqFLVCMAAUPxU b/48zTg6evU113R3d8koTgAGKgQBGChDer1ueHhYRmWn06XgJAABGACKnOp7/840 MTr671df3d/fJ6O4yWTyeLwyKgMoKgRgoAzJC8DZbHbr1m01NTWKVCMAA0CR8wcC JqMxlZKy89CciDHYLZZf/+aW6mopp68EYKBCEICBMtTX1ytIOkVYtWr1wMCAIqUI wABQzJLJpMfrtVmtag8kJ5tOi5HcdMvNUopns+IlyW7nVQkofwRgoDz15fTKqHzr rbd94AMfUKQUARgAipZIv/5AwGq1ZtJptceSIwLw/n37fvu7u2UUn5gw+nw+GZUB FBsCMFCeDMNDOr1eRuWf/eyaT3ziE4qUIgADQNES6ddms8WiUbUHckAykdj1+usP PfKwjOJjY2OBQFBGZQDFhgAMlCeNpnPRokUyKv+v//VvX/ziFxUpRQAGgOKUn/61 mM3ZbFbtsRwQi0Q2b9q0+pmnZRQfHx/3+wMyKgMoNgRgoDxpNJpFi0ZkVP7a177+ rW99S5FSBGAAKE659GuxJOJxtQfyjnAw+NJLL7348ksyio+PT/j9fhmVARQbAjBQ nrRa7ciIQUbliy/+wlVXXaVIKQIwABShotr6aFrA612zdu1r27bKKM41wEDlIAAD 5Umn0xoMUgLwpz716auvvnrhdbLZrNPpXHgdAICCRPoNBINWqzVdBFsfzeRzu59c terNt9+SUdxoNHq9BGCgIhCAgfKk0+kMBilbAX/sYx+7/vobFl6HAAwARcgfCNjt 9mgkovZADuZxOB757/8emxiXUdxoNHm9bAIMVAQCMFCe9Hrd8LCUAPy+973vt7+9 a+F1CMAAUGyKsPfVNKfN9sCDD9qdUq6dMZlMHg8BGKgIBGCgPOn1+uHhIRmVlyxZ +vDDCuxCQQAGgKKSX/xst9uTiYTaYzkMu9l89733BkNSNisymcwej0dGZQDFhgAM lCd5Abinp/eZZ55RpBRNsACgePgDAfG0HJmcVHsgh2c1mX5z222ptJQrkwnAQOUg AAPlSV4AbmpqfvXVVxUpRQAGgCJRzIuf88wTEzfceGN9Q72M4gRgoHIQgIHyJC8A J5OpXbt2KVKKAAwAxaDIFz/nGcfGfv6LX3R0dsgoTgAGKgcBGChP8gKw3+8fGxtX pBQBGACKQa7zs8MRLdbFz3kiAF/9s592d3fLKE4ABioHARgoT/ICcDab3b59hyKl CMAAoLpkMunz+60WS9EufhZSqZTTZrvx5l9XV0s5dyUAA5WDAAyUJ61WOzJikFR8 1arVAwMDC69DAAYAdeUXP9tstlQyqfZYjiabTtus1ptuuVlS/YkJo8/nk1QcQFEh AANl65RTVtTW1sqofMstvznzzDMXXsfpdBbzhAMAlD1/ICDSbywaVXsgxyAC8L69 e++653cyiqfT6Z07leltAaD4EYCBsmUwGHQ6rYzK//7vP/7sZz+78Dput1ucdiy8 DgBgHpLJpNfns1osag/k2JLx+PZt2x597E8yihuNJq/XK6MygCJEAAbKlkbTuWjR IhmVr7jiny+//PKF1/H7/fF4fOF1AABzld/3SKTfTCaj9liOLRIOv7J+/XPP/1lG 8fHxcb8/IKMygCJEAAbKllarGRkZkVH5kku++G//9m8LrxMOhyeLu+koAJSlUrn0 d1rQ51uzdu2Wra/JKD4xMeHz+WVUBlCECMBA2ZLXB+vv/u4T11xzzcLrxGKxQIBf ugNAoZXKpb/TvC7X408+uXvPbhnF6YAFVBQCMFC2dDqdwTAso/IHP/jB3/zm1oXX SafTbrd74XUAALOXTCY9Xq/NalV7IHPgstsf+uNDZjlj5hpgoKIQgIGypdfrhoel BODly0948MEHFSnFTkgAUEglsevvoewWyz333ecPSFmobDKZPB4CMFApCMBA2dLr 9cPDQzIq9/X1P/XUU4qUIgADQMEcaHxltWZKrQO/1WS67Y47EsmEjOImk9nj8cio DKAIEYCBsiUvADc3t7zyyiuKlGInJAAojHz6tdvtpdL4aibzxMQNN91UX18nozgB GKgoBGCgbHV16YeGpATgcHhy7969ipQKBoPR0unCAgAlKt/22eFwJEpz8znj2NjP Vq6UtLm92Wx2uwnAQKUgAANlS94McCaT2bHjdUVKxeNxv5/NJwBAonz6dblcJdT2 +SATo6O33HZrTU2NjOLMAAMVhQAMlC15ATibzb722tba2lpFqnEZMABIlVv57HBE S3bfdfGiM75//2133lFdLeXElQAMVBQCMFC25HWBFucizz67pqenR5FqBGAAkKcU Nz06SDwWGx8dvfvee6QFYLpAAxWEAAyUs1NOWaHUPO1BVq1aPTAwoEgpr9ebLMGO LABQ/MSzq9fns4r0W1KbHh0km06LAH/TLTfLKJ5Op3fu3CWjMoDiRAAGypa8JdDC //7f/+fzn/+8IqVisVggEFCkFABgWm7L36n0W1pb/h4qEYttfe21x558QlJ9lkAD FYUADJQtvV43NDQkacHYhRde9IMf/ECpaqyCBgBl5dKv359Lv5mM2mNZqIDX++ya NVu3b5NRPJvNms1mlkADlYMADJSzxYsXd3Z2yKj8/ve//847f6tUNZfLlSn9UzQA KBL59GuzWsvjqdVpsz3wXw/a5fyq1Gg0eb2kX6CCEICBcqbVakdGDDIq6/Vda9eu VapaOByeLNn2pABQVMos/QoWk+mWW2/NZNIyik9MGH0+n4zKAIoTARgoZzqdzmCQ 0gh6cjKyZ88epapls1mn06lUNQCoWOWXfgXj2Ng1K1dqdVopxZkBBioMARgoZ1K3 AlZwJyRBBOBSb9MCAOoqy/SbiMeN4+N33n0XmwADUAQBGChnUhtB/9//+6PPfe5z SlVjFTQALERZpl8hEg5v3779iVVPSqpPAAYqDQEYKGc6nXZ4eFjSb83PP/9zP/rR jxQsSC9oAJifAzse2Wxl0PP5IH6P56mnn359104ZxbPZrMlk8nq5BhioIARgoMyN GAySrps68cST/vCHPyhY0OPxpFIpBQsCQCUQ6dfr89lKf7/fw3JYLPf+/vdev5SM ygXAQAUiAANlTl4j6Pr6+k2bNitYMB6P+/1+BQsCQHkT0XcyEonHYjabrSzTr2Ce mLj+Vzc0NDbKKE4LaKACEYCBMqfX64aHpTSCTqfTIgA3NTUpWJNV0AAwSyL9BoJB j8cTKd8GCqlUymY233TLzbW1tTLqm0wmj4cZYKCyEICBMie1D9a11/7i7LPPVrAg rbAAYDby6dfldsciEbXHIlE8Gn3jjTf++MjDkurTAQuoQARgoMxJDcD/8A8X/vCH P1S2JpPAAHB0+fTrdDrjsZjaY5Er4PU+8+yz23Zsl1SfAAxUIAIwUOb0et3g4GBN TY2M4suXn/Dggw8qW9Pv98fjcWVrAkDZEOnXHwg4HI5kIqH2WKSzWyz33HefPyCl PUQmk7FYLCyBBioNARgof/ImgbPZqu3bFf7FfDabdTqdytYEgPKQT782my1dGT3z TePj/3nddS2tLVKKM/0LVCQCMFD+dDqtwSClEbQIq88+u6anp0fZsl6vV5zkKVsT AEpdbrNfv99mtWbKbrPfw0rE48bx8TvvvkvSbvZGo5EdgIEKRAAGyp/Uy4C//e3v fPWrX1W2ZjqddrvdytYEgNKV3+4oFovZy3e7o0MFA4GNG15d9/zzkuozAwxUJgIw UP6kBuAzzjjjtttuV7ysOClJVcYCPwA4ugMNn12uWDSq9lgKymW3P/THh8xWq6T6 BGCgMhGAgfKn0+lEAJa0hKy+vn7Tps2Kl2USGACqKqzl1UHMExPX/+qGhsZGGcWz 2awIwF4vHbCAikMABiqCzD5Y2aeeerq/v1/xykwCA6hw+Yt+7XZ7hbS8mikej0+M jt51z+8k/faW6V+gYhGAgYqg0+kMhmFJxS+//PIrrvhnxcsyCQygYlXmRb8z+b3e 9a+sf3n9ekn1jUYT079AZSIAAxVB6mXAJ5xw4gMPPCCjMu2gAVSgir3odyaHxXLv 73/v9cvq0swMMFCxCMBARdDrdcPDsmaAA4HA22/vbmhoULwyewIDqDT5i37tdnuq gn/9l0ql7BbL1T/9qb5LL+kQJpPJ42EGGKhEBGCgUgwODnR3d0sq/oMf/PDCCy+U Udnv98fjcRmVAaCo5Jc9i2c8u81WITv9Hkk4FNq2devqp5+SVJ8dgIFKRgAGKoVO pzUYDJKKv//977/zzt9KKu5wOCRVBoAiwbLnmVw224MPPWS12yTVJwADlYwADFQK qZcBRyLRnTt3ylgFLYRCoUgkIqMyABQDlj3PlEqlbGbzNStXarQaSYfgAmCgkhGA gUohNQALV1753UsvvVRScSaBAZSld7o92+3Zyl72PC0UDG7auHHtuufkHYIADFQy AjBQQUYMBq1OK6n40NDQE088Kal4NBoNBoOSigOAKvITv06nM0GngxlsZvNv775r UtrCHzZAAiocARioIFIvA85kMmvWrO3p6ZFU3+VyVXhXGABlIz/xK3Kv3W5Pp9Nq D6eIxGOxsf377773npqaGkmH4AJgoMIRgIEK0tWlHxqSuAr6M5/57I9//GNJxVOp FCvWAJSB/MSv2+2m39WhXHb76qeffnv32/IOYTab3W5eTYDKRQAGKohOpxsaGpT3 a/V4PLF9+3ZJrbAEr9ebpEMMgJJ1YOI3kXDY7alUSu3hFJ389r8rr722vaNd0iEy mYzZbGEJNFDJCMBAZenu7hocHJRX//LLL7/iin+WV59uWABKVH6jo/zEbzabVXs4 xcjv9a5/Zf3L69fLO4TFYnG53PLqAyh+BGCgssjuBV1XV/fKK6/W19dLqh8Ohycn JyUVBwAZ3pn4dTjY6OhIUqmUw2q9/lc31EtbRlRF/2cABGCg0ogAPDQ0WF0t8Wf/ 29/+zle/+lV59Z1OJ5MnAEoFE7+zFAwENm54dd3zz8s7hHj8zWYLARiocARgoOJ0 dXWJDCyvfk1NzZYtr8nL2OJsksu3ABQ/rvidvfzVv7+84fqmpiZ5RxHp1+1m/TNQ 6QjAQMWRvQpa+PKXL/3ud78rrz7dsAAUOVo9z4nX7X5u3XNbt22TehTWPwOoIgAD FairSz8wMCCvF7QQDAa3bdve0dEh7xB0wwJQnPITv/F43MEev7MjHivT+Pi1//mf +i69vKNkMhmr1coGSAAIwEAl6u7uHhwckHqIk09e8fvf/15e/UgkEgqF5NUHgHnI T/w6nc5EPK72WEqG1WS6/4EHvD6517ZYLFaXyyX1EABKAgEYqERdXfqhIbmroLPZ 7MqVPz/vvPPkHUKcymQyGXn1AWD28hO/sVjMYbfz1DR76WTy1VdffXL1KqndGaty FwCbmf4FUEUABirWiMGg1WmlHiKRSG7atKm1tVVS/XQ6TTsTAKqbbnbldDhoTzAn 4kEzT0xcd8MN7R3tUg9kNJrongggjwAMVCi9Xjc8PCz7KMcfv+yhhx6SVz8QCMRi MXn1AeDoaHY1b/nOz/f94f5gMCj7WCaTyeMhAAPIIQADFaoAGwLnXXjhRT/4wQ/k 1WdbYACqONDsKhazs+Z5XjxO57Nr1ry+a6fsA7H9L4CZCMBA5SpAK6yqqcabv/jF f55zzjmS6icSCZ/PJ6k4ABzqnQ1+HY4Ua57nJZNKvfrqq48/+YTULQnyaH8FYCYC MFC5CtAKKy8YCD63bt2iRYsk1RcBWJyJSioOANPy0VfcikAV5/qL+aqtqdn99tvX /uIXUvc9mkb7KwAzEYCBitbV1TU0NFiAA6XTmXXr1onDSarPtsAAZBO5NxAMuj2e WCTClRfzFotGJ8bGfv2b37S1yWqROJPZbKFdIoCZCMBARdPr9cPDhZgEFurrG557 7rn2dimtPmOxWCAQkFEZAA6seY7HbXZ7Jp1WezglTDyG4/v333rnnY2NDYU5oslk 5upfADMRgIFKV7CF0EJDQ8PTTz+j1UrZfsnr9bIBCQBlHVjznEjYudx3weKx2Oi+ fXfefZd4LSjMEVn8DOBQBGCg0hUyAE+pXr16dX9/v4zSLIQGoJTpy32dTmciHld7 OCUvGons3bPnt3ff3dLSXLCDEoABHIoADKCqu7trcLAQVwLnRSPRxx5/fPny5cpX jkYLsJ8kgLKXv9zX5XKxu68ixOnmls2b77zrLo2ms2AHtVgsLhdX/wI4GAEYQOH2 BJ7mdnuuv/76z3/+84pX9ng8qVRK8bIAKkR+4jcWi9lstio6XSkhGY+/8MILf3jw wd7enoIdlL1/ARwJARhATk9P98CA9D2BZxJnJ+edd97KlT9XvDILoQHMQz76xuNx u82WyWTUHk45SKVSPrf7sSce37d/fyF/xypYrVank71/ARwGARhAjk6nGxwcqK2t LfBxe3p6H3jgAXF0BWtGIpFQKKRgQQDlbbrTlc1mS9PkWSGxWGx8//4/PPhgMlXo 5mHii2ixWL1eb4GPC6AkEIABHNDb2yOpN9XRhcOTK1euvOCCCxSsyUJoALMx3enK 7XbHYzF291VKMh5/5plnnly1SquT0vb/6Gw2m8PhLPxxAZQEAjCAA5qbm1taWgq2 LfBM4qTzxBNPuu66X3Z1ddfX1ytSk4XQAI4kn3vFnUQi4XK5kokE0Vcp4iE1T0w8 /OijXp+3wMue80wmcyQSidK9DMAREIABvKPw3bBm8np93/ve9775zW8qUo2F0AAO NT3l6/F6k/E4S0UUJB7McDC4Zs2atevW6dSY+K2i9xWAWSAAA3iXnp6egQEVFkJP 02q11177i7/6q79aeCmvOMFNFvraMwDFKR99E4mE2+0Wt1naXClKnFC+sn79qtWr 0qo+sFarzelk8TOAoyEAA3iXhob69vYOVRZCT8tkMiefdPKvbryxu7t7gaVYCA1U uOnVzrFYzO1y8UsxxcWi0YnR0ceefNLj9dTU1Kg4EpPJHAoFEwm+xACOhgAM4GB6 vX5wcEDd85iqqS4mF1xwwU9/+jOtdv5L6aLRaDAYVHBUAErFzAZXiXicnY0UF4/F zCbT4088vmPHjv7CbqR3KPH1tVisLH4GcEwEYACHoVZH6EM5HM7zzz//Bz/4wdDQ PCelWQgNVJTpKd94PJ5vcKX2iMpQNBod37//mWef3bFzZ19fr9rDyaHzM4BZIgAD OLyenu4BtX+jPy2dTp94wolXff/7S5cubW5unmunaBZCA5Vg5pSvyL3s6CtDTXX1 5k2bnn722UDAX/it44/EarU6nS61RwGgNBCAARxeY2NjW1ubuhcDHySbzYro+z/+ x//46le/NqdW1bFYLBAIyBsYABUx5VsAqVRqMhx+/s9/3rRlczqdVmuzgMMymczh cFh89dUeCIDSUETPXwCKjcjAWq22SJa3zRQKhf/+7z/5rW99e+nSpbP8Kz6fL8Fp MVBe3nWVbyKRYcpXgkgksn/v3udfeOGtt97q1HSqPZyDTUwYxQhJvwBmjwAM4GiK pCHWYWWz2daW1n8UvvQlcf+YS6NZCA2Uh3zuFT/1IvbQ2FmSZCLh9Xr//Oc/79ix PSvOF4tpyncaja8AzEMxPp0BKCrF0xDrSGw2+wknnHDZZZddfPHF4oT4SElY/JHf 7y/88AAoYnqpM3v5ypNKpcKh0PqXXtqybdvY2Fh/f5/aIzoaGl8BmAcCMIBj6+np GRgo6gycJ86Eli9ffskll3zpS19qamo69AMCgUAsFiv8wADM23TuFXc8Ho/IvelU Su1BlRvx2Ab8/ldefnnHzp3j4+M9vT1qj+jYrFab00n6BTBnBGAAs1IqGTgvk8mI Z7cLL7zo8n/6p87Ozmg0Oj0tLE6Ystms2gMEcGzTl/jmNzOju5Xi4vG4zWJZ9+c/ 79y5s6GxoTivdjks0i+AeSMAA5itotoYaZZE1g0EgqeccsqVV1551llnVU0tnvT5 fGqPC8ARzezqnN/QiF9aKSiVSqWTye3btj3/4otjY2MaraY4r+89CjY9ArAQJfaU B0BdpZiBp6XT6ebm5osuuvgTn/iEVqvNn2S3trTMdVdhADIcdImveJOuzgqKRaMW s3nDhg07dr4u3iyeLXznivQLYIEIwADmprTWQh9WNpv1eX1Lli79wAc+8JnPfnbx okXTZ97kYaDAZl7i6/Z4klziq5zcxshO55bNm17fuctkNuv1upKb7D0IK58BLFxp Pw8CUEUZZOBpIgyHgsHFxy1ZtmzZ33zsY6eddpqms5PJYUC2g1pbidsUuxktWCqV qs5mJyYmNm/ZvG/ffpPZpNGU3grnIyH9AlBEmTwnAiiw3t6evr6+sjmvmub1eBcJ ixe/933vO/vss7v0eiaHAWUd3NpK5F4u8V0A8QDGopGdO15/4803TRaLw27X6XVq D0ph2WzWbrez4xEARZTbySuAghEZuLe3t4S6hs5VOp2uylYNDA4YDCNnfvjDHzrz TE1nZ9VfTt/Jw8Cc5H9wRJLJt7ZKJZO0tpqfVCqVTaf37Nnz+s6dRqPR4XDU1deV 7jW9x5TJZBw5pF8AyiAAA5g/vV7f0tys79KrPZBCEKdfvT09w8NDhpGRE09e8bG/ +ZsufUV84sBCTOfehMi9U5f4knvnKrcDVCz21ttv79m922wxO10ur9fXWwpb9S6c SPjV1TUej0ftgQAoHwRgAAvS2NjQ3t4+NDSk9kAKLTNl6dLjly1bduqpp55++ukd HR1qDwooFgdvZZRMZjMZtQdVMhKJRNDv37Vr1/79+602m8fjbmxqKuPlNkdiNptD oVA8zv7PAJREAAawUA0NDRpNZ+luj6SIbDYbiUQHBwcNhuHFi49bsWLF+973vtbW VrXHBRTUQbk3lUxmyL3HIuLuZCj01ltvjY6N2e128bj5/H5tCW7Pqyyr1er3B8SD o/ZAAJSbin5uBaCg3t6e/v4yaQ2tCBGJo9GYiMTDw0NLlixdvny5SMVdXV1qjwtQ 3jtb+P5lnTO597BSqVRtdbXH49m9e/fExITVZhNx1+/3ayo+7h7EZrNx0S8ASXi2 BaAMvV4vkp7aoyh2Pp+vp6e3v79fBOPFixefcMIJIhW3tLSoPS5gPt7JvYlEfp1z Jp1We1DFoq6+XsTdoNe7d9++8fFxu93m9nhF1g2FQ93d3WqPrtiZTGau+wUgCQEY gDIIwPOTzWbD4cm+vt7u7twUusFgEMF4+fLlTKejaL0r93o8qUQiXdm5VwTdmupq p9OZu2TXYnG6nF6fPxDwB4MhnU7L1O48EIAByMOTMgBlEICV5XA4xEMqUnFvb+/g 4ODQ0NCiRYuOP35pVxdzR1DHzNzrmVrnXJm51+/352Z0bTaz2ex2uwOBQDAUnAyH +yu7D4KyCMAA5CEAA1AGAbgwMplMKBTWaDQ6nU5kY4PBsGTJkqVLlx533HGNjY1q jw5l6ODcm0ymUym1ByWd+GStVquIuBaLxel0eL2+YDAYDosfvc4K7MZceARgAPIQ gAEogwCsrmw2K87RtVoRjbUiG3dN6evrGxoaNBhGhoaGOGvHnJR97s1kMi6Xy263 u3Lb6uauzs1doJsTDIXC3d1dLF1WEQEYgDw8uQNQRleXvgJ3Ay4V+XnjzimaKfmE nF9fPTw8LDKz2mNEUZjOvcmp63tLOvcGg0GHw+F2u/P5NhgMiJ8CEXDD4XAkEmEu t5hNLS8nAAOQggAMQBkE4JKWTqcjkWhHR0d7e7u4FTlZRGKtViu+rL29fQNT2Na4 jL2Te5PJfF+rVHHn3mg06p7i84lwG8jN2waDk38h8q34Xq6trVV7mJgnAjAAeQjA AJRBAC57+ZDc2trSfkBH51+ItDzVsiunq6uL4FEqii33ZjIZ/18EAoH8bG1eNBrJ J9tYLE64LXsEYADyEIABKIMAjLxsNutyuVtamtva2kVabm1tmyL+d2BuWdBq37lQ md5dhTcz9+av700lk5KOlUgkRJSdvrw2HJ7Mr0AWogeIOzFxG48nent7uPIWVQRg ADLxMgNAGTTBwvxkMhkRkBobm1paRFpumdI6dT93K6LzgenmDvHvgYXZGo2mvr5e 7YGXngXm3lQqNTUlGwoGQ5OT4anp2AM5NvaO3H3xjng8nkwmxNeL62wxDzTBAiAP ARiAMgjAKJhsNiticzAYbGhoaGpqEuF56nbqf1N3RHLO35+K081NTc1CPluLRD2d rsVtJQRpkVHdbrfIqYFAwGG3B0OhyOSkiKkioyYSifyd/P14PJZIJMX/p26nxUX0 1Wq1IsoyPYvCIAADkIdXMgDKIACjFOWztNfrq50iErWIeXV1tXV19eJNcb++vk6k vvr6hvzH19Xl3nS5XKqMtru7Wwx4+jLdZDIh3kwmU+JTSKfTqVQylUqL+yKzTr2Z 0ut1pFaUIgIwAHl4UQSgDAIwAEARBGAA8hCAASiDAAwAUAQBGIA8BGAAypAXgLPZ LGs4AaDYyHtyJgADkIdzSgDKkBeAQ6Hw3517zsZNm+OJOB1lAUBdmUymvr7hvaed uva5dRpNp4xDEIAByEMABqAMmQE4tG/f/mQyuW7Nmv966KHtr+9Ip9MkYQAoJJF7 q6urTzvtveeee65WqzWOjv505X+IZ34ZxyIAA5CHAAxAGTqdzmAYllFZxN3XX985 /aZIws+sXn3X7+4eHRtjaTQAyJbNZpcuPf6CCy4QuTf/nlQq5bBaf/Xrm2pra2Uc 0Wg0eb1eGZUBgHNHAMrQ6bQGg0FS8RdffKm9vX3me4LB4DPPPLNu7dpNW7aYzaaB gQFJhwaAymS1WoeGhv/mb/7mYx/7WENDw8w/qs5mXU7nL2+4XtKhjUaj1+uTVBxA hSMAA1DMqae+R9KU7L333nfKKafMfE8ymYxGo83NzeJ2y5YtmzZsWLdu3d59+zo1 nUwLA8D8ZLNZn89/wvLl55533kknnXTEj8tkRvfvv+Ou30oaw44dr8uoDABVBGAA ChocHOju7pZR+f/8n/97wQUXHPaPppNwfX19Kpl8bu3ahx56aOPmzbW1NVwnDACz kclk0qn0GR/4wDnnnKPRaI758YlYbNvWrX964nEZg2H6F4BUBGAAiuns7Fy8eJGM yl/5ymX/8i//MvuPDwaDz//5z6+sX79ly5Y9+/bp9ToZowKAkuZ2e5Ydf/yHP/KR M844o66ubvZ/MRQIvPjCCy+/+oqMUY2NjQcCARmVAaCKAAxAQRqNZtGiERmVzz33 vJUrV87+42dOC9us1g2vvPLkqlXbtm9LpdOSWrYAQElIp9N1tbXvfe/7PnjmmcPD 8+xc6HW5Hn/yyd17dis7trzx8Qm/3y+jMgBUEYABKEheH6wVK0657777FlgkNy38 /PObNmzY8fqOffv3NzY2crUwgEqQzWZjsdjSJUvf9/73z3Wy97AcVut999/v8UrZ qYgl0ACk4uQPgGL0et285xOOTqfTPffcugUWmTkt7PF4Hn/ssY0bNuzes2dsfFyr PfY1bwBQWnw+/6KRkZNXrPjoRz86myt7Z89iNN5y628y2ayCNaeZTCaPhz2QAMhC AAagGL1ePzw8JKNyODy5d+9eBQvObCK9YePGt3bt2rp169u7d1tttq4uvYIHAoBC crs9huGhZcuWn37GGccdd5ykoxjHxn62cqVOp5VR3GQyezxS5pYBoIoADEBB8gJw NptdtWr14OCg4pXzSVjUtzsc4l+3y2UaH9++ffvbu9+22ux0zwJQ/Dwe7/DQ0PLl y9//V3+1ZMkS2YeLxWITo6N333uPpKtICMAApCIAA1CMvAAsXHnldy+99FJJxaty 0yZujze36K61pWUyEhFh2ONy2azWN9944+3duy0WS2NTI/sqASgGmUwmHo8PDQ4d f/zx7zn11MWLFxfy6KFgcNPGjWvXPSepPgEYgFQEYACK0Wq1BsOwpDmBs87621/+ 8pcyKk8Tp1ypVKpqalpYZOCqqTBcX1/vDwSsNlvA631j166dO3eOjY87nE6NppMe WgAKI5vN+v2B3p5uw8iik0488b3ve19TU5Nag/E4nX967LF9o/tlFBefqdFo8vlo ggVAFs7eAChpZGREUkOp3t6+p59+WkblmVwuVyaTOeid+TycD8PiTZGHzRaL1+l8 ++23d+/ePWGcsNsdLa0tzA8DUIp4IopEor09PUNDQ0uWLj3ttNPa29vVHtQBVpPp 1ttvT6aSMoqL9Ov10gELgEQEYABK0mq1IyNSdkJyudz7p/YuklF8JqfTmT1qa9ND 87DNZotOThonJkQeNplMNrvd7XYHgsG+vl7ZowVQBuw2e2dnp16v7+npGRwcXLR4 8bJlyxoaGtQe12GkUimb2fyj//f/JD2/TUwYmf4FIBUBGICS5O2EJPzoR/9+/vnn Syo+k8PhmP0HH5SHq6Yisd3h8Pt8Qb/fYjFbTGaH0+Hx+rw+XyDgn5yMDAz0yxk4 gKJmtdpaW1s62jtE3NXptD09vf39/SOLFolbtYc2W9HJyW3btj2x6klJ9dkDCYBs BGAASpLaB+tDH/rwzTffLKn4TNls1ul0zvuvH3QJ8fT788E44PcnYjG322232cRt PhWHQuFQKDQ5GY7GYjqdjtXUQCnKZDI+n6+pqam5qbmtra1d/NvertFq9Dp9d3d3 30C/Xt+l9hgXyu1wPPzIIxMmo6T6dMACIBsBGICSpM4AV1fXbN26VVLxgywwAx/W kYLxtHxCDgWDIiTHY7HI5KTb4/F5vYFAIBwW7w7l/gmFI9FoMpnI52S73SHG2s+U MiCBzWavrq7u7e0Rydbr9TbUN7S0tLR3tHd2dHZ2dIh0q9FompubG5uaunt6DCMj ixctEj+V4ifd7XbH4/HsIQ0FyoBpfPyX11/f3NIsqz4zwAAkIwADUFhfjpRrw0Qo vfvu3733ve+VUfywh1M8Ax/ddEKuOnJInmk6MGfTaY/bbTKb7Xab2+3x+XzBKeHJ Sa1Ww3wycCQi2fr9gfa2to6O/LJkXW9Pj0ar7dBoli1btmTJEk1n59Er5H9sRZ10 Oi0Sr9vjSYjoe9Q+AqVLnDW+vmP7/Q88IKkHPhcAAygAAjAAhYnENTIyIqn4hz/8 kV//+teSih9KnMW6XK6iPZc9+pTyzBXXfp/ParOJz8Xr8fj/suI6PBmORCLd3d3s 54RyJX543W53bto2txi5vaOjXavVdXd1ibfEv0uPP/7EE088NOIec7HGoR+cSCTE z5eIvrI+k+Lgcjgefvhho9kkqf7ExITP55dUHADyOOkBoDCpq6AnJyNvv/12gac0 j9kXujjNZsW1zW73eb0iIYs87JhqXu3z+QLBYC4eh8OTU+KJOCEZRSgfbhsbGlun TOXb3CxuV5e+tbWtubV10eLFJ590kl6nO/TvziniHkm+SDwedzmd4v6CPplSkEql rCbTNStXanVaSYdg/TOAAuCEBoDCpPbBEr71rW9/7Wtfk1f/sA67P3Cpm00GyE0j i5Ds86WTybAIyU6nx+Px+/2hYO6S5MnJSFSIiX9y4olEf38/URkLIWKt3WZraGxs bmrOa2lpaWtr7cjp1Gm14m0RbhcvWrT8hBPEm4ctoki+PZLp4rFYTERfEQuVrV+0 /F7vy+vXr39lvbxD0AELQAFwmgJAYTqddnBwsLa2VlL99vb2F198SVLxoxCnZZVz pjtt9kEiP5/scbuT8bgIw56pyeRgMBDMLbUOR6K5f6KxA8QdUbm7u4vrkytBJpNx u9z1DSLVNjbU14tA2zr1n/inderiW42ms7GxqaGpadhgOPmkk7r0+qNUkxpujy5/ aHHrmVo3kU6nC3l0dYlnP4fN9uubb5Z35igeT4vF4vVyDTAAuQjAAJQngo3IwPLq X331Tz71qU/Jq38kfr8/Xu7X+M3bnGLJdPuuYCCQTuV4vV7x8Io3c6uuI5H8lLLI yfEccZuYuhNPpdN9fb1MMqslm806HM7a2tpGkWabmppEnm1orBNvNubeyi9Cbp/q jSzibl1dnVarHRgaWnLccfnrbMXXXSSc3t7eQyOuirF2Nqajr9vtFt+L5bce5JjC odDW11576pmn5R1CfG+4XG559QEgj3MIAMqTvQq6ra3tpZdellf/KEQ6C4fDqhy6 nMy133VePjaHcxsmT2bS6UwqFQgERIiORCLhycmo+N/UHHNc/JuIJxLJKQlxJ5VK Tt2mcveSSRG5M9lMX19f5cw/i8DmcDhqakR0rW2YiqZCQ0N9fV29eI94HJqam0Wa nYqxObkZ2paW/LW1NXV11TU1ItP2DwwsGhk5qGWU+KKIyuLBF3+5v79fq9Hk33/Y L3H+ncUZcY9kZo8r8W1Uiu0AFq4A079VrH8GUCgEYADKkx2Ahf/5P//1S1/6ktRD HIk4FWajDlXMLzYfKh+kI5OToqC4za/Kbm5qamxsnLqiOSrenw/Q2UxG/G9qgxsR t1Mi/OSm/rJZkfSU+7RmS6R3u90uPut8bs/fyQda8VqeW148tcA4lU6LMYs/Fe9v bmkRabazszP97tX7dVN/rNfpRJqdZZfj/P1DH/b8n4pHprq6urSS7dFNf9bxWMzp cqUqoMfVUQT8/ldfeeWFl16UehQCMIDCIAADkEJ2BhbxZNu2beIUX94hjq5EW0Oj 6t2JblrZhLdDPzvxHrMpt29NLvfW14ufzfxnWjafsrLeudB3akffirrQ97DEQ2E1 mf7zuuva2tvkHYX0C6BgCMAApJC6GVLeaae99/bbb1fxDN7r9VbC3icodeK7NBAM 1tbW5q+dJvceyYHom0i4pi705TdceQ6L5Y+PPmqxWqQehQ2QABQMARiAFAVYBZ3J ZH76s2vOO/dcFc/mQ6FQ5JC5RAAl5J3VzvF4/kJftUdURLKZzJbNmx9+9BHZF8wz AwygYAjAAGTp6tIPDcnNwJFI9Pnnn1flgsxp4uzZ62XiAig906udxY9wIh6vwH3O ji6RSJgnJq6/8ca2tlapBzKbzW436RdAgRCAAchSgElgoa+v/6mnnpJ9lGOqzF2C gRI1c7WzuK3AbY2OSTyh2czme+6799AL5hXH9C+AQiIAA5BFBODBwYEC7DTz0Y/+ 9Y033ij7KMfEcmigyLHaefacNttjTzw+OjYm+0CZTMZisRKAARQMARiARD093QMD A7KPks1mL7nkku997yrZBzqmVCrl9XrpnQMUG3o7z0kkHF69evWWra/lG6dJZbVa nU6X7KMAwDQCMACJCrMKumpqDuGb3/zm5Zf/UwGOdUw+ny/BzBJQBKanfEXoza92 5vdTxxSPRteuXfviyy8VYP1OFeufARQcARiAXF1dXUNDgwU4kMjA3/72t7/+9W8U 4FjHFIvFAoGA2qMAKte7pnwTiTSX6M9OLv2uWfPi+pcLk37NZovb7S7AgQBgGgEY gFwFmwSumsrAX/3q1/7lX/6lMIc7JjpjAQXGlO9CRMPh1U8/tWnz5sKk3yqmfwGo gQAMQLpCZmBxsnvWx8+67vrrC3O4Y4pGo8FgUO1RAOWPKd+FyPUvcLn+9Phjo2Nj BbjuN4/0C0AVBGAA0hUyAOctWrT4gQceaGpqKuRBj4KpYECSmY2d3Uz5zot40ExG 44P/9V+hcKiQxyUAA1AFARhAIRQ+AwsPP/zwkiVLC3zQI2EqGFDQdO4Vd/K5l8bO 81NTXb11y5Z77ru3qbm5kMcl/QJQCwEYQCF0demHhgodgO12x1VXXXXllVcW+LhH 4fV6xfm62qMAStj0UufcT1MiwQ/UvKVSqaDfv3bt2tVPP93f31fgo5vNZrebAAxA BQRgAAXS3d01OFiIdtAH6e3tu+eee3p7ewt/6MNKJBJ+v59VmsCcvNPdKpFwu93i NpvJqD2oEhaNRkf37Xvoj39MJFXYs81isbhcNH8GoA4CMIAC0ev1Q0ODBWuvMpPT 6briiit++MMfFqy16TEFAoFYLKb2KIASQHcrZeX7XT2xatXL69f39anwm8FsNms2 W1j/DEAtBGAAhdPT0zMw0K/W0Wuqa67+yU8++clPqjWAg6TTaa/Xm2EWCzicfO4V YWm6u5XaIyoH6WTyubVrn3722camRrXGYLXanE6nWkcHAAIwgMJpbm7u6+vr7OxQ awDiZLq3t+/nP//5aaedptYYDhKJREKhgnZeBYrZwRv5JpMsdVZETVXVxg0bnly9 Op6Iq7ISJ89oNEWnqDUAACAAAygoFRdCT8tkMkuWLPnxj//fe97zHhWHMZPP50sw wYUK9k5X50TC7fHQ1VlBNdXVmzdufGbNmkAwoO5lICx+BlAMCMAACk3dhdDTxKnY 8PDw97531amnntrc3FxfX6/ueEQA8Pv9rIhGpZl5ia+4TdHVWUGZzCvr1z/3/J8n JyfV/bVjHoufARQD9Z8NAVSahob69vaOwm8LfFgiBtfU1Fx++T8JxXCCKM5Tw+Gw 2qMApDvoEl+Re2mNrpRUKhUOhdY9t3bzli3iMS2GZ7aqqY1/Q6FgIsEvOACorCie EwFUGr1ePzg4UDw9mQWROz/72fOv+Od/FmNTfUKYFdEoV9NLnQ+0tuISX0VFo1Hj 2Nhzf173xptvdnSo1m3hUJlMxmKxsvgZQDEgAANQR29vT3+/+guhDyLO0lpaWr/x jW988YtfFCfoKiZhVkSjnBy0i694M8MlvsrJT/m+9MILG7dsSSYTRfW7xTybzeZw sPgZQFEgAANQTZFcDHxY4hz9lFPeI5Lw3//930ejUbWSMD2iUdLeaW2VTOZzL7v4 Kkjk3mQ8vmHDhk2bN+/bv6+rq0vtER0el/4CKCoEYACqEamyra11cHBQ7YEcTSAQ OPnkFV/5ylc+9alPxWIxVZKwGIM4dIEPCszbzNzrmWrpnCL3Kkc8mPFodNPGja9t 2zo6NtbZ2an2iI7GYrGEw5PsewSgeBCAAaipoaFhYGBAoynqE7g8t9u9fPkJX7j4 4ou/8AUx7AJPC2ezWa/XS4pAMXtX7vV6c7mXls7KEY+n3+/f8Oorr+/cNT4xXrTz vTMZjaZwOExHAwBFhQAMQGWNjY3d3V0lcTKXl06nxZjf855Tv/71r5955pmFPHQ8 Hg8EAjTLRVGZzr2pVMrt8cRjMa7vVYp4SLPp9FtvvbVx48b9o6OZbKa2tlbtQc2W 0WicnIyIZy21BwIA70IABqA+kSc1Gk1/f5/aA5mzYDB0wgknnHP22ed/7nMGg6Ew B2WrJBSDmfO9LpcrkUjQz1kp0WjUYjJt2bJl3/79Vqu1sxTWyBxkYsIYiZB+ARQj AjCAoqDX6wcG+ktocuMg2Ww2FosvW7bszA9+8B8uvHDp0qUiFUhdJu33+zm5RIFN h96qqfUILqczN0XJkoQFEw9jdTY7Nja25bXXRkdHrTZbW1trkezfOw/pdNpqtbHp EYDiVKrPrQDKT29vj1C6GXimQCA4YjAct2TJBRdccPbZZ4sMLCMPZzIZn8/HhcGQ 7aCmVolEgmbOCycezFg0+sauXW++9ZbJZLI7HCXRDeGYRPp1Op1segSgaBGAARSR ri59bW1dKa6FPgpxOlhTXWMwGI5ftuzzn//8Bz/4werqagXzcGKqNQ6zcFDWQZO9 bpdLvIdvs4VIpVKZVGrvvn0i9I5PjNsdzrq62vL4ld+0iQljbW2N283cL4DiRQAG UFyamho1Gm1fX6/aA5HFbnf09/UNDA4sWrT4M5/5zF//9V83Njbm83DV1NZQ84vE 7BiMhZsZehOJRG4HI3buXQDx6MWj0bd3796zZ4/JbHI5nR6vr4yf3ET6jUYjsRiX ZgAoagRgAEVHBML+/v7yWA14TJlMJh6Ld3d39/b1LV++/NOf/vTpp59eU1NTNXX2 PNdZ4mAwyH6bmJOZoTcpQq/Pl0omU0z2zl0qlUonk+Pj4yLxms1mh8Ph9flaW1vy P85lz2g0TU5O0pgAQPEjAAMoRk1NTW1tbUNDg2oPRAXpdDqZSE5dEd07MDh47rnn fvjDH+7o6Kj6SySuOtZEsdfrTbL/Ko5q5mW9+S2mcwt02b5o1hKJRDgY3D86Oj42 ZrVZPR6P3+9vam4usyXNs2Q2W8LhcCwWU3sgAHBsBGAARaqhoV6j0QwMDKg9EPVl s1mv16fTanU6nV6vHzYYTj/99HPOOUfcz3/AocFYhBmfz5dhWxrMMB16xXdUPB7P 5d5kMk3oPSrxo1RXU+P1+fbt22c2mRxOp9vtFj9coXBYr9eVbqNmBVmtVhH+Ewl+ 6QagNPDEDaCo9fb29Pb2VsgawrlyOJyazs6uLn1np6ajs3NoaPC009571llniUcs /wGxWCwYDIq0M518WltaJG3LhOI0M/Qm4nHP1GQvl/UeSjwstdXVXq93bHzcarW4 XG6/z+cP+AOBYHhyUjwRqT3AYpTJZBw5NHwGUEoIwACKnV6vb2tt1eq0ag+kZNhs ttbWNq0mRz81a9ze0d6p0S5fvvzkk0/WaQ/zSJKQy8m7Qm8iMb3CuYrLeqcym3hA rFar0+kwG01+vz8QCoWFUCgajfSz5GTWjEZTdXU1m/0CKDkEYAAloLGxsaOjY3CQ c9OFym8d3NLS2tba2t7e3tnZqZ3SIrS2Llq8+JRTTunp7j5KhZk9k0jLxeNdDZxn zPRWWi8r8Ti43W6RykTKDQQCwRxxOxVxw+FIZFKj0bCiZOEsFqt4ZGl5BaAUEYAB lAy9Xl9XV267BBcbkZccDmdjY2NLc7OIxK0tza2tbe3tbR3tHR2dnR0dHXX19bW1 tTq9fmBw8PilSzWdc2jWPTOkVZGfF+ygXYumZ3qzZXftt8iu+TQbCoUmp+QDrbgj Mm0kEo1MicVivb09XJcr1cSEsaamholfAKWLFwkApWRqKrh9cLASu0MXoXxabmio b2psEl+apqam5mZxR9w2NzY2iHfm7jU1iSDd0tLS1tYmkkkmmxVRur29vbunp6+3 V0RqMvCcHLxr0V9meou84ZkYpAioU3k1Eo2KvDopbmOxuLgV0T0+JZlMiPfF4yLG Tv2Xu4klEsmenm4ybZGwWCzBYIiJXwAljVcUAKVHr9c3NDTQlqbUiczmdntqa2vr 6urEF1Tc1h+Quzv1zvr8HfEu8QG1tTXivviL4s3q6hoh/6b4I3FbN0Ukpfkl6uTU zrdiSCKPVU1tRpVvjzzjzVQ6nRFBTrxnaGhIwcdhNsTAxAitNltdbW06k66uqs6r mno0xK14NPIb8IgHIb/Ed96PQ9WMT3/6TTEA8fiIB6Eql2Zzb+Znm/OPTDKZu5P6 i/xjJf5uamoNtkiwrDoudUz8AigbBGAAJamxsbGzs6O/v5+pIQCQJ5vN2my2QIAr fgGUCU4cAZQwvV4vAvDQECuiAUB5ZrNFBGAmfgGUEwIwgJLX1aXPNzRWeyAAUCZM ptwuR2430RdAuSEAAygHTU2Nra1t4rb7qFv4AACOzmg0VlfXTE6GYzHWPAMoQwRg AOWjqalpauOeZn2XXu2xAECJ+Uv0nYzFYmqPBQBkIQADKDfNzc0tLbktbHU6rdpj AYASYDTmFjznN6lSeywAIBcBGEB5ysfg6uqqwu9YAwClwmw2Z7NVRF8AlYMADKDM 6fX6mpqagQE2TAKAA7LZrNVqy2QydHgGUGk4HQRQEXQ6nQjA7e3tGg3NogFUrvxq ZxGAvV6v2mMBABUQgAFUlvyEcH9/n7hVeywAUCCZTMZmszPlCwAEYACVKD8hXFNT PTAwwNJoAOVqaqmzNZPJMuULAHmc9gGoaHp9bsMkkYEHB0nCAMqEiLsWi1XcivtM +QLATJztAUBOfk6YPYQBlLT8Xr7M9wLAkRCAAeAdWq1mZGRE7VEAwDxNTEz4fH61 RwEAxYsADADv6OzsXLx4kcqDAID5GhsbDwQCao8CAIoXARgA3tHb29Pf36/2KABg npgBBoCjIwADwAE6nc5gGFZ7FACwIEajiQuAAeBICMAAcIBerxseJgADKG0mk8nj IQADwOERgAHgAL1ePzw8pPYoAGBBTCYzWx8BwJEQgAHgAHkBOJPJVE+RURxAyclO qampkVGcAAwAR8HZGAAcIC8Ad3Z2Xv6Ny996662J8XGT2exwOuvqagUZxwJQhNLp dDKR7O7u7h8YWHLccT3d3b+///50Ji3jWARgADgKAjAAHCCvCdayZcvvuOOO5ubm +vp68WYwGHzttdd27NgxNrrfZrXZ7DZxtlpXX08kBsqDiLvxeFyv0/X09i0yGI5f vnzx4sUz53vtFss9993nD0hp10wTLAA4CgIwAByg1WpHRgwyKn/kIx+96aabpt9M JpPRaFTcmY7Ewq5du1544QXj+LjNbrfZbB632+f3d2o6WTgNFLNsNhsIBHVabXd3 t16v7+nrW75smcFgOPryZrfD8fAjj0yYjDKGNDFh9Pl8MioDQBngvAoADtBoNIsW jciofP75n/vRj3509I/Jp+KZkTgYDG7YuHHn66/brVaXy2V3ODxeb8DvE+/vHxiQ MU4AR2G1Wjs7OrVabVdXV19fX09vz+Ljlpx55pk93d35DxA/woFAwGazHbOU3+N5 6umnX9+1U8Y4x8cn/H62AgaAwyMAA8ABIwaDVqeVUfnyy//piiuumOvfOuxEsbBn 9+5NmzfbLBaX02m1WZ2u3FxxMOAPhsJ9fb1KjhuoSHa7o6OjXdOpEVm3p6dbq9Xp urpOXrHilBUrNJ2d0x8mfkInI5HWlpbpH09/IGC326ORyDEPEQmHX3rppedffEHG +FkCDQBHQQAGgBwRHXt6eiQ1Zf3pT3/2yU9+Uqlqh84V542Ojr755pv79u3zeb1+ n8/lcuVmjAOBUCgUiUTaO9q5xhjIS6fToWCopaWlo6NDo9HodLqe7u5OrVaj1Sxb tnzJkiWHBl1xZ2bWPSwRgK1WazwWO+YAkonEzh07/vjoIwv/XA6VyWScTqeI8TKK A0CpIwADQI7UTYAfeeTR4447TlLxaUeaMc7bt3fvzl27xsfHA35/MBh0OZ0+vy8c nhTC4n+RyXg8MTDQL3uQQAFYrbbmpsaW1ra2VvFfW3t7m0aj7e7qauvIWXL88Scs Xz4z4ubNPugeiQjAFoslEY8f8yMzqZTRaLztjtvncZTZoBE0ABwJARgAcqRuArxt 23ZJc8uzd1A89nq94j35P8qt23Q4RA4WwTgRy3G5XD6vNxAMhoLB8GQ4Go1Fo5FY LB6Lx8W9RDKh0+mYT0YhpdNpn8/XUN/QlNMo/mtubhHa29o6Ojs1Gk3+vd09PcMG w4jBcGi+rVIi4h6d+FEymUypv/xkHUUqlbJbLDfdcjNbAQNAgRGAASBHXgCenIzs 2bNHRuWFcDjeWR45nQqqZrfIM5+WRRJOp1LJRMLj9fr9/oDfHw6HI5FILkDHY4lE Mh6PJ8Ufi7iciCeS4kOT8YR4T0okmf7+PrpbV5psNmu32Wtqaxvq6xoaG+vrxDda faO4U1/f0CDe0dgobkWsbWpqzc3ZtotMK94vPkqr0w0MDg4NDh42006b07exJOKn Y2JiIpOe1e6+xrGxa1aulNR3gAAMAEfC+QcA5MgLwI2NTRs2bJBRed5ETA2FQvP7 uwuMGdP5ORqJhCcnxW1TY2Ndba1IyyI4R3PZOSbux0VojsWSUxIiNE/diggl0nM2 kyPuiDdFrK6amkyrys20p8X7s5lsOjOr+HGQ2tpakclrqmtqpma26+rqqvPvrBGq 62rrxAumeDP3/uoaVaKFCJDdPT3ik02nxWea+xxzc/jZKvF2IpHIha7c+KvFn2bF o5DNpmcXww5SW1M79SgI7zwOdfXitrq2rjb//vxj1VCfy7Aio+YSrIiyTU35BNs0 FWLFl0Z8EZuaxd2mlpYWMXLD8PDRE+yhiiHTzon49h4bGxNfqtl8sHli4vpf/aqh sUHGSAjAAHAkBGAAyNHrdcPDwzIqDwwMrFq1WkbleXM6ndnZnaMrbmakySuJYDNv 2SnVUxZYyj+1v04sGhWhVARxvU7X0NjY1tpanI9epX2h83x+/7gIwLNjNZnu+O2d sVlcMDwPJpPJ46ERNAAcBgEYAHJ0Oq3BYJBR+bTT3nv33XfLqDw/6XTa7XarPYqK I2JwJpPJzSbPNwmLSBmenBR38hUqIU+WFvEF8vp8Votllh/vtNnuf+ABp8spYzBG o9Hr9cmoDACljgAMADlarWZkZERG5XPPPW/lypUyKs+P3++Py5l0wjEpOCGMYpNf 3h+d+iXFbHhdrscef3zPvr0yBjMxMeHz+WVUBoBSxwswAOTIWwJ96aVfufLKK2VU np+Z7a+glkwmQwwuM9Nr1Gf58SG//7l16zZu3iRjMCyBBoAj4aUXAHJOOWWFpH19 vv/971900cUyKs9DNBoNBoNqjwIH5K/EJgaXh9lvApwXj0Zf27LlidWrZAwmnU7v 3LlLRmUAKHW86AKAxBbQwm233X7GGWdIKj5XLpcrk8moPQq8S3bq+uDqBVwejGIw +02A81Lx+P79+393372SxkMjaAA4LF5rAUBiABbR5uWX17e1tckoPldiME6nlI47 WDguDy51c9oEuGqqaZbNbL7ltlslfcUJwABwWLzKAkBVV5d+aEhKAA4Gg/v3j8qo PA9iMNFZX6AIVRCDS5cIwONjY3PaYMw4OvrT//gPfZdexnjMZrPbTQAGgIPx+goA EmeA6+rqN2/eLKPyPND+qlQQg0vRnDYBzjNNTFx3ww1NTY0yxsMMMAAcFq+sACCx BXR//8Dq1atlVJ6reDzu97MtSikhBpeQuW4CnGc1mW67445EMiFjSDSCBoDD4jUV AKp0Oq3BYJBR+T3vOfWee+6RUXmu3G53etZXJ6J4EINLwlw3Ac5zWK33/+EPLo9b xpCMRqPX65NRGQBKGq+mAFCl1WpGRkZkVD7nnHN//vOfy6g8V6x/Lml0ii5yc90E OM/rcv3pscf27t8nY0gTExM+H4s+AOBgvI4CgMRrgL/85Uu/+93vyqg8J6FQKBKJ qD0KLBT7BhetuW4CnBf0+9etW7dx8yYZQ+IaYAA4LF5EAaDqlFNW1NbWyqj8b//2 vUsuuURG5Tlh+recEIOL0Fw3Ac6LRyKbN29e9fRTMoaUTqd37twlozIAlDRePgFU Op1OZzBI6YAl3HrrbR/4wAckFZ+lRCLh83EpYLnJZDJcGFw85roJcF4yHt+3b9+9 v79P0qiMRpPXSx8sAHgXXjgBVDp565+z2exLL73c3t4uo/jseTyeVCql7hggA1PB xWMemwBXTfWOtppMv7n9NklfRFZBA8CheNUEUOnkBeBAIDA6Ord9QWVg/XN5y2Yy VUwFq20emwDnGcfGfnLNz7q6uhQfUhUBGAAOh9dLAJVOXgCura3bsmWLjMqzFw6H J+e4NQtKDlPB6sptAuz1Wq3Wefxd0/j4L2+4obm5SfFRVRGAAeBweLEEUOn0et3w sJRrgPv6+p96Skp7m9lj+rdyMBWsltwmwHZ7dF6N1q0m02133JFIJhQfVVUuAJs8 Hq4BBoB34WUSQKXT6bQGg0FG5RUrTrnvPlntbWYjPzGl4gBQYEwFq0IEYKvVGo/F 5vF3HVbrffff7/FKmac1Go1eLw3wAOBdeI0EUOk0Gs2iRSMyKp999jnXXnutjMqz JNJvco77sqAM0CC6wEQANpvNycR8ZnE9TuefHn983/59io9KGB+f8Pv9MioDQOni 1RFApVs0MqLRamRU/vKXL/3ud78ro/Issf65YpGBC0kEYKPRmJ5Xr/Wg379u3bqN mzcpPqoqtkECgMPhpRFARdNoOg0GQ01NjYzi3//+9y+66GIZlWeD9lcVjuXQBZPb A2l8PHcN9tzFo9HXtmx5YvUqxUdVNfV7EJHM/f6AjOIAUKJ4XQRQ0XQ6ncEgpQOW cN99v1+xYoWk4sfE9C+qpmIwGVi2ee+BJKQSidHR0bvv+Z2iI3oHk8AAcBBeFAFU NHl7IGUyma1bt9XW1soofkyJRML3/7N3J3BS1Xe+96EbaAWUrqVpmi66wcwkk4lZ JrnjjJnkaqKT1SQzPhPnJnkycXTGPDom5s7LZCaTRCK474iCKAKCCFFWFVRQxAWN +76i0FV1zqmq7lq7u9ZTyz1NOTxcROilfnVOnfN5z7zyQuj+nr8tdNWX/5bg8BsM 4XRoUbquG3/WVFUd3acXi8Wwqi5cdLPQOhRuQgKAg/ByCMDR5ApwJpN95513JJKH w3jLWxzVjkTYEluC5SRTqUgkkhnDdoPg3r2XXnmlS+YkAgowAByE10IAjiZXgCdP nrJr1y6J5OFg/TMOwpZgIUYBDoVCuWx21AmK379g4cIJEyfUcFT7UYAB4CC8EAJw NLk9wHPmzNmwYaNE8hFx/BUOiQ4swSjAqqoW8vlRJ4QUZdmK5YMyf2bZAwwAB+FV EICjuVyu7u4uieS//uu/Xrz4FonkI2L6F4fBsVi1ZRTgYDBYHMOF233h8N333K1o Wg1HtZ/fH+A4AAA4EC+BAByttXXa7NmzJZL/7u/+fu7cuRLJh5fP55PJZP2fiwZC B64howD7/f5yqTT6hFhs64MPvvb6azUc1X49PT1cgwQAB+L1D4CjdcyY0T6jXSL5 3HPPO+eccySSDy8ajZbG8F4cDkEHrpWhS4D37q0uLx+dzODgrl27dux8tIaj2o8Z YAA4CC9+AJxL9BLgq6++5tRTTxUK/yjGu/De3t46PxQNig5cE2O5BLiqpOtvvfnm 6rVrajWkg7ANGAAOxCsfAOeSOwLa8NBD26ZPny4U/lH6+/uzYziNFk5DBx4jXdeN bqmNcftuuRwJh29YeGONBnUwDoIGgAPxsgfAueQKcCwWDwQCEsmHx/FXGCk68Fgk U6lwOJzNZMYSUiwWI5r2u7lzhbZjUIAB4EC85gFwLrkCbDSKF198SSL5MHK5XCrF aTcYMTrwqBkFWNO0fC43xpxgT8811183efLkmozq4HAKMAAcgBc8AM7l8bhnzRLZ Azx9evtDDz0kkXwYfX195XK5zg+FPdCBR8cowEowqI/hDqQqLRhcvGRJsVSsyagO EgwGYzH2AAPAB3i1A+Bcbrerq0vkEuDjj//0qlWrJJI/SqlUikaj9XwibIYOPApG AQ74/WM/dz2iaatWr47FReZpA4FAPM5B0ADwAV7qADhXa2vr7NndEslf+9rXr7zy Sonkj5JIJAqFQj2fCJupXuRDBx4RowDv3bt33BjuQKqK9/Vt2rx59/vv1WRUB+np 8XM3OADsx+scAOeaNWuWx+OWSD7zzH++4IILJJI/CsdfYezowCMVTyT8PT1jzxlI pR7dsePpZ58Ze9SHcQ0SAByIFzkADuV2u4wCLPRe/ze/+e0//MM/SCQf0uDgYDqd rtvjYGPlcnn8PmYPpAHouh6Lx0NjvANpn0Iu9+ILL2y+/76xR31YpVIJBoOsggaA Kl7hADiU6CXAa9as/bM/+zOh8A9j+hc1VCqVmpqa6MBHlEylQqFQrhY3b5d0vWfv 3qXLl4096pA4CBoA9uPlDYBDeb0en0+kAJfL5ZdeetmoEBLhH5bP59ngh9oyfg/X 7Tdw4zIKsKqqhXx+7FHFYjGsKAsXLxL6siuKEo1SgAFgCAUYgEPJzQDruv76629I JB8Stx9BAodCH5FRgIPBYHHMdyBVBffuvfKaq4859tiapB0czgwwAPw3XtsAOJTc JcAul3vHjh0SyR/G7UeQQwc+PKMA+3t6avXXT2ogcPPixZVxYz1Q+pC4ChgA9uOF DYBDyV0C/MlP/vldd90lkfxh3H4EORwKfXiJZLJn795apUVUdeWdd8aTIkdVcRUw AOzHqxoAh5K7BPiUU0655pprJZI/jOOvIIpJ4I+i67pRgFVFqVVgrLd346ZN7+/d U6vAA3EVMADsx6saAIfq7JzZ1tYmkfyTn5z5i1/8QiL5IP39/dlanEALHAYd+JCS qVQkEsnU7vqxgWTykR07nnnu2VoFHogZYADYj5c0AE4kegnw73530emnny6RfBCm f1EfdOAPq+EdSFWFXO7ll17aeO/mWgUeiKuAAWA/Xs8AOJHoJcDr12847rjjhML3 S6fTg4OD0k8BxrEZ+FBqeAdSVblYDAQCS267tVaBB+EgaACo4sUMgBPJXQJcKpVe ffU1ieSDMP2LeqqUy+O5GfgAQ3cgBQLFYrFWgUZURNMW3LSwubm5VpkH4ipgAKii AANwIrkZ4FKp/Oqrr0okHyiXy6VSKemnAAdiIfSBjALc09NTqekV3MGenquuvXbq 1Ck1zPz/w5kBBoB9eCUD4ERut7urS+QS4La26du2bZNIPlBfX1+tbh8FhomF0Aeq 7R1IVVowuHjJkmKpZrPKBwoEgvE4VwEDAAUYgCO5XK7ubpFLgD/96c+sXLlSInk/ Xdd5IwtTMAlcVf0zqGlabWMjmnbnXXdFY9Haxlb5/YFEgkOwAIACDMCRWlunzZ49 WyL5a1/7+pVXXimRvF80Gi2VSqKPAD4KHXjcvvXP4XA4m8nUNjbe13fvffe9s/vd 2sZW9fT0JJPsmwAACjAAR5oxpF0i+cwz//mCCy6QSK4yqq9RgOXygcNjIfQ4gSOg qwZSqccfe+zJp5+qbWwVM8AAUOXoFzAAziR3BLRh/vxLTjvtNKFwQzwe13VdLh84 IiaBh46ADgaLtf6TqOfzr7366j0b1tc2dj8OggaAcRRgAA4kWoC3bNk6c+ZMoXCj ePT29gqFA8Pn8A5sFGB/T0/ND6KrlEohTVu46Obaxu5HAQaAcRRgAA4kdweS8eYy GAxKJFclk8l8rVddAqPg8IXQEkdAj/vvq4B/O3eu0AYNbkICgHEUYAAOJFeAjT7w 4osvSSRXRSIRuXBgRCrl8vimJrNHYYKhI6ATCU1VJcKDPT3XXH/d5MmTRcIpwABA AQbgQHKXAHd0zNy6datEsqG/vz+bzQqFA6PgzIXQQkdAV2nB4JLbbivoBYlwrgIG gHEUYAAO5HK1dnd3SyR//vOfv/32ZRLJ45j+hfVUyuWhZQ8O68BCR0BXRUKhtWvX hntF/rD7/f5EIimRDAANxFkvWgBg6O7qcrldEsmnnfad+fPnSySn0+nBwUGJZGAs yuVyk8MWQgsdAV2ViEbv37r1zbfelAhnBhgAxlGAATiNx+P2+XxCc1bnnnveOeec I5HM9C+syYGnYQkdAV2VGRx8ateuR3Y+KhFu/MdSFCUWowMDcDQHvWIBwDjJE7AM Cxfe9KUvfanmsdlstr+/v+axQE047TQsoSOgqwq53O53371zzV1C+ZyDBQAUYADO IncJcKVSefLJXVOnTq15cm9vb3WeDbAm55yGNXQEdDyuaZpcfkhRFi25RejryVXA AOCIlysA2E9uBjiXy7/11ls1jy0UColEouaxQA05pwAnU6lQKJSTPI89uHfvZVdd 1do6TSScGWAAjueIlysA2E/uDqTW1tZHH91Z89hoNFoqlWoeC9SWQzqw6BHQVWog cPPiRUJLPjgHCwDs/1oFAAeSuwPpU586/s4776xtplF9jQJc20xAgkNOwzIKcCAQ KBWLco+IaNqq1atjcZF5Wm5CAgCbv1ABwEHmzJkzbdqxEslf+9rXr7zyytpmxuNx Xea2FaDmnHAlklGAe/buFd2TH+/ru/e++97Z/a5EODPAAEABBuAgHo+7s7NT6D36 2Wefff75P6ttJrcfoYHYfhJY1/VEMqkqiuhTBvv7n3ji8ceffFIivFwuq6rKTUgA nMy2r1IA8GGidyBdddXVf/u3f1vDwFQqlcvlahgISLP3JHAylQpHItl0WvQp+Wz2 jTfeuGf9OqF8zsEC4HAUYAAOInoH0qOP7nS5XDXMZPoXDcfek8BGAdY0LS/811KF QkEJBG5dehs3IQGABHu+RAHAIcnNAA8MDL733ns1DEyn04ODgzUMBOrDxpPARgEO BoNF+W35gT17LrniCo/HLRHODDAAh6MAA3AQ4w3lrFkidyBNmTL1yZru2WP6F43L rlciGQXY39NjNHzpByl+/4033dQ8oVki3Ojw7AEG4GQ2fH0CgI/icrm6u7skkv/0 Tz9+99131yotl8ulUqlapQF1ZtdJ4EQy2bN3bx0eFFbVFStXpvpFvgn4/YFEIiGR DAANgQIMwEHklkB/9aunXHvttbVK6+vrq8MsEyDHfpPAuq7H4vGQptXhWbHe3g2b Nu3Zu0cinCXQABzOVi9OAHAYM2a0t7W1NTeLrCo866yzfvazn9ckqlgs8vYUjc5+ k8DJVCoUCuWy2To8ayCV2rnz0af++EeJ8FKp1NfXFw6zyQKAQ1GAATiF6B1I8+bN /853vlOTqHg8rsufsgNIs9kksFGAFUXRC4U6PEvP51995ZV1GzcI5TMJDMDJ7PPK BACHJ1qAt259oKOjoyZRHH8Fe7DZJHDdTsAaUi6HNO3Gm28SiqcAA3AyCjAAp5Ar wIlEsqenpyZR/f39WbE1luPHj69e0wrUh50mget2Ata4ffsgIpp20cUXT5/eJpFP AQbgZDZ5WQKAI3K73V1dIncgTZrU8swzz9QkSm76l/aL+rPNJLCu6/F4XKvLCVhV it9/3YIFLS2TJMIDgaDxryORDADWRwEG4BRydyDNmTNnw4aNY8/JZDIDAwNjzzkk CjBMYY9J4HqegFUVUpRlK5YPptMS4dyEBMDJGv41CQCGaXZ3d6urVSL55JNPvv76 G8ae09vbK9RRab8wiz0mget5AlZVLBJZv3HjXn+PRDgzwACcjAIMwBE8HrfP5xOa iTrzzH++4IILxhhSXWNZk/EA1lH9m5dGnwQeOgHL7y+XSnV74kAq9eiOHU8/W5u9 FQcx/qMYfT4W4xsOACdq7BckABgm0SOgL730sm9961tjDInFYsVisSbjASzFBpPA 9TwBqyqbybz+2msbNtVgb8UhcQ4WAMeiAANwBLkCXKlUHnlkh5E/xhxuP4JdNfok sK7rsXg8VMcTsAyFQiHo9992+1KhrxsFGIBjNeqrEQCMiFwBTqcz77777hhDUqlU LperyXgACyqXSk3NzWaPYpSSqZQWCuXreAJWVWDv3suuuMLldkmEU4ABOBYFGIAj yN2BNG3atJ07HxtjCNO/sLeGngQ2CnAwGCzqep2fqwYCNy26eZzMF41zsAA4VkO+ FAHASLW2ts6e3S2RfPzxn161atVYErLZbH9/f63GA1hTqVRqbsxJYKMA9/T0VMrl Oj83ommrVq+OxUXmaXt6/MlkUiIZACyOAgzAETo6Otrbp0skn3bad+bPnz+WBLnb jwDraNALgXVdTySTqqLU/9GJaPT+rVvffOtNiXCuAgbgWI33UgQAIyV6BPT5559/ 9tn/MupPLxaL7MSDQzRiB06mUuFIJJtO1//RxkOfemrXwzt2COWzDRiAMzXY6xAA jIJoAV6y5NYTTjhh1J8ej8f1uu8tBEzRoAVYVdVCPl//Rxfz+ffff3/FqpVC+RRg AM7UYK9DADAKcgW4VCo999zzLS0to07g+Cs4SsN1YKMABwKBkhl3dBeLxZCiLFx0 s9DeaQowAGdqpBchABgdj8c9a5bIEdCVyriXX3551J8+MDCQyWRqOB7A4srlclNT k9mjGIFEMtnT0zPOpF36wZ6ea667bvKUySLhwWAsxkHQAByHAgzA/lwuV3d3l0Ty zJmdW7ZsGfWnM/0Lp2ms+5B0XY8nEpqqmjWAUDC4ZOnSfEFkATbnYAFwpsZ4BQKA sZBbAn3iiV9ctGjR6D43l8ulUqnajgewvgaaBE6mUqFQKJfNmjWAvnD4nnXrgqrI GdQsgQbgTBRgADbn8bg7OzuF3nD/4Ac//NWvfjW6z+3r6yvX/WZRwHQNNAlsFGAl GDTxmLpUPP7wI488/+ILEuHG9x9VVVkFDcBpGuDlBwDGQvQI6N/97qLTTz99FJ9Y KpWi0WjNxwM0BOP3v9DBTrVlFOCenp6KeX9RVcjlXn7ppY33bhbKZxIYgANRgAHY nNfr8fmkCvCWLVtnzpw5ik9MJpN5My5WAaygIc6C1nU9kUyqisjy42GqlEohTVu4 6GahfEVRolEKMABnsfrLDwCMkdwMsFFi9+7tGd3ncvwVHM76HTiZSoXD4ayp57QX i8WIps2dd3FbW5tEPjPAABzI0q89ADB2brerq0vkCOjJk6fs2rVrFJ+YTqcHBwdr Ph6ggVj/KCyjAKuqWjB7pYbi9y9YuHDCxAkS4YFAIB7nIGgAzkIBBmBzcjPAn/jE n61du3YUn9jb21sx6VpRwCKsfxSWUYD9fn+5VDJ3GGFVvWPVqmQqKRHODDAAB7Lu Cw8AjN2MGe1tbW1Cx+18/evfuOKKK0b6WYVCgbs3AYPRLZusehSWruvVI6DNHsi4 eF/fvfff/86770iEl0qlvr6+cJgdGQAchAIMwM5Ej4A+77x/+9d//deRflYsFisW ixLjARqLlbcBG+03Eolk0mmzBzIuMzj41FNPPfLoDqF8JoEBOI1FX3gAoCZEj4Be terO448/fqSfxfFXwH6W7cAW2QBsKBYKe/bsWX7HCqF8DoIG4DRWfNUBgFqRmwHu 7e1VFHWk7937+/uz2azEeIBGZNmjsIwCHPD7S2ZvAB637yDosKr+du5FHR0dEvnM AANwGgowADtzu91dXbMkkidOnPTss8+O9LOY/gUOYsFJYOtsAK4K+v3X33BDy1Et EuGBQDAej0skA4A1WeslBwBqS24J9Mc+9ifr1q0b0afkcrlUKiUxGKBxWXAS2Dob gKvCirJ85cr+gX6JcJZAA3AaCjAA2xI9AvqUU0695pprRvQpfX19xnt9icEAjcuC M8DW2QBcFevt3XTvve+9/55EOAdBA3Aaa73kAEANeTzuWbNE1j8bzjnnp+eee+7w P96ovsa7TKHBAA3Nah3YOhuAqzKDg0888cTOxx8Tyg8Gg7EYq6ABOIWFXm8AoLZE 70BatGjxiSeeOPyPTyaTectMKAGWYqlV0FbbAGzQ8/ndu3evWn2nUD7nYAFwFAow ANuSmwEulUrPPfd8S8sIzqTh+CvgMKwzCWy033AkkrXMBuBx+w6CDinKwkU3C23o YAYYgKNY4sUGACTIHQE9fnzTiy++OPyPz2QyAwMDEiMB7ME6k8BW2wBcFezpufb6 64+efLREOAdBA3AUCjAA22ptbZ09u1siec6cORs2bBz+x/f29lYqFYmRAPZgqRlg f0+P1c6rCynKshXLB2XmpXt6/MlkUiIZACzIEi82ACChvb29o2OGRPJJJ518ww03 DPODi8Ui++uAI7JCB9Z1PZFMqopi7jA+LNbbu2Hjxj09eyXC/f5AIpGQSAYAC6IA A7An0ROwzjrr7J/97GfD/OB4PG68qxYaCWAbVlgFnUylQuFwLpMxdxgfNtjf//jj jz+x60mhfM7BAuAcFGAA9uT1enw+qQJ8ww0LTjrppGF+MMdfAcNR3SZg7iRw9fxn C/6NVSGXe/vtt9f8Ya1QvqIo0SgFGIAjUIAB2JPcEdDlcvnpp/84efLk4Xzw4OBg 2krHyQJWVi6VmmQOOh6mRDLp7+mx4I59o5OHVfWmxYuEJsk5CBqAc1CAAdiT3BHQ xnvjl19+eZgfzPQvMHzmbgM2SmY8kdBU1awBHF6wp+ea666bPGVYf/U2UhwEDcA5 KMAA7EluCfSsWbPuvfe+4XxkoVDgaBlgREzswMlUStO0fC5nytOPKBQM3rZsWTaX lQhnCTQA56AAA7Ahj8fd2dkptFbwf/7PkxYsWDCcj4zFYsViUWIMgF2ZeBSWUYAD gUDJqn9mo5HI+g0begJ+iXDjy66qKqugATgBBRiADVnkCGjWPwMjZdZRWLquV0/A qvNzh28gldq5c+dTf3xaKJ+DoAE4BAUYgA2JFuDrr7/h5JNPPuKH9ff3Z7MiixUB eyuVSs11PwrLaL/hcDhrvQuQ9hs6CPqtt9bc/QehfAowAIegAAOwISscAc30LzA6 pqyCHpr+VRS9UKjzc4dP1/WQotx8y2IOggaAsaAAA7Ahl8vV3d0lkTxhwoTnnnv+ iB+Wy+VSqZTEAAAnqP9RWJa9AOlAwZ6e629c0NLSIhHu9wc4tA+AE1CAAdhQd1eX y+2SSP6TP/nTe+6554gf1tfXVy6XJQYAOEGdLwS2+AVI+4UVZfnKlf0D/RLh3IQE wCEowADsxu12z5rlE5o++vrXv3HFFVcc/mOM6msUYImnAw5R5xlgi1+AtF+8r+/e ++9/5913JMKNr3kwqNCBAdgeBRiA3YiegHXBBb8488wzD/8xqVQqZ/l30oDF1bMD D12A5PeXSqX6PG7Usun0H//4x20PbxfK5xwsAE5AAQZgN6IFeMOGjXPmzDn8x3D8 FTB2dTsKa+gCpGRSUZQ6PGuMysWiEgwuvnWJUD4FGIATUIAB2I3b7e7qEjkCur+/ //339xz+Y7LZrPFhEk8HHKVuM8DJVCoUDucsfAHSfsViMaJpF8+f7/F6JPLZBgzA CSjAAOymtbV19uxuoeRHH915+I/h+CugVurTgY0CHAwGi7ou/aCaUAOBmxcvEjqr uqfHn0wmZbIBwCoowADspr19ekdHh0TyF77whaVLbz/MB5RKpWg0KvFowIHqsAp6 aP1zKqUEg6JPqaHeUGjNH9aGZfZZ+P3+RIICDMDmKMAAbEV0A/APfvDDX/3qV4f5 gEQiUSgUhJ4OOE31Vl7RSWCj/RplMptOyz2itlLx+MOPPPL8iy8I5bMNGIDtUYAB 2IrX6/H5pArwJZdc+u1vf/swH8DxV0BtlUqlZskLgYemfxVFb5y/t8pmMq+9+urG zZuE8o2vRjRKAQZgZxRgALbi8bhnzRI5AatSqTz22OPTpk37qA9Ip9ODg4MSjwYc S3oVdCKZ9Pf0VKeaG4Ku62ogcMtttwpNjAeDwViMc7AA2BkFGICtuFyu7u4uieRS qfzqq68e5gN6e3sb6G000BBEV0EbZTIWj4c0TSJcTqCn5+prr506dYpEuN8fSCQS EskAYBEUYAC2IrcHuLu7e9OmzR/1q8Y7aa4PASSUS6UmmVXQyVRKVdVCPi8RLicU DN6+Ynla5t4m9gADsD0KMAD7cLvdRvsVmiz6yle+ct1113/UrxrtV2+Qa1SAxiJ3 GdLQ+me/v9Jo95bFens3btr0/t4j3Ek+OsZX2+jA/HUeABujAAOwD9EjoM8556fn nnvuR/0qx18BciQ6cHXVhtZo658NmcHBJ554YufjjwnlMwkMwN4owADsQ7QAr1p1 5/HHH3/IXxocHEw3zjUqQMORWAXdoOufDcVCYc+ePcvvWCGUTwEGYG8UYAD24Xa7 u7pEjoCORmPBYPCjfpXpX0CUxAywUYD9PT3lRlv/bCgWixFN++3cuTNmtEvkBwJB lkADsDEKMAD7kJsBnjx5yq5duw75S4VCgUNTAWm17cBD658TCU1VaxVYZ4rfv2Dh wgkTJ0iEMwMMwN4owABswuNxd3Z2Cl0Z+pnPfPaOO+445C8Z7xSLxaLEQwHsV9sL gRt3/XNVRNNW33VXXywqEW58qY0vDrcBA7ArCjAAmxDdAHzGGf/461//+pC/xPpn oA5qOwPcuOufq1Lx+Lbt2198+SWhfCaBAdgYBRiATYgW4Msvv+Ib3/jGh39+YGAg I3MbJ4CD1KoDN/r6Z0Muk3n99dfXb9wglE8BBmBjFGAANiF3Ala5XN6166mpU6d+ +JeY/gXqplaroBt9/fO4fR0+FAzevOQWoU0fnIMFwMYowABswuv1+HwiM8ATJkx4 7rnnP/zz+Xw+mUxKPBHAh9VqBrjR1z9XBf3+6xfc0NLSIhGuKEo0ygwwAHuiAAOw A4/HPXPmzOZa3xRa9YlP/NnatWs//PPRaLRUKkk8EcAhjb0DD61/jsc1TavVkMwS UdUVq1YlUyJ/B2d8ZzO+RJyDBcCWKMAA7EB0A/Df/d3fz50796CfNN6I9/b2Cj0R wCGNfRW0DdY/VyVjsa0PPvja668J5bMNGIBdUYAB2IFoAf7d7y46/fTTD/rJ/v7+ bDYr9EQAhzTGGWBd14cKsKIYOTUclSkyg4Mvv/zyfVvuF8qnAAOwKwowADuQOwHL eKP86KM7XS7XQT/P8VeAKcbSgY32a/zJzaTTtR2SKQqFghII3Lr0threDnUgzsEC YFcUYAB20NraOnt2t0RyuVx55ZVXDvrJXC6XSqUkHgfg8MayCtoowIqi6IVCbYdk lmBPz9XXXTdlymSJ8J4eP4f8AbAlCjAAO2hvb+/omCGRfNxxx61ff/Blm319fY1+ hCzQoKqrl0cx7Vld/2wU4HGNv/65Kqwoy1asGEgPSoT7/YFEIiGRDADmogADaHii G4C/+c1vXXbZZQf+jFF9jQIs9DgAR1QqlUZx5LvRfsPhcDaTkRiSKeJ9ffdv2fLW O28L5bMNGIAtUYABNDzRAnzhhb/80Y9+dODPpFKpXC4n9DgARzS6VdBGAQ4Gg0Vd lxiSKQb6+59/7rltD28XyqcAA7AlCjCAhufxuGfNkjoB64EHHuzo6DjwJzn+CjDX KFZB67qeSCZVRREblAny+bx/z55ld6wQOgcrGAxyFTAA+6EAA2h4Lldrd7fICVj5 fOHNN9888Gey2Wx/f7/EswAM30hXQSdTqVAolLPd1WXBvXsvv/rqadOOlQj3+/2J BOdgAbAbCjCAhjdjSLtEss/nu+++/+uaTY6/AqxgpKugjQJs1LlyqSQ3JFOEgsHb lt2eldmUwTlYAGyJAgygsYluAP7qV0+59tpr9/9jqVSKRqNCzwIwfCNaBa3rejyR 0FRVeFAmiPX2btq8+b097wvlsw0YgP1QgAE0Nq/X4/NJFeDzzz//7LP/Zf8/JpPJ fD4v9CwAIzL8VdDJVEpV1YId//Bm0+mnntr18I4dQvmKokSjFGAAtkIBBtDY3G53 V5fICViGDRs2zpkzZ/8/cvwVYB3DXAVdvf5XVZSKXa7/PVC5WFSCwcW3LhHKDwSC 8TjnYAGwFQowgMbm9Xp9vk6J5MHB9O7du/f/YyaTGRgYkHgQgFEY5ipoo/1GIpFM Ol2XQdVbsVgMq+r8yy5zu10S+Yqisu8DgM1QgAE0MOM9n8/nG8WNoMMxY0bHAw88 sP8fe3t7bTmDBDSu4ayCtt/1vwfRAoElS5cW9IJEeLlcVhQlHucoLAD2QQEG0MBE T8A6+eSvXH/99dUfF4tFToIBrOaIq6Btef3vQWK9vRs2bdqzd49QPudgAbAZCjCA BiZagC+44Bdnnnlm9ceJRKJQEJlgATBqlUrl8Eugk6mUpml5mVuCLKI/lXrmmWd2 PCp1DhYFGIDNUIABNDC5E7CMN9Zbtz4wc+bM6j9y/BVgTYfvwEPX//b02PvubqPe 9+zZs3zlHcO8FGqkOAcLgM1QgAE0MLkZYF0vvv7669Ufp9PpwcFBiacAGKPDrILW dT0Wj4c0rc5Dqr/A3r1XXXvtMcdMlQhnBhiAzVCAATQqj8ft8/mEJj2OO+649es3 VH/M8VeAZR1mBjiZSimKojtg80JYUZatWDGQFvl7OuMrbHwZYzEmgQHYBAUYQKMS 3QB82mnfmT9//jiOvwIs75AduHr9rxIMmjKkOktEo/dv3frmW28K5TMJDMBOKMAA GpVoAf7d7y46/fTTjR/E43HdvheoADZwyFXQRvsNhUK5bNaUIdVZZnDw5Zdfvm/L /UL5FGAAdkIBBtCo3G5XV1eXRLLxfvrxx5+YNm3aOI6/AizvkDPARgEO+P2lUsmU IdWZrutqILD41iVCl6IHAgGuAgZgGxRgAI3KaL9GB5ZInjhx4rPPPmf8YHBwMJ1O SzwCQA0d1IGNQhiPxzUHHH+1X9Dvv2HBDZNaWiTCOQgagJ1QgAE0JNH1z8cf/+lV q1aN4/groEEctAraOcdf7RfRtFWrV8fiUguVWQUNwDYowAAakmgB/l//6wf/8R// UZ1EEnoEgBo6cAbYUcdf7ZeKx7c//PALL70olE8BBmAbFGAADcnjcc+aNUso/Lrr rv/KV75ivNsrFotCjwBQW/s7sKOOv9qvkM2+9fbba+/+g1B+MBjkJiQA9kABBtCQ XK7W7u5uieTe3r69e/dOmjSJ46+ABrJ/FbRRgP09PcY/mj2iuioWi2FV/e3cuR0d MyTy/X5/IpGUSAaAOqMAA2hI7e3TOzo6JJKPPfbYxx57nOOvgMZSnQHWdT0Wj4ec dPzVfmogsPDmm8c3iby1owADsA0KMIDGI7oB+IQTTliy5Famf4GGY3TgVH9/MBgs OvLu7r5w+O577lbEyj/bgAHYAwUYQOMRLcBnnXX2T3/600SCSy+BBpPP5VIDA6qi mD0Qcwz29z/++ONP7HpSKJ8CDMAeKMAAGo/b7erq6hIKv+uuNdOnT+f4K6DhJJLJ UChk1GCzB2KOkq7v3bv39uXLhPIDgUA8zt8MAmh4FGAAjWf27NmtrdMkkgcGBt57 733WPwMNp3r7kaoojr27u1gsRjTt4kvmezweifxAIMjNcABsgAIMoMG43e6uLqkL kGbM6Lj77rszmYxQPgAhRvsNh8NZZ//h1QKBJUuXFvSCUD4dGIANUIABNBjRDcBf /eopv/rVr4TCAcgxCnDA7y+VSmYPxEyx3t5Nmze/t+d9oXy2AQOwAQowgAbj8bhn zZKaAb7gF//7m9/4hlA4ACG6rsfjcc2Rtx8daLC///nnn39o+zah/GAwGIsxAwyg sVGAATQYr9fr83VKJJfL5fXrNxxzzDES4QDkJFMpx95+dKBCoaAEAktuu7WpqUki X1HUaDQqkQwAdUMBBtBIPB53Z2en0Hu7SZNa7r33XolkAHJ0XU8kk469/eggit9/ /Y03Tpo0USK8XC6rqsokMICGRgEG0EhENwB/+tOfufrqq4XCAQgZOvxZVQv5vNkD sYRIKLR27dpwr9RR9mwDBtDoKMAAGonoBuAzzvjHs846SygcgARuPzrIQCq1c+fO p/74tFA+24ABNDoKMIBG4nK5uru7hMKvuvqaz3z600LhACQY7TcUCuWyWbMHYhUl Xe/Zu3fp8mVC+X5/IJFICIUDQB1QgAE0Ep+v0+v1SiQPDAzu3Llz4kSRjXMAJFSn fzVVLZfLZo/FKorFYlhVL7388lZXq0R+IBCIxynAABoYBRhAwxDdADxzZueyZVJz JgAkGO03HIlk02mzB2ItIUW5ffnydEbqy8I2YAANjQIMoGF4vR6fT6oAn3rq3154 4YVC4QAkGAU44PeXSiWzB2ItiWh0y9atb7z1plC+oijRKAUYQKOiAANoGG63u6tL 6gSsX//6v0466SShcAA1p+t6PB7XNM3sgVhONpN57dVXN27eJJQfCASNr7xQOABI owADaBhyS6BLpdKatX/wejwS4QAkJFOpYDBY1HWzB2I5uq6HFOWmxYuam5sl8lkC DaChUYABNAaPx+3z+caPF/mu1dLSsm7dek7AAhqF0fESyaSqKGYPxKLUQOCmRYuE 3uVVKhVFUbgMCUCDogADaAyiG4C/8IUvXHrpZULhAGquevdvoVAweyAW1ReJrFu3 LqAEhfLZBgygcVGAATQGj8c9a5bUBuCzzjr7jDPOEAoHUFtM/x5RKpl8+umnH3v8 MaH8YDDIDDCABkUBBtAYvF6vz9cpkVypVBbfsuS4OXMkwgHU3ND0r6oW8nmzB2Jd +VyuZ8+e5SvvENo2oihqNBqVSAYAaRRgAA3A43F3dnY2NTVJhBcK+kMPPcQGYKAh 6LpuFGBFUcZVKmaPxdKCPT1XX3fdlCmTJcLL5bKqqkwCA2hEFGAADUDu/GfDccd9 bNGiRULhAGrLaL+apuVzObMHYnURVV15553xZEIon7OgATQoCjCABiBagL/3vb87 99xzhcIB1FB1+ldVlArTv0eSise3P/zwCy+9KJRPAQbQoCjAABqAy+Xq7u4SCr/i iis/97nPCYUDqCGj/YZCoVw2a/ZAGkAhl9v97rt3rrlLKN/vDyQSUtPLACCHAgzA 6qZOnWLo6OiQCI/FYtsffqR12jSJcAA1VJ3+1VS1XC6bPZYGUCwWI5r2+/nzvF6v RL7f7zf+iwwOpiXCAUAOBRiA1Ymuf3a53CtXruQELMD6jPYbDoezmYzZA2kYoWBw ydKl+YLUcdmsggbQiCjAAKxOtACfcsqpv/zlL4XCAdQK07+jkIhG79+y5c233xLK pwADaEQUYABWJ7oB+Ne//q+TTjpJKBxArTD9OwrGl+u1V1/duHmTUD7bgAE0Igow AKubMaRdIjkcjux49FG3yyURDqBWPpj+1bRyqWT2WBpJsVgMKcrvfv/7jo4ZEvkU YACNiAIMwNK8Xo/PJ7X+ecqUqWvXrmUDMGBxQ9O/kUg2zXlLI6YGg4tuuaVclvqL A0VRolFWQQNoJBRgAJYmugH4i1/8m4suukgoHEBN6Lqe6u/XVLXE9O/IxXp7N23e /N6e94Xy2QYMoOFQgAFYmugG4Asu+MU3v/lNoXAANZFMpSKRSIbp31EZHBh48YUX HnjoQaF8VkEDaDgUYACWJrcBuFwur7pzdfv06RLhAGqC6d8xMr6AaiCw+NYlTU1N EvkUYAANhwIMwLpE1z9PmDBx48aNbAAGrIzp37FTAoEbb7qpuVmkAI9jFTSARkMB BmBdogX4f/yPv7zkkkuEwgGMHdO/NRGNRNatX+8PBoTyKcAAGgsFGIB1iW4APvfc 8773ve8JhQMYO6Z/a2Kgv/+5Z5/d/sjDQvmsggbQWCjAACxq6tQpU6ZMFbq+slwu 37FyVccMkXAAY8f0b63ohYISCNxy261y24B1vTA4yN9TAGgMFGAAFsUGYMDJuPu3 htgGDAD7UYABWJTH4541a5ZQOBuAASvTdd0owJqmlZn+rQX5bcDBWCwuFA4AtUUB BmBRbW3ezs5OoXA2AANWNjT9Gw5nMxmzB2IT0tuAVVXt64sKhQNAbVGAAViRx+Oe OXNmc3OzRDgbgAEr+2D6V1WNP6pmj8UmpLcBl0olTdOYBAbQECjAAKyIDcCAYzH9 K4FtwABQRQEGYEVsAAacielfIWwDBoAqCjAAK/J6vT4fG4ABxzHabygUymWzZg/E bqS3ASuKGo2yDRhAA6AAA7Act9vl8/mE9qqVy+WVq+6c0d4uEQ5gLKrTv6qiVCoV s8diN8bXVvH75bYBG99aFUWJxxMS4QBQQxRgAJYjugG4paVl3br1bAAGLKh69VE+ lzN7IPakBgI3LVok99aPbcAAGgIFGIDluN3uri6pDcAnnvjFuXPnCoUDGLWh6d9k UlHVcUz/yoj19m7ctOn9vXuE8gOBYDzONmAAVkcBBmA5Xq/H55OaAb7wwl+eeuqp QuEARm1o8bOqFvJ5swdiW5nBwZdffvm+LfcL5SuKEo0yAwzA6ijAAKzF43Eb7Xf8 eJHvTuFw5OFHHvF6PBLhAEZN1/VEMqkqitkDsTPjixxSlIsuvrijQ+QW9EqlYnRg zoIGYHEUYADWIroB+Nhjp61evZoNwIDVJFMpozvphYLZA7E5LRi85dZb9aIulM82 YADWRwEGYC2iG4BPOeXUX/7yl0LhAEZH1/V4IqGpqtkDsb9ENHr/li1vvv2WUD7b gAFYHwUYgLV0d3W53C6h8Llzf3/iiScKhQMYnWQqFQwGi7rUtCT2y2ezb7zxxj3r 1wnlU4ABWB8FGICFiK5/jsVi27Y/7GptFcoHMAq6rsfi8ZCmmT0QRygWi2FVvfiS +V6vV+gRrIIGYHEUYAAWIlqA29rali1bzgZgwDqGrj5KpYz2WyqVzB6LU4QU5fbl y9KZjFA+BRiAxVGAAViIy+Xq7u4SCv/mN791wQUXCIUDGAWj/YbD4axYGcOHpeLx h7Zte+mVl4Xy/f5AIpEQCgeAsaMAA7CKqVOnTJkyVeh+DsNll13++c9/XigcwEhV p39VVa2Uy2aPxUGKhcL777+/YuUdQvlGAdb1wuBgWigfAMaIAgzAKkTXPxvvxu7f sqV12jShfAAjZbRfLRTKZ7NmD8RZisViRNMuv/LKY449RugRrIIGYGUUYABW4fG4 Z82SugBp9uw5CxcuZAMwYBFD07/J5ND0b6Vi9lgcxyjAq1avjsWlOmowGIzFOAsa gEVRgAFYhdfr8fmkZoB/9KMf/fjH/yQUDmCkqoufC/m82QNxomQ8/uSTT+x6+mmh fEVRolFmgAFYFAUYgCV4PEb77Rw/XuSbUqVSuWXJrXNmz5YIBzBSuq7HEwlNVc0e iEPl83n/nj3L7lgh9y1XUVRWQQOwJgowAEsQ3QBsvMm79977WP8MWIHRflP9/SFN KxaLZo/FuRS//4YbF0ycNEkon23AACyLAgzAEtxuV1eX1AVIX/jCFy699DKhcAAj kkylIpFIJs0pwWbqi0TWrVsXUIJC+YFAIB7nMiQAVkQBBmAJPl+n1+sVCv/Zz37+ 7W9/WygcwPBVrz7SVLXM1UemGuzvf+GFFx7c9pBQPgUYgGVRgAGYT3T9c6lUWn3X multbUL5AIbPaL+hUCjH1Udm03VdCwZvvmVxc3Oz0CNYBQ3AmijAAMwnegHS1KlT 16xZywZgwHRcfWQpRgFevOSWYqkklM9lSACsiQIMwHxer9fn6xQK/+pXT/nVr34l FA5g+Lj6yFIS0eiWrVvfeOtNoXxFUaPRqFA4AIwaBRiAyTwed2dnZ1NTk1D+vHnz TzjhBKFwAMPE1UdWo+fzu3fvXrX6TqH8crmsqiqTwACshgIMwGSiG4AHBga3bN3a Om2aUD6A4ahefaRpWomrjyyjWCxGNO3SK66YNu1YoUewDRiABVGAAZjM7XZ3dUlt AJ4957iFN97IBmDAXMlUKhwOZzMZsweC/4tRgO+8665oTGqhciAQjMeZAQZgLRRg ACbr7u52uVqFwv/pn37ywx/+UCgcwHBUrz5SFYWzr6wmlUzuevLJJ3Y9KZRPAQZg QRRgAGYSPf+5XC7fvmz5LJ/U+moAw8HZV5ZVKBSCPT233r5U7hQGzoIGYDUUYABm Et0A3NLSsm7detY/AybSdT2RSKicfWVVaiBw06JFcu8H2QYMwGoowADM1Nbm7eyU ugDpy1/+n7/5zW+EwgEcUfXsq1AoVNR1s8eCQ4v39W26997d7+0WyldVta+Py5AA WAgFGIBp3G63zyd4AdJFF8394he/KBQO4IiSqVQkEsmk02YPBB8pn8m8/sYb6zas F8ovl8uKorITGIB1UIABmEZ0/XM8kdy2bRsXIAFmqZ59pamqUYHMHgs+0tBlSKp6 8aWXejxuoUewChqApVCAAZhG9AKkmTM7lyxZwgZgwCxD7VfT8rmc2QPBEYRVdcXK lan+lFA+Z0EDsBQKMADTiM4Af//7Z5x99tlC4QAOj7OvGkgiFtv52M5nn3tOKJ8Z YACWQgEGYA7RC5Aqlcqixbd87LjjhPIBHEb17CtN00rFotljwZHlcjn/nj3LV94x frzU20IuQwJgHRRgAOYQnf413sbde+99rH8GTJFMpcLhcDaTMXsgGC7F77/hxgUT J00SymcSGIB1UIABmEP0AqS//MsT5s+fLxQO4DCqZ1+pilKpVMweC4YrGoms37Ch J+AXyucyJADWQQEGYAKPx220X7kLkC688JennnqqUDiAwxhqv6payOfNHghGIDM4 +PLLL9+35X6h/HK5bPyuYBU0ACugAAMwgej6597evocfecTtcgnlA/gouq7H43FN 08weCEamWCyGFGXuvHnt7dOFHsEqaAAWQQEGYALRC5Da2tqWLVvOBmCgzj64+FfT yqWS2WPBiIWCwdtXLE+L7dzmMiQAFkEBBmCCzs6ZRk0VCj/ttO+cf/75QuEAPorR fkOhUC6bNXsgGI1Yb+/2Rx555dVXhPIDgUA8nhAKB4DhowADqDfR9c+VSuXa664/ /lOfEsoHcEhDF/8mk6qimD0QjFI2k3nv3XdXr10jeRkSq6ABmI8CDKDepAvw/fdv Yf0zUE/Vi39Dmlbk4t9GFvT7b1hww6SWFql8CjAAC6AAA6g3r9fj80kVYC5AAuqP i3/tQfoyJEVRolEKMACTUYAB1JXHY7TfTrkldv/xH//5la98RSgcwIdx8a9tZNPp V155ZfN99wrlG79DFEVlEhiAuSjAAOpKdP1zPB5/aNt2V2urUD6ADzPar6IoeqFg 9kAwVsViMayq8y65xOP1CD2CVdAATEcBBlBXbW1tnZ0zhcI7O3233HILG4CButF1 PRaPh7j41y6MAnzHypXJ/pRQvqpqfX19QuEAMBwUYAD14/G4Z86c2dzcLJT/ox/9 6Mc//iehcAAH+eDiX1Utl8tmjwW1kYzHn3zyiV1PPy2UXyqVNE2LxbgQGIBpKMAA 6kf0+CvjLfjSpbd3dXUJ5QM4yNDWX1Ut5PNmDwQ1Y/zXDPT03Lbs9qamJqFHcBQW AHNRgAHUj9vt7uqaJRR+1NFH33P3Pax/BupD1/V4IqGpqtkDQY2pgcDNtyyWO9Is EAjG48wAAzANBRhA/cyePbu1dZpQ+Mknf+U///M/hcIBHOiDxc+aVi6VzB4LaiwR jd6/Zcubb78llE8BBmAuCjCAOhE9/9kwb978E044QS4fwH7V9pvP5cweCGpPz+d3 7969avWdco/gLGgAJqIAA6gT0QKczmTvu+++1mlS08sA9mPxs70Vi8WIpl1x1VVT j5kq9AgKMAATUYAB1InX6/X5OoXCP/7xT1x77bVsAAakVRc/hzStxOJn++oNhdb8 4Q/hSFgoX1HUaDQqFA4Ah0cBBlAPHo/b5/ONHy/1Pee88/7tu9/9rlA4gP2G2m8o lMtmzR4IBA309z/37LPbH3lYKL9SqSiKwmVIAExBAQZQD6LrnyOR3m3bt7d5vUL5 AKp0XU8kEiqLn+3O+A8dUpS58+bNmNEu9AhWQQMwCwUYQD20tbV1ds4UCvd6vcuX r2D9MyDqg8XPoVCpWDR7LBAXCgaXLl+WEZvqV1Wtr69PKBwADoMCDECc2+022m9z c7NQ/ne/+73zzjtPKBxAFYufHSXe1/fwjh0vvfySUH6pVDI6MPchAag/CjAAcV6v x+eTWv9cqVRuXHjTJz7+caF8AONY/Ow8uWx2z3vvrVx9p9zZDYqiRKOsggZQbxRg AOLcbndX1yyh8PFNzfdu3sz6Z0AOi5+dSfH7FyxcOGHiBKH8QCDIDDCA+qMAAxDX 2Tmzra1NKPzEE784d+5coXAA41j87FSx3t4Nmzbt2btHKD8QCMTjCaFwAPgoFGAA skTPfzZcdNHcL37xi3L5gMOx+Nmx8pnM62+8sW7DerlHcBY0gPqjAAOQ5fG4Z82S Wv+cSvU/8OCDrdOmCeUDDsfiZycrFothVb308stbXa1CjwgGg9wGDKDOKMAAZInO AH/sY39yww03sAEYEMLiZ4frDYVWr1nT29crlM8MMID6owADECS9/vmnP/3//v7v /14uH3AyFj9joL//2WeeeXjHI3KPoAMDqDMKMABBouufI5Hebdu3t3m9QvmAk32w +FnTSqWS2WOBaYzfBiFFmTtv3owZ7UKPYBU0gDqjAAMQ5PV6fb5OofDp7e23L72d 9c+ABKP9apqWz+XMHghMZhTgZSuWD6bTQvmKokajUaFwAPgwCjAAKR6Px2i/48dL fZ/5/vfPOPvss4XCASfTdT2eSGgsfsa4cYlYbOdjO5997jmh/EqlYnRgVkEDqBsK MAApohuAy+Xyrbctnd3dLZQPOFZ18bPRfo0/ZWaPBebL5/OBvXuXLl/W1NQk9Ai2 AQOoJwowACltbW2dnTOFwo86+uh77r6H9c9AzRntV1XVQj5v9kBgFWogcPMtiyuV ilS+qvX19QmFA8BBKMAARLjdbqP9Njc3C+WfeurfXnjhhULhgGPpuh6Lx0OaZvZA YCF94fADDz301ttvCeWXSiWjA8fjHIUFoB4owABEiK5/rlQqV1519ec++1mhfMCZ WPyMQ8qk0++8/fYf7rlb7kwHVkEDqBsKMAARbre7q0vqAqRypbLl/i2sfwZqyGi/ qf7+cDisFwpmjwWWE+zpuf7GBS0tLUL5gUCQGWAA9UEBBiCis3NmW1ubUPhf/uUJ 8+fPFwoHnCmZSoUjkazYbTdoaNFIZP2GDT0Bv1B+IBCIxxNC4QBwIAowgNoTXf9s +M1vfvvlL39ZLh9wGl3XE8mkpqpyBx2hoWUzmddfe23Dpo1yj2AVNID6oAADqD2P xz1rltT651Sq/4EHH2ydNk0oH3Ca6uLnUChU1HWzxwKLKhaLYVW95PLLXa5WoUcE g8FYjFXQAMRRgAHU3uzu7laxN0lz5hx34403sgEYqJVkKmW031w2a/ZAYGkRTVt9 1119sahQPtuAAdQHBRhAjUmvfz7nnJ+efvrpcvmAowwtfk4kVFU1eyCwuv5U6pln ntnx6A65R7AKGkAdUIAB1JhoAY5Eerdt397m9QrlA45SvfcopGmlUsnsscDqjN8t IUWZO2/ejBntQo+gAAOoAwowgBoTLcBtbW3Lli1n/TNQE0O3/mpaPpczeyBoDEYB vn35snQmI5RPAQZQBxRgALUkvf759NP/n3POOUcuH3AOXddj8XhI08weCBpGIhrd sXPn8y88L/cIOjAAaRRgALUkev5zuVxecuttc2bPFsoHnKO6+FlV1Uq5bPZY0DDy +bx/z57bVyxvamoSegRnQQOQRgEGUEter9fn6xQKP/royXfffTfrn4Ex4t4jjJoa DC5avKgsdl+0oqjRqNRB0wAwjgIMoIY8HrfP5xs/Xuoby9e+9vV///d/FwoHnGPo 4KtwOCe2kxM2Fo1EHty27Y033xDKr1QqiqIwCQxADgUYQM2IbgA23hVdf8OCP//k J4XyAYfg3iOMRTaTeX/37jvX3CX3d51sAwYgigIMoGba2rydnVLrn8c3Nd+7eTPr n4GxqG791TStzL1HGC3F71+wcOGEiROE8lVV7etjFTQAKRRgALXhdrt8Pp/cyShf +tKXf/vb3wqFA05Q3fobiUQK+bzZY0EDi/f13Xvffe/sflcov1wuK4oSjyeE8gE4 HAUYQG1IX4A0b978E044QS4fsL1kKmW030w6bfZA0Nj0fH737t2rVt8p9whWQQOQ QwEGUBttbW2dnTOFwnO5/KbNm1unTRPKB2xvaOtvMqmpakXs/F44RLFYjGjaVdde O3ny0UKPUFWtr69PKByAw1GAAdSAy+Xy+Tqbm5uF8j/9mc9edumlbAAGRod7j1Bb 0Uhk3fr1/mBAKL9UKimKmkiwChpA7VGAAdSA1+vx+QTXP//udxf9zd/8jVw+YG9D 9x6FQrls1uyBwCZymczrr7++fuMGuUcoihKNsgoaQO1RgAHUgNvt7uqaJRTe3z+w 9YEHWP8MjI6u6/FEQuPeI9ROdRX0JZdf3toq9Z05EAjG49wGDKD2KMAAxmrq1CnH HHNse/t0ofw//dOPX3fddax/Bkbhg3uPVLVcLps9FthKbyi0Zu3acG9EKN/vD+h6 YXCQM9sA1BgFGMBYSZ///POfX/Ctb31LLh+wqw/uPQqHC4WC2WOB3QwODLz4wvMP PPSQ3CM4CxqABAowgLESXf9svPt5aNt2t8sllA/YWDKVCkciWe49goBisRhSlHmX XuL1eoUewSpoABIowADGapbP5/F6hMJ9vlmLFy9m/TMwUtx7BGkRVV2xalUylRTK DwQC8TgHQQOoMQowgDGRXv981llnn3HGGXL5gC1Vt/6GQqFSsWj2WGBbqWTy6aef fuzxx+QewSpoADVHAQYwJh6Pe9YsqfXPoVB4+8MPT29rE8oHbOmDrb+RSCGfN3ss sDPjd5oaCPx+/vyOjhlCjwgGg7EYq6AB1BIFGMCYdHd3u1ytQuFtbW3Lli1n/TMw IslUymi/Gbb+Ql5IUW5fviydyQjlsw0YQM1RgAGMnvT65zPO+MezzjpLLh+wH7b+ op4Ssdhjjz32zHPPyj2CVdAAaosCDGD0RNc/l8vlpUtv7+rqEsoH7Ietv6izQj4f 2Lv3tuXLmpqahB7BKmgAtUUBBjB6ojPAU6dOXbNmLeufgeEz2q+maflczuyBwEG0 YHDxkluKpZJQPjPAAGqLAgxglKTXP5922nfOP/98uXzAZnRdj8XjIU0zeyBwllhv 7/ZHHnnl1VfkHkEHBlBDFGAAoyS9/nnR4lv+5GMfE8oHbGZo8XMyqbL1F3WXy+V6 3n9/+co7WAUNoCFQgAGMkugMcEvLUevWrWP9MzAc1a2/4XC4qOtmjwVOpAYCNy1a JPemkhlgADVEAQYwGqLTv4avfe3r//7v/y6XD9hJ9eCrXDZr9kDgUNFI5MFt2954 8w25RzAJDKBWKMAARkN0+rdSqVx/w4I//+QnhfIBO9F1PR6Pa2z9hXmymcz7u3ff ueau8eOl3lgyCQygVijAAEbD6/X4fFIFeMKEiRs3bmT9M3BE1cXPmqqWy2WzxwJH U/z+G2++ublZahuwoijRKAUYQA1QgAGMmMdjtN9Oub/pP+mkk3/9618LhQO2YbTf VH9/KBRi6y9M1xcO379167u73xXKr1QqiqIyCQxg7CjAAEZMev3zFVde9Ref+5xQ PmAbbP2FdWTS6XfeeusP6+5hFTQAi6MAAxgxr9fr83WKxY+/7777WP8MHN7Q1t9E QlNVswcCfEDx+6+/8cZJk6S+eyuKGo1GhcIBOAcFGMDIeDxun88n93f8X/rSl3/7 298KhQP2wNZfWFC8r2/T5s27339PKH/fKmiFs6ABjBEFGMDIiK5/Nlx55VWf/exn 5fKBRlfd+hsOhXS2/sJK9Hz+3XffvfOu1XKPYBU0gLGjAAMYGdH1z7lcftPmza3T pgnlAzbA1l9YU7FYjGjaVddeO3ny0UKPYBU0gLGjAAMYAen1z3/xF38xb958NgAD H4Vbf2FlsUhk/caNe/09QvmsggYwdhRgACMgvf754ovn/dVf/ZVcPtDQ2PoLi8tn s2+++ebd6+6RewSroAGMEQUYwAi0tXk7O6XWP6fT6fvu38L6Z+CQuPUX1lddBX35 VVcec8wxQo9QVbWvj1XQAEaPAgxguDwej8/XKbf++VOfOv6KK65g/TNwSGz9RUPo C4fvWbcuqCpC+ftWQatMAgMYNQowgOGSXv/861//10knnSSXDzQutv6iUWTT6Vdf fXXTvZvlHsEqaABjQQEGMFyi659Tqf4HHnyQ9c/Ahw1t/U0mVVWtVCpmjwU4gmKx GFbVSy+/vNXVKvQIVkEDGAsKMIBhcbvdPl9nU1OTUP7HP/7xa6+9jvXPwEGqB1+F QyGjV5g9FmBYekOhNX9YG45EhPLL5bKiqPE4Z0EDGA0KMIBhkV7//Itf/O9vfOMb cvlAgxo69lnT8rmc2QMBhmtwYOClF1/c+uADco9gFTSAUaMAAxgW0fXPiUTywYce crVKrZcDGpSu67F4PMTWXzSUYrEYUpRLLr/c7XYJPYJV0ABGjQIM4MiMNzE+n09u /fNxx31swYIFrH8GDmS030QyqbH1Fw2oV9PuXLOmL9onlL9vFbQSjyeE8gHYGAUY wJFJr3/++c8v+Na3viWXDzSc6tbfUChUYusvGtDgwMCLLzz/wEMPyT2CVdAARocC DODI2traOjtnCoXH4/GHtm1n/TOwn9F+U/39vb29bP1Fg6qeBT3vkks8Xo/QI1RV 6+uTmmEGYGMUYABHIH3+8+zZcxYuXMj6Z2C/ZCoViUQy6bTZAwFGL6Jpq1avjsWl Jmk5CxrA6FCAARyB9Prn8877t+9+97ty+UBjYesv7GGgv/+5Z5/d/sjDco9gFTSA UaAAAzgC0fXP0Whs2/btbpfUSaFAY/lg66+mlUols8cCjEn1LOiLL5lvvIgIPYJV 0ABGgQIM4HA8HvfMmTObm5uF8ru6um+++WbWPwPj/nvrbyQSKeTzZo8FqIGIqq5c vTqekFqlXCqVNE2LxVgFDWAEKMAADkd6/fM55/z09NNPl8sHGkgylQqHw9lMxuyB ALXRn0o988wzOx7dIfcIVkEDGCkKMIDDEV3/3NcXfWjbNq9H6oxQoIHouh5PJDRV NXsgQM0Yv6v3rYK+ZPp0VkEDsAoKMICP5Ha7jfYrt/65s9N3yy23sP4ZqG79Ndpv uVw2eyxALYVV9Y6VK5P9KaH8UqlkdGDOggYwfBRgAB9Jev3z2Wf/y/e//325fKAh VLf+hkMh4wdmjwWosf5U6umnn9r52GNyj2AVNIARoQAD+Ehut6urq0soPBLp3bZ9 e5vXK5QPNIqhY59DoVw2a/ZAgNqrroKeO2/ejBntQo8IBALxeEIoHID9UIABHNqk SRNdLndHxwyh/I6ZnbcuWcL6Zzjc0NbfeFzTNLMHAkgJK8rylSv7B/qF8v3+QDo9 WCiwgALAsFCAARya9Prnn/zkJz/4wQ/l8gHrG9r6m0yqmlZh6y/sK5VMPrXrycef fFLuEayCBjB8FGAAhya6/jkcjmzbvn16m9S5oID1VQ++CodCxWLR7LEAgozf6mog 8Pv58+WWFLEKGsDwUYABHMKkSZNcLpfcm5X29hlLly5l/TMcq3rwVW9vbz6XM3ss gLiwoixbsWIgPSiUv28VdLpQKAjlA7ATCjCAQ2hvn97R0SGX/6Mf/b8//vGP5fIB i0umUpFIJJNOmz0QoB4G+/ufeOKJx598Qu4RoVAoEumVywdgGxRgwIm8Xo/xv5XK 0I8nT57s8bjrPIDlK+7omCE1vQxYnK7riWRSU9VK9Q8hYHcTm5vj0ehlV11Z5+cG AsHx44fe6+77n3HRKPuEAVCAAbtzu13j9zHeaRvvtsvl8tFHHz19elv1PYFZ1v7h 7tZp00wcAGCW6tbfkKaVSiWzxwLUScukSQPJ5Nz580wcg/EK2Nvbl81mm5qa9r0q Dv2Mgc3DgNNQgAG78Xg81R8Yr+vGK3xn50zjxd7cIX3YggU3HjttWnNzc9M+1Yq+ /1enTJ7M9mDYUnXrbyQSKeTzZo8FEFTtlsYPSqVSuVye0NQUj0avu3GB2eM6mDE2 VdWqL5fVn+E0acD2KMBAw/N43NUJXuOFfPLko71er7mzu8PxyU9+cvr0dqMDT548 +aijjpo0aZLReCdOmtRimDRpxowZbperoOsTJkwwSnL1U2jFsIGhY5/D4WwmY/ZA gNowqmOxWDRarq7rhf/WMnFiuVIx/jlfKOSy2cF0enBgQFXVd9/bbfZ4j8D41wkG g8br6b6/mR36x1gsbvagANSY1d8lA/go1Zleo+vOnNlhwTnewwuHI8abi4n7eq/R cof+t7l5UsvQ/xmVuKOjo9XlMrrwtNbWY445ZsrUqVOmTOmYMWPyvg5sOLDhG29Q jG5sVGgT/3WA4TAaQjyR0FTV7IEAR1advz3om225XDbqrvE72ai1Q2uJx4/P5nID AwOpZDIej8fi8WQymcvlSuVSUf+gFRsfP9SJdb1cKrXPaDfvX2g0jH9fTQtVvxTM DAO2QQEGGkm19BpvQlpajjJ9H2+tHHgOUPXHkXB4fFPzpH2OPvooo/dOnXpMe3u7 y+XytrW53e7q1HHLvtJrfMrMmTO7Zs0y3malPzSxxrwxLKK69ddov8ZbarPHAhyB 8X3V+B07ODholNimpiajuxq11njFGRwYMFputK8v0tsbjUbzhXze+IVcvqpcNiru 0OmGB7422eZ1at95Wsa/ztBfN1OGgYZmh+9KgO0ddVTL1KlTjdfdGTPa9y8Jdohq JTb+NxLpNd6HtbQMTREfu29a2O1yHXX00UbvnTJlytEtLXqxOLFl0pTJU4yGPPWY Y442TJ7caZTjjg7jU4w3Ycb7uYMaMvUY9VHd+hsKhYq6bvZYgCHGN1Wj3GYymaEC m81OaG4u6Hp/KmU0W6PKGr9jjV9Np9PGDyZNmmT8IJlMGnU3bXwPTaeNwmv8anv7 9P8+YNlZbyaNf/dwOFKplAcHB43yb/ZwAIyYs75nAQ3H4/EYb1OOOmpovtfssVhI 9XiVSDhifA9rbmr2eD3Vk7Sqv9TX1zdp4iSj/U6ZfPSxx0471qjLxxzbOm2a8TPj m8a73B7jn41KfMR6PI6GjBoZmvsNhfLZrNkDgYNUK+6+pcpZo+I2NTfrhYJRcXt7 e42fMTrtwMCA8b/poV83arDx2zNbKOT3nyJRXfAci8ZK5dK4yrj2Ge0HnVYIvz9Q /ZowIQw0Fr6RARZlVF/jnUZnZydvOGrIeDuYiCdaWlqOOtr4v6OmHmP042OmTjUa 8TGTWlqMEu32eI899tihyWPj/6dM8fl8HTNmVDcY05AxOsbvnFg8HtI0swcCuzEK aj6fr1bc5qYmo98aP0imUn19vblsLrOv5Q7N2Gayudz/ae9Oo9u6DgOPgwBIcMG+ EgQXOd5kyatORiexk4mbuM2XzOnifGhzmqRfm9M5dWc6mU7ddHEybZxJOk7t1LIl L7Js2Wm8dNKmdu04cb3JbrVZi2VLtkiA+4Id3LDOfe9RFERSJEjiEiDf/2cLAkHo vieJBN5fb7nT4rPq0cpZp9OhtyOJpCqVSoPKnN4cFw1sGmxYA3VHO9G3s5P03Wjq 7o6JxkblYtTNzc0ig62atrY2q7WxqUn8jbg9nrlCbhPxO7cPWXyojbBkJBvoZB0T XxLxRGJI2T4urfxsoIy2/1a53NTMjNlonFX7NplIjI2Pz6imp6am1PoVGZzN5WbV s3Fzuazb7d50V0bc7MQ3+MCAcn07Mhiof2xeA3XE6/WIjWTSt26J7dFYLNZoVhK5 udnSbLFoISxiWcSwzWYzmkyinJVCbm1t0ah3OkMh0clms1kb53KdbCCVtxbtwlfD w8OFfL7W64I6UiwWxdeGyFelbE0m5f4FyWRSubjUrHJxKfHZbHZW2WmbzebzuRnl klOz+VzW6XKxC7c+aRks3sAnJshgoH6xkQ3UBYvFYrfbgsHNN6ERyomtn+HhEWVK pzlqLDc1Kh3c2tKs7FduFsVsMpvFHavV2qzuaNb2Ns+ncnsgsGBWp2WCuRJEdU1o F74aHR0V1VLrdcFG0A5I1sJVy9qZ6ekZ8YB6m0qlosplkxXiMfU2m81lC4WiiNvs bFb7VD6fb1fPtq317wZrJ74ShoeHU6n0LN/7QF3iFRaoPY/HYzabg8H2Wq8INojW yUajsVGZA1n8UEpZmw5ZNLDF0iwC2GKxiA9bW9vEIyX1n0ja2tqaVWpHN1c+9XFH R8eNN9yw4tMWZDbZvE6JZHJkdHR6crLWK4KlTU9NjYyMVPjkVvWC8zPqpD/akcZT k5PRWEzErfjGER2bz+XVyW5zOWWW3FyhWCoURNcqn9QeFVFE2epKOBwRL/IcEQ3U IV6IgVrSdgOGQh1sFeFytGuxToxPiC8SNZdNJpNZU+EIJnX6KItFZHaTcty2GtAt 6m7nVlHYbW3KT62tYkH5QqFVOd/Z6vX5erq7nQ6H1N9aJXu2N2mHK6f+xuODg4O1 XpG6YzSZioVCdccUadpkNov+nFRpJ8ZqJ8eKVtVm+lH2us7OqntdVUq15iqflUqU TEEUraDcFMTfr/i2LL/+PLCYen2sIXW2pJlarwuAi3jVBmrG6/W0NLeITaharwiw hLnwnohqe6qV8DY3mi/Ed2OjGuKmuXvKI01KnYu8aTQ3mi88STS3yWhqVHZoN2kP KPuuGxu1zypxMjPTOD+i2SwiXYzV1KQ8uVk9tbo9EJDd4TLEE4lIOCz+AGu9InKJ FrSof1miacXfpkhE0ZeiE7OzWdGJOSUVlVbM5+fKsVBUiGfmlATNiqeJJxS15xQK WmEW8jnxNOUX5PJzD6o3ytPy2jMKcw+LEM3nxReqz+clRFG3IhFlVzBnBQP1g3cL oDb8fn8g4OdCJsDytDmftTtjo2PFUlF0jtGofOMY1ehR7piM2iPlxKfE4xu/wnNK peKmuuyz6NDF16kuFkWKltQ7c58Vj4g74k9bvHxpwcncsMCKCoXC6OiYUOsVAaDg TQvYaNrkOsFgO9e7AgBAD9QrY41kMpnp6elarwugdwQwsKE46RcAAB3ilGCgTrAJ DmwctX7bQiGm+QUAQHfUBh7MZCZpYKCG2AoHNgj1CwCAztHAQM2xIQ5sBOoXAAAY aGCg1tgWB6SjfgEAwDwaGKghNscBuSwWi81m46pXAABgnnZNrHQ6PTs7W+t1AfSF LXJALo/H09XVWeu1AAAAdae/fyAajdZ6LQB9IYABidxud2dniPl+AQDAYsVicWBg MBaL1XpFAB0hgAFZLBaLy+Vqbw/UekUAAECdCocjU1NTHAgNbBgCGJDCam3zen1O p6PWKwIAAOpaJNKfzc5mMpO1XhFAFwhgQAoOfgYAAJXgQGhgIxHAQPVZLBan0xkM ttd6RQAAwCbAgdDAhiGAgSpraWkJ+P1Ol7PWKwIAADaNSKR/WlXrFQG2OAIYqLJN dPBzoVAQt21tVmMFrwSlkvi/KF40SurBWoV8vlDI53LitpBTfsrnsrlCsRAMBpnx GACwNqVSaWRkxNhgNJtN5sYmodFsbmxUPjCbTPPvrca5962G+RvDwo3aBvGeJd6d pqanxAcmk2mjfgdrx4HQwMZgOxWopuZmi8vpCtTllZ9HRkb9Pp/Pr7jqqqu+9KUv 3XLLLY2NjesfWWyvFFSjo6NnPvhgMp0eGhzs7e0dHhmJRqPxeDyRTKRSaY4JBwBo xFuSzWa1Wm0et0LcdnR0fGLbtkAg0NzcPJPLZXO5K7Zt237ddetcUCqVOnz48Jkz ZyJ9fSKtBwYHR0ZHxXtTfb4lhcOR6empmRkOhAYkIoCBavJ6vaFQR53sAh0eHmkP +Du7unbs2PnlL395165dZrM5l8tph1e1tLRUpX7LaYMvHllsapx+//3+/v6RoaGx kZHevr633zkk/qwWj1Anf3QAgDUrlUqLH5yYmLj1U58WfdvV2XnVlVeKO6JyZ7PZ bdu27dixY8GTL/dusgaL3/VEEh85cuTkyRNnP/gw0h8Jh8Ojo2PBjuA6F1QV4o9u cHBI/FnVekWArYxtTaBqvF5PMBis7XFWw8PD3V3dO3bu/MpXvnL77beLnpSXu5Vb srpj0eibb711+PDhgf7+ZDKh7CaOx1Pp1OTklN/vMyyKYdoYAOrHgsrVPhwbG29r a7Xb7U6H0+vx+Px+j9vt9fuvvvrq22691e64ZGrAKlbuqix4SxI9/Pbbb79/6tSx Y8feP3NmYHCgo6NjI9dngUKhIN7KJyaiNVwHYGtjgxKomm09PbW69tXIyOi11177 1a9+9bd/+7ebmppqskmxBpfbHS2S+K233jp+4sTQwIBo42QylRQ/ytpYU57E5DEA VFd54pbfHx8bbxWVa7M77Ha32+33+12Cx3P1NdfcfvvtzqUq11Drf4ddRnmHJxKJ l19++e033zx2/Pi5c+dqdUJTJNLPmcCAPGwyAtXh8bhDoRpc+8pkNH31a18T6Ws2 m+t282INLrfNFIlE3jl06MTJk0NDQ6lUMp1Kx+PxlJBOFwt5f0DZWNFieD6JaWMA uJz5stXuzO3IHR01msx2m81utzscDrfb5ff5naJy3e7du3d/5jOfWTBI/VduheZj 2GQ0vv3WW/ufeOLQoUONTRv9OyoWi4ODg9EoDQxIwXYhUAXNzRaPx+Pz+VZ+avWI 4v2TP/lfv/7rvy7ubORya+5yW1qZdPrNN988/t57AwMDyURC5HEsFkunRSNnxPNF HhsajIGA33BpIZPHALa28rLVbkdHxwylokhc8SoqKtdmszodTvEuJlrX7nR2d3ff duutO3buXDBOrY5YrqFUKvXGG2/88tVXf/7qqw2VzJdQPZGIMi0wV8MCZGDLD6gC t9vV1dW1YSk1MTHxR//tv3/1d3/X6XTqZ0OkEsvshRgeHj569Mi//8fhkeFhkcqZ TCaRiCdTqclMZmp6pqgoiE1D8ZcYCAQoZACbxYK+HR0d1e6bTGaj0dja0mK1ttlV LpdbiV2b7corr9y1a9cnP/nJBUNtmR251aL9gRSKxZdfeumlF1989Re/8Hg9G7No 8ZfY398fi8U3ZnGArrBhB6yXxWJxu93arsUNYLVa77//gZ07d7J1slrLbNsl4vG+ vr73z5w5ffp0OByempqanppKpZKZzOTk1OTMzKzYFlEjuVgqFhqMxvJIppAByFNS aXfGRkeLyr/TGTXixae52WJtU4iuFYnb2tbm8Xo7OzuDweCNN9xwub24BhJ3NeYy OJ//yTPP7Nm3d8lrXMsQDis7gWdn2QkMVBnbbcB6OZ3Onp7ujamg66+/4b777vN4 NuhfoPVmmU3DWDTa39//4Ycfnvvoo+GhoVgsNjMznUymMkoiT4pflS/kiwXRx0t0 MnuSASw2n7VK2Y6NidcOw4Wy1epWubJDa6tSt62tNpvVbnd4PR6rzebz+6+99tpb b73VZrMtGHP+RcxA4kog/nj/3/PP7923b2xifAMWJ74wRAMnEokNWBagK2yQAeti sVicTkcwuBHzB+7cef0Pf/hD6reGlt95MjY6OjQ8/NG5cx/39saj0bHx8VQqOTsz m1YjeUb8yumpfGHuWGux6au0shLMhYYGo9/vY5cysAVcssN2bFx8i4tv8AZ1p63J JLJW/KfcaWkWryIib5W+tVqt7YGAzW43NzZ6vd5rrrlm9+7dTucScwqw/7bmtAZ+ eN++8Q1pYPWIpGl2AgPVxWYWsC4btvtXbCk988wz3d3dsheEdVpmD0wqlTpy9OjE +Hg8FlPCt1BQL9aVisVj4xPRabGZM6PI5rIim7PZ2YK6L1l8bYlYLhSKFw/DVjap G/z+VRx1X9vpqYH6JL4HK3+yspNWPfxY+1cq8ZPJLIrWpMZtg7hnbmxqtliamy1K 2La0tFnbRNY2t7aJ7z7xTuF0ua668sqbb755ybI1ELebh3itfvrJJ+974AGTSfq8 D+wEBmQggIG127Ddv+It8MEH93z605+WvSBIVfnRiR9++OHQ0NDs7GwiHle2tUul ZCqVViZ7Ui7fNTk9nUmnxSZRSUljg9gSF18hYvD5Xy5GNjZc3DITIT04NCjv9wVs Uj6vz6he2lf7likZ5nbeNswdiqH826aSuuoeXK/HI9q1QT3z1qZODtTT07Otp6e7 p2fxocjzOCZ5S0rG4w/t2XPwx89swD9/sxMYqDoCGFi7Ddv9+zu/85W77rqrqalJ 9oJQJ1a70fzRuXNDw8NZYXZW/FplWpO2NnGnkFcUCoWfPPecMqPG7Kx4gvgh/svm srlcXjxHfYq4Ix5RPioWi4GAnyOxselcOJl23Gg0NjaaG83mxiaLuG1SNKq3yu5Z ZSdtS6tyjq3R+OU77xSfMDc2drS3+/1+l9u94lIIWmjeffvtvfv2Hjl2TPaC2AkM VB3bN8AaiQ0ph8MZDLbLXpBomaeeOtjV1SV7Qdi8yjfKDavfLo9Fo6KAJ2Kx0dFR LZjFbTqVmpycFG1gbmhQTl+eVnZBTKu3Gi2elWoWLZ0viNuC8ksLWnMXlYO2i8pd 5QPlzGetroulkniKWKh4XFnzvHY/XzIYioW8cjr0hfymwDeX0gVjo2MldY5Z8fdn Umcpb1RvTWZTg6FBPKJd40l8ZZmMJsFsFv8r943KfSVcTeqtmq3iC7mpqJ4vIL4U m8XLrnKMsXL6rPgp2N4e8PvtDkcoFBKvk3a7vfK1Xee3DCBeIfft3fvEkwc2YFki gMVrMHMCA9XC5gWwRm63u7MzJDbjZC/oL/7iL3/jN35D9lKABUmgkRcGYvNRu2Nb qlu0z4p+zmQyyp1CYXpqSrlwWKE4NTmZTKWisVg2m1WDuiRqfMHJnOJB7bMy1nxL Ei9loi3LP2xoaBB1KirU7XKJthTZqT3Y2tYqClXcEV8bZrVsgx0dUtdtya9MA9WK mkqlUocOHXr1lVdeefXnspclXsoGBgZjsZjsBQE6QQADayE2vNxul8/nk72gW2+9 7Tvf+Y7L5ZK9IGATuVwRQQY6E1hMvAplJiff+OUv9x944nxvr+zFRSKR6ekZXveA qiCAgbXweDwdHUHZV9adnc3+7Gc/u+KKK6QuBQAArEEykXjowQcf2rfPbr/shdCq olAoDA0NR6NRqUsBdIIABtYiGAwGAquYhGZt/vAP7/r617/OmZAAANShVCr12muv vfzSS28delv2ssLhSDwel70UQA/YsAZWzePxhEIdss/+7enpefDBPRswxxIAAFiD XC6XTCZf+tnP9j36aDKVlLqsYrE4ODjETmBg/QhgYNU2YPYj8T63d+++3bt3y1sE AABYv1Qy+fCePQcOPiX1X8aZDwmoFgIYWLWOYNAv+fjnL33pv9x9993Nzc1SlwIA ANbvjdd+ueehh9//4IzUpZw/35u6cP18AGtGAAOrJvsE4GQy+fLLr1x11VXyFgEA AKolk04f2L//b+691+P1yFsKpwEDVUEAA6vj8bhDIbnT//7mb/7WN7/5TXb/AgCw Wbz+i1/sfeSRU++flrcI9TTgwWiUCYGBdSGAgdWRfQJwoVB4/PH9u3btkjQ+AACo unQqtfehhx4/8IS8KRI5DRioCgIYWB3ZJwDv2LHz/vvvd7vd8hYBAACqK5fLPbl/ /4GnnoonJB6lzGnAwPoRwMDqBNvbA+0BeePfddcf3XnnnSaTyWg0mlTMAwwAQJ0T XfrG66+//K//+vqbb8hbCqcBA+vHhjWwCrJnAJ6cnHro4Yd3XHfdkp8VJVwexvNk z0gMAACWNzs7G4lEXnnppf/7d39ntbZJWgqzAQPrRwADq+Byubq7u+Ttkt15/fXf +rNvOZ3ONY+wII/ZjQwAwBoUl1IoFLQ7JdWCX5LP5//jnXcee/zxyEC/pLUSC41E +tkJDKwH28TAKvT0dIsGljf+H//x/7jjjjvkjW9gNzIAQH9ENy4ZtOXWv5RcLnf6 1Km33nzzn372z+sf7XJ6e3uTSU4DBtaOAAZWIRAIBIPtkgafnp55cM+eyx3/vJHY jQwAqGcr1uzi3bMbIJFM9vX1nTh2bN8jj7S2tUpaCtfBAtaJzVmgUk1NjW63p13a FbB6tm371rf+vDMUkjR+dZWHcXkwE8kAgFW5XMFWd/fsBhABPDI6eu7MmRdeeGFo ZFjSUsLhyORkJpvNSRof2PLYVAUq5fG4Q6GQvEOFv/7137vzzjubmpokjb/xysOY SAaALU+r1uWPN67JvtmNkcvlUun0R2fPvvH66z//xauSllJUroM1GI3GJI0PbHls hgKVcjqdPT3dkuJtbGz88f37b7zhBhmD1zPtnOT5Qi6/pZMBoIaW6dj5T23hml2b RDLZ29t7/PDhv/vRjwIBv4xFiD/zcDiSSCRkDA7oAduXQKU6QyGvzytpcLvD8b3v /Z9tPT2Sxt/sjCo6GQDWoDxlF2Rt+Ye1Xs2tQATw8MjI6ePHn/7xM5NTU5KWwmnA wHqw4QhUSuoVsD53+6/81z/4A6vVKml8nZi/xvV8IZffIZUBbHaVdCx7ZWtIOwr6 47Nnn3322ROnTkpaCgEMrAebg0Cl2hWyroD1rW/9+W233SZpcCwmYnjJSNbukMoA 5FlwCPGSxxXTsZuXaOAPzpx559Ch5154XtIiwuEIUwEDa8ZGHlARj8cTCnVIugLW xMTE4/ufuH7nThmDY/2MKyGYAV1ZcKmnZT4kYnVIOw34vSNH7v/7H/l8PhmLUK+D NRSNRmUMDmx5bLQBFXG5nN3dsq6AZbXZvv/9H3AC8JZBMAN1q3RBeaMu+eH8/Vqv MjaZudOAjx176pmnp2dmZCxCfFlGIpF4nOtgAWvBRhhQke6uTrfHI2nwO+741d// /d9va2uTND7qX4OqvJAvd7/WawrUxnyOlmfq8gVb61WGTuVyuXQmc/7cueeee+7Y e8clLaW3tzeZ5DRgYC3YlgIq4vf7Ojo6JA3+l3/5V5/61KckDY6treECLY8rvFPr tcZWVrq88nBd8sNarztQNQORyM9feeWZn/yDpPHPnz+fSqUlDQ5sbWwGARWRegWs 73733ptvvlnS4ECFFrd0ufInLP/ZWv8+cIn5g3jLU3PFx5dR298OsCnkcrmzZ88e O3z4yacPSloE18EC1owtFWBlUq+ANTMz++CePddt3y5jcKA+zTdzVW4XDLvkstb2 4ILeW5x/yz9hyQ8rua3kCQDqViKZ7AuHTx49uu/RR1taW2QsgutgAWtGAAMrc7vd XV2dknZtdYQ677nnns5QSMbgAABgg4kAHhkdPfv++z959tnxiXEZiyiVSv39A7FY TMbgwNZGAAMrczqdPT2yLgH91a997ct3ftliscgYHAAAbLBcLpeZnBwaGHjpxRdf efXnMhYhAjgcjiQSXAgaWDUCGFhZKBTy+bySBv/e9/7PjTfeKGlwAABQEyKA/+21 1/Y/eUDS+OfP96ZSXAgaWDUCGFiZ1EtA33vv92666SZJgwMAgI2Xy+XOnT179MiR Jw8+JWkRXAgaWBsCGFiBxdLkdLqCwXYZgxeLpQd+9KNrrr5axuAAAKAmEslkOBI5 dfz44/v3m8wmGYsIhyNTU5Ozs1kZgwNbGAEMrEDqJaC/8IU7vvGNb7S1tckYHAAA 1EQul0tnMh+fPfv8888fe++4jEVwIWhgbQhgYAUul6u7u0vSFbDuvvvPPvvZz8oY GQAA1Fakr+9fX3rpuX98QcbgpVIpEulnNmBgtQhgYAUOh2Pbth5JAcwJwAAAbEmy TwMWAdzXF04mkzIGB7YwAhhYQbsiIGPkkZHRJ5966vqdO2UMDgAAaiiRTPb29r53 5Mh9998vaUOCC0EDa0AAA8tpbm52OBySroBVKBQf3LPnqiuvlDE4AACoIRHAg0ND xw8ffvSxxxqbGmUsIhyOTE9Pz8zMyBgc2KoIYGA5Ho+noyNoMkm5fuPnP/+Fb3zj G1arVcbgAACghnK5XCqd/vjcueefe+74ifdkLKJQKAwNDXMdLGBVCGBgOW63u7Mz JOkS0N/85v/8/Oc/L2NkAABQD8K9vS/+y7/84z/9VMbgxWJxYGAwFovJGBzYqghg YDlOp7Onp1vSFbC++917b775ZhkjAwCAmsvlcmfPnj12+PCTTx+UMX6pVAqHI4lE QsbgwFZFAAPL6e7qdHs8MkYWb1rf/vZ3du/eLWNwAABQc9p1sP7jnXeee+F5Sf+Y LsZPJrkOFrAKBDCwHHl7gBOJ5GOPP37d9u1VHxkAANQDEcADg4OHDx168OGHXS5n 1cdnDzCwBgQwsJzu7i632y1jZEtzy3333XfFtm0yBgcAADUnAnh4ePjU8eP7DxzI F/IyFsEeYGC1CGBgOX6/r6OjQ8bIX/v67935W79lsVhkDA4AAGoul8tlJieHBwdf evHFl3/+ioxFnD9/PpVKyxgZ2KoIYGA57Qopk9d///s/uP7662WMDAAA6sfQ4ODr r732+IEnZAweDkfi8biMkYGtigAGLkvqJMD33vu9m266ScbIAACgTuRyuXNnzx49 cuTJg0/JGJ+pgIHVIoCByxIBHAp1yJgEeGRk9KmDB3fu2FH1kQEAQP1QLgTd13fi yJG//eEPg8H2qo9fLBYHB4cIYKByBDBwWW63q6urS8YloEslw4N79nziiiuqPjIA AKgfIoCHhoffO3Lk0cceM5mrf0xZqVTq7++PxTgKGqgUAQxclrw5kDwe73fvvber s7PqIwMAgPohAnhkdPTMiRNP//jHqXT1L9fMTEjAahHAwGV1BIP+gF/GyDfffMuf /umf2u12GYMDAIA6kcvlkqnUB6dPHzx48Hxfr4xFnD/fm0oxExJQKQIYuCyfzxsK hWSM/IMf/O3OnTtljAwAAOrN8ODg6//2b489sV/G4MyEBKwKAQxcViAQkHG9CgOX gAYAQDdkXwiamZCAVSGAgaXJuwR0qVT6zv/+6//0yU9WfWQAAFBvlAtB9/Yefvfd Z59/TsaFRbgQNLAqBDCwNI/HHQqFZARwOp3e98ij123fXvWRAQBAvREBPDg4+O/v vPPw3ocdDkfVx1cDeDAajVV9ZGBLIoCBpbnd7q6uThn/Umsymx+4/4ErmAMJAAAd 0GZCOnH06P4n9pckjK/OhDQQixHAQEUIYGBpLperu1vKJMA+n/+v/+ZvmAMJAAA9 0GZC+uDkyWf+4R8SyerPVyQCOBLp5zRgoEIEMLA0h8OxbVuPjAC+6aab7777buZA AgBAD3K5XDyROPLuu//405+GI+Gqjy8CuK8vnEwmqz4ysCURwMDS/H5fR0eHjJHv uefbu3fvljEyAACoQ4lk8tSpUx+cOvXsC8/LGJ+ZkIDKEcDA0uTNgUQAAwCgK7ID mJmQgMoRwMASPB5PR0fQZDLJGJwABgBAV0QAnz516oy0AC4UCkNDw8yEBFSCAAaW IG8S4ImJiQNPPsUcSAAA6IcI4L6+vhNHj/7wgft9Pl/Vx2cqYKByBDCwBHkBnMvl H96798pPfKLqIwMAgPqkzIQ0NHTs8OF9jzxiabZUfXwCGKgcAQwswe12dXVJmQPJ arP94Ad/29PdXfWRAQBAfRIBPDwy8v7x408+fXB6Zqbq46tTAffHYpwGDKyMAAaW 4HI5u7u7ZQTwNddce8899zidzqqPDAAA6lMul0umUqeOH3/iwIGhkeGqj69OBRyJ x6s/yTCw9RDAwBK6u7vcbreMkX/lVz5/1113WSzVP/wJAADUrZmZmbffeOOn//zP H3z4gYzxe3t7k8mUjJGBLYYABpbg83lDoZCMkbkENAAAOsRUwECdIICBJTAJMAAA qCKmAgbqBAEMLCRvEuBSqfRX93x7+/btba2tjY2NVR8fAADUm1wuNzk1lc/n+/v7 D7/77rPPPyfjIiNMBQxUiAAGFpI3B9Lw8PA93/7Otdu3twcCTodDe1B7XxR3qGIA ADa1Jd/TE8nkyOjo9NSU+P/0yZMP/P2PgsFg1RfNTEhAhQhgYCGPxx0KhWQE8LxC oTA9PeNyOn0+n8vl8rcH7vjVX7vyE59YXMUGwhgAgDpzubdprXXTqdRkOn3s6JGh oeHRsbGJiQnxeFtbq4yDy+apATwYjcbkLQLYGghgYCG3293V1Snj8KTllUqleDxh t9u9Ho/Nbvf5/V/84hcD7e1L7i42EMYAAEi2fOhOT02JJ8QnJt566y0RurFYLBqN ptJpj8ddk62I/v4BsQ4bvFxg0yGAgYWcTmdPj5RJgNemUChMTU45nA63yy3y2OP1 fuGOO9qDQcIYAICqWDl0s1lRt+++8874xHg0GovHY4lkymazSt2puyoigMPhSCLB VMDACuplEx+oH52hkNfnrfVarKxYLKbTaYfd7nK5bXab2+35tS9+sSMUKg9jA20M AIBqmTfE+dDNZrMTY2OH3n47Gp1QOjcRT6VSDodD6olR1XL+fK9Y21qvBVDvCGBg IXmTAG+MUqkUi0ZtNrvd4fC4XVarzel2f+5zn6ONAQBbXoWVG49Gjxw+PBGNxmOx eCIhPpXJpL1eb/0c/7UGTAUMVGITf5MDkmz2AF5GsVgUb/I2q9XhsLtcrrY2q9Pl +s+f+1xnV9eCNjaQxwCAurT829PFyp2dnRgfP3rkSDQWS8TjiaT4TCozOelyOTfF 7tw1IICBShDAwEKBQCAYbK/1Wmy0Uqk0NjZutbbZbXabzeZ2u1pFHjudn/r0p1fM YwOFDACokhXfX8oTNxaNnjp5MqqclRtLJJKZTCaVTmUyk4GAf1Pvy12bcDgSj8dr vRZAvdPdSwOwPHmTAG9qIo/Hx8bb2lptah47HPbmFnHf9pnPfra9vb2ltZVCBgBU ovK+FfdnpqdHh4dPnDihHKScSqZSaUUmPTU17ff7dJi4y2MqYKASvHAAl9iASYC3 JOXg6nhClLC1rc1ms9rtdktzS1tb222f+UxnZ+eShWxYtBlkoJMBYNOq8CW9vG/F 7dDAwImTJ0XVplJJpW0zk5lMZmp62u128V68WkwFDFSCAAYuId5xu7q6+EflqiuV SiPDI80tLWJ7qE1lt9uamizig1tvu62np0c853KdbCCVAaBGKn/5LS9bYWpysj8c Pn36dCaTVnfcZqampsRQk5OTMzMzwWA7b7VVp04F3B+LcRQ0sBxeeoBL1NskwHpT LBaj0ahFhLFKdLLNarXabBaLRcTzLbt2dXV1GZZNZQO1DADLWtWL5IKsFXeGh4Y+ /uijTCaTTKVE3E5mJsVomtnsrNfrZc9trTAVMFAJtvKBS3R3dbo9nlqvBVZWKBSS iaTF0tQsyljV2tLSZhXJbBWbcZbm5htuvHHFHcvzaGYAm9QaXr4W76oVTRvu6xMl m0mnJ1XTMzPTwoz4aWpmNutyOU0mk8TfBqqkt7c3mWQqYGA5BDBwCb/f19HRUeu1 QJUVi8WJ8Ykmi+ji5ma1mcXPra0tyk5m5b828akrr7rq6quv1p5fSTNrKGcAVbHm F5MFNSs0mc0ff/zx+++/P60ebyyGFS07pcbszKzyn7iXzWZ9PnbVbkHMhASsiAAG LuH1eDq7Omu9Fqi9Uqk0OjpmNpmUbLYITcqNerdFiefW5haln8Xmac8VV2zfvl37 VZWX87zFW70GKhrYVKryXby4YxtNpnNnz547d25a5OvUlLpLVqTszGw2O6sQd3Lq ndl8Pt/eHuDkHQgff3w+nSaAgeXwWglcwufzhkKhWq8FNrGSanx8wmw2NTY2CZam pkb1VrsvIlrbBd2iHr1tMpuDodCOHTvmR1hDRWuW3ArXUNTAvKp/pyxuV8FsNIp8 DUfC09PKscTix4wSrTPiNivkRMXO3wrZfC7vU+f1oWOxHuwBBlbEiyxwiUDAHwwG a70W0Lv5ijYajWJzvKnRbBYNrd5amhobzVpZKzfKYd2WuZ3TDQ3GQDB4yy23LBht zUW9wDLZYKCxUSUb8GW2ZK9qjAbD6VOnBgcHZ7PKHlZ1N6tyV01WJVOVH+Imr9zN 55Ub8UixUKBdUSfC4XA8zkWwgOXwSg1c5PV6Ojo6OCcKW49W1KOjY+LL22w2iZJu NJtM4me1rMVd8bH2sEopbHGrJrYS2cp1xSwWMYLL49m1a9fi8avV2MAydSo0lEqn T5+ORieySpbOZpUcVQ4I1opUrVH1h0L5uVAoaB8WCnnl54Jyt1gsBgJ+ehVbkvjy HhoampiI1npFgPrFSz9wkcfjCYUIYGAtSheMj08Ui4Varw42JaPR5PN5Gy6o9eoA m48I4MHBoWiUAAYui3cX4CK3293V1clWFwAA2IxKpVJ//0AsFqv1igD1iw194CKX y9Xd3UUAAwCAzUgEcCTSH4/Ha70iQP1iQx+4yOFwbNvWQwADAIDNSARwX184mUzW ekWA+sWGPnARcyABAIBNjZmQgOURwMBFzIEEAAA2NWZCApZHAANzmAMJAABsdsyE BCyPAAbmMAcSAADY7JgJCVgeAQxcJBrYYCgViyWRwR0dQZPJVOs1AgAAWEGhUBga GhbpazSKbfsG6hdYBgEMLEdNYsN8FbOLGAAA1JC2g3e+dcUj5C6wKgQwsGpUMQAA kI3WBWQggIHqmK9ioaFBOYJaVDFTCgMAgOWJLQf1ylXD4md1y4HWBSRi6xyQSzuv uFRS/h23tbXV5/NSxQAA6JPYIBgfn5iamlL/ldzA+brAxmNDHKgBbXexsrO4VHQ6 nTabjYOoAQDYSorFYiqZTKZSDQ1zR4TRukA9IICBeuH1ekolg9bFxWLJZrO63W52 FwMAUM/Eu7Yo20xmUj3zSTmAWdwwDS9Qt9i2Bupd+dnFIoyt1jbxCGEMAMBGWhy6 BnbqApsQ29DAZlUWxgblUGqH02bnUGoAANalWCwqBy6nkuqhywZCF9hiCGBgC1qw 09hutzudDtoYAACNqNx4PJFOp9mdC+gNAQzoS3kbC0ajiRmbAABbz/zcQsVioaGB ygUwh01eAHPm29gwt92gFHJzc3N7e4A8BgDUG/EmNTI8MjM7K96kLuzINVC5AJbH Ri2AilzIY8OFs46VRrbZbC6Xi4OrAQAyqAcqx9PptDaT0PwZuQYSF8BaEcAAqmOp Qi45HY7pmRn2IQMAFlD2346MNlss6ky5DfQtgI3BJimAjVMWyWolXzgV2Wazu1xO 9iQDwNZw4RJTqfmTb8v/GZS4BVBDBDCAuqNOdGwozZ2MbCjfpaxNg0wqA8DGE1mr TYRbvsN2/la8UFO2AOofAQxgEytPZeWHcnNht7KyY9mqnaLMAdgAsJh2nWT1JNtM wyVRq32erAWwBbFRCEBHyo/BLt+9PL+T2WZtc7ndNDOATWdRzRrKd8+Wb/IRtAD0 jC08AFjBUtk8f2+unK1Wa6FQ8Pt9HJ4NYD1ExI6NjZtMpkymvGPn98kaSFkAWA8C GAAk8njc84cRqsdpN8zvczYYLjnP2W6357K5YqnY3t7O/mdgM1KnpR02Gk1NTY3J VOrSHbCGsj2xpfKXhWg0VsN1BgC9YRsLADYBt9u9qIovnvZctl/64hHdNqu1WCx6 vB6O6AaWpB0zHJ2Iiu+RtLK71VB+tPCldwwLNpnEr43FCFcA2HzYJAIAnbr00O4F Lh7pXfbhJZltt9vy+YK45/N5RTRw7DeqS6Sp+OoaH58QX11msymVSi9I0wUHAy/4 cAEOFQYAaAhgAAAAAIAuEMAAAAAAAF0ggAEAAAAAukAAAwAAAAB0gQAGAAAAAOgC AQwAAAAA0AUCGAAAAACgCwQwAAAAAEAXCGAAAAAAgC4QwAAAAAAAXSCAAQAAAAC6 QAADAAAAAHSBAAYAAAAA6AIBDAAAAADQBQIYAAAAAKALBDAAAAAAQBcIYAAAAACA LhDAAAAAAABdIIABAAAAALpAAAMAAAAAdIEABgAAAADoAgEMAAAAANAFAhgAAAAA oAsEMAAAAABAFwhgAAAAAIAuEMAAAAAAAF0ggAEAAAAAukAAAwAAAAB0gQAGAAAA AOgCAQwAAAAA0AUCGAAAAACgCwQwAAAAAEAXCGAAAAAAgC4QwAAAAAAAXSCAAQAA AAC6QAADAAAAAHSBAAYAAAAA6AIBDAAAAADQBQIYAAAAAKALBDAAAAAAQBcIYAAA AACALhDAAAAAAABdIIABAAAAALpAAAMAAAAAdIEABgAAAADoAgEMAAAAANAFAhgA AAAAoAsEMAAAAABAFwhgAAAAAIAuEMAAAAAAAF0ggAEAAAAAukAAAwAAAAB0gQAG AAAAAOgCAQwAAAAA0AUCGAAAAACgCwQwAAAAAEAXCGAAAAAAgC4QwAAAAAAAXSCA AQAAAAC6QAADAAAAAHSBAAYAAAAA6AIBDAAAAADQBQIYAAAAAKALBDAAAAAAQBcI YAAAAACALhDAAAAAAABdIIABAAAAALpAAAMAAAAAdIEABgAAAADoAgEMAAAAANAF AhgAAAAAoAsEMAAAAABAFwhgAAAAAIAuEMAAAAAAAF0ggAEAAAAAukAAAwAAAAB0 gQAGAAAAAOgCAQwAAAAA0AUCGAAAAACgCwQwAAAAAEAXCGAAAAAAgC4QwAAAAAAA XSCAAQAAAAC6QAADAAAAAHSBAAYAAAAA6AIBDAAAAADQBQIYAAAAAKALBDAAAAAA QBcIYAAAAACALhDAAAAAAABdIIABAAAAALpAAAMAAAAAdIEABgAAAADoAgEMAAAA ANAFAhgAAAAAoAsEMAAAAABAFwhgAAAAAIAuEMAAAAAAAF0ggAEAAAAAukAAAwAA AAB0gQAGAAAAAOgCAQwAAAAA0AUCGAAAAACgCwQwAAAAAEAXCGAAAAAAgC4QwAAA AAAAXSCAAQAAAAC6QAADAAAAAHSBAAYAAAAA6AIBDAAAAADQBQIYAAAAAKALBDAA AAAAQBcIYAAAAACALhDAAAAAAABdIIABAAAAALpAAAMAAAAAdIEABgAAAADoAgEM AAAAANAFAhgAAAAAoAsEMAAAAABAFwhgAAAAAIAuEMAAAAAAAF0ggAEAAAAAukAA AwAAAAB0gQAGAAAAAOgCAQwAAAAA0AUCGAAAAACgCwQwAAAAAEAX/j+juZA0qycO cQAAAABJRU5ErkJggg=="/></symbol><use xlink:href="#c" width="1280" height="1280"/></g></g></svg>')} -.is2d .queen.white {background-image:url('data:image/svg+xml;base64,<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="614.635" height="614.635" viewBox="0 0 460.977 460.977"><mask id="b"><use xlink:href="#a" width="1280" height="1280" transform="rotate(.193) scale(.36014)"/></mask><symbol id="a" viewBox="0 0 1280 1280"><image width="1280" height="1280" xlink:href="data:image/png;base64, iVBORw0KGgoAAAANSUhEUgAABQAAAAUACAAAAAA9j6ArAAAACXBIWXMAAA7EAAAO xAGVKw4bAABGnElEQVR4nO3dd2BUZcK28VmEJIRQAlKkqYAgRcWCYi+gvouiqKu4 rhVXxb67oq5trWvFde2ou6jgqlhRVv1WQRSxi4pSpEoXCJ2QRvskIWSSzCRTznnu 55zn+v31vkpmrp3h3CaZmXN+EwEAR/1GHQAAKgwgAGcxgACcxQACcBYDCMBZDCAA ZzGAAJzFAAJwFgMIwFkMIABnMYAAnMUAAnAWAwjAWQwgAGcxgACcxQACcBYDCMBZ DCAAZzGAAJzFAAJwFgMIwFkMIABnMYAAnMUAAnAWAwjAWQwgAGcxgACcxQACcBYD CMBZDCAAZzGAAJzFAAJwFgMIwFkMIABnMYAAnMUAAnAWAwjAWQwgAGcxgACcxQAC cBYDCMBZDCAAZzGAAJzFAAJwFgMIwFkMIABnMYAAnMUAAnAWAwjAWQwgAGcxgACc xQACcBYDCMBZDCAAZzGAAJzFAAJwFgMIwFkMIABnMYAAnMUAAnAWAwjAWQwgAGcx gACcxQACcBYDCMBZDCAAZzGAAJzFAAJwFgMIwFkMIABnMYAAnMUAAnAWAwjAWQwg AGcxgACcxQACcBYDCMBZDCAAZzGAAJzFAAJwFgMIwFkMIABnMYAwqH7zHk12zWpT 9W/d1sVF89dMySuUNMFlDCDM2K1byzat2+68e1aTmP96TdHPKxYtWbxs2jyzWXAb Awjf5XbfrfmuB+zRKKvWP1m0btY38/PmTV1toApgAOGzRh067XHgfi0zk/iS4mXf fjVr9tx1vjUB5RhA+GeXXbsdfWDnlL505lfjp83/xeMeoAoGED5p2XHvM/ZpmsYN rJr8yg9zlnnWA1THAMIPzXY5+KyjPLidj178/JeVHtwOEBMDCM/V36X74MMaeXRj 6yYOm/oLb5CBPxhAeCynzXkXN/P0Flc+/fzifE9vESjDAMJLder1fOBwH273k2u/ 37jFh9uF4xhAeKdO3YG37+7Tbf9866hNTCA8xgDCM7nXXJbr482vfuJB3iANbzGA 8Ej2g+fX/lGP9BQ9d02Bz3cBtzCA8MaTFyTzaY9UFT97qYF7gTMYQHjhzitin+PA e2seu8XQPcEBDCDSN/Bxb9/3UrOVl48yeG8INQYQ6dr/P10M3+OMP0wyfI8IKQYQ aRr9fyZ++VdZ8f8bYPw+EUYMINIy4JmdJfe74qLRkvtFuDCASEPzV3r7/daXeIq+ OCNPdNcIDwYQqTvrYc23f2VWXP2i8N4RCgwgUtXozYPrSwMKPz+F00YjLQwgUnTy gx3VCZE517ylTkCgMYBIzT8HNVQn/Gr98D+pExBkDCBS0fmZI9QJ2024aKY6AcHF ACIF/YemdqkjP8wcMkadgMBiAJG0jKuubaFuiLL8gUdK1A0IKAYQycq99xztq79V FY78KycKREoYQCRpt3+erE6o5q0/zVMnIJAYQCTnsH/ur06IYdKfJqoTEEQMIJKy /2u7qRNimvc7ThCD5DGASMbRI9qqE+JYdO54dQKChwFEEn7/TAN1QlwbLnpJnYDA YQCRuNOfy1Yn1KDg/FfVCQgaBhAJO/U/qnNfJaboD2+oExAwDCAS1f9V86d+Tk7x 6XwoBElhAJGgE/6rLkjAie+oCxAoDCASc9z/1AUJOf59dQGChAFEQrpPURckqMdU dQEChAFEInLnmrrwebrWdOBzwUgYA4gENJvTWJ2QsLUdV6oTEBgMIBIwp4O6IAlz 9afqR1AwgKhVnW/3USckZfJ+W9QJCAgGELWp8/e/qhOSdO9NLCASwgCiNoF4A2Bl vB0QiWEAUYsOc9QFKeg4V12AQGAAUbPmU2y6/keilvfIUycgCBhA1Cj31T7qhJSM O523A6J2DCBqUvfmW9UJKbr9rk3qBNiPAURNBrxk9xmw4iv6/Wh1AuzHAKIGXd7b XZ2Qsp9/O0OdAOsxgIgv+8lz1QlpGHFpgToBtmMAEd+f/6EuSMtfHlIXwHYMIOLq /WYrdUJalp7yhToBlmMAEU+jF/qrE9I05ux16gTYjQFEPEMeUBek7dqh6gLYjQFE HD1HdVYnpG3mwO/VCbAaA4g4XjldXeCBV89QF8BqDCBi+/3jueoED6y+/CV1AmzG ACKmnA97qRM88fUx+eoEWIwBREz3Xq8u8Mh9QTubK0xiABFLqy/bqxM8suCgpeoE 2IsBRCwjzlEXeGZkkD/OB58xgIjhkDFN1QmeWdX/M3UCrMUAIoaxwTwLamzj+qoL YC0GENUd9F4Y3gJTbvVvv1QnwFYMIKobf5S6wFMfHa0ugK0YQFSz/7jG6gRPre0z SZ0ASzGAqObjI9QFHptwpLoAlmIAUVXPT3LUCR7LP5xzIiAmBhBVvfh7dYHnXjpL XQA7MYCoos6qcP0GcJu1TbeoE2AlBhBVPHKlusAHj16lLoCVGEBUsayFusAHy1uq C2AlBhCVnRzO64kPeEtdABsxgKjs233VBb74bj91AWzEAKKSxssy1Qm+KG65Vp0A CzGAqOSpi9UFPnn6EnUBLMQAopIVzdQFPlm5s7oAFmIAEa3rNHWBb7pNVxfAPgwg or1+qrrAN2+cpi6AfRhARFsfto8BV8hvqC6AfRhARDnkU3WBjw7l1PioigFElLdO Uhf46O2T1QWwDgOIKKvCdCr8qlaH50JP8AoDiAptF6oLfNVukboAtmEAUeGxy9UF vnr8CnUBbMMAosKsTuoCX83eQ10A2zCA2KFeibrAZxkb1QWwDAOIcr859BN1gs8O /3SrOgF2YQBRbqfh56oTfDZi0GZ1AuzCAKJcvVm7qhN8Nn8PfgZGJQwgymVvUBf4 rkGBugB2YQBRrvfn6gLfHfyFugB2YQCxXeZjf1Qn+O5fVxSrE2AVBhDb5UzcR53g u8mH5asTYBUGENs1+bmJOsF3a3Zfo06AVRhAbNd8ubrAgBZ56gJYhQFEmTr9w3lB 4MoGjNmiToBNGECUybz1BnWCAffczqsgiMIAokyj0UerEwwYP2CdOgE2YQBRpuU0 F84XuqrbMnUCbMIAokyb2VnqBAOKOi1WJ8AmDCDKtJ+vLjBi1wXqAtiEAUSZIz5W Fxhx5AR1AWzCAKLUTn8cpk4wYvC/OCMWKjCAKFX/ppvUCUb8/e+F6gRYhAFEqdwR J6oTjPjvuavVCbAIA4hSLf7bS51gxNcnuvCJPySKAUSpdp+3UScYsfjgcF/7GMlh AFFqjx9ceBtgJFK09yx1AizCAKJUp+8bqBOM2NBztjoBFmEAUarzDHWBIV1mqgtg EQYQpfb5Xl1gSM/J6gJYhAFEqZ7fqQsM2deVpUciGECUYgDhIgYQpRhAuIgBRCkG EC5iAFGKAYSLGECUYgDhIgYQpRhAuIgBRCkGEC5iAFGKAYSLGECU6jZVXWBI92nq AliEAUSpTj/UVycYUbg3J0NABQYQpTpNzlYnGFGwDwOICgwgSnX4trE6wYi1+81V J8AiDCBKtfywmzrBiGnHLFMnwCIMIEq1eHd/dYIRk/pxTRBUYABRKueBweoEI4Zd m69OgEUYQJTK/Mvd6gQjbvxHsToBFmEAUebk0eoCIwa8pS6ATRhAlOk+RV1gRA9X 3vCNhDCAKNNmkbrAiLaL1QWwCQOIMi1/aqJOMGDNnrwLBlEYQJRp9kUndYIBs3uv VCfAJgwgymQPO0edYMDIwQXqBNiEAUSZnc4drk4wYNCIzeoE2IQBxHY9flQXGLCX G691I1EMILZrslpdYEDuGnUBrMIAYrtGM1qpE3y3tMs6dQKswgBiu/qvnqBO8N07 pxeqE2AVBhDb7XTlQ+oE3/35UV4DQTQGEOWah/9EUS3y1AWwCwOIcpnLG6kTfLau BaeCQSUMIMrV++gQdYLPPjtqozoBdmEAUa7OXx5QJ/js2n9sUSfALgwgdshdpS7w WVMX3uqIZDCAqLA+R13gq/yG6gLYhgFEhQ/6qgt8NfZYdQFswwCiQv+31QW+OmmM ugC2YQARpThDXeCjkkx1AazDACLKjM7qAh/N7KIugHUYQES5/W/qAh/dcau6ANZh ABFtqzrAR/xdRzX8pUC0OR3UBb6Z21FdAPswgIg26N/qAt9c6MIp/5EkBhCVFIX1 pdLiLHUBLMQAopKJh6oLfPLpYeoCWIgBRCVHfqQu8MlRH6sLYCEGEJUtbaku8MWy 8F/wBClgAFHZE5eqC3zx5GXqAtiIAURlzRZkqxN8UNB+pToBNmIAUcXHR6gLfDDh SHUBrMQAoopDxoXvDSNFfT5TJ8BKDCCqmr6nusBzP3VVF8BODCCquvIRdYHnrnpU XQA7MYCoZkE7dYHHFrZXF8BSDCCqufU2dYHHbrtdXQBLMYCo7ufd1AWemre7ugC2 YgBRXcjOi8qZUBEPA4gYZnVSF3ho9h7qAliLAUQMd14bnrNiFT9wizoB1mIAEcuk /dQFnvl2f3UB7MUAIpaLHmyoTvDI+mueUSfAXgwgYppwuLrAI5+E8aPN8AoDiJiO fLG1OsETS87iRKiIjwFEbCE5LyDnAURNGEDE1vyDfdQJHph8bJ46ATZjABHHVXc3 UCekbcON4TuxA7zEACKe0SerC9L21gB1AezGACKeg14I+udBZp/9pToBdmMAEdeN f1cXpOmmu9UFsBwDiLiyRv5OnZCW184pUifAcgwg4uvxcnd1QhqmnjlFnQDbMYCo wdnPBPcCSUUXvaBOgPUYQNQge2hw3w795JACdQKsxwCiJru9eLA6IUWfnzVPnQD7 MYCo0SGvt1InpGTpaVwJGLVjAFGzPwbzbFIX/UtdgCBgAFGzug9doU5IwWN/3qRO QBAwgKjNh0erC5I2/hh1AYKBAURtsqcE7bKSP/fgBWAkhAFErfb8Kljnx19/4E/q BAQEA4ja5J446Ch1Q1Kmvfe/CcXqCAQCA4ga9Drx4C4tg3iFzK0FC3/8+L256gzY jgFETBn9Tjxg18YB/+uxacXMT1+fpK6AxQL+Nzz4WvzhyA7NG9Tdurlw9cLv3v5s i7rnV3X6DujdsZG6wjNb8qZ+9MZUdcWv6hxy0r7tcuvv9JtNG/Lmfvyf5eoeRBhA rUNuOrzKywtzPnhkuqalTI/zjtijSQj/Umxa9sM7ryonp+tVx3as/E/Wf/J3Pqwi F8K/64Ex5Lrmsf7xqnevX2I6ZZu6A07t3bae4p5N2fDThy99p7jj1vf1axrrn+fd P9R0CipjAFUGPRT/p8xpt7xhsORXzS747d7NnPi7sGn+56+9Y/ZTIqfe2S3uv1v3 5+EGS1CNE3/pLdRqXPyDYpu8Ox81VBLJueC0no1N3ZkVtiz6+Nnxpu7syltifp+/ w7Q+Sw2VIAYGUOL0V2r9I6uvN3AWgqyzzjigmf93Y6FN88Y+Z+CKSRfdl1vrnznj Vf87EAcDqDD0mkT+1NLz3ve14pArj2rp9PNf8tOrw339detxzyd0LrEHh/gZgZo4 fQCovHRmgn9w8oB5PiU0unjgXkF8g7PXtq4c/9Q4n257t9H7JPgnX/69TwmoDQNo 3ssDE/+zIy704Rf2B13R1+1v/ar47sUR3r9Dpu6/z038D49K9D+J8BjHgXFDHkjm T+f/cZS3d9//6oOzvb3FENi6eNQT3n5ubuC/cpL549fyfhgNBtC03p8n+QXf9Mvz 6r7rnDN4vwyvbixktq5462HPLqPZ/N0DkvyKg7/w6r6RDAbQsMZLkv/+6/r7vbjn jMvO77GTFzcUXmv+95Anrwxfd1/SX1LQeq0X94wkMYCGTa35/X+xzeyzKM27rXPh 5XvVSfM2nLD2rQfS/T6w7bjOKXzVtCBfgz64GECzLkjxjf833pPOvZ5wU6+66Xy9 W1aM/Ec6/7254e7Uvm7Qs2ncKVLEABpVd02DFL/yp6NT/cBAl7uPT/VOXbVl7kPP pXhS/Vbj90zxTjc04TpO5jGARj2fxFsjqkrphcKsG/7YOvW7dFjJhNsnpvBlyb3E X9mI81L/WqSIATSp8Zp0vnry0auT/Ioj7uvFyx4pWznsoZXJfUXu+ETf+hxTE14H MY4BNOmFP6T15cUXjUziT2f97aKd07o7bPr05mS+DTznmfQ+XPOfs9P6cqSAATQo I+0r9YzvV5Tgn+z0eB+++fPAL3f9qySxP5n1btrXT85M8K7gGQbQoAfS/9B7/qkf JPLHBtzbJe27QpkNI+5I5PWnY99I6qMfMQ29Nu2bQHIYQINWxjwtcJJGnVXbdUPq DLmWn329tOmD62p7b2CdF5P4gHdcq9w8NZkSA2jO/t94cjMr+vxQ07/OGjqovif3 gwpbJv9pQk3/fu9x3vwn5wAuYWcYA2jOu7/16IZqOH9co8cHhvqyHjJbZ/3lnbj/ MrHzOybgvX4e3RASxACaU+TZCfjmHr0g5j/PHd6fVz58M3/IazH/efvxHby6i+Is r24JiWEAjekz1sMbi3V+hEb/OpX589XcP42p/g9TOPNBfH39OjsrYmMAjXm7v5e3 NrlPlTfpZj11Fp/39d2MS6tcTanZuLTe+1zVmJO8vDXUigE0Zo3Hl16r9OH5Ovdd xYn+TNj69SXfR/2/qZ7cIp61Tby9PdSCATSl7UKvb/Gz364r/z+vvIfzHZiy5b0r 5m3/Pxu9d4jXt94u3ROfISkMoCl33uz5TRZdXPbRuKNf4IQHJhU/eWvpf3rOedr7 1yzuusXzm0QNGEBTJu3nw41O/G1+pMWYA324ZdRk1ZBnIznvHebDLX+7vw83irgY QFMKfHl7ctFF+/yZl34Fvn79Nl/eslLIFauMYgAN8f5XgAglfgloFANoSKonSodj 0rv4AZLEABry7b7qAgTCd378rhjxMICGbFUHICA4JE3i0TaEAURiOCRN4tE249j3 1QUIiOMSOuUtvMEAmvHRkeoCBMTHR6kLXMIAmrGuoboAAbG+kbrAJQygGfwKEIni mDSIB9uILj+pCxAYe85QFziEATRi+AXqAgTGs4PUBQ5hAI2Y0VldgMCYySVNzWEA jeBXgEgcB6U5PNYm9It/QTGgqhPeVRe4gwE04ZXT1QUIkFfPUBe4gwE04ZdW6gIE yNJd1AXuYAANyN6gLkCgNChQFziDATTgssfVBQiUy59QFziDATRg4qHqAgTKp35c bQSxMIAGbOA6D0hGARc5NYUB9F/XaeoCBEy36eoCVzCA/ntysLoAATPsUnWBKxhA //28m7oAATNvd3WBKxhA39XdqC5A4NTbpC5wBAPouwuGqwsQOIOeVRc4ggH0HWfD R9I4L74hDKDv8nlPA5K1IUdd4AgG0G89flQXIID2mqIucAMD6DdOBo0UcFpoMxhA vy1urS5AAC1poy5wAwPos5z16gIE0dZG+eoEJzCAPrvuPnUBAun6+9UFTmAAfTZ5 b3UBAumHfdQFTmAA/VVns7oAwbQ5Y4s6wQUMoL/OGaEuQECdO1Jd4AIG0F+cCxUp 4qyoJjCA/irKVBcgoIqz1AUuYAB91WesugCB1XecusABDKCv3umnLkBgvXuCusAB DKCvuBoIUsaVQQxgAP109IfqAgTYMePVBeHHAPrpg77qAgTY2GPVBeHHAPqpoL66 AAFWyC9QfMcA+qjfO+oCBNoJ76oLQo8B9NH4o9QFCLSPjlYXhB4D6B8+B4z0bMzi 88A+YwD9M/hJdQEC7tJh6oKwYwD9M7WbugABN627uiDsGEDfNF6jLkDgNVmrLgg5 BtA3//izugCB99Bf1AUhxwD6ZlkLdQECb3lLdUHIMYB+OegLdQFCoPeX6oJwYwD9 8gnns0T6Jh6uLgg3BtAn2RvUBQiFBgXqglBjAH0y9Bp1AULhwSHqglBjAH2yKldd gFBY3VRdEGoMoD84DwI8whkR/MQA+uOnLuoChMSMPdUFYcYA+qLHj+oChMZeU9QF IcYA+uKzg9UFCI3PD1EXhBgD6IcWy9QFCJGWy9UF4cUA+uHNAeoChMjoU9QF4cUA +iB3lboAodJ0tbogtBhAH7zdX12AUBlzkrogtBhA7/EbQHiM3wL6hQH03tg+6gKE zDguMO0TBtBz7eerCxA6uy5QF4QUA+i5b/dVFyB0vttPXRBSwRrADv+3d6fcnAb1 623cuLF49aI50775QZ1UzQn/VRcghE6078Plex/QrWPb3Mx69eptLNyQv3r2D/9v rjopeYEZwDqnnXlg2xj/fP3i6eNfzjOeE1edPM7eAe+tam7RJYKbn3l01zYNY/yL RV+9/LpFnQkIxgBmX/v7Gk8uUDT/ixfH2vHAP3GpugCh9ORl6oJSdfqe1XvXrJr+ xIyXHgjQOVyDMID97+iZyB9b8vUrr5X43VKbzjPUBQipLjPVBRm/O6NX60T+4Pd/ G+N3i1esH8A6f7u6SeJ/+pcvX3xzk38xtZvfXnnvCLEFuyrvve4pZx20S+J/fM3D d9jxE1ltLB/AuvcPrp/s1yz65NkP/GhJxEN/Ut0zQu+fsgtNH3vB4bF+/16jwmHX Sb8VSZDVA1jn4YszUvvKWe8PU5xEjUthwkeSS2T2GHzcHql9ZcnTV9v/XaDNAzj4 yXS+umja6GGGXx3O/qWR2TuEU9btYvjVheaDB3Sr8QWP2lw6zKsUv9g7gIe8lsSv HOJY8/V//mPw+/Dv9zF3X3DQ5IReDfRG3T/8oVcSv32P45fffeZBi49sHcDsN473 6JYWfPDY9x7dVC1GnGPmfuCskeeauZ+eVxzr1at5/zvV6jfFWDqAf3w0re+8qyj6 4fWn1np4e7HdcofvdwHX/e1O3++i8SWn7e3p0Xflvzy8Na9ZOYAtxu7l+W3mffLU +57faLQrH/H15oFtrnrU15s/7pLDm3t+oz/2tfdsXjYO4OWP+XTD00c/stSnm45c 9rhftwxEufwJv2651VUDuvp001dYe3TYN4CNxx7g581Pe/RpP16bv/5eH24UqO6v 9/lwo3UuvrKbDze7wzd9/f8dVEqsG8DTR2b6fh8/vzhskbe3OPJsb28PiOsFj19s azv4rN29vcUYis951ff7SIVlA1jn1VMN3dP8yeNe8ern4dwvOnt0S0DtZvb26iJJ rc7os4+pT9i9cbqNb4u2awC7fuz9b2BrULx48tjX0v/97B8fT/HzKkBKSi5P/4XV Fr/ru08b/3/aipJ35HSTd5cYqwbwmqGCO/11Bce9uST1r+/yhq+/PAFimHZqGqcd an1KH8Pbt92QBwV3WjOLBjBj7OG6O180/dO3v0vh63o809vzFqB2X1yUyqfd9z3p 0K5Jn9fAO5/0lZ+wrgp7BnDf8Y3VCWsWTP5kTBK/GMy45uLdfIsBajbv6QeTmJNW /Q/fp336n21L09qjU/k2w0fWDOANd6sLyq1eMvPbj74uru2Pdb74pBTPkgF4ZNbb T9d6mtTMXkft17l1romcRNx4j7qgEksGMOODI9QJVa3OWzjr59nTZ26u9m+yDzpi vx6S36EAVRUvnvLthC+rf952p85dO+2+R7vm1ixfuQnH2vRjsB0D2OZH656mCkUl xcUFhVu3/Z+/ycpqkJ2tDgKqKSjYUFRU9pe0fnZmZoaXn+b12Oq9FqsTKtgxgNkr LX6+AHioqJlF54exYgB3+n991QkADBn7f9V/r6RixQBmL2+gTgBgyIYW9nwLaMUA Ro78SF0AwJCjPlYXVLBjACP/vFpdAMCIh226dKIlAxiZvqe6AIABP/l10sGU2DKA uUt4HRgIv6LWXp3KxhO2DGDk5NHqAgC+G/CWuqASawYw8tx56gIAPnv+fHVBZfYM YGSeqTMzAtCYv5u6oAqLBrC1RR+QAeCDNmmcedMXFg1g5OyR6gIAPjrnBXVBVTYN YOTNAeoCAL4ZfYq6oBqrBrDOkpbqBAA+WdbavssiWTWAkU6z1AUAfLLHbHVBdXYN YOTyx9QFAHxxxePqghgsG8DI2D7qAgA+GGflOe9sG8Cc9eoCAD5omK8uiMW2AYxc d5+6AIDnrr9fXRCTdQMYmdVJXQDAY7MtvYSifQMY2bSTugCApzbXVRfEYeEAtl2o LgDgqXaL1AVxWDiAkfuvVRcA8NAD16kL4rFxACO/tFIXAPDM0l3UBXFZOYCRLXZm AUje1jrqgvjsXJruU9QFADzSY6q6ID47BzDy/LnqAgCeGGHzud4tHcDI6ibqAgAe WJOrLqiJrQPIrwGBMLD5F4ARiwfwCIuuHg8gRUdOUBfUyNoBjPzvOHUBgDS9f7y6 oGb2DmCkoL66AEBaCrPVBbWweAAzitUFANKSWaIuqIXFAxg57zl1AYA0nP+8uqA2 Ng9gZNJ+6gIAKft2f3VBrawewEhJPXUBgBRtzFAX1M7uAcxdpS4AkKKmq9UFtbN7 ACM33K0uAJCSG+9RFyTA8gGM/LybugBACubtri5IhO0DGNls9ydpAMSyJRhXtrB+ ADvMURcASFrHueqChFg/gJEnLlUXAEjSk5epCxJj/wBG8nZWFwBIyorm6oIEBWAA OTMWECyWnwMrShC2pddX6gIASTjwa3VBooIwgJHRJ6sLACTsrQHqgoQFYgAj+Q3U BQAStCFHXZC4YAxgZKs6AECCAjIqpQLSeurr6gIACTntDXVBEgIygJHPDlYXAEjA 54eoC5IRlAGMFAfg1DqA80oy1QVJCcwA5qxXFwCoVcN8dUFSAjOAkWuGqgsA1GLI g+qC5ARnACOzO6oLANRoTid1QZICNICcGQuwW0DOgRUlSAPImbEAqwXkHFhRgjSA kacuVhcAiOvpS9QFSQvUAEZW5aoLAMSxuqm6IHnBGkDOjAXYKjjnwIoSsEE54mN1 AYCYjpygLkhBwAYwMu4YdQGAGD7soy5IRdAGMFKYpS4AUE1RfXVBSgI3gBnF6gIA 1WSWqAtSErgBjFwyTF0AoIrBT6kLUhO8AYz81EVdAKCSGXuqC1IUwAGMbArc522A UNtcV12QqiAOYNuF6gIAUdotUhekKogDGPnn1eoCADs8/Cd1QcoCOYCR5UG57jwQ fnkt1AWpC+YA8pE4wBaB/AhcuYAOSa+v1AUASh34tbogDQEdwMiYE9UFAH713/7q gnQEdQAjBcH85A0QLoXZ6oK0BHYA+UgcYIGAfgSuXGAHMHLec+oCwHnnP68uSE9w BzDyw17qAsBxP+6tLkhTgAeQj8QBWsH9CFy5IA8gH4kDpIL7EbhyQR7AyKNXqAsA hz12pbogbYEewMjKAF6GCgiJVc3UBekL9gBGtqoDAGcFfDxKBfx/Q7931AWAo054 V13ggYAPYGTioeoCwEmfHqYu8ELQBzBSUk9dADhoY4a6wBOBH8Cc9eoCwEEN89UF ngj8AEZuu1VdADjn9tvUBd4I/gBGFrdWFwCOWdJGXeCREAwgp4cGzAr0SaArCcN2 cHpowKhAnwS6kjAMIKeHBkwK9kmgKwnFAHJ6aMCcgJ8EupJwDCCnhwaMCfhJoCsJ xwBGLntcXQA44vIn1AUeCskARmZ1UhcATpi9h7rAS2EZwMjm0LwwD1hsS7jOwx6a Aezyk7oAcMCeM9QFngrNAEaeP1ddAITeiPPUBd4KzwBG1jVUFwAht76RusBjIRpA Tg8N+CxMe1EqTP+DBr6sLgBC7cxR6gKvhWkAuVQ64KfAXwa9ulANIJdKB/wT/Mug VxeuAewwR10AhFbHueoC74VrACMjz1YXACH1wjnqAh+EbAAj+Q3UBUAobchRF/gh bAPIeWEAX4TpHDAVwjaAkUuGqQuAEBr8lLrAF6EbwMjsjuoCIHTmhPR0S+EbQM4L A3gtZOeAqRDCAew+RV0AhEyPqeoCn4RwACOjT1YXAKHy1gB1gV/COICRwix1ARAi ReG96FgoB5D3wgAeCuc7YEqFcgAj192nLgBC4/r71QX+CecARha2VRcAIbGonbrA RyEdwMiWsP4PA8zaGuq3lYV1J3p9pS4AQuHAr9UFfgrrAEbGHaMuAELgwz7qAl+F dgAjxRnqAiDwSjLVBf4K7wDmrFcXAIHXMF9d4K/wDmDk7hvUBUDA3XOjusBnIR7A yPLm6gIg0PJaqAv8FuYB5L0wQDrC/Q6YUqGeiH7vqAuAADvhXXWB70I9gJFJ+6kL gMD6dn91gf/CPYBcKBhIVRgvA1xNyAewy0/qAiCg9pyhLjAg5AMYef1UdQEQSG+c pi4wIewDGCkK+TvZAV8Uu3FW4dAPIB8IAVIQ9o+AbBf6AeQDIUDyQv8RkO3CP4CR lU3VBUDArGqmLjDEgQGMbFUHAAHjwi6UcuF/6Nkj1QVAoJzzgrrAFBcGMDJzD3UB ECCzOqsLjHFiACObw/+hbsArWxz6/JQbA9jzO3UBEBj7fq8uMMeNAYx8eLS6AAiI 8S5dTseRAYyU1FMXAIGw0amL6bgygC2WqQuAQGi5XF1gkisDGHnqYnUBEABPX6Iu MMqZAYysz1EXANbLb6guMMudAcwoVhcA1sssUReY5c4ARq56WF0AWO7qR9QFhjk0 gJGFbdUFgNUWtVMXmObSAHKZTKAmDlwGsyqnJqHPWHUBYLG+49QFxjk1gJFvHLjO H5CiSQeoC8xzawA5KwIQj0vnQNjBsQHsPkVdAFiqx1R1gYBjA8hZEYDYnDoHwg6u DWBkowuXuweStcnN04U4N4BtF6oLAAu1W6QukHBuACOvn6ouAKzzxmnqAg33BjBS 7NT5zoAElGSqC0QcHMDcVeoCwDJNV6sLRBwcwMjwC9QFgFWeHaQuUHFxACMF9dUF gEUKs9UFMk4OYM56dQFgkYb56gIZJwcwMvQadQFgjQeHqAt03BzAyDrHTvwNxLW+ kbpAyNEB5Pz4wHaunQW/EkcHMHLD3eoCwAo33qMuUHJ1ACMrm6oLAAusaqYukHJ2 ACNb1QGABdxdgFLu/s+/ZJi6AJAb/JS6QMvdAYwsbq0uAMSWtFEXiDk8gPwQDOe5 fPyXcvkBOPV1dQEgddob6gI1lwcwMrujugAQmtNJXSDn9ABypXS4zMHroFfj9gJw pXQ4zMHroFfj9gBGfuyhLgBEpuylLrCA4wPID8FwFT8Ab+P68X/Ex+oCQOLICeoC G7g+gPwQDDfxA3Ap5weQH4LhIn4ALsPRzw/BcBA/AJdhACM/dVEXAIbN2FNdYAkG kB+C4Rx+AC7Hsc/boeEc3gJdjgGM8EMwHMMPwDswgNvwQzAcwg/AFTjyt+GHYDiE H4ArMICl+CEYzuAH4CgMYBl+CIYj+AE4Gsd9mf5vqwsAI04aoy6wCQO43fz26gLA gAW7qguswgCW4xJJcAFHfCU8HOUG/VtdAPjuwuHqArswgDssa6EuAHy2vKW6wDIM YAV+CEbYcbxXwQNS4Zqh6gLAV0MeVBfYhgGMsrqJugDw0ZpcdYF1GMBo/BCMMONo r4aHJNpdN6kLAN/8/WZ1gX0YwEryG6gLAJ9syFEXWIgBrCSjWF0A+CSzRF1gIQaw suEXqAsAXzw7SF1gIwawipJ66gLABxsz1AVWYgCraLtQXQD4oN0idYGVGMCqxh2j LgA892EfdYGdGMBqNnPCSITNlp3UBZZiAKvp9ZW6APDYgV+rCyzFAFY3tZu6APDU tO7qAlsxgDFwgRCECpcBiYtDPYaBL6sLAA+dOUpdYC0GMJZfWqkLAM8s3UVdYC8G MCZOC4Pw4CCPj8cmplvuUBcAHvnbneoCizGAsW3IVhcAnijgDEc1YABjy1mvLgA8 0TBfXWAzBjCO109VFwAeeOM0dYHVGMB4NvHhIQTf1l6T1AlWYwDj6T5FXQCk7aa7 1QV2YwDj+rGHugBIU173PHWC3RjA+PhEHILuyAnqAstxjMd39kh1AZCWERdsUSdY jgGswYpm6gIgDUVd56kTbMcA1oRPxCHIThqjLrAeA1iTf16tLgBSNvH4AnWC9RjA GhVlqguAFG3Ze6o6wX4MYI24RhwC66pH1QUBwADW7Kte6gIgJUt6rFYnBAADWAve DIhgOvQzdUEQcHjXgjcDIpCev3CzOiEIGMDarG6iLgCSVrznPHVCIDCAtckoVhcA STv9NXVBMDCAtRp5troASNLkQ3gLYEIYwNpxZkAEzNaeP6gTAoIBrF3P79QFQFJu v01dEBQMYAJmdVIXAElY02W5OiEoGMBEcFIEBMkx49UFgcEAJuK6+9QFQMLeOWWj OiEwGMCEFGapC4AEbe42U50QHAxgQlosUxcACRr8lLogQBjAxEzaT10AJGRZV06C kDgGMEGcFAHBwEkQksFhnaCrHlYXAAl4cyCvgCSBAUxUQX11AVCrzZ3nqhMChQFM FK+DIAAufkZdECwMYMK+PFBdANTil65r1QnBwgAmjtdBYLuDv1AXBAzHdOIuGaYu AGo06g+cBjo5DGASNmSrC4AabOq4QJ0QNAxgEnJXqQuAGpz/vLogcBjAZHzeW10A xPXLnuvUCYHDACaF10Fgr95fqguChwM6KZwXC9biLFgpYACTU5SpLgBi2rIHnwFJ HgOYnA5z1AVATEMe2qJOCCAGMElzOqgLgBjWteczIClgAJPF9UFgI64DkhIGMFlP XKouAKr5+lBeAUkFA5g0rpMO62ztOkOdEEwMYNIO+VRdAFTxwF95BSQlDGDyVjRT FwCVFLdZqU4IKAYweRnF6gKgklNGqwuCigFMwf+OUxcAUeZ1LVInBBUDmAo+Egyb 7Pu9uiCwOJJTcc1QdQGww5jTeAtMqhjAlJTUUxcA221tv0idEFwMYEp6fqcuALa7 /Q7eApMyBjA1y5urC4BSxS35EHDqGMDU8FYYWIK3wKSDAUzRhMPVBcCvlnTkLTBp YABTxVlhYIMDJqkLAo0BTNVtt6oLgMj4Y7kScDoYwJRtrKsugPO27saVgNPCAKaM s8JAbuj1vAUmLQxg6lY3URfAcRub8xaY9DCAqctZry6A4/7wMt8ApocBTMNPXdQF cNraVrwFJk0MYDp4KwyUDp+oLgg8BjAdo09WF8Bhs/fkLTDpYgDTwokBodNjqrog +DiA03LLHeoCOGvccbwCkjYGMD1cIxMinAbQCwxgevqMVRfAUY9dzTeA6WMA07Qh W10AJ21uxnugPcAApqnFMnUBnHTp03wD6AEGMF2LW6sL4KDCJiXqhFBgANPGu6Fh 3vEf8PfOCwxg2j7vrS6Ac5bvwg/AnmAA08d/imEa54H2CAOYPj4QB8PmdOYbQG8w gB7gW0CY1W26uiAsGEAPPHqFugBO+eYgvgH0CAPoBc6JAJN2n6cuCA2OXC9cd5+6 AA55/7d8A+gVBtATnBMB5rRcri4IDwbQEwNfVhfAGS+cxzeAnmEAvVFST10AR2zN 5SwI3mEAvdHrK3UBHHHfjXwD6B0G0COcFgtGbGnAleA8xAB6pMMcdQGccP1QvgH0 EAPolXUN1QVwwKZM9s9LDKBXODMqDLh8GAPoJQbQM2saqwsQenwD6DEG0DN8Cwjf DX6GAfQUA+idVbnqAoTcxgx1QdgwgN7JXaUuQMgNep5vAL3FAHpoRTN1AUKNbwA9 xwB6KGe9ugChdu5/+AbQYwygl/J2VhcgxEoy1QXhwwB6iW8B4aNzXlAXhA8D6Kml LdUFCK3iLHVBCDGAnuJbQPjmrJfUBSHEAHqLbwHhE74B9AMD6C2+BYRPzhrFS8De YwA9xsdB4AveA+gLBtBjfCIYvrh0mLoglBhAr63PURcghDbXVReEEwPoNU4NDR9c f7+6IJwYQM8V8modvLaFC0/7gwH0HBeIg+fu+6u6IKQYQO8V83odvLW1Lm+B8QcD 6L1+76gLEDJPX6IuCCsG0AcbecUOXtqaVaJOCCsG0Adnj1QXIFReGaguCC0G0A+b 66gLECYNCtQFocUA+uGWO9QFCJEP+6gLwosB9MUWHld4pkWeuiC8OFB98fqp6gKE xpxO6oIQYwD9sVUdgNDoNl1dEGIMoD+mdlMXICTWNlEXhBkD6BO+BYQ3jhmvLggz BtAnXCETnuBamL5iAH3CiVHhCU6E6isG0C8F9dUFCAHOg+UvBtAvh3yqLkAIPHqV uiDcGEDfbOK/3UgbB6i/eHx9c81QdQEC74Pj1AUhxwD6h8/DIV1N1qoLQo5j1D// 47/eSM+CXdUFYccA+og3QyM9+36vLgg7BtBHS1uqCxBoxVxg0G8MoI94MzTSwpug fccA+onrwyENWzmxuO8YQD9xcRCkYdSZ6oLwYwB9xTthkLr6ReqC8OMA9dXok9UF CKy5HdUFDmAA/cU7YZCqHlPVBQ5gAP21uLW6AAFVxOmEDGAA/ZW7Sl2AgLpwuLrA BQygz4o4oS9SwXtgjGAAfTbo3+oCBNKrZ6gLnMAA+o2XQZCKBgXqAicwgH77rqe6 AAG0kotqGcEA+i2jWF2AADrhXXWBGxhA3xVySg8ki2shGcIA+o4PBCNpL52lLnAE A+g/XgZBsvgYsCEMoP++2V9dgIBZ0Vxd4AoG0AC+BURy+o5TF7iCATSggE91Ihm8 BGIMA2jAwJfVBQgUXgIxhgE0gfOiIhmZJeoCZ3BkmsDLIEhCXgt1gTsYQBP4NAiS cPz76gJ3MIBGcHk4JIwTYRnEABpxw93qAgTGuL7qAocwgGbwVkAkaueV6gKHMIBm /NJKXYCA4FogJjGAZnSYoy5AQFx/v7rAJQygIbwVEInhL4pJPNqGTDxUXYBAWNJG XeAUBtAQ3gqIhHAeBKMYQFNK6qkLEAC8CdAsBtCUodeoCxAAXxysLnALA2gMbwVE 7XZdoC5wCwNoTH4DdQGst4lflJjFABoz6N/qAljv1TPUBY5hAM3hZ2DUpmG+usAx DKA5q3LVBbBcSaa6wDUMoDl9xqoLYLlHr1IXuIYBNIifgVEzDkfTeMQNWtxaXQCr FfBGAdMYQIN6fqcugNVuu11d4BwG0CR+BkZNOBqN4yE3aWFbdQEstiFHXeAeBtCk 7lPUBbDYjfeoC9zDABrFz8CIj4PRPB5zo/gZGHHxE7AAA2gUrwMjLl4DFmAAzeJn YMTDsSjAg27WyqbqAliqOEtd4CIG0KxTX1cXwFJPX6IucBEDaBg/AyO2zBJ1gYsY QMM4LzRi4lzQEgygYXfdpC6AlcYeqy5wEgNoGj8DI5Z2i9QFTmIATdtYV10AC3E9 YA0G0LQPj1YXwEI/d1AXuIkBNC2jWF0ACx3/vrrATQygcVt4zFENfyk0eNyN48T4 qCa/obrAUQygcVwcDtUMvVZd4CgG0DzeCIOqdtqiLnAUA2heEVe/RmVbdlIXuIoB NO/lgeoCWGZyT3WBqxhAAX4GRmUHTFIXuIoBFOCNMKiMvxAqPPICy1qoC2AVrgYi wwAKnPecugBWGX6husBZDKACvwREtMbr1AXOYgAVNvGuB1TgTDA6DKDC1G7qAlhk eUt1gbsYQIXuU9QFsMhfHlIXuIsBlOCXgKjAQajDYy9RwhVwUI7PwQkxgBLf7K8u gDUWtVMXOIwBlOgwR10Aa1z8jLrAYQygBr8ERDmOQSEefI0VzdQFsMTKndUFLmMA NTglFrYbdaa6wGUMoEbrxeoCWKLNEnWByxhAEX4JiDIcgko8+iJrG6kLYIV1jdUF TmMARd4/Vl0AK3xwnLrAaQygyN6T1QWwwj4/qAucxgCq8EtAbMMRKMXDr8LFMfGr 4ix1gdsYQJUZndUFsMDMLuoCtzGAKnferC6ABe66RV3gNgZQJatQXQAL1C9SF7iN AZThVRBwAKrx+MvwVmjwNmg1BlDmk8PUBZCbeLi6wHEMoEz/t9UFkDtpjLrAcQyg Dr8EBMefGE+ADgMIjj8xngCdxa3VBRBb0kZd4DoGUGfEOeoCiI08V13gOgZQp+s0 dQHEuk1XF7iOARTil4Cu4/BT4xkQYgBdx+GnxjMgtKyFugBSy1uqC5zHAAq9+1t1 AaTe66cucB4DKHTs++oCSB33gbrAeQygEr8EdBtHnxxPgRID6DaOPjmeAqU1nAzJ ZWubqAvAACp93ltdAKEvDlYXgAFUumSYugBCg59SF4ABVKq7UV0AoXqb1AVgAKV4 FcRlHHx6PAdShVwW211F9dUFYAC1FrRTF0BmYXt1ARhArdEnqwsg89YAdQEYQC0u jOQwLohkAQZQi1dB3MWxZwGeBC0G0F0cexbgSdAqylQXQKSYdwBYgAHUWthWXQCR RbwDwAIMoNaYE9UFEPlvf3UBGEC1372qLoDI6a+pC8AAyvEqiKs49GzAsyDGALqK Q88GPAtixRnqAkiU8Pq/DRhAsbyd1QWQWNFcXYAIAyj39QHqAkh800tdgAgDKPeP P6sLIPHQX9QFiDCAct2nqAsg0WOqugARBlCPl4HdxJFnBZ4GNQbQTRx5VuBpUON9 ME7iXTB2YADVeB+Mk3gXjB0YQDXeB+Mk3gVjBwZQjffBOIl3wdiBAVTjfTBO4l0w dmAA5XgZ2EUceHbgeZBjAF3EgWcHngc5BtBFHHh24HmQW5+jLoBx+Q3VBSjFAMr9 vJu6AMbN211dgFIMoNzYPuoCGDeur7oApRhAudtuVRfAuNtvUxegFAMo13mGugDG dZmpLkApBlCPl4Hdw3FnCZ4IPQbQPRx3luCJ0GMA3cNxZwmeCL38BuoCGLaB935a ggHUW9hWXQDDFrVTF6AMA6j3yWHqAhg28XB1AcowgHqPXa4ugGGPX6EuQBkGUG/A m+oCGHbKaHUByjCAelmF6gIYVr9IXYAyDKAFeB+MazjsbMEzYQEG0DUcdrbgmbAA A+gaDjtb8ExYoKC+ugBGFWarC7AdA2iB5Vwk2y15LdQF2I4BtMDUbuoCGDWtu7oA 2zGAFni7v7oARo05SV2A7RhAC9xwt7oARt14j7oA2zGAFug+RV0Ao3pMVRdgOwbQ BrwPxi0cddbgqbABA+gWjjpr8FTYgAF0C0edNXgqbMAAuoWjzho8FTYoylQXwKDi LHUByjGANljdRF0Ag9bkqgtQjgG0wfz26gIYtGBXdQHKMYA2+PoAdQEM+qaXugDl GEAbjDpDXQCDXhmoLkA5BtAGN9+pLoBBt9ylLkA5BtAGvT9XF8Cgg79QF6AcA2gF 3gjoEg46e/BcWIEBdAkHnT14LqzAALqEg84ePBdWYABdwkFnD54LKzCALuGgswfP hRUK+XSoO4q4CKA9GEArrGmsLoAxa/nktz0YQCssbq0ugDFL2qgLsAMDaAUujOkQ LoppEQbQCuOOURfAmA/7qAuwAwNoheEXqAtgzLOD1AXYgQG0wpAH1AUw5tqh6gLs wABa4bBP1AUw5vCJ6gLswABaIbNIXQBjsorVBdiBAbQDHwVxB8ecRXgy7MAAuoNj ziI8GXZgAN3BMWcRngw7MIDu4JizCE+GHRhAd3DMWYQnww7FGeoCGFKSqS5ABQbQ DvkN1AUwZEOOugAVGEA7rGyqLoAhq5qpC1CBAbTDgnbqAhiysL26ABUYQDtwPixn cDYsmzCAdvj4CHUBDJlwpLoAFRhAO7w8UF0AQ0adqS5ABQbQDvf8VV0AQ+69QV2A CgygHQb9W10AQy4cri5ABQbQDvt+qy6AIft9py5ABQbQDpwQ0BmcDtAmDKAl+DCw KzjkbMKzYQkG0BUccjbh2bAEA+gKDjmb8GxYggF0BYecTXg2LMEAuoJDziY8G5Zg AF3BIWcTng1LMICu4JCzCc+GJYo4T7AbirPUBYjCAFqCU0I7ghNCW4UBtASnhHYE J4S2CgNoicWt1QUwYkkbdQGiMICWmN1RXQAj5nRSFyAKA2iJ7/dRF8CIyT3VBYjC AFqCc+I7gjPiW4UBtMTb/dUFMGLMSeoCRGEALfHvQeoCGDH8QnUBojCAluCiII7g kiBWYQAtceUj6gIYcdWj6gJEYQAt0e8ddQGMOOFddQGiMICW6DpNXQAjuk1XFyAK A2iJnTapC2BE3c3qAkRhAG3B+bDcwBFnFZ4OWzCAbuCIswpPhy0YQDdwxFmFp8MW DKAbOOKswtNhCwbQDRxxVuHpsAUD6AaOOKvwdNiCAXQDR5xVeDpswQC6gSPOKjwd tmAA3cARZxWeDltwXUwncFVMuzCAtiiory6AAYXZ6gJEYwBtsa6hugAGrG+kLkA0 BtAWXBjYCVwW2C4MoC1+aaUugAFLd1EXIBoDaIv57dUFMGDBruoCRGMAbTGtq7oA Bkzvpi5ANAbQFpP2UxfAgG/3VxcgGgNoi08OUxfAgImHqwsQjQG0xTv91AUw4N0T 1AWIxgDa4uWB6gIYMOpMdQGiMYC2GHaJugAGPDVYXYBoDKAt7vmrugAG3HuDugDR GEBbDHlAXQADrh2qLkA0BtAW5z2nLoAB5z+vLkA0BtAWfcaqC2BA33HqAkRjAG2x x0x1AQzoPEtdgGgMoC2yN6gLYECDAnUBojGA1uCc+C7ggLMLz4c1GEAXcMDZhefD GgygCzjg7MLz4aFmfzy3ZU6MaxsVF+evWbpo1k/TZxfX8NUMoAtqOuAyO3Xdc4+2 rZrkZMb6S5S/bMS/VvrW5SoG0Bu/P3+fpvUS/cPFJfmr8xbM+XUQo38jzgC6IPqA y/518Dq2b56bk5HwFQE3rpr83Es+ZDmLAUxbh9uOa5nWDRStz1s8Z+bPb3rUA5ud snvnjm2aN0zv4pjL3r9trkc9rmMA05L1+Cm5Ht1USYZHNwSbefY0r37z8iKPbspl DGDqjn1wL3UCnPbjNR+oE4KOAUxRs9GcwRl6Ewfwwkg6GMCUDDu3vjoBKFU4glMM po4BTF7W+N7qBCDKF0fz68AUMYBJ+3ZfdQFQxXdcUzA1DGCSxvZRFwAxjOurLggk BjAp19+rLgDi+Ot96oIAYgCTsTS9dzwDflrWSl0QPAxg4q56WF0A1OjqR9QFQcMA Jozf/sF6/CYwSQxgopY3VxcAtcproS4IFgYwMe3nqwuAhOy6QF0QJAxgQrhkGwKD C88lgQFMBPuHAGEBE8cAJoD9Q6CwgAljAGvH/iFgWMBEMYC16jBHXQAkqSNnjE4M A1ibm+9UFwBJu+UudUEwMIC14VpFCCKO7ITwMNWigDOfIogKs9UFgcAA1mzUGeoC ICWvDFQXBAEDWKOc9eoCIEUN89UFAcAA1qgk4YudA5bZyIVWa8cA1uTt/uoCIGVj TlIX2I8BrAFnQECgcV6EWjGANSjKVBcAaSjOUhdYjwGM77Zb1QVAWm6/TV1gOwYw Pt4CjaDj+K4FD1BcX/VSFwBp+vpAdYHlGMC4+AYQwccBXjMen3jW56gLgLTlN1QX 2I0BjKPZCnUB4IGdV6oLrMYAxsEPwAgHDvGa8OjEdtnj6gLAE5c/oS6wGQMYG98A Iiw4xmvAgxPTmwPUBYBHRp+iLrAYAxgT3wAiPDjI4+OxieV/x6kLAM+8f7y6wF4M YCx8A4gw4SiPi4cmhicHqwsADw27VF1gLQYwBk6DhVDhtFhxMYDVcR5UhAxnRo2H Aaxuajd1AeCpad3VBbZiAKvjJRCEDcd5HDww1fzSSl0AeGzpLuoCSzGA1fANIMKH Az02HpdqGECEDwd6bDwu1TCACB8O9Nh4XKpa01hdAHhubRN1gZ0YwKr4BhBhxJEe Ew9LVQwgwogjPSYelqoYQIQRR3pMPCxVLGyrLgB8sKidusBKDGAVfAOIcOJQj4VH pQoGEOHEoR4Lj0oVDCDCiUM9Fh6VylovVhcAvmizRF1gIwawstW8XxThtCZXXWAj BrAyfgJGWHGsx8CDUhkDiLDiWI+BB6UyBhBhxbEeAw9KZQwgwopjPQYelEqWN1cX AD7Ja6EusBADWAnfACK8ONir4zGphAFEeHGwV8djUgkDiPDiYK+Ox6QSBhDhxcFe HY9JtB/2UhcAvvlxb3WBfRjAaMUZ6gLANyWZ6gL7MIDR+AkYYcbRXg0PSTQGEGHG 0V4ND0k0BhBhxtFeDQ9JlAFvqgsAH50yWl1gHQYwyirOmIYwW91UXWAdBjAKPwEj 3Djcq+IRicIAItw43KviEYnCACLcONyr4hGp0GGOugDwVce56gLbMIAVhl+gLgB8 9ewgdYFtGMAKhVnqAsBXRfXVBbZhACvwK0CEHcd7FTwgFRhAhB3HexU8IBUYQIQd x3sVPCAVGECEHcd7FTwgFRhAhB3HexU8IBUYQIQdx3sVPCA7fHmgugDw2VcHqQss wwDuwEXREXpcHL0KBnAHLgiC0OOyIFUwgDvwK0CEHwd8ZTweOzCACD8O+Mp4PHZg ABF+HPCV8XjswAAi/DjgK+PxKPd5b3UB4LsvDlYX2IUBLPdLK3UB4Lulu6gL7MIA livgVGkIv8JsdYFdGMBy/AoQLuCIr4SHoxwDCBdwxFfCw1GOAYQLOOIr4eEoxwDC BRzxlfBwbDfqDHUBYMArA9UFVmEAt5vWVV0AGDC9m7rAKgzgdqty1QWAAaubqgus wgBux8mw4AROiFUJA7gdr4HADRzy0Xg0tmMA4QYO+Wg8GtsxgHADh3w0Ho3tGEC4 gUM+Go9GmRd/ry4AjHjpLHWBTRjAMj/spS4AjPhxb3WBTRjAMiuaqQsAI1burC6w CQNYpqSeugAwYiPveI3CAJbhNRC4gmM+Cg9GGQYQruCYj8KDUYYBhCs45qPwYJRh AOEKjvkoPBhlGEC4gmM+Cg9GKS4KDGdwaeAoDGCp1U3UBYAhazj1ZQUGsBQ/AcMd HPQVeCxKMYBwBwd9BR6LUgwg3MFBX4HHohQDCHdw0FfgsSjFAMIdHPQVeCxKMYBw Bwd9BR6LUgwg3MFBX4HHYpt3+qkLAGPePUFdYA8GcJt5u6oLAGPm76YusAcDuE1+ A3UBYMyGHHWBPRjAbfgVIFzCUb8DD8U2DCBcwlG/Aw/FNgwgXMJRvwMPxTYMIFzC Ub8DD8WvxvZRFwAGjeurLrAGA/irhW3VBYBBi9qpC6zBAG4zrR1vDIAr8hd2UyfY gwGsMGr/luwgwit/2aSB6gbbMIDVjDqgBTuIMMlf/g3LFxsDGM/LB/D9IAIuf9k3 Z6ob7MYA1ubbDtn11A1AUjYWzN1P3RAMDGCCxnVvnKVuAGpRtHYq7+lKBgOYnBEH tWjAN4SwzcYNy788Vx0RRAxgakYd0LyhugGIrM/j9Y10MIDpeeHA5tkZ6gg4p6Qg 76uz1RFhwAB6ZPT+TXjRGH7LXzNpgLohVBhAr43ev3EWvyWElzYWrWX3/MEA+uax I5o35EzTSN2G9XkTrlBHhBwDaMDQI1s0yeI3hUhESdGa5R8PUVc4gwE06x/HNG2U lamugGWKi9at+vAv6goXMYA69x/btGFWfXUFRAqL1q/64Dp1hesYQEvc069JTv26 vHoSZhs3FeavefcGdQaiMIBWuvmkxo3qZ7CHAbdxU0nhurVv36XuQFwMYCDcfFrD BlmZDKLlNm4qLtqw/nUGLzgYwID687nZ2dkZdXdiE1U2bt5UUlBQMOIhdQjSwACG yKBLsnKyM+vttBNvufFWyebNG4sL8oueGq4ugccYQAf87tqM7MzMjF+XsQ7fMMa3 ccuvO1dSXFxQ8sBr6hYYwgACcBYDCMBZDCAAZzGAAJzFAAJwFgMIwFkMIABnMYAA nMUAAnAWAwjAWQwgAGcxgACcxQACcBYDCMBZDCAAZzGAAJzFAAJwFgMIwFkMIABn MYAAnMUAAnAWAwjAWQwgAGcxgACcxQACcBYDCMBZDCAAZzGAAJzFAAJwFgMIwFkM IABnMYAAnMUAAnAWAwjAWQwgAGcxgACcxQACcBYDCMBZDCAAZzGAAJzFAAJwFgMI wFkMIABnMYAAnMUAAnAWAwjAWQwgAGcxgACcxQACcBYDCMBZDCAAZzGAAJzFAAJw FgMIwFkMIABnMYAAnMUAAnAWAwjAWQwgAGcxgACcxQACcBYDCMBZDCAAZzGAAJzF AAJwFgMIwFkMIABnMYAAnMUAAnAWAwjAWQwgAGcxgACcxQACcBYDCMBZDCAAZzGA AJzFAAJwFgMIwFkMIABnMYAAnMUAAnAWAwjAWQwgAGcxgACcxQACcBYDCMBZDCAA ZzGAAJzFAAJwFgMIwFkMIABnMYAAnMUAAnAWAwjAWQwgAGcxgACcxQACcBYDCMBZ DCAAZzGAAJzFAAJwFgMIwFkMIABnMYAAnMUAAnAWAwjAWQwgAGcxgACcxQACcBYD CMBZDCAAZzGAAJzFAAJwFgMIwFkMIABnMYAAnMUAAnAWAwjAWQwgAGcxgACcxQAC cBYDCMBZDCAAZzGAAJzFAAJwFgMIwFkMIABnMYAAnMUAAnDW/wc77wqmRWWJUAAA AABJRU5ErkJggg=="/></symbol><g mask="url(#b)"><g transform="rotate(.193) scale(.36014)"><symbol id="c" viewBox="0 0 1280 1280"><image width="1280" height="1280" xlink:href="data:image/png;base64, iVBORw0KGgoAAAANSUhEUgAABQAAAAUACAIAAACXhmigAAAACXBIWXMAAA7EAAAO xAGVKw4bAAE6aUlEQVR4nOzdC3xcdZ3//zT3uWeSyWRya6GFtiAKv5WKl8Ur+NvV PxZFquwKAlpALru6WuSiD8qiCJatoigrXVAU1ooWcIEWqVS8rJdKufqD0tA218lk Mvf7ff7fZGrsJZfJ5HzPmcy8ng83W9KZz/fbmenpeed7W1IDAAAAAEAVWKJ1BwAA AAAAUAMBGAAAAABQFQjAAAAAAICqQAAGAAAAAFQFAjAAAAAAoCoQgAEAAAAAVYEA DAAAAACoCgRgAAAAAEBVIAADAAAAAKoCARgAAAAAUBUIwAAAAACAqkAABgAAAABU BQIwAAAAAKAqEIABAAAAAFWBAAwAAAAAqAoEYAAAAABAVSAAAwAAAACqAgEYAAAA AFAVCMAAAAAAgKpAAAYAAAAAVAUCMAAAAACgKhCAAQAAAABVgQAMAAAAAKgKBGAA AAAAQFUgAAMAAAAAqgIBGAAAAABQFQjAAAAAAICqQAAGAAAAAFQFAjAAAAAAoCoQ gAEAAAAAVYEADAAAAACoCgRgAAAAAEBVIAADAAAAAKoCARgAAAAAUBUIwAAAAACA qkAABgAAAABUBQIwAAAAAKAqEIABAAAAAFWBAAwAAAAAqAoEYAAAAABAVSAAAwAA AACqAgEYAAAAAFAVCMAAAAAAgKpAAAYAAAAAVAUCMAAAAACgKhCAAQAAAABVgQAM AAAAAKgKBGAAAAAAQFUgAAMAAAAAqgIBGAAAAABQFQjAAAAAAICqQAAGAAAAAFQF AjAAAAAAoCoQgAEAAAAAVYEADAAAAACoCgRgAAAAAEBVIAADAAAAAKoCARgAAAAA UBUIwAAAAACAqkAABgAAAABUBQIwAAAAAKAqEIABAAAAAFWBAAwAAAAAqAoEYAAA AABAVSAAAwAAAACqAgEYAAAAAFAVCMAAAAAAgKpAAAYAAAAAVAUCMAAAAACgKhCA AQAAAABVgQAMAAAAAKgKBGAAAAAAQFUgAAMAAAAAqgIBGAAAAABQFQjAAAAAAICq QAAGAAAAAFQFAjAAAAAAoCoQgAEAAAAAVYEADAAAAACoCgRgAAAAAEBVIAADAAAA AKoCARgAAAAAUBUIwAAALEh7u62urm7Jktolh9RM/N+8/4XNTzr0//L5XDabHR/3 SOkxAADVigAMAMD8OBwdU3G3tlb8b+LX9fUN4v83NTWJEFtfX1dC2UwmK4JzMpnM 5fKZTHoiBE/IT0Vil2tM8T8LAABVhQAMAMAc2traGhoaCkFXfKmrqxP/Kb42NjaK b0ptWiTgVCqVzWbT6bT4WsjD4pviP71er9SmAQCoPARgAACmYbPZ6uvrJkNvbSHx NjaK/zVOTm/WjEi/qQnpQh4uDBJnMlmPh8nSAADMjQAMAMDfTC7orRe5V6Tf+voG vV5XX1+vdadmlMlkYrF4JpMWGVgk4Ww2w7JhAABmQQAGAKAw3ltfVydy78Qwr8Gg 17pH8xaNxlKplAjD2WxOBGPGhAEAOBYBGABQvWy2tsncOzHYazabxC+07pECstls KBSeTMLZySTMUmEAAA4hAAMAqk7h4KLa2tqGhoampma9Xqd1j6SIxeLJZCKdTk/O juZQJQAACMAAgGoyOeTbUF9fp9PpRe7VdkcrdeTzeZGE4/FYJpPNZNIMCAMAqlnl /8MPAIDD0SHin8i9zc3NJlOFTHWer2w2Gw6HE4lE4aXgVGEAQBUiAAMAKpmIvuJr bW2dTtes1+urM/oeTsTg2MSIcCKXy4r/JAYDAKoKARgAULHsdntjY8PEXGddVcx2 Ll4+n5+YFR2LpVJpt9utdXcAAFAJdwMAgArkcHQ0NDQYjcampiYR9ki/xyq8LMlk MhKJpNNphoIBANWAGwIAQKXp7e0R0bexsVH8mug7OxGDxddUKiVi8NDQsNbdAQBA Lm4LAACVo6enW6/XNzU1sdZ3vrLZbDKZjMViw8MjWvcFAABZCMAAgErQ1dVpMBia m5tra2sZ9S1NPp/P5XKJRCIajTqdo1p3BwAA5XGLAABY3ByODr1eL9Iv0VcRhRgs MnAsFmNhMACgwnCjAABYxJYuXWow6BsaGkT61bovFUVk4HQ6LVLw4OCg1n0BAEAx BGAAwKJUmPPc1NRUX1+vdV8qViaTSSaTzIgGAFQMAjAAYJGx2+06nU6v14n0q3Vf qsLk5lhxgRODAQCLHQEYALCYdHV1GQz65uZm9nlWUzabndwcK+Z0OrXuCwAApSMA AwAWB4ejo6mpWacT4bdZ675UKZGB4/FEMplgcywAwCJFAAYALAJdXZ2T0571DPxq K5vNxibnQ7MqGACwGBGAAQDlrre3R0RfEYC17ggOEQFYxOChoWGtOwIAwPwQgAEA 5cvh6GhubjaZTAz8lptsNhsOhxMJpkMDABYTAjAAoEx1dXUW0u+SJUvy+bz4qnWP cEjh7RBfCxmY6dAAgMWCmwkAQNlxODrq6ur1ep3BYNC6L5hDNBqNxeLZbIahYABA +SMAAwDKi91ub2pqFNGX3Z4Xi8kTkqLJZIqDggEAZY4ADAAoIw5HR2Njk8ViXoyL fvP5vF6vX7p02amnnmqz2davX1/kE7ds2eLxeF588cXBwYFYLLYYJ3tns9lgMJRK JRkHBgCUs8X3TywAoFI5HA6drtloNIr0uygW/YrUZ7O1r1ix4i1veUvxcbcYIhLv 3r17//79Hs94+f8soPBmiVcjEonE4wmXy6V1jwAAmF6531sAAKqEw9FhMBhMJpPW HZlDIfS++c1vXrdu3Zo1a1Ro8c9//vNDDz20Z8+eRRGGw+FwNBplHBgAUJ4IwAAA 7XV2OkT6NRqNWndkRiL3Ll26dP36y9auXathN7Zt+9mWLVtGRkbq6+s17MbsIpGI yMCjo4wDAwDKDgEYAKCxrq5Ok8ms05XjlldlknuFdDodCARyuVzhP3/xi1/8938/ WLZJOB5PhMMhjkcCAJQbAjAAQEsi/ZrN5nLb8Lkwz/mCCy5QdmVvaTKZjIi+okvT /u6DDz746KOPBgL+cpsdnUgkQiEyMACgvBCAAQCaKcP0K3LmGWe89aabburp6dG6 LzW5XM7v94sAPOcjR0dHN2/e/Pzzz5XVgDAZGABQbgjAAABtiPRrsViampq07sgh dXV155330euvv17rjhwiom8qlZrvs+6669vbt2+fmimtuWQyGQwGycAAgDJBAAYA aECk37a2tjKZtSu6cfnlV5TDbOcCkRgTicRCKjw44YEyicGZTMbn85GBAQDlgAAM AFBbZ6fDZrOVQ/ott+hb2D9ZqWrlE4OzmazH62FfaACA5gjAAABVORwi/bZpvlS1 3KJvLBYLh8MyKk+E4Ad+lM/nZRQvXiaT8Xi8LhcZGACgJQIwAEA9dru9pcWi0+mW LNHsH6BsNnvBBf9UPmt9U6lUIBCQHVDvuOOOJ5/coeHPHcQfMB6PBwJBt9utVR8A ACAAAwBUUg7pd9Wq1SIKlsMOzzWTmzz7fL6ZzjdSVjqd3rdv32233z7uHlOhuWmR gQEAmiMAAwBUsmLFcqPRqFX6rauru/vu/1yzZo0mrR8rEAgkk0k1WxQZ2B8I/PqZ Z/7rv7Zo9S6IDByJRPbvP6BJ6wAAEIABANI5HB06nc5kMtXW1qrfeuFo3y1btqjf 9LSU3elqXgLBoMvlisdid99998GDBzTZhyyXy4XD4Xg87nJpNhYNAKhaBGAAgFwi /dbX17e2tmqSfstq4LdwKK6G+1Gl0+lgKOQaHRW/6Ovru/fe/9JkKLgw9zuTyZCB AQAqIwADAOTS8Mjf009fUyYDvyL0er1edZb7zk5E30AgMDIyUsjhd9999+DggPrd EC+FeEE4HBgAoDICMABAIoejo729Xf30K9LdzTf/+9q1a1Vud1qhUCgej2vdi78J BINjY2Oxv07D3r17989+9lP136PJg5E8DAIDANREAAYAyGK32y0Ws8FgULldnU73 0EM/LYetntU54mi+Dk2EdrnSqVThO16vd/Pm/8jlcir3JBqNBoMhNoUGAKiGAAwA kEKkXxFErdYWldstn2nPPp9PRE2tezG9iYnQweDEROjDQq8m06H9/kA8HicDAwDU QQAGACivsPGV1WpVc2JtNpu95pp/Wb9+vWotzkTDfZ6LNzER2u2ORSKHf3PnhKdU ftf8fj8bYgEA1EEABgAor6ur02w2Nzc3q9aiyFG33PIVzRf9im74fD715xKXoDAR emxsLHXkccS7d+/+6U8fqq+vV60niUQiFAqxIRYAQAUEYACAwhwOh8GgN5lMqrWY z+cff/wJzRf9lttmV3MqTIR2jowcldi9Xu/tt9+m5jhwOByORmMul0u1FgEA1YkA DABQksPR0dDQ2NpqVe2A2XJIv4VDfcpts6tiTDsRukb1DCxeOp/Pn06nmAgNAJCK AAwAUFJ3d7dIv6oFJ6u1ddeuXeq0NZNwOByLxbTtQ8kOTYR2uVJ/3RH6cBs3bkwm E+r0JJPJ+P0TBxSr0xwAoDoRgAEAinE4HEajwWg05vN5FUaAyyH9jo+PL4oVv7OY dkfoKepk4MIHJjIhykRoAIA8BGAAgDIcjo6mpiar1apOc5qn31gsFg6HNeyAgiYm Qo+NxWbYuVrNcWC/359MJpkIDQCQhAAMAFCGmpOfNU+/5XzGbwkKE6Fdo6Mz/aFU y8BMhAYASEUABgAowOHo0OsNZrMaOz/rdLrf//4PKjQ0rVwu5/F4FuN+V7ObmAgd mEieM/3RbrzxBnUme4dC4VgsyiAwAEAGAjAAQAFLl/ZarWrs/Kztns+VNO35WIFg 0OVyxWfY0Eu1faHFW+z3+wcHh2Q3BACoQgRgAMBCdXV1Go1GvV4vuyFt028gEEgm k5o0rY7CROhRpzOTyUz7ANUycCwWi0QiTueo7IYAANWGAAwAWBCHo0On01ksFtkN ZbPZe++9b82aNbIbmpbH4xEd0KRpNYkM7Pf7Z1mC29fXt2XLPSpk4GAwGI/HmQgN AFAWARgAsCA9Pd1Wq/S9r0T4vOWWr6xdu1ZqKzM1LdKv+u1qJRAMOp3OZGLGLa92 7979s5/9VPY7nslkAoHA8DC7YQEAlEQABgCUzuHoMBiMJpP0g3/POuvsTZs2yas/ k2QyKWKY+u1qqHAssHNkZJYtr+6///69e1+V14fCxykcjkSjEQaBAQAKIgADAErX 29vb0mKRPRjY3d39+ONPSG1iWpGICGDTH41b2SZ2wxobi8/6Z7/11lvD4ZDUbmQy mWAwNDTEblgAAMUQgAEAJXI4HCaTyWCQu/dVPp9/4YUXpTYxrWAwmJh5GnBlK+yG 5XQ6szPshlVw7bUbZP/sIxqd2Hbb5XJJbQUAUD0IwACAEi1btsxsNkmNQNlsdvv2 Hepv++z3+1OplMqNlhWRgX1+v3Pm3bBqVNkUWnwAQqHwwMCAvCYAAFWFAAwAKIXD 0WE2m2UffXT++effcMONUps4ls/nE/FP5UbLUCAYHBkenv0HAdu2bXv22T9L7UYs FguFQqwEBgAoggAMACiFCsO/Dkfnjh075NWfltfrnekU3GozcSRSIDBxJFI+P8vD ZC8GZhAYAKAgAjAAYN5UGP4VKXTHjidVnvxM+j3KnEci1Uy+aLfd9rX6+np53WAQ GACgFAIwAGDejjtumckkd/j3sssu/8xnPiOv/rGY+XyswpFII8PD+VkHgXfu3Llr 19PyupHNZsPhcH8/g8AAgIUiAAMA5sfh6LBYLDqdTmYTjh07npRX/1jsejUTEYBH R0cT8fjsD5M9EToejweDQQaBAQALRAAGAMzP0qW9ZrNZ3pTXTCazffuO3t5eSfWP Vc0nHs2pMAjsHBnJ5XKzPEz2RGjxqQiFQoODnAkMAFgQAjAAYB5UWP177rnn3nTT Rnn1jxKJRKLRqGrNLUaBiaFXVzwWm/1hsneEZiUwAGDhCMAAgHno6emxWlvkrf6t ra3ds+c5ScWPlUgkgsGgas0tUkUOAgvXXffFJUtk3Vpks1m/PzA8PCypPgCgGhCA AQDzcOKJJ+j1enkh5847v/XOd75TUvGjiDg3Pj6uTluLXZGDwH19fffdd6+kPuTz +Vgs1tf3uqT6AIBqQAAGABSrq6uzra1N3vDv8ccvf/jhhyUVP5bb7Z59c2NMKX4Q ePPmzePjbkndyGazXq/X6RyVVB8AUPEIwACAYh1//HFGo1FSABbZ5pFHHl2xYoWM 4sfyeDyiRXXaqgxFbgctAurtt98m70MSiUQOHuyXURwAUA0IwACAotjt7W1tbU1N TZLqqzn8GwqF4nMFORylyDOBayQPAieTSZGx3W7mrgMASkEABgAUpbe3x2Jpqa+X NbL36KM/X758uYziR0mlUn6/X4WGKs/ELGinMznXkVFSB4EzmWwwGBgaYissAEAp CMAAgKJI3f5KzeHfsTHO0SlROp32BwIjRezDLG8QmK2wAAALQQAGAMzN4XC0t9sq YPWv1+vNZDIqNFSpAsHg8PBwOpWa/WGyVwKPj3tcLpeM4gCAykYABgDMbenSXovF IinPqDb8G4/HQ6GQCg1VMBGA3W53NBKZ85HyBoFFAA4Gg4ODQzKKAwAqGwEYADC3 VatWNjc3y5j/LMLMww8/csIJJyhe+VhMfl64dDodDIVGRkZyc+2hLW8QOJ/PJxKJ 117bp3hlAEDFIwADAOYgdf6zyWT+zW9+I6PyUZj8rJQiz0MSNm7cmEzOsWNWaZgF DQAoDQEYADCHpUuXtrRYamtrZRT/xje++e53v1tG5cMlk8lAICC7lSpROA9peGju Gch9fX333XevjD7kcrlAIDg4OCijOACgghGAAQBzWLnyRJ1OJ2P+swjVe/Y8p3jZ YzH5WVkiAA8NDWXS6Tkfed11X5Txycnn8/F4fN++PsUrAwAqGwEYADAbh6PDZmuX dPzvhz70oZtv/ncZlQ8XCoXiRczXRfFEAHaNjcWj0TkfuW3btmef/bOMPmQyWY9n 3OXiRxsAgHkgAAMAZtPb22O1WmXMf85ms88993x9fb3ilQ+Xz+fdbil7EVezQ7Og h4fF6zvng6+9doOMBeS5XM7v9w8NzX0oMQAAUwjAAIDZLF++3GQyypjF2tHR8eST v1C87FF8Pl+6iJm6mK8iDwQWbr311nBY+dOn8vl8OBw5cOCA4pUBABWMAAwAmFFb W2tXV5ek/Z+vv/6GdevWyag8JZPJeL1eqU1UreJnQe/evfuRR6Sc85zNZp1Op9fr k1EcAFCRCMAAgBk5HI6ODruM4V8RTV9++S+Klz2Kx+PJznVcLUpT/F7QwoYNX5Ax 1z2fz4+NuTkMCQBQPAIwAGB6LS0Wk8nc2mqVEYBFtN6x40nFyx4ulUr5/X6pTVS5 ib2gBweLOV1Z3ixon88vKgcCQcWLAwAqEgEYADC9trbWlpYWo1HKAuAvfelL5533 UcXLHm58fDyXy0ltosqJADw6OpooYodtSbOgRQCORCKBQIBZ0ACAIhGAAQDTk7cA WIX5z+l02ucjFMklXmS/3z8yMlLMgyXNgmYZMABgXgjAAIDpOSZ0SKose/4zq3/V EQgG+w8ezBdxGJKkWdCCyzXGMmAAQJEIwACAadhsNp2uua2tTUbx88776Je+9CUZ lQtE9BUBWF59TCnsg1XMQVPbtm179tk/y+iD1+uNxxO84wCAYhCAAQDTsNnaTCaT xWKRUfz551+QUXaK3+9PFXE+LRau+GXANRMHX10now/BYDAcDns8nHcFAJgbARgA MI32dpvVatXr9YpXrq2t3bPnOcXLHm5sbExqfUyZWGvt9zuLWwZ83XVflLGhWiwW 8/v94+OMAAMA5kYABgBMw263d3V1yqh84okrH3roIRmVCyKRSDQalVcfR/EHAv0H DxbzyM2bN4+Pu2X0wekcdbulVAYAVBgCMADgaA5HR21trcjAMopfeeVV69evl1G5 gOFflQWCwcGBgWK2HNu5c+euXU/L6INIv7lczuXirQcAzIEADAA4ms1ma25uEl9l FJe6ADiVSvn9fnn1cSwRgEdGRlLJZDEPlrQM2OPxJBJJ9sECAMyJAAwAOJqIvgaD wWptUbxyPp9/4YUXFS87xefzFbMjMRQ0r32wrr12g4yTpf3+QDQaJQADAOZEAAYA HE0E4NZWKTtgtbRYf/WrXyledgrzn9UnAvCY2x2LRIp58MaNG5PJhOJ9iMViPp+f AAwAmBMBGABwtPZ2EYFtTU1Nilc+/fQ1W7ZsUbxsQTweD4VCkopjJul0unAacDEP vvvuuwcHBxTvQzI5Mf+ZjaABAHMiAAMAjibSb3d3l4wTa6TugCUiUDFbMUFxIgD3 HzyYz+fnfKSkfbBE0yMjTkaAAQBzIgADAI7mmNAho/Jjjz3e09Mjo3IN85+1U/xG 0F6v9447Nsnog8s15nK5ZFQGAFQSAjAA4AgtLRaDwdDe3q54ZRGQXnrpZcXLFiQS iWAwKKk4ZicC8NDQUKa47cck7YM1Pj4ejUYDAT4DAIDZEIABAEdob59Y/SvjDCQR e559do/iZQu8Xm8mk5FUHLOb10lI1133RRmz6z0eTzKZZBkwAGB2BGAAwBHa2tqM RoPValW8stXaumvXLsXLFjD/WUPzOglJ0kbQfr8/Eol6vV7FKwMAKgkBGABwhPb2 dhGALRaL4pVXrVq9detWxcsKmUyG5KMhEYBdLlc8FivmwZs3bx4fdyveh2AwKALw +Pi44pUBAJWEAAwAOIIIwBaL2Wg0Kl5Z3hlI4XA4Vlz6ggzzOgpY0klIkUgkGAwR gAEAsyMAAwCOMHEEsK2tublZ8cryzkASsSeXy8mojGKk02mf3+8cGSnmwZJOQkok Eh6Pl5OQAACzIwADAI7Q3m5rbW3T6RZTAGYBsOb8fn9/f38xj5QUgOPxhM/nZRMs AMDsCMAAgCO0t7c7HB0yDqq5554ta9asUbxsNptl3E9z/kCg/+DBYh7Z19d33333 Kt4B8TFwucaYAg0AmB0BGABwBBGAu7u7ZFR+/vkXZJSNRqOR4lafQp5AMHhQBOB8 vpgHX3/9dTL6MDLiJAADAGZHAAYAHMFub+/qWkwB2OfzpdNpGZVRPBGA+w8ezGsa gJ1Op9tNAAYAzIYADAA4wqILwCwALgciAA/09xe5FRkBGACgFQIwAOAIBGCUYCIA DwzkstliHkwABgBohQAMADjC4grAuVyOZZ/lQATgwYGBLAEYAFDeCMAAgCMsrgCc SCSCwaDiZTFfEwF4cDCbyRTzYAIwAEArBGAAwBEWVwCORCLRaFTxspgvAjAAYFEg AAMAjrC4AnAgEEgmk4qXxXwRgAEAiwIBGABwBHkBeOPGm9euXatsTY/HU+S6U0hV fADevXv3I488LKMPBGAAwJwIwACAI8gLwFdeedX69euVrckW0GWi+AC8c+fOXbue ltEHAjAAYE4EYADAEdrb2zs67PX19YpXJgBXsOJ3gZYUgDOZzNiYmy3BAQCzIwAD AI7Q3m5ra2trbm5WvPKqVau3bt2qbE0CcJkoPgBv3rx5fNyteAcSiYTX6x0f9yhe GQBQSQjAAIAjEIBRAhGABwYGcgRgAEB5IwADAI4gArDVatXr9YpX1ul0v//9H5St SQAuExMBuL8/l8vN+cgbb7yhmIfNVywW8/v9BGAAwOwIwACAI9hsNrPZZDabFa9c V1f37LN7FCyYz+fdbuXHElECEYD7Dx4U78icj7zuui8uWaL87UdoQtjjIQADAGZD AAYAHKG9vd1oNFgsFhnFlT0KOJfLselRmRAB+OCBA8U8UtIhwMFgMBKJ8nkAAMyO AAwAOILN1qbT6dra2mQUv+eeLWvWrFGqGgG4fPgDgf6DB+d8WF9f33333SujA16v Nx6PezxeGcUBABWDAAwAOILNZmtqampvt8koruxJSNlslimvZcLv9/f398/5MHmH AI+Pe5LJJJ8HAMDsCMAAgKN1dXXa7XYZlZXdCJoR4DKRTqd9fr9zZGTOR0raAlpw u91O56iMygCASkIABgAczTGhQ0ZlxTeCZhfochAIBsfc7lgkMucjJW0BLbhcYy6X S0ZlAEAlIQADAI7W3m4TCbiurk7xytls9qWXXlawIAG4HIgA7Bobi0ejcz5yw4Yv 1NfXK94B8bkS6ZczkAAAcyIAAwCOZrPZWlulHAUsPPbY4z09PUpVIwCXAxGAR0dH E/H47A/zer133LFJRgdisZjP52cBMABgTgRgAMDRbLY2s9liNptkFF+37mPXX3+9 UtUIwOVABOCRkZFUMjn7w7Zt2/bss3+W0YFQKBwKBdkCGgAwJwIwAOBobW2ter1B fJVRvLu7+/HHn1CqGgG4HIgAPDw8nE6lZn/YrbfeGg6HZHTA6/XFYlHxVUZxAEAl IQADAI7W0mIRAdhub5dRPJ/Pv/DCi0pVGx8fl7SpEoonAvDg4GA2k5n9Yddeu0HG wvKaiS2gx0UADgSCMooDACoJARgAMA2Ho8PhcEgqruAyYJ/Pl06nFSmFkokAPNDf P/tPIuQtAK6Z2AJaYC4AAGBuBGAAwDTkbQQtnHXW2Zs2KZOFwuFwLBZTpBRK5g8E +g8enP0x999//969r8ponS2gAQDFIwADAKZhs9laWixGo1FGcau1ddeuXYqUSiaT gUBAkVIoTTqdFgF4ZHh49odt3LgxmUzI6EAkEgkEgmwBDQAoBgEYADCN9nabXq+3 Wq0yiit4GnAulxsfH1ekFEoTCAbH3O5YJDL7w+QtAPb7/bFYjBFgAEAxCMAAgGm0 tFgMBkN7u5R9sGoUPQyJjaC1VcwhwPIOQKqZ3AgtGmUHLABAUQjAAIDp2e12h6Oj trZWRnEFZ0G73e58Pq9IKZSgmEOA5c1/zuVyLteY+AzIKA4AqDwEYADA9Gw2W1tb a3Nz85Ilyv9joeAs6EAgkJw1fUEqEYCHBgczs56BJGn+cz6fTyQSXq+PBcAAgCIR gAEA0xPp12QyWSwWGQG4RrlZ0PF4PBQKLbwOSiMCcH9/f37mM5DkzX8WATgYDIbD YZGBZdQHAFQeAjAAYHoOR0ddXb3N1iYpACs1C1qkIGbAaiWdTosAPDw0NMtj5M1/ Fm+9x+PNZjMcAgwAKBIBGAAwI6nLgIXHHnu8p6dn4XXYB0src24B7fV677hDmTOf j8UCYADAfBGAAQCzWbVqpaRlwMJZZ529aZMC6cjv96dSqYXXwXzNuQX0/fffv3fv qzKaLiwAfu21fTKKAwAqFQEYADCbZcuWWiwWSYPASm2FxTJgrUzMfx4eTs/804cN G75QX18vo+lcLhcMBgcGBmUUBwBUKgIwAGA2XV2dNptN3izoK6+8av369Quvwyxo TYgAPNDfn5thB6ydO3fu2vW0pKZFox6Px+kclVQfAFCRCMAAgDmcdNLqxsZGSbOg dTrd73//h4XX4TRg9c25A9aNN94wUzZeIPFep1KpV1/dK6M4AKCCEYABAHNYvvx4 o9EobxD4nnu2rFmzZoFFIpFINBpVpD8o0sQOWGNjsRle9r6+vvvuu1dS0yJXi3f8 wIGDkuoDACoVARgAMIeenm6r1VpXVyepviLnIYlEND4+rkh/UCQRgJ1OZzIx/RFH 8k4/qplcPe73+4eHRyTVBwBUKgIwAGBub3zjKfICcI1Cg8DMglaZCMBDg4OZTObY 35I6/FszGYBffvkv8uoDACoVARgAMLcVK5YbDAZ5s6AVGQRmFrSaZl8ALHX4N5fL iTd6//4DkuoDACoYARgAMLeurq7WVquk82xqJgf07r33voUPArMXtGomFgC73bFI 5Njf6uvr27LlHnlTBjKZjM/ndzqdkuoDACoYARgAUJSTTlrd1NQkr74ig8Dj4+OS th3GUWZZACx1+FdIJpPs/wwAKA0BGABQlOOOW2Yymcp8JXA8Hg+FQkr1B7MQAXhw YCCbzR71fRVW/4bD4f7+AXlNAAAqGAEYAFCUzk6HzWaTGoAVOROYWdAqmFgAHAgM Dw8f+1vyzv4tEAHY4/GMjrrkNQEAqGAEYABAsU488QS9Xr9kicR/O6688qr169cv pIIIZslkUqn+YFqBYNDlcsVjsaO+v3Pnzl27npbXbj6fj8VifX2vy2sCAFDZCMAA gGL19va0tLRIHQTOZrMvvfTyAit4PB6l+oNpTRyANDSUSaeP+v6GDV+Qt1NazeSb GwgEhoamGXkGAKAYBGAAQLHsdntrq7W5uVlqK6tWrd66detCKrAVllSHDkAaHq45 8tTlzZs3j4+7pTadSCR8Pr/bLbcVAEAFIwADAOZBha2wFn4kkohJwWBQwS7hcBPz n8fG4kceuSz76KMatr8CACiBAAwAmAeHw9HSYpE9CCxy1LPP7llIBbbCkmdi+Hdo KH3k/Ofrrvui1MXhNZM/1wgEJtYeS20FAFDZCMAAgPlZvvx4o9FYW1srtZXTT1+z ZcuWkp8eiUSiRw5RQhGH5j8PDR3+zbvvvntwUO7AbC6XE+/pgQMHpbYCAKh4BGAA wPx0d3e1trZKnexao8REaAaBZTh2/2cVJj/XTH4efD7fyIhTaisAgIpHAAYAzNuK FStMJqPsVhY4EToYDCYSCQX7g5rJADw4OJjNZKa+o8LkZyEcjuzfv192KwCAikcA BgDMW3d3d2urVfagX82Cd4RmEFhZ6XTaHwiMDP/tFCIVdn6uOTT86x8ZGZHdEACg 4hGAAQClWLFiuclkUqGhjRtvXrt2bWnP9fv9qVRK2f5Us0AwKFJoKpks/Ofu3bsf eeRhFdoNh8P79x9QoSEAQMUjAAMAStHT0221qjEInM1mt2/f0dPTU8Jz8/k8Z8Yq pbD91cjwcH7y+F+v13v77bep8AHIZDKBQGB4mOFfAIACCMAAgBItX77cbFZjEHgh i4EZBFbKUdtfqbP0VwiFwgcOMPwLAFAGARgAUKKenm6TydTU1KRCW93d3Y8//kQJ T2QQWBHpdDoYCo2MjOSyWfGft956azgcUqHdZDIZDocZ/gUAKIUADAAo3fHHH2ex WNRp66yzzt60aVMJT2QQeOECweDY2Fhs8mjl+++/f+/eV9VpNxgMHjzYr05bAIBq QAAGAJSuu7vLaDTqdDp1mrvyyqvWr18/32cxCLxAheFfp9OZzWR27ty5a9fT6rQb j8cjkQhn/wIAFEQABgAsyHHHLWtpaVGnrWw2e8stXylhU+hAIJD8697FmK+J4V+3 OxaJ7N69+2c/+6kKG18dajcQ6O8fUKctAECVIAADABaks9NhMBiMRqM6zYkMfO+9 961Zs2a+T+RM4NJMDf/uffXVLVvuUS39RiKRaDQ6OupSpzkAQJUgAAMAFqq3t6el pUW1aJTP5x9//In5HowUDAYTiYSkLlWwwurfocFBdQ49Kshms4FAYGhoWJ3mAADV gwAMAFgou91uMOhV2w2rptQMzCDwfBXO/n35pZe+9rVbVUu/NZM/rYhGY6zcBgAo jgAMAFDA5G5YJp2uWbUWS8jAhVm18rpUeUT6/ctf/nLzxpvUTL/xeCISCbP3FQBA BgIwAEAZS5cubW21qtliCRmYQeDipdPpffv2ffaz/6pm+hV8Pv/g4KCaLQIAqgcB GACgDIejQ683mM0mNRudbwaOx+OhUEhqlyrGa/v2XX3VlSqn31AoHItFXS5+TgEA kIIADABQTHd3d2urVeXINN+zkcbHx3O5nNQuVYDt27d/4xubVX4rM5mM3x8YGRlR s1EAQFUhAAMAFONwdDQ2Nra2tqrc7rwycDqd9vl8sru0qGmSfmsmJj/7UqkUw78A AHkIwAAAJYkMrNPpLRZzPp9fskTVf2XOOuvsTZs2FfNIEbREDJbdn0Xqlltu+d// /Z2aLRY+KsFgKB6PkX4BAFIRgAEACuvq6jKbTc3N6u0IPeW4445/5JFHinkku2FN 61Of+tTIiAan7yYSiVAo7HSy8zMAQC4CMABAYQ5HR0NDg9Vqra2tVb910ejPf/4/ c26LFQqF4vF4aU0URrbz+fxRBaOTgsFgJBKJTYjGYvFkMhGfkEgmk+FwqLGxUTy4 qam5qalJp2vW6XTi13q9Tq836PV6o9FosVgMk8xmc2ndK83o6Ogll1ysZotTcrmc 3+9Pp9MM/wIAZCMAAwCUJzJwc3NzS0uLJq1ns9kNG6698MILZ3/YTIPAIrg6nc7R Udf4JJHNQqFgKBROJCZCbCol/pdKT8ofUlNXV6v4fG9RV/xBlkyqnVDX0NDQ2Cj+ 1yReWxGezWaLeIVbW1ttNltHh72rq9tut4tEXUJb27b97D//8z/VX/RbEAgExGtL +gUAqIAADACQwuFwGI0Go9GoSesiPYpAuH379sO/GYvF+vv79+/fPzQ0NDo66nSO eDyeSCQSjcZErBVps7AYVZOBa0WI/hc2uBZ/iPr6uqamJr3eYDIZrVarzdYu3pGu rq5ly5b19PQUBqILLrzwE263W+UF21MiE6Iul0uT1gEA1YYADACQRcSt1lZrfX29 Vh3IZLIWi3ly2DYlwqFItlrFvLJSGFsWr4Z4a9LptFYDvzWT5x75fH6W/gIAVMN9 AABAlsJi4NbWVmInjiVyeGE7biY/AwBUwx0JAECuZcuWWa3aLAZGOfP7AwMDA1r3 AgBQXQjAAAC5HI4Og8FgMpm07gjKSDgcjkajjP0CAFRGAAYASNfZ6TCbzaVtUIzK E4/HQ6HQ6CgbXwEA1EYABgDIZbfb6+vrGxoazGaThvstoUxks9loNJpKpbPZTDqd 8Xg8WvcIAFBFCMAAAIU5HB0i8YqsK2Lv5Lm1jWyChWmJMFw4VDmTyWQnMSkaACAV dyQAgAURcbe2tnYy7k4M84q4q+G5R1jU8vm8CMMiEmf+ijwMAFAWARiAZkRwEqGp 7m8OndEqboJzuVz2rzKZrPge98HlQ7xx4p2qnyQCb1NTIxObIYO4FIgMnExODBFP XAkyWZeLZcPlQlwHxG1k/WGX8KlzticPmv7bNVy8d1zAAZQPAjAAtTkcDhGZmicV OTNW3EDFYrHJqZIZ7oA1MTmruUEk3sbGhqamJhIv1PfXPJycmjJNrFKfuIA3NIjr QKNery/yOiDeuMSkZDLFBRyA5gjAANTT3d2t1+vEbVPJK0LFjVQ8Hhc3UiIMc+8r VWFic2FWs0i84n5X6x4BR8jlciIMTy0h5oIglbggiItAc3OzTqdbyAU8NiE+MjKi bPcAoHgEYABq6OrqMpmMCp6CU9hIViRhp3NUqZqw2+0i7haGecWdLsO8WCwKi4en BodFNiYPK6Wrq1NcDQwGg4IXhHg8Hg5HnE6nUgUBoHgEYAByORwder3eZDLJ2Af4 r+MJsZERbqRKNLkSu66weZW4za2trdW6R8BCiRicSCQnN9NKc9pwybq7u/STJF29 w+GwuHrzowoAKiMAA5Coq6uztbVVhT2BxV1UNBolBhdpcnpz3eRCviadjtCLilVY NhyPJ9LpiZnSZK0iiehrMBhE9JXdkHh3fD4fE3kAqIkADECWnp6e1larmuEqEhEp OMKAz0wcDsfkqbwToZfpzag2IgynUqnCyDD7Es+ks9NhMBiNRoNqLeZyOZ/PPzw8 rFqLAKocARiAFEuX9lqtVhkT52Yn7nFDoVA8HufutqBw1lRhTW9TU5PW3QHKQjab ndyUeGLNMD8yKxDXCp1OZzabNblu+/3+wcEhldsFUJ0IwACUp1X6nSLubgOBYDpd vTtFF7ZsFcQdLYO9wEwKc6QnT1lLV+2wsLhcNDQ0trRYNLxWkIEBqIYADEBh3d3d Nlubhul3yuRGo+GqWl3W1dUpbmR1uokzlrXuC7DIZDJZcdFIJpOZTBWtFhYXDZPJ pOAW/SUTGdjj8XJCEgDZtL9DBVBJHA5He7utfIYcCzOio9GY2+3Wui+yFHa0amxs ELewTHIGFq4wQVqo7H2z7Ha7waDXZM7zTMQrPz7ucbmYlA5AonK55AGoAHZ7u9Xa qtOV3dijuKny+fwVNrBQOL6osbFRr9c3NDRo3R2gAuVyuUISTqUqbT1Fd3d3a6u1 fH5YOSUeT/j9Prd7XOuOAKhYBGAAilm+/Hiz2ax1L6ZXMWdOknsB9RWScOE4pQq4 hsg7m10RoVDowIGDWvcCQMUq02sfgEWnq6urvd1WtndUBYt6KLirq7OQe8VXrfsC VCmRhOMTEot0nXDZDvweLp/Pj497nE7OdQcgRVnfqgJYLByODovFUg7bqMxp0Q0F Fw7v1en0ZTi3HKhak3tHx5PJRDabXRQXk/If+D1cPB4PBoOL4oUFsOgsgosggPLX 29vb1taqdS/mQdy8+v2Bch4KFner9fX1zc3NBoNhUdywAtUpmUzGYrFkMlXOWzd1 d3dbrS3ikqJ1R+bB6/UNDXEqEgDlcVMFYKHs9na73b64bq1qyniDaIfD0dzcJHIv S3yBxeKvU6PjqVS6rC4pZbjVc5EymYx7ArthAVDYIrsaAihDS5f2trYupuHfwyWT yWAwVA6LzQpDvjqdTq/XL7pbVQAFqVQqFoslEslyGBDu6uqyWMyL93Q0n883OMgg MACFcY8FYEFEbLPZbItu+Pdw+Xw+EAgmkwmt1puJ11DcoRqNRoZ8gcqQy+VEDI7H 41qtEJ68qjS3tFgW9U/TMpmMx+NhJTAAZS3iyyKActDT02OztWndCwWIW9VQKDQ6 quqgTVdXZ3Nzs4i+tbW1arYLSUTaKfwin8+L91Rkj9pJdXX1Ql1dnU7XnM3m8vlc Op0RDxb39+JLbpJ4ivg6FVfKfJ9eFCkeT8Ri0XRa1S2jOzsdZrN5UexKOCePxzs8 PKx1LwBUFAIwgAU58cQTDQa91r1QhogfgUAglZJ+zufkWb71ej2znctXIZSK7CqC a2NjY3Nz8+QOuiJWmIzGif9nMBiMRkNzs85qtbZNEt9UcAxfRKZgMOj1en2+iS/h cFj8ZzQaCYUm9jCPRMKRSCQejyeTSfHIqd7yk5TyJK4q0WhUvFkqXFvEx7WlpaVi PgnRaKyvr0/rXgCoKNx4ASiduNkSKizCiftUETYk3aeKV0xkJJGdRKCSUR9zmhpo FW9EYZNtkRZaW1vb2+3d3V29vUuF3t5ei8Vy7HNFgEkkEuKrKKJ+z4shQvLIJKfT OTbm8ng84juhUGjywJ5kNpsRHa+rq62wv7OLRSaTEZeXeDwhaXmwuLyYTCbxkZZR XCvi79qY+CgzCxqAcvgnEEDpli1barVate6F8sR9aiAQVHbeXWFkxmg0iq8KlsWx piJuc7NOvOCtrdaOjo6ent7ly5efdNJJK1eunNeeQIlJIj3K67DK4vF4X1/f66+/ Pjg46HKNjo97JhNyLJ1O5XL5+nqmXsuVzWZFDBYfKqdzVMGyPT09LS2WRb0dw0z8 fv/AwKDWvQBQOQjAAEp30kmrF+/+onMKh8PiPnXhIw92u725udlkYo8rhRXWzTY1 NZvNZvEi9/b2nnDCCW984xtPPfVUvb70afmiZiH0plIpBXu7WASDwVde+X+vvrp3 YGBgdNQpskckEkmn03V1dYwbK0h8eidHg+MLj8EOR4fBYDCZTIp0rAwlk0nxgdS6 FwAqB/+YAShRZ+fEBGiteyFXNpv1+fwjIyOlPb0w6ituTIm+CyTeiPr6BovF0tnZ KVLuySeffNppp65cuUqphY4ijRRCr0h6ihSsPKlU6rXX9r7yyqt9fX2DgwMejyca jU2+L4wYl27hMbi7u7u11VrxW6aNjY2pvEMhgApGAAZQokqd/3yUfD4fCoXEvb7b 7S7+WZNrfRvNZqLvvIlMJV408dHq6uo68cSVb3rTm972trfZ7XYZDRVCbyaTUbx4 lRCv4cjIyJ49e/bu3StSsfg7Eg5H8vlcxecxZYkYXNjSbF4ZT/ylMBj0ZrO5Gkbm mQUNQEGVf9EEIMnKlScuZKLp4iJu9L1en9PpnPORIvrW1zeYTMYKnhyulMJiXZ1O b7e3r1hxwmmnnXrmme9csWKFvBYLobdwOqu8VqpcOp1+7bXX/vSnP7322t7h4WER XTKZDJF4TuIzGQ5HxMezmGUXXV1dbW2t1fOqxmKxffvYCxqAMgjAAEpRkfs/z06k tWAwKOLTLLen3d1dRqOxMo7flEHc4jc1NXd2Ok4++eS3vvWt73znu1pbW2U3KjK2 SLyM9GpIvAVOp/N///d/X3zxhYMHD4pILD4J1RPe5kV8SsPh8CwHJolrb3Nzs8Vi qbbLL3tBA1BKFV09ASiop6fbZrNp3QsNiBvTYDB07FCwCHWTB8MaNelVeSqcFSTu 1JcvX37aaf/n7LPPFrlXnaYLa3pF7iX0lifx7rz44osiEr/22l6nczQej7HJ1uHE dSYcjmQy6aMiX1dXl8Virs7ZJR6PZ3i4xO0YAOBw/GMDoBTHH3/ctAelVoOjhoIn B2R0ZrNJqQ2ZFq/8pNbWtpNOWv33f3/mBz7wgZaWFjU7EJ/ERlaLTi6XGxoa3Lnz l88///zQ0FAhD2vdKe3FYrFIJFr4cVt1DvweTlx1Dx7s17oXACpBlV5GASzQ6tWr xN2YtPJLcrlsmedJEYBDobDopMViruadrkR0MZstK1ee+Pa3v+Occ86RsVvV7FKp VGGGs8rtQp5sNtvX1/fLX+586aWXRkZGxFtctXlY/P0Kh8OpVNpkMsq85Cpgcl39 kro6Wddt8Xd8797XJBUHUFUIwADmTfYC4Ntuu+0973nvHXfc8dOfPiSpCUXk8/kq HI0Rd+T19fW9vUvPOOOM8847b+XKler3QdxqFwZ7RWfUbx0qEwF4z55nn3zyF6+8 8kog4K+tra22v3dlfqkRfx/F1WDt2nNffvnlhx76iaRWWAYMQCnlez0FULa6u7vb 22UtABZ3OS+88GLh1yLe3HHHpgcffLDMR4MrnrjBNRqNq1ef9J73vOfcc881mUzq 90F8MAqhl2W9Va6/v3/79if27HluZGSYzbS0Jf4yvv3t71i7du3UJfraazfIe0fG xz0ln8oOAFMIwADm7XiZC4BPPvkN99xzj8FgmPpOIpHYsOELv/71r7nTVZO4tRXv 8qmnnvbhD3/4ve99r1Y/g0in07FYjBnOmJbP5/3FL5565plnBgb6c7kcPylTTTab Xbly5Sc/+cmGhsbDv//d735naGhIUqMsAwagCAIwgHl74xtPkZdFb7rppre97e0d HR1HfX9gYODyyy93uUbLeSrgYiduag0GwxvecMo555zzwQ9+sL6+XquesJ0V5mts bOzxxx//3e9+NzIyvGSS1j2qTPl83mAwiqvxsQv+xWu+7/XX7/uvLZKaFheol1/+ i6TiAKoH/zwAmLdTT32TpJtLcX+zc+cvxS8aGhqmPSH2oYceuvXWr3JrqyBxO1tb W7ty5cq1a8/98Ic/rOFGO+Ldj8ViIvcWzk8CSpNOp1/bt++x//mfP/3pT9FohJkj ChJ/ScWF4h3veMe0v1tXX9/V1XXBxz8m6TUXV4YXX3xJRmUAVYWbSADz09npOHZ4 VilWq/XHP9469evGxsZjH5NIJK644vLnn3+e6Y4LIW5kxSssbmQ/9alPr1ixQsOe JJNJkXtTqZSGfUDlETE4EAw6nc4/7979u9/9tnCYEBeNkuVyuZ6eniuuuOKoOc9T lixZojMYOuz2z1xxud/vl9SNsbGx0VGXpOIAqgQBGMD8HHfcMnmHu77vfWdt2LCh 8GtxOzXLmTrPPPPM5z//b2wCPF/5fL4w2Hv++edP+/MF1cTjcZF72dEK8ogMHAyF fD6f+KiJa8Xo6OhvfvObV175f+Kzx7DwvIhX78ILLzrllFNmekAh/ba1tlrM5m9+ 85tPP/1LST0JBAL9/QOSigOoEgRgAPOzatVKnU4nqfgdd/zH4fdYoiGz2TzTg1Op 1OWXX/7cc3sY1ZmdCL3idv+00/7PZZdddsYZZ2jbmWg0GptMI9p2A1VCZGDxgRNf x1yuqSXl4kP4+9///o9//GMoFNRwofuiIP6q9vYuveKKK2Z/oQqTn0X6bWho+Mtf /vKFL3xeUn/i8fhrr+2TVBxAlSAAA5gfeTtgTS0APpzdbp99xe/TTz+9YcMXWDV6 LHHn2tyse9vb3nbllVdqclrv4ci90FBhKHjc40nEYod/P5lM7tmz57e//a3HM04S Ppa4Jn/iExe+6U1vmv1hU5OfW/56OsDZZ58l758J9sECsEAEYADz4JggawFwc3Pz o4/+/Khvirsom22OM4cTicRll61/8cUXGQqumRzvFa/ke9/73n/5l38V75a2nSH3 okwUhoJF4nW5XLls9qjfFbFKXECefvppt3uMJFwz+eOz7u7uz3zmMzOt+J1y+OTn hoaGwjfPPXetvKPLXK4x8SZKKg6gGhCAAcxDb29vW9s0mzMrIpfLP/XUU8d+32w2 FzPp+rHHHvvyl79UtRtEi9wrbtz//u/P/NznPrds2TJtOyNCr4i+5F6Um8LOWGNj Y+kZNl3LZDJ//vOff/WrXX6/v2qTcDabPf/8dWvWrCnmwYdPfp765vvf//7aWlmX Yq/XJ++oYQDVoErvFAGUZvny5WazSVJxi8Xyk588NO1vFbnvdDgcvuiiiw4ePFBV MVjcrZ5yyhtF7i3yhlWeeDwucm/2mOE1oHwUpkN7vN54LFYz89IJ8Ul+5pln/vjH PySTyerZMSufz7e2tl1zzTVFbvRw7OTngo99bF0wGJTTx5pQKHzgwAFJxQFUgyq6 RwSwcPIWAAsXXnjRP//zP0/7W42NjVartcg6P/rRD++4446Knw4tcmZ7u/3CCz9x 0UWf1PYPm0qlIpHI1A5DQJkrTIcWn1vX6OicP68ZGRnZvn37vn376usrPAZnMpkP fvCD7373e4p/yrTDv8KDDz4orsNKd/AQlgEDWCACMIBidXZ2dnTMeC7RAuXz+See 2D7LnMPW1taj7rFm4fGMX3DBBR6PR6HelZd8vubd7373DTfcMMsxUSrI5XLhcFje Sj9AqsJ0aLfbnUom53yw+LTv3r37qaeeikTCFTkgrNPpPvvZz82y6/6xZhr+rTmU pT8gbybO2Jh7dHRUUnEAFY8ADKBYS5f2ihQqqfi0W0AfbvZjgae1adPXf/SjH1XM 3aq4BbfZ2tevX//xj39c255EJ7HzNha7IqdDH87lcm3f/sTevXsr5sIirr1vf/vb zz33w/N61rR7Xx1O3kbQgs/nGxxkGTCAEhGAARTrhBNOMBoNkopPuwX0sY+xHDPU MLt9+/Z98pOfTCTiC+ia9sQd6pvf/OaNG2/WdncrkRbC4TBTnVFJ5jUdekomk/n1 r5/ZtWuX+MWiXm2xZEnt1Vdf3dXVNd8nzjT5eYrUjaAjkejrr78uqTiAikcABlAU h6Ojvb1d3k/0r7rq6nPOOWfOh9lsthL68LnPfe7pp3+5GEdsxL31Rz7ykQ0brm1s nOMwEqkikUgsFmPIF5VqXtOhD/fqq68++ugjfr9/0V1eRNpfvfqkSy+9tITnzjL5 ecpjjz32ne/ctYAOzkZ0fnx83OUak1QfQGUjAAMoSnd3lwjAkorncrmnntpZzCNF ICytG3/4wx+uvvqqxXIwj4iaBoPhiis+c+GFF2rYjUwmEwqFGPJFNShhOvQUp9P5 yCMP9/f3L5aTk8SV8NJLP7Vq1aoSnjvn5Ocp73//2fKGx0UAHhlxSioOoLIRgAEU 5bjjlrW0tEgqbrfbf/jDHxX5YL1ebzKVchSTiHOXXXbZnj3PlvOUxcljSFpvuOHG s846S8NuxGKxSCTCkC+qyqHp0MnkqMuVm/9pXn6//5FHHnn11VfKOQaLv9Td3d1X XnlVyUPWc05+nnLRRRe63e7SWplTIBDo7x+QVBxAZSMAAyjKqlWrdLpmScU//OGP XH755cU/vrSJ0MK99957553fLM/JiuLGVPy5vvrVW8844wwNuxEMBtnYGdWsMB16 bGwsnUqV8PRoNPrwww+/9NKLZRuDe3uXXnTRRUajsYTnFjP5ecr3vve9Rx55uIRW ihGPJ1577TVJxQFUNgIwgLk5HI6ODrukMy1yudzWrVtbW9uKf0ppE6G/+tWvPPTQ Q2U4/FsO0ZfZzsCUQ9OhPZ6J6dAliUQiDz+87eWXXy7PGCwuOBdffElb2zyuujXz mfxc4PN5P/7xj0u65IrL5tiY2+VyySgOoLIRgAHMrbe3Z763SsUTt0fbt++Y77N0 Ot28jqzcuPGmRx99VN65lKUR93BGo+lrX/vamWeeqVUfEolEOBxeLKujAXUUpkMn k0nX6GjJfztCodDWrT/u6+srwxhstVovvfRSm20eP0ksfvLzlA984B/lXVu8Xu/Q 0LCk4gAqWHndCwIoTytWLC9t2W0xTjjhhLvu+k4JTyx+InR5pl/R+Wuv/eK6deu0 6gALfYHZFaZDu1yuzAImR4in//d/Pyi+ltviC5GBP/WpTxf5w815TX6ecvXVV8k7 rygcDu/ff0BScQAVrLxuBwGUIdkHIH3mM1euXbu2hCeKGzK73T7nw66//rodO3aU VfrN5XIXXPBP1113nVYdELk3Go1q1TqwiBSmQ7vd7uTC1sbv3bt369at8XisrFZh WCwtl1566ZwX0vlOfp7y85///O67v7uwPs6Iw5AAlKaM7ggBlKeuri67XdYBSJlM ZseOJ+d1R3W4pqam2femvu66Lz755JPlk37FHdtb3nLGt771Lb1er0kHQqFQPB7X pGlgkSpkYO/kCUkLnDHxzDPPPPlkef08TlxCL7lkjgxcwuTnAvHS/eM//oO8GeBu 97jTyWFIAOanjC7BAMqT1AOQmpt1jz766EIqWK3WxsbGaX+r3NKv0Wi6++67Tznl FE1aZ3tnoGSHTkhKpUZHR0s4IelwyWTygQd+tHfv3vJZGGyxtHz605+aaT1waZOf p5x77rmJhKwfunEYEoASlMt9IYCyJfUApLe+9W0bN25cYJGOjo5jv/m1r33tJz/Z WibpN5fLXXbZ5VdddZUmrRN9AUUcOiHJ5Vr4fun79+9/4IEHYrFomcyIbm+3X3LJ JVar9ajvlzz5eYq4wv/xj39Qoo/T4DAkACUoi1tDAGVr4vyjjg55MXLz5m+cfPLJ CywibstaW1sP/8599913553fLIc7SxF93/CGU773ve/J20VsFkRfQFmF6dDj4+MJ JZYS7Nix41e/+lVdnfZXqpqJyT7HfeITFxoMhsO/WfLk5ymvvPLKv/3b55To4DQm D0MaYxkwgHkhAAOYTW9vb1tb69yPK0kul3/qqacUKWU0Gqfu2x577LEbb7yhTDZc vf32r7///e9Xv91wOBwr9QhTALM4tCTY54tHowvfRN3v92/Zco/H4ymHS9bJJ79h 3bp1TU1Nhf9c4OTnKeIaWFsr64bT6/UNDQ1JKg6gIhGAAczmhBNWiGwpqXhnZ+f3 v/8Dpaq1t7fX1tb+4Q9/uOyy9Zovrsvlcqeeeuo992xpbpY1e3wm0Wg0Eomo3ChQ VQ4tCU4mRxdwSvDhnnrqqV/+8peaDwWLPL9mzVvOPfdckcYXPvl5yiWXXCxeKKU6 eRRxuXv99f2SigOoSARgADOSfQDSxz9+wcUXX6xUNXG75vf71607vxxmPmsy8BuL xcLhsMqNAlXr0CnBo6OZTGbh1cTl65577vF6NR4Kzmaz73vfWf/wD/+gVPoVfvCD H2zd+mNFuncsDkMCMF8EYAAz6u7ubm+3SSqey+W2bXtYwZWxIvudf/5HlapWmnw+ v3r16h/84H6VB35TqVQgEFj4bEwA81LIwG63O5VMKlLwiSeeeOaZX2k7h0Xk+XXr PvaR885TJP3WTF6czzvvI/J+NDk+7hkZGZFUHEDlIQADmNHxxx9vsZglFRf3VY89 9rhS1UScFuk3Go0qVbAE4q7xqquuvuKKK9RsVPzB/X6/IgNQAEqg7LZYNZMbRH// +9/PZNIabmKfz+dvuPFL73rnO5UqeM45/9/Ct86eSTAYOnjwoKTiACoPARjA9GTP f/67v/u7W2/9mlLVrrnm6r6+PqWqlaC+vuGBBx5YtWqVmo0GAoGkQuNOAEqm7LZY NZPTeu+669vDw8MaDgWbTObbb799+fLlilS74Ybrn3vuOUVKHUu8/l6vl1nQAIpE AAYwva6uLru9XV792267/bTTTlOklLhTfOyxx7QaLRH3uyef/IYf/vCHat6qstMV UFYU3xarpgymQ5944ok333xza2vbwku98MIL1133xYXXmYnbPe50OuXVB1BJCMAA pnfccctaWlokFVfwAKSdO3d+/eu3a7VtTCaTveyyy6655hrVWhT32X6/n+W+QBma +OsZCLhGR7PZrCIF+/r6fvCD7yuVqEvw3ve+95pr/kWn0y281Pvff7a8ZcCBQKC/ f0BScQAVhgAMYHonnbR66jRIxXV399x7770LrzM8PHzxxZ/UaoRE3JXeddd3zjzz TNVa9Pl88tbRAVi4Q1tDu1wZhf6qhkKhO++8MxIJa7K/vbjKffrT69etW7fwUhdf fLHLJeswpGQy+eqreyUVB1BhCMAAptHZ6ejo6JBX/5JLLv3Yxz62wCLizmzt2g9p FQibmpoeffTnDodDneYikYi2W3wBKNKhraHHxlKplFI1v/Odu/r7+zX5YZ+40t56 69dOP/30Bdb5wf0/2PpjWYchCWNjY6OjLnn1AVQMAjCAaSxbttRqtUoqnslknnhi +8KHlz/72X/du1ebH/kfd9zxP/nJTxobG1VoS7xcfr9fwzmQAOarsC2W2+1OJhJK 1dy27Wd//OMfNcnA4p+D2267bdmy4xZSZMzt/ud/ukBe/8V1cmBgUFJxAJWEAAxg GqtXr5J3kq3BYNi27eEFFtm69cff//731d/4Kp/Pv/3t7/jud7+rTnPs8wwsUoof jyQ888yvtm/frsmWB295y1s2bLh2ISe3B4LBCy/8RFq5UfGjJBKJvXtfk1QcQCUh AAM4muz5z2efffbnP/+FhVQ4cODA5Zdfpv5dYC6X++hHz//yl7+sQlsi94r0q0JD ACQpZGCP1xtXbv3C888//+Mf/7iuTu31wOLqd8kll15wwQUlVxAB+Pbbbnv+eVmH IdUwCxpAcQjAAI4mdf6zuIt64IEH7XZ7yRUymczatWuz2YyCvSpGNpu95pp/Wb9+ vQpt+f1+BVcPAtDKoSOCvd6Ychn4wIEDW7bco1S14i1wMbAIwK/u3XvTl78kbzcv ZkEDKAYBGMDRpM5/rq+vf/zxJxZSYcOGDS+//JJS/SmSSL9f/eqt55xzjuyGEolE MBiU3QoA1RzKwD7fRAZW6AAzt9v97W9/K5NR++eANlv7bbfd1tPTU8JzC6/DJ/75 nxTv1RRmQQMoBgEYwBE6Ozs7Okofnp3T6aef/pWvfLXkp//2t7+95ZZ/V/k4EJF+ N23a9H//7z/IbohTjoCKVMh+vskMrNQh3qLa5s2b1Z8L88EPfvCKKz7T0NBQwnMD weCXbrzx9df7FO/VlLEx9+iorMOWAFQGAjCAIyxbtsxqbZFUXNz53Xnnt1avXl3a 05PJ5Ic+dI7KG1+pk35TqZTf75faBAANiQwcjcXERWzU6VQ2A2cyaTWviplM5pZb bnnb295ewnNFAP7tb39717e/Ja/Dfn9gYGBAUnEAlYEADOBvHI6O9vZ2eZtLiZue HTueLPnpV1111f79ryvYnzmJ9Pvtb9/1rne9S2orwWAwodxZKQDKlojBPr9fwQwc CoU2bfq6KKtmBrZYLJs23bF06dL5PlEE4MHBwc//2+fk/SuTSqV8Pp/LNSapPoAK QAAG8Dfd3V0iAMur/8Y3vlHcNpX23Cef3PGNb3xD5YGOu+76jtT0m8vlPB6PUrfC AMpfIQM7nU6l1gOLDPz1r39d5bnQ73vfWVdffbVOp5vXswoB+Bub/0PqLOXx8fGR Eae8+gAWOwIwgL9Zvvx4s9ksr/43vvHNk046qYQnxuPxtWs/pObS32w2e8stX1m7 dq28JqLRaCQSkVcfQHkSOdDtdkeV++s/NjZ2553fVPNHaZlM5qabNp555pnzelYh AL/4wgsPPviApI7VTP5E4MCBg/LqA1jsCMAADrHb2zs6OuTNTBM3Z8899/z4+HgJ z/3sZ/917969indpJrlc7uqrr5F64hH7XQFV62/7QiuXgffv33/PPd9T86eEra2t X//6pv+fvfMAi+ro+jjSmyhtpSigWIg9iSVETUSjaMTeYsXejS12BUQUFEGUXkRQ LNhA1Bi7BnsXe0FFadJZYAvsLt9hNx8PL3XZvXfu3bvze94nr65355zdnTtz/nfO nGlURWiJABYKBGvWrCZvrhEKhd++fcvKkmWuwWAwygAWwBgM5j8gjjExMSav/U6d OkVFRefm5jb2jY8ePVq/fh2ywA6E+vjx4zdu3ERS+wKBANQvTnvGYJQZMs4Hfvz4 8ZEjR9TVyRKWNRk3bvzMmTOll7KVAnjPHr/MzEzyHMvJyU1NTSWvfQwGo9BgAYzB YP6jXbu2enp65LUfEBDYs2dPGWodOzkNQ3ncZd++ff39A0hqHKc9YzAYCRINnJOT w+VwiGrz6tWr58//ra6uTlSD9SMSiXx8fLp06Srl9ZUC+PXr1wcORJPnGIy0798j rZiIwWAUCCyAMRhMBWZmLQAyS0w1efLkCZfLZbPZjXqbt7f3lSuXSfKpJi1btjxz 5ixJjYP4Ly0tJalxDAajcEg0cHZ2No/LJarNQ4dinj59ikwDt2vXbssWdyMjI2ku rhTA8Oc1a9aoqZGV11NeXv7t2zdcCxqDwdQKFsAYDKYCGxvr5s3JOv4X6N69+/79 UY1d/8zIyJg2bSqySE5TUysxMVFTU5OMxiHGFYlEZLSMwWAUF4kGBrVWyucT1ebu 3bszMtLJ22RbFRjW/vxzmZOTkzQXVxXAAQH+aWlp5DlWUFDw+TM+EBiDwdQCFsAY DKZi+dfExIQ8nVleXr5vX+SPP/5YVFTEaUyyn7PzdIgLSfKqGhDGXbhw0czMjPCW S0tLZUj8xmAwSgJoYFCG3zIzCSyMt3Wre0lJCZpz43R0dHbv9rOxsWnwyqoCODk5 OTw8jDwPBQJBTk4OXgTGYDA1wQIYg8GQXv4KQpzHj5+oiB/J86Ve5bhz546bmyua AE4oFIaGhtnb2xPeMt70i8FgGkSigTPS02EsIqRBGHm2bfNAVmxv9Ogxc+bMaXDN uaoAVqnIgiaxFrQKLoWFwWDqAAtgDAaj0r59O11dXfLa//nnPoGBgSqNPPtnxIgR paWE5QTWA8SIs2bN/vPPPwlvuVGCH4PBKDMwNuYXFKSnp5cTtFfi1atXUVFR5O2z rQqMonv27LGza+CY92oCODw87OPHj+R5xeFw3r17T177GAxGQcECGINRdszNzVks U/IWWkUiUXz86datW6s0Zh/swYMHDx2KIcmlatja2p44cZLwZnNzc1EWr8ZgMIoO aOC8/Px04nbGxsbGPnr0EM1m4N69f1q7do2ubn1HCVRkemdlcUtKJEvT37598/X1 Ie+IO7CSlZWdkZFBUvsYDEZBwQIYg1F22rRpbWBgQF77urq6t27dlvxZyg29EAUO G/Y7moN/ITS8ffsO4YWvcMkrDAYjAyARM7994xJ3OLC3904YjhBoYKFQ6OW148cf f6znGknFr/T09MpF4I0bN4pExGR91wqbzf748RN57WMwGEUEC2AMRqkxM2vBYrFI lZoTJ/6xbt06yZ+lFMBubm53794hz6VKIGI7ejS2Y8eOBLZZXl4O4SayrXcYDIZJ SCRiVlYWn8cjpEGBQODq6kqqyKzE2tpm27ZtJiYm9VxTLQv61KlTDx7cJ88lkUgE XyYuhYXBYKqCBTAGo9SQffoRKMw7d+7q6f2XFCeNAC4uLh49ehSC9Qoytv5CrJmb m0tggxgMRtmQFMTKzMwUEFQU+uXLF9HR0WgWgV1cXPv161fPNdUEMI/Hc3HZTKpv +DwkDAZTDSyAMRjlRXz6kam6OomRh7m5xd9//135V2kE8Lp1a58+fUqeS5WwWC0u XLhAYIP4uCMMBkMIEg2cnpZG1E6KyMjI169fIThT3cLC0svLi8Vi1XVBNQEMbNu2 rbi4iDyXBAJhTk42XgTGYDCVYAGMwSgvVlZWRkaGpJrYuHHTuHHjJH+GSC47O7v+ 69ls9pgxoxFEaeDMlStX60/VaxR8Pr+goICo1jAYjJJDeEEsV1dXPp9H9sFyMLTC sP/rr7/WdUFNAXz79u0zZxJI9SovLx+MkmoCg8EoEFgAYzBKCovFatGCRWriWXm5 StW13Ip4Li+v/resXLny1auX5Lkkoby8fNWqVdOmTSeqQR6PV1hYSFRrGAwGoyLW ihkZGTwul5DWPn78GBISjCARGiYXb+9dLVq0qPVfawpgYPXq1aTmIgmFwm/fsgDy TGAwGAUCC2AMRkmxtrYyNCR3+dfBYYCvr2/lXxtUiXl5uRMnTkQQn9nYtI6LiyOq Nax+MRgMGUgKYmVmZpaVlhLSYExMzLNnT8lOsSkvL1+zZu3AgQNr/ddaBfD+/fvf vXtLqlf5+fkpKXgRGIPBVIAFMAajjJiZtTA1NSVVagqFwuvXbxgZGVW+UlxcXFLv 2R5Lliz+8OEDeS5JEIlEN278S1TpL5z5jMFgyIPwzcCuri4wapGdCG1kZOzj42Nu bl7zn2oVwDA7uLtvIXtKys7GO4ExGEwFWABjMMqItbW1oSGJxZ9VapS/AgoLC3l1 H+wBMnL8+HEIln9nzpxFVOVnXPUKg8GQDSjGrKyskuJiQlp78eJFdHQUgkXgDRs2 1roTuFYBrFJRCsujmKDPWBf5+QUpKbgcNAaDwQIYg1E+ECz/At7eu3777beqr+Tm 5gpqBD2VrF+/7smTJ6S6BDRt2vTffxMJaQqfeITBYBBA+MnAgYEBnz9/JlsDW1q2 3Llzp7GxcbXXQQB/y8rilpRUOyz92bNnR48eIdUlvAiMwWAkYAGMwSgdrVvbNGvW jFQToK4fPnxU7UUI4KpFPJVwudzhw53IDsgg+jl27Jid3XfyNwUfBNdTwWAwaJAk QmdkZNRcOJUBGAk3bdoofzsNWvH09OrRo0e11yV6PiM9vebz0HXr1pKdm11YWPjp 02dSTWAwGPqDBTCmAjOzFqBYVCuA/8IEpFr533IxItF//y8Uiv4fIX6MqohYWJib mpqSHWSMHTtu06ZN1V6s5xBgT0/PGzeuk+oSYG9vHxQUTEhT9Yh5DAaDIRzQjfkF BWlpaSpEjDznzp27fv0a2c8c27fvsHXr1prPW+vKgj5+/Pjjx9WfnBILjNvZ2dnp 6RmkWsGQAUSq4hhVHKqqQZAqiVObSBCHqaLK/0KMWhGnCnGkiqkdLICVFPE4ogqT n6ampra2tmyzIIwspaWlMCsLBAL4M/w/XhOjOfC7GxgY6OrqkmoFZp0HDx5C16r2 el0CGK4fMmQITGNke3Xv3n3o7fI3BfETUQVpMBgMRkpAN2ZmZnI5HEJa27JlC5fL IfVhKMQGfn57OnfuXO31ugQwXL9+/TqyZTmHw2FX1NbGuojWsFgsDQ11NTU16A8a GhoQUci2bws6FY/Hg2AV/gATN/7dMRKwAFYuxCu96lpamnp6eoRvAS0vL+fz+WJJ DONMGfwVDzR0o1WrljV3ZBHOzz/3CQwMrPl6XQI4NDQ0Lu4UyU6pzJgxc9myZfK3 k5eXV1ZWJn87GAwG0yjqSR6WgaSkpIMHD5CtNnv06LFu3Xp9ff2qL9YlgIHw8LCP Hz+S6pKKuCDF16+pZFvBNAoIUJs0aSJWuxVrM1paWoQ/nREKhSUlJRCoCoUCHKAq OVgAKwsWFuYwmsAkhKDKrgQYaLhcLshh8VM3nIVCPWhqX9U8/UhCPSWjnJyGERLP 1QNMpvfu3ZO/naKiIg5Byy8YDAbTWIhNhN61yzsrK4vUSaG8vDwwMLBt23ZVX6xH ACM4D0kFV8OiDZKsZnE2ooaOjg7KABV6Gp/Px8nwSgsWwAwHBhcYWXTFUOiGQCDk 8SRiuAynoFCFrW2bpk2bkm2lQ4cOR4/G1nydx+MVFhbWfP3Ondtubm6kpuFBBLZz p/fgwYPlbAcfeoTBYChHUg2Lx+XK31Rubu6OHV5kq44JEyY6OztXtVKPAAZ8fX1A nZLqkor4aWZyMulLzZia/P8WPA0QvdraOurqiERvrXDECAR4QVjpwAKYsYilr4a+ vh4hmx4JRCgUcjjcsrKKzcMZGZlUu6MstGzZ0sSE9ORnkUh08uSptm3b1vyn4uLi kpKSmq9PmzaV7FjH2Nj48uUr8rdTTxEvDAaDQQOxFaFDQoI/fvxIqgbW0dH19/eH OajylfoFMHw0P7/doJHIc0lCTk5uaipOhEaEubmZRgWaurroVnqlhMfjQYQiEJRh Gaw8YAHMQED6whijr6+vpaVFtS8NIN6PwZGIYTzukAd0CRMTUwTPWVmsFhcuXKj1 n/Lz80tLS6u9mJOTM2nSH6TOhaDJ9+/f/8MPP8rZTv2HGGMwGAwyKhKh8/MrEqHl hsvlurm5kq02165d5+DgUPnX+gUwsHXrVg6nlgemxCIQCHNycCI0iUjCURC9enq6 dBO9NeHz+cXFxTgcVRKwAGYalpYWRkZG9B9oqiEpoAXA0FNaWoarSROIuPJzM11d HbINgdSMiNjXs2fPWv+11srJ69eve/LkCalemZmZnz9/Xs5G6lq+xmAwGEoADZme ns7n8eRvKiIi/N27d6SGDS1btty507uyNgQ4/y0ri1tSUtdhcu/fvwevECwCczhc NrsQCx4CYbFYmpoVqldLDNlnLhKOUCjMy8tLS0un2hEMuShYv8TUg5mZmb6+XrVa i4oIyCQejycWw7h6FgG0bm1T8xhGMmjRwuyff/6p619r5g+LTz9yJDXEARNHjhzt 2LGjPI1AiIafyGAwGFohSYROT0uT/0g2gUCwceMGUodiEBV79uytHIol5axBwFO+ CAwUFhZ++vQZgSEGI6llpaGhDopXW1sbwZMLsimuoCQzE2/TYyxYADMBGHpg0AGR w4BBpxriDcMcyWnDWAnLQKtWrYyNqxdkJoMGpWZNAXzixPGIiAhSvbKysjp9OkHO RnJycqAfEuIPBoPBEEXFOuq3bxwiklOioqJevXpJ6iLwwIG/LV26tLIoSYNZ0F+/ fg0I8EcT1eTm5oE5BIYYhiTDWVNTU1dXATKcGwtENYWFhXw+HwefjAQLYIXHwsLC wKAp3SpdEY4kR5rHq8iRLisrzcoivUQkA2jZ0tLY2BhNApK1tXV8/Om6/hUEJMjI ai9OmDCBza6lLjRRELL8W1JSUlxcTJRLGAwGQxT/HQuckSGQ+2RyBIvAoJQCA4Os rKwkf21QAAM7dngVFBSQ51IlEGDk5uamphKwp5rxsFimoHnh19TWVsgM58bC4/HY 7KL0dJwRzTQY3nGZjZlZCx0dXVC/jB+AqgHChsvlSjYM4zrSdWFpaQHqF83jc9C3 cXHxtra2dV1Q8wwkBOWvTE1NL168JGcjuPIzBoOhLf8dC0xEKeOQkODk5GR1dXX5 m6qLdevW9e//XyksaQRwZmamr68PmqVFiCtAA+Odn3UhqeEMildHR4d5yYb1U15e DhqYy+XgpWAmoVzCiUkoaLErwhHXkS4pLS3Fx7hVBXH3aNeu3bFjx+u5oKioiMPh VH3F1dX13r275LkEM1ZgYFCfPn3kaaTWytUYDAZDH4iqhsVmsz08PNTUSNQ2bdrY enp6SmpSSCOAAR+fXTWzh0gCVz+qhvg0TXVNTU09PT0cbeLuwTCwAFY8WCxTGIwM DAyUbeG3fkDwiEQiEMN8Ph/GKWUWw5aWlkZGhsimK/i2//77fNUzHmtS8wyhIUMc SfVKX79pYmKiPC3UmraNwWAwtEJSDSstNbWuisrSs3v37oyMdPLmDhhUg4OD27Zt pyJFIWgJMHfs2OGFcjrLyyPmfCkFBUQvfNtaWloQZ6qqquI4syripWA2xJl4Fx4D wD1bwbCwMG/WrBn9D/ilFhikYBqTpEkr28qwlVUrQ0NDlJNWnz59AgIC67+mWiLx jRs3PD23k+mUiouL6+jRo+VpAde+wmAwCgGIyczMTO7/ZtnIQGpq6p49fqRmQU+Y MNHZ2RkkljSFoCWEh4d//JhMnkvVgPghPz//yxclqoklWemVpDfDT4NFb/1AYFlY kXaRQbUjGLnAvVxhgBFKU1OzefPmyrb7Qk4kK8McDqesTCAUChi8OMxisfT19Q0M mqI0Ct/tgwcPoWfWf1k1ATx//ryUlBTyvGrSRPXx48fytADBWV5eHlH+YDAYDHlI FoEzQEzK/cxu2zYPNptNXphhaGjo7x9gYmKiInUWtEAgWL9+HamyvCZsdlFxcTFT D8CTLPOqqalraKjr6urild7GApFPQUFBaWkpU+NJZQD3eMXAzMysaVN9PT09qh1R eEAPl4qBiEEohhnjl4WFRbNmBuhTAxYuXDRv3rz6r4HwJTc3t/KvMHM4Og4mNaVt 5MiRbm5b5GkhOztb/tM1MRgMBg0gJkGtlchdsj4xMTEh4TR5ahOmg4CAADu771Sk FsDAxYsXr127SpJLdSFe6GMzo/zv/yteNcmpRQBWvPJTUlJSVFSMzwpWUPANoABY WloYGhoifvypJDBAD5uZmenq6jRtSkEx8GbNml2/fqPByzgcTlFRUeVf4+PjQ0KC yfMKfsS7d+/p6urK3AJe/sVgMIoFgUcibdiwobycxMd/Q4f+vnDhQtBg0gtglYq6 iS7oSxJChCCu4MhVOJGDFS8aBAJBfn4+royliOD7gdbAEKatrQ0yA49caJDkS3O5 XAgmBBXp0rTePyzuHiB99Skpzwjfz4kTJzp06NDglQUFBXw+v/Kv06dPIzWvzM7u uyNHjsjTAt79i8FgFI6KI5HyCSjgdOTI4cePH5P3zF1PTy8kJNTU1LRRAhg+l5+f n7o6BZMdTAdFRcU8Hpfm8YCaGvxoFYpXclIRjhvRAHFjYWEhj8ejc/fA1ATfHvQF hjMDAwN5FrIw8iMQCMTrw/D/ApGIFkvEknlOW/u/Io1UufHrr7/6+e2R5kqQu5V1 PiFEGzp0CHmhFRg6evSoJL9ONnDxZwwGo6CApExNTS2Tb6UUxsD169eR91xVJBL5 +u7u3LmzlIWgK4mM3Pf+/XuSvGoQyTETPB6fDk/GJQu8qqoVkldDo+KkIpwkSC0c DofNZlPeMTDSgwUwTUF8kg1GSiRLxHw+//9LalVoYtDGCCSTuE6jhvhEPl3KO4aG hubdu3ellN9VK2AdOHDg8OFDpPmloqure+vWbXlawGf/YjAYBaViEbigIC01Vc52 fHx2wbhN3kTzyy+/rly5EtqXshC0BJh8N2zYQPm6Jkz6JSUcmCYEgjIEgsfExKRi YbcCVUnZKi0tLbzAS0PwGVqKBb5/aAdOe1Y4JKcuiafDiiVikQj+J1HK5Twet6Cg UIY2jY2NQOuqqkr28KjTag8PfMaoqKgffvhRmourVcCaPHlyXl5uPdfLybRp0yGu kqeFagWrMRgMRoEoqDigJZ3P48nTyKNHj44cOayhoUGUV9XQ1tYJDQ1t0aJFo7Kg geTk5NDQEMofAUuoUkNEIJn64c+5ubLUj2jevBl8J2JVW6FtJVM/yF6Y9/G5RAoE TodWIPBNRS9MTU0MDQ1x2jNjkOjgsrIyyR/Ewri81voiTcSoVgBzngadn+8OGDDQ x8dHyotLSkqK/78wKYjhIUMcycvUghDk4cNHDZ7JVA9VvcVgMBiFQ3IkUlpqqpR5 xXWxYcN6OVuoB5gL/fz2dOzYsbECGIiKinr79g1JjsmJZKIHRSx+Dv7ffF/zMpjq xdN9E8lEr6FB6xkf01g4HE5+fn52Nt5LRWvw/UYvzMxaNG/eXFtbm2pHMJja0dPT v3nzpvTX5+Xllf1/VdJjx45FRu4jx68K2rZte/z4CXlaqLpduVGAtr9z5w58M8nJ HwoKCrhcLqhxiGlA7evq6pqZmYFvv/32mzybkzEYDJN48+b15cuXP3z4kJmZCRGz uMyESE1NTUdHB8IAW9u2ffv2tbe3l+GJISGLwAcPHnz+PIm8tdbBgx0XLVrE4/Mb K4CBTZs2CYWNewsGgwwejwdhAF4EpjlYANOI5s2bATDz4QeBGHoC8dnZs2dbtbKS /i1VM4qdnaeTl2AMwjU4OATiRZlbkKH8FVwfHh7+4MF9NpstTZwKJuDbmzJlysCB A2V1E6PYcLlc+C+IHKodwVDDlStXDh069PXrF2m0JahiAwODnj17zZ0718TEREoT hCwCw5jm4bGVPAGsr68PI7aGpmaj6mBJyMnJ3rlzJ00SoTGYakBnBgFcWFgo2w44 DBqw0KIRxsZGMMPhwAhDT2BMX7Vq1bRp0xv1rkrFC+LZ0XEweSFLkyaqjx8/lqcF ydYdKS++d+9eQIB/ZmamzJ9o8GDHP//8E5fuZDbQ7a9du3bp0sXk5GQ2u0goFEh+ cRA2amrqBgZNbW1tBw0a7ODgQGFFdwwC4Bffu3fvxYsXZHu7UCg0MzNbsmRp7969 pbmekEXgrVu3FhcXkdQz4RP5+wdA/29UHaxKrl+/9s8//+DVAgw94XK5OTk5sm0I x6ABjx30wtzcDDQwfq6JoSH29vZBQcGNegvMAWw2W/LnM2fOBAYGkODXf/z8c5/A wEB5WpBydRr0zO7du/l8nvyxF6ijCRMmzpkzR852MHQDftnjx4+fPn06K+ubNM84 QB2xWC1Gjhw5fvx4rISZR0RExLFjsfL/suXl5Vpa2itWrHBwcKj/SkIWgc+ePXPj xg3yHtKNGDFizpy5HC5XhixoICws9NOnT2Q4hsHIgySbLCMjk2pHMPWBBTDtaNWq pbGxMdVeYDD/g6Gh4dWr1xr7rqobgBcuXPjp00ei/foPCPJOnjxla2srcwvVqlXX yrt371xcNufn5xO77AARrbe3d/v27QlsE0MVXC7Xz8/v2rWrsqkdUM4ODgOWL1+O U4GYAQwaq1ev5vPlWomtBgx3MCC7u2+tf9AgZBF4zZrV5D2RNzEx3bt3r6qammwC GHBzc+Xz+YQ7hsHIA8QSX7/KexQZhmywAKYjbdq0NjAwoNoLDOY/IJS/cuVq8+bN G/vGqmuqjo6DyUtX09LSunv3njwtsNlsyebMWgEZv3nzpkePHpEUC4L8HjVq9JIl S8hoHIMG+BG9vLxu3LgufycRCoW//tp/3bp1OENeoQkICIiPjyPpR4RO8uOPP27d 6lHXYUWELALv2LEjNzeHvHEvImJfc0NDGbYBSygpKXF334KTJjD0AWKJjx9xYoIC gAUwHWGxWMbGRhDTU+0IBlOxJHXy5Km2bds29o1Va0p9/Phx4cIF5AngYcOcPDw8 5GmhnvrPV65c2blzB9mbzcC6lZVVcHAI1jyKSGxs7L59+1RViewkIlH57NmzJ06c SGCbGDSAtIMR78uXLwjGjTVr1tZVVE/+ReDr16+dO3eOvEFpxYqVAwYMkG0bsISM jAxfXx88bGLoAJ/Pz83Ng3CCakcwDYMFME2xsDA3MTHBzzUx1AJhnL9/QP/+/WV4 b3FxcUlJieTPoE5v3kwk0rMqgES/dOkyi8WSuQUIImudscrKytasWf3y5Utkd6Km plZUVJSRkREacxj5KSgoWLp0CfQfMqQO9Ezo2HAPypB/gaGKvLy8GTNmlJYiSs2F AbBTp047d3rXXAqWLAKnpqaqyLEIvHbtGvIGwI4dO7q7bxUIhTJnQQMvXryIjo7C GhhDLXAn5uTkpKdnUO0IRiqwAKYvrVq1MjbGcTCGMoRC4fr1GyZNmiTb27Ozs2E+ kPx59OjRXC6HONf+By0t7bt378rTAofDKSoqqvbi06dP169fJ0/2oMxEROxr2bIl eruYxnLmzJm9e/eQXbYQ7sQ//1w2fPhwUq1gCAHU5pw5s9HbbdKkiaenV/fu3au9 Lv8i8M6dO3Nysknq5KqqapGRkdo6OjJnQUtITEw8cyYBFxDFUEhubt7Xr1+p9gIj LVgA0xpb2zZNmzal2guMMgLadfHiJfPmzZO5hcoNwHw+38lpGHmhyW+/DfL29pan hdzcXMH/Lj7s3Lnj0qVLVIVT8OWDBrayasR5yxj0bNq08f79+2iyA6BL9OrVy8Nj GwJbGJn58uULqF+qUreEQuGgQYPWrFlb9cWKReCCgopFYFm5ePHi5ctkDYageH18 fDt06CBPFrQE8PPKlcs4bw5DCUVFRcnJZJX5xJABFsC0xsyshampKX6oiUEMRNvO zjNWrlwpcwtV11RPnToVFhZKkGvVgfjp9OkEa2treRqpWqwrJydnwYL5xcXFcrsm F/ATREcfMDc3p9YNTK1A3541a2bNrAGyadq0aWTkfvxUlJ5kZGQ4O0+nXIDp6+uH hISamJhUvlJRCistrVSOasmrV69WVycrDhk2bNj8+QtkPgypKgkJCbdu3aT8J8Ao G0KhMDs7OzNTqpMUMTQBC2C6Y2FhYWJijAd0DDJgKF+0aPGCBQvkaaRq/vOiRYs+ fkwmwrVa0NDQuH//gTwtgJ/greTPZ8+e3bPHjzaPnJocO3YMF4SnGykpn+HuoCQ3 XkWc6RoSEmJtbUOJdUxdsNnsCRMmqKhQ0yuqAWP4smXLnZycJH8tKyvLLyhIk2MR eNs2D/iAJMUhpqame/ZUHIYkZxa0hAsXLly5cpk2YziG+Yi3/uamp6dT7QimcWAB rABYWVkZGRlS7QVGKYDIafXq1dOmTZeznaprqkOGDCEvLrS3/zkoKEieFiSL1RAj rlq16u3bN2RXbW0UWlpaJ06crOuYEwx6Hjy4v379emrL7QgEAk9Pz549e1HoA6Yq MHqMGzeWVgfSgozs0MHOx8dHMnpISmGVlZbK1lpCwunExESSur1IVL5//34WiyV/ FrSE69ev/f3331gDY9CQl5f/5csXqr3ANBoahXqYujAza6Gv31RfX49qRzAMB9Sv t7e3o+MQOdupmv+ck5MzZcpk8lRlWFh4z5495WkhLy/v8eNHa9eurVyyphXm5ub7 90dR7QWmgitXrnh6bqdDsVnQwOvXb6jr8BsMYmbOnJGRQcfSr6qqqjt27OjSpStI 9Lz8/PS0NNnaKS4udnffQp6kdHV1s7e3B5Uufxa0hCdPnhw+fIgOtyqG2RQXlxQX F+HkZ0UEC2DFgBmbgStTm2i1yIaRAKHSkSNH27dvL39TVfOfg4ODTp8+LX+btQJW nj1LkrORZcuWXbt2lc43V58+fTdv3ky1F8pOfHx8QIA/fUJq0MBLliwdNWoU1Y4o O1u3br116ybVXtSJUCh0cBiwYcMGkJdfv34VlJXJ1g4MQWVlpSTN3T/9ZL927Vp+ aSkhWdAS0tPT9+zxw9vHaAhjQkG89VehUezOp1RYWlqYmJgo+nihIh4y4FPACNjk /6HaI4yKkZFxXFwcIdtNq26pBaZNm1r1r8RiY9Ma3Jb57R8+fJg5cwbl9a4aBG6W 3r1/cnd3p9oR5eXkyRMhISF0e0oCY+mCBQvGjh1HtSPKi4uLy717d+k/i+no6Gxx 36qlrc2RdbiLjIx88+Y1SbeAnp5eWFg4TEBEZUFL4HA43t47eXIcAYUhivIqwP1C t7FUBuCD5OTkpKXhrb+KCt1HbUxVrK2tDQ2bU+0FMUDoZm5ubmdn9/LlS8mCoWRA pH8kwTDgmx882FHOY4SqUlhYWDXgGDx4sKoqWb/p0qV/zpo1S7b3btmyBVSNokzD 8DOdO/c33gxMCTQrjfY/VCt3hEFJWVnZsGG/K8oaI3SV/v0dhg8fDn+Q4e2vX7/e ty+CpCEIXAoPj7CxsSEwC7qS6OjoV69eKsrPxBgky7ySzqavr9+yZcv09PSioiJ6 DqQykJ9fkJKSQrUXGNnBYkORMDNrATBJIkJY37p1m6NHj/L5/E+fPj569Pj+/Xsw 0RYUFMB0xaRPSk9gitq+3fP3338nsM2q5a8glJk7dw5Jv6NAIHzw4IG2tnZj3/jh w4cZM2aUlNB94bcavXr1cnffSrUXSsc//5z38fGhc9AGIeaqVauGDBlKtSNKh4vL 5vv371PtReNQV9dYtGiRbOerrVu3lrxJed26daDPQQATmAVdyaNHj2Jjj9L5LmYG 8KsJBAIdHV1LS4u2bdvZ2raBkFVDQ8PHxzc/P49JzyDgk0Kog5OfFRosMBQMS0tL U1OThq9TKEAGm5qaxsYeMzY2rnyxqKjo3r17t27devHi+devqRxOCZbEBALDd/v2 7ffvj9LTI7K4GpfLZbPZlX/199977tw5Atuviq6u7q1btxv7LhcXl/j4OEWMhEDn REVFwwhAtSNKxJ07d0Dk0L+3QN9wd99qb29PtSNKRFpa2owZzvTvGzWB3vL99z9M mjSpsW/09t6ZnZ1N0kfu1au3pL46sVnQlfB4vMDAAPAfRxFEAVEE9CUNDU0jI8NW razs7OwgqNDR0am8AKI4X18fDofDJOkrITs7J03WknIYmoAHAsWjTZs2BgZNqfaC eGAwbdrUICYmxtrautYLcnJyLl26dO/e3UePHhcW4iVi2YHvbfNml9GjRxPectXy V4Cz8/SqC8LE0qdPn4CAQOmvf/Xq1Zw5s0Gik+QPAlgs1oEDB6n2Qll48eLF8uXL 6FP1qn4EAoGf357OnTtT7YiyMH36tKysLKq9kB2YQBcsWNiqVSvp35KQkJCY+C9J d4SBgUFwcIixsTFJi8AS7t69e+rUSUV8bEEHJIpXW1u7devW7dq179atW111Q+DW 2Lt3r0BQxsggjc0u+vjxI9VeYOSFgV1TGejUqSNTdwPCCKulpRURsa9Lly71XwkB 3/nz5yMjIz9//iTZZ4JntQaBL8rRcYinpycZQQz8Irm5uVVfGTx4EHmPfvfu9e/X r580V4ImX7lyxdWrtC71LA1wd2zatFnKT42Rh7S0tJkzZyjWwgX08/37o3COAAIS ExM9PLYqenAP04Gdnd2MGTOl7Od5eXnkHQMG08e+ffusrW3KyspIWgSWAJ86Jibm 5csXij4dIAC+K0nNKhMTEweHAT/88EODX1pKSkpISLDkXWicRAz0z5cvX1HtBYYA mNlBGQ/zNgNXA0ZPGGd37vSW/qBLCP7u3Llz6dLFp0+fpqamlpaW4umtKjCTdezY 0c9vj5mZGUkmcnJyqpZXycjImDHDmaReCoaSkp5Lc+X169dXrVpJzzN+ZQB69blz f1PtBcMpKiqaMGE8GQtQZAO327Fjx5s2ZWCKEK0YNux32UpJ0RAYG6dNmy5l7sDG jRsk5ziQ4cnGjZskT/dIXQSWkJ+fv39/ZGZmJo4TqgI/rqqqqqGhoY2NTdeu3Tp0 6CD9Q8CkpKRDh2KYfbQH3vrLJBjbTRlPy5aWJiZM2wxcExhu1q5dJ8NuJRjHExMT QQ8/e/YMlFhZWZnSznPwVbRv397Hx7eu3HJCqLn8GxoaGhd3iiRzRkbGV65cqf8a kDFz5859/fqVYq3jNciIESMWLVpMtReMBXryuHFjFffoFG1t7RMnTipK5rYiEhQU mJCQQLUXRAIauEULs4ULF1bdwFkr/v57v379StJk2rdvv7/++gs6MNmLwJVkZWVF R0dnZ2cpc3gAerVZs+bW1lbdunXv2LGjDNMlxFpnziQow3eYk5OTmoq3/jIELIAV mLZtbfX19an2AgUwPc+ZM3fp0qUytwBB7fXr169evZKUlKQ8ehi+tz59+ri5bWGx WGTbqrb8C8ybN/fLly8kmXNyGr51a30lkcPDwwMC/BkmfSVAZ46PP60k9z56Zs2a CZE31V7IhYWFRWTkfqq9YCbFxcWjRo1k5PMFGFgGD3YcNGhQPddcu3b1/PnzJM2e RkbGQUFBzZtXnPWIYBG4ksLCgtjY2Pfv3zPyZ61GpeK1srLq0qVL586d5fk1z507 d/36NWX43lTE9/6HD8lUe4EhDCyAFZvOnTspydCjIh64x4wZA3KOkKYSExOvXr36 /PnztLQ0Ho/LJD0Mn87IyGj8+AkLFy5EowBrLv8Cv//+u0hEVpbgwYMxdeXsffjw Ye7cufn5eQxOxPruu+927/aj2gsG4uLicv/+Paq9IIBevXq7u7tT7QUDWbFi+evX r6n2gizENTi0FyxYUNc5SXw+f9OmjSRFHWA9OvqAZJMOskXgSkQi0YULF+7evcPl Mi0eUFVVMzQ0lChe2dZ4axIbe/Thw4fKE39CkPPixUuqvcAQCWMDRCXBrGI3MIvB gX5NYDTv27dfUFAQsc0+efIEJr+kpKSvX7+y2YWKuI8Fvhk9Pb3+/fuvWrXKxMQU pemay78QJzk5DSMpjIBI5dmzpFpfh89++fIlxs/K8G0HBga1b9+eakcYRXR09OHD hxTuxq8V0BKTJ09xdnam2hFG8e7du8WLFzFJHdUKxPrffddxxozai8CRug3Yz2+P nZ2d5M8oF4GrwmazExJOv3r1Cr4HhfutJYWatbS0jY2Nra2tu3fv3qZNG2JNhIWF fvjwQeG+GXkQb/3NyszMpNoRDJEwYaZXclq1amVsbES1F6iBIb5Tp84HDx4kSeoU FRVdv379zp3br1+/+fYts6SkhJ6SuFyMubnFoEG/zZ49R5I8hhjQugUFBdVe/Oef 835+ZC1RwtR++XL1DcBnz551dXVhTLGrBjEwMDh27DjVXjCHO3fubN68WV2dOVGd QCDcuhUfDkwkEyaMr3rOObOBsXT8+PE9evSs9jqp24DHj58wffp0ySEX6BeBqwHz /uXLl5OSktjsQvi89AwAIBbS1NRs1qyZhYVlhw4dOnfu3OBGbtkAQ3v37s3ISFcq 6SshNzcP+jzVXmAIhnb3M0YG2rdvp6urS7UXFAAztJWV1fHjJ7S1tcm2BTLv7t27 9+/fe/XqdWrq18JCNp9fUSYH/S5TyYRnaWn5ww8//vHHHzDnIXagGllZWTWf0G/Y sOHx40ckWXR0dPTy2lH515yc7NmzZ6ekpNAwQCEP+M4XLFhIxmHOSkhGRsb06dOY F9jBWHHgwMG60lkxjSIuLi4kJFjZBpnmzZsvWrS46nGvFy9evHTpIkmPnm1t2+7Y saOywAFVi8A1SUtLu3nz5qdPHwsKCiDwQD9WiMSoqanr6uoYGRm3bGnZrl279u07 IDgRs6ysdNeuXfDBGVlTo0E4HM67d++p9gJDPEo0lDObLl3kqmSg0MCsYGJiGht7 FHHer8p/h/EkPXv29M2bN1+/pubn57PZbC6XU1ZWpkLEucSSTDOQ9xCFtGpl1blz Z3t7+549e9JnHhJ/Xm7N18ePH1dUVESSUW9v7y5dusLXC3O/j49PfHyccnZ+CArP nfub8fneZAN36+jRowQUrTKRDXSPuLh4pp4bjwzoHsOG/a5U6rcS+Ow9e/aaMGGC 5K8lJSVubq4kDTuampqRkfsrT7igfBG4ViDk+PDhw7t3b798+ZqbmwMCCb4i6BuE zPgwqsP8rqGhqaOjo6ena2xsYmlpaSMG/bwP87uvry+ENPQJORADv8jz5y+o9gJD Cso4mjMSJdwMXA2YNvT09A4cOGhra0u1L/9RUFDw6dOnrKxveXn5YvIKC9nFxUVl ZbXM5RChGhg01dPTb9asGfya1tbWrVu3RlC9WR7gO8/Kyqr1nwYN+o0kUQoT0qVL l1UqclZve3hsEwppFBih5+ef+7i4uFDthWIza9as9HQmn2xhYWEZGRlJtReKjbu7 ++3bt6j2gkrKy1WmTp0qKT24YcN6EIFkxBswvEdFRYPkq3yFPovADVIIrn77lp2d DVN/SUkJn88H6SgU1rIrR01NVVtbW1dXF2Z8CTDvt2jRAmIY9G7XSmZmpr+/P0yv Sh5V4q2/DEZ5ezbzsLa2MjQ0pNoLioEBS1NTKzg4+Mcff6TaF+ZTs/aVhIyMjBkz nEmaOHV0dCGaX7NmdUpKitI+lq4Evv+YmEMQOVHtiKKyc+fOq1cbOFCaAQwYMHDN mjVUe6GogKqZOnWKcqaZVEWcbGWyYMHCkJAQ8s7OdXV1q7pxXbIInJuXpxAamAEk JyeHh4dDMKXM0ldCfn5+SgpZRzliKEfZ+zfDsLPrgGA3LP2RJBF5ee0YPHgw1b4w lpKSkuLi4lr/KTo6+siRwyTZbdaseV5eLp2DUeh+FhaWHE5JYWEhAnNmZuZRUVEI DDGPCxcu+PjsUobHKOIC6X85OjpS7YhCMmPGjMzMDASGNMUUFRXRWXsIhUITE1MQ wCRlQQ8c+NvSpUurRjL0TIRmHk+fPj18+BCMh3Tufsjg8Xhv3ryl2gsMieBezijM zFqwWCxliOekBMK+v/5aPW3aNKodYRr1JD8Df/659N27dyj9oQ8QHS5d+ufcuXOh 73Xv3g2BUIffYtOmzf369SPbEMNITU2dMcNZeXZQCwSCqKjoli1bUu2IgpGYmOjh sRWBJACZt3OnN0zfly5dunjxAs17JoxvJEUaFhYWu3f7NWvWrOqLCpQIrYhcv379 3LmzNO9yKIHuDRFOZuY3qh3BkAgWwEwDJg8WC3UtKJoDY5mz84yVK1dS7QhzyM7O rufAoZEjR/D5fJT+0AR9/aaxsbFwD0r++uLFi6lTpyAInSFwOXv2HNlWmASIjVGj RtaawE82klp9OTnZ6E2rqanFx5/GBbEahZPTMAQF0kDXLVq0yMrKWvLXvLy83bt9 mVqYrX5AV0dHHzA1/Z8wBidCk0RCQkJi4r9Y+lYjKys7PT2dai8w5IIFMANp3dqm 2tNTjIp4ac7JyWn7dk+qHVF48vPzS0tL67mAvApYtAV61+DBjrt27ar2+uTJk1+/ foXAAejbS5YsRWCIGcybN/fLF9SbuyBw/+GHHzw9veDP69eve/z4MfpUQysrq7Cw cMRGFZeAAP+zZ88iMMRitVixYkW1F6Ojo1++fKGEY2lERIS1tU2113EiNLHExMQ8 e/YUS9+aFBYWfvr0mWovMKSDBTAz6djxO01NTaq9oCMwudrb24eGhlHtiKJSXFxc UlJSzwWfP39esGA+Mn/oQZO9e/fWmoRcWlrao8ePCEJYgUBw6lRc1eM6MXURGhp6 6tRJxOIT1K+j45CqeSi+vr4XLvyD3o0xY8bOn69sd6gssNnsMWNGI1AIcPN6enrV aujVq1dRUVFqasq1rWndunX9+zvUfB0nQhNCSEjwx48fle3BipTAlP3q1WuqvcCg AAtgZsJisczNzXAlg7oAGdyxY8eYmEP48Wej4PP5BQUF9V8TGRl57FgsGn8oB+Kw 1q3bxMTE1HN8RVhYWHBwEAJnbGxsQkJCERhSaJ48ebJ69Wp1daTBn0gkGjt2XE3Z CVL85MkTiKs2CARCb2/v77//HqVRRWTBgvmfP39GYMjBYUA99Rp5PN6ePXvy8/OU Z0IfMGDAn38uq1nREydCywOEPXv2+GVmZmLpWxfQqTIyMuupb4JhEsoyniohlpaW pqYmVHtBayAqtbRsefz4cfocvkdnYPrMyclp8LLly5e9efMGgT+UA1/I4sWL589f 0OCVP/9sz+VyyfYH+rOnpxc+AKweioqKxo4dq6qKetF1+PARS5YsqfVfAwICzpxJ QKxtRKLykydPNm3aFKVRxeLRo0fr169D8GwCTGzbtr3Byy5cuHD58iUleWIL8/Lu 3btrzWfBGlgGeDyej88uNpuNK6TWT3Z2Tloak8+Ex1QFC2AmY2vbBoc4DQKTqJGR 0bFjxyTFaTC1Un/Z56qMGTOaw+GQ7Q/l6Os3jYmJsba2lubie/fuzZs3F0HwoaGh eebMGbKtKC6TJv2Rn5+P0iLcOEOH/r58+fJ6rvHz8zt//m/EGtjQ0PDIkaMoLSoW w4cPLyurr9IBIYhEotmz57Rv316ai2EE3rt3r1DI/B2woPOjoqJNTGp/go81sPSA 6PX19QEBrDzpAzJTVFSUnPyRai8w6MC3BMPp3LmTkjwzlhOYR3V0dKKjD0gZiygV 0qtfFSWogCUUCkeMGOnh4dGod40bNzY5OZkkl6oyevQYvMOzVrZu3Xrr1k2UFuHG sbf/2c3NrcEr4Zo7d24jDlL79Om7efNmlBYVhdDQ0Li4UwgMGRkZr169ulFvOXz4 8NOnT5g9xgoEgoMHY8zNzeu6AGvgBklPTw8I8BeJRFj6SgN0uRcvXlLtBQYp+MZg OGZmLQA8AkoJTKUaGhoBAYG9e/em2he60Cj1m5eXO2nSJAb3N+ge4eER3bp1a+wb c3JyBgxwQBC2gj4/dSoOp35U48qVKzt2eCHOALSzs/Pz2yPlxej3DkBwvHbtuoED B6I0Sn+KiorGjBmNpnDd5s0uMhSu+/z5c0hIMIOHWcDT06v+bepYA9fFu3fvIiP3 wR+Y3UMIBPrPt2/f8Km/yga+PZhPq1YtjY2NqfZCkYDREAJld/etTk5OVPtCMRCi 5ebmSn/9iRPHIyIiyPOHQkBYDhgw0NfXV2YRtWnTpnPnUBypYmvbNjAwEIEhRSEn J2fSpD8QL5qZmJjGxMQ06i1Tp05FfD4w9OojR47WlWuqnCxevDg5+QMCQ126dJ08 ebJs7xWJRFFRUW/evGbqUrCT0/D58+fXf2Y11sDVePjwwbFjx2CGwtK3UUCQ8/Vr KtVeYFCDbxKloF27trjOkwzAnLpixQpn5xlUO0INPB6vsLCwUW/ZsGH948ePSfKH QiAOCwkJ+eEHuepLQczao0eP8nIRUV7VY2jXLp+uXbuSbUhRGDt2TP1ndxGOlpb2 iRMn6g/fawIB/bhx4/h8Hkle1QpMDSdPokj3VQiSkpL++msVgkwBoVDk5SVvSkJy cnJ4eBgj1Y6tbdsdO3bo6+vXfxnWwBKuXbt6/vx5pj4NIRWYGt6/R/HAC0M3GDhu YmqlS5fOeHCUDZATU6dOXb16DdWOIIXNZstQuHjixAmN1cw0RygU/vbboF27dhES E8fFxW3Z4oYgYNXU1ExIwNWwKnBxcbl//x5KixCIx8Yea968uQzvLSgogJsIsaTp 1au3u7s7Sou0ZcSI4aWlpNe+gh4yatTon376Sf6mYHqKjo5+/foVw+Z3bW3tyMj9 RkZGDV6p5Bo4Pj7u1q1buNSLbMD8/vz5C6q9wFADFsDKAvrNwDAxM6nmPgyUQ4YM 3blzJ9WOoCA3N1cgkKXWqKPjYCYtR0AQFhYW3qVLFwLbHDx4UHY2ijTXkSNHLly4 CIEhOnPhwgUfH2IeXkgJDBTBwcFt27aTuYUPH94vXLgQpZ6BsXrVqr8cHR2RWaQn wcFBp0+fRmBIR0fXxcWFwAZTUlLCwkLhdySwTWqB++jgwRgzMzNpLq7UwHweTyQU KokMPnAg+vnz50ySvoiDRrz1V8lhTqiKaRArKysjI0OUFm1tbd+/f88kGQyysFev Xvv2RVLtCFlAJJGfny9bAMHlckeOHMGMnxvCr1GjRpOxLPbhw4fRo0erq6MosXPi xEnZ1iGZQU5Ozh9/TEQZIEK3+euv1fIrSdDtu3Z5o9TA0FuOHo1V5s3ABQUF48aN RdBbBALhypUr6ylxLDNHjhx58uQxY5aC9+71l/5QBpi5SjiciqIVSrAUHBgY+Pnz JyZJXxg5TU1ZeXmNKDgiP3l5+V++fEFpEUMrsABWLjp0aK+jo4PMHExCt27djoqK CgsLZYYukgCDtbW19aFDh2Uo4ElnCgsLeTzZ9x9eunTJx2cXgf5QhaGh0f79+6U8 41cG5s+fd//+fZIar4qlZct9+/YhMERPEB9JDcPd8OHDlyxZSkhrAQH+Z86cQZlP oaure+pUHDJzdGP27NlpaSgK4cDAsmDBQpIaz8rKCgoKQryNnCSmTJk6efLkRul5 ZqdDw2i2Z49ffn4+Y55xqIgfvQ0YMNDBwcHNzRXlcMflct++fYfMHIaGYAGsdHTt 2gWlFhWJRM+eJcEfjh07tn37Niblx0qODg4ICPzxR7lqI9GB0tLSgoICOSMGLy+v 69evEeUSJUB3XbRo0fz5C0i1wuPxevfuheA2hB90w4aNv/76K9mGaMimTRsfPnyI 0iLhxbeRlSOupEePHh4e21BapAk3btxAMz1BuL99+3YNDU1SrVy4cOHy5UuKvkLY vXt3V1e3xj6yZ2Q6dHJycmTkPqFQyKQICj7OyJGj+vTpA39evfovlN0VJvqkpOfI zGHoCXPuJYyUWFiYm5qaohxGra1t4uPjJX+GOGPlyhVMGsfLxcybNx+iVap9kQVw Pj8/H4IG+ZtCtoRCBjAjdujQISJiH5pV/aCgoPDwMASGQGafPXuOSfkX0nDp0iVv 750oP7W2tvapU3HEWoQ+OWbMaHmSMmSwuHr1mkGDBiGzSAfgUzs5DUOzgfaXX34d OnQoAkMcDic4OCgrK0tx730jI6Pg4JBmzZo19o1MSoc+f/781atX1NTUGBYyTZ8+ vVOnzpJXvLy8CgsLUDqQnZ2dnp6BzCKGnjDkjsI0Chsba5Q7A2G42b7d8/fff698 5fnz53PmzOHzeYwZ01XEjzN79OgZFhamQM/dCwoK+Hw+Ua2hKaBKBhBe7Nixc+DA gSiN9unzM5oE3b59+23atAmBIZqQl5c7ceJEtEWkyo8ePWJkRPxx6/BZ/vhjkqoq unESxrHY2FgyPgtt8fDwuHkzEYEhVVW1bduQLrAnJSUdPnxIQedZcPvgwRiZ96Ur 9FIw3IYhIcEpKSlMynaGn0BVVXX+/AVVtxc9evTo+PFjKLsohD2fP6cgM4ehLQo5 LGLk57vv7LS0tJCZq0yErgoM7lOnTi0qYivo9Fwr8ElNTEyjo6NbtmxJtS/1Ied2 31r57beBCiT+JUiKe8t/IKcMPH78aObMmUhOHBXu3x9F8w5JIOPGjS0uLkZmDr7e 7du39+zZi6T2Hzy4v2HDBpRxsL6+/okTJ5GZo5bU1NSZM2cg+Hphapg3b76trS3Z hmrajYk5+OLFC4WTUnBnHThwUJ5qYVWXghVFBufm5gYEBHA4JYq7dF8T+No1NDSX Ll3KYrGq/dPatWtQflI+n//69Rtk5jB0hjnCA9Mo0J+KBLYeP35S83U2mz1+/LjM zEyGDfd//33ewsKCakeqA47BF05GUmVOTs6UKZMV6FkGfBWmpqYREfvIK3bVIJMn T379+hUCQ4aGhkeOHEVgiHLc3Nzu3r2DzBz0ojFjxs6fP59UK6GhoadOnUR5c/30 kz18k8jMUcikSX/k5+cjMMRitVixYgUCQ7WSlZUVEhLM4XAUaIgGPD29vv/+ezkb USAZnJeXt3PnDsX6jepHJBLp6+uvWvWXrq5uzX9ds2Y1yucy+NwjTFWYc5thGoul pQUIAJQWf/65T11FYkCSTZo0KTn5g8I9pa6LJmJA4axYsZIO2p7P5xcVFQmFQpIa X7RokQJtAIaJcPXqNVOmTKHWDfhF+vbtg6Ya1uzZcyZMmEC2IWq5du2ap+d2lLdb 69ZtgoODERhauHDhp08fERiSAGHr+vUbHBwckFmkhGPHju3bF4Gm9pW7+1aURzDU yr//3jh79qwCTbImJqYhISGgoORvqpoMhlfoo4Thdjtz5szt27fAHwX6deoHgg34 +VasWF5Xybfw8LCPH9GNaUB2dnZaWjpKixg6gwWwUmNr26Zp06bIzMHgHhNzqHPn zvVcM2OG86NHjxGckooM+NRDhgzZvNlFT0+PEuvFxcXk7TWFmdvf3//cubN0EPnS ALNyr169AwICtLW1qfalAl9f34MHDyAwBL9UfPzpWh/DM4OcnJxJk/5AGT5CXzp/ /h80af8QuA8dOgTxpzty5CiDTwaGUXHUqJFoBi57+59HjBiBwFCDlJWVhodHfP78 SVGEFvRDJ6fhS5cuJeSXkshgFfENRYcFYR6Pd/z48efPkxTl55AGgUBoZdVq6dI/ 67nmy5eUoKAglGvdRUVFyclI9TaG5mABrOx07twJ5b5NmHWeP3/R4GUrVqxgwCkO VYFZvEuXrps3b7Kz+w6NOQjvuFwuqVN7RET4sWPHUVbokRN9/aYw6Xbp0oVqR/4H e3t7Ho+LwBDh5/TQiokTJxQWFiIzJxKJwsLCbWxskFn8/PnzvHlzUT5patasWWzs MWTmEIPslKkmTVS3b9+OwJD0pKSkRERECAQEFP9Hg0hUPmHC+Dlz5hLVIOULwqmp qSdOHE9LS2NSnAPf53ffdZw1a1aDVyI+9wgce/HiJTJzGIVAYSJXDEmg3wysq6t7 69Ztaa7cts0jNjaWSU9GJfthxo4du2jRYjJWIEtLS0H0Ijg35ciRI9HR0SoqtMgf kwb45ufPX7Bo0SKqHamFe/fuoRE28CVs2bLF3v5nsg2hJyQkJD4+DqXFKVOmTps2 DaVF4ODBg4cOxaC0OGrU6AULyD0WmxLu3Lnt6uqK5qabPXtO+/btyTYkA5IjdhRK gDVxdnaeNGkSUc3VXBBWIVkJl5WVwtd+7959gaBMUdKmpAG+wN69e48bN16aizdu 3CgSkbIbq1bw1l9MrWABjFFp1aqlsTHSQy9gAluzZq2UF4eFhQUGBjBpqlARzxZW VlaTJ0+Br0LOj8YTQ+BpRvXj6+t78eIFNLYIQSgUdu/ePTg4hJIUdCn544+Jb9++ RWKqydmzZxUq5G2YlJTPs2fPRvmh4OYNCwtHZq4q8+bN/fLlCzJzMFLt27fP2toG mUUEwIdycnJC8/zO1NR05cpVCAzJBswdYWGhqampivWgefBgx5UrVxLYYK1KWIU4 MSwSiW7eTLx582Z+fj7Dhl/4xgYNGgxIeX1cXNz9+/dIdakaubm5X78qTIESDDKw AMZU0L59O5SbA2FGuX79RqPOIo6Pj9uyxb28XMSkAokqYnnWqlWrESNGTJs2XZqf ACabUjEwYcOcisDDSkJCQk6ePKFYcZKenr6/v7/8dUTJpqCg4Jdf+qH5bn/44Yft 2z0RGELG6NGjuFwUOeQSNDU1ExLOIDNXE8QHbuvo6MTFxSMzh4ANG9Y/fvwYgSEY rt3cttD50ZuEjx8/RkZGCoUCqh1pBDB1jh07jvD0hEolrFJDDKs0Xg/z+fzr168/ evSQeboXvgeRqHzs2DG9e/8k/btKSkq2bnVHGcVxOJx3794jM4dRIBilJTDy0KVL Z5TaptaTgRvkzp3bS5cuhWmJYTJYRVw3onnz5n379nV2dra1tYXvRygGPqzkDxT6 9u3bt6lTpyiW9IUvcOHCRQqUventvfPw4cMIDEFf8vHx7dq1KwJbCPD09Lxx4zoy c3A/njhxslEP7winoKBg3LixKOPpX3/tv379emTmSCUpKWnVqpVoRrPevXuPGjUa gSFCuHDhgsKV3oDRLCbmUIsWLchovKoYVqlND0uoqYrT09OvXr369u0bHo/PpIqe EiQfdsaMmXZ2do19L+Ktv9A9pCk6g1FOmKYiMDJjVrEbmIVSWFpb28THy7Kw8Pbt W1CJPB6XeTJYRTy7wPxiZdXKwWHAiBEjUJbprgmbzd6yxe3Zs2cKFBXBnNezZy9/ f3+Fq3hsb/8Tgv3bAPyaCQlnGLCt4NWrV8uW/Yns0QzcmZs2be7Xrx8ac/WQmJjo 4bEV2QAI99SePXs7duyIxhx5iESiESOGg5JBYAt+HYVLteDz+RERESkpnxXocSf8 mt26dXN1dTMwMCDVUDU9XGldooo5HA7clU8eP8rKylZTU2VqcKKqqrZ48WJLS0sZ 3u7l5VVYWEC4V3Uh3vqblZmZicwiRrFg4C2KkRlra2tDQ3QrGzA87dzpLf3WkWqk pqZOmTK5sLCQkTONBAjX1NU1bGxs7O3thw0bZmRkhMx0VlbW9u3bXr58qUCREPQo +IqCgoLQlNomnMePH82YMQPNF/7zz31cXFwQGCIPuDuGDx+OMm+zb99+mzZtQmau fjw8PG7eTERmTk1N/cwZhX9o4u7ufvv2LQSGhELh/PkLbG1tEdgiHJhbIyLCeTye As2t8IV36tRpw4aNLBYLmdG8vLyEhITbt29//foVBiJFvzvqAeZWTU3NZcuWy1wv 5unTp0ePHkHZo/LzC1JSUpCZwygcCjO6YdDw3Xd2WlpayMzBpJWU9FyeFths9sSJ E9PT0xg890gQ5x01adGC1b379w4ODt26dSPpIycmJoaFhWZmZiqQ9FURfz+rVq2a Nm061Y7IxcyZMyBQQGCIAWt669eve/LkCTJzurp6p06dQmZOGsaMGcPhlCAz9/33 33t6eiEzRzgo8wUsLS2XLFmKwBB5XL9+7e+//1asWQCGNTMzs3nz5pOUpiHeuvXs 2rVrT58++fYtC6YdBXpGIBvwkZs2NVi5cqWcGVVr1qxG2Zf4fP7r12+QmcMoIgy/ dTGNxcysBYvFQikmYUx8+PCRnI0IBII//pj47t07xZqt5UEgEGpqasJkb2dn98MP 3/fu/ZOcydIQHUZF7U9KSgIlqViTOgQ9Dg4O3t674Auh2hd54XA49vY/obkBFToR OjExcetWd2TOQx87dSqO2v0INSkqKhozZjSyQQ9C4c2bXeiQAS4DKJOfwYqHxzaU j5JJAj5IdHTU27dvFWtilUxhXbt2nTFjppzP+OAWu3fv7uPHT968eZOZmVlaWsq8 Pb11AYOeqSkLpK/8v/66dWtRBhVws2dlZeFzjzD1o0hhLgYNlpYWpqamKC06Ojp6 ee0gpKnZs2fdv39fgTasEoW4JKNIV1fX0NCQxWphZWXVrl07W1tbS0tLHR2dWt+S kZFx586dZ8+evX//Ljs7W7FCHAnwqc3NLUJCQqytran2hTCiovb7+fmhCRd++sne zc0NgSFi4XK5o0aNRBZRQTfz8PDo2bMXGnON4sGD+5s2bUL5VcTHn65rSKEz0M/v 3r2DwBB8RYMHOw4YMACBLTSAlggLCysuLlKsB6MSxCrOtF279t26dbO3tzc3N6/1 MhhS0tLSkpOT379//+XLl6ysb/n5+RwOR1WVmbt560cgENjYtF68eDEhrR08ePDV q5eENCUlEM+kpaWjtIhRRJTuxsZIQ5s2rcmuJ1EViBhOn04gUMP89ddfFy9eUERF RwZCcY3KqmtlIJVhUlf07wf8d3PbIj7Pk2lA9Jyfn4fAEPQNb+9d3bt3R2CLQBYs mP/582dk5nr3/mnLli3IzDUWV1fXe/fuIjNnY2MTEhKKzBwhPH36dPXqv9CMeFpa 2or4UKlBHj58cOLECUVXg0ydDYkCpG/nzl2cnZ2JajArK8vX1wdlt2Gz2R8/fkJm DqO4KPZYhiGPTp06amhoIDMHwy7h1eq9vXfGxMQoaIYnph4giBkzZqyLiwtTf9wP Hz4gS22F7zAh4YwCJU3Ex8cHBwchi6hgGDxz5iwaWzIzfLhTWVkZGlugHxYuXDRq 1Cg05uQHJpcRI4ajOTUdhqYVK1bWtcyo6MB3ePz4cVDCCjRcYKQEbpM+ffoQfmoX 4nOPYBh8+fIVMnMYhQYLYEztVByK1KIFyud2pqamFy9eIrzZ6Oio3bt3K/pza4wE iMA6dOgQEhKKsiA2JSxfvhzZ8badOnX28fFBY0tOCgoKxo8fh2y5BoLCuLh4um39 rUlRUdHo0aOQBZog844fP0HtYcjSs2rVqpcvEZ0F2q5d+1mzZqGxRRXFxcWhoSFZ WVlMff6obMDtPHToUAcH4pP23d3dudzqB0eRh/jco2946y9GSrAqwNRJq1YtZS55 Lxtr1qydNGkSGS2fPXt28+ZNClfeCVMVXV1dX9/dvXv3ptoRFID06tmzBxpbIpFo /foNDg4OaMzJw5QpU3Jzc9DYguFi9erVv/02CI05Obl8+ZK3tzey8c3Y2OTQoUNo bMnDtWvXPD23o5FqICQ8Pb2IfToDrUnqOxDYJiG8e/cuOjpaJBJS7QhGRiT9asKE CT169CSj/cTExL//PkdGy3WRm5v79WsqSosYhQaLAUx9tGvXVk9PD5k5GI4fPHhI Xi3fe/fuLVmyuKysDMtgxQKm6gULFi5YsIBqR5By4cI/a9ciKp4Jt97Jk6dovtQZ ERFx/PgxZDdvmza2QUFBaGwRwqJFiz5+TEZjC27J8eMnzJkzB4052SgqKho7dgwa 9QtfyMSJf3z//fcEtqmmri7Jps7JzeVzueKT8OjFhQsXrly5jDfQKhaSjjRr1uz2 7duTZEIgEGzcuAFljkBJScn79x+QmcMwACwDMA3QpUtnxNPbkyfknoP67t07Z+fp XC4Xy2D6IxAI+/bts3u3n7a2NtW+UMDo0aM/f0ZUz4PFYh04cBCNLRn4/PnznDmz kWX5Qox44cJFNLYIxNFxMLJhDWLciIh9NjY2aMzJwPTp07KystDYMjQ0WrNmDYEN wrRrbmHRvFkz+HMJh1NWWvotKwv+S6AJQigrK42MjPzwIVl5zgdSXCQFwJYsWWph YUGqIcSn/gqFQsKLyGAYDxYAmAZAvxm4V69eoaFhZFvJycmeMGFCXl4elsG0BWbr kydP2draUu1IA5SUlMAETEbhdDabDfofTSRB5zU9kUg0atSo0lI+MnOHDx8xMTFB Y45AcnJyJk+ehGzhRVNTKz4+np57QVHmC8Dt7+a2RVdXl6gGK9VvZSnKsrIykMF8 Pv9bZiaYI8oQUWRmZvr54Vob9AWGd21t7ZUrVyE44CMkJDglJYVsK5Xgrb8Y2cCj FaZhrK2tDA0NkZmD4Sw29liHDh0Q2ALpMn78+LS0VHrGcErOrl0+AwcOpNqL+oC+ mpubK4lH9fT09PX1CTcREhISGhpCeLO1Ah8kMDCIvLw4mXFx2Xz//n00tkD9OjvP mDJlChpzhHPo0KHo6ChkA1qvXr3c3beisSU97969W7x4EbI1qP79HRwdHYlqrab6 rQRkcEFhIT0zopOSkmJiDuJ0aLoBAxqI3lWr/kKTRZWWlubvvxflo5D8/PyUlC/I zGEYAxbAGKmws+uAMgeVjFOR6jc3deqUV69e4cmbDoAMGzt2nKurK9WONEBRURGH 8z8lLkEAk7FnHjRGWRmi1Ee4BU6fTqDVMSeJiYlbt7ojU3Tdu3f38tqBxhZJrFu3 9ulTcjeSVALh9ebNLv369UNjThpgPB85cgSyZVLQoV5eXkS1Jtn3W6v6lSBZCqZt RnRsbOyjRw/xTEoH4BYwMzNbtmw5yp8D8blHPB7vzZu3yMxhmAQWwBipMDNrwWKx UC6T6us3hcAXmTkJCxcuuHXrFp68qaK8vLxNG9uIiAian3IEgUVeXl6tpVmbNm1K YCakhK9fvzg5OSG7+2xt2wYGBqKx1SAo6xipiPX/mTNnFT0fBHrm8OFOyBQg3Sqo LV68ODkZUTkc+OyrV682MTElpDV1DQ1QLPWo30pABhey2TAK8bhcumVEFxcXBwUF 4u1FFAJdwtbWdv581GUjN2/eLBAgOpBcRXz3ZWVl4eRnjGzg4QkjLRYWFiwWMdO8 lMyaNXvp0qUoLUrw9fWJjo5W9CBY4dDU1AoICOjZk5QjGQiksLCQx+PVcwEZGnjq 1CkvX74kts26KC8vnz7dmSY5wFOnTs3JyUZjC6LG3bv9OnfujMYcqbx48WLFCnQr P6AAY2Ji0Niqn0OHDh04EI1MeklW2AhpSkNTs0WLFtKoXwn/LQWXleXk5PB5PLpl RL9//37//ki6ecV4BAJBv379RowYid70uXPnbt5EumiRlZWdnp6O0iKGSWABjGkE rVu3btaM9AoKlcDceevWbZTnMFXlzp3by5YtKy0txY+xyQaEx9Klf86dO5dqRxoA OkNBQYE0IR0ZudAQ1hQXFxHbZl1AFBUUFEz5ZuCAgICzZ88gM/fLL79u2LABmTmy 2b59+7//3kBmzslp+JIlS5CZq5V3794tWrQQWQammpq6h4cHIU1pammxWCzp1W8l NM+IvnTp0oUL/zT2Q2Eai2RWmjFjpp2dHSUO8Hg8NzdXlMFSYSH70ydERyRgGAmO 7DGNo1OnjignM5FI9OxZEjJzNcnLy5syZUpaWirOiyYDgUDo6Ojo5eVFq02ntZKf n1/amPhSV1eX2KTQt2/fjh8/Dlk/hFDm1Kk4HR0dNOZqkpSUtHLlSmRnq2hra8fH n0ZjCxmjRo2sP1uBQOBe9vX17dq1KxpzNeFyuWPGjEa25CgUCpctW25paSl/U9o6 Oqamps0MDGSeW+mcEQ3+xMTEvHjxAp+TRAbiAwiaLV++nIwSjNKDeOsvdPiXL18h M4dhJFgAYxoH+lOR7Oy+O3LkCDJzdbF06ZIbN25gGUwUIpGoQ4cOISGhNN/uqyIO rNlstgxvBPVI7JkTLi4uZ84kENhg/ZiZmUVFRSMzVxUOhwNiBpk5gUCwb98+a2sb ZBbRkJLyefZsdIcnA6dOxRGe/y8lM2Y4Z2ZmIjPXtWu3SZMmyd+Ojp6eibGxPOpX As0zoouLi0NDQ7KysvDeIqKAUQvm0DlzqM+c8vPz+/YN3a2Hzz3CEAIWwJhG06pV S2NjY2TmYLALDg6xt7dHZrEeDh48uGuXN57C5QF+0BYtzPz9/SnPsJWG3NxciDNk fruWllbz5s0J9KdPn5+rlZ4mlT59+m7evBmZuUoQi5nRo8fMnz8fmTmUhIaGxsWd QmaOqocmW7duvXXrJjJzqqpq27Ztk7ORJk2a6OrpGRkZya9+K6F5RnR6evq+fftK SorxxiJ5gClp2DCn/v37U+1IRep+RkaG984dKH9QmJS/fk1FZg7DVPAYhJGFdu3a 6emhe8wvFAqTkp4jM9cg27Z5xMbG4tVgGdDW1vbw2Ebz030lFBcXl5SUyN8OhLYE rnIjToQWiUQLFy4aPRrdYqyKeD3h/Pm/kUVUhoaGR44cRWOLEiZN+iM/Px+NrfLy 8qFDf1++nJi6UFISFxcXHByE7LkkIcnPqmpq5ubmmpqaerq6hO8qonNGtIp4d8PR o0fotkatEMCv2atXr3HjxlPtSEXNNhaLBR14/LixKGOhkhLO+/fvkZnDMBgsgDEy 0qVLZ5SjHoyz9+7dR2ZOGg4fPrxjhxdeDZYSCPKWL18xefJkqh1pGAgfQTAQGJ/B nWJiYkJUa1u2bImPjyOqtQYRCAR+fnuQ1UZOTEx0d9+CbGyBgDI2NtbICF1KC3ry 8nInTpyI8it1cXFFdjLwixcvli9fhjLNu3v37+H7lKcF6Y87khmaZ0QD//777/nz f1PthcIA4/Dw4SN++eUXqh0RS19TU00tLT1d3dGjR8mTIdVYYGx5/vwFMnMYZoMF MEZGzM3NWSxTlHkvY8aMpSQbs35u3bq1cuUKPp+Pc7rqQlVVdf78BfPmzaPaEalo bLErKYHuwWKxiGrt119/kW1bsmyIRKLDh48QqOHrAoL1yZMnIXuoBKpg7ty5dFhO IZsTJ46Hh4cjG6OY2mFUxA/y3N23ytOClra2qakpqeq3EppnRAMXL168cuUyfo5c FzBGwW07fbrzd999R7UvFQ9uYBbTEktf6L1+fn7//HMemXX4KrKysjMyMpBZxDAb HLJjZMfGxprY/Y31A8Pf9es3UFqUnvT09KVLl7x//x7nRVdFIBDMnDlr5cqVVDsi FTIXu5IeIyMjQqLer1+/DBs2DGVnA7dPnDgJoQ95JqC3jB07ls9HVLUYaNmyZUTE PmTmqGXOnNmpqeg2zmlpaZ88eZLUhVk+nz9u3FjQeOSZqAZ00bVr15qYmMrcgo6u romJCYGbfqWB5hnRQEJCQmLiv/Q/CwAl8EuZmprOnj2HDnUiq0lfeAXmyvHjx6F8 7l9QUPD5cwoycxjGgwUwRi46dvxOU1MTmTnKT0WqH3AvMDAwIiIcP88uLy83MzOP j4/X1tam2peGgR8OokM0oWHTpk0JKZO7d+/eyMh9KOMPiMNiYg6R17fnz5+fkvKZ pMZrAj96fPxpqkoWo4fD4YwaNRLl0GRtbRMaGkpS4/DzTZ06BW5bktqvCYxp/fr9 MmzYMNne3kRV1dzcvKqEQAn9M6LLykq9vHbg+lgq4ucs/fs7DB06lA6BRE3pK2HQ oN9QPoEtLS199eo1MnMYZUDZBxqMnKA/Faldu3bHjh1HZk42MjMz/fx2X716FUZt ZZvOIbQyMDA4deqUPOskKCksLER2VqoEbW3tZs2ayd/OkCFDUB4+AVhZWYWFhZPR so+Pz8WLF1Dm6K5fv8HBwQGNOZpw7do1T8/tKDPMBw92XLVqFRmNz5s398uXL2S0 XBe6unoy78FRU1c3NzNr3rw5eulbFfpnRLPZbG9vbxDDSjhvwn87ders5ORkaGhI tTsV1CV9VZA/rMTnHmHIQLmGGAwZtGxpiWCvVyW0OhWpQT58+BAQ4H/79p3SUuZv EoafRkdH9+DBg23btqXaF6kA3QvqlxLT6urq8p8llpeX5+DQH/EqQefOXXbt2kVs m4ir+KqIA02Q3MjM0QeQoy9foqsiQ1IV8b/++uvFC6TnAggEAldXN319fRneq6ml BUICzaZfaZDIYD6fD5KCnhnRGRkZ/v7+IpFQGSZNiMPbt283dOjv5ubmVLvzHyB9 QffWdUDXo0ePNmxYj/KnycnJSU1NQ2YOoyQwfHDBoKFtW1vZIgPZoNupSNKQkpIC If7NmzfZbDbz9gmLpa9OSEhot27dqPZFKsBhUI8oy1fWBAIIU1N5y8jFx8e5urqi lI7w1fXs2dPDQ95DUCt58OD+hg0bUN4UqqpqCQkJyrnhEPr8iBEjQFogswjD9fbt 23v27EVUg5s2bXzw4AHK+Btk/JgxY3r3/kmG91Ky6VcaQAYXFBbm5ObyuVwaZkQD nz9/Dg8Pg/7DPBkMH0pTU7NDBztHR0cCiyPKT6X0heGxrlx9xMnPxcXFHz4kIzOH UR6YNqxgqKJz587q6ujGRG1t7Tt37iIzRyBFRUUHDhz455/zX758ocMOHzmRJDwH BQUjOyZHfthsNpfLpdqL/2jevLmclaVmzZr15MljovyRBvjRf/rJfsuWLfI39fHj x3nz5qLUoqAAAwIC7OyoL6lKFW/evF6yZAni7zwsLLxNmzbyN+Xq6nr37h3Eiqhl y5aLFy9p7LtgeDejbtOvNFRuDM769o2M0veE8OVLSnh4BDOSouFGAG3Zvfv3/fv3 19HRodqd/6Ey4Rn+XE+PHTFiOMquIhAIX7zA5x5hSEHhBxQMTUC/GdjZecby5cuR mSODJ0+exMTE3L9/v7CwQOGWhYVCobW1tZ/fHltbW6p9kRYEdZ5lACIhAwMDmd8O QZW9vb1AgK4WropYA/fo0XPbNrnWgTMyMpydpyN+DDRs2LClS/9EaZGG+PvvPXfu HEqLIpEoOvqAnEmeGzdufPgQ6dqvSkVXV4F+3tjxGcFJv0RB/4xoFXFZjf37I/Pz 8xVxogRVaWvb9pdffiHkGRDhQBc1rWOvbzUiIsJPnDiBzDG89RdDKlgAYwjD2toK ZfEGGBxv3bqtp6eHzCJ5QHQI8WhCQsLLly+KioponpwJ3g4dOtTNbcv/sXcn8FFW 9/7HQ/YQCBCyDEnYE9YEr9fettrev/cWl167qPXWalurt7bVttr6kh1BcQHRiloV tNXijrZVUdFWEC3uC6KShE0EzTIzycxktiyzZJb/CUMjhZBMJnPOPM/M5/3qqy9M 5jm/Awx5nu88v+ccXazwHCGuQux2u5h5oifStyE+Erx3757zzz9f/aXhtGnT7rrr 7tiOFX8dP/zhD8W/4/hOqX/iB9QTTzypsqJmXXjhBSJOqK05bMOGDTHv6fKb31z5 ySefxHdCAxI/N37zm99WVFQM6qicvLyS4mINtj33Q/sd0WmHVop+8sk/19bu1Pgp MhAIZGdnV1SM/9KXvnTSSSdpttUrKztbvFGzo2tS6OrqOvfcc1R+/CR+QDU0KF3o DimFAIx4mjFjuspQpPFdkWIjflOvv/76pk2bdu782Gq1Djsk0ZPqIa4FRX646aaV //mf/5nouQyOOI9qtsGvl/hbFhk45hC7du3a++//o/q3SnFx8fr1Dw72Ql+k3x// +EeKP48Q5f7yl79qcyNx9ZxO5/nnf1/xpbko99hjjw82A4ts9n//d4nNZpM0q+MR OfDUU//rf/7nf6I/RPwDzMvPH3uc1YM07ouOaIvF7/Mlejr92b1795NPPuH1ejVy Q1i8VcT5ccSIERMnThKhd9asWZoNvRE90bekRKT06PvzzzjjdJW/KfGXu3fvPmXl kII0cWGNpGEwlIqfqip/Sp5wwgkPPfSwsnLqNTc3v/jiC++++96nn37qdrsU52Fx Xhd/m1VVVV/+8pfnzZuvrG68dHR0dHZ2JnoWgyAuoWJuajjvvO8dPHgwvvOJhrh+ evDBh6JfCl5cXv/kJxdJndKxRPpdsGDh6aefrriulr388su/+92t6q/UH3nk0egX /jGbzT//+c8Ssl6dCOriPRP96zMzM0sNhkGFCg36oiO6tTWY0GUCo/Hcc899+ul+ MVXxNlZ8ZhSJNzc3r7S0VJwfRegd+qr+KgwbJt6fxcXFg32XXnXVb/fu3St1akcS P67FaYLmZ0hFAEaclZeXiR+vysqJ89Bjjz2uoxWYhkjk4X/849UdOz7cv/8Tq9Uq 4yNwce4RVxIVFRWnnnrqj37047KysviOr4a4gHO5XJrt5euHuCiJrU1UvBm+9rVT EtLmLa4Fly69Jpptdffu3fOb3/xGfej6t3/7t9Wrb1FcVPsWL1708ccfKy4q3qJ3 3XXXgOuQiSS2ecvm3995Z0Lu8olJ3nTTTVlZ2VG+Pic3V5z4dPHQbzTEH77L7bbZ bF4Nd0QfyW63v/76a7t373E6HeL8FfefMIFAQLwPCwoKDIZxU6ZMrqmZo4/E+0/i zyQ7J0e8RcX7c7Af0Ijo+9vf/kbl5wvi2sZoNCkrh9REAEb8TZkypaBgpLJy4sxU V5e66wRaLJYPPvhgz57dBw4cMJlMNlubx9Ml/kwiN2/7P2mJ14jrvJ4ND/JHiMQ7 a9ask08++ZRTThk+fLiy+cedCGMOh0Ozq7lEI+Z2aBEvv//97yfkATnxRvrqV09e sWJFP5eeL7309zVr1qjPM9nZOc8++6zGmxITQvytnXPOOX6/6n5X8c9z3rx53/xm 393FIn21d3Tccsvqjz78MCF/a+Ln529/e1WUj/7quu25HzrqiD6Kz+cTmW3fvn3N zc3iXODzecWZTvzYieZsGDlvZmVljxw5YsyYMaWlBvE2qKycOmqUXh+dGJaenpOT U1RUFEP0jTjttLkqzylud3tCWpmQagjAkKK6erbKn5gFBQWvvfa6snI6Iq5dmpqa nE6nx+PpzYQ5OdnivF5eXi5OikmWCnTxuG+UYmuHXr9+/V13/T5Rz42Lq6tVq26u qak59lvXXnvtu+++o/79JsLMww8/It7tiuvqhdFovPjin6j/0CTyickNN9xw5Bcj oWvnzp2rb16VqBuPou7pp58+d+5p0bxY/LkZDIYsnbc99yPyNyICcKvFEuhWutR8 fIn3W3t7e1tbmzgb9nbUp6cPy87OET9me/ZqHjUqsTOMu/SMDBF9x44dG3P0TTv0 ZI3Kx4jEX019/S5l5ZDKCMCQwtCzLVKJyqvwq6666uKLL1FWDlqjqd194yW2duhL L/3phx8q3Rn4SOJCs7KycsWK63uf89y9e/fixYvV32ZMOxRmfvnLX51zzjnqS+vI s88+e++96xLyoYmIH6tXr66qqhIpK63nEY+m1TffbLFYEvjBXEXF+F//+tfRvDLJ 2p77EemIFunR6/Fodi199MrMzMzOzR1bWNjT3jWEj2b+8pe/rF//p/jOrR+H9j2y tLS0KKuIVEYAhizjx48fOzbGHS9iIM7K27d/kJ0d7SNbSBq6W+lqUEQsGTNmzKCu YMS/hVNPPbWjo13erAYUDAbHjRt39dXz7r777sbGhkQt1jp7dvWaNWsSUlpf5s2b t2tXYh4kEW+VsrLy884779FHH3U6E7zRqwgM119/w4Dxe1h6+vDhwwuTru25H70d 0Var1efzpenhweAUlHVojaucnBzx6yF2JYi/62996yyVH0W1tdmbmpqUlUOKIwBD ounTp+Xl5SkrJ87I6hd0QQJ5PJ729nZdrNEyROLfUUFBQfSvt9vtc+d+Q958oiT+ ahK4iVdOTu7GjRuTrMlfklAodO655/p83kRNILFvlQgRxa+99roRI0b0/zIRKkoN hqG0lerX4Y5ov99isXQny8MmSSCyxlVRUVEcFyE/44wz0tPV/ZMUZ/N9+1Rv9I1U RgCGXHPm1Ki8AD3llK+tXbtWWTkkin4XeY5ZRkZG9FsNCR9+uOOSSy7RyD6Z6okw 8/jjG6Lfbgci0vzoRz9M5TfMZZddPnXq1P5fljd8eM/zoilz47dP+toqKbmlZ2T0 RN+hPeh7rKVLl4ozSFyGikYoFKqtrVNWDkgjAEO2srJxKq9BRSJ66qmnKysrlVWE Yn6/X0TflH0ObeTIkdGv0f3www/dfvvtKXgLVISZZcuWn3rqqYmeiM689tprN910 YwpmYPHz5Jvf/OZ//3d/TRPij8VgMIiwkYI3fvv0xYPBXm9Iz6vu61RmVpZ4Nw79 Qd9jff7555dd9guVHRkWi8VkMisrB6QRgKHA5MmTR40aRPfmEKX4rkhJTFxvOZ3O lI2+vcTlTvRbUC5duuRvf/tbwptLVQqHw2eccca8efMTPRFdWrPmti1btqTaG6a6 uubHP/5xP68RSaOkpCQV1rsalN4HgyMxOJzyP5wVOLLbOW3ID/r2SfG+Ry6X+7PP PlNWDohIoZMcEmj27FkqrxuKi4u3bHlZWTnIluJ3ffs0atSo3NzcaF55wQUX7Nu3 V/Z8tKO8vOJPf1K3cmnyufTSS43G5kTPQp3i4pKrr776eN8dlp6eN3x48m3zG0df rI9ls/m93pR6MkWljMxMEXqHuK3RgC688AKHwyFj5D6Jt82uXbuVlQN6EYChQs+m SKWlKu8qLFu2/LzzzlNWDpIQffsR5SZJ4k9v7txvOJ1OBVNKuKys7I0bN6rf1TaZ BAKBc889t7s7JZY4EoniuutWHO8xgazsbHHmSs31rgbryGWi/T4fMThexIVTz9rO RUXZ8VjbuX8vvvji3XffJWnwYx3a96i1paVVWUWgFwEYikyYMD6GHU1jJi76d+6s VVYOcefz+dxuN9F3QAUFBQOutd7e3j537tykjzShUHjDhg2DWioMfbLZbD/84Q9V rgGbECKjXXfddX3+8xGpIzcvj/WuBosYHEdqbvke6YwzTle5ZoTdbm9sZN8jJEaS n96gKYp3RRo2LP3DDz+M+XCv1xtliyniK3U2N4qXaJ4Kttmsp59+upr5JEQwGFy9 +paTTjop0RNJEjt27Fi8eFESL4gVWSmtz93FRPDoWe8qfjvKpBqaoodiWHq6eNep ueV7pG9+85tpaer+ptj3CIlFAIY6BkNpSUmJys8XzzzzTHFNHNuxkRg2cuRIlaE9 xXV0dHR2diZ6Fno14ALRBw4c+N73zk3KRaFDodCvf33F2WefneiJJJXnnntu7dp7 kvINEwgE5s2bL1Lusd+K3Phlvauh643BtrY2EYNp5xlQVna2+F/hmDHqu+5XrVr5 +uuvKysn3gwWi4XmZyQQARhKlZeXFRcXKysXDoe3bt1aVBRjxba2tsChTQ7z8/NH jBgR16nhC+Kvye12e73eRE9E90RWKSws7Oeu3Y4dO3760/9Lskgj3j8i+v7qV79O 9ESS0Lp1a0UMTrJFoY+35S8bHcnwxUrRdrvf52Pf4GNlZmZm/bPVOU3hLd9ednvb hRdeqPKfudVqNRpNysoBx0qqsxp0YerUKSNHjlRWbogPA7e2fvEJZW5ubkFBQZJd CyaW3+9vb28PcEkUV+KNOmrUqON995133rn88suSKQP/+7//+6pVNyd6Fklr6dIl Q3mWRGtE+r300p9Nnz79qK9z41eqSAxOO7S4g81mEz/501K+LzpD5N6sLJF75W1o FKXTTz9N5cMO4qR/4MBBZeWAPnEpjwSorp6tcpnWGTNmPvHEE7Ed29XVJX5YH/kV MXORLlhmdog6D+HZMHn62SdJZODLLvtFcjzeOXnylHvvvTfRs0hyv/zlLz/7LBku WAOBwM9+9vOj0m/PE7+lpdz4VeOLvmibrdvvDwaDiZ6RatrJvRG/+tWvDh48oKyc +DdYX79LWTngeAjASABDz7ZIJcpupYqU9eCDD5144omxHS7O08eepMXk8w8Z8uxS i/iTbG9v9/l8iZ5IShARd8yYMX0G3ddee+3KK6/QewYuLS19+OFHEj2LlHDxxT85 sh1Gj8SV9yWXXDJ7dvWRX+TGb0IcdUNYJOGk/zA0s6fROato7NgsbeTeiPr6+nnz rlZ5MdbaamlpaVFTDugHARiJMWHChMLCMcrKiUufurr6mA/v58ovOzu7oKBA70FC AW75Jop4i4oYfOzXt2/ffumlP9XvW7egYNSTTz6ZTL3cWhYKhS644AK325XoicRI JK7LLru8qqqq9ysij5Sy1HOi9d4Qttvt4v8D3d3JdI4QwVKE3sgq/Yl6vrd/p502 V2U7m93uaGxsVFYO6AcBGAkzY8Z0lfsMjRlT+Oqrr8Z2rEhuHR0d/byAG8LHw1O+ GtHnQm579+75wQ9+oMcMOXJkwYYNGzR1KZn0RD754Q9/2N7uTvREBk38/Pntb6+q qKiI/Cd7/GpN7w3h5EjCGZmHjTm0nnOa9nJvxPe//32V/5y9Xu/evfuUlQP6RwBG wqjfFWnZsuXnnXdebMf22Qh9rIyMDBEz2EC454Kms5NWZ605dqukpqbGs88+JxzW 0w4lhYWFjzzyKM/hqyeS5E9+cpGIKImeyCAEg6GFCxf07gWQlZ0tTjxZ3PjVpCOT sMPhCByii4Wjxak/knvFT6fe95WW32Mvvvji3Xffpawc+x5BawjASKTy8vLi4iJl 5YayInQ4HBY/vqN/vTgR5ufnp1oSJvdq37Bhw0aNGpWTk9P7lfb29u9859sulz66 W0tKSh566GE93rVODuKn6CWXXDyoH4YJlJ2dvXjxkshe7ukZGeIXIp9w41f7epNw 2j9vC0eSsHYWzRI/SCOhV/yv8J93etO0HXqPdMYZp6v8KWq12oxGo7JywIAIwEiw ysqpKrfYFbl0+/YPYju2o6NDpLvBHiVOkSIJR67AkpXX6+069BxXoieCaIlLHxGD I8uQph1KNT/60Y/27Nmt5V2+wuFwZWXV2rVrEz0RpP3617/+9NP9Gn+3lJSUXnXV VeKtLuaZk5tbVFQkkole8gl6HRmGxV+r3++3OxwiDIeCQZV5WLyR0nsib4b4f5F4 e394pukn9PY666yzQiF1f3Ti2unTT9UtNA1EQ7tnL6SOmppqlSvx/OAHFyxevDi2 Y61Wq4gKsR3b8+BZbq5Iwvo6Ux6PuPLwHBLzHwgSTlzRjR49uvcNef311z/99FPa XBZLvM2+8Y25Mf/LRdytXr361Vdf0eatePHT6aSTvvSDH/xA/Do7J6ekuJie56Rx VB6ONEuHjhAW/xvC88PiTD3s0KcmPf8n4m56+pjRo0XcPfLjHl2/l+65554XXtik rJz4xziUJUgBSQjASLyeTZFKS1UuxP/WW2/HtmCVOLmKDDz0OWQcasYTeVibYeN4 IqHX6/Vqpw8NQ3fk3eBt27b99re/0VqqObR9688uuODCRE8E/+LJJ5944IEHtPYw tni3XHzxJdXV1WJiJaWlOWzwm9SOzMNH6snGfr/T5QpHHPrSUa+JXHUMO6TnZ6B4 kxz69VEvS6b3T1dX17nnnqN236NWHv2FBhGAoQkTJ04cM2a0snJDeRi4vb29q6/T bcxE2BBJWFylHdlSpRGRfjPfIdzpTW7ifVhQUCDeh3a7/X//938dDq0sdCSuWlet WnXSSScleiLow44dO5YuXaqdVuicnNz58+f3POWelzeWx31T2/GycZ+SKeX2Q/Gj vw6Hs6GhQVk5IHqaOWsh5c2cOePIhXlkO+mkLz3wwAOxHTuURugBZWRkZP+T+htx gUCg+xASb2oaNmzYyJEj8/LyVq686c9//nPCOxSKiorvu+8+lcsEYLA6Ojouv/xy my0OrTFDEQwGv/zlL59//g8i0ZfHfYGjzJ8/v76+Tlk5cRWxZ89eZeWAQSEAQyvU N0I/9dTTlZWVMRwrrrRsNlvcp3Q84s9EXMZF9hXM+Kchjil+C4FDK2pG/r9bz5su QgaROVtaWi655JKOjvaETEC8M7/97e9cddVVCamOwbrzzjtfeGFTotqhRd0rr7xy 4qTJY8eOJfoCx/r8888vu+wXND8DEQRgaEhFRXlRkbpdkcQVdsxrM7jdbo/HE9/5 xCzyCFNksdPI6e3INHt4XRDyLQYvLy/v/vv/+MgjjyhuRhg+PP+2226bMmWKyqIY ooMHD86fP7+ra9BL5Q+F+DH+//7f/zv/ggu56wv047TT5qr8fMpmszU3s+8RtIsA DG2pqqqMbXmq2JSVlb344t9iO9ZisZAqkQr8fv+KFSu2b39fQUe0yDMXXHDBz372 c9mFIMkDD9z/5JNPKrjUDgaDkydP+fUVV5SXl/fsu070BY7jJz+5SOXe3Z2dnfv3 f6qsHBADAjA0R+WuSCLBrllz+9y5c2M4Vlypt7W1xX1KgDY1NjauXHnTwYMHJf3z FHmmpmbOtddeO3q0uvXwIIPT6bzhhhvq6mrlvVWKi4vnzV8wderUtJRZvgiIzRtv vHHTTTcqa35m3yPoAgEYmjNu3LiSkmKVP6xra2NcFsLlcnm93vjOB9Ayi6V19erV tbW1cbzFR/RNSjJicCAQmDhx0rz588vKysi9QDROP/00lTcVLBar2WxWUw6IGQEY WjR58qRRo0YpK5ebm/vOO+/GdiyN0EhB7e3tf/rTn1599RWv1xvz48HiH05GRuYp p5xyxRVXEH2TlYjB99xzz9tvvx0MBmL+WDMUCmVmZn796//5k4svHjFiBNEXiNJ3 v/sdv9+vrJzL5frss8+VlQNiRgCGRs2ePUvlJc7ll19+2WWXx3Bgd3e33a6VHVMB xZqbm++7797a2jqPpyvKmwyRD4wqK6suu+yyOXPmSJ4gtKK2tvYPf/jDp5/uTzu0 bl80hwSDways7Mqqyp9d+rMJEyeSe4FBefTRRx9//DFl5cTl0K5du5WVA4aCAAyN MvRsi1SirBE6FApt3/5BdnZ2DMc6nU6fzxf3KQE6Ii59tmzZ8sorrzQ0fN7R0SGi S2+PdGQRcpFkxo8f/5WvfOW73/2uysXeoTU2m+35559/7733mpqaurv9kRXsI98K BHruEufm5hoM48Rb5axvfWv48OFpPOULDJ74mfytb52lbAH/Q/seWVpaWtSUA4aI AAztmjBhfGFhocqKH330cWwH0ggNHMVoNO7evXvatKrx4yco3kUJOhIKhZqaGj/5 ZP+sWbNKSko6Ont2UYp89EnuBWJ25plnKLuFINjt9sbGJmXlgCEiAEPTZs6ckZOT o6zcaaed/rvf/S6GA/1+v8PhiPt8AAAABuXGG2986603lZXz+Xx79uxVVg4YOgIw NK2nD7q0VNmnmOFweOvWrUVFxTEcKwKwyqUmAAAAjmK3t1144YUqL5xaW1tbWlrV lAPiggAMrauoKFf5xOBQdkWiERoAACTQaafNjeM2dQOy2WzNzUZl5YC4IABDB6qq qvLzhysrN3v27MceezyGA2mEBgAAiXLllVfs379fWbnOzi6V5YB4IQBDH+bMqVG5 mOFTTz1dWVkZw7E0QgMAAPU+//zzyy77hcrtM2LumAMSiwAMfSgrKyspieXR3NgM pRG6tZUnYQAAgFKnn35alPuxx4XFYjWZTMrKAXFEAIZuTJkypaBgpLJykyZN3rhx YwwH0ggNAABUuvTSS43GZmXl3O72gwcPKisHxBcBGHpSXT1b2dIO4XD4wQcfOvHE E2M4lkZoAACgRn19/bx5Vytrfg4EAvX1u9TUAmQgAENPFO+KRCM0AADQOJXNz+x7 hCRAAIbOTJw4ccyY0crKlZSUbN68JYYDfT6f0+mM+3wAAAB6/fCHF9rtdmXlHA5n Q0ODsnKADARg6M+sWTOzs7PV1AqHw2vW3D537twYjqURGgAAyPPGG2/cdNONyjrj xFXN7t171NQC5CEAQ39ohAYAAKD5GYgBARi6NH58xdixY5WVKygoeO2112M4kEZo AAAgw3nnfa+zs1NZuba2tqYmdQtNA/IQgKFX06dPy8vLU1Zu2bLl5513XgwH0ggN AADi68UXX7z77ruUlfN4PPv2faKsHCAVARh6ZTCUlpSUpKenqylHIzQAANAIlc3P oVDIYrHQ/IykQQCGjpWXlxUXFysrl5ub984778RwII3QAAAgXr773e/6/T5l5axW q9FoUlYOkI0ADH2rrJw6YsQIZeWuuOLKSy+9NIYDaYQGAABD98QTTzz88EPKynV0 dHz66QFl5QAFCMDQvZqaapVdQDt31sZ2LI3QAABgiM4443SVz3/V1dWrqQUoQwCG 7o0bZygpKVG2K1JmZub27R/EcCCN0AAAYCjOOuusUCioplY4HLZYLGZzi5pygDIE YCSDyZMnjRo1Slm5iy666Oqr58VwII3QAAAgNn/4wx82bnxGWTmXy/XZZ58rKwco QwBGkpg9e1ZWVpaaWqFQaPv2D7Kzs2M4lkZoAAAwWN3d3d/61lnKmp9FuV27dqup BShGAEaSMBgMpaXqGqGFjz76OIajaIQGAACDdeaZZyi7yAmHw62tlpYWmp+RnAjA SB4TJ04cM2a0snJnn332ihXXx3AgjdAAACB6a9bc9vLLLysr53A4GxoalJUDFCMA I6nMmjUzts7kGITD4bfeejs/Pz+GY2mEBgAA0ejq6jr33HOU3f71+/27d+9RUwtI CAIwkkpPH3RpqcoeoY8/3hnDgeLs4nA44j4fAACQZM4444z0dJXNz60tLXxMj2RG AEaymTBhfGFhobJyp5566p13/j6GA2mEBgAA/bv22mvff/89ZeXsdntjY5OyckBC EICRhGbOnJGTk6OmVjgc3rp1a1FRcQzHWiwWcXjcpwQAAJKA3d524YUXKutr8/l8 e/bsVVMLSCACMJJQSUnJuHEGZSeMUCi0c2dtDAfSCA0AAI7n9NNPy8jIUFMrHA6b zS0Wi0VNOSCBCMBITuPHjx87Vl0j9CmnfG3t2rUxHOh0On0+X9znAwAAdG3p0qUf frhDWbm2NntTE83PSAkEYCStGTOm5+bmqqlFIzQAAIgXxc3PXq937959amoBCUcA RtJSvCJ0zI3Q3d3ddrs97vMBAAA6pbj5mZWfkVIIwEhmFRUVRUVjlZWjERoAAAyR 4uZnm62tublZWTkg4QjASHLTp0/Ly8tTU4tGaAAAMBSKm589Hs++fZ+oqQVoBAEY Sc5gKC0pKUlPT1dTjkZoAAAQM5XNz+KixWKx0PyMVEMARvIrLy8vLi5SVi7mRmiX y+X1euM+HwAAoAuKm5+tVpvRaFRWDtAIAjBSQlVVVX7+cDW1wuHwtm2vjR49OoZj aYQGACA1ud3u73//f5U1P3d2du3fv19NLUBTCMBIFXPm1Gi/EToQCLS1tcV9PgAA QOPOOON0lRcqtbV1amoBWkMARqooLy8rLo5learYnHrqqXfe+fsYDqQRGgCAVHPt tde+//57yspZrVaj0aSsHKApBGCkkMrKqSNGjFBTi0ZoAAAQDcXNzx0dHZ9+ekBN LUCDCMBILTU11SoXV6QRGgAA9E9l83MwGKyrq1dTC9AmAjBSS1nZuJKSEmXlvvGN uWvWrInhQBqhAQBIBTfccMPbb7+lrJzFYjGZzMrKARpEAEbKmTp1ysiRI9XUCofD b731dn5+fgzH0ggNAEBy6+rqOvfcc5Q1P7e3tx84cFBNLUCzCMBIRSoboUWI/fjj nTEc2N3dbbfb4z4fAACgETQ/A+oRgJGKxo0zlJSUKPvA9XvfO2/58uUxHOh0On0+ X9znAwAAEqi7u7uzq+u+e+/dtu0faiqGw2GLxWI2t6gpB2gZARgpavLkyaNGFaip Jc4677+/PTs7O4ZjaYQGACCZiPTrcDrNZvPCBfOVfRbvcrk/++wzNbUAjSMAI3VV V8/OzMxUU2vYsPQPP/wwhgNphAYAIGlE0m9rS8vVV1+dkaGo+TkQCNTX71JTC9A+ AjBSl8FgKC1V1wj9059eeuWVV8ZwII3QAAAkgcP3fk2mTZs2vfnmG2qKhsPh1lZL SwvNz8BhBGCkNJWN0DFvC5xGIzQAAHoWeejX7/OZTCZxQl+0aKGyta9ofgaOQgBG qlPZCJ2dnf3ee+/HcKDf73c4HHGfDwAAkC1y49dms/m8XvGfS5YsVlaa5mfgWARg pDrFjdBXXz3voosuiuFAEYBFDI77fAAAgDyHH/ptbQ10d4v/3LZt2+bNL6kpTfMz 0CcCMJA2ZcrkggIdNEKL02d8JwMAAOSJpN8WszkYDEa+orL52e12HzxI8zNwNAIw 0KO6ujozM0NNrREjRrzxxpsxHOj1el0uV9znAwAA4q4n/TockYd+I19ZvnxZIBBQ Uz0QCNbX16upBegLARjoMW6coaREXSP0ypWrzjrrrBgObGtrU3buBAAAMYgseeXz +UxGY+8Xd+zY8dRTf1UzARG5LRaL2UzzM9AHAjBwmMpG6GAwWFtbF9uxNEIDAKBZ kbZnq9Xq/9ctDBcuXJCRoajXjOZnoB8EYOALKhuhS0sNL70UyzIYnZ2dHR0dcZ8P AAAYosNLXrW0HNWudeONN3Z1daqZA83PQP8IwMAXVDZCh8Phxx57XETuGI612Wy9 y2kAAAAtiKRfs8kUCoWO/HpjY8O6deuUXV3Q/Az0jwAM/AuVjdCBQKCuLpbPaCOn t7jPBwAAxCDy0K/f5ztyyateCxbMz8zMVDMTmp+BARGAgaPV1FQre0pnxoyZTzzx RAwHtre3d3V1xX0+AABgUCI3fm02m8/rPfa7d9xxh8WiaPGOYDAY2wfrQEohAANH KysbV1JSoqZWOBz+29/+XlZWFsOxFovl2I+ZAQCAMocf+m1tDXR3H/tdu91+6623 KNtjQlwYmExmNbUA/SIAA32YOnXKyJEj1dQKhUI7d9bGcGAgEGhra4v7fAAAQDQi 6bfFbD7ewhwqm5/b29sPHDiophagawRgoG8qG6H/67/++4477ojhQKfT6fvXXRYA AIACkfTb89Dvvy551Wv9+vX793+iZjI0PwPRIwADfSsrKyspKVZTKxwOv/XW2/n5 +TEcy7bAAACoFFnyyufzmYzG473G6/WuWHGdwuZnq4jiamoBekcABo6rqqoytlAa k2EfffRRDId5PB632x332QAAgGP1v+RVr4ULF2ZkpKuZUmdn5/79n6qpBSQBAjDQ nzlzatLTFZ3ALrzwwoULF8VwINsCAwCgQP9LXvXauHHj+++/p2ZKoVCotrZOTS0g ORCAgf6Ul5cVFytqhI55NSy2BQYAQLZI+jWbzaGBPnRetGihsk/PrVar0UjzMzAI BGBgANOmVQ0fPlxNrezsnPfei+UzY7fb7fF44j4fAACQFkm/DkfPklcDbUC4dOkS ZZsUdnV1ffLJfjW1gKRBAAYGprIReuXKVWeddVYMB7ItMAAAcRfNkle9duzY8dRT f1UwqzSan4FYEYCBgVVUlBcVFampFQgE6+piOZ/5/X6HwxH3+QAAkLIibc9Wq9Uf 3aaDCxYsyMxUtIeizWZrbh44kwM4CgEYiMr06dPy8vLU1Bo/fvzzz2+K4UC73d7d 77IcAAAgSoeXvGppCQQC0bx+9eqbXS6X7FlFeDyeffsUbTIMJBkCMBAVg6FUULOh Xzgcfu655ydOnBjDsWwLDADA0EXSb4vZHOU+CxaL5fbb1yi7ThCn+5YWzvhALAjA QLTGjx8/dmyhmloxrwjd2dnZ0dER9/kAAJA6ol/yqteCBfMzMzOlzqpXW5u9qalJ TS0g+RCAgUGYOXNGTk6Omlr/9V//fccdd8RwIKthAQAQm0EtedVr/fr1+/crakgW c9uzZ6+aWkBSIgADg6C4Efr997dnZ2cP9kBWwwIAIAaRtmebzebzeqM/KhAILFt2 Dc3PgF4QgIHBmThx4pgxo9XUGjYs/cMPP4zhwLa2tihX7AAAAGm9S161tgYGuZzk woULMzIU7ZXocDgbGhrU1AKSFQEYGLTZs2dlZWWpqXXVVVddfPElMRzIalgAAERp sEte9frHP17dsmWLpFkdRUxy167damoBSYwADAyaykZocSaObZt7t9vt8XjiPh8A AJJMJP2aTaZQKDTYYxcuXJCRoWLjX5qfgXghAAOxmDJlckFBgZpaY8YUvvrqqzEc yE1gAAD6F8OCz71WrFjh8w3iaeGhcLvdBw9+pqYWkNwIwECMamqqlX3o+9hjj1dX Vw/2QK/X63K5ZEwJAAC9i23B516NjQ3r1q1T1g5WV1evoBCQCgjAQIzKysaVlJSo qRVzI7TVao2hoQsAgOQW24LPR1K58a/FYjGZzGpqAUmPAAzErrKycsSIfDW1Tjnl a2vXrh3sUSI5i7O7jPkAAKBTMS/43Ov++/948ODB+M7qeDo6Oj/99FM1tYBUQAAG hmTOnJr0dBWbH8S8LbDD4fD7/TKmBACA7hxe8LmlJRjrfoEqN/4NhUKxtYABOB4C MDAkFRXlRUVFamqJpL1jRyzbArMaFgAAaUNb8LnXokUL1Xz2LdhstubmWB5RBnA8 BGBgqKZPn56Xl6um1pIlS88///zBHtXe3t7V1SVjPgAA6MVQFnzu9dZbb73wwqY4 zqofHo933759amoBqYMADAyVLrYF5iYwACBlDXHB5yOx8S+gdwRgIA4mTBhfWFio plZFRcWmTS8M9qiurq729nYZ8wEAQMuGvuBzr5tvXuV2u+MyqwHZ7fbGxiY1tYCU QgAG4mP27FlZWVkKCoXD4eeee37ixImDPdBisQyl6QsAAN2JpF9xBuwe8nqQIvqu WrVSTcNXIBC02azc/gVkIAAD8WHo6YQu0XIjtM/nczqdMuYDAIAGDX27oyMpa34W rFabccjd2gD6RAAG4mby5MmjRhWoqXX22WevWHH9YI+y2WwiPMuYDwAAmjL07Y6O 9OKLL7755htDHycanZ2dLpfbYrGoKQekGgIwEE81NdVqPh4OhUI7d9YO9qhAINDW 1iZjPgAAaEdctjs6krKtj8SELRaryO0KagGpiQAMxFNZWVlJSbGaWjk5ue++++5g j7Lb7d3x6AQDAECbIunXZDTGa+WLa69druzU2dYmTtN+nv4F5CEAA3FWVVWVnz9c Ta116+49+eSTB3WIuBqgqwoAkKwim/0aTaa0OKVfo9F49913qVnjw+v1Onvatkm/ gEQEYCD+5sypUdMoFQgE6urqB3uUOLn6fD4Z8wEAIIFE+rU7HEPf7PdICxbMz8zM jOOAxxMOh61Wq8lkVlALSGUEYCD+xo+vGDt2rJpap5zytbVr1w72qNZWPl0GACQP EX07u7p8Pl980+8TT2yorR30ihuxcTqdXq+X27+AbARgQIqZM2fk5OQoKBQOh99/ f3t2dvagjnK73R6PR9KUAABQKfLQr9Vq9ce1vykYDC5dukRNS5f4LbS12Vn7ClCA AAxI0bMrcGmpmkeGsrKy33///cEexU1gAEASiO9mv0datuwaZXsHivRuNJrU1AJS HAEYkGXy5EmjRo1SU+u229bMnTt3UIe0t7d3dXVJmg8AAAocTr8tLYF4bPZ7pIaG hnvvXafmg+yOjg63u50lKgE1CMCARMq2BQ4Gg7W1dYM9ipvAAAD9iqTflpaWYLzT r7Bw4QI1Z3A2/gUUIwADEqncFvikk770wAMPDOqQjo6Ozs5OSfMBAECeSPo1m80h CV3Kjzzy8J49e+I+bJ/a2uzt7W6n06WmHAACMCDXtGlVw4er2BY4ttWwuAkMANCd w+nXZAqFQnEfXOXaVz6fz+FwsPIzoBIBGJBL5WpYGRkZH3ywY1CHcBMYAKAvkfRr MhrD4bCM8ZcuXRoOxz9XH4uNf4GEIAAD0k2YML6wsFBNrZUrV5111lmDOoSbwAAA vehJvw6HyWSSlH4PHDjwwAP3yxj5WC6Xy+PxcPsXUIwADKgwe/asrKwsBYUCgUBd Xf2gDmE5aACALkTSr9FkSpOTfoUFC+ZnZmZKGvxIgUDQZrOSfgH1CMCACioboU84 4YSHHnp4UIdwExgAoHGH06/RKK/E+vV/2r9/v7zxj2Sz2ZqbJf5eABwPARhQZMqU KQUFIxUUimE1LLfb7fF45E0JAIChEOnX7nCYZKZflWtfdXV1iTMvt3+BhCAAA+rM mVOj5syalZUlMvCgDuEmMABAmxSkX2HZsmXBYPz3Ez5WOBy2WCxmMxv/AolBAAbU KS8vLy4uUlNr3bp7Tz755Ohf73Q6fT6fvPkAADBYIvp2dnWJ05Ps9Gs0Gu+++y41 Tyo5HI6Ojo62NruCWgCORQAGlJoxY3pubq6CQsFgsLa2blCHcBMYAKAdke2ObDab z+uVXWv+/Hlq1qoUv6m2tjaan4EEIgADSqlcDevMM89cvfqW6F9vt9vFiVnefAAA iFIk/Voslm6/X3at55577t1335FdJcJqtRqNJjW1APSJAAyoNnnypFGjRikoFAqF du6sjf71wWDQZrPJmw8AANFQmX6FhQsXZGRkKCjU2dnpcrnF70tBLQDHQwAGEqCm plrNuXb06NH/+Me26F8vArCIwdKmAwDAABSn35Urb+ro6FBQKBQKWSzWlhbWvgIS jAAMJEB5eVlxcbGCQuFw+Lnnnp84cWKUr+9ZadPOshwAgMRQnH7dbveqVSvVPJck Tq+dnZ2sfQUkHAEYSAxlq2ENthFaXHaI2CxvPgAA9Elx+k3raX5emJGhYntC1r4C tIMADCSGytWwfv7zX/zqV7+K8sUej8ftdkudDwAAR1Gfft9+++1Nm55XU4u1rwDt IAADCTNp0qTRo1WshjXYLZHYDwkAoJL69CssWDA/MzNTQaGOjg63222xWBXUAjAg AjCQSMpWw5o4cdKzzz4b5Yvb29u7urqkzgcAgIjD6be1VeVWfHfd9Xuz2aygEGtf AVpDAAYSSeVqWG+99XZ+fn6Ur+cmMABAgUj6FSedgML0293tX758ubK1r9xut9Pp UlALQDQIwECCTZ8+PS9PxWpYGRkZH3ywI8oXOxwOv8I+NABACkrIvV9h6dKl4XBI QSHWvgI0iAAMJFhJScm4cQY1n0P/8Y/3/8d//Ec0rwwEAuKcLXs+AICUlZDnfgWT yXTXXb9XcNoNh8NWq02Uk10IwKAQgIHEmzRp4ujRoxUUGtRqWFarNRRS8QE5ACDV JCr9pqld+0rg9i+gNQRgQBOUrYZ10UUXXX31vGheyX5IAABJnC6XyWTyeb2K627b 9o/NmzcrKHRo7SsL6RfQIAIwoAnl5eXFxUUKCg3qJjBLYQEA4q67u9vucJiMRvWl FyxYkJmp4uNmh8PR0dHR1mZXUAvAoBCAAa2YOXNGTk6OgkJTp0596qmno3ml2+32 eDyy5wMASB0JTL9r165tbm5SUCgQCNhsNm7/AtpEAAa0wmAoFdQsy/H++9uzs7Oj eTE3gQEA8ZLA9BsMBq+5ZqmaJSetVqsoRwAGtIkADGjI1KlTRo4cqaCQSL/vvfd+ NK+02WziLC57PgCApNez8JXDYUxE+hWWL18WCAQUFPJ4POK3abFYFdQCEAMCMKAt c+bUpKenKyj06KOPVVdXD/gyn8/ndDoVzAcAkMQSm34tFsvtt69R02MlapnNLbIL AYgZARjQlvHjK8aOHaugUCgU2rmzNppX0gUNABiKxKZfYeHCBWq2WnC5XG63m7Wv AC0jAAOaM3v2rKysLAWFfv7zX/zqV78a8GUshQUAiFlky1+T0RgOhxMygbfffnvT pucVFAoGg1arraWF27+AphGAAc0x9ChVUCj6LZG4CQwAiMHh9GsyhUOhRM1B2e1f m80WCARY+wrQOAIwoEVVVZX5+fkKCp144r+vX79+wJexFBYAYLAi6ddsMoUSl34f fPDBTz7Zp6CQz+dra7NbLBYFtQAMBQEY0CKVWyJ9/PHOAV/m9XpdLpfsyQAAkkYk /baYzYn9/HTRooUKlpYUJ1Or1WoymWUXAjB0BGBAoyZOnDBmzBgFhQoLx77yyisD vowuaABAlCLpt7WlRc3OQ8ezevVql0vFRgbt7e2dnZ00PwO6QAAGtKumplrBY0vh cPitt94esOPa6XT6fD7ZkwEA6N3h9NvaGujuTug0/MuXL1fQSxUKhSwWC+kX0AsC MKBd5eVlxcXFCgqJmP3BBzv6f00gEGhra1MwGQCAfkXSrwiE3X5/YmdyzTXXhEIq uq8dDkdHRwdbHwF6QQAGNG3WrJnZ2dkKCj366GPV1dX9v0Zc0CRqEwsAgC44XS6T yeTzehM7DXHCuv32NQpu/wYCAZvNxu1fQEcIwICmGQylBoNBQaFQKLRzZ23/r+no 6Ojs7FQwGQCAHnV3d9sdDpPRmOiJpC1YsCAzk62PAPSBAAxonbItkRYuXHThhRf2 /xqWwgIA9Kmn+dnhMGog/X700Ud/+cufFRQ6tPVRm8ViVVALQLwQgAGtU7YlUjAY rK2t6/81bAgMADhW5NFfk9GohSdlFi5coGYJSbY+AvSIAAzowKRJE0ePHq2g0Jln nrl69S39vIANgQEAR4mkX7PZHNLAJ6TPPrvxvffeU1Co4xCanwHdIQAD+qBmS6Ro ngSmCxoA0EsjW/72Unb7V5wNSb+AHhGAAX2oqCgvKipSUGjy5CnPPPNMPy9gQ2AA QIR2Nj2KWLv2nubmZgWFHA6nyyXOh7REAfpDAAZ0Q82WSOFw+OOPd/bzAjYEBgBE aGTTo16LFi1MT0+XXSUYDFqtVm7/AjpFAAZ0w9CjVEGhESNGvvHGG/28gC5oAIB2 ln2OuPHGG7u6VOzVZ7O1BQLdBGBApwjAgJ5Mm1Y1fPhw2VXC4fBbb73dz95Lbrfb 4/HIngYAQLM0texzWs98/MuXL1ewY4Lf77fZbGx9BOgXARjQE2VbImVmZm3fvv14 3w2FQlYr534ASFGHl302mcTpINFzOWzZsmXBoIpVuET0DYWC3P4F9IsADOjMlCmT CwoKZFcJh8PPPff8xIkTj/cCi8WikU/9AQAqRdJvS0tLUBvLPqcd6ktatWqlgk+H u7q6RC3SL6BrBGBAf+bMqVGwyIeItx9//PHxvtvR0dHZqeJRKwCApjhdLqPR6NfS dgBLlixWUOXQ1kcWkfwV1AIgDwEY0J8JEyYUFo5RUGj9+gdPPPHEPr8lrgMsFouC OQAAtKO7u9vucJg0s/CVYDabf//7OxXc/nW72+32NrY+AvSOAAzoUk1NdUZGhuwq wWCwtrbueN+1Wq3aefoLACCb1pZ9jliwYEFmpvQTojjfWSxWbv8CSYAADOhSRUV5 UVGRgkIrVlx/9tln9/mtzs7Ojo4OBXMAACTc4WWfTaawlj763L1796OPPqKgkMPh 9Pm8PP0LJAECMKBXs2fPysrKkl2l/5vAbAgMAKlAgwtfRcyfP0/NqdBqtZJ+geRA AAb0aty4nj2RFBT66U8vvfLKK/v8Fl3QAJAKNLjwlfD666/9/e9/V1Cora2tu7ub AAwkBwIwoGPTp0/Py8uVXSUQCNbV9X0T2OPxuN1u2RMAACSQBhe+iliwYH5mZqbs KuK3b7VaLRar7EIA1CAAAzpm6LkHXKpg6cszzzxz9epb+vwWXdAAkMQOP/prNGpt 7/eNGze+//57CgqJ9BsMBrn9CyQNAjCgb5WVU0eMGCG7Sj9PAttsNvFd2RMAAKgX Sb9mszmkvZ/zam7/er1eZ8/Dz6RfIHkQgAHdO+GEOQpuAp9yytfWrl177NfpggaA ZKXNR3+FDRs21NXVyq4S2fHebGbrIyCpEIAB3Zs0aeLo0aNlVwmFQjt39n21QRc0 ACQfbe76G7Fw4YKMDOl7/3Z2dra3t3P7F0gyBGAgGcyZU5Oeni67ykknfemBBx44 9ut0QQNAktHso7/Cww8/vHfvHtlVxG+8tbWV9AskHwIwkAwmTJhQWDhGdpXj3QTu 6upqb2+XXR0AoIaWH/1NU3X71+1u7+rqJAADyYcADCSJmppqBRcEJ5747+vXrz/2 63RBA0DS0Oyjv4I4B+3f/4nsKodu/1paWnj6F0hCBGAgSYwfXzF27FjZVY53E9hq tYpvya4OAJBNy4/+pqm6/etyuTweD7d/gaREAAaSR3X1bAV7QlRXVz/66GNHfbGz s7Ojo0N2aQCAVFp+9Fd44IH7Dxw4ILtKKBSyWCykXyBZEYCB5FFeXl5cXCS7yvFu AtMFDQC6Fkm/rS0tgUAg0XPpm5rbvw6Hw+fzEYCBZEUABpLK7NmzsrKyZFeZMWPm E088cdQXLRaLNu8YAACi4XS5TCaTz+tN9ET69oc/3Pf555/LrhIMBq1WK+kXSGIE YCCplJWNKykpkV2lz5vAHR0dnZ2dsksDAGSI3P7tefRXkx9livPO4sWLFNz+tdvt fr+fAAwkMQIwkGxmzpyRk5Mju8qxN4HD4bDFYpFdFwAQd5H022I2a3ZTdzW3fwOB oMXSarFYZRcCkEAEYCDZGAylBoNBdpU+bwLTBQ0AeqTx5mdxxlmyZHF6errsQjab LRAIcPsXSG4EYCAJzZgxPTc3V3aVyZOnPPPMM0d+pb29vaurS3ZdAEAcHW5+bm5O 9ESO65577jEapU9P/Dm0tbWRfoGkRwAGkpDBUCoMGyb3H/ixN4GDwaDNZpNaFAAQ R5H0azabQ1ptflb29K/VagsGuf0LJD8CMJCcpk+flpeXJ7vKCSec8NBDDx/5FTZD AgAd0Xjzs7B+/Z/2798vu4rf77fb7aRfIBUQgIHklKibwE6n0+fzSS0KAIgL7Tc/ K7z9aw0GgwRgIBUQgIGkNW1a1fDhw2VX+frXv3733ff0/qe4nLLb7bKLAgCGSPsr PwuPP/5YfX297Crc/gVSCgEYSFpqbgKLK6fa2rojv0IXNABon/abn8X5ZcmSxdz+ BRBfBGAgmam5CXz22WevWHF973/a7fbu7m7ZRQEAMdN+87Pw/PPPvfPOO7Kr+P3+ 3bv3yK4CQDsIwEAyKykpGTfOIPsmcCAQrKv74iaw1+t1uVxSKwIAYna4+bmlJRgI JHouxxUMBhcvXpSZmSm7kMViDYW4/QukEAIwkOSqqirz8/NlV7n44kuuuuqq3v+k CxoANMvpcpnNZq/Hk+iJ9Gfr1q2vvLJVdhWfz7dnz17ZVQBoCgEYSHIJeRLYZrNp eVUVAEhZkdu/JqMxHA4nei7Hxe1fAPIQgIHkp+Ym8NVXz7vooosiv+7q6mpvb5dd EQAwWE6Xy2g0+rW9X92777773HPPyq7C7V8gNRGAgeSXkJvAdEEDgNb03P51OEQA TvRE+hMKhRYtWqjm9q/JZJJdBYDWEICBlFBZWTlihPSbwCtXrjrrrLMiv7ZYLFru rwOAVBNpfjabzSFtP6JSX1//+OOPya7C7V8gZRGAgZSg5iZwKBTaubM28uv29vau ri6p5QAA0dP+xr9ph84jixcvUrD3r8ViMZnMsqsA0CACMJAq1NwEfvTRx6qrq9MO dUTbbDbZ5QAA0dDF2ldCU1PTunVrZVfh9i+QygjAQKpQcxNY+OijjyO/4DFgANAI Xax9FQqFli5douA8ZbFYRC0WfwZSEwEYSCHTplUNHz5caolwOLxt22ujR48Wv3Y4 HH6/X2o5AMCAIrd/jc3NiZ7IANxu96pVK2UHYHFi2r17j9QSALSMAAykEDU3gXNz c9955920Qz1mTqdTai0AQP8i6bfFbNb49uyhUOjGG2/0ej2yC1mtVqORxZ+B1EUA BlLL9OnT8vLypJYIh8Mff7wz8mu6oAEgsZwul9ls9nqkB8sh6u72L1++XPZHtN3d 3bt27ZZaAoDGEYCB1GIwlBoMBtlVKioqNm16QfzCZrNp/J4DACSxw1sfmUyhUCjR cxnA7bffbrVaZFexWm0a3wYZgGwEYCDlzJgxPTc3V2qJ3v2Qurq62tvbpdYCAByP LrY+Sjt0+/eaa66RvftRIBCor98ltQQA7SMAAylHzU3gU0899c47f59GFzQAJIhe tj4SNmzYUFdXK7uKzWZrbub2L5DqCMBAKpo5c0ZOTo7UEsFgsLa2Lu3QbhPav/YC gOSji62P0g7dmF2yZHFmZqbUKuKsZLVa2foIAAEYSEXjxo0rLS2RXeXyyy+/7LLL 3W63R/OLrwBAktHL1kfCtm3bNm9+SXaVtra2piYd/GkAkI0ADKSoWbNmZmdnSy0R uQkcCATEZYfUQgCAo3D790jc/gXQiwAMpKiysrKSkmLZVdatu/fkk0/mMWAAUElH t3/37dv30EMPyq5it9sbG5tkVwGgCwRgIHXNnj0rKytLaonIctDiykNcjUktBADo 1XP7t7nZ7/cneiIDEOeIpUuXyN77V1SxWCzc/gUQQQAGUldFRXlRUZHUEuFweNu2 13Jzc10ul9RCAIAIHd3+dTgct9yyWnYAdjicDQ0NUksA0BECMJDSamqqZe+7mJ8/ 4s0336QLGgDUcLpczc3N3Xq4/bty5U1dXV1Sq4TDYbO5xWKxSK0CQEcIwEBKmzBh fGFhodQS4uLj4493Wq1Wca0jtRAAQEe3f71e73XXXZueni61Snt7+4EDB6WWAKAv BGAg1c2ZUyP7+uOrX/3q7353W2dnp9QqAAC93P4VHn744b1790gtEQ6HW1stLS0t UqsA0BcCMJDqpkyZXFBQILVEIBDcubPnJrDUKgCQ4nR0+7e727906VLZux91dXV9 8sl+qSUA6A4BGEDaCSfMkb0GybJly7/+9a9LLQEAKU5Ht3/fe+/dZ599VnaV1tZW s5nbvwD+BQEYQFpVVWV+fr7UEqFQ6LXXXvf5fFKrAEDK0tHtX3FGWLx4kewlGMUZ Z8+evVJLANAjAjCANIOhVJB9E3jz5i3hcFhqCQBIWTq6/Wu322+99RbZJx2r1Wo0 mqSWAKBHBGAAPWbMmJ6bmyu1xPDhw595ZqPUEgCQmvR1+/fGG2/wer1SqwQCgfr6 XVJLANApAjCAHoYepVJLhMPhrVtfCQaDUqsAQArS0e1fj8ezYsV1sncfsNnamvXw cQAA9QjAAA6bPXtWVlaW5BLVa9askVoCAFKNjm7/CuvX/2n/frkrMweDwbq6eqkl AOgXARjAYeXlZcXFxVJLiIuSl1/eKrUEAKQap8tlNBr9elhl0OfzLVt2jezdjxwO R0NDo9QSAPSLAAzgCzU11bKX5bz88l+ec845UksAQOo4fPvXaEzTwyqDb7755osv viC1RDgcNpvNFgs7zwPoGwEYwBcmTpwwZswYqSVCodCWLS9LLQEAqcPpcplMJp/k NaXiIhAIXHPNUtlP/7a3tx84cFBqCQC6RgAG8C9OOGGO1K0pwuHwCy+8KPthYwBI BZHbvyajURebzLlczptvvln2Kaa1tbWlpVVeCQB6RwAG8C8qKytHjMiXWmLMmDFP PPGk1BIAkAqcLpfZbPZ6PImeSFRuvfVWh8MutYTP59uzZ6/UEgD0jgAM4F8YDKUG g0FqCbqgAWDoIrd/zSaT+KGa6LkMzOv1XnvtctnLTFitVqPRJLUEAL0jAAM42syZ M3JycqSW+OlPLz3//POllgCA5Kav27/btm3bvPklqSUCgWB9PbsfARgAARjA0crK ykpK2A8JADRNBODm5uZuvz/RExlYKBRavHiR7Nu/dru9sbFJagkASYAADKAPsvdD CofDGzc+O3z4cHklACCJHd79qLk50ROJioimt956C8tfAdACAjCAPkyYMKGwUO5+ SKNGjfrzn/8itQQAJCuny2U0Gv0+X6InEpVbblntdDqllmD3IwBRIgAD6Jvs/ZBY CgsAYqOv3Y88Hs91110ru6uotdXS0tIirwSApEEABtC3ysqpI0aMkFriRz/68UUX XSS1BAAkH6fLZTKbfTpZ/mrr1q2vvCJ30Qev17t37z6pJQAkDQIwgL6VlJSMG2eQ ehM4EAiI6yJ54wNAUhIBuKmxUfwITfREBhYKhRYtWpSZKXf5K4vFajKx+xGAqBCA ARyX7P2QWAoLAAZLX8tftbW1/e53t8r+LLW+fpe88QEkGQIwgONSsB9SQUHBX/7y V6klACCZ6Gj3I2HVqlXt7W6pJdj9CMCgEIAB9Ef2fkgshQUA0Tt8+9doTNPD8ldd XV0rVlwnf/krdj8CMAgEYAD9mTx50qhRo6SWuPzyX55zzjlSSwBAcuhZ/spk8nm9 iZ5IVF5//bW///3vUkt0dnbu3/+p1BIAkgwBGEB/DIZSgf2QAEAL9LX81ZIli9PT 06VWaW21mM1mqSUAJBkCMIABzJgxPTc3V9744XB48+Yt8sYHgOSgr+Wv3G73qlUr Wf4KgNYQgAEMQMFSWFVVVXfffY/UEgCgd06XS6Rfv06Wv7rvvnsbGhqklmD5KwAx IAADGJjspbCCweDLL2+VNz4A6F3k9q/JaAzrYfkrn8+3bNk1mZmZ8kqw/BWA2BCA AQxssvylsO677w+TJk2SWgIA9MvpcpnNZq/Hk+iJROXAgQMPPHC/1BIsfwUgNgRg AFE54YQ5Uh/lys7Oef755+WNDwC61rP8VVNToLs70ROJyooVK3w+uUtVt7a2ms0t UksASEoEYABRkb0UFmtBA8Dx6Gv5q46OjhtuuF7qgzMsfwUgZgRgAFEpKxtXUlIi tQQbAgNAn/S1/e+2bds2b35JagmWvwIQMwIwgGjJXgqLm8AA0CcRgBsbG4M62f53 6dIlUh+ZYfkrAENBAAYQrcmSl8JiQ2AAOJa++p9dLufNN98sNQCz/BWAoSAAA4iW wVAqSL2s+dKXvnTTTSvljQ8AutOz/a/R6Pf5Ej2RqDz88MN79+6RWoLlrwAMBQEY wCDMnDkjJydH3vhsCAwAR9LX9r9itkuXLpG6/W8gEKyvr5c3PoCkRwAGMAjl5eXF xUXyxhdXeC+88GJWVpa8EgCgI/ra/tdisdx++xqpjUIOh7OhoUHe+ACSHgEYwODM mVOTnp4ub/yysvL169fLGx8AdKSn/7m52e/3J3oiUbnjjjssFolrU4XDYbO5RcRs eSUAJD0CMIDBqaysHDEiX974gUBg69ZX5I0PAHqhr/5nr9e7fPkyqf3PosTevfvk jQ8gFRCAAQyOwVBqMBikltiwYUNh4VipJQBA+/TV/9zY2LBu3Tqp/c9Wq81oNMob H0AqIAADGLTq6tlSP+MfObLgr3/9q7zxAUAXRABubm7u1kn/86pVK9vb2+WNHwqF amvr5I0PIEUQgAEM2qRJE0ePHi1vfNaCBgB99T93dnZef/2KjIwMeSU6Ojo+/fSA vPEBpAgCMIBBU7Ah8D33rK2srJQ3PgBonL76n/fu3fvwww9JLcH2vwDiggAMIBaz Zs3Mzs6WN35ubt6zzz4rb3wA0Dh99T/fcMP1HplZPRgM1tWx/S+AOCAAA4hFRUVF UZHEdaroggaQynTX/7xixXVS14ZwOl2ff/65vPEBpA4CMIAYnXDCHKld0Hfe+fsZ M2bIGx8ANEtf/c+7d+9+9NFH5I0fDodbW1tbWiTuMAwgdRCAAcRo+vRpeXl58sbP ycl97rnn5I0PAJqlr/7nFStW+HxeeeN3d3fv2rVb3vgAUgoBGECMysrKSkqK5Y1P FzSAlCUCcGNDg/gxmOiJDEzB+s92u72xsUne+ABSCgEYQOzmzKlJT0+XNz5d0ABS UOQBYGNzc6InEpX6+vrHH39M3vj0PwOILwIwgNhNm1Y1fPhweeOzFjSAFOR0uYxG o9/nS/REonL99Su8Xon9zz6fb8+evfLGB5BqCMAAYjduXM+OwPLGpwsaQArq6X9u bAwGAomeyMAU9D/bbG3NOrkZDkAXCMAAhkR2F/SGDRsKCyXutwQAmqKv/ucDBw48 8MD98sYPh8M7d9bKGx9ACiIAAxiSysqpI0aMkDd+YWHhhg1PyBsfADTF6XKZTCaf zKbiOLrlllucToe88b1e7969++SNDyAFEYABDInBUGowGOSNHwgEtm59Rd74AKAp IgA3NTUFursTPZGBeTyea69dnpmZKa+E1WozGo3yxgeQggjAAIaqpqZa6gNgmza9 kJWVJW98ANAIffU/m0ymu+76/bBhsi4m6X8GIAMBGMBQTZ06deRIiV3QEydO+sMf /iBvfADQCKfLZTabvR5PoicSlbvvvktkYHnjezyeffs+kTc+gNREAAYwVIYerAUN AEMlAnBzc3O335/oiQzM5/MtW3YN/c8AdIcADCAOpHZBh8PhzZu3SBocALSjZwOk hoZgMJjoiQzMZrPedttt9D8D0B0CMIA4kL0W9Le//Z0rrrhC3vgAkHD6egD46aef /uCD7fLGp/8ZgCQEYABxIHst6FAovGULN4EBJDOny2U0Gv0+X6InMrBQKLR06RJ5 t3/T6H8GIA0BGEB8zJlTk56eLmlwcbG1ZcvLkgYHAC3o2QCpsTEQCCR6IgNzOByr V98s72c+/c8A5CEAA4iPqqqq/Pzh8sZfuXLVSSedJG98AEggffU/b9++/ZlnnpY3 vs/n27Nnr7zxAaQyAjCA+CgrG1dSUiJv/Ly8vI0bn5U3PgAkkL42QFqxYoXP55U3 fltbW1OTPj4LAKA7BGAAcXPCCXPkPRLGZkgAkpiONkDq7Oy8/voVUlf+b21tbWlp lTQ+gBRHAAYQN9OnT8/Ly5U3/qZNL2RlZckbHwASRUcbIImgfs89d8v7uNPv9+/e vUfS4ABAAAYQNxUV5UVFRfLGnzPnhFtvvVXe+ACQEPp6APj+++8/ePCAvPEdDkdD Q6O88QGkOAIwgHiS2gXNWtAAkpLT5TKZTD6vxKdq40Vk9WuuWUr/MwD9IgADiKdZ s2ZmZ2dLGlxcGG3ezG7AAJKNjh4Abmtru/XWW+RtgBQMBuvq6iUNDgBpBGAA8TVx 4sQxY0bLG//662/4yle+Im98AFBPRw8Av/3225s2PS9v/Pb29gMHDsobHwAIwADi yWAoNRgM8sZnMyQASUZfDwDL3gCptbXVbG6RNz4AEIABxFlNTbW8x8MCgcDWra9I GhwA1NPRA8CdnZ0rVlyXmZkpafxQKFRbWydpcACIIAADiLPKyqkjRoyQNDiPAQNI Mj0PADc1dXd3J3oiAxNB/a67fi9vpUOPx7Nv3yeSBgeACAIwgDgbN85QWloqb/xv f/s7V1xxhbzxAUCZSP+zyWgMh8OJnsvA/vrXv3744Q5549tsbc06aQUHoF8EYADx J3UzJOGllzbLGxwAlHG6XGaz2evxJHoiAwuFQkuXLpH3s50NkACoQQAGEH8zZ87I ycmRNDi7AQNIGjp6ANjtdt90043ylnjo7u7etWu3pMEBoBcBGED8TZgwvrCwUN74 zzyzcfjw4fLGBwA1RABuamoK6OEB4IMHD95//x/lje9yuT777HN54wNABAEYgBT/ 9m8nyBt89uzZa9bcLm98AFBDBOCGhoaQHnYAvvfedY2NjfLGb+lB/zMA6QjAAKSQ uhkSXdAAkoCOdgAWU73mmqVSf6qzARIANQjAAKSoqqrMz8+XNDgBGEAS0NEDwHa7 ffXqm+UFYDZAAqAMARiAFGVlZSUlxfLG/8tf/lpQUCBvfACQrWcH4Obmbr8/0RMZ 2CeffPLgg+vljd/WZm9qapI3PgD0IgADkEXqZkhVVVV3332PpMEBQAERgBsbGoJ6 eAD4nnvuNhqNkgZnAyQAKhGAAcgye/asrKwsSYPTBQ1A13T0ALDf77/mmmsyM2X1 PweDwbq6ekmDA8BRCMAAZJkyZbK8LmUCMABdc7pcZrPZ6/EkeiIDa2tru/XWW9LT 0yWN39nZuX//p5IGB4CjEIAByGLoUSpvfHYDBqBfOnoAeP/+/evX/0ne+FarTV5/ NQAchQAMQCKpjwFXV9fcdtttkgYHAKlEAG5qbAwEAomeyMDuu+/ehoYGSYOHw+Gd O2slDQ4AxyIAA5Bo1qyZ2dnZkgYPhcJbtmyRNDgAyKOjB4DFVJctu0Ze/3MgEKiv 3yVpcAA4FgEYgESTJ08aNWqUpMGDweDLL2+VNDgAyKOjB4CdTueqVSvl7QDc3t5x 4MABSYMDwLEIwAAkMhhKDQaDvPFfemmzvMEBQBIRgE0mk8/rTfREBtbY2LBu3Tp5 D7NYrVaj0SRpcAA4FgEYgFzV1bMzMzMlDX7JJZdccMGFkgYHAEl0tALWhg0b6upk PaPLA8AA1CMAA5CrqqoqP1/WWs2FhWPFxZmkwQFAEhGAGxsagsFgoicysBtvvLGr q1PS4J2dXfv375c0OAD0iQAMQK4JE8YXFhZKGpzdgAHojo5WwBIWLlwg7wFgu93e 2NgkaXAA6BMBGIBcUh8DZh0sALqjoxWw0iQH4JYerZIGB4A+EYABSFdTUy3v+unB Bx8aN26cpMEBIO5EADYajX6fL9ETGVhbW9ttt/1O0uDBYLCurl7S4ABwPARgANJN nz4tLy9P0uBf+cpXr7/+ekmDA0DciQDc1NQU6O5O9EQGtn79+v37P5E0uMfj2bdP 1uAAcDwEYADSTZw4YcyYMZIGz87Ofv75TZIGB4C409EKWEuXLgmHw5IGdzgcDQ2N kgYHgOMhAAOQjseAASCCFbB68QAwgIQgAANQYc6cmvT0dBkjh8PhzZu3yBgZAOJO XytgLV68aNgwKdeKoVCotrZOxsgA0D8CMAAVZs6ckZOTI2nw+fPnn3ba6ZIGB4A4 0tEKWB98sP3pp5+WNLjP59uzZ6+kwQGgHwRgACpMmTKloGCkpMErKioeeOBPkgYH gDjS0QpYt956i8PhkDS4291+8OBBSYMDQD8IwABUqKgoLyoqkjf+Sy9tljc4AMSL jlbAkvoAsM1ma242ShocAPpBAAaggsFQKkh6lox1sADoAitgRYTD4dbWVlbAApAQ BGAAilRXz87MzJQxsriW2rjx2eHDh8sYHADiRUcrYHm93hUrrpP0qWUgEKiv3yVj ZAAYEAEYgCLTp0/7/+3dCXhc1Z3nfbtUUmnfLFuyFkveZBskGQbm9fA8k6GhJ29C JzTwkicDTYcw0CymQxMClhcWY4LZwhoYzBIIAdNmCLRpHMCyTYCkJ3l4GzpYkjd5 U0lVWmxZVdpVVbeq5qgKC2FslSzVv+6tut/PkyiyLX73GEd1z8/n1jlpaWlC4Rdd 9De33nqrUDgARIUqwG1tbZ7hYb0HEtlbb/32888/FwofGhrat69JKBwAxkcBBhAj FRXlubm5QuF5eXmbNr0hFA4AUaEKsMPh8Hm9eg8ksvvuu29oaFAo3O12NzfbhcIB YHwUYAAxUlw8e9asWULhgUBg27btQuEAEBUjO2C1tPg1Te+BRCa6A9aRI0fa2tqF wgFgfBRgALGzdGkN+2ABMCd2wAoLBoM7d9ZLJAPARFCAAcROdXWV3IzqvffeF9pk CwCmLo52wPL7/XfeuUbu7ysbGholkgFgIijAAGJnwYL5mZmZQuHXXHPNFVdcKRQO AFM0sgNWe7snHgrwhx/uUITC+/v7Dxw4KBQOABFRgAHETllZ2YwZ+ULhJSWlL730 klA4AExRHO2A9cgjj7hc3ULhx451t7a2CoUDQEQUYACxUzSiUCh8+vTpH3ywVSgc AKZIFWBV/DSfT++BRLZyZa3FYhEK7+jo7OjoEAoHgIgowABiqqamWmhexT5YAIxs ZAtou129Uuk9kMjkdsAKBAL19Q0SyQAwQRRgADFVVXWm0FZVwWCwrm6bRDIATFF8 bQG9atVKoR2wNE1rbNwlkQwAE0QBBhBTCxcuyMjIEApft+6+ZcuWCYUDwKTF0RbQ u3fvfu21V4XCBwYG9u8/IBQOABNBAQYQU+Xlc/Ly8oTClyxZ8sQTTwqFA8CkjWwB 3dbmGR7WeyCRPfPM006nUyjc5XLZ7S1C4QAwERRgADE1e3ZRYaHUPlgpKSnvvrtF KBwAJk0VYKfD4Y2HLaDvvHNNIBAQCu/s7GxvZwcsAHqiAAOItaVLa+TeXbZjx4cS yQAwFSNbQLe0qNcovQcS2YoVd8jt1LBzZ71EMgBMHAUYQKzJ7YMVCAS2bdsukQwA UxFHW0DLnYHEDlgAjIACDCDWKisXpqenC4X/9rdvZWVlCYUDwCTE0RbQg4ODP//5 fXLhTU37hcIBYIIowABiraKiPDc3Vyj8hz/8H9dee61QOABMQhxtAf3ee+/927/9 USjc7XY3N9uFwgFggijAAGKtpKR45syZYuGlL730klA4AExCHG0B/cgjj7hc3ULh R48edTrbhMIBYIIowABirWhkH+hCoX2wkpKS3nvvfYlkAJgcVYAdDocvHraAXr16 lVByMBjs7Ozs6OgUygeACaIAA9BBdXWVaqoSyWwEDcBoRraAbm3VfD69BxKZ3BbQ fr+/oaFRIhkATgsFGIAOlixZbLPZJJLZCBqA0bAFtOLxePbs2SuRDACnhQIMQAfz 58/PysoUCmcjaACGogqwvbk5EAjoPZAIRLeA7uvrP3jwoFA4AEwcBRiADubMmZOf nycUzkbQAIwjjs5AEt0Curvb1dLSIhQOABNHAQagg+Li2bNmzRIKZyNoAMYRR2cg iW4BfeTIkba2dqFwAJg4CjAAfSxdWsNG0AASnirATqfT6/HoPZDIRLeA3rmzXigc AE4LBRiAPtgIGoAZxNEZSGwBDcAMKMAA9MFG0ADMYOQMpJYWTdP0HkhkbAENwAwo wAD0sWDB/MxMqY2g//Vf3xVq1wBwWuLlDCSfz3vPPfcIhff39x84wBbQAAyBAgxA H+Xlc/LypDaCvv766y+//AdC4QAwQXG0BfTHH39cV7dVKNzlctntbAENwBAowAD0 IboR9JIlS5544kmhcACYoDjaAvqZZ552Op1C4WwBDcA4KMAAdCO3EXRGRsbbb/+L RDIATFwcFeB77rnb5/NJJLMFNABDoQAD0I3cRtDB4LS6ujqJZACYuDg6A6m2tjYp SWQHLLaABmAoFGAAupHbCJqTkAAYAWcgTWMLaAAGQwEGoJuFCxdkZGRIJHMSEgAj GDkDqbVVk3m0OLrkzkAaGBjYv/+ARDIATAIFGIBu5s6tyMnJEQrnJCQAuuMMJKWn p+fw4WahcAA4XRRgALopLS0tKJghFH7jjTdddtllQuEAMBGqANubmwOBgN4DieAP f/jDBx+8LxTe1XXMEQ8HQQEwCQowAN0UjSgUCq+qqn700UeFwgEgojg6BPjZZ59t bZU6p7ejo7Ojo0MoHABOFwUYgJ7kTkLKzMx86623JZIBYCLi6AyktWvv8crs1MUZ SACMhgIMQE+SJyEF6+q2SSQDwESoAtzW1uYZHtZ7IJHV1q4QeinmDCQARkMBBqAn TkICkKji6BBgzkACYB4UYAB64iQkAIkqjg4B5gwkAOZBAQagp7liJyHxCDQAfY0c AtzSomma3gOJbNWqlULbMXAGEgCjoQAD0JPoSUhr19573nnnCYUDwPji5RDgXbsa N27cKBTOGUgAjIYCDEBPoichnX/+X61evVooHADGFy+HAKv2qzqwUDhnIAEwGgow AJ3JnYRUXFz88su/lkgGgPHF0SHADz/8kNvtlkjmDCQABkQBBqAzuZOQkpNTtmzZ IpEMAOOLo0OA16xZEwyKLFNzBhIAA6IAA9BZVdWZQsdvsBE0AL2MHALc3u6JhwIs dwiwpmmNjbskkgFg0ijAAHS2aFFlWlqaRDJHAQPQC4cAK0NDQ/v2NUkkA8CkUYAB 6Gz+/HlZWVkSyawAA9ALhwArfX19Bw8ekkgGgEmjAAPQWXl5eV5erkQyRwED0MvI IcCtrZrPp/dAIpM7BNjlctvtdolkAJg0CjAAnZWWlhQUFAiFP/jgQ2effbZQOACc SrwcAtzU1PTrX78sFN7V1eVwOIXCAWByKMAAdFZUVFhUVCQU/u1vf/v22+8QCgeA U4mXQ4D/9/9+44svvhAK7xjRKRQOAJNDAQagP7mjgEtKSl966SWJZAA4lTg6BPiR Rx52uVwSyRwCDMCYKMAA9Cd3FLDNZvvXf31XIhkATiWODgG+8841QsvUHAIMwJgo wAD0J1eAA4Hgtm3sgwUgpuKoAK9YscJqFXn5pQADMCYKMAD9yR0FrGZg27fvkEgG gFNRBbitrc0zPKz3QCKrrV0h9PePHAIMwJgowAD0N3/+/KysTIlkCjCA2FMF2Olw eOPhEGC5AtzX13/w4EGJZACYCgowAP1VVJTn5nIUMIAEoQqww+HwxUMBljsE2O12 NzdzCDAAw6EAA9BfWVnpjBkzhMK3bq0TSgaAk1IFuLWlRdM0vQcS2erVq4SSjx07 1toaB/tgAzAbCjAA/RUXz541a5ZQ+Lp19y1btkwoHAC+SRXgFrvd7/frPZAIdu/e /dprrwqFHzlypK2tXSgcACaNAgxAf0VFhUVFRULhF130N7feeqtQOAB8kyrAdrs9 YPgC/NZbv/3888+FwjtGdAqFA8CkUYABGMLSpTVC70NbuHDh008/I5EMACc1UoCb m4XO142ip556UpVUieRgMLhzZ71EMgBMEQUYgCHIHQWcnZ3z5ptvSiQDwDf5fD6X 2+10xMHbX++9916PR+SsJg4BBmBYFGAAhiBXgFXse++9L5EMAN/k7ulpb28fHhrS eyCRye2ARQEGYFgUYACGsHjxotTUVInkQCCwbdt2iWQA+KY4KsArVtxhtVolkoeH h/fu3SeRDABTRAEGYAgLFy7IyMiQSNY0bceODyWSAeCbVAF2Op1ej0fvgUQmV4AH Bgb27z8gkQwAU0QBBmAI8+bNzc7OlkhmBRhALI0UYIfD6/XqPZDIVq6stVgsEsm9 vb2HDh2WSAaAKaIAAzCE8vI5eXl5EsnBYLCubptEMgB8kyrAjtZWn8+n90AiW7Vq pdD2+y6Xy25vkUgGgCmiAAMwhJKSkpkzC4TC3313S0pKilA4AIylCnBrS4umaXoP JAJV0e+5526h8KNHu5xOp1A4AEwFBRiAIRSNKBQKX7v23vPOO08oHADGUgW4xW73 +/16DySCXbsaN27cKBTe0dEpdMIwAEwRBRiAUSxdWiP0MN4ll1yyfPnNEskAcAJV gO12e8DwBfiddzZ/+umnEsnBYHDnznqJZACYOgowAKOQK8DV1TW/+MUvJJIB4AQj Bbi5ORAI6D2QCDZs2NDSYpdIpgADMDIKMACjqK6uSkpKkkieNWvWq6++JpEMAGP5 fD6X2+10OPQeSGQPPLC+r69PItnv9zc0NEokA8DUUYABGIVcAU5LS9u8+R2JZAAY y93T097ePjw0pPdAIrv77ruEduqiAAMwMgowAKNYsmSxzWaTyZ6+detWmWQA+Eoc FeDa2tqkJJFDgD0ez549eyWSAWDqKMAAjKKycmF6erpEciAQ2LZtu0QyAIylCnBb W5tneFjvgUS2YsUdVqtVInlwcLCpab9EMgBMHQUYgFHMnz8/KytTIlnTtB07PpRI BoCxVAF2Op1ej0fvgUQmV4D7+voPHjwokQwAU0cBBmAUc+dW5OTkSCT7/f7t23dI JAPAWKoAOxwOn9er90Aiq61dIbTtQk9Pz+HDzRLJADB1FGAARjFnTll+fr5EcjAY rKvbJpEMAGOpAtza2qr5fHoPJLJVq1YKnTzX3d3d0tIqkQwAU0cBBmAUJSUlM2cW SCRTgAHExkgBbmkR2l05uuQK8NGjXU6nUyIZAKaOAgzAKIpGFAqFP//88+XlFULh ABCmCnCL3e73+/UeSAQdHR1PPfWkWHinyhcKB4ApogADMJCzzloqlHz99ddffvkP hMIBIEwVYLvdHjB8Af7444/r6qQOh/vii51CyQAwdRRgAAaydGmN0CN5F17417W1 tRLJADBqpAA3NwcCAb0HEsGmTf9cX18vkRwMBnfuFEkGgKigAAMwkJqaaovFIpG8 ZMmSJ56Qet4PABSfz+dyu50Oh94DieyZZ54WepuuKv/19Q0SyQAQFRRgAAZSVXWm 0LmUs2bNevXV1ySSASDM3dPT3t4+PDSk90Aie+CB9X19fRLJmqY1Nu6SSAaAqKAA AzCQ6uoqoXMp09PT/+VfNkskA0BYHBXgu+++S2irar/f39DQKJEMAFFBAQZgIIsX L0pNTZVItliS3n//fYlkAAiLowIsdwbS8PDw3r37JJIBICoowAAMpLJyYXp6ukRy IBDYtm27RDIAhKkC3NbW5hke1nsgkdXWrhB63GZwcLCpab9EMgBEBQUYgIEsWDA/ MzNTItnv92/fvkMiGQDCVAF2Op1ej0fvgUS2YsUdQhsu9Pf3HzhwUCIZAKKCAgzA QObNm5udnS2RTAEGIG2kADscXq9X74FEJrcC3Nvbe+jQYYlkAIgKCjAAAykvL8/L y5VIpgADkKYKsKO11efz6T2QyOQKsMvlttvtEskAEBUUYAAGUlZWNmNGvkRyMBis q9smkQwAYaoAt7a2avFQgOU2wTp2rFv9S5BIBoCooAADMJCSkpKZMwskkinAAKSp AtzS0uKXOV4ouuQK8NGjXU6nUyIZAKKCAgzAQIpGFAqFb978TlpamlA4AIwUYLvd 7/frPZAIPB7PvfeuFQrv6Ojs6OgQCgeAqaMAAzCQgoKC0tISofB16+5btmyZUDgA qAJst9sDhi/Au3fvfu21V4XCHQ5nV1eXUDgATB0FGICxLF1aI/Rg3o9+dPVVV10l kQwA08IFuLk5EAjoPZAItm3b9tFHv5dIDgaDO3fWSyQDQLRQgAEYS01NtcVikUg+ //y/Wr16tUQyAEwLFeDm5uag4Qvwxo0bd+1qlEhW5b++vkEiGQCihQIMwFiqq6uE Duc444wzH3/8cYlkAPD5fC632+lw6D2QyP7X/3rGITNOv9/f0CBSrQEgWijAAIyl qupMq9UqkVxcXPzyy7+WSAYAd09Pe3v78NCQ3gOJ7OGHH3K73RLJmqY1Nu6SSAaA aKEAAzAWuRXg7OycN998UyIZAOKoAN97770ez7BEMivAAIyPAgzAWJYsWWyz2SSS U1Js7777rkQyAMRRAV6zZk0wKPJGZY/Hs2fPXolkAIgWCjAAY1m0qFLotN7p06d/ 8MFWiWQAUAW4ra3NMyyyshpdK1fWCu01ODQ0tG9fk0QyAEQLBRiAsSxcuDAjI10i ORAIbNu2XSIZAFQBdjqdXo9H74FEVlu7QuidJgMDg/v375dIBoBooQADMJb58+dn ZWVKJPv9/u3bd0gkA4AqwA6Hw+f16j2QyFasuENor8G+vv6DBw9KJANAtFCAARjL vHlzs7OzJZI1Tdux40OJZACgACu9vb2HDh2WSAaAaKEAAzCWiory3NxciWRWgAHI GSnAra0+n0/vgUQm9wi02+1ubrZLJANAtFCAARjLnDll+fn5Esm8BxiAHFWAW1tb tXgowHKbYHV3d7e0tEokA0C0UIABGEtpaUlBQYFEcjAYrKvbJpEMACMFuKVF0zS9 BxLZqlUrp08XmQF2dXU5HE6JZACIFgowAGMpLi6eNWumRDIFGIAcVYBbWlr85i7A R44cbWtrk0gGgGihAAMwlqKiwqKiIqHwrVvrhJIBmNxIAbbb/X6/3gOJbPXqVULJ HSM6hcIBICoowACMpaCgoLS0RCj8+eefLy+vEAoHYGaqANvt9oDhC7BqqE899aRQ uMPh7OrqEgoHgKigAAMwnKVLa4Qez1u5ctUFF1wgkQzA5EYKcHNzIBDQeyAR/Md/ /Mdvf/umRHIwGNy5s14iGQCiiAIMwHDkCvDf/d1VV199tUQyAJOLlwJcV1f38ccf SSRTgAHEBQowAMOpqakWOqLjwgv/ura2ViIZgMmpAtzc3Bw0fAHetOmf6+tFaqoq //X1DRLJABBFFGAAhlNdXZWUlCSRfNZZZz300MMSyQDMzOfzudxup8Oh90Aie/75 51RRl0j2+/0NDY0SyQAQRRRgAIZTVVVltYoU4IqKiueee14iGYCZuXt62tvbh4eG 9B5IZI899qjQPlWa5m9spAADMDoKMADDqao602q1SiQXFMzcuHGjRDIAM4ujArx+ /fr+/j6JZE3TGht3SSQDQBRRgAEYjlwBzsrK+u1v35JIBmBmcVSA1669x+v1SiRT gAHEBQowAMNZsmSxzWaTSE5OTtmyZYtEMgAzi6MCvGbNmmBQZKcuj8ezZ89eiWQA iCIKMADDWbSoMi0tTSLZYrG8//4HEskAzCyOCvCqVSuFzpkbGhrat69JIhkAoogC DMBwKisXpqenSyQHAsFt27ZJJAMwM1WA29raPMPDeg8kshUrVgjtMjg4ONjUtF8i GQCiiAIMwHAWLJifmZkpkez3+7dv3yGRDMDMVAF2Op1ej0fvgUS2YsUdQpss9Pf3 HzhwUCIZAKKIAgzAcObNm5ednSWRrGnajh0fSiQDMDMKsNLb23fo0CGJZACIIgow AMOZO7ciJydHIpkCDECCKsAOh8Mns7tydMkV4J6ensOHmyWSASCKKMAADKeiojw3 N1cimQIMQMLICrDDIXS8UHTJFWC3293cbJdIBoAoogADMJzy8jl5eXkSybwHGICE OFoBrq1dkZQksgmWy+Wy21skkgEgiijAAAynrKxsxox8ieRAILBt23aJZABmNlKA W1t9Pp/eA4ls5cpai8UikXzsWHdra6tEMgBEEQUYgOGUlpYUFBRIJAeDwbo6jkEC EGWqAKvup8VDAZY7B7irq8vhcEokA0AUUYABGE5JSfHMmTMlkinAACRQgJWjR486 nW0SyQAQRRRgAIYze/bswsJZEskUYAASRgpwS4umaXoPJDK5AtzZeaS9vV0iGQCi iAIMwHCKRhQKhW/dWieUDMC0VAFuaWnxx0MBXr16lVByR0dnR0eHUDgARAsFGIDh 5ObmVFRUCIX/+tevzJ49WygcgDnFSwHu6up67LFHhcKbm5vd7h6hcACIFgowACM6 66ylQslr19573nnnCYUDMKeRAmy3+/1+vQcSwa5djRs3bhQK/+KLnULJABBFFGAA RrR0aY3Qu9Suv/76yy//gUQyANOKlwL88ccf19VtlUgOBoM7d9ZLJANAdFGAARiR XAG+5JJLli+/WSIZgGmpAmy32wOGL8DvvLP5008/lUimAAOIFxRgAEZUU1NtsVgk ks8//69Wr14tkQzAtOKlAG/cuHHXrkaJ5EAgUF/fIJEMANFFAQZgRNXVVUlJSRLJ /+k/nfPAAw9IJAMwrZEC3NysSqDeA4ngxRdfOHTokESy3+9vaBCp1gAQXRRgAEYk V4ArKyt/+cunJZIBmFa8FOCnnnqqo0PkqF4KMIB4QQEGYERyBbi0tPRXv3pJIhmA acVLAX7kkYddLpdEMgUYQLygAAMwIrkCXFAwU+4UEADmFC8FeP369f39fRLJFGAA 8YICDMCIqqrOtFqtEsnZ2TlvvvmmRDIA04qXAnzvvfd6PMMSyZqmNTbukkgGgOii AAMwoiVLFttsNonktLT0zZs3SyQDMC1VgJubm4OGL8B33XWX369JJHs8nj179kok A0B0UYABGNHixYtSU1MlklNSUt59d4tEMgDTGinAhw8Hg0G9BxLBnXeuEVqmHh4e 3rt3n0QyAEQXBRiAES1aVJmWliaRbLEkvf/++xLJAEwrXgrwqlUrp08XmfsNDQ3t 29ckkQwA0UUBBmBElZUL09PThcK3bq0TSgZgTvFSgGtrVwjtLzg4ONjUtF8iGQCi iwIMwIgWLFiQmZkhkRwIBLZt2y6RDMCcfD6fy+12Ohx6DyQyuQLc3z9w4MABiWQA iC4KMAAjmj9/XlZWlkSy3+/fvn2HRDIAc3L39LS3tw8PDek9kMhWrLhDaIP9vr6+ gwcPSSQDQHRRgAEY0bx5c7OzsyWSNU3bseNDiWQA5kQBVnp7ew8dOiyRDADRRQEG YERz51bk5ORIJLMCDCC6KMBKT0/P4cPNEskAEF0UYABGVFFRnpubK5FMAQYQXXFU gOXeA+x2u5ub7RLJABBdFGAARlRePicvL08imUegAURXHBVguRVgl8tlt7dIJANA dFGAARjRnDll+fn5EsmsAAOIrjgqwHIrwN3d3S0trRLJABBdFGAARlRWVjpjxgyJ ZI5BAhBdcVSAV66stVgsEsnHjh1rbY2Dg6AAgAIMwIhKS0sKCgokkinAAKKLAqx0 dXU5HE6JZACILgowACMqKSmZOVOkAAeDwbq6bRLJAMwpjgrwqlUrp08XmfsdPdrl dFKAAcQBCjAAIyouLp41a6ZEMgUYQHRRgJUjR462tbVJJANAdFGAARjR7NlFhYWF EskUYADRRQFWOjs729s7JJIBILoowACMqKCgoLS0RCh869Y6oWQAJhRHBXj16lVC yQ6Hs6urSygcAKKIAgzAiGbMyC8rKxMKpwADiCIKsNLa2nrsWLdQOABEEQUYgEGd ddZSoeSNG18X2mIagAmpAtzW1uYZHtZ7IBH09PQ89NCDQuFffLFTKBkAoosCDMCg li6tEXqv2qOPPlZVVSWRDMCE4qUAHzp06MUXX5BIDgaDO3fWSyQDQNRRgAEYlFwB vuOOO/77f/+2RDIAE4qXAvzZZ//+9ttvSyRTgAHEEQowkOBmzZqVnJxss6UkJSVZ Q8b+qsViOVXJVBOa8MdAIKC+RtM09Ynf7w99DISFfjGofkli7xO5Anzttdf98Ic/ lEgGYELxUoA/+uj327aJ7IEvVIALCgrUPSt0m7KEJSWFP478j/oldd3Ru9g49zJ1 oxr7M1qIup15PF6fz3fkyJGojxyAkVGAgURTXDxbNd6UlBT1MTR1sMTmumMKc1DN Q8YW5tHOHJqHBNSEYyJ7pdTUVAsN/rLL/r8bb7xRIhmACcVLAX733Xf//Oc/SSSr F/b6+oaIXzZjRr66MYUq61dt9uuFdlqoz45XaKNODV7dsNSNyesd6cNtbe2xuS4A vVCAgbhXVFSoCq/NZktLSx1nRddoRguzouYc/uO+XFoOBgoKCoQK8IUX/nVtba1E MgATUgXY6XR6PR69BxLBpk3/XF8v8qCyetXu6uoK1drp4UIbpuru9OmxLrRTFF4x Hhoa9ng8qhR3dHTqPSIAURYfL0YAThAuvarxqt6rJhl6Dyc6wpU4/KyapmkpKSlC E6Zly/7LunXrJJIBmFC8FOCXX355//4miWT16u31esNvsQn/xWW81N2IQk9Ke1Qf pgwDCSNBXp4Ak5g9uyg1NS0jI12V3oSZXsReVVX1o48+qvcoACSIeCnAzz77bGtr i96jiFeq5KsyPDAwODw81N7eofdwAEweE2ggDsyaNSs9PS0rKythFnv1NXfuvA0b Nug9CgAJIl4K8OOPP370KBs+RYFqwn19fYODQ2ygBcQjCjBgaGVlpRkZGTabjfXe KEpOTrnkkksKCgoKCwtLS0uLi4v5mwUAk2bYAhx+a64qvd3drp6enj/96U/BYCDy P4aJCQaDHo9nYGCgtdWh91gAnAam1IARFRUVpqamsuQrJPwkW3hrltA2LSlpaWnp 6WmpqWmZmZnZIQUhJSUlqh7n5+frPWQAxqVjAe7t7e0Kcbvdvb09AwODytDQkFeN xjPyX79fGz0EiPfOCAkvCA8PD/MmYSAu8DoIGM7cuRWq+sbs+CKMFTwu/MPjDTlZ dePUVJvqyRkZmepPJycnR7XimTNnFhYWqpI8e/ZsfYcNQEdyBThcbl0uV6jf9g4M DAwNhfvtyJE9quWq6hV+yRrdaXl012XEWCAQUDX48OFmvQcCIAJeIgEDKS8vz8nJ pvoa1tijm8KfhM+dSkqyJidbbTZbyshxVLaMjPTMzKzcXFWTc/Py8lRPnj27qLS0 LDMzU+/fAYDom0QBViX2yJEjx44d6+lxq9bU36+6bf/g4JDHM6yabehUWl/4WLjw q83YfjstgfZYTjzqj6ynp9dut+s9EACnxAsoYAglJSV5ebnhMyQQ18aW5NGV5OM9 OSlclVNSUlJD0tMzMjPVfzLHVuVZswp56BqIIyMF2OHwer29vb0ul2tsrR0aGhwO Ca3ZejVNC7Xar5pt2NiVW8ptAlB/0C6X2+l06j0QACfBiyygvwULFmRkpDPpMZXR ue/Yqjw6/bWMUG3ZYg1JTk62hajCnJ7+5WPYqjDr+RsATEY1W9Vpw+u0g4MDnhCf z6eqjmq2/pBpoe9o9S08+h099oFkXuRNRf1/YGBg8MCBA3oPBMCJeC0G9FRSMrLB EjtdYXxj2/K0LzvzNObSQCyFv+lOWKSl02J8fr+/u7vb6WzTeyAAvsILN6Cb8vLy 3Nwc5k8AACSqYDDodvfwrmDAOJh5A/pYuHBBejqPPQMAkOBUBx4cHNy/n8ehAUNg 8g3EWlFRYUFBAftdAQBgHpqmdXV1cVYwoDsKMBBTs2cXqfbLm34BADAbv9+vOnB7 e4feAwFMjQIMxA7tFwAAM6MDA7qjAAMxQvsFAAB0YEBfFGAgFmi/AAAgjA4M6IgC DIgrKiqcOXMm7RcAAISpDnz06FH2xAJijwIMyCopKcnPz6P9AgCAsVQH7u52OZ1O vQcCmAsFGJBVU1NtsVj0HgUAADCcQCBQX9+g9ygAc6EAA4IWL16Umpqq9ygAAIBB DQ8P7927T+9RACZCAQakzJlTlpeXN30632UAAODkgsGgy+VqaWnVeyCAWTA1B0QU FRUqtF8AADA+1YE7OzvZEAuIDWbngIglSxbbbDa9RwEAAOKAx+PZs2ev3qMATIEC DERfefmc3Nxcln8BAMBEBINBt9ttt7foPRAg8TFBB6KMh58BAMDp4kFoIDaYowNR Fi8PPwdD1Cdjuzq9HQAQ78J3t7GfTw/Rb0QTxYPQQAzEwWsBEEdKS0tmzJhhtLus uv37/X6LxWK1WtPT01NSbGqAGRkZxcXFPp/W19c7HOIN0TR/IKC+XH0MjJbkUSfM IYz2OwUAJJ4TCu1Jb0zqHpeUlKQ+WK1JKSGpIVlZ2cnJ1ra2toGBAfXPeb2ewcFB TdPUPU59vdHuYuq3duzYMYfDqfdAgERmrG97IN5VV1epG6reo/hSuPf+5//8/6xd u1b1W5/Pq2YGs2bNKigoGP8fVJODnp4el8t19OhRl6v72LHu7u5jPT29qir39fUP DPSrL/CEaCHhtkxhBgBMxAQLbbjTWkNsIenp6RkZmVlZ6j/ZOTnZ+fkzZszIz8vL nzlzZl5eXk5OjvqC8S/d1dV15MiRQMCfnDzSkNetW/fv//7/G6oJq1tqQ0Oj3qMA EplRvtuBBDB3bkV2dra+N9Fw6c3Nzfvbv734uuv+IT8/PwYXHVuY1dzC7XaHC3NP j3tgYFAV5oGBgaGhYVWYfT6fpvlUXw4GA9O+PgeiKgNAXBun1oZf0lWrTUqyWK3J imqzaWmpGSMyMzLSc3Jyw4U2Nze3oKBg4oU2Krq7u1966VfvvrvF7XbpXobVv7fe 3t7Dh5t1HAOQ2JhiAlGzdGmNXnfN8FTjnHPOXbt2bXl5uS5jmDhVmNVso7Ozs729 /UiIqs0uV7dq0YODQ4OqMg8MeL1emy01KytLtWhVm9Xvbvpxeg8fAEwteJx6QVZV VnXXvr4+j2c4JSVF1dn0dPWfNNVd8/LyVZWdFTJ79uzCwsL8/PzYFNqpsNvt69at +/zzz3S846h/tzt31utyacAMmEoC0bFoUWVaWlrsr6tpWkVFxWOPPV5ZWRn7q8de Q0PD9u3b1Een0+l2uz0eT3iRwWKxhL+AhgwAUzG6chsIjDyqo15UbTZbbm5uSUlJ dXX1t7/9/6qPug4wRpqamm6//WfNzc1WqzX2Vx8aGtq3ryn21wXMgJkiEAWhv94u inH18vv93/3uRWvXrs3IyIjldQ2rq+vou+9u2bnzCzVf6erqUrMHTdPUTE51Yx6u BoCwEx5UVi1XvSqqjpeWllZQUFBRUbF06Vl/+7cXFxTM1HGQxjEwMLBu3bqtWz+I 8QYf6o+mvb3jyJEjsbwoYBJMBIEoqKo6M5Z/Q6zui3PnznvxxReYoEzc559//skn H+/evaetrc3lcnk8w36/f/TJ6hO+mJIMIB6dsJvUtOOPK6vXNNXfbLbUvLy84uLi M85Ycv75f3XOOefoMsh41NV19Prrbzh8+FAs7w6apjU27orZ5QDzYJIHTFVJSXFB QUHMboqqtt1+++0//vE1sbmcSTQ1Nf3xj39saGiw2+0uV/fAwED4jceBQOCEBeRR lGQAsfTNcjvt+BJu+GUqOTk5IyMjLy+/vLy8urr6W9/6lkneGhMzv/nNK4899ljM loLVH25XV5fT2RabywHmwQQOmKoYH330q1+9xF/bx97u3bv//Oc/q49Op+Po0a7B wQGPxxNeQ572jS2sx6InAxjfSZvttDEbKR9fv7Wlp2fMnFlQUlJ6xhlnnHfeeepj bEeKkYeJ/uEfrovZ5TgSCZDAzAyYkjlz5uTl5cas5NB+jezzkKampra2Nrfb3dfX Fzp+2RcIfO1Za6oyYAbj1NppY55MtliSkpOTU1NHNr3Pzc0tLi6urKw8JyS248VE xbIDq/+TuFzulpaW2FwOMAnmW8CUxGz5V9P8P//5fZdeelkMrgVRavK0e/fu5ubm 9vb2Y8e63O6ewcFBj2dYU3/Gfv+04/NjNu4CjO+EDaWmHf9uVfcFq9Vqs6Wmp6fn 5ubMmFEwe/bsioqKM844g2abAN55Z/Pdd99jtcbi7s8iMBB1TKqAySsvn5ObG6Pl 3x/96Oqf/exnMbgQDEVV5aamfXZ7S0dH+9GjXd3d3QMD/UNDQz6f5vN59R4dYCLJ ySnJySNbJWdkZObn58+cWVBUNFvdBSorF/Eosgk9/vjjr732agwuFAwG3W63ugvE 4FqASVCAgcmL2fLv7NnFGzduVFOuGFwLAACMr7u7++///u/b22OxQxWLwEB0UYCB SSorK1WNNAbLv+rO98ADD37/+9+XvhAAAJig3/3ud2vWrI7B34MHg0HVt1tbHdIX AkyCAgxM0pIli202Wwwu9L3vff/++++PwYUAAMDE3XXXXe+997sYXMjj8ezZszcG FwLMgAIMTEZRUaESg+Vfmy319ddfnz9/vvSFAADAaTl48OBVV13l8QxLXygYDHZ2 dnZ0dEpfCDADCjAwGfPmzc3KypIuwIFAYNWq1VdeeaXoVQAAwORs2rTpoYcetFgs oldRBbivr+/QocOiVwFMggIMTMbSpTUxWP4955xzn3vuOavVKn0hAAAwCZqm3XTT TZ9//pn0hVQH3rmzXvoqgBlQgIHTtmDBgszMDOmrBAKBF154cdmyZdIXAgAAk/bp p5/ecMP10ovASn//wIEDB6SvAiQ8CjBw2qqqqqxW8V0fr732ultuuUX6KgAAYIqe fvrpl19+SfoqmuZvbOQ8JGCqKMDAaYvB88+5ubmbNr1RVFQkehUAADB1HR0dV155 hdvtFr0KT0EDUUEBBk6bdAFWd7jbbrvtxz++Ru4SAAAgin7zm1eeeOIJ6ekBBRiY OgowcHoqKxemp6eLXiI7O/v11/+5tLRU9CoAACBaHA7HVVf9XW9vr+hVBgcHm5r2 i14CSHgUYOD0VFdXJSXJvgF4+fKbb7jhBtFLAACA6HrhhRc2bHhW9BJ+v7+hgbcB A1NCAQZOTwyef/71r185++yz5S4BAACi7i9/+cv//J/X8BQ0YHAUYOD0SBfgc889 99FHH0sKsVgs4U9icOYwAACYon/8x3/805/+j1w+BRiYOmbVwGlYsGB+ZmamXH4g ELj11p9+73vfO9UXqCY8thiPisHxgwAAYBzqJv7WW2+tX3+/6E25v7//wIGDcvlA wqMAA6ehqupMq9Uql69umb/85dMLFiyYYsgJ3ZhlZAAATlfgZPx+f/iTYMgJ/8iB Awf+6Z9uUb8qNypN0xobd8nlAwmPCTFwGqSff/5v/+38NWvWyOWHsYwMADAbVVZP WmjHisqFHnjggT/84ZOoRJ0UT0EDU0QBBk6DaAGO+PxzLLGMDAAwsoht9pvLs7Hx 3nvvPfXUk3J/p0wBBqaIuSwwUUVFhYpoA3zyyScXL14ilx9dY4vx2MJMSQYAnJZT NdioL8/GwN69e37605/K5at/LZ2dnR0dnXKXABIb81RgoiorF6anp8vlV1fXPPTQ Q9KHDMfY2GJMSQaAhBdureM/b6zX2mxs+P3+VatWNTQILtIODg42Ne2XywcSG3NQ YKKqqqqsVql2qmYDN9xww+WX/0Ao38jC70kebchjP9KTAUBH4/TY0V9K7DY7OW+/ /dYLL7wgdwvTNH9jY6NQOJDwmFwCEyX6BmBN0x566OFzzz1XKD8BWELoyQAwCWOr 7Am1duwP9R5mgvjss89WrVopd2wEbwMGpoJZIzBRogU4Ozv72Wc3FBQUCOWbx+ge 16MNeewnVGUA8W4iPZZVWX11dXXdfPPy3t5eoXwKMDAVzAWBiRItwN///vd/8pNb hMJxUupP86QlOfwJVRmAnBMeIT7pc8X02Lj2zDNP/+53vxMKpwADU8EMD5iQhQsX ZGRkCIWrO9ny5TdfeumlQvmYOkskFGbAVE7Y6mmcH1Jizemdd97ZsOFZuVvDwMDA /v0HhMKBxMaMDZiQqqoz5d7M4/f7H3zwId4AnEgozIBhBY8b21FP+sPRz/UeMuLP Z599tnr1KrmTHTRNa2zcJRQOJDZmYMCEiD7/nJub++yzG/Lz84XyERemh4xtyKf6 XO+RAvoYraNja+r4DVbvIcO8uru7b755udvtFsrnKWhg0phIARPCG4BhWNOPC9fj CX6i96iRyIKnNra4nvSHeo8diBreBgwYE3MgYEJEC/CPf3zNlVdeKRQOTNw3u/RY Y79g/F/V+/eBrxl9iHds1Yz48+PQ97cDxItNmzb95jevCIVTgIFJY5oCRDZ37tyc nGyhcL/ff8cdK77zne8I5QPGNNqZo/LxhNiTXmtyP3lC3/tm/Rv/C076w4l8nMgX ADCyurq6Rx/9hdzbgHt6eg8fPiwUDiQwCjAQ2ZIli202m1C4mss+9dRTixcvEcoH AACxt3fvnltvvVXuoRiPx7Nnz16hcCCBUYCByKqrq+T+BvfMM8988MGHUlJShPIB AEDseb3e1atX7doltVez3+9vaGgUCgcSGAUYiEz0DcA/+tHVV111lVA4AADQy+uv v/7aa68KhfM2YGByKMBAZKIF+JprrrniCnbAAgAg0bzxxqZXXnlFKJwCDEwOBRiI oLh49syZM4UKsN/vv+uuu88//3yJcAAAoKNPPvnk/vt/LvQuKlWAjx492tbWLhEO JDAKMBBBZeXC9PR0ofCcnJwNGzbk588QygcAAHrp7j62fPnynp4eofzBwcGmpv1C 4UCiogADEVRVnWm1WoXCL7zwr2tra4XCAQCAvh555JHf//5DoXBN0xobpTbZAhIV BRiIoKam2mKxCIXzBmAAABKY6NuAA4FAfX2DUDiQqCjAQARyO2AFg8Hly2++9NJL JcIBAIDu3nnnnQ0bnpWbSLAPFnC6KMDAeIqKChW5HbDWrLnzggsukAgHAAC6++ij jx54YL3cPlidnZ0dHZ0S4UCiogAD4ykrK8vPzxMqwDk5uU8//fSsWbMkwgEAgO6O HDlyyy239PS4JcJVAe7udrW2tkqEA4mKAgyMZ/HiRampqULh//W/fuuuu+4SCgcA AEZw//33/9u//VEofHh4eO/efULhQEKiAAPjqa6uEnpsSfnxj6+58kp2wAIAIJFt 2rTpN795RSjc7/c3NDQKhQMJiQIMjEduByzl+uuvv/zyHwiFAwAAI3j77bdefPFF oXD2wQJOFwUYGE9VVZXVKrVxxW233fbd714kEQ4AAAxi69YPnnjiCaG/T9c0f2Mj K8DAaaAAA+ORWwHWNG39+geWLVsmEQ4AAAzi008/vfPONVarVSKcFWDgdFGAgfHI FeCqquoHHnggJSVFIhwAABiE1+tds2ZNY2ODRDgFGDhdFGBgPHIFmB2wAAAwCbl9 sCjAwOmiAAOnVFFRkZubIxR+zTXXXHEFBRgAgMT3xhubXnnlFaFwt7unublZKBxI PBRg4JQWLlyQkZEhkRwMBn/yk1suvvhiiXAAAGAoW7ZseeaZp4WeKRsYGNi//4BE MpCQKMDAKS1Zsthms0kka5p/7dq13/rWtyTCAQCAofzxj39ct26d0LkSHo9nz569 EslAQqIAA6dUXV2VlCRyr/L7/U888WRVVZVEOAAAMJTGxsbbbvup3KSioYGTkICJ ogADpyS3A5bVat2w4bmysjKJcAAAYCitra3Ll9+kaZpEOPtgAaeFAgycklwBZgcs AABMRW4fLAowcFoowMApUYABAEBUUIABg6AAAydXUVGem5srFH7jjTdddtllQuEA AMBoNm/e/PzzzwmFu93u5ma7UDiQYCjAwMktWDA/MzNTIjkQCNx++x3f+c53JMIB AIAB1dXVPfbYoxaLRSK8v7//wIGDEslA4qEAAye3ePGi1NRUiWS/33/ffT8/77zz JMIBAIAB/fnPf77nnruFNoIeHh7eu3efRDKQeCjAwMnJnYEUCAR++cunFy9eLBEO AAAMaO/evf/0T7cIrQBzEhIwcRRg4ORqaqqF7lKcgQQAgNmInoQUCATq6xskkoHE QwEGTk5uC+hrr73uhz/8oUQyAAAwrDfffPPll1+SSGYjaGDiKMDAyVGAAQBAFFGA ASOgAAMnMWdOWV5enlABvv766y+//AcSyQAAwLDefvutF198USJZFWCXy9XS0ioR DiQYCjBwEvPmzc3OzpZIVreo22677bvfvUgiHAAAGNbWrR888cQTQn+93tvbe+jQ YYlkIMFQgIGTqKxcmJ6eLpHs9/vvuuvu888/XyIcAAAY1ieffHL//T8XOmNicHCw qWm/RDKQYCjAwEksWbLYZrNJJKsC/Mgjvzj77LMlwgEAgGH95S9/qa1dIVSAPR7P nj17JZKBBEMBBk6iqupMq9UqFP7cc89XVFQIhQMAAGNqbm6+6aYbhcI1TWts3CUU DiQSCjBwEnJbQKenZ7zwwgsFBQUS4QAAwLC6urpuuOGGwcEBiXA2ggYmiAIMnARn IAEAgKjjJCRAdxRg4CQowAAAIOoowIDuKMDAiebMKcvPzxcKv/HGmy677DKhcAAA YGSbN29+/vnnhMK7u7s5ChiIiAIMnGju3Lk5OVKHAP/kJ7dcfPHFEuEAAMDgtmzZ 8swzTws9ZdbT03v4MEcBAxFQgIETLVy4ICMjQ/QSwZBAIGCxJGVmZhYWFt55552l paWiFwUAALHhcDjWr1/f2dnZ398fCPgtFsv0ENGLDgwM7N9/QPQSQAKgAAMnOuOM JSkpKbpcOtyK1SfJySk5Odnr1t1XWVmpy0gAAMBENDU1rV17T09Pr8/nVT8Md11d RuL1enfv3qPLpYE4QgEGTlRdXSV0SP2kqVasurG6odpstpyc3LvuunPx4iV6DwoA ABPZu3fP/fev7+lxezye8E1ZdV29B/U1fr+/oaFR71EARkcBBk4ktwV01AVC1GhT UlIyM7PuvPPOmpoavQcFAEAcq6+vX79+fX9/n9frVUXXEqL3oCaEjaCBiYiPWT4Q S3FUgE9l9FFqdc9OTU3Ly8v92c9upxsDABCmWu7jjz/mcrmHh4dG75gJcPenAAMR xff3OSAhAQrwOL7ejVOzs7NvvfWn5557rt7jAgAgyj777LOnnnqyt7d3eHg4YVru OCjAwEQk7EsAMGmJXYDHETxu2sguXMnp6em5ubk33bScegwAMCZVcZ97boPb7R4c HPT5fOpnph+n99B0QAEGJsKMrw7AOCoqKnJzc/QehREFx7BarTZbalZW1nXXXXfB BRfoPTQAQML66KOPXnrppb6+Po9nWNO06WPoPTQjcrt7mpub9R4FYGi8dgBfU1m5 MD09Xe9RxKXRh6uVpKQkm82Wlpb2ox9d/b3vfU/fgQEADOu999577bVXh4aGPB6P 3+8P/2RiP6gsanBwsKlpv96jAAyNFxfgawx4BlLCGLuGrGY26t9zSkpKWlr6FVdc cdlll+k9OgBAlG3evPmNN94YGhr0er2q3IZf/Fm/FcVJSEBEvPoAX0MB1t3YtyKH T1lMTk5JT0/LzMy69NJLL774Yr0HCACmtmXLlnfeeae/v29wcMjn84ZPqp9m7jff GgcFGIiIFynga0y7A1bcCc+3Qs9dB8N/YqosJydbQ205PTMz46KL/oaFZQCYiM2b N3/wwfv9/QOhraS8Pp+mXlynjbzGTgs9jDzyIsvNMS6wDxYQEa9lwNdQgBPV2IXl MIvFYrVaU1JSwm9XvuCCC6+++modRwgA0fLqq69+9NHvw2+s9Xq9mqaN7tEwjaXa hEYBBiLitQ/4GgowRo0uMo+tzaGnspPCS82pqbbU1LRly5bdeOON+g0TQMJ6/vnn P/300+HhoeFhT3hhNhDwn/CKxPIsxqIAAxHxcgl8DQUYUTG2PI/OVsP7moZXnpOS rDabLVShU88666zly2/WdbwAom/Dhme/+OKL4RGe0BbHWnglduye+WMXY7n7YOoo wEBEvNQCX0MBhnGMtuhpX1+IDk+XLSFJqklbk5Xws9yLFlXW1q7Uc9BAnHvkkYf3 7WsKPzns8/k0zef3+wMh3/w2nHa8tXLjgEFQgIGIeL0GvlJePicvL0/vUQAAAEyS y+Wy21v0HgVgXBRg4Cvz58/LysrSexQAAACT1NfXd/DgIb1HARgXBRj4yqJFi9LS UvUeBQAAwCQNDQ3v27dP71EAxkUBBr5SVXWm1WrVexQAAACTpGlaY+MuvUcBGBcF GPhKTU21xWLRexQAAACTFAgE6usb9B4FYFwUYOArbAENAADiGhtBA+Njrg98hQIM AADiGgUYGB9zfeBL5eXleXm5eo8CAABgSlwut91u13sUgEFRgIEvzZ8/PysrU+9R AAAATElfX//Bgwf1HgVgUBRg4Cvz5s1NTk5OSUmZPn06u2EBAIB4EQgEgsGg1+v1 +XyHDh3WeziAcVGAgfHMmVOmKrHVaqUVAwAAIxjtupqmqbrb0tKq94iAeEIBBk4b rRgAAMQAXReIOgowEB2qFVutI7043IrD9B4UAACIA8HjQs8wj7Rdui4ghAk6IGvu 3IrwcnFSUpLFYqEVAwBgZqrlBgIBv98fXtQ9fLhZ7xEB5sJcHNBBeXl5cnK4F1t5 iBoAgIQUfoA5VHRHui5HEwFGQAEGjKKsrCxciVkuBgAgjoxd1A3X3dZWHmAGDIrp NWB0o3tuqY/h5WKKMQAAsRcuuuqjL/w+XXalAuIQ02ggXoW33QqtFieFV4x5lBoA gKkLhPhDNM3PllRAIqEAAwlozpw5oUXjJBaNAQA4qa8v5/pDy7kteg8KgDjmxIC5 jHbj0UVjTmwCACSk8MFCo8u5tFwA0yjAAEaVlZVarcmqF6turEqyen043o55oQAA GNHxihtUn6pyG3pmOaBpvtZWh95DA2BQzGsBTEhpaWlystVi+fIdx1arVf0kD1cD AESFl3DVJ5qmqXI7UnADfp9PcziouAAmg5krgOgY05BH/htuyNOns4YMADi54HHT vuy3oXpLvwUgiVkpgNgpLS1JTk62hFuy5WvLyJRkAEgko++/nRYqt+F34aqPPp/P 4XDqPToA5sWME4DhhHpyiurFx5vyyP9MYz0ZAPQ2ds32y+Xa0IdAIOjzeWm2AIyP eSSAOFZSUpKS8uVRT6NoywAwcd/stKPUT3q9PqeTWgsgcTA1BGAixwvzlydAjRZm NckbW5ipzQDiUbjEjhZa9VI2ptCGz7wNUGgBmByTPACIYHSdeWxzVj+gOQOQcNIe e/w82y97LGuzADA5zNUAQFBxcXFKSkqoOn9ZoEcLs9VqDU9zT3hamxYNxK/wN/W0 rz9XrL6pNU0b/Znwo8WhD6rEetva2nQdMgCYC9MsAIgDxcWzU1JsqhofL8tjq/T0 8HL0tNCcm+VoYBLGLrqGv3fCi65jWmswvO4abrVer6etrV3vUQMAThvTIwAAAACA KVCAAQAAAACmQAEGAAAAAJgCBRgAAAAAYAoUYAAAAACAKVCAAQAAAACmQAEGAAAA AJgCBRgAAAAAYAoUYAAAAACAKVCAAQAAAACmQAEGAAAAAJgCBRgAAAAAYAoUYAAA AACAKVCAAQAAAACmQAEGAAAAAJgCBRgAAAAAYAoUYAAAAACAKVCAAQAAAACmQAEG AAAAAJgCBRgAAAAAYAoUYAAAAACAKVCAAQAAAACmQAEGAAAAAJgCBRgAAAAAYAoU YAAAAACAKVCAAQAAAACmQAEGAAAAAJgCBRgAAAAAYAoUYAAAAACAKVCAAQAAAACm QAEGAAAAAJgCBRgAAAAAYAoUYAAAAACAKVCAAQAAAACmQAEGAAAAAJgCBRgAAAAA YAoUYAAAAACAKVCAAQAAAACmQAEGAAAAAJgCBRgAAAAAYAoUYAAAAACAKVCAAQAA AACmQAEGAAAAAJgCBRgAAAAAYAoUYAAAAACAKVCAAQAAAACmQAEGAAAAAJgCBRgA AAAAYAoUYAAAAACAKVCAAQAAAACmQAEGAAAAAJgCBRgAAAAAYAoUYAAAAACAKVCA AQAAAACmQAEGAAAAAJgCBRgAAAAAYAoUYAAAAACAKVCAAQAAAACmQAEGAAAAAJgC BRgAAAAAYAoUYAAAAACAKVCAAQAAAACmQAEGAAAAAJgCBRgAAAAAYAoUYAAAAACA KVCAAQAAAACmQAEGAAAAAJgCBRgAAAAAYAoUYAAAAACAKVCAAQAAAACmQAEGAAAA AJgCBRgAAAAAYAoUYAAAAACAKVCAAQAAAACmQAEGAAAAAJgCBRgAAAAAYAoUYAAA AACAKVCAAQAAAACmQAEGAAAAAJgCBRgAAAAAYAoUYAAAAACAKVCAAQAAAACmQAEG AAAAAJgCBRgAAAAAYAoUYAAAAACAKVCAAQAAAACmQAEGAAAAAJgCBRgAAAAAYAoU YAAAAACAKVCAAQAAAACmQAEGAAAAAJgCBRgAAAAAYAoUYAAAAACAKVCAAQAAAACm QAEGAAAAAJgCBRgAAAAAYAoUYAAAAACAKVCAAQAAAACmQAEGAAAAAJgCBRgAAAAA YAoUYAAAAACAKVCAAQAAAACmQAEGAAAAAJgCBRgAAAAAYAoUYAAAAACAKVCAAQAA AACmQAEGAAAAAJgCBRgAAAAAYAoUYAAAAACAKVCAAQAAAACmQAEGAAAAAJgCBRgA AAAAYAoUYAAAAACAKVCAAQAAAACmQAEGAAAAAJgCBRgAAAAAYAoUYAAAAACAKVCA AQAAAACmQAEGAAAAAJgCBRgAAAAAYAoUYAAAAACAKVCAAQAAAACmQAEGAAAAAJgC BRgAAAAAYAoUYAAAAACAKVCAAQAAAACmQAEGAAAAAJgCBRgAAAAAYAoUYAAAAACA KfxfCytbFgrLEfIAAAAASUVORK5CYII="/></symbol><use xlink:href="#c" width="1280" height="1280"/></g></g></svg>')} -.is2d .king.white {background-image:url('data:image/svg+xml;base64,<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="614.635" height="614.635" viewBox="0 0 460.977 460.977"><mask id="b"><use xlink:href="#a" width="1280" height="1280" transform="rotate(.193) scale(.36014)"/></mask><symbol id="a" viewBox="0 0 1280 1280"><image width="1280" height="1280" xlink:href="data:image/png;base64, iVBORw0KGgoAAAANSUhEUgAABQAAAAUACAAAAAA9j6ArAAAACXBIWXMAAA7EAAAO xAGVKw4bAABWO0lEQVR4nO3dB3gUdeLG8fxDCCEiAiJFQUQUrChWrNiwYT+xl7Od vZ6eXVFR8fTsvSv2clbwFBuKihWwiyAoICC9hyQkf4pgNtnd7MzOzPsr389zz3N3 Sma/QvKa7M7O/F8BAHjq/9QBAKDCAALwFgMIwFsMIABvMYAAvMUAAvAWAwjAWwwg AG8xgAC8xQAC8BYDCMBbDCAAbzGAALzFAALwFgMIwFsMIABvMYAAvMUAAvAWAwjA WwwgAG8xgAC8xQAC8BYDCMBbDCAAbzGAALzFAALwFgMIwFsMIABvMYAAvMUAAvAW AwjAWwwgAG8xgAC8xQAC8BYDCMBbDCAAbzGAALzFAALwFgMIwFsMIABvMYAAvMUA AvAWAwjAWwwgAG8xgAC8xQAC8BYDCMBbDCAAbzGAALzFAALwFgMIwFsMIABvMYBI WGnrMbX/UmGHiWWKFHiPAURS1t2hW5cOnTP+7R/G/vjVh78m2AMwgIhd4UY7bL5+ u3Y5/uqx477/4oORsQYByzGAiE/LXbfr2nHNUB86evSwDwfPjbgHqIUBRBya9dy5 W8fWeR9m/M9fvP0BTw8iNgwgItaqd8+uHSM94vdfDnhtfqRHBJZhABGhrf++w4Yx HXrom/1Hx3Ro+IsBRETanr3vBjE/xEdPPcp3gogSA4gorHvFUck80C9P3DIzmUeC DxhA5K340n+0SfDhvu73dIKPBqcxgMhTy7t7J/6Yl/dN/CHhJAYQeWnx2D6Sx736 SsnDwjEMIPJx3cWqR57yj5dVDw13MIAIr/M7ub7BLQ4D968UPjqcwAAitDNv1z7+ pAOHagNgPQYQYT1xpLqg4JT71AWwGwOIkN7dWV2wWJ+r1AWwGgOIcAbtpi5Y6tLr 1AWwGQOIUB4+Tl3wp2P6qwtgMQYQYZxyj7pguWm7fK1OgL0YQITQ8ecG6oQVvo/r +jPwAAOIEH4Nd5nnWFQ9eYw6AdZiABHcJdeqC2qa2etjdQJsxQAisJKZjdQJKT7Z Vl0AWzGACOyh49UFqeadxPWxEA4DiMDmN1YX1PK+Cedkw0YMIIJSvwW4Lk6FQUgM IIIap7wETFpV/f+uToCdGEAE1PZ3dUFdo9ZVF8BODCACuvlcdUFds44YqE6AlRhA BDRmLXVBXYseOlmdACsxgAimsKJQnZDGV5urC2AlBhDBHPCSuiCdid0mqxNgIwYQ wTxzqLognXlnPqJOgI0YQAQzem11QTqLHjhVnQAbMYAIZkGJuiCtd3dVF8BGDCAC aTFNXZDeyC7qAtiIAUQghz+lLkhv0lbj1AmwEAOIQO44Q12Q3qyjX1MnwEIMIAL5 YAd1QXoLr7xBnQALMYAIxMT3gSyx6MFT1AmwEAOIQGavrC5Ir/r1/dQJsBADiEAW mfhGuCWGbqMugIUYQARROk9dkMmP66sLYCEGEEFs/oW6IJOxHdUFsBADiCCOflxd kMmk7r+qE2AfBhBBXHWFuiCT6fsPUSfAPgwggnj8aHVBJnNO5t6YCIwBRBDv7KIu yKTsklvUCbAPA4gghm+iLsik4qZL1AmwDwOIIH5dU12QCW8FQQgMIIKY1kJdkEn1 c4epE2AfBhBBVKsDMvt+Q3UB7MMAIggGEE5hABHAkO3UBZlxQSwExwAigAmrqwsy q3rkRHUCrMMAIoD5jdUFWQzYR10A6zCACMDYi2Et8cm26gJYhwFEAAa/BlJQMLyb ugDWYQARgNED+LWx71KBsRhABGD0AH7TVV0A6zCAyJ25l0JYYsElt6oTYBsGELkz 953ASyx64FR1AmzDACJ3c1dSF2T16v7qAtiGAUTuKhuoC7L6cEd1AWzDACJ3Rr8G UlDw5RbqAtiGAUTuDB/AEZuqC2AbBhC5YwDhGAYQOXvN8Dfbzjv3AXUCLMMAImej OqkLsqu881x1AizDACJns5qqC7KrfrG3OgGWYQCRs4oidUE93jP6nSowEAOInFWZ /tny2dbqAljG9E9pGMTwF4ELCoZtpi6AZRhA5Mz4AeSKgAiIAUTOjB9ATgREQAwg cvX9+uqC+lT852J1AuzCACJX05urC+pT/dRR6gTYhQFErsobqgvqNWh3dQHswgAi V8afBVNQMHQbdQHsYv7nNExh/GsgBQVfba4ugF0YQOSKAYRzGEDkyoIB5ExoBMMA IkfDLbjtbvn1fdQJsAoDiBxNaakuqF/VY8erE2AVBhA5KmukLsjBAMOv2QrDMIDI kQVnwRQUDNlBXQCr2PBJDSNY8BpIQcHnW6kLYBUGEDmyYgC5MyYCYQCRIwYQ7mEA kZtPrfjhsqzPDeoE2IQBRG4mtVYX5KLqwZPVCbAJA4jcLChRF+TklQPUBbAJA4jc LCpUF+Tk/Z3VBbAJA4jcWPEaCBfEQjAMIHJjyQByIiCCYACRG0sG8Ist1QWwCQOI nLzfQ12Qo5H7/KxOgD0YQORkXDt1QY5m7zRMnQB7MIDIydyV1AU5qtx5iDoB9mAA kRNLngJcbJ8B6gLYgwFETuwZwP1eUxfAHgwgcsIAwkUMIHKx9VB1Qc4uvKlKnQBr MIDIxe9t1QU5m7vL5+oEWIMBRC4qitQFOaveY5A6AdZgAJELe54C5GVgBMAAIhc2 DSCvgiBnDCByYdMAHvCKugDWYACRg93fVBcE0PeqSnUCbMEAIgcvHqQuCOCrg35V J8AWDCBy8Oua6oIAZu36pToBtmAAkYOyRuqCAKp2f0edAFswgMhBlVWfJ5wHg1xZ 9YkNFZteBC4oOPBldQFswQCifoc+oy4I5LaLytQJsAQDiPoN2FtdEMi3B4xWJ8AS DCDqZ9GlEJaYu9un6gRYggFE/RYWqwsCqe7Jy8DIDQOI+tn1IjAvAyNnln1mQ6Go Ql0Q0N/+qy6AJRhA1OvEB9QFAd3/z7nqBNiBAUS93tlFXRAQN0dHjhhA1GtyK3VB QPN3tecWJpBiAFGv8obqgoCq93xLnQA7MICol11vhFuCa6IiNwwg6lOyQF0Q2GHP qgtgBwYQ9Tn3ZnVBYE+eMVOdACswgKjPx9uoCwIb2+t7dQKswACiPlNXVRcEVtZz iDoBVmAAUR+Lboq+Qq+B6gJYgQFEfex7EZhroiJHDCDq0WyGuiCEvz+mLoAVGEDU o8+V6oIQXj5pqjoBNmAAUY8vN1MXhDBhz2/VCbABA4h6zFxFXRBCec8P1AmwAQOI elQ2UBeEwcvAyAUDiHrY+CIw10RFbhhAZNdhrLoglNPvVhfABgwgsrv1bHVBKG8f M1GdAAswgMju2w3VBaFM3nO4OgEWYACR3Zwm6oJQKnd/T50ACzCAyG5RobognP1e UxfAAgwgsrPzReCCgt4vqAtgAQYQWW06TF0Q0kU3qAtgAQYQWT18nLogpI8PG6dO gPkYQGQ1qpO6IKTpu3+pToD5GEBkNb+xuiCkRXsNUifAfAwgsqqy9jOEW2OiftZ+ eiMZtr4IzMvAyAUDiGx6vqUuCK3f5ZXqBBiPAUQ2Lx6kLght+EFj1AkwHgOIbMa1 UxeENmf3oeoEGI8BRDZljdQFoVXv/T91AozHACIbe18E5pqoyIHFn9+IX1GFuiAP RzytLoDxGEBkcebt6oI8PHHmTHUCTMcAIosh26kL8jB2X26NiXowgMhiWgt1QR4W 7jFYnQDTMYDIoqJIXZAPromK+jCAyMLeN8Itccjz6gKYjgFEZmuMVxfk5Yy71AUw HQOIzCy9JeZy7x7FrTGRHQOIzL7bQF2Qlyl7cU1UZMcAIrO5K6kL8sI1UVEfBhCZ 2fxGuCV4MxzqYflnOGJl94vABQWHPasugOEYQGS076vqgjzdemG5OgFmYwCR0cC9 1AV5+uGAkeoEmI0BREaTWqsL8rRgzw/UCTAbA4iMyhuqC/JUvT9vhkNWDCAysv01 EF4FQX0YQGTSepK6IG+n360ugNkYQGSyqFBdkD/OBERWDCAysPpy+Msd019dAKMx gMjgmsvUBREYeNwf6gSYjAFEBr90VBdEYNae3BwYWTCAyMDuq0Evd+DL6gKYjAFE BvafBLPEkU+pC2AyBhDpnXuzuiASz506XZ0AgzGASG/kuuqCSEzvxZOAyIwBRHrW vw9umeqDeBIQmTGASM+NpwALCo5+Ql0AgzGAqOn9Di0aF7n3SVG9aOGsKSd/qs6A cdz7XEcIn6++SqMGPnwuVFeVz5150mB1Bkzhwyc9MninQ4vShg684TeU6sqyWVPO ZQo9xwD6Z3iblYu9+HYvR1UV82af84q6AhJ8HfjimnXatWnepJg/8Iwq58+cMmHC /cPVHUgQXw+O69OlQ9sWpU68qy0xVQtnTR7360PD1B2IHwPoqFvXad+6aQl/vHmp mDvt93H3DlFnID58hTjmjvU6tGzixjnM5qhaMOP3sXfzgomDGEBHXLxxp3bN+Y4v XpWzJ48d+eTn6gxEh68Y29244Vqtm/IcX5KqF0ybMPqh99QZiAADaK0rN+ncdpUG 6gqPVZdNGfvjk9x52GoMoIWe6LKFOgF/mTNp3P3cftNSDKBNbtp0V3UCMho+8rGB 6gYExADa4aENt1YnIDdvPfq0OgE5YwANd+FWXTZUNyC4Id89y6skFmAAjdV3s73U CcjTVz88+5q6AdkwgAa6ZdOd1AmI0Hc/P8OLJIZiAA0zZDt1AeJxxTXqAtTFAJrF lQvRo653dlMXoA4G0CiX8V2Cw7b7WF2A2hhAozxxpLoA8Tmmv7oAtTGARvmct3g4 rO/l6gLUxgAahacAXfbE0eoC1MYAGoUBdNngndQFqI0BNMk/b1IXIE5bfKkuQC0M oEluP1NdgDjtx9tCTMMAmuTN3dUFiNO5t6oLUAsDaJIfu6gLEKfbzlEXoBYG0CS8 BuK2F3qrC1ALA2gSBtBtH22vLkAtDKBBzr9RXYB4bcUd5QzDABrkpn+qCxCvvf6n LkAqBtAg/z1QXYB4nXKfugCpGECDDOW+H467qo+6AKkYQIPwGojr7j1VXYBUDKBB GEDXPX+IugCpGECDMICu46LQpmEADcIAuu7zrdQFSMUAGoQBdN13G6kLkIoBNMfF 16kLELdthqoLkIIBNEe/C9UFiNvug9QFSMEAmuOBE9UFiNshz6sLkIIBNMczh6oL ELcTHlYXIAUDaI7Xe6kLELez7lAXIIVVA9i+8Uh1QpwG76guQNwuuV5dEKPOC8ap EwKzagAdx1uB3Xf1leoCpGAAzcFd0d137WXqAqRgAM3xVTd1AeLW72J1AVIwgOb4 emN1AeJ20wXqAqRgAM3xDe+Tct5/zlcXIAUDaA4G0H0MoGEYQHMwgO5jAA3DAJqD 5wDdx3OAhmEAjdH5J3UBYscFAQ3DABqj6wh1AeLHF5xZ+PMwBgPoA77gzMKfhzE6 jVIXIH58wZmFPw9jdBirLkD8+IIzC38exmj7u7oA8eMLziz8eRij2Qx1AeLHF5xZ +PMwBgPoA77gzMKfhzm4K6b7RnZRFyAFA2gOBtB9DKBhGEBzMIDu+3F9dQFSMIDm YADd9/2G6gKkYADNwQC6jwE0DANoDgbQfQygYRhAczCA7mMADcMAmoMBdB8DaBgG 0BwMoPsYQMMwgOZgAN3HABqGATQHA+g+BtAwDKA5GED3MYCGYQDNwQC6jwE0DANo DgbQfQygYRhAczCA7mMADcMAmoMBdN+33PvZLAygORhA943YVF2AFAygORhA9321 uboAKRhAczCA7vtiS3UBUjCA5mAA3Td0G3UBUjCA5mAA3ffJtuoCpGAAzcEAuu+D HuoCpGAAzcEAuu/9ndUFSMEAmoMBdN87u6kLkIIBNAcD6L4391QXIAUDaA4G0H0D e6kLkIIBNAcD6L5XDlAXIAUDaA4G0H3PH6IuQAoG0BwMoPuePkJdgBQMoDkYQPc9 fqy6ACkYQHMwgO67/2R1AVIwgOb4YT11AeJ22znqAqRgAM3xBZdKct71l6gLkIIB NMeH26sLELfL+6oLkIIBNMfAvdQFiNu5t6oLkIIBNMczh6oLELcTHlYXIAUDaI5b eILcefsMUBcgBQNojnNuURcgbpsNUxcgBQNojgNeUhcgbm0mqwuQggE0x0bfqAsQ N77eDMMfiDmKF6oLELORXdQFSMUAGoT3wrmOeyKZhgE0CAPoOq6GZRoG0CAjuqoL EK8b/6UuQCoG0CDPH6wuQLxOelBdgFQMoEEuuVZdgHhtM1RdgFQMoEG6jlAXIF58 uZmGPxGT8CqI2z7cUV2AWhhAkzCAbrvrDHUBamEATfIod4xw2hFPqwtQCwNokt3f VBcgTs1nqgtQCwNoksJF6gLEaOg26gLUxgAa5euN1QWID6dBm4cBNMq/blAXID5b fa4uQG0MoFFK56kLEJsRm6oLUAcDaBZOhHHXvaeqC1AHA2iWy69WFyAu232sLkAd DKBZuCiqs3gN2EQMoGE+6a4uQDy4J7qJGEDD7PmGugDx4CxoEzGApuFlEDe9dJC6 AGkwgKa5/Ux1AeLALdGNxACapskcdQFi8PlW6gKkwwAa56MtZpQ1W6lInYGIVJfP KmtRefM16g6kwwAap7j8z/9xe6c1V2tawp+QpSrnzZg07sVnl/2fwsJKbQ3S48vL fJd16dhm1SZ8S2iH6rJZf4wf88ogdQdywgBa5JZ12rdapaRQnYF0KuZOnzj+qdfU GQiGAbTQhet3XH3VJg3VGVisasGsyeN+eXGIugPhMIA2u3GdNVs3a8y3hMmrrpgz bcK4J/hB13YMoAvOX2/tNVZduSF/mLFbtGDGpF/HPseF/VzB14xTrl+nQ5vmjRuo M5xTXT57yoTfHuUHXef4MoBFbQvLpnl0JsK9ndZo2bTYlz/d2Cw5leX3O99TZySn aNWSqokefZ34MIB7H9p99dKlz5NVLZj81RsvzFYHJemqLh3aNl+JbwmDqS6bNeW3 3x4Ypu5IUrPee3ZrvewUg6r5vw/15Qatrg/gtv261361dMq7t3t4Zco712m3WtNG rv9x56li3rSJ42/9VJ2RuMLtz9ypZepfqhh6kRdfJW5/RRxxU9u0f332K5eOSzjF IA+svXrLlRupKwwydtLv/Tx+WaPjdb1WTvfXJ57/VNIpyXN5ANd9Zf3Mf/PHi15J rsREnU5ovvIqK69UWlpS3KioQQOXPxHS+KOsbP68ubPmzH3tw/L6f7XDCv923ToZ /+YP+/+cYIqEw5/3fS7PfoLctL63JlRigy0/Uxck5NZz1QUGKbrguqx/v+qaPsmE yDg7gIVv7Vrvr5l97b8TKLHD/i+rCxLyyGll6gRTFF12Zb2/5p3dqxIo0XF1AEu+ 7ZTLL5t53iNxl1ji5HvVBQl56cTp6gQzFJ18Zy6/bPRGTv8Lw9EBLPpp7Rx/5fij BsdaYqyi1LO9vLkf59vHTKz5f4uq3P4OJ5PCvV7P8Vf+0sXl8wIdHcDPt8j91w49 YHJ8IaZqNrfWZ/WtZ2tCEjf0iDEp/7+wSZmHL4N0emHTnH/tF1vGGKLm5gDee3KQ X73o/jM8+y6g6fw6/1Lvf5QiRODrQ3+s9VcKS8tc/h4njdJ7jw7yy+87Ja4QPScH sOebAf+xph/m02U9ms1Os/ev7ZN8iMSo3sPr/sUm5R59F1h40PPBPqB6D3e/PFwc wKJpTQN/zLv7zo+hxEjFlem+3x2yXeIhGhP+lu6dHul/U5zU+uXuQT9k9qrOfovs 4gA+GuZ9jGX/6B95iIlazE7/ufzBDgmHqIw/OO1b3Qqbzvfim8Ci024L8VGP/T3q DlM4OIAtpoS7Quine86MuMREhRm+03m/R7IdMuP+lv5db5l+Y9zS4fWNwnxY1Wqu njvk4AA+f3DID1x4kvvfBBZl+lnG+wEsKCxwfgKLT7sl5Ee+0DvSEHO4N4BNZoa/ +NMHezn+TGBJxpNaB+2WZIfQ2IO/zPB3nH8esO3rm4X90EXN5kZZYg73BvDG8/P4 4HkHvRVZiIFaTk//JV5ywjFbeHNnkd+evufX9H+nWZnLb3ooOiyfH3BuuiCyEKO4 N4CTWuf14U8EOkPKMsXpnucvPuukdd37NMhq6gv/HpPmLzv9rpCmT/XK58Mnt4kq xCzOfeav90OeB5i4w+hIQgzUekqdL/DC40/v6s33fjVU/97/9ol1/mqL+c5+C9j9 kzwPsH7t88fd4NwA3vePfI+w6Nw7oggxUJPaz+N0vWXHIkmJCapH9Xmh1nfEJZWO nu9Wcull+R7i/kDvrrKGcwM4rl3+x3h/DzdPCav1E/Dp/1pTFGKKOU/2nVDz/7v6 M3DrN7rlfYzx7SMIMY9rA1hUHsU/0Yydvo7gKMapeQ5My9sPLNGVGKPqywtqXA3I zTNhCnd/I4KjVBc7+d2xawO476uRHKbqX/+J5DhGaTV1xZd364f39PGZv7RGnT1w xf928UnA0qvyOS/iL/u9FslhDOPaAIZ6G1w67+7h3L/wmi1/p0vrx3oyfzWMPnvA n//LwYsitB4Y+uS/VG6+Hc61ARy+SVRHmrqtazeEKV12lnerp3Zx7U89b7+euezb G/deBenxflRHGpH7FQQt4tqXwrQWkR2q8h+OXS5/2dtAbjqH26Sn8fEJS07zcO3N ICUXRHeh7+mrRnYog7g2gJVRfnU/c3iEB9Nb8hrInk84+WkcgYo7r5jr2qsgLZ6r /85gOVvk5BlTjg1gUUWkhxu1pUsXiCmsavVK4EvBeeSPMwJeKNR0G3wX6eEauvb0 wBKODWDEf+QF83t+HO0BhVpPOf1mJ/8lHp0BJ80rd+Zl4KJDnoz2gBt+H+3xjODY AB4c9b/Dqy68KeIjynR4dmt1gvGmnufMFdFK+50Z8RF7vxDxAU3g2ABecm3kh3x9 fzeeFtrxjVJ1ggWq7jnfjW8BW78S+b/uLr0u6iMawLEBfODE6I/52+ZToz9o4q65 1LE/6rgMPcaF0582/yL6Yz54UvTHlHPsq+KpOF63XbD7kBiOmqy3eqoLrDHx6HfU CfkqOvLRGI769BExHFTNsQF86YA4jlp17u1xHDY5Tb5aV51gkXlnPaxOyE+Ta86J 47AvHxjHUcUcG8ABe8dzXLvPCGz1PSf/BVF52Q3qhHy0ei6e+7sMzOuKqoZybABj u7PF91vae7eQNb4Pfp9kvy3q20edEF7Up4Kt8LaLT6M4NoDx3dts5la2Pjfe4buV 1AnWqbrxInVCWHsPqP/XhDN4p7iOLOTYAL67c2yHruj9SmzHjlOrUSurEyxUdU0f dUIoxWfdGNux39sltkPrODaAr8f4NEX1VVfFd/DYNB0T3eUhfFJ56b/VCSE0veOY +A4+YJ/4ji3j2ACGvil6Tix8Gaxw9FrqBEstOOtBdUJgbV+K880+Tt4c3bEBfCzG fwEu9sMWtr0Uwvl/oU0+xrZ7RHcdEevhH4/qYsMmcWwA7zkl3uNP3yLd/WTNdd3F 6gKLfXOIXXeC7PV6vMe/99R4jy/h2ADG/gVfvrdNbxPYdohjf77JeuFwiy4AVXTa bTE/wvWXxPwACo59gZx2V9yPUH22PXcNLvmDF4DzUdXnGnVCzpr0Oz3uhzj97rgf QcCxAYz7p4Al7LlD9OAd1QWWm3acLXdCa/VE/E/27hPbGYZCjg3gRt8k8CAf7WjH BbIOelFdYL13DpqtTsjJuiMTeJCNv03gQZLm2ACWzkviUX7d1IYr5RdP5x0g+bLk fOhtP0riUVay7RSIXDg2gAVVifwDzdrSgvfFPefiaVtJG3/UYHVC/SK/Dnpa1U7e S9q1AVxQksjDWPBicIdfnPyETZr5twMvPjOZuzaUNU7kYRLm2gBOaZnM41Sdfm8y DxTaZ1uqC5zw+Vbqgnqcck9CDzR1tYQeKFGuDeBPnZN6pNtiuehkZLp/oi5wxDZD 1QVZ3Xp2Uo80sktSj5Qk1wbwgx0Se6g390zsoUIY0VVd4IivN1EXZPO/PRJ7qA+d PKnKtQF8/OjkHuvHbubeQGzTYeoCZ3Qbri7IqGTYesk9WP9432cv4toAnh/f5dDq mrLx5AQfLZCh3AM4Kp92Vxdk0vqbJJ+Wu8CZO2TX5NoA9ng/yUdbsK2h3x20mOra H6xOdcvp6oT0Ev4ufycLTggKzrWvk2TOhF6h8iAz3yv14AnqAoc8FMPNpiOw76vJ Pp6T50E7N4AFFUWJPlz1ebcm+ng5msubQKIzr4m6IJ1zbkn28SobJvt4CXFuAKcl fQX4e05L+AFzkMQ1ITxi4lUA7k764nzT3by1qnMD+M1GST/iW8mdiZCrIdupC5zy 0fbqgjre3D3pR/x246QfMRHODeB/k79vx/ebG3Y6TOHCZJ8HcF1lI8Mu/1Py5QaJ P+ZLByX+kElwbgAvvzr5x5y80dTkHzSLox9XFzjmmP7qghQtv22d/INeYc/FYYNw bgB3flfwoHO3NOruEVwINWIf9FAX1LTeD4pH3eU9xaPGzrkBLF6oeNSKPUz69Jjv 5HU7hBaUqgtqkPwrvqCgUbnkYePm3ACKvvqrjn9M8bBpdftKXeCczcx5Z+Gxj0oe 1qh/B0TIvQEcs5bmca/qo3ncuu6M/fY43rnrDHXBcn2u1Dzu2I6ax42bewMouxW4 MZfO/NHJ6xZJ/ZTgRQeyelR1c/JBiZ93kwz3BvD6i1SPPHgXM86WKHfznH2limJ1 wVKF78pejekX9x23RdwbwF3flj30yE1MOCEwkTuE+aazCTeBKRmR2OV+69jN+HtA hOPeAGpeBl7GiBMCL3PzhC2ty/uqC0Sn/y3n6IvADg5gwTzh61VzN9d/+/XuzuoC B723i7qgoPNPwgef7+rVNRwcwFGdhA9evusQ4aMvNWF1dYGDfl9DXbD9h8pHH72O 8tFj5OAAvrqv8tGrjnhW+fCLLTTjCXu3lDcSBxz6jPThX9tP+vDxcXAAL75O+/ji S4c3myF9eFc1nyl9+ERv9ZDGJddrHz82Dg6g/H5Ad56pfPSDn1c+urN6v6B89DvU J2IbfGeo/Dg4gAVV6n+oV/cXPvh1jp6wJXb9JcIHf0X9A2h1oTggNuqtiMOMZuqC z7etlD32SwfIHtplLyd/ncnlij7eUvbYf5rZXF0QFxcH0IB7go/ZSHYHmWGbqh7Z acO7qR659Fv923DNvjt8PlwcwP5HqQsKCqZtqLpl8Lh2ogd22/j2ogduPUn0wDU9 cbS6IC4uDuCJD6gLFpu3hegaqbOaah7XcbNX0Tyu5uqntZ30oLogLi4OoBH/ziyo 6Km5kTSXQoiF6HIIPd6XPGxtbVQ/z8TOxQE0ZAOqjnpa8rBO/pHKaV4HPfwpxaPW YcjFcOLg5FeLKU+DKU6JLqpI/jG90FDwwr769OflZE+Axs/JAXx7V3XBn247J/GH XGN84g/ph3YTEn/IW89O/CHTe2c3dUFsnBzAq65QFyz3Qu+kH3HroUk/oie6f5r0 Iz5/cNKPmMnVouvwJ8DJAez+ibpghU+2T/gq0T3fSvbxvLH7oGQfr3DINsk+YBbb uPtvVScHsLDSnH+sn7sme5Xog15M9OH88bf/JvpwJV+vm+jjZVNdZMa9HuJgzlJE Sf9muL/8senEJB9OdNdE9/090fueth3eKsmHy87dN8K5OoBfbqYuqKF68yQvT3Pc wwk+mE+OfyTBBzPr1s5fba4uiI+bA3jfP9QFKZL86Ul84Ux3HZbghW4Nex7j/pPV BfFxcwAN+wRK8oRALgcYkwQvCGjK6X/LJfz0Z6LcHMDSeeqCWm5I7GbFew9I6pE8 02tgUo/U78KkHilHK8kubRQ/NwewYK5pN7FK7N3knAYTk8ROgzHiWh41zWuiLoiR owP43Qbqgtr6XJXM42hvHuawHRK63d+VfZJ5nNx9v6G6IEaODuBjx6gL6kjomWTe CRKThN4JYtjrd0s8fqy6IEaODqCJr4Umc6cQM64F5qBkrgglv/tHGkm+/p04Rwew ZIG6II2h2yVxQn11Ao/hoyS+Ugo/6p7AowTVONn3MiXL0QE05JKAtYzcJIFPpUXO 3sBLqqpB/I9RMqJz/A8SmMMXAyxwdwB/0d9IJo1JG06P/THKGsX+ED5aWBL7Q7T4 rk3sjxHCmLXVBXFydQDvPlVdkNasTX6N+yFmim5e4bhZsb+9vMPYuB8hnHtOUxfE ydUB3PYjdUF6C7YdHvMjGPnDv/1i/0Fw0yTfMR7Edh+rC+Lk6gAa+1pAxV7vxPsA PAcYi7ifA9z17XiPH56zE7GUs/90C+J/ziacqqPjvdFNRVGsh/dVZbzfWB/xZKyH z0NZY3VBrJwdwO/XVxdkdN4tcR59vtufsCoLSuM8+rk3x3n0vPxg3JuqIuXsAF5+ tbogsxv/FePBTboYrENivSjovy+I8eB5uuIadUGsnB3AkrkJnLgVVv8Y36k3fo34 ju2xCTHeavXxo+M7dr4WNXH5NGiHB7Dg97bqgize7hnboYdtGtuhfTa8W2yHHmTy TScnrq4uiJe7A/jOLuqCbEZsEdd9to25KbJbYrs1btEXm8R05Ei86/ink7sDaN5l hVKM3TCmq0z2Pyqe43ruiZh+TC39bq14DhyRpC7jpuLuAK73g7ogu6kb/hHLcQ0f flvFNAStvmsZy3Ejs/6P6oJ4uTuAxp8QN3fT0XEc1rT7oTginvtidBoVx1EjFPPp j3oOD+C4GF+3i8TCHT6P4ahrjI/hoGg3IYaDbvlZDAeN1Pj26oKYOTyAr/dSF9Sn cv84brRTafD5P9ZaFMePExbcwGrAPuqCmDk8gOfE+oaLSFQd/1j0B53WIvpjem/6 qtEf89hHoz9m1M69VV0QM4cH0IqfBS/8d+SHHG70aRWWGhH92ZX/uiHyQ0Yvlp/8 TeLwANpxadBbz436iA8fF/URUfDI8VEf8ZZzoj5iDBK4DKyYywM4qpO6IBfPHB7x AQ9+PuIDoqCg9wsRH/DpwyI+YCxGr6MuiJvLA/jsIeqCnLwX8VtWistc/kPVqC4p j/aA7+4c7fFi8tyh6oK4ufy1clR/dUFuvt482rfF8SpI5CJ+DaToy66RHi82Rz+h LoibywNo5L0x0/ltw7lRHm7wjlEeDYt90CPKozX5bs0oDxcjp++IuZTLA2jPpfGm bRDl2+IMvrqmrSK9hm2rRG6xHoVYL4JoBqcH8ONt1AW5mrvZz9EdrNmM6I6FpZrP jO5Y646M7lgx+2RbdUHsnB7Aay5TF+RsYY9PozvY1BjO2vXatAivWLD10OiOFbe+ l6sLYuf0AHb+SV2Qu0UHvhbZsV7ZL7JDYYlX94/sUPu+Gtmh4tfFnm9Ww3J6AAsW xn0z1whV/+PBqA5l1ReZDfaL7F9OJz4Q1ZESUG7DOwny5PYA2nEq9HLR3X6Gm6NH Krqbopt8q6663D8N2vUBfOJIdUEg954a0YG+2DyiA2GJL7eI6ED3nBLRgZLxpAcX F3d7AA94SV0QzCsHRHOc0++M5jhY6oy7ojnOy9E9lZiIA19WF8TP7QEsKrfsn2/o dlVRHKZ4QWEUh8FSVY0jeR9c4UfdozhMcqqL47pxl0EsG4igJrVWFwQ0cpNIzr3/ ZqMojoKlvt04iqOUjOgcxWESNLmNuiABjg/gwL3UBUFN2nB6BEc58/YIDoJlzroj goO0+M66OXljb3VBAhwfwFPuURcENnvTMfkfpGiB4XeEskhl4wh+Euz4S/7HSNqp 96oLEuD4ADadpS4Irmz7L/M/yIfb538MLDVkh/yPsfkX+R8jcavMVhckwPEBLJi5 iroguMp9/5f3MXZ9O4IQLLHbO3kfYs83IuhI2ixbLiWSF9cH8CMb385ddeIjeR/D xuU3UgQ7cNzDEXQk7uPt1AVJcH0A7Tr1foXL++Z7BO4MEpH87wZyWWTv8ElUdG9M MpnrA9j+N3VBOPefnOcB2k5w/Y82GdVrTMzzCPf9I5KQxK05Tl2QBOe/SuaVqgvC GZjvbd25O2Yk8r4f5gBLTyaZv5K6IBHOD+BX3dQFIQ3bKr+zL3gZJBJ5vgRS9Jm1 n3+bqQsS4fwAXn+RuiCsfO8UMtG6M28NNKltXh9uz90/6uh3sbogEc4PYKdR6oLQ pm+U19NP/7wpqhCPnf+ffD667e9RdSRvndHqgkQ4P4AFC+y9uf2C7l/n8dGF8+z9 JzdF2Ur5XJyi64jIQhJX1lhdkAz3B9DmFwPyOyXasqvPmSivKzRaefrzcnm/+GMJ 9wfwpn+qC/JQfep94T+4eI5FdwQwUvnKeVwI62Sr30r7n/PVBclwfwDX+0FdkJfr Lwn/sXwLmKd8vgG8zu4XEdb/UV2QDPcHsKDM7lu7PHN46A8tmsOzgPkoWzn8mUhP HxZhSPIW+vKZ48EA2n5x0I93CP1EfJ8rowzxzlV9wn5k4Yc2vge9hmguAmsBDwbQ 6icBlxjddX7YD53hxRU9YjKzediPLP3aqtsRpuHLU4A+DKBNt0dPb9omE0J+5MHP Rxril94vhPzANcZH2qHgwS3Rl/FgAAvmW39K04LthoX8yBFdIw3xyddhz5/q9lWk HQoLLH0HfXA+DOCX9r+rsfLgV8J9YIdfuD9cOFVr/xruA/d34GaSX3lzY2kfBvCa y9QF+as+79ZwH/jvC6IN8caN/wr3cefcEm2HRN/L1QVJ8WEAbb0mYKo7zwz3cePa RdvhifHtw33cHWdE26Hhx7UAl/BhAAvmNFEXRCHkXQrX+44fgoOr2jDcicD23Yc1 nbkrqwsS48UAftJdXRCJHzcPdTrM+TdGHeKBC0JdSqf0y/WiDpEYuo26IDFeDODF 16kLojGtW6ifTKy8MZRWuBsCufFcy2KXXK8uSIwXA9hyirogImU7Dw3xUSUTWkRe 4rbpa5SF+Kjun0QeIrLaVHVBYrwYQHfeEFH19/4hPqrjTw0jL3FZRZcxIT7q6Mcj DxEJ/xYY+/gxgO/soi6IzLVhzunp9Zoff87RqN53QIiP6ntp5CEq7+6qLkiOH18Y dl+aLdWr+4f4oNPuirzDXaffHeKDXtkv8g6ZU/K4CKVt/BjA0rkO/XOGejHYldeB EhDmFQBXXv5dqrpJ6Itv2MehYchmUmt1QYSmbxHiKSqHfkKLV5jnGDr+En2HzmSf bifoyQD+90B1QZTK9w5xs1on3qIVu1BvOXTsFswvHaQuSJAnA+jCG9RrqD77juAf dOgz0Ye4puqIZ4N/0Jm3Rx+idEDIC29YyZMBLKxw7P1gjxwf/GO2/Cz6DrfM2fXz 4B/08HHRhyhVNcznVqC28WQAC8aspS6I2FfbBL9hWZMhFt8iNAEjtp8b+GOKP7H/ YmupxnZUFyTJlwF8KMR3TGabukWI69X1uzD6EFdU3XhR8A/q8EXL6Eu0Hj5BXZAk XwZw6zDvITNb+YEDg39Q+/9tEH2JE77fM8QbrfcOc8q04bp/qi5Iki8DWLDQvZuE V18T5qZvLp0UHp3Z/wpz8u9VV0QeIldu911kg/JmAIe7+PTX23uEeb76XzdEHmK5 2df+O8RHFb65W+QleiM2VRckypsBdPFf1gUFv28xMcyHnXLeulGXWOznm0N9U9z2 i9WjLjHB1X7dS9qbAWw9SV0Qi4X7vRXmw7qOiDrEYpt8Heajdn8z6g4ztJmsLkiU NwPoziWxUlXfcHGIj7o+xAuezurH7+BffLoU1hL+DOAgF5+wWeKTnYKfEejITQKi EeIC8MXvu3rR+Ld7qguS5c8AHvuouiAuM7b/PuiHzFwljhBLzQr8s8EG38XRYYS/ P6YuSJY/A1hc5uw/66IzAj6L32xGPCGWaj4z2K8/5Z54OgxQXRL8xwmrOTsKdbl8 g9w39qsM8su5MkyKcwNdAaboVSdufZle2NshW8ujAXzsGHVBjKbsGOQ+tu/3iC3E RoN3CvCL1/tgtbg6DPD4seqChHk0gO7ctCudRRf+J/dfzFOAKYI8CfjPUDcMtsY2 7r1lNDuPBrCgzO03+XzcM9crmbeYFmuIfVadnuMvLB3k9j2WF5aoC5Lm0wB+1U1d EK95Bw7K7Rdecm28Ida5NMc7pvQMdda5RYa5dm2vevk0gJddoy6IWfWTx+b03mAn 3xedj9ze/1r42FFxh6hd3lddkDSfBtCDn/ym7DEsh19Vzn3SU1Xkcqmgbm+6/OrH Mjk/F+AMnwawYOqq6oLYVT90Ur2/5uDnEwixS+8X6v0lD5yYQIfYNOeu7lovrwbQ pZtXZzTlgI/r+RWDd0wkxCYf1Hde0LYvu//tX0HBq/urCxLn1QA6dm+4DKpfPizr 2fyFZfwEXFtFSdYnT4ufceq2qhl5dT+4ZbwawMLyBuqERMw7tX+Wv8slodM4JdsF oY9+PLEOqUXFPt0PbhmvBrDgp87qgoR8f+DIjH/PuRvkRWH0Ohn/VueXfLmNysgu 6oLk+TWAN5+rLkhK9UtHZzgt2uErmeRjwwxX1Cntf1CyIUK3nKcuSJ5fA9hhrLog OeW3X5j2BxouBZhW+osCFt5wftIhQmuFuNGq7fwawIJZTdUFCZrXL81prXwDmF71 Rmm+BbzsopWSL5GZ7eM7xD0bQGcvC53e3Lsuq32ZrGpJiAV+XL/WXyjqe3oTSYmK bxeDXsqzATziSXVBwipePzfl5xquBJhR6lUBO9yyj29nCx35lLpAwLMBLKwoVCck buxdd5Yt/99uXxIsP1XbrbgUVMkZp68lLNGoaujfSTDeDWDBqE7qAoHqX/731NK3 h5x0vzrFZJWnPbDkv7Y9Ys+1ffuyWCLLmUAO8+1P+vYz1QUiVQsa+/fNb1AVs6ob l/r623THWeoCBd8GsNModQFgpHVGqwsUfBvAgtkrqwsAA83x6Qyxv3g3gO/soi4A DPTuruoCCe8G0Jc3tgOBHJPtAhru8m4Aixb6+iQ3kFlVo0B3lnaGdwPo54kwQHZ+ ngTj4wDeera6ADDObeeoCzT8G8COv6gLAOOsPUZdoOHfAPp1RRggF15eCWYJDwfw LR8vegFkM2h3dYGIhwN4uI8XvQCyOeJpdYGIhwPoy62RgFz5eDukZTwcQH9ujQTk xsfbIS3j4wDe6NN9HoD63XSBukDFxwFs/5u6ADDKmuPUBSo+DmDBjGbqAsAgM5ur C2S8HMDXe6kLAIMM2EddIOPlAO7/sroAMMgBr6gLZLwcwIKKInUBYIxK3+5/V4Of A/jNRuoCwBjfbqwu0PFzAPtcqS4AjHFVH3WBjp8D2HKKugAwxmpT1QU6fg5gwR+r qQsAQ0xppS4Q8nQAnz1EXQAY4rlD1QVCng7gjoPVBYAhenygLhDydAALyhqpCwAj LCxRFyj5OoCfbakuAIzw+VbqAiVfB/Cs29QFgBHOvl1doOTrAJbM9/WfHKipurRM naDk7Qz8uqa6ADDAbx3UBVLeDuDdp6oLAAPcc5q6QMrbAVx3pLoAMEDnn9UFUt4O ILcHBjy+IfCf/B3A/+2hLgDk3txTXaDl7wAe9KK6AJD723/VBVr+DiBXRQV8vhbq Uh4P4NceXwYSWOqbruoCMY8H8PKr1QWA2BXXqAvEPB7AZjPUBYBY85nqAjGPB7Bg Yht1ASA1qa26QM3nAXzsGHUBIPX4seoCNZ8HcNNh6gJAqttwdYGazwNYMHcldQEg NK+JukDO6wF8byd1ASD0/s7qAjmvB/CIJ9UFgNCRT6kL5LwewMLyBuoEQGZRcZU6 Qc7rASz4fn11ASDzwwbqAj2/B/Cay9QFgEzfy9UFen4PYMsp6gJAZrWp6gI9vwew YHIrdQEg8kdrdYEBPB/Apw5XFwAiTx+hLjCA5wO49VB1ASDS/VN1gQE8H8CC+Y3V BYDEglJ1gQl8H8APt1cXABJDdlAXmMD3ATzuYXUBIHH8I+oCE/g+gEULC9UJgEBV o0p1ggl8H8CCnzqrCwCBkV3UBUbwfgD7XaguAARuuEhdYATvB7D1JHUBINBmsrrA CN4PYMGUluoCIHFTV1MXmIEBfK63ugBI3POHqAvMwABu+5G6AEjcdh+rC8zAABYs KFEXAAkr4x1QyzCABUO2UxcACfuId0AtwwAWnPiAugBI2EkPqgsMwQDyZhB4h7eB LMcA8mYQeIe3gSzHABYUXM858fBLv4vVBaZgAAsKWnFOPPzS+g91gSkYwMX+4Kx4 +GQKt8JZjgFc7OnD1AVAgp7hVjjLMYAF3BkEnuFuICswgEtwZxB4hLuB/IUBXGLw juoCIDEf9FAXmIMBXOLYR9UFQGL+/pi6wBwM4BL/ukFdACTmwn+rC8zBAC5RvFBd ACSmUbm6wBwM4FKcCQhvcBZgDQzgUpdcqy4AEnLpdeoCgzCASxVVqAuAhDTkSjB/ YQCXmd5cXQAkYkYLdYFJGMBl+l6qLgASce1l6gKTMIDLFC5SFwCJaFClLjAJA/in WU3VBUACZq+iLjAKA/in4x9SFwAJOOFhdYFRGMA/FVZwZxC4r6ohPwHXxAAuN6Kr ugCI3debqAvMwgAud/hT6gIgdkc8rS4wCwO4QhW/F3BdNU/0pOKLfoXf26oLgJhN XF1dYBgGcIUL+6kLgJhdxIXfUjGAf6lWBwAx4+u9Fn5D/sKdQeA47gZSGwP4lzd3 VxcAsXprD3WBaRjAv/R4X10AxGqnweoC0zCANVQ2UBcAMVpUpC4wDgNYw5i11AVA jMZ2VBcYhwGs4Ykj1QVAjJ48Sl1gHAawhr0HqAuAGPUaqC4wDgNYA1eEgcu4Ekxd DGBN49qpC4DYjG+vLjAPA1jTc73VBUBsnj9EXWAeBrCmA15SFwCxOfBldYF5GMCa isr5/YCrqou5IXAdfMGnmMDVguCq39dQFxiIAUzx0gHqAiAmLx+oLjAQA5ji0GfU BUBMDntWXWAgBjAFTwLCVTwFmA5f76m4Lj4cxdXw02EAU81eWV0AxGIQl7tMgwFM xQVh4KbqJvPVCSZiAFPdco66AIjDtJbqAiMxgKnWGK8uAOLwdk91gZEYwFqmrqou AGJw+t3qAiMxgLU8yxvG4aJVZqsLjMQA1rL1UHUBEL0ZLdQFZmIAa+PuwHDQ4J3U BWZiAGt7v4e6AIjc+f9RF5iJAaztqP7qAiByq05XF5iJAayNG4PAPbNXURcYigGs 46fO6gIgYh9try4wFANYx43nqwuAiF1yvbrAUAxgHbwZBM5p/Ye6wFAMYF2zmqoL gEjN5SJHGTCAdb27s7oAiNTQbdQFpmIA6zrpfnUBEKnL+6oLTMUA1lUyn98VOGX1 ieoCU/GlnsYfq6kLgAjxFGBGDGAaA/ZWFwAR4inAjBjANE58QF0ARIinADNiANMo nacuACLUZrK6wFgMYDrTm6sLgMjwRuDMGMB0PthBXQBEZgifzhkxgOlccq26AIgM 1wLMjAFMh7cDwyHNZ6oLzMUApsV18eEMbgeSBQOY1jcbqQuAiAzaXV1gMAYwrbtP VRcAETnhYXWBwRjAtLb/UF0ARKO6pFydYDAGML3KBuoCIBKT2qoLTMYApje2g7oA iMQLvdUFJmMA03vqcHUBEIn9XlMXmIwBTG/fV9UFQBSqGlapE0zGAKbH3YHhhjFr qwuMxgBm8Ft7dQEQgYdOVBcYjQHM4OnD1AVABLp/qi4wGgOYwe5vqguA/JU3UheY jQHMpKJIXQDk7duN1QVmYwAzGbmuugDI2w0XqQvMxgBmcvuZ6gIgb2uPUReYjQHM ZL0f1AVAvuY1URcYjgHMaF6pugDI00fbqwsMxwBm9El3dQGQp7NvVxcYjgHM6Pwb 1QVAfqqbzlUnGI4BzKjpLHUBkJ8prdQFpmMAM5vJ7VRht8+3UheYjgHM7PmD1QVA Xnq/oC4wHQOYWc+31AVAXhpwKax6MIBZLOKSWLAZZwHWiwHM4tc11QVAHt7dVV1g PAYwi2suUxcAedjqc3WB8RjALFpNVhcA4VXzFE69GMBsFharC4DQZjZXF5iPAczm i83VBUBozx2qLjAfA5jNQS+qC4DQVp+oLjAfA5jVlJbqAiCkqgbqAgswgFm9eJC6 AAhpcht1gQUYwKwOfl5dAIR0J9c0rx8DmFVROb9BsFTjMnWBBfj6zm7C6uoCIBTe B5cLBjC753qrC4BQnj9EXWADBjC7A15SFwChHPiyusAGDGB2hRW8nQg2qmrIpbBy wADW47f26gIghHFcyigXDGA9njpcXQCE8PQR6gIrMID12HuAugAIoddAdYEVGMD6 VPKGIthnUZG6wA4MYH3GrKUuAAIb21FdYAcGsD6PHaMuAAJ7/Fh1gR0YwPrs+ra6 AAhst3fUBXZgAOtVwbMpsE1lQ3WBJRjAeo3qpC4AAhq9jrrAEgxgvR48QV0ABPTQ ieoCSzCA9dr+Q3UBENAOQ9QFlmAA61fO8ymwSwW3M8wRA1i/nzqrC4BARnZRF9iC AazfPaeoC4BA7j1VXWALBrB+W36mLgAC2epzdYEtGMAcLOQZFdikvJG6wBoMYA6+ 20BdAATw/YbqAmswgDm45Rx1ARDAreeqC6zBAOZgvR/UBUAA6/+oLrAGA5iLBSXq AiBnZY3VBfZgAHMxbFN1AZCz4d3UBfZgAHPR91J1AZCzay9TF9iDAcxF+9/UBUDO 1hynLrAHA5iTuSupC4AczWuiLrAIA5iTT7qrC4AcDd1GXWARBjAnF1+nLgBydMn1 6gKLMIA5aTVZXQDkqPUf6gKLMIC5mbmKugDIyaxm6gKbMIC5eb+HugDIyeCd1AU2 YQBzc+bt6gIgJ2fdoS6wCQOYm6az1AVATlaZrS6wCQOYo6mrqguAHExrqS6wCgOY o//toS4AcvDmnuoCqzCAOTruYXUBkIPjH1EXWIUBzFHJfH6rYL7q0jJ1glX4qs7V xDbqAqBek9qqC+zCAObqxYPUBUC9/vs3dYFdGMBc7f+yugCo1wGvqAvswgDmqrCi UJ0A1KOqYZU6wS4MYM7GrKUuAOoxtqO6wDIMYM4ePk5dANTjkePVBZZhAHO2/Yfq AqAeOwxRF1iGAcxdeUN1AZBVRbG6wDYMYO6+X19dAGT1wwbqAtswgLm79Wx1AZDV beeoC2zDAOZuvR/UBUBW6/+oLrANAxjA/MbqAiCLBaXqAuswgAF8uZm6AMjiq83V BdZhAAPoc6W6AMjiqj7qAuswgAG0/V1dAGSx+kR1gXUYwCBmr6wuADKa01RdYB8G MIgPdlAXABl9uKO6wD4MYBBn3aYuADI6m3u3BsYABsHNMWEwbogZHAMYyBTuOQhT TV1NXWAhBjCQ13upC4AMBuyjLrAQAxjIEU+qC4AMjnxKXWAhBjCQonJ+w2Cm6uJK dYKF+HoOZlw7dQGQ1vj26gIbMYDBPHGkugBI68mj1AU2YgCD2fVtdQGQ1m7vqAts xAAGVFGkLgDSqOSGDWEwgAH91FldAKQxsou6wEoMYEB3nKEuANK480x1gZUYwIA2 +kZdAKSx8bfqAisxgEEtKFEXAHWUcbuGUBjAoLguPgzE1fDDYQCD4rr4MBBXww+H AQyK6+LDQFwNPxwGMLBZXHgcppm9irrAUgxgYIO58DhM80EPdYGlGMDAzuTC4zDN WXeoCyzFAAbWZI66AKhl5bnqAksxgMH9waXHYZYprdQFtmIAg3tlP3UBkOLV/dUF tmIAgzv4eXUBkKL3C+oCWzGAwRVWFKoTgBqqGlapE2zFAIYwZi11AVDD2I7qAmsx gCE8dLy6AKjh4RPUBdZiAEPYeqi6AKih+6fqAmsxgGEsLFYXACuUN1IX2IsBDOPr jdUFwArfdFUX2IsBDOP6i9QFwAr9LlYX2IsBDKPDWHUBsMJav6oL7MUAhjKniboA +NPcldUFFmMAQxmynboA+NNH26sLLMYAhnLOLeoC4E/n3qousBgDGErTWeoC4E+r zFYXWIwBDGdKS3UBsNRUrs6WBwYwnFf3VRcAS73G1dnywACG0/s5dQGw1CFcnS0P DGA4XBILZuBSWHlhAEMa20FdACz261rqAqsxgCE9fJy6AFjsEa7Nlg8GMKTun6gL gMW24dps+WAAw+KSWDAAl8LKDwMY1giuQQS9rzdRF9iNAQzrOq5BBL3rL1EX2I0B DGuN8eoCoKDdBHWB3RjA0GZzFSKozWmqLrAcAxja+z3UBfDe4J3UBZZjAEM77S51 Abx3+t3qAssxgKGVzuU3D1rVTearEyzH13B4k1qrC+C5yW3UBbZjAMN78SB1ATz3 37+pC2zHAIbX63V1ATy3zwB1ge0YwDxUNlAXwGuLitQF1mMA8/DzOuoCeG3UuuoC 6zGAebjzdHUBvHbXGeoC6zGAedjoG3UBvLbxt+oC6zGA+ZjfWF0Ajy0oVRfYjwHM x+dbqAvgsS+2VBfYjwHMxyXXqgvgsUuvUxfYjwHMR8sp6gJ4bLWp6gL7MYB5md5c XQBvzWihLnAAA5iX/+2hLoC33txTXeAABjAvR/VXF8BbRz+hLnAAA5iXonJ+A6FR XVypTnAAX7/5+a29ugCeGremusAFDGB+HjtGXQBPPX6susAFDGB+tv1IXQBPbfex usAFDGCeFharC+Cl8kbqAicwgHn6ZiN1Abz07cbqAicwgHm6/iJ1AbzU72J1gRMY wDy1/01dAC+tOU5d4AQGMF+zV1YXwENzmqoL3MAA5mvwjuoCeOiDHuoCNzCA+Trt LnUBPHT63eoCNzCA+Sqdy+8hklbdZL46wQ188eZtYht1Abwzqa26wBEMYN6eP1hd AO+80Ftd4AgGMG97D1AXwDu9BqoLHMEA5q+ygboAnllUpC5wBQOYv586qwvgmZFd 1AWuYADzd/uZ6gJ45o6z1AWuYADz1/kndQE802WkusAVDGAE5pWqC+CV+SupC5zB AEbgk+7qAnhl6DbqAmcwgBH4503qAnjl/P+oC5zBAEag6Sx1Abyyymx1gTMYwChM aakugEemrqYucAcDGIVX9lMXwCOv7q8ucAcDGIWDXlQXwCN/+6+6wB0MYBQKKwrV CfBGVcMqdYI7GMBIjOqkLoA3Rq+jLnAIAxiJe05RF8Ab956qLnAIAxiJriPUBfDG Jl+rCxzCAEZjQYm6AJ4oa6wucAkDGI3Pt1AXwBNfbKkucAkDGI1LrlUXwBOXXqcu cAkDGI2WU9QF8MRqU9UFLmEAIzKthboAXpi+qrrAKQxgRAbupS6AF97YW13gFAYw Ikc8qS6AF458Sl3gFAYwIkULeTcc4lfVqFKd4BQGMCpjO6gL4IFf11IXuIUBjMqD J6gL4IGHTlQXuIUBjMrmX6gL4IEtvlQXuIUBjExZI3UBnLeQt1xGiwGMzFfd1AVw 3rDN1AWOYQAjc/nV6gI474pr1AWOYQAj02qyugDOa/2HusAxDGB0pjdXF8BxM3jD ZcQYwOj8bw91ARz35p7qAtcwgNE5qr+6AI47+gl1gWsYwOjwbjjEi/fBRY4BjNCv a6oL4LTfeLtl1BjACD10vLoATnuYt1tGjQGM0JafqQvgtK0+Vxc4hwGM0iKeBER8 qhqoC9zDAEZpwurqAjjs9zXUBe5hAKPU70J1ARx2w0XqAvcwgJGa0lJdAGdNXU1d 4CAGMFIvHaAugLNePlBd4CAGMFL7vqougLP2e01d4CAGMFqVvFCHeCwqUhe4iAGM 1o9d1AVw1E/rqQtcxABG6+Zz1QVw1C3nqQtcxABGq+Mv6gI4au0x6gIXMYARm72y ugBOmtNUXeAkBjBi7/dQF8BJg3dSFziJAYzYSferC+CkfzygLnASAxix4jJ+SxG9 6pJydYKT+GqN2rh26gI4aHx7dYGbGMCoPXaMugAOevxYdYGbGMCobT1UXQAHdf9U XeAmBjByZY3UBXDOwhJ1gaMYwMh91U1dAOcM20xd4CgGMHKXXaMugHMu76sucBQD GLkW09QFcM6q09UFjmIAozethboAjpm+qrrAVQxg9AbsrS6AYwb2Uhe4igGM3qHP qAvgmMOeVRe4igGMXtFCbg+MKFU1qlQnuIoBjMGYtdQFcMrYjuoCZzGAMXjwBHUB nPLQieoCZzGAMdj8C3UBnLLFl+oCZzGAceDdcIgQ74OLDwMYh2GbqgvgkOG8uTI2 DGAc+lypLoBDruqjLnAXAxiH1pPUBXBIm8nqAncxgLGY0UxdAGfMbK4ucBgDGIu3 eqoL4IxBu6sLHMYAxuLYR9UFcMbfH1MXOIwBjAX3hkNUuB9cnPg6jQf3hkNEuB9c nBjAeDx+tLoAjujPbQZjxADGY/sP1QVwxA5D1AUuYwBjUt5QXQAnVBSrC5zGAMbk m43UBXDCtxurC5zGAMak34XqAjjhhovUBU5jAGPSYay6AE5Y61d1gdMYwLhUqwPg BL5CY8Vvb1w+3kZdAAd8sq26wG0MYFz+eZO6AA44/z/qArcxgHFpNkNdAAc0n6ku cBsDGBueBET++AKNF7+/sRm4l7oA1ntjb3WB4xjA2BzVX10A6x39hLrAcQxgbIoq 1AWwXsNKdYHjGMD4jF9DXQDLTeCqajFjAOPz9GHqAljumcPVBa5jAOOz5xvqAlhu r/+pC1zHAMaIE2GQH74848bvcIxGdVIXwGqj11EXOI8BjNEDJ6oLYLUHT1IXOI8B jNGWn6kLYLWtPlcXOI8BjBNPAiIffHXGjt/iOH27oboAFvuO2yrEjgGM043nqwtg sZsuUBe4jwGMU6dR6gJYbJ3R6gL3MYCx4klAhMcXZ/z4PY7VJ93VBbDWUG6qED8G ME4tH9lHnQBrvX7cVHWC+xjAWJ11m7oA1jr7dnWBBxjAWO09QF0Aa/UaqC7wAAMY q67/5e3ACGf0QV+rEzzAAMaq6X1cExDhPHPybHWCBxjAeJ10v7oAlvrHA+oCHzCA 8dr9TXUBLLXHW+oCHzCA8VrvBd4OjDC+O/hHdYIPGMB4Fd9+sjoBVrrvrHJ1gg8Y wJgd/bi6AFY6httKJ4EBjFmP99UFsNJOg9UFXmAAY9bx6a3VCbDQp4ePUSd4gQGM 2/UXqQtgoX4Xqwv8wADG7dBn1AWw0GHPqgv8wADGrfsrrdQJsM4f+w9VJ/iBAYxb 6/491QmwzqCjJ6sT/MAAxu78G9UFsM4FN6kLPMEAxm7fV9UFsM5+r6kLPMEAxo5L YiEoLoWVFAYwdqX3Hq1OgGX6nzJfneAJBjB+J3JdIwRz0oPqAl8wgPE77S51ASxz +t3qAl8wgPFjABEQA5gUBjB+DCACYgCTwgBGpeluPTfr1KyBOgMO++yrQW9zo5BI MYARKNroyJ27NFFXwA9fvvfkt5XqCGcwgPnqePp+66ob4JmfX72Lq2VFggHMR/Fe p/NGX2gMuusNLpqfNwYwvK5991UnwGuvXcYbRvLEAIbU4rKjVlM3wHtTnug7Xd1g NQYwlM538qMvzDDojJHqBIsxgCF0fnAHdQKwwocnMoFhMYCBtXqQp/5gltdO/EOd YCkGMKDSC/qoE4A6+tzI9WPCYACD4eJ+MBOXEAyFAQyi5Pxr1AlABpffVKZOsA8D GECLx/ZRJwAZvX4sp8QExQDmrtOgjuoEIIsxPUerE2zDAOZs7wHqAqAevQaqCyzD AOao6JiH1AlAvU54nCvFBMEA5qbw7+wfbHDCo1XqBJswgDlh/2ALFjAIBjAX7B/s wQIGwADm4oCX1AVAzg58WV1gDwawfiXnXatOAAK49GZOic4RA1i/riPUBUAgm/C2 uBwxgPVq/5u6AAhozXHqAkswgPVpctcx6gQgoMdPn6tOsAMDWJ/d31QXAIHt8Za6 wA4MYD06jFUXACGs9au6wAoMYHZN7j1SnQCE8OQp/BCcAwYwu31fVRcAoez3mrrA BgxgVmuMVxcAIbWboC6wAAOYTfGlV6gTgJCuvrZcnWA+BjCbdbndIOzV+Wd1gfkY wCyaPr23OgEIbeDhs9UJxmMAs9h6qLoAyEP3T9UFxmMAM2v9RTt1ApCH8VtMVieY jgHMjPeAwHK8H6Q+DGBGnAID63EqTD0YwEyKzrxZnQDk6bw7uEdSVgxgJh1/URcA eVt7jLrAbAxgBqV3HK9OAPL28Jnz1QlGYwAz6DRKXQBEYJ3R6gKjMYDpld53lDoB iMATJ/MtYBYMYHpcBhCO4MKA2TCAaRX3vUCdAETixsu4JkJmDGBarSepC4CItOHt IJkxgGnxJhA4g7eDZMEAptP0v7uqE4CIvHMQF4XJiAFMh3Ng4BDOhMmMAUyj2fub qBOAyIzYaaY6wVgMYBpcBgFO4ZIIGTGAafA2YDiFNwRnxACm0e0rdQEQoc2GqQuM xQDW1eLTddQJQIRGbT1dnWAqBrAungKEY3gSMBMGsC7eBwzH8H7gTBjAurqOUBcA kdrka3WBqRjAOpoO2kqdAETqs568GSQ9BrAOLoQA53BBhAwYwDra/6YuACK25jh1 gaEYwDp4DQTO4VWQDBjAOnZ+V10ARGyX99QFhmIAa2s2tIs6AYjYT925HkJaDGBt bX9XFwCRW32iusBMDGBtvAYCB/EqSHoMYG28BgIH8SpIegxgbbwPBA7ivSDpMYC1 NP2Aq0HDPSN25L0g6TCAtfA+EDiJ94KkxQDWwrWw4CSuiJUWA1gLLwLDSbwMnBYD WAsvAsNJvAycFgOYqvS5XuoEIAYDDpmvTjARA5iq5ferqROAGEzZYKo6wUQMYCre CAdH8Wa4dBjAVLwIDEfxMnA6DGAqXgOBo3gVJB0GMEXhoU+pE4BYHPFslTrBQAxg iqafbKBOAGLx/Ta8Ga4uBjBFK94vBFe1/kNdYCAGMAUvAsNZvAycBgOYgheB4Sxe Bk6DAUzR4311ARCTnQarCwzEANZUfPWF6gQgJjdcUa5OMA8DWFOLb1ZXJwAx+X3j 6eoE8zCANfEiMBzGy8B1MYA18SIwHMbLwHUxgDXxHSAcxneAdTGANfEdIBzGd4B1 MYA1cRogHMaJgHUxgDUxgHAYA1gXA1hDyWOHqBOA2Dx3bJk6wTgMYA1NB2+qTgBi M7wH14OpjQGsocWP3BAE7pqyHmdC18YA1sBZMHAa58HUwQDWwFkwcBrnwdTBANbA i8BwGi8D18EA1sAAwmkMYB0M4F9KHjlMnQDE6JnjOA+mFgbwL03e2UqdAMTos13n qhNMwwD+pdk37dQJQIzGbzxTnWAaBvAvLaeoC4BYrTZVXWAaBvAvrSepC4BYteFM 11oYwL9wGiAcx4mAtTGAf2EA4TgGsDYGcIXifueqE4BY3XIRN4ZLxQCuUPpcL3UC EKsBh8xXJxiGAVyh6UcbqROAWH27HRfESsUArtDsp1bqBCBWf3ThRMBUDOAKnAYI 53EiYC0M4AqcBgjncSJgLQzgCpwFA+dxHkwtDOAKDCCcxwDWwgAuV9z3AnUCELMb L+NEwBQM4HIlz+yvTgBi9sphXBEwBQO4XJMPuScmXDd8B64ImIIBXK7ZDHUBELvm nAiYggFcjtMA4QFOBEzFAC7HaYDwACcCpmIAl2MA4QEGMBUDuBynAcIDnAiYigFc jgGEBxjAVAzgn0oePlydAMTu6eM5EbAmBvBPTYZuqE4AYvddd04ErIkB/BOnAcIL nAiYggH8E6cBwgucCJiCAfxTK04PgA9a/6EuMAoD+CdOA4QXOBEwBQP4JwYQXmAA UzCAf2IA4QUGMAUD+CcGEF5gAFMwgMsU33y6OgFIwF3ncU3oGhjAZUpf31mdACTg vX3mqxNMwgAu03TY2uoEIAG/dJutTjAJA7gMbwSBJ3grSE0M4DK8EQSe4K0gNTGA y/AiMDzBy8A1MYDLMIDwBANYEwO4VPHtJ6sTgETcdxbnwfyFAVyq9I0d1QlAIj7Y i/Ng/sIALlPy6DrtWqsjgHgtnDl+1N+5JHQNDGBNJedt0nmN1dQVQNQqZk4YOeJm pq8OBjCNkgs3Wnd1dhAOqJj5+8/f3sDyZcIAZlZ6wYbrtuXnYlipfMbEn7+7kaf7 6sEA1q/FPR3XWF0dAeSkumzGhDGnTldn2IIBzFmL69fp0EkdAWSwaO7UX0ddzPIF wwAG1ezc9TuuzjeEMMXib/l+H/PDLbzDNxQGMKyWF667VhueIYRK9cJZk8b+fAPv 7M0LA5ivVhesvWabduoKeGPRgpmTfvvlRm7uFgkGMDJr9Gm/xmp8S4h4VC2cPWXC uD4T1B2OYQCj1+GKdm1Wa6uugBMWlc2eMmn81b+qO1zFAMao/Wnt27VqwTeFCGpR 2dzpf4wfd/c4dYjzGMBEtD+xXbvWq/JMIbKorpw/Z9rk8eMfZPaSwwAmrdNJq7dZ rdla6gyYoap8/uyZUyb9/sBodYmfGECl9U5o1XrV5iu3UncgSdWVC+fPmTFt8h8P /ahOAQNojK7Hrdpy1WZNOMfaQYsqyubPnTlt6rRHvlanIAUDaKhND2veskWzlVdq ow5BCNWLKhcumDdn5vSpM54Zro5BFgygJbbt3bRFs6YrlzZu1LBY3YJaqqsWVSxc MH/O7JnTZz//sboGATCA1upxYJOmzZs0WTyJxQ0bNOAPMinVixZVlC+eu7lzZ8ye +9JgdQ7ywteNU3r2LF2l6cqNF4/i4lUsWjyL/PmGV7146ioXb93isVswZ/as+YMG qYsQOb5AvLD/do1LV1pppcYli4exUdHibxgLCwvVTYaoqqpa/C1d5cLFQ1e2YN68 efMXfPSKugmJYQC9d0C3RiuVlpY0blSy+LvG4uKioqKl++jIN4/V1UsXrrKysrx8 8XdzZQsXlM2fP2/hsJfVYTCCG5/liNfh6zQqLSlevJBFJcVFDRst/g5y8X8Wz2SD wv9bupRJfxZVL9216qpFi6dt8bdvi/+zsKKyvKxy8b6Vl81fOOrphHtgLQYQ0Tu9 RePCksLG/1dSWPJ/BRVbF9X4NPu/lP9aorrWfy/5X5WfNiyoLqsqq15QVVa1YPpd CTTDSwwgAG8xgAC8xQAC8BYDCMBbDCAAbzGAALzFAALwFgMIwFsMIABvMYAAvMUA AvAWAwjAWwwgAG8xgAC8xQAC8BYDCMBbDCAAbzGAALzFAALwFgMIwFsMIABvMYAA vMUAAvAWAwjAWwwgAG8xgAC8xQAC8BYDCMBbDCAAbzGAALzFAALwFgMIwFsMIABv MYAAvMUAAvAWAwjAWwwgAG8xgAC8xQAC8BYDCMBbDCAAbzGAALzFAALwFgMIwFsM IABvMYAAvMUAAvAWAwjAWwwgAG8xgAC8xQAC8BYDCMBbDCAAbzGAALzFAALwFgMI wFsMIABvMYAAvMUAAvAWAwjAWwwgAG8xgAC8xQAC8BYDCMBbDCAAbzGAALzFAALw FgMIwFsMIABvMYAAvMUAAvAWAwjAWwwgAG8xgAC8xQAC8BYDCMBbDCAAbzGAALzF AALwFgMIwFsMIABvMYAAvMUAAvAWAwjAWwwgAG8xgAC8xQAC8BYDCMBbDCAAbzGA ALzFAALwFgMIwFsMIABvMYAAvMUAAvAWAwjAWwwgAG8xgAC8xQAC8BYDCMBbDCAA bzGAALzFAALwFgMIwFsMIABvMYAAvMUAAvAWAwjAWwwgAG8xgAC8xQAC8BYDCMBb DCAAbzGAALzFAALwFgMIwFsMIABvMYAAvMUAAvAWAwjAWwwgAG8xgAC8xQAC8BYD CMBb/w8BjFfiVF8wdQAAAABJRU5ErkJggg=="/></symbol><g mask="url(#b)"><g transform="rotate(.193) scale(.36014)"><symbol id="c" viewBox="0 0 1280 1280"><image width="1280" height="1280" xlink:href="data:image/png;base64, iVBORw0KGgoAAAANSUhEUgAABQAAAAUACAIAAACXhmigAAAACXBIWXMAAA7EAAAO xAGVKw4bAAEz2klEQVR4nOzdCZxcVZn//6S7et/3rt47TUggJEHceMko/hQUcQN1 nD8KyjLzg98oOC8cUCFMEIFBMUxgUGAMCANhkzVsWVDAGGIka8dg0IHupNd07ft2 69b/dBW0mZil07mnzr1Vn/draBOWp59Jd1ffb59znjN7FgAAAAAAeWC26gYAAAAA AMgGAjAAAAAAIC8QgAEAAAAAeYEADAAAAADICwRgAAAAAEBeIAADAAAAAPICARgA AAAAkBcIwAAAAACAvEAABgAAAADkBQIwAAAAACAvEIABAAAAAHmBAAwAAAAAyAsE YAAAAABAXiAAAwAAAADyAgEYAAAAAJAXCMAAAAAAgLxAAAYAAAAA5AUCMAAAAAAg LxCAAQAAAAB5gQAMAAAAAMgLBGAAAAAAQF4gAAMAAAAA8gIBGAAAAACQFwjAAAAA AIC8QAAGAAAAAOQFAjAAAAAAIC8QgAEAAAAAeYEADAAAAADICwRgAAAAAEBeIAAD AAAAAPICARgAAAAAkBcIwAAAAACAvEAABgAAAADkBQIwAAAAACAvEIABAAAAAHmB AAwAAAAAyAsEYAAAAABAXiAAAwAAAADyAgEYAAAAAJAXCMAAAAAAgLxAAAYAAAAA 5AUCMAAAAAAgLxCAAQAAAAB5gQAMAAAAAMgLBGAAAAAAQF4gAAMAAAAA8gIBGAAA AACQFwjAAAAAAIC8QAAGAAAAAOQFAjAAAAAAIC8QgAEAAAAAeYEADAAAAADICwRg AAAM09raIr63jo+Pz+w/nDUrNT6+T0ZjAABgFgEYAICZaW1tLSgoKCwsSL8trK2t i8dj4hepNPEvzJ49O/N2/98eIPOPpv4FQdf14uISj8ednKRnzCBRAwCAv0UABgDg cFpbW0QuLXg354q/bFVVlSKbit9kpwERj8W7s9lsgUAg+S49ldLHxkjFAAAcHQIw AAB/JeJuJuvabCLh2iorK3Rdz1rWnT6RikVjotFgMKhp2tRiMTuoAQA4DAIwACB/ ZeJuYVpRUVFpaan47UH3KluCCMDibSgUTkdijUgMAMABrPo9HgCAGRCJN512bUVF tsrKylmHOJqbM0QAFv8PBgKBROLdSEweBgDks1z+rg8AgGC3t9omFVVXV83K9cR7 eJmzxB6PR5uUZLYWACDf5O9DAAAgh7W2itBbWFxcXFlZWVBQoLodM8osDvt8vkQi IYIxK8MAgHxAAAYA5A6Re4uLi1paWmKxGLl3+kQADofD4g9N0zSSMAAghxGAAQCW 19raYrPZSkvLKirK83mH87ETSTgYDMVi0dHRMdW9AABgPJ4SAAAWJqJvcXFxdXW1 CMCqe8kdqVSqsLBw376JkZER1b0AAGAkAjAAwJJE9C0pKRHR14SX9OYGEYPFW5fL NTxMDAYA5AgCMADAejo62mtra1n1zQIRg8PhcCgUYlM0ACAHEIABAFZit7eWl1dU VVWqbiS/JJNJv98fi8UYkQUAsDQCMADAMtrb2+rr69nzrEQqlQpNCo+NsRQMALAq AjAAwBq6ujrr6uoY8qyWrusul2tkZFR1IwAAzASPEQAAC+ju7q6rq1XdBSZpmubx eBkQDQCwIgIwAMDsuru76urqVHeBv0omk263hwwMALAcAjAAwNQ6OzsbGupVd4ED pVIph8M5OspeaACAlRCAAQDm1d7e1tDQUFBQoLoRHEQoFAoGg2Nj46obAQBgugjA AACTam1tbWioLyoqUt0IDsnv97/zzoDqLgAAmC4CMADApPr6+rjv1+Q0TfP5/END Q6obAQBgWgjAAAAzam9vb2pqVN0FjiwcDgcCQS4HBgBYAgEYAGA6ra0tdXV1JSUl qhvBkaVSKZ/PNzi4R3UjAAAcGQEYAGA6TH62lkgkEggERkdZBAYAmB0BGABgOvPn zystLVXdBaZL13Wfz79nD4vAAACzIwADAMylvb2tqalJdRc4OqFQOBgMcCUSAMDk CMAAAHNh+LMVJRIJvz/AOGgAgMkRgAEAJtLa2trc3FRQUKC6ERw1EYDfeecd1V0A AHA4BGAAgIl0dHQ0Njao7gIzwX1IAADzIwADAEykr29OVVWV6i4wE+ld0P6hoWHV jQAAcEgEYACAWbS2tjQ2NtpsNtWNHAVNSxYWFlRUVIjOW1tb9/9Huq7Pmrwmd/Km 3FRKn/xL19/77aT0vzX1i3dVV9cMDw+7XK5IJCz+/cLCwuz9P3PMfD7fwMCg6i4A ADgkAjAAwCza2uzNzc2quzgkTdOKioqqqqoaG5t6enpOOOGEk08+ubOzU957FAF4 z54927Zt2717t/iFwzERDIZEjjZtKg6K/kIhZkEDAEyLAAwAMIuurs76+nrVXUzK rNCWl1e0tLTMmTPnfe87+SMfOa2vr0/8I4/HE4/HFfYmcvjbb//P5s1b3nzzzaGh vW63OxaLmSQSRyKRQCA4OjqquhEAAA6OAAwAMAuFB4CTyWRxcbGIu/Pmzf/Qhz70 yU9+8lB3ETudTvEvZ7m9w9N1fWxsbP363/b39w8MDIhILNK7kknaHAMGAJgcARgA YBYnnDC/pKQkO+8rs8bb2mo/5ZT3fepTnz799NOnmRj37dsnu7djFw6Hf/vb19av /91bb+32+XxZWx8WUdzn8+/Zsyc77w4AgKNFAAYAmEJra4swe7bcb0zJZNJut59+ +sfPP//8rq6uGVSwRADen6Zpu3fvfvrpp7ds2RIMBm02uWHY7/e/886A1HcBAMCM EYABAKYgdQKWruuNjU0XXnjh17/+9WPcG2y5ALw/j8ezcuXKNWtWJxIJSe8iOCk0 Ps4cLACAGRGAAQCm0NnZ0dDQIKn4xRdfcvnllxtSytIBOEPE4BtvvHHXrj/KKB4O h0UCHh0dk1EcAIBjRAAGAJhCT093bW2tjMq6rr/++saKigpDSjkcjmOvo9xTTz31 X/91j4zKsVjM7w+MjIzIKA4AwDEiAAMATEHeCOiCgoItW7YaUiqRSLjdbkNKqbVh w4brr18qYzgWg6ABAGZGAAYAmMK8eceXlZXJqNze3v788y8YUioajfp8PkNKqfXm m29+//vfj8djhldOJpMiAO/Zs9fwygAAHDsCMADAFBYsOLGoqEhG5f/zfz5x2223 GVIqFAoFg0FDSqk1MjKyZMm1Y2NSTup6vb7BwUEZlQEAOEYEYACAelLvQLryyisv uOAbhpTy+/2RSMSQUmqJGH/zzTdv3bpFRnFuQgIAmBYBGACgnt0+mYAlFX/ssceO P36eIaU8Hk88HjeklHL33HPP008/JaNyIBB4++13ZFQGAOAYEYABAOq1tbU1NzfJ qKzr+rZt24/x7t8pTqczmUwaUkq5Z5999q67fi6jMlcBAwBMiwAMAFCvo6O9sbFR RmURgHfs6DeqWg5cAjzl5ZfX3XLLj2024wdBh0KTVwFLOmAMAMCxIAADANTr7Oxs aKiXUdlms73xxmajquVSAJZ3E1IkEgkEAqOjBGAAgOkQgAEA6nV3d9fV1cqoXF1d /dprvzWqWi4F4M2bNy9Zcq2MytFoNBAIjoyMyCgOAMCxIAADANTr7e2pqamRUbmr q+vZZ1cZVS2XAnD6KuDvyZjpJWr6/f7hYQIwAMB0CMAAAPX6+uZUVVXJqHzKKafc e+99hpRKJpNOp9OQUmYwMDBwzTU/8Hg8hldOJBIiAA8NDRteGQCAY0QABgCoN3fu 3IqKchmVzz777JtuutmQUvF4XEZcVGV8fHzJkmuHh42PqZqmiQC8d++Q4ZUBADhG BGAAgHqLFy+aPVvKt6QLL7zoO9/5jiGlIpGIyHWGlDIDt9v1ox/96E9/+pOM4uIP 6p13BmRUBgDgWBCAAQDqnXzyYkmVr712yVe+8hVDSk1ebhsKGVLKDMLh8I9//ONN m34vozgBGABgTgRgAIBiPT3dtbVSRkALd999z4c//GFDSvl8vmg0akgpM9B1/Y47 7li9+iUZxWOxmN8fYBA0AMBsCMAAAMWOO66voqJC0hbo1avXtLS0GFLK7XYnEglD SpnEAw888MgjD8uozBwsAIA5EYABAIrNnz+vtLRURuVUKrV9+w6jqjkcDl3Xjapm Bk899dR//dc9MiqLPyifz7dnz14ZxQEAmDECMABAsQULTiwqKpJRub6+4de//rVR 1XLpEuCMLVu2XHfdEkmp3uv1Dg7ukVEZAIAZIwADABRbtGhhQUGBjMqnn3768uW3 G1Ut9wLwnj17RACemJiQUdzn8w0MDMqoDADAjBGAAQCKybsD6dJLLxOMqpZ7Adjj 8dx444927dolo7jP5x8YYBA0AMBcCMAAAMXkBeBt27YbVUrXdYfDYVQ183jiiV+t WLFCRmUCMADAhAjAAACVuru7a2trZATgZDLZ37/TqGrxeNzj8RhVzTyefvrpe+65 W0blaDQaCARGRkZlFAcAYGYIwAAAlfr6+iorpdyBZOwI6Egk4vf7japmHuvWrfvx j2+x2WyGV+YmJACACRGAAQAqzZt3fFlZmYzKouzrr280qlogEAiHw0ZVM4+NGzcu XfpvMoaQJZNJn8+/dy83IQEATIQADABQSd4dSJ2dnatWPWdUNa/XG4vFjKpmHjt3 7rzmmmsSibiM4tyEBAAwGwIwAEAleXcgfeQjp/3sZz8zqprT6Uwmk0ZVM489e/aI AOxyOWUU5yYkAIDZEIABACrJGwF94YUXfec73zGqWu7dgZThdruuv/6Hf/7zWzKK E4ABAGZDAAYAqGSJO5Bm5W4AFh5//PH77rtXRmUCMADAbAjAAABluru7amtrCcBq yQvAkUgkGAxyExIAwDwIwAAAZfr65lRWVsoIwLqu79jRb1S1VCo1MTFhVDWzWb36 pWXLlhUWFhpeOR6P+/2B4WFuQgIAmAUBGACgjLw7kIqLSzZt2mRUtUQi4Xa7japm NuvXr//Rj26QdhOSb+/eIcMrAwAwMwRgAIAyJ554QnFxsYzKdnvbiy++aFS1aDQq gpxR1cxm+/btS5Zcq2ma4ZVTqZTX69uzh5uQAABmQQAGACizcOFJMnbeCu9//wdW rFhhVLVgMBgKhYyqZjZvv/32tdde4/V6ZRQXAXhwcFBGZQAAZoAADABQRt4I6PPO O+/qq79nVDWfzxeNRo2qZjYOh2Pp0qXvvPO2jOIMggYAmAoBGACgjFXuQHK5XDJ2 CJvHY4899stf3iejMgEYAGAqBGAAgDJWCcATExOpVMrAgmZDAAYA5AkCMABAjTlz equqqmQE4GQy2d+/08CCOXwJcMbzzz9/xx23yxgEnb4JyT88PGJ4ZQAAZoAADABQ 4/jj55aVlckIwDZb0RtvvGFgwZwPwK+++spNN90kYyCZpmkiAHMTEgDAJAjAAAA1 5N2B1NTUtHbtOqOqpVKpiYkJo6qZ0+bNm//t3/5N15OGV07fhOTds2ev4ZUBAJgB AjAAQA15dyAtXrz4/vsfMKpaIpFwu91GVTOnt97afd111/n9fhnFRQAeHOQqYACA KRCAAQBqyJuAdc455y5dutSoapFIRFIyNI/x8fHrrlsyNCRlozJzsAAA5kEABgCo YZUR0IFAIBwOG1jQnB555JEHHrhfRmUCMADAPAjAAAA1rBKAPR5PPB43sKA5EYAB APmAAAwAUKC3t6e6utoSdyA5HA5d1w0saE7PPPPMXXf9XMZHJBaLBQIBbkICAJgB ARgAoMDcuceVl5fLiFsFBQVbtmw1sGDO34GU8fLL62655RabzWZ4ZU3TfD6/pAPG AAAcFQIwAECBE06YX1JSIqNyXV39b37zGwML5kkA3rRpU3pyWMrwyrqu+3w+bkIC AJgBARgAoMBJJy2QsdgozJ9/wiOPPGJgwTwJwG+++eaSJUvC4ZCM4tyEBAAwCQIw AECBRYsWFhQUyKh89tln33TTzUZV0zTN5XIZVc3MRkZGrrtuyejoqIzizMECAJgE ARgAoIBVRkBHo1ER3gwsaGYrV6588MH/llGZAAwAMAkCMABAAasE4GAwGApJ2RVs QgRgAEDOIwADALKtp6enpsYadyB5vd5YLGZgQTN78sknfvGLX8ioHI1GA4HgyAg3 IQEAFCMAAwCy7bjjjquokHIHkqi5des2Aws6nU4Rqg0saGarV7+0bNmywsJCwysn Egm/3z80NGx4ZQAAjgoBGACQbfPnzystLZVRuaqq6re/XW9gwTwZAZ2xYcOGG274 oYwfTOi67vX69u7lJiQAgGIEYABAtsm7A6mvr++JJ540sGBeBeCdO3cuWbIkFovK KO7xePfs4SYkAIBiBGAAQLbJuwPpE5/45LJlywwsmFcBWATUJUuudTgcMop7vb7B wUEZlQEAmD4CMAAg26wyAnpWngVg4cEHH1y58iEZlRkEDQAwAwIwACDbrBKAE4mE 2+02sKD5EYABALmNAAwAyKqenu6amhpL3IEUCoWCwaCBBS3hzDPPkDEIWvD7A+Fw eHx8XEZxAACmgwAMAMiqvr6+ysoKGQE4lUpt377DwIJ5dQnwlM9+9mxN02R8gMLh SCDgHxsjAAMAlCEAAwCyat68eWVlUu5AKi8v37DhdQMLOhwOXdcNLGgJX/vaeU6n U8aUsvSWcs/Y2JjhlQEAmCYCMAAgq+SNgO7u7n7mmWcNLJhvE7Ayrrjiit27/yTp YzQxMTE6SgAGAChDAAYAZJW8CVinnXbanXf+zMCC+RmAly376erVqyUdAyYAAwDU IgADALLq5JMXS6p80UUXX3HFFQYWzM8A/Mwzz9x553/abDYZxQnAAAC1CMAAgOyx 21tbWlokFecSYKOcccYnJQVgh8OZTGrj43n6BwsAUI4ADADInuOO66usrJRRWdf1 HTv6jS3ocDgMLGgh8gJwJBLx+xkEDQBQhgAMAMieE088obi4WFLx3/52fVVVlVHV otGoz+czqpq1yAvAyWTS6XQxCBoAoAoBGACQPQsXniRpupJIVv39Ow0s6Pf7I5GI gQUt5Mwzz5D0YZrFMWAAgFIEYABA9sgbAW34Fuj8vAQ446yzPp1KpSR9pAjAAACF CMAAgOyRNwK6qKj4D3/4g4EF83YClvDlL38pGAwSgAEAuYcADADIkrY2e3Nzs6Ti XV1dzz67ysCC+RyAr7jiit27/1RQUCCjuNPp1DQGQQMA1CAAAwCypKurs76+XlLx H/3oxs997nMGFsznALx9+/arrvpXSceAfT5fJBIdH2cQNABAAQIwACBL+vr6qqqk 3IE0y+gR0LPyOwDPkjkIOhwOBwIBbkICAChBAAYAZMkJJ8wvKSmRUdnwCVipVGpi YsLAgpZz9tmfSSaTMo4Ba5rmcrm5CQkAoAQBGACQJfLuQKqsrFy//ncGFozFYl6v 18CClvO1r33N6XRIOgbMHCwAgCoEYABAlsi7A2nevHmPPvqYgQUDgUA4HDawoOV8 //vf27Jli6QfWBCAAQCqEIABANkgdQT0Oeecu3TpUgMLOp3OZDJpYEHLeeCBBx58 8EGbTUoAdrlciUSCQdAAgOwjAAMAsqG7u6uurk5S8Vtv/ekZZ5xhYME8n4Al7N69 +/LLvy1tELQ/EokwCBoAkH0EYABANhx3XF9lpawR0Bs2vF5eXm5gQQKwcOaZZ0gK wCL9+v1+BkEDALKPAAwAyAYLjYCeRQBO++xnP6tpCQZBAwByCQEYAJANMkdAV61f v97YmgRg4YILzhd/DgyCBgDkEgIwAEC61tYWQdII6BNOOPHhhx82sGAymXQ6nQYW tKglS67dtGkTg6ABALmEAAwAkK6tra25uUlS8a9+9R9+8IMfGFgwHA4HAgEDC1rU o48+smLFvQyCBgDkEgIwAEC67u7uurpaScWXL7/99NNPN7Cgx+OJx+MGFrSot99+ +7LLLpW0Auz3+8NhBkEDALKNAAwAkG7u3OMqKipkVNZ1/Y03NhcXFxtYkwPAU+QN go5Goz6fnzlYAIAsIwADAKQ78cQTjM2oU1Kp1PbtO4ytSQCe8vnPfy4ej8s4vJ1M Jl0uF8eAAQBZRgAGAEgnbwR0bW3tK6+8amxNAvCUiy66cGRkhEHQAICcQQAGAMjV 2trS2toqqfjixYvvv/8BY2sSgKdcf/31Gzb8jkHQAICcQQAGAMjV3t7e1NQoqfj5 55//3e/+q7E1CcBTnnzyibvuustms8ko7na74/E4g6ABANlEAAYAyNXT011bK2sE 9F133X3qqacaWDAWi3m9XgMLWtrQ0NDFF18kaQU4EAiEw+GxMQZBAwCyhwAMAJBr 7ty5FRXlMionk8nt23cYe0KVO5AOIG8QdPpnDT4GQQMAsokADACQS94IaGHbtu3G FmT/8wE+//nPx+MxGYOgdV13OJwEYABANhGAAQByLVq0UNIY4fr6hl//+tfG1iQA H+CSSy4ZGtrLIGgAQG4gAAMAJJI6AvqUU0659977jK1JAD7AjTfe+Nprr0obBO0Y HR2VURkAgIMiAAMAJOroaG9slDUC+qKLLr7iiiuMrUkAPsBzzz13++3LpQ2C9sTj MQZBAwCyhgAMAJCot7enpqZGUvFf/vKXJ5/8PgMLJhIJt9ttYMEc4HA4zjvv/5MU gIPBYCgUYhA0ACBrCMAAAImOP35uebmsEdD9/TuNrZnJY8bWzAGf+tSZks4AMwga AJBlBGAAgEQLFpxYVFQko7KIZFu2bDW2JncgHdQ553wxEokwCBoAkAMIwAAAieSN gG5qalq7dp2xNR0Oh4hkxtbMAZde+n8HBgYYBA0AyAEEYACALK2TWiQVP/XUU++6 625jazIB66B+8pOfrFu3VtIgaIfDMTLCIGgAQJYQgAEAsnR2djQ0NEgqftlll116 6WXG1iQAH9Tq1S8tW7ZMUgD2eDyxWHx8nDlYAIBsIAADAGTp7e2tqamWVPyxxx47 /vh5xtYkAB9UMBg899xzJAXgUCgk6jMIGgCQHQRgAIAs8+YdX1ZWJqOyjBHQmqa5 XC5ja+YMeYOg4/G4x+NlDhYAIDsIwAAAWU46aYGk+2NF2Tfe2GxszWg06vP5jK2Z M7785S8Fg0EZg6BTqZTD4WAOFgAgOwjAAABZFi9eJCMyCXZ724svvmhsTS4BPoxv fetbf/7zW5J2QTMIGgCQNQRgAIAUdntrS4usEdAf+9jHbr/9DmNrer3eWCxmbM2c sXz58hdeeF7aIGjnyMiIjMoAAByAAAwAkKKzs7OhoV5S8SuvvPKCC75hbE2n05lM Jo2tmTNee+21G2/8kaQA7PV6o9EYg6ABAFlAAAYASDFnzpzq6ipJxZ9//oX29nZj azIC+vDOPPMMSQE4HA4HAgEGQQMAsoAADACQYv78eaWlpTIq67q+Y0e/4WUJwId3 1lmfTqVSMg51JxIJt9vDIGgAQBYQgAEAUsgbAV1cXLJp0ybDyxKAD+8f/uGrHo9H 0mVIzMECAGQHARgAIIW8EdA9Pb1PP/20sTW5BPiIvvvdK/v7+xkEDQCwNAIwAMB4 dru9paVZUvHPfOYzN9/878bW5BLgI1qxYsWjjz4iaVXf6XRqmjY+ziI8AEAuAjAA wHhdXZ319bJGQC9duvScc841tiaXAB/Rtm3brr76KkkrwD6fLxKJMggaACAbARgA YLy+vr6qqkpJxV999bWamhpja3IJ8HTIGwQdiUT8/gBzsAAAshGAAQDGO+GE+SUl JTIqSxoBzSXA0/HZz56taZqMo92irNvt5hgwAEA2AjAAwHgLF54kaamwsrJy/frf GV6WEdDTcf75509M7GMQNADAugjAAACDtba2CJJGQM+bN//RRx81vCwBeDquvfba P/xhE4OgAQDWRQAGABisvb2tqalJUvGvfOUr1167xPCyBODpeOSRR+67715JAdjt dsfjcQZBAwCkIgADAAzW09NdW1srqfjy5ctPP/3jxtbkEuBpGhgY+Kd/+kdJNyEF AoFwODw2xiBoAIBEBGAAgMHmzp1bUVEuo7Ku62+8sbm4uNjYslwCPH3yBkHHYjGv 18cgaACAVARgAIDBFiw4saioSEblVGrW9u3bDS/LJcDT94UvfCEWi8o44K3rutPp 5BgwAEAqAjAAwGCLFi2UNCi4rq7+N7/5jeFluQR4+v7xHy/Zu3cvg6ABABZFAAYA GKl1Uouk4qeccsq9995neFkuAZ6+m2+++ZVXfiNpF7TD4RgZGZVRGQCADAIwAMBI nZ0dDQ0NkopffPEll19+ueFlGQE9fS+88MLy5f8hKQB7PJNL8ePjzMECAMhCAAYA GGnOnN7q6mpJxf/7vx9cuHCh4WUJwNPn8Xi++tW/lxSAQ6FQMBhkEDQAQB4CMADA SPPmHV9WViajsqZpO3f+UUZlAvBR+dSnzpR0BjiRSLjdHgZBAwDkIQADAIx00kkL JN0TW1hYuHnzFsPLJpNJp9NpeNkc9qUvfSkUCsoYBD2LOVgAAMkIwAAAIy1evEhS NLLb21588UXDy6avn/UaXjaHffvb33rrrbck7YImAAMApCIAAwAM09Zmb25ullT8 Yx/72O2332F4WS4BPlq33377c889Z7NJCcBOp0vTEuPjbEoHAEhBAAYAGKa7u6uu rk5S8Suv/O4FF1xgeFkuAT5a69evv+GGH0paAfb7/ZFIhDlYAABJCMAAAMPMnXtc RUWFpOIvvviS3W43vCyXAM/AmWeeISkAR6NRn8/PHCwAgCQEYACAYU488YTi4mIZ lXVd37GjX0ZlRkDPwNlnfyaZTMo47C3KulwujgEDACQhAAMADLNo0UJJF+SUlZW9 /vpGGZUJwDPw9a9/3eGYkPSxZg4WAEAeAjAAwBh2e2tLS4uk4vPmzXv00cdkVCYA z8C11177hz9skrQL2uFwjIyMyqgMAAABGABgjAULTiwqKpJU/M47f3baaacZXlbT NJfLZXjZnDc0NHTxxRdJCsCpVEpkYBaBAQAyEIABAAZonVz9bZF0A3Aymezv3ymj ciQS8fv9MirnvLPO+rS84hMTIgCzCAwAMB4BGABggI6O9sbGRknFKyur1q9fL6Ny IBAIh8MyKue8b37zG2NjY5KOAXs8nlgsxm3AAADDEYABAAbo65tTVVUlqfipp556 1113y6gsglY8HpdROectW/bTl15abbNJ2QUdDocDgSCXIQEADEcABgAYQN4FSML1 1//wi1/8oozKDodD13UZlXNef3//d797paRjwOKD4nQ6OQYMADAcARgAYIDFixfJ OwC8efMWSemaEdDH4lOfOlPSFuhZHAMGAMhBAAYAHKv29vamJlkHgEX03bTpD5KK E4CPxT/8w1c9Ho+kDOx2u+PxOMeAAQDGIgADAI7VnDlzqqtlHQA+8cQFK1eulFFZ 13WHwyGjcp5YunTp669vkLQLmmPAAAAZCMAAgGMl9QDw5ZdfcfHFF8uoHI/HPR6P jMp54tVXX7nxxhttNpuM4slk0uVycQwYAGAsAjAA4FjJOwAs/OY3r9TV1cmoHAqF gsGgjMr544wzPikpAM/iGDAAQAICMADgyHp6ugsnibBTWFAgflEgL/Hur6CgYMuW rZKK+3y+aDQqqXie+NKXzg2FQln4ZEilUrquJ/cjPnZjY+Oy3y8AIMcQgAEA7+rt 7Sncjwif2Um5h9HT0/v0009LKu5yuTRNk1Q8T1x99dXbtm2VdAx4mjLZeL94rEci EQ4PAwAOigAMAHmku7vbZjsw4ipPuYdx4YUXfec735FUnBHQx+7555+//fblagPw YaTSdD21/+JxNBojHgNA3jLvQw8AYGZ6Jxdyben9ypMR1wwLuTP24osv2e12ScUJ wIaQegxYqkw8nlwy1nVNE2+TkUiEsVsAkNus+kgEAPmso6O94F2Zg7nps7lmXYU7 Ftu2bZdXnABsiC9+8YvRaMS6P2Q5qHQkFtI7qidXj/VUavLvcOoYAKwup75dAUAu mUq5U9OnxF/it6r7yp6urq5nn10lqXgikXC73ZKK55XvfvfK/v7+nPz5y0FlFo21 9/Jx5vgx2RgArIIADACKdXZ2/O+13KKszVg2ufPOO+/qq78nqXg4HA4EApKK55Wn nnrqrrt+nj8B+DDeWzfWMhuqxW8TCY3zxgBgKjxgAUCWZILu1Fpuvi3nzsCzz67q 6uqSVJw7kAxk3WPA2ZFZNBZhOL1yPJmNCcYAoAoBGAAM1t7enp6v/O7R3KKiIhbH ZkBkhu3bd8irzx1IBvrCF74Qi0XZtnC09lsx1t6bxcVWagCQi+9VADBzHR0dIutm TuiyqGssu73txRdflFefCVgG+pd/+c6uXbv4QY8hps4YZ1aM2UcNAMYiAAPAtGTW dTNRt7i4SLxlvUuqL3/5K0uWLJFXnwBsoEcffeTee+8lAEuV3kQ9KXObsaYlScUA MAM8vQHAQXR1dYqn+cbGpsz9LqzrZt/jj/9q7ty5koqnUqmJiQlJxfNQLBb77GfP 5hhwlolPY13X4/F4eq1YxOM4lxgDwBERgAHku/Q25sKOjvZAICAeKFnFMgPxWL9j R7+8+iIzeDweefXz0Oc//znxp8q2COUyqbi4uNjtdmcmb7FQDAD74xsVgPzS2Tm5 tNvUxNKuqbW0tK5evVpe/VAoFAwG5dXPQ9/+9rfeeustfn5kQplDxTabrbq6Zs+e wUQiwUIxgHxGAAaQs6ZO7dbV1cbjcfZnWsgXv3jO9ddfL6++1+uNxWLy6uehlStX 3n//LwnAVqHrunhbXl4+Pj7OiWIAeYUADCBHdHSIuFvY1dXt9/vEsx0P4pb2yCOP zp8/X159h8ORCQAwSjgc/sIXPs+Pmawrs1BcWlrqcrkyY6hZKAaQkwjAACwpc3C3 vb09GAyI37KTOZfIPgA8ixHQcnAMOMdkInFxcbHH401HYvZOA8gFfJcCYBk9Pd2V lZUi9/KEndtkHwCeRQCW4/LLv7179242X+SwzIStoqKiiYmJ4eER1e0AwEzwEAnA GhYtWigevNhgmQ9kHwDWNM3lcsmrn7c4BpwnxEuxSMJ+f2DPnj2qewGAo0YABmAB 7e3tTU2NqrtAlsg+AByJRPx+v7z6eYtjwHmlsNA2OjrK6CwAlkMABmABXV2d9fX1 qrtANiSTyf7+nVLfhUi/IgNLfRd56zOfOUvXdQ4p5ImJCYfIwKq7AICjw7coABbQ 29tTU1OjugtkQxYOADudThGzpb6LvHXFFZf/6U9/Yhd0PhBfRB6Ph5PAACyHAAzA Aj70oQ/F49zamhdkHwCexQQsmR555JH77ruXAJwPRAD2+Xx79w6pbgQAjg4BGIAF LFx4Eo/UeUL2AeBZBGCZIpHI5z//OY4B54NUKiUC8OAgc7AAWAwBGIDZtbe3NTY2 cqowH2iatnPnH6W+C13XHQ6H1HeR5z7zmbNENFLdBbKhqKhoeHh4bGxcdSMAcBR4 oARgdh0dHY2NDaq7QDaUlJT+/ve/l/ouGAEt2/nnnz8xsa+goEB1I5Bu9uzZ+/bt Gx1lEDQAKyEAAzC77u6uuro61V0gG5qbW9asWSP1XTACWrbLL//27t27ObOQD3Rd d7lcIyMMggZgJQRgAGY3Z05vdXW16i4gi3iGrqqqbmpqam9vu/POn8l+d4yAzoJb b731L3/5s9vtDgaD4uPLanCu0jTN5/MNDQ2rbgQAjgIBGIDZvf/9p5BYcoD4IJaW ltbU1Njt9jlz+mSPej4UJmCpct999+3atUv8+ft83mg0KlIxB/utTtOSfj+DoAFY DN97AJgdI6CtRTwTFxYWVFRUNDU1dXR0HH/8vCuuuEJ1U39FADaVp59+eufOnSMj w06nMxQKaZomvtgJxlbBIGgAVsT3GACm1t7e3tjYwAOxOem6XlJSUldX19bW1tPT u3TpUtUdHRkB2BIefPDBnTv7xQfL4/FEozERtdhHbU42m21kZIRB0AAshGdKAKbG CGgz0DStuLi4srKyqampu7tn2bJlqjuaoXg8LgKV6i4wc/fcc09/f7/T6QgEgvF4 jOVi5QoKCsbHxxkEDcBC+LYBwNS6ujrr6+tVd5EvkslkUVGRCLqNjY2dnZ19fcdd fvnlqpsyEiOgc9ILL7ywY8f2kZFRl8vp9wcSibhIxawYZ4eup8QfO4OgAVgIARiA qfX09NTW1qjuItfoum6z2aqrq0XQ7ejonDt37j//8z+rbiobGAGdV9asWbNt27bR 0RHxcff7/bFYjGBsOPEF5fF4hodHVDcCANNFAAZgah/96N8FAgHVXVhSZp5QWVl5 XV1dS0tLZ2fnDTfcoLopxTgAjIzHHntsy5YtLpfL43GHw2GR4phKPTPij87r9XIT EgAL4bUegKl98IMfSCQSqrswu8zW5b6+vvb2jjlz5uTYvmUDEYBxeC+/vG7z5i0T E/vefvudcDjEivERaZrm9/u5CQmAhRCAAZja4sWLWJbJyCxSlZWV1dTUNjc3dXV1 33jjjaqbshgCMGbmySef+P3vN7lcLq/XK4Ix1zVN0XXd5/Pv2cNNSAAsg9duAKZ2 0kkLbDab6i6ySjxQirelpaW1tXVtbfbu7p7rr79edVO5IJlMOp1O1V0gpzz33HOv v75h374Jt9sdiYSTSb2wMO+2Uvt8voGBQdVdAMB05ddrNADLWbRoYQ5vQRSRTDwr V1VVNTU1d3d3zZ9/wmWXXaa6qZwVDoc5T44s2JC2d++eiQlHIOBPJBK5vVzs8/kH BgZUdwEA05WzL8cAckB7e3tTU6PqLgyj63pZWVlTU1NPT8+CBSeRdbPM4/HE43HV XSBPbdy4cf363w4O7tm3bzwYDOl6UqRi1U0Zo6CgcCxNdSMAMC0EYADm1dHR3tho yQCc2cZcXV3T3t42f/4J7GE2g4mJiVQqpboL4K/WrVu3du3akZFhj8ejaZpFJ1GL tsfGxgnAAKzCeq+zAPJHZ2dHQ0OD6i6OLJmcXMypqanp6OhYsOCkH/zgB6o7wkEw AQvm9+qrr6xb9/LQ0F6Xyx2Px6wSiScmJkZHCcAArMECr6oA8lZXV2d9fb3qLg6k 67p4JK2rq+vp6Vm4cNGVV16puiNMCwEYVrRx48Y1a9YMDg6KkCkisQmPE6dSKYfD OTo6qroRAJgWc72GAsD+uru7RM5U24N4thOJt6Kisr297cQTF9xwww1q+8HMiA+i w+FQ3QVggFdeeeWFF14YHh7yeDziE1v5WWLRg8vlGhkhAAOwBgIwZrW2ts6ePWts bFx1I8CBenq6a2trs/xOk8lkcXFxc3PL8ccfv3z58iy/d0gSi8W8Xq/qLgApVq9+ 6dlnV42PjweDgdmzZ2d5cn46ALtHRkay+U6BI7LbW1OpWeLrQnUjMB0CMADz6unp qa2tkfouMtOqRMzu7e09+eT3/cu//IvUdwdVQqFQMBhU3QWQDZs3b37ppZfefvvt iYmJRCIu+yBxMpn0eDzDwwRgANZAAAZgXr29PTU1xgdgEXpLS0vPOOOMm2662fDi MCefzxeNRlV3AaixcePGFStW7N27R8Z+aQIwAGshAAMwr145AVjTtDPP/NRtt91m eGWYlsvlEh931V0AymzYsGHZsp+GQiHDV4PFV5bX6yUAA7AKAjAA8+rt7a2pqTa8 bDKZPOusz/zkJz8xvDJMixHQyHMbN24UAdjv9xt+Qji9AiwC8LCxZQFAEgIwAPOS F4DPPvvsW275seGVYVoEYOQ5EYBvu22ZCMCGrwATgAFYCwEYgHkRgGEUAjDyHAEY ADIIwADMiwAMQ4iPuNPpVN0FoBIBGAAyCMAAzEtSANY07dOfPuunP/2p4ZVhTlwC DIgAfOutt4ZCQQIwgDxHAAZgUnZ7a1NTk+HzWoRUKvXxj398+fLbDa8McwoGg6FQ SHUXgEobNmy45ZZ/TyQShlfWdT0QCAwMDBpeGQBkIAADMCkRgFtaWmRUFgH4Ix85 7ec//7mM4lAu+Tc0TRMfdNV9ASq99tprt976E0mXgZWXl7/++kYZlQHAcARgACYl NQB/8IMf+sUvfiGjOGTTdf1vI66gui/A1H7961/fdtttySQBGEC+IwADMKnWSbIC 8MKFCx988CEZxWEITdMSiYSWRr4Fjt1LL730n/95h67rMopXVFRs2PC6jMoAYDgC MACTkheAhblz5z7++K8kFcd0iEw7FXGFzHM5G5UBSZ599tm77pJ17oMADMBCCMAA TEpqAO7q6nr22VWSimNKZiE3niZp6QnAdDz++OMrVqwoKJDy4FdVVbV+/e9kVAYA wxGAAZiUSL8iAUsq3tzcsmbNGknF80dmFXfqrcASLmBOK1eufOCB+2XM1Z81GYCr 169fL6MyABiOAAzApKQG4JqamldffU1S8ZwxtT85s37LQVzAulasWPHYY48WFhbK KE4ABmAhBGAA5nXyyYslVa6srGTDXuZ+oETa1ClcADnp7rvvfuKJX9lsNhnF/f7A O++8I6MyABiOAAzAvOQF4JKSkt//fpOk4iYxNWUqE3HZnAzks//8zztWrVolaQWY AAzAQgjAAMxr8eJFs2dLeZmy2WxvvLFZRuWs0XV9KtwKrN8COIxly5atXv2StADs f+edARmVAcBwBGAA5rVo0UJJI1tE2S1btsqobJRUKjWVbxmhDOAY3XLLLS+//LLN RgAGkO8IwADMK4cD8NT528yUKeZLAZCKAAwAGQRgAOZloQCcSstcBZQZmDz1VuD8 LQC1CMAAkEEABmBeagPwVHyd+sX+yLQALIQADAAZBGAA5iUvAM+ePXvDhtf/dqlW xvsCAOUIwACQQQAGYF7yArCwevUaSZUBwGwIwACQQQAGYF4EYAAwBAEYADIIwADM iwAMAIYgAANABgEYgHkRgAHAEARgAMggAAMwLwIwAMxMNBp1e71Tv73r5z/f+Prr BGAAIAADMC8CMAAcygER96/S15LHYrFEIpG5s028/e8H7t+6dRsBGAAIwADMiwAM IJ8dIeJGo3FNS70XcVOZ/znELeUrVz60ffsOAjAAEIABmNfChScVFkp5XBPPiGvX rpNRGQCm7+gi7nvruQeNuIf3wAMP7Nr1R0mvqD6ff2CAAAzAGgjAAMxLXgBOJpPn nfe1iy++WEZxAJgyzYj71yXcmUbcw9i7d+/KlQ95PB5pAdg3MDAoozIAGI4ADMC8 pAbgM8/81NVXXy2jOIC8cviIK/5pIpH4X7uUJUTcw9u9e/ejjz4aiYQlHSohAAOw EAIwAPM66aQFNptNRmVNS37wgx/493+/RUZxALnkkPl2Vjri6no0PW7qvRO4f92o nN02D2fr1q1PPPEr0dfs2VIe/AjAACyEAAzAvOQFYPEg2NfXd9ddd8soDsAqDhdu 0ybzbTQaj8f1/UZMTS7eZt5axO9+97vnnlslaflX/Dn4fP7BwUEZxQHAcARgAOYl LwALjY1NDz30kKTiAMzgCIu36buCJsPte8u2745QtlS4nY51k9ZKOlGSDsC+wcE9 MooDgOEIwADMS94ZYKGiouLJJ5+SVBxAFhw+34o0m7kLNylibTL57tJtdg/fmsSq VavWr/+tpJ8nEoABWAsBGIB5Sb0HuLi4RDwUSioOwCiHGTGVmS81uXKbTIpkm0wv 5KbS/yjbXZrbk08+uWnT7+XdKufz+ffsIQADsAYCMADzkhqACwoKX3zxRUnFARyt gwddkXLTu5Qn820ymdmrnMq5LcqyPfbYo1u2bCEAA8AsAjAAM1u8eJGkmaWz0tv2 1qxZK6k4gIM63HJu5jiupmUWcvW83KssyUMPPdjf3y/vVjm/XwTgvTKKA4DhCMAA zOvkkxfLKy4e2r7ylb+/9NJL5b0LIA8d/lLcWDQa17SU/t5M5cyiLkFXpoGBdx5+ +GGfz0cABoBZBGAAZnbKKe/Tpd2lqWna3/3dR6+//npJ9YFcdVQRd+pSXFKuKv39 /b/61eOJRELShhoRgH0+/969BGAA1kAABmBeH/jA+0VMlVRcPJbPnXv8z372M0n1 AeuaZsR991JcIq65bdiw4bnnVsk7TiJepf1+EYCHJNUHAGMRgAGY1wc/+MFEIi6v PlcBA/ubzL0eDxE3x6xdu3bdurXy7lRPrwD7CMAArIIADMC8Tj31w+KJXF798vLy p556Wl59wFpGx8b2jY+r7gIGW7Xq2fXr18sLwJqm+Xz+oSECMABrIAADMK/TTvtI KBSSV7+oqOi5556XVx+wltHx8X1jY6q7gMEef/zxN974g+QA7BsaGpZUHwCMRQAG YF5z5vRWV1fLq6/rqbVruQkJeJcIwBP79qWkTZ6DEg888MCuXX+UNAJ6FgEYgNUQ gAGYV29vT01NjdR3kUqlksmkeDQsKyurq6traWnp7u7+f//vn6W+U8CcRAB2TkyI rwjVjWCGdu3atXnzZrfb7ff7otGoiKYFaVLfaSKREAF4eHhE6nsBAKMQgAGYV09P d21trZJ3/V4wtolgXF9f19ra2t3dw6XByG0iALucTi2RUN0IjkAE3a1btzqdThF0 I5FoMpmNoHsoImZ7PN6REQIwAGsgAAMwr+7urrq6OtVd/C+ZgbjiQbOionJqxZhg jNwgArDb5UrEJY5ex1HZuXPn9u3bXS4RdAPhcCiZTCoMuociunK73SMjo6obAYBp IQADMK+urs76+nrVXUxLJhgXFhaWl5fX1dXb7a29vXMuueQS1X0BR0EEYI/bHY/F VDeSd0TQ3bFjh8vl8vl8IuhqmiZeTMwWdA9FBGCXyz06SgAGYA0EYADm1dHR0djY oLqLY5LZSm2z2SoqKurq6tra2ufMmXPhhReq7gs4CBGAfV5vNBJR3UjO2pnmcDj8 fhF0w9k5oyubrutOp3N0lPnhAKyBAAzAvNrb25qamlR3IUVmxVgE4/Ly8oaGBru9 TQTjb37zm6r7Ql4TAdjv80XCYdWNWF5/f/+uXX8UsdDr9WaC7uzZs+XNYVZu3759 Y2PcIA3AGgjAAMyrrc3e3NysuousmgrGFRUVU8H4G9/4huq+kBei0ejI6KjIwKob sYwdO3a8+eabTqdDBN1IJJJIJHI76B5UQUHB2CQCMABrIAADMC+7vbWlpUV1F6bw 3hljW2XlZDBubbX39vaylRqGGx4ZcUxMqO7CdLZu3bp7926XK19WdI+KzVa0efNm 1V0AwHQRgAGYV+tk/m0RD5qqGzGv/bdSn3POuRdccIHqjmBto6Oj+/btU92FYn/8 4x9feulFl8ut9nohq/D7/e+8M6C6CwCYLh4rAZjaSSctEOlOdRdWoqeVlpbW1k7e 0tTb2/vtb39bdVOwjNHx8X1jeTTNaMOGDX/605tutycQ8MfS469F3OWHbtOXSqV8 Pt/g4B7VjQDAdPESD8DU3v/+U5LJpOouLC8zjLqoqKiqqqqhobGzs/Oaa65R3RTM SATgifFx8QmjuhHjrV279s9/fsvj8YZCQXNeqGtFmqb5/f69e4dUNwIA00UABmBq vb29NTXVqrvIWSIGzJ49u6ysrL6+3m5v6+vr4+7iPCcCsGNiQrfyT502btz45z// 2el0+Hy+aDQ6i0VdmTQt6fV6hodHVDcCANPF9wMAptbV1Smymeou8ktmubikpLSm ptput6c3UV+uuilkiQjALodD0zTVjUzLq6++8pe//MXlcvn9/kQiwaJu9ul6Kn0J 8KjqRgBgugjAAEytvb29qalRdRd4d9pWZhN1S0tLT0/vlVdeqbopGE8EYLfLlYjH VTdyoHXr1oms6/F4QqFgPB4vLCwk65pBYaFNpN+xfDo3DsDqCMAATI2bkEwumUyK bFxSUlpdXWW32y+++JL6+vqGhoaSkhLVrWEmRAD2uN3x9DioLBOfS4FAIBqNrlmz Znh4KBQKJxIih88WUZcNzKZVUVGxYcPrqrsAgKPAdxQAZrdw4Unct2lRmQFmBQUF NputsNBWVGQrLi4+5ZT3X3XVVapbw8GJAOz1eGLpo7OGe+mll7Zt2xaLRTVNfGpo mW0FItxyRteiGAENwIr4fgPA7D760Y8GAn7VXcAwpaWlzzzzrOoucHAiAPt9vkg4 LKP4Lbfc4na7+HlWzkgmk16vd2hoWHUjAHAUCMAAzK6zs7OhgTlYuaO4uGTVqlWq u8DBiQAc8PvDoZCM4jfffLPP5+Xsbi6ZmJgYHeUAMAArIQADMLu2Nntzc7PqLmCY mpqaxx57XHUXOLhoNDo6NubzemUU/4//+I+xsVFWgHNGaWnp4ODg+Pg+1Y0AwFEg AAMwu9bWlqamJh6ac0ZPT8/dd9+jugsc0sjo6MQ+KZHml7/85Ztv7rLZbDKKI/u8 Xp8IwKq7AICjQwAGYAG9vb01NdWqu4AxPvzhU3/4wx+q7gKHNDo2tm98XEbl559/ 7rXXXiMA54ZkMunxeIaHR1Q3AgBHhwAMwAK4DTiX/P3ff/WSSy5R3QUOaXR8fGJ8 PJVKGV75jTfeePzxxwjAuUF8HEdGRsbGpPysBADkIQADsIDW1pbGxiabjV3QueDS Sy8799xzVXeBQxIB2LFvn67rhlfevXv3vfeuIADnBp/PNzAwqLoLADhqBGAA1vB3 f3daMBhU3QUMcO21Sz760Y+q7gKHJAKw0+FIaprhlcfHx5ct+ykBOAdwARIA6yIA A7CGjo72xkZ2QeeC5ctvnz9/vuoucEgiALucTi2RMLxyJBK57rolRUVFhldGlhUW 2kZHR8fGuAAJgPUQgAFYA7Ogc8bKlQ83NDSo7gKHJAKwx+2Ox2Iyil911b+yApwD mP8MwLoIwAAso6enu7a2VnUXOFarV69R3QIORwRgr8cTi0ZlFCcA5wBd110u98gI 858BWBIBGIBltLXZm5ubVXeBY5JMJtete1l1FzgcEYB9Xm80EpFR/Oqrry4sLJBR GVlTWlo2ODgwPi7lsmgAkI0ADMBK3ve+k2XczoKsIQCbnwjAfr8/EgrJKP79739v 9myePSxMfAn7fL69e4dUNwIAM8Q3IQBW0tHR0djI8VEL0zTt5Zd/rboLHE40Gh0d HRUhR0bxa675ga7rZGDrKigoGB8fHx1l/BUAq+I7EAArYRRWDuAMsPmNjI5O7JOy wXXp0n8TAVuEKBnFkQVc/wvA6gjAACymp6e7rKwskdBSKV0k4aKiIvGW52mrKC4u XrXqOdVd4AhGx8b2jY/LqHzTTTf6/X6+YC0hJV5kdV1LE7+w2Wzi74TD4eFhxl8B sDACMACLaW1tOdTwlY6OjnQWFom40GYT/2dj3qzZVFZWPvHEk6q7wBGMiq8xOVe8 Llv203379rGJw1SmUm4yLfPbg25yFi+/4i3jrwBYGgEYQO5rb29PB+N0Mi58Nxiz BqVEY2PTQw89pLoLHIEIwI59+0QQMrzynXfeuXfvHgJw9qVSKRFup3KurmeCbnJM zk86AMC0CMAA8tp7i8YFU8FY/IIJPfJ0dnb+4hcrVHeBIxAB2DkxIWKS4ZXvvXfF 7t272Zohz9Ryrgi376Xcgy/nAkB+4iEPAA6ivb09nYon30ztpmbR+NjNnz9/+fLb VXeBI5gMwA5HUtMMr/zwww9v376NFeBjlFnOTSS0ZFJ7b9uyLv6H5VwAOCICMAAc nY6Ojkw2zmyozkzhYtF4mj7wgQ/ceONNqrvAEYgA7HI4NAkB+Jlnnt6wYQMrwNO0 36ZlLZNyxW9IuQBwLHhiAwBjpBeNZ6c3Uxek91MXZjZUq+7LXD7xiU9cffX3VHeB I5gMwE6nlkgYXnndunVr164hAO8vlUrtv2k5vZ6bEol3bEzKIG4AyHMEYACQrqMj s6G6cP8N1fm5aHzuuV+69NJLVXeBIxAB2O1yJeJxwytv3LjxqaeezMMAvP+VQvsN W2bTMgBkWz4+fsHq0tcwTH7qivggHim4jwGW1tnZccB46txeNL744ku++tWvqu4C RyAvAO/atev++3+ZwwH4b1NuIsGmZVibeO6aPXt2KpX5Hc9dsDwCMCzAbreLp6Wi SbYDzlu+t3MsqWkJIbN/jJdm5IDMonFm2dj2nhxYNL7qqqs/+clPqu4CRyACsMft jsdihlceGhq6447brR6AD3GlEJuWkQtE3J2acCEevjK7lvZ/7koPYJt85hJ/ia9o td0CM2D5ZynkMJF7S0qKy8vLi4uLp/9fiaeQSCQSi8X4oTtyVWbROLObOvOMIn6T /vF8yvwJ+Sc/uXXRokWqu8ARyAvAgUDghz+8XnzSGl7ZQKn0Upf4ajrYcm6ClIvc k17jLRCBt6SkpKysbPpXHsTj8XA4HIvFeeKChZj9UQn5qa2trby8rKKi4lie5sUT TCQSFWFYPK+Mj/O8gjySTsiZWVym21Z9//0PtLa2qu4CRyACsNfjiUWjMopfddW/ mmQFWE8Tadzv95NvkZ/EC3JxcVFZ2oyLiCeuUCgUDkdGR0cN7A2QhAAMcxEvxCL6 VlVVGbiQJZ5pgsFgNBodHeXHk8hT4itLpODZB5dZP56dXlWe/JXUW52ef/4Fk4Qf HIYIwD6vNxqJyCguLwBnBk1lfi0+o8XnfCAQ0PXJv53638S/oGlJ8fc5MoP81Nra Il7wS0vLKisrjLriXnxlia84EYNZdYDJEYBhIh0d7bW1tfIejMJpIyP8eBI4HLu9 taWlRUblZDK5bt3LMirnm0QiIXUXsdQAfPXVV0nakuB0uoaHh2VUBnJG+oivTbzI 63pSRn1N07xe7/DwiIzigCEIwDAF8XJcUlJaW1uThROM4XAkFAqNjPDSDBxcW5u9 ublZRmUzBOBYLDYxMeFMc7mcXq8Iet70qoV4YQilJwjE4/HJIQLJpJZZPFTb8EGJ AKnr765qFrxr8jR4cXFxaWlJaWlpRUVFeXlFVVWVeF2tra2rr69vTBMf2elsdBQB 2O/zRcJhGc1///vfnzVLynl1l8udSMRZ1AUOSjxr2Ww28Tog+x2J1yXx0hqLRfli hDkRgKGeeEUWD2rV1VXZfKfhcDgYDHFYBfhb7e1tTU1NMiqLyLZ27dqj+k9EInW7 3Vu3bq2trRW5LhQKhkLhaFREs8ysu7jH4xFfy8FgIBqNir8p/o5IsLr+7sgiwWYr 0rTE1M5Y8xyHViXzxyJ+kbl+S/xBFRTMnpo3ng7RxQXpA+SlJUKpSNHFxZPhuqRE /JPJdC0itKZpPp+vt7e3oaFB/J2jamDJkmvFfy4jAItPlXicAAwcKDPYWdIL+6H4 /ZM/WOTrESZEAIZi4kW5omJymSL77zqVSonnZpGEGV2InCe+0Kb/FNLR0S5viWD1 6jXT+dcuuuhCl8slAq3Nlu951fzSEbqwoqL8n/7p/05nwtnSpUuj0YhRxw735/F4 YrH4NM8fpq+Un8XTOXJb5qxve3tHImH8td5HFAgEQiEyMEyHAAzFent7ampqFDag 67rf74/FYkz+RE6awVN+Z2dHQ0ODtI4AWbxebzQam/4AnsxXxyxiMHJUa2trWVlp dXW1whvyfD7fwMCgqvcOHBQBGCqZ5zk7kUiIGJy+MInHIOSIGS9wdXV11tfXS+gI kMvn80ejkaP9aSYxGLlHfFYXFRXX1taY4dCHy+UaGmI6HUyEAAxl7HZ7Y2ODGV6a p4RC4WAwyI5oWN0x7u3s7u6qq6sztCMgG/z+QCQSnvF2HjZFIwdk9jw3N4tP5pTq Xt6VTCadThcPVzAPAjDUEC/QNTU1x3LruiS6rvt8fkYXwrqO/SG+p6e7trbWuI6A LAkGg6FQ6FjOs5CBYWl2e2tJSWlNjco9zwcViUR8Ph9fWTAJc315IH90dnY2NJh3 j2U0GvX7A8yIhrUY9exOAIZFBQLBcPiYAvAsdkTDmjJznuvr6021sW5/Lpd7aGhI dRfAJAIwFBAv0w0NDUVFRaobOZxUKpU5TsYzEKziqEY9HwYBGBZlSACeZdyXEpAd 6WFXZTU11aobOZxEIuFyufjKghkQgKGAhUbsxGIxEYNZCob5GfjITgCGRRkVgGex FxoWkVn4raurs9lsqns5MrfbvXcvi8BQjwCMbLPE8u/+0kvBvmiUU8EwL2MXrBiC BYsKBALpq92NudOODAyTy9xypPYuyaPCIjBMggCMbOvo6GhsNMXVR0clEokGAv7R UWYYwnSMekzPrCQUFRVXVlZYYjEBOICu66FQKBaLaVpy+rcBHwYZGOaUHvVcKJ6m CgoKVPdydJxO1/AwVyJBMQIwsu24444Tj9equ5iJZDLp8/nYvQOzOcbl33TutZWU FJeXl5N7kRtEEo5EItFoNJHQjiUJE4BhQuLTsqSkpLa21myjnqcjGAz9z//8j+ou kO+s95UDS7PbW5ubm634kj0lOClkyNoCcOzE11QqlZrBA3pmASGTey10JAE4Kslk MpOEZ7wmTAaGqdjt9rY2u/jEVt3IDIlvWBMTE0adUwBmxsI5BFbU2dnR0GC9/c8H SCQSXq93ZITJWFBvBsu/IjMXF5dUVJQXFxdL6gowGxGAw+GwSMK6njyqLxkCMExC fCrabLa6ujrTXnQ0TS6Xa2iIXdBQiQCMrOrr66uqqlTdhQFSqZTX64vFmIwFxY4q ALe3t5WWllZWVlp6FwZwLCKRiEjC098aTQCGGdjtreLV20Lzrg4jEAi+/fbbqrtA XuMZCNkjHiMaGxtz6ZCheIoKBALs5IFC0wnA4t8pLp7c6iyen7LTFWByiUQivSAc Gxs7wmhDAjDUSh9XKWhqas6Zn1tqmuZ0OvmagkK58sUEK2hrszc3N6vuwmBsh4ZC R3w0T+92Lq6qqsqlHzwBRtF1PRgMRSKRw8dgMjBUSW97Lqqrq7X6tucDTExMcK0G FCIAI3s6OzsbGupVd2E8tkNDlcMs/xJ9gWnKXJ4kYvChnsgJwFAil7Y9H8Dlcg8N cacGlCEAI3t6e3ty8nU8Qzw/BQJBpkMjmw4agNM3ZJRWVVUSfYHpS6VSwWDwoDGY AIzss9vtLS25tmluis/nGxgYVN0F8hcBGNkzd+7ciopy1V1IlEgkPB7v6CjboZEl fxuAOzo6amqqudYImBld1/1+fywW23+4AwEY2ZSZ9lxbW5vDP8QMhcJ/+ctfVHeB /EUARvYsWHBizj+Xi4cnr9e7dy8be5AN+wfgtjZ7RUVlbv+MCcgOEYADgaCmJTJf XwRgZE1mC09dXa3qRuRKJBK7dr2pugvkLwIwskS8pgt5cvmK3x8Ih0M8LUG2TAAW b0tLS6urqwsKClR3BOSOUBqjepA1dntrZ2dnPB5X3Yh0qVRq3759PCZBlbxIIzAD 8bIuArDqLrInEon6/f4jXrABzJj4mhLPEIWFhTU1NcXFxarbAXKQrus+ny8WE4Ek NYtFYEiTvuuosL6+Loe3PR9ABGBukYQqBGBkSU7egXR4mqZ5PN6RkRHVjSA3tbZm BoRW58nGCkCV9EpwmPkOkCRz15FIv3m1i4ebkKAQj03Ikvb29qamRtVdZFv6hiRv LBZj3QDGstvt1dXVZWWlqhsB8oKmaT6fL5FI8GIOY9ntrSUlpbW1OXtHxqE4HE5W CKAKARhZ0tnZ0fD/s3ce8FGVWf8PkN5nMkmmpJDQEd3i66qL/l1fO4iCYIFdFGys vRIQbAgigiIoIF0QsKMLqKhrwwYoHaRKSULatDu9l/+ZGTdvNqRMZu65z52Z8/34 4YPJveceZu69z/k9z3nOKSjAsNy9e/fhw0d89NGHoDYx7EeP2Wy2WmlLMMEbJSWq /HxJcnIP1o4QRGJhMBgdDge1uyP4AtSvUqn0er2sHWkDiKm6det29dXXfPbZZ6Et APyi0+lqa0/zbpYgwoEEMCEQZWWlUqkUw3Jubu6WLd/BX+bPn79q1RsYl4geiJmM RtoSTPBAeXlZfn4+pT0TBBMsFovVaqOXORElYt70G5K+t9wyety4cR6P56abbrTZ bLxfRa/XU8sMghUUQhECUVZWBi96DMsKhfLTTz8N/d3n882cOfP9998T4Uaa4JZg rq6OdpEREQIBU2ZmVm5uDmtHCCKhsdvtZrOFtgQTESPaTb/+INddd/39998f+gmE LiCDtVoN79fS67mamhrezRJEOJAAJgSivLxMIkERwD17Vnz00Uctf2K1Wh988IFf fvmlRw9x5YjCuAIamKY8iQiAgCknJycrK4u1IwRBJLlcLqPRRDsYiQgINa7Lzxdd p1+Px/vnP/95+vTpaWlpLX7oufvuuzCmeyAcqq4mAUywgQQwIRB4ArhPnz7vvff+ mT8/fPjwhAl3m0wmjItGA7hks9loSzARPnK5PDc3NzMzg7UjcYLf7/f5fPCXbt26 JQdJC5CekZGelZWVmZmVEwQ+87y8PIhTpVIpUgmDiCksLNTpdFqtFoJIQxCzGV4t ZsBmC9YsttldLqfTCUrN6XZ74B/dLYjYVpxiF7fbbTQaT58mDUx0AYVC3rNnT7vd ztqR/wJeifCqmzNnTnl5eatfgQC+555/1tbyP3FPAphgCAlgQiB69ixHmu/s16/f O++8295vFy1atGTJYrHFfCCAIVSlSipEOID6BRlGBZ87xuv1hsrghXZHB/8EsRfQ e1deeZVEIpEGKQyCNBknTuobGzmdzu3x+IOa32KxgGwDwWwKYrfbtm/f7vP54MPz +30tTwypZdpt3gGgDeCTJA1MhIlCoSgslIkqIAnlPI8ff/vo0aPbPABu8vvuu7e6 upr3S8Ozc+oU/2YJIhxoYCMEory8XCJBEcC9e/d+//0POjiA47jx48edOnVKVJGc y+WCtz81wSM6Ri4vDqrfhFv7BUELYSIIM3hs09LSsrOzZTKZVFoAnwboWFCw8L8g ZYuLA58Pa2dFjcPh0BsMgb/5/fB3l9vt83rhg4VP2Bde7Vm73a7Xgw0DKOfAErPZ ZLFYLRYzxxngVxAfByvEdgP93KNHD1G9ZgWA1oGJcIA3eY8eyfDqEtXOLHgP9OzZ c968+ZmZme0dAw/4P/854fRp/ss1wwsEQ1cTRDgk1kBFMAQvBRqk9b/+taHTw957 772ZM58XVXAGAahez9EuMqI9gvt+c7Oy2g1N4oOQ1gUdC2q2V6/eZ5111rnn/hm0 Lmu/4pD/E8MhgpLY6XR6PQGi7yQHevjYsWMnThyvq6vX6XRWqwVsxv0yMu0HJjoG 3uQpKamgfsXzIATXfZMee+yxq666quMj4c1w5513YCSsUQo0wRCxPIpE3IPXBkku V2zevDmcI41G47hx406ePCGqQYjjDFQIkTgTiJmysgKbUVk7wjMQTqWkpIC+LS8v HzBgwHnnnde/f3/WTiUuLSVxYH0YxHBwfTi0SszLJSB0Pnz4cHV1dUNDPbyE4QaI v4Vi+OhMJjPVhSbORC6XB0teiShRBR7tXr16zZs3v2Wxq/aAB/bWW8fq9Xre3aA2 SARD4moEIsRMaWlpQQGKAIZI+quvvgr/+LfeemvWrBdElYZEZbGIM8FLmhAYCLby 8/PLy3sOGjToggvO79eP5K5Iab0+nBSYooOvz+l0htaH/fBtegOrxQFtHMVysVqt PnjwYGih2Gw2xUdpLmsQ2tVCtEShkJeVlcETxNqR3wkt/D7yyCPXXHNNmKfA8z5m zGiMeqI6nR6jthZBhAMJYEIgSktLkMqopqenb926rUunaDSaW265Ra/XYfgTGVQW i2hJSYkKnpcYXSXzer0ymaxPn77nnXfeJZdckpuby9ojIiraEMZJSRDTw8/dLpc3 sAc4KiDCPnDgAEjimppqvZ6Duz5G9bDRaHI47A0N9BonAiiVCngTiudmBu0rkxUu WbIkOzs7/LPcbvfIkTe4XC7e/dHpdLW1/G8tJohwiMnoiohFIKCHkQDDcrdu3Xft 2hXBiTNmzHj33XeSk5N5dykyIKA0GIwNDbSAkOgoFApQv8nJIkpS6BhQvFlZWX36 9LnooosvuugisXUMIjD4r9xpu91us/2+MsyH5d27dx84sP/06dM2my228qX1ej1I BUrnSXCCJa96SKVS8eSaweN54403TZgwoasnggAeNuxaDJe0Wi1VjyNYETODChHr qFTKwsJCDMsQcu3duy+yc0E533nnna2afzAEhiiO4+rqaCNZ4hIrZZ/hXs3JyTn7 7LOHDbtuyJAhoYrNENBEX0iJiDlaieHAynCw1jQvxo8ePfrzz9t/++241WoRvxim xkhEsORVikQiEcnaL7yTk5NT5s+f37t37whOh2d5yJBrMJS8RqOhaIdghagHEiKe UCoVRUVFGJa9Xu++ffsjPh1itVtvHQsxlkjiKlARoIEpLyhhweuYHT2hir79+vUf NWrUsGHDUlNTm38Fcb9eryf1SzSLYfgLiGEelTBw6NChH3744eTJE6FKWnyZ5Rfa DJzIgPpNS0sTT/kGiCj69x/w6quvRmzB6XQOHToEI1dOrVbTY0KwQhQRP5EIKBTy 4uJiDMsQc//4409ZWVnRGFm8ePHChQvEkw5tMBggeqQ8ukRDqVQUFhaKZC6mGQih cnJyLrzwr3fddWffvv3OPAAiJLPZDJpEbJ4TDPk/JRxaE3a5+CornRQs6b9ly5a9 e/eYTCbxvLeb4TiD00kv8IRDLpf37dvXZDKydiQAhEZer/eee+4ZOXJUNHY4jhs9 +ha+vGpJU1MTbZgnWEHBCiEQ8oD+LUaKjxcvXnL++edHaeTgwYO33XarJ+qCLnwB isJqtVIIlTiILfkZ4qf09PTLLrvswQcf6mD2CrSNxWIh9Uu0x+9K2O+3B3HzWk3H 7XZ9/fU327ZthbeleNaEKRE6AVEE8fl4y3eIBnh7p6amLV68WKVSRWlq+/btzzzz NC9etQQ8BAFMEQ7BCopXCOEYNOgspKn6Rx99dOzYW6O343K5br117OHDh0USylNp 6IQCr1d2V/H5fBdffPGjjz5WWVnZ8ZHwyECgD8eL5JEhxExICQfKR9vtLqeTxwXh pMDb0vrFF19AsA5mxbD30mKxWK02KmqYICiVgcqFIpmCgUdg0KBBc+e+woupd999 d/XqVdGbakWw9vuvvJsliDChkIUQjv79+6Wnp2NYHj58xDPPPMOXtfnz569YsVwk IxmVhk4Q5HK5TFbANpkTYp3c3Lw77rh93Ljx4RwPEYxWqyXpS3SJ5tRouw1Eq5X3 pJsDBw58+umnGo2aeWo0tTlNBMRW8Nnr9d5xxx233DKaF2swKLz00ktff/0VL9Za Au+Bw4eP8G6WIMKEAhdCOPr06R3lTt32+OMf//jGG6t4NLhz58677rpTJBV9qDR0 IlBR0TMvL4/V1SHK6dmz5wsvzBo4cGCYp5D6JaIkpIQddjvIYLfbza9xUJ7r1q2F NyfD1WCj0Xjy5ClWVycEQKVSikf6ArNnzznnnHN4NPjIIw8fOnSIR4PNWK3WY8d+ w7BMEOFAsQshHJWVFbm5uRiWi4qKPv/8C35twtv5hhtGqNVqfs1GBpWGjm8UCkVh oYxJpB6SvnPmzGmzulV7OJ1OCO4p85mInmYZDK9cD98yuK6ubs2aN1nJYHhANBot 5e/EK6WlJeLpdQQ6fPnyFZmZmfyaHTNmtF6v59dmCJPJdOLESQzLBBEOFLsQwoHX 3yUlJeXnn3/BsPz444//+99fiGGE8/v9BoOhurqGtSME/1RUVOTlocwNdQDcUfA8 LliwcNCgQV060eVymc1mt9tN6pfgi2YZbLFYvHwnRdfU1KxYsdzpdAp/xxqNppMn KcqPQ8rLy+D9KYZ3YLBkw/976qmnMIwPHTrEy18bs5ZAPHPqVDWGZYIIB/aPLpE4 lJaWFhSg1PiBAWDv3n0YloH169dPm/asSHKcTCaTzWajwonxhEIhLywsFHiSBR6Z Rx55JMy9vi0B2azX60n9EhgEer+p1YG2SXY77ztQvv76682bPxV4Y3BwEVhDvV7i Cbm8ODMzEymdrat4PJ5HHnl06NChSPavuOJypOCHdsgTbKEIhhAOlUpVWCjDsAyh 0k8/beU9+aeZY8eOjRkzWiQdkqxWq8VioYgqbujZs2d+vnC7fyEiP+ecc5YtWx5Z RTqI5vkt3ksQLWmuFG2zWl1OJ7/G3W7XokWv19fXCTnfZDAYT506JdjlCFQUCnl2 djZSNZOu0r17j4ULF1ZUVCDZt9vtw4dfjzTXqdFo6+qoTxjBDBLAhHAoFIri4iIk 43PnvnLppZciGU8KhmUjR95QXy+KSlTgjNFoJA0cB8jlxTKZTLBVKdCuzz47bcSI EZGdHlr75dclgjiT0FKw0+Gw22y8LwVv27Zt/foPBHvoQuXiKG0nDmCSrdMeRUVF y5YtT0tLw7vEjz/+OH36c0jGm5rUtD2eYAgJYEI4INYHkGYTR48eXVU1CcNySyZP nrR582YxjH+h/qv19TR+xDalpSUFBQXCXCs1NfXDDz9SqVSRnW61Ws1mM2U+E8Lw +1KwwwF3He+7gnU63UsvzeHXZseXoxKGsY5SqZBKpcx7ayUF5zH/9re/TZkyFftC ixYt3LhxI4Zlv9/f1NREs0IEQyiUIQRl4MABEIVjWP7Tn/68cuVKDMuteOedd2bO fF4MW4K9Xq9er6f2SDFNv359MzIyBLiQTCbbtOnjiBtxgxph21GGSEzgxmtoakJK h37hhRfsdju/ZtsErnLkyFEBLkQgIZ52RzDu33//A9dff70A13r00UcPHvwVw7LL 5Tp4EKW7EkGECQlgQlD69OmTlYWyU7egoODLL/nv1d4m+/fvv+22W8XQJZjaI8U0 SqWiqAhrU0BLSkpKNmzYGLF8hWDFZDJ5PB5a/iWEJ5QObbfZHHyLVXh/vvjiLLi3 +TXbJmq1mhJ2YhRRtTuaN29+//79hbnWLbfcbDAYMCxbrbZjx45hWCaIMKFohhAU vHYvMDjt3LkLw3KbGI3GESOGg/gU7IrtQe2RYhe8xmAtKSws/Oyzz6OJ3uA+BxEi kviPSEB+18B2u8Nm49cyaOAZM2bY7TybPRNq+hKjiKfdUW5u7vLlK4SsPn311Vch Wab2YARz2D/SREJRVlYqlaJ0QvJ6vfv27cew3AHjx4/fvXuXGIZGao8Uc8jlxfAs IO0IaAbsb9nyXcSZz0nBwN3Jd/YpQXQVvHVgt9v19NNP82vzTFwul16vp1d0DCGe dkd+v/+ss86aO/cVga+L1wMJnoWaGuqBRLCEfeBOJBQlJSqZDKUTErBmzdpBgwYh GW+PuXNfXrVqlRi2BoVqFFGAFSsolcqiokLUS3i93k8++bS0tDRiCx6PByIVn88n hlkeIsEJaWCb1ep0OPi1rNVqX3xxFnZ9I7VaI5I+AkSngPrNyckRQ7sjeI2PGnXj hAkTBL7ukSOHH3roISTj8MSdPk09kAiWUExDCApqJ6S77rr73nvvRTLeAZ9//llV VZUYEkTtdrvJZKL2SDEBdv6z3+9/7LHHx44dG40RCFMg/OLLJYKIkpAGNptMHr7b cX377beffbYZdaKHsqBjBYUi0LKCtRcB4PU7derUv/0NscVje6xevfrtt99CMk49 kAjmkAAmBEUuLy4qKkLSin/5y1+WLFmKYblTjh8/ftNNN/p8PiZXb4nL5eI4Aw0t 4qd//37RZCZ3ikql+vjjT6KxAGIDQnZa+yVERagutNFg8PP9vp05c6bZjFgQCzw/ fPgInn2CFxQKhUxWIIasLnj3Ll68pLy8nMnVq6qq9u3bi2EZIiW1Wk3ZagRbKLIh hAYv7pfJZP/+95cYlsPBbDZfd911BgP7sljBtFWOcu3EDPYKg9fr3bz5s4hb/iYF F5A1Go0YSp0TRCtASdbV15uMRn7N6nS6F1+chap8mpqaKENHzCiVyoICUbQ7ysnJ feONN7Kzs1k5MHr0LUhlPmkmiBADJIAJoenVqzInJwfDssCFoNtk3Ljb9uzZw3zR DPQPDF20x0a0lJaWFBQU4Nk/99z/Wb58eTQW7Ha7wWAQQ2I/QZxJfWOjXqdzu1z8 ml20aFFtLWJFfdDY1LVOtJSUqCQSCXP16/f7BwwYMG/efLZu4JWANpvNx4+fQDJO EGFCApgQmvLyMhhjMCyD6tuzZy/zkH3mzJnvvvsOczdgENXrudpaKrQoRiorK/CK i8KD8M0330YjsMGC0Wh0uVzMp3IIok0CidCNjYFEaF6TFCA0nz79OTwJZDKZTpyg 7i9ipLS0VCqVMH/j+Xy+YcOGPfDAg8zduOqqK5EeBI7jqHEjwRwKbgihQS0EvXjx kvPPPx/JePisX79+2rRnmU8kJwXLrgTKxtBmG5ExcOAAvAZIFRWVH374YTQWrFYr ROrMJ3EIogPqGxsNHMd7RejZs1/Ea/DucrkOHjyEZJyIDLm8OD09XYCW7J3i9Xof fviRoUOHsnYkaffu3U88MRnJOJWAJsQACWBCaFALQY8ZM2bixCok411iz57d48aN Yz6dnEQtgsWHHAKu4iKke8Pv9y9ZsjTKaSCDwWC320kAE2Lm92pYHMfvIvDRo0dX rlyB93g2NakbG2kbsFgQT7Nfn883d+4rwrdybJPXX1+0YcMGJONUApoQA+yjcyLR QC0EPXDgWevWrcOwHAEajWbYsGFOJ88LFBFALYJFhUqlKizESoKIfie83WazWK1e r1cM0zcE0QFIi8CTJiG2tdNotHV1tPwlCsTT7DclJXXVqlWohSG6xP333/fbb79h WKYS0IRIoPiGYEC/fv0yMlAKQWdn53z//fcYliPD5XINHz68oYF9QWZqESweysvL JRKsdLvBgwcvWLAwGgt6vd7pdNLyLyF+HA4HaGAj3xnLy5YtO3HiOL82m+E4Q3U1 dQNmj3ia/RYWFq5c+UZKSgprR/6PESNG2O02DMt2u+PIESoBTbCHBDDBgMrKytxc lELQPp9v7959GJaj4e677/r555+Zr6eBqjEYjJR6xJzevXshNbfw+/0QSP35z3+O xoJOp/N4PMxvV4IIBxDAOq3W43bzaPP48ePLli1FegQsFstvv2GpayJMRNLsF963 f/jDH2bPnsPWjTO58sorkOZATSbziRNUAppgD4U4BAPwCkHDcLJly3d5eXkYxqNh 9uwX161bx3xVze12cxxXX08amCUDBvRPS0vDsBz9BJDdbocAnfKfiVgBBLDZZLJZ rfyanTjx8eTkZH5thnA6nYcOHcawTISJUqmQSqVI32/4wOt6+PDh9957H1s3zsRk Mt144yikIYBKQBMigUIcggGoeyCffvqZESNGIBmPhg8++GDatGeZD7qgbfR6jjah sSJQAKu4GCm2gCfr448/icYCRCcuvnurEgQeSKWwZs6caTabeDTYTLAOVhPtgWQF vCSlUvbNfj0ez8MPP3LttdeydaNNNm/ePH/+PCTjtAeeEAkkgAkGoO69ufzyK+bM EV1CUYidO3feccftzNfWfD4f6Jza2tNs3UhMlEpFURFWFfSbbrr5iSeeiMYChOYQ oDO/RQkifOobG/U6nZvXiZv169fv2PELjwZbolarKQ2HCaWlJRKJhHkqls/nf+ml l8455xy2brTH9OnTf/zxByTjMMRQLRJCDFCUQ7Bh0KCzkNZCS0pKNm36GMMyL9TV 1Y0YMcLtZrzIBiKH4ww1NZSJJDSofbDffHPN2WefHfHpcFdAaE4CmIgtMLKgq6ur Fy9+nUeDLaE+qEwoKyuTSPKZv9x69EhesWKFXC5n60YHjBt3G1KnLo/Hc+DArxiW CaKrUJRDsKFv3z6ZmZkYllNSUn7+GWvmnhdsNtuwYcP0eh1rR5KMRqPdbqdkPCGB IEwqRdkA7/V69+3bH42FYJk0A1/+EIQwhLKgDXo9v2bxtgHr9RxNPgqJXF6ckZEh huIgubl5q1evBmdYO9IRQ4cOgdEEwzIEP0ePHsOwTBBdhQQwwYaKioq8PJTW89HL AAHw+Xxjxow5fPgQ89los9lstVpJAwtGRUVPpDgs+qkfi8Vi5buYEEEIQH1jo1aj 8Xo8PNqcPHkS0vvZaDSePHkKwzJxJqB+s7KycnJQGk+Ej9/vr6zstXDhQuYJ2J1y xRWXI+2RNhpNJ0+exLBMEF2FBDDBhrKyUqlUimR8zZq1gwYNQjLOIxMnTvz3v79g roFB84DyoW05wtCrV6+cHJQeSNFXwDIYDE6nky9/CEIwQAAbOM7pcPBoE68Oltls OX6cOiEJgUIhVyqVSOuZ4QPq96KLLn7qqafYuhEOR44cfuihh5CM6/X6mppaJOME 0SVIABNsgDGpqKgQyfi4cePx3uD88tprry1btpR5RUq73W4ymUgDC0Dfvn0zM1Hy 3y688K+LFi2KxoJGo/H5fHz5QxCC4XA46urrTUYjjzaXLl2CtFpls9mPHj2KYZlo CajfoqIi5lPMIL9Hjx5z++23s3UjTJYvX/7BB+8jGVerNfX19UjGCaJLkAAm2IA6 Mv3xj398441VGJYx2LRp09SpU5hr4OD+T2NDA9UmxWXgwAGpqakYlseOHfvoo49F Y6GxsZF5sEgQkVHf0NDEa+WejRs3bN26lUeDzbhcroMHD2FYJppRKBQFBeyb/YL6 raqadMUVV7B1I3weeeThQ4dQbs5QkUWaZydEAsU6BDPwlEBubu6WLd9FcKLP52Oy P2fXrl3jx49jvjXI7XZzHEf9OVA5++xBSJMd06fPiLKrZENDA/ObkCAio76xUdPU xGMKw44dv6xfv54vay0BUbR//wEMy0QIpVIhlbJXv3A3vvzy3Ggq8wvPyJE3IFWC oHkfQlSQACaY0bt3r+xslM2QMOrs3bsvsnPVajVem9YOqKurGz78eg+vRVwiACIz vZ6jPvVIyAMNsIuRVlnfe+/9Pn36RHw6PDVNTU0kgIkYJdANWKt1u918GWxoaHj1 1fl8WWuJ3++HZ41KDyKhUqmkUgnzpKru3XusXLlSzO2O2uTKK69AGgUsFstvv9HW d0IskAAmmFFeXi6R5GNYhvDiyy+/lMki2WMMcQnoEyYa2Gq1DhlyjcmEUnYlfEAI cRxXW3uarRtxiTxAMYZluOd37dodTeDi9XrVajUJYCJG4b0OFrwJp0x5Amm6CtQv UqvVBKe0tEQikTB/j2VlZa1Zsxap1yMeer1u9OjRSPc8xxmqq6sxLBNEBJAAJphR UqKSyWRIxh9/fOLf//73CE4M1QFipYHh0iNHjjx1inGfAFBToIGpWiPvKBSBJWAM yx6Pd//+qLp/kQAmYhoQwCaTyc5r9ubEiROTk1EWEpuammgzJO+UlZWC+mVeyECl Klm2bFksvks//PDDpUuXIBnXarWnT1NyGSEWSAATzFAoFMXFWCLzr38dvHDhwghO NBqNjuAaAisNDNx7770//fQj81HcYDDAR0F5ejyCd89H3/6aBDAR08DLqr6hwWgw 8Ghz4sTHkfaRNjWpqeIgj8jlxenp6fn5KDll4eP3+88999yZM19g60bETJkyZdeu nUjG6Z4nRAUJYIIZMGIVFhYibdQpKCj48suvIjjRZrOZzebm/0Var+uUmTNnvvvu O8zViMlkttmspIH5QqlUIM2qRLPvPQQJYCLW4b0QNJ4AhmeNyg3yBcQSmZlZubk5 bN2Al/CwYcMeeOBBtm5Ewy233GzgdQqpGRhfNBoNxRKEeCABTLCkb98+SJtk/H7/ nj17IzjR7Xbr9fqWP2HVSHDNmjWzZ7/IvI6l1Wo1my20XY0XUNtf7969J5rTSQAT sU59Y6O6sRFe/nwZrKqaiDRFSw1R+UIul+fkZGdlZbF1w+Px3HPPPSNHjmLrRpTg VcCy2WxHjx7DsEwQkUECmGBJRUXPvLw8DMsQA23Z8l1kxpuaWk9SstLAX3311SOP PMy8miUM7TqdjnasRQ+eAIb7c9eu3dFYgEemsbGRBDARu/DeCYkEsMhRKOQFBQXM p4lhiHzmmWcvvvhitm5EiclkuvHGUUihjtFoPHnyFIZlgogMEsAES0pLS2D0QjI+ cWLVmDFjIjjxTAEMFBYWMtEGBw4c+Mc//s58PzDElFqtlnL2ogQvBTop6hXgJOoD TMQ4IIC1Go2Xv2ZymAKYUqCjBV6nMpmM+SsLBsfXXnutX7/+bN2Ino8++mjJksVI xnU6HbWWIEQFCWCCJah64IILLnj99Uje5hCatJlEB2Mtk8VYEOTDhg1zu13CX7ol 8JlotTpqERwNeDd8xDn/LWnvzieImAAEsE6r9fDXCpgEsGhRqVQyWQHzqeEePZJX rVpVWIi1sUVIJk+etGdPtLOo7UE3PCE2SAATLJHLi0EPIM3g5udLvvnmmwhONBgM TqezzV+xyray2WxDhlxjNBqFv3RLQB3pdDrqZBAxeFWgoy+ClRRoAql38yceCEJg QADrdTq3i7e5QqoCLU5KSlQwFjNXv9nZ2WvWrM3IyGDrBl/ceOONZrMJwzIMTyCA qQIWISpIABOM6devL9L4EbEksFqtFoulvd9KJJLU1NQo/IoQkbQI9ng8ej1Hu9ci Q+QC2Gw222w2XvwhCOEBAczpdC4SwHGNUqmUSiXM9/3GbrPf9sCrgGW3248cOYph mSAihgQwwZjKyorc3FwMy36/f9Omj0tLS7t6IsRPHMd1cEB+fn5aWloUrkXO3Xff 9fPPP7Od+fZ6vaCBKRc6AsTcBzgpGKaYTCgrAAQhAAEBrNe72snfiQASwGJDpVKB +mVbGBJCiz/84Q+zZ89h6APv1NfXjx8/Dim0gGHlxAnGc/cE0QoSwARjQKAWFEiR jI8ff/uDD0bSlK/NOlgtycvLS09Pj8ipaHn22Wc/+uhDthPPEAHo9XqqadFVFAo5 UmdpXgSwz+fTaDTw5TLPLSSICOBdAOPtAYYhhurqd5XS0hKpVMr27QQvyauuuvqx xx5j6AMGK1aseP/995CM63QQLdQiGSeIyKAoh2AMah2siFVBpwIYyMnJQWpi3CmX XXaZXq9jculmQCZxnKGmpoatG7EFngCGr2Pbtu3RT8rAnU8CmIhR+BXAbrfrqaee QnoWSAB3lbKyMokkn/mrKS8v/91332XrAwaXX34ZXlY5VcAiRAhFOQRj5AFFUIw0 qkEov2vX7ggWS8Msh5udnZ2VlRWRa9Hyj3/8/cCBA8yjAYPB6HDYqbhF+JxzztlI q/fvvfd+nz59ojTCcRyPWygJQkj4FcANDQ2vvjqfF1Ot8Pl80edrJA4QJKSnZ+Tn 57F1A0KCvn37vvbaArZuYAA35DXXXI0XhjU1NVGQQIgNEsAEewYM6I+3pfb11xdf cMEFXT0rfBmQmZmZk5PTdb94YOrUKZ988glzDWwymW02Kw1vYXLWWQNTUlIwLM+d +8qll14apRGn02kymbxeL/P7iiC6Cr8CeP/+/W+9tY4XU61wu92//noQw3L8Aeo3 MzMrN5fNINsMqLhLL/3fyZMns3UDiZ07d0I4gWQcxpRDhw4jGSeIiKEQh2BPr16V eBpy6NBrZ8yY0dWzOi4E3YqMjAykOl6dsmLFildfnc+8EKUlCGngcMCb7nn00cfG jh0bvR2dTgcBOglgIubgVwB/++23n3/+GS+mWkGSIExA/WYHYeuGz+cbP/720aNH s3UDj9mzX/z666+RjJvN5uPHTyAZJ4iIoRCHYE9paUlBQQGS8X79+r3zTpd37HRa CLoV6enpeXlsErS++eabhx56kG1VzKRgp2KTydzYSLvaOqFv3z5IW8f/938ve/nl l6O3YzQa7XY7CWAi5uC3DdKqVauOHEGRqfC2PHr0GIbleEIulysU8nD2IqHi9Xqf fXba4MGD2bqByj33/PPkSawqzTqdjuplEiKEQhyCPXi9YZKC0nTr1m0RnBhOHayW pKamSiSSCC4UPUePHhk5ciTzvogOhwO0E1V26ZiBAwcg9ZEuKir6/PMvorcDAR98 j6AiSAMTsQUIYL1O5+ZJAE+f/hxSW2x4uA4ePIRhOW4A6VtYWMg8ucnj8SxZsrRX r15s3cDmuuuG4ZV+oI5fhDih+IYQBXiVgVALQbciJSVFKsVq6dQxHMf97W+XMA8X givnBhrtOgBvD3BaWvq2bZHM9ZyJxWIxm83MbyeC6BIggHVarcft5sXalClT/H4f L6ZaQXuAO0ahUMhkBczTmnw+3/vvf8Aqt0tIrrjicqRPm+q9EaKFBDAhClDrYK1Z s3bQoEFdPSvMQtCtSE5Oxkvn7hgQn4MH/9Xj8TC5ejPggF7P1dfXs3VDtOCtAMPd umfPHl5MwZdoNBppJzARW4AA1mo0Xp7egRMnTkxORlEFtALcAUqlsqBAylz9du/e Y8OGDUiTlaLiyJHDDz30EJJx2u5OiBYKbghRUFlZgVdHavTo0VVVk7p6lsFgcEZU TAVGbplMFsGJvHDppX8Dz1ldPYTX6wUNXFdXx9YNcdK/f7/ou/W2ScTJDm3icDg4 jqNFYCKGAAGsaWry+fhZtp048XGkfSXwcB0+fATDcqyjUqmkUglz9ZuTk/P++x+w 9UEwFi1auHHjRiTjJpPpxAms3cUEEQ0kgAlRUFKiwhONvXv3jmAws9lsZrM5siuC bCgsLIzs3OgZNWrk8ePHWV09BMSger3+9GnSwK3BK4Ll9/u3bPmOx4Q96glMxBYg gJt42n9hs1mfe+45pAwIKoLVJhAGSKVS5pNuZWVlS5cuY+uDkEyYcHd1dTWSca1W S2EAIU5IABOiQC4vLigoQEo3ArM///xLV89yu90g4SK+KFsN/MAD93///fds81dB j+n1XG1tLUMfREjv3r3wuno8/fQzI0aM4MsafINNTU2UBU3ECvUNDU08FaLftm3b hg3/4sXUmVgslt9+YzxHKTZKS0ulUgnzMeu8886bMeN5hj4Iz9ChQ7xeL4ZlCKJ0 Oh31RyTECUU2hFjAEwYej2fv3n0RzCtHUAerJTCWFxVhVbfulDlzZq9bt465euE4 rrq6hq0PoqKioideVZXLL79izpw5PBq02+1ms9nn8zG/kQiiYxwOBwhgI08bQFav Xn34MNY2XaPRePLkKSTjsUh5eRmrHgrNgPodPnz4Pffcy9YNgYF3+5VXXoGU6k8T PYSYoZiGEAvl5eUSST6S8Xnz5l9yySVdPStKARyCYS+H99577/nnZzDPKAv1laVp 4BCo93lpaenGjZv4tRnxZniCEJL6xkYTvGp4alw0a9YL8OLixdSZcJwBL+k0tpDL izMyMphXWgYd+MADDw4bNoytG8KzdevWadOeRTJO9zkhZkgAE2JBpVIVFmJtAx46 9NoZM2Z09SytVstLalBBQQGrJr3btm27++67mNcUMZvNVquVNHBSYINZKV6vrMiy /TsFNLDdbmc+k0IQHQAC2MBxToeDF2tPPDGZFzttotfra2pob0hA/WZlZeXk5LB1 A0b5WbNePPfcc9m6wYTZs1/8+uuvkYxrNFqqhUmIFhLAhFhQKOTFxcVIxkFdf/zx J109y2g0OngKpyQSCVLzm045derUsGHXslLgzYAABhlMGhh1ogciuR07dmLcaSaT Cb5B0sCEaAEBrNdq3Xw0AfZ4PFOmPIE3b0jCICmofkH6ggBm6wZ812+8saq0tJSt G6y47bZbecl0axOw3NDAz558guAdEsCEiMBrkQqB+86du7p6lt1uh7ifLx/y8vKQ +t90CijPiy4azFy9wOdpNJoaeapSE6MolQrUneHTp8+49tprMSzDs2Cz2WgzMCFO eOyBtGPHL+vXr4/eTnuo1er6en6qVcco8gBY893hA3fLhx9+hFeVUPxcffVVSJap 2TUhciiUIUREr169cnJQhiIY5376aWtXJ5u9Xq9Wq+XRDRhoWU14ezye88//C18d MiPG6XQaDIZEnhXGjvwGDx68YMFCJOOgge12O5JxgogGHktAL1u27MQJxOI9jY1N iTwPqFDIGZbGaKZbt26bNn3MPDeKITabbfjw65G+CLPZwrwdI0F0AAlgQkSgloJ8 4okpN910U1fP4j07KDMzk+GWp4svvthiibC5MV+4XC6OAw2cuAsgZ501EKnjV1Iw 0eDbb7cgGU8KprIDVBeaEBUOh6Ouvt7EU9mqZ555Gq8Dttvt/vXXg0jGxY9CoSgo kDKXnZmZWR9++CFbH5izadOmhQsXIBmnBhCEyKEIhhARKpUSr3fuX/7ylyVLlnb1 LIztMenp6QyLXl5//XXV1dVs1YvH49Hrufr6eoY+MKRPnz5ZWZlIxr1e7759+5GM h4Cvz2QygUIgDUyIBH4rYE2c+DieQrNabceOHUMyLnKUSiWoX7ZFGf1+P7jxxhur GPogEqqqqvbt24tkXKPR1NUl6BBPxAQUvhAiIpAbWlyEFFVnZ+d8//33XT1Lr9fz UlWlFampqQzbHs6ZM3vt2rVsM9BAp4EGTsxKMBWYrYCTAk2/5l1yyd/w7IcIVTUj DUyIARDAWo3G6/FEb+rAgQPr1q2N3k57JGwTYJVKJZVK2Kpfn883YsSIRGv22yYO h+Pmm29CanHn9/ubmtSJnOdPiB+KXQhxMWBA/7S0NAzLka2MWSwWCPQx/ElJScFr h9Mpa9a8OXv2nORkxrEIaODTp08z9IEJpaWlBQWIX31kyQ4RAFGOXq/38KE6CCJi IJRvaGoy6PW8WFu8+HXU5qU6nb62NuF6IJWUlID6ZTvr6vF4//nPCaNG3cjQB5EQ 2jIw4e67kDIdQFcfOnQYwzJB8AUJYEJcVFZW5uZibZF98801Z599dpdOCW5Y5ZD8 6dGjh0yG1RGnUz77bHNVVRXzbDT4eBOtJSZ2IejU1NTt23/Gs98KiKUsFgvIYFoN JphQ39gYKM/G00wlagfgpIQsAV1WViqRSNi+H7xe75QpUy+99FKGPogHeGR27tix cMFrSPZNJvOJEyeQjBMEL1C8QogLGCnx1kVHjhz15JNPdvUsvC55ScH+THjbnjvl l19+ufPOO5hX4+Q4A+qSi9iQy4vhS8ebevD5fN9+u0XgHHuQwWazmXmZcSIB4bED sMVimT79ObxXIsgwjUaTUO3Qy8vLJZJ8tj7Axz5nzkt//OMf2bohEuBdXd/QsHzZ sl27diJdQq/XJ9q8NhFzkAAmxIVSqSwqwhKEZWVlGzZs7OpZqAI4KdiMAeQQq9nx 48ePjxo1ksmlW2I0mux2W+LEhX379snMxKqDBfzjH/947LHH8ey3h8vpNJpMJIMJ wfg9/5njkvz+6K1t2LBh27at0dtpD5vNdvRoolTAksuLMzIy8/Jy2brh9/uXLl0G OpytG+KhvrGR0+ufm/askaeq6WeiVmsStsglESuQACbEBQyZRUVFSBPwYHbnzl1d PUuj0QgQ0MtkMlbZyPAPHDp0qNuN1fYjTMxms9VqTRAN3LNneX4+4qoIdjOkjvF4 PBaLBam8CkG0JJD/bDTabTZerKE2QAIMBsOpUwmR7QJDeVZWFsOefyF69Eh+8803 CwoK2LohHpo3zE+aVIUUaEG8pFarE2QoJ2IXEsCE6MBbHIP38g8//NjVIdloNDp4 6q7RMRKJJDU1VYALnQkoz6uvvpp5i+BQYeFEGDhVKlVhIeL2b6/Xu2XLdwwrjYew 2WyghP18LM0RRJvwWP8Z7tXnnpuGOhGp0WgTofQ9qF94xcFbiK0bmZlZa9euRc21 iTkCDcMAvf7ZZ59BEsAJleZAxC4kgAnRgbo49vDDD99227gunWK3200mE447rcnN zc3IyBDmWq3weDzXXXddQwPjtCX4tI1GU9y3T0DNdAhx4403TZkyBc9++Ph8PpAW DoeDlDDBL6HdjEaDgRdr69d/sGPHDl5MtUmCrIzJAxSz9iJJJitctWoVXj/nWCS0 /AvPy9dfffnFF18gXSVx0hyImIYEMCE6SkpUeLWRzz777DffXNOlU7xer1arRfLn TLKysrKzswW7XCtGjx59+PAhVlcP4XQ6YQRtaIhzDdynT2/4rvHsw330ww8/4NmP AHiUQkqYtSNEnFDf2KjTaj08tWp/8sknvV7Enl5Wq/XYsd/w7IsBhUJeWFjIvLBi ZWWvRYsWsfVBhDTXS3/11fkNDVilyCFeOn06/tMciFiHBDAhOmAELSoqQioKlZaW tm3b9q6ehV0HqxXp6el5eXlCXrElDzxw//fff8+2ZYXb7eY4Lr6bhZSVlUmliCnK Pp/vo4/+VVlZiXeJiAElDGLA6XRSuSwiYvhd/m1sbHzllbmoyk2v52pqavDsM0ep VBQUFDBvrXfeeefNmPE8Qx9ES/N+gSlTnkDKxwGzarU67ueviTiABDAhRgYM6A9K FcOyx+PdvXt3V9OiBBbAScFWrgw3cE6fPv2DD95nO4vv8XggXozjSpLY3YCBc8/9 n+XLl6NeInpsQZhvFyRiC1C/jWq1yWjkZfcvsGjRotpaXHUa3x2AlUqlVCphm3Ls 8/mGDBn68MMPM/RBtDRPGMHLdvLkycnJKPMUTqfz0KHDGJYJgl9IABNipLKyMjcX q3rk88/PHDJkSJdO4TgOtTRom0AkwbB25eLFixctWsh2Lh/Gafjk4ziZauDAAahl zyAc3LlzV6zsgvN4PI4gJIaJTuG3+HNQEkxCfVJgBDl4kPHuEjxKSlQSiYT5eDF2 7K0AQx/ETKBdtk7ndrl27tz5wQfvI13FZDKfOHECyThB8AgJYEKMlJWVSqVSJOOD Bw9esGBhl06xWq0WiwXJnw7o3r17YSFWV+ROWb9+/bRpzzLPZ9Pr9bW1pxn6gEdF RU/sXPexY8c++uhjqJfAANQCKGH4M7C+xzQbnxAhgbUsEMAGA19pnBs3bti6FbH9 b1Kwm8DJk6dQL8GK0tISGK/Z7poB9fvww48MHTqUoQ9iJvTIGDkO/r5s2bITJ44j XQjG65qaWiTjBMEjFFgQYgQ1OzQ3N3fLlu+6dIrb7YbXOpI/HQNRBXaibAds2bLl gQfuZ66BOc4Ql3vnVCol9gQHfHc7duxEvQQ2ENqGVoY9PCW7EjFNqJKtxWzmq/YV MHnyJGz9ptFo6uricENHWVmZRJLPVv3Cm2H69BkXXnghQx9ETqD7Ecc5gwUIn376 KTd/z04r4jvPn4gnSAATYkQuL5bJCpH2qPh8vr1793X1LOG3AbdEJpOxUqEHDhz4 +9/HMK/qaTAYArv+4quDSPA+l2GnKD/++MS///3vqJcQEud/oAJaCUho66/NanXy V0v8u++2bN68mS9rbQIKTavVxt/rKz09Ha9nYZjAe+C1117r168/WzfEzO/djzgu lDFRVTURKZzweLxarSbO7nMiXiEBTIgU1CYxK1as/POf/9ylU9gKYADiDKTCYJ1S W1t7/fXX+/2M9YbJZLbZrHE2uFZUVOTl5aJeIjk55ZdffkG9BCsgngMl7HK5SA8n CM19XHi0OXnyZOz1S6PRdPLkSdxrCAuo38zMLLxSHWHTbeXKlUqlkrUboiaQ/Gww OOx2+Pvx48eXL1+GdKFEaPRFxA0kgAmRUl5ehlcG+Zprrpk584UunaLT6ZhnYObk 5GRmZjK5NMdx8KE5nYw7uFosVovFHE8aWIAsaODOO++67777sK8iBkJiOLB52OtF 6vNBsMLhcNTV15uMRh5tbt68+bvvtvBosE3iLP8Z1G92dk52NmIb83BISUldu3Yt w5aBMUFo+ddkMISmCOET+/XXA0jXgjihujoONysRcQkJYEKkoAqDgoKCL7/8qkun mM1mG08VR6MBBDDIYCaXhnEUNLDBwDG5ejM2m91kMjU2xkmbQQgl4W5MSUlBvQpI wW3btqenp6NeRYSADAYx7Ha7Q5KYtTtEhMDLR28w2G02ftUv3BdTp07F3l0Ct59O p4ubaTt5EHipsHUjJycXtByrrKgYor6x0Wwy2f6TNDFt2rMO/rYPtCLOJnqI+IYE MCFSQBgUFRUhbT2NYBuw0+k0GAwYznQVGPJZbbuCz+2GG0ZUV1czuXozMH4bjcaG hjjRwD17lgvwhf7lL39ZsmQp9lXED0nimCO07xf+5DfzOSnQ7O11Ad5mMHCcOsX4 nckXCoW8sLCQeUkIpVK5fPkK5m7EBCCAdRpNc/7axImPI1WdgPBArVbHzUQPEfeQ ACbES9++ffAyft98c83ZZ5/dpVOYbwNuJiUlBa9NVKeMHz9u9+7dbMt+gnqBsDI+ qk0qFIqiokLszxPE3tKlyy644ALUq8Qifr8/JIkBCBNpL7GoCKlfu80W2sHII0eO HFmxYjn28i/cXWq1pqEhHt5USqUCxh22fcXh8xw4cOArr8xj6EMMEeh+1NBg/M/c fXV19eLFryNdy2azHT16DMk4QfAOCWBCvKCujA0deu2MGTO6dIp4BHAS6xbBjz/+ +Jdf/pt56wu9nquvj4eEK9S5nma6dev+008/JWAidAR4vd6QHg4JY9pOzITQ9kWr 2cx715Zg8vOTPXqgLyHGjSpQKpUFBVLmLfEuuujip556iqEPsUV9Y6Nep3O7XKH/ feutt/bv73ILjDCJp0wHIhEgAUyIl5ISlUwmQzIO6vGLL/7dpVM0Go2oVofYtgie NWvW22+/xTYJDVQKaOC6ujqGPvBCaWkpBJfCXGjjxk0CXCgugcff3UIWi+ptEGeE Nv067HazyYTxOc+a9YKR1+3E7aHT6WtrawW4ECoqlUoqlbBVv3AbXHfd9ffffz9D H2KLwPxRsP1v80+ee+45ux2rlIlWqz19OubHYiJxIAFMiBe5XF5cXIS0zBjBNmAI mPCqR0RMQUEBq5y0lStXzpv3CvM1Ab0eQszTDH2IHrjVCwsFavU8ePDgBQsWCnCh BAHuQM9/CKljWi6OktDCr91m47HZb0uWLVt24sRxDMut8Hq9Go021iv2lZaWSKVS tvk+8Enecccdt9wymqEPMUd9UP22fIjwNgDDS6+pSR3rtzqRUJAAJkRN//798DI2 1617a+DAgeEfH6q9hORMNOTl5bHKa92wYcOTT05lvivMYDDEeveFioqewvTzgI/r 8suveOmllwS4lqgI9qg8eurUqZqaWq1Wy3F6s9lssVjsdrvT6QxpV4izfUHgUwr9 GbGaDZ7X+bkhXRGlZg4Z6Rake/fuoT+7d++RnNwjJSUlNTUV3g+ZmZnZ2dl5efkg ZlQqZUlJaWVlJau2au3x+8KvzQZfjA+nRNnq1asPHToojJyD8eLkyVMCXAiP8vKy /Px85rtdJk6suuqqqxj6EHOEZpGMHNf8bqmtrV20CGvqEy53+PARJOMEgQEJYELU VGCqgmHDrnvuuefCPx4CYo1Gg+RMlGRlZUF0y+TSP/7447333sO8ICfEmqBkYrcE pTClsEJASNSnT591694CaSTA5aIB4iq1Wg3PnVar4TgDYDabHA6n3W4DxQqq1ev1 gMSDI50uJ0R68E9LTUmBj/Ho0aMgcZtLPcPDG1KGrP9BIiIk8oOfSbcePbqDVIaX bWVlr2YVHToMPkCPx90D1HSQjIyMtLRUeN/kBciVSgsAmUwWZUOakPR1Op02q9Xl dPLx72sN6Kh5817RarWCPWUxXf5KLi+G75p5l124/WbOfOG8885j60bMUd/YaIIx sUXvxrfffnvfvr1Il4uDuR4i0aBogBA1qNuAi4qKPv/8iy6dIqo6WK1IT09nFawc PHhwzJjRzNWF2Wy2Wq2xq4F79+6dnZ0l2OVA5MyePeeyyy4T7IogcnQcp9Pp6uvq mtRNIA9sFrPJZDYYOIifrFabzWaFY4Ky1hvSZmwT7Inwga8MJF/oKwOdDHo4IyMz MzMjJycnLy8fXk3wJodXbnFxsUqlAs3cfGKz9HXY7U6HAymBfN++fevWrRVyns5i sf7222+CXY5fQP1mZWWx6jnfDLwEFixY2LdvX7ZuxCIggLVqdctOb9OnP2ez0QZg gvgdEsCEqBHbNmC1Wi3mDX4M2yPV1dVdd90w5mWBQESBDI7RnUgqlVLgyt5wMxcU yB577LEhQ4aEf1ZIx4b+XiCRhNLv4Qb48st/79ixw253lJeXa7UavT6QYwz6Fv7w BgktwzJPFiCYE8ozD60zd+vWPT1AWnp6RnY2iK5cCKZTU1N69ep1zjl/aCmVI2Pn zp2bNm1yOOwCz9BpNJq6upisUQ/DrlKp9PkYd8mG7+uNN1aBM2zdiEXgFV1XX2/6 7x1btAGYIFpCApgQO6jbgLvaDdgQXKlAcoYXGLZH4jhuyJBrmNcJC23VbmiIvcFY Li/Oz89nsp0b1EhFReX5559/+eWX/+lPf2qOk1wuV21tbU1NTX2AOojpa2tqIbSy Wq1utys0GfQfGUOjCcE/oW3YoZk1uMeSk1OCebm58KTk5uZKpVKJRApvPJlM1nzT er3ekydP7t2799ixYzqdlkmFAngLwWARi9koCoUcPk/ms1Spqalr1qxlnoAdo9Q3 Nuq0Wk+L5mGoHYBpAzARi1DIQoidCsxtwEOGDHn++ZnhH2+zBRYYkZzhCwgTIYJh IkhgIBw6dKherxP+0i0B2QbRZ3197O2+Ky0tiX7JK0qaKz81l1Zi6w9BdErojm2+ b5nftDqdLhZL0yuVCqlUyraoIZCbm7dmzZood5UnLDAKgwA2tuh+lBQo+bn2wIED SFekDcBELEKRDSF2SkpKZDIsSSCVFnz11VfhH+/xeCCyQXKGXyCOSUlJEf66Pp/v hhtuqK4+JfylWwLfFMdxMZeCKJcXSyQSivwIInZxOp3w8om55V+VSgkvH+bqV6lU LV++nPkSdOwC6pfT61tVkps2bZrDYUe6olarO3069qZ7iASHBDAhdhQKeVER1jZg r9e7b9/+Lp0i5jpYrcjJyWHV5uT222/ftWsn23UYkOJ6vT7mKnOIYRGYIIiIicXl 35ISlVQqZSs7/X7/WWcNmjt3LkMfYp1Q9yMDxyX9d7ES1A3AarU6FvccEQkOCWAi BhgwoD/emtjixUvOP//88I+PIQEMZGRk5ObmMrn05MmTPvvsM7YaGMZmjuNqamoZ +tBVGO4EJggiSmJx929ZWalEImH+rr7kkkumTJnK0Ic4IJD8bDA47P+12Hv06NE3 3liJdEWn03no0GEk4wSBBwlgIgaoqKjIy8NScf/7v5e9/PLL4R+v1+vdLWpLiJ/U 1FQIbphceu7cl1evXs08mQ3iUYhKYygkRe3+RRAEHrHVD0YuL05PT8/Pz2frhs/n Gzly1IQJE9i6EeuEln9NBkOrdgyrVq06cgRLoxqNppMnTyIZJwg8SAATMQDqNuC8 vLxvv90S/vFWq9VisSA5g0SPHj1YCao1a96cPXtOcjLjbq4mk9lmi6UWwX379mGV vk4QRGTYbLajR4+x9iJcQP1mZmbl5jJu9uvxeP/5zwmjRt3I1o04oL6x0WQy2a3W Vj9/5pmnXS4X0kVpAzARo5AAJmIAUW0Ddrvder0ewxNUGJaG/uyzzVVVVSDChb90 S2KrRbBSqWD1fREEEQF+v1+j0cRK8Xm5XK5SqbxeD1s3YPydMmXqpZdeytaN+AAE sFaj8Xpaf6e0AZggzoSiKyI2QO0GPHfuK10agGNrG3BLJBJJamqq8Nfdvn373Xff xTwXOrZaBKNm/hMEwS8xlAsqkma/oH5nz57zpz/9ia0b8UGg+1F9PQxwrX6+f//+ t95ah3dR6gBMxCgkgInYoAKzG/Bf/zp44cKF4R8fuwI4iV1p6GPHjt10001JSf7O D8XE7XZzHBcTqzRyubyggE0vK4IgugS8WHQ6fUwkmCiVioKCAuYpOX5/0uLFiysq Kti6ETfUNzbqtdozC5QsW7b0xIkTSBelDsBE7EICmIgNUMsCgSD88cefwj9ep9N5 zsgyiiHS09PxZhM6QKPRDB06hHkJMa/Xq9frY6JFMFXDIoiYIFZqX6lUSqlUylz9 ggNvvrmG+r3xRWD5t7HRyHFn/mrq1Kk+nxfpurFy2xPEmZAAJmIDuVxeXIy4DXjH jp3h5wZbLBbrGXUmYouUlBQIg4S/LnxuQ4ZcYzKZhL90S3w+H8dxMdGrs1evXjk5 2ay9IAiiXcxmy/Hjx1l70TmlpSUSiYR55nNWVtaaNWupyB+PgPrl9HqX09nq5x6P Z8qUJ5DmO/x+f1OTOiayHgjiTEgAEzFDv359MzIykIxXVU0aPXp0mAe7XC6uranW 2ALCoMLCQuGvC0Py8OHX19UxnjaGwdtgMFRX17B1o1MUCrlUSonQBCFSQmURxV9Z oLy8LD8/n3ldveLi4hUrViLVZEpMQt2PjBwHg1qrX33//feffvoJ0nXtdvuRI0eR jBMENiSAiZihZ89yvHaFAweetW5dFwpFxPQ24JbIZDIm6XDjxt22Z88e5tGYyWSy 2Wwib4+kUqlksgLmnxVBEK0AyaHV6phP53VMsN1RZm4u44p68FkNGDBg3rz5bN2I PwLJzwaDw24/81fz5r2CF6sYDIZTp6qRjBMENhRRETEDyIDCQqz9kCACd+zYGf7x cSOAk4KdkPEqbHdAVVXVF198zlzXWa1Ws9ki8jwu1NkfgiAiQ/waINjuSOn1Yu0C DRNQvxdf/P+efPJJtm7EH6HlX5PB4PP5zvzt5MmT8EZYjUYr8qkfgugAEsBEzCCX FxcVFSHtX4LB4+uvvwm/JodWq2UeUvBIRkYGk/WBuXNfXr16NfM9acH2SKaGBvGW hoabPycnNyuLds0RhFgIthY3iTl/RKFQFBbKmL9gYXgdOXLUhAkT2LoRl9Q3NppN JltbRUnMZvOMGdPxQia1Wi3mm58gOoYEMBFL9O3bB69yxvjxtz/44INhHgxDi81m Q/KECazKYq1bt27WrBeYbwkLtkcy1NeLtzS0XC6XSPLT0tJYO0IQRJLT6YQ3hpgz R5RKpVQqYf5q9Xg899573w033MDWjXgFBLBWo/G21Zbik08++eGH75GuC/HP0aPH kIwThACQACZiifLyctAAeMb/9a8NYR4M0Y/BYEDyhBWsymJ99dVXjz76CPNlCq/X y3GcmJs6iKSBJ0EkOPCu0Ol0Ym4nXlKikkgkzN8V8EE9/fQzF198MVs34pVA96OG BmM7ociLL87Ci1I4zlBdLerkf4LoGBLARCyhUinxFJrf79+zZ2/4B6vVaiRP2MKk LNa+fXvHjh3LXAPD1wrjek2NeEtDi6SNJ0EkLOJvJF5WViaRsC/47PP55s2bP3Dg QLZuxDH1jY16nc7tcrX526qqiXgjhUajEfMjQBCdQgKYiCXk8mIQwHhN7d55593+ /fuHeXw81cFqRW5uLl7Hqfaora0dPvz6Nit5CIzIS0OrVKqCAinzyQKCSEDgBaXT 6UVb+0ckBZ8BkN8rVqxUKpWsHYlbAsu/jY3Gdjoynj59esGC15AmQbxeLwhg0Q6R BBEOJICJGKN3797Z2VlIxocMGfL88zPDPBgGADGoNSSYlMUyGo1Dhlwjhs3V4IPJ ZBbtBr+SEpVUShqYIAQFXvh6vV60uyREUvAZSEtLX7NmjRh0eBwD6tfAcU6Ho83f rlu39sCBA0iXtlisv/32G5JxghAGEsBEjFFWVopXqyk/X/LNN9+EeTCoNUc7Y098 kJycHH5ZbL5wuVzDhl0rhvTy4DZvo2hLQ1MuNEEIicgznxUKhUwmigIB8F5avfrN lJQU1o7EM6HuR0aO8/v9bR7wzDPPuFxOpKvDg1BTU4tknCCEgQQwEWMolYqioiIk 4xDi7NmzN8yFtWDvHCOSJyKhW7dueJ92B9xyyy1HjhwW/rqt8Hg8HMeJNuSFZwFi TeZVXgki7glWiedEW/VKpVJKJOwLPgMVFZWvv/46ay/in0Dys8HgsNvb/K3P55s0 qQrvflCr1aJ9FggiTEgAEzGGXF5cUFCAN7v8wgsvXH31NeEcCWOMRqNBckNUQGiV mpoq8EUfeeSRb775Wgx1XDjOUFsr0tluhUJeXFzM2guCiGfsdrvJZGpoEOmGiNLS Uokkn/mGCL/ff8EFF06bNo2tG4lAaPnXZDC0twlr165d77//HtLV3W63TqejDcBE rEMCmIg9evWqzMnJQTJ+7rn/s3z58jAPjuM6WK3IysrKzs4W+KJz5768atUqMST1 GY1GCILFOeTL5cUZGRl5eXmsHSGIOISe/XDwer2jRt04YcIE1o4kBPWNjWaTyWa1 tnfAokWLamuxehmYzebjx08gGScIwSABTMQepaWlBQVY24BTU1O3b/85zIPVanV7 O3DiD/hkJBKJwBd9++23X3hhphg0sNVqNZstYi6LlZ+fL4YcSIKID9xuN6hfMZe8 ysnJzsrCKgkZPqB+77vv/uHDh7N2JFEAAazTaDweT3sHPPHEZLyr63R60aZEEUT4 kAAmYg/UtE+fz/fdd9+HOaduMBicTqw6EyKke/fueH2Y22PLli0PPvgA8wS/JNGX xYKAODMzIycnh3neOEHENH6/32w222x20U54iafkFajf556bfuGFF7J2JFEIdD9q aDAaDO0dYLNZp02bhjdiNjU1iXY7AEGED8VJREwyYED/tLQ0JOMTJvwTCOfI0N4w JDdEi1QqFbjC5+HDh2+55RYxyDqI9jiOE+2iUFKwHE5hYRHE8KwdiXn8/6HlT5KC leGa/wzTTqu/tDod/h5+IkkHRkKEaYdoD9C9VqtFtKXvkoLpHhKJRAzq1+fzL1q0 qHfv3qwdSSDqGxv1Op3b5WrvgM8///zbb8NtZtFVnE7noUPs61MSRPTQYEnEJBUV PfE2PvXsWfHRRx+FcyTIIa1Wi+SGmMnOFjr1TqPRXHvtUFf7o75ggAIJrfyLc1tg CJVKFVyrTywZDF8NPJIhHdijR3JqakpKSiqQnp6WEQTu2/T0jMxM+C8zKytwD4cI 3c8h4DD4bU5ODl9LKB6PR6fT8WKqU3w+n8VisdvtDocD/rRarbYW2O02+IE9iNPp gJ84gsDN7P4dj8/nDVXWAX2VaHI6KH2tdXXind6Sy4vT0tLy8/PF8NUkJyevXv2m 8K3yEpnA8m9jo5HjOjhm9uzZHKdHcsBoNJ48eQrJOEEICft3KEFEQEmJSiaTIRmH MHrPnr1hHpw4dbBaIfyWYIjXhw0bptcLpCU6xhLAKtoMyRAqlTItLT0nJ1sM4XJk gBiD5xH8By0LoT/IV/jngDoFDVBQICsKUhikuLhYVLF4SIKKYcomYjiO02g0uv+g 1WohsDaZTIFb3xoQz263C+R96AsSwyaFyAgmPFucToeYV32TgnscsrMZFCNsk9zc vNWrV2dkZLB2JLEA9WvgOKfD0cExVVUT8bID4CUg5gQoggifWI2KiARHoZBD4IsU 1kM89NZbbw8cODCcgxNWACex2BIMcmjMmDGHDx8Sg6JzOp1Go1Hk7RDF3CcpJG6T k5NB2UJYn5OTK5VKZbICuVyhVCrLysoqKipE63ybwC0RXFxNoLoAzYBUrqmpqa+v b2pqVKvVej1nMHDWIC5XQCd3D8LazbYR/7ZGpVIhk8nE8AHCM1tZ2WvhwoVicCah CHU/MnJcBzsmamtrFy5cgBcawaMt8ieFIMKEfRBJEJHRt2+fzMxMJONXXXXVrFkv hnMkx3ExvcgTPcJ3CZ44ceK///2FGDSw+LcEo+ZKdAxESyBxu3fvkZGRDvoWxG1h YaFCoQBl27NnRd++fWNL3LYHPP4h0Zs4BeEj5sCvv+7buxcUcnAx2WAyGUEew0fn crnhfmGYdC3ydS3xbPqFm/yiiy5+6qmnWDuSiASSnw0Gh93ewTFr1qw5ePBXJAds NtvRo8eQjBOEwLCPIAkiMsrLy/BScHNzc7ds+S6cIyGAs1gsSG7ECqE9k0Je8bXX Xlu2bKlIIkKj0ehwOMS5Jbhnz575+Vi75Zslbnp6el5erlRaAPq2pKSkshL0bb/e vXsLPDMiGG63O7TPlkRvlwi0b9FqPW53m7/1eDwNDQ319XVNTWqdTmcwGCwWM3zM bje6PDYYjKdOnUIyHg1yeXHw4coTyXzf6NFjbr/9dtaOJCK/L/8aDP7gFv32ePrp p9ztPF/Rw3FcdTVWe2GCEBj2r1SCiAylUllUhJV/CyP9rl27w+mqKmSFGzGTkpIi lWI1Z26TTZs2TZ06RQwaOCk4NW42m0WYG4aXKAHPyNat28TQhlQY4N8bKh/l6zAA JTognB2M7QECAIJ7pOddnEtbCoVcoVD6fF7WjgSA+7+qatIVV1zB2pEEBZ4ds8lk s1o7OAa+oyeemIw3JqrVmvp6Ue+TJ4jwIQFMxCpyebFMJgtHo0bGk08+NXLkyHCO TORtwC3p1q1bYWGhkCsVu3btuv328WJYG0kKrgoaDAZR1dGBZ6SoqAhpqx48er/8 sgPDsngArRta6fV4PKx9iQcgiDcZjXabLbLTJ0+ehPSwwxetVqtFlcShUimlUqlI Jvh8Pv/LL7989tlns3YkcYFnR6tWg8Tt4JitW7du3LgByQF4B2q1WlE9IwQRDaII HAkiMnr16pWTg1USc+DAs9atWxfOkSSAW5KXl5eeni7Y5erq6oYPH+7xYCV9dQmx dUgK9gTGypKorKxcv/5DJONsCa304mUSJiyBJi4NDUaDIbLT58yZrddj9XfRaDQi mb0SVa+jpECxwx4rV66Uy+WsHUlc4MGpq683GY0dHzZv3it40YjZbDl+/DiScYIQ HlG8XgkiMkpLSwsKsNJuu3fvvnPnrnCOhJiMYuWWhKI3wS4nqvZISf/ZFi6GdOie PcvxvogxY8ZMnFiFZFx4ErmAs5CAAG6KtHnYv/710fbt2/n1pxmDwXDqVDWS8fBR KOTCd1nvgLy8vFWrqN0RYwLLvxqNt7M8lEmTqvBKc+t0+traWiTjBCE8JICJGEah UBQXFyEZ9/v9mzd/Bpfo9MhgV8yOduYkIMJ3SPrHP/5+4MABkayZiCQdGrVS+rvv vtu3bz8k48JAtayEB0J5jVrt6zCTsz3q6uoWLHiNd5dCiGEbsKjSnuGh6Nu372uv LWDtSKITZt4Ex3EvvjgLbwRsalI3NIi65x9BdAlRBIsEETEDBvRPS0tDMn7TTTc/ 8cQTnR7mcrlg7EHyIaYRuEPS008/vWHDv0TSnZJ5dWjUDcA+n2/v3n0YlrEJbesF Ot5NRyABAliv07kjbR03ceLjSHUf2G4DFlW156Tgp3HFFVdOnDiRtSNEJ7XTm1m/ fv2OHb8g+eB0Og8dOoxknCCYIIpXLUFETEVFTwgakIyDfvj88y/COZK2AbdHRkZG bm6uYJdbvXrVSy+9hFcarauA0DKZzEwmzlUqVWEhVgfg8PuEiQSHwwHfRYK37BYD 4fQy7QDULi8ajbaujkE3YIVCUVQkaPnAjvF4PHffPeGmm25i7QgRXP6FRyaMGfbp 05+zRVperlOMRuPJk6eQjBMEE8TywiWIyECN8r1e7759+8M5kgRwB/To0UMmw/qO zmTLli0PPHC/SNIIk4J3EUQPIL0EXlyqwJwbuvDCvy5atAjJOF9QhrMICbOcT3ss Xbrk5MmT/LrUjPBRvlxenJqaCs+peN5XoH6nT59x4YUXsnaECBB+xgReckQSu7kh gsCDBDAR26DmeSYF6o6+dPnll3d6mFarpYzKjpFKpSkpKcJc68SJEzfddKOovhHh K2MNHDgAL//8hRdeuPrqa5CMRwNoXRC9NptNVN8+0ZJo6mDt2rXr/fff49efZlwu 18GDh5CMn4nY6l0lBWs3vP764vLyctaOEAHCX/7du3fvO++8jeSGCJuEEUT0kAAm Yp4+fXrjxRDnnvs/y5cv7/Qwk8lkjzSpL3EQMh0aBOd1110nntLQSYGlFa/RaKit PS3AtZRKRVERVn040JZ79uwVyV7rECBdQou9rB0hOidQB6upCaLqCM6FsyZPnoS3 XgqBfn29EBsWSktL8vLyk5PFsvCbFCz4/MYbq/DK5hFdBZ4UTq93hVGaftGiRbW1 NUhuwGB67NhvSMYJghUkgImYp6ysTCqVIBlPSUn5+efOC0tA5G2MNKkvoRA4HXr8 +PG7d+8Sz+a6pN+Xgq3Yu4JRGyBlZ2d///0PSMbDx+/322w2KmcVcwSyOrXaiLfy PvXUk57O+sFEjADNkBQKRXDdV0QLv/AonXXWWXPnvsLaEeL/gKCioanJEF7j68mT J+ENc3o9V1ODpa4JghUiigsJIjJQF7t8Pt/XX39TUFDQ8WEQQKjVaiQf4g/QZni1 u1sxa9ast95aJ54tdkn4u4Ll8mKpVIqX//zXvw5euHAhkvFOAeEEupcWe2MXEMAG jnNG+g0uW7b0xIkT/LrUDDyVer0e78EU247fpODr6Prrh99///2sHSH+i8DyL8e5 wnhMzGbzjBnT8VJyBEuLIAghIQFMxDwQVYBAxdtfOnbs2EcffazTw6gOVpcI9fwQ 5lobNmx46qknRRV0JgUKRDsgcKmv579XsEqlRG3C/OKLs6+88ko8+20S2tmLt/RH CEaUdbD27Nnz7rvv8OtSSzQaDUYHb6Uy8FSKKRklAKjfxx+feNVVV7F2hPgvurT8 u3Hjhq1btyJ54na7dTodbQAm4g+RvYwJIiIqKyvwNpcqFMpPP/2008PUajUVm+0S 3bt3R9VpLTlw4MDYsf8Q5lrhAzcMaGCQdvwWx+rdu1d2djaPBlsi5AZg+HysVit8 PpHtFyVESzR1sLC3AcMjefw4nyvMCoU8IyMjJydHVHsxkoLP16uvvtqvX3/WjhCt CWRJGAzO8AqLPP/88xaLGckTk8l04gRW3XWCYIi4XscEERklJSUyWSdZyhED8dbe vfs6PSwwXIVRrIJoRW5uLkSHAlzIaDRed90wGM4FuFaX8Hg84BVfGdEQbRcWFuIJ VAE6AIPGDule1KsQDAnUwVKrfZFu3kbtBgwvfI1Gw8ucVCjnGR4Z8XQmbyYrK+uN N1YJ2aSdCJMuLf8mITdA0mp1p08LUbiRIASGBDARD8gh0Cguwptff/XV1y6++OKO j7HZbGYz1ixsfJOSkiKVSgW4EIS2t9469sCBA2JbigGcTqfZbPF43FHKYNTyV8C1 1w6bPn06hmXa3Js4hN/dtE3efvutffs6n5SMmOhLYcGIlJycIpHki23nRVJw4bdv 377z578qqkLuRDOB1kcGgyO8GcCDBw+uWfMmkidwqzQ1qRsjTdYgCDEjuiiQICID RvTMTKyFxAsuuOD11xd3fIzX69VqtUgOxD2gSEEDC7NOMnv2i2vXrhVhYJoU3Bhs sVjq6uoiO12hkMtkMrx/GsRDGzduKisr49Em6F6r1UrZEwlFIMQ3Gh02W2SnazSa l19+CW8aK/Qyj3gRWKVSZWdnZ2Sk8+sVL8A/bcSIEffeex9rR4i26ery75Ili0+d OoXkjM1mP3r0KJJxgmALCWAiTigvL5NIsJohpaambd++vdPDqA5WlAjWKPiLL76Y OPFx0S6A2O120IQej6erq8GXX34Z6iwMSOsdO3byYgr+dfBvpPXexAS+9/qGBqPB ELEF1L4vSRFtfQyu+iZnZWUJs6cjAkD9PvnkU5dccglrR4h26erc0JQpT+AVH+E4 rrqaGiAR8QkJYCJOUCqVRUVYFZV8Pt+3327pVGCTAI4ewRoF19TU3HjjKFekSZgC 4HQ6QSK6XO4wM9BUKiV8dKiqIJxUiI6BWM1isdgiXfoj4gYI9NWNjRHH7qgLX0nB G1Wr1YZZDloul6empoD0Fay7WwSAOF+yZKlKpWLtCNEuoeVfI8eF+VzAu3T69Ocw GyBpMPoUEIQYIAFMxAnYzZBuu23cww8/3PExer0erzRLQpGTk5OZmYl9FVC/N998 88mTJ0S4JbgZn88XXCl1er0dLQgrFIqCAtwccojJ3nzzzXPO+UNkp9vtdgjXqJ4z EQIEsE6r9UT6wgT1u3jx66hPLrzM9XquoaHdDqgw6PTokZyengbSV7TpJEnBJ7ek pHTx4sV44yPBC/BQmIxGe9jzgx9/vOnHH39EcoYaIBHxjXjDPoLoKpWVlbm5OUjG w2mGBPE9aBUkBxIN0HIFBViVvVsybdq09es/EOeW4JZ4PB7QkCDaPR5vq6BcpVJK pVLsfwKE+Dt37urqWV6vN1TjGsMlInbpUqWfNpk0qQpbdsJ9azQaW60DKxSK5OQe qampGRkZIizv3Ap4AK+5Zsijjz7K2hGiExwOR6NabdDrw0+LeP75GRB1IPljMplP nOCzHxhBiAoSwET8wLwZEkRLHMchOZCY5OXlpaej15L57LPNVVVV4tfAzYAYdrvd WVlZEH+DKhbG88GDBy9YsDD84202GwRn1BybaJPotwEvW7bsxInjPLrUHk6nE564 pOAcUEpKivhFbzPg9tSpT1566aWsHSE6p6vLv0nUAIkgooAEMBE/YDdDmjdv3iWX /K3jY2gbMO8I0ySprq5u1KhRDgf1nm0bn8+3YcPGnj17hnOwyWSiLr5Ep0S5DVit Vr/88ktizj1mS2pq2tKlS2FYZO0I0Tm/L/9ynD/sTSIHDhxYt24tkj/UAImIe0gA E3FFv3598Spw/s//nLds2bKOjyEBjER+fj52gRmPx3Pbbbf9+qsYuwQzJzMz88cf f+r4GPgAQfrSNngiTKLsBgxMnTrV5/Py6FJ8AOqlT58+8+bNj6HF6gQHngWzyWTr yhaq119/vaYmqm7VHWC3248coQZIRDxDcR4RV5SXl0sk+UjGU1JSfv75l46P0Wg0 VOYHCWGWgpcsWbxw4cIYSocWhjvvvOu++9rtHQrS12AweL0kRYguEEHOZys2b978 3XdbeHQpDoDH8NZbbxs7dixrR4guAM+CpqmpS8EDaicwjjNUV2Opa4IQAySAibgC uxnSV199JZN1ZD/QwY9am2IiwK7g/fv3jxt3G01kNAMfxe7de9rMNSXpS0RMoOlL Y6MhiroJcGdOmlRF65zNgCJ65ZV5/fv3Z+0I0QXgQairrzcZjeGfYjKZnn9+BjVA IoiIIQFMxBVyebFMJsOLh8aMGTNxYlUHB9jtdhiZkK5OhBBgKRgiktGjR4u8Q5Jg tNf+l/p+EVFS39io1Wi8wRJTkYHdEDhWCPU6WrRokZh7ERNtElj+Vat9XZlG/Ne/ Ptq+fTuSPx6PR6vVUgMkIr6h2I6IN3r1qszJwWqGVFRU/Pnnn3dwgNfrhZED6epE SwToFTxv3ryVK1ckeDo0BENff/1NYeF/JT5QpgPBC/XBFWBnFPcS3IozZkxP8EVg GHduvvnmO++8i7UjRJeJrBz69OnTbTasnotms/n4cWqARMQ5JICJeKO0tASvfyzE Gfv27e/4GKqDJRggTeG7Rl2k3b9//+23j///7N15fJxlvf//NE3aJG2WJpOZyd4m 6crBI+rxyFePy/GgcjxH9KsihQeHo+jPg0ePqCRd2FpogbK0IGUtLULLUkBaCm26 sCir+BUpSumaLllm7tyz3TNZZpLZfncaTqndk9yfuWd5Pf/g0Sbt+77QhJl37vu6 PpFR3KFKdTNmzHziiSeO/FZ/u+YfzqN6wCmMfhiSbunSpS6XatSSUk529lj9fwEe e05RI3sIQnQAksfjaW9nABLSHAUY6UZ6GNItt9zy1a9+7RR/gAKcYPn5+UVFRXL5 mXw6dDQafeGFjbW1tUO/1d8YZfLPAiBhsACo6mi2kbtcrttuuzUDn9TgtOdUN/gD IEXxD3Mb/LvvvvvUU2uFlsQAJGSIjHs/h0wgOgzp4x//+MMP/+YUf4CNkYmnV9OS kpJx48bJXeLxxx9fsuSWTBs6On369CefHHynxeZ2CBksAJoWGt3g6KVL79BrsFFL SgnRaPQnP/nvb33rW2YvBCOnf/F73O7IMN8wLF9+d2dnp9CSGICEDEEBRhqqq6ud NGmSULhegd5558+n+AM9PT29w5nmB6Pk5OTIPf2edfhG00UXXeT1euQukVT0d9gv v/yyxVLOz3QgZ/As6K4uzesdTUggELjxxhsy50ZocXHJvffeK/qfO0gb8Snoc+Y0 y/0o1ufzHTrUJhQOJA8KMNJQZWWF1WoVCo/H488//0JNTc3J/sDAwIBvFIM9MEoF BQVyp6BlHX4G/vHHH8uE5y3PO+8rN910k8eTKYUfZnEoitfjCQ8MjCbk0Ucf2blz p1FLSlrRaPSCC77505/+1OyFYLRG9mXvdrtvv/02uf04qqo6HE6hcCB5UICRhux2 W1lZWW5urlD+BRdcsGDBwlP8AbYBm050XPDevXu///3/TO/7/PobrJdffqW/v9/s hSD9GXIUlt4M582bm94/mdL/m7Zs2Z1TpkwxeyEYrRE/+LB27ZPbt2+XWJIuHA57 PB4GICETUICRnurr64uKpG4DlpSUvPLK707xByjAySA7O3vSpElyT0Ved91169ev S8s33LFYbOHCG84991yzF4JMMfqBwLq//OUvjz22Ji036uv1/itf+WpTU5PZC4Ex Bm//er3h4f+E8frrrxsY3bMSpxAIdO/fzwAkZAQKMNJTdXW1xSI4DOnPf373FM1K VdV4PC50dQyL/n9TaWmp0ANju3bt+tGPftjT0yMRbqJZs85aunSp2atABgmFQp0O R2DUE7aWL1/e2ZluE1zy8/Nvu+32xsZGsxcCY4z49q/0Yw5ut6ejI92+fYATogAj PUkPQ2pqar744otP9llN03h2NKmMHz++pKREKDzNdgVnZ2c/99wGuR0EwAkNnojr co1yzpb+16+55uq0mVjGjt+05Dh89lV/KDTcv/jqq6+2tGySWFIWA5CQYdLkRQI4 3rRpUwsKCoTCGxsbn376mZN9tre3N/3uCqaBvLy84uJiiWSn03n55Zc7HJ2p/s5b f8N9//0PNDQ0mL0QZBxDdgLrOjs777xzWaqfCK23kfJy6x133GGz2cxeC4w0mmPP b7/9NrlTCfv6+vbs2SsUDiSb1H6vBpyC6DCkrMFh9Cc9iCIcDntHN9UDcvLz84uK iiSS161bd8MNpzodLcnFYrGf/ex//v3f/93shSBDORTF5/UOjPrxmTfeeGPDhudS dzOw3n6vvPIX559/vtkLgfFGM/i6ublJ7lEjBiAho1CAkbakhyGtXr3m7LPPPtkf 4BysJCdUgyORyJw5c7Zt25pyT0TrX9Jf/vKXm5vnmL0QZK6hm2MBTYvFYqOMevzx x//yl/dS7omMaDT6T//0+fnz56f6HWyckP4Vrqiq5vWO4JSQQ4cO3XffvQxAAgyR Yq8NwLDMmjVz3LhxQuFf/OKXli1bdrLPUoBTgtDeYKfTecUVVxw4sD9V7kHp78bO Pff/LFiwwOyFINMZ9SC07uGHH969e1eqdGC981dX19x8880885zGHIoS8PuDfX0j +LurVq3au3eP4UsaMjAw8MEH6T9GGzgiNV4YgJGZMmVKcbHIw65Zh28hvvnmWyf7 rMvlGv1NDCRGbm5ucXGx4fds//CHPzQ1NXV3B5L8Lbjefj/5yU/edNPNZi8EGDSa knCMBx98YP/+/cn/DThhwoSrr75G/zY0ey2QpX9tu7q6Rvbe4Oqr58u9qfD7AwcO HBAKB5JQUr8qAKNUXV1lsViEwqPR6BtvvFlYeOJpwxwEnXKys7P1/zfz8vKMjV23 bt0tt9wsN7lxlPR3VP/0T5+/9tprzV4I8KGhx0T7entHcEzu8R555JEPPtiRtM9i 5OTk/Pd//5TtvplgNLO+gsHg9ddfJzkAyd3R0SkUDiQhCjDSmd1us1qtcm99fvCD y3/2s5+d8FN9fX3d3d1C14WogoKCk/1cY8RWrlx53333RqNRY2NHSV/PD3/4o+99 73tmLwT4G0MduLenZ/QHYulefvnlzZtbkm1bvv7CdOml/zF79myzF4IEcSiKW1VH 9iqwcePG119/zfAlDYnFYqqqKgr7tpBBKMBIc1OnNk6YMEEovKKictOmEw/l4yDo VJeTkzNx4sTx48cbmLlq1aoHHnigvz+UDM9kxuPxW25Zcs4555i9EOAEjO3Ae/bs eeihFcnQgfXvu3Hjxl1yySUXXUT1zSCDm9sVxe/zjeyvL168SG62Ym9v7969+4TC geRk/pswQFRtbU1paalQeCwWe++9v5zss5yDlR70Dqw3YQMPZX3++eeXLVvq8XjM eixT/7qdMWPGkiW35ufnm7IA4EwMdeBgX9/IZsYco7+///7773c4Ok38vispKfnR j/6/8847z5QFwER6+/W4XJFIZGR/vanpKrmDwb1eb1tbu1A4kJwowEhzFRUVNpvU MCTdbbfd/i//8i8n/BQFOM0UFBRMmDDBqHfPu3btWrhwYeJ3J44ZM+a6664/99xz E3lRYGSGOnB/KKTX4BFMjjne+++/v3r1own+potGo9OmTf/FL37R2NiYyOsiSYzy 9u9777335JNPGLuko3V1qU4nA5CQWSjASH8zZ84w9kHWo51zzidWrVp1wk9xEHS6 ys/P18uwIT+P179CVq5c+cQTj7vd7gQ8n/md73znBz+4PGkPBAKOp5cHr6bp/+zp 7o6O9Aba0fRvuk2bNr722mvS3wh67500adIFF3xz9uzZfNNlMr39+rzeET/Mf889 yzs6Ooxd0hH9/f07d+4SCgeSFgUY6W/KlMnFxcVC4Xpp+dOf3jnhpzgIOu2NGzdO L8OGHBzd1dW1fPny3/3ud36/ZmwTjsfjele/6KLZl156qYGxQCLpBdjZ1RUKBg15 HHrIli1bXnnl5azDj0UYlZl1uPcWFhZ95jOf+f73v19eXm5gMlLR0JeuNoozQebO nSN3bITf7z9w4KBQOJC0KMBIf1VVlXLvQvR28fzzL9TU1Bz/qd7eXrlTK5Bsxo8f r5fh0T9roH/ZrFq1qqWlxel06F9dI37fM9R7P/7xc/R34Tx4iTRw5Faw/h/WSDhs VGxHR4f+7bZ/f+sov930f1qt1i996Z8vuuiigoICo5aHVOdQFM3nG/FML7fbffvt t8kVYJfL1dnpEAoHkhYFGOnPbrdZLOU5OVLPl15wwTcXLFhw/McHBgZ8I93zg5Sm N8/xh+Xm5o4mx+12Pfvsuldf/X1bW1uP/qY/EjnFzWH9LXgsFtNLeE1N7TnnfPy8 875SV1c3mqsDSejIruBQMGjsHhNFUf70p/+3d+8+l0sNh8P699opWkc0GtU/O3Fi YVVV5Wc+c+7553+ttLTMwMUgPXx4+1d/JzDSHexr167dvv1dY1d1RCQS1V9lGICE DEQBRkZoaKg3fLLrESUlJa+88rsTfopzsJB1eODnuHHjcg/Tu/Fofpavv1n561/f 9/u13t6+3t7eYDCof2FXH1ZXV9vT02vgsoHkNHQruL9/sAX3B4OGHI51PD1fVVXP IHcwGNK/hfPyxh8+E75wSn19aWlpcVFRZWWlxKWRNgbPvtK00Ty3f/311w0MDBi4 pKN1d3e3tu4XCgeSGQUYGaGmprqsTOrH89Fo9E9/ekd/e3T8pyjAOBm9Bo89TK/H Q7/QP6L/esxhR47MObotD73Rj59EOBwOGrc9EkhyH9XgYFCvwkI1OOuo79PxegfO z8/632/J0pISQ/b/I10NPa2g+XzxkT6qEIlE5s+fJ3c+osfjaW+XOl4LSGYUYGQE u91us1nldtH88pe/vPTS/zj+4xRgAJAzVIOz4nG9BvcFg3phGHHZ0A3+5Omwocab qzfe8eNpvBgZh6J0BwJ9vSN/MOd3v3tly5YtBi7paPF4vKtLVRRFKB9IZhRgZIpp 06YVFOQLhU+ePGXdunXHf9zr9YaNO6wFAHBCHzbhrMH39fqvB8JhvQnHD++MH3pw YvAf//uHx/yt3NxcvdkO/oT0b39ISuPFaOgF2KWqsWh0xAm33rpE7iSRvr7gnj17 hMKBJEcBRqaoq6udNGmSULj+Lmv79veO/3h3d3dfX5/QRQEAx/uoDJ8Zii4Mp38R OhwOv98/mpDm5ia555/1an3oUJtQOJDkKMDIFJWVFVarVS7//vsf+Md//MdjPqi/ BI7y9Q8AAKQWh6K4Xa5oJDLihD179jz88CoDl3QMVVUdDqdcPpDMKMDIILNmzTzh UVWGOPfcc++9975jPhiNRt1ut9AVAQBAshm8/et0+ofzGMLxHnzwgQMHDhi1pGMM DAx88MFOoXAg+VGAkUGmTJlSXFwkFK5X67ff/uPxH+ccLAAAModDUbxu9yhPAJk3 b65R6zme3x+Qa9dA8qMAI4NUV1dZLBah8Fgs9uKLL5WXlx/zcQowAAAZIhQKORVF G93hVX6//6abFh+Zh2c4t9vd0dEpFA4kPwowMojdbtMLqtyREt/97oXz588/5oMu lys2irEcAAAgVTgUxef1DvT3jybkt7995k9/+pNRSzpGNBrV35koCj+dR+aiACOz NDY2TJw4USi8tLTspZdeOuaDmqb1j+6FEAAAJL/B279dXZrXO8qcBQsW9PeHDFnS 8Xp6evbtaxUKB1ICBRiZpaampqysVCg8Go3++c/v5uTkHP3B3t5e/cVG6IoAACBJ OBTF7/eHRjf+UH8vMW/eXLmn1Tweb3t7u1A4kBIowMgsFRV2q9U6ZozUV35z85zZ s2cf/ZGBgQG5QfYAACAZhEIhRVU1rzcej48m57XXXtu0aaNRqzqGvjZVVZ1ORSgf SAkUYGSc6dOn5efnC4U3NjY+/fQzR39k6MVG6HIAACAZOBSlOxDo6+0dZc7tt9/m 8XgMWdLxgsHg7t17hMKBVEEBRsapq6ubNKlEKFyvu9u3v3fMBzkIGgCA9KYXYJeq xqLRUeY0NzfJPf/s82mHDh0SCgdSBQUYGaeystJqPXZYkVH0Arxq1cOf+MQnjv4g BRgAgDQWCoUcTqdf00aZ09raumLFg3IbtVTV5XA4hMKBVEEBRsax221lZWW5ublC +Z/73Ofuvnv50R9xu93RUf9IGAAAJCeHonjc7kg4PMqchx5aoXdgQ5Z0vHA47PF4 GIAEUICRierrpxQVFQmFjx8//g9/ePvojzAJCQCAdDV4+1dR/EYceDl//rxRnqF1 CoFAYP/+A0LhQAqhACMTVVdXWSwWofBYLPbyy6+UlZUd+QiTkAAASFd6+/V5vQOj /kl3d3f3okU3ZmdnG7Kq47nd7o6OTqFwIIVQgJGJ7Hab1WqVe425+OKLm5qaj/y2 v79fG/W+IAAAkGxCoZCzq0vzekcftX79urfffvv0f25EYrGYqqo8/wxkUYCRsaZO bZwwYYJQuMVi2bbtxSO/1V91XC6X0LUAAIBZBh9+1rRQMDj6qBtuWBg0IueEent7 9+7dJxQOpBYKMDJUbW1NaWmpUHg0Gt2+/b2j7zBzEDQAAGnmw9u/Pl/WqDfuxmKx OXOac3JyDFnY8bxeb1tbu1A4kFoowMhQFRV2q9UqN2ngmmuu/fa3v33ktxRgAADS jENRAn5/sK9v9FFvvfXWhg3PjT7nhOLxuKqqTqcilA+kFgowMteMGdPz8vKEwqdP n/7kk2uP/NblcsViMaFrAQCAxNMLsKury5DX96VL75DbLRUKhXbt2i0UDqQcCjAy 1+TJdSUlJULh8XjW9u3bj/zW5/MNDAwIXQsAACSY3io7HY6A329IWlNTU07OWEOi jqdp2sGDh4TCgZRDAUbmqqystFrLhcLj8fijjz76sY/9/dBve3p6ent7ha4FAAAS zKEoHrc7Eg6PPurgwYP333+f3LYsVXU5HA6hcCDlUICRuex2m8VikTtw4gtf+MKd d9419OtQKOQ36IfEAADAXPrLusPp9Bs043DVqpV79+41JOp4kUjE7XYzAAk4ggKM jFZfX19UVCgUnpeX99Zbfxj6tf7y4/F4hC4EAAASyaEoPq93oL/fkLSrr54vd1BI INC9f/9+oXAgFVGAkdGqq6ssFotQuP5i9vLLr5SVlQ39loOgAQBIAx9OP/J6DUnr 7u5etOjGo0cnGsvtdnd0dAqFA6mIAoyMVlFhLy8vl3vVufjii5uamod+TQEGACAN OBRF07T+YNCQtPXr17399tuGRB0vFou5XC4GIAFHowAj002d2jhhwgShcIvFsm3b i0O/pgADAJDqPrz96/MNznswwg03LAwa1KWP19vbu3fvPqFwIEVRgJHpamtrSktL hcIjkch77/1l6A6zx+PRfyt0IQAAkAAORQn4/cG+PkPSYrHYnDnNcudxer3etrZ2 oXAgRVGAkekqKipsNqtc/rx58y+88EL9F36/PxQKyV0IAABI0wuwW1Wj0aghaW+8 8cYLLzxvSNQJdXWpTqdTLh9IRRRgIGvGjOl5eXlC4dOmTVu79qmsw48h9fT0CF0F AABIG5x+5HAYONfwjjtud7vdRqUdQ1/trl27hcKB1EUBBrImT64rKSkRCo/H49u3 v6f/YmBgwOfzCV0FAABIcyiK1+0Oh8NGBTY3N40dO9aotGNomnbw4CGhcCB1UYCB rMrKSqu1XChcL8CrVj38iU98YugkRqGrAAAAUYO3fxXFb9zPsltbW1eseHDMGKl3 46rqcjgcQuFA6qIAA1l2u81iscgdQfG5z33u7ruXZ3EQNAAAKUtvvz6vd6C/36jA hx5aoXdgo9KOEYlE3G63ovDGAzgWBRgYVF9fX1RUKBQ+btz4oRF/FGAAAFLRh9OP vF4DM+fPnxc3aJbS8QKB7v379wuFAymNAgwMqq6uslgsQuGxWOyll16yWMpVVZV7 qQMAAEIGH372+0MGTT/KGiyogcWLFw0NSpTgdrs7OjqFwoGURgEGBtntNqvVKvc6 dOGF35s3b57X6zXw5AwAAJAYegF2qWrMoOlHut/+9rd/+tP/MyrtGLFYTFVVnn8G TogCDHxo6tTGCRMmCIWXlpa99NJLgUAgGAwKXQIAAEgIhUKdDkfAuOlHuoULF+ix BgYerbe3d+/efULhQKqjAAMfqq2tKS0tFQqPRCLvvrt9YGCgu7tb6BIAAECCQ1E8 bnfEuGe4otHo3Llz5E7f9Hq9bW3tQuFAqqMAAx+qqLBbrVa5aQTNzXO+/e1vMwoY AIAUYvj0I91rr722adNGAwOPFo/HVVV1OhWhfCDVUYCBj8yYMT0vL08ovLGxce3a pxgFDABACjF8+pHu9ttv83g8BgYeTW/su3btFgoH0gAFGPjI5Ml1JSUlQuHxePyN N97s6ekRygcAAMYamn7k9/mMHeLQ3Nw0duxYAwOPpmnawYOHhMKBNEABBj5SWVlp tZbL5d96620f+9jH5PIBAICBDJ9+pGttbX3ooRUGBh5DVV0Oh0MuH0h1FGDgI1VV VeXlUtOAdfX1Dffee69cPgAAMJDh0490S5cudblUAwOP4XK5OzuZAAycFAUY+Ij0 NGA9edOmFqFwAABgoMHjrxwOv6HTj3Rz586RO3GTCcDAaVGAgb8hOg04Ho/fddev Z8yYIZQPAACM4lAUr9sdNm76ke7QoUP33XevXAFmAjBwWhRg4G9IPwX9sY/9/a23 3iqXDwAARk9i+pHu/vvv0zuwsZlH4/ln4LQowMDfkH4KWrd58xa5cAAAMHp6+9V8 vv5QyNjYOXOa5d5j8PwzcCYowMCxpk2bWlBQIBQej8dvv/2Os88+WygfAACMktD0 o9bW1hUrHpR7/rmvr2/Pnr1C4UDaoAADx6qurrJYBJ+CPuuss+64Y6lcPgAAGA2H ogT8/qCh049099xzT0dHu7GZR3O73R0dPP8MnAYFGDiW9FPQsVhs69ZtQuEAAGCU 9ALsdrmikYixsTz/DCQDCjBwAtOmTSsoyJfL/8UvfvnVr35VLh8AAIzM4PFXTqdf 04yN/eMf/7hu3bPGZh6try+4Z88euXwgbVCAgROorKy0Wsvl8j/72c9de+21cvkA AGBkBqcfeTzhgQFjYx955JFdu3Yam3k0VXU5HA65fCBtUICBE7DbbRaLJScnRyhf L9irVj0sFA4AAEZm6Pgrzes1PHnJkls0o+8qHxGJRNxuN88/A2eCAgyc2JQpU4qL i4TC4/H4li1bhcIBAMDIDM7+1bRQMGh4cnNz09ixYw2PHeL3Bw4cOCAUDqQZCjBw YpWVFVarVShcL8CPPrraZrMJ5QMAgBHQC7BLVWPRqLGxPp9vyZJb5AYgqarqcDiF woE0QwEGTurss/9O7oe13/nOd3/4wx8KhQMAgOEKhUKdDkfA7zc8+YUXXnjjjdcN jx0SjUb/+tf3hcKB9EMBBk6qsbFh4sSJQuFVVdUrV64UCgcAAMM1ePyV2x0Ohw1P vvXWJT6fz/DYIT09Pfv2tQqFA+mHAgycVFVVVXm5RS5/8+YtcuEAAODMDU4/UhS/ TE0VnQDscrk7OzuFwoH0QwEGTuXv//5jQjt24vH4k0+unTRpkkQ4AAAYFr39aj5f fyhkeHJ3d/fixYvk3k68995fJJKBdEUBBk5lxozpeXl5QuGzZ1982WWXCYUDAIAz NDT9yO/z6X3S8PCWlpZXX/294bFD9JXv2rVbKBxISxRg4FTq6mrlbtLW1dU98MCD QuEAAOAMORSlOxDo6+2VCL/99ts8Ho9Ectbh86UPHWoTCgfSEgUYOJWKigqbTWoY 0pgxY1paNguFAwCAM6QXYI/bHRE4/ipLeANwV5fqdDIACRgGCjBwGmedNSs3N1ci ORaLPfPMb4uKiiTCAQDAmRA9/qqvr3fhwoVCBTgcDu/Y8YFEMpDGKMDAaTQ01BcW FgqFX3rpf1xyySVC4QAA4LTkjr/Sbdu27eWXX5JIzjp8vFZr636hcCBdUYCB06it rSktLRUKnzKl/r777hMKBwAApzZ0/JVegLMEjr/SLV261OVSJZJ1Xq+3ra1dKBxI VxRg4DREtwFnZ4/dtGmTUDgAADg10eOvdHPnzhEagJTFBmBgRCjAwGnY7TaLxZKT kyMRHovF1q9/rqCgQCIcAACcmujxV6FQ6PrrrxPaAByJRNxut6J0SYQDaYwCDJxe Q0NDYeFEofAf/ODyCy+8UCgcAACcjOjxV7pXXnl569atQuHd3T2tra1C4UAaowAD p8c2YAAA0o/o8Ve6ZcuWqarUHVo2AAMjQwEGTq+yssJqldoGHI/Ht2yR+vEwAAA4 IenjryKRyLx5c4W2UOlUVXU42AAMDBsFGDg90W3AegFet24924ABAEgk6eOvXnvt tU2bNgqFswEYGDEKMHBGGhsbJk6U2gb8/e//4Hvf+55QOAAAOJ5egN0uVzQSEcpf vHhRT0+PULievG8fG4CBkaAAA2ektra2tHSSUHhZmeWxxx4TCgcAAMeQPv5K19R0 ldzzz16vr62tTSgcSG8UYOCMiG4Djkaj27a9KBQOAACOMXj8lab1B4NC+for+9VX z5ebAMwGYGDEKMDAGZHeBrx+/XP5+fkS4QAA4Bh6AVYVJS5z/JXu7bf/sH79eqFw NgADo0EBBs6U6Dbg88//15///OdC4QAA4IhQKNTpcAT8frlL3HLLzX6xfDYAA6NB AQbO1PTp0+Ru0ubmjnv++eeFwgEAwBEORfG43ZFwWO4Szc1NY8eOFQr3+XyHDrEB GBghCjBwphoa6gsLC4XCc3JyXnhBalgCAAAY8uH4X69X7hKxWGzu3DlCBTgajbpc Lp5/BkaMAgycqerqaoulTChcf7F88sknS0ul8gEAQNbQ8Vc+X38oJHeJv/zlL088 8bhQeG9v7969+4TCgUxAAQbOlN1ut1rLs7OzhfK/8Y1v/OQn/y0UDgAAsg4XYFdX VywWk7vEqlUr9+7dKxTO88/AKFGAgWGYOrVxwoQJQuGlpaWPP/6EUDgAABgc/+t0 +jVN9CrXXXdtWGyDscvl6ux0CIUDmYACDAxDbW2NXlOFwpkGDACAKIeieD2e8MCA 6FWamq4SmpsYi8VUVWUDMDAaFGBgGCoq7DabTS7/2muv++xnPyuXDwBAxkrA8Ve6 HTt2rFmzWii8r69vzx6ph6uBDEEBBoZnxozpeXl5QuHnnHPOzTffIhQOAEAmcyiK 3+8P9fWJXmXVqlV79+4RCtc07eDBQ0LhQIagAAPDM3lyXUlJiVD4uHHjN2zYIBQO AEAmGzz+SlVj0ajoVa6//roBsUes2QAMjB4FGBieyspKq7VcKDwajW7Y8Hx+fr5Q PgAAmWnw+CtF8ft80hdiAzCQ5CjAwPDY7baysrLc3Fyh/P/6ryu++c1vCoUDAJCZ 9Pbr83jk7s0O+eCDD1avflQovK8vuGeP1MPVQOagAAPDVl9fX1RUKBQ+c+bMZcvu FAoHACADhUIhRVV9Xm9WPC56ITYAA8mPAgwMW3V1tcVSJhSem5v7/PMvCIUDAJCB HIrSHQj09fZKX0h4A7C7s7NTKBzIHBRgYNjsdrvNZh0zRuTbJxqNbtrUIveINQAA mUYvwG5VjQoff5UluQE4Ho93dXWxARgYPQowMBLTpk0rKJA6qurKK6/82tfOFwoH ACCjJOz4q/fff/+xx9YIhQeDwd272QAMGIACDIxEXV3dpElSw5CYBgwAgFESc/yV 7qGHVrS2tgqFa5r/4MGDQuFARqEAAyNRVVVZXi41DKmgoODZZ9cJhQMAkDmGjr/S vN648PFXumuuuSYajQiFswEYMAoFGBgJu92mF+CxY8dKhEej0W3bXpRIBgAgoyTs +KtYLDZ37hyhNwaHNwCriqJIhAOZhgIMjNDUqY0TJkwQCr/11ts+9rGPCYUDAJAh 9ALsUtWY/PFX77zzzjPPPC0UzgZgwEAUYGCE6upqJ02aJBT+z//85ebmZqFwAAAy QSgUcnZ1aV5vAq513333tbVJDellAzBgIAowMEKVlZVWq9Q2YIulfM0aqZMkAQDI BAk7/ko3f/78eDwmFM4GYMBAFGBghOx2m9Vqzc7OlgiPxWJbt26TSAYAIBMk8vZv ODxw9dVXy20AVlXV6WQDMGAMCjAwctOmTS0oKJBI1l/tHn10tc1mkwgHACDtORQl EAgE5Y+/0r366qstLZuEwtkADBiLAgyM3OTJdSUlUtOAv/Od7/7whz8UCgcAIL0l 7Pgr3Z13Luvq6hIK1zTt4EGp3cVABqIAAyNXVVVVXm4RC69euXKlUDgAAGksFArp Bdjv8yXmcnPnzhkzRupNtcvl6ux0CIUDGYgCDIyc3W632axCr3l6bEvLZolkAADS m95+vR5POCHHX3V3dy9adKPcmSCqqiqK1O1lIANRgIFRmTFjel5enkSy/pq3du1T cpOWAABIS4k8/kq3cePG119/TSi8r69vz569QuFAZqIAA6MyZcqU4uIiofDZsy++ 7LLLhMIBAEhLgw8/+/2hvr7EXG7JkiWaJvWstc/nO3SoTSgcyEwUYGBUamqqy8rK hMJra2sffHCFUDgAAGlp8Pirrq5YTGoq7zGamppyckQGIOlU1eVwsAEYMBIFGBiV iooKm80ql7958xa5cAAA0szg8VcOh9/vT8zlFEW5885lQqeBRKNRl8vFBmDAWBRg YLTOOmtWbm6uRDLTgAEAGBaHonjc7kg4nJjLPfXUU++++2eh8J6enn37WoXCgYxF AQZGq6GhvrCwUCj8ggsuuOKKnwiFAwCQThI8/Uh344039IltNvZ6vW1t7ULhQMai AAOjVVtbU1paKhReXl6+evUaoXAAANKJ3n41n68/FErYFZuarsrJyREKV1XV4XAK hQMZiwIMjFZlZYXVKrUNOBqNbtv2olA4AABpY2j6kd/ni8fjibninj17Hn54lVB4 OBz2eDxsAAYMRwEGRstut1ksFrkfAN922+1nn322UDgAAOnBoSiBQCDY25uwK65a tWrv3j1C4d3d3a2t+4XCgUxGAQYM0NDQUFg4USj8//yfz1533XVC4QAApAe9ALtd rmgkkrArXnPNNdGo1OU8Hk97e4dQOJDJKMCAAUS3ARcUFDz77DqhcAAA0sDg8VdO p1/TEnbFaDQ6d+4cuee/urq6nE5FKBzIZBRgwACi24AjkUhLy2ahSUsAAKQBh6L4 vN6B/v6EXfHNN998/vkNQuH9/f07d+4SCgcyHAUYMIbcNGDdFVf85IILLhAKBwAg pQ0df6X5fFmJOv5K9+tf3+V0Sh3R7PcHDhw4IBQOZDgKMGCM+vr6oiKpacD19Q33 3nuvUDgAACltcPavpoWCwURedO7cOWPGSL2RdrvdHR2dQuFAhqMAA8aorq62WMrk 8jdv3iIXDgBA6tILsEtVY9Fowq7Y3d29aNGN2dnZEuHxeLyrS1UUNgADIijAgDEq KuxWq1Xoh8H6a+GqVQ9XVVVJhAMAkLpCoVCnwxHw+xN50Y0bN77++mtC4cFgcPdu qelKACjAgGFmzJiel5cnFP6Vr3z1l7/8pVA4AAApyqEoHrc7Eg4n8qJLltyiiZ04 rScfPHhIKBwABRgwzOTJk0tKioXCi4tL1q5dKxQOAEAqGpx+pCh+ny/B121ubho7 dqxQuMvl6ux0CIUDoAADhqmqqiovtwiFR6PRLVu2Cm03AgAgFentV/P5+kOhRF60 o6Nj+fK7hTY96S/3egFWlC6JcABZFGDAQHa7rby8XO5HwlddddW//Mt5QuEAAKSW oelHfp8vnsDpR7rHHlvz/vvvC4X39vbu3btPKBxAFgUYMNa0aVMLCgqEwqPR6LZt LwqFAwCQWhyKEvD7g319Cb5uU9NVOTk5QuF+v//AgYNC4QCyKMCAsWpra0pLS4XC 4/H4unXr5Qo2AAApRC/AbpcrGokk8qLBYHDhwgVyE4BVVXU4nELhALIowICxKioq bDarXP4PfnD5hRdeKJcPAEBKGDz+yun0ix3FfDJr1qzesWOHUHgsFtMLMBuAAVEU YMBgf/d3Z8k9GdXQ0HjPPfcIhQMAkCociuL1eMIDAwm+7vz58+S2HAeDod27dwuF AxhCAQYM1tDQUFg4USg8O3vspk2bhMIBAEgJQ8dfaV5v4i8tOgDJ59MOHWICMCCL AgwYrLq6ymKRGoYUi8XWr3+ObcAAgEw2OPtX00LBYIKv6/f7b7nlZrn8rq4up1OR yweQRQEGDGe323Ryx2OwDRgAkMmGbv8GNC0WiyX40qtXr/7gA6kNwNFo9K9/lZqu BOAICjBgvJkzZ4wfP14onG3AAIBM5lCU7kCgr7c38ZdetmyZqkqdUNXX17dnz16h cABHUIAB402ZMrm4uFgonG3AAIBMphdgj9sdCYcTf+m5c+fIPeHl9Xrb2tqFwgEc QQEGjFdZWWG1Sg1DisVizzzz26KiIqF8AACS1uD0I0Xx+3yJv3RfX+/ChQuzs7Ml wuPxeFeXqihsAAbEUYABEVOnNk6YMEEo/NJL/+OSSy4RCgcAIGnp7dfn9Q709yf+ 0tu2bXv55ZeEwiORyPvvS+0uBnA0CjAgora2prS0VCh88uTJ99//gFA4AADJaej4 K7/PJzeJ9xTuuON2t9stFN7b27t37z6hcABHowADIkSfgh4zZkxLy2ahcAAAkpND UQJ+f7Cvz5Srz5nTLPT8s87j8bS3dwiFAzgaBRgQYbfbLBZLTk6ORHgsFlu79qlJ kyZJhAMAkJz0AuxW1Wg0mvhLd3d3L1p0o+QG4C5FkTpfGsDRKMCAlMbGhokTJwqF z5598WWXXSYUDgBAshk8/srp9GuaKVdvaWl59dXfC4UHg6Hdu3cLhQM4BgUYkCK6 Dbi6uvqhh1YKhQMAkGwciuL1eMIDA6Zc/dZbl/jEjp5mABKQSBRgQIroNmDd5s1b 5MIBAEgeQ8dfaV6vWQsQ3QCsqqrD4RQKB3AMCjAgRXQbcDweX7PmsfLycolwAACS yuDsX00LBYOmXF3TtFtuuXnMGJG3zZFIxO12swEYSBgKMCCooaGhsFBqG/B3vvOd H/7wR0LhAAAkiaHbvwFNi8VipizghReef+ONN4TCu7t7WltbhcIBHI8CDAgS3QZc VVW9ciXbgAEAac6hKN2BQF9vr1kLWLJkiaaxARhIExRgQFBFRYXNJrUNOB7P2rKF bcAAgDSnF2CP2x0Jh81aQHNz89ixUhuAu7pUp5MNwEDiUIABWWedNSs3N1ciOR6P P/LIo3a7XSIcAIBkMDj9SFH8Yicwn5bH47nttluFNgCHw+EdOz6QSAZwMhRgQFZD Q31hYaFQ+De+8Y2f/OS/hcIBADCd3n59Xu9Af79ZC1i3bt0f//i2UHh3d3dr636h cAAnRAEGZNXU1JSVSW0Dttvtv/nNI0LhAACYa+j4K7/PF4/HzVrDzTffFAgEhMI9 Hm97OxuAgYSiAAOyRLcBx2KxrVu3CYUDAGCuwYef/f5QX5+Ja2hubho7dqxQOBuA gcSjAAPiRLcBP/jgirq6OolwAADMpRdgt6pGo1GzFqAoyp13LmMDMJBOKMCAONFt wOef/68///nPhcIBADDL4PFXDoff7zdxDc888/Q777wjFM4GYMAUFGBAXE1NdVlZ mVC4xVK+Zs0aoXAAAMziUBSvxxMeGDBxDYsWLert7REK93g87e0dQuEAToYCDIhj GzAAAMMyePyVomjmTT8a0tR0VU5OjlA4G4ABU1CAgUSYNWvmuHHjhMLvuuuu6dNn CIUDAJB4jsPttz8UMnENbW1t9913r1D4wMDABx/sFAoHcAoUYCAR6uvri4qktgF/ 8Ytfmjt3rlA4AAAJ9uH0I02Lx2ImLuOxx9a8//77QuGBQPf+/WwABkxAAQYSQXQb cHFxydq1a4XCAQBIMIeiBAKBYG+vuctYuHBhKBQUCmcDMGAWCjCQCBUVdpvNJhQe iURefPEloXAAABJML8Ael0t/dTN3GcIbgLucTkUoHMApUICBBJk5c8b48eOFwhcv vumTn/ykUDgAAAkzOP3I6fRrmrnL2L17929+87BQeH9//86du4TCAZwaBRhIkPr6 KUVFRULhn/nMuQsWLBAKBwAgYRyK4vN6B/r7zV3Gww8/vGfPbqHwQCCwf/8BoXAA p0YBBhKkurraYpHaBlxQMOHZZ58VCgcAIDE+PP7K54vH4+au5Nprr41EwkLhbren o4MNwIA5KMBAglRU2K1W65gxIt90kUhk69Zt2dnZEuEAACSGQ1H8fn+or8/cZcRi sTlzmoU2AOvdXlVVNgADZqEAA4kzY8b0vLw8ofB58+Z/4QtfEAoHACAB9ALsUtVY NGruMrZv37527ZNC4aFQaNcuqYerAZwWBRhInClTJhcXFwuFn3POOTfffItQOAAA 0gaPv3I4/H6/2QvJevDBBw4ckNqjq/8LHjhwUCgcwGlRgIHEqa6uslgsQuHjx+c9 99xzQuEAAEhzKIrX4wkPDJi9kKyrr746FpO6C+12uzs6OoXCAZwWBRhIHLvdbrPJ bQOOtrS05ObmSoQDACBq8Pavovh9PrMXMnisxrx583JyxkqEx+Pxri5VUdgADJiG Agwk1PTp0/Lz84XCf/az//n6178uFA4AgBy9/Wo+X38oZPZCst56660NG6SeqAoG g7t37xEKB3AmKMBAQk2ePLmkRGob8KxZs5YuXSYUDgCAkA+nH2laPBYzey1Zy5cv 7+yUmlGkaf6DBw8KhQM4ExRgIKGqqqrKy6W2Aefk5LzwwkahcAAAhDgUJRAIBHt7 zV7IoHnz5sqFu1zuzk42AANmogADCWW326xWq9DA3mg0umHD83KPWAMAIEEvwB6X KxKJmL2QrP7+/muvvWbsWJENwLFYTFVVRemSCAdwhijAQKJNmza1oKBAKPwHP7j8 wgsvFAoHAMBwg8dfOZ1+TTN7IYNeeeXlrVu3CoX39fXt2bNXKBzAGaIAA4k2eXJd SUmJUHh9fcO9994rFA4AgOEciuLzegf6+81eyKClS5e6XKpQuKZpBw8eEgoHcIYo wECiVVVVlpeXC4WPGTOmpWWzUDgAAMYaOv5K8/my4nGz1zJozpxmoW1KWYMbgF2d nQ6hcABniAIMJJroNuBYLPbkk0+WlpZJhAMAYKzB2b+aFgoGzV7IoEAgsHjxIrkX aDYAA8mAAgyYYOrUqRMmSG0D/u53L7z88suFwgEAMJBegF2qGotGzV7IoI0bN77+ +mtC4b29fXv3sgEYMB8FGDBBXV3tpEmThMKrqqpXrlwpFA4AgFFCoVCnwxHw+81e yIeWLFmiaT6hcJ/Pd+hQm1A4gDNHAQZMUFlZabVKbQOOxeJyJ1gCAGAUh6J43e5w OGz2Qj7U1NSUkyMyAEmnqi6Hgw3AgPkowIAJ7HZbeXm50JjBeDz+0EMra2pqJMIB ADDE4PQjRfH7pO64DpeqqkuX3jFmjMh742g06nK52AAMJAMKMGCOxsbGiRMnCIWf f/6//vznPxcKBwBg9PT2q/l8/aGQ2Qv50DPPPP3OO+8Ihff09O7bt08oHMCwUIAB c9TW1pSWlgqFWyzla9asEQoHAGCUhqYf+TUtHouZvZYPLVq0qLe3Ryjc6/W2tbUL hQMYFgowYI7Kygqr1SoUHo1Gt217USgcAIBRcihKIBAI9vaavZCPNDVdlZOTIxSu qqrD4RQKBzAsFGDAHHa7raysLDc3Vyh/6dJls2bNEgoHAGA09ALsdrmikYjZC/nQ wYMHH3jgfqHwcDjs8XjYAAwkCQowYJqGhvrCwkKh8M9//gvz588XCgcAYMQGj79y Ov2aZvZCPrJmzeodO3YIhXd3d7e27hcKBzBcFGDANDU1NWVlUtuACwuLnn76aaFw AABGzKEoPq93oL/f7IV8ZMGCBf39UsdxeTze9nY2AAPJggIMmKaiosJmYxswACCD DB1/pfl8WfG42Wv5iOgG4K4u1elkAzCQLCjAgJlmzZo5btw4ofDrr19w7rnnCoUD ADACg7N/NS0UDJq9kI/s2LFjzZrVQuEDAwMffLBTKBzACFCAATPV108pKioSCv/U pz61aNFioXAAAEZAL8AuVY1Fo2Yv5CMPPbSitbVVKDwQCOzff0AoHMAIUIABM9XU VJeVlQmF5+Xlr1+/XigcAIDhCoVCnQ5HwO83eyF/45prrolGpc6j9ng87e0dQuEA RoACDJiposJutVrHjBH5ToxGoy0tm+U2NQEAMCwORfG43ZFw2OyFfER/rZw3b+7Y sWMlwuPxuKqqTqciEQ5gZCjAgMlmzJiel5cnFH7llVd+7WvnC4UDAHDmBqcfKYrf 5zN7IX/j7bf/IPe0lP6vvGvXbqFwACNDAQZMNmXK5OLiYqHwWbPOWrp0qVA4AABn Tm+/ms/XH5KaNjQy99yzvKND6hFlv99/4MBBoXAAI0MBBkxWXV1lsViEwnNycl54 YaNQOAAAZ2ho+pHf54sn0/Qj3bx5c+XC3W53R0enXD6AEaAAAyaz2+02m+A24Oee 21BQUCARDgDAGXIoSsDvD/b1mb2Qv6HX8uuuu1ZuA3BXl6oobAAGkgsFGDDf9OnT 8vPzhcIvu+w/Z8+eLRQOAEhjeoUz6uezegF2u1zRiNRhyyPz4osvvvTSi0LhwWBw 9+49QuEARowCDJhv8uS6kpISofC6uskPPPCAUDgAAKc1ePyV0+nXNLMXcqw77rjd 7XYLhWuadvDgIaFwACNGAQbMV1VVWV5eLpe/efMWuXAAQFoy9vavz+MZGBgwJM1A c+Y0Z2dnC4W7XK7OTodQOIARowAD5rPbbVarVeg1WH8H8+ijq202m0Q4AACnNnT8 lebzZSXZ8Vc+n2/JkluEzuCIxWKqqipKl0Q4gNGgAANJYerUxgkTJgiFX3DBBVdc 8ROhcAAATmFw9q+mhYJBsxdyrPXr17399ttC4b29vXv37hMKBzAaFGAgKdTV1U6a NEko3Gq1PvroaqFwAABOQS/Arq6uWCxm9kKOddNNi7u7u4XCfT7foUNtQuEARoMC DCSFyspKq1VqG3AsFt+6datQOAAAJxMKhTodjoDfb/ZCTqC5uUloAJJOVV0OBxuA gWREAQaSgt1us1gsOTk5EuHxePzuu5dPmzZNIhwAgJNxKIrH7Y6Ew2Yv5Fjt7e33 3LNcaANwJBJxu91sAAaSEwUYSBYNDQ2FhROFwr/4xS/NnTtXKBwAgOMNTj9SFL/P Z/ZCTuCxx9a8//77QuHd3T2tra1C4QBGiQIMJIva2prS0lKh8KKi4qeeekooHACA 4+ntV/P5+kMhsxdyAgsWLOjvl1qY1+tta2sXCgcwShRgIFlUVFTYbFah8Gg0um3b i0LhAAAcY2j6kd/niyfZ9KMhohuAu7pUp9MpFA5glCjAQBKZNWvmuHHjhMKvv37B ueeeKxQOAMDRHIoS8PuDfX1mL+QE3n///cceWyMUPjAw8MEHO4XCAYweBRhIIvX1 9UVFhULhn/zkpxYvXiwUDgDA0fQC7Ha5opGI2Qs5gRUrVuzfL7VHNxDo3r9/v1A4 gNGjAANJpKamuqysTCh8/Pi85557TigcAIAjBo+/cjr9mmb2Qk7s6quvjsWiQuEe j6e9vUMoHMDoUYCBJFJRYbdarXJTGVpaNufm5kqEAwBwhENRvB5PeGDA7IWcgP5q OG/eXLm5g6qqOp2KRDgAQ1CAgeQyY8b0vLw8ofCf/vRn//Zv/yYUDgBA1v8ef6V5 vWYv5MTefPPN55/fIBSu/7vv2rVbKByAISjAQHKZMmVycXGxUPi0adN//etfC4UD AJB1+PavX9NCwaDZCzmxX//6Lrkjmv1+/4EDB4XCARiCAgwkl+rqKovFIhQ+duzY jRs3CYUDAJB1uAC7urpisZjZCzmxefPmyoW73e6Ojk65fACjRwEGkovdbrfZpLYB 629Hnn76Gbk7zACADBcKhTodjoDfb/ZCTqynp+fGG2/Izs6WCI/H411dqqKwARhI ahRgIOlMnz4tPz9fKPyii2b/53/+p1A4ACDDORTF43ZHwmGzF3JiLS0tr776e6Hw YDC4e/ceoXAARqEAA0ln8uS6kpISofCqquqVK1cKhQMAMtng9CNF8ft8Zi/kpG69 9VafT+p0Lk3TDh48JBQOwCgUYCDpVFVVlpeXC4XH4/EtW7YKhQMAMpnefjWfrz8U MnshJ9Xc3DR27FihcJfL1dnpEAoHYBQKMJB07HabXoCFXqH1Avzggyvq6uokwgEA GWto+pHf59NfaMxey4kpinLnncuETtmIRqN6AVaULolwAAaiAAPJaOrUxgkTJgiF n3feV371q18JhQMAMpNDUQJ+f7Cvz+yFnNTatWu3b39XKLy3t3fv3n1C4QAMRAEG klFtbW1p6SSh8EmTJj3xxJNC4QCAzKQXYLfLFY1EzF7ISd1www3BoFQ/93p9bW1t QuEADEQBBpJRZWWF1WoVCo9EIi+++JJQOAAgAw0ef+V0+jXN7IWcSlPTVTk5OULh qqo6HE6hcAAGogADychut1ksFrnX6UWLFn/qU58SCgcAZBqHong9nvDAgNkLOald u3Y98shvhMIjkYjb7WYDMJASKMBAkmpoqC8sLBQK//SnP33DDTcKhQMAMsrQ8Vea V2q8kCFWrnxo3z6pPbrd3d2trfuFwgEYiwIMJKmampqyslKh8Ly8/PXr1wuFAwAy yuDsX00LBYNmL+RUrrnmmmhUan+yx+Ntb28XCgdgLAowkKQqKuw2m00oPBKJbN68 Re4RawBA5nA4nS5VjcViZi/kpKLR6Ny5c+Re9bq6upxORSgcgLEowEDymjlzxvjx 44XCf/az//n6178uFA4AyBChUKjT4Qj4/WYv5FTeeuutDRueEwrv7+/fuXOXUDgA w1GAgeQ1ZcqU4uIiofAZM2bceeddQuEAgAzhUBSP2x0Jh81eyKncffevHQ6HULjf Hzhw4IBQOADDUYCB5FVdXWWxWITCs7PHbtq0SSgcAJAJBqcfKYrf5zN7Iacxd+7c MWLved1ud0dHp1Q6AKNRgIHkZbfbbTbrGJkX7Vgs9vTTzxQXF0uEAwAygd5+NZ+v PxQyeyGn0tPTc+ONN2RnZ0uEx+Pxri5VUdgADKQMCjCQ1KZPn5afny8UPnv2xZdd dplQOAAgvQ1NP/L7fHoJNHstp9LS0vLqq78XCg8Gg7t37xEKByCBAgwktcmT60pK SoTCq6qqV65cKRQOAEhvDkUJ+P3Bvj6zF3Iat956q88nNaNY07SDBw8JhQOQQAEG klpVVWV5eblQeDwe37Jlq1A4ACC96QXY7XJFI1LDdY3S3Nw0duxYoXCXy9XZKXW8 FgAJFGAgqdntNr0AC71y6wX4wQdX1NXVSYQDANLY4PFXTqdf08xeyGkoinLnncuE TtOIRqN6AVaULolwAEIowECymzq1ccKECULh5533lV/96ldC4QCAdOVQFK/HEx4Y MHshp7F27drt298VCu/t7d27d59QOAAhFGAg2dXV1U6aNEkovKSk5Mkn1wqFAwDS 0tDxV5pXamOtgRYuXBASO6Ta5/MdOtQmFA5ACAUYSHaVlRVWq1UoPBKJvPjiS0Lh AIC0NDj7V9NCwaDZCzm9pqarcnJyhMJVVXU4nELhAIRQgIFkZ7fbLBaL3Ov39dcv OPfcc4XCAQBpZuj2b0DTYrGY2Ws5jR07dqxZs1ooPBKJuN1uNgADKYcCDKSAhob6 wsJCofBPfvJTixcvFgoHAKQZh6J0BwJ9vb1mL+T0VqxYsX9/q1B4d3d3a+t+oXAA cijAQAqoqakpKysVCh8/Pu+5554TCgcApBm9AHvc7kg4bPZCTu/qq6+OxaJC4R6P t729XSgcgBwKMJACKioqbDapbcDRaHTTppbc3FyhfABA2hicfqQofp/P7IWcXiQS mT9/ntwE4K4u1elkAzCQeijAQGqYOXPG+PHjhcJ//OP/+ta3viUUDgBIG3r79Xm9 A/39Zi/k9F599dWWlk1C4f39/Tt37hIKByCKAgykhilTphQXFwmFNzQ03nPPPULh AID0MHT8ld/ni8fjZq/l9JYtW6aqUidU+f2BAwcOCIUDEEUBBlJDdXWVxWIRCh8z ZkxLy2ahcABAenAoSsDvD/b1mb2QMzJnTnN2drZQuNvt7ujoFAoHIIoCDKQGu91u s1n1pioRHovFnnjiybKyMolwAEB60AuwW1WjUaljpQzk9/tvummxUAGOx+NdXaqi KBLhAKRRgIGUMX36tPz8fKHwb33r//74xz8WCgcApLrB46+cTr+mmb2QM7Jhw4a3 3npTKDwYDO7evUcoHIA0CjCQMiZPrispKREKt9lsjzzyqFA4ACDVORTF6/GEBwbM XsgZuemmm7q7A0LhmqYdPHhIKByANAowkDKqqirLy8uFwmOx+NatW4XCAQApbej4 K83rNXshZ6q5uUluAJLL5ersdAiFA5BGAQZSht1u0wuw3Cv6XXfdNX36DKHwxOvr 6ysoKDB7FQCQDgZn/2paKBg0eyFnpK2t7b777hUKj0ajegFWFKnzpQFIowADqaSx sXHixAlC4Z///Ofnz79aKBwAkKKGbv8GNC0Wi5m9ljOyevXqDz7YIRTe09O7b98+ oXAACUABBlJJbW1NaWmpUHhhYeHTTz8jFA4ASFEORekOBPp6e81eyJm6/vrrBsT2 Knu93ra2dqFwAAlAAQZSSWVlhdVqFQqPRCJbt26Tm5oIAEhFegH2uN2RcNjshZyR WCw2Z05zTk6OUL6qqg6HUygcQAJQgIEUc9ZZs3Jzc4XC58yZ+6UvfUkoHACQcgan HymK3+czeyFn6s9//vPTTz8lFB4Oh3fs+EAoHEBiUICBFFNfX19UVCgU/nd/d/bt t98uFA4ASDl6+/V5vQP9/WYv5Ezde++97e1tQuGBQPf+/fuFwgEkBgUYSDE1NdVl ZWVC4bm5uc8//4JQOAAgtQwdf+X3+eLxuNlrOVPz58+TW63H42lv7xAKB5AYFGAg xVRU2K1W65gxIt+80Wj0uec2MD0IAJB1+PZvwO8P9vWZvZAzpTf26667VmheoN6r VVV1OhWJcAAJQwEGUs+MGdPz8vKEwi+99D8uueQSoXAAQArRC7BbVaPRqNkLOVPb tm17+eWXhML1dr1r126hcAAJQwEGUs+UKZOLi4uFwmtqalaseEgoHACQKgaPv3I6 /Zpm9kKG4bbbbvV6vULhfr//wIGDQuEAEoYCDKSeqqqq8nKLUHg8Ht+yZatQOAAg VTgUxevxhMUG6kpobm4Sev5Z53K5Ozs7hcIBJAwFGEg9drvNarUKDezVC/BDD62s qamRCAcApISh4680sbupElRVXbr0DqEzMmKxmJ6vKF0S4QASiQIMpKRp06bKHVX1 ta+df+WVVwqFAwCSn0NRNE3rDwbNXsgwPPXUU++++2eh8L6+vj179gqFA0gkCjCQ kurqaidNmiQUXlpa+vjjTwiFAwCS3NDt34CmxWIxs9cyDDfeeEOf2IHVPp/v0CGp 8cIAEokCDKSkyspKq7VcKDwajW7b9qJQOAAgyTkUpTsQ6OvtNXshw9PUdFVOTo5Q uKq6HA6HUDiARKIAAynJbrdZLBa5V/obb1z0D//wD0LhAIBkphdgj9sdCYfNXsgw 7Ny589FHHxEKj0QibrebDcBAeqAAA6mqoaGhsHCiUPinP/3pG264USgcAJC0Bqcf KYrf5zN7IcOzcuVD+/btEwrv7u5pbW0VCgeQYBRgIFXV1NSUlZUKhefl5a1f/5xQ OAAgaent1+f1DvT3m72Q4bnmmquj0ahQuMfjbW9vFwoHkGAUYCBVVVRU2GxWofBI JNrS0pKbmyuUDwBIQkPHX/l9vng8bvZahiESicybNy8nR2oCcFeX6nQ6hcIBJBgF GEhhM2fOGD9+vFD4FVf85IILLhAKBwAkIYeiBPz+oNhZykJef/31jRtfEArv7+/f uXOXUDiAxKMAAylsypQpxcVFQuGNjY3Ll98jFA4ASEJ6AXarqtyzxELuvHNZV5fU CVV+f+DAgQNC4QASjwIMpLDq6iqLxSIUnp2dvWlTi1A4ACDZDB5/5XT6Nc3shQzb 3LlzxoyRek/rdrs7OjqFwgEkHgUYSGF2u91mswq96sdisSeeeLKsrEwiHACQbByK 4vV4wgMDZi9kePx+/003Lc7OzpYIj8fjXV2qoigS4QBMQQEGUtv06dPy8/OFwr/1 rf/74x//WCgcAJA8ho6/0rxesxcybBs2bHjrrTeFwoPB4O7de4TCAZiCAgyktsmT 60pKSoTCbTbbI488KhQOAEgeDkXRNK0/GDR7IcN20003dXcHhML1/00OHjwkFA7A FBRgILVVVVWWl5cLhcdisa1btwmFAwCSxNDt34Cm6f/ZN3stw9bUdFVOTo5QuMvl 6ux0CIUDMAUFGEhtdrtNL8Bjx0oNP1y6dNmsWbOEwgEAycChKN2BQF9vr9kLGbaD Bw8+8MD9QuHRaFQvwIoidb40AFNQgIGU19jYOHHiBKHwz372c9dee61QOAAgGegF 2ON2R8JhsxcybI888siuXTuFwnt6evft2ycUDsAsFGAg5dXW1pSWlgqFFxRMePbZ Z4XCAQCmG5x+pCh+n8/shYzEtddeG4lI9Xav19vW1i4UDsAsFGAg5VVUVNhsVqHw aDTa0rJZbnsVAMBcevv1eb0D/f1mL2TY9FeoefPmym0C6upSnU6nUDgAs1CAgXRw 1lmzcnNzhcKvvPLKr33tfKFwAICJho6/8vt88Xjc7LUM29tv/2H9+vVC4eFweMeO D4TCAZiIAgykg/r6+qKiQqHwmTNnLlt2p1A4AMBEDkUJ+P3Bvj6zFzISy5ff3dnZ KRQeCHTv379fKByAiSjAQDqorq62WMqEwrOzx27atEkoHABgIr0Au1U1Go2avZCR mDt37hixd7Jut6ejo0MqHYB5KMBAOqiosFut1jEybwRisdjatU9NmjRJIhwAYJbB 46+cTr+mmb2Qkeju7l606Mbs7GyJ8Hg8rqqq06lIhAMwFwUYSBMzZkzPy8sTCv/u dy+8/PLLhcIBAKZwKIrX4wkPDJi9kJHYuHHj66+/JhQeCoV27dotFA7AXBRgIE1M nlxXUlIiFF5RUfHww78RCgcAJN7Q8Vea12v2Qkbolltu9vv9QuGaph08eEgoHIC5 KMBAmqiqqiwvLxcKj8ViW7duEwoHACTe4OxfTQsFg2YvZISamq6SG9Hncrk6Ox1C 4QDMRQEG0oTdbrNarXK7oe6+e/m0adMkwgEACTZ0+zegabFYzOy1jER7e/s99yyX O/lCVVVF6ZIIB2A6CjCQPqZObZwwYYJQ+Oc//4X58+cLhQMAEsmhKN2BQF9vr9kL GaE1a1bv2LFDKLy3t3fv3n1C4QBMRwEG0kdtbW1pqdRZzYWFhU8//YxQOAAgkfQC 7HG7I+Gw2QsZoeuvv25A7Owur9fX1tYmFA7AdBRgIH1UVlZYrVah8EgksnXrNqFH rAEACTM4/UhR/D6f2QsZoVgsNmdOs9wGYFVVHQ6nUDgA01GAgfRht9vKyspyc3OF 8puamr/85S8LhQMAEkNvvz6vd6C/3+yFjNA777zzzDNPC4WHw2GPx8MGYCCNUYCB tNLQUF9YWCgUftZZZ91xx1KhcABAAgwdf+X3+eLxuNlrGaF77rmno6NdKLy7u7u1 db9QOIBkQAEG0kpNTXVZWZlQeE5OzgsvbBQKBwAkgENRAn5/sK/P7IWM3Lx5c+XC PR5Pe3uHXD4A01GAgbRSUWG3Wq1ykyGeeea3RUVFEuEAAGmhUEhRVb/Pl6LTj3R9 fb0LFy6Um/mnqqrTqUiEA0gSFGAg3cyYMT0vL08ofPbsiy+77DKhcACAqMGzrzQt FAyavZCRa2lpefXV3wuFh0KhXbt2C4UDSBIUYCDdTJkyubi4WCi8qqp65cqVQuHA /9/encDJVdb5/u+luquX9F7ddao7KwEUAgg4ine83qtCEMVlXLno4OD1f2XmP/Ma HZQAIiK4hEUZdAZZFImjF2QLf0C2JID35d8FGYksCRoIISRdXfvS1V1L1zmn7lN1 kqYJSXqrX52qOp/3C4pKdfM7T3eSOs+3nw2AKBWAQ4FA7a7+Va666qpEQmr/6mQy uWvXK0LFAVQJAjBQb0ZGRgYHPULFTdPctGmzUHEAgJzi6Ud+v8p4djdkUdatu6C5 uVmoeDgcGR0dFSoOoEoQgIF6o2neoaEhufVRP/zhDatXr5YoDgCQ4w8EwqGQaRh2 N2ThVDr9t3/7gdw+F6FQiAOQgLpHAAbq0NFHH9XR0SFU/L3vfe+6dRcKFQcASCgO /46NJRMJuxuyKLfddttzzz0rVDydTu/Y8aJQcQDVgwAM1KEVK5b39fUJFe/q6r7r rruEigMAJPgDgVgkks/n7W7IonzjG9/I5bJCxePx+O7drwoVB1A9CMBAHRoeHh4a GhQqbhjGo49uEppiDQAou2w2OxYMJmIxuxuyKKZpXnjhOpfLJVQ/FAr7/X6h4gCq BwEYqEOa5vV4PHK9hIsuuujd736PUHEAQHn5A4FEPJ7LSo2dVsbWrVvvvPMOoeK6 rkciERYAA05AAAbq0+rVR3R1dQkVP/74E6655hqh4gCAMrKGf5PxeE2ffqTccMMN r766W6h4KpXaufNloeIAqgoBGKhPy5YtHRgYECre0tLywAO/FCoOACgjfyAwnkxm 0mm7G7JYX/3qxXIZPhqN7tmzV6g4gKpCAAbqk8+neb1eoeKGYdx77/+3ZMkSofoA gHIpnn4UDJqmaXdDFiWTyVx22dflTgAOBoNjYwGh4gCqCgEYqFvHHPNmt9stVPyc cz77mc98Rqg4AKAs6uP0I2XTpk1PPPG4UPFcLvfCC38WKg6g2hCAgbq1atXKnp4e oeJLly798Y9vESoOACgLfyAQDYd1Xbe7IYt19dVXxeNxoeLJZHLXrleEigOoNgRg oG4tXTri8XiEiptmYdOmTULFAQCLVxz+DQSSYrmxki644AKXS2r+cyQS2bt3VKg4 gGpDAAbqlqZ5h4aGhA7sLRQK73rXf/va174mURwAsHgq/cZjsalczu6GLNZ//MdP t2/f3tgo0ms1TTMUCnEAEuAcBGCgnh199FEdHR1CxVW0fuihh4WKAwAWo25OP2oo Hj5/oVD6VdLp9I4dLwoVB1CFCMBAPVuxYnlfX59QcdM0H3nkUaERZgDAYhQnPycS 2UzG7oYslrrXXHzxRXL3mng8vnv3q0LFAVQhAjBQz4aHh4eGBuXqf/nLX1m7dq1c fQDAAljDv+OJRK2ffqQ89dRTGzfeI1c/FAr7/X65+gCqDQEYqGea5vV4PC6XS6i+ Ctg/+cmtQsUBAAvjDwTGk8lMOm13Q8rgqquuTIgd46TreiQSYQEw4CgEYKDOrV59 RFdXl1BxwzA2b94iVBwAsDAqAEdCIfUWbXdDyuCCC74i92PcVCq1c+fLQsUBVCcC MFDnli1bNjDQL1S8UCjcfvvt/f0DQvUBAPNVPP3I708mk3Y3pAzGx8e/851vy+2A FY3G9uzZI1QcQHUiAAN1zufTvF6vXP0PfvBD//RP/yRXHwAwL/5AIBqJ6Pm83Q0p g40bNz711B/k6geDwbGxgFx9AFWIAAzUv+OOWyM3f8ztbrvvvvuEigMA5qU4/BsI JONxuxtSHpdccolpSk3k1nX9+ee3CRUHULUIwED9O/LI1UuWLBEqrjoQW7Y8JlQc ADAvKv3GY7GpXM7uhpSH6ALgiYmJl17aKVQcQNUiAAP1b+nSEY/HI1d//forTzrp JLn6AIC5sE4/SsRidjekPHbs2HHrrT+Rqx+JRPbuHZWrD6A6EYABRzjqqCM7OzuF ir/97W+/4opvChUHAMyRPxBIxOO5bNbuhpTHLbf8+KWXXhIqPjk5+eKLUsUBVDMC MOAIy5cv7+/vEyrOMmAAsJ01/JtMJAqmaXdbykN0AXAsFn/11VeFigOoZgRgwBGG h31DQ0NCxQ3DuP/+B9rb24XqAwBm5Q8ExpPJTDptd0PKI5fLXXrp15qbm4Xqh0Ih v39MqDiAakYABpxizZpjW1pahIp/7nP/86yzzhIqDgCYlQrAkVDIMKSGTCvs8ccf 37x5k1DxfD6/bdt2oeIAqhwBGHCKI45Y1d3dLVR8+fLlN9/8I6HiAIDDy2azo37/ eDJpd0PK5pprronFokLFx8fHX355l1BxAFWOAAw4xdKlSz2eAaHihULh0UelflQP ADg8fyAQjUT0fN7uhpTNunUXyM1/jkSie/fuFSoOoMoRgAGn0DTN6x1qbBT5W68C 8M03/2jFihUSxQEAh5HNZlUATsbjdjekbAKBwHXX/avcDSsYDKlLSBQHUP0IwICD vOlNR8ttVfXe9566bt06oeIAgENR6Tcei03lcnY3pGxuv/22Z599Vqh4JpP5y192 CBUHUP0IwICDrFy5ore3V6h4V1f3XXfdJVQcAHBQ1ulHiVjM7oaU02WXXTY1JZXn E4nEK6/sFioOoPoRgAEHGRkZHhwcFCqu6/qmTZubmpqE6gMA3sgfCKhEl8tk7G5I 2ZimeeGF61wul1D9cDg8OuoXKg6g+hGAAQfRNK/HM+hySW0r8qUv/csZZ5whVBwA cABr+DeZSBRM0+62lM0f//jHu++Wmk+k60YkEg4EgkL1AVQ/AjDgLKtXr+7qWiJV /Mgjr//364WKAwAO4A8ExpPJTDptd0PK6frrr9+7d49Q8VRqYufOnULFAdQEAjDg LMuWLRsY6Bcq3tTU9NBDDwsVBwAcQAXgSChkGIbdDSmniy++SK54NBrbs0cqXQOo CQRgwFl8Ps3r9QoVN03z7rvv6e7uFqoPAJhWPP3I708mk3Y3pJzS6cnLL79cbjuJ YDA4NsYBSICjEYABxznmmDe73W6h4p/+9Gc++9nPChUHAEzzBwKxSCSfz9vdkHJ6 9NFHf/WrJ4SK53K5F174s1BxALWCAAw4zqpVK3t6eoSKj4wsveWWW4SKAwAsxeHf QCAZj9vdkDK7+uqr43GpI52SyeSuXa8IFQdQKwjAgOOMjIwMDnqEihcKhUcf3SRU HABgUek3HotN5aQOy7XLunUXNDdLHVUQDkdGR0eFigOoFQRgwHE0zTs0NCS0wkoF 4BtvvGnVqlUSxQEADdOnH8Xj6i3X7raU09jY2Pe/f11jo0jv1DTNUCjEAUgACMCA Ex111FGdnR1CxU899bQLLrhAqDgAoDj5OZHIZjJ2N6TMbr/99meffUao+ORk+sUX XxQqDqCGEIABJ1qxYnlfX59Q8e7unjvvvFOoOAA4nDX8O55ImKZpd1vK7Bvf+EYu lxUqHo/Hd+9+Vag4gBpCAAacaHjYNzQ0JFTcMIzNm7cIFQcAh/MHAqnx8fTkpN0N Kb8LLviKy+USKh4Khfz+MaHiAGoIARhwIk3zejweuX7GJZd87V3vepdQcQBwMhWA o+Gwrut2N6TMnnnmmV/84nah4urbFYlEWAAMoIEADDjW6tVHdHV1CRU/4YS3XH31 1ULFAcCxiqcfjY0lEwm7G1J+N954w+7du4WKp1KpnTtfFioOoLYQgAGHWrZs6cDA gFDx1tbW++9/QKg4ADiWPxCIRaP5qSm7G1J+l1zyVblVzdFodM+evULFAdQWAjDg UD6f5vV6hYobhnHfffd3dEhtNA0ADlTc/ioQSMTjdjek/NSX9vWvXyp3AnAwGBwb CwgVB1BbCMCAcx1zzJvdbrdQ8b/7u3PPPvtsoeIA4ED+UvrNZaX2SbbRli1bHntM avfEXC73wgt/FioOoOYQgAHnWrVqZU9Pj1Dx5cuX33zzj4SKA4DTWKcfJePxQqFg d1vK75prronFokLFk8nkrl2vCBUHUHMIwIBzLV064vF45Oo/8sijcsUBwFH8gcB4 MplJp+1uiIh16y6Qm/8ciUT27h0VKg6g5hCAAefy+bTBwcGmpiaJ4oVC4cc/vmXZ smUSxQHAaVQADodCpmHY3ZDyC4VC1177vcZGkU6paZrhcJgFwACmEYABRzv66KPk tqo644z3f+lLXxIqDgDOkc1mR/3+8WTS7oaIuPPOO7dufVqoeDqd3rHjRaHiAGoR ARhwtBUrlvf19QkV7+/vv+2224WKA4Bz+AOBaCSi5/N2N0TEN795RVpsanc8Ht+9 +1Wh4gBqEQEYcLTh4eGhoUGh4oZhbN4stasnADhENptVAThZj6cfWS644Csul0uo eCgU9vv9QsUB1CICMOBomub1eDxyPY/166886aSThIoDgBOo9BuPxaZyObsbImLH jh233voToeK6rkcikUAgKFQfQC0iAANOt3r16q6uJULFTznlHZdffrlQcQCoe9bp R4lYzO6GSPnJT37y4os7hIqnUhM7d+4UKg6gRhGAAadbtmzZwEC/UPGOjo6NG+8V Kg4Adc8fCCTi8Vw2a3dDpFx66dd0XRcqHo3G9uzZI1QcQI0iAANO5/P5vN4hoeKG YTz88CNyU6wBoI5Zw7/JRKJgmna3RYS6R1x88UVyJwAHg6GxsTGh4gBqFAEYQMMx x7zZ7XYLFf+Xfzn/fe97n1BxAKhj/kBgPJnMiO2QbLs//OEP9967Uah4Lpd74YU/ CxUHULsIwAAaVq1a1dPTLVR8zZo13/vetULFAaCOqQAcDoVMw7C7IVKuv/76vXul pignk+O7du0SKg6gdhGAATQsXTri8XiEirtcrl/+8kGh4gBQr7LZ7KjfP55M2t0Q QRdffJFc8UgksnfvqFx9ADWKAAygQdM0r3eosVHkDcEwjPvuu7+jo0OiOADUK38g EA2H5TaIsp1K+F//+qVCC4ALhUIwGAoEAhLFAdQ0AjCAore85QShAKz83d+de/bZ ZwsVB4D6o8Khf2wsmUjY3RBBW7ZseeyxLULFVQB+5plnhYoDqGkEYABFK1eu6O3t FSu+8sYbbxIqDgD1xx8IxKLR/NSU3Q0R9L3vfTcSiQgVTyQSr7yyW6g4gJpGAAZQ NDIyPDg4KFS8sbHx4YcfESoOAHWmOPwbCCTjcbsbIuvCC9c1NTUJFQ+Hw6OjfqHi AGoaARhAkaZ5h4aGhPoihULh5z//33IBGwDqiUq/8VhsKpezuyGCEonElVeuF1p6 Y5pmKBQKBIISxQHUOgIwgH3e+ta3GobUbisf/ejHzjvvPKHiAFA3stnsWDCYjMcL hYLdbRF0//33/+53vxUq3tzs+uMf/yhUHECtIwAD2GfFiuV9fX1CxTXNt2HDBqHi AFA3ipOfE4lsJmN3Q2RdeeX6pNgJT/F4fPfuV4WKA6h1BGAA+wwPDw8NSc1SNk1z 06bNQsUBoD7sG/5NJAqmaXdbZK1bd4HQAUhKKBT2+1kADODgCMAA9tE0r8fjcblc EsULhcKNN960atUqieIAUB/8gcB4MplJp+1uiKyxsbHvf/86oQXAuq5HIhEWAAM4 FAIwgNcceeTqJUuWCBVfu/b0L3/5y0LFAaDWZbPZQCiUTCRMw7C7LbLuuOOOP/1p q1DxiYmJl17aKVQcQB0gAAN4zfLly/r7+4WK9/X13X77L4SKA0Ct8wcCqfHx9OSk 3Q0Rd8UVV2QyUqPcsVjs1Vf3CBUHUAcIwABeMzzsGxoaEipuGMbmzVuEigNArVMB OBIOG7rUbvzV44ILviK03KahuAA45PePCRUHUAcIwABe5/jjj5PbmOTKK6868cQT hYoDQO3KZrN+v19uY+Tq8dJLL91yy4+FihuG8dxzzwsVB1AfCMAAXmf16iO6urqE ir/znf/10ksvFSoOALXLHwhEIxE9n7e7IeJ++tOf/vnPLwgVT6VSO3e+LFQcQH0g AAN4nWXLlg4MDAgV7+zsvOeejULFAaBGFYd/x8aSiYTdDamEr3/90rxYzo9Go3v2 7BUqDqA+EIABvI7Pp3m9XqHiuq5v2rS5qalJqD4A1CJ/IBCLRvNTU3Y3RJxpmhde uE5uAXAwGBwbCwgVB1AfCMAADiS6DPiiiy5697vfI1QcAGpOcfg3EEjG43Y3pBK2 bt165513CBVnATCAuSAAAzjQqlWrenq6hYqfeOKJV155lVBxAKg5Kv3GY7GpXM7u hlTCTTfd+MorrwgVTybHd+3aJVQcQN0gAAM40NKlSz0eqWXAra2t99//gFBxAKgt jhr+Vb761YsLhYJQ8UgkuncvC4ABzIIADOBAmqZ5vUONjSLvD4ZhPPTQwy0tLRLF AaC2OGr4V9d1FYCFltioXB0MhgIBFgADmAUBGMBBnHDCCU1NUu8Pf//3//A3f/M3 QsUBoFZks9mxYDARjzeIDYpWlV//+tcPPfSgUHHTLDz77LNCxQHUEwIwgINYuXJl b2+PUPEjjzzy3//9eqHiAFAr/IGASr+5bNbuhlTIddf9azAYFCqeSCTlVhcDqCcE YAAH0jSv2+3u6+uTKG4YhgrAN9xwo0RxAKgV1vBvMh6XWxNbba699nuBQEBoCnQ8 Hs/lcoGAVMAGUDcIwAAOYmRkeHBwUKg4+2ABQHHvq0Qim8nY3ZDKEd0BKxwOj476 hYoDqCcEYAAH4fP5PJ4Bua1Krrjim6eccopEcQCofg4c/t2+ffuGDbcK3VYMw4hE omNjYxLFAdQZAjCAg/D5tI6Ojq6uLoniqqeydu3p69atkygOANXPgcO/t99+29at W4UCcCqVSqfTY2NsAQ1gdgRgAAehad7W1tb+/n6J4qZpDg+PbNiwQaI4AFQ5a/h3 PJFQb4Z2t6VyrrxyfTweb2pqkigei8WmpqZYAAxgLgjAAA5OdBlwc3Pzgw8+JFQc AKqZPxAYTyYz6bTdDamoiy66UOh4+QYWAAOYDwIwgIMbHvZ5PB6hn9abpvnFL37p zDPPlCgOAFXLmcO/v/vd7zZuvMflckkUV9/JSCTi97MAGMCcEIABHJzPp7W1tff0 dEsUNwzjlFNO+da3vi1RHACqljOHf3/84x/t2LFDaAFwMjmezWZYAAxgjgjAAA5O 07wtLS0DAwNC9Xt6eu+44w6h4gBQhfYN/yaTpmHY3ZaKuvzyy1VGFSoejUbz+TwL gAHMEQEYwCENDw8PDnqEVm01NTXdeusGr9crURwAqpA/EEiNj6cnJ+1uSEXF4/Gr rrpS6FZSKBTC4YjfzwJgAHNFAAZwSD6fT9O8QsdUGoZxzjmfVSSKA0C1yWazgVBo PJEwHDb8++ijj27ZslloAbDK1YFAkBOAAcwdARjAIWma1tbW1tvbI1FcdQGPOeaY H/zg3ySKA0C1cebwr/L9739/dHSv0ALgRCJZ/MlCgAXAAOaKAAzgcJYuHfF4PELF 3e62++67T6g4AFQVFYAj4bCh63Y3pNIuueQS05Qa9I5EInv3jgoVB1CXCMAADmd4 2Nff3y80da1QKFxxxTdPOeUUieIAUD2y2eyo3z+eTNrdkErbvn37hg23Cg3/6roe i8U4AAnAvBCAARyOz+dbsqRTkShuGMbatWvXrbtQojgAVA9/IBANh3XnDf/edttt W7c+LfRT1MnJyYmJSRYAA5gXAjCAw/H5tNbW1r6+PonihULB6/X+x3/8TKI4AFSJ bDbr9/uTzhv+Vb7znW+Pj48LbQEdj8enpqY4ARjAvBCAAcxiZGRkcFBqGXBzs+vu u+9ub28Xqg8AtisO/0Yiej5vd0MqLZfLXXbZZTLhtygcjoyOsgAYwPwQgAHMQnQZ sGmaX/jCFz7xiU9KFAcA2xWHf8fGkomE3Q2xwa9+9cSDDz4odPtgATCAhSEAA5iF z6e1t3d0d3dJFFc9mBNPPOm73/2uRHEAsJ1jh3+VH/7wh7t2vSwUgMfHU5lMmvnP AOaLAAxgFprmbWlpHRjoF6rf0dG5ceNGoeIAYCMnD/8ql156qa5LJf9oNJbPTwUC QaH6AOoVARjA7IaHhwcHPUK7mCjXXPPd448/Xqg4ANjFHwjEIpG8I4d/d+7cefPN NzU1NUkULxQK4XDE7/dLFAdQ3wjAAGY3MqIC8KBQcV3XP/ShD3/xi18Uqg8AtnD4 8O/dd9/15JNPCs1/bijugBUeHSUAA5g3AjCA2YkGYNM0h4eHN2z4aS6Xa2lpsV4U GjQAgIopDv9Go/mpKbsbUiHqzdx6Yhh6S0vr+vXfSSQScm/mBGAAC0MABjA70QDc UOo2ve1tb1eX6O/v93q9Q0ND3d3dS5YsaW9vd7vdzc3NVheKVAygVtT38K+VdQuF gmka+Xw+l5tKp9OTk5Mq8cbj8fHxcfVkx46/yA3/NhCAASwUARioT5rmVXGxucjV 0uJqbW2dHlytQqoXZRhGY4nqMLW0tLa3t6kA3NfXr1LxSNGwpvn6+vpUJFZfiJWE c7mceqI+ze7mA8CB6mb4N5PJqJxr3UFMU71X6yruqogbi8UiReFEIplKjatPm5rK q4+qN3Prf1S3H7mdIxZPtVPdGaPRmNVmFenZTwtwiOp9YwIwLyrxqq7GdNx1u921 OF6qkvAbH9UXokJxR0d7T0/vwEB/f/9Ad3eX6qy0tbUdddTRPp9vYGBAZeNa/HoB 1KXi8G8gkIzH7W7Iwqn32JTKtePj0Wh07949KvSq99h0elK9kkpNTE5OqFdM01Bv 0VbKfeNjbVFfr/oCk8lkPq/ysK6+LvIwUK9q7x0KwEyaprlcxcSr8qHoZDMbTSfh mZHY+pA1DU/90vpoS0tLe3tHb2+PCsk+n7Z06bIjSlRCtrH9AJymVoZ/Vd7z+/1j Y2PhcCgajVkDudlcztB1a0qO9R47HWhnxt3azbpzoet6Op2ZmppSTwIBjhoG6kp9 vm0B9c2a3qzCXl9ff6Fg1mv/4zCsJDzt8N+B0iq1Yh/Omlnd1dXd398/NDQ0MjKy cuVKFY+9Xm+9/uwAQOVVz/CvYRixWExFXBXhSnOVE6lUKp1Oq1xnrTpRt5JZ3z9n /tKZtxv1fYrHY/l8nmnSQH1w3BsZUNN8Pq21tbW3t9eBvRA5qk9jjSq3tro7Ozt6 enoGBgaGhrzDw8PLli1btWqVSsvMrwYwRypuxqPRKfnhX/XeFY/HrfHbSCSqQtr4 +Pjk5GQuN6XreettjfeuMlLf0kQioX5nx8YYEwZqGH1ooAZomtflamlvb+vo6CD6 Vp6VkBsbm9zu1vb2jq6urt7eXo/HMzg4qGna0qVLly9f1t/PLGsA5Rz+VWk2VBKL xVTuSiaTKtyWxm9z+byu4hj51hbqdqB+FzKZrK7nGRAGahE9aaCqWUO+3d3dzc3N drcFhzMdkltbW9ra2jo7O5csKebk/v4+lZS93iFN8y1btozNuoD6Vhz+jcWmcrlD fYK1uVQ4HI5GI7FYfHw8OT6empiYyGQyuVy2tOjUaGxssOYnV7LlmC/DMMbHxxkQ BmoOARioUir6ut3urq4uom89MUtKB1QVV3G73Soqd6iw3N3d1d3d09/f7/EUZ18r mqZ1d3fb3V4Ac6KCUCAQ2LNnz4s7XwqOjalMWzoWN53NqlirIlJOhSVrrz6GbeuM +p1NpVK5XI4YDNQKAjBQdTTNa0VfdmZyOGtUuaG4zXWzy6X+UYHZ3dbm7ugoZmZF JeSenuJDX8ng4ODAwAAHIwOLMTExEY1Gw+FwvGR8PJlMqng7rl6fnJxIp1WmVWEn p+t5XTdMs3jmLaO10HXdisFMigaqHwEYqCIq+jY3u/r7+xj1xYJZg8wNpdOhSppb WlwtLS2tRcX83NbW1t7eXgzRnZ3d3V0qS6tEvaSkq0RFavUhfv6C2qISyOSkdUpt 0URJujgOO6FeK62enSye8VOUm5oqDsvmi3QVYg/4W2P3l4JaVdp2O24YOjEYqGYE YKBa+HyayiEqftjdEGDfqcsqEsw487N4YMq+SF1iRWv1RIVr9cRVTNnqly63u1U9 t46nbil9QEVut9utnpf+2+ZyNVt5fPpz1P+i/kcVy1U19aguptI4OaS2qD8tKnCq PzYqZKoYUHrUc7liyLQOUy0FzuIC11yuGEHV67nSM/Wh6c9RT9X/ov5HlUtLL6t/ iwf2WDHVYu5T/BM682zw6ZNpAXtZZ00xIxqoWtwqAPtZA799fb2MuQEzWTm8YcZh pKWdxhqnHxsOcTBpGYOQKjX9g4BqYwW/A05qXWTBQ70489s+/d2Y8fORavz+AHbR dT0eTzAUDFQn7liAzawVv319fXY3BAAAlE08HmdVMFCFCMCAnTRN6+xk2jMAAHUo lUpNTqYDAaZDA1WEAAzYxufzDQ56WOgIAEC9Mk0zHI6MjY3Z3RAA+xCAARtomrep qbm/v49FvwAA1Ddd12OxuGkaTIcGqgEBGKi0/em33+XirCMAAOqfrhuxWIwMDFQD AjBQUaRfAAAciAwMVAkCMFA5zHwGAMCxmAsNVAMCMFA5w8O+0tgv6RcAACcqZeCY 38+eWIBtCMBAJWiat7nZ1d/f19zMzGcAAJzLMIxYLG4YOuPAgC0IwEAl+Hza4OAg Jx4BAIDS2UjhsTHOBwZsQAAGxGmatnz5sqmpKbsbAgAAqoLL5dq7dzQQIAMDlUYA BmRpmrelpXVgoN/uhgAAgCoSjcby+SkmQgMVRgAGZA0P+4aGhuxuBQAAqDqhUIgN sYAKIwADgjRNUwHYNE27GwIAAKpRIBBkIjRQSQRgQIqmeVtbW/v762fyc6FQUGFe PTY2Ft861CPbegEApFm3nobSbci69Vi3ofoQi8WmppgIDVRO/bx9ANVmeNg3ODhY ozdpK+u2tLT09PR4vdpRRx118sknnXLKOzRNMwxDfUg9ZjKZHTt2bNu27cUXX9y7 d284HEomx7PZrPpgnfVOAADSrPtOc7Oro6O9t7e3tH/kiqOPPvr4449Xj62trdOf OTY29uSTv3/66a3q7hMMBpLJZD6fr937jvrCw+EwE6GBiqnJdwqg+qk799KlI7qu 292Q2Vl9DrfbrbLu0qVLV68+8sQTTzz55JNHRkYWXDMajT777LPbt2/bufNllY0j kXAqlZqamlLX4iRkAHAywzBUUm1ra+vq6hocHFq2bNnq1Ucce+ya4447rq+vb8Fl R0dHn3766T/96U87d76k7jsqFedyuVpJxU1NzX6/n4nQQGXUwJsCUHM0zetyuTwe j90NOYhCSXd3j8q3b37zm0466eS//uu/HhwcrMzVVdIOBoPPPvvMCy/8+ZVXXlH9 lUgkMjGRUt0U9VGyMQDUByvlut3uJUu6PJ6B4eGRlStXHnPMm0844S1er7diy2fC 4fBvf/vbrVuf/vOf/6LuOOPjycaSylx9XtTdUNd1JkIDFVCNbwFArdM0Td3vVQa2 uyFFVuL1eAaPO27Nf/kvf33qqadWLO7Oi8rGqnfy3HPP7dixQ2XjsTF/JBJNpcZV NjbNgstFNgaA6qLrRlNTMeV2dXWru57PN6xSrjVpeWRkpDo3iVCR+LHHHvvd7377 /PPbIpFw9eRhlX7VXY9BYKACquLvPFBPNM2regOLmce1eFboXb58+Xve896PfOQj q1evtrExZaG6Kdu2bfvLX1Q23uX3+0OhcDKZyGQyqsfAXlwAIMTafcrlcrW3t/f0 9A4NDQ4Pq5S76k1vOnrNmjUeTzX+OHVedu7ced999z3xxOOvvvqq7WE4Ho/ncjkG gQFpBGCgzHw+zev12nJpa5PMt73t7eeee+473/lOW9pQedls9uWXX37hhRdefnmn 6sEEAoFYLG5Nq1Zdt1pZAAYAtrC2gVBvldZ05f7+vtLuU8uPOGL1Mcccc8QRR7S1 tdndxgr5zW9+s2HDhqee+kND6ZgDW9oQDAbHxhgEBmTRLwTKSaXfjo7Orq4lFb6u rhsrViz/+7//hw9+8IMVvnSVm5ycfPHFHTt2vPjKK7tGR0dV3yIWi6VSE9lsxlqi xugxgPpmjeI2Nze3tbWr21N/f7/X6x0ZGVm5ctXRRx911FFHd3Z22t3G6vLLX/7y xhtv2L371cqvvlG3p3R6kgwMiCIAA+U0POwbGhqq5BVV9F2z5tgrr7xq5cqVlbxu fdB1fWxs7C9/+cuuXbus0eNIJJJMJlVsnpqaMk2jobg5JwkZQPVS+bahtI1wa2ur irI9PT0ej8caxV21atWb3vQmn89XJXtS1JZXXnnloosu3LZte4VjcCgU4kgkQBQB GCgb1eHw+TRrHnIFqAu53W0/+MEPTjnllMpc0YGsbatfeukl1RPau3dvMBgIBkOl hDyRyWSnpoqzrBlGBiDEGrxV7zCtre729rbOziWls9mHvF5t6dKlK1euPPLIIyu5 qbIDPfnkk//8z/+cy2UrOSk6EAiyGxYghwAMlIemeZubXYODFTr6yDCMNWuOu/32 2ytzORyG6qFGo9GdO4srkFVIDoWC0WgskYiPj6fS6bTqNlkHIFu9WBYkA7CW3Vpb LrWqaOtu6+jo6O7u6u3tGxjoHxryqnC7fPny1atXDwwMEG6rwdlnn71t2/MVO6sv HI4YBkciAVLoigHloWmaSr+VuTuq9Hv22Z+++OKLK3AtlFEymVQheXR0byAQCIVC kUi0lJOVVCaTzmaLUVnXdWsSAWkZqCFWpm0obZ7kcrlUrG1ra2tvL8ba7u5ulWw9 noGhoSF1pxgZKYbbnp4eu5uM+Vm/fv3tt99Wsbu8ysAMAgNC6F0BZaBp3paW1oGB /gpcS90XzzrrrEsu+VoFrgUbpdNp1fsJFgVUTygaLaZlFaETiaRKy5lMRgXmXE4F 5rz6I2GWWJmZ2AwshjVfw/oLpajA43K1uN1WoFU6entVeu0pjdYODA56vN7izv8q 2XZ0dNjddsj69re/dccdd1QmA0ejsXx+ikFgQAL9JKAMKjb8q6LOkUcetXHjRukL oUapVKyisgrNkUgkFoupvKwycyo1kUqNT0xMqlCtknNO5eYp9c9UPl8Mz7pulHr7 5vTydQafUaOmh2EbSiOxpT/JTS6Xem9ubmlpaW0tTTd2u4sptqNjyZLOrq7urq7i qlqVZ/v7+z0elWa9KtY65+AfzNfHPvaxl156sTK3ewaBASF0cYDF0jSv6lWpzlMF rqX6c3/849MVuBAcTkXleDyeSqVUfp6YmFC/VI+ZknRaBWmVoovjz9YKZxWks9mc rudVllaP+byuYrUK1Oq5SiO6XnxumoaVTKykPR22rSfqUcUV9VTl7ulBbEJ4bZn+ rbR+e9XvnvXb2jDjt9L6zbUWtVrDqyqiulwu9czlalHPm5tdLS3qBfVvcdy1rc1t BVe3u83tttbKquzaWRqJbV+yZEkpxxYTbFdXV19fH2OwqIC3vvXk6Z+ziIrFYuoN lkFgoOzoXgCLVcnh3x/96Mfs+QznmJycVPlZpSOVwFVHUL2iAriK2Q2lsW4VtdUT a+H0Af3RfF6F86mytEH91f7Tn/6kwnxZqpWXiognnniiemcoSzWVMFXYnPlKKZcW l7Oq5yqIWuOiKpq2txdzpnpdBU71nVefw0GycI4nn3zyf/2v/6cCN331zhaJRBkE BsqOAAwsiqZ5VefP4xHf/Fn1cY899thf/OIO6QsBAIDD+B//46zt27dXIANHIhEV gxkEBsqLAAwsis+njYyMqPuT9IUKhcKf/vSM9FUAAMCs3vKWEypwQpXL5RodHR0b YxAYKCcCMLAow8O+oaEh6asYhnH++eefe+7npC8EAABmtWHDrddee20FBoFDoZDf PyZ9FcBRCMDAwmma1+1u6+vrFb2KaZoDAwOPP/6E6FUAAMDcvfe974lGo9LjwPF4 IpfLMgsaKCMCMLBwWpFX+ioqAD/22GMez6D0hQAAwBxFIuFTTz21AhOhVfplKyyg jAjAwAKp6Nve3t7T0yN6FcMw1q49/Xvf+57oVQAAwHx9+ctf3rx5k/RE6GQymclk GAQGyoUADCxQZU4/amxsfPrpraKXAAAAC3PyySdNH2wuxDCMcDjCIDBQLgRgYIEq MP9Z1/XvfGf9hz70IdGrAACAhXnggQe++tWLXS6X6FWYBQ2UEQEYWCCfT/N6BQNw oVBoa2v//e9/L3cJAACwSO94xzuy2Uxjo2CnOhgMchgSUC4EYGAhNM3b0dHZ3d0l dwnDMC6//IqPfvSjcpcAAACLdO+991522ddFl0SNj6fS6UmWAQNlQQAGFkLTNI9n QG7KU6FQULfSP/7xaaH6AACgXN761pMNw5AbBNZ1PRKJMgsaKAsCMLAQ0guA1X30 tNPWXnbZZc0lTU1N1hPRGVYAAGCaeTDqBm09KZRYn7l+/frHH39MdBCYZcBAudCZ BhZCegGwruv33LPxMGcsqSQ8MxhPq8CBhAAA1BwVVg8aaGdacPFkMvnxj39MdCss lgED5UIABuZN07xtbe29vVInAKt7cE9P71133bXIOgfEY4aRAQB1Y9Y0K3060QE+ +clPJpMJuR9DJxLJbJbTgIEyoB8MzJvPpw0NeeVSpK7rH//4x//hH/5fqQvMMDMY zwzMhGQAQMUcKsGWZXi2Mm644Yf33HOP5OYgDaEQg8BAGdDHBeZN01QAHpT7Ka9h GI8+uql6JjPPDMaEZADAYVip9fDzjSs8NlsZ6ut63/tOl1sGrOqHQmGWAQOLR/8V mDfRHbDKNf+5wqw1ydMJeeYjORkAatRhcuz0h+oyzS6M9Cxo9sECyoKOKTBvPp/P 6x0SKq7rxgc+8IHzzz9fqL69mkrIyQBQYTOj7AGxduYv7W5mbbv22msfeughl0tq EDgYDI2NjQkVB5yDHicwP5rm7ejo6O7uFqpvGMbPf/6/RbeYrn7Te1xPJ+SZT4jK AJxsLjmWUVlbBIPBv/3bz8jNgh4fH0+n0+yDBSwS/UhgfjRNGxz0CN3eVJfF5Wp5 8MEHJYrXJRWGDxqSrSdEZQDV6YApxAedV0yOrUVnnnmmrueF7j6GYYTDEWZBA4tE 7xCYn+LyX++Q3L3t+ONPuPbaayWKo2k2BGYAc3TAVk+H+SUh1lHOP//85557Vu6n 5MFgiAAMLBK9PWB+RHfAUgH4S1/6lzPPPFOoPuaFwAzUpcJ+MzPqQX85/dzuJqNm PPjgg9dd969ys6DZBwtYPHpvwPz4fJrcAl1d17dseUyoOCqgsWRmQj7Uc7tbCtSe 6Tg6M6YePsHa3WQ40WmnnSp3GnAwyFHAwGLRCQPmQdO87e3tPT09EsVVd62lpeWX v2QBsBM17mfF4zk+sbvVwMEVDm1mcD3oL+1uO7BYH/zgmfm81DLgZDKZyWTYBwtY DPpPwDz4fNrg4KDQEX+GYaxZs+a6674vURzO8cYsPdPMTzj8R+3+OlA205N4Z0bN WV8/DHu/HKDKfelLX9y2bZvQLGjTNMPhMIPAwGLQxQHmQdO0oSHBAHzhhReedtpa ieKAhOnMXJbHA8oe9FoLe/GAzPbGCHf4TzjoLw//uBjTFeQuAUDOli2br7rqKrkA HAqFWQYMLAYBGJgH6R2wNm/eIlQcAABUxtq1p7EPFlC1CMDAPIgGYNMsbNq0Sag4 AACojNNPP72pSaqPTQAGFokADMyVir5ut7uvr0+iuGmaqvIdd9wpURwAAFTMWWd9 Kh6PCy2YUpVzuRz7YAELRgAG5koF4K6urs7OTonihmH89//+7q997WsSxQEAQMV8 61vf+j//51dCs6AnJydTqRQBGFgwAjAwV5qmDQ56hO5nuq7feuuGZcuWSRQHAAAV s2fPns997lyh04ANwwiHI8yCBhaMAAzMVXH5r3dI6HgYFYC3bHlMojIAAKiw0047 VSgAFwqFYDBEAAYWjAAMzBU7YAEAgLlgHyygahGAgTlR0bepqWloaEiiuGmaXq/3 Zz/7uURxAABQYeec87fBYFBoH6xQKKR6DiwDBhaGAAzMiQrAHR0d3d3dEsUNw/jK Vy543/veJ1EcAABU2KOPPvrd714jtG/I+Ph4Op0mAAMLQwAG5qS4/teryaz/LQbg zZu3iJQGAAB2WLv2NKEAXCg0BIuToAnAwEIQgIE5Ed0CmgAMAECdkQvAbAQNLAYB GJgTuR2wCoWCukE+9NDDEsUBAIAtPvCB96ukKnR4BPtgAQtGAAbmxOfzeb1SO2B5 PIO33XabRHEAAGCLT3/605FIWGgfrGAwNDY2JlEZqHsEYGB2muZ1uVwej0eiuGEY 55//5fe///0SxQEAgC0efvjha6/9ntAs6Egkous6y4CBBSAAA7NTAXhJiURxFYDv v/+B9vZ2ieIAAMAWmUzmwx/+kFAAnighAAMLQAAGZqcCsMfjcblcEsV1Xd+y5TGJ ygAAwEannXaqXOchEokQgIEFIAADs9M0bWhoUGgZj2mamzZtlqgMAABsdPrpa+U6 D6FQmH2wgAUgAAOz0zTv4OCgxCymQqHgdrvvv/+BslcGAAD2+vCHP5TL5SQ2gi6d hBRmBBhYAAIwMDu5EWDTNFetOuKmm24qe2UAAGCv8847b9eul4X6D4wAAwtDAAZm J3cIsK7rt9zykxUrVkgUBwAANtq9e/fnP/8/hZYBcxQwsDAEYGB2cgHYMIzNm7dI VAYAALZbu/Y0oY2gCcDAwhCAgVmo6Nva2trf3y9RnC2gAQCoY3IbQcdisampKZYB A/NFAAZmoQJwe3t7T09P2SsXCoXGxqZHHnmk7JUBAEA1OOOMMwoFU2IfrGQymclk CMDAfBGAgVmoANzV1dXZ2Vn2yqZper3en/3s52WvDAAAqsE55/xtMBiU2AdrcnIy lUoRgIH5IgADs1AB2OPxSMxfMgzjpJNOvvrqq8teGQAAVIN169Zt3fq0xDJgXdcj kQgBGJgvAjAwi+L+V94hiclLum588pOfPO+888peGQAAVIObbrrprrvucrnKH4AL hUIwGGIfLGC+CMDALNgCGgAALBgbQQNVhQAMzIIADAAAFowADFQVAjBwOKJnIJmm uWnTZonKAACgSpx++lqJTbAaOAkJWBACMHA4KgC3tbX39oqcgaQq33fffWWvDAAA qsdHPvKRbDYjsZlIIpFUlQnAwLwQgIHDUQG4s3NJV9eSslc2TXNkZOTWWzeUvTIA AKgen/vcuaOjoxKDwKnUxOTkBAEYmBcCMHA4xR2gvZrAD22LC4D/6q/+av36K8tf GgAAVI2LL77oP//zPyWWARcKDcHiKmACMDAPBGDgcHw+bWBgQOgQ4E98gjOQAACo czfddNPdd98ldBRwNBodG2MfLGAeCMDA4bAFNAAAWCQ2ggaqBwEYOBwCMAAAWCQC MFA9CMDAIano63K1eDwDEsUJwAAAOIRcAI5EorqeZxkwMHcEYOCQVAB2u919fX1l r1woFFwu14MPPlT2ygAAoNqceeYHdF2XOAkpHo/ncjkCMDB3BGDgkFQAbm/v6Onp Lntl0zRVrr7jjjvLXhkAAFSbs876lEqqEichJZPjmUyaAAzMHQEYOCQVgLu6ujo7 O8teWQXgo446+vrrry97ZQAAUG3+8R//8cUXd0gE4MnJyVQqRQAG5o4ADBySCsBD Q0MStyvDMN773lMvvvjislcGAADVZv369Y8//pjEMmDTNEOhEAEYmDsCMHBIPp/m 8XiEDu77whfO+9SnPlX2ygAAoNrceeedN998k8vlKntlwzAikQhHAQNzRwAGDokz kAAAQFlwEhJQJQjAwCERgAEAQFkQgIEqQQAGDq50CLDL4/FIFDdNc9OmzRKVAQBA FTr99LUSu4o0FI8Cjui6zjJgYI4IwMDBqQDc2uru7xc5BLixsfGRRx4te2UAAFCd zjjjfVYHoOyVY7H41BRHAQNzRQAGDq50CHB7T0+P3CXUjdA0zebm5iVLlng8nqVL l61Zs+ajH/2o3BUBAICoe++9d9u2bXv37olEIhMTE4ZhNDU1SeTeaclkMpPJEICB OSIAAwenAvDIyIi6b1X+0ioVq0e3u623t8fr1Y455pjPf/7zlW8GAAA4jFtuueWF F14IBgOJRDKXy6pXhCY5H15zc/Po6CgBGJgjAjBwcCoADw4OCu1XsQDWcLG6s3Z2 Lunr6/N6vSoYn3POOXa3CwCAOvezn/2sFHSD8Xh8cnLCuh2LDurOi2EY4XCYAAzM UbX81QWqjc+nqQBsy49y58UKxo2NTR0d7b29fUNDg8ceu+bcc8+1u10AANSYDRs2 bN++LRQKJxLxdDqjbrBVFXQPRXUDVADmKGBgjqr9rzRgFxWAvV6RM5AqY38wbmxt be3q6urvH9A07dhjj/n4xz9hd9MAALDNPffcvX37C4FAIBaLplKpqakpdcesiaB7 GMFgkAAMzFEN/1UHRMkdAmw7dae39uRwu90qG/f19auor7LxJz7xSbubBgBAGdx9 910q5ZYmLcdUys3lctaukzWdcg+Do4CBuavPdwFg8eo4AB+eWdLa2tre3t7d3T0w 4FHx+Ljjjnv/+99vd9MAANjn4Ycffv7551XEjUYj4+PjmUxmamqqqcTuptmAAAzM HQEYOIjSIcCt/f39djekuljTqtWTlpaWtra20uhxn0rIKh5zehMAoLzuvfdeFXFV vo3H46lUKpvN5vP5htJOy/U6kLtgsVhM5X/2wQLmgrcP4CBKhwB39PR0292QGjO9 8NjlamlvVwm5u7e3p7e37/jjj2PtMQBgpnvuufu5555PJOKJRDKVGs9ksrqer4Pl uLZIJtU3ME0ABuaC9xfgIFQAHh4eMU0bDgGue9YU6+bmZmuWdWdnZ09R71ve8paP fexjdrcOAFAGGzdufOaZZ5LJRDKZnJyctOYnW9tPOHOKsrSmpma/n6OAgTkhAAMH UW2HADvN9Fxrl8vV0tLa1ta2pKSvREXl97znPXa3EQAc54knnlCxNl4yUVKaljyl 63oDM5NtxVHAwNzxPgUcBAG4VqicrNJyadK1isotra3ujo72zs5iWu7t7e3u7jrp pJPf+c532t1MAKhSv/nNb7ZufXp8PJVIJFSgnZycSKczU1O5fD6vYq31BsuYbfUj AANzRwAGDqLWDwHGQVlpuaE0TLF/bNnd3t7e0dGpdHV1qce3ve1t73rXu+xuKQAs 0K9//eunnnpqcnIylUqpx3S6OP04m81Z47TW5BoybV3iKGBgjgjAwEEQgGGxzkxu KGXm5hIVnN1F+xYwd3R0LFnSpZ6/4x3vOOWUU+xuL4A68eSTT/7+979X2XViIpVW Kba0jDaXm8rlcrqeN0qsNFvHZ9tiXgjAwBzxjgkcBAEYi1TYr2H/YEsxO7uaS/O0 Fbc1+Nze3qH+7erqUon6ne/8ryeccILdDQdQBs8+++xvfvP/q7yaSqUyRWlrGHZq Sv0zVZpdrAKsPj0tpXE/uxuOGkYABuaIt1rgIAjAqAbTm4HtPxek+GCNQ7e0FNc8 lxQ3CVNxuq2tXf2no6OjtbXl1FNPO/bYY+1uPlBjtm/f/thjW1Q+TafT2aJiZLU2 ecrvo2KrXhp6tf52mlZkZfMnVAMCMDBHvF8DB9I0r0oVAwMDdjcEKLPpRG1Ridoa dFKR2prjrXK1ReVqK2OX5nu7rZitnrS3t6lPPOOMM1asWGHjFwJn2r179yOPPGKa RiaTzeX2RdNciZVOrWWuSimpFmcIq8f9szFe+5NPXkVdikaj6q8B+2ABs+IGABxI BWC3u62vr9fuhgC1Z+bcb4uVNKx54JZS5C5OCC8F7+KDlbdLO3mrV13FNdZF6iVr xniLqvDxj3+CeRnVIxgM3nPP3erJ1FR+akrFzrz1RGVRw9BL+wfvS6T7c6hhTfrd N3JaYv05OeBPCzOBgYWJxxO5XJYADMyKewxwIBWArT2B7W4IgHkrvKbBilEz11g2 lEb/GvaPAU7vhatyuDW9XH2i9cR6paG0w9DY2NjMkfN5mTXLzYx/86Ua7/P5rH3a VJy0cqZ6oqpaT9QrDfv3P58e/5+eVz/9nSn9svjtIn8Ctcva95sADMyKmxxwIBWA NU2zuxUAAADzECgiAAOzIAADB1IBeHBwsDQWBAAAUAMMwwiHwwRgYFYEYOBAbAEN AABqDhtBA3NBAAYORAAGAAA1hwAMzAUBGHgdzkACAAC1iJOQgLkgAAOvowJwW1tb by9nIAEAgFqSSCSyWU5CAmZBAAYOpDJwa2tr8YjSZldHR3vD/nNTAAAAqodpmvki 3TCKB21PTU2RfoFZEYCB2alIrMJwc3NTMRO7XG63u6nE7nYBAABHsLKuXmKUzvxW oZe4CywAARhYoANScVtbm4rEjY38nQIAAAtXKBTy1sAuWRcQQGcdKKc3pmIViRkr BgAAb8S4LlB5BGCgEmasK27u6OgoFArqid2NAgAAFaLS7YxBXdbrArYhAAO2sY5c aiqOFjf39HSrmyKTqAEAqGmFQkHd0EtZtzSkaxocTQRUFbraQHVRqdjlcjVZsbg0 XGyapnrF7nYBAIDX0fezBnXV/Vo9J+sCVY4ADNSGUjBuKQXjJut8JuZRAwBQAftn Lxul04bMUtBlUBeoVQRgoLbtD8aNKgyrdNzVtUTdn5lKDQDAvFhTl60BXdO0RnQL BF2g/tBFBuqWpmktLa7SicXWbGoGjQEATjdz2rIKuqV9mPVAIGB3uwBUCAEYcKJS Ni6OG5eycVNnZ6fqATBuDACoA9NjuftX5hbHcks7UZFyARCAAbyeysYuV3PTa5pL 8Zhp1QCAarE/4r42imtRr5ByARwe3VkA82DF48bGptLocTEed3d35fN5lY2ZXA0A KJfiflOvG8JVVOwl4gJYLAIwgHJ6Q0Ju6unp1fW8NcVasbuBAACbmdYeU68Lt+Rb ABVCAAZQaT6f1tzsaiym5FJQbmyy1iGrrpD6KHOtAaBGFSPs/nBbemKWXrDCbcEw 9LExwi0Am9HLBFClZubkxn3DyY3d3d26rquOlPWS3W0EAEeYGWutQFsKtSRbALWH AAyg5pWicnPjPk3Tgdk6FVl1zhoYWAaAGQr7R2b3Z9qZgbYUaoux1iDWAqg/dAcB OI7P55sRmKdHmBunly67XK4GMjOAGjGdZmcupp3xWJgRaMfsbiwA2Iy+HQDMiYrN Lldxp+vp4Lw/PDfO3PTLWtJMcgYwX6WMas4Is/sGY/eH2H3/UZ+p60RZAFggumgA IK405rwvK7+WoF83BP2GCdyMPwO1ozBjr6eZo64zB2D3x9fp8ViTEAsAlUfvCgBq xvCwb38wLj7MfHIoTTMHqUnUQMnMmGq+MaQekFgbXvdEfb7fT3AFgFpFZwgAHM0K 1Q0Nr8XpmY8zhqxfi9kHS90qXbNqGuWxP5Q2TE/6fUMW3ffLGQOq1odmPhb/Q1gF AByAngoAoBKmk/b+gP26tP3G7P3GUe6G6SzeMDONHzgAbsPXVl8ONQB6kMHQA184 8PENr+57kVwKALALHQUAgBONjAxPp2X1RGWzmbHcern0WGhpaZl/rj7w81WBUvzb dxXr+Rsc/NVDUakyn89Pt3P6Rat+6YqvvTg66p9XcQAA6hIBGAAAAADgCARgAAAA AIAjEIABAAAAAI5AAAYAAAAAOAIBGAAAAADgCARgAAAAAIAjEIABAAAAAI5AAAYA AAAAOAIBGAAAAADgCARgAAAAAIAjEIABAAAAAI5AAAYAAAAAOAIBGAAAAADgCARg AAAAAIAjEIABAAAAAI5AAAYAAAAAOAIBGAAAAADgCARgAAAAAIAjEIABAAAAAI5A AAYAAAAAOAIBGAAAAADgCARgAAAAAIAjEIABAAAAAI5AAAYAAAAAOAIBGAAAAADg CARgAAAAAIAjEIABAAAAAI5AAAYAAAAAOAIBGAAAAADgCARgAAAAAIAjEIABAAAA AI5AAAYAAAAAOAIBGAAAAADgCARgAAAAAIAjEIABAAAAAI5AAAYAAAAAOAIBGAAA AADgCARgAAAAAIAjEIABAAAAAI5AAAYAAAAAOAIBGAAAAADgCARgAAAAAIAjEIAB AAAAAI5AAAYAAAAAOAIBGAAAAADgCARgAAAAAIAjEIABAAAAAI5AAAYAAAAAOAIB GAAAAADgCARgAAAAAIAjEIABAAAAAI5AAAYAAAAAOAIBGAAAAADgCARgAAAAAIAj EIABAAAAAI5AAAYAAAAAOAIBGAAAAADgCARgAAAAAIAjEIABAAAAAI5AAAYAAAAA OAIBGAAAAADgCARgAAAAAIAjEIABAAAAAI5AAAYAAAAAOAIBGAAAAADgCARgAAAA AIAjEIABAAAAAI5AAAYAAAAAOAIBGAAAAADgCARgAAAAAIAjEIABAAAAAI5AAAYA AAAAOAIBGAAAAADgCARgAAAAAIAjEIABAAAAAI5AAAYAAAAAOAIBGAAAAADgCARg AAAAAIAjEIABAAAAAI5AAAYAAAAAOAIBGAAAAADgCARgAAAAAIAjEIABAAAAAI5A AAYAAAAAOAIBGAAAAADgCARgAAAAAIAjEIABAAAAAI5AAAYAAAAAOAIBGAAAAADg CARgAAAAAIAjEIABAAAAAI5AAAYAAAAAOAIBGAAAAADgCARgAAAAAIAjEIABAAAA AI5AAAYAAAAAOAIBGAAAAADgCARgAAAAAIAjEIABAAAAAI5AAAYAAAAAOAIBGAAA AADgCARgAAAAAIAjEIABAAAAAI5AAAYAAAAAOAIBGAAAAADgCARgAAAAAIAjEIAB AAAAAI5AAAYAAAAAOAIBGAAAAADgCARgAAAAAIAjEIABAAAAAI5AAAYAAAAAOAIB GAAAAADgCARgAAAAAIAjEIABAAAAAI5AAAYAAAAAOAIBGAAAAADgCARgAAAAAIAj EIABAAAAAI5AAAYAAAAAOAIBGAAAAADgCARgAAAAAIAjEIABAAAAAI5AAAYAAAAA OML/BX0Yiq0T6k2tAAAAAElFTkSuQmCC"/></symbol><use xlink:href="#c" width="1280" height="1280"/></g></g></svg>')} -.is2d .pawn.black {background-image:url('data:image/svg+xml;base64,<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="614.635" height="614.635" viewBox="0 0 460.977 460.977"><mask id="b"><use xlink:href="#a" width="1280" height="1280" transform="rotate(.193) scale(.36014)"/></mask><symbol id="a" viewBox="0 0 1280 1280"><image width="1280" height="1280" xlink:href="data:image/png;base64, iVBORw0KGgoAAAANSUhEUgAABQAAAAUACAAAAAA9j6ArAAAACXBIWXMAAA7EAAAO xAGVKw4bAAA+xElEQVR4nO3dB5RV5b2G8QGlDnUARRBRUbDGgjFiN7GQa4kNQekg KIgGVCygFAVjwa5BRKKCYu8dRRERlGoDRCkCUqRMgRmaIncGQTpM2Xu/3/f9n9/N MusmZnjXyT3PPXN2K5YCAEYVUw8AABUCCMAsAgjALAIIwCwCCMAsAgjALAIIwCwC CMAsAgjALAIIwCwCCMAsAgjALAIIwCwCCMAsAgjALAIIwCwCCMAsAgjALAIIwCwC CMAsAgjALAIIwCwCCMAsAgjALAIIwCwCCMAsAgjALAIIwCwCCMAsAgjALAIIwCwC CMAsAgjALAIIwCwCCMAsAgjALAIIwCwCCMAsAgjALAIIwCwCCMAsAgjALAIIwCwC CMAsAgjALAIIwCwCCMAsAgjALAIIwCwCCMAsAgjALAIIwCwCCMAsAgjALAIIwCwC CMAsAgjALAIIwCwCCMAsAgjALAIIwCwCCMAsAgjALAIIwCwCCMAsAgjALAIIwCwC CMAsAgjALAIIwCwCCMAsAgjALAIIwCwCCMAsAgjALAIIwCwCCMAsAgjALAIIwCwC CMAsAgjALAIIwCwCCMAsAgjALAIIwCwCCMAsAgjALAIIwCwCCMAsAgjALAIIwCwC CMAsAgjALAIIwCwCCMAsAgjALAIIwCwCCMAsAgjALAIIwCwCCMAsAgjALAIIwCwC CMAsAgjALAIIwCwCCMAsAgjALAIIwCwCCMAsAgjALAIIwCwCCMAsAgjALAIIwCwC CMAsAgjALAIIwCwCCMAsAgjALAIIwCwCCMAsAgjALAIIwCwCCMAsAgjALAIIwCwC CMAsAgjALAIIwCwCCMAsAgjALAIIwCwCCMAsAgjALAIIwCwCCMAsAgjALAIIwCwC CMAsAgjALAIIwCwCCMAsAgjALAIIwCwCCMAsAgjALAIIwCwCCMAsAgjALAIIwCwC CMAsAgjALAIIwCwCCMAsAgjALAIIwCwCCMAsAgjALAIIwCwCCMAsAgjALAIIwCwC CMAsAgjALAIIwCwCCMAsAgjALAIIwCwCCMAsAgjALAIIwCwCCMAsAgjALAIIwCwC CMAsAgjALAIIwCwCCMAsAgjALAIIwCwCCMAsAgjALAIIwCwCCMAsAgjALAIIwCwC CMAsAgjALAIIwCwCCMAsAgjALAIIwCwCCMAsAgjALAIIwCwCCMAsAgjALAIIwCwC CMAsAgjALAIIwCwCCMAsAgjALAIIwCwCCMAsAgjALAIIwCwCCMAsAgjALAIIwCwC CMAsAgjALAIIwCwCCMAsAgjALAIIwCwCCMAsAgjALAIIwCwCCMAsAgjALAIIwCwC CMAsAgjALAIIwCwCCMAsAgjALAIIwCwCCMAsAgjALAIIwCwCCMAsAgjALAIIwCwC CMAsAgjALAIIwCwCCMAsAgjALAIIwCwCCMAsAgjALAIIwCwCCMAsAgjALAIIwCwC CMAsAgjALAIIwCwCCMAsAgjALAIIwCwCCMAsAgjALAIIwCwCCMAsAgjALAIIwCwC CMAsAgjALAIIwCwCCMAsAgjALAIIwCwCCMAsAgjALAIIwCwCCMAsAgjALAIIwCwC CMAsAgjALAIIwCwCCMAsAgjALAIIwCwCCMAsAgjALAIIwCwCCMAsAgjALAIIwCwC CJFi69QLAAKIxB1XKfcv+9SaOyf3n9LHqtfAMgKIZDRM+Ue18gekVKy97b81Oyvl x+W/fLJuWPKrYBwBRLyqHnN03bqVDs7f3zwlY9oPE8ZnxrsI+BMBRGwa/mP/A/5S iP9c9o8/Tv/ok8jnANsggIhDwwsOP6Ba0X7ELz989cqn0awBdoAAImJ1L65ffztf 9BXOjHHjXp4T1Q8DtkYAEaG6F596ZBE/+G1rwfhPXp4b9Q8F8hBARKTqJedHH7+N Fox76bWcuH447CKAiMJxF52dzwO9hTfp9Ve/i/vPgDEEEEV2eoeTYvvot6V5Hz46 Ppk/CTYQQBRNx/PPSPTPyxjx4vOJ/oEIGQFEEZze4ULBn7r09f4TBH8sAkQAUVhH dPm/hH7z3dbclx7k7BgUHQFEoVTo1D6yk/0KZ/KDT6/RLoD/CCAK4fQbkv3ib/vS h935tXoD/EYAUVD6D3+bfPfAED4GovAIIArmiB6K4x47tvjlHkvUG+AtAoiCaNLh ZPWEbT33+Aj1BHiKACL/OnaK/XKPwhl951vqCfASAUR+dessO+tl1364/Rn1BHiI ACJ/nM5fnh96D1VPgHcIIPLD+fzl+aHXc+oJ8AwBxK55kb8803qTQBQEAcSueJO/ PNN6casE5B8BxM416eHokd8dGXHzF+oJ8AYBxM4c8Zxn+csz7OLl6gnwBAHEjqUN Pls9oVCyBtz8u3oDvEAAsUP3XK9eUGhzbhukngAfEEDsQJM7nbnlQWF80WqaegLc RwCxXWmvOXjRb4EsH9xJPQHOI4DYnm591QsiMOOGV9UT4DgCiG3VecvDY7/b806T bPUEOI0AYhsD2qsXRGbuPQ+rJ8BlBBBbOf0Jrw9+bG1k44XqCXAXAcSWnm6hXhCx RVe9rJ4AZxFAbC6Yb/8291LrHPUEOIoAYjNBHPzd1o9tRqknwE0EEH9KG1ZfPSEm 2c+Fc1wHUSKA2KjJQx7d9qqgxjWZqZ4ABxFAbBDc0Y8tLez4mnoC3EMAsV7aqACP fmxpSNiFR2EQQOQ5/UP1ggRMPHOpegIcQwCR62Eb9w2Y23q4egLcQgARwJ1f8itj 4I3qCXAKAUSd4UFd+7Zz7124Sj0BDiGA5pn4+m+TcQ3T1RPgDgJo3e23qBckbGaT ceoJcAYBNO5tPx97VBSLrxuingBXEEDT7Bz+2Fz6gG7qCXAEAbQsbaKhwx+be+1C 9QK4gQAaZurw75bearRaPQEuIIB2HWP5YMAX/5ehngAHEECzjJ3+sjUKiBQCaJe5 01+29uOlE9QTIEcAjTLfPwqIFAJoFf3L9cOlE9UTIEYATaJ/61FA8wigRfRvAwpo HQE0iP79adqlk9QToEQA7aF/m6GAthFAc+jfFiigaQTQGvq3lWlNvlJPgAwBNIb+ beP7SymgWQTQlo6Pqhc46NsLp6snQIQAmmL6/gc7NvK8LPUEaBBAS+jfDow8d5l6 AiQIoCFpPBd8R945R70AEgTQDrP3f86PZ5qrF0CBANrxE/3biUeuVi+AAAE041OL zz/Kv8XXPqOegOQRQCuebqFe4LhZl3+snoDEEUAjuvVVL3De5Eu/VU9A0gigDZwA kw/DL+RkGGsIoAlp31dTT/DBC03UC5AwAmgCB4Dz54Eu6gVIFgG0gAPA+bSoy1D1 BCSKABrAAZB8+/ay79QTkCQCGD4OgBTAhxctV09Agghg8LgCrkD+e5V6ARJEAIM3 vr56gVfSu/5PPQHJIYChu+d69QLPTG3JVwZ2EMDA8QVggQ27mK8BzSCAYeMLwEJ4 +Br1AiSFAIbt7bPVCzw0t+Pb6glICAEMGs9AKpRxjWarJyAZBDBk3AO/kLg/tBUE MGScAVNI6dc+rZ6ARBDAgPELcKGNvYRfgk0ggOHiF+AiGNxSvQBJIIDh4hfgIlja mUeEWEAAg8UvwEUyttEc9QTEjwCGil+Ai+ip1uoFiB8BDBU3QS2ihVe9qp6A2BHA QDV5Tr3Ae59duEQ9AXEjgIFaxFOQiuy+69QLEDcCGCYegx6Baa3HqCcgZgQwSEd8 pV4QhFcarVNPQLwIYJCmHKxeEIRl1w5ST0C8CGCIOAISkZEXcRwkbAQwRBwBiUq/ ruoFiBUBDBCPAYnMty34NjVoBDA8XAMSoYHt1QsQJwIYHm6DH6HZ7T5UT0CMCGBw OAUmUi824VSYgBHA4HARcKTmd3hTPQHxIYChOZ1f2aL1RpNV6gmIDQEMDedAR2zZ NTwfJFwEMDCcAx259y7LVE9AXAhgYPgAGLllnYaoJyAuBDAsfACMwbtN+QgYKgIY Fj4AxoCPgOEigEHhA2As+AgYLAIYFD4AxmLZVTwjM1AEMCScAxiTV5tyLmCYCGBI uAgkJvOueEc9AbEggAHhKuDYPNtMvQCxIIABGXaGekGw5rV/Vz0BcSCA4aiQpV4Q sIevUS9AHAhgOAZw7874TG41Xj0BMSCA4eBJIHG6vYd6AWJAAIPRra96QdBGNp+j noDoEcBgcBJ0rLI6DlVPQPQIYCg4CTpmL7XgZOjwEMBQcA5MzOa1e089AZEjgIHg HJjYPdhZvQCRI4CB4BBI7DgMEiACGIifaqsXhK/Nk+oFiBoBDAOXASdgcEv1AkSN AIbhlQvVCwyY0fZT9QREjACGgatAktCrt3oBIkYAg9DxUfUCEz5osUg9AdEigEHg JMBE/Nx2mHoCokUAg7BOPcCIO7qrFyBaBDAEnASYkBEt5qonIFIEMATj66sXGLGo 3ZvqCYgUAQxA1cXqBWY82km9AJEigAHgN+DEfNKS34GDQgADMLqBeoEZiy5/Sz0B USKAAeAYcHL63qJegCgRQP9xFnSC3mvJF64hIYD+4yzoBM1t85F6AiJEAP3HdcBJ 6n6HegEiRAC9d9wY9QJTBrdZq56A6BBA7/E89ERNaDFFPQHRIYDe43GYicps97J6 AqJDAH3HZSAJe+jf6gWIDgH0HSfBJOzdVvy/nHAQQN9xM/yEfd98vHoCIkMAfcfj 4JLW7Fn1AkSGAHqOrwATxwPSA0IAPcedYBL3ccuf1RMQFQLoOb4CTNz3zSaoJyAq BNBzfAWYvKZD1QsQFQLoN74CFHigi3oBokIA/dbkOfUCg15ps0w9AREhgH57qqV6 gUFfNf9OPQERIYB++/ov6gUGZbZ5TT0BESGAfuNu+Aq9eqsXICIE0Gt1p6kXmNS/ o3oBIkIAvcadECTeabVEPQHRIIBe4xiIBEdBgkEAvcYxEAmOggSDAHqN5yFp3Hi3 egGiQQB9xnUgIvddp16AaBBAnzV8T73AqGcvX6WegEgQQJ/dc716gVGjWsxST0Ak CKDPuBeWyNRmE9UTEAkC6DMOAotktn5dPQGRIIA+4yCwyg33qBcgEgTQZ1wJrNL3 FvUCRIIAeuy4MeoFZg26Yq16AqJAAD3GWTAyz7TjPJggEECPDWivXmDWuBbfqycg CgTQY9wKQWZS88nqCYgCAfTY6AbqBWbNv+xT9QREgQB6jNMAZTJav6GegCgQQI9x GqBO137qBYgCAfQYpwHq9LlVvQBRIID+4mZYQvdyH4ogEEB/cRqgECcChoEA+osA ChHAMBBAfzV5Tr3AsBcvX66egAgQQH9xIYjQuOY8kjkEBNBfXAgixKUgYSCA/iKA QgQwDATQX1wJJ8S1cGEggP7iSjihpZcNU09ABAigvwigEAEMAwH0FwEU4m4IYSCA /lq4p3qBZdffq16ACBBAf/EJUIhPgGEggP4igEJ8BxgGAugvAihEAMNAAP1FAIUI YBgIoL84EVqIE6HDQAD9xaVwQlwKFwYC6C8CKEQAw0AA/cXtsIS4HVYYCKC/uCGq EDdEDQMB9Be3xBfilvhhIID+IoBCBDAMBNBjPBdYh+cCh4EAeowA6hDAMBBAjy2q pl5gV9d+6gWIAgH0GNfCyXAzmEAQQI9xLZwMV8IFggB6jEtBZLgQJBAE0GP3XK9e YNaoFrPUExAFAugxTgSU4TTAQBBAjx03Rr3ArEFXrFVPQBQIoM84EVCl7y3qBYgE AfQZJwKq3HCPegEiQQB9xomAIpmtX1dPQCQIoM84D0aEs2BCQQB9xnkwIpwFEwoC 6DPOgxF59nLOggkDAfRZ1cXqBUbdd516AaJBAL3GYWCNG+9WL0A0CKDXOAwskdnm NfUERIMAeo3DwBJfNf9OPQHRIIBe6/ioeoFJ77Raop6AaBBAr9Xl4bQK/TuqFyAi BNBvXA2s0Ku3egEiQgD9xlEQAY6BhIMA+o2jIAIcAwkHAfRbk+fUCwx6pc0y9QRE hAD6jWtBBB7ool6AqBBAz/1UW73AnqZD1QsQFQLouVcuVC8w5/tmE9QTEBUC6DlO hU7cu6343iEYBNBzfAmYuAc7qxcgMgTQd3wJmLRmz6oXIDIE0Hd8CZiw75uPV09A ZAig7/gSMGF8BRgSAug7vgRM2EP/Vi9AdAig96YcrF5gSma7l9UTEB0C6L0B7dUL TJnQYop6AqJDAL133Bj1AlMGt1mrnoDoEED/8WSkJHW/Q70AESKA/ht2hnqBIXPb fKSegAgRQP9xIkyC3mvJUfeQEMAAcF/85PS9Rb0AUSKAARjdQL3AjEWXv6WegCgR wAB066teYMYnLeeqJyBKBDAAXAySmEc7qRcgUgQwBOPrqxcYsajdm+oJiBQBDAG/ AydkRAt+Aw4LAQwCx4GTcUd39QJEiwAGgXOhE/Fz22HqCYgWAQwC50In4oMWi9QT EC0CGAauB05Cr97qBYgYAQwDN8ZPwIy2n6onIGIEMAxHfKVeYMDgluoFiBoBDAQP h4tfmyfVCxA1AhgITgWM3cjmc9QTEDUCGIgKWeoFweOB6AEigKHgVMCYzWv3nnoC IkcAQ3H6h+oFgXupxSr1BESOAAZjxv7qBWFr/ZR6AaJHAIPBYZBYcQgkSAQwHBmV 1AtC9p9u6gWIAQEMB09Ij9HkVuPVExADAhgObgwdo/9epV6AOBDAgHx6snpBsOa3 f0c9AXEggAHhguDYPNtMvQCxIIAh+exE9YJAzb+Sp2GGiQCGhJOhY/JqU06CDhMB DMq0uuoFQcq++in1BMSDAAalyXPqBUF6t2mmegLiQQDD8uMB6gUByr6GGwGGigCG hY+AMeADYLgIYGCm11EvCE+7J9QLEBcCGBg+Akbuvcv4ABgsAhiamfupF4TmisfV CxAbAhgazgWM2BtNOAcwXAQwOF8doV4QlPRrnlVPQHwIYHC4IjhSLzZZp56A+BDA 8HBTmAgt6PCGegJiRADDU32BekFAnm6lXoA4EcAAvX22ekEwZrcfpp6AOBHAEE05 WL0gEMu6/E89AbEigCHibOiIfNg4Qz0BsSKAQeJUmEhkXPOMegLiRQCD1PA99YIg vNM4Rz0B8SKAYRrdQL0gAIs6vaSegJgRwDA1GK1eEIDXGv+qnoCYEcBAfXCmeoH3 fu7wtnoC4kYAA7XXfPUC7w1poV6A2BHAUA1or17guR9a8zVC+AhgqFJ/qqqe4LdH O6kXIH4EMFjd+qoXeG1S06nqCYgfAQxWsan11BM8ln1Df/UEJIAAhuvMD9QLPPZu oxXqCUgAAQzYu/9UL/DW3I6cAmMCAQxYlRkV1RN89WQb9QIkggCG7Jbb1Qs89fVl U9QTkAgCGDTuClMomdcPUk9AMghg0PafoV7gpZcv4UFIRhDAsN1zvXqBh6a2HKee gIQQwLAVn3yQeoJ3sm9+RD0BSSGAgTvwB/UC77x6yVr1BCSFAIbutlvVCzwzuRlP lreDAAZvfH31Aq+kd+VBcIYQwODVmMLp0AUwtKl6ARJEAMPX9gn1Ao+MbTRHPQEJ IoAGvHKheoE35lzJ8/RMIYAGlPiurnqCL66/V70AiSKAFtT5qpx6gh9ebfS7egIS RQBNuHygeoEXxl/EF4DGEEAbhjRTL/DArMs/Vk9AwgigDcXGcTbgrmTc9Lh6ApJG AI2o/F0N9QTXDbpcvQCJI4BW1BtXXj3BbR+ct0Y9AYkjgGZcOlS9wG39bl2lnoDE EUA77rxRvcBlb7Rdqp6A5BFAQ169QL3AXWMvma2eAAECaEjxL49RT3DVT+d9q54A BQJoSflv9lVPcFPm+Z+qJ0CCAJpSe2KaeoKTrurPU5BsIoC2HMPjfrbjrh6cAWMU ATSm2RD1Avc80SVbPQEiBNCaHr3VC1zzantOgDGLAJrz2BXqBW75pOVc9QTIEEB7 Xv+XeoFLJjX+UT0BOgTQnuIjT1BPcMeMRpPUEyBEAA0qNf4w9QRX/NLoM/UEKBFA iypMrKOe4IbMJh+oJ0CKAJpUfQJ3B8y1osUr6gnQIoA27T+2inqCA27sxzOQjCOA Rh05kvuj3nczF4BYRwCtOv819QK1JzrnqCdAjQCa1fFR9QKtFzpkqCdAjgDaZfui uHfbLlRPgB4BNOz+zuoFOiNa8gx0EEDbJhytXqCyoDEnQCOFABr3+fHqBRpzmoxR T4ATCKBpxUaeqJ6gMPtS+of1CKBtu39+rHpC8uY1G6GeAEcQQONKjzN3Y4TFrd5V T4ArCKB1FSYcoJ6QrGVtX1ZPgDMIoHlVJ9ZST0jSiiueUU+AOwggao6vrp6QoB63 qxfAIQQQKQd8YefWMA9d95t6AhxCAJGScvioCuoJCXn8mtXqCXAJAUSu44ycF/fs lTwBGJsjgMjT+Hn1giS80o4bwGALBBDrXf2QekH83m/1i3oCHEMAsd5+M9UL4vfw NeoFcA0BxHoWbo/6Vpsl6glwDAHEeh+fpl4Qv9ktP1VPgGMIIPLsO0u9IAn9uqoX wDEEEHle/5d6QRK+bzFOPQFuIYDI1WC0ekEyHrua60CwOQKIlJTi3x6inpCM9FZv qSfAKQQQKSlDL1UvSMo3Lb5WT4BLCCBSLh+oXpCct1tzKgw2IYA4emSqekKCBnVa pZ4AdxBA8+qOtnMzrDwPdOVACDYigNbVGb2HekLC7r75d/UEuIIAGldvpLX+paT0 6/aregIcQQBt++sHldUTBPpfv0I9AW4ggKa1fUK9QOPFjkvVE+AEAmjZw53UC1RG tvxJPQEuIIB2lX7n7+oJOtObf6GeAAcQQLMOeL+OeoJSZp8HOR0GBNCqq+8op54g 9lJHLgoxjwDalPpyQ/UEvSktx6snQIwAmnTOgBrqCS7IeeA/OeoNkCKABpUa0kg9 wRVjW09RT4ASAbTnvEdqqSe4Y9mDd/Eh0DACaE25oeeqJ7hlYhtuEWgXATTmqp7V 1BOc0797hnoCRAigKUcNrK+e4KKfeg3l9gg2EUBDyg5qop7gqlFtflRPgAIBtKPT rfbufJV/D9+apZ6A5BFAK/7+wOHqCW6be+eg1eoNSBoBtKHG06erJ7jv6xuHrVNv QLIIoAVl771SPcEPw9rNUU9Aoghg+Ip3v6aqeoM3Bt6Urp6ABBHA4F1+S231BJ8s /S+XhhhCAAP3z3sOVU/wzew7/7dGvQEJIYBBO6HfceoJPpp62yucGG0DAQzYUfed qp7gq0ndP+DhwRYQwGDVe4B7nhbBFzd9RgLDRwADVed+bvpSRCNv/JLTAkNHAIO0 7/3nqyeE4OMbJpLAsBHAAFXrf5F6Qig+7PoNCQwZAQzOvn2aqieEZNhNX5HAcBHA wNS591/qCaEZ3pUEBosABqXevWerJ4RoxI3jSGCYCGBAjrjrLPWEUI3sNpoEhogA BuO4O05TTwjZmFtGcF5geAhgIE7rc7x6Qugm9HqXBIaGAAbh/O7HqCdY8PVdL5DA sBDAALS+jju+JGTaQ4+RwJAQQN8V73zV/uoNlswe0I87xYSDAPqtVPe2NdQbrPnl qdtWqDcgIgTQZxXvaJKm3mBR5os3c+P8MBBAf9XteZl6gl0v9J6qnoAIEEBfNbiN B11KDe8xWj0BRUYA/XRe92PVEzC275vqCSgiAuihYpd3PkS9AXmm3D+IK+S8RgC9 U6Jre55z6YzZA+75Tb0BhUcAPVPhtqY85dwpi4f0zFZvQGERQK/U7XF+qnoDtrb8 1d6z1BtQOATQIyf1/Id6Arbvg15fqCegMAigN5pcX189ATv25Z2vqyeg4AigH4r/ u+MB6g3YuakP91dPQEERQB+k3tqyunoDdm3uoP+sUW9AgRBA9+3T8+IK6g3In6XP 9chQb0ABEEDX1e/TUD0BBZD9Zh+uEvYHAXTbOd0aqCegoIb3GaGegHwigA4r1u7f XPLmpQn9nldPQL4QQGeVuqltLfUGFNaPjz7EVcIeIICOqtyHe536bf6TfVapN2BX CKCTDu7ZWD0BRZbx4i1L1BuwcwTQQaf0OlU9AdF4oe+36gnYGQLonMZdueQtIJ/0 +Vg9ATtGAN1S7Kqr66o3IFoT7npJPQE7QgBdUvKmdnurNyB6U+8fqJ6A7SOA7ih3 ezPudRqon/r3+129AdtBAF1Rq/fF5dUbEJ+Fg+7gceruIYBuOOSuc9QTELOlQ3ty owTXEEAXNOjzd/UEJCDrlVsWqDdgCwRQr2HP49QTkJDsd2+eqd6AzRBAtQu7H62e gCS93ne8egL+RAC1mt10qHoCkvZxj8/VE7ABAVRqfx1nPZs0qvdH6glYjwDKFLvy Wp5zZNbo3sPUE5BCAGWKdbxuP/UGKI3pRQL1CKBEsX93rq3eALUve72vnmAeAVTo 0JVPf8j1+a2fqCcYRwCT1/YmvvvDBiOu/k49wTQCmLTLenLkF5t5+9of1RMMI4DJ anjnEeoJcEz2m13nqzeYRQCT1OBenvKLbWU+3z1dvcEoApicuo+coZ4ARy164rbV 6g0mEcCklB9wqXoCHPZTv0fVEywigMko3rMTj/nFTn19y9vqCfYQwEQ068N5z9il D6/kXlkJI4AJOOqxY9UT4IXMwd2z1RtsIYCxKzvwMvUEeGNW30HqCaYQwLi1u31P 9QT4ZGTb6eoJhhDAeO3zAre7R8GkD+yxRr3BDAIYp2J9b1ZPgIe+bfeleoIVBDBG 9Qcfop4ALy1/9joeIpwIAhif+zurF8Bb37Ydp55gAgGMy15v87Q3FF76gO7r1BsM IIAxafZQZfUE+G14y3nqCeEjgLEoPripegK8N/2Kj9UTgkcA41D5I379RdGlP3ib ekLoCGAM6g2vqZ6AMAxtw12yYkUAo3fhU+XVExCK95stVU8IGgGMXKeH1QsQkJHN 5qonhIwARu3ae9ULEJRRTeeoJwSMAEbs6ofUCxCYkZdxOkxsCGC0znlLvQDBefey LPWEYBHASO07qZJ6AsIzqB0XhcSEAEap5HcHqicgQNldnlBPCBUBjNIb56kXIEgz 23FNSDwIYIQufkm9AIEadilPTo8FAYzO7tN59Bti0uN29YIwEcDo9OmuXoBgTWg+ VT0hSAQwMrvP20M9AeHqc6t6QZAIYGS4BAQx+rj5fPWEEBHAyHxzuHoBApbR4QX1 hBARwKjsN1O9AEEbdLl6QYgIYFRu5d6ViNPIFrPVEwJEAKPy9tnqBQjazJaj1BMC RACjMplnACNOyzs8q54QIAIYlaVp6gUI22091QsCRAAjUmqVegEC92Bn9YIAEcCI 7LlQvQCBe6yDekGACGBE+ASImD30b/WCABHAqHDLSsSrX1f1ggARwKhwEATx4iBI DAhgVMbXVy9A0NKveFk9IUAEMCpPt1AvQNC+azFJPSFABDAq7R5XL0DQ3m+xWD0h QAQwKqUXlVdPQMg4BhIHAhiZVy5UL0DAZrYdoZ4QIgIYmdN4cBfi82KL1eoJISKA 0Rn7V/UCBGvxFa+pJwSJAEbn2C/VCxCsZ1r/pp4QJAIYoecbqxcgUNNaj1FPCBMB jFDJb+uqJyBI2Z0HqScEigBGqfZXldQTEKKBV3CpeTwIYKQajFYvQIDebrpMPSFU BDBafx+uXoDgvN98iXpCsAhgxI55v4p6AsLycpvl6gnhIoBRqzm8nnoCArKs/818 /xcfAhi5EkM4GwZR+aEDFxjFiQDG4J8PHaCegCBkv3BDunpD2AhgHIp178L9oVFk o6/8Vj0hdAQwHmVvb0UCUSQTbntTPSF8BDAupbq22U+9Ad5aMeL+j9QbLCCAMTqv Q0P1BHhpzkv3zVdvsIEAxir1qkbHqDfAM7988tQH6g1mEMC4pbU541iuEEY+zfr0 xfc57y85BDABxc761wmHq0fAeUsmffLqNPUIYwhgQkqfe9qRh1ZQr4Cr5n819p3x 6hEGEcAkHXNG/QP/oh4Bxyz5Yeqo4XPVK4wigEkrdvTJRxy4bw31DDhg5dzZU8eN nKOeYRkB1Ej9W/2D99ubK+asypo7Z8Z3477+Xb3DPAIodeCRh+xfs/peXDRixi/z F/z843dfLVTvwB8IoAtSDz1ov1p77Vm1aqp6CeKxbPGiXxbMnjl5Bg/3dQsBdEql gw7YZ+8909IqVS6vnoKiy8zITF+68Oeffpieo56C7SOAjiq93/4196xWpVLlihUq lVOPQf4tz1yWkZm5ZPEvP0+f86t6DHaFAHqgxF619qpetUrlCuXLp5YrX1E9B1vK XJ6TvTw7K2Pp4oUL5ixcq56DgiCA/qm05x7VKleuVLF8+bKpZcuklk7lE2KCsnNW 5axckbNi+fKszIyMxYt+yVQvQhEQwBBUTEurXLlixXLly6WWLlu6TOlcpTiyXGRZ K1evXJX7PytXrsj7iLcsIz1jKbkLCwEMV2qVihUq5TYxtUyZ3CaWKVWqVMlSpcrU Vs9yzy8Za9aszrVqVV7scnJ/oV22LDN9OSfpGUAArSldvly5cqnlypYtk9vE3E+K uVUs9w/1qORM+WHt6jV5qcv9cLci94Nd7j+Wr+D2K2YRQKTceaN6QXKGt+HKM2xC AGEqgJ+0IoDYhAAi5f7O6gXJGdVilnoCHEIAkdKzl3pBcj5sPU89AQ4hgEgZ0ky9 IDmTmk5VT4BDCCBSPj1ZvSA5cxp/oZ4AhxBApPxk6dzAC19TL4BDCCCKm7p89aa7 1AvgEAKIw79RL0jSQ5057Rl/IoBoP0C9IEmvXp6hngB3EEA83Em9IEmft5ipngB3 EEC8+0/1giT9cOlE9QS4gwBi6kHqBUla1vRt9QS4gwCaV8zYbZ+69lMvgDsIoHnH jFMvSNYjnU2d9oOdIoDmdblPvSBZb16+WD0BziCA5j3VUr0gWeObTVNPgDMIoHmj G6gXJGtBs4/VE+AMAmje4qrqBQnr9Kh6AZxBAK2rM129IGl3G7oBNnaBAFp3ZX/1 gqS93J6L4bABAbRuUBv1gqSNbfajegJcQQCtG3OcekHSFjblKAg2IIDWZVVQL0jc NQ+rF8AVBNC4Y79UL0jeQ9dyLQj+QACNu+V29YLkPd1KvQCuIIDGvXGeekHyJh2t XgBXEEDjTD0QaaMyq9QL4AgCaNte89ULFP71pnoBHEEAbbvqEfUChf4d1QvgCAJo 2wuXqBcojP+regEcQQBtm7mfeoEEXwLiDwTQtFpz1As0Ln1evQBuIICmdb1bvUDj mebqBXADATTN1hMxN5m1v3oB3EAATVtSRb1ApN4P6gVwAgG07NRP1AtUehi8AhDb QQAte+wK9QKVUSepF8AJBNCyaXXVC1Sy91yhngAXEEDD9p2lXqDT+in1AriAABrW q6d6gc4756gXwAUE0LCJR6kX6GTuuUY9AQ4ggHbZvBPMRi0HqxfAAQTQrp691AuU +B0YKQTQsklHqhcoLauZrZ4APQJo1oHGL4bo8oB6AfQIoFkPXqNeoDWxvnoB9Aig WbP2VS8QO3SKegHkCKBVDd9TL1D771XqBZAjgFa9ea56gdrCmr+rJ0CNABpVIUu9 QK/Nk+oFUCOARt1xs3qBHodBQABtKja7lnqCA07+TL0AYgTQplb89pfrtQvVCyBG AG2yfB+ETbIPXKieAC0CaNJJI9UL3DCwvXoBtAigSSO5I/x6mXXS1RMgRQAtqj9e vcAVj1ytXgApAmjRR/9QL3DF0gMz1BOgRAAN4gPgJo+bfTAe8hBAg/gGcJPMgzkQ bBkBtOeUEeoFLhnaVL0AQgTQnvFcAbaZnL9OVU+ADgE057Jn1QvcMoovBAwjgNYU m76/eoJjLnlJvQAyBNCaHr3VC1zzw0Hr1BOgQgCNSZtRST3BOXfdpF4AFQJozDv/ p17gnqVHzVVPgAgBtIUngWzPyFPUCyBCAE3ZfRpHQLanY3/1AmgQQFMGcPun7fr5 MB6RYhMBtISLgHfk/X+qF0CCABpSfPJB6gnO4pdgmwigIfwCvGPzj1ysngABAmgH N0HYGa6IM4kAmlF62j7qCU67o7t6AZJHAM14+2z1Ardlnj5BPQGJI4BWdHxUvcB1 Px6drZ6ApBFAI+p8VU49wXnDT1cvQNIIoA2lvjtAPcED/bqqFyBhBNCG989SL/BB 1kXD1ROQLAJown+44VO+zD1xjnoCEkUALTjnLfUCX3x97Br1BCSJABpQ8+sq6gne +PBM9QIkiQCGr/Q3B6oneKR/R/UCJIgABq/YyBPVE3ySfe1A9QQkhwAG76WL1Qv8 ktH8HfUEJIYAhu7+zuoFvll4DtfEmUEAA9f5fvUC/8w6lZNhrCCAYTv3TfUCH00+ KUM9AckggEE75HOeAlwYE09aoZ6ARBDAkO07tpp6gqfGnPi7egKSQAADVn1CDfUE b404Tb0ASSCA4ao8YT/1BI/xnDgTCGCwUifUU0/w2usXqBcgfgQwVKW/OEI9wXND m6oXIHYEMFClxxypnuC9e25QL0DcCGCYSn5+jHpCAChg8AhgkOhfNP7TTb0A8SKA ISox8jj1hEBQwMARwACV/JT+RYXnJIWNAIaH33+jdN916gWIEQEMTulR9dUTgvL8 peoFiA8BDA3nv0TtjfPVCxAbAhiY1NF/UU8IzjvnqBcgLgQwLOXHHKqeEKAPGqoX ICYEMCgVvzhIPSFIH52hXoB4EMCQVP6SB2DGg7tjBYoABqTKOO5/FZdRJ69TT0AM CGA49vyytnpCwD4/7Vf1BESPAAaj5uh91BOC9sXJFDA8BDAUNb+sqZ4QuLGnrFJP QNQIYCD2+WIv9YTgjT81Rz0BESOAYdj/8+rqCQZMPCVbPQHRIoBBqDN6D/UEEyad TAHDQgBDQP+SQgEDQwADQP+SQwHDQgD9R/+SNPH41eoJiA4B9F6tsRz/SNIXx3NN SDgIoO+qTailnmDMyFPUCxAZAui5ihPqqCeYM+ws9QJEhQD6LXXsIeoJBr35L/UC RIQAeq3kF0epJ5g0sL16AaJBAH1WbMTJ6glGXTlAvQCRIIA+e76xeoFVmc3eUU9A FAigx+66Qb3ArkX/nKiegAgQQH+1fUK9wLLZJ81VT0DREUBv/XWseoFtk4/iBqn+ I4C+qv5NNfUE43hUXAAIoKdKfMUJgGr3XadegKIigJ56+2z1Aiw/+zP1BBQRAfRT 5/vVC5CSMveopeoJKBoC6KV636sXIM/nJ6oXoGgIoI9KTDlAPQHr3d5DvQBFQgB9 9GIj9QL8IfOEKeoJKAoC6KFGL6oXYKNv/6JegKIggP4pO51HALvj7hvVC1AEBNA/ r52vXoBNso6eqZ6AwiOA3mn4nnoBNjfmePUCFB4B9E3xaRwBdkuHx9QLUGgE0Dd9 u6kXYEs/11mjnoDCIoCeqTKrvHoCtvJAF/UCFBYB9Myb56oXYGuZhyxQT0AhEUC/ HDdGvQDbGtpUvQCFRAD98hkXnzoo52DuDu0pAuiVE0apF2B7nrtMvQCFQwC9wgdA N/ER0FcE0Cd8AHTV85eqF6BQCKBP+ADoqpwDORDsJQLokWPGqRdgRx7tpF6AwiCA HuE2gO5aXOM39QQUAgH0R/kFqeoJ2KEuD6gXoBAIoD/u5M5zDpvKY0p9RAC9UWzO 3uoJ2Il/vq9egIIjgN5o+ZR6AXbmlYvVC1BwBNAbnAPjtsw9flVPQIERQF+k8Qxu x7UfqF6AAiOAvujWV70AO/fRGeoFKDAC6ItJR6oXYBcqLlMvQEERQE/sx7PHnHfT XeoFKCgC6Il7rlcvwK6MPEW9AAVFAD3xzeHqBdiV7Kqr1RNQQATQD1UXqxdg15o/ o16AAiKAfvg3V5p64MXG6gUoIALoh3f+T70Au7aghnoBCogAeqHY0srqCciHv41V L0DBEEAvnPmBegHyo3cv9QIUDAH0wr3XqhcgPz5oqF6AgiGAXhh5knoB8mPRnuoF KBgC6INi6ZXUE5Avf/lWvQAFQgB9wOMwfdHtP+oFKBAC6IO+3dQLkD+vXqRegAIh gD7gLEBfTD5MvQAFQgB9MHM/9QLk026/qxegIAigB0qvVC9Afp0wWr0ABUEAPXAW zxvzBvcE9AsB9MBtt6oXIL+ev1S9AAVBAD3w6gXqBcivLxqoF6AgCKAHJhytXoD8 WriXegEKggB6YHFV9QLkW+oK9QIUAAF0X6UM9QLk34mfqxegAAig+zgI7JPOD6oX oAAIoPtu4MwKjzzaSb0ABUAA3fd4O/UC5N/rHLL3CQF039tnqxcg/8Ycr16AAiCA 7ht3jHoB8m/GAeoFKAAC6L6faqsXIP+yy6sXoAAIoPvWqQegIKotUS9A/hFA5+01 X70ABcGjMX1CAJ130kj1AhREkxfUC5B/BNB5zYaoF6AgrrtPvQD5RwCdx3nQfrnr JvUC5B8BjN5ue5Srd2jGokWLl2ZGcX/0ftdF8EOQmCfbRPWTdktL22PPPcp9NX35 Eg6ExYQARqj0UafXql659LqUYrU2PiB7eU7O8uVZmUuXLl68cHF6xtpC/NTBzaPc iLi9cX5h/5O7VU6rtle1alWqVKpYoVxqarkN//K8ebnv0pVL508f9j0PHIkaAYzG wSccVa9urV3/fdkbg7hk0S+L0jN/zcePfuucIq9Dgj7+R37/zrzgVd+jal7wypcv 92fwdmLq9CnjP19QlHXYEgEssopnnHrEYZUK+R/OXrF8ycKFk35akpm9Ys2a7f6i 88mphd+G5I39247/vZIly5SrWGXfo/aqXq18amHPmJ7/9fgPx/xWyP8wtkQAi6T4 eeedeGDRf8yy7OVZS5fM/2RWzspVv/62PoPF/owhV8L5ZatHA2/4L3L3EqXKlK19 cq1qVXM/7RX2/11usmzyiJcmFfmngAAWwb6XnV6/QpQ/cOaczMkzflmSmbP6993X ZG0s4NSDovwzELfZ+27xv5Yr83tKybIVqu5R5/CK+9SL8g+a9/kbr3P76SIigIVU sn3zY2P4sTkrcrLSM39ML5FT5rflOXMyVq78dSJPmfBKepXcv5QqW6ZMmcq1UiuU LLtuRYU6ldMqliv0r7w7sXj4wI+j/6mWEMBCObf13yvG+fMz11Ve/09ZWVkrz4zz D0L0WpUpX6Vq5UoVK1Za/yyXZWtL5OPwRqHNfPXhOTH++NARwIIrfk2HuuoNcFdO arJ/3rJPb/062T8xIASwwG64em/1BGALH97wlXqCpwhgAbXvxt354J63rp2unuAl Algghz5dXz0B2J4lz/RYrt7gIQJYEI9cpV4A7MjkDp+pJ/iHAOZfvdc5Iw8OWza4 6yr1Bt8QwHy74Ik09QRgp4a34ZSYgiGA+dWrp3oBsCuT249WT/ALAcynyunqBcCu LWz3tnqCVwhg/hw8Rb0AyJc7b1Yv8AkBzJczP1AvAPLpnQvyc5tJrEcA86N3D/UC IN+mnM49U/OLAO5aiUHclB4+WXzSNPUEXxDAXSrxv2bqCUCBLD2BAuYPAdwVPv/B PxQwnwjgLtA/+IgC5g8B3IXH26kXAIWw5Mh56gk+IIA7lfZoY14heGneZSPVEzzA 23un7rlevQAopGWVeY76LhHAnfnXY9XVE4DC+qKBeoH7COBO7PPsieoJQOHdfKd6 gfMI4E70v1K9ACiKvTkQsgsEcMca9a+ingAUxddHqhe4jgDuUO2hx6snAEVzax/1 AscRwB0a0F69ACiidQfOUE9wGwHckQsGVFNPAIpqwjHqBW4jgDtQeWhD9QSg6Bq9 rF7gNAK4Az16qxcAEVhYY516gssI4PYdPIQnoCMID3RRL3AZAdy+B/6tXgBEo3Km eoHDCOB2nTGolnoCEI2P/6Fe4DACuF2cAoNw1OZp6TtEALen0WNp6glAVL47XL3A XQRwO1KHnqeeAESnIU913RECuB233K5eAERoQU1OhdkBAritWs+crJ4ARKnLA+oF riKA2+rZS70AiNTi6twcevsI4DZqP3uCegIQrRvvVi9wFAHcxs13qBcAEZtXi28B t4sAbi3t6XPUE4CotXpavcBNBHBr5wzkQUgIzti/qRe4iQBu7bEr1AuA6O0/S73A SQRwK4c9fbR6AhC9/h3VC5xEALfS7zr1AiAOvNW3h1dlS3976iD1BCAOzzRXL3AR AdxS17t4RRCkufuoF7iIt/uW7rpBvQCIB+/17eBF2dKD16gXAPGolKVe4CACuIVT /re/egIQj9cvUC9wEAHcwg13qRcAMZm3t3qBgwjgFu68Ub0AiAtv9m3xmmzh/s7q BUBcyuWoF7iHAG7u8MFHqicAcflfW/UC9xDAzTV6vJJ6AhCXb/+iXuAeAri5225V LwBik1NOvcA9BHBz91yvXgDEh3f7NnhJNtf/SvUCID48IX0bBHAzfx3MnRAQsFcv Ui9wDgHcTLPHy6gnAPGZU1u9wDkEcDN9uqsXADFaV1y9wDkEcDPcCgZh4+2+NV6R zXAdCMJWYbl6gWsI4CZHDjlMPQGI09Cm6gWuIYCbNH28rHoCEKfpB6oXuIYAbsJ1 IAjcilT1AtcQwE04BoLQ8X7fCi/IJlwIh9Dt9rt6gWMI4J/2H3yCegIQr7u54++W COCf/m9QdfUEIF6jTlIvcAwB/BPPA0HwFu6lXuAYAvgnLoRD+HjDb4nX408cA0H4 OAqyJQK40W5PtFJPAOL2t7HqBW4hgBvVH3KwegIQt5cuUS9wCwHc6OInKqonAHH7 7nD1ArcQwI1uvU29AIhdZmX1ArcQwI3uuFm9AIgf7/gt8HJs9N8O6gVA/Pb7Sb3A KQRwg7SnzlVPAOLX5kn1AqcQwA1OGsIDY2DA8NPVC5xCADdoOpAnwsGAmXXUC5xC ADfo3UO9AEhAdnn1AqcQwA3aPswnQBgw4wD1AqcQwA169VQvABLAJ8AtEMAN7uRO kTCBt/zmeDU2IICwgbf85ng1/rDP06eqJwBJ6N1LvcAlBPAPRwz+i3oCkIRnm6kX uIQA/uHUZ2qqJwBJ4LEgmyOAf+A8aBgxdx/1ApcQwD/cfot6AZAM3vOb4cX4AweB YQXv+c3wYvyBAMIK3vOb4cVYr9ZTf1dPAJLRk3ufb0IA1zts8FHqCUAynmqtXuAQ ArjeCUP2U08AkvHhmeoFDiGA6100iEfCwYjJh6kXOIQArtetr3oBkJD0KuoFDiGA 6/FIONjBm34TXov1OAsGdvCm34TXIk/VJ89RTwCS0uEx9QJ3EMA8+w8+QT0BSEq/ ruoF7iCAeY4acqh6ApCUFxurF7iDAOY55Zm91ROApHx2snqBOwhgnsZPlFNPAJLy Qz31AncQwDy3cnUk7FheQb3AHQQwD6cBwhLe9X/ipchDAGEJ7/o/8VLkqvLkueoJ QHLaD1QvcAYBzLXf0zwnBobcdZN6gTMIYArPxIQxQ5uqFziDAOY6e9Ce6glAcsYc r17gDAKYq8u9vAwwZPa+6gXO4J2fq2cv9QIgQStS1QucQQBz9e2mXgAkibf9RrwS KZwGCGt422/EK5FCAGENb/uNeCVSUvZ+mocCwxQeDbwRAeRugDDnpUvUC1xBAFNS zvlfNfUEIElj/6Ze4AoCmJLS5T71AiBRs/dVL3AFAeRugDAnu7x6gSsIYErK7beo FwDJ4n2/AS8E50HDHt73G/BCpKT06a5eACSL9/0GvBB8AoQ9vO834IVI2ePJ/1NP AJLV+UH1AkcQwJS6Q45VTwCS9d+r1AscQQBT/vbMAeoJQLLePVu9wBEEMOX8/1VW TwCS9c0R6gWOIIApN9+hXgAkLL2KeoEjCCBnwcAg3vh/4HXgLBgYxBv/D7wO1Z9s qJ4AJO36e9UL3EAADxr8V/UEIGmPX6Fe4AYCmHLYNTX33jtNvQJIys9z587ge58/ EMAN6p13QO29a1ZSzwDiM3/u3JlTn1KvcAoB3NIh59apXZMOIizz5/486/tB6hUu IoDbdcg5dfapwe/F8N3PeeV7Ur3CYQRwp05tUqPG3nuqVwAFlL1gwc+zuNHvrhHA /Dj+gr33rl6jrHoGsCuL58+fO+Nu9Qp/EMACOOrMfWvWqLGXegawjayFC+fP+ZGv +QqKABbCsQ33qVl9L34zht7yXxYumDPzv+oZ3iKARXDsWTVr7Fltj1T1DtizeNEv C3/+qb96hvcIYBROO2uv6tWqV+fFRMwyFi9aNH/OPeoZ4eA9G6nTz6q2xx5p1cqp dyAsixYvXbTw57vUMwJEAOPR4OTqe1atklaVFKLQFi1dunTRgrlPqHeEjADGrUGD PapXS0tLq6oeAi8sy0jPWLJowbyn1UNsIIAJOuW4qtXSKleqWJnPhdjCkvTMrPQl i+cPVA8xhwCKnHZs1SqVKleoWIl7k9u0LCtrWWbm0iULH1cvMY0AuuCs+pUrp1Uo X75chYrqKYjNimXZy5cvy0xPX8xpe84ggO4567BKlSpVKFe+XGp5nlfns+XLc7Jz m5eV2zx+t3UUAXTfuYeVr1ihXLnU1LJly3KjLndlZ69ckbMiN3lZWRmPqscgfwig jy6sV7ZC+dwglilbukzZsmXUcyzKylm5asXKFStycn+rzSJ33iKAAbhwv9TyuTUs UzpXqVKly5Tnv9WIZa9ctXr1qlWrV+ZWL/cjXvZj6kGICG+VgDWumfcJsUxuFHOz WLJUyZIlS3MCzo7lrFqTa3WeVatX5X7Cy1nBtbahI4BGXbxH6dJl8j4w5oWxRKkS JUvk2r1EqXBverhiza+5flvz65pfV/+aG7o1uZVbtXLlCu6XbBkBxI40rlimVG4Z S5XIq+PuJXffrUSJ3XYvkftPu63/x+4ufPe4cu2va/P+sSb3r7+t/fXXtbmB+y03 cb+uzs3c6lUruZ4CO0UAEZXWpUoXL5VSbLfdcv+Parfdc/9SfPfif/w76/78e/78 v7d1W/8L2/H7b7/n/o2/rc39y9q161JW/75qLaeTIFIEEIBZBBCAWQQQgFkEEIBZ BBCAWQQQgFkEEIBZBBCAWQQQgFkEEIBZBBCAWQQQgFkEEIBZBBCAWQQQgFkEEIBZ BBCAWQQQgFkEEIBZBBCAWQQQgFkEEIBZBBCAWQQQgFkEEIBZBBCAWQQQgFkEEIBZ BBCAWQQQgFkEEIBZBBCAWQQQgFkEEIBZBBCAWQQQgFkEEIBZBBCAWQQQgFkEEIBZ BBCAWQQQgFkEEIBZBBCAWQQQgFkEEIBZBBCAWQQQgFkEEIBZBBCAWQQQgFkEEIBZ BBCAWQQQgFkEEIBZBBCAWQQQgFkEEIBZBBCAWQQQgFkEEIBZBBCAWQQQgFkEEIBZ BBCAWQQQgFkEEIBZBBCAWQQQgFkEEIBZBBCAWQQQgFkEEIBZBBCAWQQQgFkEEIBZ BBCAWQQQgFkEEIBZBBCAWQQQgFkEEIBZBBCAWQQQgFkEEIBZBBCAWQQQgFkEEIBZ BBCAWQQQgFkEEIBZBBCAWQQQgFkEEIBZBBCAWQQQgFkEEIBZBBCAWQQQgFkEEIBZ BBCAWQQQgFkEEIBZBBCAWQQQgFkEEIBZBBCAWQQQgFkEEIBZBBCAWQQQgFkEEIBZ BBCAWQQQgFkEEIBZBBCAWQQQgFkEEIBZBBCAWQQQgFkEEIBZBBCAWQQQgFn/D0mQ GKZW59+EAAAAAElFTkSuQmCC"/></symbol><g mask="url(#b)"><g transform="rotate(.193) scale(.36014)"><symbol id="c" viewBox="0 0 1280 1280"><image width="1280" height="1280" xlink:href="data:image/png;base64, iVBORw0KGgoAAAANSUhEUgAABQAAAAUACAIAAACXhmigAAAACXBIWXMAAA7EAAAO xAGVKw4bAACylElEQVR4nOzdi3dc1WHof1mS9bSMeZiYtNRNCaFNAvySxpfmUqdN 6kBKkybkSYFSei9r3ZW/9t4ATsDS6GlZr5E0b817fkdWSii25Rl59pkzcz6flUUJ Hu2z09ixvt777H1uDAAAAFLg3KAnAAAAAHEQwAAAAKSCAAYAACAVBDAAAACpIIAB AABIBQEMAABAKghgAAAAUkEAAwAAkAoCGAAAgFQQwAAAAKSCAAYAACAVBDAAAACp IIABAABIBQEMAABAKghgAAAAUkEAAwAAkAoCGAAAgFQQwAAAAKSCAAYAACAVBDAA AACpIIABAABIBQEMAABAKghgAAAAUkEAAwAAkAoCGAAAgFQQwAAAAKSCAAYAACAV BDAAAACpIIABAABIBQEMAABAKghgAAAAUkEAAwAAkAoCGAAAgFQQwAAAAKSCAAYA ACAVBDAAAACpIIABAABIBQEMAABAKghgAAAAUkEAAwAAkAoCGAAAgFQQwAAAAKSC AAYAACAVBDAAAACpIIABAABIBQEMAABAKghgAAAAUkEAAwAAkAoCGAAAgFQQwAAA AKSCAAYAACAVBDAAAACpIIABAABIBQEMAABAKghgAAAAUkEAAwAAkAoCGAAAgFQQ wAAAAKSCAAYAACAVBDAAAACpIIABAABIBQEMAABAKghgAAAAUkEAAwAAkAoCGAAA gFQQwAAAAKSCAAYAACAVBDAAAACpIIABAABIBQEMAABAKghgAAAAUkEAAwAAkAoC GAAAgFQQwAAAAKSCAAYAACAVBDAAAACpIIABAABIBQEMAABAKghgAAAAUkEAAwAA kAoCGAAAgFQQwAAAAKSCAAYAACAVBDAAAACpIIABAABIBQEMAABAKghgAAAAUkEA AwAAkAoCGAAAgFQQwAAAAKSCAAYAACAVBDAAAACpIIABAABIBQEMAABAKghgAAAA UkEAAwAAkAoCGAAAgFQQwAAAAKSCAAYAACAVBDAAAACpIIABAABIBQEMAABAKghg AAAAUkEAAwAAkAoCGAAAgFQQwAAAAKSCAAYAACAVBDAAAACpIIABAABIBQEMAABA KghgAAAAUkEAAwAAkAoCGAAAgFQQwAAAAKSCAAYAACAVBDAAAACpIIABAABIBQEM AABAKghgAAAAUkEAAwAAkAoCGAAAgFQQwAAAAKSCAAYAACAVBDAAAACpIIABAABI BQEMAABAKghgAAAAUkEAAwAAkAoCGAAAgFQQwAAAAKSCAAYAACAVBDAAAACpIIAB AABIBQEMAABAKghgAAAAUkEAAwAAkAoCGAAAgFQQwAAAAKSCAAYAACAVBDAAAACp IIABAABIBQEMAABAKghgAAAAUkEAAwAAkAoCGAAAgFQQwAAAAKSCAAYAACAVBDAA AACpIIABAABIBQEMAABAKghgAAAAUkEAAwAAkAoCGAAAgFQQwAAAAKSCAAYAACAV BDAAAACpIIABAABIBQEMAABAKghgAAAAUkEAAwAAkAoCGAAAgFQQwAAAAKSCAAYA ACAVBDAAAACpIIABAABIBQEMAABAKghgAAAAUkEAAwAAkAoCGAAAgFQQwAAAAKSC AAYAACAVBDAAAACpIIABAABIBQEMAABAKghgAAAAUkEAAwAAkAoCGAAAgFQQwAAA AKSCAAYAACAVBDAAAACpIIABAABIBQEMAABAKghgAAAAUkEAAwAAkAoCGAAAgFQQ wAAAAKSCAAYAACAVBDAAAACpIIABAABIBQEMAABAKghgAAAAUkEAAwAAkAoCGAAA gFQQwAAAAKSCAAYAACAVBDAAAACpIIABAABIBQEMAABAKghgAAAAUkEAAwAAkAoC GAAAgFQQwAAAAKSCAAYAACAVBDAAAACpIIABAABIBQEMAABAKghgAAAAUkEAAwAA kAoCGAAAgFQQwAAAAKSCAAYAACAVBDAAAACpIIABAABIBQEMAABAKghgAAAAUkEA AwAAkAoCGAAAgFQQwAAAAKSCAAYAACAVBDAAAACpIIABAABIBQEMAABAKghgAAAA UkEAAwAAkAoCGAAAgFQQwAAAAKSCAAYAACAVBDAAAACpIIABAABIBQEMAABAKghg AAAAUkEAAwAAkAoCGAAAgFQQwAAAAKSCAAYAACAVBDAAAACpIIABAABIBQEMAABA KghgAAAAUkEAAwAAkAoCGAAAgFQQwAAAAKSCAAYAACAVBDAAAACpIIABAABIBQEM AABAKghgAAAAUkEAAwAAkAoCGAAAgFQQwAAAAKSCAAYAACAVBDAAAACpIIABAABI BQEMAABAKghgAAAAUkEAAwAAkAoCGAAAgFQQwAAAAKSCAAYAACAVBDAAAACpIIAB AABIBQEMAABAKghgAAAAUkEAAwAAkAoCGAAAgFQQwAAAAKSCAAYAACAVBDAAAACp IIABAABIBQEMAABAKghgAAAAUkEAAwAAkAoCGAAAgFQQwAAAAKSCAAYAACAVBDAA AACpIIABAABIBQEMAABAKghgAAAAUkEAAwAAkAoCGAAAgFQQwAAAAKSCAAYAACAV BDAAAACpIIABoM9m5+Y+//tr57/+5gv/8KhSiW9OAIAABoBezc3NjX2WtZ1j0f89 Nz7+2GOPnWG06MsLhUKn3T4e5Nzd35fP/fF3Z4UMAP0lgAHg/k4Wck9CN8rU8XPn Lp4pcR9F9NxiodDudM79VxVH/+jo6CjmaQDAaBDAAPBHc3Nzx7l7d1F3fHw8/tzt RjS3fD4/dpLEd6vYQjEAdEkAA5BeJ8UbJWX02+Fjly4NejpndLyJOp/v/NcOaj0M AA8igAFIkdnZ2eNV004n+uvZXtlNvpNd0527/xnH9DAAfI4ABmDE/Sl6h3mZ92xO FoeP/04MA4AABmAkzd49qDmd0fsgn4/h6O+rTtICIH0EMACj46R7o9/bknl+VXIc b5MuFk8ucLIsDEB6CGAAht5x91rsPZPPLwsrYQBGngAGYFiddO+5QVzPO3pOblc6 /rZACQMwugQwAENG9wb1xzVhh2YBMIoEMADD4bNzrexzjsdxCRcKJ3+vhAEYDQIY gESbmJiYmp6O/mZUr+1Nvj9eLDw21qjXm83moKcDAGcngAFIKFudE8VxWQCMAAEM QLJY8k04C8IADC8BDEBSWPIdIp+dlVWv1Vqt1qCnAwBdEcAADF6UvuPnzi1cvDjo idCzKIOjGLYvGoChIIABGKQofaPfiiz5DrvjfdHFYvRXGQxAkglgAAbjZMOzO41G yWevB8tgAJJJAAMQN+k72mQwAIklgAGIj/RNDxkMQAIJYADiIH3TSQYDkCgCGICw pC8yGICEEMAAhOKEZz6v3W6XS6W2k6IBGBwBDED/SV8epNPplIrFarXaarUGPRcA UkcAA9BPk5OT09PTCxcvDnoiJFoulzt37pylYABiJoAB6BsLv2N3Vzi7/3AUgeFm knz5fH7Mi8EAxCjVv+8C0C/HJ12NjT2WpvQtFYsnqX/56aejvz55+fLMzEz0N197 4YUHfUmj0chms9Vq9eTfRqm8tbkZRXC9Xi8VCtE/yedy0V8r5XJ6/hDh+HysYrFm RzQAsRDAADySlOx5brXbc3Nzly5dOgndUyr3vo5ffC2V9vf3u1wfjj52Z3OzUa8X C4VyuVyr1Wamp8808eFgRzQA8RDAAJzdqO55Plndvfz001HuPn7p0rNXrz7KaM1m M5vNHh0dPcogURJnd3ejGI6SOJ/LRaNdHLk/dCjk865KAiAoAQzAWUxOTk5NTY1S +rba7ctPPfX4k09+5a/+6qnLl/s17MnCb7vd7teAJ6IejjJ4b3e3VDh2svt6BJxc lVSr1ZrN5qDnAsAIEsAA9GxkFn7Hx8cvP/30nz377J/9+Z/Pz8/3d/BWqxWlb7lc 7u+w94piuFqt7u/tHezvF/L58+fPh35iaA7HAiAQAQxAD0bgsKtatfrMl7985c/+ 7LmvfrXv0fuZSqWSzWbjP9gpiuGjo6Odra3Dg4PDw8MLwf4DhnZyXbClYAD6SwAD 0K0oF4f3sKup6ekvXbnywl//dR+3N99Xu93e398vlUpBn9KNqCFzh4d3NjcLudz4 +Pigp3MW+VyuXq87IBqAfhHAADzc8L7xG3Xvs3/xF1//5jfDLfZ+3tHR0d7eXtKC LSrhSqVye319f29vYmJi0NPpzfHJWJ1Oo9GwFAzAoxPAADzEML7xG3P3jt1d+D04 OCgWi/E87myOS7hcvr2xMXQlHGVwvV7XwAA8IgEMwAMdL/xOTw/RdTvj4+Nfee65 OLv3RLVa3dvbG6I8OynhjfX1vZ2dqampQU+nK+4KBuDRCWAA7u/4vKtO57FLlwY9 kYerVat/8Zd/+eLLL4d+v/dex+/Z3hXzc/ul3W4fHhxsrK3tZ7MXLlwY9HQeIvr/ drFYrDsZC4CzEsAA3MewnHcVzfOFr3/9ay+8MJCn1+v1vb296K8DeXp/tVqtzY2N O5ubyf/O4PhkrEajpYEB6F3yf5sDIFZDcd7VAJd8T5wsRR4cHER/M5AJBPLHBeHV 1ez+/kKCF4SPT8ZyUTAAvRPAAPxJ8s+7OnnL99orrwxwDs1mM5vNHh0dDXAOoTUa jaVbt/Z2dqanpwc9lwcqFAq1ajVpZ24DkGQCGIA/mr9wYWFhYdCzeKCp6elvvvTS oHY7f6ZcLkf12263BzuNeERtubG2trmxMTk5Oei53F/+7unQtkMD0CUBDMDxtufp 6enEvvQ7Pz//3b//+0Htdv5MFL37+/ulUmmw04hf9B88u7eXWVwcP5fEbxucDg1A 95L4OxkAcYrq9/zU1GOJ3PackPQdG8KLjvouyRnc6XRKxWLVdmgAHiZxv4cBEKfE vvSbnPQd9ouO+uuPGXzr1vj4+KDn8kWFQsENSQCcTgADpFcyX/pNTvqO3T0Lam9v r1arDXoiyXKcwbu7x6vBCcvgfD7fqNc1MAAPIoABUiqBN/0mKn0jxWJxf39/xC46 6qMog/d2d5cTlsHHtwTX6/ZCA3BfAhggdRJ45FVUUP/f3/7twE94/szxCmc2Wy6X Bz2RIdBsNtdXVzfW12cSc2FS1MBjjsUC4H4EMEC6JO3Iq1q1+q1r1156+eVBT+RP arXa7u6ubbQ9aTQamVu3NtbWEvI++cmxWP4IA4AvEMAAKZKo+o365Lnnn//+jRuD nsifRNWUz+cPDw8HPZFhVT06uvnhh1EMn0vASdGOhgbgXoP//QmAeExMTExPTydk gW5qevoHN25cevzxQU/kT6JM2tvbOzo6GvREhlu73d7Z3s7cunX+/PlBz+WYo6EB +DwBDJAKybnuqFatfvf69eS87nuiUqlE9RvF26AnMiKi4FzJZFaXly8m4FVzDQzA ZwQwwOhLznVHl59++n9evz47OzvoifxJp9M5PDzM5/ODnsioOdmB/Onvf5+EHciF fL5WqyVhJgAMlgAGGHEJqd9Wu/29f/iHZ69eHfRE/ptms7m7u+ua33Ci5lxfW1te WrowPz/YmWhgAMYEMMBoS0j9Xn766X967bVBz+KLbHuOzVGl8tHvftcZ9P+rjxu4 Xm/ZCw2QYgIYYGQloX6TufBr23P8jpeCV1eXM5nBLgVrYICUE8AAoykJ9ZvMhV/b ngcoCUvBGhggzQQwwAgaeP3WqtUf/PCHSVv4HbPtOQFardZKJrO3szM+Pj6oOWhg gNQSwACjZuD1Oz8/f+NHP0rUUc9jd7c95+4a9EQ4tre7e+sPf5icnBzUBDQwQDoJ YICRMtj6LRWLL3/729deeWVQE3iQVqu1t7d3dHQ06InwJ7Vq9ZObN6P/Us6dG8x3 IxoYIIUEMMDoGGz9ttrtf/rhD68888ygJvAgtVptZ2fH/TcJFP2XsraysprJRD91 BzKBqIHr9XpTAwOkhgAGGBGDrd9kbnuOFAqF/f39Qc+C0xzu7//+448HtR1aAwOk igAGGAWzc3OPPfbYoJ7+leeee+W73x3U0x+k3W5H6VsqlQY9ER6uWq3+4eOP6wM6 mlsDA6SHAAYYehMTE9PT0xcHEcClYvH1N95I4GnPjUZjd3c3qppBT4RutVqtpVu3 cgcHA3l6sVCIItw+eYCRJ4ABhtsA67fVbv/8V79K4Lbno6OjqH7ddTSM7ty+/fub NxcG8UqwBgZIAwEMMMQmJyenpqYGUr+Jfek3n88fDGgVkb7Yz2Y/uXlzIK8ERw1c Lpfjfy4AsRHAAMMqKoTzU1MDefX38tNP/9Nrr8X/3NN56XdklEuljz/8cKzTifm5 nU6nVCxqYIARJoABhtWgDr5K5pFXzWZzZ2fHS78jo1qt/v6jjxqx/xcaNXChUDiq VGJ+LgDxEMAAQ2l+fn7h4sWYH5rYI6+iWIrq10u/I6bVai1++mn+8DDm5+ZzuXq9 7mVggJEkgAGGz6Dq98c/+9mVZ56J+bkPVSwWs9nsoGdBEANr4Hy+4WIkgFEkgAGG zEB2PifzwOdOp3N4eBi1yqAnQli319c/+f3vFxYW4nxoIZ+v1WrWgQFGjAAGGCYD ufQomfXbbrez2azzilJi686dmx9+GHcDFwo1FyMBjBYBDDA0jo99Pn/+sUuX4nxo MuvXkVcptLW5efOjj+JsYIdCA4weAQwwNOLf/Dw1Pf3PP/5x0uo36t7t7W3rcim0 t7Pz+48/npmZie2JDoUGGDECGGA4xH/wVfTEn7z5ZpxP7EalUtnd3e3EfkMsCZE7 PPzo//7fqenp2J7oUGiAUSKAAYZA/Gu/yaxfBz4TOchmP/7d76ZjXAd2IBbAyBDA AEkX/8FXyazfw8PDXC436FmQCFubm4uffBJnAxcLhaoDsQCGnwAGSLTjg6+mpuJc /k1g/XY6nf39/WKxOOiJkBSNen13ezuzuBhbA7fb7ehnoJeBAYadAAZItLn5+Ysx vvrbarffee+92B7XjSg8dnd3j46OBj0REuT4fOZCYT+bXbx1K7ZfIF4GBhgBAhgg uWJ+9TeBNx5FsbG9ve26I+5Vq1ajf+3u7q5kMrE1cCGfj342NpvNeB4HQN8JYICE ivnV3wTWb5QZUf02Go1BT4QkarfbpUIh+pvdnZ2V5eXYGtjLwABDTQADJFHMr/4m sH6j7t3a2pIZnOKoXD7585E4G9jLwABDTQADJFGct/6WisUf/+xnV555Jp7HdaNW q21vb0elMeiJkGitZrNcKo3d3Sq/vrZWjetF8Xw+X3crEsBwEsAAiRPnq78JrN9q tbqzs6N+6Ua5WDwJ0eiva6urtWo1nucWCoXjm4G9DAwwbAQwQLJMTk5OTU3F9urv 11988aWXX47nWd2oVCq7u7udTmfQE2E4NOr1z3Yj12u1leXl2P7oJJ/LOZwcYOgI YIBkifPeo68899wr3/1uPM/qRrlcjup30LNgmJzch/TZn5hUq9WVTCaeR7sVCWAY CWCABIlz8/P8/PxP3nwznmd1o1Qq7e3tDXoWDJ/q0VG9Vvvs3+bz+eWlpZmZmRge bSM0wNARwABJEefm5/Hx8V+//XYMD+qS+uXMPrsP6TMH+/uZpaULFy7E8HQboQGG iwAGSIrYNj8n7dIj9csjqpTLzf9+X/TO9vbqykoMv6BshAYYLgIYIBFi2/yctGOf 1S+PLqrfqIE//0/iPBS6UCjUa7WmjdAAw0AAAwxenJufE3Xss/qlLzqdTrlY/ML5 z7VabSWTiedEcRuhAYaFAAYYvPn5+YVYNj9ffvrpf3rttRge1A1nPtNH9Vqtek+C lkql5aWl8+fPh366jdAAw0IAAwxYbJufE3XwVaVS2dnZGfQsGB2dTqeYz9/7z/ez 2eVMJoYDsYqFQrVa1cAACSeAAQZsdnb2sUuXQj+lVCy+8/77gQ6+itrj3LkefkOJ OmF7ezuevamkx1Gl0qjX7/3nG2trpVIp9NOjn8+FQiGaQ+gHAfAoBDDAIMW2+fnb 16597YUXYnjQQ9Xr9a2trS+8rgmPrtVslu8Xuo1GYyWTiWFttpDPH18LbBEYIMEE MMDAxLb5OTmv/kYpEtWvQiCQUrHYvt/PruifL2cy8bwM7DQsgCQTwAADMzc3F8PJ z8l59bfZbEb167YYwrnvUVgn9rPZzNLSwsJC0AnkcrmG07AAEkwAAwxGPMu/pWLx l2+9denxx0MM3tOrv1ESRPXbaDRCzAROPOgorJMfWl1ZeVAe95HTsACSTAADDEY8 Z18l5NbfqD22t7ejKhj0RBh9DzoKa+zkZuClpdBnrzkNCyDJBDDAAMSz/Ds1Pf3z X/0q9FMeKuqBbDYbwzG8MHZ3r0G5WHzQjx7s769kMnPz80HnUMjn6/W63f4ACSSA AeI2OTk5NTUV+u3f5Nx7dHh4mMvlQkwD7isK4FN2IK+vrd33sOj+yufzFoEBEkgA A8QtnquPwm1+7ql+S6XS3t5eiGnAg5xyFNbY3Y3Qy0tLoecQBXDdlUgAySOAAWKV qs3P1Wp1a2tr0LMgdU45CutEPBuhXYkEkEACGCBWMSz/Bt383L1Go3Hnzp12uz3Y aZBOpxyFdWJtdbVSLgedQxTAdVciASSMAAaITzzLv0nY/Bx1b1S/Lj1iUJrNZuXU F31j2ghtERggYQQwQHzm5uZCn301Pj7+67ffDvqIh4o6eXd3t+IEIAaqVCicvgEh u7e3nMksLCyEm0Mul2tYBAZIEgEMEJMYln9LxeIv33rr0uOPB33KQ0Xf9B8eHg52 DlCLnLr62ul0VpeXQ19PbREYIFEEMEBMYlj+/dKVK9+/cSPEyN1vfo6+19/e3g4x B+hJu90uFQqnf6ZYKKxkMuenpsJNwyIwQKIIYIA4xLD8W6tW/+ODD0KM3H39NpvN zc1NB1+REJVyufmwF9E3b9/O53Ld3+x1BhaBAZJDAAPEIYbl329fu/a1F14I+ojT RZ18586d+qlH70Kcovp96FHPjUZjeWkp6J/aWAQGSA4BDBBcDMu/4S7+7X75N5vN FovFEHOAs4l+9pYKheivp39sP5tdXV4Oei2wRWCAhBDAAMHFsPx74/XXn7p8ue/D dl+/lUplZ2en7xOAR1Q9OqrXaqd/Jvp5vry0FHTzgkVggIQQwABhxbD8e/npp//p tdeCPuJ00bf1t2/f9uovCRT95Cx3sTEhhtOwLAIDJIEABghrfn5+4eLFcOOXisV3 3n9/dnY23CNO1+l0dnZ2fGdPYkW/RtpdLL2urqwchby8OgrgeqPRajbDPQKAhxLA AAHFsPz77NWrr16/3vdhu9/8nM/nDw4O+j4B6JeHXgh8olwqLWcyk5OT4WZiERhg 4AQwQECzs7OPXboUbvxwVx91qV6v37lz56GHDMEAdXMh8InbGxuFfD7clUgWgQEG TgADhDIxMTE9PR30+Kvnnn/+2iuvhBv/dFH3bm5uNh52zyoMXKVUanaRnUeVSiaT mRgfDzeTfD4fdKM1AKcTwAChhN7/HGj5t/vNz4eHh7lcru8TgL5r1OtdZmfoReBo 8Fqt5jhogEERwAChhN7/PNjl33q9vrm5OainQ086nU4xn+/mk6EXgaOZFAoFi8AA gyKAAYIY0uXfLkXfxG9tbdUedr0qJEelXG52t11/Y329WCiEWwTO5XJVR2EBDIgA Bghibm5uhN/+dfIzQ6fRaByVy918slKpLIdcBI4CuFGv2wUNMBACGKD/Rnv5NwqJ zc1NJz8zXI53QRcKY939vA29COw+JIBBEcAA/TfCb/9GFbGzs+N7d4bRUaXSqNe7 +WToReB8Pl+v192HBBA/AQzQZ6FvPxrs8m+pVNrb2xvU0+FRNBuNSne7oMdiWAR2 HxLAIAhggD4Lvf95gMu/7Xb79u3b3l1kSHU6nVKh0OXu/eNF4KWliYmJQJNxFBbA QAhggD4LGsClYvGd99+fnZ0NNP7pXPzLsOt+F3RkZXk5XKO6EBhgIAQwQD+FXv79 0pUr379xI9z4p3D2FSOgp13QUaOuZDJT09OBJuMoLID4CWCAfgp9/NVP3nxzfn4+ 3Pin2N3dLXddDpBMPe2CjmSWlurB7ru2CAwQPwEM0E9BAzhK3yiAAw1+uqOjo+3t 7YE8Gvqrp13Q+/v7q8vLc3NzIWYSdXihUHAUFkCcBDBA34Te//zq9evPXr0abvwH ib5Nv3PnTr3rZoAkazQaR13vZWi1Wku3brXb7UCTsQsaIGYCGKBvgi7/ttrtd957 L9Dgp3P1EaOk0+kU8/nuP397YyPK1PEwdwIfXwhsFzRAjAQwQN/Mzc2Fu/53ULcf RbVw+/btZrMZ/6MhkEq53Gw0uv1w4PuQXAgMECcBDNAfoW8/+uC3vw00+OmKxWI2 mx3IoyGQRr3eU3OuraxUgjWqXdAAcRLAAP0xNz9/8eLFQIM/8cQTr73xRqDBT2H5 l5HU6y7ow8PD1eXlmZmZEJOJArher9sFDRAPAQzQB6N6/FWhUNjf34//uRBauVRq df0nO8GPwrILGiAuAhigD4IG8KCOv4q+3b99+7aFKUZSrVqN/tX958MehWUXNEBc BDBAH8zMzl4Kdv7zs1evvnr9eqDBT2H5lxHWarXKxWL3ny8WiyuZzPnz50NMxi5o gNgIYIA+CHr+80/efHN+fj7Q4A/i7V9GXrFQ6PSyq3lpcbER7DZsu6AB4iGAAR5V 0P3PU9PTP//VrwINfgp3/zLyouDsKWj3dnfXVlbmL1wIMRm7oAHiIYABHtXs7Oxj wfY/D+r6383NzXqwxS5IgmajUSmXu/98FMxLS0uTYS4Ezufzx7ug7bkACEwAAzyq oAE8kP3P1Wp1a2sr5odCzHq9DCmydOtWo9EINJlCoWAXNEBoAhjgkYzk/uednZ2K b8RJgUqp1NOL7ru7u+t2QQMMMwEM8EiCBvBA9j83Go3bt2/H/FAYiHqtVu2lOY93 QS8uTk5OhphM7vCw2svNTACcgQAGeCSjd/5zNpst9nI9DAyvXi9DGgu5C9plSAAx EMAAZzd6+5/b7fb6+nqn04n5uTAQ0U/1UqHQ00/43Z2d9dXVULugXYYEEJgABji7 0dv/XCwWs9lszA+FAaqUy81eVnQrlUom2C5orwEDhCaAAc5u9M5/3tra8hYiqdLr a8CRpcXFni4Q7p7XgAFCE8AAZxduBbjVbr/z3nshRj6F469IoTO8Bryxvl7I58fH x/s+mUKhUKtWvQYMEI4ABjijoPufv3Tlyvdv3Ag0+IMcHBzke7wWFYbdGV4Dzudy q8vLU9PTIebjNWCAoAQwwBkFDeBXr19/9urVQIPfVxQAGxsblp5IoV5fA45+mSx+ +mmgs+K8BgwQlAAGOKNwLwCXisUPfvvbECOfolwu7+7uxvxQSIIzvAa8srzc65d0 yWvAAEEJYIAzCrcCPD0z8+Yvfxli5FNE9Rs1cMwPhSQ4w2vA4S5D8howQFACGOAs RuwCJNf/kmbRz/xij2+/h70MyWvAAMEIYICzCBrAN15//anLlwMNfl/2P5Ny5VKp 1Wx2//momRc//TTQOq3XgAHCEcAAZxEugGvV6n988EGIkU9h/zMpVz06qtdqPX3J 2upqlM3nzvX/WymvAQOEI4ABzmJmZubS44+HGDn+F4Dtf4ZGo3HU458BhXsNOJfL RfPpaUUagC4JYICzmJubuxhmBfjZq1dfvX49xMgPUqlUdnZ24nwiJE273S4VCj19 SalUyiwuTk1NhZiP14ABAhHAAD0LdwHS2CBuAN7b24u+lY/ziZBAxXy+p30QYW8D FsAAYQhggJ4FPQHrrXffDTTyfUXfvq+vr7fb7TgfCglUKZWaPe46ziwt9frmcJec gwUQiAAG6Fm4AB4fH//122+HGPlBarXanTt34nwiJNMZzsHaunNnY319YWGh75Nx DhZAIAIYoGfhTsD60pUr379xI8TID5LLRd9pH8b5REimRr3e667jQj6fWVqK/geh 75NxDhZAIAIYoGfh3gH++osvvvTyyyFGfpCtrS0LTTB2953ecrHY05dEv3aWbt2a mJjo+2Q6nU6hUPAaMEDfCWCA3gR9AfjG668/dflyoMHv5QIk+Ez0C6GYz/f6JYuf fNIK8wq9c7AAQhDAAL0JdwFSqVj84Le/DTHyg7gACT4v+jXYbrV6+pKV5eVqmNOq nIMFEIIABujNKJ2Atb+/X+jx7lMYYZVyudlo9PQlAc/ByuUCpTVAmglggN6EewH4 iSeeeO2NN0KM/CCbm5v1ej3OJ0KS1arVWo+vxB8eHq5kMtH/LPR9Mg6CBghBAAP0 JtwR0M9evfrq9eshRr6vdru9trYW2+Mg+c5wEHSpWMwsLk5NT/d9Mg6CBghBAAP0 JtwK8LevXfvaCy+EGPm+qtXq1tZWbI+D5Itqs1wq9fQlUTMv3rp17lz/v6FyEDRA CAIYoDdXnnkm0Mg/efPN+fn5QIPfK5/PHxwcxPY4SL4zHAQdWfz002aYdVoHQQP0 nQAG6EG4E7DiPwJ6d3e3XC7H+URIviiAe70YbCWTCfSyrgAG6DsBDNCDcHcgxX8E 9MbGRqBlKxheZ7gJaevOnfX19YsBDoJ2ExJA3wlggB6EWwG+sLDw45/+NMTI9xWl bxTAsT0OhsUZbkLaz2ZXlpdDvL/gJiSAvhPAAD0IF8BfunLl+zduhBj5viqVys7O TmyPg2ERBWe9VuvpS/L5/PLS0szMTN8n4yYkgL4TwAA9mJmdvRTmCOjnnn/+2iuv hBj5vnK56Fvrw9geB8PiDFcBV8rlpaWl85OTfZ/M4cFBrccaB+B0AhigB+EuAY75 DqS9vb1Sj9e9QBqc4Srger2+FOYmJFcBA/SdAAboQbhLgG+8/vpTly+HGPm+Njc3 o+/aY3scDItms1np8c+GOp3OrU8+abfbfZ+Mq4AB+k4AA/Qg3CXAb737bqCR7xV9 V722ttbrXS+QBq1Wq1ws9vpVmcXFQH+i5CYkgP4SwADdGplLgBuNxu3bt2N7HAyR TrtdLBR6/arlTKbXN4e7JIAB+ksAA3RrZC4BdgQ0PEin0ynm871+lauAAYaFAAbo 1sgEsCOg4RRRAPf6gsD21tbaykqI/30QwAD9JYABuhVuC/SFhYUf//SnIUa+r2w2 W+z9LUdIiVKh0OuJVvvZ7Mry8vz8fN8nI4AB+ksAA3QrXAB/6cqV79+4EWLk+9rZ 2al4qxAeoFwstlqtnr4kn88vLy3NzMz0fTK5XK4qgAH6RwADdGtkAtgdSHCKcqnU 69W7AQP48LAa5ngtgHQSwADdChfAz169+ur16yFGvq+1tbUQd5bCaKiUy81Go6cv KRWLmcXFqenpvk9GAAP0lwAG6NbM7OylS5dCjPzta9e+9sILIUa+V6fTWV1djedZ MIzOEMD1en3p1q1z5/r/bdXhwUGtVuv7sACpJYABujUzM3Pp8cdDjBxnALsEGE53 VKk0enxHQAADDAsBDNCt0Qjgo6Oj7e3teJ4Fw6haqfT6krwABhgWAhigW6MRwOVy eXd3N55nwTCqHh3Ve2zOcAGcy+UajUavh3IB8CACGKBb09PTjz/xRIiR4wzgYrGY zWbjeRYMo0QFcKfTKRYK7i0D6BcBDNCt0VgBzufzBwcH8TwLhlGiAtgKMEB/CWCA bo1GAB8eHkbfUsfzLBhGiQpg7wAD9JcABuhWuACO8x7g/f39QqEQz7NgGJ0hgMPd AyyAAfpLAAN0K1wAf+nKle/fuBFi5Hvt7e2VSqV4ngXD6AwBnM/nl5eWov+J6Ptk BDBAfwlggG7NzM5eunQpxMhxBvDOzo4DdeAUAhhghAlggG7Nzs099thjIUa+sLDw 45/+NMTI99ra2qpWq/E8C4bRGQJ4P5tdWV6en5/v+2Ryh4d+wQL0kQAG6Fa4AB4f H//122+HGPled+7csaAEp6hWKvV6vacv2d7aWltZuRjgfx8EMEB/CWCAbglgSIOj SqXRYwBv3bmzvr5+cWGh75PJ5XLVo6O+DwuQWgIYoFvhArhULH7w29+GGPleAhhO VymXm41GT1+ynMnUwqzT5nO5IwEM0D8CGKBbc3NzIbY4nnjr3XcDjfwFm5ubvW7v hFSplErNZrOnL8ksLgb6ZSWAAfpLAAN0K2gA33j99acuXw40+OcJYDhduVRq9RLA nU7n1ieftNvtEJMRwAD9JYABenDlmWcCjfzta9e+9sILgQb/vNu3bzd63N4JqVIq FtutVvefr9frS7dunTsX5HuqfD5/5N4ygP4RwAA9CBfAzz3//LVXXgk0+OcJYDhd qVDoaTm3Ui4vLS2dn5wMMRkBDNBfAhigB7Ozs49duhRi5C9dufL9GzdCjPwFAhhO V8znO51O95+PGnV5aWlmZqbvM4mmUSgUBDBAHwlggB5E3+NeevzxECNfWFj48U9/ GmLkL/AOMJwias4ogHv6kv1sdmV5eX5+vu+TyeVyjUajpxeSATidAAbowczs7KUw K8CxXQW8tbVVDXNfC4yATrtdLBR6+pJwlwAfHhy4tAygvwQwQA9G4Crg7e1th8rC g7RarXKx2NOXrGQygf5QKXd46I+rAPpLAAP0IFwAR37y5pshdlF+wc7OTsUrhfAA zWazUir19CWLn37a673BXcrlclV/XAXQVwIYoAdBrwKO5yak3d3dcrkc+ikwpBr1 ek+HTkWfXwx3B5JLgAH6TQAD9CDoCvCzV6++ev16oME/s7e3V+pxgQvSo1at1nrZ dVwqFjOLi1PT0yEm4w4kgL4TwAC9CXcV8BNPPPHaG28EGvwz2Wy22OMrjpAe1aOj ei/nTh0eHq5kMrOzsyEmI4AB+k4AA/Qm3FXA8RwEHX2/nsvlQj8FhlSlXG72clH2 1p07G+vrCwGOgHYJMEAIAhigN+GuAo7nIOjoW+r9/f3QT4EhVS4WW61W959fWV4O dE6VS4ABQhDAAL0J+hrwjddff+ry5UCDnyiVSnt7e0EfAcOrmM93Op0uPxx9cvGT T1rtdoiZuAMJIAQBDNCboAH89RdffOnllwMNfuLo6Gh7ezvoI2BIRUEbBXD3n48C denWrYmJiRCTcQcSQAgCGKA3QW9C+tKVK9+/cSPQ4Cfq9frm5mbQR8CQarVa5V6O iCvk85mlpZmZmRCTcQcSQAgCGKA3QVeAYzgHq9lsbmxsBH0EDKlGo3HUyy3Z4U7A GnMENEAYAhigZ+EOgo689e67gUY+0el0VldXgz4ChlSvlwBnlpZ6ujOpe46ABghE AAP0LNxB0JFXr19/9urVQIOfWFtba4c5tgeGWhScjXq9yw+3Wq3FTz/t/sSsnjgC GiAQAQzQs6C7oKP6jRo40OAnNjc3611/lw/p0dMdSKVSKbO4ODU1FWImjoAGCEQA A/QsaABPz8y8+ctfBhr8xO7ubrmXFx0hJXq6A2l3Z2d9dXX+woUQM3ECFkAgAhig Z0HfAa5Vq//xwQeBBj9xcHCQ7+WuF0iDdrtdKhS6//za6mq5VDp3Lsi3Uk7AAghE AAOcRdDLkG68/vpTly8HGjxSKBT29/fDjQ/DqNlsVkqlLj/c6XQWP/20+/3SvRLA AIEIYICzCHoOVujXgCuVys7OTrjxYRjVa7Vq17uOw74A7AQsgGAEMMBZDPVrwPV6 fXNzM9z4MIx6OgI66AvATsACCEcAA5xF0AAuFYsf/Pa3gQYfu/uu49raWrjxYRj1 dAT0yvJy98vFvXICFkA4AhjgLIIG8Fj424A3NjaaNljCf+l0OsWuT4YLegPwmBeA AUISwABnFLSBv3Tlyvdv3Ag0eGR7e9sSE3ym3WqVisUuP5zP5VaXl6emp0PMpFAo 1KrVcMdrAaScAAY4o6CXIbXa7Xfeey/Q4GNuQoL/rlGvd7/ourG+Xsjnx8fHQ8zE C8AAQQlggDMKvQs66GVIxWIxm80GGhyGTvXoqF6rdfPJ4BcgeQEYICQBDHBGoQP4 ueefv/bKK4EGr9Vqd+7cCTQ4DJ1yqdTltUOVSiWzuDg5ORloJl4ABghKAAOcXdAG npqe/vmvfhVocAdBw2c6nU6pUOjyUKugFyB5ARggNAEMcHZBXwOO/OTNN+fn5wMN 7iBoONHTCVhLt241Go1AM/ECMEBoAhjg7IZ6F/TOzk7FTkvo5QSs6GNLQfc/ewEY IDABDHB2oQM46C7ow8PDXC4XaHAYIt2fgLW7u7u+shJo//OYF4ABwhPAAI9kbm7u YsgGDrcLulKp7OzshBgZhku5WOzytdug+5/zuVy9XvcCMEBQAhjgkQzvLujo++z1 9fUQI8MQ6XQ6xe7uxD7e/7y0NDkxEWgmXgAGiIEABngkQ70L2jlY0Go2y6VSN5/c 291dC7r/2QvAAOEJYIBHNbxnQe/u7pbL5RAjw7Co12rV7rJzaXGxUa8Hmkan0ykU Cl4ABghNAAM8qtAB/OzVq69evx5i5Fwud3h4GGJkGBaVcrnZxWu9xWJxJZM5f/58 oGnk8/njF4DtyAAITAADPKrQu6Bb7fY7770XYuSjo6Pt7e0QI8OwKBYKnXb7oR+7 vbGRz+XGx8cDTcP+Z4B4CGCAPgh9FvSr168/e/Vq34dtt9tra2t9HxaGRfRLoFQo PPRjrVZr6datdhedfGYuQAKIhwAG6IOZ2dlLIXdBX7hw4cc/+1mIkTc3N+vBXmuE hGvU691k5342u7qyMjc3F2gaLkACiI0ABuiD0Lugi4XCu//5n7Ozs30feX9/v9DF ChiMpKh+uznXajmTqYW8oMj+Z4DYCGCAPggdwJH5+fmfvPlm34ctl8u7u7t9HxaG QqlYbD9s3XV/f391eTnc8u+Y/c8AMRLAAP0xNz9/8eLFcON3Op1fv/32xMREf4dt tVrr6+v9HROGQvRrqpjPP/RjK8vLXd6TdDb2PwPESQAD9EcMi8Bf/vM//94//mPf h719+3aji2tgYMREP+2PHnYPdrFQOL79aGoq3DTsfwaIkwAG6JvQZ0GXyuUP/s// 6fuw2Wy2WCz2fVhIuOrRUb1WO/0za6urlYdF8iOy/xkgTgIYoG9mZ2cfC3kWdOTr L7740ssv93fMUqm0t7fX3zEh+R76AnC1Ws0sLY2fC/jNUlS/UYTb/wwQGwEM0Dcx 7IKOvld+73//7/6O6TVgUqibF4A31teLhcK5oAFs/zNAvAQwQD/FsAj8nVde+erz z/d3TLcBkzYPfQG42Wwu3boVdXK4OUSDFwoF+58B4iSAAfophgCOvPXuu/0d8ODg IN/FcbgwMh76AvDO9vbqykrQo90L+XzN/meAeAlggH6KYRd0p9N57Y03nnzyyT6O eXR0tL293ccBIeFKhUK73T7lA0uLi43A2yLsfwaInwAG6LMYGnhycvKXb73VxwGj ElhfXw+62xOSI/oJHwXwKR/Y291dXVm5cOFCuDlY/gUYCAEM0GcxBHCxUHj3P/9z dna2j2Nub29bjCIlGvX66W/eriwvVwP/csjlcqEfAcC9BDBAn01MTExPTwe9EDhy 5ctf/scf/KCPA+bz+YODgz4OCIkV1e8p25uLhcJKJnN+airoHFz/CzAQAhig/2I4 CqtcLr/3v/7X+fPn+zVgvV7f3Nzs12iQZMV8/pQN/2urq5VTD4h+dPlcrt5otJrN oE8B4F4CGKD/YtgFHbn6la9899VX+zjgxsZG03fkjLpWq1UuFh/0o+VyeTmTmZyY CDoHx18BDIoABggihgau1Wrvvv/+RP++U9/f3y+cejIQjIB6rXbKy7cb6+vFQuHc uYDfIDn+CmCABDBAEPEsAj//wgt/e+1av0ZzGRJpUCmXm43GfX8o+iWwvLQ0Pj4e dAKOvwIYIAEMEEoMbwI3Go1333+/X6tVnU5nbW3NZUiMsOind7FQGHvAT/LN27fz uVzQ5d8xx18BDJQABgglnkXgr3/jGy9961v9Gm1nZ6fiW3NGV7PZrJRK9/2hWq2W WVwMXb/2PwMMlgAGCCUK4IWFhdDbKVvt9tv//u/9+q69WCxms9m+DAUJVKtWo3/d 94e2t7bWVlcvXrwYdAKWfwEGSwADBDQ/P78Q+PvpyDdffvmbL77Yl6Fardb6+npf hoIEKpdK9718qF6vZxYXQz/d7UcAAyeAAQKKZxd0u93+t/4tAm9tbVUfsEQGQ+34 BeB8/r4/tLO9vbq8fDHwr1a3HwEMnAAGCGvoFoELhcL+/n5fhoJEadTr991+HN/y b73u7V+AwRLAAGEN3SJws9nc2Nh49HEgaaL6jRr43n9u+RcgPQQwQHBzc3Ohv7eO fOOll1586aW+DHXnzp1ardaXoSAhOp1OqVC495av6Kf68tJS6KfncrmG5V+ABBDA AMHFswjcbLXeee+9viwC5/P5g4ODRx8HkiOKz3KxeO8/v7O5eXhwEPq0dsu/AAkh gAHiEM8i8PMvvPC31649+jh2QTN67nsBUvXoKJPJjAe++9fyL0ByCGCAOMSzCFyv 1d55//2JiYlHH8ouaEbMfS9Aur2xUcjn+3WC+oNY/gVIDgEMEJN4FoGvfuUr3331 1UcfJ5fLHR4ePvo4kAT3vQCpUqksLy315Q+MThEFdq1Ws/wLkBACGCAm8SwCR9/T v/Mf/zE9Pf2I49gFzSi57wVI62tr5VIp9KMt/wIkigAGiE88DfzUU0/d+NGPHn0c u6AZGfdegFQsFJYzmampqaDPLRQKtWrV8i9AcghggPjEE8CdTuf1N9544sknH3Gc 6Hv3/f39vkwJBquYz3/hAqSV5eVq+IVZy78ASSOAAWI1Nz9/8eLF0E+Zn5//yZtv PuIgrVZrfX29L/OBAbr3AqTDw8OVTGZ2djboc6P6rTv8GSBhBDBArGJbBP4f3/3u c1/96iOOs729bf2KYfeFC5Cazeby0lIMXWr5FyCBBDBA3Obn5xfCLwK32u1/e/fd 8fHxRxmkWCxms9l+TQkGolwsfj53d3d2VjKZ0EeyHy//Nhr3XrwEwGAJYIC4zc3N RQEc+urRsX5cidRut9fX17/w8iQMkU67XSwUPvu3x1cfZTITj/YHQ93I5/P3njsN wMAJYIABiGcRuFQqvfXOOxcWFh5lkN3d3XK53K8pQcy+cAHS2upqJfzP56h+6+7+ BUgkAQwwGHNzc6E3YUZmZmZ+9stfPsoIlUplZ2enX/OBmEW522w0Tv7+8OBgOZOJ fukFfWIul2s4+wogqQQwwGDEcxpW5Bsvvvjiyy+f+cs7nc7Gxobv5hlG0c/e4/3P d/fw12q1lUwmhv38zr4CSDIBDDAw8VyJVD06euvf/31mZubMI+zv7xc+9xYlDItm o/HZhueN9fUohkO/e2/5FyDhBDDAwMR2Glb0oH/9+c/P/OX1en1zc7OP84F4VI+O 6rVa9De5w8Pl8Bf/jln+BUg8AQwwSPEsAke+/o1vvPStb535y6MAjjK4j/OBGJQK hXa7fbz5eWkphqPMj68+svwLkGwCGGCQZufmLsayCFwul3/99tsLZz0ROp/PHxwc 9HdKEFS71SoVi9HfrK+tlUulGJ5o+Rcg+QQwwIDFcyVSZHJi4hdvvXW22G61Wuvr 632fEoRTq1ajf+3v768sLc1fuBD6ca4+AhgKAhhgwCYmJ6enpmK4Eily5ctf/scf /OBsX7uzs1P53H2qkHDlUqmQzy9nMpMTEzE8LgrgI79AABJPAAMMXmxXInU6nVe+ +92/+upXz/C1LgRmiEQ/1Q/391eXlxv/dQlwUFFp1yz/AgwDAQwweJOTk+fPn3/s 0qUYnlWtVn/1b/82Pz/f6xe6EJgh0qjXFz/9NOrSGF6wj35pFAoFy78AQ0EAAyRC bIvAkYmJiV/85jfj4+O9fuHBwUE+nw8xJeivjdXVKIBjePU3EtVvvVZrNpsxPAuA RySAAZJibm4unjeBI08++eQP//mfe/2qRqNx+/btEPOBPsodHn78//7f+ampOJ6V yzVcfQQwPAQwQFLEdiXS2N1Nmy/8zd98+zvf6fULt7a2qtVqiClBX1SPjm5++GFs 67GuPgIYLgIYIEFiuxJp7G4D/8/r16/+5V/29FXFYjGbzYaZETyqqHs/uXkznlt/ x1x9BDCEBDBAgkxMTJyfmroUy2lYY3fXyn7+m99c7CW52+32xsZG9Ndws4IzW7p1 K7u7G882ijHLvwBDSAADJEucp2GN3Q3aX7711lQvb0tms9lisRhuSnA2dzY3f//R RwsLC/E8ztlXAMNIAAMkztz8fE+rso9oembmZ7/4RfeLZvV6fXNzM+iUoFfZvb2b v/vdzOxsPI9z9hXAkBLAAIkzOTk5NTUV24nQkSefeuqHP/pR95+/c+dOrVYLNx/o SSGfv/nhh2e42evMbH4GGFICGCCJYt4IHfmrr371f/zd33X5YUdhkRxHlcrvP/oo zq3IUW/X63WbnwGGkQAGSKg4rwUeu3so9Le+852//pu/6ebDjsIiIaIQ/eTmzaiB Y3uizc8AQ00AAyTUxOTk9PR0nC8DF4vFn/zsZ1eeeaabD+/v7xcKhdBTglNEFfrp H/5QzOfjfKjNzwBDTQADJFf8G6ErlcrPf/WrS48//tBPOgqLwep0OouffnqQzcZ2 6dGYzc8Aw08AAyRazCdCRxr1+i9+85vouQ/95NbWVrVajWFKcK/V5eWtzc2YD76q 2/wMMOQEMECiTUxMnJ+aunTpUszP/fmvf/3Qy4FLpdLe3l4884HP29na+vjDDy9c uBDnQ/P5fJwvGwMQggAGSLrZubmLFy/Guc8zEtXvT3/xiyi/T/lMp9PZ2NiwIEbM 9vf2Po7xyt8ThUKhXqvZ/Aww7AQwwBCYn59fiHcjdOTCwsK//Ou/nh7eh4eHuVwu tilB7vDw5ocfTk5OxvnQ/N1Xf1vqF2D4CWCAITB5/vzU+fNx3op04smnnvrhj350 ygeazebGxkZs8yHlioXCxx9+OB7vbohCPl+r1ex0ABgNAhhgOExGzp+P/2XgP3v2 2ev/8A+nfGBnZ6fixUjCq5TLUf12Yr992r1HAKNEAAMMjYG8DNzpdL76ta9de+WV B30gaoPt7e04p0QKVavVP3z0Ub1ej/m5Xv0FGDECGGCYDORl4KiBv/nSSy++/PKD fnRzc7PRaMQ8K9Ij6t5Pbt6M/wTmfD7fcOsvwGgRwABDJv6bgcfuVu7fXrv2tb/+ 6/v+aNQJBwcHMU+JlIj689ObN0ulUszPzeVyDbf+AowcAQwwZO6+C3z+sdhfBo4a +OVvfevr3/zmvT/UbrfX19ejD8Q8JUZeo9H45ObNSrkc83Ojn8yFQsGtvwCjRwAD DJ+JiYnzU1PxH4gVVcFfXL366ve+d+8P7e/vR8EQ83wYbdWjo5sffdQcxO76YqFQ 8+ovwCgSwABDaSAHYp2YmZ390b/8y8zMzOf/YaPRuH37dvyTYYRlFhfXV1bm5ufj f3Q+n7f8CzCSBDDAsJq/cGFhYWEgj64eHX3n7/7umy+++Pl/uL297bYY+qJcLv/h o4+azeZA/oinWChUq1Vv/wKMJAEMMMQGcij0Z6ZnZv7+e9+7/PTTJ/+2Uqns7OwM ajKMhlazmVla2lxfH8jC79jde49qtVrL5meAEfX/s3cn7G0cd57HQZzEQZA6bMlO bFmyZdlSJFuSJfmObzs+YkeOJ5nEmUwyeXZf4z4zmczszs7sZCaJHMu6T97gBXQ3 jj4A9BbQFEyTFMWjq8/v55EpkBarihLY7B+q6l8EYAAIN1+KQg/Ytr179+5X33hD RHHxeHJykm2T2B7x/Jm4e/fu7dvZbNavMSiKYor0y9wvAEQXARgAwi2VSmVzudHR UR/HoGnaEwcPnjl3biiZ5DwkbFW3250cHxfpVzyZfVnz7FBqNZNzjwAg6gjAABB6 qXQ668fBSKvYtl0oFh/ev3//I4/4OxKEhd5q3b1zZ3ZmZjiX83cknHsEADFBAAaA KEilUrlcruzrPPCASDV79+17/MABH/cnI8g67fbMzMz05KRSrQbkSatpmqHrLOAH gMgjAANARPh4MNK6bNsWcWL33r2PPPrort27/R4O/GdZ1uz09FylUqvVSj7VuFoX 6RcA4iMo90kAgJ0rlnqCk4EHms3m6Ojo2O7d+/bvF4P0ezjwTqfTWVpcnJ+bqy0t Ner1gMz3rsShRwAQK4G7SQIA7ISPhwNvUqvVEkMUQWjX7t279+xJpVJ+jwguazWb iwsLtWpVZMtGoxHkJ6SqqqZhMPcLAPFBAAaAqPH3cOAtcZZJFwqFYj8Si0ScGx72 e1DYmm63W9c0J+7W6/VWozGczwdwGcJaHPkLADEUgp9PAICt8vdw4J1o1OsiA+eF Yk9vOrtczmQyfo8LPbZt662W2g+6zXpdPBYMXQ/gwuYHUhXFME3SLwDEDQEYACIo UEWhd0iErmajkclms7nccC6XHe7l44JIyIWC+EU2dp34CzdNU/ydt5pNkW91XRcR 1+izDCMaT6rekb+WRfoFgBgiAANANEUpA29AVZS0yMYiB/ffZPoPluX6hofFw1Cs yPVAt9s1nSzbz7Qi6FqCeNt/1BZv2u18SBYwb1sv/ZomVa8AIJ6i/BMOAGIunU6L PDg6Nub3QHxm23a9Xk8mk+IvJCUs/5ZK9t+mlt/rfbj3f/rvDh6n+4+TganUJWJb u93u/Sfernj87bv937ribbfbufdR54PiIyMjI9EOtw9Uq1ZF5Cf9AkBsxfqnIABE HhnYFSJCa5omfmQODSR7Bu+JPyPe7f3Re+/2/siGUbNr9ziNJ/oPut2u865DvCv+ W37c/zMjQTrnOYzE36Sqqq1m0++BAAB8w89RAIi4dD8Ej5GBEXuaphm6zqFHABBn BGAAiL58oTAyMrI8RQnEEukXAJAgAANATBRLPSygRTxp/SN/Sb8AAO6EACAuyMCI J9IvAGCA2yAAiBEyMOKG9AsAWIl7IACIl0KxWC6X/R4F4IXekb+W1SH9AgDuIQAD QOyQgREHiqKYhsGRvwCAlQjAABBHZGBEG+kXALAuAjAAxFE2m01nMmRgRFJv5bNp kn4BAGsRgAEgplKpVC6XK4+O+j0QwE3s+wUAbIAADADxRQZGxNRqNYu5XwDA/RGA ASDWRAbO5nKjZGCEX61atSyL9AsA2AABGADirpeBs9nRsTG/BwJsn23bqqq2mk2/ BwIACDQCMAAgkU6nM5kMGRghJdJvvV63zB6/xwIACDQCMACgJ5VKZbLZMTIwQkjT NL3VYvEzAOCBCMAAgGWpdHo4lxvhbCSEiki/hq63KfsMANgEAjAA4Fv5QmFkZCSZ TPo9EGBTNFU1DIP0CwDYJAIwAOA7isUik8AIBdIvAGCrCMAAgO/I5/NUw0IoKIpC 2WcAwJYQgAEA35EvFDgWGKGg1GqtVsvvUQAAwoQADAD4jkKxWGYJNMJAURTTMCj+ DADYPAIwAOBbFMFCuLAKGgCwJQRgAMC3qICFcFEVxTRN6mABADaJAAwAWJYvFMrl 8tCQrB8NdiKRSaebzWYmk5HXCwLCtu1mo1EoFsU/d73RGM7lJHXEJDAAYPO4/wAA LCuIACyz/NUj3/ve4088IR50O52aUK3WNa3VaumtVi6XIxKHnaZpw8PD+Xy+UCqN lMu7du0qlkri47quX/zqq460SVqlVjNNk53AAIDN4G4DANDjweLno8eP36+Lbrer qaqqKI1GQ282dcMwdD2bzbIbOYBs2643Grlsdng57xZKIyPl0dFCoXC/T/n6woVm oyFvSCyEBgBsEgEYACB98bPQarXeeOedbXxWo14X2Uk8EJFYhBzTMCyh3S4Vi0wa yyNSbqvZTGcymWxPThgeFhG3UOwRH9xSazdv3JifnZX676Wpqq7rzAMDADbGrQMA xF0q3Ys5Y2NjUnsRIerkmTMuNtjtdFp9eqtl9lmm2e5FY/HG6oi37bZ4OyI52IdO b/62Xu/9o6dS4h8+3ScCrRN0s72c2wu64jcX/94W5ucvX7yY3WJs3ipN08STgQwM ANgA9wQAEGupVErEklHJ6VfY/+ijBw4elN3LWiLvGf0F1dY9Ih+LjCSycf9NWwTp TrfrfKTb7dricbfrPLATiVKpFKj8LL4c8VYkWDGmZDI5JP79kvek7kmn7/2e7gXd /gsc6f5Ubi6XE795/xX1tgFfuCA7mjrZ3uq/GiK1IwBAeAXohzoAwGPpfjTyIP2K ZHLyzJmctDrAUonBL+fkjhONu4MHzqNEfw9zoh9Ne8m5/0C87fb/1/304ms/iIq3 y1ud7z1YlWqT/XedD4p/L/lfsRSXL15UFUV2L04GbtTrsjsCAIQUARgAYsqzuV9B BLuzL73kQUcIrMrMzJVvvhnO52V35GRgwzDaliW7LwBA6BCAASCO+vs+pe/7HXjs wIFHv/99b/pCMJmmefHCBcuTUEoGBgDcDwEYAGInXyiIq7/UI39Xajabb7zzTqB2 0sIXN65eXZif9+yZQF1oAMBa3I4AQLwUSyWPCzuVyuVjx4971h2Cybbt+bm5a5cu bfUIpZ0gAwMAViEAA0BcpFKp4eHhkXLZy041TfvhW295mXkQTCKFNjTt9q1beqvl Zb+qohim2Wm3vewUABBYBGAAiIV0Op3NZj1b9jxQGhk5duKEx50imAxdn5+bu33z puwDgVdRarWhoaF2u83xSAAAAjAARF++ULBt27OSVwP1ev31N99k+hcO8SRs1Os3 r1/3eBLYwXJoAECCAAwA0ZZOp3O5XGlkxJcaVKO7dj1z9Kj3/SKwRP6cnZq6ffOm Ly+L9JZDGwYZGADijAAMAJGVLxQStu3NSb9rWZb18uuvJ5NJX3pHYOmt1s3r10UW 9eW5Uesvh7ZMs82uYACIJQIwAESQU+/Kr4nfRH+x67PHjo3u2uVL7wgy8dyoLS1d u3LFxzGoqmoaBhkYAGKIAAwAUdOb+E0kRj2vd7VSqVQ6ceoUa02xrk67PX7nzp3b twv956ovmAoGgHgiAANAdPi743dA1/Ufnz+vKIqPY0DA6a3W1cuXW82mv89VpoIB IG4IwAAQEf7u+B2wbfvMiy+O7dqlaZq/I0GQBWEhtENVFDuRYCoYAGKCAAwAoSei 79DQULlc9nsgPQ/v2/fmO++Mj493u12/x4JA67Tb05OTd27dyuZyfo8l4SxYsCyr bVl+jwUAIBEBGABCLJ3J5LJZ39c8DySTyZ/+/OetVmtubs7vsSAE9Fbr7u3bE+Pj IyMjfo+lR1XV3jlJTAUDQHQF4oYJALANhULBDsCa5wFD10X6LZZKlUql2Wz6PRyE gHgCNzTtxvXrIgkH5EUcZ0W0yXHBABBRgfhhAwDYkt6a50Si7Gud51U0Tfv0/PmH 9+0TsWF8fNzv4SA0Ou22yJw3rl0L1Jp5Z0U0MRgAoocADABh4vsBv+uybfvUCy8c efbZRD85LC0t+T0ihIneammqeuvGDb8HspqqquK53WI5AwBESIDunwAAG0hneoJT 7GpAJITDR468cPas8+7k5KRFGSFsRW8hdL3eaDRuXL2aTqf9Hs53iLHVNc3gqCQA iAoCMACEQECOOFpLxIMDBw++/Oqrzru6rs/MzPg7JISReCK1LWuuUrl940Ymm/V7 OKtxVBIARAYBGAACrRd9E4nRIG33HRCh5bEDB159/fXBR+bn5+v1uo9DQqgZur4w N3fr5s1s8DKwoNRqiaEhYjAAhBoBGAACKoCVrlZam347nc7ExIT4uI+jQtjpzebi wkJgM3BicGIwMRgAwokADACB04u+Q0MjAat0tdKqlc8Oyl9h55yiU9WlpWCuhR5Y XhRtWW12vANAqAT01goA4klE3+TQUNCKPK8iIsrTzzxz+syZVR+cnJxkTgw7J55L zXpdU9WbN24ErSbWKpSJBoDQCe4NFgDESiiir1DXtNfefPPIM8+s+niz2axUKr4M CdFjd7uNel0Eyxs3biSD/R2RIAYDQKgE/YcKAEReWKJvol+j6IOPP963f//a/zUz M6PruvdDQlR1RQbWNMuybl6/3ul0Av7d4ZyW1CUGA0DgBfrHCQBEmxN9i6VSMpn0 eyyb8vGnn4qgvvbjhmFMT097Px5Em8i9jXpdhMtbN2/OVyqBLQg3QAwGgOAjAAOA D1Kp1PDwcIiir8i9H3z00f02ZM7NzTUaDY+HhDhot9vN/sFaszMzkxMTxWLR7xE9 GDEYAIKMAAwAnuqd62vbQ8lkuVz2eyybIu7mH3/iiVdee+1+f8A0zampKS+HhFix TNNJkqqi3L55M5vL+T2iTSEGA0AwEYABwCOhW/Cc6G/6ff2ttw4eOrTBn2H6F7KZ hqG3Won+qy03r18X2TLgW4IHiMEAEDTh+PkBAKEWojJXK2VzuR999FFvyvr+mP6F NwxdN+5VWbt7587c7Oy629GDiRgMAMERplsxAAidkEbf3rLnAwdefu21Bw6b6V94 RqRHyzSdx7Va7e6tW2FZDu0gBgNAEITphgwAQkREX5EeR8IWfYVOt/vGW2997/vf f+CfpPgzvOSctdu2LOddy7Ju3bjRbrdDtKcg0f8qNE3j3GAA8EvIbssAIPjCG33F TfnevXvfevfd1H2qPa/C2b/wmHiKNhuNTrs9+MjszMzU5GRhw4X6waSqKjEYALwX spszAAiy8EbfRH8+7ZXXXz/05JOb/PPNZrNSqUgdErBWLwPX651OZ/ARwzBu3bgR ospYKxGDAcBj4ftRAQAB1Iu+iUR5dNTvgWyHuP/es2fPm+++m8lkNv8pU1NT1r3F qICXxNOvUa93V2RgYXp6emZyshCGg4LXUhXF7m9y9nsgABB9BGAA2BGnSPJoOKNv or/j99XXXz/wxBNb+ixFUZaWluSMCHiwbrfbFBm42135QcMwbt+8KT4YxqngRP/b KtFfi9HmpSUAkCaUPyEAwHepVKpXgda2R8fG/B7LNomc8L3HHhPpV3wtW/rEdrs9 OTlp27akgQGbsW4GFuYqlanJyeHhYV9GtXNKrZYYGiIGA4AkBGAA2JoIRN9E/4zf H7755p69e7fxuZVKpclaTQSASL+NfkXlVR/vdDp3bt9eWFgoh+es4FWWY7BptldU /AIA7BwBGAA2K5/PJ/prK0O619dhmubps2eP/eAH2/t0al8hULqdTqNeX3c9gvj4 7du3k0NDIV0RnXD2BosvbWiI7cEA4Jaw/kgAAC/lCwVxG10KZ3nnAXEnvf+RR157 44305k45WqvT6UxNTXW+W3wI8Jd4Qjbvk4ET/XOSpqemeq9ehRZHBwOAi0J8JwcA Hgj1yUYr5YaHX3/jje2teR6Ym5trNBpuDQlwy8YZuNNu37lzZ2F+vlwuezwwFxGD AcAV4b6fAwB5Qn2y0UqdbvfM2bNPP/PMDtsR0VcEYFeGBLhu4wwsNBuN27dvi2/q sL+YxZlJALAT4f4ZAACuS2cyznG44T3ZaEDcIh87ceLMuXM7v+Nvt9tTU1NrK+4C wfHADCwszM9PTUxkstmwx2DnzKROu22apt9jAYAwCffVHwBcFI3yzg6RAfY+9NDr b76ZE1+RG63Nzs7qur7zpgCpNpOBhcmJicrMTKFY9GZU8lAsGgC2igAMAAmnQI64 ZR6LRPQtlUovv/baDrf7rlStVmviPhsIg01mYJEYx+/eXZifHwntUUkD4tuzN6Ft 261Wy++xAEDQEYABxFpkalw50pnMuZdeeuzxx11sk3OPEDq9s5EaDXsTK/YNXb97 +3a1Vgt1fSxH71Tker1LlSwA2FAUbvgAYBsiFn3Fve/ps2eP7LjS1Sps/UVIiSdt U6TBzT11RW68c/v2UJhPDB6gWDQAbCz0F3oA2KrIlHd2WKZ5/Pnnnzt50vV7dxEe ZmZmKLGDkOpl4Eaju+ljqxcXF6cmJtLpdERisKpSLBoA1gr9JR4ANknc12ay2WjU uHIYun70+PFTL7yQSqVcb1zcQM/NzTW5e0aY2f0M3Nl0BhbmKpWZqakIlIlO9L+L VVVN9F8mo0oWADhCf3EHgAfKFwqJ/r1gBGpcOVrN5pGjR8+++KJI9ZK6WFpacs5Z AUKttxi40dhq/JudmZmenh7O5SISg8X3MsWiAaAv9Jd1ANiAiL7JoaFiqZRMJv0e izvqjcbTTz/94iuvZLNZeb1omrawsCCvfcBLIgHqzaZlWVv9xKnJSZGE8/l8BGJw YlAsmnXRAOItChd0AFgrYjWuhLqmPXXkyIsvvzw8PCy1o0ajMTc3J7ULwGMiAxu6 bhrGNj5xcmJibnbWuaTIGJvHqJIFIOaicCkHgJUiVuMq0Z+Pferw4RdfecU5r1iq VqtVqVQeeIYqEEYiA4tf2/jEbrfrxOBiqeT6qHxBDAYQWwRgABGRSqWyuZx4MBqt 6Pvkk0++9OqrzjZm2QzDmJmZIf0iwizT3Hbk63Y6ExMT85VKpGIwxaIBxAwBGEDo Ra+8c6K/4PmQh9E30U+/s7OzHPmLyGu3281GI7HdF3oGMbhQLEZmUbRTJcs0jC1V zAaAMIrChRtAbPXCoW2Le9AoLXiuNxpPPfXUuZdf9mDB8wDpF7EiYp7IwPYOnvDL i6JFDI7Q3mBFUYaIwQCiLgqXbAAx5JR3LkWoxlWiX33q8NNPn33pJdllrlYh/SKG xBO+tcUjgtdtZGpyMkolsgRVUXr7IIaGWBcNIJIicrEGEB/RK+8sNJvNp48cEdFX 6uFG69J1XaRf9v0ihpwSUO2tH4+0th0RgysiBkflwKQEVbIARFdELtMA4qDQ3w0b pdXOiX7+PPLssy+cPZvJZLzvnZrPiDnx5DcNY3ulodc2NT01JWLw8PAwMRgAAisi F2gAEbZc4ypa5Z0Fcdv9zLFjp194IZVO+zKAer0+Pz/vS9dAoOykNPRaM1NTs7Oz uVwuUjGYYtEAoiIil2YAkRTJ8s6JfhHaZ48de/7UqVQq5dcYarVatVr1q3cgaDr9 0tAuroaYnZkRv7LZbJRisKqqCWIwgJCLyEUZQMQ45Z3FrehYtKKvcOzEiR8cP+7j PbH4e11cXNQ0za8BAMHkSlmsVebn52emptLpdKRicP/MJMuydr59GgC8F5HLMYDI cMo7F0ulZDLp91jcJO6AT5w8+fSRI/4OQ9zcz83N6W7seASiR6Q7vdWyTNPdZqtL S1NTU+LKFpkYLCi1Wi8Gm2a73fZ7LACwBdG5EAMIu0iebCTup8XXdeqFFx4/cMDv sSRM06xUKtytAhsT3ym6hFW+qqpOTUzY/aPLXW/cL7VarXd0sGl2uLAACInoXIIB hFevvHPkTjay+1uXXzh79uF9+/weS0+j0Zifn6fgM7AZvS3BzaYt4XDsZqMxOTFR XVqKUkH7XgxOJHqLoonBAAIvOveaAMIokof61uv1Q4cOnT53LiBlq0XorVariqL4 PRAgTHpbgptNSRObIitO3L27sLBQKpUic/VTFaX3EtvQEFWyAARZRK65AEKnF32j eKjvU08/ffbcuWwu5/dYlrXb7fn5eTb9Atvg4inB6+p0OpMTEwtzc85LgZJ68Vi3 223U612ODgYQVBG52gIIkUhGX6vdfvbo0ZOnTvl1qO+6ms2mSL9dCcs4gfhoW5bI cvK2D4iWp6emKpXKcISODhaXnXq9bhODAQRPRK6zAEIhktF3qH+y0TFfTzZaS9x9 VqtV59BOADskdTn0gMjAlenpdCYTqIvJTogArGkaMRhAoETkCgsg4Hrn+iYSAdkT 6wpxS5fL5U6cPPnU4cN+j2U10zTn5uYsjugE3CO+5Q1dNw1DdkdLi4vTU1PJZJIY DAAyROTaCiCwIhl9R0ZGTp058+j3vuf3WFYTY1MUpVqt+j0QIJosy9JlLoce0Ppn JnUjdGaSE4PFb01iMABfReSqCiCAohd965r2xKFDL5w9O7Zrl99jWYdpmvPz8+Kt 3wMBoqy3HLrR6HQ6HvTVarVEDF5cXCyXyx505wFmgwH4jgAMwH3R2+ur6/rhp59+ 4dy5XGDKO6/ExC/gJdnVoVdpt9tOsehiqeRNj7I5laLFddWb1xEAYCUCMAA3RS/6 drrdZ5599vlTp1KplN9jWZ+4D19YWGDiF/CYyKWtRsOD5dAOERpnpqcrlUp+eNib HmVzzg02LUt2dTEAWIkADMAdhUIhMTQUmXV6gki8P3juOZF+A7sHT9wQ12o1RVH8 HggQU3a322q12h4WnBOJcX5ubnZmJpPJeNapVOIiJq6xpmEwGwzAGwG9qwMQIr1Z 36GhkZGRwAbFLRH3l4Vi8dTp048dOOD3WDbSbDYXFxfbzJwAfhPhTW+1PO60Wq1O T04O9XnctQxODLZMk2saANmicNEE4Jd8Pp9MJktRib6aqh44ePD0mTN79u71eywb ETeIIvpSSRUIjk6n02o0ut2ux/026vXJiQlxTRCXYo+7lkGp1RLMBgOQLAr3rAC8 l0qlhoeHi6VSNO66RJh86vDhMy++KCK932PZiFPsqlarebbtEMAmeXZQ8FqGYYgY vLiwMDIy4n3vrnO2dVAmGoAkBGAAW9Y738i2R8fG/B6ICyzLeubo0ZOnT6fTab/H 8gAipS8tLVke7jYEsFVty2p5clDwWp1OZ2pycr5SKRSL3vfuLk5LAiAPARjAFkTp aN+hoaFjJ04c+8EPgr9+W4ReEX1Z8wyEgveVsVbqdruzs7Nzs7PBPLNtS5zTkgzD YGMwABcF/bYPQEA4la4iUOTZtu3hfP65kycPPfmk32N5MKfOs6qqrHkGwsU0Td2/ F63EFWNxYWFmejr4a1seiPpYANxFAAbwAOlMJpfNRqDSlbgjHB0dPXX27P79+/0e y4M5KwCr1ar3ZXUAuKLb6bSaTR/rOYnLiKoo05OTdn/Ni1/DcAUbgwG4JdxXQwCy RWO7b73ROHTw4Olz58KyeJvtvkA0iAhqGoah6/6OQeTGyYmJarUa6lU84gupaxor ogHsEAEYwPrS6XQ2lwv13ZIg7jsPHznywrlz2WzW77Fsiri3E9FX9/V2GYC7Ov2p 4K7fR/tYpjkxPr4Q8mLRzlFJrIgGsG0EYADr6O34TSTKIZkvXVen23326NHnTp5M pVJ+j2VTLMuqVquNRsPvgQBwn4+HJK3SabenpqbCXixaVRTDNDtkYABbRwAG8B0R iL4i8R5/7rkjzz4blj1v7Xa7Vqtpmub3QADIJQJbbyo4ABv7I1Aserk4lmX5VXAb QEiF4+4QgDeKpVKxWEwmk34PZDuc8s4nT59+4uBBv8eyWZ1OR1EUijwD8RGcqeBE PwY7xaIzmYzfY9kmVVFMlkMD2AoCMICeVDqdC+2OX3FDKUZ++uzZ/Y884vdYNktE X5F7Rfol+gIxJAKbHoyp4ET/ElqrVqemppJDQ2FZOLOSsyuYAtEANil8lzkArssX CuIGaCyEpZ41VX3i0KEXzp7dtXu332PZLHHL68z6BuTeF4AvAjUVnLhXY3lyYkI8 CF0Mdgav67qPh04BCIuQXeAAuK5Y6gnd7U6j0Xjy8OFzL72Uz+f9HstmicTrzPoS fQE4AjUVnOgnyWazOTk+LgYWuu0wLIcGsBkhu+UF4KKQHnSk9082OhOek40SRF8A K6yaYg3aVLBDXGlFDF5cXAzXzwiWQwN4IAIwEFOpVEoEyNFQLXu2TPOZY8dOvfBC WE42Stzb68uCZwArrV1mHLSpYIdlWb2jg+fnQ3R0MMuhAWyMAAzEUeg2/Yr7mGPH jz938mSIlmoTfQFsLBRTwYl+OJ+cmFiYmyuWSn6PZbM0VSUDA1hXaG4lAbglZGcd 2fYPnntOpN8QRV9xs+hEXyo8A9gqkdl6ZwUHL7mJK9v01NR8pVIoFv0ey6aIDGwY BluCAawSmhtKAK4IUckrEdFPnDz5zLPP+j2QLbAsS1GUer1O9AWwbeICYoroput+ D2QdIp/PTE/PVSqhKECoqqpJBgbwXSG4CQbglmKxWBoZCX76FdH3+dOnnz5yxO+B bIFpmrVardFo+D0QABHR7XRarVYnkOFNxODZmZnK7GzwYzBroQGsEvT7YABuyRcK IyMjAV/5nEqlTr7wwlOHD/s9kC0Qt1Yi+or7VL8HAiBqbNu2TFNcZBKBXFQSlhhM BgawEgEYiIXg13wOXfR1TstUFMUIXsUaAFHS7Xb1VqttWX4PZH2hiMHiWs3ZSAAc BGAg+nrn/Waz5dFRvweyvqGhIRF9Q7TgWdyM1ut1cTvFvjIAnhEBuNVq2UGtKt9p t6enp+dmZ4NZIqtWq1mmySQwgAQBGIiDYrE4Ui77PYr1PX/q1DNHj/o9is0SiVfT NE42AuCLwJ6TNOBUip6rVIrBi8GKoogMzAuXAAjAQMQVCgWRfoNW+Krd6Tx/8uQP TpzweyCbZRiGyL31et3vgQCIu8CekzRgWdbkxMT83NzIyIjfY/kODkYCkCAAA9GW zWZT6fRokBY/m4bxg+eeO3n6dNAy+brsvk6feNDtW/Vg5duV7/o9dgCRFfyp4ET/ aj8+Pr64sFAOzBIkcXHWNI3NwEDMheAGFMC25QuF4KTfZqt19NixM+fOpVIpv8ci nZOc7xeP75eiBw/8Hj6AEAh4cSyHrut3b9/udDoBedGTk4EBBOJiBECG3vRvKhWE ys+aqh5+5pmXX31VDMnvsYTDAwPzBtHa77ED8JTIcnqzGfDvffFTYHx8fKhf9dDf kYhLpcjATAIDcUYABiIrCNO/4lajXC7/8O23S6WSvyOJjwcm5A3itN9jB7Ady8cF B/s0cjHIpcXFyYkJ318JVTi5HYg3AjAQWYVCwd+jj1Kp1Euvvvr9xx7zcQzYkvsF 5gcGab8HDsRap9MRAVhIBL76QLfTmZmZmZ2e9vG0pN6RSJbVYRU0EFcEYCCa8vm8 SL9+LTYzDePkCy8cf+45X3qH9zYIzBu8S6kwYNt630Qi91pW27JC9yKUyOoTd+8u +FcfS1EUVkEDsUUABqLJr/XP4p7s4X37Xn/zzUwm433vCJf7zTavsur/+j1qwE/i 26Et9HNv2F9Cqmvandu3fSmLWKvVAr5iHIA8BGAgmvL5vPflr9Kp1OtvvSUCsMf9 IlY2iMr3y89+DxnYEWeyt90XsYW74ju0MjMzPTXl8YroWrWq67qXPQIIDgIwEE3D w8Nju3Z51l2z2Tx5+rT45VmPwCZtML3c6XTWvuv3eIGeQejtnULebkf7dRzDMO7e utX28Kik3jZg0xR/td50ByBQCMBANHk5AyzuzPY+9NDTzzzz2OOPJ5NJbzoFJFk3 Ht/vsd+DRaSIa6kzz+uEXr+H4x3TNBcXFhbm59PptGedsg0YiC0CMBBBhUJhpFz2 vgJWXdN27dmzZ+/eRx55RIRhH4t8Ah5w5padPLzy7doP+j1SBJQzzbus3Y7PSyri C282m0qtVlfVRrOZy+W8/4FFAAZiiwAMRJAvG4BX6VVqsayxXbtEJH7ooYf2P/qo 74cSA74YrMEe5GHH4LHzINprXOHozfGKf/HBcyA2L46IJ7lIvJqIuw0ReJt6qzUy MuLvkAjAQGwRgIEI8v0E4HWJ+55y3+iuXbv37Nn/yCN+HYABBNDahLxKfKYHo2T5 n/Ve3I3JP6L4MkW21DSt1WqJrCtYphm0n0oEYCC2CMBANO3bv9+vQ4A3r65pxVKP eDs61pstFsFYPAj+yAHvDVZcL+8RJSEHz8oJXmfSP/IT+07WFZysa5g9+eHh4F/G CcBAbAX98gRge4KwCnp7nFMuC8ViIZ8v9OPxSLm8qxeOd3tZHwUIHSd93dtP2l71 gK3IrhtURRvM3Uc47oonUqufco0+qx90LcsqFArBz7rrIgADsRXKaxaAB/L4GCQP iDtLce817BDZWCj2lEb6yuVMJuP3GIHg2iAet+NUfml7vj1M697UbvSOmBbPA13X RbgVybYXcYV+xBXEM0RcZUMadNel1GomxyABcRWdaxmAlcI7A7w94k600Wxms9nh XC437LwZFv+JmCyysrPKWkilUn6PFAgiZ+XFqlQ8eBuxpLcxu29V1g37CwRi/L1k 2w+31j3tfrJ1iH/poO3RlapWrYq07/coAPiDAAxEk0h9VF1epReSG41MJiNycjaX y4oHuWXZfmAezvc4mVl80O/xAoHgpMFBHl71INTZeDnrrjjYOVx1qsQ/gTNPa65I s50V/0bOCxjii/LlYLwgU2q1Vqvl9ygA+IOrIRBNqVRK5LyxOE0Cu0vcFuutViqd FoE5Ld6KzNyPzoMHud5083D/TT879zNzMpn0e+CApwaTxiuDcQCz8WANs71yJXNg sq4zA+8sNha/ib89qx9fB2vWvy111t9vLL6KYqlEpt02NgADccalE4isuK2C9p24 ha1rmsjMvVcfMpnltyI8i484bzOZQZzuhej+FHR/NjrnTEoz7YwoWbmOelVCltrv d4KuV/t111k4vqIc9HJR6P5e67Yzts69CN7piJFFbIdtwIn0axoGG4CB2OJqC0RW vlAos+wtVJwFma1WK5VMOkFaSPez9OAj6X6cdh45cdpJ1+kV6To/PCzepvv8/pqA 1QbluNorDGLjltr5Nt9+u4h5U5O697Jnpzfdeu+o3pWx9DslrwbuHUXlPO49ELna tllgHC6sfwZijus1EGWFYlFkYL9HAU85W52TQ0NJkZpFTO5l52Sq//jeo+WHyeWE vZy0l9O1E6374Xk5YzvBekXG9vtLRGQ5z15hZersLQo2zd7iYNN00rJ43O2n5e4a TkS17z22naR6bwH0tx/p/xl7aKhULA71+f2lwyO9+s+W1ZG8DAFAkHHFB6KMSWC4 zllK2mg2k4lEL0WLnJxcprdaQ8lkL0z0N0OLtxRjwyriWWHouqoolmXZTjTtzwg7 +wV6U7L9ueDled3+2uDeZ3ERg0uY/gXATxQg4orF4giTwACA2FMVxWD3LxB7BGAg 4tLpdDabjdUBjwAArFKr1SzTJP0CIAAD0ZcSGTiToSI0ACC2OPoIgIMADMRCKpXK 5XLMAwMAYkhTVV3Xmf4FkCAAA/HBWmgAQAyRfgGsRAAGYiSVSokMzFpoAEAc2LZd 1zTSL4CVCMBAvLAWGgAQB7VabWhoiH2/AFYhAAOxk85kctlsaWSEozUBAJGkKopp mu122++BAAgcbn+BmMoXCuL7n6lgAECUOBO/FukXwH0QgIFYEzE4YdvsCgYAhJ1t 25qmGez4BbAhAjAQd+lMDzEYABBSTvQVb9nxC+CBCMAAenoFonM58WCURdEAgJCo Vau9ehYUuwKwaQRgAN/hLIoeSibL5bLfYwEAYB22bauqKh6YhsGCZwBbQgAGsI50 Op3JZoeGhkYoFg0ACAylVuv9xpQvgO3ivhbARvL5vLjPSNi2eMwmYQCA95bne8VP InIvgB0jAAPYrEKhYPevGqWRkWQy6fdwAACR1Qu9itJ71F+FRO4F4BYCMIAtW54W 7t+giLdjzAwDAHaM0AvAAwRgADvVq5uV6N+52HYymSxTRxoAsAlO4u2tLepXm7AJ vQDkIwADcNlyHu7f2YhLjMjDlNECACT6pxYl+nE3ce/nAokXgMe4KwUg13A+vxyA ++ule7PEqRRnLAFAtImrvaIovXP1iLsAgoQADMAHg1niQSoWd0jMFQNAGC2vZF6R dZ1LeZO4CyB4uNcEEBTfzhU7+puKnb1h1NkCAH8NZnQTzpV6xeV6iKwLIDwIwABC YFB3etm9eWMnHo8ydQwAO+ZM5Hb75RuWL6orLq3i/+qtlm+DAwCXcMsIIPRWx2OH fS8lE5IBxJ4zf+vUJkwMroZrrors0QUQedwOAoiFwa5j56pnO+/Yg99t54NEZQAh snLONrHyyrXmImZ3u7quezo4AAgkbvIAYLX1p5Qd96LyygdDySSxGcBOLM/Qdrsr p2fvN087+JwWa5IBYIu4XQMAd/QmmfvlYQYfGRpMNSe+nW1OrMnP4k0qlRopl4nQ QEg5NftUVV0/wd57d4PPJ8oCgDe42QKAoFhdB3sDg8XbK951JqLlDA2IMqVWc/ZB rDzC51sbf1f2X/ZKJZP1el3W+AAA7iEAA0B09BZvO7YYpEV4HhkZYQoa4eWcQ9t7 JJ7G312LsdJ3qgD03+1S3BgA4oR7HQBAb/12WdoabNH48PBwNpt1pbVOp8Ni0ZAa SiaVajWVSsloXKnVeGIAAB6IAAwA6GVUScun0+n06XPn9uzZIwK2Kw2KkDM7O+tK U/DeXKVy+ZtvhnM511smAAMANoMADACQGIDHdu364KOPXGyQABxq83Nzly9ezEkI wLVajZXMAIAHIgADACQG4Gaj8dv/+T9dbFDTtIWFBRcbhJeuXblSXVyU0TIzwACA zSAAAwB61bNGx8ZktCx+zPzsyy9dbLBardZqNRcbhJcm7t69evnyyMiI6y3XqlVd 111vFgAQMQRgAEDvBKYxOQG4VCp9/NlnLjY4Pz/PeTPhNV+pfPP119+WK3dPtVo1 CMAAgAchAAMAJC6B3rd//5vvvONigzMzM0z0hVetWr341VeZTMb1llVFMUyz0267 3jIAIEoIwAAQd6VSqVAsJpNJGY0fPnLk9JkzLjY4Pj7e6XRcbBBeajYaX3/11eAA ancpitJqNmW0DACIDAIwAMSdvOlf4dzLLx88dMit1mzbvnPnjlutwXvtdvvrv/zF NE0ZjROAAQAPRAAGgLiTGoA/+eyzYqnkVmuWZU1OTrrVGnxx8auvGnJ2cVMIGgDw QARgAIg7eQG40Wj8g6tnIDWbzUql4mKD8N7Vy5drS0syWuYoYADAAxGAASDu5J2B JPzc1TOQVFVdlHOKLDzDSUgAAB8RgAEg7oaHh8d27ZLRsgg5H336qYsNLi0tKYri YoPw3vzc3Dd//auMk5BqtZplmtRIAwBsgAAMAHFXKBbL5bKMlr/32GOv/fCHLjZY qVSaVDkKOVVRLn71VSqVktE4dbAAABsjAANArEmtgHX8ueeOHT/uYoNTU1OSCgjD M7quX7xwQdI8LQEYALAxAjAAxJrUAPzO++/vfeghFxu8c+eOLecIWXhG/Av+9S9/ kVStikLQAICNEYABINbkBeBut/u3v/rV0JBrP2ja7fbExIRbrcFHl7/5Rq3VZLRM IWgAwMYIwAAQa8P5/JicEtBd2/7Fr37lYoOtVmt2dtbFBuGX8Tt3rl66VJbwyotS q1mW1W63XW8ZABANBGAAiDV5ZyC5XgJa07SFhQUXG4Rf5iuVb77+WkYhaNu2VVVl GzAA4H4IwAAQX1I3AD/2+OOvvP66iw1yBlJkUAgaAOAXAjAAxJfUAHzy9Okjzz7r YoOcgRQZpmH89cKFjpyFytTBAgBsgAAMAPElNQB/+OMfu3u88OTkpGVZLjYIH319 4UKz0ZDRMnWwAAAbIAADQHzJq4DVbDZ/+z/+h4sN2rZ9584dFxuEv65evlxbWpLR MnWwAAAbIAADQHzJC8DpdPqnP/+5iw2KSDM5Oelig/DX5MTEtcuXi8WijMbZBgwA uB8CMADElNT1zw8//PBb773nYoPNZrNSqbjYIPy1uLBw+eLFTCYjo3ECMADgfgjA ABBTUgPw0ePHTzz3nIsN1mq1arXqYoPwlwjAN65eldQ4ARgAcD8EYACIKXknAAvv /ehHu/fscbHB+fn5er3uYoPwV6fT+ef/9b/Kcl6CqVWruq7LaBkAEHYEYACIKXkz wK1m8zeuVsASpqamTNN0t03469/+8IdMNiujZVVRDMMQGVtG4wCAUCMAA0AcifRb LpeHhqT8FMhms+f/5m9cbNC27bt374q3LrYJ3134058MafO0rIIGAKyLAAwAcSR1 A/D+Rx994623XGyQEtCRdPvmzbnZWUmNE4ABAOsiAANAHEndAHzy9Okjzz7rYoON RmNubs7FBhEEmqpe+vprSY3XajW91ZLUOAAgvAjAABBH8maAbdv+9PPPC4WCi21W q1WRZ1xsEEEgnir/8o//WJBzFDDbgAEA6yIAA0DsSN0A3O50vvz1r91tc25urtFo uNsmguA///3fE9K2drMKGgCwFgEYAGJH6gZg0fKPPvnE3TYnJycty3K3TQTB5W++ UaXN7Su1WotV0ACA7yIAA0DsSN0AfPjIkdNnzrjYoG3bd+7ccbFBBMf83Nyt69cl Nc4MMABgLQIwAMSO1AD87gcf7Nm718UGDcOYnp52sUEER6fT+cM//uPIyIiMxm3b VkUGZhIYALACARgA4kXq+mcRVn/9D//gbpuqqi4uLrrbJoLjP/7t35JytqMnmAQG AKxBAAaAeJEagEsjIx9/+qm7bS4sLGia5m6bCI5LFy9qiiKpcQ5DAgCsQgAGgHgp FAplaQH4ycOHz5w7526bU1NTpmm62yaCQ+o2YBGA2wIV1AAA9xCAASBGpB6AJLzz /vt7H3rIxQapgBV5vW3A//RPI6WSpPZVRWmyChoAcA8BGABiROr6Z9M0/+63v3W3 TSpgxYHc04A5DAkAsAIBGABipFAslstlSY2P7dr1wUcfudsmFbDi4PrVq0sLC5Ia FwHYsqx2uy2pfQBAuBCAASAuZK9/PnbixPETJ9xtkwpYcaCp6qWvv5bXPrWgAQAD BGAAiAup659t2/7spz/N5/PuNksFrDgQT57//fvfD7v95BlgFTQAYIAADABxIXX9 89DQ0M9++Ut32+x2u3fv3nW3TQTThT/9ydB1SY33akGzChoA0EcABoBYkL3++XuP PfbaD3/obpu6rs/MzLjbJoJpZnp6/PZtee2zChoA4CAAA0AsSF3/LLzx9tv7H3nE 3TZrtVq1WnW3TQRTp93+w+9/L/EwJFVtNhqSGgcAhAgBGABiIXQHIAmzs7Ns3YyP //qP/+h2u5IaFy1rmsYkMACAAAwA0VcoFMoyp3/37N377gcfuNumbdvj4+PyEhGC 5s6tWxWZK95ZBQ0ASBCAASAO8vn86NiYvPZfOHfuqcOH3W3TNM2pqSl320SQmYbx r7//vbxXaqgFDQBIEIABIPJSqVRueFhe/We91fr1737nenktTdMWFhbcbRMB95// /u8J25bUuG3bqqoyCQwAMUcABoCIk13+atfu3e9/+KHrzc7Pz9frddebRZDdvnVr TuYqaEphAQAIwAAQcbIDsIz1z8Lk5KRlWa43iyAzTfNf/+mf5K2CZhIYAEAABoAo k13+StL6506nMz4+7m6bCAWpq6AT7AQGgNgjAANAlBWKRXm7f4Xdu3e/J2H9c71e n5+fd71ZBN/4nTszMouf1Wq1tmW12215XQAAgowADACRlS8URPp1fXp2pRdfeeWJ gwddb5YNwLEl0um//vM/l0oleV1wHhIAxBkBGAAiq1gsjsic/rUs61e/+Y2Mlicm Jpiji60//9d/WaYpr30mgQEgzgjAABBNHkz/PvK97/3wzTddb1bk6snJSdebRVjM zc7evnlTahdMAgNAbBGAASCaZE//2rb93o9+tGfvXtdbVlV1cXHR9WYRFt1u9//8 y78M53LyulBqNYtJYACIJQIwAESQB9O/6VTqp3/7tzJanpuba3BYa7xd/uYbtVaT 2gWTwAAQTwRgAIgg2dO/wtEf/ODE88+73qxt2+Pj491u1/WWESLNRuOrP/85mUzK 64JJYACIJwIwAESNB9O/zVbr17/9bSqVcr1lwzCmp6ddbxah81//7/91Ox2pXTAJ DAAxRAAGgKiRffav8PC+fW+9+66Mlmu1WrValdEywsWDUliUgwaAGCIAA0Ck5AuF 0dFRqV3Ytv3+hx/u3rNHRuPT09OGYchoGeHS7Xb/77/+azabldqLpqpsOAeAWCEA A0CkeBCAh/P5zz7/XEbLnU5nfHxcRssIoxvXri3Oz0vtwrZtVVVZCA0A8UEABoDo 8CD9CmdfeunQk0/KaFnTtIWFBRktI4ws0/w/f/hDsVSS2ouqKE0CMADEBgEYACIi nU5nMpnRsTHZHf38yy8ltVypVIgiWOnCn/5k6LrULpgEBoBYIQADQER4cPSRcOTo 0ZOnTsloudvtjo+PizQio3GEVG1x8b/++EfZRd04EgkA4oMADABRUCgURiQffSSY hvHLv/97GacfCc1ms1KpyGgZ4WXo+tcXLnQkn4eUoBoWAMQGARgAQi+bzabSaQ92 /x48dOjcyy9Lanx+fr5er0tqHCHVbrcXKpXbt24lk0mpHbEQGgBiggAMAKFXLJVG RkZk99JqtX71m9+k02kZjYv4MT4+3u12ZTSO8BJPDE1Rrly65MHaeEVRTMPwYLYZ AOAjAjAAhFu+UBDpV/b8mPDYgQOvvPaapMZZ/4z7qWuaqijjd+7IXuGfYCE0AMQA ARgAwq1QKJTlL34WAfXLv//7bDYrqX3WP+N+Ws2mZZpXL1/2YIGA6ELTNBZCA0CE EYABIMS8WfwsPH7gwMvSpn9Z/4wNmIaht3r+euGC7HLQiX5FaNM0WQgNAFFFAAaA sMoXCmX5lZ8Tknf/Jlj/jA112u1Gf3XA9atXvTmpSFXVJguhASCiCMAAEEqpVCqb y3lQ+Vk49NRTZ198UV77c3NzbLzE/Th1sBL9I5EuXLhQlr/kgYrQABBhBGAACKVi sTgifzmoYBjGl9LO/hU6nc7ExIQHNX4RXg1Nc9Yk3751S2+1POixVqtZLIQGgCgi AANA+Hi2+Fk4dvz48eeek9e+qqqLi4vy2kcEiNBrGoZ4YFnWXy9cKBQKHnSqKopp mt4sugYAeIYADAAhkxYymbGxMW+6+/mXX0ptf3p62uhnG+B+LNMcLEienppSajVv +uVUJACIHgIwAIRJKpXK5XIenHuU6O+EfPm11w488YS8LkzTnJqaktc+oqHb7dZV dflxp3Pxr3/NSDuRayU2AwNA9BCAASBMPNv6KwwPD3/2059K7WJxcVG9F2yADWiK MtgoXl1ampme9mYLQG8zsGV1WAgNAFFBAAaA0PDs1F9B07Sf//KXUsN2t9udmJjg +F9sRrPRaFuW81gk4WtXrnj2zFEUxWIzMABEBQEYAMLBy8JXwv5HH33jrbekdiEy 9sLCgtQuEBmGrotfg3d1Xf/6q69KpZI3vauqahoGGRgAIoAADAAh0Dv1N5sd9arw lWmav/i7v0un01J7ofwVNk+Ez2a9vvIjkxMTmlfr523brmsaBbEAIAIIwAAQdF4W vkr07/WfO3Xq6LFjUnvRdX1mZkZqF4gS8bTUFGXlRzqdzqWLF2W/TLNyABTEAoAI IAADQNB5Wfgq0a999ennn8teaz03N8d8GrakoWki9K78iKIok+PjyWTSmwH0CmKZ 5qoxAADChQAMAIHmcfptNhpf/OIXsktttdvtiYkJqV0gevRWy1yzZv7WzZsr9wbL RlFoAAg7AjAABJeXZZ8dB5988txLL8nuZWlpSfnuclbggUTybK1ZNSA+eOnrr7O5 nGfDUGo1k3lgAAgtAjAABJRIv4JnZZ8T/c3G5//mb8Rbqb10u93x8fHBma7AJtnd 7rpVr6rV6szUlJffKRyMBADhRQAGgCDKFwojIyOebW4UGo3Gp59/vnfvXtkd1Wo1 kVhk94JIqmtad72p19u3bumtlpcjURXFJAMDQAgRgAEgcNLpdCaT8ezQo0S/wu3B p556Uf7i5263Ozk5yfJRbM+624AT/V3lly5eFN81no2kV5Va03oZ2LI86xQAsHME YAAIFo+P/HVkstlPz5/34EQZVVUXFxdl94KoWncbsKOuad9cvFj2sGKck4GbFDMH gFAhAANAgHg/95voz6r9+PPPd+/eLbsjERgmJiaY/sW2rT0NeKWpyUnV2+JqYjwi eHOgFwCECAEYAIKil36z2dHRUS87FXfwx44fP/H88x70xfQvdu5+24AF8fGrV654 PB4yMACECwEYAAJBpN9sNlv2Nv0Kosf3P/xQduXnBLt/4ZL7bQNe/r+6funixXw+ 7+WQyMAAECIEYADwn8ifueFhL7cvOrq2/en588Vi0YO+KP4MV7Qta+Ntt4uLi5WZ GS9PRUr0X9/RNK3VbHrZKQBgGwjAAOAzv9KvSBHvffjh9x97zIO+Op3O5OSkCAke 9IVo23gbsGP87t1Gve7NeAZURTEMgzUOABBwBGAA8FNv5XMu5336FSni8JEjp8+c 8WaibHFxUVVVDzpCHIhw29nwAF6RQq9fvSqe5J4NySGe5Iauk4EBIMgIwADgG7/S rzA6NvbO++97c26qZVmTk5MedISYECFT/HrAnzGMy998k8vlvBnSABkYAAKOAAwA /khnMr2qV36k36Fk8pPPPisUCt50V6lUmuyNhHs67fZmVjhrmiYy8MjIiAdDWom1 0AAQZARgAPCBj3O/umF8+MknDz/8sDfdtVqt2dlZb/pCTPSqLqvqZlY4z87MLC0u elwQK0EGBoAAIwADgNd8TL+apv3wrbcOP/20N5FARJTp6WnTND3oC7HSajatTTyv xDPwzu3beqvlwZBWYS00AAQTARgAPOVXzedEPwwcfPLJsy++mEwmvelRZIDFxUVv +kKsWJbV2ty5u512+8b1675UIBfPf7vbbfkRvwEA90MABgDv+Jh+hbFdu95+7z1v Cl8lOPoIMm3mMKQB0zCuXL7s2TN/JfH8b9Trjc1ldQCABwjAAOCR3srnbLY8OupL 75ls9sNPPsnn8571OD8/X/f8LFbER7PRaFvWZv9ws3nl0iUvn/8DZGAACBQCMAB4 oTf3m8v5lX67ti3S79jYmGc9UvsKspmmqW+lurimqlcuXy6VSvKGdD9kYAAIDgIw AEjnb/oVOeH9jz7at2+fZz2K2/2pqal2u+1Zj4ghu9sVmXZLn7K0uHj92jW/duDX NY0MDAC+IwADgFz+rnxuNZtvvf/+448/7uVJMIuLi+oWkwmwDY16vbPF11lmpqer S0veH4yUIAMDQDAQgAFAolQqlc3lRn1Kv5qmvf7mm08fOeLl7b6u6zMzM551hzgz DWOrRxx1u92J8fGmTymUDAwAviMAA4As6XQ6k836lX7FrfZTTz99+swZzw49SrD4 Gd7axiroRL8++Z1bt/w6nrpXv1rTRO+br+AFAHARARgApPB37lfcZD/6/e+/+vrr Yhhe9kvlZ3isWa9v4wUX8Sm3btwQSVjGkB6IDAwAPiIAA4D7fE+/ex9++M23306n 017222g05ubmvOwRsEyztZVa0Cs/8eaNG+KbxfUhbYaTgQ1d9yuEA0BsEYABwGW9 lc+ZzKiHZw6tUh4be/f998UYvOy03W5PTU11u10vOwV6SVJRtve5hmHcuHbNyz0C Ky3PAxsGWwYAwEsEYABwk+/pt1As/ujjjz1Ov+JWvlKptLZYjghwRavZtLa7odfQ 9WtXr3q8VmKADAwA3iMAA4BrfE+/2Vzu408/zWazHverKMrS0pLHnQIOkR6bO9h5 3mq1rl2+LL53XBzS5pGBAcBjBGAAcIfv6TeVSv34/Pmc5/fxnHsE39VVdSfL75uN xrWrV73/3nGQgQHASwRgAHCB7+l3KJn89Cc/Gc7nPe630+lMTU1RyAf+MnRd/NpJ Cw2Rga9cGR4edmtIW0IGBgDPEIABYKd8T7+JoaFPz5/Pe55+2fqLgNjegcCrNOr1 a1ev+puBqQsNALIRgAFgR2KbfoVqtVqr1bzvF1hrJ6WwBuoiA1+54st3U+JeBm42 Gr70DgAxQQAGgO3z97xfwU4kPvv8c1/u11ut1uzsrPf9AuvqdDoNTdt5O3VNu3b1 qo8ZWAygQQYGAGkIwACwTSL95nK5sq/p9yc//akvKzYty5qenubUXwRKo17vuLGH tpeBr13L+7cWmgwMAPIQgAFgO9LpdDabjWf6FblXpF+Rgb3vGthA27LcWj9MBgaA qCIAA8CW9dJvLlcul30cw0+++MKXU1sofIUgE7mx61IRKdHU9WvX/KqJ1e12NU1r NZu+9A4AEUYABoAtKxaLI/6l36GhIZF+s9msL70vLi6qOy63C0himaaLodHfutCq ohiGQVFoAHAXARgAtsbn9JtMnv/ii0wm40vvmqYtLCz40jWwGbZtNzTNxd3p/p4P rNRqpmW5srEZAOAgAAPAFhRLPUND/lw8k6mUSL/pdNqX3in7jFBwdxI40c/A169e 9WXHQYIMDABuIwADwGblC4VyuexX+hW597Of/tSv9Gua5szMDGWfEXy9SeB63a2d wI5msykysF/7DhRFEam+TQYGADcQgAFgU/wtfJXL5T79/PNkMulL75ZlifTLXkSE hYvloAdaIgNfu+bX7gNVUUzLalN6HQB2jAAMAA8m0q+48R0dG/Ol9+F8/tPz5/2a eRa5V6RfDj1CuLh1JvBKrVbrxvXr6VTK3WY3g4ORAMAtBGAAeACRfbOZjF9H/pZK pY8+/dSv9NvtdmdnZw3D8KV3YNs6nU5D01xvVtd1kYFTfqzFEBlYVVUORgKAHSIA A8AD+Fj2WaTuH338sV/plyN/EWp6q2VKeO3G6GdgX/Yj1Go1i4JYALAzBGAA2IiP ha/Gdu364KOPvO/XIdLv/Pw8Sy4RXr1lw6oq3rresmEYt65fT/hxWVAUxeRwYADY AQIwANxXKpXK5XK+LH7es3fvux984H2/DpEZFhYW6vW6XwMAXOH6kUgDvQx844aM lh9IVVXXS3wBQHwQgAFgfT5u/X1o3763333X+34HFhcXxU22jwMA3CKyoqTiyabI wDdvyphh3hibgQFgJwjAALA+v7b+7nvkkTffftv7fgeWlpYURfFxAICLut1uQ9Mk xVTTNG/duOF9Blb6m4E5GRgAtoEADADr8Gvr7/5HHnnD1/RbrVZrtZqPAwBcJ28h dMK/DKwqSpNJYADYOgIwAKzWO/M3nfb+1N/9jz76xltvedzpSqRfRFWr0ZB3lrUv GZiF0ACwPQRgAFjNl8XPpF9Anl5FaE2zu11J7fuSgcU3bJuF0ACwRQRgAPiOQqEw 4vniZ9IvIJsIik2Zhc1FBr55/bq89tdFRWgA2CoCMAB8hwjAHld+fujhh99+7z0v e1yF9IuYMHRd/JLXvmkY169dSyaT8rpYhYXQALBVBGAA+Fa+UBj1Nv3u2rXr/Y8+ 8rLHVaj5jPgQcVFkRUmnIjlEwL529Wo6nZbXxSri+9cyTRZCA8AmEYABYFkqlcpk s2Me1r4aKZc//OQT72tNO0QYEOmX834RK3a326jXu9I2Awu6yMCXL4uLibwuVmIS GAC2hAAMAMs8rn2VLxR+/JOf+Jh+FxYW6jK3RALB1Ol0GpomtQsRRy9fvpwfHpba y4BSq5mW1WESGAA2gQAMAD0eH/ybSqfPf/FFKpXyprtVRPqdn59vUDsHcWVZVkvy 87+uaVcuXSqWSlJ7GVAUhUlgANgMAjAA9BSKxbJX07+dbveLn/0sm8t5090q3W5X pN8m98qIN9kFsYRatXr18mVviupxJBIAbBIBGAA8nf7VW63Pf/7zkZERD/paS6Tf SqWiS77vB0Kh2WhILYhl23ZldnZpcdGba4tSq7VaLQ86AoBQIwADgHfTv1q9/tn5 8w89/LAHfa3V6XRmZ2dN0/SldyBoREDtFcTqdOR10e12J8bHvTmql0lgANgMAjCA uPNs+lfcbT9/+vSzR4/K7mhd4rZYpF9L5nwXEDoioDY0TXxvyuui0+lcv3pVahcD TAIDwAMRgAHEnWfTv/sfeeSNt9/2oKO1RO4V6ZepIWAtD4pCm6Z56euvc/KLQtdq NYty0ACwIQIwgFjzbPo3k82e/+ILXw49MgxDpF+pB58Coda2LNmrlDVNExnYg4JY lIMGgI0RgAHEWj6fHx0bk92Lrus/++UvRV+yO1qr1WpVKhVvll8C4WUahi558fDU 5KSqKFK7SPRXQXc6Hbb6A8D9EIABxFcqlcpks2OSA7AIn+deeunQU09J7WVdzWZz bm6O9AtshgjAIgbLa7/b6Vy9ckVe+w7x/a6qKpPAAHA/BGAA8ZUvFEblr0h86KGH 3n7/fdm9rFWv1+fn573vFwgpER1FbpR6MJKu619/9VWpVJLXhaAqCgd9A8D9EIAB xJcHAbjdbv/tl1+m0mmpvaylquri4qLHnQJh58HBSNPT00q1Kq/9RP+r0FSVDAwA 6yIAA4gpD9KvuA196dVXnzh4UGova1Wr1Vqt5nGnQDTIPhhJtH/p4sVUKiWpfQfn IQHA/RCAAcSUB6cflUdHP/zkE6ldrCLu2peWllRV9bJTIGI67XajXpfXvqaqE+Pj UmvC12q1tsC53wCwBgEYQBzl8/mRcjmZTMrrol6v//LXv/ay8rNIvwsLC3WZN+5A TFimKbWO1LUrVzoyF1pTCgsA7ocADCCOPFj//PiBAy+/9prULlYS97vz8/MNyWeZ AvEhtSi0aPkvf/lLeWREUvsJVkEDwH0QgAHEkez1z4auf/mb38je5jcg0u/c3Bw1 bwAXiW+rZqPRabcltX/z+nWpp/WqimIYhtR5ZgAIIwIwgNjJ5/Pl0VGpG/AOPfXU 2RdflNf+SuI2vVKpMNUDuE5qQSyRfv/y5z/LnQRWFFZBA8AqBGAAsSN7/bOX07+k X0CqdrvdlLav/uaNG/JWWSf6pbB0Lg4A8F0EYACxUygUyjIDsGfTv6RfwAPyNgP3 JoH/+7/lXY5EALZMk1XQALASARhAvORF+i2X5a1/bjWbf/fb36bSaUntD1D1CvCG +F5r1OtdOTHyyqVL8s4cTrAKGgDWIAADiBfZ65/37d//5jvvyGt/YGFhQdM0DzoC IO9kYFVRpiYnZbTsoBY0AKxCAAYQL/l8fnRsTFLjtm3/6OOPx3btktT+QLVardVq snsBMCBpIbS4aHz91VeZTMb1lh0EYABYhQAMIF6G8/kxaQE4Xyh8ev68pMYH6vX6 /Py87F4ArGR3u3U5FaGnJidVRXG9WYcYsKqqrIIGgAECMIAYkb3++blTp549elRe +4Ku67Ozs1I3DQJYl2kYMooqt9vtP/3xj/JKYbENGABWIgADiBGpAVjcYv76d79L JpOS2k/0b5Snpqa63a68LgDcj23bdVWV8fLTpYsX5VXmYxU0AKxEAAYQI1LXP+/e vfu9Dz+U1Hiif/M9MzNjyDw1FMDGxDegISFMzlUqiwsLrjfrIAADwEoEYAAxIrUC 1ouvvPLEwYOSGheWlpYUaRsFAWyGbduahG/DTqfz33/8Y7lcdr3lBNuAAeC7CMAA 4kLq+me91fr1734nbxGjruszMzOSGgeweSJJWqbperMXv/46JW0DBduAAWCAAAwg LqQG4PLo6IeffCKp8W63OzU11W63JbUPYPMknQk8OTGhqarrzTpYBQ0AAwRgAHEh df3zsRMnjp84IanxxcVFVdqdMYCtqquq67XodF2/deOGpFUktWpVtC+jZQAIHQIw gLiQNwNs2/ZPvvhieHhYRuOmaU5NTcloGcD2GLpuuJ0nxWXkwp//LOkyoqpqs9GQ 0TIAhA4BGEAs5PP58uiopNmVZDL5N7/4hYyWhZmZGaZugEDpdDoNTXO92WtXroiW XW/WwTZgAHAQgAHEgtQNwA/v2/fWu+/KaLnZbFYqFRktA9gJTVVtt1dBz0xP16pV d9scIAADgIMADCAWpAbgk6dPH3n2WdebtW17enralFBvFsAOyagFbRjGzevXJS1U oQ4WADgIwABiQV4FLHkbgBuNxtzcnOvNAtg5kX5dn1AVF5M//+lPhXze3WYdtVpN JwADAAEYQEyIgDq2a5eMlru2/Ytf/UpGy9PT04ZhyGgZwA51u926hNrsly5eZAYY AKQiAAOIBXkzwKOjoz+ScAKwruszMzOuNwvALTIOQ7pz+7aknbq2bauqyjZgACAA A4g+qSWgDx46dO7ll11vdm5ursGxJUCAydgGvDA/Py9t4wN1sAAgQQAGEAdSK2C9 +MorTxw86G6bnU5nYmLCtm13mwXgItMwXN9Va5rmjWvXZK2CJgADAAEYQBzIC8Ai o37+s59ls1l3m9U0bWFhwd02Abir02436nXXm/3v//zPYqnkerMJAjAA9BGAAUSf vABsmubf/fa3rjc7OztLuRog4Gzb1hTF9Wb/+pe/ZNx+Tc1BHSwASBCAAcSBvApY 2Vzu/BdfuNtmp9MZHx93t00AMtQ1rdvpuNvm1cuXXa+t5eAkJABIEIABxMFwPj8m JwDv2bv33Q8+cLdNjv8FwqLVaFiW5W6bd2/fbspZqFyrVnVdl9EyAIQIARhA9OWG h3fJOQT44JNPnnvpJXfbnJ+fr0vYWAjAdcb/b+/OnuO67juB94ZesBGkREqyZGts LZZESpRUSioaRxOPEzuVVPIwVXnIPORlHvJP5SGpmqk8TFVSldTE5ZRVsWPLtuyS Y2kkWdY4sbhpoUQRjaWxo3vOvRcAQRAAQaBPb/fzKeLi9oLTFyDZ93zxO/eclZXV bkfK69ev34wzBYAKMEBBAAbyYHx8fDrONcAvvvTSk0891d02r169urGx0d02gRjW 19eXu71c2fz8/IdXr3a3zYylgAEKAjAw8qKugfSNb37z3AMPdLHBEH2vxun7Al23 ubnZWljobpvhTeDX77/f3TZ3mAgaQAAGRlzUNZD+7M//fGxsrIttLi4ufvbZZ11s EIgn0kTQP3399empqa43WxCAAQRgYOTFC8BLS0v/4y//srtt3rx5cy5CfxqIZGF+ vtPtSZt/8cYb9Uaju21mBGAAARgYcVErwP/9L/6iu21+/PHHpmmFIdJaXNzs9kX7 b7/1VqVS6W6bGQEYQACGXCuXy9Va7ba7Op1w5yjNQhwvANfq9f/2Z3/W3TYvX74c aQlQIIaQJ9fX1rrb5nvvvtvdBnfMNZvLozsRdL1eLxaLhWLSuQ0fnfTOtdXVzW6v 1QwMNQEYRlyj0ch6A4lOp3P7o+GBU/stkBueODc312m3i9nXFrebKBb3PC/cE542 yEXLeAF4+tSpP/7TP+1ig6GXduXKlS42CMS2srwcIlZ32/z1++9Hmgp+uAJwEmhL pexEsxNoE+mpLP3I9jrhaeF9vljc263NJr7ec+pL8/HWM9XDIYcEYBg1Ie9t7aWd hunp6dAn2H36v7OLcHJ3Dcy3+i7pUfWyz9FoNPYN+Sd37ty5b3zrW11sMHRMP/nk ky42CMQW0m/XF9f94De/ibRgb38D8O5Ae9sDuwJtujkw0J7cnrPh/NxcOztzbWds kRhGngAMQy8k3uy0nZ3XI3Uauuu2wJwdbrEYaaBavAD8pUcf/c+vvNLFBhcWFm7c uNHFBoHYYiwFfO3q1YX5+e62mWk2m5Gi9W5bF9ek56RkEzPQdldSMc6mIUwPdXNj Y63b49uBvhv0dyLgIEmlN/QqisWptMbb78M5kSy63xmJC924fKveaMzECcBPPvXU iy+91MUGZ2dnQ/e0iw0CsYWM1Or2pAmffPzx7M2b3W0z05yd7e4VK5VKZaxaTfa2 RyOHbWn7xDTU56bsF7WF7SFNKsMwMob4jQlyaGt4c9rDGIrfpp9c0v9Iu1Vra2vH S8L1en3m9OluH1fiuRdeeOb8+S42+Nlnn43S9GOQB+12e7Hb1drPb9z49Pr17raZ mZ2dXe1GAE5qvGnuHY1fwt7V7srw+vr6xvp6v48IOL4Rf8OC0VCpVJKuRrE4OTlZ KpX6fTg9tXO9VlYfzn4Vn3W2diLxnrmsdxeNk+rE2FikIdC//fLLX3nssS42+NFH H612ezYdIKrwHrXQ7bW7w9vdR9eudbfNrZYPvQa4nJ1r7phCeSfudnZdozu9nXtH Pv3utjsJqwnDkMrRexYMo2ycc+hxRBrEO6SyTtjC/PxWAK5Upqamsk5Y1jtph/5Z IemglEuliWi/Nfj67//+gw891MUGr1y5YrkOGDohAN8xxf6JLC0tXf7ggy42uCOp Vy8u3na0t0YuJ1F2entsUSeVTKHcbuc27h4i++GEnfW1tUhTdgOReBeDAZVNbZWH oWXD64/+5E+6WFsO3alLly51qzWgZxbn57u7fHcIVL9+//0uNrjbXLM5nY8raHqj 2WwW07nQxGAYFt7+YOBkF/pOi74D7/e/9a2pqalKOsz65K2FztPVq1dP3g7QY62F he6O3eh0Ou+9+65TwBCZT0cBiMEwFLy3wgARfYdI6OuMT0yMZarV7HPIwhMTE/V6 vZLeLFduCTcPH4m9urr60Ucf9ez4gW5ZarXudVakbIBxiM3tIPu0mQjxKYSosLMw P+9EMHTEYBgK3lthIISkVKvVdi5kZUiFrk+r1aqUy+U0DYfPIfhWsu12DC6n25CT ayEnbwt3rq+tzTab5VTepjqDoba8tLSerhYb3gHaO7JUu2s/C7dbcTe7c9f+5vbX hTeHYV9AKOfmms14K9sDJ+ftFfovu9x3+tSpfh8IPZLk5MXFUpp1K2lODkKHKfSd S2n6TT/KpSwKp/OvhtBcLqV3bCfk5EuObGJyMt63A8Pr6Ev4dgqFrEi7FVfTvZBo V1dX19bWwk6WY7MMHB7aFYXTrNvphP/5pnXIj/m5ufAvY1MpGAaPd2Hop5BhksKv LhEHSxZZWVgI/0JK4U8afUvJjSQBH72RLDBv5ebtyL2Vv7NK9e79tF59TwEbBkE2 hDjIPmVDim/duWNjI4uvWZo9evtJvg1flUbcTvq1HZmWgyXzYykFw+Dxlg19k6y4 GG2JWjih7BrF1tJSKZwqtoP3Vvoul4vpElNZEi/uyuRZUE/2b3+0nD5UzIrb6Z3F 4q2v29lmlfAse4cQ3u+fAfcmq3NmsTDbz6qgnZ07020nTZ63jRa+/Tk7T2unl8nu fnh3lbWzfVMQZWBlv8EMGdhVwTA4nCqgP7Lar2HPcLidBUvn5uayHmRp+/LILEUX 0oVJ77xq2lWUxxAC5Z7VbLMgurVQbGb7aWNjY9PT0zvP9NOGgyTDodWBYWA4XUEf VCqVLz766FKrpctIzu3k28WFhWwnKxRv7e3cUyzuPLOw/byS/z49lF3Ceuf92d9L lpALWTbeftrk1FS2440OspmxlpeW+n0ggAAMPRfS7/3nzu3blQQARlKn01lcXDz6 vGtAJAIw9FS5XD41M1OtVvt9IABAry3Mz6+m04b3+0AgvwRg6J3G+HilXLYgDQDk lhWSoL8EYOiFythYrVabnJx0LRwA5Nxcs7kWMrBpsaAf9MUhuiT9VquTU1PSLwBQ kIGhf3THIS61XwDgTjIw9IUeOUQk/QIAB5GBofd0yiGiiclJ6RcAOIgMDD2mXw5R VCqVWq0WAnCpVOr3sQAAgyvJwOvr5oWG3hCAIYrG+PipU6f6fRQAwBBoNpsry8v9 PgrIBQEYuq9cqVTHxk7NzPT7QACA4TA/P7/UavX7KGD0CcDQZZWQfmu16enpfh8I ADBMFhYWWouL/T4KGHECMHSZwc8AwDG02+2QgZeXlvp9IDDKBGDopnK5XK1WDX4G AI7BQGiITQCGrimnMz+P0uDnTqfTWlwslcthv725OWFJJwAGQDg9LadTRoWd8fHx ETs3GQgNUY3U+wX011APfg59iLXV1fGJicmpqanp6ZmZmfvPnr3v/vvHxsZ2nrO2 tjbXbM7Ozi7MzydjtFqtpeXlpaWl1eVl2RiA7spOTPVGOLuOh49wogmnp3CePXPm TNjf/cy5ubnPPv109ubNcJJaXFxcWlxsLS2Fs1m/jvyEDISGqHRYoTuGaObn0KXY WF8PvYetzsTMTAi6oT9RrVaP3War1QrJOPzJfm+dxOKlkI6XQ5uCMQAHyWq59Xo9 jbmN8cns17DTp8+cCWG3nA5BOp6Qij//7LPZ2dn5ubnFcG5KTUxMdPHg4zEQGuLR MYUuqKSDn6cGcvBzu90uFIszp06FnsTMmTNnz549c999u+u6sV89ROIQjOfS/sfS 4mISi5eWVkI2rtVkY4A8CCl3aWmpEWJulnJDDE1/AztzOtGzU1IhHV386fXrNz// fC4E42Burt5o9OzV70k4tiVFYIhA7xO6oDE+Pj09PSBxLmTOUrF45v777z979gsP P7xnGPPg2NzcXJifbzaboQfSyurGqZCNx9SNAYZNUstdWUlSbiORpNyJieyamhB0 TzLIKKoQiT/68MPPrl+/ceNG8+bNwcnDc81mdp0z0F26mHBSg7Dwb+h2hND74MMP f/FLX3r4kUdqtVofD+bkssm3smyc1I1braW0aLyS5OOV0ZvvBGBYtNvtzY2NkBK3 Bi1ntdypqRByT83MnGTE8oD4/PPPr1y69NG1a9evXw/fX38PxmxYEINOJJxUH+e+ Ch2RWr3+2OOPP/bEE8M728e9Wl9fn2s2szHVoWcQ4nGai1fCx+rKyqTpuABOIJt6 Kpxc6mktdzydfWpye8Ry3zNhz4Sfw9UrV/79/ffDNvw0+nIMyWVE8/PqwNBduolw IsnCv7Va7wPw+sbGVx577PyFC6E70uOXHnAhCWeXdYVsnMTjpaWVJBwvr6YajYZ4 DOTc4sJCNYTb2nbI3VXIDaczs/rvEZLwr//f/3vv3XeXWq3e/2RCAG6ZDQu6yhsc nEjvy78bm5sXnn32wnPPVSqVXr7uaNjc3Aw9v2RkdRqPl9OpqleTiLyytrYmIQPD LrmEZGmpWq3Wwp8s5Y6PN+r18ayKGyLuzMxgTgwx+D6/ceP1H/0onEF6eZoIf6Hh FS2JBF2knwfHl5R/q9WeLX20sLDw+BNPvPy7v1vv01isPGi3261WayFNyNng6tDt CMl4ZXU1ycdra+tra0Iy0BdJuG21qqkQbmvJp9rOjFOT2wu5+/VoVFcuX/7h97/f y6udTQcN3aUPB8fU46WP1tfXX/7a1x5/8snevByHCCE5pOKF7SHWIRL/6pe/zCKx YAycXAi6YRveXi48+2ySb7dGKCcF3BGYZWoEbGxs/PM//dPCwkJvXk4RGLpLXw2O qZdLH4Uez+994xvnHnigB6/FSSQF43TO6mw9p+Sy45WVtdXVtfX1kJPDNuyH3WwO VWkZ8iNbCLdSLo9Vq2NBdVuttjVWeWfGqYmJ8OH9YfD96Ic/vHLpUm/+piyJBF3k 7RWOo5flX+l3VIVEvLP0cXIdcjrKei29FjmE5I2NjWy7sb2/ubmZzb+qZwx9lF1k WymVyiHHVlJJok12w8dYrZZG2iTY1rZSbZJrXboykn70gx9cvXKlN681NzenCAxd oRcFx9Gz8m/IQi+/8soTRj6zLSThbNaubF7rtdR6Ul1e39gJzJuJsJt92tzWTj7a 2TXMUjR5k40rDtm1XCyWyuVyCKzlLaX0ViW7Mw20WaqtpqXasSzNplfbhhwbwm2/ vxUGyD/+/d/35gJdRWDoFh0guGfltPw73ZPy78Nf/OIrv/d7PXgh8mZrUHaanLdK zanNrU9pWs5ic7udBelO+3adzq7dTvKEVHh2yBnhy8KrhP0QO8LDO9udsZ0SeN5k +TMZCZyu6VIqlW5t00mbytv3lMI/jlIqRNNsN93ZunPbTnZNttnNLL5m2TZNsNvV 2bEsxPbz+2dEhX/Sf/NXf9XoyfLIisDQFfofcM96Vv6dnJz85h/9kU4bIyxk7ywX baT5eWsnDc8hdG/dE3bSe3bb3O9O4immCfPOOyvpneH9sLy9U0mX2Anvj5XttXaU TBltly9d+vEPf9iDXoEADF0hAMM9azQaPVj6aH1t7eVXXnn8iSdivxAAcBL/5x/+ YbEnk0LLwHByAjDcm56t/fvAgw/+1z/4g9ivAgCc0Orq6v/867+enJyM/ULz8/PZ RQTAsQnAcG8a4+OnTp2K/SrVWu0b3/zmTPyYDQCc3FtvvvneO+/EfpVkTeC5ObNh wUkIwHAPyuVyrV6PPf1Vq9X67d/5nWcvXoz6KgBAF/3vv/3bdvy5CRYWFlqLi7Ff BUaYAAz3oDfl3zNnznzrj/849qsAAF108/PP//nb3+7BbFiffPxx7JeAESYAw1El qx9Vq9PxA/ArX//6w488EvtVAIDu+t6rr17/5JPYr2JNYDgJARiOqjE+PjU1la1a Gc8XHnnkv3z961FfAgCIoTfLApsLGk5CAIaj6sH453qj8Qd/+Ic9mEYSAIjh/ffe +8XPfx71JULM7kGdGUaVAAxHFTsAh/PZf/rKV17+2tfivQQAENv/+pu/qVQqUV9C ERiOTQCGI0mW/63V4laAi8XnX3xxcmqqvK1UKpVvF3sANgBwQu+8/fY7b70V9SVc BgzHJgDDkTTGx6enp+NN7djpdE6dPv30+fOHPy0cwL7BeHdg7sH8kwBA+wAbGxv/ +Hd/Nz4xEe+lBWA4Nh1lOJLY45/DyfLpCxfO3HffyZvaE4+VkQHgrjqpgzLtjs3N zWwne/5Brb337rvzzWbUo3UZMByPAAxHEjsA12q15196KV77uykjAzDyjpJm9+ji q7cWF99+882oJ9Nms7miCAz3Th8XjqRer8+cPh2p8YXFxSeefPLRL385UvvHcEgZ OdsPWyEZgJ651zR7SHm2N378gx+E02W89s2DBcej/wp3l8yAVa2empmJ1P7m5uaz zz8/NT0dqf1IdgfjOxOykAzAvnZqs4cXafc82u+jvmf//v77n9+4Ea/95uzsyspK vPZhVOmbwt3FHv9cbzQuvvhivPb7aN9gvLuMbLg1wFDbN8TeNdn2+6h7YXVl5Rdv vBHvHGcINByPfifcXdQAPIDjn3ssuyZ5TyrevVVMBuiNu2bXOyNuTtLs8UQdBW0e LDgeHUq4u6gBeGNj48LFi/HGV4+MUkpOBrirPRMa78m0h9zs94GPmvffe69582a8 9l0GDMegpwh3F3UGrGq1+vxLL4lt3bIzx/VONt69Y+g1MER259hs54ixVlV2QCzM z//y7bfjtW81YDgG/T+4i5CUxsbGIgXg0EeZOXPmqWeeidE4hwsBeN+QvG9s7vfB AkNsz4Dhg3buvFOOHQH/+uqr9UYjUuMqwHAMAjDcRdTxz6urq1995pkHHnwwUvt0 S+nIstqy8jKMjJ0y7EHbw28KsTn31r/9W7ypqsI/sE+vX4/UOIwqXTS4i7hTQBeL F194Id7vhumXu+bkrP68e19mhq7bnV33hNKj3NzZ7/f3wRC7duXKh1evRmrcPFhw DPpbcBdRA/AIL4DEvcrqxock5D37u3f6fezQNZ1ddvLnnTf33b8zwfb7u4HC+vr6 z3/603hv1C4Dhnul2wR3EW8GrNA/O33ffV99+ukYjZMfxW1ZGL7XnT37/f5uGAKd OxS2F4Pd99EjZlqRlVH1r//yL/VaLVLjLgOGe6WvA4eJOgPWyurqU08//cBDD8Vo HI5h30i8OxvfeefxHu3z9zkSdifPwq7YeZT93TcPuv8Q/fumYSi9+fOfr66sRGq8 OTu7Eq1xGEl6IXCYqOOfQ8i4+OKLtWi/FYZBtpOKu7Ld0+y+r3W8O/fkvTvj3+FP 2PfmUbZHeQIwFD768MOrly5FalwAhnslAMNhXAAMAJxE1MuAO+bBgnskAMNhogbg icnJCxcvRmocABgQ3/32t6ejdScWFxYWFxcjNQ6jRwCGw9QbjZmZmRgttxYXH3vy yUe//OUYjQMAg+Mnr71WijcRtHmw4F4IwHCgcqVSHRs7FScAr6+vn3/uudNnzsRo HAAYHO+988783FykxpvN5oqVkODIBGA4UGN8fHp6OtJFO2NjYy/81m+ZDhcARt5c s/mrd9+N17ilgOHodL7hQFEvAG5MTDz3/PORGgcABsrrr70W6bfe7Xb70+vXY7QM I0kAhgOZAQsA6ArzYMGAEIDhQI1GI9IFwEut1hNPPfXIl74Uo3EAYND87Cc/6bTb kRo3DxYcnQAMB6rX6zOnT0dpuli8+OKLof0ojQMAA+bDa9euXb4cqXGXAcPRCcCw v3K5PFatRloDqVarPf/SSzFaBgAG0Orq6ptvvBGp8ebs7MrKSqTGYcQIwLC/qBcA j09MPGsGLADIk3jzYFkJCY5OAIb9xQvAnU7n1OnTT58/H6NxAGAwff/VVxuNRoyW Q9fi+iefxGgZRo8ADPuLF4BbrdYTX/3qFx99NEbjAMBg+umPfxyiaqTGzYMFRyQA w/7iTQFtBiwAyKEPr169duVKpMYFYDgiARj2V6vXT8eZArpaq71gBiwAyJkQUP/v L34RqXETQcMRCcCwj2QK6LGxSGsgNcbHn3vhhRgtAwCDLN48WLOzs6smgoYjEIBh H1GngJ6cmjr/3HORGgcABtar3/nO1NRUjJZv3ry5troao2UYMQIw7KNarZbL5RjX AM/PzX3liScee+KJrrcMAAy4H37ve6GPEaNlSwHDEQnAsI94FeCl5eWnz59/8KGH YjQOAAyyf/vZz9bX12O0bClgOCIBGPYRLwCPjY09/9JLpVIpRuMAwCCbazZ/9e67 kRr/5OOPI7UMo0QAhn3EC8D1RuPiiy/GaBkAGHCdTudnP/5xpMYFYDgKARj2EW8R YFNAA0CexZsI2lLAcBQCMOyjXq/HWAOp0+mEXP30hQtdbxkAGArf/+53G+PjMVq2 FDAchQAM+6jV66cjBOClVuvxr371i48+2vWWAYCh8LOf/KTTbsdo2TxYcBQCMOxV LpfHxsZiVIDXVleffvbZ+8+e7XrLAMBQePvNN5darRgtGwINRyEAw17xZsDa3Nx8 9oUXpqamYjQOAAy+//j1r298+mmMljudzvVPPonRMowSARj2MgU0ABDPT3/0o0gt mwga7koAhr0EYAAgHgEY+kgAhr3irYE0MTV14bnnYrQMAAyLV7/znUjXQ7kMGO5K AIa9Iq2BND8399iTT37l8ce73jIAMERe+973xqrVGC1bCQnuSgCGvSKtgdRqtZ46 f/4LDz/c9ZYBgCHyxuuvb25uxmhZAIa7EoDhNskaSNXqTIQh0Gurq888++x91kAC gHx75623WouLMVpuzs6urKzEaBlGhgAMt2mMj09PTxeL3f+vkayB9PzzU9PTXW8Z ABgi8VZCUgGGuxKA4TamgAYAYos0EbSlgOGuBGC4jQAMAMRmJSToFwEYbhNvDaTx iYlnn38+RssAwHB5/bXXYlxvVbASEtyNAAy3qTcaMWbA6nQ6M6dPP3X+fNdbBgCG zr+++mrocsRoWQCGwwnAcJtIiwAvLi4+/uSTj375y11vGQAYOhErwObBgkMJwHCb SIsAh1PRMxcunHvwwa63DAAMnTffeGN1dTVGy81mc0UAhoMJwHBLuVIZGxuLMQR6 fX39wsWLMWrLAMDQ+dUvfzk3OxujZUsBw+EEYLgl3hTQnULhuRdeGB8fj9E4ADBc rly69PGHH8ZoWQUYDicAwy3WQAIAesNSwNAXAjDcIgADAL1hKWDoCwEYbom3CPDE 5OSFixdjtAwADKNXv/OdqampGC1bCQkOIQDDLfEWAZ6anj7/3HNdbxkAGFLf++53 I00OIgDDIQRguCXSIsA7QhJeXl6u1Wrhherj441G477775+OM+gaABgEH167ttRq hUS6srKyurwctrFP/QIwHEIAhi3lSqU6NhZpCPQhQipeXFysbcXier3RuP/s2TP3 3dfjwwAATujSb36zFILu8vJqyLqrq+GsXiz2obNtImg4hAAMWxrj41NTU6VSqd8H siUpFy8tVdNcnGXj+8+ds5IwAPTd5Q8+WF5eToJuELJu/KLuPZmdnV21FDAcQACG LfGmgO6uLBiPVatZMA4J+dwDD5w+c6bfxwUAo+aD//iPEHRXs6C7urq2ujpQQfcg zdnZFQEYDiAAw5ZhCcAH2RpKXa2O1WrZgOrw5+zZs0NxqgaAfrl6+fLy9qDlsF1f W6s3Gn0ZutwtlgKGQwzx/23ormEPwIcIJ8LW0lJ1bKwagnG1mtWNz547JxsDkBNX Ll1aSccqZ4XckHLDqXBwrnvqOksBw0EEYNgywgH4EFndeCxk40wIyGn9+L6zZyMt TggAMXx49eqtiLu2th5S7vp6OLkPdS332ARgOEge3xFgX41Go/dTQA+4nXg8llaP sxpyyMrnHnhganq630cHQL5kVdysfrsW0m2+I+7hrIQEB/F+AVtiLwI8krIZucoh GG+l5GryZ2wsJGTjqwG4J5d+85sQbG/l27DZ2NhYW3NCOYa5ZnPZSkiwHwEYEuVy uVqtqgB3XUjIC/PzlUolBONKmpMr1a2w/MCDDyojA+TEByHcpsl2PbWRbjc3NsYn JtRvY7AUMBzEOw4kBm0R4LxJpulqtSqZNB5nmTmLyvefOzcxMdHvYwRgr2tXrmTF 2pBsk0y7sbGzDeFW5baPLAUMBxGAIZHPGbCGTlJPXlgol0ohFZcrlfBnLN3ujs1n z50Lf5v9PlKAYfXRtWtru+q0IccmNjc3k4ptYlLNdhioAMNBvH9BQgAeSVlhuVxO MnL6kewlmzQqZ3c88OCDAjMwwq5evpwVZZMYu7MNQXY71m6221NTUzLtiLEUMBzE mx0kBGAyycTXITMXi1lUvs12tTm79cBDD9Xr9X4fL5AX165c2UiHFm9l142NdlqP DTfb6XYz3RkfH3c5DxkrIcG+BGBICMCcUEjOO/ulcrleq5V2YnOqlFaba7VaHw8S GBAfXr2ajStup2E2i7LBjU8/3ZkdUEmWk1ABhoN4b4WEAExfZFc1l0I/t1RKAnMp lX7eubW1v6sUHZ7+0MMPV6vVfh8+5MvVy5ezmNpubyXWdrrfzu5Kd27dTDedQmFy clKUpS9UgGFf3pEh0Wg0rIHECMjWncoCdTHE5nQnc2svubH9wE7oTp+fJe/w6INf +EKlUun3dwP35qNr13YCapZDO+1t4c7O1q3waTPdbknv76RPCFwNy8iYm5tbXlrq 91HAwPEWD4l6ozEjAMMRpBkhmV0s7CdBOkgz81bqTj/t5OutJ9y6Xdq9vzuJF4rF hx95JGTwfn9/dMe1K1e2smVIoZ0sYnayFNrZTqHZfrLZfsLWQ9v3b2b/2tKvCm1O pJMPS6dwRAIw7MtZBBL1en3m9Ol+HwVwd9nl1gsLC2EvC9vhTBZCeNhmc/+EuwrF XbI7wzOzr8/y03aIKhZ2XWp5585QSX4u6Q9nz86ty9Oz/e2HQtRMdrLAmSqkWbSQ PhQ+heTZyX7lEZ5ZLE5NTRWG9WcDeTTXbC5bCQnu4DQGhXK6iKwKMAAwMpqzsysr K/0+Chg4AjAkM2BNT08rawAAI0MFGPalxw+mgAYARo2VkGBfAjAIwADACLISEtxJ AAZrIAEAI2h+bm7JRNBwOwEYrIEEAIwgKyHBnQRgKJTL5Wqtli1vWiwWp0+dMiEW ADB0Qk9mfn4+6c8UklXLpF+4k14+7KMxPr61JxUDAIMnybpzc51d65kb7QxHoUMP RyUVAwC9tyfrho3SLhybvjuciFQMAHTLnjHMBVkXuk03HaLYCsZSMQCwn2azmXUS ioIu9JAeOfTOrVScbsNm5vTp/h4SABDV1gDmNOsq6kLfCcDQZwZRA8AICCfxubm5 QhZ0CwYww4DSyYYBJRgDwGBqNpvJSK7srCzowlDRmYYhc1swTjfh/HtKNgaArrpz 6HJB0IXhp8cMo2PnGuPCdjCemp4ulUp9PiwAGFQ745aVcyEnBGDIhT0DqpO1BNWN AciHnVqulAvo+0Le7c7GhSwgi8cADJV9I25BygXuoHcLHOZWPC7cWsDJjFwA9FI2 UDm5uqdQ2D3HckHEBe6R/itwIvsmZDVkAI5ub/22IN8CseibAtHtGWVd2E7KKskA o2135XbP4OSCcAv0g34nMCj2FJOTTUE9GWDgJLG22dxaH6hQULYFhojeJDB8QlQu ZvG4sKuqXLgtLRd2dckAONxWqbbd3qnT7sm0BbEWGAl6h8Dou7O2XNgOzOmmUyqV pmVmYFQcmGYLAi2Qd7p6APvbNzYXdifndKdYKhmeDcTQbrfn5+dDjt097/GdhdmC KAtwZHpsAF1w26jszO5Sc2FvZp6eni6menuYQH/sLclm9rwFyLQA8el7AQyQ28rO O/arP+/ez6rQBUO4oUtu5dXC3rrrIZE1+y2Y4AowyHSVAEbc+Ph4Z98HOnvv3nde sWw/mVpsZqYgYzMAdqYg3rq9Xyg9JKbuJqwC5I1+DADdsX/5escdeXvr7v2e0Lnj HlXuAZHFzrm5uXa7vWdepb1/MfveWTgsju6QSwGIRDcCgNF0l0DOLgInADkhAAMA AJALAjAAAAC5IAADAACQCwIwAAAAuSAAAwAAkAsCMAAAALkgAAMAAJALAjAAAAC5 IAADAACQCwIwAAAAuSAAAwAAkAsCMAAAALkgAAMAAJALAjAAAAC5IAADAACQCwIw AAAAuSAAAwAAkAsCMAAAALkgAAMAAJALAjAAAAC5IAADAACQCwIwAAAAuSAAAwAA kAsCMAAAALkgAAMAAJALAjAAAAC5IAADAACQCwIwAAAAuSAAAwAAkAsCMAAAALkg AAMAAJALAjAAAAC5IAADAACQCwIwAAAAuSAAAwAAkAsCMAAAALkgAAMAAJALAjAA AAC5IAADAACQCwIwAAAAuSAAAwAAkAsCMAAAALkgAAMAAJALAjAAAAC5IAADAACQ CwIwAAAAuSAAAwAAkAsCMAAAALkgAAMAAJALAjAAAAC5IAADAACQCwIwAAAAuSAA AwAAkAsCMAAAALkgAAMAAJALAjAAAAC5IAADAACQCwIwAAAAuSAAAwAAkAsCMAAA ALkgAAMAAJALAjAAAAC5IAADAACQCwIwAAAAuSAAAwAAkAsCMAAAALkgAAMAAJAL AjAAAAC5IAADAACQCwIwAAAAuSAAAwAAkAsCMAAAALkgAAMAAJALAjAAAAC5IAAD AACQCwIwAAAAuSAAAwAAkAsCMAAAALkgAAMAAJALAjAAAAC5IAADAACQCwIwAAAA uSAAAwAAkAsCMAAAALkgAAMAAJALAjAAAAC5IAADAACQCwIwAAAAuSAAAwAAkAsC MAAAALkgAAMAAJALAjAAAAC5IAADAACQCwIwAAAAuSAAAwAAkAsCMAAAALkgAAMA AJALAjAAAAC5IAADAACQCwIwAAAAuSAAAwAAkAsCMAAAALkgAAMAAJALAjAAAAC5 IAADAACQCwIwAAAAuSAAAwAAkAsCMAAAALkgAAMAAJALAjAAAAC5IAADAACQCwIw AAAAuSAAAwAAkAsCMAAAALkgAAMAAJALAjAAAAC5IAADAACQCwIwAAAAuSAAAwAA kAsCMAAAALkgAAMAAJALAjAAAAC5IAADAACQC/8fO3B23f74RIoAAAAASUVORK5CYII="/></symbol><use xlink:href="#c" width="1280" height="1280"/></g></g></svg>')} -.is2d .knight.black {background-image:url('data:image/svg+xml;base64,<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="614.635" height="614.635" viewBox="0 0 460.977 460.977"><mask id="b"><use xlink:href="#a" width="1280" height="1280" transform="rotate(.193) scale(.36014)"/></mask><symbol id="a" viewBox="0 0 1280 1280"><image width="1280" height="1280" xlink:href="data:image/png;base64, iVBORw0KGgoAAAANSUhEUgAABQAAAAUACAAAAAA9j6ArAAAACXBIWXMAAA7EAAAO xAGVKw4bAABJTklEQVR4nO3dd4BU5f228f3BsrSlFxEFsaGiQbBEbEHsigV9rYnG xK6oEWMviSaWaFRULGgsscWCDQULCHYsWEApgiBVpHcWWHZ3XkGFBbZMOefcz/N8 r88fiQVmb2b2XO7uzJzzf3kAYNT/qQcAgAoBBGAWAQRgFgEEYBYBBGAWAQRgFgEE YBYBBGAWAQRgFgEEYBYBBGAWAQRgFgEEYBYBBGAWAQRgFgEEYBYBBGAWAQRgFgEE YBYBBGAWAQRgFgEEYBYBBGAWAQRgFgEEYBYBBGAWAQRgFgEEYBYBBGAWAQRgFgEE YBYBBGAWAQRgFgEEYBYBBGAWAQRgFgEEYBYBBGAWAQRgFgEEYBYBBGAWAQRgFgEE YBYBBGAWAQRgFgEEYBYBBGAWAQRgFgEEYBYBBGAWAQRgFgEEYBYBBGAWAQRgFgEE YBYBBGAWAQRgFgEEYBYBBGAWAQRgFgEEYBYBBGAWAQRgFgEEYBYBBGAWAQRgFgEE YBYBBGAWAQRgFgEEYBYBBGAWAQRgFgEEYBYBBGAWAQRgFgEEYBYBBGAWAQRgFgEE YBYBBGAWAQRgFgEEYBYBBGAWAQRgFgEEYBYBBGAWAQRgFgEEYBYBBGAWAQRgFgEE YBYBBGAWAQRgFgEEYBYBBGAWAQRgFgEEYBYBBGAWAQRgFgEEYBYBBGAWAQRgFgEE YBYBBGAWAQRgFgEEYBYBBGAWAQRgFgEEYBYBBGAWAQRgFgEEYBYBBGAWAQRgFgEE YBYBBGAWAQRgFgEEYBYBBGAWAUTuWjz+8R1F6hFA5gggctZ6dOO8H7dfrJ4BZIwA Ilebj2nw0//O3pYCwjsEEDna6uv6a/5/9vYLxEuATBFA5Kb9iLq//NW8bSkgPEMA kZMdv6i99q/n7TBHuATIHAFELjp9WlDu7xa2p4DwCgFEDtbvHwWEbwggsrfjlwUb /BMKCK8QQGSt/M//fkUB4RMCiGxV1D8KCK8QQGSp4v5RQPiEACI7242suH8UEB4h gMhK27H1Kv13FBC+IIDIRosJDav4txQQniCAyELD75tV+e8XbsW74uADAojMFUzc vJpfMW8rzg0DDxBAZO7r31T7S2ZtxRlS4T4CiIy9fUAav2jG1itiHwLkiAAiUw+f kdYvm9K+OOYhQK4IIDLU6840f+GEHUpiHQLkjAAiM4e+nvbnzJjflMW5BMgZAURG 2o+qlf4v/nz3+IYAESCAyESdGU0y+eVD03m6BJAhgMjEF7tk9utfOD6eHUAkCCAy cP95mf6Oh8+KYwcQDQKI9B3XL/Pfc9O10e8AIkIAkbaW0zY8A346LuoT+RAgIgQQ aZuwdTa/K3ViFl83AokggEhXmu8A2UjZge9EOwSICgE0o0XJopxel3zA4Gw/WVb9 ZlwuHxiIDQE045EuD/fO4bcXzG2Q9e9dtiUnSIWTCKAVe71TsKL/tROy/v2DDsrh g8/eglPDwEUE0IjWr+/80/+Ou/aFLH//yf/L6cOP3y6n3w7EgwDaUHjzBWse6qKB d36WzU8C68yvm9uAd/bP7fcDcSCAJtQ5/abGP/9V6fCbX8viBt48JNcJD52T6y0A kSOAJhzwcLtf/7Js8v39pqUy/P0HDcp9w2W3534bQLQIoAn9jyr3N2XvXTsss99e Y17j3Dekjnsp9xsBIkUADah3wXWF5f++bOz1mT0X8sC5Ucwo3W1EFDcDRIcAGnDq jW02eJxXvXLB7PR/f+tpNSLZUbRlBh8USAABNGBUh40e5tTk3o+nfeXeLztHNGRW W66TBKcQwODVOKNvRV/ALXzykjSvWXT0K5Ft+aZjZDcFRIAABu+gh9pV+M+Lv+w7 YF46NzC7RXRjXj06utsCckYAQ1fvzX0qe5BnP3JHGgW84l9Rzrn1yihvDcgNAQxc zZMfr/wZjMXP/3va8mpuoGBRnUgHnf5YpDcH5IIABm6PRztU9a9XTvrHM1XfwCOn RzknL6+s64fR3iCQPQIYtpZ3nVj1S1hSE8+u8nSljebmRzooL694h+8jvkUgWwQw bBfdVFjdLykZcEwV//blHhGu+dmiLRZFfptAVghg0HZ9avvqf1HJm9d/Udm/a/VD NK+BXs/UrdN8AQ4QMwIYtKdOqpnGryoddlFlb1J7+4Ao5/zqsz3iuFUgYwQwZEc+ 1TCtX1f6zb/6V3jK5tbT4/kEef7EWG4WyBABDFiT17uk+0vn3/hIRe+Mi+cLwDwu lw5HEMCA/fsvtdL+tUVP3jx1o38Y1xeAP/nT43HdMpA+Ahiu1iMyeQ/bqscv3Oi7 4AHdI5yzPi4WDBcQwGAV3HFBZr9hymFj1/8HDeen8xRKllbtPLb6XwTEiwCGqtaJ dzXL8LeMOuuT9f7+iVOjm7Oxoq1nxnnzQBoIYKh2emy3TH9L6vMjyp+xtGBJQYR7 Njav3dJYbx+oFgEM1c2XZf4ettSYk0at+7sbr4lwTkWmbsv5UaFFAAPV6eV2Wfyu 1Dc9152qYH6TyNZUYuxO2VyjGIgMAQxTo4ePyeoJjNTwM379GvDYFyPcU4lP036h IhAHAhimnjc1yu43lr53/rif/+rb7aKbU6lBOV9wHcgBAQzTiI7ZPrKpwedMXv3/ UVwLPQ0DjkzkwwAVIoBBOvnpHB7Y4aetfoVelFcCqcpL/y+ZjwNUgACGqO0bVZ4G uhqpd376LrhgZWRrqtHvhKQ+ErAhAhigujdfmNNbOFLP/77sn8mdrYACQoYABqjz gNY53sKXXSdn+jaSHFBAqBDA8DS67axcH9bUhG0jmZImngmBCAEMz/H3N1dPyNTg g9ULYBMBDE6T5w/w71H9ZG/eEwIB/w4VVOP8W6u9EJyDRnfiQklIHgEMzebPd/Hy QZ28Y5F6Auzx8lhBFa6/oo56Qnbm7DBPPQHmEMDQTGmrXpCtJR0nqyfAGgIYlhqH DvD3IV3xu+HqCTDG36MFFfi/7e/dX70hB6UnvaCeAFsIYFDqXXapj08Br5W68jb1 BJhCAIPS6akOnj+iD56rXgBLPD9csL5et2V+IRDH8KYQJIgAhqThoD3UE3I3ZteN LtAOxIQAhuTim+qpJ0SgdOysmT9Omzjh+1XqJQgeAQxIs0Gdg3o8y4qLFs+fNWPK xHFjeZcIYhHUAWPdaX09fRNI9VKripbMn/PDxLFfT+CsCYgOAQxHo6e7qyckoaRo 8dwfpn43esRs9RL4jwCG4+Q+CZ7F2QGp4mULf5w07qvP5qiXwFsEMBh1Xzi0hnqD RtmKhbMmjfniI0KITBHAYLT/tLF6glhZ0bwfxn3x7mj1DviDAAajZx8ezDVSRXMm j/psyAz1DniAYyYU7Z7eSz3BLaULp436ZPB49Qw4jQCGouet9dUTXFS2eNrId17j p4OoGAEMxaCD1AscVjzr22GvfaFeAfcQwEC0Gt1UPcF1ZfO+ff+FEeoVcAoBDETP 3rXUE7xQOmfMu09/r14BVxDAQHywj3qBR1ZO+eSFN7gMJwhgKDb/lqdAMpOa+80b j3EdOusIYBBqnvaIeoKXFo18+bFF6hEQIoBBaHHvCeoJ3low4sXHl6pHQIQABmH3 F7y9GrATZr3X9x31BigQwCCcdb/31wJRWzXm5Xv5kaA5BDAIT5yqXhCEee/f+aF6 AxJFAENQ+GkH9YRQLB/+4LOcc9oOAhiCE//TQD0hIKWjn76Xa5AYQQBD8NTJRk+F GpfUxMfu5OKcFhDAEHzZiccxamVjH7qfN4sEjwMnAHW+3UI9IUilI+99nJ8Hho0A BqDbsy3VE0K16r2rh6s3IEYE0H81z7mNNwLHZ+7Tf+fdcsEigP6rdcUNPAcSp9So 255Sb0A8CGAA/n2pekHwVrzai4sshYgA+q/whUPUEwxIjb62v3oDIkcA/bfHk9uq J9iw8LFreYF0YAig/068exP1BCtKP/jL1+oNiBIB9N+xjxeqJxjyXa+B6gmIDgH0 X9fBXA8pSbP+cb96AqJCAP13Vl9eBZOsJfddx7vkwkAA/dfnfAKYtOJnLuA0+iEg gN6reVdPHsXklfQ7mwT6j0PHe7Uuu0k9wSYSGAAC6L26t16onmBVyf/O44WBfiOA 3tvkoaPUE+wigZ4jgN6r9+wRPIo6q+6+gnMG+otDx3/vdlUvsG3xXx9WT0C2CKD/ PttdvcC6aae+p56A7BBA79Uc1I1HUe3L479XT0A2OHT89/4+PIpyqVd/z7MhHuLQ 8d9XndQL8JMVV9yjnoCMEUDv1Xz2OPUErDGpB+fK8g0B9F7tf16mnoCfpV75PZdT 9wsB9F5h7zPVE/Cr5Zf0VU9AJgig9+rextlgHDLhsAnqCUgfAfTfbXwL7JKyOy5X T0DaCKD/7j2fR9Ep0w8eq56ANHHo+O+Wv3JKfLeU3c8JejxBAP134dWt1BOwgZmH 8IoYLxBA/+247cvqCdhQ6lGem/cBAQxBSj0AG/ux2zj1BFSLAIaAALqo7Pp/qieg OgQwBATQTV/vt0A9AVUjgCEggI5accJr6gmoEgEMAQF01hOnqRegKgQwBATQXVP3 mKmegMoRwBAQQIcVn/ySegIqRQBDQACd9vBZ6gWoDAEMwdQ26gWoyrd7LFZPQMUI YAgKVqoXoErLun6hnoAKEcAg8D2w48ou7qOegIoQwCCU8Ti6rt8J6gWoAAdOEIo5 IZbzvt19qXoCNkIAg7CkUL0A1Vq4x3j1BGyIAAZhYSP1AlSv5PhX1BOwAQIYhJUF 6gVIQ+qaW9QTsD4CGIKdvlEvQHoeO129AOshgCF48Gz1AqTpw65l6gkohwCGYFI7 9QKka2LHIvUErEMAA5C/kiuj+2POjnPUE7AWAQzAKU+qFyADS3fl5TDOIIABGHSQ egEyUdz1E/UE/IIABoBXAXqm9Ig31RPwMwLov7ZT1AuQobJTnlFPwBoE0H+9L1Yv QKZSF9yvnoDVCKD/Jm6lXoDMXXmregHyCGAACpbzIhgf/Y3LpjuAAHrv3AfUC5CV G69TLwAB9N+wPdULkJ1br1QvAAH03vI66gXIEgWUI4C+2+cD9QJk7R9/Vy+wjgD6 rv9R6gXI3vU3qBcYRwB9t6ihegFycMVt6gW2EUDPdRypXoCcnPugeoFpBNBzz5yk XoCcpE5+Tj3BMgLouXlN1QuQm7LunBlBhwD6bZvv1AuQq5K9hqsn2EUA/fbon9UL kLOVHb5XTzCLAPqN74BDsGTLeeoJVhFAr3E9zDDM3mKFeoJRBNBrLx6rXoBITNiO q2VKEECvLSlUL0A03ttPvcAmAuizru+qFyAqj5ypXmASAfQZl4MLCG+KUyCAHqux vEA9AZFJHfuKeoJBBNBjnAs6KCUdx6on2EMAPTauvXoBorS4zWL1BHMIoL9azuTR C8uEbdULzOEQ8td/T1MvQMQGHqFeYA0B9NfiBuoFiBrXykwYAfRW9wHqBYhc6pDB 6gm2EEBvjdhZvQDRW9lupnqCKQTQV61m8NiFaEYb3hWcIA4iX/U7Tr0AsXibt/ck iAB6ineBBOvKW9ULDCGAnrr6JvUCxKSsC6fITwwB9NSsluoFiMvSTZeqJ5hBAP10 8FvqBYjPNx3VC8wggH4au716AWJ0x6XqBVYQQC91/lK9AHFKdXtPPcEIAuilz3dV L0CslrXix4CJIIA+2moCj1vgvuQ/cYngQPLR0G7qBYjbP/6uXmACAfRQi1k8bMEr 6/y1eoIFHEkeev0w9QLEb15L3hQcPwLon7aTedQs6N9DvcAADiX/DNtTvQCJOOk5 9YLwEUDvdBypXoBkrNxkkXpC8Aigd77ZSb0ACeG1MLEjgL7pNlS9AIm5pLd6QegI oG8mb6FegMSUbDFDPSFwBNAzZz2kXoAEcaXgmBFAv9RYVKiegCTdeJ16QdgIoF8e PFu9AIkq23qyekLQCKBXNp9SQz0ByZq4jXpB0AigV7gWsD03XK9eEDIC6JOT/6de gMSVbjVVPSFgBNAjdebWV09A8sZx+YP4EECPvHqkegEUeDl0fAigP7q+q14AiVWb LFBPCBYB9Eb+7CbqCdD4tIt6QbAIoDf6HadeAJU/8OxXTAigLw54W70AMsuaFqsn BIoAeqLeLN4DZ9gLx6sXBIoAeuLDvdULIJTaZYR6QpgIoB8uvEe9AFLT26gXhIkA eqH9mJrqCdC6/gb1giARQB/k/9hcPQFivBgwFgTQB4MOUi+A3Hv7qReEiAB64Kqb 1QvggP3fUS8IEAF03z7v8yghL29WK/WCAHFoOa/ZtLrqCXACp8ePHgF0Xf6U1uoJ cENJcy6UHjUC6Lphe6oXwBVDDlQvCA4BdNzDZ6gXwB27faFeEBoC6Larb1IvgEMm b6leEBoC6LRTnuABQjk971cvCAzHl8u6vc1VMFFeUaMS9YSwEECHdRqer54AxzzK z4QjRQDdtc2o2uoJcE3ppnPUE4JCAJ3VejwXwcRG3u+qXhAUAuiq1t82UE+Ai3gp TJQIoKPoHyo2cRv1gpAQQDe1HUX/ULHfP6NeEBAC6KT2IzgBAioxv5l6QUAIoIs6 fcLzv6jUNZwfMjIE0EHd3qqlngCHLW/Iq6GjQgDdc/yzvP8DVXnoHPWCYBBA5/Ts w4OCKnFiwMhwrLnm9r+qF8B5/XuoF4SCADqm/1HqBXBf2aaz1RMCQQCdUvDZzuoJ 8MHbXCg1GgTQJa1GtlRPgBdSW01WTwgDAXTIXkPqqCfAEx/vpV4QBgLojvP78PIX pGun0eoFQSCAznjyFPUCeGRkJ/WCIBBAR9T7bEf1BHily6fqBSEggG7Y6cNG6gnw y/jt1AtCQACd0PMefvyHDB0ySL0gAATQATVe5tXPyNjULdQLAkAA9Vp/url6Anx0 1GvqBf4jgHI9nitQT4CX+BIwdwRQ7f7z1Avgq8PeVC/wHgHUavbh9uoJ8NakrdQL vEcApXo8y7nvkb0Dh6gX+I4AKj31B/UCeO279uoFviOAOm0/4tlf5GbfD9ULPEcA Zc66P189Ab77dgf1As8RQJGCAZzSErnjHcG5IYAa+wzgvb+IwOid1Av8RgAlHj6d Ox6R2OUr9QKvcRwKbPPuZuoJCAXnBcwJAUzetTdw6hdEZrvx6gU+I4BJa/JuR/UE hOS9/dQLfEYAE3b6A5z6AFFKbTJHPcFjBDBRhW/urZ6A0LxwvHqBxwhgko5/vK56 AoJT0mCFeoK/CGBy6rzKa58RgwfOVy/wFwFMzOHPFaonIEjLC8vUE7xFABOS36+H egJC9bd/qhd4iwAm4+B+DdUTEKyFTdQLvEUAk1DwUnf1BITsjEfVC3xFABNw5P/4 6R/i9ANnlswSAYwdT/4idgcPVi/wFAGM23GP11NPQPC+3lm9wFMEMF6FA3+nngAD Uu2mqif4iQDG6vT76qgnwIQBR6oX+IkAxqjZW7uqJ8AI3g+XHQIYn1631lJPgBl3 XKpe4CUCGJfNB3HBLiRnMReZyQYBjMkN19RUT4Apf3pcvcBHBDAW7d9qp54AYyZv qV7gIwIYh3t6ctUPJK3zCPUCDxHA6HV6o5V6AgwaxtnGM0cAo1bjsVO5UyFQ1nyB eoJ/OFYj1vWlpuoJMOqJ09QL/EMAI1Xw7DHqCTBrOe86zxgBjFL3ZxqoJ8Cw8/qq F3iHAEanXv8D1RNgGq+EyRgBjMzJj3DNS2h1GKte4BsCGJFGb+ypngDzBh2iXuAb AhiNc+6urZ4AlNQvVk/wDAGMAue9ghtuula9wDMEMAIX3sF5r+CEuS3UCzxDAHPW cnBH9QTgFwcOUS/wCwHM1aW35KsnAL/6fHf1Ar8QwNy0HtxBPQFYJ9WMNwRnggDm 5PKb+PIPTnn0DPUCrxDAHLQcspN6ArC+ZYXqBV4hgNnjyV846IR+6gU+IYDZavL2 LuoJwMa+3lm9wCcEMEtn3legngBUgKdBMkEAs9LwrS7qCUDFHjxXvcAjBDAbRz/D iV/gqkWN1Qs8QgAzV+PFHuoJQOUOe1O9wB8EMGOdBzdTTwCqMPy36gX+IICZuvNi 7jM4razRUvUEb3AwZ6b1+1urJwDV6H2JeoE3CGBGzu3DW9/gvHnN1Qu8QQAzkP8G Vz2CD/b9UL3AFwQwfZ2GNlFPANLx4b7qBb4ggGn7+99qqCcAaSmpW6Ke4AkCmKbC d3ZTTwDSddnt6gWeIIDpOaB/ffUEIG0Tt1Ev8AQBTEvvv3BHwSebzFYv8APHdRoK P+QMQ/DLw2epF/iBAFZvj7c5yS48s6CpeoEfCGC1rrqJOwne2fMT9QIvcGxXo8Yb B6snAJkbwov200EAq9Z6eGv1BCALq+qUqSf4gABW6aDXaqsnAFk590H1Ah8QwKrw 4z94a8yO6gU+4ACvQv+j1AuAbKWaLFJP8AABrFThl9uqJwDZu6uXeoEHCGBlthnO tWXgs5mbqhd4gABW4tBXa6knADnZ+nv1AvcRwIpdeDf3DDz31KnqBe7jMK9QnwvU C4BcLeQEvtUigBV58xD1AiB3u32hXuA8Arixgi92Uk8AIjDwCPUC5xHAjTQavZl6 AhCF5fXUC5xHADe0+Te8/AWBOOo19QLXEcAN7Di8rnoCEJGP9lEvcB0BXN+uwwrU E4CocEqY6hDA9XR9O189AYjO2f9RL3AcASyve/+a6glAhL7majZVI4DlnPwUlz5H UMrqr1BPcBsBXOesB7k3EJgrblMvcBuH/FoX3cWdgdCM7aBe4DaO+V+d+4B6ARA5 vgeuGgH8xTkPcFcgQHwPXCWO+p/9+RHuCYSI74GrxGG/xqmPc0cgSHwPXCWO+9VO fpr7AYG6pLd6gcs48H9y3PPcDQjVaE7uVgWO/Ly8bm/z+mcEq6xusXqCwwhgXsfP ufwRAsb3wFUggG3H1VFPAGLE98BVMB/AZt83VE8A4sT3wFWwHsB6k1uoJwDx4nvg yhkPYP537dQTgJhxTqzKGQ/gp79VLwDiVlrAeaErYzuAz56oXgDE70+Pqxc4y3QA b/ibegGQgGF7qxc4y3IAT3nC8p8edqzklV6VMZyALh/xBhDYcNib6gWushvAtuNr qycAyXjjcPUCV5kNYJ0fmqonAAlZ2kC9wFVmAziC10bBjs4j1AscZTWAT5yqXgAk 57mT1AscZTSAPe9VLwASNK+5eoGjbAaQJ4BhzBZT1QvcZDKALabUVU8AEtX3PPUC N1kMYI2pm6knAMma3ka9wE0WAzigu3oBkLBUw6XqCU4yGMBed6oXAIm77Hb1AifZ C2Dnz3kCBPZ8uat6gZPMBbBwBi+Kh0GrCtQLnGQugLwDBDZxQoSKWAtgnwvUCwCJ 145SL3CRsQAe/KaxPzDwi4VN1AtcZKsHDWfyCmhYxZtBKmArgPwAEHbdfbF6gYNM BfCWK9ULAJlJW6kXOMhSAPf42NKfFlhfqk6xeoJ7DCWhzqyG6gmA0Hl91QvcYyiA H+yjXgAofbyXeoF77ATw/PvUCwCp5fXUC9xjJoCtp+SrJwBavxmlXuAcMwGcyFNg sO6hc9QLnGMlgPdcqF4AqE1pp17gHCMB5BUwQF5Z7RL1BNfY6EL+nMbqCYDe6Y+p F7jGRgBf7qFeADhg6AHqBa4xEcDDB6oXAC5YwnsBNmAhgHXmFKonAE7gjDAbsBDA QQepFwBuuONS9QLHGAjg8c+rFwCOGL+deoFjwg9g4WxOggr8rLSgTD3BLeEH8N2u 6gWAM455Rb3ALcEH8NgX1QsAd/TnFWHrCT2AdebWV08A3DF7E/UCt4QewIGHqxcA DkkVFqknOCXwAB78lnoB4JSe96sXOCXsAObPbaSeADjl3W7qBU4JO4DPnqheALhl MV8TlBd0AHcdHvQfD8jCJrPVC1wSdCF+bKVeALjm+hvUC1wScgBv/6t6AeCcL3dV L3BJwAFsN7GGegLgnBW8NbScgAP4Le/7Bja202j1AoeEG8CLe6sXAC66lwuErRNs ABvOKVBPAFzEKbHKCTaAQ3m9J1CRklrqBQ4JNYAHDVIvABy19zD1AncEGsAac5qq JwCOeugc9QJ3BBrAB85VLwBcxQ8B1wkzgFt9x0sAgUqs4vnBtcIM4Jgd1AsAd3X5 VL3AGUEG8Mz/qBcADut7nnqBM0IMYJ35vNkHqNy47dULnBFiAF88Vr0AcBk/BFwr wAB2+jLAPxQQod2+UC9wRYCtmNJWvQBw230XqBe4IrwAXvEv9QLAcWM7qBe4IrgA chIEoDrFtdULXBFcAD/nfLdAdTqPUC9wRGgBvPxW9QLAfb0vUS9wRGgBLOU9cEC1 RnRWL3BEYAEcvpt6AeCBZYXqBY4IK4Ctf1AvALzQco56gRvCCuDHXdQLAC9ceod6 gRuCCmD3AeoFgB+GHqBe4IagAjiP00ADaZnbQr3ADSEF8MZr1AsAT6QKStQTnBBQ AAvn8R4QIE3Hv6Be4ISAAvjK0eoFgDeePVm9wAnhBLD1NF4DDaRr0lbqBU4IJ4Dv 76teAPiDy6OvEUwAdxgdzB8FSADnQ1gtmGrwJjggE3dcql7gglAC2P7bUP4kQCKG /1a9wAWhZOPDvdULAK8sbqRe4IJAArj51ED+IEBS6hepFzggkG7wGkAgQ3/4n3qB A8IIYH4Rz+kDmeGl0HmhBPDv16sXAL6ZuI16gQPCCOBsTm0BZIhLw+UFEsAdR6kX AP7ZYqp6gV4QAex3nHoB4J+rb1Ev0AsigEu4wguQMc4KHUYAuw1VLwA8NHsT9QK9 EALId8BAFspqlaknyIUQwJn8hwzIwv7vqBfIBRDAwsUB/CGA5N19sXqBXADtuOhu 9QLAS5/toV4gF0AABx+oXgB4aQHXkQ0ggNM3Uy8AvJTKN/8sSAABLOZECEBWDhyi XqDmfwDbTlEvADzFsyD+B/DCe9QLAE/xLIj/AXzgXPUCwFM8C+J/AAd0Vy8APMWz IP4H8Itd1AsAX5l/FsT/AE5pq14A+Mr8syD+B3B+E/UCwFfmnwXxP4ALGqsXAL4y /ywIAQTsMv8sCAEEDOvyqXqBFgEEDLvxOvUCLQIIGDbE+LmU/A/gj63UCwBvTW+j XqDlfwAnbK1eAHjL+tXR/Q/gJ9ZfyQTkoOUc9QIp/wP4zEnqBYC/znpYvUDK/wBe 9w/1AsBfT52qXiDlfwC7fKxeAPhr1G/UC6T8D2CNEv//DIDK4kbqBVIBxGOh7UcQ yIXxN8MFEECeBgayt9976gVKAQTw5qvUCwB/3XqleoFSAAFsN0m9APCX7TfDBRDA vCWF6gWAt6a0Uy9QCiGA7+ynXgB4a0Vd9QKlEAJ4XD/1AsBfdVeoFwiFEMC84lrq BYC3DhmkXiAURADf31e9APCW6aeBgwhg13fVCwBvDT1AvUAoiAByaUwga1O3UC8Q CiOAt/9VvQDwlemngcMIYJ2lNdUTAF9Zfho4jADmDTxcvQDwVffX1Qt0AglgqxmB /EGAxP37cvUCnVC68W5X9QLAU5afBg4lgG0nh/InARI2eUv1Ap1gsvH6YeoFgSv9 7vkOx6lHIA7LDJ9NJJgANpvFE8HxmTvs0dfK8r7srN6BOKRqqBfoBBPAvL7nqBcE atmo/n0XrPmreU3FUxCPnUarF8iEE8Aaiwx/IR+XFeNe7zt17d+VGv5KIWgX9VEv kAkngHmnPKleEJZlYwf/d3z5f9B+nGoK4vXEaeoFMgEFMO/zXdULQpFaMOr1x2Zv +E8v7q3Ygvh9Zve6YiEFsMWMfPWEAKya9tlL/Ysr+jfPH5/0FiRj5qbqBTIhBTDv 8lvVC/xWNnf00GcnVPqvR3dIcAsStLKOeoFMUAHkEM1aavH4D18YVvWvWVo/mS1I nN3TIYQVwFZTOTl+5pZO+WzAgAq/6V1PvWUJbIHE/u+oF6iEFcC8sx5SL/BKatH3 w994o/r2rfH7p+MdA53rb1AvUAksgHlDu6kXeKJ03viPB35QlsHveOLU2MZA7JVj 1AtUQgtgwUzOjl+d5TNGffjq+Op/3QbG7BDDFjjh653VC1RCC2Bex694u0KlSuZN /GLI4KLsfvOyetGOgTvmtFQvUAkugHmX/lu9wEWpRVO/+eC1GTncQrO5kY2Ba4pr qxeohBdATo+/gaIZY4a98XXON9Przgi2wFH5peoFIgEGsMaUzdUTHLFi5vjh73yQ 5pO81Xlnv2huBy767XD1ApEAA5jXcrLl6/ytsWrexM/fyfaHfRXjXFgh63WXeoFI iAHM22OY4SdClk79+t2cfthXMV4GHbTHTlcvEAkygFZfD1005pNBb0X0He+GTn8k ntuFEz7aR71AJMwA5vW+OOIbLC0pLk7l5RXk13b1zPuzbnqgJMabH9A9xhuH2pR2 6gUigQYwwmskLZoy5uPPRi5f+/e1Oh6wR+c2jp14a+Wzf1kU70eY2yze24eU2esi hRrAvFE7RnAj8z5+/sWKn0k4tFdXd146Ne+umzN5T1s2Wmx0elSEpMzVb2ziFmwA Cya0yfEWpr9w85wq/nWNXtc1yvEjRGPyZS/E/0Gu/3v8HwNCbaarF2gEG8C8hpNy ed3Gslcvr/4z4p4L9Hff6J7vJfFhRnZM4qNA5qTn1As09EdwbFpNyPoEntP/8Z+0 ft3hr2q/c0h9emZCFzQs5kSLYbvlavUCjYADmLfd1wVZ/b5xZ36Y7i897b9ZfYSI fHJa5ud0yU63oQl9IIj0O0G9QCPkAObt9V4WT9ZO+mPa+fvJ9M0y/wgR+fyPYxP7 WC+ZPV+cFVYvDBd0APO6Dsn0W9QFPZ/J6Nfff16GHyAqY05I6JvfNRY0TvCDQWDq FuoFGmEHMO/g1zMqYOk9l2T4AUTfG845q3+SH45LogdvsRsvaUhc4AHMO/KVDN4W /PnhVb3upUL5qzL9HRFY8Y9bkv2Aj1h9p6gdpY69tD8poQcw7+iX0/0jLj/nySxu f1XynzivnZD0RQznNE/4AyJxdVaqF0gEH8C8459N72vATw9enM3NJ36x3Jk9Pk34 I/IdsAVdEv+0ckL4Aczr3j+NnwOWXJblCdGWJPsmytI7L0/0463x1B+S/5hIWM/7 1QskDAQwr9ugar9NnfS7bN8JlGwAZ3SdkOSH+8WihoIPimTde6F6gYSFAObt8UHV 72NI3X9B1red5LfAqSf+lNwHW4dXQVvwus3znZkIYF6nT6o6dcvK/zcw+5tO8D1i y44ZnNjHKo+rgVjwjc13e9sIYN52X1T+hdrk32b84pdyShM7+/7ovbJ6liZn+cuN vkLClpmbqhdIGAlgXqvRlZ0b5tmTc7nd2om9IuWRM5P6SBu4+ibRB0aSjJ4S1UoA 8xp+07aif1x61mM53ewen+T029OW+kufZD7QxqZxlVELjL4S2kwA8wqGV/BDjiX7 5HjF8J735vb701Ry5JuJfJwK7PSN6iMjUTavjW4ngHl5Q/bf8J+M3z3XH6v1PSfH G0jLij1HJPFhKvT2AbIPjSRtb/Ll7pYCmPfon9f/+wjOgTZsz5xvonrLOn6fwEep WJ2lVq8WYc3xCVxZwT2mAph36W3l/rypv/bO/RZnbpL7bVRnSQfh9Rpuu0z3sZGk a25WL1CwFcC87q+s/VFv8RFRvKougZcBFu0wNfaPUTneBWKF7GUGUsYCmLfDZ788 2z9vlyiy0vqHCG6kait+o3j3269Of0T4wZGkQYeoFyhYC2Beo2/WXC7zm99G8gK+ XndGcStVKd51VNwfoiq8BsaMkZ3UCxTMBTCvxuD980pfOCmaG3vtiGhup1Ilew2P +SNU6aBByo+OJE3P9ULaXrIXwLy8my//3bCIbmpKha+ujk5Zd9nr/9YY11764ZEg myfFtxjAvHaTo7qlkphfI3LWw/HefjWSep8LHLAqu4vIes5kACMTdyD+8fd4b786 I22eIcSmVGKn9XAJAcxFzBfFfOK0WG++WnwBaEqDpeoFAgQwF6N2jPPW3+8a562n YXQH8QAkaZev1AsECGAuVsb5Y5NJ25TFeOtp6PKx9uMjWSf0Uy8QIIA56BTnfzIX tdWc/3SdCVuLByBRl92uXiBAAHMQ548Ai3fQnQDhZz1eFg9AsvpcpF4gQABzMH7b 2G667FDN9T/KSeI8D3BIBCdH8g8BzEGMrwI8r29sN52mC+9RL0Cy3ttPvUCAAGbv 6Fdiu+m7esV202nKX1RPPQHJMnldOAKYvf5HxXXLbxwe1y2nbcOTxyJ4U7dQLxAg gNmb2yymGx4T68sL09LqB5PvCzBtQWUXTgwZAcxai9kx3fCctolda7NSw3dTL0DS llv8oQcBzNotV8Zzu8u2iqus6TvyVfUCJM7khTEJYNa+3S6Wm13VeXQst5uR+U3U C5A4k2dDIIDZyl8Zy+dL2cFD4rjZzPS5QL0AAgWr1AuSRwCzddp/47jV1B+eieNm M7PVdxa/FsDm8V/hxjkEMFvv7xvHrV7UJ45bzRDngbZpT4OnPyOA2VoWx3NmV94a w41mKv4rPcFJFi+NTgCztOvnMdzoDdfHcKOZavZj/Nc6hosuuE+9IHkEMEv/Ozn6 23Sif3lfdlYvgIb6CgwKBDBLs1tEfpNX3xL5TWah573qBRB54Hz1guQRwOy0jvwJ s9SFTnwDwjfAdj0X0dWyfUIAs3PPhRHfYNlJbpyQnOuA2DXoEPWC5BHA7ER9RfQV B0R1rfbcXG/wx0D4xSd7qhckjwBmpdGCaO+4mTvr3/+72nZjeAm0XRZPCEgAsxLx F0pDDymJ9PayVeOHVuoJ0Bkfz7vbnUYAsxLpeyVKe7nw9o/V+h2nXgAhi2dEJYDZ KFgR4f02+aAJ0d1YTk7+n3oBlGZuql6QPAKYjYvujuymSm+5LrLbylHLaXFe5x3O m9dcvSB5BDAbCxpHdUsfHevGsx+rTWqnXgCpxY3UC5JHALOw14cR3W2Tfu/Q+Tfi eHMffFJUX70geQQwCxF9ATjp/DcjuZ1o/P5p9QKIFddWL0geAczcyz0iuJHUFxc6 9NVfXl7bCbwFzroSg58CBDBjbSfnfqfNf/5vcyKYEp38H1qqJ0CtrKZ6QfIIYMb+ fWaO3wHPH3TL19FMic6He6sXQM7iVZEIYBYa/blHx8bZ3XNLvnvtfnee913rtsvU C+AAgzUw+EeORv6BR3TZqmEG3zOULZ05/PVXiuJblIMeL/F5gJ8+qUvVCxLHJ35O Wuy/5zabN9+sil+RWrl84ewfJw1/b0ZiozLWfpTBn35jY40WqxckjgBGoKofnZQl tiJrhdMie103vNZkoXpB4gggvjV4EhBUxOCFgQmgea8crV4AR7Sdpl6QOAJo3Q1/ Uy+AK3b4Vr0gcQTQuBOf4VMAvyCAMKbzcIOv/kclfjtcvSBxBNC0FpPrqSfAHXu7 cWWuJBFAy+pM4R3AWOcwl05PlAwCaBkvgEF53V9XL0gcATRsaDf1AjiFAMKQR05X L4BbCCDsiPjaxvAfAYQZZz2kXgDX7PeeekHiCKBR3V/joccGeBkMjNj1U14AjQ3x QmjYsM0ogxcAQ3U6jVQvSBwBtKjlxEL1BDiI9wLDgoaTmqonwEUEEAYUfF/VOfxh 17YT1AsSRwDNqTG2vXoC3MQZoRG+LzurF8BRmzh4xdaYEUBr3t9XvQCuqrNSvSBx BNCYgYerF8BZBmtg8I9s2jMnqRfAWamqru8aKAJoyn/OVC+Au8oMvjuIAFrS+2L1 AjispJZ6QfIIoCE3XqNeAJcVG3x/JAG046qb1QvgtOUGr5BFAM246G71ArhtSUP1 guQRQCt63qteAMfNb6ZekDwCaMQ5D/BQo2qzWqkXJI+jwobTHuORRjWmtFMvSB6H hQmnPs4DjeqM2VG9IHkcFxYc/xyPM6r1yZ7qBcnjwDCgx0s8zKjeW4eqFySPIyN8 R79k8D2eyNwzv1cvSB4BDN7Bb9A/pKPPReoFySOAoTv4dYNvcUc2/vZP9YLkEcDA 0T+k6+z/qBckjwCGjf4hbUcMVC9IHgEMGv1D+jqPUC9IHgEMWdch9A9pa7JQvSB5 BDBgXd/OV0+APyyeEZ8ABoz+IROrCtQLBAhgsOgfMrK4kXqBAAEMFf1DZmZspl4g QAADRf+QIYsngyGAgaJ/yNT7XdULBAhgkHj9HzL23EnqBQIEMET0D5m741L1AgEC GCD6hyxccJ96gQABDA/9QzYOGaReIEAAg3P4q/QPWWg+T71AgACGhvM/IytlJv+7 SQADQ/+QnaL66gUKBDAs9A9Z+rG1eoECAQzKcc/RP2RnZCf1AgUCGBKu/4usvXaU eoECB0xA6B+yd1cv9QIFjphw/P4pHk1k7ayH1QsUOGSCcerjPJjInsUrghDAcNA/ 5CS/VL1AgYMmEKc/zEOJHKyso14gwVEThnMe4JFELmy+DJAAhoH+IUef7aFeIMFx EwL6h1w9cZp6gQQHTgDoH3L2l3vUCyQ4cvxH/5C7nb9WL5Dg0PEe/UPuUvll6gkS HDu+o3+IwPJ66gUaHDyeo3+IwrS26gUaHD1+o3+IxDv7qxdocPh4jf4hGv++XL1A g+PHZ/QPETl4sHqBBgeQx856kIcP0ahdrF6gwRHkL87/gqgsK1QvEOEQ8hb9Q2S+ a69eIMIx5KuTn+axQ1RePVq9QISDyFNc/wMRuvJW9QIRjiI/0T9Eyeg7gQmgp7j+ OaJUVlO9QIUA+oj+IVKzWqkXqBBADx35Cv1DlN7tpl6gQgD9c8BbZr9hQTxuuF69 QIUAeqfLB/nqCQjMTqPVC1QIoG86fVZLPQGBKbH7KUUAPbPjlwXqCQjNjM3UC2QI oF+2+cbm9asRp0GHqBfIEECvtB1r9MzliJPZ94EQQL+0/raBegIC1Ga6eoEMAfRI i/GN1RMQIKsXRFqNAPqj0cRm6gkI0chO6gU6BNAb9b7fRD0BQep9iXqBDgH0RcF3 Ri9ciLj9ZpR6gQ4B9ESN0durJyBMqyy/spQAeuLzXdULECizp8NfjQD64Z391AsQ qkfPUC8QIoBe6HecegGCdeAQ9QIhAuiDB85VL0CwDJ8JIY8AeuH6v6sXIFzjt1Mv UCKA7jv/PvUCBKzPReoFSgTQeVwADnHafpx6gRLHluv2eY8LgCA+lt8InEcAnbfD SNM/o0bcPttDvUCKALqt1UTb/4FG3K6+Rb1AigA6rXBKU/UEhK35PPUCKQLosvyJ nAABsZrXXL1AiwC67LPd1QsQuH4nqBdoEUCHvXisegFCt+cn6gVaBNBdt12mXoDQ rairXiBGAJ117gPqBQjesL3VC8QIoKsOfpPHBnE7+z/qBWIcZI5qP4oXQCNuZbVL 1BPECKCbGk1tqJ6A8Jk+GfQaBNBJ+d+3UU+AATddq16gRgCd9HEX9QIYkGqySD1B jQC66GHLV2lAYiZtpV4gRwAd1PNe9QKYwHfABNBBnAEQieA7YALooFaT6qgnwAS+ AyaA7imYuol6AmzgO2AC6J5he6oXwAa+A84jgM7pfbF6AYyYuI16gQMIoFuOf169 AFZceod6gQMIoFPaj85XT4ARJXWtvw94NQLokoKZTdQTYIX5M2GtQQBdwjvgkJju r6sXuIAAOuTmq9QLYMayQvUCJxBAdxz0Fo8GkvL8ieoFTuCQc0az6bwDBInZdoJ6 gRMIoDO+42VZSMzULdQL3EAAXdH3HPUCGHJJb/UCNxBARxw+gIcCiSmuW6ae4AaO Ojc0+cH6BVqRpAFHqhc4ggC6YXQH9QJYst149QJHEEAn3HKlegEsmdJOvcAVBNAF Hb/iHNBIUK+71AtcQQAdUGN2M/UEWLKyHk+B/IIAOuClY9QLYMrTp6gXOIMA6vV4 Wb0ApqRazFNPcAYBlKs3u756Akz5lJMOrUUA5Ybsr14AW7p8ql7gDgKodlw/9QLY Mr2NeoFDCKBYvbm8BQSJuuA+9QKHEECxod3UC2BLET9yLocAah0+UL0AxtzVS73A JQRQqsb8RuoJsGVVYbF6gksIoNQTp6oXwJin+JQrjwAq7fQ19z8SVdZ0kXqCUzgA lSa1Uy+AMW8crl7gFgIodNHd6gUwJtV2unqCWwigTp0FXAYOyfp4L/UCxxBAnZd7 qBfAmNT2nAl6fQRQhmdAkLRP9lQvcA3HoMzY7dULYAxfAG6EAKoc+6J6AazhC8CN EECVOc3VC2AMXwBujACKXPtP9QJYwxeAGyOAGvlLeAkMkpVqP0E9wT0EUKPvOeoF sGbIgeoFDiKAEvUW1lJPgDFlreaoJziIAEo8c5J6Aax5js+5ChBAhWazaqonwJhV jYvUE1xEABVePVK9ANb0uUi9wEkEUKDJ3BrqCTCmqFGJeoKTCKBAv+PUC2DNpXeo F7iJACav0Tx+AohkzdxUvcBRBDB5T/1BvQDWHDxYvcBRBDBxBUt5DSCS9cVu6gWu IoCJu5PrsiJZZVtOVU9wFQFM3NL66gUwhtdAV4oAJu3i3uoFMGZFkxXqCc4igEmb uYl6AYzpdZd6gbsIYMK6DVUvgDFTt1AvcBgBTNjnu6oXwJbULiPUExxGAJPVYhb3 OBI18Aj1ApdxOCbryVPUC2DLyuZL1RNcRgCTVVRXvQC2XHa7eoHTCGCiTn1CvQC2 TN5SvcBtBDBRY3ZQL4ApqR3GqSe4jQAmqeVM7m8k6ZEz1QscxwGZpEf/rF4AUxY0 L1NPcBwBTNKCxuoFMIWzYFWHACZoj0/UC2DK2wepFziPACbo9cPUC2DJ8uZcCK46 BDBBy+uoF8CSP/xPvcB9BDA5x/VTL4AlH++lXuABApicD/ZRL4AhKzdZpJ7gAQKY nJUF6gUw5KyH1Qt8QAATc/zz6gUwhOsgpYUAJobvgJGc4lYL1BO8QAATw3PASM6f Hlcv8AMBTMpeH6kXwI4Pfqde4AkCmJR+x6kXwIyiFrwEOj0EMCnzmqoXwIyjXlMv 8AUBTEirH9ULYMarR6sXeIMAJuTGa9QLYMX8TUrUE7xBABPyzU7qBTAitetX6gn+ IIAJKa6lXgAj/nWVeoFHCGAyDnhbvQBGjO2gXuATApgMrgeMZBS3nqee4BMCmIxJ 7dQLYAMnAcwIAUxGSU31Apjw0v9TL/ALAUwEPwJEIma04TJwGSGAieB6mEhCydZT 1RM8QwATMa69egEsOP0x9QLfEMBErKitXgADXjlGvcA7BDAJ7SapF8CAmZvxA8BM EcAkXPcP9QKEr2TbyeoJ/iGASRiyv3oBwnfGo+oFHiKASfixlXoBgjfgSPUCHxHA JPAyaMRtVmt+AJgFApiAjiPVCxC6ku2+V0/wEgFMwN+vVy9A6HgFYHYIYAJeP0y9 AIF78o/qBZ4igAngVDCI1/jt1At8RQATwCXREatlmy1ST/AVAYxfvWXqBQha2V6f qid4iwDG7/CB6gUI2hW3qRf4iwDG719XqBcgZG8crl7gMQIYv7cOVi9AwDgHai4I YPwmbK1egHAVbzFTPcFnBDB+ixqqFyBYqSP5CXMuCGD8eCcwYnP7ZeoFfiOAsWu0 UL0AwfpwX/UCzxHA2B38lnoBQjWzTYl6gucIYOyuvkm9AIFa2Y4nQHJEAGP31B/U CxCm1EFD1BO8RwBj93EX9QKE6epb1Av8RwBjN6WtegGC9OrR6gUBIICxW9xAvQAh mriNekEICGDsVuWrFyBAnAIrEgQwdin1AASobLev1BOCQADjtvk09QIE6Oz/qBeE gQDGjddBI3qPnKleEAgCGLcL71EvQHC+2E29IBQEMG539lIvQGjmbF6snhAKAhi3 fsepFyAwxVtPV08IBgGM24d7qxcgLKlDBqsnhIMAxm10B/UChOVv/1QvCAgBjBvv hEOk3tlfvSAkBDBuc5qrFyAkc1qqFwSFAMZtSaF6AQJS0mSpekJQCGDcVhaoFyAg 249TLwgLAYxbaQ31AoSDd8BFjADGjXMhIDLHv6BeEBoCGLMm89ULEIy+56kXBIcA xqzjSPUChGIsLymNHAGMWbeh6gUIxPJNOQVq5AhgzI59Ub0AYeAdcHEggDE7/RH1 AoTh7ovVC0JEAGP219vVCxCE79qrFwSJAMbshr+pFyAExW1mqycEiQDGrDffuCAC pz6lXhAmAhizh89QL0AABh2iXhAoAhizZ09UL4D/ljTnHPjxIIAxe7mHegH8d+AQ 9YJQEcCYDTxcvQDee55vI+JCAGM2+ED1AvhuSdMS9YRgEcCYvb+vegF8d9Rr6gXh IoAxG7GzegE8995+6gUBI4Ax+3Y79QL4raTlAvWEgBHAmE1qp14Av93VS70gZAQw ZjM2VS+A1xY1LVNPCBkBjNksrmKIXPS8X70gaAQwZvOaqhfAZ/ObqReEjQDGbGEj 9QL47C/3qBeEjQDGbHED9QJ4bEVd9YLAEcCYLa2vXgCPPXWqekHgCGDMltdRL4DH Np2pXhA4AhizFbXVC+CvGZupF4SOAMZsZYF6Afx13wXqBaEjgDErrqVeAH9tP069 IHQEMGar8tUL4C2eA44dAYwZAUTWvumoXhA8AhgzAoisPXGaekHwCGDMSmqqF8Bb f3pcvSB4BDBmBBBZazNdvSB4BDBmpTXUC+CrFJ87sSOAMSOAyNbyeuoF4SOAMeO9 wMjW3BbqBeEjgDGb01y9AL6avKV6QfgIYMw4ISqyNbKTekH4CGDMFjRWL4CvPt5L vSB8BDBmBBDZemd/9YLwEcCYcUp8ZGvgEeoF4SOAMVtSqF4AX71yjHpB+AhgzAgg skUA40cAY0YAka2Xj1UvCB8BjBkBRLb4CjB+BDBmBBDZIoDxI4AxI4DIFs8Cx48A xowAIltvHapeED4CGL3N99596yM4ETSiUTJg4vCPODFgTAhghOrt/bvO27Yq5ARY iFrZ0pnfffX+R0XqHcEhgNHodNheHVrXUa9A4FbMGDPsjRHqFSEhgDlrctyRu2zK V31IStmPX772wgL1ikAQwJzkn3rqbg3UI2DQks+ffLJEPSIABDB77S/q3pav/KBS NnXgPePVI3xHALNU76o/b6beAPN+eOwWnhjJBQHMyqmXdORrP7ig7Os7n1Rv8BgB zFz+P89vqN4ArLX4/uv4cWCWCGDGep/Ly13glhV9e6kneIoAZujaq+uqJwAbWX7z jeoJXiKAGTnoiVbqCUCFZv5xsHqChwhgJl49gvsLrkoNOEo9wT8c0Onr+gpXeIPL FvZ4Tz3BNwQwbddeX1M9AahS6fX8JDAzBDBdAw/jvoLrUm90V0/wCwd1ehqNaKee AKRhcqdF6gk+IYBp2eZLTnkAPyzZZYJ6gkcIYDq2+YoT28MXSztTwLQRwDTQP/iE AqaPAFZvmxH11ROADCzrRAHTRACr1WQqX//BL0vbcsbo9BDA6hz6bCP1BCBDi056 Uz3BDwSwOkWc/AD+WV5PvcAPBLAaX3VSLwCyMKKzeoEXCGDVevbhHoKPUhfep57g Aw7vKhUsraWeAGRlVWGxeoIHCGCVxm+rXgBk6bv26gUeIIBV+eu/uX/gq9Rld6gn uI8DvAqN5vANMPy1qgXnRagOAazCmB3UC4AcjO2gXuA8Ali57q9y7V/4rOyogeoJ riOAlVvIW0Dgt0VcxKEaBLBS//4rdw78lrrjMvUEx3GMV6qYZ0Dgu1UF6gWOI4CV +biLegGQs0/2VC9wGwGsRL0lPAMC/5U1KFJPcBoBrMSkduoFQAQmb6le4DQCWLG9 PuALQISgbN9h6gkuI4AV4yUwCAQvhakKAazQxXdyxyAMqUvuUk9wGMd5hZZwGRCE YinXtK4cAazIVTdxvyAUqWtuUU9wFwd6RRbwYxOEY2ET9QJ3EcAKnPIEdwvCkfrj U+oJzuJIr8BoziKEkIzZUb3AWQRwY43m8xpAhKSsKWdGrQQB3Fjfs7lXEJLUQ+eq J7iKQ31jpXwBiLCU1VQvcBUB3Ej/o9QLgIi9erR6gaMI4Ebm86IBhGZBU/UCRxHA jZTw7QJCU5qvXuAoArgRfgSI4PBDwEoQwA2921W9AIjce/upF7iJAG6IE2EhQJwU q2IEcEP8CBAB4oeAFSOAG+JHgAgQPwSsGAHcQL/j1AuAGLxwvHqBkwjgBmZsql4A xODH1uoFTiKAG+By6AgSl0ivEAHcAD8CRJD4IWCFCOD6Gi7kHkGIUo0Xqye4iMN9 fUO7qRcAsXiXT+0KEMD1cSYEBIrzIVSEAK5vFa8XRZhKeHqvAgRwfTwHgkDxLEhF COD6CCACRQArQgDX8/ph6gVATN44XL3AQQRwPXObqRcAMZnPJ/fGCOB6eB8IgsV7 QSpAANfDjwARLH4IWAECuJ4y7g+EKsV/3TfGAV/evedzfyBY912gXuAeDvjyxm6v XgDE5tsd1AvcQwDLW9xAvQCIzZKG6gXuIYDl8UY4BIw3w22MAJbHk8AIGM+CbIwA ltNhFHcHwpXaaYx6gnM44st5+wD1AiBGQw5UL3AOASyHCyIhaDP5BN8QASxnRW31 AiBGK+uoFziHAJZTwnuFEDLeDLcRArhOk3ncGwhZqtkC9QTXcMiv8+dHuDcQstQZ j6knuIZDfp0RO6sXALEa2Um9wDUEcB2uCIfALeRTfAMEcB3OhorAcU7UDRHAdeZx 4VSEjWsDb4gArsNXgAgcXwFuiACuw6kQEDheCLghArgOAUTgCOCGCOBa/7qcOwNh S912pXqCYzjm1xrIdaMRute7qxc4hgCuxQVBEDwuC7IBArgWr4NG8Hgl9AYI4Fpc EATBK+WTfH0EcC2eBEbweBp4AwRwLQKI4BHADRDAX910FfcFQpf619XqCW7hoP/V Sz24LxC8l49VL3ALB/2vvuysXgDEbgSf5ushgL/iknAwgAvDrY8A/qqornoBELvl 9dQL3EIAf8WTwDCAp4HXRwB/RQBhAAFcHwH8xXn3cVcgfKkL7ldPcApH/S8eOIe7 AuFLPXieeoJTOOp/MfgA7goYMORA9QKncNT/YnQH9QIgAWP5RC+PAP5idgv1AiAB c/lEL48A/mIl18uCBcW11QucQgB/watgYAKvg1kPAfwFAYQJBHA9BPBnZ/flnoAF qXMfUk9wCYf9z+66iHsCFqTuvUg9wSUc9j8bcDj3BCxIvcGVMcvhsP/ZuPbqBUAi vuNTvRwC+DOuiQkjuDJmeQTwZ7wMEEas4lO9HAL4M14FAyN4HUx5BPBnBBBGEMDy CODPCCCMIIDlEcA1bryaOwI2pG65Rj3BIRz3aww6kDsCNqSGHKSe4BCO+zUmbK1e ACTkez7Z1yGAayxorF4AJIQXApZDANdYwUnSYAVnBCyHAK5RwjNjsKI0X73AIQRw DV4FAzN4HUw5BHANvgKEGQSwHAK4Bl8BwgwCWA4BXK3XHdwPsCJ16Z3qCe7gwF/t v3/kfoAVqSdPU09wBwf+ah/tyf0AMz7eS73AHRz4q01to14AJGY6n+5rEcDVltZX LwASU8Sn+1oEcDVeBQNDeBp4HQK4Gq+CgSEEcB0C+JPL/8XdADtSV92qnuAMjvyf PPkH7gbYkfrfKeoJzuDIX63PTm1b1OfbYIQvtXTu1FEXqFe4gwCuc85u27VtXo97 BCFKFc2b+u3nD6pnuIbDfSPn7N6+TQs6iECkiuZOGz+8r3qGozjOK3PW7tu1ac73 xfBWWdGc6eOGP6Se4TYCWJ3bOrdp2YBTSMIfpUtmT/vqMvUKPxDANF2125abNq7N 3QV3pVYu+nHS5zerZ3iFIzozp+++TZsWDWqpZwDlrFoyZ/qE4Y+oZ/iIAGbn3N9u tXmzQr4zhlLJsrk/TBz+gHqGzwhgbs7co91mzRvwrTESlCpePO+HSZ8+rN4RAo7c iFy05+abNimsxf2J2KxaOn/mtE/uVs8ICgds1P7SZbNNmhbyNSEiklq5dP6sGR/T vVhwnMbm5D03b928cf0CXkqIzKVWFi2YO2P6x8+ohwSOACbg2C6bt27ZpLAOz5mg aiUrli6Y88MPn7yoHmIGAUzW8Xtv0qp5owZ1a/F1IX6WKl6+dOHcmbM+6qdeYhEB 1Dnmd5u0bNqksF5BTR4FW1KlxcuXLJw/a9b7L6unWMeh54ge+zdv3rRRYb3a+Zyu N0SlJSuLli6eN3fu0FfUU1AOAXTSIQc0ad6kcWH9egW1avAQ+ShVtuqnb22XLlww d8HQN9VjUCmOLi8cemijJo0aNqhXt3Z+PkV0UKqspGTl8qIlixctWPQmwfMHB5On uh1dv1HjBoX16tSpVSufHyImKlVaWrxqxYqipUsXLFrW/x31HOSAIycgux9f96cv E+vWrVundkGtWjVr8LVijlJlZaWrVhWvXLF8+fKfvrhb3m+4ehEixiFiwE5/LCis V79+nTp1ateuVVCrZv5PaeSB/1VqdeZKfupc8crlK1YsW1a0tPiJUepRSAjHgXHt /pRfv169erXr1q7905eNBbXy82v+9KXjT4EM5TMjtTpwZaWlJSWrin/6Ym7lyuUr i4qKlpX8d7J6GRwQyqc5fNCsmn8/L5EVwFoEEIBZBBCAWQQQgFkEEIBZBBCAWQQQ gFkEEIBZBBCAWQQQgFkEEIBZBBCAWQQQgFkEEIBZBBCAWQQQgFkEEIBZBBCAWQQQ gFkEEIBZBBCAWQQQgFkEEIBZBBCAWQQQgFkEEIBZBBCAWQQQgFkEEIBZBBCAWQQQ gFkEEIBZBBCAWQQQgFkEEIBZBBCAWQQQgFkEEIBZBBCAWQQQgFkEEIBZBBCAWQQQ gFkEEIBZBBCAWQQQgFkEEIBZBBCAWQQQgFkEEIBZBBCAWQQQgFkEEIBZBBCAWQQQ gFkEEIBZBBCAWQQQgFkEEIBZBBCAWQQQgFkEEIBZBBCAWQQQgFkEEIBZBBCAWQQQ gFkEEIBZBBCAWQQQgFkEEIBZBBCAWQQQgFkEEIBZBBCAWQQQgFkEEIBZBBCAWQQQ gFkEEIBZBBCAWQQQgFkEEIBZBBCAWQQQgFkEEIBZBBCAWQQQgFkEEIBZBBCAWQQQ gFkEEIBZBBCAWQQQgFkEEIBZBBCAWQQQgFkEEIBZBBCAWQQQgFkEEIBZBBCAWQQQ gFkEEIBZBBCAWQQQgFkEEIBZBBCAWQQQgFkEEIBZBBCAWQQQgFkEEIBZBBCAWQQQ gFkEEIBZBBCAWQQQgFkEEIBZBBCAWQQQgFkEEIBZBBCAWQQQgFkEEIBZBBCAWQQQ gFkEEIBZ/x8scL61A2PdwgAAAABJRU5ErkJggg=="/></symbol><g mask="url(#b)"><g transform="rotate(.193) scale(.36014)"><symbol id="c" viewBox="0 0 1280 1280"><image width="1280" height="1280" xlink:href="data:image/png;base64, iVBORw0KGgoAAAANSUhEUgAABQAAAAUACAIAAACXhmigAAAACXBIWXMAAA7EAAAO xAGVKw4bAAD6FElEQVR4nOzdiZ9TVZ7//yKVfa2iAFFREQSlcQNRXLDdWu12V1yx 7db+177f7unp/k1/p6fnO/Od7hkRQUBANkHZl6KW1JJKUqkkN7nb7yRRmoYCUsk9 d8l9PR89DGByzqkUlTrvOud8zqI+AAAAAAB8YJHTAwAAAAAAwA4EYAAAAACALxCA AQAAAAC+QAAGAAAAAPgCARgAAAAA4AsEYAAAAACALxCAAQAAAAC+QAAGAAAAAPgC ARgAAAAA4AsEYAAAAACALxCAAQAAAAC+QAAGAAAAAPgCARgAAAAA4AsEYAAAAACA LxCAAQAAAAC+QAAGAAAAAPgCARgAAAAA4AsEYAAAAACALxCAAQAAAAC+QAAGAAAA APgCARgAAAAA4AsEYAAAAACALxCAAQAAAAC+QAAGAAAAAPgCARgAAAAA4AsEYAAA AACALxCAAQAAAAC+QAAGAAAAAPgCARgAAAAA4AsEYAAAAACALxCAAQAAAAC+QAAG AAAAAPgCARgAAAAA4AsEYAAAAACALxCAAQAAAAC+QAAGAAAAAPgCARgAAAAA4AsE YAAAAACALxCAAQAAAAC+QAAGAAAAAPgCARgAAAAA4AsEYAAAAACALxCAAQAAAAC+ QAAGAAAAAPgCARgAAAAA4AsEYAAAAACALxCAAQAAAAC+QAAGAAAAAPgCARgAAAAA 4AsEYAAAAACALxCAAQAAAAC+QAAGAAAAAPgCARgAAAAA4AsEYAAAAACALxCAAQAA AAC+QAAGAAAAAPgCARgAAAAA4AsEYAAAAACALxCAAQAAAAC+QAAGAAAAAPgCARgA AAAA4AsEYAAAAACALxCAAQAAAAC+QAAGAAAAAPgCARgAAAAA4AsEYAAAAACALxCA AQAAAAC+QAAGAAAAAPgCARgAAAAA4AsEYAAAAACALxCAAQAAAAC+QAAGAAAAAPgC ARgAAAAA4AsEYAAAAACALxCAAQAAAAC+QAAGAAAAAPgCARgAAAAA4AsEYAAAAACA LxCAAQAAAAC+QAAGAAAAAPgCARgAAAAA4AsEYAAAAACALxCAAQAAAAC+QAAGAAAA APgCARgAAAAA4AsEYAAAAACALxCAAQAAAAC+QAAGAAAAAPgCARgAAAAA4AsEYAAA AACALxCAAQAAAAC+QAAGAAAAAPgCARgAAAAA4AsEYAAAAACALxCAAQAAAAC+QAAG AAAAAPgCARgAAAAA4AsEYAAAAACALxCAAQAAAAC+QAAGAAAAAPgCARgAAAAA4AsE YAAAAACALxCAAQAAAAC+QAAGAAAAAPgCARgAAAAA4AsEYAAAAACALxCAAQAAAAC+ QAAGAAAAAPgCARgAAAAA4AsEYAAAAACALxCAAQAAAAC+QAAGAAAAAPgCARgAAAAA 4AsEYAAAAACALxCAAQAAAAC+QAAGAAAAAPgCARgAAAAA4AsEYAAAAACALxCAAQAA AAC+QAAGAPSCRCIRDIVMo2Fubs7p4QAAADciAAMAPC+ZTEai0VAoJH5fF2o1MjAA ALgWARgA4G1Xpt8WMjAAAJgXARgA4GHXpt+WRgRWlHK57MioAACAOxGAAQBeJdJv NBYLBoPz/lcyMAAAuAoBGADgSTdOvy1kYAAAcCUCMADAe9pJvy2qqirVKhkYAAD0 EYABAJ7TfvptIQMDAIAWAjAAwEsWmn5byMAAAKCPAAwA8JDO0m8LGRgAABCAAQDe 0E36bSEDAwDgcwRgAIAHdJ9+W8jAAAD4GQEYAOB2VqXfFjIwAAC+RQAGALhaI/1G o8FQyMI2ycAAAPgTARgA4F6JRCIai4UsTb8tZGAAAHyIAAwAcKlkMhmORMLhsKT2 ycAAAPgNARgA4EaN9CtEIlJ7qQu12tzcnNReAACASxCAAQBuNDA4GI1GbeiIDAwA gH8QgAEArpMZGIjFYrZ1JwKwSMFkYAAAeh4BGADgLulMRqTfRYts/Q5Vq9VUMjAA AL2OAAwAcJFUOh2Px21Ovy1kYAAAeh4BGADgFqlUKhaPBwIBpwZQUxRVVcnAAAD0 KgIwAMAVksmkSL/9/f3ODkNRlEI+7+wYAACAJARgAIDzRPqNRCIhaVf+Lki1Wi0W Ck6PAgAAWI8ADABwnm2XHrWpWqkUi0WnRwEAACxGAAYAOCydycTjcadH8Q9M06xW q7NkYAAAegsBGADgpFQqFU8kHCn7fGONDFypzM7OOj0QAABgGddNOAAA/pFMJqOx WDAYdHog8xMZuFKplMjAAAD0CgIwAMAxg4sXRyIRp0dxI4ZhVEUGLpWcHggAALAA ARgA4AwXHv2dl67r1Wp1jgwMAID3EYABwJNEdDT7+voDgbm5OafH0olkKiU+hEAg 4PRA2qJpmiIysDdfagAAcBkBGAA8KZ3JiPSr6boXT6g2bv2NRkOhkNMDWQBVVUUG LpfLTg8EAAB0jgAMAN5zuXaUpmlqva7rurcWJzMDA7FYzOlRLFhdqNW89VIDAIAr EYABwGNE+g2GQtFotPVH0zRFKhNJ2CuFmlx771E7aoqSz+edHgUAAOiQJ+cfAOBb Iv0G+vtF+r3y9KzIwLqmqaqq67r4o5uXKBtr19Fo0FObn69SrVaLhYLTowAAAJ0g AAOAZ4j0uCgQCIdCoXD42v8q0m9rO7Sbl4I9uvn5SqZpigw8Wyw6PRAAALBgBGAA 8IxkKtUMv+Hr7R82RAbWGkzDcOE6sBh/wrObn68kMnClUvFi+TEAAHzO87MQAPCP zMBANBq9aYAUMbhWr+ua5qoM3Kj8HInMu3btRYZhVEUGdvFiOwAAuBYBGAA84IfN z+Fwm1cHiQxcV1XdTZWx0plMPB53ehRW0nVdZGBX/ZQBAADcGAEYADwglUoFQw1X 1r66KfdckiQCfCwe7+/vd3YYltNUVVEUx19eAADQJgIwAHjAwOBgOBxeUPptMQxD VVXHTwWL8V++t6nHcDkwAAAeQgAGAFdrbX4W6bHj5VPTNLVmCDYcWgr29MW/7VAU pcDlwAAAeEHPTkcAoDfctPJzOxoXBeu6pmni/wzDKJfLFo7wphYPDYXtqn0lPkxH NlpzOTAAAJ5AAAYA90omk8FgMByJdLD5eV71el1TVZESbcvAqXQ6kUjY05f46J55 7rmdO3aIF82eHi9rXA5cqcxyMRIAAO5GAAYAl4pGo6FQKBaLBaxb0mxsh9YaG6IN XTdMsyI5BosAH43F7Imj4uP6xWuvDS1ZcuH8+V0OZWDxerqn7DYAALgWARgAXEqk RxGAI3JqR7W2Q2uS70my7eojXdcfePDBBzdsaP3x5IkTB77+2v690IauV7gYCQAA FyMAA4AbifQr8ptIv1Ztfr5Wq0C0MCcnAycSiXgiYU8KDQaD73744ZV/c/TQoW+P HrU/A2uaplSrZGAAANyJAAwAbpRKp8PhcCgUktqLaZoiBtfrdRkFnDIDA7FYzPJm ryXG/8HHH0cikav+fu9XX509c8b+DKyqqsjANlcaAwAA7SAAA4DrtDY/hyMRe64O 0nVdZEhd0yxctxQfQjyRkLd8fZkY/M9efvmW5cvn/a+f/+1vE9ms/Tcw1Wo1tV5n HRgAALchAAOA62QyGZF+7Vy6FDFSBDbNugxsz/KvaZq33nbbsy+8cIPH/N9/+7fZ YtH+DMzlwAAAuBABGADcJZVKifQbDAZtzmyNDKyquqaJVNllDLZt+VcM+JPPPrvp w37/v/+37JHMq1qpFItFR7oGAADzIgADgIskEolQWORfmzY/X6ter4tUaRpGNxnY nuVfkdhffuWVJUuX3vSRtVrtD7/7newD1dficmAAANyGAAwALpJOp1uVn50KwH3N ZdXWRcGdZWDbln+TqdRrb77Z5oOr1eof/+mfwuGw1CFdi8uBAQBwFQIwALiFiI7h SMT+kHYtTdPq9XpnGdie5d/rVX6+gWKx+Od/+Rf7X97G5cDVqqS7pgAAwIIQgAHA FUT6DfT3i+jo4NrvVTooZSw+ilg8Lrt8l67rTz799N2rVi30iRPZ7N/+3/8LBoMy RnUDuqZVuRwYAAAXcMs0CwD8TITGYH9/KBx2w/LvZa0rgjVVbT+5pTOZeDwudVQN pvnhJ5909tQzp059vWePI5cD1xSFDAwAgLMIwADgvGQyGQyFHKx9dT0LysDio4jG YrLXVzVNe2vr1mQq1XELB/btO/n99/ZnYPFK1ms1MjAAAA5y10wLAPypVfvK/kjW jvYzsPgo4omE7PEsqPbV9fzPX/86OTFh/48bOthVDgAALEQABgCHJZPJ1tVHTg/k utrMwENDQyHJW7g7qH11PX/4p38ydL37dhaqpijqQnaVAwAACxGAAcBJiUQiGAyK +OvO5d/LbpqBU6lUIpmUOgbTNO9dt27jpk2WtFar1f74u98Fbb8cWFAUpZDP298v AAAgAAOAk1LpdDgcFhnYbad/r6XrusjAuqbNm4EHBwcj0ajUAYjef/Wb31jYoFOX A7e6LhYK9vcLAIDPuX2+BQC9bWBwUASwQCDg9EDaYhhGrVa7NgMnU6lEIiE1w5um uXHTpnvXrbO22Xw+/+//+q8hJ9aBycAAANiPAAwAjkmlUrF43Cvpt0UEUZGBr9oL vXhoSPY6qqqqn3z2mYyWR4aHv/j8c/svBxaqlUqxWLS/XwAAfIsADADOaNS+CoVk bxuW4ap1YPGBJJJJ2cu/m598ctXq1ZLa//bIkaOHD9t/DFt8XEq1SgYGAMA2BGAA cEC8Wfsq4vraV9fTyMCKouu6yMA23H4kb/n3sp07dowMD9t/EpsMDACAnQjAAOCA ZDIZDjfuPnJ6IF1RFEVTVfFRSN3/LHv597L/++c/z87OkoEBAOhhBGAAsFsikegP BqPRqLdO/17LMAxVBOBwWGpotGH597Lf/a//FXCoHDc1sQAAsAEBGADslkqlQo31 Xwdu37GcaZqyT/8+uGHD+vvvl9fFlWq12j//9rdOfWrIwAAAyEYABgBbJRKJYCgU iUS8vvxrD8vv/r2pubm5P/3hD05l4Nau8nlvWgYAAN0jAAOArVLptAhXjlw860XL b7312RdesLnT3PT0f/zlL059jsjAAADIQwAGAPskk8lgMBhm+bc9qqq+v21bxIlS YRcvXNi1Y4dTNbprtZpar5OBAQCwHAEYAOyTTqfDzauP7C817EXRWOytrVud6t2p y4Fb6vV6TVHK5bIjvQMA0KuYgQGAfQYXL5ZdM9k0TfFrDwRsXdff3Lo1mUw6OIZd O3ZccuJy4BZVVUUGZh0YAAALeX6GBACe0AhyixbF43HZm59FbmwFNq/vstY07Zef ftrBE0VuLJfL0Wg0Eol0n13/8y9/KRQKTmVg8SIo1SoZGAAAqxCAAcAOIgD3B4Ox WEx2R7F4/J61ay8ND+emppzavmuJRzdvXr1mTQdPnJycbO0cDgQCt9xyi0jCXY7k n3/729a6uiN0XRcZuFQqOTUAAAB6CQEYAKQTobRR+0p+8WfDMNY/+GA6kxG/H710 6dLFi33e3A7dzfLvyMjIlX+TyWQGBwe7eRFqtdoff/e7oHOFu8WntSoy8OysUwMA AKBneG9WBACe0yj+HAqJACx1W7KISeFI5JHHHrv8x+zY2MULFwIeDMCZgYFfvPZa B0+cmZkpFotX/WUkElm2bFkwGOx4PCID//Nvf+vU5cB9zaPdIgPPXvOhAQCABfHe rAgAPCeVTkejUakbklt7dO9cufK2FSsu/6XIwPlc7uyZM6ZhyOvacmLYWz/4oIPb j8SLMDw8bMz3wQYCgSVLliQSiY5HNTc396c//MHZDKwoSrFQcGoAAAD0AAIwAMjV Wv7t/iTqjem6PrRkyeq1a69d55yemjp35oyuaV4piyU+lo9//esOnlgulycnJ2/w gHQ6vXjx4o63Qxfz+T//n//jYAYWaoqiqiplsQAA6AwBGADkSqXTNpz+7Vu06OFH HrnequlkNnvu7Nk+03T/eWDTNF946aVlt9zSwXMvl7+6AfG5WLZsWcefjumpqf/8 93+X/tm8IV3XRQZurPmbTX19rd/ohlGtVBwcGAAA7uf2mRAAeFoikWic/ZV8+lck oqW33LLm3nuv9wDDMMZHRz1RE0tEu08++6yDJ4oEePHixXbKNXe5HXp8bOx//vrX bk4US9IIweIz/cMvf9f3429IyAAAuHoaBABel0qlItGo1LAk0k4wFBLpd2Bw8MaP HBsZuXj+/KImeePp0uKhoZd+8YsOnlipVCYmJtp/fDfboS+cP79rxw4XZuAba8Xg Vjy+MiRfTsh9zaPOTg8TAACJ3DsHAgCvSyQSIppGIhGpy78iyty6YsXtd9zRTh7L TU+fPnnStXuhOy5/JUxPTy/0stxutkOfPXNmz65dnsvAN9YKxi3XriGTjQEAPcCN EyAA6A2pVCrUPP0rNW2m0ulVa9a0X2RrbHR0+Pz5PlfuhRa5a9uvftXZc4eHh3Vd X+izAoHA0qVL4/F4Bz2ePHHiwNdfSy3u7So/BOMfV5AbvzSzsfiLmx69BgDAJVw3 +wGA3hBPJET0jYTDAZkBSWSPBx5+OJlKLehZoyMjw+fOSR1YZ55+9tnbr7jGqX21 Wm1sbKzjfjOZzODgYAc/ETj5/fcH9u3zTwa+HvHvUNf1K7OxSTAGALgSARgApEgm k5FIJChz+VcEjHA4/MjmzR08t1gofH/smKsWgTu+/UgoFAr5fL6b3sUna9myZR1s aT5+7Njhb74hA8+rEYuvXDduxmK2UgMAHOSiqQ8A9JJUOh2LxeSd/m2liTtXrrz9 jjs6e/pMLnfm5EnTNeeBO67/LIyPjyuK0uUAxCdLZGDxWVvoE/22F7pLreXiv580 bv5KKgYA2MMVkx4A6DHJZDIYDEYXHqXaJ8KDyNhr160Lh8MdtzA+Nnbp/PlFMmt0 tU+8aK+99VYHTxQfyMXmDU+WGGha6A8FyMDdaO2XbqXiy/uoicQAABkIwABgPRFN w83yV/K6EFnh3nXrhpYs6aoRXZ/IZoebdyNZNbCO3f/AA/c/9FAHTyyXy5OTkxaO JBqNLl26dKHboXuyLrSDWpH48tFi8QdOFAMAuuf8jAcAek9mYECEKKmnf+OJxEMb N1rS2ujIyKULF/ocrQutadp7H31k2wVIN9VZdWiP3g/sCaZptvLwD6vELBEDADpC AAYAi7XKX4U63ZncDhEAVq5evfy226xqcHxs7OK5c33OZWBd0z7+9NPOnnvp0iWR ny0dzg86qA49OjLy+d/+JnXxHy0iA4vPu/HjcWLyMACgHQRgALBYKp2ORqPyjoOa pplKpe5dv97ClUZd10eGh8dHRhoJ2IkMvOKOO7Y880wHT1RVdUQMW5pwOLxs2bIF BdqJbPav//EfUn8CgmvpP2J9GABwAwRgALDYwMBAOBKRV/9ZTO7vuffepcuWWd7y +bNnx0dH7a/k1M3+59nZ2VwuZ/mQrrRo0aKhoaHUQi5bzudyf/nznzuuT4YuXd4v 3crDVJkGAFxGAAYAKzX2P0ejwWBQ0jqqSL+xePy+9euj0aiM9ifGx8+dOSMvvc9L BOBfdrr/OZvNVqtVS4czv0QiIWJw+z8dmCuV/vTHP5KB3aC1WfqHu5copgUA/kYA BgDLiFAaCofj8bjE8lemueLOO29fsUJeRh0bGbl44cIiG88DDw4Ovvzqqx08UcSZ 4eFh0zQtH9K8RPpdsmRJ+5WxRDL//37/e84Du4r419IIw+J/hGEA8CUCMABYRkQj kXZiCywdvCCi8TX33iu1C+HCuXPjo6P2rAOrqvr+tm2d7X+uVCoTExOWD+nGUqnU 4sWL23xxarXan/7whz5HK2zjehphWFW1HytLs00aAPyA78cAYJlkMhkKhzvLcu0Q 0/TVa9cuu+UWSe1fNjYyMnzhgj2Z7dbbbnvm+ec7e24ul5udnbV2PO0IBoNLliyJ xWJtPv7f//VfS6USGdjNftgm3VwZnrP6Vi0AgHvwzRgALCO1/rPZ3On7xJYtMhq/ qqO9u3bZs/xbr9c/+Pjjjn9kIO8CpHYsaCn4i//5n9GREfsLjKEDWlPjzDB7pAGg 5xCAAcAy6Uym/QOiCyWm4wODgz954AFJ7V928vvvCzMzsnvpaybthzduXLd+fWdP F+F5dHTU2iEt1IJOBR88cOD748fJwB4i/omqqqo3wzAbpAGgNxCAAcAajf3PoVBE TnFmwTSM++6/X2RgSe23VCuVwwcOBGwJaSJafPLZZx0/PZ/PFwoFC8fTMRGAFy9e 3E6xqzOnTu3dvdvCC5xhm8aisAjDus6lSgDgaQRgALBGKpUKRyLySv5GIpGHN22S 1Phl+/fsMQxDdi99zQXtZ557bsWdd3bcwujoaL1et3BI3Vi0aFE6nR4YGLjpjujs +Pjf/vM/Q1yP5Fnin67aSsLUzQIADyIAA4A1MpmMCMCSNriK2fatt99+9+rVMhq/ bPjChbGREXtqNZmm+dEnn3T8dJFARkZGLByPJcRnf/HixYlE4savYbFY/PO//AtX BHudYRji36GmaSRhAPAQAjAAWGNgcFBEGlm1o0xzzbp1i4eGpDTeVFOUb/bts+eE qsgMr7/9diaT6bgFkSFnbDmo3IFQKCRi8I0PBler1X/5/e+DXBHcE0QSrtfrrAkD gCcQgAHAAq0LkAQZy6emaabT6XvuvTcs7YIlYd/u3c0603aIxeNvvvNONy2MjY3V ajWrxiOD+McwMDAgYvD1/kmI8f/bn/6kaRrXI/WMH3ZHaxrnhAHAtfimCwAWSKZS zfwrZVOroetr1q1bsnSpjMZbThw/XrSroJRar7/fxdVHfW7d/zyvYDCYyWSSyeT1 tgZs/+//HhsdpTR0jxEZuN5MwsRgAHAbAjAAdCsajbaWfyVVwNINY/OTT8rLSNnx 8Qtnz9p29HfNvfdueuyxbhpxT/3nNonXNpFIpFIpEfuvfZ0PHzx4/NtvycC9p3WL UuNKYU3jPmEAcAkCMAB0KxaPB4PBWCwm4wCwmEMHQ6FNmzdb3nJLqVT69tAh29JX l1cftYyMjIh2LBmPzcTrHI/HRRiORqNXJuGLFy58uX27vBLicNYPh4Q1TXy5OT0W APA7AjAAWCCdTotYI6NlMXVetnz56jVrZDReU5SD+/bZc+tvX/OE5HMvvHDbihXd NFKr1cbGxqwaklMCgUD0R62j4/lc7i9//jOloXtb4y7hZrkstkYDgFMIwADQrXg8 HgqHY7GYjMbFXPmhjRsTyaTlLddrtW9E+pVUtno+/cHgex9+2GUj09PTPbaMJj4F rf3zIgPv27vXMIxWNbJFTf39/VTJ6jEsCAOAg/ieCgDdapWA7qaq0w2ILPT4li2W N9tIv/v3B2xMVqqqvvvhh13+mEAkh+HhYduqVdtPZN3WRydScX+Tpqoi888Wi+W5 OUVRWsHpqpDcyslOjx0Lptbr4uvC4PIkALARARgAupVKpULNFTzLV+rEzDgajT60 caO1u5RLs7PHDh+2bedzXzPGr7///gc3bOiyndnZ2VwuZ8mQeokIUfmZGfFpLZfL dUVp3MSj62ZT42ccixYFmlhJdifxyWr9XIMYDAA24HshAHRLBOBwJCKjgpGYGQ8u XrzmvvuCwaBVbU5ms2dOnbJ5wVAk+W2/+lX37Xi3/JXjlGp1Ipstz81Vq9XWXbWt ZeRWMGajtePE50LEYE1V2RcNAFLx3Q4AupVMpWKxmIxIKQLw8ttuW3n33Vat1n53 7NhsoWBz1NE07a2tW8Wr1GU7iqKMj49bMiRcpV6rTU5MzBaLIh6L3zcWkA2j74r9 1cRje7RuThJKs7NOjwUAehPfzwCgW6l0WtIdSIZh3H3PPctvvbX7pspzc0cOHrT/ pKiY0N+7bt3GTZu6b2piYqJSqXTfDhaqWqlkx8ZKpZLSXD0W/yzFXy5qrh1z9liS Rgiu1zkeDACWIwADQLfSmUw0GpURgHVdf3DDhu7XTk9+911+ZsaRRTyrNj/X6/XR 0dHu24GFREbLTU4WCgUR0uqKoreCcfPIMcHYEpqmiX/5BtcmAYB1CMAA0JXGPa6R iKQAbJrmxkcfDXdRX3pqcvLMyZN23nV0JTF93/rBB5ZcEDU5OVkul7tvBzYQwXh8 bKyQz1crFbVeF/+MScXdaFTJau5LJwYDQPcIwADQlVg8HgwGE4mE5S2L2CACw/0P P9xZgCyVSiePHxcR1KnTm2L8jz3++Oo1a7pvSgSqkZGR7tuBg35IxblcuVLRVdVs rhWLrx1OF7eJGAwAluC7DgB0JZ5IiEl8PB63vOVGhd7+/g2bNi20vnR5bu7Ed9+p 9bqz0SKRSLz+9tuWNDU9PU1p3J5ULpeHz58vzc6KaGc0S1ITiW9MBOCaeK2IwQDQ Kb7HAEBXRPQNhcPRaNTyWXtj42hf3+YtW9p/iggSp0+cEPNjp/Y8X6ap6i8/+8yS pjj96yuVcvnCuXOzs7NqvS7+2N/k9KBchxgMAB0jAANAV2LxeDgcjkQilmfOxhbo YPDRxx9v58G56elzp0+LabEbVs8Mw3j1jTcyAwOWtJbNZqvVqiVNwXNUVR0bGZme mlKqVZH3Av39Ft6J7XW6pjViMJWiAWAhnJ8nAYDXDQwMRK2o83QVMa+NRqPrH3zw BkWwREgevnBhvLlA6obo29cc0tr77nvk0Uctaa1SqUxMTFjSFHpA6yDxVPNnIq1D 8qwPN+9LqnNvMAC0yRWzJQDwtIHBwUgkImMLtGj2gQ0b5l3yqtdqZ06dKuTzbgsA Ysxvv/eeJU2JV2B0dFTM7y1pDb1H/NsYHR6enJio1Wp+LqklvlJEBhavxhxH5QHg Zvz4fQIALBSNRiPifxK2QPc191c/uGHDVX85NTFx8fx5Mdl1/KDvtTRN++Wnn1rV 2uzsbC6Xs6o19LxSqXT21Kny3JxhGD5cHBYxuFaraSIGsyMaAK6PAAwA3RoYGAjL OQMcTyTuW78+HA73NZd8z54+XcjnXZh7WxpHf998M5PJWNKayNKjo6OiTUtag9+I r5dzZ87M5HK6pvUHg/4Jw+JLRsRg8VETgwFgXgRgAOiWpC3QQigcXnf//bmpqfGR EU3XXRt9+5pxffOTT65avdqq1iYmJqh9BUvUFKXxw6OZGV3XfRKGtWZ9LA4GA8C1 CMAA0JVoc/9zNBaTEYBNwzD7+tyce1tEXr1n7dpHN2+2qkE2P0MSEYZPnThRLBTE 73v7zPAPB4PrdZaCAeBKPfu+DwD2iMfjYhodTyScHoiTFi9e/NIrr1jVWqOy0eio mL5b1SAwr3wud/rkSRGJe3hZuLEjWlF0bgwGgB8RgAGgK40AHArF5KwAe0I4HH7n /fetak3k3mw2qyiKVQ0CN9WqqT7T3HTQk8vC7IgGgMt67S0eAGwWTyTEjDkajbp/ o7IMiwKB9z/6yMLAkM/nC83tqYAjxsfGzp85o+t6KBTqpSTMjmgAaOmdd3YAcEo6 nY7F4700V27f+9u2WZj8y+Xy5OSkVa0B3cjn86e+/76mKOFwuGe+ukWwFx/RLEvB AHysR97QAcBB6UzGhyvApmmK9Gvhycl6vT42NsbRX7hNsVg8ceyY+PfZM2vCtVqN pWAAvtUL7+MA4Kx0Oh2JRnu1iM68REj9wNK1X13XRfrVNM2qBgHLzeRyJ7//XlPV HkjChmEoijJbLDo9EACwm7ffvgHADVLptJgQh8Nhpwdik/5g8L0PP7SwQW79hbdM TkycOXFC/LsNhkJOj6UrdaFWYykYgK8QgAGgW8lkctGiRYlk0umBSCdm/Ol0+tU3 37S2zenpaabg8BxVVU+fOJGbnu5vcno4HWIpGIDfEIABwBrLb73V6SHIJZLqrbfe +uzPfmZts7lcjpI88LRKuXzs6NGaonh3azRLwQD8w5Nv0wDgQr0dgA3DWLd+/YZH HrG2WS49Qi+ZyGZPnzgRCAS8uCBMgWgAPkEABgBr9HAA1jTtpV/8Ytktt1jbbLFY nJmZsbZNwHFKpXL0yJG6ooS8VhfANM1Wgehyuez0WABAFgIwAFijVwOwmA2/+9FH sVjM2mZnZ2dzuZy1bQLuoarq2VOnJicmgsGgtxaENU2rKUqpVHJ6IAAgBQEYAKzR ewHYNE0xcX9z69ZIJGJty4VCIZ/PW9sm4E7FfP740aN9ixZ5KAaLr/1qtUplLAA9 iQAMANbosQCs6/p9P/nJI48+am2zYmItom+RiTV8RqlUjhw+rNXrHro5qbUdmspY AHoMARgArNFLAVjMen/++utLly61tlmRfnO5HFsr4Vuqqn57+HB5bs4r14azHRpA 7yEAA4A1eiMAi4waCATeevddy7c9G4YxNTVVqVSsbRbwnMsXCHvi2iS2QwPoMW5/ 2wUArxhcvNjy0GgzMS9/eOPGBx56yPKWNU2bmJio1+uWtwx41/CFCxfPn/dEDK4p inh/YDs0gB7g9jdcAPCKZDKZSCbdP5Gdl9n0xjvviI/C8sZrtZpIv7quW94y0ANE BhZJ2P0xWARgEYPJwAC8ztVvtQDgLbcsX+7yKey8xLx2/QMPbNy0SUbj5XJ5ampK pGsZjQM9Q8Rg8b9wOOzm9xBD16uKUpqddXogANA5977JAoDnLLvllkAg4PQoFkDX dTHhfvWNN+KJhOWNU/AZWKjzZ8+OXLwYcnEMFl/XSrXK1zUA73Lp2ysAeNGSpUuD waDTo2iLmMWK9Pviz39+y/LlMtrXNG1qakpRFBmNA73txPHj01NTIRdfmMSRYADe RQAGAMsMLVni5jlri4i+Yua64ZFHZBS7aqlWq5OTk4ZhSGof6Hn1Wu3wwYNqve7a n6lxJBiARxGAAcAyLg/Arej78IYND27YIK+LQpOk9gFfqVYqhw4cEL/p7+93eizz 0HVdqVa5JRiAtxCAAcAyrt0CLXKppqobH310/QMPyOtFpOupqalarSavC8CH8vn8 8SNHxHuLCw8GG4ZRFRmYslgAvMN176QA4FHuvAZJ13UxpKd++tO7Vq6U14sI2KVS aWZmhmrPgCSt25LC4bDTA7ma+KoXGXiWslgAPMJdEzUA8K50JhOPx50exQ9au50H Bgeff/FFGVf7XknTtOnpaTEDltoLAPFFfWj/fvEV58Id0Uq1KgbGkWAA7kcABgBr DC5eHIlEnB1DY6uzpoWCwceefHLV6tU2dMfCL2CzYrF49ODBUCjktv0mtVpNrdfJ wABczl1vnQDgUclkMp5IOHUJcCv39vf3b3jkkXXr19vTab1en56e5sQv4IjzZ8+O Dg+HXLYjWrwt1BSlXC47PRAAuC4CMABYIJVKJSTvNL6W3hSLxR59/PGVd99tW7+t Us/FYpGFX8BB9Vrtm337xJehq3ZEcz0SAJcjAAOABTIDAyKI2tBRq55zoL9/6bJl jz/1VDqdtqHTK1Wr1VwuJ+a4NvcLYF7jY2NnTp50VXEsTdOUapUMDMCdCMAAYAGp NwCL0Nsq5rx4aEiE3sHBQUkd3ZiY1M7MzLC5EXAbVVW/+fprwzDcsxTMFcEAXIsA DADdknoBkki/jz3++Oo1a2Q03v4YisVioVBgzzPgWhPZ7Knvv3fPUnDjiuBKhQwM wG0IwADQLakXIGma9stPP5XUeDvK5fLMzIwYhoNjANAOVVUP7t+vu+aepEYGrlZL s7NODwQA/o4ADADdknoBkoMBWFEUEX2p8wx4S3Zs7LRrTgWTgQG4DQEYALoi+wKk VDr96htvSGr8elRVzefzHPcFPKpeqx3YuzfQ3++Gu4JN06xWKrNkYADu4PzbIgB4 mgioiURCUuNi4vjz116zs+qVruuFQoGpKtADzp4+nR0bCwaDTg+EDAzARQjAANCV gYGBqLQLkOr1+q9+8xtJjV/FMIxiE5WugJ5RKpUO798flnZGo31kYAAuQQAGgK4s WbpU4gKLaX74ySeyGv+RiL5iViqir/iN7L4A2ExV1UP792suqIxFBgbgBgRgAOhc Ukil5LV/x513PvXTn8prXyTeUqkkoq+u6/J6AeC44QsXLl286Ph2aDIwAMcRgAGg c5mBgZi0/c8ilL774YeS6kuLaaiIvoVCgegL+MRcqXTowAHHq0OLN59KpUJdaABO IQADQOeGliwJhUKSGldV9ZPPPrO8WcMw5ubmiL6AD4l3lQN79y5qcnAYZGAADiIA A0CHkslkIpmUN48Ujb/+1lsWNshZXwDCye++y01PO3skmPuBATiFAAwAHcpkMrF4 XFLjYnb4i9dft+oCJF3XZ5uIvgCEyWz21IkT8jawtKORgSuVUqnk4BgA+BABGAA6 tHhoSN5pOqsuQNI0rRV9udwIwJUq5fI3+/Y5eyTY0PXGOjAZGICNCMAA0AnZ+58D gcD727Z104KqqsVicW5ujugLYF7iXWLf7t39/f0OHgnWRQauVMQ7lVMDAOA3BGAA 6EQ6k4lL2/8sIuvmJ59ctXp1Z0+v1+ut6GvtqAD0pCPffFMulx08EqxpmlKt8pYF wB4EYADohNT9zx3Xf1YURUTfSqVi+ZAA9LCzp09PjI87mIHFm57IwCKHOzUAAP5B AAaABZO9/1nX9Y9//ev2H2+aZrVaLRQKtVpN0pAA9Lbs2NjZU6eCzpXFqgu1GuvA AGQjAAPAgkmt/yzcvmLF088+284jRfQV88VisaiqqrzxAPAD8U5y9OBBB8ti1Wo1 tV4nAwOQigAMAAs2tGSJvOtDNE1776OPIpFIOw+uVqvZbFbSSAD4jVKp7P/6awcz sNLczOJU7wD8gAAMAAuTTKUSiYS8/c+aqv6y7QPAU1NTrJYAsFC9Vvt6926nMnDr QMdssehI7wD8gAAMAAuTGRiIxWLy2l+6bNkLL73UziPFTHF4eNgwDHmDAeBDqqru 37MnEAg4cj2SeGerVCql2Vn7uwbgBwRgAFiAZDIZjcWCwaCk9nVdf+f999sM2Ox/ BiDPga+/1lTVkQxsGEZVZOBSyf6uAfQ8AjAALEAqnU4kEvLaX9AFSLlcbpZFEgDS HD5wQFEURzKwrusiA3PEA4DlCMAAsACDixe3WZ6qMwODgz9/9dV2Hmma5sjIiKZp 8gYDAMeOHp0tFBy5IlhV1ZqikIEBWIsADADtSiaT8UQiEAhIal/X9bfffTfe3gqz oijj4+OSRgIAl31//Hg+l3MkA9dqtfzMjP39AuhhBGAAaFc6k4nLvP5X07Rffvpp mw+emZkpuqlQ6tTk5MT4+P0PPeT0QABY78Tx4zMOZeBqtVrkYiQA1iEAA0C7pF7/ Kyy75ZbnX3yxnUe6bf+zSL9ifqzW6wOLF2989FGnhwPAeqdOnJienLQ/AzcuRqpU qHcAwCoEYABoSyqVSiST8toXafa9jz5q84Cxq/Y/z83N7du9uz8Q6Fu0SNf1+x98 cNny5U4PCoD1nMrAhmFUKpU5ikIDsAIBGADaMjA4GI1G5bWva9rHHtz/fOTgwdz0 dCv9ij+aRsPzL7/s9LgASHHyu+8aX/K2Z2BN05RqlYJYALpHAAaAm5Nd/kq4a+XK J7ZsaeeR7tn//OX27bqqBn5Mvy0iAwdDoS3PPuvcuABI5FRNrHqtVq/XycAAukQA BoCby2QyMZnlr1RVfX/bNg/tfy4WCgf37xe/mfeHAoaub9y8Wbxoto8LgB2Of/tt qVi0/35gCmIB6B4BGABuIplMRmOxYDAorwvTND/65JM2H+z4/udLFy+ePnlSRN/r Tn9Ns3EY+KGHOAwM9Kqjhw5VymWbM7B4q6xUKiUKYgHoAgEYAG4ilU4n2rubtzNi SvfU00/fuXJlmw++dOmSiJfyxnNjJ777bvTSpZv/OMA0xS/P/OxndowJgBMO7t9f r9VszsCNgljlMhuhAXSMAAwAN7F4aCgcDstrX63XP/nNb9p8cLVazWaz8gZzY0cP HZqemmrz7J+Ypw4MDm7YtEn2qAA4Zf+ePbqu25yBVVWtKQoZGEBnCMAAcCOpVCqe SEid3iWSydffeqvNB09PT5ccugtkz86dSrV6VcmrGzN0fWjp0gc3bJA6MAAO+mrH DqknROalKEohn7e5UwC9gQAMADcyODgYkXr7ka6/uXVrsr0bhk3THB4eNgxD3njm lZ+ZOXbkiKZpHdTBFs9ac999d951l4yBAXCcqqp7d+2Suk1mXpVKZdYdt8EB8BYC MABcl8iliWRS6vLvgq7/FRO+iYkJeYOZ12Q2+/2xY4ZpdnYLlAjtpmE8+sQTyVTK 8rEBcIOaouzbvTvcXh17qzQOA1cqcw7tiAHgXQRgALiugcHBqMzlX5ENH9ywYf39 97f5+MnJyXK5LG8818rlcocPHAj29ze2PZtm+5uff9B8igjAoXD4qWeekTNGAM6r VioHvv7a5nVgDgMD6AABGADml0wm44lEZ8uebVpQ+SvDMIaHh81mdWV7nDt9+sL5 822WvLoxMfglS5c+8PDD3TcFwJ2KhcKxI0dsPg/MYWAAC0UABoD5ZQYGYrGY1C7C kcg7773X5oPn5uampqakjudK+3bvLs/NBaxIvw2mqRvGXStXrl671poGAbhPdmzs 3JkzlvzUrE2maVYrlVluBgbQNgIwAMwjISSTUpd/dV1//e230+l0m4/PZrPValXe eK701Y4d9VrNsvT7I/Ehb9i0aXDxYmubBeAeZ0+fnhgftzMDczMwgAUhAAPAPGxY /hVp8ONf/7rNB2uadunSJanjaZnMZi+cOydmk4tkhH/TFKH66eees75lAK7x7eHD Io/aeTlwXajVyMAA2kEABoCr2XD61zTNJ7ZsWXn33W0+vlAo5OWfczt3+vTF8+cX dNPvQhm6HovHH9+yRVL7ANxg95df2rkILFSr1WKhYGePADyKAAwAVxsYGIhKXv6t 1+u/arv8lTAyMqKqqrzxCGdPnbrYKnkled1G17Q7Vq5cc++9UnsB4CDxfrVn586I jRcjmaZZKZdL3IoE4GYIwADwD2y4+1dYumzZCy+91OaDa7Xa2NiY1PEcP3p0Ipvt l7n2+3fNu5GeeeEF6R0BcI5Sqey392IkTdOqlYrNd8UB8BwCMAD8A9l3//Y110be 37at/bWR6elpqcsae778UlEUqTufr2Iahujr2Z/9zJ7uADhiJpc7cexYv40XI3Er EoCbIgADwN8lU6lEIiF7+TcUCm394IM2H2ya5vDwsCESoxySCj7fVONm4GXLHnjo IZv7BWCnc2fOZMfGbDsP3NgIXamUuBUJwPURgAHg7wYXL5Z9aG2htx/Ju/63VCwe OXRIrdftT78NzZuBf3L//ctvu82B3gHY5eD+/fVazbai0OI9tlqpUBEawPUQgAHg B6l0Oh6P2zBL+/CXv2z/wZKu/y0Wi0cPHjR03bZtz/MSU9XHnngimUo5OAYAsu3a vj1k42HgWq2Wn5mxrTsA3kIABoCGZDIZiUZDoZDUXgzDePmVV4aWLGnz8ZKu/52b m9u/d+8i05Ry2e+CmGYgGHz62WcdHgYAmRRF2b9nj50FsSrl8iwboQHMhwAMAA3p TCYej8vuRQTgbb/6VfuPz+fzBatvtizk8wf37QsEAs6n3yZD1weHhh5+5BGnBwJA ounJyVMnTth2GJiN0ACuhwAMAI3l31g8LntmJiZkz7/44q1tH3k1TfPSpUviWRaO ITs+/v2xY+Kt3yXpt0XTtJV337167VqnBwJAohPHjxfyedsOA7MRGsC8CMAAYMfV R4Kmqr/87LP2H18ulycnJy0cwNTk5LGjRxvB19Fzv/MSL87Dmza1vzkcgBft/vJL 2xaB+9gIDWA+rpsDAYDNUqlUXP7VR6ZpPrFly8q7727/KZaXv9q5fbvjVa+uxzQM c9Gi57gZGOhpqqru2blTdrH9y9gIDeBabpwGAYBt7Kl91dec9n2ykOVf8fiRkREL B/D5X/8aECnfTTufr2IYRiKReOzJJ50eCACJ8vn8999+a9s6cE1RRI/29AXAEwjA AHwtMzAQi8Vk9yKi3ZNPP72g5d+ZmZlisWjVAL7cvt3QNDen3xZD1+++556Vq1Y5 PRAAEp06cWJmetqew8CmaVYqlRIboQH8iAAMwL+SqVRC/uZnQde0jz/9tP3Hixnb 8PCwiM2W9L53505FUdyffvuaH7hpGM+99JLTAwEg1+4dO/qDQXv6Eu/AIgOXy2V7 ugPgcgRgAD7V2PwciYTk30u50OLPfc17eqempizpff+ePXOlUsDGqjNdMnR93f33 L1/IywXAc+q12te7d9t2M7CiKAU2QgNoIgAD8KlMJhOTf/GvYJjmtk8+WdBTxsbG arVa910fP3p0Mpv1UPptME3xeeEkMNDz7LwZuLERulwulUo29AXA5QjAAPwomUrF 4/GA/F3Buq6/8tprg0ND7T9FUZTx8XFLev/8r3/tFx+jK8s+X5dp6obxPLugAR84 euiQyKX2HAZWVbWmKFSEBuCpWREAWMG2ys9CYNGi9z/+eEFPmZyc7P6smpjkHfnm G01VPZZ+m0zDuPX22+/9yU+cHggA6XZu327bRuhqpWJhcUEAHuW9iREAdGlgYCAq v/KzoGnaG++8k06nF/SUS5cudd/1gb17S6WSDUvckvQHAluee87pUQCQrjw3d/ib b4K2FMQyDKNSLrMIDPgcARiAv6TS6Xg8bs+Ou2g0+ta77y7oKZbcfnTh3Lmzp0/b M6GURNf1TZs3pzMZpwcCQLozJ09OT03Z87Zcq9XyMzM2dATAtQjAAHwkmUzG4nF7 aq6oqvr+tm2RSKT9pxiGcenSpe5vP9r+t7+JN3dP3Hs0P9PUdP2Fl192ehwAbPLV jh22/cyuXC5zLTDgZwRgAH4h0m84ErHnsJlpmqvuuWfzE08s6Fmzs7O5XK7Lrocv XDh76pTHKj9fxTR1XX/sqafEp8zpoQCwg6IoB/butac0g3h7aVwKzLXAgF8RgAH4 RWZgIGbL0d++5vLvJ599tqCniMw8Ojoqnthl1zu3bzd03Yu1r65kGsbDjz46MDDg 9EAA2OTSxYvif/bs0FGq1UKhYENHAFzI2zMkAGiTnUd/dV3f8swzd61cuaBnlcvl ycnJLrseGxk58d139swgZXto48aBwUGnRwHAPnu+/NKe3SumaYq33DmuBQZ8iQAM oPclk8l4ImFbSWQRsz9Y4NVHwujoaL1e77Lr744dmxwf9/Dp38tM8/Y77rjn3nud HgcA+9RrtX179tizEVq83850feQEgBcRgAH0uEQiEYvHbSuvoqrq2++9t9DDq9Vq NZvNdt/75//1X/1eLv58mWEYa+67b8Uddzg9EAC2unTx4sjwsD0/r6yUy7NUwwL8 hwAMoJc1Cl8JCynF3A3TNFeuWvXEU08t9Inj4+OKonTZ+5lTpy6eP+/p248uEwH4 uRdfdHoUABywe8cOe36QRzUswJ8IwAB62cDAQNSuwld9HdW+6muWPxUBuPve9+/Z M1cqebv+848MXX/upZecHgUAB9QUZb9dFaGr1WqRaliAzxCAAfSsdCYTj8dt607X 9ZdeeWXp0qULfWI2mxWTsO4H8OXnn+ua1gsB2DTFL8/87GdOjwOAMy6cO5cdG7Oh bKFhGJVyeW5uTnZHANyDAAygN9lZ9rklkUi8/vbbC31WvV4fHR21ZADb//Y38att tb7kMXQ9nkhsXvhOcgA9Y9cXX9izCFyr1fIzMzZ0BMAlCMAAelAqlYrF43ZGQZFj P/j448jCDxtPTk5acgItn8sd/uabvkWLeiAA67q+/LbbfnL//U4PBIBjKuXyoQMH bChqYJpmpVIpUQ0L8A0CMIBekxTpNxaz8y5cEdiee+GF21asWOgTLVz+zY6NfX/s WCP92rjoLYl4PR/auHFoyRKnBwLASSe/+y4/M2PDRh5NVRVFYSM04BOenycBwJWS yWQsHrcz/QrxROKNhW9+FiYmJiqViiVjGL106dSJEwExU/R6ADZN8Xo++sQTTo8D gPN2bt8eDodt6Ei8Fc8WizZ0BMBxHp8nAcAVRPqNxmI23wPU8ebnWq02NjZm1TCy 4+Mnjh9vvKd7OgCbpm4Yz1P/GUBTMZ8//u23NvxMkyuRAP/w8jwJAK4g0m8kGrWn aMplYs70s5dfvmX58g6ea1Xx55axkZEzp06ZhuHpAGwYxuKhoYc2bnR6IADcYt+e PY13NvmUarXAlUiAD3h4ngQAlzmSfk3TvOOuu7b89KcdPFdEXxGALRxMsVA4euiQ Ycs0URIxxzX7+p578UWnBwLARVRV3btrlw0bocVbeuNCJE4CA72OAAzA8xxJv33N 5d+Pf/3rzp47NjZWq9WsHc+BvXs9vX9PU9XVa9euXLXK6YEAcJfRS5cuXbxoQzUs rkQC/IAADMDbnEq/qqq+/d57ovcOnlupVCYmJiwfUm5q6uihQx4tBG3o+p0rV4oA 7PRAALiRPdcCN65EKpdLpZLsjgA4yHuTJAC4rFH1KhoNOrH2+/iTT65es6aD54oJ 1tjYWL1et3xU+Vzu4IEDwf5+zwVgwzDS6fQjmzc7PRAALlUulw/bci2weHOeyeVk 9wLAQR6bJAHAZY7UfO5rJthlt9zyQqeVikul0vT0tLVDuuyL//5vG3YJWsvQ9Xgi sfmpp5weCABX+2bfPk1VbehIhO3S7KwNHQFwhMfmSQDQkkylYrGYzff9tuia9vGn n3b2XMMwRkZGdF23dER/9+3hwzMiXXslA5umeCnEp/KxJ590eigA3K5RDWvnzvDC 75xbKE3TlGqValhAr/LIJAkArpBKpaIOpd96vf7O++93dvRXmJmZKRaL1g7pKp// 13/1u38XtGkahmGa5q0rVty1cmU8kXB6QAA8YGxkZPjCBRv2uVQqlVnJ79UAnOLu GRIAXCOVTsdisUapJ9vpuv7Mc8+tuPPOzp6uquro6KhIfdaO6iqHv/mmmM+7NwA3 P3zdMKLR6JMd3SAFwM/sqYYl3u0r5bKn6+oDuB63zpAAYD7pTEakX0eOuYrges+a NY8+/njHLUxMTFQqFQuHNK9Ssbh/717XLgIbuh4MhVavWXPbihVOjwWA95RKpW8P HuyXX/2hWq0WCwXZvQCwnxunRwAwr8zAQDQadarIUygU2vrBBx0/XcylstmsheO5 gXOnT188fz7gxBbxGxDRV2TyBzduHBoacnosADzs6927+yRvpelrlmyolMucBAZ6 DwEYgAckk8lgKCTSr1MDUFX1/W3bIp0WXzFNc3R0VLWlfmnL3p07q4riyEbxq5iG 0djwHIncfscdK1evdno4ADyvXqvt27PHho3QLAIDPYkADMDtRPoNRyLhcNipAYjJ 1rsffthNoabZ2dmc7RdLfrVjR71edywDt8pcNSuWDS1ZsqqjO5MBYF6nT57MTU3J 3hDEIjDQkwjAAFzNqct+L9NU9eevvbZk6dKOW9B1fWRkREykLBxVO8Sk7eD+/Yam LbIzA/+Ye/sDgYHBwRV33SXSr329A/CNnZ9/bsOVSEq1WmARGOgtBGAA7uVgwecW kV03P/HEPWvXdtPI5OSkU6VERQY+tH+/bkMGbuZe8f8N0xRT0jvuvHPlqlVyewTg b5PZ7JlTp2Tfh8ciMNB7CMAAXCqTyUQdKvjcItLvuvXrN27a1E0jlUplYmLCqiF1 5tyZM+fPng1KqAttNrX+XzgavX3Firs55QvALvZciaQoSiGfl90LANsQgAG4juMl r/qa0e62229/5vnnu2nEMIyRkRERpK0aVce+O3YsOzq6KBBY1PqJQjdJuFl81WxW txKvUjyRuHPlSu40AmC/uVLpyMGDss/IiDe6xhIwi8BAryAAA3AXkX4j0agNP9S/ ATHdSafTr775ZpftTE9Pl0olS4ZkiW++/rpYKIgYvLBd5VdcN9KIvIbRHwwuW758 3fr11g8RABbCniuRaoqSZxEY6BUEYAAukkqno9Go7DNdNyYinhjD2++912U7iqKM j49bMiRrjQwPnz11Std1s7ES/ONa8D+uCQeu+KPRXOkNhcPis3PP2rXJVMrW4QLA 9dlzJZJ4D6yUy676gSaAjhGAAbhCMpnsDwZF8nTw0G+LSHvbPvmky0bsv/h3Qebm 5sZHR0uzs5VKRavXW3WbG6+8aTYicX9/sL8/EomkBwZuX7FC/Afx2RFPEb86PXAA uNqhAwdEDJbdS61Wy8/MyO4FgA0IwACc17jpV5B/ocVNaar63rZtka5Hks/nvXhz xmQ2K0J7f1MwGBwcGnJ6RABwE+Jda++uXbLvimcRGOgZBGAADkulUpFo1MGbfi+r 1+sffPxx9+m3VquNjY1ZMiQAwE2dO3NmMpuVvYGIRWCgNxCAATgpnclEo1EHb/q9 TKTf9z76KBaLddmOYRijo6OaplkyKgBAO3Zu384iMIB2EIABOCORSDR2PTt619Fl VqVfYWpqitsyAMBmYyMjwxcusAgM4KYIwAAc4J5tz32Wpt9yuTw5Odl9OwCAhbJn EVi8z8+xCAx4GQEYgN0ymUw0FnO82nOLqqrvfvihJelX07TR0VHDMLpvCgCwUJMT E2dPnZJ9poZFYMDrXDEBBeAT7qn23GJVzee+5rJANptVFKX7pgAAndm1fXvIhkXg uTmOugDeRQAGYJNUOh2NRvv7+50eyA90XX/3ww8tSb9CsVicYU0AABw1k8udOH5c 9jeamqLk83mpXQCQhwAMQLpkMtkfDIr065Jtz6ZpBgKBt95916r0y71HAOASu774 IhQKSe2CRWDA01wxGQXQw0T6jUSjsqcj7RMTl3Q6/eqbb1rVoK7rIv1y7xEAuEGx WDx+5IjsRWBFUQosAgPeRAAGIJF7rvltEWH11ttue/7FF61qUMTpiYmJarVqVYMA gC599eWXQckBmEVgwLsIwACkcFu9K8HQ9bvvueeJp56ysM18Pl8oFCxsEADQJRFN jxw8yCIwgHkRgAFYz231rvqadxQ98uij69avt7DNSqUyMTFhYYMAAEvs2blT9uYj FoEBjyIAA7BSIpEINdZ9Iy6pd9Wi1usvvPTSbStWWNhmvV4fGxsTEyAL2wQAWKJa qRzav78/GJTai1KtsgkI8BwXzVABeF0qnRbRNyh5wrFQIqm++fbbmcFBC9tsp/CV yMau+ikAAPjKnl27ApLfhA3DKM/Nlctlqb0AsBaTMwAWSCaTIvdGXHPRUYuIoGJ2 8s7778diMWubzWaziqLc+DGueikAwG8ai8AHDsg+jCN6KRaLUrsAYC3mZwC6lUql RPR128Jv47qjTObVN96wvOXp6elSqWR5swAAa9lwEljXdZGBOQkMeAgBGEDnkslk fzAYddnCb19zRrJq1aonnn7a8pYLhUKesp8A4AWVcvnwN9/IXgSuVCqzLAID3uGu OSsAD0mmUpFIJBQKOT2Qq6mq+uSWLavXrLG85bm5uampKcubBQBIsvvLL2UHYE3T lGqVRWDAKwjAABbMtQu/fc2SV6+//fagpSWvWqrV6sTEBGWfAcBD7LkTuFIuz87O Su0CgFVcN3kF4HKpVCrsyoXfRt2pvr63338/EolY3nitVhsfHyf9AoDnfPXll0HJ AVit13O5nNQuAFiFAAygXW5e+NV1fcUddzzz/PMyGldVdWxszDAMGY0DAKQqlUrf HjokexG4XC6XWAQGvMB1s1gA7uTahd++ZkB96qc/XbV6tYzGNU0bHx+/8ZW/AAA3 +2rHDtlXFdRrtZmZGaldALAEARjATbh54dc0TV3X39q6NZlKyWhfNC7SrwjYMhoH ANijWCweP3JE6iKw+H5ULpfnuCQPcD3XTWcBuEqqWeo56MqFX5FOBwcHX5Fw0+/l 9km/ANAbdn3xhexNTIqiFLgnD3A9AjCA+SWTyWAwGHHlwm9fc2fyQxs2PPDQQ5La F+k3m83W63VJ7ctmGEYgEHB6FADgFvlc7vvjx6UuAos33kq5zH1IgMu5cV4LwHGp dLqx8Cv5xFTHRC595fXXlyxdKql9r6dfAMC1dm7fHg6HpXZRrVaLhYLULgB0iQAM 4B8kEolQOCzSrzsXfk3T7O/vf3PrVhl3HbWw8xkAelJ2bOzCuXNSv7uJ7yDVSoVF YMDN3DjBBeCUVDodjUZl3xXRMU3T1j/wwIZHHpHaRTabJf0CQE+yYRG4UqnMFotS uwDQDQIwgIZkMhkKhcJuXfjta257fv3NNweHhuR1IXKvSL/ceAQAverCuXPZsTGp 3+nEt5Lc9LS89gF0yaUzXQB2SqfTERcv/Oq6nkgkfvH66/K2Pfc1A7ZIv6IveV0A ABxnwyJweW6uxH1IgFsRgAFfayz8Nk/8Oj2Q61JV9bEnnrj3vvuk9qIoysTEhGEY UnsBADju6KFD1UpFahe1Wi0/MyO1CwAdIwAD/pXOZKLRqGsvyzFN09D1N7duTaZS UjuqVCqTk5OiO6m9AADcQFXVr7/6SuqdwOIbSuM2JEphAa5EAAb8KJlMhiMR2XvA uqHr+oo77njm+edldzQ7O5vL5WT3AgBwjwNff61LLvegVKsF7kMCXIkADPiLiL6B /n43L/z2NY/jvvSLXyy/9VapvZimmc/ni9TqBACfqddq+/fulXrXvWEY5bm5crks rwsAnSEAAz6STKUi4XDI3Qu/sXj81TfekH0sWUxNpqene2xqIiK9a4t4A4Cr7P3q K9lvl9yHBLgTUyXAF5LJZH9/f8TdC79qvf7Eli33rF0ruyNN0yYmJur1uuyOAADu VK1UDh04IPX6A/G9ZnpqSl77ADpDAAZ6XyqVCkciUgt+dKlVgOrNd96JJxKy+1IU ZXJysveuO2L5FwAWZNcXX8j+zlgul0uzs1K7ALBQzJaAXtZY+A0Go9Gom6ORpmn3 /eQnmx57zIa+SqVSLpej4DMAIDc9ffrECanfH7kPCXAh986JAXQplUpFIpGguxd+ dU17/a23MoODNvQ1MzMzy0/iAQA/2vn552GZJSe4DwlwIQIw0IMSiUQoFIq4fuH3 7lWrnvrpT23oS9f1qamparVqQ18AAK84f/bsxPi41O+V4ltPkfuQADdx7+QYQGdS 6XRj4Vfm7Q5dMk3z/2fvTvyjKvL9/2frpJfT3QlJAFEEkUV2FAUX3K86Ojqj39Fx HHXuvfNf3u/j+xNRcRmVJRAIm8oSIEknnfR+tj6/SnqGy7CEdPf5VJ/T/Xo+vFwm pKsOJDmn3l1Vn1Lp990//GFoeFhDd5ZlTU1NOcJHPgIAwujrw4f7JQ9HcF23XCox CQwEBwEYaB+LE7/9/Sr9BnniVw0FHlm//uXXXtPTnRpzZDKZNt70S+0rAGjGzz/8 IP0OaalYZAMOEBwMm4A2EY6JX9t+6/e/X71mjYbuqtXq3NxcPp/X0BcAIKTMSuWn H34QfXpaljU3OyvXPoC6EICB0DMMoy8SCf7E75q1a//jrbf0dGfb9vT0NCf9AgAe 6LuvvuqRPBB4sRRWsVjgDVkgGII7XAawEslUKhqN9ko+uZtUm/h94+231z70kJ4e 1ThjZmamjZc9AwB8lF9YOHXypOiTtFKpzGezcu0DWDkCMBBWhmFEIpH+wE/8rl23 7vU33tDTnQq9s7Ozbb/smX2/AOCvb778MiJ5amC1Wi0WCsViUa4LACvEEAoIpXBM /DrOW++8o2fHbxfLngEAjbo+OXnl119F31sslUq5hQW59gGsEAEYCJmw7Ph9+JFH Xnn9dW095vP52dlZlj0DABrz9Rdf9A8MyLVv2/ZsJiPXPoAVCu4AGsDdwjLx+/a7 746MjurpUYXtTCZTKpX0dAcAaEvHfvzRFl5DVCwU2n6TDhB8BGAgHEJxxq+Kvo9u 2PDSq69q67FcLs/MzKgMrK1HAEBbskzzx++/Fz0PiVJYQBAEdyQN4JZQnPGrUujv 33tvaHhYW49zc3O5XE5PdwCAtvftkSO9ko9aSmEBQUAABgJtccdvX99ANBrwid8t W7cefP55bT1aljU9PW3btrYeAQBtLzs7O3HmTE9Pj1wXlMICWi64Q2oAyWRSRd+A T/xWq9X3PvgglUpp63FhYWF+fp56VwAA31EKC2h7BGAgiAzD6O3riwZ74lc9xXft 2fPk/v3aerQsK5PJmKaprUcAQEcZHxsrCNepohQW0FrBHVsDHUul3/6Bgf7+/lZf yH1Vq9Wenp53339fXaqeHj3Py+Vy2WyWiV8AgBzbtn84ejQSich1QSksoLUIwECw pFKpaCwmugGpSZZlPXPw4PadO7X1qIYjMzMzTPwCADT4/uhR0fFxtVotFYuFQkGy EwD3RQAGgsIwjNpBR62+kPtyXVdd4Xvvvx+LxfT06HlePp+fm5tj4hcAoEexWDz5 88+9vb1yXagAzCkGQKsQgIFASKZS0WhU9HHbJMuyXnjppcc3b9bWo23bmUymUqlo 6xEAAOWbw4cjkhuR1CN1bnZWrn0AyyAAAy0W/HpX1Wo1Gov9/g9/0DY7TalnAEAL TV69evXyZbnnsnq6La6BZhU00AoBHXADHUKlX5UqRd9mbpJlWa++/vr6DRu09Wia ZiaTUf1q6xEAgDt8ffiwaDXKSrk8Pz8v1z6A+yEAAy2TTKViAa535bquusK33nlH 58RvNptdWFjQ0x0AAPfzj2+/FV2FpB6y5VKJSWBAPwIw0AKGYfRFIipYBnPZs3rk O7b95jvvrFm7VlunlUolk8nYtq2tRwAA7qdULJ4QLoVVLBbzlMICtAvi4Btob0Yy ubjsWfKMwWa4rvvw+vWvvPaath6r1erc3Fw+n9fWIwAADyS9Cto0zezcnFz7AO6J AAxolUqno9FoMJc9e56n0u/b7747PDKirdNisTg7O6v61dYjAAArce7MmflsVq59 DgQGWoIADGhSW/as0m+rL+TeHMfZtHnz84cO6exRRd9SqaStRwAAVs627R+OHhVd saUegjkqXwB6EYABHRarPUejwVz27Hle1XXf/eMf00ND2nrM5XLZbJZTjgAAQfb9 0aOiY2XbsmY5EBjQiwAMiAtytWfHtrdt3/7Ms89q65FTjgAAYZHP508dPy5XCosD gQH9CMCAIMMwevv6otFoAKs9L078VqvvffBBKpXS06Pqbn5+nlOOAAAh8tUXX4ge B1gulxc4EBjQKHCDcqBtqPTbr+g6RLcutm3v3L37qaef1tZjqVSanZ11HEdbjwAA NG98bKwgeU6BejJWymUmgQFtCMCACCOZjEajfX19rb6QO3lL/vDBB+oK9fRIsSsA QHhpKIXFgcCATgRgwH+B3fSrnuJ79u7d+9RTerqj2BUAoA1899VXPWLbgBWzUslK nrcE4HYEYMBn6cHBAG769ZYy6OLEr2Ho6ZFiVwCA9jA3O3v+7Fm5J3u1Wi0WCsVi Uah9ALcL1hgdCDWVLSOLe34Dt+nXtu1de/Y8uX+/nu7UgzybzeZYzQUAaBfSpbA4 EBjQhgAM+COYJ/3qL/VcLBZnZ2dd19XTHQAAGvz0ww+uZB1Hy7LmOBAY0IIADPgg mUwOBK/kleM4W7dtO/Dcc9q6o9gVAKAtVUqlYz/9xIHAQBsgAAPNCmDJK/UcdV33 vT/+MT00pKc7il0BANrb14cP9/f3y7VfLpUWWAUNyCMAA01JpdMq/Qaq5JXjOJs2 b37+0CE93VHsCgDQCSbGxxfm5+Xat217NpORax9ATYBG7UDoBLDgs21Zb7/33sjo qIa+KHYFAOgc0gcCswoa0CNAA3cgRAzD6ItEVPpt9YX8r6rrGqnUW++8o6cMNcWu AACd5tsjR3ol632Uy2XRSWYAXQRgoAGJREKFzP4gHXdkWdbLr722YeNGDX1R7AoA 0JkyMzMXz52TW/mlnrCqC6HGAdQQgIH6BO24I9d11cX88U9/0jDx63lePp+fm5uj 2BUAoDNJl8IqFgrqUSvXPgACMFAHlX6jsVhwjjuybfvJ/ft37dmjoS/LsjKZjGma GvoCACCYfvz++6rk9p9KuTzPKmhAEgEYWKlApV/P89QD+I9/+pORTGroa36JdEcA AARcqVg88fPPcgcCu65bLpUohQXIIQADK6JyZiwWk3vg1UU9HR9at+61N97Q0Fel UslkMrZta+gLAIDgE18FXSzmOWEBEEMABh4smUxGA5N+tdW74pQjAADuNnbsWLlc lmu/UqnMZ7Ny7QMdjgAMPIBKv7F4vKenp9UX0lUrPfX+hx/GYjHpvtSjPZPJOI4j 3REAAOFimeZPP/wg97Z4tVotFYusggaEEICB5SRTKZU2g5B+XdfdtHnzcy+8oKGj ubk5nrsAANzPN4cPR1gFDYQTARi4r+CkX8uy3nrnnTVr10p3pJ64s7OzrmR9SwAA wu7s6dO5hQW59s1KJcsqaEAGARi4t4CkX8/z1E/pB3/+s/Qxvyr0quirArBoLwAA tAHbtv/x7bdyB0OwChqQQwAG7iEg6VeF0o2PPfbCSy9Jd8TELwAAdfnmyy8jkYhc +6yCBoQQgIE7BaTqlW1Zr7z++voNG0R7YeIXAIAGTF69evXy5e5uqbE0q6ABIQRg 4N8EIf16nqdy6fsffmgYhmhHpVIpk8kw8QsAQANEJ4FZBQ0IIQAD/ysI6VfF0aFV q9557z3pXij1DABAM7776qsescOQulgFDcggAAP/FJD0u2379qcPHBDtpVwuz8zM MPELAEAzMtPTF8+fl1sFXalU5lkFDfiNAAwsMlT6jcXkDrVfCdu2X3ntNdFNv57n ZbPZBcmTGwAA6BxfHz7cL3YgcNV1S6USy7UAfxGAgS7DMGLxeGvTr2VZ73/4YSqV Eu1iZmZG/SrXBQAAHeX7o0dFB9OsggZ8RwBGp1PpNxqLyR3l90Ce56lf/4/kSb+q i3w+Pzc3V+sLAAD4YiGbPTs+zipoIEQIwOhoiURCpV/Rc/yW57ru6Ojom++8I9rF zMxMuVyW6wIAgI7FKmggXAjA6FyGYfQPDMg9tB5IRdOt27Y98+yzcl2op6ZKv9Vq Va4LAAA6GauggXAhAKNDqfQb6e+XW3X8QI7jHHzuuS3btgm1T70rAAA0YBU0EC4E YHSowaGhaDTaqt5ty3rj7bfXPvSQUPsqXU9PT5umKdQ+AAC4RXQVtOu6ZVZBA/4h AKMTpdPpWDzeqt4ty/rjBx+kh4aE2mfZMwAAOomvgi4U8vm8ZA9AByEAo+OkUimV fuWWKi1Ppd8PP/44nkhINM6yZwAA9BNfBV0uz8/PCzUOdBoCMDpLMplU6benp6cl vTuO89EnnwhtPGbZM9BOzErlyuXLC/PzTx882OprAfBgoqug1SM+MzMj1DjQaQjA 6CCGYaj029vbq79r6cN+K5XK1NQUy56B9qDS74/ff69uVurW0d3d/dyLL7b6igA8 AKuggbAgAKNTqPQbjcX6+vr0d62GsNFo9IOPPhJqP5fLzc7OCjUOQDPXdX/87jv1 m9pySvU/e3p6nj10qNXXBWA50qugy+XyAqugAT8QgNERVPodGBiItOLIX5V+jWTy vfffl2i8Wq2q6EtlSKBtzM/NXb1yJZ/L3b5WRWVg9T8PvvBCCy8MwAOJroK2bXs2 kxFqHOgoBGB0hFYdeqTS79DQ0O/efVeiccdxpqamLMuSaByATrl/TexklwJwJBK5 4xNUBn74kUc2bNqk/dIArJToKmg1oigWCrzlDTSPAIz2l0qn46049Eg9q1avWfP6 m29KNF6pVKanp9WYWKJxANrkblvTaNv2+KlT96wUoO4njuMcfOGFu7MxgIDIZrPn RFdBl0oc9AA0jwCMNpdMpeKtOPRoMf2uXfv6G29INM6mX6AN5O7aznd6bKynp+d+ 96taBj70yiviVwagUaKroC3LmuPpDzSNAIx2ZhhGPJHQf+iRXPrlpF+gDdwdfZWJ M2dUvl2+TL3ruuseeWQjC6GBoPru66/lRh2sggZ8QQBG20okErF4XH/ZZ/V8Gh4Z efPtt31vuVqtZjKZYrHoe8sA9Lhn9FU/2ir9ql9XckibY9svMAkMBNXUzZu/Xrwo t+6sVCrleBMcaA4BGO3JMIx+RebQ3WXIpV/XdaempkzT9L1lABrcM/rWTE9PZ6an VzhiVjeZZDq9c/du/y4NgJ+++fJLub36ahiQnZsTahzoEARgtKf04GAsFtPcqVzN Z9u2b9686TiO7y0DkLZM9O1aKud+9vTpvhUPl9V9Rt0QXnz1VT8uDYD/jh45Irf6 rFqtlopFVkEDzSAAow21pPCVGpWm0+l3/vAH31uuVCpTU1Pqmed7ywBELR99a04e P15vyZxahflNW7Y0el0ABJ2fmMhKlqoqFov5XE6ufaDtEYDRbhYLX8XjPSvYSucj NR6NRqMffPSR7y2r59zMzIxq3/eWAYhaSfqdzWSmbt6s99262iTwoVde0V/fHsAD qR/Pf3z7rdwkcKVSmc9mhRoHOgHPTrQVlX4HolH952RWq9W//u1vvjfLcUdAGK0k +taMnTjR2P1K3XOe2L59aGSkgdcCkPbN4cMRscOQHMfJzMwINQ50AgIw2srg0FA0 GtXcqW3bf/7rXwf8Lrg1Pz+f5S1eIFRWHn2Vs+Pjnuc1NourXtjT2/v0wYP6j3kD 8ECnT54sSm7TVY3n83m59oH2RgBG+0il0/F4XHOnlmV99Mkn/hbc4rBfIIzqSr+m aV44d24l5x7dk7pLOI6zecuWtQ8/3FgLAORYpvnTDz80/AP+QOVyeaGeGw6A2xGA 0SaSyWQsHtc8GaLS7//56CMjmfSxTTWunZ2d5Z1dIETqir41J44da37ZSCQS2fPU U/pPOwfwQF8fPlxvfbuVsy2LHVJAwwjAaAeGYUSj0ZWfI+IL27bf/cMfhoaHfWxT pd+ZmZlisehjmwBENZB+r16+nM/nmy9hpe5CT+7fHzcMqmEBQXP8p58s0xRqXI0W Fo9C4jAkoCE8MtEO9G/9dR3nxVdeeXTjRh/brFar09PT5XLZxzYBiGog/XY1Ufvq DqZp7nvqqVg8LlduB0BjyqWSysByq6BLpVKOrVJAQwjACL1UKhVPJHT26Lrunn37 du/d62ObKv1OTU1VKhUf2wQgp7Hoa9v22fHxvr4+X+ZsVWu79uxRrSWSSSaBgaD5 6osvfC+QeYtpmtm5OaHGgfbG8xLhtnjqbyKhc+uv53mPPProiy+/7GObpF8gXBpL v8qpEyd83KxRC8DqBsgkMBBA3x89KjfOViOHUrHIKmigAQRghJj+U39V+k0PDr7z 3ns+tkn6BcKl4fRbKZd/uXTJx6lax3ESicSmzZt7ensT7AQGAmY2k7kwMSH3g1ks FvO5nFDjQBvjYYkQGxwcjPp6/tADVT3vr59/7meDpF8gVBpOvyqsjp865W9VWNd1 4/G4CsDq9/FEQnMhQAAP9M2XX8q9TV8pl+c5DAmoHwEYYZVMpdTIT+eMh2VZH3/6 qY/7eVT6vXnzpilWJRKAjxqOvjUXL1ywLcuvi6nxPC8ajdYCcF9fX9ww/G0fQJOO Hjkid1CZY9uZTEaocaCNEYARSoZhxOJxueKKd1s89Oj994eGhvxqkPQLhEiT6bdY KPz6yy++37JuD8CKkUz2aLwrAnigifHxBbFJWg5DAhpDAEYoDa1aJVdZ8W6u6z53 6NCmxx/3q0HSLxAiTaZfx3FOj41J3LLuCMD9AwOad4UAWJ5t2z9+9x2HIQGBQgBG +KTS6Xg8rq07NcR8bNOmZ194wccGVfpl3y8QCk2mX+XCuXMqA/tyMXe4fQ+w0t3d baRSlMICAuXrw4f93fx/Ow5DAhrAYxIho/ncIxVWk8nku++/72OD09PTpVLJrwYB yGk+/arhqQrAQvM/tm3v2bfv9o9QCgsImp//8Q/HtoUa5zAkoAEEYITJ4rlHAwM6 j7t0HOez//ovv1pT6XdmZqZYLPrVIAA5zadfZezECbkasCpd73vqqds/ovqKJRJC 3QFogHron/z5Z7lV0Cr+5vN5ocaBtkQARpikBwdjGne42Zb1wUcfGcmkXw1mMhme UkAo+JJ+c7nctStX5NYkW6a5998DMKuggQD6+osv+sUKl5TLZbk6W0Bb4hmJ0FBB NJFIaBvYua77wksvbXzsMb8anJubW6BSBRAGvqRf5eSxY3KjXqWnp2fb9u13fDBu GHLHrgBowHfffNMjNnqxbXuWw5CAehCAEQ6Li5+jUbmVhHfwPO/h9etfeuUVvxqc n5/PZrN+tQZAjl/pN5/LXZWc/nVd9/EtW+5eFEMtaCBopm7e/PXiRaG7AYchAfUi ACMcNC9+Vo+TTz7/3K/Wcrnc7OysX60BkONX+nUc58ypU6IFC+7eAFzT09vr48YN AL745siRiNjSDA5DAupCAEYIJJPJuMbFz5ZlffTJJ37l7WKxOD097UtTAET5mH7P jo9Lr0NW6Xrzli33/KNkOs02YCBQvvnyS8F6eJUKq8yAleMBiaAzDCMai2nb0uY6 zhtvv716zRpfWqtUKjdv3vQ8z5fWAMjxK/0qhXz+yuXLohHUtu0du3bd78bIYUhA 0Bz/6SfLNIUad123XCqxChpYIQIwgm5wcFDbfjaVVDdt3nzwued8ac2yrBs3blSr VV9aAyDHx/SrnDh2bECy9lXN9p077/dHA9Go+k/6AgCsXKlYPMFhSEAwEIARaJoX Pyt/+ewzX9pxHEelX/WrL60BEOVjAL508aJZqbRw+lfpi0TinAYMBMzXhw/3i9UF 4DAkYOUIwAguzZWffdz6W61Wr1+/rgapzTcFQJqP6Xd+fv7alStykzw16q64eevW ZT6hp6fHSKVErwFAvb776qsesZuDGsPMUW4TWBkCMIJLZ+Vn13Vfff31dY880tjL Hce5NRvjed7NmzcrlYp/VwdAio/pV90Hxk+dkpvhqbFMc+eePQ8si0AdLCBoLpw/ PzczI9R4tVotFYtsAwZWgqcjAkrn4mcVWddv2HDopZcaeO3t0bfW1MzMTLFY9O/q AEjxd+vvqRMnpEtPqTvMyOpFD/xMI5Xq6ekRvRgAdbFt+x/ffitX1FONPfK5nFDj QDshACOINC9+dl330//8z3pfdUf0rclms/NswgHCwN/0e31ycj6blX7P7n5n/94t YRi9uornA1ghtgEDQUAARhCl0+lYPK6nL9u2P/joIxW563rVPdNvoVCYEVvdBMBH /qbfSrl84fx56dPaPM/buHFjfGU3K05CAgLopx9+cMWqY6rxzGwmI9Q40E4IwAgc lUXV0E3P4j3XdZ96+ullThNZubqO/FWfxvY8oFX8Tb9dus49Wvn0rxKLxyPCu5EB 1Cufz4+fPCk0AFBDi8VNwGwDBh6EITgCZ9XwsHQVmVv6+vo+/Mtfmm/Htu3r169z 5C8QfL6n3wvnzqk7gPRbWq7rPrphQyqdXuHnR2OxfvlMDqBeoqug2QYMrAQBGMGi hndxXYufLcv6+NNPVz5vo/LtPeelOfQICAvf0+/c3Nz1a9ekzz2qqWutCgEYCKaj R47IbZeoVCrz2axQ40DbIAAjQAzDiMXjeoaSTZ57dIvneVNTU+VyubHXshAa0Mb3 9Gvb9tnxcQ3l+lRHGx97bOXTv10EYCCoxk+elFul7DhOhlokwIMw+EaADA0NDUSj GjpSyXN09er/eOutlb/knlWvlEwmk8/n/bs0ACJ8T7/KyePHNezXUPereCKhAnBd ryIAA8FkVio//+MfQu/1sw0YWAkCMIIimUrF43E9M6K2ZX3+9783304ul5udnW2+ HQCiJNLvpYsX1UBWwy3LNM2tTzxR794QAjAQWF9/8YXcj2epVMotLAg1DrQHAjAC wTAMNVyTPkSkxnXdN373u9Vr1jTZTqVSuXHjhi+XBECORPpV48trV69qSL+e56XS 6UfWr6/3hVSBBgLru6++6hHb7WVWKlm2AQPLIgAjENKDg7FYTENHajT50MMPv/La ayv8/PutfFYfn5yc9KXs8/1qawFonkT6tW373NmzeqoVWJb1xPbtDewNiRuGnrcU AdTr/MREVmz5mOu6M9PTQo0D7YEAjNYzkslEIqFp8bNtf/7f/91kIyqy3rhxQw1M fbkkAEIk0q/jOOOnTuk5qk31NTo6unbdugZem0gm9UR0APVSQ5F/fPut3FtUhXye bcDAMgjAaDHDMAYGBvQs1VOjyd+/997Q8PBKPnmZidnp6elisejrpQHwmVD6PT02 tvKz05pU9bztO3Y0tkLESKVYWgIEluhpwGwDBpZHAEaLaTv41/O8hx955KVXX22y nfn5eXbXAAHXBunXsqxH1q8fHhlp4LXd3d3Jes5MAqDZD0ePyjVummZ2bk6ufSDs CMBoJcMw4omEnmmKuhY/32/rb6lUmpqa8vW6APhMKP1OnDmjbVGx53mxWOyxxx9v 7OXqOhPJpL+XBMBH01NTv1y4ILT5i23AwPIIwGglbQf/qofBm++8Mzo62kwjKkJf v3694cJXV3777cbkpIrQt38wHo8PDQ8/8uijeqbBgbbXBum3q4naVzWR/v4YtxQg 2L758stIJCLUONuAgWUQgNEy2g7+9Txv9dq1r7/xRjONNFP46vhPP2VnZ72urt6e nu5/n+72qlW3WlWPwM3btq17+OFmrhCARPpVfrl0yaxUJFq+J9u2R1evfqih2lc1 HAIMBB/bgIFWIQCjNRYP/o1G+8Te+7ydbVmf//3vTTYyMzPTwJup0zdvnjt71nXd B+R8z1Ofk0qnH9+6dWjVqsavEuhUQtHXcZyFbPbGjRt6pn89z1O/9vX1bX3iiWba SRhGL2cgAcH20w8/uI4j1DinAQPLIACjNdLptJ4VeipYvvbGG83MpSi5XG62ziP7 bNv+5vBh9ZvFHc4rnOX2PMd19+3f31jZG6BjCaVf5cbk5LxY43dT96tIJPLoxo1N noueTKf1HCwHoGEqoJ4bH5faBuw4MzMzEi0DbYAHJFpAZ+2raDT6/ocfrvCT71n7 yjTNGzdu1GZmVmj65s3xsbGe+qeMvGpVPQs3bdmyfsOGel8LdCa59DubyVyfnJQ7 q/NulmnufeqpJhvp7etLGIYv1wNAFNuAgZYgAKMFhlat0nOUiBpNfvzZZ8305bru 9evXnXoWKV357beL5841vP6wp6fHdZx4InHg+ecbawHoEHLRt0v7oUddS8tGtm3f 3nyPA9GonuKCAJrENmCgJQjA0C2ZSiUSCQ0dqez67PPPP75lywo/v1qt3jEp7Xne 1NRUuVxeeac/ff99LpdrfruguvhNmzdv3LSpyXaAdiWaflUWHT91Smf6VT/yo6tX r1m7tvmm2AAMhIUaM6iffaHG2QYM3A8BGFot1r6KxfQsKezu7v7400+baUE9Oera /nfi55+zc3N+Le2uuu6rb77pS1NAOxGNvjUnjx3TXEXZq1Z37N7dfDvqvmekUmwA BkJhbnb2/NmzQj+wjuNk2AYM3AvPSGg1ODQU1bI2z7btP/35z/EmpprL5fLNmzfr 6vHbr75quLu7VavVhGEceO45H9sEwk5H+j1+PBKJ6MyQlmnu3LPHl3cGOQEYCJej R47IzQqwDRi4JwIw9NG2+NnzvO07d+5ropaM4ziTk5Mqgq7w86du3Dg9Nub7M0z9 RXbt2TOyerW/zQJhpCH6qh/8s6dP9/b16Uy/qtPHt2yJ+5Ra44mEnuPlAPhCdhtw sZjL5YQaB8KLAAx9Vq9Zo6fys+s4n/7XfzX8chU7b968WalUVv6SL//f/1v8WRIY NKtQ/cLLL/veLBAiGqJvzcXz523b1tNXjY9bf7tY/wyE0D+++85b8bvt9VIjmXm2 AQN34TEJTbQtfnYc5/d//OPQ0FDDLdS79ffH778v5HINHHq0Euqv8/pbb0m0DISC tvT72y+/lEolnenR87xIJLJl2za/GuwfGIg2d4AwAM1mM5kLExNCdx7btlX7Ei0D oUYAhg6GYSQMQ8/IMpVOv/Peew2/vN6tvz99/31epd+eHv+nfz1PtVmtVh/dsOHx rVt9bhwIPG3RV7l08WK5VGq+fntd1Nh0z759PjaYSCY1/xUANE/uNGDP8wr5fLFY lGgcCC8CMHTQNv1rWdbHn37a8OEl9W79Pf7TTwvZbLfwum71AHvlP/5DtAsgUHRG X2Xy2rWF+XnNK4dN09y5e7ePo14VfVUA9qs1ANqIbgNW6TfPNmDg3xGAIS6ZTMYT CQ2DS9d1X3z55Uc3bmzs5fVu/R07fjw7Oyux7/ffeF5fJMI2YHQIzdFXuXb1am5h QXP6tW17y7ZtMV+XK8fi8YjYGBqAHNFtwOVyeUH7fRUIOAIwxK0aHpZ7a/N2Pb29 f/7kk4ZfXtfWXzV+/ebwYaF9v//G89TQ/KXXXxfvCGgp/dG3q0Xp13XddevWrRoZ 8bFNyl8B4TU9NfXLhQtCP7+WZc3Nzkq0DIQXD0vISqVSzRzGu3IqkX74l780PKNS 79bfr7/4oup5jfVVr6rr7n7yyZHRUT3dAZq1JPoqV377LZ/P6ylNf4tKv4NDQ4+s X+9vswPR6ICWbSYAJBz98kuhA8yq1WqpWOQ0YOB2BGAIMgwjGovJnfB+i+d5W7Zt e/rAgcZeroakk5OT6tcVfv7szMypEyekt/7eogLwnqeeGvZ1vghouVbl3hqVftWI UPOUqe9ln28xUinNSR6Aj2S3ARcK+XxeqHEgjAjAEJQeHPR3k9v9OI7zWRMH/05N TZVKpZV//hf/8z+98ql+Ua0QtOuuW79+2/btOnoE5LU2+na1Lv16XV07d+3yvWVO PwLC7rtvvukRuyOVS6WFhQWhxoEwIgBDimEY8URCw6SE67pv/O53q9esaezluVxu tp7tMafHxmanp8VrX92mWq1u27Fj3cMPa+sRENLy6Kv8+ssvZb3n/dZYlrX3yScl Wmb6Fwi7CxMTcjt1TdPMzs0JNQ6EEQEYUgYHB/VMSgwMDHzw0UeNvVYNSa9fv+6t eDevvtpXt3Ec5/W33tLZI+C7IETfrqX0WywU9B+Wa5nmzj17JPaDRPr7Y/G4780C 0EndIn764QehW5PrujPT0xItAyFFAIYIbdO/zRz8W61WVfpVmXblLzl65IiKow30 1TjPWzUysnvfPq2dAj4JSO6t+eXSpUq53IK5X9N8YufOhs8nXx7Tv0B7EN0GXMjn qYMF3EIAhojBoaGofElSz/N27927a8+exl6eyWTuKAuhIvEyQ8mWTP+6rvvam2/q 7BFoUqBC7y0XL1xQQVR/+rUta+sTTwgth2H3L9A2jh45Ilc0tFQq5dgGDPwLARj+ 07f713E+bbT2VbFYnK5zRdDP//hHQXMdRc9To9uDL7ygtVOgTsFMvLe7cO6cbdst SL+2vXnz5rhhSDTO2b9AOxk7frxcTz3OulQqlflsVqhxIHR4cMJ/enb/ep73u3ff HRoaauC1juNMTk5Wq9W6XvXF//2/mrcOVl334KFDcTb4IXiCH3pvmThzRv2w6w+K 6j6z4bHHUqmUUPsDsZjQsmoA+pWKRZWBhe5Utm3PZjISLQNhRACGz7RN/6oR7V// 9rcGXqiS882bNyuVSteD1jzfQXcA9rw1Dz30xM6d+noE7i9Eifd246dOdS/R3K9K v4+sXz+0apVQ++rGlUgmmf4F2sk3X34ZiUQkWlYjn2KhwDZgoIZnJ3ym5+xf13U/ /MtfGpv9WFhYmKv/PADTNL/76qtubcVmPC8Wjx94/nlN3QH3EtLQe8vJ48fVaLIl 6Xfdww8Pj4zIdRFPJPpkBsoAWuWbw4cjYnWwVADOa97GBQQVARh+MgxDpd9esSoO NZ7nPbZp07MN7Yyt99yjrn/NEs/Nzp46caKBHuujLkwN1qn8jBYJe+K93dkzZ7wW rXxe+9BDo6tXy3Whoq8KwHLtA2iJn374wRU7aaJcKi1QBwtYQgCGn5KpVEJ+WKbG l581VPtK5d7Jycm6zj26ZT6bPXnsWAMvrJvnJQzj6Wef1dEX0F6ht0bdIsbHxiL9 /frTrxq8jq5Zs2btWtFeOPoIaEtzs7Pnz54VunGZppmtf/kb0JYIwPDTquFhuVPs atTQ9r0PPkin0w28dnZ2NpfLNdavis3fHjnSJTyerrru2nXrtu/aJdoLOlz7Jd7b qVvE2fFxudNEluG67ujq1dLpdyAaHZA/ZA5AS8htA1b3xszMjETLQOgQgOEbwzAS hiE95ZJKp995770GXlgul2/evNlM14f/7/8VPATY89Toefe+faNr1kh1gU7V3on3 dqZpqvTbktrI6ud3ZGRk7bp1or309vbG5W+zAFrl68OHhSYSqIMF3MJDFL5Jp9Mx 4QN7LNP8+LPPGhjdqrHp5OSk+rWZ3uWqQKsLi8fjzx46JNE4OlDnJN7bzc/PX/nt N6HJk+XpSb9KIpnUfBgbAJ2+++orubfai8VivtF1cEA7IQDDN8MjI6JDT8/z9jz5 5M6GlgdPT0+r+36TF/D//c//+L6uslZha9/TTze2qBuo6czEe7vLv/6az+dbEg61 pV8WPwNtb3xsrCBWq7lcLi90/MMC6CIAwy9GMmkYhmgXDde+KhQKM37se/FnCXSt zrP6/yr7et7mrVsf3bix+WtDpyHx3mLb9plTp1pS8qpLV9WrLhY/A52hUiqdOHZM 6Cfdsqy52VmJloFw4VEKf0ivf3Zd9+VXX33k0UfrfaGKzZOTkypsNn8Nk1evXjx/ vvHX/yv6di0Vu1q/YcPmbduavyp0CBLvPZXL5fMTE9K19+5H3V5Wa0m/XSx+BjqG XB0sNRYqFYtsAwYIwPCHdP1nFYA//c//rPdVnudNTU2pIbIv12Db9tEvv+xu7vQR r1pVo9g9+/ez5hnLI/EuT4XPK5cvq6FcSwo+d2k57/eWaCzW34rKXgD0k6uD1bW0 Jk5uiTUQFgRg+MAwjHgiIXcupUq///HWWw1Ms+RyuVlfV/t8e+SIXe8h9bcmfpfq PG/fteuhhx/28ZLQHoi7dSmVShcmJlqYCVX6fWjdupHRUQ19qYQfSyRY/Ax0iH98 +62nRg4y1M0zt7Ag1DgQFjxQ4YNkKpVIJOTadx3n0/p3/9q2PTk56e9TZHZm5vTJ kw2cBlx13ZHVq3fv2+fjxSCkyLrNUMnzt19+qVQqLVwPrK5h3cMPD4+MaOhL5V4j mWxy4QmAEPnl4sWZqSmhxtXNcz6bFWocCAsCMHyQHhyMxWJCjasEe+ill9Zv2FDv q27cuGGapu/XU18pLM9zq9VUOv3Ypk3DWiaLEChkXR+p2Hnp4sVyqdSSY35vv4yH 169ftWqVnu7ihtGqNd4AWsK27R+/+07oPT7bsvxdGQeEEQEYPlBjQbm1iOpJ8Pl/ /3e9r8pms/My2ePrw4dXVFJrKfqqgfK27dslLgNBQ9YVNXn1aiaTaVWxq1vU7Wjj xo2pwUE93XHuEdCZ5LYBUwcL6CIAwxejq1fLLUdcvXr1a2++WddLTNO8fv260PWo EfA3X3557w3PS8utXdeN9Pfv2LVrIBaTPhoKLUTi1WMx+s7MtOqUo9upn/1Njz9u JJN6uuuLRGLxeMv/1gD0O3rkiNzSD+pgATxZ0SyV8RJip1M6jvPRJ5/UteLR87zJ yUk1VJW4nprxU6cyd+3PcavVWCy2a9++pK7xMTQj8eq0uNf311+L+XwQom/X0rrB zVu2xHW9pdXT05NIJoPwFweg3/GffrIE9nDVUAcL4OGKZolWwGrg9KO5ubkF+Tv7 lcuX7/jIo3XuUkZYkHs1M03z0oULKgALnYTZAMuytmzbFpc86vwOnPoLdLJsNntu fFzoLTDqYAEEYDQrlU7LjQvXPPTQq6+/vvLPF138jI5C7tVvbm7u6uXLPT09gSr7 ZJnmEzt36qy8FYvHI63e7Qygtb758kuhNwGpgwUQgNEsuRLQrut+8OGH8RVPL2tY /IxOQPTVzDTNXy5eVDkzIKudb6eubbve9EvhKwDKV198IXTnoQ4WEKyhBsJocGgo KjNcsyzrb3//+8o/X8/iZ7Qxoq9OjuNcuXw5t7DQ19cXzOW+Kv3u3L1b50ps1VdM 8kx1AGFBHSxADgEYzRpatUroTUrXcT79r/9a4SdXKpUbN25IXAY6AdFXm1ruzS8s 9PT2Bmqp8x0slX737NF5hb29vXGxgoIAwoU6WIAcHrRo1vDwsNB2tUgk8qePP17J Z1ar1evXr7P4GQ0g+uphmuaV335To66gbfG9m+d5KqXv2LVL53WqfxaVfu99vhqA zkMdLEAOARjNkgvAqXT6nffeW8lnzs7O5nI5iWtAGyP6alAoFFTutSwrsOuc7+At 2bl7t85O1Rg3odJvGP59AGhDHSxACAEYzZILwGsfeuiVFZSAZvEzGkD6lWPb9tXL l/P5vMp1KveGaE2vir49PT1P7NihuV+VfnuDPSsOQD/qYAFCQjMuQWC1NgCrm/jk 5KTjOBIXgLZE9JWgfgZvXL8+n826rhuWyd47qPQbiUS2bNumud94ItEXmBOPAQSH bB2sfJ4AjI5FAEaz5ALwquHhN99+e/nPYfEz6kL69ZEKvTNTU+pn0HUclXhDPYep cnvCMB7btElzv7FEQmeVaQAhIlsHq1hk+ISORQBGs+QCcDQaff/DD5f5BBY/Y+WI vr5YnOmdnJyfn1eJsTfYZZxXTv1dBoeGHlm/XnO/sXhc6OYJoA2I1sEql8sLPBbR qQjAaNaq4eF+mTGc53mffP75/f6Uxc9YOdJvMyqVyrWrV0vFolet9oZzefMyVPod GRlZu26d5n6jsVi/zO4+AG1Drg6WaZrZuTmJloHgIwCjWXLnAFuW9be///1+f8ri Z6wQ6bdetbXN2WzWtu3QFbKqi0q/ax96aGR0VHO/pF8AKyFXB0vd5zMzMxItA8HX nmMa6DQ4NBSNRiVaVnfnjz755J63/nK5fPPmTYlO0U6IviuXW1i4fv26Wamo3/cu afUViVN3mPWPPqruYJr7HYhGB2TumQDajFwdLM/zCvl8sViUaBwIOAIwmpVOp2Px uFDjW7Zu3X/gwB0fZPEzVoL0u7xSqXT92jX1q/qB6unpaeNp3ntSN5DHHn/cMAzN /fYPDERjMc2dAgipn3/4QW60o9JvnpV06EgdNNyBkFQqFU8k5Nr/y2ef3fGRTCaT z+flekQbIP3erZZ4y0uJt7vzEu/tbNvesm1bTHsQZe4XQF0u//rrzevXhRpXj4OF hQWhxoEg69DRD3xkKMmkUONqnPrnv/719lXQLH7G8oi+NY7jzM3OZrNZs1LpzDne +7Eta9uOHULb6pbBvl8A9VKjoB+/+05oT0qlUpnPZiVaBgKOwRCapfJvPJFQw2uh 9tc/+ugLL71U+z2Ln7G8Tk6/apx0c3IyXyiogNfV3d0h+3jrZZrmzt279R+9S/oF 0JivDx8WOmtDPTVmMxmJloGAIwDDB8MjI3IDSnWD/vy//7v2eyo/YxkdlX4dx5mf m5vLZs1yubakWcVdufeh2oNKv7v27NF/djHn/QJomFwAVs+OUrFYKBQkGgeCjAAM H8gVgu5aKlT4wosvPrpxY6VSuXHjhlAvCLu2T7+Vcll9/6uhius4TPDWS91GHMfZ sWtXC9JvIqF/whlA2/j+6FG5wbpKvwWKqqDzEIDhA+k6WGrk+te//Y3Fz7intoy+ i+uZb9zI53LqNyq8sYO3GbV/wCd27NDftbox9pF+ATThzKlTcrWaS8UiC+vQgRhO wQeGYSQMQ250rsavO3btSg0OCrWP8GqP9Os4zszU1EIuZ5mmx3pmX6m7R//AwOYt WzT3q+6HKv32ap9wBtBmVEYdO35caIhVLpcX2uIxCtSFAAx/iG4DVizLevHVV+Xa RxiFN/0W8vkb169XymV3qT5zz1LibfVFtSfLNPc+9ZTmTtUXNG4YvIUBwBffHDkS kXk3zTTN7NycRMtAkBGA4Y/04KDooZqe560aHt66fbtcFwiXEKVfNcK4ef16oVCo reGvxV3WM+uh/s13792rs8fevr54IsHXF4Bf5OpgqTtkZmZGomUgyHhCwx/JZDJh GKJdOLa9/8CBaDwu2gtCIeDpV2XdG5OT5XK5tp6Z7bstpP7lde7+jfT3R2MxvtwA fHT0yBGhAn6e5y2WgaYQNDoMD2n4ZnR0VHrDm+M4L7z8smgXcmzbzi0sFItFs1yu VCq14ka3/lSNmNXjrb+/PxKJxBKJ0dWrqRx7T0GLvup78tqVK+oLV1pSXVrSTOIN DhVHH9u0SU9fA9Fo/8AAX3oA/vrx+++rrivUeHGxDjSFoNFZeE7DN4ODg1HJVdBd S29Vrl23bqOu4WzDKqXS5d9+U3HXXKpptJhuu7vr2uepcpR62nlLEVm9UA2sh4aG 1m/YoIbXolcecIFKvyruXjh3rld9Wfv61BeK2BNMo6OjI6tXa+goGo8LrVEE0MnU 8+XCxITcTl0KQaMDMWKDb4xkMiG/881eWggdC9hC6Eql8suFCwvz847j1OZyJf4d XNdVuVg9DOOGsWXr1mQ67XsXQRaQ9Guapsq96gvBNG/wqR+ZJ3bskD77V30bxBIJ /ScMA+gEtmXlc7mJM2eEaiVSCBodiNEb/DQ8PByRnwNRD4NDAagIraL4pfPnZ2dn q67bu0Rn757nLYbtnp7HNm1a98gjOrtuiSCkXxV9a0MQKjaHhfoh3bNvn2gX6ptB pV8KPgMQUi4W1a1s7MQJoY1RFIJGByIAw0+pdDouPzersp+RSu3as0e6o3uqlEpn xseL+XxvX18QgtA/k3B397YdO0ZGR1t9OSJann7Vv7CKvl1Laae1V4K6WJa198kn 5dqn5BUAUeoRX8jl1K8njx0T2gNFIWh0IB7b8JNhGLF4XENIcF1389atq9eule7o FrNSGT91Kji5927qAWnbdu2wqHYqoNXa9Kv+SRcXPLuudIE3SDBNc5/YIcAq+nb4 nnwA0lQ6LS2VaD514kSfzJOdQtDoQARg+Ez6QOBbbMt6+uBBDaciXZ+c/OXChbpK WLWWymyxeHzPk0+2QQxuYfqtVCoq+qrfsLczvISWQLPpF4AelXLZMk31m3MTE3KF oBfjL4Wg0UkIwPCZYRhxXTviLMt6UWwzsHrknB4bKxYKKkaGcYmj+sdZu27dlm3b Wn0hDWph9FVf9EsXL4boLQ/cj+d5O3bt8rdNNv0C0KaQyy0Wv+zqmrpxY45C0IBP wjesR/BpOA+pRo1u+yKRpw8e9LdZ9SQ4efx41XXDPsNTWxS9dfv2NRrXivuiVelX jQB+vXSJMldtw/dDgPsHBgai0TC+IwYgdNQ45NbEbK0UBYWgAV/wFIf/dE4Cq4w3 tGrVth07fGmtWCiMHTum2mynDZ+u60YikX1PPx2WFdEtSb9qkHHp4kWir35yRyir ljds3JgwDH+a6+6OxeNh+SEC0AbMSkX9d+t/Ugga8AsBGCK07QTuWgp4G5s+CqhU LJ74+eeu9i3za5nmnv3704E/Olh/+i0WChcvXCD6aqZ+bB3bVr92LwVLiS4cx9m9 d68vTfX09sbj8R6+QwBoVMjnb9/3e+LYsQGZwnu2bc9mMhItA8FEAIaIRCIRTyS0 JQo10t2xZ8/Q0FADrzUrFfVQcR2n7fOPChsPPfzwY48/3uoLuS/N6bdUKl08f569 vtrU1uSr70M1pFs822Op6Ojg0FA0GpXozq8KWP39/QOcdQRAL3WTzC8s3P4RuULQ 1Wp1empKomUgmHiiQ4qeM4FvsSzrqQMHVPBe+UvU+Hh8bKyQz3fOskaVPYZWrdru d1kgX+hMv+pLf+7s2a72nfAPjto51e4SlXuLxeIdn7BqeFglTImuLdPc2+QZSN3d sVgsInN5ALAM27LKpdLtH5EtBJ3PcxISOgcBGFIMwxiIRnVmS9M0Dzz//Apnk27e uHH+7Fmh1URBpgKJ+ls/+cwzrb6Qf6Mt/aowduniRatSEXofHV1L32OLK5wdR43V qtXq8oOq0dWrhd6GaHIGmGrPAFqoWCio2+jtH1HjFrmdusViMU8haHQMAjAEJZPJ eCKhc+mgysDPvfji8qm7Uir9/OOP6qo6dvZvsexQT8/B559v9YX8k7b0O3ntWmZm Rmi+scPdmuldSei9xVCSSblLavgMpIFotH9ggGXPAFri7vXPXcKFoEulUu6uHoF2 xdMdsuQ2+N2PbVkHDx26Xwa+MDExffMms3/q4RqNxfbt39/ay9AWfdWj/cK5cyE9 0jmwVNCtTfOqyOutOPTeLplK1bVtoS6xeHzjY4/V+6qenh71wnaqAw8gdNSttXSv O6pcIehKpTKfzUq0DAQQY0HI0lwNq0YNyJ9/6aU7PlgsFI79+CMR6Bb1rzS6Zs2W bdtadQF60q8aRlw4f961bSJN8zzPU3HX+dc0761CVg1Lp9NCJaDVtT32+OP11qKP 9PdHqXcFoNXKpZJtWXd/XK4QtGVZc7OzEi0DAcRjHuKSqVQ8Htc5prx7ie+Fc+cW J36JQP9OZeBNmzevXbdOf9d60u9cJnPlypUO3Onto9o0r1tLvA1N8y5jaGhoICAl oKl3BSAw8gsLaiRz98dPHj8utItH3eczMzMSLQMBRACGDnLD3PtRT47evr5nnn22 Uqn8/MMPvb29zOrck8oJ+w8cEJqFux8N6Vf9vSbGx7s54qh+KujeKtq88t28jRke GRFazldXCei+vr5oPE69KwBBoG6/xXz+nn80fvp0j8xgRo2aioUChaDRIYgE0MEw jMVtdXqjSG25ZtXzOueUo8Y4jvPCyy9r605D+p3LZK5evUqxqxX63/pVS3O8zS9s XiF1W0gYhtA7UysPwNGliV/eIAMQEPdb/6z8eulSpVIR6ncx/t4neANthkc+NNG/ EBorpALPw+vXr9+wQUNf0ulXBbnzExMqyDHxu4z/nePVm3jvkEwmVQAWanwlJaAX DzqKx3v4VgEQJPdb/9y1VNDxt19+ERpKcRISOgdpBPqkBwfrrUkDPSzLevb+pbP9 Ip1+i4XChfPn2fF7t9uXNKu829WixHuHVDodF1t7H08kNmzcuMwncNARgABSN+rl p2FPnTwpVNCkXC4v6DqaAWgtnv3QxzAMFU4oMxNQ3d2iJwNLp9/Lv/6ay+Woc9a1 NPl5a4JXonKVX+RKA6h/gce3bLnfWyE9SxO/rBEAEECVctkyzWU+Qa4OFichoXMQ gKGVysBx1hwGkuM4Tx88KBRIRNOvuvKzp0/39vV15mze4l73pSXNtR3vLVzSXK+R kRGhE7mXKQHdr2JxNNqZ3yoAgm+Z9c81nIQENI9BAHRjM3BgqQypMrC/bUpP/JZK pfMTEx217PnWDl6vdhRvUCd4l5dIJIxkUmcFrMWJ31iM46ABBNZi4f0H7cIdO3FC aL8SJyGhcxBC0AJsBg4m27IO+roTWDr9zmUy165da+8q37USzdV/CWncvVsylVIZ WKhx9S+2e+/e2z/CxC+A4KuUStZ96j/fMnHmzPJTxA1TzS7Mz8tVmQaCg9EAWsAw jEh/f0fN2oWFiiU7du/2pSnp9Hv1yhX1qG6znZy3b9/1glSwynei74KprLvp8cdr v2fiF0BYPHD9c9fSs0/usCLVcls+cYA7EIDRGioDR2MxShYFjWWaL772WvPtSKff 8xMTlmWFPf2Gd/tu84aHh4Xq4al/w02bN0eXdrNT6hlAWDyw/nONaZqXLlzgJCSg GQwL0DIUxAogFcb2HzjQZCks6fQ7fvp092LV6vDdvv65nvlfxxG1zXrmei3+7CcS PT09Eo3XKmBR6hlAuJRLJftB659r5E5CKpVKuYUFiZaBQAnfCBLthIJYARRLJO5X QXclpAs+j586FYlEwvI9U0u8t5Y0d84E7/JENwCbpnnw+eeZ+AUQIurpsDj1urLN vWPHjwutoKmUy/McBYwOwPgALZZKp2OxWOcMVWurXr1/ufXx7qV/gu6eRa3917At 69Crrzb2Wun0e/rUqYEwnCOtvrL2ko6d412e6AZg9fP13IsvCjUOABLUA6604ofF yWPH+mWqqJimmZ2bk2gZCJROSR0IsjYuCn1rAvDWiTXq11KxuMxLFtdtqgy8lIN7 env7+vo0L+N0bPuFV15p4IWi6VeFyXGVfgNfOE19uS3Lch2nuOxXucOtGh7uF3sj Y3DVqm3btws1DgAS1MBAPXxX+Mknjx8XuoWqR+1sJiPRMhAoBGAEwuDQULS5fafB UZv9q1U28mXJazKZVEk4EonoqRmmrnnr9u0qotT1KtKvyr1M+a6E6AnA6ufu6YMH heZGAEDC4vrnenbejp8+3SNzC61Wq9NTUxItA4FCAEYgtMHBSIu517IWZ3tlZv/U P1F3T09/f7+GY28HotF9+/ev/PPFVz6PjQX2e0N93VX0dWw7L3YuRZtJpVJxsQ3A fpUxBwBt1OChXCqt/PMvXbjwwOOCG8ZJSOgEBGAEhQp4KuQI1XUQZdu2szTlq+eZ kUqno9GoUAXdmqrrPvfSSyv8ZPGqV2NjwZzQU9HXNE11hXJHMrYl0eUeruM8//LL Qo0DgIRioaDuXSv//OmpKbmFyupieD8XbY8AjABZzMDRqIYZTl/8c+rPcfQfmmck k7FYTG5v8Mqn0TTUfJbbLNqwarVam/XlbfIGjI6O9oot5lf3kJ179wo1DgC+Uw+U Qp2jCPVwnDhzRmgMUCoWcxwFjHZHAEawqPFrNBbTs9m1YYvR1zTtluafZDIZTySE NlKqv9qhB9XBkj7sVxk7cSJo74YQfZtkJJPqZ1yocdd1nzpwoG2qCQDoBGo4USmX 632V3POxXCotcBQw2h0BGIGjxseLlZD1lj5eodqsr21ZQcg/q1atElob7DjOC8uu I9WQfsdPn+5eOh1KuqMV+ueCZ6Jvc9LptPrpFmpc/Wy+2OgJXgDQEoV8vuq69b5K 7iSkSqUyn81KtAwER1AGl8DtpJf4NkblXiU4e2NS6XRcJkuosLf/4MH7vbusIf2e n5hQITwg6TcIE/5tY3h4WG6f/wPfuAGAQHFdt9jQoELuJCSOAkYnCMT4ErhbMpmM BiYDq0eUWakEbVeM6GrSxzZvXr1mzd0f15B+f/vtt1KhEJD0W5vwD867HqGmvl0T hiH3lU2mUjt27xZqHAB8VymXLdNs4IWnTpzok1kCzVHA6ASBGGIC95RcmgfuaWkG ri18VRFI4mSjJonGCZV+VQa+44Ma0u/N69czmUwQ3vhwHEd96fVXOGtjcmsWujgB GEDYqAFGIZ/3qtUGXnvm9Gm509RnpqclWgaCgwCMQFvMwPG46JE/y1iMQJVKkGf/ RlevFsqKd0+maUi/c3Nzk1evtrwEWrVaVdHXdRzWPPtr1fCwXE1vNgADCBc1xig1 +pT55dIlNT7x93pqVCzP53Kles4lBkKHAIyga0kGDkvFo+GREaE6kHcEYA3pt1go XLp4seVlnxf3eZtmwL/uYSS9/lm1fOD554UaBwDflUsl27Iae63oUcCFfJ6HINob ARghoHk/sOu6lUolFGtf9QRgDenXNM2JM2dae+RvMHd6tw3R+s+e523dvn3V8LBQ +wDgr9pEq/p/jb3ccZzzExNCbykWi8VQDIGAhhGAEQ7a6kLXdvyG5b1PDQFYQ/pV D/LTY2MDLd29aZmmFZ6vexjJfa92rezkagAIDjXSKDe3zFjuKOBSqZTjKGC0NQIw QmPxfGCVgcU2iFar1UqlEq6bvnQA1pB+uySf4isRxq976BjJZCKRkFv/TAAGEC6l YtGx7WZakDsJqVwuL2h5+gOtQgBGmKgMHI3FJIokBb/e1T2Njo4KvSOgAvAj69dL tHyHc2fPuq7bqkOPVHAyTbMQtq976KQHB2OxmFz7HIAEIES8arX5NcYnjx0Tqntf qVTms1mJloGAIAAjZFQGHohG/Z0wVBHIMs0AHnT0QKvXrBEqD5ZKpR6WD8CXf/1V /bO3Kv2qZ3zw65y1gcW1G/G43P4F13Wfee65lpdPA4AVUkOOSrncZCNyAdiyrLnZ WYmWgYAgACN81Hha3fR9WfnjeZ56CC2Ec/lrPB5PplJC6XF09eqR0VGJlm+ZnppS /7XkyF/1dS+Xyyx71kN9lyYSCbn2OQAJQLgU83nXdZts5NTJk0KnBtq2LVdiGggC AjBCSWXgSH9/k2WTFqs9l8uhW/Z8i/pHMJJJiZZVPtyybZvolFoul7v8668tOfK3 Wq2q9EuJS21WrVolNE1RE4vF9jz1lFz7AOCjquv6su9m4uxZr1ptvp27qdHRzPS0 RMtAQBCAEVYq/fVFItFotLGXL27+rFRCvfxVbmJNPfx27dkj0XJNpVI5f/ZspBWH HoX9XY/QkT7+V31B9x84MNDofQAANFNjD/Vf8+1c/u23kszWLc/zFubnK35cJBBM BGCEW2PFddSzxw7/5s9UOh2XOVhV/ePs2bdPouVa4+OnTrXk0CPHcVT6DfvXPVyk y1+x/hlAuBRyuaofM7ezMzPTYvO0hXyeZyXaGAEYoadyoBphr3CKKdSbfu8wODgY lYkWKlTsffJJiZZVBB0fGxNdEHs/bTDnHzrS5a8U1f4eme9VAPCd67pFn5Ygqefp +YkJofU1xUKBpVJoYwRgtINkKqUy8APrIbfZ5s9Vw8NCZwBaprlXZlOlXNGO5ZF+ WyKVSsUly1+p8d8zzz7bkvdTAKABlXJZPWH9au3UiRN9MtU6isVi2wyWgLsRgNEm kslkNBZbZq5pcfmrikBt9I7m6OrVQnNrQjPArTryl/TbKsMjI6Kl1GzLOsT6ZwAh 4XmeGoT4WLlq7MQJoXtsqVTioAS0MQIw2scyRwSrRGeZZjtFINHaQhJFsC5dvKhS qP70y77fVpE+/UgZHBratmOHaBcA4Bf1PCr5+jA6ceyYUEGNcrm8MD8v0TIQBARg tBU14F48HOnfnweVSsUJf8mrO4imi/7+/se3bPGxwd9+/bWQz+s/8pf020JDq1aJ ljqzbfvgCy+IzjADgI/KpZJtWT42KBeA1cBpPpuVaBkIAgIw2o1hGL19fdFotLu7 23VdyzTbo+TVHeSK63qet2HjxoRh+NXgld9+y+Vy+tOv+uqr0QbptyWMZDKRSIhO +Kuv7/MvvSTXPgD4aHH9cy6nfvWxTbkl0KZpZufmJFoGgoAAjPaUSqUGotE2zj9y 02uO4+zeu9ev1lo197tY8KxUoohlq0hP/6pB5Nbt21cND8t1AQA+cmzb92N7T4+N CT1ebduezWQkWgaCgACMthWPx0ulUquvQkooKmBdunhRpVD96VelI/Wlp4Jlq4hu UK/h+F8A4VIuFlWq9LfNibNnfSypdTvXdWfEDhkGWo4ADISPChhGMinUuGlZ+/wI wGfPnFEPZv1Vr1T6Vak7R/ptncGhoWg0KtpFNBYTOqkLAHynHkx5gd1Yv/3yS7lc 9r3ZrqVVVNNTUxItA0FAAAbCJ5VOx+Nxocarnrdz165mWjBNc2J8PNLfrz/9dnF4 Q6tpmP7l+F8A4WJbVllgSZrKqHILldWTtI2X0aHDEYCB8BGdYTOSyfWPPtrwy9Xz +OaNG62qzVspl+c5uaGlhoaGBoSnfyl/BSBcSsWi4/f6566lnboXzp0TesOxkM+3 axUVgAAMhM/I6GhfX59EyypabNu+vbH4WqlUzk9M9PT06N/0W2Oapm1ZPLBbSMP0 r/oW3bl7d3poSK4LAPCRV63K1aQ4dfKk0HigWChQSBLtigAMhIzoBuDGKmBVyuUL 58+r3wg9hlfCtm2zUiH9tpZ08eeupbc5XnrtNdEuAMBHlmlWZHbqdkmehFQsFqkl iXZFAAZCRnQDsG1Ze1YcgFXmvHrlSi6X6+vtbdWsb43jOGp4QfptrWQyGRc++9fz vDVr1z62ebNcFwDgr2Kh4DqOUONjx49H+vslWqagBtoYARgIGdFJtr5IZP+BA7n7 b6M1TfPG5GRh6XG+mHpbN+V7S7VaVc/pAiu1Wm3V8HC/zDjsFk4/AhAu6glVkJxH PXHsmNCQoFwqLRCA0aYIwEDIyJ0A7Hled3e319Xl2HYylRro7y+XyyrxqqxbXTpp sHtpf29PT49E743hyN+AUN8wiURCupfaGzTSvQCAX0TXP3dJBmCKSqKNEYCBMEkm kwnDaPVVBMXikb/lMmu0Ws4wjGg02idc+pvTjwCETjGfd11Xrv2Tx44J3RUrlcp8 NivRMtByBGAgTNKDg7FYrNVXERQq/S7w/nQAiO5Lv8XzvGcPHZLuBQD8Ir3+uUuy CJZpmtm5OYmWgZYjAANhomGbZViYlUqWN6cDwDCMWDwuXQXNcZynnnkmJh+zAcAv 6jml/hPtYvzUKaF9SbZlzc7OSrQMtBwBGAiNRCJhJJOiVXbDwlJMk7LPQTA4NBSN RqV7cV33+Zdeku4FAHwkvf5ZOXf2bK1Ih+8cx8nMzEi0DLQcI2kgNFKpVFy+zlDw ceRvcGg4+qhrKf3uefJJueOvAcB3VdfVcDzBr5cuVWQmmdWNd2Z6WqJloOUIwEBo DA0NDchPtQWceiSXSyXSb0AMDw8LHUF5O8dxXnj5ZeleAMBHGtY/KzcmJ4VqNVer 1empKYmWgZYjAAPhoGenZcBVXbdULnPkb0DoqX3luu7OvXvT6bR0RwDgI/Woqgqv f1ay2ezN69clWvY8L5fLlUslicaB1iIAA+HAAUjValU9ifOk32AwDEOl3x75d2SY /gUQOq7rFrU8rdQd8vzEhNA+FBWAS8WiRMtAaxGAgXAYHByMdvABSJ7nlVT6FT5P Ais3tGrVgPyRvGoQufvJJ5Ps/gUQKnrWP9ecHhsTWh1WyOfZcIS2RAAGwmFkZKRP 5qy/4CP9Bk0ylYrH4xoKkjP9CyCMCrmcUHHmu506ebKvr0+i5WKhwKortCUCMBAC hmEkDKMzD0BS6bdcKuVIv4GRSCRi8bjQeOt2Kv3u27+/w1f+Awgdbeufa8ZOnIjI vD9eLBZ56xltqRPH00DopNPpmHy1oQAi/QaQnoN/u5a++s8eOqShIwDwUaVctkxT W3djx48LVeMvFYs8f9GWCMBACKwaHu6XP2wmaFj5HEA6Fz/vP3hQT9IGAB/pXP+s nDx+XGiEoB7BuYUFiZaB1iIAA0HXmeufF2s+l8uk30DRtvhZ6e3re/rgQQ0dAYCP XMcp6i0cdeLYMaGShOVSaYEAjHbUWUNqIIz0nLYaKK7rVlT6pfZGwAwNDQ1omZK1 LOvZQ4eEdrUBgBzN65+7RANwubwwPy/RMtBaBGAg6PScNxMcjuOoAQRHLwRNKpWK aVn87Hne6Jo1j2/ZIt0RAPhL3b4K+byncf2zcvLYsX6ZQUKlUpnPZiVaBlqLAAwE WkIxjJ6enlZfiCaWYpqk36AxDEOlX6GjJu+gvgFefO01DR0BgL8cxylpf37JVYEm AKNdEYCBQEulUvFEotVXoYPneepZ6zoO6TdoVPrtHxjQU4bNdd2tTzwxsnq1hr4A wF/61z93SZ4DbJpmdm5OomWgtQjAQKBp23XZWoubfisVSl4Fk85TuFzHef7ll/X0 BQA+Wlz/nMupXzX3O37qlNAyMQIw2hUBGAguwzDiiUTbr39Wj1jbspj4DaZkMqm+ CfUUIV88+uiZZ6IdVvINQHtoyfpn5czp00K3aMuy5mZnJVoGWosADARXMpVKtPX6 Z9d1zUolx8RvUBmGEY3F9Jx75HleanBwx65dGvoCAN+VSyXbsvT3O3H2rFDZLQIw 2hUBGAiu4ZGRdj0JRqUdFX0ddvwGm84K5Gqk9eKrr+rpCwD81ar1z8r5c+dcx5Fo 2bbt2UxGomWgtQjAQEC16/pnNT5QUYc1z8Gndeuv62554olRal8BCCfHtkvFYku6 vnTxolDlLfWXyhCA0Y4IwEBADQ8PR7TU3dWmFn3VAzWfz7f6WvAAOrf+1hx84QVt fQGAv1q1/ln57ddfVe8SLTuOk5mZkWgZaC0CMBBE6cHBWCzW6qvwTbVarUVfZn1D Qeepv4oaNar022Zv9wDoHJ7nLZ5i0Ir1z8rVK1cKMm8ru647Mz0t0TLQWgRgIHDa ZvGzGhPYtu04jus4xRatDUO9dJ7627X0TbL1iSdWjYzo6Q4AfKeedOXWPeNu3rgh dFhRtVqdnpqSaBloLQIwEDipVCoSifRFIjoXoPqolntV6HVdlynf0BkcHIxqXH2g BlhvvvMOq+IBhFepWHRsu1W9z87MTMvM0xKA0a5CObwGOkEikejp7e3tWfylt68v 4BPCKvQ6S4m3qv6rVsm9IZVKpWLxuLZ3Xmzb/uDDD+eyWfWdo6dHAPDX4vrnhYUW XkBuYWHy2jWJltVfbermTYmWgdYiAAMhYBiGyiTdPYt6F/9v8ZfWzg9X3aWku/SL sngCBKE35JLJpEq/2t5qUd8z27Zv37l79/Xr1/X0CAC+sy1LqAbVCjmOc35iQmhI MJ/NVioViZaBFiIAA6GUWNok3L0UgxejcXe3RA0hFVEWw20t4Nb867fE3TajufBV 19Liur/+7W/ZbHZ+fl5bpwDgr9auf645c/q0UADOLSyUWhrvAQkEYKBNqADje5uk 3A6hvnkGotFIJKKtx9riZyOZnJyctFp0dggANKnl659rxk+dElq8QwBGWyIAA0Cn GxoaUgFYW3dqyLhj5869Tz2lYvA1ma1rAKCBZVmVAOTD02NjQut3crlciUMc0HYI wADQ0fQfOq0ePB9/9pn6zfz8fDab1dk1APioVCg4jtPqqyAAA/UhAANA59Jc9rlr acLko08+qUXu69evm6aprWsA8NHikQe5XKuvYtGpkyf7+vokWiYAoy0RgAGgQ2ku +6y4rvvs888/vmVL19I2YNY/AwgvyzQr5XKrr2IRARioCwEYADqR/rLPSiwW++Of /lT7/cLCwtzcnM7eAcBHxXw+IGeYE4CBuhCAAaDjJBIJlUX7NJZ97lpa/Pzxp58O DAzU/ifrnwGEV9V1C/l8q6/in+QCsPo7ch4E2g8BGAA6i2EY/QMD/QIHRy/DcZzf //GPQ0NDtf/J+mcAoWZWKuq/Vl/FP42dOCF0jl2xoCJwUHI+4BcCMAB0Fs2HHnUt bf3dvWfPniefvPWRbDY7Pz+v8xoAwEeFXK5arbb6Kv5JLgAXCoXgTHQDfiEAA0AH 0X/okaJGZn/6+OPbP3Lt2jXbtjVfBgD4wnWcYpAWBhOAgboQgAGgU6TSaZV+dR56 1HXX1l/FNM3r16/rvAYA8FGlXLaCVMKAAAzUhQAMAB1B/5G/XUt7ff/w/vvpf239 rclkMmwqAxBSnucVcjn1a6sv5H8RgIG6EIABoP0lU6m49vTruu7+Z555YseO2z+o Ro1XrlwJzt45AKiLY9tBOxmIAAzUhQAMAG0umUzG4vGenh6dnaqgOzwy8ubbb9/x 8WKxOD09rfNKAMBHKv06ASthwDFIQF0IwADQzgzDUOm3t7dXc7+u6376n/9598en pqZKpZLmiwEAX3iel19YaPVV3EkuAOdyuaBNdwPNIwADQNtS6TcaiwkNjJZhWdaH H38cTyTu+LjjOFevXtV8MQDgF8s0K+Vyq6/iTgRgoC4EYABoTyr9DkSjQhvDlqFS 7hu/+92atWvv/qP5+flsNqv5egDAL8V83nXdVl/FnQjAQF0IwADQhlT67R8Y6O/v 19yvGhru2r1771NP3f1Hnuddu3ZNxWPNlwQAvlD3t2IgK0IRgIG6EIABoN0spl/l tqN39bhf4auaUqk0NTWl+ZIAwC9BO/73FgIwUBcCMAC0FZV+I5HIQDSqv2sVgD/5 /PP7/SnlrwCEVwCP/73l9NiYUKVDAjDaEgEYANrK4NBQtBXp17Ksjz/9dOA+086U vwIQagE8/veW8VOnhA66IwCjLRGAAaB9DA4ORmMx/f3atv2H999PDw3d7xMofwUg 1AJ4/G+N4zjnJya6u0WG9LmFBVbuoP0QgAGgTaQHB2OtSL+u6x56+eUNGzfe7xM8 z7t69WoAS6cCwEpUq9VC7v9n706c27jOfO9TXEDsIEVSkmUn8RIvseN4i53Ekxk7 seN4i7fxrjjj+B+8d6rem6q5NW+9U/dWzdwkN5SozVosWxJJACRA7L0veA8Bi6El ghv6dDe6v59SZEqintOkHXT/cM55Tivoq9hZs14vFosyKouX7rVyWUZlIFgEYACI gkKhkEylJE0C7ELE2scef/zJndo+b2m329Vq1bdLAgBvGboufgR9FTurViqV9XUZ lUXsX6dzIaKIAAwAIy9fKKSCSL/dbveukydffOml3T9tdXXVNE1/LgkAvCVe6JR2 W6TBoC9kZ6VisSFngwkBGFFFAAaA0RZg+s1kMm+9997un6ZpWplFdABGlm3baqcT 9FUMtHzzZkfO6cSO40iaWwaCRQAGgBGWz+dT6bT/6VdwbPvU55/v+WmcfgRgpGmq aoV4Dcv1r7/WNE1GZZH8q5WKjMpAsAjAADCqcvl8OqD0a5rmB598smfPLcuyVlZW /LkkAPBct9ttN5tBX8Vurl29KmmPiW1ZtG9AJBGAAWAkBZt+33n//Xw+v+dnioen tpy1eQDgA9MwdDnzq165cvmyY9syKluWtUEARhQRgAFg9Ij0m0qlxsfH/R/atqxX Xn/92PHje36m4zjLy8vdbteHqwIAGTqtVmjbX/VdunhR0susZZobGxsyKgPBIgAD wIgJMP2KTPuLX/7y/gce2M8n12q1ZriXDgLALkLe/qrvwvnz43KWApmmWSMAI4oI wAAwSnK5XCqdDir9/vjxx5/Y9cjf7Z/M9C+AkaYqim1ZQV/FHs4tLU1OTsqobBhG vVaTURkIFgEYAEZGgOnXdd1777//+V/+cp+fX6/XG42G1EsCAHnEi16n1Qr6KvZ2 9syZqakpGZUNXa/LOWEYCBYBGABGQ4Dpt9vtzi8s/ObVV/f5+eLBcXl5OeQb5wBg F7qmmYYR9FXsbWlxMTE9LaOy+A7wPiYiiQAMACMg2PSbyWbfevfd/f8V8czEvAGA 0SVe9zqt1khs4jizuDgtJwBrmtYkACOKCMAAEHab6TeVGp+YCGR08Qj4yWef7f/z mf4FMOos09RUNeir2BeJAVhVaWSISCIAA0CoifSbTKUmAkq/tmV98OmnB3q6YvoX wKhT2m3HcYK+in1ZOn06kUjIqKyqaosAjCgiAANAeAWbfk3T/OCTT1Kp1P7/CtO/ AEadY9tK6E8/2iKvCZaqKK1RaAMGHBQBGABCKvD0+96HH2az2QP9LZo/Axh1I3H6 0RZ5AVhRlDYBGFFEAAaAMAo8/b797ruF2dkD/S3O/gUw6kbl9KMt8s4BVjqddrst ozIQLAIwAIROsOnXsqzX3nxzfmHhoH9xY2OD9XIARtqonH7UJ16ur16+fOSIlOd5 EX87o7MUHNg/AjAAhEu21/M5wK5XL/32t3edPHnQvyiew1ZWVmRcEgD4o9vttkeq 7dP62tpGtSqpeKvZVEekFTZwIARgAAiRgNOvbf/Tiy9+/957D/F319fXFUXx+ooA wD+GrosfQV/FAdy4fl2V88Lruq5I1zIqA4EjAANAWASbfh3H+fnzzz/w4IOH+LuG YRSLRc8vCQB80+12O63WaHUxuHLpkqTjmhzbrlQqMioDgSMAA0AoBJ5+n3zmmcd+ /OPD/fVSqaSP1LQJANzGMk1t1Fb8Xjh/flzOBmDLsuQtrgaCRQAGgOAFm35dx3ns 8cefePrpw/11RVHW19e9vSQA8FO321Xa7ZE7w1zeGUimYdRqNRmVgcARgAEgYIHP /T78ox/99LnnDvfXxfPi6uqqbdveXhUA+MmyLG0EuxgsLS4mpqdlVDZ0vV6vy6gM BI4ADABBCjz9PvDDH/78H/7h0BXEE1Kj0fDwkgDAf0q7LWkzrVTyArCuaby2I6oI wAAQmGDP+3Vd9/s/+MEvX3jh0BVs215ZWRmtnjEAcBvbsiT1UpZt6fTpRCIho7Km qs2ROhEK2D8CMAAEI9j0K1LrybvvfuHXvx6myNraGqdEAhh1SqfjjOY+Dnl7gMVr e4sAjIgiAANAAAJPv8dOnHjpN78Zpoh4PFrjlEgAI862bbXTCfoqDkNc+aWLFyXd RxRFabdaMioDgSMAA4DfAk+/8wsLv3n11WGK0PsKQDSI9DuiL2W1jY21cllScaXT abfbkooDwSIAA4Cvgu16JdLv3Pz8K6+9NmQdel8BiADHcZSRjXnXv/lG3sHF7VZL Gc190cCeCMAA4J9cL/2OB5d+Z2ZnX3vzzSHrmKa5urrqySUBQIBURbEtK+irOKRL Fy9K6kHouu46O1wQXQRgAPBJ4Ok3n8+/8fbbw9cpl8u6rntyVQAQlJGe/hXOLS1N Tk7KqGxZ1ka1KqMyEAYEYADwQzTSr9But6s8GAEYfSM9/Tsm8xBg0zRrGxsyKgNh QAAGAOkCT7+ZTOat994bvhQH/wKIBse2ldFs/rzlzOLitJwArOt6o16XURkIAwIw AMi1mX7T6fHx8UBGF2FVjP7OP/+zJ9XK5bKmaZ6UAoAAjfr075jMQ4DF63yTNoeI LgIwAEgUePpNJpPvfvCBJ9U6nU6lUvGkFAAEKALTv2My9wCrqtpqNmVUBsKAAAwA skQp/dq2vbq66rquJ9UAIEARmP4VAf7G9etHjkh5klcUpd1qyagMhAEBGACkiFL6 HWPxM4CoiMb07zfXrsnrxt9ptzuj/y0CBiEAA4D3IpZ+6fwMIDJE+hUZOOirGNbF c+eOyLnFiDtIs9HgrDtEGAEYADyWy+c3ez5HJf1alrW6ukrnZwARYNu2Gom5zaXT pxOJhIzK4ltUpd0DIo0ADABeilj6FQVLpZJhGF4VBIAAKe224zhBX4UH5J2BxCHA iDwCMAB4JmLpV6jX6w0OwwAQCZZlaYoS9FV4Q94ZSBwCjMgjAAOAN6KXfsVjUKlU 8rAgAARFvEgq7XY0Wtnbtn3p4sWJiQkZxTkDCZFHAAYAD0Qv/YrHxNXVVXv0W8UA gGCZpqaqQV+FNyrr6/K26XIGEiKPAAwAw4pe+hXW19eVqKwVBBBz4nWy0253IzH9 K1y5fFleI2vOQELkEYABYCiRTL+tVmuDJigAosI0DD1CJ5mfO3NmUs4GYNd1VUUh ACPaCMAAcHiRTL+maRaLRc49AhANm9O/rVaUXtOWFhcTclpA25bFqe+IPAIwABxS JNOv67oi/VqW5W1ZAAiKoeviR9BX4SV5LaANw6jXajIqA+FBAAaAw4hk+h1j6y+A aHFdtxOtlk6WZV3+8ktJLaA1TWty9B2ijgAMAAcWePrNZDJvvfee55XZ+gsgYjRV tUwz6Kvw0urycktapFcVRV5xICQIwABwMFFNv4ZhFItFz8sCQFAcx1Ha7aCvwmNf Xrggr3hHiNx3DLgNARgADiCq6Vc8Jor0y6m/AKJEVRQ7ch0Nlk6fTiQSMiqLW8xm A2haQCPqCMAAsF+5XC6VTkcv/YrK5XJZj1aTGAAxZ9u2GsUsJy8AW5a1QQtoxAAB GAD2JfD0m83lfvfOOzKK12q1ZrMpozIABKI/mek6TtAX4jGR6i9dvCipAxYtoBET BGAA2Fvg6Tefz7/x9tsyinc6nUqlIqMyAATFMk1NVYO+Cu+VSyV5GZUW0IgJAjAA 7CHC6dcwjFKpJIaQURwAAiFe0zqtViRf2aR2wFIUpU0LaMQAARgAdhPh9EvjKwCR ZOi6EdGmBkuLi4npaUnFO+02HbAQBwRgABgo8PQ7Mzv72ptvSipO4ysA0dN13QhP Y8rrgOU4TmV9XUZlIGwIwACws830m0qNy+k1siep6VeoVqttDnsEEDlqpxPVhS1S O2CZplnb2JBRGQgbAjAA7CDa6bfZbNZo9QkgchzbVqK7iHd1ebklbXKbDliIDwIw ANwu20u/kt5l35NIv7Ozs69KS7+qqq6trUkqDgABajebkex91Xf+7Fl5NyZVUeSl ayBUCMAA8B3ZbDaVTgeYfufm51957TVJ9U3TLBaLEX5ABBBbhqBpQV+FRHTAAjxB AAaAv4t2+qXtM4Cocl23E/UJzLNnzkxNTcmoTAcsxAoBGAC+JdJvMpWanJwMZHTZ 6Vc8HZbLZcMwJNUHgAApnY4T6Xf3Go1GcWXlyBEpj+6mYdAYAvFBAAaATdFOv6J+ pVJRFEVSfQAIkGVZWtRf3768cEFecTpgIVYIwADQS7/J5KScpWV7kp1+hXq93uDh BkAUiZfQdrMZ9FVIJ+8EYEFRlAgfngzchgAMIO5E+p1OJiVtrNqTD+m30+lUKhV5 9QEgQJqqWqYZ9FVIJ28DsLgNKZ0OHbAQHwRgALGWyWSSqVSE06+maeVyWV59AAiQ bdtqDJKbCKg3rl+XtAHYtqxqtSqjMhBOBGAA8SXS73QyKW9R2e58SL+maZZKJdd1 5Q0BAEERr6KdVisO57pJ3QCs63qjXpdXHwgbAjCAmMpms4np6QinX9u2i8Wi4zjy hgCAAMVk8bNwZnFxWtoJwKqitNgAjDghAAOII5F+pxIJec8Tu/Mh/bquWyqVzHg8 GgKIoZgsfh7rfaVfXrgg75CCTrvNBmDECgEYQOxspt+pqelkMpDRfUi/Yoi1tTVN 0+QNAQABis/iZ6FULMpboizSdZUuiYgZAjCA2JmZnU1GN/0KlUqFt/MBRJiuaaZh BH0VPjl/9uzExISk4oZh1Gs1ScWBcCIAA4iXwsxMKpUKZGh/0i9H/gKItvgsfu6T uwFYVVsxOEUZ2I4ADCBGCoVCKp0OZGiRfmdmZ197802po7TbbU6zABBhm4fWttvx aW5vWdblL7+UNwO8ef5vuy2pOBBOBGAAcZEX6TeVknSO4u78Sb+qqq6trUkdAgCC patqrNr7ff3VV4a0xd6O41TW1yUVB0KLAAwgFvL5fCqdDir9itHfePttqaOIJ6RS qRSTljAA4ilui5+FpcXFhLT1z4au1zkBGPFDAAYQfbl8Ph3p9GtZVrFYjM+aQAAx tNn5ud3uxuyF7uyZM1NTU5KKswEY8UQABhBxuVwulU6Pj4/7P7R4XMvmcr975x2p o9i2XSqVxM9SRwGAYGmqasVp8bOwUa2ulcuS3r3d3E29uQM4XjPqwBgBGEC0ZbNZ kX7ltQ/ZhXi2yGQyb733ntRRXNcV6TdWO+IAxJBtWaqiBH0Vfju3tDQ5OSmpOCcA I7YIwAAiS6TfZCol7+lhF/6kXzFKuVzWdV3qKAAQrM3Fz61WDHscLJ0+nUgkJBUX 944GG4ARSwRgANEk0u90Milv69QuxFNaMpl894MPZI9SqVSU+E2JAIibGC5+Hutt 0L3+9dfyuleI20e71ZJUHAgzAjCACBLpNzE9Le+N8z10ux9/9pnsQarVapvDGwFE nWVZWizf6bt4/ry89NvvKMZbqIgnAjCAqBHpdyoh8q+scyN25zjO+x9/LHv0er3e aDSkDgEAgeu67mbn5/gtfhbOLC7Ku5WYplnb2JBUHAg5AjCAqJmZnU0mk4EMbdv2 B598Ijv9tlqtDR5cAMSAqii2ZQV9FQFQVfXrr76S18FRU9UmByAhrgjAACKlUCik 0ulAhrYs68NPP5WdfhVFWV9flzoEAISBZZoipwV9FcGQuv5Z6LTbHICE2CIAA4iO fD4v0q/Uh4ZBTNP86NQp2elX07RyuSx1CAAIA9d1lbgufh6TvP6ZA5AQcwRgABGR y+fTwaXfDz75JJVKSR3FMIxSqRTbx0EA8SFe6DRFETkt6AsJhuz1z7qm0UUCcUYA BhAFuVwulU6Pj4/7P7RIv+9/9FE6k5E9iki/rutKHQUAwsA0DBHSgr6KwMhe/8wB SIg5AjCAkZfNZlOp1MTkpP9Di1z63gcfZHM5qaPYti3Sb2wnQwDEius4nXif8SZ1 /bP49qqqygZgxBkBGMBoy2QyyVRqamrK/6FF+n3n/ffz+bzUURzHEenXimUfVABx 0+12RTgTr3tBX0hg2q3W8s2b8maADcOo12qSigMjgQAMYIQFeOSvZZpvvvvu7Oys 1FFc1y2Xy+J5ReooABAShq6LH0FfRZDOLS1NylzQpCpKi/XPiDcCMIARNjMzk5Tc empHlmW9+uabCwsLUkfpdrtra2tajDfCAYgVx3GUeC9+Fs6eOSNvTdNmb+1OR1EU SfWBkUAABjCq8oVCOogjf23b/vXLL5+85x6po4j0W6lUeEwBEBPiRU+k35i3+iuX y7VqlfXPgFQEYAAjKahDj0T6/eULL9x7332yB6pWq+3Yz4QAiA9d08zYb/dYWlxM yNzUw/pnYIwADGAUZbPZdCbj/6FHjuP89LnnHv7Rj2QPVK/XOaQRQHzYtq3Gvi+x ZVmXLl6UtwGY9c9AHwEYwIgR6TeZSkntEbIjkX4fe/zxJ59+WvZArVZrY2ND9igA EBJd1+20291uN+gLCdjlS5dcme2vWf8M9BGAAYwSkX4T09OJRMLncUX6vf/++3/x j/8oe6BOp1OpVGSPAgDhoSqKzUlvko//HWP9M3ALARjAKAmk7XO32z1x112/evll 2QOpqrq2tiZ7FAAID8s0NVUN+iqC16jVisWivMYWrH8GthCAAYyMfKGQSqV8bnwl 0m+hUHj9rbdkD6TrerlcZhEggPhwHadDt78eqacfjbH+GdiGAAxgNORyuVQ67X/j K5G3Pzp1SvYopmmWSqWYn/8BIFa63a7a6Tgyd72OCtntrwRFUdqsfwZ6CMAARkA2 mxXpd2Jiwudxbcv64NNPpW7KGuu1Py0WizwFAogVQ9fFj6CvIhSuXLok9RYgimuq 2ol9n22gjwAMIOxE+hURdMr3xlemaX506pTs9CueS0qlkkUDGABx4ti2Qh67RXb7 K13TOFoP2EIABhB2M7OzyWTS50FF+n3vww9F9pY6iuu6Iv2KsaSOAgCh0u12lXab TR99tWq1XC5LbW/REdhrDdxCAAYQavl8PpVO+9z4yrKsN996a3ZuTuoo4hFQPPTo rAAEEDOaqlq88XfL0uJiQub0r7ijbVSr8uoDI4cADCC8srlc2vfGV7Ztv/jrX9/z /e9LHUWk30qlwokUAOKGc4+20zTt2tWrUjtciO92s9mUVx8YOQRgACGVyWRS6bTU rph3chzn6Z/+9EePPSZ7oI2NjRYNOQHEjOu6m2txOe/tlvNnz0pNv5urzTcXQLPd Gvg7AjCAkJo9elR2A6rbiPT7w4ce+tkvfiF7oEajUa/XZY8CAKHCuUe3sW37ywsX pL7Py/G/wJ0IwADCKF8opNNpP0cUT2Zz8/OvvPaa7IHa7XaV7VgA4odzj25z5fJl x7alDsHxv8CdCMAAQieQrb9Hjhz56NQp2aOoqrq2tiZ7FAAIG9u2VRbiftfS6dMJ mSf8ie+5rmmsfwZuQwAGEC6BbP21LOvDTz+VveJa1/Vyudxl8xuAmOn2tv7y6rfd 6spKs9GQesaBpmlNjv8F7kAABhAus7Oz0/6e+msaxvsff5zOZOSOYpqlUolzLwHE kKootmUFfRXhcmZxUeq7rrS/AgYhAAMIkXw+LzuI3sayrNd/97u5+Xmpo9i2XSwW af0CIIZMw9A1LeirCJfK+rr4IXX6l/ZXwCAEYABhkc1mRfr1c+uvSKQ/f/75Bx58 UOooruuWSiXTNKWOAgAhJF5mlXY76KsIHdnTv2O0vwIGIwADCAWRfhPT01Lbgdym 2+3ee//9v/iHf5A9Srlc1ml8CiB+Nlfhttts/bhNo14vrq5Knf6l/RWwCwIwgFAo FAopH889Eo9l+Xz+jbfflj1KpVJRFEXqKAAQTpqqWix+ucPS4mJC8vSv+M43m02p QwCjiwAMIHi5XC6dyUh9O/w2jm2f+vxz2aPUajUeQQDEk4i+IoYFfRWh02o0bt68 OTExIW8I13WVTof3XoFBCMAAApbNZqeTyampKd9GNE3z/Y8+kt1tq9VqbWxsSB0C AMLJdZzN9bece3QHH6Z/dV1v1OtShwBGGgEYQMAKMzOpVMq34WzbfuW1144dPy51 FEVR1tfXpQ4BAOHUP4DHpe/9HXyY/uX0I2BPBGAAQfJ58bPjOD958snHn3hC6ii6 rpfL5S5THwBiSVdV+t7vyIfpX9Mwapx+BOyKAAwgMNlsNplKTU5O+jOcSKTzCwu/ efVVqaNYllUsFul6CiCe2Po7iA/Tv2OcfgTsAwEYQGB8XvwsQumnf/iD1CEcxymV SiIDSx0FAMKJrb+78GH6V9x9NqpVqUMAEUAABhCMbC6X8XHxs2maH3zyidS8zZG/ AOKMrb+7qFWrpVJpfHxc6iiqqrY4egDYCwEYQAB87vzs2PavX3nlrpMnpY5SqVTo OwIgttj6uwsfpn/FnU7TNG5DwJ4IwAACkC8U0um0P2N1u90HH374p889J3WUer3e aDSkDgEAocXW312Ui8VarSZ7xZP4/nPyPLAfBGAAfstms+lMRvZKsC2Tk5Pvf/yx 1CE6nU6lUpE6BACEFlt/d3dmcXFa9vSv46jKJqmjANFAAAbgt9mjR2U/CmwxTfOj U6ekDsehRwDijK2/u7t540an3ZY+/atpTVYhAftDAAbgq1w+n8lk/BnLtu1X33hj fmFB3hAcegQg5jRVtdj6O4C4DV04dy6RSEgdRdyDVEVh9y+wTwRgAP7x8+BfH7b+ imcOkX459AhAbLH1d3dfXrjgwyi6ptGEAtg/AjAA//h58O+RI0c+OnVKXn0RsNfX 11We/ADEleM4Srsd9FWEl2EYVy5dkv2eL9O/wEERgAH4xM/eVz6c+lur1ei3CSC2 Nrf+tttsANnF2TNnfDjtT9f1Rr0uexQgSgjAAHwyOzs7nUz6MJDjOP/4wgvfv/de eUPQ9hlAzLH1d3etZvPmjRsTExNSR2H6FzgEAjAAP+RyuXQmI7sN5lhvUmJ+YeE3 r74qbwjDMEqlEm2fAcSWaRi6pgV9FaHmw9FHY0z/AodCAAbgh6Nzc7LbYPZZlvXZ H/8or75t28Vi0eHADwBxxdbfPZWKxXqtJvs9X6Z/gcMhAAOQzrejj0Q6fe3NN+fm 5yXV73a7pVLJMAxJ9QEg5MTLYKfd7rL1dzB/jj4aY/oXOCwCMAC5fDv6SDyWfe/7 3//lCy/IG6JarbaZ9wAQY6qi2Jz9tquL58/7sN+H6V/g0AjAAOTKFwrpdNqHgWzb /v3nn8urL6KvCMDy6gNAyLH1d09qp/P111/L7n0laJrW5Oxf4FAIwAAkymazqXTa h0cBkX7fePvt2dlZSfUNwygWi5KKA0D4ObatMN+4l6XFxYT83leO46jKJtkDAZFE AAYgUaFQSMmf/u12uyfvueeFX/1KUn3xqLG6ukrjKwCx1XXdTqfD1t/d+dP7aqx3 BhUH0QOHRgAGIEsmk0lnMj5M/1qm+dkXX0gqLtL12tqaxqo/AHElXgZF4mLr7+4s y/ry/Pkp+b2vHNsWtyR2/wKHRgAGIEthZiaVSskexXWcF1966eQ990iqX6/XG+yz AhBjhq6LH0FfRdidP3vWhzd8BVVVW0z/AkMgAAOQwrfp36lE4p8//FBScU3TyuWy pOIAEH62batMNu6l0Wis3LzpR8MLy9J1nelfYBgEYABS+LP71zLND0+dmpbTcUQ8 9q2urrrseQMQV5tbf9vtbrcb9IWE3ZnFRUl3otsoitJutXwYCIgwAjAA7/kz/Sue yR559NGnnnlGUvFyuayz6g9AXG1u/VUU27aDvpCwu/bVV4au+9D7yjTN2saG7FGA yCMAA/CeP9O/Ug/+ZesvgJhj6+9+aJr21ZUrk5OTsgfqdruKonTabdkDAZFHAAbg MX/O/nUc5+Xf/vb4iRMyirP1F0DMsfV3n5ZOn07I7/ws6LreqNd9GAiIPAIwAI/l 8/l0JiN7lPGJiQ8/+URGZU79BRBzrusqbP3dh5vXr3c6HR8WP4t/I6qi0PsK8AQB GIDH5ubnp6ampA5h2/Y777+fzWZlFF9fX1cURUZlAAg/tv7uk65pV31Z/Cxoqtrk 6CPAIwRgAF7K5fMZ+dO/+ULh9d/9TkbldrtdrVZlVAaAkcDW331aWlxM+NL52bZt EbaZ/gW8QgAG4KWjc3Oyd0OZpvmRnKOPLMtaXV1l1R+A2HJsWyFo7cPyjRvtdtuH xc9jHH0EeI0ADMAz2Vwuk8lIfSAQ6fShRx555tlnZVQulUqGYXheGQBGgngZ3Dz1 l8PP96Lr+tXLl/1Z/CzuSvVazYeBgPggAAPwzMzsbDKZlDqEaZp/+OILGZUbjUad BpsAYkxVFNuygr6KEeDb4md6XwEyEIABeCMjZLPj4+Pyhuh2uz958snHHn/c88oi VxeLRRY/A4gt0zB0TQv6KkbA9a+/VlXVn8XPmqY1OZEe8BoBGIA3CoVCKp2WOoRl mp9JmP5l8TOAmHMcR2m3g76KEaB2OteuXfNn8TO9rwBJCMAAvDG/sCD1mUDE1Kef ffbhRx7xvHKz2ayxwwpAXIlXV5F+Xbb+7oNvi5/H6H0FSEMABuCBXC6XkXMq7xZJ 0790fgYQc5qqihfYoK9iBFy9fFncMvxZ/EzvK0AeAjAAD8zOzk7LbH8lAuqTTz/9 o8ce87xyqVTSOfESQFyJ6CsCcNBXMQIatdrKysrExIQPY9H7CpCKAAxgWNlsNp3J SG1/Jan5s3i8qFQqnpcFgJEggpbSbrMEZk+WZV08f172KfdbVFVtNZv+jAXEEAEY wLDyhUJaZvsr8XD2yKOPPvXMM96WdRxnZWWFbW8A4km8tKqK4th20BcyAs6dOTM5 NeXPWJZpGobB9C8gDwEYwLDm5uenZD4ZSJr+rVarbbqeAogrQ9cNNoDsw+rKSrPR 8Gfr72ZDMkXpcG8CZCIAAxhKNpvNZLNSnwxmZmdffeMNb2sahlEsFr2tCQCjgnOP 9knXtKtXrvhz7tEYB/8CviAAAxhKYWYmlUrJq29Z1oeffjrt9bETIv1y8C+AeOLc o32ybfv82bOe34B2GY6DfwEfEIABDEX28b+i+Psff+xtTXpfAYgzkbJM3gHch4vn z/uz8nns1pZsNuYAPiAAAzg82cf/Oo7z+ltvzc7OeljTdd2VlRVR2cOaADAqbMsS QSvoqxgBa+VyZX3dn3OPxnrvSjRY/Az4ggAM4PBmZmaSMtc/27b9+88/97ameMKo 1+ve1gSAkdDtdjvtdpfFz3vRdf3KpUtS+ztuJ252mqoqvDEB+IIADODwpK5/Fg9q Tz/77MOPPOJhTY4+AhBnImVZphn0VYyAM4uLvm393Vz8rKrtVsuf4QAQgAEckuz1 zzJOP9rY2GjxkAEglizL0phj3IfLX37pOI5vu391XW+wLgnwEQEYwCHJXv8sir/z z//sYUHbtldWVrrdroc1AWAkuK6rtNu8AO5pXSiXfdv6y+JnwH8EYACHJHX9s+M4 v3v33Xw+72FNpn8BxJbIWLZlBX0VYefz1l86PwOBIAADOIyskMvJq+95+yumfwHE Fouf92np9OlEIuHbcHR+BgJBAAZwGIVCIZVOy6t/8u67/+lXv/KwINO/AOKp67od Fj/vw5VLl2zb9m3rr2VZhq53Oh1/hgOwhQAM4DCOzs3Je5tcPIJ88MknHnbgdBxn eXmZ5z8AMaQpisXi5734vPWXxc9AgAjAAA4sm81msll5b5OLJ4NPPvvMw4K1Wq3Z bHpYEABGAouf90PTtKuXL/u29bc/YpPFz0BACMAADiyfz6czGUnFRfr96XPPPfjw w14VdF13eXmZs38BxI14Oe20Wix+2Z1t2xfOnk34deqvYJmmYRgsfgaCQgAGcGAz s7PJZFJSccuyPvvjHz0s2Gq1NjY2PCwIACNB1zSRtIK+irA7d+bMpI9zv67rqopC +gUCRAAGcGALx47J2yjl7fpnUW1lZcW2ba8KAsBIcGxbIWXt5fo334g46lvjq7He eVR0ZASCRQAGcDDZXC6bzUoq7vn6Z1VV19bWvKoGACNBvJaK9Os6TtAXEmq1Wq24 suJb4yvB0PV6ve7bcAB2RAAGcDBSD0DyfP1zuVzWNM3DggAQfiJoiR9BX0WoGYZx +eLFKR9P/bVtW1NVhZ5kQNAIwAAOZvboUQ8PKLqN4zin/uVfvKom4vTKyopX1QBg JLiu22GR7a5EFj1/9qy8e9mdOPcICA8CMICDkboB+MRdd7340kteVeP0IwAxxMG/ e7pw/vy4j/t+BU1VuR8BIUEABnAAUjcAO47z3ocfplIpT6p1u93l5WWHLXAA4sS2 bZXeV7taXV5uNBrj4+O+jWgahmmadH4GQoIADOAA8oVCWt4GYNP87IsvvKpG+ysA cbPZ+6rd5tjzXbRarRvffDM5OenbiI7jaKpK+gXCgwAM4ABmZ2enpZ0AnEwm33n/ fa+qra+v02sEQKyYhqHT9m8wy7Iunj+f8LHxFVt/gRAiAAM4gPmFBUlvnIunhBdf eumukyc9qeY4zs2bNz0pBQAjoeu6m0Gr2w36QsJraXEx4WPjK0HTtGaj4eeIAPZE AAawX9lsNpPNHpHTOMTbA5DEU2C1WvWqGgCEn65ppmEEfRXhdeniRdd1Jd3CdmQK hsHiZyBsCMAA9iufz6czGUnFbdv+/eefe1WtVCrpnIEJIDZcx+mwznaw5Rs32u22 n+mXrb9AaBGAAexXYWbGqxbNd8rmcm++/bYnpVj/DCBuVEWxOfpogEattry87Gfj q82tv6ra5jRmIJQIwAD26+jcnKTeIeJZ4Tevvjq/sOBJtVartbGx4UkpAAg/jj7a hWEYl7/8cmpqys9B2foLhBkBGMB+LRw7NjExIaOytxuAy+WyRh9UAPGwOdnY6XDm +Y5s2z5/9uy0v42v2PoLhBwBGMC+ZIVcTlJxDwOw67o3btzwpBQAhJ94/dQ48m2A c0tLfq58HmPrLzAKCMAA9iWXz2ekdcBKTE+/98EHnpRSFGV9fd2TUgAQct1uV2m3 XdcN+kLC6JuvvxZZ1M/GV5z6C4wEAjCAfZHaAevBhx9+5tlnPSlVqVR46x1ATFim KTJe0FcRRtVqtVwsStq2M4iqqq1m088RARwCARjAvswePSppG5XjOO9//LEnxbvd 7vLyMnvhAMQB07+DiCD61ZUrPje+MnS9Xq/7OSKAwyEAA9iX+YUFSTupTNP8wxdf eFVqdXXVk1IAEHKmYeg0/LuDZVkXzp3zufGVGFT8u1DYjA2MAgIwgL1ls9lMNitp J5Vj26c+/9yTUs1ms1areVIKAMKs2+122u0u0793WDp9WtKJfYO4rqsqCrtvgFFB AAawt2wuJzKwpOKpdPrt997zpBQHIAGICXb/7ujyl186juN34ytVbbdavo0IYEgE YAB7y+fzaWktoB986KFnnntu+DriKeTGjRvi5+FLAUCYsft3RyvLy4163efGV5qm NRsNP0cEMCQCMIC9yWsB7TjOex9+6ElxwzCKxeLwdQAg5Dj7907nlpaOHDnic/o1 DcM0TRY/A6OFAAxgb/JaQIvHuM/++EdPSrEBGEBMKO027e63++baNU3T/Fz5LNi2 rWsa6RcYOQRgAHubm5+XdJ6EhwF4bW1NZUccgKgTuUsldG3TqNVWV1fHx8f9HNR1 XU1V2+22n4MC8AQBGMDeFo4dk7eu7OPf/96TOjdv3mRKBEDkqYpiW1bQVxEWhmFc uXRJ0il9g3S7XZF+WzS+AkYTARjAHjKZTDaXk7S0LJfPv/HWW8PXsW17eXl5+DoA EGau63bIXbeIV/7zZ8/6fOSvoGtag8ZXwMgiAAPYQy6Xy0g7A+nhH/3oqWeeGb6O oijr6+vD1wGAMBPRyzSMoK8iLM4tLfk89yuYgmGw9RcYXQRgAHvI5fMZOWcgdbvd d95/35MW0PV6nffjAUSbeM3stFoc9tZXLpWqlYrPbZ9pfAVEAAEYwB4KhUIqnZZR WTxJ/P7zzz0pVS6XNU3zpBQAhJNpmjqt/npUVb129arP07+u64pxOzS+AkYcARjA HmZmZpJyDgEWD3N/+OILT0otLy+LOO1JKQAIJ04/6gtk62+32xXpt80GbGD0EYAB 7CH8hwC7rnvjxo3h6wBAaInoqzD32BPI1l9N05pstAEigQAMYA/yDgF2u91PP/ts +DqGYRSLxeHrAEBo0f6qb2V5udVsSjqYYBBxl6nXan6OCEAeAjCAPcg7BHg6mXz3 /feHr9Nut6vV6vB1ACCcaH/V1+l0vrl2zefpX8uydE1TFMXPQQHIQwAGsIfjJ05I eq/92LFjv37lleHr1Gq1ZrM5fB0ACCfLNLXYt78KZOuv4zjiO0/bZyBKCMAAdpMV cjlJxR9/4onHHn98+Dq0gAYQbSKB0efP/62/NL4CIokADGA3uVwuk83KqOzhIcC0 gAYQYa7rdmKfwUrFYm1jY3x83M9BRfptsbwIiBwCMIDd5PL5TCYjo7JXhwCLIH39 +vXh6wBAOJmGocd7kYv48q9evjwppx3jwEF1vVGv+zkiAH8QgAHsJp/Pp+UEYK/O QBJ1VlZWhq8DAOGkdDpOvBe5LJ0+nUgk/BzRFAyDrb9AJBGAAeymUCik0mkZlcXT xR+++GL4Opqmlcvl4esAQAix/vnaV18Zuu7nuUe2beuaRvoFoooADGA3MzMzSS+2 6d7JMs3PvAjAnIEEIMIMIcbrnzvt9jdff+1n7yvXdVVVFeP6NiIAnxGAAexmdnZ2 OpmUUdmx7VNe7AGu1+uNRmP4OgAQQkq77ThO0FcRDP/PPep2u5qqtuI95Q5EHgEY wG5mjx6V9PBx5MiRj06dGr5OpVJhoRqASIr5+ueL58/7ufJ5rLenpsk7qkDUEYAB 7Obo3Jyk1iMiV7/7wQfD1ymVSrquD18HAMImzv2fW63WzevXJyYmfBvRNM3axoZv wwEICgEYwG7m5uen5Jw8kcvn33jrreHrrKysWJY1fB0ACBu104ntIedLi4sJHxc/ O46jqSrriYA4IAAD2M38woKk7iPHjh379SuvDF/n5s2bsd0gByDCut1uu9kM+iqC 8fW1a7qm+bb+WXyrlU6H9AvEBAEYwG6OHT8+Pj4uo/K999//8+efH7KIeGq5fv26 F5cDAOFimaamqkFfRQA0TfvqyhXfOj+7ritGbMd4rzUQNwRgALs5fuKEpPfgf/LE E48+/viQRRzHuXnzpifXAwChItKvyMBBX0UAlk6fltR74k7dbldVlDaHHgFxQgAG MFAqnS4UCpKK//KFF+753veGLGJZ1srKiifXAwCh0m42RTwL+ir8tlGtlopF33pf qaraius6cyC2CMAABsoKuZyMyo7jvP/xx8MfsKTreqlU8uSSACA8xIukEstpyTOL i74d/Gvoer1e92csAOFBAAYwkEi/IgLLqGzb9u8//3z4OoqirK+vD18HAELFEOJ3 ANKN69eVTsef3lfiNqSpqriJ+DAWgFAhAAMYKJfLZcIdgNvtdrVaHb4OAIRKDA9A El/vxfPnJR28dxvXdVVV7cRyjh0AARjAQLl8PpPJyKhsWdZnf/zj8HVardbGxsbw dQAgPOJ5ANKlixd92/PM1l8gzgjAAAYKfwBuNBrs4AIQMbZtqzE7k9bP6V/DMOq1 mg8DAQgnAjCAgfL5fFpOADZN8w9ffDF8HZF+RQYevg4AhIeh6+JH0FfhK9+mf0XS 1jWtE7P3FwBsRwAGMFC+UEin0zIqW6b5mRcBeGNjo9VqDV8HAMIjbhuAfZv+5dRf AGMEYAC7kBeAvZoBrlQqvJEPIEpiuAH4yuXLji+BX9O0JouGgNgjAAMYqFAopMI9 A7y+vs4hFgCiRERBJWbv6/lz9q9lWYau854pAAIwgIEKMzOpVEpGZa+aYK2tramq OnwdAAiJuJ0AXKtWy+Wy7LN/OfcIwBYCMICB5AVgr84BFo9NWpyeFAFEnqootmUF fRX+WTp9OpFIyB5FU9VmzBaWAxiEAAxgIIkB2LI++PTT4de8lUolPWa9UgFEW7vV 6rpu0FfhE8Mwrl6+PDExIXUUFj8D2I4ADGCgmZmZpJwALPzs+efvu//+IYsQgAFE ieu6nTh1tr986ZLrOFKHoPMzgNsQgAEMNDM7m0wmZVQWTyTvffjh8DPAxWLRMAxP LgkAAmdZlhanxn4+tL/SNY3j4gFsRwAGMNDs7Oy0nADsOM6pf/mX4eusrq6apjl8 HQAIA5HWzNi8qefD+mdxr1EVhcMCAGxHAAYw0OzRo5Lem3ds+5QXTbAIwACiROl0 /DkRNwx8WP+sqmqL3lcAvosADGCgo3NzkppzetUFmgAMIErazWa32w36Knwie/0z va8A7IgADGAgAjAA+CZuHbDOnjkzNTUlr76iKO04fT8B7BMBGMBABGAA8E2sOmDV arVysXjkiKwHUXFrqG1sSCoOYKQRgAEMNDc/L+ntefGc99kf/zh8HQIwgMgwdN2I zbluF86dGx8fl1ef6V8AgxCAAQxEAAYA36iKYltW0Ffhk6XFxYS0DcC2bVcrFUnF AYw6AjCAgeQFYJFa//DFF8PXIQADiIxOq+W6btBX4ROpG4A1VW3S/BnAAARgAAPN LyxMTk7KqOxVAC4Wi0ZszswEEGHdbrcdm8wmXrevXb0qaQOw+E4qnQ7NnwEMQgAG MJC8AGyZ5mcEYAC4xbFtJYqZzbbtO+8j33z9ta5pkkY0DaNWq0kqDiACCMAABgr/ DHCpVNJj0zMGQISJV0VdVYO+ir+zTPPI+Phtfaq2/9J1XfHL236+rYj4HfGgOXHH feT82bMTExOSrlxV1VZs5tIBHAIBGMBAC8eOSXpG8aoJFgEYQDTommYGtJ5FxFTH trdiqtTmzH1Lp09LOmOP9c8A9kQABjCQxADs0RLocrmsSVtHBwC+UTsd27aDvgqf nFlcnJbTApr+zwD2RAAGMFD4Z4DX1tbUMC0aBIDDoQW0J3Rdb9TrMioDiAwCMICB wh+A19fXFUUZvg4ABChWLaBt27508aKkmwsbgAHsiQAMYCB5AVg8AP3+88+Hr1Op VNjrBWDUOY6jtNtBX4VPahsba+WypOJKp9OOzXcSwOEQgAEMRAAGAB9YlqXFZjHL 8s2bHWkZVVTmpgBgdwRgAAOFPwBXq1Xe7Acw6gxdN2LT0P7a1aumacqo7Lru+tqa jMoAooQADGCgY8ePSzoPw7HtU14E4Fqt1mS7F4ARp6mqJScThtClixe73a6MyrSA BrAfBGAAA83Nz0tq1Dk5Ofn+xx8PX6derzcajeHrAECAYnUG0vmzZyWtLTJNs7ax IaMygCghAAMY6OjcXCKRkFE5l8+/8dZbw9cR6bfOiRcARlyszkA6d+bMpJy3Vg3D qNdqMioDiBICMICB5ubmpuQE4MLMzGtvvjl8nVartcH7/QBGWazOQBrjEGAAQSMA Axgo/AG43W5Xq9Xh6wBAUFzX7bRaQV+Ff5ZOn5a0tkjXNDbFANgTARjAQOEPwJ1O p0LLEwCjzLZtNU4n9ywtLiamp2VU1jStSQAGsBcCMICB5DXBmj169Levvz58HVVV 1zj0AsAos0xTU9Wgr8I/ZxYXpwnAAIJDAAYwkLwALCr/5tVXh68jHnfK5fLwdQAg KLE6BHiMAAwgaARgAAPJC8C/evnl4ydODF/HMIxisTh8HQAISqwOAR4jAAMIGgEY wEDhD8CWZa2srAxfBwCConQ6TmwOAR6TGoBVtRmnftoADocADGCg8Adgx3Fu3rw5 fB0ACEq71erG5hDgMWaAAQSNAAxgoPAHYNd1b9y4MXwdAAhE3A4BHiMAAwgaARjA QOEPwMI333zjSR0A8F/cDgEeIwADCBoBGMBAIxGAb9y44cZp9SCAKHFsW4nTIcBj BGAAQSMAA3GUzWaPCOPj4qdEIjExMeHzBXgYgG/evOk4jielAMBnlmVpihL0VfhK XgC+k7g7mKbZFVxX/NSJ2XsNAHZEAAYiTmTdMRF1e3G3T8TdIz0BXpWHAXhlZUU8 QXpSCgB8ZhqGrmlBX4V0W+t0xAfnz571LQBv1+0Rkdjt6W7+rztGKgbihwAMRM3m 7O62rNuPu0Ff1O2eeuaZ7/3gB5sX17tK8Tvin4crVSwWDcPw9OoAwCci/ZqReAXb HnFdx+nNufY+FP+zbcveZAq6+Iq1qUQi2Kvd0o/E21MxeRiIvNA9FgM4qEwmM94P kuLH5OR4b2Fz0Be1B/HMkS8UUqnUdDKZmJraXIY9OTk5NTV9S6JHBOTJvTYhl0ol Xdf9uWwA8JamKCO3hqWfdbcmVEWytcxetjUMS/ywLPFbTm9ytdv/WTxuiruS+Gdv 8ZF4sQ/tTaqf2zev/9v47igxW6AOxEFIX4AA7K6/iVfk3sme0D5MDOL05gfGek8b /aei/u+P974o8VWJBJxK92QyvZ8y4pfJVGqqZ/t08draWqfTOfQEMgAESOl0RNwK +ip2JgKgSLNbb6r2w6FtWZquG5r4SQReoz93Kv6o/zlHbtkqcueOmxG6YYmvqzd1 bffntJkcBqJhZF6DAIz1cm9/WbMIgYHv4/VKPwlv13+cGrs1w9CP+uJLTiWTmWw2 J+TzIhJPJ5PiyaxaqYhHtLT4zpCBAYyaTqsVwj72ItZqqmpalqoo4od4dRXZ17Lt ftzdmsvdug1tf/mNxo3pNv2b0ebktvgOOA5JGBhpEXyRAqIn20t3k71FwnGLeVvx +O+pWDx+HTnS394sgrFtWZv7nMfHxUOJ+GUylZqenp4S36pEYnNpdW85dT8qB/p1 AMAOWgEd2yOyXL1WUxTF0HXx8dYsbp94Ue3P925/h/LId0PvWESz7p760+Cb08Js GAZGUxxfuYARksvlJiYnEyL3+n5SUZj1H8m+nTbpzUVsX6T37fpq8fTW+7TxfgPs ycnJXjxO9ILx1NSUyMaJW1uOiccA/CciZrvVklRcJNvaxobaa7LVT2vbZ2730x/x tuU58Yy7u3Adx+xteG6320FfC4AD4LUMCKP+lK/IaaO4vzfM+m1N+qvZRDw+0p/T uNUvu998q7/NeKo3eTzdn0/eqxEXAByC4zjKYbOTYRgi3+qaZpim3ZvC7b8nOC5u GbeOveP24YP+PmHLNJkQBkYFr4xA6OQLhX4DZJ5dfPb32eNtUx+bIbnXZFvoJ+RJ kY57CXkzIieT4p/JZDLQCwcwkuzeJts7f980jEajoYlwaxh2f9/prT0g/eUq5Nuw 6d8+TNNsNZtBXwuAPfDSCYRILp+f7h0IxGNNOPXj8XcadI3d2hjXexrtL67u79bu 70PenFK+tQ9Z/HbQXwGAIOmatr6+rvV23oqw1G+q1L3VBOsI4XbEbcZg2zZMU97K dgDD4+UVCIVsLtdffMtDz0jrt43ZHpK3/mBr6514sBXxePPHxK1jrL4blRMsugZG h97baisybf9YINu2nd6G227/peC7vaNItnHQ7xdtmmaHvcFAKPEqDASvMDNDH6ZY +U5OFk/D2wLz1pTyt/8cG5voTSn3el6Pi8D898x8kJB88p57JH0tQDSIxNJutQwR YvVNpmXZvf5Gm4uPt1Ygbwu0Y99Z/MHTFG4n/psxDKMZUJdvALvgJRsIUjaXE9GX TlfYxXcOI+kF5q0H8QNVGdt2csm3T+0iUfdD9cREfzq63/2r3yI7XygwEY2RILJr q9k0DcPqzbtZveC6eWSt0Euw3V6DqK2lGZu2FmX0f3mra1RgXwOiqN8fS8RgpoKB UOGZGwhMLp9PJpMTnG+EUPo2ePcXcvdOCB3btq67f2To1gdH+n/a/0BkibHNRPHt 8VS9nY39WbJvI3cve/d/Z7zXgrvfh3vzaJbJyc0l4pOT4u8mEglRJpVOk8NDS0RN TVXFB6ZpjvWe9d3eHsh+QyB329xpf0mw0/vR3fY73f55Zv1zy8a+3Vu/9UbPbf+Z jW2dxHNk84+31kowB4swE/9f0HWdXcFAeHDDAILBsmdgP7am7NxbjYLG7jietP9b t/8Gx5YewvZv4x3fve3fz63XLr7JwJ5YDg2ECvctwG+ZTCbRa3XEgyMAAHHQ7XZN wTCUnQ6+AuAnnr8BX2Wz2f5xOKRfAADi49stwbre6XSCvhYg1ngEB/xD+gUAILbI wEAY8BQO+IT0CwBAzJGBgcDxIA74gfQLAADGyMBA0HgWB6TLZDLJVIr0CwAAxm5l YF3T6IkF+I/HcUCuXC6XmJ4m/QIAgC39DGwaRrvdDvpagHjhiRyQa35+fnJqKuir AAAAoWNbVrVaDfoqgHghAAMSzczOTk9PM/cLAADu1O12DcNo1OtBXwgQIzyXA7Lk 8vlUKjU+Ph70hQAAgJByXVfTtHarFfSFAHFBAAakyGaz/cZXQV8IAAAItX5DLJpC A/4gAANSzB49mkgkWPwMAAB21+12TdOs12pBXwgQCzydA95j8TMAANg/FkIDviEA Ax7LZDLpTGZiYiLoCwEAACPDcRxVUTgZGJCNAAx4bHZ2NjEinZ/FvXbr5/3odrub X1e3u/mL3he49WUeufXL8fHxkfjaAQAjoX9e7uZHd9xddr7dbLszub0bnPiNkXhX enMhtGHU6QgNSMZzKuClXC6XSqfDufhZBF3XdcUHiampbD5/4q67Hnn00Uwmc+iC 4lYtCvbLOrfour6yvLxRqXTabcMwNtO1iM3jm0bi+QMA4D9xQxH3i27P+JEjk5OT yXS6UCgcO378vgceSKVSw7y1qijKpYsXy6VSp9UyLUv8TmhvSZsLoVW13W4HfSFA lBGAAS/Nzc+L23ZIpkD7iXRifDyby93z/e8PGXcPpx+S+3f05Zs3S6VSq9EQIVn8 zo4PHyH51gEAPLd5R3Act9vdXEnUS7nTyWQul5tfWHjokUf8vEP1I/HKzZuddtvp 3Y9Ckof7090b1WrQFwJEGc+agGfy+Xwy6N5X/dA7PT199z33/OSpp8QlBXgxu1NV VTx8rK2tNRsNVVEs0xRPIf0V1Dt+D8nGABB+/fc9e//r9tcei1tSJpudPXr0kUce KczOBn2BO2i1WmdPn15dWTEMI/AwLL5zuqa16IYFSMMDJeCZhWPHgrprbq5Ddpy5 hYVfPP/87NxcINfgIRGJl2/erFYq4glAU1XLstzeorhB2XiMeAwAPtq+Ynl7yp2Z nX34Rz+aDWXK3af6xsZ//ed/blQq48ElYfG9rayvBzI0EAc8MgLemJmZmU4m/Y9h pmnmcrl/fPHF+YUFn4cORL1eL66ubvSysSqysWlu9jg58q2xsbGtD7aQjQHgEL6N uK7b7W2a3dyXm0xmc7m5+fkHH3pIfBD0BcpVrVT+93/8R7vdTiQSPg8tvuuGrjca DZ/HBWKC50LAA9lsNpVO+/xWsYi+d99zz8+ef16M7ue4oWX0+m9VKpVmo6F0OoZh 2OLprb+seuzbttVjdyRk4jGA2NqayO1vyhV3MRH20plMoVBYOHbsB/fdNz09HfQ1 BqzT6fz5P/9zdWXF5xgs/r1oqipG93NQICZ48gM8MHv0qLg1+halxH1RhN4XX35Z PKP4M2IEbFSr5XK5trHR7i2rNk2z37+6v6Z6e0Ie6811bH1MQgYwurbP4m6uVZ6c TExNpdLpfD4/t7Bw3/33p1KpoK9xBDSbzf/4938XcdS3d7o3j0QyzXqt5s9wQKzw YAcMS2TRdCbjW+8rcUd87uc/f+TRR/0ZLibazeba2poIyZsrqxVFNwzbtt1bZzht fdqRnUIyCRlAIL5tN9XTn8IVr0tTk5PTqZS4Mc3MzMwfO3birruYxfXKpYsX//J/ /o9vU8HiX664HzEJDHiO5zZgWH4efWRZ1su//e1dJ0/6MBa2azYalfX1Wq3WabUU VTUMo7/9ePNo5VuLqru3PpmcDGBI28PtZqMp8RrSO7pWpK/pZFLk28Ls7AM//GGY W/1HUqlY/Pd/+7epqSkfxuJIJEASHsiAoeTy+VQqtdV+SepYpN+QE48p4oeIyp1O R9M0Q9fFvzK716B7c37m1n8hk5OTQV8pgMDclmzHem+TbbaYmpiYmp5O3gq3999/ f+S7TI0oPzOw+E9F3E3aHIkEeIoADAylP/279Ut5Gdgyzef/6Z8e+OEPJdWHPwzD OP23v3Xaba03jWzbtmPb7tZzsPjv59ZpT8wYA6Oin2nFP7b+v9yfsO3H2slEYnp6 OpVMpnvLkn9w331sux1117766j//1/+akr8WmklgQAYesIDD2z79u0VGbhG3wEcf e+yJp5/2vDLCSSTkG9ev9zckb7bssizbNO3eiut+M5uxbe2sCcyAV7amZ/sf99ce 9zvkif+P9Q+GnZyaSkxNTYtAK2SzhXz+7u99j322cbO0uHjxwgUfXniZBAY8xwMT cHhzc3OTOy2C8vyOmEgk3nj7bR6wMIjIyasrK61mU1VV8ahkGoZl27Zl9aeXN9dg 9z5ta25q7LvHJt95eDIwWvr/bW9l129/Z+sX/ZdlkWDFByLC9poh921Ozk5P93fV ZnO5u06e5JUW+2EYxv/41381TVP2QJuTwJa1sbEheyAgPnjiAQ4pl8ul0ulBscHD OCHur//44ov33X+/VwWB24gnueLqqq6qumHoIj+bZi8+W5sR2nG+nXnu/eyKp7He Us/urYAh/lvfljL+fqDU1v8F7mwPdmdjsP5JLdsz+Rhtw0bK9inTrV8O+rStP976 b+POQ7qP9BY1jPeXN/SI3Cr+dyu3Tk5NTU32pmH7Tt59N8EVPvvm66//93/8hw9N oTcngVW13W7LHgiICR4vgEOanZ1N7PW85ckT/PETJ3718svD1wFCRaTuRr3e/3hm dva29LL1p5qm9X/HNIx+WNqccukFKBHR+zN+355Z9V39c57lfg2Rs72vTz9t9hPo t79/5Ej/WV+8rm29+vW3s975bxCIg//v3/99rVyWPcrmmcCGUb/1gglgSARg4DAy mcw+z/4dMgOLJ/jfvv763Pz8MEUAAIDnNqrVf/vTn/bzMDAkx3FUZZPsgYA4IAAD h5EvFJLJ5D7D7aEzsG3bP/vFLx58+OHD/XUAACDV1cuX//xf/yX7fDvXdXVdbzWb UkcBYoIADBzGsePHDxRrD5eBCzMzv339dR/eWgYAAIcgoum//elPzUZD3hBbW+vX 19bkjQLEBwEYODCRS6enpw+RaQ/0VyzTfOmVV07ec89BRwEAAL4prqz8v//zf8o4 Fnh7PznxsWEYUpM2EBMEYODABp1+tE/7icHiPvfjn/zk8SeeOPQoAADAH+eWls6f Peth7/odW6lzHhLgCQIwcGALx44NuSx5z3ukqP/mO++k0+lhRgEAAD5QVfX/+e// 3avO84MOEhP1K+vrngwBxBkBGDiwg24AHmRQEcdxnnn22UcefXT4IQAAgA8uXbz4 t7/+dWJiYpgig6Lv1p+yDRgYHgEYOJiZmZnpZNKrajtm4PEjR958912mfwEAGBWb k8D/7b+5uybY3e2efvsMXW+wDRgYDgEYOJi5+XlvTzu4LQO7rvvEU0899vjjHg4B AABku3Du3NLp04fbJLWf9DvWOx9xo1o9RH0AWwjAwMEMvwF4R1sx2LKsN95+++jR o54PAQAA5KnVav/jX/916uBtMveZfsfYBgx4gQAMHIxXG4Dv1C+bTqef/cUvJnpE 0p74Ls4EBgAgtP7tT3+q12r7//z9R9+tz2cbMDAkAjBwAIVCYTqZlBSAx3rtrx54 8METJ08O+gQx9I7BeHtglnd5AABgi3uHb65dWzp9ej9bpQ4afbf+lqHrzWbzEH8X QB8PysABHD16VMZJ91ts2376ueeGbH91WzxmGhkAgD11e+7MtLdxHKf/Qf/zbyui quriX/6y5yrow6XfPss0aweZZAZwGwIwcADzCwtDnnCwu2wu9+MnnpBXv49pZABA 5O0nzd7Gk3HPLy0pnc7uFzZMfZHAq5XKMBWAmOMZFziAY8eOHZE2ferY9gMPPbTL +mc/7TKN3P9Y/ExIBgD45qBpdsiceWjlYvHa1auDVkEPf1VsAwaGxPMrsF/ZbDad ychLfbZlPfXss5lsVlJ9z20PxncmZEIyAGBHW3Ozu0/S3vanQV/1fimdzum//nXH DVOeZHJRRFXEILtNMgPYBc+mwH4VZmaSyaS8+tOp1BNPPRWxDbo7BuPt08gstwaA kbZjiN0z2QZ91RKJL3Dp9GlT17f/prdfsq7rzUbDw4JArPDcCezX3Nzc5MEP99sn cb+89/77T95zj6T6Ydbfk3xbKt7+M5PJAOCPPbPrnRE32mn2cIorK9e//nqraYjn 3yLbsjY2NrytCcQHD5TAfi0cOyZvetayrCeeeSafz0uqHwHjPeRkANjTbQ2Nb8u0 u/wy6AuPiFartfS3vyUSCUnvDoh/U5X1dRmVgTjgSRHYL6kdsMQ98unnnpuenpZU Pz62elxvZePtH7D0GsAI2Z5j+x/sM9YyKxsswzAW//IXeXcZ+mABw+D5D9ivY8eP y7uZzczOPvLYY5KKY0fi3+aOIXnH2Bz0xQIYYbctGB70wZ2/SY4dXZcuXGjU65KK E4CBYRCAgX2R2gFLPOXc+8ADJ+++W1J9DG983/pzy0wvA5GxNQ076Ofdf0mIjafi 6ur1a9fkvX9KHyzg0HhEA/bl6NzclLQOWKZpPvnTn7IBOEr2zMn9+eftH5OZAc9t z663hdL9/HLr46C/DoyeVqt15v/+38ROhyF5wrKsGn2wgEPheQvYl4WFhfFb7Rxl eOZnP5MXsDES+vPGuyTk2z7e/kHQ1w54prvNVv6885c7fnxngg36q0F8iYD6tz// WV59+mABh8ZjE7AvUjtgsQEYwzhySz8MH/SD2z4O+qvBCOjeYezWYbA7/uk+My2R FRHDNmAgnHjWAfZFagesuWPHHnzoIUnFgf3bMRJvz8Z3/ubh/jTgrzMStifPsW2x cz8fb//loN/fRXBfNDBKrl65siFtkpYADBwaTyHA3vKFQjKZlPTUbtv2g488cvzE CRnFgdDaSsWe/Hxb2R3HOtxv3pb37ox/u3/Cjr/cz8/7+QQAYbZWLl+9dGlyclJG cfE6oOt6q9mUURyINgIwsLfZ2dmEtBN6Lct6+tlnM9mspPoAAMB/Sqez+Ne/Suyg aRh1aUusgQgjAAN7m5ufl/QOrjCdTD7x9NOcNAsAQJS4rru0uGjouqT6tm1vVKuS igMRRgAG9rZw7Ji8gDq3sPDgww9LKg4AAIJy9fLljUpFUnEaQQOHQwAG9ia1A5ZI 1w/QAQsAgMi5duWKvIxKHyzgcAjAwB6y2Ww6k5HVAcuyHv7xjxcWFmQUBwAAAapU KpfPn5+Usw1YBGBVUTqdjoziQIQRgIE9FGZmpqen5c0AP/Ozn8nrkAEAAIJiWdb/ /fOfJT1AiABsGEaz0ZBTHogsAjCwh6NHj04lEpKK5/L5x37yE0nFAQBAsC6cPdtu tSQVt0yzVqtJKg5EFQEY2MP8wsLExISk4mwABgAgwqRuA3YcpyqtyRYQVQRgYA/y WkC7rnvfD39418mTMooDAIDAlYrFb776St6DBI2ggYMiAAO7yQjZrKwOWLb96E9+ cvToURnFAQBA4Gq12sWzZycnJ2UU73a7SqejKIqM4kBUEYCB3eRyuVQ6LSkAd8fG nn722enpaRnFAQBA4AzDWPzrX+X1wdJUtd1uyykPRBMBGNjNzOxsIpGQFIAz2ezj Tz4pozIAAAiJc2fOKNIOKxIBu1GvSyoORBIBGNjN0bk5eWcUzR079iAdsAAAiLSr V65sSNupa1lWbWNDUnEgkgjAwG6ktoD+/r33nrznHknFAQBAGBRXVm5evy6puOs4 FRpBAwdBAAZ2I28G2LbtR3784/n5eRnFAQBASFSr1cvnz0/I6YPFDDBwUARgYDfy ZoAt03zi6afzMzMyigMAgJBoNRpLi4tTiYSM4hwFDBwUARjYjbxDgKeTSRGAJRUH AAAh4bquCMCGrsso3u1219fWZFQGoooADOxGXgCmAxYAADEhrw9W13XXpXXYAiKJ AAwMlM/nk6mUpDOQRLR+gAAMAEAMXLtypSIpAHe7uqa1Wi0ZxYFIIgADAxVmZqan p2UEYNd173vwwbvuusvzygAAIGxKpdI3V6/KWFMmArBhGM1Gw/PKQFQRgIGBZmZn E4mEjABsWdbjTz4p6nteGQAAhE2jXj9/5syknHMlTMOo1+syKgORRAAGBpJ3BpJl mk8991w2m5VRHAAAhEqn0zn9l79IagTNSUjAgRCAgYHkdcByHOfp555LpVIyigMA gFDRNG3xL3+RdLCi67qSNhgDkUQABgaSF4DpgAUAQKxI7INFI2jgIAjAwEASA/Dx 4w88+KCMygAAIISuXb1akXNgLwEYOBACMLCzXD6fknYG0g/uu++uu++WURkAAIRQ aXX1xjffyKjc7XY1TWtzEhKwPwRgYGeFQmE6mZQRgG3bfvTHPz46P+95ZQAAEE4b 1eqX589PTk56XnnzJCRdbzabnlcGIokADOxsZmYmIecQ4M0zkJ56StT3vDIAAAin RqNx7vRpGadLiABsmmaDk5CA/SEAAzubPXpU3KVkBGBxl3qaM5AAAIiTTqez+Je/ JCSdhGSatVpNRmUgegjAwM7m5ucnJiZkBGDOQAIAIG6knoRk2/ZGtSqjMhA9BGBg ZwvHjh3p8b4yLaABAIgfeY2gOQoY2D8CMLCzfgAWH3iegY+dOHH/D3/obU0AABBy 1776qlIuy6hMAAb2jwAM7CCXyyW3nYHkbQY+fuLEfQRgAABi5puvvlqTE4A3T0JS 1Xa7LaM4EDEEYGAH+Xw++d09ul5lYNd1H3joIZGBPakGAABGhUi/165cGR8f97yy CMC6rrc4CQnYBwIwsIP/v737fWrjuhc4vCASXGqBwbiNQ1I7ed3pdKad6f//MjO9 d+507stOYjchTmNsbOxifuhHV7tokYSQhJB2JX2fZ2xMbCEpJ450PpzdPTuPHm1u bt78/ftncKPR+OOf/vRob++e9wMALJd3b9/+/z/+Ma+tgM/P3797N/N7htUjgGGI R7u7IzYquE8GX15c/Pmvf61vb099DwDAMjo5Ofm/v/99Hjsh2QoYJieAYYi9vb2N cVvVT5fBl5eXf/nb37a2tqZ6XgDAsjo9Pf3f774bO8GYQhrAjUbj7Zs3M79nWD0C GIbY399fn2CnvikauNVqpQE89PhqAGCFnZ+f/893383jHOBUs9k8ev16HvcMK0YA wxDFHkiTuFMG2wQYAMKa01bA7YydkGASAhiGuFMA5ya8vU2AASCs7//5z19nuhNS 2r3FJwIYJiGAYdDAJsCTm+RLnn3zzdODg6meFwCw3F4dHr784YdZ3VtRv/k/fPr0 yVbAMJYAhkHb29ubDx5MfannEV/YarW+PDjY29//zdbWZ3O4BgYAsJguLy8/nZ6+ PTr6+fDw/qcB96Vv19mnTycnJ/e8Z1h5AhgG7ezsfL65eZ+9jsZ+basrvV1tYyN9 uD88f767t6eKAWDZpa17/Pbtv168uDg/bzYaaaqud83k/ofWb+r87Oz9+/czeQhY YQIYBo3eBHhyUyR0I32bTN/V2u219fWNzz57/u23W1tblosBYAHli7qpF99/37i8 bLda6Xv/+tpabWNjTo94W/rmbAUMkxDAMGjv8eONGb113WcZudBqtdqdnx21LIyf PX++9fChMAaAElyF7sePL1+8aDQazWZzLQvdtdkt6k5idP0m2bfRbQUMYwlgGDTh JsCTm0kG35QfRJ3vfJC+Adc2Np59881DYQwAU8lD92Mauj/80Dl0OVvR7XZueaF7 09j0zaWzAlsBw1gCGAbtP3ky8/e5OTXwbZrNZvpm2TnHeG0tXzT+6tkzbQwAReX+ 9PJl4/KymX0rOX3f77xjzvTb37MyYf0mdkKCyQhgGPTkyZO1+Xyjt+QMvqlTxWkb Z98kztu4lrbx11/Xt7e1MQArI6/cDycnP/34Y7O3crNrT1b97CY1efoWtxfAMJYA hkHzC+BkARp4hHzduLgK13otrePPvjw4kMcALJoicX8+PEw/73x7t3vE8sKu5d7J Xes3EcAwmcWdi0Ml0th7cI9NgCexyA08QprH6VtrK3s/Xst2dKhtbDw9OHi0u5v+ jkIGYIbyvk0/eXd8/OrwsNlodC57kf3Revo2uhKJO8IU9Zt/1dnZ2QdbAcNISzkR h/m5/ybAE1rSDL5Nfsrx9QJyfsmQWu2Lp0/39vcThQxAj6Jv3x4d/fLqVecQ5ewo pFVawp3OdOlbfO3F+bmtgGG0lZqCw/092t1NO620Ol2xDB4tv2x1kr+7Z5GcTnDS TP79F1/sP3mS30YnAyy1omxTR69f//uXX1r9cZtkxxBVe1HlxXSf9C1cXlwc2woY Rgo0+YZJ7D1+XKvVSu7SUBk8Vn4qcpIvJmeDk5+QvFGrPfnd7/L15EQqA5SoN2vf Hh29/vXXRrOZn3ZbvFYnsVdu72Mm6ZuzFTCMZdoNfR7v79fW15MqilQG30l+xPXV acn51KHYrTGr5TSVLSwD3GZgqTbN2rxpW92mvTpUp1u21mznYYbpm2s2m2+OjmZ7 n7BiTLihT2cT4CJEZfAKyS/i1U7ypeV2Z5TzKV36o1ZLf+zu7v7+6dPi9poZWCK9 NZv696tXx8fHrTxou1dnaCfdE2yzT9ZHHu408zBjwJxGuNVqHb1+PY97hpVhqg19 0gBeG5gRyOBVNHaE+y7rVWRz9lWduWNnN8mrc5h3dnaeHhwUX6icgakNdOyrw8P3 79/n59C2slelvJnaxdpst2nz16SZPAfpO29zHWE7IcFYJtnQJw/g/PPr/z0qylEZ XIKZD3I+sxmI5+LP8sdby6aq6cdadiWYh/X6l1991XsnKhqWzkC7pn7+6aePHz6k rwadSxznrwl5wWYvBfltBiI2qe6VX/eWoIRBtgIMY5leQ5/eAE40cBiLNs69FZ2f 4dy+EdJJcTTj1anPnare+u1vv3727OYdKmoYcLNXcz++fHn6n/+08mNAut/JKs6J 7Q3Xns8qbtd7kr7lKGec07+0rwUwjLSUr9QwJ/V6/cGDBzdbVwYHscLj3FfU+fGT WVQn3X/O/25fHVeZdNu6Z7E6P8Ay/R/kD8+fD30Ijc0M3VanqX+9eHF2dtbuDdRs WbU4zbU4W6E45iL/2O5Zbl3qXp0t9VuCMgc5fayzT58+fPhQ2iPC0vHSD9e2t7c3 0wAexlnBQRjnqRWNXfUTKdu8p7YB/06q03JI33KUPM7pw52fnZ2cnJT5oLBcvLvA tZ2dnc83N0fcwFJwEMYZWGHStxyVjHP6oBcXF+/fvSv/oWFZmOTBtUe7u2OP4bQU HIehBlaP+i1HNeOcPWrj8vL4+LiCR4clYXoH1/YeP67VapPc0lJwEMYZWBnStxyV jXP3iomtZvPNmzfVPAdYBuZ2cG3gEtCjWQqOw1ADS036lqba+k26WwbYCQlGMKuD a3cK4GQBGjjRZiUy1MDSkb6lqTx9k/za/gIYxjGfgyv1en3zwYMpIkcGR2O0gQWn e8u0OOlb/P7Z2ZmdkOA2pnFwZXt7+/PNzanbpvKzghNhVjoDDiwU3VuyKge855jn m+yEBCOYvcG1+vb2eto061futRosgyMx5kCFdG/5Fi190+fTynR+abc/qF+4nUkb jPKwXu8U8R2rWAaHZdiB0ujeSlSevunPZrOZdW47z92PjnaGuzBXgztLq7jTwSOr eBFODE70WHWMPDAnurcq5Y98p3Cz1m1pXZgdUzSYjaFVvCAZnOix6hh5YCZ0b4VK GPz0IazrQjnMzGC+bp5XXGERibGqGHlgatK3QvMY/FaX83WhEuZkUIF6vb623tvF 01xwa2pirCpGHrgT6Vuh+w/+wIWp0o+2JoJFYDYGi6LvIOr0Q62WfpzTgdNKrEIG HxhL+lZoisHvXdRtZ7QuLCzzMFh09exK1AMrxjO5ZyVWLeMPDNC91Ro7/n0ruhZ1 YTmZfsGyuloxzsO4G8fT7F0swypl/IFE+lZtYPybzWb3WlRCF1aNiResoOtzjHtW jUfcXoNVzn8CCEv6VmLwBF2VC2GYckEsRRt3zzVeK9aNNVjl/CeAaNTvXF0lbu9i rsqF8Ey2gCvXV+Hq9nGRx8KsNIYagpC+M9F7jeV2l010gRHMtICJ5Hmc9AVy3wIy M2RIYYVJ38l1V217DlROR89lloF7MMcCZuNmIfdGctXPbomJYVgBoneoYvH2evU2 61tLuMD8mFcB5cm3dBqIZAdaT84QwRKJHL3XK7f9LN4ClTOXAhbOkMXk9NWq59pd VT/BhSCGYQGtfPTebNqrss3+yLItsPjMn4Aldp3KSXJzYbknn1fZyv8LwuJb3u4d WrP5v44FW2AlmTYBgfQeg50UyZwMieeqn+mUlveZw9JZwOgdcrxx9zcTQQuQMVUC GGNwnTnpBnOyuOW8OM8EVkwJ3XtbxybXIZu4UhTAdMyQAObo4cOHnZOWe9s56avo ZFhNz/AJKGGYiQm7d+AQ4r6l1557ufo1u0zUx48f5/WkAbjBxAhgCfSFdOdn/ycD i9PJ8Lqu6snDYhqxvloEam+19n4iXAGWlPkQQFBXUZ305HRyI62T4Y1986PAZrb6 lk9v/zi0Tjsfej4XqwAUzFcAYHpbW1tzvf/T09O53j8AhCKAAQAACEEAAwAAEIIA BgAAIAQBDAAAQAgCGAAAgBAEMAAAACEIYAAAAEIQwAAAAIQggAEAAAhBAAMAABCC AAYAACAEAQwAAEAIAhgAAIAQBDAAAAAhCGAAAABCEMAAAACEIIABAAAIQQADAAAQ ggAGAAAgBAEMAABACAIYAACAEAQwAAAAIQhgAAAAQhDAAAAAhCCAAQAACEEAAwAA EIIABgAAIAQBDAAAQAgCGAAAgBAEMAAAACEIYAAAAEIQwAAAAIQggAEAAAhBAAMA ABCCAAYAACAEAQwAAEAIAhgAAIAQBDAAAAAhCGAAAABCEMAAAACEIIABAAAIQQAD AAAQggAGAAAgBAEMAABACAIYAACAEAQwAAAAIQhgAAAAQhDAAAAAhCCAAQAACEEA AwAAEIIABgAAIAQBDAAAQAgCGAAAgBAEMAAAACEIYAAAAEIQwAAAAIQggAEAAAhB AAMAABCCAAYAACAEAQwAAEAIAhgAAIAQBDAAAAAhCGAAAABCEMAAAACEIIABAAAI QQADAAAQggAGAAAgBAEMAABACAIYAACAEAQwAAAAIQhgAAAAQhDAAAAAhCCAAQAA CEEAAwAAEIIABgAAIAQBDAAAQAgCGAAAgBAEMAAAACEIYAAAAEIQwAAAAIQggAEA AAhBAAMAABCCAAYAACAEAQwAAEAIAhgAAIAQBDAAAAAhCGAAAABCEMAAAACEIIAB AAAIQQADAAAQggAGAAAgBAEMAABACAIYAACAEAQwAAAAIQhgAAAAQhDAAAAAhCCA AQAACEEAAwAAEIIABgAAIAQBDAAAQAgCGAAAgBAEMAAAACEIYAAAAEIQwAAAAIQg gAEAAAhBAAMAABCCAAYAACAEAQwAAEAIAhgAAIAQBDAAAAAhCGAAAABCEMAAAACE IIABAAAIQQADAAAQggAGAAAgBAEMAABACAIYAACAEAQwAAAAIQhgAAAAQhDAAAAA hCCAAQAACEEAAwAAEIIABgAAIAQBDAAAQAgCGAAAgBAEMAAAACEIYAAAAEL4LyMC H4FMU3sLAAAAAElFTkSuQmCC"/></symbol><use xlink:href="#c" width="1280" height="1280"/></g></g></svg>')} -.is2d .bishop.black {background-image:url('data:image/svg+xml;base64,<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="614.635" height="614.635" viewBox="0 0 460.977 460.977"><mask id="b"><use xlink:href="#a" width="1280" height="1280" transform="rotate(.193) scale(.36014)"/></mask><symbol id="a" viewBox="0 0 1280 1280"><image width="1280" height="1280" xlink:href="data:image/png;base64, iVBORw0KGgoAAAANSUhEUgAABQAAAAUACAAAAAA9j6ArAAAACXBIWXMAAA7EAAAO xAGVKw4bAABGJUlEQVR4nO3dB3xUdaK38bzZiDRDMTQREFFU1EVlEUXE3kBpXiys YFlRirpi74Bi7wqCveBacFWwN1REXRQLFhCQ3kvoJVERXwwgKZNk5sw55/cvz/fe z91dN0yezzDzu8nMmXP+XwYAeOr/qQMAQIUBBOAtBhCAtxhAAN5iAAF4iwEE4C0G EIC3GEAA3mIAAXiLAQTgLQYQgLcYQADeYgABeIsBBOAtBhCAtxhAAN5iAAF4iwEE 4C0GEIC3GEAA3mIAAXiLAQTgLQYQgLcYQADeYgABeIsBBOAtBhCAtxhAAN5iAAF4 iwEE4C0GEIC3GEAA3mIAAXiLAQTgLQYQgLcYQADeYgABeIsBBOAtBhCAtxhAAN5i AAF4iwEE4C0GEIC3GEAA3mIAAXiLAQTgLQYQgLcYQADeYgABeIsBBOAtBhCAtxhA AN5iAAF4iwEE4C0GEIC3GEAA3mIAAXiLAQTgLQYQgLcYQADeYgABeIsBBOAtBhCA txhAAN5iAAF4iwEE4C0GEIC3GEAA3mIAAXiLAQTgLQYQgLcYQADeYgABeIsBBOAt BhCAtxhAAN5iAAF4iwEE4C0GEIC3GEAA3mIAAXiLAQTgLQYQMapca+/qjSrWL/6o +2N+/uyVE5eulzTBZwwg4tF4rzr1d9o5p3HF6gn/65X5M3PnLZi/+KeZMXfBawwg IpfTrGGtRv/YPbtiuV+Zv/rnr2YvnTMpN4YqgAFExKo3brL7gQc0TOnPzPnmy5+n z1wZURGwDQOI6DRosOcRBzYN9EenfvnR5LlzQ+4BimEAEZH6jfc5pXnNNG5g+Xcj fpw5P7QeoCQGEFGoXbdVt8NDuJ2Pn/ti0ZIQbgdIiAFE6CrXa9arTXZIN7b602GT FnKADKLBACJk2Tv1OG/HUG9x2SPPLFgd6i0CmzGACFNmhf3uODSC2x17xYRfN0Zw u/AcA4jwZGadOrBxRLc9s/+LG5hAhIwBRGhqXtKnRoQ3v+Khe5ZHePPwEQOIkFS+ +6zyP+qRnvynLuXtEISJAUQ4hvaK5dsM6x3Lt4EnGECE4aYLEp/jIHwrB18f03eC BxhApO/UIeEe91K2ZX1fjPG7wWkMINLVcvgeMX/HKd3Hx/wd4SgGEGka2VHwTUd1 EnxTuIcBRFo6PZoj+b65PUdKvi/cwgAiDbVfPCjqQ19Kkz/uVM6SgHQxgAiu2/2a H/82y/33c8LvDicwgAgq+9WDK0kD8v7XmXMkIC0MIALqeHcTdULG9EtHqRNgNQYQ wdx3zg7qhE3WPHGxOgE2YwARRNNH26oTtvik51R1AuzFACKAk+4KdqmjKEy97HV1 AqzFACJlFS66vLa6oZAldz7wq7oBlmIAkaqat3bXvvtbXN7wqzlRIAJhAJGixvcq PvtWtlH9ZqoTYCUGEKlpe08LdUICX1/yiToBNmIAkZKWI3ZRJyQ06xROEIPUMYBI xVFP7axOKMW8s0arE2AfBhApOP3RKuqEUq3r+bw6AdZhAJG8rk9VVieUYf1ZL6kT YBsGEEnr8h/Vua+Sk//PV9QJsAwDiGSd9Jq6oFwd+FAIUsIAIknt31AXJOHEN9UF sAoDiOQc/7a6ICknvKMugE0YQCRlnx/UBUna90d1ASzCACIZNafHdeHzdK1swueC kTQGEEnImVZNnZC0VbvlqhNgDQYQSZi+q7ogBTP0p+qHLRhAlCvzm+bqhJR8d8BG dQIswQCiPJk3X6VOSNFt17KASAoDiPJYcQBgURwOiOQwgChHk2nqggB2m64ugBUY QJSt9g8mXf8jWUv2XaJOgA0YQJSp5oij1AmBjD6FwwFRPgYQZcm6rr86IaCBgzao E2A+BhBl6fS82WfAKl3+6SPVCTAfA4gy7PlWY3VCYDPbTVYnwHgMIEpXeWgPdUIa num9Xp0A0zGAKF2/e9QFabnkXnUBTMcAolStX66rTkjLopM/VyfAcAwgSpP97Enq hDS9fsZqdQLMxgCiNJfdqS5I2+V3qQtgNgYQpdj/habqhLRNPe1bdQKMxgCiFCO6 qgtC8NIp6gIYjQFEYqcPqaFOCMGKvs+rE2AyBhAJVf2wpTohFOOPXKtOgMEYQCR0 25XqgpDcbtvZXBEnBhCJ1BvXUJ0QkjkHLVQnwFwMIBJ5pru6IDTDbf44HyLGACKB NqNqqhNCs7zjp+oEGIsBRAIf2HkW1MRGH60ugLEYQJR00FsuHAKz1Yp249QJMBUD iJI+OlxdEKqPj1AXwFQMIEpo+X41dUKoVh0zXp0AQzGAKGFMW3VByD45TF0AQzGA KG7/T6qqE0K2ti3nREBCDCCKe+50dUHonu+mLoCZGEAUk7ncrVcA/7Sq5kZ1AozE AKKYBy5UF0TgwYvUBTASA4hiFtdWF0RgSR11AYzEAKKojm5eT7zTKHUBTMQAoqhv 9lcXROLbA9QFMBEDiCKqL9penRCJX+quVCfAQAwginj4PHVBRB45X10AAzGAKCJ3 R3VBRJblqAtgIAYQhTWbqC6IzN6T1AUwDwOIwl7uoi6IzCsnqwtgHgYQha1x7WPA 26zdQV0A8zCAKKTNWHVBhA7l1PgojgFEIaM6qAsi9FpHdQGMwwCikOUunQq/uBXu XOgJYWEAsU2DOeqCSDWcqy6AaRhAbDO4r7ogUkMuUBfANAwgtvl5N3VBpKbtri6A aRhA/KXCL+qCiG3/q7oAhmEAsVVmmzHqhIgd9iknhkYRDCC2ynq8hzohYs/8a4M6 AWZhALFVhamN1AkRm92U34FRBAOIraquURdEboe16gKYhQHEVq0/UxdE7pDP1QUw CwOILSo+eK46IXKPXZivToBRGEBskf1Jc3VC5L5ru1qdAKMwgNii5vTq6oTIrWyy XJ0AozCA2KL2YnVBDOosURfAKAwgNss8yc0LAhfV6XUOhUYhDCA2q3jD1eqEGNx6 I++CoBAGEJtVf+UIdUIMPurC5YFRCAOIzep/78P5Qpf/fb46ASZhALFZo8kV1Qkx yN9ztjoBJmEAsVmTaeqCWOw2XV0AkzCA2Oywj9UFsTjc9VN+ISUMIApk/WuYOiEW vR7njFjYhgFEgcrXXKtOiMXNt6xXJ8AgDCAK5Dx5ojohFm+cnatOgEEYQBSoN6ql OiEW4zsuVCfAIAwgCjQeW1+dEIv5h85UJ8AgDCAKNPvah8MAMzLyW0xSJ8AgDCAK 7PlVFXVCLNb9Y7I6AQZhAFFgnx/UBTHZ90d1AQzCAKJAyy/VBTE5cLy6AAZhAFGg 1Th1QUwO+kJdAIMwgCjAAMJHDCAKMIDwEQOIAgwgfMQAogADCB8xgCjAAMJHDCAK MIDwEQOIAgwgfMQAogADCB8xgCjAAMJHDCAK8FE4+IgBRAFOhgAfMYAowOmw4CMG EAWafVVJnRCLvH9wQlRswwCiQOMxDdQJsZh7GKfExzYMIArUe7WVOiEWX3TmokjY hgFEgZzHOqoTYjHqXC6LiW0YQBSofEV/dUIsBt7BhdGxDQOIAllnPapOiEXPpzao E2AQBhCbtRmrLojFoZ+qC2ASBhCbNZ6hLojFrrwJjEIYQGzW6CcfDgTM22u2OgEm YQCxWb3vaqkTYrC0OUfBoBAGEJtlv3CCOiEGb5+2Wp0AkzCA2KzClTeqE2Jww+2/ qhNgEgYQm2Ue/a46IQbHfbBRnQCTMIDYouYydUEMdlyuLoBRGEBsUXNKjjohcrl7 MIAojAHEFtnvH6hOiNyXx/AeCApjALFFhVsuVSdE7u5reA8EhTGA2Orv36kLItf8 e3UBzMIAYquKeeqCyFXKVxfALAwgtqowYS91QsR+2o/fgFEEA4itsu7op06I2L1X cC4sFMEAYqvMfVx/EbD5jxwGjSIYQGzzhzogYjzaUQwPCWzzzf7qgkh9e4C6AKZh ALHNNTerCyJ17S3qApiGAcQ22avUBZGqxsdAUAwDiELm76QuiNCC+uoCGIcBRCFD e6kLIjSst7oAxmEAUcjuU9UFEWr6s7oAxmEAUdiiOuqCyCyuqy6AeRhAFHbnZeqC yNx1uboA5mEAUVjOUnVBZGrlqgtgHgYQRUxroi6IyPTd1AUwEAOIIvrdoy6IyCX3 qgtgIAYQRa3KVhdEYnU1dQFMxACiqFc7qQsiMbKzugAmYgBR1D7jK6oTIpDf8kd1 AkzEAKKYSS6eF/qnZuoCGIkBRDHnPK4uiMC/nlAXwEgMIIqb1UhdELrZu6gLYCYG EMX1H6AuCN2AgeoCmIkBRHF1vnPtA8GLmy9WJ8BMDCBKeMi180YN7aMugKEYQJRQ +xu3Th06/4Al6gQYigFESQ9eoC4I1eAL1QUwFQOIkup84dIbwbNb8QogSsEAIoH7 /q0uCNH9F6sLYCwGEAnU+2gPdUJophyxUJ0AYzGASKTvnZXUCSHJu3yIOgHmYgCR SNaY1uqEkHx+2AZ1AszFACKhLo/WVCeEYnnPV9QJMBgDiMSeOlNdEIqnz1IXwGQM IBJr9vKe6oQQTD55kjoBJmMAUYorblcXhODKO9QFMBoDiFLUfLKDOiFtr529XJ0A ozGAKM1hz+2kTkjTgm5j1AkwGwOIUl1zs7ogTdfeoi6A4RhAlKr2s8eoE9Ly/hmc BQZlYwBRulYv7KJOSMOs075QJ8B0DCDKYPUFkrgQEsrFAKIMVR/qrk4IbHifteoE GI8BRFkajNpfnRDQtx3nqhNgPgYQZWr7qp2fCV7e+RN1AizAAKJs5w9TFwTS62F1 AWzAAKIcVl4jjuvAISkMIMrznn1HA75/rLoAdmAAUZ6a/2uqTkjR1IP5CDCSwgCi XC0+rqpOSMnaw79WJ8ASDCDK1/OBiuqEFORf9Kg6AbZgAJGEq206q8A1t6oLYA0G EMm48zJ1QdLuulxdAHswgEjK4L7qgiQNuUBdAIswgEjOyI7qgqSM6qQugE0YQCSn 6nAbpmVkd86AgBQwgEhS9qjD1Qnl+rjjanUCrMIAIlkW/BLML8BIDQOIZOWZfzBg fiV1AezCACI559y3gzohCWsu5jTQSAEDiGQc8czO6oQkzevxkToB9mAAUb76L7dS J6Tgi5PnqxNgCwYQ5cl67Ex1QoqePneDOgF2YABRjr53VFYnpGz9FUPUCbACA4gy tX6hgTohkLmnfa5OgAUYQJSh9stt1AmBfXryEnUCjMcAolSZQ3qpE9IyrO9GdQIM xwCiNB2fqq5OSNPKs0apE2A2BhCJ1X7NpkNfSvNFB34PRhkYQCR025XqgpDcfpW6 AAZjAJFAy9fqqhNCs6jDeHUCjMUAooSs/5yiTgjViH9yXDQSYwBRXKfhdl0Fs3xr u49UJ8BMDCCKqvzWYeqECIxpt16dABMxgCji1CfdPKVe3tkvqhNgIAYQhbj5499m /BCIkhhAbNPlWTd//Nss74xX1AkwDQOIrbJe7qBOiNhrJ/N2MIpgALFFq7drqBMi t+KEL9QJMAoDiM0euFBdEIsHL1IXwCQMIP6U81lTdUJMph6Sq06AORhAbNLpVXVB jDpzVDS2YgCRkfFMd3VBrIb3UBfAFAwgan/ZSJ0Qs9kHcpIsFGAAvXfUGxXVCbHL P3G0OgFGYAB9N6C/ukBi4AB1AUzAAPot6/3D1QkiHx/DQdFgAP1W+9ud1AkyC/bn hUAwgD5r8Yl91zwPz/q2X6sToMYAeuyM4eoCse7PqgsgxgD6687L1AVyd12uLoAW A+itEV3VBQZ4ya2rnyBVDKCnMse2VicY4fNDN6oTIMQA+qnid76c/KA8U5vnqxOg wwB6qeakOuoEYyxutlydABkG0Ee1J7t/7tPkrdiTAwK9xQB6qP7EauoEo6zae746 ASIMoH8a/bCDOsEwa/adrU6ABgPonUYTq6gTjLNubxbQTwygb+pPYf9KWrcHvwV7 iQH0TM3p1dUJRlrZhPeCfcQA+qXyzNrqBEMtabxenYD4MYBeqfBzQ3WCsebs/qs6 AbFjAL3y497qAoNN3EddgNgxgD4Z1UFdYLTXOqoLEDcG0CO3XqUuMNxtV6sLEDMG 0B9nPqUuMN5ZT6sLEC8G0ButxqkLLHDQF+oCxIoB9EXVhVXVCRZYW2+tOgFxYgB9 8f2+6gIr/PB3dQHixAB6YnBfdYElhlygLkCMGEA/dBypLrBGp1HqAsSHAfRCzlJ1 gUVq5aoLEBsG0At8AiQFfCLEIwygD/oPUBdYZcBAdQHiwgB6oNEsdYFlduH0qL5g AD0whUtgpmbqHuoCxIQBdF+/e9QF1rnkXnUB4sEAOq/qGnWBhXbgAyF+YACd985x 6gILvXu8ugCxYABdt88P6gIr7fujugBxYABdN2kvdYGVfmqmLkAcGEDHHfOeusBS x76vLkAMGEDHzWisLrDUzF3VBYgBA+i2Y99VF1jrOH529gAD6LaJvJQV1CQ+P+0B BtBpzSaqCyy29yR1ASLHADrt3WPVBRZ7jwMo3ccAuizrN3WB1bbboC5A1BhAl115 m7rAalfdri5A1BhAl03dXV1gtZ85i47zGECHZa9SF1iu2mp1ASLGADrs+hvVBZa7 4SZ1ASLGADrsm/3VBZb79gB1ASLGADosf3t1geV+qaguQMQYQHc1naIusN4eU9UF iBYD6C5eAkwbLwK6jgF014dHqAusd9fl6gJEiwF01+yG6gLrvXGSugDRYgDdtbaK usB6vA3sOgbQXX+oA+w3r4G6ANFiAJ3FmRDSt3xHdQGixQA6q/48dYH9VtZQFyBa DKCzWn6pLrDf6jr56gREigF0FgOYPgbQdQygszgdfvpWVVcXIFoMoLMazFEX2I/X AF3HADor83d1gf2W1lYXIFoMoLs4DjBtU/dQFyBaDKC7ltVUF1jvszbqAkSLAXQX 50NN2+PnqgsQLQbQXff9W11gve7PqgsQLQbQXa0/UxfYbnX9teoERIsBdBjvgqRp GpcVdR0D6LBxrdQFlhvWW12AiDGADjvncXWB3da3+VadgIgxgA7jUOj0cBSg+xhA lz37T3WB1S65V12AqDGALqu5TF1gs4U7qQsQOQbQaW+doC6w2M3XqQsQOQbQadVX qAvsNXNXdQGixwC67Q4ubBvUaS+qCxA9BtBx83khK5gPjlEXIAYMoOOaTFMX2Gn+ zuoCxIEBdN3FHMsRwPp2Y9QJiAMD6LzhZ6gLLMQhgJ5gAN336SHqAusMuUBdgHgw gO7L/G4fdYJlnu+mLkBMGEAffNZaXWCVoX3UBYgLA+iFUR3UBRa5sb+6ALFhAP1w 9S3qAlus7vamOgHxYQA90frdquoEK0w9dIk6ATFiAH1R8b/t1QkWuP0qdQFixQD6 o91wLhRcth9PnqpOQLwYQJ/0v3p7dYLBFl/4kjoBcWMAvVLxvvPVCaZaNug+dQLi xwB6JmtQ72x1g4HmDHxCnQAFBtA/Hfvvr04wzOv9ufybpxhAH1W9skdDdYMxJjzI D3/+YgA9Vbtfl6bqBgOMG/5EvroBQgygv7JOOfWg2uoIoVkfPjda3QAxBtBvFU7u 2GoXdUT88maM/S/jBwYQmzQ4+fAW/pwBfuoX77+5XB0BQzCA+NMz3dUFsbl+kLoA 5mAA8aeFddUFsfmylboA5mAAsUn2KnVBfNZwIDj+wgAiw7PTBXYeqS6AMRhAbDKh ubogRq92URfAGAwgNvlDHRCnxf683onyMIDIyOjo1y+Fe3DWP2zBACIj460T1AWx uv9idQFMwQAiI2OVX2+MTt5LXQBTMIDIaDJNXRCvvMrqApiCAUTGQ73VBTG76EF1 AQzBACJjViN1QczGHK4ugCEYQFTMUxfEbWUNdQEMwQDiwgfUBbE79n11AczAAGKc f2cHeNafk9+gTAwg8v27WPAc3171RCkYQO+1GasuEKiVqy6AERhA743oqi4QGHS9 ugBGYAC9tzRHXSDwTQt1AYzAAPqu9mJ1gcK6quoCGIEB9N2tV6kLJHoMVxfABAyg 7ybvoS6QeKu9ugAmYAA9l/WbukAjt5a6ACZgAD135lPqApEDx6sLYAAG0HNj2qoL RB7rqS6AARhAv/UdrC6QOfIjdQH0GEC//bSnukDmjZPUBdBjAL2W+bu6QGdpbXUB 9BhAr53h89FwB3yrLoAcA+i1z1qrC4SePEddADkG0GteXRC9uLkN1QWQYwB91v4N dYHUbtPVBVBjAH32/tHqAqnBF6oLoMYA+myd3xfInb6bugBqDKDHDvtYXaCVv4uX pwJDIQygx95spy4Qu/sydQHEGECPra2iLhCb6uepwLANA+iv1p+pC9Ty6y9XJ0CL AfTX6yeqC+TuvEJdAC0G0F9ruC7GFH/PBYECDKC3Wo1TF+jl1V2tToAUA+itkR3V BQa49Rp1AaQYQG+t3kFdYIBJe6sLIMUA+qrFV+oCE+TlrFcnQIkB9NUrndUFRhh0 vboASgygr/gNuAC/A/uNAfRUm7HqAjPk7cyx0D5jAD3l/eeAt7rrcnUBhBhAT62v pC4wxLTd1QUQYgD9dPzb6gJT5Dedq06ADgPopw+PUBcYY8gF6gLoMIB+8vpqSEXN aqwugA4D6KX/e0ldYI78/SerEyDDAHrJ6+sBF/f4ueoCyDCAPsr8XV1gknkN1AWQ YQB91PMRdYFRDubEYN5iAH30wz7qAqP8t6u6ACoMoIeqrlEXmGVZjroAKgygh265 Wl1gmG7PqwsgwgB6aF59dYFhxhyuLoAIA+ifxjPUBaZZk60ugAgD6J9nuqsLjHPl HeoCaDCA/llZTV1gnO+bqwugwQB6p+0YdYF58hrmqhMgwQB654Oj1AUGuv9idQEk GEDf8DG4RGbvoi6ABAPom15D1QVGOvRTdQEUGEDfTGmqLjDSax3VBVBgAD1Te7G6 wEwraqoLoMAAeuZRTn6X2EUPqgsgwAB6ZkV1dYGhJuyvLoAAA+iXIz5UF5hqfeMl 6gTEjwH0y9g26gJjDeutLkD8GECvZP2mLjDX/J3VBYgfA+iVq29RFxis/VvqAsSO AfTK7IbqAoO9f6y6ALFjAH2y+1R1gclW8Qa5fxhAn4zqoC4w2qDr1QWIGwPoEc6D ULaZu6oLEDcG0COX3qUuMNyx76sLEDMG0CNzGqgLDPfBMeoCxIwB9Mc+P6gLTLem +kZ1AuLFAPrjXQ7zKM9dl6sLEC8G0Bt8CqR8cxqpCxAvBtAb192kLrBAh9fVBYgV A+iNhXXVBRYYc7i6ALFiAH3R4it1gQ3W1spXJyBODKAvPjlUXWCFIReoCxAnBtAT 2avUBXZYVE9dgDgxgJ4Y2ktdYIleD6sLECMG0BNrqqoLLPF9c3UBYsQA+uHsJ9QF tsg75Ft1AuLDAPphRmN1gTXeOEldgPgwgF7Yj59qkrYqZ4M6AbFhAL3AxeBSwJEw HmEAfVB9hbrAJhwJ4xEG0AdPnK0usMpFD6oLEBcG0AOZ6yqqE6wyeS91AeLCAHrg ytvUBXbJ7/ieOgExYQA9sDRHXWCZzw9RFyAmDKD7urysLrDNuubT1QmIBwPovp93 UxdYZ2RndQHiwQA6j4OgU8fB0L5gAJ33v4PUBRYa1ltdgFgwgK6rP09dYKOltdUF iAUD6Lo32qsLrDToenUB4sAAOo4zQQczr4G6AHFgAB331JnqAkvxeTgvMIBu42ro Qa3dQV2AGDCAbrvzMnWBtUacqi5A9BhAp2WuqaxOsBfPDQ/wl+y0/gPUBRYb3kNd gMgxgE5bzQtZaeDJ4T7+jl3W7x51gdUeP1ddgKgxgC5bVlNdYDeeHc7jr9hhfYao Cyz3yPnqAkSMAXQYPwCmi6eH6/gbdlfPR9QF1hvaR12AaDGA7uJM+Onj+eE4/oKd de6j6gIH8COg4xhAZ/EDYBh4griNv19X9R2sLnACxwK6jQF01Yrq6gI38AxxGn+9 jrridnWBI95upy5AhBhAR62pqi5wxd82qgsQHQbQTQP6qwucMZ3LKjuMAXRS1upK 6gR37D1JXYDIMIBOmtVIXeCQPE4q6y4G0EV7/qQucMrAAeoCRIUBdNGSWuoCp/xR d4k6ARFhAB3Uapy6wDHf7acuQEQYQAdxDHTYznlSXYBoMIDuOf5tdYFz8ndcr05A JBhA96zjXcvQjT5aXYBIMIDO4TyoUTjhHXUBosAAOucPdYCTVuVsUCcgAgygawZd qy5w0/Pd1AWIAAPomMzf1QWO+qPl1+oEhI8BdMyLp6gLXLWonroA4WMA3VJ9hbrA XXdfpi5A6BhAt3zZUl3gro27zVQnIGwMoFOaTVQXuGzqHuoChI0BdMq8+uoCp/V9 SF2AkDGALjn1BXWB08acuFadgJAxgA7JXMt5oKOz5p+vqxMQOgbQIQ9cqC5w1x8j zuCjIA5iAN2Rs1Rd4K5FHcarExAFBtAdY9uoC1y18f5L1AmIBgPojLZj1AWumno8 BwC6igF0xqI66gI3/XblveoERIYBdEX/AeoCN41rv1ydgOgwgI7gQ8CRWPevF9UJ iBID6IjRR6oLXPRa11/VCYgUA+iGNmPVBQ5a2uVTdQIixgC6YWFddYFzNj54sToB kWMAnXDTdeoC50xux7EvHmAAXVB7sbrANb9cOkSdgDgwgC4Y/w91gWM+6rRanYBY MIAO4CxY4Vp+2vvqBMSEAbRf1soq6gSXbHyIk+r4gwG0HxeCC9OPJ85WJyA+DKD1 Wn6pLnBIXt8n1QmIEwNoPU6CEJo/RnbLVzcgVgyg7e7ppy5wxuwTf1QnIGYMoOUa z1AXuGLjlXepExA7BtByM3dRFzjif4dz3gMPMYB2u5SfWkKxpjW//XqJAbQan4EL xR8DB6oToMEAWm36ruoCF0xoyRUvfcUA2qzfPeoCB6w/+Ht1AmQYQIvVXKYusN8f t1+tToAQA2ix+TupC6w3uTnv/XqNAbQXZ0FN17wO36oToMUAWot3gNN1Y391AdQY QGut3kFdYLev2i9RJ0COAbRV38HqAqut6/m8OgEGYAAtVWeRusBqr57Gmx/IYACt 9ePe6gKLLek4Tp0AMzCAdrryNnWBxe7jDGLYggG0EifBCm7KCVzwF1sxgFaa1Uhd YK1/P6AugEEYQBs9eIG6wFZjO6xUJ8AkDKCFWvESfjBruo9SJ8AsDKB9spbUUCfY 6YXunPYKRTGA9hnZUV1gpQUn8sFfFMcAWqfLy+oCK93Gaa9QEgNom+oLK6oTLDTp +LnqBJiIAbTNhObqAgtdMERdADMxgJbpP0BdYJ9PT+LYFyTGANplnx/UBdZZ1+MV dQKMxQBaJXNRLXWCbUaeynlfUCoG0Covd1EXWGZ550/UCTAZA2iTriPUBZZ58tyN 6gQYjQG0CFcBSc3CdhPUCTAcA2iRqburC6zCaf9QLgbQHoP7qgtsMvO4n9UJMB8D aI0jPlQX2GTQ9eoC2IABtEXVRVXUCRZZyzVDkQwG0Bbj/6EusMkPf1cXwAoMoCUG 9FcXWGVUJ3UBrMAA2qHFV+oCu9x9mboAVmAArVBhSTV1gl0uelBdACswgFYY01Zd YJlTXlIXwAoMoA363aMusM2RH6kLYAUG0ALNJqoLrHPop+oCWIEBNF/Woh3VCdbp xPUvkQwG0HwfHKUusM95j6oLYAUG0HgX3a8usNDtV6kLYAUG0HScBD+I/3ZVF8AK DKDhshbXVCfY6HuunYdkMICG+/AIdYGVVqj/38ZlG+4TFyAZDKDZLr1LXWCp7aO7 FFJm+afZP2jofrnHfx1ZAULDABptv2/VBbbq9nx0t521oZwveKj3pv8zcZ/oChAW BtBkFRZXVyfY6s0TZd+64o9NCv6VM9JYgAE02Wet1QXW0r0I+Pevttvy764fpGpA shhAg11/o7rAYrtNj/DGy/gluNCJG5d1+DzCBoSBATRXq3HqAps9fm6Ut17aAmZ+ tX+h/zS5eXRvxSAUDKCxKi/iuhZpkPwOXH9y1SL/WfhKJJLCABrrqxbqArsJTgjT 6ZXizycuTmc4BtBUt12pLrDc54dEevMV80v8o6d7lPhHK7qOjrQCaWIADcVVgNNW bXWkN198AatObJjgq34+YG2kFUgPA2im6gsqqROs98j50d5+0QVsMS4r4Vd9cEy0 FUgLA2imn/ZUF9gvv0r5n1kLzcAbSvtvuECdyRhAIw2L+IcXP9x8XbS3X/Wv324z vyz9HatVZ42MNgNpYABN1JGnTBjWRn0cUfaWVxnrTM0u46tmHrQk4g4ExgAaqM4i dYEjBg6I+Btsfhnw2HfKfhp9cljEGQiMATTQrEbqAkesy47jVcDBfcv7iqF9YshA EAygeZ4/TV3gjDuviPgbVF9Z4Yem5X7V2t7PRtyBgBhA43R/Rl3gkEolD1cO1/89 u30SXzX3sJkRdyAYBtA0jWeoC1zyfLdobz/ZE5aNOzjaDgTEABomc35ddYJTGs6N 8MYrzs1J9kufPCfCDgTGABrmzXbqArd8E+EpJXaflPjDH4msv3RYdCEIjAE0S9/B 6gLXnPhmVLd85lOpfPWCYyZF1IE0MIBG4SrooVuRE9GhMAnO/VKmr/8RTQfSwQCa pMJC9eVsHfRYz0hudtJeqf6JF06PogNpYQBNMraNusBFTX8O/zYrL6mS8p/Jv+7u 8EOQHgbQINfdpC5w0owmod9ky3GZAf7U4o5fhF6C9DCA5uAiSBEZMDDkG7zi9mB/ 7vsW5V1SHTFjAI1RdQEXQYrIzvNDvbm3Tgj6J0d2DrMD6WMAjfHN/uV/DQKZvluI N5Y1e6fgf/gGXuUwCwNoijs5cXB07r84tJuqP6NCGn96WdePQitBCBhAQxz1gbrA aQeH9frq/41I7ykzqRUXSTIJA2iGmvO4CFKUVtb5NZTbGdor3Vt4q30YHQgJA2iG KeWfVA7peO+4EG4k85vm6d/I7VelfxsICwNohEfPVRc475wn076JnBlhvE+/4szX Q7gVhIMBNEGnV9UFHkj7AyFtPwpy9HNJP7fhIknGYAANUHuxusAHufXSOwq5/4Bw OjIy3j82rFtCuhhAA8xorC7wQnoXZxvTNqwOrpVuEAZQL9XzKiGgNC6RlPNT0ud+ TsLKf70S4q0hDQygXNcR6gJvdA56wfnWY5I/93MyprXhVQ8zMIBq9RaoCzyy74+B /thld4bckfHBMWHfIgJhANVmN1QXeGTdLrmp/6HMtyN40+K+fuHfJlLHAIo9x2mC 47SgccqfCKnzXZ0IQlb1fCmCW0WqGECt059TF3jmp2Yp/oFj39gukpDphy6M5HaR EgZQqv48dYF3Pj00pS+/4/KIOjJGHx3VLSN5DKDU3J3VBf559/jkv7bi2Agv5Rbi OboQFAOoNKKrusBHb5yU7FfuNyY7wo5V578Y4a0jKQygUPdn1AV+ertdcl936R3h fPi3NNOPmBvp7aN8DKBOo1nqAl+NTeZjbVlvR/4i3YdHRf0dUA4GUGdefXWBtya1 yC/vS/YcG+aH30rB0YBqDKAMRwAKLdmvnINQLrrnbzFk8KFgNQZQpcvL6gKv/dJ+ dBn/bdY7Mf1yOvkwzg0oxQCK5CxVF/iujHPD7D+6RlwVr3eI6zshEQZQZPIe6gLv TTyylJ++Bl4X7bu/Rb/ZgPi+F0pgADXu+7e6ABkZ/34gwT/M/iSEKx8lb+mpXClY iAGUOOxjdQH+NO2kycX/0fGvxHyB0m9bl/uONCLDACpUXVRFnYDN3j5jeZH//MTZ sSe8wOEAOgygwhcHqgvwl1HnbXspsMnHgg9n511zX/zfFJsxgALX3aQuQGGfXzpu 87+59PY4Dv4rYV6HbxXfFhkMoMJ+PNxNs2T4oJUZVT9oJfr2nx8i+sZgAGOXtbim OgElzR7fPuZ3Pwp5uJfsW3uOAYzde1wPB8Ws+feT6gRPMYBxO3+YugDmmX7MTHWC nxjAmDWYoy6Aid47Tl3gJwYwZrMaqQtgpFuvURd4iQGM18PnqQtgpqVnvKdO8BED GKsjPlQXwFTfHLpeneAhBjBOlRdXVSfAWM+cqS7wEAMYp0854BWlWncZBwjEjgGM 0YWJzr4EbDH9hJ/VCd5hAOPDETAoW7LX60RoGMD4zGisLoDhbuyvLvANAxibey9W F8B0i7p+qk7wDAMYlxZfqQtgvs/aqAs8wwDGJHMp54BB+QZfqC7wCwMYk1c7qQtg gxXn/Ved4BUGMB4dR6oLYIfvjlxe/hchLAxgLCrn6k62CbsM76Eu8AkDGItPDlUX wBZr+z2mTvAIAxiHM59SF8AePx0zX53gDwYwBtVXqAtgkxdPUxf4gwGMwVct1AWw Sd7lQ9QJ3mAAo8c5EJCaacdPVyf4ggGMXJ1F6gLYZmRndYEvGMDITWymLoBt8q+7 W53gCQYwapfepS6Afaa3m6pO8AMDGDF+AUYQr3ZRF/iBAYzYD/uoC2Cj/GvuVSd4 gQGM1sU8jBHItHacHz8GDGCkai9WF8BW/+2qLvABAxipCc3VBbBV3lUcPxo9BjBK fTiiH4FNOWGmOsF9DGCEslepC2CzZ7urC9zHAEZoTFt1AWy25sKn1QnOYwCjc9Jr 6gLY7esjV6sTXMcARiZr+Q7qBFhuyAXqAtcxgJF54VR1AWy39Ky31AmOYwCj0vJL dQHsN+ZwdYHjGMCoLKyrLoADBl2vLnAbAxiRQdeqC+CCWZ0nqBOcxgBGg8/AIRwv naIucBoDGI0vDlQXwA3rLuYqmRFiACPR5WV1AVzxzTHL1QkOYwCjkLkiW50AZ9x/ sbrAYQxgFJ7uoS6AOxadMVqd4C4GMAJNp6gL4JK32qsL3MUARoDrwCFM+VdyZsCo MIDhO/05dQHcMuGYXHWCqxjA0PEOCMJ27yXqAlcxgKEb3FddANfMO/VzdYKjGMCw cSFghI/Pg0SEAQzb5werC+AeTg4dEQYwZEd9oC6Aiz47Ol+d4CQGMGTzd1IXwEnX D1IXOIkBDFffweoCuGlSu9nqBBcxgKHKXF1FnQBH8ZHgKDCAoeIQGERl7inj1AkO YgDDVHOZugDu4jrpEWAAw/TOceoCuGt5z1fUCe5hAEPUbKK6AC7jrDDhYwBDNKG5 ugAuW9fvUXWCcxjA8LQZqy6A28YcvUGd4BoGMDzTmqgL4LZfrrpPneAaBjA0HUeq C+C6ccetVic4hgEMDR+CQ+SuuVVd4BgGMCxnP6EugPsmHL9YneAWBjAsy2qqC+CB QderC9zCAIbk4nvVBfDBxJNmqhOcwgCGZEV1dQG8cPN16gKnMIDh6DNEXQA/fH/i XHWCSxjAcOTuqC6AJwYOUBe4hAEMxbl8RgkxmdBuoTrBIQxgKBbXVhfAG5wcP0QM YBjOGK4ugD++Pj5XneAOBjAMfAgEMbrqdnWBOxjAEBz/troAPvn0uPXqBGcwgCGY tJe6AD7J6/ewOsEZDGD6OBE04vXmieoCZzCA6fvkUHUB/LLyvJfUCa5gANOWs1Rd AN88301d4AoGMG0vnqIugG8WnTFaneAIBjBdFX5RF8A/Q/uoCxzBAKbrJs7OgdhN 7TxJneAGBjBdS2qpC+Cha29RF7iBAUzTER+qC+Cjj4/7VZ3gBAYwTV8cqC6Aj1b3 fk6d4AQGMD3VV6gL4KfhPdQFTmAA0/PweeoC+Gn2aePUCS5gANOzpqq6AJ7i4iBh YADT8n98JAki/2u3Up3gAAYwLV+1UBfAV2v6PKtOcAADmI6KeeoC+OuxnuoCBzCA 6eBTINCZ0oVPg6SNAUzHvPrqAnjsknvVBfZjANOw+1R1AXw2srO6wH4MYBo4ERaU FpzxkTrBegxgGjgIEFKDrlcXWI8BDK71Z+oC+O2D4zaqE2zHAAY3sqO6AH5b3OM9 dYLtGMDgVmWrC+C5gQPUBbZjAAPb71t1AXz3Vnt1ge0YwMBeOFVdAN8t6DZGnWA5 BjCw5TXUBfDe9YPUBZZjAIPa8yd1ATCqk7rAcgxgUA/1VhcAM04br06wGwMY1LQm 6gIgv98wdYLdGMCAMn9XFwBcIT1dDGBAXUeoC4CMjM9O5LzQ6WAAA3qDI7BggCVn vqNOsBoDGNCymuoCYJNrblUXWI0BDCZnqboA+NPz3dQFVmMAg7n6FnUB8KcfOk9X J9iMAQxmbBt1AfCnFee+ok6wGQMYzMpq6gKgAJ+GSwcDGEj2KnUBsNnwHuoCmzGA gZz7qLoA2OzLDovVCRZjAAN5uYu6ANiMSyOlgwEMZOYu6gJgMz4OnA4GMJA/1AHA VndeoS6wGAMYRJ1F6gJgqxdPUxdYjAEM4pzH1QXAVl90WKJOsBcDGMQz3dUFwFZz Tv9cnWAvBjCICc3VBcBWa3s/q06wFwMYRO6O6gLgL1feoS6wFwMYBG8CwyD39VMX 2IsBDIA3gWGUunwWJCgGMABOhw+jnPKSusBaDGAAt1ytLgAKufUadYG1GMAAXums LgAKeZWPpgfFAAbw9QHqAqCQb1qoC6zFAAYwd2d1AVDIvAbqAmsxgAFwOmgYZVV1 dYG1GMAAOAwQZuFpHBT3XAAMIMzC0zgo7rnUVcxTFwBFVMpXF9iKAUzdnj+pC4Ai 9pqsLrAVA5i6oz5QFwBFHD1aXWArBjB13f6jLgCK+Odz6gJbMYCp6/mIugAo4jwu 0xoQA5i6fveoC4AiLrlXXWArBjB119+oLgCKuOEmdYGtGMDU3XqVugAo4jbOTxQQ A5g6BhCGYQCDYgBTxwDCMAxgUAxg6hhAGIYBDIoBTB1vgsAwvAkSFAOYOg6DgWE4 DCYoBjB15w9TFwBF9HpYXWArBjB1p/O5I5il2/PqAlsxgKlrO0ZdABRx2CfqAlsx gKlrMk1dABSx23R1ga0YwNRV+EVdABSx/a/qAlsxgAFwSnyYhadxUNxzATCAMAtP 46C45wJYwVUIYZKVNdQF1mIAA5jDdahhkrkN1QXWYgAD+LKlugAoZPyB6gJrMYAB jOiqLgAKeekUdYG1GMAAbrpOXQAUMuh6dYG1GMAAOr2qLgAK6TxSXWAtBjCA6ivU BUAhNVaqC6zFAAbBgYAwCc/iwLjrgsjdUV0A/GVZjrrAXgxgEOP/oS4A/vIVh2UF xgAGMbivugD4y5AL1AX2YgCDaPemugD4S/u31AX2YgCDyPpNXQD8ZbsN6gJ7MYCB rMpWFwBbrK6mLrAYAxjIhObqAmCL7/ZTF1iMAQzk0XPVBcAWj/VUF1iMAQzk2HfV BcAWx72nLrAYAxgMnwWBKXgOp4E7L5iZu6gLgAKzGqsLbMYABjP8DHUBUODZ7uoC mzGAwfAiIAzBS4DpYAAD4kVAmIGncDq49wLiRUAYgZcA08IABjTsfHUBsMnDvdQF VmMAA2oyTV0AbLLbdHWB1RjAoLg6OgzANdHTwwAGNbKjugDIGNVJXWA3BjCoIz5U FwAZR36kLrAbAxhYXkV1AbyXX0ldYDkGMLDPWqsL4L3PD1EXWI4BDKzLy+oCeO/k V9QFlmMAg1vPrx/QyqusLrAdAxjcayepC+C51zuoC2zHAAa337fqAnhu/wnqAtsx gGlYmqMugNdya6kLrMcApuGh3uoCeG1oH3WB9RjANNRerC6A1+osURdYjwFMxw/7 qAvgsR/3VRfYjwFMR6dX1QXwWOeR6gL7MYBp4ZQwkOFEMCFgANNy78XqAnjrvn7q AgcwgGmpvE5dAG9VWa8ucAADmJ4xbdUF8NQnh6kLXMAApmf/b9QF8NQBfBApBAxg mqY0VRfAS1P3UBc4gQFMU7s31QXwUvu31AVOYADTtaCeugAeWriTusANDGC6zn1U XQAP9XxMXeAGBjBtHAyN2HEQdEgYwLRdf6O6AN654SZ1gSMYwLRlrq6iToBn1mVv VCc4ggFM3zU3qwvgmWtvURe4ggEMwcpq6gJ4ZRUvO4eFAQzBhQ+oC+CVix5UFziD AQxD7o7qAnhkGdeiCQ0DGIYzn1IXwCNnPa0ucAcDGIr5HJePuCyory5wCAMYimPf VRfAG8e9py5wCAMYjq8PUBfAE9+0UBe4hAEMR+MZ6gJ4YteZ6gKXMIAhGdFVXQAv vHSKusApDGBIuDoIYsGVQELFAIZlQH91ATwwcIC6wC0MYGgW1VEXwHmL66oLHMMA hqbNWHUBnHfop+oCxzCA4XnnOHUBHPfu8eoC1zCA4am6Rl0Ax+2wVl3gGgYwRJwV BpHiLDChYwDD9PNu6gI4bNru6gL3MIBh2vMndQEcttdkdYF7GMBQPXiBugDOGnyh usBBDGC4FnKcFqKxqJ66wEUMYLj2+1ZdAEftP0Fd4CIGMGSPnqsugJMe66kucBID GLYltdQFcNDS2uoCNzGAYWv5pboADjpwvLrATQxg6Ib2UhfAOcN6qwscxQCGb04D dQEcM7ehusBVDGD4OD0+QsZp8KPCAEbgsjvVBXDK5XepC5zFAEaBa8QhRFwHLjoM YBSqL6yoToAz8uutVCe4iwGMRMeR6gI4o9ModYHDGMBoPHG2ugCOePIcdYHLGMCI zGisLoATZu6qLnAaAxiRegvUBXDCTgvVBU5jAKNy6gvqAjjgtBfVBW5jACPz/Gnq AljvhdPVBY5jAKMzq5G6AJabvYu6wHUMYHRqz+ZoQKQjv9ESdYLrGMAIHfOeugBW O/Z9dYHzGMAoDbpWXQCL3XydusB9DGCkPmutLoC1Pj9EXeABBjBSFRbsqE6ApZbt 9Ks6wQMMYLR2n6ougKWa/qwu8AEDGLEuL6sLYKWTX1EXeIEBjNotV6sLYKFbr1EX +IEBjNwHR6kLYJ3RR6sLPMEARi5z9s7qBFhmXqON6gRPMIDRy5lTSZ0Aq+Q1zFUn +IIBjMFB/1MXwCoHj1MXeIMBjMOZT6kLYJGznlYX+IMBjMUdl6sLYI07r1AXeIQB jMcb7dUFsMSbJ6oLfMIAxuSnPdUFsMLkvdQFXmEAY1J5bk11AiywvMF6dYJXGMC4 NJjK6VFRnvymc9UJfmEAY9PyS3UBjHfgeHWBZxjA+HBeBJSDMyDEjQGM0cX3qgtg tH73qQu8wwDG6YEL1QUw2IMXqQv8wwDG6rWT1AUw1usd1AUeYgDj9VULdQEM9fU/ 1AU+YgDjlTW5iToBRpq+5wZ1go8YwJhVnlFHnQADLd6VA6AVGMC41ZyZrU6AcVY3 Xq5O8BMDGLtGk/lICIrK33O2OsFTDGD89vtWXQDD7D9BXeArBlDgiA/VBTDKkR+p C7zFACp0HKkugEE6jVIX+IsBlDhjuLoAxuj+rLrAYwygRp8h6gIYou9D6gKfMYAi 19ysLoARrr1FXeA1BlDltivVBTDA7VepC/zGAMoM7qsugNyQC9QFnmMAdR4/R10A sSf+pS7wHQMo9Ow/1QWQ+s8Z6gLvMYBKL3dRF0DolZPVBWAApd5spy6AzFvt1QVg AMVGH6kugMiHR6kLwADKfXKougASn/IXbwIGUI0F9BL7ZwYGUI4F9BD7ZwgGUI8F 9A77ZwoG0AAsoGfYP2MwgCZgAb3C/pmDATQCC+gR9s8gDKAZWEBvsH8mYQAN8QGH xfph9NHqAhTCAJqCBfQC+2cWBtAYfC7YA3z+1zAMoDleO0ldgIi93kFdgKIYQIO8 eIq6AJEacaq6AMUwgCZ56kx1ASL09FnqAhTHABrlod7qAkRmaB91AUpgAM1y16Xq AkTk7svUBSiJATTMwBvUBYjEjf3VBUiAATTNlbepCxCBq25XFyARBtA4fYaoCxC6 vg+pC5AQA2iebv9RFyBk/3xOXYDEGEADnfSaugCh6vC6ugClYABNdMSH6gKE6MiP 1AUoDQNopJZfqgsQmgPHqwtQKgbQTM2+qqROQCjyOy+uklE1s+J2W//B+t8zfsvL 2LA+I+/XX/M2rFW2gQGM1D6tD9ijYa0d1Bmw2Nqlc6Z8/fmP6gxXMYCRyDmy9d93 rVVZnQFnrF868/vPPsxVZziHAQxZVttjD2xaX10BR82f+uV7n2xQVziEAQxRw38e u0+OOgLOy/3xvedmqyMcwQCGpPr5XZvxvgXikjfppYdXqiMcwACG4eB/H1ZX3QDv LB5z3//UDbZjANNW96YuNdUN8NTyV25YqG6wGgOYnsxLz2+iboDXpj9890Z1g70Y wHTUvIdz2EPvmX7L1Qm2YgCDqz6Ma9zADCPO5x2RQBjAoDIHc/0OmGNYX34RDoAB DKjHA9XUCUAhqy98Rp1gIQYwkBpvt1InAMV80Y6XAlPFAAZxOif4hYm6Pa8usA0D GMAQLvAKM3Ht4RQxgCmrOOZAdQJQivFt89UJVmEAU9X0M853AHPltpmiTrAJA5ii Qz9RFwBlOoyHaPIYwNSwfzAeC5g8BjAl7B8s0HasusAaDGAq2D9YgQVMFgOYgmYT 1QVAUvaepC6wBAOYvO581Ai26DFcXWAHBjBpWb+pC4Ckbcelk5LBACZtGmc+hT1m 8HBNBgOYrIE3qAuAFNzEAzYJDGCSGs1SFwAp2YVLZ5aPAUzSPC52Drss4CFbPgYw ObdcrS4AUnQbD9pyMYBJ2WOyugBI2V48bMvDACZl5i7qAiBls3dRFxiPAUzGWU+q C4AAzuGBWw4GMAmZv6sLgED+xqXiysYAJuGRnuoCIJDHeOiWjQEs34656gIgoJxl 6gKzMYDlm9BcXQAE9D0P3jIxgOXadbq6AAhsNx6+ZWEAyzV/J3UBENhCHr5lYQDL 0+lVdQGQhs4j1QUmYwDLwSEwsByHwpSBASxH/wHqAiAtAwaqCwzGAJaN00DDepwc unQMYNk4Cwysx1lhSscAlilz5Q7qBCBNa6vxKmBpGMAy9R2sLgDSdiEP49IwgGWa uru6AEjbNB7GpWEAy9J0iroACMEeU9UFpmIAy/J0D3UBEILhPJBLwQCW5Q91ABAK nuel4I4pwzvHqQuAULx7vLrAUAxgGVZlqwuAUKyupi4wFANYBn4Dhit4oifG/VK6 6ivUBUBIavJgTogBLN1nrdUFQEj+x4M5IQawdPwGDHfwTE+Iu6V0DCDcwTM9Ie6W Uu2wWl0AhCZ7jbrASAxgqUZ2VBcAoXmNh3MiDGCpFtRTFwChWcTDOREGsFS8BAiX 8FRPhHulVAwgXMJTPRHuldI0nqEuAEK060x1gYkYwNKMaasuAEI0lgd0AgxgaZbX UBcAIVrJAzoBBrA0vAQIt/BcT4A7pTQMINzCcz0B7pRSZK9SFwChqsZHm0piAEvx NqfQhVs4K3QCDGApcndUFwChWpajLjAQA1gKXgKEa3iyl8R9UgoGEK7hyV4S90li mb+rC4CQ/W2jusA8DGBiQ3upC4CQPcyDugQGMLGJzdQFQMh+4kFdAgOYGC8Bwj08 20vgLkmMAYR7eLaXwF2SEO+BwEG8C1ICA5jQwZ+rC4DQHcLDujgGMKH3j1YXAKEb zcO6OAYwoXn11QVA6ObvrC4wDgOYEO+BwEU83YvjHkmIAYSLeLoXxz2SyK7T1QVA BJpwpa9iGMBEeg1VFwAR6MMDuxgGMJGvD1AXABH4lgd2MQxgIks5dSRcxDlRi2MA E+E9ELiJ53sx3CGJLKmlLgAikMsDuxgGMBF+AoSbeL4Xwx2SCAMIN/F8L4Y7JBEG EG7i+V4Md0gCt12pLgAicecV6gLDMIAJjOqgLgAi8ToP7aIYwAS+31ddAETiRx7a RTGACXAcNBzFkdDFMIAJ8B4IXMUTvijujwQYQLiKJ3xR3B8JMIBwFU/4org/Srr5 GnUBEJFbeXAXwQCWNKKrugCIyH95cBfBAJY0rpW6AIjIlzy4i2AAS5rdUF0ARGQu D+4iGMCSeA8E7uIZXwR3R0kMINzFM74I7o6SGEC4i2d8EdwdJfQdrC4AInMhD+/C GMASHrhQXQBEZjAP78IYwBLeaK8uACLzFg/vwhjAEr7ZX10AROa7/dQFRmEAS5hX X10ARGYBD+/CGMASeBMYLuMpXxj3RgkMIFzGU74w7o0SGEC4jKd8YdwbxZ0/TF0A RKg3D/BCGMDi7rpUXQBE6N5L1AUmYQCLe7mLugCI0MjO6gKTMIDFffd3dQEQIa6M WRgDWNzi2uoCIEJLeYAXwgAWx5vAcBvP+UK4M4pjAOE2nvOFcGcUxwDCbTznC+HO KI4BhNt4zhfCnVHMgP7qAiBSN/IQ34YBLGZUB3UBEKk3TlIXGIQBLOaHfdQFQKQm 8hDfhgEshsMA4TgOBCyEASyG90DgOp7023BfFMMAwnU86bfhviiGAYTreNJvw31R DAMI1/Gk34b7ohgGEK7jSb8N90VRF92vLgAidjEP8r8wgEUN7aUuACL2yPnqAnMw gEW9f7S6AIjYaB7kf2EAi5rSVF0AROxnHuR/YQCL4j0QuI9n/V+4K4piAOE+nvV/ 4a4oigGE+3jW/4W7ooh+96gLgMhdysN8KwawiEd6qguAyD3Gw3wrBrCoW5ruUr+u OgKIzKIFs6ZerY4wBwOYSI+9m+6ynzoCCNV3s6dMfFodYRoGsAxnN2vaqLk6AkjT 97OnTnxSHWEoBrB8ZzVr2nCnOuoKIEWLF875meUrGwOYvJt3b7TTzuoIoFzzFs7+ +Rp1hB0YwJRd2bRxfT5LBBP9PH/m1NvUEVZhAIM6Z89dG9RtqK4ANpm7aO6MyY+r K2zEAKarT9PGDWrXV1fASwsWz58xdYi6wmYMYFh679aofp3G6gp4Ydbi+bOnM3wh YABDd1XjnevV4s0ShG/+0k2/6vIaX5gYwOhc27B+3ZxG6gpYb/ayRfNn36yucBMD GIPzGm36mbAmb5ggFXOXL104f9bD6gzHMYCxOrvRTvVq16xWS90BQ+WuWr5k4fw5 T6g7vMEAqvRqUKd2To3sndQdkFu4amXukkXzhqo7fMQAmqDPTnVq1ai5A68X+mPO 6hUrlixe8JC6w3cMoHEuqpuTs2P2DlX59LFbFq9bvXp57tLFXJTXJAyg4frk5NSo UX2HqlXYQ9ssXr929aoVK3KX8mOeuRhAy/TbsUb1atlVq1SutKM6BUUsy8tbt2nx Vi5fdq86BUljAK13SY3s6tk7VKlSsdL2vLscl9z8/Lz1a9euWrV6OdfXsBkD6KSL qmVv2sTKlSpX3H77CsxiOpb+9sufY5e3bs3qVat5/c41DKBXLq5atXLlqpUqVto0 jNtvVyGrhjrIECt/++3XX375c+ny1q3LW7uWX2J9wQBii95VKleuXGn7SttvX7HC Jtttl5WVVV0dFZKVG37/bdPGbfJLfsEPdOvXr+OwOzCASMX5m36nrlhh02/V2236 3+22z/rbdtv9LSvrb5nbZWqWcuXGDb//vmHDxl9/+33DL5sW7pfffs3/5dc/B45P kCEpDCCi8+/MSn+rmFGp4H8y/sjY9nDb/K+ZBf/mr/8t/mDMz8gr+J/83/M28uIb IsEAAvAWAwjAWwwgAG8xgAC8xQAC8BYDCMBbDCAAbzGAALzFAALwFgMIwFsMIABv MYAAvMUAAvAWAwjAWwwgAG8xgAC8xQAC8BYDCMBbDCAAbzGAALzFAALwFgMIwFsM IABvMYAAvMUAAvAWAwjAWwwgAG8xgAC8xQAC8BYDCMBbDCAAbzGAALzFAALwFgMI wFsMIABvMYAAvMUAAvAWAwjAWwwgAG8xgAC8xQAC8BYDCMBbDCAAbzGAALzFAALw FgMIwFsMIABvMYAAvMUAAvAWAwjAWwwgAG8xgAC8xQAC8BYDCMBbDCAAbzGAALzF AALwFgMIwFsMIABvMYAAvMUAAvAWAwjAWwwgAG8xgAC8xQAC8BYDCMBbDCAAbzGA ALzFAALwFgMIwFsMIABvMYAAvMUAAvAWAwjAWwwgAG8xgAC8xQAC8BYDCMBbDCAA bzGAALzFAALwFgMIwFsMIABvMYAAvMUAAvAWAwjAWwwgAG8xgAC8xQAC8BYDCMBb DCAAbzGAALzFAALwFgMIwFsMIABvMYAAvMUAAvAWAwjAWwwgAG8xgAC8xQAC8BYD CMBbDCAAbzGAALzFAALwFgMIwFsMIABvMYAAvMUAAvAWAwjAWwwgAG8xgAC8xQAC 8BYDCMBbDCAAbzGAALzFAALwFgMIwFsMIABvMYAAvMUAAvAWAwjAWwwgAG8xgAC8 xQAC8BYDCMBbDCAAb/1/jtkupgjlrUMAAAAASUVORK5CYII="/></symbol><g mask="url(#b)"><g transform="rotate(.193) scale(.36014)"><symbol id="c" viewBox="0 0 1280 1280"><image width="1280" height="1280" xlink:href="data:image/png;base64, iVBORw0KGgoAAAANSUhEUgAABQAAAAUACAIAAACXhmigAAAACXBIWXMAAA7EAAAO xAGVKw4bAAD1TUlEQVR4nOzdiX9bxbn/cVvW7iPJ2UjSha2hXC4QoKUEKC1roXAD bVhLW7h/84+GLXu8L9qls2+/kQS5iePYss/M0ZHO5/1KjUnsZyaWqPX1zDwzPwcA AAAAQArMT3oCAAAAAADEgQAMAAAAAEgFAjAAAAAAIBUIwAAAAACAVCAAAwAAAABS gQAMAAAAAEgFAjAAAAAAIBUIwAAAAACAVCAAAwAAAABSgQAMAAAAAEgFAjAAAAAA IBUIwAAAAACAVCAAAwAAAABSgQAMAAAAAEgFAjAAAAAAIBUIwAAAAACAVCAAAwAA AABSgQAMAAAAAEgFAjAAAAAAIBUIwAAAAACAVCAAAwAAAABSgQAMAAAAAEgFAjAA AAAAIBUIwAAAAACAVCAAAwAAAABSgQAMAAAAAEgFAjAAAAAAIBUIwAAAAACAVCAA AwAAAABSgQAMAAAAAEgFAjAAAAAAIBUIwAAAAACAVCAAAwAAAABSgQAMAAAAAEgF AjAAAAAAIBUIwAAAAACAVCAAAwAAAABSgQAMAAAAAEgFAjAAAAAAIBUIwAAAAACA VCAAAwAAAABSgQAMAAAAAEgFAjAAAAAAIBUIwAAAAACAVCAAAwAAAABSgQAMAAAA AEgFAjAAAAAAIBUIwAAAAACAVCAAAwAAAABSgQAMAAAAAEgFAjAAAAAAIBUIwAAA AACAVCAAAwAAAABSgQAMAAAAAEgFAjAAAAAAIBUIwAAAAACAVCAAAwAAAABSgQAM AAAAAEgFAjAAAAAAIBUIwAAAAACAVCAAAwAAAABSgQAMAAAAAEgFAjAAAAAAIBUI wAAAAACAVCAAAwAAAABSgQAMAAAAAEgFAjAAAAAAIBUIwAAAAACAVCAAAwAAAABS gQAMAAAAAEgFAjAAAAAAIBUIwAAAAACAVCAAAwAAAABSgQAMAAAAAEgFAjAAAAAA IBUIwAAAAACAVCAAAwAAAABSgQAMAAAAAEgFAjAAAAAAIBUIwAAAAACAVCAAAwAA AABSgQAMAAAAAEgFAjAAAJFomjb4x/z8/F1vj1IoDMO73oo3/X5f2iwBAAABGACA wxok3jtxd2RuLrOwIP6ZyWRGb49QNggCEX5/euv74TALD+Lwz5GYPAwAQEQEYAAA DrAr8YqMK+KuSLkLw9CrdGgRfn3fF6lYROKAPAwAQDQEYAAA9nB36M0MZbPZ0QLv BGc1WiL2PC8YIgwDAHAoBGAAAP7PT7n352VeEXoXFhYmPakH8n1/EIbvWhwmCQMA sA8CMAAAd+Xe4cbmfD4/6RkdmuM4o83SJGEAAB6EAAwASK+7c2+hUDha86qkERnY tm2SMAAA9yMAAwBSZ3Rx0fzPm5xzudykZ6SE67qjDdIhlyoBADBEAAYApMhoyTcz Pz9IvbncZDtaxUOk30ESdt2ABWEAQOrN/jd+AABGS74i+maH53szCe5rpU7g+47j eL4/x4IwACCtCMAAgFl2Z7fzaMl3Nk75RhEEwWhBmH3RAIAUIgADAGaWSL8i8Yrc m03HbufxifQrMrAg8jAZGACQHrwaAADMoEH0He52zmazIuyRfu83+rJ4nuc4TuD7 xGAAQBrwggAAMGuqtdqdO42IvvsbbYQe3ZzU7XQmPR0AANTiZQEAYHZUq9VcLreQ zXLW97BEBva9wbbobrc76bkAAKAKARgAMAsqlUpuuOF5fmjS05lK4ZAnYrDj9Hq9 SU8HAAD5eIkAAJhumoi+IvgOOzwTfaMTGTgIgsFasOf1icEAgNnCCwUAwBSrLS0N 7vUl+so2isGO43Ta7UnPBQAAaXi5AACYSnf2PHPcV53BUjA7ogEAM4QADACYMpqm LQy2PA82Pk96LqngDZtj+Z7HVUkAgGlHAAYATBMWfieCpWAAwGwgAAMApsNPC7/D fleTnktKjTpjsRQMAJheBGAAwBSoVCqDTc/DVs+TnkuqBUEwSMGuy1IwAGAaEYAB AElXrdWG4ZeF36Rwh7qdzqQnAgDA4RCAAQDJpVUq2YWFXD6/sLAw6bngHoNLkmzb 833uCgYATBECMAAgoQbbnrPZfKEwPz8fhiE3/SbH6OEQbwcZ2PPYDg0AmBa8mAAA JI6mafOZTC6Xy+fzk54LDuA4juu6YRDQGQsAkHwEYABAsoj0m1lYyA/vOpr0XDAW z/NEDA58nwwMAEg4AjAAIEFGdx3lp/PQbxiGIrRrlcqpU6eKpdIz58+P+Yn/+X// r76z0263LcsKg2AaO137vi8yMDckAQASjgAMAEgKbXToN58XCXAqDv0GQVAsFmtL S6fPnBk/7u4i/qYbGxu2bd/9myu3b3fabcMwPNdN/s8CRg/WoC2W43giA3MkGACQ VEl/bQEASAmRfnO5XKFQmPREDjAKvQ+dPn3ut789c/ZsxGoiOt64fj2zb8Rtt1qb 6+vdbtf3vOQvDosk77ouGRgAkEwEYADA5In0m8/l8glOvyL3ikk+8+yzj587J6um CIpbW1vi7fifsrWxsbq8LEJmkpeFHdt2yMAAgEQiAAMAJqwi0m+hkMvlJj2RPajI vaOyzWYzyu1BCU/CItWLGMz1SACApCEAAwAmSaTfQqGQTVj6He1z/u1//deRT/Y+ SBiG/X5fpF8xhJSCK7dvb6yvJ3B3tOe6NhkYAJAwBGAAwMQM0m+xmKjrjkQuPX3m zEuvvCLmJr2467rb29uO40ivbJrm9StXup1OohaEPc+zLYsMDABIDgIwAGAyRMIs lkqJCmznnnjixQsXVFQWubrVanW7XRXF7yZi8PbWVnJWg8nAAIBEIQADACYgaen3 mfPnpe92vkPX9Uaj4fu+ovr3W7l9e3V5OSExmAwMAEgOAjAAIG4i/ZbK5YTEM6XR 13VdEX1N01RUf3/JicEi/FumSQYGAEwcARgAECtNpN9krP0qjb5hGHY6nXa7Ld5R NMSYEhKDRQY2TZO7kQAAk0UABgDER9O0Uder+fmJfQMKguC3Tz6p6KzviG3bOzs7 h7rgV7XrV65sbW5O8OcOYRiO9kL3+/1JzQEAAAIwACAmSUi/taWl115/XUWH55HY ml0dgWEY31++7E0ulpOBAQATRwAGAMTk2PHj+Xx+gun3jbffPnP2rLr6ImE2Gg2R 8dQNEZHI55tra7du3pzUUrDIwI7jtJrNiYwOAAABGACgnKZp2VyuUChMJP2OrvZ9 +9131Q3h+36z2ZyKhU3XcUzDuH7tmmWaEzkYLDKwbdue607FlwsAMGMIwAAAtUT6 FUGrVC5Pau1X9cKvCHKNRkPEbHVDyGXquuu6vV7v9oSWgkUGFiFcfMXIwACAmBGA AQBqTfDSo1MPPaR64VdEX13X1Q2hQiiSZ683ak99/do1x7bjn4NIvyIDczESACBm BGAAgEKaphVLpWw2G/O4It1deOWVx8+dUzeEYRj1el1kYHVDqOO5rvFzbm82Gutr a/EvBXueZ5kmi8AAgDgRgAEAqoj0my8U8vl8zOOKLPfXixeVtnpuNpvTvnppGobr OKP3bdu+duVK/Kv0jmDbZGAAQGwIwAAAJUT6XchmS6VSzOOq3vZsWdbOzk6SWz2P KQzDwUbou44uT2Q7tGmavueRgQEA8SAAAwDkGzW+KpZKcS4qBkFw/vnnnzl/XlF9 kRhbrVan01FUP34ixhv3Js+tzc36zk7Mj5plmjTEAgDEgwAMAJCvUqkUisU4j/6K BPXyq6+qO/QrsuL29rY9iX5RSonwuWvVN/4jweJra1vWtG8pBwBMBQIwAEAyrVLJ DW/9jW3EMAwv/v3v6g796rper9en6KKj8Ykvnd7r7fqriZx/9ccf48zAYkTXdftk YACAYgRgAIBMg83PCwulUim2W3+Vpl9RvNlsdrtdFcUT4v6N0HOxZ+DBzcCmGfg+ G6EBAEoRgAEAMlWq1WKxGFtwyufzH3/+uaLirutub287P7dKnmGWYez51/zu229j e6Hg+75lWb2Z/lkDAGDiCMAAAGm0SiU/FIZhDCvAStOvrus7OzviL6KofqLc3xH6 jngy8OgJ4wyxERoAoA4BGAAgR8z3HqlLv7PX7Xkcnusaur7nH8W5DsytSAAApQjA AAA5KtVqoVCIp/OzuvQbBMH29raIYSqKJ5yp667r7vlHsWXgQUdo22YjNABAEQIw AECCODs/LywsfPbllyoqi/i3ubkpMpiK4skXBsFgI/QDdn1/+5//xHM/MB2hAQDq EIABABLUarViLJ2f1fV8tixLpN+UHPp9ENdxTMPY849i6wstHgLLNNO2BR0AEA8C MAAgqsqw91Uun1c9kLr02+v16vW69LLTyOj3H7QGHlsGdofdsHosAgMAZCMAAwAi 0TQtm8sVi0XVAwVB8NZf/nLm7Fm5ZUWobg/JLTu9BpfxPjh5ilC6fOtWDHuhLcvy XJduWAAAuQjAAIBIqtVqXn3vK5F+X3711cfPnZNbVqTfRqPBSuMutmWJXw/602aj sbG+rjoDe57n2HaXblgAAKkIwACAo7vT+0r1xb+/+vWvX3v9dbk1xZzr9TprjPcT Xxm91wv2uhZ45NbNmw86KixrAuLpRDcsAIB0BGAAwNFVazWRflUfCi0vLn506ZLc miJi7ezs6A+4+RYieZr7fnF++O471Q3DfN8XGbhLNywAgDwEYADAEWnD3ld5xb2v RMr68quvpNdk7fdAer/v73sj1OVvvlH9s49hMyyHRWAAgCwEYADAEdWWlgqFgtKz oEEQfHjpkty2zyL9NptNDpceyPd9fd/kadv2tStXVD8BxCgdWpQBACQhAAMAjkKr VArqrz4698QTL164ILdmu91utVpya84qyzAcx9nnA9ZWVlT/KMF1HJtFYACAJARg AMBRxLD8q+Lor2EYW1tbcmvOsCAIBslz37O+qg8DswgMAJCIAAwAOLTB8m+hkMvl 1A2hYvOz4zjr6+uqWzfNmP2vRJobboS++uOPSg8Du64rRmERGAAQHQEYAHBoS0tL ecXLv8+cPy9+SSzo+/7a2pp4K7FmGoRh2O929/+pwdbmZrPRUDeHIAgc226zCAwA iIwADAA4nBiWf6Vvfhb5bWtryzRNiTXTQ4RP66AvneqN0CwCAwCkIAADAA6nVqvl Vd79q2LzM42vohDJVu/1xOOyz8eo3gjt+77I4R3uBAYAREMABgAcgqZphWJR6fKv 9M7PlmVtbGxILJhCruOYhrH/x6juCD1YBLYsbm8GAERBAAYAHEK1ViuoXP4V/vHv f0usFgTB2tqa53kSa6bQOIvAwuVvvlG6CGzbdpdFYABABARgAMAhHD9xIpfLzc+r +vbxxttvnzl7VmLBRqOh+qLalBhnEbjX660uLyuagAjhrusq7bYFAJh5BGAAwLgq lUqxVFK3xFdbWnr/4kWJBdn8LNGYi8BXfvzRV7be7vu+ZZo9WmEBAI6KAAwAGNfS sWP5fF7R7UfSe1+x+Vm6cdpB27Z97coVdU8Sx3Ha9DMDABwVARgAMBZN04qlUjab VVRf+vJvq9Xi5li5xrkTeE7xIrDneSKE0woLAHA0BGAAwFiqtVqxWJyW5V/XdVdX V2VVwx22ZYlfB3yM4kVgy7JohQUAOBoCMABgLErbX0lf/t3c3DQP2qyLIxD5sz9G UzF1i8C0wgIAREEABgAcTKtUSsraX0lf/tV1fXt7W1Y17GIahus4+3+M0kVg3/dN 0+zTCgsAcHgEYADAwWq1WkHZ/me5y79hGK6trbmuK6sgdvE9Tx/jCK66ReAgCGzL 6rALGgBweARgAMDBTpw8mc1mVex/lr782+12G+yPVazf6wW+v//HqFsEDsPQ87xG vS69MgBg5hGAAQAH0CqVcrmsaPk3n89//PnnsqqJOL26uuoflM0Q0Tj3IQnfffut otcZ4oE2DINd0ACAwyIAAwAOUFtaKhaLitpfvfH222fOnpVVrd1ut7gkVr0wDHtj 7EDu9Xqry8uKJmBZVodrrgAAh0QABgAc4MSJE1ll/Z//8e9/yyoVBMHKyop4K6sg 9mHoujfGQevL33yjonfaYBe067LXHQBwWARgAMB+NE0rLy4q2v987oknXrxwQVa1 TqfTbDZlVcP+XNc1df3AD1tbWemOcW3SEQx2Qet6f4x2XAAA3EEABgDsp1qrlUol Re2v/vn117KqhWG4srLC6d/YDHZBi2Qbhgd+5Lf/+Y+iVlimaXbpBQ0AOAwCMABg P8eOH8/n8yoCcHlx8aNLl2RV6/V6ddoCx2ucC4GFH777LhwjJx+WqOk4Tos1fwDA YRCAAQAPpGlaqVxWcYZTeOnllx8/d05WtbW1NWeMMAaJxtwF3Ww0tjY3VUzA930R wtkFDQAYHwEYALA3kX7n5ucXFxeTv//ZsqyNjQ1Z1TCmMXtBz6lshaWLBB6GZGAA wJgIwACAvYkAnFlYUHQAWO7+5+3tbX2MpUhIZ/T7nucd+GHqdkGbphn4PgEYADAm AjAAYG8iAOfyeUUHgCXufxYBbGVlRUopHJZj25ZpHvhhinZBj44Bu45DAAYAjIkA DADYm7oDwHL3P7fb7VarJasaDmWw+trrjfORinZBcwwYAHAoBGAAwN60SmVwDFgB ufufV1dXXdeVVQ2H1et0xtnerGgXtCDS75ghHAAAAjAAYA+jA8DlcllF8XNPPPHi hQtSStm2vb6+LqUUjsbU9XF+ALG2stLtdlVMwDAMjgEDAMZEAAYA7EEE4GwuVywW VRT/x7//LatUo9FQFKswpjGPAQvff/utiglYluW5LgEYADAOAjAAYA8iABeKxVwu p6K4rAAchuHKyorv+1Kq4WjE11+f6DFg13VtyyIAAwDGQQAGAOxBBGCtUlFRuba0 9P7Fi1JKcf1vEox/G/CVH3/0x7gz6Qj6vR4BGAAwDgIwAGA3EX7n5+cX1XTAeub8 efFLSqlms9kZL3pBKb3XG2cdfmtzs9loKJlAvy9yOBkYAHAgAjAAYLdBB6xMpry4 qKK4xAPAKysrnpoVRRyKZZqObY/zkYqOARu6HgQBARgAcCACMABgNxGAF7LZUqkk vXIYhl9+9ZWUUq7rrq6uSimFiMbvg6XoGLBpmr7nEYABAAciAAMAdht0wCoUcvm8 9Mr5fP7jzz+XUqrb7TbU7KfFYXmeZ4wXPr/79lsVrzxcR2RwmwAMADgQARgAsJsI wMVSKZvNSq986qGH3n73XSmltra2DMOQUgoRjd8H6/q1a2Nulj4UkcAt0yQAAwAO RAAGAOwmAvDisA+W9MqyOmCJxLW8vBwEQfRSkEIEYPGgHPhhivpgiaH1fp8ADAA4 EAEYALCbVqloalpA/8/f/laRcbuS4zhra2vR60CWMRtB27Z949o1FRMYxN/xriMG AKQZARgAcI/BHUiZzKKCFtBBEPzz66+llOr1evV6XUopSGHouue643zkt//5TyaT kT4BXddDGkEDAA5CAAYA3GMq7kDa2dkh6iTK+DchKWoEzU1IAIBxEIABAPdQdweS xBbQq6ur7njrjYjH+DchKWoEzU1IAIBxEIABAPfQKpVsNlssFqVXri0tvX/xYvQ6 YRjeunUreh1I5DqOOV5T7is//iiSqvQJWJbliQDMMWAAwL4IwACAe2ialhcKBemV Zd2BZNv2+vp69DqQaPyrgBXdhCRqOo7DCjAAYH8EYADAPbRKpVgsqrgEWNYdSCLk 7OzsRK8DiXzf18dbfVV0E9LgKmDLYgUYALA/AjAA4B4iABcKhVwuJ72yrADcbDY7 nU70OpAoDIJetzvORyoKwK7r2rZNAAYA7I8ADAC4hwjApWJxQcEK8Btvv33m7Nno dba3t3Vdj14HEoVh2BvvpxK9Xm91eVn6BHzPM1kBBgAchAAMALiHCMCapqmoLOsO pPX1dVvBIVJE1BUBOAzH+cjvv/1WxQT6AgEYALAvAjAA4B7JD8DLy8u+70spBYl6 nU5IAAYAJBsBGABwj4QHYO5ASqx+txsEwTgfSQAGAEwKARgAcI+EB2DP81ZWVqLX gXQifAbjrcwTgAEAk0IABgDcI+EB2HGctbW16HUgnd7rjbk1nQAMAJgUAjAA4B4J D8CWZW1sbESvA+n0ft/3vHE+kgAMAJgUAjAA4B4JD8CGYWxtbUWvA+kIwACA5CMA AwDukfAArOv69vZ29DqQjgAMAEg+AjAA4B4JD8Ai4+zs7ESvA+kIwACA5CMAAwDu QQDG0RCAAQDJRwAGANwj4QG41+vV6/XodSAdXaABAMlHAAYA3EME4MXFxfl5+d8g vvjXv6KXZQU4scYMwGEY/vDdd9JHF2V1XScAAwD2RwAGANxDBOBisZjNZqVXfv2t t87+4hcRi9AFOrFE+AzGCMC9bnd1ZUX66J7nWZZFAAYA7I8ADAC4hwjAhUIhl8tJ r/zM+fPiV8Qipmlubm5KmQ/k6ne7QRAc+GHi4Ws1GtJHd13Xtm0CMABgfwRgAMA9 1K0AP/3ss88+91zEIiLkrK+vS5kP5Op1OmEYHvhhmxsbrWZT+uisAAMAxkEABgDc Q9O0XD5fKBSkVz556tQ7770XsYjruqurq1LmA7m67fY4H3b96lXHcaSPbtu26zj9 fl96ZQDALCEAAwDuoVUq2Wy2WCxKr1yr1d7/8MOIRcIwvHXrlozpQCbxuPQ6nXE+ 8soPP4zZLPpQLMvyPI8VYADA/gjAAIB7aJq2kM2WSiXplfP5/Meffx69zu3bt8c5 a4o4hUHQ63bH+cjvLl9W0WPcNE1fBGBWgAEA+yIAAwDuIQJwJpMpLy6qKC7lKuDV 1VXXdaPXgUS+7+vjrb5e/uabhYUF6RMwdD0IAgIwAGB/BGAAwD1EAJ7PZBYVBGCR T7786qvoq39bW1uGYUiZEmTxPM8YI3yGYfjd5cuZTEb6BHRdDwnAAICDEIABALtp lYqIwSoqv3/xYm1pKWKRVqvVHq/fEmLjuq6p6wd+mGWaN2/cUDEBEX05AAwAOBAB GACwm0i/i5qm4qDmU08//dwLL0QsIpLOzs6OlPlAFse2Rbg98MM21tfbrZb00cMw 1AcJmOVfAMABCMAAgN1EAC6WSiquAj5x8uRf/vrXiEW4CjiBRPoVGfjAD7t29aqr 4A6kwSXApkkABgAciAAMANhNq1TyQ9IrZ3O5T7/4ImKRMAxv374t3kqZEqQwDWOc ZKuoBbQzxBZoAMCBCMAAgN3U3YQUBME/v/46ep319XV7jPVGxEbv933PO/DDFLWA 5g4kAMCYCMAAgN2U3oT0yRdf5HK5iEUajUZ3vFtnEY9+t3vg5cy+71/54QcVo3MH EgBgTARgAMBu2rAD1qKaRtBPPvXUC7//fcQiuq5vb29LmQ+iC8Ow1+kc+GEba2uK 2nfr/b6YAwEYAHAgAjAAYA/qGkFrlcrFv/0tYhHf95eXl6XMB9ENVl/HWJD/8Ycf At+XPjotoAEA4yMAAwD2IAJwvlBQ0QdLxJUvv/oqep21tTVHQT9hHIHnecYY+fM/ 33yTVXAAeND/yrYJwACAcRCAAQB7EAE4m8sVi0UVxf/+6afRK3MMODnGuQRYhOSr P/6oYnTLsjzXJQADAMZBAAYA7GHQB2thoVwuqyj+60ce+eOf/hSxiGEYW1tbUuaD iMa5BPj2rVuGrqsYXTwTAt8nAAMAxkEABgDsTatUFhcXVRwDLhQKlz77LGIRbgNO DqPf9w66A+n7b79VMfTgALCucwMwAGBMBGAAwN40TSuWStlsVnrlwPc//+c/s5Ev Q9re3tbVLCriUHrdbrjvHUi+7//w7bcZBQeARfC2TJPlXwDAmAjAAIC9iQCcy+Xy hYKKReBnzp8XvyIWEbFnZ2dHynxwZOPcgbS1udlsNFQM7di2ywFgAMDYCMAAgL0N jgFnMqVyWUUAzufzH3/+ecQiQRAsLy+zC3qyxmkB/d3lyyqeReKhNw1jcAkTARgA MB4CMABgbyIAz83PKzoGLELLZ19+mWMX9PQ7sAX0YP/zd99lMhnpQ48OAIt/EIAB AGMiAAMA9nPy1KmFhQUVGfjpZ5999rnnIhahF/TEmYbh7nsh8+bGRqvZlD6uSL8i WtfZAw8AOAwCMABgP0vHjhXUHAPO5nKffvFFxCIiBS0vLwf7dmCCUv1ud/+v/7eX L2fU7H+2bbvdakmvDACYYQRgAMB+KtVqWc0xYBFg/vbxx+XFxYh1Go1Gt9uVMiUc 1oEdsBzHuXbliqLnj2EYPR56AMBhEIABAPvRNK1ULmcyGRUZ5syZM2+8807EIiJi ra2tSZkPDstzXWPfM9g3r1+3LEv6uCL9BkFgGganfwEAh0IABgAc4Pjx47l8XlEr rC/+9a+FyNfDrq+v27YtZUo4FNuy7AfnW/H4fnf5cvTH934iALuO01RwtBgAMNsI wACAA1RrtVKppCIAC8+98MJTTz8dsUiv16vX61Lmg0Mx+n3P8x70p9tbWw01j8vg AiTT7B50/zAAALsQgAEAB9A0rby4qOIaG0Hk6i/+9a+IRYIgWFlZoRVWzA48AHz5 m29ULP/ODR9xQ9fZ/wwAOCwCMADgYMdPnMjlcopaGf3p9dd/9fDDEes0m80O64Hx 8jzPeHAE7bTba6urip4zrus2Gw3plQEAM48ADAA4WLVaLZZKihaB8/n8x59/HrGI CGMrKytS5oMx7X8A+LvLlxVtmw+CwDJNWn8DAI6AAAwAONigF3SptJDNqigehuEf //znhx95JGKd7e1tfd+OxJBL7/V839/zj9qt1vramqIA7HueaZrsfwYAHAEBGAAw lmPHj+fV9IIWcrncJ198EbGIbdvr6+tS5oMDhUGwzx286pZ/wzB0HKdF/2cAwJEQ gAEAY6lUq6ViMaOmp9FgEfhPf3r40Ucj1tnY2FBx6yzu5zqOaRh7/pHS5d/A903L 2id7AwCwDwIwAGBcJ06ezGazioJNNpf7NPIisGmam5ubUuaD/Rm67rnunn+kdPnX 8zxFVysBANKAAAwAGFdtaalQKChqhSWyzauvvfbIY49FrLO2tuY4jpQp4UEGFyB1 u+If9/9Rq9ncWF9X1/7Ktu1Ou62iOAAgDQjAAIBxaZVKsVjMqmmFJSwsLHz8+ecR b47VdX17e1vWlLAn13XNvfqNiYD6/bffKvoRydyw17dlWf1eT1F9AMDMIwADAA7h 2LFj+UJB0fqecO6JJ168cCFKhTAM19fXWQRWSqRfd6/9z2srK+puJxq0v7LtVqul qD4AIA0IwACAQ6hUq8ViMeIi7T6CILj4t79Va7UoRVgEVmqw/7nTuf/3Lcu6duWK uueG7/sW7a8AANEQgAEAh6P0PiShVqu9/+GHUSqwCKzUg/o/X/nhhwddCxwdtx8B AKQgAAMADieGReA/XLjwxJNPRinCIrA6er/ve96u36zv7Gxtbqo7/cvyLwBACgIw AOBwtEoln8/ncjl1i8Ci7sW//31R06IUWV9ft21b1pQwEgRB/74U6jjO1R9+UHRH 9Nxw+dd1XTEK7a8AABERgAEAh1at1QqFgrpF4LnhRuv3PvggSgXuBFbBMk3nvh8r XL1y5UF3Akvh+75t2929Dh4DAHAoBGAAwKFpmjZYBFZ5EjgMw9+9+OKTTz0VpcjG xoZlWbKmBPGg9Lvd8N7rf3e2t8Uvpc+EweKv4/T7fUVDAADSgwAMADiKGBaB5+bn //rBB0vHjh25gEhNa2trEmeUcve3vzJN8/q1awvKjv7OsfwLAJCKAAwAOAqtUsnl ckrbQQvlxcWPLl2KUmF7e1vXdVnzSbl+rxfc2+f5h++/D4NA3Yij5s+u63L6FwAg BQEYAHBEcSwCz8099vjjF1599cif7vv+8vKyxPmklue6xr0/SlhZXladS1n+BQDI RQAGABzRYBE4m80XCkoXgYMguPDKK7954okjV2i1Wu12W+KU0mnX7UeNen1zY0Pd vUdzo+Vf23Y9j+VfAIAsBGAAwNFVqtVCoZDNZkVWUdoG6e13333o9Okjf/ry8nKg cqfuzPM8z7irB5VIpLdu3lS3+D96OolBbdvm7l8AgEQEYADA0Wmalv15EVjpOnA+ n//go4+KxeLRPl3X9e3tbblTSpW7l39FLr3y449KX0CEQ45ti7Fo/gwAkIgADACI pFKpDHph5fOqB6rVan95/32Rt4/wuSJNra+vO44jfVZpcPfp3yAIrl+54t3bCkuF Qe8rx+mx+RkAIBUBGAAQVbVWKxYKGcXdsIQzZ8++8fbbR/tc13VXV1flzicNwjA0 +n3/58R78/r1GK5WDnzfovcVAEABAjAAIKpRN6zCUfcnjy8IgocfffS1P//5aJ/e aDS6HCg9pLvv/r1982a/31fa+GrEtix6XwEAVCAAAwAkuNMNS/VAIgM/8eSTf7hw 4QifG4bh7du3xVvps5pV4mslUujopt/VlZVOux1D+qX3FQBAHQIwAEACTdMWslmR gWMISCIDn3/++WfOnz/C5xqGsbW1JX1Ks8q2LHu44Xlzc7O+va36zue54YMr0q9P 7ysAgBoEYACAHFqlks/l8oVCDGOJmPTsc8+JX4f9xDAMRZaL4RTrDAh8f7QJeXNj o76zE0P6FRzbdlyXzc8AAEUIwAAAaSrVarFYFElJ6bXAIyIDP/Pcc+cPn4F9319e XlYxpRlj9Pue58WTfkdPGPHQWJbF5mcAgDoEYACANKON0KPbelUH4LlhBn762Wef e+GFw35it9ttNBoqpjQzRr2vNtbXG/V6DGu/o4PZIv2y+RkAoBQBGAAg06AjdC5X iGUj9NwwAy9q2ptvv12t1cb/LK4F3p/4qjZ2dm5ev+77fgyHukds23bZ/AwAUIwA DACQLLaO0HeEwwXEcql06qGHHn388V/88pcHrj+LuCUycDzTmwriS9hqNne2tnrd ruM4IvfGsIZ/B52fAQDxIAADACTTNC2zsFAsFmNbPNwlCIKFhQUxjVOnTz/8yCOn z5zZM8u1Wq12ux3/9BJCJN5Ou13f2el1OpZti3+f4ONlWdag5xabnwEAihGAAQDy ifCZzeVGh4EnTuQrEe3EZCrV6vETJ86cPfvQ6dOjTl3p2Qgtvggi7nZarV6/bxmG 53niNyeVeHcR6ddzXdIvACAGBGAAgBJapVLI53P5/KQnsodwaCGbzefzIgSWygOL IrVXKnHu3FZBJNt+r6f3+4ZhmIYxulN39COAOLc0j891HNtxOPoLAIhHEr8XAgBm w51bkSY9kXGFPxuExUxGJGQhNySicq4gEv1AoVAQ/x7n38v3/UFQtEVUHHCH77hD IvGKiBuKjDu8SWgktolFxL1HAICYTc33SADANKrWaqVSaYoi2fjupOW50XfT0d/x rgAqIvT8QddBjT5fxNfB+6PbgIYFf7oX6Od6s/oFNE2z2+lMeiIAgBSZwW+oAIBE qS0tiQw86VkgcUT67aS4CRkAYCIIwAAAtTRNG9wMnIyGWEgI27JcGl8BAGJHAAYA KDdoiFUoiBg86YkgEUT0tW2bxlcAgPgRgAEAcahUqyIDT3uPZUTneZ5IvzS+AgBM BAEYABCTqWsKDelo+wwAmCwCMAAgPtVqtUAGTiuRfm3L6pJ+AQCTQwAGAMRqhi9G wj649AgAkAS8/gAAxK22tFQsFsnA6SHSr2VZXHoEAJg4XnwAAOKmadpCNlsoFDKZ zKTnAuWCILBt2/c8Lj0CAEwcARgAMAGjDFwqlSY9EShnmibpFwCQEARgAMBk1JaW CMBpIAIwm58BAAlBAAYATMbJU6e4FjgNPM+r7+xMehYAAAwQgAEAcatUq/l8PpfL TXoiiInruo7jcP0vAGDiCMAAgPholYrIvSL90gI6bcIwFBlYJOF+rzfpuQAA0ovX HwCAOGials3lCoUC0TfNRAy2bdsTMZieWACASeBVCABALRF9MwsLxUJBvJ30XJAI ge9bti3eEoMBADEjAAMAFKpUq4V8PstxX9zHc12bg8EAgHgRgAEASoyO+xYKhUlP BIlm2zYHgwEAsSEAAwAkGxz3zWYLxSLHfTGOwcFgy/I8jx3RAADVeGkCAJBmdNy3 UCgscNwXh+T7vs3BYACAYgRgAIAclUolXyhwuy+iGNwYbNs9dkQDANQgAAMAouKK I0jEVUkAAHV4pQIAiKRarRaKRfY8Q67BjmjL6tIjGgAgFQEYAHBEWqWSH5r0RDCz nCF6RAMAZCEAAwAOTdO0hYWFQrGYyWQmPRfMuCAIbMvyaY4FAJCBAAwAOByaXSF+ NMcCAEhBAAYAjGtKL/gNwzAIgkwmI96ZH5r0jCZm9KUYvbOwsDBdXwquCwYARDdN 3/kAABNUqVRE9BUBeNITOQQRmXK53EuvvPLwI4+Mfse27Z2trUaj0W639V7Psm3X cXzfF380M9k4/Jl4P7OwkF1YyOXzxWKxXC4vDn+EMfqwdqu1tro6dX9rEYBFDGYp GABwNNP0PQ8AMBHTuPAr4p+Y84svvfTYb34z5qe4rttqNjudTr/XMwzDMk0RtFzP E78f+H4giEg5TJUTCY13x9rRBOYzIt4OZHO5vAj6+Xxmfj5fKJRKpfGbcjcbjY31 9emKwSwFAwCObGq+2wEAJmIaF35Flvvdiy8+8eST6oYYrUOalmUPf7Xabb3f931/ sMdYpOXhTuPB/4b7jfeXyWRElB0QkXa4LVnEV/FOTnzRc0P5QbwdJ9OOkqFj24f9 69R3djY3NqbrLiuWggEAR0AABgDsbdDqOZstTtvC77PPPffM+fOxjajreqPRGG2i TgjPdU3DGK0VH8rW5ubO9vYUxWDxd7Qsy2cpGAAwtql5TQMAiJNWqRTy+dz03PEr stCTTz31uxdfjG1E13VF9DVNM7YRxxcEgcjAIhke4XPXV1ebzeYUxWDXcWzuCgYA jIcADADYrVqrFafnjl8R9n5z7twfXn45tgmLsN1utzudzhFWWWMj5ubYtm1ZR/vc 1ZWVTrs9LTFYPAcsy+p2OpOeCAAg6QjAAID/o2laLp8vFAqTnshYROz59cMPv/La a3EeUTZNs16ve0daXI2fmKep60cL6uLLu3z7dr/Xm5YYbA97erMdGgCwDwIwAOAn lUqleJgGwhMkstnpM2f+9MYb+Rg3aYsw2Ww2dV2PbUQpBqujhnHkxO573q2bNy3L moodAb7vW6ZJZywAwIMQgAEAA9VarVQqJb/fVRiGtVrt9bfeWtS0OAftdrutVivJ e573EWU79IjjOLdu3BApeiqeIaZpsh0aALCnpH8bAwCoNi3bnkWwKRaLf3rzzZMn T8Y5rkiO9XpdJMA4B1UhynboEV3Xl2/dEhWSH4PZDg0A2FPSv4EBAJTSKpXiNFzz m1lYePnVVx9+5JE4B/V9v9VqzdJ+2nDYHTriAeZ2q7W2upr8HdHir2lZFt2hAQB3 IwADQHpVq9ViqZTwJBOG4XO/+91/P/10zOP2+/1GoxEEQczjqhZ9O/TI9taW+JXw E+OD88+m2e12Jz0RAEBSEIABII00TVvIZovFYpL3sor0cu63v/3DhQsxT9JxHBF9 rcgRMcl8zzMMI4wW70WWXltZaSf7tiQxSfFQir8v26EBAHMEYABIIZF+8/nBqd9J T+SBRk2eX3/zzWwuF/O4nU5HJLo4B52UwXZo0/RcN2Id3/cHbaJNM8lbCRzbdjgS DAAgAANA2gwO/RYKMQfL8YVhWCqV3nznndrSUsxDG4bRaDSm5YJfKWRthxZEAL55 40aS+2OJqG/ZNkeCASDlEvpdCgCgQsJv+hXfk1565ZXHfvObmMed0gt+ZZGyHXqk 2WhsrK1lkvoE45ZgAAABGADSolqtlsrlZC7QjY77vvTyyzGPG4ahiEMi/U7pBb+y yNoOPbK6vJzYg8GDW4INg7ZYAJBaSXwZBACQrlarFUulBKZfEX1Pnjr1+ltvxX8R 8cxc8CuFxO3Qc8NF9Zs3boiCCTwYPGiLZZqdTmfSEwEATEDiXgkBAOTSNC2bzYr0 O+mJ7CZySL5QeOOtt06cPBnz0CJ1t1otlgHvJ4Krqeuy1sMNXb9186Z4J4E/eREZ 2KM1NACkT+K+IQEAJBLpN5fLFYrFSU9kNxFBn3vhhaeffTb+oXVdbzQavu/HP/RU GGyHNgyJzcC2Njd3trcTuCPatizXdcnAAJAqBGAAmFmD644KhXw+P+mJ3ENE31MP PfTm22/H34lahDoRfQ3DiHncqSN3O/TcsPvUzRs3RMGk7Yh2BNsmAwNAehCAAWA2 ifRbKBRyCUu/mYWFN95666HTp2MeVyS6brfbarVS3uzqUORuhxZEzrx982bSMrA7 iMBkYABICwIwAMygQfotFnNJuux3Un2e52h2FUEw3A7tS70bOYE9ol3XtS2LDAwA aUAABoBZk7T0G4ZhqVz+y3vvLWpazEPT7Co68fCJcOjYtsSajuNcv3YtDILkNMci AwNASiTlGw8AQIqkpV8RQX/3hz/811NPxT+0YRiNRkNiM6c081zXNAy5G8h3tre3 NjeTsxRMBgaANCAAA8DsSFT6FWGpUq3+5a9/jf+CXxF6m82mrusxjzvbBtuhdV1u 92zxSF2/elXUTMhSMBkYAGZeIr7fAACiS1TXKxGWfv+HPzwZ+8KvSN29Xq/VaokJ xDx0Ggy2Q5um9NPUiVoKpicWAMw2AjAAzILk3HgkMtLi4uK7H3xQjP3yYRHM6vW6 LfW0Ku4nIqIp+yopz/OuXbkSJONUMHcjAcAMm/y3GQBARCL95vL5+Hca308EmKef ffa5F16IeVyRuttDMY+bWr7vm7oufZl9Y329Ua8nYSnYtm2R88nAADB7CMAAMPWW jh2Lf7n1ftls9r0PPqhUqzGPa1lWvV53XTfmcVMuDEPTMDzZX3bbsq5dvZqEu4LF 86rdak16FgAAyQjAADDdaktLpVJpsnMIguDhRx997c9/jn/cZrPZ6/ViHhd32IJp Si97++bNfr8/8RhsmmaHbQUAMFsIwAAwxarVaqlcnuyxySAMRfR9+JFHYh7XMIx6 vS63KTGOwPM8U9fl3pAktNvt1eXlyW6HHq1yc480AMwSAjAATKtKpVJeXJxs+i0W i3+9eDHmDdgi9DYaDW45Sg4VNyTNDaP11R9/lFvzsEQGNnSdXQYAMDMIwAAwlbRK pVQqTXB9TASDRx977JXXXot53H6/L9IvtxwljaIbkoTl27f7vd4Ef9Az6Phlmn0y MADMBAIwAEyfwZW/xWIul5vUBET+fOWPf3zsN7+Jc1CRQ+r1uiH7Ah5IJAKwpeAB ajYa62trE/xxj+u6tmXRFBoAZgABGACmz2TbPs9nMh9cvBhzt2cWfqeF73mGYYSy HymRP69evbowubZYNIUGgNlAAAaAKVOt1crl8qRGr1Qq73/4YZzteTnxO3UGR4IN QyRhuWXDMLzyww8T/CGICPbdTmdSowMApCAAA8A0EfmzVC5P5HoYET8efuSRP8Z7 15HIvfV6nYXfqaPuSPDtW7f0fn8iR4JHwZ6GWAAw1QjAADA1NE0T6XciJyHFS//n f//7/3766ThHbDQanLqcao5tWwpuCd7e2trZ3p7Ij4EGDbEMg6clAEwvAjAATI1J Hf0VWfTNd945+4tfxDaiZVk7Ozue7D20iJ+iW4K73e7yrVsT+WEQh4EBYKoRgAFg OlSq1XK5HP/OTxFd3r94UWTv2IZrtVodTlrOkCAIDF0PZN8SbJrmtatXs7Fn4MHN wIbR63ZjHhcAIAUBGACmwKQ2P4u8/dGlS6W4em65rru9va3i4CgmS4RGU9elL+mL J8yP338f/38XbIQGgOlFAAaAKXDs+PFCoRDzoNlc7u8ff5yN67ZhESfq9br0vbJI iEFbLMtybFtuWZFFRQaOf2eEbdutZjPmQQEA0RGAASDpKtXq4uJizIMW8vmPPvkk nrW1IAiazSbNddNARVss8fz58bvv5mLPwLqusxEaAKYOARgAEm0im5+LxeJHH38c T5ddx3F2dnbY9pweruOYhiG3ZhiGP4gMHC82QgPANCIAA0Ci1ZaWSqVSnCOKvP3R pUvx7CnVdV2kX7Y9p42K1tCDDPz993PxPpdM0+y023GOCACIiAAMAMmlVSrlcjnO +06LxeLfPvkkhvRLt+eU833f6PflZ+B414EHDa4No8/ufQCYHgRgAEiuY8eOFWK8 +Deby1369NMYtluL2LC9vW3KPguK6SKeBrrIwEEgt6bIwHH2xLItq8W1wAAwPQjA AJBQWqWyuLgY20v5TCbz8WefxdDz2XXdra0t8Vb1QEi+wQpqvx9IzcC+74sMHNu+ iTAMdV1nERgApgUBGAASKuarjy599lkMw1mWJdKv3MCDqaYiA3ueJzJwbK3juBIJ AKYIARgAkqhSqZTjWv4V2eN/PvqotrSkeiBu+sWeVGRgyzSvXb0aTwYWT2lD17nH CwCmAgEYAJIottO/InW8/tZbv/zVr1QP1O12G42G6lEwpVRk4G6ns7K8HM9eaE4C A8C0IAADQOLEdvo3DMPnf/e7p55+WvVA7XabeID9qcjA21tb9Z2deP5T4iQwAEwF AjAAJE5sd/+eOXv2jbffVj2KiL5t7krFGAZ9oXs9uZvkb16/blmWxIIPwp3AADAV CMAAkCyappUXF2PYt5nL5T754gvVo5B+cSi+5+n9vtya312+HMMi8GAFWxdzlzx5 AIBcBGAASJZKtbq4uKh6lCAML33ySalcVjoKO59xBJ7riiQpsaDruj9+/30MDbF0 Xe91u6pHAQBEQQAGgGSJ4fajMAz/+Kc/Pfzoo0pH6fV69Xpd6RCYVY5tW6YpsWC7 1VpfW1O9Dsx9SACQfARgAEiQePY/nz5z5s133lE6hGmam5ubSofAbDMNw3UciQVv XLsmAqrEgvdjFzQAJB8BGAASpFqtlhXvfxb/v//5v/6ldCnMdd319XW57XyRNoO+ yv1+4PsSC373n/9kFG+EFgG4yy5oAEgwAjAAJMjSsWNFldf/igzw5zffVHrrr8i9 Iv2KDKxuCKSESL+D1VR5TaG7nc7qyorSn/5YltXm3DsAJBgBGAAS5OSpU9lsVl39 Wq32/ocfqqsv7OzssAUUsriOYxqGxIJXfvjBl7eqfD/P8+o7O+rqAwAiIgADQFJo lYqmaerqB0Hw8WefFVXeMCyi7w6v/iGVoeuevA0FMXSEFv8V9Hs9dfUBAFEQgAEg KVQfAP7FL3/55zffVFff87y1tTWO/kKuMAhEngzlbYS+eeOG3BbTu3AMGACSjAAM AElRW1oqKVueFbn08y+/zOZyiuoLW1tbhtTdqsCI67qmvJuBG/X61uamopPAvu/b lkUABoDEIgADQFIovQH41EMPvf3uu4qKC7qub29vq6uPlJO4EdoyzZs3bkgpdb8g CGzb7rTbiuoDACIiAANAUpw4eTKnZoU2DMMPL11Sd8BYvOhfXV1V2lsIKSeeY315 y6pbm5vNRkNWtbuJ/9ZEAKYRNAAkFgEYAJLiodOnM5mMisrZXO7TL75QUXmk3RYv +HnFD7VsyxK/pJTq9Xq3b95U1ArLse1ms6miMgAgOgIwACSCpmmLmqboXOJjjz9+ 4dVXVVSeGx56XFlZkdijCNiTeI4NumHJ6LLmOM6tmzd9z4teas/iipaXAQDREYAB IBFEANYqFUXF3/vgg2PHjysq3ul0er2eiMH0f4ZqEq8F3lhba6s5qSsm2SAAA0BS EYABIBHUXQIscuk/v/5aReVdwjAUY/k/u/P+6J07/xrDTDCrxHNM7/cDGc+iRr2+ vbUVvc79XNe1Lavf76soDgCIiAAMAIkwAwF4THfn4X3esqcae/Jc15BxJVKz0djc 2FBx6IAADABJRgAGgERQF4BFknz3gw9OnDihorg6wdD9wfj+f530TBE3fbjlPmIR hVugXbdRr6uoDACIjgAMAImg9AywyMAX//73irL6E3Rn3/WBbyc9U0gTfRG4vrOz ubGhqAs0Z4ABIMkIwACQCEq7QM8NF1TPP//8M+fPK6qfcKOc/KBjyawnT50jLwJ7 nreyvCzys6Irx+boAg0AyUYABoCkOPXQQ4qWpO4Q9V986aXHfvMbpaNML5GT7w/G u9p6EZKTwHVd85CLwOKx29rcFNFU6X9l4ikkAnCLe4ABIKkIwACQFMdPnMjn8zEM JP6v/7Fz557/3e/iGW7G7ArJ9ydkgQ5eqg3aQfd6Y/4wwjLN9bU1wzBU/4BpbrjV wrFtRaeLAQDREYABICmWjh0rFouxDSdeqRdLpUceffTpZ54R78Q2bho8KB57nkdC lkXkTJFs9/kA0zC2t7b6/f78UDyzEg+ubdvdTiee4QAAh0UABoCkqNZq5XI5/nFF GMtkMsdPnHj08ccfe/zxbDYb/xzSZtch5FEwJiEfivgS9bvdXV+oUQdmkT8dxxHP 6thy7x3isROxvNfrxTwuAGBMBGAASAp1NyGNT2SwhUxGzOTU6dO/+vWvz/7iF/FH CMw9YA35biRkwbYsQ9dF3BW/TNN0PW9hEqH3blwCDAAJx8saAEiQh06fVtec9ghE DBNxolgsVmu14ydOiOmdPnOGJeIkuHu5eBfx+7Paqct1nHarJeKuSJiWZQW+H+f2 5gPRAQsAki8p3zMAAHOxHwM+gtF9QiID5/P5UrlcqYpoXBPTPnnqVMJnniqjTl27 UvG0LCCPYqRIuXq/bxqGbVmO6w7mHAQT2dU8Pg4AA0DyJfe7CACkkMiTi4uLk57F EY1WHUVEWVhYyOVyBaFYFCFZBOPy4sDormPxR5OeKfZeQL7zO4oWkEWyFUNYlmUP fzm2LZKtyLqe+OV5gRj351ieqH0Q4xvsf7btPgeAASDBCMAAkCAiIorEGMNlLRMU DheRRdCZn5/PDIl3stns/DA5Zwf/G70ZvBX/yIl3stlRrhbEOyJCZ4b/Pnone2+i 5m6nowtDkUhH74zysDOMpoO3Itt5nkird7ZYDx7GYVYerc0GP7/jD98Ph2vQ4fDh Fv+bGy7bJmq7snSDhWvbbrVak54IAGA/M/t9CACmVK1WK02iFzSAKALfNy2r1+1O eiIAgP0QgAEgWTRNKy8uTukWUCC1HMdpNhqTngUA4AAEYABInNrSUqlUmvQsAIxr 0P7Ksros/wJA4hGAASBxWAQGpgi3HwHAFCEAA0ASVavV8tS2gwZSxfd9yzR7NH8G gGlAAAaAhDp+/Hi+UJj0LADsJwgC27Y77fakJwIAGAsBGAASKg1XIgFTLQxD13Ga bH4GgOlBAAaA5KpUq+VyeYavTgWmmue6lm332fwMANODF1UAkGhcCwwkUxAEpmly 8S8ATBcCMAAk3dLSUpFbkYAkGdx7ZNvdTmfSEwEAHA4BGACSTtO0bC5XLBYnPREA A4PGV5bVIf0CwBQiAAPAdGAdGEgC1n4BYKoRgAFgatREBi4W6YkFTEoQBJZpdjn3 CwBTi1dRADBNKtVqqVTKZDKTngiQOq7rOrbdo+czAEwzAjAATBmtUikUCrlcbtIT AdIiDEMRfUUA7vf7k54LACASAjAATB9N0xayWbZDAzHwPW9w6JdtzwAwE3jlBADT arAUnM/n8vlJTwSYTUEQOI7jeV6fbc8AMCsIwAAw3SrVaqFQyGazk54IMDvCMHQH R34dTvwCwIwhAAPA1NM0LbOwkM/nicFARD9FX9ftsecZAGYRARgAZsQgBmcyuXye /ljAEQw6XQ03PBN9AWCGEYABYNZUKpWFbDafz3NbEnAgkXtHZ3193+esLwDMPAIw AMym0YKwSMK5XI4kDNxPJF7XdcVblnwBID0IwAAw435KwgsLIgqLt5OeDjBJo/Xe Ue4V73GvLwCkDQEYANJCJOH5+flBFBZhOJtlWRgpMQq9nueJ0CveYZ8zAKQZARgA 0uinMDxcGs5ls+I98a+TnhQgjQi9Iu6K0BsMEXoBACO83AEADPNwZhiHM5l8oTDp 6QBHMdjb7Dh+EITiVxiyvRkAcD8CMADg/1RrtXK5POlZAEfh+75lWXS0AgDsgwAM APg/x0+cyOfzk54FcBSj24zardakJwIASC4CMADgJ5qmlRcX1TXHCsOQk8YpJ54D 4q26p4Hruo16XVFxAMAM4IUIAOAnlWp1cXFRUfEgCD79xz/EW0PQdduy7CGRWBzH 8VzXGwqGjXpHV9QEw+a9IjOJdwbJaWhUbfTO8H/h3aMQsKMK7/2CDr+ko59czI/+ Rfzr8KG587Ue/t786B+Zn1qrDZqqDfqND2+iHnUdF/L5fC6f7/d662triqY/2AVt mj1aXgEAHoAXCgCAnywdO1YsFhUVF3Ho8y+/lFjQsqyNjQ2JBTEOkXBdxzF0/cgV TMO4fu2aoiupRTa3LavT6agoDgCYAQRgAMBPTj30kKJYIpz95S9ff/NNiQWbzSY5 ZyI8zzMiNFh2XffW9eue70uc0h1hGIr6zUZDRXEAwAwgAAMABiqVyqKmKSouYslf 3n//5MmTEmuurq6KqCOxIMYkHs1etB89bG9vN3Z2ZM1nF9/3TdPk4l8AwJ4IwACA gdrSUqlUUlQ8DIIvv/5aYkHP81ZWViQWxKH0u93B8eyj0nX95vXrqnZB+75l2112 BwAA9kIABgAMnDh5MpfLKSperVY/+OgjiQV7vV6dZr+TY+p6lOV327ZvXL06p6Zj WRiGjm23uAwJALAXAjAAYHAB0qKmqWuh/MLvf//kU09JLLi9va1H6MOEiAb9u03z yJ/u+/762pq6Xcqe59WVbbEGAEw1AjAAYK5aq5XLZUXFgyD4x7//LfF64TAMl5eX o2zBRUQR+2AJvW53ZXlZ0c9cBpchWZYYQkVxAMBUIwADAOaOHT9eKBQUFc/n8x9/ /rnEgrZtr6+vSyyIw4reB8syzWtXr6q7DMmx7Xa7raI4AGCqEYABIO00TSsvLkpc od3lsccfv/DqqxILdjqdZrMpsSCOIGIfLM/zbt+6JWKqxCndzXXdBqfEAQD3IQAD QNpVqtXFxUVFxcMw/PDSJU3qBUtbW1uGYUgsiCMwdN2Ldg1Vs9HY2tyUNZ9dRDgX TxIuQwIA7EIABoC0Wzp2rFgsKiouvs188e9/SyzIAeCEsC1L/IpSQUToG+ouQwoC Mb0OlyEBAO5FAAaAtDt56lQ2m1VX/J333pNYkAPACeG5rhGtEbfjOCIAh2p+ljG4 DMlxWmyVBwDciwAMAKmmVSpy9yfv8tqf//yrhx+WWJADwAkRvQ+WqLC5sdFWdmGv 7/umYfSjdasGAMwYAjAApFqtVispuwBJJJB//e//yq3JAeDk6HW7Eddv+73e7Vu3 FDVgE08/27K6XIYEALgLARgAUu34iRP5fF5R8fLi4keXLsmtefv2bQ4AJ0T0PliW ZV2/elVRAA7D0LZtdSvMAIBpRAAGgPTSNG1R0+bnVX0v+O9nnjn//PMSCzqOs7a2 JrEgoojeB8v3vJWVFVPZkj6XIQEAdiEAA0B6VavVsrILkIIg+OzLL3O5nMSavV6v Tp5JjOh9sIROu72u7Icavu9bptnjMiQAwM8IwACQXseOHSsouwBpYWFBBGC5NXd2 duhplBxhEPQin7A1DOPGtWsKL0OybZGxVRQHAEwjAjAApJSmaaVyWVHwEH7561// 6fXX5dZcXl72fV9uTUTR73YjHsl2XffmjRu+58ma0i6O4zQbDUXFAQBThwAMAClV qVQWlV2AFIbhe//zP8ePH5dYUySl1dVViQURXfQ+WMLO9nZ9Z0fKfO43uAzJNPvs ggYADBGAASCllpaWiqWSouIiAH/51VdyaxqGsbW1JbcmIoreB0vo9/u3btxQtwva sqxutCuLAQAzgwAMAGlUqVYXlbW/EorF4t8//VRuTQ4AJ5DneUbkB8UyzevXrim6 DGluOEmRgVkEBgDMEYABIJ2Utr8SXnzppXO//a3cmhwATqAwDHuRF1eDIFhfXVXX q5lWWACAOwjAAJA6qttfibzx5Vdfyb1e2BteGCuxIGSJ3gdL6HY6ayoPeNMKCwAw QgAGgNRR2v5KmM9kvvjnP+XW7HQ6zWZTbk1IYeq6G7kPlqHr169fzyr7oQy7oAEA IwRgAEgdpe2vhMfPnXvp5Zfl1tzc3DRNU25NSGELkR8aEVBv37rl2LaUKd2PVlgA gBECMACkzslTp7LZrKLiYRj+/ZNPSuWy3Jq3b98WbyXWhCxS+mAJzUZja3Mzep09 iSeP4zgtNhEAQOoRgAEgXVTvf1ZxAZJpmpvKohEiktIHa07xZUhzo13QpkkjcQBI OQIwAKRLbWmppHL/88lTp9557z25Nev1uroWwYhOSh8s27ZvXr+ubp3f930xBLug ASDlCMAAkC4nT57M5nLq6r/5zjunz5yRWFAkopWVFS5ASjLTMFzHiVhEPNBbm5vq dimzCxoAMEcABoBU0SoVTeX+5yAI/vn113JrWpa1sbEhtybkcmzbktGirNftriz/ f/buw72t48z3OMWGQgAEqGL1LlHFcW6c5CbuJY7tuBdVt5vsn5pknbjLkiyJYic6 CZAg6um4Q2pXq1WlqJnBwcH38/jx1rxzJBwA54eZeWdB7gFad6IXNACAAAwAPUTp +ud2uz0Si33w8cdyy5bL5Wq1Krcm5JLVB0uk6Ompqf7+/icvdV+sggYAEIABoIds 3bZtSNn6Z/GNcubiRblNjESozmQyIl9JrAnpZPXBEuq12tzsrKJWWKyCBgAQgAGg V8Ti8ZGREXXrS5/aufO1N96QW5P1z91CBFdPxj5tEVBnZ2aklLovekEDQI8jAANA r1C9/vmNt97avmOH3LJLS0tkla4gpQ9W3/qNtFgsLpfLT17qvtZWQRsGi+oBoGcR gAGgVyhd/6zi+F9Rc35+Xt25OJDIsiyj2ZRSSumBwGuroE1zZWVFRXEAgP8RgAGg J6he/yzS9Z/ffltuTRGElpaW5NaEIq7rNiR1V1Z9IDCroAGglxGAAaAnKF3/LDz3 4osHDh6UW7NQKLRkHK4DDST2wRKlCrlcpVKRUu1erIIGgF5GAAaAnqB0/bPjOGcv XAiFw3JrptNpiQWhWqNedyX1667VavNKe0GzChoAehUBGACCT/X6Z9d1P/9//09u TZFP1M0BQgWj1RLBUkop0zBmpqellLovx7YNw2AVNAD0IAIwAATf6OhoJBpVV3/P 3r0vvfqqxIIc/9uNbNtuNRpSSnmel8/lqpLWVN+LVdAA0LMIwAAQfF23/rnVahUK BYkFoYFIrXV5kbJWqy3MzfX398sqeCdWQQNAzyIAA0DAKV//7Dif//WvcmsWi8Wm pDN1oFNtdVVW92bDMGaVroKmFzQA9CQCMAAEnOr+z7v37Hn5tdckFnRdd2FhQWJB aNNsNBzbllJqbRV0NqtulTKroAGgNxGAASDgtm3bNthV658rlQprU7uUiJTiH1nV atXqwvy8wlXQlrWyvKyiOADAtwjAABBk8Xh8JBZTV1/6+mcRS9LptOu6EmtCG8e2 m5L6YPWtr4KemZ5W96TCKmgA6EEEYAAIMtXrn3ft3v3K669LLCgyTz6fl1gQOrXb 7Zq81s2e5+UymVqtJqvgXdZWQZumul7TAAAfIgADQJBt2759cHBQUXHXcc5IXf8s Ak+xWDTkraGFfvVqVbyOsqpVq9U0q6ABAPIQgAEgsFSvf3Zs+4u//U1iwXq9vrS0 JLEg9Gs1m7ZlyapmtFprq6CV9TBfWwVtGHVlk8wAAL8hAANAYCWTybDK9c9P7dr1 2p/+JLFgoVBotVoSC0I/yzQNeS+i53nZdFrdNl3PdQ1WQQNALyEAA0AwxWKxSDQ6 MDCgqL70/s+cfhQM4nVsSJ1QZRU0AEAiAjAABFM8kRgZGVFXX3r/Z5FzyuWyxILo iLU+WNWq+C+yCuroBc0qaADoGQRgAAimZCoVlno871327tv34iuvSCyYz+dpfxUM zXpdpEpZ1TzPy2ezVRGq1RD1TcNYZRU0APQGAjAABFDXrX8WBdPptKxq6CyRJ02p v2XUqtX5uTl197NlWcusPgCA3kAABoAASiQSUZXrnz3P++yrryQWrFQqKysrEgui gxzbbjYaEgua66ugJRa8i7u+ClrdgcMAAP8gAANAAI2NjQ2HQurqHzpy5A/PPSex YCaTsW1bYkF00No2YKkrikXBfC63WqlIrHknz/Ms06woqw8A8A8CMAAETSwWG4nF 1B2dKpLquYsXJa5/tiwrm83KqgY/qFerIlVKLFir1eZnZ9WtghZ3dblUUlQcAOAf BGAACJrE6Gg0GlU6xIUvvpBYbXl5mRZEAdNqNm3LkljQNM3Z6em2vObSd3Fdd20V tLJWWwAAnyAAA0DQbN22bWhoSFFxkUBOnD79m2eflVgwnU6L+CGrIPxApF+RgeXW LBQKK8paVYn7UGTsChvRASDoCMAAECixeHxkZETh+mfLOvfZZxLXP7daLRFsZFWD T3ieV5c9m1qv1eZUroJ2bHvtQOB6XVF9AIAfEIABIFBGk8lIJKKufv+WLec+/1xi waWlJSJHINVWV+WuWLYsa3Z6Wu7W4ju5rmuaZpXV+AAQaARgAAiOWCwWjkQGBwcV 1Rd55uVXX92zb5+sgiLMLCwsqNvYiQ5qNhqO7M7eS4uLpaUluTVvE/ehyNgry8uK 6gMA/IAADADBEU8kRlQe/yviwVf/8R8SCzYajcXFRYkF4R+WaRqtltya9Xp9bmZG 4Sro9QOB6xwIDADBRQAGgOBIpVISd+feKxwOf3TmjMSCxWKxKbtVEnzCdd2G7CRp 2/b83Jzc/tJ38jzPNE11Bw4DADqOAAwAARGLxSLRqLrJMZFn3vvgg9FUSmLBhYUF WdXgN+12e+1UIdnr25fL5aLKrmkiXZeV9ZoGAHQcARgAAkL18b8iGHwpdf1ztVol aQRbs153HEdyzWZzZnp6oL9fbtnbOBAYAIKNAAwAAaH0+F8hmUq9/e67Egtms1lL 2VpW+IFpGOIfuTVdx0kvLLRk7y6+jQOBASDYCMAAEASqj/91XfeTc+ckHrAkoq8I wLKqwZ9EWG0oOONqtVLJpNP9yiaBORAYAAKMAAwAQZBMJsMqj/8VSebzv/5VYsHl 5eVVDlwNurVtwApeZaPVmpmeVvpzDwcCA0BQEYABoOupbn8l7Nu//4WXX5ZVTeSi dDotYoasgvCtRr3uyt4G7HlePputKtumK+5P27KWORAYAIKIAAwAXU/18b+2bZ+7 eFHiAUvNZrNYLMqqBj9TsQ24b72D2sLcHAcCAwAeFwEYALpeamwsFAopHKDdvvDl lxLrLS4uNhoNiQXhWyJJNhVspjVNc3Z6ui37jKXbOBAYAIKKAAwA3S0Wi43EYur2 Q4qM8fxLLx04eFBWQREtFhYW1EUX+IqibcBCsVBYVnmMlm3b5VJJXX0AQEcQgAGg u40mkxKbM99L+vG/tVqtRK7oJSq2AQv1en1uZkbdKui1VliGoW6nMQCgIwjAANDF YrFYOBIZHBxUN0Q0Gv3gk08kFszlcqZpSiwIn1O0Ddi27YX5eUvZvdRuty3LWqEV FgAECwEYALqY6vZXrut++MknsXhcVkERWjKZjKxq6AqKTgMWRDrN53Lq1v/TCgsA gocADABdTHX7KxEAvpB6/O/KykqFxkI9pt1u16tVFbu+W83mzPR0f3+/9Mq30AoL AIKHAAwA3SoWj4+MjKib/urj+F9I0mw0HNuWXlYE1Fw2W1O5Tde2bdMw6mpmsAEA +hGAAaBbKW9/xfG/kMQyTaPVUlFZ9YHAtMICgIAhAANAV4rFYpFoVN1zv9Df33/u s88kFuT4354lYmRDzU5a0zTnZmY8z1NRvI9WWAAQOARgAOhKqttfiUTx+ptv7ty5 U1ZBEYEWFhZkVUPXqVWrbTUxdWlxsbS0pKLyLY7jmIZRoxUWAAQCARgAutLY1q3D w8Pq6luW9ZXU439XV1eXmUbrYa1m07YsFZUbjcbc9HS/stUQnudZpknzNgAIBgIw AHQfDe2vRpPJv7z3nsSCmUzGVtAGCd1CvPotNQvgHcdJz88bCo4avo1WWAAQGARg AOg+yWQyrLL9lUgUn54/L7HDlmmauVxOVjV0o3a7XVtdVVR8tVLJpNPqzkNaa4Vl mlVl1w8A0IYADABdRkP7K5FVLn75pcSCpVKJLZRo1Ouu46iobBjG3MyMiqOGb7Ms a7lcVlcfAKAHARgAukxidDQajaqrL1LEi6+8sm//flkFPc9Lp9Pq+vSiW5iGYSpb qFwsFpdLJUXF+261wjJNpWcOAwA0IAADQJfZum3b0NCQuvrS21/V6/UllU160S3U HYbUt36bzc/OqlsF3W63RQCurKwoqg8A0IMADADdJB6Pj8RiSodIplJvv/uuxIL5 fF5pgyJ0EXWHIbmOk0mnm82miuK3OI4j7uQ6i/kBoJsRgAGgm6TGxkKhkLr60ttf 2badyWRkVUO3M1otyzQVFVfdCsvzPNM0VzkPCQC6GQEYALqGhtOP+trtC1LbXy0v L6/SOxf/zXGcprLDhEzDmJub81xXUf0+zkMCgO5HAAaArqH69KN2u/3Ka6/t3rtX YsGFhQXaX+E2cUvUq1V17ZpLpdJSsaioeB/nIQFA9yMAA0B30HD6Ee2voEGr2bQt S1HxRqMxPzOzRdkq6D7OQwKALkcABoDuoPr0o771/tJ/fvttiQVpf4V72bbdajQU FXddN5fNKu1T5TqOwXlIANC1CMAA0AVisVg4EhkcHFQ3hOM4Zy9cCIXDsgrS/gr3 1W63ayqXENdqtfnZWXVrJcT1W6a5wnlIANCdCMAA0AXiicTIyIjSIbZs2XL+888l FqT9FR6k2Wg4tq2ouGmaC/Pz6ur3rf9aZBpGjfOQAKALEYABoAuMbd06PDysrr7r um++/fb2p56SVZD2V3gI27JaKg/sXVlZKeRy6uqLG9syzQrnIQFAFyIAA4DfxePx qOLTj2zb/vJvf5NYkPZXeAjVq6Cbzeb8zEyf4rcM5yEBQDciAAOA36XGxkKhkLr6 Io0cPHz4uRdekFiT9ld4uFajYStbpSxu6cVCYXl5WVH9vvVJYNM0V5kEBoBuQwAG AF+LxeMjiqd/Lcs6/9lntL+CTkp7Qfetn4c0NzPTr/I8JCaBAaAbEYABwNeSyWQ4 ElE6hAjY73/8scSCtL/CI7Xb7Xq1Kv6tqL5Ip9lMRulOY9d1TdOscqsDQFchAAOA f8VisUg0qu5Al771frafnD0blddi2vO8dDpN+ys8kkintmWpq1+v1ebn5pROAluW tVwuq6sPAJCOAAwA/jWaTEYUT/8KF774QmK1Wq1WKpUkFkRQOY7TVLl+2DCMhfl5 13HUDbE2CWwY1WpV3RAAALkIwADgUxqmf8Xj+5/ffnuHvNOPhGw2a6mc1kNgqF4F 3af+PKS+9WOHV1R22wIAyEUABgCfSoyORqNRpUNIP/3IMIx8Pi+xIILNaLUs01RX v9VqzU1PKz0PyXEckYFrTAIDQJcgAAOAH8VisXAkMjg4qG6Idrt95Nix//vHP0qs ubi42FDZ2hcB47luvVZTV3/tPKRiUek2XTGEyMBllv0DQJcgAAOAHyUSCYmNqe7L Ms3zn38u8fQjEQPS6bSsaugRjXpd6TbdRqMxOz2tdCtB33pDLzqfA0BXIAADgO+s Tf+Gw4NDQ0pHSY2NvfXOOxILrqysVCoViQXRC2zLUnpYkeM4+VxO6Txz3/p2+qXF RaVDAACkIAADgO/EE4kRxdO/tm2fu3hR4vRvu91Op9MiBsgqiB6hoRVWrVabn51V PQncbDY5ExgA/I8ADAC+s3XbtiHF078i+n585ozEgo1GY5EZMGyK6lZYlmVlFhZM lUP0MQkMAF2CAAwA/qJh+lc8qX/46aexWExizXw+bxiGxILoHeKGbCheory6uioy cH9/v9JRmAQGAP8jAAOAv2zdunVoeFjpEOKj//wXX0gsaFlWNpuVWBC9RgRgpevn DcNYmJtTvUSfSWAA8D8CMAD4iJ7p3zffeWf79u0Sa5ZKpZriGTwEm2VZhspWWEK5 XF4sFJQO0cckMAD4HgEYAHxkbOvWYcXTv67jfP7Xv8os6LrpdFppEyMEnoZWWCKa zs/Oqqt/C5PAAOBzBGAA8AsN078iYDz/0ksHDh6UWLNSqaysrEgsiN6kuhWWUCwU lstlpUP0MQkMAP5GAAYAv9Aw/Wvb9pd/+5vEgpx+BFk8z6tXq0qHaDQac7Oz/VvU PvwwCQwAfkYABgBf0DP9+3+effbk6dMSa9ZqtVKpJLEgelmr0bBtW1198RbIZbMa pmeZBAYA3yIAA4AvaJj+tSzrq//4D7k1s9msKCu3JnqWhvOQarXa/NzcgOLzkJgE BgDfIgADQOdpmP4Vdu7a9eqf/iSxYKvVKqhvq4ue0qjXXcdRV3+tZ9vCQktxx+k+ JoEBwK8IwADQeRrO/rUs6/xnn4XCYYk1RfoVGVhiQcCx7WajoXQIkUtFBu5nEhgA ehIBGAA6TM/079Zt2/789tsSC4pEnc1mJRYEbqnXap7Ktmqu40zevKnh4K5Wq7Va qageBQDwWAjAANBhIpoODQ0pHcK2rHOyp39LpVJN8XZN9CZxu6peoixyaTaT2aK4 HbTI2I36GqWjAAAeCwEYADopkUhE1U//JkZH33n/fYkF1zZSptMa5tDQg9ZyY63m eZ66IRzHmZyYUFf/NtM0V5aXNQwEANggAjAAdEwsFgtHIoODg0pHsW373MWLcqd/ K5XKysqKxILAnTRMAot7OKdnErjRqLNWAgB8gwAMAB2TGhsLhUKqR4lGox988onE guKZPp1Ouyp3aaLHaZgEtm17amKiT3EA7lufbS4tLakeBQCwQQRgAOiMWDw+MjKi egJKPOWfuXAhEolIrFmr1UqlksSCwL00TAKvLC/ncznV70Gh2WhUq1XVowAANoIA DACdMbZ167Dio4/61Ez/ZrNZkasl1gTuFaRJYPGnEBmYblgA4AcEYADogO6d/m00 GoucbgotgjQJbBhGhW3zAOADBGAA6AANRx8J4Ujko08/lVszm81aliW3JnBf7Xa7 Wa8r3W0ubuapyUkND0Nrf5ZGg5PDAKDjCMAAoFs8Ho+qn/51bPtT2dO/rVarUChI LAg8nLiNRW5UOoS2SWDHcYxWi4XQANBZBGAA0G3btm2D3Tn9m8/nDcOQWxN4uGa9 LqKjouLtdnvq5k3btjUE4L71n5BWKxUNAwEAHoQADABaxROJkZER1aOo2P1rmmYu l5NYENgI13UbalYOL5fLuWx2YGBARfH7YiE0AHQcARgAtNqxY0e/+gdukbHf//hj uTUXFxcbihejAvfVajZtqTvPbduenJgQ/42eid+7hjYNg4XQANApBGAA0CeRSES1 TP+eu3gxFA7LrZnJZCQWBDbO87y6vHN00wsL1dXV/v5+WQUfl8jzq6urnRodAHoc ARgANInFYpFoVMN6y8To6Dvvvy+3ZqlUYt0mOsg0DPOJ95/X6/XZmZlBjWue72vt WOBms84bCgA6gQAMAJqMjo6KAKx6FNuyzn32mdzpX8dxMplMu92WWBN4LOL2a9Rq Ijpu7j8u/oOTExOu6+pf83xflmUtl8udvgoA6EW++BoAgMCLxWLRkRENqy7Htm59 8y9/kVtzeXmZFZvoONu2W5vahV7I58ulUgfXPN9Xs9ms8rYCAO0IwACgQzKVCkud lb0vFbt/XddNp9NM/8IPHvdIJNM0JycmdPZ53jjxzmo1m3TDAgDNCMAAoFwsHh8Z GdGw9nLb9u1vvPWW3JorKysVTi6FP3iuu/Gts1OTk5Zp+mTN832ZhiHeX52+CgDo Lf79VgCAwBgbGxsOhVSP4jjO2QsXpE//ZjKZTW+8BKQzWi0Rax/+/1MulfK5nD8n fu+0dixws1mT1+AaAPBIBGAAUCsej0e1TP8eHx9/9ve/l1uT6V/4zcO7YTmOM3H9 +pZ1mi/scYk/iGkY4oJZBQ0AOvn96wEAulosFgtHIoODg6oHsm37y7/9TW5NkTHS 6TTTv/Abx7ab9+uGNTs93Wq1/B99+9bfsJZpcrQYAOjXBV8SANC9EqOjUfVHH7Xb 7f/z7LMnT5+WW7ZSqbBBEf7UajREhrz9P64sL2fT6QH1vzQ9Oc/zTMNwXZeJXwDo CAIwAKgSi8Ui0aiGjYiO43zx17/Krcn0L/xM3JmNWu1Wc/LMwsLq6qrfTjm6L2vd xvt4AQCkIwADgCrJZDIciageRWSAF15+ef+BA3LLMv0Ln7Mta7FYXJib64ro67qu aRhV+l0BQKcRgAFACW1HHzH9ix4k8uS1K1fqtZr/02+73bZM07Zt1jwDgB8QgAFA ibGtW4eHh1WPIp6t33jrre07dsgty/Qv/CyXyczPzvo/+vat/z5lmiYHHQGAfxCA AUC+eCIxMjKiYSDP8z776ivpNZn+hT8ZhnH1558d2/Z/q2dOOQIAf/L79wcAdB1t va/EE/Zf3n8/mUzKLcv0L/xpenKymM9reGc9OU45AgDfIgADgGSjyWREfe8rYUt/ //nPPpNbk+lf+FCtWr12+XKf72d9+26dcmSaLhO/AOBXXfBdAgBdRFvvK/Gc/f5H H8UTCbllV1ZWKpWK3JrApon7/MYvv6xWKl2x45dTjgDA/wjAACCTnt5XfetJ+70P P5Rb03XddDp962xVoONKi4uTExNdEX3XTjkyzerqaqcvBADwCARgAJAmkUhEtfS+ ch3n/OefDw4NyS27vLy8yhM8fMBxnKuXLhmG0RXNrjjlCAC6iN+/VwCgW2jrfSXs 2r37lddfl1tTRI5MJsP0LzouvbCQnpvrimZXnHIEAF2HAAwAciRTqXA4rGEg8cz9 2VdfSV8XWiqVaFqLzmq1WlcvXXJdtysmfg3DoNkVAHQdv3/BAEBXiMfjUS29r4SD hw798YUX5Na0bTuTycitCTyWyYmJpWKxKyZ+aXYFAN2LAAwATyoWi4XC4SHZO3Lv y3Xdz776SnrSXlxcbDQacmsCG7RaqVy/etX/s759NLsCgO7XBV82AOBzo6OjkWhU z1gnT5/+9W9+I7emeKDP5XJyawIb4XnetStXatWq/1s9t9tt8U5xaHYFAF2OAAwA TyQWj0ejUW2P7xe++EJ6zUKh0Gq1pJcFHm5p/ZSjAd9HX0Hk3rVmV6x5BoDuRwAG gCei7eDfdrv9x+efP3TkiNyyhmHk83m5NYGH66JTjjzPMw3DdV0mfgEgGPz+xQMA fqbt4F9hcGjozPnz0svmcjnTNKWXBR4km07Pz852RbMr89YBv0z8AkCAEIABYJN0 HvzbbrffeOut7Tt2yC3baDQWFxfl1gQeROTJK5cuObbdFRO/rVaLA34BIHj8/g0E AL6VGhsLhUJ6xhJh+72PPpJbU4TqbDZr27bcssB9zU5P57NZ/0/8rjW7MgyHA34B IKAIwACwGfFEYkTX4mfXdT8+ezYqu9F0tVotl8tyawL3ajYaV37+WSTLTl/Io9nr za5Y8wwAAUYABoDHFovF1jo/65rL2r1nz8uvvSa3pud5mUxGRGu5ZYG73Lxxo7y0 5P9TjljzDAA9ggAMAI9N5+Jn8Vx+4YsvpOeHlZWVSqUityZwp+rq6rUrV/y/3ZcD fgGgp/j9awkA/Ebn4mfxaP7s7343fvKk3LKO42QymXY3LElFNxK31o2rVyuViv8n flnzDAC9hgAMAI9BZ+dnYWh4+NNz56SXLZVKNZ74ocZyuTxx7Zr/o6/neUarVWXN MwD0GAIwADyGsbGxYY2Ln99+7z0xotyylmVls1m5NYG+9Tv22pUrtWrV5+m33W5b tw74Zc0zAPQeAjAAbFQikYjqWvws7Ny169U//Ul62UKh0Gq1pJdFjysvLd28ccPn 0VcQ0dcS0ZcVEADQqwjAALAhsVhsJBbT1tGn3W6f//xz6XGi2WwWi0W5NdHjXNf9 5fLlZqPh835X4jpNw2DNMwD0OF9/VwGAf2zdtm1oaEjPWCL9/vH55w8dOSK9bDab tW1bbln0sqVicXJiQtuu+M2hzzMA4DYCMAA8WjyRiEaj2ia4RmKx9z/6SHrZarVa Lpell0Vvcl33yqVLRqvl84lf27Yt06TrGwDgFl9/aQGAH8Ti8Ugkom2OS+SKMxcu SD9n2PO8dDot/i23LHrTYqEwffNmv78nfsXdbhqGeEMx8QsAuI0ADACPkEylwuGw nrHWDv79/e/HT5yQXrlcLrP7EU+uWyZ+rXU0uwIA3MXX314A0HG6Fz+PjLz/8cfS y3L0EaToionftWZXplldXe30hQAA/IgADAAPFIvFItGotsXPnueduXBheHhYemWO PsIT6oqJXw74BQA8kn+/xgCg41JjY9L34j6IeHb/w3PPHT56VHrlRqOxuLgovSx6 R1dM/DqOY5pmjXX+AICHIgADwP0lRkej0ai24ZKp1Nvvviu9rMjVmUxGZAPpldEL XNe9+vPPrWbT5xO/pmGIm5yJXwDAI/n3+wwAOkhz52fxBH/+88/7+/ulV65UKisr K9LLoheUFhdv3rjh8zN+OeUIAPBYCMAAcLdYLBYKhYYU7MW9L8/z/vTmm0/t3Cm9 suM4mUxGpGvplRFs4p785fLlRr3u54lfTjkCAGyCf7/YAKBTRpPJSCSibbg9e/e+ 9OqrKiovLi42Gg0VlRFg5VLp5vXrKtYjSGSZpmXbnHIEAHhcBGAA+F/i8Xh0ZETn xNeFL75QUbbVahUKBRWVEVTtdvva5cu1Ws3PE79rpxwZBodaAwA2x7/fcACgXywW C0cig4ODeobzPO+jM2dUtNoSSSabzdq2Lb0ygmq1Url+5coWH0/8csoRAODJEYAB 4H8kU6lwOKxnLPE0//Svf/2rZ55RUZzeV3gsE9euLZfLfl72zClHAAApCMAA8F/i iUQ0GtW2+HNoaOjT8+dVVKb3FTauUa9fvXSpz8drnjnlCAAgkX+/8ABAJ83nHrmu +9lXXykK2/S+wgZNT04u5vP9Pj7oiFOOAAByEYABYG3r73AoNKzr3KN2u/3SK6/s 3b9fRfFms1ksFlVURpCYpvnzjz+2Pa/TF/JAa6ccmabLxC8AQCoCMAD0jY6ORhR0 onrIcH95/30VlUVmyGazjuOoKI7AyCwsLMzNaVvvsAnWOk45AgBIRwAG0Os0n3tk 2/aXf/ubouLLy8urq6uKiiMAXNe9/OOPpmn69qAjz/MMw/Bcl4lfAIAKPv3+AwA9 NJ97JNLvh59+mkgkVBS3LCubzaqojGAoLS3dvH6diV8AQC8jAAPoaamxsVAopGes drt94tSp3/z2t4qKFwoFwzBUFEe3E7fHtStXatWqzyd+q6xfAAAo5tMvQgDQIDE6 GtW49VeEkItffqmoeK1WK5VKioqjq4l74+rPP/f7Nfr2rXfksi2LNc8AAA38+3UI AEppPvfItu2Pz56NxWIqiruum8lkPB939EWnzE5NFfL5/v7+Tl/I/bXb7VazWa1W O30hAIBeQQAG0ItEEA2Fw0NDQ3qGEwH12d/97uTp04rqc/Av7mVb1qUff3Qdx7fL nvvWfxgqs3IBAKCRf78UAUCdZCoVDoe1DTcwMHD24kVFxTn4F/daLBSmbt70c7+r WwzDqKysdPoqAAA9hAAMoOckEolINKptWswyzfOffx5Sk7c5+Bd3EbfEL5cvN+p1 P0/83tZqtVYrlU5fBQCgh3TBtyMASKR566/rui+/9tq+/fsV1efgX9xprd/VpUu+ 3fF7r2azSednAIBOBGAAPUTz1t92uy1GfP/jjxXVN00zl8spKo6uMzc9nc/luij9 Co1Go0YHLACARgRgAD0kmUyGIxFtw1mWdf6zzxQtfhbpWqRfMYSK4ugujuP8/OOP tmV1xbLnOzXq9Vqt1umrAAD0kC77pgSATYsnElGNW39FJvnLe+9t3bZNUf1KpbJC 9yD09ZVLpYlr1/zf7+q+6vW1BNzpqwAA9BACMICeoHnrb7vdPnb8+O/+8AdF9S3L yuVyYhRF9dEtRPRdLpe7a9nznQjAAADNCMAAgi8Wiw2HQsPDwzoHvfDFF4oqi9yb z+dN01RUH11B3AA///BDt/8IwhJoAIBmBGAAwTeaTEb0bv09e/GiuhFXV1eXl5cV FUdXWCwWpyYmunTZ851oggUA0IwADCDgNG/9dV33+ZdfPnTokKL6tm1ns9lun/fD k7h29Wq1Uum6flf31Ww0qgRgAIBGQfj6BIAH0b/1V+m5R6J+oVAwDENRffhcMJY9 36nVbHKQNQBAJwIwgMDSv/VX6blHfSx+7m2BWfZ8J8MwKjQzBwBoRAAGEFiat/46 tv3+Rx+NplKK6rP4uZddv3p1NSjLnu9kW1a5XO70VfS0eCIh/s1ObAC9I2hfpQBw i+atv57nPf2rXz3zm98oqk/n554lIuJPP/zQ9rxOX4gS4o3TbDTq9XqnL8RHYrGY nr+QWDw+ODgYDoetdZxHBaBHEIABBJDmrb+CGOvsxYvq6rP4uTeVS6WJa9cCtuz5 LpyEdC8NGTgxOio+JG//RMhadAC9gwAMIGjEs2MoFBoK0NZfUT+Xy7H4uddMTUws LS729/d3+kLUarVaq5VKp6+ih4hPSPHxKD4k7/xfep5nmiYvBIBeQAAGEDTJZDKs ceuv67p/euutnTt3KqrP4uceJG6qSz/8YFtW8Db93ottwDo9ZHWMuOsMw2AzMIDA C/43K4CekkgkIhq3/op0evDgwedeekndEJVKZYWlib1EJJCrP/8c+Inf28SbaG0T MNuA7yF9IfQjPx7ZDAygFxCAAQSH/q2/Xrv92ZdfqqtvmmYul1NXH36TXlhIz835 bdOvyKie56m7qmazWeU04PuRlYFFncGhoVAo9MgfB03DsG2b3yMABBgBGEBArG39 DYeHhoa0jWhZ1tmLF9WdtCQih0i/4mFUUX34zdWff67Xan5b9uy67lM7d9aqVXXr 8FkFrdRjfTayGRhA4PnrWxYANi2ZSoWVtaG6l0gFL7/22r79+9UNISJBlf14vcEy zZ9++KHPh33O2u2j4+MiO5WWlpYWF5UN0m40Gqy8VSEej0ei0cdaUS8+3EzD4MMH QFARgAEEgf6tv6mxsbfffVfdEK1Wq1AoqKsP//DnWUee5yVTqT179976H13Hmbhx Q91bzGi1Ksw6PsCmF0LfddbRxtmWZbIZGEBAEYABdD39W38dxzl74YK6c49c181m s+LfiurDP2anpgr5vN9aXrmed/jIkWg0euf/8urly+reZSJvNxsNtp4+yONm4Pue dfRYTNMUMZhXBEDwEIABdDfxnBcOhwc1bv0VD4Wfnj8fHRlRN8Ti4mKj0VBXH37Q brcv//RTq9n01aZfcVXiDXXoyJF7r2p6ctKyLHVD0wrr4TaegaX8JijuBMMw2AwM IHh89KULAJuQSqXUzcTey3Pd5158UcQDdUOIZ9ylpSV19eEHIkn+9N13nb6Ku7mu u2fv3tTY2H3/r8vlclHlsnzHcYxWiynHJyRxP8jaZmDT5FcJAAFDAAbQxRKjo3et 0lSq3W6LEd/94AN1Q9i2nc1m2z5shgR5ViuVa5cv9/tp06+45fr7+48ePz44OPiQ /59frlxRuteg2WjQe+khHj4JvPGzjjZOfCJZplljMzCAACEAA+hWm+hu+oQc2z57 8aK6CWcRMPL5vLrDZuAHmYWF9Py8rzb9uq67ddu2Xbt3P/L/88b1623PU3clIm6V SyV19QPgQRk4Fo+L6KviHDg2AwMIGAIwgK4knvbWtv4+eLZKOvEI+PG5c+LpU90Q KysrNMINtmtXr1YrFV9t+hXp98jRo5GNraRYLBZVB1QmgR/p3gys9NfAdrttGgYf TQACw0ffwQCwcamxsSdpcPq4PNf9wwsviJygbgjDMPL5vLr66CzP8376/nvHtjt9 If9DBJvhUEjc1RsP5BpWQdu2LeIW840bt+mzjjaOzcAAgoQADKD7jIoHPr1bf+OJ xHsffqhuCJGOstms4zjqhkAHifDw03ff+W3id+euXdu2b3/c/+DEjRue4gO6mAR+ pFuTwGtnHQ0N6ekCyGZgAIHhoy9jANiIeDweHRnRmSXEk985lVt/haWlJaa8gmq1 UvlF5Qm6m9But48ePz48PLyJ/2xlZSWfy0m/pDuJcN5qNnlHPJz4JAzp3QbCZmAA wUAABtBNYrFYJBrVmSVE+v347FmlW3859yjActns/PS0fxo+e543EosdPHToSYpc uXx5UPGfSATgVRbcPlgymRTpV/OaAjYDAwgGAjCAriFS6HAotLlpq83xXPf1N9/c uWuXuiE49yjAJicmyktL/ln57Lru3n37kqnUE9aZnZkxWi0pl/QgIqg3Gw0mG++l /2PwTuIj0WAzMIAu55dvZQB4pNFkMhKJaBtOhNLTzzzzzK9/rXSIXC5nWZa6IdAp ly9datbr/km/4m47Oj4u5Zgc27Zv3rih+iQnwzAqKytKh+g6+pfA3GttM7Bl1dik DaBr+eaLGQAeKp5IRKNRnXEimUq9/e67SodYXl5mnWfweJ7347ffuoo7RW2cuJ5Y PH7g4EGJNSeuX/dUHgjct/7zULPRoOvSbfpPPn8QyzQt267z0gDoTgRgAF1APL5H IhGd8x4iaZ+9eFHps2ar1SoUCurqoyNENvjx++/98+Uqcvi+/ftHk0m5ZUUuTc/P q/5ByrbEX6fJQug+LWcdPRbm5wF0L798kgLAg8RisVAoNKRz66/nvfP++0++VfIh RCzJZrP+mSSEFPVa7fJPP/mq4fOx8XFFjYJ/uXJFw2xks9lkx2kqldJz1tHGiQ9J 0zBYwAKgGxGAAfhdMpkM6936++tnnz11+rTSIYrFYktxGyFoVi6VJq5d80n6FffY yMjIgSfr9vxw4s+7WCyqq39Lj3fDWvv5LxyWsnNbOsdxTNNkMzCArkMABuBr+rf+ bt2+/c9vvaV0iEqlssLqwWDJ53Jz09N+2J/Zt76+YPeePWNbt6oe6KqW841FylpZ XlY9ig/F4vGoPzb9Poi1js3AALoLARiAf+nf+ts/MHD2wgWledswjHw+r64+9Juf nc1lMj4JKp7nHRsf13NMTiGf1xNNG41Gr8006v/tb3PEB5pj2z07RQ+gG/n9gxVA z9K/9k8kh/c//jgej6sbwnXdXC7nOI66IaCZfw77bbfb4i1z+MgRnRdz9cqVAfXJ X7xxWs1m76Ss0WQyHA774aZ6pLXNwKa5Wql0+kIAYKO64LMVQG9KplJhjX1fRHj4 v3/845Fjx5SOUiwWm82m0iGg0y8//1yr1fwQVERE3PHUU+IfzeMWC4XlclnDQD2y EDoWiw0LoVCnL+QxOI5jmWa1x6boAXSvzn9nA8C9EolEdGRE54i7du9+5fXXlQ4h HhDLWqIC9Lj0/fcilXX6KtaI9Hv4yBHNb5nb9OwE7uuBjtAi/YYjEUVdu5ViMzCA LkIABuA7+rf+Dg0NfXr+vNIhRFLK5/PtdlvpKNBDvI4/fvutX5ayb9lyfHy8g92n S0tLi8WihmnwtY7QzWZQU1ZcfO75u+XVw5mGYbMZGEA3IAAD8Bf9cyDiqfrjM2fE o6fSIbLZrF/yEp6MeDV/+OYb8e9OX8j6WUex2IGDBzt9IZrOBBZExBJBK3gpKzE6 GolE/LCWftPE3WgYBpuBAfhfF3/UAgikVCoV0rj1V8SYF195Zf+BA0pHWVxcbDQa SoeAHq7rfv/vf3f6KtaIK9m1e/fWbds6fSFrqqurmXRaT35rtVpBSlmxWGxwaEhn vwN1xD1pGgabgQH4HAEYgI8kRkejKmdi73Xg0KHnXnhB6RBs/Q0M27J++PZbP0zT ea575NixcCTS6Qv5HzeuXdOzwl+M0mw0aoFYCK2/171q9vpm4GC8OgCCqvPf4gBw Szwej46M6EwX4XD4ozNnlA7B1t/AsEzzR5F+fbBFU7xHjp844bfNokarNT01peeq gnEqkv5mB3qIDz0Rg7v91QEQYARgAL6gf+uvCKWfnj8/PDysdIhMJsPW3wAQ6feH 777r7/Tcr7ijoiMjBw8d6uxlPMjM1JS2tthr84ym2b0pK55IRKNRP6wmkI7NwAB8 LoCfvAC6UWpsLKTx6EvP8157441du3crHaVcLrMdLgB8kn5d131q587tO3Z09jIe Qrytrl29qm1K02i1Kt2ZspLJZCgcDmT6vWVtM7BpBvvMKgDdK7AfvgC6iOatv+12 +/iJE7/9/e+VjtJsNovFotIhoIFP0q+zftLvSIdO+t24YqFQLpX0RDvxRm41m931 G1MsFhsOhZQuPPEJNgMD8C0CMIAO07/1V4z47ocfKh3CcZxMJsPW327nk/Tred74 yZM6Nwg8iWtXr2p7O4u/GZGBuyVlBXXT74OsbQa27aCe2wygexGAAXSSeCIMh8Oa n+zPXLigdES2/gaDbVnff/NNZ3tNiXtJ3KvHxse7aLlsq9Wa0dUNq+9WQ6xWy/8p K8Cbfh+EzcAA/KmHPogB+JDurb+u+9a77yo9OlXk3lwuJx7K1Q0BDcQr+N2//tXZ uCLyQyweV31ItQpzMzMilGobzrZt0zB82xArFosNDA6GA73p90HYDAzAh3rusxiA f4yOjkb0bv19+plnfvXrXysdIp/Pa2uEC0U8z/tWpN/OXoPr7vB3y6uHEG+Ea1eu 9Gtc62uZpuXLo3di8fjwuk5fyH9pr9O5rsG2bfHqdMsydQC9gAAMoDP0b/1NplJv v/uu0iFo+xwAIv1+/803bc/r4DW4rnvg0CHxHungNTyh6upqJp3W+QY3DWNlZUXb cBshXsGwnzb9int79549W/r7xUszoDEDsxkYgK8QgAF0QCwWi0ajOieIxDPf2QsX lM57NBqNxcVFdfWhh0i/bkf3b4v0e2x8XOfWAEWmp6YsvashfHUwUiKRiPhp06+4 r8ZPnhwaGhL/fSGfLy0taUvmbAYG4Ct++VwG0FPGxsaG9Z76++4HH4wmk+qGsG07 m83S9rnbXfr++86uYBe30PiJEwNd0vD54TQfC3xLq9XqeNCKxWKDQ0PhcLizl3En cV+dPH36zjQ+NzvbbDS05XM2AwPwDwIwAN30b/199ne/Gz95Ut0Q4kE/l8uJDKxu CGhw7cqVWkdXsIus2F0Nnx+pWq2m5+c1d9LubAaOxeOhUOjWRKsfiA/ASCRy6MiR u/734vNqdmrK1bjUn83AAHwiON+yALqC/q2/23fs+NObbyodYnFxsdFoKB0Cqk3f vLm0uNip8LmWUqLRQ4cPd2R0pebn5pra3x2dysDxREKkzc4enXUncV+JD8AHtVKr rq6mFxZ0Xu3aZmBf9ioD0FMIwAD0Wdv6OzKi83lrYGDgzIULSlNNtVotl8vq6kOD bDqdnp/vYPodTSb37N3bkdE1+OXKFf2ZUPN+YB+edeS67pGjRx++3KZYKCwtLrIZ GEBP8cvHNIBeoHnrr3j+++jTT0diMXVDiIe5fD6vrj40KC0tTd640alZO8/ztu/Y seOppzoyuh6maU5OTOhvhmwaxlrzYfXzjX4766hv/dPv1NNPb+Sunp+ba9TrbAYG 0DsIwAA00b/194/PP3/vzjeJxJNcNpsV/1Y3BFSr12qXf/qpUwfViJtnz969qbGx joyuU7FQKJdK+mdHrXVKD+CJJxLhcNg/Zx31rTe9P7HhrgeO48xMT+vsfG6vvyhs BgbQKQRgADro3/q7e+/el199VV19EbCLxWKr1VI3BFSzbfu7f/9b54GodwrAYb+P ZeL6da8TpyuLgGcYhooM7MNlz+JzKRaP7z9w4LH+UyKLLszNad0MrGtyHgDu5ZeP bAABJh4TI9GozhmS4eHhT86dUzrEysqKf04cxSaIqPDtv/7V16GTq0QqO3b8eDgS 6cjoHSEC/7VffhnsxEypCN5Gq1WV2uJ7rdvz8PCQn5Y9iz/m7j17NregYGlxsVgo sBkYQC8gAANQLpVKhTQeiem125+cOaM0WjSbzWKxqK4+NPj5xx+NDk3giyh4bHw8 pHE/vE/on2m8k0hcjqRZx0QiEfZTt2fBdZxjJ048yU2VXliorq5q+0M5jmOZptxf JQBgIwjAANRKjI5GNW799TzvxVdeedwVgI/Ftu1cLteRxZyQZermzVKHDj0S6Xf8 5En/nBOrWS6braysdGrNsPjLFzH4SU57jsVig0NDImf6Z9lz3/rn3snTp58wu4q/ nJmpKUfjZmANO7QB4F4++vgGEDyxeFykX53zJPsOHHjhpZfU1RcPmvl8Xjy0qRsC qi0WCtOTkx2ZvhP3z4mTJwcGB/UP7R83b9zoYOu4drst3r9rG1AfP3fF4/FQODzo p5dP/HFEID8+Pi6lWr1eX5ib05ntJU7LA8AGEYABqBKLxcTDos6ZrlAo9PHZs0qH WFpa4lmtq7VarUvff9+R9CuyyolTp3y1brYjPM+79ssvneo9dvsaTNN0HWfjb+fE 6Gg4HPbVy6fiBOm1zcD5vLbfaNZeCMNY5VQkABoRgAGokkylwpq3/p49q3TEWq1W KpXU1YdqIjB88/XXHfnmI/3eqVMnA9/FdV3Lsh4Zg2Ox2Nohvz7bsy2i4959+0QA ll5Z/2ZgcT88ybp0AHgsBGAASsQTiWg0qm0pnXgWfPnVV/fu369uCPGIls/n2x1q GgwpOtX4ivR7r9VKJZNO++HvRHx6WKbpuO59F0X78JjfPsV91NY2A09PO7atovh9 ib9/a1OL0gFgEwjAAOTTv/X3wMGDz734orr64okwl8vpbA8D6ebn5vKZjP7eRaTf B8nncivLyz7pJiVeJtu2xXvcE0l4fULYn/2u+iS1vHq4RqMxPzurdTNwq8XBcgD0 8NdnOoAAWFsuGAoNazweMxwOf3TmjLr64sm4WCy2OnRkDqSoVatXf/5Zfwol/T7c 7MxMpw6jehARL0USFjF4aHjYV/2u+tZvJxHIjxw7pmEs/ZuBDcOoshkYgHoEYACS jSaTEZVn8N5FPBF+cu6c0iNVV1ZWmJroauLZ+pv//E/Srz9NXL/OoWIbIW6nsa1b d+7apW1EzZuBbdu2TLPGQmgAihGAAcjUga2/r722d98+dUM0m81isaiuPjS4culS s9HQPKiGdarBIHLdtatX+Yt6ONd19x88mEgkdA4q7uHpqSmdm4FN07Qti077AJQi AAOQJhaLRaJRnd1iDhw69NwLL6irb9t2LpdjeqqrFfP52elpzds4RVw5eepUj5/3 u3Gu49y4dq3fZ42m/EPcTsdPnNC5r+Q2zZuB2+22YRirrLgBoBIBGIA0qbExpUuR 7xKORD769FN19UXuzefzlmWpGwKq2Zb13b//rbmFr4gr4ydP6jwBOwDEG23ixo1B MvD9iNupgzPkpaUl8Umo7aURbx/TMKqcigRAGQIwADkSo6PRaFTbcG3P++T8eaV5 e2lpiZV43e77b75x9fbudhxHxJWOTNZ1u1arNT056bcDhzqo3W6LD9WDhw93+kL6 Fubna9WqthBuWZZtWWwGBqAIARiABJrPPfI875XXX9+zd6+6IarVarlcVlcfGqQX FrILCzoXP7uue+To0YjGX4ICptlozExPk4H71j/ltu/YseOppzp9IWvExdy8cUPn KeiGYTi2zU+QAFQgAAN4UrFYLBQO61zwefDw4T8+/7y6+qZp5nI5dfWhgW3b3/3r XzqjlAgJ+/bvT4yOahsxkBqNxmzPZ2DXdQ8cOhSPxzt9If9DvC7Tk5PaPuc5FQmA OgRgAE8qmUyGNZ57FAqFPj57Vl198eiZzWbFv9UNAQ1++u47nfu3xfP6zp07t27f rm3EAKvXarMzM347g1cb1/PGT5zw4R7yQj6/tLio7XVZOxXJsmpsBgYgGwEYwBPR f+7RJ2fPqsvb7Xa7UCgYhqGoPvTQ3PlZ3DbJVGr3nj16husFPbsWur+///iJE5qb lm/c7MyMeGm07XbhVCQAKvj0ExZAV9B87pGIGc+9+OLBQ4fUDbG8vLzKorsu57ru N//5nzqzUyQS8UOnooAxWq2pmzd75ygp8fkWi8f3HzjQ6Qt5GNdxbt640cepSAC6 GQEYwOZpPvdo1+7dr7z+urr6jUZjcXFRXX3oce3yZZ39Y7ds2XLi1Cltw/UU0zSn JiZ64Xxg13V37drVFUvoq9Xq3PT0kK4+5yJyi9uAU5EASEQABrBJms89GhgcPHvh grr6lmXlcjmdbU6hQqvZvPTDD9qWaIrccurppzt4Rmvgib/hievXfbskWArxZzx8 5Eh0ZKTTF7JRuWy2XCpp2wxsratzKhIASYL8jQJAHf3nHn3wySexWExdfZF+bdtW VB/a6Dz4V+SWY+PjOhdB9KZ2uz05MeE4TiBjsPjTHT9xous6fk1PTpqmqe0VMVqt CguhAUgSwO8SAKqJIDocCg3rWgInHhCf/f3vx0+cUFd/cXGx2Wwqqg9tSouLUzdv 6nko59AjzTILC6urq0GabBefPKFQ6MixY52+kM2wLGtyYkLfb6Cua5gmpyIBkIIA DOCxjSaTEY3nHm3dtu3Pb7+trn6lUllZWVFXH9r86x//0PNELqKLeBfs2btXw1i4 bWV5OZvJBKM1tOd5Y1u37tq9u9MXsnnic3N+bk7bL6H2+kJondv7AQQVARjA44nH 49GREW0r38RAZy9eVJdqWq1WoVBQVBw6zc/OFnI5PWOJG3L85Ek9Y+FOpmlO37y5 pcvngV3X3bd//2gy2ekLeVKZhYVKpaLtJwnDMBzb5lQkAE+IAAzgMcRisXA4PDg0 pGc48Zj4zvvvp8bGFNW3bTuXy3mep6g+dPr6H/8Y0JKLPNc9SeOrjpqdnm61Wl26 Jdj1vGPHjwdm6/jkjRuO6+oZS3xWiwzMQmgAT6grvzwAdEoymQzrWvzcbrdPP/PM M7/+taL64lkqn89blqWoPnSam54uapnJd133yLFjOrcA4L5Wlpczmcxgty2H7u/v PzY+HqRfT0QiFRlY26+itr22FLrGqUgAngABGMBGaV78nEgk3vngA3X1l5aWWEoX DO12+1//+IeGdZhioNTYWFfv2wwSz/Omp6ZEHuqKqWBx84zEYgcOHuz0hci3tLiY z+WGdGVg0zBsFkIDeAJd8J0BwA9isVgkGtW210s8LJ69eFHd0SDVarVcLisqDs1m JifFI7iGgbb0959g66/PVFZWsul0v7+ngl3X3blr17bt2zt9IarMz87W6nU9exDE t4PRaq2yEBrAZhGAAWxIMpUKh8N6xvI87/U//1k8LyqqbxhGPp9XVBz6ff33v2v4 aUZkmJOnTg1023mtvUAkooX5+Vq16s8G0eLOOXTkyMjISEdGHwqFbNNUPYp4CW5c vy7+i+qBbnFs22QhNIDNIgADeLR4IhGNRrWtMzxw8OBzL76oqLjjOLlcztXVtQWq ZRYWsum06lHE8/3uPXuSqZTqgbBptm3PTk05ruurFdHizjl+4oS6xSwPMTAwEIlG +wcGjFbLUp+B67XazPS0voXQpmlbFguhAWyCj74kAPhTLB6PRCLaplbE89On588r Ki4eRvP5vKn+WRDafPPPf/apDzwiwBwbH1c9Cp6EyEJzMzP+mQQWnzahcPjI0aMd GT0UiQwPD9/6LUBcSbNe1/CrXy6bLZdKetL+2kJow1itVDSMBSBgCMAAHiGVSoU0 Ln7+8JNPRmIxRfVpfBUwK8vLE9euqZ7xW1v8fPq0f5IV7pXP5ZbLZf90VxYfZWPb tu1Sto/jIcSNGr6nX4O4nnqtpmGJ8vTNm6autmSO45imyUJoAI+LAAzgYXQufm63 27/57W9PnDqlqD6Nr4Ln+2++cR1H6RDittzx1FMBbl/U7dZ6Qd+8aTuOf1Y+u667 /8CBxOio/qFD4fBwKHTfvwrbslrNpuoLEIl0cmJC269FawuhbXst2wPAhvnl2wKA D2le/DyaTP7lvfcUFafxVfCIZ98fv/1W9aQfnZ/9rNlszk5N+aoFtAjkx0+c0LYV 9rb7TvzeRQRgW/3J5+VSKZvJ6PkboCM0gE0gAAN4IJ2dn5Wee0Tjq0C6/ssvVcU7 AEWYOXr8eCgUUjoKNqdYKCwtLvpnabr4EBscGjp2/Lj+ueiHTPzeSVxho1YTd7Xq 69F5KhILoQE8LgIwgPvTufhZPJC99sYbu3bvVlGcxldB9a9//EP19G8kEjl4+LDS IbAJ4k09NTlp69pruhHiQyyZSu3Zu1fzuBuZ+L2T67oN9QuGxd/GxPXrqke5jY7Q AB6LX745APhKLBaLjoxo6ygjnhpfevVVRcVpfBVIy+XyzevXleYfERVOPf20f/oq 4RbDMKYnJ331uohbZd/+/aPJpOZxNzjxexfTMMQ/ii7pturq6tzsLAuhAfgQARjA fehc/DwwMHD24kVFxWl8FVQ/ffedpXg3Y2psbGcnuvjiIZYWF4uFgn+WPfetz3Ye Gx8fHh7WOejjTvzeae1UpEZDdfc4IZNOV1ZW9LxYLIQGsHEEYAB307n42XXd9z78 UNHMSavVKhQKKiqjs0Tk+Pc//6n0wVrcmU8/84y6+nhcIrZNT01ZpumfZc/ikoYG B4+Oj2u+pHAkMvTfZ/xujngHNWq1tvpTkW5OTGhI2reYhrHWEZr1PgAexS/fIgB8 IhaLRTY7sfC4xOPXiVOnfvPb36ooLp6EcrmchnYv0C+Xzabn5pQOsXXbth1PPaV0 CGyc0WpNTU3paaq0QR3Z9DswOBiJRKR0vRafkK1G48nrPFyr2Zy8eZOF0AB8hQAM 4H9JJpPhSETPWCJpf/jJJyoqi2fTfD6veoksOkX1+memf31lsVgU//hq2XNHNv0+ +cTvXfScilTI55eKxUEtGVikess0axwLDOChCMAA/kc8Ho+OjGjr/PzJuXMqdhq3 2+2lpaWG+skNdMrXf/+70jjE9K9P+LDbc18nNv2uTfxGo9L7fmk7FWl6aso0DD0v omEYDguhATyUj75RAHRWLBYLhcPa1qo9+/vfj584oaJ4pVJZWVlRURl+sFwuT964 oa6+47q/YvrXB5rN5szUlK8mftc2/Q4PHz12TF8g37IlHImoC9uu4zTUZ0XLsiau X1d0zPtdRJ4XGbjKQmgAD0YABvBfRkdHI9GonrHi8fi7H36oorJ4aC4Wiyoqwyeu XLrUVDm9PxKL7T9wQF19bEQ+l1sulaRsdpVFJKuxrVsVHVd+X4NDQyL9qj7wSc+p SMVCQfyj5wdWa12dhdAAHoAADGBNLB6PKlhid1/tdvvMhQsqnoTEQ08ul9PQ2hQd 9K9//EPdjeq67snTp30169hrxEswNTnpOo6vlj2Lqzpw8GA8kdAz3Jb1id8hLaus tZ2KNDM9LQbS8+YyWq1KpaJhIADdyEffLgA6aGzrVj1b2sTD1h+ff/7QkSPSK4sn VJF+HV1HbqAjxKv87ddfqwvA4un8uJqV+diIarW6MDfntx8gxKfWsfFxPbOXgsi9 4XB4i8aW157nrc2XKv7pUHw4T1y/rudnVvFBYRpGlWOBAdwPARhAXyKRiI6M6Bkr NTb21jvvSC8rnlALhYKhfiEfOiuXyaTn5xUVF3fR3n37EqOjiurj4dILC9XVVT0B aYPELSGy6OGjR/UMJ0JvJBLR0zD5LrZltZpN1aMsl8uZhQU9M9umaa4dC8xCaAD3 IAADvU7zwb9nL15U0QqlVCpx9EUvULoBmNOPOkUElcmbN/32RCLuhx07d+7YsUPP cMOhUCgc7uDC71ajIV4I1aPMzsw0Gg0NRzpzLDCAB/Hb1w0A3ZKplIqziO4lHkde ePllFe2FqtVquVyWXhY+9O9//lNdQghHIocOH1ZUHA9SWloq5PN+W/Ys0u/ho0ej WvoC9g8MRCKRAS1Nkh9CfETXq1XVPRTEX+zE9et6cv7ascCWVWMhNID/jQAM9DSd B/9u3bbtz2+/Lb1sq9UqFArSy8Kf1HXAEs/9Iv1qa4SOvvWtp9OTkyKl+KrfVd/6 UuRjx4/ryeShcHg4FPLJ34Bj20pbrN+icyE0xwIDuJcvPnABdITmg3/PffaZ9AdK 8eicy+XEY7TcsvCnWq127fJlRcVZ/6yZeDXnZ2f9NvErPkwSo6P79u/XMNbA4GAk EvHVUU996/2TLdNUPcraQuh6XcOrz7HAAO5FAAZ6l3jO07PAb23x80sv7T94UG5Z 8WQj0q+GTWvwibmZmWI+r6j40PDw0WPHFBXHXRbm52vVqq/6XfWt/wiyd9++ZCql eqAtW7aEIhE9jfcfl/i4btRqqn9VdB3nxo0b/VrmvTkWGMBdCMBAj9J58O/Y1q1v /uUvcmuKp7RisdhqteSWhZ8p7YD11M6d4kZVVBy3mYYxNTnpt+jbt/6D2vETJzSs iBFDiPTrw7+B21zXbaiPizoXQotvilWOBQbw3wjAQI9KpVIhXb2vVHR+LpfLnPHY a779+mtFHXpE+Dn19NM+2YcZYPl8vry05Ldlz9rOOurgKUePyzQMU/2pcrPT02sd odXfD47jmKZJNywAt/BlD/Qibb2vxJPlcy++ePDQIbllafvcm77++98VPSuLAHz6 V79SURm3iAQydfOm+Hv2268Mrus+tXPndvVnHXX8lKPHIj66m/W6+MtROoq4Kyau X9czGU43LAC3dccHMQCJdPa+Gh0d/cv778utSdvnnqUuAIu3w9Hjx1VURt/6Ytdc Nuu3id++9fR75NixSCSidBTxBw/rOmtdIs91NeybLS0tiXtDw/fRWjesVot1QwD6 CMBAD9LW+0o8cJy5cEFuoxfaPvcsx3G+//e/FU2gjSaTu/fsUVG5x4mEOT015fjv oKN2uz00OHjk+HHV04/hSGRoeNhvf/wNskzTUN9nYWZy0jBNDX9FpmmKbxC6YQHo yk9kAJsWi8cjkYiGuQjxfPnrZ589dfq0xJriYVqkXxGEJNZEt6isrExcu6ao+L4D B2KxmKLiPWtleTmTyQz6b+bT87yxrVt37d6tdJTBoaGwv5tdPdLaQuhGw1X8kWsa xs0bN/RsjW41m6sciQT0PAIw0FuSyWRY8Xq/W8Lh8EdnzkgsKB7FCoWCob4vC/wp s7CQTadVVKYDlnTir3RmetrSMq33uFzXPXTkyMjIiLohtvT3r038dkOzq0cSL+Xa lKma5nO35bLZcqkkvVfivWzbFrdljUlgoLf57psJgDqxeHxES+8r8cz04SefjEid UltaWqJ/SS+bnJhYLpVUVBaJ6OlnnlFRuTetVirphQUfbnltt9sDg4PHFC977q5m VxthWZbRbKoe5ebEhOqp5luMVstxHL5NgF4WnA9oAI80NjYmHs40DHT02LHf/eEP EgtWKpWVlRWJBdF1bly7tqrmHiAAy+J53uz0tOnLiV9xbalUavfeveqG6NJmVxvR rNdV7z0RiXRmakrDtLl4vxuGwZFIQC/z3VcUAEXiiYTSVX+3iee/sxcvSizYaDQW FxclFkQ3+uXyZXXda05K3azemyorK5l02p/xT2SeA4cOxeNxRfVF4F9rrd+1za4e yfO8Rq2m6BTu29ILC6uVioZbyDQMmyORgB4WzE9qAHfRdvSReE564623djz1lKyC pmnm83nVD17wvyuXLjUbDRWVt/T3nzh5UkXlHiHe9dNTU7Zl+TD+rS17Hhg4evy4 ulglcq/4dO3qZlcbIV7fluKF0OLFuqGs0d2d1o5EMowq3bCAXuW77yoAKmg7+mjb 9u0iAMuq5jhOLpdzXVdWQXSvSz/8YKppgSai0fETJ1RU7gXL5XI2k9HQvmgTRM5J plJ7lC17FqE3HI3688+uQrPRcGxb6RDidsosLAxJPTzvvjgSCehlBGAg+GKxWETL zjSv3T538aKsx0Hx8CrSr634eQvd4sdvv1V0MwwODR07flxF5WBzHGdmakr824cT v33ry54PHj6s7nSrUDg8HAr588+uiJ6F0NNTU0arpXpGXfwpxCgciQT0ph764AZ6 1mgyGVF/9JF4nvg/zz4ray+lqFYsFlutlpRqCIBL339vmqaKygODg8fHx1VUDrBi obC0uOjPHb+3uj0fPXZM0eUF4IDfTdPQEXrtWOCJCQ3z6uLPYlsWRyIBPYgADARc LB6PRqMantVCw8Mfnzsnq1qpVOK5BHf6+ccfDTU/iAz09x9nD/CGiXwyMzXVXu/8 1OlruY+1bs9jY7v37FFRPEgH/G6aho7Q2UxmuVzWkIFbrdZqpaJ6FAB+48dvLwAS JVOpcDisehTx0PnuBx+MJpNSqq2uri4vL0sphcC48vPPTTVdW0WQO3HqlIrKwZNe WKhWKv2+nPjtW1/2fPjoUUX9DoJ3wO/miE/7uvozhG5cv972PNWj2LZtWRZHIgG9 ptc/x4Fgi8XjIyMjGp7Ydu3Z88prr0kpxaFHuC91xyCJB/rTv/qVispBsrq6mp6f 9+ea5771Zc/Dw8NHjh1T8XE3ODi4tubZr392/SzTVLQc47ZKpbIwN6dhsl38QRzH 4UgkoKcQgIEgS42NhUIh1aOIR8/zn38uZZU1hx7hQW788ouixYqu6z79zDMqKgeD z5td9a2/gjt37dq2fbv0yuKPvLbmWX1T4u4iPqKbjYareCH0zPS0GEX1by7ixhbf O0wCAz3Fp19mAJ5cPB6Pqp/+FU9Cz/7ud+MytlBy6BEeYm5mppjPq6hMAH6IXCaz vLzs24nfvvUJ/KPHj6v4pY81zw/hua7qM4RELr1544aGncCGYTi2zSQw0Dv4WAcC a2xsbFj99O/w8PAnMnpfcegRHm6pWJyZmlJU/NDhw2H1ndK7S61aXZif93OvY/Gh MRKLHTx0SHplEbpCkYifY78faFgInUmnV5aXVWdg13VFBmYSGOgdBGAgmOLx+Iiy AzBvEw+gb7/3nkjaT1iHQ4/wSM1m88pPPykqnhob27lrl6LiXce27dnpaT+veRYc 1z1w4EBidFRuWfo8b9zaQuh6XfWanRu//KJhS8zaJLDjqJ7TBuAT/v1uA/Aktm7d qmHf2vYdO/705ptPXodDj7AR//7nPxVFsoGBgeMnTqio3F1EpMmk06uVip8nP8VF Dg4MHDl+XPpFsub5cYn021D80b1cLmcWFlR/nYk/iGkYVSaBgd7ApzwQQPFEYmRk RPUonuedu3hx8ImnSiqVysrKipRLQrB9/fe/KwpmbAPuW08auWzWz9G3b/2V2r5j x1M7d8otS5/nTTNaLcs0lQ4xPTlpmqbqHybYCQz0DgIwEEB6pn/HT578zW9/+4RF OPQIG/fNf/6nosrtdvvAoUMafjbyJ/E2XJidba83Pe70tTzMWr+rY8dCUg827+/v D7Hm+QmI906jVvNUntnbbDSmJidVv0ZMAgO9w9dfdQA2Qc/0r3hQPv/5509YxDCM QqHAoUfYoJ9//FFd051bp8gqKu5btm3PTU9btu3nZld969E3Fo8fOHhQblmRpYdD IZ/Hfv9zHKepeOJ0bna2XqupXp7AJDDQI/jQB4JmbOvWYcXTvyKy/vH55w8dOfIk RcSTdy6XUzpvgICZmZxcUrZewHXd07/6Ve9kIfHWm5+ba9TrPl/z3Lf+0hw4dCge j0usOTQ8LNKvz2N/F2k1m7Zlqasvvi8mrl0bUN8OmklgoBf0yjc90CP0TP+Ghoc/ frKjj8Rzhki/juPIuiT0gsrKingIVld/NJncvWePuvo+0W63s+l0xd+drm4Rlzoc Ch05elTiDxPiTx2ORFRHqV7T9rx6raZ0OY+eI5FoBw30AgIwECgapn89z3vrnXe2 btu26QriIalQKIjnDIlXhV4g7px//eMf6mJbL7TCyudypVJp0PfRt2/95di9Z4/4 TJNVUKRoEX0Hh4Z6Z55fJ8uyjGZT6RDXf/lFaf0+zgQGegPfAUBw6Dn7dzSZ/Mt7 7236Py4yzNLSUqPRkHhJ6B3ffv210lmmxOjonr171dXvoKXFxcVCoSsaHYuXWFzn 0WPHJE73ccSRamvHAjcarsp1PaWlpVw2q7obFjuBgcDjmwAIjrGxMfGQp3QI13U/ OXs2Eo1uusLy8vLq6qrES0JPuXHt2qrKQ7PE4/v4qVMB6wm8WCyKf/y/4PkW8SGz 46mnxD+yCg4ODYXD4a5I/t1Ow7HAEzdueK6rdAgmgYHAIwADARGPx6MjI6rnN3bu 3PnqG29s+j9eq9VKpZLE60Gvqa6uXr96VekQ4k104tQppUNoUywUSouL3ZL92u32 lv7+o8eOyfoBor+//9aaZynVsBGqjwVeWV5Oz8+rPudP/CnWdgIzCQwEFAEYCIhU KiX3eMx7eZ539uLFTT+btlqtQqEg95LQg77++9+VTmaKGDaaTHb1Qui1bfa5XHl5 eaB7uhy7rrvt/7N3J0xuXfed99EAGvvWC3dKFHdRKyWKuyU79iRTSSrlTGI7i+OZ 9zZVeeZ5JslTk5p6nql6RvZEXuNxLFEkm7tIimRv7B07cLfnALcbAnvFcs+59wLf T8ltdLNxzm10A/f8cM79n337Dh465EhrIyMj4vVQxCTWPCsm/vaK+bzU6xQePnig 1etSf7O6ptXqdSaBgUHFiQEYBKl0Oil/+ve111+//sknvd23Xq/PzMyw5S/6d+Pf /q0mc4op0Hyv58hrr+VyOam9yCBi5Itnzwryd0x1mGWdPHPGqQJ+XO7rLpFOKzKr Ya2trn799Kns6xQqlYroSGoXANzC6QEYBGKkHovHpXYhIsFf/fjHvY2qdV0X6deQ fOEWhsTiwsJXDx7I7qWx9+wbb6QzGdkdOaVWqz1/9qxaqfgr+orHeWJy8tDhw460 xuW+HlEqFqVWw/rq4UPxBy/1PQ4R44UC+yEBg4gADPheKpVKJJNByWsdT54+ffHy 5R7uKJLz7OysGEk4fkgYWr/5+c8VhByRzV57/fWs5+eBl5eW5ufmxBNN9ouAsxpX /I6MiBcWRyZ+ReyPxuOyN4lFh2RXwyoWCo+/+kr6JHC5TMlGYCARgAHfy2az/ZRl 7oQYqv713/1dD2+3izvOz89XKhUZR4WhdfPGjYqSnbREqpzct+/AwYMK+uqWoevT 09P5tTV/TfnaREDat3+/Iw/sSDAYi8XY3ddrZFfDEgG4XCpJ/eNvzgHXi0wCAwOH swXgb2qmf8+eO/fBhQs93HFxcZElZHBcIZ+funlTTeCxLGs0Ejl1+rR38tXiQoNp GP6a8rXZe/yePHXKgem7kZFoNBqJRr3zq0GL7GpYpVLpq4cPpU4Ci4OvVCp5JoGB gcM5A/C3TCYjArDULnqe/l1bW1teXpZxSMD//vWvVdZUMwzjyNGjY+PjynrcqlAo zM/N+e4q33biYTxw8OC+/fv7byoixGJ+fAtgeNTr9arMaliPHz0ql8tSnw61alXT dSaBgQFDAAb8bXxiwqnSqTs5ffbshYsXu71XqVR6+fKljOMBhLmZma+fPFHZo71L 7evHjiUlv+W0SSv3irDn36nOxkT66OiJU6f6jytUuvIL8UsvFYumtPKHxWJRZGCp k8CGYVSrVfZDAgaMX0+lAAJKdj+yTPOvf/KTbruo1Wqzs7NsegSpfvPLXwaVB0K7 dNOBgwfHJybk9SKG3YsLC2srK7V6XSRG/+Zem1PlxELhsIi+ISpd+Yeu6+ViUV77 IgBXmu8NyetCtG/oelHmTwFAMX+fU4EhlxsbE8NBqV2cOHXq0pUrXd1F07SZmRnT NCUdEmB78ujRy/l5t3oXoS4ej+8/eDCdTjvToK4vLy/n19aq1ar4dDAW94rXgWQy eez48T4zvHg0ovG47Kq/kKFSKomTgqTGC4XCE8nloMXB12s1ilkAg4QADPiVgvJX pmX99Y9/3FUXYrwr0q+84Q7Q7je/+IW7QdGyLPE3HwoGxZMxnclkstnOd+KpVipr a2vlUqlaq4n06+sVztsSD84bJ04k+qtRLx4TO/oO2IMzPMQTpChzCbGCPYHL5TKl sIBBwukE8Csx1O5zZLknMXi9cu1a59/PpkdQbObFi2dPn3onGtl5WNxoZNlgw0gz wlnNt5PEv1n2x+YXB2OOd1uGYUzu23fw0KF+GhEPUSQWi0Qi3vn9ojdSt0TK5/NP Hz+WOgksAramaZTCAgYGJxXAryYmJ6We8sU4/kd/+7edT2cF2PQIbvjXX/2KM5l3 rBe7Onmyzyt1oyL6sr/RoJC9JdLDBw+0el3eX4s4G4oMn6cUFjAoOLUAvpROp5Op lNQu9u3f/70/+qPOv391dXVlZUXe8QDbWl5aenD3LknJCwzTfP3YsUwm008jkebW vgM8PT6c6rVaVdrioKXFxekXL6S+IywOXqcUFjAoGDEAviS7/JVpmn/+gx90vsSa TY/goi8//1ze2BqdMAxDvCgdfe21fhoZjUSibO07oBqTwIWCJa044v07d0yZ+w5Q CgsYJARgwH8a5a8SCanbYKbT6T/9/vc7/OZqtTo3N8emR3CLSF+//dWv+t9gFj0w TTMSjR4/caKryyU2aUTfaJStfQebVq9XymVJjc/Pzb2cmwvLnASmFBYwMAjAgP9k MplEMimvfRFl/+iP/3hicrKTb2bTI3jBwvz8Vw8fshBaJfs9r2PHjyf7eDkSiSUa i/HmxTAQfzClYtE0DEnt37l9W+orQK1a1XSdUljAAGCsAPjP+Ph4JBqV175o/C9+ +MNOvpNNj+AdN7/4Qt78EjbRDePgwYP79u/vuQWi7xDSNa1cKklqfPrFi5WlpT6r r+1C1/VarVagFBbgfwRgwGdSqVQylZL6PvfFy5dPnj6957dZljU3N1etVuUdCdA5 8Qf5v3/1qwCTwJIZhpHOZF4/dqznVyGi7zArFQqGnElgTdPu3bnTz1L8PVUqlbXV VXntA1CDgQLgM9lsNi5z+1+RIv7mJz/p5DvZ9AheU6vVfv/b35KsJOn/cl+iL3Rd L0urpfz40aNypRKSVketXqvV2RAY8D8CMOAzsrf/fe3Ysesff7znt7HpEbxpaXHx wd27VBJ2lmVZIyMjx44f77wy/CZEX7SUikVD12W0vLa6+vXTp/JOkWwIDAwGAjDg J6l0OplMylv/LM7uf/lXfxXd6wJjNj2Clz19/HhuZoaCWE4RLwuHjxwZGx/v7e5U eMYmIv2WpE0C3797V2pRxkqlYrAhMOBzjA8AP8nmcvF4XF77nex+VKvVZmdn2fQI XvbowYPFly/JwH0yDePAoUOT+/b1dncRfMV/zMZjq3KxqMuZBG7shzQ/L+9K4Hq9 rtXrXP4D+BqDA8BPpK5/Fpn2O9/73qHDh3f5HjFkmZmZkVTCBHDQvamp1ZUVMnBv xHNc5N6Dhw71cueRkUgkQvTFLuRdCWya5p3bt+UttmcVNDAAGBkAviF7/bNo+a9+ /ONdvkGc+GdnZ+v1uqQDAJw1dfNmIZ8nA3fF0PWx8fHDR4/28LiNBIPRaHQ0EuEx x57kXQn85PHjUqkkrxQWtaABv+MUBfiG7PrPx44fv3r9+k7/alnW/Py8OPHLOwDA cffv3l1ZWiKPdUI3jPGxsd6ibzAUEtE3PDrKQ40OyZsEzq+tPX3yRN5qKWpBA37H iQrwjYmJidFIRFLjpmn+xY9+FIvFdvqGpaUlFn3Bj75+8mTmxQuW4+7CENF3fPzQ kSM9xNdwOBxpRl8ZB4bBJm9P4Ht37sgrVCGOuVqtFjghAr5FAAb8Qfb652g0+h9+ +MOd/lVEXxGAJXUNyPZybu7RgwfswbNVI/pOTBw+cqTre9oX+kYilHdGz7R6vVIu y2h55sULcc6SVwqLVdCArxGAAX/IZLM978DZifc++OCtt9/e9p/K5fL8/Ly8rgEF CoXC1I0bI8wDN1lNBw4e7KHCczAYjHChL5wg/ghLhYKMXYuqlcqD+/flrYKu1Woa q6AB3+LsBfjD2Pj4ntvz9kyMP/7mJz/Zdjhbr9dnZmbY9AgDQPyd3/ziCzEyHubk Jp7LI8HgkaNHM5lMt/cNj4rYGwmFw8P8AMJZ9VqtKqe0xMMHD7R6XdLfqq7rIgOz ChrwKc5hgA+kUql4IiFvAWc2m/3jP/uzrV83DEOkX0m7NQKuePb06Ytnz4ZwObR4 Okdjsddeey3W5V7iIjCL3CuyL9dRw3GWZRXzeRnvsb6cn5+bnZU3CVwul/Nra5Ia ByAVARjwgXQ6nUyl5LV/5fr1N44f3/RF0zTn5uZqtZq8fgFXVKvV219+qWvaMMxk imghnstj4+OHDh/uNsEy5QsFqpVKXcKJRtO0e3fuyLsMWBy2rutFOYWsAUjFKQ3w gWwuF+9y0qZzYnD8t//xP276ohg0LywslEolSZ0CrpudmXny6NEATwWLp7bIriL3 ZrPZru4oHpPR5pQvuRcKiD/Uopy1xI8ePKhLWwUtWtbq9QKXAQM+xLkN8IHxiYmI tA2Q0un0n37/+5u+uLKyskqJSww6MfK+NzW1urIySDHYLnAlQu+hI0e6+rmCwWAj 946OUtgZipVLJV3THG92fm7u5fy8pElgNkMC/IsADHhdKpVKplLypmIuXr588vTp 9q8Ui8WFhQVJ3QFeo2na/ampfD7v9xgsRuTxeFzk3q4qxtu5Nzw66vcfH/6l63pZ wlrier1+/+5diZshlctrXAYM+BABGPC6dCaTTCYlNb61/nO1Wp2dnZXUHeBZjbHy nTsFH8ZgkXsj0ej+/ftzY2Od3ysYCo2OjpJ74QXy9kN6eP++Ju1qf3G61DWNy4AB 3yEAA16Xy+W6rdrauWQq9Wd//uetT8VAYWZmRsYoBPAF8cf/9ePH83Nz4raXr4C1 S1tFo9F9Bw6Il4jO7ygSb1gYHaWkMzylVq2K/xxvdm52duHlS0mTwFq9gcuAAd/x 7tkdgG1iclLeRg7n3n77/Q8+sG8bhjE7O6tJuBAL8J2V5eWvnzwpl0qemiC135xK plL79u/vfGGI+BEaM73hsLjh5VSPYSapFJZ4Cj96+FDSOZTLgAGf4kQIeJrUC4At y/qLH/0oGo3at+fm5qoS3oAHfG1pcfHFs2elYjEYDLqSHkUwsAKBaCQyNj4+PjHR 4cytHXfD4iObGMEnJJXCunfnjox9hm3sBgz4ESdFwNOkXgAshsV/9eMf27cXFxdZ xwXsQox0Z6enV1dWatWq1DBsL28OhkLxeDwnjI110peIu+IuoWbqdSurA/3QNK0i Ye+9r588EWc3SUs5GpcB63qRsyfgK5wgAU/LZrPxbgq6dmXf/v3f+6M/EjfW1taW l5cl9QIMnlqttrSwIJ445VJJq9cbebWnzGln3YBdinl0VDzZU+l0JpPZfZpXdCS+ QcTdYND+/9AIiRf+J54OjeXETs/Wiqfq9PS0pFXQ9VqtrmkEYMBfOF8CnjY2Pm4v UZbh6vXrx44fL5fL8/PzkroAhkRjFiifF8+mSrks4rGuaY1wa+/J24y4I82I3Eir IrKGw+J5LeJuPB7fGlwbX2l+1Y61dtxd/9hMvGRdDCrx9NHqdWfbFM/Nu1NTkupg icbF853LgAF/4SQKeNq+/fslLdyyN0Cq1+uzs7Pyro8C0K7xXNvu+dY4GY/YHzgv Y3jpmlaWsAr6wb17hmE43myg+YwWoT1PAAZ8hRMt4F2pdDqZTEoaEIfD4T//wQ9m ZmYkDQsAAOiKyJPFfN7x92SfP3u2troq6d1kEYDXqIMF+AoBGPAuqRWwDhw4cOat t+pOLzYDAKBnMlZBLy8tvXj+XNJlwI06WJpWLBZlNA5ABgIw4F2ZbDYhrQLW2XPn cuPjkhoHAKAHMmpBizbv3bkj6TLgWq2mUQcL8BUCMOBdubGxWCwmo2XTNC9duyZp PRgAAL1p1IKWsKJY3m7AIv3WazX2EQR8hAAMeNf4xEQkEpHRsgjAVz/+WEbLAAD0 o1QsGrrubJtPHz8uFosy3vY1DKNarVIIGvARAjDgXfJKQIdHRy9cuiSjZQAA+lGr VsV/zrY5OzOzuLAgYxV0oxB0pZKnDhbgHwRgwKOkloDOjY2dfestGS0DANAPXdfL EmpK3b51KxQMOt5soJmBS6USlwEDfkEABjwqLQJwKiWp8eMnT+4/eFBS4wAA9EzS ZcBPvvqq6vTEckupWOQyYMAvCMCAR2UymYScPZDE2OKjK1ck1cMEAKBPMi4DFun3 8aNHktZVlUulPJcBAz5BAAY8KpvNxuXsgWQYxrVPPpHRMgAA/atWKvVazfFmb964 IWk34Eq5vMZlwIBPEIABj5K3B5IVCFy5fl1GywAA9E+r10WkdLzZL7/4QtLeCtVq dXVlRUbLABxHAAY8amx8PBqNymh5NBL58OJFGS0DANA/0zSLElYUywvAtVptZXlZ RssAHEcABjxqYnJS0kqtVDr99nvvyWgZAID+SaqDdevGjbCcE6umaUuLizJaBuA4 AjDgUfv37w/K2QR434EDJ06dktEyAACOKBYKpmE42+bdqSlnG2zRNW2RAAz4BAEY 8Kj9Bw4E5exYeOzEiYOHDsloGQAAR1RKJU3TnG3z8Vdf1eTshGQYxsLLlzJaBuA4 AjDgRSkhnZbU+FvvvpvOZCQ1DgBA/2QUgp6dnV2VdqVusVAoFouSGgfgIAIw4EUi /YoILKNly7IuXbsmaW4ZAABHiPQrMrCzbRby+efPnknaClikX5GBZbQMwFkEYMCL 5AVg0zSvfvyxjJYBAHCKrmnlUsnhNnX93p07ITn1NQjAgF8QgAEvSqfTSUkB2DCu fvKJjJYBAHCKoeslCSuK5RWCLjXyLwEY8AECMOBF6UwmmUzKaNkwjGsEYACAt0na CvjmjRuSthgslUoFCQcMwHEEYMCL5AVg07KufutbMloGAMApkrYCJgADIAADXpTJ ZBIEYADAsJIUgL/84otIJOJ4s0K5VMoTgAE/IAADXiQvAFuBwJXr12W0DACAg/Kr q463SQAGQAAGvIgADAAYcgRgADIQgAEvIgADAIYcARiADARgwIsIwACAYcY1wAAk IQADXiSxCJZpXv34YxktAwDgFAIwAEkIwIAXsQ0SAGCYsQ8wAEkIwIAXyQvAhmFc ++QTGS0DAOAUcbYqFQqON0sABkAABrwonU4nUykZLbMEGgDgfbqmlUslx5u99eWX 4XDY8WaFUrFYkJDYATiOAAx4USqdThGAAQDDql6vV8tlZ9vUdf3enTuhUMjZZm3F YiMBy2gZgLMIwIAXifQrMrCMli3Lunj1qqTTPwAAjqhVq+I/Z9vMr629eP58ZETK 6FekXxGBZbQMwFkEYMCL5AVg4a13301nMpIaBwCgf5VSSdM0Z9ucnZlZXVlxts0W AjDgFwRgwKP2HzgQDAZltHzs+PGDhw/LaBkAAEeIPGkahrNtPv7qK8dnlW2GYSy8 fCmjZQCOIwADHrVv/35JC5Un9+07eeaMjJYBAOifpE2A79y+LWn9s65pi4uLMloG 4DgCMOBRE5OTkrZqSCaT75w/L6NlAAD657s9kDRNWyIAAz5BAAY8amx8PBqNymg5 FA5/dPmyjJYBAOifjBLQwo3PP5d0Yq3VaivLyzJaBuA4AjDgUbmxsVgsJqNly7Ku fOtbMloGAKB/lXJZq9cdb/bLL76IRCKONytUq1V55bUAOIsADHhUNpuNJxIyWmYr YACAlxXzeXGqcrbNxibAU1OhcNjZZm0isa9JuGgZgAwEYMCjMplMIpmU0bJlWR9c vChpGRgAAP0Q0VcEYMebXV5ampudlVQEq1wq5SUcMwAZCMCAR6XT6WQqJanxo6+/ fuS11yQ1DgBAz+q1WrVScbzZh/fv67rueLO2UrFYkFC1C4AMBGDAo1KplAjAkt6r Fo2//f77MloGAKAf5WJRRlKVVwLasiwRgAUZjQNwHAEY8C55WwGPBIOXrl6V0TIA AD2TtANwQGYFLMMwFl6+lNEyABkIwIB3jU9MSDpbUwcLAOBBWr1ekbABUkDmDHC9 Xl9eWpLRMgAZCMCAd0ndCenDS5ckpWsAAHpTLpV0TXO+2XL56ePHkq4qYg8kwF8I wIB3ZbLZhJydkISDhw8fO35cUuMAAHTLMs2CnFrK9+7etZzeV6lFpOs8eyAB/kEA BrwrlU6npBWCjkQiH1y8KKlxAAC6Jan+s/Dl559HpG3+16h/RQlowD8IwIB3ifSb SCaDwaCMxrkMGADgKcV83pQzTyvvAmDTMMrlMiWgAR8hAAOeNjE5KW/bBi4DBgB4 hK7rZTkxUuoFwJqmLS0uymgZgCQEYMDT5NXBCnAZMADAMySVvwpIvgCYCliA7xCA AU+TWgcrPDp64dIlSY0DANAh0zSLcspfBWTuABygAhbgQwRgwNPS6XRSWh0s0zCu fvKJpMYBAOhQtVKp12oyWtZ1/e7UVDgcltG4UGoUwKICFuAnBGDA6/bt3x8KhSQ1 fuL0adG+pMYBANiTZVkFaZOoT588qZTLkho3DGPh5UtJjQOQhAAMeN3Y+HhU2uYN sXj8/Q8/lNQ4AAB7qlWr4j9JjUtd/1yr1VaWlyU1DkASAjDgddlsNi7tMmDDNK+x GRIAwCWWZRXzefFRRuO6rt+5fVvSZgpCpVxe4wJgwG8IwIDXSb0MWIw5zr3zTjaX k9Q+AAC7kDr9Oz09vbayImkDpAAXAAP+RAAGfEDqZcCsggYAuELq9G9A8vpnLgAG fIoADPiA1MuAxSn8GrWgAQDKySv+HJBf/5kLgAGfIgADPiB1N2Dh2IkTBw8dktc+ AACbSN37V3j81VfyFlcH2AEY8C0CMOADqVQqmUrJu4opPDp64dIlSY0DALBVpVzW 6nV57d/4/HN5i6csyyoVGyS1D0AeAjDgDxMTE6MyL2S6fP26vMuMAQBoJ847JZnl o2q12sP79+Wd10R0X1paktQ4AKkIwIA/ZHO5eDwur/2JfftOnTkjr30AAFpKxaKh 6/Lav3P7trxlU0KlUllbXZXXPgB5CMCAP6TS6ZS0zZAEyzSvsCEwAEA+rV6vlMvy 2m9s/3vrlrxlU0Jj9TMbIAH+RAAGfGNy3z551Swtyzp19qzoQlL7AAAE5G99JHz9 9GmpWJQ3AywC9uLCgqTGAchGAAZ8I5fLxWSugg6Fwx9dviyvfQAApG59ZJNa/irQ /BFWWf8M+BYBGPCNdDqdlLkK2jTNC5cuRWQOGgAAw0x27atA8+riJ48fSy3rWGos f2b9M+BXBGDAT6Sugg40rzR++7335LUPABhalmWVi0WRgaX2cuvGjfDoqLz2Wf8M +B0BGPAT2bWgTdO8fP16MBiU1wUAYDjVa7VqpSK1C9m7HwWo/wz4HwEY8JNUOp1M JqVu7TA2MXHmzTfltQ8AGEKmaRbzedm9TN26JfU9XMuySqUS9Z8BXyMAAz4zPjER kbm1g2kYVz7+WGrGBgAMm3KxqMvc+FfQNO3e1JTU9c/1en15aUle+wAUYIwL+Ewm m00kElK7OHDo0BsnTkjtAgAwPGRv/Gu7d/euZZpSuyiXy/m1NaldAJCNAAz4TCqV SiSTcpd4meaVjz+W1z4AYHiYplkqFKRu/Bto1qa6c+vWqMwVUoZhiBhfLBbldQFA AQIw4D+5sbFYLCa1i8NHj7527JjULgAAw6BcKumaJruXB/fuya4vXa1WV1dWpHYB QAECMOA/sjcEDjTfsL/KJDAAoD9qFj83pn9v3x6VefVvgO1/gUFBAAZ8aWJyUvaZ fv/Bg8dPnpTaBQBggDUqP4vEKHnxs3D3zh3ZvWiatrS4KLULAGoQgAFfUlAKi3LQ AICeWZZVLpUMyZWfA0qKPwcofwUMEIa2gC+lUql4IhEKhaT2MrFv36kzZ6R2AQAY SPVarVqpKOjozu3bst+rpfwVMEgIwIBf5XK5WDwutQtxyr98/brsmA0AGDDi9FFS crlsrVZ7cO9eOByW2otI8qurq1K7AKAMARjwq1Q6nUwmZb/tnUql3n7/faldAAAG iWVZpWLRlFyT2Xbzxg3ZFTEaP06pVKT8FTAoCMCAj42Nj0ejUaldmKZ5/sKFuOTr jQEAA6NaqdRrNQUd5VdXnz17JnuZUq1WW1leltoFAJUIwICPqZkEDofDFy5fltoF AGAw6JpWLpXU9HXj889lvwvM9C8weAjAgL+NT0xEIhGpXYjT/+k335yYnJTaCwDA 70zTLBUKlvx9j4S5mZnl5WXZbwHX6/XlpSWpXQBQjAAM+Fs6k0kmk7J7EWOZK9ev y+4FAOBfIvdWSiVd/r5Hguhl6tYt2e//CqVSqZDPy+4FgEoEYMD3JiYnZZcAEfYf OHD81CnZvQAAfErZvkfC3akpBb1omra0uKigIwAqEYAB38tkMgn5k8CGYXx05YqC t9sBAL5j6HpJ1Ta55XL58aNHCrboK5dKeaZ/gYFDAAZ8L5VKRWMxBZPAIv1+cPGi 7F4AAP7SqBRVKJimqaa7Lz//PCK59lWgOf1bq1aLqlI9AGUIwMAgUHQlsGWdOnt2 ct8+2R0BAHykXCrpmqamr5np6dWVFdm1rwJc/QsMLgIwMCDUXAlsWtaV69cVjDwA AL6g8tJfTdPuTk0pONlx9S8wwBjFAgNCzSSwkMnlzr39toKOAAAeZxhGSeEeubdv 3lRw6W+A6V9goBGAgcGhYE/gQHObx3fef1/kbdkdAQC8TPGlv0tLS7PT0woCMHv/ AoONAAwMjnQ6nUylFHTEtsAAgEqppKm69FfZxr9CqVgsKJzWBqAYARgYKOPj4wpq Ywpj4+Nnzp1T0BEAwINUXvorTN2+HVRSfkL8XMvLywo6AuAWAjAwUNLpdCKZVFCk yjTNd8+fT6XTsjsCAHiNyl1/hZWVlennzxUsfrYsq1wqMf0LDDYCMDBocmNjsVhM TV+XWQgNAEPGMs1isWipuvS3sfj55k01i5uq1erqyoqCjgC4iAAMDJpUKpVIJoPB oIK+cuPjZ1kIDQBDw7KsSrmsbNffgMLFz4ZhiB+tqHBmG4ArCMDAAMpms/FEQkFH pmmee+ed3NiYgr4AAK6rVaviP2XdLb58OTc3p2brI5F+19bWFHQEwF0EYGAApVIp EYDVjBhMy7p87ZqaCWcAgIt0XS8rnCDVNO3u1NTo6KiCvsSPVq1UmP4FhgEBGBhM mUwmkUyq6UuE7fc++EBNXwAAV5imWSoULMtS1uPNGzfUpF+hXCrl83k1fQFwFwEY GFjjExNqtkwU46HjJ08eOHRIQV8AAPUa5ZGLRcMwlPU4/eLF2uqqgk0NhHq9vry0 pKAjAF5AAAYGViqdTirZEinQrB3y0ZUravI2AECxaqVSr9WUdVcplx89fBgOhxX0 JbJ9qVQqsvURMDQIwMAgy+Zy8XhcTV/BkZGL166p6QsAoIxWr4tEqqw7lfseCZVK ZW11VU1fALyAAAwMMpXVsISx8fEz7IoEAAPEMIyS2tlRZfseBah9BQwlAjAw4NKZ TCKRULMQ2jRNEYAnJicV9AUAkK2xPLhQEK/tynqcn59fmJ9X875t48LmcrlA7Stg yBCAgcE3Nj4eVbWWzDSMi9euqblwCwAgj8iHlXJZ1zRlPVYrlYf374dVVX6u1Wor y8tq+gLgHQRgYPCl0ulEIqFsq95QOPzR5ctq+gIASFKrVsV/yrrTdf32zZvK3q41 DKNSqVD7ChhCBGBgKGSyWZGBlXU3Pjl5+uxZZd0BAJylaVqlVFLZ452pKZWj0nK5 nF9bU9ghAK8gAAPDQtm2wIHmxcCnzp7dt3+/mu4AAA4yDaNRF8qylPU4Mz29srQU VFWykY1/gWFGAAaGheKF0IZhfHjpUiwWU9MdAMAR6gtfFfP5J0+eKCseweJnYMgR gIEhonghtBUIXL52TU0BagBA/9QXvtI07c7t28oWKAVY/AwMPQamwHBRuRBaiMXj 73/4obLuAAD9UF/4aurWLZVnJRY/AyAAA8NF8UJoy7IOHj78xokTaroDAPRMfeGr +3fvGoahbKEQi58BBAjAwBBSvBDaNM0z585NTE4q6xEA0C0RDktqC1/Nzc4uLiyE VBW+CrD4GUATARgYRmPj48r2WgxQEAsAvG3gC18JtVptZXlZWXcAPIsADAyjVCoV TyRUvu8uRleXrl1TtvQaANChRuGrUknXdWU9iix6784dlZf+NhY/l8uNvZ0ADD0C MDCk0plMIpFQWaJ5NBL58OJFZd0BADpRrVTqtZqy7tQXvhIJv1wuF/J5ZT0C8DIC MDC8cmNjipcl58bHz547p7JHAMAutHq9Ui6r7FGkX8WrgarV6urKisoeAXgZARgY XqlUKhaPq7wEy7Ks195448jRo8p6BADsxND1ktpVwU+fPCmXSioXH+m6Xq1UWPwM oIUADAy1dDqdSCZVjkVM03zz7bfHxseV9QgA2Eq8GpcKBUth2ef5ubmFly8Vl58Q ebvAvkcA2hCAgWGneFekQLMYyQcffRRX2ykAoKWRDItF8WqsrMf86urXX3+tcs1R gH2PAGyHAAxA9a5IgmWaH129qngkBACwVcplrV5X1l21Wn1w9+6owsJXAfY9ArAD AjCAQCqdjsfjKpelCSPB4KWrV1X2CAAINJNhrVJR1l2j7PPNmxG1b7M2Lv2tVoss fgawBQEYQIP6i4GFWDz+/ocfquwRAIacrmnlUkldd8o3PQpw6S+AXRGAAazLZrOK r8sVY5SxiQk2RgIANUzDaNRDVlj46vatW8GREcXvrlbK5TUu/QWwAwIwgG+4cDGw ZR06cuTY8eMqOwWAISReb0uFgmmaynp89PBhvVZTnH659BfA7gjAAL6hfmfgQHMr jpOnT+8/eFBlpwAwVOxVwYauK+vxxfPnqysriqtLsOsvgD0RgAG8IpVOJxKJYDCo slPDMN5+771sLqeyUwAYHtVyua6w7PPCy5fzc3OK0684lVRE+uXSXwC7IgAD2CyT ycQTCcWL1tgcGAAkqddqVYVln13Z8teyrEq5nM/nVXYKwI8IwAC2kcvlYvG44k5N 0/zo8mXFG0UCwGBTXPa5XC4/evBgdHRUWY82kfBXV1cVdwrAjwjAALaRSqUi0aji jSsCzbfwL169qnjVHAAMKtMwSsWiparsc61Wu3fnjvpzR12o1bj0F0AnCMAAticy cCKZVHwxsDASDF68ckXxAmwAGDyKyz5rmjZ165birQQC9qW/5TLpF0CHGGIC2FE6 nY4rL4glhEdHL1y6pLhTABgkiss+67p+++ZN9enXbBa+KlD4CkDHCMAAduNKQSwh Fo+//+GHijsFgIFRKZc1VWWfRfqdunXLlatmKHwFoFsEYAB7yOZyceUFscSwJpPL vfXOO4r7BYABoLLss0i/d6amwqGQ+rdKK5XKGoWvAHSJAAxgD6lUajQSUb+wTWTg iX37Tp89q7hfAPA1xWWfp27fFqNJ9em3Vqtp9TqX/gLoFgEYwN5EBo7FYmHl21qI DHzg0KHjJ08q7hcAfMowjJLCC2If3r+vaZr69CtCfrVaJf0C6AEBGEBHUul0PB5X v0GRyMBHXnvttWPHFPcLAL5jmmZj0yNVZZ+/evSoVq2qT79Gs/BVkcJXAHpCAAbQ qXQ6nUgm1Y91xJDu2PHjh48eVdwvAPhIo+xzsSjCoZruvn7ypFAouPKuaLlUouwz gJ4RgAF0wa2i0CIDnzxzZv+BA4r7BQBfELGwWi5rmqamu+nnz1dWVlxJv5R9BtAn AjCA7rhSFDrQXPN29q23JiYn1XcNAB5Xq1bFf2r6mpuZWVxcVJ9+A5R9BuAEAjCA ro2NjUVjMfX9igx87p13xsbH1XcNAJ6l1euVcllNX/NzcwsvX7qSfkXCX1lZUd8v gAFDAAbQtVQqFYlGI5GI+q5FBn7r3XdzY2PquwYAD9J1vayqGPJLYW7OlfRbF2o1 yj4D6B8BGEAvGhsjxePhcFh916ZpigyczeXUdw0AnmIaRqPss2Up6GthYWF+dtaV 9CtCfrVSIf0CcAQBGECP3NoYKdCcB373/Pl0JqO+awDwCJF7S4WCqWTTo6XFxZnp aVfe9GTTIwDOIgAD6F1aZOBEIhgMqu9aDIne++ADEcLVdw0ArrN3AzJ0XUFfy8vL 08+fu5V+q5UKmx4BcBABGEBf0plMwo2NkQJkYABDrFIua/W6go5cTL+NkF8uF9j0 CICjCMAA+pXJZuPxOBkYANRQtumRu+m3Uqnk19bUdw1gsBGAATjArc2BA80MfP7C hUQy6UrvAKCYsk2PVldXn3/9tSvpN8CWvwCkIQADcEZubCzmxubAgWZd6Pc//JAM DGDgGbpeUlIM2d30W61WV9nyF4AcBGAAzkilUqORSDQadaV3MjCAgSde6EqFgoJN j9xNv7VaTavX2fQIgCQEYACOERlYJOBIJOJK72RgAANM2aZH7qbfulCrkX4ByEMA BuAkkYGjsdjo6KgrvVMTC8BAUrbpkYtVrwRN02rVKukXgFQEYAAOExk4Fo+7NX4i AwMYPGo2PXI3/eq6Xq1USL8AZCMAA3CeyJ+JRCIYDLrSu8jA754/n85kXOkdAJyl ZtOjpcXFmelpF9+7rIj0Wyi40juAoUIABiCFyMDxeDwUCrnSOxkYwGBQs+kR6RfA 8CAAA5AlLTKwq/PA77z/fiabdaV3AOifrutl+UuCXU+/1UqlQPoFoAoBGIBE7mZg 0zTPvfNObmzMld4BoB+mYZSKRdmbHr0U5uZcXK1D+gWgGAEYgFzpTCaRSIyMuPNq I0ZXb7799vjEhCu9A0BvLNMU6Vf2pkdzs7OLCwtupd9GaetyuZDPu9I7gKFFAAYg nesZ+My5c5P79rnSOwB0S82mRzPT08tLS6RfAMOGAAxAhUwmE3cvA5uGcfLMmf0H D7rSOwB0TiTDarmsaZrUXl48f766suJi+q2Uy3nSLwA3EIABKJLJZuPxuGsZ2DSP nzx58PBhV3oHgA4p2PTo2ddf59fW3Ey/lYo4AFd6BwACMAB1XM/Arx8/fuToUVd6 B4A91ev1quRNj54+eVIsFEi/AIYWARiAUtlsNuZqBj782mvH3njDld4BYBe6ppVL JaldfPXwYbVadasyf2N1d6WyRvoF4CoCMADVRAaOJxJu9S5GYPsPHjxx6pRbBwAA WxmGUZK8G9CDe/d0XXfr/UehUi6TfgG4jgAMwAXZXC4ej7vVu8jA45OTZ958060D AIB2pmmK9Ctvy1+Re+/fvTvSJKmLPVUqlbXVVbd6B4AWAjAAd7iegTO53FvvvOPW AQCATbwcNbb8NQxJ7Yv0e2dqKhwKkX4BIEAABuCiXC4XjcXcGpOJQWcynX73/fdd 6R0AAnZRqFJJl7blbyP93r4dDoddTL/VSmWV9AvAMwjAANxkZ2Bxw63Bmej9/IUL rnQNAJVyWavXJTUu0u/tW7eikYik9jtB+gXgNQRgAC5rZeCASzE4PDr64cWLLk6P ABhOUrf81TRtSqTfaFRS+50g/QLwIAZ8ANzXnoEDbsTgUCj04aVLbm0NAmAIafV6 RdqWv7Va7d7UVIT0CwBbEIABeMKmDBxQH4NHRj66fFkkYaWdAhhKuq6Xi0VJjYv0 e3dqirlfANgWARiAV2zNwDZlSdgKBEQGDofDaroDMJwaW/6K9Ctn0yORPO/fuxfh ul8A2AEBGICH7JSBA6pisGmaFy5dcnfdIIAB1tjyt1i0TFNG46LlRw8fkn4BYBcE YADesksGDiiJwYZpnr9wIZFIyO4IwLCRuuXv2urq10+fjo6Oymi8Q6RfAN5HAAbg OdlcLrZzBg7Ij8GGYbx7/nw6k5HaC4ChInXL36XFxZnpaXev4KhUKmukXwCeRwAG 4EV7ZuCA5BhsmubZt94an5iQ1wWAoSJvy9+5ubnFly/dreFH+gXgFwRgAB7legY2 DOPU2bP7DxyQ1wWAISFvy9/p589XVlZIvwDQIQIwAO/qJAMHZMZg0zRff+ONI6+9 Jql9AMNA3pa/Tx8/LhaLLqZfy7Kq1SrpF4CPEIABeFo2m43F43t+m9QMfOjIkTdO nJDUPoDBJm/L34cPHtRrtWAwKKPxTjTSb6Wytrbm1gEAQA8IwAC8LpPNxjvIwAFp MVgM8sYnJ8+8+aaMxgEMMMMwRPq1nN7yV4Tq+/fujSjcJn2rRk2vSiVP+gXgNwRg AD7ghQycTKXePX9eRuMABpJpmiL9mk5v+SvS793bt0PhMOkXAHpAAAbgD51n4IC0 GBwKhT66ckVGywAGjIiIIv0aTm/5K9Lv1K1bo6OjpF8A6A0BGIBvZDKZeCLR1V0c HyOapnn5+nUXL7oD4H2NiFgu65rmbLOapon0G41GnW22K/aPls/nXTwGAOgHARiA n6RFBo7He4i1DiZhwzDe//DDZCrlVIMABky1UqnXas62WavV7k1NRVxNv6ZpViqV AukXgJ8RgAH4TM8ZOOBcDLYs6+jrr4v/HGkNwCARSbVWqTjbpkjU9+/edTf9GoZR rVZJvwD8jgAMwH/S6XQ8keg5zToSg0UGTqRS777/votX4gHwGhlb/haLxccPH45G Is4225VG+q1UCoWCi8cAAI5g3AbAl0QGjsXjfV6L2392FTH4/EcfxWKxPtsBMABk bPm7urz87Nmz0dFRZ5vtCukXwCAhAAPwq1Q6He87Awf6jsFiaHjy9OkDhw71eRgA fE3Glr8vX76cn50Nh8MOttkV8ePY1/0WSb8ABgUBGICPOZWBbT0nYTFGzORyb73z jiOHAcB3REosifTr6Ja/0y9erCwvh0IhB9vsUCvG29f9kn4BDBICMAB/Exk4Fo2G nJsh6efS4vMXLrhbpQaAejK2/H369Gkxn1effttnsMVPVKtWW5+LV0arg4HjjjPg dsviBbZ5o+j0WnEA6BABGMBmIlKKl4aRYFAkumAbt49Lqd5isBgvnnnzzcn9+x0/ HgDe1NgXt1TSdd3BNh8+eFCv1dS/6jq7fttdZhuruZJb/GxMZQMIEICBIZdKpUZs Gyk3FApR1tjW2+MgBlvjk5Nnz51z/HgAeFClXNbqdadaE0H6/r17I45uXd6JQYq+ u9gmFVsWc9HAsGGYCwwREXfFqKo1sRsOh4dtXrcHvQ1DxQN7/qOP3C3cCkC2WrUq /nOqNZF+79y+LV6ZVabfIYm+uzAMw2z8z7SasThAJAYGHQEYGHCNOd6NqV3F46pB 0sPjJoZSZ996a3xiQsbxAHCds1v+ivR7+9atqNrNfkm/W4mXbqPJbEZiwjAweBgK AwPIDr0h8V847OL+GQOmtwy8b//+U2fPyjgeAC5ydstf8Vpx88aNqMISekTfDhni N93Mw4RhYGAQgIHBkUqnGwubQ6Hw6CgzvZL08MCGwuHzFy7wTgQwMEQcKoks5FyG fPb118VCQc3rNtG3N+Jx0zVNb84MU0wL8DWGyIDvpVKpYMie62WFsyLdPs5ixPTW O+/kxsYkHQ8AZfrZ8lfX9Uq5XKlWF+bnNU0baaNgxyOir1PE7078KknCgE8xVgb8 yl7nHA6FRl+9ZowMrFLnj7YYKh08dOj4qVNSjweAVCJDivRrbmz521gIXSpVq9Va raY1Gc1cZF8+asdNO9+2bgSbO8wpPmaV3Q0P8cBq9brO6mjAbxgoA/5jT/lGotHg zqMoYrBiHT7ghmmm0unI6GgkEonGYuK/WLxBweQPgF2I7Lq6vFxpVnUWqWY9zTbr A7en2cay57ZA6+V948i9yhi6Lv5ixJ8KMRjwBY++agPY1nr0jUQ63L7IsyOzAdbD Y2412TfsCaKQbXQ0HA6LX7eIy9FmYI41MzObVwFbibyaX1urVir1psbUXNP6Djfi Q3OHm005tjUzq35iVhJyr3r2Y26apvjDIwYD3jcIr/XAMGhE32CwMevbffgZjFGd 70h62K0NgY0VlfY0lB2awy2jzVlm8SEqsnOkt78cQCoRWculkvjYWD/cnHQ17Gsr RWRtW0jc3Jx1I7s2g2t7fLWaHwcpwfaG3OuKrQ97IwbXaiaLogEPG95TBeAj6XRa hJk+ywgP89DQXR555O0UsX4ozewgIkdgpP0LzQixsYFWqJWoR5saIToqPkskk+Iz 934OKGKnUxFE7UzaYjTzqT2t+k1GFTHAbFaFst+daQur9rqGwMYT4ZU/uA3u/ZS+ R+51y+6PvHimiBfYAiWyAE/irAN4WjKZFPHD2c0hGW66ZQAe+Ua4aV4MuR5y7Lm4 QKB9CXfrxkjbTJ342JiAtm+ImC1uBoP2lJ0due3boWYCDzZXga9fYNms9CZuN4qc B4N29h6AEG7Hy8BGHZ1Ac8TcfHQb0dJqXlUYaG63YzXfuTCaVZfWP9qXpG78Luzg 2fi4kTzXfxnNTwP2p82vND7aibR5I2APAuw/y5HGPwTakqq9ZGAA/mgHErnXRZ0/ +LVaTTyRmQoGvIYTG+BdqXRaRF9J5ZEY17qFR75/rQGo2bYVzTaj0u3GqZZDj//I toPgHRpv/6W31qLzl4AeEH1d1MODbxiGiMHslgR4CmdfwKMymUw0FpM9RGYI7hYe eQBdIfq6qJ8HX9y3Vq3m83kHjwdAPxiBAZ6TSqVC4bCzy553QRJzEQ8+gD0RfV3k 1IPPcmjAOxh7Ad4i0u9oo3av6usbSWLu4vEHsAm5112OP/66ptXrdTIw4DqGXICH iPQbjcUkXfTbCWKYu3j8AQSIvm6T9/ibhlGtVsnAgLsYbAFesZ5+g8Gd6uioQQZz Hb8CYGgRfV0n+1dABgZcxzAL8IRv0q/N7QhEBnMdvwJg2JB+3aXs8ScDA+5igAW4 z06/67tutv+D2xGIDOYuHn9gSBB9Xaf4V0AGBlzE6ApwWXv6bfFODCaDuY5fATDA iL6uc+tX0NgimAwMuIFxFeCmVDodiUR2qnrlnRgcIIZ5A78FYAAQer3A/d+CZTUy cL1eLBRcPhJgyDCWAlyTSqVi8fiekcZTMThABvMMfhGAj7gft7DB/d9F2wGYllWt VJgHBlRi/AS4Jjc21vl+v8Rg7IJfB+BB7gcttPHEr6PtGFq3NE1bXVlx5XCA4cSY CXBHOp2OxePd3osYjN3xGwFc54mghTae+I1sF31bqtVqIZ9XeTjAMGOoBLggmUrF O1j8vBNiMDrB7wVQxhMRC1t44veya/Td+BarUqmUWAgNKMHwCHDB2NhYuOPFzzvx WgwOkLi8it8LIIkn8hW28MrvpYPo26Jr2goLoQElGBUBqvW2+HknHonBpmmKAYcI WsFgkLjlWfxqAEd4JV8NAbPJarJfv8TrmPg8uGHT93vlV9NN9G1hITSgBoMhQKk+ Fz/vRFkMFmMLeywihh3RaDSTzR46fPj4yZOjo6NGU6VSef7s2eLCQqlYrFWruq43 xgEjDaFQiADmEfwigB54JVwNkMYJpXlSsT8VZ5ZwOByJRhOJRDabHZ+cFKcYcdK0 s+6mFy5xinl4//7M9PTa2lqtVhPNeOJN2J6i78ZdqQgNqMAYCFCqq8rP3XI2BotB idHMuuFQKBqLZXO5Q4cOnT57Vtzurp1mZhYK+fzDhw+XRTYulcRgRaRla+d38aEA MRjoENG3N+351k6n4gwoTiLJZFKcU/bt2yfybbfnlN3ZqXh2dnZtdbVxotH1gLK3 X/uIvi1UhAYUYPQDqJNKp+PiTC/5NNxbDLYzqhidxKLR7NjYkSNHTp4+7ey4ZCdi vCIGK/Ozs8tLS41543qdbKwSMRjYBdF3J60FQfZDFBQ5MxwW+TYWi4mT3djY2MS+ BjXnkd2Js8xXDx9OT0+LbGnPFTt/ctn4O+n/z6VSqRQLhb6bAbAjxj2AIqlUKhKN huwzrgcycCPvGsZoJJLN5d544w1lcbcrjWw8MzM3P78qsnHbvLE9k0A2dhZJGGgh 9247edtYnByPp7PZsfHx48ePe/Cs0SE7Ej99+nRtdVWr14OhUO8nFCcmftuJ01y9 VmMhNCAPwx1AkXQmE41GVdas2tqXPc0rovix48ffefdd/45dAs3hy8LCwsv5+eWl pWKhUK1WdU2zx2rr14oRj3tCDMaQG4boKyKW+Dnbw204HB6NROIi3KbTubGx8YkG X58juiJOKLdv3fr6yRMRO7t4d9Xp6NtCNSxAKgY6gArJZFIMLFqJ95snnvywITow mqVBjr7++uWrV+POFaD2MjGa+frp05cvX+bX1srlcr1t6tgTVVI8j8cHQ2gAom8j 2TYrONg/SSgYDIVC4Ugk2iwrlc5kcrncsTfeGJ5k24NKpfKvv/719PPn4u9BPHo7 fp9za563a9uqlMulUklC2wAIwIAS2Vxua+0rBTFYDIb2Hzjw7e9+d0hyb4fE+ObJ 48dLCwv5fF7cbsXjQHP22E7Ibh+jJxCDMSQ8Hn1bl9pabXO2IpuNimQbiSSSyXQ6 PTY+/trrr5NsHSTODp/97Gcv5+c319CSNvHbrl6vr62uSmseGGoMbgDpGtO/icS2 /yQvA+u6fvX69TNvvulss8PALsq1uLCwurLSuPC4WtU0bX2jY/GLGr6ETAzGoHIx 94qXlNZH+0jE00yE2nCzjlQkEhFnjVQ6nc1mM9nsUK1G9qD79+799le/Er+b9pdC 2X86jUngSqXElcCABAxrAOlyY2NiTLPLNzgbgw3DeP3YMZF+GTBJIiLxy/n5xaWl tZWVYrFYFQm5Xjd03Z6dGdkwwCGZSAyfkpd4G1HWvqp2o4/Gi0CzMPL6VG1zEXIy JVJtWmTa8fFxXqJ9RLzs/+bXv3729Kn4dap416T5R6Tr+gpbIgESMIgB5EqlUrHO lh87Uh9LxLDv/+VfZnO53u4Op9g1upZFSF5dbYTkSqXe3N5p/Qq9jauRByYnE4nh Qb3FXTvK2u9ntVqwL44INS6oDY/a9aJisXgz0IpEe+TIEdLsMBCv5//8T/8U2vUd 7X69emmxOHdQDhpwHEMWQCJ766OuEk4/MTgUDP6HH/6QcZiPiJy8vLwsBlVCuVis VKu1Wk1rRmWzeVlyayrJX2mZPAxXWG1an9r/1PiLbE7JimdRozSUvdR4dDTalNiI sh7ZtxaeJV60/+9/+IfW2nXH7HBdseiILZEAxzFGASQSw6lYT2OpHmKwiEZ/Qfod dGLs9fz580KhINJyuVwWn9Y1Tdc0OzBvWn5pp1AvxGbyMHbRCKnNqsWt1Bpom3pt /Rk3rsBvFiNq1jVuLCwON6+VjYr/4k2JBi6XhWwOZ+C9SmqJ7sRrvjN9AWhiUALI 0sP07yadx2ARgf767/6OYR+21SjrNTNTbKo1J5nrtZreZIj/7PjRNmlm36sVoQOO pmjCsO80/0DMwKsrijf9tQQ2plhb77sEW4uGm/WK7cXD9mazEbvKUyQSi8djMfEh nsvlePmCj4gX0v/z7/9+9+oee+usmjSTwIDjGIgAsqTTaUeGdHvGYHF2/Msf/SiR TPbfF7ATMeBbXV0tlUrVZoQWn+pag75hfRa6yWrbtiWwcS2lXed2fYK67UZgY4pv 236/mQDc9dt8bdN63VdS5cjI1tj56q1vHsxA6+WibdY00Nr72r4ZbCbT5sdmOP1m PbA9pyo+RqJRO6BGmqWbSKfAVuVS6Z/+63/t8Z3BLjdSYhIYcNYAjiQAL0ilUmIE KcaXTjW4Sww+dPjwd//wD53qCPAmO4Hbtyvl8voXazV7+FgXN+y6qc09qxo3moF8 UyNGM6I7cjxbd/YWRIAMtj097QrAjRvNbBloPpFFpLT/tbU7GgkT8KOfffrp7PR0 d/fpaQ9h8cKl1etMAgNOIQADUnRe/LkrWzdM0nX9r3/8Y0bPAACo1PVC6FcrPHeF ctCAgwjAgBTZXG5UnBTlLNdsNWpZ1r//kz/Zd+CAjF4AAMAuXs7P/3//43/sfWlG H9HXpmtaawkMgD4RgAHnJZPJWDy+dbbWWaLRZCr15z/4gYzGAQDAnv7bP/5jqVTa 8Z/7jr4tlXJ5t44AdIwADDgvnclEI5HNX3U6Bhu6TuVnAABctONC6J4u992to1qt kM870RIw7AjAgPMmJicD2z67HM3AV65dO3XmjIMNAgCAbj168OBff/3rbxZCOx19 WxYXFhxtDxhSBGDAYZlMZrRt+ldSDA6OjPztf/pP/bcDAAD69H/85/9s7/rW+oqz 0ddWr9XyTAIDfSMAAw4bGxsLvrr70U7bm/bchTjLsvEvAAAesb4tcPPMLiP6NliW YZory8uSmgeGBwEYcJi9/nkrB6eCxycm/uTP/qy3+wIAAMf9v//9vy8vLclqvTm3 LP63tLgoqwtgaBCAASclEol4IrHLN/Qfgw3DYONfAAA8pVat/l9///ebloA5wHpl RrlSqVALGugTARhwUiabHR0d3fPb+onBY2Njf/r973d3WAAAQLL/55//eWVlxbHm rM2LqcXnmqbl19Yc6wIYSgRgwElbLwDeRQ8x2DTNH/7N38Tj8a6PDAAAyFSpVP7h v/yXYDDYb0PbRV+byWXAQN8IwICTxicmRrq/srerJPyt73wnFAqJ82toO/bXezgG AADQLfNV/+0f/1F87L25naNvC5cBA31ilAw4JplMxnqdm+2oUrRlHT127Njx43u2 tikeb03LDrw/DQDAYLGazL0YhmHfsL+/vYWvnzx58exZb31v/sIO31jlMmCgPwRg wDHpTCbStgNwD3aPwbquX/vkk06uMd67o5ERppEBAIOtkzS7SZ89apr265//PBwO d36I23xt13vU6/UCuwEDfWCACzgml8uFOj/n7WynGCxy6dWPP+6//Q7tMo1s3xYf CckAAGW6TbPWdvFStt/88pemYez9fd1HX5uh66urq10fFoANDF4Bx4yPj484t7R4 05NTnBTffu+9sfFxp9p3RHsw3pqQCckAgG215mZ3n6Td9K9uH3VHVpaX79y6tcc3 dbzgebu7WhI3HAaGAANTwDETExON/3M077Xa0g3j29/7noMtK7NtMG6fRma5NQD4 2rYhds9k6/ZRS/TZT3+64yroPqJvC3WwgH4w6ASckUgm47HYN587HYNHgsFrn3zi YJueYl+TvCkVt39kMhkA1Ngzu26NuIOdZnvw65//fJvHxInoa6tUKmXqYAG9YjQJ OCOTyWwuT+VoWjty9OjxU6ccbNCPgk3kZADY06aCxpsy7S6fun3gg+DJo0cz09Pf fO5c9LVp9XqeOlhArxgmAs7IjY3ZewttflI5EcbEiOTqxx87Uv95GLRqXLeycfsN ll4D8JH2HGvf6DDWMivrIk3TfvOLX4izTM+VrnZnGMbqykrfzQBDisEf4Izx8fFW 1nU8A4uhzCff/W6fjWCrkWZt7V3ScntsdvtgAfjYpgXDO93Y+kVyrE/9/Gc/C205 cTj1u6QOFtAPAjDgjHG7AlYbB2NwIpn88OLFnu8ORwQ7Zs8tM70MDIzWNOxOH3f/ lBA7hD7/3e8qbZfpOvwXYFlLBGCgV4zPAAckEolYPL7169s8wXoKRWfOndt/4EAP d4SL9szJ9vxz+20yM+C49uy6KZR28mnrtts/B3zm5fz8g7t3RxyPvoH1K4obdbDK ZcfbBoYBgy3AAemtFbBe1c9ssGkYVz/5hAuAh4E9b7xLQt50u/2G28cOOMZq08qf Wz/d9vbWBOv2T4MhZV8G7PDlM21vxNQ1rUAdLKAnjJkAB+RyuWAotOe39RaDuQAY exrZYIfhbm9suu32TwMfsLYIbGwGu+2/dphpiawYJD//2c8cC8CvrkGwmmMD6mAB vWGgAzhgbHy889jQbQxOpdPnL1zo5bCA7m0biduz8dYv9vavLv+cA6E9eQbaYmcn t9s/3enru3DvhwZ848bvf18sFPptZUv03fiytbK83G/jwFBiCAI4YGsFrD11HoO5 ABiDqpWKHfm4qdlt++rti5vy3tb4t/s3bPtpJx87+QYAnmVfBtz7/XeIvi0UggZ6 QwAG+pVKpSLRaG/33TMGi2HulW99iwuAAQDwF03T/vWXv+xlwcte0ddWr9WKxWIv RwYMNwIw0K9UOh2JRPppYZcYrOv6d/7dv+uncQAA4Ip/+fTTcDjcxR06i762er3u wBJrYPgQgIF+ZbLZcCjUzza/tp1i8Le+850+WwYAAOr98rPPAh1esNBN9LXpup5f W+vlsIDhRgAG+tUoAd0q89hfDN5654NHjpw6c6afNgEAgCsePXgwNzOzxzdtLSvQ WeMUggZ6QwAG+tUoAb3pSw7FYHEKfO+DD7K5XD+tAQAAV6ytrt66cWPHf+41+m7c m0LQQC8IwEBfUqnUaPMCYGczsN1gowLWxx9TAQsAAD/asQ5Wf9G3hTpYQA8IwEBf EslktK0EtLMx2DAMKmABAOBfn336aai9DpZD0ddWq1ZLpVIfDQDDiAAM9CWdToe3 zNA6FYNT6fQHH33U230BAIDrvvi3fyvZk7SORl+bpmmFfL7vZoDhQgAG+pLJZkOh 0NavO5KBT505c+jIkV4OCwAAeMDs9PRXDx/2UOR5b5ZlmOba6qojjQHDgwAM9CU3 NrbLHvd9xWAuAAYAwOfWLwNu+4oD6XcjTpuWRSFooFsEYKAvY+Pje35PbzHYNM1v f+97vRwTAADwjJ//9Kf2dokORt/1zwIBCkED3SIAA73bVAFrd93GYCpgAQAwAD77 9NPgdldLdWeHRdS1Wq1MHSygGwRgoHfJZDLScQC2dR6DU6nUBxcv9nJYAADAM774 3e/62qxo1+uH67UahaCBrhCAgd6lM5lw+94GHeskBh8/efLo66/3clgAAMAzXjx7 9uSrr3q5Zwels3RdpxA00BUCMNC7bDbbz6Km3WKwZb334YfZXK7nxgEAgBesra7e /OKL7u7TcdVok0LQQJcIwEDvGiWg7Vu97vQb2PZJODJimebVTz6hBDQAAH6nadpv fvGLXfaMeEWXGyZZFIIGukQABnrXmAFu1nVc51wMNkyTClgAAAyGvetgWZujbocl o03DWFtb6/GwgKFEAAZ6l8vltnlD14kYbFoWeyABADAYPtvYCWkbvUbfjXszAwx0 hwAM9O6bJdCb9JGBA82n5aGjR0+dOdNPIwAAwCMePXgwOz29+av9Rd8WtgIGukIA BnonArB9w/EY/N4HH7QaBwAAvra6snLrxo1vPnco+toIwEBXCMBAj5Kp1KYiVQ7G 4PcpAQ0AwKBoFIL+/PPGkMDR6Nu8v1XXtFI/+wwDQ4YADPQolU5v3QR4x2dUNzHY Ms1r3/42JaABABgMmqb9+uc/D746GOg3+gbWZ5I1XS8WCv03BgwJAjDQo3QmE9qh omOfU8EmJaABABgs//Lpp6GNOlhORV+bbhiFfL7/JoEhQQAGepTZtAfSFj3HYPEd H3/3uz0eFgAA8J5f/OxnAaejr800TXZCAjpHAAZ6lMvl9kyzva2IjkYil7/1rR4P CwAAeM9vf/nLWr3eVxNbou/6l5tFtvpqGRgmBGCgR51Xae42BlMBCwCAAbO2uvrl 55/3eOedo6+NAAx0jgAM9KjbbYo6j8EEYAAABkyPAXiv6GsjAAOdIwADvUgmk40q zT1tcbT7tcGWZV375BNKQAMAMEjsQtAjnY8cOou+rcbZCQnoEAEY6EUqlXplD6Tu k/BOMdgwjD/4wz/s+cAAAIA3/cv//J/BHfaPeMV20Xf36lm6phUJwEBnCMBALxqb AG86hzk0G2xaFnsgAQAweP7l00933z+ih+hrM3S9wFbAQGcIwEAvGpsA73QO6282 eCQY/PgP/qDHwwIAAF71i//1v6xtFzZ3s9p5W6Zh5NkKGOgMARjoRWMT4F2Cbh+z wZFY7Mr16z0eFgAA8Kp//eUv65t2Quo7+q5/P1sBAx0jAAO9aFVp3u0p1FMMPn/h AiWgAQAYPK8UgnYo+rZaW11d7e2uwLAhAAO92JRRHYzBBGAAAAbSegB2Ovra/08A BjpEAAa6lrD3QHrVHs+ljmMweyABADCQ1ndC2vL1PqOvra5p5VKpt5aAoUIABrqW TCbDO2TUPmOwZZrfYQ8kAAAGVGMnpLYimo5EX5um62wFDHSCAAx0LZVKhdo3Ad6i 5xhsmiabAAMAMKhaAdjB6GvTdZ2tgIFOEICBrqXS6VAHG9n3FoO//b3v9XJMAADA 8z776U97vOfO0TfQjNOmYbAVMNAJAjDQtXQms8dG9m26isHhcPj6t7/d42EBAABv +9Vnn+m63vXd9kq/geYisgJbAQMdIAADXctks41nTsd1rTrPwKlU6sLlyz0fGAAA 8LLf//a33S1U7iD6tr6TrYCBThCAga5ls9lvPnE0BrMHEgAAA2xtdfXG73/f0bd2 Hn3bGu/lmIAhQwAGuvZKALZ1s9nvLt96/qOPCMAAAAyqjgLwztF399JZBGCgEwRg oDuJRGLHfXr7i8HirHb9299mE2AAAAaVpmm/+uyzkW0HDN1P+W5tnK2AgT0RgIHu JJLJcDi82zOn1xhsWtaHFy/aXRCDAQAYJK10+sXvfjeyqZRm39HXpmtaiQAM7IUA DHQnmUy2NgGWEYMDzVOdZZojI+L8GByNRGKJxImTJ0nFAAD4gp11nzx6VKlUxG3T NC3LGmna/K0ORV+7Kd0wSmwFDOyFAAx0J5VKBV/dBFhSDN7KbJ4mxekzHA5Ho9Ez 584FmC4GAMAlrUnd+3fv1qtVwzDEmVqczTdP8G7L0ehr/79hmkW2Agb2QgAGupNO p7c9sSmLwZtas5rEjWAwaAfj02++GSAYAwDgkFbQfXjvXq1W03XdNE3xaVCckbs5 xTfsmnsDvUZfm4jfbAUM7IkADHQnk8nscrZzKwZvw7LsGWNxeg6Fw5Fo9CwzxgAA 7OyVGd1azdB1+y3mkWCwddLtLqC2kxl9Wy3k2QoY2AsBGOhOZuseSFt4KAZvx540 Xr/GeHRUZONTZ84EyMYAgCHQSrmPHjyoV6taczp3/bS461nVy9G31Q4BGNgTARjo TicB2ObxGLy1cauZje3bjWwcDo9Go6fPng2QjQEAvvLNouX79+tti5YDzVIaXe1C 1Hvu3bnNHhvvYH9gAjCwJwIw0J3OA3BgzyeYJ2Pw9s1aVuti45Hmmmr7euMTp08H iMcAAOVaEffxo0e1alVEXMMwrGbKHWmuceq0oQ5SZS9URd9NTRGAgT0RgIEuJBIJ Efy6jZoOxmDHW+u05d2bbY/HwYZwKNSaPQ6QkAEAXWrl20BzFler1/WNtcqBXWZx uzJY0dcmHqUyWwEDuyIAA11obALc2gPJveDq2mxwry03xiuvJmTxMIZHR+26XAES MgAMmfZ8++DuXfFpYw+hVr51qu7UTgYx+toMtgIG9kIABrrQ2AR406oqYrBD1ueQ xX8j9uK1ZkgOh8++9Vbre8jJAOBx7clWuH/njr04eT3cNmtNrc/ftp9Kdqhp7DAH t97tpuWuG+/jOE3DKBKAgV0RgIEupNLpbUpEdp8G/RKD92jf6Ri8fXNtvVhta62b /7Kek0VQFsH4ZPOCZBtRGQActCnWfvXwofhKY03yq9O2gVa47RzRt+PWOmnKMs1C odBVn8CwIQADXUhnMjtvAexmDN67te4b7LRxCbPBeybhPW2NypvS8olTp1rfTFoG MIQ2ZdrHjx411iG3zdZa9pKcjYU5Dlxz205N7t2hI2e6czZUO9Sa+K0V8vluOweG CgEY6IIIwAFvB1c3J4T7bryL7pweh9lZubEPZHOcEWyuzVu/WLm5EtveKrmFzAzA Uzal2UBzk1t7htYOtOIFzmwuP7baFyFvvMxKSZ5bydhnqMu+HOjO2SnfvRrsobU8 ARjYFQEY6IIdgG2OR0Ev5+ru2lc2Jyynr056t1qVvezYLMaUdtWWjanm9eQcCp0k OQPo2NYc+5XIsSLBbuTY9rUt60UTArsuPJa39Ldz5F61DRKAgd0RgIEutAdgGzFY XuPddaokCe/Ye+eHsZGZ7Rv2+LVV+sseyDbrZAfF/4XD4VAweKLt2mYbKRrwoK3Z VXj88KHezK6Wue6bFwHbxtM/4NTWPgFvhN6dD0Nx7nWgR49P+W5pkAAM7I4ADHRh awBucXZGVHUM7r7N7roYxCS84wF8888Sj6Q9QrcPfOwl3Os7iGxMR69vPRUMntrY mXkTEjWG0LZ51fbowYP16dZmZLXarL9ptaEVXFsfXeOR0BtQeHHvDn051uleubeX LiRHXxsBGNgdARjoVDyRCIfDu3+Pl2Pw3g321GZ3XahMwtK66+4Y1v/Z6y+26zl6 I063Pl0/8ler4NjXSK+n6+b/hUIiXwfbS4ttQsZGV3ZJp4FmuSaRS+1pVWsjodrX uAbaNx5vT6qB9afhNzdeDaxKI6JTvB165R6DvKXOuzbeey9Koq9N0/VKudxDk8CQ 8PqYDPCORCIR2isA2xy/PtZ3E8J79CItDXohCe92GOv/7NcX3n6O29o0V936pO1G 65HZ+L+2Ij0jr2gFb/FhU32yXRDCO7R7+Nzk0YMHjazZDKFbJ0u/eT/Fjqatu238 urfmUltHi4E7SCk73rXne7rL8bW4ffJS7nWmX+9f6LtXm+LfDF0vE4CBnfl1HAao J0bPoWCw8/Ti8Ri8d4M9tdldF4OehANKHmR39f0nourH33Th5cYXA60B6A4JrWVk 42pt2Ufar+ZBbvOTtr+/sOW9hvbvbV2QKvlAO9ZH0A34N+u2885M73qXQ5d7e+nF jehrMw2j1PF7WMAQ8szpDfC8ZCoVtEeEjmTgbtqR2qb7E8JOtN91v24M7gc+DNuc +RkG4qFAd/oLuutt9N+EF3htpne914HLvXt10WMvMg67mzYt0ywWi731AwwDRhhA p1Kp1CtL8ojB3XMxAbqyJHvHDjv6poF6fXbshxmsh2VIORF0AwOTdVtkTEI6wmO5 15muJT3abkff/7+9e1lOIwfAMKpUVrYn7/+gSWY1qYwTMNcG972l/s9ZJMSFJQFV 0F/UwMdv/P7x/fu42SCBIwno69u3bx0/rTmDhw+7Wpht+C7Zqkq4RMbwyfy3aqd3 VHtmStzzePMOV4/WorcsvZ4KtnxHTlRH+p5890HQ8JhjBeirO4APhhx2r/3e4FHD KuHl5n02ba8r7f95e9lbGHAHLmvuuL0ae7mh61Ft9JZKu3ee2bfo3pFjfjZsnzEF MDzhOAB6eXl5OXwE9CzV1MRucK8xRw07ZqKwEi5iuMvqp6on3b1LZm3HbGtOVoOa o7fsunt7zDJyolrT9+A/34QEjyW9usMEL6+vX79+Pf1TBk8fdsxcCwdJnSVcxHAP ld74dR6Uddu1v0qXtZrKo7ds171Pp55z9sj0PYzz69cv34QEj1R6zAAVem/gL4ev Qrn8etJHdpfBvYYdO/LgiVJLuIjhUdwdC0lP3Hv1R2+pt3tnW0C//xLaW/qev4D7 z0Xbv/CEowIY7+Xl5RDD5zC+ucamGfz5sKNG7n2T9lDCn6yhgs5c8+GIEnh/bR9m zVkutGa3YfQ+nX3ONTTXvZ+N/PgxO4fu4cvN5S4MEvgSD8t6r+JTDB/reK6PyCoN bgiPHXzwXKsEXuUxXAY9p9exYC4dHpIqeol7vU81r+UR3DZ6ny5gzmUs+t8QW2z5 3gx73tnVujATB0CwhqFV3NCGcK9hJww+ZrrNY3itNfQx8Iuwalk2bGnI26pryd2y 1htrJ6xh5mUsd8L5Flu+v7UurMWxDmzp9fX1SRW3lcG9Rp4w+ObTPZukgjX0J4nh SqO5e1BD9H62jNJK9/YYfJaRb1rXp1XByhzZQHX+VPFFEn+5f2vxjcpKeP13pdZT wqW1GC4jXgbquwkwwMAPza6ueEsz0VtW797xMy52qvPv6/fral2ogeMYaMPNZ1Af L1+qb9s2vIRLgzF8MOrBrvS2EG34F0TVmLsHlURvyere/iOfT13+KF4nMEO1HLJA 205hfG7jyjaEe408bfyRk67bbLWtZ5CxD3y9t4i9GfVlyPXmbln3pOI+9tS9Pcb/ 5BOYbepCyxydwD6dzqM+VXHPMF50E7XSEp57xs9n+/waDTw5j19iC7eOSo0K3VJ5 656ER2+/GSdN2vsWXe3o/v230IXdcBQCcY6fvHX59cVdQbL9hvCEKcbPu3qb7SOG D6YutJ1byuLGhm5ppXVPaoveUm/3Tpq3a4qbvdz3C//+/Dl6BqAVjjaAs/c2vvy6 pl4fwVV2WsJzT9prwl5Xaux5e46vgW7sJjPAhNA9DjDLMta0fl72sfTW64RJJ817 d8ayygUcVQC9XH5j082FowmVooQ75ux1pVafw2d9FFu9E1JMTtzzSHMNtL4Kt3mP E7ffvXd9e/iJM5aBRxw3ADM45fF503j4J3JtlcEDpt6otSpf3ozmvwHt3ycNmC9x j+PNO9wmNgnL/rZa3qj0vXkvrsQFJnJkAKzh9e3tWMWXf35cuLnyhiU8YPbtymrf m8OdFr8x+7q7ZjN32d4Ov+jo66vz3Obz3Ns1+eOpfz/qWycqA4vxkg/U4nkkr/+d uvWXcGlkkYva9N5v515dOGWfzbzVxCuofJv3OP1mm70dZyYXcQtsr50Xb4C/uju5 PNtSnqiVyGxlnWsKuqnb2XPi3ljhQ5vmslj3noL2vmzf//ipbIHqOTYAdusmlcvf p7zzZ3cNfIvywbanZw/V1morEX5HbF9u9Wgod8uk1XZu0spaYK/CX+gBzt7e3v78 dRnMNxvM5SoUW8zLFte8SyPu3Coqa8fayt2DuzU/ithTyh4uCFogmeMbgEn+ZPPH 9vL5vcqdZ2iffqemthy2lJpWDiMNeUf0Jrl77tbLgi1SFmAGDmUANnMTz90Xbup6 lQQdfmq4VxPqM/Cjv+Zp3Y9YvUrXm4ItIhZgMw5ZAJr39s8/5fIJ/WIjuvSo6z7G vFqoYlYz/GOuz7/QuctaumL1+vLPHz9GrhaA7Tg6AaDDfVQf/774Z9/MvhlaGNPP 59undz8s16VaxCoA1xyFALClR6VdrgO78yeParx0dTiD3ZdnuY7P8nB3tPvKRZcC sDHHBABwdhvkZZF+XuLVt+Mk4Mtu/fun4AQgnAAGAAAgggAGAAAgggAGAAAgggAG AAAgggAGAAAgggAGAAAgggAGAAAgggAGAAAgggAGAAAgggAGAAAgggAGAAAgggAG AAAgggAGAAAgggAGAAAgggAGAAAgggAGAAAgggAGAAAgggAGAAAgggAGAAAgggAG AAAgggAGAAAgggAGAAAgggAGAAAgggAGAAAgggAGAAAgggAGAAAgggAGAAAgggAG AAAgggAGAAAgggAGAAAgggAGAAAgggAGAAAgggAGAAAgggAGAAAgggAGAAAgggAG AAAgggAGAAAgggAGAAAgggAGAAAgggAGAAAgggAGAAAgggAGAAAgggAGAAAgggAG AAAgggAGAAAgggAGAAAgggAGAAAgggAGAAAgggAGAAAgggAGAAAgggAGAAAgggAG AAAgggAGAAAgggAGAAAgggAGAAAgggAGAAAgggAGAAAgggAGAAAgggAGAAAgggAG AAAgggAGAAAgggAGAAAgggAGAAAgggAGAAAgggAGAAAgggAGAAAgggAGAAAgggAG AAAgggAGAAAgggAGAAAgggAGAAAgggAGAAAgggAGAAAgggAGAAAgggAGAAAgggAG AAAgggAGAAAgggAGAAAgggAGAAAgggAGAAAgggAGAAAgggAGAAAgggAGAAAgggAG AAAgggAGAAAgggAGAAAgggAGAAAgggAGAAAgggAGAAAgggAGAAAgggAGAAAgggAG AAAgggAGAAAgggAGAAAgggAGAAAgggAGAAAgggAGAAAgggAGAAAgggAGAAAgggAG AAAgggAGAAAgggAGAAAgggAGAAAgggAGAAAgggAGAAAgggAGAAAgggAGAAAgggAG AAAgggAGAAAgggAGAAAgggAGAAAgggAGAAAgggAGAAAgggAGAAAgggAGAAAgggAG AAAgggAGAAAgggAGAAAgggAGAAAgggAGAAAgggAGAAAgggAGAAAgggAGAAAgggAG AAAgggAGAAAgggAGAAAgggAGAAAgwv/T1VqQkYjt1AAAAABJRU5ErkJggg=="/></symbol><use xlink:href="#c" width="1280" height="1280"/></g></g></svg>')} -.is2d .rook.black {background-image:url('data:image/svg+xml;base64,<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="614.635" height="614.635" viewBox="0 0 460.977 460.977"><mask id="b"><use xlink:href="#a" width="1280" height="1280" transform="rotate(.193) scale(.36014)"/></mask><symbol id="a" viewBox="0 0 1280 1280"><image width="1280" height="1280" xlink:href="data:image/png;base64, iVBORw0KGgoAAAANSUhEUgAABQAAAAUACAAAAAA9j6ArAAAACXBIWXMAAA7EAAAO xAGVKw4bAAA+HUlEQVR4nO3dCXhV5Z3H8YiKyCqyiyK4IIpSXFoVrVXrUqxarda6 DLWoba1bpy6tj3bqNtXHvVO3Ota1jEuttG7VultFrBWRIiCbskNYAwkRUJMhrEm4 977vSc45//f//r+f55lnHHNGf+eG8/UmuTl3szIAMGoz6QEAIIUAAjCLAAIwiwAC MIsAAjCLAAIwiwACMIsAAjCLAAIwiwACMIsAAjCLAAIwiwACMIsAAjCLAAIwiwAC MIsAAjCLAAIwiwACMIsAAjCLAAIwiwACMIsAAjCLAAIwiwACMIsAAjCLAAIwiwAC MIsAAjCLAAIwiwACMIsAAjCLAAIwiwACMIsAAjCLAAIwiwACMIsAAjCLAAIwiwAC MIsAAjCLAAIwiwACMIsAAjCLAAIwiwACMIsAAjCLAAIwiwACMIsAAjCLAAIwiwAC MIsAAjCLAAIwiwACMIsAAjCLAAIwiwACMIsAAjCLAAIwiwACMIsAAjCLAAIwiwAC MIsAAjCLAAIwiwACMIsAAjCLAAIwiwACMIsAAjCLAAIwiwACMIsAAjCLAAIwiwAC MIsAAjCLAAIwiwACMIsAAjCLAAIwiwACMIsAAjCLAAIwiwACMIsAAjCLAAIwiwAC MIsAAjCLAAIwiwACMIsAAjCLAAIwiwACMIsAAjCLAAIwiwACMIsAAjCLAAIwiwAC MIsAAjCLAAIwiwACMIsAAjCLAAIwiwACMIsAAjCLAAIwiwACMIsAAjCLAAIwiwAC MIsAAjCLAAIwiwACMIsAAjCLAAIwiwACMIsAAjCLAAIwiwACMIsAAjCLAAIwiwAC MIsAAjCLAAIwiwACMIsAAjCLAAIwiwACMIsAAjCLAAIwiwACMIsAAjCLAAIwiwAC MIsAAjCLAAIwiwACMIsAAjCLAAIwiwACMIsAAjCLAAIwiwACMIsAAjCLAAIwiwAC MIsAAjCLAAIwiwACMIsAAjCLAAIwiwACMIsAAjCLAAIwiwACMIsAAjCLAAIwiwAC MIsAAjCLAAIwiwACMIsAAjCLAAIwiwACMIsAAjCLAAIwiwACMIsAAjCLAAIwiwAC MIsAAjCLACIvm7dutUXbLVoV+eiKL6q+WFH9Za6LYB4BRCY69+zerXOnju3atj58 i8T/zzUfVldXV1UuWbSwfN7shRmsA9YigEhN55127Nm9a8djkxevtJoxSyuWzJ83 e/onxBDpIoBonhbb9+29Q4+u38npX/fxooXz586cNmlWTU7/QkSNAKJJWu+2W5+e 3U7cXGxA7fhF88tnfzpxYrXYBOhHAJFEm/59+2zf4zjpGQ1MWbhg7qxPJ41bLj0E +hBAeGi9W7+dtu+R15e5TTVlwfy5sz75mOeE8EYA4fTd+7eRnpBIxdnDpSdACQII p1rpAUmd8aj0AihBAOGkLoD7jZJeACUIIJzUBbAN3wWEHwIIJ3UB5E81PPFHBU7a AljbQnoBtCCAcNIWwGUdpBdACwIIJ20BXNhFegG0IIBw0hbAudtJL4AWBBBO2gI4 Y0fpBdCCAMJJWwCn7Cq9AFoQQDhpC+DHu0svgBYEEE4Vyn6qOnaA9AJoQQDhpuwp 4JiB0gugBQGEm7IAjtpPegG0IIBwI4CIFAGEGwFEpAgg3AggIkUA4UYAESkCCDcC iEgRQLgRQESKAMKNACJSBBBuBBCRIoByOnTo0H6bdm3bbb3VVi3rbLl52RYtyso2 37ys7Msvy8pWlZV9/sWqVStXrf6fzyqrKpYuXVyxUmYpAfSy1TbbduiwTd0ndPVn c/X/bLFlWVnLjZ/Qmi/Kvvx8VZ2VdZ/QyoplS5culVmK9QhgfrbZYbtuXTt3bNe2 7WHN+KfUjK9eXr28csniBQtmzy6vSW1dKQSwkBbdevbs0mXbju3atD5k82b8c8Yt X15VVblk4fzyOTMrUlsHLwQwUy167NirR7euHY9rzgVS2oSKpUsWLSyfO2P64sz+ HcoC+P5XM/tHb1v3+ezcqeO3Mvs31HxUsXjJ/LrP59x8/utmGwHMQKtddt5h+25d vp37v3jCkiULF8yd+cmkynT/ucoCOHJQuv+8dn132qFHl875fz4nLVq8oHzWzKlT VuT+r7aCAKan++479erZ9TjpGWvUjFn9rHDOp5MmpnLpmAxgq9369tmu28lbpPHP arYpCxfMnz3jkwnzpIfEhgA2W+f+u/Te/j/CuE4KmLxw9ZOIGZM+bs4XyJYCuG2/ vr2273Z8amNSVvPh/Hmzpk0Zt1B6SCQIYFNt1XePnXttF8bzPS+rL53VTyKmjJub /P/VQAB79N9l9dP37L61l7pPF5TPmTF1/CShFwbEggAmtc1e/Xbe4XTpFc2xuoRz Z0+bNM7/OWG8Ady2f9/ePXso6t6mxpXPmzn147H8/LhJCKCvnnvt1qfnydIrUjVt /oI5sz55udx5YHwB7HbkTttvl/9PNbI0uXze7E8njp0tvUMXAujW6bqewX5LKAW/ vs55SHwBVHZGScycO2/2fy2SXqEFAXSL+GKpM2SY8xBlj4DtANbZZ7T0Ai0IoFvk F8sJTzsPUfYIEMBD3pJeoAUBdIv8YjnyFechyh4BAkgAfRFANy4WZY8AASSAvgig GxeLskeAABJAXwTQjYtF2SNAAAmgLwLoxsWi7BEggATQFwF042JR9ggQQALoiwC6 cbEoewQI4NEvSS/QggC6RX6xEMD4DH5ReoEWBNAt8ovloHechyh7BAggAfRFAN0i v1g8fm1K2SNAAAmgLwLoFvnFQgDjQwB9EUC3yC8WAhgfAuiLALpFfrEQwPgQQF8E 0C3yi2WPCc5DlD0CBJAA+iKAbpFfLLtNch6i7BEggATQFwF0i/xi6TPNeYiyR+Cf BzgPUXZGSRFAXwTQLfKLZTv328QpewRG7ec8RNkZJUUAfRFAt8gvlh7uN9tW9ggQ QALoiwC6RX6xtK90HqLsESCABNAXAXSL/GIhgPEhgL4IoFvkF8sWXzoPUfYIEEAC 6IsAukV+sXj8EVD2CBBAAuiLALpFfrEQwPgQQF8E0C3yi4UAxocA+iKAbnFfLNVt nIdUdMhhR4rGDHQeEvfnlAB6I4BucV8sS7dxH9I+hx0pGjvAeUjcn1MC6I0AusV9 sSzu5DyEAGpDAH0RQLe4L5by7s5DCKA2Jw2XXqAFAXSL+2KZvb3zEAKozclPSS/Q ggC6xX2xTOvjPIQAakMAfRFAt7gvlsl9nYdoewA+3t15iLZTSogA+iKAbnFfLOP7 Ow/R9gAQQALoiwC6xX2xfLi38xBtD4BHALW9tDEhAuiLALppu/6T+dfXnIdoewA8 AqjunJL53p+lF2hBAN3ivlZGHOw8RNsDMLGf+xht55TMkGHSC7QggG5xXyuvH+48 RNsD8MnO7mO0nVMyBNAXAXSL+1p5cbDzEG0PAAEkgL4IoFvc18rTJzgP0fYAEEAC 6IsAusV9rfzp+85DtD0A03u7j9F2TskQQF8E0C3ua+XhHzoP0fYAzOzlPkbbOSVD AH0RQLe4r5V7znMeou0BIIAE0BcBdIv7Wrn1Uuch2h4AAkgAfRFAt7ivlWuvch6i 7QGY18N9jLZzSoYA+iKAbnFfK7+8yXmItgfA4xaH6s4pGQLoiwC6xX2tnH+38xBt D8DCLu5jtJ1TMgTQFwF0i/taOeNR5yHaHoAl27qP0XZOyRBAXwTQLe5r5bjnnIdo ewAqOrqP0XZOyRBAXwTQLe5r5aB3nIdoewCq2rmP0XZOyfzoD9ILtCCAbnFfK/3H Ow/R9gB4vNWxunNK5tx7pRdoQQDd4r5Wupc7D1H3AHj8qVZ3TokQQF8E0C3ua2WL L52HqHsACCAB9EQA3aK+VmpbeByT/Yx0EUAC6IkAukV9rUT5E9NWK52HqDunRAig LwLoFvW1Mqen+xh1D0DHCuch6s4pEY9Xt2MNAugW9bUyZVf3MeoegO3mOg9Rd06J /Py30gu0IIBuUV8rYwa6j1H3AOw2yXlI3O+LSQB9EUA3ddd/EiMHuY9R9wAMHOM+ Rt1JJUEAfRFAt6gvlVePcB+j7gE48F33MepOKgkC6IsAukV9qTzzHfcx6h6Aw95w H6PupJIggL4IoFvUl8qjZ7iPUfcADH7RfYy6k0ri4tulF2hBAN2ivlQ83hJE3wNw 8lPuY9SdVBJX3CC9QAsC6Bb1pXLj5e5j1D0AZz7iPkbdSSVBAH0RQLeoLxWPO+Lr ewB8Xges7qSSIIC+CKBb1JeKz53j1D0Al93iPkbdSSVBAH0RQLeoL5WThruPUfcA XHWt+xh1J5WEx1v9YQ0C6Bb1pXLwCPcx6h6AKL+xmQQB9EUA3aK+VDx+a0zfA3DH Re5j1J1UEgTQFwF0i/pSaV/pPkbdA3Dfj93HqDupJAigLwLoFvWl4vMHQN0DMGyI +xh1J5XEzb+QXqAFAXSL+VLxuR+qvgfgz99zH6PupJIggL4IoFvMl8qsHTwOUvcA vDjYfYy6k0qCAPoigG4xXyoT+3kcpO4B+Mc33MeoO6kkbrlMeoEWBNAt5kvlg309 DlL3AIzaz31M1HdE/d3PpBdoQQDd1F3/CcT5XGnCHh4H6TstfwTQFwF0i/lKeeEY 9zH6zn96b4+D9J2WPwLoiwC6xXyl/On77mP0nf+Crh4H6Tstf3ddIL1ACwLoFvOV 8uBZ7mP0nX91G4+D9J2Wv//9ifQCLQigW8xXis9TBYXnv8WX7mMUnpY3AuiLALrF fKVEetuA7uXuYxSeljef3wVEHQLoFvOV8l//7T5G4fnvM9p9jMLT8vbwD6UXaEEA 3WK+Ui66w32MwvM/7jn3MQpPyxsB9EUA3WK+UoY+5D5G4fmfe6/7GIWn5c3nbhCo QwDdYr5STn/MfYzC84/0K3tvj58mvUALAugW85US6RtI/s9/uo9ReFreCKAvAugW 85US6VuIW78h4F++K71ACwLoFvOVctgb7mMUnv/zx7qPUXha3gigLwLoFvOVcuC7 7mMUnv/bX3cfo/C0vPn8BwB1CKBbzFeKxwvmlrbPYUfKxg5wHxPzp5UA+iKAbjFf KR4B1Hj6c3q6j9F4Xr5ePkp6gRYE0C3mKyXSANa28Dgm+xliCKAvAugW85USaQDL ui5wHqLyvDy9eaj0Ai0IoFvMV0qsATzkLechKs/Lk8+NvlGHALrFfKXEGkCPX/FT eV6eRg6SXqAFAXSL+UoZNNJ5iMrTv+pa5yEqz8vTe/tLL9CCALrFfKUc/ZLzEJWn 73FHUJXn5cnnbfFQhwC6xXylePwusMrTf/oE5yEqz8uTz+sgUYcAusV8pcT6vbJ3 DnIeovK8PI3bU3qBFgTQLeYr5fy7XUfoPPvpvZ2H6DwxPxP7SS/QggC6xXylXHaL 6widZ+/xSmidJ+bnk52lF2hBAN1ivlJu/oXrCKVnv8tU1xFKT8zL9N7SC7QggG4x Xyn3n+M6QunZf+/PriOUnpiX2dtLL9CCALrFfKW4bxyn9Ox/fZ3rCKUn5qW8u/QC LQigW8xXyuuHu45QevYPDXUdofTEvCzuJL1ACwLoFvOV8sG+riOUnv2rRzgOqOiQ yw4ZVe2kF2hBAN2UJsDLrB0cB2g9+Ql7OA74rFUuO2T43A4MdQigm9YG+HBeKVpP vtJ1H2utJ+aH69oTD5Rb1JfKdnNLf1ztye82qfTH1Z6YF65rTzxQTlutkF6QpeOf Lf1xtZ045/7SH1d7Yl5arZReoAQBdGq3THpBln71m9IfV9uJOy8s/XG1J+alfaX0 AiUIoFOPOdILsuR6C3G1nXC9LYbaE/Pi+s4G1iGATjvMkF6QpX8eUPLDejMxrU/p j+s9Mx+9ZkovUIIAOvWdKL0gS4s6l/yw4ky0/LzURxWfmA/Xj4CwDgF02nOs9IJM lb5rgOJOHPROqY8qPjEfe30kvUAJAui09wfSCzJ14Z2lPqq4E6Xv9KX4xHx4vNkV 6hBAp8gD+NjppT6quBOPn1bqo4pPzAcB9EQAnSIP4NRdSnxwmeLfKR3fv8QHq9rk tkMEAfREAJ3i/iFI6VdMaH6eVLvllyU+mN8OEfwQxBMBdOo1XXpBtn55U/GPqe7E YW8U/5jqE/OwY9Sv3UoRAXSK+4XQZWWvHFn8Y6o7ce1VxT+m+sQ88EJoTwTQqfVy 6QXZWt6p+O+Nqu7Es8cX/ZDq8/LRplp6gRIE0C32q+WCu4p9RPeZf7pT0Q/pPjEP XNeeeKDcYr9aiv82nPIzL35HAOUn5rS8rfQCLQigW+xXS/FfBlF+5kOGFfmA8vNy m9dDeoEWBNAt+svlvh8X+YDyM3/wrCIfUH5ebhP7SS/QggC6RX+5VPQofM/XSuVf SBV7KXT0n1DXPX6wAQF0i/96ueGKgn9b/YkX+Vmo+vNyev5Y6QVaEEC3+K+XRb0K lkL9iZ/6RKG/q/603O4+X3qBFgTQzcAF84cfFfq76k+88Dc31Z+W28W3Sy/QggC6 Gbhgancv8AvPmu+EsNa/v1Lgbxr4dJYd8pb0Ai0IoJuFK+bdAzf9e/rPu7b1pj/d 0f6THR/V7WqkJ2hBAN0qOkgvyEGBWyLoD2DZaY9v8rciOCunMQOlF6hBAD1YuGaq 9p7S+G9FcNqPnNn470RwUm5//IH0AjUIoAcTF83UAY1+EhzDWU/ZtdHfiOGk3E55 UnqBGgTQg42r5t2DGn7jKIqzbnRbqNhvBL1WVccvpCeoQQB9RNECp0avno3ipBu9 HiSKc3J69QjpBXoQQB82rpuyZ75T//+K4qQbRj2KU3IrehMIbIIA+jBy4ZS9fvTG NxOP45zLu2/8a/2va/Qzb7s4Pne5IIBerPyJGvPNRev/MpJT3v+99X+1sqXkjhzd eaH0AkUIoJdIauBWPvSFdX8VySn/z3+u+4tIzsetYocq6QmKEEA/Zi6fsj+eteZH iLH8vPSjvdb8ry0+dxwXj9svll6gCQH0YyeAZZ9c/HRZRCfcdUFZRGfjVt678M0d URAB9GToEip7/aKP4jnfS28t23Os9Igc8SPgRAigr2iK4OO5SwrcHUanN34Szan4 eOlo6QW6EEBfpgIIpebsvkx6gi4E0BsFROiq9h8vPUEZAuiPAiJwQx+SXqANAUyA AiJo11wtvUAdApgEBUTA6F9yBDARCohgXXm99AKFCGAyFBBhWnzmc9ITNCKACZn5 lXqoMvGoGdITVCKASRn6rVKoMWwoN4FuEgKYHF8GIyzTf/a09AStCGATbLlKegGw 0QPn8lVJUxHAJtljnPQCYK03zue3P5qOADbRZ62kFwBlZaOveFF6gmoEsMlWbCW9 ANb9+5rh0hOUI4DN8K0X3McAWXnnOp79NRcBbJa9P5BeAKOqnr9xtPSGCBDAZmpb Kb0ABn3y+A289VEaCGDz8ZUwclX16u/52jclBDANrZbwM2Hk5INH7+Jtj1JDANOx tL30AtgwZqD0gqgQwHQs2UZ6AWwYOUh6QVQIYDoWd5ReABsIYKoIYDoIIPJBAFNF ANNBAJEPApgqApgOAoh8EMBUEcB0EEDkgwCmigCmhLukIhcEMFUEMCUEELkggKki gCkhgMjF21+XXhAVApgSAohcvHmo9IKoEMCUEEDk4tUjpBdEhQCmhAAiFy8fJb0g KgQwJQQQufjbt6UXRIUApoQAIhfPHyu9ICoEMCUEELn4y3elF0SFAKaEACIXw0+S XhAVApgSAohcPH6a9IKoEMCUEEDk4tEzpBdEhQCmhAAiFw//UHpBVAhgSgggcnH/ OdILokIAU0IAkYu7LpBeEBUCmBICiFzc/AvpBVEhgCkhgMjF1ddIL4gKAUwJAUQu LrtFekFUCGBKCCBycd490guiQgBTQgCRiyHDpBdEhQCmhAAiFyc8Lb0gKgQwJQQQ uTj8dekFUSGAKSGAyMV+o6QXRIUApoQAIhe7TJVeEBUCmBICiFx0WSi9ICoEMCUE ELnYvEZ6QVQIYEoIIPJQ1U56QVwIYEoIIPIwr4f0grgQwJQQQOTh052kF8SFAKZk aXvpBbDgo72kF8SFAKaFp4DIwT8PkF4QFwKYFgKIHLz2TekFcSGAaSGAyMEz35Fe EBcCmBYCiBwMGyK9IC4EMC0EEDm45zzpBXEhgGkhgMjBjZdLL4gLAUwLAUQOLrlN ekFcCGBaCCBywA2h00UA00IAkYMjX5FeEBcCmBYCiBzsMUF6QVwIYFoIIHLQdrn0 grgQwLQQQGSvtoX0gsgQwLQQQGRvYRfpBZEhgGkhgMje1F2kF0SGAKalooP0AsRv 9D7SCyJDAFPDU0Bk7h/fkF4QGQKYGgKIzHEzmJQRwNQQQGTuoaHSCyJDAFNDAJG5 Wy+VXhAZApgaAojMXX6j9ILIEMDUEEBkbuhD0gsiQwBTQwCRuaNfkl4QGQKYGgKI zPWbKL0gMgQwNQQQmWtTLb0gMgQwNQQQWeNeCGkjgKkhgMjcIW9JL4gMAUwNAUTm +BI4ZQQwNQQQWZu7nfSC2BDA9FBAZGzkIOkFsSGA6SGAyNjjp0kviA0BTA8BRMau vUp6QWwIYHoIIDJ20nDpBbEhgOkhgMhY1wXSC2JDANNDAJGtBV2lF0SHAKaIAiJT 7+0vvSA6BDBFBBCZeuJU6QXRIYApIoDI1FXXSi+IDgFMEQFEprgbYOoIYIoIIDLF bwKnjgCmiAAiS9N7Sy+IDwFMEwVEhl4+SnpBfAhgmgggMvS7n0kviA8BTBMBRIbO eFR6QXwIYJoIIDLUabH0gvgQwDQRQGRnWh/pBREigKmigMjMs8dLL4gQAUwVAURm +D2QDBDAVBFAZGbQSOkFESKAqSKAyErFtvzpSh8BTBd/RpGRNw6TXhAjApguAoiM XH+l9IIYEcB0EUBkZL9R0gtiRADTRQCRDW6HnwkCmDIKiEy8OFh6QZQIYMoIIDJx 6a3SC6JEAFNGAJEJfhE4EwQwbRQQGfhgX+kFcSKAaSOAyMB1v5ZeECcCmDYCiAz0 mSa9IE4EMG1L20svQHw+3l16QaQIYOp4CojU3Xi59IJIEcDUEUCkrsc86QWRIoDp o4BI2YiDpRfEigCmjwAiZUMfkl4QKwKYPgKIdC3oXiM9IVYEMAMUEKl6+IfSC6JF ADNAAJGq/uOlF0SLAGaBAiJF7xwkvSBeBDALBBApOuFp6QXxIoBZqN5aegHiMb6/ 9IKIEcBM8BQQqTnzEekFESOAmSCASMuk3aQXxIwAZoMCIiW8CDpLBDAby1tLL0Ac xg6QXhA1ApgRngIiFcc9J70gagQwKxQQKXjrEOkFcSOAWSGAaL7afpOkJ8SNAGaG AqLZHjhbekHkCGBmCCCaa/qun0tPiBwBzA4FRDMd+7z0gtgRwAxRQDTL0ydIL4ge AcwQAURzTO+3QnpC9AhgliggmuGwN6QXxI8AZooCosnuuEh6gQEEMFsUEE309tel F1hAALNFANE0M/tXSk+wgABmjAKiKaoOGCc9wQQCmDUKiCYYMkx6gQ0EMHMUEInd eLn0AiMIYPYoIBIaNkR6gRUEMAcUEInwGyC5IYA52KxGegE0eflo/pOZFwKYhxZf Si+AHi8N5j+YuSGAueA5IHz97Vie/+WHAOaEP9Tw8tTJ0gtMIYB5oYDwcOeF0gts IYC5oYBwuuIG6QXGEMD8UECUtviHz0pPsIYA5ogCopRJh8+WnmAOAczTVtzhF0W9 dPxK6Qn2EMB88SQQRdx+sfQCiwhgvgggithvlPQCiwhgvgggiuAdQCQQwHwRQBRx 3HPSCywigPkigCjitMelF1hEAPNFAFHEj/4gvcAiApgvAogizr1XeoFFBDBfBBBF EEAJBDBfBBBFEEAJBDBfBBBFEEAJBDBfBBBF/Py30gssIoD5IoAoggBKIID5IoAo 4qI7pBdYRADzRQBRxDn3Sy+wiADmiwCiCH4TRAIBzBcBRBH8LrAEApgvAogiuBuM BAKYLwKIIrgfoAQCmC8CiCJ2myS9wCICmC8CiCK6LpBeYBEBzBcBRBFcihJ41PNF AFFYRUfpBSYRwHwRQBQ2Y0fpBSYRwHxVdJBegDCNGSi9wCQCmDOeAqKg174pvcAk ApgzAoiCnjhVeoFJBDBnBBAF3X6x9AKTCGDOCCAKOv9u6QUmEcCcEUAUdPAI6QUm EcCcEUAU1Ha59AKTCGDOCCAKmd9NeoFNBDBvFBAFjBwkvcAmApg3AogChg2RXmAT AcwbAUQBV9wgvcAmApg3AogCBo2UXmATAcwbAcSmqtrz50IEAcwdf9KxiQ/2lV5g FAHMHQHEJh4aKr3AKAKYOwKITZz+mPQCowhg7gggGqttvUJ6glEEMH8UEI1wN1Qp BDB/BBCN3HaJ9AKrCGD+CCAa2We09AKrCGD+CCAamt5beoFZBFAABUQDvAhGDAEU QADRwEHvSC8wiwAKIICob+ou0gvsIoASKCDqufVS6QV2EUAJBBD19JopvcAuAiiC AmKDNw6TXmAYARRBALHBMS9ILzCMAIoggFhvcl/pBZYRQBkUEOtccJf0AssIoAwC iLWm9+HPgiACKIQ/9VjjktukF5hGAIUQQNSZvlON9ATTCKAUCojVhj4kvcA2Aiil qo30AsjjzZCEEUAxPAVE2aFvSi8wjgDKoYDmPXWy9ALrCKAcAmjd3F2qpSdYRwAF UUDjhgyTXmAeAZREAU3727elF4AASiKAls3YjTcDFkcARVFAw/gJcAAIoCwKaBb3 gQ4BARRGAY16cbD0ApQRQHHVW0svgIRxe38uPQFlBFAeTwEtmjdggfQE1CGA4iig PUv2nyw9AWsQQHkU0Jrlh74vPQFrEcAAUEBjTnlSegHWIYAhoICW1A59WHoC1iOA QaCAdlSf+WfpCdiAAIaBAlpRNfht6QnYiAAGggLaMO+IcdITUA8BDMXKltILkL2J 3yiXnoD6CGAwWn0mvQBZe+sobgATFgIYEL4MjtwdF0kvQCMEMCQUMGYLzn5WegIa I4BBqWwrvQBZ+eexC6UnYBMEMDA8CYzT8ht+Iz0BBRDA0HzWSnoB0jf2uOnSE1AI AQzOZjXSC5CyZbdexzP7MBHAAHXmXnFRefl0vvsXKgIYJJ4vxGPy5cOlJ6AoAhgm vg6OxLxbbuO/ZgEjgKFquVJ6AZqt4v4rVklvQCkEMFxtqqQXoFkW//HK5dIbUBoB DFlrrh+9Fj54dbX0BrgQwLBtyVdQOk2573be91IBAhi8E/4ivQBJvXPzX6UnwAsB VKDvROkFSGDe07dNkt4ATwRQhc3O+KP0BPgZ8fv/43UvehBALbrN4JbRwRs7/B7u +KwKAVRkV76yCtnk5+6ZLL0BCRFAXfh2YKAW3/cA/3lSiAAqwy1TwzR6H+kFaAoC qAzfYA/TjB2lF6ApCKAyBDBM1W2kF6ApCKAyBDBQnRZLL0ATEEBlCGCgBo2UXoAm IIDKEMBADRkmvQBNQACVIYCB+hXv+qYRAVSGAAbq7vOlF6AJCKAyBDBQw0+SXoAm IIDKEMBA/eMb0gvQBARQF/oXqvH9pRegCQigLgQwVAu6Si9AExBAXQhgsDbnnUwV IoC6EMBg9ZkmvQDJEUBdCGCwjn5JegGSI4C6EMBgnX+39AIkRwB1IYDBuvFy6QVI jgDqQgCDNWyI9AIkRwB1IYDBevko6QVIjgCqUtFBegGK4ab4GhFAVXgCGK45PaUX IDkCqAoBDFdtC+kFSI4AqkIAA7b9bOkFSIwAqkIAA/bN16QXIDECqAoBDNi590ov QGIEUBUCGLDrr5RegMQIoCoEMGCPnCm9AIkRQFUIYMBeHCy9AIkRQE2WbCO9AMV9 sK/0AiRGADXhCWDIZm8vvQCJEUBNCGDIeCW0QgRQEwIYtO7l0guQFAHUhAAG7bA3 pBcgKQKoCQEM2jn3Sy9AUgRQEwIYNF4JrQ8B1IQABo1XQutDADUhgEHjntD6EEBF uB902MYMlF6ApAigIjwBDFt5d+kFSIoAKkIAA7fFl9ILkBABVIQABm63SdILkBAB VIQABu7Ev0ovQEIEUBECGLhf3iS9AAkRQEUIYODuukB6ARIigIoQwMD99UTpBUiI ACpCAAM3cpD0AiREAPWgf6Gbsqv0AiREAPUggKGrbC+9AAkRQD0IYPA6LZZegGQI oB4EMHiHvim9AMkQQD0IYPB+fJ/0AiRDAPUggMG74QrpBUiGAOpBAIM3bIj0AiRD APUggMF75UjpBUiGAKqxlNdYBG/sAOkFSIYAqsETwPAt6iy9AMkQQDUIoAJbr5Be gEQIoBoEUIH935NegEQIoBoEUIGzH5BegEQIoBoEUAFeCKgMAVSDACrw6BnSC5AI AVSDACrwxmHSC5AIAdSC/mnw8e7SC5AIAdSCAGpQ0VF6ARIhgFoQQBU6VkgvQBIE UAsCqAJ3BNSFAGpBAFU47x7pBUiCAGpBAFW49VLpBUiCAGpBAFV48hTpBUiCAGpB AFUYcbD0AiRBAJWgfzrw1sC6EEAlCKAOVe2kFyAJAqgEAVSixzzpBUiAACpBAJUY /KL0AiRAAJUggEpcfLv0AiRAAJUggErcc570AiRAAJUggEo8f6z0AiRAAHWo6CC9 AH4+3Ft6ARIggDqsbCm9AH4WdJVegAQIoA58BaxGm2rpBfBHAHUggGocPEJ6AfwR QB0IoBrcEEsTAqgDAVTjf/5TegH8EUAdCKAafz1RegH8EUAdCKAa//qa9AL4I4Aq rNhKegF8zd1OegH8EUAVeAKoSMvPpRfAGwFUgQAqss9o6QXwRgBVIICKDH1IegG8 EUAVCKAiN14uvQDeCKAKBFCRP31fegG8EUAVCKAi7xwkvQDeCKAGy1tLL4C/mb2k F8AbAdSAJ4CqbF4jvQC+CKAGBFCVPSZIL4AvAqgBAVRlyDDpBfBFADUggKrwOhg9 CKAGBFCVp06WXgBfBFADAqjKe/tLL4AvAqgA94LRpby79AL4IoAK8ARQGd4XSQ0C qAABVObQN6UXwBMBVIAAKvPz30ovgCcCqAABVObec6UXwBMBVIAAKvP3b0kvgCcC GL5l7aQXIJnx/aUXwBMBDB9PALVZ1kF6ATwRwPARQHV6zZReAD8EMHwEUJ2Tn5Je AD8EMHwEUJ1rrpZeAD8EMHwEUJ1Hz5BeAD8EMHwEUJ0RB0svgB8CGLzqraUXIKlZ O0gvgB8CGDyeACrU8nPpBfBCAINHABXa/z3pBfBCAINHABW68E7pBfBCAINHABXi dghKEMDgEUCFXjlSegG8EMDQVbWRXoDkPt1JegG8EMDQ8QRQo9otaqQnwAcBDB0B VGmf0dIL4IMAho4AqnTePdIL4IMAho4AqnT3+dIL4IMAho4AqvTS0dIL4IMABq6y rfQCNMXUXaQXwAcBDBxPAHXix8A6EMDAEUClBoyVXgAPBDBwBFCpH98nvQAeCGDg CKBSd1wkvQAeCGDgCKBSLw6WXgAPBDBs/BBYqwl7SC+ABwIYNp4AalXNTSw0IIBh I4Bq7TFBegHcCGDYCKBaZz8gvQBuBDBsBFAtfgysAQEMGwFUi98G1oAABo3bQes1 rY/0ArgRwKDxBFAx3htYAQIYNAKo2CFvSS+AEwEMGgFU7Jc3SS+AEwEMGgFUbNgQ 6QVwIoBBI4CKvXug9AI4EcCQrWwpvQBNt6Cr9AI4EcCQ8QRQte7l0gvgQgBDRgBV O/UJ6QVwIYAhI4Cq3fwL6QVwIYAhI4CqPXu89AK4EMCALWsnvQDNMW5P6QVwIYAB 4wmgbtVt+QyGjgAGjMtHuX1GSy+AAwEMGAFU7sI7pRfAgQAGjAAqd/850gvgQAAD RgCV+8c3pBfAgQCG67NW0gvQPHN6Si+AAwEMF08A1eu0WHoBSiOA4SKA6p3ypPQC lEYAw0UA1bv1UukFKI0AhosAqvf3b0kvQGkEMFi8I5x+03tLL0BpBDBYPAGMQJtq 6QUoiQAGiwBG4JgXpBegJAIYLAIYgeuvlF6AkghgsAhgBJ75jvQClEQAQ1XZVnoB mm/KrtILUBIBDBVPAKPQ8nPpBSiFAIaKAEbh0DelF6AUAhgqAhiFX/1GegFKIYCh IoBRePIU6QUohQAGqqKD9AKkYcxA6QUohQAGiieAcVjejs9kyAhgoLhsIrHfKOkF KIEABooARuKS26QXoAQCGCgCGIlhQ6QXoAQCGCgCGIlR+0kvQAkEMEz0LxZV7flc BowAhomLJhoHviu9AMURwDARwGhceb30AhRHAMNEAKMx/CTpBSiOAAaJe2HFY3Jf 6QUojgAGiSeAEdl6hfQCFEUAg0QAI8L7ggSMAAaJAEbkxsulF6AoAhgkAhgR3h09 YAQwRNVbSy9Aemb2kl6AoghgiHgCGJUuC6UXoBgCGCICGJUhw6QXoBgCGCICGJV7 zpNegGIIYIgIYFTeOkR6AYohgAGif3FZ2EV6AYohgAEigJHpO1l6AYoggAEigJG5 4C7pBSiCAAaIAEbmjz+QXoAiCGCACGBkPthXegGKIIDhoX+xqW5XIz0BhRHA8BDA 6HzzNekFKIwAhocARocbwoSKAIaHAEbn5aOkF6AwAhgc+hefeT2kF6AwAhgcAhih nT6VXoCCCGBwCGCELrpDegEKIoDBIYAReuJU6QUoiACGZlk76QVI38R+0gtQEAEM DU8Ao9SmWnoBCiGAoSGAUTppuPQCFEIAQ0MAo3THRdILUAgBDA0BjNLbX5degEII YGDoX5yWbCu9AIUQwMAQwEjtM1p6AQoggIEhgJG68nrpBSiAAAaGAEbq6ROkF6AA AhiWqjbSC5CNaX2kF6AAAhgWngBGq8tC6QXYFAEMCwGM1tCHpBdgUwQwLAQwWo+c Kb0AmyKAQVnaXnoBsjK+v/QCbIoABoUngBHjfggBIoBBIYARO/UJ6QXYBAEMCgGM 2P/+RHoBNkEAg0IAI/b+V6UXYBMEMCT0L2bVHb6QnoDGCGBICGDUjn1eegEaI4Ah IYBR+93PpBegMQIYEgIYtZGDpBegMQIYEPoXt6oONdIT0AgBDAgBjNzgF6UXoBEC GBACGDm+CRgcAhgQAhg5vgkYHAIYDvoXO74JGBwCGA4CGL1jXpBegIYIYDgIYPTu vFB6ARoigOEggNF790DpBWiIAAaD/sWPXwcODQEMBgE04PhnpRegAQIYDAJowO9/ Kr0ADRDAYBBAA8YOkF6ABghgKOifCbwxSFgIYCgIoAmnPya9APURwFAQQBMeGiq9 APURwEAsaye9AHmY2E96AeojgIHgCaARHSukF6AeAhgIAmjEj/4gvQD1EMBAEEAj Hj9NegHqIYBhqGojvQD5mNZHegHqIYBh4AmgGTvOkF6AjQhgGAigGb+8SXoBNiKA YSCAZrxwjPQCbEQAg0D/7FjQVXoBNiKAQSCAhhz4rvQCbEAAg0AADbnlMukF2IAA BoEAGjLiYOkF2IAAhoD+WcJ98QNCAENAAE05+SnpBViPAIaAAJry8A+lF2A9AhiA yrbSC5CnKbtKL8B6BDAAPAE0ptdM6QVYhwAGgAAac/mN0guwDgEMAAE05uWjpBdg HQIoj/5Zs6QTn/NAEEB5XAzmfOvv0guwFgGURwDN+f1PpRdgLQIobml76QXI2/j+ 0guwFgEUxxNAg7oslF6ANQigOAJo0EV3SC/AGgRQHAE06NnjpRdgDQIojf5ZNL+b 9AKsQQClEUCTBo2UXoA6BFAaATTp9oulF6AOAZRGAE36cG/pBahDAIXRP6PaV0ov QBkBFEcAjTrnfukFKCOA4gigUU+eIr0AZQRQGv2zak5P6QUoI4DSCKBZX31fegEI oDQCaBYvhAkBAZRFAM0aO0B6AQigMPpnGHeECQABFEUADfv5b6UXgADKIoCGvThY egEIoCj6Z1nFtnz+xRFASVwAph33nPQCEEBJBNC0B8+SXgACKKiqjfQCSPpkZ+kF IICCeAJoXN/J0gvMI4CCCKBx1/1aeoF5BFAQATTuX1+TXmAeAZRD/6yrbVstPcE6 AiiHAJp39gPSC6wjgHIIoHnDT5JeYB0BFEP/MK+H9ALrCKAYAoiyg0dILzCOAIoh gCi780LpBcYRQCnL2kkvgLyJ/aQXGEcApfAEEKvtOEN6gW0EUAoBxGpXXyO9wDYC KIUAooxfBpFGAIXQP9Sp7VApPcE0AiiEAGKN8+6RXmAaARRCALHG374tvcA0AiiD /mGtik410hMsI4AyCCDWOWm49ALLCKAMAoh1Hj1DeoFlBFAE/cN6s3aQXmAZARRB ALHB/u9JLzCMAIoggNjgjoukFxhGACUsbS+9AOGYsIf0AsMIoASeAKKeXjOlF9hF ACUQQNRz1bXSC+wigBIIIOrhhghyCKAA+of6uCGCHAIogACigZ/+XnqBWQRQAAFE A9wQQQwBzB/9Q0PcEEEMAcwfAUQjpz4hvcAqApg/AohG/vR96QVWEcDc0T80Vt5d eoFVBDB3BBCbOPol6QVGEcDcEUBs4sGzpBcYRQDzRv+wqem9pRcYRQDzRgBRwH6j pBfYRADzRgBRADcFlEEAc7asnfQChGhiP+kFNhHAnPEEEAXtMlV6gUkEMGcEEAVd f6X0ApMIYM4IIAoaM1B6gUkEMF/0D0V0XSC9wCICmC8CiCIuv1F6gUUEMF8EEEWM HCS9wCICmCv6h2Jq2y2XnmAQAcwVAURR590jvcAgApgrAoiiXjhGeoFBBDBP9A/F Lev0hfQEewhgngggShgyTHqBPQQwTwQQJfz1ROkF9hDAHNE/lLK4M39C8kYAc8Qf b5R08lPSC8whgDkigCiJN4fLHQHMD/1DafO7SS8whwDmhwDC4ZgXpBdYQwDzQwDh MGyI9AJrCGBu6B9c5vSUXmANAcwNAYTToW9KLzCGAOaGAMLp/nOkFxhDAPNC/+A2 vbf0AmMIYF4IIDx89X3pBbYQwLwQQHi4+3zpBbYQwJzQP/iYsqv0AlsIYE4IILz0 Hy+9wBQCmBMCCC+3Xyy9wBQCmI+l7aUXQIcJe0gvMIUA5oMngPC0y1TpBZYQwHwQ QHi68XLpBZYQwFxUdJBeAC3G7Sm9wBICmAueAMLbjjOkFxhCAHNBAOHt+iulFxhC AHNBAOFtzEDpBYYQwDzQPySw/WzpBXYQwDwQQCRwzdXSC+wggHkggEhg9D7SC+wg gDmgf0ike7n0AjMIYA4IIBL59XXSC8wggDkggEhk1H7SC8wggNmjf0io6wLpBVYQ wOwRQCR0xQ3SC6wggNkjgEjovf2lF1hBADNH/5BYp8XSC4wggJkjgEjsslukFxhB ADNHAJHYPw+QXmAEAcwa/UNytR2XSk+wgQBmjQCiCS6+XXqBDQQwawQQTfDOQdIL bCCAGaN/aIraDpXSE0wggBkjgGiSi+6QXmACAcwYAUSTvPZN6QUmEMBs0T80TXWn FdITLCCA2SKAaKIL7pJeYAEBzBYBRBO9cqT0AgsIYKboH5qqetuV0hMMIICZIoBo sp//VnqBAQQwfd0H7nmz9AZEY9H/zfzow3nSK2JFAFPUau999/ip9AhEafzMT8aP Gs0PhtNGANOx+0F7nye9AdGbOWni6BETpFfEhAA2W4cjDz1fegMMqRj34Rsvc7OY dBDAZmlx/F+kJ8CkyW8/80yN9IgIEMCm633Gf0tPgGHLRr36f9OkR2hHAJuo5Y/5 ZXWI+9cj/7tKeoNqBLBJjntGegGwxtLXHnxWeoNiBDC5Fl9KLwDqmXTP7/h2YBMR wMT47Q6EZtYdN0lPUIoAJkT+EKLpN9wrPUElAphI/4+kFwCFjTpznPQEhQhgEjz9 Q7iqH7xAeoI+BNDfsnbSC4BSPj7xY+kJ2hBAbzz9Q+gWX8F3ApMhgL7oH8JX+/BQ 6Qm6EEA/rZdLLwB8jDiqWnqCJgTQC0//oMXkr5dLT1CEAPqgf9BjysEU0BsB9ED/ oMnUgyigLwLoRv+gCwX0RgCd6B+0mTKQH9r5IYAulW2lFwBJTfzeWOkJOhBAB57/ QaPpvaUX6EAAHQggVPrLd6UXqEAAS6N/0Knquy9LT9CAAJZE/6DVvB2+kJ6gAAEs iQBCrZeOll6gAAEshf5Br+Xff156QvgIYAn0D5qV78R9EVwIYAkEEKr97dvSC4JH AIujf9Ct8pAPpSeEjgAWRwCh3MR+0gtCRwCLon/QrvayW6UnBI4AFkP/oF95d+kF gSOAxRBAROCx06UXhI0AFkH/EIOKbqukJwSNABZBABGF1w+XXhA0AlgY/UMclu03 WXpCyAhgYQQQkRi3p/SCkBHAgugfYlF98gvSEwJGAAuhf4gHr4YugQAWQgARj+rT n5aeEC4CWAgBRETGDpBeEC4CWAD9Q0yqjxohPSFYBLAAAoioPH+s9IJgEcBN0T/E paInd0YtggBuigAiLrVXXys9IVQEcBP0D7FZ1kF6QagI4CYIIKJz54XSCwJFADdB ABGdf39FekGgCGBj9A/xWdRZekGgCGBjBBDx4ZuARRDAxgggIvTImdILwkQAGyOA iBA3xSqMADZC/xAjvglYGAFshAAiRpXtpReEiQA2QgARpdsvll4QJALYCAFElEYO kl4QJALYEP1DnOb0lF4QJALYEAFEnJZuI70gSASwIQKIOFV1WSE9IUQEsCECiEg9 NFR6QYgIYEMEEJHifgiFEMAG6B9iNb+b9IIQEcAGCCBixU9BCiGADRBAxKqqnfSC EBHABgggonXvudILAkQAGyCAiNbofaQXBIgA1kf/EK95PaQXBIgA1kcAES/uCl0A AayPACJe/BSkAAJYHwFExH71G+kF4SGA9RFAROzFwdILwkMA66F/iNnHu0svCA8B rIcAImYLukovCA8BrIcAIma8L8imCGA9BBAxq+47W3pCcAhgPQQQUXvwLOkFwSGA 9RBARO3dA6UXBIcAbkT/ELcZO0ovCA4B3IgAIm5LtpVeEBwCuBEBRNyquy6XnhAa ArgRAUTcak8eLj0hNARwIwKIyD19gvSC0BDAjQggIjd2gPSC0BDADegfYsc9URsj gBtRQESO9wZujABuQP8Qu7nbSS8IDQHcgAAidtwOoTECuAEBROy4K35jBHADAojo XXKb9ILAEMANCCCix5ujN0IANyCAiB5vC9IIAdyAACJ6H+0lvSAwBHA9+of4Leos vSAwBHA9Aoj48WPgRgjgegQQ8VveVnpBYAjgegQQBvz8t9ILwkIA1yOAMOCOi6QX hIUArkcAYcBfT5ReEBYCuB4BhAHv7S+9ICwEcB36Bwum95ZeEBYCuA4BhAXLOkgv CAsBXIcAwgJeB9MQAVyHAMKC2jMek54QFAK4DgGECVdfI70gKARwHQIIEx48S3pB UAjgOgQQJnBDrAYI4DoEECaM3kd6QVAI4Fr0DzbwxnANEMC1CCBs4IZYDRDAtQgg bKhuI70gKARwLQIII059QnpBSAjgWgQQRvzqN9ILQkIA1yKAMOK+H0svCAkBXIsA wohXj5BeEBICuAb9gxXj+0svCAkBXIMAwor53aQXhIQArkEAYQUvBKyPAK5BAGEF AayPAK5BAGEFr4SujwCuQQBhxsW3Sy8ICAFcgwDCjIeGSi8ICAFcgwDCjDcPlV4Q EAJYh/7Bjo93l14QEAJYhwDCjnk9pBcEhADWIYCwg7cGrocA1iGAsIO3Bq6HANYh gLCDV0LXQwDrEEDYwSuh6yGAdQggDDn7AekF4SCAdQggDLn5F9ILwkEA6xBAGPLk KdILwkEA6xBAGPLugdILwkEAy+gfbJmxo/SCcBDAMgIIW3gdzEYEsIwAwhZeB7MR ASwjgDDm3HulFwSDAJYRQBhz2yXSC4JBAOtctdtp0hOAXEyfOXPiNdIjwkEANzpt z52/L70ByMisGTOnfvSY9IrQEMBNnLbXTnQQ8Zg5Y9YnYylfYQSwmFP36sPXxdBs +oxZn459XHpF2Aigyy/6/0B6ApDIhDmzx90kPUIHAujp3D1/soX0BqCk2g/mzPjo 99IrVCGAyZy8145nEEKEpXbc3DnTx/5ZeoZGBLBpTttrx9OlN8C8CfPmTufnG81B AJvnewO2/w+eESJftR/Onzvr309Kz4gBAUzJD77S45TNpUcgarXj5pfPHfOI9Iyo EMC0/eAr3U/hOSHSU/vhwgXz6F42CGBmvj2wW7fvkkI0Tc3YRQvLyz98XnpH5Ahg Do4a0K37qaQQbjXvL144r/zfL0nvMIMA5uvofTp16fQtvlmIjWrHV1QsWrDog79L D7GIAMo5Yt/OnToeRwwtqhmztGLJooWjXpEeYh0BDMThB3Ts2PF4vk6OV82/Kpct WbLk3dekh6AeAhikgw5o37FD+2PpoWY171dWLlu6ZNm7I6SXoCgCqMJBB7dv367d cS34ejlcNbXvVleuTt6ytwmeHgRQqa8d1rpthzZtBm9GEyXU1P7zs+rly5dWVb/+ nvQWNAMBjMheR7Zq27Ztq61bHUEWU1NT+6+Vn634bEVVVdWKl8dKr0HKCKABfY/d svXWq23VquVhpLGgmtr3V65ctWLlZ6tVf/7cJOk9yAkBNK7ndzZfncZWLVttudVW Lbf8xmabtZBelImastr3V636fNXKlZ+vWLVideW+fHq29CYEgAACMIsAAjCLAAIw iwACMIsAAjCLAAIwiwACMIsAAjCLAAIwiwACMIsAAjCLAAIwiwACMIsAAjCLAAIw iwACMIsAAjCLAAIwiwACMIsAAjCLAAIwiwACMIsAAjCLAAIwiwACMIsAAjCLAAIw iwACMIsAAjCLAAIwiwACMIsAAjCLAAIwiwACMIsAAjCLAAIwiwACMIsAAjCLAAIw iwACMIsAAjCLAAIwiwACMIsAAjCLAAIwiwACMIsAAjCLAAIwiwACMIsAAjCLAAIw iwACMIsAAjCLAAIwiwACMIsAAjCLAAIwiwACMIsAAjCLAAIwiwACMIsAAjCLAAIw iwACMIsAAjCLAAIwiwACMIsAAjCLAAIwiwACMIsAAjCLAAIwiwACMIsAAjCLAAIw iwACMIsAAjCLAAIwiwACMIsAAjCLAAIwiwACMIsAAjCLAAIwiwACMIsAAjCLAAIw iwACMIsAAjCLAAIwiwACMIsAAjCLAAIwiwACMIsAAjCLAAIwiwACMIsAAjCLAAIw iwACMIsAAjCLAAIwiwACMIsAAjCLAAIwiwACMIsAAjCLAAIwiwACMIsAAjCLAAIw iwACMIsAAjCLAAIwiwACMIsAAjCLAAIwiwACMIsAAjCLAAIwiwACMIsAAjCLAAIw iwACMIsAAjCLAAIwiwACMIsAAjDr/wF2yDi1UaI7JgAAAABJRU5ErkJggg=="/></symbol><g mask="url(#b)"><g transform="rotate(.193) scale(.36014)"><symbol id="c" viewBox="0 0 1280 1280"><image width="1280" height="1280" xlink:href="data:image/png;base64, iVBORw0KGgoAAAANSUhEUgAABQAAAAUACAIAAACXhmigAAAACXBIWXMAAA7EAAAO xAGVKw4bAADuE0lEQVR4nOzdh38UV5rvf+UcO0iIKHLOYMBgG3Bgwp3Znblzd3d2 Zvb+dl939+5feR3GZEw2UYCEcu5UHao6/I7UtoYBGUvqek6lz/vFgKxlnz5Iperz rZOqqwAAAAAACIBqpxsAAAAAAIAOBGAAAAAAQCAQgAEAAAAAgUAABgAAAAAEAgEY AAAAABAIBGAAAAAAQCAQgAEAAAAAgUAABgAAAAAEAgEYAAAAABAIBGAAAAAAQCAQ gAEAAAAAgUAABgAAAAAEAgEYAAAAABAIBGAAAAAAQCAQgAEAAAAAgUAABgAAAAAE AgEYAAAAABAIBGAAAAAAQCAQgAEAAAAAgUAABgAAAAAEAgEYAAAAABAIBGAAAAAA QCAQgAEAAAAAgUAABgAAAAAEAgEYAAAAABAIBGAAAAAAQCAQgAEAAAAAgUAABgAA AAAEAgEYAAAAABAIBGAAAAAAQCAQgAEAAAAAgUAABgAAAAAEAgEYAAAAABAIBGAA AAAAQCAQgAEAAAAAgUAABgAAAAAEAgEYAAAAABAIBGAAAAAAQCAQgAEAAAAAgUAA BgAAAAAEAgEYAAAAABAIBGAAAAAAQCAQgAEAAAAAgUAABgAAAAAEAgEYAAAAABAI BGAAAAAAQCAQgAEAAAAAgUAABgAAAAAEAgEYAAAAABAIBGAAAAAAQCAQgAEAAAAA gUAABgAAAAAEAgEYAAAAABAIBGAAAAAAQCAQgAEAAAAAgUAABgAAAAAEAgEYAAAA ABAIBGAAAAAAQCAQgAEAAAAAgUAABgAAAAAEAgEYAAAAABAIBGAAAAAAQCAQgAEA AAAAgUAABgAAAAAEAgEYAAAAABAIBGAAAAAAQCAQgAEAAAAAgUAABgAAAAAEAgEY AAAAABAIBGAAAAAAQCAQgAEAAAAAgUAABgAAAAAEAgEYAAAAABAIBGAAAAAAQCAQ gAEAAAAAgUAABgAAAAAEAgEYAAAAABAIBGAAAAAAQCAQgAEAAAAAgUAABgAAAAAE AgEYAAAAABAIBGAAAAAAQCAQgAEAAAAAgUAABgAAAAAEAgEYAAAAABAIBGAAAAAA QCAQgAEAAAAAgUAABgAAAAAEAgEYAAAAABAIBGAAAAAAQCAQgAEAAAAAgUAABgAA AAAEAgEYAAAAABAIBGAAAAAAQCAQgAEAAAAAgUAABgAAAAAEAgEYAAAAABAIBGAA AAAAQCAQgAEAAAAAgUAABgAAAAAEAgEYAAAAABAIBGAAAAAAQCAQgAEAAAAAgUAA BgAAAAAEAgEYAAAAABAIBGAAAAAAQCAQgAEAAAAAgUAABgAAAAAEAgEYAAAAABAI BGAAAAAAQCAQgAEAAAAAgUAABgAAAAAEAgEYAAAAABAIBGAAAAAAQCAQgAEAAAAA gUAABgAAAAAEAgEYAAAAABAIBGAAAAAAQCAQgAEAAAAAgUAABgAAAAAEAgEYAAAA ABAIBGAAAAAAQCAQgAEAAAAAgUAABgAAAAAEAgEYAAAAABAIBGAAAAAAQCAQgAEA AAAAgUAABgAAAAAEAgEYAAAAABAIBGAAAAAAQCAQgAEAAAAAgUAABgAAAAAEAgEY AAAAABAIBGAAAAAAQCAQgAEAAAAAgUAABgAAAAAEAgEYAAAAABAIBGAAAAAAQCAQ gAEAAAAAgUAABgAAAAAEAgEYAAAAABAIBGAAAAAAQCAQgAEAAAAAgUAABgAAAAAE AgEYAAAAABAIBGAAAAAAQCAQgAEAAAAAgUAABgAAAAAEAgEYAAAAABAIBGAAAAAA QCAQgAEAAAAAgUAABgAAAAAEAgEYAAAAABAIBGAAAAAAQCAQgAEAAAAAgUAABgAA AAAEAgEYAAAAABAIBGAAAAAAQCAQgAEAAAAAgUAABgAAAAAEAgEYAAAAABAIBGAA AAAAQCAQgAEAAAAAgUAABgAAAAAEAgEYAAAAABAIBGAAAAAAQCAQgAEAAAAAgUAA BgAAAAAEAgEYAAAAABAIBGAAAAAAQCAQgAEAAAAAgUAABgAAAAAEAgEYAAAAABAI BGAAANaiqampunrxbbRa7M20VFr8rZTNZqVeAgCAICEAAwACrbmlZZnPLibPBdUL VARdiKHq08VidU1NR0fH4qf1vYeqFy8Wi8lkUn2w9MLlJv6tEcu1J5NOa2kgAADe QAAGAPjWMuF2MUAu/rmQHzs6O3XmWP3UPzMRj5c/+KnxakIyACA4/PyuDwDwt7a2 tkKx+HefKpVqamuLhYKKeeVxWoea5iULITmRKKmvZPnr9fdftNqamlQq5VDTAACw GT0DAICrvT2KWyotJLTF8cx2Iq688hhyafHL/m48ZvQYAOAt9BsAAM5ram7+uyir 8m1NTalYLFVVdfp9lrJ3qVQcj8erlsvGCxt3ZTLONQ0AgOXRpQAAaPLuWC4p16/e k42rGDcGADiH3gYAQFxtbW1DQ4Pvd5zCSpTnVJumWSgUnG4LACBw6IgAAMSFwmEV gJ1uBVwkHo8zDgwA0I8ADAAQF+3pqa2tdboVcBECMADAEQRgAIC43nXrmPyMNxGA AQCOoDsCABDX09tbvcjphsAVSqXS5MSE060AAAQRfREAgLjuUKi+vr6mpsbphsAV isXi1OSk060AAAQRARgAIC4UDqfT6a6uLqcbAleIxWKcEgwAcAQBGAAgLhwOG4bR 1d3tdEPgCvNzc7lczulWAACCiAAMABBHAMabCMAAAKcQgAEA4sKRSDqd7uzsdLoh cIX5+flcNut0KwAAQUQABgCIi0SjacPoIABjUWx+PksABgA4gQAMABAX7ekxUikC MMoIwAAApxCAAQDiurq7TdPs6OhwuiFwBQIwAMApBGAAgA4tra0EYJQRgAEATiEA AwB0aG1tbScAYxEBGADgFAIwAEAHAjCWEIABAE4hAAMAdCAAYwkBGADgFAIwAEAH AjCWEIABAE4hAAMAdCAAYwkBGADgFAIwAEAHAjCWEIABAE4hAAMAdCAAYwkBGADg FAIwAEAHAjCWEIABAE4hAAMAdCAAYwkBGADgFAIwAH2aW1qW/by6E5Xe/Wxpmc+t VPWKb26lUnV1dTqdXvtrYWX8F4BLi5dosVhMJpOlYrFq4bqz4V21VPXDxV9dU9Pe 3l5TU2NXZfcgAOvR0tKycJWu5n649hd751WWv7EvynDLBeAcX72hAtCsubl5ma7V j10o1X0v/Uj9pc6uLtd24lUL4/F4OQyX+4t/a+ibH/7Yn6utqUmlUtqb6W1uDsCF QiGVTC5836vVZVtTo36vXaA+rK2rq6utrauvV3/Wq9/V/xoWdHZ2NqnrX55lWapt pmlauZxpLcgri38ULEu1XCXw8u+lhf+VSou/qX/LUnh2IQLwGrS1tRXKz1neCpZL qXXxxlW+5aqP1SXq6ltuLLbwkWrhT99yl/52JpPR2DoAPufSOyMAZy31tP7O0kjC Yn+rw8W9K2k/BOaqqr/rui39+eMgHp22N7W2talIpv911Tcrob5ZKtNWVy+m2tpy iG1sbGxqamppbQ1HIj81N8G7VEBOJhKZdNowDHUdmtlsOTkX8nmVj1ViLjn6UxyL xbL8dLyh/DDx75Ltj7MAFp5oLH7CzYFWWvmn+IfJEeWvwjtfCp5LAlihgN5JASz1 t6qWulylUrmzpT7f0dER2J6WjQqFgpFKFRe/pMv02AKWkOUC8ELnOJFQX9waFW5/ zLcL4batLRqNBvlJzfuZpjk/N5dKJlVIVnHUMs03E7L6orWL3QeCFoCXmSzz4/1W fYXbXDxW7yE/hOS/T8h/e48L2P0WwHvQJwD8bGEB2Jv/vRRxgz1+6x6x8iTAxanX Cx+8+R3xXXdNLgD3rFu3dft2icpB9uzx44nx8cbGRoni/gvAb0fcxZut+r24OJDb 1dXlWMuwaNl4XKY+YhsIIFDo/gKe99bszaVY29bWxqiCd/3UaIZ3hzLkAvC69eu3 bN0qUTnInj15MjE2RgB+09sTlXmk6BcLuwCkUuXtKt4aq2e/LsB/uFkD3rA0lrsU gZbWhjG2EEALQ8fLLT+ucnF3jQDsLYENwH/3SPHHhbjFxZTLzTaA/u5m+8bjD8aN Ae8iAAPu8tY8utqamkKhwKJcrNxPDmU4PW5MAPYWfwfg5WcsM3EGK7Y0SWfhrdlN d1oAP4v+NOCM5paWt+fRLWKEAXLeGsoof7K89ZGGVycAe4s/AvDC4VUNDT/8BxNn oMW7d9ry271rp+cAQUMABnSora1tUP1IBhngPvF4XE+3jADsLf4IwF3d3U1NTRpe CPhZb03PMXO5hRleALQjAAM6RHt6VAZ2uhXAMgjAWJY/AnAoHG5YGgEG3ETbvRfA WwjAgA6RaLSurs7pVgDLSMTjerZyIQB7iz8CcDgSqa+v1/BCwGoRgAGnEIABHQjA cC1GgLEsfwRg7r1wLQIw4BQCMKADnTC4FgEYyyIAA6IIwIBTCMCADnTC4FoEYCyL AAyIIgADTiEAAzrQCYNrEYCxLAIwIIoADDiFAAzoQCcMrkUAxrIIwIAoAjDgFAIw oAOdMLgWARjLIgADogjAgFMIwIAOHMUB1yIAY1kEYEAUARhwCgEY0CESidQRgOFK BGAsiwAMiNJ2BjuAtxCAAR0IwHAtAjCWRQAGRBGAAacQgAEdCMBwLQIwluWPABzt 6amtrdXwQsBqEYABpxCAAR0IwHAtAjCWRQAGRBGAAacQgAEdCMBwLQIwlkUABkQR gAGnEIABHQjAcC0CMJZFAAZEEYABpxCAAR0IwHAtAjCWRQAGRBGAAacQgAEdCMBw rXgsltESRQjA3kIABkQRgAGnEIABHQjAcC0fjAD3bdiwub9fonKQPX/yZNz7Abin t7empkbDCwGrRQAGnEIABnQgAMO19AXg1tb2jg6Jyhs2bdq4ebNE5SAbePZsfGSk QSgAz89ns1mJym8hAMO1CMCAUwjAgA4EYLiWtk4YAdhbCMCAKAIw4BQCMKADAbis VCoVi8VkMqk+qqpepG5DNTU/fKB++/GDHz75xmeWipQ/+UM5VUf9Wf546TXUq6j/ KhZ//D//8Pd++PON/1SlOjs73yweQPrWABOAPcUfAbh33bqA/4CrG108Hl/2lvu3 +23Z4ufLd9c377rv3nKr3rzrlm+55fttsfjDJ378v/7trrv4GVWno6Pjx4YEHQEY cAo3IEAHHwdg1bFR7+JVi52q2poFtbW1C/+rW1CvfjWoLvSCrlCota3NVf0ey7LS hmGaZjaTyWWzuVxOfVzILygsUr26ovp9sWNXztWq9Z1dXa76V1SIAIxlEYBdaCHN xmJVi/fbmsXIWlu+55a9ccttaGpqbm5WN6uGhgY9DTOSyeJiAH4/dXdNJZPqTmvm cuoOnP/xfrt4ry38cL/98Zar/n6Hf59REoABp/jzngK4jUcDcDnclkcGFnpXNTXq X1HuXTU1NbW0tYXC4ZaWFqebqZXqtsXm5gzDyKTTqgev/jNvWT/02xZ5rtOmLYoQ gL2FAKzZDw8T1e1W/Vq83y48Rly44zaoG66604Yikfb2dtfO6LZM0/bdBFQ2VhEx l8lkczl1waiX+CEtl++3izlZfX/bF0eV7X1pDQjAgFO8d78AvMi1AVh1I1KGofpb qqdVHkBQna3m5uaW1tZob29bW5vTDfQklYrn5+ZSyWS562aWO235vOqulcc31N9x z9TrifFxPS9EAPYWfwTgdX19Gl5lJX6YilxVVfvjkK2KtuqG29TYqO63kWjUQ0/N lrUwCJxKqVuc5tdVd1f1uulFP4wq/5iQF6ZkV1erNzJ3PjUgAANO8fCtFvAQBwNw uddVniVXr/Lt4khCe3t7KBzu37q1s6tr6W/Oz8/HFifXQVoul5uZmkomk5nFHptp WQX1a3EKoObumro8Jicm9LwWAdhb/BGAe3p7da44LRQKhmGoF/thDcjifBl1yw33 9HR1danP6GmGU1T4zBiG0634OwtjyIax8CudzmWz5UnX5ek6C7OsHX0WSQAGnEIA BnSQDsBvptyG+vryfDkVbvu3bVvX11e/spcmALuB6p+pXlFKheNEYiEemyodW6qj 1tLaKvFyBGD8FH8E4O5QqKGhQSjhZDOZWnW/bWxsbm5ua2+P9va2yvyceoVTg8Br pu6u6lJUbf5hPUs+v7gQWVM2JgADTiEAAzrIBeC0YVz8/PO+DRsaK+6nEoDdaWZ6 +vmTJ0Jjwuo7ntWyA1ZXd7fqX3bIBGCVflUGlqgcZC+ePx9TAVhmCyVtATgUDquM 0fXGVBcbHTl+vLGpSaKyd7lwEHhtyitZxsfGctlsR2enxEsQgAGnEIABHeQCcKFQ +NP//t+2lCIAu9PUxMTAs2e1tbUSxVUPL5fLSVR+i2gA3tTfv37DBonKQfZyYGB0 eNgPAdgw1OUnUfzAkSMBH/J918q3g/aE+3fvZtJpAjDgMwRgQAcCMNZsYmxMRREC 8HsQgCX4JABHIulUSigA7zt4UGhWv6ctHCznl1xHAAZ8iQAM6BCORFa4EHe1SqXS H//yF1tKEYDdaWxk5NWLF0Lb5xCA8VP8EYDD4bAhNgK8Z//+TpnJ1Z6m3pVSiUT5 QDivEw3A8Xjc9oOjAKwEARjQQS4AK//y5z/bUocA7E4qhAy+fCkVgOfnc1pyCAHY c/wRgBdGgFUAlompO/fsCYXDEpW9Tt1V9NxYpN2/dy9jGARgwGcIwIAOBGCs2fDQ 0OtXr4Sm0BOA8VP8EYDVvTedTnfKBJjtu3ZFolGJyl5XLBZTiYTTrbABARjwJQIw oAMBGGs2+PLlyOvXQtePthwS7ekxUimhfuSWrVvXrV8vUTnIBl+8GH792usBWAXU tFiA6d++vXfdOonKPqCinWWaTreiUgRgwJcIwIAOBGCs2auBgRHvD8RFenrSYgG4 f9u23r4+icpBxpOXn7W5v7+PqQc/IZ/Pqx95p1tRKQIw4EsEYEAHAjDWbODZs/HR UQLwexCAJfgjAHd1d1umKbRX84ZNmzZu3ixR2R9SiYTXz0MiAAO+RAAGdCAAY82e P3kyPjbW2NgoUVx9x7OZjETltxCAPccfAVhpbWtrb2+XqNy3YcPm/n6Jyv7gg62w RAMwxyABTiEAAzqEwmGhEbyampp/+td/taUUAdidnj56NDkxQQB+DwKwBALwz+pZ t27r9u0Slf3BB1thPbh3T2VUod37GAEGnEIABnQgAGPNHj14MD011dTUJFE8Hotl 9ARgyb2Itu3cGe3pkagcZK8HB9UvHwRgFX/b2tokKoej0R27dklU9g0jmSwUCk63 Yu0IwIAvEYABHQjAWLPv792bnp5ubm6WKO6PAMxpNBJEz9/SGYDb29tbZQJwVyi0 e+9eicq+YeZyeuaYCCEAA75EAAZ0IABjzR7cuTM7O0sAfg8CsAQC8M/q6Orau3+/ RGXf8PosaAIw4EsEYEAHAjDW7N53383NzbW0tEgU1xaAw5GI6kd2EoC9QwXgoVev hKZAq7uNtu2RVHppaW2VqNza3n7g0CGJyn6SSiaLnp0FTQAGfIkADOhAAMaa3bl5 U31fpAKwrh5YJBJJGUZXV5dE8V1793aHQhKVg2x0eHjw5cu6ujqJ4loDcGen0I9P c2vroSNHJCr7iaf3giYAA75EAAZ0IABjzb67fl31k1plhrAIwPgpvgnAnV1dQisI Ghobj544IVHZTwr5vJFKOd2KNSIAA75EAAZ0IABjzW5evZpMJIQWMRKA8VMIwD+r rr7++AcfSFT2k1KplEok1O9ON2QtCMCALxGAAR0IwFizG1euJJNJoXNctPXAwuGw oQJwd7dE8d379glVDrKxkZFXL15IBeC5uVwuJ1H5XeraEDpFrKa29uTp0xKVfSZt GHnLcroVa0EABnyJAAzoQADGml27fDmVTLa3t0sU90cA3nvggND+0kE2Pjb2amCg trZWorjOANwdCjU2NkpULlVVnT57VqKyz3j3MCQCMOBLBGBABwIw1uzqX/9qpFLt Hu+BiQbgfQcPCn19gmxibOwlAfi9CoXChx9/LFHZZ9QXykgmnW7FWhCAAV8iAAM6 EICxZpe/+SadSgmNcGrrgakfgbRYAD5w+LDQGukgm5qYGHj2zAcBWO72a5nmuQsX JCr7TKlUSsbjTrdiLQjAgC8RgAEdCMBYs2+/+kruBF1/BOCDR44IHfQaZFOTkwNP n/ogAIcjEaHTjDPZ7PlPP5Wo7D9GKlXI551uxaoRgAFfIgADOsgFYNU9/V9//KMt pQjA7vTtl1/KTR7WGYBVD1hor+Yjx483yuxyFGQz09PPnzypqamRKK4zAEeiUaGt vNQP5sUvvpCo7D/ZTMbU9R230cP799OG4fUVKADeQgAGdAiFQg0yi9BUx+4P//Iv tpQiALvTX7/8Mp1OCx0gpHUEWOxfceTECaFFnkE2Oz39TCwAq1uNtl2Roj09QuPY yWTys1/8QqKy/1im6cWwJxqAE/F42oNfE8AHCMCADgRgrI1lWbeuXateJFE/Hotl tOSQbvUj0NAg9K84fuqU0BBfkM3PzT199EjoW1YqlSYnJiQqv6unt1coxqt/xelz 5yQq+0+xUEh5cB8sAjDgSwRgQAcCMNZGOoSoAJzNZiWKv4UA7Dm+CcDRnh4VgLn2 nOXRfbAIwIAvEYABHQjAWJvpqamBp0+Fxq+KxeLU5KRE5Xf19PbKjWOf4ixWAap3 /vjhQ6HiOgNwdyhUX18v9EN06OjR5pYWicr+YySThULB6VasDgEY8CUCMKADARhr MzY6+mpgQGiISdv8Z6V33Tq5sUSmoUqQnn6vrfcfikQyYvuo79m/v1NmZbv/qO+C ZZpOt2J1CMCALxGAAR26QyGhTXrqGxr+5z/9ky2lCMAuNDw09PrVqzqZQ1x07sTb 29tbzTpMr/nm//0/uYnr2p6/hCMRI5US2kd9+65dkWhUorL/5LLZnJYFFzZaCMDp dHt7u0RxdoEGnEIABnSQC8CNTU2/+8MfbClFAHahVwMDI8PDQmdoxebn9SwArpLc iCiRSHz+y19KVIY/diBXATVtGB0yI8Cb+vvXb9ggUdl/LMvKGIbTrVid7x88MAyD AAz4DAEY0IEAjLV5/uTJxNiY0Px5nQGYo2i8aCEAy51BrWsEWLXfNM0OmVmsfRs2 bO7vl6jsP4VCwfDaRtAEYMCXCMCADgRgrM3jhw+nJiebmpokivvjLNZUKvXppUsS lfHtl18acgFYY++/ta1NKMNEenq279wpUdl/vLgRNAEY8CUCMKADARhr8/29e9PT 083NzRLFdW6CFYlGhbbyUt3Ti198IVEZvgnAKv62tbVJVO4KhXbv3StR2ZdUAFYx 2OlWrAIBGPAlAjCgAwEYa3Pv9u252dkWmXNW/BGA1T/h/GefSVTG5a++SqkA7PE1 wIoKMK0yAbito2P/wYMSlX3JcychEYABXyIAAzoQgLE2t2/cUDG1pbVVorjO7lck EhHayzqXy3188aJEZVz++mu57aN0ngGj/glCT5GampsPHzsmUdmX1OWUtyynW7EK BGDAlwjAgA5d3d1CyzibW1r+4fe/t6UUAdiFbl27pnKC0OCVzu5XOBKplwnApml+ dOGCRGWIBmCdl19nV5fQOoL6hoZjJ09KVPalbCZj6jp6zRaPHjxIEYAB3yEAAzrI BeCWlpbfEoD968bly8lkss373a9QOCx0mJNlWefOn5eojCvffGOkUj4IwHJ34Jqa mpNnzkhU9iXPHQX8aHEE2Ad3YABvIgADOhCAsTbXvv02lUr5YPxBbhVAoVD48OOP JSrj6rffGslku8wBQv64/Iql0plz5yQq+5Jlmt6KfARgwJcIwIAOBGCsjW+G4OQS SKmq6vTZsxKVce3y5ZQKwN7v/QtOQDDNc8zAX7G8ZaUNw+lWrAIBGPAlAjCgg1wA bmtr+x//+I+2lCIAu5BvtuFlDqoX3bhyZWEGPkvQfxqbkK9KoVAwkkmnW7EKjx4+ VIndB7swAHgTARjQQTAAt7f/j3/4B1tKEYBd6K9ffZVNp30wAiz3I1BXV3f81CmJ yrh59WoykfBB759jqF2iWCymEgmnW7EKBGDAlwjAgA4EYKyBZVkqgdTU1FRXi9yr dZ4DLLcNb0NDw1G24ZXx3fXr6iLxQe8/2tNTW1srUblUKp1mDfCKqS9XMh53uhWr QAAGfIkADOhAAMYaxObnn3z/vVD6rdIbgDmI1Yu+u3Ej4YtjqHvXrZP7OTpx+rRQ uvalhKfeZQjAgC8RgAEd5Ia/VK741W9+Y0spArDbTE1ODjx9KjdyNTkxIVF5WR0d HUI5SpU9eOSIRGXcvXVrfm5OKgBrfP7S09tbvUiiuLr8hL5EvpSMx9XNx+lWrNTj 7783UikCMOAzBGBAB7kA3NnZ+UsCsE+NjYy8evFCaO2izvihtHd0tMqEBFV538GD EpVx//btubk5oXuXziswFA6r1+qUWUu/e9++ru5uicq+lEokisWi061YKQIw4EsE YEAHAjDWYOjVq+GhIaHda9W3O5fNSlReVnt7u1AnsrO7e8++fRKV8fDu3ZmZGR8E 4EgkIreb+tYdO3p6eyUq+1IqmSwWCk63YqUIwIAvEYABHQjAWIMXz5+PjYwInV8a m5/PagzAqgcpdJxsKBLZuXu3RGU8un9/enpaaP8CdbfJagvAPT1psfO0N27evGHT JonKvqTyZCGfd7oVK0UABnyJAAzoIBeAu7u7L/3617aUIgC7zdPHjyfHxxsbGyWK 64wfSmtra3tHh0Tl3r6+/m3bJCpD9grU+Aimq7vbsiyhRzBcgauSTqXy3gnATx49 SqkA7P194AC8iQAM6CAYgEOhS7/6lS2lCMBu45vxt2hPjyE2/rZh06aNmzdLVMbA s2fjo6PMQXg/5iCsStow8pbldCtWigAM+BIBGNBBLgCHQqEvCMA+9eDu3VlfrMAM RyLpdFpoC6L+bdt6+/okKmPw5cuR169Zhf5+HV1de/fvl6jsSyryWabpdCtWigAM +BIBGNBBLgBHotHPLl2ypRQB2G3ufffd3Nyc0PG5WgNwOGwYhtBOuTv37AmFwxKV MTo8rDKw0D7k83NzuVxOovKy5A7iamtv33/okERlX/JWAH76+HEqmfTBUdgA3kQA BnQgAGMN7ty8GZuf90HfqzsczogF4H2HDglNbcXk+PiL58+FTqLWPAW6o7NT6FmS urcfOnZMorIvZTMZU+ODjwoRgAFfIgADOsgF4GhPz6dffGFLKQKw23x3/Xo8FvPB BqTqKq2pqamuFnnHOXriRIPMLk2YnZl59vix+t5JFC+VSury1paB5W7C6vJTF6FE ZV/yVgB+9uRJUgVgoWk4BGDAIQRgQAe5wYfedesufPaZLaUIwG5z8+rVZCLhgwDc 09srF6JOnT0rFK1hmebNa9fkHl7onIff1d0ttJ9cXV3d8VOnJCr7krcC8PMnTxIE YMB36DQAOhCAsQbXL19OJpNC83s1jwALTaNNJBKf//KXEpVR9tcvv0yn011dXRLF dV6EcgG4qrr61IcfilT2IwLwEgIw4BQCMKCDXABet379+YsXbSlFAHaba99+m0ql fBCAw5GI0E7CRip10aY18FjWt19+KbeBmdaF6KGQ0IHGxVLpzLlzEpV9KZfN6tz9 u0LPnz5NJBIEYMBnCMCADnIbkK7fsOHjCxdsKUUAdpurf/2rCnjtHR0SxRPxeFpX 3ysUCgkt083lch/b9AAIy7r89ddpwxA6w1nrRRgOCx1oXCgUPvz4Y4nKvuStADzw 7JkKwD44iw7AmwjAgA4EYKzBlW++UQFYKHv4Y/Yp2UOa6FMYnRehXAC2LOvc+fMS lX2JALyEAAw4hQAM6CAXgDdu3nzOpgBAAHYb0cE3ndlDbgPempqak2fOSFRG2Y3F hehtzMP/aaZpfmTTU8gg8FYAfvH8ubpKCcCAzxCAAR3aOzpaZQLwpi1bzn70kS2l CMBu45vZp3IPgDiBRprsWVwaA0AkEqmTCcDMw18VAvASAjDgFAIwoAMBGGtw+auv Uobhgw1429vbhRKUKnvg8GGJyii7+91383NzUpsA6QzA0WhdXZ1EZfVPOG/TVvxB QABeQgAGnEIABnSQCwD927adtukEDgKw2/hmA1518QvtZd0VCu3eu1eiMsq+v3dv enpaKACoG07W+wFY/ZBe/OILicq+5K1jkF4ODKirlAAM+AwBGNCBAIw18EcAVu03 TbNDZhelnnXrtm7fLlEZZU8ePZqamBA6QCg2P5/VNRgodxg1Z3GtCgF4CQEYcAoB GNBBLgBv27Hjg9OnbSlFAHYbfwTgSCSSzmSEAvCmLVvWb9woURllL54/HxsZEdo/ Wec0BAKwS3grAL968UK9LQptYk8ABpxCAAZ0kAvA23fuPHnqlC2lCMBu448ArIJH dXV1TU2NRPHtu3ZFolGJyigbHhoaevVKaP/kYrE4NTkpUfldBGCX8FYAHnz5Ur0z EoABnyEAAzq0tbUJnSOyc/fu4ydP2lKKAOw2/gjAPb29QulX2X/4cJvMoyWUTY6P v3j+XCg6VmnMAARgl1C3Hcs0nW7FShGAAV8iAAM6yG0CtHvv3qPHj9tSigDsNv4I wHKbD5VKpQ/OnKkRy2ZQzFzu1vXrNTU11dUiHQadMxEIwG7grQA8NDg4NzsrFIB1 bgIH4E0EYEAHuQC8b//+Q0eP2lKKAOw2/gjAoXBYaAUpu+/q8devvsqm014/j5oA 7BIZw7Asy+lWrNTroSEVgKU2gSMAAw4hAAM6CAbggwcP2XQOKgHYbfwRgFX7hcZP TNP86MIFicp40+Wvv04bhlAA9sFMBB7ErIq6lvIE4EUEYMApBGBAh9bW1naZXXAP Hjmy/8ABW0oRgN3m26++SqfTnR4PHp1dXUKHiJSqqk6fPStRGW+6fvlyMpkUeoSn 7ToMRyJCW3llMpnzn30mUdmXjFSqkM873YqVGhkenpme9sExYADeRAAGdGhpbRU6 BubIsWN79u2zpRQB2G38MfImtwV6Q0PDUZt2gMN73Lp2LRGPC30Tte0DJBeAzVzu o4sXJSr7kpFMFgoFp1uxUioAz87MCC3iIAADTiEAAzq0tLQIxZhjJ0/u2r3bllIE YLe58s03Rirl9bWXcvP/2zo69h88KFEZb7p3+/bc7Ky6iUkU1zYLVG4tumVZ586f l6jsS6lksuidADw6MjIzPU0ABnyGAAzoIBeAPzh9etuOHbaUIgC7zdVvv1UB2NNT TyPRqIrZQtMfwtHojl27JCrjTY8fPpyanJQ6CUbXTITuUEhoImuhWPzwo48kKvtS MpEoFYtOt2KlxsfGpqemhOYOEIABpxCAAR3kAvDps2f7t261pRQB2G2uXb6c8vja y2hPT3V1tdA5wBs3b96waZNEZbzpxfPnYyMjQoNgxWJRpWuJym+RC8CsRV+VZDxe KpWcbsVKTYyPq+uTAAz4DAEY0KG5pUVoK6OzH3+8afNmW0oRgN3mxpUryWSyTWjt pa4ALHT2jLJzz55QOCxUHEtGXr8eevVKaAvlKl2XotxmbDU1NSfPnJGo7EsJT73L TCrj40IBWL3n5gjAgBMIwIAOTc3NXV1dEpU/uXixb/16W0oRgN1GdvMhLalDbuch 5eiJEw0yY3p40+zMzLPHj4WG8at0LUfv6OwUWsasrvBjH3wgUdl/SqVSMh53uhWr MD01NTE+LvT0hwAMOIUADOjQ1NQkdJrrZ5cuRaJRW0oRgN3mzq1bsfl5oV67nt13 5Q4BTiaTn/3iFxKV8RbLsm5evaq+4EJP8fQ8i2nv6GhtbZWo3NzaeujIEYnK/lMs FFLJpNOtWIXZmZnxsTGhaSzzc3O5XE6iMoD3IwADOsgF4Eu/+lV3KGRLKQKw2zy4 e1d1v4TmbeoJwHLDbpZpnrtwQaIy3nX5m2/SYhuS6wnAbe3tQqsJOru69uzfL1HZ fwr5vJFKOd2KVZibnR0bHSUAAz5DAAZ0kJsC/evf/rbdpi12CcBuI7r7rp7jZ+RS h+qSnjh9WqIy3iW7HF3+WUxXd7dlWUL7yUV6e7fbtBW/7+UtK20YTrdiFWLz86Mj I0Lz/7WdAQbgLQRgQIee3l6hd9Df/v73do2wEYDdZuDZs/HRUaHddzUMu0V7euTO MW5taztw+LBEZbzr7q1b82Kz8TXshasCsGmaQsdxbdi0aaNNOxH6nmWaek69sks8 FhsZHhZ6+9a2BTqAtxCAAR16162rrhb5cfv9P/2TXQGJAOw2rwcH1S+hTaQ09L1U AJZbOBrp6dm+c6dEZbzL65MRRI/j2rZzp6ovUdl/coqnxjyTicTw69dCb9+lUmly YkKiMoD3IwADOsgF4H/+05/sqpzJZCYnJz10QqPvTYyNvRwYkDtGSHoQWPQMpC3b tq3r6xMqjrcMvngxMjwst6G39CxouTk4yr6DB+1ah+J72UzG9NSqVyOVGhocJAAD PkMABsS1tLQIzQJVb59//MtfbCxYKBQSi4rFoo1lsTa5XO6769dVx12o+yUdgEPh sND8beXAkSNCm/riXVMTEwPPnnn3WYzccVzqJnzi9Gm5Q5J9Rn2XLdN0uhWrkM/n nz5+XL1Ior6eM8AAvIUADIhrbm7ulJkFansALlPpN5lMqi6pysO2F8eq/PXLLzOZ TKc3d99Vl73QFtbqEj197pxQlxTvUqHlxtWrNYsk6ktfinLHcRmp1MVLlyQq+1La MPKW5XQrVufu7dsNDQ1STyG17MYP4C30HgBxzS0tQgEmlUr9n//+b4nKVYvpOpfL zc7Omp56YO8zl7/+WnUZpY6fEe57tbe3t8rsG6yuzI8vXpSojJ/y7ddfq4wqtI+U 9KWomt0iM19A3R4/4jiuFTOSSc89V1UBWF2cnj4EG8BbCMCAOI8G4CX5fF69SScS CekXwruuX76cTCaFjm8R3XwoEo2qjp3Q2siampqTZ85IVMZPubF4KbbJXIrSE0Fb 29qEfoiqqqtPffihSGU/Ssbjnttm4t6dO0Yq1R0KSRQnAAOOIAAD4uSmQKcN4z/+ 7/+VqPwu1WsxDGN2dpblwTrduXlTxVSh42dEh92i0WhNba3QvEGVZvYfOiRRGT/l 3nffzc3NCV2K6vaSSCSEkoC6FA2xaRTNra2HjhyRqOw/6rusArDTrVg1FYDVW21X d7dEcaZAA44gAAPi5EaA0+n0f/zXf0lU/imqB2Oa5vz8PO/Zejx68GB6akpo+WKV 5PhDJBqV2xmob8OGzf39QsWxrOdPnoyPjTU2NgrVl7sURXcjD0ejO3btEiruM8Vi MeXBmUSyAZgRYMAJBGBAnFwAzmYy/99//qdE5Z9VKBTKG2UxICxq8OXLkdev5Y6f kZt62h0KyYWlvQcOCA3o4aeMj46+evHCixtBh0KhBrFLsX/btl6O41qZQj5vpFJO t2LVCMCA/xCAAXG+DMBlpVJJxSf1Fp7z1NGOHqI6Xndu3aoVm0ssNwFPbtshtoB2 hPhG0B68FNUN8OiJE41iEzR8Rl1CXgx7BGDAf+hAAOLkArDqL/67owF4iWVZiUQi lUoxIGy7bxdPQhIa8BQaAVadxbxlCW2YpC62c+fPS1TG+13+5puFjc08tQ+WuhTV BSPUZpWLLnzxhURlXzJzObld9+Tcu31bXZkEYMBPCMCAOH9sgrUS5Y2ykslkNpt1 ui3+ce3y5ZTYRtBCmw9FolG5ocL6+vpjH3wgURnvd+vaNRVThY62KhaLqrjttw51 KcpNoChVVZ0+e1aisi+p9Gt6cK4Qm2AB/kMABsQJHoNkGP/HTQF4iWVZyUUMCFfu 7q1b83NzQnM4q2SGIER3wFI90d379gkVx3s8vHt3ZmamublZqL7EpSi6Fl39VB5k C+gVUzEyb1lOt2LVOAcY8B8CMCBOLgCrePmv//ZvEpVtUV4hnEgkGBCuxPMnTybG xuR28ZEYglAZVW7n6k1btqzfuFGoON7j5cDA6PBwQ0ODUH2JMNDe3i40ZF3FbuSr lEomi4WC061YNRWA6+vrpZa+E4ABJxCAAXFyAVglzH/+05+E3phtVB4QTqVSBQ/2 fhw3NTk58PSp3O67sVjMMk17vzVyqUNd80eOH28SG4TEe3huS7ZINKpuO0Jjd8rB I0fkpmb4TyIeVz/ATrdidfL5/JNHj9SbrNQ1TwAGnEAABnToXbdO6O3zN7/7XatH emDlAWGVhFnytCqWZd28etVIpeQO/rG3E6ZSh/pGd3R02FXwTaqd5z//XKIyVuLb r75S3wKhS9H2MCA6/1ld5Be4FFesVCwmPXgIcDwWGxkeFnrKrN4TJycmJCoDeD8C MKBDU3Oz0CjE+c8+W7dunURlOfl8vrxCmAHhFbpx5Yr6crWJzeRMJBJpw7CrWrSn R27ApKa29uTp0xKVsRKil+LClmwqA9v3gKy9o0Pu+WBtbe0JLsUV8+ghwDPT0+Nj Y0I7GsRiMS9uiw34AAEY0KGpqUloD8mjx4/v3rtXorI01dlVPV3VmZY4+8RnHj14 MD01Jbeq1t69oEPhsNwy0c6urj379wsVx896cPfurEf2wRLd/1kJRyI7du8WKu4/ Hj0EeHRkRGVgoRva/NxczoPbYgM+QAAGdGhpaRGaNLi5v//Dc+ckKmszNDTEZtHv NzY6+mpgQG5f5Spbg4e61NUFb0upd23Ztm1dX59QcfyswRcvRoaH6+vrhep75TpU 9uzfL3S+nS/lstmcB3dDfPH8ubomhZ74xObn2SEScAQBGNChta1N6BzXpqamf/zD HyQqazM4OFjy2s4omlmWdePKlbRhCC4DjsVMO7bC6uruzltWm9ipxcdPnZJLX/hZ qr9++8YNuSnuiXjclikhkWjUMAyh3QerFvcDu/DFF0LFfSljGJYHz0D6/sGDTCYj NJGeKdCAUwjAgA6im+Ke//TTvvXrJYrr8erVK6eb4AG3rl1T2UDuQJcqmwbfROed 5nK5jy9elKiMlbv89ddym5zZNRtf9CAupaGh4ejJk3L1/cfw4KYP6pb76uXL+vp6 r2x7DmCFCMCADp1dXXKr5gzD+OTChR27dgnVF6X6u4ODg063wgMGnj0bHxmROw24 arE3ZuXz+cpGaUQXANc3NBwjdThN+llM5Q9iIpFIWmyr6rINmzZt3LxZrr7/JONx b830mZ2ZeT00lM1m5Y7R4gwkwCkEYEAH0dM4qhZjZDgcPv/ZZ3LZQ0ixWBwaGnK6 FR6Qy+VU8KhZJPcqyWSywp1aRRdehiKRnWw75LRH9+9PT0/Lja9Wngqkh3/VXevk mTOia/J9Rn3FUt45A8k0zRfPn6cNo7mlRW4TtSoCMOAcAjCgQyQa1dBbymWzh44c OXL8uOh7tr0KhcLr16+dboU3XL982TAM0WOfVT914aDmtfbJOru6Cvm80AJgZeee PaFwWKg4Vmjk9euhV6/kbmgVLgMORyK1tbWiz4mqqqtPffihYH3fyVuWjQetycnn 8yPDw3MzM5Zlic4gKCMAA07xTC8Z8DQVgFPJpNBJSG8pFIsHDx06ePiwJ2Kw6nAM Dw873QpvePr48eT4uOhUgqrKzgRW17ncGLVK5p9euuSJq9rfLNO8cfVqKpUSmhq6 8BQmkVjb2shQOKyii+hDIqW3r69/2zbRl/AZM5dz+W5P6p1odGRkthx9Zda3v4Ut oAEH0ZMAdFDR1zRNPW+rZepdfPfevUePH3f5lrmqnSMjI063whty2eyt69elZ0FX VTAuIboAmGE397h++XIymRTa2b6qgitQerFJFfOf10R9Ny3TdLoVy1NvzcNDQ7FY TGVgne/RBGDAQQRgQBPpQymXZRjGlv7+w0ePRnt6NL/0CqnOx+joqNOt8IybV66k UqkW4QGuhb6gtbAf1mr/H1X3Ua5tnd3de/btEyqOVXlw9+7szIzcxn5r2x03FA6n 02m5LYvKamtrT5w+LfoS/uPOLaBTyeTrwUF1zaibnfRl8y7mPwMOIgADmoQjEacG Y0ulUl19/Y5duw4cPOi2AeFcLjc2NuZ0Kzzj1cDAyPCwhq3OEvG4qTLwanaEjvb0 qK6k3Kjg9l27ItGoUHGsyvDQ0OtXr+rEbiZrWAYsffkt2dzf37dhg/Sr+Il6A0rG 40634m8WnrqOjMzPzalM3tra6tSqCgIw4CACMKDJwjJgsVVzK6QasHHjxh27d2/f scMlaymz2ez4+LjTrfCM8vJLuVNY37TaxcCiJwCrxnx66ZL03G+skIoQNyWXAa/2 NODuUCifz0sv/VUymcwnn37qkpunVxQLhVQy6XQrFlb5Tk1MzExP53K5fKHg7Htx LBZTXxbTrdPCAd/jJg7o09be3iZ2eOaq5LLZDYtJeEt/v7OdOdWhnJiYcLABniM9 +/RNyUTCWHEGFl1+qRLR6XPnhIpjDa59+60KwC5ZBqxtgUlHV9fe/fs1vJCfWKbp 4FCnyr3TU1Mq92azWZU5NeztvBJrm+QPwC4EYEAf2S2C1iSXy23YsMHBJJxOpycn J/W/rnelDeP2zZviB738aOUZWGWhVrHnO6rbuvfAAaHiWIP7d+7Mzc66YRmwtvRb LBaPnjwpesKwL2UzGTOX0/yi7sy9S5j/DDiLAAzoE4lGVXpx2ztxmUrCfevXb9u+ fduOHTonmqpwNTU1pe3l/OG769cTiYS2PdVUBs6Z5vvXA0d7eoxUSu7a3rp9e8+6 dULFsQZDr14NDw3J7SmwkgDc1d2tso30nnBLGhobj544oee1/ETdGQqr31FvbSzL mpqcnJudVam7WCy6892W4V/AcQRgQKvOri49k1fXTCXSvr6+zf39O3fvlj5QpGrx cNeZmRnpV/EZ1X96cPduXV2dtkF7lbdz2ex79nGNRKNyB8Mk4vFPf/ELFgC7ipnL 3bx2TfR48/ePknWHQirtaFtUUiqV9h086M5A5WYLO2AlEuoP0VcxTXN8bCw2N6c+ cHx9789i+BdwHAEY0ErlBJUwO73QiyoWi80tLRs3bdq9d6/clksqWc3OzgoV97Eb i+chadj1Z4lK3VXV1T/Vb5N9ssMJwK7k4GnAKv3mslmdcbS6puaDM2e0vZxviO6A pS6P0ZER9SZSKBRaWlo88YxM3UitNR0yB8BGBGBAN/cPAr+lVCrVVFev37hxx65d fevX21tc9XHn5ubsrRkEsbm5h/fv6xwErlq8ElTqtkzzrc1L1SWtOqByY3FdodDu vXuFimPNvr93b3p6Wu5utuw+5A0NDc0tLU1NTZqv/D3798uNdfuY7Ttgqeg4Pzc3 Mz1tGIZK123t7d7alJvhX8ANvHTXAPzBzSuBf9auPXuO2boKLhaLzc/P21gwOG5e vZpMJnUOApclFo/0fPOYVtEDkBSVPTrdPacxmMZGR18NDMhNfV84DEmlhTdWS4ZC oZxpajjs9y21dXUnTp3S/KL+kE2n7T3sZ+jVq7m5OY9uRRaPxdRX4z1rSQDoQQAG HNAdCjU0NHjruXXZhk2bPvrkExsLqvSrMrCNBYNDZYP7d+5oHgQuW1jXl0yq38tD GaIHIKmkfeHzz4WKoxKWZd28elV08zN1kZcftTS3tKhLvaWlxZGrff+hQ+3yJ2/7 UiqZLNqa9waePUskEt6aRVW22tOtAcjxXv8b8IeOjg5tm5fayPYAPDc3F18cUcQa 3Ll5Mx6LNevaDvotCzOiVe+2WKyvr5e7mBsaGo6ePClUHBW6de2ayqhyx18lE4ny BdbsRPQta2puPnzsmCMv7XULT8rsvr17NwCv6lh1AKIIwIAzIpFIOpOR21xKiO0B eHZ2VvVmbCwYKNlM5rsbN5ydUV9a3N9VLpz0rl/fv3WrUHFU6NnjxxPj43Lj/9JX 188yUqmPL16sEzvtyd/y+Xw6lbK3pkcDcDweN3M5Jj8DLkEABhwTCofT6bTLD2x4 y6YtW85+9JGNBWdmZpJie4QGwdPHjyclE4izVP45evKkX/91PqDuYHdu3hRdAe6s 3r6+/m3bnG6FV+WyWfXL3povnj9XYdJbATgWi+XZ+RlwE3++YwFe4bnFwLYH4Onp 6ZTdQwSBYlnWd9evG4ah7UBUnVSX8aytMw5guyvffJNJp9u0b0ylQbFYPGPr7S5o 0qmU7anPcwG4fBJymqW/gJt4ptsN+FVXd3djY6NXMrDtAXhqaoplURVSvat7331n eG02wUq0dXTsP3jQ6Vbgfe7dvj03O9vi0EJ0OYlE4twnnzi1wN4HJBYAV3ktAJeP jjN4yAu4jDf63IC/eSgDb9m69czZszYWnJyc5NF45R4/fDg1OenRo0HeY/uuXZFo 1OlW4H2Gh4aGXr2q990q2Uhv7/YdO5xuhYcV8nmJ4PdyYCAWi3kiAJN+AdfyQIcb CAKvZOD+bdtOf/ihjQUnJibePOcTa2NZ1u0bN1Rny08ToQ3DuPD55+7/oQg4yzRv XLmSTqc9erb5skpVVadtfdIXQBILgKu8E4BJv4Cb0bEA3KI7FFLdBZd3Im0PwOPj 41mBTlIAqQSiMnDGRzmEA5C8QvowJM3ShnH2/Hl1+TndEG+TWABc5ZEAHI/Fqqqr OfIXcC0CMOAiKgNbpunm7WRsD8Cjo6OmadpYMMhmpqcfP3hQ76lt1d6jb+PGzVu2 ON0K/LznT5+Oj476Y7PuUqm0Y/duJt5XSGgBcJUXAnAiHldvauz5DLiZHzpJgJ80 NDQ0NS9wZ4bZvnPnyVOnbCw4MjJiWZaNBQPu0YMH01NTPlgMrDrQx0+d8t/KUl/K ZrPfXb/uj8OQusPhXXv2ON0Kz5M4Abhs8OXL+fl5d97iFqY9J5PqHY2nuoDLef69 CvClUCiUzeU6OjqcbsjbbA/Aw8PDPCm3kep73b99O5lIeH33WhZhesu1b7/1wVlc DY2NR0+ccLoVfpDNZMxcTqKyawNwPB6vXlyK4nRDAPw8AjDgUnX19S0tLeptvqam xum2/I3tAfj169eFQsHGgjBN8/aNG6of1tra6nRb1o6BOG/5/v79melpF8aSlStV VZ368EMfDGK7gZFMCt3YXRiAi8WiYRi5XC7PbCbAI7jRA67W3NJSV1enkrBLumU7 du068cEHNhYcGhpSvQcbC6Jqcf/VWzduZNNpN68nf49SqXTg8GGPNj6YFg6jvn1b 3axccqdaLcs0z3z0UW1dndMN8QN1S08lEkLFXRWAy3Oei6US+10B3uLJNyogaLq6 u/P5vBumF+7eu/fo8eM2FhwcHFR9CBsLokx1yG7fvJnJZNo9GCMtyzp3/rzTrcDq XP76a49eb2Yud/rcuXq2fbaJZZpygXBocHBudtYNATihQn6pxJxnwIsIwIBndHZ1 FVQMdrR/aXsAfvXqlY3V8Ka0Ydy5dWvhgFb3LSZ/v7aOjv0HDzrdCqzO/du3Z2dn W7y2+Dyby505e7bBF1tYu4S688hNBnZDAE7E46XFh4wOtgFAJQjAgMeo/mVNbW1r a6sjUw3tDcClUmlwcNCuanhXOQN7blxu19693aGQ063A6owODw++fFnnqVnEZi53 ivRrq4VZwYmE3LweBwPwwtlOySSjvoAPEIABT1pYG1xba+XzXV1dOl937/79h48e tasaAVgDlX7vLM6FdsMU+pXIZLPnP/3U6VZg1SzLunn1qmEYXplxUCgUTp45w1Fb 9pI7AKns9dCQCsCaD52OxWIL3eXqakZ9AX8gAAMeVldX19rWpjoc2sb39h08eOjw YbuqEYD1MHO5hbnQhtHihX2hm1taDtn3kAU63bl5MzY/74nLrKam5vipU67aY98f 5A5AKtMcgMuznS3T5Lg+wE8IwIAflOdF5+UHhAnAHqU6cN/fvz8/P9/c3OzyfXr7 t2/vXbfO6VZgLQZfvhx5/drlY6rqtqNumAePHnX5D4JHJROJkuTG/noCcHnIV10h zHYGfIm7P+AftbW1zYs70MitELY3ABeLxaGhIbuq4WeNDg8PPHuWzWY1z5xfOSOV uvDFFyQTj7JM88bVq2nD6OjsdLoty0skEnv379+4ebPTDfGnQqFgJJOiLyEagJdW +eZyOQ6oB3yMTgbgNwubRRcKQgs+CcBeF4/FHty9m8lk3LlQs6Gh4ejJk063Amt3 69q1RDze6soF55ls9sQHH3C+tJxcNqt+ib6EaABOJBJpw5CoDMBVCMCA36gALLcq mADsA7lc7uHduyqlNLe0uG2sddOWLes3bnS6FVi7lwMDo8PDDS47U7dUKjU0Nh4+ dqy2ttbptvhZKpEoSs5/rhIOwLFYLJvJSFQG4Cru6voAqJyHAnChUHj9+rVd1bAq E2NjTx8/NnM598xWTaZSFz//nH2JPM00zZtXr6ZSKfdMs1eN2XfgQN+GDU43xOc0 zH+uIgADsAMBGPAbAjBWKJNOP7x3L5VMumQouL6+/tgHHzjdClTKPbOgS6VSXV3d 4ePHXb4vlz9I7/9cRgAGUDnnezwA7OWhAKzaOTw8bFc1rM3M9PSjhw+tXM7xtZEb N2/esGmTs21A5V48fz42MuL4LOhcNrv34MFoT4+zzQgO6f2fywjAACpHAAb8xkMB 2LKskZERu6phzSzTfP706eTERN6ynJoRnUwmL37xBfOffcDM5W5eu+bgLGiVxDb3 9+/cs8cN8xoCopDPG6mUhhciAAOoHO8NgN8QgLE2uWz2yaNHqnNpmqb+6FJXX3+c +c9+cfPqVZVC9c+Cjsfj6zdu3LtvX21dneaXDrhMOm2ZpoYXIgADqBwBGPAh1e/0 RABWQWt0dNSuarBFJpN58vDh/Py8ZVk6Y/CGTZs4ndU3Bp49Gx8d1TkLWkXf3r6+ fQcOsNxXv1KplEok1O8aXosADKByBGDAh7wSgHO53NjYmF3VYKNsNvvs8ePZmRk9 k6ITicSnly4x/9k3dM6CTiYSfRs37t67t45RX4dYlpXRdXwuARhA5QjAgA/JBeA9 +/YdOXbMrmoEYJdTMebFwMDk+HghnxfdIktFl+OnTsnVh34aZkGnDWPjli3bd+7k 0Ymz1Dcib1l6XmtocHB+bo4ADKASBGDAh9ra2oTiyu69e48eP25XtWw2Oz4+blc1 CLEsS2XgkdevDdXNzeclxvTWb9y4acsW28vCQQNPn46NjkoEFZVSOjo6tu/a1dPb a3txrFaxWEwlEtpeTgXgudnZpqYmieLxWCxDAAYCgAAM+JBKv20yAy87du06Yd9O RaqrMTExYVc1SMtlsy9fvJianMxbVmtrq11b7CYSiYtffFFbW2tLNbhELpe7Zess 6FKppGqu37hx2/bt7HHlHuq2oH5pe7nBly/n5+cJwAAqQQAGfKi9vV1o5uH2nTtP 2jdVNZ1OT05O2lUN2qQN4/nTp/Nzc/l8vq2trcIkrMLMB2fOFOVPEIVmN69cSSaT Fd6LVO7NpNO9fX3bduxoam62q22whfruGMmkzh9eAjCAyhGAAR+SC8Bbt2079eGH dlUzDGNqasquatBPJeEXz5/Pzc6qJNzS0rK2pZjMf/ar50+eTIyNNaxpFrTKVDnT XNfX1791K7nXtdQPflrL8b9LXg4MxONxAjCAShCAAR+SC8D927adti8Ap1Kp6elp u6rBQblc7vXg4MzUVDqdVtFFXYErHBZWf/nkmTPs3+tLuWz21vXrNYtW8vcXTtNJ pVpaWjZs2qR+cVW4X8YwLF3bX5WpAByLxZplnokQgIGAIAADPtTe0dHa2ipRedOW LWc/+siuaslkcmZmxq5qcIlUMvnq5cv4/LzKP8VS6f1huLa29sTp0zqbB51uXLli qEz707ejcuhtbGyM9vaq24vQjQsSNG9/Vfbi+fN4PE4ABlAJAjDgQ4IBePPmsx9/ bFc11Y+Zm5uzqxpcKG0YQ4ODsdnZTDZbyOdVHn5rS6T+7dt7161zqnmQNj42phJL 3jSbW1qWPhmLxepqa9Vnevv6Nm7a1CgznRXSNG9/VUYABlA5AjDgQx0dHe8ZcqnE +g0bPr5wwa5q8/PzqitsVzW4nGWaU5OTM9PTqWQyl8s1NTd/aN9sAriWZVnfXb9u GEZjY2N7R8eGTZvCkYhdW4jDKQtD94mE+l3z6w48e5ZIJAjAACrBOxDgQx2dnS1v jLfYqG/Dhk/sC8Bzc3PxeNyuagAAPSzTzKTT+l9XBWD1riH0BqcqO/KPAqAZARjw IbkA3Ltu3YXPPrOr2szMTDKZtKsaAEAPI5ksFAr6X/f5kyeJZJIADKASBGDAh+QC cCQa/ezSJbuqTU9Pp/QeoQEAqJD+04+WPHv8OKkCsMwaHwIwEBAEYMCHOru6hJZI dXd3X/r1r+2qNjk5maa3AQCeotKvysCOvPSTR49SqZTQLo8EYCAgCMCAD8kF4I6O jl/99rd2VRsfH89q30QUALBmhULBcG7pyuOHDw3DEDrongAMBAQBGPChru7uJpmT RVpbW3/zu9/ZVW10dNQ0TbuqAQCkZQzDsiynXv3RgwdGOt1GAAZQAQIw4EPdoVBj Y6NE5campt/94Q92VRsZGXGwIwUAWJVioZBydOfC71UANoz29naJ4gRgICAIwIAP hUKhBpkAXFtb+7/++Ee7qg0NDRWLRbuqAQBEqXxoOTpt5+H9+2kVgDs6JIon4nG2 pQCCgAAM+FAoHG5oaJCorG4Z//znP9tVbXBwsFQq2VUNACCnWCymEgln2/Dg3j0V gDs6OyWKMwIMBAQBGPChcCRSX18vUVl1gP713/7NllIq+qoAbEspAIA0x4d/lft3 76pmCAVgRoCBgCAAAz4UiUbr6uokKpum+W//8R+2lCIAA4BXOL76t+z+nTtGOt3V 1SVRnBFgICAIwIAPRXt6amtrJSpnMpl//8//tKVUsVgcGhqypRQAQJSzmz8vuXf7 dloF4O5uieIEYCAgCMCAD8kF4FQq9X/++79tKZXP54eHh20pBQCQ4+zZv2+6e/t2 JpNhBBhAJQjAgA/19PbW1NRIVC6VSv/y5z9XV9tw67Asa2RkpPI6AABR6VQqn887 3YqFx6ZPHj1S7262vAe9iwAMBAQBGPChaE+PXBfht7//fUtLS+V1TNMcHR2tvA4A QI6KnSoAO92KBfFYbGR4WO7xrpFaIFEcgKsQgAEfCoXDabFtQj7/xS/CkUjldbLZ 7Pj4eOV1AABCyrGwWCg43ZAFszMz42NjQgt8YrFYNpORqAzAbQjAgA+Fw2HDMIS2 CTn3yScbN22qvE4mk5mYmKi8DgBAiJnLuScWTk5OTk1MCJ1xMD83l8vlJCoDcBsC MOBD4Wg0YxhCJyWeOHVqx86dlddJp9OqN1N5HQCAhFKplEok1O9ON+QHY6Oj01NT DQ0NEsVj8/PZbFaiMgC3IQADPtTV3W3mckIB+MDhwwcOHqy8DgEYANwsm8mYbhoU HX79enZmprGxUaI4ARgIDgIw4E+tbW3t7e0SlXfu3n385MnK6xCAAcC13HP00ZLB ly/n5+ebmpokirMGGAgOAjDgTyr+trW1SVTesnXrmbNnK69jGMbU1FTldQAAtjNS qYILjj5608uBARVTm5ubJYrHY7EMARgIBgIw4E/t7e2tMgG4b8OGTy5cqLwOARgA 3MkyTReeiDvw9Gk8kbDlHL53EYCB4CAAA/7U0dHR0toqUTkciXz+i19UXocADAAu 5La9r5Y8ffw4lUwKvbURgIHgIAAD/tTZ1SU0T6y9o+PXv/1t5XUIwADgQpl02jJN p1uxjMcPH6o3DqHJTfF43IWD3gAkEIABf+rq7hbaKaSxqel3f/hD5XU4BxgA3CZv WWnDcLoVy/v+wQMVgIX2dyQAA8FBAAb8qTsUEjororq6+p//9KfK62Sz2fHx8crr AABs4drJz2UP7t1Lix1xTwAGgoMADPhTKBxuaGiQqGxZ1l/+/d8rr5PL5cbGxiqv AwCwhWsnP5fdu3Mnk8l0EoABVIYADPhTJBqtq6uTqKy6CP/+X/9VeR3TNEdHRyuv AwConGVZGbdOfi4jAAOwBQEY8KdoT09tba1E5VKp9Me//KXyOvl8fnh4uPI6AIAK FYtFI5l07eTnqsW3jKePH1cvkqhPAAaCgwAM+FPvunVCvQTlt7//feUnMar+1tDQ kC3tAQBUIm0YectyuhXvE4/FRoaHa2pqhOrHYrEsxyABwUAABvwp2tOjArBQX+Gz S5ci0WjldQYHB9084AAAQWDmcu7PfrMzM+NjY0Izm4rF4tTkpERlAC5EAAb8KRwO ZzIZod0yz5w7t6W/v/I6r1+/LhQKldcBAKyNugkbyaTTrfh5kxMT6ld9fb1E8Xgs lnH9IwAAdiEAA/4UiUbljos4fOzY3n37Kq8zNjaWy+UqrwMAWINSqaTSb7FYdLoh P29keHh2ZkbodIPY/Hw2m5WoDMCFCMCAP3V1d1um2d7RIVF81549x06cqLzO1NSU 4e5NRwHAx9y/9HfJ0KtXc3NzTU1NEsUJwECgEIAB32pta2tvb5eovGnLlrMffVR5 HdWbicfjldcBAKyWJ5b+Lnnx/Ll6v2hubpYozg5YQKAQgAHfUulXZWCJyj09PRe/ +KLyOslkcmZmpvI6AIBVyefz6VTK6VaswrMnT5KJREtrq0Rx1gADgUIABnyro7Oz 8sOKltXZ2fnL3/ym8jqqwzExMVF5Hfz/7N2HdxvH3e9/kmhEJbrcZMXdkS23xLEd dydxiR332I5rnifOzb3/5z3nd+/5/U5sWVa3bIm9gCgL7GI7fgMsxYePCsWygwWw 79dRaComZ0ewuDsfzMx3AGDvRv/U3+udPX1a7XQkvavLIcBAqBCAgYk1l89LWi02 Ozv7/scfH74dx3Hm5+cP3w4AYI/6ha86HXfcKvCfPnVKVVVJ+3oIwECoEICBiVUo FhOJhIyWp6enP/3iC1+a4iQkABgakX5F0huXwlc7nTp5Ut7RBgRgIFQIwMDEKpZK kk6MMHT9m2+/9aWp1dVVdl4BwHDo3a45nofPnfzuO13a4fZKq6URgIHQIAADE6tU LsdiMRkt93q9v331lS9NNRqNZrPpS1MAgF2MV9nna3z/73/H4/HpaSkDV2aAgVAh AAMTq1KtRiIRGS2LAPzpF1/MzMwcvilN09bW1g7fDgBgF5Zldcf23HXx0BEBOJFI EIABHB4BGJhYR267TdJYQYxF3vvoI19KTLuue+XKlcO3AwC4mbE79Ogahq5fOH8+ EokQgAEcHgEYmFgiAIuk6ss87fXe/fBDv85YWlxctMawIgsAjAXHcVSRfsfq0KNr tJrNxYUFSY8z13XXWYgEhAkBGJhY5UolGo1KavyZ3//+nnvv9aWper3earV8aQoA sJM7SL/jdeTv9VZXVkRGlVTVYooZYCBkCMDAxKpUqzMzM5IWjN3/4IO//d3vfGmq 2+2urq760hQAYJvruv3067pBd+SwLv/8c6PRmJ2dldF4r9dTFIUADIQHARiYWOVy WdM0SYdGiMb/+OabvjQlBh/z8/Pu+A/RAGB0iJuq1ulMxq31/NmznXY7lU7LaLzV bHIaHxAqBGBgkqUzmWw2K6PleDz+4Sef+NXa+vq6OrblSQFg1ExS+hV+PHVKU1VJ j7Nmszm+p0MBOAACMDDJcrmcpLfMDV3/5ttv/WpNpF+Rgf1qDQDCbMLSr3Dyu+9E RpW0oIkZYCBsCMDAJMsXCvI2TX3w17/61bgYqM3Pz497mRYACNzkpV/TMC6cPy+v pAUVsICwIQADk6xULssrm/ns88//6p57/GqNVdAAcEiTl36nKAENwG8EYGCSlSuV SCQi6V3ze++//3fPPutXa5qmrXESIwAcVP/EI1WdgJrP1/jl0qVmsymxBLQIwCyB BsKEAAxMslKp1JW2byqfz7/5zjt+tSZGIYuLi7Zt+9UgAISH4zja+J/3e0PnTp/u dDrpTEZG42wABkKIAAxMOHmFoIXPvvzSx9YajUaz2fSxQQAIA8e2NVWdyPQrnDp5 UmRUSkAD8AsBGJhw8gpBu64rAvDMzIxfDdq2vbCw4FdrABAGtmVpk1tAQTwXzp4+ PTMgo31mgIEQIgADE05eIWjhpVdfvePOO31skFJYALB3pmnqE13AaWN9fXVlJRqN SmqfClhACBGAgQkntRD0fQ888PQzz/jYoK7rKysrPjYIAJPK0HXxK+heyHX5558b jYa8t3EJwEAIEYCBCVepVuUdnzg3N/fWX/7ib5vLy8uGYfjbJgBMkl6vp3e7lmkG 3RHpzp4+rUqrgNUvAa0oBGAgbAjAwIQrVyqapuVyORmNO677xddf+9umqqrr6+v+ tgkAE0PENk1VnXDUzP/h++/7ZxnIeYQx/QuEEwEYmHzZbFbe2+cf/PWv/i5OE20u LS1ZluVjmwAwGVzX1Todd+IO+70h0zAunD8vbxETFbCAcCIAA5NvLp9PJpOSGn/y N7956Ne/9rfNdrtdq9X8bRMAxp1t293JPe7oekuLi7WNjXg8Lql9ZoCBcCIAA5Ov WCrJG0BUq9XXXn/d3zbF8G5xcdEOxwI/ANgL0zDCdmLthXPn2ooi6SS/KQIwEFYE YGDySa2DJXz25Ze+t8kkMAB4wlPy6hqnTp7sdrvZbFZG4/0KWCIAh+w9BQBTBGAg DKTWwRJjiPc//tj3JdZMAgPA1GDTb1fTQlLyaifDMC6cOxeJRGRtAGb6FwgrAjAQ CvLqYAmPPf748RMnfG+WSWAAIRe2Tb87LczP12u1eCIhqX0qYAGhRQAGQiFfKPhb q/m/NZ7Pv/nOO743SzloAGEWwk2/O507fboj7QTgKWaAgRAjAAOhUK5UotGopMa7 3e7fv/1Wxio1zgQGEEK9Xk9kMzvEb//Ztn329GlNVXNzc5IuQQAGQosADISCCMAi TM5JG0n87rnn7r3vPhktLy8vG4Yho2UAGEGO43RVNSQn/d7MyvLyxvp6LBaT1D7r n4EwIwADYZHJZjPS1pKJgP3HN96Q0bIYo6yurspoGQBGTciXPW+7cPZsu92WeAAS ARgIMQIwEBZStwEbhvH1f/6npFqda2trGgvVAEw0lj1vs237zI8/ileD9c8AZCAA A2FRqVYjkYi89p96+ukHH3pIRsuWZS0uLspoGQBGQb/as6b1wr3sedvy0tLG+no8 Hpd3CQIwEGYEYCAsRABWOx15b6in0+m/fPCBpMY3NzcVRZHUOAAEpdfrGbpuUulg B2/6l/XPACQhAAMhIvU0YDGMe++jj1KplIzGHcdZXFwMeVUYABPGdRyR9MT9LeiO jBBD18+fOxeNRiXtqZkiAAOhRwAGQqRQLCYSCXnt/+ree5/9/e8lNa4oyubmpqTG AWCYer2eZZrUu7rezz/91Gw2k8mkvEsorRZ1JYAwIwADIVKpVGYiEXlvq5uW9dXf /y6pfTFeXFpasqgQA2DMua6ra5pt20F3ZORsHf+rablcTtIlxKNEBGBmgIEwIwAD 4SL1MCThsccfP37ihKTGORIJwLjzJn5FDAu6I6NoYX6+XqvFZa5UUhRFU1V57QMY fQRgIFykHobU1+t99tVX8ppfX19XGbsAGEP9id9ul4OObsa27XNnznQ1LZPNyrsK 9Z8BEICBcClXKhGZq6CFJ3/zm4d+/WtJjYsR0uLiIpMnAMYLE7+3tLS4WNvYkHr6 UX/9s6IQgIGQIwAD4ZIvFGzLkvr+uuu6f/vqK4kFPFuter0uqXEA8Bc7fvfC2/3b 7XazMh9PlL8CMEUABkJI+iroqamHHn74yd/+VlLjVMMCMBYo9bx3Vy5fbmxuJiQ/ m1j/DGCKAAyEULlcjsg8YlEQI4wvvvlGXiETXddXVlYkNQ4Ah+c4js4Zv3tjGMaF s2f7xZ/n5uRdpdfrtRWFGWAABGAgjLK5XDqdlnqJQqHwxttvy2u/Vqu122157QPA wYigZei6aRhBd2RsnD97ttPppFIpqVeh/jMADwEYCKNiqSS10MjUYAj43Asv/Oqe eyS17zjO4uKi67qS2geAA7BtW9c0bk1716jX569cicViUtclTbEBGMBVBGAgjCqV iqqqUhebCaZp/u2rr8SwRlL77Xa7VqtJahwA9kWEXqPbpTzBvojHxHlv8XMuJ/VC rWazy2ZsAAMEYCCkRPqVvd5MyGSz77z3nrz2V1ZWdF2X1z4A3BLFrg7Gtu2L589r qpqSvCVnivJXAHYgAAMhVSqXo5JLYXnue+CBp595RlLjlmUtLS1xtCaAoDi23WXN 84Fc/vnnZrOZkFYucRvH/wLYiQAMhNcQSmFNDUYev3/xxWO/+pWk9sX4qdFoSGoc AG6mf8Bvt2uz5vlAxI378i+/xOPxIbwPS/krADsRgIHwKpXL8jbo7qRp2seffipp y7EI2MvLy6ZpymgcAK4nbjumYRjsvzgoVVV/unBB73Zll6LwUP4KwE4EYCC8RAAW A7hMNjuEa1mW9fFnnyWTSRmNi4GoyMAyWgaAa4i7ma5p7Lw4MJF7L5w/3xXpV3Lh Kw/pF8A1CMBAqA3hPKRtPdf96LPPJF2uXq+3Wi0ZLQOAx3UcEaXEx6A7MsZMw7hw 7pxIv8N573WK8lcArkMABkKtcuRIV1WHNhARGfiDTz6ZnZ31v+Veb2lpiQNIAMgg 7l1dtvsemqHr58+dG9rKoymmfwHcCAEYCLthTgJPDc69+ODjj9OZjO8t67q+srLi e7MAwqzX64nAZhpG0B0Ze11Nu3jhwtBWPnsIwACuRwAGwm6YO4E9erf73kcfFYpF 31ve3NxUFMX3ZgGEk8i9nO7ri3a7/fNPPw2t6pWH9AvghgjAAPqTwLFYbAhnUWwT g6FX/vCHBx580N9mXdddWlqybdvfZgGEjbiN9A/OodKVHzZrtfkrV3Rdz+fzQ7so Z/8CuBkCMIC+XC6Xkn8m8E5idHLnXXe99Oqr/jbb7XZXV1f9bRNAeDiO01VV13WD 7sgksG17/vLlZrM5Ozs7zPdYhbaiqJz9C+BGCMAA+krlciQSmZmZGfJ1o7HYO++9 529ZrFqt1m63fWwQQBj0XFdTVYcizz7Rdb1/2K+up4f77urUYDWQCMBdlq8DuBEC MIAtc/m8pHN6d6dp2kuvvHK/f8uhWQgNYF96vZ5lmoauc7qvX7xlz6ZhDHPT77Z2 u612OsO/LoCxQAAGsKVSraqqOsz6nNvEoFNc909vveVXPWoWQgPYC9d1RUgT6Zfo 6xfTNC9duKBpWjKVGvKyZ0+r1bIsizOrANwMARjAfxl+NaydOp3O08888/iTT/rS GguhAdyMiLu2bVuGwVIRH4kXc2V5eWN93TLNQCZ+p6h9BWAPCMAA/pu5ublkKhVg B6ZnZl557bUjt912yHZc111eXraYBACwg7gziHgm9Chz5at2u/3LpUuGYWQkHPO+ j25Q+wrArRCAAfw3AS6E3tbr9bLZ7B9ef/2QUZyF0AC2eVO+vCnmO73bFdE3wDXP 21qtlmkYlDEDsDsCMIBrFYvFWDwe7DhGaDWb99x//0uvvHKYGtGbm5uKovjYKwDj xStwJXIRJxv5ztD1X375pdNui1c4XygE2xkWPwPYIwIwgBsQQxl/jyY6sFardc+9 9z73wgvZbPYA385CaCC0HMfxClwF3ZEJ1O12r4jo2+mIu2s+nw+6O31UfgawRwRg ADeWy+VSQz+88WZEjk1nMs+/+GK5Utnv9+q6vrKyIqNXAEaQN+UrfrEUVgYRei// /LO4ryaTyeEfHX8zbP0FsHcEYAA3JqKmpmnBbga+Rr9wq+M88eSTjz722L5WaNfr 9VarJa9jAEYBU77y2La9urJS29iwLCudTge+R2Yntv4C2JcRun8BGDWFYrHb7Y7I 8radOu32sXvuefqZZ/a460wk5+XlZZNhMTCJtnb5mqZLBJJA07SFy5fbnY5j20Ed brSLZrMpMrnDcVYA9owADGA3IgPHR6Ag1g31R722ffyRR5546qloNLr7FxuGITLw cDoGYAjEHcBxHAo7S2KZ5tLSUqNet2171KZ8t1H4CsABjOLtDMBIERk4kUgE3Yvd tFqtXC732BNPHH/00V1GaY1Go9lsDrNjAGTgLF95vKXOmxsb4uW1HWcEVwDtROEr AAdAAAZwa3P5fDKZDLoXt+Yl4eMnTjzy6KPXzwn3er3V1VVd1wPpG4BD6lcBsPrJ l/WuvrMsS+Te+uamaRijn3s9FL4CcDAEYAB7Mjc3l0ylgu7FXomBsgi6Dz700FNP P70zuouh8/Lysvi3AfYNwL70lzrbIvlaVLfynWEYS/PzjWZTvMKZbHY01znfEOkX wIGNzZ0OQOBG6mCkPRJD5067XSqXf/vMM3cfOzY1qJjSaDSC7heAW+tv8R0caMSb Vj6ybbtRr6+vrWmq6rpuNpcbo9zrIf0COIwxu+UBCNY4ZuBt/X2Dtv3gQw/ddvvt U+M24APCw9via1kWVZ19pHe7y8vLzUbDcZxUKjU6R/juF+kXwCExBASwP7m5udT4 rIW+oV6vJ4ZQyWTyjqNH7zp6ND7aJb6AkOjXdR+sc2aLr18Mw1hdWWnW6+ITt9fL jeFk7zVIvwAOb7zvgwACMV77gXfnheHZZLJQKt197NgInnIJTDavtJVgc5rRodm2 LW5ojUaj3WoZgyrZ47jC+WZIvwB8MSH3RABDNpfPz87OTsy4apvSasXj8XQ2e9fd d1ePHBnfVYLAiPuv0lYi97LF9xDEC7hZqzXq9W63KwKwCL2T90Zev5pDp8OJRwB8 MWmDVwBDky8UEonE5GXgba7rapom/oxiNCnycLFUCrpHwNjr595BaSuRfSltdTAi 5bYG1fzanY41mOZNZzIT/G4d6ReAvyZ25ApgCArFoqHrkzfbcENiwBmNREQezuRy d9x1V7lSmeARJ+AvkWFckXsHW3zJvfslXrZGvS5uQV1VFZ87juP2emNxVO/hiag/ NT3d1bSgOwJgchCAARxKqVwWGTiTzQbdkWETg3gxJpsrFMSfXYxEC6VSLBYLulPA yNk6ysiyeq4bdF/GhmmaG+vrSqul67q3RHy8Dun1i3gFDMNwKAYOwFehu5kC8F0k Ekmn0+N7PJIvRB7Wu93ZVEq8DkJubq5QLEaj0aD7BQRje52zS+69FRF3N2u17bjb z3u93iQVrzqYtqKIF4T0C8B3ob63AvBRvlCYnZ0NuhcjpB+JdX02mRSROJPJZLPZ XD6f4MglTLTtdc7k3huybVsdbGdtt9vE3V2I14dNvwAk4W4LwB+VajUSiQTdi1En hnSJ2VmRipODqWIx6s3NzTFRjHEn4q63ztllvu6qaCwm4u7a8rIism632z/f2HHE C9UbnCQXdO9GXavVYt8vAEkIwAD8Ua5UCHIH0N9L3O32U/EgGKeuBmPxedBdA26h n3styx5Eu6D7EiQRdL0yxeKXruvit/2sO3hNmNo9GAIwAHm4KQPwR6lcpgqUj5RW S6TifjBOJGZTKW/GOJPNsogagRO51x6scw5n7jVNs60o/VOI2m3xOjiu2xO/er18 oRB01yYHARiAPARgAP4olkrxeDzoXkw+r/p0TEj00/EgFveJjyxBh1RbuVdEPtsO ui/SiT+s+EHTul3xUe92zcECb/EHFz9xzOgOAQEYgDzcxAH4gwAcLBGMVVWNi2Ac H+jPHA+2G6f6xEdG7TiYSc294kfGMAwRbo0Br3ZXf0V3/392JpPhRyZABGAA8nBz B+CPYrEYZ3XuqPLmjaNePPY+Jga2CnKl+G+Ha/QG+3vHOveKzuu6bui6N3/rHcsk wq09qL3MXO4oU1otjQAMQA5u/QD8QQAea67riqgQjfYz8pZEYisme2Wrk0mKnIVB r9fz6lrZo517RSz3Zm63wu1g5ta+SvzbZCo1MzMTdDdxQARgAPIQgAH4gwA88bZC ciQSGQTkfloeTCdvLbu+OqUsPjCxNnZGJPf2u+El2u1Y6xnM2XrJVnxCuJ14BGAA 8jBGAeAPAjA8IsN0Op3IzEw0FouIkBzti3iBeVt8KzKL/1G7K0DiP5Z9dfpU0iVc 1zW399ZeDbSOd1LQ4IPjRVvbdnu9bDbLuyeYIgADkInHDAB/FIpFTujBAYgMpqnq dCTSn1vuZ+XBh8Ev7/Po1fAcvVrhS/yDCcDDOFju7VfDGkzGejl2a0p2m0iw/dNv Xe9z73CgNKWkcCAUwQIgD48lAP4gAGNoegNifCzClYjIIgxvfRS8f/Szc//zrU88 0asRO+rNSke87wr6TyOdCK5eVBXZtb9rdlAUyu1nVXc7sroD4svEC7v1+8En3peI V9wrGUWaxXAQgAHIw5MMgD8IwBhHXpZWVVU8DkW6E+FZ/GNm8GvKC3wzM/1/dTUn zwx+KzJkIL1NzM72BoF2q/MipXofez3xJ3EHv6YGwbX/p5qaSpNaMZ4IwADk4aEI wB+cAwwA8AUBGIA8BGAA/iAAAwB8QQAGIA8BGIA/SuVyLBaT0XKv12MNJwCMGnk3 ZwIwAHkYUwLwR7lSiUajMlpWO514ImEYhrehUcYlAAB7JHKvPtgGb5lmbm5OxiUI wADkYSgJwB+ValXSga5ipPX3b78V46H/7//8n8XFRcuySMIAMGT90uvdbrFUuvOu u+Lx+Ml//1vcnAnAAMYOI0gA/pAXgF3X/fzrr7d/KwZG/8///t8ry8uzs7PEYACQ TUTfeCJx97Fj24UebNs+d+bMoEq6lIPEWs2mCNsyWgYAxo4A/FE9ckTekaoffvLJ NRW2NE07+d13ly5eFJ+4jpMvFCRdGgDCqdloiNx7+x133Hb77dfc3tuKsjA/L+8t SAIwAHkIwAD8IQKwvBNHX3/rrWKpdMN/ZRjGzz/9dObHHxv1uuu62VyOaWEAOJhe ryfCbSqdvuvuuws3f2Oxvrm5vLQkadWP6MPa6qqMlgFgigAMwC8ioHa73Tk5+8Ge /f3vf3Xvvbf8MqXV+n//7/9dXFgwDSOTzZKEAWAvRObUVLVcrd5x5517OdBudWVl fW1NUuV/pn8BSMXoEIA/SuWypmmSAvAjJ06cePzxvX+9GDydOXXqp4sXO+224ziS yrQAwFhTWq3ZZPL2O+4oVyr72sMyf+VKfXMzkUjI6FWj0TAGVaYBQAYCMAB/5AsF 0zRzuZyMxo8eO/b8iy8e4BsNw1hcWLh08eLK8rJlWalUSt5GZQAYfa7r9qs353Ii 92ay2YM1Im6qrVYrmUz62zdPs9HQCcAApCEAA/CNGEtlMhkZLRcKhTfefvuQjfSn hX/88fLPP7eaTcdxWCMNICR6vZ7a6cwmk0duu22/k703dO7MmU6nk06nfeneNVgC DUAqBn8AfJPL5VJyxkOxePyjTz7xsUGl1fr+3/9eWlxUVdVljTSASSRudPFEolSp 3HbbbXvZ2bt3P/7wg6Zp2YNOIO+OAAxAKgIwAN/M5fOSVsQZuv7Nt99KadkwLpw/ /9OFC0qzaVmW67qEYQDjS4TeWCyWyWZvu+MOSXtShJPffad3u5Lulq1Wq6tpMloG gCkCMAAfFYpFSTVRer3eex9+KGl6WajVau12WwTg2sbG2sqKGEFapkkYBjAW/iv0 3n77EO5auq5fPH8+EolI2kVCAAYgFQEYgG/KlUo0GpXU+FNPP/3gQw9JalwE7NXV 1Z1lV0QY3tzoazUahmH0XJc9wwBGhLen1wu91dtukzfTe0PLS0sb6+v+rqneiQAM QCoGcwB8U6lWZ2ZmJKXEO48effHll2W07HEcZ3l52bbtG/5bkYGXFhZqGxuaqtqW JUaf2VyOPAxgOMQ9p60o0Wh0NpkUd9pSuRyJRILqTH/PiKJI2vAi/qQiAOvsAQYg DaM3AL4plUpdabvCErOzH3z8sYyWt5mmubKy4rruLb9S/DGX5+fr9bqmaSIPuyIP Mz8MwD/9xNtux6JRcesTcVf8isViQXdqy+lTp1RVpQIWgDHFcA2An9KZjKRRUafT +ce//iU7ZOq6vrq6Koae+/ou0zDWVlcb9bra6RiG4di2SNEiFefzeUn9BDBJms3m zPR0NBqNJRLJZFLEXXH3GM1Dy23bPnv6tLghS7q/iZeC6V8AUhGAAfhJ3klIwnMv vHDsV7+S1Pi2brcrMvAhG7Esq9loNOv1drstBnPityIVOyIUi19TUwRjIJxEuhMD r5lIJCp+xWLxRCKdShXLZUkH6sqwtroqfsmbjmYGGIBsBGAAfsoXCrOzs5Iav+32 21/5wx8kNb6Tqqrr6+syWhZJWAzvOorS6XQMXTdN0x5wB3qD1de5uTlWUwPjqNfr Ka2W+PmdnhEhNxIRH6N98Xg8mUoVCgXxMeg+HtbF8+cVRUlJ+4NQAQuAbIyxAPhJ aiFoERE///prSY1fQ14G3p1IyG1F0btd0QHxUSRkS4Rkx+lPIDuOF5LdXk/cuzPZ 7MzMjBgsTjGlDMjRbDbFx7m5OfFj12m3e1NTM9PT/WQbjUYGU7jidpdIJGaTItim iqWSl29FDBY/tl71+KD/BP774fvv+7UepNWdJgADkI0ADMBPIgDL2xsmhpV/eOON arUqo/HrBZWB98ULzGqnIz6KUakYc9uWtTWl7DjT09NUqwZ20Z+zVRTxE+Jl2lgs JgKtyLGZbLZcre53nlMkXtPsZ9/91hEYF+12+5dLl0Tsl3RXYQMwgCFgVATAZ/Lq YAlHbr/91aGsgvaIDLyxsTG+Y9mtFdftttbpdHVdjMtZcY1QuXZN8iDixhOJ2dlZ cacSETeTyfhyIfEDJX6+xC9fWhtZF86fb8tc/0wABjAEDHoA+EwEKnnDI13Xv/nH P4YZ2Lrd7tra2vhm4N2ZptlsNFQRjzVNvLaWYViDtdb9QtY9b7V1f7k1IRkjyAu3 4iczMjMj8u1gUXK0X1kqHhcBV9yFSpXKEM4nEz8upvjZsSypVxkFtm2f+fFHca+Q dNbdFOufAQwFAxoAPiuWSmIAKq/9E48//siJE/Lav55hGKurq3s5H3giWSIkN5ua qmqatlW4y7JESna9X71+UO5/GETluXyeqIzDEH+XWoOdtyLTzngzt+KTaHSrbPJ2 uC2X05lMsH/ZRCAU0Vd8DLAPw7QwP79ZqyUSCXmXIAADGAKGKQB8Vq5UZgYktS+G vJ9+8YWkxm/GsiyRgcMz0j2Y/nxyvS5yshjCbpXvGnAcp7e16npgcBbU1KC2EGk5 DPqZdlCtTQTa/g/w9HQ/03orkqPRWH/WNhafnZ1NJoulUnZQ3S3oLu9G/HG86Cv+ Ygfdl+ERf+RzZ892VTUjbYeLuEN4tQwktQ8AHkYeAPwnRkh+7ay7oaefffa++++X 1/4NicHu2tqaMel7/IbGK99l6LpXu8v0Vl9vV/AaFPHyJpa9GebeIHiI7ERsDtBW lBX/NaanZwZR1punnRr805up9eZpvalaoVAs7jz7R/z39oonB/inODCvvLP4uxrC 9SAry8sb6+vyjv8VFEXRVFVe+wDgYQwBwH9z+XwymZR6ic++/FJq+zckhr+1Wq3T 6Qz/0vCI2Nxpt0Vg1gc1vayr67G3j4naru/V2zaozdufc76aoqe8IB2m1driT91W lK3U6kXVQXrtDabdxOszvf3/D3hzs96q42g8Ppvo65/yfaOfa/GfoKtp8URC/JrU l9SrcSX+vk1qOYDdDWH6d4r1zwCGZTIfVACCValWxfhZ6iUeOXHixOOPS73EDXkz YI1GY/iXho9EkNZUVQzrxSf98OyV/nLdnUF6e/55yvtkavCfv9cTf7el7nLfpc+i w9PeKuLBFtnp7Y2yU1Mis/Zj69Xs2g+xUW86NpZKpURy29nUYM1x3MfDbLzJeV+a GjXir4R3uljQHQnS4sLCZq0m+689ARjAcEzm4wpAsKpHjnQ6nVwuJ+8Suq5/8c03 Utfj7ULTtPX19XDOBWHs9Kd/B1tw+7k3FhMfJzWs+qi/0deyTMMI1UbfG7Is69yZ M+KmJ/WWTvoFMDQ8AgFIIfUwJM9cPv/WO+9IvcQuTNMUGTgMZ59gAti2HYlEyL17 0XNdc7DRl3e4PD+dP6+027J3tRCAAQwNz0IAUpQrFdl1bsTw9LfPPPPAgw9Kvcou XNfd2NjQGLQBE6F/ou9go2/QHRkhIpde/vnnmPxVAwRgAENDAAYgRfXIEVVVszIr pkwNFkJ/9Omnsq+yCxHCFUWp1+tBdQDAIYmfYse2RfTlnLNrmKZ5/uxZ2YufBaXV 4p1EAENDAAYgyxBqQQuRSOSDv/412FNVRA7f2Nhg9AyMF2+1s2WaITzW6JbEDe3C uXNdTUul07KvxfQvgGEiAAOQpVwuR/wrM7uLfLH4+ptvzszMyL7QLhzHqdVqTGIA Y4HVzrd06eJFRVFmZ2dlX8hbR0MABjA0BGAAEuVyuSHMHojx01133/3CSy8FXuPH Ww5N7RxgNFHbeY9WV1ZWlpcTQznYua0oqqrKvgoAbCMAA5CoVC4P56QiMa6978EH f/fMM0O41u5M09zY2DCZWQJGies43mpn3p+6pY319aXFxXg8Ppy3FFn/DGDICMAA JKoeOaKpamYoRarEuPaBhx/+7dNPD+Fat+xJo9FoDU5eBRCgrSlf03TYor83/fS7 sBAfytzvFOWvAASBAAxArkKxmEgkhnMtMdi99/77n3nuueFcbnfdbrdWq1EZCwgE U74HsNZf+Dyklc8epn8BDB8BGIBclWpVVVXZp2hsE4NdccU/vvHGcC63O9d1G42G oihBdwQIC6Z8D8a27Su//CLi6OzsLOkXwGQjAAOQbpiTwB4xhnvn/feDPRtpG1PB wBA4jmMx5Xsg4kW7cOGCPpQTj3YiAAMIBAEYgHRDngT2WJb1lw8+yOfzw7zozTAV DEgi4q6XeynsfDCdTufSxYuGYWSHUqxhG+kXQFAIwACGoVgqxePxIV9UDLCe+u1v nx6B0tAeXddrtZpI5kF3BBh7Ivc6tt2PvvxAHZRt20uLi5u1mki/w3+vkPJXAIJC AAYwDKVyWYyxMpnM8C8di8XeeuedIS/tuxkxahexvNlsskoTOBjXdft7fE2z57pB 92WMdbvdSxcv6rqeDuLeqCiKxtm/AAJCAAYwJMVSSWTRoZVX2UkMth49ceK5F14I 5OrXE2P3zc1NMfQMuiPA2KC6lV9s256/fLnRaIgXM5BNIuI/pbgns/4ZQFBGYiwI ICTm5uaSqVRQVxej5+dffvmee+8NqgM7iSFgp9Op1+sus1jAzfWXOl+tbhV0XyZB o16/cvmyiL5D3vG7U1tRVKZ/AQSHAAxgeMqViqaqubm5oDogBtPRWOyV116rVKtB 9WEnMbJvNBrtdjvojgAjZ+sgX8tiqbMvOu32L5cu6YaRTqcDXAvTajYt27bZuQ0g OARgAENVKBbj8XiwS5FFDE4mky+8/LII5AF2Y5uu65ubmyYTXID48XRdEXqp6uyj Tqdz+eefxX0mlUoFfu9l8TOAwBGAAQxbbm4uFdxC6G1iKJaIx5978cXb77gj6L5s jQubzSYrohFO3hZfgblBHymt1pVffjFMM/Do62HxM4BREPzdEEDY9BdCa9qQjwW+ mf4horb9xJNPnnj88cAHiI7j1Ov1TqcTbDeAodne4ityL6XR/WLb9srycm1jQ3wS 7ILnnVqtlmkYTOwDCNxI3BMBhE2AFaFvRsTOe++77+lnnw2wNoyHFdEIg63SVmzx 9VW32124cqXdbovoOyJvMnpY/AxgdIzQ6BNAqOQLhdnZ2aB7cS0xSnNd9/Enn3zk xIkA8zkrojGpvFN8Re51mQn0j4i7qysrmxsb4pUdnSnfnUQmV1nbAmA0jNwtEkB4 5HK5VDoddC9uTGm1iqXSE7/5zf0PPBBUH6gRjYnR32swyL2c4usjkXs3a7X1tTVD 18XtIsAC+7tj6y+AkUIABhAYkTBNw8gEveR4d2LoViiVHnviiQcefDCQeRXDMOr1 uq7rw780cEhbpa1M0yb3+ke8mBvr6yL6ituCY9sjm3s9SqtlUtsMwCghAAMIUqlc 7mraiA/gPGIYJ/p5/NFHf/3II7FYbMhXV1VVxGBSBMZCP/fatlfaKui+TA7xeq6u rjY2Nw3TdEd4vnenVrNpcqIVgBFDAAYQsGKppHe7YzGY87iDc0qrR448/uSTd9x5 5zCv2xqgWC5GlvjRMHSd/b1+sW1bZMjaxkan0xF3gFQqNTMzE3Sn9qqffln0DmD0 EIABBK9QLHa73Xw+H3RH9q2tKOlM5t7773/k0UezQ6m5KgbEjUaDo5IwOnq9nmkY pmlSz9kv4n64srystFqWaYrcO0bvD25rNpsWc78ARhIBGMBIEBk4FouN0eTGNUQG UFU1lUrddvvtjz72WPXIEamXMwxjc3NTfJR6FWAXItuYum7bNksSDk+8jG1FadTr iqL0Q2+vl81mR7CY8x6J0N5utzn0CMBoGtd7K4DJM+4ZeCcxlp1NJoul0sPHj//q nnsikYiMq3Q6nUajwcZgDI1X1Kq/q5O/dYdmWdbm5mazXhdBUfwUj+lM7/XEH0QV WKUCYFQRgAGMkPFdC70LMRzUu91UOl2uVn99/Pgdd97p48SOaNw7MZhZOMjjOI5l GCKw8dfsMETKbTYarWaz0+l4K8bTmcxkvOW3TdyLZqanNeZ+AYwwAjCA0VIoFLq6 PmEZeCcxQIxFoyIPF0ulBx9++O5jxw4/P8yJwfCd67r9E4woYnQI4tVr1OviR15T VfG56zhurzfZNzfxd4Y1KQBGHAEYwMgpFIuGrk/GasBb6vV6nU4nHo+nM5lyuSwi 8e133HGwKWLTNOv1erfb9b2TCImeCL2OYw9ObWWyd7+8CV5FUdTBBK9j2+IVHOut vPtCzWcA4yIUN2UAY6dYLIoRZCabDbojAXBdV1PVWCyWTKXyhcJ9999/1913JxKJ PX67pmkiBlucv4q9EUFXhBYPxxftXf/9plqt3el0NW17nnzyljTvkdJqiReEuV8A Y4EADGBERSKRdDqdSqeD7kjwRERpK4oYWIsYLFJxbm6uUq3ee//9czeZJO9/fbvd aDRcjqXBjfRDryDyikhuhN5diRdJU9WOqqrttq7rXtbtv2jT07lcLiSzu7sTdyfx yvAXCcC44MYNYKTN5fOzs7OMMm+o2WxGZmZisVhcBONkMpvLFUule++7L18oTA1m ksUXKIrCWlZMDUKv62zN9bJO9XriZVE7/Zwr4q4hgq43JT7Qm+iNu4fh7eCg4DOA 8cKYEsCoC9WWYF80G43pmZlIJBKLRmOJRDQaTSQS6UymeuRIJjQ7EjHlhV7X3V7h PMVbIYPXxDTNbrerd7vra2vbtan6yyVE0B28eYS9aDWbU9PTHPYLYOwwDAIwBkQG FsP3NMuhD02M/pVWS2RgkZCjIiKLcBzrEwk5lUqVyuXc3NyMnFOLMTQ7Z3rDNv8v cqxhGKb4NeAVsrYGpYm99d6pdJr3gA5PURSDZc8AxhPPAABjYy6fF0Nb1iJKJfJS q9USn8wMQnJkZjCVLHKy+BCLiV+JeN9sKlUoFkVmDrq/2LJzprc3cXu/RXY1B7Wp ravB3gu0W5873oe+8FRdDkqz2Zxm4hfAOOMhAWCc5AsFMeoNZ3XoEbSVlns9EZX7 ebkfmWf6/xt8jAw+iQzy839NNg/yczyRyM3N7b20NW6of2rR1UA44gXP+vnci6mD pOrlVXdw6pI7+MT76Ax+2//D2N4HW/ypspkMmXZEKK2WMTjhKeiOAMDB8UQBMH6Y Cp4MXgUd8Rzqh+dIxJtznpnZ+qf3+dXf9D9MDT4R39jP2/1/THu/9Q6e8UL49m/3 aytAentBB33zFg/v/K23pVb8LxnQ1HdX06av/um21zZv/3mv+eMf5nXY/uNvfRR/ 6sFv3O3/03spdr4s2/+P9/nVT0J1Fu4EY+IXwMTggQRgLEUikVQ6nUqlGFgDgDz9 N6oGR0Cx4xfAZGDgCGCMFYpFyzRZEQ0AMiitVm+w9CDojgCAbwjAAMZePp83TZNz kgDAL63BmmeN6Atg4hCAAUyCaDSaSqcty5ojBgPAIXgH/FqmaVPsCsAkIgADmBxe DLYti9lgANgvoi+AMCAAA5g00VgslUoRgwFgj7ai7+Cw5aD7AgByEYABTCYRg9Pp tG3bWUpkAcBNeGWuiL4AwoMADGDCJVOpSCQiwjAHJgGAp9frtdtt8ZEKzwDChuEg gFBIJpPRWMyxbdZFAwgzb7WzSMDdbjfovgBAAAjAAMKFCWEAIcSULwB4GP8BCKNk MjkTiYg7YDqTIQkDmFT93KsovcFnTPkCwBQBGEDIJVOp2GBpdCabJQkDmAz/lXun ppjyBYCdGO0BQF8ymYzF4xyeBGCsscUXAHZHAAaALXP5vAjA2Vwu6I4AwAE1Gw1d 14PuBQCMLgIwAGwplcuaps0xAwxgbDUaDYMADAA3RwAGgC2VarWtKPlCIeiOAMAB MQMMALsjAAPAluqRIzMzM0H3AgAOpdVssgEYAG6GAAwAW8qVSjQaDboXAHAorVaL ys8AcDMEYADYUiyV4vF40L0AgEMhAAPALgjAALAlXyjMzs7KaLnX65/HyTnDADxS 7wkEYADYBaMxANgyl88nk0kZLUei0bvvvntlZaWtKKZhuK6bzmTYbwyEh+M4IpRG IpHE7GyxVNrY2DB0PZPJyLgWARgAdkEABoAt2VwunU7LaHlubu6tv/xl+7e6rl/5 5ZelxcXNzU1NVS3L6hGJgQki4q740RZxN5ZIpFOpSrUqbi8753vPnj6tdjppSQGY IlgAcHMEYADYIgaj2WxWRsu33X77K3/4wy5fICLxwvz88tJSvVZTVdU0DNtxpnq9 awbNAEZNr9drK8qMyLrRaGJ2NpPL5efmxK1k95/ci+fPK4qSSqVkdKnZbOoEYAC4 CcZVANBXqVbVTic3Nyej8Xvvv/93zz673+/qatovv/yyurLSajQ0TfNSses4YsDN YcXA8DUbjRlBZN1YTGTddDp95PbbS6WS+H+2v8axbXEnuWVTv1y6JGKqpKIDHAUM ALsgAANAnxjFdrtdSQH4xBNPPPLoo740ZRjGytLS+vp6fXOz026LYa5lmlvBeGoq n8/7chUgzEQ0nZmeFrE2Go3GEyLqzmZzuSO33SY+3vJ7xc/jXvbfLi4s1DY2EomE H/29FkugAWAXBGAA6KtUqzMzM5LWGz//0ktH775bRsvbRDDeWF9v1kUu3lQURQzB xf9jW5bIxj3XFV+QyWbZYwx4XNfttNviEy/l9md0E4lkKiV+TMrV6mFWJhu6buxh 9nVNWFkR1z3whXbR6/XUTp+MxgFg3BGAAaCveuSIvHz49rvv7mXuSB4RhsVou9ls Nur1drvd7XbFGN2yLNdxHNcVCbl/KMv0NBPImAzir7pIgd5y5Yj4KCLuYC43mUym 02kRcSVVnxL0btc0jFv3sNFYWlyUd8+hEDQA3AwBGAD6SuWyvNmYz778ctRqWS0u LooAvP1b8bna6YhgrKmqrusiMPdXVtu2Y9vuQM8dpGTxYfDkEHme+WQMk+M4nXZb /PXrr9MYrNbYyrfRvlg8nojHZ5PJVDpdKBYl7a3dC/ETZO/4yboZ8cN17swZeatO CMAAcDOjNSADgKCIQbOk/XiGrn/z7bcyWj4wEXFXVlYO/O1eWrYMQxvMJBum2U/L lmXfKC33rn4y+KxPBJe5ublRe0cAson/9CKVib8M0ztMiRx7NdAOEu0g0w6qTHnL kkWUTSST+UJB0o+n70RKdx1nL1958rvvdGl1BwjAAHAzjD8AoE+MsCXNGon77Kdf fimj5QOr1WrtwQbIQHj52RSxWWRmy3L6E819ruP9w3UHH9yra7O9NN1fpD0IUf2P VxN1/8P2J4OPOz/Zu+00fs0nW7/1otrWP6fdQQ8P9xochMiH6UwmGo1uvxr9V2zw 6nlvPRz+ddj+8+/yOux8Kf5bcL2aXr0E64nGYtFIJB6PZ+fmApyVHSal1Zra2yt/ 6uRJTVUJwAAwZARgAOjL5XKpdFpGy8lk8r2PPpLR8sGIpDQ/P3+QdIT925r0vpob D8k0DL3bFRnYW/croiYT6SOlfyawCMB7c/rUKRGAM3LOHqcQNADcDA9OAOjLZrOS 6uIUS6XX33pLRssH0263a7Va0L0IHW8q+5B7Pr23LQi9I8txHHXPayvOnz0rfhjT ct53IwADwM3wEAWA/vpnyzQlFWo+evfdz7/0koyWD2Z5ednYQ5VayODvhDBGjWVZ XVXd4xdfunix1Wolk0kZPWk2GvoeTmMCgBDiAQwAU+VyWet2c3IC8MPHjz/x1FMy Wj4A0zSXlpaC7gX6C9GJwZPHW6O+xy+ev3y5Xq9LKu7FHmAAuBkevQAwValWvVI+ Mhr/3bPP3nv//TJaPoDNzU1FUYLuBbawpHnC7PEQYM/K8vLG+rqk09dc111fW5PR MgCMOx66ADBVPXJE3qm2f3rrrVKpJKnxfRFxa35+vl8uGKPEOylqWtqRsBiaPR4C 7KnXasvLy5FIRFJnmAQGgBviWQsAU+VKJRqNymhZRJtPPv9c3hh3X1RVXV9fD7oX uDG2B0+AvR8CPDXYMHz+7NlD1kXbBQEYAG6IpywATBWLxbicnXh6t/v3f/5TRssH sLq6SmHYEUcMHmvtVmtfB4yd/Pe/dV2XdBSw0mppBGAAuA7PVwDoV4GenZ2V0bIY Df/tq69ktLxflmUtLi4G3QvsCTF4HO3rEGDPDydPdlVVUgBmBhgAbognKwBM5XK5 lJzTOGeTyfc/+khGy/vVaDSazWbQvcA+EIPHy74OAfacPnVKVdVsNiujPxwFDAA3 xDMVAKbEADSdychouVgsvv7nP8toeV9EjlpYWHD2vDsRo4MYPC72dQiw59yZM51O Jy3n3TcCMADcEE9TAGGXLxTEyFXSJMxdR4++8PLLMlreF03T1jgTZZxRKXr07esQ YM+lixdbrVYymZTRn2azud/+AEAY8BwFEHalcrnb7eZyORmNP3T8+JNPPSWj5X0R 6ZdyOBOAc4NH2b4OAfZcuXy5Ua8n5FTgYw8wANwQD1EAYVepVkWikHQO8G+feeb+ Bx6Q0fLe2ba9sLAQbB/gI2LwaNrXIcCelaWl9fX1eDwuoz+u666z7gMArsPjE0DY VY8ckZR+hT+9+WapXJbU+B41m81GoxFsH+A7EW/YGDxS9nUIsGezVltZXpZ3Tjjb gAHgejw4AYRduVKJRqMyWu71en/9298kNb73PiwuLtq2HWAfIAlTwSNlv4cATw3q Zp0/e3ZG2tZuVkEDwPV4agIIu2KpJGkJYrfb/Y9//lNGy/vqw+rqarB9gFQ9151i KjhoBzgE2HPyu+/0bpejgAFgaHheAgi7fKEwOzsro2UxJv7bV1/JaHnv1tfX1X0e zYKxw1Rw4BzbVjudA3zjD99/LzIqARgAhoaHJYCwy+VyKTnncIpc/f7HH8toeY8c x5mfnw+wAxgmpoIDZJnmwaLm6VOnVFWVdAwbe4AB4Ho8JgGEnRh6pjMZGS0XCoU3 3n5bRst71Gq16vV6gB3AkDEVHBRD18WvA3zjuTNnOp1OWs57cARgALgez0gAoZYv FEzTlHQI8J1Hj7748ssyWt4LkYWWlpasfZ7LgglAgejh62qaZZoH+MafLlxQFCWZ TPreJaHZaOgHiuUAMMF4OgIItVK5LG8D3kPHjz/51FMyWt4Lyl+FGRl4yNROxzlQ rfUrly836vVEIuF7l6aYAQaAG+HRCCDUKtWqvDNIfvfss/fef7+MlveC8lchx3Lo YWorSn8P9v6tLC9vrK/HYjHfuzQ1+DsgMjCTwACwE89FAKEmAnAkEpHU+Bt//nOh WJTU+O4ofwWPiEBkYNkOfAaSUN/cXF5akncXYhIYAK7BQxFAqJXKZXlzL59+8cXM zIyMxm+p2Ww2Go1ALo1RQ3Vo2VzH6bTbB/te27bPnTkjbx0KJyEBwDV4HAIItUKx KGn3nWEY3/zjHzJaviWRvRcXF+0D7UjERGJLsFS2ZWmH2G7ww3ffdbtdjgIGgOHg WQgg1ObyeUn1V2dmZj75/HMZLd8S5a9wPbYEy2Mahn6IZcanTp7UNE1SLXoCMABc gwchgFDL5nKSTuDMZDLvvP++jJZvifJXuCEysCQi/YoMfOBvP/Pjj5qqSjqNnD3A AHANnoIAQk0MOrPZrIyWq9Xqa6+/LqPl3dm2vbCwMPzrYlxQFst3Ir7ahzhw+8K5 c21FScl5J67ZbB5mdhoAJg+PQADhVa5UxMhV0ta7e+6775nnnpPR8u4ajYYY8g7/ uhgjZGB/ddpt13EO/O2/XLokfmZnZ2d97NK2ZqPBMUgAsBPPPwDhValW2+12Pp+X 0fjjTz7560cekdHyLkSwWVhYcA4xFkdIkIF91G61vOXlB7O4sLBZq8XjcR+7tI0Z YAC4Bg8/AOFVPXJE3jFFL7/22u133CGp8ZtRVXV9fX3IF8WYIgP74jCHAHs21tdX V1ai0ahfXboG24ABYCeefADCq1ypyBt0vv/xx5LWNO5idXWVkS72jgx8eI5tq53O YVpQWq2F+Xl5b8ZRCBoAduKxByC8iqWSpGWHHVX99l//ktHyLizLWlxcHPJFMe7I wIdkmeYh46Vt2+fOnJG3HYMADAA78cwDEF75QkHSJK3rup9//bWMlndRr9dbh1uK iXAiAx+GoevGoatM/fD99yKjSirIRwAGgJ144AEIr1wuJ+nokcTs7Acffyyj5ZsR kXthYUF8HOZFMTHIwAfWVVXrEGcgeU6fOqWqqqQj2dgDDAA78bQDEF5iuJnOZGS0 XCgU3nj7bRkt30y73a7VasO8IiYMGfhg1Hb78HXXz5050+l00nLejyMAA8BOPOoA hFS+UDBNM5fLyWj8rqNHX3j5ZRkt38zS0pL44wzzipgw3kE+ZOD9UlqtqUOcgeS5 dPFiq9VKJpO+dOkaHAUMADvxnAMQUqVSqdvtStp09+tHHnn8ySdltHxDYnS7srIy tMthUpGB98t13Y6iHL6d+StX6pubiUTi8E1djxlgANiJhxyAkKpUqzMzM5LG+s/8 /vf33HuvjJZvaH19XVXVoV0OE0wkuumBoDsyHmzb1g53BpJndWVlfW0tFosdvqnr 9Xo9pdUiAwOAhyccgJCSegjwm2+/nS8UJDV+DTEEX1hYGM61EAaO48h7b2jCmIah +xEsG/X60uJiJBI5fFM3RCFoANjG4w1ASMk7BLjX63325ZdDyw+NRqPZbA7nWggJ 13VFBg66F2NApF+RgQ/fTv8o4NOnZyIRSfcNpdXSCMAAMEAABhBS8g4Btizrq//4 DxktX0+E7fn5eU4/gu8oCr0Xmqrahz4DyfPDd991dV1SWT5mgAFgG882ACGVm5tL pVIyWo7F4x998omMlq/H6UeQhwx8Sx1F8evtpx9/+EHTNFlHAROAAeAqHmwAQiqT zWbkHAKcz+fffOcdGS1fj9OPIA9FoXcnXp92q+VXa+dOn+4fBSznpkQhaADYxlMN QBhVqlW105F0BtKdd9314iuvyGj5GmJEu7q6OoQLIbSYBN6FX2cgeX66cEFRFI4C BgDZeKoBCKPi4BDgOTkB+OHjx5946ikZLV9DpF9mdSAbGfhmbMvS/Dt+bP7y5Xq9 zlHAACAbjzQAYST1EOBnn3/+V/fcI6PlnUzTXFpakn0VYIoMfBN+nYHk4ShgABgO nmcAwkjqIcBvv/tuVk4p1502NjY6nY7sqwBTbAa+Cb/OQPI0G42lxUV5p09RBwsA PDzMAIRRsViMy1lq6Lru519/LaPlnWzbXlhYkH0VYFvPdac5Gfi/0zod8ZPoV2v9 o4DPnJmenpaUgTkKGAA8BGAAYTSXz0sqNmM7zpfffCOj5Z3q9XrLv/KzwF6wEPoa bUXp+XoE9w/ff9/tdjkKGACk4kkGIIzEEDOVTstoOZ5IfPjXv8poeZvrugsLC36d PgrsEQuhd/L3DCTP6VOnVFWVdRQwdbAAYIDHGIAwSmcykkaZhWLxjT//WUbL21qt Vr1el3oJ4IaYBN7m2Lbq9yb8c2fO9I8ClvPeXLPZ9LFkFwCMLx5jAEKnXKloqirp EOCjx449/+KLMlr2iASysLDgOI68SwC7IAN7LNP0fUXxpYsXW60WRwEDgFQ8wwCE TqVabbfb+XxeRuOPnDhx4vHHZbTsET2v1Wry2gd2x0Joj78loD3zV67UNzclHQXM DDAAeML+AAMQQtUjR+SdNfL8Sy8dvftuSY2L7LG0tGRZlqT2gb1gEljQVNX2+ydx bXVV/JJ0FPAUhaABYCDsDzAAIVQul6PShpjvfvhhKpWS1Liqquvr65IaB/aODNxR FN8L0bWazcWFBXlvzxGAAWCKAAwghArFoqRFhp1O59v/+T9ltOxZXl42/F51CRxA yBdCyygBPXX1KGB5GzQ4CQkApgjAAEJI3iHArut+/vXXMloWdF1fWVmR1DiwXz3X nZY2VzniHMdR220ZLfePAtY0SSX6CMAAMEUABhBC2Ww2ncnIaHk2mXz/o49ktCys rq5yjCdGSmgXQssoAe3hKGAAkC2Mzy0AYZYvFMTgNZvLyWi8VC7/6c03ZbRsmubS 0pKMloED67lufxl0+DKwjBLQnnNnz6rtdkrSUcCchAQABGAAYVMoFAzDkLTC8Ng9 9zz3/PMyWt7Y2Oh0OjJaBg7DdV15RZtGlowS0J6ff/qp2WxK2qPBDDAATBGAAYRN pVoV43VJc1aPP/XUr48f971Z27YXFhZ8bxY4vHBWw5JRAtqzuLCwWavF43EZjYv/ WIqisA0YQMiF64kFAOVKJRqNSmr8tddfr1arvje7ubkphq2+Nwv4ImzVsCSVgPbU NjZWlpfl3aOogwUABGAA4VIsFuNyzkASw+JPPv88Eon426zjOAsLC948GzCaQlUN y7FtVdp+BMuyzp89K2+VCkcBA0BYHlcA4JF3BpJpml//53/63myz2Ww0Gr43C/go VAHYNAxd5k7aH777rtvtchISAEgSlscVAHiyuVxaToXVaDT68Wef+dumyBULCwuO 4/jbLOC78GRgeSWgPT/+8IOmqpIq1VMHCwBC8awCgG3pTEbSGZv5QuHNt9/2t812 u12r1fxtE5AhPNWw1E7HsW157Z87c6bTbks6q7zZbEqdvgaA0Tf5DyoA2Cb1DKSj x449/+KLPjYoEsXS0pIl57QVwHchORKp3WpJ3ZN/6eLFVqvFSUgAIAkBGECISD0D 6dHHHhO/fGxQ07S1tTUfGwSkCsMksAj5Hckl2Rfm5+u1mrxafZyEBCDkJvkpBQDX EAHY9yrN21569dU77rzTxwZXVlZ0XfexQUC2iZ8Etiyrq6pSL7Gxvr66ssJJSAAg CQEYQIgUS6V4PC6j5V6v99Gnn/rYuGEYy8vLfrUGDMfETwIbum5IflvKNM0L585x EhIASDKxjygAuF6+UJidnZXRsq7rf//2Wx8b3NjY6Eg7axSQZ7IngTVVteVvyz/5 73+LWwonIQGADARgACGSy+VScs5AEiP+Tz7/3K/WbNteWFjwqzVgyCb4SKSOooiE L/sqp06e1DQtx0lIACDBZD6fAOCG5J2BJIaqf373Xb9aq9frrVbLr9aAIZvUSWAR 7NtD+cE8e/q02ulwEhIAyEAABhAW+ULBNE1Jkyp33HXXS6+84ktTIjwsLCwMYZYJ kGciJ4Ft29aGsjHhpwsXFEWRdRISS6ABhNukPZwA4GbKlcrMgIzGjz/yyGNPPulL U2Lgu7m56UtTQFAmchLYNIzhzJ3OX7lS39xMyDkJSfyn0VSVEgMAQosADCAspJ6B 9PyLLx49duzw7fR6vaWlJUt+lR1AtsmbBO5qmmWaQ7jQ2urq+upqNBaT1D6TwADC bKKeTACwC3lnIAnvffSRL+sVNU1bW1s7fDtA4CZvEng4FbCmBicVLczPy3v1CMAA wowADCAs5J2BpKrqP/71L1+aWl1dlVegdXp62jumFRiOSZoEHloFrKnBZuNzZ860 2+18Pi+jfQIwgDCbkMcSANxSNpdLyzkDSfjsyy8P34hlWYuLi4dv54ZIvxi+SZoE dmxbHeK+2f5JSKoq6yhgTkICEGIEYABhIe8MpEwm88777x++nVqt1m63D9/ODRGA EYiJmQQeWgUsz5kffxQBmJOQAMB3k/BMAoBbKhQKhmFImk65/c47X3711UM24rru /Py8pIxK+kVQJmYSeGgVsDw/nT/fUpRUKiWjcWaAAYQZARhAKFSqVTEKlzQT9etH Hnn80GcgtVqter3uS3+A0eG98zIBk8Cddtt1nKFdTupJSOI/iqIobAMGEE5j/0AC gL0oVyrRaFRS4y+8/PJdR48epgUxHl1cXLRt268uAaNjAiaBh1kBy7O2ttY/CUna XYs6WABCiwAMIBQKxaK8uZQPP/nkkI1z+hEm2ARMAtu2rQ2xApZgmuaFc+fkrVsh AAMIrTF+GgHA3s3l876c03s9Q9e/+fbbQzaysrKi67ov/QFGkOs4M5FI0L04OEMY +qbZk999p3e7sgpBE4ABhBUBGEAoZLNZSfVUo7HYx59+epgWTNNcWlryqz/ACBr3 SWBNVW3LGvJFf/zhB03TJNWupw4WgNAa10cRAOxdvlAwpZWALhQKb7z99mFa2Nzc VBTFr/4Ao8lxnMjYTgK3FaXnukO+6LkzZzqdjqTTy5uNBqtOAIQTARjA5KtUq+12 O5/Py2j82D33PPf88wf+dqmnHwGjY3wPBBY/pJ0g3qL6+aefms2mpL0bHAUMILTG 8lEEAPtSPXJEXhHaJ5566uHjxw/87YqibG5u+tgfYGSNaQa2LKurqsO/7tLiYm1j Ix6PS2qfbcAAwmn8nkMAsF+lcjkWi0lq/E9vvVUqlQ72vSIPLC0tWUPfWwgEYkwD sN7tmoYx/OvWa7Xl5WV568YJwADCafyeQwCwX/lCYXZ2VkbLruv+7auvDjym73a7 q6ur/nYJGGXjmIHVTscJ4oxu27bPnj49MyCjfQIwgHAas4cQABxAbm4ulUrJaNlx 3S++/vrA3762tqYxAEWYuK4rbz+CDCKxtxVlKqBd+j98/323283lcjIaJwADCCcC MIDJl85kJB0lkkyl3vvww4N9r23bCwsL/vYHGHFjdx6S4zhqux3U1c+cOtVRVUm3 L+pgAQinsXkCAcDB9M9AMk1JUyjVI0de+9OfDva99Xq91Wr52x9g9I3XJLBpGAGm xAvnzrUVJSXnJCRmgAGEEwEYwISrVKtitC1pxumBhx76zdNPH+AbRQZYWFhwh36y KBC48ZoE7qpqgGXqLv/8c6PRkFTCQPyHUBSFDAwgbMbj8QMAB1auVKLRqKTGn33+ +V/dc88BvrHdbtdqNd/7A4wFx3HkFTf2V1tResG9UbW6srK+tiaviD2TwABCiAAM YMIVi8V4IiGp8Xc//PBg5bWWl5eNIA5WAUbBuNSCdl23oygBdqDVbC4uLMhbMa60 WtThAxA2Y/D4AYDDmMvnk8mkjJa7mvYf/+N/HOAbRfQVAdj3/gBjZCwysGWawU6Q 2rZ97syZTqczNzcno31mgAGE0Kg/ewDgkLLZbDqTkdHyzMzMJ59/foBv3NjYECNa 3/sDjJGxKIWld7tm0Cs1Tp08qWmarJOQms0uhaABhAwBGMAkk1oCem5u7q2//GW/ 3+U4zsLCQi+gY0WBETEWpbA67bbrOMH24ezp02qnI+ldPGaAAYTQSD94AOCQypXK zICMxo8eO/b8iy/u97uazWaj0ZDRH2C8iGw5M8KlsEREb4/AQWWXLl4UMVXSPg7X dTVVZUEKgFAhAAOYZJVqVV6x2Seeeurh48f39S1iSL24uGjbtqQuAWNkxLcB25Yl wmHQvZhaXFjYrNXi8bik9pkEBhA2o/vgAYDDk1oC+o0//7lQLO7rWzRNW1tbk9Qf YOyMcgYehQ3AQn1zc3lpSd4beRSCBhA2I/rUAQBfyCsB3VaUb//X/9rv2H11dZWS M8C2US6FpbbbTtAbgKcGhaDPnj7dabfzhYKM9pkBBhA2BGAAk0xeCWjhsy+/3NfX W5a1uLgoqTPAmBrNSeAR2QDs+eHkya6q5iSdhEQhaAAhM3KPHADwS75QEJlTZGAZ jWdzubfffXdf31Kv11sjM6QGRsRoTgKPyAZgz9kff1RVVdJ7eSyBBhA2BGAAE0tq Ceg7jx598eWX9/71vV5vfn5ejPVldAYYX6M5AzwiG4A9P124oCgKhaABwBcj98gB AL9ILQF94oknHnn00b1/vRhfbmxsSOoMMNZGMAOPyAZgz+LCQm1jIyGtnh/bgAGE ymg9bwDAR8VSSd7ZIX98441ypbL3r19eXjZGZkIJGCmjtgp6pDYAC5u12srysry3 8wjAAEKFAAxgYskrAS3G63/76qu9z1mJ6CsCsIyeAJNhpCaBLcvqjswG4KmrhaDl beggAAMIlVF52ACA7+SVgBYB+POvv97719dqtXa7LaMnwGQYqUngkdoA7Pnh+++7 3W4ul5PROIWgAYQKARjAZMoXCmIIK+ngkEwm88777+/xi8XIfn5+vtfryegJMBlG aga4oyijVq/uzI8/atIKQTcbDV3XZbQMACNoVB42AOCvSrXabrfz+byMxu+4886X Xn11j1+sKMrm5qaMbgCTZEQysIi+IgAH3YtrSS0E3Ww2dWaAAYRG8E8aAJBBagno Rx577MRjj+3xixcXFy3LktQTYGKMyCpo0zT10dsQuzA/v1mrUQgaAA6PAAxgMkkt Af3qH/945Lbb9vKVuq6vrKxI6gYwSbxtAoFPAndVdQTfsaptbKwsL0ejUUntK62W RgAGEA4EYACTSV4JaDFM/+Tzz/c4vby+vq6OUjlZYJS5jjMjbeHGXoif7o6ijOCO fZHJz589OzMzI+kNAmaAAYQHARjAZJJXAtpx3S/2VgLacZz5+XkZfQAmUuDbgMXP rDqqBdspBA0AviAAA5hA+ULBMs2snJFiKp1+94MP9vKVzWaz0WjI6AMwqYLNwIau G6NaD/nMqVOqpmXkvK/HEmgA4UEABjCBKpXKTCQiaRh92x13vPLaa7f8MjGOX1xc tG1bRh+ASRVsKSy103FG9Wf24vnziqKkUikZjYv7lWicVdAAwoAADGAClSsVedVi fv3oo48/8cQtv0zTtLW1NUl9ACZVgKWwxKXbrdbwr7tH81eu1Dc3KQQNAIdEAAYw gQrForxh4it//ONteygBvbq6yp464AAcx5F3htkuLNMc5QQouxA0ARhASBCAAUyg XC6XSqdltLzHEtCWZS0uLsroADDxgloFLeKfyMDDv+4eibvKuTNnItI2d1AHC0BI EIABTKB0JpPNZqU03et99tVXt/yqer3eGuG1lMCIG34prJE9AGmnH77/Xtd1STe3 ZrOpE4ABhAABGMCkKRQKhmHk5uZkNJ7L5f787ru7f40YQ8/Pz7uuK6MDQBgM/0Dg UT4AadvZH39UVVXSAW/MAAMICQIwgElTrlTkrRI8euzY8y++uPvXdDqdjY0NGVcH QmL4M8CjfADStksXL7ZarWQyKaPxfiHoVosMDGDiEYABTJpiqRSPxyU1/tRvf/vg ww/v/jUrKyv6yI+kgRE35AysttuO4wztcgeztLhY29iQd3+jDhaAMCAAA5g0c/m8 pBkS4e333tt9A55pmktLS5KuDoTHMEth9Vy3rSjDudZhNBsNkYHlvSwEYABhQAAG MGlEQJW0R67b7f7HP/+5+9dsbm4q4zCSBkbcMGeATdPUxyH42bZ97swZtdORVOOA bcAAwoAADGCi5AsFU1oFrGg0+vFnn+3yBa7rLiwsUP4K8MXQMrCmqrZlDeFCh/fj Dz+I3mZzORmNNxsNtm8AmHgEYAATpVypdNptEYOlNF4u//HNN3f5gna7XavVZFwa CKHhrIIWMbs9PoeWnT97VtziJJ1zTgAGEAYEYAATpVKtRqSdnvLAQw/95umnd/mC paUl0zQlXR0IG+9UXtmTwJZldVVV6iV8dPnnnxuNxuzsrKT22QYMYOIRgAFMlGKx GE8kJDX+/EsvHb377pv9W8MwlpeXJV0aCCfHceS9peURec8an/et/n/27sS7jTO9 8z2JhQSxAwQoy5JlWbZsy5JlW5ZsyfLWdiwnnWQ6k3QyPVlOcubeOTP/30yS7pub mTM55870alsbRS2WbUkUKZIigVqwVqHuC5QIsSmKAkk8qCrg+zk0BZLyU68ksvD+ 8G4PlIWFaDQqVF8rlysEYABDjQAMYKikM5l4PC5R2XGcn/7sZ9v0O5eXlw3DkLg0 MLKkZ0Grn2tD09yh5kBoNpvXr11TfydCA+OMAAMYegRgAEMlkUxuf0zRrlm2/bd/ //dP+6pt23fv3g1QNxoIBOlZ0JZlVYL2utXFb76pVatpoX2wSqUaG0EDGGoEYADD I5fL1RsNoX5hIpH403//75/21XK5vLq6KnFdYMS1bDskNgtahb1GvS5UXMjs5ctm pZKUOeyNEWAAQ48ADGB4FGdm5GYGHjh48KNPP33aV+/du9cMyDEqQLDIHYbUnv+s 607Qzi27deOGpmlTU1MSxdXfiaYyMIPAAIYXARjA8JguFOT2hnnz7bePnzix5ZdU Z3FxcVHougCEMrBtWWbQ5j8r9+7eXVlenhTb7Y9BYADDjQAMYHhkslmhURHlyx// OJfPb/mlpaUlMzjHqACBIzQLOojzn5XVhw/vz8/LbY5NAAYw3AjAAIZHKpVKyKyL Mwzj//6v/3XLL9m2fefOHYmLAnAJjQAbmtYK2vznsc7GXXOzs7quZ7NZifrlUokp 0ACGGAEYwJDI5nINsR2wQqHQX/31X2/5pVKptLa2JnFRAF19z8C2bZu63seCg3T5 4sVKpSJ0u2MEGMBwIwADGBKiO2Dl8/kLP/7xk59XnfJ79+5ZliVxUQBdfT8QOKDz n11zs7OGYSQSCYni7X2wNI0MDGBYEYABDAnRHbBeefXV0++99+TnK5XKgwcPhC4K oKvvI8ABnf/s+v727bW1tVgsJlSfQWAAQ4wADGBIZHM5ue7gR59+euDgwSc/r9Jv hW4iMBB9zMCBnv+sLKlbz+JiJBIRqk8ABjDECMAAhoTcDliq2/1Xf/3XT+65alnW 3bt3Ja4I4El9nAUd6PnPSrPZvD47GwqHhRZ9sA8WgCFGAAYwDLK5nOoRqgwsUt1x fvZ3f/fkp9fW1kqlksgVATyhjyPAgZ7/7Lp08aKK8UI3Pa1cZm4LgGFFAAYwDArF YqhDongmk/mjP/3TTZ9UffG7d+/ati1xRQBb6ksGti3LNIy+tMdDc1evtvfBkpn2 0mq1dF1nFjSAoUQABjAMVACWWw730ssvv3/u3KZPmqa5tLQkdEUAW+rLLOigz392 ffftt6VSiX2wAGCnCMAAhoHoDlhnz58//NJLmz65uLjIGjlgwPY+AqwqGJqm3ver SV5ZXFhYevBAbut7AjCAYUUABjAM0ul0XOxIzL/4D/9hYmJi4yebzea9e/ckLgdg e3vMwFazWTHNPrbHK41G48bcnNzh5+yDBWBYEYABBF42l1N9QZWBJYrbtv03f//3 mz65urpaLpclLgdge3ucBV2tVJqNRh/b46FL33yjMqrQra+0tlar1SQqA4C3CMAA Aq9QLBqGkc1mJYonU6k/+clPNn7GcZw7d+4EfQtZIKDc2cu7G/ZU/6+uaWPBn//s unblimmaQvtglUqlGiPAAIYRARhA4BVnZp48pLdfDh0+/MGHH278jArby8vLQpcD 8Ey2be/uR77ZaAzTutZvb94sl8tTU1NC9VkGDGAoEYABBF4un5+cnBQqfvr99185 enTjZxYWFpgZCHho17OgK6ZpNZt9b49X7s/PLy8tbdqhoI8IwACGEgEYQOCJ7oD1 Zz/96cYBFra/Ajy3u1nQKjYbmibTIm/U6/Ubc3PhcJh9sACgdwRgAIGXSCRSMtvA NBuNv/tP/2njZx4+fKgNVx8aCKJdzIJu1OvDt6j10tdft/fBymQkirMPFoChRAAG EGyiO2DF4/F/9+d/3v2w1WrdvXuX7a8Az+1iFrSh6y3bFmqPV2YvXzZNM5lKSRRn HywAQ4kADCDYVACORCJCxQ+88MJHn3zS/VDX9ZWVFaFrAejdTmdB27Zt6rpki7xx 68YNTdPYBwsAekcABhBsuVxuMhYTKv72qVOvv/FG98P79+/X63WhawHYkR3Ngq5V q41h/OGdv3dvZXlZbh8srVyuEIABDBcCMIBgS6XTCZkdsJQ//slPUutzCxuNxvz8 vNCFAOxU77OgHccxNM0ZluN/NyqtrakMvLs9sXvBPlgAhg8BGECAZXM5q9kUWv9W q1b/4T//5+6HKysr+jBOoQQCqvdZ0OouUTFN+RZ5wLKsa1evqj+d0D5YjAADGD4E YAABViwWQ2JHgMRisT/76U/dx61W686dO0M5ggQEV4+zoIfs+N9Nrl66ZFYqKZnX AdVNT2VgBoEBDBMCMIAAmy4UotGoUPHnDx78+NNP3ceapj18+FDoQgB2p5dZ0MN3 /O8m7IMFADtCAAYQYNlcLia2A9ap06dfff119/H8/Hyj0RC6EIDdcRznmRNA6rVa fagPs5XeB4sADGDIEIABBFgqlUokkxKVVcf6J3/xF/F4XD2u1+v379+XuAqAPXpm BjY0bbjP7lbx/sb162GxxSDsgwVgyBCAAQRVNpdrNBrpdFqieNOy/u4f/sF9vLy8 bBiGxFUA7NH2s6Aty6qMwA/vxa+/rtVqQjdDRoABDBkCMICgKhSLcoMeyVTqT37y kzG2vwL8bfsRYJXcmiOweOHalSumacpNh9E0jQwMYGgQgAEEVX56Wm7Z24svvXTu /Pkxtr8CfO9pGVh9Xi+XB9+ewbt961apVGIfLADoBQEYQFBlslm5Dt/Z8+cPv/SS enDv3r3m8B6gAgyBp82CbtTrtdFYvLq4sLD04IHclvgEYADDhAAMIKiSitjRlz/9 2c9Ub7JWqy0sLEhcAkC/PG0E2NR127YH357Bazab169dC4VC7IMFAM9EAAYQSIVi sWKa6UxGqP7P/vZv1fulpSXTNIUuAaBfnszAtmWZI7D9Vdelixdr1WpK5jVBAjCA YUIABhBIxZmZcDgsVDyXy335x39s2/bdu3fZ/grwvydnQY/I9lddc7OzhmEkEgmh +syCBjA0CMAAAimXz09OTgoVP/raa++eOaM6fKurq0KXANBHm0aAR2f7q67vb99e W1uLxWJC9QnAAIYGARhAIKUzmXg8LlT8088/3/fcc/fu3bMsS+gSAPprYwYene2v ulaWlhYWFiKRiFB9AjCAoUEABhBIifYGWCKr3QzD+L/+y3+p1WqLi4sS9QFI2DgL 2tA09aG37Rkwy7KuXb2qbl/ZbFaifqlUGrXXFAAMKwIwgOApFIuGrmdzOYni4XD4 L//jf2T7KyBYuiPAKgpWRmn7q64rly5VTDOVTksUL62t1Wo1icoAMGAEYADBowKw 3Ey/mZmZjz/77O7du0L1AQhxM7AKgdZInt19Y25O17Q4+2ABwLYIwACCJ5vLye31 cvzkyRcOHVpbWxOqD0BIy7bHxscNTfO6Id64e+fOw5UVud0BCcAAhgMBGEDwpFKp RDIpVPzLH//YME22vwICx3GcRr1eH9WZumurq/P37smdD8dpwACGAwEYQMAUZ2ZM w0hnMhLFa9XqX/3N3zx48ECiOABRKgAbmjayZ3dbljU3Oyt3eyQAAxgOBGAAATMz MxMSG+KIxWLnPvqowjQ/IICajcaIz9G9eumSWakI7ZA/RgYGMBQIwAACJpfPyy1y 23/gwKHDh4WKAxBl6rpt2163wku3btzQNG1qakqoPsuAAQwBAjCAgEmn03LbnB47 cUJo9iAAUbZlmSN5+tFGC/PzS0tLExMTQvUZAQYwBAjAAIIkm8tZzWZSZoKf4zjv nz/vHiUKIFhG9vSjjRqNxo25uVAoJHQf08plVogACDr6eQCCpFgshsJhob6dCsBn P/xQojIAUa1Wa2RPP9rk8sWLtWpV7lVCTdOYBQ0g0AjAAIJkulCIRqNCxRPJ5Im3 3hIqDkCOinyNet3rVvjC3LVrpq7LrRNhGTCAoCMAAwiSTDYrt7/Lvv37Dx85IlQc gJARP/1okzs//LD68KHcToEEYABBRwAGECSJZFLuhI8Tb72l6gsVByCkUa/X2Jlp 3drq6vy9e2Gxs+JKpRJ/2wACjQAMIDCKMzOmYQjt0lytVD794guJygDkOI5j6nqr 1fK6IX5hWda1q1crpil0q2QjaABBRwAGEBgqAMsNa6jKp8+eFSoOQEiz2ayaptet 8JfZK1dM00yKzWdhFjSAQCMAAwiMXC43GYtJFc/nXz12TKg4ACGmrtu27XUr/OX2 rVulUkluuwQOQwIQaARgAIGRSqXk1ui+/OqrhWJRqDgACbZlmYbhdSt854GysCC3 YT6zoAEEGgEYQDBkc7lGo5FOpyWKt1qt98+fD4VCEsUBCKmYptVset0K32k2m3Oz s6EOifpMgQYQaARgAMFQKBbD4fD4uMhdSwXgcx99JFEZgBD1Y2tomtet8Kkrly6p jJqU2TPfcRxN08jAAAKKAAwgGPLT0xMTE0LFE8nkibfeEioOQEKtUmk0Gl63wqdu XL+ua1o8HheqzzJgAMFFAAYQDOl0Op5ICBU/cOjQwRdeECoOoO8Y/t3evbt3H66s yL1oyDJgAMFFAAYQANlczmo25abzvXPmzOTkpERxABJq1WqjXve6Ff5Vr9VuXL8u t2yEEWAAwUUABhAAxWIxJNaTq9frH3/2mURlABIcx9E1Tf3idUN87dI331SrVaGN A1kGDCC4CMAAAkB0AbCq/M6ZM0LFAfRdvVZTb163wu/mrl41DEPu6Dj2ggYQUARg AAGQyWanpqaEihdmZl4+elSoOID+chzH0DSH4d9n+f727bW1tVgsJlSfAAwgoAjA AAIgkUymZBYAK68fP64CtlBxAP3VqNdrbL/Ug5Xl5YX79yORiFD9UqnEPwSAICIA A/C7QrFo6Ho2l5MobhrGZ19+KVEZQN85jmPqeqvV8rohAWBZ1tzsrLrFpTMZifql tTX1D8FJVAAChwAMwO+mC4VoNCpUfDwUeu/cOaHiAPqr2Wgw7bZ3s5cvG6YpN32G WdAAgogADMDvRBcAZ/P5144dEyoOoI8Y/t2p27dulUolufsnARhAEBGAAfid6ALg l199tVAsChUH0EcM/+7UA2VhQW4GDcuAAQQRARiAr7UXABtGVmaTKk3T/uAP/1Do eGEAfdQe/jWMlm173ZAgsSzrWucwJKFbKAEYQBDR7QPga4VCISI2fKG61Gc//FCo OIA+ajabVdP0uhXBc+Xy5YrkMmCtXK4wLA8gUAjAAHxNdAFwKpN548QJoeIA+sjU dZvh3527deOGpmksAwaALgIwAF8TXQB8+MiRffv3CxUH0C9Ws1lh+HdXFu7fX15a YhkwAHQRgAH4l+gCYMdxzpw7Fw6HJYoD6COGf3et2WzOzc6qG53QZgcEYACBQwAG 4F+iJwCr/vQHH38sVBxAvzD8u0eXL12qVSpJTgMGgA4CMAD/El0AnEilTpw8KVQc QL8w/LtHN69f1zQtHo8L1ScAAwgWAjAA/xJdAHzo8OH9Bw4IFQfQFwz/7t39+fnl paWJiQmh+syCBhAsBGAAPiW9APj02bORSESiOIB+Yfh375qNxvVr10KSy4Bbtt1o NCSKA0DfEYAB+BQLgIERx9m//cIyYADoIgAD8CkWAAOjzHEc0zBaDP/2A8uAAaCL AAzAp5LJpNx4BQuAAZ9rNhpkqn6RXgaslcsV/rEABAQBGIAfFYrFUIdEcRYAAz7X Hv7V9Var5XVDhoT0MmD1L6XrOi9YAAgEAjAAP8pPT8sNVrAAGPA5hn/7jmXAAOAi AAPwo3QmI7dcjQXAgJ8x/CuBZcAA4CIAA/CdbC5nNZssAAZGU6Ne51zZvmMZMAC4 CMAAfKc4MxMKhYTWqjmOc+bcuXA4LFEcwB6pn1BD09R7rxsybJrN5tzsbFhsGbD6 J1MZuMorFwB8jwAMwHdEFwC3Wq1zH30kVBzAHtVrNfXmdSuG05VLl6osAwYw8gjA AHwnnU7HEwmh4qlM5o0TJ4SKA9gLp7OZ8BjDvzJu3bihaZrc+erlUokRYAD+RwAG 4C/ZXK7ZaKTSaaH6L73yysy+fULFAexFrVpt1Otet2JoLS4sLD14EI1GheqzDBhA IBCAAfhLoViUW6WmadrnX34pdLwwgL1otVqGpnndimHmLgM2DCObzUrUby8D1jRm QQPwOQIwAH/J5fOTk5NS1cfH3//gA6niAPZABadmo+F1K4bc1cuXTdNMsQwYwAgj AAPwF9UzSySTQsWz+fxrx44JFQewa7Ztm7rudSuG3+1bt0qlEsuAAYwyAjAAHykW i6ZppjMZofpHX389Pz0tVBzArlVM02o2vW7F8FteWlpcWIhEIkL1CcAA/I8ADMBH CsWiXM/MNIwfXbggtLoYwK5ZllUxDK9bMRLUX/W1q1crkq8zMgsagM/REQTgI5ls Vm5uXjgcPn32rFBxALvjOI5Kv7Zte92QUTF75YppmkmxlSYEYAA+RwAG4COJZFJu d5bpYvGVV18VKg5gd5qNBnlpkL6/fXttbS0WiwnVL5VKNWZBA/AxAjAAvygUi3Ln cyhvnDwpl64B7ILjOIauO62W1w0ZIasPH96fnw+Hw0L1VQBu2XaDDb0B+BUBGIBf TBcK0WhUqHi1Vvv088+FigPYnbrCaOFgWZY1Nzvb3m4wnRa6BLOgAfgZARiAX6Qz mXg8LlR8YnLyndOnhYoD2AWn1WoP/zqO1w0ZOSoAG4aRSCSE6hOAAfgZARiAL2Rz uWazKTdFef+BA4cOHxYqDmAXatVqo173uhWj6O6dO6srKxOTk0L1tXK5QgAG4FcE YAC+UCgWw+Gw0BlFjuOcOnNGrrcHYKds2zZ13etWjKh6vX5jbk70lqtpGoPAAPyJ AAzAF3L5/KRYQLUs6/wnnwgVB7ALFcNQP5het2J0Xb54sVatJsUm3TALGoBvEYAB +EIqlUqInUupKp946y2h4gB2ymo2K6bpdStG2o3r13VNk9t2oVwqVdneDIAvEYAB eK9QLKrecDqTEar/4pEjz+3fL1QcwI44jmPqeoujjzy1MD+/vLwst/E+ARiAbxGA AXhP9AAk1c9+/4MPQmKHXgLYkUa9XiMaea3ZbM7NzoY6hC7BLGgA/kQABuC9TDY7 NTUlVNwZGzt7/rxQcQA7wtFH/nH18uVKpZIUW3tCAAbgTwRgAB7L5nJWsym3F0su n3/12DGh4gB2hKOP/OP2rVulUknuxUcOQwLgTwRgAB4TPQBJOXbihNzqYgC94+gj X3m4srJw/35YbHkIhyEB8CcCMACPiR6ApPpen37xhVBxADtiGobN0Ue+YVnW3Oys +keRe4mQWdAAfIgADMBjogcgqWj99unTQsUB9K7ZaJCF/EYFYMMwEomEUH32ggbg QwRgAF6SPgDp+YMHX3jxRaHiAHrkOI6haex95Tf37t5dWV6Wm4NDAAbgQwRgAF5S ATgSiQgVV73td99/X+6AJQA9Yu8rf2o0Gjfm5kKhkNwuDMyCBuA3BGAAXhI9AKnV ap376COh4gB61LJtg72v/OrKpUsqoMrtw08ABuA3BGAAXlK9LrlTKNPZ7LHjx4WK A+hRxTStZtPrVmBr3968qTKq4GFImqa+AYSKA8AuEIABeEb6AKSjr7+en54WKg6g Fyr6kn/8bPnBg8XFRdGlKFq5zEpgAP5BAAbgGZVOJyYmhIqbpvnZhQtCxQH0QoUf U9dbrZbXDcFTtQ9DunrVlNyMkFnQAHyFAAzAM+l0Oi52/EY0Gj313ntCxQH0ol6r qTevW4FnuKYCsGHIHUfHXtAAfIUADMAbhZmZ9gFI6bRQ/X379x8+ckSoOIBnYu+r oLjzww+rDx8KHobECDAAPyEAA/CG9AFI75w5I9efA/BMpmHYluV1K/BstVrt5vXr ojsykIEB+AcBGIA3RA9Asizr/CefCBUH8EzNRoPAEyCXL16sVaschgRgFBCAAXgj qYh1tlTl4ydPChUHsD3HcQxNU++9bgh6dfP6dU3T4vG4UH2tXK4QgAH4AwEYgAek D0B66ZVXZvbtEyoOYHu1arVRr3vdCuzA4sLC0oMH0WhUqH77MCRNYxAYgB8QgAF4 IJfPyy3Q1XX98y+/lEvXALZhW5ZpGF63AjtjWda1q1cNw8hms0KXYBY0AJ+ggwjA A6lUSu7IjXA4fPrsWaHiALbRPvjXMFq27XVDsGOzly+blUqSw5AADDsCMIBBKxSL pmlmMhmp+jMzLx89KlQcwDYa9XqNkBNM39++vba2FovFhOoTgAH4BAEYwKBNFwqi K81OvvNOPJEQqg/gaVqtlqFpXrcCu1StVG7dvMlhSACGHgEYwKClMxm5vUabzeaH n34qVBzANiqGYXHwb5Bd6hyGlOIwJABDjQAMYKCyuZzKqHIdLA5AAjzBwb9DgMOQ AIwCAjCAgZI+AOnI0aPFmRmh4gC2xMG/w+HB4qJ64zAkAMONAAxgoLK5nNwmK6Zh /OjCBQ5AAgZMRZpmo+F1K7BX7mFIFdNMi21SyCxoAJ6jmwhgoJKplNwxG9Fo9NR7 7wkVB7AllZoqHPw7LFQANg1D7pg6TdNUwBYqDgC9IAADGJxCsRjqEKq//8CBQ4cP CxUH8KT2wb+63mq1vG4I+uPunTurKysTk5NC9dW3iq7rDAID8BABGMDg5KenJyYm hIqrjvi7770XFasP4Em1arVRr3vdCvSN+te8cf16KBSSW0vCVlgAvEUABjA4qXQ6 IXZCb8txzn34oVBxAE+ybdvUda9bgT67culStVqVW6tSLpVUfaHiAPBMBGAAA1Io FkX3Vsnm868dOyZUHMAm7cnPhtGyba8bgj67fetWqVSampoSqk8ABuAtAjCAAVEB OBKJyNU/duKEXLoGsEm9VlNvXrcC/fdwZWXh/v1wOCx3CfaCBuAhAjCAAclks3JD CrVa7ZPPPxcqDmATJj8PMcuy5mZnTdNMp9NClyAAA/AQARjAIGRzOavZTKZSQvVV tD556pRQcQAbOY5TMQybyc/D6/q1a4aux8W2bGAfLAAeIgADGIRCsRgOh+W2FT30 0kv7n39eqDiAjRr1eo01nEPt/vz88tKS6Kb9mqYxCAzAEwRgAIOQzeVisZhQcV3X P7twQe54YQBdLds2mPw87JrN5tzsrGEY2WxW6BLMggbgFQIwgEFIplJyh2qEwuEz Z88KFQfQ1Z78bJq2ZXndEIibvXzZrFTk7tuapqnvJaHiALANAjAAcYViMdQhVL+4 b9+RV14RKg6gi8nPo+OH775bXV2Vm7nTarV0TeM8JACDRwAGIC6fz09MTgoVdxzn 7XffjYntLw3AxeTnkVKrVm/euCG6dwNbYQHwBAEYgLhUKpUQm0dnWdb5Tz4RKg7A xeTnEXT54kUVg+V27y+XSowAAxg8AjAAWYVi0TTNTCYjVD+VTr/x5ptCxQG4mPw8 gm7duKFpmtz57QRgAJ4gAAOQNV0oRKNRufpHX389Pz0tVx8Ak59H0/KDB4uLi5FI RO4S7AUNYPAIwABkpTOZeDwuVLxSqfzoiy+EigMYY/LzCLMs69rVq+pfPy02hYcA DGDwCMAABBVmZtqdp3RaqH4sFnvr3XeFigMYY/LzaLt+7Zqu64lEQqg+ARjA4BGA AQgqFIui0+deOHz4+QMH5OoDI47JzyPu/vz88tLSxMSE3CXIwAAGjAAMQFAmm5Xb QEXX9c8uXJA7XhgYce3Jz4Zh27bXDYFnms3m3OysYRjZbFboEgRgAANGAAYgJZvL Wc2m3BEa4Ujk9PvvCxUHUK/V1JvXrYDHZq9cqZim3FF2nAYMYMAIwACkFIrFcDg8 Pi51n9m3f//hI0eEigMjzrZtk8nPGBu788MPqw8fTk5OCtV3HEfTNAaBAQwMARiA lGwuF4vFhIqrPtOp994TXZkGjCz186XSb6vV8roh8F69Xr8xNyf6aiazoAEMEgEY gJRkKpUUmzXXcpxzH34oVBwYcbVqtVGve90K+MWVS5eq1arc/VzTtIppChUHgE0I wABEFIrFUIdQ/dz09Kuvvy5UHBhllmVVDMPrVsBHbt+6VS6X5Wb0tFotXdOqnLYF YCAIwABE5PJ50TVjJ95+W244AhhZTH7GkyqmeevmzUgkwixoAEOAAAxARCqVkts1 tNlsfvjpp0LFgVGmQkiz0fC6FfCdS998U6vVUmK7+pdLJUaAAQwGARhA/xWKRdM0 M5mMUP1kKnX85Emh4sDIajabVZZiYis3r1/XNC0ejwvVJwADGBgCMID+y09Pi+7P /Mprr00XCnL1gRHUarVMXXccx+uGwI8ePHiwtLgYiUTkLsEsaACDQQAG0H/pdDqe SAgVr1QqP/riC6HiwMiqmKbVbHrdCviUZVnXrl5V3yRpsak9DAIDGAwCMIA+KxSL op2kyVjs7XffFSoOjKZGvV4je2Bbc7OzhmEkxF7cJAADGAwCMIA+my4UotGoXP0X Xnzx+YMH5eoDo6Zl24aue90K+N38vXsry8uiy1uYBQ1gAAjAAPosncnIbZSi6/pn Fy7IHS8MjBrHcSqGYdu21w2B3zWbTXcQOJvNCl2CAAxgAAjAAPqpPf+5Ukmn00L1 w+Hw6bNnhYoDI6heq6k3r1uBYJi9csU0Tbkz2AnAAAaAAAygn4ozMyqjytWfee65 l15+Wa4+MFIsy6oYhtetQGDc+f771dXVyclJuUuQgQFIIwAD6KdMNjs1NSVU3HGc U2fOTEj2vYDRoX6gDF13Wi2vG4LAqNfrN+bmwuHw+LhUB5IADEAaARhA32RzOavZ TKZSQvVbjnPuww+FigOjhnOPsAtXLl9WAVVuFrRWLlcIwAAkEYAB9E2hWBQdGcgX Ckdfe02oODBSGo1GjZiBnfvu229LpVIsFhOq7ziOpmkMAgOQQwAG0DfZXE60V3Ty 1Cm5/aWB0cG5R9g1FU1v3bzJLGgAwUUABtA3yVRKbl6cZVnnP/lEqDgwOhzHMQ2j xblH2K3LFy/WqlW51S6aplVMU6g4ABCAAfSH9PznTDb7+vHjQsWB0aGiS6Ne97oV CLBvb94sl8ui+x1q5XK1WhWqD2DEEYAB9Ecunxc9G+PYiRPpTEauPjAKrGaTsTXs 0cOVlYX790VPvGMWNAA5BGAA/ZFKpxOJhFDxer3+8WefCRUHRkSr1TJ13XEcrxuC YLMsa2521jTNdDotdAlmQQOQQwAG0AeFYjHUIVQ/kUqdOHlSqDgwIjj3CP1y8/p1 lVHldiVstVqqfo1Z0AAEEIAB9EE+n5+QnP/8ymuvTRcKcvWBodeo14kT6JelBw8e LC5GIhG5S3AgMAAhBGAAfZBKpRJi+z9XK5VPv/hCqDgwCmzbNjn3CP3zaBa0Ycht zVAuldgHC4AEAjCAvSoUi4ZhZLNZofqxqam3Tp0SKg4Mvfa5R7rearW8bgiGyvVr 1wxdj4tt/VAqlVq23Wg0hOoDGFkEYAB7lZ+enpiYkKt/+MiRffv3y9UHhlutUiFF oO8W7t9fXlqKRqNyl2AvaAASCMAA9kp0/2fTMH504YLc8cLAcGs2m1V204UAy7Ku Xb1aMU1mQQMIFvqUAPakUCyKdoCiExOnzpwRKg4MN849gqi5q1cNw5DbAIIADEAC ARjAnkwXCqJT4A4cOnTwhRfk6gPDSuXeimnaluV1QzC07t29+3BlRXQJDLOgAfQd ARjAnqTTablNUDRN++zChXA4LFQfGGK1arVRr3vdCgyzZrM5Nzsrugkig8AA+o4A DGD3ijMzosdgqOh7+uxZoeLAELOazQpLfyFv9soV0zSTzIIGEBwEYAC7Jz3/ed/+ /YePHJGrDwwllv5iYO788MPqw4eTk5Nyl2AWNID+IgAD2D3R+c+q+/7ue+9FJVeX AcOHpb8YpEa9fmNuLhQOy+3VzyAwgP4iAAPYpfb8Z9NUGViovjM2dvb8eaHiwLCq 12rqzetWYIRcvXy5UqkIzoJmBBhAXxGAAexSoViMRCKC9WdmXj56VK4+MHwsy6oY htetwGj5/vbttbW1WCwmdwkyMIA+IgAD2KV0JhOPx4WKO47zzunTk5I9KmDIOK2W wdJfDFytVrt5/XpYdBY0ARhA/xCAAezGzL59hmHIzX9utVrnPvpIqDgwfFTuVQnB aja9bghG0ZVLl9S3XzKVEqpPAAbQRwRgALshPf85Xygcfe01ufrAkGnU6zU2CoJH vvv221KpxCxoAIFAAAawG5lsdmpqSqi44zgnT52Sm18NDBnbskyW/sI7KpreunmT WdAAAoEADGDHCjMzqiOSEpvtZtv2Bx9/LFQcGDKO45i63mq1vG4IRtrlixdr1arc LGitXK4QgAH0AwEYwI5NFwqRSETulf5sPv/asWNCxYEhUzFNlv7Cc7dv3SqVSqIz gzRNYxAYwN4RgAHsmPT85xNvvSU3jAAME5b+wicqpnnr5k3R10aZBQ2gLwjAAHYm m8tZzaZcQFXFz3/6qVBxYJjYtm3qutetAB5hFjSAQCAAA9iZQrEoutNJOps9dvy4 UHFgaLD0F37z7c2b5XKZWdAAfI4ADGBnsrmc6FkXx06cSGcycvWB4VA1zSZLf+En D1dWFu7fD4fDcpdgFjSAvSMAA9gB6fnP9Xr9488+EyoODA2W/sKHLMuam501TTOd TgtdglnQAPaOAAxgB6TnPyfT6eNvvilUHBgOnPoL37p1/XpZ0+ROcWcWNIC9IwAD 2AHp+c+vHjuWy+fl6gNBx9Jf+Nny0tLiwkIkEpG7BLOgAewRARjADiRTqWQyKVS8 Wqt9+vnnQsWB4cCpv/CzQcyC1jT1UyBUHMAoIAAD6JX0/Od4IvHm228LFQeGAEt/ 4X835uZ0TVP3c6H6zIIGsEcEYAC9kp7//PKrr6qMLVcfCDSW/iIQHiwuqrdoNCp3 CWZBA9gLAjCAXonOf65UKj/64guh4kDQOa2WoeuO43jdEOAZLMu6dvVqxTTlDrRj FjSAvSAAA+iJ9Pzn2NTUW6dOCRUHAk3l3qppqlzhdUOAnly/ds3QddlZ0OVyleUA AHaFAAygJ9Lznw+//PK+556Tqw8EV71WU29etwLo1cL9+8tLS8yCBuBPBGAAPZGd /2yan37xhdzwMhBclmVVWPqLQFHftLNXrqiAyixoAD5EdxPAsxUKhXAkIhdQJ2Ox t999V6g4EFytVstk6S8C6PrsrG4YCWZBA/AfAjCAZxOf/3zkyL79++XqA0GkuvgV 07RZ+osAYhY0AN8iAAN4NtH5z6Zh/OjCBeY/A5uw9BfBxV7QAHyLHieAZ5De/3li cvKd06eFigMBZTWbdO4RaHOzswazoAH4DwEYwDPk8vnJyUm5+odeemn/88/L1QcC h6W/GAL35+eXl5YmJibkLsEsaAC7QAAG8AypdFruJXzmPwObtJf+GoZt2143BNgT dxa0aZoZZkED8BM6nQC2UygWQx1C9ScmJt45c0aoOBBEtWq1Ua973QqgD+auXm3P ghbbQqLVaum6ziAwgB0hAAPYjvT85xdefPH5gwfl6gPB0mw06M1jaMzfu7eyvMws aAC+QgAGsB3R+c+6YXz2xRdyw8tAsNi2beq6160A+qbZbLpbYWWzWaFLMAsawE4R gAE8lfT852g0euq994SKA8HiOI5Kv61Wy+uGAP3UXgYsPQta09gLGkDvCMAAnkp6 /vPBQ4cOvPCCXH0gQKqm2Ww2vW4F0GfMggbgNwRgAE+VTKWSYi/b67r+2YULzH8G lEa9XmMIC8NoALOgy6USI8AAekcABrC1QrEo2mWJRKPvMv8ZGBuzLcs0DK9bAUi5 duWKaZpys6BLpVKz0eDkMAA9IgAD2Jr0/OcDL7xw8NAhufpAIDitlmEYDkt/Mbzu 3b37cHl5QvIJhVnQAHpHAAawtVQqJfeCvaZpn124EA6HheoDgeA4TtU0LcvyuiGA IGZBA/AVAjCALUjPfw5HIqfff1+oOBAU9VpNvXndCkAcs6AB+AcBGMAW8tPTopt2 7j9w4NDhw3L1Af+zmk3OL8WIuHvnzsOVFdFlNbqus5YeQC8IwMAoisfj6r0zNhaN RCzLSmcyA27Au++/H4lEBnxRwD9arZap647jeN0QYBB0TVMZeHx80N3Ocqk01rmo e+EK64QBEICBoTc1NTXW6XSojnY4FLJtWz3IZDKD74hs9P758x5eHfCWyr0Vw2C6 JkaHaZp3vv/e2zaon7tyuax+aT/9rT8tqg9ZPAyMGgIwMGymOqO7SigUUs/3qVTK 26y7pTffeScajaoWum0b7/C6UcCA1KrVRr3udSsAQU6H+6DVahm6fn9+3ocHv6vm aZqmfhlbfw5iN2lg6NHjBAJPJV73lWyVIVVHI+316G4vQuHw1NTUxOSkisGRSCQc iaiOkXrfFg67nwmHw92EDAyNZqNBDxtDw823iq1Ylt150LKs9mdaLavzSfU9XzFN 9bg9I8nf2nm4XHafT90nVn5ageFDzxIIKpV7VVBUfY2kL8d4t1cqldxX3MfdfkYn 6IY6VO5VqXhSdZRisclYTIXkiY6IG5WfSMXuIEPg/gYwmlQcMHXd61YAz/bkrXVj 1rWaTfWmNNSbUq+rd+pD9/c46x4X6tzw5U4WEKLarmuau1KfJAwMDbqMQJC405tV /rNbLc/X8fbLk/sAlUsl9cluKnbHhKOTk/GO2NSUCsYqJKsw7HRWc6l4HJ2YGI6/ DQwx9e2q0q+KB143BHgG9b2q0qxlWY/Sa6tldbJuvfaIirtuGnY6X3Xfq5tw5omI Oxx3Znf9sLtiZ4wwDATcMNyVgKGn4p/KeKFwWMU/H66hEtWNx6rz4cbdsIrE7hxp 9VehEnK4rd33CoWm4nH1FzXZGTRuT652f5mYUL9/ODphCLT2LNBm0+tWAG3qdmrb tpty1bdle6KybTc64bbVibLqN6ivuFu1tXdP7AzsPhrd7dxvM+vHB4za3bW9pNkw 1N9go9FQf0VeNwfAjo3WPQsIHJXoVLpTT7GBmzkmyk3F7Ujc6Yel0+nuNlrdFVzt 2dTunOpOWlbibjyOxaKdYEw8xiDVFTabxQBtirhWR6PeHsS13Whr2+6U5u6sZXUf 7O4i4U5m1nV9Y9zlVrlRqVRyx4QZEAaChRsZ4FOZbFZ1WYK4vtfP2v05TWuPG29Y chzqxGMVjCc78djNxW3rI8mjNuqOvlNxo2IYXrcCw0bd0DrZtrMcV0Xazvv2gtzO KK7tRlz15q7H7YRc9X+l0mnuaX3UXSdMDAaCgo414DvpTEb1afx5fNFwezx63N2S yx1G7my+Fetk44n1VNyOx50BZEV91eu2w79UFDF1/cm17sD2Ho3frg/eumO5jfZc gnp3Myp3/LYdb92I2+nYBeIsgCHz6DglYjAQBNwfAR/JZLOqi0P09S3V3TRUkukm 5I05ORx2T3Vqh+L1B5HoOkaSR5XqFldM02ahIDZoZ9dOoG0P21q/p7OlcqO737Kz vqPyxnzLEK5vuTFY/RtViMGAj9HJBnwhHIlMTU0lEgmib6C5O4W6B36E3GXJ7oPQ Y9HuFOtOQm5vcE1UHl61arVRr3vdCgyCOyHZ2hBrHy217bxrnxG0nmy7E5LdZDu2 fmRQd7UtTwSB1p4Urev1ep1XvgB/4g4LeC+dyTQaDba5Gh1uTnZPDRlfz8nj65l5 fD0wq1/dPbpC4fBEJyi7gdkV6nnedTweTySTon8ibElFnqppet0KbK1aqdRqtR5/ sztm624cZa//2uzE3e6Zt91M2/7967F2bOxRvCXZjpr2FlnsjwX4EjdiwEvpdNpu tZLJJL0iPE13L1Z3YHl8fSPW8Z2MEj9O16ENk7bdLbI7xyy337uD0pHI5ORkKpOJ xWJif6aR0OpMmPe6Fb6jvvFanZN1+kjl0Fq12lxfK7tx3NXurJRtrdsYU52tDiHf TjfQdh6qH6aN+88DT3L3x+K0JMBvuGsDnsnmco16Pb1+lCLgK08G78fv13v93bHr 8U4gH99kfRw7tPFBOPz4g84xzu778c5+Y2H3N4QfmYrHVSb3+m9iN9Tfnqnr6i/Q 64bIUt36emeCd+tR0rQ3Ll5trc/3bXWHRjsDoY8GUTcscN1obH0y8OPh07FHUbX7 1TGCKIKj3BkKZlUw4B88WwDeSHdG2FjqCWyvO0bXPZJ041cfZ56twg/PcL3beiR0 Q9rcSIXYVCrVvX2RPIHttbeCNwyTBRGAP/CkBQxaJBpV0Zf9rgAAGBHuzljt6dDN ptdtAUYd/W9goLK5XLPRSHLQEQAAo4QlwYBP0AUHBifbOeaX9AsAwAgiAwN+QC8c GJBMNmuRfgEAGGFkYMBzdMSBQSD9AgCAMTIw4DX64oC4XC7XYN0vAADoIAMDHqI7 DshKpdMt2yb9AgCALjcD1+t127a9bgswWuiRA4IKxWKlUkmn0143BAAA+E65XK5W Kl63AhgtBGBAUCqVinPeLwAA2IrjOJrKwNWq1w0BRgj9ckBKNput1evqvdcNAQAA PlUqlZqNBhOhgYEhAAMi8tPTtWo1ncl43RAAAOBr5VJJBeBGo+F1Q4CRQAAGRCST yUQyyeRnAACwPSZCA4NE7xzov0w2W2fyMwAA6E17InSzaXMqEiCPAAz0WT6fr9Vq TH4GAAC9K6sMbFlWs+l1Q4AhRwAG+iyZSiUCsvOzbduqnSquO46zxZe3+qTTeRtz /4dWy3346DOOo6plstlA/NkBAD6knkpUDnQfj4dC6ukkFAo9erz+5LL+y/jYkx3Z Db+n5TjqaW5qakr9j24Rn2MiNDAY9FOBfvLz5OdSqRQJh2OxWDyZnJ6ePvraa/ue ey4cDu+umnqebrVaqm/hvnepLL28tLS2ulpeWzMrlUa9blmW+rz6rU5nW+z+/okA AAGlnpJCbjDtJFvVHw1Ho7HJSZVX1fPUVCKRTCbT6fRzzz/vJthdX0jlyTvff7+4 uLi6smKapnqOti1LZWN/PiWpvxar2R4G9rohwDAjAAP9lFDP2amUT4ZA1fNoNBpV fYjizMzrb7zx3P79A34J3A3JSrVSefDgwcrKytrDh4bepp7gt5wl7pO/OgDArm05 q0grlyPRaDgcnpiYUJlWPTeplKuk0ukDBw+qzwyseW4knr93b3lpqWKazWbTP3lY /dXpmlapVLxuCDDM6GsCfaOePicmJ72dZ1VaW4tNTRWKxTdOnHjx8OFdD/BKsyxr bXV1cWFhZXlZ9YpM06zVauqT7lhxhmwMAP62Zcotl8vjnenKkXBYxd3Jycl4PJ7O ZguFwktHjsQTicG385lU2rx969b33333cGWlXq+3bDuby3nYnlarZeg6GRiQQ4cS 6I/p6emqdwf/qj5HOp0+/uabx44fj0ajnrShXxqNxsrSUnu62uqq+0J4/VnZeIx4 DAD9tvX2EOspNxQOh1XQ7aTcqampVCYzXSi8/MorCV+m3B6ZhnH50qXvvv1WPbBU EvZoWLhcKrESGJBDlxHoj1QqFfdi7ysVDl8/fvydd9+dmJgY8KUHr16vrywvLz14 sKaycecFcvXHb89e6yxFVn/5qXR6fHx8078C2RgAnmZTynU/1Mrlsc5Abqgzlhud mHDHctU9drpYPHLkyFQ87k1zB8XQ9a9++9vvbt9uNhrJVGrAV2c3LEAU/UKgD3LT 07Vq9WmDk0Isy3rv7NlXXn01EJtbSrNtu1wqLS4urj18WHbnVFerjUbD3ezE6WxY rTpzqc4K7Y2RmHgMYLhtjLiP8q2mOZ0XDcc6u1CFw+F2yp2cnIrFEslkJpudmZl5 /uBBFXq9a7UvqAh6/dq1K5cu1Wq1ZDI5yEuXO8cCsxsWIIGeH9AH6nlRdRoGFqUM XX/n9Om333knHIkM5opBp/oua6urD1fajO7QcaNhdXaoVgm5e+aTO4y88TUFEjIA P9uUb7Vy2f2Me+9qb7Tcmausni+iExOxycl4IpHN5fLT04defDEWi3nW7uBQTxlf //a3N2/caNTrA1voxCAwIIeOHbBXgz76aHz8D3/8Y2+36BgyKgmXy+XV1dVyqaTe dE2r1etN9dZsts9wco2NPS0kk5AByOnm22647d5z1BdCjw4SaudbZWJiQuXbdFrF tEw2n39u/35Gcftl6cGDf/n5z1UiHdhQcKkzCGwzCAz0G/02YK/cZVGDSUHqQp99 8cUgj4vAWGdfLq1UWltb0zRNxWPDMCqVikrIjc78tI1jyORkAD3aJtk+osLtxvFb 95jczgG5qUzmxcOHfXJyz+gol8v/7y9+oZ4OBrMEWn1LlEulWq02gGsBI4UOGbAn yXTaajQGMx6bSqU+u3CB9OtPqo+ieioqIRvqzTSrpqlCcnskudGwVE7uzLXeNJLs avd6Q6H0htdQiMpAcP1erO0utd2o87E7bhvuLMCNuOF2qs09F/eFQ4eY5uNPbgZW d/v4QDJwaW2taVkMAgP9RTcL2L1cPl+v1QYz/Kv6Un/yk5+oa0lfCHLq9fp3t2/r mtaOx9Wq+uapNxpuQlbhuLXVdGvH7U8/mZnHx3e0FI2d0oAntTrb4/XoaYO0Y+t9 qfb2euonbXy8M2TbPh9IJdvJWMw9JSjeGbl9/uDBAW+XiL57uLLy83/8x2qlMoDd oRkEBiQQgIHdG9jwr3oK/PTzz/c//7z0heAHql+1uLjYjsf1esUwquoXlZY7Udnd FNTuHPvU/q2dtPzkyU+bqK8N/ZklwC6on7WNry25L0A92jlqE/c0IGViYnJiYiLm jte2B2yfe/751MCPyYG3Fubn/+UXv1DfDgN4+ZtBYKDvCMDA7g1s9e/LR4+eOn06 HA5LXwhBVKtWlx48UDG5oXT27mqn5PYv7d1T3MCsaVprndM5F8p5YtHyo1A9Pu6O UDETG8HifkuXy2X3W7o962HDZOPuZlHtJbWdWceRaPTQoUMq0KoH7Uw7OVkoFtky Cr1QN9X/79/+7bvbtwfwDcMgMNB39G+AXUpnMipuDGAPEtVr+/Gf/ikjDBCikvPy 0pK7UNlaH2FW7xudRP1ozLnz2ZZtu4PPj4O043QfPJq+/fuzuJ2NCyI3TeRe//zY hmWTG5dDk8CDZf2f/dHCV/eTj/4R1/9BNy5zdw+hHV9/vGm4tZNY2/s/dXeB6gZX 9d9ENBru7HjcHo+dnNy3b18imSS7YpBWHz78+T/+Y6VSGcCm0KVSyeJMYKB/6F4A u5RMpRKJxAD66Oc+/PDFw4elrwIMkkrdpbU193E2l9sUXbpftTpD2e0HnVCuAlar E87HOg/ah1R1Bq7bX/r9dN1aT+YD+vMEn7qVRTbMMRl/FEAf7dKkbnMhlTw7Y6pu ClW/J9J5pB4UZ2YInxhBl7755uLXX0ejUekLcSYw0F8EYGA3cvl8rVYbwF4mxX37 Pvrkk4mJCekLAQCA3hmG8b/+9V+Xl5djsZj0tcqlUnP9BUEAe0QABnYjk81OTk5K 76xbr9f/7C/+IsNJjwAA+M/K8vI///f/Xq1W08JnNLRaLV3Xq5WK6FWAEUEABnYs Pz1dqVQGsPr3nXffffX111kJCQCADzmO89tf//ra1asDmKhVKpVqzIIG+oGONbBj g1n9G4/Hv/ijP5qamhK9CgAA2LVyqfT//PM/65oWTyREL+TuMMcgMLB3BGBgxwZw +pF6nvvRH/zBc/v3y10CAADs3eLCwr/8/OeRSES6Y8B5SEBfEICBnckXChXDyOZy old54cUX3z93zt1qFQAA+JZlWf/2P/7HnTt3pHfDWltdrdfropcARgEBGNiZASwA VvX//C//UjpjAwCAvlh68OAX//RP1UolLXk8BMuAgb4gAAM7k0i2iU5zevGll868 /z7DvwAABIJlWf/rX//17t27ooPAHAgM9AUBGNgZ6QXArVbrD778cmbfPqH6AACg 7x4sLv7in/4pEonIHZHIMmCgLwjAwA4MYAFwOpP57IsvpNcRAQCAPqrX6//83/7b 6upqPB6XuwrLgIG9IwADOzCABcCvvPrqocOHw+FwKBQK/z65F5UBAMAeffWb31y5 fFn0TGCWAQN7RwAGdkD6BOBqtfreBx887cVjdd0tg3E3Hqv30qcTAwCAsc6SpU0e rqz82//8n+qpPJ1OC12U04CBvaOvDOyA9A5YU4nEGydO7GX7q03xmGFkAACeyel4 MtNuYtu2+8D9/ZuKWJZ16euvy6WS3Czo9jLgcplBYGAvCMBAr6YLBVN4AfBLr7wi vf0Vw8gAgKHXS5rdpC/X/eG77+7+8EM0Gu1LtS2xDBjYI7q5QK/aC4BNUy4AV2u1 986dE908o0fbDCO7j9V7QjIAYGB2mmafHJ4dDF3TLn71legsaAIwsEd0YYFe5fJ5 9ZQmtwPWZCx2/ORJ0ZeN+2hjMH4yIROSAQBb6o7Nbj9Iu+mrXre6V81m89JXX2nl cjyRELpEqVRqNhq2bQvVB4Ye3VOgV9I7YL3w4ov7DxwYptC4ZTDeOIzMdGsACLQt Q+wzk63XrRak/nS3b926f++e3F7Q7IMF7BFdT6BX8Xg8lU4LBTZd1899+GEimZQo 7mfumuRNqXjjewaTAWAwnpldn4y4w51md0crly9+9ZXcoYntfbBKpVqtJlEcGAX0 KYGeTE9Pm5ILgFXAe/v0adHDAwMt1EFOBoBn2rSh8aZMu82HXjd8SDQaja9+/WvV Z0iKvajNMmBgL+gsAj2R3gErl8+//OqrKsUJ1R8R3T2uu9l44wOmXgMIkI051n3Q Y6xlVNZbtm1fu3z54cOHsVhM6BIEYGAv6AICPWkHYLHpTMorr702XSgIFceTVADe MiRvGZu9biyAANs0YfhpD578JDk2uO7dufPDd99FIhGh+qVSiaOAgV0jAAM9Ed0B y9D1cx99JLdjJPYo1DN3bJnhZWBodIdhn/Z++w8JsaPJXQZcrVYzmYxEffbBAvaC XhrQE9EdsMbGx99hAfAQeWZOdsefNz4mMwN9tzG7bgqlvXzYfez1nwPB014G/Ktf tZcBp1IS9dkHC9gLulzAs0nvgJUvFF4+epSptqPMHTfeJiFverzxgddtB/rG2aCb P5/8cMvHTyZYr/80GF3q22/u6tXlpSWWAQM+RM8JeLa8CsCGkcvnheqzABi7Nr7O DcM7fbDpsdd/GgSA84Sx9cNgt/xqj5mWyIohI70MmAAM7BrdHeDZpHfAev348YxY caBHW0bijdn4yU/u7qse/zmHwsbkObYhdvbyeOOHT/v8Nrz7QwNBcn9+/rtbt9gH C/AhOiLAs6XS6Xg8LtRxr9Vq7507NxWPSxQH/KmbivvyflPZLa+1u09uyntPxr/t f8OWH/byvpffAMDPdF2/+LvfVavVdDotUd9hHyxgtwjAwLMlEolkKiUUgCcmJk68 /XY0GpUoDgAABq/ZbKoArDJqQuaIh3YALperDAIDO0cABp4hn8/XajW5LaAPHjr0 /MGDzAsFAGBoqID67c2bC/PzQkc8OGwEDewWfW7gGaS3gGYBMAAAw+f+vXvfffst +2ABfkMABp5BegvoYydOpDMZoeIAAMATC/PzKgCHw2Gh+gRgYHcIwMAzZHO5Wq0m tAV0s9E4ffZsbGpKojgAAPCKYRgXf/tb1YVIplIS9UulkupF2LYtURwYYgRg4BnU 81YikRBao5svFF4+ejQUCkkUBwAAXmm1WteuXFlZXo7FYhL12Qga2B0CMPAMU/F4 WmwHrCNHjxZnZiQqAwAAb935/nv1JnTQQ3sfrHKZ04CBnSIAA9tJZzKNRiOTyQgF YBYAAwAwrESXAasAXCqV6mwEDewQARjYTn56uiK2BbSmaec//jguc0IgAADwllYu X/zqq0qlIrSTCPtgAbtAAAa2k8vnq9Wq0PNWo9E4c+6c0NIgAADgrVqt9ttf/rJa qQjN9iqVSlazaVmWRHFgWBGAge2ks9nY5KTQJlW56emXjx6VOyABAAB4yLbta1eu PFxZEXqxu9Vq6brOPljAjhCAge0kEolkKiW0APilV16Z2bdPojIAAPCDH7777u4P P8jtg6WVy1X2wQJ2ggAMbCcej6fEtoB+/fjxjMzkagAA4Af35+e/u3UrEolIFG9v BF0q1dgHC9gJAjDwVNPT06bYDljqSeuNN99kC2gAAIaYVi5f+vprFYCFXkxnHyxg pwjAwHbkRoArpnn2ww+n4vG+VwYAAD5RrVZ/87//t8qoEi95MwIM7AIBGHgq0RHg luO8e+bMxOSkRHEAAOAHjXr9d7/+tepOpFIpifqMAAM7RQAGniqvArBh5PJ5ieIH X3zx+QMHhCZEAQAAP3Ac5/atW/fv3ZuYmJCoTwAGdorON/BUKgDLHV7PDlgAAIwC 0X2wSqVSjV2ggZ0gAANPlUqnp6amhA4BPnbiBDtgAQAw9BZUAP7223A4LFGco4CB nSIAA0+VTKUSiYTELGVN085//HE8keh7ZQAA4CvqSf/i734nNKesfRSwphGAgd4R gIGnUulXZWCJANxsNs+cOzfJDlgAAAy7er3+m1/+UmXUdDrd9+LtAFwuV5kFDfSM AAw8ldwZSOFw+K13341Go32vDAAAfKXZbH7161+bhpFIJvtenJOQgJ0iAANbyxcK FcMQOgMpkUq9/sYbQvthAAAA/7As68o335RKpampKYn6bAQN7AgBGNia6BlI7IAF AMDoEN0HiwAM7AgBGNia6BlIBGAAAEaHaADmJCRgRwjAwNZS6XQ8HpdYAOw4zvGT J1MCO2EAAAAf0srlS19/HYlEhPoVbAQN9I4ADGxN7gykSqVy9vz5qXi875UBAIAP 1arVX/2f/9Oo1STmfxGAgR0hAANbkzsDybKs02fPcgYSAAAjol6v//ZXv6qapsT8 L05CAnaEAAxsbSoeT8ucgRSJRE6eOsUZSAAAjIhms/n1b35j6LrUSUjlMsuAgR4R gIEtZDKZeqOh3ksEYM5AAgBgpIiehKQCsKpc5yhgoDcEYGALnIEEAAD6aOH+/e9u 3eIkJMBzBGBgC5yBBAAA+kg0AHMSEtA7AjCwBRVQY7FYKBSSKE4ABgBg1Czev39b LAC3Wi1d19kIGugFARjYgtwhwIauf/Dxx5yBBADASNE17eLvflepVjOchAR4igAM bEHuEOBGvf7eBx9MxmJ9rwwAAHyrXqv9+pe/rFUqHAUMeIsADGxB7hDgsfHxd06f npiY6H9lAADgV41G46tf/co0TdXB6HtxjgIGekcABrYQj8dTMocAx2Kx42+9xRlI AACMFMuyLv7udyqmxhOJvhdvHwVcKtU4CQnoAQEY2Gx6eto0zWwuJ1E8k8sdfe01 oT0wAACAP9m2fe3SpZWHDyWOAh7jJCSgZwRgYDMOAQYAAH3HUcCAHxCAgc04BBgA APQdRwEDfkAABjaTOwTYcZzjJ0+m0um+VwYAAD6nlcuXvv46EolIbDLCUcBAjwjA wGZyhwCrZ7433357uliMRqN9Lw4AAPyp2WyqaKrebs7NVSqVjMAsM05CAnpEAAY2 kzsEuMu2bdM0Q6GQSsKTk5PZXO7Q4cNT8bjcFQEAwACorKtr2vKDB+W1tXqjoT5U T/rq88lkUmJyWRcBGOgRARjYTPAQ4G25T12h8fFIJBKdmEhns88fOJDOZBguBgDA b9xBXfV+YX6+XCq1g65lqayr+g9CJyluj6OAgR4RgIHfk5+erlWrnjx1PU2r1TIM Q7Un6gbjTOa555/PZLMEYwAApD0Kuo3G4sLC46Dbao3JD+ruCEcBAz3ySxcf8AnR Q4D7Sz3V6Zo23hkxjqhgnE4/f/AgwRgAgF1wg26j0ViYn9fKZXfqcntEt7M5iH9e Ft8GJyEBvQjADzMwSKKHAA+GOwlKPVWHIhF30Fg9cz+3fz/ZGAAw4rop98HiorZh OLfVWaabzmQCEXSfhgAM9CLAP+SAhCEIwNtwlxmrH/twpCMaTafT+/bvz+ZyZGMA wHB4lHLr9cXFRd0dy11PuV4t0B0MAjDQi+H8+Qd2TQXgSqWSFTifwOfaa4fK5VB7 4DgUCYdVNnbjcXHfPuIxAMBXuhF3aWnJjbhWZwMqFXId9TY2lgn4WO7ulEqlGptg Ac8ycrcGYHtyhwAH2sZ4HA4/Gj9OJJP79u+fUuJxEjIAoF/cfKseqDj3YHHR0HU3 3xJxt8dJSEAvuHEAv2cAhwAPpe7CYzchtyNyOOwm5Hg8TkIGAHR186167+Zbe52b b4d7orIcAjDQC+4swO+JJxIpLw4BHnruGLJ6EFIZORwOqZzczsjhRCKhQrJ6r75E TgaAQOsmW6VimosLC+q9ZVmd5bePB2/HGL+VwVHAQC+49QCP+fAQ4FHjPnmr7lGo oxOUH025ViG5UCzGicoAMFgbY616sLy0ZJqmbVluslXRtuU47XDrOOPB30g50DgK GOgFdyjgsQAdAgzbtg1dHxt3p12HQp33KiqHOnk5Ho9PF4sMLAPAljYN1a4sL1cq Fbu7zta2VZRqJ9pOrFV32lQqpe6x3rYZvWAjaOCZCMDAY8N9BtIo2zgBezwUepSZ O6PLnSXL4djUVKFYVD089/eTmQEEyMY0qxi6rgJttVq11+cet8dn3SFaN9N2fhuT kIcSARh4Jm58wGO5TgDOE4DRzcydoY/Q+jjz+nBzJzl3fonFYtOFQjqTcf8vkjOA XduUY3VNW1lZqasc21k9242y6zG286Bzs1J3JtIsXKurqw0CMLAt7pXAY4wAY+86 PdKxjeH50TztboYOhTaOP09OTuampzPrEXqMFA0E0Kbsqmjl8urDhyqKPNra2N0C yg2unTFYZ32CcfuW0blduPcBciz2ghFg4Jm4yQKPqRxSZQ0wfGBTih7v9InHOwvw 3OHo7lj04zgdCkUnJnL5/JOv4JCogU2ezKuu0tpaO7U2Giqauqn1cWR1ucFV/brh w3GyK3xDfQ+zCRawPe7UwGPpdFpFBXowGD7dRO0esNkN1eqTm3L1WHeydzdjrw9a qxSdzeW2nCJBxkYfPS2djnVGt1T/3urs1eSsL2vtvle/of3+yaQ6Nvb4vcqroRB5 FcNKfYfrmlbhKGDg6bj1A48lU6lEIkGXCNgFN1+o+KHrutOJIsBOqWja3W2YWzGw C+3TBDXtaS8hARgjAAMbJZJt9LoAAEAQtQNwuVytVr1uCOBfdPSBx6bi8XQ6TQAG AABB5B5hUCMAA09HRx94JJ3JNBoNTpIAAAABpQJwqVSqsw8W8HR09IFHOAMJAAAE HSchAdsjAAOPcAYSAAAIOk5CArZHAAYe4QwkAAAQdJyEBGyPvj7wCGcgAQCAoOMk JGB79PWBx6bicfW8Md45gjKZTLpnUQIAAPjZozPYVR9mrH2INukX2AYBGNhOOxKP jXVTcSqVYogYAAB4xR3g7WZd9Y64C+wIXXlgx0jFAABAGlkXkECvHeiPbioOhUIt lYqTyfEOr9sFAAB8TUXcVqtlGIZ61P6YrAtIoncOyHLXFYfDYdu21dNaJpMhFQMA MJpU1i2Xy+1JZG5ngPW6wMDREQc84A4Xt5/8Oq/1ptJpUjEAAMOkPYG5XHbcrMug LuAb9LkBv4jH452ZT+0fS/V8qZ4s0wRjAAD87cmgq/7jGF7At+hbA373aHXx2Fg4 FLJtWz1IM48aAIDBejLojjGoCwQQfWggqLrBuPtjzFRqAAD2iKALDDf6ysAQenxQ 0/i4+xRONgYAoOv3Uu4YGy8DI4QOMTBaNo0bO+vnGBOPAQDDpHu2kPqFsVwAXXR5 ATzSzcbd4xlanU2qOboJAOBD7pFC7VFc92CFsTFSLoBnolMLoCeb4/H4uNNqsVU1 AEDOo4nKncePnmmIuAD2hm4rgP7YmJDb7zuxmDFkAMCWNo7fjnWfJMi3AITRJQUw OI9D8tjjidZOJyRzthMADI3HI7e/v8uUi3ALwEN0NwH4jsrJ450Nuto2zLh2Ovcs ojIAeKIba91b9MYxW/czJFsA/kcnEkCAbYrKY+40ug1p2T3/icAMAE9yOnRN25xp x4i1AIYWnUIAI+T35mCPrR+V7HbyOlOxycwAAurRqT+67mw46G7TwloXgRbAKKOH BwDP8GRsHusMNW9Mzk4nS7PdF4A9creGat9n1u8mTw7MdhFlAWCn6KgBgCA3PD+e pz22vkv2xgg9tj4T0U3R2SwpGgiidnYtldwf5O5PsbOps9Xd7Xj9tkCIBYBBoo8F AAEwNTU1tmUqXo/TGxfsjW0YlE4zoxt4CnfOsK7rG4dbx9Zz6dMGXbv/c7VaFW8i AKDf6BIBwIjaPLV7I8fZ+JE7WD22PuV7bMOo9XgoRMaGhG46Vb+4m9ttTKSPDo/d 5OnfhIyyAgBc9FcAAAAAACOBAIz/v/06EAAAAAAQ5G89yGURAADAggADAACwIMAA AAAsCDAAAAALAgwAAMCCAAMAALAgwAAAACwIMAAAAAsCDAAAwIIAAwAAsCDAAAAA LAgwAAAACwIMAADAggADAACwIMAAAAAsCDAAAAALAgwAAMCCAAMAALAgwAAAACwI MAAAAAsCDAAAwIIAAwAAsCDAAAAALAgwAAAACwIMAADAggADAACwIMAAAAAsCDAA AAALAgwAAMCCAAMAALAgwAAAACwIMAAAAAsCDAAAwIIAAwAAsCDAAAAALAgwAAAA CwIMAADAggADAACwIMAAAAAsCDAAAAALAgwAAMCCAAMAALAgwAAAACwIMAAAAAsC DAAAwIIAAwAAsCDAAAAALAgwAAAACwIMAADAggADAACwIMAAAAAsCDAAAAALAgwA AMCCAAMAALAgwAAAACwIMAAAAAsCDAAAwIIAAwAAsCDAAAAALAgwAAAACwIMAADA ggADAACwIMAAAAAsCDAAAAALAgwAAMCCAAMAALAgwAAAACwIMAAAAAsCDAAAwIIA AwAAsCDAAAAALAgwAAAACwIMAADAggADAACwIMAAAAAsCDAAAAALAgwAAMCCAAMA ALAgwAAAACwIMAAAAAsCDAAAwIIAAwAAsCDAAAAALAgwAAAACwIMAADAggADAACw IMAAAAAsCDAAAAALAgwAAMCCAAMAALAgwAAAACwIMAAAAAsCDAAAwIIAAwAAsCDA AAAALAgwAAAACwIMAADAggADAACwIMAAAAAsCDAAAAALAgwAAMCCAAMAALAgwAAA ACwIMAAAAAsCDAAAwIIAAwAAsCDAAAAALAgwAAAACwIMAADAggADAACwIMAAAAAs CDAAAAALAgwAAMCCAAMAALAgwAAAACwIMAAAAAsCDAAAwIIAAwAAsCDAAAAALAgw AAAACwIMAADAggADAACwIMAAAAAsCDAAAAALAgwAAMCCAAMAALAgwAAAACwEHSwM +X++pF0AAAAASUVORK5CYII="/></symbol><use xlink:href="#c" width="1280" height="1280"/></g></g></svg>')} -.is2d .queen.black {background-image:url('data:image/svg+xml;base64,<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="614.635" height="614.635" viewBox="0 0 460.977 460.977"><mask id="b"><use xlink:href="#a" width="1280" height="1280" transform="rotate(.193) scale(.36014)"/></mask><symbol id="a" viewBox="0 0 1280 1280"><image width="1280" height="1280" xlink:href="data:image/png;base64, iVBORw0KGgoAAAANSUhEUgAABQAAAAUACAAAAAA9j6ArAAAACXBIWXMAAA7EAAAO xAGVKw4bAABGnUlEQVR4nO3dd2BUZcK28VmEJIRQAlKkqYAgRcWCYi+gvouiqKu4 rhVXxb67oq5trWvFde2ou6jgqlhRVv1WQRSxi4pSpEoXCJ2QRvskIWSSzCRTznnu 55zn+v31vkpmrp3h3CaZmXN+EwEAR/1GHQAAKgwgAGcxgACcxQACcBYDCMBZDCAA ZzGAAJzFAAJwFgMIwFkMIABnMYAAnMUAAnAWAwjAWQwgAGcxgACcxQACcBYDCMBZ DCAAZzGAAJzFAAJwFgMIwFkMIABnMYAAnMUAAnAWAwjAWQwgAGcxgACcxQACcBYD CMBZDCAAZzGAAJzFAAJwFgMIwFkMIABnMYAAnMUAAnAWAwjAWQwgAGcxgACcxQAC cBYDCMBZDCAAZzGAAJzFAAJwFgMIwFkMIABnMYAAnMUAAnAWAwjAWQwgAGcxgACc xQACcBYDCMBZDCAAZzGAAJzFAAJwFgMIwFkMIABnMYAAnMUAAnAWAwjAWQwgAGcx gACcxQACcBYDCMBZDCAAZzGAAJzFAAJwFgMIwFkMIABnMYAAnMUAAnAWAwjAWQwg AGcxgACcxQACcBYDCMBZDCAAZzGAAJzFAAJwFgMIwFkMIABnMYAwqH7zHk12zWpT 9W/d1sVF89dMySuUNMFlDCDM2K1byzat2+68e1aTmP96TdHPKxYtWbxs2jyzWXAb Awjf5XbfrfmuB+zRKKvWP1m0btY38/PmTV1toApgAOGzRh067XHgfi0zk/iS4mXf fjVr9tx1vjUB5RhA+GeXXbsdfWDnlL505lfjp83/xeMeoAoGED5p2XHvM/ZpmsYN rJr8yg9zlnnWA1THAMIPzXY5+KyjPLidj178/JeVHtwOEBMDCM/V36X74MMaeXRj 6yYOm/oLb5CBPxhAeCynzXkXN/P0Flc+/fzifE9vESjDAMJLder1fOBwH273k2u/ 37jFh9uF4xhAeKdO3YG37+7Tbf9866hNTCA8xgDCM7nXXJbr482vfuJB3iANbzGA 8Ej2g+fX/lGP9BQ9d02Bz3cBtzCA8MaTFyTzaY9UFT97qYF7gTMYQHjhzitin+PA e2seu8XQPcEBDCDSN/Bxb9/3UrOVl48yeG8INQYQ6dr/P10M3+OMP0wyfI8IKQYQ aRr9fyZ++VdZ8f8bYPw+EUYMINIy4JmdJfe74qLRkvtFuDCASEPzV3r7/daXeIq+ OCNPdNcIDwYQqTvrYc23f2VWXP2i8N4RCgwgUtXozYPrSwMKPz+F00YjLQwgUnTy gx3VCZE517ylTkCgMYBIzT8HNVQn/Gr98D+pExBkDCBS0fmZI9QJ2024aKY6AcHF ACIF/YemdqkjP8wcMkadgMBiAJG0jKuubaFuiLL8gUdK1A0IKAYQycq99xztq79V FY78KycKREoYQCRpt3+erE6o5q0/zVMnIJAYQCTnsH/ur06IYdKfJqoTEEQMIJKy /2u7qRNimvc7ThCD5DGASMbRI9qqE+JYdO54dQKChwFEEn7/TAN1QlwbLnpJnYDA YQCRuNOfy1Yn1KDg/FfVCQgaBhAJO/U/qnNfJaboD2+oExAwDCAS1f9V86d+Tk7x 6XwoBElhAJGgE/6rLkjAie+oCxAoDCASc9z/1AUJOf59dQGChAFEQrpPURckqMdU dQEChAFEInLnmrrwebrWdOBzwUgYA4gENJvTWJ2QsLUdV6oTEBgMIBIwp4O6IAlz 9afqR1AwgKhVnW/3USckZfJ+W9QJCAgGELWp8/e/qhOSdO9NLCASwgCiNoF4A2Bl vB0QiWEAUYsOc9QFKeg4V12AQGAAUbPmU2y6/keilvfIUycgCBhA1Cj31T7qhJSM O523A6J2DCBqUvfmW9UJKbr9rk3qBNiPAURNBrxk9xmw4iv6/Wh1AuzHAKIGXd7b XZ2Qsp9/O0OdAOsxgIgv+8lz1QlpGHFpgToBtmMAEd+f/6EuSMtfHlIXwHYMIOLq /WYrdUJalp7yhToBlmMAEU+jF/qrE9I05ux16gTYjQFEPEMeUBek7dqh6gLYjQFE HD1HdVYnpG3mwO/VCbAaA4g4XjldXeCBV89QF8BqDCBi+/3jueoED6y+/CV1AmzG ACKmnA97qRM88fUx+eoEWIwBREz3Xq8u8Mh9QTubK0xiABFLqy/bqxM8suCgpeoE 2IsBRCwjzlEXeGZkkD/OB58xgIjhkDFN1QmeWdX/M3UCrMUAIoaxwTwLamzj+qoL YC0GENUd9F4Y3gJTbvVvv1QnwFYMIKobf5S6wFMfHa0ugK0YQFSz/7jG6gRPre0z SZ0ASzGAqObjI9QFHptwpLoAlmIAUVXPT3LUCR7LP5xzIiAmBhBVvfh7dYHnXjpL XQA7MYCoos6qcP0GcJu1TbeoE2AlBhBVPHKlusAHj16lLoCVGEBUsayFusAHy1uq C2AlBhCVnRzO64kPeEtdABsxgKjs233VBb74bj91AWzEAKKSxssy1Qm+KG65Vp0A CzGAqOSpi9UFPnn6EnUBLMQAopIVzdQFPlm5s7oAFmIAEa3rNHWBb7pNVxfAPgwg or1+qrrAN2+cpi6AfRhARFsfto8BV8hvqC6AfRhARDnkU3WBjw7l1PioigFElLdO Uhf46O2T1QWwDgOIKKvCdCr8qlaH50JP8AoDiAptF6oLfNVukboAtmEAUeGxy9UF vnr8CnUBbMMAosKsTuoCX83eQ10A2zCA2KFeibrAZxkb1QWwDAOIcr859BN1gs8O /3SrOgF2YQBRbqfh56oTfDZi0GZ1AuzCAKJcvVm7qhN8Nn8PfgZGJQwgymVvUBf4 rkGBugB2YQBRrvfn6gLfHfyFugB2YQCxXeZjf1Qn+O5fVxSrE2AVBhDb5UzcR53g u8mH5asTYBUGENs1+bmJOsF3a3Zfo06AVRhAbNd8ubrAgBZ56gJYhQFEmTr9w3lB 4MoGjNmiToBNGECUybz1BnWCAffczqsgiMIAokyj0UerEwwYP2CdOgE2YQBRpuU0 F84XuqrbMnUCbMIAokyb2VnqBAOKOi1WJ8AmDCDKtJ+vLjBi1wXqAtiEAUSZIz5W Fxhx5AR1AWzCAKLUTn8cpk4wYvC/OCMWKjCAKFX/ppvUCUb8/e+F6gRYhAFEqdwR J6oTjPjvuavVCbAIA4hSLf7bS51gxNcnuvCJPySKAUSpdp+3UScYsfjgcF/7GMlh AFFqjx9ceBtgJFK09yx1AizCAKJUp+8bqBOM2NBztjoBFmEAUarzDHWBIV1mqgtg EQYQpfb5Xl1gSM/J6gJYhAFEqZ7fqQsM2deVpUciGECUYgDhIgYQpRhAuIgBRCkG EC5iAFGKAYSLGECUYgDhIgYQpRhAuIgBRCkGEC5iAFGKAYSLGECU6jZVXWBI92nq AliEAUSpTj/UVycYUbg3J0NABQYQpTpNzlYnGFGwDwOICgwgSnX4trE6wYi1+81V J8AiDCBKtfywmzrBiGnHLFMnwCIMIEq1eHd/dYIRk/pxTRBUYABRKueBweoEI4Zd m69OgEUYQJTK/Mvd6gQjbvxHsToBFmEAUebk0eoCIwa8pS6ATRhAlOk+RV1gRA9X 3vCNhDCAKNNmkbrAiLaL1QWwCQOIMi1/aqJOMGDNnrwLBlEYQJRp9kUndYIBs3uv VCfAJgwgymQPO0edYMDIwQXqBNiEAUSZnc4drk4wYNCIzeoE2IQBxHY9flQXGLCX G691I1EMILZrslpdYEDuGnUBrMIAYrtGM1qpE3y3tMs6dQKswgBiu/qvnqBO8N07 pxeqE2AVBhDb7XTlQ+oE3/35UV4DQTQGEOWah/9EUS3y1AWwCwOIcpnLG6kTfLau BaeCQSUMIMrV++gQdYLPPjtqozoBdmEAUa7OXx5QJ/js2n9sUSfALgwgdshdpS7w WVMX3uqIZDCAqLA+R13gq/yG6gLYhgFEhQ/6qgt8NfZYdQFswwCiQv+31QW+OmmM ugC2YQARpThDXeCjkkx1AazDACLKjM7qAh/N7KIugHUYQES5/W/qAh/dcau6ANZh ABFtqzrAR/xdRzX8pUC0OR3UBb6Z21FdAPswgIg26N/qAt9c6MIp/5EkBhCVFIX1 pdLiLHUBLMQAopKJh6oLfPLpYeoCWIgBRCVHfqQu8MlRH6sLYCEGEJUtbaku8MWy 8F/wBClgAFHZE5eqC3zx5GXqAtiIAURlzRZkqxN8UNB+pToBNmIAUcXHR6gLfDDh SHUBrMQAoopDxoXvDSNFfT5TJ8BKDCCqmr6nusBzP3VVF8BODCCquvIRdYHnrnpU XQA7MYCoZkE7dYHHFrZXF8BSDCCqufU2dYHHbrtdXQBLMYCo7ufd1AWemre7ugC2 YgBRXcjOi8qZUBEPA4gYZnVSF3ho9h7qAliLAUQMd14bnrNiFT9wizoB1mIAEcuk /dQFnvl2f3UB7MUAIpaLHmyoTvDI+mueUSfAXgwgYppwuLrAI5+E8aPN8AoDiJiO fLG1OsETS87iRKiIjwFEbCE5LyDnAURNGEDE1vyDfdQJHph8bJ46ATZjABHHVXc3 UCekbcON4TuxA7zEACKe0SerC9L21gB1AezGACKeg14I+udBZp/9pToBdmMAEdeN f1cXpOmmu9UFsBwDiLiyRv5OnZCW184pUifAcgwg4uvxcnd1QhqmnjlFnQDbMYCo wdnPBPcCSUUXvaBOgPUYQNQge2hw3w795JACdQKsxwCiJru9eLA6IUWfnzVPnQD7 MYCo0SGvt1InpGTpaVwJGLVjAFGzPwbzbFIX/UtdgCBgAFGzug9doU5IwWN/3qRO QBAwgKjNh0erC5I2/hh1AYKBAURtsqcE7bKSP/fgBWAkhAFErfb8Kljnx19/4E/q BAQEA4ja5J446Ch1Q1Kmvfe/CcXqCAQCA4ga9Drx4C4tg3iFzK0FC3/8+L256gzY jgFETBn9Tjxg18YB/+uxacXMT1+fpK6AxQL+Nzz4WvzhyA7NG9Tdurlw9cLv3v5s i7rnV3X6DujdsZG6wjNb8qZ+9MZUdcWv6hxy0r7tcuvv9JtNG/Lmfvyf5eoeRBhA rUNuOrzKywtzPnhkuqalTI/zjtijSQj/Umxa9sM7ryonp+tVx3as/E/Wf/J3Pqwi F8K/64Ex5Lrmsf7xqnevX2I6ZZu6A07t3bae4p5N2fDThy99p7jj1vf1axrrn+fd P9R0CipjAFUGPRT/p8xpt7xhsORXzS747d7NnPi7sGn+56+9Y/ZTIqfe2S3uv1v3 5+EGS1CNE3/pLdRqXPyDYpu8Ox81VBLJueC0no1N3ZkVtiz6+Nnxpu7syltifp+/ w7Q+Sw2VIAYGUOL0V2r9I6uvN3AWgqyzzjigmf93Y6FN88Y+Z+CKSRfdl1vrnznj Vf87EAcDqDD0mkT+1NLz3ve14pArj2rp9PNf8tOrw339detxzyd0LrEHh/gZgZo4 fQCovHRmgn9w8oB5PiU0unjgXkF8g7PXtq4c/9Q4n257t9H7JPgnX/69TwmoDQNo 3ssDE/+zIy704Rf2B13R1+1v/Srb+v2LI7x/h0zdf5+b+B8eleh/EuExjgPjhjyQ zJ/O/+Mob+++/9UHZ3t7iyGwdfGoJ7z93NzAf+Uk88ev5f0wGgygab0/T/ILvumX 59V91zln8H4ZXt1YyGxd8dbDnl1Gs/m7ByT5FQd/4dV9IxkMoGGNlyT//df193tx zxmXnd9jJy9uKLzW/O8hT14Zvu6+pL+koPVaL+4ZSWIADZta8/v/YpvZZ1Gad1vn wsv3qpPmbThh7VsPpPt9YNtxnVP4qmlBvgZ9cDGAZl2Q4hv/b7wnnXs94aZeddP5 eresGPmPdP57c8PdqX3doGfTuFOkiAE0qu6aBil+5U9Hp/qBgS53H5/qnbpqy9yH nkvxpPqtxu+Z4p1uaMJ1nMxjAI16Pom3RlSV0guFWTf8sXXqd+mwkgm3T0zhy5J7 ib+yEeel/rVIEQNoUuM16Xz15KNXJ/kVR9zXi5c9UrZy2EMrk/uK3PGJvvU5pia8 DmIcA2jSC39I68uLLxqZxJ/O+ttFO6d1d9j06c3JfBt4zjPpfbjmP2en9eVIAQNo UEbaV+oZ368owT/Z6fE+fPPngV/u+ldJYn8y6920r5+cmeBdwTMMoEEPpP+h9/xT P0jkjw24t0vad4UyG0bckcjrT8e+kdRHP2Iaem3aN4HkMIAGrYx5WuAkjTqrtuuG 1BlyLT/7emnTB9fV9t7AOi8m8QHvuFa5eWoyJQbQnP2/8eRmVvT5oaZ/nTV0UH1P 7gcVtkz+04Sa/v3e47z5T84BXMLOMAbQnHd/69EN1XD+uEaPDwz1ZT1kts76yztx /2Vi53dMwHv9PLohJIgBNKfIsxPwzT16Qcx/nju8P698+Gb+kNdi/vP24zt4dRfF WV7dEhLDABrTZ6yHNxbr/AiN/nUq8+eruX8aU/0fpnDmg/j6+nV2VsTGABrzdn8v b21ynypv0s166iw+7+u7GZdWuZpSs3Fpvfe5qjEneXlrqBUDaMwajy+9VunD83Xu u4oT/Zmw9etLvo/6f1M9uUU8a5t4e3uoBQNoStuFXt/iZ79dV/5/XnkP5zswZct7 V8zb/n82eu8Qr2+9XbonPkNSGEBT7rzZ85ssurjso3FHv8AJD0wqfvLW0v/0nPO0 969Z3HWL5zeJGjCApkzaz4cbnfjb/EiLMQf6cMuoyaohz0Zy3jvMh1v+dn8fbhRx MYCmFPjy9uSii/b5My/9Cnz9+m2+vGWlkCtWGcUAGuL9rwARSvwS0CgG0JBUT5QO x6R38QMkiQE05Nt91QUIhO/8+F0x4mEADdmqDkBAcEiaxKNtCAOIxHBImsSjbcax 76sLEBDHJXTKW3iDATTjoyPVBQiIj49SF7iEATRjXUN1AQJifSN1gUsYQDP4FSAS xTFpEA+2EV1+UhcgMPacoS5wCANoxPAL1AUIjGcHqQscwgAaMaOzugCBMZNLmprD ABrBrwCROA5Kc3isTegX/4JiQFUnvKsucAcDaMIrp6sLECCvnqEucAcDaMIvrdQF CJClu6gL3MEAGpC9QV2AQGlQoC5wBgNowGWPqwsQKJc/oS5wBgNowMRD1QUIlE/9 uNoIYmEADdjAdR6QjAIucmoKA+i/rtPUBQiYbtPVBa5gAP335GB1AQJm2KXqAlcw gP77eTd1AQJm3u7qAlcwgL6ru1FdgMCpt0ld4AgG0HcXDFcXIHAGPasucAQD6DvO ho+kcV58QxhA3+XzngYka0OOusARDKDfevyoLkAA7TVFXeAGBtBvnAwaKeC00GYw gH5b3FpdgABa0kZd4AYG0Gc569UFCKKtjfLVCU5gAH123X3qAgTS9ferC5zAAPps 8t7qAgTSD/uoC5zAAPqrzmZ1AYJpc8YWdYILGEB/nTNCXYCAOnekusAFDKC/OBcq UsRZUU1gAP1VlKkuQEAVZ6kLXMAA+qrPWHUBAqvvOHWBAxhAX73TT12AwHr3BHWB AxhAX3E1EKSMK4MYwAD66egP1QUIsGPGqwvCjwH00wd91QUIsLHHqgvCjwH0U0F9 dQECrJBfoPiOAfRRv3fUBQi0E95VF4QeA+ij8UepCxBoHx2tLgg9BtA/fA4Y6dmY xeeBfcYA+mfwk+oCBNylw9QFYccA+mdqN3UBAm5ad3VB2DGAvmm8Rl2AwGuyVl0Q cgygb/7xZ3UBAu+hv6gLQo4B9M2yFuoCBN7yluqCkGMA/XLQF+oChEDvL9UF4cYA +uUTzmeJ9E08XF0QbgygT7I3qAsQCg0K1AWhxgD6ZOg16gKEwoND1AWhxgD6ZFWu ugChsLqpuiDUGEB/cB4EeIQzIviJAfTHT13UBQiJGXuqC8KMAfRFjx/VBQiNvaao C0KMAfTFZwerCxAanx+iLggxBtAPLZapCxAiLZerC8KLAfTDmwPUBQiR0aeoC8KL AfRB7ip1AUKl6Wp1QWgxgD54u7+6AKEy5iR1QWgxgN7jN4DwGL8F9AsD6L2xfdQF CJlxXGDaJwyg59rPVxcgdHZdoC4IKQbQc9/uqy5A6Hy3n7ogpII1gB3+b+9OuTkN 6tfbuHFj8epFc6Z984M6qZoT/qsuQAidaN+Hy/c+oFvHtrmZ9erV21i4IX/17B/+ 31x1UvICM4B1TjvzwLYx/vn6xdPHv5xnPCeuOnmcvQPeW9XcoksENz/z6K5tGsb4 F4u+evl1izoTEIwBzL729zWeXKBo/hcvjrXjgX/iUnUBQunJy9QFper0Pav3rlk1 /YkZLz0QoHO4BmEA+9/RM5E/tuTrV14r8bulNp1nqAsQUl1mqgsyfndGr9aJ/MHv /zbG7xavWD+Adf52dZPE//QvX7745ib/Ymo3v73y3hFiC3ZV3nvdU846aJfE//ia h++w4yey2lg+gHXvH1w/2a9Z9MmzH/jRkoiH/qS6Z4TeP2UXmj72gsNj/f69RoXD rpN+K5IgqwewzsMXZ6T2lbPeH6Y4iRqXwoSPJJfI7DH4uD1S+8qSp6+2/7tAmwdw 8JPpfHXRtNHDDL86nP1LI7N3CKes28XwqwvNBw/oVuMLHrW5dJhXKX6xdwAPeS2J XznEsebr//zH4Pfh3+9j7r7goMkJvRrojbp/+EOvJH77Hscvv/vMgxYf2TqA2W8c 79EtLfjgse89uqlajDjHzP3AWSPPNXM/Pa841qtX8/53qtVvirF0AP/4aFrfeVdR 9MPrT6318PZiu+UO3+8Crvvbnb7fReNLTtvb06Pvyn95eGtes3IAW4zdy/PbzPvk qfc9v9FoVz7i680D21z1qK83f9wlhzf3/EZ/7Gvv2bxsHMDLH/PphqePfmSpTzcd uexxv24ZiHL5E37dcqurBnT16aavsPbosG8AG489wM+bn/bo0368Nn/9vT7cKFDd X+/z4UbrXHxlNx9udodv+vr/O6iUWDeAp4/M9P0+fn5x2CJvb3Hk2d7eHhDXCx6/ 2NZ28Fm7e3uLMRSf86rv95EKywawzqunGrqn+ZPHveLVz8O5X3T26JaA2s3s7dVF klqd0WcfU5+we+N0G98WbdcAdv3Y+9/A1qB48eSxr6X/+9k/Pp7i51WAlJRcnv4L qy1+13efNv7/tBUl78jpJu8uMVYN4DVDBXf66wqOe3NJ6l/f5Q1ff3kCxDDt1DRO O9T6lD6Gt2+7IQ8K7rRmFg1gxtjDdXe+aPqnb3+Xwtf1eKa35y1A7b64KJVPu+97 0qFdkz6vgXc+6Ss/YV0V9gzgvuMbqxPWLJj8yZgkfjGYcc3Fu/kWA9Rs3tMPJjEn rfofvk/79D/blqa1R6fybYaPrBnAG+5WF5RbvWTmtx99XVzbH+t88UkpniUD8Mis t5+u9TSpmb2O2q9z61wTOYm48R51QSWWDGDGB0eoE6panbdw1s+zp8/cXO3fZB90 xH49JL9DAaoqXjzl2wlfVv+87U6du3bafY92za1ZvnITjrXpx2A7BrDNj9Y9TRWK SoqLCwq3bvs/f5OV1SA7Wx0EVFNQsKGoqOwvaf3szMwMLz/N67HVey1WJ1SwYwCz V1r8fAHwUFEzi84PY8UA7vT/+qoTABgy9v+q/15JxYoBzF7eQJ0AwJANLez5FtCK AYwc+ZG6AIAhR32sLqhgxwBG/nm1ugCAEQ/bdOlESwYwMn1PdQEAA37y66SDKbFl AHOX8DowEH5Frb06lY0nbBnAyMmj1QUAfDfgLXVBJdYMYOS589QFAHz2/Pnqgsrs GcDIPFNnZgSgMX83dUEVFg1ga4s+IAPAB23SOPOmLywawMjZI9UFAHx0zgvqgqps GsDImwPUBQB8M/oUdUE1Vg1gnSUt1QkAfLKstX2XRbJqACOdZqkLAPhkj9nqgurs GsDI5Y+pCwD44orH1QUxWDaAkbF91AUAfDDOynPe2TaAOevVBQB80DBfXRCLbQMY ue4+dQEAz11/v7ogJusGMDKrk7oAgMdmW3oJRfsGMLJpJ3UBAE9trqsuiMPCAWy7 UF0AwFPtFqkL4rBwACP3X6suAOChB65TF8Rj4wBGfmmlLgDgmaW7qAvisnIAI1vs zAKQvK111AXx2bk03aeoCwB4pMdUdUF8dg5g5Plz1QUAPDHC5nO9WzqAkdVN1AUA PLAmV11QE1sHkF8DAmFg8y8AIxYP4BEWXT0eQIqOnKAuqJG1Axj533HqAgBpev94 dUHN7B3ASEF9dQGAtBRmqwtqYfEAZhSrCwCkJbNEXVALiwcwct5z6gIAaTj/eXVB bWwewMik/dQFAFL27f7qglpZPYCRknrqAgAp2pihLqid3QOYu0pdACBFTVerC2pn 9wBGbrhbXQAgJTfeoy5IgOUDGPl5N3UBgBTM211dkAjbBzCy2e5P0gCIZUswrmxh /QB2mKMuAJC0jnPVBQmxfgAjT1yqLgCQpCcvUxckxv4BjOTtrC4AkJQVzdUFCQrA AHJmLCBYLD8HVpQgbEuvr9QFAJJw4NfqgkQFYQAjo09WFwBI2FsD1AUJC8QARvIb qAsAJGhDjrogccEYwMhWdQCABAVkVEoFpPXU19UFABJy2hvqgiQEZAAjnx2sLgCQ gM8PURckIygDGCkOwKl1AOeVZKoLkhKYAcxZry4AUKuG+eqCpARmACPXDFUXAKjF kAfVBckJzgBGZndUFwCo0ZxO6oIkBWgAOTMWYLeAnAMrSpAGkDNjAVYLyDmwogRp ACNPXawuABDX05eoC5IWqAGMrMpVFwCIY3VTdUHygjWAnBkLsFVwzoEVJWCDcsTH 6gIAMR05QV2QgoANYGTcMeoCADF82EddkIqgDWCkMEtdAKCaovrqgpQEbgAzitUF AKrJLFEXpCRwAxi5ZJi6AEAVg59SF6QmeAMY+amLugBAJTP2VBekKIADGNkUuM/b AKG2ua66IFVBHMC2C9UFAKK0W6QuSFUQBzDyz6vVBQB2ePhP6oKUBXIAI8uDct15 IPzyWqgLUhfMAeQjcYAtAvkRuHIBHZJeX6kLAJQ68Gt1QRoCOoCRMSeqCwD86r/9 1QXpCOoARgqC+ckbIFwKs9UFaQnsAPKROMACAf0IXLnADmDkvOfUBYDzzn9eXZCe 4A5g5Ie91AWA437cW12QpgAPIB+JA7SC+xG4ckEeQD4SB0gF9yNw5YI8gJFHr1AX AA577Ep1QdoCPYCRlQG8DBUQEquaqQvSF+wBjGxVBwDOCvh4lAr4/4Z+76gLAEed 8K66wAMBH8DIxEPVBYCTPj1MXeCFoA9gpKSeugBw0MYMdYEnAj+AOevVBYCDGuar CzwR+AGM3HarugBwzu23qQu8EfwBjCxurS4AHLOkjbrAIyEYQE4PDZgV6JNAVxKG 7eD00IBRgT4JdCVhGEBODw2YFOyTQFcSigHk9NCAOQE/CXQl4RhATg8NGBPwk0BX Eo4BjFz2uLoAcMTlT6gLPBSSAYzM6qQuAJwwew91gZfCMoCRzaF5YR6w2JZwnYc9 NAPY5Sd1AeCAPWeoCzwVmgGMPH+uugAIvRHnqQu8FZ4BjKxrqC4AQm59I3WBx0I0 gJweGvBZmPaiVJj+Bw18WV0AhNqZo9QFXgvTAHKpdMBPgb8MenWhGkAulQ74J/iX Qa8uXAPYYY66AAitjnPVBd4L1wBGRp6tLgBC6oVz1AU+CNkARvIbqAuAUNqQoy7w Q9gGkPPCAL4I0zlgKoRtACOXDFMXACE0+Cl1gS9CN4CR2R3VBUDozAnp6ZbCN4Cc FwbwWsjOAVMhhAPYfYq6AAiZHlPVBT4J4QBGRp+sLgBC5a0B6gK/hHEAI4VZ6gIg RIrCe9GxUA4g74UBPBTOd8CUCuUARq67T10AhMb196sL/BPOAYwsbKsuAEJiUTt1 gY9COoCRLWH9HwaYtTXUbysL6070+kpdAITCgV+rC/wU1gGMjDtGXQCEwId91AW+ Cu0ARooz1AVA4JVkqgv8Fd4BzFmvLgACr2G+usBf4R3AyN03qAuAgLvnRnWBz0I8 gJHlzdUFQKDltVAX+C3MA8h7YYB0hPsdMKVCPRH93lEXAAF2wrvqAt+FegAjk/ZT FwCB9e3+6gL/hXsAuVAwkKowXga4mpAPYJef1AVAQO05Q11gQMgHMPL6qeoCIJDe OE1dYELYBzBSFPJ3sgO+KHbjrMKhH0A+EAKkIOwfAdku9APIB0KA5IX+IyDbhX8A IyubqguAgFnVTF1giAMDGNmqDgACxoVdKOXC/9CzR6oLgEA55wV1gSkuDGBk5h7q AiBAZnVWFxjjxABGNof/Q92AV7Y49PkpNwaw53fqAiAw9v1eXWCOGwMY+fBodQEQ EONdupyOIwMYKamnLgACYaNTF9NxZQBbLFMXAIHQcrm6wCRXBjDy1MXqAiAAnr5E XWCUMwMYWZ+jLgCsl99QXWCWOwOYUawuAKyXWaIuMMudAYxc9bC6ALDc1Y+oCwxz aAAjC9uqCwCrLWqnLjDNpQHkMplATRy4DGZVTk1Cn7HqAsBifcepC4xzagAj3zhw nT8gRZMOUBeY59YAclYEIB6XzoGwg2MD2H2KugCwVI+p6gIBxwaQsyIAsTl1DoQd XBvAyEYXLncPJGuTm6cLcW4A2y5UFwAWardIXSDh3ABGXj9VXQBY543T1AUa7g1g pNip850BCSjJVBeIODiAuavUBYBlmq5WF4g4OICR4ReoCwCrPDtIXaDi4gBGCuqr CwCLFGarC2ScHMCc9eoCwCIN89UFMk4OYGToNeoCwBoPDlEX6Lg5gJF1jp34G4hr fSN1gZCjA8j58YHtXDsLfiWODmDkhrvVBYAVbrxHXaDk6gBGVjZVFwAWWNVMXSDl 7ABGtqoDAAu4uwCl3P2ff8kwdQEgN/gpdYGWuwMYWdxaXQCILWmjLhBzeAD5IRjO c/n4L+XyA3Dq6+oCQOq0N9QFai4PYGR2R3UBIDSnk7pAzukB5ErpcJmD10Gvxu0F 4ErpcJiD10Gvxu0BjPzYQ10AiEzZS11gAccHkB+C4Sp+AN7G9eP/iI/VBYDEkRPU BTZwfQD5IRhu4gfgUs4PID8Ew0X8AFyGo58fguEgfgAuwwBGfuqiLgAMm7GnusAS DCA/BMM5/ABcjmOft0PDObwFuhwDGOGHYDiGH4B3YAC34YdgOIQfgCtw5G/DD8Fw CD8AV2AAS/FDMJzBD8BRGMAy/BAMR/ADcDSO+zL931YXAEacNEZdYBMGcLv57dUF gAELdlUXWIUBLMclkuACjvhKeDjKDfq3ugDw3YXD1QV2YQB3WNZCXQD4bHlLdYFl GMAK/BCMsON4r4IHpMI1Q9UFgK+GPKgusA0DGGV1E3UB4KM1ueoC6zCA0fghGGHG 0V4ND0m0u25SFwC++fvN6gL7MICV5DdQFwA+2ZCjLrAQA1hJRrG6APBJZom6wEIM YGXDL1AXAL54dpC6wEYMYBUl9dQFgA82ZqgLrMQAVtF2oboA8EG7ReoCKzGAVY07 Rl0AeO7DPuoCOzGA1WzmhJEImy07qQssxQBW0+srdQHgsQO/VhdYigGsbmo3dQHg qWnd1QW2YgBj4AIhCBUuAxIXh3oMA19WFwAeOnOUusBaDGAsv7RSFwCeWbqLusBe DGBMnBYG4cFBHh+PTUy33KEuADzytzvVBRZjAGPbkK0uADxRwBmOasAAxpazXl0A eKJhvrrAZgxgHK+fqi4APPDGaeoCqzGA8Wziw0MIvq29JqkTrMYAxtN9iroASNtN d6sL7MYAxvVjD3UBkKa87nnqBLsxgPHxiTgE3ZET1AWW4xiP7+yR6gIgLSMu2KJO sBwDWIMVzdQFQBqKus5TJ9iOAawJn4hDkJ00Rl1gPQawJv+8Wl0ApGzi8QXqBOsx gDUqylQXACnasvdUdYL9GMAacY04BNZVj6oLAoABrNlXvdQFQEqW9FitTggABrAW vBkQwXToZ+qCIODwrgVvBkQgPX/hZnVCEDCAtVndRF0AJK14z3nqhEBgAGuTUawu AJJ2+mvqgmBgAGs18mx1AZCkyYfwFsCEMIC148yACJitPX9QJwQEA1i7nt+pC4Ck 3H6buiAoGMAEzOqkLgCSsKbLcnVCUDCAieCkCAiSY8arCwKDAUzEdfepC4CEvXPK RnVCYDCACSnMUhcACdrcbaY6ITgYwIS0WKYuABI0+Cl1QYAwgImZtJ+6AEjIsq6c BCFxDGCCOCkCgoGTICSDwzpBVz2sLgAS8OZAXgFJAgOYqIL66gKgVps7z1UnBAoD mCheB0EAXPyMuiBYGMCEfXmgugCoxS9d16oTgoUBTByvg8B2B3+hLggYjunEXTJM XQDUaNQfOA10chjAJGzIVhcANdjUcYE6IWgYwCTkrlIXADU4/3l1QeAwgMn4vLe6 AIjrlz3XqRMChwFMCq+DwF69v1QXBA8HdFI4LxasxVmwUsAAJqcoU10AxLRlDz4D kjwGMDkd5qgLgJiGPLRFnRBADGCS5nRQFwAxrGvPZ0BSwAAmi+uDwEZcByQlDGCy nrhUXQBU8/WhvAKSCgYwaVwnHdbZ2nWGOiGYGMCkHfKpugCo4oG/8gpIShjA5K1o pi4AKilus1KdEFAMYPIyitUFQCWnjFYXBBUDmIL/HacuAKLM61qkTggqBjAVfCQY Ntn3e3VBYHEkp+KaoeoCYIcxp/EWmFQxgCkpqacuALbb2n6ROiG4GMCU9PxOXQBs d/sdvAUmZQxgapY3VxcApYpb8iHg1DGAqeGtMLAEb4FJBwOYogmHqwuAXy3pyFtg 0sAApoqzwsAGB0xSFwQaA5iq225VFwCR8cdyJeB0MIAp21hXXQDnbd2NKwGnhQFM GWeFgdzQ63kLTFoYwNStbqIugOM2NuctMOlhAFOXs15dAMf94WW+AUwPA5iGn7qo C+C0ta14C0yaGMB08FYYKB0+UV0QeAxgOkafrC6Aw2bvyVtg0sUApoUTA0Knx1R1 QfBxAKflljvUBXDWuON4BSRtDGB6uEYmRDgNoBcYwPT0GasugKMeu5pvANPHAKZp Q7a6AE7a3Iz3QHuAAUxTi2XqAjjp0qf5BtADDGC6FrdWF8BBhU1K1AmhwACmjXdD w7zjP+DvnRcYwLR93ltdAOcs34UfgD3BAKaP/xTDNM4D7REGMH18IA6GzenMN4De YAA9wLeAMKvbdHVBWDCAHnj0CnUBnPLNQXwD6BEG0AucEwEm7T5PXRAaHLleuO4+ dQEc8v5v+QbQKwygJzgnAsxpuVxdEB4MoCcGvqwugDNeOI9vAD3DAHqjpJ66AI7Y mstZELzDAHqj11fqAjjivhv5BtA7DKBHOC0WjNjSgCvBeYgB9EiHOeoCOOH6oXwD 6CEG0CvrGqoL4IBNmeyflxhAr3BmVBhw+TAG0EsMoGfWNFYXIPT4BtBjDKBn+BYQ vhv8DAPoKQbQO6ty1QUIuY0Z6oKwYQC9k7tKXYCQG/Q83wB6iwH00Ipm6gKEGt8A eo4B9FDOenUBQu3c//ANoMcYQC/l7awuQIiVZKoLwocB9BLfAsJH57ygLggfBtBT S1uqCxBaxVnqghBiAD3Ft4DwzVkvqQtCiAH0Ft8Cwid8A+gHBtBbfAsIn5w1ipeA vccAeoyPg8AXvAfQFwygx/hEMHxx6TB1QSgxgF5bn6MuQAhtrqsuCCcG0GucGho+ uP5+dUE4MYCeK+TVOnhtCxee9gcD6DkuEAfP3fdXdUFIMYDeK+b1Onhra13eAuMP BtB7/d5RFyBknr5EXRBWDKAPNvKKHby0NatEnRBWDKAPzh6pLkCovDJQXRBaDKAf NtdRFyBMGhSoC0KLAfTDLXeoCxAiH/ZRF4QXA+iLLTyu8EyLPHVBeHGg+uL1U9UF CI05ndQFIcYA+mOrOgCh0W26uiDEGEB/TO2mLkBIrG2iLggzBtAnfAsIbxwzXl0Q ZgygT7hCJjzBtTB9xQD6hBOjwhOcCNVXDKBfCuqrCxACnAfLXwygXw75VF2AEHj0 KnVBuDGAvtnEf7uRNg5Qf/H4+uaaoeoCBN4Hx6kLQo4B9A+fh0O6mqxVF4Qcx6h/ /sd/vZGeBbuqC8KOAfQRb4ZGevb9Xl0Qdgygj5a2VBcg0Iq5wKDfGEAf8WZopIU3 QfuOAfQT14dDGrZyYnHfMYB+4uIgSMOoM9UF4ccA+op3wiB19YvUBeHHAeqr0Ser CxBYczuqCxzAAPqLd8IgVT2mqgscwAD6a3FrdQECqojTCRnAAPord5W6AAF14XB1 gQsYQJ8VcUJfpIL3wBjBAPps0L/VBQikV89QFziBAfQbL4MgFQ0K1AVOYAD99l1P dQECaCUX1TKCAfRbRrG6AAF0wrvqAjcwgL4r5JQeSBbXQjKEAfQdHwhG0l46S13g CAbQf7wMgmTxMWBDGED/fbO/ugABs6K5usAVDKABfAuI5PQdpy5wBQNoQAGf6kQy eAnEGAbQgIEvqwsQKLwEYgwDaALnRUUyMkvUBc7gyDSBl0GQhLwW6gJ3MIAm8GkQ JOH499UF7mAAjeDycEgYJ8IyiAE04oa71QUIjHF91QUOYQDN4K2ASNTOK9UFDmEA zfillboAAcG1QExiAM3oMEddgIC4/n51gUsYQEN4KyASw18Uk3i0DZl4qLoAgbCk jbrAKQygIbwVEAnhPAhGMYCmlNRTFyAAeBOgWQygKUOvURcgAL44WF3gFgbQGN4K iNrtukBd4BYG0Jj8BuoCWG8TvygxiwE0ZtC/1QWw3qtnqAscwwCaw8/AqE3DfHWB YxhAc1blqgtguZJMdYFrGEBz+oxVF8Byj16lLnANA2gQPwOjZhyOpvGIG7S4tboA VivgjQKmMYAG9fxOXQCr3Xa7usA5DKBJ/AyMmnA0GsdDbtLCtuoCWGxDjrrAPQyg Sd2nqAtgsRvvURe4hwE0ip+BER8Ho3k85kbxMzDi4idgAQbQKF4HRly8BizAAJrF z8CIh2NRgAfdrJVN1QWwVHGWusBFDKBZp76uLoClnr5EXeAiBtAwfgZGbJkl6gIX MYCGcV5oxMS5oCUYQMPuukldACuNPVZd4CQG0DR+BkYs7RapC5zEAJq2sa66ABbi esAaDKBpHx6tLoCFfu6gLnATA2haRrG6ABY6/n11gZsYQOO28JijGv5SaPC4G8eJ 8VFNfkN1gaMYQOO4OByqGXqtusBRDKB5vBEGVe20RV3gKAbQvCKufo3KtuykLnAV A2jeywPVBbDM5J7qAlcxgAL8DIzKDpikLnAVAyjAG2FQGX8hVHjkBZa1UBfAKlwN RIYBFDjvOXUBrDL8QnWBsxhABX4JiGiN16kLnMUAKmziXQ+owJlgdBhAhand1AWw yPKW6gJ3MYAK3aeoC2CRvzykLnAXAyjBLwFRgYNQh8deooQr4KAcn4MTYgAlvtlf XQBrLGqnLnAYAyjRYY66ANa4+Bl1gcMYQA1+CYhyHINCPPgaK5qpC2CJlTurC1zG AGpwSixsN+pMdYHLGECN1ovVBbBEmyXqApcxgCL8EhBlOASVePRF1jZSF8AK6xqr C5zGAIq8f6y6AFb44Dh1gdMYQJG9J6sLYIV9flAXOI0BVOGXgNiGI1CKh1+Fi2Pi V8VZ6gK3MYAqMzqrC2CBmV3UBW5jAFXuvFldAAvcdYu6wG0MoEpWoboAFqhfpC5w GwMow6sg4ABU4/GX4a3Q4G3QagygzCeHqQsgN/FwdYHjGECZ/m+rCyB30hh1geMY QB1+CQiOPzGeAB0GEBx/YjwBOotbqwsgtqSNusB1DKDOiHPUBRAbea66wHUMoE7X aeoCiHWbri5wHQMoxC8BXcfhp8YzIMQAuo7DT41nQGhZC3UBpJa3VBc4jwEUeve3 6gJIvddPXeA8BlDo2PfVBZA67gN1gfMYQCV+Ceg2jj45ngIlBtBtHH1yPAVKazgZ ksvWNlEXgAFU+ry3ugBCXxysLgADqHTJMHUBhAY/pS4AA6hUd6O6AEL1NqkLwABK 8SqIyzj49HgOpAq5LLa7iuqrC8AAai1opy6AzML26gIwgFqjT1YXQOatAeoCMIBa XBjJYVwQyQIMoBavgriLY88CPAlaDKC7OPYswJOgVZSpLoBIMe8AsAADqLWwrboA Iot4B4AFGECtMSeqCyDy3/7qAjCAar97VV0AkdNfUxeAAZTjVRBXcejZgGdBjAF0 FYeeDXgWxIoz1AWQKOH1fxswgGJ5O6sLILGiuboAEQZQ7usD1AWQ+KaXugARBlDu H39WF0Diob+oCxBhAOW6T1EXQKLHVHUBIgygHi8Du4kjzwo8DWoMoJs48qzA06DG +2CcxLtg7MAAqvE+GCfxLhg7MIBqvA/GSbwLxg4MoBrvg3ES74KxAwOoxvtgnMS7 YOzAAMrxMrCLOPDswPMgxwC6iAPPDjwPcgygizjw7MDzILc+R10A4/IbqgtQigGU +3k3dQGMm7e7ugClGEC5sX3UBTBuXF91AUoxgHK33aougHG336YuQCkGUK7zDHUB jOsyU12AUgygHi8Du4fjzhI8EXoMoHs47izBE6HHALqH484SPBF6+Q3UBTBsA+/9 tAQDqLewrboAhi1qpy5AGQZQ75PD1AUwbOLh6gKUYQD1HrtcXQDDHr9CXYAyDKDe gDfVBTDslNHqApRhAPWyCtUFMKx+kboAZRhAC/A+GNdw2NmCZ8ICDKBrOOxswTNh AQbQNRx2tuCZsEBBfXUBjCrMVhdgOwbQAsu5SLZb8lqoC7AdA2iBqd3UBTBqWnd1 AbZjAC3wdn91AYwac5K6ANsxgBa44W51AYy68R51AbZjAC3QfYq6AEb1mKouwHYM oA14H4xbOOqswVNhAwbQLRx11uCpsAED6BaOOmvwVNiAAXQLR501eCpsUJSpLoBB xVnqApRjAG2wuom6AAatyVUXoBwDaIP57dUFMGjBruoClGMAbfD1AeoCGPRNL3UB yjGANhh1hroABr0yUF2AcgygDW6+U10Ag265S12AcgygDXp/ri6AQQd/oS5AOQbQ CrwR0CUcdPbgubACA+gSDjp78FxYgQF0CQedPXgurMAAuoSDzh48F1ZgAF3CQWcP ngsrFPLpUHcUcRFAezCAVljTWF0AY9byyW97MIBWWNxaXQBjlrRRF2AHBtAKXBjT IVwU0yIMoBXGHaMugDEf9lEXYAcG0ArDL1AXwJhnB6kLsAMDaIUhD6gLYMy1Q9UF 2IEBtMJhn6gLYMzhE9UF2IEBtEJmkboAxmQVqwuwAwNoBz4K4g6OOYvwZNiBAXQH x5xFeDLswAC6g2POIjwZdmAA3cExZxGeDDswgO7gmLMIT4YdijPUBTCkJFNdgAoM oB3yG6gLYMiGHHUBKjCAdljZVF0AQ1Y1UxegAgNohwXt1AUwZGF7dQEqMIB24HxY zuBsWDZhAO3w8RHqAhgy4Uh1ASowgHZ4eaC6AIaMOlNdgAoMoB3u+au6AIbce4O6 ABUYQDsM+re6AIZcOFxdgAoMoB32/VZdAEP2+05dgAoMoB04IaAzOB2gTRhAS/Bh YFdwyNmEZ8MSDKArOORswrNhCQbQFRxyNuHZsAQD6AoOOZvwbFiCAXQFh5xNeDYs wQC6gkPOJjwblmAAXcEhZxOeDUsUcZ5gNxRnqQsQhQG0BKeEdgQnhLYKA2gJTgnt CE4IbRUG0BKLW6sLYMSSNuoCRGEALTG7o7oARszppC5AFAbQEt/voy6AEZN7qgsQ hQG0BOfEdwRnxLcKA2iJt/urC2DEmJPUBYjCAFri34PUBTBi+IXqAkRhAC3BRUEc wSVBrMIAWuLKR9QFMOKqR9UFiMIAWqLfO+oCGHHCu+oCRGEALdF1mroARnSbri5A FAbQEjttUhfAiLqb1QWIwgDagvNhuYEjzio8HbZgAN3AEWcVng5bMIBu4IizCk+H LRhAN3DEWYWnwxYMoBs44qzC02ELBtANHHFW4emwBQPoBo44q/B02IIBdANHnFV4 OmzBALqBI84qPB224LqYTuCqmHZhAG1RUF9dAAMKs9UFiMYA2mJdQ3UBDFjfSF2A aAygLbgwsBO4LLBdGEBb/NJKXQADlu6iLkA0BtAW89urC2DAgl3VBYjGANpiWld1 AQyY3k1dgGgMoC0m7acugAHf7q8uQDQG0BafHKYugAETD1cXIBoDaIt3+qkLYMC7 J6gLEI0BtMXLA9UFMGDUmeoCRGMAbTHsEnUBDHhqsLoA0RhAW9zzV3UBDLj3BnUB ojGAthjygLoABlw7VF2AaAygLc57Tl0AA85/Xl2AaAygLfqMVRfAgL7j1AWIxgDa Yo+Z6gIY0HmWugDRGEBbZG9QF8CABgXqAkRjAK3BOfFdwAFnF54PazCALuCAswvP hzUYQBdwwNmF58NDzf54bsucGNc2Ki7OX7N00ayfps8uruGrGUAX1HTAZXbquuce bVs1ycmM9Zcof9mIf630rctVDKA3fn/+Pk3rJfqHi0vyV+ctmPPrIEb/RpwBdEH0 AZf96+B1bN88Nycj4SsCblw1+bmXfMhyFgOYtg63HdcyrRsoWp+3eM7Mn9/0qAc2 O2X3zh3bNG+Y3sUxl71/21yPelzHAKYl6/FTcj26qZIMj24INvPsaV795uVFHt2U yxjA1B374F7qBDjtx2s+UCcEHQOYomajOYMz9CYO4IWRdDCAKRl2bn11AlCqcASn GEwdA5i8rPG91QlAlC+O5teBKWIAk/btvuoCoIrvuKZgahjAJI3toy4AYhjXV10Q SAxgUq6/V10AxPHX+9QFAcQAJmNpeu94Bvy0rJW6IHgYwMRd9bC6AKjR1Y+oC4KG AUwYv/2D9fhNYJIYwEQtb64uAGqV10JdECwMYGLaz1cXAAnZdYG6IEgYwIRwyTYE BheeSwIDmAj2DwHCAiaOAUwA+4dAYQETxgDWjv1DwLCAiWIAa9VhjroASFJHzhid GAawNjffqS4AknbLXeqCYGAAa8O1ihBEHNkJ4WGqRQFnPkUQFWarCwKBAazZqDPU BUBKXhmoLggCBrBGOevVBUCKGuarCwKAAaxRScIXOwcss5ELrdaOAazJ2/3VBUDK xpykLrAfA1gDzoCAQOO8CLViAGtQlKkuANJQnKUusB4DGN9tt6oLgLTcfpu6wHYM YHy8BRpBx/FdCx6guL7qpS4A0vT1geoCyzGAcfENIIKPA7xmPD7xrM9RFwBpy2+o LrAbAxhHsxXqAsADO69UF1iNAYyDH4ARDhziNeHRie2yx9UFgCcuf0JdYDMGMDa+ AURYcIzXgAcnpjcHqAsAj4w+RV1gMQYwJr4BRHhwkMfHYxPL/45TFwCeef94dYG9 GMBY+AYQYcJRHhcPTQxPDlYXAB4adqm6wFoMYAycBguhwmmx4mIAq+M8qAgZzowa DwNY3dRu6gLAU9O6qwtsxQBWx0sgCBuO8zh4YKr5pZW6APDY0l3UBZZiAKvhG0CE Dwd6bDwu1TCACB8O9Nh4XKphABE+HOix8bhUtaaxugDw3Nom6gI7MYBV8Q0gwogj PSYelqoYQIQRR3pMPCxVMYAII470mHhYqljYVl0A+GBRO3WBlRjAKvgGEOHEoR4L j0oVDCDCiUM9Fh6VKhhAhBOHeiw8KpW1XqwuAHzRZom6wEYMYGWreb8owmlNrrrA RgxgZfwEjLDiWI+BB6UyBhBhxbEeAw9KZQwgwopjPQYelMoYQIQVx3oMPCiVLG+u LgB8ktdCXWAhBrASvgFEeHGwV8djUgkDiPDiYK+Ox6QSBhDhxcFeHY9JJQwgwouD vToek2g/7KUuAHzz497qAvswgNGKM9QFgG9KMtUF9mEAo/ETMMKMo70aHpJoDCDC jKO9Gh6SaAwgwoyjvRoekigD3lQXAD46ZbS6wDoMYJRVnDENYba6qbrAOgxgFH4C RrhxuFfFIxKFAUS4cbhXxSMShQFEuHG4V8UjUqHDHHUB4KuOc9UFtmEAKwy/QF0A +OrZQeoC2zCAFQqz1AWAr4rqqwtswwBW4FeACDuO9yp4QCowgAg7jvcqeEAqMIAI O473KnhAKjCACDuO9yp4QCowgAg7jvcqeEAqMIAIO473KnhAdvjyQHUB4LOvDlIX WIYB3IGLoiP0uDh6FQzgDlwQBKHHZUGqYAB34FeACD8O+Mp4PHZgABF+HPCV8Xjs wAAi/DjgK+Px2IEBRPhxwFfG41Hu897qAsB3XxysLrALA1jul1bqAsB3S3dRF9iF ASxXwKnSEH6F2eoCuzCA5fgVIFzAEV8JD0c5BhAu4IivhIejHAMIF3DEV8LDUY4B hAs44ivh4dhu1BnqAsCAVwaqC6zCAG43rau6ADBgejd1gVUYwO1W5aoLAANWN1UX WIUB3I6TYcEJnBCrEgZwO14DgRs45KPxaGzHAMINHPLReDS2YwDhBg75aDwa2zGA cAOHfDQejTIv/l5dABjx0lnqApswgGV+2EtdABjx497qApswgGVWNFMXAEas3Fld YBMGsExJPXUBYMRG3vEahQEsw2sgcAXHfBQejDIMIFzBMR+FB6MMAwhXcMxH4cEo wwDCFRzzUXgwyjCAcAXHfBQejFJcFBjO4NLAURjAUqubqAsAQ9Zw6ssKDGApfgKG OzjoK/BYlGIA4Q4O+go8FqUYQLiDg74Cj0UpBhDu4KCvwGNRigGEOzjoK/BYlGIA 4Q4O+go8FqUYQLiDg74Cj8U27/RTFwDGvHuCusAeDOA283ZVFwDGzN9NXWAPBnCb /AbqAsCYDTnqAnswgNvwK0C4hKN+Bx6KbRhAuISjfgceim0YQLiEo34HHoptGEC4 hKN+Bx6KX43toy4ADBrXV11gDQbwVwvbqgsAgxa1UxdYgwHcZlo73hgAV+Qv7KZO sAcDWGHU/i3ZQYRX/rJJA9UNtmEAqxl1QAt2EGGSv/wbli82BjCelw/g+0EEXP6y b85UN9iNAazNtx2y66kbgKRsLJi7n7ohGBjABI3r3jhL3QDUomjtVN7TlQwGMDkj DmrRgG8IYZuNG5Z/ea46IogYwNSMOqB5Q3UDEFmfx+sb6WAA0/PCgc2zM9QRcE5J Qd5XZ6sjwoAB9Mjo/ZvwojH8lr9m0gB1Q6gwgF4bvX/jLH5LCC9tLFrL7vmDAfTN Y0c0b8iZppG6DevzJlyhjgg5BtCAoUe2aJLFbwqRiJKiNcs/HqKucAYDaNY/jmna KCtTXQHLFBetW/XhX9QVLmIAde4/tmnDrPrqCogUFq1f9cF16grXMYCWuKdfk5z6 dXn1JMw2birMX/PuDeoMRGEArXTzSY0b1c9gDwNu46aSwnVr375L3YG4GMBAuPm0 hg2yMhlEy23cVFy0Yf3rDF5wMIAB9edzs7OzM+ruxCaqbNy8qaSgoGDEQ+oQpIEB DJFBl2TlZGfW22kn3nLjrZLNmzcWF+QXPTVcXQKPMYAO+N21GdmZmRm/LmMdvmGM b+OWX3eupLi4oOSB19QtMIQBBOAsBhCAsxhAAM5iAAE4iwEE4CwGEICzGEAAzmIA ATiLAQTgLAYQgLMYQADOYgABOIsBBOAsBhCAsxhAAM5iAAE4iwEE4CwGEICzGEAA zmIAATiLAQTgLAYQgLMYQADOYgABOIsBBOAsBhCAsxhAAM5iAAE4iwEE4CwGEICz GEAAzmIAATiLAQTgLAYQgLMYQADOYgABOIsBBOAsBhCAsxhAAM5iAAE4iwEE4CwG EICzGEAAzmIAATiLAQTgLAYQgLMYQADOYgABOIsBBOAsBhCAsxhAAM5iAAE4iwEE 4CwGEICzGEAAzmIAATiLAQTgLAYQgLMYQADOYgABOIsBBOAsBhCAsxhAAM5iAAE4 iwEE4CwGEICzGEAAzmIAATiLAQTgLAYQgLMYQADOYgABOIsBBOAsBhCAsxhAAM5i AAE4iwEE4CwGEICzGEAAzmIAATiLAQTgLAYQgLMYQADOYgABOIsBBOAsBhCAsxhA AM5iAAE4iwEE4CwGEICzGEAAzmIAATiLAQTgLAYQgLMYQADOYgABOIsBBOAsBhCA sxhAAM5iAAE4iwEE4CwGEICzGEAAzmIAATiLAQTgLAYQgLMYQADOYgABOIsBBOAs BhCAsxhAAM5iAAE4iwEE4CwGEICzGEAAzmIAATiLAQTgLAYQgLMYQADOYgABOIsB BOAsBhCAsxhAAM5iAAE4iwEE4CwGEICzGEAAzmIAATiLAQTgrP8POqwLpgeK9FUA AAAASUVORK5CYII="/></symbol><g mask="url(#b)"><g transform="rotate(.193) scale(.36014)"><symbol id="c" viewBox="0 0 1280 1280"><image width="1280" height="1280" xlink:href="data:image/png;base64, iVBORw0KGgoAAAANSUhEUgAABQAAAAUACAIAAACXhmigAAAACXBIWXMAAA7EAAAO xAGVKw4bAAEUI0lEQVR4nOzdh5sc1Znv8Qmd00RJgwJBgaQAxiYajDGYXe+yYLCR jdf2f3mf3efhXt+7tgFjMNhKKIFGk3PoVF2x79td0ng0oWOd6p6u7+eRxVjqOXWm e1Rzfn3OeU9/HwAAAAAAAdDf6Q4AAAAAAOAHAjAAAAAAIBAIwAAAAACAQCAAAwAA AAACgQAMAAAAAAgEAjAAAAAAIBAIwAAAAACAQCAAAwAAAAACgQAMAAAAAAgEAjAA AAAAIBAIwAAAAACAQCAAAwAAAAACgQAMAAAAAAgEAjAAAAAAIBAIwAAAAACAQCAA AwAAAAACgQAMAAAAAAgEAjAAAAAAIBAIwAAAAACAQCAAAwAAAAACgQAMAAAAAAgE AjAAAAAAIBAIwAAAAACAQCAAAwAAAAACgQAMAAAAAAgEAjAAAAAAIBAIwAAAAACA QCAAAwAAAAACgQAMAAAAAAgEAjAAAAAAIBAIwAAAAACAQCAAAwAAAAACgQAMAAAA AAgEAjAAAAAAIBAIwAAAAACAQCAAAwAAAAACgQAMAAAAAAgEAjAAAAAAIBAIwAAA AACAQCAAAwAAAAACgQAMAAAAAAgEAjAAAAAAIBAIwAAAAACAQCAAAwAAAAACgQAM AAAAAAgEAjAAAAAAIBAIwAAAAACAQCAAAwAAAAACgQAMAAAAAAgEAjAAAAAAIBAI wAAAAACAQCAAAwAAAAACgQAMAAAAAAgEAjAAAAAAIBAIwAAAAACAQCAAAwAAAAAC gQAMAAAAAAgEAjAAAAAAIBAIwAAAAACAQCAAAwAAAAACgQAMAAAAAAgEAjAAAAAA IBAIwAAAAACAQCAAAwAAAAACgQAMAAAAAAgEAjAAAAAAIBAIwAAAAACAQCAAAwAA AAACgQAMAAAAAAgEAjAAAAAAIBAIwAAAAACAQCAAAwAAAAACgQAMAAAAAAgEAjAA AAAAIBAIwAAAAACAQCAAAwAAAAACgQAMAAAAAAgEAjAAAAAAIBAIwAAAAACAQCAA AwAAAAACgQAMAAAAAAgEAjAAAAAAIBAIwAAAtCWRTA709/f191d+pt7/vZWGyuXy tt+dcrlYKHjZUQAAAo8ADABAc1Kp1D/jrquvb2BwUP47MDDg/t5Cs44jmbd873fb LlezcCUO34/E+Xze468EAICAIQADAFBHPJEYrCZbN/HKRxJ3JeUOVkOv0ktL+LVt W1KxRGJnKw/LHzqOViwqvTQAAL2HAAwAwB4SicTA/dA7UDVYpTrx1ubm4XuR2HHc MCwfFAnDAAA0gAAMAMA/uRt63aXMEnlDoZCE3k53al+ShC3Lujc5XF08zbZhAABq IAADAHB/vvf+TG8kEul0j5pmGIY7M1yuTg4zJwwAwG4EYABAcG3PvdFotLXiVd1G 0q+u6yRhAAB2IwADAALn3jrn+4ucw+Fwp3ukhGma7gLpMocqAQBQRQAGAASIO+Ur Kqk3HO5sRSt/SPqtJGHTdJgQBgAEXu//4AcAIJVKSfar5N5QKBKJDHRxXSt1HNs2 DKMyJ1x9KjhVGAAQQARgAEAvk+grv/f397tTvr2xy7cdkn7dCeHKkcJ9fcRgAECg EIABAD0rmUwODg5K7g0FY7Vz4yT9SgYWtm0X2BsMAAgMRgMAgB6USqUGqqcZhUIh CXuk393cp8WyLMMwHNtmKhgAEAQMCAAAvSYzNCTRd7C60ZfoW5u7ENqubg/Obm52 ujsAAKjFsAAA0DsymUw4HB4Mhdjr2yzHcWyrsiw6m812ui8AAKhCAAYA9IJ0Oh2u Lniunu/LT7dWlKssicGGkcvlOt0dAAC8xxABAHCwpVIpt8zVwMAA0bd9koEdx3FL ZLExGADQYxgoAAAOsKHh4cqa58FBoq+3JAbbti0ZeHNjo9N9AQDAMwwXAAAH0taa Z7b7qlOZCmZFNACghxCAAQAHTDKZDIUrJP12ui+BYFWLY8n/ODEYAHDQEYABAAcJ E78dwVQwAKA3EIABAAdDKpUaDIUq077hcKf7ElDViWDLtiyKYwEADigCMADgAEin 0+6yZyZ+O8txHHc5NFPBAICDiAAMAOh2maGhavhl4rdbVM9IMrObm53uCAAAzSEA AwC6VyqVCoVCkWiUid9u4ziOoesWy6EBAAcKARgA0KUqy56r6be/v79cLnPSb/dw Xw753c3ALIcGABwUDCYAAF0nlUr1DwyEw+FIJNLpvqAOwzBM0yw7DlPBAIDuRwAG AHSXZDI5GApFqmcddbovaIhlWRKDbcvioGAAQJcjAAMAuoh71pGk38HBwU73pWnl cllCeyqdPnToUCweP3fhQoOfeOXSpZKmLS8v53M5CZMHcbG3bdtuBmYeGADQzQ7e j1gAQK+qlLyqLnseGBg4EJt+HceJxWJDw8NHJiYaj7uNkEi8uLCwubFRKpW6vwCY +2JVymIZhmWaZGAAQNfq9rEFACAgJP1K9o1Go53uSB1u6D185MiZJ56Q3OvDFSUJ 37pxY2lx8UCEYV3XTcMgAwMAuhMBGADQeal0OhIOR7o4/UrulU6eO3/+5OnTHezD 1cuXb1y/rpdK3bxE3NB1wzTzlIYGAHQfAjAAoMPSkn6j0XA43OmO7KEbcq/bjVwu t7GxIR+4f7I4Pz8zNaXrencmYdM0JQZzPBIAoNsQgAEAnSTpNxqNhros/brrnB9/ 8klvd/a2oFwuu9HXtu09HzB99+783JxtWd22OtoyTZ0MDADoMgRgAEDHVNJvLNZV xx1J9D0yMfHiyy+n0unO9kSib6FQWF9ftyyr7oNLmnb75s3s5mZXTQhLz/VSiQwM AOgeBGAAQGd0Yfo9febMD158sdO9qNA0bW1tzTCMZj/x25s3lxYXu2c2mAwMAOgq BGAAQAdI+o3F490zXXnuwoWOr3Z26bou0bdUKrXTyPTduzNTU10Sg8nAAIDuQQAG APgtlU4nEokuiWfdE31N01xfXy8UCl412D0x2LZtTdOoCw0A6DgCMADAV6lUKp5I dMPcb/dEX8uyNjY2FM2RdkkMrmTgYpHzgQEAnUUABgD4J5lMxuLxUCjU39+xH0CO 4zz+xBNdstdXOpPNZiX9lstlpRf69ubNxYWFDr7vIF+g5PySpnk4xQ0AQLMIwAAA n3RD+h0aHn7t9dc7XuG5736R57W1tf3ON/KcVixeu3LFMk1/LrcbGRgA0HEEYACA T0ZGRyORSAfT7xtvvXVkYqJTV9+uVCpJ9NV13efrOo6zMDc3+d13nZoKlgxsGMb6 2lpHrg4AAAEYAKBcKpUKhcPRaLQj6dc92vfNt9/2/9K7WZYl0beDU6CmYWjF4re3 b5c0rSMbgyUDS/K3TJP9wAAA/xGAAQBqSfqVoBVPJDo199slE7+SwzerVG/3rUsr FEzTzOVyd+/c6chUsDwDEsLlCSEDAwB8RgAGAKiVTqfjHTr06NDhw10y8VsoFFZX V33b7ltbWZJnLufm8G9v3zZ8X4ndV307QDIwhwMDAHxGAAYAKNSpQ48k3b348ssn T5/2+bq7maYp0VfTtE535AGWaRbvL8NeW12dm531/zVyC2IxCQwA8BMBGACgSjKZ jMZikUjE5+tKlvvZO+90vNSzhPDNzU0fjjhqjVYsmobhfqzr+u2bN/2fpTcMQy+V KAoNAPANARgAoISk31A4HI/Hfb5ulyx71jRtdXXV7NyZQ3VJLK8shHacrT/pyHJo eaIs0yQDAwD8QQAGAHjPLXwVi8f9nFR0HOfCs8+eu3DBtyvuybZtib4HItFZllV8 cAXy4sLCyvKyz69aSdMoiAUA8AcBGADgvXQ6HY3FQqGQb1eUBPXSK690fNNvLpdb W1tztk2rdjkJnztmff3fEiw5XC+VKIgFAPABARgA4LFUKhWORKLRqG9XLJfL//Hz n3d206+kuJWVlW4rdlWXPHWFXG5HYtd1/daNG35mYLmiaRhMAgMAVCMAAwC8VFn8 PDgYj8d9O/W3G9JvLpdbXV3tzmJXde1eCN3newaunAysaY5tk4EBAEoRgAEAXkpn MnEft/5GIpEPLl7051p7sm17ZWWlWCx2sA/tKxWLxv2K0Ntdu3rVt4GCPJOlUimX zfp1QQBAEBGAAQCeSaVSkWhUQmm5XPZhBrjj6Vdy7/Ly8gHa8buf3RWht/iTgd1v GKNyLJLOJDAAQB0CMADAG5J+B0Mh38496mz6ldC7trbWS3WbLNMs7lO52s95YE3T bMsiAwMAFCEAAwC8kc5kYrGYP7tGO5t+DcNYWlrq5jN+W6MVCvt9Ub5l4EpFaF1n ITQAQBECMADAA35WfpaM/eFHH/lwoT3l8/mVlZUDWu+qtrLjVBZC7/OlXb182Z+t 3VSEBgCoQwAGAHhgaGgo5kvl5w7WfJZLr66u9tKy590keWr7FPTyrS60PM8lTdvc 3FR9IQBAABGAAQDtSqfTkUgkHImovpBTLr/bofRrWdbS0pKEQP8v7bNiPi9f7J5/ 5VsGNivlsIzefq8BANARBGAAQFtSqVQoHI7FYqov5DjOm2+/fWRiQvWFdiuVSpJ+ bdv2/9L+qxzGu3/ylFA6NTnpw1poec4t02QhNADAWwRgAEBbMplMVH3tK0m/L778 8qkzZ5ReZU8S+VZWVvy/bgfppZL82u9v11ZX5+fmVGdgy7IMXc9SDQsA4CkCMACg dVu1r1Qf/Hv02LEfvfGGuvb3JF/URpXP1+04+cILuVyN840n79zZb6uwVx2Qbyeq YQEAPEcABgC0LjM0JOlX9fRvNBZ7/5e/VHqJ3SSDLS8vF/Y5Grfnmaap1fzar1+7 proUtm3bkoGzVMMCAHiHAAwAaFEqlYpEoxHFta8cx/nN73+v9BJ7XnRxcbG0/zLg ICjk8/Y+1bBcVy5dUv3eR6UWlq4zCQwA8AoBGADQoqHh4Wg0qnQvqATRf3v33eHh YXWX2M227YWFBUlefl60C8nzUKhZh1nX9ds3b6r+BpCrbAZvFToAQBECMACgFalU StKv6qOPHn7kkVdee03pJXawLEvSr2mafl60a5WKxdpvBMxOT6uuU2VW5oCZBAYA eIMADABohQ/Tv5Kuf3Hxorr2d5P0Oz8/v98puAHkOE7lSKSae31VbwZmEhgA4CEC MACgaZXp31gsHA6ru4Rt2//27rsjIyPqLrED6XdPtY9E6qsuhL5144bSzcCmaUof mAQGALSPAAwAaNrw8HBE8fTvyTNnXnjxRXXt7yB5W9IvK593K5fL+Wy29hzv4sLC 2uqquj44jmPoegDPowIAeI4ADABojg/Tv6Fw+IMPP1QasLeTfCXpl6pX+5HwWdK0 2o9RvRCaSWAAgCcIwACA5gwNDUVUnv1r2/ZP//VfDx85oqj9HSS2LSwsBPzEo9rk KSrkco7j1HiM6oXQ8l0hOXyTM4EBAO0hAAMAmuDD9O/E0aM//slP1LW/nUS75eXl QqHgz+UOLtMwtGKx9mNUV4RmEhgA0D4CMACgCZmhoajK6V/HcX75619HFJ+utGVt bY1JxUY0Mgksrly6pHQSWNf1LK8XAKANBGAAQBNGx8bC4XB/v6ofH9/7/vefeOop RY3vkM/nl5eX/blWD2hkEjiXy81MTSnqgIRw0zSVVtsCAPQ8AjAAoFHpdDqeSKir TRWNxf7j5z8PhUKK2t9O1/X5+XmldZt6TIOTwDdv3LCVHSUlV5cQLjFbUfsAgJ5H AAYANGp4ZCQSiSgKwJJtfvTGG8dPnFDR+A62bc/OzsrvPlyrlzRSDlrX9ds3b6r7 JjEMY2N9XUXjAIAgIAADABqSTCbjiYS66dloLPbeBx/4cPRRuVxeXFzU6gU57NbI mcB9iieBLcvSikXqlgEAWkMABgA0JDM0FIvF1M3svf6Tnxw7flxF4ztsbGysM4XY Kr1U0usdGaV6ErhUKlEKCwDQGgIwAKAhSstfRWOxd99/X10B4S2Snebn51VfpYdJ /sw3cNaRuklgSmEBANpBAAYA1JdKpeKJhKKA6tvuX7nQ7OyspWx1bkBoxaJpGLUf o3QS2LZt6QMHAgMAWkAABgDUNzQ0FFW2/tm36d/V1dVsA7OXqM22rEID4VPdJLDj OHqpxAHOAIAWEIABAPWNjY+HQiEV658lzLz24x+fePhhz1vegcXPHsrnck69Gtrq JoHL5bJlWasrK563DADoeQRgAEAdqVQqkUwqmv7tHxj44MMPw+Gwisa3sPjZW42c hySuXb2qaJwhL2ixUGAVNACgWQRgAEAdQ8PDsVhMUfmrC9/73tNnz6poebv19fWN jQ3VVwmOcrmca2AFci6Xm5maUtSBUqm0yWsKAGgSARgAUMfY2FhITf1nx3He//DD eDzuecvbmaY5MzOj9BIBVCwULNOs+7Arly6p2N1dWQVtmqvUggYANIkADACoRen6 58MTE2+8+aaiueUtCwsLWgPrddEU0zS1QqHuw2anpxUVHmMVNACgBQRgAEAtmaGh eDyuaPr3nZ//PJPJeN7ydoVCYWlpSeklgqmyClqSbblc95FXL19WVApL07QstaAB AM0gAAMAahkZHY1EIioCcCgc/uDDDxXNLbskI83OzpoNrNRFCxo5EFhcv3at3EBO bpa0aRjG+tqa5y0DAHoYARgAsK94IpFKpRSd0Pvk008/+9xzKlreks1m2SaqToOr oNdWVxcXFlR0wLbtfD4vOVxF4wCAnkQABgDsS9JvMpVSMf0r0eWDixeVlr9yHGdm Zsaud1wtWtZgLeg+laWwKpuA2QYMAGgYARgAsLdYLBaJRhVtAA6Fw7+4eFFp+auN jY319XV17UMU8/lGTldWtwpa07TKocSlkueNAwB6EgEYALC3eCJRycBqNgCfPX/+ /DPPeN7sFsdxpqen5Xd1l4CohM8GKmwrWgXtbgOW9MsqaABAgwjAAIC9qdsAbNv2 xd/8JhwOe97yls3NzTXKI6nn2HY+l2vkkYpWQbMNGADQFAIwAGBvkn5T6bSKlsOR yC8uXlTRsqtcLk9PT7P71x+5zc1GljcrWgUtJIGzDRgA0CACMABgD4lEIhQOy+8q Gj9+4sSrr7+uomVXLpdbWVlR1z620wqFRg6amp2ezmazKjpQLBYt0ywyCQwAaAAB GACwB4m+kWg0FoupaPyDixcjkYiKll2zs7NGA+fTwhMNbgMW31y9qqIDpVJJ+kAA BgA0ggAMANiDBOB4IqFim27ZcT76/e89b3aLxKH5+Xl17WMH27YLHd0GXDmOuFgk AAMAGkEABgDsIZlMpjMZFS0nksl3339fRcuupaWlQqGgrn3s0PhpwDdv3LAbODOp BblslhcdANAIAjAAYKdUKtXf359MpVQ0/uTTTz/73HMqWhaWZU1PTytqHPsp5HKN lBxbXFhYW11V0oF8XnI4pbAAAHURgAEAO1UqYIVCiWRSReO/+s//VHGwsGtjY2N9 fV1R49hPSdMMXW/kkYq2ARcLBcuyWAUNAKiLAAwA2EkCcDgSicfjnrfsOM5vVG4A npmZaaQiMbzVeB0sRduANU0zDYMADACoiwAMANipUgErHg8rKNQcCod/+atfed6s S9f1ubk5RY2jhsrsa2PLj69dvapi5CHpVzIwARgAUBcBGACwUyKZdFdBe97y2KFD P/2Xf/G8Wdfq6qqik2ZRW+N1sL69fbvBxdJNcdc/F6mDBQCohwAMANhJ0m86k1Gx U/fchQvyy/Nm+6oZbHp6upFSTFBBArC8BHUfpqgOViWBZ7PMAAMA6iIAAwB2Sol0 WkXL77z3nqKWOf63sxosBK3r+ne3b6voQD6Xowo0AKAuAjAA4AGxWCwciSQVlIBW WgFrbW1ts7FVuFChUoe5sfJjVy9fHhgY8LwDhULBNIxSqeR5ywCAXkIABgA8IJFM hgYHlZyBVC7/+ne/877ZqunpacuyFDWOuho/CUlRIehKArdttgEDAGojAAMAHhBP JCJqzkCSZj+4eNHzZoVpmjMzMypaRoMaPwlJUSFoTRK4YWhsAwYA1EQABgA8IJFM SlKNxWKetzw0PPyzd97xvFmRzWZXFZRWQuPMhsPnzRs3bAVz9aVSSQIwM8AAgNoI wACAB0gAjkWjkWjU85YPHT785ttve96sWFxcpAJwZzV+FLCik5AqU9C6TgAGANRG AAYAPCAhkkkVhwArOgOpXC5PTU05juN5y2icbduFXK6RRyo6CamSwAsF3gcBANRG AAYAPEDSbzweD4fDnresKAAbhjE7O+t5s2hK2XFy2Wwjj1QUgE3T1DSNGWAAQG0E YADAAyQAp5LJAQV1et94660jExOeN5vL5VZWVjxvFk0pl8u5xo6hktdrZmrK8w44 tp0vFAjAAIDaCMAAgAdIAM5kMipa/vVvf6ui2eXl5Xxju0+hVFYCcLncyCO/uXpV SQeyWQIwAKA2AjAA4AHJZDJ9oALwzMyMaZoqWkZTcpub5Y4G4Fw2WyAAAwBqIgAD AB5wsAKwJK7JyUnPm0UL8tlsg6XICMAAgE4hAAMAHnCwArCu63Nzc543ixbkcznH tht5JAEYANApBGAAwAMOVgDO5/PLy8ueN4sWFHI5mwAMAOhuBGAAwAMOVgBeW1vb bKz4MFQr5PO2ZTXySAIwAKBTCMAAgAccrAC8tLRE5ukSBGAAQPcjAAMAHnCwAvDc 3Jyu6543ixYQgAEA3Y8ADAB4gLoA/MJLL508fdrbNqemphrcdwrVGgzAa6uriwsL KjpAAAYA1EUABgA8QF0APnfhgvzysEHOQOoqDQZgSb+SgVV0gAAMAKiLAAwAeEAi mUylUgMDA5637HkAtixrenrawwbRjgarQCsKwI7j5PP5IgEYAFATARgA8AAJwIl4 PBQOe97y0PDwz955x8MGDcOYnZ31sEG0o8EAfPPGjQa3CjfFMs2iphGAAQC1EYAB AA84QAG4VCrNz8972CDakc/lHAIwAKC7EYABAA+QAByPx8MKAvDg4OCHH33kYYPF YnFxcdHDBtGOfDbrOE7dh129fFnFAnvTNDUCMACgHgIwAOABiUQiKmIxFY17exJS oVBYWlrysEG0I7e5WS6X6z7syqVLg4ODnl9dL5V0XS8Wi563DADoJQRgAMADEslk JBKJHYQAnM/nl5eXPWwQ7chubDTyMEWHAJdKJcMwmAEGANRGAAYAPCCRSITCYfld ReNvvPXWkYkJr1ojAHePcrmc29ys+7BcLjczNaWiA8VisbINmBlgAEBNBGAAwAMk +g6GQslkUkXj3p6EJGlqZWXFq9bQjrLj5LLZug9TdwhwoVCwLYsADACojQAMANgp nU4nUykVLXtbCJoZ4O5h23Yhl6v7MEUloEUhn8810AEAQMARgAEAO6VEOq2iZW8L QVMFuntYllXM5+s+TFEJ6L7qIUz5BjoAAAg4AjAAYKdEskJFqV7HcX7z+9971Zqm aQsLC161hnZUTiFqoACVohLQlfnnQoEKWACAugjAAICdEolEPJFQcRSweOe997ya XtZ1fW5uzpOm0CZD10uaVvsx8np9d/u2iqtX4nexyAZgAEBdBGAAwE6Vo4BjsWg0 qqLx02fO/ODFFz1pSmLPzMyMJ02hTZJ+JQPXfszs9HS2gUJZLZBorZdKBGAAQF0E YADATu70r6KTkBLJ5Lvvv+9JU+VyeXJy0pOm0CatWDQNo/Zjrl+7Ji+ZiqtL9HUn gVU0DgDoJQRgAMBOsVhMArCiQtASgT763e+8au3u3buO43jVGlpWyOfrlndWtAHY vboE4FKppKJxAEAvIQADAPagrhB0n6fbgGdmZiT5eNIU2pHPZmu/E6FuA3AfJaAB AA0jAAMA9pBIJJKplKL5uuMnTrz6+uueNLW4uMjOz44rl8u5zc3aj5m8c0fREuVK Ceh8nm8DAEAjCMAAgD1IAI7F45FIREXj0uwHFy960tT6+vrGxoYnTaFljuPk61W3 unb1qqIxh2EYJU0jAAMAGkEABgDsIZFMhsPheDyuonEPTwPO5/PLy8ueNIWWWZZV rLcC+erlywMDAyqurmmaaZocAgwAaAQBGACwh0odrEgkmUwqat+rw5A4Crgb1D0E WN0BSKJQKJiGQQUsAEAjCMAAgL1J+k2l0/39Sn5SeLUKulwu3717V9HhOmhQ3UOA 1a1/lpc+n8sVmP4FADSGAAwA2FsikYgnEqFQSEUG9nAV9NzcnF4zfUG1Yj5v1TwD SdH6Z0m/ct3K9l82AAMAGkMABgDsTdJvNBKJxmKKJoG9WgW9urqqbnktGpHLZsv7 n4Gkbv2zBGC9VNINQ1F9aQBA7yEAAwD2lkql+gcGEolEl6+CLhQKS0tL7beD1tQ9 A0np+udisSjZm0OAAQANIgADAPaldBuweOe996T9NhuxbXtqasqT/qAFtUtA67r+ 3e3bii7NBmAAQLMIwACAWsbGxxVtAxbHT5x49fXX229ndnbWMIz220ELapeAnrxz R9H6ZHcD8OrKiorGAQC9igAMAKhlaHg4pmwbsFelsNgG3EGSb8393324cunS4OCg iutKAC6VSpsbGyoaBwD0KgIwAKCWdDqdSCbVrYI+d+GC/GqzkWKxuLi46El/0Kx8 NuvsUwFrcWFhbXVV0XUrG4ALhVwup6h9AEBPIgADAOoYP3RocHBQUQaWlj/86KM2 G+E04E6pXQFL0elH7nVt215ZXlbROACghxGAAQB1jIyMRKJRdZPAb7z11pGJiTYb WVpaohiS/yzTLO7ztOdyuRllxckkABu6vr6+rqh9AECvIgADAOrIZDKxeFzRVF6f R+ch5fP5ZeYDfVc5hrdU2vOv1J1+1FfdPV7SNDZ+AwCaRQAGANR36PBhRaWMXO1P AksimpqaYhW0z4r5vGVZu/9c6fRvX/Xsq2UOfwYANI8ADACob2R0NBKJqFsF7ckk MKugfVZjA7DS6d/K+mfDWF9bU3YFAEDPIgADAOpLZzJxlaugHcd58+2325wEpha0 zyzLKubzu/88l8tNTU4q/W7RNC3H+mcAQPMIwACAhowfOhQKhdS13/4kcLlcnpqa 2u9IHnhuvw3ASqd/+6rBm/rPAIDWEIABAA0ZHh6ORKPqpvX6vNgJvLq6SmEk3xRy Odu2d/yh6t2/juMYur6xsaHuEgCAHkYABgA0JJVOJ+LxAZWlsNo/E9gwjNnZWa/6 gxrKjrPnImR1Z/+6HNsualo+l1N3CQBADyMAAwAaNTo2Fg6H1ZXCEucuXJBf7bQw Nzen67pX/cF+TMPQisUdf7i4sLC2uqruouVy2TRNpZcAAPQ2AjAAoFGZoaFYLKZ2 fs9xfvP737fTQi6XW1lZ8ao/2E+xULBMc8cfXrl0SelxWZXjf0ul7D6lpwEAqIsA DABoVDKZjMfjoXBY6VWGhod/9s47LX+6ZKTp6WlKYSlVOQApm+178NTlmzdu2Hud CewhidyapnHYFQCgZQRgAEATfCiF1f6RSGtra5tMEqpkShB9MIWqPvqoj/JXAAAv EIABAE1IpVKxeFzpeUiuX//2ty1/rmVZ09PTHnYGO0j6NR9c/6x68XNf9WUtaVp+ r5OHAQBoEAEYANCckZGRSDSqtBSWOHT48Jtvv93ypy8tLbFQVpHK+ucHJ9i/vX3b UFx4TC4ql1hfX1d6FQBAzyMAAwCak85k4rGY0vOQ+tpeCK3r+tzcnLddgmtH/Wcf Fj/3VU8/0kqlPQ9eAgCgcQRgAEDTRkZHo9GoDxdqZyH0/Px8qVTysDNwFfL57cWu fFj83Fd9R2N9bU31VQAAPY8ADABomj+TwH3tVYTWNG1hYcHb/sBxnPy2aVgfKj/3 Mf0LAPAOARgA0ArfJoFfeOmlk6dPt/a5s7OzhmF425+AK2na1nbftdXVRV/eYmD6 FwDgFQIwAKAVmUwmGov5sPbVcZx3338/lU638LmFQmFpacnzLgVWuVzOZ7Pl6vG/ Ekpv37ypeutvX7X4s0TuLNO/AAAvEIABAC3ybRK4r9XNwBLV5ubmmAT2yvbyV/5s /e1j+hcA4CkCMACgRZlMJhKN+nAmsEgkk+++/34Ln8gksIfyuZxj2/LB9WvX3Hlg 1Zj+BQB4iwAMAGjd8MhILBbz51rHT5x49fXXm/0sJoG9YplmsXq08uSdO9uPQVKq VCptcPYvAMA7BGAAQOvSmUwkEgmHw/5c7tyFC/Kr2c9iEtgT7ulHiwsLa6ur/lzR NE3DMCj+DADwEAEYANCW4eHhWDzuz7Ucx3nplVdaKAo9Nzen369djBZYllXM5yX6 zs/N+VD4ylXStI2NDX+uBQAICAIwAKAtqXQ6Eg5H/KqGJRn4zbffPjIx0dRncSZw mwr5/Mb6+tTkpG/p19B1wzTzuZw/lwMABAQBGADQrszQUCwW8y0alcvl//j5z5s9 GGl+fr5UKinqUm+zTHN9be3WjRv+lH3uq77NIS9WdnPTn8sBAIKDAAwAaFcymQxH Ir5Vw+prKQPruj43N6euS71Knur11dXr1675ln77qrWvTMMoVGtuAQDgIQIwAMAD PlfD6mspAy8tLZGpmpXLZi///e9+pl9qXwEA1CEAAwC8MTQ8HPerGpar2QwsyWpm ZkZpl3qMVix+/eWXfqbfvuqG7U1qXwEA1CAAAwC8kUqlwpFI1K9qWK5mM/Dq6mqW qcXGlDTtqy++8Dn96rpuGkY+n/fzogCA4CAAAwA8k85kYrGYz5GpqbORbNuemZmR T1Hdq4NucX7+u9u3fSts5pJXp1QqsfgZAKAOARgA4JlUKiXpN55I+HzdpjLw5ubm 2tqa6i4daB1Jv33VFdeSgZn+BQCoQwAGAHhJMnAoHI7FYuVyub/f158yx0+cePX1 1+s+TDo2OztrmqYPXTqIrl+96vMWXPdbpVQqWaZJ+gUAKEUABgB4LJ1OR2OxUCjU kUv/+3vv1X1YsVhcXFz0oT8HzldffGEahv/XtSxLL5VyuZz/lwYABAoBGADgsVQq NTA4GI/HfZ4BdjVYFmthYUHTtNYu4X5dcqHtf2iapqQ427LkA/m98nGVc+8/1f+a 5kB1g3T/gPx3cLD6e/WjilAoJP8Lh8OVj6oftNa91pQ07esvv/R/2XNf9ZmU18Jh 8TMAQD0CMADAe5WF0KFQzN9TkbY4jvPcD37w5NNP13iMYRizs7N7/pVkV0mDpVJJ 13VDfhmGVQ23ktOkZfmffCAR175fSav/Pm+/ivJ9967R1zcgvw8M3AvP1cAcrp69 HI3FotGoPNstVyCbnZ6empzsSPrtq2ZveXpJvwAAHxCAAQBKSAaORKORSKQjV5fc mEgm3/vgg+1/aJpmVmxs5HK5QqGwsb7uVl2SNOvcj5oSAjsyce2J7Zm5v/qVSFYO V3Ny5XyqaDQej8vTIr8PbMvJX37+uST8Tn3VhtB10i8AwB8H9Wc8AKD7deRUpO0c xwmHw051BXLf/anaTnWme2zlZAnJ8n86NfHbx7lHAADfMQ4AAKjS2c3A6HJs/QUA +I8RCQBAraHh4XiHNgOjm0n69fm8JQAACMAAALVSqVS4ugW10x1BF9F13TQM5n4B AD4jAAMAlEul0xKAfT7XB13LNE0JwHlO/QUA+I4ADABQK5lMDgxUju6RDNzBekvo Eo7jmIZhO1W2XSwWO90jAECAEIABAB6r1L6qHlc7cP/EWopgYU/VCGw7djUOV89Z ZlE0AEApRiQAgLZI3K0cLuTGXfkVCjHNi9ZUI/C2SEweBgB4jQAMoGMqwamamtz0 dO+MVhkCu+eU3p8RcqonuDIO7h7ywvXdC7z3JnhJvFBhKw+LMnm4y1TuA31999Z6 VG/i907Z7u93T5neuoUzsQ+gqxCAAfhNhk2DoXsaXBkrw1/Lstx5IQZSHeGuah6o hl3meNER9/Kw3AqqYZhY1RHu4d5CbuDyeyOfIi+cVSWvHS8ZgI4jAAPwTzqTCVe1 vCO0MpAyTTcMM5BSyl3Y7Ibexke6gG/cWLW1XpobglKVNy6rt4JQezdwsyqXzXrb PQBoHAEYgB8k+kYiEQ9PwXELycrwN8dJKt6plGuurmd2R7pM8+KgcCeH5YbghmH5 v+Rhr6TT6UrsjUQ8vCFIBjYMgxgMoCMIwADUSqVSknsj0aiKOsDMJ7TP3YntLmxu fFE60M3+uWnCcThtuGXtr9mpQe7ehq7L3Zu3KgD4jIEOAIXS6XQsHvdh9WxlNoEY 3LCt8mPy0iga3QLdYGtmmAoCTams2am8cxlRfSF5XUqaxkIeAH5i0ANAlczQUDwe 9zNcGVVM+OzH3cXnzvSyvBlBI2F4a2aYAlr7SaXTkSrfriivi6Zp2c1N364IIOAI wACUGBoaivmbfl0yltJ13WJZ3X33Vjjfi72hTncH6Ar3poWrBaV5y8wl94pQOBxV s12lNrlvlzRtkwwMwBcEYADe61T63SKj21KpFOQVj0z2Ao1gWrjv/slGsVisg/cK MjAA3xCAAXgsnckkEolu2FZaKTSq64HaXZZOp2UgG64eVdLpvgAHTKW2vGkGbbew 3DQi0aiHJfpbJhm4WCxSygGAap0foQLoJalUKpFMds+Uo7si2jSMQqHQ6b6o4h7Y W5nuDYdZ5Ay0z10g7R6q1MNJOJlMhiORjqx53o8888VCoYefcwDdoFtueQB6gAyn YvF4N8wk7CCDKk3TemxiYWtzrzzhPtTZBgKoXC5XcnB1WrjHUlk6k4nH493zZuUW 0zRLmtbDb1kC6DgCMADPjIyMRGOxTvdibz1z5iS5F/Cfm4TlBtIDc8JKz2b3hF4q ra+vd7oXAHpWl977ABw46XQ6kUx27YjKVTlzslQ6oFPB8gxXcm8kQu4FOkWSsMRg icLOwayYlc5kYrFYl99DKpuBC4VAlW8A4KeuHqoCOChSqVQ0FuvCxc+7HbipYLee cygcPhBPLxAQbsUsy7IOSu3o7p/43U6eW71UOhBPLIAD5wDcBAF0v8zQUCKR6HQv mtD9U8GVg0kGBirlnCORAzFgBYLJXRptW1Y3p7UDMfG7Q7FYzHIqEgAFGFQBaFcy mUwkkwdraNXXxQWiJfq6uffAPaVAYG0tjbZtu6tuKV1Y6rlB8kwWC4WuejIB9IYD djcE0IWGhobiB2r6dzvLsvRSqRs2m92b8q0udT5wQ1UALoltpmFY3TEhnE6no7HY wT0dTSsWN5kEBuA1xlgA2iKxTdLvgZ6rLJfLpVKpgysYK7t8Q6EIU75Ar3AnhEWn dgi7d5VYLHag302zbVsycDe8lQCglxzg2yKAbpDJZBLJZKd74YFKzRVdz/s7FZxO p0MSfQ/g6kTsyXGcvmr42foT95XtHxjor/4u5G/lY0f+4zjyuPI+n9KFB7SiBW4M 9vnwpFQ6HY1Ge6NsXrFQyHZxsQYABxFDLgBtGR0bi0Qine6FNypTwZpmqx+qumf5 hlnt3MWq+dSRV6caWgcGQ6FwdWO2qJzAHAoNVP9OHhmqVtaNRiLygYep1S0ybOi6 UWVV95datu2mKfdj+UAeVq7qq2Zmvp26k9xV5EX0YZmJWzQ+Fo/3zHeCPG9rq6ud 7gWAntIj90cAHSGDraRkuV4ZabkqaUPXFY1TKxt9BwclQoV6YnLmIPpnXJSgUH0b QtJrNBaLJxLy6qRFJuNOoG3/LMmZuq6XquSD7RO2XUXisVYslrQK6W7lxK9qkeJK VK5+4f33dbqnQSTfRe57GepuL5HKWzE98o6kS75pC/k8q6ABeIgfgQBaNzQ8HI/H O90L78k4VXKOtydwuDMzMjxlo69q9yJuf3/lCQ+FJNwmkkl5/uXbdWR0VH41+BLY tr099Krutm8qaxxyOUkUWqGgV780S/7Istx4zNJr1Spz+9UqWd7W3ssMDcVisZ58 +TRN29zY6HQvAPQOAjCA1o0fOnRw64vW5R6S1P7MQzKZrKySpcaV19xVyvKsVmZw 4/F0JjM8PDw2Pi7fli3vfnQPiHYZhuFthw8E0zSzm5u5bLZYLOqaZlbP9ZGnmvXV 3pKn1J0Nbj8Gp1Ip96AjTzrWhSzLWlle7nQvAPQOfpgBaFEqnZaBV6d7oZYbh3Kt lmBh1tcrjm1Xlo5HIolkckhS7tiYpNyR0VFPIpkMr7dCr+S99hvsSfISSFSTfwvu 1HFlR6ttM2PcpvZjcDqTicViPX+HqayB7oLD6gD0BgIwgBb16vrnHWSE6k4FFwqF xj/L3esbJfo2z3EcyVTy1CVTqeGRkfHx8YmjRxNeHzQtQXcr9EoA9rbx4JB/HVqx uLG+LvmtsqC6WueJVNysSgyu7tZuKuMlk0l34jcIM/Osggbgod6/aQJQZGx8vDeO 2WhEZSpY0xqZpalE34EBGZb28OJwr7ibdQdDoXg8PjQ8fOjQoWPHj8sHii63FXq1 aq1vRVeB4zgS5NZWV/PZ7L1J9XJ5gHeC6mmqRFY6nY7F48F5f02+i1ZXVjrdCwA9 ggAMoBU9Wf+5tspUcHW2sMbwNJ3JuMfk+NmxA8Sd3ZXvnNHR0YmHHjp24kQsFlN6 RXd5syReZno7yD1gTALM5sZGsVAwLaufg4734di2XvPAJLn3hqql3YJ2+6UWNACv BOjuCcBDmUwmkUx2uhcdICFKYvDuqeBUOh2pngfbkV51J/e4oUgkMjQ0NH7o0MOP Pjo2NubDdW3bdhOv/E7o7U7yGkkYlkicz+XkH5T7zkigEl1t8n1rGIaz60zydDot 0TeYq0uKhUK21XIMALAdP2wAtGJ4ZET13F3X2jEVXJmQqZ4ly/DdXdIs3xgjo6NH jx179LHHon59k7gnV1WPv9UoZHXguHuJFxcWJBXL6yjBLziLe2swK4eSG+7bbcGc +N1OvjE21tc73QsAvSCgt1EAbVJ6AJKbo7p8haQ7FSyD0WgASrDWIMkzEokMj4w8 dPToY6dOeV6tqga3gq4bemVw7Nt1oZq8svlcbmlhIbu56b6yXX43UMctwmfbdrTr ywpUjsvq6wspuxlyGBIArxCAATRN9Qbgl3/4w+MPP/zVl1/evnmzm6c7ZGzazd1T pLquubLbeWJi4tTjj4+MjPjcAbeWlZt7JX77fHX4z7Ht9fX1xYUFScWWaQZwsXSX 32os25b7wNFjxzY3Nhbm5xVdhW3AALzSvfdTAF1Lwk9S2QZg27Z//dvfunOqMuL5 6osvbly/Htj5ny4hOTMcDg+Pjp44ceLk6dORSMT/Dmj3sa034CQFLc7Pb2xs6MGe HO4Gcrt29zts5fMrly6pWxFTKBRaPpUdALYQgAE0TekG4EQy+fKrrx46dGjrTyTw /Pl//mdudpaRrp/c0CsvxMkzZ048/HBHJqBM0yxWscIZezJ0fXFhYXV5WdO0/qpO 9ygo5P6QSCQeeeyxHbflb2/flhdF0UXZBgzAE/yoANC0Q4cPq3uP//QTT4yNjz/0 0EM7MnY2m/3Dxx9rxSJjXHVkUBsKheT5f+zkyUdPnuzIOw6VI3NKJQm9lLNCU+Tb ZmFubm11VZcwHLxl0r5x12M/durU7rdB5c+1UunO7duKLm3b9vLSkqLGAQQHPx4A NO3IxISiwaUEsJdfe00+CIfDx7Ytq9ty68aNLz//vJ+pYO+4e3qHh4dPnjlz6vTp ThXakaGtO9krudftEtCyYqEwOzOztrJiU1DaU7ZlTRw9Or5thc52g6FQMpX67E9/ UvTemdwZFhcWVLQMIFAIwACak0qnU6mUosZl2PT8yy+7H4+MjEgq2/0Yy7L+8PHH qysrzPC0o1K9ORp96OjRc+fPD+31PPtD13U39xqG0ak+oFdVSihrmkSmlZUVvVQK YPUsD8mTGYlETp4+vV+4lec2nkyGQqEvPvtMXXW6ShWsXcewA0BT+EkAoDkSSmPx uKLGR8bGHn/ySfdjGU4dO3YsHA7v+ciZ6ek//b//x3C2WTKKlbgro9gzjz/eqZmx rUXOgopWUM22LK1YdOuorSwv57LZsuMMMC3cDNu2Tzz8cI13yrbSr3x88/r19dVV RT0padrGxoaixgEEBGNHAM0ZGx/fL5S276lz5zJDQ1v/Nx6PT0xM7PdgGZP94eOP ZURLDK7N3bM3fujQuQsXJh56qIPdkARSKBSK1TTSqW4ggCrvuRSLW1vKLctaXVlZ W11lgXRdlYnfaPTkqVO1VzW7i5/dj7Obm99cuaKoP/IiymunqHEAAcGoEUBzDh85 omh/lwxGX/nRj3Ze7vDh2kcuTd29+8kf/0gG3k1GrgODg5J4Lzz7rP+n9W7vBrkX 3cAwDInB2/9E7jkba2srq6umYZCEd5Pn5/jDD++5FWW77dO/rk//+EdFz6fcQ5YW F1W0DCA4GDICaEJKpNOqWi+XX3z11R1/JqOo48eP147c7AreTgKnPGnHTpx49rnn 1B3X3Eg3yL3oNpLoKsuhbXvHn8u368b6+vLSkkESrpInJByJnNp/x++W3elXfP7n P/cpuxvnc7l8Pq+ocQBBwGARQBMyQ0OJREJR43vOAFcumsmMjY3V/fQ73377l08/ DWwGrqxzHhh46OjR733/+/KMdbAbpVKpUEXuRReqfItqmrlP0TX5pl1fW5MkbFlW YJOw3IqPHjs22sBdt+/Bxc9b1M0Ai2KxmN3cVNQ4gCAI6EgRQGtGRkej0aiixgf6 +59/5ZU9/+ro0aONXNcwjI//67+y2WygYrCMVsfGxyX3Htl/v7QPdF3P5/OSe+1d 02tAtzFNUysW+/Y/cEsCsMTg9dXVcrU6vZ9966DK+pFQ6PTp04ONHYe25/Sv+OLT Tx1lh5nJrWZ9bU1R4wCCIEBjRADtO3T4sLr39Y8eP37ikUf2/KtIJCIZuMFY+83V q1//7W89P2Z1HCcWjz/51FNPnT3bwcAvOSFftVVhCDgQKnWhG3i/RnLywvy8fId3 6ohs38hTcfjIEfnV+KfsOf0rpu/enZuZ8a5rD5B+Li8tKWocQBAQgAE0SukJwOVy +YVXXqmRWkdHR4e2FYiuTcas//2//peu6x71rrvIwP3YiRPPv/iiuuXojfShWCzm crlSqdSpPgBtqhwUXCoZDdwo5JFrq6tLi4vynd+rb66dfvzxpir87zf921e9P/xV 5YYUTgMG0A4CMIBGSf6M+74BeEvtY4H39LcvvrjxzTc9M1qVIXgsFjt7/vzWUckd IYlXcm+hUCgrW+II+KnucujtSppWmRDO5RpcJNz9JKwOj4wcO368qc+qkX5dSrcB y+u1yTZgAK0iAANo1OjYWCQSUdX6XiWgd5D491CTx9iur69//N//vbvo68EiI9RD hw+/+MorHaxuZdt2ddIlx1Jn9J4Gl0Nvf/zy0pJ7CPmBrjggX8jJU6daeGdzv8XP W5QWgjYMY211VVHjAHreAb5rA/BTKpVKJJPqZlMffvTRh44dq/uw8fHxdPPnMP3x //7fmenpgzgVXC6XT5058/3nn+9gQVpN0yT3FotFpnzRwxpfDr1ddnNzbm7OtqwD d3uR6Cu39MdOnmzhc+tO/4r52dmpyckWO1dPZQtGocBhSABaQwAG0JB0JqPuUNm6 65+3yCjz2LFjLVSjmZ+b+58//KH5rnWGjMXlazz/zDNPPv10p/ogQ0wZX2azWaZ8 ERxNLYfeIp8yOztb0rSDcnKS3HIfefTRdEsrShpJvy6lq6ALhUIum1XUOIDeRgAG 0JDh4eFYPK6o8cFQ6AcvvtjggxOJxJFm6pRukUT3fz7+eGVpqZuXLEr0jUaj8mw8 vE9BbB8YhiG5V9IvU74IIMe2i8ViC/sm5B/O7MxMIZ/v5hgs/6gjkcipM2davg3W Xfy85cvPP7ctq7Wr1FXStI2NDUWNA+ht3TsKBNBVxsbHmypA1ZTDR448dvp0449v bSG0uHr58j++/ro7Fyu6Na5efvXViSb3OXvYAU3TNjc3KeyMgJN/C5KvTMNo4XMt y5IYnMtmuzYGR6LRhx95pLX7eePTv+LO7dtLi4stXKURpmmurqwoahxAbyMAA6gv lUolUylFE6cy1nzu+edlTNb4p7S2EPqvf/nLt7dudeH0b8ejL6udgd0kAFeWQ7f2 uaY5JzE4l+vOGCy9euSxx6LN3HX7mky/wtD1r774Qt0PjkL1BHIVjQPobV03EATQ hTJDQ+qOnHXK5Zfr1X/eLR6PT0xMNP74v3z66Z1vv+229Ovu9X3ltdeaPYPEK5Zl Se6VYbpk4I50AOhmtm1rhULL/zokBk/fvVssFrswBg8MDDwqGTgWa/xTGl/8vOWz P/95QNldV57YLIchAWhed40FAXSnkdHRZucKGheLx5957rkWPrHxhdDdmX7F959/ /swTT3Tk0jI039zcZKMvUFtla0CxaLWxOKKkaRKDDdPsts0XlQx88mSD9/Zmp39d //jqK/nyW+pdfbqur6+tKWocQA/ruuEggG6j+gCkE488crSl+U8ZkB07dqzuTrZP /vSnqcnJrkq/juM8/sQTjdf98paMGiX6FgqFjlwdOIj0Uklvb298NpudmZ6WPN1V 9yK5sT/y2GOxevPAraVfMTczI+G/1d7VwWFIAFrTRXdhAN0pnU43u+ytcTKCefGH P2w5XUej0YceeqjGgPKTP/5x6u7d7hlxytd7ZGLi9TfeCCmrKFZDqVTa2NjQlE3I AD3Mqp6Q1OaKiSWxuDjYTVPBjWTgFhY/u+SO9/knn6h7/1Tiby6XU9Q4gF7VLYNC AF1L6QFIMpZ86Yc/bKeFkZER6eGef9Vt6TcUCr3x1ltj4+P+X1qi7/r6OuWdgXa4 U44tnJC0nW3bU5OThUKhezYG194P3PL0r+svn3yi7hbMYUgAWtAt40IAXUvpAUiZ oaGnzp1rs5GjR4/u3sb25eef37p5s0vSr4ybz54//8z3vuf/pYm+gIcqJyQVi+3X S8/nctNTU+WuWRE9GApJBo5EIjv+vM30K765ckVdqSoOQwLQgq647QLoWkoPQBKS fiUDt9mI5HPJwNtX2V29fPnS3//eDSNLGeCOjI7+5Kc/3T2yVI3oCyhi6LontZ3m 5+dXlpdD3TEVHI1GH3700R1Zt+XFz1sk/UoGbq9r++IwJAAt6PzoEEA3U3oAkm3b r/zoR540JUH90KFD7sd3vv32M5W7zhong7MfvvaajCl9vq5hGBJ9i60eYQqgLsuy tEKh/SLq8q9VblnSWjfcshLJ5PETJ7bWZrc//ev69I9/VLfem8OQADSLAAygltHR 0YiyA5BC4fD3X3jBq9YkAEsMnp+b+8PHH3d8c50Mi8fGx3/y05+2P3ZsimmaGxsb zIcAPnBsu9jGKcHbLSwsLC8tdXwqWG5cQ0NDR48f76/yJP2Kv/31r+2cI1Wboetr HIYEoBkEYAD7Un0A0sTRo4889phXrclwLZFI/O//+q+BLhhE+j/xa9v2+vo6BVEB P1VOCS4ULMtqv6nKVPB331mdPi5Y8vzY+PhDR496lX7F3Tt3FubmPGlqNw5DAtAs AjCAfaUzmWQyqahxGTj+4MUXPTwNSAaOX/zlL50dO8oXNTw8/NOf/czPiV8Z/2Wz 2Y2NjfZXYwJolvy700slQ9c9aW1+bm51ZaWza1hs2z524oSH707KzfnLzz9XV5Sh UCjksllFjQPoPQRgAPsaHhmpfThkO2TU+NKrr3rY2l8/+6yvowlQRo3nn332wjPP +HbFSgGYQmF9fd2TCSgALfOqLFZftUD03clJdxGyJw22wHGcJ8+eHRkd9arBv/z5 z+q+nMoJ5+vrihoH0HsIwAD2lkql4omEuomIVDp99sIFr1r7x1dfeTX6bNm//Nu/ eTherEvGfGtra7pH804A2uRVWay+6ntbt2/dklDdwSUt/QMDZ8+fb7ME9Jarly7l lW3QsG1bKxZZBQ2gQQRgAHtLp9NeDX329MTTTw+PjHjS1Lc3by4vLXVqtsQ96Ojt n/3Mt6GqjPYk+jLaA7qNh2Wx+rpgOXQsHn/q7FlP6iBurK/fuHat/Xb2U8jnqYAA oEEEYAB7Gx4eltGPosY9PABpaWHh21u3OjVPIiPds+fPP/O97/lzOQnb2Wx2fX2d 7b5Ad5J7glYoyC3Ok9Yk1E1NTnZwHnhkdPTU4497EsKVHoZU0rSNjQ1FjQPoMQRg AHsbP3RIXSWncCTy3PPPt9+OVix+/eWXnZohkZHu6z/5ybHjx/25nKZpq6urprLT RAB4olIaulj06uAf+Sd/++ZNabMji1zkuscfflh+td/UV198YRpG++3sybKsleVl RY0D6DEEYAB7SKXTKZXrn4+dONH+iEpGZp9/8kmnVj4PDAz8+3vvqauSvZ1t2xJ9 C4WCD9cC0L5KaWhNM7zLe7dv3dJLpY5MBXtVEGtmamp2etqTLu0pn8+r22YMoJcQ gAHsYWh4OK5s/bMMp1545ZX2p20vff21Vix60qVmpdLpn73zjg8zzzKMzuVy6+vr Xu0qBOAbiazyy6vWZqanN9bXO7LgRYL32QsXEu2932fb9l8//VRdhtc0bZNV0AAa QAAGsIfx8XEPT+jdqb//xVdeabON6amp2akp/6d/JZFOPPTQG2+95cO1DMNYWVmh zjNwcHl4PJJYWlyUXx3JwOlM5vEnn2zz54LSw5As05QbpqLGAfQSAjCAnVSvfx4d Hz/zxBPttFDI5//x1Vf+jwIl/Z46c+aFl17y4UIbVaovBEA10zQ17/YvrK+tzc7M dOTud+zEiROPPNJOI9cuX85ls151aTdWQQNoBAEYwE5K1z/LKOp7P/hBNBZruQXH cT7/5BP/98LJdS88++w5784u3o+u6ysrKx7uHgTQWZZpFr3LwJLyJr/7zv8MbNv2 U+fOtbMZuFAoXP76a3WTwKyCBtAIAjCAnZTWf3bK5ZdffbWdFq784x8F34/AdWxb uv3YqVNKr1Iul9fX1zc3N5VeBYD/LMuqZGCPDjArlUrf3brV7/v7gIOh0Nnz5+OJ RMstfPanP6l7+5Ja0AAaQQAG8ADV65/TmczT58+3/OkyuLl944bPW38l/f7wRz96 5LHHlF5F1/Xl5WVOOQJ6lV3NwF4d4m3o+q2bN/1fCzN+6NBjp0+3fN1LX32lebcp ejdWQQOoiwAM4AGq1z+fvXBBMnBrn27b9ueffOLzwj/HcX742mtK0688LZubm+vr 6+ouAaAbyE2smM97m4H7qzxpsBHyJTzx9NNj4+OtffrSwsJ3t2+zChpABxGAAfxT KpVKJBIDyhKmDPteamP989//9jcPzxRphKTfH73xxvETJ9RdwqxWLi35+3UB6BRv M7DcQG5ev+5zBh7o7z/7zDOtnYqkuoShbVmSgfO+b5MBcIAQgAH8UzqTSbZ30mNt Q8PDT54929rnLszPT377rc8THa//5CdK06+M0iT9ejUUBnAgyL2lUsjA0wzs81ro kbGxU2fOtJBj5Qu/fu2apXKvR6FQUFprGsBBRwAG8E8jIyPt1Geu6/mXXmptetn/ xc+O47z0yisnT59W1/7q6irTFEAw2ZblYTG/Uql0+9atQR8zsNyTH3/qqfFDh5r9 RPmq11ZW5mZnVfTKpZdK7CgBUAMBGMA9SZFKqZtGKJfL//H++8stlei89PXXWrHo eZf2I109/8wz6k48MgxjaWmJeldAkFXqQnuXgfO53OSdO36+SyjXOnvhQrMVoSUA S/i/cumSuq46jiNXKXh37hSAHkMABnBPJpNpbU9Xg0ZGR19+9dXV1dVmP3F9be3G tWu+LX6W9HvqzJkXXnpJUfvZbHZtbY1lzwC8PR9YbpUz09PqDrHb7fDExKMnTzZ1 c3YD8K2bN5WugpZnNcsqaAD7IAADuGd0bCwSiahr/0dvvCEBu4WVaZ/9+c8DPm79 nXjooR+/+aaKlln2DGAH0zA8XN6ytLgov3ybB5Z72tPnzw8NDzf+KW4Azm5uzs7M qOuYYRhrzb/ZCiAgCMAAKlKpVDKVUjfLWi6XP/rd7yT+Nfuu/M3r19d9HMdIRH/3 /fdVtGya5tLSkgzLVDQO4OAydL3k3dG4U5OTcpv1LQPH4vGnzp6NRKMNPt4NwPLB 5UuXQipPHChUTgTm3UYAeyAAA6gYHh6OKTv+V4yNj//0X/91eXm5qRGJDAq/+uIL 30Zy/QMDv/zVr1RcrlgsytfuOI7nLQPoAXKvkxjsVWu3btwwDMOfutASNR85efKh o0cbfPxWAL5965ap8g1BeUo3OBAYwF4IwAAq07/xREJdzpQR0ps//enhiYnFxcVi M4v9/vb551Z1qOQDSafv/eIXKk6BkkEYJUkB1CA3yVKx6GFhvG+uXpU2fSudcO6Z Z5KpVCOP3ArA+Vxu6u5ddT20bVsrFpkEBrAbARhAX2ZoKNFkJc+muOuf5YO5uTm9 4VmO1ZWVW9ev+zOAk/T7xltvNT6J0SD5wldWVhiBAahLbhcS1yS2edKaZVk3vvnG t8OBDx858uipU43crrcCsFBaC7qvuvQmu7mprn0ABxQBGEDf2NhYWGX5q4mJiR+/ 9ZZ8MDMz0/gUx18++cSfO5SMO586e/bZ557ztlkZyC4uLjYe+AEEnHt+T9mjvRKS /e7evatun+12crs7/+yz6Uym7iO3B+A7335bKpXU9co0jBbOHQDQ8wjAQNCl0ulk Mqm0/NW/vfvu0NCQfCyjsQb3wU5NTs7Pzirq0g6ZTEZ66G2bhmFI+vVt/TaA3iBJ spDLedXa9N27m5ub/pRRSA8NPf7kk3UPYZK7olYouOfASfr97vZtpT99CoVC3rvn E0BvIAADQTcyMhKNxdS1L2OvDz/6qK86FpmcnGzkUyQkf/7JJ74t3pPueTtAlFGd pF9KXgFogWmamneHA9/85hvTsny4nUp0f+rcuZHR0bqP3D4JfPXyZaV900slSjAA 2IEADASa6tOPxOkzZ37w4ot91Tf+p6enG/mUb65c8WfjlmPb//LOO2NjYx62WSgU lpeX3fkNAGiBxDbdo7XBjuN8c/WqP+8nRqPRp86fj9Y7Eml7AJ6dnm72bLymcB4S gN0IwECgqT79SMZeH370UTgc7quuCp5tYFWz5OS/fvqpD2v2VGz9lZEcW84AtEnu TlqxaHlUFHpzc3N6cnKw3uLk9skN/8yTT44fOlT7YdsDsG3b169dU5rPOQ8JwA4E YCC4UqlUIplUOvKIJxLvffCB+7GmaQsLC3U/5eo//uHPu/WxWOznv/ylhw1y3BEA r1SmLnM5r3ZS3PnuO4mdPryxGI5Ezp4/X3tbzfYALL65dq1P5ZIZeQ6LhQKTwAC2 EICB4BoaHo6rnP4V33/hhTOPP+5+LOOP5eXl2o83TfOLzz7zYZTm2Pb7Fy96+OVL 9GWSAYCHvC2Ide3KFfld9cFykttPP/74+OHDNR6zIwCvLi8vLS0p7ZWmaZvcnwHc RwAGAiqZTCaSSaVR03Gc3/z+91v/d3Nzc21trfanXP7734veVX/ZjwzRnn3uuafO nvWqQfm6NjltEoDXDF0vaZonTeXz+TvffefDqUiDodC5Z56J7T8JvCMAi8v/+Efd 8tHtsG1bfrIU1P9wAXAgEICBgPJh+vfo8eM/+vGPt/5v3ZQoQ72//fWvPhRrSaXT 77z3nletkX4BqKMVi6ZheNLU3cnJXDareolNuVw+eebM4SNH9nvA7gA8+d13mkc5 fz9MAgPYQgAGgsiH3b+O43xw8eL2SYClpaXab8D/46uvvJrrqN2xX1y86NXJT6x8 BqCUt5uB/VkIPTA4eP6ZZ/arsLg7AJumefP6ddU/ktgJDMBFAAaCyIfp3+3lr1zz 8/Ol/Q/2MAzjb59/7sP075NPP+1V5WeqXgHwgcTFgkfJbXNjY3pqyodJ4Bo7gXcH YHH92jXVp8cxCQzARQAGAseH6V/xymuvPfzII9v/ZHp62to16Nly9dKlvHflXvYT Cod/+atfedIUJx4B8I2HJwPfvnVLmlL9IyAciZy7cCGy15nA8oNAKxR2xN2N9fX5 uTmlXWISGICLAAwEzvDISI3yJF759W9/u+NPJicn93uD37btzz/5RPWkhIx+/vXf /310bKz9pgqFguqypQCwRW6eEt52T5y21tTVy5d9uN8+efbsyOjonn9bzOd3vx96 5dIl1b0qlUobLNsBAo8AjIpUKtU/MNC/XV91k5D8txpZ3NxS3s5xeBv1IEqn04lk UvUGsJOnTr3w8svb/0QGQ3fv3t3v8Te++WajXoHo9h2ZmHjjrbfab0eGUAsLC6pX 6wHAdnIXrSyT8eLOMz83t7qyojptxuLxp8+fD4fDu/9qz1XQM1NTOcXrgNz3EVRf BSrsHqn2uQPV6n8qP5Hvj1cZqaIuAnBAVe4j/XInGZCff4OhUGs/BeWHsW3b8j/5 wJH7jG1zxkCXk9c9Go2GIxGlV5Fvh1/953/u+KYyDGN2dnbPx8sPqc/+9CcfpiMu /uY37Z+0YZrm3NycVwVpAKBxpmFoxaInTX1z9arce5W+GSojhHPPPJMZGtr9V3sG YLmvXrtyRfXPAnkOdV0nF3W5ZDIpI9SB6ki1OlQdbG3RvnwTyneaXR2pyjc8rztc BOBgcd8/k7wbCoc9/xkjd5Z7N5pKIHb6uNF0HxmIJBIJ1VeZmJj48a6J1mKxuLi4 uOfj79y+vbTPX3noiaee+t73v99mI/KNLelXMrAnXQKAZu25eLgFGxsbM+qrYaUz mceffDK0axJ4zwAs7nz7bY1aiV6Rn0dZzq7rMjJA7XMnZuRXdWLG83dnKkNU05Q0 zMwwCMBBkU6n5YYSiUR8qLLrkqggNxq7Ok3Mu27dwJ/aV7tPP3LVKBn12Z//PKB4 Sbb8UP3Vb37TZiPybfz/2TsP9zauY2+zoIMobCCpQrFT7JIoUs1d7pbjFPc4yf/2 PU+uEye5JXGPc51YEsUiqrD3Dhb0QvTCb4C1eRlWcLE7WzDvI8sShd1zsHvK/M6Z M2Oz2YIcbb8QBEGwgENH6JmpqVgsxm/yoUSi4/LlIoNh38+PEsAI+ZDyKBqWaPjR GzG9vatQKjEN1Gg0Ci2QnOFzFhLAMgcGFxhQlADPXq/HkxLDjAsKiWHhKC4pUR8W kJNbTCbTG2+/ffDnLpfLe9iKu9PhmJ2a4tUND5rcrWefra6pyfI+lPSIIAgxEI1E OEmZHolEZqen+d4ErqiqulBbu2+QP0oAAzAjgLnAa5Xy0t/dzX/gCeIg/yd6Uyfw FGii91Bi0WgsFkvShnDuQQJYtjDSV6VWZ3/okVtgoEkNN+kDGQhpbwgGHOdnkJpv 3LljLi4++E82m+3QI+IPBwY4iWt6DCD7f/Hee1neJBwOb2xscFIfgiCIbOAwIvTC 3FwoFOJbhHRevqz99wnoGAEM9Vmcn+c7UmMeOULjUmQwFKZP8yoRd3ozJB6PRyMR ksE5BQlgGZKSvoWFKpVKbNL3IOkjwz/uDNO4wx84zs+ARqP5+bvvHvpPVqs1Go3u +2EkEnk0OMhrxcBSvP3qq5aKimxuAvMi1J+Tc3cEQRDZk5o0uVhBhjl4cmKC703g uoaG8n8fhI8RwHnpAF281oeBHKH5hjFHmZ1evttY9qRkcDRK5miOQAJYbhiMRhAh 4h9o9sEE0ILRJ7UzTNGkOSUV+VmjOTQRBbfAS3zplVcqKisP/dfl5eWDkZPHR0b4 9gLQaLU//9WvsrzJUdvXBEEQQhEJhyNcxItanJ8PBoO8LkSqVKq2zk7VnjM4MN2H AoGjksn5/f7V5WWETeBYLAbPkAQPh+j1+tSR3p9EL8JL5BYwQcPhsN/nE7oiBL9I rF0SxwA6B2YXlaBnfTkBZkQmTB8dGOYEc3HxwZBUfHCM1IQZZWVlZd8PEbIfQRGv vvlmaWlpNjcB6QsCmKsqEQRBcAKMbwG/P/uUbAjJh2A2bzuQD0kMm8B56eMtHgru kB27x3qZJCOSE70HiUZTybLI/pQxkm+jRF566ClUKEDkyGDQ2QdzYJh8pFmDc/Q3 7ySpeegBWuvq6toBVcwt+qKit3/+82zuAG3ParUm+I/IQhAEcVrisViQC+eUpcVF 0NIFfGrg4tLS+sbGvTL7eAEM3wtqhWPV0GFgdux6OIvwWG/2gFUDpgs0UTI+ZYnc 9FIOYjAa1eKLdMU5uz7SjBgmf9RMMBqNWp0Ox4A4Xmr6/X6Hw7Hvh4MPHuxkvXdx DJxs/9rtdpr8CIIQLSAU41lnJkfYBIYBufPyZZ1ev/uT4wUwMD05mf3+diZA3UKg gcnrNQP0ev3eY73y23fZB5idkUiEPKLlh8wbrrwpKipSKJWgfmU/AO0D5qrUtjCI YYojfTQGo1GHpX7BRnnrZz8zmc1HfeBgDiSE8FfHROTKEIr8TBCEyEmFruXCOkcI B13X2Fhusez+9UQBHA6F5ufmcLYWU4G1g0HSOUfBxHAG1auUhYfzqYC2ARZLPBaj 1XA5kVuNWE6AvNFqtfLzOTktqW1hxkea4tfvAbl5GE2mNw/L/bvL1tYW2BZ7fzIx Nubn0+UMZqznX3rpzNmz2dxhfX39YORqgiAIUcFJNKxYLDY1OangcxNYrdG0dXbu RmQ8UQADM1NTaCdQwIoIhUKkgXdhsmkWpo/1Si60KudQ85AZJIClh16vV6pUObjx ezwgV3bSB4bjicRObothZPULs8LPfvGLIoPhmM+srq7uyyHUd/duIZ81LFQo3vvw w2zucKjbNkEQhNhIRYv0+Y6KqJw5s9PT0WiUv7kDpGzn5cu7k8XxgaAZIpHI3MwM 5nSW4yInFc6qoECRPtYLfyA7cy/MVnAsGqVTeDKAWrbEMBgMao1G9id+sySthZOp A8PxeK7tDJtMJo1WizlpVVZVvXD79jEfgFewvLy89ycOm21+dpbXWvVcu1bf2Mj6 cqjz2toaxb4iCEISgFEe+ncvGxYEg8GFuTle9/oqqqou1NbuzlCZbAIvzs+Hucj2 lCGp0EehkDeXYmL9uNOrSFFAovckUqeCw2E/nb+TONTKJUMq1HNhIbK2kQG7YjiZ Rsabw3q9PuUYsCfRIgLJnZ0PPv74eIPp4Enaxw8fRiMRXiv24SefZHM5WD8ul4ur yhAEQfBK6ggriMms1+ymJiZgouTPzAB91Xnlyu48lYkARgjQdZBIJAKTlFw3+pht XgYSvSxgVkkSlJ1EylCLlwayyfErOEw0aSaUdDItjuUxfgkVDLy9sxN+Hf8Zn8/n dDp3/wpPvf/ePV5d2mrq6q7fvMn6crC3VldXcaKPEgRBcAIoyUDW05nDbt/c2OBP bcK42t7VBRMW89dMBDCwubnp3jOJ4CCn8L8/Kt50ql4GUrzZQ7mCJQ11AAkAU4VG o6EIBHwgAz0ME5tSqVQJcSYcyv3VBx+c+DGHw7HXWWjdal1dWuKvVmBgvf/RR4qf 4qywgLZ/CYKQIpykRBofHeV1gbK0vLyuvp7JOZyhAM5Lx03En+PAKACFE5Ng+F9S vDiA9RgOh+WxSpJrUH8QNalERwqFWqOhkQsHJpJWPJ1gSfz+0kweLJVKJUgwcHg+ b9y5U1xScuIn19fXI3scnh8ODGRo8bDDZDZDxVhfDk1gdXWVTv8SBCE5kolE9qkB V5aXfV4vj2vu+fmXrlwBwybvNAI4FAwuzM8LNdlFo1GRZ8HZ9WouTHs1U/wqNFKR scJhsBvF3DyIg1D3EC8wnMEMocxiI4vIHpj5ftwiTiZ3xLFF/GOQRoUCpK+AM1zV mTPPv/TSiR+DZ7a8vLwb5xMeY/+9e/yZVlDQa2++WVJayvoOFPyZIAjpAkIxll3y NhhFx0dHeR2lWzs6jCZTXmaBoHdZWlgIhUI81epEUrvBIIPjcfGYAWAAMGmKAEqK KSyxWAxksOANg8gcEsAihdL8ihMmpFYyLYh3GE2c3isOZh1+80RScRrT85xSqRS8 YcC8+/7HH2civ8FisFqtu39dXlra3PNXzoHn895HH2VzB6gt5f4lCEKipBIfZO2Q OTM1BQY9fxONubi4obm58JRe0Hwr8wxJphMuMienEASPTqdL+TIX/Kh3C9OSl8JW iRDKoSUtqP+IDnJ7lhy7qji586MoTq1np3+Px+Ps8jdodTrm0A4Tp1FUZ3jgO778 2muWiopMPrwvAtZQf3+ST+/iposXr1y9yvrygwGrCYIgpEUkHI5klzfI7XKtra7y F1VxJy/vUne35pRe0MC237+8tCT4EjDD/8UQYc5Mpf/KLhmVJp3eMjXF5/9IwU8n eEnrSghyh5YQ1KnEhU6v12o0Sor2LBd29kjiH4Vx+ocHP5nqintnPhHPeWfPnXv2 hRcy/LDdbt+dCfj2f4b7f/DrX2dz/721JQiCkCIwxWz7fBn6FR8Fr6Gw9npBn0oA A0uLi9lnPOaJn3zC9qyDH/YxZnLP34OYZ3zitKSScofDQZnm0JIN1N/ERVFRkUar xU9mQxAZclof47W1tdhPUUnXVlasq6v81CuF0Wh882c/Y305WC0rKyvsrEa41uV0 Oh2O4PY24x2385N9U1hQoNZo9Hq9pbJyN/kHQRA5jt/ns21uBgKBSDic+Eky5afH WKVSqSsqKi0rKyktZadCs98EXl5aAhVdwNt6ZUlZWV1DA3zZ0wrgPP7jVBNENqRc /0IhWkwXOSSARYRGowFDWUPOz4RYAZn39s9/nrmKAx0IknL3r8MDA3He4j+D7fjC 7dtVZ86wvgOL8FeRSGRpYcHjcsGTycQggwei0WrPVVdn6EBOyA8mwLjg5xgJobBt ba2trIB9nEkbYAYWc0lJTV2dWq3OvJTsN4Fjsdj05CR/DRXsnK50LOhTxcFiAG0/ OzNDnYgQJ9CYw+kVKHYn4AgcSGiJCK0uBYV9JsQJjOmXrlxpaWvL/JJgMLi1tbV7 +YO7d3k1WT785JNsLt/Y2Mh8unI5nQtzc7FolN1GRCKZLLdY6hsbaR9D3kCzt9ts 9vRGHxj6jK9jXlrYwD8pFAq9Xl9eWQmNgdY95Q288fnZWWgMhay6PFyuVKnqGhoy D3Gf/Sbw5Ph4alOan5YJ36i9q4tZTmWxCWzb2nLY7dRrCHESi8XA/hGtrz6RRwJY bBQZDEzEP6ErQhD7qaisfPHll091idPp9P0UEXHDal1ZWuK+Wj9RWVn5wimrtxcQ J6uZuWfbt7bm5+byuLALE4lE1dmztfX1Wd6HEBsgG6yrqxvr67FoNJNFH2gJIG+q zpw5e/482fTyY3F+HgbA7Jf/Utuk+fn1DQ3lGbiQZL8JDHWGMZy/Vctyi6Wmrq6A lRc0sDA3tzfDPEGIBCYzSPYZuQleoYlWdBhNJtDAQteCIP4NlUr1y/ffP+1Vew8A PxkeznI74hjAyHvz7bdNZjPrO+yLVn0ofr9/amwMtArHEmVnp7Wry2AwcHlPQiCg eczNzLgcDnbrmGA5lZSVNTQ1kXunPIBBY+Lp0zxORwwY7qB5XGxvP3HQyH4TeHRk RMFbU4Rv0Xn5skqtZieAgYmxMVowIsQGqF+f1yt0LYgToIFDjBQXF6vT6QEIQgyA vfXL9947bZvct6fa98MP/Nn0IDbe//jjbO6wubkZCoWO+leQJZOjoyCSefLOgPtb KivrGxv5uDmBA7zEmakpkL7Zt3NQ0SCDmy5eJG8gSTM/O2vb3ORv0DAajS0dHcfc P/tN4OmpqThvCYGhnXdduaIvKmJxDJgBLpyamKDVIkI8RMJht9stdC2IkyEBLEb0 er1Wp6NY0IQYADPrzbffNhcXn/bCvTGlAtvbo0+e8LdUf6Gm5sYzz7C+/Pj4z7at rbnpab5tLChdrVZ3dXeT5pEia9CAlpa4bSQgD6pras5VV3N4TwIHGFKeDg9HIhG+ 9yehkTQ0Nx8TVC/LTWAY/eAXf6NfTV1dRVVVHqtjwAyhUGh+dpY0MCEGUks5wWCA EiBJARLAIsVgMOj0evLtIYQFzLjnXnzx3PnzLK612Wy708DUxISXtzVRkI7v/OpX 2RwcgHpCbQ/+HL7+2NOnMJuh9USQ4FeuXlWdJtwrISzRaHTk8eN4LMZHI0kFylIq U26ilBxeOkQjkUcPH6JN3tBIwFpo7+o6dO0M/tXv8+VlsQk8NjLCn7zU6vWtbW3Q yFkLYMDr8aytrtLSISEs0NfAWvDT0V+JQPpKvNBhYEJYQP519/Y2X7zI4lqYCVZW VuAOzF8H7t/ntGr/Rvb+zw6H4+Ck5XG7J8fG8I2qRDJ5ubtbS31fCmxYrYvz83zv PiUSidr6+qqzZ3ktheCEUDD4eHiYXajnbIDBtqW9/VBXnSw3gXn1goZqX756VaPV svaCZnDY7Vu8eZsTRCbQ0V9pQQJY1BSXlJwq9R9BcAUYIh1dXe2dnewuD4VCm5ub zJ/BfB/s6+PPNDl3/vwzzz+fzR1WV1f3JSiemZx0so1jlD1gFHZduaLT6wUpnciQ idFRMHdwvAOgPxpNptaODoSyCNYEA4Gnjx4JOG6UlpU1tbTs+/lOMun/KRo/C2Ak d9hsPK3yQMOGVg1tOy8LL2gGqKfL4SC/OUIQIpGI2+USuhbEKaCRQtQUFRWlsiLR 4RYCFzBKmltarly9yvoOe/dUrWtra8vLHFVtP1DVt955x5hOJsmOfcG6YBp7Ojyc TdgYTtjdGBG2GsShxGOxR0ND+I0EjPsrPT0KyhUvSsKh0OOHDwXfhIRG0tXdvW/p HOoWzSJj0OjTp/wFJSkrL6+tr2edDGkv61arx+0mDUwgk0wkUnmPtreFrghxCmiY EDt0GJhABqRXe1dXZ1cX6zvs83/mNQESdIwPPvkkmzvApGW325k/b6yvL83NiWTJ CR7g1evXlaR2RIbgu3zkHSBCYrHYw/5+wdUvA5jjNQ0NVWfO/N9PksntLDaBpyYm 4A482SGFCkXnpUsqtTpLL2iGzY0NAZ13iByEjv5KFJJVEsBkNmtpI4hAIZk+gNrS 1pbNTfb6PwMP7t7lzxypqKx88eWXs7kDs1kNX3z0yZNQMCiqxSawBHtv3CBjTjy4 nM6p8XFhQ84mEomLbW0lpaUC1oHYC4wegw8eiGjgSBvlWp2u49Kl3dEDBrdYNMru butray6Xi6dmD+358tWrTNSD7DeB89KRq+02Gw2bBA5g8Hg9HqFrQZwaUY3YxOEU FRWp1GqKAkrwDZhxt5599kJtbZb32ev/HIlEHg8N8acqQf2CBs7mDmtraw67fWJs rEBM0ncXhVLZ3dsrdC2IFDgJsTLhxOQ3BCbDg4PxWEzoWhxCcmentb3dZDbnpdtM gO0mVSwWm56c5K/lQ2MuLSvL40gAA26Xy7q2JoauSsibKBCJkPOzFBGjwUccBDSw VqeT+mi+69okqk02ggHezut37hSfPt/vwfvs9X9emJuzb21lXbvDgVI+/u1vs7zD t1995XI6xbxdAPbrxez25InsWbdalxcWxNNOoOleqKs7Q6GhhWZqfFzM+z/QTkpK S5tbW/PS3vushfr42Fg+b3O30WRqamkBC4cTL2iGUDA4PzcndatJlsjGFEwkEiE6 +itZpN34cgqD0ajT6aQ+XuSl5+PU/3Z28tOmpAy+kQxQq1RvvfMOJ+ln9x6pBR4O DHCyon8oRQbDnXfeYX25x+3++1dfJX7S6qIFzAWTydRCEYCFw7q6urK0JB71ywBj aXVNzVlWaboJTpgcHfViRQLPkvauLrVGE2RrrC8uLIB+5qsL5Odf7u5mJiCuNoHz 0gEOZ6em8qTwdmQPI3p3ksmdtNUntrGUBamjv8FgNvHVCWGhcUFKyOkwMJhuoOeL S0pcTmcoFMr7SQlLwpKQEzCIn6+uzjKN0F42NjbCe0Je9f3wA39r8B1dXW1sZeFA X9/83JxUpmF4Tb03b0qltjIjFRptfl6cDx8G0pr6+r3hjgg0Ukd/+/qkMmdBbcss ljNnziQSCRaX+7ze5aUlnmJBQ5W6rlzRFxXlcSqAGZYWF0G6S+U1yYYfFW+awoIC jVYLhgE0QnEOpCygo79Sh0YEKVFUVAQzhJzGcRgZDUbj62+9BfMfzK+2ra2tjQ2X 2x0Jh2GUlNM3FSfw/G/culVTV8fVDaPRqNVq3f0rmB0jjx/z9B5hKn3/449ZGGSp jd+vv2ZnBQoI9BRKA4vP5sbGorgXSqAj1DY0VFZVCV2RnGNidFRy+z8w5tfW17Nb SR8bGeFvNbOusbHcYslLb9ty5QW9Cx0JxgHeGkysBYWFWo1Gn7ZXNRoNDJ6z09Pw czlZdPBNA9vb5PwsaeTTHHMEMIL1skuAAUMJjJJv3LmzN+spSCkwPTesVqfDAaMM TIr5aQSsp5xIedWaza+8/jq3WXacTqdvj0U4PzPj2OMOzS1gzbz30UenverB/fuL Yt3NOx7QOZe6u5lYqQQOMPjMTE6Kv7VA22hqaWHCCBE4hILBJ8PD4m8bB4HWAoZE 9YULp70Q+kIsHufpKxuNxqbWVkajcr4JnJfeZJ6fnWUMCW7vnLOAFcEkxwIrQqvV QqMyGAyFe5akY7HY3PT0jhw9+wKBgOQWv4h9yK1R5gLFJSVqLs5qig0YTBVK5Wtv vgkT4aEfCIVCK8vLm+vrdpsN5DHpYdak/GmvX69vbOT2tjAXrq6uJvccqR0eGIjz dgC4sqrqhdu3M/88iPP//fZbyW387gVsi6vXrgldi1zB5/WOPX0qlV0jaNjtXV1G k0noiuQKvEY3QCDlOFBXd6qE0utWq8vp5KlH5BcUXLpyhTkGzMcmMIPT4dhYX5dK pxYbu4pXr9cXGQwms/moBfRwODw/OytXIy0SibhdLqFrQWSLDJtmLlBusch1BIcR tqCg4Parr5aVlx//SRiIlxcXJ8bGwE5l5kkpLsYjk0wkqmtqbj77LB/Pyufzgcjc +xNeMwA/+8ILZ8+dy+ST0Kh++P5769qa1FsIfJGG5uYTuwaRPaFg8PHDh9IaZvfm UyV4xWG3z01PS924hzkUlMyF2toMv0g0EpnhLQ0YtN5L3d27gpyPTWAGGEWXl5YC fn+BpHq3IEALSS1D7OwoVSowO4tLSk5sKoFAgPGxknrvOApoqHabTehaEBwgzwYq e+R3GHgfMObCtwOdlrmbFlyysb6+srwMYxPMnXKKtcAJ8ECKi4ufe+klnlzo4fmv rq7u3V8Nh0JPhof5OwCcYQKktdXVe//6Fx91EAT44jeefVboWsiceCw21N8vxQEE mkfP9esKTs81EAfhdWkPGRi0z1dXM7mCT2R8dJS/bb36pqbd1T3+NoEZotHo8sJC NBaTzXvkBEbxKpVKnV5vMpkMRmPm79rj8aytrMhY+ubR0V95IdtmKnuMRuOpnJck Cgw3V3p6mi9ePO2FMI6vW62ghx12ezAQyGU9DN/dbDY/88ILR/mWc8LB7d/F+Xnb 5iZPxalVql+8//7xnwET5x/ffutxu2U2H5dbLHVcu68Tu0B/Gerrk3DqlJ2dHgoY zicLs7My2wJizh/V19cXnhRTcG5mJhKJ8NS6TMXFjc3NuzvM/G0C7xIOh1eWlmI5 LIMZxatQKHQ6nclsNppMLKZLsLI2Nzak5S/DDjAmfXT0Vy5Ido4n8vJKSktVKpXQ tcAAxui2jo6uy5ezucPa6urqyorT4cgdPQxfs+rMmWs3b+p49oo8uP0LPB4aAgnK U4kXamtv3Lp1zAfGRkZGnjyR5VuG59x78yZP+UiIR4ODYBALXYusUCqVV3p7ha6F PInH44N9fbK09WFgKbdYKiorj/mMbWsLfvH09QsKC7uuXNm1avjeBN4lFo2CbRAM BmX5Wvexq3i1oHgBszmbBeKN9XWwqXLhueWll9Rd/77KT0gaEsDSxlJRIUsT/1Bg 4K5raLh+8yYnt1q3Whk9nFpmTiTk9Bjh26nV6oamps5Ll3A2Pw9u/wL9d+/m8/ZU X3n99aNi3nrc7v/9+98jkYjMNn73ArZLZxbrQcRRTI6OymOB32g0tlDSLB4Yefw4 FAwKXQu+YNTmMXmSYK6cHB/nSfAkE4nLPT17k0EgbALvAt99c2PD7XIxgUhwCkXg R69mlQreKQhednu8BwHzyevx5Ij0zUs/RtvWltC1ILhEtgZijiD7w8AHYXY1X3z5 ZW5va7fZlhcXHQ6H3++PSTPENDwZhVJ59ty5K7jJcg7d/oW/Dvb18WRGgJ308e9+ d2hN7v7zn2urq3IyXw4F3nX7pUsGg0HoisgKGAE2rFbJdfxDgb5QdfbshdpaoSsi K2B2GJOpX8leYHjR6fU1RwTH4vUYcGtHh2HPUR20TeC9xGKxdat12+/Pk2Bkzd1A zSqVKuXVXFwMViK3RSzMzYVCIck9mWygo7+yRA4zfY5jNJn4dnAVITDEl5SWvvrG GzyNwtFo1Lq6ur6+7nG5AsFg6oyQKCXxThowVqqrq9s6OtQaDX4d3G63x+PZ98PN jY3lhQWeSlSr1b947719P1ycnx948ICnEkVIfkFB740bQtdCPkgl5W/mUHJgzhl8 8GBnT5o3eZNIJM6cPQvz7L6f83oMuKKqqrqmZu/NMTeB9wHy27a56fV6GR8xcRoA jNxVKBQardZgMJhMphMPcrMua3ZmJhaNymmQzJBgMOjzeoWuBcExouvPBAtKS0uV uXEYeB8wIuuLit58+22E85AwBW6sr29tbrqczm2/HyyAZCKRL8SkyBxghi9usVia Ll4sLilBrsBeYrGY1Wo9uEI/PjLCrKDzAZhlt557btf5KhQMfvftt1CcCA0U/oBn DpbimcwSQRHHEw6FHg0Nyc+dD0atK//uU0qwZn1tbWVpKdcGmYLCwvqGhr3pXjc3 Nx02G0+dRa3RtHd27g1jLsgm8EFglnHY7YFgMB6LQRvAF4EprZtI5OXnw5Nn/JmL DCkQagImx8z0dMrgyaXGvwto/oMnvAgZkIutWZbk1GHgfcDEALPmG2+9hZ8AEyYG p8Nht9ncLpff7w+Hw9FoFIxOZqrI/o0k07sNMOGp1WqD0VhSWlp15kxFZaV45iEw hkKh0MGfD/b18WeyXGxrM5nNKTtAqZyZnFxbXZWfdMkEaGnXn3kmZzs+V0AvG+jr KxBNn+KW5M7ONQoKnTXQSPrv3cvZccZsNp+rrmb+Cop0amKCp0cBs8blnh6Y7/b+ UMBN4EOBSm77/fArGApFIxHm+A9XMz4zb6buVlioKCxUqdWgdXX6FPjzfiwWm52Z yUunpUQuWiTQ0V8Zk6NtWn7k4GHgfTCBDV99440M8xkiEAmHfT5fMBAIRyLwZ0Ye x6LR5GFOdDB3qlQqpSoFTHUgd8Xv3B4IBGxHpAPp++EHniwksDZuPvdcnhx9Vllg NJtb2tqEroW0eTQ0FOMtXLkYgFHlSk+P0LWQNpPj474DBz1yir3pgsdGR3k6EwSl XL56dd9atkg2gU8EhhGY5WG2B90Iij2RTMLvh1Y6P72uXcgs4ioUzKauRqMRT2z/ cCg0PzcnxWAoHEJHf+VN7rZs+QEz01GRG3MHJn7ji7dvW47N5UBkTyqz1NravthX DDB3Phke5m/ivNzTM/70qbzjPGdIKm5qb69GiLPf8mBmasqdA+5txaWlTafPpk4w gKp5PDhYkJPbv3tJrTIXFtY2NCzOz/OXO7ehufngwXWpaGAZsO33Ly0uivPMMzKh UMib28te8ibX27fMKCsvF88KooAw0+StZ5+trqkRui6yxW63H7Uyury4uLm+zlO5 MDGD7SVmX0QmLFk8FsNJJ6tQKrsp6SsrtjY2wJTPBTsP2mRtfX1FVZXQFZEkw4OD cZS+zCzgMmGNEIpjRyKRUKpUsWiUp0G4uLS0vrHx4M3F5ggtPzxuN5NDQczND414 PO6w24WuBcEj1MplBTlC7yO5s3Olu/tia6vQFZEbxzg/A08fPQofdjA4FwDjtfPS pfbOTrBl/+P//T8EoQ4FNTQ3l5WX812QzAgFg48fPhTzSgq3HOpcSpwIGMFz09MI syoY3DBuQEFbm5t23qJMccUOb+dClUplx+XLe8NuMdAmMH/AbG7b3BR5k8OEnJ9z AVJKcsNgMOi5TvsmdZKJxMW2titXrwpdEZmQSpO4vn7oSWaG/vv3c3NkUSgUb9y5 s9sBnQ7Ht199hWA6J3d2bjzzDN+lyIlU4Kv79wU5QM4kKRFkLwu+9bVbt3L82Pxp eXDvHkKANDC4a2prdXo989doJDI7M5Obbwpa6ZWenkNT+pEG5px1q9XlcPCUOUm6 gPr185bGghAJuWmmyhxzcTGdCTwITKsXamtvPfus0BWRNvAYNzY2oscGDeIvApZo gcdy/sKFZ59/ft/Pv/7iC4/bjVCBsvLy+qYmhILkweOhoePbMB+A4W4wGts6O/PS ecL8Ph++t45KpbpMAbEyZn5mBscNUqFQNDY37/vh0uIiGOK5JoNhLO26cmV3LWAf 5AjNFctLSzAE5dpMnQnhcBhn1iaEhQSwPCm3WGhcOxSYXCsrK1969VWhKyJVbDZb IBA45gNgoIw9fYpWHzEAwua5F188e1hK3kQi8cff/x7BhIWCem7cOOg3SBxkcW5u a3MTWXxCIyktL98rcmanp512O341KioraxsaMAuVKLFYbOjBA4SZFDpva3v7oaOE z+tdXl5W5NhsXtfYCDbMof9Em8DZszA3FwqFcm1hJUOgM9qPPt5FyAkSwPJEr9cX GQx0GPgoQAYXFxe/9tZbNAecCrfb7TkpKOLSwsLWxgZOfQSH2dN77c03j1GeYyMj 8AuhMmq1+hL5+Z+Ex+2eHBtD7vhHyU5BpDiMfi3t7ebiYsxCpciThw8jkQhCQcWl pZVHpy0Ai3xudjYRj+fOhF5cUlLf1HTU0gNpYHbAE5ubno7yFr5bBjAZno9f4idk Q66MpzkI2OX6I5yICAYmWu+bb79N+2aZ4Pf7HQ7HiR8befw4FAwi1EdwQEh0dHXB rxM/+adPPz00XxS3QHtubm0F25HvgqRLPBYbRNnT2wu8l/KKivrGxkP/dX521r61 haxtoDX23rihoHHvaNwu1/TEBMYB/mSyraPjxI9tbmw47PYccexSqlQdly4dMy+T Bj4V0N9np6dFHl1cDID09ft8QteCQII6g5wBU1itVgtdC7EDkyg8pTfu3KH4qMdw fNjnvQzcv893ZcRAoULx2ptvGo3GTD4Mxuv3332HYHxAY75O0bCOZujBg2OCt/EB vJEyi6Xh2OPZczMzDpsN2TYtKCjouXEDs0Rp0X/vHk6HPV9dbchsGAmHw/Ozs7mw fZdK39DTc7z1Qho4E2KxGEhf+ANJ3xOJRCJul0voWhB4UJeQORaLpSA31oyzBOZR kDSvvP56MXkGHiBz9ZuXAxGwQEHV1tWdNuryl3/9qw9ladlSUUEnPA9lanzce5ID P7fAqGIym1va20/85OTYGNQN2UiFul1sa8MsUSoszs3ZtrYQCoKhsunixVNdsrK8 7Pf55C2DUym7enq0Wu3xHyMNfAyhYHAhneScpG8mJBOJzI0cQh5Qx5A5lBn4VMBU WpCf//zt25VVVULXRSycSv1GI5FHQ0Mybm/w1W6/+iqLpLuhUOi//vQnBLM1mY6G Rd6t+wA9szA7i9wytTpd5+XLGX4Y/+wADHd1jY2WigrMQsVPPB37CmHhGGRec0sL iwM4ge3txYUFea8zNre2ZnJMnTTwQfw+38rSUn5BgYwnYm6hrL+5CXUP+WM0mXTk 3HsamNn0+s2btfX1QtdFYHw+n9PpzPzz1tXVtZUV/uojIMlk8uz588+98AJrq+LB vXvLS0ucVupw1BrNpe5uhIKkQiQSGR4YQBYMhQrF1WvXTnXJw4EB5BQvoMG6r12j kzJ7eTI8HAmHEQrSFxVVX7jA7lqYpJYWF4OBgFy3gsssFph/M/l2pIF3cTmd61Zr AUnfUxIMBn1er9C1ILChTpITlJSWqlQqoWshPZI7O5euXGnNSS9BsCfcbrf3lLPC +MjIthzTx4M98eLLL2e5VwaP9I+//z1XVTq+oJb2dpPZjFCWJBjo68tDto93dnpu 3jytOEkmk0NQVWTjNT//2s2bqCWKGK/HMzk2hqAfEolEW0dHlgXBYAsyWJZbwWqN pr2zM0NPFtLAtq0t+CXLlsA30WjUdZpVfkI2kADOFcB2l+tSMd+AVdrc0tLd0yN0 RfBIpcKz20Oh0GkvBPM9KS8rBN7+uerqZ59/nhObeH52drC/HyO4Tl7e9Vu3+C5F EkyOjuKcvt4Fus/V69fZrTmCNfawvx/ZkDUajS0ZBCLOBfrv30ewipi0WKVlZZzc anlxMSC/reCdncs9PaqMfRNyVgNb19bcLhdJX3bA/I5z2p8QISSAcwX8w8AwFcnJ DwcGyuqammeee07oivAOmOBbW1txVq6YD374QU5B18CmfOmVV1ic+D2G//7zn8Mo DpblFRV1OR8Na2tjYzEdCQatRFC/nZcvFxkMrO+w7fePPH6MadHCWF1bX1+R84EP Fubm7FjWcAunjkUggJcWFuSkgZPpOFiak+Jg7QXmrEg4DBfmiAxeXlz0+/1ykr7I RiMd/c1x5KNPiBMxmc0nhlXkFoPB4PV6ZTUrJ5OWioqXX3tN6IrwAswHPp/P7Xaz MyDA9B968EAeqx6pUM/19Td42ET1uN1f/u1vCJ0im31IeYB/9BeaTV1DQ/ZKEnQ7 iDHMkZMOA6PtvTONhI+5WGYBols7Ow2nX0jKha3g+dnZcDgsmxedlx5/YKqC3zEL DYVCyHkBCFEhB1OVyJzSsjIWMSdZA5PQux9+ODE2Nj46KqfBGiyYIoPh9TffzNxB S/zEYjGHw5HN5qRtc3Nxfp7DKgkFzMQvv/56hjl+WfC/336Lk3FBqVJdySXX/X0g p6SG4a7cYqk/NuVv5szPzNjRkwNfy2G3+UdDQ7FoFKEgtVrNn2sGDOCp5Dc83R2X qrNnz1+4wKILyFUDw/eam51NxONysqZA9IJdaqmomJ6cxBzuwOBxOhxoxREiRB7j JHEKKiorMUcZ0Iof//a38IfZ6emHAwP5Mhq4U6mDCwtfeOklS2Wl0HXJCvgiXq/X 4/FkaTHABOaReB55aK4dXV3wi9dSwI757D/+A8GIgRfa0NRUZrHwXZAImRgd9eMe /eU8+DZaOOJdDEZja04eBnbYbHMzMzixr1rb2/nu+5sbGw67XerOsUVFRRfb29l9 C5m5Q2/7/ctLSzJL6gtKvvLMGeaE0djICPKhj63NTbTiCHEin75EZIjBYNDp9ZjD aJHBcOedd5g/r62u3vvXv+R0PHgnPcG2tbd3ZZzwU1QEAgG32x2LxbK/1aPBQU7u IwjwGk1m88uvvoqzqz/y5MnE2BhCQcmdneu3bsmmu2WIbXNzYW4O9Vvv7PRy/Zyh TQ7ev48ZFDqVGbihQeoreqcFvnX//fsFKM/ZXFJShXLWGhQgdAH4Xbp9HxRRV3d3 Nj5rMtgK3lhfdzoccspsBK8jmUyev3DBZDIxP5menISfYFYgGAj45ZiugjgVMulR xKkwm82nii2RJTDc3Lh1q6aubvcnDrv9H3//ezKRkM2YnpcO2lFeWXn7lVek4p4U CoVA+kYiEa5u2H/vnlRfaH7+zWeeYZ2Tkx1/+vRTnCNPpuLii62tCAWJhGgk8hD3 6G/quPW1a3wsncjpu4iWqYkJr9uNUBBY+W24G+wej2dtdbVQIlPSPuBxXentzfJc ukS3gqG283NzkVBITkElU9J3Z6e2rk6v1+/+0O1ygcjHtBzCoZCHjv4SJIBzlrLy coVCgVYcDHwf/eY3+37o8/m+/fLLWCwmVdV0GPBNNRrNK6+/nk0YWL4B0etyuTiP Rdz3ww+Sc7pjgnvfevZZ/EZo29r6x7ffIpQL3/FSd7dWp+O7IJEw2NeHaeym0qS1 tpaUlvJ0f5fTOT0xgbmsBm2yN2cyA4eCwSfDwzjnEaovXMCfF6DclaWl7e1tqazM 7pIauK5e5SRamIRkMMzOC3NzcvKSy2Mc5XZ26hsbwTra908TKGm3d4GW4LDb0Yoj xIx8OhhxKgTJinRQA+eltzi+/NvfQqGQzIb7n/3iF/CEha7Iv5Hy/AkGfT4fH2l4 YNp+PDQkoZfILFXcfu01/oJdncjXX3zhQdl6Atu358YNhIIEZ3JszOf1ohXHJHSt 5Tnd1OLc3NbmJmbnMppMLe3taMUJyNCDBzjulwqForG5GaGgQ4Exf3F+XnKyqrm1 1VxczNXdxC+DwRyam52V1js6HqbJQcs/dMcF/+gv5T0idpFPNyNOi8Fo3OuIgkBl ZeULL7986D/BzPTNF1/IKWcSM8U2X7x4+epVweczeLz+NDz53MJtnz56hBNDlRPg 7cB7udjSImw1otHonz/9FMHJDb7vuepq+MV3QcJi39qaxzUfOQ98dRTIAbGY7Zry igq0EgVhbWUFfmHEvorHW9raChG9rg7FbrNtbW5KyE8Hnhj0L2691RgZnJc+tSQS JQzV2LBaXekQkhJ6O8eTTCYVSmVjU9NRRt3i/Dwfa/HHEAgEkCMjEmKGBHBOU1xS gpn4EUb5V994o7Ss7JjPfPvVVw67XTYyOC8dhejChQu9N25gJqD6sehkMhQKbW9v B4NBnopIHVWanbVJx6iCZ1JRWfn8Sy9hHgE4hkcPH85MTSEUlEgkem/eFMm35oNI JPJocBA5d+71Z57BKRHabf+9e8g5jbM/gSlmQAgN9vXhPFKT2Xzm7FmEgk4EXuvi wkI4FJLKJAu9zFJZWd/YyPk6hRg2hOHbra2ugiqTygSaCdDGYNxoODYhXDAQWFpc xFyshAnCLfEsFQS3kADOdSwWC2aUhd2sSMfzw/ffr66syGxKKCkt7b1+nb+zgrvA nBpMA+qX16l9aX5+3WqV0GsC+ffC7dtM3gXx8NmnnyZRomGhbVcKwlBfXxLRkIWe 1XHpEuYxh8D29uiTJ5gmY0F+fo98DwOjbarjx746kQDIj4UFqWjgvPSkdubs2Zr6 es7vLNSGMEzQ1tVVUGUSmkBPBF4TDIm1eyKeHsX46Chm84OXa7PZ0IojJAEJ4FwH /zAwDPfvffRRJp8c7O+fm5mR0CR9IjC/ggarb2zsvHSJ2704sLEiaUD0IrgVrS4v r62sSOjVwPNp7+yExy50RQ5hc2Pj++++Q+iD0PwaL1483gVDoizOzdm2tjBLrDp7 trqmBrNEYGVpacNqxSzRUlHB9wlnQXA6HLNTUzid7nx1tUG4QAPHsLGx4ZRUumAY xs9VV5/nJ1w/jhKGr7C5vu52u+WW1DeRMJvNGZ6yQVa/dPSXOBT5dD+CNUaTSYcb Ibaxqam7tzfDD4+NjIw8eSIhrZUJMFsYDIamlpbmixdZz4IwYUej0XAaDrMZHc/s 9LTDZpPQ6wCDo6y8/MWXX8Z3Qc+cr/72Ny9K6CZ4Gtdu3ZLQ68uEYCDwZHgY045X qVSXe3rQitvL46GhKOJhexipLnV363CjRfAN9IKB+/dxeoGisLDx4kWEgtgB73dh fj4aiUhoTEgN6RYLfxHFdpVwHndiGG7isNudDgfcXEIrDpkATQheR2XGycOta2uY cQrz0pvtyCUSkoAEMJGitLRUqVKhFQeTwS/fe099ICD+MczPzg729+elU3TwVi8B gLm8qKiotr6+pbVVcbRCgycWTxOLxaJp4A+YuePz0ptsG+vr0pq8obYv3L5dbrEI XZETAHvrL599hmODFhkMbZ2dCAWhAWIGszgwh6/fuoVZ4j76799HHgSvCfp9OWd8 ZGTb70coCLTBRRjYRX/wfnt7e3lxUUIaOC/9bKvOnOHbPWGvGM47vR6GStptNo/b LT/dC88hkUyeOXPmVC5F8BxmUDwvdgGDyel0ohVHSAhZaQkiGywVFahHMjI7DLwP EGD/+v77nWRSZjI4L/1AlEqlpbKyobERJAr8NZEGJgzmDwLWLRwOPx4akpZ5lPJ5 7urq7OoSuiKZMjw0NDs9jVAQPJnWjg6T2YxQFgLTk5MexNAm0BOvXr+uQlwuPEg0 Gn3Y349pT5tLSpqFDpnOFV6PZwLLA9NoMp09dw6hIE7Y3NhwSMojOi89ml3u6TmY XZYn9unhH+twQBWHgkGbzcYsskhr3swE+LLJdFJrFhkEkfMeQfNAPhpDSAi5qQiC NfiHgUHm3XnnHRYXul2uv3/9NVii8pPBeczskkxqtdrS8vIzZ88esy2MQCwWmxof h4lcQrM4PD1LRcULL70k7KNjAVo0LDBfrt+6JYPu4/N6x0dG0Bon9M2G5mYxBFED oTI3PY32BlNhnDo7Qc7hFMcf8Ab7798vQHluIox9dSIwqy4tLITDYWkN+GBLXGxr E+qQC6OK4ffUZq/LFYlGCwsKZDC6HmQnTV19vZbVobnpyUlMtzU6+kscjwy7KMEa k9kMugutOBiebj37LOtAMqDKvv7yy1g0KsuZhiG1rryzo9HpSkpLK6uqVIgpSWBG h+kK5g8JWULwuNRq9Qu3byOE2uYD29bWd998g7Q3ZTa3tLUhFMQfKTFz7x5m+zQV F19sbUUr7nimJia8bjdacWC5Xn/mGakPtpPj4z6PB6EgeFwXampAmCGUxTnBYBBk cJ6kDhzBA9cXFTW3tJzqaFWWRCORzY0Nl9MZDgbz5BXUah/MFnd9YyPrvGget3vd asV8RKFQyIvS2QmJItvuSrCjrLwc88ASO0fovcAM9OXnn4eCQRnPPQzMzjBoYJPZ XG6xwO88fWWH3Q7WTywalZD0BeDpXOrulrqo+/vXXzsdDoSCZLCnh3aScxexHYVF Pvws9dPjmP4CSpWqobERoSD+sG1tpRK8i/4A815SJ4lUqpq6Op7cNGAWBk1lt9ng dyZyWC4YHvkFBY1NTVlahsiRn+PxOFgyaMURUkTmXZc4LfiO0Hn5+R/++tdZ3gOm va8//9zj8UhLs2UD40qk1mjAKjWbzSWlpVl6/IJ1uLK46PP7C6S2kg2P4uy5c888 /7y0Tq8dSjwW++zTT3GasaQdoZF9gBOJRO+NG2JzqofWMvjgAVqzF48HOAswnZ+h tbS0tclgOIKhdXlxMRgMSmtiZQ6pGg2G6traLNf4oIu5nE4wLbb9fub0r7QeRTYw cUkam5uzH2bHRkcLKe8RITIkafoQvGIwGvW4SS/OV1ffeu45Tm713Tff2La2cmeK 2oXZHy4oLIQZS61Wa3U6Zi0D/nCUHRYOhZxOp9fjCW5vR6NRKZpr8K3hC770yiss onGIlomxsaePH+NIO7AOW9rbEQriFhAYA/fvYwq/ppYWcfrVg3U+MzmJuRBw7dYt KY4Vk2NjOKlQoLWUlZdbKioQysIhHA4vLixINPYktFiVSgXToclsLi0t1RxxyAs+ FgoGGdUEf4hEIqk8C4lELuzxHgRsCY1GU8+RC8Py0lIwEODkVhkSCAT8Ph9miYQU ybmOTWRCcXEx5kEasBjeeucdDjXM3X/9a3V5OQdl8KHAZMYc4GEm8t0/y+D5XLtx o7a+XuhacM9/fvYZTq5XaBsggM3FxQhlcciThw/REl8DBpOpVcTLBBNjY37ELJdq tfrS1atoxXGCx+0GAYwz4sHw2irxgxiH4nI6161WKa597EXGsyEnJBKJIoOhpraW qxuGw+GFuTnMRYRIOOxGDI5ASBcSwMThlFssmFMdDLu//t3vuL3n8NDQ9OQkTWzy A4yY+oaG3hs35Lo2D/b6l3/7G5oj9LWbNyXUTcAKX1lcRHv1YCJff+YZnLJY03/v HuYDqa6tPXP2LE5x2QPDxUBfH1rk57qGBsxYkpjAq19bXfV6PFKXwcRBwAYrLinh PGsXct4jJvEyWnGEpJGn+UhkD/5hYI1G8/N33+X8thPj408ePcKxfgi+AQvMZDa/ 9MoraIkfheJf33+/YbXilKXT6zsuXcIpK0uQU+CCnum5fl1sR38PEo/Fhvr70VYx xJAMOXNGnzxB88DUaLW1dXU4ZQlFLBZbnJ+Px+NyXX/MNaA7Wyoq+HDanxwf5/ye x0BHf4lTQeMXcSRGk0nHKtsbay5fvdp88SIfd4YJu7+vL09SeR2IfYDsefaFFyqr qoSuCAYgvf74+9/jNFewG+obG8ulcGoRZB5OquS89GOpa2iwVFbiFJclts1NTFfD gsLCnuvXccrKBvvW1vzsLM5jiScS7R0d3JYFgx4T34HDe3KC3+dboXNGUgbaVSKZ PHv2LE/RDRx2O/JmbDAYxDnnT8gDEgPEccDIiLnMDyPy+x9/zN/2zubGxr/+8Y/k zg7JYGkBr6y9s7Ozq0voiqCyvLjYh+XaKs4ox/tYnJ/f2thA67xqjeZSdzdOWZzw ZHiYCVSLAIzVFVVVIj+BjxklGx5I1ZkzxSUlHN6zUKHQpQNSxmKxSCjEHFgVFTCl gs4hj2hpsZNeU6muqTHwFjwymUxOTUxgGlrRaNTldKIVR8gAkgHECVgqKjBXeWFc /ii7zMAn4na7//711wny4JICMI9WVlU99+KLmOmpWbDDz6rKF//zP36sVLdgbV+9 dg2nLBYEtrefPnqE5/ycSNzgKDQ9Jg9++KEA6xElEomuK1f0RUU4xbHg4cAAjPM4 ZcFj59Z9CZq6bs8pJJgZw+FwDCU23qmAIXppYSEUCtFusPjZSVNXX6/l2blv7OlT zAzS0AhtW1toxRHygAQAcQL4h4EtFstLr77KdymhYPCrzz+PRCIkg0ULTNVvvv22 yWwWuiLHATLA5XLB7xUVFZy3pWgk8uc//AFH0oh5Tw/qNtDXh9ZRobjLPT1qtRqr QM6AAe3x0BBeQKy8vGs3b4pzCMX0F0gmEs2trRwu0u1Tv7vAOBMOBhNYpwAyJxwK LczPi7MlEHk/xbtubG5W8u/mszA3hxmln47+Euyg0Yo4GVAgmGEtYTh7/a23uPUl O4pYLPbl3/4WDARo5hYb0AxuPfdc9YULQlfkOAKBgNPpZOxRvV5fXl7OeUMaefp0 YnSU23seBdjx7ZcvGwwGnOIyB54AWl5HaHhnzp2rrqnBKY5zVpaW1tfW0AY0g9HY 2tGBU1bm+P3+sceP0TbDYbbiMDbBUeqXAdqnOD2iPR7P6sqKgtyhRQa0k4KCApC+ OO4zoWBwcWEB06AKhUJejwetOEI2kNFPZERZWRnm+cBkMvkxz47Q+4r75osv3G43 OXGJASbL0bWbN4WuyHHE43GQvsFgcO8Pi4qKoKdwPvf/8fe/RzN2d5LJ3lu3RNUR HHb73PQ0mkUFL7FN4qfNx58+RdsPgZbZ0NxcVl6OU1wmwAAyeP9+PmJM7PbOTq7u xpz7PbG1i9YjenV52efziWoAyVmgI6iUSuiemHJ0fHQU8+3HYzGHw4FWHCEnSAAT GYHvCK1QKN798EO04hj+9+9/39zYoMlbKMCYNhqNt197TcxZjqCSoC5cLtehoVkN BkNpaSm3PcXv833+P/+Tm8GfMOMY5aV1xbVnnpG6P0jKY/zePUwFKKoIasjBwOob GtQcjVfwDLU6XebNLxGPh0MhsXlEx2Kxhbk5qJXU+5F0gblJq9XWNTQgl4usfsn5 mcgGGp6ITAHLHjneSUtbW9fly5glMjx6+HBqYoJkMDJgr7/w0ksV4s46E0uvN4eP Na/50MDffPml2+Xi8IbHAFbF2fPnz4vD+RwzjhFYjW2dnUaTCac4XvF5veMjI2iD mHgiqK0uL1tXV9GkF0jWxqYmTm6lVKk0Wu1pa57yiI5GQfCLzSPa7/cvLy0V0jSK SyKRKCkpOXPuHH7RG+vrHrcbs0RQv2hBIgn5QQKYOAXm4mLMrTmY0d/98EOEmA2H AqP5D99/DzYxLWPzTSqc7OXLHLoR8gG0Rq/X6/F4MjE0+fCF/tMf/oAmBeGNdIjg MPD87KwDMZMkjG/Nra1oxfHN9MQEpj1aZrHUNzaiFXcoYA2PPn6MFyo8mWzj6Pyz Sq1WazSsRwzRekRvbW7atrZEHsNfBjDJoqtraoy8ZTY6HpgypicnMY0laPDIepuQ GWTZE6ej3GLBTPqHfBj4IDDIfv3FF8FAgDaE+QDe7/kLF249+6zIH28kEnE4HNHT 2Jc6nc5isXBoELhdrq8+/xztQcGr6b15U8AMn16PZwLToW5n59ozzyCVhcXAvXt5 WCYpNJjWjg4BY7aDCT7Y14fZQbhKJ6PRalVchBwXp0c0aLPlpaXA9rbIB3mJAu2w oLCwobFRqK0ChrGREczJAhq5HXFtlJAlJICJ04F/GBgsqjfu3EEr7ij++Y9/rFut NIVzBVhF8GZfeuUVMR/3zUubF26328cqBLFWqwUNzGGbeXD//vLiIld3OxGFUtnd 24tW3F7i8Xjq6C/iKdZL3d06vR6nODSCgcCT4WE0wzSRTKYOAwu03Tc8OBiPxdCK g3mQkxj1Wr2eQ+kiWo/oWCy2OD8P/Zo8qrgCRi29Xi+GxHVzs7OY3gd09JfgBBqJ iFNjNJl0PGdR3wsMdi/cvl115gxaiccwNTHx6OFDksHZAC8UlOHzt28XFxcLXZcT CAaDTqcznoXjsVqtrqio4FCB/OnTTzF3eExm88W2NrTidkEWM5aKilr0gDE4LM7N 2ba20IoTatFkanwcMxUKJ87PIAV1en0hD+sFovWIDgWDS4uLMAWQDM4GmAIslZUW i0XoiqRc94OBwMzUFOYLhXnZ5/WiFUfIFRqDCDaUlJaqVCq04gR3hN7HYH//3MwM yWAWFBQWXr95U+TZffPSO5AulysQCGR/K6VSCRqYq00eZEdoMFWra2qQQ6pA53LY bGgWFTzMnhs3cMoShKEHDw6NWM4H0GDKLJYGjuJCZcj62trK0hJag+HE+RlGQlC/ vHZkcXpE56UzBltXV2kCZQG0PZPJdK66WuiKpGK2qTUaeIkP7t7FfJXRaNTldKIV R8gYEsAESywVFZijHhg3H/z612jFZcL05OTw0BDN4hkCY82l7u7mlhahK3ICYMH7 fD63282hD2FhYSFoYDUXx/yAgb6+xYUFTm6VCak0p11daLGRHXb77NQU5knO7t5e Tk5gipZoJDI8OIj5SBsvXkTLDOzzeseePsU8f1hUVJRljPTTpjtijWg9ogG7zWbb 3CwQLsqAtIBxuKKyslwEu74p6atWMy/uwb17BYh7vzC2YPqzEPKGBDDBkiKDQa/X Y/q91DU09F6/jlZchqxbrXf/+U8KFn0MYHt1dHWJPMgzA4tgVxkCzcNisXB1duDP f/wjpocwNO8rvb1cCfhjgOc/PDCAl/V3ZweUzNnz53GKExDr6urq8jLaGAXGeve1 azgN5hGits9Lt5nW9vZs7qDWaEBAYM4XovWIBjY3Nx02m4DB9kTOj+GdL1wQQ3o2 hVIJrXf3Zc3NzDjtdrTSU0d/A4FtyntEcASZ7AR7zGazRqtFKw6Gv1++955alDGT Atvb//zHP7xeL20I7wXs4Ja2titXrwpdkZPJJthV5pSUlJi4sGP8Pt/f/vu/ke3+ nhs3eLVT4RUM9fWhRS0GVCrV5Z4etOKE5fHQEB8rO0cCDebmTX5dfBOJoQcPMJUk lNjY1JTNHKTV6ZSIp4f2IlqP6Lz0OrLL6SQZvBcYD5UKRU1dnRj8U/ZJ37x0VLPh gQHUvEehkAfxnD8he0gAE1lRXl7ORwyPoxDbYeB9gEgYefJkHDN3i1hJRbrS6e68 844kMkBub2+7XC4c09BgMJSWlmZvNzx59GhyfBzT/gDrp/vaNf5KfPLwYSQS4enm B0kmEqDQJNE+OSEejw/19WF6nKrV6ku8LX7BCAP2N6acgxKLS0pYh2PMLyhIhbwS VOOJ2SMaJvfpyUmKj5WXXmcpLSurrKoSw6M4KH0ZkI/+JuJxO+JuM5ELCN+7CEmD nxXJaDK9+fbbaMWxI5DOPrK2upqDrtFgwShVqrfefpuTDJl8E41GnU5nOBzGLFSj 0Vi4yKf933/5SzgU4qRKGcLfluns9LTTbkfrLNBK6xsbyysqcIoTCfatrfnZWcyH XFpe3tjczMfNsTe007SwjYheqFDodLp8cSyMitkjOhaLzUxP56fPjAhdF1QYV2eD 0Vh15gxmhNFjOEr65qEvVlLeI4IPcmuIIfjAaDRi5s8UVVakE/G43U8fP97c2MgF JQyvBuy8V19/3Sz6/EZ56Q0Hj8fjFSibgkKhqKioyNLQASv2Pz/7DNndQFdU1NHV xe09kaP4AjBkdVy6hFaceBh98iTIRWzzDOEpivjo06dBXGs4kUg0t7Swi+WeChmk 0Yht/IdvFA4GxekRHQqFFubm8tMIXRd+YXRvUVFRRVWVFvFA2fGkpK9afZRzn9vl mp6YQM17FAjwfTqJyEFkPrgQOJSUlGAeUxG5I/ShwPANpue61RqLxeTnIJ2SvoWF L73yClro1ywJBAIulyubBL/ZAwZEeXm5PrvFo/nZ2cH+ftSAOjs7RpOpNeskqLu4 nE4wpzA7BQwg127dkl83zAT47gP37yM/7ebW1pLSUq5uODE66vN6kdt8RWVlaVkZ i2sFPPR7IimP6FgsEgqJ0CM6Lx1ZY2lxUZYymElLVmQwQLvSiCmsyfHSlwE771Ek ApM1WnFE7iC3YYUQCuSsSAWFhe9/9BFacRwSjUYnx8eXl5a2/X4ZmOCMw/OLt2+z sw7xSWURdLlCuJ7Dx2BOk42F9/dvvsEMxZnHaGCzOctYuAxg4z599AjzYCSYnu1d XQajEa1EseH3+caePkU9v5dIdF25oi8qyv5WE2NjPo8HWRHBENfQ2Hjaq+AJa4U+ 9JsJ0J1BA+P7k2dIMBBYBBksC6do6AigME0mU+oIjMiiDxzj8LyX/vv3MV8D5T0i +EPyAwohEvAPAze3tFzu7kYrjg/sNtvUxMTW5iYYH5ITwynHLYPh+RdfNJnNQtcl I3DiPLNAq9WmgsmxNZThe332H//BbZVOJKWBjcbW7FJbhUOhx0NDyIlAy8rL65ua MEsUIfMzMw7cRZNkInG5pyfLrAETIyPQf5GFEIiWto6O0xaKlumXK8TsEZ2XHiuW lpYS8bgUJ0r4HawjGHmKuFgD4hylUqnKQPoCS/PzYK4gVImBjv4SvCKZ0ZkQPyCE MA+xwOD47ocfsjuUJTbguywtLCzMz7ucTvH7SIMte6G29pp0IujC42XiPDO2iAiB J2mxWFjnTYVm8/XnnyMrSQD0TNeVK+yujUYiw7gZXPPSm3I9N25glihahh48QO4O UFx3by/rwzJPHz1CDvmWlx7rahsaTpu+W63VIuRA5hyRe0TnpZvQ6sqK3+sV2/bp PpieBcNjMVBSItp1EKUqdT49w4kjHo8/xD1uEwqFvJT3iOANkXZLQqKUlZdjiiIp HgY+ETA+rGtri/PzDrsdJgDxnICCpw2z5Y1bt85yHdKGV8LhsNPpFK2D3y7wlktL Sw0GA7vLnz5+PDE2ht9UwBK90tNzWh2bUr9DQwXoW3lXr18XSYRVwYEeAeYssoNu cmenu6fntBoYRp5HQ0MJ9BP7LPIeQQfU6vVSWRk8lJRHdDgcRYzxywKf17u2ugpV FcliMRPLqjDt9A6a12gyiWTWPoqU9NVoTvX0+n74AXO4AL2N7KVC5Bqi7qKE5MB3 hC4pLX31jTfQisNn2+9fXFjY3NjwejxglOQXFCBHf8lLn1OtqKy8wk/+G/6AGdTl cgUQY95mD/QgkMHsrLov/ud//H4/51U6EWgkl3t6Mt/yAvMa9Ayy5QqVrGtosFRW YhYqcmybm0ysXcxCQSfASKLOOPBPJBJ5PDQkiJwAPdPU0pL550H3anQ6kUiyLEl5 RIdC+IsOp2V9bW17e5s5Q4Q8MyYTCZiOoSXDoF1cUiKNPf/8fJUqte172lY68vhx KBjkqVIHIednAgESwATHGIzGLAPbngoYKEEASyUCU/aAHl5dWbHZbF63OwQGSiLB ub3FiF59UdHZc+cutrRwEroGGTCyvWlE68t3DEql0mKxsNioBMH/5z/8gY8qnQi0 w8bm5kzS6uJHYGIAI7WN6+xNMmD86VN8KzPzOGT2ra3Z6WlB4khBk25tb8+8oYIQ Al0h8n2/0xKLRsMi9ojeSzQSsdvtMLzE0+eEOX8RzOlohUIBLxosHJPZLA3F+xPw QKB9smui8FTHR0Yw23YgEPCLL1oHITNkNVgTIgF5NVSWjtCZEwwGbZubLqcT9B7Y suG0Kk6dQdrZOXG7eCcNfAZEFwjd0rKyyqqqM2fOKCR7spo57ut2u0UbzSUTWLtD QzP46vPPBREM8ORNJtPF9vZjmtzmxsbC7Cx+9cB+v3bzpszECSfAWxvo68N/LtA9 6xobYbQ56gNQsamxMS9uuqNdUtXL+OivDNyej0ESHtH7gNcH8mnb7w+GQqDhGQF/ oireSfsxM1ofPgkvFKZFjUaj1emKiopEm8vqRFLb1Go11J91V0LOexSJRNyU94jg HzIICF6wWCyYIXlgpnr3gw/QipMQII+3fb5wJJKIx3cX8uHV6IGiIq1WKydVEAqF XC6X+I/7Zgg7d+jx0dGRJ0+Eeq3Qwlrb2oyHBQafHB0VRM+ANXz56lXtKeMY5Q6h YPDxw4cCrEqkV0xaDkso7XG7J8fGhPIlhoqVlpVVZOYtDzIpFe1ZFm7Px5BMJMLh cDwWE7oi7IHXCvWPRKO7kpgBZkNFYSEjEQWsHh8UpL8XWEfZjLoDfX15iC4A0NJs NhtacUQuIx/blxAV+IeBOy9fBssbrThCVKTWjNM+4UJXhGOUSmV5eflp/Sm+++Yb AcOHgHGp1+ub29p2vbh9Xm8qQJdAlamurT1z9qwQhUuGdat1ZXFRkEWT1IpJe7vR ZGL+GgwEQPrGYjEBF+ag3dZnlvVXlm7PxwACMhwKiTaWPrGLQqFQaTTZeyWsraxY V1c5qVIm0NFfApNcGbgJfMCmOW32iGyAofP9jz8WxPmTEBCwlUH6SivS1akA8zoV VtRozNzOhr7wlz/+MS5oABuwkpUqVUNT08LcXCQcFmo3T6fXd1y6JEjR0mL0yZOg QJ0ImgooyeqaGmgqgid6hcq0HuvGz5BfUACzm8iT8fABjC3RSArMXUEic5TpGFec GELQFwb7+jDXd4LBoM/rRSuOyHFIABM8UlpWhpmnN8cPA+caiUTC4/H4/X5JxGjJ Eq1WW15enrlZEw6H/+uzzwT3zGROmAtYfO+tW7mzQZcN8KYG79/PE+5ZCdxU0oD8 bm5tPXHOSh0N1ekEr62AwFQbCYdjcjlsIgOYGFegfjlcP0LOexSLxZwOB1pxBJG7 IziBQ0VlJaahUFlZ+cLLL6MVRwgCSF+fzyfRIM+sAVukrKwsc68K29bWd998I4+k LCyARtLd25t5uh0CJM3w4GDOOtGAqLtQU1N0UuQ5rU4nv8Oi7JBKqiR5U1BYmJK+ 2R30Pcj4yMg2YlI9mMq3NjfRiiOIPBLABN8YDAbMPDowjL5x5465uBitRAITMFIZ 6Zuz59CgQ5WUlGQoayfGx58+epSDW1XQPBqbm8ssFqErIjEcNtvs9HQOLprAxFFW Xm45No9XYWEhqF/M4I6SIHUwOBxOSjnqvkRRKJUgffkIPx7Y3h7FjaQIJQqSxJ7I ZXLOMCLwATmqQdyHSSQSv/7d79CKI3AASQMTpMfjyVnpuwtYPOXl5Rn2qft3764s LeWUBk5F8S0vBwEsdEUkCQhgp92eaw1GX1R0oabmmM+A0lBrNDn1WDKHCbAMMngn 5wdnBPjwdt4HsvMztByP241WHEEw0GhOYFBusWCOp6ANfv7uu2jFEbxCu76HYjKZ iouLM7HIv/r8c6/Hg1AlkaBUKq/09gpdCwnzaHAwJuWEN6elUKFoOnq5JL+gQKvT yTXNL4ek4mMBIINz6WQKJtBQVSpVlmmNTmTowQPMqTaRSNgp7xEhBCSACQzwsyJd 7e1taGpCK47gA5K+xwNKr6ys7MStYLBH//NPf8qRiDXwZXtv3sxBJ14OwY/+KiDQ YFra2o76skqVSiOvZOl8w4SJhl8kg7kCml8qtrNKheB+v7m+vry4yHcpu1DeI0JA aFgnkDCZTFrcrEgf/eY3rK8FEzBng8GIASbMFUDS90SMRmNxcfHxki8ajf7Xn/4k e5M0Ffjq2rXTpk0mDhKJRIYHBmQ/BkKDaWltPTSbEagOkL4U74odJIM5AWfLdy/9 9+5hLveEgkEv5T0iBIIEMIEHclYk4MNPPmF3Idh/gUAARLvsTUCxEYvFQPfmSHIj rlAoFGVlZVqt9pjPgKnx33/5i4z3spLJ5MW2tuKSEqErIhPcLtfU+LiM99LjicTF lpZDpyQQHql4V/L97jiQUzQ78gsKoFnibPnu5cHdu5htnvIeEcIiW2OIECH4jtDn q6tvPfccu2udTifIMIPBADKYDoAhEIlEvF5vIBAQuiJSBdpqcXHxMUs2Xo/ni7/+ VZZmPVjY1TU1Z86dE7oismJ9bU2uEdQSiURDY6PmsDUjZuNXlt9aEKBvgtQBGUzu PCcCDQ9+wRiO3/ymJyYwI1GR8zMhODTEE6gYjEa9Xo9WHAyyP//Vr9i5XsNsbbVa 4+kkh1BnkMHkWskH8I6CwaDP5wuHw0LXRfKAuC0pKSk6epnJtrn53bffykwDQxOy VFTUNTYKXREZsjA7a9vakpkaBPVbU1t7MOUvJTrij1Sk6Hg8GolQ3uCDKBQKJa6r 8z7gvTwaGkLNexQI+H0+tOII4iCymtUISVBcUoKpJEHHfvzb37K7NhQKbe5Jzq7R aIxGo06nk5k5KBRghvrTxMkk4hRoqKWlpaojji9urK9//913ctLAoGTaOjuFroVs GR8Z2ZZRik4Ydi7U1BiMxn0/p41fHOD5x1KO0dG8nPeLLgTdq1TCf4KPxsjOz5FI xO1yoRVHEIdCYz0hAJaKCszR1mQ2v3HnDrtrHQ7HvvzsCoXCZDIVFRUJPmlJF5j/ fD5fIBCgs2H8Aa3UbDYf2krlpIHVGs2l7m6hayFzngwPR2ThoHGo+k2d+NVqaeMX k5RfdDQKv+CNCF0XbMSjexmQe3cymbRtbaEVRxBHQQKYEADkw8Aw17782mvlFguL a2GwXltbOzhJQ+X1er3RaCS/6MyBh5lyfPL7QQALXZecoLCwsLi4+FCP6LXV1R++ /14kFhhrFApF97VrQtciJxgeGJC6pwYM4+cvXDCZTHt/SBu/wsJsCMMv2S+GKhRp 4atU5otp1PV5vROjo5jGGB39JUQCDfqEMJjM5uOD1nJLNo7QwWBw6+gFS5VKZUwf bJa6luAPmPPC4TDMebTlKwjQREtLSw+mC97a3Pzum2+kG+cc7Mie69dJuuAAPXeo v39HsnGMQL3X1NUZ9pz7BT2ioVDP4gBaVyIej8Vi8J+c5ggYnUD0MtJXnCMVsvNz KBTyejxoxRHEMYixQxI5Qll5OWZ0ZZABv3z/fXbX2u3249csmQ3hoqIikBninOcE AQwaZstX6ntHMgDaZ3Fx8b6kLy6n8+svvyyQYIsF9Xv12jVSL5gkk8mHAwNS1MCJ RKKuoUH3UzREyvErWuShhAsVP1IgRDznzBl88ACzO4MZ4LDb0YojiOMRb88kZA9+ VqSrvb0NTU0sLgT7yWq1ZnJaqbCwsCjNUSGIcgGY5wJpyNVZbBgMBrPZvHfhye/z ffHXvwpYJRZAL7vS20vqFx/QwI8GB6V1bhNq29jUpP7JAwJ0b2qZkhqPuAH1m0yA Fk4hicDRMCgxuhd+F7Po3WVzfX15cRGtOHJ+JsSGBHopIWPwsyJ99JvfsLsW5JzN Zsv88zAR6tOocuaAGeleSQCt0ZRmV0BGo9G//dd/xWIxYSuWIWBfdvf25kifEiEw ig6DBpaCJslL17b54sXC9IpPQWGhVqstpKTuUoPZFmaUsHgWX2AIYkRv6pe4d3oP pf/ePcp7ROQyEuuxhPwoKSlRIcaRghb/wSefsLsWBDAM4qe9CqZGkME6nU6W3tFg moDcDaaRioIi8tIZg0EDG41GRgbDe/z6iy88breYmyhUUqPVUsxnMfBkeDgcCom8 tSiUysampvw0ao2Ggl3JgNTOcDIJMhjEcPp/eHoYhsqClOQt/PF3KTsR9N+9i+kE EY1EXJT3iBAZNBkQwoOcFamhsfEqq8ixMNeura0l2Z6ZSR0804ABn0LqDtKgdcNh MIBTsH4ghOBAvzObzQaDgemAA31983Nz4jTswPAtLi1tbmkRuiLEj0xPTrqdTnFK ShiUjEbj+QsX4M8qdQryeZYlO2lACSf3ABI5m/PDqfUSGASZ39JCl0GcTZ0F87Oz jtO4s2UJ5T0ixIlM+jMhafCzIr374Yf7ogFlyPb2tp2LKA6FaWc80MNgmSnFGh9y H7uiF34Xjx8akT17d4NT6ZH++U+xhcUCE+rchQvnq6uFrgjxb6yurKwtL4ttxSSV 7qi62pQ+667WaqUb55zIhrQyTu7skv7Rvs8wMy/jIwD/K0j/LonpmDXxePxhfz/l PSIIOfdzQkJIKCvS1tZWMBjksDJgPjJKGFCpVOIx12CmjEQi0Wg0koZ2euUNtENj mlgs9uVf/wrvXega/QjomZb29uKSEqErQhyC2+WaHBsTz6gFEqexqSk1omq1mFkG CEIS9P3wA2ZvpbxHhGghAUyIBeSsSOUWy+1XX2VxIchCq9XKnxqEyUn1E8p0CkGc 6SqeTj6xCyne3CQ/P99gMJhMpkcPH85NTxcILWwKFYpL3d2kZMQMDB1PhocFD4uV TCRMZnN1TQ0jfeW9j0cQLBh9+jSIuBlLeY8IMUMzBCEW8B2h37hzx1xczOJav9/v cDg4r9JRwDNhlDAjhvfCnE3K5CZM7BCGdOiQVFjN3d9jUk66SPAB9Ef4/V//+IdQ OZyhoZZXVLDLW0bgMzczY9/aEsodGloLNBUYzxUSOVFCEMgEtrdHnzwh52eCYKB5 ghARRqNRh5gVCYTfr3/3O3bXbm5uhkIhbuvDGuYIExOlg5ne9qrZH+OCkL4lTo9W q11eWBAgMlZ+fntnpz4twgmpAPbu2MjIwZOWvALDeGlZWV1jI+36EsQxIDs/BwMB H+U9IkQMzRaEuCgpLcWMkKzT6X72y1+yuDAWi1mtVlKVRC4AumJ6YsLpcCDIYNAz Z86eramv57sggieW5ufXrVYEUzuZTGp1upa2NrVGw3dZBCFpHg4MYB5SiEajLqcT rTiCYAEJYEJ0YGZFAgV767nnqtPZMk6Lz+dz0hBP5AyhYHB2aioQCPDUPUHPFBkM za2tUk8SRoD5Oz0xse3389dUVEplU2urwWjk4/4EISccdvvc9DSafwTlPSIkAQlg QnSAEazX6zEHa3YRoUE8b25uhsNhzqtEEKIlEg7PTk/7vF4Ot/hI+soSPmRwIpHQ 6XTNbW2YWQMIQtI8uHsXc1MhEAhAr8cpjiBYQwKYECPm4mINoldbQWHh+x99xOJC coQmcpN4LLa0sJAKBbezw3qtKtVxdnbMpaV1DQ0kfeUKyOCFuTmP05lNhlUmj2tZ WVltfb2CVQp3gshN+u/fxzT0w+Gwx+1GLJAgWEICmBAp5RYLZsCGto6Ojq4uFhd6 vV6Xy8V5fQhCEoSCwcX5eZ/Pt5NMZh6QHD6s1etBzJjMZr5rSIgEr8cDTSUUCOSn w/VlckkqE1s6L1ddQwNmfESCkAcrS0sbVitacYlEwm6zoRVHENlAApgQKfhZkd7/ +GMWkhsu3NjYiEQifNSKIKRC6tzX5iZYP8FgMBGPM2HJmX/a2WE28FIxpc0lJVVn z6rVakErSwgJjJZglHtcLiaQfv6enWEmXj20HI1GU2axQFPBXAYlCDkBvWmwr4/y HhHEoZAAJsSLyWTS6nRoxcHw/dFvfsPiwmg0ur6+To7QBLGXUDDo9/mKDAboxZSf hjgKGDmhqWz7/QajEZoKM5BSgyGILEHOewS92Ov1ohVHEFlCcwwhasrKyxUKBVpx 586ff+b551lc6PF43HTuhSAIgiAIoZkaH/d6PGjFxeNxh92OVhxBZA8JYELU4DtC //xXv2Kx7QwXrq+vR6NRPmpFEARBEASRCdFI5NHQEDk/E8QxkAAmxI7RaMQMf8I6 KxI5QhMEQRAEISzIzs/BQMDn86EVRxCcQAKYkAAlpaWYWVKKS0pee/NNFheSIzRB EARBEELx9NGjcDq8HA7RaNTldKIVRxBcQQKYkAYVlZWY/jxv3LljLi5mcSE5QhME QRAEgU9ge3v0yRNMY2lrcxOnLILgFhLAhDQwGAz6oiK04rJxhLYipt0jCIIgCILI Q3d+Br3t9/vRiiMIDiEBTEiG4pISzPShILnfeucdFheSIzRBEARBEJg8GhyMxWJo xUUiEbfLhVYcQXALCWBCSlgqKgoKCnDK2tnZefm118otFhYXkiM0QRAEQRA4+Lze idFRNOfnZDJp29rCKYsg+IAEMCElkLMikSM0QRAEQRAi58Hdu5jbA5T3iJA6JIAJ iWEym7VaLVpxGo3m5+++y+JCt9vtQUxDTxAEQRBEDvKwvz+RSKAVFwqFvGTeEBKH BDAhPcotFrQwDzs7O7eee676wgUWF5IjNEEQBEEQ/OGw2+emp9E840Bp2202nLII gj9IABPSgxyhCYIgCIIgyPmZIFhAApiQJEaTSafToRWnUCrf/eADFheSIzRBEARB EHww0NcHqhStuGAw6PN60YojCP4gAUxIldKyMqVSiVbc1d7ehqam015FjtAEQRAE QXDO5vr68uIiWnGxWMzpcKAVRxC8QgKYkCpScYSORCKggTmvD0EQBEEQOQs5PxME a0gAExLGYDTq9Xq04goKC9//6CMWF5IjNEEQBEEQXNF//z6mBR8IBPw+H2KBBMEv JIAJaVNSUqJSq9GK6+jqauvoOO1V5AhNEARBEAQnrC4vr6+toRUXjURcLhdacQSB AAlgQvJYKiowvYA++s1vWFxIjtAEQRAEQWRP/717mOe/bFtbOGURBBokgAnJU2Qw 6PV6tMkAivngk09YXEiO0ARBEARBZEP/3bv5mEd/A4Ftvx+nOIJAgwQwIQfMxcUa jQatuKaLF69cvXraq8gRmiAIgiAI1izOzWHux4bDYY/bjVYcQaBBApiQCeUWS2Fh IU5ZIGXf//hjFsWRIzRBEARBECxIJpODfX1o/m6JRMJus+GURRDIkAAmZAJyViTW h4HJEZogCIIgiNPS98MPmAv9lPeIkDEkgAn5YDKbtVotWnE1dXXXb9487VXkCE0Q BEEQxKmYnZ52ORxoxYVCIS8t1hPyhQQwISuQHaHf/fBDpVJ52gtB/VqtVj6qRBAE QRCEzPj/7N3pexvXle97igRAEhNJgJPsSHE7nmNbtiJL1JjEcZyk0yfuTI4tD/lf z5vb5znn9rnmKIo0JXEGOGKoCajhFi2HUSyJAEGsXVXA9/Oo3R6ItXf0QsAPe9da tm3/n//6Ly4/A+1CAEZHUXwR2vW8uy1dhD48PDygsQQAAGiEy89AexGA0WmGhoYG k0lly51/4YWff/jhaV/FRWgAANDQwsxMuVxWtpyh66VSSdlyQCAIwOhAo2NjsVhM zVp+lP3PP/+5hcjtp18/A/svl9gVAACIuppl/ff//t/K7rXZtr27s6NmLSBABGB0 oFQqlc5k1F2Edt27X3/dwgu5CA0AAJ5H8eXnaqWiaZqa5YAAEYDRmbJDQ0mFF6En Jyd/8dFHp32V/2aztbVlWZbElgAAQHTNTU/7iVTZcrqul7n8jO5AAEbH4iI0AACI Ii4/A3IIwOhYqjtCt3oRulQq7e/vt30/AAAgouj8DMghAKOTcREaAABEC5efAVEE YHS4/OhoPB5Xs1bLF6Hr9frGxgYXoQEA6HKKLz/7n0D2dnfVrAWEBAEYHY6L0AAA ICq4/AxIIwCj82Wy2VQqpWy5li9Cb29vm6YpsSUAABB+ii8/a5pWKZeVLQeEBAEY XSGXzycSCTVr+VH2T3/9a//AwGlfyEVoAAC6lv8x4P/9X/9L2Z21Wq22v7enZi0g VAjA6BYTk5PhvwhdLpf3eDcCAKD7KL78XNjeVrMWEDYEYHQLxRehz7/wws8//PC0 r+IiNAAAXWhhZqas8DYyl5/RzQjA6CK5XC7R369mLS5CAwCAZqi+/GxZ9N1ENyMA o7uMT0z09vaqWYuL0AAAoCGVl5/9DyfFQkHNWkA4EYDRXTKZTCqdVrbciz/60e1f /OK0r+IiNAAAXWJhbq58eKhsOa1arShsNA2EEAEYXWckl+tXeBH6L599Fo/HT/tC LkIDANDxbNv+P//1X8ouP1uWdcDlZ3Q9AjC6kcqL0J7rft7SRehSqcQjOgAAdLD/ 53/+z14uPwNqEYDRjdKZTCqVUvaF68uvvHJ1auq0r/I8b2try7IsiS0BAIBgLS0u 7u/uqlnL/1ChaVqVy88AARhda3hkZOD0LZpb47/rfHr3bgv9LbgIDQBA53Fd1zSM 6f/7f5V9F2+a5uHBgZq1gJAjAKN7qbwI7fvsyy9beBUXoQEA6CRH6VfX/7///m86 PwOBIACje6XT6VQ6rezL1zd/+tNL779/2ldxERoAgI7hZ1G9Wt1YX1d2Hnt0+bl6 RM1yQPgRgNHVFF+E/vyrr1p4Ya1W29zc5CI0AACR5jqOn0X9N/T52VkuPwNBIQCj 26m8CO2/2/3tiy9aeOHhof/mxbsXAACR5LpuvVazTNP/+9npaS4/AwEiAKPbKb4I /d7ly2+89dZpX+V53ubmZq1Wk9gSAACQ87jllV2v+39fLBb3dnbUrMvlZ+CZCMBA z8jISH/oL0JbluVn4LbvBwAAyPHTr6FpjuM8/keVl58t0+T6GPA0AjBwROVF6Fhf 318+/7yFF+7v75dKpbbvBwAASDh+6PfxP87PzJxT9WGDy8/A8xCAgSPpTCaVSin7 Unbqxo2XXn75tK/y38w2NjZs25bYEgAAaCPHT7+VyvE/Huzvb29tqVn66PKzplWf WB3AMQIw8D2VF6H9KHv3669beKFhGNvb223fDwAAaBf/Xb5mWbV/HWE4NzOj7K4Z l5+BExCAgX9SeRF6YHDwP//85xZeuLOzQ0MLAADC6ajlla7/4LrWwtycyg1w+Rk4 AQEY+CeVF6E9z/v4d7/Lj46e9oWO42xsbBy30wAAACHhh0+9WvX/+uS/1DXt4YMH yj5dcPkZOBkBGPgXKi9C+yH2i7//vYUX+u9txWKx7fsBAAAt+0HLq2MqB/9y+Rlo iAAM/JDKi9DDIyO//f3vW3hhoVDQdb3t+wEAAKflum69VvPD59P/6f7ioqOqeyWX n4FmEICBH8pkMql0Ws1anuf94Y9/bGE527bX19ef/poZAACodPTQr2HY9frT/6lm WctLS8pmTGjVaoXLz0AjBGDgGUZyuf7+fjVruY5zt6WL0OVyeW9vr+37AQAATfLT r6Fpz2vMMfvNN32xmJqdWJZ1sL+vZi0g0gjAwLOpvAj9wosv3vnlL0/7Ks/ztra2 rH+dsgAAANTw0+/RQ7//2vLq2IOVFdMwlO2Ey89AkwjAwLNlstlUKqVmLT/K/uWz z+Lx+Glf6Kffzc1NiS0BAIATOI6jPf++sf9fFxcW1F1+1rRKuaxmLSDqCMDAc+Xy +UQioWYtPwN//tVXLbxwb2+vzHseAACqnNDy6tjM9HRMVefnWq22zyNRQNMIwMBJ JiYnlX19++prr/3s6tXTvsp/G15fX2csMAAACpzQ8urYxvp6uVRSsx/P8wrb22rW AjoDARg4ieKL0K0dAjMWGAAABfz0q2ua2+hL5/nZWS4/A6FFAAYayOfzcVUXoc/1 9v7t7t0WXri9vW2o6rQBAEAX8nPvUcurRgMIZ2dm+lQ10azXasyDAE6LAAw0pvIi 9NSNGy+9/PJpX1Wv1zc2NhgLDACAhJNbXh072N/f3tpSsJ8eLj8DrSIAA41ls9mk qovQruve/frrFl54eHh4cHDQ9v0AANDN/PflmmXVmhs6ODczo2yGoq5pdMEEWkAA BpqSHx1tYUxRa1Lp9P/4z/887as8z9vY2Kif2JYDAAA076jlla7btt3MD99bWHje TOC289/u93Z31awFdBgCMNCUdDrt51I1F6H9KPv7Tz7JZrOnfaFhGNvchgIAoB38 9GtoWpNzFkzTXFleVvY5QaseUbAW0HkIwECzskNDyWRSzVotX4Te2dnhHREAgDNq suXVsdnp6T5Vg391XVc2ZgnoPARg4BRGx8ZisZiatV548cU7v/zlaV9l2/b6+jrd sAAAaFmTLa+OPVhZMVXNYvDf6Hd3dtSsBXQkAjBwCoovQn96924LXyfTDQsAgNa4 rluv1SzTPNVL7s3Pc/kZiAoCMHA6Q8PDg4ODypb77MsvT/sS/91xfX29yY4dAADg saOWV4Zhn7KdpMrLz4ZhlA4P1awFdCoCMHBqY+Pjyt7q3n3//bd++tPTvkrX9UKh ILEfAAA60qlaXh0rFgrKujH7e9spFtWsBXQwAjBwaiovQrfcDWt7e9tQ9TwSAACR 5r/b6tWqe/ohRsoG/3L5GWgXAjDQipGRkf6BATVrJRKJP3366WlfVavVNjY2JPYD AEAnOW3D52Pzc3PKPklbpkmDD6AtCMBAi8YnJpR96fvx736XHx097Qv39/dLjEkA AOD5Ttvw+ZiuaQ8fPFB2HazIk01AmxCAgRZlMplUOq1mrdYuQvuvWltba+FCFwAA Ha+Fhs9PUtn7SqtWKy2ldABPIwADrcvl84lEQs1ak5OTv/joo9O+yn+/3FXVnAMA gKhoreHzsQfffmu2mpxPq1ar7e/tqVkL6AYEYOBMJiYnwzwW2H/V5uam/94ptCsA ACLnqOGzrjutzgtUPPi3sL2tYCGgexCAgTPJZrPJVErZci2MBTZNc2trS2IzAABE TssNn4+pvPysa1q5XFazFtAlCMDAWeVHR+PxuJq1fvbBB6++/vppX1UoFHRdl9gP AAAR0nLD52O7OzvKhvHW63VlQ4aB7kEABs4q/GOB/XfQ9fV1if0AABAVLTd8fhKD f4GoIwADbTA0NDSYTKpZK5lK/eGPfzztq3Z3d2kgCQDoTmds+Hzs3sKCp2q2gqHr zDIEJBCAgfYYGx9X80SQ53m//+STbDZ7qlc5jrO2tnaWS18AAESRn3796Fs/cz/I er2+tLio7MKXrmkc/wISCMBAe6i8CO2n2S/+/vfTvurg4ODw8FBiPwAAhNMZxx09 SengX02r0PsKkEEABtpmeGRkYGBAzVovvfzy1I0bp3qJ/yFgfX3dD89CWwIAIFTO OO7oSVubm4cHB2ev04zad7e1/QysZjmg2xCAgXYan5hQ1hvj86++Ou2ryuXy3t6e xH4AAAiVs487etL87Kyywb/0vgJEEYCBdspkMql0Ws1aftL+9O7dU73Ef1vd2Nio t+MmGAAAoeXnXq1SaVfnC2Xp16fruus4BGBADgEYaLNcPp9IJNSs9fMPPzz/wgun eommaUVVAwwBAFDv+wDZpvRr6PqDlRU1Adi2bdMwSL+AKAIw0H4Tk5Nh7oa1ublp WZbEfgAACFZbhv0+SVnvK8/zdE1jZiEgjQAMtF92aCipaizw5OTkLz766FQvMU1z a2tLaD8AAASl7el39dEjTdV57FG3atvm+BeQRgAGRIyOjcViMQULeZ736d27p/1y ent72zAMoS0BAKCY67o1y6q19X6T/w67MDen7EqXoeukX0ABAjAgQuVYYH+Vv33x xaleYlnW5uam0H4AAFCpjcN+nzQ3M6NmskMPg38BhQjAgBSVY4Fv3L598cc/PtVL CoWCrutC+wEAQI2j9KvrdjuG/T7JT6SPHjxQ80V2zTrC4F9ADQIwIEjZWGD/7f/u 11+f6iW1Wm1jY0NoPwAAKOC//Rm67rQ7/fao7X3F4F9AJQIwIEjlWOCx8fFfffzx qV5SLBb5vhkAEFF++tU1zXWctld+9OCBsktS/kI1yzJNU81yAAjAgKx8Ph9XMha4 hW5YHAIDACLqKP1Wq/5f215ZZe8rBv8C6hGAAVkqu2H5Pvvyy1P9PIfAAIDI8XOv Vqn4SVWiuLLeVwz+BQJBAAbEDQ0NDaoaCzx148ZLL7/c/M9zCAwAiBbXcbRqVSj9 ViuVtdVVicpPM03Trtc5/gUUIwADKoyNj6vppdFCNyzaQQMAosJPv0eJUSb99ijs ffX4AWbSL6AeARhQQeVF6Fw+//Hvftf8zzMTGAAQCUfpV/LC8MOVFcMw5Oo/yU+/ ZQb/AkEgAAOKjORy/f39ChZqoRvW9va2srd8AABa4DiOJpl+Vfa+qtfrlmly/AsE ggAMqDMxOanmndVf5W9ffNH8z5umubW1JbcfAADOQjr99qjtfaVpmuhRNoATEIAB dTLZbCqVUrPWzz/88PwLLzT/85ubm5Zlye0HAIDWKEi/hq4/WFlR8yW1YRi1Ws2g +wYQEAIwoNTo2FgsFlOw0Gm7Yem6XigU5PYDAMBp+e9l9VrNMk3phWa++UbNu7Mf 5v3oy+VnIEAEYEApld2wLly8ePPOnSZ/2PO8jY2Ner0uuiUAAJrkp18/+voBWHqh zfX1UqkkvcpjmqZV6H0FBIoADKg2PDIyMDCgYCE/037+1VfN/3ylUtnd3ZXbDwAA TVKWfnsUPv1b++4028/ACtYC8DwEYCAA4xMTat5r44nEnz/9tMkf9gPz2tqa4zii WwIA4GQq0++9+XlPbKrwk456X1WrXH4GAkcABgKgrBuW/3b7+08+yWazTf58qVTa 398X3RIAACdQmX7r9frS4qKi3le6XqvX6X0FBI4ADAQjnN2w/B9eXV1V8104AAA/ oDL9+mamp2N9fQoWovcVEB4EYCAYKrthvfX22+++916TP7y3t1emPwcAQDnF6Xdv Z6dYLKpZi95XQHgQgIHAKOuGdapD4Hq9vr6+LrofAAB+QHH67aH3FdCtCMBAkJR1 w0pnMv/xySdN/nChUNB5SAkAoMpR+jUMlaP4lu7ft5UsR+8rIGwIwECQVHbD+stn n8Xj8WZ+2DCM7e1t6S0BANDzXfo1DUNNHD1e8d78vLLeV5ZlmaapYC0AzSAAAwHL j442mUvP6ty5z774osmf3djYqCm8hwYA6E7qz357FF5+pvcVEEIEYCBgqVQqncmo +R76lx99NDE52cxPlsvlvb096f0AALqZ+ud+e747kn2wsqLgbdfzPF3TKpWK9EIA ToUADARveHh4YHBQwULNd8Pyf3Jtbc3/q/SWAADdKZD065udnu5TMvqodtT8yuL4 FwgbAjAQCsq6Yb32xhuXr1xp5ieZhwQAkOOnX0v5k7HFQmFvd1fBQvS+AkKLAAyE grJuWM0fAjMPCQAgxHEcLYi7wcqe/jUMo1arGYxUAMKHAAyExejYWCwWU7BQNpv9 9z/8oZmf3N7e9t/CpfcDAOgqQaXfb5eW1PR3dF1X1zSOf4FwIgADYZFOp1PptJq2 HJ/evdvME1C6rhcKBen9AAC6R1Dp13/vW5ibU9NyUtM0z3UJwEA4EYCBEBnJ5fr7 +xUs5H8C+FsTI5H8jwtra2v+hxUFWwIAdDzXcaoBdUVWdvm5Xq+bhuFnYAVrAWgB ARgIl4nJSTXfT//6t7/Nj442/LGDg4PDw0MF+wEAdLYA069pmivLy2ruWPnRN6j/ mQCaQQAGwiU7NJRMJhUs1GQ3LNu219bWFOwHANDBAky/PQpHH/lJ27Isel8BYUYA BkJnbHxczfv0W2+//e577zX8MVphAQDOwnVdrVLxPC+Q1fd2dorFooKF6H0FRAIB GAidtC+TUbBQk4fAtMICALTsKP1Wq57rBrUBZU//+unXpfcVEHoEYCCMcvl8IpFQ sFB+bOzXv/nNyT9DKywAQGuODkWrVTe49PtwZUXNJSbbtg1dp/cVEH4EYCCMVI5E +vyrrxr+2P7+fqlUkt4MAKCT+LnX0LRgvz+dn51V82bqZ98Kva+AKCAAAyE1NDw8 ODioYKH+ROKPn3568s/U6/X19XUFmwEAdAY//Zq6btt2gHtYXFhQc/hsWVa9VuPy MxAJBGAgvMYnJhQ8tuR53l8++ywej5/8Y5ubm/4bvPRmAAAd4Cj9GoZdrwe7h3vz 84pGH1WrpF8gKgjAQHhlstlUKqVmrc++/PLkHyiXy3t7e2o2AwCILj95WqZZr9WC 3Yay3leGYdRqNUYfAVFBAAZCbWxsrC8WU7DQr3/72/zo6Ak/4H+gWV1dDWqIBQAg Kvz06/8Kdg+maa4sLys4/mX0ERA5BGAg1EI1EqlYLNLfEgBwAsdxtBD0gpr55puY kq+PGX0ERA4BGAg7ZSOR3r9y5fU33jjhBxgIDAA4ges41RCk34P9/e2tLQULMfoI iCICMBB2ykYiNTwEZiAwAOB5/DcRrVIJw5Mys9PTfX190qsw+giIKAIwEAHDw8MD SkYiXbh48eadOyf8AAOBAQBPe/worBuCb0g31tfLSt6napZVY/QREEEEYCAalI1E +vyrr074Af/NfmNjQ3obAIAICcPI32Nqmj8z+giILgIwEA3ZbDapZCRSJpP5/Sef nPADDAQGABwLydCjx5aXltTsxDAM/3+1GXSzawAtIAADkTE2Pq7moaaTD4EZCAwA OBaGoUfH5mdnGX0E4GQEYCAylI1EisVif/nss+f9V8dxVldXFWwDABByIWn7/NjC 3JyahRh9BEQaARiIknw+H5cfieR5nh+A4/H4835ge3vbMAzpbQAAwiw8bZ97vtvM vfl5Bce/jm3rjD4CoowADESJspFIvs++/PJ5/6lare7s7CjYAwAgnI6uAVer/l+D 3sj31PS+8mnVqp/5Of4FoosADETMyMhI/8CA9Cr+u/vvP/kkm80+87/6n3hWV1dD 8q0/AEAx/13A0HUnHG2fffV6fWlxUcG3w/5ClmmSfoFIIwAD0TMxOammycfdr79+ 3n8tFotcAAOA7mQaRi1M4wDmpqd7lTSJZPQR0AEIwED0DA0PDw4OKljoVx9/PDY+ /sz/5KdfPwMr2AMAIFQcx9FC0/iq57uJRA++/VbB98KWZRm6zugjIOoIwEAkjU9M KHjYyf+U88Xf//7M/+R53urqanie/gIAKBCqts+PzXzzTSwWk16F41+gYxCAgUjK ZrPJVErBQlenpl5+5ZVn/qednR0+CgBA9zhq+1ytemH66rNcKm2srytYyDAMx7Z5 1wM6AAEYiKqx8fE++UeeTngS2P80sL29Lb0BAEAYhK3x1WNqjn+PWl5rGukX6AwE YCCq0plMOp1WsNCbP/3ppffff/rfcwsaALpH2Bpf+XaKxV0lM/l0XT+6+00ABjoC ARiIsPzoaDwel17lhEPgvb29crksvQEAQLDC1vjqsdnpaQU3ofz/7bqmMfgA6BgE YCDC0ul0Kp1W0PrywsWLN+/cefrfm6a5tbUlvToAIEBHj/5WKmGb/b6xvl4ulRQs 5Edfz3U5/gU6BgEYiLZcLpfo75de5XmHwP7nobW1NcdxpDcAAAjE48df3fD9OT83 M6NgGoJt26ZhkH6BTkIABiJvYnJSwSHw5OTkLz766Ol/zy1oAOhgIXz017f66JEm H0qPRh9pWtjGPgE4IwIwEHnDw8MDg4PSq/ifAz7/6qun/z23oAGgU4Vw6u9jao5/ az7L4vgX6DAEYKATqDkEHhsf/9XHH//gX3ILGgA6Ujgf/fU9fPDA0HXpVY6Of6tV 0i/QeQjAQCcYGh4eDO4QeHd3txLKIwIAQGtC++hvj6rjX8uy6rUaARjoPARgoEOM T0wo+ECQHxv79W9+84N/aRjG9va29NIAAGXC+eiv78HKir836VU4/gU6GAEY6BDZ oaFkMim9yjMPgf1/ubq66rqu9OoAAAVC++hvj6rjX9M07XqdAAx0JAIw0DnUHAKP 5HK/+fd//8G/3NnZ4YMCAHSA0D7663vw7bd+NJVeheNfoLMRgIHOkclmU6mU9CrP PATWdb1QKEgvDQAQ5adfU9dt2w56I8+m5vjXMAzHtgnAQKciAAMdZWx8vK+vT3qV oeHh3/3Hfzz5b/xU/OjRo3CeGAAAmmSZpiV/xNqaleVlS/6x5Mfdv0i/QAcjAAMd JZPJpNJp6VWeeQhcLBY1TZNeGgAgxM9+R4/+hvKrTP99Z352VsXxr647jkMABjoY ARjoNKNjY7FYTHqVpw+B/fTrZ2DpdQEAEvz0a2haaIe6Kzv+1apVvswFOhsBGOg0 aV8mI73K04fA/ueG1dVVbkEDQBSF+fKz/86yMDd37pz4p9aj0ceuy/Ev0NkIwEAH Gh0djcXj0qtkMpnff/LJk/+mUCjoui69LgCgvY5SX7kc9C6ea3lpqV6rSa/iOI6h 66RfoOMRgIEOlE6nU+m09JflTx8CVyqV3d1d0UUBAO31uO2TG9bLz8qe/tU0zeP4 F+gCBGCgM+VHR+Pyh8C5fP7j3/3u+B8dx1ldXZVeFADQRmG+/Ox7uLJiGIb0Khz/ At2DAAx0pqAOgTc3NxX0KQEAtEXILz9z/Aug7QjAQMdScwg8ef78L371q+N/LJVK +/v70osCAM4u5J2ffasPHyroyczxL9BVCMBAx1JzCOx/frr79dfH/1iv19fX10VX BAC0RcgvP3P8C0ACARjoZPl8Pp5ISK/y0ssvT924cfyPfgD2Y7D0ogCAswj55Wff 5vp6qVSSXsVxnB2G2APdhAAMdLJUKpXOZBQfAu/v7yv4yAIAaNnR5Wddd2w76I08 l+d5czMzfX190gtp1aq/Fse/QPcgAAMdLpfPJ+QPgV9/8833f/azx39vmubW1pb0 igCAltUsy5RvrXwWhe3t/b096VVs297d2ZFeBUCoEICBDqf+SWDP89bW1sLcVQUA upn/J7ZWqfh/Vge9kefi+BeAHAIw0PnUHAK/d/nyG2+99fjvd3d3K5WK9IoAgBaY hlEL97y6vd3dYqEgvQrHv0B3IgADnU/9IbCu6wX5zy4AgNNyHaca7i8oVR7/8l0t 0IUIwEBXUHMIPHXjxksvv9zzXRheXV0N8/06AOhC/h/Ouqa54X5EpXR4uLmxIb0K x79A1yIAA11B/SFwoVDQdV10OQDAqYR88G8Px78A5BGAgW6h5hD417/9bX501P8b /4PF7u6u9HIAgCaFv/eVT9e0Rw8fSq/C8S/QzQjAQLdQcwjsf7T6/Kuver77eLG2 tia6FgCgeeHvfUXzZwAKEICBLpLP5+PCh8D+R4o//fWv/QMD/t9vbGzUajXR5QAA zXBdt1ouB72LBur1+tLiovQXtY7j7BSLoksACDMCMNBF1BwC9/b1ffr55/7fHBwc HB4eiq4FAGjIT7+GpoV8PLvneffm5xUspGlaJfTfBQCQQwAGukt+dDQej4sucXwL 2rKszc1N0bUAAA3VLMs0jKB30YCf0v0AzPEvAGkEYKC7pH2ZjPQqyVTqD3/8o5+E 19bWQn7mAACd7Wj0UbXq/zXojTRwf3HRsW3pVTj+BUAABrrO6NhYLBYTXeL4EHh3 d5c5EwAQoPCPPur5LqUvzM319vZKr1IsFESXABB+BGCg66g5BD7/wgs///BDXdcL fNoAgIBEYvSRb/XRI02+J7OuaWWOf4GuRwAGupGCQ2D/U9fdr7/2/7q6uhr+z14A 0JHCP/qo57v3i/nZWenpR0dXwTWN0UcACMBAN0pnMul0WnqVn77zzjuXLm1vbxuh b74CAJ0nEqOPfMVicW9nR3oVXdfLpZL0KgDCjwAMdKmx8XEFX7ff/frrcrm8t7cn uhAA4Gkc/z65Cse/AB4jAANdKpPJpOQPgX/+4Yd+0l5bW5NeCADwpKgc/1bK5XX5 9whD10sc/wL4DgEY6F4qDoE97+5XX62vr9frddGFAABPMnW9VqsFvYsGPM+bm53t E27+7K9ydPjL8S+A7xCAge6VzWaTqZToEv7Hjj/99a8aX70DgEJROf71I/ry/fvn zsl+HDUMo3R4KLoEgAghAANdbXxiQnruYl9f3//44x+3trZEVwEAHDN0vR6F4997 8/MKVqlWKpqmSS8EICoIwEBXGxoaGkwmRZfwP3x89uWXq6urruuKLgQA6InO8a/j OIsLC9LHv5ZlHezviy4BIFoIwEC3m5iclP78MT4x8falS3wBDwAKROL41/fwwQN/ q6JL8PQvgKcRgIFuNzIy0j8wILqE67p/+NOfduTHPAJAl4vK8a+a6Uf1en1vd1d0 CQCRQwAGoOIQ+PKVK/H+ftElAABROf71c2mxUJBe5ejwt1KRXgVAtBCAAfTk8vlE IiG6hOu6v/joI8uyRFcBgG4WlePfo+lHMzPSx7+2be9y8wjAUwjAAHrS6XQqnZY+ BP7w4495DBgA5ETl+LdmWctLS9JvOv47TiUKXwcAUIwADODI6NhYLBYTXaK3t/eD 69dFlwCArhWh4997c3M9wunX/91QcMUaQBQRgAEcSfsyGdEl/A89N3/+c8dxRFcB gO4UleNfx7YX792TPv7Vdb1cKokuASCiCMAAvjc2Pi79RFYylXrnvfdElwCALhSV 41/fw5UVwzBEl+D4F8AJCMAAvpfJZlOplOgS/oeS67dviy4BAF3INIxaFLoMOo6z MDcn/WWrH7BLh4eiSwCILgIwgH8an5jo7e0VXeLCSy+98OKLoksAQFc5Ov6tVHo8 L+iNNLa7s7NTLIou4Xme/7tBz0UAz0MABvBPQ8PDg4ODoks4jnPjzh3RJQCgq1im 6f8KeheN+UF9fnZW+vjXsqyD/X3RJQBEGgEYwL+YmJwU7U3ied7VGzekz5kBoEv4 qVKrVLwoHP/Wa7Wl+/el32K06hG5JQBEHQEYwL/I5fOJREJ0CeYhAUC71CzLFO4p 1S6L9+65woMAbNve3dkRXQJA1BGAAfwLNfOQpm7dEl0CALqB67p6ter/NeiNNOY4 zr35eenrP5qmVSLSDRtAUAjAAH5odGwsFouJLvHihQs/unhRdAkA6HgROv4tFot7 wmezTD8C0AwCMIAfymQyqXRadAlaYQHA2Rm6Xq/Vgt5FY57nzc7MxKSnH+l6qVQS XQJAByAAA3gG6XlI/oehK1NT0ufMANDBjqYfReS6b82ylpeWaH8FIAwIwACeQcE8 pN5z5z64cUN0CQDoYKZh+MEy6F00ZXFhQfpBZaYfAWgSARjAsymYh0QrLABoTYSm Hzm2fW9hQfpWEce/AJpEAAbwbLlcLtHfL7rE+RdfvPjSS6JLAEBHsnwRaX9V2N7e 39sTXYLpRwCaRwAG8GypVCqdyYgeAtMKCwBao1erfuoLeheNHbW/mp6W7vjA9CMA zSMAA3gu6XlItMICgBZEqP2VZVnfCre/YvoRgFMhAAN4rkw2m0qlRJc419t79fp1 0SUAoMNEZfqR7978vPSDykw/AnAqBGAAJ1EwD4lWWADQvKPj30qlJwrtr2zbXqT9 FYCQIQADOMnwyMjAwIDoEhdeeumFF18UXQIAOoZlmv6voHfRlJ1iUbo3Va1Wk+6w BaDDEIABnCSdTqfSaVphAUBIRKj91dzMTF9fn+gqR4e/lYroEgA6DAEYQAMKWmFx CxoAmhGh9lf1en1pcZH2VwDChgAMoIFMJpNKp0WXGBgcvHT5sugSANABTF2vRaT9 1crysmVZokvQ/gpACwjAABqTboXluu7127fl6gNAB/D/qNQqFemmym3hOM7C3Jzo /WfaXwFoDQEYQGMKWmG9femS9DkzAERazbJMwwh6F02pViprq6uiS9D+CkBrCMAA mjIxOSn6KJfX0zN186ZcfQCIOl3T7Ho96F00ZX5uTvojJu2vALSGAAygKbTCAoAA Rav91f1796QfnKH9FYDWEIABNEVBKywGAgPA80Ro/G+xWNwTHv9L+ysALSMAA2gW rbAAIChateow/vcfS9D+CkDLCMAAmiXdCotb0ADwTFG6/1yrLd2/L9ozgvZXAM6C AAygWel0OpVOi36syWSzb73zjlx9AIgi0zBqwjN12+XhgweGrosuQfsrAGdBAAZw CtKtsBzHuXHnjlx9AIicCI3/9bc6Pzsrev+Z9lcAzogADOAUMtlsKpWSq+9/wrt6 44bok8YAEC0RGv9rmubK8rLoRSHDMEqHh3L1AXQ8AjCA05EeCBxPJC5/8IFcfQCI FlPXa7Va0LtoytLioi3ZqcvzvGqlomma3BIAOh4BGMDp5PL5RCIhV59e0ABwLEL3 nx3HWZibE73/7KfrXeEBSwA6HgEYwOmkfZmM6BLvX7mS6O8XXQIAIiFC9591TXv4 4IHoFSFN0yoR6YYNILQIwABOTXog8Lne3qvXr8vVB4CoMHS9HpH7z/fm50VPqv3i he1tufoAugQBGMCpDQ8PDwwOytXnFjQA9ETq/rNt24sLC6LfjdYsa39/X64+gC5B AAZwagoGAv/03XelL1oDQMhF6P5zuVzeWFsTXYLxvwDaggAMoBVj4+OinU68np6p mzfl6gNA+EXo/vPC3Jxofcb/AmgXAjCAVmSHhpLJpFx9bkED6HLcf36SaZqHBwdy 9QF0DwIwgBZJDwR+6513MtmsXH0ACLMo3X8ulTbW1+Xqe56nHV2ArsotAaB7EIAB tCg/OhqPxwUX8Lxrt24J1geAEIvQ/ef5uTnRD5SO4+wUi5IrAOgiBGAALcpks6lU Sq4+t6ABdDOtUvGDX9C7aEzB/WdD10ulklx9AF2FAAygddyCBgAJrutWy+Wgd9GU 0uHh5saGXH3uPwNoLwIwgNbl8/l4IiFXn17QALqTaRg1ywp6F01ZmJ3tkfwm1Lbt 3Z0dufoAug0BGEDr0plMOp2Wq88taADdSatWHdsOeheNKbj/rOt6mfvPANqHAAzg TKRvQb9/5Uqiv1+uPgCETYTuP1crlbXVVbn6nucVtrfl6gPoQgRgAGeSy+VEA2pf X9+VqSm5+gAQNpZp+r+C3kVTFu/dcyU7ddn1+u7urlx9AF2IAAzgTNK+TEauPreg AXQbXdP84Bf0Lhqzbfve/HxfX5/cEpqmVSJyGA4gKgjAAM5qfGJC9AGwD65fF60P AOERofvPhq4/WFmRewqG+88AJBCAAZzVSC7XL3kL2i/+3pUrcvUBIDxqlmUaRtC7 aMry/ft1yZNqv/ge958BtBsBGMBZSd+Cdhznxp07cvUBIDwMXa/XakHvojH/T+aF uTnuPwOIHAIwgDYQvQXted7UrVtCxQEgVLRKxZFsK9Uulml+u7zM/WcAkUMABtAG 0r2gR8fHf/Lqq3L1ASAMIvQA8MbaWllyq9x/BiCEAAygDbgFDQBnZxpGzbKC3kVj nufNzcxw/xlAFBGAAbTHxOSk6F04bkED6Hh6tWrbdtC7aKxWqy3fv8/9ZwBRRAAG 0B65fD6RSMjVf+3NN0dyObn6ABCsCN1/3t/bEw2otm3v7uzI1QfQzQjAANojk8mk 0mnRJa7dvClaHwACFKEBSPNzc6KfIHVdL5dKkisA6F4EYABtI3oL2nXd67dvCxUH gMBFZQCSbduLCwuinf+16hGh+gC6HAEYQNvkR0fj8bhc/Q+uX5f7yAUAwYrKACRd 1x+urMh93en/JuwUi0LFAYAADKBtstlsMpWSq59Kp9++dEmuPgAEJUIPAD/49lvT NOXqG4ZROjyUqw+gyxGAAbST6C1ohiEB6FSWaVqSqbJd/KA+PzPTF4sJ1ef+MwBp BGAA7TQ2Pi43GZJhSAA6VVQeALYs69ulJdF2D8VCQag4APQQgAG019Dw8ODgoFz9 V994I5fPy9UHgEBE5QHgvZ2douQDun7APtjfl6sPAARgAO2U9mUyokswDAlAh4nQ A8DSA5CObj9XKpIrAOh2BGAAbTY+MSHXq5lhSAA6T1QeALZt+978vOhzLoXtbaHi APAYARhAm+VyuUR/v1BxHgMG0HkMTavX60HvojFD1x9IDkDyfxP2dneFigPAYwRg AG2WzmTS6bRc/dHx8Z+8+qpcfQBQyXVdrVLxPC/ojTS2vrpakbyfrGtaOSJXwQFE FwEYQPuJDkPiFjSATlKzLNMwgt5FY35En5uZEb3/zAAkAAoQgAG03+jYWExySiS3 oAF0jKg8AFyv1+/fuyfX4sFxnB3J/tIA8BgBGED7DQ0NDSaTcvV/du2aXMAGAJV0 TbOj8ABwtVpde/RIrr5pmocHB3L1AeAxAjAAEZPnz8sVT6ZS77z3nlx9AFCmWqm4 UZgA/O3SUq1Wk6vv/z5w/xmAAgRgACJEhyE5jnPjzh2h4gCgTFQmAPv7nJudjTEA CUD0EYABiMjl84lEQqg4jwED6AxReQC4ZllL9+/Lfa3JACQAyhCAAYjIZDIpyWFI l69ejcfjcvUBQAFD1+uS94rbpVIur6+tydXXdb1cKsnVB4BjBGAAUkSHIQ0MDl66 fFmoOACooVUqThQeAF5eWpIL6gxAAqASARiAlLHxcbmJkTwGDCDqIvMAsOMcPQAs 1nvf/30oFgpCxQHgBwjAAKSMjIz0DwwIFecxYABRV7Ms0zCC3kVjlmV9u7Qkd6On Vqvt7+0JFQeAHyAAA5CS9mUycvWZBgwg0iLzAHClsr66Kldf07RKFE7CAXQGAjAA QaKPASfT6XcuXRIqDgDS9GrVtu2gd9HYyvKyZVlCxRmABEAxAjAAQTwGDADPFJkH gF13fnZW7k9yHgAGoBgBGICg4ZGRAbHHgP2PTddv3xYqDgCiovIAcK1WW1pclJsA bFnWwf6+UHEAeBoBGIAg6ceAr928KVccAORYpun/CnoXjema9vDBA7mHWXgAGIBi BGAAssYnJuSODl64cOHCxYtCxQFATlQ6YK0+eqSJTejlAWAA6hGAAcjK5fOJREKo eG9f3wdTU0LFAUCOVqk4jhP0LhpbmJuTK84AJADqEYAByBoaGhpMJoWK8xgwgCiK Sgcs3+z0tFwHLEPXS6WSUHEAeCYCMABZoo8BE4ABRFFUOmD55mZm5B5jqVYqVbH7 1QDwTARgAOJEHwO+dPnywOCgUHEAkOCn35rYZN02sixrZXlZqDgDkAAEggAMQFx+ dDQejwsVzwwNvfX220LFAUCCrml2vR70Lhp7sLIid1Jdr9f3dneFigPA8xCAAYgb Gh4eFDuk9Xp6phiGBCBSotIBS/T+s2EYpcNDoeIA8DwEYADiRB8D9j9E3rhzR6g4 ALQdHbAe4wFgAIEgAANQYWJy8tw5kT9wPM+bunVLojIASIhQB6z52Vm5P7qZAAwg EARgACqMjo3FYjGh4v/2k5+MT04KFQeA9opKB6z9vT25jGrb9u7OjlBxADgBARiA CiO5XH9/v1DxRCLx/gcfCBUHgPaKSgesxYUF13WFiluWdbC/L1QcAE5AAAagQjab TaZSQsUd173BNGAAERGVDliiDwDrmlaOyIPQADoMARiACul0OpVOCz1L5rrudQIw gCiIUAcsuRbQnudp1SodsAAEggAMQJHxiQm5z1JXpqbknjEGgHaJSgcsx3EWFxbk vrUsFgoSlQGgIQIwAEXyo6PxeFyq+NjYK6+9JlQcANrFMk3/V9C7aGx9dbVSqQgV r9fre7u7QsUB4GQEYACKDA8PDwwOChXv7e394Pp1oeIA0C6GrtdrtaB30djC3Jxc cdMwDg8P5eoDwAkIwAAUyWQyqXRaqLjrONfv3BEqDgDtolWrjm0HvYvGZr/5pk/s uRL/N0HueBkATkYABqDOxOQkfbAAdC06YPV817VBbrwwADREAAagztj4uNBQDf8T 1dUbN4Q+rgFAW0SlA5b/J+rC3JzQ95WO4+wUixKVAaAZBGAA6uRyuUR/v1DxFy5c uHDxolBxADg7yxeFAFzY3t7f2xMqXrOs/f19oeIA0BABGIA62aGhZDIpVDyeSFz+ 4AOh4gBwdlHpgLV4757rOELFdV0vl0pCxQGgIQIwAHXSvkxGqDiPAQMIOV3T7Ho9 6F00Njs9LfS4iq9aqVSrVaHiANAQARiAUoJ9sGgEDSDctErFETtZbaO56elesX4N dMACECwCMAClRPtgTd26JVEZAM4uQi2g52dn6YAFoFMRgAEolcvnE4mEUPFX33jD ry9UHADOIiotoMul0sb6ulDxWq0m114LAJpBAAag1NDw8ODgoFDxwWTy3fffFyoO AGdhmab/K+hdNLa8tCTXqcswjNLhoVBxAGgGARiAUulMJp1OCxXnFjSA0DJ1vRaF FtBzMzNyM9WrvkpFqDgANIMADEA1uT5YjuPcoA8WgFDSq1XbtoPeRWNyLaDpgAUg DAjAAFSjDxaALhSVFtB0wALQ2QjAAFTLj47G43Gh4j+7ejUmVhwAWhOVFtC2bS8t LgoVr9fre7u7QsUBoEkEYACqDQ8PD4j1wZo4f/6ll18WKg4ArYlKC+itzc3DgwOh 4v7vwCEdsAAEjQAMQLVMNptKpYSKxxOJyx98IFQcAFoTlRbQi/fuuWL3tDVNq0Th GBxAZyMAA1AtnU6n0mmhZ8w81526fVuiMgC0zNB1udlCbTQ3Pd0r1qNBO+oBXZUo DgDNIwADCMD4xITQmA0aQQMIIV3T7Ho96F00JtcC2nXdYqEgURkAToUADCAAo2Nj sVhMojKNoAGEEC2gbdve3dmRqAwAp0IABhCAkVyuv79fqDiNoAGETbVcdl036F00 INoC2rKsg/19oeIA0DwCMIAADA0PD9IIGkB3iMoMJNEW0IZhlGgBDSAECMAAApDJ ZFLptFBxGkEDCJWozECSbQFdrVYqFaHiANA8AjCAYExMTtIIGkA38NOvn4GD3kVj oi2gC9vbEpUB4LQIwACCQSNoAF0iKjOQaAENoBsQgAEEg0bQALqEXq3ath30Lhqj BTSAbkAABhCMXC6XEGsEfWVqSugcAwBOKxIzkFzXXVxYECpes6x9WkADCAcCMIBg iDaC/tHFiy9euCBUHACaF5UW0MVicU/skJYW0ADCgwAMIBiijaAHk8l3339fqDgA NC8qLaCXl5bkHlSmBTSA8CAAAwiMXCPonnPnrt24IVIZAE4jKgFY7gFgWkADCBUC MIDA0AgaQMeLygykmenpGC2gAXQBAjCAwMg1giYAAwgJZiDRAhpAqBCAAQQml88n EgmJykxCAhASuqbZ9XrQu2hM7gp0rVbb39uTqAwALSAAAwjM8MjIwMCAUHEmIQEI A2YgmaZ5eHAgVBwATosADCAw2Ww2mUoJFb/w4x+/8KMfCRUHgCZVy2U/Xga9iwZ2 ikW5W8q6ppWjMAgKQJcgAAMITNqXyQgVT6bT71y6JFQcAJoRlSHA3y4vy3XqqlYq 1WpVqDgAnBYBGECQ5CYh+WWvMgkJQKCYgcQMJABhQwAGECQmIQHoYJZp+r+C3kVj zEAC0D0IwACCxCQkAB0sKkOAmYEEoHsQgAEEiUlIADpYVIYAMwMJQPcgAAMIktwk JAIwgMDp1apt20HvojG5AMwMJABhQwAGECTRSUivvP56fnRUqDgANBSJIcClUmlz fV2oODOQAIQNARhAkEQnIQ3ncq+/+aZQcQBoKBJDgB89fOjHVKHizEACEDYEYAAB k5uEFI/HL1+9KlEZABqKyhDgxYUFoZTODCQAIUQABhAwuUlIPAYMIEBRGQI8NzMj 9IcwM5AAhBABGEDAxsbHhcZv+J+9rt++LVEZABqyfFEIwHIzkBzH2SkWJSoDQMsI wAAClh8djcfjEpUZBQwgQAwBrtfre7u7EpUBoGUEYAABG8nl+vv7JSpzBRpAgBgC bFnWwf6+RGUAaBkBGEDAhoaHBwcHJSoTgAEESNc0u14PeheNyQVgwzBKh4cSlQGg ZQRgAAETHQX8+ltvDY+MCBUHgBNEYghwpVxeX1sTKs4QYAAhRAAGEDDRUcC50dFX X39dqDgAnCASQ4DXVlerlYpQcYYAAwghAjCA4DEKGECHYQgwQ4ABhBMBGEDwBEcB 9/RM3bwpURkATsAQYIYAAwgnAjCA4MmNAmYSEoBARCUAz3zzTSwWk6jMEGAA4UQA BhA8RgED6DCWafq/gt5FYwwBBtBtCMAAgic3Cth13eu3b0tUBoATmLpei8IQYLkr 0AwBBhBOBGAAwRseHh5gFDCADmLoej0KAVhuCLBpGIcMAQYQPgRgAMHLDg0lk0mh 4tdoggVAOb1atW076F00tjA3J1RZ1/VyqSRUHABaRgAGELxMJpNKp4WKv/rGG7l8 Xqg4ADyTVqk4jhP0LhrwA+rG+rpQca1arYhNGAaAlhGAAQQv7ctkhIrnx8Zeee01 oeIA8Ex++HNDH4DXV1flMqr/O1CtVoWKA0DLCMAAQmFiclLoObSBwcFLly9LVAaA 56mWy67rBr2LBpbu37frdYnKnucVtrclKgPAGRGAAYTC+MSEUCfSc729V69fl6gM AM/kR18/AAe9i8bm5+aEPgj6vwPFQkGmNgCcCQEYQCiMjY8LzaL0XHeKSUgAFKpZ lmkYQe+isbnp6V6ZP3gdx9kpFiUqA8AZEYABhMLo2FgsFpOo7H8Ou3HnjkRlAHim qATg2elpoW8ebdve3dmRqAwAZ0QABhAKuXw+kUhIVCYAA1DMT79+Bg56F43JBeBa rba/tydRGQDOiAAMIBRGRkb6BwYkKnueN3XrlkRlAHgmU9f9BBj0Lhqbn50V6j5o mebBwYFEZQA4IwIwgFAYGh4eHByUqEwABqCYoWl1me7K7SUXgA3DKB0eSlQGgDMi AAMIhUw2m0qlhIp/MDUl1OgFAJ6mV6u2bQe9iwZc111cWBAqrmlaJQp9sAF0IQIw gFBI+zIZoeKvvP56fnRUqDgA/IBWqTiOE/QuGiiVSpvr60LFq5VKtVoVKg4AZ0EA BhAWE5OTQpfxxiYmXn7lFYnKAPA0P/65oQ/AG+vr5VJJorLneYXtbYnKAHB2BGAA YSEXgFPp9NuXLklUBoCnVctl13WD3kUD3y4vC7WqJgADCDMCMICwGJ+Y6O3tlajc F4tduXZNojIA/IAffatRePz13vy8n1QlKvu/A8VCQaIyAJwdARhAWIyNjwtNpPRd u3lTqDIAPKlmWaZhBL2LxuZnZs7JfOfoOM5OsShRGQDOjgAMICxGx8ZisZhEZdd1 r9++LVEZAH4gKgF4dnpa6DtH27Z3d3YkKgPA2RGAAYRFfnQ0Ho9LVHYc58adOxKV AeAHLNP0fwW9i8bkAnC9Xt/b3ZWoDABnRwAGEBYjuVx/f79EZQIwAGVMwxBqLtVe cgHYsqyD/X2JygBwdgRgAGExPDIyMDAgUZkr0ACUMXS9XqsFvYvG5mZmhPoOmqZ5 eHAgURkAzo4ADCAshoaGBpNJicqe503duiVRGQB+QNc0u14PeheNzc/OCk2eM3S9 JDNhGADOjgAMICwy2WwqlZKoTAAGoIxerdq2HfQuGpMLwJqmVaIwCApAdyIAAwiL tC+TESr+znvvJWXSNQA8SatUHMcJehcNmIbxYGVFqHi1UqlWq0LFAeCMCMAAQmTy /Hmhyj+6ePHFCxeEigPAMT/+uaEPwMVicU9sUtH21pZQZQA4OwIwgBCZmJwUupI3 ks+/9sYbEpUB4EnVctl13aB30cDqo0eazCGt53mF7W2JygDQFgRgACEiF4AHk8l3 339fojIAHPOjbzUKj78uLy0JtaomAAMIOQIwgBAZn5gQGsvRF4tduXZNojIAHKtZ lmkYQe+isXvz835Slajsum6xUJCoDABtQQAGECJj4+N9fX1Cxa/dvClUGQAei0oA lhsC7DjOTrEoURkA2oIADCBERsfGYrGYRGXPdadu35aoDADHIhOAp6d7Zb5ttG17 V6y9FgCcHQEYQIjkR0fj8bhEZddxrt+5I1EZAI5Zpun/CnoXjc1+802fzLeN9Xp9 b3dXojIAtAUBGECI5HK5RH+/RGXXda9zAgxAmGkYNcsKeheNzU5PCz1v4v/P39/f l6gMAG1BAAYQIiMjI/0DAxKVCcAAFDB1vSbTXbm95J4Btkzz4OBAojIAtAUBGECI DA0PDw4OSlQmAANQwNC0er0e9C4akwvAhmGUDg8lKgNAWxCAAYRIdmgomUxKVPY8 b+rWLYnKAHBM1zQ7CgF4fnZWaOi6ruvlUkmiMgC0BQEYQIhkstlUKiVRmQAMQAGt WnVsO+hdNCYXgDVNq5TLEpUBoC0IwABCJO3LZISKX5makhsyDAA+rVJxHCfoXTTg 7/D+vXtCxauVSrVaFSoOAGdHAAYQIslkMjs0JFT81TfeyOXzQsUBoOe7+OeGPgCX S6WN9XW54rquCxUHgLMjAAMIl4nJSaGLeedffPHiSy9JVAaAx6rlsuu6Qe+ige3t 7YO9PYnKnucVtrclKgNAuxCAAYSLXAAezuVef/NNicoA8FilXPZCH4AfPXyoa5pE ZQIwgPAjAAMIl/GJCaHhHMlU6p333pOoDAA9341bq0ah/9Py0lJdZlix/ztQLBQk KgNAuxCAAYSLXACOx+OXr16VqAwAvpplmYYR9C4aW1xYELqnTQAGEH4EYADhMjY+ LtSr+Vxv79Xr1yUqA0BPdALw/Nyc0Oc/x3F2ikWZ2gDQHgRgAOEyOjYWi8UkKns9 PVM3b0pUBoCe6ATguZkZoYs2tm3v7uxIVAaAdiEAAwiX/OhoPB6XqOy67vXbtyUq A4DPMk3/V9C7aGx2elrook29Xt/b3ZWoDADtQgAGEC65fD6RSEhUJgADEGUaRs2y gt5FY3IBuFar7csMWAKAdiEAAwiXkVyuv79fojIBGIAoQ9eFuiu3l1wAtizrYH9f ojIAtAsBGEC4jIyM9A8MSFR2HOfGnTsSlQGghwD83SXwg4MDicoA0C4EYADhMjw8 PDA4KFGZE2AAogxNq9frQe+iMbkmWKZhHB4eSlQGgHYhAAMIl6GhocFkUqKy53lT t25JVAYAn65pdhQC8Pzs7LlzIp8ADV0vlUoSlQGgXQjAAMIlm80mUymJygRgAKL0 atW27aB30ZhcANY1rVwuS1QGgHYhAAMIl0w2myIAA4ggrVp1ujsAa5pWIQADCDcC MIBwSfsyGaHi127eFKoMAFql4jhO0LtobGFuTqhytVKpVqtCxQGgLQjAAMIlmUxm h4aEir/z3ntC96sBwI9/bugDsGkYD1ZWhIqXSyVd14WKA0BbEIABhM7E5KTQ9byX X3llbGJCojIAVMtl13WD3kUDB/v721tbEpU9zytsb0tUBoA2IgADCB25ADz54os/ fuklicoAEIkA7KdfPwNLVCYAA4gEAjCA0JELwCP5/GtvvCFRGQAq5bIX+gC8+uiR JvOYLgEYQCQQgAGEzvjERG9vr0TldDr900uXJCoD6HKu61aj0AB5ZXnZsiyJyv7v QLFQkKgMAG1EAAYQOnIBuL+//70rVyQqA+hyNcsyDSPoXTR2/949oVbVBGAAkUAA BhA6Y+PjfX19EpX7YrEr165JVAbQ5aISgBfm53s8T6Kyn6t3ikWJygDQRgRgAKEj F4DPnTt39cYNicoAulxUAvD87KxQkwUCMIBIIAADCJ3RsbFYLCZR2fO8qVu3JCoD 6HJRCcBzMzNCz5jYtr27syNRGQDaiAAMIHTyo6PxeFyisut51wnAAAREJQDPzsz0 yQTger2+t7srURkA2ogADCB08vl8PJGQqOw4zo07dyQqA+hylmn6v4LeRWMz33wj dMWmXqvt7e1JVAaANiIAAwidXC6X6O+XqEwABiDENIyazHih9pqdnhZqsuD/z9/f 35eoDABtRAAGEDojuVw/ARhApBCALcs6IAADCD0CMIDQGR4ZGRgYkKhMAAYgxND1 eq0W9C4akwvApmkeHhxIVAaANiIAAwid4eHhgcFBicqu616/fVuiMoAuZ+p6LQoB WK4LtGkYh4eHEpUBoI0IwABCZ2h4eJAADCBSonICLBeADcMoEYABhB4BGEDoZIeG ksmkRGXmAAMQYmhavV4PeheNzc/Onjsn8vFP1/VyqSRRGQDaiAAMIHSy2WwylZKo TAAGIETXNLvLA7CmlctlicoA0EYEYAChk8lmUwRgAJFCANY0rUIABhB6BGAAoZPO ZNLptERlAjAAIXq1att20LtoTC4AV32VikRlAGgjAjCA0PHTr5+BhYpfu3lTqDKA bqZVq04UAvDC3JxQZT/9+hFYqDgAtAsBGEDoDAwMDI+MCBV/9/JloRbTALpZJAKw ZVkry8tCxQ8PDkzTFCoOAO1CAAYQRpPnzwtVfuX11/Ojo0LFAXQtrVJxHCfoXTRQ KpU219eFim9vbQlVBoA2IgADCKOJyUmhp9R+dPHiixcuSFQG0M0iEYCLxeLezo5E Zc/zCtvbEpUBoL0IwADCSC4Aj01MvPzKKxKVAXSzaqXihj4Ab6yvC43qJQADiAoC MIAwkgvAw7nc62++KVEZQDeLRAB+9PChrmkSlQnAAKKCAAwgjMYnJnp7eyUqpzOZ n777rkRlAN2sWi67rhv0Lhp48O23Qn2q/P/txUJBojIAtBcBGEAYyQXggcHBS5cv S1QG0M0iEYCX7t+363WJygRgAFFBAAYQRnIBOJFIvP/BBxKVAXSzSATgxYUFoU0S gAFEBQEYQBiNjY/39fVJVO6Lxa5cuyZRGUA3i0QAXpif7/E8icqO4+wUixKVAaC9 CMAAwkguAJ/r7b16/bpEZQDdLBIBeH5uTuiTHwEYQFQQgAGE0ejYWCwWEyp+7eZN ocoAulalXPZCH4DnZmaEni6xbXtXZsIwALQXARhAGI2OjsbicYnKnudN3bolURlA N6uUSp7M7eI2EgzA9fru7q5EZQBoLwIwgDDKj47GhQKw607dvi1RGUA3i0YAnp7u lXm6pF6v7xGAAUQBARhAGOXz+XgiIVHZcd0bBGAA7RaJADw7PS3UXqFeq+3t7UlU BoD2IgADCKNcPp+QCcCu614nAANoK/8Plmq5HPQuGpMLwLVabZ8ADCAKCMAAwmgk l+vv75eo7DjOjTt3JCoD6Fo1yzINI+hdNCYXgC3LOtjfl6gMAO1FAAYQRiMjI/0D AxKVCcAA2o4AbJnmwcGBRGUAaC8CMIAwGh4ZGSAAA4gIArBpmocEYABRQAAGEEbD w8MDg4MSlV3HuU4ABtBWUQnAcl2g/f/5h4eHEpUBoL0IwADCaGh4eFAoANMEC0C7 RSYAi80BNgyjRAAGEAUEYABhNDQ0NJhMSlQmAANoOwKwoeulUkmiMgC0FwEYQBhl h4aSMgHY87ypW7ckKgPoWlEJwPOzs+fOiXz203W9TAAGEAUEYABhlM1mk6mURGUC MIC2IwDrmlaOwiRkACAAAwijTDabIgADiAgCsKZpFQIwgCggAAMIo0wmk0qnJSoT gAG0HQFYq1YrlYpEZQBoLwIwgDBKZzJpAjCAiCAAV6tHCViiMgC0FwEYQBglk8ns 0JBQ8Ws3bwpVBtCdohKAF+bmhCqXSyVd14WKA0AbEYABhNFgMjlEAAYQEQTgUqlk EIABRAEBGEBITZ4/L1T5vStX+vv7hYoD6EKWafq/gt5FA/VabXlpSaj49taWUGUA aC8CMICQmpicFHpW7c2335a7Xw2gC0UiAFer1bVHjyQqe55X2N6WqAwAbUcABhBS cgH4337yk/HJSYnKALpTJALw/t6eUEwlAAOIEAIw0OFSqVRvX1+sr+9c75Fz3zn+ rz/4xyf5H2iO/+afXPfoL//4p57v/50r0ftELgC/eOHCjy5elKgMoDtFIgAXC4W9 3V2JykIBOJlMPn7b+v696ty579/D/vFe9uRb2AnvZcdvZ8f/6L9t+f9nO47rOJqm tX3nAMKMAAx0mkwm4yfex77/6KDEswPzv2bmx//Ncd1meqXIBeDxycl/+8lPJCoD 6E6RCMCbGxulw0OJyk0G4MFksu+JQPvMNNsw0Lbd4zzsfMf/f0wzBjoeARiIvHQ6 fXTGG4spTrxn9M/AfPRV/Pffxz95tpxMpYT+t4zk86+98YZEZQDdyTSMmmUFvYsG Vh890qpVicr+H9q6pv3LOW3vPy4d9fY+/pkIvTc9zsO2bfv/ryrzOwYgQNH4wwjA DzwOvXE/9MZivf/4eBF1jyPx4/TrJ2E/zwt9YMoMDb319tsSlQF0p0gE4AcrK0Kz mo6u9jhO7z+OdnuiE3cbOgrDtl0nDAMdpEP+eAK6RDqTicVi8Xg8Qie9IZRMp9+5 dCnoXQDoHJEIwN8uL4d/k6H1+GS4XvezsF3lmjQQZXyABiIglUr5oTeeSPT19QW9 l07QPzDw3s9+FvQuAHSOSATg+4uLjm0HvYtO4DhOvVbzwzANtIAoIgADoZYdGkp8 l3s5720jz/Mmzp/3Y3B/f/9gMjk4OMhvL4CzCGcA9v+ss77jpzXfwf7/396dOEd1 JYYebnVrV2tHYgcz2Bgbe+yxJzXlSl5VXt64MuX8vXFNyvPypuol5ZpK7PGGjbEZ zA4C7WjvJUfdSDSS0Eafvq2+31dYbgQ+92Kg7/npLmeqZW6ZaQbVC7/D/9i52dmk 9wU4AHM+aEb5fL69vb2zq8tkJYbNB1RnqgtBZbPrTw+rPDe7vXJbdeV0e2c1j7u7 u8OrpHcZaGpJBfDa2lro27Dp1bW1wupqofjMs8cKVh4sWP2ZW56xTB2F/8/ht2D9 0mg3CcNR4H0Qms7Q8HBIL9OURNQ+iCuzuRpH9pnthdwV+rhnXaJ7DSQsUgDXnr8t hMTdWKrnWdrW9m0m03oPoDpaqufbZ6ank94RYA/eIqGJDA4NhZ4yd2latWsd1353 /dmnG2t+rHdye3v1WWXVO7fXM7kSyeFTie06ENNBA7hQKFTP3K4/VKlatuFT1bjd LNvw742J2paydZhoWuE3bnl5OdJ6y0BdeAOFptA/MBDS1zOuWsDLIjlTcwnis7PJ lVSunlWuTeXw0UXXcLQsLy6uVp6KtH6u9sWsLVZWlS1VbhgtbbwtlGtmYOK29YTf +ZDB83NzSe8IsANvspC8kdHRkD8mPalSG8ZbUjn8SQivspnnxbx+arlyo3I1mDfP MCey55BO1fVv1oN2I2s3b7ItV8/Zvvjzt1+N7E0+VcIfivBnZmpyMukdAbbyXgxJ 6h8Y6Onp8aQrdldby9u/CzTMlojVtOyuVCotLS05FQxNxRs3JMYdvwDQ2twVDM3G zBuS4bJnAEgDl0NDUzH5hkbL5/M9vb2edwUA6VEsFpcWF60VDIkTwNBQ+f7+3t5e N/0CQNqUSqXF0MDz80nvCKSaAIbGUb8AkGYaGBIngKFB1C8AoIEhWQIYGkH9AgBV GhgSJIAhunw+39vXp34BgKr1Bl5Y8EwsaDwBDHH1Dwz09PSoXwCgVmjgpaWl+bm5 pHcE0kUAQ1zHT5yw2C8AsF25XH708GHSewHpYl4OER0bG2tvb096LwCAJlUoFJ48 fpz0XkCKCGCIZXBwsLunx+lfAOBlyuXy8tLS7Oxs0jsCaWFqDlHk8/m+fF79AgC7 Cw28/jgsD8SChjA7hyhc/AwA7JMLoaFhBDDU3+DQUHd3t9O/AMB+rF8Ivbw8OzOT 9I5A6zNBhzpz8TMAcFAuhIbGMEeHOjsqFz+HA+32T+p2AI66o3uAcyE0NMAReC+A I2RgYKCnt7fZjrLlivAim82259aFiUB7R0dfX1/4/OrKSqFYLBYKxVKpVCyWws8M Lyo/f/scYssvrdl+pQC0ni0Ho5cdm7LhYzjOtbVlw3Eum821t4dDXmdXV/jRhYWF wtpa+C/XD3fF9cNd9b9qtqNY+KUtLS7Ozc0lvSPQyprrrz0cdePHj4eDb9J78Uy1 e8eOH//dRx9V+zZMC0Kf9/T07P4frq2thSoOFhcXV5afCZ9ZDdbWCuFDoVCqzCHK pXVhJlKuTCYEMwB72mfQtoWYrXzptq3y1duQtR2haTs7Ozs6wodQtt0V4V+9vb1d XV3hMx0dHbtveilYXCyVy9VC/svnnz9+9KipSjgcVScePUp6L6CVNcvfdmgBQ8PD XZWvNCe4D2EaEY6dYTcuXLx45d13w8ygARutDeblpaXwohrMQUjlajCHAg9K1f2r 1PIWUhngSNszazMbNZtta1s/O9veXg3a8LGar+s1Gz729Ow/aOsiHLOufvvtzRs3 wmGrsncJH8fDbsxMTye4D9DaTDGhbo6fOJHUUbP2ZO/AwEAi+7B/IZhDIi8urAvN vBS+LS+vVJp5PZjX1sK3YqmUy+U6OjvDJzevVcsIY4CklWvukQm5GDJ1bXW1WCzm stn2jo7wLQRt53rIdveEb73r+vr6wj/hM40J2lcxNzeX+Gnh8P/20cOHiWwa0sBU Eupj9NixRI7rIQ7z/f3/6x//cXh4uPFbb7wnjx/fvnVr8smThadPV1ZWQidnKpOw zWmKQgZ4FZtnbp+9aGsLZRt6ti+fD0e6c+fPHxsbS3L/GmV6evr///nPT+fnE7mz aW1tLRzpGr9dSAMzRaiDvr6+UKENTq9SsXjuwoXfffRR839BvTGWFhf/duNGKOS5 ubnlpaVCoVB+sY2rFDKQZjteqNxWuSa5u6dnYGAg9O2vLl7s6e1NaAebSwjRv3z+ +e2bN7O5XCO3G35fQnsvLCw0cqOQEiaCUAdj4+O5Bh4aw3ExzFH+6eOPTVD2b+Lh w7t3705PTT2tnjp+SR5XiWTgKNrxttvN97pc5VbbfD4/PDJy5syZ8RMnGr6DR9XS 4uK/f/bZ3NxcI48OxWLx8cREwzYH6WGSB6+qf2Cgt4FLH5VKpfc//PDtK1cas7mU mJ6evn/37pMnT57OzS0vLxfW1koba0e97HdWJAONtGPcZmr6NltZ3667uzs/MHDs 2LFTZ86k5NaYhvn+6tWvvviiYVdEh9/ZxcXFeUsiQb2ZwMGrauTSR+Fw+H8+/tiX 7RtvcnLy4f37U5OTT+fnl5eW1p9rXSxuzkd3iWGdDOzuZWVb+0Pr528riwB19/Tk +/tHRkdPnDo1OjraqH3kmYmHD//vZ5818kvelkSCujMzg1cyODTU3d3dmGOh+m1y YWI0MTExPT1dfUDX6upqsVBYXyd54/zM7n9OpDK0kl2yNrPx6P5M9cxtZUHayrq2 6w+aGh4eHg+81TerRjZw+EOyvLw8OzPTgG1BephvwStp2Onf0FG/++iji2+80YBt EVWYPE1NTc3NzYVOri6bXKicT95M5So9DEfLlr+/61mbC2HbXl3YNpTtwMDAyMiI sm0BN3766S+ff96wo7+TwFBfJlhweI08/Xvp8uUPfvvbBmyIpjI5OTlTqeXFxcVQ y+tXX6+tFSq1XCoWk967etj1LNm+BqjLbsRR57cGXxNJVMjZEDztuVxHR0cI2vCt t7c3NO3QyIhLkVPoy//+7+vXrjVgQ04CQ905msLhNez0b5hn/fMnn4TYbsC2AIDd hSj9t08/XVpcbMC2nASG+hLAcEgDg4M9PT0NOP0bjnwf/f3fX7h4MfaGAIB9unnj xuf/+Z8N+Dp4uVxeWlqam52NvSFICQEMh3RsbKy9vb0BGzr/2msf/cM/NGBDAMD+ ff4f/3Hrl18asKFCofDk8eMGbAjSQADDYeTz+b58vgGnf7PZ7D9/8sng0FDsDQEA BzI7M/Nvn35aKpVib6hcLi88XRd7Q5AGAhgOY3h4uLOrK3YAhwPeB3/3d29evhx1 KwDA4fx47dqX//VfDZgPrK6sTE9PR90KpIQAhsM4fuJEA07/jo2P/+/f/74xz9kC AA6qVCr9vz/96fHEROwNhQZ+9PBh7K1AGghgOLCR0dHOzs7YWwnH1H/6+OMTJ0/G 3hAAcGgPHzz4988+a8BXq1dXV6cmJ2NvBVqeAIYDa8zqR29dufLeb34TeysAwCv6 +q9//eHq1dhbsR4S1IUAhgNrwPXPHZ2df/iXf+nr64u6FQDg1S0sLPzxX/91bXU1 6lZcBQ11IYDhwGIHcDjCvffBB29fuRJvEwBAHX1/9erXX34Ze3oggOHVCWA4mNFj xzo6OqJuor2j4w+ffJLv74+6FQCgXp7Oz//x008La2tRt7K2tjb55EnUTUDLE8Bw MA24AfidX/86fIu6CQCgvr775pvwLeom3AYMr04Aw8FEv/65VPr9H/4wNj4ebxMA QN09npj40x//2Bbzq+SugoZXJ4DhYGIH8MDg4G9++9tcRTabzb3ImsAA0LT+/Kc/ PYwZqAIYXp0AhgMYGRnp7OqKN344sL32q1+dOHXqZT8htPeOYVwbzLGfUA0AZCoX JG9x88aN7775JuqBeHVlZWpqKt740PJMlOEAxsbHQ2HGGz8cO999//1XfPzVljx2 GhkA9lSu2N60WxSLxeqL6s/fMsjT+flvv/oq6nE27MDjiYl440PLE8BwALGvfx4a Hn7z7bfjjV/lNDIALW8/NbtFXbb74/ffz0xP12WoHbkKGl6ROS4cQNQA3vP650ba 5TRy9XX4KJIBaJiD1uz207ON8fD+/V/+9reoswUBDK/C/BX2K5/P9+Xz8Q5pxVLp 3ffe6x8YiDR+3dWG8fZCFskA7Gjz3OzuJ2m3/GjSe71f83Nz3379dS7aVdDhf8vC 03WRxoeWZ24K+zU6OtrR2Rlv/FDXV3796xYrxh3DuPY0ssutAY60HSN2z7JNeq8j Cr+6q998sxAzUNdWVycnJ+OND63NvBP2a/z48XiPtQjHy7Pnz58+ezbS+M2sek/y liqu/ehkMkBj7Nmu2xO3tWv2cO7duXPn1q14h63wv33i0aNIg0PLM6GE/Yp6A3Cx WHzrnXeGR0Yijd8CshU6GWBPWx5ovKVpd/lu0jveIqanpn747rt4y0a4DRhehZki 7FfUAG7LZt/74IOumIsMp8TmM64327j2hUuvgSOktmOrL/aZtc7KJmtlZeXrL78s R/uCggCGV2H+B/sVNYCPjY1dvHQp0uDsKPxu7hjJO2Zz0jsLHGFbLhh+2Yvtn9Sx R9eN69efPH4caXABDK9CAMO+jIyOdkZ7AlY4kp27cOHU6dORxufVZfetem7Z6WVo GZunYV/2cffvith0un/v3u2bN+MdC1ZXV6c8BwsOxRQN9iXqE7DcANx69uzk6vnn 2teaGequtl23ROl+vrv5OulfB0dP7NuAPQcLDs18C/Yl6vXP2coNwJ1uAE636nnj XQp5y+vaF0nvO9RNucZmf27/7o6vtxds0r8a0mu1chtwvD+EroKGQzNtgn1xAzBN q21DNYYP+mLL66R/NRwB5W0yG4vB7vij+2xayUqLcRswNCdzHdiXqAF86syZs+fP Rxoc9m/HJK5t4+2fPNyPJvzrbAm15Zmpyc79vK797ss+v4vkftFwlNy5dev+3buR BhfAcGhmIbC3oeHh7u7uSIOXSqVfvf768ZMnI40PzWmziuvyccuwO27rcJ/c0nvb 82/3n7Djd/fzcT8/AWhmjx48+NvPP8d7gMjy8vLM9HSkwaGFCWDY27Gxsfb29kiD l4rFd95/v39gINL4AEDjzc/NfffVV9loz8EqFArxLrGGFiaAYW9RHwHd29d35d13 4x0gAYDGKxWLV7/9dnFhIdb4HgQNhyKAYW9RbwA+efr0uddeizQ4AJCU27/88uDe vUiDuw0YDkcAw97iPgHr7Nmz585FGhwASMqd27fv37kTaXABDIcjgGEP/f39vX19 kQK4VCq98eabx8bHYwwOACToycTETz/+GOkuqhDAiwsL8/PzMQaHFiaAYQ+jo6Md nZ2RBs+2tb334YedXV2RxgcAkrK6svL1F1+Uoj25fW11dXJyMtLg0KoEMOxhbHw8 F+0JVcOjo5cuX440OACQrOvXrk1Ha9Risfh4YiLS4NCqBDDswQ3AAMDhuA0Ymo0A hj3EC+Bw3Dp34cKp06djDA4AJO7+vXu3b96MN5EQwHBQAhh2k8/n+/L5eE/Aev3S pbHjx2MMDgAk7vGjRz9fvx7vOVgLT9fFGBxalQCG3QwMDvb09EQK4HA4/PVvftPV 3R1jcAAgcSvLy9/89a+lUinG4CGAl5aW5mZnYwwOrUoAw26OjY21t7dHGnxwePjy 229HGhwAaAbXvv9+dno60uCFQuHJ48eRBoeWJIBhN+PHj0e6bCk4debM2fPnIw0O ADSDO7du3b97N9LgpVJp4tGjSINDSxLAsJuoj4A+c+7c6bNnIw0OADSDe3fu3L19 O9LgnoMFByWAYTfxzgCHI9ZrFy+eOHkyxuAAQJN4+ODBLzduxHugpjPAcCACGHYT 7wxwsVi8fOXKyOhojMEBgCYxNTl57erVXC4XY3BngOGgBDDsJl4A9+bzV955Jxvn cAgANIlSsXj1u+8W4yxWJIDhoAQw7CZeAHsCFgCkRLznYAlgOCgBDC81NDzcHW2R 3lNnz549dy7S4ABA87hz+/b9O3ciDb68vDwTbZklaD0CGF5qZHS0s7Mzxsjlcvn8 hQsnT5+OMTgA0FQe3Lt36+bNSNeUra6uTk1OxhgZWpIAhpc6NjbW3t4eY+RSqfTG 5cth/BiDAwBN5cnjxz9duxZpXYlCoRDGjzEytCQBDC8Vbw2kYrH4znvvDQwOxhgc AGgqc7Oz3339daQHQVsJCQ5EAMNLxXsCVqlcfu+DD3p7e2MMDgA0lcXFxa+//DIb Z1LhOVhwIAIYXiriI6A9AQsA0iTec7AEMByIAIaXEsAAQF0IYGgSAhh2NjQ01N3T E2nws+fPnzpzJtLgAECzuX/37p1btyINvry0NDMzE2lwaDECGHYWdQ2kCxcvHj95 MsbgAEATevTgwc0bN6yEBIkTwLCzqGsgXXrrrdFjx2IMDgA0ocknT67/8IOVkCBx Ahh2Nj4+no2zXEGxWHz3/ff7BwZiDA4ANKH5ublvv/oq1kpIxeLExESMkaH1CGDY mTWQAIB6sRISNAkBDDuLF8Cnz5494xHQAJAyd2/fvudB0JA0AQw7E8AAQB0JYGgG Ahh2MDg42N3TEymAQ/2GBo4xMgDQtEL9hgaOMXII4OWlpdnZ2RiDQ4sRwLCD4eHh ru7uGCOHQ9RrFy+esAYSAKTMwwcPfom2EtLK8vL09HSMkaHFCGDYwejoaEecRYBL pdIbb755bHw8xuAAQNN6MjHx048/RloJaW11ddJSwLAPAhh2EG8R4GKx+Pa77w4N D8cYHABoWjPT099/+22klZAsBQz7JIBhB+PHj0f6Am2xVHrvgw/6+vpiDA4ANK2F hYWvv/wyF2eCUSqVJh49ijEytBgBDDuI9wjoTFvb+x9+2NXVFWVwAKBZraysfPXF F5lyOcbgHgQN+ySAYQfWQAIA6s5KSJA4AQw7EMAAQN0JYEicAIatBgcHe3p7Iw1+ 9vz5U2fORBocAGhm9+/evXPrVqTBlxYXLQUMexLAsNXQ8HB3tEWAz1+4cPL06RiD AwBN7sG9e7du3ox0ldny8vKMpYBhLwIYthoZHe2MswjwpnLlARilUil8zOVyXd3d b771VrzTzgBAIy0tLv74ww8ry8vFYjF8t7q0RKzna25YXV2dshQw7EUAw1Zj4+OR 1ujbU3lDtq0t195++Z13+vv7E9kTAGA/5ufnr333XbFQKJXLbRsS2ZMQ248nJhLZ NBwhAhi2ircI8KE9D+Nstr29/c233+4fGEh6pwAgRebn5n78/vtCCN1SKdnQfRlL AcN+NNffW2gGERcBrrctZ4wvvfXW4NBQ0jsFAEfY7MzM9R9+aIYzugflQdCwH0fj 7zM00hEK4JfZDOPwOpfNtnd2vn7pkjYGgKpQuT9fv15YXS1WnsdxtEL3ZQQw7MfR /nsOMbRAAO+ito2zuVx7e/vFN94YHhlJer8AoM6mp6Zu/PTT+kXLlSdRtUbl7kIA w3607FsAHFprB/AuqlVczeO2bDaXzXZ0dLx28aI8BqA5hcT95caNtbW1YqlU3rg1 NxP/ecvNSQDDfqTx3QF2EW8R4KPuhTxua6vedXz+woWx48eT3jUAWtbjR49u3bxZ vSO3vHFTbiatibsnSwHDnrx3wAtGR0c7Ii8C3KqeXVldCeX16UnlHPLZ8+dPnDqV 9K4B0KQe3r9/59at6vnb9b7NPL9SOeldO5LWVlcnLQUMu/LmAi9IcBHglld7DjlT E8mnz549deZM0nsHQJ3dv3v33p07m3Gb2WjbjPO30VgKGPbk3Qde0ISLAKfNDp3c 1hY6OdfRcfLUqZOnTye9gwCp9uDevQf37xert92++F6dUbZJsxQw7MmbFLwgtU/A OnKqU65MTSoH2fB7F1I5l2vP5Y6fPOnEMsB+3L9799GDB4XiuvWE2nhTrb0U2cHx SPAcLNiT9zJ4gQBuVZsnljM18ZytXIa9Lpc7Nj5+/rXXEtxDgHq59csvTyYmSsVi qXL5cW3QbvlIixHAsCfvffACAcym2pPMmx83J47VG5hDOQ+PjFy4eDHB/QRa1c0b N6anpkLH1t5Gu+W9qPozHbmoEsCwJ2+X8AIBTF3sGM+Z6ntu9ZLCyo3N1ZPPg0ND v3r99aR2FYjkbz//PDszUz0NG/7J1Dwqv0rEUncCGPbkrRZeIIBpHjXz5G0h3dZW rryDP1stJPtMPp+/9NZbyewutITrP/zw9OnTUkV54yFP1b9u5Z0uJK79DCROAMOe vF/Dc4NDQz09PUnvBQDAIS0tLc3OzCS9F9C8BDA8Nzwy0tXVlfReAAAc0srKyvTU VNJ7Ac1LAMNzo8eOdXR0JL0XAACHtLa2NvnkSdJ7Ac1LAMNzY+PjuVwu6b0AADik YrH4eGIi6b2A5iWA4TlPwAIAjjTPwYLdmevDcwIYADjSBDDszlwfnhPAAMCRJoBh d+b68Iw1kACAFmAlJNiFAIZnrIEEALQAKyHBLgQwPDc8PJzN5bIVroUGAI6Kcrlc qioWp6enk94daF6m+LCbwcHBzSRWxQBA4p63biV3Z2dnk94jOErM5uHAVDEA0ABa F+rOxB3qY0sVh88IYwBgP0Loho9aFxrABB3iGhoezlXCuG1D0nsEACSmvKHSucUZ 9+tCY5mLQwIGh4ZyNU/bUsUA0Ho2Q7faupYmgmZg2g3NYmBwcL2JnS4GgCOl9qTu eumWSnMuYIZmZXoNza727mJhDABJeSF03akLR5NpNBxVz8I41LBLqQGgfjYrt/JP WehCKzFdhhY0ODRUu0qTNgaALbaezi2V3KMLaWBODOmyvY0zVmwCoBVV1xZSuUAt s17gmYHBwc0wlscANL8tibsZup5BBbyMeS2wL9U83mzj8E/GxdUARFaN2/Cv0ouV K3GBwzFzBepjYGAgm8vVnj12DhmAXdSev33hLG6xODc3l/TeAa3JrBRonOeRXAll kQzQqrbGbTVtxS2QNDNOoOlsdvLzVM5kMlIZIGmbWVt9tZm1yhY4KswjgSOsf2Ag F1I5vJfVXnedUcsA+7W1aWvO2YbvFovFeVkLtBBTQyBFngVzTSq3bTzNK1NTy7IZ OIqqKZvZ0rQvZq2gBVLOJA9gD5vnmTNtL8hspLJyBupoh4598UlR1U9JWYBDMFcD iKgaz5nNds5svTx7+6XaKhqOrs12zWzL18y2y4wzIhag4UyzAI6A/v7+XHt7pvqu vf0EdPXfldcZCQ2H9SxfNyp2s1c3q3Xzh4qFwvz8fGI7CsBhmSQBAACQCgIYAACA VBDAAAAApIIABgAAIBUEMAAAAKkggAEAAEgFAQwAAEAqCGAAAABSQQADAACQCgIY AACAVBDAAAAApIIABgAAIBUEMAAAAKkggAEAAEgFAQwAAEAqCGAAAABSQQADAACQ CgIYAACAVBDAAAAApIIABgAAIBUEMAAAAKkggAEAAEgFAQwAAEAqCGAAAABSQQAD AACQCgIYAACAVBDAAAAApIIABgAAIBUEMAAAAKkggAEAAEgFAQwAAEAqCGAAAABS QQADAACQCgIYAACAVBDAAAAApIIABgAAIBUEMAAAAKkggAEAAEgFAQwAAEAqCGAA AABSQQADAACQCgIYAACAVBDAAAAApIIABgAAIBUEMAAAAKkggAEAAEgFAQwAAEAq CGAAAABSQQADAACQCgIYAACAVBDAAAAApIIABgAAIBUEMAAAAKkggAEAAEgFAQwA AEAqCGAAAABSQQADAACQCgIYAACAVBDAAAAApIIABgAAIBUEMAAAAKkggAEAAEgF AQwAAEAqCGAAAABSQQADAACQCgIYAACAVBDAAAAApIIABgAAIBUEMAAAAKkggAEA AEgFAQwAAEAqCGAAAABSQQADAACQCgIYAACAVBDAAAAApIIABgAAIBUEMAAAAKkg gAEAAEgFAQwAAEAqCGAAAABSQQADAACQCgIYAACAVBDAAAAApIIABgAAIBUEMAAA AKkggAEAAEgFAQwAAEAqCGAAAABSQQADAACQCgIYAACAVBDAAAAApIIABgAAIBUE MAAAAKkggAEAAEgFAQwAAEAqCGAAAABSQQADAACQCgIYAACAVBDAAAAApIIABgAA IBUEMAAAAKkggAEAAEgFAQwAAEAqCGAAAABSQQADAACQCgIYAACAVBDAAAAApIIA BgAAIBUEMAAAAKkggAEAAEgFAQwAAEAqCGAAAABSQQADAACQCgIYAACAVBDAAAAA pIIABgAAIBUEMAAAAKkggAEAAEgFAQwAAEAqCGAAAABSQQADAACQCgIYAACAVBDA AAAApIIABgAAIBUEMAAAAKkggAEAAEgFAQwAAEAqCGAAAABSQQADAACQCv8DRMCa nmMbZ5EAAAAASUVORK5CYII="/></symbol><use xlink:href="#c" width="1280" height="1280"/></g></g></svg>')} -.is2d .king.black {background-image:url('data:image/svg+xml;base64,<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="614.635" height="614.635" viewBox="0 0 460.977 460.977"><mask id="b"><use xlink:href="#a" width="1280" height="1280" transform="rotate(.193) scale(.36014)"/></mask><symbol id="a" viewBox="0 0 1280 1280"><image width="1280" height="1280" xlink:href="data:image/png;base64, iVBORw0KGgoAAAANSUhEUgAABQAAAAUACAAAAAA9j6ArAAAACXBIWXMAAA7EAAAO xAGVKw4bAABWPElEQVR4nO3dB3gUdeLG8fxjCCEiAlIVRETBimLFXrFXTuzlbGev p2dXVGynZ+9dsZezgqfYUFSsgF0EAQHpvYUkJH+KYDbZ3ezMzsz7K9/Pc89zd0pm v0LymuzOzvxfAQB46v/UAQCgwgAC8BYDCMBbDCAAbzGAALzFAALwFgMIwFsMIABv MYAAvMUAAvAWAwjAWwwgAG8xgAC8xQAC8BYDCMBbDCAAbzGAALzFAALwFgMIwFsM IABvMYAAvMUAAvAWAwjAWwwgAG8xgAC8xQAC8BYDCMBbDCAAbzGAALzFAALwFgMI wFsMIABvMYAAvMUAAvAWAwjAWwwgAG8xgAC8xQAC8BYDCMBbDCAAbzGAALzFAALw FgMIwFsMIABvMYAAvMUAAvAWAwjAWwwgAG8xgAC8xQAC8BYDCMBbDCAAbzGASFhp 61G1/1JhhwllihR4jwFEUtbdoVuXDp0z/u2fRv/8zcdjEuwBGEDErnCjHTZfv127 HH/16LE/fvXR8FiDgOUYQMSnxW7bde24ZqgPHTlyyMcD50bcA9TCACIOTXvs0q1j 67wPM+7Xr979iKcHERsGEBFr1atH146RHvHHr/u9MT/SIwLLMICI0NZ/32HDmA49 +O2+I2M6NPzFACIibc/Zf4OYH+KTZx7nO0FEiQFEFNa98uhkHui3p26bmcwjwQcM IPJWfNk/2iT4cN/e+GyCjwanMYDIU4t7eyX+mFf0Sfwh4SQGEHlp/sR+kse95irJ w8IxDCDycf0lqkee8o9XVQ8NdzCACK/ze7m+wS0O/Q+sFD46nMAAIrSz7tQ+/sSD B2sDYD0GEGE9dZS6oODUB9QFsBsDiJDe30VdsFjvq9UFsBoDiHAG7K4uWOqy69UF sBkDiFAePV5d8Kdj+6oLYDEGEGGcep+6YLlpu36rToC9GECE0PHXldQJK/wY1/Vn 4AEGECGMCXeZ51hUPX2sOgHWYgAR3KXXqQtqmrnvp+oE2IoBRGAlMxuqE1J8tq26 ALZiABHYIyeoC1LNO5nrYyEcBhCBzW+kLqjlQxPOyYaNGEAEpX4LcF2cCoOQGEAE NVZ5CZi0qvr+XZ0AOzGACKjtH+qCukasqy6AnRhABHTreeqCumYd2V+dACsxgAho 1FrqgroWPXKKOgFWYgARTGFFoTohjW82VxfASgwggjnoFXVBOhO6TVInwEYMIIJ5 7jB1QTrzznpMnQAbMYAIZuTa6oJ0Fj10mjoBNmIAEcyCEnVBWu/vpi6AjRhABNJ8 mrogveFd1AWwEQOIQI54Rl2Q3sStxqoTYCEGEIHcdaa6IL1Zx7yhToCFGEAE8tEO 6oL0Fl51kzoBFmIAEYiJ7wNZYtHDp6oTYCEGEIHMXkVdkF71mweoE2AhBhCBLDLx jXBLDN5GXQALMYAIonSeuiCTn9dXF8BCDCCC2PwrdUEmozuqC2AhBhBBHPOkuiCT id3HqBNgHwYQQVx9pbogk+kHDlInwD4MIIJ48hh1QSZzTuHemAiMAUQQ7+2qLsik 7NLb1AmwDwOIIIZuoi7IpOKWS9UJsA8DiCDGrKkuyIS3giAEBhBBTGuuLsik+oXD 1QmwDwOIIKrVAZn9uKG6APZhABEEAwinMIAIYNB26oLMuCAWgmMAEcD41dUFmVU9 dpI6AdZhABHA/Ebqgiz67acugHUYQARg7MWwlvhsW3UBrMMAIgCDXwMpKBjaTV0A 6zCACMDoAfzW2HepwFgMIAIwegC/66ougHUYQOTO3EshLLHg0tvVCbANA4jcmftO 4CUWPXSaOgG2YQCRu7krqwuyev1AdQFswwAid5UrqQuy+nhHdQFswwAid0a/BlJQ 8PUW6gLYhgFE7gwfwGGbqgtgGwYQuWMA4RgGEDl7w/A328477yF1AizDACJnIzqp C7KrvPs8dQIswwAiZ7OaqAuyq365lzoBlmEAkbOKInVBPT4w+p0qMBADiJxVmf7Z 8sXW6gJYxvRPaRjE8BeBCwqGbKYugGUYQOTM+AHkioAIiAFEzowfQE4EREAMIHL1 4/rqgvpU/OcSdQLswgAiV9ObqQvqU/3M0eoE2IUBRK7KG6gL6jVgD3UB7MIAIlfG nwVTUDB4G3UB7GL+5zRMYfxrIAUF32yuLoBdGEDkigGEcxhA5MqCAeRMaATDACJH Qy247W75Db3VCbAKA4gcTWmhLqhf1RMnqBNgFQYQOSprqC7IQT/Dr9kKwzCAyJEF Z8EUFAzaQV0Aq9jwSQ0jWPAaSEHBl1upC2AVBhA5smIAuTMmAmEAkSMGEO5hAJGb z6344bKs903qBNiEAURuJrZWF+Si6uFT1AmwCQOI3CwoURfk5LWD1AWwCQOI3Cwq VBfk5MNd1AWwCQOI3FjxGggXxEIwDCByY8kAciIggmAAkRtLBvCrLdUFsAkDiJx8 uJO6IEfD9/tVnQB7MIDIydh26oIczd55iDoB9mAAkZO5K6sLclS5yyB1AuzBACIn ljwFuNh+/dQFsAcDiJzYM4AHvKEugD0YQOSEAYSLGEDkYuvB6oKcXXRLlToB1mAA kYs/2qoLcjZ31y/VCbAGA4hcVBSpC3JWvecAdQKswQAiF/Y8BcjLwAiAAUQubBpA XgVBzhhA5MKmATzoNXUBrMEAIgd7vK0uCKDP1ZXqBNiCAUQOXu6pLgjgm55j1Amw BQOIHIxZU10QwKzdvlYnwBYMIHJQ1lBdEEDVHu+pE2ALBhA5qLLq84TzYJArqz6x oWLTi8AFBQe/qi6ALRhA1O+w59QFgdxxcZk6AZZgAFG/fvuoCwL5/qCR6gRYggFE /Sy6FMISc3f/XJ0ASzCAqN/CYnVBINU9eBkYuWEAUT+7XgTmZWDkzLLPbCgUVagL Avrbf9UFsAQDiHqd9JC6IKAH/zlXnQA7MICo13u7qgsC4uboyBEDiHpNaqUuCGj+ bvbcwgRSDCDqVd5AXRBQ9V7vqBNgBwYQ9bLrjXBLcE1U5IYBRH1KFqgLAjv8eXUB 7MAAoj7n3aouCOzpM2eqE2AFBhD1+XQbdUFgo/f9UZ0AKzCAqM/U1dQFgZX1GKRO gBUYQNTHopuir7Bvf3UBrMAAoj72vQjMNVGRIwYQ9Wg6Q10Qwt+fUBfACgwg6tH7 KnVBCK+ePFWdABswgKjH15upC0IYv9f36gTYgAFEPWauqi4IobzHR+oE2IABRD0q V1IXhMHLwMgFA4h62PgiMNdERW4YQGTXYbS6IJQz7lUXwAYMILK7/Rx1QSjvHjtB nQALMIDI7vsN1QWhTNprqDoBFmAAkd2cxuqCUCr3+ECdAAswgMhuUaG6IJwD3lAX wAIMILKz80XggoJeL6kLYAEGEFltOkRdENLFN6kLYAEGEFk9ery6IKRPDx+rToD5 GEBkNaKTuiCk6Xt8rU6A+RhAZDW/kbogpEV7D1AnwHwMILKqsvYzhFtjon7Wfnoj Gba+CMzLwMgFA4hseryjLgjtxisq1QkwHgOIbF7uqS4IbWjPUeoEGI8BRDZj26kL Qpuzx2B1AozHACKbsobqgtCq9/mfOgHGYwCRjb0vAnNNVOTA4s9vxK+oQl2QhyOf VRfAeAwgsjjrTnVBHp46a6Y6AaZjAJHFoO3UBXkYvT+3xkQ9GEBkMa25uiAPC/cc qE6A6RhAZFFRpC7IB9dERX0YQGRh7xvhljj0RXUBTMcAIrM1xqkL8nLmPeoCmI4B RGaW3hJzufeP5taYyI4BRGY/bKAuyMuUvbkmKrJjAJHZ3JXVBXnhmqioDwOIzGx+ I9wSvBkO9bD8MxyxsvtF4IKCw59XF8BwDCAy2v91dUGebr+oXJ0AszGAyKj/3uqC PP100HB1AszGACKjia3VBXlasNdH6gSYjQFERuUN1AV5qj6QN8MhKwYQGdn+Ggiv gqA+DCAyaT1RXZC3M+5VF8BsDCAyWVSoLsgfZwIiKwYQGVh9Ofzlju2rLoDRGEBk cO3l6oII9D9+sjoBJmMAkcFvHdUFEZi1FzcHRhYMIDKw+2rQyx38qroAJmMAkYH9 J8EscdQz6gKYjAFEeufdqi6IxAunTVcnwGAMINIbvq66IBLT9+VJQGTGACI9698H t0x1T54ERGYMINJz4ynAgoJjnlIXwGAMIGr6sEPzRkXufVJUL1o4a8opn6szYBz3 PtcRwperr9pwJR8+F6qryufOPHmgOgOm8OGTHhm816F5aQMH3vAbSnVl2awp5zGF nmMA/TO0zSrFXny7l6Oqinmzz31NXQEJvg58ce067do0a1zMH3hGlfNnThk//sGh 6g4kiK8Hx/Xu0qFt81In3tWWmKqFsyaNHfPIEHUH4scAOur2ddq3blLCH29eKuZO +2Ps/YPUGYgPXyGOuWu9Di0au3EOszmqFsz4Y/S9vGDiIAbQEZds3KldM77ji1fl 7Emjhz/9pToD0eErxnY3b7hW6yY8x5ek6gXTxo985AN1BiLAAFrrqk06t111JXWF x6rLpoz++WnuPGw1BtBCT3XZQp2Av8yZOPZBbr9pKQbQJrdsups6ARkNHf5Ef3UD AmIA7fDIhlurE5Cbdx5/Vp2AnDGAhrtoqy4bqhsQ3KAfnudVEgswgMbqs9ne6gTk 6Zufnn9D3YBsGEAD3bbpzuoEROiHX5/jRRJDMYCGGbSdugDxuPJadQHqYgDN4sqF 6FHXe7urC1AHA2iUy/kuwWHbfaouQG0MoFGeOkpdgPgc21ddgNoYQKN8yVs8HNbn CnUBamMAjcJTgC576hh1AWpjAI3CALps4M7qAtTGAJrkn7eoCxCnLb5WF6AWBtAk d56lLkCcDuBtIaZhAE3y9h7qAsTpvNvVBaiFATTJz13UBYjTHeeqC1ALA2gSXgNx 20u91AWohQE0CQPotk+2VxegFgbQIBfcrC5AvLbijnKGYQANcss/1QWI197/Uxcg FQNokP8erC5AvE59QF2AVAygQQZz3w/HXd1bXYBUDKBBeA3Edfefpi5AKgbQIAyg 6148VF2AVAygQRhA13FRaNMwgAZhAF335VbqAqRiAA3CALruh43UBUjFAJrjkuvV BYjbNoPVBUjBAJrjxovUBYjbHgPUBUjBAJrjoZPUBYjboS+qC5CCATTHc4epCxC3 Ex9VFyAFA2iON/dVFyBuZ9+lLkAKqwawfaPh6oQ4DdxRXYC4XXqDuiBGnReMVScE ZtUAOo63ArvvmqvUBUjBAJqDu6K777rL1QVIwQCa45tu6gLE7cZL1AVIwQCa49uN 1QWI2y0XqguQggE0x3e8T8p5/7lAXYAUDKA5GED3MYCGYQDNwQC6jwE0DANoDp4D dB/PARqGATRG51/UBYgdFwQ0DANojK7D1AWIH19wZuHPwxgMoA/4gjMLfx7G6DRC XYD48QVnFv48jNFhtLoA8eMLziz8eRij7R/qAsSPLziz8OdhjKYz1AWIH19wZuHP wxgMoA/4gjMLfx7m4K6Y7hveRV2AFAygORhA9zGAhmEAzcEAuu/n9dUFSMEAmoMB dN+PG6oLkIIBNAcD6D4G0DAMoDkYQPcxgIZhAM3BALqPATQMA2gOBtB9DKBhGEBz MIDuYwANwwCagwF0HwNoGAbQHAyg+xhAwzCA5mAA3ccAGoYBNAcD6D4G0DAMoDkY QPcxgIZhAM3BALqPATQMA2gOBtB933PvZ7MwgOZgAN03bFN1AVIwgOZgAN33zebq AqRgAM3BALrvqy3VBUjBAJqDAXTf4G3UBUjBAJqDAXTfZ9uqC5CCATQHA+i+j3ZS FyAFA2gOBtB9H+6iLkAKBtAcDKD73ttdXYAUDKA5GED3vb2XugApGEBzMIDu67+v ugApGEBzMIDue+0gdQFSMIDmYADd9+Kh6gKkYADNwQC679kj1QVIwQCagwF035PH qQuQggE0BwPovgdPURcgBQNojp/WUxcgbnecqy5ACgbQHF9xqSTn3XCpugApGEBz fLy9ugBxu6KPugApGEBz9N9bXYC4nXe7ugApGEBzPHeYugBxO/FRdQFSMIDmuI0n yJ23Xz91AVIwgOY49zZ1AeK22RB1AVIwgOY46BV1AeLWZpK6ACkYQHNs9J26AHHj 680w/IGYo3ihugAxG95FXYBUDKBBeC+c67gnkmkYQIMwgK7jalimYQANMqyrugDx uvlf6gKkYgAN8uIh6gLE6+SH1QVIxQAa5NLr1AWI1zaD1QVIxQAapOswdQHixZeb afgTMQmvgrjt4x3VBaiFATQJA+i2e85UF6AWBtAkj3PHCKcd+ay6ALUwgCbZ4211 AeLUbKa6ALUwgCYpXKQuQIwGb6MuQG0MoFG+3VhdgPhwGrR5GECj/OsmdQHis9WX 6gLUxgAapXSeugCxGbapugB1MIBm4UQYd91/mroAdTCAZrniGnUB4rLdp+oC1MEA moWLojqL14BNxAAa5rPu6gLEg3uim4gBNMxeb6kLEA/OgjYRA2gaXgZx0ys91QVI gwE0zZ1nqQsQB26JbiQG0DSN56gLEIMvt1IXIB0G0DifbDGjrOnKReoMRKS6fFZZ 88pbr1V3IB0G0DjF5X/+jzs7rdmySQl/QpaqnDdj4tiXn1/2fwoLK7U1SI8vL/Nd 3qVjm9Ua8y2hHarLZk0eN+q1AeoO5IQBtMht67RvtWpJoToD6VTMnT5h3DNvqDMQ DANooYvW77j6ao0bqDOwWNWCWZPG/vbyIHUHwmEAbXbzOmu2btqIbwmTV10xZ9r4 sU/xg67tGEAXXLDe2mustkoD/jBjt2jBjIljRr/Ahf1cwdeMU25Yp0ObZo1WUmc4 p7p89pTxvz/OD7rO8WUAi9oWlk3z6EyE+zut0aJJsS9/urFZcirLH3d/oM5ITtFq JVUTPPo68WEA9zms++qlS58nq1ow6Zu3XpqtDkrS1V06tG22Mt8SBlNdNmvK778/ NETdkaSmvfbq1nrZKQZV8/8Y7MsNWl0fwG1v7F771dIp79/p4ZUp716nXcsmDV3/ 485TxbxpE8bd/rk6I3GF25+1c4vUv1Qx+GIvvkrc/oo48pa2af/67NcuG5twikEe Wnv1Fqs0VFcYZPTEP270+GWNjtfvu0q6vz7hgmeSTkmeywO47mvrZ/6bP1/8WnIl Jup0YrNVVl1l5dLSkuKGRSut5PInQhqTy8rmz5s7a87cNz4ur/9XO6zwb9evk/Fv /nTgrwmmSDj8ed/7iuwnyE3rc3tCJTbY8gt1QUJuP09dYJCiC6/P+verru2dTIiM swNY+M5u9f6a2df9O4ESOxz4qrogIY+dXqZOMEXR5VfV+2ve26MqgRIdVwew5PtO ufyymec/FneJJU65X12QkFdOmq5OMEPRKXfn8stGbuT0vzAcHcCiX9bO8VeOO3pg rCXGKko928ub+3G+e+yEmv+3qMrt73AyKdz7zRx/5W9dXD4v0NEB/HKL3H/t4IMm xRdiqqZza31W336OJiRxg48clfL/CxuXefgySKeXNs351361ZYwham4O4P2nBPnV ix4807PvAprMr/Mv9b5HK0IEvj3s51p/pbC0zOXvcdIovf+YIL/8gVPjCtFzcgB7 vB3wH2v64T5d1qPp7DR7/8Z+yYdIjOg1tO5fbFzu0XeBhT1fDPYB1Xu6++Xh4gAW TWsS+GPe339+DCVGKq5M9/3uoO0SD9EY/7d07/RI/5vipNavdg/6IbNXc/ZbZBcH 8PEw72Ms+0ffyENM1Hx2+s/lj3ZIOERl3CFp3+pW2GS+F98EFp1+R4iPeuLvUXeY wsEBbD4l3BVCP99rZsQlJirM8J3Ohzsl2yEz9m/p3/WW6TfGLR3e3CjMh1W1dPXc IQcH8MVDQn7gwpPd/yawKNPPMt4PYEFhgfMTWHz6bSE/8qVekYaYw70BbDwz/MWf Ptrb8WcCSzKe1Dpg9yQ7hEYf8nWGv+P884Bt39ws7Icuajo3yhJzuDeAN1+QxwfP 6/lOZCEGajE9/Zd4yYnHbuHNnUV+f/a+Men/TtMyl9/0UHR4Pj/g3HJhZCFGcW8A J7bO68OfCnSGlGWK0z3PX3z2yeu692mQ1dSX/j0qzV92+l0hTZ7ZN58Pn9QmqhCz OPeZv95PeR5gwg4jIwkxUOspdb7AC084o6s33/vVUP1H3zsn1Pmrzec7+y1g98/y PMD6tc8fd4NzA/jAP/I9wqLz7ooixECNaz+P0/W2HYskJSaoHtH7pVrfEZdUOnq+ W8lll+d7iAcDvbvKGs4N4Nh2+R/jwz3dPCWs1k/AZ/xrTVGIKeY83Wd8zf/v6s/A rd/qlvcxxrWPIMQ8rg1gUXkU/0Qzdv42gqMYp+Y5MC3uPLhEV2KMqq8vrHE1IDfP hCnc460IjlJd7OR3x64N4P6vR3KYqn/9J5LjGKXV1BVf3q0f3cvHZ/7SGnFO/xX/ 28UnAUuvzue8iL8c8EYkhzGMawMY6m1w6by/p3P/wmu6/J0urZ/owfzVMPKcfn/+ LwcvitC6f+iT/1K5+XY41wZw6CZRHWnqtq7dEKZ02VnerZ7Z1bU/9byNOWvZtzfu vQqy04dRHWlY7lcQtIhrXwrTmkd2qMp/OHa5/GVvA7nlXG6TnsanJy45zcO1N4OU XBjdhb6nrxbZoQzi2gBWRvnV/dwRER5Mb8lrIHs95eSncQQq7r5yrmuvgjR/of47 g+VskZNnTDk2gEUVkR5uxJYuXSCmsKrVa4EvBeeRyWcGvFCo6Tb4IdLDNXDt6YEl HBvAiP/IC+b3+DTaAwq1nnLGrU7+Szw6/U6eV+7My8BFhz4d7QE3/DHa4xnBsQE8 JOp/h1dddEvER5Tp8PzW6gTjTT3fmSuild54VsRH7PVSxAc0gWMDeOl1kR/yzQPd eFpox7dK1QkWqLrvAje+BWz9WuT/urvs+qiPaADHBvChk6I/5u+bT43+oIm79jLH /qjjMvhYF05/2vyr6I/58MnRH1POsa+KZ+J43XbBHoNiOGqy3umhLrDGhGPeUyfk q+iox2M46rNHxnBQNccG8JWD4jhq1Xl3xnHY5DT+Zl11gkXmnf2oOiE/ja89N47D vnpwHEcVc2wA++0Tz3HtPiOw1Y+c/BdE5eU3qRPy0eqFeO7v0j+vK6oayrEBjO3O Fj9uae/dQtb4Mfh9kv22qE9vdUJ4UZ8KtsK7Lj6N4tgAxndvs5lb2frceIcfVlYn WKfq5ovVCWHt06/+XxPOwJ3jOrKQYwP4/i6xHbqi12uxHTtOrUasok6wUNW1vdUJ oRSffXNsx/5g19gOrePYAL4Z49MU1VdfHd/BY9NkVHSXh/BJ5WX/VieE0OSuY+M7 eL/94ju2jGMDGPqm6Dmx8GWwwpFrqRMsteDsh9UJgbV9Jc43+zh5c3THBvCJGP8F uNhPW9j2Ugjn/4U26Vjb7hHddVish38yqosNm8SxAbzv1HiPP32LdPeTNdf1l6gL LPbdoXbdCXLfN+M9/v2nxXt8CccGMPYv+PJ9bHqbwLaDHPvzTdZLR1h0Aaii0++I +RFuuDTmB1Bw7Avk9HvifoTqc+y5a3DJZF4AzkdV72vVCTlrfOMZcT/EGffG/QgC jg1g3D8FLGHPHaIH7qgusNy04225E1qrp+J/sne/2M4wFHJsADf6LoEH+WRHOy6Q 1fNldYH13us5W52Qk3WHJ/AgG3+fwIMkzbEBLJ2XxKOM2dSGK+UXT+cdIPmy5Hzo bT9J4lFWtu0UiFw4NoAFVYn8A83a0oL3xb3g4mlbSRt39EB1Qv0ivw56WtVO3kva tQFcUJLIw1jwYnCH35z8hE2a+bcDLz4rmbs2lDVK5GES5toATmmRzONUnXF/Mg8U 2hdbqguc8OVW6oJ6nHpfQg80tWVCD5Qo1wbwl85JPdIdsVx0MjLdP1MXOGKbweqC rG4/J6lHGt4lqUdKkmsD+NEOiT3U23sl9lAhDOuqLnDEt5uoC7L5356JPdTHTp5U 5doAPnlMco/1czdzbyC26RB1gTO6DVUXZFQyZL3kHqxvvO+zF3FtAC+I73JodU3Z eFKCjxbIYO4BHJXPu6sLMmn9XZJPy13ozB2ya3JtAHf6MMlHW7Ctod8dNJ/q2h+s TnWL6eqE9BL+Ln9nC04ICs61r5NkzoReobKnme+VevhEdYFDHonhZtMR2P/1ZB/P yfOgnRvAgoqiRB+u+vzbE328HM3lTSDRmddYXZDOubcl+3iVDZJ9vIQ4N4DTkr4C /H2nJ/yAOUjimhAeMfEqAPcmfXG+6W7eWtW5Afxuo6Qf8Z3kzkTI1aDt1AVO+WR7 dUEdb++R9CN+v3HSj5gI5wbwv8nft+PHzQ07HaZwYbLPA7iusqFhl/8p+XqDxB/z lZ6JP2QSnBvAK65J/jEnbTQ1+QfN4pgn1QWOObavuiBFi+9bJ/+gV9pzcdggnBvA Xd4XPOjcLY26ewQXQo3YRzupC2pa7yfFo+76geJRY+fcABYvVDxqxZ4mfXrMd/K6 HUILStUFNUj+FV9Q0LBc8rBxc24ARV/9VSc8oXjYtLp9oy5wzmbmvLPwuMclD2vU vwMi5N4AjlpL87hX99Y8bl13x357HO/cc6a6YLneV2ked3RHzePGzb0BlN0K3JhL Z/7s5HWLpH5J8KIDWT2uujn5gMTPu0mGewN4w8WqRx64qxlnS5S7ec6+UkWxumCp wvdlr8bcGPcdt0XcG8Dd3pU99PBNTDghMJE7hPmmswk3gSkZltjlfuvY3fh7QITj 3gBqXgZexogTAi9384QtrSv6qAtEp/8t5+iLwA4OYME84etVczfXf/v1/i7qAgd9 sKu6oKDzL8IHn+/q1TUcHMARnYQPXr7bIOGjLzV+dXWBg/5YQ12w/cfKRx+5jvLR Y+TgAL6+v/LRq458Xvnwiy004wl7t5Q3FAcc9pz04d84QPrw8XFwAC+5Xvv44kuH N50hfXhXNZspffhEb/WQxqU3aB8/Ng4OoPx+QHefpXz0Q15UPrqzer2kfPS71Cdi G3xnqPw4OIAFVep/qNcPFD749Y6esCV2w6XCB39N/QNodaE4IDbqrYjDjKbqgi+3 rZQ99isHyR7aZa8mf53J5Yo+3VL22H+a2UxdEBcXB9CAe4KP2kh2B5khm6oe2WlD u6keufR7/dtwzb47fD5cHMC+R6sLCgqmbai6ZfDYdqIHdtu49qIHbj1R9MA1PXWM uiAuLg7gSQ+pCxabt4XoGqmzmmge13GzV9U8rubqp7Wd/LC6IC4uDqAR/84sqOih uZE0l0KIhehyCDt9KHnY2tqofp6JnYsDaMgGVB39rORhnfwjldO8DnrEM4pHrcOQ i+HEwcmvFlOeBlOcEl1UkfxjeqGB4IV99enPy8meAI2fkwP47m7qgj/dcW7iD7nG uMQf0g/txif+kLefk/hDpvfe7uqC2Dg5gFdfqS5Y7qVeST/i1oOTfkRPdP886Ud8 8ZCkHzGTa0TX4U+AkwPY/TN1wQqfbZ/wVaJ7vJPs43ljjwHJPl7hoG2SfcAstnH3 36pODmBhpTn/WL92TfYq0T1fTvTh/PG3/yb6cCXfrpvo42VTXWTGvR7iYM5SREn/ Zri/TN50QpIPJ7provv+nuh9T9sObZXkw2Xn7hvhXB3ArzdTF9RQvXmSl6c5/tEE H8wnJzyW4IOZdWvnbzZXF8THzQF84B/qghRJ/vQkvnCmuw5P8EK3hj2P8eAp6oL4 uDmAhn0CJXlCIJcDjEmCFwQ05fS/5RJ++jNRbg5g6Tx1QS03JXaz4n36JfVIntm3 f1KPdONFST1SjlaWXdoofm4OYMFc025ildi7yTkNJiaJnQZjxLU8aprXWF0QI0cH 8IcN1AW19b46mcfR3jzMYTskdLu/q3on8zi5+3FDdUGMHB3AJ45VF9SR0DPJvBMk Jgm9E8Sw1++WePI4dUGMHB1AE18LTeZOIWZcC8xByVwRSn73jzSSfP07cY4OYMkC dUEag7dL4oT66gQew0dJfKUUftI9gUcJqlGy72VKlqMDaMglAWsZvkkCn0qLnL2B l1TVSvE/RsmwzvE/SGAOXwywwN0B/E1/I5k0Jm44PfbHKGsY+0P4aGFJ7A/R/Ic2 sT9GCKPWVhfEydUBvPc0dUFaszYZE/dDzBTdvMJxs2J/e3mH0XE/Qjj3na4uiJOr A7jtJ+qC9BZsOzTmRzDyh3/7xf6D4KZJvmM8iO0+VRfEydUBNPa1gIq934v3AXgO MBZxPwe427vxHj88ZydiKWf/6RbE/5xNOFXHxHujm4qiWA/vq8p4v7E+8ulYD5+H skbqglg5O4A/rq8uyOj82+I8+ny3P2FVFpTGefTzbo3z6Hn5ybg3VUXK2QG84hp1 QWY3/yvGg5t0MViHxHpR0H9fGOPB83TlteqCWDk7gCVzEzhxK6y+Mb5Tb9wa8R3b Y+NjvNXqk8fEd+x8LWrs8mnQDg9gwR9t1QVZvNsjtkMP2TS2Q/tsaLfYDj3A5JtO TlhdXRAvdwfwvV3VBdkM2yKu+2wbc1Nkt8R2a9yirzaJ6ciReN/xTyd3B9C8ywql GL1hTFeZ7Ht0PMf13FMx/Zha+sNa8Rw4Ikldxk3F3QFc7yd1QXZTN5wcy3ENH35b xTQErX5oEctxI7P+z+qCeLk7gMafEDd305FxHNa0+6E4Ip77YnQaEcdRIxTz6Y96 Dg/g2Bhft4vEwh2+jOGoa4yL4aBoNz6Gg275RQwHjdS49uqCmDk8gG/uqy6oT+WB cdxop9Lg83+stSiOHycsuIFVv/3UBTFzeADPjfUNF5GoOuGJ6A86rXn0x/Te9NWi P+Zxj0d/zKidd7u6IGYOD6AVPwte9O/IDznU6NMqLDUs+rMr/3VT5IeMXiw/+ZvE 4QG049Kgt58X9REfPT7qI6LgsROiPuJt50Z9xBgkcBlYMZcHcEQndUEunjsi4gMe 8mLEB0RBQa+XIj7gs4dHfMBYjFxHXRA3lwfw+UPVBTn5IOK3rBSXufyHqlFdUh7t Ad/fJdrjxeSFw9QFcXP5a+XovuqC3Hy7ebRvi+NVkMhF/BpI0dddIz1ebI55Sl0Q N5cH0Mh7Y6bz+4ZzozzcwB2jPBoW+2inKI/W+Ic1ozxcjJy+I+ZSLg+gPZfGm7ZB lG+LM/jqmraK9Bq2rRK5xXoUYr0IohmcHsBPt1EX5GruZr9Gd7CmM6I7FpZqNjO6 Y607PLpjxeyzbdUFsXN6AK+9XF2Qs4U7fR7dwabGcNau16ZFeMWCrQdHd6y49blC XRA7pwew8y/qgtwtOviNyI712gGRHQpLvH5gZIfa//XIDhW/LvZ8sxqW0wNYsDDu m7lGqPofD0d1KKu+yGxwQGT/cjrpoaiOlIByG95JkCe3B9COU6GXi+72M9wcPVLR 3RTd5Ft11eX+adCuD+BTR6kLArn/tIgO9NXmER0IS3y9RUQHuu/UiA6UjKc9uLi4 2wN40CvqgmBeOyia45xxdzTHwVJn3hPNcV6N7qnERBz8qrogfm4PYFG5Zf98g7er iuIwxQsKozgMlqpqFMn74Ao/6R7FYZJTXRzXjbsMYtlABDWxtbogoOGbRHLu/Xcb RXEULPX9xlEcpWRY5ygOk6BJbdQFCXB8APvvrS4IauKG0yM4yll3RnAQLHP2XREc pPkP1s3JW/uoCxLg+ACeep+6ILDZm47K/yBFCwy/I5RFKhtF8JNgx9/yP0bSTrtf XZAAxwewySx1QXBl23+d/0E+3j7/Y2CpQTvkf4zNv8r/GIlbdba6IAGOD2DBzFXV BcFV7v+/vI+x27sRhGCJ3d/L+xB7vRVBR9Jm2XIpkby4PoCf2Ph27qqTHsv7GDYu v5Ei2IHjH42gI3GfbqcuSILrA2jXqfcrXNEn3yNwZ5CI5H83kMsje4dPoqJ7Y5LJ XB/A9r+rC8J58JQ8D9B2vOt/tMmoXmNCnkd44B+RhCRuzbHqgiQ4/1Uyr1RdEE7/ fG/rzt0xI5H3/TD7WXoyyfyV1QWJcH4Av+mmLghpyFb5nX3ByyCRyPMlkKIvrP38 20xdkAjnB/CGi9UFYeV7p5AJ1p15a6CJbfP6cHvu/lHHjZeoCxLh/AB2GqEuCG36 Rnk9/fTPW6IK8dgF/8nno9v+EVVH8tYZqS5IhPMDWLDA3pvbL+j+bR4fXTjP3n9y U5StnM/FKboOiywkcWWN1AXJcH8AbX4xIL9Toi27+pyJ8rpCo5WnPy+X94s/lnB/ AG/5p7ogD9WnPRD+g4vnWHRHACOVr5LHhbBOsfqttP+5QF2QDPcHcL2f1AV5ueHS 8B/Lt4B5yucbwOvtfhFh/Z/VBclwfwALyuy+tctzR4T+0KI5PAuYj7JVwp+J9Ozh EYYkb6EvnzkeDKDtFwf9dIfQT8T3virKEO9c3TvsRxZ+bON70GuI5iKwFvBgAK1+ EnCJkV3nh/3QGV5c0SMmM5uF/cjSb626HWEavjwF6MMA2nR79PSmbTI+5Ece8mKk IX7p9VLID1xjXKQdCh7cEn0ZDwawYL71pzQt2G5IyI8c1jXSEJ98G/b8qW7fRNqh sMDSd9AH58MAfm3/uxorD3kt3Ad2+I37w4VTtfaYcB94oAM3k/zGmxtL+zCA116u Lshf9fm3h/vAf18YbYg3bv5XuI8797ZoOyT6XKEuSIoPA2jrNQFT3X1WuI8b2y7a Dk+Max/u4+46M9oODT+uBbiEDwNYMKexuiAKIe9SuN4P/BAcXNWG4U4Etu8+rOnM XUVdkBgvBvCz7uqCSPy8eajTYS64OeoQD1wY6lI6pV+vF3WIxOBt1AWJ8WIAL7le XRCNad1C/WRi5Y2htMLdEMiN51oWu/QGdUFivBjAFlPUBREp22VwiI8qGd888hK3 TV+jLMRHdf8s8hCRllPVBYnxYgDdeUNE1d/7hviojr80iLzEZRVdRoX4qGOejDxE JPxbYOzjxwC+t6u6IDLXhTmnZ983/Phzjkb1/v1CfFSfyyIPUXl/N3VBcvz4wrD7 0mypXj8wxAedfk/kHe46494QH/TaAZF3yJyax0UobePHAJbOdeifM9SLwa68DpSA MK8AuPLy71LVjUNffMM+Dg1DNhNbqwsiNH2LEE9ROfQTWrzCPMfQ8bfoO3Qm+XQ7 QU8G8L8HqwuiVL5PiJvVOvEWrdiFesuhY7dgfqWnuiBBngygC29Qr6H6nLuCf9Bh z0Uf4pqqI58P/kFn3Rl9iNJBIS+8YSVPBrCwwrH3gz12QvCP2fKL6DvcMme3L4N/ 0KPHRx+iVNUgn1uB2saTASwYtZa6IGLfbBP8hmWNB1l8i9AEDNt+buCPKf7M/out pRrdUV2QJF8G8JEQ3zGZbeoWIa5Xd+NF0Ye4ourmi4N/UIevWkRfovXoieqCJPky gFuHeQ+Z2coP7h/8g9r/b4PoS5zw414h3mi9T5hTpg3X/XN1QZJ8GcCChe7dJLz6 2jA3fXPppPDozP5XmJN/r74y8hC5crvvIhuUNwM41MWnv97dM8zz1f+6KfIQy82+ 7t8hPqrw7d0jL9Ebtqm6IFHeDKCL/7IuKPhjiwlhPuzU89eNusRiv94a6pvitl+t HnWJCa7x617S3gxg64nqglgsPOCdMB/WdVjUIRbb5NswH7XH21F3mKHNJHVBorwZ QHcuiZWq+qZLQnzUDSFe8HTWjfwO/sWnS2Et4c8ADnDxCZslPts5+BmBjtwkIBoh LgBf/KGrF41/t4e6IFn+DOBxj6sL4jJj+x+DfsjMVeMIsdSswD8bbPBDHB1G+PsT 6oJk+TOAxWXO/rMuOjPgs/hNZ8QTYqlmM4P9+lPvi6fDANUlwX+csJqzo1CXyzfI feuAyiC/nCvDpDgv0BVgil534taX6YW9HbK1PBrAJ45VF8Royo5B7mP74U6xhdho 4M4BfvF6H7WMq8MATx6nLkiYRwPozk270ll00X9y/8U8BZgiyJOA/wx1w2BrbOPe W0az82gAC8rcfpPPpz1yvZJ582mxhthntek5/sLSAW7fY3lhibogaT4N4Dfd1AXx mnfwgNx+4aXXxRtinctyvGNKj1BnnVtkiGvX9qqXTwN4+bXqgphVP31cTu8NdvJ9 0fnI7f2vhU8cHXeI2hV91AVJ82kAPfjJb8qeQ3L4VeXcJz1VRS6XCur2tsuvfiyT 83MBzvBpAAumrqYuiF31IyfX+2sOeTGBELv0eqneX/LQSQl0iE1z7uqu9fJqAF26 eXVGUw76tJ5fMXDHREJs8lF95wVt+6r73/4VFLx+oLogcV4NoGP3hsug+tXDs57N X1jGT8C1VZRkffK0+DmnbquakVf3g1vGqwEsLF9JnZCIeaf1zfJ3uSR0GqdmuyD0 MU8m1iG1qNin+8Et49UAFvzSWV2QkB8PHp7x741cO8EQW4xcJ+Pf6vyKL7dRGd5F XZA8vwbw1vPUBUmpfuWYDKdFO3wlk3xsmOGKOqV9eyYbInTb+eqC5Pk1gB1GqwuS U37nRWl/oOFSgGmlvyhg4U0XJB0itFaIG63azq8BLJjVRF2QoHk3pjmtlW8A06ve KM23gJdfvHLyJTKzfXyHuGcD6OxlodObe8/ltS+TVS0JscDP69f6C0V9zmgsKVHx 7WLQS3k2gEc+rS5IWMWb56X8XMOVADNKvSpgh9v28+1soaOeURcIeDaAhRWF6oTE jb7n7rLl/9vtS4Llp2q7FZeCKjnzjLWEJRpVDfw7Cca7ASwY0UldIFD92/+eWfr2 kJMfVKeYrPL0h5b817ZH7rW2b18WS2Q5E8hhvv1J33mWukCkan4Dty+HGIWKWdWN Sv37GWGZu85WFyj4NoCdRqgLACOtM1JdoODbABbMXkVdABhojk9niP3FuwF8b1d1 AWCg93dTF0h4N4C+vLEdCOTYbBfQcJd3A1i00NcnuYHMqhoGurO0M7wbQD9PhAGy 8/MkGB8H8PZz1AWAce44V12g4d8AdvxNXQAYZ+1R6gIN/wbQryvCALnw8kowS3g4 gO/4eNELIJsBe6gLRDwcwCN8vOgFkM2Rz6oLRDwcQF9ujQTkysfbIS3j4QD6c2sk IDc+3g5pGR8H8Gaf7vMA1O+WC9UFKj4OYPvf1QWAUdYcqy5Q8XEAC2Y0VRcABpnZ TF0g4+UAvrmvugAwSL/91AUyXg7gga+qCwCDHPSaukDGywEsqChSFwDGqPTt/nc1 +DmA322kLgCM8f3G6gIdPwew91XqAsAYV/dWF+j4OYAtpqgLAGO0nKou0PFzAAsm t1QXAIaY0kpdIOTpAD5/qLoAMMQLh6kLhDwdwB0HqgsAQ+z0kbpAyNMBLChrqC4A jLCwRF2g5OsAfrGlugAwwpdbqQuUfB3As+9QFwBGOOdOdYGSrwNYMt/Xf3KgpurS MnWCkrczMGZNdQFggN87qAukvB3Ae09TFwAGuO90dYGUtwO47nB1AWCAzr+qC6S8 HUBuDwx4fEPgP/k7gP/bU10AyL29l7pAy98B7PmyugCQ+9t/1QVa/g4gV0UFfL4W 6lIeD+C3Hl8GEljqu67qAjGPB/CKa9QFgNiV16oLxDwewKYz1AWAWLOZ6gIxjwew YEIbdQEgNbGtukDN5wF84lh1ASD15HHqAjWfB3DTIeoCQKrbUHWBms8DWDB3ZXUB IDSvsbpAzusB/GBndQEg9OEu6gI5rwfwyKfVBYDQUc+oC+S8HsDC8pXUCYDMouIq dYKc1wNY8OP66gJA5qcN1AV6fg/gtZerCwCZPleoC/T8HsAWU9QFgEzLqeoCPb8H sGBSK3UBIDK5tbrAAJ4P4DNHqAsAkWePVBcYwPMB3HqwugAQ6f65usAAng9gwfxG 6gJAYkGpusAEvg/gx9urCwCJQTuoC0zg+wAe/6i6AJA44TF1gQl8H8CihYXqBECg qmGlOsEEvg9gwS+d1QWAwPAu6gIjeD+AN16kLgAEbrpYXWAE7wew9UR1ASDQZpK6 wAjeD2DBlBbqAiBxU1uqC8zAAL7QS10AJO7FQ9UFZmAAt/1EXQAkbrtP1QVmYAAL FpSoC4CElfEOqGUYwIJB26kLgIR9wjuglmEAC056SF0AJOzkh9UFhmAAeTMIvMPb QJZjAHkzCLzD20CWYwALCm7gnHj45cZL1AWmYAALClpxTjz80nqyusAUDOBikzkr Hj6Zwq1wlmMAF3v2cHUBkKDnuBXOcgxgAXcGgWe4G8gKDOAS3BkEHuFuIH9hAJcY uKO6AEjMRzupC8zBAC5x3OPqAiAxf39CXWAOBnCJf92kLgASc9G/1QXmYACXKF6o LgAS07BcXWAOBnApzgSENzgLsAYGcKlLr1MXAAm57Hp1gUEYwKWKKtQFQEIacCWY vzCAy0xvpi4AEjGjubrAJAzgMn0uUxcAibjucnWBSRjAZQoXqQuARKxUpS4wCQP4 p1lN1AVAAmavqi4wCgP4pxMeURcACTjxUXWBURjAPxVWcGcQuK+qAT8B18QALjes q7oAiN23m6gLzMIALnfEM+oCIHZHPqsuMAsDuEIVvxdwXTVP9KTii36FP9qqC4CY TVhdXWAYBnCFi25UFwAxu5gLv6ViAP9SrQ4AYsbXey38hvyFO4PAcdwNpDYG8C9v 76EuAGL1zp7qAtMwgH/Z6UN1ARCrnQeqC0zDANZQuZK6AIjRoiJ1gXEYwBpGraUu AGI0uqO6wDgMYA1PHaUuAGL09NHqAuMwgDXs009dAMRo3/7qAuMwgDVwRRi4jCvB 1MUA1jS2nboAiM249uoC8zCANb3QS10AxObFQ9UF5mEAazroFXUBEJuDX1UXmIcB rKmonN8PuKq6mBsC18EXfIrxXC0IrvpjDXWBgRjAFK8cpC4AYvLqweoCAzGAKQ57 Tl0AxOTw59UFBmIAU/AkIFzFU4Dp8PWeiuviw1FcDT8dBjDV7FXUBUAsBnC5yzQY wFRcEAZuqm48X51gIgYw1W3nqguAOExroS4wEgOYao1x6gIgDu/2UBcYiQGsZepq 6gIgBmfcqy4wEgNYy/O8YRwuWnW2usBIDGAtWw9WFwDRm9FcXWAmBrA27g4MBw3c WV1gJgawtg93UhcAkbvgP+oCMzGAtR3dV10ARG616eoCMzGAtXFjELhn9qrqAkMx gHX80lldAETsk+3VBYZiAOu4+QJ1ARCxS29QFxiKAayDN4PAOa0nqwsMxQDWNauJ ugCI1FwucpQBA1jX+7uoC4BIDd5GXWAqBrCukx9UFwCRuqKPusBUDGBdJfP5XYFT Vp+gLjAVX+ppTG6pLgAixFOAGTGAafTbR10ARIinADNiANM46SF1ARAhngLMiAFM o3SeugCIUJtJ6gJjMYDpTG+mLgAiwxuBM2MA0/loB3UBEJlBfDpnxACmc+l16gIg MlwLMDMGMB3eDgyHNJupLjAXA5gW18WHM7gdSBYMYFrfbaQuACIyYA91gcEYwLTu PU1dAETkxEfVBQZjANPa/mN1ARCN6pJydYLBGMD0KldSFwCRmNhWXWAyBjC90R3U BUAkXuqlLjAZA5jeM0eoC4BIHPCGusBkDGB6+7+uLgCiUNWgSp1gMgYwPe4ODDeM WltdYDQGMIPf26sLgAg8cpK6wGgMYAbPHq4uACLQ/XN1gdEYwAz2eFtdAOSvvKG6 wGwMYCYVReoCIG/fb6wuMBsDmMnwddUFQN5uulhdYDYGMJM7z1IXAHlbe5S6wGwM YCbr/aQuAPI1r7G6wHAMYEbzStUFQJ4+2V5dYDgGMKPPuqsLgDydc6e6wHAMYEYX 3KwuAPJT3WSuOsFwDGBGTWapC4D8TGmlLjAdA5jZTG6nCrt9uZW6wHQMYGYvHqIu APLS6yV1gekYwMx6vKMuAPKyEpfCqgcDmMUiLokFm3EWYL0YwCzGrKkuAPLw/m7q AuMxgFlce7m6AMjDVl+qC4zHAGbRapK6AAivmqdw6sUAZrOwWF0AhDazmbrAfAxg Nl9tri4AQnvhMHWB+RjAbHq+rC4AQlt9grrAfAxgVlNaqAuAkKpWUhdYgAHM6uWe 6gIgpElt1AUWYACzOuRFdQEQ0t1c07x+DGBWReX8BsFSjcrUBRbg6zu78aurC4BQ eB9cLhjA7F7opS4AQnnxUHWBDRjA7A56RV0AhHLwq+oCGzCA2RVW8HYi2KiqAZfC ygEDWI/f26sLgBDGcimjXDCA9XjmCHUBEMKzR6oLrMAA1mOffuoCIIR9+6sLrMAA 1qeSNxTBPouK1AV2YADrM2otdQEQ2OiO6gI7MID1eeJYdQEQ2JPHqQvswADWZ7d3 1QVAYLu/py6wAwNYrwqeTYFtKhuoCyzBANZrRCd1ARDQyHXUBZZgAOv18InqAiCg R05SF1iCAazX9h+rC4CAdhikLrAEA1i/cp5PgV0quJ1hjhjA+v3SWV0ABDK8i7rA Fgxg/e47VV0ABHL/aeoCWzCA9dvyC3UBEMhWX6oLbMEA5mAhz6jAJuUN1QXWYABz 8MMG6gIggB83VBdYgwHMwW3nqguAAG4/T11gDQYwB+v9pC4AAlj/Z3WBNRjAXCwo URcAOStrpC6wBwOYiyGbqguAnA3tpi6wBwOYiz6XqQuAnF13ubrAHgxgLtr/ri4A crbmWHWBPRjAnMxdWV0A5GheY3WBRRjAnHzWXV0A5GjwNuoCizCAObnkenUBkKNL b1AXWIQBzEmrSeoCIEetJ6sLLMIA5mbmquoCICezmqoLbMIA5ubDndQFQE4G7qwu sAkDmJuz7lQXADk5+y51gU0YwNw0maUuAHKy6mx1gU0YwBxNXU1dAORgWgt1gVUY wBz9b091AZCDt/dSF1iFAczR8Y+qC4AcnPCYusAqDGCOSubzWwXzVZeWqROswld1 ria0URcA9ZrYVl1gFwYwVy/3VBcA9frv39QFdmEAc3Xgq+oCoF4HvaYusAsDmKvC ikJ1AlCPqgZV6gS7MIA5G7WWugCox+iO6gLLMIA5e/R4dQFQj8dOUBdYhgHM2fYf qwuAeuwwSF1gGQYwd+UN1AVAVhXF6gLbMIC5+3F9dQGQ1U8bqAtswwDm7vZz1AVA Vnecqy6wDQOYu/V+UhcAWa3/s7rANgxgAPMbqQuALBaUqguswwAG8PVm6gIgi282 VxdYhwEMoPdV6gIgi6t7qwuswwAG0PYPdQGQxeoT1AXWYQCDmL2KugDIaE4TdYF9 GMAgPtpBXQBk9PGO6gL7MIBBnH2HugDI6Bzu3RoYAxgEN8eEwbghZnAMYCBTuOcg TDW1pbrAQgxgIG/uqy4AMui3n7rAQgxgIEc+rS4AMjjqGXWBhRjAQIrK+Q2DmaqL K9UJFuLrOZix7dQFQFrj2qsLbMQABvPUUeoCIK2nj1YX2IgBDGa3d9UFQFq7v6cu sBEDGFBFkboASKOSGzaEwQAG9EtndQGQxvAu6gIrMYAB3XWmugBI4+6z1AVWYgAD 2ug7dQGQxsbfqwusxAAGtaBEXQDUUcbtGkJhAIPiuvgwEFfDD4cBDIrr4sNAXA0/ HAYwKK6LDwNxNfxwGMDAZnHhcZhm9qrqAksxgIEN5MLjMM1HO6kLLMUABnYWFx6H ac6+S11gKQYwsMZz1AVALavMVRdYigEMbjKXHodZprRSF9iKAQzutQPUBUCK1w9U F9iKAQzukBfVBUCKXi+pC2zFAAZXWFGoTgBqqGpQpU6wFQMYwqi11AVADaM7qgus xQCG8MgJ6gKghkdPVBdYiwEMYevB6gKghu6fqwusxQCGsbBYXQCsUN5QXWAvBjCM bzdWFwArfNdVXWAvBjCMGy5WFwAr3HiJusBeDGAYHUarC4AV1hqjLrAXAxjKnMbq AuBPc1dRF1iMAQxl0HbqAuBPn2yvLrAYAxjKubepC4A/nXe7usBiDGAoTWapC4A/ rTpbXWAxBjCcKS3UBcBSU7k6Wx4YwHBe319dACz1BldnywMDGE6vF9QFwFKHcnW2 PDCA4XBJLJiBS2HlhQEMaXQHdQGw2Ji11AVWYwBDevR4dQGw2GNcmy0fDGBI3T9T FwCLbcO12fLBAIbFJbFgAC6FlR8GMKxhXIMIet9uoi6wGwMY1vVcgwh6N1yqLrAb AxjWGuPUBUBBu/HqArsxgKHN5ipEUJvTRF1gOQYwtA93UhfAewN3VhdYjgEM7fR7 1AXw3hn3qgssxwCGVjqX3zxoVTeer06wHF/D4U1srS6A5ya1URfYjgEM7+We6gJ4 7r9/UxfYjgEMb9831QXw3H791AW2YwDzULmSugBeW1SkLrAeA5iHX9dRF8BrI9ZV F1iPAczD3WeoC+C1e85UF1iPAczDRt+pC+C1jb9XF1iPAczH/EbqAnhsQam6wH4M YD6+3EJdAI99taW6wH4MYD4uvU5dAI9ddr26wH4MYD5aTFEXwGMtp6oL7McA5mV6 M3UBvDWjubrAAQxgXv63p7oA3np7L3WBAxjAvBzdV10Abx3zlLrAAQxgXorK+Q2E RnVxpTrBAXz95uf39uoCeGrsmuoCFzCA+XniWHUBPPXkceoCFzCA+dn2E3UBPLXd p+oCFzCAeVpYrC6Al8obqgucwADm6buN1AXw0vcbqwucwADm6YaL1QXw0o2XqAuc wADmqf3v6gJ4ac2x6gInMID5mr2KugAemtNEXeAGBjBfA3dUF8BDH+2kLnADA5iv 0+9RF8BDZ9yrLnADA5iv0rn8HiJp1Y3nqxPcwBdv3ia0URfAOxPbqgscwQDm7cVD 1AXwzku91AWOYADztk8/dQG8s29/dYEjGMD8Va6kLoBnFhWpC1zBAObvl87qAnhm eBd1gSsYwPzdeZa6AJ6562x1gSsYwPx1/kVdAM90Ga4ucAUDGIF5peoCeGX+yuoC ZzCAEfisu7oAXhm8jbrAGQxgBP55i7oAXrngP+oCZzCAEWgyS10Ar6w6W13gDAYw ClNaqAvgkakt1QXuYACj8NoB6gJ45PUD1QXuYACj0PNldQE88rf/qgvcwQBGobCi UJ0Ab1Q1qFInuIMBjMSITuoCeGPkOuoChzCAkbjvVHUBvHH/aeoChzCAkeg6TF0A b2zyrbrAIQxgNBaUqAvgibJG6gKXMIDR+HILdQE88dWW6gKXMIDRuPQ6dQE8cdn1 6gKXMIDRaDFFXQBPtJyqLnAJAxiRac3VBfDC9NXUBU5hACPSf291Abzw1j7qAqcw gBE58ml1Abxw1DPqAqcwgBEpWsi74RC/qoaV6gSnMIBRGd1BXQAPjFlLXeAWBjAq D5+oLoAHHjlJXeAWBjAqm3+lLoAHtvhaXeAWBjAyZQ3VBXDeQt5yGS0GMDLfdFMX wHlDNlMXOIYBjMwV16gL4Lwrr1UXOIYBjEyrSeoCOK/1ZHWBYxjA6Exvpi6A42bw hsuIMYDR+d+e6gI47u291AWuYQCjc3RfdQEcd8xT6gLXMIDR4d1wiBfvg4scAxih MWuqC+C033m7ZdQYwAg9coK6AE57lLdbRo0BjNCWX6gL4LStvlQXOIcBjNIingRE fKpWUhe4hwGM0vjV1QVw2B9rqAvcwwBG6caL1AVw2E0XqwvcwwBGakoLdQGcNbWl usBBDGCkXjlIXQBnvXqwusBBDGCk9n9dXQBnHfCGusBBDGC0KnmhDvFYVKQucBED GK2fu6gL4Khf1lMXuIgBjNat56kL4KjbzlcXuIgBjFbH39QFcNTao9QFLmIAIzZ7 FXUBnDSnibrASQxgxD7cSV0AJw3cWV3gJAYwYic/qC6Ak/7xkLrASQxgxIrL+C1F 9KpLytUJTuKrNWpj26kL4KBx7dUFbmIAo/bEseoCOOjJ49QFbmIAo7b1YHUBHNT9 c3WBmxjAyJU1VBfAOQtL1AWOYgAj9003dQGcM2QzdYGjGMDIXX6tugDOuaKPusBR DGDkmk9TF8A5q01XFziKAYzetObqAjhm+mrqAlcxgNHrt4+6AI7pv6+6wFUMYPQO e05dAMcc/ry6wFUMYPSKFnJ7YESpqmGlOsFVDGAMRq2lLoBTRndUFziLAYzBwyeq C+CUR05SFziLAYzB5l+pC+CULb5WFziLAYwD74ZDhHgfXHwYwDgM2VRdAIcM5c2V sWEA49D7KnUBHHJ1b3WBuxjAOLSeqC6AQ9pMUhe4iwGMxYym6gI4Y2YzdYHDGMBY vNNDXQBnDNhDXeAwBjAWxz2uLoAz/v6EusBhDGAsuDccosL94OLE12k8uDccIsL9 4OLEAMbjyWPUBXBEX24zGCMGMB7bf6wugCN2GKQucBkDGJPyBuoCOKGiWF3gNAYw Jt9tpC6AE77fWF3gNAYwJjdepC6AE266WF3gNAYwJh1GqwvghLXGqAucxgDGpVod ACfwFRorfnvj8uk26gI44LNt1QVuYwDj8s9b1AVwwAX/URe4jQGMS9MZ6gI4oNlM dYHbGMDY8CQg8scXaLz4/Y1N/73VBbDeW/uoCxzHAMbm6L7qAljvmKfUBY5jAGNT VKEugPUaVKoLHMcAxmfcGuoCWG48V1WLGQMYn2cPVxfAcs8doS5wHQMYn73eUhfA cnv/T13gOgYwRpwIg/zw5Rk3fodjNKKTugBWG7mOusB5DGCMHjpJXQCrPXyyusB5 DGCMtvxCXQCrbfWlusB5DGCceBIQ+eCrM3b8Fsfp+w3VBbDYD9xWIXYMYJxuvkBd AIvdcqG6wH0MYJw6jVAXwGLrjFQXuI8BjBVPAiI8vjjjx+9xrD7rri6AtQZzU4X4 MYBxavHYfuoEWOvN46eqE9zHAMbq7DvUBbDWOXeqCzzAAMZqn37qAlhr3/7qAg8w gLHq+l/eDoxwRvb8Vp3gAQYwVk0e4JqACOe5U2arEzzAAMbr5AfVBbDUPx5SF/iA AYzXHm+rC2CpPd9RF/iAAYzXei/xdmCE8cMhP6sTfMAAxqv4zlPUCbDSA2eXqxN8 wADG7Jgn1QWw0rHcVjoJDGDMdvpQXQAr7TxQXeAFBjBmHZ/dWp0AC31+xCh1ghcY wLjdcLG6ABa68RJ1gR8YwLgd9py6ABY6/Hl1gR8YwLh1f62VOgHWmXzgYHWCHxjA uLXu20OdAOsMOGaSOsEPDGDsLrhZXQDrXHiLusATDGDs9n9dXQDrHPCGusATDGDs uCQWguJSWElhAGNXev8x6gRYpu+p89UJnmAA43cS1zVCMCc/rC7wBQMYv9PvURfA Mmfcqy7wBQMYPwYQATGASWEA48cAIiAGMCkMYFSa7N5js05NV1JnwGFffDPgXW4U EikGMAJFGx21S5fG6gr44esPnv6+Uh3hDAYwXx3POGBddQM88+vr93C1rEgwgPko 3vsM3ugLjQH3vMVF8/PGAIbXtc/+6gR47Y3LecNInhjAkJpffnRLdQO8N+WpPtPV DVZjAEPpfDc/+sIMA84crk6wGAMYQueHd1AnACt8fBITGBYDGFirh3nqD2Z546TJ 6gRLMYABlV7YW50A1NH7Zq4fEwYDGAwX94OZuIRgKAxgECUXXKtOADK44pYydYJ9 GMAAmj+xnzoByOjN4zglJigGMHedBnRUJwBZjOoxUp1gGwYwZ/v0UxcA9di3v7rA MgxgjoqOfUSdANTrxCe5UkwQDGBuCv/O/sEGJz5epU6wCQOYE/YPtmABg2AAc8H+ wR4sYAAMYC4OekVdAOTs4FfVBfZgAOtXcv516gQggMtu5ZToHDGA9es6TF0ABLIJ b4vLEQNYr/a/qwuAgNYcqy6wBANYn8b3HKtOAAJ68oy56gQ7MID12eNtdQEQ2J7v qAvswADWo8NodQEQwlpj1AVWYACza3z/UeoEIISnT+WH4BwwgNnt/7q6AAjlgDfU BTZgALNaY5y6AAip3Xh1gQUYwGyKL7tSnQCEdM115eoE8zGA2azL7QZhr86/qgvM xwBm0eTZfdQJQGj9j5itTjAeA5jF1oPVBUAeun+uLjAeA5hZ66/aqROAPIzbYpI6 wXQMYGa8BwSW4/0g9WEAM+IUGFiPU2HqwQBmUnTWreoEIE/n38U9krJiADPp+Ju6 AMjb2qPUBWZjADMovesEdQKQt0fPmq9OMBoDmEGnEeoCIALrjFQXGI0BTK/0gaPV CUAEnjqFbwGzYADT4zKAcAQXBsyGAUyruM+F6gQgEjdfzjURMmMA02o9UV0ARKQN bwfJjAFMizeBwBm8HSQLBjCdJv/dTZ0AROS9nlwUJiMGMB3OgYFDOBMmMwYwjaYf bqJOACIzbOeZ6gRjMYBpcBkEOIVLImTEAKbB24DhFN4QnBEDmEa3b9QFQIQ2G6Iu MBYDWFfzz9dRJwARGrH1dHWCqRjAungKEI7hScBMGMC6eB8wHMP7gTNhAOvqOkxd AERqk2/VBaZiAOtoMmArdQIQqS968GaQ9BjAOrgQApzDBREyYADraP+7ugCI2Jpj 1QWGYgDr4DUQOIdXQTJgAOvY5X11ARCxXT9QFxiKAayt6eAu6gQgYr9053oIaTGA tbX9Q10ARG71CeoCMzGAtfEaCBzEqyDpMYC18RoIHMSrIOkxgLXxPhA4iPeCpMcA 1tLkI64GDfcM25H3gqTDANbC+0DgJN4LkhYDWAvXwoKTuCJWWgxgLbwIDCfxMnBa DGAtvAgMJ/EycFoMYKrSF/ZVJwAx6HfofHWCiRjAVC1+bKlOAGIwZYOp6gQTMYCp eCMcHMWb4dJhAFPxIjAcxcvA6TCAqXgNBI7iVZB0GMAUhYc9o04AYnHk81XqBAMx gCmafLaBOgGIxY/b8Ga4uhjAFK14vxBc1XqyusBADGAKXgSGs3gZOA0GMAUvAsNZ vAycBgOYYqcP1QVATHYeqC4wEANYU/E1F6kTgJjcdGW5OsE8DGBNzb9bXZ0AxOSP jaerE8zDANbEi8BwGC8D18UA1sSLwHAYLwPXxQDWxHeAcBjfAdbFANbEd4BwGN8B 1sUA1sRpgHAYJwLWxQDWxADCYQxgXQxgDSVPHKpOAGLzwnFl6gTjMIA1NBm4qToB iM3QnbgeTG0MYA3Nf+aGIHDXlPU4E7o2BrAGzoKB0zgPpg4GsAbOgoHTOA+mDgaw Bl4EhtN4GbgOBrAGBhBOYwDrYAD/UvLY4eoEIEbPHc95MLUwgH9p/N5W6gQgRl/s NledYBoG8C9Nv2unTgBiNG7jmeoE0zCAf2kxRV0AxKrlVHWBaRjAv7SeqC4AYtWG M11rYQD/wmmAcBwnAtbGAP6FAYTjGMDaGMAVim88T50AxOq2i7kxXCoGcIXSF/ZV JwCx6nfofHWCYRjAFZp8spE6AYjV99txQaxUDOAKTX9ppU4AYjW5CycCpmIAV+A0 QDiPEwFrYQBX4DRAOI8TAWthAFfgLBg4j/NgamEAV2AA4TwGsBYGcLniPheqE4CY 3Xw5JwKmYACXK3nuQHUCELPXDueKgCkYwOUaf8w9MeG6oTtwRcAUDOByTWeoC4DY NeNEwBQM4HKcBggPcCJgKgZwOU4DhAc4ETAVA7gcAwgPMICpGMDlOA0QHuBEwFQM 4HIMIDzAAKZiAP9U8ugR6gQgds+ewImANTGAf2o8eEN1AhC7H7pzImBNDOCfOA0Q XuBEwBQM4J84DRBe4ETAFAzgn1pxegB80HqyusAoDOCfOA0QXuBEwBQM4J8YQHiB AUzBAP6JAYQXGMAUDOCfGEB4gQFMwQAuU3zrGeoEIAH3nM81oWtgAJcpfXMXdQKQ gA/2m69OMAkDuEyTIWurE4AE/NZttjrBJAzgMrwRBJ7grSA1MYDL8EYQeIK3gtTE AC7Di8DwBC8D18QALsMAwhMMYE0M4FLFd56iTgAS8cDZnAfzFwZwqdK3dlQnAIn4 aG/Og/kLA7hMyePrtGutjgDitXDmuBF/55LQNTCANZWcv0nnNVqqK4CoVcwcP3zY rUxfHQxgGiUXbbTu6uwgHFAx849fv7+J5cuEAcys9MIN123Lz8WwUvmMCb/+cDNP 99WDAaxf8/s6rrG6OgLISXXZjPGjTpuuzrAFA5iz5jes06GTOgLIYNHcqWNGXMLy BcMABtX0vPU7rs43hDDF4m/5/hj10228wzcUBjCsFhetu1YbniGESvXCWRNH/3oT 7+zNCwOYr1YXrr1mm3bqCnhj0YKZE3//7WZu7hYJBjAya/Ruv0ZLviVEPKoWzp4y fmzv8eoOxzCA0etwZbs2LduqK+CERWWzp0wcd80YdYerGMAYtT+9fbtWzfmmEEEt Kps7ffK4sfeOVYc4jwFMRPuT2rVrvRrPFCKL6sr5c6ZNGjfuYWYvOQxg0jqdvHqb lk3XUmfADFXl82fPnDLxj4dGqkv8xAAqrXdiq9arNVullboDSaquXDh/zoxpkyY/ 8rM6BQygMboev1qL1Zo25hxrBy2qKJs/d+a0qdMe+1adghQMoKE2PbxZi+ZNV1m5 jToEIVQvqly4YN6cmdOnznhuqDoGWTCAlti2V5PmTZusUtqoYYNidQtqqa5aVLFw wfw5s2dOn/3ip+oaBMAAWmungxs3ada48eJJLG6w0kr8QSaletGiivLFczd37ozZ c18ZqM5BXvi6cUqPHqWrNlml0eJRXLyKRYtnkT/f8KoXT13l4q1bPHYL5syeNX/A AHURIscXiBcO3K5R6corr9yoZPEwNixa/A1jYWGhuskQVVVVi7+lq1y4eOjKFsyb N2/+gk9eUzchMQyg9w7q1nDl0tKSRg1LFn/XWFxcVFS0dB8d+eaxunrpwlVWVpaX L/5urmzhgrL58+ctHPKqOgxGcOOzHPE6Yp2GpSXFixeyqKS4qEHDxd9BLv7P4plc qfD/li5l0p9F1Ut3rbpq0eJpW/zt2+L/LKyoLC+rXLxv5WXzF454NuEeWIsBRPTO aN6osKSw0f+VFJb8X0HF1kU1Ps3+L+W/lqiu9d9L/lfl5w0KqsuqyqoXVJVVLZh+ TwLN8BIDCMBbDCAAbzGAALzFAALwFgMIwFsMIABvMYAAvMUAAvAWAwjAWwwgAG8x gAC8xQAC8BYDCMBbDCAAbzGAALzFAALwFgMIwFsMIABvMYAAvMUAAvAWAwjAWwwg AG8xgAC8xQAC8BYDCMBbDCAAbzGAALzFAALwFgMIwFsMIABvMYAAvMUAAvAWAwjA WwwgAG8xgAC8xQAC8BYDCMBbDCAAbzGAALzFAALwFgMIwFsMIABvMYAAvMUAAvAW AwjAWwwgAG8xgAC8xQAC8BYDCMBbDCAAbzGAALzFAALwFgMIwFsMIABvMYAAvMUA AvAWAwjAWwwgAG8xgAC8xQAC8BYDCMBbDCAAbzGAALzFAALwFgMIwFsMIABvMYAA vMUAAvAWAwjAWwwgAG8xgAC8xQAC8BYDCMBbDCAAbzGAALzFAALwFgMIwFsMIABv MYAAvMUAAvAWAwjAWwwgAG8xgAC8xQAC8BYDCMBbDCAAbzGAALzFAALwFgMIwFsM IABvMYAAvMUAAvAWAwjAWwwgAG8xgAC8xQAC8BYDCMBbDCAAbzGAALzFAALwFgMI wFsMIABvMYAAvMUAAvAWAwjAWwwgAG8xgAC8xQAC8BYDCMBbDCAAbzGAALzFAALw FgMIwFsMIABvMYAAvMUAAvAWAwjAWwwgAG8xgAC8xQAC8BYDCMBbDCAAbzGAALzF AALw1v8DAYRX4soBezsAAAAASUVORK5CYII="/></symbol><g mask="url(#b)"><g transform="rotate(.193) scale(.36014)"><symbol id="c" viewBox="0 0 1280 1280"><image width="1280" height="1280" xlink:href="data:image/png;base64, iVBORw0KGgoAAAANSUhEUgAABQAAAAUACAIAAACXhmigAAAACXBIWXMAAA7EAAAO xAGVKw4bAAEJ3klEQVR4nOzd6XscRZrvfak21V4lyZJss5ulG2gaDHQDZh3o6YVu uj0MewPzN54Xc2bOzHnmug4Gs0MDxgs22JK1b7WolszKpZ6oSlsIG9taIiojM7+f i1YbY24FtiorfoqIO4aHAAAAAACIgGG/BwAAAAAAwCAQgAEAAAAAkUAABgAAAABE AgEYAAAAABAJBGAAAAAAQCQQgAEAAAAAkUAABgAAAABEAgEYAAAAABAJBGAAAAAA QCQQgAEAAAAAkUAABgAAAABEAgEYAAAAABAJBGAAAAAAQCQQgAEAAAAAkUAABgAA AABEAgEYAAAAABAJBGAAAAAAQCQQgAEAAAAAkUAABgAAAABEAgEYAAAAABAJBGAA AAAAQCQQgAEAAAAAkUAABgAAAABEAgEYAAAAABAJBGAAAAAAQCQQgAEAAAAAkUAA BgAAAABEAgEYAAAAABAJBGAAAAAAQCQQgAEAAAAAkUAABgAAAABEAgEYAAAAABAJ BGAAAAAAQCQQgAEAAAAAkUAABgAAAABEAgEYAAAAABAJBGAAAAAAQCQQgAEAAAAA kUAABgAAAABEAgEYAAAAABAJBGAAAAAAQCQQgAEAAAAAkUAABgAAAABEAgEYAAAA ABAJBGAAAAAAQCQQgAEAAAAAkUAABgAAAABEAgEYAAAAABAJBGAAAAAAQCQQgAEA AAAAkUAABgAAAABEAgEYAAAAABAJBGAAAKTJ5/PiY6PR2N2/uLt/FwAAbBMBGACA 3RCRdTgWG+4T/5dKpdxuNxaLiX/U7XbFR/Hz2yy19dd3XVf8yOp0RDXx424fqRgA ACkIwAAAXE9vbXZ4eDPoitCbSiZFYPWy7gB4GVh8RtuyRCS+lIlFKt7YGMwAAAAI DQIwAAA/6q3r9lPupaybSnUvr+tq5XIK7tq23QvFrBUDALANBGAAQHRtjbuxeDyR SHgrvX6Pa5f6m6ZdIjEAANcS1Pd4AAB2wTu460mmUsM7OakbRJcisWU5lyMxeRgA EGVhftcHAEDIFwpe4h1JpYaCvMC7dyIMi48d03T7CMMAgKiJ7iQAABBivdA7PByP x5OplIYneHXQ7a8Odzodb3GYMAwAiAICMAAgPPL5vAi92VzOdd0or/TulPjtsizL 6R8eJgkDAEKMyQEAIPBE7o3FYolkD7l3L1xvTdi2N7hjCQAQRswSAAAB5i35pkZG xEe/xxIe3rXD7VZro173eywAAMhEAAYABFIv+iYSIyMjHPFVxOsgbRpGnRgMAAgL AjAAIHiKxeJIOs2q7wCIGGwJnQ6bogEAIUAABgAESb5QSCaTIyMjfg8kWnpLwabp 2DYtsgAAgUYABgAERqFYTLPw6xNvKbjT6TRYCgYABBYBGAAQDKVSKZ3J0OTZX67j tA2D5lgAgIBiGgEACIBSuZzJZPweBXocxzHIwACAYCIAAwB0R/rVDRkYABBQBGAA gNaKpVI2m/V7FLhSby90u01raABAsBCAAQD6KhSLIv1y7ldPnT56YgEAAoQpBQBA U/l8PpPN0vNZZ6ZhVCoVv0cBAMB2EYABAJoaHRvjvl/NuY5jmGa9VvN7IAAAbAsB GACgo0KxmMvl/B4FbsyyLNM02QgNAAgEAjAAQDv5fD6dySQSCb8HghvrdrumYVSr Vb8HAgDAjRGAAQDaofNzsFiW1TFNOkIDAPRHAAYAaGffxATLvwHS7XYNw6ixCAwA 0B4BGACgF07/BhFXIgEAAoEADADQC82fg8hxHJN20AAA7RGAAQAayRcKuVxueJi3 p+ARAbiyvu73KAAAuB5mGAAAjRSLxSz7n4OJ+5AAAPojAAMANML+5+BiFzQAQH8E YACALvL5fDaXi8Vifg9kB1zX7Xa78Xg8lUqNpNM/8yvEP978gfjh8HC3/+NLP7fl x55EMmm0Wh3L6jqO+MXB+t0wDKNaqfg9CgAArokADADQRaFQyOXzfo/imkTWHR4e jidERE2KoC5GWxodVXpfsQjMrWazWq026vV2q2WapuM4wxqnYnpBAwA0RwAGAOii VCplVObJ7esv1nZF0hX5tlgqTUxMHLzpplK5LP7R3NycyHg+jk3k8GajUVlfF6m4 1W5bltV13Xg87uOQNonBdExzgwAMANAVARgAoAsfDwCLVBmLx7OZTHlsbP/+/Tff euu1lnZnZmYcxxnw8K5PZHWj3V5dXa1Xq61mU6TQWCzmSydtjgEDADRHAAYA6GLf xEQikRjM5+qfxx0SiXdiauq222676ZZbtpkYz58/r3pse2fb9urKyvrKSqPREKF0 YFume1HcMGrV6mA+HQAAO0UABgBoIZ/P5/J51euWrutms1kRd395772FYnGn/7oI kzMzMyoGpo74T25sbMzNzopc2nVd1WHYNIwKfbAAALoiAAMAtKC0A1a3202PjNz7 q1/94t5795KxO53O3NycxIENmBj/xenplaUldd9o6HXBMs1Go6GoPgAAe0EABgBo oVgqqeuofO/99z94+PDe67Tb7cXFxb3X8ZeIqGdOnmw1myqK0wcLAKAzAjAAQAvl cjmdyaio3O12X3njjWQyufdSjUZjZWVl73V8Nzc7Ozs9raKybdumCMD1uoriAADs EQEYAKAFpS2g33j7bSl1arXa+vq6lFL+WltZ+e70aRXngWkEDQDQGQEYAKCF8X37 pCzSXi2by/31X/5FSimRfmuhiHYioJ48cULFJMB1XRGAaQQNANATARgAoIWJycl4 PK6i8sGbb37mueeklFrpXywkpZS/2q2WCMC2ZakobhhGlUbQAAAtEYABAP5TegfS g4cP33v//VJKLS4uttttKaX8Zdv2mZMnG2paVXETEgBAWwRgAID/8oVCXtkdSH94 8cXRsTEppebm5jqdjpRSvjv//ffLajpam6ZZCcVJaQBA+BCAAQD+U3cJcLfbfePt t2WtLc/MzDiOI6WU7+ZnZy+qaQTNVcAAAG0RgAEA/isWi9lcTkVl13XfevddKaVE lr5w4YKUUjpYXlz8/uxZFY2gO32K9lcDALAXBGAAgP+KpVI2m1VRWbzPvS7pDiTH cWZmZqSU0sHaysqZU6dUNB6zLKtjmhsEYACAfgjAAAD/lcrlTCajonIimXzl9del lOp0OnNzc1JK6aCyvn76229VrADbtm2KAFyvS68MAMAeEYABAP4rj46m02kVlXP5 /EtHj0op1W63F9V0jfKFuquAnX4ArhOAAQD6IQADAPw3OjY2MjKiovK+iYnf/eEP UkptbGysrq5KKaWDZqNx8ptvXNeVXtlxnF4ArtWkVwYAYI8IwAAA/42Nj6dSKRWV b7399iNPPSWlVLVaDdP1tka7ferECRW3OolQbRpGjQAMANAPARgA4L+p/ftl3VR0 hV/ce+/hRx6RUmptbS1M23o7pnn65Ml2q6WiuAjAYfpmAQAgNAjAAAD/7T9wQFHl R37727vvuUdKqeXl5WazKaWUDmzb/u706Q0167QEYACAngjAAACflcvltJoW0MJz L7wgK10vLCwYhiGllA663e73Z8+urayoKE4jaACAngjAAACfjY2NJVMpRVug//ov /5LN5aSUmp2dtSxLSilNTJ8/vzg/r6IyfbAAAHoiAAMAfLZv375EMqmicrfbffOd d2RVm56eVtEz2UdzItNPT6uoLH7nDcOoVasqigMAsGsEYACAzyYmJ+PxuIrKqZGR l199VUopEX2n1WRFH1XW109/+20sFlNR3Gi3qwRgAIBmCMAAAJ+pawF94ODBZ59/ Xkopy7JmZ2ellNJHq9k8eeKEY9sqihuGUaUPFgBAMwRgAIDP1AXg+x544NcPPiil VLvdXlxclFJKH51O58zJky01ra0JwAAADRGAAQA+UxeA33j7bVmlGo3GipqGyf6a u3hxdmZGRWUCMABAQwRgAICfSuVyOp1WEYBd133r3XdlVatWq6G82HZ+dvaimrPN tmWZnQ43IQEAtEIABgD4aXRsLKXmDiS3231LXgvotbW1ehiz3PLi4vdnz6rog8VN SAAADRGAAQB+Gt+3L6nmDqR4PP7qm2/Kqra0tNRqtWRV08fa6up3J0/GFHThdl1X BGBuQgIAaIUADADwk7o7kHL5/EtHj8qqNj8/L+KcrGr6EAH11IkTis5gcxMSAEA3 BGAAgJ/UdcDav3//c7/7naxqMzMzjuPIqqaPVrP57TffuGr+0+iDBQDQDQEYAOAn dQH4F/fee/iRR6SU6na7Fy5ckFJKNx3TPPXtt0a7raI4ARgAoBsCMADAT4G4A8m2 7YsXL8qqppvZmZk5Nf91BGAAgG4IwAAA36i7A2lIagAWQW5hYUFWNd2oC8CWZXW4 CQkAoBMCMADANwrvQJJ6CXCz2VxeXpZVTTeLCwvnz53jJiQAQBQQgAEAvlF3B9Jw LPb6W2/Jqlar1dbX12VV083qysp3p06p6MXduwnJMGoEYACANgjAAADfqLsDKZPN /u3ll2VVE+k3xCmuWqmc+vbbmIJ1+G63a4gAzE1IAABtEIABAL6ZnJpSsfN2qB+t X/j972VVW15ebjabsqrpptFonPrmG9d1VRSnDxYAQCsEYACAb9S1gL77nnse+e1v ZVVbWFgQQU5WNd2YpnnqxAlTzX8gARgAoBUCMADAN4G4A0m4ePGibdsSC+qGm5AA ABFBAAYA+CYQAbjb7U5PT4uPsgpqiAAMAIgIAjAAwB+jo6OpkRH970ByHGdmZkZW NT0tzM9P//CDij8Lx7Z7NyFxFTAAQA8EYACAP8bHxxPJpP4rwCK/zc/Py6qmp5Xl 5bOnT3MTEgAg9AjAAAB/TExMxBMJFZXT6fTRV16RVa3ZbC4vL8uqpqfK+vqZb78d VtCRm5uQAABaIQADAPyh7g6ksfHx3//pT7Kq1Wq19fV1WdX0tFGvn/r2266im5Da 7SoBGACgBwIwAMAf6jpg3XHo0GNHjsiqtra2FvojrCKjnjpxotPpKClOHywAgDYI wAAAfwSiBbSwtLTUarUkFtTTxenp+dlZFZUJwAAAfRCAAQD+CEoAnpubU7Q0qhUC MAAgCgjAAAAflEdHR4JwB5IwPT3tqjkcq5X5ubmZ8+dV/InYtt3hJiQAgB4IwAAA H4yNjyeDcAeSiL4iAMuqprPlxcVz332n6CYkwzDq3IQEANAAARgA4IN9ExMJNXcg pVKpl197TVa1TqczNzcnq5rO1tfWzpw8qaIvNzchAQD0QQAGAPhA3R1IpXL5T3/5 i6xqrVZraWlJVjWd1Wu1UydOKCrOTUgAAE0QgAEAPlDXAevW228/8tRTsqrV6/W1 tTVZ1XTWbrVEALYsS0Vx+mABADRBAAYA+CAoLaDX19drkTm8SiNoAEDoEYABAD4I SgBeXl5uNpsSC+qMAAwACD0CMABg0AJ0B9L8/LxpmhIL6mzu4sXZmRkVlW3bFr+N G9yEBADwGwEYADBo6u5A6na7b77zjsSCMzMzjuNILKizxYWFH86eVXETkvg9FAGY m5AAAL4jAAMABk3dHUiJZPKV11+XVU3E6QsXLsiqpr+1lZUzp06pCMDchAQA0AQB GAAwaJOTkzEFKUsoFosv/vWvsqo5jjOjZkuwnkRAPX3ixJCas9ntdpsADADwHQEY ADBo6jpg3XTzzU8/95ysap1OZ25uTlY1/bWazZMnTji2raI4fbAAADogAAMABi0o LaBbrdbS0pLEgvqbuXBhQU3mJwADAHRAAAYADFpQAnCtVltfX5dYUH8EYABAuBGA AQADVS6XR9LpQNyBtLKy0mg0JBYMhOPvvaeiD5ZgmqbV6UTwtxQAoA8CMABgoEbH xlKpVCDuQIrUJcCbPjx2bLhPemXLssTvZ2NjQ3plAAC2iQAMABio8X37ksmkisrx ePzVN9+UWHB6etp1XYkFA+Gzjz6ybVtFAHYcp91uE4ABAD4iAAMABkrdAeBcPv/S 0aOyqkXtEuBNX33xRbvVUvRn1GyI/EsABgD4hgAMABgodQF4/4EDz73wgqxqrutO T0/LqhYgZ8+cWV1ejsViKooTgAEA/iIAAwAGSsRURZV/ed99Dz38sKxqlmXNzs7K qhYg83Nz0z/8QAAGAIQSARgAMDj5QiGfzysqLvcOJMMwFhYWJBYMEHWNoJvNZtd1 aQQNAPALARgAMDhj4+OpVEpFZektoEVIW1lZkVgwQNQFYBpBAwD8RQAGAAzOxOSk omQlvPzaaxLT9fr6eq1Wk1UtWNQFYNd1W60WARgA4BcCMABgcCanphQdLhXJ6q13 35VYcHFxsd1uSywYIB++915M2fcpOAYMAPARARgAMDjqWkBLD8DRvATY8+GxY8N9 KooTgAEAPiIAAwAGR10LaJHWXv/732VVi+wlwJ6Pjx/vui4BGAAQPgRgAMCAFAqF nLIW0KLyS0ePyqoW2UuAPV998UW71VIUgFvNpksjaACATwjAAIABKZVKmWxWUfHH nnjijjvvlFXNtu2LFy/KqhY41Url1IkTik5rG4ZhWxYBGADgCwIwAGBARsfGRkZG FBWX2wLaNM35+XlZ1YKIm5AAAKFEAAYADMi+iYlEIqGisvQOWM1mc3l5WWLBwFHX B4ubkAAAPiIAAwAGRN0dSIl4/JU335RYsFKpVKtViQUD59OPPnJsmz5YAICQIQAD AAZE3R1IpVLpTy+9JLHg0tJSq9WSWDBwvv3qq3q9rugbFgRgAIBfCMAAgEFQ2gL6 jkOHHjtyRGLBmZkZx3EkFgyc6fPn52dnFQXgVqvlOg59sAAAg0cABgAMQqlczmQy ioofefrpW2+7TVa1iF8C7Nmo10989RWNoAEAIUMABgAMwtj4uMQuzVd45fXXE8mk rGoRvwR4E42gAQDhQwAGAAyCwhbQ3e5b77wjsaCIZ7OzsxILBhSNoAEA4UMABgAM gsIW0InEK2+8IbFgu91eXFyUWDCgPvv4Y9uyaAQNAAgTAjAAQLl8Pp/L5xVFqfLo 6B///GeJBUUwW11dlVgwoE5+802tWqURNAAgTAjAAADlCsViLpdTVPyuu+9+9LHH JBYU6ZdsJlycmZmdnqYRNAAgTAjAAADllLaAfurZZ2++5RaJBefm5jqdjsSCASXS 6TdffqkoAJuGYdEIGgAwcARgAIBy6lpAd7vd1956S2KzYu5A2urDY8cUBWDbsgwa QQMABo4ADABQbmJyUtGFOl3XffPddyUW5A6krT56/33xUVEj6HarxVZzAMCAEYAB AMqpawGdTKX+9bXXJBa0bfvixYsSCwba5598YnU6NIIGAIQGARgAoFZeKBQUFR8b H//9n/4ksaBhGAsLCxILBtqpEyeqlQqNoAEAoUEABgCopbQF9D2/+MXDv/mNxIKt VmtpaUliwUCbu3hx5sIFRQG43Wo5NIIGAAwWARgAoFa5XE4rawH97PPPHzh4UGLB SqVSrVYlFgy0Vqv11WefxdSc3zZNs9cImkVgAMAAEYABAGqpawHtuu6b77wj94Qq dyBd4fh77ylqYGbbtmEYBGAAwCARgAEAailsAd3tigAstyB3IF1BXSNo8bvdbDYJ wACAQSIAAwDUmtq/X1Eb4dTIyMuvviqxIAH4al98+mnHNGkEDQAIBwIwAEAhpS2g 901M/O4Pf5BYkEuAr3b65MnK2hqNoAEA4UAABgAoVCwWs8paQP/yvvseevhhiQXb 7fbi4qLEgiGwMDd34YcfVDWCbrcd26YRNABgYAjAAACFyqOj6XRaUfEXfv/7iclJ iQVrtdr6+rrEgiFgmubnH3+s6BR3xzQ7NIIGAAwQARgAoND4vn3JZFJFZdd133r3 Xbk1l5eXm82m3JohQCNoAEBoEIABAAqpawEtvPH223ILcgfSz/r4/fe7NIIGAIQC ARgAoJC6FtDpdProK6/IrTk9Pe26rtyaIfDlZ5+ZhkEjaABACBCAAQCqKG0BPTk1 9fw//7PEgtyBdC3fnT69trKiqhF0s7lRr6uoDADA1QjAAABViqVSNptVVPz+Bx54 4MEHJRa0LGt2dlZiwdBYXFg4f+6cwkbQjsMuaADAYBCAAQCqKG0B/YcXXxwdG5NY kDuQrsW27U+OH1fVCLqPAAwAGAwCMABAlWC1gK7X62tra3JrhsaHx44pWgF2HKfd bhOAAQCDQQAGAKgyOTkZU7NsKN69XpfdAnp9fb1Wq8mtGRofHz/edV1FjaBbzSZ9 sAAAg0EABgCooq4FdCab/dvLL8utySXA1/GPzz9vt1qq+mDRCBoAMCgEYACAEvlC IZ/PKyp+4ODBZ59/Xm7N+fl50zTl1gyNc2fOrCwv0wgaABB0BGAAgBJKW0A/ePjw vfffL7fmzMyM4zhya4bG6vLy2TNnFAVgo922bbvRaKgoDgDAVgRgAIASo2NjIyMj ior/5ehRucvLrutOT09LLBg+x997T1EjaKvTMWkEDQAYCAIwAECJffv2JYLTArrT 6czNzcmtGTIfHjs23Ce9Mo2gAQADQwAGACgxOTWlaMfscCz2+ltvya3ZarWWlpbk 1gyZT48fd9Q0gh6iDxYAYFAIwAAAJdS1gM4XCn/529/k1uQS4Bv65h//ECGVRtAA gEAjAAMA5FPaAvqW22578umn5dbkEuAbOv/994vz84oCcKvZdF2XPlgAANUIwAAA +UqlUkZZC+jfPPbYnXffLbcmlwDfULVSOfXNNzE1fbAMw7AtiwAMAFCNAAwAkE9p C+h/efVV6cW5BHg7FDaCtizx+08fLACAagRgAIB8+yYmEomEisoqWkAPcQnw9nx0 7NiQmkbQ4o+13WpxDBgAoBoBGAAgn7oW0Il4/JU335Rbs9vtXrhwQW7NUPrs449t y6IRNAAguAjAAADJ8vl8Lp9XFJNK5fKf/vIXuTUty5qdnZVbM5ROfv11rVajETQA ILgIwAAAyQrFYi6XU1T80F13/fbxx+XW5BLgbbo4PT07M6MoALdbLcdx6IMFAFCK AAwAkKxcLqczGUXFn3r22ZtvuUVuTS4B3qZmo/HVF18o6oNlmqZlWfTBAgAoRQAG AEg2Nj6eSqVUVO52u6+99Zb0AMYlwNunrhG0bduGYRCAAQBKEYABAJJNTE4qykiK WkBzCfD2ffTBB0PdrooD3t1ut9VscgwYAKAUARgAINnU/v2KOmClUqmXX3tNelku Ad6+Lz/9VPxe0QgaABBQBGAAgEx5oVBQVHzfxMTv/vAH6WW5BHj7zpw8ub62pqoR dLO5Ua+rqAwAgIcADACQqVgqZbNZRcXvvf/+Bw8flluTS4B3ZHF+/vz336tqBN1u 9xpBswgMAFCGAAwAkGl0dHQknVZU/Hd//OO+ffvk1uQS4B3pdDqfffSRojPenT4C MABAHQIwAECm8X37ksmkisqKOmC12+3FxUXpZUPsw2PHFK0AO44j/jgIwAAAdQjA AACZJqemFKWjoeHhN/7+d+lVNzY2VldXpZcNsY+PH++6Ln2wAABBRAAGAMikrgV0 Jpv928svSy9bqVSq1ar0siH21RdftJpNVX2wCMAAAJUIwAAAaQqFQi6fV1T8wMGD zz7/vPSyXAK8U+e++25laUlRAG61Wq7jNBoNFcUBACAAAwCkKZXLmUxGUfGHHn74 l/fdJ70slwDv1OrKytlTp2Jq+mCZhmHZNseAAQCKEIABANKMjY+nUilFxV86elTF 8jKXAO/C8ffeU9QI2rYswzQJwAAARQjAAABpJiYnFeUiRS2gRdnp6WnpZUPvw/ff H+51JZM/ixB/Iu1Wi2PAAABFCMAAAGnUdcASufrVN9+UXrbT6czNzUkvG3qffvSR Y9s0ggYABA4BGAAgR75QyCvrgFUqlf700kvSy7ZaraWlJellQ+/k11/XajVVjaCb zY16XUVlAAAIwAAAOdTtfxae+ad/OnjTTdLL1uv1tbU16WVDr9Vq/eOzzxT9cXe7 3ZbIwCwCAwAUIAADACTI5/O5fF7RnlhFB4AFkX7rLDbuyvFjx+JqVoCH2AUNAFCG AAwAkKBYLGZzOUXF44nEq2+8oaLy0tJSq9VSUTn0Pv/4Y8uyFH3Lo91uO7bNbcAA AOkIwAAACUbHxkZGRhQVn5yaev6f/1lF5bm5uU6no6Jy6J09c2Z1eVnRMWARrU0u QwIAKEAABgBIoPQA8G8ff/zQXXepqDw9Pe26rorKoVerVr/9+muOAQMAgoUADACQ QN0FSCKgvv73v6sIWo7jzMzMSC8bHcffe0/ddz04BgwAUIEADADYq0KxmFN2AFjk ahGAVVQ2TXN+fl5F5Yj49Phxx3VVHQNutRzH4RgwAEAuAjAAYK+UHgAuj47+8c9/ VlFZhKuVlRUVlSPi5IkTtUpF1THgTsfsdDgGDACQiwAMANgrpQeAH3jwwfsfeEBF 5Wq1WqlUVFSOiJXl5bOnTyv6o3ddt91qsQsaACAXARgAsFfqDgALR195JZ1Oq6i8 srLCDts94hgwACBYCMAAgBsrl8vDsT6RdPsf1CXeK7zx9tuKKi8sLBiGoah4RHz8 wQfdbncAXwzdy1zX7f+va9s2G6QBADtFAAYAXFIeHfXybexyxB1Yyr2WQqHw57/9 TVHxixcvihClqHhEnPjqq416XdEx4G3qbtGPxl3LssjGAICfRQAGgAgplcubq7je /w/12yz7Pa5r+sW99x5+5BEVlUVMunDhgorKkbIwP3/h3LmYsl3QeyT+lIcuJ2SW jgEAQwRgAAif3kLu5ZCryULurr109Ggun1dRudPpzM3NqagcNUqPASvlxWNv0dj7 aFsWp44BINyCOiUCgCgrFouXcu2Pq7kxf7ehqiACyZvvvKOoeKvVWlpaUlQ8Uj5+ //2u3vsIdsGLxJ6t+6tZOgaAoAvV2xUAhMnWlLspZDHj+nL5/EtHjyoqXqvV1tfX FRWPlG/+8Q8RC8P3/ZdruRSGHce9vG5MNgaAAInQRAoA9FQsla7IuYHetCzR3ffc 88hvf6uo+OrqKptdpZibnZ354QdtjwEP0qV143427vazsUMwBgDNMMECgAHxgq4X cEVaiNpy7i78+a9/LRSLiopzB5JEwT0GPBjeKrHjON3LB44JxgDgF+ZeACCZyGyb Hai8oBud3aESKT0APMQdSFJ99MEHQwO5DThkflwxvryXmq3UAKAa71UAsHu9Y7pe 0BVY1JUqk83+7eWXFRXnDiS5vv7yy2ajwTd6pNg8Y+z0721iHzUAyMVEDQC25cd1 3V7UJesqd+jOO3/7xBOKinMHklwXZ2Zmp6cJwEp5a8XO5duMWSsGgN1h9gYAP6NU KomsOzIyImaZZF1f/PHPfy6Pjioq3mw2l5eXFRWPIJHLPv7gA44BD9jm0eJL9zU5 Dn3dAOCGmNIBiDqvN1Umm3Vte6i/xOv3iNBb7Hrr3XfV1a9Wq5VKRV39CPro/feH QncbcBB5B4nFH0Sn06HbFgBcjTcqANEi4m6sv7QrpobDLO3qKp3JHP3Xf1VXf2Vl pdFoqKsfQV998UWr2eT7RxryFoq7Q0OJREL8GbFQDCDimPkBCK3NU7upVEpM/9if GSB3HDr02JEj6urPz8+bpqmufgRdnJ6enZkhAAeFt1Acj8UMw+BEMYBIIQADCAmv IXM2l7Mta5idzAH3+xdfHBsbU1d/enpazPjV1Y8g27Y/OX6cbzMF16W907FYxzT7 tzO5LBQDCCUCMIBAunRwN5NxHIcmVSGj+gCw+JqZmZlRVz+yOAYcMj+JxP2bmYjE AEKAdykAgVEul5OpFHE39FQfAG6324uLi+rqRxbHgEPv0mni4WGj1arX634PBwB2 g0kkgGCYnJoSH5lbR4HqA8Bi4r62tqaufmT1jgFPT8fYBR12Xgw2TbNWrfo9FgDY MQIwgAAoFIu5XM7vUWBAVB8AFumXxSsVOAYcKa7rtlotWmcBCBwCMIAAKJVKmWzW 71FgEFQfABYWFxfb7bbSTxFZHx47Ntzn90CgnOO6RqvFqWAAgcNbFIAAKI+OptNp v0eBQVB9AFiYmZlxHEfpp4gsjgFHh3gRmYbBZgoAgUMABhAAUwcO8LSKCNUHgF3X nZ6eVlc/4jgGHB3ipSQCcK1W83sgALAzTCkBBMDE5CQHCyNC9QFg0zTn5+fV1Y84 x3E+/uADXq1R0OuDZRhV+mABCBoCMADdFYrFbDbLqcIoEPHp7//2b0o/RaPRWFlZ UfopIu7DY8fYAh0RIgM3m036YAEIFiaUAHRXLJWydMCKBhGcXnvrLaWfghbQqn32 0Ue2bfMdqyhwXbdNHywAQcP7EwDdlcrlTCbj9ygwCOl0+ugrryj9FLSAVo0+WNHR C8Dt9gbfUQIQKARgALobHR0doQV0eLndbjKRyGSz+Xz+uRdeUP3paAE9AN+dPt3c 2LAsy3acGLcihVevEbRp1umDBSBQeE8CoLupqalhVpOCz3XdeCyWGhnJ5fOlUklp q+dr6Xa7Fy5cGPznhXDhhx826nWRl2zLEl8MsViMYBx0NIIGEES89wDQ3eTUFNsp A0TMicVbSyKZTGcyhUKhPDr60MMP+z2oSyzLmp2d9XsU+NH87KyIT0a73el0XMfp drsE4wChETSAIOI9BoDWaAGts96ibjw+0l/ULRaLvizq7kir1VpaWvJ7FLixmQsX 6tWqaZqWbYtgTCrWltvttmgEDSBQeDsBoDVaQOvA6SeQZCqVzWQKxeLTzz3n94h2 qVqtVioVv0eB3Tv//fe1atUyTfE16bJcrAHxp9BuNmkEDSBAeNsAoLVSqZQhAA+K dzIzkUxm0ul8f/fyg4cP+z0omWgBHUqL8/MiFYs/WavTsW17qNsdJhgPiuM4hmHQ CBpAgPD2AEBrIoOlaQEtmxd0k6nUZtD99UMP+T2oQaAFdKQsLSxUq1WjH4wt2+7S eUuBXiNow+BubQABwtsAAK0duOkmMW31exSB1GtGNTwcTyRGRkay2awIuk88+aTf g/ITLaCxaXZmplqpdEQw7nTEK4XmW7vGTUgAAodnPQCtHTh4UMxN/R6F7rwV3WKp lM/nS+VyyPYtyyJm6jMzM36PAlpbXlysVCoi0bUbDYcV423gJiQAgcNjHYDWpvbv ZwLqERPNoeHhRDye6q/oFgqFJ556yu9BBYlINfPz836PAoE0d/FiZX3dWzEWwXiI FePLut2uIQIwNyEBCA6e3QC0NjE5GY/H/R7FQIkJZdd1va3LQbleKBA2NjZWV1f9 HgVCZWFubn1tzTRNkY27jjM0fInf4xooEYCrNFcHEBzRekYDCJxwrwB7i7rJRCLT X9EdHR//9YMP+j2o0BLpl8taMABrKytra2vtVksEY8e2Q3/AmAAMIFhC+zgGEAKF YjGXy/k9CmlE3E0kEulMplgsju3bR9YdsLm5uU6n4/coEFFrq6siGLcup2KRh0Uq 9ntQcognm/jvavDdJQABQQAGoC8RFLPBDMDdvmQqlc/lxsbH2cPsO/HHMT09TUM1 aGV5cXF5aal3UZNlib8N6PZpAjCAYAnecxZAdBRLpWw26/cobqx34dDQUGpkJF8o jI+PP/rYY36PCFcSf0YiAPs9CuAGVpaXVxYXW/27i4Oyd1q8uNqtFucLAASF7k9V AFFWKpUy+gVgbxVRxN1isTi+b9/Djz7q94hwY51OZ25uzu9RADu2trq6LCJxq9Ux TT0jseM4hmFs1Ot+DwQAtkWvZygAbFUqlzOZjL9j8DYzJ5LJfC43Oj7+xJNP+jse 7E6j0VhZWfF7FIAEK0tLi4uLRqtlWZYOZ4l7K8DtNgEYQFAQgDGUz+eHhoc5vQMN lcvl9MADsJjMiQllJpstj44++0//NODPDkUqlUqVq0oRUosLC4vz86ZhOI4z+CVi VoChp3yhMNTtNhoNvwcC7RCAAehLRNB0Oq30U3gLvN5+5onJycOPPKL008EvKysr TIMQEZX1dRGJW82mZZpd9b21RAAW2btOAAYQEARgAPpSFIC9c3S33Hbbkaeekl4c elpYWDAMw+9RAP5YW12dPn9exFQV+6UJwACChQAMQF+KArCYron0+8xzz0mvDG1d vHjRtm2/RwH4Zm1l5dx333W7XemrwQRgAMFCAAagL0UB2HXdW2+//alnnpFeGXoS k/4LFy74PQrAT2urq99/913vzjbZAVjUNNptAjCAoCAAA9CXugB82+23P0kAjgzL smZnZ/0eBeAntQHYMOq1mtyyAKAIARiAvgjAkKLdbi8uLvo9CsBPBGAA8BCAAeiL AAwpNjY2VldX/R4F4CcCMAB4CMAA9KWuCdatt9/+9LPPSq8MPXEJMCACcK8JFmeA AUQeARiApvKFQjabVXFpR7fbPXjTTc8+/7z0ytDT8vJys9n0exSAn9ZWVs6eOaPi QmDxRDVNs1qpSK8MACoQgAFoSgTgfD6vorKYru0/cOCffvc7FcXhC/Fn6rqubdvO zxE/L36B32ME/LS6vHz2u+9iCgKwZ3FhQVFlAJCLAAxAU0oD8OTU1Au//72K4lDk Z5PtVn4PENDa8tLS9yIAK9hT4yEAAwgKAjAATYn0KzKwisoiAI+Nj//hxRdVFMfu dPtc191cs7Usy+4j3wJ7tzg/f/6HH1StAA8Pi/pKKgOAbARgAJpSF4CFYqn04ksv KSqOn+VtQnb7RKC1+uzLxE9u/hoA0s3Pzk6fP69qBZgADCA4CMAANKVuC7SQy+df OnpUUfEo+9mF3E6fF3EB+GJ2ZmbmwoV4PK6i+PDw8AIBGEBAEIABaErpCnA6nT76 yiuKiofV5hKu+MHmyVuRbzc/CizhAnoS6VdkYFUBOBZbmJtTURkApCMAA9CU0gCc TCb/9fXXFRUPqK1blL0l3M39yd76LQdxgeA6//33IqMSgAGAAAxAX/sPHFBUORGP v/Lmm4qK66m7xdb7gTbP4rJFGQix8+fOLczPKwrApmlW1tdVVAYA6QjAAPSlLgDH YrHX3npLUXFfeOu33vnbzRtxvWTrRVw2JwNR9v133y0tLhKAAYAADEBfU/v3D6u5 tEMUff3tt1VUVuSKfHvF+q3A+i2A6zh75szq8rKiLtCmYVQqFRWVAUA6AjAAfakL wCJJvvnOOyoq785mvr26hbLXRZl8C2Avzpw6tb66SgAGAAIwAH2FKQBvnr/19id7 Ni/Cpb8UAKUIwADgIQAD0JfOAXhzN/LmtUCbzaW8JdzNj94vkDVyANgFAjAAeAjA APQ14AC8uf1485ztFT/YikwLIEAIwADgIQAD0Je6ACzy6x9efPHqpVoVnwsAfEcA BgAPARiAvhQGYNd94umnVVQGAA0RgAHAQwAGoC8CMABIQQAGAA8BGIC+CMAAIAUB GAA8BGAA+iIAA4AUBGAA8BCAAeiLAAwAUhCAAcBDAAagLwIwAOxUd9PlO9vExx/O navXagRgACAAA9AXARgArvZjvu1/3Pxh99q3lM9cuLCxsUEABgACMAB9TU5NKZqu EYAB6OznI+6Wv91pwQvnzzcbDUVPVMMwqgRgAAFBAAagL3UB2HGcgzfffPuhQyqK A8ANXRFxf1zC3W3EvY5WszkzM+PYNgEYAAjAAPSlNADvm5y855e/VFEcAIYuR1xv 5fYnu5QVRNzrq9frsxcvigEpOlRCAAYQIARgAPqamJyMx+MqKospaLFUuv/Xv1ZR HEBEXL1LeetGZb9H96PK+vr83Nxwn4r6BGAAAUIABqAvdQFYzE7T6fRDjz6qojiA 0PAyres4P9mo3O16y7t+j267VldWFhcW1D1OTdMkAAMICgIwAH2pC8CCqPzo448r Kg5Acz9eFSTC7eVl20stlAMVbrdjaXFxZXlZYQA2jGq1qqI4AEhHAAagL6UBeGh4 +LEjR1QVB+CrrWduRcDteku4Az98q4n5ubn11dV4IqGiOAEYQLAQgAHoS2kAFlPg x598UlFxAKptvRnIdZxLQVf81f9nfo9OL3MXL1YqFXUrwIZh1AjAAAKCAAxAX+q6 QAtiovw4VwEDevNWbR0v317eq9wN3RZl1S7OzNSr1RgBGAAIwAB0pnQFWEymjzzz jKLiAHZkM+i6tu0t5LqR3KusyPSFC42NDUXfTxR/UqZpEoABBAUBGIC+lK4Ai6n2 gYMH77jrLkX1AWx1ueXUTy8N8hZ1CboqNRqN2ZkZ8cQjAAPAEAEYgM5UB+DRsbF7 f/UrRfWBqPnZiLv1b/0eYERVq9W5ixfVXQJMAAYQLARgAPqa3L8/pmbGNuRdBZzJ PPTII4rqA+FzRcTdbLNMxNXZ6srK0sKCogPAQ14ANoxaraaoPgDIRQAGoK+p/fsV LVl4uAoYuAIRN3wWFxdXlV0CPEQABhA0BGAA+tq/f/+QygAsPMZNSMBlIt9uEGNC Z352dn19XWlDQdM063zlAAgIAjAAfe0/eFDpfZ5iuv/4U0+pqw8ETp2TnKEzOzNT rVYJwADgIQAD0Nfo6OhIOq2uPjchAVfYqNe7ruv3KCDThfPnm42G0oaCBGAAAUIA BqCv8uhoWmUAHrp84lH8n5gdJlKp9MhIJpc7xN1IiKrmxobIM36PArtUq9Uq6+tW p2NbVu/g9tCQeLIp7aQg2LbdEQG4Xlf6WQBAFgIwAH2Vy+V0JuPLp+5eFovHU8nk SDqdzWa5NBih12o2RXbyexS4ARF0q5WKiJ3iD8vpr9gPIOhei+M4hmFsEIABBAQB GIC+SuVyxqcAfC2bwTgejydTqZGRkWwud8edd/o9LkCOdqtldTp+jwKX1Ko9vaBr 272V+f635PwKutdCAAYQLHo9QwFgq1KplMlm/R7FtnhXxXSHh+OxWDKZTGcyIhjf fuiQ3+MCdsZot0Xc8nsUkXMp6Pa3Los86X2LTbegey0impsEYADBEYxnK4BoKpZK 2YAE4GvxrlAVE1lvK3U6nc7m87fdcYff4wJ+nki/IgP7PYrQEkG3VquZ3tbl/llr H7cuy9JbAW63NzY2/B4IAGxLsJ+5AMKtUCzmcjm/R6HEFcF4JJMR/6UEY/jO6nTa rZbfowi8arVar9U6pmldDrq9F7uyPsz+Ev+B7Xa7QQAGEBAEYAD6KhQKuXze71EM 1GYw9s4YX1oxvv12v8eFqLBtu9Vo+D2KwKhWKvV6/VLQdV3xAg5x0L0W8chqtVoE YABBQQAGoK98oZCPWAC+liuC8Ug6zYoxVHAcp0mSuUplfX1jYyMiK7o75Xa7y4uL fo8CALaLAAxAXyL95vL5oB+QU2rrVuoDBw/eylox9kZ8PdHNqFatLi0sdPrXQYXg jK5qpmFUKhW/RwEA28UzHYDWJiYn4/G436MIkkuROBZLJhK964tzuTvvvtvvQSFI 6tWq30MYnNWVFRH4RdZ1LMt74Qz3+T2uwBAPHBGAq1H6mgEQdDziAWhtcmqKfYZ7 9+MO6kQilUplMplf3Hef34OCpjZqNfEF4/co5FtcXGxsbFidTmjaL+tAPFhEAK7V an4PBAC2i0c/AK2VR0fT6bTfowgtMXkVUScWjyf7VzTl8nnuLoZIiW4/IgbU2uqq d17Xtu3e933EXIesq4z4HTba7Xrkt80DCBDeDwBorVQqZQJ+FXDgbC4Xi1Tc20Sd zd55zz1+DwqD02o0RHT0exTbsry01Gw0zE7Hse3et3IIugPXuwTYMDg3DiBAeJ8A oLUQXwUcLJtHixOxWKp/tPjuX/zC70FBiXarZXU6fo/iSkuLi41Go9PfwCy+FuPx OFlXB9yBBCBwePMAoDVuQtKct4laRJFEIjGSydx+xx3JVA+ty4LLaLc7pjn4zyu+ kCzLch1ncXFRjKEXdPtfWnSl0trw8OL8vN+DAIAd4B0FgO4mJydjpKlgEvF4qN9P KSYCTH97qvhfaXT0nl/+0u+h4ZpMwxB/qai8MD9fq1a9b5ps9tki4gYXLaABBBHv NwB0d+Cmm7oiRyE0ut3HnnrK70HgmqxOp91qqah85tQp27bp6x4ajuOYplmnBTSA QCEAA9BdsVTK0gcrRLpDQ48/+aTfo8A12ZbVajZVVD598qTXX01FcQye47pGq7XB AWAAgcKbEADdFQqFHMeAQyQ2PPybI0f8HgWuyXGcpppIc/bMmU6nwwpweHS7jT6/ xwEAO0AABqC7fD6fyWZpqhQaIyMjDz36qN+jwDW5rttQc6vNhR9+aDabBODQMAyj Wqn4PQoA2BkCMIAAKI+OptNpv0cBOQql0n2/+pXfo8A1dbvdDTWnOhfm5tbW1vhm Vji4rmu023VuAAYQNARgAAHAbcBhMnXgwO2HDvk9ClyPCMCbXZolWl9bm5+bIwCH g9vttppNbgAGEDgEYAABkM/ns7kcOyfD4Zbbbjt4881+jwLX06jXXQWt1+v1+syF CwTgcGD/M4CAIgADCIYDBw+qWJLC4N15zz37Jib8HgWup9loOLYtvazRbp87e5YA HAJcgAQguAjAAIKhWCxm2QUdCvc98EChWPR7FLieVrNpW5b0siJUn/z220QiIb0y Bsx13Varxf5nAEFEAAYQDPSCDo2HHn10ZGTE71Hgeox2u2OaKiqf+PprXsUhwP5n AMFFAAYQGOVyOZ3J+D0K7NVjTz7p9xBwA6ZhiL9UVCYAh4DjOCIAb9D/GUAwEYAB BEahUMjl836PAnviuu4TTz/t9yhwAx3TNNptFZW/+frrBAE44LpDQ82NjUaj4fdA AGA3CMAAgmRyaope0IHmOs4Tzzzj9yhwA5ZltZtNFZVPfPNNnJdwkLmuaxpGjfZX AAKLAAwgSIqlUjab9XsU2D3HcY4QgLXn2HZTzfret998M9ynojgGwO12283mBu2v AAQW70AAgqR3IXA2G2MLZWA5rnuELdDac123oeaE58kTJ8RHAnBw0f4KQNDxDgQg YMrlciKZFBP0brcbu4z5dFCIP7XHn3rK71HgBsQf04aaPa6nT54UL15esIHQ7XP7 vOet+Emr06nT/gpAkPEOBCBg8vn8tZqvFEslb3dlbIsBDw/XJ/50fnvkiN+jwI3V q1UVZb87fdqyLF6YWtlMub2g28+64gc/u8k5329DSPsrAIFGAAYQfoViMbaZjMWH eJxFY7/E4/FHH3/c71Hgxhr1ukhB0sueO3vWNAwC8OBtXc71VnS9v21wmhdAxDD/ AxBpP1k07mdjOvQolUqlDv/mN36PAjfW3NhwHEd62fPff99qtQjA6lxKuY7jreRe ZzkXAKKJSR4A/IxCsdhLxZuLxkI/G/s9rsDLZLO/PnzY71HgxpqNhmPb0svOTE9v 1OsE4D3y1m8dx+luLuaynAsA28NkDgB2piiycX8HtReP4ywa70ShWLzvgQf8HgVu rNVo2AoC8NzsbGV9PU4j9+3ZejTXJeUCgAzM2ABADm/R+Md1Y7pw/ZzRsbF77r3X 71HgxlrNpm1Z0ssuLS6uLC8TgLe68miut2+52yXoAoAKBGAAUK7oZePYT6JxNBeN J6em7rjrLr9HgRtrt1pWpyO97Nrq6sL8fAQD8E+uFGI5FwD8E8XpF4LOu4ahR+SH bpf7GBBoXheu6Cwa33TLLTffeqvfo8CNKQrAtVrt4vR0iAPw1VcKOaRcBFxv3tWf cXl/y7wLQUcARgDkC4V+B6Le1TXif8Nbls62TjU2m17yaEYIhHXR+I677pqcmvJ7 FLgxo93umKb0sq1W64dz54IegLlSCCEm4u7WKwOvePfxvtadS9Mup16r+TtaYBcC P5dCiIncm4jHk6nUjqZK4slsWZZj23zTHWH1k6ubLk9NBPHFr39C/uX995fKZb9H gRtTFIDF8/n0yZOJREJ6ZYm6/ZUu7zV1xZVCvLMglLw1XpF344lEMpnc/luJyMBW p2M7Dq8LBIjuUyVEU6FQELl3R4/gq4mZim3bYrIl5i6sCSNSdN5W/eDDD6czGb9H gRszDUP8paLyia+/1mQF2Mu34oUi3inIt4gmEX3F67GXepPJXRfx1h5EEubGaQQC ARh6EQ9i8QhOjYxIXMgSz+WOaYowzHMZkSVeWb0M7L2urvi49QdbKBrJb554Qp80 jusQj02j3VZRWV0Avnwh7qWTisOxmC2Srfhb76e2fuzfMEQXCURWb5/z8LDIvalU StYD35tuiSDMywqaIwBDI8ViMZ1Ox5RNjKy+jXpdRX0gNPKFwo+t5qQSkeOJp59W UTlqxO+k6u8jBDEAt1otTiQC1+cd8c1mMsNqniGu4xiGUWeuBY0RgKGF3g6cREKk 3wGcYOxv0ukQg4FrKRQKOTUB2HGcI888o6LyjsZgmman/5fZ6djicWBZjmXZ4h/0 ewf0ehp5Zz6Het850/NYtUi/P1nt7I+yt+n9crNA8UTd3NaY7C/ypEb60ulthk/x oGy3WioGLwKwoo5uIgBz5gW4Fm8r0EgmE1f87TPxXBIZWDxReTFCTzq+ryNqetue +3OzQX7SXgjmsArwcwrFYi6XU1F5FwFY/CsiqVYrFfGUEFM3x4upl/V2dogQ29dr SNrPrk5/y+vmftehfisjr5p3LFr+f1igeAdfvR9v9k77cRt8P5v2QrIXquPxZCIR 67ff96J1ryN/PO7tqRFfJ+LZvdPl3G+/+UbRNnuR2B0CMHAVb9U3k8kM8gFomqZ4 PvN6hIYIwPCZL+nX0zus0lv7sWh5gtATL7Ttz0KKxWJWTQDe/hbozz/5xOtLRF7V n3cPkIjBdxw6tJ0OZydPnBi6fAhdrna77Wy7G623z5/ZOcLNO+srHum+bGYhA0NP BGD4rDw6mk6nfRyAmLeZhkEHf4TVLmb5xVIpm80qGxGgitFu2zvZdbl51p0JOkJJ fIUnkskRqY1Fd8owjGql4tdnB34WARh+0mee7R0L5PAYwmTXC1ylUimjxwsT2BEx 1e4F4B1+N5MYjPDpHfeNx3uNRTXYREN3OuiGAAzf5AsFkX51eDRv6p8L7rAUjKDb 497OUrmc4apeBJDpXcGy22c4m6IRAt6e54xO8yvXdUUGZnIFfRCA4Q/xgB5Jp/dy 67oitC5E0O19El8ul7dzkhPQTa+5997aOpCBEWj5QiGRSPi75/lnWZZlGgavLGhC r5cHokOfzc8/y7Zt8aSmRzSCRdbcnQCMgNrjCrCHHdEIIq/Pc3rb95wNHhuhoQ8C MHwgHtOZbFbbZ7Sn1xzLNG0xl2IOhIDYUavn6yAAI6CkBOAheS8lYDC8Zlf+thS9 Icdx2q0WryzogAAMHwSoxQ5LwQgKiVN2AjACSlYAHmIvNAJC/4XfrUQArrEIDA0Q gDFogVj+3erSPUmcCobG5C5Y0QQLASUxAA+RgaE978Sv5gu/W7EIDE0QgDFoxWIx m8v5PYodE5OqjmmyFAwNyZqmeysJ8Xg8lUrp0z4U2L5ut9vpdBzbdl1XyiSbDAw9 ea2e05lMgJYTPK1ms16v+z0KRB0BGIM2Nj4uptd+j2I3xIzKNAx270A3e1z+9XJv Ih5PknsRFiIJW5ZliyS8t9vdCcDQkPiyjPcXfnVr9bwdnU5nfW3N71Eg6oL3ykGg 5QuFXC4XxEf2pt5NwabJfAiaEK8pMdnfxRfk5npvMpkM3BoCsE2u69peEhYvk11t 4SEDQyu9eVQ2OxzYb1Z2u91ms8mdwPBXgHMIgkjz24+2yXEcwzA22MMDDexi+VfM n7x9zuReRIdIwr01Ycvq7vAbRgRgaEJ8KcZisXQmE/StOtyHBN8RgDFQo2NjIyMj fo9CAjGFEhnYoTMW/LajAFwoFhOJhIi+gd6FAeyF1bf9rdEEYOggcP2ursM0zcr6 ut+jQKQxB8LgiGlENpcL+ncut7I6HbPTYScPfLSdANw7MNY/4ivmT4MZFaA5x3G8 Q8I3fIATgOGv4Pa7uhbXdVvNJq8p+IgAjMEpFAq5/kwiTNgODR/dcGru7XYeGRkJ 0zeeAFm8rtE3vDmJDAy/hGbb8xVE/OVaDfiIAIzBCccB4KuxHRp+uc7yL9EX2CYv BtuWda0ZOQEYvgjTtucrcAwY/iIAY3DKo6OhfI576A6NwfvZAOzdkEH0BXbkOjGY AIzBE+k3m82G9TFuGEa1UvF7FIguAjAGJ7g3AG9Tbzt0u82uHgzM1QG4WCqJ6Bua o2LAgIkYbBqG7ThbN0UTgDFIYd32vBW3AcNfBGAMzsTkZOjn5b3t0O12jY09GIit AbhQKCRTqXB/jwkYDNu2O6bpuq73+iIAY2C8LTyZTMbvgajlOM7K8rLfo0B0EYAx IOKZnut3MvR7IINgmqbV6TBbgmpeABYfE4nESDodkdcXMBi9/lidDpt6MDD5fq/Q KDzHu91urw000yT4JAqvMmhBPNbzoWsBfR2WZYkYzA1JUEe8psQkYjgWS6fTod9b AfjiUo9DxxE/GmIRGMqE766jG+rFX+ZI8AkBGAMSyjuQrs913Xa7zQ1JUKS38JtM joyMsPALKMVSMJTqHfqNxzOZTKQe5tyEBB9F6JUGfxWKxVwu5/coBo0bkqBIvlAQ 0TeZTPo9ECASXNcVD3PXcXiYQ64Q33V0fc1mkxUC+IUAjAFRegnwobvu+v7sWW2/ dcqRYMhVLBbD3SAU0JPIwLZl8TCHLDrfddTtm5iaWllaUjFCrgKGjzQNDAifUqmU UROAE8nkK6+/Ln7w5eefnz55Us8YbNu2mDlx3AV7VyqX0/S7AnzS6eNhjj3S+dCv F30P3nzzbXfc4brupx9+qOKztFstrsyAX5hCYUDErF1RW3+Rq//28svej8Uj+9OP Pjp39qyG30/lSDD2SEyYkqnUyMiI3wMBIs2yLJGBeZhj17Q99CsmUWKuMnXgwJ13 3+39jPjbLz75pNcHTjYxI6pVq9LLAtuh1wsPIaYuABcKhT//7W9bf0bMTv7f//zP sppNO3vBLcHYNTFhEtmXa34BHYg8YBgGGRi74F1cl9bvpl+RdQvF4r2/+tXWRWnx k//47DMxrZL+6QjA8BEBGAOiLgAXS6UXX3rp6p9fX1//n//+b1vBU3uPTMOwOEWG nRATppF0mpZXsngb/LwfDQ0PD8disf4HMe2LJxK9D8mkmKGKj+L/UqlUMtVbefd7 1D8xMjLSMU1vO64l/rIsu/c/2xEfRDgTP3B7uo4j/kvF/4b7N2YN9/k99pAQv83i YV4nA2Mn9LwSUjwlxOPvV7/+dfaqZqXiMfLV55+L54z0T0oAho94I8SAlMtlRd/v LJVKf/q5AOz5+h//OPHVVzHNztiICWvvlmAyMLaB9LsdYpY21J/Gbf3JXtgbHp6Y mOglWE86PRK9hXSj1RLZuNv/LbJtu7d/1wvMliVSXGV9Xfx896cTAi8nE5ivr9ca ut0mA2ObRPrNaHbo19vzfMttt4m/fvYX9ALwF1+IKYv0Ty1eO1UCMHzCGxsGROEK cLH44l//ep1fYBjGf//nfzY2NrSayfV20LXbXIKH64ts+t08cuZlMDFlTI2MiBwr fitS/Y+9HJvuxdlkxNLsrnkz3R7H6X9w3O2d63Nsu+NlZvGhF6B7i8xekO6vMneH L+fn/lK6Ro/ZAWAdGNvRa3kVi2U0694vngniQfrA4cOJROJav4YVYIRStN6o4CN1 ATiXz7909OgNf9nZM2c+/eSTmE6TM9pi4foicu63n6G6iX6mFS/nYrFYHh3Vbctx KHmRuLdf2u65Yv18F0SdjUaj2WgY7baYMYtwOHyZlAHrifPAuD4NW155r/077757 6sCB6/9K8cu+/OwzFafJCMDwkS4vRYSeumuQ0pnM0X/91+38StM0/+9//me9Xtfq TUjMnHgPwNXC2vPZ26ss4m42my0Ui6NjY+Kj34NCz6Uw3F8f9laJpZTtbRLe2Gg1 m94lukNhXCi2bVu8v5CBcbV8odBreZVO+z2QH4mJhxjPA4cPb2cztsIu0FyDBP+E 6h0IOiuWSlk1AVhEhJdffXX7v/7MqVOfffKJVodwaIuFq6nbNDFgYua0GXfHxseJ uwHiLRP1VoYv9w1z+5ufe9l4D8vFRn/PcKvRaLfb4ssjHHnY60bGqRZsJdJvLp/X 54vbe0Ufuuuu/QcPbvNfEb/+s48/7kr6dthWrVarTgCGT/R5VSLk1AXgWDz+2ptv 7uhfEY/d//Pv/24qaOqwa7TFwlbFYjGTzQY0FYgJUzKZzOVy5bGxfZOTETzAHAVi Jm3178MVgXiPpcQXjJgH9yJxq2VbVnDzcG+J27YbZGD0FQoF8RjX59CveM3GE4nD jz56nRO/VxMvz0+OH1fxkiQAw0eBfI9BEIkJ/dXt9WV54+23d/FvffLhh+fOntXn zUnMnMT8ickT8oVCVqdp0w2JGVIimSyVShOTk9l8PnzbtnF9juNYpnlpZVhGtWql ImbG7XZbFAxWHm63WmL8fCsz4i61vEqn9bmBQnxZHjh48I677trpvyhegx9/8IGK 96NWs0n3OPglMG8qCLpCsZhTE4DF0/mtd9/d3b+7vLT0P//933LHsxe0xUJQ2j57 y7zj4+N33Hnn7YcOiZ9pNpurq6t7b6SEQOtdQty/YGmbLaZvaGNjY31tTXx1uUHY LO32G2IxrY8y3VpeeccXHnjooXyhsIt/XTzqP3r/fRWnxsSLmtkO/KLFixNRUOif hFFReS8BeKi/7vpf//EftWpVn/cqkYHZFxRZ6m7M3jsv3I6Ojd11990i926dEokZ //r6OukXm8ST2erdnSQtCQviwbi2utpstbwrl2SVlYvDwFEm0m88kdCnfYN4Jmey 2QcffnjXFRzH+eT4cRUvt2ajwcsEftFixo8oyBcKeTUBWDzfX3njjT2umH391Vff /OMf+nTGMtrt3lky9tFFTKFQyOZymnwvZlPvjqJE4sDBg/c/8IBIv1f/gkqlIuYx 4itWt5FDByIAe6eFZbWVFkS9leXlWrUqZuf6PLc39Zp78QCPHjHJKZRKKvpF7YLX 7+q2O+646ZZb9lKn0+l8+emnska1lXiBcOYLfmGyggERbwy9Xohq5sfPvfDC/hvd ZXdDa2tr//c//kOfBSzTNMWUkSlUdOi2+bnXMSUev/nWWx86fPhaB/jFrxHpV3yV kn5xfeJLpXdUuL86KrGsmOIvLy1V1tbcblefNWExqt7lT2zvjJJew+dsdliPL0Jv M86DDz+89+sn19fWzp4+LWNQPyFG2OwlYGY48AfzFQzO5NSUognKg4cP33v//Xuv I+Zn//W//3dVm+3QlmWZhsE7RESouyt7p0SWOHjw4OFHHimVy9f6NeI1IkLvxsaG eL2I6b4mLxnor9c+utPrei9xQXiof5hlaXGxsr6uyTlh8R/YsSwWuCKiUCikMxlN NiOIl1g2n//1Qw9JKTU7MzM/O7v3UlfwvnUlvSywTf6/SSA69k1M7Kj5/vbdcejQ Y0eOyKr25eefn/r2W00WE2gNHRH5fD6by/n7VSfmOslk8r5f/Ur8df1f6aVfr+uV DmEDQSS+hDr9e4Pklq1Vq4uLiyJj+55GuOUlCi41fM5kNJkzOI5zy+2333LrrVKq iTeFs2fOVNbWpFTbSrzwV1dWpJcFtomJCwZnbHw8lUqpqDy+b98///GPEgsuLy39 f//1X5rM7GkNHQXl0dF0Ou3XZxeznHyhcOTpp8fHx7f56zc2Nki/2DsxXxcx2LIs uWVF+JyZnnYdx8cvUcMwqpWKX58dA1AoFjWKvq57/wMPXGfbzi58/eWX7VZLYsFN nU5nXUGuBraJuQsGZ3R0dETNFF8kh6OvvCK3ppiQ/fv/+l9iBiO37O7QGjrceofH fOp95UXfp5555me7W11LpVKp1WrsfIYs3u1BtuwYLObu0/7F4N4px2aT/TthVSyV 9LnrKB6PP/Too9I32X320UeOvC7uW5mGUeHbQ/CPFq9bRIS6+13EO9Drf/+7isrH /t//m52Z0eEdTsylxASxVq36PRDI58vyr/iKSqVSz73wwvi+fTv6F6vV6sbGhmVZ OrwuECZiqm30+yfLLdtqNi+cPz/Uf6eQW/mGWAQOq5KYz6TTOjwDxZO8NDoqpQ3K 1T48dkzR+rZ4pVeZz8A//r90ER3FUimrpseP6zhv/du/qagsnPvuu08++kiTPU5m f68gbbHCxJflX7fbfejw4Rue9b2CmGm1Wq319XXSL9SxOh0xOZZ+p/Ty0pL4a8AH g1kEDp98Pp9MJhVtZ9spx3EO3XXX/oMHFdX/8L33YmpeMpyQh7+YwWBwCsVi7hqX qeyRmGS8+sYbCWX3x1Qrlf/z7/+uyQ1JnT5mVKEx4OVf8WIZGx9/4fe/38VmOdM0 FxcX5TbvBa4mvkpNw+iYptyy4kv3+3PnRMAe5LdvWAQOk3yhkOrzeyA9Xdd94PDh XD6vqL5I159++KGiF0uz2aSzCXxEAMbgiHeO/P/P3p34tXFk+wIHjATaJUACJ463 eHfifZlsM5k4yTiTm8ROvMfO/e/eu5/77p04eyYzuXPjyepJJrEBAzYYBJhVgJDU 3dr1jqSEIWwWUp+uaun3/Xg8BKRSWbS663RVncN2pn72t7/dpFPawxWl0+mP339f 5ckGsV7pVCqeSCAGrgIGJ3+mAODkU089vnPnep9IYyBN00KhkO7JigBWQyc6TVV1 nwqeCYXGx8YMmwqmD52qKFi2UwVoDGO32ZhmRNdrQ2Pj4WPHWA/jmenp/rt3mRrP lwDGGAbEQQAMxqGxvsPpZLqbuHPXrqMnTnC0vNhXN24MB4MyLP4sbpaL4vphcnz7 Apaj4/bVN94o4yYUPTEej0ciETreZDj4oXbkKHpUVd13BScSiXt9fYbFwFjtWQXk qfSby+V8LS279+3jfqH79+5NT01xtJzfGpCPgHFXCITBUAYM5Q8EmK4frX7/S3/4 A0fLS9zt7f3+5k0ZtgSjPFIVaG1rs7At3V+sqanptbNny8sRSoOVuQIZDnuoNXzL oft6evRtczWpVGomFDLmtYCDPOWOMpnM1u3bH9m0yYDX6vzpJ1VROFqmfwVTaA1Q IgTAYCi+UsA0vj97/jxHy8uFQqG/fPKJDFNhKI9kai6Xi2/71mJ2h+O1M2fKO2Lp WRT6RiKRdDotwzEPtYkC4Lim6dsmnT/7entzhuxpV/LrPbFgx5TkKXeUyWafPHiQ onFjXu4f33zDlPEBRYBBOPGfZ6gpfPl+aChz+do1jpZXlEgkPnrvPTqJG/aKq0F5 JPPiKwy2GH3i3njrrbJHb3R0zczM0N8yzH5ALaPzbVzvLAx0/uy9c0ffNleEoi8m JU+5o/qGhsPHjhmzYqiIsQYSMsOBaOI/0lBTPB6PjakSUjZ75Z13OFpew18+/TQ0 PS3DpRHlkUzH6XTSZ4F7RxkdnG9dvFjeyue6wsdqYmIioffqU4DycMwD00F+p6uL +5OYyWQ0VcUp2kTkKXeUy+XsTueBQ4cMfl2+AJg+C/NYuQZCiR+4Q01xu912nkpI 5KXTp1vb2pgaX80/v/++984dGSbH8sWREgkMsMzCgPXPNLJ/7exZeqEynkuRMw3Z 6XCanZ2ldmS4ywNQV7jZR390btOQnFhYBW0iFP1am5pkKHdEp9+OjRu37dhh8OtG I5E7nZ1MjauKEkH6EhAKYxowFGslpH1PPGH8LVISHBz8iu1G6bqkUqkEyiOZBPf6 51wud/jo0T3lZgqliLdY9ZfCYH07BlAhGj2n9S7HNTU1FZqaYr3Rg1XQZkEDlfzy HAmu6RT97ti92x8IGP/SNLCZGBtjahw1kEA4BMBgKNZKSIFA4IWXX+Zo+aHmw+FP PvxQyEsvkUmntXgclxb5tfn9Za9MLoXd4Xj97Nnynkuf0FQyGYlGabyOuV+QTS6X o1Oc7smreu/c0b3m8GLpdDo0Pc3XPuhCnmK/FP0ePHKEb9Hc2rpu3VJ4FpShBhLI ACMbMBrfuN/IRNDLJZPJD69flyEtVr48kqpirZ3MWJdC1BWOgdfffLPsl2hoaKDj Z3p6mjUeACgbBZOq3gPoRCLRf/cu61oeTHxJzlWY+5VhPVd9Q8OR48dZb5KujS8F NO4EgQwQAIPRfC0tFKlytGxwIugVffbJJzOhkPBJM7puxTUNe2yk5fZ47DzZ4Ir8 gcCpClZD0ABlfn4+HA7LMBAEWJGmqim9bzgO9PfrXnB4MVVVUbVOWm63u1mCYr/5 lFcOx4HDh8V2gy8DViKRmJud5WgZoHQIgMFoHq/XxrP1kaI+CoCFB5//+O67/rt3 hXcDJYJl5vP5+JKL0gfhzfPny95gTIduJEIHznwymRR+GAOsJpfN5hdC67pIIZVK 3e3t5QuBEvH4HKq/SEmSYr90PPsDgcd37RLejW+//JIrBbSmoXAjCIfBDRiNNRH0 86dOdWzcyNR46SgAvvntt8JvJNcV0q6k02lstpGN3+/fwLa2zeVyvfrGG2U/nYY+ oVCIYmAZDmCANXBkhO7r6WFa+VlXyNEwjcWfknE6nY2NjQaUZH+oTCazfceOjkce Ed2RuvDcXB9bfWykgAYZIAAGo7Hufty5e/fR48eZGl+X6ampv376ab0EIQRKBMuG NRUcha+/f/HFSm4DqaoaDoc1TUMADJLLZ8OKRPSdBI5GoyPBIN/HE+l/pCJPsd9s JrP/4EG3xyO6I3n3+/unJyeZGsdOeJABAmAwGuvo3+vznX71VY6Wy0CBxIfXr/NN JpQOJYKl4nK7HZyJPS9dvVrJ02dCoZiiZDIZ4asBAR6KYxK46/ZtvprAiqJEMf0l B3mK/ear1h0/zpQepQy3/vnPuKZxtIx7QCAJjG9AgNa2NovFwtHyhsbG85cucbRc HooiPnzvPU1VRXcEJYIlwrcNnnRs3Pj8qVNlPz2bzY6NjdGhgulfMAU6YmN6x5OD AwNxvYPqBdgAKQl5iv3SuOXI8eNSnXK/++orppZpKDITCjE1DlA6BMAgAF8iaBoM XXnnHY6WK/H5Z59NTU4Kn09Lp9NxlAiWQEtLi5UtEfqpl18OtLeX/XRVVWdmZuhQ EX64ApRIVZR0KqVjg7FYbHhoiOkjkEwkZpECV7R89Guz8c3zl4hOuU6n84lDh8R2 Y7mvb9xgenOQAhokgSEOCMA3A0aXkzcvXJBnHdGCH27evNvXJzyoyGQycU1DiWCx +EphZ3O5K+VWAqODkw6Pubk5Gv1j/TOYCEW/FAPr2ybfKmgUQRXO5XI1yxH9Btrb t+/cKbYby6VSqR+++47pEoAVECAJDHFAANY9kMdPnnxcvisKuXf37s1vvhF+0c1m s3QFwiY0UVj3wNsdjtfPni3vudQlGppPTEwk9a6tCsCKIxVW7507+ja4AHsgxaLh h02CYr+ZTGbbjh0bJUj4vNzE2FhwcJCpceyBB0kgAAYBWBNBb3rssWd/9zumxis0 NTn5188+axA9t4YSwQK5XC4H28G/Y+fOYydPlv30VCo1OjpKhwemf8FcNFVN6Xrj 5sHICF+lFiWfBBfLcASQpNgvRb/7DxzweL1iu7Ga3u5uvklapIAGSWCUA2IE2tuZ bsFWMglmADr5f/Tee0xzC6WjDsTjcaxEMh5rHewXT59ua2sr77nFpQFTU1MIgMF0 dF8FrSjK8NCQjg0uhjqoQlDA2dzcLPzkRmfaw8eOyVB2eDU/3Lyp76b6BfRvn2Kr rgSwLhjlgBitra0WntoDdExfrKwMDDe6tLx//XoykRDdkTqKgdMoEWwsvg3wlWSA o0FhKpWKRqNh3BMBE8rlclG9l7TwbQPGNkiDOZ3ORoulWYJiv/UNDUdPnBC+E2pt 3/797/U88xOpZHJmZoajZYD1QgAMYnh9PqarkZyJoJeg4dqnH30UnpsTfjc6kUjQ NQkxsGH4jnw6li6+/XbZz00mk3Nzc4reyYQAjKHEYpl0WscG+QLgeDxOJ3+OlmE5 in4tVqvw1Jh00W+22Q4eOSL8ov9Q3/z970wL9HDkgzxk/xxCtfJ4PDa7nanxl06f bi13IaiRvvzii5HhYeGXw2QBtuUYg68GWIUZsBKJRCgUSkiwMAGgDIl4PKFr8V6+ PFioBGMYp8tlt9uFp7yiA8nr8+3Zv19sN0oRjUTudHYyNa6p6jySj4AcEACDGKyJ oHfv3Xv46FGmxvV168cfuzs7hV+eU6kUjckQAxugta3NYrFwtNze0fH7F18s77kU AGuaNjk5mc1m9e0VgDHS6bSq60qW+/39TPeD6Hw7EwpxtAyLSVLsl06qGx99dOv2 7WK7UaLBgYGpiQmmxpECGuSBABjEoCsTBcBMk58UY7x0+nQZT6RxCVNwsga63nzz 1VfCY2AaPsbjccTA3Px+/waeIsC79uw5cuxYec+lw4+GJuPj48LXIwCUR/dtwGOj o0yzVZl0ehqlgJlJEv1mMpkdu3YFOjrEdqN0t3/8UVNVjpbzBcAUBWMMkATGOiAM XyTQaLGcu3ixjCfGYjG6XjLlKFqDJOWR6FId1zTU52DFl//85FNPbXv88fKeS3Fv MQAWfiMGoGyxSETHJQyzMzOTPFNhyIXLzeVyNcsR/cpc7mhF3339dR3Pyn/c9wGp IAAGYVpaWqw8myHLzoMVj8cnJiba29uNj4Hz5ZGuXxdcHOmXWjhYpMTE6XQ6nE6m WdbTr77q9fnKfjodgZOTkwiAwbw0RUnpV76FzoRD9+/r1dpi+amwfDlUpB5k4XK7 6Qou/FSWy2YPyV3uaEVf37jBdOMgmUjMYus7SAMBMAjDVw+Ghhdn3nqrjCRbmUxm uJCVSkgMTEO39/70J6b6e6Wjd49GfhFkqmBAAbDT5eJomX5rl65eLTu0pqfTcHxq akr4qBGgbPrmwaIPRU93N9Ptqlg0igCYg9vjoWu3+K0c9fVHT5xo5Fnjxodi1H/+ 4x9M7x6qf4FURJ8joIa53W47Wx6sQ0eP7tm7t4wnBoPBbDYrKgamIdfH778vfBEy dSNO1yrEwHqj6JdCYI6WK6z+hQAYqkAqldJ0rePFl6EwP/8r+jxffTweT7ME0a/F aj187JjwbpThwejoaDDI1LiqKBEsLgNpmO/zCVWDLxggHR0dz5eVEXd8fDxemEOg q1cgELCz1Wpaw9/++tcJCdIRUQycTqcxTaEjBMAAfDKZjKJrVMlXChgBsL7ovNrY 2Ch8vTGdSF1u9/4DB8R2o2zdt2/zHZY45kEqCIBBGLpi2R0OpgF3U1PT2fPny3hi KBRaPAHb3t4uJAb+x3ff9d+9KzwGTiQSqWQSMbBeXC6XAwEwAA/dE0HzBcBKPhZA MKAPGktYrFam+uqlo8PPHwg8vmuX2G5U4h/ffMNUCY+aVRUFYwmQBwJgEImvJmou m71cVjwwPz+/JE9DIBDgK1m8ht47d/75/ffCA5JkAW7c6oIvAC77gP/56QiAoSpQ AJzTL4dt161bTKUKEADrxelyWQvEdoMCvM1btz762GNiu1Ghb27caOC544Pa1yAb BMAgktfna25u5miZxkBvXrhQxi1hTdMmlpW+EBUDDweDX37xhfCYJH/vVlURA1eO MQDO5S5fu1b+8+vraUROR77wgw2gEvpWQsIMsOQo+rXb7cLPWplMZtfevW1+v9hu VIhi1B+++45p3Vk8Hg/PzXG0DFAeBMAgktvj4VtgfPjo0d3rz4OVTqdHRkaWf9/v 9/PtWF7DTCj02ccf14u+wFN8pSoKRmwVknYGmEaQiqKMjY0JH0oCVIICy0w6rVdr mAGWGZ1O7Q6H8I1C2UzmiUOHXG632G5Ubmx0dIQvA5aqorQESAUBMIjEFw+QQHv7 Cy+9VMYTh4aGVlxE19bW5uKpYbM2ijw/uH5dx3V95cnHwKqKEsGVkHYGmOJe+uVO TEwIP8wAKkFnSx0ryWEGWFoUcNrtdvHRbzZ75MQJ4duPddF96xbfHl0c8CAbBMAg ktPppHiA6RpmtVrfvHChjCeOjY0lEokVf9Ta2uoWcaM3XSgRnJKhRLCqopJB2aTN Ak2fwXg8Pj09LfwYA6gEnaBSyaRerSELtJzoKmyTIPqlDhw9eZLpCDHezW++yfFk wKKRQz7/FTJggUwQAINgfHmwyg4JKAxY40zt8/m8Xm8F/SoTXUI+ev994WMmelc1 TcM8cHlkDoATicTc3Jyqqjr2CsBgcVVNIgCuai6Kfm024Zs1zFvsdzVf37jBdLQj AxZIqHo+umBSFE82seXB+rczZ8pYtBwOh+fWzNZAATB1u4Kule/zzz6bmpwUe9FF DFw2mQNgGqPMz89jeh9MLa5pyVXW75QBAbBsZIh+aWhBp/EnDh0S2Afd0TX91g8/ MA0tEvH42mMqAOMhAAbBWPNg7dm379CRI+t9lqqqk5OTaz/G4/FQDCwkEP3u66/v DwyIjYHza6E1DTkt1kvaALjul1zf09PT9MutpmkNqCn6BsDdnZ1MsRYC4DLQaIGi X+HXvla/f+fu3QL7wGHo/v3J8XGmxpEBCySEUQ4IxpoHq7yoIJVKjY6OPvRh1PPW 1lYhF+N3/9//W22XsmFoHBCPx+fDYbHdMBe+AJh+HecvX26sLGNt8chHAAzmpWMA TJeP3jt3mD4LCIDXy+P1Njc3Cz81NTQ0HH/qKbF94MC3/rkOGbBAShjlgGCsebBo KH/p6tX1Nk7PCgaDpaTDpc63tbUJuST/+eOPZ2dmhI8GKAZOp1JIblG69o4Opt/a 6Vdf9VawMp96lU6nJyYmdNxCCWAwHQNgTdOG7t/Xpakl6OIyuazaPKyGrrONFksz z1ap0tFvzWa3H1z/mjL50T/tu6++4huGIQMWSAgBMIjX5vdXOHO1ht+98MLGRx5Z 77MePHhQYhhgt9sDgYCQQPTrL78MDg4Kj4ETiUQqmcTlrUT+QIDpRvuzv/3tps2b y346HUiZTKa4DZi+EH5cAZRBxwB4Phwee/BAl6aWoM/X9NQUR8vVh6Jfi9UqvM4Q RXG+1tbde/eK7QaTudnZuz09TI2n0+nQ9DRT4wBlwxAHxPO1tPBd3rZs3frUs8+u 91lrJ4JewmazUQwsJC1Hd2fn7Z9+Eh6rJEkigRi4FHy3ew4dObJn375KWqBBXiKR KBZDEn5QAZRBxwB4ampqhmfgjpCgRBT9UuxrtVrFdoNOjI8+9thjW7aI7QYfin4p BmZqPF9fgK1xgLJhiAPisebB8ng8r7z22nqf9dBE0Es0Nze3t7cLiYFHh4dv/O// Cq8JQSFTIh5HDPxQfHW/Ht206bnnn6+wERrqTUxMaJqGABjMSMcySEODgxpPVTBU hSkFRb92h0P4pS2bze7as6fV7xfbDVY/ff89X1YRZMACOWGIA+LxZQaqK6SsuHDl ynqfVUoi6CWsVmtHRwdfGok1zM3OfvzBB0JeerF0Oh2nGBi5LtbEtwS6ubn5zLlz lbcTjUbn5+cpikAMDKZDIWtKpwC4p7tbl3aWwxLoh6JRgd1uFx790m/qwJEjfOMT SXz75Zd8Z3vkewM5YXwDUuDLDFReImiK5UZGRtb7LIvFQjEw337mNVDk+af//E8Z hguapuFqtwa+ALi8ez3L0S9xZmaGwmDhhxPAeqmKkk6ldGmKrwYSAuC1yRP9Hv/N byyiF2AbgC8FNPK9gbQQAIMUWPNgvXT6dGtb27qeUnoi6CXoX7Fx40YhMTBdrf/r //7fdfdYb9lCDIyaB6vhC4ArLwVcVF9fP1+AncBgOkoslkmndWmq89YtpjM5AuA1 uFwum83WIHpBUy6bPfHMM8KDcANEI5E7nZ1MjWO7O0gLgxuQgs/na2IrcrBz166j J06s91ljY2Pl7Yqh8IZiYKZ9ng/13//5n3qtACwbRWL5GDgSEdsNOfHd69ErAK4r DNApAJ6bm6uF8R9Uk1gkQh8EXZrqun2b6V4VooLVuNzufPQr+rRTX19/4umnxfbB MPfv3eO7HZOIx9eVTgXAMAiAQQput9vucPA1/sfXX1/vs0KhUNnTmHT97ujoEFW5 4eP334+IDj5zuZymqsK7ISG+JFj0nr954YIuRx2N/1RVnZ2dRU1gMJdIOKxLOxSj 3u3tZVoBgSRYK6Irtc1uF77qxGq1Hj5+XGwfjPTj99/rlTh9OVVRMAwAOSEABik4 nU668jHdbqcL6sW3317vs+bn52cryN1PMXB7e3sz27T22v7388/Hx8bEjiTyMbCm If3jEi0tLVa2OyPHT558fOdOXZqiX18xFZzw8ShAieigjep0wqEAdWqdeRBLR/FG JReXquT2eGw2m/BrFnVj35NPCuyD8b75+9/59rprqoraECAnjGxAFi2trUzl/rLZ 7OVr19Z7ZaXgbaKy5A30ioFAgK/C09p++Mc/+GYwSkdv47xOczLVwevz8d0W2fTY Y8/+7ne6NEVHTjqdDofD0WiUPkHCDySAh6IBt6JT9gG+Gkh1hZyFYawLXcTj9VL0 K7YPFP0GOjq279ghthsGo3/1t19+yRQAJ5PJ2ZkZjpYBKocxDciC9RJIUQHFBut6 Co2lhoeHK39pv98vqojCvb6+72/eFB660GgvnUrhNnAR63HucDpfO3NGxwYp9J2Y mOArEQmgo1QyqVfU2tvTk9NpL/FyuC24gC6OjRaLqKVSCygO3LJt28ZHHxXbDePN hEL9fX1MjeM4B5khAAZZuNxuB9s24C1btz717LPrfRYFwBQGV/7qra2tbre78nbK MD429re//lV4ThGKoGhsihiYeDweG9uiADqhX7x6Vd82U6nU9PQ0DWWEH0UAa0vE 4/RHl6a6b9/mS0RMUfo89oYUol+L1SoqWcaCbDa7Z/9+X0uL2G4IcbenZ45tNb6i KMiFCdJCAAyycLpcfDOldofj9bNn1/us8fHxuE7DKZ/P5/V6dWlqvSLz8x9cv860 v7p0SZJIIAZmvdFDI7mLb7+t++86v2IzHKbRDGJgkJmmKCk9igDT56inu5vvaEdg UFeIfin2Zdr3VLpMJnPo2DFRO5WE++G779I6lQ1bji73MRREBFkhAAaJ8JVIzeVy l69dW++zZmZmdExg6PF4KAwWsiCZYs//+o//EB690Ng0EY/XeAzscrkcnEviTz71 1LbHH9e3TTpoNU2jGFhVVeEr6gFWo1cNpNmZmcnKEkCsTcnHBTUdGOTTXjocG0Rf kij6PfH000x16UyBNQMWil2DzDCUAYn4WlqYVkNRAHzu0qX1lp+hMUpI12IVdNVv a2sTEkLQuPA//8//Mf51l0in03GKgWt48EfHgNPl4mu/Y+PG50+d0r1ZOmjjicTc 7CxFwro3DlA5HVNADw4M6LX2Z0V0Aqzl+4B0ArTZbMIXJdE18eQzzwi/LywQXY6/ //ZbpgFJonC94GgZQBcIgEEirPmBjh4/vnP37nU9hc7gY2Nj+nbDbrcHAgFR02j/ 9R//wbfeqUT50giaVssxMN9KB2KxWN66eJGpcfrdzc7OKoqCvNAgGzqzqTpFlXe6 uvgO7xqfGZMk+iUU/YrugmDjDx4MDw0xNY4MWCA5jGBAIqzbIynsfOHll9f1FBrl B4NB3XvS3Nzc3t4u6sbzB9evU/ApNnqhN1ZT1ZpdBMhX8auu8N5eeecdpsbrivNs 0WgkEkkmk4iBQR46ZsDqun2bL0Kr5dowLop+7Xaxk650BrNYrUdPnBDYB0l03bql sK1EwEZ3kByGLyARp9PpcDqZRtWNjY3nLl1a77NGR0d1yaqyBMU/HR0dou6Cy1Ai OB8Da1ptXiBZSwHXlVX0a13yy6HjcYqBo6LvpAAsoKF8Ro/lLfPh8NiDB5W3s5qa LQLscrttNpvw6LcGi/2u5ruvvmJqmd5nJZ8Cq3bX+YP8MHYBubT5/UwZKcqbGZua mlIUhaM/Foulvb19vduS9dLT3f3jDz8IH4tQDBypvXIgbo+HNeloGYsdylC8hTE7 Oyt8UT2AjhuA7/f3sxa+VlW1Nk96FP0Kv+u6eevWRzlvDpoInbdvfv010114ajw0 Pc3RMoBeEACDXPjyYJEXT59ua2tb11PC4fAc2916uvZ0dHSIqgMxNDj4NVsGyBLR sDWuabVWEpM7ETSNMi++/TZf+4tlMhn69cViMRrxYDYYREmlUppOdypZ1z/X1WQK aI/H0yw6+qUz1c7du/3t7QL7IJXpycn7/f1MjSMDFsgP4xWQC10pbWyTY9sff/zE U0+t6ymqqk5OTjL1h1D82d7ezrogdg2TExOff/aZ8DSYtZYtw+l02h0Ovrc9l8ud PX/eyIOKwo9ogS5FaADWS68KwOl0mnV7CH1AVEWpqaWhrLktS0TR774nn/T6fGK7 IY9sJtPb3c13I0ZT1Vq7rw2mgwAY5MI6OUYtv3bmzLqeQuOhkZERpv4U0WDL7/fz Zf9aG0WeH3/wgfC5u3g8nk6lamdc2NraauGc+d+1e/eR48f52l8RfVhi0ei8TrVY AUqUX/8cidD/Vd7U2Ogo68A9lUzO1EwGLKfT2WixiLq9u4Ci30NHj9oFXWHlFNe0 2z/9lGM7UdfgMgcwHQTAIBfWPFg0Trp87dp6nxUMBg0Y0Le1tbk4y8OuQVXVD959 N6fH8LESiUSCRoc1EgN7vd5mzlkR1mJIa6MPSyH7SYx1IyXAAjpvaKqqS1OsBZDq CoFHuDZWu9Cl3GK18m1oKhGdjo6cOCG8G1IpbpjnW+qPDFhgCgiAQTp8k2N0Xqao YL17bsfHx+M6VddYm8/no7jIgBdaLpVKvfff/y08m1GSJBK1cOFkrfhVVxj2vXnh gti5FwqAo9Eo/TaF31uB6qZX/mc6Afb19LBuCamR2jDcuzxKd/TkSaa0muZFZ2Y1 Gu1jW+pfU8scwLwQAIN0WCfHDhw+vG///nU9hU7lEaOGLG63u6WlRciCZAqZPrh+ Xa+JlLJRKJ6Ix6s+BmZd6VD0+M6dx0+e5Gu/RJlCzWf6hcbjcUTCoLtMJqPotNhy dGSENTqtkZkxOrnZHI4NoqPfDY2NR44flyEIlwodhLFodHJ8fCYUYnqJ2lnmAKaG ABikQ0Eg33adltbWl195ZV1PiUajIbZLxXIOh8Pv94valPvJhx8Kz0eVTqcpWIpV +w4iOhRZE4Bv2LDh/OXLfO2vF/1aNU0rRsKi+wLVQ1WUtE6l2rs7O1njpWQyOVvt M2NOl8tms4kqcb+gqbn50NGjYvsgp2K+9Ht37+r1qVmOPpKGzRkAlA0BMEiHrqAU BDJFgDS+uXDlyrqekkgkxsbGODqzmubm5vb2dlG3rv/388/Hx8aEl6yIa1p1Z9Hg To6ay+X++NprHkGL6tdQjIQVRaFPFtJlQSV0nP6lE879gQHW817Vp7t3uVzNoqNf Ou+5PZ59Tz4psA8yK+4X4LvXk1/moChVf/8aqgACYJBRm9/PtG+HBtyXrl5d16mf TuhDQ0McnVmD1WqlGFjU5qWb3347cO+e2BiYflM0Xqzi/XLc1YCJPxA49fLLrC9R CfoVJ+JxRc2jSEZ0d8B89Nr9Swb6+5PMaduqOzWuy+222WzCC8u3BQI7du0S2AeZ FW8Y0bt0p6uL6TeVTqdD09McLQPoCwEwyMjX0sKXtvE3Tz+9dfv2dT3lwYMHyWSS qT+roei3o6PDYrEY/LpFt2/d6rp1S+xohgKkuKZV8WIqv9+/gfMeRzaTuXTtmvy7 4GhAlkql4r9AMAyl0DH5Mx2B3bdvs34YKVCfrt7AwO12N4uOful68chjj23ZulVg HyRHnxf61MzNzk6MjzO9RCKRoPaZGgfQEQJgkJHH47HZ7UyNd2zc+PypU+t6Cg1c hGQuofEExcCiSjj0371789tvhd/R1ygG5qzMKZDX5+NO1Lxrz54jx46xvoS+aBSb 36WmaRQJJ5PJ/Pye6CLVICE6TopzWbq0xl3+t65Q6jw8N8f6EqK46XptswlfMbTt 8cc7HnlEYB8kly9QV7ibPDgwwJeIgWJs7o8SgC4wsAAZsa4ObbRYzq2zRCqd0GcF 3dSkUUUgELCz3Q5Y2+jIyI2//U14DExX66rcO8ddDCmvvv7S22/zvgSb4sxwIpEo zgwLL9MFksjfF1NVHbP4dHV2cmctrtYCSB6vt7m5WXjOiN379rW2tQnsg/zoNJoo xL2sxa6re50/VBMEwCAj1iqC2Wz2yjvvrOspmqZNTExwdKZEbW1tLpdLyEvPhEJ/ /uSTBtGzcHFNo/inyiqIGFMt89DRo3v27mV9CWPQAVAoFP0zJNCqWQtDeV1MT01x 71qkY1VVlOo7fTU2NvLVLCwRRb9PHjrkcrvFdkNy+epHkUhxxUTX7dtMicqq8jiH aoUAGCTFWiTmhZdeCrS3l/54usQODw8zdaZEXq/X5/MJeeloNPrRe+8JeenFKOZJ JZNVdnE1YBU0uXT1KvdLGC+VShXj4eLfiIdrRLGOi44N8sUDC6pv/TNFvxarVdT2 nAX0qT907BhrOv3qQKfIuKbRF3QBHQkGuV6lBgp9QdVAAAySYi0S89iWLc8899y6 njIyMiJ8BabL5WptbRWy2IwGcO//6U/CY4xkIdapphjYiFXQdXV79+8/ePgw96sI lMvl6OO5OCTOZDJ6bRAFedBvWdX14z8+NmZAaFpl658p+qXYl7WMeSnoA370xAmL 6G7IL1+aKBotXr6DQ0OqrvePFqv6Ql9QTRAAg6RYA4Ompqaz58+v6ymTk5OqThlH K2G32/1+v5BNuTT0pBjY+GzYS+Q3hcbjVRMD01DSZrdzT0DRAOj85cuiqmoJQQFw cck0KQbGSC5tdrpHvxQS3Onq4v700YGnqWo1nbIM2LjxUPUNDRT9iq05bBbpVGoh 6O3p6uJLK1hlN3qguiEABknRVdbhdDLNdmYzmSv//u/resrc3FxYjlubFL23t7cL ufBTHPXhe+8pokdyNA6OUwxcLZk2vF6vAfvoAoHACxLXBDYAxSGpAoTEZqT7ymdy v78/wVz7t66Qv0CSa0flnC6XzWYTHnZaLJbDx4+LzbxlImostrB+revWLaZyX/l5 5lisam70QNXD6QPk1drWxlcF98XTp9vWkzRSVdXJyUmmzqwXvS0UA4sqEfyXTz8N TU8LT/tJw8rqyDZJY0qHw8H9fmaz2d+/+OJGlAlZhN6ThYXTxdiY/lP4On9YbmEH o46ikchwMMg9k5mPChSlOu7WuVyuZtHRL72fdofjQFVv6NAXXSuVXw4/OhSHh4aY XojOnzOhEFPjALpDAAzyYp0Z27J161PPPlv642lkPDIywtSZMogtEfz3L74YHR4W XvhRU9XqiIFZ7/Usdu7SpZpaCL1eNLwuFiJeiIeLX2A7sSj5KmiqmtKv4lGRMYuf 66ooKqDo12a3Cy+J5/H59u7fL7APpkNXydQvG5eGg0G+BVzVtNIBagECYJCX2+22 s20Dbm5uPnPu3LqeEgwGpZodElsi+Pvvvrt39674GFjTqmDTkdvjMeb36HA6Xztz xoAXqjLF5dM/x8O/hMVSnQ2qUn73rKJwvM+9PT05Q359qqpG5ucNeCFWLrfbZrMJ j3797e2P79wpsA+mQwf54utjT3c332upihIx/7UYagcCYJAX7zbg9VcDHh8fj+tX fFIvra2tbkElELs7O2/9+KPwURHFwGYfYjpdLrtRsysdGzc+f+qUAS9U9RZWUKd/ Ufwa08WVo/cwn86b53w7ODBgzJk8XxZVVc2+/tnt8VD0K/xe56YtWx7bvFlgH8xo ScVsvopf2AAMpoMAGKTW1tbWyLY09KVXXqHosfTHz87OzksZaHk8Hp/PJ2SAcr+/ /5uvvhK+K4yGs2avvmBMQeC6wtu1afPm5373OwNeSyoUnYbn5iLz89FoVNM0Ghcm k8l0IWTNkGw2R38WKT6rvGg2V3hmiQ+mT27lMXOxkYWTQH3xq4aGBvqioWED/Wks sFisVmuzzWYnDoec6+Ez6TT9grI8KcqGBgdVRTHmbFkF5X89Xi+dl4RnfHh85872 jRsF9sGM6IQQi0QWzi2qqgYHB5lei06koapY6g+1AwEwSI01KtiybdtTzzxT+uNj sdj09DRTZyrkcDj8fr+QYcrYgwf/+/nnwqti0FiTrsHmvQNtTCqsovxWOo/nD6++ Kjyb60NRdKqpKoVD9Hd+RjCRSBWyN+f35Wazxai1YcOGhsL7Vgw7c4W/KPCgx1MQ RUFtfeE79fX1SBu72EKc//Ob09BA8TBFxfn3qPBG1S9+GP28GEvTu10Ipy30x/qL piZdjiV6ofyNCZ7MzNlstv/uXTqiDPuUmTr9ldPpbLRYjLkrtwb6re3et69lPbeq oYhOldqi2o28G4DNf68Hag1GAyA1qbYBJ5PJBw8eMHWmcvTPCQQCQkKamZmZzz7+ WHh0kShER+aNgWmQR6GEka/49HPPbd6yxchXrCtMRFBUQEMxCg/o6/wivUSCYp5k cTK2kIe5GHQVAi7BN1agRMXfWv6r+mI0XZh23rCBgij6YynOPDc3N9H/bLbl2fvo ufThpYOBaQF5OBweHR428vRI14vZmRnDXk5fFP1a8rc1xCRZXEAH1ROHDrlcLrHd MCklGl1c6Q0bgAEWQwAMUpNqGzCNzILBoMwb/ASWR6Kw88Pr141/3SWSBSaddXG5 3Q622z0rooOZApIjR49u3b69wqboABgOBqcmJmjIRf8QTVXjhTXGqcJvZCE6Kq7J 1aPvYGLFbNt1vyzVpkA5HzE3NDRu2ECnr0QySUcJnfk9Xm/lMdjc7Oz4+HjdovXh xlAUxaT5+YxMSbAGOkIOHztmQI30qpROp9Vf3wvGBmCAxTAQAdm1+f18G9XWWw14 bGwswbM8Ty80aqEYWMi6NQp43n/3Xaade6VLp1LxRMKMMbDT6aTRnpBtmTTWdHs8 HR0dj23Z4g8EFsa+FM3SO0nj+Px0bTRvfn4+EY+n83tms/U/z/YV18ziagL6W1ik XVyu3VCYW87vZC5MLP+y/rqJ/rdw0Oa3PsZikXCY/k6lUkIWxVD4Edc0M4YE+ejX ZmsQvTmCftdHjx+3GLsippqoipJeVDyMtQIwHe0hWXeHAawGQxaQHes24M1btz69 nmrAoVBI/sKzFIr4/X6D5xKL6EJIMTDTFr7SUdhGo0/5f1PLGVYPaQ1L1jggsgX5 yXbQmrT6kcvlarbZhKcGqG9oOHrihPBumFc2m439evUBRb8UAzO9HDYAgxlhZAOy Yw0Jmpqazp4/X/rjI5HIjEm2dbW0tHg8HuNfl0aiH73/vvAJWJOWCBY4CQwAujDp 9K8MxX6JxWo9fOyY8FsYpkaH35Lb0LwbgM15uwdqHE4xIDvW7Ljr3QacSCTGxsY4 esLB5XK1trYKGUn85c9/Dk1NiR3E5EsE04XZbDGwDJPAAFA2M8YDbop+7XbhZ2yH 0/nkoUMC+1AF6G3M3/n99ZoI3g3AZs52DjULATCYAOs24OdPneooucAgBczBYJCp JxxsNltg0ZZOI31148ZwMCh8RBXXNDmrN68Gk8AA5mXG6V+Px0PnHOHnal9Ly+59 +wT2oTokEwk6Ahd/JxqNjg4PM70cNgCDSSEABhNg3Qb86KZNzz3/fOmPHx0dTS3K LSE/q9Xa3t4uJKD65/ff9/X0CF/MRqMBukibaEjKWv0LAPiYqx5MvthvY6PwTMsU /bZ3dGzbsUNsN6pAfj42Gi2mWF8wNDi4uCCwvrABGEwKATCYAOuiUIvF8tbFi6U/ fnp62kShVNGGDRsoBhZS1LGnu/vHH34Qvq/MdCWCW9vahJSzAoCypVKpmVBIdC9K JU+x381btz762GNiu1Ed6AjUliW7utPVxXcb2owL/gHqEACDKUi1DXh+fn52dpaj J6wEpoYeGhz8+u9/Fx4D58vRJhJmiYFdLped7ZgHAN3lcjm1UCxMdEdKQtEvnWGE n5YzmczO3bv97e1iu1E1lFgsk04v+SY2AAMsh9EVmAPrNuBnf/vbTZs3l/hgTdMm JiaYesLN5/N5vV7jX3difPx//vIX4YOt/Pa8eNwsV2vWlf8AoC8TrQXNF/u124Wf kCn63ffkk3SiE9uNqkGhr7LsDu98ODz24AHTK2IDMJgXAmAwB9ZgoKOj4/kXXyzx wabLg7WEqNTQNDT85MMPhU9pmqhEsNPptNntKIYJID86sWiqaooFJpIU+6V37OCR Iw6nU2w3qommKMsTlAwODMTjcaZXNNFNH4AlEACDObCmBaKhwPnLl0t//MjISHrZ KiMTaW5uDgQCxg+AVFX94N13c78uz2A8E5UIRjYsAFMwS+4rSYr90kn4yIkTwrcf VxN6S2MrHYHdnZ18v26zHPYAyyEABnNwOp0Op5NvG/DFt98uPSCcmppSluWZMBeL xdLe3m58mqVUKvXen/6UFp1GO18iWNNMkbrD19KCYSKAzBKJxJwZEkO4PR6b6HJH efX1R0+cQKU3fcU1LZlILPkmjW16uruZAuD8BuBYzBSrHgCWE30eBCgZa17cw8eO 7d6zp8QHh8PhOfMv+6GLYiAQsBleAIMuyR++954q+g5CvkRwPD4fDovtxkM5XS6b BOsVAWBF+cXPmiZ/ZgGP19vc3Cw8+qW49/Dx48KnoKsMXc5ikcjy1VWh6enpqSmm FzVXznOAJRAAg2l46frNFq15fb7Tr75a4oNVVZ2cnGTqicHa2tpcLpfxr/vZJ5/Q tVP4aCwRj9NVXPJ72C632263C3+vAGCJfOZnVZV8P0W+3JHF0iQ6ox69V3aH48Dh w2K7UZWSiURc05Z//15fH992LXrFsPR3kAFWgxEVmAaFAaxVfC5dvVriIzOZzPDw MF9PDObxeHw+n/Hx1Zc3bowEg8LjOlOUR2K9+wMA5ZE/BpCk3BFFv96Wlj379ont RlXKL0WORrPZ7PIf8RVAIoqiSH7rB2ANCIDBNFi3AdMl5Oy5c6XHGBQAUxjM0RMh bDZbIBAwfpD0z++/7+vpER4Dy18eiQ5+a1OT1WoV3REA+Jn8984k2UBBl9f2jo5t O3aI7Ua1SqdSK24pSqVS9/r6+IZM2AAMpoYAGMyEdRvwnn37Dh05UuKDJycnVVVl 6okQotJi9fb0/PMf/xA+QSF/eSSKgZttNmSOAZBB/q6ZpskcAEhS7iibzW7etu3R TZvEdqOKUSCaWWmd8/jYGF+NImwABrNDAAxm4vF6+ZI2OZzO186cKfHBc3Nzkq98 KwNFoRQD89VbXs1wMPjlF18Ij4FpoEYjWpmLOtCI1ma3C3+jAGpcvpSaqsp8v8zt djdLUO4ok8ns2ru3ze8X240qRu+wsspx2NfTs+K6aF1omiZ/CkmANSAABjNh3Qac y+UuX7tW4oMVRZliS64olpC0WKHp6c8+/bRB9Fpo+VNDS1LGE6BmyV9IXJKEzxSb PXHwoNvjEduN6qapaiqZXPFH2AAMsAYEwGAmrPk8KPj5w6uvtrS0lPLgdDo9MjLC 0Q0ZuN1ueh8MHj9Fo9GP3nvPyFdcjeSpoZEUGkAUydM+S5Lwua5wm+DQsWPGl9mr KfQmx1Y5FOkoHbp/n+kyQa+rKoq0l0iAUmAIBSbT0trKlwpo89atTz/7bIkPDgaD fOuLhKOBi9/vN3j/WCKReP9Pf5Ihu1gqn91G3vQ2brfbhhgYwFgU/WqqKu0uiXye SIejXoblIbnckZMnjc8oUWsS8Tj9WfFHw0NDykqZsXSRTCZnZ2aYGgcwBsZPYDIe j4eG/kyNU2j95oULJT54fHw8vsq1pzo0Nja2t7cbnHmYot8P3n1XhjdW8tTQWAsN YCTJVz5LkvCZUB+OnDiBUxO3XC4Xi0To7xV/eqeri+8Oqaaq8/PzTI0DGAMBMJiM y+VyOJ1MjdMQ5/K1ayVeNmZnZ6v+GkBvRSAQsLPdcVjNJx9+KMNGXMmHvJJkeQWo epJniZfndlhTc/Oho0dF96ImJBMJOiZX/BFFxd2dnYwbgGMxaT8LACVCAAwm43Q6 bXY735n9N888s3XbtlIeGYvFpqenmbohFZ/P5/F4DF5we+Nvf3swOip8lW9+0aOm RWS90+F0uezICw3AKZVK5TdEyDrid3s8FP3KcKp0e737nnhCbDdqRL4MbzS62ias udnZifFxppfOZDKaqkq7PwigRAiAwXx8LS1NTU1MjfsDgVMvv1zKI5PJ5IMHD5i6 IRuHw9HW1mZwoPXP77/vvXNHhuguHo+nZU2L5XQ6Gy0W44tXAdQCfPZLQZFYx8aN 23bsEN2RWkHHpLr6Ft+B/v5kIsH00olEggJspsYBDIMAGMzH7fHwLcqtr6+/+Pbb pTwyl8sFg8HVduBUH6vVGggEDM5r0tfb+8PNmzLEwMlkPi+WnOPgukJarKbmZiyH BtBLJpNJxOMyp7yyNjUZnKNhRRT9btm+/ZFHHxXdkRqixmLpdHq1n7IWQFJVVdol UQClQwAM5uN0uZxs24ApoH3zwoUSZ5jHxsYSbPdZJUSBKMXABle2GB0ZufG3v8kQ A0ueFqtYAYXGxMIXQwKYGl0FkomEzLXQ5El5RdHvrr17W9vaRHekhmQyGWX1yxBd p+729vJdBehDIe1FEKB0GCeBKbX5/Y2NjUyN73vyyQMHD5byyJmZGWnnB/i0tLR4 PB4jX3F2dvbTDz+UIQam0V5c02T+pcuTDsfsios7/rXE45ev1juyLD6PnrV4tUh9 4Vt1vzRYYkG1tRspo2+wHMW9yWRS2tR3dYXlHs1yfMYpEjtw+DBF46I7Uls0VaVj dLWfToyP8y1Rpug6VBupT6Dq4WIJpuT1+fg2PrlcrlffeKOUR0aj0VAoxNQNmTmd ztbWViNHYKqqfvDuuzIsOKc+xOPxTDot7exQXa2GwbmC/Ff19Q30p2AD/WnMo78t Fkv+q8LflkV+/g+rtfDj/M+sVqsuwWR+rkZRZoyqmUn/fBqh0otmM3nFrzPFv//1 33k5+q/iw7JZ+jqb+5e6QiBdZEy3JSF/6EsnXjqM6donw6+Gjpkjx4/z5eOAFWWz 2diah2hfby99rplena594bk5psYBjCT+HApQBrfbbXc4mBqnIeDla9dKeWQikRgb G2PqhuSM3xKcTqXev36dL7fHulA3kqmU5CvBKAymaE6vWE6In0OyQjRLoexCdErD borwbXZ7/k/hC4fd3mzs4vzV5JcJFGiallx9okZ+hW3vifyhXviK/qIAkaLEzC8x dpZ+QYW5a/rtmPoYo39aOp2WOfStKyx7thb2OIjuSB59II+eOCHDGuxak4jH6c8a D+DdAKwoMi+AAiidWa9YUONoKOBwOJiGXDQeevmPf2xtbS3lkUNDQxx9MAXjtwTT G/7pRx+F5+ZkGG3TiJkGIpKXQ2TdMF+hYnBLv8r83GwhUKcItrm52e5wUJ+p5x6P h+8+l76K6wKKQW9N5QVYQP9qGhzTvz8/QC/cHkoXospMNo/eIJmDZPm3NcpT9JsO derJwSNHpP1tVjF682ORyBoroVRVHbp/n29opCiK5J8UgBLh/AVm1drWxjf9+Njm zc/89relPPLBgwemnuSpnPFVgr/84ouR4WEZhl/ybwlmXSuxtoX1tMX1xhTZ2ux2 6gwN5d0eDx02ZgluV0P/Oor0FoJeGdbnS47epdDUlKaqxRRT+cnkTDFAztYXJvlF fagln9eSZ9MvHeRen2/P/v2iO1Kj6INDp5s1HhAcGlqjPFKF6AM7U5N7vqAqiR9B ApTH4/XyzT3SgP3cxYulPHJ6elrmvaDGoLjG7/cbOT679eOP3Z2dkowIKQZKy7ol mHW3/OIQtzh/W5y89Xg83pYWr9crw4SVvujfS6NArYBCXwS960Wj83QqteKPikvH KTz+ed11Ya21MeGxtDsb85V+GxubJNn0m81ufPTRrdu3i+5IjcpP/0ajuTUT5t3p 6uI7VOikNx8OMzUOYDDxp1SA8rhcLgfb2k660l+6erWU+CoSiRiW4UZmFoslEAgY WZRycGDgm6++kiEGJqlkMpFMSrg2jG+hBH1Gzl++bHBdaFEo6C3O9JISMzbDih66 g3E1mUym984dps+7nFNb+Z0+dnu9HKc4ev937NoV6OgQ3ZHalU6l1p7dpQiZAmC+ a6KS3ygg3TUOoDwIgMGsnE6n3eHgO9cfO3GCrvcPfRgNi8fHx5n6YC719fV+v99h 4LrWqcnJv372WYMEcyN1hQEiHQxS5dGhz4jD6WSaEKBGL169ytGyJOgXujDTm06n RXenSqSSSU1Vy3tu9+3bDTxrCvKbG/P7gCVaxOFyu5ubmyVZQ0Gfhf0HDni8XtEd qWlKNJpZM73zTChE10SmV89msxR+S/UZAaiEFANHgPL4Wlr4ajB4fb7Tr7760IfR VSEYDDL1wYw8he2dhi3Yo+vxh9evG/NaDyVbhSQaQ/Pdjyi9WpiJ/LwKtyC1ykpd qES+LlS5k0h3e3oybNPviqJIcvdKqlpHdYUPxeFjxyRJsV6z0um0+rDLyr2+Pr5b dYlEgq+8MIDxpDi9ApTH7fHY7Xa+9i+VNsE1OjqKsfJiTU1NgUCgsbHRmJdLp1If vPtuQppUZMkCGZZDe71evmHrzt27jx4/ztS4kYq5rIpBb20mcDYSvdvR+fnynvtg dDRS7nMfKq5pYQn2N+ZrHRWI7sjPGurrj5w8KclEdC1TYrHMw4Jb3gJIqsr36QMw HgJgMDHWEi80UHv97NlSthlPTU0pbHkXTcr4Ckl//vjj2ZkZSeZMJFkOzZop/Q9/ /KOvpYWpcW7IZSVQLBrNrrmSczWaqg4NDurenyIZtgFLteyZPhQ2u/3gkSOiOwIl rZtIJpP9d+/yXQHlLxUGsC5SDBYBytbm9/PNNO7YufPYyZMPfVg4HJ6TMoOocAZX SPrmq6/4SiCul/Ds0KwbgLPZ7JV33uFomdXCtl6y9m464ENxbKrc9Rp8c1xitwFL le25rvButLS17dqzR3RHIG+N3OkLHoyM8JXyogtZaHqaqXEAIaQ41QKUjbXKC7V8 5ty5hz5MVdVJtswTZmez2fx+v2FzGne6u3/64QdJUkPXFaaVEomEkBvnrBuAS68T JhzF6gsrnGu8ZLckHlrLdA2sVV5EbQN2ulx0npRk4reu8JF5bMuWTZs3i+4I5NGv I1bCYdnT3c3XB2nrhAGUDQEwmBvrKL/Eaa5MJjM8PMzUhypAA7tAIMB3n2KJ0ZGR L/7nf6QaTSbicTpIDJ5cYr031N7R8fsXX2RqXBcU62KFs5xKSeezmvv9/Xz7tI0f 5efzXW3Y0NTcLM89OzpT7d63r7WtTXRH4Gclrphg3QAsT4o4AL0gAAZzY13nSZ5+ 7rnNW7Y89GEUAGNF5dpaWlrcbrcxC/zmw+FPPvzQgBcqnfGZsfyBAN946DfPPLN1 2zamxsuWzWaLQa+qqvg8SquSPFhzs7MTbGXn6JiZnppianw52fJd1RU+QQePHLEb WMoO1lbi9G94bm58bIypDxIWCQOoHAJgML2W1la+MQRFEadefvmhD5uYmNDKXdRX O4xcDp1KpT6UKTV03S8ldoxJpOlyuUrJ31Ye+odcvnZNns2Kiyd7RXcHSkJj+mxZ BY3o132nq4tvvlTJJ/ox4i6V2+Nplmnit66Q8PnwiROGZe+HUsQ1LVnCkoeB/v5S HlYeOsHOzswwNQ4gihQjGIBKeLxevmzDNMq/+PbbD33Y7OzsPCoElICiX4qBDcsO /ZdPPw1NT0sSqhUZMxXMWgCpccOGc5cvMzVeouJkr6qqSGdlRpqilF067k5nZz1b 3GhAMSQJJ35zuZzd6Txw6JDojsCvlL5WgnX9M51j5yWoEAagL4nGhQDlYZ3soivQ 2XPnHhpLKIoyZeDaObPzFhgTl37/3Xd3+/qkmmnh3hXsdDrzOXXYZnI6OjqeF7QB mKImtQCTvaZGx3+i3N/g4MAA328/k07TcJ/vgynbjt+6wuko0NHx+M6dojsCS9Fx nizhUKez4r2+PsbkcEYtiwAwEgJgML38cN9u57v9uWvPniPHjq39GLoCjY6OMnWg KjU3N/s5S1gtdr+//9uvv5Zq0FlXOGaSiQTHwII1Mxx5+tlnN2/dytf+ErlcjgaC xbg3nU4b9rrAp5I8WKzbHevY8v24XK5mmVI9F2UyGQp92zduFN0RWKr06d+x0VG+ BWj50nGqig3AUH0QAEM18Pl8TWwJbym6fuPNN9d+DF2rgsEgks2uC0WkFAPb7XYD XmsmFPrsk0+kWgtdV9y/mkik0ml9V0T7Wlqampp0bHCxbCZz+Z13DHgni4ucKRqh v8vbLwrSqiQPVn4bcGdnA1skmUgk5mZndWzQ6XJZGhutTU2ynX8otnny0CGX2y26 I7CCRKF6WymP7Llzp45t7JGIx+dQAAmqkVynY4DyuN1uvsSVNOK/8u///tCHjY2N 8dXnqGL0u/P5fAZMz9Jv54Pr19Pl7jzko++KaBptOxwOvqE2dwVgeh9UVS3GvXyv AsLFotFsuZu3WasB53PeKoou96TkXPP8s/r6I8ePWywW0f2AFazrDlHXrVt8G17o XBxBASSoRgiAoRpwF0N67vnnH920ae3HhEIh7JMpDw3CAoGAAVlhaFTx2SefzM7M yDYVU1dYFJpMJPJFLyoLg1nTX5Et27Y99cwzujdL/3yKOrC5t3aUWN10RcPBoMK5 JrPyVFh0SaKgl0Jf2dY81xVOgza7/cDhwxKeBqGIrgXx0u4ARubnH7Btv0IBJKhi OP1BlWhta+O7mR1ob3/hpZfWfgxFvxQDM3Wg6tFQrKWlxeVyGTAm++Hmzb7eXhnn ZIobg5PJsrcgOl0uu93O90+j8dC/vfGGjmsmi3EvweqJWkPHeVxVy3tuIh4f6O/n O1dks1lVVcueBKYPiNVqlXNylf5p7R0d25HySmLrmv6939/Pd/Kk69EMRjVQpRAA Q5XgLYbU0HDxypW1H0MXoTHO1Cy1wLBCwcNDQ19+8QXfNsIKpQpxcBmzwVu2buWN JOvrL5VQFeyhMplMMe7FfG/NymYylSwz7urs3MB5D6uMrY/FWV+LrKFvXeE937ln T1sgILojsJZ13Rti/SCgABJUMQTAUCXYiyGdP9+8Zp4tCleCwSBTB2oHRb9tbW0G ZMaKRiIff/CBzHnL0uk0hcGl7w12ud30vrFOoZeyFGIN9G6rhYSiarlTf1BNovPz ZX8AWSe+6n45Vktci1Hc60uhrzFp7cuTzeUOHTliMyTpIJSNDrxYJFLi54KuEXd7 e1EACaAMCIChSnAXQ9q9d+/ho0fXfszo6GhKvhxLZuRyuVpaWrhXKVNs+emHH0Yi EZn3wuUzRSeTNNDJrTkh7HS5bMxFVqgnL50+3eb3l/FcilUKW8liyOcMC1RFKTsp naIowcFB1k9uvgCMpq0xTU0XnfqGBgp6rVar5OcQ6uGhY8fk3PcBi6WSSa3k+4Pj Dx5UuFl9DSiABNVN3lM2wHqxVn8ppRjS1NQUDcuYOlBraFjp9/vXnnXXxXdffz3Q 3y//0JBCx1QqRYOS/NLoXw/KXW43Rb/c/wQaRl++dm1dT6GuKoUkosly0x1BFSs9 08+Kum7f5t4uQR+3eDy+ZB7Y6XLRZy0/5WuxmOK80RYI7Ny9W3RHoCTrWhbRe+cO 3yIm3euBAUgFATBUD7fHw7d0loYRV955Z+3HhMNhVMzTl8fj8fl83LMrQ4ODX924 IWG+1tXQ0UhD88bGRhp/p9NpY3resXHj86dOlfhgingp7o3FYjIvMgex8lvBK1hg OTgwYMwecvqIFVcu0ImIPmvyB70L6B2m0Nff3i66I1CSdU3/1jHfA1JVNVJusW4A +SEAhurBXQzp2d/9btNjj63xALpgTE5OMr16zbJYLH6/n29uv4hCtY8/+KDswqRV j+LYV19/3e3xPPRhmqZR6IsqvlCKSrYBU/R7nzMXtNnR23royBHWomigr2gkkit5 k8h8ODz24AFTT1AACaoerhxQVViLIfkDgVMvv7zGA9Lp9MjICNOr1zhvAetgN5vN fvbJJ3OzsxhSL7dhw4bzly+v8YB86Y4ojd8i2AYPpaukGjDp7uw00XysYYqVfp88 dAhvjomkUyl1PVuoBvr7kyiABFAujPOgqvAWQ6qvv/iwGjDBYBBpfpgYMxXceetW 508/SVshSZS9+/cfPHx4xR8VQ99wOJzB/Dms03rXfC4xPjYWxq6TX8tmMo9u3rx5 61bRHYH1iUUi6xo8sK5/RgEkqHoIgKGqcBdDOvPWW2uXkRgfH0dpU1YG7AoOhUJ/ /fRTvvZNh4Zll69dW/6eI/SFCuWy2RJLDa389Fyuu7PTRLv3udFH9YmDB11ut+iO wPqk02l1PeuNU6nUvb4+FEACKBsCYKgqTqfT7nDwrfvauXv30ePH13jAzMxMpILx HJTCYrG0tbWxJoim4cifP/pI8gpJhlmx/K+qqrOzs1jwDBWioXYmnS776dwFgc0i X+uoqengkSO4HWBGFG6uKwPFg9FRvgxV2WxWVRRsAIbqhrEdVBvWYkgUdJ05d26N B0Sj0RB2zhjCgFrBP/7wQ093d43vo6PBEB3zi/OrJ5PJmZkZrHQAXSTi8UQFx1Iq lbrb24sP6cZHHtn6+OOiOwLloNB3jXLTK6ILE1Nn6lAACWoDAmCoNmKLIdGVY2xs jOnVYYkNGza0trY6HA6+lwiFQp9/+mktV/LxeL2v/Nu/Fb+m4z8cDs+jNgbop4zR /xJ3+/oqmUM2u1w2ux/Lns2sjEUQKIAEUCEEwFBtuIshPfXMM1u2bVvtp7lcbmho iOmlYUU2m43CYL7s37WcHZr+7a+dOVMcW2uaFgqF0jUcaQATJRqtZBt5Ih7vv3ev BieBke25CtA5NrbObVN0MZoYH2fqDwogQY2oufEc1ALWYkjU+EunT6/xgNHRUWyM NBiFpl6v1+Px8MWofT09P9y8WWvZoektfeW112iINjc3h83twCSZSMQrKxx9r7c3 XWOZ2LKZzJbt2x/ZtEl0R6AiqqKk1zlg6L93r5LiYWtDASSoEQiAoQqxFkMil65e XeOnU1NTynqq+YFeGhsbW1tb+RbAq6r6548+qp2MOxT3nj13jmL+6elp3NMBPvl0 4pUtuaTjs6+np3byPzU0NBw4coS7JhxwKy8LOgogAVQOATBUIe5iSP925gy9xGoP CIfDcyhNKQ4FwC0tLXxLAL7/7rt80p0aGGpv2rz5wKFDMzMzojsC1U9T1QontYKD g2oFJYXNIpvJBDZufHznTtEdAR2UcdgnEomBe/dQAAmgQgiAoQo5nU6b3c53i3Tr 9u2/efrp1X5Kg7DJyUmml4YSeTwer9fLtDUuPDf3l08/re7it7lc7vcvvaRVtjAV oET0aVIqG3bXRE3gXO6JQ4f4bu+Ckcpb+DAyPFxh0rg10MeQYnJsAIZagAAYqhNr MSSL1frWhQur/TSVSo2OjjK9NJSOol+fz+dyuZhuln/z1VeDAwNVmX6GRmZ79u3z trSI7gjUkAoLAtcVVt+MjY5WZbK6bDbb6vfv2rNHdEdAN5qmpda/oeZOVxffEY4C SFA7qvA6AUDcbredrToOjUUuXb26WuRDwUMwGKS/mV4d1qWxsbGlpYWpVNLs7Oz/ /PnP1Zd9hz47Tx46JLoXUFvS6bRa8dQTa34ggfYfOOBcfd8NmE5507/0LAqA+e66 qoqCZIdQIxAAQ3XiLoZ0+OjR3Xv3rvbTsbGx2kmVZApNTU0+n48pNVp+V3BfX9VM BWdzuZNPP101/xwwEQqAK6yzlc1m73R3b6iWozeTybRjx281SsTj9Ge9z5qemgpN T3P0pw4FkKDGIACGqpWvDWu1MjXudrv/+Prrq/10enoaVxEJNTc3UxhMf+veMo0b /vrZZ6qimH35JQ24Dxw54sQmQxCh8p3AdYXEQgP9/WbfDEzRSKPF8sTBgxznKxCr 7LTnd3t7+XJPpJJJpDyE2mHusRrAGliLIeWy2cvvvLPaT+fn52exkUZWdFR4vV6O YeXAvXs3v/3WvDEwDcu2bNu28dFHRXcEaldc05IVL58JTU9PTU6a95NIQc72HTs6 HnlEdEeARdmFr7tu3drQ2Kh7f4pQAAlqilkvDwAPxV0M6aVXXmlra1vxp3QhmZiY YHpp0AVTGJzNZr+6cWMkGDRdnSQ6pFtaW3etvrAfwAD5dZjRKH2OKmxnOBiMRaOm i4GzmYy3tXX33r3Yg1DFovPzZWQJURQlODiIAkgAujDZtQFgXfyBAN9CuEceffS3 v//9ij9Kp9MjIyNMrws6ampq8hZWCug7qqCRxN8+/zwaiZhl/E2jMY/Xu/eJJ0R3 BECfhdBk6P59VVVN9Bm0NjXte/JJrHmubqlkUiurYPXg/fvlzRuXgj5001NTTI0D SMgcFwaA8nh5NnwWUWh9/vLl1X4aDAYrn8QAY1gsFo/H43A49J11GR8b++rGjVQq JfkQnEbeLrd7/4EDojsC8LOyg4Ql7vf3x+Nx+T+A1MNde/f6UHisBsQikfLGBt2d nXzrAuhjEp6bY2ocQEJSXxUAKsRdDOncpUvWVfJsIRG06dDYwuWiSNDdqOsmq4F7 976/eVPaslj5uV+fb+/+/aI7AvAr5aXJXW5ocFDm7HTZXG7b9u3Y7lsjyq71lUmn e3t6UAAJQC+SXhIAdMFdDInChoOHD6/4o1AohO00JmW32ykS1ndddHdnZ+etW3q1 ppdsNvvYli2bNm8W3RGAFeiSEItMTU5OT03JtquWPn300aMPoOiOgHGUaLS8NM7j Y2N8M7QogAQ1CAEwVLmW1tbVJmkrZ7Pb33jzzRV/hETQZtfY2OgssFgserVJYXBX Z2c2k5FhPoq6sffJJ70+n+iOAKxKrxg4Go0G79/ny6BbuuJikEcp9MWNpxqTzWZj 5c6y9t65w7eMKJlMzqIAEtQY8YMwAFYej4fCVKbG6Xp2ZZViSEgEXTWamprySwkc Dr0Sqg0ODPz4ww+JREJUGEwDKfpQPHHwoNlrpUItKLtmzBKZTOb+wEAqmRT4uWvY sGHrtm2Bjg4hHQCx1FgsnU6X99yu27f5Tteaqs6XVZcYwLwQAEOVc7pcTrZiSOTp 557bvNIaNiSCrj52u53CYPpbl7WUs7OzN7/5ZnZmxuCVmdlsdtfeva2rVPACkFA6 laIxui4zYPPh8MjwsMG3fuhDZ7Pbd+zaRdcjI18X5FHJ9G94bm58bEzf/iyWX/2M HVtQYxAAQ/Vr8/v1TWu0WKvf/9If/rDij5AIulrZbDSazav8uKIxfXdn593e3ng8 zh0J09G48ZFHtmzfLsMCbIB1oaOXYuBMuRNoi9GHbmJsbGZmhjsMpj5vaGykD92m zZvxoatxlSzm7793L5VM6tufBel0OjQ9zdQ4gLRwRobqx1oMiVy6enXF7yMRdNWz Wq22gqampgrDV1VRbv3004ORkWQyqW8knCt49LHHNm/dqmOzAAajw5jCAB1LoU6M j9PQnz5u+kanFPdSm77W1i3bttGZQceWwaTo0I1WsMaYdf0zCiBBbUIADNXP5XY7 2Ioh0YXt386cca20sG16ehppFWsHjXQpEm5ubqaouJLBSiqVutPVla/dQgdPfX3Z Q/P8etFczu3xbN62DQsvoWpQeEkxcDqV0qtBVVUnx8fzpZIqiITzN5myWUtTU5vf v2nzZr41R2BGldT0SiQSA/fu8a0gUBQligJIUHsQAEP1czqddoeDb33ptu3bTz79 9PLvh8PhOdxYrUk0/G36hcViKTse1lR1oL//wehoNBpNJZM0wm5YvanCCDz/AArC vV5voKODrwg2gFgUAFMYrO8eE2pwbnY2GovlP2u53Nozw9lMJldXt6GxkT5uvpaW jo0brZjshZXkp38pwix3B/vI8DDfBl36BKmKgjv1UIMQAENNoAEK31I0i9X61oUL y7+fn1iYnGR6UTARGklbrVZLQeMvyouKKSSeCYUSiUQqnaYYgFDLLpfL4XJRg7jh ArUjvyI6lUpoGlN5mEwmQx+0ZCKPvm6gD1hDHp3wXW63zWajj3O9ZLWFQUIVpjG/ 09XFN/1Lx/Yc6jVCTUIADDXB7fHYOYshXXz77eXxDA3ORkdHmV4UzI7GNBsKaEhd /IK+U5x0Kn6x8LCFpxQH+rlV0PGm6bc9EsAUihuDE/E4V5XUX39OGwqfU5YXgioV jURy5S5VoNFFT3c33/o1VVUjKIAENQnncagJ+TquTiffwOXg4cN79+9f8k0akA0N DTG9IgAAFOXX/2cyyWQynU6XHWyQ+oaf/TzdWwh3EfFC2dKplKooZT99anJyJhTS sT+L0acmv/oZ65+hJuG0DrWita3NYrEwNe5yuV59443l3x8dHU3pl6wFAADWVtwM T+j/irmpigsn8n/98pj6JQpBL2Jd0F0sGs1mMmU/va+nh6+YIg1O+KJrAMnhXA+1 wuP12mw2psZpnHXl2rXl35+cnFRVlelFAQAAQE6ZdFqpbH6VtQCSpmnz4TBT4wCS QwAMtSKfKMjp5Gv/+VOnOjZuXPLN2dnZeWywAQAAqDEU/VIMXPbTo9Ho6PCwjv1Z groXZcsvDSA5BMBQQ/yBAN/N1PaOjt+/+OKSb9LVJYQlRgAAALUkm8lUWL7ofn9/ IpHQqz9LZDKZ6akppsYB5IcAGGqI1+drbm5mary+vv7i228v+WY8Hh8fH2d6RQAA AJCQpigVZgBhXf9Mg5MwyuZBDUMADDXE7XbbHQ6mxnO53BtvvbWk2FImkxnmXMIE AAAAUslls9FIpJIWKHi+19fHl5VNVZRIZT0EMDUEwFBDnE4nBcB8JfUe37nz+MmT S74ZDAb5sjgCAACAVOKalqxs9fLoyEiFIfQaaExCATAKIEEtQwAMtaWltdVqtTI1 bm1qevP8+SXfHBsb49vGAwAAAPLI5XLRipNf3unu5hugJ5PJ2ZkZtuYBTAABMNQW t8ezZJWyjrKZzKVr15bMME9PT+M+KwAAQC2g8DJeWflDCqHvdHY2sG0AVlU1gvoU UNsQAENtcbpcDoeDb1/N4WPHdu/Zs/g74XB4DqkmAAAAakB0fp4i2EpaCE1P86Vo pr4pilJhhmoAs0MADDWnta3NYrEwNe52u//4+uuLv0NXmikUGwAAAKh26VRKVZQK G7nb25vJZHTpz3KpVGoG1Rmh5iEAhprj8XptNhtT47lc7vK1a4u/k0gkxsbGmF4O AAAAJBGLRrMVx66sBZA0TZsPh5kaBzALBMBQc1wul8PpZGqcAuBTL78caG9f+E42 mw0Gg0wvBwAAADLIZDJKxUuLY7HY8NAQ30YtJUZBOtY/Q61DAAw1x+l02ux2vtur HRs3Pn/q1OLvDA8P8y1nAgAAAOFURUmnUhU2MjgwEI/HdenPcjQU0VQViTkBEABD LfL5fE3NzUyNNzQ0XLhyZfF3UAkJAACgimWz2ZgelXu7OzuX1JLQUSIeR1ZOgDoE wFCb3G633eFgajyXy509d6550TZjVEICAACoYnFNS1Z8pzuVSt3r6+Nb/6wqSkSP KB3A7BAAQy1yOp0Op5PvGrNz9+6jx48v/Ofc3FwYOScAAACqUS6Xi+pRWffB6Chf hd58AaRYDLfjAeoQAEPNamlttVqtTI03NTWdPX9+4T/pejM9Pc30WgAAACBQMpGI a1rl7fR0d1feyGqSyeTszAxf+wAmggAYapTH47HZ7UyNZ7PZy9euLcwwoxISAABA VcpP/0Yi9H+Vt9Pd2clYAElV59mmlwHMBQEw1Ciny+VwOPhWQR87cWLHrl3FrzOZ zPDwMNMLAQAAgCipZJJiy8rbmQmFpiYnK29nRfn1z4oSQwEkgAIEwFC72vz+xsZG psY9Hs8rr7228J/BYDCbzTK9FgAAAAgRi0R0ub7f6+1Ns1VMTKfTIWzFAvgFAmCo XV6vd3GuZn3R5fDKO+8s/OeDBw+SySTTawEAAIDxKLBUdUor1XnrFt9N+bimIRkn wAIEwFC7XC6Xw+lkajyXy710+nSb31/8z6mpKUVRmF4LAAAAjKcqSjqVqrwdGiEE Bwf5tmUpsVgU658BfoEAGGqX0+m02+0NbAknNj7yyO9eeKH49ezsLJJPAAAAVI1s JqPXrtqh+/c1PfJIr4j6qaoqCiABLEAADDXN19LS1NTE1HhDQ8OFK1eKX0cikRmU HwAAAKgWcU1LJhK6NNXd2UljBl2aWi6RSMzNzjI1DmBGCIChprndbrvDwdR4Lpc7 e+5ccZuxpmkTExNMLwQAAABGylc/0mlhVyqVutfXx7f+WVWUSCTC1DiAGSEAhprG XQxp5+7dR48frytc3kZHR5leBQAAAIyUIDotWn4wOhph2ySFAkgAyyEAhlrX0tpq tVqZGm9qajp7/nxd4Qo0NDTE9CoAAABgmPz0byRC/6dLaz3d3bq0s6JkMjmLHVgA v4YAGGqdx+Ox2e1MjWcymSvvvFOcYR4ZGUmn00wvBAAAAMZIJZOaqurSFMXS3Z2d G9jycVI/kYMTYAkEwFDrnC6Xk60YEjl6/PjO3bvpi/Hx8Xg8zvdCAAAAYAAlGs1k Mro0FZqenp6a0qWpFcViMax/BlgCATBAXZvfz1d93uPxvPLaa/QFXeNQhAAAAMDU Mum0ot/V/G5vr16x9HLpdJoCbKbGAcwLATBAndfrLeZq5pDLZi+/8w59EQ6H5+bm mF4FAAAADKApSiqV0qu1rlu3NrDdgo9rGo09mBoHMC8EwAB1LrfbwVkM6dTLLwfa 22Ox2DRuxAIAAJhWNpuN6VdSiAYGw0NDfKUoFEWJogASwDIIgAHqnE6n3W5vYEtB 0bFx4/OnTsXj8fHxcaaXAAAAAG5xTUsmEnq1NjgwwJccJJvJqKqKvVcAyyEABsjz tbQ0NTUxNV7f0HDxypV0Oj0yMsL0EgAAAMAqX/1I14zKXZ2dGxoadGxwsUQiMTc7 y9Q4gKkhAAbIc7vdds5V0GfeeqvZZgsGgzmdygYCAACAkZLJZFyn6kcklUrd6+vj W/+sKkoE658BVoIAGCDP6XQ6nE6+69COnTuPnTw5OjqqY+YMAAAAMEwsGs3ql7H5 wcgIX4Cay+WUfAUkrH8GWAECYICftbS2Wq1WpsabrNazFy5MTExomsb0EgAAAMAk nU6rusaTPV1ddWy33ZPJ5OzMDFPjAGaHABjgZx6Px2a3MzWeyWQuX7s2OzsbRT16 AAAAs1EVJa3fGq5cLtfd2bmBLfumpqrzum5XBqgmCIABfuZ0uRwOB98q6MPHjrV3 dKAUMAAAgLnoW/2IhKanp6emdGxwsfz6Z0WJ4YY7wCoQAAP8S1tbW6PFwtS42+3+ 7QsvoBQwAACAuehb/Yjc7e3N6LedeIl0KhUKhZgaB6gCCIAB/sXr9TbbbEyNZ7PZ l155BRkpAAAATCSXy8UiEX2LOHTdvs23/pnC9XA4zNQ4QBVAAAzwLy6Xy+F08rW/ Z/9+j9fL1z4AAADoS9/qR3WFbNIjw8M6NriEEosh4QjAGhAAA/yLy+12sFUDJk3N zYeOHuVrHwAAAPSlb/UjcrevL5NO69jgEoqiRFEBGGB1CIAB/oW7GnA2l3vq2WeZ GgcAAAB9UaSq6L13qauzc0NDg75tLkAFYICHQgAM8Cus1YDpsrT/wAGX283UPgAA AOhIU5SUftWP6grTs8HBQb5b7agADPBQCIABfoV7FbTD6Xzi4EG+9gEAAEAXulc/ Ivf7+xO6JpReAuufAR4KATDAr7Cvgs5mn3ruOabGAQAAQC+JeJz+6Nsma/5nrH8G KAUCYIClWltbLZyroPc+8QRyQQMAAMiMo/oRhabDQ0N8N9lTyeQM1j8DPAwCYICl 3G63nXMVNDX+5KFDfO0DAABAhSiY1HStfkQG7t1LJpP6trmYqigRrH8GeBgEwABL ca+CzuVyv0EuaAAAAIkpsZjuxYrudHWxji6w/hmgFAiAAVbQ2tZmsVj42t+6fXv7 xo187QMAAEDZMpmMEo3q2+bszMzkxIS+bS6WSqVmQiG+9gGqBgJggBVw54L2eL17 9u/nax8AAADKpqlqSu+1ykODg7qvqV4M+Z8BSoQAGGAFTqfTbrc3sOVptFgsR06c YGocAAAAypbL5aLz87o329fTk81mdW+2KJvJqKqK9c8ApUAADLAyr8/X3NzM1Hgm k3n6t79lahwAAADKlkwk4pqme7Odt283st1Yj8fj4bk5psYBqgwCYICVuVwuh9PJ 1Hgulzt07BhfgA0AAADliUWj2UxG3zaTyWT/3bt8GbCUGPVa503LANUKATDAqgLt 7Q0NDVyNd3Rse/xxpsYBAACgDOl0WmVYSDz24MF8OKx7s0XZbHZqcpKpcYDqgwAY YFUtra3W/8/enT05da1vns9UatbemnIAYzDGxmBjYzMlSTJ1VEfURUVXRV3XRdU/ Vxd9XVHVURcV0RVdER1R3dE3JjMhk8nAARJyVEra89RLEsbYB0MOerW3pO8nOHn4 4fN7tBLb2nrY+10rmxUKZwwYAICksQzD87y+x4oOALuuu7O9LRQOjB4KMPC3RPeC VhfCxTt3hMIBAMBBqUtzW2Yj5eV796bEBoDZ/xk4EAow8CnHjh8XmtiJoujK9ety d5gBAMCBOLatfvQ91vO8R2trch8nRI8XBkYPBRj4lJnZ2XQ6LRR+/MSJ02fOCIUD AID9U02y3Wyqr31PXl9fb+zs9D22x/f9rc1NoXBgJFGAgU+pVKuFQkEoPJvLXb52 TSgcAADsn+95pmFIJD9cXQ36va30e5ZlyW2vBYwkCjDwKZqua2KHITEGDABAQqj2 6wtsfzUhPADcbndOQBIKB0YSBRj4jNm5OaHrVhRFVxcWMpmMRDgAANgnue2vfN9/ uLoqNAAcBMHmxoZEMjDCKMDAZ9Tq9VwuJxR+4uTJU6dPC4UDAID9ENr+Snn75o3c GUWO4+yKTRcDo4oCDHxGpVIpFItC4bl8/tLVq0LhAADgs6Io6hwjJLD9lfJwbS3w fYlkxTLNvb09oXBgVFGAgc8QHQOOwvAGY8AAAMRHbvsrZeXevRQDwECSUICBz1Dt t1gsCl29oii6duOG3ElLAADg0+S2vwqCYO3BA6EB4DAITNNUFVgiHBhhFGDg80TH gL88derkV18JhQMAgE+Q2/5K2Xj7dntrSyicAWDgcCjAwOcxBgwAwEiS2/5KebS2 5jMADCQMBRj4PF3XS3KnAQfB4t27QuEAAODviG5/FYbh/eVluROAjc78LwPAwIFR gIHP64wBl0qpVEoinDFgAABiIbr91dbmptwhvapdq5UzAAwcAgUY2Jd6vZ5lDBgA gBGiGqTcGUWr9+9HMveWFddxdhgABg6FAgzsS6VaLRQKQuGpqan5GzeEwgEAwD8T 3f5KWb53T+75Z8uy9hoNoXBgtFGAgX2RHQMOw0VOAwYAYIAcxbKEwqMoerCyInQA 0gQDwMARUICBfZEeA55fXJT7c2IAAPAXrb09uUeUt7e2Nt6+FQpnABg4CgowsF/1 6elsNisUPj07e/bcOaFwAADwId/3TckCufrgQRSGQuGu6+5sbwuFAyOPAgzs1/TM TCaTEQqPoujG7dtC4QAA4EOmYfieJ5fPADCQWBRgYL9q9XpObCPoMIoWKcAAAMjr HP+7tyeaf39pKSVTgHn+GTgiCjCwX+VKpVgsCoWri+WV+Xm5k5YAAECPY9vqh1x+ o9FYf/VKKJznn4EjogAD+6VpWknT5HZ0nJ2b++a774TCAQBAT7vZDMUGdJVnT59a YvtL8/wzcEQUYOAARPfBmpqausZpwAAASAqCwBA+QOj+8rLgAUiG0ZI8vhgYeRRg 4AAqlUpB7ClodUm+efeuUDgAAFAs0/RcV/Ql5HbAiqKoM/7LADBwBBRg4AA0Xdc0 TS7/7Llz07OzcvkAAIwz6e2vlL29vdcvXwqFq+q+zQAwcDQUYOBgZmZm0mKHIamC /ePPPwuFAwAw5lzXtU1T9CV+e/rUFhsAVskNBoCBo6EAAwdTrVbzhYJQeDQxcePW LaFwAADGXLvVCoNA9CUYAAYSjgIMHIyu6yWxp6DDMLx+86bQ4BAAAONMXWTb8u2R AWAg4SjAwMFomlYoFuU66qmvvz7x5ZdC4QAAjC3bNF3h7a+ae3uv5AaAPW97a0so HBgfFGDgwGr1ei6XEwpX7frny5eFwgEAGFuqnU5EkehLMAAMJB8FGDiwcrlcLJWE wqMounH7tlA4AADjyfc80zCkX4UBYCD5KMDAgWmaVtI0oStcGIYLt26lUimJcAAA xpPRagXC219NMAAMDAMKMHAY0zMzGbHDkE5/883xL74QCgcAYNwMZvurvUbj9atX QuEMAAP9QgEGDqNSrRbEDkPiNGAAAPpoANtfKb89eWLbtlC4Sm7s7gqFA2OFAgwc hl4ul8TGgJUFTgMGAKBPWnt7kfD2V8rK0pLcBBMDwEC/UICBw9A0rVgqCV3ngiC4 efeuRDIAAONmMNtfqYJ9f3lZ6INBZwDYMNqtlkQ4MG4owMAh1aens9msUPj3P/5Y qVaFwgEAGB+qN4by21/t7uy8WV8XCmcAGOgjCjBwSKJjwLXp6XPffy8UDgDAmIii qLW3N4AXevL4ses4QuEMAAN9RAEGDkl0DHgqnb62sCAUDgDAmBjM9lcTDAADw4MC DByS7GnAQbDIGDAAAEcwsNu/YRg+WFlhABgYChRg4PCmp6czMmPA6mp36dq1fD4v EQ4AwDjwPM+S3/5K2dzY2NrcFApnABjoLwowcHjVajUvNgY8d/z4mW+/FQoHAGDk DWb7K+XR2prv+0LhtmU1Gg2hcGAMUYCBwxMdA85kMleuXxcKBwBgtIVh2B7U3OzK vXupqSmhcAaAgf6iAAOHJzsGHIaLd+5IJAMAMPIs0/QGsv2V53mP1taEPgx0BoDb HRLhwHiiAANHMjM7m06nJZLVNe/K9etyRw0DADCqBrb9lbL++rXcGUWqw29vbwuF A+OJAgwcSbVWk9uq6viJE6fPnBEKBwBgVLmua5vmYF5rbXVVbtLYsqw9BoCBvqIA A0dSrlSKxaJQeDabvTw/LxQOAMCoajebYRgO5rWWfv1V6FmwCQaAAQEUYOBINF3X NE0onDFgAAAOKvB9Y1BDs7ZlPX3yRG43ENMwGAAG+osCDBzV7NzclMzej5wGDADA QanS6HveYF7r5YsXrVZLKNx13R0GgIF+owADR1Wr13O5nFD47LFj35w9KxQOAMCI GeTpR8qDlRW5cMs09wa1lRcwPijAwFFVKpWC2BjwVDp9bWFBKBwAgBHj2Lb6MbCX W/711ym5AeB2W+72MjC2KMDAUem6XhIbAw6C4Obdu0LhAACMkiiK2s2m+jqYl1Pt 9OWLF0Lh6gOAZZoMAAN9RwEGjkrTtGKxmJIZA1a+//HHSrUqFA4AwMjwPM8yjIG9 3G9Pn9qWJRTuOM7uzo5QODDOKMBAH4iOAZer1R9+/FEoHACAkWG024HvD+zlVpaW UqmUULhpmk0GgAEBFGCgD0THgJWFW7fkwgEAGAFhELQHODEbRdH95WW5Atxutwf5 7QDjgwIM9IHoGHAYhqoAy11iAQAYAbZluY4zsJfb3tzc2NgQCvd9f2tzUygcGHMU YKA/5E4DVk6dPn3i5EmhcAAAhl0URa1mc2JQ218pjx4+lDtt2Lbtxu6uUDgw5ijA QH+IjgHn8vlLV68KhQMAMOxcx5Hbj+qjVu7dk9v/0jSM5gBPMwbGCgUY6I9ypVIU GwMOw3Dxzh2hcAAAhl271QqDYGAv53neo7W1yUmRD9JRFBmdCWAOQAJEUICB/tB0 vVQqyV0Lf7lyRXSfLQAAhpTv++Zg6+L669dyjyirdr29tSUUDoACDPTNzMxMOpMR Cq/PzHx3/rxQOAAAw8s0DLlx3I9ae/AgDEOhcNuyGo2GUDgACjDQN9VaLZ/PC4Wn Uqn5xUWhcAAAhpQqou2Bj8su37snt/OlYRgtBoABMRRgoG/0crlUKgmFB0GweOeO 0CPWAAAMKce21Y9BvqJpms+ePhW6Iqs+bxoGA8CAHD5MA32jaVqxVJI7sPfMt9/O HT8uFA4AwNCJoqjdbEYDPP1IefHsmWEYQuGu6+5sbwuFA5igAAP9NT0zkxEbAw6C 4Obdu0LhAAAMHc91LdMc8IuKPv/MCcCANAow0E+VSkVur+Yoiq7duJFOp4XyAQAY Lka7Hfj+IF9Rvdza6qrcRJL6jlqtllA4gAkKMNBfmq5rmiaX/+WpUye/+kouHwCA YREEgTHwrvj82TNT7PlnTgAGBoACDPTZ3LFjcmPAuXz+0tWrQuEAAAwRyzQ91x3w iy4vLU2JXeU5ARgYAAow0Ge1ej2XywmFh2G4eOeOUDgAAMMiiqLW3t7gX3dlaUnu j7kty9rjBGBAGAUY6LNyuVwUOwyJMWAAABTXcWzLGvCLep73+OFDufzO088MAAPC KMBAn2maVtI0ue0xGAMGAIy5zqxsqxWG4YBfV3QAWH07G2/fCoUDeI8CDPTfzOys 3E1axoABAGPO9zy5IvoJj9bWfLFNpxkABgaDAgz0X7VWy+fzQuFRGN5gDBgAMMZU +1UdePCvu3LvXkrsBGDLNPfimGoGxg0FGOg/XddLYochRVF0dWEhk8kI5QMAkGRh GLabzcG/ru/7D8VOAO481G0YDAADA0ABBkTUp6ez2axQ+ImTJ0+dPi0UDgBAktmW 5TrO4F/37Zs3O9vbQuEMAAMDQwEGRFQqlUKxKBSey+UuXbsmFA4AQGJFUdRuNtXX wb/0w9XVIAiEwl3XlWvXAD5EAQZEiD4FzWnAAIDx5LmuZZqxvPTyvXtTYgPApmk2 GQAGBoICDIjQNK1YKqVSKYnwKIquXL8u94g1AADJZLRacrdhP8HzvEdra4IDwJ0j gNsS4QD+ggIMSKnX69lcTij8+IkTp8+cEQoHACCBVPU1Ytoman19vbGzIxTOAUjA IFGAASmiY8DZbPby/LxQOAAACWSZpue6sbz02oMHYRgKhXMAEjBIFGBACmPAAAD0 SxRFrfhaougAsNFutzgACRgUCjAgpTMGXCymZK6X6nPA5fn5nNgj1gAAJIrrOLZl xfPSrvv44UOhAeAwCEzTZAAYGBgKMCCoVq/LddRjx49//e23QuEAACRHZ5uoVkvu IeRPW3/1qtFoCIU7jrMrNl0M4J9RgAFBomPAmWz2CmPAAIAx4HueaRhxvfra6moo tvU0A8DAgFGAAUGarmtiY8BBENy8e1coHACA5FDtV3XguF596d69tNgAcOf4IwaA gQGiAAOyZufmhLbNiKLo0tWr+UJBIhwAgIQIw7DdbMb16o7jPHn0SGgAOAiCzY0N iWQAf4cCDMgSHQNW7fqb774TCgcAIAlsy3IdJ65Xf/XyZVPsEWUGgIHBowADssqV SlFsDDidyVy9fl0oHACA2EVR1G421de4FrD64EEktvmWaZpy7RrAR1GAAVmiY8Cc BgwAGG2u69qmGeMCRE8AZgAYGDwKMCBOdAz458uXi6WSRDgAALEzWq1AbAfmz7It 6+mTJwwAA6OEAgyIEx0Dnp6dPXvunFA4AAAxCnzfaLdjXMDLFy9aYndoGQAGYkEB BsSJjgFPTU1du3FDKBwAgBhZpum5bowLeHD//oTY+DEDwEAsKMCAOE4DBgDgoKIw bMV3+lEPA8DA6KEAA4MgNwasXLh4US+XhcIBAIiFY9vqR4wLMA3j+bNnQuEMAANx oQADgyA6Blyt18//8INQOAAAg9c5/ajVkjt/aD9ePHtmGIZQOAPAQFwowMAgiI4B p1Kp+cVFoXAAAAbP8zxLrHzu04OVFblwBoCBuFCAgUFgDBgAgP0z223f9+NdAwPA wEiiAAMDMjM7m06nhcLP/fBDrV4XCgcAYJDCIIi9HLaazZf/+IdQuOr2W5ubQuEA Po0CDAxIrVbL5fNC4eVK5YeffhIKBwBgkGzLch0n3jU8e/rUsiyhcMe2d3d3hcIB fBoFGBgQ0THgicnJhZs3pcIBABiUzvZXzWYkdvruPq0sL6cmpT4nMwAMxIgCDAyI puulUmlS5moaBMHinTtC4QAADIzrurZpxrsGVb9XlpaEBoBVuGEYsT/jDYwtPi4D gyM6Bvztd9/NzM0JhQMAMBiqGYZBEO8aGru7669fC4UzAAzEiwIMDE61VsuLjQFr uv7jzz8LhQMAMACB7xvtdtyrmHj6+LEjNoRs23aDAWAgPhRgYHDK5XKxVJJKj6KF 27elwgEAkGeZpue6ca9iYmVpKZVKCYWbhtFsNoXCAXwWBRgYHE3TSpomNKkbhuHC rVtyF2wAAESpC1k7Ac1QLePByorQ9bQzANw5Ajj+u9zA2KIAAwM1PTOTyWSEwk+f OXP8xAmhcAAARDm2rX7EvYqJ7a2tjbdvhcI9z1P5QuEA9oMCDAyU6BhwoVT6+dIl oXAAAOR0Tj9qtaIwjHshE48fPZJ7DJsBYCB2FGBgoPRyuSQ2BhxG0SJjwACAIeR5 nmUYca+iY/nePaEDkBTDMFoJeMwbGGcUYGCgpMeAr9+8KXfZBgBAiNlu+74f9yom giBYvX+fAWBghFGAgUETHQP+8tSpk199JRQOAICEMAjarVbcq+jYePtWbkaXAWAg CSjAwKBVq9V8oSAUnsvnL129KhQOAIAE27JcsXN3D+Th2logdiNafZuNRkMoHMA+ UYCBQZMdAw7DxTt3hMIBAOi7KIo6Y7FRFPdCOhgABkYeBRgYNNExYPUx4sr8fDaX kwgHAKDvXMexLSvuVXR4nvdobU3uAs0AMJAEFGAgBvXp6Ww2KxR+7Isvvv7mG6Fw AAD6q91qhUEQ9yo61l+/ljujyHXdne1toXAA+0cBBmJQqVYLYmPAmWz2yvy8UDgA AH3k+76ZmJuia6urclXcsqw9BoCBBKAAAzHQdb2kaULhQRDcvHtXKBwAgD6yDMPz vLhX8c7Sr7+m02mhcKPdbiVjp2tgzFGAgRhomlYsleSOGfz5ypVisSgRDgBAv4Rh 2E7MplC2bT99/FhoAFh9p6ZhMAAMJAEFGIiH6Bjw9Ozs2XPnhMIBAOgLx7bVj7hX 8c7LFy/k7tAyAAwkBwUYiEelUimI3aSdmpq6duOGUDgAAEcXRVG71YrCMO6FvPPg /n25o5gs09zb2xMKB3AgFGAgHowBAwDGmed5lmHEvYo/yJ4AzAAwkBgUYCAemqYV ikW5a+0PP/1UrlSEwgEAOCLVCQPfj3sV7xiG8eLZM6HwIAgs02QAGEgICjAQm1q9 nsvlhMKrtdr5CxeEwgEAOArVCY0k3RF9/uyZKXY72nGc3Z0doXAAB0UBBmJTrlTk 9mqeTKWuLy4KhQMAcBS2ZbmOE/cq/nB/ZUXuM7Fpmk0GgIHEoAADsdF0XWMMGAAw ZqIoajWbcjtOHYLoAHC73ZkAFgoHcFAUYCBOs3Nzclfcs+fPT8/MCIUDAHA4ruPY lhX3Kv6wt7f3+uVLofAgCDY3NoTCARwCBRiIU61Wy+XzQuF6uXzh4kWhcAAADqfd aoVBEPcq/vDbkye22HHEjm3v7u4KhQM4BAowECfRMeBoYuLGrVtC4QAAHILv+2bC 9kNeWVpKpVJC4QwAA0lDAQbipOl6qVSanBT5NzEMw4Vbt+Qu6gAAHJRpGL7nxb2K P0RRdH95WehaqcINw2AAGEgUCjAQs5nZ2XQ6LRR++ptvjn/xhVA4AAAHEoZhu9mM exV/sr21tfH2rVC47/tbm5tC4QAOhwIMxKxaq+XFxoCLpdLFS5eEwgEAOBDHth2x advDefzokee6QuG2bTcYAAYShgIMxKxcLquaKhQeRtHi7dtC4QAA7F8URe1mM0rS 6UcTwgcgmYbRTNgdbwAUYCBm0mPA84uLco9YAwCwT57rWqYZ9yr+JAiC1fv3GQAG xgoFGIjf9MxMJpMRCj9x8uSp06eFwgEAI0xVuD7++azRbge+36+0vnj75s3O9rZQ uOd521tbQuEADo0CDMSvWq3mCwWh8Fwud+naNaFwAAD2IwgCI3n3Qh+urgZiJxLb ltVoNITCARwaBRiIn14ul+TGgMNw8c4doXAAwKjq7+1f2zRdsb2mDk10ANgwjBYD wEDyUICB+GmaVtI0oTFg9Qnm0rVrchtNAwDwaepK1KmCCdv+ShXyxw8fyl18jXaH RDiAo6AAA4lQn57OZrNC4bPHjn1z9qxQOAAAn+Y6jm1Zca/ir169fNnc2xMKV+1a broYwFFQgIFEqFSrBbEx4Kl0+trCglA4AACf1m42wzCMexV/tXr/vtyZTJZl7TEA DCQSBRhIBF3XS5omFB4Ewc27d4XCAQD4BN/3zUQ+CSw7ANxut5K36ReACQowkBCa phVLJbmjCH/85RfVsSXCAQD4BNMwfM+LexV/ZZrms6dPhQaAwzBU3zUDwEAyUYCB pKjV67lcTii8Wq+f/+EHoXAAAD5KVcF2IndCfvHsmWEYQuGO4+zu7AiFAzgiCjCQ FJVKpVAsCoVPplLXFxeFwgEA+CjHttWPuFfxEfdXVuQ+BFumuSe2vRaAI6IAA0mh 6brGGDAAYFREUdRuNuU2mjoK0QHgzvFHDAADSUUBBhJkdm5O7np89vz56ZkZoXAA AP7Cc13LNONexUfsNRqvX70SCg+CYHNjQygcwNFRgIEEER0D1nX9ws8/C4UDAPAX Rrsd+H7cq/iI3548scUezGYAGEg4CjCQIOVKpSg2BjwRRQu3b0uFAwDwgSAIjKQ+ BryytCR07MJEd3/pJgPAQIJRgIEE0XS9VCrJncqwcOuW3CUfAID3LNP0XDfuVXyE uho+WFmRO3fQMAwGgIEkowADyTIzO5tOp4XCvzpz5osTJ4TCAQDoUT2wldS7oNub mxtiM7q+729tbgqFA+gLCjCQLNVaLZ/PC4XnC4VfrlwRCgcAoMd1HNuy4l7Fxz16 +ND3PKFw27Ybu7tC4QD6ggIMJEu5XC6WSkLhURjeuHNHKBwAgJ52sxmGYdyr+LiV e/dSYgcumIbRbDaFwgH0BQUYSBbRMeAoiq5ev57JZiXCAQCY6D4GbLbbca/i49Ta Hq6uyl1kGQAGko8CDCTO9MxMJpMRCj9+4sTpM2eEwgEAMA1D7hnjI1p//VruEWXP 87a3toTCAfQLBRhInGq1mi8UhMIz2eyV+XmhcADAmAvDsJ3gZ4DXVlfDIBAKty2r 0WgIhQPoFwowkDh6uVwSGwNWF/7Fu3eFwgEAY86xbfUj7lX8reVff50SO2rBMIxW gss/gB4KMJA4mqYVSyW5Iwp/vnxZbp8tAMDYUpeYdrOpvsa9kI+zLevpkydCA8Bh GJqG0U7q8DOA9yjAQBLVp6ezYltV1Wdmvjt/XigcADC2PNe1TDPuVfytf7x4IbdD leu6O9vbQuEA+ogCDCRRpVotiI0Bp1Kp+cVFoXAAwNgy2u3A9+Nexd96sLIiF25Z 1h4DwMAwoAADSaTreknThMKDILjJGDAAoK/UxcVI9glAy/fuTYmdAKzKfyvZ3z6A HgowkESdMeBiMSV2nT73ww+1el0oHAAwhizT9Fw37lX8rWaz+eof/xAKD4PANE0G gIGhQAEGEkoV1FwuJxSul8sXLl4UCgcAjJsoilp7e3Gv4lN+e/LEFtue2nGc3Z0d oXAA/UUBBhKqXKkUi0Wh8Ghi4satW0LhAIBx4zqObVlxr+JTVpaWhI5XUEzTbCa7 /wN4jwIMJJSm65rYGHAYhgu3bsl9FAAAjI8oioxWS11Z4l7I31IrvL+8LHfVa7fb cvtLA+gvCjCQXDOzs+l0Wij89Jkzx0+cEAoHAIwP3/fNZI+/bm9tbbx9KxSuvv2t zU2hcAB9RwEGkqtaq+XzeaHwQrH48+XLQuEAgPFhGobveXGv4lMeP3zoia3Qtu3G 7q5QOIC+owADyVUul4ulklB4GIaLd+4IhQMAxoS6mrSbzbhX8RmiByCp/t9M/O8A gPcowEByaZpW0rTJSZF/T6Mounr9eiablQgHAIwJx7Ydsd2V+8L3/Yerq3IXU6Mz AZzoJ8ABfIgCDCTa9MxMJpMRCj9+4sTpM2eEwgEAI0/Vv3azqb7GvZBPWV9fb4id UeR53vbWllA4AAkUYCDRqtVqvlAQCs9ks1fm54XCAQAjz3NdyzTjXsVnrK2uhkEg FG5bVqPREAoHIIECDCSaXi6X5MaAg2Dx7l2hcADAyDPa7cD3417FZyz/+uuU2JEK hmG0GAAGhgoFGEg0TdOKpZLQ0YVRFP18+bLcPlsAgBEWBIGR+MNvbct6+uSJ0ABw GIamYTAADAwXCjCQdPXp6azYVlX1mZnvzp8XCgcAjDDLND3XjXsVn/GPFy/aYi3d dd2d7W2hcABCKMBA0lWq1YLYGHAqlZpfXBQKBwCMqiiKWnt7ca/i8x4sL0/I3P5V LMvaYwAYGDYUYCDpdF0vaZpQeBAENxkDBgAckOs4tmXFvYrPEz0B2Gi3W4l/CBzA X1CAgaQTHQNWzp4/Pz0zIxQOABg9ncNvW60wDONeyGfs7e29fvlSKJwBYGBIUYCB IVCr13O5nFC4rusXfv5ZKBwAMHp8z1PdL+5VfN5vT57Yti0U7jjOrtjxwgDkUICB IVCuVIrFolR6FC3cvi0VDgAYOar9qg4c9yo+b2VpSe75KdM0m8MwBQ3gLyjAwBDQ dF0TGwMOw3Dh1i25jwgAgFGirhrtYTj5Vq3zwcqK3NWt3W7L7S8NQA4FGBgOM7Oz 6XRaKPzU6dMnTp4UCgcAjBLbslzHiXsVn7e5sbG1uSkU7vu+XDgAURRgYDhUa7V8 Pi8UnsvnL129KhQOABgZURS1m031Ne6FfN6jtTVVU4XCbdtu7O4KhQMQRQEGhkO5 XC6WSkLhYRgu3rkjFA4AGBme61qmGfcq9kX0ACTTMJrD8Bw4gH9GAQaGg6ZpJU2b nBT5dzaKosvz83IbTQMARoPRagVBEPcqPs/zvEdra3IXzc7xRxyABAwnCjAwNKZn ZjKZjFD43PHjZ779VigcADACVPU1hmTbp9evXu01GkLhql1vb20JhQOQRgEGhka1 Ws0XCkLh6XT66sKCUDgAYARYpum5btyr2JfV+/flBpVty2qItWsA0ijAwNDQy+WS 2BhwEAQ3794VCgcADDvVJ1vDc+yt6ACwYRgtBoCBoUUBBoaGpmnFUknuSMMLFy+q ji0UPni+78sdHAUA48Z1HNuy4l7FvpiG8fzZM6HwMAxVPgPAwPCiAAPDpD49nc1m hcKrtdr5CxeEwgEAw6uz7VOrpbpf3AvZF9V+VUcVCnddd2d7WygcwABQgIFhUqlU CsWiUPjk5OT1mzeFwgEAw8v3PLlK2Xf3l5eF9n+e6A5C7w3Po+AA/hkFGBgmuq6X NE0oPAiCxTt35D40AACGlGq/qgPHvYp9iaJoZWlJcAC43W4NyVbYAD6KT7rAkJmd m5O7rn9z9uzssWNC4QCAYRSGYXt49nza3dl5s74uFB4EwebGhlA4gMGgAANDplav 53I5ofCipl385RehcADAMLIty3WcuFexX08eP5ZbreM4qmALhQMYDAowMGTKlUpR bAw4iqIbt28LhQMAho66LrSbTbkzdftueWlpSuy4BNM0mwwAA0OOAgwMGU3XS6WS 0KRuGIbzi4ucHgQA6PFc1zLNuFexX0EQrN6/L3ReYGcrbMNoMwAMDDkKMDB8ZmZn 5TrqiZMnT50+LRQOABguRqulWmXcq9ivt2/eyJ1R5Pv+1uamUDiAgaEAA8OnWqvl 83mh8Gw2e3l+XigcADBEVPU1huqG58MHDwKxw4pt227s7gqFAxgYCjAwfPRyuVQq CYWrjzs3794VCgcADBHLND3XjXsVB7B0715a7gAkw2gNz27YAP4OBRgYPpqmlTRN aAw4iqKfr1yR22cLADAU1OWgNVQbPtm2/fTxY7mLo9HukAgHMEgUYGAoTU9PZ7JZ qfDZ2bPnzgmFAwCGgqNYVtyrOICXL160xB7Y9lx3W2y6GMAgUYCBoVSpVguFglD4 1NTUtRs3hMIBAMnXueHZaoVi87QSHqysyIVblrXXaMjlAxgYCjAwlHRdL2maULj6 xLN4545QOAAg+XzPMw0j7lUczPK9e1NyA8DtttztZQCDRAEGhpKmacVSSeioQ+W7 77+vT08LhQMAEk61X9WB417FATT39l69fCkUHoah+g1hABgYDRRgYFjV6vVcLicU rpfLFy5eFAoHACSZ6nvtYdvu+LcnT2zbFgp3HGd3Z0coHMCAUYCBYVWuVAT3ao6i hdu3pcIBAAlmW5brOHGv4mBWlpbknooyTbM5VBtiA/gECjAwrDRd1yTHgBdu3ZL7 MAEASKYoitrNpvoa90IOQF2zHqysyF2zOscfMQAMjAoKMDDEZmZn0+m0UPip06dP nDwpFA4ASCbPdS3TjHsVB7O1ubm5sSEU7vu+yhcKBzB4FGBgiFVrtXw+LxSeLxR+ uXJFKBwAkExGqxUEQdyrOJhHa2uqpgqF27bd2N0VCgcweBRgYIiVy+ViqSQUHkbR ImPAADBOVPU1hvBZ3+WlpSm5AWDDaA7blmAAPoECDAwxTdNKmjY5KfIvchRFl+fn 5TaaBgAkjWWanuvGvYqD8Tzv0dqa3KWwc/wRByABI4QCDAy36ZmZTCYjFD53/PiZ b78VCgcAJIoqe60h3Ov49atXe42GULhq19tbW0LhAGJBAQaGW7VazRcKQuHpdPrq woJQOAAgURzFsuJexYGt3r8vt2e1bVkNsXYNIBYUYGC46eVySWwMOAiCm3fvCoUD AJKj86xvqxWGYdwLObDle/empqaEwg3DaDEADIwWCjAw3DRNK5ZKcocf/vDTT+VK RSgcAJAQvueZhhH3Kg5MFdQXz54JhYdhqH5PGAAGRgwFGBh69enpbDYrFF6pVr// 8UehcABAQqimpzpw3Ks4sGe//SZ3arHrujvb20LhAOJCAQaGXqVSKRSLUumTkws3 b0qFAwASIAzD9nA+6LuyvJyS2f95orsn9t4Q7goG4NMowMDQ03Rd0zShcPWpaOHW LblHrAEAsbMty3WcuFdxYFEU3VcFWOwK1Tn+aAhPRQbwaRRgYBTMzs3JbQFy+ptv jn/xhVA4ACBeqka2m025jZTlbG9tbbx9KxQeBMHmxoZQOIAYUYCBUVCr13O5nFB4 oVj8+fJloXAAQLw815UboxX1+NEjtXihcMdxdnd2hMIBxIgCDIyCcqVSFBsDDsNw 8c4doXAAQLyMVisIgrhXcRiiByCZptlkABgYRRRgYBRoul4qlSZlNgKJoujK9ety G00DAOKiqq8xnGOunuc9WluTu/AZhsEAMDCSKMDAiJiZmUlnMkLhx7744utvvhEK BwDExTJNuaeIRa2/ft3Y3RUK9z1va2tLKBxAvCjAwIioVqv5QkEoXFXrq9evC4UD AGIRRVFraJ/yXX3wIApDoXDbshqNhlA4gHhRgIERoZfLpVJJKDwIgpt37wqFAwBi 4TqOanpxr+KQRAeADcNoDefByAA+iwIMjAhN00qaJjcN9eMvv+i6LhEOABi8zphr qxWK3UQVZZrms6dPBQeAO0cAtyXCAcSOAgyMjvr0tNxWVdVa7fyFC0LhAIAB8z3P NIy4V3FIz589k1u867o729tC4QBiRwEGRkelWi2IjQFPTk5ev3lTKBwAMGCqQKoO HPcqDun+8rLQ7V/Fsqw9BoCB0UUBBkaHruslTRMKD4Jg8c4duQ8cAICBCcOwPbQz rlEUrSwtCQ4At9stDkACRhefZYHRoWlaoViU+0xw5uzZuWPHhMIBAANjW5brOHGv 4pB2d3berK8LhQdBYJkmA8DACKMAAyOlVq/ncjmh8GKpdPHSJaFwAMBgRFHUbjbV 17gXckhPHj1yxc4udhxHFWyhcABJQAEGRkq5UikWi0LhYRQt3r4tFA4AGAzPdS3T jHsVhyd6AJJpms2hPRsZwH5QgIGRoul6qVSSOxni6sJCJpORCAcADEa72RzS048U 3/cfrq4KHoBkGG0GgIGRRgEGRs3M7Gw6nRYKP37ixOkzZ4TCAQDSXMexLSvuVRze +vp6Q+wRZdWutzY3hcIBJAQFGBg11Votn88LhWey2Svz80LhAABprb294Z3+VdZW V8MgEAq3bbuxuysUDiAhKMDAqNHL5VKpJBSuPnYs3r0rFA4AEBX4vjHk+xsv//rr lNhTToZhtIb2dCgA+0QBBkaNpmklTZObj/rp0iVN7LRhAICcdqsld/t0ACzT/O3p U8EB4HabA5CAkUcBBkbQ9PR0JpsVCq/V6+d++EEoHAAgRFXfYd/e6cXz53J3sD3X 3d7eFgoHkBwUYGAEVarVQqEgFD6ZSl1fXBQKBwAIsQzD87y4V3Ek91dW5D65Wpa1 12iIxQNICgowMIJ0XS+JPaUcBMHinTtCT6ABACREUdQa8uNt1bewsrQkdwKw0W63 hvwOOYD94CMsMII0TSuWSqlUSij/m+++m52bEwoHAPSdY9vqR9yrOJLdnZ036+tC 4WEYmobBADAwDijAwGiq1eu5XE4ovKRpP/3yi1A4AKC/oihqN5tDffqR8uTxY9dx hMIdx9kVO14YQKJQgIHRVK5UisWiULj6FHXj9m2hcABAf3mua5lm3Ks4quWlpSmx J5tM02wO+SPiAPaJAgyMJk3X5Q4rCsNwfnExLXYSIwCgj9rNpnrfjnsVRxL4/uqD B3KjPZ3jjxgABsYDBRgYWTOzs3Id9Ysvv/zq66+FwgEA/RIEgTH81e7Nmze7YmcU +b6/tbkpFA4gaSjAwMiq1mr5fF4oPJvNXp6fFwoHAPSL2W6rghf3Ko5q7cEDuZvY tm03dneFwgEkDQUYGFnlcrlYKgmFB0Fw8+5doXAAQF+o0thuNuNeRR8s/fqr3DNN pmE0R+J3CcB+UICBkaVpWknThA7sjaKoWq9/f+GCRDgAoC9sy5LbOXlgnv/2m2EY cpezzvFHHIAEjA0KMDDKpqenM9msUHgYRYvsBQ0ASTUapx9NCO//7Lnutth0MYAE ogADo6xSrRYKBaFw9aFq4dYtoT+SBwAckes4tmXFvYqjUteaBysrctcay7L2Gg2h cAAJxCdXYJTpul4SOwxJOfPtt3PHj8vlAwAOp/Nkb6s17KcfKTvb22/fvJHLNzrn Hw39LtkA9o8CDIwyTdOKpZLcwYmZTObK9etC4QCAQ/Nc1zLNuFfRB6L7P6tk0zAY AAbGCgUYGHG1ej2XywmFsxc0ACST0Wqpt+i4V9EHy/fuTU1NCYU7jrO7syMUDiCZ KMDAiCtXKsViUSg8iqIr8/NZsYINADiEwPeNkbir6Xneo7U1uQFg0zSbe3tC4QCS iQIMjDhN1zXJMeCZublvv/tOLh8AcFCmYfieF/cq+uDVP/4hekJv5/gjBoCBMUMB Bkbf3LFjcmPAE1G0wGFIAJAYYRi2JUvjIK0sLcldv9Rv1Mbbt0LhABKLAgyMvnq9 LveUsvoAsXjnjlA4AOCgbMtyHSfuVfSHaAFWv0s7DAAD44cCDIy+crlcLJXk8s9f uFCt1eTyAQD7FEVRa1SGWlut1ssXL+TyTcMQfb4aQDJRgIGxUJ+ezmazQuF6uXzh 4kWhcADA/jm2rX7EvYr++O3JE1vse3Fdd2d7WygcQJJRgIGxUKlWC4WCVDpjwACQ AFEUtVutSOzU3AETff7Zsqy9RkMoHECSUYCBsaDreklsL+gwDK/fvCl3TiMAYD88 17VMM+5V9EcQBKv378sVYKOz/TP7PwPjiAIMjIvZuTm5jvrlqVMnv/pKKBwAsB9G q6V6Y9yr6I+Nt2+3t7aEwtXv0ubGhlA4gISjAAPjolar5fJ5ofBsNnt5fl4oHADw Wb7vm+123Kvom4erq3Jl3rHt3d1doXAACUcBBsaF6F7Q6mPKzbt3hcIBAJ9lGobv eXGvom+W7t1Liz21xP7PwDijAAPjQtO0kqZNTor8Wx9F0c+XL4setgQA+DthGLZH qNHZlvX0yRO5C5bR7pAIB5B8FGBgjEzPzGQyGaHw2vT0ue+/FwoHAHyCaoyu48S9 ir558fy5IVZQPc+Tmy4GkHwUYGCMVKvVvNhhSJOp1PXFRaFwAMDfiaKotbcX9yr6 6f7ystDt34nuHxY0OAAJGGMUYGCM6OVySXIMePHOHbmPLACAj3IUy4p7FX2j+vzK 0pLcsQWGYbRG6HFxAAfFR1VgjGiaViyV5I5VPHP27NyxY0LhAIB/pupiu9WKwjDu hfTN7s7Om/V1ofAwDE3DYAAYGGcUYGC81Or1XC4nFK7a9cVLl4TCAQD/zHNdyzTj XkU/PXn0yHVdoXDHcVTBFgoHMBQowMB4KVcqxWJRKDyMosXbt4XCAQD/zGi15M7L jcXyvXtyzz+bptkcrXlpAAdFAQbGi6brmqYJhUdRdHVhQW6jaQDAhwLfl9stORa+ 7z9cXZXbTqJz/FGrJRQOYChQgIGxMzM7m06nhcKPf/nl6a+/FgoHAHzIMgzP8+Je RT+9WV+Xe0RZteutzU2hcADDggIMjJ1qrZbP54XCM9nslfl5oXAAwHthGLZHbjfj tdXVUOyJbtu2G7u7QuEAhgUFGBg7oochqQ8ui3fvCoUDAN6zLct1nLhX0WfLv/46 JfaMEgcgAZigAANjSNO0kqYJTVhFUXTx0qWS2JgxAGCid/pRs6m+xr2QfrIs67cn T+QuT53jj0ZrZBrAIVCAgXFUn57OZrNC4bXp6XPffy8UDgBQXMexLSvuVfTZi+fP 5fb0cl13Z3tbKBzAEKEAA+OoUq0WCgWh8MlU6vriolA4AKBzM7PVCsMw7oX02f2V FbkPppZl7TUaYvEAhgYFGBhHuq7LPaUcBMFNxoABQIzveaZhxL2K/hM9AdjonH/E AUgAKMDAWNI0rVgqpVIpofxvz52bmZ0VCgeAMWe2277vx72KPmvs7q6/fi0UHoah aRgMAAOYoAADY6tWr+dyOaHwkqb99MsvQuEAMM6CIDBG8U7m08ePHbFNrVWy3PHC AIYLBRgYU+VKpVgsCoVHUXTj9m2hcAAYZ5Zpeq4b9yr6b2VpSe65JNM0m3t7QuEA hgsFGBhTmq5rYmPAYRjOLy6mxc5yBIDxFIXhSJ5kGwTB6v37cgW4c/zRKN42B3AI FGBgfM3Mzsp11BMnT546fVooHADGk2Pb6kfcq+i/t2/eyJ1R5Pv+1uamUDiAoUMB BsZXtVbL5/NC4dls9vL8vFA4AIyhKIrazab6GvdC+u/h6moQBELhtm03dneFwgEM HQowML7K5XKxVBIKD8Lw5p07QuEAMIY817VMM+5ViBA9AMk0jOYoPjcO4HAowMD4 0nS9VCpNToq8D0RR9POVK3L7bAHAuGm3WqHYbdIY2bb99PFjuYuRYRgMAAN4jwIM jLXpmZlMJiMVPjt79tw5oXAAGCu+75sjeoztyxcvWmIF1fO87a0toXAAw4gCDIy1 SrVaKBSEwqempq7duCEUDgBjxTQM3/PiXoWIBysrcuGWZe01GnL5AIYOBRgYa7qu lyQPQ1pkDBgAjky9nbZHd4pVdADY6Jx/xPPPAP5AAQbGmqZpxVJJ7ujF8xcuVGs1 oXAAGBO2ZbmOE/cqRKh2+vLFC6HwMAxNQ1Xg0Xx0HMDhUICBcVer13O5nFC4Xqlc +OknoXAAGAdRFLX29uJehZTfnj5V9V4o3HGc3Z0doXAAQ4oCDIy7cqUiulfzwq1b cuEAMPIc21Y/4l6FlJWlJbmnkEzTbI7unx0AOBwKMDDuNF3XJMeAVQGW+3ADAKMt iqJ2qxWFYdwLEaG+u/vLy3LXiHa7zQFIAP6CAgxgYmZ2Np1OC4V//c03x774Qigc AEab57qWaca9Cik729tv37wRCvd9f2tzUygcwPCiAAOYqNZq+XxeKLxYKl28dEko HABGW7vVCoMg7lVIefLokeu6QuG2bTd2d4XCAQwvCjCAiXK5rGqqUHgYRYu3bwuF A8AI833fHOkdjEUPQDINozm6Z0cBODQKMIDOYUglTZucFHlDCMNwfnFR7hFrABhV qv2qDhz3KqQEQbB6/77QAHAURZ3jj0b6jw8AHA4FGEDH7Nyc3B/Dnzh58tTp00Lh ADCSVD80RnoDp7dv3uxsbwuFq9+9zY0NoXAAQ40CDKCjWq3mCwWh8Fwud+naNaFw ABhJlml6YvOxSfBwdTUQG2+2LavRaAiFAxhqFGAAHXq5XJIbAw7DxTt3hMIBYPSo t832qM+vig4AG4bRGvXfQACHQwEG0CE6BhxF0eX5+VwuJxEOAKPHtizXceJehSDX dR8/fCh30WEAGMDfoQADeGfu2DGhzUg64cePn/n2W6FwABglqr+1m031Ne6FCHr9 6tWe2CPKYRhuvH0rFA5g2FGAAbxTqVYLYmPA6Uzm6vXrQuEAMEpcx7EtK+5VyFp9 8CAKQ6Fwy7Lk2jWAYUcBBvCOruslTRMKZwwYAPajc/u31ZIrhwkhOwDcVr+Fo7yB NoCjoAADeEfTtGKpJHck48VLl+QKNgCMBs91LdOMexWyLMv67ckTucPnTcNgABjA 36EAA/hDvV7Pim1VVZ+Z+e78eaFwABgN7VYrFDscKCH+8eJFW+wOres4Ozs7QuEA RgAFGMAfKpVKoVgUCk+lUvOLi0LhADACfM8zDSPuVYh7sLIiF26Z5t7enlw+gGFH AQbwB9kx4CBYvHtXKBwARoDRbge+H/cqxC3/+utUOi0UzgAwgE+jAAP4k9m5ObmN Sc5fuFCt1YTCAWCoqeprjMHkqmqnL1+8EAoPgmBzY0MoHMBooAAD+JNavZ4TGwMu V6s//PijUDgADDXTMHzPi3sV4p799pvcLl+O4+wyAAzgkyjAAP6kXKkUxcaAJyYn F27elAoHgKEVBIExHg/u3l9eFtr/WTFNs8kAMIBPogAD+BNN1zWxMWD1CW/xzh25 jz4AMKQs0/RcN+5ViIuiaGVpSW7Qpt1uy+0vDWA08DEUwF+JjgF/8913Kl8oHACG URiG7WYz7lUMwu7Ozpv1daFwBoAB7AcFGMBfVWu1fD4vFK5p2o+//CIUDgDDyLYs 13HiXsUgPH382BH7Tm3bbuzuCoUDGBkUYAB/VS6Xi6WSUHg0MXHj1i2hcAAYOuNz +1dZWVpKpVJC4aZhNMfmdxLAoVGAAfyVpmklTROa1FUf9RZu3ZL7AAQAw2V8bv+q 9/8HKytC7/9RFBmdCeDRP0cKwBFRgAF8hOgY8Kmvvz7x5ZdC4QAwRFRtazWb6r/i XsggbG1uys3oMgAMYJ8owAA+QnQMOF8o/HLlilA4AAwRx7bVj7hXMSCP1tZ83xcK ZwAYwD5RgAH8laZpU+l0oVCQCA/DUCVfunZNIhwAhkgURe1mMxqP27/Ko9VV1/OE HoG2LCvwfR6BBvBZFGAAH6GXyyX2wQIASa7j2JYV9yoGR3QHLMMwWuyABWAfKMAA PkLT9UKhIDQGHATB9z/+WJ+elggHgKEwbrd/m3t7z58/T4tdVizLardaEuEARgwF GMBHqAKcyWRyuZxEuPqkMjM3d+777yXCAWAojNvt3xfPn6sOLPTnqo7jeJ5HAQaw HxRgAB/RGQOemioUixLhURRlstmr169LhANA8nXO7Gm1wjCMeyGDs/rgQRgEQgfs WaYZBAEDwAD2gwIM4ONEx4DVx77FO3eEwgEg4TzXVZ0t7lUM1PK9e3Kn6zEADGD/ KMAAPk7X9UKxKLRhSRAE35w9e/zECYlwAEiyMbz9u721tf76tVABVr+Tlmm2eP4Z wP5QgAF8nKbr6XRa6DTgMAgqtdqFixclwgEgycbw9u9vT56YhpGSKcC2bfu+zwAw gH2iAAP4OE3T1IeVoswYsJJKpeYXF4XCASCZOrd/2+0wCOJeyEA9WFmRCzdNM2QA GMC+UYAB/C1d14ulktCeJWEUXb52TegOMwAkk+95pmHEvYqBcl334dralMxATRRF 6veT558B7B8FGMDf0lQBlhwD/vKrr05//bVEOAAkk+pqwZjd/n2zvr61uSk3AGya Js8/A9g/CjCAv6VpWjqTkRoDDsNiqfTLlSsS4QCQQGN4+1d59PCh6zhCf5baGQD2 PJ5/BrB/FGAAn1Iul4tihyFNRNHC7dtS4QCQMEa7Hfh+3KsYtJWlJaH2q5iG0eQA JAAHQQEG8CnShyF9/+OP9elpiXAASBTf983xu1HZ3Nt7/vx5mgOQACQGBRjAp2i6 nu2SCFcFeGZ29twPP0iEA0CiqPbrj9/t3xfPn6sOLDQA7HYxAAzgQCjAAD5FFWD1 waVQKEiER1GUzmSuLSxIhANAcgS+b4zf7V9l9f79MAyFThOwLCsIAgowgAOhAAP4 DL1cLomNAasPRtdv3hS6OQAACWEahu95ca9i0FQ7fbCyIvcObxhGiwFgAAdEAQbw Gbqu5wsFoU8w6uPR6TNnvjx1SiIcAJJAvdEZY3mXcuPtW/VD7vJhWxYDwAAOigIM 4DM0Xc9kMrlcTiI8DEOtXL74yy8S4QCQBON5+1d58vix6qhC2yg6juN5Hs8/Azgo CjCAz9A0LTU1VSwWpV5gcnLh5k2pcACI1dje/lVWlpdTMtO/immaYRBwAjCAg6IA A/g8vVxWBVhoF5MwDC9cvFipViXCASBelmF4Y3n7V1XTZ0+fCj3/HEWRKsAMAAM4 BAowgM8T3QcrCIK548fPnjsnlA8AcQnHeI/ily9eNBoNdsACkDQUYACfJ1qAoyjK ZLNXr19XTfj9qJjQ3WYAGCTLND3XjXsVA6LezN//RL2Zrz54oPq/3Js5BRjA4fAR E8DniRbgie5N4Gq1ms3lMrlcPqf+k09nMul0empqSn2KmuyaoBUDGCojfPv3w64b dgW+7weBavuK73Wogip6xB0FGMDh8GkSGE2apnVaY+qdqa64F/W3oq7eTya7d4HV ilUBzmSzqhUXCoW8+pHPq/+zV4l7/1/qI5f6FtX/LNa1A8DHjcbtX9Vs1btz7423 916t3ntVv3UdR3Xd3lbMqvGqth/+/j4+0f3zyvd/dplMQffutPoW1LejviW1dvbT AsZEct+YAByIarzqE0dK/eh2XVULk/zJ4++8v6vw/uedStz9RjrfVCaT7Z7IlEmn 1a+rX9F0XfXjbNcwfr8ARpWqVe1hvj+p3mN93+8VXdXk1bejLjFB91d81R19v/Mr Xf/8hM4wvht3in0UeaoPd5v8BH0YGF3D9w4F4EO9M4p6jTfJ93iP4sNn7f5Ukbt6 Nxl69yUmu/1f1ePOo9T5fKFQKJZKJU0TOsQYAP7OUNz+VW1WrdO2bad7O9fv1lrV AHtvp+/fWj/8f3lXdn+vuMPYdfej2/E7TZ+TloDRM5pvW8Bo6z3erJqe6nUJf8ZM yF8/kH3ydyD6XWeYuPsnBdnfn6zu1ONSSXXl949VA8DRJeT2r3rf69y/tSxVcTtP LHtep+KqfhuG0f6eUj7Qm+1I6l0+HMfp/bkAZRgYAWP3RgYMNU3Xp1TvzWZTI3qz Nxa9kbaJ7pDbuwetOwU5172DXOw15DH82Afg0GzTdOVv/3b6revaltW5f/v7LdzO w8ndp3knu+9pvHf1kerA6nc5GN29zYAxwdsiMAQ6zzmnUqqYKXyaGbwPG/K73blU Sc7lVE/ulOROTS5mecoaQFe/bv96nte5c2vbqnT1NprqPJIbBL1Nm3q7HHJFGDx1 RXi375f6G80NYWAI8b4JJFrvlm+2u/tx3GvBp7wvyeoz6VRv2+10urdlV+d+cr5D FWU26wJGnm1ZruP83V/tbS71xzPJvR+9cdOud9sZUG4TT/0tc7khDAwh3luBhFLV N62qby7HeOoo+aMn/35IVe+EKtWUe3tcd5+9zvcKs/rFuNcLYF96d2sd9R/Lajeb XvdRZP99pw3D98O0NNsRo/7+uo7jU4OB4cFbMJA4mqZNpdM5qu/Ye7f/aveDc6q3 WU33GOR09/byVPdJ7Ez3gexsNpvpzi2r/3AwMnAUqrd2Drd1HM/t6B770/kSfNBp o+5+SL0524l9bCWFkaf+qVD/zKh/QngoGkg+3q+BBOls75xK5fN5HnjGob3f9Xri /fmc3VtOnS/dx7Pf3XTutuhMt0j3tv5K93RLtfpF/vwFw6VzfI9qqt2za/0e1Vq7 p9n07scGvQHa7qPG0funjbtPZLz/94Uqi6NQ/3DZth0xGwwkG+/yQFJout6dGGUv JcSv1wfena6sftL9xXfNoPe1+xin+s/E78OK76cWU93/6u4Y1vvp5FT3xvW7n0xN /f70d+r9T97/1d5XlamaOD1kuPRGW9V/Bd27o72v4e/e/7zzk24R7f3Kh/+zie5f fv8/7v3j1/n17r3Wzj+T3cN7ev90vqus3X8437dW/plBEnQeH/A8nogGEotLBRA/ bvwCH/V+bPJPh5H++WRS1Xn+clTp+1/v1yImknpXsPeE/ESf1vZ3v40f/nqvZX74 V//yEwAT3AoGko0rFhCz3sRvoVCIeyEAAKBvLMtiKhhIIAowECfVfnt7F8W9EAAA 0Ge93dTowECiUICB2Gi6XiwUUjz2DADAiAqDwLQsRoKB5KAAAzHoDf0WVPtlo10A AEZaGIaWZTESDCQEBRgYNNovAABjhQ4MJAcFGBgo2i8AAGOIDgwkBAUYGBzaLwAA Y4sODCQBBRgYHF3XC8Ui7RcAgPHU6cCm2WJPLCA+FGBgEHr3fvP5/BR7PgMAMMaC ILBtm/vAQFwowMAgaLpeKpUmJ/k3DgCAcRdFkWEYnI0ExIKP44A4TdP0clld7eJe CAAASIQwisx2m5vAwOBRgAFZqv2mpqaKxWLcCwEAAAlimmYYBHRgYMAowIAsXddL mhb3KgAAQOIY7TYbYgEDRgEGBGmaptovo78AAOCfhWFoGgY3gYFB4nM5IEW136mp qcIIPfwc/U79fPJ3cS8KADDi3l961NfRu/pYphnwIDQwQKPz9gEkja7rxaHd+bn3 aSOVSmWzWdXhK9XqjDI7m8vn1XU6DEP11fO8RqOxt7vbajZN03QcR/2S+mvqG55M pYb0GwcAxKJz1VFXkFQqnU7ncjl1AVWX0Wq9ri4+1Vrtw0MEjXb7zfr6xsbGXqNh GobruuqqNLytWH3f6rvgQWhgYIbynQJIvs7Oz7o+FPs+97rulOq6uVxJ09TnjFnl 2DHtgKPLvVbc+2pZ1vbWVmN3t6m6sWE4tu37fu8DiirVQt8IACD51LVAfVWFNpvN 5gsFvVyuVCr16enpmZl8Pn/o2Ha7vfn27ebmprr0qIbsOk4wPK1YNX+DB6GBQRmC NwVg6HR2fk6liqVS3Av5iF7dVR87VNet1etzc3PHT5wY2CbV6qXVBX7j7dvd7e1e N7ZVN+7dN6YbA8CoeNdyU6lMt+WqK065XK7X6zOzs4N8Nso0zTevX29sbOzu7HRa sesmthKrC6L6TaMDAwOQxLcAYNipAlwoFj98XitGvcarPn9MT09/ceLEya++SuaZ TL1uvL25udu9b6w+qdiW1XuwTf1VujEAJM37e7mq5Rby+WK35dZqtenZWS2pG0Cq SvzyxYv116+3t7fVVSY5fbjz8JRpUoCBAUjEv/PAKOnsfZVOFwqFGNfQK72arp88 derbs2cr1WqMi+kL9bFAfVhp7O7u7e2pbmypbuw4vu+/3xAl7gUCwAjqXU3Ue2w6 nc7mcoXuvdxKpVJVLXd6egR2edxrNJ48fvzyH/9ot1qxX03UpS3wfTowII1PjUCf qdp50OnZfultkjl37NgPP/544ssvY1nD4KkarFrx7va2+trqjRw7Tu/WMfUYAD7t fcXt7Xr4bvep7lyu6rjqq6q+ca9xQF6/evVgZWXj7duJ7kkHsaxBtd82u2EBwvhc CPSTar+ZTEZ9gBjw66qyp1764s8/n/n22wG/dMJ1tqre3e1sx7W3pz5XvKvHnhdw 9xjAeHhfcafS6Wz3CqUqrqZp5e6NXPVDXbbiXmOy/PbkydK9e6qIDn76Rl2h1GWL DgyI4pMf0E+6rpcGe/tXVd9arXbr7l31UWaQrzsawu7Gm7s7O6oet1qtzqZcltX5 /OH7YRDQkAEk3x+3cKemMt0DhPKFQu8MIXVdqNXrpVKJbRQOQV0X/u//8T92d3cH /LtndO4BU4ABQXywA/pG07TSALf96JzTOzX1v/yLf3H8iy8G84pjqHc8Y6PRaDWb 6iOJastWryF37yF3SnL3STlKMgAJ78rtxIR6t59Kp3tPGHUGcUulzlF75XK1Wh3e A+eHwpv19f/rv/939W4/sN/kIAwtjkQCJPGOCfRHZ8fLVKo0qKOPOjd+6/V/9a// 9WBeDp+gPp6qVrzXaHT+0L7VskzTtm3Htl3X9X0/6B6A3DsRmqoMYOL3WjvR/RCW SqVUs+1sMZXN5vIdhWJRdVvVbyvVquq6vGkkwX/9L/9ld2dnYLeCDcOIOBIJEMO7 KtAfqgAXB/WYmSpU586fv7awMIDXQh85jqMacrv7rLXqyVavJ3dnkt9X5d6xIhO0 ZWCovO+0E91O+0etzWQ6+0qpWttttsXenVtdH/xWETii/+//+X8erq0N5irPkUiA KD5dAX2g2m9qamow5+uqgnT23LnrN24M4LUQI9/zDMMwle5z173h5N4G170HsP0g CNWPMIy6+11Hv5+WTG0GjqLXY9W/WZO9P4d6V2en0r8/hNzbKrk3alvoTtt2i20p zVZSo+7//Z//8/HDh4PpwOq9X73D04EBCXxOAvpgYLd/1WeySqXyv/3bfyv9QhhS qhfbtt3bzavzJLYqzN07zL1jkz9szkH3bvO78vz7Q9o93HzGkPrwNuxE9yOOqq/v S+zUn3ts72Dbd3doc92nj7ttVv33+Bz8g4P6P/7Tf9rb2xvM5d5kEhiQwUcc4KhU +1UfqAoDuf2rPtv9u3//7wfwQhhzqivb3bvNbverqs2d57S7j2r73Sb9rkV3qQ9q 6td6XfqPXt39ANf9T/eWWvdXOj9RPyYnP2wpE91ff1+5//knGArv/55++JO//E3s /J/dfwDe/RFLt52mJt49NNzrq72m2mutqoh2S2tHr7umu8W1QxXXTGaqOzrb6bHZ bD6X4x4sBuB//4//cTDvTpZpBtwEBgTw8QI4qkHe/v1f/+W/ZM9njA/P8zpPok5O qsoddKej1U/Cbr/qjUxPdIflok7n/lOj7rTwIOjLGtSrb25s/CU/IVRNnJ2bi/q0 NtUw//I+1q2nnf458fteTb1f7PVM9b9WP+lsR59KcZAsxseb9fX/87/9twFc9JkE BoRQgIEj6Uz/plJF+c2fe+f9/qt/82+kXwgAAHzCf/3P/3kw5wObhhGyHTTQbxRg 4Eg0XS8N5AzGKAz/3X/4D9KvAuD/b+/en9u6CgSOS7Ysv5M+aRpooU07LCzQsn2n KcO/sDsDs8Pwz/ELP5QZ9l9gmjTpcyksS7fTpoW2pClNH3Hit+/VHunasiLLtiTr WJLP5zPBXDvulTyTSPebc+45AIf67W9+M9GYHBFV3tiL/vatW7EfCJIigOFIFkMA LyzEfpQ8y5586qkf/uhHsR8IADjUX//yl3fefvsYGnj5dn2P+diPAkkRwNC/+vJX lcrs7GzUR6nVatPT0//xy19GfRQAoHu/f/nl9fX12FPAVldXs60ts6BhgAQw9C8E 8MLiYuxHybPs33/xi+NZZRoA6Mbqysp//e53xzAIfPvWLQEMAySAoU8hfitTUzMz M1EfJc/zhx5++KWf/zzqowAAvbr4hz988vHHsVfDWltb29rc1MAwKAIY+nQ8ux/Z +BcARtYxbAuc53l9KSwBDAMigKFPxzD/Ocuy8xcuPHLuXNRHAQD689HVq5cvXZqM PBHaLGgYIAEMfQr1uxBz/edarRbeUH/5q1/FewgA4Ihe/u1vsyyLOg4c6tdmSDAo Ahj6EdJ3qlqdnp6O9xB5lj13/vy5xx+P9xAAwBFdff/91y9fjroa1vr6+ubGhkFg GAgBDP0IATw7NxdvylOtViuXy//5619HOj8AcET5jt+//HLxxh3pgbIsW11ZEcAw EAIY+hH7BuDwbnrft7714yeemGyYmJiYvFPsxbcAICm1hvwwoUWLg+L7i//2vXff /erGjahvzW4DhkERwNCP2DcAh/fXZ55/fqpa3e8byuVyxzBuDebY61ICwMjqpmbb 9P1Ymxsbb772WtSlsNwGDIPi+hh6FnsH4PCeHfr12RdeOOJ52vK49dPiOHwUyQCM hV5rtjk8ezzeuHIlj7kUlt2AYVBc+0LPFhYXZ2dn4/1Db3jbfuDBBx997LFI52/V GsZ7C1kkAzBwzbHZgwdp23532M/6EB9+8MHnn30WbxZ0/Tbg1VWDwHB0rmuhZwsL C/MLC/GyMLzNP3/hwuhkZ8cwbh1GNt0aIFkdI/bQsh32sx688EO9dulSvAAO51+u T4M2AgxH5ZoVehZ1BaxBzX8+ZsU9yW1V3PrRYDLA6Du0Xfcm7oms2f7EngVtHSwY CBej0LOoK2DljfWfH//+9yOdf7gmGnQyQFRtCxq3Ne0Bnw77iY+3999778Y//xlv ENg6WDAQrjKhNyF9p6ampqOtgJVl2b89+2y8FbbGQnON62Ybtx6Yeg0korVji4Mu s9ao7FCsra399xtvxFsiZH1tbdM6WHBkrh2hNwuLi3OzsxNx3t6Ka50XXnopxslP pBDAHSO5YzYP+8kCiWqbMLzfwd4v6tixc+XixXJDjJPnWbZiHSw4MgEMvYm6Ala4 3AmB/eMnn4xxcia6VowtG14GSi3DsPt9PPhTEZuU/3nnnRCokf7J1TpYMBAu76A3 UVfACpdKj5w7d+bs2UjnpyeHdnIx/tx6rJlhpLS2a1uUdvNp83jYPwdj4/q1ax9d vRrxNmDrYMGRuVaD3kRdASvLsvM/+1mkk3MMinHjAwq57bj1YNjPHUZCrUWzP/d+ 2vF4b8EO+6chRZdfeSXebcDWwYKjc8kFPQjpW5mairRCVTHK8MKFCzFOzogr7yhi uNeDtuNh/zSccLU9SjubwXb83S6bVrJyMly5dKnceFWPcfK1tbUt62DB0bhOgh4s LC7Ozs5G+pfdcOU3v7Dwk5/+NMbJSUfHJG5t471f7O93h/xzJq+1PEst2dnNceun +339AMP7oWEM/PmPf1y+fTvSLOgsy1atgwVH4woGehB7Baxzjz/+rTNnYpwcYmhW 8UA+tp2242P198W2ZtubcAd/Q8dPD/54FM0zxHsIIJ5/Xr9+9f33rYMFI0sAQw+i roDlBmAAOAHi3gZsHSw4GgEMPRDAAMDBBDCMMgEM3QrxO1mpzM7Oxjh5rVabnJh4 5vz5GCcHAI7Nm5cvZ3ke6Yap1dXVbGtLA0PfBDB0KwRwdXq6Wq3GOHme53ffe++/ /PCHMU4OAByb//vrX7/+8stItwFvBOvrAhj6JoChW1GXgM6y7Mmnn56bm4txcgDg 2KysrLzz1lvxLhgsBA1HIYChW1GXgHYDMACcGPFuA7YQNByRAIZuWQELAOiGdbBg ZAlg6MpCY+x3fmEhxslrtVplaurp556LcXIA4Ji99frrW5ubkWaNLd++Ha4cNDD0 RwBDV0IAT01NTc/MxDh5nuePPvbYAw8+GOPkAMAx+/yzzz784INI62Ctr61tbm4K YOiPAIauhACenZuLt6CF+c8AcJLEmwVdXwdrZUUAQ38EMHRlYXFxbm4u0j/lCmAA OGHiBXCe5yshgC0EDX0RwNCVeCtg1RpeeOmlGCcHAIbiysWL5YYYJ7cOFvRNAENX Qv0uRFsBa7JSeeb552OcHAAYijdfey3b2ooVwIERYOiLAIbDhfSdmJiYm5+PcfI8 zx85d+7M2bMxTg4ADMX1a9c+uno10s1TK8vL4frBIDD0QQDD4UIAV4Pp6Rgnz7Ls uRdfjLdbIABw/ML7++uvvhrp/X1jfX1jY0MAQx8EMBzOEtAAQK8sBA0jSADD4RYW F+fn5yPdxpPnuRWwAODkuXLxYqQp0LVabXl52W3A0AcBDIeLNwIc3sBK5fLzL744 8DMDAMP12quvhnf6GP+AbgQY+iaA4XDxRoBDAM/MzDz59NMDPzMAMFzvvPXW2tpa pOsHI8DQHwEMh4u3CXCWZU8+9VSk9aUBgCFaWV5+5+23I90GbCtg6I8AhsNFDWAr YAHASRVvHSwBDP0RwHCIEL/hrWt2bi7GyQUwAJxg8QJ4dWUlXEVoYOiVAIZDhACu TE3NzMwM/My1BktAA8BJdeXixXLDwM+8tra2tbkpgKFXAhgOEQK4Oj1drVYHfuZQ vyGtn37uuYGfGQAYBW+9/nrI1BgBvBGsrwtg6JUAhkPE2wMpz/PFU6d+9MQTAz8z ADAK/vKnP91aWoqxG7CdkKA/AhgOEW8PpBDAZ86efeTcuYGfGQAYBR9dvXr92rUY AWwnJOiPAIZDWAIaAOibhaBhpAhgOIQABgD6JoBhpAhgOEjUPZDyPLcENACcbFcu XowxBbpkJyToiwCGg0TdAyn89XvuwoWBnxkAGB2vX7pUC9fcdkKC0SCA4SAhgKeq 1enp6YGfOQRwOPNTzz478DMDAKPj7Tfe2NzYiBHA6+vr4cwCGHoigOEgUfdAOnX6 9L/+5CcDPzMAMDr+989/Xrp5005IMCIEMBxkYXFxbm4uxptWfQ+kBx985LHHBn5m AGB0fPTBB9c/+yzStcRKCGA7IUEvBDAcJATwwsJCjDNbAhoAEhFxIehAAEMvBDAc RAADAEckgGF0CGDYV0jfiYmJufn5GCfPs+wFAQwACbjyyisTcQJ4ZXk5z3O3AUP3 BDDsq74JcKUyOzs78DPXarXwv+dtAgwACXjt4sX6PkgRFoJeXV3NtrYEMHRPAMO+ om4CPDkx8cz58wM/MwAwat68fDnLc1sBwygQwLCvEMDV6elqtTrwM4cAnpmdffKp pwZ+ZgBg1Lzz9ttrq6sxAngjWF8XwNA9AQz7iroJ8D333ff9H/xg4GcGAEbNe+++ +9WNG7YChlEggGFfUTcBfui73/3Oww8P/MwAwKj59OOPP/n7320FDKNAAMO+7IEE AAyEnZBgRAhg2JcABgAGQgDDiBDA0FnUTYAFMAAkJV4A2woYeiKAobOomwAHL9gE GACSceXixbKtgGEECGDoLN4mwE1FCYeDycnJarU6Mzd36tSps9/5TrxHBACiuvbp p0tLS2srKxsbG1mWha9E6t4mWwFDTwQwdBYCeG5+PsaCjYcKVZzneXjoUODTMzOL i4vfe/TR438aAMAB/vbhh7du3Vpv9Gfxxh01dPdTXwh6eVkAQ5cEMHQ2xADuqLZj cnJyqlqdnp5ePHXq4e99b9jPCwBOuI//9rdbS0vr6+ubjUHd8o5hP69tAhh6Mip/ dWHULCwuzs/Pj87b2352w3hiohLCuFpdPH36u488MuznBQBj5u8ffXTr5s31jY2t ELp5Pmqhu59wDbAcAthC0NCdUf8rDcMSbw+k49EM43II42LQeGbm1KlT337ooWE/ NQAYmn988snS0tL62tpmCN0sq41P6B7ATkjQvTH+qw5RjXsAH6C5+FZ4s68EjTuN tTEAJ0azcrc2N7e2tprvemNduQcQwNC9k/kqAEd3ggP4YMUSXOESYWJyMtRx/W7j 6emQx2fOnh32UwOAbdevXVtq3Je7sb4eEjfPsvD+NaxlqIZOAEP3UnyNgEPVNwGe nJydmxv2ExktrdOqJxqjx1PVavh1+vRpuzcBMFjXPv305s2bmxsb9bnKIXEb/0B7 AqYrx7C6spJlmXWwoBtePqCDY9gE+ESqNa5Oao1pZsUA8lTDqdOnza8GoFV9lnLo 24bmEG64MC2nOop7FLYChu55fYEOQgDXl4AemT2QTpJiinU4mAgm60Ihh1A+fddd 3zaMDHAi/OPTT29+881WI26zLAtx23zlF7cxhHfWZTshQXe8BkEHo7YJcGp251rX h5LrKpVKsQFytZHK9z/wwLCfI0Byvvj885C1GyFqG9vh1odt87w+8ad4uTYzeXhs BQzd8zoFHQjgcdEcTy6mzNUHlcOvSrG49VT4eNfdd997//3DfpoAI+rLL7745uuv Q8oW85BD1NbHahtNWzNmOz4EMHTPKxp0kOwS0Cdbc2C5VGyG0ajlYhp2I5kr4f/u vuee+wQzMLZufPHF1199VR+cbSimH2c747Slna2ANO3JYyFo6JKXP+hAAFNoa+bi yjFkc7kI52JmduPDPffeG34N+/kCJ8RXX34ZfmXFPOPGx/AhRGxWdGzrv+WpWRoE MHTJKyZ0IIA5ouLatD6BsFwu7o4rNeZpTzTmabcOPtcLemoqfHbvffedvuuuYT9x YABufvPNlzdu5Hm+1VgCqnUYdnt6cWN28faLQ2NvuVLxr2zQLwEMXfJSCx0IYEbB 9uBzEdMNxSj0xM49z9tFXWR0UdSVSvjK/Q88cOr06WE+dRhDSzdvfvH556FOs8aW PKFXt5cvLjZ4ay45sDP6WiquoozBMhoEMHTJ6zW0C+kbQmJubm7YTwQGrDmdu9hs s7iE3x6dLtK6uJBvrLy98/8TEztTvovEDl9/4MyZufn5of4opGhlefnz69fDn95G nObFlOCmok+LUs1bJglvTxVu/IFv/mnXq5w8Kysr4W+FdbDgUN4AoF0I4MlKZXZ2 dthPBMZPa3I0M7u8Mw+8iI+iQrYjpNwcyd49aA3vYtJ4+O/OPvTQzMzMcH86mtbW 1q598kmpsfbsdnq2hWit1jy442b6nUkNxR+J1j8kpTs/Aj1ZXV3NtrYEMBzKewy0 CwE8Va1OT08P+4kAPWst8NbZ46Uiq3ZvyG69ObvxobnO2c4NmaWdb1xfX+/2zfKO BzyC7gowPFh4pWr+sKXGbee14sds/uyNg+KHbR4Xt6bvPlpp94ct6U8YT+GVanNj QwDDobzJQTubAAMA48VWwNAlAQztBDAAMF4EMHRJAEM7S0ADAGPHQtDQDQEM7QQw ADB2BDB0QwDDHeyBBACMIzshQTcEMNwhBHClUpmxBxIAMFbWVle37IQEhxHA0K6+ D/DkZLEVaTgoNiYd9pMCALhDrVbLsmx7C+48zwz/Qhdc1sPhQhKXiw5WxQDAsWtr 3Tx8nudyF/rgCh761FbFlcagsSoGAI6i3rY7sat1YeBcrMMgGSsGALpkXBeOn+ty OA679xWXy5WpqfCVcDjsJwUAHJOicvOQu43Kdb8uDIsAhqEptlwqRounpqbCG6Lh YgAYa4283VXMZ9a6MDpcasNoqVdxI4O3h4srlVLjcNjPCwC4w/aI7s7U5SJ9tS6M OAEM42E7jHfuL57cGToe9vMCgBOubUS3GOEVujCmBDCMt9YR43Jxg7Gp1ADQo9ap yzUjunByuUSGE6t5j3ExVlyfTW3xLQDS1j6c6x5dSIwAhhS1tfHk5GSp0cbGjQEY d82x3OJA5QKtXOwCd9idU73Tx/IYgJHSmri1ncQ1YxnohstZoAdFHpd2+7hcbOBk RS4ABmjvEG5QkrjAkQlgYJD2K+SSMWQAGppZ2xq3+hY4Hi5GgeO2sLgYUrg1koPJ SqV4PSo+HfJTBKB3rVORa3eqx22tdvvWrWE/RyB1rjKBEVXv5Ma06t1KLpUq1Wq4 sCoZTwY4Rnc0bThoad1SY7qysgXGhctHYOztDimXWnO5XKlUiouzloIGoFTbX6l4 3TRgC5xQLgeB5LSOLZeaeVwqtc3K1szAWNgvYpsjtMZpAZpc2wF0ZTebS9upXGq5 Y1k5A0fUoWPbIrY4krIAR+ASDSC6tknapZbB5+Jja0OXzNmGcdMhWXfGYEt3fjTB GGC4XF0BjI3FxcVyI6RLOwPRzYNOVd1hjHpoTx1GyUHjqx2a9c6DWu2WcAUYWy6G AJK2HdWlUltXtx6X95R2ad/o9rbCUbXdudpx+LRWKrV/sVS643jnG8UqAK1cqQBw HHZLu9QS26UOvV3aM77d+aD5zXtSnKM4aAS044ho28Ge4/qHluOSLgVgeFwoAJCi xVOndt8CW7K5/Yu12sTkZHnPtw3ZTlXmWdZ8ntu/s+fbii/eWlo61mcIACNpZN7L AQAAICYBDAAAQBIEMAAAAEkQwAAAACRBAAMAAJAEAQwAAEASBDAAAABJEMAAAAAk QQADAACQBAEMAABAEgQwAAAASRDAAAAAJEEAAwAAkAQBDAAAQBIEMAAAAEkQwAAA ACRBAAMAAJAEAQwAAEASBDAAAABJEMAAAAAkQQADAACQBAEMAABAEgQwAAAASRDA AAAAJEEAAwAAkAQBDAAAQBIEMAAAAEkQwAAAACRBAAMAAJAEAQwAAEASBDAAAABJ EMAAAAAkQQADAACQBAEMAABAEgQwAAAASRDAAAAAJEEAAwAAkAQBDAAAQBIEMAAA AEkQwAAAACRBAAMAAJAEAQwAAEASBDAAAABJEMAAAAAkQQADAACQBAEMAABAEgQw AAAASRDAAAAAJEEAAwAAkAQBDAAAQBIEMAAAAEkQwAAAACRBAAMAAJAEAQwAAEAS BDAAAABJEMAAAAAkQQADAACQBAEMAABAEgQwAAAASRDAAAAAJEEAAwAAkAQBDAAA QBIEMAAAAEkQwAAAACRBAAMAAJAEAQwAAEASBDAAAABJEMAAAAAkQQADAACQBAEM AABAEgQwAAAASRDAAAAAJEEAAwAAkAQBDAAAQBIEMAAAAEkQwAAAACRBAAMAAJAE AQwAAEASBDAAAABJEMAAAAAkQQADAACQBAEMAABAEgQwAAAASRDAAAAAJEEAAwAA kAQBDAAAQBIEMAAAAEkQwAAAACRBAAMAAJAEAQwAAEASBDAAAABJEMAAAAAkQQAD AACQBAEMAABAEgQwAAAASRDAAAAAJEEAAwAAkAQBDAAAQBIEMAAAAEkQwAAAACRB AAMAAJAEAQwAAEASBDAAAABJEMAAAAAkQQADAACQBAEMAABAEgQwAAAASRDAAAAA JEEAAwAAkAQBDAAAQBIEMAAAAEkQwAAAACRBAAMAAJAEAQwAAEASBDAAAABJEMAA AAAkQQADAACQBAEMAABAEgQwAAAASRDAAAAAJEEAAwAAkAQBDAAAQBIEMAAAAEkQ wAAAACTh/wHKaXFT997P+gAAAABJRU5ErkJggg=="/></symbol><use xlink:href="#c" width="1280" height="1280"/></g></g></svg>')} diff --git a/public/piece-css/monarchy.external.css b/public/piece-css/monarchy.external.css deleted file mode 100644 index 4f8779b0e84fe..0000000000000 --- a/public/piece-css/monarchy.external.css +++ /dev/null @@ -1,12 +0,0 @@ -.is2d .pawn.white {background-image:url('/assets/piece/monarchy/wP.svg')} -.is2d .knight.white {background-image:url('/assets/piece/monarchy/wN.svg')} -.is2d .bishop.white {background-image:url('/assets/piece/monarchy/wB.svg')} -.is2d .rook.white {background-image:url('/assets/piece/monarchy/wR.svg')} -.is2d .queen.white {background-image:url('/assets/piece/monarchy/wQ.svg')} -.is2d .king.white {background-image:url('/assets/piece/monarchy/wK.svg')} -.is2d .pawn.black {background-image:url('/assets/piece/monarchy/bP.svg')} -.is2d .knight.black {background-image:url('/assets/piece/monarchy/bN.svg')} -.is2d .bishop.black {background-image:url('/assets/piece/monarchy/bB.svg')} -.is2d .rook.black {background-image:url('/assets/piece/monarchy/bR.svg')} -.is2d .queen.black {background-image:url('/assets/piece/monarchy/bQ.svg')} -.is2d .king.black {background-image:url('/assets/piece/monarchy/bK.svg')} diff --git a/public/piece/monarchy/bB.svg b/public/piece/monarchy/bB.svg deleted file mode 100644 index a5ac5db2167c0..0000000000000 --- a/public/piece/monarchy/bB.svg +++ /dev/null @@ -1 +0,0 @@ - \ No newline at end of file diff --git a/public/piece/monarchy/bK.svg b/public/piece/monarchy/bK.svg deleted file mode 100644 index 3f4e68aadf871..0000000000000 --- a/public/piece/monarchy/bK.svg +++ /dev/null @@ -1 +0,0 @@ - \ No newline at end of file diff --git a/public/piece/monarchy/bN.svg b/public/piece/monarchy/bN.svg deleted file mode 100644 index 0213ea8382250..0000000000000 --- a/public/piece/monarchy/bN.svg +++ /dev/null @@ -1 +0,0 @@ - \ No newline at end of file diff --git a/public/piece/monarchy/bP.svg b/public/piece/monarchy/bP.svg deleted file mode 100644 index 854569e647b71..0000000000000 --- a/public/piece/monarchy/bP.svg +++ /dev/null @@ -1 +0,0 @@ - \ No newline at end of file diff --git a/public/piece/monarchy/bQ.svg b/public/piece/monarchy/bQ.svg deleted file mode 100644 index df3811688a7f5..0000000000000 --- a/public/piece/monarchy/bQ.svg +++ /dev/null @@ -1 +0,0 @@ - \ No newline at end of file diff --git a/public/piece/monarchy/bR.svg b/public/piece/monarchy/bR.svg deleted file mode 100644 index 312278e8cfc45..0000000000000 --- a/public/piece/monarchy/bR.svg +++ /dev/null @@ -1 +0,0 @@ - \ No newline at end of file diff --git a/public/piece/monarchy/wB.svg b/public/piece/monarchy/wB.svg deleted file mode 100644 index 671a6f5c8ddaa..0000000000000 --- a/public/piece/monarchy/wB.svg +++ /dev/null @@ -1 +0,0 @@ - \ No newline at end of file diff --git a/public/piece/monarchy/wK.svg b/public/piece/monarchy/wK.svg deleted file mode 100644 index 6ddeb192c48ae..0000000000000 --- a/public/piece/monarchy/wK.svg +++ /dev/null @@ -1 +0,0 @@ - \ No newline at end of file diff --git a/public/piece/monarchy/wN.svg b/public/piece/monarchy/wN.svg deleted file mode 100644 index 7a728d5b4973a..0000000000000 --- a/public/piece/monarchy/wN.svg +++ /dev/null @@ -1 +0,0 @@ - \ No newline at end of file diff --git a/public/piece/monarchy/wP.svg b/public/piece/monarchy/wP.svg deleted file mode 100644 index c0cfccfa8f1b3..0000000000000 --- a/public/piece/monarchy/wP.svg +++ /dev/null @@ -1 +0,0 @@ - \ No newline at end of file diff --git a/public/piece/monarchy/wQ.svg b/public/piece/monarchy/wQ.svg deleted file mode 100644 index e73504e4b8323..0000000000000 --- a/public/piece/monarchy/wQ.svg +++ /dev/null @@ -1 +0,0 @@ - \ No newline at end of file diff --git a/public/piece/monarchy/wR.svg b/public/piece/monarchy/wR.svg deleted file mode 100644 index 5e7a364ff6f56..0000000000000 --- a/public/piece/monarchy/wR.svg +++ /dev/null @@ -1 +0,0 @@ - \ No newline at end of file From 9e667fdeb60ed69d3d8e9768a4b0a014358e634a Mon Sep 17 00:00:00 2001 From: Thibault Duplessis Date: Sun, 16 Jun 2024 15:53:51 +0200 Subject: [PATCH 077/168] ensure settings user ids are normalized --- modules/memo/src/main/SettingStore.scala | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/modules/memo/src/main/SettingStore.scala b/modules/memo/src/main/SettingStore.scala index ec7f80fabdb32..422bca2363fa2 100644 --- a/modules/memo/src/main/SettingStore.scala +++ b/modules/memo/src/main/SettingStore.scala @@ -79,7 +79,7 @@ object SettingStore: given StringReader[Strings] = StringReader.fromIso(using stringsIso) object UserIds: val userIdsIso = Strings.stringsIso.map[lila.core.data.UserIds]( - strs => lila.core.data.UserIds(UserId.from(strs.value)), + strs => lila.core.data.UserIds(UserStr.from(strs.value).map(_.id)), uids => lila.core.data.Strings(UserId.raw(uids.value)) ) given BSONHandler[UserIds] = lila.db.dsl.isoHandler(using userIdsIso) From 9cd7cff84b4a90453176b56b866f455a27819bd9 Mon Sep 17 00:00:00 2001 From: Trevor Fitzgerald Date: Sun, 16 Jun 2024 10:05:30 -0400 Subject: [PATCH 078/168] use const --- ui/bits/src/bits.importer.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ui/bits/src/bits.importer.ts b/ui/bits/src/bits.importer.ts index e9ac93fbe8154..8261015017360 100644 --- a/ui/bits/src/bits.importer.ts +++ b/ui/bits/src/bits.importer.ts @@ -1,4 +1,4 @@ -var $form = $('main.importer form'); +const $form = $('main.importer form'); $form.on('submit', () => setTimeout(() => $form.html(site.spinnerHtml), 50)); From 7a75da2f0f7bd6382473369d5bac5966661031b9 Mon Sep 17 00:00:00 2001 From: Trevor Fitzgerald Date: Sun, 16 Jun 2024 10:06:14 -0400 Subject: [PATCH 079/168] concise username regex --- ui/common/src/richText.ts | 2 +- ui/common/tests/richText.test.ts | 3 ++- 2 files changed, 3 insertions(+), 2 deletions(-) diff --git a/ui/common/src/richText.ts b/ui/common/src/richText.ts index d037c7a11141d..d0f63929f702c 100644 --- a/ui/common/src/richText.ts +++ b/ui/common/src/richText.ts @@ -6,7 +6,7 @@ import { VNode, Hooks } from 'snabbdom'; export const linkRegex = /(^|[\s\n]|<[A-Za-z]*\/?>)((?:(?:https?|ftp):\/\/|lichess\.org)[\-A-Z0-9+\u0026\u2019@#\/%?=()~_|!:,.;]*[\-A-Z0-9+\u0026@#\/%=~()_|])/gi; export const newLineRegex = /\n/g; -export const userPattern = /(^|[^\w@#/])@([a-zA-Z0-9_-]{2,30})/gi; +export const userPattern = /(^|[^\w@#/])@([a-z0-9_-]{2,30})/gi; // looks like it has a @mention or #gameid or a url.tld export const isMoreThanText = (str: string) => /(\n|(@|#|\.)\w{2,}|(board|game) \d)/i.test(str); diff --git a/ui/common/tests/richText.test.ts b/ui/common/tests/richText.test.ts index 1abc3a98c49a8..42ca3618d3706 100644 --- a/ui/common/tests/richText.test.ts +++ b/ui/common/tests/richText.test.ts @@ -1,4 +1,4 @@ -import { describe, expect, test, vi } from 'vitest'; +import { describe, expect, test } from 'vitest'; import { movePattern, userPattern } from '../src/richText'; describe('test regex patterns', () => { @@ -6,6 +6,7 @@ describe('test regex patterns', () => { expect('@foo'.match(userPattern)).toStrictEqual(['@foo']); expect('@foo-'.match(userPattern)).toStrictEqual(['@foo-']); expect('@__foo'.match(userPattern)).toStrictEqual(['@__foo']); + expect('@Foo'.match(userPattern)).toStrictEqual(['@Foo']); }); test.each([ From 846b2a2d1ebadd92d8d32971802760c7c3e9831b Mon Sep 17 00:00:00 2001 From: Trevor Fitzgerald Date: Sun, 16 Jun 2024 12:00:02 -0400 Subject: [PATCH 080/168] remove duplicate css property --- ui/bits/css/_titleRequest.scss | 1 - 1 file changed, 1 deletion(-) diff --git a/ui/bits/css/_titleRequest.scss b/ui/bits/css/_titleRequest.scss index a93532c8c0688..41acc120bf25f 100644 --- a/ui/bits/css/_titleRequest.scss +++ b/ui/bits/css/_titleRequest.scss @@ -3,7 +3,6 @@ gap: $block-gap; grid-template-columns: repeat(auto-fill, minmax(25em, 1fr)); margin-bottom: 2em; - gap: 2em; } .title-image-edit { From 2afdddcd847a227326498f2069c408efb95ffac7 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?S=C3=A9rgio=20Gl=C3=B3rias?= <9739913+SergioGlorias@users.noreply.github.com> Date: Sun, 16 Jun 2024 17:03:52 +0100 Subject: [PATCH 081/168] Reduce california pieces SVG (#15534) * Reduce california pieces SVG * FIX svg need width and height * fix base64 * better no touch in diffrent css --- public/piece-css/california.css | 24 ++++++++++++------------ public/piece/california/bB.svg | 2 +- public/piece/california/bK.svg | 2 +- public/piece/california/bN.svg | 2 +- public/piece/california/bP.svg | 2 +- public/piece/california/bQ.svg | 2 +- public/piece/california/bR.svg | 2 +- public/piece/california/wB.svg | 2 +- public/piece/california/wK.svg | 2 +- public/piece/california/wN.svg | 2 +- public/piece/california/wP.svg | 2 +- public/piece/california/wQ.svg | 2 +- public/piece/california/wR.svg | 2 +- 13 files changed, 24 insertions(+), 24 deletions(-) diff --git a/public/piece-css/california.css b/public/piece-css/california.css index 0cd63bd4ceb0f..598fb2297b1ea 100644 --- a/public/piece-css/california.css +++ b/public/piece-css/california.css @@ -1,12 +1,12 @@ -.is2d .pawn.white {background-image:url('data:image/svg+xml;base64,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')} -.is2d .knight.white {background-image:url('data:image/svg+xml;base64,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')} -.is2d .bishop.white {background-image:url('data:image/svg+xml;base64,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')} -.is2d .rook.white {background-image:url('data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxMDAiIGhlaWdodD0iMTAwIiB2aWV3Qm94PSItNTAgLTEwMCAzODYuODMzIDUwMyI+PGRlZnM+PGNsaXBQYXRoIGlkPSJhIj48cGF0aCBkPSJNMCAwaDI5Ni44MzJ2MzczSDBabTAgMCIvPjwvY2xpcFBhdGg+PC9kZWZzPjxwYXRoIGQ9Ik00OS4zMiAxODIuMzQ4Yy40ODUtNjguNDMtNDMuNTE1LTEyNS4xNjQtMzAuNTYyLTE2Ni4xMWgyNTkuMzJjMTIuOTUzIDQwLjk0Ni0zMS4wNDcgOTcuNjgtMzAuNTYyIDE2Ni4xMS41MDcgNzIuMjAzIDQzLjkxIDEzMi4yMTQgMzAuNTYyIDE3NC40MThIMTguNzU4QzUuNDA2IDMxNC41NjIgNDguODA4IDI1NC41NSA0OS4zMiAxODIuMzQ4IiBzdHlsZT0ic3Ryb2tlOm5vbmU7ZmlsbC1ydWxlOm5vbnplcm87ZmlsbDojY2NjO2ZpbGwtb3BhY2l0eToxIiB0cmFuc2Zvcm09InRyYW5zbGF0ZSgwIC0yMCkiLz48cGF0aCBkPSJNOTIuODYgMThjLTkuNzQzIDU1LjIwMyA2IDEyNS4zMjQgNiAxNzMgMCA0Ni41NDMtMTguMjQ3IDEwMS4wNTUtMTUgMTY2bC02MC4zNC0uMjM0TDQyLjg2IDE5MSAyMy41MiAxNS44MDVabTAgMCIgc3R5bGU9InN0cm9rZTpub25lO2ZpbGwtcnVsZTpub256ZXJvO2ZpbGw6I2ZmZjtmaWxsLW9wYWNpdHk6MSIgdHJhbnNmb3JtPSJ0cmFuc2xhdGUoMCAtMjApIi8+PGcgY2xpcC1wYXRoPSJ1cmwoI2EpIiB0cmFuc2Zvcm09InRyYW5zbGF0ZSgwIC0yMCkiPjxwYXRoIGQ9Ik0yNTEuMjY2IDI4MS43NThjLTkuMjQ2LTI5LjIzLTE5LjcyNy02Mi4zNTYtMTkuOTg5LTk5LjI5My0uMjU0LTM1LjgwOSAxMC40NDYtNjcuNzM1IDE5Ljg4My05NS45MDMgNi45NTMtMjAuNzU3IDEzLjE2NC0zOS4yOTIgMTMuMDY3LTU0LjA5SDMyLjYwNWMtLjA5NyAxNC43OTggNi4xMTQgMzMuMzMzIDEzLjA2NyA1NC4wOSA5LjQzNyAyOC4xNjggMjAuMTM3IDYwLjA5NCAxOS44ODMgOTUuOTAzLS4yNjIgMzYuOTM3LTEwLjc0MyA3MC4wNjYtMTkuOTg5IDk5LjI5My03LjE2IDIyLjY0NC0xMy41NDYgNDIuODI4LTEzLjEwMSA1OC43N0gyNjQuMzdjLjQ0Mi0xNS45NDItNS45NDEtMzYuMTI2LTEzLjEwNS01OC43N00zLjI3NyAzNjEuNjZjLTguNTIzLTI2LjkzNyAxLjEyMS01Ny40MjIgMTEuMzI4LTg5LjY5NSA4LjU1NS0yNy4wNCAxOC4yNS01Ny42ODggMTguNDc3LTg5LjczLjIxOS0zMC4zOTUtOS4xNDUtNTguMzM3LTE4LjItODUuMzU2QzQuNjU3IDY2LjM1NS01LjAwNyAzNy41MjMgMy4yNzggMTEuMzM5QTE2LjIzNCAxNi4yMzQgMCAwIDEgMTguNzU3IDBoMjU5LjMyMWM3LjA3OCAwIDEzLjM0NCA0LjU5IDE1LjQ4IDExLjM0IDguMjgyIDI2LjE4My0xLjM3OCA1NS4wMTUtMTEuNjA5IDg1LjUzOS05LjA1NCAyNy4wMi0xOC40MTQgNTQuOTYtMTguMTk5IDg1LjM1NS4yMjcgMzIuMDQzIDkuOTIyIDYyLjY4OCAxOC40NzcgODkuNzMgMTAuMjEgMzIuMjcgMTkuODUxIDYyLjc1OSAxMS4zMzIgODkuNjk2YTE2LjI0MiAxNi4yNDIgMCAwIDEtMTUuNDggMTEuMzRIMTguNzU3YTE2LjIzNCAxNi4yMzQgMCAwIDEtMTUuNDgtMTEuMzQiIHN0eWxlPSJzdHJva2U6bm9uZTtmaWxsLXJ1bGU6bm9uemVybztmaWxsOiMwMDA7ZmlsbC1vcGFjaXR5OjEiLz48L2c+PHBhdGggZD0iTS0uMDAxLS4wMDF2LTU4LjEzNyIgc3R5bGU9ImZpbGw6bm9uZTtzdHJva2Utd2lkdGg6MzA7c3Ryb2tlLWxpbmVjYXA6YnV0dDtzdHJva2UtbGluZWpvaW46cm91bmQ7c3Ryb2tlOiMwMDA7c3Ryb2tlLW9wYWNpdHk6MTtzdHJva2UtbWl0ZXJsaW1pdDoxMCIgdHJhbnNmb3JtPSJtYXRyaXgoMSAwIDAgLTEgOTguNTgzIDQuNTQyKSIvPjxwYXRoIGQ9Ik0wLS4wMDF2LTU4LjEzNyIgc3R5bGU9ImZpbGw6bm9uZTtzdHJva2Utd2lkdGg6MzA7c3Ryb2tlLWxpbmVjYXA6YnV0dDtzdHJva2UtbGluZWpvaW46cm91bmQ7c3Ryb2tlOiMwMDA7c3Ryb2tlLW9wYWNpdHk6MTtzdHJva2UtbWl0ZXJsaW1pdDoxMCIgdHJhbnNmb3JtPSJtYXRyaXgoMSAwIDAgLTEgMTk4LjI1IDQuNTQyKSIvPjxwYXRoIGQ9Ik0tLjAwMS0uMDAyaDI1MC4xNDQiIHN0eWxlPSJmaWxsOm5vbmU7c3Ryb2tlLXdpZHRoOjMwO3N0cm9rZS1saW5lY2FwOmJ1dHQ7c3Ryb2tlLWxpbmVqb2luOnJvdW5kO3N0cm9rZTojMDAwO3N0cm9rZS1vcGFjaXR5OjE7c3Ryb2tlLW1pdGVybGltaXQ6MTAiIHRyYW5zZm9ybT0ibWF0cml4KDEgMCAwIC0xIDIzLjM0NSAyNzguMjcyKSIvPjxwYXRoIGQ9Ik0wLS4wMDFoMjE1Ljk0NiIgc3R5bGU9ImZpbGw6bm9uZTtzdHJva2Utd2lkdGg6MzA7c3Ryb2tlLWxpbmVjYXA6YnV0dDtzdHJva2UtbGluZWpvaW46cm91bmQ7c3Ryb2tlOiMwMDA7c3Ryb2tlLW9wYWNpdHk6MTtzdHJva2UtbWl0ZXJsaW1pdDoxMCIgdHJhbnNmb3JtPSJtYXRyaXgoMSAwIDAgLTEgNDAuNDQ1IDEyMC44MikiLz48L3N2Zz4=')} -.is2d .queen.white {background-image:url('data:image/svg+xml;base64,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')} -.is2d .king.white {background-image:url('data:image/svg+xml;base64,<svg xmlns="http://www.w3.org/2000/svg" width="100" height="100" viewBox="-50 -60 478.766 511.579"><defs><clipPath id="a"><path d="M44 356h301v75.578H44Zm0 0"/></clipPath><clipPath id="b"><path d="M241 127h147.766v195H241Zm0 0"/></clipPath><clipPath id="c"><path d="M0 0h388.766v431.578H0Zm0 0"/></clipPath><clipPath id="d"><path d="M0 0h388.766v431.578H0Zm0 0"/></clipPath><clipPath id="e"><path d="M0 0h388.766v431.578H0Zm0 0"/></clipPath></defs><path d="M319.383 416.578h-250c-5.524 0-10-4.476-10-10v-25c0-5.52 4.476-10 10-10h250c5.523 0 10 4.48 10 10v25c0 5.524-4.477 10-10 10" style="stroke:none;fill-rule:nonzero;fill:#ccc;fill-opacity:1" transform="translate(0 -20)"/><path d="M95.383 413.578h-36v-45h36Zm0 0" style="stroke:none;fill-rule:nonzero;fill:#fff;fill-opacity:1" transform="translate(0 -20)"/><g clip-path="url(#a)" transform="translate(0 -20)"><path d="M74.383 401.578h240v-15h-240Zm245 30h-250c-13.785 0-25-11.215-25-25v-25c0-13.785 11.215-25 25-25h250c13.785 0 25 11.215 25 25v25c0 13.785-11.215 25-25 25" style="stroke:none;fill-rule:nonzero;fill:#000;fill-opacity:1"/></g><path d="M328.383 371.578h-268c-5.524 0-10-4.476-10-10v-46c0-5.52 4.476-10 10-10h268c5.523 0 10 4.48 10 10v46c0 5.524-4.477 10-10 10" style="stroke:none;fill-rule:nonzero;fill:#ccc;fill-opacity:1" transform="translate(0 -20)"/><path d="M88.383 359.578h-35v-45h35Zm0 0" style="stroke:none;fill-rule:nonzero;fill:#fff;fill-opacity:1" transform="translate(0 -20)"/><path d="M65.383 356.578h258v-36h-258Zm263 30h-268c-13.785 0-25-11.215-25-25v-46c0-13.785 11.215-25 25-25h268c13.785 0 25 11.215 25 25v46c0 13.785-11.215 25-25 25" style="stroke:none;fill-rule:nonzero;fill:#000;fill-opacity:1" transform="translate(0 -20)"/><path d="M0 .002v123.172" style="fill:none;stroke-width:30;stroke-linecap:round;stroke-linejoin:miter;stroke:#000;stroke-opacity:1;stroke-miterlimit:10" transform="matrix(1 0 0 -1 194.383 118.174)"/><path d="M0 0h72" style="fill:none;stroke-width:30;stroke-linecap:round;stroke-linejoin:miter;stroke:#000;stroke-opacity:1;stroke-miterlimit:10" transform="matrix(1 0 0 -1 158.383 31)"/><path d="M207.375 97.875h-24.152c-5.168 0-9.836 3.07-11.887 7.809l-14.984 34.625a12.966 12.966 0 0 0 0 10.285l14.984 34.625a12.947 12.947 0 0 0 11.887 7.804h24.152c5.164 0 9.836-3.066 11.887-7.804l14.98-34.625a12.966 12.966 0 0 0 0-10.285l-14.98-34.625a12.955 12.955 0 0 0-11.887-7.809" style="stroke:none;fill-rule:nonzero;fill:#ccc;fill-opacity:1" transform="translate(0 -20)"/><path d="M184.566 178.023h21.465l14.094-32.574-14.094-32.574h-21.465l-14.097 32.574Zm22.809 30h-24.156a27.934 27.934 0 0 1-25.653-16.851l-14.98-34.621a28.066 28.066 0 0 1 0-22.2l14.98-34.624a27.94 27.94 0 0 1 25.653-16.852h24.156a27.936 27.936 0 0 1 25.652 16.852l14.98 34.625a28.066 28.066 0 0 1 0 22.199l-14.98 34.62a27.93 27.93 0 0 1-25.652 16.852" style="stroke:none;fill-rule:nonzero;fill:#000;fill-opacity:1" transform="translate(0 -20)"/><path d="M315.148 141.594c32.375 0 58.618 24.113 58.618 53.855 0 62.832-48.848 98.735-58.618 107.711-9.77 8.977-58.62 0-58.62 0V195.45c0-29.743 26.245-53.856 58.62-53.856" style="stroke:none;fill-rule:nonzero;fill:#ccc;fill-opacity:1" transform="translate(0 -20)"/><path d="M367.383 148.578c-23 44-67-5-85 144 0 0 11 26.95-7 1s2-74.05 2-100c0-25.95 22-42.129 40-50.777 18-8.649 54 5.777 50 5.777" style="stroke:none;fill-rule:nonzero;fill:#fff;fill-opacity:1" transform="translate(0 -20)"/><g clip-path="url(#b)" transform="translate(0 -20)"><path d="M271.527 290.895c15.063 1.957 29.434 2.464 34.192 1 .84-.743 1.797-1.567 2.86-2.477 13.722-11.793 50.187-43.113 50.187-93.969 0-21.746-19.567-39.437-43.618-39.437-24.054 0-43.62 17.691-43.62 39.437Zm24.164 30.683c-4.425 0-9.343-.234-14.816-.691-14.035-1.172-26.633-3.469-27.164-3.567l-12.184-2.238V195.449c0-37.644 33.028-68.27 73.621-68.27 40.594 0 73.618 30.626 73.618 68.27 0 63.758-45.309 102.676-60.2 115.469-1.273 1.094-2.375 2.039-3.054 2.664-5.926 5.445-15.176 7.996-29.82 7.996" style="stroke:none;fill-rule:nonzero;fill:#000;fill-opacity:1"/></g><path d="M253 137.996c32.375 0 58.621 24.11 58.621 53.856 0 62.832-48.848 98.734-58.621 107.71-9.77 8.973-58.617 0-58.617 0v-107.71c0-29.747 26.246-53.856 58.617-53.856" style="stroke:none;fill-rule:nonzero;fill:#ccc;fill-opacity:1" transform="translate(0 -20)"/><path d="M289.383 148.578c-39 22-56 1-61 154 0 0-8 14.95-26-11s-7-72.05-7-98c0-25.95 22-42.129 40-50.777 18-8.649 54 5.777 54 5.777" style="stroke:none;fill-rule:nonzero;fill:#fff;fill-opacity:1" transform="translate(0 -20)"/><path d="M209.383 287.297c15.058 1.957 29.433 2.465 34.187 1a247.7 247.7 0 0 1 2.86-2.477c13.726-11.789 50.191-43.113 50.191-93.968 0-21.747-19.566-39.442-43.621-39.442-24.05 0-43.617 17.695-43.617 39.442Zm24.164 30.683c-4.43 0-9.348-.234-14.817-.69-14.035-1.173-26.632-3.474-27.164-3.567l-12.183-2.239V191.852c0-37.645 33.023-68.274 73.617-68.274s73.621 30.629 73.621 68.274c0 63.757-45.312 102.68-60.203 115.468-1.273 1.094-2.375 2.04-3.055 2.664-5.922 5.442-15.172 7.996-29.816 7.996" style="stroke:none;fill-rule:nonzero;fill:#000;fill-opacity:1" transform="translate(0 -20)"/><path d="M73.617 141.594c-32.37 0-58.617 24.113-58.617 53.855 0 62.832 48.848 98.735 58.617 107.711 9.77 8.977 58.621 0 58.621 0V195.45c0-29.743-26.246-53.856-58.62-53.856" style="stroke:none;fill-rule:nonzero;fill:#ccc;fill-opacity:1" transform="translate(0 -20)"/><path d="M81.383 139.918c-63 38.66-31 96.11 14 156.66 0 0-23 16.336-41-9.61-18-25.952-45-60.55-45-86.5 0-25.948 18-51.902 36-60.55 18-8.648 36 0 36 0" style="stroke:none;fill-rule:nonzero;fill:#fff;fill-opacity:1" transform="translate(0 -20)"/><path d="M83.047 291.895c4.758 1.464 19.129.957 34.191-1v-95.446c0-21.746-19.57-39.437-43.62-39.437-24.052 0-43.618 17.691-43.618 39.437 0 50.856 36.465 82.176 50.191 93.969 1.059.91 2.016 1.734 2.856 2.477m10.027 29.683c-14.648 0-23.894-2.55-29.82-7.996-.68-.625-1.781-1.57-3.059-2.664C45.31 298.125 0 259.207 0 195.449c0-37.644 33.027-68.27 73.617-68.27 40.594 0 73.621 30.626 73.621 68.27v119.633l-12.183 2.238c-.532.098-13.13 2.395-27.164 3.567-5.473.457-10.391.691-14.817.691" style="stroke:none;fill-rule:nonzero;fill:#000;fill-opacity:1" transform="translate(0 -20)"/><path d="M135.766 137.996c-32.375 0-58.621 24.11-58.621 53.856 0 62.832 48.847 98.734 58.62 107.71 9.77 8.973 58.618 0 58.618 0v-107.71c0-29.747-26.246-53.856-58.617-53.856" style="stroke:none;fill-rule:nonzero;fill:#ccc;fill-opacity:1" transform="translate(0 -20)"/><path d="M152.383 138.578c-36 33.43-30 93.45 15 154 0 0-18 26.223-36 .274-18-25.954-49-70.325-49-96.274 0-25.95 22-42.129 40-50.777 18-8.649 30-7.223 30-7.223" style="stroke:none;fill-rule:nonzero;fill:#fff;fill-opacity:1" transform="translate(0 -20)"/><path d="M145.195 288.297c4.766 1.469 19.14.965 34.188-.992v-95.453c0-21.747-19.567-39.442-43.617-39.442-24.051 0-43.621 17.695-43.621 39.442 0 50.855 36.464 82.18 50.195 93.968 1.058.91 2.012 1.73 2.855 2.477m10.024 29.683c-14.645 0-23.89-2.554-29.82-7.996-.676-.625-1.778-1.57-3.051-2.664-14.891-12.789-60.203-51.71-60.203-115.468 0-37.645 33.027-68.274 73.62-68.274 40.59 0 73.618 30.629 73.618 68.274v119.632l-12.184 2.239c-.527.093-13.125 2.394-27.164 3.566-5.469.457-10.39.691-14.816.691" style="stroke:none;fill-rule:nonzero;fill:#000;fill-opacity:1" transform="translate(0 -20)"/><path d="m104.383 305.578 31.851 69" style="stroke:none;fill-rule:nonzero;fill:#fff;fill-opacity:1" transform="translate(0 -20)"/><g clip-path="url(#c)" transform="translate(0 -20)"><path d="m0 0 31.852-69" style="fill:none;stroke-width:30;stroke-linecap:butt;stroke-linejoin:miter;stroke:#000;stroke-opacity:1;stroke-miterlimit:10" transform="matrix(1 0 0 -1 104.383 305.579)"/></g><path d="m178.707 305.578 31.852 69" style="stroke:none;fill-rule:nonzero;fill:#fff;fill-opacity:1" transform="translate(0 -20)"/><g clip-path="url(#d)" transform="translate(0 -20)"><path d="m0 0 31.852-69" style="fill:none;stroke-width:30;stroke-linecap:butt;stroke-linejoin:miter;stroke:#000;stroke-opacity:1;stroke-miterlimit:10" transform="matrix(1 0 0 -1 178.706 305.579)"/></g><path d="m253.031 305.578 31.852 69" style="stroke:none;fill-rule:nonzero;fill:#fff;fill-opacity:1" transform="translate(0 -20)"/><g clip-path="url(#e)" transform="translate(0 -20)"><path d="m0 0 31.853-69" style="fill:none;stroke-width:30;stroke-linecap:butt;stroke-linejoin:miter;stroke:#000;stroke-opacity:1;stroke-miterlimit:10" transform="matrix(1 0 0 -1 253.03 305.579)"/></g></svg>')} -.is2d .pawn.black {background-image:url('data:image/svg+xml;base64,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')} -.is2d .knight.black {background-image:url('data:image/svg+xml;base64,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')} -.is2d .bishop.black {background-image:url('data:image/svg+xml;base64,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')} -.is2d .rook.black {background-image:url('data:image/svg+xml;base64,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')} -.is2d .queen.black {background-image:url('data:image/svg+xml;base64,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')} -.is2d .king.black {background-image:url('data:image/svg+xml;base64,<svg xmlns="http://www.w3.org/2000/svg" width="100" height="100" viewBox="-50 -60 478.766 521.579"><defs><clipPath id="a"><path d="M44 356h301v75.578H44Zm0 0"/></clipPath><clipPath id="b"><path d="M241 127h147.766v195H241Zm0 0"/></clipPath><clipPath id="c"><path d="M0 0h388.766v431.578H0Zm0 0"/></clipPath><clipPath id="d"><path d="M0 0h388.766v431.578H0Zm0 0"/></clipPath><clipPath id="e"><path d="M0 0h388.766v431.578H0Zm0 0"/></clipPath></defs><path d="M319.383 416.578h-250c-5.524 0-10-4.476-10-10v-25c0-5.52 4.476-10 10-10h250c5.523 0 10 4.48 10 10v25c0 5.524-4.477 10-10 10" style="stroke:none;fill-rule:nonzero;fill:#4d4d4d;fill-opacity:1" transform="translate(0 -20)"/><path d="M95.383 413.578h-36v-45h36Zm0 0" style="stroke:none;fill-rule:nonzero;fill:gray;fill-opacity:1" transform="translate(0 -20)"/><g clip-path="url(#a)" transform="translate(0 -20)"><path d="M74.383 401.578h240v-15h-240Zm245 30h-250c-13.785 0-25-11.215-25-25v-25c0-13.785 11.215-25 25-25h250c13.785 0 25 11.215 25 25v25c0 13.785-11.215 25-25 25" style="stroke:none;fill-rule:nonzero;fill:#000;fill-opacity:1"/></g><path d="M328.383 371.578h-268c-5.524 0-10-4.476-10-10v-46c0-5.52 4.476-10 10-10h268c5.523 0 10 4.48 10 10v46c0 5.524-4.477 10-10 10" style="stroke:none;fill-rule:nonzero;fill:#4d4d4d;fill-opacity:1" transform="translate(0 -20)"/><path d="M88.383 359.578h-35v-45h35Zm0 0" style="stroke:none;fill-rule:nonzero;fill:gray;fill-opacity:1" transform="translate(0 -20)"/><path d="M65.383 356.578h258v-36h-258Zm263 30h-268c-13.785 0-25-11.215-25-25v-46c0-13.785 11.215-25 25-25h268c13.785 0 25 11.215 25 25v46c0 13.785-11.215 25-25 25" style="stroke:none;fill-rule:nonzero;fill:#000;fill-opacity:1" transform="translate(0 -20)"/><path d="M0 .002v123.172" style="fill:none;stroke-width:30;stroke-linecap:round;stroke-linejoin:miter;stroke:#000;stroke-opacity:1;stroke-miterlimit:10" transform="matrix(1 0 0 -1 194.383 118.174)"/><path d="M0 0h72" style="fill:none;stroke-width:30;stroke-linecap:round;stroke-linejoin:miter;stroke:#000;stroke-opacity:1;stroke-miterlimit:10" transform="matrix(1 0 0 -1 158.383 31)"/><path d="M207.375 97.875h-24.152c-5.168 0-9.836 3.07-11.887 7.809l-14.984 34.625a12.966 12.966 0 0 0 0 10.285l14.984 34.625a12.947 12.947 0 0 0 11.887 7.804h24.152c5.164 0 9.836-3.066 11.887-7.804l14.98-34.625a12.966 12.966 0 0 0 0-10.285l-14.98-34.625a12.955 12.955 0 0 0-11.887-7.809" style="stroke:none;fill-rule:nonzero;fill:#666;fill-opacity:1" transform="translate(0 -20)"/><path d="M184.566 178.023h21.465l14.094-32.574-14.094-32.574h-21.465l-14.097 32.574Zm22.809 30h-24.156a27.934 27.934 0 0 1-25.653-16.851l-14.98-34.621a28.066 28.066 0 0 1 0-22.2l14.98-34.624a27.94 27.94 0 0 1 25.653-16.852h24.156a27.936 27.936 0 0 1 25.652 16.852l14.98 34.625a28.066 28.066 0 0 1 0 22.199l-14.98 34.62a27.93 27.93 0 0 1-25.652 16.852" style="stroke:none;fill-rule:nonzero;fill:#000;fill-opacity:1" transform="translate(0 -20)"/><path d="M315.148 141.594c32.375 0 58.618 24.113 58.618 53.855 0 62.832-48.848 98.735-58.618 107.711-9.77 8.977-58.62 0-58.62 0V195.45c0-29.743 26.245-53.856 58.62-53.856" style="stroke:none;fill-rule:nonzero;fill:#4d4d4d;fill-opacity:1" transform="translate(0 -20)"/><path d="M367.383 148.578c-23 44-67-5-85 144 0 0 11 26.95-7 1s2-74.05 2-100c0-25.95 22-42.129 40-50.777 18-8.649 54 5.777 50 5.777" style="stroke:none;fill-rule:nonzero;fill:gray;fill-opacity:1" transform="translate(0 -20)"/><g clip-path="url(#b)" transform="translate(0 -20)"><path d="M271.527 290.895c15.063 1.957 29.434 2.464 34.192 1 .84-.743 1.797-1.567 2.86-2.477 13.722-11.793 50.187-43.113 50.187-93.969 0-21.746-19.567-39.437-43.618-39.437-24.054 0-43.62 17.691-43.62 39.437Zm24.164 30.683c-4.425 0-9.343-.234-14.816-.691-14.035-1.172-26.633-3.469-27.164-3.567l-12.184-2.238V195.449c0-37.644 33.028-68.27 73.621-68.27 40.594 0 73.618 30.626 73.618 68.27 0 63.758-45.309 102.676-60.2 115.469-1.273 1.094-2.375 2.039-3.054 2.664-5.926 5.445-15.176 7.996-29.82 7.996" style="stroke:none;fill-rule:nonzero;fill:#000;fill-opacity:1"/></g><path d="M253 137.996c32.375 0 58.621 24.11 58.621 53.856 0 62.832-48.848 98.734-58.621 107.71-9.77 8.973-58.617 0-58.617 0v-107.71c0-29.747 26.246-53.856 58.617-53.856" style="stroke:none;fill-rule:nonzero;fill:#4d4d4d;fill-opacity:1" transform="translate(0 -20)"/><path d="M289.383 148.578c-39 22-56 1-61 154 0 0-8 14.95-26-11s-7-72.05-7-98c0-25.95 22-42.129 40-50.777 18-8.649 54 5.777 54 5.777" style="stroke:none;fill-rule:nonzero;fill:gray;fill-opacity:1" transform="translate(0 -20)"/><path d="M209.383 287.297c15.058 1.957 29.433 2.465 34.187 1a247.7 247.7 0 0 1 2.86-2.477c13.726-11.789 50.191-43.113 50.191-93.968 0-21.747-19.566-39.442-43.621-39.442-24.05 0-43.617 17.695-43.617 39.442Zm24.164 30.683c-4.43 0-9.348-.234-14.817-.69-14.035-1.173-26.632-3.474-27.164-3.567l-12.183-2.239V191.852c0-37.645 33.023-68.274 73.617-68.274s73.621 30.629 73.621 68.274c0 63.757-45.312 102.68-60.203 115.468-1.273 1.094-2.375 2.04-3.055 2.664-5.922 5.442-15.172 7.996-29.816 7.996" style="stroke:none;fill-rule:nonzero;fill:#000;fill-opacity:1" transform="translate(0 -20)"/><path d="M73.617 141.594c-32.37 0-58.617 24.113-58.617 53.855 0 62.832 48.848 98.735 58.617 107.711 9.77 8.977 58.621 0 58.621 0V195.45c0-29.743-26.246-53.856-58.62-53.856" style="stroke:none;fill-rule:nonzero;fill:#4d4d4d;fill-opacity:1" transform="translate(0 -20)"/><path d="M81.383 139.918c-63 38.66-31 96.11 14 156.66 0 0-23 16.336-41-9.61-18-25.952-45-60.55-45-86.5 0-25.948 18-51.902 36-60.55 18-8.648 36 0 36 0" style="stroke:none;fill-rule:nonzero;fill:gray;fill-opacity:1" transform="translate(0 -20)"/><path d="M83.047 291.895c4.758 1.464 19.129.957 34.191-1v-95.446c0-21.746-19.57-39.437-43.62-39.437-24.052 0-43.618 17.691-43.618 39.437 0 50.856 36.465 82.176 50.191 93.969 1.059.91 2.016 1.734 2.856 2.477m10.027 29.683c-14.648 0-23.894-2.55-29.82-7.996-.68-.625-1.781-1.57-3.059-2.664C45.31 298.125 0 259.207 0 195.449c0-37.644 33.027-68.27 73.617-68.27 40.594 0 73.621 30.626 73.621 68.27v119.633l-12.183 2.238c-.532.098-13.13 2.395-27.164 3.567-5.473.457-10.391.691-14.817.691" style="stroke:none;fill-rule:nonzero;fill:#000;fill-opacity:1" transform="translate(0 -20)"/><path d="M135.766 137.996c-32.375 0-58.621 24.11-58.621 53.856 0 62.832 48.847 98.734 58.62 107.71 9.77 8.973 58.618 0 58.618 0v-107.71c0-29.747-26.246-53.856-58.617-53.856" style="stroke:none;fill-rule:nonzero;fill:#4d4d4d;fill-opacity:1" transform="translate(0 -20)"/><path d="M152.383 138.578c-36 33.43-30 93.45 15 154 0 0-18 26.223-36 .274-18-25.954-49-70.325-49-96.274 0-25.95 22-42.129 40-50.777 18-8.649 30-7.223 30-7.223" style="stroke:none;fill-rule:nonzero;fill:gray;fill-opacity:1" transform="translate(0 -20)"/><path d="M145.195 288.297c4.766 1.469 19.14.965 34.188-.992v-95.453c0-21.747-19.567-39.442-43.617-39.442-24.051 0-43.621 17.695-43.621 39.442 0 50.855 36.464 82.18 50.195 93.968 1.058.91 2.012 1.73 2.855 2.477m10.024 29.683c-14.645 0-23.89-2.554-29.82-7.996-.676-.625-1.778-1.57-3.051-2.664-14.891-12.789-60.203-51.71-60.203-115.468 0-37.645 33.027-68.274 73.62-68.274 40.59 0 73.618 30.629 73.618 68.274v119.632l-12.184 2.239c-.527.093-13.125 2.394-27.164 3.566-5.469.457-10.39.691-14.816.691" style="stroke:none;fill-rule:nonzero;fill:#000;fill-opacity:1" transform="translate(0 -20)"/><path d="m104.383 305.578 31.851 69" style="stroke:none;fill-rule:nonzero;fill:#fff;fill-opacity:1" transform="translate(0 -20)"/><g clip-path="url(#c)" transform="translate(0 -20)"><path d="m0 0 31.852-69" style="fill:none;stroke-width:30;stroke-linecap:butt;stroke-linejoin:miter;stroke:#000;stroke-opacity:1;stroke-miterlimit:10" transform="matrix(1 0 0 -1 104.383 305.579)"/></g><path d="m178.707 305.578 31.852 69" style="stroke:none;fill-rule:nonzero;fill:#fff;fill-opacity:1" transform="translate(0 -20)"/><g clip-path="url(#d)" transform="translate(0 -20)"><path d="m0 0 31.852-69" style="fill:none;stroke-width:30;stroke-linecap:butt;stroke-linejoin:miter;stroke:#000;stroke-opacity:1;stroke-miterlimit:10" transform="matrix(1 0 0 -1 178.706 305.579)"/></g><path d="m253.031 305.578 31.852 69" style="stroke:none;fill-rule:nonzero;fill:#fff;fill-opacity:1" transform="translate(0 -20)"/><g clip-path="url(#e)" transform="translate(0 -20)"><path d="m0 0 31.853-69" style="fill:none;stroke-width:30;stroke-linecap:butt;stroke-linejoin:miter;stroke:#000;stroke-opacity:1;stroke-miterlimit:10" transform="matrix(1 0 0 -1 253.03 305.579)"/></g></svg>')} +.is2d .pawn.white {background-image:url('data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxMDAiIGhlaWdodD0iMTAwIiB2aWV3Qm94PSItNTAgLTEwMCAzNDUuOCA1MDYuNSI+PGRlZnM+PGNsaXBQYXRoIGlkPSJhIj48cGF0aCBkPSJNMCAwaDI1NS44djM3Ni41SDBabTAgMCIvPjwvY2xpcFBhdGg+PC9kZWZzPjxwYXRoIGZpbGw9IiNjY2MiIGQ9Ik0yMzkuNSAzMjAuNGMwLTkwLjMtNzQuNC0xMTkuOS02NS45LTE3Ni4yQTgxIDgxIDAgMCAwIDEyOS4zLTMuN2E4MS4yIDgxLjIgMCAwIDAtNDguMiAxNDcuOGM5LjUgNTYuNC02NC44IDg2LjQtNjQuOCAxNzYuMyAzMyA5LjkgNTQuNCAxOS43IDExMi4yIDE5LjdzNzgtOS44IDExMS0xOS43Ii8+PHBhdGggZmlsbD0iI2ZmZiIgZD0iTTEyNiAxMC40cy0yNSAyNi0yNiA2NGMtMSAzOC4xIDE0IDYwLjYgMTQgNjYgMCA1LjUuNCAyOC40LTUgNDhzLTM2IDg5LTM0IDEzNmMxLjQgMzIuOC01NS42LTEwLjQtNTUuNi0xMC40bDcuNi01Ni42IDU2LjYtODIuNi00LjMtMzQuOS0zMy44LTUyLjIgMTkuNi02MlptMCAwIi8+PGcgY2xpcC1wYXRoPSJ1cmwoI2EpIiB0cmFuc2Zvcm09InRyYW5zbGF0ZSgwIC0yMCkiPjxwYXRoIGQ9Ik0yMzkuNSAzNDAuNFpNMzMuMSAzMjguNWwxLjkuNmMyNiA4LjIgNDYuNiAxNC43IDkzLjUgMTQuNyA0Ni4zIDAgNjYuMi02LjMgOTEuNC0xNC40bDIuOC0uOWMtMy0zNi40LTIwLTYxLTM2LjMtODQuOS0xNi43LTI0LjItMzMuOS00OS4yLTI5LTgxLjlhMTYuMyAxNi4zIDAgMCAxIDYuOS0xMSA2NC44IDY0LjggMCAxIDAtNzQgMCAxNi4zIDE2LjMgMCAwIDEgNi44IDEwLjdjNS42IDMzLTExLjUgNTguMy0yOC4yIDgyLjgtMTYgMjMuOC0zMi43IDQ4LjMtMzUuOCA4NC4zbTk1LjQgNDhjLTUyIDAtNzctOC0xMDMuMy0xNi4zTDExLjYgMzU2QTE2LjMgMTYuMyAwIDAgMSAwIDM0MC40YzAtNTIuNyAyMy4yLTg3IDQyLTExNC41IDE1LTIyLjMgMjQuMS0zNi42IDIzLjYtNTNBOTcuNiA5Ny42IDAgMCAxIDEyOS43IDBhOTcgOTcgMCAwIDEgNjYuNSAyOC42IDk3IDk3IDAgMCAxLTcgMTQ0LjJjMCAxNy4zIDEwLjggMzMgMjQgNTIuMyAxOSAyNy43IDQyLjYgNjIgNDIuNiAxMTUuMyAwIDcuMi00LjcgMTMuNi0xMS42IDE1LjZsLTE0LjQgNC41Yy0yNS43IDguMi01MCAxNi0xMDEuMyAxNiIvPjwvZz48L3N2Zz4=')} +.is2d .knight.white {background-image:url('data:image/svg+xml;base64,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')} +.is2d .bishop.white {background-image:url('data:image/svg+xml;base64,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')} +.is2d .rook.white {background-image:url('data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxMDAiIGhlaWdodD0iMTAwIiB2aWV3Qm94PSItNTAgLTEwMCAzODYuOCA1MDMiPjxkZWZzPjxjbGlwUGF0aCBpZD0iYSI+PHBhdGggZD0iTTAgMGgyOTYuOHYzNzNIMFptMCAwIi8+PC9jbGlwUGF0aD48L2RlZnM+PHBhdGggZmlsbD0iI2NjYyIgZD0iTTQ5LjMgMTYyLjNDNDkuOCA5NCA1LjggMzcuMiAxOC44LTMuN0gyNzhjMTMgNDAuOS0zMSA5Ny42LTMwLjYgMTY2IC41IDcyLjMgNDQgMTMyLjMgMzAuNiAxNzQuNUgxOC44Yy0xMy40LTQyLjIgMzAtMTAyLjMgMzAuNS0xNzQuNSIvPjxwYXRoIGZpbGw9IiNmZmYiIGQ9Ik05Mi45LTJjLTkuOCA1NS4yIDYgMTI1LjMgNiAxNzMgMCA0Ni41LTE4LjMgMTAxLTE1IDE2NmwtNjAuNC0uMkw0MyAxNzEgMjMuNS00LjJabTAgMCIvPjxnIGNsaXAtcGF0aD0idXJsKCNhKSIgdHJhbnNmb3JtPSJ0cmFuc2xhdGUoMCAtMjApIj48cGF0aCBkPSJNMjUxLjMgMjgxLjhjLTkuMy0yOS4zLTE5LjgtNjIuNC0yMC05OS4zLS4zLTM1LjggMTAuNC02Ny44IDE5LjktOTYgNy0yMC43IDEzLjEtMzkuMiAxMy01NEgzMi42YzAgMTQuOCA2LjEgMzMuMyAxMyA1NCA5LjUgMjguMiAyMC4yIDYwLjIgMjAgOTYtLjMgMzYuOS0xMC44IDcwLTIwIDk5LjMtNy4yIDIyLjYtMTMuNiA0Mi44LTEzLjEgNTguN2gyMzEuOWMuNC0xNi02LTM2LjEtMTMuMS01OC43bS0yNDggNzkuOWMtOC41LTI3IDEuMS01Ny41IDExLjMtODkuNyA4LjYtMjcgMTguMy01Ny43IDE4LjUtODkuOC4yLTMwLjQtOS4yLTU4LjMtMTguMi04NS4zQzQuNyA2Ni40LTUuMSAzNy41IDMuMyAxMS4zQTE2LjIgMTYuMiAwIDAgMSAxOC44IDBIMjc4YzcgMCAxMy4zIDQuNiAxNS41IDExLjMgOC4yIDI2LjItMS40IDU1LTExLjcgODUuNi05IDI3LTE4LjQgNTUtMTguMSA4NS4zLjIgMzIgOS45IDYyLjcgMTguNCA4OS44IDEwLjIgMzIuMiAxOS45IDYyLjcgMTEuNCA4OS43QTE2LjIgMTYuMiAwIDAgMSAyNzggMzczSDE4LjhhMTYuMiAxNi4yIDAgMCAxLTE1LjUtMTEuMyIvPjwvZz48cGF0aCBmaWxsPSJub25lIiBzdHJva2U9IiMwMDAiIHN0cm9rZS1saW5lam9pbj0icm91bmQiIHN0cm9rZS1taXRlcmxpbWl0PSIxMCIgc3Ryb2tlLXdpZHRoPSIzMCIgZD0iTTk4LjYgNC41djU4LjJtOTkuNy01OC4ydjU4LjJtLTE3NSAyMTUuNmgyNTAuMk00MC40IDEyMC44aDIxNiIvPjwvc3ZnPg==')} +.is2d .queen.white {background-image:url('data:image/svg+xml;base64,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')} +.is2d .king.white {background-image:url('data:image/svg+xml;base64,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')} +.is2d .pawn.black {background-image:url('data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxMDAiIGhlaWdodD0iMTAwIiB2aWV3Qm94PSItNTAgLTEwMCAzNDUuOCA1MDYuNSI+PGRlZnM+PGNsaXBQYXRoIGlkPSJhIj48cGF0aCBkPSJNMCAwaDI1NS44djM3Ni41SDBabTAgMCIvPjwvY2xpcFBhdGg+PC9kZWZzPjxwYXRoIGZpbGw9IiM0ZDRkNGQiIGQ9Ik0yMzkuNSAzMjAuNGMwLTkwLjMtNzQuNC0xMTkuOS02NS45LTE3Ni4yQTgxIDgxIDAgMCAwIDEyOS4zLTMuN2E4MS4yIDgxLjIgMCAwIDAtNDguMiAxNDcuOGM5LjUgNTYuNC02NC44IDg2LjQtNjQuOCAxNzYuMyAzMyA5LjkgNTQuNCAxOS43IDExMi4yIDE5LjdzNzgtOS44IDExMS0xOS43Ii8+PHBhdGggZmlsbD0iZ3JheSIgZD0iTTEyNiAxMC40cy0yNSAyNi0yNiA2NGMtMSAzOC4xIDE0IDYwLjYgMTQgNjYgMCA1LjUuNCAyOC40LTUgNDhzLTM2IDg5LTM0IDEzNmMxLjQgMzIuOC01NS42LTEwLjQtNTUuNi0xMC40bDcuNi01Ni42IDU2LjYtODIuNi00LjMtMzQuOS0zMy44LTUyLjIgMTkuNi02MlptMCAwIi8+PGcgY2xpcC1wYXRoPSJ1cmwoI2EpIiB0cmFuc2Zvcm09InRyYW5zbGF0ZSgwIC0yMCkiPjxwYXRoIGQ9Ik0yMzkuNSAzNDAuNFpNMzMuMSAzMjguNWwxLjkuNmMyNiA4LjIgNDYuNiAxNC43IDkzLjUgMTQuNyA0Ni4zIDAgNjYuMi02LjMgOTEuNC0xNC40bDIuOC0uOWMtMy0zNi40LTIwLTYxLTM2LjMtODQuOS0xNi43LTI0LjItMzMuOS00OS4yLTI5LTgxLjlhMTYuMyAxNi4zIDAgMCAxIDYuOS0xMSA2NC44IDY0LjggMCAxIDAtNzQgMCAxNi4zIDE2LjMgMCAwIDEgNi44IDEwLjdjNS42IDMzLTExLjUgNTguMy0yOC4yIDgyLjgtMTYgMjMuOC0zMi43IDQ4LjMtMzUuOCA4NC4zbTk1LjQgNDhjLTUyIDAtNzctOC0xMDMuMy0xNi4zTDExLjYgMzU2QTE2LjMgMTYuMyAwIDAgMSAwIDM0MC40YzAtNTIuNyAyMy4yLTg3IDQyLTExNC41IDE1LTIyLjMgMjQuMS0zNi42IDIzLjYtNTNBOTcuNiA5Ny42IDAgMCAxIDEyOS43IDBhOTcgOTcgMCAwIDEgNjYuNSAyOC42IDk3IDk3IDAgMCAxLTcgMTQ0LjJjMCAxNy4zIDEwLjggMzMgMjQgNTIuMyAxOSAyNy43IDQyLjYgNjIgNDIuNiAxMTUuMyAwIDcuMi00LjcgMTMuNi0xMS42IDE1LjZsLTE0LjQgNC41Yy0yNS43IDguMi01MCAxNi0xMDEuMyAxNiIvPjwvZz48L3N2Zz4=')} +.is2d .knight.black {background-image:url('data:image/svg+xml;base64,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')} +.is2d .bishop.black {background-image:url('data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxMDAiIGhlaWdodD0iMTAwIiB2aWV3Qm94PSItNTAgLTYwIDM4MS4zIDUxMS43Ij48ZGVmcz48Y2xpcFBhdGggaWQ9ImEiPjxwYXRoIGQ9Ik0wIDcwaDI5MS4zdjM2MS43SDBabTAgMCIvPjwvY2xpcFBhdGg+PC9kZWZzPjxwYXRoIGZpbGw9ImdyYXkiIGQ9Ik0xODAuNCAyOS44YTM0LjggMzQuOCAwIDEgMS02OS43IDAgMzQuOCAzNC44IDAgMCAxIDY5LjcgMCIvPjxwYXRoIGZpbGw9Im5vbmUiIHN0cm9rZT0iIzAwMCIgc3Ryb2tlLWxpbmVqb2luPSJyb3VuZCIgc3Ryb2tlLW1pdGVybGltaXQ9IjEwIiBzdHJva2Utd2lkdGg9IjMwIiBkPSJNMTgwLjQgMjkuOGEzNC44IDM0LjggMCAxIDEtNjkuNyAwIDM0LjggMzQuOCAwIDAgMSA2OS43IDBabTAgMCIvPjxwYXRoIGZpbGw9IiM0ZDRkNGQiIGQ9Ik0yNDguMSAxNDkuOUMxOTEuNiAxNjUuMiAxNTQgMjYxLjMgMTU0IDI2MS4zczQuNy04Ni41IDQ0LjgtMTYwLjFjLTI3LjktMjIuMy01Mi42LTM2LTUyLjYtMzZzLTEzMiA3Mi0xMzEuMSAxNTQuNmMxIDgyLjYgNjYuMiAxNDcgNTggMTY0LjMtOCAxNy4yIDE1NC4zIDE2LjMgMTQ2LjEgMC04LjEtMTYuNCA1Ni4zLTgyLjYgNTcuMi0xNjQuMy4zLTI0LjctMTEuNS00OC42LTI4LjItNzAiLz48cGF0aCBmaWxsPSJncmF5IiBkPSJNMTUwLjMgNzEuOGMtNTAuNSA4Ny02Mi41IDEyNi02Mi41IDE1MyAwIDU2LjkgNTEgMTQ4IDI2LjUgMTYyaC0zNmwtNDUtOTAtMTgtNjMgOS01NCAzNi00NVptMCAwIi8+PGcgY2xpcC1wYXRoPSJ1cmwoI2EpIiB0cmFuc2Zvcm09InRyYW5zbGF0ZSgwIC0yMCkiPjxwYXRoIGQ9Ik04OC43IDM5Ny41YTI4OSAyODkgMCAwIDAgNTUuOCA0LjJoMS43YzI3LjktLjEgNDcuOC0yLjMgNTcuNC00LjQgMS4zLTEwLjQgOC0yMi42IDE3LjQtMzkuNCAxNi44LTMwLjMgMzkuOC03MS43IDQwLjMtMTE4LjIuMi0xNi4xLTYtMzMuNS0xOC42LTUxLjgtMzYuMSAxNy42LTY1LjkgNzYtNzQuOSA5OC45YTE1IDE1IDAgMCAxLTE3LjEgOS4xIDE1IDE1IDAgMCAxLTExLjgtMTUuNCA0NDYgNDQ2IDAgMCAxIDQwLjgtMTU1LjEgNDM5LjYgNDM5LjYgMCAwIDAtMzMuNy0yMi45Yy0xMS4yIDYuOC0zNCAyMS40LTU2LjQgNDAuN0M2Mi4yIDE2NyAyOS42IDIwMyAzMCAyMzkuN2MuNSA0NyAyMy44IDg3LjkgNDAuOCAxMTcuOCA5LjcgMTcuMSAxNi43IDI5LjUgMTcuOSA0MG01NS45IDM0LjJjLTE2LjUgMC0zMi4zLS44LTQ1LTIuMi0yMi42LTIuNC0zMC02LjMtMzQuNC05LjctNi40LTUtOC45LTEyLjgtNi42LTIwLTEtNS04LjItMTcuNC0xNC0yNy41QzI3LjIgMzQxLjQuNyAyOTQuNyAwIDI0MGMtLjQtMzguOSAyMy4zLTc5LjIgNzAuNC0xMTkuOEE0MTcuNCA0MTcuNCAwIDAgMSAxMzkgNzJhMTUgMTUgMCAwIDEgMTQuNSAwYzEgLjYgMjYuMSAxNC43IDU0LjcgMzcuNWExNSAxNSAwIDAgMSAzLjggMTguOSAzNDIgMzQyIDAgMCAwLTI4LjQgNzEuOWMxOS4zLTI0LjEgMzkuNi0zOS4yIDYwLjctNDVhMTUgMTUgMCAwIDEgMTUuOCA1LjNjMjEgMjcuMSAzMS42IDUzLjggMzEuMyA3OS40LS42IDU0LjEtMjYuNyAxMDEuMi00NCAxMzIuNC01LjYgMTAuMS0xMi41IDIyLjUtMTMuNyAyNy41IDIuMiA2LjkgMCAxNC40LTYuMSAxOS40LTQuMiAzLjQtMTEuNSA3LjMtMzQgOS45YTQyOC41IDQyOC41IDAgMCAxLTQ2LjggMi40aC0yLjEiLz48L2c+PHBhdGggZmlsbD0ibm9uZSIgc3Ryb2tlPSIjMDAwIiBzdHJva2UtbGluZWNhcD0icm91bmQiIHN0cm9rZS1saW5lam9pbj0icm91bmQiIHN0cm9rZS1taXRlcmxpbWl0PSIxMCIgc3Ryb2tlLXdpZHRoPSIzMCIgZD0iTTQ3LjMgMzI0LjNjMTUuNiAyNC4zIDE4MS41IDI4LjggMTk4IDAiLz48L3N2Zz4=')} +.is2d .rook.black {background-image:url('data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxMDAiIGhlaWdodD0iMTAwIiB2aWV3Qm94PSItNTAgLTEwMCAzODYuOCA1MDMiPjxkZWZzPjxjbGlwUGF0aCBpZD0iYSI+PHBhdGggZD0iTTAgMGgyOTYuOHYzNzNIMFptMCAwIi8+PC9jbGlwUGF0aD48L2RlZnM+PHBhdGggZmlsbD0iIzRkNGQ0ZCIgZD0iTTQ5LjMgMTYyLjNDNDkuOCA5NCA1LjggMzcuMiAxOC44LTMuN0gyNzhjMTMgNDAuOS0zMSA5Ny42LTMwLjYgMTY2IC41IDcyLjMgNDQgMTMyLjMgMzAuNiAxNzQuNUgxOC44Yy0xMy40LTQyLjIgMzAtMTAyLjMgMzAuNS0xNzQuNSIvPjxwYXRoIGZpbGw9ImdyYXkiIGQ9Ik05Mi45LTJjLTkuOCA1NS4yIDYgMTI1LjMgNiAxNzMgMCA0Ni41LTE4LjMgMTAxLTE1IDE2NmwtNjAuNC0uMkw0MyAxNzEgMjMuNS00LjJabTAgMCIvPjxnIGNsaXAtcGF0aD0idXJsKCNhKSIgdHJhbnNmb3JtPSJ0cmFuc2xhdGUoMCAtMjApIj48cGF0aCBkPSJNMjUxLjMgMjgxLjhjLTkuMy0yOS4zLTE5LjgtNjIuNC0yMC05OS4zLS4zLTM1LjggMTAuNC02Ny44IDE5LjktOTYgNy0yMC43IDEzLjEtMzkuMiAxMy01NEgzMi42YzAgMTQuOCA2LjEgMzMuMyAxMyA1NCA5LjUgMjguMiAyMC4yIDYwLjIgMjAgOTYtLjMgMzYuOS0xMC44IDcwLTIwIDk5LjMtNy4yIDIyLjYtMTMuNiA0Mi44LTEzLjEgNTguN2gyMzEuOWMuNC0xNi02LTM2LjEtMTMuMS01OC43bS0yNDggNzkuOWMtOC41LTI3IDEuMS01Ny41IDExLjMtODkuNyA4LjYtMjcgMTguMy01Ny43IDE4LjUtODkuOC4yLTMwLjQtOS4yLTU4LjMtMTguMi04NS4zQzQuNyA2Ni40LTUuMSAzNy41IDMuMyAxMS4zQTE2LjIgMTYuMiAwIDAgMSAxOC44IDBIMjc4YzcgMCAxMy4zIDQuNiAxNS41IDExLjMgOC4yIDI2LjItMS40IDU1LTExLjcgODUuNi05IDI3LTE4LjQgNTUtMTguMSA4NS4zLjIgMzIgOS45IDYyLjcgMTguNCA4OS44IDEwLjIgMzIuMiAxOS45IDYyLjcgMTEuNCA4OS43QTE2LjIgMTYuMiAwIDAgMSAyNzggMzczSDE4LjhhMTYuMiAxNi4yIDAgMCAxLTE1LjUtMTEuMyIvPjwvZz48cGF0aCBmaWxsPSJub25lIiBzdHJva2U9IiMwMDAiIHN0cm9rZS1saW5lam9pbj0icm91bmQiIHN0cm9rZS1taXRlcmxpbWl0PSIxMCIgc3Ryb2tlLXdpZHRoPSIzMCIgZD0iTTk4LjYgNC41djU4LjJtOTkuNy01OC4ydjU4LjJtLTE3NSAyMTUuNmgyNTAuMk00MC40IDEyMC44aDIxNiIvPjwvc3ZnPg==')} +.is2d .queen.black {background-image:url('data:image/svg+xml;base64,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')} +.is2d .king.black {background-image:url('data:image/svg+xml;base64,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')} diff --git a/public/piece/california/bB.svg b/public/piece/california/bB.svg index 3ccbe575cd9cf..e7289234afb04 100644 --- a/public/piece/california/bB.svg +++ b/public/piece/california/bB.svg @@ -1 +1 @@ - \ No newline at end of file + \ No newline at end of file diff --git a/public/piece/california/bK.svg b/public/piece/california/bK.svg index 66f5719890fae..4db7f7b87ddc7 100644 --- a/public/piece/california/bK.svg +++ b/public/piece/california/bK.svg @@ -1 +1 @@ - \ No newline at end of file + \ No newline at end of file diff --git a/public/piece/california/bN.svg b/public/piece/california/bN.svg index 585c006d45fb5..8bbe5005aeb2a 100644 --- a/public/piece/california/bN.svg +++ b/public/piece/california/bN.svg @@ -1 +1 @@ - \ No newline at end of file + \ No newline at end of file diff --git a/public/piece/california/bP.svg b/public/piece/california/bP.svg index e688531ed613a..bb4ce3f9192b3 100644 --- a/public/piece/california/bP.svg +++ b/public/piece/california/bP.svg @@ -1 +1 @@ - \ No newline at end of file + \ No newline at end of file diff --git a/public/piece/california/bQ.svg b/public/piece/california/bQ.svg index 23e395b8cbcd0..479e1f95f5e84 100644 --- a/public/piece/california/bQ.svg +++ b/public/piece/california/bQ.svg @@ -1 +1 @@ - \ No newline at end of file + \ No newline at end of file diff --git a/public/piece/california/bR.svg b/public/piece/california/bR.svg index 2cd8f50dae8fa..aae79ba472194 100644 --- a/public/piece/california/bR.svg +++ b/public/piece/california/bR.svg @@ -1 +1 @@ - \ No newline at end of file + \ No newline at end of file diff --git a/public/piece/california/wB.svg b/public/piece/california/wB.svg index f412208eaf232..03c71b7e39cc4 100644 --- a/public/piece/california/wB.svg +++ b/public/piece/california/wB.svg @@ -1 +1 @@ - \ No newline at end of file + \ No newline at end of file diff --git a/public/piece/california/wK.svg b/public/piece/california/wK.svg index 842934894faa0..5478848b58eb1 100644 --- a/public/piece/california/wK.svg +++ b/public/piece/california/wK.svg @@ -1 +1 @@ - \ No newline at end of file + \ No newline at end of file diff --git a/public/piece/california/wN.svg b/public/piece/california/wN.svg index dba04ffd1b9dd..45b2bda22934b 100644 --- a/public/piece/california/wN.svg +++ b/public/piece/california/wN.svg @@ -1 +1 @@ - \ No newline at end of file + \ No newline at end of file diff --git a/public/piece/california/wP.svg b/public/piece/california/wP.svg index 0247d305b9fb8..bba8d0f49d55d 100644 --- a/public/piece/california/wP.svg +++ b/public/piece/california/wP.svg @@ -1 +1 @@ - \ No newline at end of file + \ No newline at end of file diff --git a/public/piece/california/wQ.svg b/public/piece/california/wQ.svg index a6459435ee7a5..a857fc4106f53 100644 --- a/public/piece/california/wQ.svg +++ b/public/piece/california/wQ.svg @@ -1 +1 @@ - \ No newline at end of file + \ No newline at end of file diff --git a/public/piece/california/wR.svg b/public/piece/california/wR.svg index 2482b5088f0d6..4b2f598f08ba5 100644 --- a/public/piece/california/wR.svg +++ b/public/piece/california/wR.svg @@ -1 +1 @@ - \ No newline at end of file + \ No newline at end of file From c101feb7034c034dc64b807fd2abbfe40f28470a Mon Sep 17 00:00:00 2001 From: Thibault Duplessis Date: Sun, 16 Jun 2024 18:21:14 +0200 Subject: [PATCH 082/168] insane mongodb aggregation magic to achieve the desired featuring where the first ongoing tournament of a group is selected --- modules/relay/src/main/RelayListing.scala | 114 ++++++++++++++++++---- modules/relay/src/main/RelayPager.scala | 4 +- 2 files changed, 95 insertions(+), 23 deletions(-) diff --git a/modules/relay/src/main/RelayListing.scala b/modules/relay/src/main/RelayListing.scala index cb9382c327953..5907619781f27 100644 --- a/modules/relay/src/main/RelayListing.scala +++ b/modules/relay/src/main/RelayListing.scala @@ -35,15 +35,92 @@ final class RelayListing( for upcoming <- upcoming.get({}) max = 100 + tourIds <- colls.tour.distinctEasy[RelayTourId, List]( + "_id", + RelayTourRepo.selectors.officialActive ++ $doc("_id".$nin(upcoming.map(_.tour.id))) + ) + groupToursDocs <- colls.group.aggregateList(Int.MaxValue): framework => + import framework.* + Match($doc("tours".$in(tourIds))) -> List( + PipelineOperator( + $lookup.pipelineFull( + from = colls.tour.name, + as = "tours", + let = $doc("tourIds" -> "$tours"), + pipe = List( + $doc("$match" -> $doc("$expr" -> $doc("$in" -> $arr("$_id", "$$tourIds")))), + $doc("$addFields" -> $doc("__order" -> $doc("$indexOfArray" -> $arr("$$tourIds", "$_id")))), + $doc("$sort" -> $doc("tier" -> -1, "__order" -> 1)), + $doc("$project" -> $doc("live" -> true)) + ) + ) + ), + Project( + $doc( + "tours" -> $doc( + "$ifNull" -> $arr( + $doc( + "$first" -> $doc( + "$filter" -> $doc( + "input" -> "$tours", + "as" -> "tour", + "cond" -> "$$tour.live", + "limit" -> 1 + ) + ) + ), + $doc("$first" -> "$tours") + ) + ) + ) + ), + Project($doc("_id" -> true, "tour" -> "$tours._id")) + ) + groupTourPairs = for + doc <- groupToursDocs + groupId <- doc.getAsOpt[RelayGroup.Id]("_id") + tour <- doc.getAsOpt[RelayTourId]("tour") + yield s"$groupId$tour" docs <- colls.tour .aggregateList(max): framework => import framework.* - Match( - RelayTourRepo.selectors.officialActive ++ $doc("_id".$nin(upcoming.map(_.tour.id))) - ) -> List( + Match($inIds(tourIds)) -> List( Sort(Descending("tier")), - PipelineOperator(group.lookup(colls.group)), - // Match(group.filter), + Project( + $doc("subscribers" -> false, "notified" -> false, "teams" -> false, "players" -> false) + ), + PipelineOperator( + $lookup.pipelineFull( + from = colls.group.name, + as = "group", + let = $doc("tourId" -> "$_id"), + pipe = List( + $doc("$match" -> $doc("$expr" -> $doc("$in" -> $arr("$$tourId", "$tours")))), + $doc( + "$project" -> $doc( + "_id" -> true, + "name" -> true + ) + ) + ) + ) + ), + AddFields($doc("group" -> $doc("$first" -> "$group"))), + AddFields( + $doc( + "isGroupTour" -> + $doc( + "$let" -> $doc( + "vars" -> $doc( + "allPairs" -> groupTourPairs, + "pair" -> $doc("$concat" -> $arr("$group._id", "$_id")) + ), + "in" -> $doc("$in" -> $arr("$$pair", "$$allPairs")) + ) + ) + ) + ), + Match($doc($or("group".$exists(false), "isGroupTour".$eq(true)))), PipelineOperator(roundLookup), UnwindField("round"), Limit(max) @@ -52,7 +129,7 @@ final class RelayListing( doc <- docs tour <- doc.asOpt[RelayTour] round <- doc.getAsOpt[RelayRound]("round") - group = RelayListing.group.readFrom(doc) + group = RelayListing.group.readFromOne(doc) yield (tour, round, group) sorted = tours.sortBy: (tour, round, _) => ( @@ -82,8 +159,8 @@ final class RelayListing( import framework.* Match(RelayTourRepo.selectors.officialActive) -> List( Sort(Descending("tier")), - PipelineOperator(group.lookup(colls.group)), - Match(group.filter), + PipelineOperator(group.firstLookup(colls.group)), + Match(group.firstFilter), PipelineOperator: $lookup.pipeline( from = colls.round, @@ -143,10 +220,11 @@ final class RelayListing( private object RelayListing: object group: + // look at the groups where the tour appears. // only keep the tour if there is no group, // or if the tour is the first in the group. - def lookup(groupColl: Coll) = $lookup.pipelineFull( + def firstLookup(groupColl: Coll) = $lookup.pipelineFull( from = groupColl.name, as = "group", let = $doc("tourId" -> "$_id"), @@ -160,21 +238,15 @@ private object RelayListing: ) ) ) - val filter = $doc("group.0.isFirst".$ne(false)) - - def groupliveTourLookup(tourColl: Coll) = $lookup.pipelineFull( - from = tourColl.name, - as = "liveTour", - let = $doc("tourIds" -> "$tours"), - pipe = List( - $doc("$match" -> $doc("$expr" -> $doc("$in" -> $arr("_id", "$$tourIds")))), - $doc("$match" -> $doc("live" -> true)), - $doc("$project" -> $doc("_id" -> false, "id" -> true)) - ) - ) + val firstFilter = $doc("group.0.isFirst".$ne(false)) def readFrom(doc: Bdoc): Option[RelayGroup.Name] = for garr <- doc.getAsOpt[Barr]("group") gdoc <- garr.getAsOpt[Bdoc](0) name <- gdoc.getAsOpt[RelayGroup.Name]("name") yield name + + def readFromOne(doc: Bdoc): Option[RelayGroup.Name] = for + gdoc <- doc.getAsOpt[Bdoc]("group") + name <- gdoc.getAsOpt[RelayGroup.Name]("name") + yield name diff --git a/modules/relay/src/main/RelayPager.scala b/modules/relay/src/main/RelayPager.scala index ba23a71bb593e..fc9b33dce4343 100644 --- a/modules/relay/src/main/RelayPager.scala +++ b/modules/relay/src/main/RelayPager.scala @@ -172,8 +172,8 @@ final class RelayPager( ) = onlyKeepGroupFirst.so( List( - framework.PipelineOperator(RelayListing.group.lookup(colls.group)), - framework.Match(RelayListing.group.filter) + framework.PipelineOperator(RelayListing.group.firstLookup(colls.group)), + framework.Match(RelayListing.group.firstFilter) ) ) ::: List( framework.PipelineOperator( From 7a76183305b829590e7056ae717a506aed1764da Mon Sep 17 00:00:00 2001 From: Thibault Duplessis Date: Sun, 16 Jun 2024 18:41:30 +0200 Subject: [PATCH 083/168] broadcast: ignore source games with an unknown player --- modules/relay/src/main/RelayGame.scala | 6 ++++++ modules/relay/src/main/RelayInputSanity.scala | 6 +++++- 2 files changed, 11 insertions(+), 1 deletion(-) diff --git a/modules/relay/src/main/RelayGame.scala b/modules/relay/src/main/RelayGame.scala index 081364dbe1206..180df1a9fd52f 100644 --- a/modules/relay/src/main/RelayGame.scala +++ b/modules/relay/src/main/RelayGame.scala @@ -38,6 +38,10 @@ case class RelayGame( def fideIdsPair: Option[PairOf[Option[chess.FideId]]] = tags.fideIds.some.filter(_.forall(_.isDefined)).map(_.toPair) + def hasUnknownPlayer: Boolean = + List(RelayGame.whiteTags, RelayGame.blackTags).exists: + _.forall(tag => tags(tag).isEmpty) + private object RelayGame: val lichessDomains = List("lichess.org", "lichess.dev") @@ -46,6 +50,8 @@ private object RelayGame: val eventTags: TagNames = List(_.Event, _.Site) val nameTags: TagNames = List(_.White, _.Black) val fideIdTags: TagNames = List(_.WhiteFideId, _.BlackFideId) + val whiteTags: TagNames = List(_.White, _.WhiteFideId) + val blackTags: TagNames = List(_.Black, _.BlackFideId) import scalalib.Iso import chess.format.pgn.{ InitialComments, Pgn } diff --git a/modules/relay/src/main/RelayInputSanity.scala b/modules/relay/src/main/RelayInputSanity.scala index df4a50f91333a..22f3f6c97c71e 100644 --- a/modules/relay/src/main/RelayInputSanity.scala +++ b/modules/relay/src/main/RelayInputSanity.scala @@ -8,7 +8,11 @@ import lila.study.* private object RelayInputSanity: def fixGames(games: RelayGames): RelayGames = - fixDgtKingsInTheCenter(games) + fixDgtKingsInTheCenter: + removeGamesWithUnknownPlayer(games) + + private def removeGamesWithUnknownPlayer(games: RelayGames): RelayGames = + games.filterNot(_.hasUnknownPlayer) // DGT puts the kings in the center on game end // and sends it as actual moves if the kings were close to the center From 0aa0c5a5dde827b6863bd5c7795e16a411073d24 Mon Sep 17 00:00:00 2001 From: Thibault Duplessis Date: Sun, 16 Jun 2024 20:29:04 +0200 Subject: [PATCH 084/168] broadcast viewers stats per round --- modules/relay/src/main/JsonView.scala | 31 +++++++++------ modules/relay/src/main/RelayRoundRepo.scala | 6 +-- modules/relay/src/main/RelayStatsApi.scala | 44 +++++++++++++++------ modules/relay/src/main/ui/RelayTourUi.scala | 12 ++---- 4 files changed, 57 insertions(+), 36 deletions(-) diff --git a/modules/relay/src/main/JsonView.scala b/modules/relay/src/main/JsonView.scala index 91ddf7521bfd7..0bcdab2f91e7d 100644 --- a/modules/relay/src/main/JsonView.scala +++ b/modules/relay/src/main/JsonView.scala @@ -45,18 +45,6 @@ final class JsonView( "tours" -> g.withShorterTourNames.tours ) - given OWrites[RelayRound] = OWrites: r => - Json - .obj( - "id" -> r.id, - "name" -> r.name, - "slug" -> r.slug, - "createdAt" -> r.createdAt - ) - .add("finished" -> r.finished) - .add("ongoing" -> (r.hasStarted && !r.finished)) - .add("startsAt" -> r.startsAt.orElse(r.startedAt)) - def fullTour(tour: RelayTour): JsObject = Json .toJsObject(tour) @@ -165,6 +153,25 @@ object JsonView: given OWrites[SyncLog.Event] = Json.writes + given OWrites[RelayRound] = OWrites: r => + Json + .obj( + "id" -> r.id, + "name" -> r.name, + "slug" -> r.slug, + "createdAt" -> r.createdAt + ) + .add("finished" -> r.finished) + .add("ongoing" -> (r.hasStarted && !r.finished)) + .add("startsAt" -> r.startsAt.orElse(r.startedAt)) + + given OWrites[RelayStats.RoundStats] = OWrites: r => + Json.obj( + "round" -> r.round, + "viewers" -> r.viewers.map: (minute, crowd) => + Json.arr(minute * 60, crowd) + ) + private given OWrites[RelayRound.Sync] = OWrites: s => Json .obj( diff --git a/modules/relay/src/main/RelayRoundRepo.scala b/modules/relay/src/main/RelayRoundRepo.scala index 675529bf87a58..f869994a2c5c0 100644 --- a/modules/relay/src/main/RelayRoundRepo.scala +++ b/modules/relay/src/main/RelayRoundRepo.scala @@ -49,16 +49,16 @@ final private class RelayRoundRepo(val coll: Coll)(using Executor): def studyIdsOf(tourId: RelayTourId): Fu[List[StudyId]] = coll.distinctEasy[StudyId, List]("_id", selectors.tour(tourId)) - def tourCrowds: Fu[List[(RelayTourId, Int)]] = + def roundCrowds: Fu[List[(RelayRoundId, Int)]] = coll .aggregateList(maxDocs = 500, _.sec): framework => import framework.* Match($doc("sync.until" -> $exists(true), "crowd".$gt(0))) -> - List(GroupField("tourId")("crowd" -> SumField("crowd"))) + List(Project($doc("_id" -> 1, "crowd" -> 1))) .map: docs => for doc <- docs - id <- doc.getAsOpt[RelayTourId]("_id") + id <- doc.getAsOpt[RelayRoundId]("_id") crowd <- doc.getAsOpt[Int]("crowd") yield (id, crowd) diff --git a/modules/relay/src/main/RelayStatsApi.scala b/modules/relay/src/main/RelayStatsApi.scala index ffc2979976060..56e59039b1238 100644 --- a/modules/relay/src/main/RelayStatsApi.scala +++ b/modules/relay/src/main/RelayStatsApi.scala @@ -6,31 +6,51 @@ object RelayStats: type Minute = Int type Crowd = Int type Graph = List[(Minute, Crowd)] + case class RoundStats(round: RelayRound, viewers: Graph) final class RelayStatsApi(roundRepo: RelayRoundRepo, colls: RelayColls)(using scheduler: Scheduler)(using Executor ): import RelayStats.* + import BSONHandlers.given // on measurement by minute at most; the storage depends on it. - scheduler.scheduleWithFixedDelay(0 seconds, 1 minute)(() => record()) + scheduler.scheduleWithFixedDelay(1 minute, 1 minute)(() => record()) - def get(id: RelayTourId): Fu[Graph] = - colls.stats - .primitiveOne[List[Int]]($id(id), "d") - .mapz: - _.grouped(2) - .collect: - case List(minute, crowd) => (minute, crowd) - .toList + def get(id: RelayTourId): Fu[List[RoundStats]] = + colls.round + .aggregateList(128): framework => + import framework.* + Match($doc("tourId" -> id)) -> List( + Sort(Ascending("createdAt")), + AddFields($doc("sync.log" -> $arr())), + PipelineOperator( + $lookup.simple(colls.stats, "stats", "_id", "_id") + ), + AddFields($doc("stats" -> $doc("$first" -> "$stats"))) + ) + .map: docs => + for + doc <- docs + round <- doc.asOpt[RelayRound] + data = for + doc <- doc.getAsOpt[Bdoc]("stats") + data <- doc.getAsOpt[List[Int]]("d") + yield data + stats = data.so: + _.grouped(2) + .collect: + case List(minute, crowd) => (minute, crowd) + .toList + yield RoundStats(round, stats) private def record(): Funit = for - crowds <- roundRepo.tourCrowds + crowds <- roundRepo.roundCrowds nowMinutes = nowSeconds / 60 update = colls.stats.update(ordered = false) - elements <- crowds.sequentially: (tourId, crowd) => + elements <- crowds.sequentially: (roundId, crowd) => update.element( - q = $id(tourId), + q = $id(roundId), u = $push("d" -> $doc("$each" -> $arr(nowMinutes, crowd))), upsert = true ) diff --git a/modules/relay/src/main/ui/RelayTourUi.scala b/modules/relay/src/main/ui/RelayTourUi.scala index dffc3bea5351a..54defb524d4d6 100644 --- a/modules/relay/src/main/ui/RelayTourUi.scala +++ b/modules/relay/src/main/ui/RelayTourUi.scala @@ -102,17 +102,11 @@ final class RelayTourUi(helpers: Helpers, ui: RelayUi): ) ) - def stats(t: RelayTour, graph: RelayStats.Graph)(using Context) = + def stats(t: RelayTour, stats: List[RelayStats.RoundStats])(using Context) = + import JsonView.given Page(s"${t.name.value} - Stats") .css("bits.relay.index") - .js( - PageModule( - "bits.relayStats", - Json - .obj("points" -> graph.map: (minute, crowd) => - Json.arr(minute * 60, crowd)) - ) - ): + .js(PageModule("bits.relayStats", Json.obj("rounds" -> stats))): main(cls := "relay-tour page box box-pad")( boxTop(h1(a(href := routes.RelayTour.show(t.slug, t.id).url)(t.name), " - Stats")), "Here, a graph shows the number of viewers over time." From 41e3db1b4e2a8cbf375bf5184e00350b2547c8e2 Mon Sep 17 00:00:00 2001 From: Thibault Duplessis Date: Sun, 16 Jun 2024 20:37:02 +0200 Subject: [PATCH 085/168] refactor broadcast stats and add logging --- modules/relay/src/main/RelayRoundRepo.scala | 13 ------------- modules/relay/src/main/RelayStatsApi.scala | 18 +++++++++++++++++- 2 files changed, 17 insertions(+), 14 deletions(-) diff --git a/modules/relay/src/main/RelayRoundRepo.scala b/modules/relay/src/main/RelayRoundRepo.scala index f869994a2c5c0..a288e03cbf128 100644 --- a/modules/relay/src/main/RelayRoundRepo.scala +++ b/modules/relay/src/main/RelayRoundRepo.scala @@ -49,19 +49,6 @@ final private class RelayRoundRepo(val coll: Coll)(using Executor): def studyIdsOf(tourId: RelayTourId): Fu[List[StudyId]] = coll.distinctEasy[StudyId, List]("_id", selectors.tour(tourId)) - def roundCrowds: Fu[List[(RelayRoundId, Int)]] = - coll - .aggregateList(maxDocs = 500, _.sec): framework => - import framework.* - Match($doc("sync.until" -> $exists(true), "crowd".$gt(0))) -> - List(Project($doc("_id" -> 1, "crowd" -> 1))) - .map: docs => - for - doc <- docs - id <- doc.getAsOpt[RelayRoundId]("_id") - crowd <- doc.getAsOpt[Int]("crowd") - yield (id, crowd) - private object RelayRoundRepo: object sort: diff --git a/modules/relay/src/main/RelayStatsApi.scala b/modules/relay/src/main/RelayStatsApi.scala index 56e59039b1238..311a9ae6793cb 100644 --- a/modules/relay/src/main/RelayStatsApi.scala +++ b/modules/relay/src/main/RelayStatsApi.scala @@ -45,7 +45,7 @@ final class RelayStatsApi(roundRepo: RelayRoundRepo, colls: RelayColls)(using sc yield RoundStats(round, stats) private def record(): Funit = for - crowds <- roundRepo.roundCrowds + crowds <- fetchRoundCrowds nowMinutes = nowSeconds / 60 update = colls.stats.update(ordered = false) elements <- crowds.sequentially: (roundId, crowd) => @@ -56,3 +56,19 @@ final class RelayStatsApi(roundRepo: RelayRoundRepo, colls: RelayColls)(using sc ) _ <- elements.nonEmpty.so(update.many(elements).void) yield () + + private def fetchRoundCrowds: Fu[List[(RelayRoundId, Crowd)]] = + val max = 500 + colls.round + .aggregateList(maxDocs = max, _.sec): framework => + import framework.* + Match($doc("sync.until" -> $exists(true), "crowd".$gt(0))) -> + List(Project($doc("_id" -> 1, "crowd" -> 1))) + .map: docs => + if docs.size == max + then logger.warn(s"RelayStats.fetchRoundCrowds: $max docs fetched") + for + doc <- docs + id <- doc.getAsOpt[RelayRoundId]("_id") + crowd <- doc.getAsOpt[Crowd]("crowd") + yield (id, crowd) From caf15219903470ba48d31646736c8c7c93790303 Mon Sep 17 00:00:00 2001 From: Thibault Duplessis Date: Sun, 16 Jun 2024 20:45:26 +0200 Subject: [PATCH 086/168] hide the broadcast stats link for now but start recording data --- ui/analyse/src/study/relay/relayTourView.ts | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/ui/analyse/src/study/relay/relayTourView.ts b/ui/analyse/src/study/relay/relayTourView.ts index edac7327fd2af..e79ddb1317860 100644 --- a/ui/analyse/src/study/relay/relayTourView.ts +++ b/ui/analyse/src/study/relay/relayTourView.ts @@ -285,13 +285,13 @@ const makeTabs = (ctrl: AnalyseCtrl) => { makeTab('boards', 'Boards'), relay.teams && makeTab('teams', 'Teams'), relay.data.tour.leaderboard ? makeTab('leaderboard', 'Leaderboard') : undefined, - study.members.myMember() - ? h( - 'a.text', - { attrs: { ...dataIcon(licon.LineGraph), href: `/broadcast/${relay.data.tour.id}/stats` } }, - 'Popularity stats', - ) - : undefined, + // study.members.myMember() + // ? h( + // 'a.text', + // { attrs: { ...dataIcon(licon.LineGraph), href: `/broadcast/${relay.data.tour.id}/stats` } }, + // 'Popularity stats', + // ) + // : undefined, ]); }; From 222ad9dcb67dbda4e69b7e67a1d94175a1d57fb4 Mon Sep 17 00:00:00 2001 From: Thibault Duplessis Date: Sun, 16 Jun 2024 20:52:40 +0200 Subject: [PATCH 087/168] disable blocked player's dropdown items - closes #15536 --- modules/relation/src/main/ui/RelationUi.scala | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/modules/relation/src/main/ui/RelationUi.scala b/modules/relation/src/main/ui/RelationUi.scala index 8a3a39a07fbec..5ba6e197671c1 100644 --- a/modules/relation/src/main/ui/RelationUi.scala +++ b/modules/relation/src/main/ui/RelationUi.scala @@ -51,8 +51,9 @@ final class RelationUi(helpers: Helpers): blocked: Boolean, signup: Boolean = false )(using ctx: Context) = + val blocks = relation.contains(Relation.Block) div(cls := "relation-actions")( - (ctx.isnt(user) && !blocked).option( + (ctx.isnt(user) && !blocked && !blocks).option( a( cls := "text", href := s"${routes.Lobby.home}?user=${user.name}#friend", @@ -64,14 +65,14 @@ final class RelationUi(helpers: Helpers): (!user.is(myId)) .so( frag( - (!blocked && !user.isBot).option( + (!blocked && !blocks && !user.isBot).option( a( cls := "text", href := routes.Msg.convo(user.name), dataIcon := Icon.BubbleSpeech )(trans.site.composeMessage.txt()) ), - (!blocked && !user.isPatron).option( + (!blocked && !blocks && !user.isPatron).option( a( cls := "text", href := s"${routes.Plan.list}?dest=gift&giftUsername=${user.name}", From 3e23d94cc384bf1c3096c62f6258b686f8bbf126 Mon Sep 17 00:00:00 2001 From: Thibault Duplessis Date: Mon, 17 Jun 2024 07:27:35 +0200 Subject: [PATCH 088/168] New Crowdin updates (#15509) * New translations: site.xml (Norwegian Bokmal) * New translations: faq.xml (Norwegian Bokmal) * New translations: site.xml (Danish) * New translations: site.xml (Norwegian Bokmal) * New translations: site.xml (Japanese) * New translations: team.xml (Arabic) * New translations: team.xml (Arabic) * New translations: coordinates.xml (Finnish) * New translations: site.xml (Finnish) * New translations: team.xml (Finnish) --- translation/dest/coordinates/fi-FI.xml | 1 + translation/dest/faq/nb-NO.xml | 4 ++-- translation/dest/site/da-DK.xml | 4 ++-- translation/dest/site/fi-FI.xml | 2 ++ translation/dest/site/ja-JP.xml | 2 ++ translation/dest/site/nb-NO.xml | 10 ++++++---- translation/dest/team/ar-SA.xml | 9 +++++++++ translation/dest/team/fi-FI.xml | 1 + 8 files changed, 25 insertions(+), 8 deletions(-) diff --git a/translation/dest/coordinates/fi-FI.xml b/translation/dest/coordinates/fi-FI.xml index 2132e97b438f5..22641c1cfa74f 100644 --- a/translation/dest/coordinates/fi-FI.xml +++ b/translation/dest/coordinates/fi-FI.xml @@ -13,6 +13,7 @@ Sinulla on 30 sekuntia aikaa paikantaa niin monta ruutua kuin ehdit! Tee sitä kaikessa rauhassa, aikarajaa ei ole! Näytä koordinaatit + Koordinaatit jokaisessa ruudussa Näytä nappulat Aloita harjoitus Etsi ruutu diff --git a/translation/dest/faq/nb-NO.xml b/translation/dest/faq/nb-NO.xml index 37b62c8ec90d2..60f24e37bc3c4 100644 --- a/translation/dest/faq/nb-NO.xml +++ b/translation/dest/faq/nb-NO.xml @@ -51,7 +51,7 @@ Lichess bruker Stockfish til maskinanalyse. Tap på tid, remis og utilstrekkelig materiell Hvis tiden løper ut for en spiller, vil vedkommende vanligvis tape partiet. Partiet er likevel remis hvis stillingen er slik at motstanderen ikke kan matte spillerens konge ved noen lovlig trekkrekkefølge (%1$s). -Dette kan i sjeldne tilfeller være vanskelig å avgjøre automatisk (tvungne linjer, festninger). Da holder vi med spilleren der tiden ikke løp ut. +Dette kan i sjeldne tilfeller være vanskelig å avgjøre automatisk (tvungne varianter, festninger). Da holder vi med spilleren der tiden ikke løp ut. Legg merke til at den kan være mulig å matte med en enkelt springer eller løper hvis motstanderen har en brikke som kan blokkere kongen. FIDEs håndbok @@ -167,7 +167,7 @@ Vi viser det røde ikonet for å varsle deg når dette skjer. Ofte kan du ekspli 3. Klikk på Informasjonskapsler og nettstedstillatelser 4. Rull ned og klikk på Automatisk avspilling av medier 5. Legg til lichess.org under Tillat - Stoppe meg selv fra å spille? + Stoppe meg selv fra å spille? egen psykisk helsetilstand Lichess-brukerstiler færre lobbypuljer diff --git a/translation/dest/site/da-DK.xml b/translation/dest/site/da-DK.xml index 404fa19acad46..3e0f9b7520432 100644 --- a/translation/dest/site/da-DK.xml +++ b/translation/dest/site/da-DK.xml @@ -38,8 +38,8 @@ Hvid i trækket Sort i trækket - Din modstander har forladt partiet. Du kan kræve sejr om %s sekund. - Din modstander har forladt partiet. Du kan kræve sejr om %s sekunder. + Din modstander har forladt partiet. Du kan kræve at få tildelt sejren om %s sekund. + Din modstander har forladt partiet. Du kan kræve at få tildelt sejren om %s sekunder. Din modstander har forladt partiet. Du kan fremtvinge modstanderens kapitulation eller vente. Kræv sejr diff --git a/translation/dest/site/fi-FI.xml b/translation/dest/site/fi-FI.xml index f3732010a2742..62eaa8ba665cc 100644 --- a/translation/dest/site/fi-FI.xml +++ b/translation/dest/site/fi-FI.xml @@ -70,6 +70,8 @@ Nosta muunnelmaa Päämuunnelmaksi Poista tästä alkaen + Taita kokoon muunnelmat + Laajenna muunnelmat Pakota muunnelmaksi Kopioi muunnelman PGN Siirto diff --git a/translation/dest/site/ja-JP.xml b/translation/dest/site/ja-JP.xml index 5c3959d19164c..7406145dafbf2 100644 --- a/translation/dest/site/ja-JP.xml +++ b/translation/dest/site/ja-JP.xml @@ -69,6 +69,8 @@ 変化を主手順にする 主手順にする これ以降を削除 + 変化手順をかくす + 変化手順を表示する 変化として表示 手順の PGN をコピー 手 diff --git a/translation/dest/site/nb-NO.xml b/translation/dest/site/nb-NO.xml index 1a9d2737b47d6..c1a31af2191f6 100644 --- a/translation/dest/site/nb-NO.xml +++ b/translation/dest/site/nb-NO.xml @@ -70,6 +70,8 @@ Forfrem variant Gjør til hovedvariant Slett herfra + Skjul varianter + Vis varianter Vis som variant Kopier variant-PGN Trekk @@ -119,7 +121,7 @@ Pil for beste trekk Vis variantpiler Evalueringsmåler - Flere linjer + Flere varianter Prosessorer Minne Uendelig analyse @@ -330,7 +332,7 @@ Gi %s sekunder Denne kontoen brøt vilkårene for å bruke Lichess - Åpningsutforsker & tabellbase + Åpningsutforsker og tabellbase Angre Foreslå å angre Angreforslag sendt @@ -865,8 +867,8 @@ Ingen betingede forhåndstrekk Spill %s - og lagre %s linje med forhåndstrekk - og lagre %s linjer med forhåndstrekk + og lagre %s forhåndstrekkvariant + og lagre %s forhåndstrekkvarianter Du har mottatt en privat melding fra Lichess. Klikk her for å lese den diff --git a/translation/dest/team/ar-SA.xml b/translation/dest/team/ar-SA.xml index 9fff9f41a1e68..be798a3abfa64 100644 --- a/translation/dest/team/ar-SA.xml +++ b/translation/dest/team/ar-SA.xml @@ -67,4 +67,13 @@ الطلبات المرفوضة انضم إلى فريق %s الرسمي للأخبار والأحداث صفحة الفريق + انتهت هذه البطولة، ولم يعد من الممكن تحديث الفريق. + قائمة الفرق التي ستتنافس في هذه المعركة. + فريق واحد لكل سطر. استخدم الإكمال التلقائي. + يمكنك نسخ ولصق هذه القائمة من بطولة إلى أخرى! + +لا يمكنك إزالة فريق إذا كان اللاعب قد انضم فعلًا إلى البطولة معه. + عدد القادة لكل فريق. مجموع درجاتهم هو نتيجة الفريق. + لا يجب عليك تغيير هذه القيمة بعد بدء البطولة! + الفريق الداخلي diff --git a/translation/dest/team/fi-FI.xml b/translation/dest/team/fi-FI.xml index 7f6c3f77ae6f2..741c07a11e079 100644 --- a/translation/dest/team/fi-FI.xml +++ b/translation/dest/team/fi-FI.xml @@ -63,4 +63,5 @@ Pelaajat, jotka eivät mielellään ota vastaan viestejäsi, saattavat lähteä Et voi poistaa joukkuetta, jos pelaaja on jo liittynyt turnaukseen sen kanssa. Johtajien määrä kussakin joukkueessa. Heidän pisteidensä summa muodostaa joukkueen pistemäärän. Tätä arvoa ei todellakaan tulisi muuttaa turnauksen jo käynnistyttyä! + Sisäinen joukkue From 9fc0cbaec62456d9f6bc45d57e87033bafaa8968 Mon Sep 17 00:00:00 2001 From: Thibault Duplessis Date: Mon, 17 Jun 2024 07:54:59 +0200 Subject: [PATCH 089/168] fix mongodb aggregation --- modules/relay/src/main/RelayListing.scala | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/modules/relay/src/main/RelayListing.scala b/modules/relay/src/main/RelayListing.scala index 5907619781f27..49191e9c3f330 100644 --- a/modules/relay/src/main/RelayListing.scala +++ b/modules/relay/src/main/RelayListing.scala @@ -64,8 +64,8 @@ final class RelayListing( "$filter" -> $doc( "input" -> "$tours", "as" -> "tour", - "cond" -> "$$tour.live", - "limit" -> 1 + "cond" -> "$$tour.live" + // "limit" -> 1 // TODO unsupported by mongodb 4.4 (but also not needed here) ) ) ), From bef8bb058c68d6f7b10a1a567e9100371db1ec4c Mon Sep 17 00:00:00 2001 From: Thibault Duplessis Date: Mon, 17 Jun 2024 08:54:25 +0200 Subject: [PATCH 090/168] fix some z-index after #15510 --- ui/analyse/css/study/relay/_tour.scss | 2 +- ui/board/css/_menu.scss | 4 ++-- ui/ceval/css/_settings.scss | 2 +- ui/voice/css/_voice.scss | 2 +- 4 files changed, 5 insertions(+), 5 deletions(-) diff --git a/ui/analyse/css/study/relay/_tour.scss b/ui/analyse/css/study/relay/_tour.scss index a5fe56f09aeb5..2f15dc0c698db 100644 --- a/ui/analyse/css/study/relay/_tour.scss +++ b/ui/analyse/css/study/relay/_tour.scss @@ -456,7 +456,7 @@ $hover-bg: $m-primary_bg--mix-30; max-height: 12em; overflow-y: auto; background: $c-bg-zebra; - z-index: z(mz-menu); + z-index: $z-mz-menu-4; width: 100%; border: $c-primary 2px solid; } diff --git a/ui/board/css/_menu.scss b/ui/board/css/_menu.scss index 86d4ad0f3685d..ee76dbac89ef5 100644 --- a/ui/board/css/_menu.scss +++ b/ui/board/css/_menu.scss @@ -8,14 +8,14 @@ position: absolute; right: 0; min-width: 100%; - z-index: z(mz-menu); + z-index: $z-mz-menu-4; } @media (max-width: at-most($small)) { position: fixed; top: 50% !important; left: 50%; transform: translate(-50%, -50%); - z-index: z(context-menu); + z-index: $z-context-menu-108; min-width: 80%; border-radius: $box-radius-size; } diff --git a/ui/ceval/css/_settings.scss b/ui/ceval/css/_settings.scss index cc19d82570867..3597e77e54350 100644 --- a/ui/ceval/css/_settings.scss +++ b/ui/ceval/css/_settings.scss @@ -6,7 +6,7 @@ @extend %flex-column, %dropdown-shadow, %box-radius-bottom; position: absolute; border-top: 2px solid $c-primary; - z-index: z(mz-menu); + z-index: $z-mz-menu-4; width: 100%; background: $c-bg-high; gap: 1.5em; diff --git a/ui/voice/css/_voice.scss b/ui/voice/css/_voice.scss index 8c67c1d17dcee..be0f41a9db84e 100644 --- a/ui/voice/css/_voice.scss +++ b/ui/voice/css/_voice.scss @@ -114,7 +114,7 @@ button#microphone-button { @extend %flex-column, %dropdown-shadow, %box-radius-bottom; position: absolute; border-top: 2px solid $c-primary; - z-index: z(mz-menu); + z-index: $z-mz-menu-4; width: 100%; background: $c-bg-high; gap: 1.5em; From 6b44f3be73c1312afb63418b403adf43dd66a479 Mon Sep 17 00:00:00 2001 From: Allan Joseph Date: Mon, 17 Jun 2024 07:18:47 +0000 Subject: [PATCH 091/168] upgrade chartjs everywhere --- pnpm-lock.yaml | 21 ++++++--------------- ui/insight/package.json | 2 +- ui/opening/package.json | 2 +- 3 files changed, 8 insertions(+), 17 deletions(-) diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml index b12793ea45865..d3e1e761fb0ff 100644 --- a/pnpm-lock.yaml +++ b/pnpm-lock.yaml @@ -380,11 +380,11 @@ importers: specifier: workspace:^ version: link:../chart chart.js: - specifier: ^4.4.0 - version: 4.4.0 + specifier: 4.4.3 + version: 4.4.3 chartjs-plugin-datalabels: specifier: ^2.2.0 - version: 2.2.0(chart.js@4.4.0) + version: 2.2.0(chart.js@4.4.3) common: specifier: workspace:* version: link:../common @@ -503,11 +503,11 @@ importers: specifier: ^3.1.9 version: 3.1.9 chart.js: - specifier: 4.4.0 - version: 4.4.0 + specifier: 4.4.3 + version: 4.4.3 chartjs-adapter-dayjs-4: specifier: ^1.0.4 - version: 1.0.4(chart.js@4.4.0)(dayjs@1.11.10) + version: 1.0.4(chart.js@4.4.3)(dayjs@1.11.10) common: specifier: workspace:* version: link:../common @@ -3042,20 +3042,11 @@ snapshots: dependencies: '@kurkle/color': 0.3.2 - chartjs-adapter-dayjs-4@1.0.4(chart.js@4.4.0)(dayjs@1.11.10): - dependencies: - chart.js: 4.4.0 - dayjs: 1.11.10 - chartjs-adapter-dayjs-4@1.0.4(chart.js@4.4.3)(dayjs@1.11.10): dependencies: chart.js: 4.4.3 dayjs: 1.11.10 - chartjs-plugin-datalabels@2.2.0(chart.js@4.4.0): - dependencies: - chart.js: 4.4.0 - chartjs-plugin-datalabels@2.2.0(chart.js@4.4.3): dependencies: chart.js: 4.4.3 diff --git a/ui/insight/package.json b/ui/insight/package.json index 52e7f67a6b37d..2cc781fb9337c 100644 --- a/ui/insight/package.json +++ b/ui/insight/package.json @@ -13,7 +13,7 @@ "license": "AGPL-3.0-or-later", "dependencies": { "chart": "workspace:^", - "chart.js": "^4.4.0", + "chart.js": "4.4.3", "chartjs-plugin-datalabels": "^2.2.0", "common": "workspace:*", "snabbdom": "3.5.1" diff --git a/ui/opening/package.json b/ui/opening/package.json index 4bd09189b3789..a8db21be1c34e 100644 --- a/ui/opening/package.json +++ b/ui/opening/package.json @@ -7,7 +7,7 @@ "license": "AGPL-3.0-or-later", "dependencies": { "@types/debounce-promise": "^3.1.9", - "chart.js": "4.4.0", + "chart.js": "4.4.3", "chartjs-adapter-dayjs-4": "^1.0.4", "common": "workspace:*", "dayjs": "^1.11.10", From fca5d062c47ba0fce62d1dba37d969bb4d77c10b Mon Sep 17 00:00:00 2001 From: Thibault Duplessis Date: Mon, 17 Jun 2024 11:30:59 +0200 Subject: [PATCH 092/168] sneak in another rounding pixel --- ui/common/css/abstract/_variables.scss | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ui/common/css/abstract/_variables.scss b/ui/common/css/abstract/_variables.scss index 006f8171352c5..9dbb7930583a0 100644 --- a/ui/common/css/abstract/_variables.scss +++ b/ui/common/css/abstract/_variables.scss @@ -7,7 +7,7 @@ $viewport-min-width: 320px; $block-gap: var(---block-gap); -$box-radius-size: 5px; +$box-radius-size: 6px; $box-padding-vert: 5vh; $transition-duration: 150ms; From 62bbbee01df5d7843ff343703a39da297d315389 Mon Sep 17 00:00:00 2001 From: Thibault Duplessis Date: Mon, 17 Jun 2024 11:31:07 +0200 Subject: [PATCH 093/168] broadcast form navigation --- app/controllers/RelayRound.scala | 28 +-- app/controllers/RelayTour.scala | 29 +-- modules/relay/src/main/RelayApi.scala | 19 +- modules/relay/src/main/RelayRoundRepo.scala | 8 +- modules/relay/src/main/ui/FormUi.scala | 187 +++++++++++------- .../src/study/relay/relayManagerView.ts | 12 +- ui/bits/css/relay/_form.scss | 26 +++ ui/bits/css/user/_show.scss | 6 +- 8 files changed, 196 insertions(+), 119 deletions(-) diff --git a/app/controllers/RelayRound.scala b/app/controllers/RelayRound.scala index 3d3bd95b4fd10..c1c2dade5058d 100644 --- a/app/controllers/RelayRound.scala +++ b/app/controllers/RelayRound.scala @@ -9,6 +9,7 @@ import scala.annotation.nowarn import lila.app.{ *, given } import lila.common.HTTPRequest import lila.relay.{ RelayRound as RoundModel, RelayTour as TourModel } +import lila.relay.ui.FormNavigation import lila.core.id.{ RelayRoundId, RelayTourId } final class RelayRound( @@ -21,7 +22,7 @@ final class RelayRound( NoLameOrBot: WithTourAndRoundsCanUpdate(tourId): trs => Ok.page: - views.relay.form.round.create(env.relay.roundForm.create(trs), trs.tour) + views.relay.form.round.create(env.relay.roundForm.create(trs), FormNavigation(trs, none)) } def create(tourId: RelayTourId) = AuthOrScopedBody(_.Study.Write) { ctx ?=> me ?=> @@ -35,7 +36,7 @@ final class RelayRound( bindForm(env.relay.roundForm.create(trs))( err => negotiate( - BadRequest.page(views.relay.form.round.create(err, tour)), + BadRequest.page(views.relay.form.round.create(err, FormNavigation(trs, none))), jsonFormError(err) ), setup => @@ -51,30 +52,31 @@ final class RelayRound( } def edit(id: RelayRoundId) = Auth { ctx ?=> me ?=> - FoundPage(env.relay.api.byIdAndContributor(id)): rt => - views.relay.form.round.edit(rt, env.relay.roundForm.edit(rt.round)) + FoundPage(env.relay.api.formNavigation(id)): (round, nav) => + views.relay.form.round.edit(round, env.relay.roundForm.edit(round), nav) } def update(id: RelayRoundId) = AuthOrScopedBody(_.Study.Write) { ctx ?=> me ?=> given play.api.Mode = env.mode env.relay.api - .byIdAndContributor(id) - .flatMapz: rt => - bindForm(env.relay.roundForm.edit(rt.round))( - err => fuccess(Left(rt -> err)), + .formNavigation(id) + .flatMapz: (round, nav) => + bindForm(env.relay.roundForm.edit(round))( + err => fuccess(Left((round, nav) -> err)), data => env.relay.api - .update(rt.round)(data.update(rt.tour.official)) - .dmap(_.withTour(rt.tour)) + .update(round)(data.update(nav.tour.official)) + .dmap(_.withTour(nav.tour)) .dmap(Right(_)) ).dmap(some) .orNotFound: _.fold( - (old, err) => + { case ((round, nav), err) => negotiate( - BadRequest.page(views.relay.form.round.edit(old, err)), + BadRequest.page(views.relay.form.round.edit(round, err, nav)), jsonFormError(err) - ), + ) + }, rt => negotiate(Redirect(rt.path), JsonOk(env.relay.jsonView.withUrl(rt, withTour = true))) ) } diff --git a/app/controllers/RelayTour.scala b/app/controllers/RelayTour.scala index 465ba63651d20..ec77fba160af9 100644 --- a/app/controllers/RelayTour.scala +++ b/app/controllers/RelayTour.scala @@ -6,6 +6,7 @@ import scalalib.Json.given import lila.app.{ *, given } import lila.core.net.IpAddress import lila.relay.RelayTour as TourModel +import lila.relay.ui.FormNavigation import lila.core.id.RelayTourId final class RelayTour(env: Env, apiC: => Api) extends LilaController(env): @@ -98,23 +99,23 @@ final class RelayTour(env: Env, apiC: => Api) extends LilaController(env): } def edit(id: RelayTourId) = Auth { ctx ?=> _ ?=> - WithTourCanUpdate(id): tg => + WithTourCanUpdate(id): nav => Ok.page: - views.relay.form.tour.edit(tg, env.relay.tourForm.edit(tg)) + views.relay.form.tour.edit(env.relay.tourForm.edit(nav.tourWithGroup), nav) } def update(id: RelayTourId) = AuthOrScopedBody(_.Study.Write) { ctx ?=> me ?=> - WithTourCanUpdate(id): tg => - bindForm(env.relay.tourForm.edit(tg))( + WithTourCanUpdate(id): nav => + bindForm(env.relay.tourForm.edit(nav.tourWithGroup))( err => negotiate( - BadRequest.page(views.relay.form.tour.edit(tg, err)), + BadRequest.page(views.relay.form.tour.edit(err, nav)), jsonFormError(err) ), setup => - env.relay.api.tourUpdate(tg.tour, setup) >> + env.relay.api.tourUpdate(nav.tour, setup) >> negotiate( - Redirect(routes.RelayTour.show(tg.tour.slug, tg.tour.id)), + Redirect(routes.RelayTour.show(nav.tour.slug, nav.tour.id)), jsonOkResult ) ) @@ -126,16 +127,16 @@ final class RelayTour(env: Env, apiC: => Api) extends LilaController(env): } def image(id: RelayTourId, tag: Option[String]) = AuthBody(parse.multipartFormData) { ctx ?=> me ?=> - WithTourCanUpdate(id): tg => + WithTourCanUpdate(id): nav => ctx.body.body.file("image") match case Some(image) => limit.imageUpload(ctx.ip, rateLimited): - (env.relay.api.image.upload(me, tg.tour, image, tag) >> { + (env.relay.api.image.upload(me, nav.tour, image, tag) >> { Ok }).recover { case e: Exception => BadRequest(e.getMessage) } - case None => env.relay.api.image.delete(tg.tour, tag) >> Ok + case None => env.relay.api.image.delete(nav.tour, tag) >> Ok } def leaderboardView(id: RelayTourId) = Open: @@ -212,12 +213,12 @@ final class RelayTour(env: Env, apiC: => Api) extends LilaController(env): private def WithTourCanUpdate( id: RelayTourId - )(f: TourModel.WithGroupTours => Fu[Result])(using ctx: Context): Fu[Result] = + )(f: (FormNavigation) => Fu[Result])(using Context, Me): Fu[Result] = WithTour(id): tour => - ctx.me - .soUse { env.relay.api.canUpdate(tour) } + env.relay.api + .canUpdate(tour) .elseNotFound: - env.relay.api.withTours.addTo(tour).flatMap(f) + env.relay.api.formNavigation(tour).flatMap(f) private[controllers] def rateLimitCreation( fail: => Fu[Result] diff --git a/modules/relay/src/main/RelayApi.scala b/modules/relay/src/main/RelayApi.scala index a6c7868fd6405..a88a458f4069b 100644 --- a/modules/relay/src/main/RelayApi.scala +++ b/modules/relay/src/main/RelayApi.scala @@ -45,9 +45,20 @@ final class RelayApi( def byIdAndContributor(id: RelayRoundId)(using me: Me): Fu[Option[WithTour]] = byIdWithTourAndStudy(id).map: _.collect: - case RelayRound.WithTourAndStudy(relay, tour, study) if study.canContribute(me) => + case RelayRound.WithTourAndStudy(relay, tour, study) + if study.canContribute(me) || Granter(_.StudyAdmin) => relay.withTour(tour) + def formNavigation(id: RelayRoundId)(using me: Me): Fu[Option[(RelayRound, ui.FormNavigation)]] = + byIdAndContributor(id).flatMapz: rt => + formNavigation(rt.tour).map: nav => + (rt.round, nav.copy(round = rt.round.id.some)).some + + def formNavigation(tour: RelayTour)(using me: Me): Fu[ui.FormNavigation] = for + group <- withTours.get(tour.id) + rounds <- roundRepo.byTourOrdered(tour.id) + yield ui.FormNavigation(group, tour, rounds, none) + def byIdWithTourAndStudy(id: RelayRoundId): Fu[Option[RelayRound.WithTourAndStudy]] = byIdWithTour(id).flatMapz { case WithTour(relay, tour) => studyApi @@ -64,7 +75,7 @@ final class RelayApi( RelayRound.WithStudy(relay, _) def byTourOrdered(tour: RelayTour): Fu[List[WithTour]] = - roundRepo.byTourOrdered(tour).dmap(_.map(_.withTour(tour))) + roundRepo.byTourOrdered(tour.id).dmap(_.map(_.withTour(tour))) def roundIdsById(tourId: RelayTourId): Fu[List[StudyId]] = roundRepo.idsByTourId(tourId) @@ -73,7 +84,7 @@ final class RelayApi( roundIdsById(tourId).flatMap: _.sequentiallyVoid(studyApi.kick(_, userId, who)) - def withRounds(tour: RelayTour) = roundRepo.byTourOrdered(tour).dmap(tour.withRounds) + def withRounds(tour: RelayTour) = roundRepo.byTourOrdered(tour.id).dmap(tour.withRounds) def denormalizeTourActive(tourId: RelayTourId): Funit = val unfinished = RelayRoundRepo.selectors.tour(tourId) ++ $doc("finished" -> false) @@ -314,7 +325,7 @@ final class RelayApi( ) tourRepo.coll.insert.one(tour) >> roundRepo - .byTourOrderedCursor(from) + .byTourOrderedCursor(from.id) .documentSource() .mapAsync(1)(cloneWithStudy(_, tour)) .runWith(Sink.ignore) diff --git a/modules/relay/src/main/RelayRoundRepo.scala b/modules/relay/src/main/RelayRoundRepo.scala index a288e03cbf128..eedde0a66ac91 100644 --- a/modules/relay/src/main/RelayRoundRepo.scala +++ b/modules/relay/src/main/RelayRoundRepo.scala @@ -10,14 +10,14 @@ final private class RelayRoundRepo(val coll: Coll)(using Executor): import RelayRoundRepo.* import BSONHandlers.given - def byTourOrderedCursor(tour: RelayTour) = + def byTourOrderedCursor(tourId: RelayTourId) = coll - .find(selectors.tour(tour.id)) + .find(selectors.tour(tourId)) .sort(sort.chrono) .cursor[RelayRound]() - def byTourOrdered(tour: RelayTour): Fu[List[RelayRound]] = - byTourOrderedCursor(tour).list(RelayTour.maxRelays) + def byTourOrdered(tourId: RelayTourId): Fu[List[RelayRound]] = + byTourOrderedCursor(tourId).list(RelayTour.maxRelays) def idsByTourOrdered(tour: RelayTour): Fu[List[RelayRoundId]] = coll.primitive[RelayRoundId]( diff --git a/modules/relay/src/main/ui/FormUi.scala b/modules/relay/src/main/ui/FormUi.scala index d8bda1ef7337c..ae17b19facc46 100644 --- a/modules/relay/src/main/ui/FormUi.scala +++ b/modules/relay/src/main/ui/FormUi.scala @@ -8,40 +8,94 @@ import ScalatagsTemplate.{ *, given } import play.api.data.Form import lila.core.id.ImageId +case class FormNavigation( + group: Option[RelayGroup.WithTours], + tour: RelayTour, + rounds: List[RelayRound], + round: Option[RelayRoundId], + newRound: Boolean = false +): + def tourWithGroup = RelayTour.WithGroupTours(tour, group) + +object FormNavigation: + def apply(trs: RelayTour.WithRounds, roundId: Option[RelayRoundId]): FormNavigation = + FormNavigation(none, trs.tour, trs.rounds, roundId) + final class FormUi(helpers: Helpers, ui: RelayUi, tourUi: RelayTourUi): import helpers.{ *, given } import trans.{ broadcast as trb } + private def navigationMenu(nav: FormNavigation)(using Context) = + def tourAndRounds(shortName: Option[RelayTour.Name]) = frag( + a( + href := routes.RelayTour.edit(nav.tour.id), + cls := List( + "relay-form__subnav__tour-parent" -> shortName.isDefined, + "active" -> (nav.round.isEmpty && !nav.newRound) + ) + )( + shortName.fold(frag(nav.tour.name))(strong(_)) + ), + frag( + nav.rounds.map: r => + a( + href := routes.RelayRound.edit(r.id), + cls := List("subnav__subitem" -> true, "active" -> nav.round.has(r.id)) + )(r.name), + a( + href := routes.RelayRound.create(nav.tour.id), + cls := List("subnav__subitem text" -> true, "active" -> nav.newRound), + dataIcon := Icon.PlusButton + )("New round") + ) + ) + lila.ui.bits.pageMenuSubnav( + cls := "relay-form__subnav", + nav.group match + case None => tourAndRounds(none) + case Some(g) => + frag( + span(cls := "relay-form__subnav__group")(g.group.name), + g.withShorterTourNames.tours.map: t => + if nav.tour.id == t.id then tourAndRounds(t.name.some) + else a(href := routes.RelayTour.edit(t.id), cls := List("subnav__item" -> true))(t.name) + ) + ) + object round: - private def page(title: String)(using Context) = + private def page(title: String, nav: FormNavigation)(using Context) = Page(title) .css("bits.relay.form") .js(EsmInit("bits.flatpickr")) .wrap: body => - main(cls := "page-small box box-pad")(body) - - def create(form: Form[RelayRoundForm.Data], tour: RelayTour)(using Context) = - page(trans.broadcast.newBroadcast.txt()): - frag( - boxTop(h1(a(href := routes.RelayTour.edit(tour.id))(tour.name), " • ", trans.broadcast.addRound())), - standardFlash, - inner(form, routes.RelayRound.create(tour.id), tour, create = true) - ) + main(cls := "page page-menu")( + navigationMenu(nav), + div(cls := "page-menu__content box box-pad")(body) + ) - def edit(rt: RelayRound.WithTour, form: Form[RelayRoundForm.Data])(using Context) = - page(rt.fullName): + def create(form: Form[RelayRoundForm.Data], nav: FormNavigation)(using Context) = + page(trans.broadcast.newBroadcast.txt(), nav.copy(newRound = true)): frag( boxTop( - h1(dataIcon := Icon.Pencil, cls := "text")( - a(href := routes.RelayTour.edit(rt.tour.id))(rt.tour.name), + h1( + a(href := routes.RelayTour.edit(nav.tour.id))(nav.tour.name), " • ", - a(href := rt.path)(rt.round.name) + trans.broadcast.addRound() ) ), - inner(form, routes.RelayRound.update(rt.round.id), rt.tour, create = false), + standardFlash, + inner(form, routes.RelayRound.create(nav.tour.id), nav.tour, create = true) + ) + + def edit(r: RelayRound, form: Form[RelayRoundForm.Data], nav: FormNavigation)(using Context) = + page(r.name.value, nav): + val rt = r.withTour(nav.tour) + frag( + boxTop(h1(a(href := rt.path)(rt.fullName))), + inner(form, routes.RelayRound.update(r.id), nav.tour, create = false), div(cls := "relay-form__actions")( - postForm(action := routes.RelayRound.reset(rt.round.id))( + postForm(action := routes.RelayRound.reset(r.id))( submitButton( cls := "button button-red button-empty confirm" )( @@ -49,7 +103,7 @@ final class FormUi(helpers: Helpers, ui: RelayUi, tourUi: RelayTourUi): em(trb.deleteAllGamesOfThisRound()) ) ), - postForm(action := routes.Study.delete(rt.round.studyId))( + postForm(action := routes.Study.delete(r.studyId))( submitButton( cls := "button button-red button-empty confirm" )(strong(trb.deleteRound()), em(trb.definitivelyDeleteRound())) @@ -146,21 +200,18 @@ final class FormUi(helpers: Helpers, ui: RelayUi, tourUi: RelayTourUi): object tour: - private def page(title: String, menu: Option[String])(using Context) = + private def page(title: String, menu: Either[String, FormNavigation])(using Context) = Page(title) .css("bits.relay.form") .js(EsmInit("bits.relayForm")) .wrap: body => - menu match - case Some(active) => - main(cls := "page page-menu")( - tourUi.pageMenu(active), - div(cls := "page-menu__content box box-pad")(body) - ) - case None => main(cls := "page-small box box-pad")(body) + main(cls := "page page-menu")( + menu.fold(tourUi.pageMenu(_), navigationMenu), + div(cls := "page-menu__content box box-pad")(body) + ) def create(form: Form[lila.relay.RelayTourForm.Data])(using Context) = - page(trans.broadcast.newBroadcast.txt(), menu = "new".some): + page(trans.broadcast.newBroadcast.txt(), menu = Left("new")): frag( boxTop(h1(dataIcon := Icon.RadioTower, cls := "text")(trans.broadcast.newBroadcast())), postForm(cls := "form3", action := routes.RelayTour.create)( @@ -172,23 +223,19 @@ final class FormUi(helpers: Helpers, ui: RelayUi, tourUi: RelayTourUi): ) ) - def edit(tg: RelayTour.WithGroupTours, form: Form[RelayTourForm.Data])(using Context) = - page(tg.tour.name.value, menu = none): + def edit(form: Form[RelayTourForm.Data], nav: FormNavigation)(using Context) = + page(nav.tour.name.value, menu = Right(nav)): frag( - boxTop: - h1(dataIcon := Icon.Pencil, cls := "text"): - a(href := routes.RelayTour.show(tg.tour.slug, tg.tour.id))(tg.tour.name) - , - image(tg.tour), - postForm(cls := "form3", action := routes.RelayTour.update(tg.tour.id))( - inner(form, tg.some), + boxTop(h1(a(href := routes.RelayTour.show(nav.tour.slug, nav.tour.id))(nav.tour.name))), + postForm(cls := "form3", action := routes.RelayTour.update(nav.tour.id))( + inner(form, nav.tourWithGroup.some), form3.actions( - a(href := routes.RelayTour.show(tg.tour.slug, tg.tour.id))(trans.site.cancel()), + a(href := routes.RelayTour.show(nav.tour.slug, nav.tour.id))(trans.site.cancel()), form3.submit(trans.site.apply()) ) ), div(cls := "relay-form__actions")( - postForm(action := routes.RelayTour.delete(tg.tour.id))( + postForm(action := routes.RelayTour.delete(nav.tour.id))( submitButton( cls := "button button-red button-empty confirm" )(strong(trb.deleteTournament()), em(trb.definitivelyDeleteTournament())) @@ -196,7 +243,7 @@ final class FormUi(helpers: Helpers, ui: RelayUi, tourUi: RelayTourUi): Granter .opt(_.Relay) .option( - postForm(action := routes.RelayTour.cloneTour(tg.tour.id))( + postForm(action := routes.RelayTour.cloneTour(nav.tour.id))( submitButton( cls := "button button-green button-empty confirm" )( @@ -268,7 +315,7 @@ final class FormUi(helpers: Helpers, ui: RelayUi, tourUi: RelayTourUi): pre("player name / rating / title / new name"), "All values are optional. Example:", pre("""Magnus Carlsen / 2863 / GM -YouGotLittUp / 1890 / / Louis Litt""") + YouGotLittUp / 1890 / / Louis Litt""") ).some, half = true )(form3.textarea(_)(rows := 3)), @@ -280,7 +327,7 @@ YouGotLittUp / 1890 / / Louis Litt""") pre("Team name; Fide Id or Player name"), "Example:", pre("""Team Cats ; 3408230 -Team Dogs ; Scooby Doo"""), + Team Dogs ; Scooby Doo"""), "By default the PGN tags WhiteTeam and BlackTeam are used." ).some, half = true @@ -361,39 +408,39 @@ Team Dogs ; Scooby Doo"""), ) ) - private def image(t: RelayTour)(using ctx: Context) = - div(cls := "relay-image-edit", data("post-url") := routes.RelayTour.image(t.id))( - ui.thumbnail(t.image, _.Size.Small)( - cls := List("drop-target" -> true, "user-image" -> t.image.isDefined), - attr("draggable") := "true" + private def image(t: RelayTour)(using ctx: Context) = + div(cls := "relay-image-edit", data("post-url") := routes.RelayTour.image(t.id))( + ui.thumbnail(t.image, _.Size.Small)( + cls := List("drop-target" -> true, "user-image" -> t.image.isDefined), + attr("draggable") := "true" + ), + div( + p("Upload a beautiful image to represent your tournament."), + p("The image must be twice as wide as it is tall. Recommended resolution: 1000x500."), + p( + "A picture of the city where the tournament takes place is a good idea, but feel free to design something different." ), - div( - p("Upload a beautiful image to represent your tournament."), - p("The image must be twice as wide as it is tall. Recommended resolution: 1000x500."), - p( - "A picture of the city where the tournament takes place is a good idea, but feel free to design something different." - ), - p(trans.streamer.maxSize(s"${lila.memo.PicfitApi.uploadMaxMb}MB.")), - form3.file.selectImage() - ) + p(trans.streamer.maxSize(s"${lila.memo.PicfitApi.uploadMaxMb}MB.")), + form3.file.selectImage() ) + ) - def grouping(form: Form[RelayTourForm.Data])(using Context) = - form3.split(cls := "relay-form__grouping")( - form3.group( - form("grouping"), - "Optional: assign tournaments to a group", - half = true - )(form3.textarea(_)(rows := 5)), - div(cls := "form-group form-half form-help")( // do not translate - "First line is the group name. Subsequent lines are the tournament IDs and names in the group. Names are facultative and only used for display in this textarea.", - br, - "You can add, remove, and re-order tournaments; and you can rename the group.", - br, - "Example:", - pre("""Youth Championship 2024 + def grouping(form: Form[RelayTourForm.Data])(using Context) = + form3.split(cls := "relay-form__grouping")( + form3.group( + form("grouping"), + "Optional: assign tournaments to a group", + half = true + )(form3.textarea(_)(rows := 5)), + div(cls := "form-group form-half form-help")( // do not translate + "First line is the group name. Subsequent lines are the tournament IDs and names in the group. Names are facultative and only used for display in this textarea.", + br, + "You can add, remove, and re-order tournaments; and you can rename the group.", + br, + "Example:", + pre("""Youth Championship 2024 tour1-id Youth Championship 2024 | G20 tour2-id Youth Championship 2024 | G16 """) - ) ) + ) diff --git a/ui/analyse/src/study/relay/relayManagerView.ts b/ui/analyse/src/study/relay/relayManagerView.ts index e03f810adb5f8..21d7fbb86f598 100644 --- a/ui/analyse/src/study/relay/relayManagerView.ts +++ b/ui/analyse/src/study/relay/relayManagerView.ts @@ -14,17 +14,7 @@ export default function (ctrl: RelayCtrl, study: StudyCtrl): MaybeVNode { ? h('div.relay-admin', { hook: onInsert(_ => site.asset.loadCssPath('analyse.relay-admin')) }, [ h('h2', [ h('span.text', { attrs: dataIcon(licon.RadioTower) }, 'Broadcast manager'), - h('span', [ - h('a', { attrs: { href: `/broadcast/round/${ctrl.id}/edit`, 'data-icon': licon.Gear } }), - ' ', - h('a', { - attrs: { - href: `/broadcast/${ctrl.data.tour.id}/new`, - title: 'New round', - 'data-icon': licon.PlusButton, - }, - }), - ]), + h('a', { attrs: { href: `/broadcast/round/${ctrl.id}/edit`, 'data-icon': licon.Gear } }), ]), ctrl.data.sync?.url || ctrl.data.sync?.ids ? (ctrl.data.sync.ongoing ? stateOn : stateOff)(ctrl) diff --git a/ui/bits/css/relay/_form.scss b/ui/bits/css/relay/_form.scss index 5e2d055418f52..48e0c22d62b45 100644 --- a/ui/bits/css/relay/_form.scss +++ b/ui/bits/css/relay/_form.scss @@ -54,3 +54,29 @@ @extend %flex-between; } } + +@include mq-subnav-side { + .relay-form__subnav__group { + display: block; + margin-bottom: 1em; + font-weight: bold; + color: $c-font-dimmer; + } + .relay-form__subnav__tour-parent { + background: $c-bg-box; + border-radius: $box-radius-size 0 0 $box-radius-size; + } + .subnav { + width: 30ch; + a { + white-space: wrap; + } + .subnav__subitem { + margin-left: 1em; + } + .subnav__subitem2 { + margin-left: 2em; + letter-spacing: 0px; + } + } +} diff --git a/ui/bits/css/user/_show.scss b/ui/bits/css/user/_show.scss index 0f0276e1f266d..f0cc93d2c88f6 100644 --- a/ui/bits/css/user/_show.scss +++ b/ui/bits/css/user/_show.scss @@ -58,7 +58,7 @@ z-index: $z-link-overlay-2; visibility: hidden; background: $c-bg-header-dropdown; - border-radius: 3px 0 3px 3px; + border-radius: $box-radius-size 0 $box-radius-size $box-radius-size; position: absolute; top: 3rem; right: 0; @@ -72,10 +72,10 @@ font-size: 1.4em; } &:first-child { - border-radius: 3px 0 0 0; + border-radius: $box-radius-size 0 0 0; } &:last-child { - border-radius: 0 0 3px 3px; + @extend %box-radius-bottom; } &:hover { background: $c-primary; From bd12c53962caabce5bc043d8c81a04dd2655cd37 Mon Sep 17 00:00:00 2001 From: Thibault Duplessis Date: Mon, 17 Jun 2024 11:58:41 +0200 Subject: [PATCH 094/168] better permission denied pages for broadcast forms --- app/controllers/RelayRound.scala | 13 +++++++++++-- app/controllers/RelayTour.scala | 9 +++++---- modules/relay/src/main/RelayApi.scala | 8 +++++--- modules/relay/src/main/ui/FormUi.scala | 12 ++++++++++++ 4 files changed, 33 insertions(+), 9 deletions(-) diff --git a/app/controllers/RelayRound.scala b/app/controllers/RelayRound.scala index c1c2dade5058d..3fd3f37d5e7b2 100644 --- a/app/controllers/RelayRound.scala +++ b/app/controllers/RelayRound.scala @@ -52,8 +52,17 @@ final class RelayRound( } def edit(id: RelayRoundId) = Auth { ctx ?=> me ?=> - FoundPage(env.relay.api.formNavigation(id)): (round, nav) => - views.relay.form.round.edit(round, env.relay.roundForm.edit(round), nav) + env.relay.api + .byIdAndContributor(id) + .flatMap: + case None => + Found(env.relay.api.formNavigation(id)): (_, nav) => + Forbidden.page(views.relay.form.noAccess(nav)) + case Some(rt) => + env.relay.api + .formNavigation(rt) + .flatMap: (round, nav) => + Ok.page(views.relay.form.round.edit(round, env.relay.roundForm.edit(round), nav)) } def update(id: RelayRoundId) = AuthOrScopedBody(_.Study.Write) { ctx ?=> me ?=> diff --git a/app/controllers/RelayTour.scala b/app/controllers/RelayTour.scala index ec77fba160af9..1ea846a2b2e83 100644 --- a/app/controllers/RelayTour.scala +++ b/app/controllers/RelayTour.scala @@ -215,10 +215,11 @@ final class RelayTour(env: Env, apiC: => Api) extends LilaController(env): id: RelayTourId )(f: (FormNavigation) => Fu[Result])(using Context, Me): Fu[Result] = WithTour(id): tour => - env.relay.api - .canUpdate(tour) - .elseNotFound: - env.relay.api.formNavigation(tour).flatMap(f) + for + canUpdate <- env.relay.api.canUpdate(tour) + nav <- env.relay.api.formNavigation(tour) + res <- if canUpdate then f(nav) else Forbidden.page(views.relay.form.noAccess(nav)) + yield res private[controllers] def rateLimitCreation( fail: => Fu[Result] diff --git a/modules/relay/src/main/RelayApi.scala b/modules/relay/src/main/RelayApi.scala index a88a458f4069b..c7ab5f3e6fbb4 100644 --- a/modules/relay/src/main/RelayApi.scala +++ b/modules/relay/src/main/RelayApi.scala @@ -50,9 +50,11 @@ final class RelayApi( relay.withTour(tour) def formNavigation(id: RelayRoundId)(using me: Me): Fu[Option[(RelayRound, ui.FormNavigation)]] = - byIdAndContributor(id).flatMapz: rt => - formNavigation(rt.tour).map: nav => - (rt.round, nav.copy(round = rt.round.id.some)).some + byIdWithTour(id).flatMapz(rt => formNavigation(rt).dmap(some)) + + def formNavigation(rt: RelayRound.WithTour)(using me: Me): Fu[(RelayRound, ui.FormNavigation)] = + formNavigation(rt.tour).map: nav => + (rt.round, nav.copy(round = rt.round.id.some)) def formNavigation(tour: RelayTour)(using me: Me): Fu[ui.FormNavigation] = for group <- withTours.get(tour.id) diff --git a/modules/relay/src/main/ui/FormUi.scala b/modules/relay/src/main/ui/FormUi.scala index ae17b19facc46..8423f18f8c3d4 100644 --- a/modules/relay/src/main/ui/FormUi.scala +++ b/modules/relay/src/main/ui/FormUi.scala @@ -62,6 +62,18 @@ final class FormUi(helpers: Helpers, ui: RelayUi, tourUi: RelayTourUi): ) ) + def noAccess(nav: FormNavigation)(using Context) = + Page("Insufficient permissions") + .css("bits.relay.form") + .wrap: body => + main(cls := "page page-menu")( + navigationMenu(nav), + div(cls := "page-menu__content box box-pad")( + boxTop(h1("Insufficient permissions")), + p("You are not allowed to edit this broadcast or round.") + ) + ) + object round: private def page(title: String, nav: FormNavigation)(using Context) = From 6ea27c619742d1e50f2cc27dcfaacc46a8a7b89a Mon Sep 17 00:00:00 2001 From: Thibault Duplessis Date: Mon, 17 Jun 2024 14:32:35 +0200 Subject: [PATCH 095/168] guess new broadcast round settings based on previous 2 rounds --- modules/relay/src/main/RelayRoundForm.scala | 49 +++++++++++++++++---- 1 file changed, 41 insertions(+), 8 deletions(-) diff --git a/modules/relay/src/main/RelayRoundForm.scala b/modules/relay/src/main/RelayRoundForm.scala index ab4c1c246cc0d..9a952c8f55f90 100644 --- a/modules/relay/src/main/RelayRoundForm.scala +++ b/modules/relay/src/main/RelayRoundForm.scala @@ -38,24 +38,57 @@ final class RelayRoundForm(using mode: Mode): )(Data.apply)(unapply) .verifying("This source requires a round number. See the new form field below.", !_.roundMissing) - def create(trs: RelayTour.WithRounds) = Form { + def create(trs: RelayTour.WithRounds) = Form( roundMapping .verifying( s"Maximum rounds per tournament: ${RelayTour.maxRelays}", _ => trs.rounds.sizeIs < RelayTour.maxRelays ) - }.fill( - Data( - name = RelayRound.Name(s"Round ${trs.rounds.size + 1}"), - caption = none, - syncUrlRound = Some(trs.rounds.size + 1) - ) - ) + ).fill(fillFromPrevRounds(trs.rounds)) def edit(r: RelayRound) = Form(roundMapping).fill(Data.make(r)) object RelayRoundForm: + def fillFromPrevRounds(rounds: List[RelayRound]): Data = + val prevs: Option[(RelayRound, RelayRound)] = rounds.reverse match + case a :: b :: _ => (a, b).some + case _ => none + val prev: Option[RelayRound] = prevs.map(_._1) + val roundNumberRegex = """([^\d]*)(\d{1,2})([^\d]*)""".r + val roundNumberIn: String => Option[Int] = + case roundNumberRegex(_, n, _) => n.toIntOption + case _ => none + def replaceRoundNumber(s: String, n: Int): String = + roundNumberRegex.replaceAllIn(s, m => s"${m.group(1)}${n}${m.group(3)}") + val prevNumber: Option[Int] = prev.flatMap(p => roundNumberIn(p.name.value)) + val nextNumber = (prevNumber | rounds.size) + 1 + val guessName = for + n <- prevNumber + if prevs + .map(_._2) + .fold(true): old => + roundNumberIn(old.name.value).contains(n - 1) + p <- prev + yield replaceRoundNumber(p.name.value, nextNumber) + val nextUrl = + prev.flatMap(_.sync.upstream).flatMap(_.asUrl).map(_.withRound).filter(_.round.isDefined).map(_.url) + val guessDate = for + (prev, old) <- prevs + prevDate <- prev.startsAt + oldDate <- old.startsAt + delta = prevDate.toEpochMilli - oldDate.toEpochMilli + yield prevDate.plusMillis(delta) + Data( + name = RelayRound.Name(guessName | s"Round ${nextNumber}"), + caption = none, + syncUrl = nextUrl, + syncUrlRound = nextUrl.isDefined.option(nextNumber), + startsAt = guessDate, + period = prev.flatMap(_.sync.period), + delay = prev.flatMap(_.sync.delay) + ) + case class GameIds(ids: List[GameId]) private def toGameIds(ids: String): Option[GameIds] = From e757228a2b78acaa23716b4bc9191b3c9cbc821b Mon Sep 17 00:00:00 2001 From: Thibault Duplessis Date: Mon, 17 Jun 2024 14:39:57 +0200 Subject: [PATCH 096/168] redirect to round edit --- app/controllers/RelayRound.scala | 8 ++++++-- modules/relay/src/main/ui/FormUi.scala | 1 + 2 files changed, 7 insertions(+), 2 deletions(-) diff --git a/app/controllers/RelayRound.scala b/app/controllers/RelayRound.scala index 3fd3f37d5e7b2..69d57d93d6929 100644 --- a/app/controllers/RelayRound.scala +++ b/app/controllers/RelayRound.scala @@ -45,7 +45,7 @@ final class RelayRound( .create(setup, tour) .flatMap: rt => negotiate( - Redirect(routes.RelayRound.show(tour.slug, rt.relay.slug, rt.relay.id)), + Redirect(routes.RelayRound.edit(rt.relay.id)).flashSuccess, JsonOk(env.relay.jsonView.myRound(rt)) ) ) @@ -86,7 +86,11 @@ final class RelayRound( jsonFormError(err) ) }, - rt => negotiate(Redirect(rt.path), JsonOk(env.relay.jsonView.withUrl(rt, withTour = true))) + rt => + negotiate( + Redirect(routes.RelayRound.edit(id)).flashSuccess, + JsonOk(env.relay.jsonView.withUrl(rt, withTour = true)) + ) ) } diff --git a/modules/relay/src/main/ui/FormUi.scala b/modules/relay/src/main/ui/FormUi.scala index 8423f18f8c3d4..570253f0650c1 100644 --- a/modules/relay/src/main/ui/FormUi.scala +++ b/modules/relay/src/main/ui/FormUi.scala @@ -105,6 +105,7 @@ final class FormUi(helpers: Helpers, ui: RelayUi, tourUi: RelayTourUi): val rt = r.withTour(nav.tour) frag( boxTop(h1(a(href := rt.path)(rt.fullName))), + standardFlash, inner(form, routes.RelayRound.update(r.id), nav.tour, create = false), div(cls := "relay-form__actions")( postForm(action := routes.RelayRound.reset(r.id))( From 40777e754b52433833aaa515ff72bac89173a0d1 Mon Sep 17 00:00:00 2001 From: Thibault Duplessis Date: Mon, 17 Jun 2024 15:03:25 +0200 Subject: [PATCH 097/168] remove unused argument --- modules/relay/src/main/ui/RelayUi.scala | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/modules/relay/src/main/ui/RelayUi.scala b/modules/relay/src/main/ui/RelayUi.scala index 5e00bb851d9d8..7d551ed7ae657 100644 --- a/modules/relay/src/main/ui/RelayUi.scala +++ b/modules/relay/src/main/ui/RelayUi.scala @@ -24,8 +24,7 @@ final class RelayUi(helpers: Helpers)( rt: lila.relay.RelayRound.WithTourAndStudy, data: lila.relay.JsonView.JsData, chatOption: Option[(JsObject, Frag)], - socketVersion: lila.core.socket.SocketVersion, - crossSiteIsolation: Boolean = true + socketVersion: lila.core.socket.SocketVersion )(using ctx: Context) = Page(rt.fullName) .css("analyse.relay") From e51abf0f31e30467ef47d8fc372e00c0708d4bbb Mon Sep 17 00:00:00 2001 From: Thibault Duplessis Date: Mon, 17 Jun 2024 15:10:14 +0200 Subject: [PATCH 098/168] always guess url round number for first 2 rounds --- modules/relay/src/main/RelayRoundForm.scala | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/modules/relay/src/main/RelayRoundForm.scala b/modules/relay/src/main/RelayRoundForm.scala index 9a952c8f55f90..e036288a3af70 100644 --- a/modules/relay/src/main/RelayRoundForm.scala +++ b/modules/relay/src/main/RelayRoundForm.scala @@ -83,7 +83,7 @@ object RelayRoundForm: name = RelayRound.Name(guessName | s"Round ${nextNumber}"), caption = none, syncUrl = nextUrl, - syncUrlRound = nextUrl.isDefined.option(nextNumber), + syncUrlRound = (prevs.isEmpty || nextUrl.isDefined).option(nextNumber), startsAt = guessDate, period = prev.flatMap(_.sync.period), delay = prev.flatMap(_.sync.delay) From cc8dc78957e928c1da5844697656fee6e9de5c1d Mon Sep 17 00:00:00 2001 From: Thibault Duplessis Date: Mon, 17 Jun 2024 15:21:21 +0200 Subject: [PATCH 099/168] rewrite with for --- modules/security/src/main/EmailChange.scala | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/modules/security/src/main/EmailChange.scala b/modules/security/src/main/EmailChange.scala index a2cddab1b4631..8dfe31f52bb44 100644 --- a/modules/security/src/main/EmailChange.scala +++ b/modules/security/src/main/EmailChange.scala @@ -50,10 +50,11 @@ ${trans.common_orPaste.txt()} // also returns the previous email address def confirm(token: String): Fu[Option[(Me, Option[EmailAddress])]] = tokener.read(token).dmap(_.flatten).flatMapz { case TokenPayload(userId, email) => - userRepo.email(userId).flatMap { previous => - (userRepo.setEmail(userId, email).recoverDefault >> userRepo.me(userId)) - .map2(_ -> previous) - } + for + previous <- userRepo.email(userId) + _ <- userRepo.setEmail(userId, email).recoverDefault + me <- userRepo.me(userId) + yield me.map(_ -> previous) } case class TokenPayload(userId: UserId, email: EmailAddress) From 34ba5eff31305c9f4d91090d2767c4e968280d0f Mon Sep 17 00:00:00 2001 From: Thibault Duplessis Date: Mon, 17 Jun 2024 15:23:20 +0200 Subject: [PATCH 100/168] log email change --- modules/security/src/main/EmailChange.scala | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/modules/security/src/main/EmailChange.scala b/modules/security/src/main/EmailChange.scala index 8dfe31f52bb44..910345216ad88 100644 --- a/modules/security/src/main/EmailChange.scala +++ b/modules/security/src/main/EmailChange.scala @@ -54,7 +54,9 @@ ${trans.common_orPaste.txt()} previous <- userRepo.email(userId) _ <- userRepo.setEmail(userId, email).recoverDefault me <- userRepo.me(userId) - yield me.map(_ -> previous) + yield + logger.info(s"Set email for $id: $email") + me.map(_ -> previous) } case class TokenPayload(userId: UserId, email: EmailAddress) From 0c11e70b041ffe78dbb07e975e9b30b42ca85698 Mon Sep 17 00:00:00 2001 From: Thibault Duplessis Date: Mon, 17 Jun 2024 15:46:57 +0200 Subject: [PATCH 101/168] fix lobby ublog bg --- ui/lobby/css/_lobby.scss | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/ui/lobby/css/_lobby.scss b/ui/lobby/css/_lobby.scss index 3c4fc0eed7691..de05fd279966d 100644 --- a/ui/lobby/css/_lobby.scss +++ b/ui/lobby/css/_lobby.scss @@ -105,8 +105,11 @@ body { @extend %page-text-shadow !optional; font-size: 1.2em; } - .ublog-post-card:hover { - box-shadow: none; + .ublog-post-card { + background: $c-bg-box; + &:hover { + box-shadow: none; + } } } From 777f9bdfcbbc351a6067f13bea62910f02214e94 Mon Sep 17 00:00:00 2001 From: Thibault Duplessis Date: Mon, 17 Jun 2024 16:14:22 +0200 Subject: [PATCH 102/168] lobby pool buttons without borders --- ui/common/css/theme/_default.scss | 1 + ui/lobby/css/app/_pool.scss | 10 ++++++---- 2 files changed, 7 insertions(+), 4 deletions(-) diff --git a/ui/common/css/theme/_default.scss b/ui/common/css/theme/_default.scss index 33743f19086f3..2f4dd98fad6b3 100644 --- a/ui/common/css/theme/_default.scss +++ b/ui/common/css/theme/_default.scss @@ -122,4 +122,5 @@ $c-clearer: #fff; --c-good-move: #{$c-good-move}; --c-brilliant: #{$c-brilliant}; --c-interesting: #{$c-interesting}; + --c-pool-button: #{hsla($site-hue, 7%, 19%, 66%)}; } diff --git a/ui/lobby/css/app/_pool.scss b/ui/lobby/css/app/_pool.scss index fdfb119465b8f..18bf734a9ae3e 100644 --- a/ui/lobby/css/app/_pool.scss +++ b/ui/lobby/css/app/_pool.scss @@ -5,7 +5,9 @@ grid-template-columns: repeat(3, 1fr); grid-template-rows: repeat(4, 1fr); grid-gap: 9px; - padding: 9px; + padding-top: 9px; + background-color: transparent !important; + box-shadow: none; @include fluid-size('font-size', 14px, 25px); @@ -15,18 +17,18 @@ justify-content: center; align-items: center; cursor: pointer; - border: $border; - background: $m-font--fade-95; + background: $c-pool-button; @include if-light { background: $m-bg--fade-50; } - color: $c-font; + color: $c-font-dim; @include transition; &:hover { + color: $c-font; background: $m-accent--fade-80 !important; opacity: 1; } From 1a9c3431d496412c69d1c120d0888ca43afe9d22 Mon Sep 17 00:00:00 2001 From: Thibault Duplessis Date: Mon, 17 Jun 2024 16:23:10 +0200 Subject: [PATCH 103/168] fill round caption --- modules/relay/src/main/RelayRoundForm.scala | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/modules/relay/src/main/RelayRoundForm.scala b/modules/relay/src/main/RelayRoundForm.scala index e036288a3af70..a4578ba10f03a 100644 --- a/modules/relay/src/main/RelayRoundForm.scala +++ b/modules/relay/src/main/RelayRoundForm.scala @@ -81,7 +81,7 @@ object RelayRoundForm: yield prevDate.plusMillis(delta) Data( name = RelayRound.Name(guessName | s"Round ${nextNumber}"), - caption = none, + caption = prev.flatMap(_.caption), syncUrl = nextUrl, syncUrlRound = (prevs.isEmpty || nextUrl.isDefined).option(nextNumber), startsAt = guessDate, From 346d934da45d1badae484acb65fc2cd832d4e7e6 Mon Sep 17 00:00:00 2001 From: Thibault Duplessis Date: Mon, 17 Jun 2024 16:36:34 +0200 Subject: [PATCH 104/168] stop teaching study admins how to use broadcasts --- modules/relay/src/main/ui/FormUi.scala | 16 +++++++++------- 1 file changed, 9 insertions(+), 7 deletions(-) diff --git a/modules/relay/src/main/ui/FormUi.scala b/modules/relay/src/main/ui/FormUi.scala index 570253f0650c1..eda99f52892ed 100644 --- a/modules/relay/src/main/ui/FormUi.scala +++ b/modules/relay/src/main/ui/FormUi.scala @@ -129,12 +129,14 @@ final class FormUi(helpers: Helpers, ui: RelayUi, tourUi: RelayTourUi): ) = val isLcc = form("syncUrl").value.exists(RelayRound.Sync.UpstreamUrl.LccRegex.matches) postForm(cls := "form3", action := url)( - div(cls := "form-group")( - ui.howToUse, - (create && t.createdAt.isBefore(nowInstant.minusMinutes(1))).option: - p(dataIcon := Icon.InfoCircle, cls := "text"): - trb.theNewRoundHelp() - ), + (!Granter.opt(_.StudyAdmin)).option: + div(cls := "form-group")( + div(cls := "form-group")(ui.howToUse), + (create && t.createdAt.isBefore(nowInstant.minusMinutes(1))).option: + p(dataIcon := Icon.InfoCircle, cls := "text"): + trb.theNewRoundHelp() + ) + , form3.globalError(form), form3.split( form3.group(form("name"), trb.roundName(), half = true)(form3.input(_)(autofocus)), @@ -270,7 +272,7 @@ final class FormUi(helpers: Helpers, ui: RelayUi, tourUi: RelayTourUi): private def inner(form: Form[RelayTourForm.Data], tg: Option[RelayTour.WithGroupTours])(using Context) = frag( - div(cls := "form-group")(ui.howToUse), + (!Granter.opt(_.StudyAdmin)).option(div(cls := "form-group")(ui.howToUse)), form3.globalError(form), form3.split( form3.group(form("name"), trb.tournamentName(), half = true)(form3.input(_)(autofocus)), From f2e73393316108358d0d53dd22da4eacab2b5654 Mon Sep 17 00:00:00 2001 From: Thibault Duplessis Date: Mon, 17 Jun 2024 16:38:10 +0200 Subject: [PATCH 105/168] use translation --- modules/relay/src/main/ui/FormUi.scala | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/modules/relay/src/main/ui/FormUi.scala b/modules/relay/src/main/ui/FormUi.scala index eda99f52892ed..9dd2607ec0b72 100644 --- a/modules/relay/src/main/ui/FormUi.scala +++ b/modules/relay/src/main/ui/FormUi.scala @@ -46,7 +46,7 @@ final class FormUi(helpers: Helpers, ui: RelayUi, tourUi: RelayTourUi): href := routes.RelayRound.create(nav.tour.id), cls := List("subnav__subitem text" -> true, "active" -> nav.newRound), dataIcon := Icon.PlusButton - )("New round") + )(trb.addRound()) ) ) lila.ui.bits.pageMenuSubnav( @@ -92,7 +92,7 @@ final class FormUi(helpers: Helpers, ui: RelayUi, tourUi: RelayTourUi): boxTop( h1( a(href := routes.RelayTour.edit(nav.tour.id))(nav.tour.name), - " • ", + " / ", trans.broadcast.addRound() ) ), From d5186650afa75502ad8c3e1be07cc23ce191f8ef Mon Sep 17 00:00:00 2001 From: Thibault Duplessis Date: Mon, 17 Jun 2024 16:43:20 +0200 Subject: [PATCH 106/168] broadcast status icons in form navigation --- modules/relay/src/main/ui/FormUi.scala | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/modules/relay/src/main/ui/FormUi.scala b/modules/relay/src/main/ui/FormUi.scala index 9dd2607ec0b72..5bc04ed385ad6 100644 --- a/modules/relay/src/main/ui/FormUi.scala +++ b/modules/relay/src/main/ui/FormUi.scala @@ -40,7 +40,11 @@ final class FormUi(helpers: Helpers, ui: RelayUi, tourUi: RelayTourUi): nav.rounds.map: r => a( href := routes.RelayRound.edit(r.id), - cls := List("subnav__subitem" -> true, "active" -> nav.round.has(r.id)) + cls := List("subnav__subitem text" -> true, "active" -> nav.round.has(r.id)), + dataIcon := r.stateHash.match + case (_, true) => Icon.Checkmark + case (true, false) => Icon.DiscBig + case _ => Icon.DiscOutline )(r.name), a( href := routes.RelayRound.create(nav.tour.id), From 25e9fd2be9bd2eb59dc5d28b6f610a4a6ba04dd3 Mon Sep 17 00:00:00 2001 From: Thibault Duplessis Date: Mon, 17 Jun 2024 16:52:24 +0200 Subject: [PATCH 107/168] fix broadcast form navigation on new round page --- app/controllers/RelayRound.scala | 22 +++++++++++----------- modules/relay/src/main/RelayApi.scala | 6 +++--- modules/relay/src/main/ui/FormUi.scala | 7 ++----- 3 files changed, 16 insertions(+), 19 deletions(-) diff --git a/app/controllers/RelayRound.scala b/app/controllers/RelayRound.scala index 69d57d93d6929..57586cd408e68 100644 --- a/app/controllers/RelayRound.scala +++ b/app/controllers/RelayRound.scala @@ -20,29 +20,29 @@ final class RelayRound( def form(tourId: RelayTourId) = Auth { ctx ?=> _ ?=> NoLameOrBot: - WithTourAndRoundsCanUpdate(tourId): trs => + WithNavigationCanUpdate(tourId): nav => Ok.page: - views.relay.form.round.create(env.relay.roundForm.create(trs), FormNavigation(trs, none)) + views.relay.form.round + .create(env.relay.roundForm.create(nav.tourWithRounds), nav) } def create(tourId: RelayTourId) = AuthOrScopedBody(_.Study.Write) { ctx ?=> me ?=> NoLameOrBot: - WithTourAndRoundsCanUpdate(tourId): trs => - val tour = trs.tour + WithNavigationCanUpdate(tourId): nav => def whenRateLimited = negotiate( - Redirect(routes.RelayTour.show(tour.slug, tour.id)), + Redirect(routes.RelayTour.show(nav.tour.slug, nav.tour.id)), rateLimited ) - bindForm(env.relay.roundForm.create(trs))( + bindForm(env.relay.roundForm.create(nav.tourWithRounds))( err => negotiate( - BadRequest.page(views.relay.form.round.create(err, FormNavigation(trs, none))), + BadRequest.page(views.relay.form.round.create(err, nav)), jsonFormError(err) ), setup => rateLimitCreation(whenRateLimited): env.relay.api - .create(setup, tour) + .create(setup, nav.tour) .flatMap: rt => negotiate( Redirect(routes.RelayRound.edit(rt.relay.id)).flashSuccess, @@ -187,14 +187,14 @@ final class RelayRound( )(using Context): Fu[Result] = Found(env.relay.api.tourById(id))(f) - private def WithTourAndRoundsCanUpdate(id: RelayTourId)( - f: TourModel.WithRounds => Fu[Result] + private def WithNavigationCanUpdate(id: RelayTourId)( + f: FormNavigation => Fu[Result] )(using ctx: Context): Fu[Result] = WithTour(id): tour => ctx.me .soUse { env.relay.api.canUpdate(tour) } .elseNotFound: - env.relay.api.withRounds(tour).flatMap(f) + env.relay.api.formNavigation(tour).flatMap(f) private def doShow(rt: RoundModel.WithTour, oldSc: lila.study.Study.WithChapter, embed: Option[UserStr])( using ctx: Context diff --git a/modules/relay/src/main/RelayApi.scala b/modules/relay/src/main/RelayApi.scala index c7ab5f3e6fbb4..edeb6d4087f53 100644 --- a/modules/relay/src/main/RelayApi.scala +++ b/modules/relay/src/main/RelayApi.scala @@ -49,14 +49,14 @@ final class RelayApi( if study.canContribute(me) || Granter(_.StudyAdmin) => relay.withTour(tour) - def formNavigation(id: RelayRoundId)(using me: Me): Fu[Option[(RelayRound, ui.FormNavigation)]] = + def formNavigation(id: RelayRoundId): Fu[Option[(RelayRound, ui.FormNavigation)]] = byIdWithTour(id).flatMapz(rt => formNavigation(rt).dmap(some)) - def formNavigation(rt: RelayRound.WithTour)(using me: Me): Fu[(RelayRound, ui.FormNavigation)] = + def formNavigation(rt: RelayRound.WithTour): Fu[(RelayRound, ui.FormNavigation)] = formNavigation(rt.tour).map: nav => (rt.round, nav.copy(round = rt.round.id.some)) - def formNavigation(tour: RelayTour)(using me: Me): Fu[ui.FormNavigation] = for + def formNavigation(tour: RelayTour): Fu[ui.FormNavigation] = for group <- withTours.get(tour.id) rounds <- roundRepo.byTourOrdered(tour.id) yield ui.FormNavigation(group, tour, rounds, none) diff --git a/modules/relay/src/main/ui/FormUi.scala b/modules/relay/src/main/ui/FormUi.scala index 5bc04ed385ad6..a333161ef3460 100644 --- a/modules/relay/src/main/ui/FormUi.scala +++ b/modules/relay/src/main/ui/FormUi.scala @@ -15,11 +15,8 @@ case class FormNavigation( round: Option[RelayRoundId], newRound: Boolean = false ): - def tourWithGroup = RelayTour.WithGroupTours(tour, group) - -object FormNavigation: - def apply(trs: RelayTour.WithRounds, roundId: Option[RelayRoundId]): FormNavigation = - FormNavigation(none, trs.tour, trs.rounds, roundId) + def tourWithGroup = RelayTour.WithGroupTours(tour, group) + def tourWithRounds = RelayTour.WithRounds(tour, rounds) final class FormUi(helpers: Helpers, ui: RelayUi, tourUi: RelayTourUi): import helpers.{ *, given } From 1beb0fac39e51cb20609ea967ece4c688c0b2bd8 Mon Sep 17 00:00:00 2001 From: Thibault Duplessis Date: Mon, 17 Jun 2024 17:28:06 +0200 Subject: [PATCH 108/168] scala tweak --- modules/relay/src/main/ui/FormUi.scala | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/modules/relay/src/main/ui/FormUi.scala b/modules/relay/src/main/ui/FormUi.scala index a333161ef3460..5f92c7b225353 100644 --- a/modules/relay/src/main/ui/FormUi.scala +++ b/modules/relay/src/main/ui/FormUi.scala @@ -38,10 +38,11 @@ final class FormUi(helpers: Helpers, ui: RelayUi, tourUi: RelayTourUi): a( href := routes.RelayRound.edit(r.id), cls := List("subnav__subitem text" -> true, "active" -> nav.round.has(r.id)), - dataIcon := r.stateHash.match - case (_, true) => Icon.Checkmark - case (true, false) => Icon.DiscBig - case _ => Icon.DiscOutline + dataIcon := ( + if r.finished then Icon.Checkmark + else if r.hasStarted then Icon.DiscBig + else Icon.DiscOutline + ) )(r.name), a( href := routes.RelayRound.create(nav.tour.id), From 08248f4b18b2afd38642d83100a88582cb09f86d Mon Sep 17 00:00:00 2001 From: Thibault Duplessis Date: Mon, 17 Jun 2024 18:49:55 +0200 Subject: [PATCH 109/168] fix user dropdown RTL - closes #15528 --- ui/bits/css/user/_show.scss | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ui/bits/css/user/_show.scss b/ui/bits/css/user/_show.scss index f0cc93d2c88f6..d4e087579654a 100644 --- a/ui/bits/css/user/_show.scss +++ b/ui/bits/css/user/_show.scss @@ -61,7 +61,7 @@ border-radius: $box-radius-size 0 $box-radius-size $box-radius-size; position: absolute; top: 3rem; - right: 0; + @include inline-end(0); a { width: 20em; display: block; From 0a178ae88836a87916fdace97abc5d1c92ce5537 Mon Sep 17 00:00:00 2001 From: Thibault Duplessis Date: Mon, 17 Jun 2024 19:13:20 +0200 Subject: [PATCH 110/168] fix broadcast selector dropped shadow I couldn't figure out how to achieve it while keeping the text overflow ellipsis --- ui/analyse/css/study/relay/_tour.scss | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/ui/analyse/css/study/relay/_tour.scss b/ui/analyse/css/study/relay/_tour.scss index 2f15dc0c698db..efaa4b2d0d335 100644 --- a/ui/analyse/css/study/relay/_tour.scss +++ b/ui/analyse/css/study/relay/_tour.scss @@ -165,10 +165,10 @@ $hover-bg: $m-primary_bg--mix-30; } &__mselect { - @extend %ellipsis; position: unset; flex: auto; @include fluid-size('font-size', 12px, 20px); + white-space: wrap; &.mselect__active { overflow: visible; } @@ -193,6 +193,7 @@ $hover-bg: $m-primary_bg--mix-30; &__status { font-size: 1rem; margin-inline-end: 1ch; + white-space: nowrap; } &__label { .round-state { From 27b5238e1614e668715f15a8d8cab6d5892abef7 Mon Sep 17 00:00:00 2001 From: Thibault Duplessis Date: Mon, 17 Jun 2024 20:44:06 +0200 Subject: [PATCH 111/168] optimize relay stats storage by only recording new values --- modules/relay/src/main/RelayStatsApi.scala | 29 +++++++++++++++++----- 1 file changed, 23 insertions(+), 6 deletions(-) diff --git a/modules/relay/src/main/RelayStatsApi.scala b/modules/relay/src/main/RelayStatsApi.scala index 311a9ae6793cb..e02458ab49fbf 100644 --- a/modules/relay/src/main/RelayStatsApi.scala +++ b/modules/relay/src/main/RelayStatsApi.scala @@ -1,6 +1,7 @@ package lila.relay import lila.db.dsl.{ *, given } +import reactivemongo.api.bson.BSONInteger object RelayStats: type Minute = Int @@ -47,13 +48,29 @@ final class RelayStatsApi(roundRepo: RelayRoundRepo, colls: RelayColls)(using sc private def record(): Funit = for crowds <- fetchRoundCrowds nowMinutes = nowSeconds / 60 - update = colls.stats.update(ordered = false) - elements <- crowds.sequentially: (roundId, crowd) => - update.element( - q = $id(roundId), - u = $push("d" -> $doc("$each" -> $arr(nowMinutes, crowd))), - upsert = true + lastValuesDocs <- colls.stats.aggregateList(crowds.size): framework => + import framework.* + Match($inIds(crowds.map(_._1))) -> List( + Project($doc("last" -> $doc("$arrayElemAt" -> $arr("$d", -1)))) ) + lastValues = for + doc <- lastValuesDocs + last <- doc.getAsOpt[Crowd]("last") + id <- doc.getAsOpt[RelayRoundId]("_id") + yield (id, last) + lastValuesMap = lastValues.toMap + update = colls.stats.update(ordered = false) + elementOpts <- crowds.sequentially: (roundId, crowd) => + val lastValue = ~lastValuesMap.get(roundId) + (lastValue != crowd).so: + update + .element( + q = $id(roundId), + u = $push("d" -> $doc("$each" -> $arr(nowMinutes, crowd))), + upsert = true + ) + .dmap(some) + elements = elementOpts.flatten _ <- elements.nonEmpty.so(update.many(elements).void) yield () From fd01f5652dd0592f75704b4c475cb58445578045 Mon Sep 17 00:00:00 2001 From: Thibault Duplessis Date: Mon, 17 Jun 2024 20:44:44 +0200 Subject: [PATCH 112/168] extract ui/analyse glyphs to ui/chess --- pnpm-lock.yaml | 3 +++ ui/analyse/src/autoShape.ts | 4 +-- ui/chess/package.json | 3 ++- ui/{analyse => chess}/src/glyphs.ts | 38 ++++++++++++----------------- 4 files changed, 22 insertions(+), 26 deletions(-) rename ui/{analyse => chess}/src/glyphs.ts (90%) diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml index d3e1e761fb0ff..47e38a009a786 100644 --- a/pnpm-lock.yaml +++ b/pnpm-lock.yaml @@ -292,6 +292,9 @@ importers: ui/chess: dependencies: + chessops: + specifier: ^0.14.1 + version: 0.14.1 common: specifier: workspace:* version: link:../common diff --git a/ui/analyse/src/autoShape.ts b/ui/analyse/src/autoShape.ts index 38c0521d8d5cc..c47f9f8133137 100644 --- a/ui/analyse/src/autoShape.ts +++ b/ui/analyse/src/autoShape.ts @@ -4,7 +4,7 @@ import { winningChances } from 'ceval'; import * as cg from 'chessground/types'; import { opposite } from 'chessground/util'; import { DrawModifiers, DrawShape } from 'chessground/draw'; -import { annotationShapes } from './glyphs'; +import { annotationShapes } from 'chess/glyphs'; import AnalyseCtrl from './ctrl'; const pieceDrop = (key: cg.Key, role: cg.Role, color: Color): DrawShape => ({ @@ -122,7 +122,7 @@ export function compute(ctrl: AnalyseCtrl): DrawShape[] { } }); } - shapes = shapes.concat(annotationShapes(ctrl)); + if (ctrl.showMoveAnnotation()) shapes = shapes.concat(annotationShapes(ctrl.node)); if (ctrl.showVariationArrows()) hiliteVariations(ctrl, shapes); return shapes; } diff --git a/ui/chess/package.json b/ui/chess/package.json index d7fb184595928..cf863743a7091 100644 --- a/ui/chess/package.json +++ b/ui/chess/package.json @@ -25,6 +25,7 @@ "license": "AGPL-3.0-or-later", "dependencies": { "common": "workspace:*", - "snabbdom": "3.5.1" + "snabbdom": "3.5.1", + "chessops": "^0.14.1" } } diff --git a/ui/analyse/src/glyphs.ts b/ui/chess/src/glyphs.ts similarity index 90% rename from ui/analyse/src/glyphs.ts rename to ui/chess/src/glyphs.ts index e77172d6b2b62..47ae3409b6790 100644 --- a/ui/analyse/src/glyphs.ts +++ b/ui/chess/src/glyphs.ts @@ -1,11 +1,9 @@ import { parseUci, makeSquare, squareRank } from 'chessops/util'; -import AnalyseCtrl from './ctrl'; import { DrawShape } from 'chessground/draw'; -export function annotationShapes(ctrl: AnalyseCtrl): DrawShape[] { - const shapes: DrawShape[] = []; - const { uci, glyphs, san } = ctrl.node; - if (ctrl.showMoveAnnotation() && uci && san && glyphs && glyphs.length > 0) { +export function annotationShapes(node: Tree.Node): DrawShape[] { + const { uci, glyphs, san } = node; + if (uci && san && glyphs?.[0]) { const move = parseUci(uci)!; const destSquare = san.startsWith('O-O') // castle, short or long ? squareRank(move.to) === 0 // white castle @@ -17,29 +15,23 @@ export function annotationShapes(ctrl: AnalyseCtrl): DrawShape[] { : 'g8' : makeSquare(move.to); const prerendered = glyphToSvg[glyphs[0].symbol]; - shapes.push({ - orig: destSquare, - brush: prerendered ? '' : undefined, - customSvg: prerendered ? { html: prerendered } : undefined, - label: prerendered ? undefined : { text: glyphs[0].symbol, fill: 'purple' }, - // keep some purple just to keep feedback forum on their toes - }); - } - return shapes; + return [ + { + orig: destSquare, + brush: prerendered ? '' : undefined, + customSvg: prerendered ? { html: prerendered } : undefined, + label: prerendered ? undefined : { text: glyphs[0].symbol, fill: 'purple' }, + // keep some purple just to keep feedback forum on their toes + }, + ]; + } else return []; } // We can render glyphs as text, but people are used to these SVGs as the "Big 5" glyphs // and right now they look better const prependDropShadow = (svgBase: string) => - ` - - - - - -` + - svgBase + - ''; + ` +${svgBase}`; // NOTE: // Base svg was authored with Inkscape. // On Inkscape, by using "Object to Path", text is converted to path, which enables consistent layout on browser. From 4584d4fa89050f7eb57aa21ea90782b35db131e7 Mon Sep 17 00:00:00 2001 From: Thibault Duplessis Date: Mon, 17 Jun 2024 20:58:19 +0200 Subject: [PATCH 113/168] fix puzzle good move color --- ui/common/css/theme/_default.scss | 4 ++-- ui/common/css/theme/_light.scss | 2 +- ui/tree/css/_tree.scss | 4 ++-- 3 files changed, 5 insertions(+), 5 deletions(-) diff --git a/ui/common/css/theme/_default.scss b/ui/common/css/theme/_default.scss index 2f4dd98fad6b3..237e629dc7303 100644 --- a/ui/common/css/theme/_default.scss +++ b/ui/common/css/theme/_default.scss @@ -33,7 +33,7 @@ $c-shade: hsl(0, 0%, 30%); $c-inaccuracy: hsl(202, 78%, 62%); $c-mistake: hsl(41, 100%, 45%); $c-blunder: hsl(0, 69%, 60%); -$c-good-move: hsl(130, 67%, 62%); +$c-good: $c-secondary; $c-brilliant: hsl(129, 71%, 45%); $c-interesting: hsl(307, 80%, 70%); $c-dark: #333; @@ -119,7 +119,7 @@ $c-clearer: #fff; --c-inaccuracy: #{$c-inaccuracy}; --c-mistake: #{$c-mistake}; --c-blunder: #{$c-blunder}; - --c-good-move: #{$c-good-move}; + --c-good-move: #{$c-good}; --c-brilliant: #{$c-brilliant}; --c-interesting: #{$c-interesting}; --c-pool-button: #{hsla($site-hue, 7%, 19%, 66%)}; diff --git a/ui/common/css/theme/_light.scss b/ui/common/css/theme/_light.scss index 0b3a5a689bbc0..7eb701b3a1729 100644 --- a/ui/common/css/theme/_light.scss +++ b/ui/common/css/theme/_light.scss @@ -24,7 +24,7 @@ $c-shade: hsl(0, 0%, 84%); $c-inaccuracy: hsl(202, 78%, 40%); $c-mistake: hsl(41, 100%, 35%); $c-blunder: hsl(0, 68%, 50%); -$c-good-move: hsl(130, 67%, 40%); +$c-good: $c-secondary; $c-brilliant: hsl(129, 71%, 30%); $c-interesting: hsl(307, 80%, 59%); $c-dimmer: #fff; diff --git a/ui/tree/css/_tree.scss b/ui/tree/css/_tree.scss index 406581eeb43db..129196d651bbe 100644 --- a/ui/tree/css/_tree.scss +++ b/ui/tree/css/_tree.scss @@ -37,9 +37,9 @@ } } &.good { - color: $c-good-move; + color: $c-good; &:hover { - background: $m-good-move_bg--mix-30; + background: $m-good_bg--mix-30; } } &.brilliant { From 4caa0b9e6ff3c238f1366df9cb759ac9506de16f Mon Sep 17 00:00:00 2001 From: Thibault Duplessis Date: Mon, 17 Jun 2024 21:00:07 +0200 Subject: [PATCH 114/168] ui/puzzle typing --- ui/puzzle/src/view/tree.ts | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/ui/puzzle/src/view/tree.ts b/ui/puzzle/src/view/tree.ts index 9aaf8def95f54..73c98bfb3c179 100644 --- a/ui/puzzle/src/view/tree.ts +++ b/ui/puzzle/src/view/tree.ts @@ -21,9 +21,9 @@ interface Glyph { symbol: string; } -const autoScroll = throttle(150, (ctrl: PuzzleCtrl, el) => { - const cont = el.parentNode; - const target = el.querySelector('.active'); +const autoScroll = throttle(150, (ctrl: PuzzleCtrl, el: HTMLElement) => { + const cont = el.parentNode as HTMLElement; + const target = el.querySelector('.active') as HTMLElement | null; if (!target) { cont.scrollTop = ctrl.path === treePath.root ? 0 : 99999; return; From fdacb97428b0fddb06d912a6609a735bbd2e4e32 Mon Sep 17 00:00:00 2001 From: Thibault Duplessis Date: Mon, 17 Jun 2024 21:09:27 +0200 Subject: [PATCH 115/168] fix puzzle move tree autoScroll after #15488 --- ui/puzzle/src/view/tree.ts | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/ui/puzzle/src/view/tree.ts b/ui/puzzle/src/view/tree.ts index 73c98bfb3c179..7664e9c323d9c 100644 --- a/ui/puzzle/src/view/tree.ts +++ b/ui/puzzle/src/view/tree.ts @@ -28,7 +28,8 @@ const autoScroll = throttle(150, (ctrl: PuzzleCtrl, el: HTMLElement) => { cont.scrollTop = ctrl.path === treePath.root ? 0 : 99999; return; } - cont.scrollTop = target.offsetTop - cont.offsetHeight / 2 + target.offsetHeight; + const targetOffset = target.getBoundingClientRect().y - el.getBoundingClientRect().y; + cont.scrollTop = targetOffset - cont.offsetHeight / 2 + target.offsetHeight; }); function pathContains(ctx: Ctx, path: Tree.Path): boolean { From e6b9beabf09c5f8ebc74f8d142a4bcd11c4d7b78 Mon Sep 17 00:00:00 2001 From: Thibault Duplessis Date: Mon, 17 Jun 2024 21:21:24 +0200 Subject: [PATCH 116/168] fix lobby preload lpools is the tab that's loaded most of the time and it has no background --- app/views/lobby/bits.scala | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/app/views/lobby/bits.scala b/app/views/lobby/bits.scala index 6906963989872..ba745279203d9 100644 --- a/app/views/lobby/bits.scala +++ b/app/views/lobby/bits.scala @@ -8,7 +8,7 @@ object bits: val lobbyApp = div(cls := "lobby__app")( div(cls := "tabs-horiz")(span(nbsp)), - div(cls := "lobby__app__content") + div(cls := "lobby__app__content lpools") ) def underboards( From 98c335bf0367c1868015721276b082b360519fd5 Mon Sep 17 00:00:00 2001 From: Thibault Duplessis Date: Mon, 17 Jun 2024 21:22:14 +0200 Subject: [PATCH 117/168] fix css var --- ui/common/css/component/_lichess-pgn-viewer.scss | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ui/common/css/component/_lichess-pgn-viewer.scss b/ui/common/css/component/_lichess-pgn-viewer.scss index 6d0e86d9c7990..30f918240adda 100644 --- a/ui/common/css/component/_lichess-pgn-viewer.scss +++ b/ui/common/css/component/_lichess-pgn-viewer.scss @@ -27,7 +27,7 @@ --c-lpv-bg-inaccuracy-hover: #{$m-inaccuracy_bg--mix-30}; --c-lpv-bg-mistake-hover: #{$m-mistake_bg--mix-30}; --c-lpv-bg-blunder-hover: #{$m-blunder_bg--mix-30}; - --c-lpv-bg-good-hover: #{$m-good-move_bg--mix-30}; + --c-lpv-bg-good-hover: #{$m-good_bg--mix-30}; --c-lpv-bg-brilliant-hover: #{$m-brilliant_bg--mix-30}; --c-lpv-bg-interesting-hover: #{$m-interesting_bg--mix-30}; From 59094af7e011f1c486f85981377c743f1c7bfb67 Mon Sep 17 00:00:00 2001 From: Thibault Duplessis Date: Mon, 17 Jun 2024 22:06:27 +0200 Subject: [PATCH 118/168] show puzzle glyphs over the board - closes #15379 --- ui/chess/src/glyphs.ts | 10 ++++++++-- ui/puzzle/src/autoShape.ts | 25 +++++++++++++++---------- ui/puzzle/src/ctrl.ts | 5 ++++- ui/puzzle/src/view/tree.ts | 4 +--- ui/tree/css/_tree.scss | 3 +++ 5 files changed, 31 insertions(+), 16 deletions(-) diff --git a/ui/chess/src/glyphs.ts b/ui/chess/src/glyphs.ts index 47ae3409b6790..0c3bf5cb6c77a 100644 --- a/ui/chess/src/glyphs.ts +++ b/ui/chess/src/glyphs.ts @@ -14,19 +14,25 @@ export function annotationShapes(node: Tree.Node): DrawShape[] { ? 'c8' : 'g8' : makeSquare(move.to); - const prerendered = glyphToSvg[glyphs[0].symbol]; + const symbol = glyphs[0].symbol; + const prerendered = glyphToSvg[symbol]; return [ { orig: destSquare, brush: prerendered ? '' : undefined, customSvg: prerendered ? { html: prerendered } : undefined, - label: prerendered ? undefined : { text: glyphs[0].symbol, fill: 'purple' }, + label: prerendered ? undefined : { text: symbol, fill: fills[symbol] || 'purple' }, // keep some purple just to keep feedback forum on their toes }, ]; } else return []; } +const fills: { [key: string]: string } = { + '✓': '#168226', + '✗': '#df5353', +}; + // We can render glyphs as text, but people are used to these SVGs as the "Big 5" glyphs // and right now they look better const prependDropShadow = (svgBase: string) => diff --git a/ui/puzzle/src/autoShape.ts b/ui/puzzle/src/autoShape.ts index 5e98eca04c4c1..66f9fa129fcc1 100644 --- a/ui/puzzle/src/autoShape.ts +++ b/ui/puzzle/src/autoShape.ts @@ -1,4 +1,5 @@ import { winningChances, CevalCtrl } from 'ceval'; +import { annotationShapes } from 'chess/glyphs'; import { DrawModifiers, DrawShape } from 'chessground/draw'; import { Api as CgApi } from 'chessground/api'; import { opposite, parseUci, makeSquare } from 'chessops/util'; @@ -42,14 +43,8 @@ export default function (opts: Opts): DrawShape[] { let nextBest: Uci | undefined = opts.nextNodeBest(); if (!nextBest && opts.ceval.enabled() && n.ceval) nextBest = n.ceval.pvs[0].moves[0]; if (nextBest) shapes = shapes.concat(makeAutoShapesFromUci(color, nextBest, 'paleBlue')); - if ( - opts.ceval.enabled() && - n.ceval && - n.ceval.pvs && - n.ceval.pvs[1] && - !(opts.threatMode() && n.threat && n.threat.pvs[2]) - ) { - n.ceval.pvs.forEach(function (pv) { + if (opts.ceval.enabled() && n.ceval?.pvs?.[1] && !(opts.threatMode() && n.threat?.pvs[2])) { + n.ceval.pvs.forEach(pv => { if (pv.moves[0] === nextBest) return; const shift = winningChances.povDiff(color, n.ceval!.pvs[0], pv); if (shift > 0.2 || isNaN(shift) || shift < 0) return; @@ -65,7 +60,7 @@ export default function (opts: Opts): DrawShape[] { if (opts.ceval.enabled() && opts.threatMode() && n.threat) { if (n.threat.pvs[1]) { shapes = shapes.concat(makeAutoShapesFromUci(opposite(color), n.threat.pvs[0].moves[0], 'paleRed')); - n.threat.pvs.slice(1).forEach(function (pv) { + n.threat.pvs.slice(1).forEach(pv => { const shift = winningChances.povDiff(opposite(color), pv, n.threat!.pvs[0]); if (shift > 0.2 || isNaN(shift) || shift < 0) return; shapes = shapes.concat( @@ -76,5 +71,15 @@ export default function (opts: Opts): DrawShape[] { }); } else shapes = shapes.concat(makeAutoShapesFromUci(opposite(color), n.threat.pvs[0].moves[0], 'red')); } - return shapes; + let glyph: Tree.Glyph | undefined; + switch (n.puzzle) { + case 'good': + case 'win': + glyph = { id: 7, name: 'good', symbol: '✓' }; + break; + case 'fail': + glyph = { id: 4, name: 'fail', symbol: '✗' }; + } + const withPuzzleGlyphs = glyph ? { ...n, glyphs: [glyph] } : n; + return shapes.concat(annotationShapes(withPuzzleGlyphs)); } diff --git a/ui/puzzle/src/ctrl.ts b/ui/puzzle/src/ctrl.ts index 7b5ccfc82f2ed..01d7ecfef6d9b 100755 --- a/ui/puzzle/src/ctrl.ts +++ b/ui/puzzle/src/ctrl.ts @@ -255,7 +255,10 @@ export default class PuzzleCtrl implements ParentCtrl { return config; }; - showGround = (g: CgApi): void => g.set(this.makeCgOpts()); + showGround = (g: CgApi): void => { + g.set(this.makeCgOpts()); + this.setAutoShapes(); + }; pluginMove = (orig: Key, dest: Key, role?: Role) => { if (role) this.playUserMove(orig, dest, role); diff --git a/ui/puzzle/src/view/tree.ts b/ui/puzzle/src/view/tree.ts index 7664e9c323d9c..493cc2b8eb8c6 100644 --- a/ui/puzzle/src/view/tree.ts +++ b/ui/puzzle/src/view/tree.ts @@ -100,9 +100,7 @@ function renderMainlineMoveOf(ctx: Ctx, node: Tree.Node, opts: RenderOpts): VNod return h('move', { attrs: { p: path }, class: classes }, renderMove(ctx, node)); } -function renderGlyph(glyph: Glyph): VNode { - return h('glyph', { attrs: { title: glyph.name } }, glyph.symbol); -} +const renderGlyph = (glyph: Glyph): VNode => h('glyph', { attrs: { title: glyph.name } }, glyph.symbol); function puzzleGlyph(ctx: Ctx, node: Tree.Node): MaybeVNode { switch (node.puzzle) { diff --git a/ui/tree/css/_tree.scss b/ui/tree/css/_tree.scss index 129196d651bbe..feb399aab18d4 100644 --- a/ui/tree/css/_tree.scss +++ b/ui/tree/css/_tree.scss @@ -38,18 +38,21 @@ } &.good { color: $c-good; + font-weight: bold; &:hover { background: $m-good_bg--mix-30; } } &.brilliant { color: $c-brilliant; + font-weight: bold; &:hover { background: $m-brilliant_bg--mix-30; } } &.interesting { color: $c-interesting; + font-weight: bold; &:hover { background: $m-interesting_bg--mix-30; } From 1fe946bdee80db6ae98ae156427340f210054834 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?S=C3=A9rgio=20Gl=C3=B3rias?= Date: Mon, 17 Jun 2024 20:17:49 +0000 Subject: [PATCH 119/168] Use translete --- modules/web/src/main/ui/TopNav.scala | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/modules/web/src/main/ui/TopNav.scala b/modules/web/src/main/ui/TopNav.scala index 17e0aa3fb2de2..537b2a5366dc2 100644 --- a/modules/web/src/main/ui/TopNav.scala +++ b/modules/web/src/main/ui/TopNav.scala @@ -39,7 +39,7 @@ final class TopNav(helpers: Helpers): linkTitle(puzzleUrl, trans.site.puzzles()), div(role := "group")( a(href := puzzleUrl)(trans.site.puzzles()), - a(href := langHref(routes.Puzzle.themes))("Puzzle Themes"), + a(href := langHref(routes.Puzzle.themes))(trans.puzzle.puzzleThemes()), a(href := routes.Puzzle.dashboard(30, "home", none))(trans.puzzle.puzzleDashboard()), a(href := langHref(routes.Puzzle.streak))("Puzzle Streak"), a(href := langHref(routes.Storm.home))("Puzzle Storm"), From 21a65f0f308b185ce6aeb7e52dd67455bdfe7103 Mon Sep 17 00:00:00 2001 From: Thibault Duplessis Date: Mon, 17 Jun 2024 23:55:20 +0200 Subject: [PATCH 120/168] bump broadcast max delay to 1h --- modules/relay/src/main/RelayDelay.scala | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/modules/relay/src/main/RelayDelay.scala b/modules/relay/src/main/RelayDelay.scala index bdda1e47590e8..ee90565ae3e9f 100644 --- a/modules/relay/src/main/RelayDelay.scala +++ b/modules/relay/src/main/RelayDelay.scala @@ -84,6 +84,6 @@ final private class RelayDelay(colls: RelayColls)(using Executor): _.flatMap(_.getAsOpt[PgnStr]("pgn")) private object RelayDelay: - val maxSeconds = Seconds(1800) + val maxSeconds = Seconds(60 * 60) private case class GamesSeenBy(games: Fu[RelayGames], seenBy: Set[RelayRoundId]) From 13e68ab3e557103143aa760ca1bc9f7a51b7d47e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=C4=90inh=20Ho=C3=A0ng=20Vi=E1=BB=87t?= <134517889+M-DinhHoangViet@users.noreply.github.com> Date: Tue, 18 Jun 2024 10:33:19 +0700 Subject: [PATCH 121/168] Align multi-line text next to icon --- ui/bits/css/user/_show.scss | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ui/bits/css/user/_show.scss b/ui/bits/css/user/_show.scss index d4e087579654a..1e47ada555f60 100644 --- a/ui/bits/css/user/_show.scss +++ b/ui/bits/css/user/_show.scss @@ -64,7 +64,7 @@ @include inline-end(0); a { width: 20em; - display: block; + display: flex; padding: 0.7rem 1rem; color: $c-header-dropdown; &::before { From 8cbc395581a2c5e088bd01940c601c3841590501 Mon Sep 17 00:00:00 2001 From: Thibault Duplessis Date: Tue, 18 Jun 2024 07:46:21 +0200 Subject: [PATCH 122/168] New Crowdin updates (#15540) * New translations: site.xml (French) * New translations: site.xml (Dutch) --- translation/dest/site/fr-FR.xml | 3 ++- translation/dest/site/nl-NL.xml | 2 ++ 2 files changed, 4 insertions(+), 1 deletion(-) diff --git a/translation/dest/site/fr-FR.xml b/translation/dest/site/fr-FR.xml index 117f82cc56078..a53b18564860f 100644 --- a/translation/dest/site/fr-FR.xml +++ b/translation/dest/site/fr-FR.xml @@ -70,7 +70,8 @@ Promouvoir la variante En faire la variante principale Supprimer à partir d\'ici - Afficher les variantes + Fermer les variantes + Afficher les variantes Forcer la variante Copier le PGN de la variante Coup diff --git a/translation/dest/site/nl-NL.xml b/translation/dest/site/nl-NL.xml index 1182ab32dca32..6de9fd1f1ec8c 100644 --- a/translation/dest/site/nl-NL.xml +++ b/translation/dest/site/nl-NL.xml @@ -70,6 +70,8 @@ Promoveer variant Maak hoofdvariant Verwijder vanaf hier + Varianten verbergen + Varianten weergeven Forceer variatie Kopieer variatie PGN Zet From 156e1e148765ad9001587f97da690ddedee6ac41 Mon Sep 17 00:00:00 2001 From: Thibault Duplessis Date: Tue, 18 Jun 2024 09:04:36 +0200 Subject: [PATCH 123/168] earlier start for delayed broadcast rounds --- modules/relay/src/main/RelayApi.scala | 19 +++++++++++-------- 1 file changed, 11 insertions(+), 8 deletions(-) diff --git a/modules/relay/src/main/RelayApi.scala b/modules/relay/src/main/RelayApi.scala index edeb6d4087f53..5c9cc8eced7c3 100644 --- a/modules/relay/src/main/RelayApi.scala +++ b/modules/relay/src/main/RelayApi.scala @@ -392,17 +392,21 @@ final class RelayApi( .list[RelayRound]( $doc( "startsAt" - .$lt(nowInstant.plusMinutes(30)) // start 30 minutes early to fetch boards - .$gt(nowInstant.minusDays(1)), // bit late now + // start early to fetch boards + .$lt(nowInstant.plusSeconds(RelayDelay.maxSeconds.value)) + .$gt(nowInstant.minusDays(1)), // bit late now "startedAt".$exists(false), "sync.until".$exists(false) ) ) .flatMap: - _.sequentiallyVoid { relay => - logger.info(s"Automatically start $relay") - requestPlay(relay.id, v = true) - } + _.sequentiallyVoid: relay => + val earlyMinutes = Math.min(60, 30 + relay.sync.delay.so(_.value / 60)) + relay.startsAt + .exists(_.isBefore(nowInstant.plusMinutes(earlyMinutes))) + .so: + logger.info(s"Automatically start $relay") + requestPlay(relay.id, v = true) private[relay] def autoFinishNotSyncing: Funit = roundRepo.coll @@ -417,10 +421,9 @@ final class RelayApi( ) ) .flatMap: - _.sequentiallyVoid { relay => + _.sequentiallyVoid: relay => logger.info(s"Automatically finish $relay") update(relay)(_.finish) - } private[relay] def WithRelay[A: Zero](id: RelayRoundId)(f: RelayRound => Fu[A]): Fu[A] = byId(id).flatMapz(f) From 8ac885be32b0c4733d4a0ca2042a211bcc8431d4 Mon Sep 17 00:00:00 2001 From: Thibault Duplessis Date: Tue, 18 Jun 2024 09:06:53 +0200 Subject: [PATCH 124/168] only auto-start broadcast rounds with sync.upstream --- modules/relay/src/main/RelayApi.scala | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/modules/relay/src/main/RelayApi.scala b/modules/relay/src/main/RelayApi.scala index 5c9cc8eced7c3..5f4485d92583d 100644 --- a/modules/relay/src/main/RelayApi.scala +++ b/modules/relay/src/main/RelayApi.scala @@ -396,7 +396,8 @@ final class RelayApi( .$lt(nowInstant.plusSeconds(RelayDelay.maxSeconds.value)) .$gt(nowInstant.minusDays(1)), // bit late now "startedAt".$exists(false), - "sync.until".$exists(false) + "sync.until".$exists(false), + "sync.upstream".$exists(true) ) ) .flatMap: From 59a56f06ecc8df381022a1bdf738f9da941c1f7b Mon Sep 17 00:00:00 2001 From: Thibault Duplessis Date: Tue, 18 Jun 2024 10:26:03 +0200 Subject: [PATCH 125/168] fix broadcast form lacks image field --- modules/relay/src/main/ui/FormUi.scala | 1 + 1 file changed, 1 insertion(+) diff --git a/modules/relay/src/main/ui/FormUi.scala b/modules/relay/src/main/ui/FormUi.scala index 5f92c7b225353..0fc8b62c27e42 100644 --- a/modules/relay/src/main/ui/FormUi.scala +++ b/modules/relay/src/main/ui/FormUi.scala @@ -244,6 +244,7 @@ final class FormUi(helpers: Helpers, ui: RelayUi, tourUi: RelayTourUi): page(nav.tour.name.value, menu = Right(nav)): frag( boxTop(h1(a(href := routes.RelayTour.show(nav.tour.slug, nav.tour.id))(nav.tour.name))), + image(nav.tour), postForm(cls := "form3", action := routes.RelayTour.update(nav.tour.id))( inner(form, nav.tourWithGroup.some), form3.actions( From 4fbafb6f2ab74f6f365089e16c246951d4ae288c Mon Sep 17 00:00:00 2001 From: Thibault Duplessis Date: Tue, 18 Jun 2024 10:32:49 +0200 Subject: [PATCH 126/168] align user dropdown icons --- ui/bits/css/user/_show.scss | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ui/bits/css/user/_show.scss b/ui/bits/css/user/_show.scss index 1e47ada555f60..66f4531ebcfa7 100644 --- a/ui/bits/css/user/_show.scss +++ b/ui/bits/css/user/_show.scss @@ -63,8 +63,8 @@ top: 3rem; @include inline-end(0); a { + @extend %flex-center-nowrap; width: 20em; - display: flex; padding: 0.7rem 1rem; color: $c-header-dropdown; &::before { From 9eb36d0c338fcb31ebde39d5739a5a080a9f6aa0 Mon Sep 17 00:00:00 2001 From: Thibault Duplessis Date: Tue, 18 Jun 2024 10:58:01 +0200 Subject: [PATCH 127/168] more subtle lobby pool start loading screen --- ui/lobby/src/view/main.ts | 5 +++-- ui/lobby/src/view/pools.ts | 6 +++--- 2 files changed, 6 insertions(+), 5 deletions(-) diff --git a/ui/lobby/src/view/main.ts b/ui/lobby/src/view/main.ts index 8fc5228b8f213..6991babedccbe 100644 --- a/ui/lobby/src/view/main.ts +++ b/ui/lobby/src/view/main.ts @@ -10,7 +10,8 @@ import LobbyController from '../ctrl'; export default function (ctrl: LobbyController) { let body, data: VNodeData = {}; - if (ctrl.redirecting) body = spinner(); + const redirBlock = ctrl.redirecting && ctrl.tab != 'pools'; + if (redirBlock) body = spinner(); else switch (ctrl.tab) { case 'pools': @@ -29,6 +30,6 @@ export default function (ctrl: LobbyController) { } return h('div.lobby__app.lobby__app-' + ctrl.tab, [ h('div.tabs-horiz', { attrs: { role: 'tablist' } }, renderTabs(ctrl)), - h('div.lobby__app__content.l' + (ctrl.redirecting ? 'redir' : ctrl.tab), data, body), + h(`div.lobby__app__content.l${redirBlock ? 'redir' : ctrl.tab}`, data, body), ]); } diff --git a/ui/lobby/src/view/pools.ts b/ui/lobby/src/view/pools.ts index db41d3293e32c..e0767ab8911ad 100644 --- a/ui/lobby/src/view/pools.ts +++ b/ui/lobby/src/view/pools.ts @@ -3,10 +3,11 @@ import { spinnerVdom as spinner } from 'common/spinner'; import { bind } from 'common/snabbdom'; import LobbyController from '../ctrl'; -export function hooks(ctrl: LobbyController): Hooks { - return bind( +export const hooks = (ctrl: LobbyController): Hooks => + bind( 'click', e => { + if (ctrl.redirecting) return; const id = (e.target as HTMLElement).dataset['id'] || ((e.target as HTMLElement).parentNode as HTMLElement).dataset['id']; @@ -15,7 +16,6 @@ export function hooks(ctrl: LobbyController): Hooks { }, ctrl.redraw, ); -} export function render(ctrl: LobbyController) { const member = ctrl.poolMember; From ede45dd70f8e0d8728f96a3d95c8d2ec5dd9aa1d Mon Sep 17 00:00:00 2001 From: Thibault Duplessis Date: Tue, 18 Jun 2024 11:05:53 +0200 Subject: [PATCH 128/168] lobby pool css tweaks --- ui/lobby/css/app/_pool.scss | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/ui/lobby/css/app/_pool.scss b/ui/lobby/css/app/_pool.scss index 18bf734a9ae3e..8165ebdd83423 100644 --- a/ui/lobby/css/app/_pool.scss +++ b/ui/lobby/css/app/_pool.scss @@ -8,6 +8,7 @@ padding-top: 9px; background-color: transparent !important; box-shadow: none; + overflow: visible !important; // for button shadows @include fluid-size('font-size', 14px, 25px); @@ -36,7 +37,6 @@ .active { @extend %popup-shadow; - @include back-blur(); // for all themes, not just transp .perf { display: none; @@ -44,7 +44,7 @@ } .transp { - opacity: 0.4; + opacity: 0.35; } .spinner { From 4ea5af0297e5ed3a6c61b86294fe5a9a071f5ff0 Mon Sep 17 00:00:00 2001 From: Thibault Duplessis Date: Tue, 18 Jun 2024 11:30:34 +0200 Subject: [PATCH 129/168] TS code golf --- ui/lobby/src/view/pools.ts | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/ui/lobby/src/view/pools.ts b/ui/lobby/src/view/pools.ts index e0767ab8911ad..67cd9de24b33d 100644 --- a/ui/lobby/src/view/pools.ts +++ b/ui/lobby/src/view/pools.ts @@ -21,12 +21,12 @@ export function render(ctrl: LobbyController) { const member = ctrl.poolMember; return ctrl.pools .map(pool => { - const active = !!member && member.id === pool.id, + const active = member?.id === pool.id, transp = !!member && !active; return h( 'div', { - class: { active, transp: !active && transp }, + class: { active, transp }, attrs: { role: 'button', 'data-id': pool.id }, }, [ From 49a91e034db59167480665f3d32c5f9ddec3949d Mon Sep 17 00:00:00 2001 From: Thibault Duplessis Date: Tue, 18 Jun 2024 11:30:53 +0200 Subject: [PATCH 130/168] don't show that pool is left while redirecting to new game --- ui/lobby/src/lobby.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ui/lobby/src/lobby.ts b/ui/lobby/src/lobby.ts index d6728ecd7de95..50b37ae5cf247 100644 --- a/ui/lobby/src/lobby.ts +++ b/ui/lobby/src/lobby.ts @@ -42,8 +42,8 @@ export function initModule(opts: LobbyOpts) { site.contentLoaded(); }, redirect(e: RedirectTo) { - lobbyCtrl.leavePool(); lobbyCtrl.setRedirecting(); + lobbyCtrl.leavePool(); site.redirect(e, true); return true; }, From 0126c9bef4250efc1b435a2b561b5b0ee1c481c6 Mon Sep 17 00:00:00 2001 From: Thibault Duplessis Date: Tue, 18 Jun 2024 12:34:19 +0200 Subject: [PATCH 131/168] fix user actions in blind mode - after #15260 - closes #15545 --- ui/bits/css/user/_show.scss | 3 +++ 1 file changed, 3 insertions(+) diff --git a/ui/bits/css/user/_show.scss b/ui/bits/css/user/_show.scss index 66f4531ebcfa7..44eb3a1a8827a 100644 --- a/ui/bits/css/user/_show.scss +++ b/ui/bits/css/user/_show.scss @@ -62,6 +62,9 @@ position: absolute; top: 3rem; @include inline-end(0); + body.blind-mode & { + visibility: visible; + } a { @extend %flex-center-nowrap; width: 20em; From 176832738a8127edd7c09956bf8a4fd253e63735 Mon Sep 17 00:00:00 2001 From: Thibault Duplessis Date: Tue, 18 Jun 2024 12:34:36 +0200 Subject: [PATCH 132/168] fix user actions style --- ui/bits/css/user/_show.scss | 14 ++++++++------ 1 file changed, 8 insertions(+), 6 deletions(-) diff --git a/ui/bits/css/user/_show.scss b/ui/bits/css/user/_show.scss index 44eb3a1a8827a..39864cfd5d664 100644 --- a/ui/bits/css/user/_show.scss +++ b/ui/bits/css/user/_show.scss @@ -74,12 +74,6 @@ margin-inline: 0 1rem; font-size: 1.4em; } - &:first-child { - border-radius: $box-radius-size 0 0 0; - } - &:last-child { - @extend %box-radius-bottom; - } &:hover { background: $c-primary; &, @@ -88,6 +82,14 @@ } } } + > a { + &:first-child { + border-radius: $box-radius-size 0 0 0; + } + &:last-child { + @extend %box-radius-bottom; + } + } } &:hover { > a { From 8dee6e213969b7c2f910082b595598d17de7afd4 Mon Sep 17 00:00:00 2001 From: Thibault Duplessis Date: Tue, 18 Jun 2024 14:44:58 +0200 Subject: [PATCH 133/168] fix /opening/tree js data - closes #15547 --- modules/opening/src/main/ui/OpeningBits.scala | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/modules/opening/src/main/ui/OpeningBits.scala b/modules/opening/src/main/ui/OpeningBits.scala index 79ea81800c68e..4457a12a7b3b8 100644 --- a/modules/opening/src/main/ui/OpeningBits.scala +++ b/modules/opening/src/main/ui/OpeningBits.scala @@ -1,7 +1,7 @@ package lila.opening package ui -import play.api.libs.json.Json +import play.api.libs.json.* import chess.opening.{ Opening, OpeningKey } import lila.ui.* @@ -15,7 +15,7 @@ final class OpeningBits(helpers: Helpers): def pageModule(page: Option[OpeningPage])(using Context) = PageModule( "opening", - page.so: p => + page.fold(JsNull): p => import lila.common.Json.given Json.obj("history" -> p.explored.so[List[Float]](_.history), "sans" -> p.query.sans) ) From cac60a4b59bc38b636959344d03f9e736255ab1d Mon Sep 17 00:00:00 2001 From: Thibault Duplessis Date: Tue, 18 Jun 2024 14:45:51 +0200 Subject: [PATCH 134/168] remove debug --- ui/opening/src/wiki.ts | 2 -- 1 file changed, 2 deletions(-) diff --git a/ui/opening/src/wiki.ts b/ui/opening/src/wiki.ts index b7d89b6d00ddc..e7303e39214c9 100644 --- a/ui/opening/src/wiki.ts +++ b/ui/opening/src/wiki.ts @@ -48,8 +48,6 @@ async function fetchAndRender(data: OpeningPage, render: (html: string) => void) console.warn('error: unexpected API response:
' + JSON.stringify(page) + '
'); return; } else { - console.log(page.extract, title); - console.log(transform(page.extract, title)); return render(transform(page.extract, title)); } } else return; From 7cc6a9bc4e7e9ebc649d4749be6109cbc51fcefc Mon Sep 17 00:00:00 2001 From: Thibault Duplessis Date: Tue, 18 Jun 2024 15:34:25 +0200 Subject: [PATCH 135/168] filter broadcast source games by round --- modules/relay/src/main/RelayFetch.scala | 1 + modules/relay/src/main/RelayGame.scala | 4 ++++ modules/relay/src/main/RelayRound.scala | 1 + modules/relay/src/main/RelayRoundForm.scala | 15 +++++++++------ modules/relay/src/main/ui/FormUi.scala | 10 ++++++++++ 5 files changed, 25 insertions(+), 6 deletions(-) diff --git a/modules/relay/src/main/RelayFetch.scala b/modules/relay/src/main/RelayFetch.scala index eb8f1344de023..620b671c5f44d 100644 --- a/modules/relay/src/main/RelayFetch.scala +++ b/modules/relay/src/main/RelayFetch.scala @@ -80,6 +80,7 @@ final private class RelayFetch( if !rt.round.sync.playing then fuccess(updating(_.withSync(_.play(rt.tour.official)))) else fetchGames(rt) + .map(RelayGame.filter(rt.round.sync.onlyRound)) .map(games => rt.tour.players.fold(games)(_.update(games))) .flatMap(fidePlayers.enrichGames(rt.tour)) .map(games => rt.tour.teams.fold(games)(_.update(games))) diff --git a/modules/relay/src/main/RelayGame.scala b/modules/relay/src/main/RelayGame.scala index 180df1a9fd52f..208bc56878de5 100644 --- a/modules/relay/src/main/RelayGame.scala +++ b/modules/relay/src/main/RelayGame.scala @@ -73,3 +73,7 @@ private object RelayGame: , mul => RelayFetch.multiPgnToGames(mul).fold(e => throw e, identity) ) + + def filter(onlyRound: Option[Int])(games: RelayGames): RelayGames = + onlyRound.fold(games): round => + games.filter(_.tags.roundNumber.has(round)) diff --git a/modules/relay/src/main/RelayRound.scala b/modules/relay/src/main/RelayRound.scala index 75505b7cb08e6..90c1fb2fe7c12 100644 --- a/modules/relay/src/main/RelayRound.scala +++ b/modules/relay/src/main/RelayRound.scala @@ -75,6 +75,7 @@ object RelayRound: nextAt: Option[Instant], // when to run next sync period: Option[Seconds], // override time between two sync (rare) delay: Option[Seconds], // add delay between the source and the study + onlyRound: Option[Int], // only keep games with [Round "x"] log: SyncLog ): def hasUpstream = upstream.isDefined diff --git a/modules/relay/src/main/RelayRoundForm.scala b/modules/relay/src/main/RelayRoundForm.scala index a4578ba10f03a..4b9ca1e688fcf 100644 --- a/modules/relay/src/main/RelayRoundForm.scala +++ b/modules/relay/src/main/RelayRoundForm.scala @@ -32,9 +32,8 @@ final class RelayRoundForm(using mode: Mode): "startsAt" -> optional(ISOInstantOrTimestamp.mapping), "finished" -> optional(boolean), "period" -> optional(number(min = 2, max = 60).into[Seconds]), - "delay" -> optional( - number(min = 0, max = RelayDelay.maxSeconds.value).into[Seconds] - ) // don't increase the max + "delay" -> optional(number(min = 0, max = RelayDelay.maxSeconds.value).into[Seconds]), + "onlyRound" -> optional(number(min = 1, max = 999)) )(Data.apply)(unapply) .verifying("This source requires a round number. See the new form field below.", !_.roundMissing) @@ -54,7 +53,7 @@ object RelayRoundForm: val prevs: Option[(RelayRound, RelayRound)] = rounds.reverse match case a :: b :: _ => (a, b).some case _ => none - val prev: Option[RelayRound] = prevs.map(_._1) + val prev: Option[RelayRound] = rounds.lastOption val roundNumberRegex = """([^\d]*)(\d{1,2})([^\d]*)""".r val roundNumberIn: String => Option[Int] = case roundNumberRegex(_, n, _) => n.toIntOption @@ -86,7 +85,8 @@ object RelayRoundForm: syncUrlRound = (prevs.isEmpty || nextUrl.isDefined).option(nextNumber), startsAt = guessDate, period = prev.flatMap(_.sync.period), - delay = prev.flatMap(_.sync.delay) + delay = prev.flatMap(_.sync.delay), + onlyRound = prev.flatMap(_.sync.onlyRound).map(_ + 1) ) case class GameIds(ids: List[GameId]) @@ -143,7 +143,8 @@ object RelayRoundForm: startsAt: Option[Instant] = None, finished: Option[Boolean] = None, period: Option[Seconds] = None, - delay: Option[Seconds] = None + delay: Option[Seconds] = None, + onlyRound: Option[Int] = None ): def requiresRound = syncUrl.exists(RelayRound.Sync.UpstreamUrl.LccRegex.matches) @@ -176,6 +177,7 @@ object RelayRoundForm: nextAt = none, period = period.ifTrue(Granter.ofUser(_.StudyAdmin)(user)), delay = delay, + onlyRound = onlyRound, log = SyncLog.empty ) @@ -207,5 +209,6 @@ object RelayRoundForm: startsAt = relay.startsAt, finished = relay.finished.option(true), period = relay.sync.period, + onlyRound = relay.sync.onlyRound, delay = relay.sync.delay ) diff --git a/modules/relay/src/main/ui/FormUi.scala b/modules/relay/src/main/ui/FormUi.scala index 0fc8b62c27e42..79bb1feb6ce13 100644 --- a/modules/relay/src/main/ui/FormUi.scala +++ b/modules/relay/src/main/ui/FormUi.scala @@ -209,6 +209,16 @@ final class FormUi(helpers: Helpers, ui: RelayUi, tourUi: RelayTourUi): )(form3.input(_, typ = "number")) ) ), + form3.split( + form3.group( + form("onlyRound"), + raw("Filter games by round number"), + help = frag( + "Optional, only keep games from the source that match a round number." + ).some, + half = true + )(form3.input(_, typ = "number")) + ), form3.actions( a(href := routes.RelayTour.show(t.slug, t.id))(trans.site.cancel()), form3.submit(trans.site.apply()) From c7a904a4d497c3b4e5e117852f4a0bfdf438d9c5 Mon Sep 17 00:00:00 2001 From: Thibault Duplessis Date: Tue, 18 Jun 2024 16:15:41 +0200 Subject: [PATCH 136/168] broadcast game slicing --- modules/relay/src/main/BSONHandlers.scala | 3 ++ modules/relay/src/main/RelayFetch.scala | 1 + modules/relay/src/main/RelayGame.scala | 38 +++++++++++++++++++++ modules/relay/src/main/RelayRound.scala | 1 + modules/relay/src/main/RelayRoundForm.scala | 13 +++++-- modules/relay/src/main/ui/FormUi.scala | 19 ++++++++++- 6 files changed, 71 insertions(+), 4 deletions(-) diff --git a/modules/relay/src/main/BSONHandlers.scala b/modules/relay/src/main/BSONHandlers.scala index 8c8967dc4cfc9..3d85ca7675240 100644 --- a/modules/relay/src/main/BSONHandlers.scala +++ b/modules/relay/src/main/BSONHandlers.scala @@ -30,6 +30,9 @@ object BSONHandlers: given BSONHandler[SyncLog] = isoHandler[SyncLog, Vector[Event]](_.events, SyncLog.apply) + given BSONHandler[List[RelayGame.Slice]] = + stringIsoHandler[List[RelayGame.Slice]](using RelayGame.Slices.iso) + given BSONDocumentHandler[Sync] = Macros.handler given BSONDocumentHandler[RelayRound] = Macros.handler diff --git a/modules/relay/src/main/RelayFetch.scala b/modules/relay/src/main/RelayFetch.scala index 620b671c5f44d..3eb0640e970b2 100644 --- a/modules/relay/src/main/RelayFetch.scala +++ b/modules/relay/src/main/RelayFetch.scala @@ -81,6 +81,7 @@ final private class RelayFetch( else fetchGames(rt) .map(RelayGame.filter(rt.round.sync.onlyRound)) + .map(RelayGame.Slices.filter(~rt.round.sync.slices)) .map(games => rt.tour.players.fold(games)(_.update(games))) .flatMap(fidePlayers.enrichGames(rt.tour)) .map(games => rt.tour.teams.fold(games)(_.update(games))) diff --git a/modules/relay/src/main/RelayGame.scala b/modules/relay/src/main/RelayGame.scala index 208bc56878de5..b997c4e689aaf 100644 --- a/modules/relay/src/main/RelayGame.scala +++ b/modules/relay/src/main/RelayGame.scala @@ -77,3 +77,41 @@ private object RelayGame: def filter(onlyRound: Option[Int])(games: RelayGames): RelayGames = onlyRound.fold(games): round => games.filter(_.tags.roundNumber.has(round)) + + // 1-indexed, both inclusive + case class Slice(from: Int, to: Int) + + object Slices: + def filter(slices: List[Slice])(games: RelayGames): RelayGames = + if slices.isEmpty then games + else + games.view.zipWithIndex + .filter: (g, i) => + val n = i + 1 + slices.exists: s => + n >= s.from && n <= s.to + .map(_._1) + .toVector + + // 1-5,12-15,20 + def parse(str: String): List[Slice] = str.trim + .split(',') + .toList + .map(_.trim) + .flatMap: s => + s.split('-').toList.map(_.trim) match + case Nil => none + case from :: Nil => from.toIntOption.map(f => Slice(f, f)) + case from :: to :: _ => + for + f <- from.toIntOption + t <- to.toIntOption + yield Slice(f, t) + + def show(slices: List[Slice]): String = slices.pp + .map: + case Slice(f, t) if f == t => f.toString + case Slice(f, t) => s"$f-$t" + .mkString(",") + + val iso: Iso.StringIso[List[Slice]] = Iso(parse, show) diff --git a/modules/relay/src/main/RelayRound.scala b/modules/relay/src/main/RelayRound.scala index 90c1fb2fe7c12..4641c65112263 100644 --- a/modules/relay/src/main/RelayRound.scala +++ b/modules/relay/src/main/RelayRound.scala @@ -76,6 +76,7 @@ object RelayRound: period: Option[Seconds], // override time between two sync (rare) delay: Option[Seconds], // add delay between the source and the study onlyRound: Option[Int], // only keep games with [Round "x"] + slices: Option[List[RelayGame.Slice]] = none, log: SyncLog ): def hasUpstream = upstream.isDefined diff --git a/modules/relay/src/main/RelayRoundForm.scala b/modules/relay/src/main/RelayRoundForm.scala index 4b9ca1e688fcf..3ad8b5db581ea 100644 --- a/modules/relay/src/main/RelayRoundForm.scala +++ b/modules/relay/src/main/RelayRoundForm.scala @@ -33,7 +33,10 @@ final class RelayRoundForm(using mode: Mode): "finished" -> optional(boolean), "period" -> optional(number(min = 2, max = 60).into[Seconds]), "delay" -> optional(number(min = 0, max = RelayDelay.maxSeconds.value).into[Seconds]), - "onlyRound" -> optional(number(min = 1, max = 999)) + "onlyRound" -> optional(number(min = 1, max = 999)), + "slices" -> optional: + nonEmptyText + .transform[List[RelayGame.Slice]](RelayGame.Slices.parse, RelayGame.Slices.show) )(Data.apply)(unapply) .verifying("This source requires a round number. See the new form field below.", !_.roundMissing) @@ -86,7 +89,8 @@ object RelayRoundForm: startsAt = guessDate, period = prev.flatMap(_.sync.period), delay = prev.flatMap(_.sync.delay), - onlyRound = prev.flatMap(_.sync.onlyRound).map(_ + 1) + onlyRound = prev.flatMap(_.sync.onlyRound).map(_ + 1), + slices = prev.flatMap(_.sync.slices) ) case class GameIds(ids: List[GameId]) @@ -144,7 +148,8 @@ object RelayRoundForm: finished: Option[Boolean] = None, period: Option[Seconds] = None, delay: Option[Seconds] = None, - onlyRound: Option[Int] = None + onlyRound: Option[Int] = None, + slices: Option[List[RelayGame.Slice]] = None ): def requiresRound = syncUrl.exists(RelayRound.Sync.UpstreamUrl.LccRegex.matches) @@ -178,6 +183,7 @@ object RelayRoundForm: period = period.ifTrue(Granter.ofUser(_.StudyAdmin)(user)), delay = delay, onlyRound = onlyRound, + slices = slices, log = SyncLog.empty ) @@ -210,5 +216,6 @@ object RelayRoundForm: finished = relay.finished.option(true), period = relay.sync.period, onlyRound = relay.sync.onlyRound, + slices = relay.sync.slices, delay = relay.sync.delay ) diff --git a/modules/relay/src/main/ui/FormUi.scala b/modules/relay/src/main/ui/FormUi.scala index 79bb1feb6ce13..c9dd9ee6758c6 100644 --- a/modules/relay/src/main/ui/FormUi.scala +++ b/modules/relay/src/main/ui/FormUi.scala @@ -217,7 +217,24 @@ final class FormUi(helpers: Helpers, ui: RelayUi, tourUi: RelayTourUi): "Optional, only keep games from the source that match a round number." ).some, half = true - )(form3.input(_, typ = "number")) + )(form3.input(_, typ = "number")), + form3.group( + form("slices"), + raw("Select slices of the games"), + help = frag( + "Optional. Select games based on their position in the source.", + br, + pre(""" +1 only select the first board +1-4 only select the first 4 boards +1,2,3,4 same as above, first 4 boards +11-20,21-30 boards 11 to 20, and boards 21 to 30 +2,3,7-9 boards 2, 3, 7, 8, and 9 +"""), + "Slicing is done after filtering by round number." + ).some, + half = true + )(form3.input(_)) ), form3.actions( a(href := routes.RelayTour.show(t.slug, t.id))(trans.site.cancel()), From a4f55eb5f9baa044d0604bbf477db80007fd8cb5 Mon Sep 17 00:00:00 2001 From: Thibault Duplessis Date: Tue, 18 Jun 2024 16:29:45 +0200 Subject: [PATCH 137/168] remove debug --- modules/relay/src/main/RelayGame.scala | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/modules/relay/src/main/RelayGame.scala b/modules/relay/src/main/RelayGame.scala index b997c4e689aaf..8b59b6f530cd0 100644 --- a/modules/relay/src/main/RelayGame.scala +++ b/modules/relay/src/main/RelayGame.scala @@ -108,7 +108,7 @@ private object RelayGame: t <- to.toIntOption yield Slice(f, t) - def show(slices: List[Slice]): String = slices.pp + def show(slices: List[Slice]): String = slices .map: case Slice(f, t) if f == t => f.toString case Slice(f, t) => s"$f-$t" From fbca504acaf9c305458c69e113b3b97adf1ab6ff Mon Sep 17 00:00:00 2001 From: Thibault Duplessis Date: Tue, 18 Jun 2024 16:40:43 +0200 Subject: [PATCH 138/168] better board slicing example --- modules/relay/src/main/ui/FormUi.scala | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/modules/relay/src/main/ui/FormUi.scala b/modules/relay/src/main/ui/FormUi.scala index c9dd9ee6758c6..c389d3145a39e 100644 --- a/modules/relay/src/main/ui/FormUi.scala +++ b/modules/relay/src/main/ui/FormUi.scala @@ -228,7 +228,7 @@ final class FormUi(helpers: Helpers, ui: RelayUi, tourUi: RelayTourUi): 1 only select the first board 1-4 only select the first 4 boards 1,2,3,4 same as above, first 4 boards -11-20,21-30 boards 11 to 20, and boards 21 to 30 +11-15,21-25 boards 11 to 15, and boards 21 to 25 2,3,7-9 boards 2, 3, 7, 8, and 9 """), "Slicing is done after filtering by round number." From 73202fdc905fe7ec59cd6f1899a8cd4944ef2f43 Mon Sep 17 00:00:00 2001 From: Thanh Le Date: Tue, 18 Jun 2024 07:54:53 +0700 Subject: [PATCH 139/168] Clean up leftover of forumSearch ingestor --- modules/forum/src/main/ForumPostRepo.scala | 4 +--- modules/forumSearch/src/main/Env.scala | 2 -- modules/forumSearch/src/main/ForumSearchApi.scala | 5 +---- 3 files changed, 2 insertions(+), 9 deletions(-) diff --git a/modules/forum/src/main/ForumPostRepo.scala b/modules/forum/src/main/ForumPostRepo.scala index 33029a19f59fc..e2e253e0d4a28 100644 --- a/modules/forum/src/main/ForumPostRepo.scala +++ b/modules/forum/src/main/ForumPostRepo.scala @@ -8,9 +8,7 @@ import lila.forum.Filter.* import lila.core.forum.ForumPostMini import reactivemongo.api.CursorOps -final class ForumPostRepo(val coll: Coll, filter: Filter = Safe)(using - Executor -): +final class ForumPostRepo(val coll: Coll, filter: Filter = Safe)(using Executor): def forUser(user: Option[User]) = withFilter(user.filter(_.marks.troll).fold[Filter](Safe) { u => diff --git a/modules/forumSearch/src/main/Env.scala b/modules/forumSearch/src/main/Env.scala index 6092317e9eff1..d9b08fa2af131 100644 --- a/modules/forumSearch/src/main/Env.scala +++ b/modules/forumSearch/src/main/Env.scala @@ -4,11 +4,9 @@ import com.softwaremill.macwire.* import play.api.Configuration import lila.common.autoconfig.{ *, given } -import lila.search.* import lila.core.forum.BusForum import BusForum.* import lila.core.config.ConfigName -import lila.core.id.ForumPostId import lila.search.client.SearchClient import lila.search.spec.Query diff --git a/modules/forumSearch/src/main/ForumSearchApi.scala b/modules/forumSearch/src/main/ForumSearchApi.scala index 3b85b2094005d..23bad2e6ae357 100644 --- a/modules/forumSearch/src/main/ForumSearchApi.scala +++ b/modules/forumSearch/src/main/ForumSearchApi.scala @@ -1,14 +1,11 @@ package lila.forumSearch -import akka.stream.scaladsl.* - import lila.search.* -import lila.core.forum.{ ForumPostApi, ForumPostMini, ForumPostMiniView } import lila.core.id.ForumPostId import lila.search.client.SearchClient import lila.search.spec.{ ForumSource, Query } -final class ForumSearchApi(client: SearchClient, postApi: ForumPostApi)(using Executor) +final class ForumSearchApi(client: SearchClient)(using Executor) extends SearchReadApi[ForumPostId, Query.Forum]: def search(query: Query.Forum, from: From, size: Size) = From 811fb46c66d248deb26461b282ed3719b9f7c371 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?S=C3=A9rgio=20Gl=C3=B3rias?= <9739913+SergioGlorias@users.noreply.github.com> Date: Tue, 18 Jun 2024 20:51:27 +0100 Subject: [PATCH 140/168] Fix texts and add missing info --- modules/relay/src/main/ui/FormUi.scala | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/modules/relay/src/main/ui/FormUi.scala b/modules/relay/src/main/ui/FormUi.scala index c389d3145a39e..d624489f02aba 100644 --- a/modules/relay/src/main/ui/FormUi.scala +++ b/modules/relay/src/main/ui/FormUi.scala @@ -356,11 +356,13 @@ final class FormUi(helpers: Helpers, ui: RelayUi, tourUi: RelayTourUi): br, """"Jorge Rick Vito" will match "Jorge Rick", "jorge vito", "Rick, Vito", etc.""", br, + "If the player is NM or WNM, you can:", + pre("""Player Name = FIDE ID / Title"""), "Alternatively, you may set tags manually, like so:", pre("player name / rating / title / new name"), "All values are optional. Example:", pre("""Magnus Carlsen / 2863 / GM - YouGotLittUp / 1890 / / Louis Litt""") +YouGotLittUp / 1890 / / Louis Litt""") ).some, half = true )(form3.textarea(_)(rows := 3)), @@ -372,7 +374,7 @@ final class FormUi(helpers: Helpers, ui: RelayUi, tourUi: RelayTourUi): pre("Team name; Fide Id or Player name"), "Example:", pre("""Team Cats ; 3408230 - Team Dogs ; Scooby Doo"""), +Team Dogs ; Scooby Doo"""), "By default the PGN tags WhiteTeam and BlackTeam are used." ).some, half = true From 26747a4ecea8b33f3207f39abe0abec3b9d659e6 Mon Sep 17 00:00:00 2001 From: Thibault Duplessis Date: Wed, 19 Jun 2024 12:48:04 +0200 Subject: [PATCH 141/168] relay multi-url wip --- bin/mongodb/relay-lcc-migrate.js | 17 +++ modules/coreI18n/src/main/key.scala | 4 +- modules/relay/src/main/BSONHandlers.scala | 20 ++- modules/relay/src/main/JsonView.scala | 13 +- modules/relay/src/main/RelayApi.scala | 2 +- modules/relay/src/main/RelayFetch.scala | 51 ++++--- modules/relay/src/main/RelayFormat.scala | 25 ++-- modules/relay/src/main/RelayRound.scala | 25 ++-- modules/relay/src/main/RelayRoundForm.scala | 134 ++++++++++++------ modules/relay/src/main/ui/FormUi.scala | 119 ++++++++++------ modules/ui/src/main/helper/Form3.scala | 1 + translation/source/broadcast.xml | 4 +- ui/analyse/src/study/relay/interfaces.ts | 1 + .../src/study/relay/relayManagerView.ts | 10 +- ui/bits/css/relay/_form.scss | 10 ++ ui/bits/src/bits.relayForm.ts | 16 ++- ui/common/css/form/_form3.scss | 4 +- ui/simul/css/_form.scss | 7 - 18 files changed, 292 insertions(+), 171 deletions(-) create mode 100644 bin/mongodb/relay-lcc-migrate.js diff --git a/bin/mongodb/relay-lcc-migrate.js b/bin/mongodb/relay-lcc-migrate.js new file mode 100644 index 0000000000000..e2c53262ca08c --- /dev/null +++ b/bin/mongodb/relay-lcc-migrate.js @@ -0,0 +1,17 @@ +const regex = /.*view\.livechesscloud\.com\/?#?([0-9a-f\-]+)/; +let done = 0; +let failed = 0; +db.relay.find({ 'sync.upstream.url': /view\.livechesscloud\.com/ }).forEach(relay => { + const url = relay.sync.upstream.url; + try { + const id = url.match(regex)[1]; + const round = parseInt(url.split(' ')[1]) || 1; + if (!id) throw new Error('No id in ' + url); + db.relay.updateOne({ _id: relay._id }, { $set: { 'sync.upstream': { lcc: { id, round } } } }); + done++; + } catch (e) { + failed++; + } +}); +console.log(done + ' done'); +console.log(failed + ' failed'); diff --git a/modules/coreI18n/src/main/key.scala b/modules/coreI18n/src/main/key.scala index f94c0339668e6..08b853fee5c82 100644 --- a/modules/coreI18n/src/main/key.scala +++ b/modules/coreI18n/src/main/key.scala @@ -1665,9 +1665,9 @@ object I18nKey: val `tournamentDescription`: I18nKey = "broadcast:tournamentDescription" val `fullDescription`: I18nKey = "broadcast:fullDescription" val `fullDescriptionHelp`: I18nKey = "broadcast:fullDescriptionHelp" - val `sourceUrlOrGameIds`: I18nKey = "broadcast:sourceUrlOrGameIds" + val `sourceUrl`: I18nKey = "broadcast:sourceUrl" val `sourceUrlHelp`: I18nKey = "broadcast:sourceUrlHelp" - val `gameIdsHelp`: I18nKey = "broadcast:gameIdsHelp" + val `sourceGameIds`: I18nKey = "broadcast:sourceGameIds" val `startDate`: I18nKey = "broadcast:startDate" val `startDateHelp`: I18nKey = "broadcast:startDateHelp" val `credits`: I18nKey = "broadcast:credits" diff --git a/modules/relay/src/main/BSONHandlers.scala b/modules/relay/src/main/BSONHandlers.scala index 3d85ca7675240..03b4f2377624c 100644 --- a/modules/relay/src/main/BSONHandlers.scala +++ b/modules/relay/src/main/BSONHandlers.scala @@ -10,18 +10,24 @@ object BSONHandlers: given BSONHandler[RelayTeamsTextarea] = stringAnyValHandler(_.text, RelayTeamsTextarea(_)) import RelayRound.Sync - import Sync.{ Upstream, UpstreamIds, UpstreamUrl } - given upstreamUrlHandler: BSONDocumentHandler[UpstreamUrl] = Macros.handler - given upstreamIdsHandler: BSONDocumentHandler[UpstreamIds] = Macros.handler + import Sync.{ Upstream, UpstreamIds, UpstreamUrl, UpstreamLcc, UpstreamUrls } + given upstreamUrlHandler: BSONDocumentHandler[UpstreamUrl] = Macros.handler + given upstreamLccHandler: BSONDocumentHandler[UpstreamLcc] = Macros.handler + given upstreamUrlsHandler: BSONDocumentHandler[UpstreamUrls] = Macros.handler + given upstreamIdsHandler: BSONDocumentHandler[UpstreamIds] = Macros.handler given BSONHandler[Upstream] = tryHandler( { - case d: BSONDocument if d.contains("url") => upstreamUrlHandler.readTry(d) - case d: BSONDocument if d.contains("ids") => upstreamIdsHandler.readTry(d) + case d: BSONDocument if d.contains("url") => upstreamUrlHandler.readTry(d) + case d: BSONDocument if d.contains("lcc") => upstreamLccHandler.readTry(d) + case d: BSONDocument if d.contains("urls") => upstreamUrlsHandler.readTry(d) + case d: BSONDocument if d.contains("ids") => upstreamIdsHandler.readTry(d) }, { - case url: UpstreamUrl => upstreamUrlHandler.writeTry(url).get - case ids: UpstreamIds => upstreamIdsHandler.writeTry(ids).get + case url: UpstreamUrl => upstreamUrlHandler.writeTry(url).get + case lcc: UpstreamLcc => upstreamLccHandler.writeTry(lcc).get + case urls: UpstreamUrls => upstreamUrlsHandler.writeTry(urls).get + case ids: UpstreamIds => upstreamIdsHandler.writeTry(ids).get } ) diff --git a/modules/relay/src/main/JsonView.scala b/modules/relay/src/main/JsonView.scala index 0bcdab2f91e7d..8625ba6c272c4 100644 --- a/modules/relay/src/main/JsonView.scala +++ b/modules/relay/src/main/JsonView.scala @@ -93,9 +93,7 @@ final class JsonView( rt: RelayRound.WithTourAndStudy, previews: ChapterPreview.AsJsons, group: Option[RelayGroup.WithTours] - )(using - Option[Me] - ): JsObject = + )(using Option[Me]): JsObject = myRound(rt) ++ Json.obj("games" -> previews).add("group" -> group) def sync(round: RelayRound) = Json.toJsObject(round.sync) @@ -172,7 +170,8 @@ object JsonView: Json.arr(minute * 60, crowd) ) - private given OWrites[RelayRound.Sync] = OWrites: s => + import RelayRound.Sync + private given OWrites[Sync] = OWrites: s => Json .obj( "ongoing" -> s.ongoing, @@ -180,6 +179,8 @@ object JsonView: ) .add("delay" -> s.delay) ++ s.upstream.so { - case url: RelayRound.Sync.UpstreamUrl => Json.obj("url" -> url.withRound.url) - case RelayRound.Sync.UpstreamIds(ids) => Json.obj("ids" -> ids) + case Sync.UpstreamUrl(url) => Json.obj("url" -> url) + case Sync.UpstreamLcc(url, round) => Json.obj("url" -> url, "round" -> round) + case Sync.UpstreamUrls(urls) => Json.obj("urls" -> urls.map(_.url)) + case Sync.UpstreamIds(ids) => Json.obj("ids" -> ids) } diff --git a/modules/relay/src/main/RelayApi.scala b/modules/relay/src/main/RelayApi.scala index 5f4485d92583d..760270c8a686a 100644 --- a/modules/relay/src/main/RelayApi.scala +++ b/modules/relay/src/main/RelayApi.scala @@ -244,7 +244,7 @@ final class RelayApi( def requestPlay(id: RelayRoundId, v: Boolean): Funit = WithRelay(id): relay => - relay.sync.upstream.flatMap(_.asUrl).map(_.withRound).foreach(formatApi.refresh) + relay.sync.upstream.foreach(formatApi.refresh) isOfficial(relay.id).flatMap: official => update(relay): r => if v diff --git a/modules/relay/src/main/RelayFetch.scala b/modules/relay/src/main/RelayFetch.scala index 3eb0640e970b2..98de665690b4d 100644 --- a/modules/relay/src/main/RelayFetch.scala +++ b/modules/relay/src/main/RelayFetch.scala @@ -14,7 +14,7 @@ import lila.memo.CacheApi import lila.study.{ MultiPgn, StudyPgnImport } import lila.tree.Node.Comments -import RelayRound.Sync.{ UpstreamIds, UpstreamUrl } +import RelayRound.Sync.{ UpstreamIds, UpstreamUrl, UpstreamUrls } import RelayFormat.CanProxy import scalalib.model.Seconds @@ -142,8 +142,7 @@ final private class RelayFetch( Seconds(60) else round.sync.period | Seconds: - if upstream.local then 3 - else if upstream.asUrl.exists(_.isLcc) && !tour.official then 10 + if upstream.asUrl.exists(_.isLcc) && !tour.official then 12 else 5 updating: _.withSync: @@ -168,26 +167,32 @@ final private class RelayFetch( private def fetchGames(rt: RelayRound.WithTour): Fu[RelayGames] = rt.round.sync.upstream.so: - case UpstreamIds(ids) => - gameRepo - .gamesFromSecondary(ids) - .flatMap(gameProxy.upgradeIfPresent) - .flatMap(gameRepo.withInitialFens) - .flatMap { games => - if games.size == ids.size then - val pgnFlags = gameIdsUpstreamPgnFlags.copy(delayMoves = !rt.tour.official) - given play.api.i18n.Lang = lila.core.i18n.defaultLang - games - .sequentially: (game, fen) => - pgnDump(game, fen, pgnFlags).dmap(_.render) - .dmap(MultiPgn.apply) - else - throw LilaInvalid: - s"Invalid game IDs: ${ids.filter(id => !games.exists(_._1.id == id)).mkString(", ")}" - } - .flatMap(multiPgnToGames(_).toFuture) - case url: UpstreamUrl => - delayer(url, rt.round, fetchFromUpstream(using CanProxy(rt.tour.official))) + case UpstreamIds(ids) => fetchFromGameIds(rt.tour, ids) + case url: UpstreamUrl => delayer(url, rt.round, fetchFromUpstream(using CanProxy(rt.tour.official))) + case UpstreamUrls(urls) => + urls + .traverse: url => + delayer(url, rt.round, fetchFromUpstream(using CanProxy(rt.tour.official))) + .map(_.flatten.toVector) + + private def fetchFromGameIds(tour: RelayTour, ids: List[GameId]): Fu[RelayGames] = + gameRepo + .gamesFromSecondary(ids) + .flatMap(gameProxy.upgradeIfPresent) + .flatMap(gameRepo.withInitialFens) + .flatMap { games => + if games.size == ids.size then + val pgnFlags = gameIdsUpstreamPgnFlags.copy(delayMoves = !tour.official) + given play.api.i18n.Lang = lila.core.i18n.defaultLang + games + .sequentially: (game, fen) => + pgnDump(game, fen, pgnFlags).dmap(_.render) + .dmap(MultiPgn.apply) + else + throw LilaInvalid: + s"Invalid game IDs: ${ids.filter(id => !games.exists(_._1.id == id)).mkString(", ")}" + } + .flatMap(multiPgnToGames(_).toFuture) private def fetchFromUpstream(using canProxy: CanProxy)(upstream: UpstreamUrl, max: Max): Fu[RelayGames] = import DgtJson.* diff --git a/modules/relay/src/main/RelayFormat.scala b/modules/relay/src/main/RelayFormat.scala index 38bdd5b465dfe..21d55e19cbd8c 100644 --- a/modules/relay/src/main/RelayFormat.scala +++ b/modules/relay/src/main/RelayFormat.scala @@ -29,34 +29,33 @@ final private class RelayFormatApi( )(using Executor): import RelayFormat.* - import RelayRound.Sync.UpstreamUrl + import RelayRound.Sync.{ Upstream, UpstreamUrl, UpstreamLcc } - private val cache = cacheApi[(UpstreamUrl.WithRound, CanProxy), RelayFormat](64, "relay.format"): + private val cache = cacheApi[(Upstream, CanProxy), RelayFormat](64, "relay.format"): _.expireAfterWrite(5 minutes) .buildAsyncFuture: (url, proxy) => guessFormat(url)(using proxy) - def get(upstream: UpstreamUrl.WithRound)(using proxy: CanProxy): Fu[RelayFormat] = + def get(upstream: Upstream)(using proxy: CanProxy): Fu[RelayFormat] = cache.get(upstream -> proxy) - def refresh(upstream: UpstreamUrl.WithRound): Unit = + def refresh(upstream: Upstream): Unit = CanProxy .from(List(false, true)) .foreach: proxy => cache.invalidate(upstream -> proxy) - private def guessFormat(upstream: UpstreamUrl.WithRound)(using CanProxy): Fu[RelayFormat] = { + private def guessFormat(upstream: Upstream)(using CanProxy): Fu[RelayFormat] = { - val originalUrl = URL.parse(upstream.url) + // val originalUrl = URL.parse(upstream.url) // http://view.livechesscloud.com/ed5fb586-f549-4029-a470-d590f8e30c76 - def guessLcc(url: URL)(using CanProxy): Fu[Option[RelayFormat]] = - url.toString match - case UpstreamUrl.LccRegex(id) => - guessManyFiles: - URL.parse: - s"http://1.pool.livechesscloud.com/get/$id/round-${upstream.round | 1}/index.json" - case _ => fuccess(none) + def guessLcc(using CanProxy): Fu[Option[RelayFormat]] = upstream match + case UpstreamLcc(id, round) => + guessManyFiles: + URL.parse: + s"http://1.pool.livechesscloud.com/get/$id/round-$round/index.json" + case _ => fuccess(none) def guessSingleFile(url: URL)(using CanProxy): Fu[Option[RelayFormat]] = List( diff --git a/modules/relay/src/main/RelayRound.scala b/modules/relay/src/main/RelayRound.scala index 4641c65112263..84c31915d0699 100644 --- a/modules/relay/src/main/RelayRound.scala +++ b/modules/relay/src/main/RelayRound.scala @@ -114,21 +114,16 @@ object RelayRound: override def toString = upstream.toString object Sync: - sealed trait Upstream: - def asUrl: Option[UpstreamUrl] = this match - case url: UpstreamUrl => url.some - case _ => none - def local = asUrl.fold(true)(_.isLocal) - case class UpstreamUrl(url: String) extends Upstream: - def isLocal = url.contains("://127.0.0.1") || url.contains("://[::1]") || url.contains("://localhost") - def withRound = url.split(" ", 2) match - case Array(u, round) => UpstreamUrl.WithRound(u, round.toIntOption) - case _ => UpstreamUrl.WithRound(url, none) - def isLcc: Boolean = UpstreamUrl.LccRegex.matches(url) - object UpstreamUrl: - case class WithRound(url: String, round: Option[Int]) - val LccRegex = """.*view\.livechesscloud\.com/?#?([0-9a-f\-]+)""".r - case class UpstreamIds(ids: List[GameId]) extends Upstream + sealed trait Upstream + case class UpstreamUrl(url: String) extends Upstream + case class UpstreamLcc(id: String, round: Int) extends Upstream: + def url = s"https://view.livechesscloud.com/#$id" + case class UpstreamUrls(urls: List[UpstreamUrl]) extends Upstream + case class UpstreamIds(ids: List[GameId]) extends Upstream + val LccRegex = """.*view\.livechesscloud\.com/?#?([0-9a-f\-]+)""".r + def tryLcc(url: String): Option[UpstreamLcc] = url match + case LccRegex(id) => UpstreamLcc(id, 1).some + case _ => none trait AndTour: val tour: RelayTour diff --git a/modules/relay/src/main/RelayRoundForm.scala b/modules/relay/src/main/RelayRoundForm.scala index 3ad8b5db581ea..8c144eb8788b7 100644 --- a/modules/relay/src/main/RelayRoundForm.scala +++ b/modules/relay/src/main/RelayRoundForm.scala @@ -1,33 +1,55 @@ package lila.relay +import scala.util.Try import io.mola.galimatias.URL import play.api.data.* import play.api.data.Forms.* +import play.api.data.format.Formatter import play.api.Mode - -import scala.util.Try -import scala.util.chaining.* - -import lila.common.Form.{ cleanText, into } import scalalib.model.Seconds + +import lila.common.Form.{ cleanText, into, stringIn, formatter } import lila.core.perm.Granter import lila.relay.RelayRound.Sync +import lila.relay.RelayRound.Sync.UpstreamUrl final class RelayRoundForm(using mode: Mode): import RelayRoundForm.* import lila.common.Form.ISOInstantOrTimestamp + private given Formatter[Sync.UpstreamUrl] = formatter.stringTryFormatter(validateUpstreamUrl, _.url) + private given Formatter[Sync.UpstreamUrls] = formatter.stringTryFormatter( + _.linesIterator.toList + .map(_.trim) + .filter(_.nonEmpty) + .traverse(validateUpstreamUrl) + .map(_.distinct) + .map(Sync.UpstreamUrls.apply), + _.urls.map(_.url).mkString("\n") + ) + private given Formatter[Sync.UpstreamIds] = formatter.stringTryFormatter( + _.split(' ').toList + .map(_.trim) + .traverse: i => + GameId.from(i.trim).toRight(s"Invalid game ID: $i") + .left + .map(_.mkString(", ")) + .filterOrElse(_.sizeIs <= RelayFetch.maxChapters.value, s"Max games: ${RelayFetch.maxChapters}") + .map(_.distinct) + .map(Sync.UpstreamIds.apply), + _.ids.mkString(" ") + ) + val roundMapping = mapping( - "name" -> cleanText(minLength = 3, maxLength = 80).into[RelayRound.Name], - "caption" -> optional(cleanText(minLength = 3, maxLength = 80).into[RelayRound.Caption]), - "syncUrl" -> optional { - cleanText(minLength = 8, maxLength = 600) - .verifying("Invalid source", validSource) - .verifying("The source URL cannot specify a port", url => mode.notProd || validSourcePort(url)) - }, + "name" -> cleanText(minLength = 3, maxLength = 80).into[RelayRound.Name], + "caption" -> optional(cleanText(minLength = 3, maxLength = 80).into[RelayRound.Caption]), + "syncSource" -> optional(stringIn(sourceTypes.map(_._1).toSet)), + "syncUrl" -> optional(of[Sync.UpstreamUrl]), + "syncUrls" -> optional(of[Sync.UpstreamUrls]), + "syncIds" -> optional(of[Sync.UpstreamIds]), "syncUrlRound" -> optional(number(min = 1, max = 999)), "startsAt" -> optional(ISOInstantOrTimestamp.mapping), "finished" -> optional(boolean), @@ -52,6 +74,13 @@ final class RelayRoundForm(using mode: Mode): object RelayRoundForm: + val sourceTypes = List( + "url" -> "Single PGN URL", + "urls" -> "Combine several PGN URLs", + "ids" -> "Lichess game IDs", + "push" -> "Push local games" + ) + def fillFromPrevRounds(rounds: List[RelayRound]): Data = val prevs: Option[(RelayRound, RelayRound)] = rounds.reverse match case a :: b :: _ => (a, b).some @@ -73,8 +102,11 @@ object RelayRoundForm: roundNumberIn(old.name.value).contains(n - 1) p <- prev yield replaceRoundNumber(p.name.value, nextNumber) - val nextUrl = - prev.flatMap(_.sync.upstream).flatMap(_.asUrl).map(_.withRound).filter(_.round.isDefined).map(_.url) + val nextLcc: Option[Sync.UpstreamLcc] = prev + .flatMap(_.sync.upstream) + .flatMap: + case lcc: Sync.UpstreamLcc => lcc.copy(round = nextNumber).some + case _ => none val guessDate = for (prev, old) <- prevs prevDate <- prev.startsAt @@ -84,8 +116,9 @@ object RelayRoundForm: Data( name = RelayRound.Name(guessName | s"Round ${nextNumber}"), caption = prev.flatMap(_.caption), - syncUrl = nextUrl, - syncUrlRound = (prevs.isEmpty || nextUrl.isDefined).option(nextNumber), + syncSource = prev.map(Data.make).flatMap(_.syncSource), + syncUrl = nextLcc.map(l => Sync.UpstreamUrl(l.url)), + syncUrlRound = nextLcc.map(_.round), startsAt = guessDate, period = prev.flatMap(_.sync.period), delay = prev.flatMap(_.sync.delay), @@ -99,9 +132,6 @@ object RelayRoundForm: val list = ids.split(' ').view.flatMap(i => GameId.from(i.trim)).toList (list.sizeIs > 0 && list.sizeIs <= RelayFetch.maxChapters.value).option(GameIds(list)) - private def validSource(source: String)(using mode: Mode): Boolean = - cleanUrl(source).isDefined || toGameIds(source).isDefined - private def cleanUrl(source: String)(using mode: Mode): Option[String] = for url <- Try(URL.parse(source)).toOption @@ -112,10 +142,19 @@ object RelayRoundForm: if !subdomain(host, "chess.com") || url.toString.startsWith("https://api.chess.com/pub") yield url.toString.stripSuffix("/") + private def validateUpstreamUrl(s: String)(using Mode): Either[String, Sync.UpstreamUrl] = for + url <- cleanUrl(s).toRight("Invalid source URL") + url <- if !validSourcePort(url) then Left("The source URL cannot specify a port") else Right(url) + yield Sync.UpstreamUrl(url) + + private def cleanUrls(source: String)(using mode: Mode): Option[List[String]] = + source.linesIterator.toList.flatMap(cleanUrl).some.filter(_.nonEmpty) + private val validPorts = Set(-1, 80, 443, 8080, 8491) - private def validSourcePort(source: String): Boolean = - Try(URL.parse(source)).toOption.forall: url => - validPorts(url.port) + private def validSourcePort(source: String)(using mode: Mode): Boolean = + mode.notProd || + Try(URL.parse(source)).toOption.forall: url => + validPorts(url.port) private def subdomain(host: String, domain: String) = s".$host".endsWith(s".$domain") @@ -142,7 +181,10 @@ object RelayRoundForm: case class Data( name: RelayRound.Name, caption: Option[RelayRound.Caption], - syncUrl: Option[String] = None, + syncSource: Option[String], + syncUrl: Option[Sync.UpstreamUrl] = None, + syncUrls: Option[Sync.UpstreamUrls] = None, + syncIds: Option[Sync.UpstreamIds] = None, syncUrlRound: Option[Int] = None, startsAt: Option[Instant] = None, finished: Option[Boolean] = None, @@ -151,33 +193,32 @@ object RelayRoundForm: onlyRound: Option[Int] = None, slices: Option[List[RelayGame.Slice]] = None ): + def upstream: Option[Sync.Upstream] = syncSource match + case None => syncUrl.orElse(syncUrls).orElse(syncIds) + case Some("url") => + syncUrl.map: u => + (Sync.tryLcc(u.url), syncUrlRound).mapN((l, r) => l.copy(round = r)) | u + case Some("urls") => syncUrls + case Some("ids") => syncIds + case _ => None - def requiresRound = syncUrl.exists(RelayRound.Sync.UpstreamUrl.LccRegex.matches) - - def roundMissing = requiresRound && syncUrlRound.isEmpty - - def gameIds = syncUrl.flatMap(toGameIds) + def roundMissing = upstream.exists: + case u: Sync.UpstreamUrl => Sync.tryLcc(u.url).isDefined + case _ => false def update(official: Boolean)(relay: RelayRound)(using me: Me)(using mode: Mode) = + val sync = makeSync(me) relay.copy( name = name, caption = caption, - sync = makeSync(me).pipe: sync => - if relay.sync.playing then sync.play(official) else sync, + sync = if relay.sync.playing then sync.play(official) else sync, startsAt = startsAt, finished = ~finished ) private def makeSync(user: User)(using mode: Mode): Sync = RelayRound.Sync( - upstream = syncUrl - .flatMap(cleanUrl) - .map { u => - RelayRound.Sync.UpstreamUrl(s"$u${syncUrlRound.so(" " +)}") - } - .orElse(gameIds.map { ids => - RelayRound.Sync.UpstreamIds(ids.ids) - }), + upstream = upstream, until = none, nextAt = none, period = period.ifTrue(Granter.ofUser(_.StudyAdmin)(user)), @@ -207,10 +248,19 @@ object RelayRoundForm: Data( name = relay.name, caption = relay.caption, - syncUrl = relay.sync.upstream.map { - case url: RelayRound.Sync.UpstreamUrl => url.withRound.url - case RelayRound.Sync.UpstreamIds(ids) => ids.mkString(" ") - }, + syncSource = relay.sync.upstream + .fold("push"): + case _: Sync.UpstreamUrl => "url" + case _: Sync.UpstreamUrls => "urls" + case _: Sync.UpstreamIds => "ids" + .some, + syncUrl = relay.sync.upstream.collect: + case url: Sync.UpstreamUrl => url.withoutRound, + syncUrls = relay.sync.upstream.collect: + case url: Sync.UpstreamUrl => Sync.UpstreamUrls(List(url.withoutRound)) + case urls: Sync.UpstreamUrls => urls, + syncIds = relay.sync.upstream.collect: + case ids: Sync.UpstreamIds => ids, syncUrlRound = relay.sync.upstream.flatMap(_.asUrl).flatMap(_.withRound.round), startsAt = relay.startsAt, finished = relay.finished.option(true), diff --git a/modules/relay/src/main/ui/FormUi.scala b/modules/relay/src/main/ui/FormUi.scala index c389d3145a39e..39c038579e1bb 100644 --- a/modules/relay/src/main/ui/FormUi.scala +++ b/modules/relay/src/main/ui/FormUi.scala @@ -81,7 +81,7 @@ final class FormUi(helpers: Helpers, ui: RelayUi, tourUi: RelayTourUi): private def page(title: String, nav: FormNavigation)(using Context) = Page(title) .css("bits.relay.form") - .js(EsmInit("bits.flatpickr")) + .js(List(EsmInit("bits.flatpickr"), EsmInit("bits.relayForm")).map(some)) .wrap: body => main(cls := "page page-menu")( navigationMenu(nav), @@ -154,25 +154,77 @@ final class FormUi(helpers: Helpers, ui: RelayUi, tourUi: RelayTourUi): form3.input(_) ) ), - form3.group( - form("syncUrl"), - trb.sourceUrlOrGameIds(), - help = frag( - trb.sourceUrlHelp(), - br, - trb.gameIdsHelp(), - br, - "Or leave empty to push games from another program." - ).some - )(form3.input(_)), - form3 - .group( - form("syncUrlRound"), - trb.roundNumber(), - help = frag("Only for livechesscloud source URLs").some + form3.fieldset("Source")(cls := "box-pad")( + form3.group( + form("syncSource"), + "Where do the games come from?" + )(form3.select(_, RelayRoundForm.sourceTypes)), + div( + cls := List( + "relay-form__sync relay-form__sync-url" -> true, + "form-split relay-form__sync-lcc" -> isLcc + ) )( - form3.input(_, typ = "number") - )(cls := (!isLcc).option("none")), + form3.group( + form("syncUrl"), + trb.sourceUrl(), + help = trb.sourceUrlHelp().some, + half = isLcc + )(form3.input(_)), + isLcc.option: + form3.group( + form("syncUrlRound"), + trb.roundNumber(), + help = frag("Only for livechesscloud source URLs").some, + half = true + )(form3.input(_, typ = "number")) + ), + form3.group( + form("syncUrls"), + "Multiple source URLs, one per line.", + help = frag("The games will be combined in the order of the URLs.").some, + half = false + )(form3.textarea(_)(rows := 5))(cls := "relay-form__sync relay-form__sync-urls none"), + form3.group( + form("syncIds"), + trb.sourceGameIds(), + half = false + )(form3.input(_))(cls := "relay-form__sync relay-form__sync-ids none"), + div(cls := "form-group relay-form__sync relay-form__sync-push none")( + p( + "Send your local games to Lichess using ", + a(href := "https://github.com/lichess-org/broadcaster")("the Lichess Broadcaster App"), + "." + ) + ), + form3.split(cls := "relay-form__sync relay-form__sync-url relay-form__sync-urls none")( + form3.group( + form("onlyRound"), + raw("Filter games by round number"), + help = frag( + "Optional, only keep games from the source that match a round number." + ).some, + half = true + )(form3.input(_, typ = "number"))(cls := List("none" -> isLcc)), + form3.group( + form("slices"), + raw("Select slices of the games"), + help = frag( + "Optional. Select games based on their position in the source.", + br, + pre(""" +1 only select the first board +1-4 only select the first 4 boards +1,2,3,4 same as above, first 4 boards +11-15,21-25 boards 11 to 15, and boards 21 to 25 +2,3,7-9 boards 2, 3, 7, 8, and 9 +"""), + "Slicing is done after filtering by round number." + ).some, + half = true + )(form3.input(_)) + ) + ), form3.split( form3.group( form("startsAt"), @@ -209,33 +261,6 @@ final class FormUi(helpers: Helpers, ui: RelayUi, tourUi: RelayTourUi): )(form3.input(_, typ = "number")) ) ), - form3.split( - form3.group( - form("onlyRound"), - raw("Filter games by round number"), - help = frag( - "Optional, only keep games from the source that match a round number." - ).some, - half = true - )(form3.input(_, typ = "number")), - form3.group( - form("slices"), - raw("Select slices of the games"), - help = frag( - "Optional. Select games based on their position in the source.", - br, - pre(""" -1 only select the first board -1-4 only select the first 4 boards -1,2,3,4 same as above, first 4 boards -11-15,21-25 boards 11 to 15, and boards 21 to 25 -2,3,7-9 boards 2, 3, 7, 8, and 9 -"""), - "Slicing is done after filtering by round number." - ).some, - half = true - )(form3.input(_)) - ), form3.actions( a(href := routes.RelayTour.show(t.slug, t.id))(trans.site.cancel()), form3.submit(trans.site.apply()) @@ -470,7 +495,7 @@ final class FormUi(helpers: Helpers, ui: RelayUi, tourUi: RelayTourUi): ) ) - def grouping(form: Form[RelayTourForm.Data])(using Context) = + private def grouping(form: Form[RelayTourForm.Data])(using Context) = form3.split(cls := "relay-form__grouping")( form3.group( form("grouping"), diff --git a/modules/ui/src/main/helper/Form3.scala b/modules/ui/src/main/helper/Form3.scala index 27d75919f35d2..e7a014b499010 100644 --- a/modules/ui/src/main/helper/Form3.scala +++ b/modules/ui/src/main/helper/Form3.scala @@ -6,6 +6,7 @@ import scalalib.Render import lila.ui.ScalatagsTemplate.{ *, given } import lila.core.user.FlairApi import lila.core.i18n.{ I18nKey as trans, Translate } +import scalatags.Text.TypedTag final class Form3(formHelper: FormHelper & I18nHelper, flairApi: FlairApi): diff --git a/translation/source/broadcast.xml b/translation/source/broadcast.xml index 011b9d493b95c..d7ddd12a58b7c 100644 --- a/translation/source/broadcast.xml +++ b/translation/source/broadcast.xml @@ -23,9 +23,9 @@ Short tournament description Full tournament description Optional long description of the tournament. %1$s is available. Length must be less than %2$s characters. - Source URL, or game IDs + Source URL, or game IDs URL that Lichess will check to get PGN updates. It must be publicly accessible from the Internet. - Alternatively, you can enter up to 64 Lichess game IDs, separated by spaces. + Up to 64 Lichess game IDs, separated by spaces. Start date in your own timezone Optional, if you know when the event starts Credit the source diff --git a/ui/analyse/src/study/relay/interfaces.ts b/ui/analyse/src/study/relay/interfaces.ts index d70bd288bbf25..4a0d89a0a04e4 100644 --- a/ui/analyse/src/study/relay/interfaces.ts +++ b/ui/analyse/src/study/relay/interfaces.ts @@ -44,6 +44,7 @@ export interface RelayTour { export interface RelaySync { ongoing: boolean; url?: string; + urls?: [{ url: string }]; ids?: string; log: LogEvent[]; delay?: number; diff --git a/ui/analyse/src/study/relay/relayManagerView.ts b/ui/analyse/src/study/relay/relayManagerView.ts index 21d7fbb86f598..7cc2bd15db661 100644 --- a/ui/analyse/src/study/relay/relayManagerView.ts +++ b/ui/analyse/src/study/relay/relayManagerView.ts @@ -7,7 +7,8 @@ import { side as studyViewSide } from '../studyView'; import StudyCtrl from '../studyCtrl'; export default function (ctrl: RelayCtrl, study: StudyCtrl): MaybeVNode { - const contributor = ctrl.members.canContribute(); + const contributor = ctrl.members.canContribute(), + sync = ctrl.data.sync; return contributor || study.data.admin ? h('div.relay-admin__container', [ contributor @@ -16,9 +17,7 @@ export default function (ctrl: RelayCtrl, study: StudyCtrl): MaybeVNode { h('span.text', { attrs: dataIcon(licon.RadioTower) }, 'Broadcast manager'), h('a', { attrs: { href: `/broadcast/round/${ctrl.id}/edit`, 'data-icon': licon.Gear } }), ]), - ctrl.data.sync?.url || ctrl.data.sync?.ids - ? (ctrl.data.sync.ongoing ? stateOn : stateOff)(ctrl) - : null, + sync?.url || sync?.ids || sync?.urls ? (sync.ongoing ? stateOn : stateOff)(ctrl) : null, renderLog(ctrl), ]) : undefined, @@ -52,6 +51,7 @@ function renderLog(ctrl: RelayCtrl) { function stateOn(ctrl: RelayCtrl) { const sync = ctrl.data.sync, url = sync?.url, + urls = sync?.urls, ids = sync?.ids; return h( 'div.state.on.clickable', @@ -67,6 +67,8 @@ function stateOn(ctrl: RelayCtrl) { ] : ids ? ['Connected to', h('br'), ids.length, ' game(s)'] + : urls + ? ['Connected to', h('br'), urls.length, ' urls'] : [], ), ], diff --git a/ui/bits/css/relay/_form.scss b/ui/bits/css/relay/_form.scss index 48e0c22d62b45..62030d3ddcda8 100644 --- a/ui/bits/css/relay/_form.scss +++ b/ui/bits/css/relay/_form.scss @@ -55,6 +55,16 @@ } } +.relay-form__sync-lcc { + .form-half:first-child { + flex: 0 1 76%; + } + .form-half:last-child { + flex: 0 1 20%; + min-width: 3ch; + } +} + @include mq-subnav-side { .relay-form__subnav__group { display: block; diff --git a/ui/bits/src/bits.relayForm.ts b/ui/bits/src/bits.relayForm.ts index f1f177ebd95b5..3c1b2b7a63d1f 100644 --- a/ui/bits/src/bits.relayForm.ts +++ b/ui/bits/src/bits.relayForm.ts @@ -7,6 +7,20 @@ site.load.then(() => { selectClicks: $('.select-image, .drop-target'), selectDrags: $('.drop-target'), }); + + pinnedStreamerForm(); + + const $source = $('#form3-syncSource'), + showSource = () => + $('.relay-form__sync').each(function (this: HTMLElement) { + this.classList.toggle('none', !this.classList.contains(`relay-form__sync-${$source.val()}`)); + }); + + $source.on('change', showSource); + showSource(); +}); + +function pinnedStreamerForm() { const pinned = document.querySelector('.relay-pinned-streamer-edit') as HTMLElement; if (!pinned) return; @@ -27,4 +41,4 @@ site.load.then(() => { else deleteImageBtn.onclick = () => fetch(deleteImageBtn.dataset.postUrl!, { method: 'POST', body: new FormData() }).then(site.reload); -}); +} diff --git a/ui/common/css/form/_form3.scss b/ui/common/css/form/_form3.scss index 9d000a5dc0d99..6b49d14c12ca6 100644 --- a/ui/common/css/form/_form3.scss +++ b/ui/common/css/form/_form3.scss @@ -133,10 +133,12 @@ textarea.form-control { .form-fieldset { @extend %box-radius; - margin: 1.5em 0; + margin: 1rem 0 3rem 0; border-color: rgba(128, 128, 128, 0.3); + padding: 2rem 2rem 0 2rem; legend { + padding: 0 1em; text-align: center; font-style: italic; font-size: 1.2em; diff --git a/ui/simul/css/_form.scss b/ui/simul/css/_form.scss index 664ffad554216..e150195fd23a9 100644 --- a/ui/simul/css/_form.scss +++ b/ui/simul/css/_form.scss @@ -23,11 +23,4 @@ } } } - - .form-fieldset { - legend { - padding: 0 1em; - } - padding: 1em; - } } From c375705198429ff65c324f8a45e509148006dd27 Mon Sep 17 00:00:00 2001 From: Thibault Duplessis Date: Wed, 19 Jun 2024 13:19:42 +0200 Subject: [PATCH 142/168] mapN --- modules/relay/src/main/RelayGame.scala | 10 +++------- 1 file changed, 3 insertions(+), 7 deletions(-) diff --git a/modules/relay/src/main/RelayGame.scala b/modules/relay/src/main/RelayGame.scala index 8b59b6f530cd0..dee3cc97ad08f 100644 --- a/modules/relay/src/main/RelayGame.scala +++ b/modules/relay/src/main/RelayGame.scala @@ -100,13 +100,9 @@ private object RelayGame: .map(_.trim) .flatMap: s => s.split('-').toList.map(_.trim) match - case Nil => none - case from :: Nil => from.toIntOption.map(f => Slice(f, f)) - case from :: to :: _ => - for - f <- from.toIntOption - t <- to.toIntOption - yield Slice(f, t) + case Nil => none + case from :: Nil => from.toIntOption.map(f => Slice(f, f)) + case from :: to :: _ => (from.toIntOption, to.toIntOption).mapN(Slice.apply) def show(slices: List[Slice]): String = slices .map: From 89c334cb8b3c37364db415dbfd58b7c8113b151d Mon Sep 17 00:00:00 2001 From: Thibault Duplessis Date: Wed, 19 Jun 2024 14:46:12 +0200 Subject: [PATCH 143/168] refactor broadcast sync source --- bin/mongodb/relay-lcc-migrate.js | 2 +- modules/relay/src/main/RelayApi.scala | 5 +- modules/relay/src/main/RelayDelay.scala | 22 ++++----- modules/relay/src/main/RelayFetch.scala | 23 +++++---- modules/relay/src/main/RelayFormat.scala | 36 ++++++-------- modules/relay/src/main/RelayRound.scala | 18 ++++--- modules/relay/src/main/RelayRoundForm.scala | 55 +++++++++++---------- modules/relay/src/main/ui/FormUi.scala | 38 +++++++------- ui/bits/css/relay/_form.scss | 10 ---- 9 files changed, 100 insertions(+), 109 deletions(-) diff --git a/bin/mongodb/relay-lcc-migrate.js b/bin/mongodb/relay-lcc-migrate.js index e2c53262ca08c..e716fe2167898 100644 --- a/bin/mongodb/relay-lcc-migrate.js +++ b/bin/mongodb/relay-lcc-migrate.js @@ -7,7 +7,7 @@ db.relay.find({ 'sync.upstream.url': /view\.livechesscloud\.com/ }).forEach(rela const id = url.match(regex)[1]; const round = parseInt(url.split(' ')[1]) || 1; if (!id) throw new Error('No id in ' + url); - db.relay.updateOne({ _id: relay._id }, { $set: { 'sync.upstream': { lcc: { id, round } } } }); + db.relay.updateOne({ _id: relay._id }, { $set: { 'sync.upstream': { lcc: id, round } } }); done++; } catch (e) { failed++; diff --git a/modules/relay/src/main/RelayApi.scala b/modules/relay/src/main/RelayApi.scala index 760270c8a686a..ca32574e5ab97 100644 --- a/modules/relay/src/main/RelayApi.scala +++ b/modules/relay/src/main/RelayApi.scala @@ -9,7 +9,7 @@ import scala.util.chaining.* import lila.db.dsl.{ *, given } import lila.memo.{ CacheApi, PicfitApi } -import lila.relay.RelayRound.WithTour +import lila.relay.RelayRound.{ WithTour, Sync } import lila.core.perm.Granter import lila.core.study.data.StudyName import lila.study.{ Settings, Study, StudyApi, StudyId, StudyMaker, StudyRepo, StudyTopic } @@ -244,7 +244,8 @@ final class RelayApi( def requestPlay(id: RelayRoundId, v: Boolean): Funit = WithRelay(id): relay => - relay.sync.upstream.foreach(formatApi.refresh) + relay.sync.upstream.collect: + case f: Sync.FetchableUpstream => formatApi.refresh(f) isOfficial(relay.id).flatMap: official => update(relay): r => if v diff --git a/modules/relay/src/main/RelayDelay.scala b/modules/relay/src/main/RelayDelay.scala index ee90565ae3e9f..81add186ced9d 100644 --- a/modules/relay/src/main/RelayDelay.scala +++ b/modules/relay/src/main/RelayDelay.scala @@ -6,7 +6,7 @@ import scalalib.model.Seconds import lila.db.dsl.{ *, given } import lila.memo.CacheApi -import lila.relay.RelayRound.Sync.UpstreamUrl +import lila.relay.RelayRound.Sync.FetchableUpstream import lila.study.MultiPgn final private class RelayDelay(colls: RelayColls)(using Executor): @@ -14,9 +14,9 @@ final private class RelayDelay(colls: RelayColls)(using Executor): import RelayDelay.* def apply( - url: UpstreamUrl, + url: FetchableUpstream, round: RelayRound, - doFetchUrl: (UpstreamUrl, Max) => Fu[RelayGames] + doFetchUrl: (FetchableUpstream, Max) => Fu[RelayGames] ): Fu[RelayGames] = dedupCache(url, round, () => doFetchUrl(url, RelayFetch.maxChapters)) .flatMap: latest => @@ -31,10 +31,10 @@ final private class RelayDelay(colls: RelayColls)(using Executor): private val cache = CacheApi.scaffeineNoScheduler .initialCapacity(8) .maximumSize(128) - .build[UpstreamUrl, GamesSeenBy]() + .build[FetchableUpstream, GamesSeenBy]() .underlying - def apply(url: UpstreamUrl, round: RelayRound, doFetch: () => Fu[RelayGames]) = + def apply(url: FetchableUpstream, round: RelayRound, doFetch: () => Fu[RelayGames]) = cache.asMap .compute( url, @@ -51,10 +51,10 @@ final private class RelayDelay(colls: RelayColls)(using Executor): private object store: - private def idOf(upstream: UpstreamUrl, at: Instant) = s"${upstream.url} ${at.toSeconds}" - private val longPast = java.time.Instant.ofEpochMilli(0) + private def idOf(upstream: FetchableUpstream, at: Instant) = s"${upstream.url} ${at.toSeconds}" + private val longPast = java.time.Instant.ofEpochMilli(0) - def putIfNew(upstream: UpstreamUrl, games: RelayGames): Funit = + def putIfNew(upstream: FetchableUpstream, games: RelayGames): Funit = val newPgn = RelayGame.iso.from(games).toPgnStr getLatestPgn(upstream).flatMap: case Some(latestPgn) if latestPgn == newPgn => funit @@ -64,14 +64,14 @@ final private class RelayDelay(colls: RelayColls)(using Executor): colls.delay: _.insert.one(doc).void - def get(upstream: UpstreamUrl, delay: Seconds): Fu[Option[RelayGames]] = + def get(upstream: FetchableUpstream, delay: Seconds): Fu[Option[RelayGames]] = getPgn(upstream, delay).map2: pgn => RelayGame.iso.to(MultiPgn.split(pgn, Max(999))) - private def getLatestPgn(upstream: UpstreamUrl): Fu[Option[PgnStr]] = + private def getLatestPgn(upstream: FetchableUpstream): Fu[Option[PgnStr]] = getPgn(upstream, Seconds(0)) - private def getPgn(upstream: UpstreamUrl, delay: Seconds): Fu[Option[PgnStr]] = + private def getPgn(upstream: FetchableUpstream, delay: Seconds): Fu[Option[PgnStr]] = colls.delay: _.find( $doc( diff --git a/modules/relay/src/main/RelayFetch.scala b/modules/relay/src/main/RelayFetch.scala index 98de665690b4d..0271e303e391b 100644 --- a/modules/relay/src/main/RelayFetch.scala +++ b/modules/relay/src/main/RelayFetch.scala @@ -6,6 +6,7 @@ import chess.{ Outcome, Ply } import com.github.blemale.scaffeine.LoadingCache import io.mola.galimatias.URL import play.api.libs.json.* +import scalalib.model.Seconds import lila.core.lilaism.LilaInvalid import lila.common.LilaScheduler @@ -13,10 +14,8 @@ import lila.game.{ GameRepo, PgnDump } import lila.memo.CacheApi import lila.study.{ MultiPgn, StudyPgnImport } import lila.tree.Node.Comments - -import RelayRound.Sync.{ UpstreamIds, UpstreamUrl, UpstreamUrls } -import RelayFormat.CanProxy -import scalalib.model.Seconds +import lila.relay.RelayRound.Sync +import lila.relay.RelayFormat.CanProxy final private class RelayFetch( sync: RelaySync, @@ -142,7 +141,7 @@ final private class RelayFetch( Seconds(60) else round.sync.period | Seconds: - if upstream.asUrl.exists(_.isLcc) && !tour.official then 12 + if upstream.isLcc && !tour.official then 12 else 5 updating: _.withSync: @@ -166,10 +165,12 @@ final private class RelayFetch( ) private def fetchGames(rt: RelayRound.WithTour): Fu[RelayGames] = + given CanProxy = CanProxy(rt.tour.official) rt.round.sync.upstream.so: - case UpstreamIds(ids) => fetchFromGameIds(rt.tour, ids) - case url: UpstreamUrl => delayer(url, rt.round, fetchFromUpstream(using CanProxy(rt.tour.official))) - case UpstreamUrls(urls) => + case Sync.UpstreamIds(ids) => fetchFromGameIds(rt.tour, ids) + case lcc: Sync.UpstreamLcc => fetchFromUpstream(lcc, RelayFetch.maxChapters) + case url: Sync.UpstreamUrl => delayer(url, rt.round, fetchFromUpstream) + case Sync.UpstreamUrls(urls) => urls .traverse: url => delayer(url, rt.round, fetchFromUpstream(using CanProxy(rt.tour.official))) @@ -194,10 +195,12 @@ final private class RelayFetch( } .flatMap(multiPgnToGames(_).toFuture) - private def fetchFromUpstream(using canProxy: CanProxy)(upstream: UpstreamUrl, max: Max): Fu[RelayGames] = + private def fetchFromUpstream(using + canProxy: CanProxy + )(upstream: Sync.FetchableUpstream, max: Max): Fu[RelayGames] = import DgtJson.* formatApi - .get(upstream.withRound) + .get(upstream) .flatMap { case RelayFormat.SingleFile(doc) => doc.format match diff --git a/modules/relay/src/main/RelayFormat.scala b/modules/relay/src/main/RelayFormat.scala index 21d55e19cbd8c..210e34be398e6 100644 --- a/modules/relay/src/main/RelayFormat.scala +++ b/modules/relay/src/main/RelayFormat.scala @@ -29,44 +29,38 @@ final private class RelayFormatApi( )(using Executor): import RelayFormat.* - import RelayRound.Sync.{ Upstream, UpstreamUrl, UpstreamLcc } + import RelayRound.Sync.{ FetchableUpstream, UpstreamUrl, UpstreamLcc } - private val cache = cacheApi[(Upstream, CanProxy), RelayFormat](64, "relay.format"): + private val cache = cacheApi[(FetchableUpstream, CanProxy), RelayFormat](64, "relay.format"): _.expireAfterWrite(5 minutes) .buildAsyncFuture: (url, proxy) => guessFormat(url)(using proxy) - def get(upstream: Upstream)(using proxy: CanProxy): Fu[RelayFormat] = + def get(upstream: FetchableUpstream)(using proxy: CanProxy): Fu[RelayFormat] = cache.get(upstream -> proxy) - def refresh(upstream: Upstream): Unit = + def refresh(upstream: FetchableUpstream): Unit = CanProxy .from(List(false, true)) .foreach: proxy => cache.invalidate(upstream -> proxy) - private def guessFormat(upstream: Upstream)(using CanProxy): Fu[RelayFormat] = { + private def guessFormat(upstream: FetchableUpstream)(using CanProxy): Fu[RelayFormat] = { - // val originalUrl = URL.parse(upstream.url) + def parsedUrl = URL.parse(upstream.url) - // http://view.livechesscloud.com/ed5fb586-f549-4029-a470-d590f8e30c76 - def guessLcc(using CanProxy): Fu[Option[RelayFormat]] = upstream match - case UpstreamLcc(id, round) => - guessManyFiles: - URL.parse: - s"http://1.pool.livechesscloud.com/get/$id/round-$round/index.json" - case _ => fuccess(none) - - def guessSingleFile(url: URL)(using CanProxy): Fu[Option[RelayFormat]] = + def guessSingleFile(url: URL): Fu[Option[RelayFormat]] = List( url.some, - (!url.pathSegments.contains(mostCommonSingleFileName)).option(addPart(url, mostCommonSingleFileName)) + (!url.pathSegments.contains(mostCommonSingleFileName)).option( + addPart(url, mostCommonSingleFileName) + ) ).flatten.distinct .findM(looksLikePgn) .dmap2: (u: URL) => SingleFile(pgnDoc(u)) - def guessManyFiles(url: URL)(using CanProxy): Fu[Option[RelayFormat]] = + def guessManyFiles(url: URL): Fu[Option[RelayFormat]] = (List(url) ::: mostCommonIndexNames .filterNot(url.pathSegments.contains) .map(addPart(url, _))) @@ -87,10 +81,10 @@ final private class RelayFormatApi( ManyFiles(index, _) .dmap(_.orElse(ManyFilesLater(index).some)) - guessLcc(originalUrl) - .orElse(guessSingleFile(originalUrl)) - .orElse(guessManyFiles(originalUrl)) - .orFailWith(LilaInvalid(s"No games found at $originalUrl")) + guessSingleFile(parsedUrl) + .orElse(guessManyFiles(parsedUrl)) + .orFailWith(LilaInvalid(s"No games found at $upstream")) + }.addEffect { format => logger.info(s"guessed format of $upstream: $format") } diff --git a/modules/relay/src/main/RelayRound.scala b/modules/relay/src/main/RelayRound.scala index 84c31915d0699..b200be6266149 100644 --- a/modules/relay/src/main/RelayRound.scala +++ b/modules/relay/src/main/RelayRound.scala @@ -114,16 +114,18 @@ object RelayRound: override def toString = upstream.toString object Sync: - sealed trait Upstream - case class UpstreamUrl(url: String) extends Upstream - case class UpstreamLcc(id: String, round: Int) extends Upstream: - def url = s"https://view.livechesscloud.com/#$id" + sealed trait Upstream: + def isLcc = false + sealed trait FetchableUpstream extends Upstream: + def url: String + case class UpstreamUrl(url: String) extends FetchableUpstream + case class UpstreamLcc(lcc: String, round: Int) extends FetchableUpstream: + override def isLcc = true + def id = lcc + def url = s"http://1.pool.livechesscloud.com/get/$id/round-$round/index.json" + def viewUrl = s"https://view.livechesscloud.com/#$id" case class UpstreamUrls(urls: List[UpstreamUrl]) extends Upstream case class UpstreamIds(ids: List[GameId]) extends Upstream - val LccRegex = """.*view\.livechesscloud\.com/?#?([0-9a-f\-]+)""".r - def tryLcc(url: String): Option[UpstreamLcc] = url match - case LccRegex(id) => UpstreamLcc(id, 1).some - case _ => none trait AndTour: val tour: RelayTour diff --git a/modules/relay/src/main/RelayRoundForm.scala b/modules/relay/src/main/RelayRoundForm.scala index 8c144eb8788b7..98d972f760c67 100644 --- a/modules/relay/src/main/RelayRoundForm.scala +++ b/modules/relay/src/main/RelayRoundForm.scala @@ -42,25 +42,29 @@ final class RelayRoundForm(using mode: Mode): _.ids.mkString(" ") ) + val lccMapping = mapping( + "id" -> cleanText(minLength = 10, maxLength = 40), + "round" -> number(min = 1, max = 999) + )(Sync.UpstreamLcc.apply)(unapply) + val roundMapping = mapping( - "name" -> cleanText(minLength = 3, maxLength = 80).into[RelayRound.Name], - "caption" -> optional(cleanText(minLength = 3, maxLength = 80).into[RelayRound.Caption]), - "syncSource" -> optional(stringIn(sourceTypes.map(_._1).toSet)), - "syncUrl" -> optional(of[Sync.UpstreamUrl]), - "syncUrls" -> optional(of[Sync.UpstreamUrls]), - "syncIds" -> optional(of[Sync.UpstreamIds]), - "syncUrlRound" -> optional(number(min = 1, max = 999)), - "startsAt" -> optional(ISOInstantOrTimestamp.mapping), - "finished" -> optional(boolean), - "period" -> optional(number(min = 2, max = 60).into[Seconds]), - "delay" -> optional(number(min = 0, max = RelayDelay.maxSeconds.value).into[Seconds]), - "onlyRound" -> optional(number(min = 1, max = 999)), + "name" -> cleanText(minLength = 3, maxLength = 80).into[RelayRound.Name], + "caption" -> optional(cleanText(minLength = 3, maxLength = 80).into[RelayRound.Caption]), + "syncSource" -> optional(stringIn(sourceTypes.map(_._1).toSet)), + "syncUrl" -> optional(of[Sync.UpstreamUrl]), + "syncUrls" -> optional(of[Sync.UpstreamUrls]), + "syncLcc" -> optional(lccMapping), + "syncIds" -> optional(of[Sync.UpstreamIds]), + "startsAt" -> optional(ISOInstantOrTimestamp.mapping), + "finished" -> optional(boolean), + "period" -> optional(number(min = 2, max = 60).into[Seconds]), + "delay" -> optional(number(min = 0, max = RelayDelay.maxSeconds.value).into[Seconds]), + "onlyRound" -> optional(number(min = 1, max = 999)), "slices" -> optional: nonEmptyText .transform[List[RelayGame.Slice]](RelayGame.Slices.parse, RelayGame.Slices.show) )(Data.apply)(unapply) - .verifying("This source requires a round number. See the new form field below.", !_.roundMissing) def create(trs: RelayTour.WithRounds) = Form( roundMapping @@ -77,6 +81,7 @@ object RelayRoundForm: val sourceTypes = List( "url" -> "Single PGN URL", "urls" -> "Combine several PGN URLs", + "lcc" -> "LiveChessCloud page", "ids" -> "Lichess game IDs", "push" -> "Push local games" ) @@ -117,8 +122,7 @@ object RelayRoundForm: name = RelayRound.Name(guessName | s"Round ${nextNumber}"), caption = prev.flatMap(_.caption), syncSource = prev.map(Data.make).flatMap(_.syncSource), - syncUrl = nextLcc.map(l => Sync.UpstreamUrl(l.url)), - syncUrlRound = nextLcc.map(_.round), + syncLcc = nextLcc, startsAt = guessDate, period = prev.flatMap(_.sync.period), delay = prev.flatMap(_.sync.delay), @@ -184,8 +188,8 @@ object RelayRoundForm: syncSource: Option[String], syncUrl: Option[Sync.UpstreamUrl] = None, syncUrls: Option[Sync.UpstreamUrls] = None, + syncLcc: Option[Sync.UpstreamLcc] = None, syncIds: Option[Sync.UpstreamIds] = None, - syncUrlRound: Option[Int] = None, startsAt: Option[Instant] = None, finished: Option[Boolean] = None, period: Option[Seconds] = None, @@ -194,18 +198,13 @@ object RelayRoundForm: slices: Option[List[RelayGame.Slice]] = None ): def upstream: Option[Sync.Upstream] = syncSource match - case None => syncUrl.orElse(syncUrls).orElse(syncIds) - case Some("url") => - syncUrl.map: u => - (Sync.tryLcc(u.url), syncUrlRound).mapN((l, r) => l.copy(round = r)) | u + case None => syncUrl.orElse(syncUrls).orElse(syncIds) + case Some("url") => syncUrl case Some("urls") => syncUrls + case Some("lcc") => syncLcc case Some("ids") => syncIds case _ => None - def roundMissing = upstream.exists: - case u: Sync.UpstreamUrl => Sync.tryLcc(u.url).isDefined - case _ => false - def update(official: Boolean)(relay: RelayRound)(using me: Me)(using mode: Mode) = val sync = makeSync(me) relay.copy( @@ -252,16 +251,18 @@ object RelayRoundForm: .fold("push"): case _: Sync.UpstreamUrl => "url" case _: Sync.UpstreamUrls => "urls" + case _: Sync.UpstreamLcc => "lcc" case _: Sync.UpstreamIds => "ids" .some, syncUrl = relay.sync.upstream.collect: - case url: Sync.UpstreamUrl => url.withoutRound, + case url: Sync.UpstreamUrl => url, syncUrls = relay.sync.upstream.collect: - case url: Sync.UpstreamUrl => Sync.UpstreamUrls(List(url.withoutRound)) + case url: Sync.UpstreamUrl => Sync.UpstreamUrls(List(url)) case urls: Sync.UpstreamUrls => urls, + syncLcc = relay.sync.upstream.collect: + case lcc: Sync.UpstreamLcc => lcc, syncIds = relay.sync.upstream.collect: case ids: Sync.UpstreamIds => ids, - syncUrlRound = relay.sync.upstream.flatMap(_.asUrl).flatMap(_.withRound.round), startsAt = relay.startsAt, finished = relay.finished.option(true), period = relay.sync.period, diff --git a/modules/relay/src/main/ui/FormUi.scala b/modules/relay/src/main/ui/FormUi.scala index 15e4b7a97a33d..0000349137d2b 100644 --- a/modules/relay/src/main/ui/FormUi.scala +++ b/modules/relay/src/main/ui/FormUi.scala @@ -129,7 +129,6 @@ final class FormUi(helpers: Helpers, ui: RelayUi, tourUi: RelayTourUi): private def inner(form: Form[RelayRoundForm.Data], url: play.api.mvc.Call, t: RelayTour, create: Boolean)( using ctx: Context ) = - val isLcc = form("syncUrl").value.exists(RelayRound.Sync.UpstreamUrl.LccRegex.matches) postForm(cls := "form3", action := url)( (!Granter.opt(_.StudyAdmin)).option: div(cls := "form-group")( @@ -159,25 +158,26 @@ final class FormUi(helpers: Helpers, ui: RelayUi, tourUi: RelayTourUi): form("syncSource"), "Where do the games come from?" )(form3.select(_, RelayRoundForm.sourceTypes)), - div( - cls := List( - "relay-form__sync relay-form__sync-url" -> true, - "form-split relay-form__sync-lcc" -> isLcc - ) - )( + form3.group( + form("syncUrl"), + trb.sourceUrl(), + help = trb.sourceUrlHelp().some + )(form3.input(_))(cls := "relay-form__sync relay-form__sync-url"), + form3.split(cls := "relay-form__sync relay-form__sync-lcc none")( form3.group( - form("syncUrl"), - trb.sourceUrl(), - help = trb.sourceUrlHelp().some, - half = isLcc + form("syncLcc.id"), + "Tournament ID", + help = frag( + "From the LCC page URL. The ID looks like this: ", + pre("f1943ec6-4992-45d9-969d-a0aff688b404") + ).some, + half = true )(form3.input(_)), - isLcc.option: - form3.group( - form("syncUrlRound"), - trb.roundNumber(), - help = frag("Only for livechesscloud source URLs").some, - half = true - )(form3.input(_, typ = "number")) + form3.group( + form("syncLcc.round"), + trb.roundNumber(), + half = true + )(form3.input(_, typ = "number")) ), form3.group( form("syncUrls"), @@ -205,7 +205,7 @@ final class FormUi(helpers: Helpers, ui: RelayUi, tourUi: RelayTourUi): "Optional, only keep games from the source that match a round number." ).some, half = true - )(form3.input(_, typ = "number"))(cls := List("none" -> isLcc)), + )(form3.input(_, typ = "number")), form3.group( form("slices"), raw("Select slices of the games"), diff --git a/ui/bits/css/relay/_form.scss b/ui/bits/css/relay/_form.scss index 62030d3ddcda8..48e0c22d62b45 100644 --- a/ui/bits/css/relay/_form.scss +++ b/ui/bits/css/relay/_form.scss @@ -55,16 +55,6 @@ } } -.relay-form__sync-lcc { - .form-half:first-child { - flex: 0 1 76%; - } - .form-half:last-child { - flex: 0 1 20%; - min-width: 3ch; - } -} - @include mq-subnav-side { .relay-form__subnav__group { display: block; From 9950b2e6f669b541ca3f0772d53c1a318a12c44d Mon Sep 17 00:00:00 2001 From: Thibault Duplessis Date: Wed, 19 Jun 2024 14:51:12 +0200 Subject: [PATCH 144/168] fix lcc format --- modules/relay/src/main/RelayFormat.scala | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/modules/relay/src/main/RelayFormat.scala b/modules/relay/src/main/RelayFormat.scala index 210e34be398e6..6938a708c357e 100644 --- a/modules/relay/src/main/RelayFormat.scala +++ b/modules/relay/src/main/RelayFormat.scala @@ -49,6 +49,8 @@ final private class RelayFormatApi( def parsedUrl = URL.parse(upstream.url) + def guessLcc: Fu[Option[RelayFormat]] = upstream.isLcc.so(guessManyFiles(parsedUrl)) + def guessSingleFile(url: URL): Fu[Option[RelayFormat]] = List( url.some, @@ -81,7 +83,8 @@ final private class RelayFormatApi( ManyFiles(index, _) .dmap(_.orElse(ManyFilesLater(index).some)) - guessSingleFile(parsedUrl) + guessLcc + .orElse(guessSingleFile(parsedUrl)) .orElse(guessManyFiles(parsedUrl)) .orFailWith(LilaInvalid(s"No games found at $upstream")) From 6a83f4fec23e3788605be8b89a1741df1b5f05dc Mon Sep 17 00:00:00 2001 From: Thibault Duplessis Date: Wed, 19 Jun 2024 15:00:30 +0200 Subject: [PATCH 145/168] guess lcc sources --- modules/relay/src/main/RelayRound.scala | 6 +++- modules/relay/src/main/RelayRoundForm.scala | 32 ++++++++++++++------- 2 files changed, 26 insertions(+), 12 deletions(-) diff --git a/modules/relay/src/main/RelayRound.scala b/modules/relay/src/main/RelayRound.scala index b200be6266149..3b70161ee0674 100644 --- a/modules/relay/src/main/RelayRound.scala +++ b/modules/relay/src/main/RelayRound.scala @@ -118,7 +118,10 @@ object RelayRound: def isLcc = false sealed trait FetchableUpstream extends Upstream: def url: String - case class UpstreamUrl(url: String) extends FetchableUpstream + case class UpstreamUrl(url: String) extends FetchableUpstream: + def findLccId: Option[String] = url match + case LccRegex(id) => id.some + case _ => none case class UpstreamLcc(lcc: String, round: Int) extends FetchableUpstream: override def isLcc = true def id = lcc @@ -126,6 +129,7 @@ object RelayRound: def viewUrl = s"https://view.livechesscloud.com/#$id" case class UpstreamUrls(urls: List[UpstreamUrl]) extends Upstream case class UpstreamIds(ids: List[GameId]) extends Upstream + private val LccRegex = """.*view\.livechesscloud\.com/?#?([0-9a-f\-]+)""".r trait AndTour: val tour: RelayTour diff --git a/modules/relay/src/main/RelayRoundForm.scala b/modules/relay/src/main/RelayRoundForm.scala index 98d972f760c67..3140e3f317b41 100644 --- a/modules/relay/src/main/RelayRoundForm.scala +++ b/modules/relay/src/main/RelayRoundForm.scala @@ -86,15 +86,16 @@ object RelayRoundForm: "push" -> "Push local games" ) + private val roundNumberRegex = """([^\d]*)(\d{1,2})([^\d]*)""".r + val roundNumberIn: String => Option[Int] = + case roundNumberRegex(_, n, _) => n.toIntOption + case _ => none + def fillFromPrevRounds(rounds: List[RelayRound]): Data = val prevs: Option[(RelayRound, RelayRound)] = rounds.reverse match case a :: b :: _ => (a, b).some case _ => none val prev: Option[RelayRound] = rounds.lastOption - val roundNumberRegex = """([^\d]*)(\d{1,2})([^\d]*)""".r - val roundNumberIn: String => Option[Int] = - case roundNumberRegex(_, n, _) => n.toIntOption - case _ => none def replaceRoundNumber(s: String, n: Int): String = roundNumberRegex.replaceAllIn(s, m => s"${m.group(1)}${n}${m.group(3)}") val prevNumber: Option[Int] = prev.flatMap(p => roundNumberIn(p.name.value)) @@ -197,13 +198,22 @@ object RelayRoundForm: onlyRound: Option[Int] = None, slices: Option[List[RelayGame.Slice]] = None ): - def upstream: Option[Sync.Upstream] = syncSource match - case None => syncUrl.orElse(syncUrls).orElse(syncIds) - case Some("url") => syncUrl - case Some("urls") => syncUrls - case Some("lcc") => syncLcc - case Some("ids") => syncIds - case _ => None + def upstream: Option[Sync.Upstream] = syncSource + .match + case None => syncUrl.orElse(syncUrls).orElse(syncIds) + case Some("url") => syncUrl + case Some("urls") => syncUrls + case Some("lcc") => syncLcc + case Some("ids") => syncIds + case _ => None + .map: + case url: Sync.UpstreamUrl => + val foundLcc = for + lccId <- url.findLccId + round <- roundNumberIn(name.value) + yield Sync.UpstreamLcc(lccId, round) + foundLcc | url + case up => up def update(official: Boolean)(relay: RelayRound)(using me: Me)(using mode: Mode) = val sync = makeSync(me) From 59083047e9dbd3a4ca39306fdea93287117d677c Mon Sep 17 00:00:00 2001 From: Jonathan Gamble <101470903+schlawg@users.noreply.github.com> Date: Wed, 19 Jun 2024 08:59:06 -0500 Subject: [PATCH 146/168] better object equivalence --- ui/.build/src/manifest.ts | 59 ++++++++++++++++++++++----------------- 1 file changed, 33 insertions(+), 26 deletions(-) diff --git a/ui/.build/src/manifest.ts b/ui/.build/src/manifest.ts index ddf070021f87c..65df38abc3708 100644 --- a/ui/.build/src/manifest.ts +++ b/ui/.build/src/manifest.ts @@ -29,7 +29,7 @@ export async function css() { const css: { name: string; hash: string }[] = await Promise.all(files.map(hashMove)); const newCssManifest: Manifest = {}; for (const { name, hash } of css) newCssManifest[name] = { hash }; - if (isEquivalent(newCssManifest, current.css)) return; + if (enumerableEquivalence(newCssManifest, current.css)) return; current.css = shallowSort({ ...current.css, ...newCssManifest }); clearTimeout(writeTimer); writeTimer = setTimeout(write, 500); @@ -53,7 +53,7 @@ export async function js(meta: es.Metafile) { } newJsManifest[out.name].imports = imports; } - if (isEquivalent(newJsManifest, current.js) && fs.existsSync(env.manifestFile)) return; + if (enumerableEquivalence(newJsManifest, current.js) && fs.existsSync(env.manifestFile)) return; current.js = shallowSort({ ...current.js, ...newJsManifest }); clearTimeout(writeTimer); writeTimer = setTimeout(write, 500); @@ -94,7 +94,7 @@ async function write() { await Promise.all([ fs.promises.writeFile(path.join(env.jsDir, `manifest.${hash}.js`), clientManifest), fs.promises.writeFile( - path.join(env.jsDir, `manifest.${env.prod ? 'prod' : 'dev'}.json`), + path.join(env.jsonDir, `manifest.${env.prod ? 'prod' : 'dev'}.json`), JSON.stringify(serverManifest, null, env.prod ? undefined : 2), ), ]); @@ -112,29 +112,6 @@ async function hashMove(src: string) { return { name: path.basename(src, '.css'), hash }; } -function shallowSort(obj: { [key: string]: any }): { [key: string]: any } { - // es6 string properties are insertion order, we need more determinism - const sorted: { [key: string]: any } = {}; - for (const key of Object.keys(obj).sort()) sorted[key] = obj[key]; - return sorted; -} - -function parsePath(path: string) { - const match = path.match(/\/public\/compiled\/(.*)\.([A-Z0-9]+)\.js$/); - return match ? { name: match[1], hash: match[2] } : undefined; -} - -function isEquivalent(a: any, b: any) { - // key order does NOT matter - if (typeof a !== typeof b) return false; - if (Array.isArray(a)) return a.length === b.length && a.every(x => b.includes(x)); - if (typeof a !== 'object') return a === b; - for (const key in a) { - if (!(key in b) || !isEquivalent(a[key], b[key])) return false; - } - return true; -} - async function isComplete() { for (const bundle of [...env.modules.values()].map(x => x.bundles ?? []).flat()) { const name = path.basename(bundle, '.ts'); @@ -152,3 +129,33 @@ async function isComplete() { } return true; } + +function shallowSort(obj: { [key: string]: any }): { [key: string]: any } { + // es6 string properties are insertion order, we need more determinism + const sorted: { [key: string]: any } = {}; + for (const key of Object.keys(obj).sort()) sorted[key] = obj[key]; + return sorted; +} + +function parsePath(path: string) { + const match = path.match(/\/public\/compiled\/(.*)\.([A-Z0-9]+)\.js$/); + return match ? { name: match[1], hash: match[2] } : undefined; +} + +function enumerableEquivalence(a: any, b: any) { + if (a === b) return true; + if (typeof a !== typeof b) return false; + if (Array.isArray(a)) + return a.length === b.length && a.every(x => b.find((y: any) => enumerableEquivalence(x, y))); + if (typeof a !== 'object') return false; + for (const [x, y, deep] of [ + [a, b, true], + [b, a, false], + ]) { + for (const key in x) { + if (!Object.prototype.propertyIsEnumerable.call(x, key)) continue; + if (!(key in y) || (deep && !enumerableEquivalence(x[key], y[key]))) return false; + } + } + return true; +} From 05d21993cb73be3ac33c8b7fcec3c13ac3e29cff Mon Sep 17 00:00:00 2001 From: Jonathan Gamble <101470903+schlawg@users.noreply.github.com> Date: Wed, 19 Jun 2024 09:31:57 -0500 Subject: [PATCH 147/168] use Object.keys instead of prototype --- ui/.build/src/manifest.ts | 20 ++++++++++---------- 1 file changed, 10 insertions(+), 10 deletions(-) diff --git a/ui/.build/src/manifest.ts b/ui/.build/src/manifest.ts index 65df38abc3708..25b1b9c954a51 100644 --- a/ui/.build/src/manifest.ts +++ b/ui/.build/src/manifest.ts @@ -142,20 +142,20 @@ function parsePath(path: string) { return match ? { name: match[1], hash: match[2] } : undefined; } -function enumerableEquivalence(a: any, b: any) { +function enumerableEquivalence(a: any, b: any): boolean { if (a === b) return true; if (typeof a !== typeof b) return false; if (Array.isArray(a)) - return a.length === b.length && a.every(x => b.find((y: any) => enumerableEquivalence(x, y))); + return ( + Array.isArray(b) && + a.length === b.length && + a.every(x => b.find((y: any) => enumerableEquivalence(x, y))) + ); if (typeof a !== 'object') return false; - for (const [x, y, deep] of [ - [a, b, true], - [b, a, false], - ]) { - for (const key in x) { - if (!Object.prototype.propertyIsEnumerable.call(x, key)) continue; - if (!(key in y) || (deep && !enumerableEquivalence(x[key], y[key]))) return false; - } + const [aKeys, bKeys] = [Object.keys(a), Object.keys(b)]; + if (aKeys.length !== bKeys.length) return false; + for (const key of aKeys) { + if (!bKeys.includes(key) || !enumerableEquivalence(a[key], b[key])) return false; } return true; } From f250da197ecaf2d70a3f6d3b3fc34ff836e81dbb Mon Sep 17 00:00:00 2001 From: Thibault Duplessis Date: Wed, 19 Jun 2024 18:57:24 +0200 Subject: [PATCH 148/168] document broadcats round filter --- modules/relay/src/main/ui/FormUi.scala | 13 ++++++++++++- 1 file changed, 12 insertions(+), 1 deletion(-) diff --git a/modules/relay/src/main/ui/FormUi.scala b/modules/relay/src/main/ui/FormUi.scala index 0000349137d2b..5d448a55f6a7b 100644 --- a/modules/relay/src/main/ui/FormUi.scala +++ b/modules/relay/src/main/ui/FormUi.scala @@ -202,7 +202,18 @@ final class FormUi(helpers: Helpers, ui: RelayUi, tourUi: RelayTourUi): form("onlyRound"), raw("Filter games by round number"), help = frag( - "Optional, only keep games from the source that match a round number." + "Optional, only keep games from the source that match a round number.", + br, + "It uses the PGN ", + strong("Round"), + " tag. These would match round 3:", + pre( + """[Round "3"] +[Round "3.1"]""" + ), + "Games without a ", + strong("Round"), + " tag are removed." ).some, half = true )(form3.input(_, typ = "number")), From 0445b434a460e30264a27f384c310f2efffa798a Mon Sep 17 00:00:00 2001 From: Thibault Duplessis Date: Wed, 19 Jun 2024 20:56:36 +0200 Subject: [PATCH 149/168] broadcast form wording --- modules/coreI18n/src/main/key.scala | 2 +- modules/relay/src/main/ui/FormUi.scala | 6 +++--- translation/source/broadcast.xml | 2 +- 3 files changed, 5 insertions(+), 5 deletions(-) diff --git a/modules/coreI18n/src/main/key.scala b/modules/coreI18n/src/main/key.scala index 08b853fee5c82..00da5602b6fc9 100644 --- a/modules/coreI18n/src/main/key.scala +++ b/modules/coreI18n/src/main/key.scala @@ -1665,7 +1665,7 @@ object I18nKey: val `tournamentDescription`: I18nKey = "broadcast:tournamentDescription" val `fullDescription`: I18nKey = "broadcast:fullDescription" val `fullDescriptionHelp`: I18nKey = "broadcast:fullDescriptionHelp" - val `sourceUrl`: I18nKey = "broadcast:sourceUrl" + val `sourceSingleUrl`: I18nKey = "broadcast:sourceSingleUrl" val `sourceUrlHelp`: I18nKey = "broadcast:sourceUrlHelp" val `sourceGameIds`: I18nKey = "broadcast:sourceGameIds" val `startDate`: I18nKey = "broadcast:startDate" diff --git a/modules/relay/src/main/ui/FormUi.scala b/modules/relay/src/main/ui/FormUi.scala index 5d448a55f6a7b..1db723404d330 100644 --- a/modules/relay/src/main/ui/FormUi.scala +++ b/modules/relay/src/main/ui/FormUi.scala @@ -160,7 +160,7 @@ final class FormUi(helpers: Helpers, ui: RelayUi, tourUi: RelayTourUi): )(form3.select(_, RelayRoundForm.sourceTypes)), form3.group( form("syncUrl"), - trb.sourceUrl(), + trb.sourceSingleUrl(), help = trb.sourceUrlHelp().some )(form3.input(_))(cls := "relay-form__sync relay-form__sync-url"), form3.split(cls := "relay-form__sync relay-form__sync-lcc none")( @@ -211,9 +211,9 @@ final class FormUi(helpers: Helpers, ui: RelayUi, tourUi: RelayTourUi): """[Round "3"] [Round "3.1"]""" ), - "Games without a ", + "If you set a round number, then games without a ", strong("Round"), - " tag are removed." + " tag are dropped." ).some, half = true )(form3.input(_, typ = "number")), diff --git a/translation/source/broadcast.xml b/translation/source/broadcast.xml index d7ddd12a58b7c..daa6188910282 100644 --- a/translation/source/broadcast.xml +++ b/translation/source/broadcast.xml @@ -23,7 +23,7 @@ Short tournament description Full tournament description Optional long description of the tournament. %1$s is available. Length must be less than %2$s characters. - Source URL, or game IDs + PGN Source URL URL that Lichess will check to get PGN updates. It must be publicly accessible from the Internet. Up to 64 Lichess game IDs, separated by spaces. Start date in your own timezone From b549bc25a76b042771a97ef4fdba5b9159e5c8b0 Mon Sep 17 00:00:00 2001 From: Thibault Duplessis Date: Wed, 19 Jun 2024 21:21:58 +0200 Subject: [PATCH 150/168] broadcast lcc warning --- modules/relay/src/main/package.scala | 3 ++ modules/relay/src/main/ui/FormUi.scala | 42 +++++++++++++++++--------- ui/bits/css/relay/_form.scss | 10 ++++++ ui/common/css/component/_flash.scss | 11 +++++-- 4 files changed, 49 insertions(+), 17 deletions(-) diff --git a/modules/relay/src/main/package.scala b/modules/relay/src/main/package.scala index 1f6b3065e50d2..51d0f38ad876f 100644 --- a/modules/relay/src/main/package.scala +++ b/modules/relay/src/main/package.scala @@ -4,6 +4,9 @@ export lila.core.lilaism.Lilaism.{ *, given } export lila.common.extensions.* export lila.core.id.{ RelayRoundId, RelayTourId } +val broadcasterUrl = + "https://github.com/lichess-org/broadcaster#user-content-lichess-broadcaster" + private val logger = lila.log("relay") private type RelayGames = Vector[RelayGame] diff --git a/modules/relay/src/main/ui/FormUi.scala b/modules/relay/src/main/ui/FormUi.scala index 1db723404d330..ce89e092a9d4f 100644 --- a/modules/relay/src/main/ui/FormUi.scala +++ b/modules/relay/src/main/ui/FormUi.scala @@ -163,21 +163,33 @@ final class FormUi(helpers: Helpers, ui: RelayUi, tourUi: RelayTourUi): trb.sourceSingleUrl(), help = trb.sourceUrlHelp().some )(form3.input(_))(cls := "relay-form__sync relay-form__sync-url"), - form3.split(cls := "relay-form__sync relay-form__sync-lcc none")( - form3.group( - form("syncLcc.id"), - "Tournament ID", - help = frag( - "From the LCC page URL. The ID looks like this: ", - pre("f1943ec6-4992-45d9-969d-a0aff688b404") - ).some, - half = true - )(form3.input(_)), - form3.group( - form("syncLcc.round"), - trb.roundNumber(), - half = true - )(form3.input(_, typ = "number")) + div(cls := "relay-form__sync relay-form__sync-lcc none")( + (!Granter.opt(_.Relay)).option( + flashMessage("box")( + p(strong("Please use the ", a(href := broadcasterUrl)("Lichess Broadcaster App"))), + p( + "LiveChessCloud support is deprecated and will be removed soon.", + br, + "If you need help, please contact us at broadcast@lichess.org." + ) + ) + ), + form3.split( + form3.group( + form("syncLcc.id"), + "Tournament ID", + help = frag( + "From the LCC page URL. The ID looks like this: ", + pre("f1943ec6-4992-45d9-969d-a0aff688b404") + ).some, + half = true + )(form3.input(_)), + form3.group( + form("syncLcc.round"), + trb.roundNumber(), + half = true + )(form3.input(_, typ = "number")) + ) ), form3.group( form("syncUrls"), diff --git a/ui/bits/css/relay/_form.scss b/ui/bits/css/relay/_form.scss index 48e0c22d62b45..c3ef02fe7f376 100644 --- a/ui/bits/css/relay/_form.scss +++ b/ui/bits/css/relay/_form.scss @@ -35,6 +35,16 @@ font-family: monospace; } +.flash-box { + border: 5px solid $m-brag_bg--mix-70; + + &::before { + color: $c-brag; + content: $licon-InfoCircle; + font-size: 5em; + } +} + .relay-image { max-width: 100%; height: auto; diff --git a/ui/common/css/component/_flash.scss b/ui/common/css/component/_flash.scss index 2187ef0783da8..6896606ac7bdd 100644 --- a/ui/common/css/component/_flash.scss +++ b/ui/common/css/component/_flash.scss @@ -3,13 +3,12 @@ margin: 1em 0 2em 0; padding: 1em 2em; background: $c-good; - color: $c-over; &::before { @extend %data-icon; content: $licon-Checkmark; - @include margin-inline-end(1em); + @include margin-inline-end(2rem); font-size: 1.5em; } @@ -42,4 +41,12 @@ @extend %box-neat; background: $c-bg-zebra; } + + &-box { + @extend %box-neat; + background: $c-bg-zebra; + a { + color: $c-primary; + } + } } From 20538be05d8413fc7c336f6f25fe53d31d68a8ea Mon Sep 17 00:00:00 2001 From: Thibault Duplessis Date: Wed, 19 Jun 2024 21:28:08 +0200 Subject: [PATCH 151/168] fix ui/build by reverting to env.jsDir which is probably wrong reverts this change https://github.com/lichess-org/lila/commit/59083047e9dbd3a4ca39306fdea93287117d677c#diff-b3fbb3c2873779e8f6322c18417dd873d4bf40493285ad3fbd1e514b6b82b322R97 which seems unrelated to its commit and is causing ui/build to fail --- ui/.build/src/manifest.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ui/.build/src/manifest.ts b/ui/.build/src/manifest.ts index 25b1b9c954a51..074fa5dcd289d 100644 --- a/ui/.build/src/manifest.ts +++ b/ui/.build/src/manifest.ts @@ -94,7 +94,7 @@ async function write() { await Promise.all([ fs.promises.writeFile(path.join(env.jsDir, `manifest.${hash}.js`), clientManifest), fs.promises.writeFile( - path.join(env.jsonDir, `manifest.${env.prod ? 'prod' : 'dev'}.json`), + path.join(env.jsDir, `manifest.${env.prod ? 'prod' : 'dev'}.json`), JSON.stringify(serverManifest, null, env.prod ? undefined : 2), ), ]); From 31480cb7b1b2565d3d6b409f028f8c8ca63b2fd0 Mon Sep 17 00:00:00 2001 From: Thibault Duplessis Date: Wed, 19 Jun 2024 22:13:33 +0200 Subject: [PATCH 152/168] tweak icon size --- ui/bits/css/relay/_form.scss | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ui/bits/css/relay/_form.scss b/ui/bits/css/relay/_form.scss index c3ef02fe7f376..ea2fb0d1e2b7f 100644 --- a/ui/bits/css/relay/_form.scss +++ b/ui/bits/css/relay/_form.scss @@ -41,7 +41,7 @@ &::before { color: $c-brag; content: $licon-InfoCircle; - font-size: 5em; + font-size: 4em; } } From 21854f937a7d120d6dc8333dc213bf15f5034aea Mon Sep 17 00:00:00 2001 From: Thibault Duplessis Date: Wed, 19 Jun 2024 22:13:44 +0200 Subject: [PATCH 153/168] dimmer c-font-dim --- ui/common/css/theme/_default.scss | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ui/common/css/theme/_default.scss b/ui/common/css/theme/_default.scss index 237e629dc7303..1de52f1820327 100644 --- a/ui/common/css/theme/_default.scss +++ b/ui/common/css/theme/_default.scss @@ -70,7 +70,7 @@ $c-clearer: #fff; --c-metal-top-hover: #{hsl($site-hue, 7%, 25%)}; --c-metal-bottom-hover: #{hsl($site-hue, 5%, 22%)}; - --c-font-dim: #{change-color($c-font, $lightness: 60%)}; + --c-font-dim: #{change-color($c-font, $lightness: 55%)}; --c-font-dimmer: #{change-color($c-font, $lightness: 42%)}; --c-font-clear: #{change-color($c-font, $lightness: 80%)}; --c-font-clearer: #{change-color($c-font, $lightness: 89%)}; From 569e0c15d170e6ad0a06f3a56a945503de8ef086 Mon Sep 17 00:00:00 2001 From: Thibault Duplessis Date: Wed, 19 Jun 2024 22:25:16 +0200 Subject: [PATCH 154/168] better broadcaster url --- modules/relay/src/main/package.scala | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/modules/relay/src/main/package.scala b/modules/relay/src/main/package.scala index 51d0f38ad876f..8c146de4836d8 100644 --- a/modules/relay/src/main/package.scala +++ b/modules/relay/src/main/package.scala @@ -4,8 +4,7 @@ export lila.core.lilaism.Lilaism.{ *, given } export lila.common.extensions.* export lila.core.id.{ RelayRoundId, RelayTourId } -val broadcasterUrl = - "https://github.com/lichess-org/broadcaster#user-content-lichess-broadcaster" +val broadcasterUrl = "https://lichess.org/page/broadcaster-app" private val logger = lila.log("relay") private type RelayGames = Vector[RelayGame] From 64dc2545d329bf5677efb7b5bb6eebba2aba72f3 Mon Sep 17 00:00:00 2001 From: Thanh Le Date: Wed, 19 Jun 2024 18:56:35 +0700 Subject: [PATCH 155/168] Bump lila-search RC10 and use it's types --- modules/forumSearch/src/main/ForumSearchApi.scala | 2 +- modules/forumSearch/src/main/package.scala | 2 +- modules/gameSearch/src/main/GameSearchApi.scala | 9 +++++---- modules/gameSearch/src/main/GameSearchForm.scala | 12 ++++++------ modules/gameSearch/src/main/package.scala | 10 ++++++++-- modules/search/src/main/LilaSearchClient.scala | 2 +- modules/search/src/main/model.scala | 7 ------- modules/studySearch/src/main/Env.scala | 2 +- modules/studySearch/src/main/StudySearchApi.scala | 7 ++++--- modules/studySearch/src/main/package.scala | 2 +- modules/teamSearch/src/main/TeamSearchApi.scala | 2 +- modules/teamSearch/src/main/package.scala | 2 +- project/Dependencies.scala | 2 +- 13 files changed, 31 insertions(+), 30 deletions(-) delete mode 100644 modules/search/src/main/model.scala diff --git a/modules/forumSearch/src/main/ForumSearchApi.scala b/modules/forumSearch/src/main/ForumSearchApi.scala index 23bad2e6ae357..576109be9b22e 100644 --- a/modules/forumSearch/src/main/ForumSearchApi.scala +++ b/modules/forumSearch/src/main/ForumSearchApi.scala @@ -10,7 +10,7 @@ final class ForumSearchApi(client: SearchClient)(using Executor) def search(query: Query.Forum, from: From, size: Size) = client - .search(query, from.value, size.value) + .search(query, from, size) .map(res => res.hitIds.map(ForumPostId.apply)) def count(query: Query.Forum) = diff --git a/modules/forumSearch/src/main/package.scala b/modules/forumSearch/src/main/package.scala index 2ad306ac32014..3604898cd0680 100644 --- a/modules/forumSearch/src/main/package.scala +++ b/modules/forumSearch/src/main/package.scala @@ -5,4 +5,4 @@ export lila.common.extensions.* private val logger = lila.log("forumSearch") -val index = lila.search.spec.Index.Forum +val index = lila.search.Index.Forum diff --git a/modules/gameSearch/src/main/GameSearchApi.scala b/modules/gameSearch/src/main/GameSearchApi.scala index f5c687a7b0ed4..6d7c8d194dc39 100644 --- a/modules/gameSearch/src/main/GameSearchApi.scala +++ b/modules/gameSearch/src/main/GameSearchApi.scala @@ -12,9 +12,10 @@ final class GameSearchApi( extends SearchReadApi[Game, Query.Game]: def search(query: Query.Game, from: From, size: Size): Fu[List[Game]] = - client.search(query, from.value, size.value).flatMap { res => - gameRepo.gamesFromSecondary(res.hitIds.map(GameId.apply)) - } + client + .search(query, from, size) + .flatMap: res => + gameRepo.gamesFromSecondary(res.hitIds.map(GameId.apply)) def count(query: Query.Game) = client.count(query).dmap(_.count) @@ -53,7 +54,7 @@ final class GameSearchApi( winnerColor = game.winner.fold(3)(_.color.fold(1, 2)), averageRating = game.averageUsersRating, ai = game.aiLevel, - date = lila.search.spec.SearchDateTime.fromInstant(game.movedAt), + date = lila.search.SearchDateTime.fromInstant(game.movedAt), duration = game.durationSeconds, // for realtime games only clockInit = game.clock.map(_.limitSeconds.value), clockInc = game.clock.map(_.incrementSeconds.value), diff --git a/modules/gameSearch/src/main/GameSearchForm.scala b/modules/gameSearch/src/main/GameSearchForm.scala index fba10520ccd4f..cd1b62aca7cc0 100644 --- a/modules/gameSearch/src/main/GameSearchForm.scala +++ b/modules/gameSearch/src/main/GameSearchForm.scala @@ -91,16 +91,16 @@ private[gameSearch] case class SearchData( source = source, rated = mode.flatMap(Mode.apply).map(_.rated), status = status, - turns = IntRange(turnsMin, turnsMax).some, - averageRating = IntRange(ratingMin, ratingMax).some, + turns = IntRange(turnsMin, turnsMax), + averageRating = IntRange(ratingMin, ratingMax), hasAi = hasAi.map(_ == 1), - aiLevel = IntRange(aiLevelMin, aiLevelMax).some, - date = DateRange(dateMin.map(transform), dateMax.map(transform)).some, - duration = IntRange(durationMin, durationMax).some, + aiLevel = IntRange(aiLevelMin, aiLevelMax), + date = DateRange(dateMin.map(transform), dateMax.map(transform)), + duration = IntRange(durationMin, durationMax), analysed = analysed.map(_ == 1), whiteUser = players.cleanWhite.map(_.value), blackUser = players.cleanBlack.map(_.value), - sorting = SpecSorting(sortOrDefault.field, sortOrDefault.order).some, + sorting = SpecSorting(sortOrDefault.field, sortOrDefault.order), clockInit = clockInit, clockInc = clockInc ) diff --git a/modules/gameSearch/src/main/package.scala b/modules/gameSearch/src/main/package.scala index 7ba8569af0bec..aa3c156c3b59d 100644 --- a/modules/gameSearch/src/main/package.scala +++ b/modules/gameSearch/src/main/package.scala @@ -1,14 +1,20 @@ package lila.gameSearch +import lila.search.spec.{ IntRange, DateRange } + export lila.core.lilaism.Lilaism.{ *, given } export lila.common.extensions.* private val logger = lila.log("gameSearch") -val index = lila.search.spec.Index.Game +val index = lila.search.Index.Game + +extension (range: IntRange) def nonEmpty: Boolean = range.a.nonEmpty || range.b.nonEmpty + +extension (range: DateRange) def nonEmpty: Boolean = range.a.nonEmpty || range.b.nonEmpty extension (query: lila.search.spec.Query.Game) - def nonEmpty = + def nonEmpty: Boolean = query.user1.nonEmpty || query.user2.nonEmpty || query.winner.nonEmpty || diff --git a/modules/search/src/main/LilaSearchClient.scala b/modules/search/src/main/LilaSearchClient.scala index af9dd4a729a44..c20a9cad0e0d6 100644 --- a/modules/search/src/main/LilaSearchClient.scala +++ b/modules/search/src/main/LilaSearchClient.scala @@ -43,7 +43,7 @@ class LilaSearchClient(client: SearchClient, writeable: Boolean)(using Executor) logger.info(s"Count error: query={$query}", e) CountOutput(0) - override def search(query: Query, from: Int, size: Int): Future[SearchOutput] = + override def search(query: Query, from: From, size: Size): Future[SearchOutput] = monitor("search", query.index): client .search(query, from, size) diff --git a/modules/search/src/main/model.scala b/modules/search/src/main/model.scala deleted file mode 100644 index ff7ac084f898f..0000000000000 --- a/modules/search/src/main/model.scala +++ /dev/null @@ -1,7 +0,0 @@ -package lila.search - -opaque type From = Int -object From extends OpaqueInt[From] - -opaque type Size = Int -object Size extends OpaqueInt[Size] diff --git a/modules/studySearch/src/main/Env.scala b/modules/studySearch/src/main/Env.scala index 5348917f1fc9f..47fbaf15c5bcb 100644 --- a/modules/studySearch/src/main/Env.scala +++ b/modules/studySearch/src/main/Env.scala @@ -8,7 +8,7 @@ import scalalib.paginator.* import lila.common.LateMultiThrottler import lila.core.study.RemoveStudy import lila.study.Study -import lila.search.{ From, Size } +import lila.search.* import lila.search.client.SearchClient import lila.search.spec.Query diff --git a/modules/studySearch/src/main/StudySearchApi.scala b/modules/studySearch/src/main/StudySearchApi.scala index c7011a8e0790b..71cb3d867d421 100644 --- a/modules/studySearch/src/main/StudySearchApi.scala +++ b/modules/studySearch/src/main/StudySearchApi.scala @@ -23,9 +23,10 @@ final class StudySearchApi( extends SearchReadApi[Study, Query.Study]: def search(query: Query.Study, from: From, size: Size) = - client.search(query, from.value, size.value).flatMap { res => - studyRepo.byOrderedIds(res.hitIds.map(StudyId(_))) - } + client + .search(query, from, size) + .flatMap: res => + studyRepo.byOrderedIds(res.hitIds.map(StudyId(_))) def count(query: Query.Study) = client.count(query).dmap(_.count) diff --git a/modules/studySearch/src/main/package.scala b/modules/studySearch/src/main/package.scala index c0409a39f590c..91418a10f7308 100644 --- a/modules/studySearch/src/main/package.scala +++ b/modules/studySearch/src/main/package.scala @@ -5,4 +5,4 @@ export lila.common.extensions.* private val logger = lila.log("studySearch") -private val index = lila.search.spec.Index.Study +private val index = lila.search.Index.Study diff --git a/modules/teamSearch/src/main/TeamSearchApi.scala b/modules/teamSearch/src/main/TeamSearchApi.scala index 29dea5cbf57ea..bd7a7c95c14c0 100644 --- a/modules/teamSearch/src/main/TeamSearchApi.scala +++ b/modules/teamSearch/src/main/TeamSearchApi.scala @@ -15,7 +15,7 @@ final class TeamSearchApi( def search(query: Query.Team, from: From, size: Size) = client - .search(query, from.value, size.value) + .search(query, from, size) .map: res => res.hitIds.map(TeamId.apply) diff --git a/modules/teamSearch/src/main/package.scala b/modules/teamSearch/src/main/package.scala index e4fb49b101791..9e3f5b1de4cfb 100644 --- a/modules/teamSearch/src/main/package.scala +++ b/modules/teamSearch/src/main/package.scala @@ -5,4 +5,4 @@ export lila.common.extensions.* private val logger = lila.log("teamSearch") -val index = lila.search.spec.Index.Team +val index = lila.search.Index.Team diff --git a/project/Dependencies.scala b/project/Dependencies.scala index 52412dd976ab2..88f7a4009c0d2 100644 --- a/project/Dependencies.scala +++ b/project/Dependencies.scala @@ -26,7 +26,7 @@ object Dependencies { val lettuce = "io.lettuce" % "lettuce-core" % "6.3.2.RELEASE" val nettyTransport = ("io.netty" % s"netty-transport-native-$notifier" % "4.1.111.Final").classifier(s"$os-$arch") - val lilaSearch = "org.lichess.search" %% "client" % "3.0.0-RC9" + val lilaSearch = "org.lichess.search" %% "client" % "3.0.0-RC10" val munit = "org.scalameta" %% "munit" % "1.0.0" % Test val uaparser = "org.uaparser" %% "uap-scala" % "0.17.0" val apacheText = "org.apache.commons" % "commons-text" % "1.12.0" From 86006cd0e7acb5cedfbb8c7bfc190b51d74d8e99 Mon Sep 17 00:00:00 2001 From: slither77 <132110444+slither77@users.noreply.github.com> Date: Thu, 20 Jun 2024 01:34:25 -0400 Subject: [PATCH 156/168] monarchy piece set (svg format) (#15557) * Create monarchy * Delete public/piece/monarchy * Create test * Delete public/piece/monarchy/test * Add monarchy pieces (svg format) hopefully this works :) * white rook --------- Co-authored-by: Thibault Duplessis --- public/piece/monarchy/bB.svg | 23 +++++++++++++++++++++++ public/piece/monarchy/bK.svg | 21 +++++++++++++++++++++ public/piece/monarchy/bN.svg | 15 +++++++++++++++ public/piece/monarchy/bP.svg | 15 +++++++++++++++ public/piece/monarchy/bQ.svg | 22 ++++++++++++++++++++++ public/piece/monarchy/bR.svg | 15 +++++++++++++++ public/piece/monarchy/wB.svg | 17 +++++++++++++++++ public/piece/monarchy/wK.svg | 17 +++++++++++++++++ public/piece/monarchy/wN.svg | 15 +++++++++++++++ public/piece/monarchy/wP.svg | 15 +++++++++++++++ public/piece/monarchy/wQ.svg | 23 +++++++++++++++++++++++ public/piece/monarchy/wR.svg | 17 +++++++++++++++++ 12 files changed, 215 insertions(+) create mode 100644 public/piece/monarchy/bB.svg create mode 100644 public/piece/monarchy/bK.svg create mode 100644 public/piece/monarchy/bN.svg create mode 100644 public/piece/monarchy/bP.svg create mode 100644 public/piece/monarchy/bQ.svg create mode 100644 public/piece/monarchy/bR.svg create mode 100644 public/piece/monarchy/wB.svg create mode 100644 public/piece/monarchy/wK.svg create mode 100644 public/piece/monarchy/wN.svg create mode 100644 public/piece/monarchy/wP.svg create mode 100644 public/piece/monarchy/wQ.svg create mode 100644 public/piece/monarchy/wR.svg diff --git a/public/piece/monarchy/bB.svg b/public/piece/monarchy/bB.svg new file mode 100644 index 0000000000000..216ea7d1d8814 --- /dev/null +++ b/public/piece/monarchy/bB.svg @@ -0,0 +1,23 @@ + + + + + + + + + + + + + + + + + + + + + + + diff --git a/public/piece/monarchy/bK.svg b/public/piece/monarchy/bK.svg new file mode 100644 index 0000000000000..fc80f2a1ac179 --- /dev/null +++ b/public/piece/monarchy/bK.svg @@ -0,0 +1,21 @@ + + + + + + + + + + + + + + + + + + + + + diff --git a/public/piece/monarchy/bN.svg b/public/piece/monarchy/bN.svg new file mode 100644 index 0000000000000..5371375f793a3 --- /dev/null +++ b/public/piece/monarchy/bN.svg @@ -0,0 +1,15 @@ + + + + + + + + + + + + + + + diff --git a/public/piece/monarchy/bP.svg b/public/piece/monarchy/bP.svg new file mode 100644 index 0000000000000..e56d92900df61 --- /dev/null +++ b/public/piece/monarchy/bP.svg @@ -0,0 +1,15 @@ + + + + + + + + + + + + + + + diff --git a/public/piece/monarchy/bQ.svg b/public/piece/monarchy/bQ.svg new file mode 100644 index 0000000000000..cde1027fb5484 --- /dev/null +++ b/public/piece/monarchy/bQ.svg @@ -0,0 +1,22 @@ + + + + + + + + + + + + + + + + + + + + + + diff --git a/public/piece/monarchy/bR.svg b/public/piece/monarchy/bR.svg new file mode 100644 index 0000000000000..c5035059267a3 --- /dev/null +++ b/public/piece/monarchy/bR.svg @@ -0,0 +1,15 @@ + + + + + + + + + + + + + + + diff --git a/public/piece/monarchy/wB.svg b/public/piece/monarchy/wB.svg new file mode 100644 index 0000000000000..fad56652550d7 --- /dev/null +++ b/public/piece/monarchy/wB.svg @@ -0,0 +1,17 @@ + + + + + + + + + + + + + + + + + diff --git a/public/piece/monarchy/wK.svg b/public/piece/monarchy/wK.svg new file mode 100644 index 0000000000000..97d87236f1dca --- /dev/null +++ b/public/piece/monarchy/wK.svg @@ -0,0 +1,17 @@ + + + + + + + + + + + + + + + + + diff --git a/public/piece/monarchy/wN.svg b/public/piece/monarchy/wN.svg new file mode 100644 index 0000000000000..b4feb360baaab --- /dev/null +++ b/public/piece/monarchy/wN.svg @@ -0,0 +1,15 @@ + + + + + + + + + + + + + + + diff --git a/public/piece/monarchy/wP.svg b/public/piece/monarchy/wP.svg new file mode 100644 index 0000000000000..5c4c7bc17d5e0 --- /dev/null +++ b/public/piece/monarchy/wP.svg @@ -0,0 +1,15 @@ + + + + + + + + + + + + + + + diff --git a/public/piece/monarchy/wQ.svg b/public/piece/monarchy/wQ.svg new file mode 100644 index 0000000000000..4245a53508184 --- /dev/null +++ b/public/piece/monarchy/wQ.svg @@ -0,0 +1,23 @@ + + + + + + + + + + + + + + + + + + + + + + + diff --git a/public/piece/monarchy/wR.svg b/public/piece/monarchy/wR.svg new file mode 100644 index 0000000000000..21aadda404368 --- /dev/null +++ b/public/piece/monarchy/wR.svg @@ -0,0 +1,17 @@ + + + + + + + + + + + + + + + + + From 9babeae0ef30f75cc51918dc53c07870f0205d67 Mon Sep 17 00:00:00 2001 From: Thibault Duplessis Date: Thu, 20 Jun 2024 07:32:31 +0200 Subject: [PATCH 157/168] fix gitignore unignore bin/gen --- .gitignore | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.gitignore b/.gitignore index d69e05f00f0ee..5c91d043ca27a 100644 --- a/.gitignore +++ b/.gitignore @@ -22,7 +22,7 @@ data/ dist/ node_modules/ local/ -gen/ +ui/common/css/theme/gen/*.scss ui/common/**/*.js ui/common/**/*.d.ts ui/chess/**/*.js From aabf7abb49620394b22892e3b5ac7b1c34083d9f Mon Sep 17 00:00:00 2001 From: Thibault Duplessis Date: Thu, 20 Jun 2024 07:32:44 +0200 Subject: [PATCH 158/168] integrate monarchy piece set --- COPYING.md | 1 + bin/gen/piece-sprite | 1 + modules/pref/src/main/PieceSet.scala | 1 + public/piece-css/monarchy.css | 12 ++++++++++++ public/piece-css/monarchy.external.css | 12 ++++++++++++ 5 files changed, 27 insertions(+) create mode 100644 public/piece-css/monarchy.css create mode 100644 public/piece-css/monarchy.external.css diff --git a/COPYING.md b/COPYING.md index 0362eaf249abe..6531d7f304a28 100644 --- a/COPYING.md +++ b/COPYING.md @@ -59,6 +59,7 @@ public/piece/disguised | danegraphics | [CC BY-NC-SA 4.0](https://creativecommon public/piece/kiwen-suwi | [neverRare](https://github.com/neverRare) | [CC BY 4.0](https://creativecommons.org/licenses/by/4.0/) public/piece/mpchess | [Maxime Chupin](https://github.com/chupinmaxime) | [GPL3v3+](https://www.gnu.org/licenses/quick-guide-gplv3.en.html) public/piece/cooke | [fejfar](https://github.com/fejfar) | [CC BY-NC-SA 4.0](https://creativecommons.org/licenses/by-nc-sa/4.0/) +public/piece/monarchy | [slither77](https://github.com/slither77) | [CC BY-NC-SA 4.0](https://creativecommons.org/licenses/by-nc-sa/4.0/) public/sounds/futuristic | [Enigmahack](https://github.com/Enigmahack) | AGPLv3+ public/sounds/nes | [Enigmahack](https://github.com/Enigmahack) | AGPLv3+ public/sounds/piano | [Enigmahack](https://github.com/Enigmahack) | AGPLv3+ diff --git a/bin/gen/piece-sprite b/bin/gen/piece-sprite index afcb9537bb27c..668c5e33e371d 100755 --- a/bin/gen/piece-sprite +++ b/bin/gen/piece-sprite @@ -44,6 +44,7 @@ themes = [ ['kiwen-suwi', 'svg'], ['mpchess','svg'], ['cooke','svg'], + ['monarchy','svg'], ] types = { 'svg' => 'svg+xml;base64,', diff --git a/modules/pref/src/main/PieceSet.scala b/modules/pref/src/main/PieceSet.scala index 55178a1e70e5f..38874ecf48c98 100644 --- a/modules/pref/src/main/PieceSet.scala +++ b/modules/pref/src/main/PieceSet.scala @@ -47,6 +47,7 @@ object PieceSet extends PieceSetObject: PieceSet("tatiana"), PieceSet("staunty"), PieceSet("cooke"), + PieceSet("monarchy"), PieceSet("governor"), PieceSet("dubrovny"), PieceSet("icpieces"), diff --git a/public/piece-css/monarchy.css b/public/piece-css/monarchy.css new file mode 100644 index 0000000000000..ccb6c12e18b60 --- /dev/null +++ b/public/piece-css/monarchy.css @@ -0,0 +1,12 @@ +.is2d .pawn.white {background-image:url('data:image/svg+xml;base64,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')} +.is2d .knight.white {background-image:url('data:image/svg+xml;base64,<?xml version="1.0" encoding="UTF-8"?>
<svg width="1280" height="1280" version="1.1" viewBox="0 0 1280 1280" xmlns="http://www.w3.org/2000/svg">
 <path transform="translate(582,120)" d="m-1.9445 11.137 3.7626 6.3588 17.166 13.984 4.0156 11.27 11 7.5 9.75 14.5 8.25 9.5 13.5 14 17.25 7.25 46 1.5 27.5 1.25 19 7.75 28 10.25 18.5 4.25 31 17.25 18.75 12.25 16 11.25 26 21.25 5.25 11 4.75 9.25 15.5 25.25 18.5 20.5 12.75 27.25 13 30 1.25 36.5 17.5 41.5 24.75 40.25-0.25 34.25-6.5 36.25 12.75 42.5 9.5 24.75v51.75l-6 25.5-6.5 32-10.5 20.5-3.5 27.25-6 17.25-14.5 14.5-10.5 20.5-15.5 19.25-6.25 9.5-8 9.5-10.75 11.25-7 12-5 14.25-2.75 22.75 10.25 10 24.5 3.5-18.75 0.25 20 2.25 20.25 7.5 11 11.75 6.75 17.75 0.25 21.25 10 42-6.5 13.75 4.75 6-46.75 1.25-48 8.25h-58.75l-48.75 1-38 2.75-228.75 4.25-72-2.5-64-2.75-54.75-5.25-40.25-18.75-27.75 9.75-1-2 31.188-44.812-13.688-25.625 4-13.5 5.4375-9.0625 3.875-9.6875 8-9.375 5.0625-3.375 10.188-4.1875 22.75-4.0625 14.534-0.2111 15.291-38.674-2.9498-26 3.5581-16.459 3.2877-20.879 16.071-20.884 2.7522-24.071 6.9948-9.4922 12.182-17.541 12.265-12.232 13.055-14.232 50.924-57.464 14.248-12.508 11.005-11.005 9.5303-13.21 8.7296-9.6967 15.359-19.381 8.7071-13.492 5.8232-24.419-2.1543-18.574-8.8388-17.109-34.652 6.9393-59.785 22.783-21 10-14 10-9 9-9 11-15 15-14 8-17 4h-39l-13-3 1-4 7-22 4-18v-12l4.1265-7.0659-2.5528-4.4142-6.0329-1-19.801-2.8284-17.094-8.4628-17.182 19.667-18.21 4.9567 0.12652 8.4524-9.5476-10.227-8.9341-12.204-15.685-11.199-12.215-12.674 3.2756-10.586-0.53033-10.641 5.2097-7.0502 3.4038-16.972 14.21-17.26 14.682-32.209 9-12 9-11 14.536 1.435 10.559-12.012 14.6-13.966 25.192-19.955 27.045-16.282 29.823-21.945 29.076-21.071-13.638 7.8596 22.496-17.016 10.884-10.348 9.7071-12.172 17.546-28.844 6.6412-23.636 7.8943-19.38 0.76776-13.581-3.2981-12.834-1.591-13.061 5.2981-12.464-1.955-19.005 12.47-26.414 15.409-18.399-1.7123-0.94239 17.045 14.407 17.066 9.1716c-6.9147 7.1853 9.8483 7.2553 14.639 7.4216l7.3765-18.775 15.071-10.288 1.9289-15.712 11-12z" fill="#e7e7e7"/>
 <path transform="translate(582,120)" d="m0 0 5 3 23 23 7 8 12 14 12 13 14 14 4 3 16 2 46 5 29 5 26 6 33 11 24 11 22 13 16 12 13 11 22 22 11 14 11 15 12 19 12 21 13 26 13 30 13 35 13 40 12 45 8 37 8 49 4 37 1 15v55l-3 29-6 31-7 24-11 27-12 23-12 19-10 14-10 13-8 10-9 11-12 15-8 13-3 10-1 17 14 1 19 4 10 4 11 8 7 7 8 13 6 12 6 29 6 45 2 17-1 1-59 8-48 5-55 4-63 3-29 1h-244l-74-3-61-4-51-5-54-7-14-2-1-2 7-55 6-31 4-10 7-13 7-9 10-9 10-5 13-4 18-3h10v-40l2-26 4-23 7-23 9-20 10-17 10-14 9-11 12-14 15-16 61-61 7-8 8-8 9-11 12-15 12-20 8-18 6-20 2-10v-5l-32 8-65 12-21 10-14 10-9 9-9 11-15 15-14 8-17 4h-39l-13-3 1-4 7-22 4-18v-12l-1-3-6-3-4-1h-16l-14 4-14 8-16 13-5 2-16-15-13-13-11-15-7-14-3-12v-14l3-12 8-16 12-20 16-24 9-12 9-11 11-12 17-17 14-11 16-12 35-23 30-20 19-14 15-13 8-8 10-13 9-15 8-17 10-30 1-4-1-18-1-7v-12l3-16 6-16 13-25 17-26 5 2 22 15 13 12 6 5 7-16 8-14 9-12 11-12zm1 43-6 8-9 16-7 17-4 12-9 16-9 12-8 9-13 10-16 8-16 5-3 1-8 26-6 16-10 21-12 18-8 10-11 12-11 10-17 13-17 12-29 19-30 20-16 12-13 11-9 8-7 8-10 11-12 16-10 15-13 21-9 16-2 8 1 9 6 12 9 11 6 6 5-2 14-8 18-6 5-1h25l12 3 11 6 5 4 6 9 3 10v22l-2 11 6 1 11-2 8-5 5-4 7-8 12-14 7-7 15-11 27-14 24-5 44-8 30-7 18-6 16-8 23.031-22.219v-2l3-1 7.375-7.9688 10.594-11.812 10-15 7-11 8-12 4-5 3-1 6 8 3 8v14l-7 14-8 13-9 11-9 10-25 25-8 7-7 7-2 11-4 23-6 21-8 20-8 15-12 18-11 14-10 11-7 8-10 10-7 8-63 63-7 8-11 13-14 19-12 22-7 19-4 16-3 25-1 38v15l2 1 49 5 54 4 61 2h177l55-2 55-4 40-4 18-2 1-1 2-24 3-12 8-16 14-19 2.0884-2.2322 1.9116-1.7678 11-14 12-15 13-18 12-20 10-19 9-23 6-20 5-23 3-25 1-14v-38l-3-39-5-37-6-34-9-39-8-30-9-29-10-29-12-30-12-26-11-22-15-25-12-17-13-16-15-16-22-18-19-12-17-9-23-9-23-7-28-6-35-5-53-5-12-11-8-7-16-16-9-11-12-13-6-7z" fill="#2f2f2e"/>
 <path transform="translate(340,1021)" d="m0 0h32l32 4 65 6 30 2 24 1h221l45-2 53-4 66-7h26l14 3 9 4 6 7 7 14 6 25 4 27v4l-49 6-43 4-64 4-78 3h-218l-78-3-64-4-52-5-40-5 2-19 5-26 5-16 8-13 6-5 13-4z" fill="#E7E7E7"/>
 <path transform="translate(996,599)" d="m0 0h1l6 41 3 31 1 17v38l-3 32-5 26-6 21-8 21-10 21-14 23-14 19-11 14-9 11-2 3-2 1.5026-2 2.4974-12 16-8 14-4 12-2 13-1 16-1 1-47 5-22 2h-11l1-17 5-30 6-21 9-21 10-17 11-16 14-19 14-18 13-18 16-23 11-17 12-21 14-29 10-26 16-47 14-39z" fill="#b7b7b7"/>
 <path transform="translate(340,1021)" d="m0 0h32l32 4 65 6 30 2 24 1h221l45-2 53-4 66-7h26l14 3 9 4 6 7 5 9v4l-44 3-107 6-93 4-33 1-53 1h-64l-47-1-65-3-72-5-83-7 1-7 7-10 5-4 13-4z" fill="#FCFCFC"/>
 <path transform="translate(583,163)" d="m0 0 6 5 7 8 12 14 11 12 14 14 11 9 2 4-12-3-15-8-19-14-12-9h-3l-12 36-6 12-10 13-11 10-18 12-27 14-7 3-2 3-5 17-11 27-10 20-10 16-13 16-16 16-17 13-24 16-24 15-30 20-14 11-12 11-8 7-11 12-12 14-12 16-13 18-21 31h-3l-3-10 1-9 8-16 15-24 8-12 12-16 11-13 21-21 14-11 18-13 23-15 39-26 16-12 11-9 13-12 9-10 12-17 9-16 9-20 10-31 1-4 17-5 16-8 11-8 10-9 11-15 10-18 5-15 8-18 8-13z" fill="#FCFCFC"/>
 <path transform="translate(647,481)" d="m0 0 2 1-6 7-9 14-10 16-9 11-10 11-2 3-1.9688 2.125-2.0312 1.875-17 16-9 6-12 6-18 6-30 7-65 12-23 11-14 9-11 9-7 7-9 11-9 10-9 6-6 2-10 1-3-2 2-10 1-17h1l1 6 9-9 8-7 15-14 8-7 14-12 17-13 16-8 20-4 30-5 43-9 16-4 19-9 12-8 10-9 11-11 7-8 11-10 14-9z" fill="#b7b7b7"/>
 <path transform="translate(555,697)" d="m0 0 1 3-8 21-9 19-12 19-12 16-13 15-9 10-7 8-14 15-9 10-13 15-12 15-10 15-10 19-6 18-3 15-2 23v42h-13l-10-1-2-1v-15l1-38 3-25 6-22 8-19 11-19 10-13 9-11 10-11 7-8 63-63 7-8 10-10 9-11 8-9 9-13z" fill="#FCFCFC"/>
 <path transform="translate(538,303)" d="m0 0 4 2 10 13 9 12 4 8v12l-6 10-10 6-13 5-14 3h-9l-10-5-4-5-3-8v-8l4-9 7-9 8-8 11-9z" fill="#212120"/>
 <path transform="translate(663,495)" d="m0 0 3 4 4 10 1 4v21l-5 15-9 16-11 14-13 14-11 9-15 12-22 15-1-4 4-26 3-5 11-11 8-7 26-26 11-14 10-17 5-10z" fill="#B7B7B7"/>
 <path transform="translate(293,532)" d="m0 0h7l8 5 4 8v8l-3 6-0.89515 1.0607-1.1049 0.93934-13 8-8 4-3 1h-8l-3-5-1-3v-10l5-9 7-9 7-5z" fill="#212120"/>
 <path transform="translate(499,194)" d="m0 0 4 2 19 19-2 5-7 9-9 7-15 7-7 2v-14l5-15 11-21z" fill="#E5E5E5"/>
</svg>
')} +.is2d .bishop.white {background-image:url('data:image/svg+xml;base64,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')} +.is2d .rook.white {background-image:url('data:image/svg+xml;base64,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')} +.is2d .queen.white {background-image:url('data:image/svg+xml;base64,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')} +.is2d .king.white {background-image:url('data:image/svg+xml;base64,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')} +.is2d .pawn.black {background-image:url('data:image/svg+xml;base64,PD94bWwgdmVyc2lvbj0iMS4wIiBlbmNvZGluZz0iVVRGLTgiPz4KPHN2ZyB2ZXJzaW9uPSIxLjEiIHZpZXdCb3g9IjAgMCAxMjgwIDEyODAiIHdpZHRoPSIxMjgwIiBoZWlnaHQ9IjEyODAiIHhtbG5zPSJodHRwOi8vd3d3LnczLm9yZy8yMDAwL3N2ZyI+CjxwYXRoIHRyYW5zZm9ybT0idHJhbnNsYXRlKDYzNCwyODUpIiBkPSJtMCAwIDIzIDIgMjAgNCAyMCA2IDE4IDggMTcgOSAxNyAxMiAxMyAxMSAxNiAxNiAxMyAxNyAxMSAxOCAxMCAyMSA3IDIxIDUgMjQgMSA4djI2bC00IDI0LTYgMjEtOCAxOS0xMiAyMy0xMCAxNS04IDExLTExIDEyLTcgOC05IDEwIDEgNiA3IDggNyA2IDE4IDExIDI3IDE0IDM2IDE3IDI0IDExIDI1IDEyIDE3IDkgMTIgOCAxMCA5IDUgOSAxIDEwLTMgOC02IDctMTQgNy0yMCA1LTMwIDQtMzkgMy02NyAzaC04bDQgMjQgNSAxOSA3IDE2IDggMTQgMTMgMTYgMzMgMzMgMTEgMTQgOCAxNiA1IDE0IDMgMTYgMSA5djlsMy0xIDIxLTIgMTAtMiAzMC0yaDI0bDE4IDQgMTIgNSAxMSA4IDkgOSA4IDEzIDYgMTIgNiAyOSA2IDQ1IDIgMTctMSAxLTU5IDgtNDkgNS01NSA0LTMzIDItOTAgMy01MSAxaC04NGwtODctMi01My0yLTY0LTQtNTYtNS01NS03LTIxLTMtMS01IDYtNTAgNi0zMSA0LTExIDgtMTUgNy05IDctNiA1LTUgMTMtNiAxNS00IDYtMWgyNGwzMCAyIDE3IDMgMTIgMSAxLTE2IDMtMTYgNi0xNyA3LTEzIDExLTE0IDM0LTM0IDExLTE0IDgtMTMgOC0xOCA2LTIzIDMtMTh2LTNsLTU1LTItNDgtMy0zNS00LTIwLTQtMTQtNS04LTYtNS02LTItNXYtMTBsNC05IDEwLTEwIDE0LTkgMjMtMTIgMjktMTQgMzMtMTUgMzMtMTYgMTctOSAxNS0xMCA5LTggNC03LTEtNC0xMS0xMS03LTgtMTAtMTEtMTItMTYtMTQtMjUtOC0xNy04LTI0LTUtMjUtMS0xMHYtMTZsMy0yMiA1LTIwIDgtMjIgMTItMjMgMTEtMTYgMTEtMTMgMTEtMTIgMTQtMTIgMTYtMTEgMTQtOCAxOS05IDIxLTcgMTctNCAxNC0yeiIgZmlsbD0iIzE4MTkxOSIvPgo8cGF0aCB0cmFuc2Zvcm09InRyYW5zbGF0ZSg2MjIsMzEzKSIgZD0ibTAgMGgyM2wxOCAzIDE1IDQgMTkgNyAxNyA5IDEyIDggMTEgOSAxMiAxMSA3IDggMTAgMTMgOSAxNSA5IDE5IDYgMTkgNCAxOSAxIDl2MTVsLTMgMjAtNiAyMS01IDEyLTE0IDI5LTEwIDE0LTEzIDE1LTggOC0xMCA1LTE2IDQtMjUgMy0xNyAxaC02NmwtMjgtMi0yNC00LTEzLTUtOC02LTEwLTEwLTktMTEtMTAtMTUtMTItMjQtNi0xNS01LTE2LTMtMTYtMS05di0xM2wzLTIxIDQtMTQgNy0xOSAxMS0yMSAxMC0xNCAxMS0xMyAxMS0xMSAxNy0xMyAxNy0xMCAxNy04IDE5LTZ6IiBmaWxsPSIjNEU1MzUzIi8+CjxwYXRoIHRyYW5zZm9ybT0idHJhbnNsYXRlKDM0OSwxMDIyKSIgZD0ibTAgMGgxM2w2NiA3IDUwIDQgNTEgMmgyMTZsNTEtMiAzOS0zIDYwLTYgMTgtMmgxMmwyNCA0IDEwIDQgNyA4IDYgMTEgNCAxMyA1IDI2IDIgMTV2NWwtNDggNi01NiA1LTY2IDQtNTYgMi0zOCAxaC0xNjRsLTY5LTItNjAtMy01NS00LTQ5LTUtMzAtNCAxLTE2IDYtMzEgNS0xNiA3LTExIDUtNCA5LTR6IiBmaWxsPSIjNEU1MzUzIi8+CjxwYXRoIHRyYW5zZm9ybT0idHJhbnNsYXRlKDU0Nyw3OTkpIiBkPSJtMCAwaDE3NmwzIDIyIDQgMTkgOCAyMyAxMCAxOSAxMCAxNCAxMiAxNCAzMiAzMiA5IDEzIDUgMTIgMyAxMSAyIDE3djVsLTMgMS0yNiAyLTYxIDJoLTE4NmwtNjItMi0zMi0yLTMtMSAxLTE2IDQtMTcgNC05IDYtMTAgMTEtMTIgMjgtMjggOS0xMSAxMC0xNCA5LTE3IDctMTkgNS0xOHoiIGZpbGw9IiM0RTUzNTMiLz4KPHBhdGggdHJhbnNmb3JtPSJ0cmFuc2xhdGUoNTUwLDYzOCkiIGQ9Im0wIDAgMTIgMSAzNCAzaDc4bDQ1LTQgNSAxMyA3IDEwIDEwIDEwIDE2IDExIDI1IDE0IDM1IDE3IDMzIDE1IDMzIDE2IDE1IDggMyAydjJsLTIyIDQtMjkgMy01MCAzLTUzIDJoLTIzNGwtNjktMy00MC0zLTIzLTMtMTQtM3YtMmwyNi0xNCAyOC0xMyAzOS0xOCAyOS0xNCAyMi0xMiAxNy0xMiA5LTggOS0xM3oiIGZpbGw9IiM0RTUzNTMiLz4KPHBhdGggdHJhbnNmb3JtPSJ0cmFuc2xhdGUoMzQ5LDEwMjIpIiBkPSJtMCAwaDEzbDY2IDcgNTAgNCA1MSAyaDIxNmw1MS0yIDM5LTMgNjAtNiAxOC0yaDEybDI0IDQgMTAgNCA3IDggNCA3djNsLTEzOCA4LTg2IDQtNjUgMmgtMTQ2bC01MS0yLTY1LTQtOTgtOC0xNi0yIDItNSA0LTcgNS00IDktNHoiIGZpbGw9IiM2Rjc0NzQiLz4KPHBhdGggdHJhbnNmb3JtPSJ0cmFuc2xhdGUoNjIyLDMxMykiIGQ9Im0wIDBoMTVsLTQgNC0xMiA4LTE3IDEyLTEzIDEwLTE2IDEzLTEyIDExLTE1IDE1LTEwIDEzLTEwIDE2LTkgMTktNSAxNi0zIDE1LTEgMTF2MjFsMyAyMyA2IDI0IDExIDMyIDEwIDI0IDEgMy02LTItMTAtOS0xMi0xMy0xMC0xNC0xMi0yMy04LTE4LTUtMTUtNC0yMC0xLTl2LTEzbDMtMjEgNC0xNCA3LTE5IDExLTIxIDEwLTE0IDExLTEzIDExLTExIDE3LTEzIDE3LTEwIDE3LTggMTktNnoiIGZpbGw9IiM2Rjc0NzQiLz4KPHBhdGggdHJhbnNmb3JtPSJ0cmFuc2xhdGUoNTQyLDY1NykiIGQ9Im0wIDAgMSAyLTcgMTYtNyAxMi0xMSAxMy0xMSAxMC0yMSAxNC0yNyAxNC0xNSA3IDIgMSAxMTcgNiA2MiA0IDY3IDYgNDIgNXYxaC0yMjFsLTY5LTMtNDAtMy0yMy0zLTE0LTN2LTJsMjYtMTQgMjgtMTMgMzktMTggMjktMTQgMjItMTIgMTctMTIgOS04eiIgZmlsbD0iIzZGNzQ3NCIvPgo8cGF0aCB0cmFuc2Zvcm09InRyYW5zbGF0ZSg1NDcsNzk5KSIgZD0ibTAgMGgyN2wtMyAyNC01IDI2LTcgMjQtOCAxOS05IDE1LTEwIDEzLTkgMTAtMjIgMjItOCA3LTkgMTEtNSAxMS0zIDEzLTEgN2gtMjRsLTMtMSAxLTE2IDQtMTcgNC05IDYtMTAgMTEtMTIgMjgtMjggOS0xMSAxMC0xNCA5LTE3IDctMTkgNS0xOHoiIGZpbGw9IiM2Rjc0NzQiLz4KPHBhdGggdHJhbnNmb3JtPSJ0cmFuc2xhdGUoNzMzLDY2NCkiIGQ9Im0wIDAgNyA2IDE1IDExIDI3IDE1IDM1IDE3IDMzIDE1IDMzIDE2IDE1IDggMyAydjJsLTIyIDQtMjkgMy01MCAzLTI2IDFoLTIzdi0xbDQ4LTcgMjQtNSAxMS0zaDNsLTMtMy0yMi0xNC0xNy0xMi0xNi0xMi0xMS05LTEyLTExLTE0LTE0LTctOHoiIGZpbGw9IiM0MTQ0NDQiLz4KPHBhdGggdHJhbnNmb3JtPSJ0cmFuc2xhdGUoNzM5LDg2NykiIGQ9Im0wIDAgMyA0IDggMTQgMTIgMTYgMTIgMTMgMjggMjggOSAxMyA1IDEyIDMgMTEgMiAxN3Y1bC0zIDEtMTIgMWgtMTNsLTMtMjMtNS0xNS05LTEyLTEyLTE0LTgtMTMtNi0xMy02LTE5LTUtMjJ6IiBmaWxsPSIjNDE0NDQ0Ii8+CjxwYXRoIHRyYW5zZm9ybT0idHJhbnNsYXRlKDc0NywzNjMpIiBkPSJtMCAwIDUgNSA5IDEwIDEwIDE1IDExIDIxIDggMjQgNCAxOSAxIDl2MTVsLTMgMjAtNiAyMS01IDEyLTE0IDI5LTggMTEtMS0yIDExLTQwIDUtMjMgMi0xNXYtMzRsLTQtMjQtOC0yNy0xMC0yNy03LTE3eiIgZmlsbD0iIzQxNDQ0NCIvPgo8L3N2Zz4K')} +.is2d .knight.black {background-image:url('data:image/svg+xml;base64,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')} +.is2d .bishop.black {background-image:url('data:image/svg+xml;base64,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')} +.is2d .rook.black {background-image:url('data:image/svg+xml;base64,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')} +.is2d .queen.black {background-image:url('data:image/svg+xml;base64,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')} +.is2d .king.black {background-image:url('data:image/svg+xml;base64,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')} diff --git a/public/piece-css/monarchy.external.css b/public/piece-css/monarchy.external.css new file mode 100644 index 0000000000000..4f8779b0e84fe --- /dev/null +++ b/public/piece-css/monarchy.external.css @@ -0,0 +1,12 @@ +.is2d .pawn.white {background-image:url('/assets/piece/monarchy/wP.svg')} +.is2d .knight.white {background-image:url('/assets/piece/monarchy/wN.svg')} +.is2d .bishop.white {background-image:url('/assets/piece/monarchy/wB.svg')} +.is2d .rook.white {background-image:url('/assets/piece/monarchy/wR.svg')} +.is2d .queen.white {background-image:url('/assets/piece/monarchy/wQ.svg')} +.is2d .king.white {background-image:url('/assets/piece/monarchy/wK.svg')} +.is2d .pawn.black {background-image:url('/assets/piece/monarchy/bP.svg')} +.is2d .knight.black {background-image:url('/assets/piece/monarchy/bN.svg')} +.is2d .bishop.black {background-image:url('/assets/piece/monarchy/bB.svg')} +.is2d .rook.black {background-image:url('/assets/piece/monarchy/bR.svg')} +.is2d .queen.black {background-image:url('/assets/piece/monarchy/bQ.svg')} +.is2d .king.black {background-image:url('/assets/piece/monarchy/bK.svg')} From 758f9697918d501c110e6294f76149e06c66f324 Mon Sep 17 00:00:00 2001 From: Thibault Duplessis Date: Thu, 20 Jun 2024 08:16:43 +0200 Subject: [PATCH 159/168] fix broadcaster url --- modules/relay/src/main/ui/FormUi.scala | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/modules/relay/src/main/ui/FormUi.scala b/modules/relay/src/main/ui/FormUi.scala index ce89e092a9d4f..f423b2fd6be4a 100644 --- a/modules/relay/src/main/ui/FormUi.scala +++ b/modules/relay/src/main/ui/FormUi.scala @@ -205,7 +205,7 @@ final class FormUi(helpers: Helpers, ui: RelayUi, tourUi: RelayTourUi): div(cls := "form-group relay-form__sync relay-form__sync-push none")( p( "Send your local games to Lichess using ", - a(href := "https://github.com/lichess-org/broadcaster")("the Lichess Broadcaster App"), + a(href := "https://github.com/lichess-org/broadcaster")(lila.relay.broadcasterUrl), "." ) ), From d342021d6edc9ce852d3b0633c93be2ebda5c216 Mon Sep 17 00:00:00 2001 From: Thibault Duplessis Date: Thu, 20 Jun 2024 09:55:12 +0200 Subject: [PATCH 160/168] combine lcc sources --- modules/relay/src/main/BSONHandlers.scala | 16 +++++++++++--- modules/relay/src/main/JsonView.scala | 5 ++--- modules/relay/src/main/RelayDelay.scala | 2 +- modules/relay/src/main/RelayFormat.scala | 2 +- modules/relay/src/main/RelayRound.scala | 24 ++++++++++++++------- modules/relay/src/main/RelayRoundForm.scala | 13 +++++++---- 6 files changed, 42 insertions(+), 20 deletions(-) diff --git a/modules/relay/src/main/BSONHandlers.scala b/modules/relay/src/main/BSONHandlers.scala index 03b4f2377624c..4c6da447cce59 100644 --- a/modules/relay/src/main/BSONHandlers.scala +++ b/modules/relay/src/main/BSONHandlers.scala @@ -10,9 +10,19 @@ object BSONHandlers: given BSONHandler[RelayTeamsTextarea] = stringAnyValHandler(_.text, RelayTeamsTextarea(_)) import RelayRound.Sync - import Sync.{ Upstream, UpstreamIds, UpstreamUrl, UpstreamLcc, UpstreamUrls } - given upstreamUrlHandler: BSONDocumentHandler[UpstreamUrl] = Macros.handler - given upstreamLccHandler: BSONDocumentHandler[UpstreamLcc] = Macros.handler + import Sync.{ Upstream, UpstreamIds, UpstreamUrl, UpstreamLcc, UpstreamUrls, FetchableUpstream } + given upstreamUrlHandler: BSONDocumentHandler[UpstreamUrl] = Macros.handler + given upstreamLccHandler: BSONDocumentHandler[UpstreamLcc] = Macros.handler + given BSONHandler[FetchableUpstream] = tryHandler( + { + case d: BSONDocument if d.contains("url") => upstreamUrlHandler.readTry(d) + case d: BSONDocument if d.contains("lcc") => upstreamLccHandler.readTry(d) + }, + { + case url: UpstreamUrl => upstreamUrlHandler.writeTry(url).get + case lcc: UpstreamLcc => upstreamLccHandler.writeTry(lcc).get + } + ) given upstreamUrlsHandler: BSONDocumentHandler[UpstreamUrls] = Macros.handler given upstreamIdsHandler: BSONDocumentHandler[UpstreamIds] = Macros.handler diff --git a/modules/relay/src/main/JsonView.scala b/modules/relay/src/main/JsonView.scala index 8625ba6c272c4..40110e054f143 100644 --- a/modules/relay/src/main/JsonView.scala +++ b/modules/relay/src/main/JsonView.scala @@ -178,9 +178,8 @@ object JsonView: "log" -> s.log.events ) .add("delay" -> s.delay) ++ - s.upstream.so { + s.upstream.so: case Sync.UpstreamUrl(url) => Json.obj("url" -> url) case Sync.UpstreamLcc(url, round) => Json.obj("url" -> url, "round" -> round) - case Sync.UpstreamUrls(urls) => Json.obj("urls" -> urls.map(_.url)) + case Sync.UpstreamUrls(urls) => Json.obj("urls" -> urls.map(_.formUrl)) case Sync.UpstreamIds(ids) => Json.obj("ids" -> ids) - } diff --git a/modules/relay/src/main/RelayDelay.scala b/modules/relay/src/main/RelayDelay.scala index 81add186ced9d..2666e314861bb 100644 --- a/modules/relay/src/main/RelayDelay.scala +++ b/modules/relay/src/main/RelayDelay.scala @@ -51,7 +51,7 @@ final private class RelayDelay(colls: RelayColls)(using Executor): private object store: - private def idOf(upstream: FetchableUpstream, at: Instant) = s"${upstream.url} ${at.toSeconds}" + private def idOf(upstream: FetchableUpstream, at: Instant) = s"${upstream.formUrl} ${at.toSeconds}" private val longPast = java.time.Instant.ofEpochMilli(0) def putIfNew(upstream: FetchableUpstream, games: RelayGames): Funit = diff --git a/modules/relay/src/main/RelayFormat.scala b/modules/relay/src/main/RelayFormat.scala index 6938a708c357e..0270c7a0d8436 100644 --- a/modules/relay/src/main/RelayFormat.scala +++ b/modules/relay/src/main/RelayFormat.scala @@ -47,7 +47,7 @@ final private class RelayFormatApi( private def guessFormat(upstream: FetchableUpstream)(using CanProxy): Fu[RelayFormat] = { - def parsedUrl = URL.parse(upstream.url) + def parsedUrl = URL.parse(upstream.fetchUrl) def guessLcc: Fu[Option[RelayFormat]] = upstream.isLcc.so(guessManyFiles(parsedUrl)) diff --git a/modules/relay/src/main/RelayRound.scala b/modules/relay/src/main/RelayRound.scala index 3b70161ee0674..6308fe4d0f26c 100644 --- a/modules/relay/src/main/RelayRound.scala +++ b/modules/relay/src/main/RelayRound.scala @@ -117,19 +117,27 @@ object RelayRound: sealed trait Upstream: def isLcc = false sealed trait FetchableUpstream extends Upstream: - def url: String + def fetchUrl: String + def formUrl: String case class UpstreamUrl(url: String) extends FetchableUpstream: - def findLccId: Option[String] = url match - case LccRegex(id) => id.some - case _ => none + def fetchUrl = url + def formUrl = url + case class UpstreamUrls(urls: List[FetchableUpstream]) extends Upstream + case class UpstreamIds(ids: List[GameId]) extends Upstream case class UpstreamLcc(lcc: String, round: Int) extends FetchableUpstream: override def isLcc = true def id = lcc - def url = s"http://1.pool.livechesscloud.com/get/$id/round-$round/index.json" + def fetchUrl = s"http://1.pool.livechesscloud.com/get/$id/round-$round/index.json" def viewUrl = s"https://view.livechesscloud.com/#$id" - case class UpstreamUrls(urls: List[UpstreamUrl]) extends Upstream - case class UpstreamIds(ids: List[GameId]) extends Upstream - private val LccRegex = """.*view\.livechesscloud\.com/?#?([0-9a-f\-]+)""".r + def formUrl = s"$viewUrl $round" + object UpstreamLcc: + private val idRegex = """.*view\.livechesscloud\.com/?#?([0-9a-f\-]+)""".r + def findId(url: UpstreamUrl): Option[String] = url.url match + case idRegex(id) => id.some + case _ => none + def find(url: String): Option[UpstreamLcc] = url.split(' ').map(_.trim).filter(_.nonEmpty) match + case Array(idRegex(id), round) => round.toIntOption.map(UpstreamLcc(id, _)) + case _ => none trait AndTour: val tour: RelayTour diff --git a/modules/relay/src/main/RelayRoundForm.scala b/modules/relay/src/main/RelayRoundForm.scala index 3140e3f317b41..ec0a821b282e2 100644 --- a/modules/relay/src/main/RelayRoundForm.scala +++ b/modules/relay/src/main/RelayRoundForm.scala @@ -19,15 +19,15 @@ final class RelayRoundForm(using mode: Mode): import RelayRoundForm.* import lila.common.Form.ISOInstantOrTimestamp - private given Formatter[Sync.UpstreamUrl] = formatter.stringTryFormatter(validateUpstreamUrl, _.url) + private given Formatter[Sync.UpstreamUrl] = formatter.stringTryFormatter(validateUpstreamUrl, _.fetchUrl) private given Formatter[Sync.UpstreamUrls] = formatter.stringTryFormatter( _.linesIterator.toList .map(_.trim) .filter(_.nonEmpty) - .traverse(validateUpstreamUrl) + .traverse(validateUpstreamUrlOrLcc) .map(_.distinct) .map(Sync.UpstreamUrls.apply), - _.urls.map(_.url).mkString("\n") + _.urls.map(_.formUrl).mkString("\n") ) private given Formatter[Sync.UpstreamIds] = formatter.stringTryFormatter( _.split(' ').toList @@ -147,6 +147,11 @@ object RelayRoundForm: if !subdomain(host, "chess.com") || url.toString.startsWith("https://api.chess.com/pub") yield url.toString.stripSuffix("/") + private def validateUpstreamUrlOrLcc(s: String)(using Mode): Either[String, Sync.FetchableUpstream] = + Sync.UpstreamLcc.find(s) match + case Some(lcc) => Right(lcc) + case None => validateUpstreamUrl(s) + private def validateUpstreamUrl(s: String)(using Mode): Either[String, Sync.UpstreamUrl] = for url <- cleanUrl(s).toRight("Invalid source URL") url <- if !validSourcePort(url) then Left("The source URL cannot specify a port") else Right(url) @@ -209,7 +214,7 @@ object RelayRoundForm: .map: case url: Sync.UpstreamUrl => val foundLcc = for - lccId <- url.findLccId + lccId <- Sync.UpstreamLcc.findId(url) round <- roundNumberIn(name.value) yield Sync.UpstreamLcc(lccId, round) foundLcc | url From e0dda580d93c6affa10cd07f99f0455ff386a22d Mon Sep 17 00:00:00 2001 From: Thibault Duplessis Date: Thu, 20 Jun 2024 10:21:06 +0200 Subject: [PATCH 161/168] apply board brightness to custom svgs - closes #15563 --- ui/common/css/theme/board/_chessground.scss | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/ui/common/css/theme/board/_chessground.scss b/ui/common/css/theme/board/_chessground.scss index 2691386ed9872..7f0b444e5b4dd 100644 --- a/ui/common/css/theme/board/_chessground.scss +++ b/ui/common/css/theme/board/_chessground.scss @@ -199,7 +199,8 @@ cg-auto-pieces { html:not(.transp) body:not(.simple-board) { &.coords-in coord, cg-board piece, - cg-board square { + cg-board square, + .cg-custom-svgs { filter: brightness(calc(0.3 + 0.0059 * min(120, var(---board-brightness)))); //hue-rotate(calc(var(---board-hue) * 3.6deg)); } From 2ffadc93d9c8013ea3ed9c633e66eeebf0f69ee2 Mon Sep 17 00:00:00 2001 From: Thibault Duplessis Date: Thu, 20 Jun 2024 10:21:33 +0200 Subject: [PATCH 162/168] New Crowdin updates (#15548) * New translations: site.xml (Chinese Simplified) * New translations: site.xml (Tagalog) * New translations: coordinates.xml (Luxembourgish) * New translations: site.xml (Luxembourgish) * New translations: study.xml (Luxembourgish) * New translations: site.xml (Hebrew) * New translations: site.xml (Arabic) * New translations: faq.xml (Arabic) * New translations: swiss.xml (Arabic) * New translations: appeal.xml (Arabic) * New translations: faq.xml (Arabic) * New translations: arena.xml (Arabic) * New translations: team.xml (Arabic) * New translations: coordinates.xml (Arabic) * New translations: faq.xml (Arabic) * New translations: swiss.xml (Arabic) * New translations: appeal.xml (Arabic) * New translations: ublog.xml (Arabic) * New translations: swiss.xml (Arabic) * New translations: site.xml (Arabic) * New translations: site.xml (Arabic) * New translations: faq.xml (Arabic) * New translations: swiss.xml (Arabic) * New translations: broadcast.xml (Korean) * New translations: broadcast.xml (Arabic) * New translations: broadcast.xml (Romanian) * New translations: broadcast.xml (French) * New translations: broadcast.xml (Spanish) * New translations: broadcast.xml (Afrikaans) * New translations: broadcast.xml (Belarusian) * New translations: broadcast.xml (Bulgarian) * New translations: broadcast.xml (Catalan) * New translations: broadcast.xml (Czech) * New translations: broadcast.xml (Danish) * New translations: broadcast.xml (German) * New translations: broadcast.xml (Greek) * New translations: broadcast.xml (Basque) * New translations: broadcast.xml (Finnish) * New translations: broadcast.xml (Irish) * New translations: broadcast.xml (Gujarati) * New translations: broadcast.xml (Hebrew) * New translations: broadcast.xml (Hungarian) * New translations: broadcast.xml (Italian) * New translations: broadcast.xml (Japanese) * New translations: broadcast.xml (Lithuanian) * New translations: broadcast.xml (Dutch) * New translations: broadcast.xml (Polish) * New translations: broadcast.xml (Portuguese) * New translations: broadcast.xml (Russian) * New translations: broadcast.xml (Slovak) * New translations: broadcast.xml (Slovenian) * New translations: broadcast.xml (Albanian) * New translations: broadcast.xml (Swedish) * New translations: broadcast.xml (Turkish) * New translations: broadcast.xml (Ukrainian) * New translations: broadcast.xml (Chinese Simplified) * New translations: broadcast.xml (Chinese Traditional) * New translations: broadcast.xml (Vietnamese) * New translations: broadcast.xml (Galician) * New translations: broadcast.xml (Portuguese, Brazilian) * New translations: broadcast.xml (Indonesian) * New translations: broadcast.xml (Persian) * New translations: broadcast.xml (Marathi) * New translations: broadcast.xml (Croatian) * New translations: broadcast.xml (Norwegian Nynorsk) * New translations: broadcast.xml (Kazakh) * New translations: broadcast.xml (Estonian) * New translations: broadcast.xml (Latvian) * New translations: broadcast.xml (Azerbaijani) * New translations: broadcast.xml (Hindi) * New translations: broadcast.xml (English, United States) * New translations: broadcast.xml (Faroese) * New translations: broadcast.xml (Esperanto) * New translations: broadcast.xml (Luxembourgish) * New translations: broadcast.xml (Tatar) * New translations: broadcast.xml (Breton) * New translations: broadcast.xml (Rusyn) * New translations: broadcast.xml (Bosnian) * New translations: broadcast.xml (Kannada) * New translations: broadcast.xml (Norwegian Bokmal) * New translations: broadcast.xml (Sorani (Kurdish)) * New translations: broadcast.xml (Swiss German) * New translations: broadcast.xml (German) * New translations: broadcast.xml (Hebrew) * New translations: broadcast.xml (Persian) * New translations: appeal.xml (Hindi) * New translations: broadcast.xml (Spanish) * New translations: broadcast.xml (Danish) * New translations: broadcast.xml (German) * New translations: broadcast.xml (Hebrew) * New translations: broadcast.xml (Portuguese) * New translations: broadcast.xml (Russian) * New translations: broadcast.xml (Galician) * New translations: broadcast.xml (Persian) * New translations: broadcast.xml (Danish) * New translations: broadcast.xml (German) * New translations: broadcast.xml (Hebrew) * New translations: broadcast.xml (Polish) * New translations: broadcast.xml (Norwegian Nynorsk) * New translations: broadcast.xml (Portuguese) * New translations: broadcast.xml (French) * New translations: broadcast.xml (Vietnamese) * New translations: broadcast.xml (English, United States) * New translations: site.xml (Catalan) * New translations: site.xml (Tagalog) * New translations: broadcast.xml (Finnish) --- translation/dest/appeal/ar-SA.xml | 21 ++++++++++++++++++++- translation/dest/appeal/hi-IN.xml | 1 + translation/dest/arena/ar-SA.xml | 1 + translation/dest/broadcast/af-ZA.xml | 2 -- translation/dest/broadcast/ar-SA.xml | 2 -- translation/dest/broadcast/az-AZ.xml | 2 -- translation/dest/broadcast/be-BY.xml | 2 -- translation/dest/broadcast/bg-BG.xml | 2 -- translation/dest/broadcast/br-FR.xml | 1 - translation/dest/broadcast/bs-BA.xml | 2 -- translation/dest/broadcast/ca-ES.xml | 2 -- translation/dest/broadcast/ckb-IR.xml | 2 -- translation/dest/broadcast/cs-CZ.xml | 2 -- translation/dest/broadcast/da-DK.xml | 4 ++-- translation/dest/broadcast/de-DE.xml | 4 ++-- translation/dest/broadcast/el-GR.xml | 2 -- translation/dest/broadcast/en-US.xml | 4 ++-- translation/dest/broadcast/eo-UY.xml | 2 -- translation/dest/broadcast/es-ES.xml | 4 ++-- translation/dest/broadcast/et-EE.xml | 2 -- translation/dest/broadcast/eu-ES.xml | 2 -- translation/dest/broadcast/fa-IR.xml | 3 +-- translation/dest/broadcast/fi-FI.xml | 4 ++-- translation/dest/broadcast/fo-FO.xml | 2 -- translation/dest/broadcast/fr-FR.xml | 4 ++-- translation/dest/broadcast/ga-IE.xml | 2 -- translation/dest/broadcast/gl-ES.xml | 4 ++-- translation/dest/broadcast/gsw-CH.xml | 2 -- translation/dest/broadcast/gu-IN.xml | 5 +---- translation/dest/broadcast/he-IL.xml | 4 ++-- translation/dest/broadcast/hi-IN.xml | 2 -- translation/dest/broadcast/hr-HR.xml | 2 -- translation/dest/broadcast/hu-HU.xml | 2 -- translation/dest/broadcast/id-ID.xml | 2 -- translation/dest/broadcast/it-IT.xml | 2 -- translation/dest/broadcast/ja-JP.xml | 2 -- translation/dest/broadcast/kk-KZ.xml | 2 -- translation/dest/broadcast/kn-IN.xml | 2 -- translation/dest/broadcast/ko-KR.xml | 2 -- translation/dest/broadcast/lb-LU.xml | 2 -- translation/dest/broadcast/lt-LT.xml | 2 -- translation/dest/broadcast/lv-LV.xml | 2 -- translation/dest/broadcast/mr-IN.xml | 2 -- translation/dest/broadcast/nb-NO.xml | 2 -- translation/dest/broadcast/nl-NL.xml | 2 -- translation/dest/broadcast/nn-NO.xml | 4 ++-- translation/dest/broadcast/pl-PL.xml | 4 ++-- translation/dest/broadcast/pt-BR.xml | 2 -- translation/dest/broadcast/pt-PT.xml | 4 ++-- translation/dest/broadcast/ro-RO.xml | 2 -- translation/dest/broadcast/ru-RU.xml | 3 +-- translation/dest/broadcast/ry-UA.xml | 2 -- translation/dest/broadcast/sk-SK.xml | 2 -- translation/dest/broadcast/sl-SI.xml | 2 -- translation/dest/broadcast/sq-AL.xml | 2 -- translation/dest/broadcast/sv-SE.xml | 2 -- translation/dest/broadcast/tr-TR.xml | 2 -- translation/dest/broadcast/tt-RU.xml | 2 -- translation/dest/broadcast/uk-UA.xml | 2 -- translation/dest/broadcast/vi-VN.xml | 4 ++-- translation/dest/broadcast/zh-CN.xml | 2 -- translation/dest/broadcast/zh-TW.xml | 2 -- translation/dest/coordinates/ar-SA.xml | 1 + translation/dest/coordinates/lb-LU.xml | 1 + translation/dest/faq/ar-SA.xml | 9 +++++++++ translation/dest/site/ar-SA.xml | 3 +++ translation/dest/site/ca-ES.xml | 4 ++-- translation/dest/site/he-IL.xml | 6 +++--- translation/dest/site/lb-LU.xml | 6 ++++-- translation/dest/site/tl-PH.xml | 4 ++++ translation/dest/site/zh-CN.xml | 2 ++ translation/dest/study/lb-LU.xml | 2 +- translation/dest/swiss/ar-SA.xml | 14 ++++++++++++++ translation/dest/team/ar-SA.xml | 16 ++++++++++++++++ translation/dest/ublog/ar-SA.xml | 1 + 75 files changed, 110 insertions(+), 128 deletions(-) diff --git a/translation/dest/appeal/ar-SA.xml b/translation/dest/appeal/ar-SA.xml index 3ea04e700dfa8..31f0a3374cb04 100644 --- a/translation/dest/appeal/ar-SA.xml +++ b/translation/dest/appeal/ar-SA.xml @@ -1,2 +1,21 @@ - + + حسابك غير مميز أو مقيد. أنت بخير! + حسابك مشار إليه كمساعدة الخارجية في الألعاب. + نحن نعرف هذا بأنه استخدام أي مساعدة خارجية لتعزيز معرفتك و/أو مهاراتك في الحساب من أجل اكتساب أفضلية غير عادلة على خصمك. راجع صفحة %s لمزيد من التفاصيل. + حسابك محظور من الانضمام إلى الساحات. + تم حظر حسابك من البطولات ذو جوائز حقيقية. + تم تحديد حسابك للتلاعب بالتقييم. + نحن نعرف هذا بأنه التلاعب المتعمد بالتصنيف عن طريق فقدان الأدوار عن قصد أو اللعب ضد حساب آخر يفقد الأدوار عمدا. + تم كتم صوت حسابك. + اقرأ %s الخاص بنا. الفشل في اتباع القواعد الإرشادية للتواصل يمكن أن يؤدي إلى كتم الحسابات. + تم استبعاد حسابك من لوحات المتصدرين. + نحن نعرّف هذا على أنه استخدام أي طريقة غير عادلة للدخول إلى لوحة المتصدرين. + تم إغلاق حسابك من قبل المشرفين. + تم إخفاء مدوناتك من قبل المشرفين. + تأكد من قراءة %s مرة أخرى. + تم إيقافك عن اللعب. + قواعد التواصل + قواعد المدونة + اللعب العادل + diff --git a/translation/dest/appeal/hi-IN.xml b/translation/dest/appeal/hi-IN.xml index 89a4eda072b15..17509bcf792cb 100644 --- a/translation/dest/appeal/hi-IN.xml +++ b/translation/dest/appeal/hi-IN.xml @@ -1,6 +1,7 @@ आपका एकाउंट मॉडरेटर द्वारा बंद कर दिया गया था. + हमारे %s को दोबारा पढ़ना सुनिश्चित करें। संचार दिशानिर्देश फेयर प्ले diff --git a/translation/dest/arena/ar-SA.xml b/translation/dest/arena/ar-SA.xml index 63b5953c3bcfb..3d2246931b54d 100644 --- a/translation/dest/arena/ar-SA.xml +++ b/translation/dest/arena/ar-SA.xml @@ -70,6 +70,7 @@ أي فريق ستمثله في هذه المعركة؟ يجب أن تنضم إلى أحد هذه الفرق للمشاركة! تم الإنشاء + لعب مؤخرًا أفضل النتائج الإحصاءات إحصائيات البطولة diff --git a/translation/dest/broadcast/af-ZA.xml b/translation/dest/broadcast/af-ZA.xml index f98e438c79129..d0e649c0eeae4 100644 --- a/translation/dest/broadcast/af-ZA.xml +++ b/translation/dest/broadcast/af-ZA.xml @@ -14,9 +14,7 @@ Kort beskrywing van die toernooi Volle geleentheid beskrywing Opsionele lang beskrywing van die uitsending. %1$s is beskikbaar. Lengte moet minder as %2$s karakters. - Bronadress, of spel IDs URL wat Lichess sal nagaan vir PGN opdaterings. Dit moet openbaar beskikbaar wees vanaf die Internet. - Of anders, kan jy tot en met 64 Lichess spel IDs bevoeg, gespasieer deur spasie. Begin datum in jou eie tydsone Optioneel, indien jy weet wanner die geleentheid begin Gee krediet aan die bron diff --git a/translation/dest/broadcast/ar-SA.xml b/translation/dest/broadcast/ar-SA.xml index e601455155848..fa854c94789a4 100644 --- a/translation/dest/broadcast/ar-SA.xml +++ b/translation/dest/broadcast/ar-SA.xml @@ -27,9 +27,7 @@ وصف موجز للبطولة الوصف الكامل الوصف الاختياري الطويل للبث. %1$s متوفر. يجب أن لا يتجاوز طول النص %2$s حرفاً. - URL المصدر، أو ID المباراة URL الذي سيتحقق منه Lichess للحصول على تحديثات PGN. يجب أن يكون متاحًا للجميع على الإنترنت. - بدلاً من ذلك، يمكنك إدخال ما يصل إلى 64 ID لمباريات Lichess، مفصولة بمسافات. تاريخ البدء في المنطقة الزمنية الخاصة بك اختياري، إذا كنت تعرف متى يبدأ الحدث ائتمن المصدر diff --git a/translation/dest/broadcast/az-AZ.xml b/translation/dest/broadcast/az-AZ.xml index d0ee3ce6bce32..d02db396eec5b 100644 --- a/translation/dest/broadcast/az-AZ.xml +++ b/translation/dest/broadcast/az-AZ.xml @@ -13,9 +13,7 @@ Qısa turnir açıqlaması Tədbirin tam açıqlaması Tədbirin istəyə bağlı təfsilatlı açıqlaması. %1$s seçimi mövcuddur. Mətnin uzunluğu %2$s simvoldan az olmalıdır. - Mənbə URL və ya oyun ID-si Lichess, verdiyiniz URL ilə PGN-i yeniləyəcək. Bu internetdə hamı tərəfindən əldə edilə bilən olmalıdır. - Alternativ olaraq, boşluqlarla ayrılmış 64-ə qədər Lichess oyun ID-ni daxil edə bilərsiniz. Öz saat qurşağınızdakı başlama tarixi İstəyə bağlı, tədbirin başlama vaxtını bilirsinizsə Mənbəyə bax diff --git a/translation/dest/broadcast/be-BY.xml b/translation/dest/broadcast/be-BY.xml index 2e77ade23cb5f..75968908b127e 100644 --- a/translation/dest/broadcast/be-BY.xml +++ b/translation/dest/broadcast/be-BY.xml @@ -16,9 +16,7 @@ Сціслае апісанне турніру Поўнае апісанне турніру Неабавязковая дасканалае апісанне турніру. Даступны %1$s. Даўжыня павінна быць менш за %2$s сімвалаў. - Зыходная спасылка, або ідэнтыфікатары гульні Спасылка, з якой Lichess паспрабуе атрымоўваць абнаўленні PGN. Яны павінна быць даступнай для кожнай ва Інтэрнэце. - Інакш, вы можаце праз прабел ўвесці 64 сімвальныя ID гульняў на Lichess. Дата пачатаку ў вашым часавым поясе Па жаданні, калі вы ведаеце пачатак падзеі Падзякаваць крыніцы diff --git a/translation/dest/broadcast/bg-BG.xml b/translation/dest/broadcast/bg-BG.xml index 78c2bc702ea71..87a40894b8942 100644 --- a/translation/dest/broadcast/bg-BG.xml +++ b/translation/dest/broadcast/bg-BG.xml @@ -19,9 +19,7 @@ Кратко описание на турнира Пълно описание на събитието Незадължително дълго описание на излъчването. %1$s е налично. Дължината трябва да по-малка от %2$s знака. - Изходен URL, или идентификатор (ID) на партията Уебадресът, който Lichess ще проверява, за да получи осъвременявания на PGN. Той трябва да е публично достъпен от интернет. - Вместо това, може да въведете до 64 идентификатора на Lichess партии, разделени с интервал. Дата на започване във вашата часова зона По избор, ако знаете, кога започва събитието Признателност на източника diff --git a/translation/dest/broadcast/br-FR.xml b/translation/dest/broadcast/br-FR.xml index 268d7569976a2..e65733441ab66 100644 --- a/translation/dest/broadcast/br-FR.xml +++ b/translation/dest/broadcast/br-FR.xml @@ -10,7 +10,6 @@ Deskrivadur an abadenn a-bezh Deskrivadur hir ar skignañ war-eeun ma fell deoc\'h.%1$s zo dijabl. Ne vo ket hiroc\'h evit %2$s sin. An URL a ray Lichess ganti evit kaout hizivadurioù ar PGN. Ret eo dezhi bezañ digor d\'an holl war Internet. - A-hend all e c\'hallit lakaat betek 64 ID partienn Lichess, dispartiet gant spasoù. Eur kregiñ en ho kwerzhid-eur Diret eo, ma ouzit pegoulz e krogo Orin ar vammenn diff --git a/translation/dest/broadcast/bs-BA.xml b/translation/dest/broadcast/bs-BA.xml index 130447e5c09a0..7d537e804b639 100644 --- a/translation/dest/broadcast/bs-BA.xml +++ b/translation/dest/broadcast/bs-BA.xml @@ -19,9 +19,7 @@ Kratak opis turnira Potpuni opis događaja Neobavezni dugi opis događaja koji se emituje. %1$s je dostupan. Dužina mora biti manja od %2$s slova. - URL izvora ili identifikacijski broj partije Link koji će Lichess koristiti kako bi redovno ažurirao PGN. Mora biti javno dostupan na internetu. - Alternativno, možete unijeti do 64 identifikacijska broja partija na Lichessu, odvojena razmacima. Datum početka po Vašoj vremenskoj zoni Neobavezno, ukoliko znate kada počinje događaj Navedite ko je zaslužan diff --git a/translation/dest/broadcast/ca-ES.xml b/translation/dest/broadcast/ca-ES.xml index 9104c81ab6ae7..a57524541db57 100644 --- a/translation/dest/broadcast/ca-ES.xml +++ b/translation/dest/broadcast/ca-ES.xml @@ -23,9 +23,7 @@ Breu descripció del torneig Descripció total de l\'esdeveniment Opció de llarga descripció de l\'esdeveniment. %1$s és disponible. Ha de tenir menys de %2$s lletres. - Enllaç d\'origen, o identificador de la partida URL que Lichess comprovarà per a obtenir actualitzacions PGN. Ha de ser públicament accessible des d\'Internet. - Alternativament, pots introduir fins a 64 identificadors de partida, separats per espais. Data d\'inici en la teva zona horària Opcional, si saps quan comença l\'esdeveniment Cita la font diff --git a/translation/dest/broadcast/ckb-IR.xml b/translation/dest/broadcast/ckb-IR.xml index bce8b67a194fa..5fca9553a022d 100644 --- a/translation/dest/broadcast/ckb-IR.xml +++ b/translation/dest/broadcast/ckb-IR.xml @@ -21,9 +21,7 @@ باسی پاڵەوانێتیەکە بکە بە گشتی باسی پالەوانێتیەکە بکە وەسفێکی درێژی ھەڵبژاردنی پاڵەوانێتییەکە. %1$s بەردەستە. درێژی دەبێت کەمتر بێت لە کاراکتەرەکانی %2$s. - URL سەرچاوە، یا ID یارییەکە URL مافی لی چێسە بۆ بەردەست خستنی تازەکردنەوە PGN پێویستە بۆ ھەموان بەردەست بێت لەسەر ئەنتەرنێت - یان دەتوانیت تا ٦٤ ناسنامەی یاری Lichess دابنێیت، کە بە بۆشایی جیا دەکرێنەوە. بەرواری دەستپێکردن لە چوارچێوەی کاتی خۆتدا بە ھەلبژاردنی خۆتە چ کاتێک دەس پێ بکات لە سەرچاوەکە دڵنیابە diff --git a/translation/dest/broadcast/cs-CZ.xml b/translation/dest/broadcast/cs-CZ.xml index 4183cf222a4e9..5827af04c0b2e 100644 --- a/translation/dest/broadcast/cs-CZ.xml +++ b/translation/dest/broadcast/cs-CZ.xml @@ -24,9 +24,7 @@ Stručný popis turnaje Úplný popis události Volitelný dlouhý popis přenosu. %1$s je k dispozici. Délka musí být menší než %2$s znaků. - Adresa URL či ID hry URL adresa, kterou bude Lichess kontrolovat pro získání PGN aktualizací. Musí být veřejně přístupná z internetu. - Případně můžete zadat až 64 Lichess ID partií oddělených mezerou. Datum a čas zahájení ve vašem časovém pásmu Nepovinné, pokud víte, kdy událost začíná Uveďte zdroj diff --git a/translation/dest/broadcast/da-DK.xml b/translation/dest/broadcast/da-DK.xml index adbfca1eb533e..9214e24fc7640 100644 --- a/translation/dest/broadcast/da-DK.xml +++ b/translation/dest/broadcast/da-DK.xml @@ -23,9 +23,9 @@ Kort beskrivelse af turnering Fuld beskrivelse af begivenheden Valgfri lang beskrivelse af transmissionen. %1$s er tilgængelig. Længde skal være mindre end %2$s tegn. - Kilde URL, eller spil-ID\'er + URL for PGN-kilde URL som Lichess vil trække på for at få PGN updates. Den skal være offentlig tilgængelig fra internettet. - Alternativt kan du indtaste op til 64 Lichess spil-ID\'er, adskilt af mellemrum. + Op til 64 Lichess parti-ID\'er, adskilt af mellemrum. Startdato i din egen tidszone Valgfri, hvis du ved, hvornår begivenheden starter Krediter kilden diff --git a/translation/dest/broadcast/de-DE.xml b/translation/dest/broadcast/de-DE.xml index 9c4fca5d170de..54fcd97d89d31 100644 --- a/translation/dest/broadcast/de-DE.xml +++ b/translation/dest/broadcast/de-DE.xml @@ -23,9 +23,9 @@ Kurze Turnierbeschreibung Vollständige Ereignisbeschreibung Optionale, ausführliche Beschreibung der Übertragung. %1$s ist verfügbar. Die Beschreibung muss kürzer als %2$s Zeichen sein. - Quell-URL oder Partie-IDs + PGN Quell-URL URL die Lichess abfragt um PGN Aktualisierungen zu erhalten. Sie muss öffentlich aus dem Internet zugänglich sein. - Alternativ kannst du bis zu 64 durch Leerzeichen getrennte Lichess-Partie-IDs eingeben. + Bis zu 64 Lichess Partie-IDs, getrennt durch Leerzeichen. Startdatum in deiner eigenen Zeitzone Optional, falls du weißt wann das Ereignis beginnt Erwähne die Quelle diff --git a/translation/dest/broadcast/el-GR.xml b/translation/dest/broadcast/el-GR.xml index a47fe00d23289..5aeb0c835599f 100644 --- a/translation/dest/broadcast/el-GR.xml +++ b/translation/dest/broadcast/el-GR.xml @@ -22,9 +22,7 @@ Σύντομη περιγραφή τουρνουά Πλήρης περιγραφή γεγονότος Προαιρετική αναλυτική περιγραφή της αναμετάδοσης. Η μορφή %1$s είναι διαθέσιμη. Το μήκος πρέπει μικρότερο από %2$s χαρακτήρες. - Διεύθυνση URL πηγής ή ID παιχνιδιού URL για λήψη PGN ενημερώσεων. Πρέπει να είναι δημόσια προσβάσιμο μέσω διαδικτύου. - Εναλλακτικά, μπορείτε να εισάγετε έως 64 IDs παιχνιδιών Lichess, με κενά μεταξύ τους. Ημερομηνία έναρξης στη δική σας ζώνη ώρας Προαιρετικό, εάν γνωρίζετε πότε αρχίζει η εκδήλωση Αναφέρετε την πηγή diff --git a/translation/dest/broadcast/en-US.xml b/translation/dest/broadcast/en-US.xml index 43ffd27d234ad..449b09b6167d1 100644 --- a/translation/dest/broadcast/en-US.xml +++ b/translation/dest/broadcast/en-US.xml @@ -23,9 +23,9 @@ Short tournament description Full event description Optional long description of the broadcast. %1$s is available. Length must be less than %2$s characters. - Source URL, or game IDs + PGN Source URL URL that Lichess will check to get PGN updates. It must be publicly accessible from the Internet. - Alternatively, you can enter up to 64 Lichess game IDs, separated by spaces. + Up to 64 Lichess game IDs, separated by spaces. Start date in your own timezone Optional, if you know when the event starts Credit the source diff --git a/translation/dest/broadcast/eo-UY.xml b/translation/dest/broadcast/eo-UY.xml index 68ed84a1c5993..ff7c8046daf57 100644 --- a/translation/dest/broadcast/eo-UY.xml +++ b/translation/dest/broadcast/eo-UY.xml @@ -23,9 +23,7 @@ Mallonga turnira priskribo Plena eventa priskribo Laŭvola longa priskribo de la elsendo. %1$s haveblas. Longeco devas esti malpli ol %2$s literoj. - Fontaj URL-oj, aŭ ludaj ID-oj URL kiun Lichess kontrolos por akiri PGN ĝisdatigojn. Ĝi devas esti publike alirebla en interreto. - Alternative, vi povas enmeti ĝis 64 Lichess ludajn ID-ojn, apartigitajn per spacoj. Komenca dato en via propra horzono Laŭvola, se vi scias, kiam komenciĝas la evento Citu la fonton diff --git a/translation/dest/broadcast/es-ES.xml b/translation/dest/broadcast/es-ES.xml index cee42009ee332..715a6e1f9aada 100644 --- a/translation/dest/broadcast/es-ES.xml +++ b/translation/dest/broadcast/es-ES.xml @@ -23,9 +23,9 @@ Breve descripción del torneo Descripción completa del evento Descripción larga opcional de la emisión. %1$s está disponible. La longitud debe ser inferior a %2$s caracteres. - Enlace de origen o identificador de la partida + URL origen del archivo PGN URL que Lichess comprobará para obtener actualizaciones PGN. Debe ser públicamente accesible desde Internet. - Alternativamente, puedes introducir hasta 64 identificadores de partida, separados por espacios. + Hasta 64 identificadores de partidas de Lichess, separados por espacios. Fecha de inicio en tu zona horaria Opcional, si sabes cuando comienza el evento Cita la fuente diff --git a/translation/dest/broadcast/et-EE.xml b/translation/dest/broadcast/et-EE.xml index f7f0681108a65..46a035083600f 100644 --- a/translation/dest/broadcast/et-EE.xml +++ b/translation/dest/broadcast/et-EE.xml @@ -13,9 +13,7 @@ Lühike turniiri kirjeldus Sündmuse täielik kirjeldus Valikuline otseülekande kirjeldus. %1$s on saadaval. Pikkus peab olema maksimaalselt %2$s tähemärki. - Allika URL või mängu ID-d URL, kust Lichess saab PGN-i värskenduse. See peab olema Internetist kättesaadav. - Või siis on võimalik lisada 64 Lichess mängu ID-t, vahedega eraldatud. Alguskuupäev sinu ajavööndis Valikuline, kui tead millal sündmus algab Viita allikale diff --git a/translation/dest/broadcast/eu-ES.xml b/translation/dest/broadcast/eu-ES.xml index d9bc2070db07f..e4e2a834d6743 100644 --- a/translation/dest/broadcast/eu-ES.xml +++ b/translation/dest/broadcast/eu-ES.xml @@ -23,9 +23,7 @@ Txapelketaren deskribapen laburra Ekitaldiaren deskribapen osoa Emanaldiaren azalpen luzea, hautazkoa da. %1$s badago. Luzera %2$s karaktere edo laburragoa izan behar da. - Iturburu URLa edo partiden IDak Lichessek PGNaren eguneraketak jasoko dituen URLa. Interneteko helbide bat izan behar da. - Bestela, Lichess partiden 64 id sartu ditzakezu, espazioarekin banatuta. Zure ordu-zonako hasiera data Hautazkoa, ekitaldia noiz hasten den baldin badakizu Jatorria zein den esaiguzu diff --git a/translation/dest/broadcast/fa-IR.xml b/translation/dest/broadcast/fa-IR.xml index ef708cc564d81..9c0bb795b9ed1 100644 --- a/translation/dest/broadcast/fa-IR.xml +++ b/translation/dest/broadcast/fa-IR.xml @@ -23,9 +23,8 @@ توضیحات کوتاه مسابقات توضیحات کامل مسابقات توضیحات بلند و اختیاری پخش همگانی. %1$s قابل‌استفاده است. طول متن باید کمتر از %2$s نویسه باشد. - نشانی منبع، یا شناسه بازی‌ها وب‌نشانی‌ای که Lichess برای دریافت به‌روزرسانی‌های PGN می‌بررسد. آن باید از راه اینترنت در دسترس همگان باشد. - همچنین، می‌توانید تا ۶۴ شناسه بازی Lichess را که با *فاصله* از هم جدا شده‌اند، وارد کنید. + تا ۶۴ نشانه بازی لیچس٬ جداشده با فاصله. تاریخ شروع، در منطقه زمانی خودتان اختیاری است، اگر می‌دانید چه زمانی رویداد شروع می‌شود به منبع اعتبار دهید diff --git a/translation/dest/broadcast/fi-FI.xml b/translation/dest/broadcast/fi-FI.xml index ad045ec9af4c4..6e54bd3b0bdf1 100644 --- a/translation/dest/broadcast/fi-FI.xml +++ b/translation/dest/broadcast/fi-FI.xml @@ -23,9 +23,9 @@ Turnauksen lyhyt kuvaus Täysimittainen kuvaus tapahtumasta Ei-pakollinen pitkä kuvaus lähetyksestä. %1$s-muotoiluja voi käyttää. Pituus voi olla enintään %2$s merkkiä. - Lähteen URL-osoite tai peli ID:t + PGN:n lähde-URL URL, josta Lichess hakee PGN-päivitykset. Sen täytyy olla julkisesti saatavilla internetissä. - Vaihtoehtoisesti, voit syöttää jopa 64 Lichess peli ID:tä, erotettuna välilyönneillä. + Korkeintaan 64 Lichess-pelin tunnistenumeroa välilyönneillä eroteltuna. Alkamispäivämäärä omalla aikavyöhykkeelläsi Ei-pakollinen, laita jos tiedät milloin tapahtuma alkaa Mainitse lähde diff --git a/translation/dest/broadcast/fo-FO.xml b/translation/dest/broadcast/fo-FO.xml index f50d18b0c4eeb..0cb94cce03c13 100644 --- a/translation/dest/broadcast/fo-FO.xml +++ b/translation/dest/broadcast/fo-FO.xml @@ -9,9 +9,7 @@ Nummar á umfari Fullfíggjað lýsing av tiltaki Valfrí long lýsing av sending. %1$s er tøkt. Longdin má vera styttri enn %2$s bókstavir. - Keldu-URL ella talvsamleikar URL-leinki, ið Lichess fer at kanna til tess at fáa PGN dagføringar. Leinkið nýtist at vera alment atkomiligt á alnetinum. - Til ber eisini ístaðin at skriva 64 Lichess-samleikar upp. Teir noyðast at vera skildir sundur við millumrúmum. Byrjanardagfesting í tínum egna tíðarøki Valfrítt, um tú veitst, nær tiltakið byrjar Nevn kelduna diff --git a/translation/dest/broadcast/fr-FR.xml b/translation/dest/broadcast/fr-FR.xml index 39d2deef5c60d..49a3ee11bde87 100644 --- a/translation/dest/broadcast/fr-FR.xml +++ b/translation/dest/broadcast/fr-FR.xml @@ -23,9 +23,9 @@ Brève description du tournoi Description complète de l\'événement Description détaillée et optionnelle de la diffusion. %1$s est disponible. La longueur doit être inférieure à %2$s caractères. - URL source ou IDs de parties + URL source de la partie en PGN URL que Lichess interrogera pour obtenir les mises à jour du PGN. Elle doit être accessible publiquement depuis Internet. - Vous pouvez également entrer jusqu\'à 64 IDs de parties Lichess séparés par un espace. + Jusqu\'à 64 ID de partie Lichess séparés par des espaces. Date de début dans votre fuseau horaire Facultatif, si vous savez quand l\'événement commence Créditer la source diff --git a/translation/dest/broadcast/ga-IE.xml b/translation/dest/broadcast/ga-IE.xml index 4941e6601b6ac..97bab1791832e 100644 --- a/translation/dest/broadcast/ga-IE.xml +++ b/translation/dest/broadcast/ga-IE.xml @@ -13,9 +13,7 @@ Cur síos gairid ar an gcomórtas Cur síos iomlán ar an ócáid Cur síos fada roghnach ar an craoladh. Tá %1$s ar fáil. Caithfidh an fad a bheith níos lú ná %2$s carachtar. - URL foinse, nó cluiche CA URL a seiceálfaidh Lichess chun PGN nuashonruithe a fháil. Caithfidh sé a bheith le féiceáil go poiblí ón Idirlíon. - Nó is féidir suas le 64 ID cluiche Lichess a iontráil, scartha le spásanna. Dáta tosaigh i do chrios ama féin Roghnach, má tá a fhios agat cathain a thosóidh an ócáid Creidmheas an fhoinse diff --git a/translation/dest/broadcast/gl-ES.xml b/translation/dest/broadcast/gl-ES.xml index cd2de28ff4eee..4852c77cbf46b 100644 --- a/translation/dest/broadcast/gl-ES.xml +++ b/translation/dest/broadcast/gl-ES.xml @@ -23,9 +23,9 @@ Breve descrición do torneo Descrición completa do evento Descrición longa opcional da retransmisión. %1$s está dispoñíbel. A lonxitude debe ser menor de %2$s caracteres. - Ligazón de orixe ou identificador da partida + URL de orixe do arquivo PGN Ligazón que Lichess comprobará para obter actualizacións dos PGN. Debe ser publicamente accesíbel desde a Internet. - Alternativamente, podes introducir ata 64 identificadores de partida, separados por espazos. + Até 64 identificadores de partidas de Lichess, separados por espazos. Data de inicio na túa zona horaria Opcional, se sabes cando comeza o evento Cita a fonte diff --git a/translation/dest/broadcast/gsw-CH.xml b/translation/dest/broadcast/gsw-CH.xml index 168ad25abcbd3..7a3b2f16d796b 100644 --- a/translation/dest/broadcast/gsw-CH.xml +++ b/translation/dest/broadcast/gsw-CH.xml @@ -23,9 +23,7 @@ Churzi Turnier Beschribig Vollschtändigi Ereignisbeschribig Optionali, usfüehrlichi Beschribig vu de Überträgig. %1$s isch verfügbar. Die Beschribig muess chürzer als %2$s Zeiche si. - Quell-URL oder Partie-IDs URL wo Lichess abfrögt, für PGN Aktualisierige z\'erhalte. Sie muess öffentlich im Internet zuegänglich si. - Alternativ chasch bis zu 64 dur Leerzeiche trännti Lichess Partie IDs igeh. Startdatum in dinere eigene Zitzone Optional, falls du weisch, wänn das Ereignis afangt Erwähn die Quälle diff --git a/translation/dest/broadcast/gu-IN.xml b/translation/dest/broadcast/gu-IN.xml index 7a6c4fad92c5b..3ea04e700dfa8 100644 --- a/translation/dest/broadcast/gu-IN.xml +++ b/translation/dest/broadcast/gu-IN.xml @@ -1,5 +1,2 @@ - - સ્રોત ચુ. આર. એલ., અથવા રમત આઇ. ડીસ - વૈકલ્પિક રીતે, તમેં 64 લાઇચેસ રમત આઇડીસ નાખિ શકો છો, વચ્ચે સ્પેસ નાખિને. - + diff --git a/translation/dest/broadcast/he-IL.xml b/translation/dest/broadcast/he-IL.xml index 099739d2f7d7b..f938cd4c992a4 100644 --- a/translation/dest/broadcast/he-IL.xml +++ b/translation/dest/broadcast/he-IL.xml @@ -25,9 +25,9 @@ תיאור הטורניר בקצרה תיאור מלא של הטורניר תיאור מפורט של הטורניר (אופציונאלי). %1$s זמין. אורך התיאור לא יעלה על %2$s תווים. - קישור למקור (URL) או מזהה המשחקים (IDs) + קישור המקור של ה-PGN הקישור ש־Lichess יבדוק כדי לקלוט עדכונים ב-PGN. הוא חייב להיות פומבי ונגיש דרך האינטרנט. - לחלופין, ניתן להזין עד 64 IDs של משחקי ליצ׳ס, מופרדים ברווחים. + עד 64 מזהי משחק של Lichess, מופרדים ברווחים. תאריך ההתחלה באזור הזמן שלך אופציונאלי, אם את/ה יודע/ת מתי האירוע צפוי להתחיל תן/י קרדיט למקור diff --git a/translation/dest/broadcast/hi-IN.xml b/translation/dest/broadcast/hi-IN.xml index d97e2c0670f6b..d27142de5a14f 100644 --- a/translation/dest/broadcast/hi-IN.xml +++ b/translation/dest/broadcast/hi-IN.xml @@ -18,9 +18,7 @@ संक्षिप्त प्रतियोगिता वर्णन संक्षिप्त वर्णन प्रसारण का वैकल्पिक लंबा विवरण. %1$s उपलब्ध है. लंबाई %2$s से कम होना चाहिए - स्रोत URL, या गेम आईडी URL जो Lichess PGN अपडेट प्राप्त करने के लिए जाँच करेगा। यह सार्वजनिक रूप से इंटरनेट पर सुलभ होना चाहिए। - वैकल्पिक रूप से, आप रिक्त स्थान द्वारा अलग किए गए 64 Lichess गेम आईडी तक दर्ज कर सकते हैं। अपने स्वयं के समयक्षेत्र में प्रारंभ दिनांक वैकल्पिक, यदि आप जानना चाहते हो की प्रतिस्प्रधा कब शुरू होगी स्रोत को श्रेय दें diff --git a/translation/dest/broadcast/hr-HR.xml b/translation/dest/broadcast/hr-HR.xml index 9abe54e1519b7..5a8a5071df827 100644 --- a/translation/dest/broadcast/hr-HR.xml +++ b/translation/dest/broadcast/hr-HR.xml @@ -18,9 +18,7 @@ Kratak opis turnira Potpuni opis događaja Neobavezni dugi opis prijenosa. %1$s je dostupno. Duljina mora biti manja od %2$s znakova. - URL izvora ili identifikacijski broj igre Link koji će Lichess ispitavati kako bi dobio PGN ažuriranja. Mora biti javno dostupan s interneta. - Možete i unijeti do 64 identifikacijska broja igara Lichessa, odvojenih razmacima. Datum početka u vlastitoj vremenskoj zoni Neobavezno, ako znaš kada događaj počinje Naglasi izvor diff --git a/translation/dest/broadcast/hu-HU.xml b/translation/dest/broadcast/hu-HU.xml index 832da2213ff91..d0adfb37758bc 100644 --- a/translation/dest/broadcast/hu-HU.xml +++ b/translation/dest/broadcast/hu-HU.xml @@ -17,9 +17,7 @@ Verseny rövid leírása Esemény teljes leírása Opcionális a közvetítés még bővebb leírása. %1$s használható. A hossz nem lehet több, mint %2$s karakter. - Forrás URL vagy játszmaazonosítók URL amit a Lichess időnként PGN frissítésekért ellenőriz. Ennek nyilvános internetcímnek kell lennie. - Illetve megadhatsz legfeljebb 64 Lichess játszmaazonosítót, szóközökkel elválasztva. Kezdés időpontja a saját időzónádban Opcionális, ha tudod mikor kezdődik az esemény Forrásmegjelölés diff --git a/translation/dest/broadcast/id-ID.xml b/translation/dest/broadcast/id-ID.xml index 9f04a7fd5527e..80fb0440c0161 100644 --- a/translation/dest/broadcast/id-ID.xml +++ b/translation/dest/broadcast/id-ID.xml @@ -13,9 +13,7 @@ Deskripsi singkat turnamen Keterangan acara secara penuh Deskripsi panjang opsional dari siaran. %1$s tersedia. Panjangnya harus kurang dari %2$s karakter. - Sumber URL, atau IDs game URL yang akan di-polling oleh Lichess untuk mendapatkan pembaruan PGN. Itu harus dapat diakses publik dari Internet. - Kalau tidak, kamu bisa memasukkan lebih dari 64 Lichess IDs game, dipisahkan oleh spasi. Tanggal mulai di zona waktu Anda sendiri Opsional, jika Anda tahu kapan acara dimulai Sertakan sumber diff --git a/translation/dest/broadcast/it-IT.xml b/translation/dest/broadcast/it-IT.xml index bca4380d9abcd..adc748be56885 100644 --- a/translation/dest/broadcast/it-IT.xml +++ b/translation/dest/broadcast/it-IT.xml @@ -23,9 +23,7 @@ Breve descrizione dell\'evento Descrizione completa dell\'evento (Facoltativo) Descrizione completa dell\'evento. %1$s è disponibile. La lunghezza deve essere inferiore a %2$s caratteri. - URL sorgente, o ID gioco L\'URL che Lichess utilizzerà per ottenere gli aggiornamenti dei PGN. Deve essere accessibile pubblicamente su Internet. - In alternativa è possibile inserire fino a 64 ID di partite su Lichess, separati da spazi. Data di inizio nel tuo fuso orario Facoltativo, se sai quando inizia l\'evento Cita la fonte diff --git a/translation/dest/broadcast/ja-JP.xml b/translation/dest/broadcast/ja-JP.xml index 37bcba2c1f51a..53bdbd425abe8 100644 --- a/translation/dest/broadcast/ja-JP.xml +++ b/translation/dest/broadcast/ja-JP.xml @@ -22,9 +22,7 @@ 大会の短い説明 長い説明 内容の詳しい説明（オプション）。%1$s が利用できます。長さは [欧文換算で] %2$s 字まで。 - ソース URLかゲーム ID Lichess が PGN を取得するための URL。インターネット上に公表されているもののみ。 - Lichess ゲーム ID は半角スペースで区切れば最大 64 個まで入力できます。 開始日付（あなたの現地時間） イベント開始時刻（オプション） ソースを表示する diff --git a/translation/dest/broadcast/kk-KZ.xml b/translation/dest/broadcast/kk-KZ.xml index 854b352a05ea4..6406d3b24d3af 100644 --- a/translation/dest/broadcast/kk-KZ.xml +++ b/translation/dest/broadcast/kk-KZ.xml @@ -18,9 +18,7 @@ Жарыстың қысқа сипаттамасы Оқиғаның толық сипаттамасы Көрсетілімнің қосымша үлкен сипаттамасы. %1$s қолданысқа ашық. Ұзындығы %2$s таңбадан кем болуы керек. - Сілтемесі не ойын нөмірлері PGN жаңартуларын алу үшін Личес тексеретін сілтеме. Ол интернетте баршалыққа ашық болуы керек. - Одан бөлек, бос орынмен ажыратып, ең көбі 64 Личес ойындарының нөмірін енгізе аласыз. Басталу күні (өз уақыт белдеуіңізде) Міндетті емес, егер күнін біліп тұрсаңыз Қайнар көзіне сілтеңіз diff --git a/translation/dest/broadcast/kn-IN.xml b/translation/dest/broadcast/kn-IN.xml index 1132b463203e7..132a6c33e8ba4 100644 --- a/translation/dest/broadcast/kn-IN.xml +++ b/translation/dest/broadcast/kn-IN.xml @@ -17,9 +17,7 @@ ಸಣ್ಣ ಪಂದ್ಯಾವಳಿಯ ವಿವರಣೆ ಪಂದ್ಯಾವಳಿಯ ಸಂಪೂರ್ಣ ವಿವರಣೆ ಪಂದ್ಯಾವಳಿಯ ಐಚ್ಛಿಕ ದೀರ್ಘ ವಿವರಣೆ. %1$s ಲಭ್ಯವಿದೆ. ಉದ್ದವು %2$s ಅಕ್ಷರಗಳಿಗಿಂತ ಕಡಿಮೆಯಿರಬೇಕು. - ಮೂಲ URL, ಅಥವಾ ಆಟದ ಐಡಿಗಳು PGN ನವೀಕರಣಗಳನ್ನು ಪಡೆಯಲು Lichess ಪರಿಶೀಲಿಸುವ URL. ಇದನ್ನು ಇಂಟರ್ನೆಟ್‌ನಿಂದ ಸಾರ್ವಜನಿಕವಾಗಿ ಪ್ರವೇಶಿಸಬೇಕು. - ಪರ್ಯಾಯವಾಗಿ, ನೀವು 64 ಲೈಚೆಸ್ ಗೇಮ್ ID ಗಳನ್ನು ನಮೂದಿಸಬಹುದು, ಇದನ್ನು ಸ್ಪೇಸ್‌ಗಳಿಂದ ಬೇರ್ಪಡಿಸಬಹುದು. ನಿಮ್ಮ ಸ್ವಂತ ಸಮಯವಲಯದಲ್ಲಿ ದಿನಾಂಕವನ್ನು ಪ್ರಾರಂಭಿಸಿ ಐಚ್ಛಿಕ, ಈವೆಂಟ್ ಯಾವಾಗ ಪ್ರಾರಂಭವಾಗುತ್ತದೆ ಎಂದು ನಿಮಗೆ ತಿಳಿದಿದ್ದರೆ ಮೂಲವನ್ನು ಕ್ರೆಡಿಟ್ ಮಾಡಿ diff --git a/translation/dest/broadcast/ko-KR.xml b/translation/dest/broadcast/ko-KR.xml index 373ddcf389856..162ee9fefe881 100644 --- a/translation/dest/broadcast/ko-KR.xml +++ b/translation/dest/broadcast/ko-KR.xml @@ -20,9 +20,7 @@ 짧은 토너먼트 설명 전체 이벤트 설명 (선택) 방송에 대한 긴 설명입니다. %1$s 사용이 가능합니다. 길이는 %2$s 글자보다 짧아야 합니다. - 출처 URL 또는 게임 ID Lichess가 PGN 업데이트를 받기 위해 확인할 URL입니다. 인터넷에서 공개적으로 액세스 할 수 있어야 합니다. - 또는, 공백으로 구분하여 최대 64 개의 Lichess 게임 ID를 입력 할 수 있습니다. 본인 시간대 기준 시작일 선택사항. 언제 이벤트가 시작되는지 알고 있는 경우 출처 diff --git a/translation/dest/broadcast/lb-LU.xml b/translation/dest/broadcast/lb-LU.xml index 7e9e837182ac7..fe30e6accdee3 100644 --- a/translation/dest/broadcast/lb-LU.xml +++ b/translation/dest/broadcast/lb-LU.xml @@ -17,9 +17,7 @@ Kuerz Turnéierbeschreiwung Komplett Turnéierbeschreiwung Optional laang Beschreiwung vum Turnéier. %1$s ass disponibel. Längt muss manner wéi %2$s Buschtawen sinn. - Quellen-URL oder Partien IDs URL déi Lichess checkt fir PGN à jour ze halen. Muss ëffentlech iwwer Internet zougänglech sinn. - Alternativ kanns du och bis zu 64 Lichess Partien IDs aginn, getrennt duerch Espacen. Startdatum an denger eegener Zäitzon Optional, wann du wees wéini den Turnéier ufänkt Quell kreditéieren diff --git a/translation/dest/broadcast/lt-LT.xml b/translation/dest/broadcast/lt-LT.xml index 8198580d28b4d..c4c5fcdf314cb 100644 --- a/translation/dest/broadcast/lt-LT.xml +++ b/translation/dest/broadcast/lt-LT.xml @@ -20,9 +20,7 @@ Trumpas turnyro aprašymas Pilnas renginio aprašymas Neprivalomas pilnas transliacijos aprašymas. Galima naudoti %1$s. Ilgis negali viršyti %2$s simbolių. - Šaltinių adresai arba žaidimų id URL, į kurį „Lichess“ kreipsis gauti PGN atnaujinimus. Privalo būti viešai pasiekiamas internete. - Taip pat galite įvesti iki 64 Lichess žaidimų id, atskyrę juos tarpais. Pradžios laikas jūsų laiko juostoje Neprivaloma; tik jeigu žinote, kada prasideda renginys Paminėkite šaltinį diff --git a/translation/dest/broadcast/lv-LV.xml b/translation/dest/broadcast/lv-LV.xml index 8242152a35009..92eac6b60cebb 100644 --- a/translation/dest/broadcast/lv-LV.xml +++ b/translation/dest/broadcast/lv-LV.xml @@ -13,9 +13,7 @@ Īss turnīra apraksts Pilns pasākuma apraksts Neobligāts garš raidījuma apraksts. Pieejams %1$s. Garumam jābūt mazāk kā %2$s rakstzīmēm. - Avota URL, vai spēļu ID URL, ko Lichess aptaujās, lai iegūtu PGN atjauninājumus. Tam jābūt publiski piekļūstamam no interneta. - Varat arī ievadīt līdz pat 64 Lichess spēļu ID, atdalītus ar atstarpēm. Sākuma datums jūsu laika joslā Neobligāts, ja zināt, kad pasākums sākas Kreditējiet avotu diff --git a/translation/dest/broadcast/mr-IN.xml b/translation/dest/broadcast/mr-IN.xml index d48b77fccd3b7..3111fb098a28d 100644 --- a/translation/dest/broadcast/mr-IN.xml +++ b/translation/dest/broadcast/mr-IN.xml @@ -22,9 +22,7 @@ लघु स्पर्धेचे वर्णन संपूर्ण स्पर्धेचे वर्णन स्पर्धेचे पर्यायी संपूर्ण वर्णन. %1$s उपलब्ध आहे. %2$s अक्षरांपेक्षा कमी. - Source URL, or game IDs URL जी लाइसेस PGN अद्यतने मिळविण्यासाठी तपासणी करेल. ते इंटरनेट वरून सार्वजनिकरित्या प्रवेश करण्यायोग्य असणे आवश्यक आहे. - वैकल्पिकरित्या, आपण स्पेस देऊन ६४ पर्यंत लीचेस गेम आयडी प्रविष्ट करू शकता. आपल्या स्वत: च्या टाइमझोनमधील तारीख पर्यायी, इव्हेंट कधी सुरू होतो हे आपल्याला माहिती असल्यास Credit the source diff --git a/translation/dest/broadcast/nb-NO.xml b/translation/dest/broadcast/nb-NO.xml index a2bf0865ecdb8..55d652db79fa9 100644 --- a/translation/dest/broadcast/nb-NO.xml +++ b/translation/dest/broadcast/nb-NO.xml @@ -23,9 +23,7 @@ Kort beskrivelse av turneringen Full beskrivelse av turneringen Valgfri lang beskrivelse av turneringen. %1$s er tilgjengelig. Beskrivelsen må være kortere enn %2$s tegn. - Kilde-URL eller parti-ID-er Lenke som Lichess vil hente PGN-oppdateringer fra. Den må være offentlig tilgjengelig på internett. - Du kan ellers skrive inn opptil 64 ID-er for partier hos Lichess. De må være adskilt med mellomrom. Startdato i din egen tidssone Valgfritt, hvis du vet når arrangementet starter Krediter kilden diff --git a/translation/dest/broadcast/nl-NL.xml b/translation/dest/broadcast/nl-NL.xml index d5c98975e8353..8063d1ddd6a4c 100644 --- a/translation/dest/broadcast/nl-NL.xml +++ b/translation/dest/broadcast/nl-NL.xml @@ -22,9 +22,7 @@ Korte toernooibeschrijving Volledige beschrijving evenement Optionele lange beschrijving van de uitzending. %1$s is beschikbaar. Totale lengte moet minder zijn dan %2$s tekens. - Bron-URL of partij-ID\'s Link die Lichess gebruikt om PGN updates te krijgen. Deze moet openbaar toegankelijk zijn via internet. - U kunt ook maximaal 64 Lichess partij-ID\'s invoeren, gescheiden door spaties. Aanvangsdatum in je eigen tijdzone Optioneel, als je weet wanneer het evenement start Bronvermelding diff --git a/translation/dest/broadcast/nn-NO.xml b/translation/dest/broadcast/nn-NO.xml index e2250cf1ead49..f73a33756d29b 100644 --- a/translation/dest/broadcast/nn-NO.xml +++ b/translation/dest/broadcast/nn-NO.xml @@ -23,9 +23,9 @@ Kortfatta skildring av turneringa Full omtale av arrangementet Valfri lang omtale av overføringa. %1$s er tilgjengeleg. Omtalen må vera kortare enn %2$s teikn. - Kjelde-URL eller parti-ID-ar + PGN kjelde-URL Lenke som Lichess vil hente PGN-oppdateringar frå. Den må vera offentleg tilgjengeleg på internett. - Som eit alternativ kan du skriva opp til 64 Lichess-ID\'ar, skilde frå kvarandre med eit mellomrom. + Opp til 64 Lichess spel-ID\'ar, skilde med mellomrom. Startdato i di eiga tidssone Valfritt, om du veit når arrangementet startar Kreditér kjelda diff --git a/translation/dest/broadcast/pl-PL.xml b/translation/dest/broadcast/pl-PL.xml index 26c2b6f59d383..62130d166a1e2 100644 --- a/translation/dest/broadcast/pl-PL.xml +++ b/translation/dest/broadcast/pl-PL.xml @@ -25,9 +25,9 @@ Krótki opis turnieju Pełny opis wydarzenia Opcjonalny długi opis transmisji. %1$s jest dostępny. Długość musi być mniejsza niż %2$s znaków. - Źródłowy URL lub lista ID partii + Adres URL zapisu PGN Adres URL, który Lichess będzie udostępniał, aby można było uzyskać aktualizacje PGN. Musi być publicznie dostępny z internetu. - Alternatywnie, możesz wprowadzić do 64 ID\'ów gier Lichess, oddzielonych spacjami. + Do 64 identyfikatorów partii, oddzielonych spacjami. Data rozpoczęcia wydarzenia w Twojej strefie czasowej Opcjonalne, jeśli wiesz kiedy wydarzenie się rozpocznie Potwierdź źródło diff --git a/translation/dest/broadcast/pt-BR.xml b/translation/dest/broadcast/pt-BR.xml index 1b6e7587efeb9..827ac3fd43520 100644 --- a/translation/dest/broadcast/pt-BR.xml +++ b/translation/dest/broadcast/pt-BR.xml @@ -23,9 +23,7 @@ Descrição curta do torneio Descrição completa do evento Descrição longa e opcional da transmissão. %1$s está disponível. O tamanho deve ser menor que %2$s caracteres. - URL de origem ou IDs das partidas URL que Lichess irá verificar para obter atualizações PGN. Deve ser acessível ao público a partir da Internet. - Como alternativa, você pode inserir até 64 IDs de jogo do Lichess, separados por espaços. Data de início em seu próprio fuso horário Opcional, se você sabe quando o evento começa Crédito a fonte diff --git a/translation/dest/broadcast/pt-PT.xml b/translation/dest/broadcast/pt-PT.xml index a0bf27cb80744..098522ff13a8d 100644 --- a/translation/dest/broadcast/pt-PT.xml +++ b/translation/dest/broadcast/pt-PT.xml @@ -23,9 +23,9 @@ Breve descrição do torneio Descrição completa do evento Descrição longa do evento opcional da transmissão. %1$s está disponível. Tem de ter menos que %2$s carácteres. - URL de origem ou IDs do jogo + URL da fonte PGN Link que o Lichess vai verificar para obter atualizações da PGN. Deve ser acessível ao público a partir da internet. - Como alternativa, você pode inserir até 64 IDs do jogo Lichess, separados por espaços. + Até 64 IDs de jogo Lichess, separados por espaços. Data de início no teu fuso horário Opcional, se souberes quando começa o evento Credita a fonte diff --git a/translation/dest/broadcast/ro-RO.xml b/translation/dest/broadcast/ro-RO.xml index e5e9696766f27..b1df2049de7e2 100644 --- a/translation/dest/broadcast/ro-RO.xml +++ b/translation/dest/broadcast/ro-RO.xml @@ -23,9 +23,7 @@ O descriere scurtă a turneului Întreaga descriere a evenimentului Descriere lungă, opțională, a difuzării. %1$s este disponibil. Lungimea trebuie să fie mai mică decât %2$s caractere. - Link-ul sursă, sau ID-ul partidei URL-ul pe care Lichess îl va verifica pentru a obține actualizări al PGN-ului. Trebuie să fie public accesibil pe Internet. - Alternativ, poți să adaugi 64 ID-uri de jocuri pe Lichess, separat de spațiu. Data de începere conform fusului tău orar Opțional, dacă știi când va începe evenimentul Creditează sursa diff --git a/translation/dest/broadcast/ru-RU.xml b/translation/dest/broadcast/ru-RU.xml index 972e56f549e36..4146cf59a043b 100644 --- a/translation/dest/broadcast/ru-RU.xml +++ b/translation/dest/broadcast/ru-RU.xml @@ -25,9 +25,8 @@ Краткое описание турнира Полное описание события Необязательное полное описание трансляции. Доступна разметка %1$s. Длина должна быть меньше %2$s символов. - Исходный URL или идентификатор партии URL-адрес, с которого Lichess будет получать обновление PGN. Он должен быть доступен для получения из Интернета. - Кроме того, вы можете ввести до 64 идентификаторов партий, разделённых пробелами. + До 64 идентификаторов (ID) игр Lichess, разделённых пробелами. Дата начала в вашем часовом поясе Дополнительно, если вы знаете, когда событие начнётся Признательность diff --git a/translation/dest/broadcast/ry-UA.xml b/translation/dest/broadcast/ry-UA.xml index 9dfcbfc4d5d68..4625abe83fc1f 100644 --- a/translation/dest/broadcast/ry-UA.xml +++ b/translation/dest/broadcast/ry-UA.xml @@ -13,9 +13,7 @@ Куртый опис турніра Повный опис турніра Немусайно повный опис турніра. %1$s приступный. Довжина має быти менша за %2$s сімболув. - Зачаточноє URL, вадь ідентіфікатор бавкы Одкликованя, через якоє Lichess буде доставати обновеня PGN. Ун має быти приступный из Інтернета. - Попиля того, можете увести 64 ідентіфікаторув бавкы на Lichess, роздїлені пролишами. Дата старта у вашум часовум поясі Опціонално, кідь знаєте коли ся зачинат припад Оддяка diff --git a/translation/dest/broadcast/sk-SK.xml b/translation/dest/broadcast/sk-SK.xml index bdc97f08e9479..75d8978539a7a 100644 --- a/translation/dest/broadcast/sk-SK.xml +++ b/translation/dest/broadcast/sk-SK.xml @@ -21,9 +21,7 @@ Krátky popis turnaja Úplný popis turnaja Voliteľný dlhý popis vysielania. %1$s je dostupný. Dĺžka musí byť menej ako %2$s znakov. - Zdrojová URL alebo ID partií URL, ktorú bude Lichess kontrolovať, aby získal aktualizácie PGN. Musí byť verejne prístupná z internetu. - Prípadne môžete zadať až 64 ID Lichess partií oddelených medzerami. Dátum a čas začiatku, vo vašej časovej zóne Voliteľné, ak viete kedy sa udalosť začne Uveďte zdroj diff --git a/translation/dest/broadcast/sl-SI.xml b/translation/dest/broadcast/sl-SI.xml index c1810a50e6e20..719c85ee31daa 100644 --- a/translation/dest/broadcast/sl-SI.xml +++ b/translation/dest/broadcast/sl-SI.xml @@ -25,9 +25,7 @@ Kratek opis turnirja Polni opis dogodka Neobvezen dolg opis prenosa. %1$s je na voljo. Dolžina mora biti manjša od %2$s znakov. - Izvorni URL ali ID igre URL, ki ga bo Lichess preveril, da bo prejel PGN posodobitve. Javno mora biti dostopen preko interneta. - Lahko pa vnesete do 64 ID-jev lichess iger, ločene s presledki. Datum začetka v vaše časovnem pasu Izbirno, če veste, kdaj se dogodek začne Navedi vir diff --git a/translation/dest/broadcast/sq-AL.xml b/translation/dest/broadcast/sq-AL.xml index 9c9bd8d7845eb..ff873de32923a 100644 --- a/translation/dest/broadcast/sq-AL.xml +++ b/translation/dest/broadcast/sq-AL.xml @@ -23,9 +23,7 @@ Përshkrim i shkurtër i turneut Përshkrim i plotë i turneut Përshkrim i gjatë opsional i turneut. %1$s është e disponueshme. Gjatësia duhet të jetë më pak se %2$s shenja. - URL burimi, ose ID-ra loje URL-ja që do të kontrollojë Lichess-i për të marrë përditësime PGN-sh. Duhet të jetë e përdorshme publikisht që nga Interneti. - Ndryshe, mund të jepni deri në 63 ID-ra lojërash Lichess, ndarë me presje. Datë fillimi në zonën tuaj kohore Opsionale, nëse e dini kur fillon veprimtaria Atriboji merita burimit diff --git a/translation/dest/broadcast/sv-SE.xml b/translation/dest/broadcast/sv-SE.xml index 26a8fc5dcec28..b7507af95de49 100644 --- a/translation/dest/broadcast/sv-SE.xml +++ b/translation/dest/broadcast/sv-SE.xml @@ -22,9 +22,7 @@ Kort beskrivning av turneringen Fullständig beskrivning Valfri längre beskrivning av sändningen. %1$s är tillgänglig. Längden måste vara mindre än %2$s tecken. - Käll-URL eller spel-ID:n URL som Lichess kan använda för att få PGN-uppdateringar. Den måste vara publikt tillgänglig från Internet. - Alternativt kan du ange upp till 64 Lichess spel-ID:n, separerade med mellanslag. Startdatum i din egen tidszon Valfritt, om du vet när händelsen startar Kreditera källan diff --git a/translation/dest/broadcast/tr-TR.xml b/translation/dest/broadcast/tr-TR.xml index c9f823299015d..76e5a6567899d 100644 --- a/translation/dest/broadcast/tr-TR.xml +++ b/translation/dest/broadcast/tr-TR.xml @@ -23,9 +23,7 @@ Turnuvanın kısa tanımı Etkinliğin detaylıca açıklaması Etkinliğin isteğe bağlı detaylı açıklaması. %1$s seçeneği mevcuttur. Metnin uzunluğu azami %2$s karakter olmalıdır. - Kaynak URL ya da oyun ID\'si Lichess, sağladığınız URL yardımıyla PGN\'yi güncelleyecektir. İnternet üzerinden herkese açık bir URL yazmalısınız. - Ayrıca en fazla 64 Lichess oyununun ID\'sini, aralarında boşluk bırakarak, ekleyebilirsiniz. Kendi saat diliminizdeki başlangıç zamanı İsteğe bağlı, etkinliğin ne zaman başladığını biliyorsanız ekleyebilirsiniz. Kaynağı görüntüle diff --git a/translation/dest/broadcast/tt-RU.xml b/translation/dest/broadcast/tt-RU.xml index 1f4995a9a5d90..b4bea29039cc2 100644 --- a/translation/dest/broadcast/tt-RU.xml +++ b/translation/dest/broadcast/tt-RU.xml @@ -10,9 +10,7 @@ Ярыш исеме Вакыйганы тулы тасвирлау Ишетләштереш өстәмә озынлыгы тасвирламасы %1$s бар. Озынлык %2$s символлардан ким булырга тиеш. - Чыганак URL яки уен IDе PGN яңартуларын алу өчен Lichess тикшерәчәк URL. Ул Интернеттан ачык булырга тиеш. - Альтернатив рәвештә, сез буш урыннар белән аерылган 64 Lichess уен ID-ләрен кертә аласыз. Башлагыз сәнә сезнең үзегезнең вакыт җирендән Ихтимал, вакыйганың кайчан башланганын белсәгез Чыганакка кредит diff --git a/translation/dest/broadcast/uk-UA.xml b/translation/dest/broadcast/uk-UA.xml index e32161e348799..d8cbe8d1075de 100644 --- a/translation/dest/broadcast/uk-UA.xml +++ b/translation/dest/broadcast/uk-UA.xml @@ -25,9 +25,7 @@ Короткий опис турніру Повний опис події Необов\'язковий довгий опис трансляції. Наявна розмітка %1$s. Довжина має бути менша ніж %2$s символів. - Посилання на джерело або ідентифікатор гри Посилання, яке Lichess перевірятиме, щоб отримати оновлення PGN. Воно має бути загальнодоступним в Інтернеті. - Крім того, ви можете ввести до 64 ідентифікаторів гри Lichess, розділених пробілами. Дата початку у вашому часовому поясі За бажанням, якщо ви знаєте, коли починається подія Вдячність джерелу diff --git a/translation/dest/broadcast/vi-VN.xml b/translation/dest/broadcast/vi-VN.xml index 3bd49d5b48818..4c1b2fafbcbf0 100644 --- a/translation/dest/broadcast/vi-VN.xml +++ b/translation/dest/broadcast/vi-VN.xml @@ -22,9 +22,9 @@ Mô tả ngắn giải đấu Mô tả đầy đủ giải đấu Tùy chọn mô tả dài về giải đấu. Có thể sử dụng %1$s. Độ dài phải nhỏ hơn %2$s ký tự. - URL nguồn hoặc ID ván cờ + URL Nguồn PGN URL mà Lichess sẽ khảo sát để nhận cập nhật PGN. Nó phải được truy cập công khai từ Internet. - Ngoài ra, bạn có thể nhập 64 ID ván đấu trên Lichess, phân tách bởi dấu cách. + Tối đa 64 ID ván cờ trên Lichess, phân tách bằng dấu cách. Ngày bắt đầu theo múi giờ của bạn Tùy chọn, nếu bạn biết khi nào sự kiện bắt đầu Công nhận nguồn diff --git a/translation/dest/broadcast/zh-CN.xml b/translation/dest/broadcast/zh-CN.xml index b701099df1fb0..975fa3503897a 100644 --- a/translation/dest/broadcast/zh-CN.xml +++ b/translation/dest/broadcast/zh-CN.xml @@ -22,9 +22,7 @@ 锦标赛简短描述 赛事详情 转播内容的详细描述 (可选）。可以使用 %1$s，字数少于 %2$s 个。 - 资源的 URL 链接或对局 ID Lichess 将从该网址搜查 PGN 的更新。它必须是公开的。 - 你也可以输入最长 64 个字符的 Lichess 对局 ID，用空格隔开。 开始日期，在你的本地时区 如果你知道比赛开始时间 (可选) 信任来源 diff --git a/translation/dest/broadcast/zh-TW.xml b/translation/dest/broadcast/zh-TW.xml index 51e54912bbeb7..fbe5362588d1b 100644 --- a/translation/dest/broadcast/zh-TW.xml +++ b/translation/dest/broadcast/zh-TW.xml @@ -13,9 +13,7 @@ 簡短比賽說明 完整比賽說明 直播內容的詳細描述 。可以利用 %1$s。字數限於%2$s個字。 - 對局URL連接，或遊戲ID Lichess 將以該網址更新PGN數據，網址必須公開 - 此外，您可以輸入最長64个字符的 Lichess 遊戲 ID，用空格隔開。 開始日期 (當地時間) 可選，如果知道比賽開始時間 將來源歸因 diff --git a/translation/dest/coordinates/ar-SA.xml b/translation/dest/coordinates/ar-SA.xml index c057b3b1e09c8..339bfab6471cf 100644 --- a/translation/dest/coordinates/ar-SA.xml +++ b/translation/dest/coordinates/ar-SA.xml @@ -13,6 +13,7 @@ لديك 30 ثانية لرسم خريطة صحيحة لأكبر عدد ممكن من المربعات! اذهب طالما تريد، لا يوجد حد زمني! إظهار الإحداثيات + الإحداثيات على كل مربع إظهار القطع إبدأ التدريب ابحث عن مربع diff --git a/translation/dest/coordinates/lb-LU.xml b/translation/dest/coordinates/lb-LU.xml index 69a843ed4efcd..b3512b7a20718 100644 --- a/translation/dest/coordinates/lb-LU.xml +++ b/translation/dest/coordinates/lb-LU.xml @@ -13,6 +13,7 @@ Du hues 30 Sekonnen fir esou vill Felder wéi méiglech korrekt ze wielen! Spill sou lang wéi du wëlls, et gëtt keng Zäitlimite! Koordinaten uweisen + Koordinaten op jiddwer Feld Figuren uweisen Training ufänken Feld fannen diff --git a/translation/dest/faq/ar-SA.xml b/translation/dest/faq/ar-SA.xml index 14d1ab58eb429..013d037f970c7 100644 --- a/translation/dest/faq/ar-SA.xml +++ b/translation/dest/faq/ar-SA.xml @@ -163,4 +163,13 @@ 3. انقر على ملفات تعريف الارتباط و أذونات الموقع 4. مرر للأسفل وانقر على Media Autoplay 5. أضف lichess.org للقائمة المسموح بها + كيف أوقف نفسي عن اللعب؟ + حالة عقلية مستقلة + أنماط المستخدم ليتشيس + تصنيفات أقل + نتلقى بانتظام رسائل من المستخدمين يطلبون منا المساعدة لمنعهم من اللعب كثيرًا. + + على الرغم من أن Lichess لا تقوم بحظر اللاعبين أو حظرهم باستثناء انتهاكات شروط الخدمة، فإننا نوصي باستخدام أدوات خارجية للحد من سلوك اللعب المفرط. تتضمن بعض الاقتراحات الشائعة لأدوات حظر مواقع الويب %1$s و%2$s و%3$s. إذا كنت تريد الاستمرار في استخدام الموقع ولكن لا تنجذب إلى التحكم في الوقت السريع، فقد تكون مهتمًا أيضًا بـ %4$s، إليك واحدة مع %5$s. + + قد يشعر بعض اللاعبين أن سلوكهم في اللعب يتحول إلى إدمان. في الواقع، تصنف منظمة الصحة العالمية اضطراب الألعاب على أنه %6$s، مع ميزات أساسية تتمثل في 1) ضعف التحكم في الألعاب، 2) زيادة الأولوية المعطاة للألعاب، و3) تصاعد الألعاب على الرغم من العواقب السلبية. إذا كنت تعتقد أن سلوكك في لعب الشطرنج يتبع هذا النمط، فإننا نشجعك على التحدث عن ذلك مع صديق أو أحد أفراد العائلة و/أو مع أحد المحترفين. diff --git a/translation/dest/site/ar-SA.xml b/translation/dest/site/ar-SA.xml index f3949ace2acc9..d179135d643be 100644 --- a/translation/dest/site/ar-SA.xml +++ b/translation/dest/site/ar-SA.xml @@ -74,6 +74,8 @@ رفع سلسلة الحركات رفع الى التسلسل الرئيسي احذف من هنا + أعلى + وسع التفريع فرض التسلسل انسخ التفريع بصيغة PGN التقلة @@ -854,6 +856,7 @@ تبديل أسهم النقلات المرشحة الدورة السابقة/التفريع التالي تبديل الرموز التوضيحية + تبديل تحليل الموقف أسمهم النقلات تسمح لك بلعبها دون استخدام قائمة النقلات المرشحة. لعب النقلة المحددة مسابقة جديدة diff --git a/translation/dest/site/ca-ES.xml b/translation/dest/site/ca-ES.xml index 88b4f62d71dd2..3940f593b8bea 100644 --- a/translation/dest/site/ca-ES.xml +++ b/translation/dest/site/ca-ES.xml @@ -70,8 +70,8 @@ Promoure variant Convertir en línia principal Esborrar des d\'aquí - Amagar variacions - Expandir variacions + Amagar variacions + Expandir variacions Forçar variant Copia el PGN de la variació Moviment diff --git a/translation/dest/site/he-IL.xml b/translation/dest/site/he-IL.xml index 5db647b9d37b3..07c1667f44639 100644 --- a/translation/dest/site/he-IL.xml +++ b/translation/dest/site/he-IL.xml @@ -72,8 +72,8 @@ העדפת וריאנט קביעה כוריאנט הראשי מחיקה מכאן והלאה - הסתרת מהלכים חלופיים - הצגת מהלכים חלופיים + הסתרת מהלכים חלופיים + הצגת מהלכים חלופיים וריאנט יחיד העתקת ה-PGN של הוריאנט מסע @@ -460,7 +460,7 @@ או העלו קובץ PGN מעמדה מסוימת המשיכו מכאן - הפכו ללוח למידה + לוח למידה ייבוא משחק כשמדביקים משחק בפורמט PGN מקבלים אפשרות לצפות במשחק ולדפדף בו, ניתוח ממוחשב, צ׳אט וקישור לשיתוף. וריאציות — כלומר רצפי מהלכים שאינם המסעים הראשיים (mainline) — יימחקו. כדי לשמור אותן, ייבאו את ה־PGN כלוח למידה. diff --git a/translation/dest/site/lb-LU.xml b/translation/dest/site/lb-LU.xml index ef08ad14ff253..cc05128a13d49 100644 --- a/translation/dest/site/lb-LU.xml +++ b/translation/dest/site/lb-LU.xml @@ -70,6 +70,8 @@ Variant opwäerten Haaptvariant maachen Vun hei läschen + Varianten zesummeklappen + Varianten opklappen Variant forcéieren PGN-Variant kopéieren Zuch @@ -688,7 +690,7 @@ zeréck/no fir beweegen bei Start/Schluss goen Kommentarer weisen/verstoppen - Variant wiehlen/verloossen + Variant wielen/verloossen Computeranalys ufroen, léier aus denge Feeler Nächst (Aus dengen Feeler léieren) Nächst Gaffe @@ -845,7 +847,7 @@ Mëttelspill Endspill Bedingt Virauszich - Aktuell Variante bäifügen + Aktuell Variant bäifügen Variant spillen fir bedingt Virauszich ze kreéieren Keng bedingt Virauszich Spill %s diff --git a/translation/dest/site/tl-PH.xml b/translation/dest/site/tl-PH.xml index 147466a351696..bbe901f46bdcf 100644 --- a/translation/dest/site/tl-PH.xml +++ b/translation/dest/site/tl-PH.xml @@ -183,12 +183,16 @@ Palitan ang iyong pangalan Ang laki o liit lang ng mga letra ang pwedeng baguhin. Halimbawa, pwedeng gawing \"JohnDoe\" ang \"johndoe\". Palitan ang iyong pangalan. Maaari mo lang itong gawin ng isang beses at maaari mo lang baguhin ang laki o liit ng mga letra sa pangalan mo. + Tiyaking pumili ng pampamilyang username. Hindi mo ito mababago sa ibang pagkakataon at ang anumang mga account na may hindi naaangkop na mga username ay isasara! + Gagamitin lang namin ito para sa pag-reset ng password. Password Palitan ang password Palitan ang email Email Ibalik ang password Nakalimutan mo ba ang iyong password? + Mangyaring huwag gamitin ang iyong username bilang iyong password. + If everything else fails, then send us this email: Ranggo Ranggo: %s diff --git a/translation/dest/site/zh-CN.xml b/translation/dest/site/zh-CN.xml index e526f1204ed56..e899a5ac84c21 100644 --- a/translation/dest/site/zh-CN.xml +++ b/translation/dest/site/zh-CN.xml @@ -69,6 +69,8 @@ 提升变着 做为主线 从此处开始删除 + 折叠变着 + 展开变着 强制作为变着 复制变着的PGN 着法 diff --git a/translation/dest/study/lb-LU.xml b/translation/dest/study/lb-LU.xml index 7612345016498..0f5599ed3fd12 100644 --- a/translation/dest/study/lb-LU.xml +++ b/translation/dest/study/lb-LU.xml @@ -83,7 +83,7 @@ Ugepinnten Kapitelkommentar Kapitel späicheren Annotatiounen läschen - Variatiounen läschen + Variante läschen Kapitel läschen Kapitel läschen? Et gëtt keen zeréck! All Kommentarer, Symboler an Zeechnungsformen an dësem Kapitel läschen? diff --git a/translation/dest/swiss/ar-SA.xml b/translation/dest/swiss/ar-SA.xml index e606cfa288f51..fbca6610f443f 100644 --- a/translation/dest/swiss/ar-SA.xml +++ b/translation/dest/swiss/ar-SA.xml @@ -1,5 +1,6 @@ + النظام السويسري البطولات السويسرية اعرض الجولة%s @@ -66,6 +67,16 @@ الفاصل الزمني بين المباريات أزواج محظورة أسماء المستخدمين للاعبين الذين يجب ألا يلعبوا معا (على سبيل المثال). اسمان مستخدمان لكل سطر، مفصولان بمسافة. + مزاوجة يدوية في الجولة القادمة + حدد يدويًا جميع عمليات الاقتران للجولة التالية. زوج لاعب واحد لكل سطر. مثال: +اللاعب أ اللاعب ب +اللاعب ج اللاعب د +لإعطاء إقصاء (1 نقطة) للاعب بدلا من زوج، إضافة سطر مثل: +اللاعب 1 +اللاعبين المفقودين سيعدون غائبين ويحصلون على نقطة صفر. +اترك هذا الحقل فارغاً للسماح لليتشيس بإنشاء أزواج تلقائياً. + يجب أن يكونوا قد لعبوا آخر مواجهة لهم بالنظام السويسري + اسمح للاعبين بالانضمام فقط إذا كانوا قد لعبوا آخر مباراة لهم في SWISS. إذا أخفقوا في الظهور في حدث SWISS مؤخرًا، فلن يتمكنوا من الدخول إلى حدثك. يؤدي هذا إلى تجربة SWISS أفضل للاعبين الذين يحضرون فعلًا. بطولة جديدة بالنظام السويسري متى تستخدم البطولا السويسرية عوضاً عن البطولات العادية؟ في نظام البطولات السويسرية، يمكن للمشاركين اللعب ضد أحدهم الآخر مرة واحدة فقط، ويلعب الجميع نفس العدد من المباريات. @@ -141,4 +152,7 @@ السماح فقط للمستخدمين المحددين مسبقاً بالانضمام إذا كانت هذه القائمة غير فارغة، فسيمنع اللاعبون غير الواردة أسماءهم في هذه القائمة من الانضمام إلى البطولة. اسم مستخدم واحد لكل سطر. ألعب مبارياتك + أقاصٍ + الغيابات + كسر التعادل diff --git a/translation/dest/team/ar-SA.xml b/translation/dest/team/ar-SA.xml index be798a3abfa64..496b6571c92b2 100644 --- a/translation/dest/team/ar-SA.xml +++ b/translation/dest/team/ar-SA.xml @@ -76,4 +76,20 @@ عدد القادة لكل فريق. مجموع درجاتهم هو نتيجة الفريق. لا يجب عليك تغيير هذه القيمة بعد بدء البطولة! الفريق الداخلي + + معركة %s فريق + معركة فريق واحد + معركة فريقين + معركة %s أفرقة + معركة %s فريقا + معركة %s فريقا + + + %s قائدا لكل فريق + قائد واحد لكل فريق + قائدين للفريق + %s قادة للفريق الواحد + %s قائد للفريق الواحد + %s قائد للفريق الواحد + diff --git a/translation/dest/ublog/ar-SA.xml b/translation/dest/ublog/ar-SA.xml index f59934b716a79..57c3433a2ffad 100644 --- a/translation/dest/ublog/ar-SA.xml +++ b/translation/dest/ublog/ar-SA.xml @@ -64,4 +64,5 @@ اي شيء غير لائق من الممكن أن يتسبب باغلاق حسابك. نصائحنا البسيطة لكتابة مقالة رائعة ناقش منشور المدونة هذا في المنتدى + تم حظرك من قبل مؤلف المدونة. From 92d00e58a5f378a9c7bd56e2e172ca3e10c71376 Mon Sep 17 00:00:00 2001 From: Thibault Duplessis Date: Thu, 20 Jun 2024 11:20:45 +0200 Subject: [PATCH 163/168] monitor round viewers for 30m after the round stopped syncing --- modules/relay/src/main/RelayStatsApi.scala | 19 ++++++++++++++++--- 1 file changed, 16 insertions(+), 3 deletions(-) diff --git a/modules/relay/src/main/RelayStatsApi.scala b/modules/relay/src/main/RelayStatsApi.scala index e02458ab49fbf..aadfef5ee52f2 100644 --- a/modules/relay/src/main/RelayStatsApi.scala +++ b/modules/relay/src/main/RelayStatsApi.scala @@ -2,6 +2,7 @@ package lila.relay import lila.db.dsl.{ *, given } import reactivemongo.api.bson.BSONInteger +import scalalib.cache.ExpireSetMemo object RelayStats: type Minute = Int @@ -20,7 +21,7 @@ final class RelayStatsApi(roundRepo: RelayRoundRepo, colls: RelayColls)(using sc def get(id: RelayTourId): Fu[List[RoundStats]] = colls.round - .aggregateList(128): framework => + .aggregateList(RelayTour.maxRelays): framework => import framework.* Match($doc("tourId" -> id)) -> List( Sort(Ascending("createdAt")), @@ -74,13 +75,24 @@ final class RelayStatsApi(roundRepo: RelayRoundRepo, colls: RelayColls)(using sc _ <- elements.nonEmpty.so(update.many(elements).void) yield () + // keep monitoring rounds for 30m after they stopped syncing + private val syncTail = ExpireSetMemo[RelayRoundId](30 minutes) + private def fetchRoundCrowds: Fu[List[(RelayRoundId, Crowd)]] = val max = 500 colls.round .aggregateList(maxDocs = max, _.sec): framework => import framework.* - Match($doc("sync.until" -> $exists(true), "crowd".$gt(0))) -> - List(Project($doc("_id" -> 1, "crowd" -> 1))) + Match( + $doc( + $or( + $doc("sync.until" -> $exists(true)), + $inIds(syncTail.keys) + ), + "crowd".$gt(0) + ) + ) -> + List(Project($doc("_id" -> 1, "crowd" -> 1, "syncing" -> "$sync.until"))) .map: docs => if docs.size == max then logger.warn(s"RelayStats.fetchRoundCrowds: $max docs fetched") @@ -88,4 +100,5 @@ final class RelayStatsApi(roundRepo: RelayRoundRepo, colls: RelayColls)(using sc doc <- docs id <- doc.getAsOpt[RelayRoundId]("_id") crowd <- doc.getAsOpt[Crowd]("crowd") + _ = if doc.contains("syncing") then syncTail.put(id) yield (id, crowd) From 0cea482a0a13de77aa4bdf05d809a2e8ed3f7b94 Mon Sep 17 00:00:00 2001 From: Thibault Duplessis Date: Thu, 20 Jun 2024 11:33:25 +0200 Subject: [PATCH 164/168] also monitor viewers on pushed broadcasts --- modules/relay/src/main/Env.scala | 5 ++--- modules/relay/src/main/RelayPush.scala | 5 +++-- modules/relay/src/main/RelayStatsApi.scala | 12 +++++++----- 3 files changed, 12 insertions(+), 10 deletions(-) diff --git a/modules/relay/src/main/Env.scala b/modules/relay/src/main/Env.scala index c5dbf759d6e33..d63edf02cae0b 100644 --- a/modules/relay/src/main/Env.scala +++ b/modules/relay/src/main/Env.scala @@ -62,6 +62,8 @@ final class Env( lazy val listing: RelayListing = wire[RelayListing] + lazy val stats = wire[RelayStatsApi] + lazy val api: RelayApi = wire[RelayApi] lazy val tourStream: RelayTourStream = wire[RelayTourStream] @@ -90,9 +92,6 @@ final class Env( private lazy val delay = wire[RelayDelay] - // must instanciate eagerly to start the scheduler - val stats = wire[RelayStatsApi] - import SettingStore.CredentialsOption.given val proxyCredentials = settingStore[Option[Credentials]]( "relayProxyCredentials", diff --git a/modules/relay/src/main/RelayPush.scala b/modules/relay/src/main/RelayPush.scala index ce7dd9bab627c..96b45d85c5b75 100644 --- a/modules/relay/src/main/RelayPush.scala +++ b/modules/relay/src/main/RelayPush.scala @@ -4,15 +4,15 @@ import akka.actor.* import akka.pattern.after import chess.format.pgn.{ Parser, PgnStr, San, Std, Tags } import chess.{ ErrorStr, Game, Replay, Square } - import scala.concurrent.duration.* - import scalalib.actor.AsyncActorSequencers + import lila.study.{ MultiPgn, StudyPgnImport } final class RelayPush( sync: RelaySync, api: RelayApi, + stats: RelayStatsApi, irc: lila.core.irc.IrcApi )(using ActorSystem, Executor, Scheduler): @@ -50,6 +50,7 @@ final class RelayPush( .flatMap: event => if !rt.round.hasStarted && !rt.tour.official && event.hasMoves then irc.broadcastStart(rt.round.id, rt.fullName) + stats.setActive(rt.round.id) api .update(rt.round): r1 => val r2 = r1.withSync(_.addLog(event)) diff --git a/modules/relay/src/main/RelayStatsApi.scala b/modules/relay/src/main/RelayStatsApi.scala index aadfef5ee52f2..42fdd86a7eaef 100644 --- a/modules/relay/src/main/RelayStatsApi.scala +++ b/modules/relay/src/main/RelayStatsApi.scala @@ -46,6 +46,11 @@ final class RelayStatsApi(roundRepo: RelayRoundRepo, colls: RelayColls)(using sc .toList yield RoundStats(round, stats) + def setActive(id: RelayRoundId) = activeRounds.put(id) + + // keep monitoring rounds for 30m after they stopped syncing + private val activeRounds = ExpireSetMemo[RelayRoundId](30 minutes) + private def record(): Funit = for crowds <- fetchRoundCrowds nowMinutes = nowSeconds / 60 @@ -75,9 +80,6 @@ final class RelayStatsApi(roundRepo: RelayRoundRepo, colls: RelayColls)(using sc _ <- elements.nonEmpty.so(update.many(elements).void) yield () - // keep monitoring rounds for 30m after they stopped syncing - private val syncTail = ExpireSetMemo[RelayRoundId](30 minutes) - private def fetchRoundCrowds: Fu[List[(RelayRoundId, Crowd)]] = val max = 500 colls.round @@ -87,7 +89,7 @@ final class RelayStatsApi(roundRepo: RelayRoundRepo, colls: RelayColls)(using sc $doc( $or( $doc("sync.until" -> $exists(true)), - $inIds(syncTail.keys) + $inIds(activeRounds.keys) ), "crowd".$gt(0) ) @@ -100,5 +102,5 @@ final class RelayStatsApi(roundRepo: RelayRoundRepo, colls: RelayColls)(using sc doc <- docs id <- doc.getAsOpt[RelayRoundId]("_id") crowd <- doc.getAsOpt[Crowd]("crowd") - _ = if doc.contains("syncing") then syncTail.put(id) + _ = if doc.contains("syncing") then activeRounds.put(id) yield (id, crowd) From 41c3bee552b4a0be39607d81dc4f289e320366a3 Mon Sep 17 00:00:00 2001 From: Thibault Duplessis Date: Thu, 20 Jun 2024 13:25:33 +0200 Subject: [PATCH 165/168] improve logging --- modules/security/src/main/EmailChange.scala | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/modules/security/src/main/EmailChange.scala b/modules/security/src/main/EmailChange.scala index 910345216ad88..dd0385e9c6a28 100644 --- a/modules/security/src/main/EmailChange.scala +++ b/modules/security/src/main/EmailChange.scala @@ -55,7 +55,7 @@ ${trans.common_orPaste.txt()} _ <- userRepo.setEmail(userId, email).recoverDefault me <- userRepo.me(userId) yield - logger.info(s"Set email for $id: $email") + logger.info(s"Change email for $userId: $previous -> $email") me.map(_ -> previous) } From 53a163889419e4abbeb52790e269c672ad5a8299 Mon Sep 17 00:00:00 2001 From: Thibault Duplessis Date: Thu, 20 Jun 2024 13:25:48 +0200 Subject: [PATCH 166/168] improve puzzle visual feedback --- ui/puzzle/src/autoShape.ts | 12 +++++++++--- ui/puzzle/src/ctrl.ts | 3 ++- 2 files changed, 11 insertions(+), 4 deletions(-) diff --git a/ui/puzzle/src/autoShape.ts b/ui/puzzle/src/autoShape.ts index 66f9fa129fcc1..103ec70df66fb 100644 --- a/ui/puzzle/src/autoShape.ts +++ b/ui/puzzle/src/autoShape.ts @@ -7,6 +7,7 @@ import { NormalMove } from 'chessops/types'; interface Opts { node: Tree.Node; + nodeList: Tree.Node[]; showComputer(): boolean; ceval: CevalCtrl; ground: CgApi; @@ -71,8 +72,14 @@ export default function (opts: Opts): DrawShape[] { }); } else shapes = shapes.concat(makeAutoShapesFromUci(opposite(color), n.threat.pvs[0].moves[0], 'red')); } + const feedback = feedbackAnnotation(n, opts.nodeList[opts.nodeList.length - 2]); + return shapes.concat(annotationShapes(n)).concat(feedback ? annotationShapes(feedback) : []); +} + +function feedbackAnnotation(n: Tree.Node, prev?: Tree.Node): Tree.Node | undefined { let glyph: Tree.Glyph | undefined; - switch (n.puzzle) { + const node = n.puzzle ? n : prev?.puzzle ? prev : undefined; + switch (node?.puzzle) { case 'good': case 'win': glyph = { id: 7, name: 'good', symbol: '✓' }; @@ -80,6 +87,5 @@ export default function (opts: Opts): DrawShape[] { case 'fail': glyph = { id: 4, name: 'fail', symbol: '✗' }; } - const withPuzzleGlyphs = glyph ? { ...n, glyphs: [glyph] } : n; - return shapes.concat(annotationShapes(withPuzzleGlyphs)); + return node && glyph && { ...node, glyphs: [glyph] }; } diff --git a/ui/puzzle/src/ctrl.ts b/ui/puzzle/src/ctrl.ts index 01d7ecfef6d9b..1c27eef938e33 100755 --- a/ui/puzzle/src/ctrl.ts +++ b/ui/puzzle/src/ctrl.ts @@ -321,6 +321,7 @@ export default class PuzzleCtrl implements ParentCtrl { this.withGround(g => g.playPremove()); const progress = moveTest(this); + this.setAutoShapes(); if (progress === 'fail') site.sound.say('incorrect'); if (progress) this.applyProgress(progress); this.reorderChildren(path); @@ -349,7 +350,7 @@ export default class PuzzleCtrl implements ParentCtrl { revertUserMove = (): void => { if (site.blindMode) this.instantRevertUserMove(); - else setTimeout(this.instantRevertUserMove, 100); + else setTimeout(this.instantRevertUserMove, 300); }; applyProgress = (progress: undefined | 'fail' | 'win' | MoveTest): void => { From 03216e00044b3b69fa30b6152c6af241ff8dd316 Mon Sep 17 00:00:00 2001 From: Thibault Duplessis Date: Thu, 20 Jun 2024 16:58:40 +0200 Subject: [PATCH 167/168] eagerly instanciate the challenge socket to make mobile local dev more predictible --- modules/challenge/src/main/Env.scala | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/modules/challenge/src/main/Env.scala b/modules/challenge/src/main/Env.scala index 491cfbf4cb33e..40275ecb1962a 100644 --- a/modules/challenge/src/main/Env.scala +++ b/modules/challenge/src/main/Env.scala @@ -50,7 +50,7 @@ final class Env( lazy val api = wire[ChallengeApi] - private lazy val socket = wire[ChallengeSocket] + private val socket = wire[ChallengeSocket] lazy val granter = wire[ChallengeGranter] From b58a6dab716a8fb2be8a7bdc7e15252574732fec Mon Sep 17 00:00:00 2001 From: Thibault Duplessis Date: Thu, 20 Jun 2024 17:14:20 +0200 Subject: [PATCH 168/168] serve different flavours of challenge to website, lichobile, and API/mobile --- app/controllers/Challenge.scala | 31 ++++++++++++++--------- modules/challenge/src/main/JsonView.scala | 19 +++++++++++--- 2 files changed, 35 insertions(+), 15 deletions(-) diff --git a/app/controllers/Challenge.scala b/app/controllers/Challenge.scala index 04adf129889d5..4c4e8fffbcee3 100644 --- a/app/controllers/Challenge.scala +++ b/app/controllers/Challenge.scala @@ -46,11 +46,11 @@ final class Challenge( else if isForMe(c) then Direction.In.some else none direction.so: dir => - val json = env.challenge.jsonView(dir.some)(c) for fullId <- c.accepted.so(env.round.proxyRepo.game(c.gameId).map2(c.fullIdOf(_, dir))) socketVersion <- ctx.isMobileOauth.so(env.challenge.version(c.id).dmap(some)) - yield JsonOk(json.add("fullId", fullId).add("socketVersion", socketVersion)) + json = env.challenge.jsonView.apiAndMobile(c, socketVersion, dir.some, fullId) + yield JsonOk(json) } protected[controllers] def showId(id: ChallengeId)(using Context): Fu[Result] = @@ -69,7 +69,7 @@ final class Challenge( if mine then Direction.Out.some else if isForMe(c) then Direction.In.some else none - val json = env.challenge.jsonView.show(c, version, direction) + val json = env.challenge.jsonView.websiteAndLichobile(c, version, direction) negotiate( html = val color = get("color").flatMap(Color.fromName) @@ -310,15 +310,22 @@ final class Challenge( JsonBadRequest: jsonError(lila.challenge.ChallengeDenied.translated(denied)) case _ => - env.challenge.api.create(challenge).map { + env.challenge.api.create(challenge).flatMap { if _ then - val json = env.challenge.jsonView - .show(challenge, SocketVersion(0), lila.challenge.Direction.Out.some) - if config.keepAliveStream then - jsOptToNdJson: - ndJson.addKeepAlive(env.challenge.keepAliveStream(challenge, json)) - else JsonOk(json) - else JsonBadRequest(jsonError("Challenge not created")) + ctx.isMobileOauth + .so(env.challenge.version(challenge.id).dmap(some)) + .map: socketVersion => + val json = env.challenge.jsonView + .apiAndMobile( + challenge, + socketVersion, + lila.challenge.Direction.Out.some + ) + if config.keepAliveStream then + jsOptToNdJson: + ndJson.addKeepAlive(env.challenge.keepAliveStream(challenge, json)) + else JsonOk(json) + else JsonBadRequest(jsonError("Challenge not created")).toFuccess } yield res } @@ -358,7 +365,7 @@ final class Challenge( .map: challenge => JsonOk: val url = s"${env.net.baseUrl}/${challenge.id}" - env.challenge.jsonView.show(challenge, SocketVersion(0), none) ++ Json.obj( + env.challenge.jsonView.apiAndMobile(challenge, none, none) ++ Json.obj( "urlWhite" -> s"$url?color=white", "urlBlack" -> s"$url?color=black" ) diff --git a/modules/challenge/src/main/JsonView.scala b/modules/challenge/src/main/JsonView.scala index 18725936bc22a..827a8dfdf6b28 100644 --- a/modules/challenge/src/main/JsonView.scala +++ b/modules/challenge/src/main/JsonView.scala @@ -10,6 +10,7 @@ import lila.game.JsonView.given import lila.core.i18n.I18nKey as trans import lila.core.socket.{ SocketVersion, userLag } import lila.core.i18n.{ Translate, JsDump } +import lila.core.id.GameFullId final class JsonView( baseUrl: lila.core.config.BaseUrl, @@ -45,14 +46,26 @@ final class JsonView( r.key -> JsString(r.trans.txt())) ) - def show(challenge: Challenge, socketVersion: SocketVersion, direction: Option[Direction])(using - Translate - ) = + def websiteAndLichobile( + challenge: Challenge, + socketVersion: SocketVersion, + direction: Option[Direction] + )(using Translate) = Json.obj( "challenge" -> apply(direction)(challenge), "socketVersion" -> socketVersion ) + def apiAndMobile( + challenge: Challenge, + socketVersion: Option[SocketVersion], + direction: Option[Direction], + fullId: Option[GameFullId] = none + )(using Translate) = + apply(direction)(challenge) + .add("socketVersion" -> socketVersion) + .add("fullId" -> fullId) + private given OWrites[Challenge.Open] = Json.writes def apply(direction: Option[Direction])(c: Challenge)(using Translate): JsObject =