From e459570480e433da1cc1430f8b74d59990a63304 Mon Sep 17 00:00:00 2001 From: Andras Toth <4157749+tothandras@users.noreply.github.com> Date: Wed, 13 May 2026 13:27:42 +0200 Subject: [PATCH 1/2] feat(api): add accounting periods to spec --- .../packages/aip/src/accounting/index.tsp | 2 + .../aip/src/accounting/operations.tsp | 162 ++ .../packages/aip/src/accounting/period.tsp | 121 ++ api/spec/packages/aip/src/konnect.tsp | 10 + api/spec/packages/aip/src/openmeter.tsp | 10 + api/spec/packages/aip/src/shared/consts.tsp | 3 + api/v3/api.gen.go | 1619 ++++++++++------- api/v3/openapi.yaml | 353 ++++ api/v3/server/routes.go | 14 + 9 files changed, 1650 insertions(+), 644 deletions(-) create mode 100644 api/spec/packages/aip/src/accounting/index.tsp create mode 100644 api/spec/packages/aip/src/accounting/operations.tsp create mode 100644 api/spec/packages/aip/src/accounting/period.tsp diff --git a/api/spec/packages/aip/src/accounting/index.tsp b/api/spec/packages/aip/src/accounting/index.tsp new file mode 100644 index 0000000000..a76e7b65cc --- /dev/null +++ b/api/spec/packages/aip/src/accounting/index.tsp @@ -0,0 +1,2 @@ +import "./period.tsp"; +import "./operations.tsp"; diff --git a/api/spec/packages/aip/src/accounting/operations.tsp b/api/spec/packages/aip/src/accounting/operations.tsp new file mode 100644 index 0000000000..96fa662cbf --- /dev/null +++ b/api/spec/packages/aip/src/accounting/operations.tsp @@ -0,0 +1,162 @@ +import "@typespec/http"; +import "@typespec/rest"; +import "@typespec/openapi"; +import "@typespec/openapi3"; +import "../common/error.tsp"; +import "../common/pagination.tsp"; +import "../common/parameters.tsp"; +import "../common/properties.tsp"; +import "../shared/index.tsp"; +import "./period.tsp"; + +using TypeSpec.Http; +using TypeSpec.OpenAPI; + +namespace Accounting; + +/** + * Filter options for listing accounting periods. + */ +@friendlyName("ListAccountingPeriodsParamsFilter") +model ListAccountingPeriodsParamsFilter { + /** + * Filter periods by lifecycle status. Use `filter[status][oeq]=open,closing` to + * fetch the currently-active periods. + */ + #suppress "@openmeter/api-spec-aip/doc-decorator" "filter field" + status?: Common.StringFieldFilterExact; + + /** + * Filter periods by `start_at`. + */ + #suppress "@openmeter/api-spec-aip/doc-decorator" "filter field" + start_at?: Common.DateTimeFieldFilter; + + /** + * Filter periods by `end_at`. Open periods (no `end_at`) are excluded when this + * filter is applied. + */ + #suppress "@openmeter/api-spec-aip/doc-decorator" "filter field" + end_at?: Common.DateTimeFieldFilter; + + /** + * Filter periods by labels. + */ + #suppress "@openmeter/api-spec-aip/doc-decorator" "filter field" + labels?: Common.LabelsFieldFilter; +} + +/** + * Request body for initiating a close on the currently-open accounting period. + */ +@friendlyName("CloseAccountingPeriodRequest") +@summary("Close accounting period request") +model CloseAccountingPeriodRequest { + /** + * The intended end of the period being closed (exclusive). Must be strictly + * greater than the open period's `start_at` and not in the future. + * + * Becomes the closing period's `end_at` and the newly-opened next period's + * `start_at`. + */ + @summary("End of period") + end_at: Shared.DateTime; + + /** + * Optional labels applied to the closing period. + */ + @summary("Labels") + labels?: Common.Labels; + + /** + * Optional display name for the period (e.g. "2026-Q2"). Auto-generated if + * omitted. + */ + @summary("Name") + @minLength(1) + @maxLength(256) + name?: string; + + /** + * Optional description. + */ + @summary("Description") + @maxLength(1024) + description?: string; +} + +interface AccountingPeriodsOperations { + /** + * Close the currently-open accounting period. + * + * Atomically, under a namespace-period advisory lock: + * + * 1. Freezes membership on the currently-open period `P`: sets `P.end_at`, + * transitions `P.status` to `closing`, and records `P.closing_started_at`. + * 2. Opens a new period `N` with `N.start_at = P.end_at` and `N.status = open`. + * + * The transition `closing → closed` (balance snapshot computation, close-time + * validations, and seal hash commit) is performed by the close pipeline; poll + * `GET .../{periodId}` to observe the final `closed` state, `closed_at`, + * `sealed_at`, and seal fields. + * + * Late-arriving transactions whose `booked_at` falls inside the now-closed period + * are posted to `N` with an `adjusts_period_id` backpointer to `P`; they do not + * modify `P`. + * + * Returns the period transitioned to `closing`. The newly-opened next period can + * be retrieved by listing with `filter[status]=open`. + */ + @extension(Shared.UnstableExtension, true) + @extension(Shared.InternalExtension, true) + @post + @route("/close") + @operationId("close-accounting-period") + @summary("Close the open accounting period") + close( + @body body: CloseAccountingPeriodRequest, + ): Shared.CreateResponse | Common.ErrorResponses; + + /** + * Get an accounting period by id. + */ + @extension(Shared.UnstableExtension, true) + @extension(Shared.InternalExtension, true) + @get + @operationId("get-accounting-period") + @summary("Get an accounting period") + get( + @path periodId: Shared.ULID, + ): Shared.GetResponse | Common.NotFound | Common.ErrorResponses; + + /** + * List accounting periods. + * + * Returns the namespace's periods in reverse-chronological order by `start_at` by + * default (most recent first). + */ + @extension(Shared.UnstableExtension, true) + @extension(Shared.InternalExtension, true) + @get + @operationId("list-accounting-periods") + @summary("List accounting periods") + list( + ...Common.PagePaginationQuery, + + /** + * Sort periods returned in the response. Supported sort attributes are: + * + * - `start_at` (default, descending) + * - `created_at` + * - `id` + */ + @query(#{ name: "sort" }) + sort?: Common.SortQuery, + + /** + * Filter periods returned in the response. + */ + @query(#{ style: "deepObject", explode: true }) + filter?: ListAccountingPeriodsParamsFilter, + ): Shared.PagePaginatedResponse | Common.ErrorResponses; +} diff --git a/api/spec/packages/aip/src/accounting/period.tsp b/api/spec/packages/aip/src/accounting/period.tsp new file mode 100644 index 0000000000..8cfa7bac7a --- /dev/null +++ b/api/spec/packages/aip/src/accounting/period.tsp @@ -0,0 +1,121 @@ +import "../shared/index.tsp"; + +namespace Accounting; + +/** + * Lifecycle status of an accounting period. + * + * - `open`: the current posting bucket. New transactions can be posted to this + * period. Exactly one period per namespace is `open` at any time. + * - `closing`: membership is frozen — no new transactions can post to this period + * — but balance snapshots and the seal have not yet been committed. At most one + * period per namespace is `closing` at any time. + * - `closed`: the period is sealed. `closed_at`, `sealed_at`, and (when sealing is + * enabled) `seal_hash` are set. Transaction membership and the closing balance + * snapshots are immutable. + */ +@friendlyName("AccountingPeriodStatus") +@summary("Accounting period status") +enum AccountingPeriodStatus { + // The current posting bucket for new transactions. + Open: "open", + + // Membership is frozen but the seal has not yet been committed. + Closing: "closing", + + // The period is sealed and immutable. + Closed: "closed", +} + +/** + * An accounting period is a sequential, non-overlapping window of ledger activity + * within a namespace. Closing a period freezes its transaction membership and + * (eventually) seals an authoritative closing balance. + * + * Late-arriving transactions whose `booked_at` falls inside an already-closed + * period are posted to the current open period with an `adjusts_period_id` + * backpointer; they do not mutate the closed period. + */ +@friendlyName("AccountingPeriod") +@summary("Accounting period") +model AccountingPeriod { + ...Shared.ResourceImmutable; + + /** + * Start of the period (inclusive). + * + * For the first period in a namespace this is the namespace creation time. For + * every subsequent period, equals the previous period's `end_at`. Immutable once + * set. + */ + @visibility(Lifecycle.Read) + @summary("Start of period") + start_at: Shared.DateTime; + + /** + * End of the period (exclusive). + * + * Unset while the period is `open`. Fixed at the moment a close is initiated, and + * immutable thereafter. + */ + @visibility(Lifecycle.Read) + @summary("End of period") + end_at?: Shared.DateTime; + + /** + * Current lifecycle status of the period. + */ + @visibility(Lifecycle.Read) + @summary("Status") + status: AccountingPeriodStatus; + + /** + * Timestamp when the close was initiated (open → closing transition). Set on + * `closing` and `closed` periods. + */ + @visibility(Lifecycle.Read) + @summary("Closing started at") + closing_started_at?: Shared.DateTime; + + /** + * Timestamp when the period was marked `closed` (closing → closed transition). Set + * only on `closed` periods. + */ + @visibility(Lifecycle.Read) + @summary("Closed at") + closed_at?: Shared.DateTime; + + /** + * Timestamp when the seal hash was committed. Set only on `closed` periods that + * have a seal hash. + */ + @visibility(Lifecycle.Read) + @summary("Sealed at") + sealed_at?: Shared.DateTime; + + /** + * Cryptographic hash sealing the period. The hash covers the period's frozen + * transaction membership and closing balance snapshots in a deterministic, + * versioned input format described by `seal_algorithm` and `seal_input_version`. + * + * Set only on `closed` periods that have been sealed. + */ + @visibility(Lifecycle.Read) + @summary("Seal hash") + seal_hash?: string; + + /** + * Algorithm used to compute `seal_hash`. Example: `"sha256"`. + */ + @visibility(Lifecycle.Read) + @summary("Seal algorithm") + seal_algorithm?: string; + + /** + * Version of the seal input format. Versioning the input format lets verifiers + * reproduce a historical seal even after the format evolves. + */ + @visibility(Lifecycle.Read) + @summary("Seal input version") + seal_input_version?: string; +} diff --git a/api/spec/packages/aip/src/konnect.tsp b/api/spec/packages/aip/src/konnect.tsp index 4278bc14c8..a5bddd2f01 100644 --- a/api/spec/packages/aip/src/konnect.tsp +++ b/api/spec/packages/aip/src/konnect.tsp @@ -14,6 +14,7 @@ import "./billing/index.tsp"; import "./tax/index.tsp"; import "./defaults/index.tsp"; import "./governance/index.tsp"; +import "./accounting/index.tsp"; using TypeSpec.Http; using TypeSpec.OpenAPI; @@ -59,6 +60,10 @@ using TypeSpec.OpenAPI; Shared.GovernanceTag, #{ description: Shared.GovernanceDescription } ) +@tagMetadata( + Shared.AccountingTag, + #{ description: Shared.AccountingDescription } +) @useAuth(systemAccountAccessToken | personalAccessToken | konnectAccessToken) namespace MeteringAndBilling; @@ -197,6 +202,11 @@ interface OrganizationDefaultTaxCodesEndpoints @tag(Shared.GovernanceTag) interface GovernanceEndpoints extends Governance.GovernanceOperations {} +@route("/openmeter/accounting/periods") +@tag(Shared.AccountingTag) +interface AccountingPeriodsEndpoints + extends Accounting.AccountingPeriodsOperations {} + /** * The system account access token is meant for automations and integrations that * are not directly associated with a human identity. diff --git a/api/spec/packages/aip/src/openmeter.tsp b/api/spec/packages/aip/src/openmeter.tsp index c17b5df874..18c58febf3 100644 --- a/api/spec/packages/aip/src/openmeter.tsp +++ b/api/spec/packages/aip/src/openmeter.tsp @@ -15,6 +15,7 @@ import "./llmcost/index.tsp"; import "./productcatalog/index.tsp"; import "./defaults/index.tsp"; import "./governance/index.tsp"; +import "./accounting/index.tsp"; using TypeSpec.Http; using TypeSpec.OpenAPI; @@ -65,6 +66,10 @@ using TypeSpec.OpenAPI; Shared.GovernanceTag, #{ description: Shared.GovernanceDescription } ) +@tagMetadata( + Shared.AccountingTag, + #{ description: Shared.AccountingDescription } +) namespace OpenMeter; @route("/openmeter/events") @@ -201,3 +206,8 @@ interface OrganizationDefaultTaxCodesEndpoints @route("/openmeter/governance") @tag(Shared.GovernanceTag) interface GovernanceEndpoints extends Governance.GovernanceOperations {} + +@route("/openmeter/accounting/periods") +@tag(Shared.AccountingTag) +interface AccountingPeriodsEndpoints + extends Accounting.AccountingPeriodsOperations {} diff --git a/api/spec/packages/aip/src/shared/consts.tsp b/api/spec/packages/aip/src/shared/consts.tsp index 76668969e7..821bb015d1 100644 --- a/api/spec/packages/aip/src/shared/consts.tsp +++ b/api/spec/packages/aip/src/shared/consts.tsp @@ -42,6 +42,9 @@ const DefaultsDescription = "Organization-level default configuration."; const GovernanceTag = "OpenMeter Governance"; const GovernanceDescription = "Governance evaluation of customers to check their feature access."; +const AccountingTag = "OpenMeter Accounting"; +const AccountingDescription = "Accounting manages the accounting periods, transactions, and revenue recognition."; + // The functionality should be considered unstable. const UnstableExtension = "x-unstable"; // The functionality is internal and should not be used by customers. diff --git a/api/v3/api.gen.go b/api/v3/api.gen.go index a51baf9a83..bcf18fa95e 100644 --- a/api/v3/api.gen.go +++ b/api/v3/api.gen.go @@ -23,6 +23,27 @@ import ( "github.com/openmeterio/openmeter/api/v3/filters" ) +// Defines values for AccountingPeriodStatus. +const ( + AccountingPeriodStatusClosed AccountingPeriodStatus = "closed" + AccountingPeriodStatusClosing AccountingPeriodStatus = "closing" + AccountingPeriodStatusOpen AccountingPeriodStatus = "open" +) + +// Valid indicates whether the value is a known member of the AccountingPeriodStatus enum. +func (e AccountingPeriodStatus) Valid() bool { + switch e { + case AccountingPeriodStatusClosed: + return true + case AccountingPeriodStatusClosing: + return true + case AccountingPeriodStatusOpen: + return true + default: + return false + } +} + // Defines values for AddonInstanceType. const ( AddonInstanceTypeMultiple AddonInstanceType = "multiple" @@ -1199,6 +1220,96 @@ func (e ResourceManagedBy) Valid() bool { } } +// AccountingPeriod An accounting period is a sequential, non-overlapping window of ledger activity +// within a namespace. Closing a period freezes its transaction membership and +// (eventually) seals an authoritative closing balance. +// +// Late-arriving transactions whose `booked_at` falls inside an already-closed +// period are posted to the current open period with an `adjusts_period_id` +// backpointer; they do not mutate the closed period. +type AccountingPeriod struct { + // ClosedAt Timestamp when the period was marked `closed` (closing → closed transition). Set + // only on `closed` periods. + ClosedAt *DateTime `json:"closed_at,omitempty"` + + // ClosingStartedAt Timestamp when the close was initiated (open → closing transition). Set on + // `closing` and `closed` periods. + ClosingStartedAt *DateTime `json:"closing_started_at,omitempty"` + + // CreatedAt An ISO-8601 timestamp representation of entity creation date. + CreatedAt DateTime `json:"created_at"` + + // Description Optional description of the resource. + // + // Maximum 1024 characters. + Description *string `json:"description,omitempty"` + + // EndAt End of the period (exclusive). + // + // Unset while the period is `open`. Fixed at the moment a close is initiated, and + // immutable thereafter. + EndAt *DateTime `json:"end_at,omitempty"` + Id ULID `json:"id"` + + // Labels Labels store metadata of an entity that can be used for filtering an entity list or for searching across entity types. + // + // Keys must be of length 1-63 characters, and cannot start with "kong", "konnect", "mesh", "kic", or "_". + Labels *Labels `json:"labels,omitempty"` + + // Name Display name of the resource. + // + // Between 1 and 256 characters. + Name string `json:"name"` + + // SealAlgorithm Algorithm used to compute `seal_hash`. Example: `"sha256"`. + SealAlgorithm *string `json:"seal_algorithm,omitempty"` + + // SealHash Cryptographic hash sealing the period. The hash covers the period's frozen + // transaction membership and closing balance snapshots in a deterministic, + // versioned input format described by `seal_algorithm` and `seal_input_version`. + // + // Set only on `closed` periods that have been sealed. + SealHash *string `json:"seal_hash,omitempty"` + + // SealInputVersion Version of the seal input format. Versioning the input format lets verifiers + // reproduce a historical seal even after the format evolves. + SealInputVersion *string `json:"seal_input_version,omitempty"` + + // SealedAt Timestamp when the seal hash was committed. Set only on `closed` periods that + // have a seal hash. + SealedAt *DateTime `json:"sealed_at,omitempty"` + + // StartAt Start of the period (inclusive). + // + // For the first period in a namespace this is the namespace creation time. For + // every subsequent period, equals the previous period's `end_at`. Immutable once + // set. + StartAt DateTime `json:"start_at"` + + // Status Current lifecycle status of the period. + Status AccountingPeriodStatus `json:"status"` +} + +// AccountingPeriodPagePaginatedResponse Page paginated response. +type AccountingPeriodPagePaginatedResponse struct { + Data []AccountingPeriod `json:"data"` + + // Meta returns the pagination information + Meta PaginatedMeta `json:"meta"` +} + +// AccountingPeriodStatus Lifecycle status of an accounting period. +// +// - `open`: the current posting bucket. New transactions can be posted to this +// period. Exactly one period per namespace is `open` at any time. +// - `closing`: membership is frozen — no new transactions can post to this period +// — but balance snapshots and the seal have not yet been committed. At most one +// period per namespace is `closing` at any time. +// - `closed`: the period is sealed. `closed_at`, `sealed_at`, and (when sealing is +// enabled) `seal_hash` are set. Transaction membership and the closing balance +// snapshots are immutable. +type AccountingPeriodStatus string + // Addon Add-on allows extending subscriptions with compatible plans with additional // ratecards. type Addon struct { @@ -3562,6 +3673,26 @@ type ChargePagePaginatedResponse struct { Meta PaginatedMeta `json:"meta"` } +// CloseAccountingPeriodRequest Request body for initiating a close on the currently-open accounting period. +type CloseAccountingPeriodRequest struct { + // Description Optional description. + Description *string `json:"description,omitempty"` + + // EndAt The intended end of the period being closed (exclusive). Must be strictly + // greater than the open period's `start_at` and not in the future. + // + // Becomes the closing period's `end_at` and the newly-opened next period's + // `start_at`. + EndAt DateTime `json:"end_at"` + + // Labels Optional labels applied to the closing period. + Labels *Labels `json:"labels,omitempty"` + + // Name Optional display name for the period (e.g. "2026-Q2"). Auto-generated if + // omitted. + Name *string `json:"name,omitempty"` +} + // ClosedPeriod A period with defined start and end dates. // // The period is always inclusive at the start and exclusive at the end. @@ -4527,6 +4658,31 @@ type LLMCostProvider struct { // Keys must be of length 1-63 characters, and cannot start with "kong", "konnect", "mesh", "kic", or "_". type Labels map[string]string +// LabelsFieldFilter Filters on the resource's `labels` field. +// +// The schema is a map keyed by the label name; each value is a +// `StringFieldFilter`. Both deepObject forms are accepted: +// `filter[labels][key]=value` (nested) and `filter[labels.key]=value` +// (dot-notation). +type LabelsFieldFilter = filters.FilterLabels + +// ListAccountingPeriodsParamsFilter Filter options for listing accounting periods. +type ListAccountingPeriodsParamsFilter struct { + // EndAt Filter periods by `end_at`. Open periods (no `end_at`) are excluded when this + // filter is applied. + EndAt *DateTimeFieldFilter `json:"end_at,omitempty"` + + // Labels Filter periods by labels. + Labels *LabelsFieldFilter `json:"labels,omitempty"` + + // StartAt Filter periods by `start_at`. + StartAt *DateTimeFieldFilter `json:"start_at,omitempty"` + + // Status Filter periods by lifecycle status. Use `filter[status][oeq]=open,closing` to + // fetch the currently-active periods. + Status *StringFieldFilterExact `json:"status,omitempty"` +} + // ListAddonsParamsFilter Filter options for listing add-ons. type ListAddonsParamsFilter struct { // Currency Filters on the given string field value by exact match. All properties are @@ -5512,6 +5668,22 @@ type NotFound = NotFoundError // Unauthorized defines model for Unauthorized. type Unauthorized = UnauthorizedError +// ListAccountingPeriodsParams defines parameters for ListAccountingPeriods. +type ListAccountingPeriodsParams struct { + // Page Determines which page of the collection to retrieve. + Page *PagePaginationQuery `json:"page,omitempty"` + + // Sort Sort periods returned in the response. Supported sort attributes are: + // + // - `start_at` (default, descending) + // - `created_at` + // - `id` + Sort *SortQuery `form:"sort,omitempty" json:"sort,omitempty"` + + // Filter Filter periods returned in the response. + Filter *ListAccountingPeriodsParamsFilter `json:"filter,omitempty"` +} + // ListAddonsParams defines parameters for ListAddons. type ListAddonsParams struct { // Page Determines which page of the collection to retrieve. @@ -5818,6 +5990,9 @@ type ListTaxCodesParams struct { IncludeDeleted *bool `form:"include_deleted,omitempty" json:"include_deleted,omitempty"` } +// CloseAccountingPeriodJSONRequestBody defines body for CloseAccountingPeriod for application/json ContentType. +type CloseAccountingPeriodJSONRequestBody = CloseAccountingPeriodRequest + // CreateAddonJSONRequestBody defines body for CreateAddon for application/json ContentType. type CreateAddonJSONRequestBody = CreateAddonRequest @@ -6873,6 +7048,15 @@ func (t *InvalidParameters_Item) UnmarshalJSON(b []byte) error { // ServerInterface represents all server handlers. type ServerInterface interface { + // List accounting periods + // (GET /openmeter/accounting/periods) + ListAccountingPeriods(w http.ResponseWriter, r *http.Request, params ListAccountingPeriodsParams) + // Close the open accounting period + // (POST /openmeter/accounting/periods/close) + CloseAccountingPeriod(w http.ResponseWriter, r *http.Request) + // Get an accounting period + // (GET /openmeter/accounting/periods/{periodId}) + GetAccountingPeriod(w http.ResponseWriter, r *http.Request, periodId ULID) // List add-ons // (GET /openmeter/addons) ListAddons(w http.ResponseWriter, r *http.Request, params ListAddonsParams) @@ -7128,6 +7312,24 @@ type ServerInterface interface { type Unimplemented struct{} +// List accounting periods +// (GET /openmeter/accounting/periods) +func (_ Unimplemented) ListAccountingPeriods(w http.ResponseWriter, r *http.Request, params ListAccountingPeriodsParams) { + w.WriteHeader(http.StatusNotImplemented) +} + +// Close the open accounting period +// (POST /openmeter/accounting/periods/close) +func (_ Unimplemented) CloseAccountingPeriod(w http.ResponseWriter, r *http.Request) { + w.WriteHeader(http.StatusNotImplemented) +} + +// Get an accounting period +// (GET /openmeter/accounting/periods/{periodId}) +func (_ Unimplemented) GetAccountingPeriod(w http.ResponseWriter, r *http.Request, periodId ULID) { + w.WriteHeader(http.StatusNotImplemented) +} + // List add-ons // (GET /openmeter/addons) func (_ Unimplemented) ListAddons(w http.ResponseWriter, r *http.Request, params ListAddonsParams) { @@ -7635,6 +7837,88 @@ type ServerInterfaceWrapper struct { type MiddlewareFunc func(http.Handler) http.Handler +// ListAccountingPeriods operation middleware +func (siw *ServerInterfaceWrapper) ListAccountingPeriods(w http.ResponseWriter, r *http.Request) { + + var err error + + // Parameter object where we will unmarshal all parameters from the context + var params ListAccountingPeriodsParams + + // ------------- Optional query parameter "page" ------------- + + err = runtime.BindQueryParameterWithOptions("deepObject", true, false, "page", r.URL.Query(), ¶ms.Page, runtime.BindQueryParameterOptions{Type: "object", Format: ""}) + if err != nil { + siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "page", Err: err}) + return + } + + // ------------- Optional query parameter "sort" ------------- + + err = runtime.BindQueryParameterWithOptions("form", false, false, "sort", r.URL.Query(), ¶ms.Sort, runtime.BindQueryParameterOptions{Type: "string", Format: ""}) + if err != nil { + siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "sort", Err: err}) + return + } + + // ------------- Optional query parameter "filter" ------------- + + err = filters.Parse(r.URL.Query(), ¶ms.Filter) + if err != nil { + siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "filter", Err: err}) + return + } + + handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + siw.Handler.ListAccountingPeriods(w, r, params) + })) + + for i := len(siw.HandlerMiddlewares) - 1; i >= 0; i-- { + handler = siw.HandlerMiddlewares[i](handler) + } + + handler.ServeHTTP(w, r) +} + +// CloseAccountingPeriod operation middleware +func (siw *ServerInterfaceWrapper) CloseAccountingPeriod(w http.ResponseWriter, r *http.Request) { + + handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + siw.Handler.CloseAccountingPeriod(w, r) + })) + + for i := len(siw.HandlerMiddlewares) - 1; i >= 0; i-- { + handler = siw.HandlerMiddlewares[i](handler) + } + + handler.ServeHTTP(w, r) +} + +// GetAccountingPeriod operation middleware +func (siw *ServerInterfaceWrapper) GetAccountingPeriod(w http.ResponseWriter, r *http.Request) { + + var err error + + // ------------- Path parameter "periodId" ------------- + var periodId ULID + + err = runtime.BindStyledParameterWithOptions("simple", "periodId", chi.URLParam(r, "periodId"), &periodId, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true, Type: "string", Format: ""}) + if err != nil { + siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "periodId", Err: err}) + return + } + + handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + siw.Handler.GetAccountingPeriod(w, r, periodId) + })) + + for i := len(siw.HandlerMiddlewares) - 1; i >= 0; i-- { + handler = siw.HandlerMiddlewares[i](handler) + } + + handler.ServeHTTP(w, r) +} + // ListAddons operation middleware func (siw *ServerInterfaceWrapper) ListAddons(w http.ResponseWriter, r *http.Request) { @@ -10046,6 +10330,15 @@ func HandlerWithOptions(si ServerInterface, options ChiServerOptions) http.Handl ErrorHandlerFunc: options.ErrorHandlerFunc, } + r.Group(func(r chi.Router) { + r.Get(options.BaseURL+"/openmeter/accounting/periods", wrapper.ListAccountingPeriods) + }) + r.Group(func(r chi.Router) { + r.Post(options.BaseURL+"/openmeter/accounting/periods/close", wrapper.CloseAccountingPeriod) + }) + r.Group(func(r chi.Router) { + r.Get(options.BaseURL+"/openmeter/accounting/periods/{periodId}", wrapper.GetAccountingPeriod) + }) r.Group(func(r chi.Router) { r.Get(options.BaseURL+"/openmeter/addons", wrapper.ListAddons) }) @@ -10302,650 +10595,688 @@ func HandlerWithOptions(si ServerInterface, options ChiServerOptions) http.Handl // Base64 encoded, gzipped, json marshaled Swagger object var swaggerSpec = []string{ - "H4sIAAAAAAAC/+y973IbObIv+CoIno5oey9FS/7X3d6YmFDL9ozu2N26lj0T5zS9FFQFkjgqAtUFlCRO", - "hyM27od9gN0P+xL3LfZNzpNsIBNAoapQRRZNue1p37gnpi0WgEQCyEwkMn/52yiRq1wKJrQaPfttxG7p", - "Ks8Y/PdLWVzyNGXiBf7R/O2aZiX8R8o05dno2ejfZUlSSYTUZEmvGclZseJKcSmIluZfc1msiF5yRWii", - "uRSj8YgLpalI2OjZ6EqKxTNd0IQ9e/jdw0dHTx7/8Pi7755+/8MPR4+ePB6NR0pTXarRs8eHj8YjzbWh", - "oyJt9OHDePST1C9lKdJeOn+SmsBXneM//f7o6eMfnh4+fPL48PuHjx4+fPqkNv7javyqMzP+O0FLvZQF", - "/yfrpyH8sJOM7x89/u7R40ffPX368OHh0ZMfHh99XyPjqCKj1t8HQ0pOC7pimhWwgidloWRxRhdcUMP6", - "/1GyYm1+4GL0bPQr/Gs8EnRlOsvpgpmBkiVbUfPRNwWbj56N/u1BtUUe4K/qQbTnM9PDB0PrGshLGct/", - "vvxPlmjzV/NrhJSUqaTgOeyMZ6PnhvYVF0yRmyVPlsRQReSc6CUjicwyBnvIbK2C6YKzazYBTm4xH5qm", - "3DSm2Vkhc1Zobvb5nGaKjUd58KffRqJcXbKiTd7bJUOK8AMztF7nZjQuNFuwAqbP/8niTbGVmQ7XbKXM", - "LLhIsjKFYwM9x7r84P8kPTdjPP4wHhVM5VIonMWPNH3Dfi2Z0uZfiRSaCfhPmucZT2AdHuSFvMzY6r/9", - "pzJk/rbl+lddvygKWeDmq0/4R5oSN/yH8ehEinnGk/2T4jruJMSP/GEcCI7tyQhlYsdRj9Hnmj1oyVFD", - "4nZzq5p2TS6QhOPRX6Rge+ev6bRzeBgxEME7sjUiwXtZ2vx+e476ll0zCkR7XbJ/wh0Ta7P9FGutu6bZ", - "UB2ubyD5OE1xHr0Ss97fcZoeSEFolskbRditZiLlYkFUeek/U+SG6yUxJFPNLzNG8oy6v1ZjTUVBNUto", - "kSojDeuSOSkY1SydUVyELPt5Pnr2Sz9DnlPN3vIVG3143yJbkNPznw++f3p4RDRfMaXpKicFywummNCw", - "vEZeM6G5XhMY3fwppRpEdcFo+rPI1qNnuijZh/EoKYuCiWS9PXU/8izjYnFiG57INEaoUR+ub5LI1CtF", - "CowHtWGtAtfTCBY9Y78fu2D0XnbVum+qzJ9z3BAk+LObdsGULIuETaZiKl7TW74qV+To8OFjkixpQRNj", - "ApkRV/T2FRMLvRw9M796Tap0wcXCsIjN58aouGazeSFXe2GTWSwzZUJFCnwiN0smguUilyyRK6aIH3xC", - "/mE+MWa0ylnC55ylY9NiKmwTY0CTtKBz3eZktfgvXIdEaVpoIKM+Sy0/0Ry5IkKSTIoFKzZMdCrq7fzX", - "hIuUzbngmmXr7ebNROpnzdPt5/ru1elzmGdrkzo7fYZ7Z9sOQYye2rZvTdM4F8NP6qdaTcgJNZuFTEeK", - "i0XGpiMiCzIdrcpM89z8Ozz5++jtw3h0xQaIrzf2IP6NrWMCg1yxNW5dxVb8oBT819LsTXP6iF5SbX4s", - "FUvBGE6N4JivQ8FGTsNPpqJgc2bEG4OPMqqZ0uSCwtpfkGtWqEBK2B1ltqjpAwcHdQMny30dWPOWkzCb", - "8SijlyxTmxTuK/zqg7t6tC41XOUZXRPza1R+/cj0DWOCHAGlD5887RZiD588HY9WXHihFpFoRn3OQH/G", - "ryHmdwK/t5UIXEw2Wv+ost5QzU5oAZaSY9wb33d1kaFFQdd4acFL7KATdI6N4mcHe2xMg5zIVV5qlpJL", - "araNRLHEGqLR8NoJC/XMrMMBuQABe/GMXNTVwgVKM00U0xP40O641pdkWh4ePkr+RIS8uYAx7l2Ewjfs", - "ichiKi6EvLGNSO3D+3agIlnya5bWh9KyNlCfaHQMHI/KPP0djaeMKk2QhG6D4JpmPIWWM2Zs18gWfsWV", - "Nt1WnxL8dOv9e1bItEz0CdU0k4u/+36stdzNyr83h4xscitUkO45LTMNp7Q+h7/H5NSEnIqkYCsmzN6N", - "qFO7fiASuDAmD3TdSa2lJOpRKNivJS/MteYXoyat7BqHBnZtw6BaqKbXVIuB6esPek0UvY94MdoqMiqw", - "eKdOm9hji/rs4pnTcDRNUaXQ2g2ESJGtiRQgdw/IhVN8mxuuZGE0DhXYejQeMWHY/4tVpWZJbGfBTCuZ", - "DDMNXGAsfWNdNQMvWqYPkrtOiHP4tG9KKdVwVdzqROCV70N7N6+Y3njh9FN6bT5ubi6gw3bUuQfeOK0+", - "/NopBfE2QZsLaAFutvvaJ2Izraearb4Aes+91t1OfxKwuI32REOspQqNUqvrtKmoZjFpaNK3VcdLiqpv", - "zTS5NAZPXl5mXC1ZCn0meARZyo2Qq2vZtzVBWG9HrynP6GXGyFwWxlJsKc63HbeSdsvgYMMERuMR0mD+", - "w3bYdcALptTw/QCtWm4OriPe8ROu17WbvvkqQksiS6GLAUb8CTbo8D3YX9HtwAX55fT8Z/Lo6OnTg6P3", - "95Za5+rZgwc3NzcTruREFosHXMkD+N0ScmBaqslSr7L7U0GzfEkPHhqWr6iuzcfSbSxvLthRmwMveaE0", - "MT8Ge9ZwMOzmlfn5KMYY0/Bhu9dzlkiRbtXtw1i3+VIKNut6NDgzv0buGPj3n7BVrFepNM1mhneRTuFH", - "WJJan/hnWMhIl+a4RzozEoKZq2BeyGtu5VJoPkY6iz1KHOf556vi7KXlOM9/Hz3XfDLZ3kFIlXPAj39r", - "qgsBVvCs/u7X19sptjirGrR0SbvP9nzew4wcYa0dZey1lBYpmsnthbMvor+13AXLckWNgqQpiGV2m2cU", - "Xwyduygx1hm8J8skKdEVYA+t9cNPpuKt+X3OWZaSFTWSS2jKTb+wAA+cf5JqanpbsiyHDkrFClKKlBUw", - "gam4WVJNbpjQ5KaQYjEhL0SSScXINS04UAivvMqIRfVrSQtGLguaXDGtJuR8KcssJZcM1OM1N5YlVWQ6", - "OjcWvqE7oYpNR6B8Ul6wRBsKTF+GmHenk6mI3euap7p6R27y8511rBRMl4Wwj6hFwTLk6OlzckmTK2Qo", - "zn7sRkfpPBXByzReOIMOZjyFv7EJAYYbPipSGs6L1Lo5MnZNhSaZXCjDTiYIJUmptFyxwtwVZaEVoUYv", - "q5JtOWHVY9H89e3bM2fWhH5y2IgT8k6xeZnh5SqnSqEbinkhMxWXMl0bjiRLnqWk2reGMZTMC3gCSs3q", - "kNelMoaMZS+urpkKXrN6JxO8F1tB2z4LaikLPcYjceCPhCpXK1qsm3uenGrTwGw4IfVUJEsqFoxcWteS", - "Pytg7FHXbEzYbcJyDVswkwnN+D9haSdT4bcvudPdqzuvfbBkxPw+2dxRQ4j5GyhyNzgkYyd93gfeYyul", - "2kLbKo2vxt1X4+4PbtwF9lNrDHDhZJmRENWzuBkn5eazlTGb0ExY0Tw3Q8AruWaFoNmMi2vJE/jrJtPt", - "hW1z6puMR4qK9FLebm58bj8cwzxhepta4Hcf/Ale/4TBRcCdD+ORFGz7J96ww60bWJq3b9Fm0Yf3vctp", - "3aC7eDP89ZnmuQJFcIndog4sKD77G20qhTAawj6+8CI9yGmh10Sx4pon4DY4Np0kVGAgobGwpFHiNKeX", - "POOggzN+xYhaCzMvNN/A527UhCRuQ02FWitzJRhXZIhF99BAuKa3JKFZUqJpMyYpy/g1A0U7FbhFmRqH", - "QWhyTnK6Xpl1GBOmE3AeVCEezWNoVj7kiwuWWMsSOQQd+y6RXmw2qcLa7A6qHdnaFvUmds/L+vP2gzrN", - "88k26jr+xPVT8LS1bU/DXlOr/dr1lBo6h2MkNE0E67a2fu+wsw3nxVqvz+3tc8iByfPK+DXbt32njUnF", - "4TwKaYwLhMhFgdswS0fg0pizRnFesdQfLuLpclz2RlTrC9RKKGo/bg5Obu5AuD14DWJdhx+2Xuo2G4et", - "fZs9m7ZC9fq8HevcO3SLSfgDijlzT4usZSiX7Hupo65mJtkhtmfbebX+2/PKrtkG/rifZ+g0b18gmt2c", - "Poc4gpqcNr3Mjh4+evzk6Xff/3DY2iJh65jVZd/4ZlZsz1ZML2W6iSTbygl7gq3I6fM6bfmql7TOXqLm", - "8V3tpohm++gdtLfDdhpKK8KEsVZUjdaWWVAdCmM0I2udSQGPG29RwxBV5tZ9QS75AV6BMWDNWCjLQgp7", - "mSY51YYecrNkBSM/50y8ZpoVU2FnTFZU0AVTwDVra5CMz1myTjJGbpY8w3gXf3KRHLKkIsUJQZupqL29", - "U5H6vVHZLTCH05ADsriaZ/IGYiCOJvBa4uw4Ow6+CvtxFEZ9FVQobk28JVsRvSxkuVhWlE8FXEoUuQeP", - "KeS//q//Gxw9pmf33yy9PxUPcdRwXQqWMH7NFLlhl0spr4iQms/t3UIReilL7XkFwxD0eaipeNTuLqFZ", - "pry7y3o0Wvw8fY5TWzFNjdCZiscxynDZHWvZNdhr0Pc1p+iWsb9ZT9Tx2alhLt7FmruDK3BQFhJuUJdr", - "YqarMDoqp+hTwWnmhVyYmyuXYipKoXkW3RWJFHNerFRrJEPd8dkpMMOQ+wUG2NpwQGvWDrYpgrtOPKLI", - "HOwEvyLVWLgYIO54eNc1a+eCjDrI/RqAuykAF4TyDCTEzOzYmdn/bWpewHcYAtva2aYJkALRpdhlOq7k", - "1Q3PMnuYYCF9P9rFsN5Qrq1SY+bCV513czmjWRa28qMziCHLJReaXLK5LIJDKhbWsz4VTujBcNZbbq9/", - "sQOspYtuQtryguUUAlCYv4uiUeSnnHLVnDMttVxRzQ3xa0+Wl9JNJrh9jMG4IEMWZcFSrx/MjuNiEaQo", - "XUqZMSqCVbQT3WIdPUs+eiVrzB2wlm0KBqwmS2uLyYQqC9ZYzcqS8OpaEVUmCVNqXmbZeiqsuAWq51zQ", - "DIgIzQBLB4cw2BUtrtAPjzR87Pq3WUcLM8HViqWcapat20NGl38/kdZfZrzt0LDW0B3YEdt6Xo/LMToJ", - "HWi8Q890v6KYxu4NxYW2RJwM77fw2Hz28aM7xTVaP1BgWAQBjB3KqUfe9TuPdg50y/PNYWMDj18kFeF5", - "zYO2ZZRZ21s98LaPrazpBTFgEO4PApwpcN66+8icUW0E7VfD9avh+nsbrl913pek89wz4VdFF1F0G8R6", - "R7zNiV+fIJAYAmACSROugZnF2pAVZh/HomlbL6Y7+Y/t6HU9QRMIXNjkobWfGZVIlZIJBzPd5Y65rRm8", - "L+D3W718fVVVX1XVH0FVZfyaraIRLqci5Ql4hm+WTC9Z4WU+OkPt2YI8HNPL9qcsuJOuqLoy2yLnM5vS", - "2t6K+I3r/vjsFBJWYSdCrhC7zaWy9/o5xCcZ9QkSes5uGuuw4+P5V929UXejEviquqN31ECjBWeutf83", - "6XjD4pMlS65kqc/xkQEfct+yWw3x4kMDILE50exWkxQ3uRHp2sf2KA2vXg7fyQ5O5pm8iSjuuWbFTJWX", - "K64HEvK2QYHpqfZMY19McDkvS61x29YJWDGl6KJj2+JbJ7Hf4JzvregtOXp4eBic1/tNgf3w8HCr+Du1", - "5BA6N6M7BaM2WZBJsVA8ZcT166Iiw5fCz40F+1h7P/EvbP01K1ZqJuczG7Y2o0nCch/4P5QjBcszmrjw", - "dxdJAIOY82gHIXRRMMhIhhl9Xjz5MFygvY5aI1b7u2+J/ZgYOQoKOIClw5h7DiH4eVkY66AlvxS2r2kw", - "pst8q6tOg+J3p3GaW8S+O0V6Qzfv6pKlKWANLqXSW961TkALNcioB8KfeBERvRTqQmaVZecptYJF1WJD", - "vlXetxeEZbsZ0FLLUaAwd6b/RAqjr+uED1FlTXYn2GEYD+qezGhcdjYihApWKjbz52s3c2z7+Z7h6K9h", - "8Ddm7GM/dCwrwC6iWaprrjhE4K6DkFcXbATTqMTExEairiSEadz5rKqR2pN4YaN9GiG7rglE2K9WpbAx", - "JW5J4cQbgy1ID9aSvDsnK1YkSyq0siBGimnzyxS26XQ0rrZ6GuJYwjGYCi2JWsobYKnEe14NnyQ4EZCJ", - "wyYxsX/XHH1rxvt5fm5Ha3P1DZ5F5emF+G5URm394V5RcdMAa30HFB+5243evXlFuCBrWRbuZvacquWl", - "pEVqmK65WKjJlgrgo0/H0OTVvuOxUUZItbPfZU/zPXMktJfe/QTX0LpUCI2pTsnwSdbrLGBhB/kbpViQ", - "xNZWRkvE29yfKjqricsGzZukVSjd7NGI0CykYHukuCEk2sZfy4z0tiqxuhy3REUoULgXTW/F0ju4Pw9V", - "85XxwpNlFfsLqcTKv07i1dwBZMTsvsbVNbiy7fFU12b6I1vSay4Le24t8tBIsGvIQKvP8x/O6yaJotd4", - "F2qYYRAq4wJ4nWmGxjD0rVD1Qf8WOM65tz7fOfoFBV9bOEPzhw3Tczflz3eK/i7PBSZgupAnN0v3Qe9M", - "dxfT8Zm0xIP7BVFXzMe1bAh72CCzq+9O5WQbsGZnefGGYeT2z+JErnL05bdJdl+Ry5B2d8FqkVm/xGQ3", - "dK1G4xGfz7x82wPdgGWA7wdquJyrzBBrjWJIP74OGTFAOq7F6JJ2lit+9K2ail9ad6Tjs1NSoUhU6cSp", - "TNQEfbqTRK4e0Jw/cBx84Dj4AL2h99vS1Aoq5wibJfVL3f5OZuelt3427T7sPJous2/Dtbd5JE23Y6uI", - "4C2idn92UhqQDARLmFK0WLtUxqkIchlBeCVG+WazsojAbhh7G1Ai7B6vLPubpSTYMq7pDM0/SY2xrA60", - "ruSzFWSTKzL1PgiLVNp6Cs24uRP70Kbos+w7BO6soD8tfqiZbMESKRKOyQp26+AzLRe1oFpksIN5C9N6", - "xiShhYb/kAWhYk0kLJ2FI+U1oP8wER+sorvbfm2fRfSiHhxkOMD281CiOlsxLYFvbhlxYwxGrN4IVV0w", - "dpAxrQ13z38mjx8efdcAr+aClHnOioQqFl4KMejLG+fmUy9RiX8qNd+AQ63xBU7HzHmm2e3HuFQ2PINE", - "1iF46tDS+ZubDG+/fQQ0s2JWVjbrXdkXfc6ejzN6P4xH7DY3N3v7+NY6xLfBE5qHt2x2RGwn4XF9dEhW", - "XJSagWB8+JgsZVk4C8GGM0xIKDzdN+bkoimEoCtPH0drdqDDJfJO/eLtS5JRsSjBgU0XLqq8IvvdqXPX", - "QF7VnFxmVFwhsLLzC5XuCfmykDcqdPEQi+//zIhKYb6djuYF/m/KOoSmy07qVvq/xRIV66gYgKF6xdYH", - "gGBEcsqtJ0drmiwdJlBU4lsQHTiGWhZWiXGX/KaLMtGQORCYoZMYvErDJWp+7wF8bdzZ4WvI+8eEgnts", - "spgYviW0SJGDpZpdUnE1sy+k09F9t0gNoHVr6rj8QJplFXRRfdg6ymxHUnuFK+Z06kyKWVKzL/d4wqMm", - "bMxzN9CGhRMYuPNFzUoolbEQ8C21mtqEnDP2bCq6bD0Hb1AZfChvDmxexEFOF+zP9quDkv/J0XdgthKy", - "VJeFiFsybxDoyhg0/XOzdLu1paVeGmWfUJ8h6TUSn3dZNOAHc/w4QGduY7dgPoXNYokeZjvv+HzO8UfS", - "baHV+S8WngCnI4fZaPtYvdgsNb2d8fTubKW39PY03d1S0vQWcj9jBpJl1d6sCfuiV79D2Pe5WLScfdhr", - "a55QJE9tD9ORsz2Uv8Ed4E9YX6q+gV1qFFMWwitbm79J8L1PBc3zulqthvkYP8EbpmDWg66s2MjogS2v", - "qCcI+ofSHDOqKqeIYCx12HitM9XUfbKYCoi7gfQsQkVEsMRjVvpuXfBCjncrc7wxNzw42AXztHmMi7Vt", - "sftdCkaFD4P71OnzCuPNur4tVGJT34fXLfOZM9rgxgUPNq1rVw+piiUFi9iKJ0gg/gzjevabgS0ozn8q", - "/3Rmv+dp5DbRo+DuStrtOcD37RZW8w1VNks/vZtr3UntAtcpjGr3GbaKwnyeVE4Q+MI7M/i82odaBuBH", - "bQ7XsT8+OvMpxAixJ6AOgRC533yadeVZZq9Ekz3Z/q9tF9bUR153PWS0JPxedeHr+F57HQB3RtUdbkYN", - "YP7ZmkwxvmY6Is6osdgcVgQEmr5lzW+wKKFgSodV2TAmG0Zk1NjDFhsRa5q7AIFhIt3pMp9xKErX2Sd6", - "SvAjs71dynHTBGq94E5GA7FX62jy0YXrF7hxRzDuvX9zP8wcE/HvBxXUZ5tW0/NsB5yg4ZY6zD+w1jeo", - "89a1KTbgQGdt8xRDpdJ7ZpmtAWgOx/3JaBN2asivKBNr+7i9CxuBzCAw3u9qKzYN+4GhjmDXdwZp4RmI", - "vd00QNnw/lar6RLHHUJXhG4N27xYNJ390Fs8tb5amru8MTmTadi7Y2ueXLkH/vRu3hi7yG4fyBZtQeQB", - "ydg1WtHukY7PZ15n7PI4Z4/HmSw0zSytu73N2Yc9eDmCvoN7jpNQOIy/7rTvHeEu75R7mO5trjO3HNKs", - "p+IXJwvDDja83DnJkANRD2pN1X0IfCsVqwDD7Dkb25SnS3iw1orMS2EBtLheIyKGy/Ym6LKbinpxRK8f", - "vYPVBTK34qzaeGgdLl9gzIu3L6fil9DxO4wHjUfMf8P/sb86BXaAJNyfCqsx8d+VHsLPzZmq4te5AGZ4", - "J/MFLbW8sKUig9fFHG53BUtn2KsyHzfdz66yXpRBG6yiqfiloYrugkUVEfctLo1jjpZVHscaIWOtOkUA", - "FV64O6xRt7Cx1GQo1PHGI743V0Z19DoO+Y7cxVnd38kj0uS39rbSVDSo3EUE1T1yrggkDsj/2QjYwXlt", - "a0P2c+Pf6pvMGZI1ij/Btf7EYf/ou50WDlOlgfbhfjRlz0DbfScCwWSMwLl3JY++sr/cKVFBHl3bJNuk", - "O+pPhsOk+51OCukeKOyrR5U7JS4g4SPuctVWVvVb3fY3LHC6N25ZO6ueqejVPa1U0Oh1qyVLa3metdtW", - "jYt+vc0/+69g3dUXdRtYu4mp4WGexx3QUl1W9MmSFrHsMa9dEvhgUymBeUb1bM42Ifq/zKh+yZgddDwq", - "FV2wGbzbbWj5znwJMW+28Z5KAtQp2hLkv03M+7D6e41zPUVNsHEXtscrjz4bQHu45TBi4O9Q+MjVzbV7", - "0Nbaw88A7g7q/DmX02WpXflbrKpH1q16ukF7ruxn+Ang47W+ACC9ADvP3BuEJPOygCuqxYQF/wu7zcH7", - "gt1Z2IgOku2v4W53ijQoCQjDjjwERVhTBtlLur1TtWV4KzXNBuf0mtMJDf3qiIV7AaGZMTsMhxyQARVp", - "WFf2omA0m2m+YjM4CBf2m/BS0Ai8lPJqBz+EnVsHFsgKYFa8zxCYRjNAiiE4oDM9/cuSDecInfPdVXB/", - "RKKxqm9mprvfCbheozOpJzx5rreZ3jeDN24Ebelo6A27LO83HXX1AoaKIHLC3238b11+qMhZb+6b8AB9", - "q4AhB0Av/NzA/wlbjrrllmVL78GRSv9IFR96arD4xSVksNknrUvTTfBmcLluvf58aXBz9aKtn5RG8MNQ", - "zTA+D4MKETNJactqrqbCU+i8O/7tb0y4xoevy7Bse4hKCiiv9gtMw8RK6hcuPjF4tZtzqn2lpT2FuDJi", - "em1EtfpHUT/Ryf7Ad4pBkaE/lStW8KTrtdMQWMASOZLtRCZxq7RioSWkZnX2SR5jQevj9D9LpXfIpjw2", - "Oz3lmlDfQw0iUkuyoleMrKgojWLwX2EoYxBuD1C7pqdLmlFhgXXO/YkvFTtIqPJCDmwsLJaYWHfAgPo6", - "nwbU6UtEDmxsLiAp1ALN1R5t3FqYow2JqGcy40kE6AmStXH5jXWXSKOta6WfEylUucp98N8BuZBi5qTs", - "xTNyYlsbM7JqShVRUgrzv4Zti4IKMHBdIIbryKHd9fcmRVJHJeGA4Wxx8nxnimmdwSvGoJ6wWc2gDaYY", - "W4SAsyRH1vZoY2j0Ix6uXQxZey6r52M7M7Rsg0t8wyYNRuzp9HLtRBxn9RDeXjUQTsqakDH4qSDcVxec", - "Xe8x9MeY+F7XWtbYWRE7Gnpf+2GmaoSNK661l93/tOnkvSxFysUCc7Dj7J/jJy5iO/WWl8NB8CfGfGmf", - "DA/IhZDCmJU/Sd+Dx6CHAoNMjTESA4Pna5gO0KWCbiwSujVQG2OZLQFYlQcWnN0BrpthoLlzZXS0l6X2", - "OEK2CxuCfsMLhtVR5qwYT0UDEJ5BnpFVWT6gDo7h/XZGtG0TuFYii1Zn9MZj+hczlV1VMfKBZplEBD93", - "UGsKF98bAuGUFvRGkFTeCEIXlAul3Q0DrnNFWgHsk0rCQcjCVATFCGzEHxgvCS0it1S8h+3DVAI2sdTb", - "ICvEHvwCEDyHR/+5/bHZ8PU2r5VGixqX0OT9Csm50Xqb88zVax9wCl9iq8puD85k+yi49/OYe2/FdasH", - "SCR3ZdYbj+/+33Cc6+/w3rjGXpog7lSsXetafbNfRlzkpZ5pecWEUTiy1MG/32+ppd/YNfkbW7dTcGLv", - "u1Za2rSj4Wckov7ae/ZlXfeFh2WPt0KnHYbtolOr6nwEeLWhkEBSlXYFf+FFnWUXRg169Xon5QhOffKt", - "Y53TzzE4Zr//25i1XAzmTufQUES6d/wYHzbPPmJZbqy70G2NVhv9y8SWzwsuC18j3UaiHR22/HgFvTkA", - "g8I1qB8y8kresIJAeqPCV7olXyxZ4b9vJocePUVijVA3Ix4eAq32n7G80bwskiVVQ3fYmW1Wq9DnYbCC", - "KZyhgsNDSDut4am4Vz+g7pUFLen7d2kkGZMg9/NBE4mcWPQBowAKuSIXOStmpeB6lkilZ+Abu4DZW8Vx", - "gS0vomc4vInOcn/J30FoR7wF9XjH8Erckyc91J8QhkHWPAt3nKvhkLka6wNbt70iu24Hx7yjyWGEad7p", - "m7PCLbcZuIr4cZslSqtN2I3vIK7I4eTJYbiT7DMMV+Sbo8PDyeEhRgrC24m9ckyF+fWJ+RGrO2IK9Ko0", - "pJqzZ4x7ow6pIIdg/rTc1+QQsrqnoqEZ/wQHDgDsGW2HwB5NDic2cN/ecGY7onHjfnaCxOKhnftuO5G6", - "beZEVaCyumshJZt9CX67jp0YiTmAP2pecPPaOIcs8kbdbw1oejvDy+THEPaW3mLsWkwc0ttIjHlFldkR", - "L2VRWU+wdytfQ+Mqr8ZYmb7Wo1rKMkvJJdR7rdKlsAadc1qTgl0zAbApiVwgarjFray/tQRhsw07HkfG", - "hBrUNOkYExGp/hYVDLy9mMll8hJuTBZHmN4mcHP3b8lfAjT7eHQtDU/uML8LGXtDFcGh9gUQ37jSjCOH", - "tFbspe4+Aqo2OvzCQ9mO2Ak3TvNgOr9ezoBK92JsHY6ZTK56Y0XWTCNU6GQq7l1UL5tUgwaw+Xrz0lww", - "AcKnbS+4rlZM34/Em4SUcPcwrLO1RSg1R5RlfMHj+r2bppwqPTan2+UNRgimIp2KDpI9udhDGqPX/oSX", - "kYKtKBdGfpQC9Kt1546nokYFvM8bnudUKfe4gFsyNkawYckbP4TzQ3O4Ps4ZbwTM2OUOA2YssSN31Lo2", - "Y2sLbefTrCTz8DyhttSmdfcK1P7uFsZkmCweTwUXSVamDsnKqYBs7TzM6MqOvHkEyHrDAlnobQNfsMkE", - "Dw1i5X0VexPcgLl7WUd1ukM+KKxTyqpqiF2KNGXbUPKh2kTbrORGSbfJrOqSft527bauWpLQAQZ7AYip", - "7q4obCACm2+B1b9j3TS/tu9/sU8jT4PB0a0qdTm7NXZqN0994wl+W1Ch6C5pfv5tQlddVJaAIpQoLhaZ", - "F2oreY2UtaC3pyKMDzhp9YreT75aldpc9u7yYn3OF8JsgnpYWX0CE4KgxtfM+TloWsl8ItiCmh+nwv5a", - "sLRM/ANi32U7YzP71Q5vudVl2KkIiwMOFYZ99ZWArx3lXja5rjz3xiMcYesGG1xutrexJSN2wcGwu30+", - "9Pp63xjtV+cQ6GAcM/7k8wd9kmr6OtyOo2CSVYB1jc32tUrb5+X0dQXBdriTB3oDshg6oihsGkNbU3zE", - "HaySAb5GV+zi1ZapbQUaELTRPmnOeGPeRmTS1hBBU9NHEvnXXJDUPT7NA3KBfwgbu7+YMwcRvuY2Nmes", - "BoeMI2JWC3zdmyASSI3mSygFkDNbZKgKYOxPFcHPtxU5+DHGP27ZxtC1r/SQRp/DxCXS/qEvODOUrPvy", - "PXesC9jy7Ryo8ej2YCEPNi2/GctOqCNXqDEQOdXBzYySEiGE4UJxWWqwqc01IeOIfgKXZyrWU+Fy4SMB", - "vi259rgm1h5t3sbVHHYMWG/t9WbSbbrRBOpm7e9nRVRGeMDxLerU9qjs521NHfJtoHraj2qOq1ojrEM1", - "68lsbuJluaLiwPQKQtmiYEOx0uqyg2nysf7GRJXJklBFpqN35+S5zDJaTEcIVfuiLCTCzQ6tJrpeXcou", - "QBz4beO84hOxgXW2B5f9357KN9MR6Cc/JZzQf/3P/2V/MFODiW1ngWzQpMEe8olheHw2lyeNmRXWbHDW", - "RSulcwv5DephaGlOe8qqmExaHb1aJkwMC61L7uyoQb6e7K8n+7M82WD37e1cb3GU4+a8P61A77xlXXGI", - "0tto8WAgbdPk8eg/RGkqUlqkEaunxpBxIPG6LR50qe1UMpgVHnaei5Rf87SEJFezARZU2EQKhfvKfKjK", - "SxRjREuSZ1QofFaBqB+KqGy6CmHcWFNkONaWbRe/ezZLKzXANibknQuV1PQW3b4uex5MZpfKarvxg/0r", - "en0GunsiPLTcHvcz098sv4YrfzrflK3D39f4hX0Ga0T1frGhjCtarLuAcN8GxYTrSLjN3R1s3DPb4AX0", - "+SWWwHfIG1Trgl+WO8HB+6ompqfjoKMImix6f2xxC/iQEahJBYmfANMj6wgv1uxl1/B8VYK2DtcA00Nr", - "w+4UtrGhLr+b5PNewN+oInW6wk8ppZpGXlnyfObhhAeCS9aoi+ybPG+P7hjY+hFeVKwSzgs559lwd/AZ", - "tut9VQ60sR0myIEOcpdaKekhumCzB5eJ7rH0GgrbTagPbc5xs6J+N8upCuq/k7j8OFxYNG18i429ub7d", - "HsEzm+Xpouve/AoffH2oqi3l1ihFE+LoYVEiZ8ZOBRfmHsSSsmDjRkEGADSZ04RNyNslxAVhNQaPaBkU", - "udLSWO+x0QMz+NLBcKQkgxBWKNGDtrGtOI38b28Nizsl87uo292oVdjeVT+HFQht9IYDpe6r8fB2yRTz", - "9QspVJpWZq18NQsPIw8lClvA2t6CPT473blAYXPvN3g59BzEcSb3fRriKJPxQ2ELQGyHDdnqGkAaBKjZ", - "JePFVDT279gCF1notOZlCV6i7BUOPnARQEuutCzWE1utHZHPEH2bN9AMmwKbK5JxYbGFqIOKo3mO18bu", - "dPM9H5M+1ODdTkkXQvDH79GWpTVsLw63wibkZxGsoRFwcJ//JyvkVMiCrGTBnHWmxuDlkML/BRoA9tUl", - "yySOLAXrwRKwDWdXbN2FcG8HQ5ELoAtuLmmbfFu9jq1yvbaFOiVOdSpqpqXFb4gkloXEbpUM2VylcxzB", - "5UZaw8T+lfyNrYO4rCplsrZTQq707JMXAno3J/sYjutO2LhBL+7UF9BPF8Js5EJs1rz+dq3MNSXBKwp2", - "riYEI0WNLDCc/u/nP/9Ecloo06hKOa89UQXtwd9ghaLzoWOGS1B0sw5B7fNeR7+RaRUT8FqmLFPT0TPy", - "y3S0yPXBEyxeZ/7zsZyO3pMPo40eyLHL9Z3ZK/Z2Yql2yY7DHGG35IqtY1yoTasKc1jBnGI3vyVVM1zX", - "KE4LwsqHontJVeDB0xVJE3IMhZWJ6RlW+cJCtF6gFL/AVb9oLPtzljORQu0gFysEja0sanweTtCFiUVX", - "IoCH3SmWJdj4W0Sx9K4DzntjVIv1UIcbp7Y+25317QJQmrRad7Lluc1NAJodH3t8yy+R4levXr+VV6wr", - "BMb8VDnMX716jRlcmZRXZQ3FFJLQffa5ua/TZMlmhnn+HzcFB9SrglElBUYuWIxX+C+VS6HYdkS/E1yf", - "yMHGXGMGDflCXtBkSVK+YgLsuHv25lqM4f6QjYn2DLlvVONUXAZp/IQqwjicPuqkJWbFQfQ0rBNZFLLM", - "Dy7XxMW2gB9tKu6tSl1C4Dq7TbJS8etY2W4gI1LiEAeDX83NEkf1xTxBCqJATDJapuzg0cGTAyWFYFDP", - "04hhLCvgcmymwsksXdDkKoj+hTEm5HWLWtS3F/D7zE3uIrzJg5CO1mKttWlP73UH58CAWMosRe3jph+Z", - "j2U+yMGp8D1VSz0HU2iLqbVn5OkZxZ2XiY2aGiTJ2jv9zPYUq0mqZHbNUqM6D3CH2mHxIm3m7zd+SjW9", - "pIpNyJnMbXoxF8SdPjUVnmdu98PtAZlrL8ip4eaKC5aO3Y6HkcJND09N5q9T0dj5FrUDucpuaaLJiupk", - "yVQ/gqebpWMEHA6gsPNEmGn7aTROhcyZoByPBRV6WcicJ0OPg+u8Z9u4T+KH4sxNIbp5Gi13PhohH3qP", - "x1RQ0nE8Bkw1OsPecwLbdraT0o9pskgmAG6ISoDjdogxo2utq7ZTYXcRXI1A9+Gv6v6EXFidBmlqVBCa", - "cYr3zQv48mJsPsHjZr+ZiuAjVKEXPWyumBXfU5XarrP24/dRxYJdhWzYwxYT7JhX/17qt6Zqka3eroFs", - "eiMhQ6smy2Lv8zETsMfO6xblgyue7CDmI+VUnWE2y1mBOEH7SLUBkAK4vJkBiBnALjYX5N3589q7cfVJ", - "zuyegJf4yk68U+JghA3U4Tc18hBp6W4IC4RIhKRT+LVGjMV5uhtqsPNOcn7Gn2v0eKv+jkjy/XdS9cZ/", - "ERDWfFJpLGGEj5uP8muAHdzxCnJM5vzWnmIvdDyoyN2lwr3sHNWzchfZaSEYo+ITf9tSgvYCYdT5H3K+", - "AQpUm14sh9U7Pl64mxouh0M/tpmChVFh6VrQlbUiG/fevvQIozWGWvcQFgHc2qplYwfuq5JGR+c73lh6", - "8ybqVTsGH6GMajJnvtiBzU/u9ErT9JqKhM18QuRecg0ZLTIOb0N8xcL6w1i1ogokxNFTRO0EZHyaXBkD", - "SaQAP5IwpeyLYtf15xj7wMxPw0fcqTgjY9jZkluDY8SO8dT1VpbAdFM/SKM+Qx/V0fa1OAVW8CH4gSeZ", - "VCw9w1YbYhPgo3BJ8BFDES17q13U2v8hIwRjGKWbVzsMB0zC2NVdgpI2RaB457a8Ee4BbxsSLVlfIxa3", - "iVg0as6c4OGvtFa+P/cddKRru9+bEBXVUrqlC7pqvdR0v7lEHwSh77FFBDTjJg6IwA32snqyiV0x52WW", - "zRQrrnnC7kKEmf7HpBQoMqFMOozlZNrWR/JlmWWNxnsHTr0bnPamOrWxPcKCw1x6FJPeuj8OpZXuhOWJ", - "IRfp7HKH58DX2PbHrkfBalp2FBcwOZdZJm+MSENJ0Te9177pZxSvi5EpM82K1Q7hhzxxkDFvTQdt5p0F", - "WJ9uPg17sOZ+DD53Hnm2G11dyJ3mt+2PpO0KTFRbjbBeNXUobW+oZie0SM9cf7WisJ1EO2Mu+kof4WO8", - "ASIx3pkgrCoXNSRgIq8h6sUems1sP28JwQBAcrULAFMFafQ6bkWd1zH4t98ijYYfAwUZFiiMs7gLAXIL", - "Mm2341EYHzmcj0HjTVZfLRATnNOy4AtzDWdpW7cH6uOG+pIy6C6lU1HrjG+ogRdSOfo4GMxh2JdbL0er", - "6YC8Pd+5T1Jz5UDf9wyIfpt28gSkzc18EHW00Ow7zK3zH4UR0RunGmn8RWZx7JTw4EFS7FWmZqfUwFM8", - "aFhgqbXEddyabd3QneZsy82Gyu9WbJ1OiwDJ5WVdk482epCe164oAxAh6jcPuAFAfmOdAGVjpBGxGJJu", - "jR1FFbk4K2RaJvqEaprJxcR3eAFRlOa2IUsM8r2wdSrnnGXpeCqwnp+r4to/fMuXlbMiMbstVvP3zP/m", - "b1bNixVaK/cO/+v//H+ODg/vTxpw7QFa+6HnvShXl+bO/KFznaqLXM+KnVH79jgE5t20qePQ5axQ5qAV", - "5LJUXDClAku56feD+Gc2XHHCuMe+eUQY2NDquSyMsilYLYOhcv4B9jyfE8FYakF8e8Qhr+omuCjy3FAy", - "2SZ8cVDYYjRHMCbypPM02GzoIIrRktZ59XjFFjSzF4+iA7LET6/9jktvZzzdbeXe0lssQaG77l/447eK", - "ZECkY3ziU0eqZOK8LHKpmAKg8zVZUVuwXOolK6YCT4cNnr5h3xbMxQVoVjCbpUL0UipmsXBbHfdmNTW2", - "4mBYR8x4sSz3J6K9v/aUzd2dxv1jPSuhHVDfHPP9BqaEq7xLfRK9JkpLV1Y4ZZryTBFHkZGYdltAmTPb", - "orl4ZnGNMelq/oAYLNYfC/BR2Yqnta3Z4bH9yYgerN5tiGtsZ0AwUEt5IxxcpzWb3cbXa5LKpMTY0t7N", - "mNGhWQtngCVgY4MIJZqt8swVTg1t8B5MgYSmPp9vK/adnv9s7LTn/bdg91Rgu29TRIyGWWCcS55REctM", - "dLT94R8KkuCS22TWV6iAQY73Oyg93UZHrSI9M4jrTOSKKQ/rHhQ6qFcqg8+hLAEX5CIt6FxfdBa+qHbA", - "i8qVo2kBIUqsPlUt97MfiPkoLTOWbjnhIlnya5bGp4zYOtDCTtkyyPlLuEjZnAuuWbbejgFMpH76ewWF", - "2EfGyjFYeBwCH9mKH1izL4QhshUpagrSH3pyGn4wFdUl3XxiBL/SFQ+vWaFCa9Cw2WJ224H9s4391Blc", - "oXT5sgEullR1Fd8FfuAHBHYZ85c4sxqFkXQY/BCqrQk5xkZE3XCdLKdCJklZKLRLqbbpJCkWBq6/l0/I", - "sSYZowoTAbEbXllFW2fRBQbDGdT3+gCcOMW2R4FnuZrjqF0OOC/kzOhwsZgxYW7Jaa2mGR6xeA5UXsgD", - "bGomYFtbuzeiz8+qz91IscykHT2xZpa9fti69xWP0olc5ZAXeUlVVbiVNSQplNawIsUVX7dy+Rm5qKuS", - "C+d2UExbUHsnLM3HQt6QaXl4+CghjXaTesmPRre20Z+IkDdYjics6KFlOCyRxVTER9Ly4r4dyMnk2lBa", - "1gbazjn9JdTMMddCdJmxopBFtNqoAgT76lOCnza1MEMZnReYHuulKizTJeNiMRV5eZlxtRxwmuvOrr97", - "Il4YGqJlve06/L1Jb+SMW8leL1YYv0bQwisCm3meZfKGrGWJOfJXzGbCK++BQxRzEJelEDD/1q0jLFHY", - "ORNLZbuI4c64NdXUa37b5q0n8ORaOfm+/4Z2tkNBxbq6IZDxEWgZ4LNC5sIlHj7+VlVlpBWR16xASwsz", - "SWoPLHkhF+h6aF/zPodQl8HPr9tdMdPGOw5wt8e2BuYXpWjYlcTsSDRFQaLgdyu6JtJVIU6DPGkfNBM8", - "BW0BHPYvARhmNuQMNmTcpgo3bP2yOsSuca/uISTAG9/zJkAAKx1QBgQEbzjXXbVz6vYDHs1JwxDw53tJ", - "q3o4ULvGawOsAWkRF1IoRdUu9OVuQtFWYPVz0XDrNDV62I2QJJNiwYoG3ECpWNs+CRtWlzwMBwro0VDn", - "FQK4nMp175rAjbCaliPLCFnXY18O8pmLH2loJ/PnTZHh82wjBD708zLDgnQFY1t9br4bjxYFTUujX7Zp", - "8xf/MbzXbkXWO/PdeHQts3K1FWF/xy/3FJ5ezXXLkPSKl0MawCyHNKhYOaSV403fiff0Dyxwn4H9xxN2", - "10WL64WV5rVx6zHg28ci+A7CUITwiTgedrBrTkm1qwYyuWCsi8m7TrRgbLeJbppftUWHTdK3I5pDuBXS", - "bDQLYCWYvzoT0NbRRh+DfWxGTCJjiHMbrmNaTIjNgAStgeb6VFBFknJVZlBty7ZMCglvVaYVuZSlSGnB", - "7Zs8WFCYa+IwaOwVzN2TvaIfNzsg98p8puUMt8d9c6uYCnabg30KCiyR4pohfLt1jxgpGTFdTc8dGhl+", - "CgrqWlYiD+tuFqDvY7wsps+3HAPbo16Wt0Bn++61416tlM2OJxP5tmnjhqGgcQdZIxqUNqRQBVAys2k4", - "EA4zo0XBaI2AuKYHng59csUYC1hTZxBVy2+sJVSh7oIF27nudYMO/HKTexCOZQNNC9iK+K/7vuK2Yhpv", - "FVOx7aEIzwB4yKIHYCo2nICKtt3CalFDx+Pg/VoGzLBbEiXJicVqlCIJ/PvuODF4gq/hib6MdGmD1j5q", - "Fmg2RGcBGYlbzSIPcPaglRed9stRLQYuPpFgVfeh59/l4GYBDHBXaxX8p7+WFF1cDro1kUJTLly8g5vc", - "6ZyUeJX1rylufWTOxAHG9N/zV1vz4/3aTIECN1z/87RfimFntmKmRTCF4CufHQqHprk49hK/8bRNBR63", - "2jECRxaWxHeKxk4Q1BObLCbkLz+6Ivhmt1yuNVP3P61FV+3cvVp0cOG4W4vOmtfDdgE2ats6ZkI2SC7c", - "9XA0qYtI96A4GE3iM63xiMIjTYaJ0ohoi15afHP5Au2ZQIV98caMvdHenSVTYXEPRx+3eKvKiVcMQmVa", - "c7FQYbEG9MNIoQuZKZcdNRULJljlGGxBl6tdIcKP89xH63e9adnYVhdK4/I1uGqiyU6+hOgZ/zbRDbpY", - "hQk7nHM/wdhb4tdImK8FXfuqR5Vwpy52i4HtOJNAvBMVNNF15HUbFOpGjh7Wqajisb+QB9YbWVzNM3kz", - "mJP/cA37Awhd/3XBjGEGQeGC4a+EfgsEcxij3K4E0mbdUxfWQ4GnXEPn1omKddqW6a3aCa6I0C6g35tS", - "w3zngEFeBXADRJll3SRIUL0LGpw3YgMFmt7exehQq6lv5Kb9Qm99bhDCsTrWbN5QZ3Rh/g8z79447Nah", - "uR0LwzKXvudA8SLPw7a6yjAj0h67tpW4Ythdb7yDI+u1+bjJOSDIdrSZV7uWI2lYgJ+0KknbPhtUnMS/", - "jg51nfk7jg13U7V4N4x0qtDN0eFnsRpk4ZKEf/c4cmcbuMm4936AdaiDGkjBDoyWm4p7QoqDgiVlYfT/", - "fXzyDzJGKmeY2hSGLlcrrgF8e3g2bs5EehJ0EMlrNp+QYJBK2AQzRgj5WnIbOPUPMJYNJzIV98w9dFz5", - "R8f2ZlnzANXo+cKRUdzR2B4apbWbNqCibE+ShTnxAsrctDeA2McAVaKUOQiVotJaf5wYlLsAwbCXz/D1", - "YrzFi0hDEJ0Kh0dW/zKo9OENiKnokDmfGFQjur88jsZHZOK7s9ibkW8tKxyil6QqA78/4AfZtYX6/Njk", - "5igEYo30zya32BY03Icf+yfo0qwUviKjw31RUIHoD4yRSzaXRVCTW9NCq1BnwWVnKkKNlYE5ck9I7bO0", - "FaCFU9Tk2sJLUAXldUgpNM9QLfo3tqlgt0taKg2pwB8274AOUJcdQjv7AV96NsVO4Cgt+l93J5BVpIUw", - "KR2HPvy0dcpWG0pEx6nqqCnaT5RRGn8HoHsXcS9kBWlw8Yz8JKs+MJLNonnhK6O6eEaQDBacnVqcP0TS", - "FmxFOSDcWdev3bNTYd8OAj92SIHHYXDj9T11t+Xg8A22QUY27HG2pNccA+S2y4L90bX4MPaZtH0tYSpp", - "07Rp7JdNJcUbED/tMgMNhJ/AGx/ZIEnBUq5nesnEzLrnL56RE/irLV9l5emcF0rDTUFAeXHcBCk8q0yF", - "Bz4LezW6++JZJY0QpSOtsNWNZFtQLpQm2KRWlDxCG/qlXN/h60gTn6h7Y7VuE8P2VfymEaowUsOC5Mp+", - "bGuJKWhP7eMUvj1bHeSxTfGDlVQYRe3e+boQme3vs/0+u4YzyPiKN+n35FVkVRhwIcH2yeyOSexhcheV", - "Na73qr7zJpjUgP0SJsF1QxqIZCmLPeWaVo9vplP3+mMxviVHeG2Q5PDg23glDuOkv1VT4a//lUthnWQM", - "kioxj8XWW7DwMAQS+2ATL+VNpXAUPgEnNEuwyAvkkq2ksHQ6mXRCMyZSWpCVFHpJ7h1hkhGjyRL/dP8Z", - "uXh4+PDJweHRweHR28PDZ/D//+PCtA7ZTagQ/JoVihZrci+l62rDKL4QLCVlfh+GhD9jZu49981BVUUp", - "pev7W6Dz2kX8IpLucY6zPTnpPF8rb51q7PtN8LfEdP75Pz/+Pm9/eUbFvtYKkhU61omcM0AGqsPQNWHq", - "fHJKJ54kDvERqanhMR6QorrtpvuCMjFjT3Tdb3PhwR43tYtfjffbaboTKhKs7bZDcWKoZgsdYGqe6tWD", - "mq92eYMLqX2Rcv0Wu2k4p1YrlnIKhf4akDv1avCtLQRbH+bAUuK7ydaTrY2FE4gk/xgWVsmN6qsl8S9h", - "SRjiGjtv3N56PoLVil7v2W5y1Wt7m+VaeytDhsTeZgJjJcTFH3bBDkuF21LkrYnMZfEJHge3pQTyRLDO", - "Ss1oCf55xdY+hN0tEIQMX0q9xGr04bJNxelzv1qlqod2N6ybO4DDM2wI8O8+dz7AJGLCcxeTaNd08gr/", - "pcNuuJPNui/DC+QHLNXfAtxDm4LqkeL43N4DWrqj1hk5nU9FfEFJz3oGFt6eK1PDRIKJhZSPzayoWG/J", - "rqn4vPhlnw9r0BLR6TcQiOIsiKoQxDKaihiGUS9tvUgSrcN6F+ZajRPwQ+SpyAYqiCaetqiqG2l65fBo", - "JuSlLKaiw4ZCjtEkYbnZM7ZEbAp1xJ2/O/y+UT2+HX8SwB+DdPJ8ej/EWNwxcsk1G2Y1IsKH/qiV7MXg", - "0/WjZB+5qlVDqFZ2eyckCHZj8WciJ8mWgKqR0lpQ5I6lcNtlBCH0EW5Cp7ht1davtv5XW/+rrf/V1v9q", - "63+19b/a+l9t/U9q628wcbc0iQJjvx2wELKfpRxql5qVsfnZTTtfRQ390znKJe/Lrd8dHNRjmecSU07X", - "EXZTCwjo2GfMGF0WAnnIbukqBy6GHuVBeEFxnrwQ5WojUE9gu23iMfS3NZ9tILif09hGooLtaRhpuR6w", - "eypCZ7gNJGe3euZj2o2tt0VHFvh1KkzrhqUYImUE/G6P0xdFFC/k9BGmeaVOagVAAkRhjDv02Putik5T", - "AfF39gWo6uUTGE5bP4+FNKPkz3eFb0Tkxk+oeqvpIq5h3zslEIcTNEuzw/xMs9Z4dzyvTXXBTg1Npp8I", - "BmokX6bRKq4Cenux3Hsf4ewmhQKtcXNtqUu6AAdrm7bCfncyxKPrceH/073tbQu0F8b8tTU6vSUuhrCq", - "0GSGD8HJUS6sjVLD/Gx6ixjuSVamFUyJx9WBWLmUpVMBlkkUKwAaK5ySj63bMI8TF0E7YLtDNGXKlFGe", - "Vs8W0QT+mQUYjKzSa/wF0qTyHDAQMIfTdT4UmcHO5TjPbdch+uWxHSIcgXji2ml4n3+6/9fk/E+SnP9H", - "SQr61yxHiCktNUHUo1zaEmSYXNxKpLVlpAOGGZpyDTgwndgmVtwtbUUFL/S4aqbJ1eCTbMMqdymag2A7", - "a+cXpZuRafyUgxE2L8r2Nvt2bGx122bkm9CUp56DHXZdXyDQrqkL5wx8107FVneJKp9B9ecvDK3nVWUy", - "RKu/1swa64uo/NyR3OzQ4vEPBX5D+u7AwVLvrJ5R4vqzQOSWId8qD2XjunIDNrfmZZCiwayPdbY75oNf", - "UeevPfVdIefygiUIahqrAuJaBcAQ1ZKGpPd+iGGVBc/Z7vSfY/ttiMZPOwht/diUIMPJ6z+dTt4EyAMe", - "qQxcdRdudKz54f854+lFw48XfKrpFVNTYTjBIGfdejUukNET/MoI0UzJeBdK8ywjN1woM/BUtJryhZAF", - "S6PSM+DarnG+/avo+Xb6PEaAuy5uFGXtjT9Mtm08AvEChV25XSkL6ppCdcu8YIF/j7WHC28ugbX09PEO", - "Sm0rLRact49KYZvLgmA/2/LJVkghvzhmvb+31DpXzx48SGWiJn6Hrh5oemv+7wAMlvt1d6e+TdLZ0SH+", - "P4Bk0Yaro2ej/wN+mk7T377/8M3obhgYqTUZtUyCOrXe4iGiXoNyi6KTU1FVnaxtkEcPN1rTjmipaTY0", - "rwwbOUQ996i+WiGYorEts4y4Z3B4GMe8M6cp/S3hjtE4taETg2WaFxQf3UFvmRoHaBG0njHX57uqgDxt", - "YMAMBtwv9TbPDoAJ+WVp5UW1WGGl6868FRu3gOR9cImJd0lvysxpBourkOVi6ZIma3wPkzZ76bdtPf1+", - "uT7lDPygfaRWddE9sTDVmXd23QXJAF1lEzLT1KZAy7y16avEws4qi45Mu0KNWXj33V3PIjMErlu+xgEz", - "ORW9M7lj+uvIDqHA66L3bYPKfdI3B7XRJw5tgNlHSMO3SHnzKo0yss71rt3UdVaaArYtAJoizfGvR11D", - "qvePVLEUxeNgrK0Q3MICUqGacw/PsYL6AB0zA27vrSwto0XGGUB/h1VaLU2VzWlHTzGR3aiRS5pcLQpZ", - "mjtAXsiEKcXFolfnWfAbnMGHKm8L4RQGVEbOpGLpGbbqhwWzCNHBnC5ZJsXCnJbJFrmulrQ/fIFpF4oF", - "POzPc62qTdei8IZckF1o1SbYRR/XJW8EguNvR6Il6+tLw++Pt1YZPQ291xaRm8DXZvY1YxiCWrtvB5+G", - "7vUWP+Zlls0s3OFdiK45QBWWwmLIpA5a0cmyrY/iyzLLGo3393JkkUr2dXDeWtAdPDBNPQQvxxqrVWDJ", - "OQ/E0mvFwTeE7hSMuaKCLlg6u9whFPA1tv2xKyCwmpYdxflx5jLL5A3WQTYSom96r33Tzwh8727R6Dbv", - "eQ9Nd4cHNCgCXT+ZibyG8hV2MTdTe946nMrj+8x2Av9qwCZFEEQbuElbc7aJPLQ76AHazL1wBxmfMwh6", - "awAfbEGmhzxQTTCbXbNuNlkhtdA3eJK03jbNQstz3BJrN7Qd3tuKo9s2gO0j8Rh7cRi9c7YBXbd5OVpN", - "/f10131jvY4R22uxKNgCmHkp5ZWt91UwmmE2Dzoeg+y6TaTHGmxf6qQawNfeMRbNDCya0fuecaMFUKBM", - "1q8lm/kHIfuA0qqm9GsZvBqF6SQbZxxpPPrDBFPYR/sg8juwAGo1wn1F8MAGaimcuJ3YuvM6ldmW/HWz", - "1h+aIPjwXctCHnW7LP4RlmEYDoTeqrIQe5vJMqMXd5C2jrgT38W5HabLgPIfRso++GoNH8YfUffA0eRf", - "ADeQVL289VO0aw0ER48FAN5AjQMY7qdll2oIjo639HYDDZre9o7/YfNurTbEccYXwjEuEhLkfsa8YNvM", - "ugRyJqB2XsYFRhXDdUISKtw9Amzh5xhsAUFN9YSJmyVPlmTFKDxYUU1uGFaR8wlpFJJwbW+EXbNiPRU2", - "i5Q1k2+suYjQt+SeoZhX2NBA4H0IihWp/3kqLPK0/X1TwWvMhdxYkbqH0ceuh6YptWuHTWtlH5Wptx/u", - "Y7vz7OirG71N+50E8BYd++gifFStnYipGH4kWgLe5zoPvlS9cS1771VVLrU9IM708lOZbGd+Bd8HgfGO", - "/++3LC7Xmu5u6/4RmJrDOr/z9d+R8TXh8f5ji2r3mArDmOs6qtkSnoNLeQPSHX/rYhm82QgPCxx5tAm1", - "1keaRJUGrOG+/eYZ2hCv+1eSaFBpVlzj82KFPXf29uivkZIIHLDfAwcJFb7IAYRMZtS6Sqo1cElGLXKm", - "ohY+We01n4SCwZHzMhtD3U2bkbUqM83zrH5PV2RJr8FYy/hiqbM1Sfkcrj26qrqMVKt6lNDZkbkUYd22", - "0bORrVITjQByhnp0q7ldu3mrty3QYTvd+UFrthhtFVCL7N5SS1+7O1zvWOSdr8QoiWm3oponNMvWhCtV", - "ohnkzKMKkSQt6FyjUiBLqkhOlYtubVdsNN8GqifYfYfP4/U46mrEDY8e5CuWA9QHdOvcTObTFRUlzUjB", - "rjm72XHxgZOLgil4ibac3sjCc3xuDZr6Rbo0pzeTN7HyYn+OsCu2+3hjH2yx9exlAz0vx+Gy7rgXz2L3", - "kvZeDFxl1ZFZMb2UKeTEAz1TUdtofTfSGbaNa6/2EI0dU0Nrh6FntZE3a7U2Je+3Zv45E6k9wr8r0xUT", - "aY+quwtmmyE9Jn4s0S8tg4CIQCA86pcIKIDwVhdKBq5IWrIJ+QfXS6LkKrhHy6xEvcH1twrK9UxFUGIr", - "EBytGTZECNK2lQLZ3xaq9s1OW2PTbTN6Kgb5M/pEzLi+EQb6Sdqnp333bDN314voFtMZeBftm8gWWyD0", - "0wxPhB1sM9hDOLujpwjrownixd2ThLE78jxbu/gBu1uQ8sqKBCOWCXNo040K+QV8V9kzOGwVnGwlJuY2", - "t0A3aJ4DMh+xh388FRB1YJNJvFmHvViaxq67CgqMXHPqGr2lt3HriIm5LJLGnOKpCfjlDnP5R53OJatM", - "ZbVWmq0QUERIjcZK6B/ztwiIvJClbo4/mQpLGQgkI4qdRW7EtqFAjWExHTsdT2ieO8wbFYJFTcWSXjOb", - "25bJJJgmuN4QFienPG0hNmxjToXuzZgphSLgs6/WetJ41/qUxVprj+1DYyitLocj5TB0YF1trdIUnoeU", - "vR563Q/JTTd0bcEIwMq2WaRB69vGT0xESinNC7naW/QLDu5vv1Bgqk16nOa6hfHw8OEjB/939Az+/+Tw", - "8Og/avlstECEU7m/UFKRbiS/i6+DiH8h0tZOg6WA6UT3mRTzjCf6RVEMShylimETo7Kbek5TDl6QinY3", - "DPpJlHb35uqLKykWz3RBE/bs6OGjx0+efvf9D4f1UAr/8ePDHyqx0zWM88lVv7rMJ/hf6JUpSH16fPhD", - "7M3lPfBH6R+p4urzl1aO0t9JYMlS6GIdz8765fT8Z/Lo6OnTg6MqAe3m5mbClZzIYvGAK3kAvyfYDWah", - "TZZ6ld0nNMuX9OAhsb9NBWRjO/RNfSMPMqY1ZH3BBxajBNJgMiUDlY3OPXHNBHclq6vt8e68EdVVi+l6", - "WMt6++X44D/e//YQU96aVy+Efz1OUylsIYehEtw03YgBOzys2ccQbx/dnASRUDRND6wREAlp/hyQP6xk", - "GYisAOw+tW17wBXCT+o8URNygg7c6UhxscjYdERkQaYj52KdjmpJt3vobb9gjMcAAAoZk4qt+AGG1BDk", - "Lb7sBhn9NtNyHW4Lchp+MhUBIJqHKiQXiLx00QQ9xD7AwDB94OAuELkCOMS6rCEnv2jsFSiEmdAiVXGP", - "kK8oqNpHcIhq8IXvA2P9je+7hYLUVyW4fsRqwT/BbKIKAsSZj2sFVIfdxGO9j41y0lyPdgi8hc6P89zH", - "OKpuzJXM5ibb7Q83Q66aGBYTFJP+darjlcC+18AjgL3T+w6i3v/fX/B+mcfP2AUZ3yEJ54wWuiuAHYjH", - "BD+haaIJF+jQDAsYuJGj28SITgcJaci8CePTdnko3ZAI1gpgq95RLEVdIsEzMCByjOet2ujdssBbrLuJ", - "Ad98owTwYemzvd1Ltw3NhFNsiIMo5sqvnkilySVQDwW4HYURpF+uPZhvFV8fwK/CbnNfKKZB+14IeXPh", - "MW7BBQXiZ86pHgjNsoW5aHpt2Iw+ONhPdOJU3t6Kv5quQUf6wSwJ7UIO1bwtDT3bEnJej9P/LBXk5+64", - "Oxu9bFZTewNp+IstKo/Juz6pe6dMyB2uDHbXL2pUqMlXVbWzqopL38D0sntn056GjfEx2xk6+LqTP4+d", - "POeZ+XjgQr7EVpXIRNbCHCN+XAy0j9xPXvEV160eKoBbnrjcUmV1mv83eGZ8xJJ9Lqn1EkZDYSTZ2rWu", - "+Wx+GXGRl3qm5RUTxuiQpQ7+/X7La1IDyLN1G2odqnkJIVjBc/6wPQhzfYmdvLavqq2taH93wQDhZpx8", - "uUZ3XnBZcL2uvcYdHbZeMwt6c5DKG0FcgzoDyCt5wwpXsgtes5Z8Ye5P7vtJGErAhT56isSaA2dGPDz0", - "RelDSn0lhPEoL4tkB9DzM9sM+OWiJDQrVqoxhTO0FfHdjRK7qSp7HNO+1VTcq+83V8vgQkjBLu5HBPA1", - "5Rm95BnX61kuM76LnET7JejpDDuql9aVYuYAGEZtA13oQmauzJOHKkqkuSJhzzZAJJFClavcvnbWEw4u", - "gjEudhT+G6T+SUPi534JK42Ts2JWCm6sSKVnYNHuquIc844mh6PYrcZeDHJWOOFqBvbeN//+HaXVInRe", - "ROgFEMLDyZNDvKCGStX88s3R4eHk8BChNhHWxoWTmV+fmB8nxGhIRLtx5YIWYA8YdUIFOXSVOOpXHHI4", - "NvRPxUV9L/8J9jDhQmlG09baH00Ou4qyJeuovfMR0RWBjTMs59PpUjzXZg4vZUEu7LO+haF0QIQX/qAj", - "B9Q4ErLh4WWCeiZaEiZUWRjOFgVLNCnYNROQlpjIheBYWwhrcbRqxdhd11C0NXRgRJmAmjN6SfW3tmIK", - "QzW/yOQlmDQ+zMQ0hK2BuKsdZmpDVw60W925hbeeHU3XWh+bn1Xs5XigLYm9bzQNn7ctwurSOliZxlW6", - "d0M1ByCnOgQuIstyRcVBwWgKgjh09lcuqKnQHf2NiSqTJaGKTEfvzslzmWW0cE8VL8pC4qPHUK/cenUp", - "s/is8LeN84pPxLpCbA84rdhUvpmO4ET7KeGE/ut//i/7g5kaTGyHO1sX2qXb7g7dZ7eNbgN8tq4emaYF", - "U8Od48e2Xb9f0fberFU3Ie+cWQ/QbiKtEkRjpQv9YJ9A70dotLMZ9xP7mT2EblG8IFpv8Au+VKxosZ6x", - "lY08iaKlmE8IfNK5N0c1vBRo8AL6jCX7A2gB1YgguktytzuwkK5+HHTU3qmuxICWxI3IjAEBqCpAiYvu", - "9GF+DgD52tbgNaImnCCMSmrDdr/8dcssiwm1m8hygFKbJNaXcaY+8izBcm6/iSzvXptWm4BYoOuqKIRD", - "/WrXhIDziMAJEBHKk6XdXlzVi/A2qwCMmz0rTTVPwh0HpFYgGp9RERR3Txp8hO0ivBNcm5tbhP1+d+as", - "OIB7HFyM6pXEjb4h0xHmSVgzg7rSy2G7MZHFVExHWbaajsyRz6S8ImWOnfoKUa9evca/pFRTs5zVmuJW", - "WBSyzA8u13C/sAetJhzcgLsJBbspdxEJuEk2+pgtpM0gsQtdHwctOx70qy987ahSVa9MwMHPxQuc8hUT", - "ikvR4wj+LdKsRupPdMVS8t/Pf/7pjOolYbc5ZNlJAZdwdqsNSfaKK8vcqBbrefM7DtWM2W4wp7+xtfIO", - "AhvPY1/FFVca0oQwsE+gawR+LUXKCpXIgjX44D2+firfTHy5muYWBFJm3TnZSKpbWQuG7LCQg8Wvhwfm", - "hVzlerRRlkDvarbXCGh4QVbcBVPhEbY3Hkc/jguSZF5m4Ii/4jmRWep/ahVbGQOm/JIrLQue0Mx+CQ56", - "BxI9Gf2BqmHBrp65FKg2PZEj0jwh6Bvz54KLBRY/BdZ+q+CIeKm79pHg/jvbXhZElasxodeLMVlxqE2b", - "kpW5hFQ7VNkaBxAWZ66pdCrCy699R8lpYV2H7lvvpLLQWQnia1c9j+vE1x1+7oaNOTzQdipqUtPxwbOy", - "Uf6kOlbfTPzjzQ73aVvnKxDptePfraDOMio+IkLXN9+sqMxXA2NRN1lzLloygtkKZavDul7w6efyYlnI", - "1cxQOKuKye6pkPhVo9g3Vp1tBN1YvuELhGo8QTg/eg3v1rSv+tsNLPV29mtJAaEtro7sm5Q/xXMMKAop", - "dufYklhlBmOV8pfGJsRI4QMXoOliiTGQa85ZlvrzK1dcgw1vji/EFLeaTQU82tgvx6QUGV9xs9XcZFpE", - "WZdY9aDm0VhvfaNR7J3t8w2xwMPb3rj9cmV3kbK15y6hqa+Jt9UJsrnUzz3WZK/rznZvtVCIDVIqVC5c", - "tUTNj/XGoztHXg9zE5rEfJ4Oud85Uh+lxcfE6YMsjEfpu0+n4l8sSh+OfEeEfqUblM209AWaoSQTXeX2", - "Ll/LoyXHVkGpG66T5VTIJCkLZW9FPv8PgKMaBRsm5FiTjFG4Q7nq6ly5NN90aG6AETtnTrmtuDjFtoH8", - "PqvmGCmYnBdyZmSKWMy2zR13ke55IQ+wKSRAYusg+LhxpM+qz91I0XTkTjMxeHhsylG/yt2S3Zcm3EW4", - "28bb5Cp8saWz/xA+2s/XVtmy5DEGOfxIM7pNTd2I9sXwgUvsgFyua+/X0TikbC8R375cWXCxxbAhlpKC", - "L5aaCHkzIc9Zwa8dbHiSMVqwFKMdFKLbIDrNGuRIxhcco5ssJLbhMSLUFGXGGhhXRxACs58SM13hqK2u", - "Ldzb3lkIMXOXZlO6+NbLEhgrpCZrpkP+TsgpeoOU5eRU0BvKQRa7CDdgNewJWdinBDIv4TGgSltwsNRh", - "Vnucp10xPxVDxsH+et8sa+c26KjzCECcz+ef1V3R+jvldQMBbwsqFIWD8bHsOikLZa7bd8qwgN5d2YZ0", - "7sYzu1mPq0D4Ae8fUjBNi7UPzBPGenQx1T3C1g+2lXCoy6ztr2Rdleh6g/JqXUQM6YIxl8P/y+n5z48f", - "Hn3XjRNgfj1ww4VAAVNRuxpWCAFh/7VPukACpqIHJeB5oypsTVs/isAEPOqACbCUfP4yKLhL/w4CqDqH", - "EYw26NkCylF4fWpNOacLtv1hN5xs0Qhd9BN3Zkdp5E/wQkVyfd+9OXXhGvAFgQGCePWc6uUomr20oTuo", - "AbFtb4Ld9vdmPujqTZSZte1sqYx2UA675rJUvSO4j3YeRfF/RkSKvaWxFPol8FFwio8OfU/orGituG0B", - "HAqm0r0Hqq34P0pWrN12GHCGnzPNihUXTFmXNZDuIpQq6EQtScF0wdl1DFa5gnyM8KO+qKZvc2TGFeiX", - "d+YY+eDRaM1lnBbUvntHFgHLD/cPW1vpjUO7gsabx45vAIiB9Q51BG0OHntzBhZImFHvHdIfomuMQVVf", - "gKyuKjj+HrK6WZ1yxwhW75RscwVr+2wuzdcudROj2D+8tzGL3rw8efTo0Q+VIaKlzNSEMz0HW8TYHA+K", - "eWI+uk9QcJkFNXecAyhwYX2yXEzFu7cnW6N5eRnoewq8YJYqYgg/eGt/a54JN6uXnGUpZvxh5Yv1oFiE", - "8YbFa2TZ/7qXeIe/w1Mz3sOzNWG/ljRTZMGvmSBvXp4cwOwrblfJ91wQ4PKH8Wih90gKQLUHGS4QBjOQ", - "HHaH9MgCmeRU6jDasj2zKmNK7cqnbN98qoj5GCZFkOG6smplOG1zfEEO3HPj3LcPsRAbMSHHWUaqM2Tu", - "IlMhraP0f3f5O4TdUjgJUrAqvdYVB1jltOCqjsrlOEPg+BN7/sej24OFPLAzscnDE/zR8zL46ICvzIUI", - "LWhztRktuF6Wl4CYJ3MmQCVzWf33A5rzB9ePHrjEZMO4WJh5S9RGPsIHri3ftmhVcd3clsVUuGQrD30R", - "it7Dox8oe3w4P3j88Mn3B9/Nj54c/PD4h6OD7x8/nD9+SL9Ln9Jks0/Wl/a3Izniyd/ixXFtpOhgMM+E", - "5jYBk9h0BAhZ8HF/RAIWLKAOUbdpIlXSP/cq3V/rTW/Gt9tLfeKvgexfA9n/kIHs/6r1ObtC8e2SmuUE", - "n8Qbpizy3AAFhI0wEsGdCViQX02X3ZfWDrgm8zMp5M32T9WtWdgCjY3L7d7irc9DtGkzSY5bl0sMhd4T", - "LvSLChO6NUjs1r3VAg8uYnps1sKFvhcDl3qYnNmE5bXKSwDZMQPap497KLD/v/+XeLFxf0J+KrMMISVc", - "mI3Fw/DPgVPhM/LBEE/k6tL5ieW8Mp1gE270MH66ILZg7ja9REfzGZ/D38mKKeAPwmsEfDP8KLNsTNht", - "nlEusJLCuhojgcwBw7NLgBtUMruuFZfac34J5DD4joIweaO3q+LU8poVE3JhcxUtboLLZ5zx9AKvSEa6", - "FtcsbSxkG6XnzkDo4VZ3WSZXTPdP5u6A5AeRAOdoX0e1nnVapSsE8PYtEYYEjFFk1CKxKnj62l7rEXcN", - "O3GoOvPRjpJQa0O0TMcQbKr5oLMBdKufsyCm8c59DmflNc1PNWvjRniPQrN4S3CM7E7wrvEVvQ0pgUeO", - "msEatHXziLB5p1tGBC37eY1AmIjjs3P2cxVyuk7s9j5cuy8+X9+8u/r/Lj55n59tNz5st92ytD+ZV/6l", - "LC55mjJxx2Up/Dj7qkvxKF6XojbOoMIUj7oKU/yF6Voo3xkt6EoFvv6hkIBE2hB/I8sXCAVMaCPe79NV", - "IbBE9YUbRl/q/iIFu+NdY4bY04Y5OoxvGDfEkL1ydNi5V4whIAyp9iQfJ4nDfRlwV4BGYT1QSjDpqFtd", - "LqmaUT9YF+B5AFqBq6uzNRQ9xaY+VMKOMhVTcWGM9QtEaMHYb7AW0VWDF+4MymXZaEeI83H3A8ylhMKE", - "aMtMRa0FaKeCrazp7PY+uQC+XFTVIAMnUSmq7hFbCO0jSJuCyUCsZcFosmTpmMiC3EPgP18q8b7HyPOx", - "mVPBbpe0VBqt87q3oNKYf/W8iiLEF4yqIUmIHfvlDXbT4xnCgYJqmW5ZU8nwjoZ1x6LLSs5kjj45m3x2", - "Ue0eQK6z7O9jhCOxoWaCbfg+KjP65jvUwAQW0HBvwOUUuuSXmbU8Q8iZRgiHw3fpszI/RGrG2O+I0kWZ", - "mLERhJ7d6j6WHVfDRVgzDCq8l5Edgv41TZZcsAqGjBlRjBF8PWRjb8buUe5yU+/3r3Vws4hjHgbqG+O1", - "7XtzAVLAFXekDN5i8bDIFmPs6fLw6ikTnKV+o+EOC4vEluJKyBsxclhFIItmVgSZuxe2nAWyK/irkHo2", - "l6UAH6ScoWya1WOum9f+appw06kU8fYHCBraTWAEMcS/5rTQHGpmqxKmOS8zsvCDoYeqx1z/lzhTFUvv", - "5ig5kdThvnWy3D67clZUbvrCB3pRAJ5My4SleMHbeMpO2h3HHFFf3EFvLFf71dsvjjWmWvt5TnnmIK9b", - "R9r7xapzusWJ3C19Dc+kloRd06yEigs1oWMnkAGyy9xvFRW7LlR7bKf9byfgNo2t9NvYSuD9C97bP2Kg", - "lw4BPRwnuNDbiEIrHtXmIrPe7K2iERuXnBC+Gcu60mRJnJc2ACn8x9JYiLCV8Ru3KnaZzBHgLnGnMUiy", - "ZMmVaoMtVzaWm+xpjUq1OenSr/EW56O1nMM25qvGjgtkiKrt12qftvfkFVtHricvDEMZ1hPEbLPKaCMX", - "V2x9AYAraOYfBDCADmsPP5pMxWlIk81eQ997tag1mxBuKwWz+QjV6wwot6m4AHmmLgh4kWoPaW2pSW9d", - "Rq8FPG8n+HoBbBiBOExdc9pYLAx4uf26vwzqCwxYdn/hcBLHbXyYQce6k9N5hWdBs8zXI5hW5o9jtiwW", - "VPB/4hHC1dBlIVg6IWcQYeNREIACyL9O5GrFRGquLxCibXRgbeUgDB34C5H6kqYuXuySJlfMXF9Zcc0T", - "prbdo68GTP+jt4nzAv7NkLK3bbCTm9Y184D6Dc257bO0dWkE4hLfQNUYou3w9OcQ6tEUvts+X7cnbFTD", - "h25b5Dn6c5uOYjzzsRQYsIzRxlGECYBjggeamyXPmLHG4OYJG7aWer4L/c5P1kn+C6Sz29O99ROqz757", - "P94i7YfY97FccqHJiq7tka0uD9U55Lhr5mWWwWsi/vUGHkXZbcIYnkRWHCieWheO6rcfux3zzDGk00Mf", - "3yI7OedaO7nup4tu44810FqZBx0P3q76PEAeaXMFrWnrQBVuc1sITLydX+O6/KIfIui7gZhVPleFF07C", - "olfUhvjlVpMWrOYlhD8WPjOJC3LhfF/mpwtwCrJrsPzx71OBhka/fmq5I/Fxj9xQ5aGeejjqdXBka9qF", - "it8InfINVzF+IwzNHNCalQ1rzCxwvxYQ88t42yfsjS0jkyGbR3VbKJZl1rItsTQn5KTTjEPoGG+aY5Y6", - "549UdBU6pGWW0Vyh186hbLnDBWSPcTvgwgXLW12TDaNYSpYM73LdarhTvrTPS0TC7jm67a2PaHPvuFBv", - "jyWQ7b+koo05/a0KzwM8GGYswc0+FbDyyLm+/fgOp0FoG3vWbcfAVxFIgRoHYoK2CYIVr1MO4Xzumyr7", - "J5WJmqR8weG1xQVxKvP3cuWi/R6YD8yXD344PDw8evz99wdHjx74d9MHxYwrOTMjzFI7wgxzDyZLvbrv", - "0Bvr8epnR/8eZgXZWYxqmcZn9/78bDpN/xv8z8T81/0///v9P0f++jr6139E//oc/vo28stfB/R9fv/P", - "9//8TXijbHI55u85tdiTL64Z4DR8lqADEKrAxaJG7O+AOHAqrmnG0zOXKXmylHzLp/6G+oeGKmRAExeq", - "dW7DqUII8q8ls5/bkHPIeqm/Y9qo1o7OaiLRPsJUbSE3xLEHU2q26qrMIm44jqyrskwVQr8ETjf43/db", - "jIAyoU7spUzXGx2LwRwUHAegdeyXY5s1f85yc/0UeodlT13b5so3oyP/eIvvWTODsWAttuTKPjcG7ge/", - "P4IF22Zv2LQTlzowaG98xPr5cntB4+9jEKCxhQa0Uv9mvMJ0cCrI90GKxJ2u/IrezjLkGOK44rmA//59", - "xIHj51ZLjlCsn3zJHQLszkuOIQIO5PDTrTYXwWpzMTOmnLa41LNM3rAioYrZf5d5Xvs31pVyX/uNwsXv", - "tFHsKmyzUc41FSkt0k+3R+5ArPdi3+KE38CC75Hb2zBXbbMXwzuhFGwbON+uNfwwHtawLiUGt66plaGt", - "AyN1aNO6rQNBbnWf9WazpLYrdhEYfmeMR1zN3FBczS6pYk8f2/+2b2TwD3M5nVk8B65mThjCP4xJ4f4L", - "EGngv+3Ggv+2mxL+uyy5HXf+ayocBRDpgQ/EVQ0Dwxlw/86qfEX4HrI6R87Ho2YFW7Bb8xNO3Q7qYLFm", - "gukbWVzNasVl/ykFm2Vc6a6vE54Ws8tMJlfNL1ymshk3uALuYl29evX6RCr9WqYsG/qA+Oo1wXbxiOb6", - "19VLXuUTSVk2JmyymIzJdLTI9cHj6cj8Z5LRMmUHjw6eHCgpBNNYDXHLGo4/BQmjjTH+cvbWjXECY5BH", - "kyfkvHuMzqTCmAALeXmG+VVDUULlVZCbheW7IY/TziNlQq7sNTyHh/ArJiKOaJos2cys/SxnBZb03gsI", - "pumXmH6BRlbRQO69O39+HysMw+A3BdfsLkaHjnuGx6rmex341HTZM6StnL7XMX+GPnsGRUVqZNNex33j", - "uiWyn4LmyWiwPcKVniPz8zUrCp4yhIseeGhweaAUNiAlQOx9zooDc1BVThO3XaQdZULeIThGjkjaIEvH", - "eMamAkotVeVR5+YIupaEZmb3rwm75UorUs+VbHRFqEgrXMUx4Zrc8CyDqk7obG1172N9of9aE5vDvI8s", - "gm0re2Lw24fxyIPQ7q800z/w4YWravKutogfrTH2npIBIyOz25wXTMF4sHSzmAY7oUIKKPWEy1u9KESV", - "E3YUV1GNuDvsz3wa7SkPdMlWs48posgjRU3ZIAAkotLDLo68l9tfHlwzkcq6Ht+sO32/AY+rudUSGxv7", - "rUdwmNkNxoURFTQCCoaCJbJIxxX8gHvxx2+87LMPwg5Q1goMeLcL/vzJcGROHDCMB1CY7Adge4iAIPeq", - "vBOa3dA1lrR+Ph3dj1Jzp7IElzMiSHoJ2btgQTKcVCE/40Ny9diMv8NbrmNdP617yCu1Kq8utFoDrfw9", - "YLCg6Up5dtKhjc7+6cRadPRKzA0a3knBWHCN/aklGVujV36UgWPzhJ1j2+gG9LifsMMScxMyxyxKw57f", - "vF8FEC19Ail2pWrqhi7FYNnWkiLdEC+bdMe5X4iO66oyx7Zg7iIWaI0adyvHtyipoR/R06Jx5c2NNPza", - "fVbxa5ebd2WououxzJmgHG/GVOhlIXOe7Hzrbvf/c87E8Sn2f9zb/7Abt0fX6ophCkCgnj5qYkCFcOP0", - "4J+HBz8A6PjRh3vVPw8ms/f/W/Drf7Pv8f2oHUgYUVoWzAfaATyMcJBGYTGO0hWmw/AjuML4DzFWqMCK", - "YowWyRJ+TwqplO9snRtN0yofK+cEHfPk6ODpo+A9APM4bTQ1AnRAKM4UknBxoa6kECzR+I8VU0v7Z7Ny", - "EHA1Hc2mo8lU1KvMMnE9ejbSTNkwqBqywpMAWcGuXmxdudJQzlHtNzfbsBKYh5X6+i9TfXIQESgCjNgX", - "tzSEgNikoEN02e1w5VojhkdxcMMqoXqXWX7oWLKTJS0W7I7WLMHO22tWzWU7HdY1q848ehyYXK7DUMVz", - "X/TApZITWrBn5qcDcmHV0QX8wxaEg/+ec0Ez/E+L2nhhmjTj68M+fQA9BNjm6OrwrSc9yyGV/pGqO1sQ", - "owovTf8xrBeqZ8OS9bYENfCDmvUww9TxoPrYUdWDuSuOYJ4Q1vn5BJ6aOtCDLdRUx3kYDz4e7eo559jD", - "9uPbY7JpKYJKM3e7IDoY6PeC4QhpaK2Rw6rYYYUCJr6Fqu4D6TBD960UksnvTIj4/mMgeelu2s2xc8Aa", - "Iu+6uYAhsy8qqAuXhI6xkM9t5OPQ/DsfKx2AaLg4YJ9dEa/N0o0W6YLL432WmR5c7DA2765cnL7cpk44", - "xpDJd7bTOjNrXUnLvJBznrHZl2HDQVHlXUfNC76ixXrGVhajZ3APiIsQpBHMbBrBjjR1nT2IC76jPeGL", - "9EPh+56c69lQD1xtal0iGUcFKbxkIZSeFwunzydDceUirN08vhvH8mMnn9AOUwYkRoAZMH+GrBtHwmS0", - "g5tsp7lbSGm0lWTxu84eCUBa8DTd9eRxFLRCbDGXO504ztUMtYPls9MUN1g4HgLxLgSMS7CJZiXvJHYh", - "omo3DbWjpuliXOhGvSP5XPe47sV2H7CFAivdVkVkk8WE/BmddL+4397/wn59/6d358+bz8d3QRA+FZ8+", - "b9DihkVaIJSq/QZ9d/TA03WMIvPD+18SKTTlQgFlo50eX4ZR5Z9g6zS5PyOX0Od9x2qm0i91UvCPSIh9", - "Kug8aJApdUcnDAM0O8XT3vlhA0Iv1+SK4d33znZnNRRGVnTy9yyjd+WAMDb6nbiZ/0U8xuflpefkHS2B", - "CofYaOEPVKk7NYKL2+4td1l6v2/2v4yv2fDlOrbA1pC5UKuCgs9iKZtDMc+lvCFaIuYBPFh5hPbgxhY8", - "PbmfcRRVNl6GoXTg447SgQ0KTwkGEryz6GZ1MH8bJzH6ZuLeqy1fvpnAf3wYj4DAmf1zXshVDpHeKVTR", - "+svTJ//x3ZMnxy//cfy3v744+v/ZexvfNm6kf/xf4U/4AU2eR5LtJL1rczg8cJ2kzV2T+Jqkh7vIsOld", - "SuJlRe6Ru47VIP/7FxwOudw3aWXrxW9A0dhevnNmOBzOzOfJ23/tH/3jx1e/ICTJ8x44HOnTTGbwmmzZ", - "1vo2aPIB/xq+4C+aGiSaL9zaYZTQEp7FYba/cAW7CmUggcOgZrMrSNA2KOVma3NdZMDHbOzf+g+AW7cf", - "cGst4Bdv6YzF5G/v3709ptmUsEuzIgiEIQm7zMyQrAeuknlqznqg9SCZhr1vggm19jqOGHnwEi6FBrOp", - "AD+2dEqF9ZG2Sb1EzJSOpGKVdQhkT00A1CRlKBGa7LZ4NUbOcBnuMG1JwDzlFAdetCzBt7IC83StyB7g", - "7KO5wGxdVqjrKWQDcuNHQU0+ajbOAURSf+YpkYm3upHX45Go4IjRJCFTrjOpwOMWb/NUMdduPLxNsG43", - "BOLspmN41Y+q6pI1yIKqKEBYFScAyjbe7zTIAg95Nod1/hCWK2BZdD7rE3ox6ZMZF9ZjZkYvQ1bUVoVx", - "cNkK8twEkJvo35NSpV2mQlsWun0lFcqgU0g9FrbcLw/eDsoJLoq4nkPyCvKg5iIbidLx6tbBL6UZKJ8I", - "a14M5YfXBZaQz5Xx1folpaIkBk/a9MnDshpyZV2icMxDZdAslY9qPHW/0osJhhzbCHXD4ODA1OS+BwO8", - "uYgpVh/fCV4KdB3g9Ogr3eLKwD0OaKgtOWEnNWPbuEJ2sMCcCyC5RgK0DYTpfjTqsf9aDzsuRr3HAUKx", - "Pfh8/GcbYFF5O74t3KCfFRV5QhVvErIfQKHyBUq4WaBogegBnGSXigmH6A5wo7W4VEUAKTejWciNxx8O", - "3vT65h9z5Tk+eAH/f9POb9fIwHwYUlCYxDFQ3qxWVEKW338O/5n70yRcLBytWQyI4e097338cGRxuIIW", - "ngQtfFsEhdX9hlXirHYg7Sp5IudsFNXNgpeRAruDa4/NaF2kv1WWcfWZhyTbMiT+B2sAeYMlsReEYIAi", - "ky0AtiPh51BBhLM3CpFxxUJcS2j79Hx+WpZGi4H8wiGhWwY5n5fo8lOvZF04WSENbVX4B+QaZNlGyq0P", - "1EPimdGF6iksq2mHUI1mGp9m+fXh20MrFf5tCrxA2NmRgERwz/f2vnz5MuRU0KFUkz3T0sC0pB/bDKRF", - "0wFQeWy2f8aFvWAAzdkQzWY8P92GSfzxwxGUg/Z9GKZuQW7cDO7gIibJ5HCZyL5SctM3JdHn8gcGks/q", - "Fp+qJ2nJLLrYYOVsYfDqNMhydS57QdaaNA8QJdskbLvsxCtB73nv4Mnw6bPv/wTrfNXWvnX3orJbZBPk", - "Ak1ZAF4jFEIwJMJmaTa3+cRtMmvMdt3VxSrY4A3D815Nau+OFzp5jpWXb00QvhWVM2SXW8MlV9OUH9Bo", - "bzQaLe7yetBogw6g3TrX2e5WQpp1aT1tOs8rHFZcTNASOpZJIr+4WOyjROY2Saj2sdZ1c2gh0UsMJ+3F", - "cZYapecXliSyT75IlcT/H0wL7B8lxclzJHD299HB/pjGbHAQ/cgGz+I/RYMfnvz5+0H0/ZPo6Z/+/PQg", - "fhoV4YnPewhGMED7iBnuBVPazvJguN8L3Lu8EBmAScU6YZUkQOU1p/yk1HqidUVqKizPKZ0nksZD4l4I", - "+oSPCVrzCM8C89Pf3r97SyS6jrUCgRdUYQYF4E8ia7Z/H9mP1paDnBHuOJy9lkrJO3NrLlhl1EMcQMgi", - "/B8txahHuB4JasjHae6/fPhwHN5Aq3UMMRdGsdrXDmDnZoiW8RaGk4IeC8XwrdPMjMZTpsxHSODu8xXn", - "itfMckvHsTAGVBePImUzYEcSX2Jh1svDaW1eBcABM0fvlymHt12kwSlNUyaqNsoKP4XrMwhTcy0bXciH", - "4TXIsmTDNcgWbiLIkgjCWRTvTTlGRRVTsF0sG2Dh81mFrTe/nTvyQZQch9EFXaIa45a29A1hxdRIPPIJ", - "AOLCN+lxeahlgbRkyFdzGl2WM92nSpAR+sqwgjTIGyOHLMuYO+Jvr47I06dPfyzPYoEEXcpC7TKKcqEJ", - "SiJ8QD13J5STXXbNFQNATmeFkYpb5A0xGYliVpWVl7Mh/jbUcsagpasY5n2gfEjyWLMgs5MKcLiZyEvs", - "svVgL+frXjn1in/RmJUPe4g+th9L4CTlwz2E2Fimc7s3T192K6f4qX3yuMIxXnK+X1Qz8FJvKPbEFvt2", - "fXQSF5Dj8c+X4ZPwkjzSYUQDbG8I3RruzgqWQK9ZNg8FuSzxMjEIJrhWcMOiB3CApWqPZIDvPNMhnBBc", - "Qpyj/9WDDq4wKtubOy1itNG5ywWPLbBCG2QS2gaxmENOwrOm/NK6mgGkKlh+95142KSFkWVOUoabHC7t", - "SQjKh8NcTdRVR7Sa5IMm6ku3AbjVooHrw6w2pPOxOKnE5y6DHFBdwUKPLAhod4BS0+U0n1FBbgpI6VuZ", - "vZK5iDcMlP9WmvtvLuI1oeXvP2tGyzf9vHL9rAKZv/+sDTLfGR3qKWLQo8p7iGij91N1zjNF1dzcNCMO", - "+jb6SJRxWkajwf992h/8ePK/j0ajof2pJRnLuwDjCSE6P9BLQ30rwyUGLQ0SdsESgtcGktFLS/3+BoKZ", - "IYzQsYp6tai2kPVWK/QJ4zD81KnuLq2kucKGYFWIn2gWyBwqeSZnNOMRQDsX+nKIbsX1grSR63WxLGnv", - "zoGyOR2dBcOGbAGnGb1cMU0E7uMineRFdYMwN2g5N4OXScEHX8Vy3YWEHFRbHKXvs4wii38sDW+TkFWB", - "q1aHDF71dWrb5dXydB3TCXvDmt5n/E0sLeAM7RtXkHTcoYWCD7V30Rqj2ar8UlPmDUwjHkrC4trlc4xf", - "DnTK6GdG9XyQMaXoWKrZwPpYFYne+B9lkRp4aqzWknUFLzd1tbYq++erwlhdRy0bEngH1XbFLqiVfMHG", - "cPT/sFfQ8kqneOov8Ulije5IqTujkU/Kw6uOv+MyHydUQOqpVZ25XL3q8YZ3ILMS5+jOSSEuyAY0CExG", - "1QfxryQcBSOBZjGbpwp8awogQyMo0lxFU6pZgPOf0IZU4NRPpZOAgBl4qYUIAY1vBzCy2g0Pth4H4lVN", - "KPrg1n8n3PrHSs5OIQwpNeTXfZ1KDtSNJPWZeU8zYA/owPrxFuZVpDuX4rWZKULqe2XqF+2tz2l8VRfw", - "Gb08/W9OYa/b7lZ2Y4qjCqgmnLfzJ8aJxt7fFZiOvJLK4WwO3KXBCxFIDAo4LEV6QIQ4BU/FWZ5kvFbN", - "iCImiuxkuQBMXxYTN5naoIYBik6Igv2GXvpKvSZcowcv+e5e8sssNQ7fvNHk0MkucwyPBtkRzWgiJw0G", - "mbbb9u/VLpdBnnfzJbdHWV0ENWoq7jS+uX7ahaKxE19t0/3NXRzMO2UGuaPlUTxiN3d9Sunvd7RAi6TD", - "amtUExiYwAESeINxjMVNag3XOmcbMKHqTOVRlisWO5vMuk2pb6wZtYCAgHljBsvV7aceUK6uVKTUqOX2", - "DRKKlV8cQajqvVTJPUUzFlEV6z1wiNnD3DV/h/esVgR0xHXrbtKtYF9s0Zzr1qmJnGtRICu7Elr7A+LH", - "I1KEjQTz9Dgk71KmaGYo3FzpZnmWg/mOXUZJrvkF60MA6kgAXDuWhZc0dGWhGaGYPKlG9aIJs0TOziGS", - "PkjLHeMgtXuUS+QEgiwP377orBzU16vig74IVQ7YwlpwWqK73IoRV648AXRXa4py/e+yFjHcpmN7XCxr", - "j2sHrl9vUi/GrK/47C9cMNF1xTyGEFboOlOxfOkKeCKzhp0b7rSGptltrKNU1+SSd79tiUmKBxsrnYht", - "g2A6kC5CzIWyXV+WCWJmTMDShGJtRtPlom0kKrKNPIi2GyLaLIbZ0jahVNCAg+V8EI4PwvHmCcc3NCWm", - "zgIp+RuLcmUKH0MMyorC0dd2ISx2BQShIpqCpASjPhcZUxc0aRJmptx6TEtgIRqAlw92n0nIjo9GsspQ", - "q6lDFnmnucsNNgsD6PfctLoP//X7dz/8af/gBcYJt9h+Xbs+njgMICZB/LAf+zEEEBdPpFg/rObbQn/h", - "6vUAdyKY1UkjuRSG6xpzHILVGnJAYDKZMPtDEMeIbrdzQOp2GWfD+bi/ov9giFvzbDluzcn/Pvq/56f+", - "l8f/8/8Hi+NmQOxVriYh3Pc3VNAJi3+aL4FD4tGU2JyFZAZVdDirkRiJ30EuOTAMi4l09hyiPF05szi2", - "dkxsgWROHiEkY8wEOZ8TmStyePzaLKLSj4fQmO14QWOYXNeWwzpBCrgONYPSi6CdwPuzWKSThgUvWm5a", - "9/dSZSC8mk+AM6qjM6Lz8ZhfwkHqHnho2blES5URqWLMp6YjJmIuJkOb1uTMNBw24yjSup8YgjQlbB3b", - "zHAk3uRJxtOE2cYLgwqZ0TnY+v0JxCmkcJvNKNEspQqsXAnX2XAkfLIWIdHOjdXrY9D5+aA48h6xyXPy", - "3VjK4TlVML7vHldwhgJDMRQI6L1Y16ZFryU3BJk8R1FWLb8Srn+7FgIMUdb4LGYsigvrT/5onP/xx9ym", - "u3vcWQe0bZsyUVakk2juYiVF0AIaqpz1C+uRfzpyYUGPhBQDkSfJ479YLyS7MvUaI0HPsYYp3axRTrK2", - "+XFNJrDjyshW0bqECbvkkZwomk55hDk0WPNiTjLWtTepnFonu/U8Egu7ThbNM2Far22SycJJFl2tPMPF", - "3Yp2Sm1QlDsSqmxnsN/Q9wRe0WyYEc0I8NPApY/0z8sgrgYxcy+Z6VQBopC9D4wEXnwxx1IYcHRotM+X", - "IpIgYaGdF66ZhVp4fS5NC9Q8C3ZJo4zcwFk0+H+2JSWRDcRsxYOlrfM5YTybMoWzlYoEwnBIDpPE5+zi", - "iIvlDsS/uOPI1kUbQ3C84GphNp0huAJN5ADHjleZYekuEhQZ8FkqVWbdlYwG1pvwbJqfgx+sTJmwkSyy", - "+HmPpnzv4umeS/PyrencsSlV13f4bORo2AwbP5B+lfSLaQKpkzKlj8Q1SN1rRc56aHrGfMmWBpezQ63c", - "mngi0J+v4nNn/e0KZxg0RlQV+Mr9e83o0139O2BnaAyhjKUcBOF9sObpQdcKUX2VsQapChaPdPuehtWN", - "fvA4vIMeh7vx1rsZrmiL/QW9Ax6OxHKKOUAAhv/A5jAFb0BSdetr89H7xyL/PNfhtsnVmpxSyTHM3UU1", - "+gX4QjVkk5HJBeYP2jze+fr9+q7lFRc4Vobb1C+dd032zdohfHO9nur6wk5cn8Jh3HgXunCwu1kujIW6", - "8SuF49zpIhUBY3WJb0sU0YbDFvT/5QdkXdB0GZLzJNjxsKBsbRjmr+TRR8EvmNLwlvDRvsf8Gtqs4MN7", - "qTJwPfOPGqqSAGVhIrfw8WV/8OeTT/uDHw8Hv/zt72/eHg8+/D7498nXJ99/C99fYMQNp3sV4KVkC1i+", - "XFcxD6yoRq1mTYA9cJnEvO1gDV22mhoqPa7fsGA6cGYFfPN2Cd6vZFbosKvrsjTA2uzAzgD9hlaGhfYF", - "5I01GxY+CppnU6n4H2zTgfqvBURYQHyxITFq7w/rCNk/aA7ZDye3ctT+QVvU/kdQKgPU95eXRszR5D3L", - "EPr5aum3sRY5l/EcbiSgvrqcSQx7ISmdA1C19t0hjLzNyGnjiUcCAorrR8y1QO6P0YB0bIdQTLgV+N7c", - "vgT70j7oeipFHGHjiQZLjzik615k6jBIh8RinVtmxgx6ueDZKSBsWklhQ7lGAq8Y9YX2FVZea5zfR8Gz", - "I1O/vqrenpAyNTAdWezPEj4Y4MiQET7Gj3roaT3mlywu1+sTqUZi1EuS2ahnRFci5WeSp7ZRDw/iIUZd", - "Khzwn4mJzUHFlM3SPTifh88PQ/KeZabNM5EnyZn5KUoYxfzgl4g854fyFwifgzEwesGIIeRcRFMqJnaN", - "awnJnCx1LTTnhraEA9lqrkY2Njs03kqDzPhVsfeAJnXz0KRuo0WrnYgXZGy5GmkvaHApwT+kKFlHipLm", - "zdZMZWj7vxKYBzz55NDMjZZYTgE8XQ3hHOb3Gut+AN5v1D7CImX7rx6SIxuQPepZ4++oR6QyZyY6dY16", - "4dato7Vba2BXNGOnEPTWbGI33wl8rxjZu17qUPn5zejWVFl93XkJ+raXxUejEbhMUqXBn7TzWpq6PI4v", - "aEavyHXlRpbyn9PqT72wWFldrHTpbiNe0DTwxUejt2EOSp+Tcko1oSTh4jOLi9uGHxehaRpyw8taCXs9", - "U3wVLm6ew3vbylUGbqtWB+sabJe0Lo5ayTFPrni3KLfRQfZiVuUGd0Jw8IE8FLzsw5raxpudAm+ANL+d", - "0k3nkG1OrUy4x1S1gizB4FHJzYzCHOR38ulIXM92s12CO9zlkShSJJlhfpHq8zhB9I5VhvlPV7F5pK5b", - "1z5c07mYFAn23IjaJK5fwGCQfU/h7ULXcT2O8+qCt6GhpQxI0/TUgwBcQ1w1vXmmaSGgXHpm73VR/WjW", - "A/fg1C30ypToJNfiFMQVCvN06PMNG+5CZCjnu94vSaBqCzWMKJzlT+Vyi4RvkT/5Olu/dL/dEtM4NvfZ", - "1bcd6y1eWWzdG8rdwpKPPg0RvbSpjpsuCG7ZfGf9HqZAn6+SkNrWsM90J/UVs58XjBFn0188WNfQw+Fz", - "jcMnVXxG1fyUzdBm3pCbwhYhUKSVwoKNOcYKL6HNptxNmk7YqQskWQnE3pmEsVvA/T8MGqrT2xuapnDl", - "lUG0JhgNWYyoVuhM78UihhhZMxImjy89nkCtUrdNJ1P7yeOzCl1N6BRZDG/BFfsu5KJ7yCJ3J7PINauT", - "XTKXFWx8dQ6+Dcx7Sw81s28ttqKCsR0yKobMW0ODorPU5QUK/ZbJIUoX/YVn0RTBYTS+HWQIORvbZ1Cv", - "pVrwWXKYkYRRbbMD2GYAg9KS3qpWKsgJ5yRTOfjeHcDFHHt1N6lUyVMFz46nTBhJGJcMAvZtq9kokCo5", - "sFXNBLB2cE+r5JQ9Loq7nuqWg2YmxNG38543jF+F/Zw7VJdL2szqD7opPZjVLMyepykAC8Eblc8jv+rO", - "4rAO0xSbDg2Rh9hF2APxg6tv84P0WOOZUCKERqKsKKLvrdbYmI4Avxn1ZbgUNgoeKcayaQuZsC/DkNgg", - "SmQeE0EzfuHAWj12k1kWJ5MQLsmCOfs2RuLw+LVN8qPJXOaQDAFwVawWrPuYbci+tkP7fWjXBs/7DYEF", - "T3jE0G3UbmnvMKXRlJEnAMeUqwTdXxBtmsJXwJvGqnrv19dHL9++fzl4MtwfTrNZAqzA1Ey/G7+3Uwhc", - "aLyb0RCWYQ8KDuR4gLMNZFKxbIfHr3v9XgkraghuPqY1mvLe895T+BN4E06BjkOHJsjJZ/44YVlLZlea", - "JKErv02oxKV4Hfee9xKuswG2YrpwKfFbFeOiyF7gpsulsGH03/o1QoO0AKgSukT6AZKudcsl7/M0lcqo", - "edU8AlQxlx6Cx2fw72c2tz+YnbU/FW7vZ+QRniOP4UvhA39mmllHvgRSpEsYiZXyJcDTfZrA8yueCtys", - "0n8xCQGSqum41+8VGJELfd19EgN4f5gDiY2lmjXsBkbzLd2PXvO4xs5Nr9vIDP3BHVEfG7LR6OUXDDNm", - "LH1XOCu6/oGkn+zvu1QJDv2rirX5/GvHkSwIVwDx1tF5/Fu/98yOqqkzP/q9n2jslAKocrC8StVX79n+", - "0+WVXkl1DjlQ4MzQ+WxG1dwzvt1kI3eoUR0+BXIHc7ISTMpqjpPLASS3ETRx+tflIDeXM+9tZPQ29Oeq", - "mNOA+QgFT7fi2bMsaiyHDlwUCuo7P8l4vrZdtuMoGTW+lQ9TnEaFzg7WS2dNJGVNJSilbiFFuS228ZLr", - "I6lv/fp5tvcV/n0df7OklrCmzBTv5TizcYmFfWVOeFynPFvIU17llAM5Bx7EXsxh970q5XSVexikUBdo", - "z5rwWiGu83aQhKnxbHkNh3xWoaH6jq1VNjWqQD+zbAl1TFh2E0hjf1sy6G4SWr/37KDDVH6WglWosqCQ", - "9Z6UeQM1Wg/GAsqnjSatzrojslz/udzgy9fpXN4aT3gbzANrhKzhyHW7h/4eVdGUX8CR36xvHtoCAR/h", - "DbrOSdjWvZLweOO9DyqFp4QSGWyPVNP8POF62k6qx7ZAF1LFth5I9W6SqqeELZFqmi4xDMLLa5KwmJiy", - "bbZB08xaLIMbpbI0vW/GHbsvddo5NB9OGohh7ytNU7xTt1+VRJksWq5LadpNPpkOb7J0KtwZG0VUmt4H", - "wQT7DjvakZrQHQ/fJ9sFTFEOvHyteR/9mvxTkE2+3Cx8go42+DgRDPOa7xORjFn1+QGfKB4eHuDhocta", - "w2JJhykS1DCkM09B2bNZFmSSyC9mjgGi83Os+MkUPfmr9adb33PGkR/Orp80nOvpPTv4SjKhLrBQol9J", - "ZSqa3kOyaVXr/YuHLehGNTccCnyNssw9Z4OXj6HUucwVkV8EVhwJVzN0OiZprlKpmW59RbG1B94xepPv", - "Kd6XGvrc0cOK97kNx9JE5eUSt//FpUJgmyf6va+uL3PBjaTOBufOlW3BWS91BvkQNHquFRzxSqrKLDjT", - "EFKhmPPl9CGiImgIsnfGfAwBHRk5Y+MxK1LUnUFyvLZ7SzDuLppqMeXrqqutJ18xr64nX1HjfE7GnHrh", - "N7eOV4vPQZfb+JOpCRHfJ3/9+P7FGo9CqbOfzPC6nIT9m3dpxPFzfadP0OvdDSq8vQbps9SHwPXGa5Kk", - "9TBEXufb5vWTjR67jjx3fOK6YTQetu7jHThnPdlt4Ii1MT3hEdp423XFNnrZxU7W5YsH99vKnTdwxnu4", - "+fqb79KFr158XYXzOUQZdbv2fmbzk7/O5oP4fABpgdd278XR7P7aawdy7669hXCoSye/O72T4IBdcHOE", - "3d/klbEcz7yryyJOtfGaiHGWd+SCaAEsFxJGy6Fk7nv2x5rDXaMbXdBfF13LNf3gTLdezdxOtfvu95s1", - "jwnLbs6O7u9EAtyTJ54VKAV916o+aZqp3RLLpjzTrnRc7YZYHzzVWjzVYFnWehbuoTW+9dYWys6BK3xn", - "ZahN9NNOmmHioXsmUv27DWI3XFG+xqF+vkuC2rScbUh2tVuRuwptP0jgRb7CV2OJVcTxHk3Tgctatgon", - "DXzFO8RSLUk7d8NOtbRwjT5VzflBH7ipCzfRNN0AR9mkpXvRlEWfZZ4NNCY77+D/8AnzjR5hXfLe1j15", - "5OLiYxnpoe0BkCUQCUH77h6PRGMSPtuHJrTWuM2BLZOERZDYw4ErzFg2lXE5zaSyThY4f2tHxvmhm4ZF", - "gx31NMvydNQjMxmzPiZvwk6078ICe+iR+MKzqRlSNKVq4jAq/H7x2YzFnGYsmdsusSEWVwfrcRRcdqVx", - "nuWqjFjpth+W5ZVUZCq1acqtoJuQ7hPFYq5YFBr6MbOYNzt//O1XzNzEZucsjlkc1M+1zUUTJZyJ7FSz", - "SFn8Ai54xmnC/2CYYnb4H1i3uczVSASiY4nPClMDSwyDKrndDbFc0SzsWqFVFCeMVLxb4+hhmi4cm86T", - "rFElguJYtanS7bKoblGmo8xsEZgbkeipVBlNustzNzYnxo6hvhsiiJ+Pmo1zwP73oqYk+VDatLSUSZes", - "JZsyrkaiLA11n1isE/u5llKUipjQKDI/2gI2KScjU64zqebDkXgnkjnKOm1EXS1bdjV9K9cudXYmCSXa", - "5882vRVHR2exVl7zuy/U3HscTPtGirbmEXYScO1VH8RcJzHn2c6yBdHrlHagey2PQnAvfbY0SDEH9RdK", - "hu+0K2KB/6hiBUgviwnVhHFIQTdOaEbGjAFuFOShGlgoKNdFWzgDSgo37nX5eWxUpLT4keBKLXRmWMmR", - "pOQ0MiBnmDbrFBMYgssnfPCJwoMPN8XJIyCxwJMD1+p87oDqlnlunqEzhy1+8kmy/578FReob2Gaz9bo", - "22HH19GNszzxl5epOZTHeZIQm4nOuu15kNfYw2lWSAIBswJKUIwmpxmfsVPgqbPnBFsHLoVBfmcojiYD", - "APaGUm2pqhhULa3DKmkQcU3sAJqAfssEsVGPFxjKg5PqEifVipjfnBdf5QwCxC29R+P/5DoDy8aCxAUO", - "uaso7TzgnSfbjH5mxGIWBqW0VU6Lo2oksKVzmlARVeVtrtkgoppp5C2bLTySyijs9vxtVmah0UHR8d3Q", - "X1ERhMkd+rnt2DupMpoWXbRU5o4rnY0Zx+oss0x5XD9zI5MtDp0mFY5sDJ0udEDLaa7l7bKZ0xmvpzv8", - "zDJLoD/ZSezaNbTEWDgm3c5WrsS9ifEu3XRKtLp9jrLQlUtublWUy6Y7lWUjbG7rXLQWx3x3eQinu43U", - "rAGE9+7duouxPGi6SzTdkE7Wwrmd8rqG3Q7JYen3wk6iIdNRkkhLBUSOSapYSnnsNNaKKjtcoopC+3dP", - "CwVKvwkKKAyk/ZCEz/dS7azS/K7OyL2vUbETS/P3lNm0WQXdHWO12CrD+d0Gj8jujHN/VMsbyCl7mmVZ", - "wsyVcc/h+bbbZtDlBoB48FGyqO8Mt3JszjfXWDIn41zELC5zHT6TWjwaJuJUcgE+FHouoqmSgv9R6Scz", - "PZfb9h+/8Gw6EgCVCrmSiJb2fUKxCyZyoxlGciK4TTci/FgQZIwnPJsDsCk8YFym4IXSmnI2FA4DN5ZB", - "sRB3VGBswj0vLh/2Di/6vV/LHfu+dpdi9yhLo3O8C5Vbz5I1ebB9SZcpKjQFG26323NYwSdUCLzs3Eso", - "FYTPZjkMrE9ATMlETnhEE5AwCnDFsNGZvIBl0M/LAlCPBOI963xW/HVIPoSjsA+rxfXWCDKlWaVTiN4e", - "ifO5iw1fbAEoLcxNswMc5UpLtaoloLR1W7MHhFt1M6wCwYg62QXsat9fy0CFFbYkoeCZ10rHgfXR6pbu", - "YtBQ8e4EUYW5E14WEz2EeToibnOWh02tuKjY138yZjTLFbMucdYXzq7dvXnnDciGeLKp03qw6HW/IjxZ", - "9F5GLwcAl7gw2E+qCRX8D/jjAOsOiqobJKN3Qc8vbMcI1Nj4wLGg+H25koZ75bPLeFTMRlLBldKrYnw0", - "XqQ60MqmLh0Ldn9HV441ku+dDhhquopsnpDLMtFibS5LHT9hEIFiC7do5g77c4BNruruuKLWbHvpml4J", - "S5/PHbh+13SKWPzkE/jkOSXmYH1q+EsY2ZW88cA1c9k6dMvvlfF6Xi+37YWPZiZVkefrnyXgdhyGuexp", - "n/obmoUcXWfk0Uxqw8iROcHHXOns8ZBAGxRqmBVnSUy4JqmSF9xcM13UFcVUYn3Cbc4wHST+GpLDNGXo", - "NxgmHhuJTOKcXdk+wdAzm1vMZShz5YJGt+xiukml9DXuI1DaHb5S1bVHD0fsRZKTnm/cF8t+13w5tSsM", - "VhXoyVDZOc2iKZFjxxmFnDH0d5TI3G6Ixmx2rfF0lg0bxGs3lQLgiW2d/12NbtwawTBheVvaHcBcG1rv", - "5IJb6abqe1vptt4JFfN349YDpq2X9QzupJNm9aROMR+mzBHGlF4wcs6YKM5ZCHxS5q8YumTuOxCTgE8K", - "MtfJ/PYwo+WPVdixoqW4++9y7GtXskVJ8Q1tMOmmv6xf80x+wL2+ZnzG8o0oK4m+/Dmizp/yuKue6Mpj", - "9MYo399/GvEY/mXr0xZf2SHu2lLrh3GvsnIGwqN+C3vlPq7JCQs7a3WYwu8bTeyJc9qR4xL23kRP+On2", - "p/MsdvHaFNV8Yu59xZ+W4GtjgklPd0vQtYtxLzfd+wE8JAXdSFLQNdLQIljtZZQxYdlNIYv9bcqgh4jw", - "ujl+rSSZmttlO7p2hS6JhQTKkjmRIrHwc7ng2Smk/Lc2JheEZ3XmVu+o3VHzpt4KrnKgb5WZ7p/v0VY1", - "AAB42rPXkFbXSLhl2YdowzJyvEgbhbYcpwA2y51gF1h/WIiAV7bAG0dSZ9htW8aSD3CBhUGRKdVE51HE", - "WGzk2J3lFUuSTtAjla2ZXybywhQXEevGIG40mKHIOtsl3HJMkYLOWWO8Z7BiWiYXTBNGo2nx1sFjJjI+", - "5japUuG2B8ZAVSQwGQnsEH2UXTI9JAkW+2tqn6RJHph9ykGAIxG6DMMwT18wzSfCmnfOGYksMLAURgDw", - "SxDLY8X0lMDSXtDE+aOgTcTtI+F6JEwZcBZ0jUVTFg9PWyRIsfqtXkFXez/ckID42Y+3KiW2eaLWRtFu", - "grmdYqNBChSUssgRqFiZNmGQKn5BM9ZROiTJDE63PdOu4vEyW3TK1MCcdTqlESOp4hEjvmqLcdr1MSj6", - "aD5Lr29H/PXXN+aoOTbjuq2IfjD4e2aC/PXXN6iVBSRSp35TzOzvuoyRi6i51UJZI+cN2SqRlt9hL3bQ", - "2zZWhgzVSH6wZrfeXlmjv3WQ3zJJu/cVKK6rBXM1YkWDZhOxLr/G4LgeDJsbMWxuk9hgJ5ec6ZNEntOk", - "GJatMyQuqMb+boGMPfESkClGwR8TKubLjn4cR434Gh84cQDre168ilrQ8AKOC7EmzEm8Iqmh+8NMxiwx", - "v1XewCuI0ZW/ZfJevow/aG03SGvz3L1ZMVY+MBc86TjXs8oIyfmcvH5RCDaIXoYPrbJtJBqF24RVZdtu", - "z9X9rSl899FMZ4iqTEnrJ3VHOIsOaltmkZ/6Rh3AbI0NuH/RyUSxCQyg5A922OYOdvjgDeaVpWW7UvYF", - "w9JXAmOGuoPPbL4+xQwYZ+cBujCKe3Z2e3FR8lUtQy+3WE2gaqt5BL5u1H0LRroj5y3ou4kq7BFw6w0h", - "bvdqVNF0Wu19hX+7GjBa6AYtFa7n5VoUdvpgndiIdaKVAhY6UUEt1K8bteUbsL3725IC9yQ4eQGlYExx", - "i2dTiyBA96TdUMqmXJNWP6y2Rqb3zympjWKvfF8rTsBuzhVOUI6lQuAHyHjPMnJ2GEUszZ6T6nafkUfB", - "PeaxuZRMrJEjU3mU5YrF5G/v370NNf5Sgxm7zPYifXFmqsbyi0gktWq/pjMGQIzmskTJ0fvfCYBJ6ZzD", - "xM0wR0KnitFYTxnLEHnQFIxkks+E7pv7BtyH+v6SdzZWctYnmewTF2fcPyGfnOfHKY/73g3k9DObB78Z", - "xu6fEBtmEvMZEwD5NRwObcRJ3wJuFLc/bP8Mx2OubszG7lo3yS9TJoJSXLv7EWzXd3okziZK5unp+fy0", - "6O/MzjObKsbImR/d/7hubECw6yiTEwaIOqbHkbBdBrNt6JY099riRHJXJGKj99nWBWLZD63fc/xhKrNL", - "OksT2/HPZodswHfJaanYMOi4OBKXl+/3gHzNXdmwSCb7IVOUeKLMEvA00M/mKetDCyPxZP/J08H+wWD/", - "4MP+/nP479/9yh8P4I/7Bz//6ft///n77w9f/fPw77+8PHjy9l/7R//48dUvfRrN2ICLqH8YzRh5LaJh", - "f5Jmg2eDLFfnss9Fmmf9gye13g6aenuylt6e7Nd6e9LU29Nybz89/de/D/7+2+GP//zh9z8fv3/yoj9J", - "5Dm77P8M/5AjqdJSbzLPTHfPzMnyVhJgx8H5vHV3W8rUd3Tl/VltfVdbn2f2HPTMgWG+OlNcTB7Mu6H/", - "1Rp1gzShokNMLxRrsebaJjZozIUO1vWU6W26F0zpqhV3cVTvDbGiLlmO9Vk8j01HuzZ4mkHcM3unY6j6", - "s82xknEeZeSIZjSRk3WiDZhOWw2l5uNG7aRml3ebnN+MoJGkEipuv60UN3BdFNVwhux9Nf90dhAzq7o4", - "vhWH3OGlGvp9MLFuxMS6ZsJZaJhdRBQTlu2eIva3KnQeolrrdty1k+Ni6+8iikQT8C6IchMGYM1UtvIp", - "vF2GuNOZKK/OF0itWzzi92gcL02HT+N4AMnntZYRB/UJXNdoi6rp75IDbH17THUTfTQTKg7NOjyAsy1O", - "T+3IbCzVBk6HZlDhOAbQNejZhoouvT1Zor79B0VxXQPq3NGdzfffdlbAx/uEogY06Qly+2eB/R2Wfckd", - "8Dc2kxcsYKCxkrNWFgoug1tnoX5r2zjPhzvneonYkUZAF1u8f3qCdBoLN4OAnALNtOnupPeBMPe3Lbvv", - "C5BfM8lt9567MuUHd987SvybvGKvrjltnfvuHejDdvhwsSKloim/YO1+WYe2gLNL4QNmnTuxoftmL71H", - "PoKOEkI62BaZpvl5wvW0nUyPbYGlZIoNPZDpnSVTRwnbIVMlxzxZlkDg3O4QcaVb7JBYbOAbXYt7yzZI", - "zw74nnlMVHe1kchwhbqEjQn2pdomeD//VOmHmK2j6IGjWZZxMbGmSFcb0VkzJRNNuLiQPGIjMWECSW5I", - "DkUZcSqiwgJSzPIk42nCarMjMRtzweIhORyJykfCNUm4+GxDQoPwcpqmQ/JhynVJx+GaMOAprqcsHok4", - "Vw4fpdLwd9qa0xzotWIzyoUuMGxbzZ8VXtqoH0mZC3bsUYLzbeC6conb717SyDFLmLBZeu995R1dSJr4", - "851I5kTn0bTOM5hwOEZrGgC6F+6BQmalEGys5j6lXGBORioCl+lcmy78rz4pg6kGLv3Ax2MuaGJW2/G/", - "brNy1jlluVLEH6yQm/F8oSvS80LXliqxNtoSb8r27+9OEt4Xq9/KtLXYT2UpeaHBbocUtimD2jVO/B3S", - "+f2LZ6TXUg90fu5XcwnMebnoBsMSSh2tKzyBBtnTKpEI1CdRuyGBCKUFWGPcwfuw3V3HH4SDefDFWeyL", - "U2W9On+XtrZ0E2+8OoYNbujeiBInHNhu0tc2DKSJtMLvd9zBxVT4cXmFIynGCY+y5qtphYSWk+SCg2fv", - "a/hrObdfXZ2v9Lxc0yo3fgv0+pVo9Z6o9hult06Ot0b7sOUscEzYRou5Oyyyivvteim2f2Xt7K7ghIe0", - "8eD9u6LGQTzhrpnpIioilrQ/eB7Bd5vDscRs5J88Scxe5Elm7gWUmI2Oc7gGRXhsET42NRUz14GRkJCe", - "o3y3wFqY5jGj5hYxNtMChCjo3RrmMz5rssNDiRtxHm1Hf7P7tRsbwEpn4t02A1xTf4Nd3PB5Gk2pmCxw", - "uTlKpDYXdaJyIQzXlgWOiC07anwBkQIQcaSC3KuZtGhR7g0OH/yOEPpQs9gmV0onisZM9yHjkfvZtA3v", - "5naIDQ/V9sM9Ymu7V7tnazuQu4f0tG0Gh2XcMIPnwh2eg+CgbGf4j758/TwPj9oGE3tzTw8Xv4dDrp0H", - "CnJrpbQr8ERGLweRLAOkNdz6imKbsZK/FlGSx8GbO70k0F9TzpouVzhuGzzFBnsN6aLOpUwYFdu9tn2g", - "l0cyvm9OV347Gyn0A71cOcyy0QbsqHSjfkO4g7t1GMJBNCoU9tPt9xRyRHNNmmmRd3tfM7tQtRjERn+b", - "gLSWH9K+5Qd/m43426yJMvrtBvmbst37OxAc98T6vjYiQn+bqheNZmqndLQpL5qrnH+7IOOHFDAtKWBg", - "WdZ1uJq2mbpoBj78VUY06fV7uUp6z3vTLEuf7+0l5o9TqbPnX1Opsm97NOV7F08h56zipm1t79wK79zg", - "19J73vvhhx9+gA1vsLzlcakb/XyvOPOHkfnuujHMgTOu+V8WWNXsgia5NZSH+PAkkySasuizuZNwVUGV", - "Hxas3AhtXR/5u8Cbf5CwC5Z4t+JIijGf5MqbEGotv7AldUO7LkgmskEyZEYFnTBt00X2XSKUvgOE5yr0", - "9LdRCaV3vnOqWey8shoHUw3LqY/JQ43FNKOmQUTT52JChFQzdHxOFY/MnyCBuxlIQsUkN7cgyBatCY2U", - "1NpB8Ss9JBYAE5KX67mIWGzzAfigCHZpqZhomSsoKWJC80wOYJHVjMU2o3o2ZXNCJ4qxxjl6JLQGNydE", - "8SeKpYppJsAvHPcgtbD9nGlyTqPPNpm2PQr6iNHn4L1Spga54JldqeU04PptGNIHf4U2C+OQvyKaRHmC", - "6jWzW+3Ju7ELIwzqrbvwFkdZDWEguk+iXCkmIg4/mxmZfUe6cx7uHYbgXP3qwzhMU02YgLT+c5mbGZrd", - "NvsrYmyV/8FKMTaAUEC+SPV5nMgvgBpm5NzELLOY2A0pSGauMzazJGMEncWQhW4jKoCKZjYwPiZMTEF4", - "zGVeRPWwSNo2TD/a+vfBm15IFhCHQDWQ71RJwf8wRexAgRFgUNmUq3iQUpXNDSdnY6lmZmFxS+EdwWxq", - "n7igIZxxzBJ+wSBcx616n0ypiO120fnMEGwkk4RFZmHtBtnnRecHrFhCrWVGf27eJbMoDVv0UmQ8S5jp", - "okKKNtYJhaf5y9hx0XKSCFtt8rosPYqGvWaKRp9xaeXY7pVjVSP27B4Py2YzFxLCRcwveJzTRJvCYTCW", - "tnEipiCKznPm8utY8oEIj/pkG6dXNto1HHn+RLrK3Ira256X77lhTlACWOaiRitdZ/ayqJoqaYbEYkId", - "W8lcJ3PDh0ZaOQGspZX7MzqHAB6zHLMZiznNWDIn9ILyxMGGWKCL8hnoh237bpuY9qCLU/kFwoMQHpK5", - "+VZjAamgyTzjkSZprlKpjeDBpnDb3Png8uX5Ey+AnjTznMrYbhXk+udiYlpyZWflJtFqZAbjwVRggARw", - "GqywNUMcJ+ySn7sG4MEzYoIqLnV1dXTv28m3/xcAAP//Idl255IHBAA=", + "H4sIAAAAAAAC/+y97Y4bObYg+CqEbgNlY5Rypu2qrvLgopGVtvvmtF2V47S7MbfCq6QiKIk3Q2RUkJGZ", + "6oaBwfzYB9hdYF9i3mLf5D7JgueQDEYEQ1LISpfd5cFcdDkVJA8PD88Xz8c/RqlcFVIwodXo2T9G7I6u", + "ipzBf7+U5YxnGRMv8I/mbzc0r+A/MqYpz0fPRv9DViSTREhNlvSGkYKVK64Ul4Joaf41l+WK6CVXhKaa", + "SzEaj7hQmoqUjZ6NrqVYPNMlTdmzx398/OTk26c/PP3jH7/7/ocfTp58+3Q0HilNdaVGz54ePxmPNNcG", + "jhq00YcP49FPUr+Ulcg2wvmT1AS+6l3/u+9Pvnv6w3fHj799evz94yePH3/3bWP9p/X69WRm/XeCVnop", + "S/53thmG8MNeML5/8vSPT54++eN33z1+fHzy7Q9PT75vgHFSg9GY74MBpaAlXTHNSjjBs6pUsrygCy6o", + "Qf1/r1i5Nj9wMXo2+hX+NR4JujKTFXTBzELpkq2o+egPJZuPno3+5VFNIo/wV/UoOvOFmeGDgXUN4GWM", + "FT/P/oOl2vzV/BoBJWMqLXkBlPFs9NzAvuKCKXK75OmSGKiInBO9ZCSVec6AhgxplUyXnN2wCWByh/3Q", + "LONmMM0vSlmwUnND53OaKzYeFcGf/jES1WrGyi54b5cMIcIPzNJ6XZjVuNBswUrYPv87iw/FUWY7XLOV", + "MrvgIs2rDK4NzByb8oP/k/TYjOH4w3hUMlVIoXAXP9LsDfu1Ykqbf6VSaCbgP2lR5DyFc3hUlHKWs9V/", + "+Q9lwPzHjudfT/2iLGWJxNfc8I80I275D+PRmRTznKeHB8VN3AuIX/nDOGAcu4MR8sSeqx6Dzw171OGj", + "BsTd9lYP7dtcwAnHoz9LwQ6OXzNp7/KwYsCC90RrhINvRGn7+90x6kf27Shg7U3O/gkpJjZm9y02Rvdt", + "syU63NwA8mmaykpoLhYXrOQy28o8m1OfCkL9DIaxcZkRI/6JMuxAaE7zMRFSHMkbVua0KMx3t1xk8tbw", + "xpxlC1aCtnDD9ToRt1wvuSCUGM6uCpqyCTnLpTLDqFtgXjL2d6YI14rokgqF2gZZMcNz1ZIXhIosEQ/Y", + "DRO6onm+fkgUo7kiVBCLDE01v2EktZPPaG7k8yQRiXhFNTuiZclvzC/BCkZSScXI1UzKa5ZNqb4ic5rn", + "inCheMZg+rxkNFsfmYlZlggLMy0ZKaTSLDOiAERcVZZMaCILJtzOzPbNJFc0+49KaTXFv095dpWIGU2v", + "C2lERflfzQxrp4ytKk01w0lhVTudETBNYYc/TymSdZ7/PB89+2UziT2nmr3lKzb68L59+ubPStNVQW6X", + "TMD6bh9UkRUtr1lGrnDNK/LAofo//8//y8EJuAViezghl0wnQop8TaSoh+GMyuzFIPZnka9Hz3RZsVo3", + "OsPJKLB9u8pUaVrqe90rQAhb5YJrTs3ZPoDTdDv05BNskUiRiCv765Uh1MF7NdPa7blNl4wecLOngpxf", + "/nz0/XfHJ0T7jZesKJliQgMnNNfXXHC9JrC6+VNGNesC32ZIbXXp5wK5DQn+7PTAkilZlfZevqZ3fFWt", + "yMnx46ckXdKSpkb9NSuu6N0rJhZ6OXpmfvValNIlFwuDIiYOhp4XInPwWXp/wO7SvFL8hj0ESN8JxbRR", + "a3MWfsYVuTIEcjUhL/kdnB78vJIrwwmoJSkeUNQYWRlfmUs+w+lKRucaVdI+MrEg4rpm+zzbfevvXp0/", + "h213zjGnM5arbVLpFX71wennHc2fqyKna+Dx0YP+kelbxgQ5gevx+Nvv+k/78bffjUcrLvzpR47esP4p", + "zReG6y9XXXhO3U+kUsifzaYqzcgVDF1StbyaECuen5GrZKSW9PG33yWjq02HcMloTup1+yAz03eBOivX", + "hZaLkhZLnhLzDYgwYCmeoibE2BrwY2okrAp++0aReSn/zkQi+oVkW/4RJWihllIbEiSUZNZI40rzdJwI", + "swaXgmWEi6LSxFj8VNubO2MZma0t0vy+LY+DP8KgqZ3kCs4aWWKc6RO9pNbXMDP0YOZg2VaUA0L7sN0A", + "oYv2v+IPjizNkMZWJ8R+4Q6igYecaUVuWMnnnJUqEYZlyqxKGaFkyZWWJU9pjrMa5YTARYZ57AzsRuY3", + "TG3dIy7rttGz2XsVf8qhGkRgKlcrrjXLnJDbcKKJgCOl9RTbtusFHYi9Q23q0kzW5uRgpdec/KW0x8NL", + "pT0fb2io6PHiePfqv3qpaCTohLyUZSLYDSvXRFUzqx7bCceE/VoZ9RQAKdkNl5Wqr/EVyq6rCTn3YkCK", + "lCVGymxEndtgLQecc2lX9LUNhEsc30XmmVVncz5n6TrNGcGlmvjdAi1MDb6NXyteGkPsFyO5rCBp6DkB", + "Lfhdva8nO22bJaOIZ6W9ucBvxbI31r8y0CQyc5DCTUKcl6ari2dUg30H/qFtIrVjp9WOIlqWdG3+vWJ6", + "q8Hod/fafNxGNYBkJ3q/A74uPTE1cfAqQgM0YirCDTuyOtGzhlVkbCWQS1V6zfSE/MRum5ZYSgWZNW0q", + "rpy5BcI61cCD/NUuWBlcT6+LGSWMijVeUwDHKefPQmHJnTgl//k//x8iJBExiAw4Dhi7biLMgFmlIzLW", + "SMaAl94wsOfWTKO8C5jqqSYrM7cUzNuU3Q3VZkVsTyyzSK7VUStR3e+Gy4xRVrt/GBAfANN36odBMxOG", + "C2UPQw0JbFzDkcjbfn3DGU6BzpGIACElI17XNXeGiWplSNMc1chbd/a/WLbxylvqi0nH0yxD6T/E2ZFl", + "R9IY+Lm8VYTdaSYyMMWqmf9MoQlvbh7V3DDqIqfur/VaiSipZikt0dhrGemfuTGHVzRd7w7djzw3lHNm", + "B57JLKpj+OufrkkqM28bUEA8uMudFexAANsyZ78dumD1z972nc9ZqvkNm85LuTqMQrhksGW81HzFasUQ", + "j4vMWCpXTBG/+IT8zXxiOJwqWGp05GxsRiTCDgHPYVbS+Uat5oWbEJ0gAEZzl1p+oj1yZSRBLsWClVs2", + "mojmOP814SJjc2Pws3y9276ZyPyuD2PYu/fJKdLOztqhYaPnduxbMzSOxfCT5q1WE3KGkjwZGc6es2RE", + "ZEmS0arKNS/Mv8Obf4jZPoxH12wA+3pjL+Jf2DrGMMg1Wzun94ofVYL/WhnaLNFEpNr86DwLPDOMY74O", + "GRs5Dz8xVuOcGfaGvqOcaqY0uQInObtyNl9z40CiZg5cHMQN3Cz3dfCKaTEJu/lSXTpGfE5BfsafX83v", + "BH7vCpGdFG4rst5Qzc5oifq2RdwbP/eoq4QPtq/MDeo1qsxWmmaUI5kz9FBlZEYN2UhkS6zFGg2uHbNQ", + "z6y2DQz26hm5aoqFK+RmGlQ4+NBSXOdLklTHx0/SfyVC3qJ358FVyHzDmYgxe6+EvLWDSOPDh3ahMl3y", + "G1BPGxM1FtrFdByPqiL7DZWnnCpNEIR+heCG5jyDkVNWlrKMGlAK7Pb6U4Kf7ky/F+B30mdU01wu/urn", + "sa+E/aj8a3vJCJE3vGdzWuUabulGT5rndSIt2YoJQ7sRcWrPD1gCF0blgal7oW07wMJIip28CAHBoFio", + "t9cWi4Hq6y96gxVFbeaOiIwyLN4r05yRjPLs6pmTcDTLUKTQhgXiXG+pNfyc4Ns+cCVLI3GowNGB8YVL", + "myOxkwU7bdlUn7ELBUy+38ZvYpZ+46T6cLNTCuJ1gi4WUAPcrvd1b8R2WM81W30B8PY5ovrkJwGNG58r", + "zF87ohCeLBqiKhH1LiYtSfq2nnhJVdOHU1SznKsly/C5Ba8gy7hhck0p+7bBCJvj6A3lOTh+57I0mmJH", + "cL7tsUq6I4OLDRsYjUcIg/kPO2HfBS+ZUsPpAUZ13BxcR6ICz7heNyx981UEFnD1lAOU+DMc0ON7sL+i", + "24EL8sv55c/kycl33x2dvH+w1LpQzx49ur29nXAlJ7JcPOJKHsHvFpAjM1JNlnqVP0wEzYslPXrs3ozC", + "/Vi4jebNBTvpYuAlvDSYHwOaNRgMp3llfj6JIcYMfNyd9ZKlUmQ7Tfs4Nm2xlIJN+4IlL8yvERsD//4T", + "jorNKpWm+dTgLjIp/AhH0pgT/wwHGXv30sYw7u4fQmRkSYpS3nDLl0L1MTJZLBjztCg+XxFnjZbTovht", + "5Fw7VHR3ByFVLvBw/I+2uBCgBU+b8c6bZjvHERf1gI4s6c7Z3c972JEDrENRRl/LaJmhmtw9OBsJ3gk2", + "IMtqRY2ApBmwZXZX5BQjpZ27KPVPCDJNK3QFuGc0jD+cJOKt+X3OWZ6RFTWcS2jKzbxwAI+cf5JqamZb", + "sryACSrFSlKJjJWwgUTcLqkmt0xocltKsZiQFwLDUG5oyQFCiG6HgAD1a0VLRmYlTa+ZVhNyuZRVnpEZ", + "A/F4w41mSRVJRpdGwzdwp1SxZATCJ+MlS7WBwMxlgHl3PklEzK5r3+o6fr6Nz3fWsVIyXZU2MEuWJcsR", + "o+fPyYym1y7ozux+7FZH7pyIICIfDc5gginP4G9sQgDhBo+KVAbz9jWjZDm7oUKTXC6UQScThJK0Ulqu", + "WGlsRVnCUw/hSlVsxw2rDRrNv719e+HUmtBPDoQ4Ie8Um1c5GlcFVcpFKjgmk4iZzNYQ5rLkeUZqusWH", + "7XkJoa+ZOR3yulJGkbHoxdM1W0Eza+Nmgjh5y2i7d0EtZanHeCWO/JVQ1WpFy3Wb5sm5NgMMwQmpE5Eu", + "qVgwMrOuJX9X8L3RDRsTdpeyAmI0SC5TmvO/w9FOEuHJl9wr9epesw+OjJjfJ9snajGx+nULsBtckrHj", + "PsHr2AvLpbpM2wqNr8rdV+Xud67cBfpTZw1w4eQQiVSnA5h1Mm4+Wxm1CdWEFYa5Y3aAZqWAqLMbyVP4", + "6zbV7YUdc+6HjEeKimwm77YPvrQfjmGfsL1tI/C7D/4Gr3/CpCrAzofxSAq2+xNvOOHOAyzMu4/ooujD", + "+43Had2g+3gzvPlMi0KBIJjhtCgDS4rP/hA0KoSREPbxhZfZUUFLvSaKlTc8BbfBqZkkpQKDPYyGJY0Q", + "pwWd8ZyDDM75NSNqLcy+UH0Dn7sRE5I4gkqEWitjEoxrMCCzomdpAFzTO5LSPK1QtRmTjOUcItLkPBFI", + "okyNw+Q7OScFXa/MOYwJ0yk4D+rUlvY1NCcf4sUFS6xlhRiCif2UCC8Om9TpfJaCGle2QaJexd7wsv68", + "+6BOi2Kyi7iOP3H9FDxt7TrTsNfUml77nlJD53AMhLaKYN3W1u8dTrblvljt9bm1PodcmKKolV9Dvl2b", + "NsYVh+MohDHOECKGArfppQ7ApVFnjeC8Zpm/XMTD5bDslajOFyiVkNV+3B4c39wDcHvxWsC6CT/sfNRd", + "NA47+y56tpFC/fq8G+rcO3QHSfgDsjljp0XOMuRL9r3UQddQk+wSu6Ptsj7/3XFlz2wLftzPU3Sadw2I", + "9jTnzyGOoMGnzSzTk8dPnn773R+//+G4QyLh6JjWZd/4ppZtT1dMLyEpbSNIdpRj9gRHkfPnTdiK1UbQ", + "emeJqsf3RU0RyfbRFHSwy3YeciuCkZmqAWtHLagvhVGaEbVOpYDHjbcoYYiqCuu+IDN+hCYwBqwZDWVZ", + "SmGNaVJQbeAht0tWMvJzwcRrplmZCLtjsqKCLpiySROgawTB4nWulL+5CA5ZUpHhhmBMIhpv71RknjZq", + "vQX2cB5iQJbX81zeQgzECabNOD3OroOvwn4dG5zrs/cA8BXRy1JWi2UNeSLAKFHkATymQO4fV6pymY7g", + "9MkeJuIxrhqeS8lSxm+YIrdstpTymgip+dzaForQmay0xxUsQ9DnoRLxpDtdCqmozt1lPRodfJ4/x62t", + "mKaG6STiaQwyPHaHWsiktXPfcIpuGfub9USdXpxDPg+A2aYOrsBBWUqwoGZrYrZr83sKij4V3GZRyoWx", + "XLkUiaiE5nmUKlIp5rxcqc5KBrrTi3NAhgH3CwywteGAVq0drFMEtk48oshc7BS/IvVaeBiYyxLauubs", + "XJBRD7hfA3C3Jp8apjwFDjE1FDs19N+F5gV8hyGwHco2QwAUiC61Efjjml/d8jy3l8nmldp5tIthvaVc", + "W6HGjMFX33djnNE8D0f51RnEkEHmOZmxuSyDSyoW1rOeCMf0YDnrLbfmX+wCa+mimxC2omQFhQAU5m1R", + "VIr8ljOu2numlZYrqrkBfu3B8ly6jQRHxxiMCzxkUZUs8/LBUBwXi6A0y0zKnFERnKLd6A7n6FHy0SfZ", + "QO6As+xCMOA0WdY4TCZUVbLWadaahBfXiqgqTZlS8yrP14mw7BagnnNBcwAiVAMsHBzCYG3dAKqs6PzY", + "8++ijpYMMqpZxqlm+bq7ZPT4f9cp1APDWkN3YE9s62UzLsfIJHSg8R450/+KYga7NxQX2hJxMrzfwWPz", + "2ceP7hXXaP1AgWIRBDD2CKcN/G6z82jvQLei2B42NvD6RVIRnjc8aDtGmXW91QOtfRxlVS+IAYNwf2Dg", + "zKY6Wntkzqg2jPar4vpVcf2tFdevMu9LknnumfCroIsIui1svSfe5syfTzOXvcFpwjOA6l8GrLDqWiya", + "tvNiupf/2K7elBM20X6bh9Z+ZkQiVUqmWMLK5Y450gzeF/D7nV6+voqqr6Lq9yCqcn7DVtEIl3OR8RQ8", + "w7dLppe2zI897PpuQR6OmWX3WxbYpCuqoBBhwac2pbVLiviNm/704hwSVoESIVeI3RVSWbsey9wY8Qkc", + "es5uW+ew5+P5V9m9VXajEPgquqM2aiDRgjvXof9tMt6g+GzJ0mtZ6Ut8ZMCH3LfsTkO8+NAASBxONLvT", + "JEMix7p+LrZHaXj1cnWt7eJknsvbiOCea1ZOVTVbcT0QkLctCHxhsfp1DF5M8DhnldZItk0AVkwpuugh", + "W3zrJPYb3PODFb0jJ4+Pj4P7+rDNsB8fH+8Uf6eWHELnpnSvYNQ2CnIpFlCW1c3roiLDl8LPDQWHOHu/", + "8S/s/DUrV2oq51MbtjalacoKH/g/FCMlK3KauvB3F0kAi5j7aBchdFEyyEiGHX1eOPkwnKG9jmojVvq7", + "b4n9mBg+CgI4KMePMfccQvCLqjTaQYd/KRzfkGBMV8VOpk4L4nfncZg7wL47R3hDN+9qxrIMeiwsoRTY", + "bgCAFGqB0QyEP/MsImoU6lLmtWbnIbWMRTViQ75R3rcXhGW7HdBKy1EgMPeG/0wKI6+bgA8RZW10pzhh", + "GA/qnsxonHe2IoRKVik29fdrP3Vs9/1e4OqvYfE3Zu1Tv3QsK8AeojmqG644ROCug5BXF2wE26jZxMRG", + "oq4khGnc+67qlWKliDHapxWy64ZAhP1qVQkbU+KOFG68UdiC9GAtybtLsmJluqRCK1vESDGoZ5cAmSaj", + "cU3qWdi/A65BIrQkailvAaUS7bxGfZLgRkAmDpvE2P59Y/StWe/n+aVdrYvVN3gXlYcX4rtRGHXlh3tF", + "RaIB1PoJKD5ydwe9e/OKcEHWsiqdZfacquVM0jIzSNdcLNRkRwHw0bdjaPLqpuuxlUdItbff5UD7vXAg", + "dI/e/QRmaJMrhMpUL2f4JOd1EaCwB/ytXCxIYusKoyX2GTmcKLposMsWzNu4Vcjd7NWIwCykYAeEuMUk", + "uspfR430uiqxshxJogYUIDyIpLds6R3Yz0PFfK288HRZx/5CKrGvq2pNc1cgI6b3tUzXwGQ74K1u7PRH", + "tqQ3XJb23trKQyMoqzxq7/NvzusmiaI3aAu11DAIlXEBvE41Q2UY5lYo+mB+WzjOubc+3z36AwVfW7hD", + "84ct23OW8ue7RW/Lc4EJmC7kye3SfbBxp/uz6fhOOuzB/YJVV8zHjWwIe9kgs2uTTeV4G6Bmb37xhmHk", + "9s/iTK4K9OV3QXZfkVkIuzOwOmA2jZj8lq7VaDzi86nnbweAG2oZ4PuBGs7najXEaqMY0o+vQ9BRqMcs", + "Rpe001zxo29UIn7p2EinF+ekriJRpxNnMlUT9OlOUrl6RAv+yGHwkcPgI/SGPuxyU8uonCNsmjaNusPd", + "zF6jt3k3LR32Xk2X2bfF7G1fSTPt2AoieIto2M+OS0MlA8FSphQt1y6VMRFBLiMwr9QI33xalZGyG0bf", + "hioRlsZrzf52KQmOjEs6A/NPUmMsqytaV/HpCrLJFUm8D8JWKu08hebc2MQ+tCn6LPsOC3fWpT9t/VCz", + "2ZKlUqQckxUs6eAzLTSDqoNqEcGuzFuY1jMmKS01/IcsoTS4hKOz5Uh5o8FhmIgPWtH9kV/XZxE11IOL", + "DBfYfh5yVKcrZhXgzR0jEsbgitVbS1WXjB3lTGuD3cufydPHJ39sFa/mglRFwcqUKhYahRj05ZVz86nn", + "qMQ/lZpvwKHW+gK3Y/Y81ezuY1wqW55BYh0e6qcOLZ2/uY3w7ttHADMrp1Wts96XfrHJ2fNxSu+H8Yjd", + "Fcayt49vnUt8Fzyh1Z3CWhMRO0l4XZ8ckxUXlWbAGB8/JUtZlU5DsOEMExIyT/eNubmoCmHRle+eRnuV", + "osMl8k794u1LklOxqMCBTRcuqrwG+925c9dAXtWczHIqrrGwsvMLVe4JeVbKWxW6eOrGScmICfNtMpqX", + "+L8Z62GaLjupX+j/I5ao2KyKATVUr9n6CCoYkYJy68nRmqZL34gvxvFtER24hlqWVohxl/ymyyrVkDkQ", + "qKGTWHmVlkvU/L6h4GvLZoevIe8fEwoesMliYvCW0jJDDFZqOqPiempfSJPRQ3dIrULrVtVx+YE0z+vS", + "Rc1lm1Vme5La67piTqZOpZimDf3ygDc8qsLGPHcDdVi4gYE7XzS0hEoZDQHfUuutTcglY88S0afrufIG", + "tcKH/ObI5kUcFXTB/mS/Oqr4vzr4jgwpIUp1VYq4JvMGC10ZhWbz3izc7mxppZdG2KfUZ0h6icTnfRoN", + "+MEcPo7QmduiFsynsFks0cts9x3fzyX+SPo1tCb+xcID4GTkMB3tEKcX26Wmd1Oe3Z+u9JbenWf7a0qa", + "3kHuZ0xBsqg6mDZhX/SaNoR9n4tFy9mHva7kCVlyYmdIRk73UN6CO8KfsK92k4BdahRTtoRXvjZ/k+B7", + "TwQtiqZYrZf5GD/BG6Zg14NMVhxk5MCOJuoZFv1Dbo4ZVbVTRDCWudp4nTvVln2yTAQ2ncz536GRbZex", + "xGNWNlld8EKOtpW53pgbHlzsknnYfI2LtR2xvy0Fq8KHgT11/ryu8WZd37ZUYlveh+YWNmdCpQ0sLniw", + "6ZhdG0BVLC1ZRFc8QwDxZ1jXo98sbIvi/IfyT2f2e55FrIkNAu6+uN2BA3zf7qA1Q59BXPZ+zLqzhgHX", + "y4wa9gxbRct8ntVOEPjCOzP4vKZDLYPiR10MN2t/fHTmU1gjxN6AZgmEiH3zac6V57k1iSYH0v1f2yms", + "qh903Y44Wzsc/qCy8HWc1l4HhTuj4s42VIRi/vmaJBhfk4yIU2psbQ7LAgJJ39Hmt2iU0DClR6tsKZMt", + "JTLeeBRGbK1Y06YCLAwTmU5XxZRDM/7eOdFTgh8Z8nYpx20VqPOCOxkNrL3arCYfPbjNDDfuCEba+xf3", + "w9QhEf9+1N/IDmee7lEnaLimDvsPtPUt4rxjNsUWHOisbd9iI53IA3PMVgE0l+PhZLStdmqIrygSG3Tc", + "pcJWIDMwjPf76optxX5gqCPo9b1BWngHYm83raJsaL81errE6w6hK0J3lm0bFm1nP8wWT62vj+Y+LSan", + "Mg17d+zskyv3wJ/dzxtjH9jdC9mBLYg8IDm7QS3aPdLx+dTLjH0e5+z1uJClprmFdb+3OfuwBy9HMHdg", + "5zgOhct4c6drd4RU3sv3MN3bmDN3HNKsE/GL44XhBFte7hxnKACoR42h6iEEvlWK1QXD7D0bu87o8GCt", + "FZlXwhbQ4nqNFTFctjdBl10ims0RvXz0DlYXyNyJs+rWQ+tx+QJiXrx9mYhfQsfvMBy0HjH/Bf/H/uoE", + "2BGC8DARVmLiv2s5hJ+bO1XHr3MByPBO5itaaXllW0UGr4sFWHcly6Y4qzIft93PrrNeFEFbtKJE/NIS", + "RfeBohqIh7YujUOOlnUexxpLxlpxigVUeOlsWCNusQ3xZGip461X/GCujPrq9VzyPbGLu3q4l0ekjW/t", + "daVEtKDchwU1PXKuCSQuyP/eCtjBfe2qQ27Gxr80icwpkg2IP4FZf+Zq/+j73RYuU6eBbqr70eY9A3X3", + "vQDkWbyce1/y6Cv7y70CFeTRdVWybbKj+WQ4jLvf66YQ7oHMvn5UuVfgAhA+wparSVk1rbrdLSxwures", + "rL1FTyI2yp5OKmjU3Orw0kaeZ8PaamDRn7f552YTrL/7ou4W1m7X1PBlnsc9paX6tOizJS1j2WNeuqTw", + "wbZWAvOc6umcbavo/zKn+iVjdtHxqFJ0wabwbrdl5DvzJcS82cEHagnQhGjHIv9dYN6H3d8bmNvQ1AQH", + "99X2eOWrzwalPdxxGDbwV2h85PrmWhq0vfbwMyh3B33+nMtpVmnX/ha76pF1p59uMJ4r+xl+AvXxOl9A", + "Ib2gdp6xG4Qk86oEE9XWhAX/C7srwPuC09myET0g219DaneCNGgJCMuOfAmKsKcMopf0e6cax/BWapoP", + "zuk1txMG+tMRC/cCQnOjdhgMuUIGVGRhX9mrktF8qvmKTeEiXNlvQqOgFXgp5fUefgi7t55aICsos+J9", + "hoA0mkOlGIILOtXTvyzZcI7QOd/fBfdHBBq7+uZmu4fdgJs1upNmwpPHehfpm3bwxq2gLRwtuWGP5f22", + "q65ewFKRipzwdxv/2+QfKnLX23QTXqBvFCDkCOCFn1v1f8KRo36+ZdGy8eJIpX+kig+9Ndj8YgYZbPZJ", + "a2amCd4MZuvO68+XVm6u2bT1k8IIfhiqGcbnYVAh1kxS2qKaq0R4CJ13x7/9jQnX+PA1C9u2h1VJocqr", + "/QLTMLGT+pWLTwxe7eacat9p6UAhroyYWVtRrf5R1G90crjiO+WgyNCfqhUredr32mkALOGIHMh2I5O4", + "Vlqj0ALS0Do3cR6jQevT7D8qpffIpjw1lJ5xTaifoVEiUkuyoteMrKiojGDwX2EoYxBuD6V2zUwzmlNh", + "C+tc+htfKXaUUuWZHOhY2Cwxte6AAf11Pk1Rpy+xcmCLuACkUAq0T3u0lbQwRxsSUS9kztNIoSdI1sbj", + "N9pdKo20brR+TqVQ1arwwX9H5EqKqeOyV8/ImR1t1Mh6KFVESSnM/xq0LUoqQMF1gRhuIlftbvNsUqTN", + "qiQcajjbOnl+MsW0zuEVY9BMOKyh0AZbjB1CgFlSIGo3SGMY9CNern0UWXsv6+djuzPUbAMjvqWTBitu", + "mHS2diyOs2YI70YxEG7KqpCx8lNBuK8uObs5YOiPUfG9rLWosbsidjX0vm4uM9UAbFxjrXvs/qdtN+9l", + "JTIuFpiDHUf/HD9xEduZ17xcHQR/Y8yX9snwiFwJKYxa+ZP0M/ga9NBgkKkxRmJg8HyjpgNMqWAaWwnd", + "KqittQxJQK3KI1uc3RVcN8vAcOfK6BkvK+3rCNkpbAj6LS8ZdkeZs3KciFZBeAZ5RlZk+YA6uIYPuxnR", + "dkzgWokcWhPRW6/pn81W9hXFiAea5xIr+LmL2hC4+N4QMKespLeCZPJWELqgXCjtLAww58qsLrBPag4H", + "IQuJCJoR2Ig/UF5SWkasVLTDDqEqAZpY5nWQFdYe/AIqeA6P/nP0sV3x9Tqv5UaLBpZQ5f1aknOr9jbn", + "uevXPuAWvsRRtd4e3MnuVXDv5zH33orrzgyQSO7arLce3/2/4To33+G9co2ztIu4U7F2oxv9zX4ZcVFU", + "eqrlNRNG4MhKB/9+v6OUfmPP5C9s3U3Bib3vWm5p046G35GI+OvS7Mum7AsvywGtQicdhlHRuRV1PgK8", + "JigEkNStXcFfeNVE2ZURg1683ks7gnOffOtQ5+RzrByzp/9uzVouBmOnd2loIr1x/Rgetu8+ollu7bvQ", + "r43WhP5l1pYvSi5L3yPdRqKdHHf8eCW9PQKFwg1oXjLySt6ykkB6o8JXuiVfLFnpv28nh558h8Aapm5W", + "PD4GWO0/Y3mjRVWmS6qGUtiFHdbo0OfLYAVbuEABh5eQ9mrDiXjQvKDulQU16Yf3qSQZlaDw+0EViZzZ", + "6gNGAJRyRa4KVk4rwfU0lUpPwTd2Bbu3guMKR15F73BoiU4Lb+TvwbQj3oJmvGNoEm/Ikx7qTwjDIBue", + "hXvO1XCVuVrnA6TbPZF9ycEh72RyHEGad/oWrHTHbRauI34csURhtQm7cQriihxPvj0OKck+w3BF/nBy", + "fDw5PsZIQXg7sSZHIsyv35ofsbsjpkCvKgOquXtGuTfikApyDOpPx31NjiGrOxEtyfivcOGggD2j3RDY", + "k8nxxAbuWwtnumc1bqRnx0hsPbRLP21vpW6bOVE3qKxtLYRkuy/Bk+vYsZGYA/ij9gWW19Y95JE36s3a", + "gKZ3UzQmPwawt/QOY9di7JDeRWLMa6gMRbyUZa09Ae3WvoaWKa/G2Jm+MaNayirPyAz6vdbpUtiDzjmt", + "SclumICyKalcYNVwW7ey+dYShM229HhcGRNqUNJkY0xEpPobFDDw9mI2l8sZWEy2jjC9S8Fy92/JX0Jp", + "9vHoRhqc3GN+FyL2liqCSx2qQHzLpBlHLmmj2UvTfQRQbXX4hZeyG7ETEk77Yjq/XsEASvdibB2OuUyv", + "N8aKrJnGUqGTRDy4ql82qQYJYPP15pUxMKGET1dfcFOtmH4YiTcJIeHuYVjna1uh1FxRlvMFj8v3fpgK", + "qvTY3G6XNxgBmIosET0ge3BxhiwGr/0JjZGSrSgXhn9UAuSrdeeOE9GAAt7nDc4LqpR7XECSjK0RECx5", + "45dwfmgO5uOc8VbAjD3uMGDGAjtyV62PGDsktJtPs+bMw/OEulybNt0r0Pu7nxmTYbx4nAgu0rzKXCUr", + "JwLytfMwoys78uYRVNYbFshC71r1BdtI8KVBLL+vY28CC5i7l3UUp3vkg8I5ZazuhtgnSDO2CyQfaiLa", + "5SS3crptalUf9/O6a7921eGErmCwZ4CY6u6awgYssP0WWP87Nk37a/v+F/s08jQYXN26U5fTW2O3dvvW", + "t97gtyUViu6T5uffJnQ9Ra0JKEKJ4mKRe6a2kjcIWaf0diLC+ICzzqzo/eSrVaWNsXefhvUlXwhDBM2w", + "suYGJgSLGt8w5+egWc3ziWALan5MhP21ZFmV+gfETcZ2zqb2qz3ecmtj2IkIWwccOgz77isBXnvavWxz", + "XXnsjUe4ws4Dtrjc7GxjC0bMwMGwu0M+9Pp+3xjt18QQyGBcM/7k8zt9kmr7OhzFUVDJ6oJ1LWL72qXt", + "83L6uoZge9jkgdyALIaeKAqbxtCVFB9hg9U8wPfoihleXZ7aFaABQFv1k/aOt+ZtRDZtFRFUNX0kkX/N", + "BU69wad5RK7wD+Fg9xdz5yDC11hjc8Ya5ZBxRcxqga83JogEXKP9EkqhyJltMlQHMG5OFcHPd2U5+DHG", + "P+44xsB1qPSQ1pzD2CXC/mFTcGbIWQ/le+45F9DluzlQ49Hd0UIebTt+s5bdUE+uUGshcq4Dy4ySCksI", + "g0ExqzTo1MZMyDlWPwHjmYp1IlwufCTAt8PXnjbY2pPtZFzvYc+A9Q6tt5Nus60qUD9qfzstolbCA4zv", + "0Kd2g8h+3pXUId4GiqfDiOa4qDXMOhSzHsw2ES+rFRVHZlZgyrYKNjQrrY0dTJOPzTcmqkqXhCqSjN5d", + "kucyz2mZjLBU7YuqlFhudmg30fVqJvsK4sBvW/cV34gNrLMzuOz/7lb+kIxAPvkt4Yb+83/9b/uD2Rps", + "bDcNZIskDWjIJ4bh9dnenjSmVli1wWkXnZTOHfg3iIehrTntLatjMml99RqZMLFaaH18Z08J8vVmf73Z", + "n+XNBr3vYPd6h6scV+f9bQV45x3tikOU3laNBwNp2yqPr/5DlKYio2UW0XoaCBkHHK9f40GX2l4tg1np", + "y85zkfEbnlWQ5GoIYEGFTaRQSFfmQ1XNkI0RLUmRU6HwWQWifihWZdN1COPWniLDa23ZcXHbs91aqVVs", + "Y0LeuVBJTe/Q7euy50Fldqmsdhq/2D+j12eguyeCQ4vt8WZkesvya7jyp/NN2T78mwa/sM9grajeLzaU", + "cUXLdV8h3LdBM+FmJdw2dQeEe2EHvIA5v8QW+K7yBtW65LNqr3LwvquJmek0mChSTRa9P7a5BXzICPSk", + "gsRPKNMjmxVerNrLbuD5qgJpHZ4Bpoc2lt0rbGNLX363yecbC/5GBamTFX5LGdU08spSFFNfTnhgcckG", + "dBG6KYru6g6BnR/hRcUK4aKUc54Pdwdf4LiNr8qBNLbLBDnQQe5SJyU9rC7YnsFlovtaei2B7Ta0qdqc", + "w2YN/X6aUx3Ufy9x+fFyYdG08R0Ie3t/uwMWz2y3p4uee/srfPD1oaq2lVurFU1YRw+bEjk1NhFcGDuI", + "pVXJxq2GDFDQZE5TNiFvlxAXhN0YfEXLoMmVlkZ7j60eqMEzV4YjIzmEsEKLHtSNbcdpxH+XNGzdKVnc", + "R9/uVq/CLlX9HHYgtNEbrij1ph4Pb5dMMd+/kEKnaWXOynez8GXkoUVhp7C212BPL873blDYpv0WLofe", + "g3idyUPfhniVyfilsA0gdqsN2ZkaijQIELNLxstEtOh3bAsX2dJpbWMJXqKsCQcfuAigJVdaluuJ7daO", + "lc+w+jZvVTNsM2yuSM6FrS1EXak4WhRoNvanmx/4mmyqGrzfLemrEPzxNNrRtIbR4nAtbEJ+FsEZGgYH", + "9vzfWSkTIUuykiVz2pkag5dDCv8XGAC1r2Ysl7iyFGxDLQE7cHrN1n0V7u1iyHKh6ILbS9YF33avY6tC", + "r22jTolbTURDtbT1GyKJZSGwOyVDtk/pEldwuZFWMbF/JX9h6yAuq06ZbFBKiJUNdPJCwOzmZp/Cdd2r", + "Nm4wi7v1JczTV2E2YhCbM2++XStjpqRoouDkakIwUtTwAoPp/3b580+koKUyg+qU88YTVTAe/A2WKTof", + "Oma4BE03myWofd7r6B8kqWMCXsuM5SoZPSO/JKNFoY++xeZ15j+fymT0nnwYbfVAjl2u79Sa2LuxpYaR", + "HS9zhNOSa7aOYaGxrTrMYQV7ill+S6qmeK7ROi1YVj5k3UuqAg+erkGakFNorEzMzHDKV7ZE6xVy8Ss8", + "9avWsT9nBRMZ9A5ysUIw2PKi1ufhBl2YWPQkgvKwe8WyBIS/QxTLxnPAfW+NarEe6pBwGuez213fLQCl", + "Dat1J1uc29wEgNnhcYNv+SVC/OrV67fymvWFwJifaof5q1evMYMrl/K6alQxhSR0n31u7HWaLtnUIM//", + "47bkUPWqZFRJgZELtsYr/JcqpFBsN6DfCa7P5GBlrrWDFn8hL2i6JBlfMQF63ANruZZjsB/yMdEeIQ+N", + "aEzELEjjJ1QRxuH2UcctMSsOoqfhnMiilFVxNFsTF9sCfrREPFhVuoLAdXaX5pXiN7G23QBGpMUhLga/", + "GssSV/XNPIELIkNMc1pl7OjJ0bdHSgrBoJ+nYcPYVsDl2CTC8Sxd0vQ6iP6FNSbkdQdalLdX8PvUbe4q", + "tOSBSUd7sTbGdLf3ugdzoEAsZZ6h9HHbj+zHIh/4YCL8TPVRz0EV2mFr3R15eEZx52Vqo6YGcbIupV/Y", + "mWI9SZXMb1hmROcRUqhdFg1ps39P+BnVdEYVm5ALWdj0Yi6Iu30qER5njvrBekDkWgM5M9hcccGysaN4", + "WCkkenhqMn9NRIvybdUOxCq7o6kmK6rTJVObK3i6XTpEwOUACHtvhNm230brVsiCCcrxWlChl6UseDr0", + "OrjJN5CN+yR+KS7cFqLE0xq599UI8bDxeiSCkp7rMWCr0R1uvCdAttO9hH5MkkUyAZAgagaO5BBDRt9Z", + "12MTYakITCOQffirejghV1amQZoaFYTmnKK9eQVfXo3NJ3jd7DeJCD5CEXq1Ac01suI0VYvtJmo/no5q", + "FOzLZMMZdthgz74209JmbaoR2er1GsimNxwy1GryPPY+H1MBN+h5/ax8cMeTPdh8pJ2qU8ymBSuxTtAh", + "Um2gSAEYb2YBYhawh80FeXf5vPFuXH9SMEsT8BJf64n3ChyssAU6/KYBHlZauh/AAiYSAekcfm0AY+s8", + "3Q80OHkvOD/jzw14vFZ/TyD5+XuheuO/CABrP6m0jjCCx+1X+TWUHdzTBDklc35nb7FnOr6oyP2lwr3s", + "XdWjch/eaUswRtkn/rYjB91YCKOJ/xDzraJAje3Fcli94+OFs9TwOFz1Y5spWBoRlq0FXVktsmX3bkqP", + "MFJjqHYPYRGArZ1GtijwUJ00eibf02LZmDfR7Nox+ArlVJM5880ObH5yr1eaZjdUpGzqEyIPkmvIaJlz", + "eBviKxb2H8auFXUgIa6eYdVOqIxP02ujIIkMyo+kTCn7othn/pziHJj5afCIlIo7Moqdbbk1OEbsFG/d", + "xs4SmG7qF2n1Z9gEdXR8I06BlXxI/cCzXCqWXeCoLbEJ8FF4JPiIoYiWG7tdNMb/LiMEYzVKt592GA6Y", + "hrGr+wQlbYtA8c5teSvcA94uIFqwvkYs7hKxaMScucHDX2ktf3/uJ+hJ13a/t0tU1Efpji6YqvNS0//m", + "En0QhLnHtiKgWTd1hQjcYi/rJ5uYiTmv8nyqWHnDU3YfLMzMPyaVQJYJbdJhLcfTdr6SL6s8bw0+eOHU", + "+6nT3hanNrZH2OIwM1/FZGPfH1elle5VyxNDLrLpbI/nwNc49se+R8F6W3YVFzA5l3kubw1LQ06xaXuv", + "/dDPKF4XI1OmmpWrPcIPeepKxrw1E3SRdxHU+nT7aemDDfdj8LnzyLP94Oqr3Gl+2/1K2qlARbXdCJtd", + "U4fC9oZqdkbL7MLN12gK2wu0U+air/QRPMYHYCXGe2OEdeeiFgdM5Q1EvdhLsx3tlx0mGBSQXO1TgKku", + "afQ6rkVdNmvw704irYEfUwoybFAYR3FfBcgdwLTTjkdhfORwPAaDt2l9jUBMcE7Lki+MGc6yrmwPxMct", + "9S1l0F1KE9GYjG/pgRdCOfq4MpjDal/ufBydoQPy9vzkPknNtQN9v2FB9Nt0kycgbW7qg6ijjWbfYW6d", + "/yiMiN661cjgLzKLY6+EB18kxZoyDT2lUTzFFw0LNLUOu45rsx0L3UnOLt9sifx+wdbrtAgqubxsSvLR", + "Vg/S84aJMqAiRNPyAAsA8hubACgbI40ViyHp1uhRVJGri1JmVarPqKa5XEz8hFcQRWmsDVlhkO+V7VM5", + "5yzPxonAfn6ui+vm5Tu+rIKVqaG2WM/fC/+bt6zahhVqKw+O//N//t8nx8cPJ61y7UG19mOPe1GtZsZm", + "/tB7TrUht+HELqh9exxS5t2MadahK1ipzEUryaxSXDClAk257feD+Gc2XHDCuqd+eIQZ2NDquSyNsClZ", + "I4Ohdv5B7Xk+J4KxzBbx3cAOed03wUWRFwaSyS7hi4PCFqM5gjGWJ52nwWZDB1GMFrRe0+MVW9DcGh5l", + "T8kSv73uOy69m/Jsv5N7S++wBYXus7/wx28UyQFIh/jUp47UycRFVRZSMQWFztdkRW3DcqmXrEwE3g4b", + "PH3LvimZiwvQrGQ2S4XopVTM1sLtTLwxq6lFioPLOmLGi0W5vxFd+jpQNnd/GvePzayEbkB9e833W5AS", + "nvI+/Un0migtXVvhjGnKc0UcRIZjWrKANmd2RPvwzOEaZdL1/AE2WK4/tsBHrSueN0izx2P7k2E92L3b", + "ANciZ6hgoJbyVrhynVZtdoSv1ySTaYWxpRuJMadDsxYuoJaAjQ0ilGi2KnLXODXUwTfUFEhp5vP5dkLf", + "+eXPRk97vtkKdk8FdvouRMRImAXGuRQ5FbHMRAfb7/6hIA2M3DayvpYKGOR4v4fW093qqHWkZw5xnalc", + "MeXLugeNDpqdyuBzaEvABbnKSjrXV72NL2oKeFG7cjQtIUSJNbeq5WHogZiPsipn2Y4bLtMlv2FZfMtY", + "WwdG2C1bBDl/CRcZm3PBNcvXuyGAicxv/6BFIQ6RsXIKGh6HwEe24kdW7QvLENmOFA0B6S89OQ8/SERt", + "pJtPDONXusbhDStVqA0aNNua3XZh/2xjP3UKV8hdvuwCF0uq+prvAj7wAwJUxrwRZ06jNJwOgx9CsTUh", + "pziIqFuu02UiZJpWpUK9lGqbTpJhY+Dme/mEnGqSM6owERCn4bVWtHMWXaAwXEB/rw+AiXMcexJ4lus9", + "jrrtgItSTo0MF4spE8ZKzho9zfCKxXOgilIe4VCzATva6r0ReX5Rf+5WimUm7emJNbvc6Idtel/xKp3J", + "VQF5kTOq6satrMVJobWGZSmu+brly8/IVVOUXDm3g2LaFrV3zNJ8LOQtSarj4ycpaY2bNFt+tKa1g/6V", + "CHmL7XjChh5ahssSWSYivpKWVw/tQo4nN5bSsrHQbs7pL6FnjjEL0WXGylKW0W6jCirY158S/LQthRny", + "6KLE9FjPVeGYZoyLRSKKapZztRxwm5vOrr96IF4YGKJtve05/LUNb+SOW87ebFYYNyNo6QWBzTzPc3lL", + "1rLCHPlrZjPhlffAYRVzYJeVELD/jtURtijs3YmFstvEcO+6NfXWG37bttUTeHItn3y/2UK72KOhYlPc", + "EMj4CKQM4FkhcsGIh4+/UXUbaUXkDStR08JMksYDS1HKBboeumbe5xDqMvj5dTcTM2u94wB2N+jWgPyy", + "Ei29khiKRFUUOAp+t6JrIl0X4izIk/ZBM8FT0A6Fw/4pCoYZgpwCQcZ1qpBgm8bqEL3GvbqHJQHe+Jm3", + "FQSw3AF5QADwlnvd1zunqT/g1Zy0FAF/v5e07ocDvWu8NMAekLbiQgatqLqNvpwlFB0FWj8XLbdOW6KH", + "0whJcikWrGyVG6gU6+on4cDayMNwoAAeDX1eIYDLiVz3rgnYCLtpObAMk3UzbspBvnDxIy3pZP68LTJ8", + "nm8tgQ/zvMyxIV3J2E6fm+/Go0VJs8rIl13G/Nl/DO+1O4H1znw3Ht3IvFrtBNhf8csDhafXe90xJL3G", + "5ZABsMshA2pUDhnlcLPpxnv4Bza4z0H/4ym776bFzcZK88a6zRjw3WMR/ARhKEL4RBwPO9g3p6SmqoFI", + "LhnrQ/K+Gy0Z22+j2/ZXk+iwTfpxRHMIt0KYjWSBWgnmr04FtH200cdgH5uxJpFRxLkN1zEjJsRmQILU", + "QHU9EVSRtFpVOXTbsiPTUsJblRlFZrISGS25fZMHDQpzTVwNGmuCOTvZC/pxewLyoCqmWk6RPB4aqyIR", + "7K4A/RQEWCrFDcPy7dY9YrhkRHU1M/dIZPgpaKhrUYk4bLpZAL6P8bKYOd9yDGyPelneApxd22tPWq2F", + "zZ43E/G2jXDDUNC4g6wVDUpbXKguUDK1aTgQDjOlZcloA4C4pAecDn1yxRgLOFOnENXHb7QlFKHOwAJy", + "bnrdYAJ/3OQBhGPZQNMSSBH/9dB33FZMo1WRiF0vRXgHwEMWvQCJ2HIDatj2C6tFCR2Pg/dnGSDDkiRy", + "kjNbq1GKNPDvu+vE4Am+UU/0ZWRKG7T2UbtAtSG6C8hI3GkXRVBnD0Z51mm/HDVi4OIbCU71EHL+XQFu", + "FqgB7nqtgv/014qii8uVbk2l0JQLF+/gNnc+JxWasv41xZ2PLJg4wpj+B960NT8+bOwUIHDLbX6e9kcx", + "7M7WyLQVTCH4ymeHwqVpH4414rfetkTgdWtcI3BkYUt8J2jsBkE8scliQv78o2uCb6hlttZMPfy0Gl1N", + "uQfV6MDguF+NzqrXw6gAB3V1HbMhGyQXUj1cTeoi0n1RHIwm8ZnWeEXhkSbHRGmsaIteWnxz+QL1mUCE", + "ffHKjLVo70+TqWtxD68+buutKsdeMQiVac3FQoXNGtAPI4UuZa5cdlQiFkyw2jHYKV2u9i0RfloUPlq/", + "703Lxra6UBqXr8FVu5rs5EuInvFvE/1FF+swYVfn3G8w9pb4NRLma0PXTd2jKrCpy/1iYHvuJADvWAVN", + "dbPyug0KdStHL2si6njsL+SB9VaW1/Nc3g7G5N/cwM0BhG7+JmPGMIOgccHwV0JPAsEexsi3a4a0XfY0", + "mfXQwlNuoHPrRNk67fL0Tu8E10Ron6Lf21LD/ORQg7wO4IYSZRZ1kyBB9T5gcN6ILRBoencfq0Ovpk0r", + "t/UXeudzg7Acq0PNdoK6oAvzf5h598bVbh2a27EwKHPpe64oXuR52HZXGaZE2mvX1RJXDKfbGO/gwHpt", + "Pm5jDgCyE23H1b7tSFoa4CftStLVzwY1J/Gvo0NdZ97GseFuqhHvhpFOdXVzdPjZWg2ydEnCv3kcudMN", + "3Gbcez+UdWgWNZCCHRkpl4gHQoqjkqVVaeT/Q3zyDzJGameY2haGLlcrrqH49vBs3IKJ7CyYIJLXbD4h", + "wSI1swl2jCXkG8lt4NQ/wlg23EgiHhg7dFz7R8fWsmx4gBrwfOGVUdzV2L00SoeatlRF2R0kW+bEMyhj", + "aW8pYh8rqBKFzJVQKWup9fuJQbmPIhjW+AxfL8Y7vIi0GNG5cPXIml8GnT68ApGIHp7ziYtqROnL19H4", + "iEx8dxc3ZuRbzQqX2AhSnYG/OeAH0bWD+PzY5OZoCcQG6J9NbrFtaHgIP/ZPMKU5KXxFRof7oqQCqz8w", + "RmZsLsugJ7empVahzAJjJxGhxMpBHXkgpPZZ2gqqhVOU5NqWl6AK2uuQSmieo1j0b2yJYHdLWikNqcAf", + "tlNAT1GXPUI7Nxd82UAUexVH6cD/uj+BrAYtLJPSc+nDTzu3bLWlRXQcqp6eopuBMkLjr1Do3kXcC1mX", + "NLh6Rn6S9RwYyWareeEro7p6RhAMFtydRpw/RNKWbEU5VLizrl9Ls4mwbweBHzuEwNdhcOtteuru8sHh", + "BLaFR7b0cbakNxwD5HbLgv3Rjfgw9pm0m0bCVrK2atOil20txVslfrptBloVfgJvfIRA0pJlXE/1komp", + "dc9fPSNn8Ffbvsry0zkvlQZLQUB7cSSCDJ5VEuELn4WzGtl99azmRlilI6trqxvOtqBcKE1wSKMpeQQ2", + "9Eu5ucPXkXZ9on7C6lgTw+gqbmmEIow0akFyZT+2vcQUjKf2cQrfnq0M8rVN8YOVVBhF7d75+ioy29+n", + "h312DXeQ8xVvw+/Bq8Gqa8CFANsns3sGcQOS+6BsYH2j6LtsF5MaQC9hElx/SQORLmV5oFzT+vHNTOpe", + "f2yNb8mxvDZwcnjwbb0Sh3HS36hEePO/dims05xBUiXmsdh+C7Y8DIHEPiDipbytBY7CJ+CU5ik2eYFc", + "spUUFk7Hk85ozkRGS7KSQi/JgxNMMmI0XeKfHj4jV4+PH397dHxydHzy9vj4Gfz/f78yo0N0EyoEv2Gl", + "ouWaPMjouiYYxReCZaQqHsKS8GfMzH3gvjmquyhldP1wh+q89hC/iKR73OP0QE46j9faW6dadL+t/C0x", + "k3/+z4+/zdtfkVNxqLOCZIWecyKXDCoDNcvQtcvU+eSU3nqSuMRHpKaG13hAiuquRPcFZWLGnuj63+bC", + "iz1uSxd/Gu93k3RnVKTY222P5sTQzRYmwNQ8tVEOar7a5w0uhPZFxvVbnKblnFqtWMYpNPprldxpdoPv", + "kBCQPuyBZcRPk68nOysLZxBJ/jEorJMb1VdN4p9CkzDAtShv3CU9H8FqWa/3bLex6qW9zXJtvJUhQmJv", + "M4GyEtbFH2Zgh63CbSvyzkbmsvwEj4O7QgJ5IthnpaG0BP+8Zmsfwu4OCEKGZ1IvsRt9eGyJOH/uT6tS", + "zdDulnZzD+XwDBqC+nefOx5gEzHmuY9KtG86eV3/pUdvuBdiPZTiBfwDjuovQd1Dm4LqK8XxubUDOrKj", + "MRk5nycifqBkw3kGGt6BO1PDRoKNhZCPza6oWO+IrkR8Xviyz4eN0hLR7bcqEMVREBUhWMsoEbEaRhth", + "21hJonNZ70Nda2ACfog8FdlABdGupy3q7kaaXrt6NBPyUpaJ6NGhEGM0TVlhaMa2iM2gj7jzd4fft7rH", + "d+NPgvLHwJ08nt4PURb3jFxyw4ZpjVjhQ3/USW6swaebV8k+ctWnhqVa2d29gCDYra0/E7lJtgVUA5TO", + "gSJ2LIS7HiMwoY9wEzrBbbu2ftX1v+r6X3X9r7r+V13/q67/Vdf/qut/Ul1/i4q7o0oUKPvdgIUQ/Szj", + "0LvUnIzNz27r+Sqq6J/PkS95X27TdnClHquikJhyuo6gm9qCgA59Ro3RVSkQh+yOrgrAYuhRHlQvKI6T", + "F6JabS3UE+hu23AM8+2MZxsI7vc0tpGooHsaRFqsB+hOROgMt4Hk7E5PfUy70fV2mMgWfk2EGd3SFMNK", + "GQG+u+tsiiKKN3L6CNW8FieNBiBBRWGMO/S19zsdnRIB8Xf2Baie5RMoTjs/j4UwI+cv9i3fiJUbP6Ho", + "rbeLdQ03vVMCcLhBczR77M8M66x3z/va1hfs3MBk5onUQI3ky7RGxUXAxlks9t5HMLtNoMBoJK4dZUlf", + "wcEG0da13x0P8dX1uPD/6d72di20F8b8dSU6vSMuhrDu0GSWD4uTI19YG6GG+dn0Dmu4p3mV1WVKfF0d", + "iJXLWJYI0EyitQJgsMIt+di6Lfs4cxG0A8gdoikzpozwtHK2jCbwT22BwcgpvcZfIE2qKKAGAuZwusmH", + "VmawezktCjt1WP3y1C4RrkA8cN00vM8/3f9rcv4nSc7/vSQF/XO2I8SUlgYj2iBcuhxkGF/ciaV1eaQr", + "DDM05RrqwPTWNrHsbmk7Knimx1U7Ta5RPskOrHOXojkIdrJuflG2vTKN33KwwvZD2V1n3w2NnWm7iHwT", + "qvLUY7BHr9sUCLRv6sIlA9+1E7G1LVHnM6jN+QtD+3nVmQzR7q8Ntcb6Imo/dyQ3O9R4/EOBJ0g/HThY", + "mpM1M0rcfLYQuUXIN8qXsnFTuQXbpDkLUjSY9bFO96/54E/U+WvP/VSIuaJkKRY1jXUBcaOCwhD1kYag", + "b/wQwypLXrD94b/E8bsAjZ/2ANr5sc1BhoO3+XY6fhNUHvCVysBVd+VWx54f/p9Tnl21/HjBp5peM5UI", + "gwkGOevWq3GFiJ7gV4aJ5krGp1Ca5zm55UKZhRPRGcoXQpYsi3LPAGv7xvluPkWPt/PnMQCcubiVlXUJ", + "fxhv23oF4g0K+3K7Mhb0NYXulkXJAv8e6y4XWi6BtvTd0z2E2k5SLLhvH5XCNpclwXl2xZPtkEJ+cch6", + "/2CpdaGePXqUyVRNPIWuHml6Z/7vCBSWh013p75Ls+nJMf4/KMmiDVZHz0b/B/yUJNk/vv/wh9H9IDDS", + "azKqmQR9ar3GQ0SzB+UOTScTUXedbBDIk8dbtWkHtNQ0H5pXhoNcRT33qL5aYTFFo1vmOXHP4PAwjnln", + "TlJ6K+Geq3FqAycGy7QNFB/dQe+YGgfVImgzY26T76ou5GkDA6aw4GGht3l2UJiQzyrLL+rDCjtd9+at", + "2LgFBO+DS0y8T3gzZm4zaFylrBZLlzTZwHuYtLkRfjvWw++P61PuwC+6CdS6L7oHFrY69c6u+wAZSlfZ", + "hMwssynQsugQfZ1Y2Ntl0YFpT6i1C+++u+9d5AbAdcfXOGAn52LjTu4Z/mZlh5Dh9cH7tgXlIeGbg9jY", + "xA5tgNlHcMO3CHnblEYe2cR6HzX13ZU2g+0ygDZLc/jbIK4h1ftHqliG7HFwra2wuIUtSIVizj08xxrq", + "Q+mYKWD7YG1pGS1zzqD0d9il1cJU65x29QwT2Y0YmdH0elHKytgARSlTphQXi40yzxa/wR18qPO2sJzC", + "gM7IuVQsu8BRm8uC2QrRwZ5mLJdiYW7LZIdcVwva777BtAvFAhxuznOtu003ovCGGMgutGpb2UUf1yVv", + "BRbH3w1EC9bXl4bfvt5arfS05F6XRW4rvja1rxnDKqh153bl09C93sHHvMrzqS13eB+saw6lCitha8hk", + "rrSi42U7X8WXVZ63Bh/u5chWKjnUxXlri+7ghWnLIXg51titAlvO+UIsG7U4+IbQvYIxV1TQBcumsz1C", + "AV/j2B/7AgLrbdlVnB9nLvNc3mIfZMMhNm3vtR/6GRXfu99qdNtp3pemu8cLGjSBbt7MVN5A+wp7mNuh", + "vexcTuXr+0z3Kv7VKpsUqSDaqpu0M2bblYf2L3qAOvPGcgc5nzMIemsVPtgBTF/yQLWL2eybdbNNC2mE", + "vsGTpPW2aRZqnuMOW7ul3fDeThzdrgFsH1mPcWMdRu+cbZWu234cnaHePt2XbqzXMaJ7LRYlWwAyZ1Je", + "235fJaM5ZvOg4zHIrtsGemzA7q1O6gV87x2j0UxBoxm937ButAEKtMn6tWJT/yBkH1A63ZR+rYJXozCd", + "ZOuOI4NHv5tgCvtoH0R+BxpAo0e47wge6EAdgRPXEzs2rxOZXc7fVGv9pQmCD991NORRv8vib2EbhuGF", + "0DtdFmJvM3lu5OIe3NYBd+anuLTL9ClQ/sNI2wffreHD+CP6HjiY/AvgFpDql7fNEO3bA8HBYwsAb4HG", + "FRjeDMs+3RAcHG/p3RYYNL3buP6H7dRaE8RpzhfCIS4SEuR+xrxgO8y6BAomoHdezgVGFYM5IQkVzo4A", + "Xfg5BltAUFMzYeJ2ydMlWTEKD1ZUk1uGXeR8QhqFJFw7G2E3rFwnwmaRsnbyjVUXsfQteWAg5nVtaADw", + "IQTFisz/nAhbedr+vq3hNeZCbu1IvQHRp26Gtiq174RtbeUQnal3X+5jp/Po2NQ3epfxezHgHSb20UX4", + "qNq4EYkYfiU6DN7nOg82qt64kRvtqjqX2l4Qp3r5rUx2U7+C74PAeIf/9zs2l+tsd79z/4iamsMmv/fz", + "3xPxDebx/mObam9QFYYh103U0CU8BpfyFrg7/taHMnizEb4scOTRJpRaH6kS1RKwUfftHx6hLfZ6eCGJ", + "CpVm5Q0+L9a15y7envxbpCUCh9rvgYOECt/kAEImc2pdJfUZuCSjDjiJaIRP1rTmk1AwOHJe5WPou2kz", + "slZVrnmRN+10RZb0BpS1nC+WOl+TjM/B7NF112WEWjWjhC5OjFGEfdtGz0a2S000Asgp6lFSc1S7ndS7", + "GugwSnd+0IYuRjsN1CLUW2npe3eH5x2LvPOdGCUx41ZU85Tm+ZpwpSpUg5x6VFckyUo61ygUyJIqUlDl", + "olu7HRvNt4HoCajv+Hm8H0dTjLjl0YN8zQoo9QHTOjeT+XRFRUVzUrIbzm73PHzA5KJkCl6iLaa3ovAS", + "n1uDof6QZub25vI21l7sTxF0xaiPt+hgB9KzxgZ6Xk7DY92TFi9idkmXFgNXWX1lVkwvZQY58QBPIhqE", + "tskineLYuPTqLtGimEa1dlh62lh5u1TrQvJ+Z+RfMpHZK/ybIl0xkW0QdfeBbLOkr4kfS/TLqiAgImAI", + "TzZzBGRAaNWFnIErklVsQv7G9ZIouQrsaJlXKDe4/kZBu55EBC22AsbR2WGLhSBsOwmQw5FQTTd7kcY2", + "azN6Kwb5MzaxmHGTEAb6Sbq3p2t7dpG7ryG6w3YG2qKbNrIDCYR+muGJsIN1BnsJp/f0FGF9NEG8uHuS", + "MHpHUeRrFz9gqQUhr7VIUGKZMJc22yqQX8B3tT6Dy9bByZZjYm5zp+gGLQqozEfs5R8nAqIObDKJV+tw", + "FgvT2E1XlwIjN5y6QW/pXVw7YmIuy7S1p3hqAn65x17+1oRzyWpVWa2VZissKCKkRmUl9I95KwIiL2Sl", + "2+tPEmEhA4ZkWLHTyA3bNhCoMRymQ6fDCS0KV/NGhcWiErGkN8zmtuUyDbYJrjcsi1NQnnUqNuyiToXu", + "zZgqhSzgs+/WetZ61/qUzVrhsf00hUge7x2yZcH3LCY+k9maoMuUa+5qH6VmIZcLYcsd5usjWTBBqF+f", + "1H2d2kxtYBRWPLLKxS4FwyM6jRF1B4yq8YEzUO7TGdegBs0YlKGBiAfywEfOPpyQ17ZGmoEq1UbXWcA9", + "NpoatRklBnc40TeKXMGNmlKN6WiGBdiw63mlq9IFm6RyZd1TZtUa5WYG3DeO11jV0h4Ry6Dsjv8Wks7s", + "co10QtxhHU1Rx/zshkoX/dNBpD9jnLEdq9bcTAjStkT4mnjCSB2nEttzesAmiwlJRo+PH3939N8fJ6OH", + "E2JUi6MFEwxjxPg8ERIbA+0QtmOB+wnfRDfrnZYcg3dHuLXda+NKII36LrqLqhkaLG2nB9npimXB+dum", + "xBm8AyvrB/JYgyzGW7q2VUfAnLbp4sHou9ZPTETu/7yUq4NdSFy8cRMjoMdhbpoSj48fP3F1Pk+ewf+f", + "HB+f/HsjcZWWWMpYHi5mvM1IIuD34XUQ8C9E1iFHOArYTlSgSDHPeapflOWgDHGqGA4xunmb92vKwd1Z", + "w+6WQYeo0s5BVn9xLcXimS5pyp6dPH7y9Nvv/vj9D8fNmCn/8dPjH2r9om8Z53yvf3UpjvC/MCtTkOP4", + "9PiH2OPqe8CP0j9SxdXnr5Y4SH8jzcTwtnIdT8P85fzyZ/Lk5Lvvjk7qTNPb29sJV3Iiy8UjruQR/J7i", + "NJhuOlnqVf6Q0LxY0qPHxP6WCCi74Mrs6lt5lDOtIb0TPrDFiCDfLVcy0M3Riy9umOCuN31NHu8uW3Kg", + "IQUeN9Jbfzk9+vf3/3iMua1tfQTrPJ9mmRT7qWYwdGux5+H5Cz5ZYPc0hjQIeaRZdmS1/UjuwudQ4sdy", + "loElVADd53bshioq4SdNnKgJOcOXmmRk9JqcJSMiS5KM3FtKMmpk1x9gtsNWXT2FSr+QGq3Yih9h7BxB", + "3GIIR1C6w6ZUr0OyIOfhJ4kIKh/6mqTkCkusXbWrm+IcoGCYOXBxl3FQVzLFBswhJr/oIkvQ8TalZabi", + "rl/fOlR1r+AQ0eDSSsIKaG/83J1yZ5vagTevWCPKL9hNVEAAO/MB7FC+ZT/22JxjK5+kRaH2iLCHyU+L", + "wgczq/7iSrktQmDJH1xAXLWL1UyQTfpn6J7nQPswC6991nnnJ4g+8/32jPfLvH5GL8j5Htl2F7TUfZkq", + "ADxm8gpNU2PV48tF2KnErRwlE8M6Xe1XA+ZtGIi6T0TElozPTqRq/WBqIepjCR6BAZBjvG81offzAq+x", + "7scG/PCtHMDnn0wPZpfuGoMNt9gAB+kK9QNaKpUmM4AeOu07CCMlvbn2VbvrRJqgzjJQm/tCMQ3S90rI", + "2ytfzBp8zcB+5pzqgTWYdlAXzawtndFnAfiNTpzIO1iXZzM1yEi/mAWh27Gl3reFYQNZQnL7afYflYJE", + "/D2pszXLdjF1sGosfy6pgLraAIKv3rBXyvMeJoOl+kUDCjX5Kqr2FlVx7huoXpZ2ttE0EMbHkDNM8JWS", + "Pw9KnvPcfDzwIF/iqJplImphjxE/LmbUROyTV3zFdWeGupI1T10SubIyzf8bPDM+NNG+izZmCcMeMWR0", + "7UY3fDa/jLgoKj3V8poJo3TISgf/fr+jmdSq2NuxhjqXal5BrGUQtzOMBmGvL3GS1zZ8okOK9ncX9RMS", + "4+TLVbqLksuS63Xj2f3kuBO2UNLbo0zeCuIGNBFAXslbVrrefPBsveQLYz+57ydhzBAX+uQ7BNZcOLPi", + "8THAav/ZbXkyHhVVme7R3eDCDgN8uXAozcqVam3hAnVFfGCnxBJVrY/jm5lKxIMmvbmmJVdCCnb1MMKA", + "byjP6YznXK+nhcz5PnwS9ZdgpgucqNlDW4qpq7Qy6iroQpcyd/3cfE2yVBoTCWe2kWCpFKpaFTasoZlZ", + "dBWscbUn89/C9c9aHL/wR1hLnIKV00pwo0UqPQWNdl8R55B3MjkexawaaxgUrHTM1SzsvW8+0CUKqy3F", + "exWBF6qNHk++PUYDNRSq5pc/nBwfT46PsaYu1q9ycaPm12/NjxNiJCSWtXJ9wRov3ceu5U7TxCHHYwN/", + "Iq6atPyvQMOEC6UZzTpnfzI57uu+mK6j+s5HhFEFOs6w5G4nS/Femz28lCW5svE7tt6sqzh65S86YkCN", + "I7FZvo5U0LhIS8KEqkqD2bJkqSYlu2EC8o9TuRAcm4hh051OUyhLdS1B2ygDjk/00FxKL6n+xrZGYijm", + "F7mcgUrj48nMQCANLLDco6a2ZOVAvdXdW3jr2VN1bcyx/VnFGscDdUmcfatq+LyrEdZG62BhGhfp3g3V", + "XoCc67BCGVlWKyqOSkYzYMShs792QSVC98w3JqpKl4QqkozeXZLnMs9p6Z4qXlSlxEePoV659Wom8/iu", + "8Let+4pvxLpC7Ay4rdhW/pCM4Eb7LeGG/vN//W/7g9kabGwPm62vrK0jd1fGaz9Ct5F8O7eJzbKSqeHO", + "8VM7brNf0c7ebko5Ie+cWg81HEVWZ4LHepT6xT6B3I/AaHcz3gzsZ/YQukOXkmhj0S/YqFjRcj1lKxt5", + "Ei2LZD4h8EkvbY4ahZFgwAuYM1bVA6qTUI2lgvep4uAuLNSlOA0m6lKq6yWiJXErMqNAQPkkgMSH1jku", + "4Cqd39hm24bVhBuEVUlj2f6Xv36eZYu/7ceyXOW4bRzry7hTH3mX4Dh3JyKLu9dm1LaKSzB13f3Flffr", + "Nn+B+4gVUiD0m6dLS15cNbttt9t9jNszK001T0OKA1DrajmfUbcjZycNvsL2EN4Jro3ltikStmDlEdhx", + "YBg19H2QNyQZYUKUVTOo67EejhsTWSYiGeX5KhmZK59LeU2qAif1reBevXqNf8mopuY46zNFUliUsiqO", + "ZmuwL+xFazAHt+B+TMES5T4sAYlkq4/Z1q4axHZh6tNgZM+Dfv2FbxJXqfqVCTD4uXiBM75iQnEpNjiC", + "/xEZ1gD1J7piGflvlz//dEH1krC7AtJppQAjnN1pA5I1cWVVGNFiPW+e4lDMGHKDPf2FrZV3ENh4Hvsq", + "rrjSkA+IgX0CXSPwayUyVqpUlqyFB+/x9Vv5w8T3pWqTIIAy7S++gKC6k7VVz130fXD4zfDAopSrQo+2", + "8hKYXU0PGgENL8iKu2AqvMLW4nHw47rASeZVDo74a14QmWf+p05XpTE0j1hypWXJU5rbL8FB76rBT0a/", + "o7Z3QNVTl+vYhSdyRdo3BH1j/l5wscAux4DabxRcEc911z4S3H9nx8uSqGo1JvRmMSYrDk2oM7IyRkhN", + "oco2M4GwOGOm0kSExq99RyloaV2H7lvvpLI18lIspF/PPG4C33T4OQsbk/VgbCIaXNPhwaOy1eeovlZ/", + "mPjHmz3sadvQL2DpjevfL6Aucio+IkLXD98uqMxXA2NRt2lzLloyUpwZ+tOHDfzg08/lxbKUq6mBcFp3", + "jT5A7KpByXWrqz+2l24F3Vi8zWxWVfMJwvnRG4Wtzfh6vv2qIt9Nf60olGKMiyP7JuVv8RwDikKI3T22", + "INYlAOC4zS1MBEYKH7kATRdLjIFcc87yzN9fl/cE1xdiijvDEgGPNvbLMalEzlfckJrbTAco6xKrH9R8", + "2eU7P2gUe2f7fEMs8PJ2CXczX9mfpezsuUtp5ptf7nSDbNGE576o7EbXnZ3eSqGwCFClULhw1WE1PzYH", + "j+69xUKYm9AG5vN0yP3GkfrILT4mTh94YTxK332aiH+yKH248j0R+rVsUDbT0ndih95rdFVYW76RME9O", + "rYBSt1yny0TINK1KZa0in/8HFeJanVkm5FSTnFGwoZidhiuXz58NzQ0wbOfCCbcVF+c4NuDfF/UeI53R", + "i1JOS8gan+5aJMJFuhelPMKhkACJo4Pg49aVvqg/dytF6w70qonBw2Obj/pT7ufsvgfpPszdDt4lV+GL", + "7ZH/u/DRfr66yo69zTHI4Uea012aZ0ekL4YPzHACMls33q+jcUj5QSK+fV/CwLDFsCGWkZIvlpoIeTsh", + "z1nJb1x/gDRntGQZRjsoLGOFZajWwEdyvuAY3WRr32P9BkOcZZWzVjG7EwiBOUwvqb5w1M7Utq7jwVEI", + "MXMzQ5QuvnVWAWKF1GTNdIjfCTlHb5CymEwEvaUcaxnYCDdANdCELO1Tgi1lEaQtuPrzYVZ7HKd9MT81", + "QsYBfb1v9690BDrqvQIQ5/P5Z3XXsP5Ged0AwNuSCkXhYnwsus6qUhlz+14RFsC7L9oQzv1wZon1tA6E", + "H/D+IQXTtFz7wDxhtEcXU72B2frFdmIOTZ61u0nW13JyY1BeY4qIIl0y5nL4fzm//Pnp45M/9tcJML8e", + "ueXCQgGJaJiGdYWAcP7GJ31FAhKxoUrA81b754a0fhIpE/Ckp0yAheTz50GBLf0bMKD6HkaKMcLMtnIk", + "hdenzpYLumC7X3aDyQ6MMMVm4C7sKq38CV6qSK7vuzfnLlwDviCwQBCvXlC9HEWzl7ZMB81edp1NsLvN", + "s2ERqfhsosqtbmd74nSDctgNl5XauIL7aO9VFP97hKVYK41lMC+Bj4JbfHLsZ0JnRefE7QjAULCVfhqo", + "SfG/V6xcO3IYcIefM83KFRdMWZc1gO4ilOoaqVqSkumSs5tY/fS6tmus2FvjUM3c5sqM6+p+3plj+IMv", + "O22McVpS++4dOQTsM7552cZJb13adS7fvnacACAG1jvUsTp78NhbMNBAwox675D+ED1jDKr6Anh13ar1", + "t+DV7Ta0e0aweqdkFyvYxGt7D85uT6sYxP7hvVuz6M3LsydPnvxQKyJaylxNONNz0EWMzvGonKfmo4cE", + "GZc5UGPjHEEnG+uT5SIR796e7VzNy/NAP1PgBbNQEQP40Vu+inY+c7t6yVmeYcYftrhZD4pFGG85vFaW", + "/a8HiXf4Kzw1uzqKhP1a0VyRBb9hgrx5eXYEu6+xXSffc0EAyx/Go4U+ICjQk6FVy3EoOOwe4ZElIsmJ", + "1GGw5QdGVc6U2hdP+aHxVAPzMUiKVIbry6qV4bbN9QU+8MCt89A+xEJsxISc5jmp75CxRRIhraP0v7r8", + "HcLuKNwEKVidXuu6gKwKWnLVrMrlMEPg+hN7/8eju6OFPLI7scnDE/zR4zL46IivjEGEGrQxbUYLrpfV", + "DCrmyYIJEMlc1v/9iBb80c2TRy4x2SAuFmbeYbWRj/CBa8e3LeqdrWAti0S4ZCtf+iJkvccnP1D29Hh+", + "9PTxt98f/XF+8u3RD09/ODn6/unj+dPH9I/ZdzTduSSog5044Mlf4l2wbaTo4GKeKS1sAiax6QgQsuDj", + "/oiEos9QdYg6oikjeU2feTv+r43lt9e3O0gj8q+B7F8D2X+Xgez/rI14+0Lx7ZGa4wSfxBumbOW5QWXi", + "zSCMRHB3Ag7kVzNlv9HaU67J/ExKebv7U3VnF7YTa8u4PVi89WVYbdpskiPpQp3yw9WFflHXhO4sErO6", + "dzrgwd2KT81ZuND3cuBRD+Mz22p5rYoKiuyYBe3TxwNk2P/f/0s823g4IT9VeY4lJVyYja2H4Z8DE+Ez", + "8kERT+Vq5vzEcl6rTkCEWz2Mny6ILdi7TS/R0XzG5/B3smIK8IPlNQK8GXxUeT4m7K7IKRfYMmVdr5FC", + "5oDB2QzKDSqZ3zS6yB04vwRyGPxEQZi8kdt1F3p5w8oJubK5irZugstnnPLsCk0kw13LG5a1DrJbpefe", + "itCDVTer0mumN2/m/grJDwIB7tGhrmoz67ROVwjK23dYGAIwRpbRiMSqy9M3aG0Du2vpiUPFmY92lIRa", + "HaKjOobFptoPOluKbm3GLLBptLkv4a68psW5Zt26Ed6j0O7SFFwjSwneNb6idyEk8MjRUFiDsW4fETTv", + "ZWVEqmU/bwAIG3F4ds5+rkJMN4Hd3Ydr6eLz9c070/838cn7/GxL+EBu+2VpfzKv/EtZzniWMXHPbSn8", + "OofqS/Ek3peisc6gxhRP+hpT/JnpRijfBS3pSgW+/qElAYm0If6Gly+wFDChrXi/T9eFwAK1Kdww+lL3", + "ZynYPVONWeJABHNyHCcYt8QQWjk57qUVowgIA6q9yadp6uq+DLAVYFDY+JcSTDrqF5dLqqbUL9ZX8Dwo", + "WuFbjUF3YxzqQyXsKolIxJVR1q+wQgvGfoO2iK4aNLhz6Itnox0hzsfZB5hLCR1IUZdJRGMESKeSrazq", + "7GifXAFeruq2r4GTqBL19FhbCPUjSJuCzUCsZcloumTZmMiSPMDCf74n6kNfI8/HZiaC3S1ppWyXqqa3", + "oJaY/+ZxFa0QXzKqhiQh9tDLG5xmg2cIFwra4rpjzSRDGw0bDEaPlVzIAn1yNvnsqqYeqFxn0b8JEQ7E", + "lpgJyPB9lGds2u9QBRNQQEPaAOMUpuSz3GqeYcmZVgiHq++yScv8EOkZY78jSpdVatbGIvTsTm9C2Wm9", + "XAQ1w0qFb0RkD6N/TdMlF6wuQ8YMK8YIvg1g42xG71HOuGnO+2/N4mYRxzwstGmN13bu7Z2Goa64A2Uw", + "icXDIjuIsbfLl1fPmOAs84SGFBZ2g67EtZC3YuRqFQEvmloWZGwvHDkNeFfwVyH1dC4rAT5IOUXeNG3G", + "XLfN/nqbYOnUgnj3CwQDLREYRgzxrwUtNYfm+KqCbc6rnCz8Yuih2qCu/1PcqRql93OVHEvqcd86Xm6f", + "XTkrazd96QO9KBSezKqUZWjgbb1lZ92JY46oL+6it46r++rtD8cqUx16nlOeu5LXnSvt/WL1Pd3hRu6X", + "voZ3UkvCbmheQceFBtOxG8ihssvck4qKmQs1je1F/3YDjmhsS+8WKYH3L3hv/4iFXroK6OE6gUFvIwot", + "e1Tbu0l7tbeORmwZOWH5ZuzfTNMlcV7aoEjh35ZGQwRSxm/cqdhjMleAu8Sd1iLpkqXXqltsudax3GbP", + "G1Cq7UmX/ox3uB+d4xxGmK9aFBfwENWg15pOuzR5zdYR8+SFQSjDfoKYbVYrbeTqmq2voOAKqvlHQRlA", + "V2sPP5ok4jyEyWavoe+9PtSGTgjWSslsPkL9OgPCLRFXwM/UFQEvUuMhrcs16Z3L6LUFz7sJvp4BG0Rg", + "Haa+PW1tFga43P3cXwb9BQYce91d2J6/I3zYQc+5k/N5Xc+C5rnvR5DU6o9DtiwXVPC/4xXC09BVKVg2", + "IRcQYeOrIAAEkH+dytUKGkcnAkK0jQxsnByEoftuzbmkmYsXm9H0mhnzlZU3PGVqVxp9NWD7H00mzgv4", + "FwPKwchgLzetG+YL6rck567P0talEbBLfANVY4i2w9tfQKhHm/nu+nzd3bARDR/6dZHn6M9tO4rxzsdS", + "YEAzRh1HESagHBM80Nwuec6MNgaWJxBsI/V8H/idn6wX/BcIZ7+ne+cnVJ999368Q9oPse9jheRCkxVd", + "2ytbGw/1PeRz22g9z+E1Ef96C4+i7C5lDG8iK48Uz6wLR23WH/sd88whpNdDHyeRvZxzHUpu+umiZPyx", + "Clon86DnwdsKGXgRotqYoA1pHYjCXayFQMXb+zWuzy/6IVJ9N2Czyueq8NJxWPSK2hC/wkrSkjW8hPDH", + "0mcmcUGunO/L/HQFTkF2A5o//j0RqGhslk8ddyQ+7pFbqkjQ4r4Po14GR0jTHlTcInTCNzzFuEUYqjkg", + "NWsd1qhZ4H4tIeaX8a5P2CtbhidDNo/q11AsyqxmW2FrTshJpzmH0DHeVscsdM4fqegqdEjLPKeFQq+d", + "q7LlLheAPUZywIMLjrc2kw2iWEaWDG25fjHcy1+69yXCYQ8c3fbWR7S5d1zot8dSyPZfUtGtOf2NCu8D", + "PBjmLEViTwScPGJuEz2+w20Q2q0968gx8FUEXKCBgRijbRfBivcph3A+902d/ZPJVE0yvuDw2uKCOJX5", + "e7Vy0X6PzAfmy0c/HB8fnzz9/vujkyeP/Lvpo3LKlZyaFaaZXWGKuQeTpV49dNUbm/HqFyf/I8wKsrsY", + "NTKNLx786VmSZP8F/mdi/uvhn/7Hwz9F/vo6+te/Rf/6HP76NvLLvw2Y+/Lhnx7+6Q+hRdnGcszfc25r", + "T764YVCn4bMsOgChClwsGsD+BhUHzsUNzXl24TIlz5aS7/jU3xL/MFCFCGjXherc23CrEIL8a8Xs5zbk", + "HLJemu+YNqq1Z7IGS7SPMPVYyA1x6MGUmp2mqvKIG44j6uosU4WlXwKnG/zv+x1WQJ7QBHYms/VWx2Kw", + "BwXXAWAd++PY5cyfs8KYn0LvceyZG9s++XZ05O/v8D1qprAWnMWOWDkkYSA9ePoIDmwX2rBpJy51YBBt", + "fMT5+XZ7weDvYyVAYwcN1Ur9m/EK08GpIN8HKRL3evIrejfNEWNYxxXvBfz3b8MOHD53OnIsxfrJj9xV", + "gN37yDFEwBU5/HSnzUVw2lxMjSqnbV3qaS5vWZlSxey/q6Jo/Bv7SrmvPaFw8RsRij2FXQjlUlOR0TL7", + "dDRyD2x9Y+1b3PAbOPADYnsX5KpdaDG0CaVgu5Tz7TvDD+NhA5tcYvDohlgZOjpQUocObeo6EOTW9Flv", + "V0saVLEPw/CUMR5xNXVLcTWdUcW+e2r/276RwT+McTq19Ry4mjpmCP8wKoX7L6hIA/9tCQv+2xIl/HdV", + "cbvu/NdMOAgg0gMfiOseBgYz4P6d1vmK8D1kdY6cj0dNS7Zgd+Yn3Lpd1JXFmgqmb2V5PW00l/27FGya", + "c6X7vk55Vk5nuUyv21+4TGWzbmAC7qNdvXr1+kwq/VpmLB/6gPjqNcFx8Yjm5tf1S17tE8lYPiZsspiM", + "STJaFProaTIy/5nmtMrY0ZOjb4+UFIJp7Ia4Yw/Hn4KE0dYaf75469Y4gzXIk8m35LJ/jd6kwhgDC3F5", + "gflVQ6uEyusgNwvbd0Mep91HxoRcWTO8gIfwayYijmiaLtnUnP20YCW29D5IEUwzLzHzAoyshoE8eHf5", + "/CF2GIbFb0uu2X2sDhNvWB67mh904XMz5YYlbef0g675M8y5YVEUpIY3HXTdN25aIjdD0L4ZLbRHsLLh", + "yvx8w8qSZwzLRQ+8NHg80AobKiVA7H3ByiNzUVVBU0cu8v9n7+2X28aRveFbwas6VZOclWQ7yczOeGvq", + "lMdJZrM7SXwmyW6djVw2REISTyiAS5C2Nan8+17Ac4nPlTyF7gYIfukr+nBsV23txCIJNIDuRqPR/Wvq", + "pc8+IDhGgkjaoEu7KGMDCaWWivKoIyOC9kvGY8P9MyZuIp1pVs6VrDTFuAwLXMUuizJ2HcUxVHVCZ2ut", + "eRfrC+2XPqEc5k1kESxb2ROD3750Ow6EdnOlmf6JFy+RLgZva4u43ip9bygZsKFncZNEqdDQHyzdRdMO", + "dsqlklDqCZe3uFFo3JywoeYtqhJ3h+2ZVxtbSry9ZKnRN21EDZcUpc0GASARlR64uOG+nJ4cXAkZqvI+", + "vnjvdO16c1yMrZTYWOG3OYrDjG5lXBhZQCOgYkhFoNKwW8AP2Bt/fMfpProQtoCypDDg3s77eWc4MqcW", + "GMYBKPQ3A7C9ioJgj4q8Ex5f8xmWtH4+6DxupGarugSXs0GRzCVk44oFybBahb3Fi+Tishmfw12unbr5", + "tG4gr5S2vLLSqnU0deeAlRVNW8qz1Q51dPbdqbXG3gs1t1L3Vgs2BdfQo5pmrPVe+FFW7DsKxDv8tpEB", + "He4ncFhgTkJGzBpp2PCd928eRMs8hdR0pKruDW0bA01bTYu0Q7ws2jveuYVoOa5qI7apsAcxb9cozW7h", + "+JY5N/QjelpjXHmVkVY/dp8V87XOybswVO3BWCVC8ghPxlxmk1QlUbD2qbve/ttEyJNX2P7J3PZXO3E7", + "dK22GCYPBOqHp1UMKB9unPf+OOz9BKDjR18eFX/2+hfn/+k9/RPdx89H7UDCmM5UKlygHcDDSAtp5Bfj", + "yG1hOgw/giOMexFjhVKsKCZ4GkzgeZAqrV1js8TsNLXysWrE0DHPjno/PPXuAzCPk6KpEaADQnEGkISL", + "C/VJSSmCDP+YCj2hn83KQcDVoHMx6PQHslxlVsirznEnE5rCoErICt97yAq0eq3rWoVgXSNMDZEi/Ia+", + "LMCftNEp32l2ieBtl+hSd+VGsW1EWZxiwBpCCCKI+JBM+b9gXkEBLjKQlzVyLvvsF5VNWChE8hZD30cq", + "nRK4fhCIJBPh8UBeImN8RIrOP34Ss/OfoelL9khC/MRjxHwpvdj33hvIR6HKelJhuM1jP0+B2LUCelle", + "lnkgmG4lNwyB+Vuks5MAwnIjOT4DhBS92XR9I10oT7YbQmJpiCQXcr3dssR/ben61KthpEvs6LLPjN50", + "Tx5J5R49Bg4RN1ho2JqWkR5IimA0HJckcURViAscwiUNjpoELkM4cR2l7KfZbmbLdnXZL2MFLNdtTSZf", + "3PA5QLWl4UYjEcyCWNgYVoDwsyKIv51/VOLf5z8bNu8GsdKRHF9C8cCRyKi2qjsF9LB0YMGAjTANIBRh", + "qOS2JAHLmM73NK0zo90loU4q6noJ0M1GNW/tlJU/LDhonVG2LdnphKdjsaU1C7Dx+pptWxqoYyMNXhz3", + "O1cRxuJsGHV1bB712CXZ6pfwB1XLhH+PIslj/CdB2l6aT6rJR36bLrsIsg8S9AO7r+dIkLHAf+F6awti", + "zglD034TEBbPLlbLZF4S8cV1atbDdFMGy5s3HUWxrG3NCCZRYhG0Hbixyyg4VMWuDIKz+mZRLy32DltY", + "vn8Sk0VL4ZXh2u6CZF5H+8Io8mmorZEF8lljhbxJfG9aWZUO0/W8lUIyo60pEdd+E4JouN7uZqdzhTXE", + "uWufBcwneFHgAFmEDgwUf05h4asmJ7tEEg9hyCZJuNSz5sJV7VC6NvOmuc08zlauBNs07rZExXmJn61Y", + "tf4kb43TWmEHbL3fJFWjKBYX34YNBxXn1+01SaMpT2cXYkoAZiu3gKAxXo7VBeVYrUlTm+xB0sSWeCKi", + "xAwmoJP2fMeLVa8nljrhYa/Wr+LhjDq18Op5f1XQzYapXdy/7YfmY3uH2vKQAaYWMFjMz5CSaEnod9a4", + "Q1hr7IS3j7aSSvc6eiQAaUFp2vbgsRe0QqjS1VYHjmM1Xa1h+aw1xAUWjsOH3YaCsdmHjZANa6ldcCSu", + "t0OtudO0TZx/x7Ql/Vy+jtqI7b4CC3lWOpWMFf1xn/0XOb/ss/OP4t/nP39497waW7MNgjCO5tXzCi22", + "W6QF4kzrATrbowfiepooMg/OPwZKZjySGijrrHUzvRpVLj6lTJP9GWcJLwS3vM0U+0uZFPwRCaF71FZB", + "gzTSLUkYRq+3qqeNzwdFyw9n7JPAs+/WuLPoCsPOWuf3LObbckAYG30rbuY74jF+lw/dTG5pCbTfxUIL", + "f8Utda2P4OC2/pfrLL3jm80v42ux+nKdEOo/XDCXSkRhzEAoRlDpeKKuWaYQEAbufl35Cu/E5t3L28fY", + "i84rYTNQV/VZS13VCoWvGEZZfSDox3KlEwoi6/xH3wbz0Lz8Rx/+8aXbAQIv6OckVdME0mBCKDH46w/f", + "/+vP339/8vKfJ3//64ujJ2/+5/D0v396+Veq13TcgWhMfZGpDEJtUGwx8Euz9/SrH940b2hwO17k/ACV", + "0BLtxT4Uqj+DyyplYIET78vmODmvbTDKzdLmuigPQqUqvnQfqhF++9UIN1IZ6A2fipD97d3bN2c8mzBx", + "Y2aEqgQpJm4yQxKmJ6QqT8xeD7zuIQ3heRNcqLXQISogCmFCSmpwm0oI8k0mXGICCSIeylCkOlCpqMyD", + "p3tqCqCmKX2N0OS3paMxSYaF/yRMJ094yvgvTrUsKP6HCvNio2WPIBJSR5KgDFGp6wlApVn6SVGzD1qM", + "cqiwqz9FCVOx87qxV6OBrBRZ5HHMJpHOVArpCHSa56mw7Yb9b6nm5S2p/3jbCxzWt6rqlDXogqoqoJpT", + "VgGUfbzfadAFrh7kzMW8ufeKmlU6n3YZvxp32TSSGE445Te+KGo0YTApF2DELEhTKfgx4am2MK74LnT7", + "UqWkgy4gMstvuVsmHomyiotT0eM+ewkg0bnMBrK0vdp5cFNpCI3GEt2Lvv5wtsAC9lm7+GS3ZFSU1OB5", + "mz15UjZD1rYliqhlMgbNVLmU7wv7J78aEx4DwncYAYfozqbYZiDw9paTQnt8L8WkoGuviJle6xRXrmpm", + "q7C1IbcuZWbsuugaEgvCOade4UCCtQGV5zV7NOiIf2P4cSQHncde+Xbc+FxyfFs1t/JyfJm7QL+mXOYx", + "T6MmJfseDCr3QqmoIBhaoHqgiLzFqSMS7QZurBaL4wb1Nqc886Xx7P3R607X/Mccec6OnsP/v26Xt6+A", + "pz/xOchHuPWMN7SKzBnqqT1DHR7D/8z5aexPFlFrJgMADjrHnQ/vT7FIodfCE6+FL/PqBC5/wipJVpvb", + "q86eJDlbLXmJ4ZysKGwUaVe4FvNHvlSmcfWR+yzbQlL0h2iogAlTggcEj0CZqZbq3gPpxlApl4knCplF", + "qfCL/kLbF8PZRVkbza9y6pNEYRlsOCvx5cdOybtwvgJGd1X5e+zqlSAgzq0T6kL6DXW+eQrTatphXJOb", + "xmHQvzp5c4Ja4V/mhedUk3sgASXz+ODg+vq6H3HJ+yodH5iWeqYl/RjhmYumI43pIplioVn+aSTxgAE8", + "h/nrzcVOdVvB9g/vT+E9aN/lqOuWsrbbKco6T0gy1V+kstdCfn5dUn0WXNXTfGhbfKzupCW36HyHlfWF", + "wa1TL8vToep4kF5J7pXbbdOw7bqTjgSd487Rk/7TZ9//APO8bmtflo+iwiVC9HDgKaxObpSCXymOiWmS", + "zbDYAiL9UymAZUOsvAXecu3y9bT2/mRhqcix8vRtqL55xeT0xeWbkZL1LOWHUt23ulQ3rfJmSnV7HUC7", + "danD7lYqw20xjxHreI3NKpJj8oSOVByrawtUcRqrHBGUtQOiqLtDC41eEjiFB8dpYoyev4o4Vl12rdI4", + "/P9gWOD/KBlOTiJBsr8Pjg5HPBS9o+An0XsW/hD0fnzy5+97wfdPgqc//PnpUfg0KHK3jztUqaVH/hFD", + "7pVINY7yqH/Y8cK7nBLpgUsFg7BKGqBym1O+Umrd0ZYtY1d4nhM+ixUP+8zeEHRZNGLkzWNR5rmf/vbu", + "7RumKHSsjslW4wpDFFTGk1mz//sUH6IvhyTDX3HYe5FL2Vtzai5EZdChIqkAsf6/WslBh0V6ILlhH2u5", + "//X9+zP/BFr9xjBz4RSrPW0do6cpecZR8Obm2mdFfi3edZqR8XAiUvMQqls4MPc8jWpuuYV0zE2Q18Wl", + "SNkNuCSLL/Aw68VYAwg6A0USzdZ7PYngbpd4cMKTRMiqj7IiT/789HzcwkXU+XLoH4NQJBuOQfhyE0OW", + "VBCNorhvyikrqhgCdrGIwCLms3JTAH8NLftQCTFbwBC6JDPGTm3pGdVcTAfykUNHCYvYpMdlUssKaQHJ", + "6wWNLioo4XBkVECxMqJgDfba6CEUGXNG/P3lKXv69OlP5VHM0aALRahdR/FIakaaiC5Qh3aHsroL5zwV", + "UK3YemFUGmFZIjkeyGJUlZlX0z791ddqKqCldRzzDkXEZ3n6smCz81KNItx6X1CXrRt7uZjByrhU7kZj", + "Wt7sAZoBH5YqN5U3d7/+0CKb2955und3sotf4JXHGtt4Kfh+3pdelHrDa0/wtS9fX7rJJuT87jTsguJN", + "UUkfaT+jAZbXr2vtr84KnkBnWTaTQlIWO53oJRN8VXLDvAtwqNnXnskAz6NM+7XW4BBiA/3XTzpYgyrs", + "ze4WIfno7OEiCrHqTFs9OfIN0mu2rBztNeWb1tUcIFXF8g/XiaspNzezzGpKf5H9qT33K5YSmaupuipF", + "q2k+aKI+dVuoRV008PU1qBuwzrCINHPAjgCQt2wl5VOskLx89WbT5SSfcsluSwXnNyp7qXIZFkywXM4u", + "18Jy8udaeZWMkvAKS+CNMuffXIaouXTGZRWU/pOS4+Ms5YE4Pnry9Nn3P/z5x58OyzGe7uVnh8++uOmo", + "9vPS9mPNnuKxLW8F/yVMAsC3eXb4rMlffW5miJwOdfwsiqhyESLa2P08HUZZytOZOWkGEdjbFCNRLmI1", + "GPT+6+Nh76fzPz0aDPr4rxakqrdeATyqX/ye3xjuW7mWrNdSLxZXImZ0bGAZv0HudycQQoYwSgcN9eqr", + "DrAGwqAsmialn1rT3WLumiOsX8mPisuaCTKbSp6pKc+iAOreF/ayX/ov0nMwdTcbYlmy3m0AZTNWJ+Sh", + "XwBawEXGb1aEiaB1nGeTPK8uEAEnl7EZnE7yHrhPUOquFAD07ZBK12e5xDb9WCJvm/X8vFCtJeAN6/PU", + "tsqrgRie8bF4LZruZ9xJLClqveIdl1eRwZZShhhqF6I1IrdV+aamLBtUY8HXhMWxyxVguOnpRPBPgutZ", + "LxNpykcqnfYwxqpAwYz+KKtUL1JjtZYwFLzc1HptVdbPfQq02o5aFsSLDqqtCk4oaj5vYSKK/8AjaHmm", + "E9r1F8QkicZwpMTu0SQnZfKawN2WmOazmEuAnlo1mMt+V93e6AxkZmJI4Zwc8oIwoUESGFUX1H+qYCsY", + "SHKLIU4VQuW5Kq9GUSR5Gky4FnCwimyTDeakG8pSCgJG4LQWlU9pvDsAymonPFh6IsSZmvDqQ1j/nQjr", + "H6VqegFpSIlhv+XnqRRA3chSn4SLNAPxgA4wjrdwrxLfWfzrZqHwue+l+b5ob3NB46uGgE/5zcW/cw5r", + "3Xa2woUptirgGn/cNp6YBhq6eFcQOvZSpbYIcc8eGpwSAdRkwPkssFOp/jNEKk7zOItqnxlVJGSBTpZL", + "KHguQmYHUyOq75UYg43T1Sm+cR91moq+PUTJLx8lv8hT8xuBADW6HJbyy5zBpUF2yjMeq3GDQ6bttP2P", + "apedBc6b5WLJcSurq6BGS8Xuxrc3TrswNPYSq226v72TQ7hThsg9TU8aBeL2zk+pNsieJmiedlhtjmoK", + "gwAcoLoBOMdE2GTWRFrnYgsuVJ2leZDlqQitT2bTrtTX6EYt6uPAuAnBcnX/qau2WTcqEm7McryDRJDv", + "0o0jKFV9kKTqIOWZCHga6gMIiDkg7Jq/w31WG0Uvqejl8i7dSmGgHbpz7Tw1sXMtC2TlUEL0PxA0NZXR", + "wUwwx48Adp3yzHC4OdJN8ywH9x2AXOvoSnQhAXUglRRM0btwk0ahLDxjnMCTalwvmwo6qekQMum9mgUh", + "EantpVysxpBkefLm+dLGQX2+KjHo80pugligB6clu8vOGLPvlQdA4WpNWa7/XtQipdss2V4kF7UXaQar", + "NWposmxsLYrZnzthctkZcwXW6INlRyoXT11Ru83M4dINLzWHptldzKNKv1JK3v6+IyEpLmxQOzFso614", + "QZMSs6lsX6/LJDMjZuBpIrU25cli1TaQFd3GHlTbLVFtWOBxYZvwlteArVn8oBwflOPtU46vecLMN3O0", + "5O8iyNPUFVtZUTm6r20KC86AZFwGE9CU4NSPZCbSKx43KTPz3mZcS+Ah6kGUD3WfKUDHJydZhdQqdMi8", + "6DR7uKFmgYBuxw5refJfvXv74w+HR88pT7jF92vbdfnEfgIx8/KHHe1nkEBcXJHS9/5nri2KF64eD2gl", + "vFGdN7JL4biuCccJeK0BA4LAZHz0By+PkcJuZ4wXvsvSeOyvFD/oF/V6trio1/mfHv3X8YX74/F//oc3", + "OXYEDI9yNQ1hn7/mko9F+MtsQa24KJgwxCxkU/hE+6MayIH8B+glWwwDC8ZdHkOWp33PTA5+HTJ8IZ6x", + "R1SvNhSSDWdM5Sk7OXtlJjHVj/vQGHY8pzEC18X36BsPAm6JL72359W9g+jPYpLOGya8aLlp3t+pNAPl", + "1bwDXHIdXDKdj0bRDWyk9oKHl4NLtEozptKQ8NR0IGQYyXEfYU0uTcN+M5YjMfzEMKR5A7/BZvoD+TqP", + "syiJBTZeOFTYlM/A1+92oIgDhNt0ypkWCU/ByxVHOusPpANrsRW57Od1GnQ+7BVb3iMxPmbfjZTqD3kK", + "9H33uFKEzXMUwwsevxfz2jTpNXBD0MkzUmXV9xfsDdWCBW1WCAhE2eLDgtqkLjCe/NEo/+OPGcLdPV7a", + "BsS2zTtBVsBJNHexkiGI1V7TXHQL75G7OrJpQY+kkj2Zx/Hjv2AUEs5M/YuB5EP6wrzdbFGOs7bxRZqN", + "YcVTo1tl6xTG4iYK1DjlySQKCENDNE/mOBPL9qZSa9ap5XoeyLldx/PGGQutNzbIeO4gi65WHuH8bmU7", + "pzYYyksyqmoXsN8p9gRu0TDNiGcM5Kln4SPd9TKoq14o7E1mMkmhohCeB1x9OcJY8hOOToz1+UIGCjQs", + "tPPcNjPXCq+PpWmCmkchbniQsVs4iob4zwWlJ0sLjeoBeWs4YyLKJiKl0aqUecqwz07i2GF2RVQXy26I", + "f7HbEX5LPgZve6HZIjSd/tw6j3QW2XidxxZI1c1tPlvZGrYjxg+sX2X9YpjA6qzM6QP5FazurCLrPSwK", + "oDLkwcXiUHtvQzLh2c/rxNxhvF0RDEPOiKoBXzl/b7g0/7LxHbAyPIRUxhIGgX8erEV68I3W71+HVg+q", + "YD6lu480rC70Q8ThHYw43E+03u0IRZsfL+gC8IgSlBSzgVzzmWZHiGEK0YCsGtbXFqP33/Pi82yHu2ZX", + "dDklKqI0d5vV6CbgmmtAk1HxFeEHNbDArY/r+6qoOC+w0l+mbmm/a/Jv1jbh2xv1VLcX9hL65JNx60Po", + "fGL3M12UC3XrZ4ro3OskFQljdY2PbxTZhvVRL1dTpCn8dhmSbCTBnsmCd2tkmF/Zow8yuhKphruED3gf", + "85vvs4IH71SaQeiZu9RIKwAoc4Hc/MuXw96fzz8e9n466f31b39//eas9/4fvX+df37y/Rf//gUobtjd", + "qwVeSr6AxdO1jntgRTNqNW8CrIFFEnO+gw102epqqPS4eceC6cC6FejO2wK8r+VWWGJVN+VpgLnZg58B", + "+vW9DHP9CyQbG3YsfJA8zyYqjf4Q207UfyUhwwLyiw2LcTw/bCJl/6g5Zd8f3MpZ+0dtWfsfwKj0qr6/", + "uDFqjsfvREaln9eD36av2FCFMziRgPlqMZME9cISPoNC1dp1R2XkEZET84kHEhKK61vMVxW5PyMH0hmS", + "UAy4tfC9OX1Jcd1OdB1KkShs3NFg6qkO6aYnmdsapH2Gtc5RmAlBL5dRdgEVNlFTYCrXQNIRoz7R7oOV", + "55rG90FG2an5vj6rzp+QiLRnOsLan6X6YFBHhg3oMn7QoUjrUXQjwvJ3XabSgRx04ng66BjVFSv1ieUJ", + "NurKg7gSoxYKB+JnQoYYVCJFlO7ecOZfP/TZO5GZNi9lHseX5l9BLDjhg99Q5TlHyl8gfQ5oEPxKMMPI", + "uQwmXI5xjmuAZFaX2haasaGRcQCtZj22QXRoOpV6yPhVtfdQTer2VZP6Fj1a7Uw8B7FlPdae0+BChn+A", + "KNkEREnzYmuRZuT7X6uYB1z55NDMrdZY1gC8WK3COYzvFX37HmS/0frwXyn7f3WfnWJC9qCDzt9Bh6nU", + "7JkU1DXo+Eu3ida+WQd7yjNxAUlvzS5285zB84qTfdlDHRk/vxvbmqdor9soQdf2ovxocgKXWapE/Hm7", + "rCWJxXF8zjO+ptSVG1kof9aqv3DKYmVzsdKlPY04RdMgFx+M3UYYlA6TcsI14yyO5CcRFqcNRxfjSeJL", + "w4vaG3g8S6NVpLh5DO+wlXUIx0+rxNoG2zWtzaNO1SiK1zxblNtYQvcSqnJDOCEE+AAORVSOYU2w8eag", + "wFugzb9N7aZzQJtLV2bcM562FlkC4snIzYzB7OE7OTgS2zMutgW4o1UeyAIiyZB5rdJPo5iqd6xC5j/t", + "h82U2m5t+3BMj+S4ANizFLVpXDeBHpFdx+HtStdKPdG5vuJtaGihAPIkuXBFAL5CXTXdeSZJoaAsPLOL", + "uqg+NPNBa3BhJ3plTrSaaz4EcYXDHB86vGEjXVQZysaud0saqNpCrUYUjfKX8nvzlG+Bn/w1S79wve0U", + "8zA059nVl52+mz+z1LpzlNuJZR8cDBG/QajjpgOCnTbXWbdDEOizVQCp8Qu8pjuvzxg+nkMjjaY7n1jb", + "0MPm8xWbT5JGU57OLsSUfOYN2BT4CoNXWjnMW5gz+uAFtNmE3aT5WFzYRJKVithblzB1C3X/T7yG6vz2", + "micJHHmVl60JTkMRUlUrCqZ3apFSjNCNRODxpcsT+KrUbdPO1L7zOFSh9ZROgWL4DRyx7wIW3QOK3J1E", + "kWs2J5dBLivEeH0J/haE9xvd1My6tfiKCsG2lVEpZR4dDSmfJhYXyI9bZiekXfR1lAUTKg6j6e4go5Kz", + "IV6DOisVi8+yk4zFgmtEB8BmoAYlst6qXirAhLOaqZx8bzfgYoydephUkqqLFK4dL4Q0mjAsOQTwbqvZ", + "KZCkqoefmgHQ1945rYIpe1a8bnuqew6ahZCob5c95xhfR/xsONQyh7Qp2g+6CR4MLQuz5kkChYXgjsrh", + "yK+6skTWSZJQ074j8oS68Htgjrj6Mj9ojw3uCSVGaGTKiiH6Dq3GRjgCembMl/7CslFwSTFSTUsoJN4M", + "A7BBEKs8ZJJn0ZUt1upqN5lpsTqJyiVhMWfXxkCenL1CkB/NZioHMASoq4JWsO4S2hDetkP7XWgXk+fd", + "gsCEx1EgKGwUl7RzkvBgItgTKMeUpzGFv1C1aQ5Pod40faoPfnt1+uLNuxe9J/3D/iSbxiAKIp3qt6N3", + "OAQvhMaFGfVhGg7gxZ4a9Wi0nk4qpu3k7FWn2ynViupDmI9pjSdR57jzFH6CaMIJ8LEf0BQEKpdGuR2g", + "nocXxiJrQXkt3qd9AetQ/O7BsZvJ0gkPxHfavsMiyVJhiBS9YJIqqSyIC2IJDGfsEvKULnh2yYazgbSu", + "kkdTpY1qC6BIZ5TqDOInEdQpUvJV2DnuxJHOegVlPTsSM2QL0d9qqBevHHhhw5GSmNb/pVtjfJVmbmAW", + "2N+r7IthwuxdniQqNWZnFdeAp8LCVRSDfkQj7noQCY/hnSIe/xL+jsJLuL9PYriDpa0hMqT9m5AIiF9N", + "x51upygUOTfg3SEZwCXEDPhspNJpwxRQSt/CSeg00zWysXrLUWYY78StLiLp6DOzbJqi/jyKQyGSt0Xw", + "oiUF2PrJ4aGFTrDVwKq1N48/L0lUlaDmkHPQfEvGlX/pdp4hgU39uoEc/MJDay/AJ0eLP6mG8T07fLr4", + "o5cqHQI8CmwnOp9OeTpr1wNGO3FjYHz0tZN7zew3Nz1Av5E8tgbaTS83pzcXjmR6mqudDoJYoU5OKDCs", + "4pczj8kPQhFoPdNenWDQWyeZmmKodhdDZRgv9BfpEcbDq0irdMZiFXwCyT3qs5epEH8IzabCHH31JEps", + "SGylY2rk8uzymGmRaXZ51hcSxLk7kFnKpQaDDx5g5B4EeV2akUZyfIk7VCoClYbwEj24oMJupqX+QD4B", + "WDyoGAnhgtTtm0vMYbx807fKhv3MHAlYLvsNdcx+ZobmS5gbs7UW5Dl62P/9//8Pg1UIL9mjIY/h7K0l", + "T/QEwM6mSY4ZSV18DTCjBrIAB9c4Ii14zCZcTyASOsoeGxMgEanROQVCDjTBkigRcSTFX1ii4nggL399", + "8Z71+/2DzzjOV+EXmDQ1hCrfFEJtTMNLS6oZoejav2n6Lw0R9FdBFLgccGP7jWeix9M0ugLvm5kOHuBy", + "XU8MZZdDpT5hC2zE49jsdToKkQSprnvYH63HQPJUMMO6CErjlodLdsnD/811pi/wVShdPuTBJ8hFEwC3", + "dXl2+RfT8IyFikmVDeRUhdFoZh7U9mFb9t4tIXVp+QqNJymuiVNFyKS4sVsbC7gcyKFR5lkaiStckZjC", + "DZGlUI9/RN45/xlZp7Y7IxPUtucOmqhCZ7+ocLYxvQwKoKqcnb4sG8aUrFfZI462tkc0bQfVd2wVrW9w", + "Yyh0b7PG3dEOUaiEVlP2V5EBjF6VQsPiUVhn4bHIGhm4Yl6CrQOpBM7UsbR0qny3rPFD6Uq7NGWWYtNv", + "gj3NF88Wf2HrLFb4uY1LtsLHgI2+4OwVx35KddMZCFvZ4rnHuua/8twThXiW+SRm+A8jLpfV4447FOFB", + "qMhFvrT2ydfi1rECtm4gV8KtuyVHsIXrscEjGDDX3s9d7Wnjd/ewhYvcqHeoNgaj4hhLKp9u2/EJhI+O", + "EEX4acWgg5d6Fg1gK1YcdFG6XN617YY5/1++NEeFf8NWGi0x4tZsjqWa9rODz/BfMsUQgKbBk6xGGeLD", + "FPfczXYYvuQ4b7H5Rd1v3vp61uDhR3yd+2AZ1Vdso7qp3Wafyx1gpe+fNQ53pYPuJqN1O8+OlhjKr0qK", + "Jnt989yY5A3ciJlkRUnVNp5Em3VPbLn5fbkhp2qpfXlnMuHuwh9EwxcNy6673fQPeBpMoqs57voTfMGT", + "I7rJrEsStXWvNDydeO+DSeE4ocQGu2PVJB/GkZ60s+oZvrAMq1JbD6x6N1nVccKOWDVJFjgGIQI2jkXI", + "zLttvkHTzEY8g1vlsiS5b84dXJcGj7J5cN7ADAefeZIscb1RYouW41KSLKefTIe3WTsVaWWNKipJ7s2F", + "BazoktxEaVEUJ9quYIr3INsS3ft0Qe9C8rAITrPy8Tra4uWER+ZX3k8EKhTV6we6oni4eICLh2XmGiZL", + "2dqO3heGdWYJGHsYqqHiWF2bMWJ8Jiz/MX340bx6/jPmNW3uOuPUkbPvKw2bAnjPNr6STqgrLNLoa5lM", + "RdMHxDbtAWP2xgNftFTNjISCXJMus2HFkG1hOHWm8pSpa0kfDqT90k/+ZEmeJkoL3XqLgl/3XILqNu9T", + "XE4r9LmnixWX++jT0sTl5Te+/RuXCoNtn+kPPtu+zAE3UDrrDW1K0Zy9XukMcOk0ZRAVEvFSpZVRREJD", + "ansqbE6dg+qRXkMQLhZGI0isz9ilGI1EARV+CSDlbecWj+5lLNViyF9rrrbufMW4lt35ii+GMzaKuFN+", + "M0yAmb8P2hozH82XgLx1/vOHd883uBUqnf1iyFtmJ+zevkMj0R/pO72Dft3ZoCLbG9A+C2MIbG9RTZO0", + "boYk69GuZf18q9uuZc8977iWjMbN1j68A/usY7stbLGIreBvoY2nXfvaVg+71MmmYvHgfFs585Zyjx5O", + "vnSOXTjx1YOv/WA4A7SH5Y69n8Ts/OfprBcOe1CeZWPnXqJm/8deJOTeHXsL5VDXTm51OufeBjvn5Air", + "v80jYxlXal+HRRpq4zGR8G7uyAERFnQ+Y7RsSua8h/+sBdw1htF5/S1ja9mmH4LpNmuZ41CXX/1us+Ux", + "FtntWdHDvWiAe3LFswKnUOxaNSZNi3S/zLKtyLS1tqv9MOtDpFpLpBpMy0b3wgPyxree2nzd2bMv31kd", + "ioCr7azpA8DeM5Xq7m2oht6a+jX07fN9MtS29WwD6PB+Ve4qvP2ggefFCq8nEquo4wOeJD2LHr2KJPXc", + "h3dIpFqKJ+xHnGrw3I0xVc11Gh6kaRlp4kmyBYnC4hEHwUQEn1Se9TQVnVoi/uEj1X04pW/ZO/z2/JHF", + "JwtVoPvYA1T4o4p02nX3eCAbwdCxD814rXGsRaTiWASYYE9F7qYim6iwDPefYpAFjR/9yDQ+CtMQADQ2", + "6GiR5cmgw6YqFF0C0aVOtOsCCyzqgbyOsokhKZjwdGxrBbr1iqZTEUY8E/EMu6SGRFgl1tWzsyi3ozzL", + "U1FC4LTLD9PyUqVsglAwdgbtgHSXpSKMUhH4jn5CeHZu5w+//0YIumI6FGEoQu/73OIgxZGQ2YUWQYp1", + "5CIZZRGPoz8Elfro/y/M20zl6UB6qmNBzIpIe8gMvSq73Q21XLEscK7IK0oDJi7er3P0JEnm0qbzOGs0", + "ieB1+rTpo2/Lo7pDnU46s0VhbkWjJyrNeLy8Pre0WTV2Bt9bEkH9fNBilMdGIzhVU9J8pG1aWsqUBc3M", + "JiJKB7KsDXWXYc1JfFwr7cBlyHgQmH/iC1gcQbBJpDOVzvoD+VbGM9J12qi6WtWiahmNSNsSRplinGlX", + "x8j0VmwdS6u18pzffaVm7+Ng2LdStTVTuJSCa//0Qc0tpeac2KFYML1JbQe21+IsBHvTh2/XEO/sC99p", + "+woWYOepMZqoDJQIGddMRAAFPop5xkZCQP1ewAPuYUle20VbOgNpCkv3puI8tqpSWuJIaKbmBjOsFEhS", + "Bawl+GLCNexDyCc8cAWbvAe3JcjDYzEvkoPmajizBcMXRW5WMBI/KvHv859pgrocYmAvNxjbgfQtGcZZ", + "HviLm8RsyqM8jhkigmPYXmrLYYVMyCyCktRllqDCxR4npILHF1k0FRcgU5fHjFoHKQUivzMcx2MAB0Uk", + "7jaoKgGfluZhFTh6mhMkwKtu7CDmywyx1YgXIOUhSHVBkGpFzW8viq+yB0HlY32AMKzg2ZgDXGArKBdv", + "2wh4G8k25Z8Ew9rx3lsajdNiqxpIaomgdCvClWvRC7gWmmQLqzYFKjUGO+6/zcYsNNorOr4b9isZgjC4", + "Eze2PUcnVahpsUVL79xxo7MRcawuMouMx80LNwnZ/NRpVpHIxtTpwgZESbMt71bMrM34dbbDryJDBv0F", + "B7Hv0NCSYBFNul2s7Bv3Jse7dNIp8eruJWqcctop55zckEZ8te1MhWJEze1cijYSmG8PD/5wdwHNimLw", + "K/S397DugpYHS3eBpevzyUYkdylcV7/bPjsp/V34STQgHcWxQi5gasSSVCQ8Cq3FWjFl+wtMUWj/7lmh", + "wOm3wQAFQto3SXh8L83OKs/va488+BwUK7EQv6csps0m6P4Eq8VX6Y/vW4iIXF5w7o9peQsl5UCLLIuF", + "OTIeiBvbX5tvhkJuoAYOXUoW31vHrRqZ/c02Fs/YKJehCMtSR9ekWBdUyBBK8UCW4kxCHbvoj0o/mem5", + "3LZ7eB1lk4E0ryNWEtMK7ydScSVkLqDG01hiuSUuHS1U7DmKo2zGrlX6CS4wbhKIQmmFnPWVQ8/S0ism", + "4o4qjG2E54Xlzf4FTeY7N5d7jn1dXovdI5RGG3jnG7dOJGv6YPeazq8lttTpuVR8zAIqeFF29iaUSxZN", + "pzkQ1mXlcptYRc4oKGp0qq5gGvRxWQHqgQQNpKTOp8WvffbepwIvVovjLdX4ZA01PgdyOLO54fM9AKWJ", + "uW1+gNM81Spd1RNQWrqd+QP8pbodXgGPoqX8Ajjb99czUBGFHWkouOZF7djDGK3l4C56DR/enSQqHzvh", + "RTHQExinZeK2YHlY1EqICt7+s5HgWZ4KDInDWDicu3tzz+uxDXNsU+d1b9LrcUW0s+iDjN/0oGz93GQ/", + "lY65jP6AH3v0ba/4dIts9Nbr+Tl2TAXzGy845rx+X46k/lo5dJmM3zC7VnVWoZnSq9b4aDxILcEr2zp0", + "zFn9PR05Nsi+dzphqOkosn1GLutEcSUW3sxFciwgAwVfbrHMob1IjnvU5KrhjitazdjLsvBK9PZwxnQO", + "luyycIr0+vlHiMmzRszR5szwF0DZWtF4EJq5aB6Ww/fKojqul132IkYzU2mB8/XPiZBMTaMsE2HXkmEO", + "e9pBf0OzgNF1yR5NlTaCHJgdfBSlOnvcZ9AGhy/MjIs4hPreqbqKzDHTZl1xghLrsggxw7QH/NVnJ0ki", + "KG7QBx4byEzRmO27XUapZ4gtZhHK7HteozsOMd2mUfqK1hE47Q4fqerWo1VJzKkkqz1f2ycofl95c4oz", + "DF4V6Mlw2ZBnwYSpkZWMQs8Y/juNVY4LognNrjWfDsWwQb0uZ1IEpif85k+r8Y2dIyATprel3R6MtaH1", + "pUJwK91UY28r3dY74XL2dtS6wbT1shnizpeyrJ7UOeb9RFjGmPArwYZCyGKfhcSn1PxKqUvmvAM5CXSl", + "oHIdz74dYUT5WEUcK1aKPf8urn1t32wxUlxDWwTddIf1r9yTH+pef2V+xuKFKBuJ7v3hDHn1IgqXtRPt", + "+5S9McgPD58GUQj/FZuzFl8iifv21Doy7hUqp6c86qewl/bhhoKwqLPWgCl6vlVgTxrTngKXqPcmfqJH", + "3z6cZ7GKX81RzTvmwWf614L62gQw6fhuQXXtgu7FrntHwAMo6FZAQTfIQ/PKai/ijLHIbgtbHO5SBz1k", + "hNfd8RtlycScLtura1f4kmFJoCyeMSVjLD+Xyyi7AMh/9DHZJDy0mVujo/bHzdu6K1hnQ9+pMN2/2KOd", + "WgBQ4OkAjyGtoZFwysKLaCMyajTPGoW2rKRAbZY7IS4w/zARnqzsQDZOlc6o2zbEkvdwgAWi2IRrpvMg", + "ECI0euzOygqypFX0xGUblpexujKvy0AsJyCWGkIowmC7OEKJKSDorDfGRQanQqv4SmgmeDAp7jqiUMgs", + "GkUIqlSE7YEzMC0ATAaSOqQYZQumRywhQndM7bIkzj23TzkJcCD9kGEg8+K50NFYontnKFiAhYGVNAog", + "ugG1PEqFnjCY2ise23gU8onYdWSRHkjzDgQL2saCiQj7Fy0apJj91qig9e4Pt6QgfnX0VrXELnfUGhXt", + "LphvU200aIGCU+YFAhUz06YMkjS64plYUjvE8RR2twPTbhqFi3zRiUh7Zq/TCQ8ES9IoEMx92uKctn30", + "ij6a99Kv9yP+9ttrs9WcGbq+1Yp+QPw9c0H+9ttrsso8Fqlzv3nNrO+mnJHzuLnVQ1lj5y35KomX31Iv", + "SPSunZW+QDWyH8zZN++vrPHfJthvkaY9+Awct6wHczVmJYdmE7MuPsYQXQ+Oza04NnfJbLCSC/b0cayG", + "PC7Iwm/6zCbV4N9YyNgxLwOdYgz8EeNytmjrJzpqzNd4wUkEbO56cR2zoOEGnCZiQzUn6YiU9u0PUxWK", + "2PxVuQOvVIyu/Jape3kz/mC13SKrzUn3dtVYecOcc6VjQ88qFLLhjL16Xig2yF6GB626bSAbldtYVHXb", + "fvfVw50ZfPfRTWeYqsxJm2d1yzjzNmp8Z16c+lYDwPCLLYR/8fE4FWMgoBQPdtIWDnbyEA3mjKVFq1KO", + "BaO31yrGDN/2PonZ5gwzEJy9J+gCFfds73bqohSrWi693OI1gU9b3SPwdKvhW0DpnoK3oO8mrsAt4Jt3", + "hNjVq3FF02518Bn+u6wDo4VvyFNhe15sRVGnD96JrXgnWjlgbhAVfEX2daO1fAuW93BXWuCeJCfP4RTK", + "KW6JbGpRBBSetB9O2VZo0uqb1c7Y9P4FJbVx7NrntWIHXC64wirKkUqp8AMg3ouMXZ4EgUiyY1Zd7kv2", + "yDvHPDaHkjE6ObI0D7I8FSH727u3b3yLv9RgJm6yg0BfXZpPQ3UtY8XR7Nd8KqAQozkscXb67h8Miknp", + "PIKBGzIHUiep4KGeCJFR5UHzYqDifCp115w34DzUdYe8y1Gqpl2WqS6zecbdc/bRRn5cRGHXhYFcfBIz", + "7y8j2N1zhmkmYTQVEkp+9ft9zDjpYsGN4vRH7V8SPeboJjB3F8MkrydCem9F2p6PYLm+0wN5OU5VnlwM", + "ZxdFf5c4zmySCsEuHXX/abvBhGDbUabGAirqmB4HErv0RtvQLWvutSWI5K5oxMbos50rxHIcWrdj5cN8", + "LG74NImx41/NCmHCdyloqVgw6LjYEhe/3+0A+5qzshGRTHV9oSjJRFkk4Gqgm80S0YUWBvLJ4ZOnvcOj", + "3uHR+8PDY/jfv7qVH4/gx8OjX3/4/l9//v77k5f/PPn7X18cPXnzP4en//3Ty792eTAVvUgG3ZNgKtgr", + "GfS74yTrPetleTpU3UgmedY9elLr7aiptycb6e3JYa23J029PS339svT//nX0d9/P/npnz/+489n7548", + "745jNRQ33V/hP+xUpUmpN5VnprtnZmd5oxiIY284a13dlnfqK7ry+qw2v6vNzzPcB51wUJqvztJIjh/c", + "u3781QZtgyTmcomcXnitxZuLTWzRmQsdbOoq0/l0r0Sqq17c+Vm9t8SLumA6NufxPDMd7dvhaYi4Z/5O", + "K1D1a5uzVIV5kLFTnvFYjTdZbcB02uooNQ+36ic1q7xfcH5DQSNLxVx++75SWsBNcVTDHnLw2fxn6QAx", + "M6vz81uJ5CVuqqHfBxfrVlysG2acuY7ZeUwxFtn+OeJwp0rnIau17sfdODvO9/7O40hyAe+DKbfhANYi", + "zVbehXcrEHcaiXJ9uSBu3eEWf8DDcCEcPg/DHoDPa62CCMwnCF3jLaamO0v2qPXdCdVtjNGMuTwx8/BQ", + "nG0+PLVls5FKt7A7NBcVDkMougY9Y6rowtMTMvW3v1EUxzXgzj2d2Vz/bXsFPLxPVdSAJx1D7n4vwL9h", + "2hecAX8XU3UlPAEapWraKkLeYXDnItRtbZvG+XDm3CwTW9bw+GKH50/HkNZiiQwRgCnQzJv2THofGPNw", + "17r7vhTya2a53Z5zV+Z87+x7R5l/m0fs1S2nnUvfvSv6sBs5nG9IpcEkuhLtcVkn+IL1S9EFZl06qaH7", + "5i+9RzGClhN8PtgVmyb5MI70pJ1Nz/CFhWxKDT2w6Z1lU8sJu2HTVI2ieBGAwBBXiNm3W/yQ9FrPNbqR", + "8JZdsB4SfM8iJqqr2shkNEPLpI1JcV1tE6Kff6n0w8zScYrA0SLLIjlGV6T9mqqzZqmKNYvklYoCMZBj", + "IYnl+uxElitOBVxiQYppHmdREova6FgoRpEUYZ+dDGTlIYs0iyP5CVNCvfRyniR99n4S6ZKNE2kmQKYi", + "PRHhQIZ5auujVBr+TqM7zRa9TsWUR1IXNWxb3Z8VWdpqHElZCvYcUULjbZC68hvffnhJo8QsEMJm7X3w", + "OVoyhKRJPt/KeMZ0HkzqMkOAwyF506CgexEeKFVWSsGmz+yjJJKEycilFzKda9OF+9OBMpjPIKQf5HgU", + "SR6b2bbyr9u8nHVJWWwURQ9eyO1EvvAV+XluaEuVWRt9ibdl+Q/3pwnvi9dvZd6aH6eykL3IYbdHDtuW", + "Q+0rdvw98vn9y2fkX2Ue6HzoZnNBmfPyq1tMSyh1tKn0BO6hp1UyEbgDUbsliQilCdhg3sE7v9195x/4", + "xDzE4syPxamKXl2+S0tbOok3Hh39Brd0biSN4xO2H/jaBkKaWMt/fscDXMwHPy3+4FTJURwFWfPRtMJC", + "i1lyzsZz8Nn/s4ztVzfnKz0vtrTKjX8Ddv1KvHpPTPut8ttSgbfG+sD3sHCM30aLu9t/ZZXw281ybHdt", + "6+yu1An3eeMh+ndFi4M5xt2w0AVcBiJuv/A8heeI4VgSNvbPKI7NWuRxZs4FnJmFDnM4BgW0bbFoZL5M", + "hTkODKQCeI7y2YK+IpjHjJtTxMgMCypEQe/omM+iaZMfHt64FfvRbuw3XK/9+ABW2hPvthvgK+03WMUt", + "76fBhMvxnJCb01hpc1BnaS6lkdqywpEhiqOmGxAloSKOSgF7NVNYLcrewdGF3ymVPtQiRHClZJzyUOgu", + "IB7Zf5u24d4cSWy4qMYH90isca32L9ZIyN2r9LRrAYdp3LKA59Junj1vo2wX+A/u/fp+7m+1DS725p4e", + "Dn4Pm1y7DBTs1sppa8hExm96gSoXSGs49RWvbcdL/koGcR56d+78hkF/TZg1yxzhImzwghrsNMBFDZWK", + "BZe7Pba95zenKrxvQVduORs59D2/WTnNstEHbLl0q3FDtIL7DRgiIhoNCnz07UcKWab5Sp5p0XcHnzOc", + "qFoOYmO8jcdaizdp1/JDvM1W4m02xBnddof8bVnuwz0ojnvifd8YE1G8TTWKRot0r3y0rSiadfa/fbDx", + "AwRMCwQMTMumNlfTtkivmgsf/qYCHne6nTyNO8edSZYlxwcHsflxonR2/DlRafblgCfRwdVTwJxNI9O2", + "xjN3SmduiGvpHHd+/PHHH2HBGzxveVjqRh8fFHt+PzDPbTdGOGjEtaS5IFC5zCI5ZlMu+ZjO9bz4ORFp", + "pELdZVnKpeYBnKm6FOR+JWRutGegxjKyB38S7WJui04ajkFFHWwmrnico6ver1DPMsWCiQg+GdKitFLX", + "vrFHr7h2vce3Xj5BLxZXInaBzYGSo2icp7x1LM/xTd3Qrk3TCTBNx00oZIh1LRRL15akj1I/1wDzIko3", + "jUOuRWjjwhqJqSYG1Wlyxc5CnnHTINXzNysrVTql0OskjQLzE0DIG0JiLse5OYcBXrVmPEiV1sxWutR9", + "hiU4AT5dz2QgQkQkcGkZ4gbliGmVp/CmDBnPM9WDSU6nIkRM92wiZoyPUyEax+hqsTUEWiEjaJaKJBVa", + "SIhMpzVI+DCKoywSmg158AnhvHEz6lKVQFtgLBFpL5dRhjO1mAdsvw0kvXeHeDMxtvZYwOMgj8nAF7jU", + "jr0buzDqqN66TbDxRbUayt9lQZ6mQgYR/NuMyKw78Z2NsV+CBBtsWCfjJEk0ExIKC8xUbkZoVtusrwyp", + "1egPUcrygRoJ7Fqln0axuoa6ZUbTjs00yzEuSMEyM52JKbKMUbVYxRa6DbgELppian7IhJyA8pipvMgr", + "EoHCNkw/GiMM4VbRZwvIhOAa2HeSKhn9YV5BQkEQgKhsEqVhL+FpNjOSnI1UOjUTS0sKNxlmUbvMpi3R", + "iEMRR1cCEobsrHfZhMsQl4vPpoZhAxXHApQqLhBecNpI5FTEHH1D+lPzKplJaViiFzKLsliYLiqsiNlW", + "pDzNLyMrRYtZwm+1Ke6zdC3r95qlPPhEU6tGuFZWVI3awzXulx13NiklkmF0FYU5j7V52U8H05ipYl4k", + "1TkUFuEH2QdyTOqDbRxe2W3YsOm6HWmdsRVf73pcrueGMcEbIDJXNV5ZdmQvik+TVBmSRMi4FSuV63hm", + "5NBoK6uAtUK9P+UzSCEy0zGdijDimYhnjF/xKLaFS7DURnkPdGRj320D067s40RdQ4ISFagUdrzVbEQu", + "eTzLokCzJE8TpY3ioaZo2ez+YBH73I7nFb8045yoEJcKqg1Ecmxasu9Oy02S38oQ48q5AIEMKkWgsjUk", + "jmJxEw1tA3DlGgjJ00jp6uzozpfzL/8vAAD//5TdgNaaLwQA", } // GetSwagger returns the content of the embedded swagger specification file diff --git a/api/v3/openapi.yaml b/api/v3/openapi.yaml index 05868653db..620d5b132d 100644 --- a/api/v3/openapi.yaml +++ b/api/v3/openapi.yaml @@ -19,6 +19,8 @@ servers: description: Cloud variables: {} tags: + - name: OpenMeter Accounting + description: Accounting manages the accounting periods, transactions, and revenue recognition. - name: OpenMeter Governance description: Governance evaluation of customers to check their feature access. - name: OpenMeter Defaults @@ -46,6 +48,131 @@ tags: - name: Meters description: Meters specify how to aggregate events for billing and analytics purposes. Meters can be configured with multiple aggregation methods and groupings. Multiple meters can be created for the same event type, enabling flexible metering scenarios. paths: + /openmeter/accounting/periods: + get: + operationId: list-accounting-periods + summary: List accounting periods + description: |- + List accounting periods. + + Returns the namespace's periods in reverse-chronological order by `start_at` by + default (most recent first). + parameters: + - $ref: '#/components/parameters/PagePaginationQuery' + - name: sort + in: query + required: false + description: |- + Sort periods returned in the response. Supported sort attributes are: + + - `start_at` (default, descending) + - `created_at` + - `id` + schema: + $ref: '#/components/schemas/SortQuery' + explode: false + style: form + - name: filter + in: query + required: false + description: Filter periods returned in the response. + schema: + $ref: '#/components/schemas/ListAccountingPeriodsParamsFilter' + style: deepObject + responses: + '200': + description: Page paginated response. + content: + application/json: + schema: + $ref: '#/components/schemas/AccountingPeriodPagePaginatedResponse' + '400': + $ref: '#/components/responses/BadRequest' + '401': + $ref: '#/components/responses/Unauthorized' + '403': + $ref: '#/components/responses/Forbidden' + tags: + - OpenMeter Accounting + x-internal: true + x-unstable: true + /openmeter/accounting/periods/close: + post: + operationId: close-accounting-period + summary: Close the open accounting period + description: |- + Close the currently-open accounting period. + + Atomically, under a namespace-period advisory lock: + + 1. Freezes membership on the currently-open period `P`: sets `P.end_at`, + transitions `P.status` to `closing`, and records `P.closing_started_at`. + 2. Opens a new period `N` with `N.start_at = P.end_at` and `N.status = open`. + + The transition `closing → closed` (balance snapshot computation, close-time + validations, and seal hash commit) is performed by the close pipeline; poll + `GET .../{periodId}` to observe the final `closed` state, `closed_at`, + `sealed_at`, and seal fields. + + Late-arriving transactions whose `booked_at` falls inside the now-closed period + are posted to `N` with an `adjusts_period_id` backpointer to `P`; they do not + modify `P`. + + Returns the period transitioned to `closing`. The newly-opened next period can + be retrieved by listing with `filter[status]=open`. + responses: + '201': + description: AccountingPeriod created response. + content: + application/json: + schema: + $ref: '#/components/schemas/AccountingPeriod' + '400': + $ref: '#/components/responses/BadRequest' + '401': + $ref: '#/components/responses/Unauthorized' + '403': + $ref: '#/components/responses/Forbidden' + tags: + - OpenMeter Accounting + requestBody: + required: true + content: + application/json: + schema: + $ref: '#/components/schemas/CloseAccountingPeriodRequest' + x-internal: true + x-unstable: true + /openmeter/accounting/periods/{periodId}: + get: + operationId: get-accounting-period + summary: Get an accounting period + description: Get an accounting period by id. + parameters: + - name: periodId + in: path + required: true + schema: + $ref: '#/components/schemas/ULID' + responses: + '200': + description: AccountingPeriod response. + content: + application/json: + schema: + $ref: '#/components/schemas/AccountingPeriod' + '400': + $ref: '#/components/responses/BadRequest' + '401': + $ref: '#/components/responses/Unauthorized' + '403': + $ref: '#/components/responses/Forbidden' + '404': + $ref: '#/components/responses/NotFound' + tags: + - OpenMeter Accounting + x-internal: true + x-unstable: true /openmeter/addons: get: operationId: list-addons @@ -2926,6 +3053,156 @@ components: additionalProperties: false style: deepObject schemas: + AccountingPeriod: + type: object + required: + - id + - name + - created_at + - start_at + - status + properties: + id: + allOf: + - $ref: '#/components/schemas/ULID' + readOnly: true + name: + type: string + minLength: 1 + maxLength: 256 + description: |- + Display name of the resource. + + Between 1 and 256 characters. + description: + type: string + maxLength: 1024 + description: |- + Optional description of the resource. + + Maximum 1024 characters. + labels: + $ref: '#/components/schemas/Labels' + created_at: + allOf: + - $ref: '#/components/schemas/DateTime' + description: An ISO-8601 timestamp representation of entity creation date. + readOnly: true + start_at: + allOf: + - $ref: '#/components/schemas/DateTime' + description: |- + Start of the period (inclusive). + + For the first period in a namespace this is the namespace creation time. For + every subsequent period, equals the previous period's `end_at`. Immutable once + set. + title: Start of period + readOnly: true + end_at: + allOf: + - $ref: '#/components/schemas/DateTime' + description: |- + End of the period (exclusive). + + Unset while the period is `open`. Fixed at the moment a close is initiated, and + immutable thereafter. + title: End of period + readOnly: true + status: + allOf: + - $ref: '#/components/schemas/AccountingPeriodStatus' + description: Current lifecycle status of the period. + title: Status + readOnly: true + closing_started_at: + allOf: + - $ref: '#/components/schemas/DateTime' + description: |- + Timestamp when the close was initiated (open → closing transition). Set on + `closing` and `closed` periods. + title: Closing started at + readOnly: true + closed_at: + allOf: + - $ref: '#/components/schemas/DateTime' + description: |- + Timestamp when the period was marked `closed` (closing → closed transition). Set + only on `closed` periods. + title: Closed at + readOnly: true + sealed_at: + allOf: + - $ref: '#/components/schemas/DateTime' + description: |- + Timestamp when the seal hash was committed. Set only on `closed` periods that + have a seal hash. + title: Sealed at + readOnly: true + seal_hash: + type: string + description: |- + Cryptographic hash sealing the period. The hash covers the period's frozen + transaction membership and closing balance snapshots in a deterministic, + versioned input format described by `seal_algorithm` and `seal_input_version`. + + Set only on `closed` periods that have been sealed. + title: Seal hash + readOnly: true + seal_algorithm: + type: string + description: 'Algorithm used to compute `seal_hash`. Example: `"sha256"`.' + title: Seal algorithm + readOnly: true + seal_input_version: + type: string + description: |- + Version of the seal input format. Versioning the input format lets verifiers + reproduce a historical seal even after the format evolves. + title: Seal input version + readOnly: true + additionalProperties: false + description: |- + An accounting period is a sequential, non-overlapping window of ledger activity + within a namespace. Closing a period freezes its transaction membership and + (eventually) seals an authoritative closing balance. + + Late-arriving transactions whose `booked_at` falls inside an already-closed + period are posted to the current open period with an `adjusts_period_id` + backpointer; they do not mutate the closed period. + title: Accounting period + AccountingPeriodPagePaginatedResponse: + type: object + required: + - data + - meta + properties: + data: + type: array + items: + $ref: '#/components/schemas/AccountingPeriod' + meta: + $ref: '#/components/schemas/PaginatedMeta' + additionalProperties: false + description: Page paginated response. + AccountingPeriodStatus: + type: string + enum: + - open + - closing + - closed + description: |- + Lifecycle status of an accounting period. + + - `open`: the current posting bucket. New transactions can be posted to this + period. Exactly one period per namespace is `open` at any time. + - `closing`: membership is frozen — no new transactions can post to this period + — but balance snapshots and the seal have not yet been committed. At most one + period per namespace is `closing` at any time. + - `closed`: the period is sealed. `closed_at`, `sealed_at`, and (when sealing is + enabled) `seal_hash` are set. Transaction membership and the closing balance + snapshots are immutable. + title: Accounting period status Addon: type: object required: @@ -6753,6 +7030,42 @@ components: $ref: '#/components/schemas/PaginatedMeta' additionalProperties: false description: Page paginated response. + CloseAccountingPeriodRequest: + type: object + required: + - end_at + properties: + end_at: + allOf: + - $ref: '#/components/schemas/DateTime' + description: |- + The intended end of the period being closed (exclusive). Must be strictly + greater than the open period's `start_at` and not in the future. + + Becomes the closing period's `end_at` and the newly-opened next period's + `start_at`. + title: End of period + labels: + allOf: + - $ref: '#/components/schemas/Labels' + description: Optional labels applied to the closing period. + title: Labels + name: + type: string + minLength: 1 + maxLength: 256 + description: |- + Optional display name for the period (e.g. "2026-Q2"). Auto-generated if + omitted. + title: Name + description: + type: string + maxLength: 1024 + description: Optional description. + title: Description + additionalProperties: false + description: Request body for initiating a close on the currently-open accounting period. + title: Close accounting period request ClosedPeriod: type: object required: @@ -8174,6 +8487,46 @@ components: description: Name of the provider, e.g., "OpenAI", "Anthropic". additionalProperties: false description: LLM Provider + LabelsFieldFilter: + type: object + additionalProperties: + $ref: '#/components/schemas/StringFieldFilter' + description: |- + Filters on the resource's `labels` field. + + The schema is a map keyed by the label name; each value is a + `StringFieldFilter`. Both deepObject forms are accepted: + `filter[labels][key]=value` (nested) and `filter[labels.key]=value` + (dot-notation). + title: Labels Field Filter + x-go-type-import: + path: github.com/openmeterio/openmeter/api/v3/filters + x-go-type: filters.FilterLabels + ListAccountingPeriodsParamsFilter: + type: object + properties: + status: + allOf: + - $ref: '#/components/schemas/StringFieldFilterExact' + description: |- + Filter periods by lifecycle status. Use `filter[status][oeq]=open,closing` to + fetch the currently-active periods. + start_at: + allOf: + - $ref: '#/components/schemas/DateTimeFieldFilter' + description: Filter periods by `start_at`. + end_at: + allOf: + - $ref: '#/components/schemas/DateTimeFieldFilter' + description: |- + Filter periods by `end_at`. Open periods (no `end_at`) are excluded when this + filter is applied. + labels: + allOf: + - $ref: '#/components/schemas/LabelsFieldFilter' + description: Filter periods by labels. + additionalProperties: false + description: Filter options for listing accounting periods. ListAddonsParamsFilter: type: object properties: diff --git a/api/v3/server/routes.go b/api/v3/server/routes.go index 7d5b7063d0..0911e13ae5 100644 --- a/api/v3/server/routes.go +++ b/api/v3/server/routes.go @@ -464,3 +464,17 @@ func (s *Server) UpdateOrganizationDefaultTaxCodes(w http.ResponseWriter, r *htt func (s *Server) QueryGovernanceAccess(w http.ResponseWriter, r *http.Request, params api.QueryGovernanceAccessParams) { unimplemented.QueryGovernanceAccess(w, r, params) } + +// Accounting Periods + +func (s *Server) ListAccountingPeriods(w http.ResponseWriter, r *http.Request, params api.ListAccountingPeriodsParams) { + unimplemented.ListAccountingPeriods(w, r, params) +} + +func (s *Server) GetAccountingPeriod(w http.ResponseWriter, r *http.Request, periodId api.ULID) { + unimplemented.GetAccountingPeriod(w, r, periodId) +} + +func (s *Server) CloseAccountingPeriod(w http.ResponseWriter, r *http.Request) { + unimplemented.CloseAccountingPeriod(w, r) +} From 0b9b26b0acdf9cf3fd884875beb559da78bfcc6c Mon Sep 17 00:00:00 2001 From: Andras Toth <4157749+tothandras@users.noreply.github.com> Date: Fri, 15 May 2026 12:53:57 +0200 Subject: [PATCH 2/2] chore: address review comments --- .../aip/src/accounting/operations.tsp | 4 +- api/v3/api.gen.go | 498 +++++++++--------- api/v3/openapi.yaml | 6 +- 3 files changed, 254 insertions(+), 254 deletions(-) diff --git a/api/spec/packages/aip/src/accounting/operations.tsp b/api/spec/packages/aip/src/accounting/operations.tsp index 96fa662cbf..be43497698 100644 --- a/api/spec/packages/aip/src/accounting/operations.tsp +++ b/api/spec/packages/aip/src/accounting/operations.tsp @@ -105,7 +105,7 @@ interface AccountingPeriodsOperations { * modify `P`. * * Returns the period transitioned to `closing`. The newly-opened next period can - * be retrieved by listing with `filter[status]=open`. + * be retrieved by listing with `filter[status][eq]=open`. */ @extension(Shared.UnstableExtension, true) @extension(Shared.InternalExtension, true) @@ -115,7 +115,7 @@ interface AccountingPeriodsOperations { @summary("Close the open accounting period") close( @body body: CloseAccountingPeriodRequest, - ): Shared.CreateResponse | Common.ErrorResponses; + ): Shared.UpdateResponse | Common.ErrorResponses; /** * Get an accounting period by id. diff --git a/api/v3/api.gen.go b/api/v3/api.gen.go index bcf18fa95e..11ff7f7660 100644 --- a/api/v3/api.gen.go +++ b/api/v3/api.gen.go @@ -11028,255 +11028,255 @@ var swaggerSpec = []string{ "STJaFProaTIy/5nmtMrY0ZOjb4+UFIJp7Ia4Yw/Hn4KE0dYaf75469Y4gzXIk8m35LJ/jd6kwhgDC3F5", "gflVQ6uEyusgNwvbd0Mep91HxoRcWTO8gIfwayYijmiaLtnUnP20YCW29D5IEUwzLzHzAoyshoE8eHf5", "/CF2GIbFb0uu2X2sDhNvWB67mh904XMz5YYlbef0g675M8y5YVEUpIY3HXTdN25aIjdD0L4ZLbRHsLLh", - "yvx8w8qSZwzLRQ+8NHg80AobKiVA7H3ByiNzUVVBU0cu8v9n7+2X28aRveFbwas6VZOclWQ7yczOeGvq", - "lMdJZrM7SXwmyW6djVw2REISTyiAS5C2Nan8+17Ac4nPlTyF7gYIfukr+nBsV23txCIJNIDuRqPR/Wvq", - "pc8+IDhGgkjaoEu7KGMDCaWWivKoIyOC9kvGY8P9MyZuIp1pVs6VrDTFuAwLXMUuizJ2HcUxVHVCZ2ut", - "eRfrC+2XPqEc5k1kESxb2ROD3750Ow6EdnOlmf6JFy+RLgZva4u43ip9bygZsKFncZNEqdDQHyzdRdMO", - "dsqlklDqCZe3uFFo3JywoeYtqhJ3h+2ZVxtbSry9ZKnRN21EDZcUpc0GASARlR64uOG+nJ4cXAkZqvI+", - "vnjvdO16c1yMrZTYWOG3OYrDjG5lXBhZQCOgYkhFoNKwW8AP2Bt/fMfpProQtoCypDDg3s77eWc4MqcW", - "GMYBKPQ3A7C9ioJgj4q8Ex5f8xmWtH4+6DxupGarugSXs0GRzCVk44oFybBahb3Fi+Tishmfw12unbr5", - "tG4gr5S2vLLSqnU0deeAlRVNW8qz1Q51dPbdqbXG3gs1t1L3Vgs2BdfQo5pmrPVe+FFW7DsKxDv8tpEB", - "He4ncFhgTkJGzBpp2PCd928eRMs8hdR0pKruDW0bA01bTYu0Q7ws2jveuYVoOa5qI7apsAcxb9cozW7h", - "+JY5N/QjelpjXHmVkVY/dp8V87XOybswVO3BWCVC8ghPxlxmk1QlUbD2qbve/ttEyJNX2P7J3PZXO3E7", - "dK22GCYPBOqHp1UMKB9unPf+OOz9BKDjR18eFX/2+hfn/+k9/RPdx89H7UDCmM5UKlygHcDDSAtp5Bfj", - "yG1hOgw/giOMexFjhVKsKCZ4GkzgeZAqrV1js8TsNLXysWrE0DHPjno/PPXuAzCPk6KpEaADQnEGkISL", - "C/VJSSmCDP+YCj2hn83KQcDVoHMx6PQHslxlVsirznEnE5rCoErICt97yAq0eq3rWoVgXSNMDZEi/Ia+", - "LMCftNEp32l2ieBtl+hSd+VGsW1EWZxiwBpCCCKI+JBM+b9gXkEBLjKQlzVyLvvsF5VNWChE8hZD30cq", - "nRK4fhCIJBPh8UBeImN8RIrOP34Ss/OfoelL9khC/MRjxHwpvdj33hvIR6HKelJhuM1jP0+B2LUCelle", - "lnkgmG4lNwyB+Vuks5MAwnIjOT4DhBS92XR9I10oT7YbQmJpiCQXcr3dssR/ben61KthpEvs6LLPjN50", - "Tx5J5R49Bg4RN1ho2JqWkR5IimA0HJckcURViAscwiUNjpoELkM4cR2l7KfZbmbLdnXZL2MFLNdtTSZf", - "3PA5QLWl4UYjEcyCWNgYVoDwsyKIv51/VOLf5z8bNu8GsdKRHF9C8cCRyKi2qjsF9LB0YMGAjTANIBRh", - "qOS2JAHLmM73NK0zo90loU4q6noJ0M1GNW/tlJU/LDhonVG2LdnphKdjsaU1C7Dx+pptWxqoYyMNXhz3", - "O1cRxuJsGHV1bB712CXZ6pfwB1XLhH+PIslj/CdB2l6aT6rJR36bLrsIsg8S9AO7r+dIkLHAf+F6awti", - "zglD034TEBbPLlbLZF4S8cV1atbDdFMGy5s3HUWxrG3NCCZRYhG0Hbixyyg4VMWuDIKz+mZRLy32DltY", - "vn8Sk0VL4ZXh2u6CZF5H+8Io8mmorZEF8lljhbxJfG9aWZUO0/W8lUIyo60pEdd+E4JouN7uZqdzhTXE", - "uWufBcwneFHgAFmEDgwUf05h4asmJ7tEEg9hyCZJuNSz5sJV7VC6NvOmuc08zlauBNs07rZExXmJn61Y", - "tf4kb43TWmEHbL3fJFWjKBYX34YNBxXn1+01SaMpT2cXYkoAZiu3gKAxXo7VBeVYrUlTm+xB0sSWeCKi", - "xAwmoJP2fMeLVa8nljrhYa/Wr+LhjDq18Op5f1XQzYapXdy/7YfmY3uH2vKQAaYWMFjMz5CSaEnod9a4", - "Q1hr7IS3j7aSSvc6eiQAaUFp2vbgsRe0QqjS1VYHjmM1Xa1h+aw1xAUWjsOH3YaCsdmHjZANa6ldcCSu", - "t0OtudO0TZx/x7Ql/Vy+jtqI7b4CC3lWOpWMFf1xn/0XOb/ss/OP4t/nP39497waW7MNgjCO5tXzCi22", - "W6QF4kzrATrbowfiepooMg/OPwZKZjySGijrrHUzvRpVLj6lTJP9GWcJLwS3vM0U+0uZFPwRCaF71FZB", - "gzTSLUkYRq+3qqeNzwdFyw9n7JPAs+/WuLPoCsPOWuf3LObbckAYG30rbuY74jF+lw/dTG5pCbTfxUIL", - "f8Utda2P4OC2/pfrLL3jm80v42ux+nKdEOo/XDCXSkRhzEAoRlDpeKKuWaYQEAbufl35Cu/E5t3L28fY", - "i84rYTNQV/VZS13VCoWvGEZZfSDox3KlEwoi6/xH3wbz0Lz8Rx/+8aXbAQIv6OckVdME0mBCKDH46w/f", - "/+vP339/8vKfJ3//64ujJ2/+5/D0v396+Veq13TcgWhMfZGpDEJtUGwx8Euz9/SrH940b2hwO17k/ACV", - "0BLtxT4Uqj+DyyplYIET78vmODmvbTDKzdLmuigPQqUqvnQfqhF++9UIN1IZ6A2fipD97d3bN2c8mzBx", - "Y2aEqgQpJm4yQxKmJ6QqT8xeD7zuIQ3heRNcqLXQISogCmFCSmpwm0oI8k0mXGICCSIeylCkOlCpqMyD", - "p3tqCqCmKX2N0OS3paMxSYaF/yRMJ094yvgvTrUsKP6HCvNio2WPIBJSR5KgDFGp6wlApVn6SVGzD1qM", - "cqiwqz9FCVOx87qxV6OBrBRZ5HHMJpHOVArpCHSa56mw7Yb9b6nm5S2p/3jbCxzWt6rqlDXogqoqoJpT", - "VgGUfbzfadAFrh7kzMW8ufeKmlU6n3YZvxp32TSSGE445Te+KGo0YTApF2DELEhTKfgx4am2MK74LnT7", - "UqWkgy4gMstvuVsmHomyiotT0eM+ewkg0bnMBrK0vdp5cFNpCI3GEt2Lvv5wtsAC9lm7+GS3ZFSU1OB5", - "mz15UjZD1rYliqhlMgbNVLmU7wv7J78aEx4DwncYAYfozqbYZiDw9paTQnt8L8WkoGuviJle6xRXrmpm", - "q7C1IbcuZWbsuugaEgvCOade4UCCtQGV5zV7NOiIf2P4cSQHncde+Xbc+FxyfFs1t/JyfJm7QL+mXOYx", - "T6MmJfseDCr3QqmoIBhaoHqgiLzFqSMS7QZurBaL4wb1Nqc886Xx7P3R607X/Mccec6OnsP/v26Xt6+A", - "pz/xOchHuPWMN7SKzBnqqT1DHR7D/8z5aexPFlFrJgMADjrHnQ/vT7FIodfCE6+FL/PqBC5/wipJVpvb", - "q86eJDlbLXmJ4ZysKGwUaVe4FvNHvlSmcfWR+yzbQlL0h2iogAlTggcEj0CZqZbq3gPpxlApl4knCplF", - "qfCL/kLbF8PZRVkbza9y6pNEYRlsOCvx5cdOybtwvgJGd1X5e+zqlSAgzq0T6kL6DXW+eQrTatphXJOb", - "xmHQvzp5c4Ja4V/mhedUk3sgASXz+ODg+vq6H3HJ+yodH5iWeqYl/RjhmYumI43pIplioVn+aSTxgAE8", - "h/nrzcVOdVvB9g/vT+E9aN/lqOuWsrbbKco6T0gy1V+kstdCfn5dUn0WXNXTfGhbfKzupCW36HyHlfWF", - "wa1TL8vToep4kF5J7pXbbdOw7bqTjgSd487Rk/7TZ9//APO8bmtflo+iwiVC9HDgKaxObpSCXymOiWmS", - "zbDYAiL9UymAZUOsvAXecu3y9bT2/mRhqcix8vRtqL55xeT0xeWbkZL1LOWHUt23ulQ3rfJmSnV7HUC7", - "danD7lYqw20xjxHreI3NKpJj8oSOVByrawtUcRqrHBGUtQOiqLtDC41eEjiFB8dpYoyev4o4Vl12rdI4", - "/P9gWOD/KBlOTiJBsr8Pjg5HPBS9o+An0XsW/hD0fnzy5+97wfdPgqc//PnpUfg0KHK3jztUqaVH/hFD", - "7pVINY7yqH/Y8cK7nBLpgUsFg7BKGqBym1O+Umrd0ZYtY1d4nhM+ixUP+8zeEHRZNGLkzWNR5rmf/vbu", - "7RumKHSsjslW4wpDFFTGk1mz//sUH6IvhyTDX3HYe5FL2Vtzai5EZdChIqkAsf6/WslBh0V6ILlhH2u5", - "//X9+zP/BFr9xjBz4RSrPW0do6cpecZR8Obm2mdFfi3edZqR8XAiUvMQqls4MPc8jWpuuYV0zE2Q18Wl", - "SNkNuCSLL/Aw68VYAwg6A0USzdZ7PYngbpd4cMKTRMiqj7IiT/789HzcwkXU+XLoH4NQJBuOQfhyE0OW", - "VBCNorhvyikrqhgCdrGIwCLms3JTAH8NLftQCTFbwBC6JDPGTm3pGdVcTAfykUNHCYvYpMdlUssKaQHJ", - "6wWNLioo4XBkVECxMqJgDfba6CEUGXNG/P3lKXv69OlP5VHM0aALRahdR/FIakaaiC5Qh3aHsroL5zwV", - "UK3YemFUGmFZIjkeyGJUlZlX0z791ddqKqCldRzzDkXEZ3n6smCz81KNItx6X1CXrRt7uZjByrhU7kZj", - "Wt7sAZoBH5YqN5U3d7/+0CKb2955und3sotf4JXHGtt4Kfh+3pdelHrDa0/wtS9fX7rJJuT87jTsguJN", - "UUkfaT+jAZbXr2vtr84KnkBnWTaTQlIWO53oJRN8VXLDvAtwqNnXnskAz6NM+7XW4BBiA/3XTzpYgyrs", - "ze4WIfno7OEiCrHqTFs9OfIN0mu2rBztNeWb1tUcIFXF8g/XiaspNzezzGpKf5H9qT33K5YSmaupuipF", - "q2k+aKI+dVuoRV008PU1qBuwzrCINHPAjgCQt2wl5VOskLx89WbT5SSfcsluSwXnNyp7qXIZFkywXM4u", - "18Jy8udaeZWMkvAKS+CNMuffXIaouXTGZRWU/pOS4+Ms5YE4Pnry9Nn3P/z5x58OyzGe7uVnh8++uOmo", - "9vPS9mPNnuKxLW8F/yVMAsC3eXb4rMlffW5miJwOdfwsiqhyESLa2P08HUZZytOZOWkGEdjbFCNRLmI1", - "GPT+6+Nh76fzPz0aDPr4rxakqrdeATyqX/ye3xjuW7mWrNdSLxZXImZ0bGAZv0HudycQQoYwSgcN9eqr", - "DrAGwqAsmialn1rT3WLumiOsX8mPisuaCTKbSp6pKc+iAOreF/ayX/ov0nMwdTcbYlmy3m0AZTNWJ+Sh", - "XwBawEXGb1aEiaB1nGeTPK8uEAEnl7EZnE7yHrhPUOquFAD07ZBK12e5xDb9WCJvm/X8vFCtJeAN6/PU", - "tsqrgRie8bF4LZruZ9xJLClqveIdl1eRwZZShhhqF6I1IrdV+aamLBtUY8HXhMWxyxVguOnpRPBPgutZ", - "LxNpykcqnfYwxqpAwYz+KKtUL1JjtZYwFLzc1HptVdbPfQq02o5aFsSLDqqtCk4oaj5vYSKK/8AjaHmm", - "E9r1F8QkicZwpMTu0SQnZfKawN2WmOazmEuAnlo1mMt+V93e6AxkZmJI4Zwc8oIwoUESGFUX1H+qYCsY", - "SHKLIU4VQuW5Kq9GUSR5Gky4FnCwimyTDeakG8pSCgJG4LQWlU9pvDsAymonPFh6IsSZmvDqQ1j/nQjr", - "H6VqegFpSIlhv+XnqRRA3chSn4SLNAPxgA4wjrdwrxLfWfzrZqHwue+l+b5ob3NB46uGgE/5zcW/cw5r", - "3Xa2woUptirgGn/cNp6YBhq6eFcQOvZSpbYIcc8eGpwSAdRkwPkssFOp/jNEKk7zOItqnxlVJGSBTpZL", - "KHguQmYHUyOq75UYg43T1Sm+cR91moq+PUTJLx8lv8hT8xuBADW6HJbyy5zBpUF2yjMeq3GDQ6bttP2P", - "apedBc6b5WLJcSurq6BGS8Xuxrc3TrswNPYSq226v72TQ7hThsg9TU8aBeL2zk+pNsieJmiedlhtjmoK", - "gwAcoLoBOMdE2GTWRFrnYgsuVJ2leZDlqQitT2bTrtTX6EYt6uPAuAnBcnX/qau2WTcqEm7McryDRJDv", - "0o0jKFV9kKTqIOWZCHga6gMIiDkg7Jq/w31WG0Uvqejl8i7dSmGgHbpz7Tw1sXMtC2TlUEL0PxA0NZXR", - "wUwwx48Adp3yzHC4OdJN8ywH9x2AXOvoSnQhAXUglRRM0btwk0ahLDxjnMCTalwvmwo6qekQMum9mgUh", - "EantpVysxpBkefLm+dLGQX2+KjHo80pugligB6clu8vOGLPvlQdA4WpNWa7/XtQipdss2V4kF7UXaQar", - "NWposmxsLYrZnzthctkZcwXW6INlRyoXT11Ru83M4dINLzWHptldzKNKv1JK3v6+IyEpLmxQOzFso614", - "QZMSs6lsX6/LJDMjZuBpIrU25cli1TaQFd3GHlTbLVFtWOBxYZvwlteArVn8oBwflOPtU46vecLMN3O0", - "5O8iyNPUFVtZUTm6r20KC86AZFwGE9CU4NSPZCbSKx43KTPz3mZcS+Ah6kGUD3WfKUDHJydZhdQqdMi8", - "6DR7uKFmgYBuxw5refJfvXv74w+HR88pT7jF92vbdfnEfgIx8/KHHe1nkEBcXJHS9/5nri2KF64eD2gl", - "vFGdN7JL4biuCccJeK0BA4LAZHz0By+PkcJuZ4wXvsvSeOyvFD/oF/V6trio1/mfHv3X8YX74/F//oc3", - "OXYEDI9yNQ1hn7/mko9F+MtsQa24KJgwxCxkU/hE+6MayIH8B+glWwwDC8ZdHkOWp33PTA5+HTJ8IZ6x", - "R1SvNhSSDWdM5Sk7OXtlJjHVj/vQGHY8pzEC18X36BsPAm6JL72359W9g+jPYpLOGya8aLlp3t+pNAPl", - "1bwDXHIdXDKdj0bRDWyk9oKHl4NLtEozptKQ8NR0IGQYyXEfYU0uTcN+M5YjMfzEMKR5A7/BZvoD+TqP", - "syiJBTZeOFTYlM/A1+92oIgDhNt0ypkWCU/ByxVHOusPpANrsRW57Od1GnQ+7BVb3iMxPmbfjZTqD3kK", - "9H33uFKEzXMUwwsevxfz2jTpNXBD0MkzUmXV9xfsDdWCBW1WCAhE2eLDgtqkLjCe/NEo/+OPGcLdPV7a", - "BsS2zTtBVsBJNHexkiGI1V7TXHQL75G7OrJpQY+kkj2Zx/Hjv2AUEs5M/YuB5EP6wrzdbFGOs7bxRZqN", - "YcVTo1tl6xTG4iYK1DjlySQKCENDNE/mOBPL9qZSa9ap5XoeyLldx/PGGQutNzbIeO4gi65WHuH8bmU7", - "pzYYyksyqmoXsN8p9gRu0TDNiGcM5Kln4SPd9TKoq14o7E1mMkmhohCeB1x9OcJY8hOOToz1+UIGCjQs", - "tPPcNjPXCq+PpWmCmkchbniQsVs4iob4zwWlJ0sLjeoBeWs4YyLKJiKl0aqUecqwz07i2GF2RVQXy26I", - "f7HbEX5LPgZve6HZIjSd/tw6j3QW2XidxxZI1c1tPlvZGrYjxg+sX2X9YpjA6qzM6QP5FazurCLrPSwK", - "oDLkwcXiUHtvQzLh2c/rxNxhvF0RDEPOiKoBXzl/b7g0/7LxHbAyPIRUxhIGgX8erEV68I3W71+HVg+q", - "YD6lu480rC70Q8ThHYw43E+03u0IRZsfL+gC8IgSlBSzgVzzmWZHiGEK0YCsGtbXFqP33/Pi82yHu2ZX", - "dDklKqI0d5vV6CbgmmtAk1HxFeEHNbDArY/r+6qoOC+w0l+mbmm/a/Jv1jbh2xv1VLcX9hL65JNx60Po", - "fGL3M12UC3XrZ4ro3OskFQljdY2PbxTZhvVRL1dTpCn8dhmSbCTBnsmCd2tkmF/Zow8yuhKphruED3gf", - "85vvs4IH71SaQeiZu9RIKwAoc4Hc/MuXw96fzz8e9n466f31b39//eas9/4fvX+df37y/Rf//gUobtjd", - "qwVeSr6AxdO1jntgRTNqNW8CrIFFEnO+gw102epqqPS4eceC6cC6FejO2wK8r+VWWGJVN+VpgLnZg58B", - "+vW9DHP9CyQbG3YsfJA8zyYqjf4Q207UfyUhwwLyiw2LcTw/bCJl/6g5Zd8f3MpZ+0dtWfsfwKj0qr6/", - "uDFqjsfvREaln9eD36av2FCFMziRgPlqMZME9cISPoNC1dp1R2XkEZET84kHEhKK61vMVxW5PyMH0hmS", - "UAy4tfC9OX1Jcd1OdB1KkShs3NFg6qkO6aYnmdsapH2Gtc5RmAlBL5dRdgEVNlFTYCrXQNIRoz7R7oOV", - "55rG90FG2an5vj6rzp+QiLRnOsLan6X6YFBHhg3oMn7QoUjrUXQjwvJ3XabSgRx04ng66BjVFSv1ieUJ", - "NurKg7gSoxYKB+JnQoYYVCJFlO7ecOZfP/TZO5GZNi9lHseX5l9BLDjhg99Q5TlHyl8gfQ5oEPxKMMPI", - "uQwmXI5xjmuAZFaX2haasaGRcQCtZj22QXRoOpV6yPhVtfdQTer2VZP6Fj1a7Uw8B7FlPdae0+BChn+A", - "KNkEREnzYmuRZuT7X6uYB1z55NDMrdZY1gC8WK3COYzvFX37HmS/0frwXyn7f3WfnWJC9qCDzt9Bh6nU", - "7JkU1DXo+Eu3ida+WQd7yjNxAUlvzS5285zB84qTfdlDHRk/vxvbmqdor9soQdf2ovxocgKXWapE/Hm7", - "rCWJxXF8zjO+ptSVG1kof9aqv3DKYmVzsdKlPY04RdMgFx+M3UYYlA6TcsI14yyO5CcRFqcNRxfjSeJL", - "w4vaG3g8S6NVpLh5DO+wlXUIx0+rxNoG2zWtzaNO1SiK1zxblNtYQvcSqnJDOCEE+AAORVSOYU2w8eag", - "wFugzb9N7aZzQJtLV2bcM562FlkC4snIzYzB7OE7OTgS2zMutgW4o1UeyAIiyZB5rdJPo5iqd6xC5j/t", - "h82U2m5t+3BMj+S4ANizFLVpXDeBHpFdx+HtStdKPdG5vuJtaGihAPIkuXBFAL5CXTXdeSZJoaAsPLOL", - "uqg+NPNBa3BhJ3plTrSaaz4EcYXDHB86vGEjXVQZysaud0saqNpCrUYUjfKX8nvzlG+Bn/w1S79wve0U", - "8zA059nVl52+mz+z1LpzlNuJZR8cDBG/QajjpgOCnTbXWbdDEOizVQCp8Qu8pjuvzxg+nkMjjaY7n1jb", - "0MPm8xWbT5JGU57OLsSUfOYN2BT4CoNXWjnMW5gz+uAFtNmE3aT5WFzYRJKVithblzB1C3X/T7yG6vz2", - "micJHHmVl60JTkMRUlUrCqZ3apFSjNCNRODxpcsT+KrUbdPO1L7zOFSh9ZROgWL4DRyx7wIW3QOK3J1E", - "kWs2J5dBLivEeH0J/haE9xvd1My6tfiKCsG2lVEpZR4dDSmfJhYXyI9bZiekXfR1lAUTKg6j6e4go5Kz", - "IV6DOisVi8+yk4zFgmtEB8BmoAYlst6qXirAhLOaqZx8bzfgYoydephUkqqLFK4dL4Q0mjAsOQTwbqvZ", - "KZCkqoefmgHQ1945rYIpe1a8bnuqew6ahZCob5c95xhfR/xsONQyh7Qp2g+6CR4MLQuz5kkChYXgjsrh", - "yK+6skTWSZJQ074j8oS68Htgjrj6Mj9ojw3uCSVGaGTKiiH6Dq3GRjgCembMl/7CslFwSTFSTUsoJN4M", - "A7BBEKs8ZJJn0ZUt1upqN5lpsTqJyiVhMWfXxkCenL1CkB/NZioHMASoq4JWsO4S2hDetkP7XWgXk+fd", - "gsCEx1EgKGwUl7RzkvBgItgTKMeUpzGFv1C1aQ5Pod40faoPfnt1+uLNuxe9J/3D/iSbxiAKIp3qt6N3", - "OAQvhMaFGfVhGg7gxZ4a9Wi0nk4qpu3k7FWn2ynViupDmI9pjSdR57jzFH6CaMIJ8LEf0BQEKpdGuR2g", - "nocXxiJrQXkt3qd9AetQ/O7BsZvJ0gkPxHfavsMiyVJhiBS9YJIqqSyIC2IJDGfsEvKULnh2yYazgbSu", - "kkdTpY1qC6BIZ5TqDOInEdQpUvJV2DnuxJHOegVlPTsSM2QL0d9qqBevHHhhw5GSmNb/pVtjfJVmbmAW", - "2N+r7IthwuxdniQqNWZnFdeAp8LCVRSDfkQj7noQCY/hnSIe/xL+jsJLuL9PYriDpa0hMqT9m5AIiF9N", - "x51upygUOTfg3SEZwCXEDPhspNJpwxRQSt/CSeg00zWysXrLUWYY78StLiLp6DOzbJqi/jyKQyGSt0Xw", - "oiUF2PrJ4aGFTrDVwKq1N48/L0lUlaDmkHPQfEvGlX/pdp4hgU39uoEc/MJDay/AJ0eLP6mG8T07fLr4", - "o5cqHQI8CmwnOp9OeTpr1wNGO3FjYHz0tZN7zew3Nz1Av5E8tgbaTS83pzcXjmR6mqudDoJYoU5OKDCs", - "4pczj8kPQhFoPdNenWDQWyeZmmKodhdDZRgv9BfpEcbDq0irdMZiFXwCyT3qs5epEH8IzabCHH31JEps", - "SGylY2rk8uzymGmRaXZ51hcSxLk7kFnKpQaDDx5g5B4EeV2akUZyfIk7VCoClYbwEj24oMJupqX+QD4B", - "WDyoGAnhgtTtm0vMYbx807fKhv3MHAlYLvsNdcx+ZobmS5gbs7UW5Dl62P/9//8Pg1UIL9mjIY/h7K0l", - "T/QEwM6mSY4ZSV18DTCjBrIAB9c4Ii14zCZcTyASOsoeGxMgEanROQVCDjTBkigRcSTFX1ii4nggL399", - "8Z71+/2DzzjOV+EXmDQ1hCrfFEJtTMNLS6oZoejav2n6Lw0R9FdBFLgccGP7jWeix9M0ugLvm5kOHuBy", - "XU8MZZdDpT5hC2zE49jsdToKkQSprnvYH63HQPJUMMO6CErjlodLdsnD/811pi/wVShdPuTBJ8hFEwC3", - "dXl2+RfT8IyFikmVDeRUhdFoZh7U9mFb9t4tIXVp+QqNJymuiVNFyKS4sVsbC7gcyKFR5lkaiStckZjC", - "DZGlUI9/RN45/xlZp7Y7IxPUtucOmqhCZ7+ocLYxvQwKoKqcnb4sG8aUrFfZI462tkc0bQfVd2wVrW9w", - "Yyh0b7PG3dEOUaiEVlP2V5EBjF6VQsPiUVhn4bHIGhm4Yl6CrQOpBM7UsbR0qny3rPFD6Uq7NGWWYtNv", - "gj3NF88Wf2HrLFb4uY1LtsLHgI2+4OwVx35KddMZCFvZ4rnHuua/8twThXiW+SRm+A8jLpfV4447FOFB", - "qMhFvrT2ydfi1rECtm4gV8KtuyVHsIXrscEjGDDX3s9d7Wnjd/ewhYvcqHeoNgaj4hhLKp9u2/EJhI+O", - "EEX4acWgg5d6Fg1gK1YcdFG6XN617YY5/1++NEeFf8NWGi0x4tZsjqWa9rODz/BfMsUQgKbBk6xGGeLD", - "FPfczXYYvuQ4b7H5Rd1v3vp61uDhR3yd+2AZ1Vdso7qp3Wafyx1gpe+fNQ53pYPuJqN1O8+OlhjKr0qK", - "Jnt989yY5A3ciJlkRUnVNp5Em3VPbLn5fbkhp2qpfXlnMuHuwh9EwxcNy6673fQPeBpMoqs57voTfMGT", - "I7rJrEsStXWvNDydeO+DSeE4ocQGu2PVJB/GkZ60s+oZvrAMq1JbD6x6N1nVccKOWDVJFjgGIQI2jkXI", - "zLttvkHTzEY8g1vlsiS5b84dXJcGj7J5cN7ADAefeZIscb1RYouW41KSLKefTIe3WTsVaWWNKipJ7s2F", - "BazoktxEaVEUJ9quYIr3INsS3ft0Qe9C8rAITrPy8Tra4uWER+ZX3k8EKhTV6we6oni4eICLh2XmGiZL", - "2dqO3heGdWYJGHsYqqHiWF2bMWJ8Jiz/MX340bx6/jPmNW3uOuPUkbPvKw2bAnjPNr6STqgrLNLoa5lM", - "RdMHxDbtAWP2xgNftFTNjISCXJMus2HFkG1hOHWm8pSpa0kfDqT90k/+ZEmeJkoL3XqLgl/3XILqNu9T", - "XE4r9LmnixWX++jT0sTl5Te+/RuXCoNtn+kPPtu+zAE3UDrrDW1K0Zy9XukMcOk0ZRAVEvFSpZVRREJD", - "ansqbE6dg+qRXkMQLhZGI0isz9ilGI1EARV+CSDlbecWj+5lLNViyF9rrrbufMW4lt35ii+GMzaKuFN+", - "M0yAmb8P2hozH82XgLx1/vOHd883uBUqnf1iyFtmJ+zevkMj0R/pO72Dft3ZoCLbG9A+C2MIbG9RTZO0", - "boYk69GuZf18q9uuZc8977iWjMbN1j68A/usY7stbLGIreBvoY2nXfvaVg+71MmmYvHgfFs585Zyjx5O", - "vnSOXTjx1YOv/WA4A7SH5Y69n8Ts/OfprBcOe1CeZWPnXqJm/8deJOTeHXsL5VDXTm51OufeBjvn5Air", - "v80jYxlXal+HRRpq4zGR8G7uyAERFnQ+Y7RsSua8h/+sBdw1htF5/S1ja9mmH4LpNmuZ41CXX/1us+Ux", - "FtntWdHDvWiAe3LFswKnUOxaNSZNi3S/zLKtyLS1tqv9MOtDpFpLpBpMy0b3wgPyxree2nzd2bMv31kd", - "ioCr7azpA8DeM5Xq7m2oht6a+jX07fN9MtS29WwD6PB+Ve4qvP2ggefFCq8nEquo4wOeJD2LHr2KJPXc", - "h3dIpFqKJ+xHnGrw3I0xVc11Gh6kaRlp4kmyBYnC4hEHwUQEn1Se9TQVnVoi/uEj1X04pW/ZO/z2/JHF", - "JwtVoPvYA1T4o4p02nX3eCAbwdCxD814rXGsRaTiWASYYE9F7qYim6iwDPefYpAFjR/9yDQ+CtMQADQ2", - "6GiR5cmgw6YqFF0C0aVOtOsCCyzqgbyOsokhKZjwdGxrBbr1iqZTEUY8E/EMu6SGRFgl1tWzsyi3ozzL", - "U1FC4LTLD9PyUqVsglAwdgbtgHSXpSKMUhH4jn5CeHZu5w+//0YIumI6FGEoQu/73OIgxZGQ2YUWQYp1", - "5CIZZRGPoz8Elfro/y/M20zl6UB6qmNBzIpIe8gMvSq73Q21XLEscK7IK0oDJi7er3P0JEnm0qbzOGs0", - "ieB1+rTpo2/Lo7pDnU46s0VhbkWjJyrNeLy8Pre0WTV2Bt9bEkH9fNBilMdGIzhVU9J8pG1aWsqUBc3M", - "JiJKB7KsDXWXYc1JfFwr7cBlyHgQmH/iC1gcQbBJpDOVzvoD+VbGM9J12qi6WtWiahmNSNsSRplinGlX", - "x8j0VmwdS6u18pzffaVm7+Ng2LdStTVTuJSCa//0Qc0tpeac2KFYML1JbQe21+IsBHvTh2/XEO/sC99p", - "+woWYOepMZqoDJQIGddMRAAFPop5xkZCQP1ewAPuYUle20VbOgNpCkv3puI8tqpSWuJIaKbmBjOsFEhS", - "Bawl+GLCNexDyCc8cAWbvAe3JcjDYzEvkoPmajizBcMXRW5WMBI/KvHv859pgrocYmAvNxjbgfQtGcZZ", - "HviLm8RsyqM8jhkigmPYXmrLYYVMyCyCktRllqDCxR4npILHF1k0FRcgU5fHjFoHKQUivzMcx2MAB0Uk", - "7jaoKgGfluZhFTh6mhMkwKtu7CDmywyx1YgXIOUhSHVBkGpFzW8viq+yB0HlY32AMKzg2ZgDXGArKBdv", - "2wh4G8k25Z8Ew9rx3lsajdNiqxpIaomgdCvClWvRC7gWmmQLqzYFKjUGO+6/zcYsNNorOr4b9isZgjC4", - "Eze2PUcnVahpsUVL79xxo7MRcawuMouMx80LNwnZ/NRpVpHIxtTpwgZESbMt71bMrM34dbbDryJDBv0F", - "B7Hv0NCSYBFNul2s7Bv3Jse7dNIp8eruJWqcctop55zckEZ8te1MhWJEze1cijYSmG8PD/5wdwHNimLw", - "K/S397DugpYHS3eBpevzyUYkdylcV7/bPjsp/V34STQgHcWxQi5gasSSVCQ8Cq3FWjFl+wtMUWj/7lmh", - "wOm3wQAFQto3SXh8L83OKs/va488+BwUK7EQv6csps0m6P4Eq8VX6Y/vW4iIXF5w7o9peQsl5UCLLIuF", - "OTIeiBvbX5tvhkJuoAYOXUoW31vHrRqZ/c02Fs/YKJehCMtSR9ekWBdUyBBK8UCW4kxCHbvoj0o/mem5", - "3LZ7eB1lk4E0ryNWEtMK7ydScSVkLqDG01hiuSUuHS1U7DmKo2zGrlX6CS4wbhKIQmmFnPWVQ8/S0ism", - "4o4qjG2E54Xlzf4FTeY7N5d7jn1dXovdI5RGG3jnG7dOJGv6YPeazq8lttTpuVR8zAIqeFF29iaUSxZN", - "pzkQ1mXlcptYRc4oKGp0qq5gGvRxWQHqgQQNpKTOp8WvffbepwIvVovjLdX4ZA01PgdyOLO54fM9AKWJ", - "uW1+gNM81Spd1RNQWrqd+QP8pbodXgGPoqX8Ajjb99czUBGFHWkouOZF7djDGK3l4C56DR/enSQqHzvh", - "RTHQExinZeK2YHlY1EqICt7+s5HgWZ4KDInDWDicu3tzz+uxDXNsU+d1b9LrcUW0s+iDjN/0oGz93GQ/", - "lY65jP6AH3v0ba/4dIts9Nbr+Tl2TAXzGy845rx+X46k/lo5dJmM3zC7VnVWoZnSq9b4aDxILcEr2zp0", - "zFn9PR05Nsi+dzphqOkosn1GLutEcSUW3sxFciwgAwVfbrHMob1IjnvU5KrhjitazdjLsvBK9PZwxnQO", - "luyycIr0+vlHiMmzRszR5szwF0DZWtF4EJq5aB6Ww/fKojqul132IkYzU2mB8/XPiZBMTaMsE2HXkmEO", - "e9pBf0OzgNF1yR5NlTaCHJgdfBSlOnvcZ9AGhy/MjIs4hPreqbqKzDHTZl1xghLrsggxw7QH/NVnJ0ki", - "KG7QBx4byEzRmO27XUapZ4gtZhHK7HteozsOMd2mUfqK1hE47Q4fqerWo1VJzKkkqz1f2ycofl95c4oz", - "DF4V6Mlw2ZBnwYSpkZWMQs8Y/juNVY4LognNrjWfDsWwQb0uZ1IEpif85k+r8Y2dIyATprel3R6MtaH1", - "pUJwK91UY28r3dY74XL2dtS6wbT1shnizpeyrJ7UOeb9RFjGmPArwYZCyGKfhcSn1PxKqUvmvAM5CXSl", - "oHIdz74dYUT5WEUcK1aKPf8urn1t32wxUlxDWwTddIf1r9yTH+pef2V+xuKFKBuJ7v3hDHn1IgqXtRPt", - "+5S9McgPD58GUQj/FZuzFl8iifv21Doy7hUqp6c86qewl/bhhoKwqLPWgCl6vlVgTxrTngKXqPcmfqJH", - "3z6cZ7GKX81RzTvmwWf614L62gQw6fhuQXXtgu7FrntHwAMo6FZAQTfIQ/PKai/ijLHIbgtbHO5SBz1k", - "hNfd8RtlycScLtura1f4kmFJoCyeMSVjLD+Xyyi7AMh/9DHZJDy0mVujo/bHzdu6K1hnQ9+pMN2/2KOd", - "WgBQ4OkAjyGtoZFwysKLaCMyajTPGoW2rKRAbZY7IS4w/zARnqzsQDZOlc6o2zbEkvdwgAWi2IRrpvMg", - "ECI0euzOygqypFX0xGUblpexujKvy0AsJyCWGkIowmC7OEKJKSDorDfGRQanQqv4SmgmeDAp7jqiUMgs", - "GkUIqlSE7YEzMC0ATAaSOqQYZQumRywhQndM7bIkzj23TzkJcCD9kGEg8+K50NFYontnKFiAhYGVNAog", - "ugG1PEqFnjCY2ise23gU8onYdWSRHkjzDgQL2saCiQj7Fy0apJj91qig9e4Pt6QgfnX0VrXELnfUGhXt", - "LphvU200aIGCU+YFAhUz06YMkjS64plYUjvE8RR2twPTbhqFi3zRiUh7Zq/TCQ8ES9IoEMx92uKctn30", - "ij6a99Kv9yP+9ttrs9WcGbq+1Yp+QPw9c0H+9ttrsso8Fqlzv3nNrO+mnJHzuLnVQ1lj5y35KomX31Iv", - "SPSunZW+QDWyH8zZN++vrPHfJthvkaY9+Awct6wHczVmJYdmE7MuPsYQXQ+Oza04NnfJbLCSC/b0cayG", - "PC7Iwm/6zCbV4N9YyNgxLwOdYgz8EeNytmjrJzpqzNd4wUkEbO56cR2zoOEGnCZiQzUn6YiU9u0PUxWK", - "2PxVuQOvVIyu/Jape3kz/mC13SKrzUn3dtVYecOcc6VjQ88qFLLhjL16Xig2yF6GB626bSAbldtYVHXb", - "fvfVw50ZfPfRTWeYqsxJm2d1yzjzNmp8Z16c+lYDwPCLLYR/8fE4FWMgoBQPdtIWDnbyEA3mjKVFq1KO", - "BaO31yrGDN/2PonZ5gwzEJy9J+gCFfds73bqohSrWi693OI1gU9b3SPwdKvhW0DpnoK3oO8mrsAt4Jt3", - "hNjVq3FF02518Bn+u6wDo4VvyFNhe15sRVGnD96JrXgnWjlgbhAVfEX2daO1fAuW93BXWuCeJCfP4RTK", - "KW6JbGpRBBSetB9O2VZo0uqb1c7Y9P4FJbVx7NrntWIHXC64wirKkUqp8AMg3ouMXZ4EgUiyY1Zd7kv2", - "yDvHPDaHkjE6ObI0D7I8FSH727u3b3yLv9RgJm6yg0BfXZpPQ3UtY8XR7Nd8KqAQozkscXb67h8Miknp", - "PIKBGzIHUiep4KGeCJFR5UHzYqDifCp115w34DzUdYe8y1Gqpl2WqS6zecbdc/bRRn5cRGHXhYFcfBIz", - "7y8j2N1zhmkmYTQVEkp+9ft9zDjpYsGN4vRH7V8SPeboJjB3F8MkrydCem9F2p6PYLm+0wN5OU5VnlwM", - "ZxdFf5c4zmySCsEuHXX/abvBhGDbUabGAirqmB4HErv0RtvQLWvutSWI5K5oxMbos50rxHIcWrdj5cN8", - "LG74NImx41/NCmHCdyloqVgw6LjYEhe/3+0A+5qzshGRTHV9oSjJRFkk4Gqgm80S0YUWBvLJ4ZOnvcOj", - "3uHR+8PDY/jfv7qVH4/gx8OjX3/4/l9//v77k5f/PPn7X18cPXnzP4en//3Ty792eTAVvUgG3ZNgKtgr", - "GfS74yTrPetleTpU3UgmedY9elLr7aiptycb6e3JYa23J029PS339svT//nX0d9/P/npnz/+489n7548", - "745jNRQ33V/hP+xUpUmpN5VnprtnZmd5oxiIY284a13dlnfqK7ry+qw2v6vNzzPcB51wUJqvztJIjh/c", - "u3781QZtgyTmcomcXnitxZuLTWzRmQsdbOoq0/l0r0Sqq17c+Vm9t8SLumA6NufxPDMd7dvhaYi4Z/5O", - "K1D1a5uzVIV5kLFTnvFYjTdZbcB02uooNQ+36ic1q7xfcH5DQSNLxVx++75SWsBNcVTDHnLw2fxn6QAx", - "M6vz81uJ5CVuqqHfBxfrVlysG2acuY7ZeUwxFtn+OeJwp0rnIau17sfdODvO9/7O40hyAe+DKbfhANYi", - "zVbehXcrEHcaiXJ9uSBu3eEWf8DDcCEcPg/DHoDPa62CCMwnCF3jLaamO0v2qPXdCdVtjNGMuTwx8/BQ", - "nG0+PLVls5FKt7A7NBcVDkMougY9Y6rowtMTMvW3v1EUxzXgzj2d2Vz/bXsFPLxPVdSAJx1D7n4vwL9h", - "2hecAX8XU3UlPAEapWraKkLeYXDnItRtbZvG+XDm3CwTW9bw+GKH50/HkNZiiQwRgCnQzJv2THofGPNw", - "17r7vhTya2a53Z5zV+Z87+x7R5l/m0fs1S2nnUvfvSv6sBs5nG9IpcEkuhLtcVkn+IL1S9EFZl06qaH7", - "5i+9RzGClhN8PtgVmyb5MI70pJ1Nz/CFhWxKDT2w6Z1lU8sJu2HTVI2ieBGAwBBXiNm3W/yQ9FrPNbqR", - "8JZdsB4SfM8iJqqr2shkNEPLpI1JcV1tE6Kff6n0w8zScYrA0SLLIjlGV6T9mqqzZqmKNYvklYoCMZBj", - "IYnl+uxElitOBVxiQYppHmdREova6FgoRpEUYZ+dDGTlIYs0iyP5CVNCvfRyniR99n4S6ZKNE2kmQKYi", - "PRHhQIZ5auujVBr+TqM7zRa9TsWUR1IXNWxb3Z8VWdpqHElZCvYcUULjbZC68hvffnhJo8QsEMJm7X3w", - "OVoyhKRJPt/KeMZ0HkzqMkOAwyF506CgexEeKFVWSsGmz+yjJJKEycilFzKda9OF+9OBMpjPIKQf5HgU", - "SR6b2bbyr9u8nHVJWWwURQ9eyO1EvvAV+XluaEuVWRt9ibdl+Q/3pwnvi9dvZd6aH6eykL3IYbdHDtuW", - "Q+0rdvw98vn9y2fkX2Ue6HzoZnNBmfPyq1tMSyh1tKn0BO6hp1UyEbgDUbsliQilCdhg3sE7v9195x/4", - "xDzE4syPxamKXl2+S0tbOok3Hh39Brd0biSN4xO2H/jaBkKaWMt/fscDXMwHPy3+4FTJURwFWfPRtMJC", - "i1lyzsZz8Nn/s4ztVzfnKz0vtrTKjX8Ddv1KvHpPTPut8ttSgbfG+sD3sHCM30aLu9t/ZZXw281ybHdt", - "6+yu1An3eeMh+ndFi4M5xt2w0AVcBiJuv/A8heeI4VgSNvbPKI7NWuRxZs4FnJmFDnM4BgW0bbFoZL5M", - "hTkODKQCeI7y2YK+IpjHjJtTxMgMCypEQe/omM+iaZMfHt64FfvRbuw3XK/9+ABW2hPvthvgK+03WMUt", - "76fBhMvxnJCb01hpc1BnaS6lkdqywpEhiqOmGxAloSKOSgF7NVNYLcrewdGF3ymVPtQiRHClZJzyUOgu", - "IB7Zf5u24d4cSWy4qMYH90isca32L9ZIyN2r9LRrAYdp3LKA59Junj1vo2wX+A/u/fp+7m+1DS725p4e", - "Dn4Pm1y7DBTs1sppa8hExm96gSoXSGs49RWvbcdL/koGcR56d+78hkF/TZg1yxzhImzwghrsNMBFDZWK", - "BZe7Pba95zenKrxvQVduORs59D2/WTnNstEHbLl0q3FDtIL7DRgiIhoNCnz07UcKWab5Sp5p0XcHnzOc", - "qFoOYmO8jcdaizdp1/JDvM1W4m02xBnddof8bVnuwz0ojnvifd8YE1G8TTWKRot0r3y0rSiadfa/fbDx", - "AwRMCwQMTMumNlfTtkivmgsf/qYCHne6nTyNO8edSZYlxwcHsflxonR2/DlRafblgCfRwdVTwJxNI9O2", - "xjN3SmduiGvpHHd+/PHHH2HBGzxveVjqRh8fFHt+PzDPbTdGOGjEtaS5IFC5zCI5ZlMu+ZjO9bz4ORFp", - "pELdZVnKpeYBnKm6FOR+JWRutGegxjKyB38S7WJui04ajkFFHWwmrnico6ver1DPMsWCiQg+GdKitFLX", - "vrFHr7h2vce3Xj5BLxZXInaBzYGSo2icp7x1LM/xTd3Qrk3TCTBNx00oZIh1LRRL15akj1I/1wDzIko3", - "jUOuRWjjwhqJqSYG1Wlyxc5CnnHTINXzNysrVTql0OskjQLzE0DIG0JiLse5OYcBXrVmPEiV1sxWutR9", - "hiU4AT5dz2QgQkQkcGkZ4gbliGmVp/CmDBnPM9WDSU6nIkRM92wiZoyPUyEax+hqsTUEWiEjaJaKJBVa", - "SIhMpzVI+DCKoywSmg158AnhvHEz6lKVQFtgLBFpL5dRhjO1mAdsvw0kvXeHeDMxtvZYwOMgj8nAF7jU", - "jr0buzDqqN66TbDxRbUayt9lQZ6mQgYR/NuMyKw78Z2NsV+CBBtsWCfjJEk0ExIKC8xUbkZoVtusrwyp", - "1egPUcrygRoJ7Fqln0axuoa6ZUbTjs00yzEuSMEyM52JKbKMUbVYxRa6DbgELppian7IhJyA8pipvMgr", - "EoHCNkw/GiMM4VbRZwvIhOAa2HeSKhn9YV5BQkEQgKhsEqVhL+FpNjOSnI1UOjUTS0sKNxlmUbvMpi3R", - "iEMRR1cCEobsrHfZhMsQl4vPpoZhAxXHApQqLhBecNpI5FTEHH1D+lPzKplJaViiFzKLsliYLiqsiNlW", - "pDzNLyMrRYtZwm+1Ke6zdC3r95qlPPhEU6tGuFZWVI3awzXulx13NiklkmF0FYU5j7V52U8H05ipYl4k", - "1TkUFuEH2QdyTOqDbRxe2W3YsOm6HWmdsRVf73pcrueGMcEbIDJXNV5ZdmQvik+TVBmSRMi4FSuV63hm", - "5NBoK6uAtUK9P+UzSCEy0zGdijDimYhnjF/xKLaFS7DURnkPdGRj320D067s40RdQ4ISFagUdrzVbEQu", - "eTzLokCzJE8TpY3ioaZo2ez+YBH73I7nFb8045yoEJcKqg1Ecmxasu9Oy02S38oQ48q5AIEMKkWgsjUk", - "jmJxEw1tA3DlGgjJ00jp6uzozpfzL/8vAAD//5TdgNaaLwQA", + "yvx8w8qSZwzLRQ+8NHg80AobKiVA7H3ByiNzUVVBU0cu8v9n792b28aRveGvgld1qiY5K8nOZW7emjrl", + "cZKZ7E4Sn0myU2cjlw2TkMQTCuAQpG1NKv++H+D5iM8neQrdDRC86WZdfKva2olFEmgA3Y1Go/vX1Euf", + "fURwjASRtEGXdlHGBhJKLRXlUYdGBO2XjMeG+6dMXEU606ycK1lpinEZFriKXRZl7DKKY6jqhM7WWvMu", + "1hfaL31COczryCJYtLInBr997XYcCO36SjP9gRcvkS4Gb2uLuN4qfa8pGbChZ3GVRKnQ0B8s3WnTDnbE", + "pZJQ6gmXt7hRaNycsKHmLaoSd4ftmVcbW0q8vWSh0TdtRA2XFKXNBgEgEZUeuLjhvpye7F0IGaryPj5/", + "73TtenNcjK2U2FjhtxmKw4xuaVwYWUAjoGJIRaDSsFvAD9gbf3zH6T66ELaAsqQw4N7O+3lrODJHFhjG", + "ASj01wOwvYyCYI+KvBMeX/IplrR+Meg8bqRmo7oEl7NBkcwkZO2KBcmwWoW9w4vk4rIZn8Ndrp262bSu", + "Ia+Utryy0qp1NHHngKUVTVvKs9UOdXT27am1xt4LNbdU91YLNgXX0KOaZqz1XvhRluw7CsR7/LaRAR3u", + "J3BYYE5CRswaaVjznfdvHkTLLIXUdKSq7g1tGwNNW02LtEO8zNs73ruFaDmuaiO2qbAHMW/XKM1u4fiW", + "OTf0I3paY1x5lZGWP3YfF/O1ysm7MFTtwVglQvIIT8ZcZuNUJVGw8qm73v67RMjD19j+4cz2lztxO3St", + "thgmDwTqu2dVDCgfbpz3/trv/Qig40++Pir+7PVPT/7Te/o3uo+fjdqBhDGdqVS4QDuAh5EW0sgvxpHb", + "wnQYfgRHGPcixgqlWFFM8DQYw/MgVVq7xqaJ2Wlq5WPVkKFjnj3pfffMuw/APE6KpkaADgjFGUASLi7U", + "ZyWlCDL8YyL0mH42KwcBV4PO6aDTH8hylVkhLzoHnUxoCoMqISt86yEr0Oq1rmsVgnWFMDVEivAb+joH", + "f9JGp3yj2RmCt52hS92VG8W2EWVxggFrCCGIIOLnZMr/HfMKCnCRgTyrkXPWZz+rbMxCIZJ3GPo+VOmE", + "wPWDQCSZCA8G8gwZ4xNSdPLps5ie/ARNn7FHEuInHiPmS+nFvvfeQD4KVdaTCsNtHvt5CsSuFdDL8rLM", + "AsF0K7lmCMzfIp0dBhCWG8nRMSCk6PWm6xvpQnmy3RASS0MkuZCr7ZYl/mtL16deDSOdYUdnfWb0pnvy", + "SCr36DFwiLjCQsPWtIz0QFIEo+G4JIkjqkJc4BAuaHDUJHARwonrKGU/zbYzW7ars34ZK2Cxbmsy+fKK", + "zwCqLQ03GopgGsTCxrAChJ8VQfzt5JMSf578ZNi8G8RKR3J0BsUDhyKj2qruFNDD0oEFAzbCNIBQhKGS", + "m5IELGM629O0yox2F4Q6qajrBUA3G9W8tVOW/rDgoFVG2bZkR2OejsSG1izAxutrtmlpoI6NNHhx3O9d", + "RRiLs2HU1YF51GNnZKufwR9ULRP+PYwkj/GfBGl7Zj6pJh/5bbrsIsg+SNAP7L6eIUHGAv+Z640tiDkn", + "nJv2m4CweHa6XCbzgogvrlOzHqabMljerOkoimVtakYwiRKLoG3BjV1GwaEqdmUQnOU3i3ppsffYwuL9", + "k5jMWwqvDNdmFyTzOtoVRpFPQ22NLJDPCivkTeIH08qydJiuZ60UkhltTIm49psQRMPVdjc7nUusIc5d", + "+yxgPsHLAgfIInRgoPgLCgtfNjnZJZJ4CEM2ScKlnjUXrmqH0rWZN81t5nG2dCXYpnG3JSrOSvxsxar1", + "J3ljnNYKO2Dr/SapGkaxOL0dNhxUnF+11ySNJjydnooJAZgt3QKCxng5VqeUY7UiTW2yB0kTG+KJiBIz", + "mIBO2vMdT5e9nljohIe9Wr+KhzPq1MLrF/1lQTcbpnZ+/7Yfmo/NHWrLQwaYWsBgMT9DSqIlod9Z4Q5h", + "pbET3j7aSird6eiRAKQFpWnTg8de0AqhSlcbHTiO1XS1guWz0hDnWDgOH3YTCsZmHzZCNqykdsGRuNoO", + "teJO0zZx/h3ThvRz+TpqLbb7EizkWelUMlb0R332X+T8ss9OPok/T376+P5FNbZmEwRhHM3rFxVabLdI", + "C8SZ1gN0NkcPxPU0UWQenHwKlMx4JDVQ1lnpZno5qlx8Spkm+zPOEl4IbnibKfaXMin4IxJC96itggZp", + "pBuSMIxeb1VPa58PipY/n7LPAs++G+POoisMO2ud3+OYb8oBYWz0jbiZ74jH+H1+7mZyQ0ug/S7mWvhL", + "bqkrfQQHt9W/XGXpHd+sfxnfiOWX65BQ/+GCuVQiCmMGQjGESsdjdckyhYAwcPfryld4JzbvXt4+xl50", + "Xgmbgbqqz1vqqlYofM0wyuojQT+WK51QEFnnP/o2mIfm5T/68I+v3Q4QeEo/J6maJJAGE0KJwV+++/bf", + "33/77eGrPw7/+evLJ0/f/s/+0X//+OpXqtd00IFoTH2aqQxCbVBsMfBLsw/0qx/eNGtocDte5PwAldAS", + "7cU+FKo/g4sqZWCBQ+/L5jg5r20wys3S5rooD0KlKr52H6oR3v5qhGupDPSWT0TI/vH+3dtjno2ZuDIz", + "QlWCFBNXmSEJ0xNSlSdmrwde95CG8LwJLtRa6BAVEIUwISU1uE0lBPkmYy4xgQQRD2UoUh2oVFTmwdM9", + "NQVQ05S+Rmjy29LRmCTDwn8SppMnPGX8F6da5hT/Q4V5utayRxAJqSNJUIao1PUYoNIs/aSo2UcthjlU", + "2NWfo4Sp2Hnd2OvhQFaKLPI4ZuNIZyqFdAQ6zfNU2HbD/m2qeXlD6j/e9AKH9a2qOmUNuqCqCqjmlFUA", + "ZR/vNxp0gasHOXUxb+69omaVziddxi9GXTaJJIYTTviVL4oaTRhMygUYMQvSVAp+THiqLYwrvgvdvlIp", + "6aBTiMzyW+6WiUeirOLiVPS4z14BSHQus4Esba92HtxUGkKjkUT3oq8/nC0wh31WLj7ZLRkVJTV40mZP", + "HpbNkJVtiSJqmYxBM1Uu5fvU/skvRoTHgPAdRsAhurMpthkIvLnlpNAe30kxKejaK2KmVzrFlaua2Sps", + "bcitC5kZ2y66hsSCcM6oVziQYG1A5XnNHg064k8MP47koPPYK9+OG59Ljm+r5lZejq8zF+iXlMs85mnU", + "pGQ/gEHlXigVFQRDC1QPFJG3OHVEot3AjdVicdyg3uaEZ740Hn948qbTNf8xR57jJy/g/9+0y9s14OkP", + "fQ7yEW494w2tInOGembPUPsH8D9zfhr5k0XUmskAgIPOQefjhyMsUui18NRr4eusOoGLn7BKktXm9qqz", + "J0nORkteYjgnKwobRdoVrsX8ka+VaVx+5D7LtpAU/SUaKmDClOABwSNQZqqluvdAujFUymXiiUJmUSr8", + "or/Q9un59LSsjWZXOfVJorAMdj4t8eWnTsm7cLIERndV+Xvs6pUgIM6tE+pC+g11vnkK02raYVyTm8Zh", + "0L8+fHuIWuHf5oUXVJN7IAEl82Bv7/Lysh9xyfsqHe2ZlnqmJf0Y4ZmLpiON6SKZYqFZ/kkk8YABPIf5", + "683FTnVbwfaPH47gPWjf5ajrlrK2mynKOktIMtWfp7JXQn5+U1J9FlzV03xoW3yq7qQlt+hsh5X1hcGt", + "Uy/L03PV8SC9ktwrt9umYdt1Jx0JOgedJ0/7z55/+x3M86qtfV08igqXCNHDgaewOrlRCn6lOCYmSTbF", + "YguI9E+lABYNsfIWeMO1y1fT2ruThYUix8rTt6b65hWT0xeXWyMlq1nKD6W6b3Spblrl9ZTq9jqAdutS", + "h90tVYbbYh4j1vEKm1UkR+QJHao4VpcWqOIoVjkiKGsHRFF3hxYavSRwCg+Ok8QYPb+KOFZddqnSOPz/", + "YFjg/ygZTk4iQbK/DZ7sD3koek+CH0Xvefhd0Pvh6fff9oJvnwbPvvv+2ZPwWVDkbh90qFJLj/wjhtwL", + "kWoc5ZP+fscL73JKpAcuFQzCKmmAym1O+UqpdUdbtIxd4XlO+DRWPOwze0PQZdGQkTePRZnnfvrH+3dv", + "maLQsTomW40rDFFQGU9mzf7vI3yIvhySDH/FYe9FLmXvzKm5EJVBh4qkAsT6/2olBx0W6YHkhn2s5f7r", + "hw/H/gm0+o1h5sIpVnvaOkZPU/KMo+DNzLXPivxavOs0I+PhWKTmIVS3cGDueRrV3HJz6ZiZIK+LS5Gy", + "G3BBFp/jYdbzsQYQdAaKJJqt93Icwd0u8eCYJ4mQVR9lRZ78+en5uIXzqPPl0D8GoUg2HIPw5SaGLKkg", + "GkVx35RTVlQxBOxiHoFFzGflpgD+OrfsQyXEbAFD6JLMGDu1pWdUczEdyEcOHSUsYpMel0ktK6Q5JK8W", + "NDqvoITDkVEBxcqIgjXYG6OHUGTMGfH3V0fs2bNnP5ZHMUODzhWhdh3FI6kZaSK6QD23O5TVXTjnqYBq", + "xdYLo9IIyxLJ0UAWo6rMvJr06a++VhMBLa3imHcoIj7L05cFm52UahTh1vuSumzd2MvFDJbGpXI3GpPy", + "Zg/QDPiwVLmpvLn79Yfm2dz2ztO9u5Vd/BSvPFbYxkvB97O+9KLUG157iq99vX7pJpuQ87vTsHOKN0Ul", + "faT9jAZYXr+utb86S3gCnWXZTApJWex0opdMcK3khlkX4FCzrz2TAZ5HmfZrrcEhxAb6r550sAJV2Jvd", + "LULy0dnDRRRi1Zm2enLkG6TXbFk52mvKN63LOUCqiuVfrhNXU25mZpnVlP4i+1N74lcsJTKXU3VVipbT", + "fNBEfeo2UIu6aOD6NagbsM6wiDRzwI4AkLdoJeUjrJC8ePVm0+U4n3DJbkoF57cqe6VyGRZMsFjOLtfC", + "cvKXWnmVjJLwCkvgrTLn31yGqLl0xmUVlP6zkqODLOWBOHjy9Nnzb7/7/ocf98sxnu7l5/vPv7rpqPbz", + "yvZjzZ7isS1vBf8lTALAt3m+/7zJX31iZoicDnX8LIqochEi2tj9PD2PspSnU3PSDCKwtylGolzEajDo", + "/den/d6PJ397NBj08V8tSFXvvAJ4VL/4A78y3Ld0LVmvpV4sLkTM6NjAMn6F3O9OIIQMYZQOGurVVx1g", + "DYRBWTRNSj+1prvF3DVHWL+SHxWXNRNkNpU8UxOeRQHUvS/sZb/0X6RnYOquN8SyZL3bAMpmrE7IQz8F", + "tIDTjF8tCRNB6zjLJnlRXSACTi5jMzid5D1wn6DUXSgA6Nsila7Pcolt+rFE3ibr+XmhWgvAG9bnqW2V", + "lwMxPOYj8UY03c+4k1hS1HrFOy6vIoMtpQwx1C5Ea0huq/JNTVk2qMaCrwmLY5crwHDV04ngnwXX014m", + "0pQPVTrpYYxVgYIZ/VVWqV6kxnItYSh4uanV2qqsn/sUaLUdtSyIFx1UWxWcUNR83sJEFP+BR9DyTCe0", + "68+JSRKN4UiJ3aNJTsrkNYG7LTDNxzGXAD21bDCX/a66vdEZyMzEOYVzcsgLwoQGSWBUXVD/qYKtYCDJ", + "LYY4VQiV56q8GkWR5Gkw5lrAwSqyTTaYk24oCykIGIHTWlQ+pfHuACirnfBg6YkQZ2rCqw9h/XcirH+Y", + "qskppCElhv0Wn6dSAHUjS30WLtIMxAM6wDjewr1KfGfxr5uFwue+V+b7or31BY0vGwI+4Venf+Yc1rrt", + "bIULU2xVwDX+uG08MQ00dPGuIHTslUptEeKePTQ4JQKoyYDzWWCnUv1niFSc5HEW1T4zqkjIAp0sl1Dw", + "XITMDqZGVN8rMQYbp6tTfOU+6jQVfXuIkl88Sn6ep+Y3AgFqdDks5Jc5hkuD7IhnPFajBodM22n7X9Uu", + "O3OcN4vFkuNWVldBjZaK3Y1vbpx2YWjsJFbbdH9zJ4dwpwyRO5qeNArEzZ2fUm2QHU3QLO2w3BzVFAYB", + "OEB1A3COibDJrIm0zsUGXKg6S/Mgy1MRWp/Mul2pb9CNWtTHgXETguXy/lNXbbNuVCTcmOV4B4kg36Ub", + "R1Cqei9J1V7KMxHwNNR7EBCzR9g1/4T7rDaKXlHRy8VdupXCQFt059p5amLnWhbI0qGE6H8gaGoqo4OZ", + "YI4fAew65ZnhcHOkm+RZDu47ALnW0YXoQgLqQCopmKJ34SaNQll4xjiBJ9W4XjYVdFKTc8ik92oWhESk", + "tpdysRpBkuXh2xcLGwf1+arEoM8quQligR6cluwuO2PMvlceAIWrNWW5/jmvRUq3WbC9SM5rL9IMVmvY", + "0GTZ2JoXsz9zwuSiM+YKrNEHi45Uzp+6onabmcOFG15oDk2z25hHlV5TSt79viUhKS5sUDsxbKOteEGT", + "ErOpbNfXZZKZETPwNJFam/BkvmobyIpuYw+q7YaoNizwOLdNeMtrwNYsflCOD8rx5inHNzxh5psZWvJ3", + "EeRp6oqtLKkc3dc2hQVnQDIugzFoSnDqRzIT6QWPm5SZeW89riXwEPUgyoe6zxSg45OTrEJqFTpkVnSa", + "PdxQs0BAt2OHtTj5r9+/++G7/ScvKE+4xfdr23X5xH4CMfPyhx3tx5BAXFyR0vf+Z64tiheuHg9oJbxR", + "nTSyS+G4rgnHIXitAQOCwGR89Acvj5HCbqeMF77L0njsrxQ/6Bf1ej6/qNfJ3x7918Gp++Pxf/6HNzl2", + "BAyPcjUNYZ+/4ZKPRPjzdE6tuCgYM8QsZBP4RPujGsiB/BfoJVsMAwvGnR1Alqd9z0wOfh0yfCGeskdU", + "rzYUkp1PmcpTdnj82kxiqh/3oTHseEZjBK6L79E3HgTcAl96b8+qewfRn8UknTRMeNFy07y/V2kGyqt5", + "BzjjOjhjOh8OoyvYSO0FDy8Hl2iVZkylIeGp6UDIMJKjPsKanJmG/WYsR2L4iWFI8wZ+g830B/JNHmdR", + "EgtsvHCosAmfgq/f7UARBwi3yYQzLRKegpcrjnTWH0gH1mIrctnP6zTo/LxXbHmPxOiAfTNUqn/OU6Dv", + "m8eVImyeoxhe8Pi9mNemSa+BG4JOnpIqq74/Z2+oFixos0JAIMoWHxbUJnWB8eSPhvlff00R7u7xwjYg", + "tm3eCbICTqK5i6UMQaz2muaiW3iP3NWRTQt6JJXsyTyOH/8do5BwZupfDCQ/py/M280W5ShrG1+k2QhW", + "PDW6VbZOYSyuokCNUp6Mo4AwNETzZI4ysWhvKrVmnVqs54Gc2XU8a5yx0Hptg4xnDrLoaukRzu5WtnNq", + "g6G8IKOqdgH7nWJP4BYN04x4xkCeehY+0l0vg7rqhcLeZCbjFCoK4XnA1ZcjjCU/4ejQWJ8vZaBAw0I7", + "L2wzM63w+liaJqh5FOKKBxm7gaNoiP+cU3qytNCoHpC3zqdMRNlYpDRalTJPGfbZYRw7zK6I6mLZDfHv", + "djvCb8nH4G0vNFuEptOfWeeRziJrr/PYAqm6vs1nI1vDZsT4gfWrrF8ME1idlTl9IK/B6s4qst7DogAq", + "Qx6cLw6199YkE579vErMHcbbFcEw5IyoGvCV8/eaS/MvGt8BK8NDSGUsYRD458FapAdfa/3+VWj1oApm", + "U7r9SMPqQj9EHN7BiMPdROvdjFC02fGCLgCPKEFJMRvIJZ9q9gQxTCEakFXD+tpi9P57Vnye7XDb7Iou", + "p0RFlOZusxrdBFxyDWgyKr4g/KAGFrjxcX3XiorzAiv9ZeqW9rsm/2ZtE765UU91e2EnoU8+GTc+hM4n", + "djfTRblQN36miM6dTlKRMFbX+PhGkW1YH/ViNUWawm8XIclGEuyYLHi3Rob5lT36KKMLkWq4S/iI9zG/", + "+T4rePBepRmEnrlLjbQCgDITyM2/fNnvfX/yab/342Hv13/8883b496Hf/X+ffLl6bdf/fsXoLhhd68W", + "eCn5AuZP1yrugSXNqOW8CbAGFknM+Q7W0GWrq6HS4/odC6YD61agO28L8L6SW2GBVV2XpwHmZgd+BujX", + "9zLM9C+QbKzZsfBR8jwbqzT6S2w6Uf+1hAwLyC82LMbx/LCOlP0nzSn7/uCWztp/0pa1/xGMSq/q+8sr", + "o+Z4/F5kVPp5Nfht+oqdq3AKJxIwXy1mkqBeWMKnUKhau+6ojDwicmI+8UBCQnF9i7lWkftjciAdIwnF", + "gFsL35vTlxSX7UTXoRSJwsYdDaae6pCue5K5rUHaZ1jrHIWZEPRyGWWnUGETNQWmcg0kHTHqE+0+WHqu", + "aXwfZZQdme/rs+r8CYlIe6YjrP1Zqg8GdWTYgC7jBx2KtB5GVyIsf9dlKh3IQSeOJ4OOUV2xUp9ZnmCj", + "rjyIKzFqoXAgfiZkiEElUkTp7p1P/euHPnsvMtPmmczj+Mz8K4gFJ3zwK6o850j5O6TPAQ2CXwhmGDmX", + "wZjLEc5xDZDM6lLbQjM2NDIOoNWsxjaIDk2nUg8Zv6r2HqpJ3bxqUrfRo9XOxDMQW1Zj7RkNzmX4B4iS", + "dUCUNC+2FmlGvv+VinnAlU8OzdxojWUNwNPlKpzD+F7Ttx9A9hutD/+Vsv9X99kRJmQPOuj8HXSYSs2e", + "SUFdg46/dOto7dY62FOeiVNIemt2sZvnDJ5XnOyLHurI+Pnd2NY8RXvdRgm6tuflR5MTuMxSJeJP2mUt", + "SSyO4wue8RWlrtzIXPmzVv2pUxZLm4uVLu1pxCmaBrn4aOw2wqB0mJRjrhlncSQ/i7A4bTi6GE8SXxpe", + "1t7A41kaLSPFzWN4j62sQjh+WiXWNtiuaW0edaqGUbzi2aLcxgK6l1CVG8IJIcAHcCiicgxrgo03BwXe", + "AG1+O7WbzgFtLl2acY952lpkCYgnIzczBrOH7+TgSGzPuNgW4I5WeSALiCRD5qVKPw9jqt6xDJl/2A+b", + "KbXd2vbhmB7JUQGwZylq07huAj0iu47D25WulXqic3XF29DQXAHkSXLqigBcQ1013XkmSaGgLDyzi7qo", + "PjTzQWtwaid6aU60mms2BHGFwxwfOrxhI11UGcrGrndLGqjaQq1GFI3y5/J7s5RvgZ98naWfu952inkY", + "mvPs8stO382eWWrdOcrtxLKPDoaIXyHUcdMBwU6b66zbIQj06TKA1PgFXtOd1GcMH8+gkUbTnU2sbehh", + "87nG5pOk0YSn01MxIZ95AzYFvsLglVYO8xbmmD54CW02YTdpPhKnNpFkqSL21iVM3ULd/0OvoTq/veFJ", + "Akde5WVrgtNQhFTVioLpnVqkFCN0IxF4fOnyBL4qddu0M7XvPA5VaDWlU6AY3oIj9l3AontAkbuTKHLN", + "5uQiyGWFGK8uwbdBeG/ppmbWrcVXVAi2rYxKKfPoaEj5JLG4QH7cMjsk7aIvoywYU3EYTXcHGZWcDfEa", + "1FmpWHyWHWYsFlwjOgA2AzUokfWW9VIBJpzVTOXke7sBF2Ps1MOkklSdpnDteCqk0YRhySGAd1vNToEk", + "VT381AyAvvbOaRVM2ePiddtT3XPQLIREfbvsOcf4KuJnw6EWOaRN0H7QTfBgaFmYNU8SKCwEd1QOR37Z", + "lSWyDpOEmvYdkYfUhd8Dc8TVl/lBe6xxTygxQiNTVgzR92g1NsIR0DNjvvTnlo2CS4qhalpCIfFmGIAN", + "gljlIZM8iy5ssVZXu8lMi9VJVC4Jizm7Ngby8Pg1gvxoNlU5gCFAXRW0gnWX0Ibwth3a70K7mDzvFgQm", + "PI4CQWGjuKSdw4QHY8GeQjmmPI0p/IWqTXN4CvWm6VO999vro5dv37/sPe3v98fZJAZREOlEvxu+xyF4", + "ITQuzKgP07AHL/bUsEej9XRSMW2Hx6873U6pVlQfwnxMazyJOgedZ/ATRBOOgY/9gKYgULk0ym0P9Ty8", + "MBJZC8pr8T7tC1iH4ncPjt1Mlk54IL7R9h0WSZYKQ6ToBeNUSWVBXBBL4HzKziBP6ZRnZ+x8OpDWVfJo", + "orRRbQEU6YxSnUH8JII6RUq+DjsHnTjSWa+grGdHYoZsIfpbDfXilT0vbDhSEtP6v3ZrjK/SzA3MAvt7", + "lX0xTJi9z5NEpcbsrOIa8FRYuIpi0I9oxF0PIuExvFPE45/B31F4Bvf3SQx3sLQ1RIa0PwmJgPjVdNzp", + "dopCkTMD3h2SAVxCTIHPhiqdNEwBpfTNnYROM11DG6u3GGWG8Q7d6iKSjj42y6Yp6s+jOBQieVcEL1pS", + "gK2f7u9b6ARbDaxae/Pgy4JEVQlqDjkHzbdgXPnXbuc5EtjUrxvI3s88tPYCfPJk/ifVML7n+8/mf/RK", + "pecAjwLbic4nE55O2/WA0U7cGBiffO3kXjP7zVUP0G8kj62BdtXLzenNhSOZnmZqp70gVqiTEwoMq/jl", + "zGPyg1AEWs+0VycY9NZhpiYYqt3FUBnGC/1FeoTx8CLSKp2yWAWfQXKf9NmrVIi/hGYTYY6+ehwlNiS2", + "0jE1cnZ8dsC0yDQ7O+4LCeLcHcgs5VKDwQcPMHIPgrzOzEgjOTrDHSoVgUpDeIkenFJhN9NSfyCfAiwe", + "VIyEcEHq9u0Z5jCeve1bZcN+Yo4ELJf9ljpmPzFD8xnMjdlaC/IcPez//v//h8EqhGfs0TmP4eytJU/0", + "GMDOJkmOGUldfA0wowayAAfXOCIteMzGXI8hEjrKHhsTIBGp0TkFQg40wZIoEXEkxd9ZouJ4IM9+efmB", + "9fv9vS84ztfhV5g0dQ5VvimE2piGZ5ZUM0LRtX/T9J8ZIuivgihwOeDG9hvPRI+naXQB3jczHTzA5boc", + "G8rOzpX6jC2wIY9js9fpKEQSpLrsYX+0HgPJU8EM6yIojVseLtkZD/8315k+xVehdPk5Dz5DLpoAuK2z", + "47O/m4anLFRMqmwgJyqMhlPzoLYP27L3bgmpS8tXaDxJcUmcKkImxZXd2ljA5UCeG2WepZG4wBWJKdwQ", + "WQr1+CfknZNP4s+Tn5B9ajs0MkJti+6gmSp09rMKp2vTzaAEqgra6cyycUwJe1vbJ5q2hOo7FDR2GzeH", + "Qv82a90t7RKFWmg1Z38RGUDpVSk0bB6FdRYeiayRgSsmJtg7kE7gzB1LS6fKd4saQJSydHLT2PRWsKf5", + "4vn8L2ytxQo/t3HJRvgY8NHnnL/i2E+rbjoHYSsbPPtY9/w1zz5RiOeZz2KK/zDiclY98riDER6Ginzk", + "M2ujXBe7jhXQdQO5FHbdDTmGzV2PNR7DgLl2fvZqTx2/uwcuXORGvUP1MRgVyFhQ+XTbjlAgfHSMKEJQ", + "KwYdvNSziAAbseKgi9IF80K225P18lnjTgjX1qSlbqOVRkuM2DXrY6mm/WzvC/yXTDEEoWnwJqthhhgx", + "xV13sx2GLznOm29+Uffrt76eN3j5EWPnPlhG9RVbq25qt9lncgdY6btnjf1t6aC7yWjdzvMnCwzlFyVF", + "k72+fm5M8gZuxGyyoqxqG0+izbojtlz/vtyQV7Vtn8psmXD34Q+i4YuGZdftbvp7PA3G0cUMl/0hvuDJ", + "Ed1m1iWJ2rpXGv5W+QKvZ1I4TiixwfZYNcnP40iP21n1GF9YhFWprQdWvZus6jhhS6yaJHMcgxAFG8ci", + "ZObdNt+gaWYtnsGNclmS3DfnDq5Lg0fZPDhpYIa9LzxJFrjeKLFFy3EpSRbTT6bDm6yditSyRhWVJPfm", + "wgJWdEFuotQoihVtVzDFe5Bxie59uqR3YXlYCKdZ+XgdbfBywiPzmvcTgQpF9fqBrigeLh7g4mGRuYbJ", + "Ura+o/eFYZ1pAsYehmuoOFaXZowYownLf0AffjKvnvyEuU3ru844cuTs+krDpgHes42vpBPqCos0+kom", + "U9H0HrFNe9CYvfHAFy1VUyOhINeky2xoMWRcGE6dqjxl6lLShwNpv/QTQFmSp4nSQrfeouDXPZekusn7", + "FJfXCn3u6GLF5T/6tDRxefmN23/jUmGwzTP93hfblzngBkpnvXObVjRjr1c6A2w6TVlEhUS8UmllFJHQ", + "kN6eCptX5+B6pNcQhIyF0RCS6zN2JoZDUcCFnwFQedu5xaN7EUu1GPJ1zdXWna8Y16I7X/HF+ZQNI+6U", + "3xSTYGbvg7bOzCfzJaBvnfz08f2LNW6FSmc/G/IW2Qm7N+/QSPRH+k7voNc7G1Rkew3aZ24Mge0tqmmS", + "1s2QZD3atqyfbHTbtey54x3XktG42dqHd2CfdWy3gS0W8RX8LbTxtGtf2+hhlzpZVywenG8rZ95S/tHD", + "yZfOsXMnvnrwtR+cTwHxYbFj72cxPflpMu2F5z0o0bK2cy9Rs/tjLxJy7469hXKoaye3Op0Tb4OdcXKE", + "1d/kkbGMLbWrwyINtfGYSJg3d+SACAs6mzFaNiVz3sN/1gLuGsPovP4WsbVs0w/BdOu1zHGoi69+t9ny", + "GIns5qzo/k40wD254lmCUyh2rRqTpkW6W2bZVGTaStvVbpj1IVKtJVINpmWte+EeeeNbT22+7uzZl++s", + "DkXQ1XbW9EFg75lKdfc2VEdvRf0a+vb5Lhlq03q2AXh4typ3Gd5+0MCzYoVXE4ll1PEeT5KeRZBeRpJ6", + "7sM7JFItBRR2I041iO7GmKrmWg0P0rSINPEk2YBEYQGJvWAsgs8qz3qaCk8tEP/wiWo/HNG37D1+e/LI", + "YpSFKtB97AGq/FFVOu26ezyQjYDo2IdmvNY41iNScSwCTLCnQncTkY1VWIb8TzHIgsaPfmQaH4VpCAAb", + "G3S0yPJk0GETFYouAelSJ9p1gUUW9UBeRtnYkBSMeTqy9QLdekWTiQgjnol4il1SQyKsEutq2lmk22Ge", + "5akooXDa5YdpeaVSNkY4GDuDdkC6y1IRRqkIfEc/oTw7t/PH338jFF0xORdhKELv+9xiIcWRkNmpFkGK", + "teQiGWURj6O/BJX76P8vzNtU5elAeqpjTsyKSHvIDL0qu90NtVyxLHCuyCtKAyYu3q1z9DBJZtKm8zhr", + "NIngdfq06aPb5VHdok4nndmiMDei0ROVZjxeXJ9b2qwaO4bvLYmgfj5qMcxjoxGcqilpPtI2LS1lygJn", + "ZmMRpQNZ1oa6y7DuJD6ulXfgMmQ8CMw/8QUskCDYONKZSqf9gXwn4ynpOm1UXa1yUbWURqRtGaNMMc60", + "q2Vkeiu2joXVWnnO775Ss/dxMOwbqdqaKVxIwbV/+qDmFlJzTuxQLJhep7YD22t+FoK96cO3a6h39oVv", + "tH0Fi7Dz1BhNVApKhIxrJiKAAx/GPGNDIaCGL2AC97Asr+2iLZ2BNIWle11xHhtVKS1xJDRTM4MZlgok", + "qYLWEoQxYRv2IeQTHriiTd6DmxLk4bGYF8lBc3U+tUXD50VuVnESlfjz5CeaoC6HGNizNcZ2IH0LhnGW", + "B/7yKjGb8jCPY4ao4Bi2l9qSWCETMougLHWZJah4sccJqeDxaRZNxCnI1NkBo9ZBSoHIbwzH8RgAQhGN", + "uw2qSsCnpXlYBpKe5gQJ8CocO5j5MkNsNOIFSHkIUp0TpFpR85uL4qvsQVD9WO8hFCt4NmYAF9gqysXb", + "NgLeRrJN+GfBsH6895ZG47TYqgaSWiI43Ypw5Vr0Aq6FJtnCyk2BSo3BjvtvszELjfaKju+G/UqGIAzu", + "0I1tx9FJFWpabNHSO3fc6GxEHKuLzDzjcf3CTUI2O3WaVSSyMXW6sAFR0mzL2xUzazNez3b4RWTIoD/j", + "IHYdGloSLKJJt4uVfePe5HiXTjolXt2+RI1STjvljJMb0oivtp2pUIyoua1L0VoC8+3hwR/uNqBZUQx+", + "gf52HtZd0PJg6c6xdH0+WYvkLoTr6nfbZ4elvws/iQakozhWyAVMDVmSioRHobVYK6Zsf44pCu3fPSsU", + "OP0mGKBASPsmCY/vpdlZ5fld7ZF7X4JiJebi95TFtNkE3Z1gtfgq/fHdhojIxQXn/piWN1BS9rTIsliY", + "I+OeuLL9tflmKOQG6uDQpWTxvXXcqqHZ32xj8ZQNcxmKsCx1dE2KtUGFDKEcD2QpTiXUsov+qvSTmZ7L", + "bbuHl1E2HkjzOmIlMa3wfiIVF0LmAuo8jSSWXOLS0UIFn6M4yqbsUqWf4QLjKoEolFbIWV859CwtvWIi", + "7qjC2ER4Xlje7F/SZL53c7nj2NfFtdg9Qmm0gXe+cetEsqYPtq/p/HpiC52eSwXILKCCF2Vnb0K5ZNFk", + "kgNhXVYuuYmV5IyCokYn6gKmQR+UFaAeSNBASup8UvzaZx98KvBitTjeUp1P1lDncyDPpzY3fLYHoDQx", + "N80PcJSnWqXLegJKS7c1f4C/VDfDK+BRtJBfAGf7/noGKqKwJQ0F17yoHXsYo7UY3EWv4cO7k0TlYye8", + "LAZ6COO0TNwWLA+LWglRwdt/NhQ8y1OBIXEYC4dzd2/ueT22YY5t6rzuTXo9roh2Fr2X8aselK6fmeyn", + "0hGX0V/wY4++7RWfbpCN3nk9v8COqWh+4wXHjNfvy5HUXyuHLpPxK2bXqs4qNFN62RofjQepBXhlU4eO", + "Gau/oyPHGtn3TicMNR1FNs/IZZ0oLsTcm7lIjgRkoODLLZY5tBfJUY+aXDbccUmrGXtZFF6J3j6fMp2D", + "JbsonCK9jsWLnRHzZH1m+EugbKVoPAjNnDcPi+F7ZVEd18suexGjmam0wPn6YywkU5Moy0TYtWSYw552", + "0N/QLGB0nbFHE6WNIAdmBx9Gqc4e9xm0weELM+MiDqHGd6ouInPMtFlXnKDEuixCzDDtAX/12WGSCIob", + "9IHHBjJTNGb7bpdR6hlii1mEMvue1+iWQ0w3aZS+pnUETrvDR6q69WhVEnMqyWrPN/YJit81b05xhsGr", + "Aj0ZLjvnWTBmamglo9Azhv+OYpXjgmhCs2vNp0MxbFCvi5kUgekJv/nbcnxj5wjIhOltabcHY21ofaEQ", + "3Eo31djbSrf1Tricvhu2bjBtvayHuJOFLKundY75MBaWMcb8QrBzIWSxz0LiU2p+pdQlc96BnAS6UlC5", + "jqe3RxhRPpYRx4qVYs+/82tf2zdbjBTX0AZBN91h/Zp78kPd62vmZ8xfiLKR6N4/nyKvnkbhonaifZ+y", + "Nwb5/v6zIArhv2J91uIrJHHXnlpHxr1C5fSUR/0U9so+XFMQFnXWGjBFzzcK7Elj2lHgEvXexE/06PbD", + "eRareG2Oat4x977Qv+bU1yaAScd3c6prF3TPd907Ah5AQTcCCrpGHppVVnseZ4xEdlPYYn+bOughI7zu", + "jl8rSybmdNleXbvClwxLAmXxlCkZY/m5XEbZKUD+o4/JJuGhzdwaHbU7bt7UXcEqG/pWhen+xR5t1QKA", + "Ak97eAxpDY2EUxZeRBuRUcNZ1ii0ZSUFarPcCXGB+YeJ8GRlC7JxpHRG3bYhlnyAAywQxcZcM50HgRCh", + "0WN3VlaQJa2iJy5bs7yM1IV5XQZiMQGx1BBCEQbbxRFKTAFBZ70xLjI4FVrFF0IzwYNxcdcRhUJm0TBC", + "UKUibA+cgWkBYDKQ1CHFKFswPWIJEbpjapclce65fcpJgAPphwwDmacvhI5GEt0754IFWBhYSaMAoitQ", + "y8NU6DGDqb3gsY1HIZ+IXUcW6YE070CwoG0sGIuwf9qiQYrZb40KWu3+cEMK4hdHb1VLbHNHrVHR7oK5", + "nWqjQQsUnDIrEKiYmTZlkKTRBc/Egtohjiewu+2ZdtMonOeLTkTaM3udTnggWJJGgWDu0xbntO2jV/TR", + "vJde34/4229vzFZzbOi6rRX9gPh75oL87bc3ZJV5LFLnfvOaWd91OSNncXOrh7LGzhvyVRIvv6NekOht", + "Oyt9gWpkP5izW++vrPHfOthvnqbd+wIct6gHczlmJYdmE7POP8YQXQ+OzY04NrfJbLCSc/b0UazOeVyQ", + "hd/0mU2qwb+xkLFjXgY6xRj4Q8bldN7WT3TUmK/xgpMIWN/14ipmQcMNOE3EmmpO0hEp7dsfJioUsfmr", + "cgdeqRhd+S1T9/Jm/MFqu0FWm5Puzaqx8oY540rHhp5VKGTnU/b6RaHYIHsZHrTqtoFsVG4jUdVtu91X", + "97dm8N1HN51hqjInrZ/VLePM2qjxnVlx6hsNAMMvNhD+xUejVIyAgFI82GFbONjhQzSYM5bmrUo5Foze", + "XqkYM3zb+yym6zPMQHB2nqALVNyzvdupi1Ksarn0covXBD5tdY/A042GbwGlOwregr6buAK3gFvvCLGr", + "V+OKpt1q7wv8d1EHRgvfkKfC9jzfiqJOH7wTG/FOtHLAzCAq+Irs60Zr+QYs7/62tMA9SU6ewSmUU9wS", + "2dSiCCg8aTecsqnQpOU3q62x6f0LSmrj2JXPa8UOuFhwhVWUQ5VS4QdAvBcZOzsMApFkB6y63GfskXeO", + "eWwOJSN0cmRpHmR5KkL2j/fv3voWf6nBTFxle4G+ODOfhupSxoqj2a/5REAhRnNY4uzo/b8YFJPSeQQD", + "N2QOpE5SwUM9FiKjyoPmxUDF+UTqrjlvwHmo6w55Z8NUTbosU11m84y7J+yTjfw4jcKuCwM5/Sym3l9G", + "sLsnDNNMwmgiJJT86vf7mHHSxYIbxemP2j8jeszRTWDuLoZJXo6F9N6KtD0fwXJ9owfybJSqPDk9n54W", + "/Z3hOLNxKgQ7c9T9p+0GE4JtR5kaCaioY3ocSOzSG21Dt6y515YgkruiERujz7auEMtxaN2OlQ/zsbji", + "kyTGjn8xK4QJ36WgpWLBoONiS5z/frcD7GvOykZEMtX1haIkE2WRgKuBbjZNRBdaGMin+0+f9faf9Paf", + "fNjfP4D//btb+fEJ/Lj/5Jfvvv33999+e/jqj8N//vryydO3/7N/9N8/vvq1y4OJ6EUy6B4GE8Fey6Df", + "HSVZ73kvy9Nz1Y1kkmfdJ09rvT1p6u3pWnp7ul/r7WlTb8/Kvf387H/+/eSfvx/++McP//r++P3TF91R", + "rM7FVfcX+A87UmlS6k3lmenuudlZ3ioG4tg7n7aubss79RVden2Wm9/l5uc57oNOOCjNV2dpJEcP7l0/", + "/mqNtkESc7lATi+81uLNxSY26MyFDtZ1lel8uhci1VUv7uys3hviRZ0zHevzeB6bjnbt8DRE3DN/pxWo", + "+rXNcarCPMjYEc94rEbrrDZgOm11lJqHG/WTmlXeLTi/oaCRpWIub7+vlBZwXRzVsIfsfTH/WThAzMzq", + "7PxWInmBm2ro98HFuhEX65oZZ6ZjdhZTjES2e47Y36rSechqrftx186Os72/sziSXMC7YMpNOIC1SLOl", + "d+HtCsSdRqJcXS6IW7e4xe/xMJwLh8/DsAfg81qrIALzCULXeIup6c6SPWp9e0J1E2M0Yy4PzTw8FGeb", + "DU9t2Wyo0g3sDs1FhcMQiq5Bz5gqOvf0hEx9+zeK4rgG3LmjM5vrv22vgIf3qYoa8KRjyO3vBfg3TPuc", + "M+DvYqIuhCdAw1RNWkXIOwxuXYS6rW3TOB/OnOtlYssaHl9s8fzpGNJaLJEhAjAFmnnTnknvA2Pub1t3", + "35dCfs0st91z7tKc75197yjzb/KIvbzltHXpu3dFH7Yjh7MNqTQYRxeiPS7rEF+wfim6wKxLJzV03/yl", + "9yhG0HKCzwfbYtMkP48jPW5n02N8YS6bUkMPbHpn2dRywnbYNFXDKJ4HIHCOK8Ts2y1+SHqt5xpdS3jL", + "NlgPCb5nERPVVW1kMpqhRdLGpListgnRzz9X+mFm6ThF4GiRZZEcoSvSfk3VWbNUxZpF8kJFgRjIkZDE", + "cn12KMsVpwIusSDFJI+zKIlFbXQsFMNIirDPDgey8pBFmsWR/IwpoV56OU+SPvswjnTJxok0EyBTkR6L", + "cCDDPLX1USoNf6PRnWaLXqdiwiOpixq2re7PiixtNI6kLAU7jiih8TZIXfmN2x9e0igxc4SwWXvvfYkW", + "DCFpks93Mp4ynQfjuswQ4HBI3jQo6F6EB0qVlVKw6TP7KIkkYTJy6YVM59p04f50oAzmMwjpBzkeRpLH", + "Zrat/Os2L2ddUuYbRdGDF3IzkS98SX6eGdpSZdZGX+JNWf793WnC++L1W5q3ZsepzGUvctjtkMM25VC7", + "xo6/Qz6/f/mM/Frmgc7P3WzOKXNefnWDaQmljtaVnsA99LRKJgJ3IGo3JBGhNAFrzDt477e76/wDn5iH", + "WJzZsThV0avLd2lpSyfxxqOj3+CGzo2kcXzCdgNf20BIE2v5z+94gIv54Mf5HxwpOYyjIGs+mlZYaD5L", + "zth49r74f5ax/ermfKXn+ZZWufFbYNcvxav3xLTfKL8tFHhrrA98DwvH+G20uLv9V5YJv10vx3ZXts7u", + "Sp1wnzceon+XtDiYY9w1C13AZSDi9gvPI3iOGI4lYWN/RHFs1iKPM3Mu4MwsdJjDMSigbYtFQ/NlKsxx", + "YCAVwHOUzxb0FcE8ZtycIoZmWFAhCnpHx3wWTZr88PDGjdiPtmO/4Xrtxgew1J54t90A17TfYBU3vJ8G", + "Yy5HM0JujmKlzUGdpbmURmrLCkeGKI6abkCUhIo4KgXs1UxhtSh7B0cXfkdU+lCLEMGVklHKQ6G7gHhk", + "/23ahntzJLHhohof3COxxrXavVgjIXev0tO2BRymccMCnku7efa8jbJd4D+69+v7ub/VNrjYm3t6OPg9", + "bHLtMlCwWyunrSATGb/qBapcIK3h1Fe8thkv+WsZxHno3bnzKwb9NWHWLHKEi7DBU2qw0wAXda5ULLjc", + "7rHtA786UuF9C7pyy9nIoR/41dJplo0+YMulG40bohXcbcAQEdFoUOCj2x8pZJnmmjzTou/2vmQ4UbUc", + "xMZ4G4+15m/SruWHeJuNxNusiTO67Q75m7Lc+ztQHPfE+742JqJ4m2oUjRbpTvloU1E0q+x/u2DjBwiY", + "FggYmJZ1ba6mbZFeNBc+/E0FPO50O3kadw464yxLDvb2YvPjWOns4Eui0uzrHk+ivYtngDmbRqZtjWfu", + "lM7cENfSOej88MMPP8CCN3je8rDUjT7YK/b8fmCe226McNCIa0lzQaBymUVyxCZc8hGd63nxcyLSSIW6", + "y7KUS80DOFN1Kcj9QsjcaM9AjWRkD/4k2sXcFp00HIOKOthMXPA4R1e9X6GeZYoFYxF8NqRFaaWufWOP", + "XnHteo/vvHyCXiwuROwCmwMlh9EoT3nrWF7gm7qhXZumE2CajptQyBDrWiiWri1JH6V+rgHmRZRuGs+5", + "FqGNC2skppoYVKfJFTsLecZNg1TP36ysVOmEQq+TNArMTwAhbwiJuRzl5hwGeNWa8SBVWjNb6VL3GZbg", + "BPh0PZWBCBGRwKVliCuUI6ZVnsKbMmQ8z1QPJjmdiBAx3bOxmDI+SoVoHKOrxdYQaIWMoFkqklRoISEy", + "ndYg4edRHGWR0OycB58Rzhs3oy5VCbQFxhKR9nIZZThT83nA9ttA0gd3iDcTY2uPBTwO8pgMfIFL7di7", + "sQujjuqt2wQbX1SrofxdFuRpKmQQwb/NiMy6E9/ZGPsFSLDBhnUyDpNEMyGhsMBU5WaEZrXN+sqQWo3+", + "EqUsH6iRwC5V+nkYq0uoW2Y07chMsxzhghQsM9WZmCDLGFWLVWyh24BL4KIJpuaHTMgxKI+pyou8IhEo", + "bMP0ozHCEG4VfbaATAiugX3HqZLRX+YVJBQEAYjKxlEa9hKeZlMjydlQpRMzsbSkcJNhFrXLbNoSjTgU", + "cXQhIGHIznqXjbkMcbn4dGIYNlBxLECp4gLhBaeNRE5FzNE3pD83r5KZlIYleimzKIuF6aLCiphtRcrT", + "/DK0UjSfJfxWm+I+S9eyfq9ZyoPPNLVqiGtlRdWoPVzjftlxZ5NSIhlGF1GY81ibl/10MI2ZKuZFUp3n", + "wiL8IPtAjkl9sI3DK7sNGzZdtyOtMrbi622Py/XcMCZ4A0TmosYri47sZfFpkipDkggZt2Klch1PjRwa", + "bWUVsFao9yd8CilEZjomExFGPBPxlPELHsW2cAmW2ijvgY5s7LttYNqVfRyrS0hQogKVwo63mo3IJY+n", + "WRRoluRporRRPNQULZvdHyxin9vxvOKXZpxjFeJSQbWBSI5MS/bdSblJ8lsZYlw5FyCQQaUIVLaGxGEs", + "rqJz2wBcuQZC8jRSujo7uvP15Ov/CwAA//9zHKSAni8EAA==", } // GetSwagger returns the content of the embedded swagger specification file diff --git a/api/v3/openapi.yaml b/api/v3/openapi.yaml index 620d5b132d..04669cee09 100644 --- a/api/v3/openapi.yaml +++ b/api/v3/openapi.yaml @@ -119,10 +119,10 @@ paths: modify `P`. Returns the period transitioned to `closing`. The newly-opened next period can - be retrieved by listing with `filter[status]=open`. + be retrieved by listing with `filter[status][eq]=open`. responses: - '201': - description: AccountingPeriod created response. + '200': + description: AccountingPeriod updated response. content: application/json: schema: