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..be43497698 --- /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][eq]=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.UpdateResponse | 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..11ff7f7660 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+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 05868653db..04669cee09 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][eq]=open`. + responses: + '200': + description: AccountingPeriod updated 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) +}