diff --git a/api/spec/packages/aip/src/common/pagination.tsp b/api/spec/packages/aip/src/common/pagination.tsp index 7f5a85c918..3a5f2c01c3 100644 --- a/api/spec/packages/aip/src/common/pagination.tsp +++ b/api/spec/packages/aip/src/common/pagination.tsp @@ -8,30 +8,34 @@ using TypeSpec.OpenAPI; namespace Common; /** - * Cursor page query. + * Determines which page of the collection to retrieve. */ -@friendlyName("CursorPaginationQuery") -model CursorPaginationQuery { +@friendlyName("CursorPaginationQueryPage") +model CursorPaginationQueryPage { /** - * Determines which page of the collection to retrieve. + * The number of items to include per page. */ - @query(#{ explode: true, style: "deepObject" }) - page?: { - /** - * The number of items to include per page. - */ - size?: integer; + size?: integer; - /** - * Request the next page of data, starting with the item after this parameter. - */ - after?: string; + /** + * Request the next page of data, starting with the item after this parameter. + */ + after?: string; - /** - * Request the previous page of data, starting with the item before this parameter. - */ - before?: string; - }; + /** + * Request the previous page of data, starting with the item before this parameter. + */ + before?: string; +} + +/** + * Cursor page query. + */ +@friendlyName("CursorPaginationQuery") +model CursorPaginationQuery { + #suppress "@openmeter/api-spec-aip/doc-decorator" "-" + @query(#{ explode: true, style: "deepObject" }) + page?: CursorPaginationQueryPage; } /** diff --git a/api/spec/packages/aip/src/governance/governance.tsp b/api/spec/packages/aip/src/governance/governance.tsp new file mode 100644 index 0000000000..e53e66b8e9 --- /dev/null +++ b/api/spec/packages/aip/src/governance/governance.tsp @@ -0,0 +1,227 @@ +import "../shared/index.tsp"; +import "../common/pagination.tsp"; +import "../customers/customer.tsp"; + +namespace Governance; + +/** + * List of customer identifiers to evaluate access for. + */ +@friendlyName("GovernanceQueryRequestCustomers") +model GovernanceQueryRequestCustomers { + /** + * Each entry can be a customer `key` or a usage-attribution subject `key`. + * Identifiers that cannot be resolved to a customer are reported in the response + * `errors` array. + */ + @summary("Customer keys and usage-attribution subjects") + @minItems(1) + @maxItems(100) + keys: string[]; +} + +/** + * Optional list of feature keys to evaluate access for. If omitted, all features + * available in the organization are returned. Providing this list is recommended + * to reduce the response size and the load on the backend services. + */ +@friendlyName("GovernanceQueryRequestFeatures") +model GovernanceQueryRequestFeatures { + /** + * List of feature keys to evaluate access for. + */ + @summary("Feature Keys") + @minItems(1) + @maxItems(100) + keys: string[]; +} + +/** + * Query to evaluate feature access for a list of customers. + */ +@friendlyName("GovernanceQueryRequest") +model GovernanceQueryRequest { + /** + * Whether to include credit balance availability for each resolved customer. When + * true, each feature evaluation includes credit balance checks. + * + * Defaults to `false`. + */ + @summary("Include credits") + include_credits?: boolean = false; + + #suppress "@openmeter/api-spec-aip/doc-decorator" "-" + @summary("Customer") + customer: GovernanceQueryRequestCustomers; + + #suppress "@openmeter/api-spec-aip/doc-decorator" "-" + @summary("Feature") + feature?: GovernanceQueryRequestFeatures; +} + +/** + * Response of the governance query. + */ +@friendlyName("GovernanceQueryResponse") +model GovernanceQueryResponse { + /** + * Access evaluation results, one entry per resolved customer. + */ + @visibility(Lifecycle.Read) + @summary("Data") + data: GovernanceQueryResult[]; + + /** + * Partial errors encountered while processing the request. + */ + @visibility(Lifecycle.Read) + @summary("Errors") + errors: GovernanceQueryError[]; + + /** + * Pagination metadata. The endpoint may return a partial response if the full + * response would exceed server-side limits. + */ + @visibility(Lifecycle.Read) + @summary("Meta") + meta: Common.CursorMeta; +} + +/** + * Access evaluation result for a single resolved customer. + */ +@friendlyName("GovernanceQueryResult") +model GovernanceQueryResult { + /** + * The list of identifiers from the request that resolved to this customer. Each + * entry is either the customer `key` or one of its usage-attribution subject + * `key`s. + * + * Duplicate or aliased identifiers that resolve to the same customer collapse to a + * single result entry, with every requested identifier listed here. + */ + @visibility(Lifecycle.Read) + @summary("Matched identifiers") + matched: string[]; + + /** + * The customer the matched identifiers resolved to. + */ + @visibility(Lifecycle.Read) + @summary("Customer") + customer: Customers.Customer; + + /** + * Map of features with their access status. + * + * Map keys are the feature keys requested in `feature.keys`, or every feature + * `key` available in the organization when the feature filter was omitted. + */ + @visibility(Lifecycle.Read) + @summary("Features") + features: Record; + + /** + * Timestamp of the most recent change to the customer's access state reflected in + * this result. + */ + @visibility(Lifecycle.Read) + @summary("Updated at") + updated_at: Shared.DateTime; +} + +/** + * Access status for a single feature. + */ +@friendlyName("GovernanceFeatureAccess") +model GovernanceFeatureAccess { + /** + * Whether the customer currently has access to the feature. + * + * `true` for boolean and static entitlements that are available, and for metered + * entitlements with remaining balance. `false` when the feature is unavailable, + * the usage limit has been reached, or (when applicable) credits have been + * exhausted. + */ + @visibility(Lifecycle.Read) + @summary("Has access") + has_access: boolean; + + /** + * Optional reason when the customer does not have access to the feature. Populated + * when `has_access` is `false`. + */ + @visibility(Lifecycle.Read) + @summary("Reason") + reason?: GovernanceFeatureAccessReason; +} + +/** + * Reason a feature is not accessible to a customer. + */ +@friendlyName("GovernanceFeatureAccessReason") +model GovernanceFeatureAccessReason + is Shared.BaseError; + +/** + * Machine-readable reason code for denied feature access. + */ +@friendlyName("GovernanceFeatureAccessReasonCode") +enum GovernanceFeatureAccessReasonCode { + /** + * Default zero value. Reserved for forward compatibility. + */ + Unknown: "unknown", + + /** + * The customer has reached the metered usage limit for the feature + * within the current usage period. + */ + UsageLimitReached: "usage_limit_reached", + + /** + * The feature is not available to the customer. + */ + FeatureUnavailable: "feature_unavailable", + + /** + * The feature `key` referenced by the request is not configured in the + * organization. + */ + FeatureNotFound: "feature_not_found", + + /** + * The customer has no available prepaid credit balance. + */ + NoCreditAvailable: "no_credit_available", +} + +/** + * Query error within a partially successful governance query response. + */ +@friendlyName("GovernanceQueryError") +model GovernanceQueryError is Shared.BaseError { + /** + * The customer identifier from the request that produced this error. + */ + @visibility(Lifecycle.Read) + @summary("Customer identifier") + customer?: string; +} + +/** + * Error code for a governance query failure. + */ +@friendlyName("GovernanceQueryErrorCode") +enum GovernanceQueryErrorCode { + /** + * Default zero value. Reserved for forward compatibility. + */ + Unknown: "unknown", + + /** + * The provided identifier could not be resolved to any customer + * (neither by customer `key` nor by a usage-attribution subject `key`). + */ + CustomerNotFound: "customer_not_found", +} diff --git a/api/spec/packages/aip/src/governance/index.tsp b/api/spec/packages/aip/src/governance/index.tsp new file mode 100644 index 0000000000..a1d975c493 --- /dev/null +++ b/api/spec/packages/aip/src/governance/index.tsp @@ -0,0 +1,4 @@ +import "./governance.tsp"; +import "./operations.tsp"; + +namespace Governance; diff --git a/api/spec/packages/aip/src/governance/operations.tsp b/api/spec/packages/aip/src/governance/operations.tsp new file mode 100644 index 0000000000..4116bd2fb5 --- /dev/null +++ b/api/spec/packages/aip/src/governance/operations.tsp @@ -0,0 +1,36 @@ +import "@typespec/http"; +import "@typespec/rest"; +import "@typespec/openapi"; +import "@typespec/openapi3"; +import "../common/error.tsp"; +import "../shared/index.tsp"; +import "./governance.tsp"; + +using TypeSpec.Http; +using TypeSpec.OpenAPI; + +namespace Governance; + +interface GovernanceOperations { + /** + * Query feature access for a list of customers. + * + * The endpoint resolves each provided identifier to a customer and returns the + * access status for the requested features, plus optional credit balance + * availability. + * + * _Designed to be called on a fixed refresh interval and the query response is + * intended to be cached._ + */ + @extension(Shared.UnstableExtension, true) + @extension(Shared.InternalExtension, true) + @extension(Shared.PrivateExtension, true) + @post + @route("/query") + @operationId("query-governance-access") + @summary("Query governance access") + query( + ...Common.CursorPaginationQuery, + @body _: GovernanceQueryRequest, + ): GovernanceQueryResponse | Common.ErrorResponses; +} diff --git a/api/spec/packages/aip/src/konnect.tsp b/api/spec/packages/aip/src/konnect.tsp index 77e195306f..4278bc14c8 100644 --- a/api/spec/packages/aip/src/konnect.tsp +++ b/api/spec/packages/aip/src/konnect.tsp @@ -13,6 +13,7 @@ import "./apps/index.tsp"; import "./billing/index.tsp"; import "./tax/index.tsp"; import "./defaults/index.tsp"; +import "./governance/index.tsp"; using TypeSpec.Http; using TypeSpec.OpenAPI; @@ -54,6 +55,10 @@ using TypeSpec.OpenAPI; #{ description: Shared.ProductCatalogDescription } ) @tagMetadata(Shared.DefaultsTag, #{ description: Shared.DefaultsDescription }) +@tagMetadata( + Shared.GovernanceTag, + #{ description: Shared.GovernanceDescription } +) @useAuth(systemAccountAccessToken | personalAccessToken | konnectAccessToken) namespace MeteringAndBilling; @@ -188,6 +193,10 @@ interface PlanAddonEndpoints extends ProductCatalog.PlanAddonOperations {} interface OrganizationDefaultTaxCodesEndpoints extends Defaults.OrganizationDefaultTaxCodesOperations {} +@route("/openmeter/governance") +@tag(Shared.GovernanceTag) +interface GovernanceEndpoints extends Governance.GovernanceOperations {} + /** * 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 97abdaee3b..c17b5df874 100644 --- a/api/spec/packages/aip/src/openmeter.tsp +++ b/api/spec/packages/aip/src/openmeter.tsp @@ -14,6 +14,7 @@ import "./features/index.tsp"; import "./llmcost/index.tsp"; import "./productcatalog/index.tsp"; import "./defaults/index.tsp"; +import "./governance/index.tsp"; using TypeSpec.Http; using TypeSpec.OpenAPI; @@ -60,6 +61,10 @@ using TypeSpec.OpenAPI; #{ description: Shared.ProductCatalogDescription } ) @tagMetadata(Shared.DefaultsTag, #{ description: Shared.DefaultsDescription }) +@tagMetadata( + Shared.GovernanceTag, + #{ description: Shared.GovernanceDescription } +) namespace OpenMeter; @route("/openmeter/events") @@ -192,3 +197,7 @@ interface PlanAddonEndpoints extends ProductCatalog.PlanAddonOperations {} @tag(Shared.DefaultsTag) interface OrganizationDefaultTaxCodesEndpoints extends Defaults.OrganizationDefaultTaxCodesOperations {} + +@route("/openmeter/governance") +@tag(Shared.GovernanceTag) +interface GovernanceEndpoints extends Governance.GovernanceOperations {} diff --git a/api/spec/packages/aip/src/productcatalog/plan.tsp b/api/spec/packages/aip/src/productcatalog/plan.tsp index b3ead7dd19..394dd756e3 100644 --- a/api/spec/packages/aip/src/productcatalog/plan.tsp +++ b/api/spec/packages/aip/src/productcatalog/plan.tsp @@ -119,7 +119,7 @@ model Plan { * Validation errors providing detailed description of the issue. */ @friendlyName("ProductCatalogValidationError") -model ProductCatalogValidationError { +model ProductCatalogValidationError is Shared.BaseError { /** * The path to the field. */ @@ -127,29 +127,6 @@ model ProductCatalogValidationError { @summary("Field") @example("addons/pro/ratecards/token/featureKey") field: string; - - /** - * The machine readable code of the error. - */ - @visibility(Lifecycle.Read) - @summary("Code") - @example("invalid_feature_key") - code: string; - - /** - * The human readable description of the error. - */ - @visibility(Lifecycle.Read) - @summary("Message") - @example("not found feature by key") - message: string; - - /** - * Additional attributes. - */ - @visibility(Lifecycle.Read) - @summary("Attributes") - attributes?: Record; } /** diff --git a/api/spec/packages/aip/src/shared/consts.tsp b/api/spec/packages/aip/src/shared/consts.tsp index 35a9d15e9f..76668969e7 100644 --- a/api/spec/packages/aip/src/shared/consts.tsp +++ b/api/spec/packages/aip/src/shared/consts.tsp @@ -39,6 +39,9 @@ const ProductCatalogDescription = "Product catalog manages plans, add-ons, and t const DefaultsTag = "OpenMeter Defaults"; const DefaultsDescription = "Organization-level default configuration."; +const GovernanceTag = "OpenMeter Governance"; +const GovernanceDescription = "Governance evaluation of customers to check their feature access."; + // 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/spec/packages/aip/src/shared/errors.tsp b/api/spec/packages/aip/src/shared/errors.tsp new file mode 100644 index 0000000000..b86e5ec081 --- /dev/null +++ b/api/spec/packages/aip/src/shared/errors.tsp @@ -0,0 +1,50 @@ +namespace Shared; + +/** + * Shared properties for inline errors returned inside a 2xx response. + * + * Use for partially successful responses (e.g. per-item failures alongside + * a `data` array) or for pre-flight findings on resources that are not yet + * finalized (e.g. validation errors on a draft resource). + * + * This is **not** an RFC-7807 problem detail. RFC-7807 covers errors that + * fail the whole request; inline errors live as fields on the response or + * resource model. + * + * Compose with `is` and add domain-specific identifying fields as needed: + * + * ```tsp + * @friendlyName("MyOperationError") + * model MyOperationError is Shared.BaseError { + * // domain-specific identifiers, e.g. the input that produced the error + * subject?: string; + * } + * ``` + * + * `T` is the type of the `code` field. Prefer a domain-scoped enum with an + * `Unknown: "unknown"` zero member so codes stay discoverable and stable. + * Use `string` only when the set of codes is open-ended. + */ +@friendlyName("BaseError") +model BaseError { + /** + * Machine-readable error code. + */ + @visibility(Lifecycle.Read) + @summary("Code") + code: T; + + /** + * Human-readable description of the error. + */ + @visibility(Lifecycle.Read) + @summary("Message") + message: string; + + /** + * Additional structured context. + */ + @visibility(Lifecycle.Read) + @summary("Attributes") + attributes?: Record; +} diff --git a/api/spec/packages/aip/src/shared/index.tsp b/api/spec/packages/aip/src/shared/index.tsp index cc86fdd432..306d0993f7 100644 --- a/api/spec/packages/aip/src/shared/index.tsp +++ b/api/spec/packages/aip/src/shared/index.tsp @@ -1,6 +1,7 @@ import "./address.tsp"; import "./consts.tsp"; import "./enums.tsp"; +import "./errors.tsp"; import "./filters.tsp"; import "./parameters.tsp"; import "./properties.tsp"; diff --git a/api/v3/api.gen.go b/api/v3/api.gen.go index 05440b0a72..81ad7a8682 100644 --- a/api/v3/api.gen.go +++ b/api/v3/api.gen.go @@ -881,6 +881,51 @@ func (e BillingWorkflowPaymentSendInvoiceSettingsCollectionMethod) Valid() bool } } +// Defines values for GovernanceFeatureAccessReasonCode. +const ( + GovernanceFeatureAccessReasonCodeFeatureNotFound GovernanceFeatureAccessReasonCode = "feature_not_found" + GovernanceFeatureAccessReasonCodeFeatureUnavailable GovernanceFeatureAccessReasonCode = "feature_unavailable" + GovernanceFeatureAccessReasonCodeNoCreditAvailable GovernanceFeatureAccessReasonCode = "no_credit_available" + GovernanceFeatureAccessReasonCodeUnknown GovernanceFeatureAccessReasonCode = "unknown" + GovernanceFeatureAccessReasonCodeUsageLimitReached GovernanceFeatureAccessReasonCode = "usage_limit_reached" +) + +// Valid indicates whether the value is a known member of the GovernanceFeatureAccessReasonCode enum. +func (e GovernanceFeatureAccessReasonCode) Valid() bool { + switch e { + case GovernanceFeatureAccessReasonCodeFeatureNotFound: + return true + case GovernanceFeatureAccessReasonCodeFeatureUnavailable: + return true + case GovernanceFeatureAccessReasonCodeNoCreditAvailable: + return true + case GovernanceFeatureAccessReasonCodeUnknown: + return true + case GovernanceFeatureAccessReasonCodeUsageLimitReached: + return true + default: + return false + } +} + +// Defines values for GovernanceQueryErrorCode. +const ( + GovernanceQueryErrorCodeCustomerNotFound GovernanceQueryErrorCode = "customer_not_found" + GovernanceQueryErrorCodeUnknown GovernanceQueryErrorCode = "unknown" +) + +// Valid indicates whether the value is a known member of the GovernanceQueryErrorCode enum. +func (e GovernanceQueryErrorCode) Valid() bool { + switch e { + case GovernanceQueryErrorCodeCustomerNotFound: + return true + case GovernanceQueryErrorCodeUnknown: + return true + default: + return false + } +} + // Defines values for InvalidParameterChoiceItemRule. const ( InvalidParameterChoiceItemRuleEnum InvalidParameterChoiceItemRule = "enum" @@ -4012,6 +4057,18 @@ type CursorMetaPage struct { Size float32 `json:"size"` } +// CursorPaginationQueryPage Determines which page of the collection to retrieve. +type CursorPaginationQueryPage struct { + // After Request the next page of data, starting with the item after this parameter. + After *string `json:"after,omitempty"` + + // Before Request the previous page of data, starting with the item before this parameter. + Before *string `json:"before,omitempty"` + + // Size The number of items to include per page. + Size *int `json:"size,omitempty"` +} + // CustomerPagePaginatedResponse Page paginated response. type CustomerPagePaginatedResponse struct { Data []BillingCustomer `json:"data"` @@ -4164,6 +4221,119 @@ type GoneError struct { Type interface{} `json:"type,omitempty"` } +// GovernanceFeatureAccess Access status for a single feature. +type GovernanceFeatureAccess struct { + // HasAccess Whether the customer currently has access to the feature. + // + // `true` for boolean and static entitlements that are available, and for metered + // entitlements with remaining balance. `false` when the feature is unavailable, + // the usage limit has been reached, or (when applicable) credits have been + // exhausted. + HasAccess bool `json:"has_access"` + + // Reason Optional reason when the customer does not have access to the feature. Populated + // when `has_access` is `false`. + Reason *GovernanceFeatureAccessReason `json:"reason,omitempty"` +} + +// GovernanceFeatureAccessReason Reason a feature is not accessible to a customer. +type GovernanceFeatureAccessReason struct { + // Attributes Additional structured context. + Attributes *map[string]interface{} `json:"attributes,omitempty"` + + // Code Machine-readable error code. + Code GovernanceFeatureAccessReasonCode `json:"code"` + + // Message Human-readable description of the error. + Message string `json:"message"` +} + +// GovernanceFeatureAccessReasonCode Machine-readable reason code for denied feature access. +type GovernanceFeatureAccessReasonCode string + +// GovernanceQueryError Query error within a partially successful governance query response. +type GovernanceQueryError struct { + // Attributes Additional structured context. + Attributes *map[string]interface{} `json:"attributes,omitempty"` + + // Code Machine-readable error code. + Code GovernanceQueryErrorCode `json:"code"` + + // Customer The customer identifier from the request that produced this error. + Customer *string `json:"customer,omitempty"` + + // Message Human-readable description of the error. + Message string `json:"message"` +} + +// GovernanceQueryErrorCode Error code for a governance query failure. +type GovernanceQueryErrorCode string + +// GovernanceQueryRequest Query to evaluate feature access for a list of customers. +type GovernanceQueryRequest struct { + Customer GovernanceQueryRequestCustomers `json:"customer"` + Feature *GovernanceQueryRequestFeatures `json:"feature,omitempty"` + + // IncludeCredits Whether to include credit balance availability for each resolved customer. When + // true, each feature evaluation includes credit balance checks. + // + // Defaults to `false`. + IncludeCredits *bool `json:"include_credits,omitempty"` +} + +// GovernanceQueryRequestCustomers List of customer identifiers to evaluate access for. +type GovernanceQueryRequestCustomers struct { + // Keys Each entry can be a customer `key` or a usage-attribution subject `key`. + // Identifiers that cannot be resolved to a customer are reported in the response + // `errors` array. + Keys []string `json:"keys"` +} + +// GovernanceQueryRequestFeatures Optional list of feature keys to evaluate access for. If omitted, all features +// available in the organization are returned. Providing this list is recommended +// to reduce the response size and the load on the backend services. +type GovernanceQueryRequestFeatures struct { + // Keys List of feature keys to evaluate access for. + Keys []string `json:"keys"` +} + +// GovernanceQueryResponse Response of the governance query. +type GovernanceQueryResponse struct { + // Data Access evaluation results, one entry per resolved customer. + Data []GovernanceQueryResult `json:"data"` + + // Errors Partial errors encountered while processing the request. + Errors []GovernanceQueryError `json:"errors"` + + // Meta Pagination metadata. The endpoint may return a partial response if the full + // response would exceed server-side limits. + Meta CursorMeta `json:"meta"` +} + +// GovernanceQueryResult Access evaluation result for a single resolved customer. +type GovernanceQueryResult struct { + // Customer The customer the matched identifiers resolved to. + Customer BillingCustomer `json:"customer"` + + // Features Map of features with their access status. + // + // Map keys are the feature keys requested in `feature.keys`, or every feature + // `key` available in the organization when the feature filter was omitted. + Features map[string]GovernanceFeatureAccess `json:"features"` + + // Matched The list of identifiers from the request that resolved to this customer. Each + // entry is either the customer `key` or one of its usage-attribution subject + // `key`s. + // + // Duplicate or aliased identifiers that resolve to the same customer collapse to a + // single result entry, with every requested identifier listed here. + Matched []string `json:"matched"` + + // UpdatedAt Timestamp of the most recent change to the customer's access state reflected in + // this result. + UpdatedAt DateTime `json:"updated_at"` +} + // ISO8601Duration [ISO 8601 Duration](https://docs.digi.com/resources/documentation/digidocs/90001488-13/reference/r_iso_8601_duration_format.htm) // string. type ISO8601Duration = string @@ -4878,16 +5048,16 @@ type PricePagePaginatedResponse struct { // ProductCatalogValidationError Validation errors providing detailed description of the issue. type ProductCatalogValidationError struct { - // Attributes Additional attributes. + // Attributes Additional structured context. Attributes *map[string]interface{} `json:"attributes,omitempty"` - // Code The machine readable code of the error. + // Code Machine-readable error code. Code string `json:"code"` // Field The path to the field. Field string `json:"field"` - // Message The human readable description of the error. + // Message Human-readable description of the error. Message string `json:"message"` } @@ -5307,17 +5477,8 @@ type UpsertTaxCodeRequest struct { // UsageAttributionSubjectKey Subject key. type UsageAttributionSubjectKey = string -// CursorPaginationQuery defines model for CursorPaginationQuery. -type CursorPaginationQuery struct { - // After Request the next page of data, starting with the item after this parameter. - After *string `json:"after,omitempty"` - - // Before Request the previous page of data, starting with the item before this parameter. - Before *string `json:"before,omitempty"` - - // Size The number of items to include per page. - Size *int `json:"size,omitempty"` -} +// CursorPaginationQuery Determines which page of the collection to retrieve. +type CursorPaginationQuery = CursorPaginationQueryPage // PagePaginationQuery defines model for PagePaginationQuery. type PagePaginationQuery struct { @@ -5462,7 +5623,6 @@ type ListCreditGrantsParams struct { // ListCreditTransactionsParams defines parameters for ListCreditTransactions. type ListCreditTransactionsParams struct { - // Page Determines which page of the collection to retrieve. Page *CursorPaginationQuery `json:"page,omitempty"` // Filter Filter credit transactions returned in the response. @@ -5471,7 +5631,6 @@ type ListCreditTransactionsParams struct { // ListMeteringEventsParams defines parameters for ListMeteringEvents. type ListMeteringEventsParams struct { - // Page Determines which page of the collection to retrieve. Page *CursorPaginationQuery `json:"page,omitempty"` // Filter Filter events returned in the response. @@ -5526,6 +5685,11 @@ type ListFeaturesParams struct { Filter *ListFeatureParamsFilter `json:"filter,omitempty"` } +// QueryGovernanceAccessParams defines parameters for QueryGovernanceAccess. +type QueryGovernanceAccessParams struct { + Page *CursorPaginationQuery `json:"page,omitempty"` +} + // ListLlmCostOverridesParams defines parameters for ListLlmCostOverrides. type ListLlmCostOverridesParams struct { Filter *ListLLMCostPricesParamsFilter `json:"filter,omitempty"` @@ -5700,6 +5864,9 @@ type UpdateFeatureJSONRequestBody = UpdateFeatureRequest // QueryFeatureCostJSONRequestBody defines body for QueryFeatureCost for application/json ContentType. type QueryFeatureCostJSONRequestBody = MeterQueryRequest +// QueryGovernanceAccessJSONRequestBody defines body for QueryGovernanceAccess for application/json ContentType. +type QueryGovernanceAccessJSONRequestBody = GovernanceQueryRequest + // CreateLlmCostOverrideJSONRequestBody defines body for CreateLlmCostOverride for application/json ContentType. type CreateLlmCostOverrideJSONRequestBody = LLMCostOverrideCreate @@ -6818,6 +6985,9 @@ type ServerInterface interface { // Query feature cost // (POST /openmeter/features/{featureId}/cost/query) QueryFeatureCost(w http.ResponseWriter, r *http.Request, featureId ULID) + // Query governance access + // (POST /openmeter/governance/query) + QueryGovernanceAccess(w http.ResponseWriter, r *http.Request, params QueryGovernanceAccessParams) // List LLM cost overrides // (GET /openmeter/llm-cost/overrides) ListLlmCostOverrides(w http.ResponseWriter, r *http.Request, params ListLlmCostOverridesParams) @@ -7196,6 +7366,12 @@ func (_ Unimplemented) QueryFeatureCost(w http.ResponseWriter, r *http.Request, w.WriteHeader(http.StatusNotImplemented) } +// Query governance access +// (POST /openmeter/governance/query) +func (_ Unimplemented) QueryGovernanceAccess(w http.ResponseWriter, r *http.Request, params QueryGovernanceAccessParams) { + w.WriteHeader(http.StatusNotImplemented) +} + // List LLM cost overrides // (GET /openmeter/llm-cost/overrides) func (_ Unimplemented) ListLlmCostOverrides(w http.ResponseWriter, r *http.Request, params ListLlmCostOverridesParams) { @@ -8623,6 +8799,33 @@ func (siw *ServerInterfaceWrapper) QueryFeatureCost(w http.ResponseWriter, r *ht handler.ServeHTTP(w, r) } +// QueryGovernanceAccess operation middleware +func (siw *ServerInterfaceWrapper) QueryGovernanceAccess(w http.ResponseWriter, r *http.Request) { + + var err error + + // Parameter object where we will unmarshal all parameters from the context + var params QueryGovernanceAccessParams + + // ------------- 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 + } + + handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + siw.Handler.QueryGovernanceAccess(w, r, params) + })) + + for i := len(siw.HandlerMiddlewares) - 1; i >= 0; i-- { + handler = siw.HandlerMiddlewares[i](handler) + } + + handler.ServeHTTP(w, r) +} + // ListLlmCostOverrides operation middleware func (siw *ServerInterfaceWrapper) ListLlmCostOverrides(w http.ResponseWriter, r *http.Request) { @@ -9947,6 +10150,9 @@ func HandlerWithOptions(si ServerInterface, options ChiServerOptions) http.Handl r.Group(func(r chi.Router) { r.Post(options.BaseURL+"/openmeter/features/{featureId}/cost/query", wrapper.QueryFeatureCost) }) + r.Group(func(r chi.Router) { + r.Post(options.BaseURL+"/openmeter/governance/query", wrapper.QueryGovernanceAccess) + }) r.Group(func(r chi.Router) { r.Get(options.BaseURL+"/openmeter/llm-cost/overrides", wrapper.ListLlmCostOverrides) }) @@ -10074,618 +10280,650 @@ func HandlerWithOptions(si ServerInterface, options ChiServerOptions) http.Handl // Base64 encoded, gzipped, json marshaled Swagger object var swaggerSpec = []string{ - "H4sIAAAAAAAC/+z9/3IbObIviL8KvjwTMfb3UrTkX93tjRMTatme0Z12W9eSZ+KcppeCqkAS4yJQXUBJ", - "4nQ4YuP+sQ+w+8e+xH2LfZPzJBvIBFCoKlSRRVP+Me2Nc3faYgFIJIDMRCLzk7+NErnKpWBCq9Gz30bs", - "lq7yjMF/v5TFFU9TJl7gH83frmlWwn+kTFOejZ6N/kOWJJVESE2W9JqRnBUrrhSXgmhp/jWXxYroJVeE", - "JppLMRqPuFCaioSNno3eS7F4pguasGcPv3v46OjJ4x8ef/fd0+9/+OHo0ZPHo/FIaapLNXr2+PDReKS5", - "NnRUpI0+fBiPfpb6pSxF2kvnz1IT+Kpz/KffHz19/MPTw4dPHh9+//DRw4dPn9TGf1yNX3Vmxn8raKmX", - "suD/ZP00hB92kvH9o8ffPXr86LunTx8+PDx68sPjo+9rZBxVZNT6+2BIyWlBV0yzAlbwpCyULM7oggtq", - "WP8/SlaskSKVFDyH5Xg2em4arLhgitwsebIkOV0wIudELxlJZJYxWDizngXTBWfXbALkj56NfoUuxyNB", - "V4Yi09JQmyzZipqRaJpy05hmZ4XMWaG52Vxzmik2HuXBn34b0blmRZu6N+zXkikNxAh2qz11KdV0TJSm", - "heZiQW64XsJHXLMVgc5w23meGKL1Ojd0Kl1wsRh9GI+u2FwWrH/YvGDXXJZqu6Gxx23GVvyfkZEvzETL", - "1RUrzFCmS2VYz0WSlSkcMKAj6JELzRasgM1o/ySv/sESDYPoNWyWlLH8tf/rGV2wr2VjIDPijAKK8IMY", - "Qz4jjz+MRwVTuRQKZ/EjTe2eMv9KpNBMwH/SPM94AuvwIC/kVcZW/+0fypD5W8CvPxRsPno2+rcHlcB+", - "gL+qB1XXL4pCFigK6hP+kabEDf9hPDqRYp7xZP+kuI47CfEjfxgHYnx7MkIN1SF4Y/S5Zg9aWs2QuN3c", - "qqZdkwv00nj0ZynY3vlrOu0cHkYMFOKObI3o016WNr/fnqO+ZdeMAkVb17OfcMfE2mw/xVrrrmk2FLnr", - "G0g+TlOcR6/ErPd3nKYHUhCaZfJGEXarmUiNolLllf9ModoyJFPNrzJG8oy6v1ZjTUVBNUtokSojDeuS", - "OSkY1SydUVyELHs9Hz37pZ8hz6lmF3zFRh/etcgW5PT89cH3Tw+PiOYrpjRd5aRgecEUExqW18hrJjTX", - "awKjmz+lVIOoLhhNX4tsPXqmi5J9GI+SsiiYSNbbU/cjzzIuFie24YlMY4Qa9eH6JolMvVKkwHhQG9ZG", - "cz2NYNEz9vnYBaP3sqvWfVNlvs5xQ5Dgz27aBVOyLBI2mYqpeEVv+apckaPDh49JsqQFTYxBakZc0duf", - "mFjo5eiZ+TViErH53BgV12w2L+RqL2wyi2WmTKhIgU/kZslEsFzkiiVyxRTxg0/I380n5lKjcpbwOWfp", - "2LSYCtvEXGdIWtC5bnOyWvwXrkO0FYGM+iy1/ERz5IoISTIpFqzYMNGpqLfzXxMuUjbngmuWrbebNxOp", - "nzVPt5/r259On8M8W5vU3ZpmuHe27RDE6Klte2GaxrkYflI/1WpCTqjZLGQ6UlwsMjYdEVmQ6WhVZprn", - "5t/hyd9Hbx/Go/dsgPh6Yw/iX9k6JjDIe7bGravYih+Ugv9amr1pTh/RS6rNj6ViKRjDqREc83Uo2Mhp", - "+MlUFGzOjHhj8FFGtbkyXVJY+0tyzQoVSAm7o8wWNX3g4O7uNBXu68Cat5yE2YxHGb1imdqkcH/Crz64", - "q0frUsNVntE1Mb9G5dePTN8wJsgRUPrwydNuIfbwydPxaMWFF2oRiWbU5wz0Z/waYn4n8HtbicDFZKP1", - "jyrrDdXshBZgKTnGvfF9VxcZWhR0jZcWdCkMOkHn2Ch+drDHxjTIiVzlpWYpuaJm20gUS6whGg2vnbBQ", - "z8w6HJBLELCXz8hlXS1cojTTRDE9gQ/tjmt9Sabl4eGj5N+JkDeXMMa9y1D4hj0RWUzFpZA3thGpfXjf", - "DlQkS37N0vpQWtYG6hONjoHjUZmnn9F4yqjSBEnoNgiuacZTaDljxnaNbOGfuNKm2+pTgp9uvX/PCpmW", - "iT6hmmZy8Tffj7WWu1n5t+aQkU1uhQrSPadlpuGU1ufwt5icmpBTkRRsxYTZuxF1atcPRAIXxuSBrjup", - "tZREPQoF+7XkhbnW/GLUpJVd49DArm0YVAvV9JpqMTB9/UGviaJ3ES9GW0VGBRbv1GkTe2xRn10+cxqO", - "pimqFFq7gRApsjWRAuTuAbl0im9zwxU62KjA1qPxiAnD/l+sKjVLYjsLZlrJZJhp4AJj6Rvrqhl40TJ9", - "kNx1QpzDp31TSqmGq+JWJwKvfB/au3nF9MYLp5/SK/Nxc3MBHbajzj3wxmn14ddOKYi3CdpcQAtws93X", - "PhGbaT3VbPUV0Hvute52+pOAxW20JxpiLVVolFpdp01FNYtJQ5NeVB0vKaq+NdPkyhg8eXmVcbVkKfSZ", - "4BFkKTdCrq5lL2qCsN6OXlOe0auMkbksjKXYUpwXHbeSdsvgYMMERuMR0mD+w3bYdcALptTw/QCtWm4O", - "riPe8ROu17WbvvkqQksiS6GLAUb8CTbo8D3YX9HtwAX55fT8NXl09PTpwdG7e0utc/XswYObm5sJV3Ii", - "i8UDruQB/G4JOTAt1WSpV9n9qaBZvqQHDw3LV1TX5mPpNpY3F+yozYGXvFCamB+DPWs4GHbzk/n5KMYY", - "0/Bhu9dzlkiRbtXtw1i3+VIKNut6NDgzv0buGPj3n7FVrFepNM1mhneRTuFHWJJan/hnWMjY8482F+P2", - "/M2fzVUwL+Q1t3IpNB8jncUeJY7z/MtVcfbScpznn0fPNZ9MtncQUuUc8OPfmupCgBU8q7/C9vV2ii3O", - "qgYtXdLusz2fdzAjR1hrRxl7LaVFimZye+Hs+/RvLXfBslxRoyBpCmKZ3eYZxRdD5y5KjHUGT50ySUp0", - "BdhDa/3wk6m4ML/POctSsqJGcglNuekXFuCB809STU1vS5bl0EGpWEFKkbICJjAVN0uqyQ0TmtwUUiwm", - "5IVIMqkYuaYFBwrhzV0Zsah+LWnByFVBk/dMqwk5X8oyS8kVA/V4zY1lSRWZjs6NhW/oTqhi0xEon5QX", - "LNGGAtOXIebt6WQqYve65qmuXvWb/HxrHSsF02Uh7CNqUbAMOXr6nFzR5D0yFGc/dqOjdJ6KIE4AL5xB", - "BzOewt/YhADDDR8VKQ3nRWrdHBm7pkKTTC6UYScThJKkVFquWGHuirLQilCjl1XJtpyw6rFo/nJxcebM", - "mtBPDhtxQt4qNi8zvFzlVCl0QzEvZKbiSqZrw5FkybOUVPvWMIaSeQFPQKlZHfKqVMaQsezF1TVTwWtW", - "72SC92IraNtnQS1locd4JA78kVDlakWLdXPPk1NtGpgNJ6SeimRJxYKRK+ta8mcFjD3qmo0Ju01YrmEL", - "ZjKhGf8nLO1kKvz2JXe6e3XntQ+WjJjfJ5s7aggxfwNF7gaHZOykz7vAe2ylVFtoW6Xxzbj7Ztz9zo27", - "wH5qjQEunCwzEqJ6FjfjpNx8tjJmE5oJK5rnZgh4JdesEDSbcXEteQJ/3WS6vbBtTn2T8UhRkV7J282N", - "z+2HY5gnTG9TC/zugz/B658xuAi482E8koJt/8Qbdrh1A0vz9i3aLPrwrnc5rRt0F2+Gvz7TPFegCK6w", - "W9SBBcVnf6NNpRBGQ9jHF16kBzkt9JooVlzzBNwGx6aThAoM6zQWljRKnOb0imccdHDG3zOi1sLMC803", - "8LkbNSGJ21BTodbKXAnGFRlVzFx7aCBc01uS0Cwp0bQZk5Rl/JqBop0K3KJMjcMgNDknOV2vzDqMCdMJ", - "OA+qEI/mMTQrH/LFBUusZYkcgo59l0gvNptUYW12B9WObG2LehO752X9eftBneb5ZBt1HX/i+jl42tq2", - "p2GvqdV+7XpKDZ3DMRKaJoJ1W1u/d9jZhvNirdfn9vY55MDkeWX8mu3bvtPGpOJwHoU0xgVC5KLAbZil", - "I3BpzFmjON+z1B8u4ulyXPZGVOsL1Eooaj9uDk5u7kC4PXgNYl2HH7Ze6jYbh619mz2btkL1+rwd69w7", - "dItJ+AOKOXNPi6xlKJfse6mjrmYm2SG2Z9t5tf7b88qu2Qb+uJ9n6DRvXyCa3Zw+hziCmpw2vcyOHj56", - "/OTpd9//cNjaImHrmNVl3/hmVmzPVkwvZbqJJNvKCXuCrcjp8zpt+aqXtM5eoubxXe2miGb76B20t8N2", - "GkorwoSxVlSN1pZZUB0KYzQja51JAY8bF6hhiCpz674gV/wAr8AYsGYslGUhhb1Mk5xqQw+5WbKCkdc5", - "E6+YZsVU2BmTFRV0wRSG9KOtQTI+Z8k6yRi5WfIM4138yUVyyJKKFCcEbaai9vZORer3RmW3wBxOQw7I", - "4v08kzcQA3E0gdcSZ8fZcfBV2I+jMOqroEJxa+It2YroZSHLxbKifCrgUqLIPXhMIf/1f/5f4OgxPbv/", - "Zun9qXiIo4brUrCE8WumyA27Wkr5ngip+dzeLRShV7LUnlcwDEGfh5qKR+3uEpplyru7rEejxc/T5zi1", - "FdPUCJ2peByjDJfdsZZdg70GfV9zim4Z+5v1RB2fnRrm4l2suTu4AgdlIeEGdbUmZroKo6Nyij4VnGZe", - "yIW5uXIppqIUmmfRXZFIMefFSrVGMtQdn50CMwy5X2GArQ0HtGbtYJsiuOvEI4rMwU7wK1KNhYsB4o6H", - "d12zdi7IqIPcbwG4mwJwQSjPQELMzI6dmf3fpuYFfIchsK2dbZoAKRBdil2m40pe3fAss4eJYoqV7Ue7", - "GNYbyrVVasxc+Krzbi5nNMvCVn50BjFkueRCuzQsf0jFwnrWp8IJPRjOesvt9S92gLV00U1IW16wnEIA", - "CvN3UTSK/JRTrppzpqWWK6q5IX7tyfJSuskEt48xGBdkyKIsWOr1g9lxXCyCFKUrKTNGRbCKdqJbrKNn", - "yUevZI25A9ayTcGA1WRpbTGZUGXBGqtZWRJeXSuiyiRhSs3LLFtPhRW3QPWcC5oBEaEZYOngEAa7osV7", - "9MMjDR+7/m3W0cJMcLViKaeaZev2kNHl30+k9dcZbzs0rDV0B3bEtp7X43KMTkIHGu/QM92vKKaxe0Nx", - "oS0RJ8O7LTw2X3z86E5xjdYPFBgWQQBjh3LqkXf9zqOdA93yfHPY2MDjF0lFeF7zoG0ZZdb2Vg+87WMr", - "a3pBDBiE+4MAZwqct+4+MmdUG0H7zXD9Zrh+bsP1m877mnSeeyb8pugiim6DWO+Itznx6xMEEkMATCBp", - "wjUws1gbssLs41g0bevFdCf/sR29AfqRQODCJg+t/cyoRKqUTDiY6R53w27N4H0Bv9/q5eubqvqmqn4P", - "qirj12wVjXA5FSlPwDN8s2R6CcA5zC12dbYgD8f0sv0pC+6kK6rem22R85lNaW1vRfzGdX98dgoJq7AT", - "IVeI3eZS2Xv9HOKTjPoECT1nN4112PHx/Jvu3qi7UQl8U93RO2qg0YIz19r/m3S8YfHJkiXvZanP8ZEB", - "H3Iv2K2GePGhAZDYnGh2q0mKm9yIdO1je5SGVy+H72QHJ/NM3kQU91yzYqbKqxXXAwm5aFBgobpY8DoG", - "Lya4nFel1rht6wSsmFJ00bFt8a2T2G9wzvdW9JYcPTw8DM7r/abAfnh4uFX8nVpyCJ2b0Z2CUZssyKRY", - "KJ4y4vp1UZHhS+GXxoJ9rL2f+Fe2/poVKzWT85kNW5vRJGG5D/wfypGC5RlNXPi7iySAQcx5tIMQuigY", - "ZCTDjL4snnwYLtBeRa0Rq/3dt8R+TIwcBQUcwNJhzD2HEPy8LIx10JJfCtvXNBjTZb7VVadB8dvTOM0t", - "Yt+eIr2hm3d1xdIUkB+XUukt71onoIUaZNQD4U+8iIheCnUhs8qy85RawaJqsSF/VN63F4RluxnQUstR", - "oDB3pv9ECqOv64QPUWVNdifYYRgP6p7MaFx2NiKEClYqNvPnazdzbPv5nuHor2DwN2bsYz90LCvALqJZ", - "qmuuOETgroOQVxdsBNOoxMTERqKuJIRp3PmsqpHak3hho30aIbuuCUTYr1alsDElbknhxBuDLUgP1pK8", - "PScrViRLKrSyIEaKafPLFLbpdDSutnoa4ljCMZgKLYlayhtgqcR7Xg2fJDgRkInDJjGxf9ccvTDjvZ6f", - "29HaXH2DZ1F5eiG+G5VRW3+4V1TcNMBa3wHFR+52o7dvfiJckLUsC3cze07V8krSIjVM11ws1GRLBfDR", - "p2No8mrf8dgoI6Ta2e+yp/meORLaS+9+gmtoXSqExlSnZPgk63UWsLCD/I1SLEhiayujJeJt7k8VndXE", - "ZYPmTdIqlG72aERoFlKwPVLcEBJt469lRnpblVhdjluiIhQo3Iumt2LpLdyfh6r5ynjhybKK/YVUYuVf", - "J/Fq7gAyYnZf4+oaXNn2eKprM/2RLek1l4U9txZ5aCTYNWSg1ef5d+d1k0TRa7wLNcwwCJVxAbzONENj", - "GPpWqPqgfwsc59xbX+4c/YKCry2cofnDhum5m/KXO0V/l+cCEzBdyJObpfugd6a7i+n4TFriwf2CqCvm", - "41o2hD1skNnVd6dysg1Ys7O8eMMwcvu1OJGrHH35MXB2m+J8FdLuLlgtMuuXmOyGrtVoPOLzmZdve6Ab", - "sAzw/UANl3OVGWKtUQzpx9chIwZIx7UYXdLOcsWP/qim4pfWHen47LTCo1dVOnEqEzVBn+4kkasHNOcP", - "HAcfOA4+QG/o/bY0tYLKOcJmSf1St7+T2XnprZ9Nuw87j6bL7Ntw7W0eSdPt2CoieIuo3Z+dlAYkA8ES", - "phQt1i6VcSqCXEYQXolRvtmsLCKwG8beBpQIu8cry/5mKQm2jGs6Q/PPUmMsqwOtK/lsBdnkiky9D8Ii", - "lbaeQjNu7sQ+tCn6LPsWgTsr6E+LH2omW7BEioRjsoLdOvhMy0UtqBYZ7GDewrSeMUlooeE/ZEGoWBMJ", - "S2fhSHlHLQVrgN3d9mv7LKIX9eAgwwG2n4cS1dmKaQl8c8uIG2MwYvVGqOqCsYOMaW24e/6aPH549F0D", - "vJoLUuY5KxKqWHgpxKAvb5ybT71EJf6p1HwDDrXGFzgdM+eZZrcf41LZ8AwSWYfgqUNL529uMrz99hHQ", - "zIpZWdmsd2Vf9Dl7Ps7o/TAesdvc3Ozt41vrEN8GT2ge3rLZEbGdhMf10SFZcVFqBoLx4WOylGXhLAQb", - "zjAhofB035iTi6YQgq48fRyt2YEOl8g79YuLlySjYlGCA5suXFR5RfbbU+eugbyqObnKqHiPwMrOL1S6", - "J+SrQt6o0MVDLL7/MyMqhfl2OpoX+L8p6xCaLjupW+n/FktUrKNiAIbqe7Y+AAQjklNuPTla02TpMIGi", - "Et+C6MAx1LKwSoy75DddlImGzIHADJ3E4FUaLlHzew/ga+PODl9D3j8mFNxjk8XE8C2hRYocLNXsior3", - "M/tCOh3dd4vUAFq3po7LD6RZVkEX1Yeto8x2JLVXuGJOp86kmCU1+3KPJzxqwsY8dwNtWDiBgTtf1KyE", - "UhkLAd9Sq6lNyDljz6aiy9Zz8AaVwYfy5sDmRRzkdMH+ZL86KPm/O/oOzFZCluqyEHFL5g0CXRmDpn9u", - "lm63trTUS6PsE+ozJL1G4vMuiwb8YI4fB+jMbewWzKewWSzxkkw47/h8zvFH0m2h1fkvFp4ApyOH2Wj7", - "WL3YLDW9nfH07mylC3p7mu5uKWl6C7mfMQPJsmpv1oR90avfIez7XCxazj7stTVPKJKntofpyNkeyt/g", - "DvAnrC9V38AuNYopC+GVrc3fJPjep4LmeV2tVsN8jJ/gDVMw60FXVmxk9MCWV9QTBP1DaY4ZVZVTRDCW", - "Omy81plq6j5ZTAXE3UB6FqEiIljiMSt9ty54Ice7lTnemBseHOyCedo8xsXattj9LgWjwofBfer0eYXx", - "Zl3fFiqxqe/D65b5zBltcOOCB5vWtauHVMWSgkVsxRMkEH+GcT37zcAWFOcfyj+d2e95GrlN9Ci4u5J2", - "ew7wvdjCar6hymbpp3dzrTupXeA6hVHtPsNWUZjPk8oJAl94ZwafV/tQywD8qM3hOvbHR2c+hRgh9gTU", - "IRAi95tPs648y+yVaLIn2/+V7cKa+sjrroeMloTfqy58Fd9rrwLgzqi6w82oAcw/W5MpxtdMR8QZNRab", - "w4qAQNO3rPkNFiUUTOmwKhvGZMOIjBp72GIjYk1zFyAwTKQ7XeYzDkXpOvtETwl+ZLa3SzlumkCtF9zJ", - "aCD2ah1NPrpw/QI37gjGvfdv7oeZYyL+/aCC+mzTanqe7YATNNxSh/kH1voGdd66NsUGHOisbZ5iqFR6", - "zyyzNQDN4bg/GW3CTg35FWVibR+3d2EjkBkExrtdbcWmYT8w1BHs+s4gLTwDsbebBigb3t9qNV3iuEPo", - "itCtYZsXi6azH3qLp9ZXS3OXNyZnMg17d2zNkyv3wJ/ezRtjF9ntA9miLYg8IBm7RivaPdLx+czrjF0e", - "5+zxOJOFppmldbe3OV8HWlpRHdxznITCYfx1p33vCHd5p9zDdG9znbnlkGY9Fb84WRh2sOHlzkmGHIh6", - "UGuq7kPgW6lYBRhmz9nYpjxdwYO1VmReCgugxfUaETFctjdBl91U1Isjev3oHawukLkVZ9XGQ+tw+QJj", - "Xly8nIpfQsfvMB40HjH/Df/H/uoU2AGScH8qrMbEf1d6CD83Z6qKX+cCmOGdzJe01PLSlooMXhdzuN0V", - "LJ1hr8p83HQ/u8p6UQZtsIqm4peGKroLFlVE3Le4NI45WlZ5HGuEjLXqFAFUeOHusEbdwsZSk6FQxxuP", - "+N5cGdXR6zjkO3IXZ3V/J49Ik9/a20pT0aByFxFU98i5IpA4IP9nI2AH57WtDdnPjX+rbzJnSNYo/gTX", - "+hOH/aPvdlo4TJUG2of70ZQ9A233nQgEkzEC596VPPqT/eVOiQry6Nom2SbdUX8yHCbd73RSSPdAYV89", - "qtwpcQEJH3GXq7ayqt/qtr9hgdO9ccvaWfVMRa/uaaWCRq9bLVlay/Os3bZqXPTrbf7ZfwXrrr6o28Da", - "TUwND/M87oCW6rKiT5a0iGWPee2SwAebSgnMM6pnc7YJ0f9lRvVLxuyg41Gp6ILN4N1uQ8u35kuIebON", - "91QSoE7RliD/bWLehdXfa5zrKWqCjbuwPX7y6LMBtIdbDiMG/gaFj1zdXLsHba09/Azg7qDOn3M5XZXa", - "lb/Fqnpk3aqnG7Tnyn6GnwA+XusLANILsPPMvUFIMi8LuKJaTFjwv7DbHLwv2J2Fjegg2f4a7nanSIOS", - "gDDsyENQhDVlkL2k2ztVW4YLqWk2OKfXnE5o6FdHLNwLCM2M2WE45IAMqEjDurKXBaPZTPMVm8FBuLTf", - "hJeCRuCllO938EPYuXVggawAZsX7DIFpNAOkGIIDOtPTvyzZcI7QOd9dBfdHJBqr+mZmuvudgOs1OpN6", - "wpPnepvpfTN440bQlo6G3rDL8m7TUVcvYKgIIif83cb/1uWHipz15r4JD9AfFTDkAOiFnxv4P2HLUbfc", - "smzpPThS6R+p4kNPDRa/uIIMNvukdWW6Cd4Mrtat15+vDW6uXrT1k9IIfhiqGcbnYVAhYiYpbVnN1VR4", - "Cp13x7/9jQnX+PB1FZZtD1FJAeXVfoFpmFhJ/dLFJwavdnNOta+0tKcQV0ZMr42oVv8o6ic62R/4TjEo", - "MvTncsUKnnS9dhoCC1giR7KdyCRulVYstITUrM4+yWMsaH2c/qNUeodsymOz01OuCfU91CAitSQr+p6R", - "FRWlUQz+KwxlDMLtAWrX9HRFMyossM65P/GlYgcJVV7IgY2FxRIT6w4YUF/n04A6fY3IgY3NBSSFWqC5", - "2qONWwtztCER9UxmPIkAPUGyNi6/se4SabR1rfRzIoUqV7kP/jsgl1LMnJS9fEZObGtjRlZNqSJKSmH+", - "17BtUVABBq4LxHAdObS7/t6kSOqoJBwwnC1Onu9MMa0zeMUY1BM2qxm0wRRjixBwluTI2h5tDI1+xMO1", - "iyFrz2X1fGxnhpZtcIlv2KTBiD2dXq2diOOsHsLbqwbCSVkTMgY/FYT76oKz6z2G/hgT3+tayxo7K2JH", - "Q+9rP8xUjbBxxbX2svufNp28l6VIuVhgDnac/XP8xEVsp97ycjgI/sSYL+2T4QG5FFIYs/Jn6XvwGPRQ", - "YJCpMUZiYPB8DdMBulTQjUVCtwZqYyyzJQCr8sCCszvAdTMMNHeujI72stQeR8h2YUPQb3jBsDrKnBXj", - "qWgAwjPIM7IqywfUwTG8386Itm0C10pk0eqM3nhM/2ymsqsqRj7QLJOI4OcOak3h4ntDIJzSgt4Iksob", - "QeiCcqG0u2HAda5IK4B9Ukk4CFmYiqAYgY34A+MloUXklor3sH2YSsAmlnobZIXYg18Bgufw6D+3PzYb", - "vt7mtdJoUeMSmrzfIDk3Wm9znrl67QNO4UtsVdntwZlsHwX3fh5z7624bvUAieSuzHrj8d3/G45z/R3e", - "G9fYSxPEnYq1a12rb/bLiIu81DMt3zNhFI4sdfDvd1tq6Td2Tf7K1u0UnNj7rpWWNu1o+BmJqL/2nn1Z", - "133hYdnjrdBph2G76NSqOh8BXm0oJJBUpV3BX3hZZ9mlUYNevd5JOYJTn3zrWOf0cwyO2e//NmYtF4O5", - "0zk0FJHuHT/Gh82zj1iWG+sudFuj1Ub/OrHl84LLwtdIt5FoR4ctP15Bbw7AoHAN6oeM/CRvWEEgvVHh", - "K92SL5as8N83k0OPniKxRqibEQ8PgVb7z1jeaF4WyZKqoTvszDarVejzMFjBFM5QweEhpJ3W8FTcqx9Q", - "98qClvT9uzSSjEmQ+/mgiUROLPqAUQCFXJHLnBWzUnA9S6TSM/CNXcLsreK4xJaX0TMc3kRnub/k7yC0", - "I96CerxjeCXuyZMe6k8IwyBrnoU7ztVwyFyN9YGt216RXbeDY97R5DDCNO/0zVnhltsMXEX8uM0SpdUm", - "7MZ3EFfkcPLkMNxJ9hmGK/KHo8PDyeEhRgrC24m9ckyF+fWJ+RGrO2IK9Ko0pJqzZ4x7ow6pIIdg/rTc", - "1+QQsrqnoqEZ/x0OHADYM9oOgT2aHE5s4L694cx2ROPG/ewEicVDO/fddiJ128yJqkBldddCSjb7Evx2", - "HTsxEnMAf9S84Oa1cQ5Z5I263xrQ9HaGl8mPIeyC3mLsWkwc0ttIjHlFldkRL2VRWU+wdytfQ+Mqr8ZY", - "mb7Wo1rKMkvJFdR7rdKlsAadc1qTgl0zAbApiVwgarjFray/tQRhsw07HkfGhBrUNOkYExGp/iMqGHh7", - "MZPL5BXcmCyOML1N4Obu35K/Bmj28ehaGp7cYX4XMvaGKoJD7QsgvnGlGUcOaa3YS919BFRtdPiFh7Id", - "sRNunObBdH69nAGV7sXYOhwzmbzvjRVZM41QoZOpuHdZvWxSDRrA5uvNS3PBBAiftr3guloxfT8SbxJS", - "wt3DsM7WFqHUHFGW8QWP6/dumnKq9Nicbpc3GCGYinQqOkj25GIPaYxe+xNeRgq2olwY+VEK0K/WnTue", - "ihoV8D5veJ5TpdzjAm7J2BjBhiVv/BDOD83h+jhnvBEwY5c7DJixxI7cUevajK0ttJ1Ps5LMw/OE2lKb", - "1t0rUPu7WxiTYbJ4PBVcJFmZOiQrpwKytfMwoys78uYRIOsNC2Shtw18wSYTPDSIlfdV7E1wA+buZR3V", - "6Q75oLBOKauqIXYp0pRtQ8mHahNts5IbJd0ms6pL+nnbtdu6aklCBxjsBSCmuruisIEIbL4FVv+OddP8", - "2r7/xT6NPA0GR7eq1OXs1tip3Tz1jSf4oqBC0V3S/PzbhK66qCwBRShRXCwyL9RW8hopa0FvT0UYH3DS", - "6hW9n3y1KrW57N3lxfqcL4TZBPWwsvoEJgRBja+Z83PQtJL5RLAFNT9Ohf21YGmZ+AfEvst2xmb2qx3e", - "cqvLsFMRFgccKgz76isBXzvKvWxyXXnujUc4wtYNNrjcbG9jS0bsgoNhd/t86PX1vjHar84h0ME4ZvzJ", - "53f6JNX0dbgdR8EkqwDrGpvtW5W2L8vp6wqC7XAnD/QGZDF0RFHYNIa2pviIO1glA3yNrtjFqy1T2wo0", - "IGijfdKc8ca8jcikrSGCpqaPJPKvuSCpe3yaB+QS/xA2dn8xZw4ifM1tbM5YDQ4ZR8SsFvi6N0EkkBrN", - "l1AKIGe2yFAVwNifKoKfbyty8GOMf9yyjaFrX+khjT6HiUuk/UNfcGYoWffle+5YF7Dl2zlQ49HtwUIe", - "bFp+M5adUEeuUGMgcqqDmxklJUIIw4XiqtRgU5trQsYR/QQuz1Ssp8LlwkcCfFty7XFNrD3avI2rOewY", - "sN7a682k23SjCdTN2s9nRVRGeMDxLerU9qjs521NHfJtoHraj2qOq1ojrEM168lsbuJluaLiwPQKQtmi", - "YEOx0uqyg2nysf7GRJXJklBFpqO35+S5zDJaTEcIVfuiLCTCzQ6tJrpeXckuQBz4beO84hOxgXW2B5f9", - "357KH6Yj0E9+Sjih//qf/8v+YKYGE9vOAtmgSYM95BPD8PhsLk8aMyus2eCsi1ZK5xbyG9TD0NKc9pRV", - "MZm0Onq1TJgYFlqX3NlRg3w72d9O9hd5ssHu29u53uIox815f1qB3nnLuuIQpbfR4sFA2qbJ49F/iNJU", - "pLRII1ZPjSHjQOJ1WzzoUtupZDArPOw8Fym/5mkJSa5mAyyosIkUCveV+VCVVyjGiJYkz6hQ+KwCUT8U", - "Udl0FcK4sabIcKwt2y5+92yWVmqAbUzIWxcqqektun1d9jyYzC6V1XbjB/tX9PoMdPdEeGi5Pe5npr9Z", - "fgtX/nS+KVuHv6/xC/sM1ojq/WpDGVe0WHcB4V4ExYTrSLjN3R1s3DPb4AX0+TWWwHfIG1Trgl+VO8HB", - "+6ompqfjoKMImix6f2xxC/iQEahJBYmfANMj6wgv1uxl1/B8VYK2DtcA00Nrw+4UtrGhLr+b5PNewN+o", - "InW6wk8ppZpGXlnyfObhhAeCS9aoi+ybPG+P7hjY+hFeVKwSzgs559lwd/AZtut9VQ60sR0myIEOcpda", - "KekhumCzB5eJ7rH0GgrbTagPbc5xs6J+N8upCuq/k7j8OFxYNG18i429ub7dHsEzm+Xpouve/AoffH2o", - "qi3l1ihFE+LoYVEiZ8ZOBRfmHsSSsmDjRkEGADSZ04RNyMUS4oKwGoNHtAyKXGlprPfY6IEZfOVgOFKS", - "QQgrlOhB29hWnEb+t7eGxZ2S+V3U7W7UKmzvqtdhBUIbveFAqftqPFwsmWK+fiGFStPKrJWvZuFh5KFE", - "YQtY21uwx2enOxcobO79Bi+HnoM4zuS+T0McZTJ+KGwBiO2wIVtdA0iDADW7ZLyYisb+HVvgIgud1rws", - "wUuUvcLBBy4CaMmVlsV6Yqu1I/IZom/zBpphU2BzRTIuLLYQdVBxNM/x2tidbr7nY9KHGrzbKelCCP74", - "PdqytIbtxeFW2IS8FsEaGgEH9/l/skJOhSzIShbMWWdqDF4OKfxfoAFgX12xTOLIUrAeLAHbcPaerbsQ", - "7u1gKHIBdMHNJW2Tb6vXsVWu17ZQp8SpTkXNtLT4DZHEspDYrZIhm6t0jiO43EhrmNi/kr+ydRCXVaVM", - "1nZKyJWeffJCQO/mZB/Dcd0JGzfoxZ36AvrpQpiNXIjNmtffrpW5piR4RcHO1YRgpKiRBYbT//389c8k", - "p4UyjaqU89oTVdAe/A1WKDofOma4BEU36xDUPu919BuZVjEBr2TKMjUdPSO/TEeLXB88weJ15j8fy+no", - "Hfkw2uiBHLtc35m9Ym8nlmqX7DjMEXZL3rN1jAu1aVVhDiuYU+zmt6RqhusaxWlBWPlQdC+pCjx4uiJp", - "Qo6hsDIxPcMqX1qI1kuU4pe46peNZX/OciZSqB3kYoWgsZVFjc/DCbowsehKBPCwO8WyBBt/iyiW3nXA", - "eW+MarEe6nDj1NZnu7O+XQBKk1brTrY8t7kJQLPjY49v+SVS/NNPry7ke9YVAmN+qhzmP/30CjO4Minf", - "lzUUU0hC99nn5r5OkyWbGeb5f9wUHFCvCkaVFBi5YDFe4b9ULoVi2xH9VnB9Igcbc40ZNOQLeUGTJUn5", - "igmw4+7Zm2sxhvtDNibaM+S+UY1TcRWk8ROqCONw+qiTlpgVB9HTsE5kUcgyP7haExfbAn60qbi3KnUJ", - "gevsNslKxa9jZbuBjEiJQxwMfjU3SxzVF/MEKYgCMclombKDRwdPDpQUgkE9TyOGsayAy7GZCiezdEGT", - "90H0L4wxIa9a1KK+vYTfZ25yl+FNHoR0tBZrrU17eq86OAcGxFJmKWofN/3IfCzzQQ5Ohe+pWuo5mEJb", - "TK09I0/PKO68TGzU1CBJ1t7pZ7anWE1SJbNrlhrVeYA71A6LF2kzf7/xU6rpFVVsQs5kbtOLuSDu9Kmp", - "8Dxzux9uD8hce0FODTdXXLB07HY8jBRuenhqMn+disbOt6gdyFV2SxNNVlQnS6b6ETzdLB0j4HAAhZ0n", - "wkzbT6NxKmTOBOV4LKjQy0LmPBl6HFznPdvGfRI/FGduCtHN02i589EI+dB7PKaCko7jMWCq0Rn2nhPY", - "trOdlH5Mk0UyAXBDVAIct0OMGV1rXbWdCruL4GoEug9/Vfcn5NLqNEhTo4LQjFO8b17Cl5dj8wkeN/vN", - "VAQfoQq97GFzxaz4nqrUdp21H7+PKhbsKmTDHraYYMe8+vdSvzVVi2z1dg1k0xsJGVo1WRZ7n4+ZgD12", - "XrcoH1zxZAcxHymn6gyzWc4KxAnaR6oNgBTA5c0MQMwAdrG5IG/Pn9fejatPcmb3BLzEV3binRIHI2yg", - "Dr+pkYdIS3dDWCBEIiSdwq81YizO091Qg513kvMaf67R4636OyLJ999J1Rv/RUBY80mlsYQRPm4+yq8A", - "dnDHK8gxmfNbe4q90PGgIneXCveyc1TPyl1kp4VgjIpP/G1LCdoLhFHnf8j5BihQbXqxHFbv+Hjhbmq4", - "HA792GYKFkaFpWtBV9aKbNx7+9IjjNYYat1DWARwa6uWjR24r0oaHZ3veGPpzZuoV+0YfIQyqsmc+WIH", - "Nj+50ytN02sqEjbzCZF7yTVktMg4vA3xFQvrD2PViiqQEEdPEbUTkPFp8t4YSCIF+JGEKWVfFLuuP8fY", - "B2Z+Gj7iTsUZGcPOltwaHCN2jKeut7IEppv6QRr1GfqojravxSmwgg/BDzzJpGLpGbbaEJsAH4VLgo8Y", - "imjZW+2i1v53GSEYwyjdvNphOGASxq7uEpS0KQLFO7fljXAPeNuQaMn6FrG4TcSiUXPmBA9/pbXy/bnv", - "oCNd2/3ehKioltItXdBV66Wm+80l+iAIfY8tIqAZN3FABG6wl9WTTeyKOS+zbKZYcc0TdhcizPQ/JqVA", - "kQll0mEsJ9O2PpIvyyxrNN47cOrd4LQ31amN7REWHObKo5j01v1xKK10JyxPDLlIZ1c7PAe+wrY/dj0K", - "VtOyo7iAybnMMnljRBpKir7pvfJNv6B4XYxMmWlWrHYIP+SJg4y5MB20mXcWYH26+TTswZr7MfjceeTZ", - "bnR1IXea37Y/krYrMFFtNcJ61dShtL2hmp3QIj1z/dWKwnYS7Yy56Ct9hI/xBojEeGeCsKpc1JCAibyG", - "qBd7aDaz/bwlBAMAydUuAEwVpNGruBV1Xsfg336LNBp+DBRkWKAwzuIuBMgtyLTdjkdhfORwPgaNN1l9", - "tUBMcE7Lgi/MNZylbd0eqI8b6kvKoLuUTkWtM76hBl5I5ejjYDCHYV9uvRytpgPy9nznPknNlQN91zMg", - "+m3ayROQNjfzQdTRQrNvMbfOfxRGRG+caqTxV5nFsVPCgwdJsVeZmp1SA0/xoGGBpdYS13FrtnVDd5qz", - "LTcbKr9bsXU6LQIkl5d1TT7a6EF6XruiDECEqN884AYA+Y11ApSNkUbEYki6NXYUVeTyrJBpmegTqmkm", - "FxPf4SVEUZrbhiwxyPfS1qmcc5al46nAen6uimv/8C1fVs6KxOy2WM3fM/+bv1k1L1Zordw7/K//4/8+", - "Ojy8P2nAtQdo7Yee96JcXZk784fOdaoucj0rdkbt2+MQmHfTpo5Dl7NCmYNWkKtSccGUCizlpt8P4p/Z", - "cMUJ4x775hFhYEOr57IwyqZgtQyGyvkH2PN8TgRjqQXx7RGHvKqb4KLIc0PJZJvwxUFhi9EcwZjIk87T", - "YLOhgyhGS1rn1eMntqCZvXgUHZAlfnrtd1x6O+Ppbit3QW+xBIXuun/hj39UJAMiHeMTnzpSJRPnZZFL", - "xRQAna/JitqC5VIvWTEVeDps8PQN+2PBXFyAZgWzWSpEL6ViFgu31XFvVlNjKw6GdcSMF8tyfyLa+2tP", - "2dzdadw/1rMS2gH1zTHfbWBKuMq71CfRa6K0dGWFU6YpzxRxFBmJabcFlDmzLZqLZxbXGJOu5g+IwWL9", - "sQAfla14WtuaHR7bn43owerdhrjGdgYEA7WUN8LBdVqz2W18vSapTEqMLe3djBkdmrVwBlgCNjaIUKLZ", - "Ks9c4dTQBu/BFEho6vP5tmLf6flrY6c9778Fu6cC232bImI0zALjXPKMilhmoqPtd/9QkASX3CazvkEF", - "DHK830Hp6TY6ahXpmUFcZyJXTHlY96DQQb1SGXwOZQm4IJdpQef6srPwRbUDXlSuHE0LCFFi9alquZ/9", - "QMxHaZmxdMsJF8mSX7M0PmXE1oEWdsqWQc5fwkXK5lxwzbL1dgxgIvXT3ysoxD4yVo7BwuMQ+MhW/MCa", - "fSEMka1IUVOQ/tCT0/CDqagu6eYTI/iVrnh4zQoVWoOGzRaz2w7sn23sp87gCqXL1w1wsaSqq/gu8AM/", - "ILDLmL/EmdUojKTD4IdQbU3IMTYi6obrZDkVMknKQqFdSrVNJ0mxMHD9vXxCjjXJGFWYCIjd8Moq2jqL", - "LjAYzqC+1wfgxCm2PQo8y9UcR+1ywHkhZ0aHi8WMCXNLTms1zfCIxXOg8kIeYFMzAdva2r0RfX5Wfe5G", - "imUm7eiJNbPs9cPWva94lE7kKoe8yCuqqsKtrCFJobSGFSmu+LqVy8/IZV2VXDq3g2Lagto7YWk+FvKG", - "TMvDw0cJabSb1Et+NLq1jf6dCHmD5XjCgh5ahsMSWUxFfCQtL+/bgZxMrg2lZW2g7ZzTX0PNHHMtRJcZ", - "KwpZRKuNKkCwrz4l+GlTCzOU0XmB6bFeqsIyXTEuFlORl1cZV8sBp7nu7PqbJ+KFoSFa1tuuw9+a9EbO", - "uJXs9WKF8WsELbwisJnnWSZvyFqWmCP/ntlMeOU9cIhiDuKyFALm37p1hCUKO2diqWwXMdwZt6aaes1v", - "27z1BJ5cKyff9d/QznYoqFhXNwQyPgItA3xWyFy4xMPHf1RVGWlF5DUr0NLCTJLaA0teyAW6HtrXvC8h", - "1GXw8+t2V8y08Y4D3O2xrYH5RSkadiUxOxJNUZAo+N2Krol0VYjTIE/aB80ET0FbAIf9SwCGmQ05gw0Z", - "t6nCDVu/rA6xa9yrewgJ8Mb3vAkQwEoHlAEBwRvOdVftnLr9gEdz0jAE/Ple0qoeDtSu8doAa0BaxIUU", - "SlG1C325m1C0FVj9XDTcOk2NHnYjJMmkWLCiATdQKta2T8KG1SUPw4ECejTUeYUALqdy3bsmcCOspuXI", - "MkLW9diXg3zm4kca2sn8eVNk+DzbCIEP/bzMsCBdwdhWn5vvxqNFQdPS6Jdt2vzZfwzvtVuR9dZ8Nx5d", - "y6xcbUXY3/DLPYWnV3PdMiS94uWQBjDLIQ0qVg5p5XjTd+I9/QML3Gdg//GE3XXR4nphpXlt3HoM+Pax", - "CL6DMBQhfCKOhx3smlNS7aqBTC4Y62LyrhMtGNttopvmV23RYZP07YjmEG6FNBvNAlgJ5q/OBLR1tNHH", - "YB+bEZPIGOLchuuYFhNiMyBBa6C5PhVUkaRclRlU27Itk0LCW5VpRa5kKVJacPsmDxYU5po4DBp7BXP3", - "ZK/ox80OyL0yn2k5w+1x39wqpoLd5mCfggJLpLhmCN9u3SNGSkZMV9Nzh0aGn4KCupaVyMO6mwXo+xgv", - "i+nzgmNge9TLcgF0tu9eO+7VStnseDKRb5s2bhgKGneQNaJBaUMKVQAlM5uGA+EwM1oUjNYIiGt64OnQ", - "J1eMsYA1dQZRtfzGWkIV6i5YsJ3rXjfowC83uQfhWDbQtICtiP+67ytuK6bxVjEV2x6K8AyAhyx6AKZi", - "wwmoaNstrBY1dDwO3q9lwAy7JVGSnFisRimSwL/vjhODJ/ganujLSJc2aO2jZoFmQ3QWkJG41SzyAGcP", - "WnnRab8c1WLg4hMJVnUfev5tDm4WwAB3tVbBf/prSdHF5aBbEyk05cLFO7jJnc5JiVdZ/5ri1kfmTBxg", - "TP89f7U1P96vzRQocMP1P0/7pRh2ZitmWgRTCL7y2aFwaJqLYy/xG0/bVOBxqx0jcGRhSXynaOwEQT2x", - "yWJC/vyjK4JvdsvVWjN1/9NadNXO3atFBxeOu7XorHk9bBdgo7atYyZkg+TCXQ9Hk7qIdA+Kg9EkPtMa", - "jyg80mSYKI2ItuilxTeXr9CeCVTYV2/M2Bvt3VkyFRb3cPRxi7eqnHjFIFSmNRcLFRZrQD+MFLqQmXLZ", - "UVOxYIJVjsEWdLnaFSL8OM99tH7Xm5aNbXWhNC5fg6smmuzka4ie8W8T3aCLVZiwwzn3E4y9JX6LhPlW", - "0LWvelQJd+pitxjYjjMJxDtRQRNdR163QaFu5OhhnYoqHvsreWC9kcX7eSZvBnPy765hfwCh678umDHM", - "IChcMPyV0G+BYA5jlNuVQNqse+rCeijwlGvo3DpRsU7bMr1VO8EVEdoF9HtTapjvHDDIqwBugCizrJsE", - "Cap3QYPzRmygQNPbuxgdajX1jdy0X+itzw1COFbHms0b6owuzP/DzLs3Drt1aG7HwrDMpe85ULzI87Ct", - "rjLMiLTHrm0lrhh21xvv4Mh6ZT5ucg4Ish1t5tWu5UgaFuAnrUrSts8GFSfxr6NDXWf+jmPD3VQt3g0j", - "nSp0c3T4WawGWbgk4c8eR+5sAzcZ994PsA51UAMp2IHRclNxT0hxULCkLIz+v49P/kHGSOUMU5vC0OVq", - "xTWAbw/Pxs2ZSE+CDiJ5zeYTEgxSCZtgxgghX0tuA6f+Acay4USm4p65h44r/+jY3ixrHqAaPV85Moo7", - "GttDo7R20wZUlO1JsjAnXkCZm/YGEPsYoEqUMgehUlRa6/cTg3IXIBj28hm+Xoy3eBFpCKJT4fDI6l8G", - "lT68ATEVHTLnE4NqRPeXx9H4iEx8dxZ7M/KtZYVD9JJUZeD3B/wgu7ZQnx+b3ByFQKyR/sXkFtuChvvw", - "Y/8MXZqVwldkdLgvCioQ/YExcsXmsghqcmtaaBXqLLjsTEWosTIwR+4JqX2WtgK0cIqaXFt4CaqgvA4p", - "heYZqkX/xjYV7HZJS6UhFfjD5h3QAeqyQ2hnP+BLz6bYCRylRf+r7gSyirQQJqXj0Ieftk7ZakOJ6DhV", - "HTVF+4kySuNvAHTvIu6FrCANLp+Rn2XVB0ayWTQvfGVUl88IksGCs1OL84dI2oKtKAeEO+v6tXt2Kuzb", - "QeDHDinwOAxuvL6n7rYcHL7BNsjIhj3OlvSaY4DcdlmwP7oWH8Y+k7avJUwlbZo2jf2yqaR4A+KnXWag", - "gfATeOMjGyQpWMr1TC+ZmFn3/OUzcgJ/teWrrDyd80JpuCkIKC+OmyCFZ5Wp8MBnYa9Gd18+q6QRonSk", - "Fba6kWwLyoXSBJvUipJHaEO/lOs7fB1p4hN1b6zWbWLYvorfNEIVRmpYkFzZj20tMQXtqX2cwrdnq4M8", - "til+sJIKo6jdO18XIrP9fbbfZ9dwBhlf8Sb9nryKrAoDLiTYPpndMYk9TO6issb1XtV33gSTGrBfwiS4", - "bkgDkSxlsadc0+rxzXTqXn8sxrfkCK8NkhwefBuvxGGc9B/VVPjrf+VSWCcZg6RKzGOx9RYsPAyBxD7Y", - "xEt5UykchU/ACc0SLPICuWQrKSydTiad0IyJlBZkJYVekntHmGTEaLLEP91/Ri4fHj58cnB4dHB4dHF4", - "+Az+7z8vTeuQ3YQKwa9ZoWixJvdSuq42jOILwVJS5vdhSPgzZubec98cVFWUUrq+vwU6r13EryLpHuc4", - "25OTzvO18tapxr7fBH9LTOdf/vPj53n7yzMq9rVWkKzQsU7knAEyUB2GrglT55NTOvEkcYiPSE0Nj/GA", - "FNVtN91XlIkZe6LrfpsLD/a4qV38arzbTtOdUJFgbbcdihNDNVvoAFPzVK8e1Hy1yxtcSO2LlOsL7Kbh", - "nFqtWMopFPprQO7Uq8G3thBsfZgDS4nvJltPtjYWTiCS/GNYWCU3qm+WxL+EJWGIa+y8cXvr+QhWK3q9", - "Z7vJVa/tbZZr7a0MGRJ7mwmMlRAXf9gFOywVbkuRtyYyl8UneBzclhLIE8E6KzWjJfjne7b2IexugSBk", - "+ErqJVajD5dtKk6f+9UqVT20u2Hd3AEcnmFDgH/3pfMBJhETnruYRLumk1f4Lx12w51s1n0ZXiA/YKn+", - "GuAe2hRUjxTH5/Ye0NIdtc7I6Xwq4gtKetYzsPD2XJkaJhJMLKR8bGZFxXpLdk3Fl8Uv+3xYg5aITr+B", - "QBRnQVSFIJbRVMQwjHpp60WSaB3WuzDXapyAHyJPRTZQQTTxtEVV3UjT9w6PZkJeymIqOmwo5BhNEpab", - "PWNLxKZQR9z5u8PvG9Xj2/EnAfwxSCfPp3dDjMUdI5dcs2FWIyJ86I9ayV4MPl0/SvaRq1o1hGplt3dC", - "gmA3Fn8mcpJsCagaKa0FRe5YCrddRhBCH+EmdIrbVm39Zut/s/W/2frfbP1vtv43W/+brf/N1v+ktv4G", - "E3dLkygw9tsBCyH7WcqhdqlZGZuf3bTzVdTQP52jXPK+3PrdwUE9lnkuMeV0HWE3tYCAjn3GjNFlIZCH", - "7JaucuBi6FEehBcU58kLUa42AvUEttsmHkN/W/PZBoL7OY1tJCrYnoaRlusBu6cidIbbQHJ2q2c+pt3Y", - "elt0ZIFfp8K0bliKIVJGwO/2OH1RRPFCTh9hmlfqpFYAJEAUxrhDj73fqug0FRB/Z1+Aql4+geG09fNY", - "SDNK/nxX+EZEbvyEqreaLuIa9r1TAnE4QbM0O8zPNGuNd8fz2lQX7NTQZPqJYKBG8mUareIqoLcXy713", - "Ec5uUijQGjfXlrqkC3Cwtmkr7HcnQzy6Hhf+P93b3rZAe2HMX1uj01viYgirCk1m+BCcHOXC2ig1zM+m", - "t4jhnmRlWsGUeFwdiJVLWToVYJlEsQKgscIp+di6DfM4cRG0A7Y7RFOmTBnlafVsEU3gn1mAwcgqvcJf", - "IE0qzwEDAXM4XedDkRnsXI7z3HYdol8e2yHCEYgnrp2G9+Wn+39Lzv8kyfm/l6Sgf81yhJjSUhNEPcql", - "LUGGycWtRFpbRjpgmKEp14AD04ltYsXd0lZU8EKPq2aaXA0+yTascpeiOQi2s3Z+UboZmcZPORhh86Js", - "b7Nvx8ZWt21GvglNeeo52GHX9QUC7Zq6cM7Ad+1UbHWXqPIZVH/+wtB6XlUmQ7T6a82ssb6Iys8dyc0O", - "LR7/UOA3pO8OHCz1zuoZJa4/C0RuGfJH5aFsXFduwObWvApSNJj1sc52x3zwK+r8tae+K+RcXrAEQU1j", - "VUBcqwAYolrSkPTeDzGssuA5253+c2y/DdH4aQehrR+bEmQ4ef2n08mbAHnAI5WBq+7SjY41P/w/Zzy9", - "bPjxgk81fc/UVBhOMMhZt16NS2T0BL8yQjRTMt6F0jzLyA0Xygw8Fa2mfCFkwdKo9Ay4tmucb/8qer6d", - "Po8R4K6LG0VZe+MPk20bj0C8QGFXblfKgrqmUN0yL1jg32Pt4cKbS2AtPX28g1LbSosF5+2jUtjmsiDY", - "z7Z8shVSyC+OWe/uLbXO1bMHD1KZqInfoasHmt6a/3cABsv9urtT3ybp7OgQ/z+AZNGGq6Nno/8dfppO", - "09++//CH0d0wMFJrMmqZBHVqvcVDRL0G5RZFJ6eiqjpZ2yCPHm60ph3RUtNsaF4ZNnKIeu5RfbVCMEVj", - "W2YZcc/g8DCOeWdOU/pbwh2jcWpDJwbLNC8oPrqD3jI1DtAiaD1jrs93VQF52sCAGQy4X+ptnh0AE/Kr", - "0sqLarHCStedeSs2bgHJ++ASE++S3pSZ0wwWVyHLxdIlTdb4HiZt9tJv23r6/XJ9yhn4QftIreqie2Jh", - "qjPv7LoLkgG6yiZkpqlNgZZ5a9NXiYWdVRYdmXaFGrPw7ru7nkVmCFy3fI0DZnIqemdyx/TXkR1CgddF", - "70WDyn3SNwe10ScObYDZR0jDC6S8eZVGGVnnetdu6jorTQHbFgBNkeb416OuIdX7R6pYiuJxMNZWCG5h", - "AalQzbmH51hBfYCOmQG391aWltEi4wygv8MqrZamyua0o6eYyG7UyBVN3i8KWZo7QF7IhCnFxaJX51nw", - "G5zBhypvC+EUBlRGzqRi6Rm26ocFswjRwZyuWCbFwpyWyRa5rpa0332BaReKBTzsz3Otqk3XovCGXJBd", - "aNUm2EUf1yVvBILjb0eiJevbS8Pnx1urjJ6G3muLyE3gazP7mjEMQa3dt4NPQ/d6ix/zMstmFu7wLkTX", - "HKAKS2ExZFIHrehk2dZH8WWZZY3G+3s5skgl+zo4FxZ0Bw9MUw/By7HGahVYcs4DsfRacfANoTsFY66o", - "oAuWzq52CAV8hW1/7AoIrKZlR3F+nLnMMnmDdZCNhOib3ivf9AsC37tbNLrNe95D093hAQ2KQNdPZiKv", - "oXyFXczN1J63Dqfy+D6zncC/GrBJEQTRBm7S1pxtIg/tDnqANnMv3EHG5wyC3hrAB1uQ6SEPVBPMZtes", - "m01WSC30DZ4krbdNs9DyHLfE2g1th/e24ui2DWD7SDzGXhxG75xtQNdtXo5WU38/3XXfWK9jxPZaLAq2", - "AGZeSfne1vsqGM0wmwcdj0F23SbSYw22L3VSDeBr7xiLZgYWzehdz7jRAihQJuvXks38g5B9QGlVU/q1", - "DF6NwnSSjTOONB79boIp7KN9EPkdWAC1GuG+InhgA7UUTtxObN15ncpsS/66WesPTRB8+LZlIY+6XRZ/", - "D8swDAdCb1VZiL3NZJnRiztIW0fcie/i3A7TZUD5DyNlH3y1hg/jj6h74GjyL4AbSKpe3vop2rUGgqPH", - "AgBvoMYBDPfTsks1BEfHBb3dQIOmt73jf9i8W6sNcZzxhXCMi4QEuZ8xL9g2sy6BnAmonZdxgVHFcJ2Q", - "hAp3jwBb+DkGW0BQUz1h4mbJkyVZMQoPVlSTG4ZV5HxCGoUkXNsbYdesWE+FzSJlzeQbay4i9C25Zyjm", - "FTY0EHgfgmJF6n+eCos8bX/fVPAacyE3VqTuYfSx66FpSu3aYdNa2Udl6u2H+9juPDv66kZv034nAbxF", - "xz66CB9VaydiKoYfiZaA97nOgy9Vb1zL3ntVlUttD4gzvfxUJtuZX8H3QWC84/+7LYvLtaa727p/BKbm", - "sM7vfP13ZHxNeLz72KLaPabCMOa6jmq2hOfgUt6AdMffulgGbzbCwwJHHm1CrfWRJlGlAWu4b795hjbE", - "6/6VJBpUmhXX+LxYYc+dXRz9JVISgQP2e+AgocIXOYCQyYxaV0m1Bi7JqEXOVNTCJ6u95pNQMDhyXmZj", - "qLtpM7JWZaZ5ntXv6Yos6TUYaxlfLHW2Jimfw7VHV1WXkWpVjxI6OzKXIqzbNno2slVqohFAzlCPbjW3", - "azdv9bYFOmynOz9ozRajrQJqkd1baulrd4frHYu885UYJTHtVlTzhGbZmnClSjSDnHlUIZKkBZ1rVApk", - "SRXJqXLRre2KjebbQPUEu+/webweR12NuOHRg/ye5QD1Ad06N5P5dEVFSTNSsGvObnZcfODkomAKXqIt", - "pzey8ByfW4OmfpGuzOnN5E2svNifIuyK7T7e2AdbbD172UDPy3G4rDvuxbPYvaS9FwNXWXVkVkwvZQo5", - "8UDPVNQ2Wt+NdIZt49qrPURjx9TQ2mHoWW3kzVqtTcm7rZl/zkRqj/BnZbpiIu1RdXfBbDOkx8SPJfql", - "ZRAQEQiER/0SAQUQ3upCycAVSUs2IX/nekmUXAX3aJmVqDe4/qOCcj1TEZTYCgRHa4YNEYK0baVA9reF", - "qn2z09bYdNuMnopB/ow+ETOub4SBfpL26WnfPdvM3fUiusV0Bt5F+yayxRYI/TTDE2EH2wz2EM7u6CnC", - "+miCeHH3JGHsjjzP1i5+wO4WpLyyIsGIZcIc2nSjQn4B31X2DA5bBSdbiYm5zS3QDZrngMxH7OEfTwVE", - "HdhkEm/WYS+WprHrroICI9ecukYX9DZuHTExl0XSmFM8NQG/3GEuf6/TuWSVqazWSrMVAooIqdFYCf1j", - "/hYBkRey1M3xJ1NhKQOBZESxs8iN2DYUqDEspmOn4wnNc4d5o0KwqKlY0mtmc9symQTTBNcbwuLklKct", - "xIZtzKnQvRkzpVAEfPHVWk8a71qfslhr7bF9aAyl1eVwpByGDqyrrVWawvOQstdDr/shuemGri0YAVjZ", - "Nos0aH3b+ImJSCmleSFXe4t+wcH97RcKTLVJj9NctzAeHj585OD/jp7B/00OD4/+s5bPRgtEOJX7CyUV", - "6Ubyu/g6iPgXIm3tNFgKmE50n0kxz3iiXxTFoMRRqhg2MSq7qec05eAFqWh3w6CfRGl3b66+eC/F4pku", - "aMKeHT189PjJ0+++/+GwHkrhP358+EMldrqGcT656leX+QT/C70yBalPjw9/iL25vAP+KP0jVVx9+dLK", - "UfqZBJYshS7W8eysX07PX5NHR0+fHhxVCWg3NzcTruREFosHXMkD+D3BbjALbbLUq+w+oVm+pAcPif1t", - "KiAb26Fv6ht5kDGtIesLPrAYJZAGkykZqGx07olrJrgrWV1tj7fnjaiuWkzXw1rW2y/HB//57reHmPLW", - "vHoh/OtxmkphCzkMleCm6UYM2OFhzT6GePvo5iSIhKJpemCNgEhI85eA/GEly0BkBWD3qW3bA64QflLn", - "iZqQE3TgTkeKi0XGpiMiCzIdORfrdFRLut1Db/sFYzwGAFDImFRsxQ8wpIYgb/FlN8jot5mW63BbkNPw", - "k6kIANE8VCG5ROSlyyboIfYBBobpAwd3gcgVwCHWZQ05+VVjr0AhzIQWqYp7hHxFQdU+gkNUgy98Hxjr", - "b3zfLRSkvirB9SNWC/4JZhNVECDOfFwroDrsJh7rfWyUk+Z6tEPgLXR+nOc+xlF1Y65kNjfZbn+4GXLV", - "xLCYoJj0r1MdrwT2vQYeAeyd3ncQ9f5/fsH7dR4/YxdkfIcknDNa6K4AdiAeE/yEpokmXKBDMyxg4EaO", - "bhMjOh0kpCHzJoxP2+WhdEMiWCuArXpHsRR1iQTPwIDIMZ63aqN3ywJvse4mBnzzjRLAh6XP9nYv3TY0", - "E06xIQ6imCu/eiKVJldAPRTgdhRGkH659mC+VXx9AL8Ku819oZgG7Xsp5M2lx7gFFxSInzmneiA0yxbm", - "oum1YTP64GA/0YlTeXsr/mq6Bh3pB7MktAs5VPO2NPRsS8h5PU7/USrIz91xdzZ62aym9gbS8GdbVB6T", - "d31S906ZkDtcGeyuX9SoUJNvqmpnVRWXvoHpZffOpj0NG+NjtjN08G0nfxk7ec4z8/HAhXyJrSqRiayF", - "OUb8uBhoH7mf/MRXXLd6qABueeJyS5XVaf7f4JnxEUv2uaTWSxgNhZFka9e65rP5ZcRFXuqZlu+ZMEaH", - "LHXw73dbXpMaQJ6t21DrUM1LCMEKnvOH7UGY60vs5JV9VW1tRfu7CwYIN+Pk6zW684LLgut17TXu6LD1", - "mlnQm4NU3gjiGtQZQH6SN6xwJbvgNWvJF+b+5L6fhKEEXOijp0isOXBmxMNDX5Q+pNRXQhiP8rJIdgA9", - "P7PNgF8uSkKzYqUaUzhDWxHf3Sixm6qyxzHtW03Fvfp+c7UMLoUU7PJ+RABfU57RK55xvZ7lMuO7yEm0", - "X4KezrCjemldKWYOgGHUNtCFLmTmyjx5qKJEmisS9mwDRBIpVLnK7WtnPeHgMhjjckfhv0HqnzQkfu6X", - "sNI4OStmpeDGilR6BhbtrirOMe9ocjiK3WrsxSBnhROuZmDvffPv31FaLULnZYReACE8nDw5xAtqqFTN", - "L384OjycHB4i1CbC2rhwMvPrE/PjhBgNiWg3rlzQAuwBo06oIIeuEkf9ikMOx4b+qbis7+V/hz1MuFCa", - "0bS19keTw66ibMk6au98RHRFYOMMy/l0uhTPtZnDS1mQS/usb2EoHRDhpT/oyAE1joRseHiZoJ6JloQJ", - "VRaGs0XBEk0Kds0EpCUmciE41hbCWhytWjF21zUUbQ0dGFEmoOaMXlL9R1sxhaGaX2TyCkwaH2ZiGsLW", - "QNzVDjO1oSsH2q3u3MJbz46ma62Pzc8q9nI80JbE3jeahs/bFmF1aR2sTOMq3buhmgOQUx0CF5FluaLi", - "oGA0BUEcOvsrF9RU6I7+xkSVyZJQRaajt+fkucwyWrinihdlIfHRY6hXbr26kll8VvjbxnnFJ2JdIbYH", - "nFZsKn+YjuBE+ynhhP7rf/4v+4OZGkxshztbF9ql2+4O3We3jW4DfLauHpmmBVPDnePHtl2/X9H23qxV", - "NyFvnVkP0G4irRJEY6UL/WCfQO9HaLSzGfcT+4U9hG5RvCBab/ArvlSsaLGesZWNPImipZhPCHzSuTdH", - "NbwUaPAC+owl+wNoAdWIILpLcrc7sJCufhx01N6prsSAlsSNyIwBAagqQImL7vRhfg4A+drW4DWiJpwg", - "jEpqw3a//HXLLIsJtZvIcoBSmyTW13GmPvIswXJuv4ks716ZVpuAWKDrqiiEQ/1q14SA84jACRARypOl", - "3V5c1YvwNqsAjJs9K001T8IdB6RWIBpfUBEUd08afITtIrwVXJubW4T9fnfmrDiAexxcjOqVxI2+IdMR", - "5klYM4O60sthuzGRxVRMR1m2mo7Mkc+kfE/KHDv1FaJ++ukV/iWlmprlrNYUt8KikGV+cLWG+4U9aDXh", - "4AbcTSjYTbmLSMBNstHHbCFtBold6Po4aNnxoF994WtHlap6ZQIOfile4JSvmFBcih5H8G+RZjVSf6Yr", - "lpL/fv765zOql4Td5pBlJwVcwtmtNiTZK64sc6NarOfN7zhUM2a7wZz+ytbKOwhsPI99FVdcaUgTwsA+", - "ga4R+LUUKStUIgvW4IP3+Pqp/GHiy9U0tyCQMuvOyUZS3cpaMGSHhRwsfj08MC/kKtejjbIEelezvUZA", - "wwuy4i6YCo+wvfE4+nFckCTzMgNH/HueE5ml/qdWsZUxYMovudKy4AnN7JfgoHcg0ZPR76gaFuzqmUuB", - "atMTOSLNE4K+MX8uuFhg8VNg7R8VHBEvddc+Etx/Z9vLgqhyNSb0ejEmKw61aVOyMpeQaocqW+MAwuLM", - "NZVORXj5te8oOS2s69B9651UFjorQXztqudxnfi6w8/dsDGHB9pORU1qOj54VjbKn1TH6g8T/3izw33a", - "1vkKRHrt+HcrqLOMio+I0PXNNysq89XAWNRN1pyLloxgtkLZ6rCuF3z6pbxYFnI1MxTOqmKyeyok/r5R", - "7BurzjaCbizf8AVCNZ4gnB+9hndr2lf97QaWejv7taSA0BZXR/ZNyp/iOQYUhRS7c2xJrDKDsUr5S2MT", - "YqTwgQvQdLHEGMg15yxL/fmVK67BhjfHF2KKW82mAh5t7JdjUoqMr7jZam4yLaKsS6x6UPNorLe+0Sj2", - "zvblhljg4W1v3H65srtI2dpzl9DU18Tb6gTZXOrnHmuy13Vnu7daKMQGKRUqF65aoubHeuPRnSOvh7kJ", - "TWK+TIfcZ47UR2nxMXH6IAvjUfru06n4F4vShyPfEaFf6QZlMy19gWYoyURXub3L1/JoybFVUOqG62Q5", - "FTJJykLZW5HP/wPgqEbBhgk51iRjFO5Qrro6Vy7NNx2aG2DEzplTbisuTrFtIL/PqjlGCibnhZwZmSIW", - "s21zx12ke17IA2wKCZDYOgg+bhzps+pzN1I0HbnTTAweHpty1K9yt2T3pQl3Ee628Ta5Cl9t6ezfhY/2", - "y7VVtix5jEEOP9KMblNTN6J9MXzgCjsgV+va+3U0DinbS8S3L1cWXGwxbIilpOCLpSZC3kzIc1bwawcb", - "nmSMFizFaAeF6DaITrMGOZLxBcfoJguJbXiMCDVFmbEGxtURhMDsp8RMVzhqq2sL97Z3FkLM3JXZlC6+", - "9aoExgqpyZrpkL8TcoreIGU5ORX0hnKQxS7CDVgNe0IW9imBzEt4DKjSFhwsdZjVHudpV8xPxZBxsL/e", - "NcvauQ066jwCEOfz5Wd1V7R+prxuIOCioEJROBgfy66TslDmun2nDAvo3ZVtSOduPLOb9bgKhB/w/iEF", - "07RY+8A8YaxHF1PdI2z9YFsJh7rM2v5K1lWJrjcor9ZFxJAuGHM5/L+cnr9+/PDou26cAPPrgRsuBAqY", - "itrVsEIICPuvfdIFEjAVPSgBzxtVYWva+lEEJuBRB0yApeTLl0HBXfozCKDqHEYw2qBnCyhH4fWpNeWc", - "Ltj2h91wskUjdNFP3JkdpZE/wQsVyfV9++bUhWvAFwQGCOLVc6qXo2j20obuoAbEtr0Jdtvfm/mgqzdR", - "Zta2s6Uy2kE57JrLUvWO4D7aeRTF/xkRKfaWxlLol8BHwSk+OvQ9obOiteK2BXAomEp8D2DAzVdwjqvq", - "fp/jHDcrF+4Y3VjV/W9xBeu+bC7b1i6DEqPYP8q28WzevDx59OjRD5WS0lJmasKZnoOeMvroQTFPzEf3", - "CW5qs6DG/j2A4gfWX8fFVLy9ONka6cmfD99T4CGxVBFD+MGF/a15YNysXnKWpZgNhlUR1oPeqccbFq+R", - "gf3rXt7C/wbPkHhHy9aE/VrSTJEFv2aCvHl5cgCzr7hdJWZzQYDLH8ajhd4jKQDjHWQ/QIjEQHLYHdIj", - "C2SSE7fDaMv2zKqMKbUrn7J986ki5mOYFEEN68q4lOG0zfEFOXDPjXPfPtLBu/mEHGcZqc6QsVOnQlon", - "2v/mcjsIu6VwEqRgVeqlA45f5bTgqo7Y5DhD4PgTe/7Ho9uDhTywM7GJpRP80fMy+OiAr4yxjNaVMXtH", - "C66X5RWgqcmcCYhQ4bL67wc05w+uHz1wSauGcbEQ5JaojXyEjx9bvnvQqhq3uUmJqXCJOB4WIRS9h0c/", - "UPb4cH7w+OGT7w++mx89Ofjh8Q9HB98/fjh//JB+lz6lyWZ/nS/7bkdyxJO/xgun2ijCwUCPCc1tch6x", - "oerwnO1jwogEnFBApKFu00QqaH/pFZy/1SLejH22l9q134KcvwU5/y6DnP9Vazd2hWnbJTXL+T9KVqzf", - "MGVRyQYoIGyEr9TuTMCC/Gq67L60dkD5mJ9JIW+2f8ZszcIW72tcbvcWi3seIhGbSXLculximOyeMINf", - "VHjBrUFit+6tFnhwgctjsxYuLLoYuNTD5MwmnKdVXgIAixnQusXvocD+f/8f4sXG/Qn5ucwyhBtwIRgW", - "K8E/FU2Fz9YGQzyRqyvnQ5TzynSCTbjR+/TpApyCudvUAx3NdXsOfycrpoA/CL0Q8M3wA8ros9s8o1wg", - "yv66GiOBqHLDsyuAolMyu64VHtpz7gHEt/uOghBqo7erwsXymhUTcmnz2GxOvct1m/H0Eq9IRroW1yxt", - "LGQbweXOAMrhVndVJu+Z7p/M3YGMDyIBztG+jmo9I7EKZQ+gz1siDAkYo8ioRelU0OW1vdYj7hp24lB1", - "5iPhJKHWhmiZjiEQUdPZvwGQqZ+zIKbxzn0OZ+UVzU81a2MKeI9Cs7BHcIzsTrCpSmArhpSAA7xmsAZt", - "3TwibN7plhFBUn5eIxAm4vjsAgq5CjldJ3Z7H67dF1+ub95d/T+LT97n7tqND9tttwzeT+aVfymLK56m", - "TNxxyQI/zr5qFjyK1yyojTOoaMGjrqIFf2a6FuZ1Rgu6UoGvfyhcHJE2/NvI8gXCxBLaiAX7dAj1lqi+", - "ULQobNufpWB3vGvMEHvaMEeH8Q3jhhiyV44Ou/ZKMzEgXrsBrrHum+rVK5WJmqR8wWEU57xQ5u/lyt1y", - "H5gPzJcPfjg8PDx6/P33B0ePHnh58aCYcSVnZoRZakeYoc99stSr+y6jrVlu8j/ipeKC6Iuze396Np2m", - "/w3+Z2L+6/6f/uP+nyJ/fRX969+jf30Of72I/PKXAX2f3//T/T/9IVBsLS7HDO5Tm4/34ppB7NoXGYgF", - "KpqLRY3YzxCFdSquacZTEH6GpJOl5FuquIYYg4YqZEAzVr7uqmlMFVxvv5bMfm5drfDaUz+/1pvT0VlQ", - "N4BRhUe1agtvIo49+JS0VVdlFnFNcmQdyR3vFIbDBgUo4X/fbTECyoQ6sVcyXW8s6xjMQcFxAFrHfjm2", - "WfPnLGciZULvsOypa9tc+aZX4Pe3+J41MxgL1mJLruxzY+B+8PsjWLBt9oZ9bnEu80F74yPWz0OQBo2/", - "j6VFxhYaMjiFtNHbK1kwfML+PngauNOVX9HbWYYcw9xWPBfw359HHDh+brXkmJ76yZfcZcXuvORYrtEl", - "fn261eYiWG0uZsaU0zZXf5bJG1YkVDH77zLPa/9GrD33td8oXHymjWJXYZuNcq6pSGmRfro9cgdivTcf", - "GCf8BhZ8j9zehrlqm70YPgFtV264cw03VRXulxKDW9fUytDWgZE6tGnd1oHLXT2fc7NZUtsVuwgMvzPG", - "I65mbiiuZldUsaeP7X/bZE34R0o1m9k4Rq5mThjCP4xJ4f4LonThv+3Ggv+2mxL+uyy5HXf+ayocBQKm", - "+l7IG1HhuhjOKMXFYla908P3EM0ASkUnS6ZmBVuwWyh7BVO3g7pUgZlg+kYW72c1wO1/SsFmGVe66+uE", - "p8XsKpPJ++YXLkLHjBtcAXexrn766dWJVPqVTFk28GL400+vCLaLe/LqX59ipBW30BVLY5akLBsTNllM", - "xmQ6WuT64PF0ZP4zyWiZsoNHB08OlBSCaVsWbztc25+DQInGGH8+u3BjnMAY5NHkCTnvHqPzMT0mwEJe", - "nuG74tDMSfk+eJPEkgYQv2DnkTIhV/YanoND/D0TEYcaTZZsZtZ+lrMCyxzsJTHQ9EtMv0Ajq2gg996e", - "P7+PqOsw+E3BNbuL0aHjnuGx0sNeBz41XfYMaatJ7HXM19Bnz6CoSI1s2uu4b1y3RPZT0DwZDbZHuNJz", - "ZF5fs6LgKcMU+oGHBpcHygNAhCAWJWfFgTmoKqeJ2y7SjjIhbzEoNEd0AZClYzxjUwHwcxVk9NwcQdeS", - "0Mzs/jVht1zpqjoKxgg0uiJUpFWuWa1Al429aXWfSoZxCNB/rYmN3dmH93xbtGPIjgOsuv0XRgP4eXi9", - "85N3eEtVkbP62Ht6BI+MzG5zXjCs2ANLN4tpsBMqpAD4O1xe7jVaVDlhR3EV9Zc6ojr2Zz6N9pQHumSr", - "2ccUUeSFtaZsMCkOkTpgF0fS6OwvD66ZSGVdj2/Wnb7fgMfV3GoP+o391iM4zOwGx0OLKiQQBUPBElmk", - "4yrsDkPFbaRLJfssRItLsrUCAwINgz9/svjpExcQ7QMHJ/sBHRgiIMg97F8DUOcNXSPM//Pp6H6UmjuV", - "JbicEUHSS8jeBQuS4aQKeY3oaBhk5XB/INCmYl0/rXuIp7Aqry60WgOt/D1gsKDpCvVx0qGNWPHpxFp0", - "9ErMDRreScHI0O6nlmRsjV75UQaOzRN2jm2jGxAcvX4HJuYmZI5ZlIY9RzL/FIQm9wmk2JWqqRu6FINl", - "W0uKdIc2b9Id534hOq6rUJaqYO4iFmiNGncrx7coqaEfs4aC8Vt37rNwBw67dp9V/Nrl5l0Zqu5iLHMm", - "KMebMRV6WcicJzvfutv9v86ZOD7F/o97+x924/ZZJV2RdEHyw9NHzdyHEIKBHvzz8OAHAGI4+nCv+ufB", - "ZPbu/x/8+t/se3x/tCoSRpSWBfOYAxAWLVwofwhQ5CsYYkwdXGH8hxkAYReIsshokSzh96SQSvnO1rnR", - "NC1IbTkn6JgnRwdPHwXvAYgTbGF8MDAVAuqmEHyCC/VeCsESjf9YMbW0fzYrN8ZqN7PpaDIVdeRtJq5H", - "z0aaYb5EI6LwSRBRaFcvtq5caYC4VfuNSTKstDVnDmzIb/dlqk8OYuRlkBv94paGoY+bFHSYVb1dPlVr", - "xPAoDm5YBRLtMssPHUt2AmXg7mjNsMZcZM2quWynw7pm1Rk/hgOTqzXBoSDr6twDwbgQKkIL9sz8dEAu", - "rTq6hH9YkEz47zkXNMP/tNmKl7YSn8fQpVlW65MUTJeFYClhtwnL0dXhW096lgMrn9/ZgtjCfbE12X/9", - "cLcYflCzHu2C4n3sqDCy7oojQc089Qk8NfUARwteV49vHA8+Hm1EsXPsYfvx7THZtBQB+tbdLogOBvpc", - "4achDa01cjGaO6xQwMQLqHQxkA4zdN9KIZn8zoSI77+9MLtxxfJ1AzP8sFvxANOHXgiwXFZM6OMkYUq5", - "iMrnNu5xiBVvjDpfg4tVPRMKXfsoSxJHq+rOkURzcd7RZ5npwfCvsXmXmbavEN0xbVsnIYZMvrN9Zrvv", - "BkvPCznnGZt9HRYcwMzvOmqrEN7gHlpV7WY25W5HmrrOHkQF39GeqNdciWoGnzc4zP9Wm1qXDLJFdGz9", - "vSCBzIuF0+eTodlUEdZuHt+NY/mxk0dohylD/mFVFOqGKr8kk9EOTrKd5m6BFNBSksVnnT0SgLTgabrr", - "ybtyj5BCsmJ3PnFbU4uv2A52z05T3KDbfeLfXQgYm5gYkSy7Cm6Ip9pNQ+2oaboYFzpR70g+1/2te7Hc", - "B2yhwEa3OLFsspiQP6GL7hf327tf2K/v/v3t+fPm4/FdEIQPxafPG7S4YZEWCKRqv0DfHT3wcB2jyPzw", - "7pdECk25UEDZaKenl2FU+QfYOk3uz8gl9HjfsZqp9EudFPwjEmIfCjoPGuRJ3dEJw/DMTvG0d37YcNCr", - "NXnP8OZ7Z7uzGgrjKjr5e5bRu3I/GBv9TpzM/yL+4vOwZtTdLEGtLNVGC3+gSt2pEVzcdm+5y9L7fbP/", - "ZXzFhi/XsYVzgLyFGvYXPophhSRFlvKGaEkgyBqeqzwuSXBjCx6easV+R6psvAsDYO7jDsDcBoWnBMMI", - "3lrQkTqEjY2SGP1h4l6rW9Vmw+KyVU1Ys+yjw6M/P33yn989eXL88u/Hf/3Li6OHP//H4cn/+OHlXywQ", - "17MR1rqcaanhLRmPLUY2KHJh/xq+3/dNrVmstKql+eHLLJf8DWbyq4eZ/FZu+lu56bsvN/21gJl+IcCe", - "Xzpy5be62l9NXe3tUUUHlt1uGRNRWbmlLVGF5Vlj0BYhCrkO9cEWNuEY89PNAYfwpVjwHhD45eKEoT3+", - "WVDCYOgAnU7tdIurw9U5eL0upNitzIxPjaaHxMLh7AGinAqwNmxxinvTEfsV4+u4mI7uB7j8qPh89mcX", - "TF99OT70LtCfCyrKjBadxcYX1Qc1tEgwtED0QHUAB8RkSXQK3FgtDqgIgFRXVIen8ezi6NVobP7HXHnO", - "jp7D//9V93mz2MO7lFQ9DndQWFE1MN7QKqrVUzl8Bv9n7k+LkFmWWsMMyOAdPRu9vThB9Mmgh4dBDx/6", - "ACC3v2HVTlZ3+Yjm9rQn506xTBGyE/7T4aN7RGIMkP7QYOPwmYdbtoMk/k8WgTYFluAFISBQaNkB2z4V", - "fg4NHFRbb1nzgoVoztD37Go9q0ujfvjakCQblkGu1rV9+cuo5l14FwRtxNBiXAb/4WFb+AfbNSi6bHdu", - "m1APBAvFvQLzFNhq+iHUFbJO3RXl9PjnY5QK/2k+eG7B1qcCYOBcgT4qKFQ+Mj0dmJ7U/Qm5qHUdlOdI", - "zfKvXLls2HOYoBlHsVVdSPxvL07gO+jfJ2GqDrziu0Hb7TskWk42ieydkNdf1USf6aAh+dC2+KWpSWtu", - "0X6HlfOFwavTgS6LKzkKMGvyMsBR7pKw3bLTXglGz0ZHDyePHj95CnzetbcP20dR4RKB4wD3FMLOG6Hg", - "IMLHEKO/yvWawEHD8uoYqrt1iFWwwHcMSr+b1P58Z2GryLE6+/YEXN8wOcPj8tWckt0s5W8Y7F80Brtd", - "5f1gsAcDYC2x1qnD4QbhqztQTwTz3EFZQbl18ITOZZbJG5eJfZLJEiFClc+0brtDK4leO3ASL46r3Bg9", - "f2FZJsfkRhZZ+v+DaYH/o2Y4+RMJJ/tJcnQ4pyk7OEp+YAeP06fJwfcPv3tykDx5mDx6+t2jo/RRUiUn", - "PhuZbc0TdmD9I4bca1YonOXR5HAUhHd5IXIALhUMwuqr7Fh/UurUaB0nPHqkkd85XWeSphPiXgjGhM+J", - "9eYRrgP3038/f/0zkTZ0rLP8RbUrDFGJFJoJHfd/n+CP6MuxJyNccdC9tuLda3Nrro7KdGSuO3YzPPiH", - "kmI6gvpM1GwfZ7n/5eLiLLyBNtuYzVw5xVq/blHiw5CIB683mRTsWPjMvnWamdF0yQrzo5yEaMVlwVtu", - "uY109GaAqupRpO4G3HKLb/Awq83JtIiqIDS7hZLlWFTL2FGwB5c0z5lo+igb5ynkz0EIzLWJuvAchtcg", - "PJKRaxB+HNuQNRFkZ1G9N5U2J6qaAg6xicAq5rNZrMX868ptH/zMkYVDWjPGsbb2W17ItExYMRX3fPp/", - "WsUm3a+TWhdIG0jeLWg0ppH8C4KcV0AJMrGxMqzaGuSVkUN4ZMwd8c3LE/Lo0aMftq6Nu/EIdcsoyoUi", - "VhLZB9Qrp6Gc7EKeFwxKwzkvjCw4liAXi6moZtXgvFxN7L8mSq4Y9LSLY96nyYdb3rasttm7RrkMM5EX", - "dshOxV5H6x4MvOJfNFZ1ZQ+5x/hjs0p7oNzd1nSZ7n02t3vz9N9+Ei0+wyePHdR4Lfi+r2UQpR757CF+", - "9qEr0GlI7mGzEHdXGSqbrcBr8ihSTdF/OqmtzgBPoLcs46TYU5Z5mRgkE3xUckPfA7i53fRkMsDvXCsj", - "hRMGaJJ4CXGB/rsnHexAFY7mtIUriOguFzzFsgqsKGTR4cSsPiP4mdM19ZfWYQ6QpmD5mx/EFdXozyxz", - "kjJc5JC1gahz4wwUdU2Khkk+6KLNuvaDlkuoYmqIEX/svyNVB5MYBrBlwnE1TIQBLm87AuZDkyUXCAEJ", - "yGVh6bn/j71v4W0jR/L/KoTxByZzq4eTyd7OZrE4ePKYze1k4pskM7iNDJvupiReWmQv2e1YCfLd/2Cx", - "2M3uZkstWw/bEjDAOGq+WVUsFn9VBXNa1Cv4yYYipdkkdOEup/mMirLDAGppab9vsP1lZ2dkx+eGE7rf", - "/iqzVzIX8YbTw/wqzf03F/G6kgo9DeeIMf28cv2slFToaVuiGGd0aAaIQURVgRDRRu+n6pJniqq5uWlG", - "HPRtxEhUs7SMRv3/+njc/+vZnx6NRgP7V0solrdqQgX/Apz2wmr57+m1ob5Vn6T9lvoJu2IJwWsDyei1", - "pf7iBoJxIYzQsYp6vaiGlzlr4yzDxaH7qVPdXVBJc4WVXvcDG/THLJA5VPJMzmjGI5okc09f9ipAfLHW", - "oJHrhVhWtHcHoAwHowMv9HOIFXCe0esVg0TgPi7SSV7UNwgjg1YjMxQyyftQVLFcdyUhAtUWR1n06Y/w", - "tfuxMrw1g7kqG+hBtTrE72quU9surxal65RO2BsWep8pbmKInjHEbt+4vJDjoACZa5nMaFJAtMZotqq+", - "1FR5A4OI+5KwvHYVEcav+zpl9BOjet7PmFJ0LNWsbzFWZZg3/qUqUj2kxmotWSh4tambtVXbv6IqjNV1", - "1LIhHjqosSt2Qa3k8zaGI/7DXkGrK53iqb8Ek8SCcKTUndHIJ9Xh1cffcZlPEyog8NSqYC5Xr3684R3I", - "rMQlwjkp+AVZhwaBoah6IP6VhKNgJNAsZqNUAbameHUEQZHmKppSbZNgctdkQJ0sptJJQMAMqlkeW94O", - "YGSNGx5sPQ6kUDWh6AHW/yBg/WMlZ+fghpQa8uu+ThUAdZCkPrECaQbsAR1YHG9pXkW6cwFew0zhU98r", - "U79sb32g8VUh4DN6ff7vnMJet92t7MaURxVQjT9vhyfGicZlzmTDdOSVVCOhuZgkrO8uDYUQsZlyOUvi", - "MjigjThmkYqzPMl4o5oRRUyUsclykfAZNwzvJtMY1MDLoQMHp7uF0eui0lEoq9EBJd8dJb/MUvMLBgEK", - "mhw62WVO4dEge04zmshJwCDTdtv+vd7l0RLjTTcsuT3KmiIoqKm40/ju4rRLRWMnWG3T/d1dHIw7ZQa5", - "o+VRPLrDycArwe93tECLpMNqa9QQGBjAAcJ3g3GMxSG1hmudswdqQvWSu9mUUucYSwYfmFY1sRYZ55oD", - "SqnR3O0zJRSr9g9yVw9TJYeKZiyiKtZDwMwMcUj/XDiiV5j4bWNWXy+HnrOausA7GGhiDaZhl76ug4m4", - "4VGyMizR2jKsl4DLOWG9ygrSHJC3KVM0M9xiroezPMvBFMiuoyTX/Ir1wJl1JKRgRGJZeJVDWAzNCMVA", - "TA0OEqHsJ3J2CV75XoDvGAep3QNfIifgsHny64vOikZzvWp49kX56YDVrDWoxVPMrRhx5aoTQOhbyGP2", - "38taRNedju1xsaw9rgns1jjQZFVxW4b/X7hgouuKFdmIsELXmYrlS1cmOjJr2LnhTmtomt3GOkp1Sy55", - "+9uWmKR8/LHSidg2CIYW6SLEnFvc7WWZIGbGBKxWKNZmNF0u2kaiJtvIQbTdEdFms6EtbRNKeQ24BJ8H", - "4XgQjndPOL6hKTF1FkjJ31iUK1P4FPxZVhSORW3nDmNXQBAqoilISngg4CJj6oomIWFmyq3HTAXWpj4g", - "hrD7TEKcfTS41YZaD0OyCOnmLkzYLAygd+Sm1X34r9+9/fE/jx+/QJ/jFjuya7fwTfadkYnni1yM/RSc", - "kcvnVqzvVyvaQuxx/XqAO+HN6ixILqURvMEcJ2ABh3gSGJjGjyTh+UQihHcOOb9d9Fp/Pu5XvCr6GXCe", - "Ls+Ac/anR//17Lz4x/f/8f+8xXEzIPbO15AQ7vsbKuiExT/NlyRW4tGU2PiHZAZVtD+rkRiJ30EuubQa", - "NrvSxTPwGHXlzOLY2jGxBZI5eYTJHWMmzC1Q5oqcnL42i6j09wNozHa8oDEM1GvLYR0vnFyHml7pRUmi", - "AElaLtJZYMHLlkPr/k6qDIRX+AS4oDq6IDofj/k1HKTusYhWgSpaqoxIFWNsNh0xEXMxGdgQKRemYb8Z", - "R5EWymII0pSwdWwzg5F4kycZTxNmGy9tK2RG5/BuUJxAnEI4uNmMEs1SqsBilnCdDUaiCPwiJNrMsXpz", - "DDq/7JdH3iM2eUa+G0s5uKQKxvfd97WMRZ7RGQp49F6ua2jRG4ESQSbPUZTVyy85G2r4nFYtBBiiqvHZ", - "7LMoLiw2/dE4//JlbkPnfd9ZB7RtmzJRVoamCHexkiJoUyOqnPVKM1PxDOVcjB4JKfoiT5Lv/2YRTXZl", - "mjVGgl5iDVM6rFFOsrb5cU0msOPKyFbRuoQJu+aRnCiaTnmE8ThYeDEnGevam1ROrZPdeh6JhV0ni+aZ", - "MK3XNslk4STLrlae4eJuRTulBhTljoQq2xnsN8SxwIucdVmiGQF+6rtQlMVTNYirfszcq2g6VZCbyN4H", - "RgIvvhivyXdeOjHa50sRSZCw0M4L18xCLbw5l9AChWfBrmmUkTs4iwCWtC3AiQwQsxUPlrYu54TxbMoU", - "zlYq4gnDATlJkiL+F8cMW+5A/Js7jmxdtDF4xwuuFkbmGQCsaCL7OHa8ygwqdxGvSJ/PUqkyC30yGtjR", - "hGfT/BIwtTJlwnrFyPLvIU358OqHoQsZ8y107tjwrOs7fDZyNGyGjQ+kXyf9cppA6qRK6SNxC1IvtCJn", - "PTQ9Y+xlS4PL2aFRbk084enPN8HvWexeCaxBY0Rdga/dv9ecx7orVgR2hsbgFlmJZ+DfBxuoEbrWZNc3", - "GasX9mDxSLePWqxv9AG9+ADRi7tB/t0NWNti7GEB5sORWE4xBwgk9H9s46ECspDUIYJteL//WYT1cx1u", - "m1ytySmVHF3mnYdksQCfqYbINDK5wlhEm8+cvn6M4K0Qdh5I09+mXuW8C9k3G4fw3UVQNfWFncCo/GHc", - "eTieP9jdLBf6Vd35lcJx7nSRSuezpsS3JUrPxeasu+UnCUF5uwzJIQl2PCwo2xiG+ZU8+iD4FVMa3hI+", - "2PeYX3ybFXx4J1UG+LTiUUPVgqksDArnP74c9/9y9vG4/9eT/j/++59vfj3tv/+9/6+zr0/+/M1/f4ER", - "B073erKYii1g+XLdxDywohq1mjUB9sBFJStsB2vostXUUOtx/YYF04EzK+CbtwsWfyOzQoddXZelAdZm", - "B3YG6Ne3Miy0LyBvrNmw8EHQPJtKxb+wTTv9v7ZIX/BVNiRG7f1hHe7/j8Pu//7kVo4A8LgtAsAHUCq9", - "/PEvr42Yo8k7lmEa6ZuF8sZa5FLGc7iRgPrq4i8x7IWkdA5Jr3XRHSakt9E9rW/ySIBzcvOIuVW6/FM0", - "IJ3aIZQTbk2hb25fgn1uH3QzLCOOMHiiwdJjTtN1LzJ1sOoBsUnWLTNjNL5c8OwcsnVaSWHdwkYCrxjN", - "hS4qrLzWOL8PgmfPTf3mqhb2hJSpvunI5hGt5BqDnDRkhI/xoyNEWo/5NYur9XpEqpEYHSXJbHRkRFci", - "5SeSp7bRItVIka7UhdUB/ExMbDwrpmzE7/7l3H9+GJB3LDNtXog8SS7MX1HCKMYav8YsdsVQ/gaueDAG", - "Rq8YMYSci2hKxcSucSO4mZOlroVwnGlLOBD55mZkYyNN463Ui7JfF3uHzFR3LzPVfbRotRPxgugvNyPt", - "BQ0uJfhDuJN1hDsJb7ZmKkPb/40Sg8CTTw7N3GmJ5RTA89WypcP8XmPd98D7Qe3DL1K1/+oBeW6du0dH", - "1vg7OiJSmTMTQV2jI3/r1tHavTWwK5qxc/COC5vYzXcC32tG9q6XOlR+fjO6NVVWX3cowaLtZb7WaASu", - "klRl8GftvJamLibkC5rRG3JdtZGl/Oe0+vNCWKysLta6dLeRQtAE+OKD0dswnmUR33JKNaEk4eITi8vb", - "RjEuQtPU54aXjRL2eqb4KlwcnsM728pNBm6r1gfrGmyXtM4nW8kxT254t6i20UH2YoTmAJwQAD4Q04JX", - "MaypbTwMCrwD0vx+SjedQ+Q6tTLhnlLVmrAJBo9KbmYUZi9WVBHaxPVsN9sFy8NdHoky3JIZ5mepPo0T", - "zASyyjD/cBXDI3Xduvbhms7FpAzW50bUJnGLBfQG2SsovF3oOq7Hcd5c8AYaWsqANE3Pi4QCtxBXoTfP", - "NC0FlAv1XKAu6h/NeuAenLuFXpkSneRaHM64RmEFHRaxiw13YZYph13vVSRQvYVGvimc5U/VcouEbxmL", - "+TZbv3S/3RLTODb32dW3HestXllsvTCUu4UlH4qQRvTahk0OXRDcshWd9Y4wnPp8leDWtoZ9pjtrrpj9", - "vGCMOJve4sG6hg6Hzy0On1TxGVXzczZDm3kgiIUtQqBIK4V5G3OKFV5Cm6E4UJpO2LlzJFkpIb4zCWO3", - "H0xLJ15DTXp7Q9MUrrzS89YEoyGLMUMWgukLsYguRtaMhIHoK48nUKvSbehkaj95ighFNxM6ZUTEe3DF", - "fghx7Q4R6R5kRLqwOtklClrJxjfn4PvAvPf0UDP71mIrKhnbZVlFl3lraFB0lrq4QD5umZygdNGfeRZN", - "MdGMxreDDNPXxvYZtNBSbSJbcpKRhFFtowPYZiCfpSW9Va1UEF/OSaaq8707gMs5HjVhUqmS5wqeHc+Z", - "MJIwrhgE7NtW2CiQKtm3Vc0EsLZ3T6vFpz0ti7uempaDMBPi6Nt5rzCM34T9HByqyyVtZvWHADk5zcLs", - "eZpCkiJ4oypi0q+6sziskzTFpn1D5Al24fdAisE1t/kgPdZ4JlQIIUiUNUX0ndUag+EI8JtRXwZLU1DB", - "I8VYhraQCfsyDIENokTmMRE041cu8WuRB8osi5NJmHrJJoYu2hiJk9PXNsiPJnOZQzAEyNFitWDdw2hD", - "9rUd2u9Bu9Z5vtgQWPCERwxho3ZLj05SGk0ZeQKpnXKVIPwFM1dT+Aq5q7GqHv7y+vnLX9+97D8ZHA+m", - "2SwBVmBqpt+O39kpeBCaAmY0gGUYQsG+HPdxtp5MKpft5PT1Ue+okndqADAf0xpN+dGzox/gJ0ATToGO", - "fUATBO8zP05Y1hIlliaJD+W3AZW4FK/jo2dHCddZH1sxXbjw+q2KcVlk6MF0uRTWjf5br0FoEBYAVUIX", - "lN/LymthueRdnqZSGTWvHkeAKubCQ/D4Av7/ic3tH2Zn7V8l7P2CPMJz5Hv4UmLgL0wz64iXQMpwCSOx", - "UrwEeLpPE3h+xVOBm1X6NwYhQFI1HR/1jsp8kwux7kUQA3h/mAOJjaWaBXYDvfmW7sdReFxjB9PrNjJD", - "f3BH1KeGbDSi/Lxhxoylb0uwousfSPrJ8bELleAyidXzdj772nEkC9wVQLx1BI9/6x09taMKdVaMfvgT", - "jZ1SAFUeL69Sx+o9Pf5heaVXUl1CDBQ4M3Q+m1E1LxjfbrKRO9SoDh89uYPxXQkGeDXHyXUfgtsImjj9", - "67qfm8tZgTYyehviuWrmNGA+QgHpVj57VkWN5dC+80JBfecnGc/Xtst2HBWjxrfqYYrTqNHZ4/XSWYik", - "rKkEpdQ9pCi3xdZfcn0k9a3XPM+GX+H/r+NvltQSFopM8U6OM+uXWNpX5oTHTcqzhQrKq51yIOcAQVyI", - "Oez+qE45XeUeOik0BdrTUO5X8Ou8HyRhajxdXsNlUavRUHPH1iqbgirQzyxbQh0Tlt0F0jjelgx6mITW", - "O3r6uMNUfpaC1aiypJD1npR5gBotgrFMC9RGk1Zn3RFZrv9cDmD5Op3LW+OJwgZzYA2fNRy5bvfQH1IV", - "TfkVHPlhffPEFvD4CG/QTU7CtvZKwuONdx9UioISKmSwPVJN88uE62k7qZ7aAl1IFds6kOrDJNWCErZE", - "qmm6xDAIL69JwmJiyrbZBk0za7EMbpTK0nTfjDt2X5q0c2I+nAWIYfiVpineqduvSqJKFi3XpTTtJp9M", - "h3dZOpVwxqCIStN9EEyw77CjHakJ4Xj4PtkuYMpygPK15n3ENRVPQTb4clj4eB1t5nECzeHeQFst4vB2", - "IF2mC6+GmdA8BRXE+v7LJJGfzdy8nMXPsOJHU/Ts7xbltT4j+/NiOLs2tDtA5J6J4wqlNtkI5cyNDvKy", - "6SGSTauyWdjhbUE3qvmAvJ/CMxdymHtkBeyJodS5zBWRnwVWHAlX04fCkjRXqdRMt9r2be1+AdfdpJW/", - "QPhCnzsy9xdIUH8sISqvlrj/7wA1Ats80Q+/ur7MtSuSOutfOoDVghNI6gy89DXiqUqOeCVVbRacaQD6", - "K+YQhoXjovAagpiSMR+Dm0FGLth4zMrAaRcQsq1Nm/bG3UV/Kqd8WyWq9eQr59X15CtrXM7JmNNC+M0t", - "HGjxOegi7n40NcEP+ezvH969WONRKHX2kxlel5Owd/euMjh+rh/0CXo7jbXG22uQPktftl1vvCFJWg9D", - "5HW+bV4/2+ix68hzxyeuG0bwsHUfH8A5W5DdBo5Y62niH6HBO5grtkF8WNHJuhBiAAyrAcE8iNgBCFbc", - "fJcufP3i6yrY3Lsdr72f2Pzs77N5P77sQ7Datd17cTS7v/bagezdtbcUDk3pVOzO0Zl3wC64OcLub/LK", - "WPWy3dVlEacavCai998DuSDatIoLCaPlUDL3PftnAwYWBHd5/XXRtVzTB4jXejVzO9Xuu98Lax4Tlt2d", - "HT3eiQTYk4eHFSgFEVV1pJRmarfEsim81I2Oq90Q6wE/1YKfgmVZ61k4RGt8663Nl519V/jBylAbfqad", - "NP1wOHsmUot3G8wocEP5Gvv6+S4JatNyNhCCabcidxXaPkjgRQjWm7HEKuJ4SNO072JprcJJ/aLiA2Kp", - "llCSu2GnRrCyINInHLXywE1duImm6QY4yobSHEZTFn2SedbXGIK7A/7hI0bBfI51yTtb9+yR89aOZaQH", - "tgfId4Dx+XXR3fcjEQwNZ/vQhDYat5GZZZKwCMJNuJD/M5ZNZVwNfqgsyALnb+3IOD+EadgcpaMjzbI8", - "HR2RmYxZD0MKYSe66MKmm9Aj8ZlnUzOkaErVxGVOKPaLz2Ys5jRjydx2iQ2xuD7YIrq/i/kzzrNcVfMo", - "uu2HZXklFZlKbZpyK+gmpHtEsZgrFvmGfox3VZidP/z2C8YTYrNLFscs9urn2kZIiRLORHauWaRsVH0u", - "eMZpwr8wDHw6+D9Yt7nM1Uh4omMJZoWpviWGfp3cHoZYrmkWdq3QKooTRirerXH0JE0Xjk3nSRZUiaA4", - "Vg1Vul8W1S3KdJSZLQJzIxI9lSqjSXd57sbmxNgp1HdDBPHzQbNxDhnpC1FTkXwobVpayqQLIZJNGVcj", - "UZWGukdsBg77uRHokoqY0CiyCfJNARsqkpEp15lU88FIvBXJHGWdNqKuEcO5HlSUaxfQOZOEEl1EdTa9", - "lUdHZ7FWXfOHL9TcexxM+06KtvAIOwm49qoHMddJzBVsZ9mC6HVKO9C9lmPj3UufLQ1SzCWg8yXDd9oV", - "senoqGJl6lgWE6oJ4xAYbZzQjIwZg2xGEB2pbxMUuS7aQPYoKdy414Xz2KhIacGR4EotBDOsBCSpgEb6", - "5AKDOZ1jWD2AfMKHIny19+GugDw8EvOQHLhWl3OXPm0ZcvMCwRy2+NlHyf599ndcoJ5NHnyxRmyHHV9H", - "GGd14i+vU3Moj/MkITY+moXtFalH4yLJY40kMI2TRwmK0eQ84zN2Djx18Yxg68ClMMjvDMXRpA/ppqFU", - "WwAlBlUr67BKcD5cEzuAUPrZKkFsFPECQzmAVJeAVGtifnMovtoZBHmg9JDG/5frDCwbC9zpXT6psrRD", - "wDsk24x+YsRm0vNKaauclkfVSGBLlzShIqrL21yzfkQ108hbNoZ1JJVR2O35G1ZmodF+2fHD0F9REYTJ", - "nRRz2zE6qTaaFl20UuaBK53BOFhNllmmPK6fuZHJFjv0khpHBh16Sx3Qcpprebts5nTG2+kOP7PMEuhP", - "dhK7hoZWGAvHpNvZypXYG8/jyk2nQqvb5yibUHHJza2eezF0p7JshM1tnYvW6hvtT3cbAUO9xNK7h3WX", - "Yzlouks0XZ9O1sK5naKN+t0OyEnl36WdREP8nSSRlgqIHJNUsZTy2GmsNVV2sEQVhfYfnhYKlH4XFFAY", - "SPshCZ/3Uu2s0/yuzsjh16jciaVRZapsGlZBd8dYLbZKf373ARHZnXH2R7W8g5wy1CzLEmaujEOXZbbd", - "NoOQG0gPg4+SZX1nuJVjc765xpI5GeciZnGV6/CZ1GZJYSJOJReAodBzEU2VFPxLrZ/M9Fxtu/j4mWfT", - "kYAEnhDBh2hp3ycUu2IiN5phJCeC23AjohgLpr7iCc/mkG4THjCuU0ChtAZC9YVD342lXy7EAxUYm4Dn", - "xdXD3mUxfles5Y6xr92l2B7FDnTAO1+5LViyIQ+2L+kyRYWmYMPtdnv2KxQBFTyUnXsJpYLw2SyHgfUI", - "iCmZyAmPaAISRkG2K2x0Jq9gGfSzqgDUI4FZiHU+K38dkPf+KOzDanm9NYJMaVbrFLy3R+Jy7nzDF1sA", - "Kgtz1+wAz3OlpVrVElDZuq3ZA/ytuhtWAW9EnewCdrX31zJQY4UtSSh45rXSsW8xWt3CXfQDFR+OE5Uf", - "O+FlOdETmKcj4jawPGxqDaJiX//JmNEsV8xC4iwWzq7d3rzzemRDCrJp0rq36E1cEZ4sepjR6z4k8Vvo", - "7CfVhAr+BX7sY91+WXWDZPTW6/mF7RjTBwYfOBYU35crqb9XRXSZIldjkFRwpfSqmSeCF6kOtLKpS8eC", - "3d/RlWON5PugHYZCV5HNE3JVJtoMkMsCmk8YeKDYwi2auctI2ccmV4U7rqg12166hlfC0pdzl/K9azhF", - "LH72ETB5Tol5vD41/CWM7EZoPIBmLluHbvG9Mt6M6+W2vcRoZlKVcb7+qKQTx2GYy54uAlJDsxCj64I8", - "mkltGDkyJ/iYK519PyDQBoUaZsVZEhOuSarkFTfXTOd1RTGUWI9wGzNMe4G/BuQkTRniBv3AYyORSZyz", - "K9sj6HpmY4u5CGWunNfoliGmm1RKX+M+AqU94CtVU3sskuQWIslJzzfui2W/W76c2hUGqwr0ZKjskmbR", - "lMix44xSzhj6e57I3G6Ixmh2rf50lg0D4rWbSgFJc22dP61GN26NYJiwvC3t9mGugdY7QXBr3dSxt7Vu", - "m51QMX87bj1g2npZz+DOOmlWT8LZ6pEwpvSKkUvGRHnOguOTMr+i65K574BPAj4pyFwn8/vDjJY/VmHH", - "mpbi7r/LMzK7ki1KStHQBoNuFpf1W57Jh2zMt/TPWL4RVSWxKH+JudDPedxVT3Tl0XtjlB8f/xDxGP7P", - "1qctvrJD3LWlthjGXkXl9IRH8xb2yn1cEwgLO2sFTOH3jQb2xDntCLiEvYfoCT/d/3Ce5S7emqLCJ+bw", - "K/61JOszBpgs6G5Jzudy3MtN98UADkFBNxIUdI00tCjZ8zLKmLDsrpDF8TZl0MEjvGmOXytJpuZ22Z7z", - "uUaXxKYEypI5kSKxSdFywbNzCPlvbUzOCc/qzK3oqN1R86beCm5yoG+VmfYPe7RVDQASPA3tNaQVGgm3", - "LPsQbVhGjhdpo9CW4xTIzfIg2AXWHxbC45Ut8MZzqTPsti1iyXu4wMKgyJRqovMoYiw2cuzB8oolSSfo", - "kcrWzC9JMgP6HcorphSPl1mbUqb6hpp1SiNGUsUjRoqqLeYn10e/7CPMLbe3FPzyyxtDTKdmXPc1ZxcM", - "fs+MDL/88gblrkciTVI3xcz+rsvcsIiaW20QDXLekDUCafkt9mIHvW1zhM9QQfKDNbv3FokG/a2D/JZJ", - "2uFXoLiuNorViBVNFiFiXa6o4LgOpouNmC62SWywk0vO9EkiL2lSDsvWGRAHm7f/tqlKC+IlIFNYTPiY", - "UDFfdvTjOBrEF3zCwAGs7wHhJmpB4I0LF2JNWeUQ8KEG7oeZjFli/lV75arlhK39lsm9fPs6aG13SGsr", - "uHuzYqx6YC4w2jpwSW2E5HJOXr8oBRv4J8KHVtk2EkHhNmF12bbbc/V4awrfPl7EDVFVKWn9pO4IZ9FB", - "bcssQqJuFOJha2wA4EEnE8UmMIAK4uOkDfBxcsB7FMrSsl2poj2w9I3SrULd/ic2X59iBoyzcxc8GMWe", - "nd2FuKig0arJVVusJlC11TwCXzcK0ICR7gieAX2HqMIeAffeEOJ2r0EVodNq+BX+39WA0UI3aKlwPS/X", - "orDTg3ViI9aJVgpYCJOAWqhfB7XlO7C9x9uSAnvifriAUtBrsAW70CIIEICwG0rZFPhg9cNqa2S6f7CD", - "Noq98X2tPAG74QucoBxLhaHdIaY1y8jFSRSxNHtG6tt9QR5595jvzaVkYo0cmcqjLFcsJv/97u2vvsZf", - "aTBj19kw0lcXpmosP4tEUqv2azpjkGrNXJYoef7udwLpYnTOYeJmmCOhU8VorKeMZZhbzBSMZJLPhO6Z", - "+wbch3rFJe9irOSsRzLZI86TsHdGPjo/wnMe9woX9/NPbO79yzB274xYIHnMZ0xAUp/BYGAx5T0bUr+8", - "/WH7Fzgec3Vj1jvPAqE+T5nwSnHt7kewXd/pkbiYKJmn55fz87K/CzvPbKoYIxfF6P7DdWNd/lxHmZww", - "yJlhehwJ26U320C3JNxrC9DkoUjEIL5k6wKxijTpHTn+MJXZNZ2lie34Z7ND1qWzCMhARUzKDYOOyyNx", - "efneEZCvuSsbFslkz2eKCk9UWQKeBnrZPGU9aGEknhw/+aF//Lh//Pj98fEz+O9fvdqPj+HH48c//+ef", - "//WXP//55NUfJ//8x8vHT3793+Pn//PXV//o0WjG+lxEvZNoxshrEQ16kzTrP+1nubqUPS7SPOs9ftLo", - "7XGotydr6e3JcaO3J6Hefqj29tMP//uvx//87eSvf/z4+19O3z150Zsk8pJd936G/5HnUqWV3mSeme6e", - "mpPlV0mAHfuX89bdbSnT3NGV92e19V1tfZ7ac7BgDnTk05niYnIw7/o4qzXqBmlCRQevPSjWYs21TWzQ", - "mAsdrOsps7DpXjGl61bcxX57d8SKumQ51mfxPDUd7drgaQaxZ/ZOx1DNZ5tTJeM8yshzmtFETtYZT9x0", - "2mooNR83aic1u7zb8NtmBEGSSqi4/7ZS3MB1UVTgDBl+Nf/rDBAzq7rYgw2H3OGlGvo9mFg3YmJdM+Es", - "NMwuIooJy3ZPEcdbFToHv7WmHXft5LjY+ruIItEEvAui3IQBWDOVrXwKb5chHnSsuZvzBVLrFo/4IY3j", - "pQGvaRz3Iby01jLioD4BdI22qJrFXbKPrW+Pqe4iRjOh4sSswyH90uIAtI7MxlJt4HQIpw2NY0irBD3b", - "9ElLb0+WqO//QVFe14A6d3RnK/pvOyvg4z7lSQKaLAhy+2eB/Tcs+5I74G9sJq+Yx0BjJWetLORdBrfO", - "Qr3WtnGehzvneonYkYZHF1u8fxYE6TQWbgYBKTrCtOnupPtAmMfblt37kqorTHLbveeuTPne3feBEv8m", - "r9ira05b5769C+u+HT5crEipaMqvWDsu68QWcHYpfMBscic2tG/20j3CCDpK8OlgW2Sa5pcJ19N2Mj21", - "BZaSKTZ0INMHS6aOErZDpkqOebIsgMCl3SHiSrfYIbFYv2h0LfCWbZCeHfCeISbquxokMlyhLm5jgn2u", - "twno559q/RCzdRQROJplGRcTa4p0tTH/YqZkogkXV5JHbCQmTCDJDciJqOaUiaiwIedneZLxNGGN2ZGY", - "jblg8YCcjETtI+GaJFx8si6hnns5TdMBeT/luqLjcE0Y8BTXUxaPRJwrlwGh1vB32prTXFpbxWaUC11m", - "qWw1f9Z4aaM4kioX7BhRgvMNcF21xP2HlwQ5ZgkThqX38CvvCCEJ8edbkcyJzqNpk2cwpGiM1jRI2VzC", - "A4XMKi7YWM19SrkQyFHCg0zn2nRR/LMIymCqAaQf+HjMBU3Majv+121WzianLFeK+MEKuRnkC12RnhdC", - "W+rEGrQl3pXtP96dJNybBP2r0tZinMpS8kKD3Q4pbFMGtVuc+Duk8/3zZ6S3Ug90flms5pJExtWiG3RL", - "qHS0LvcE6kVPq3ki0CKI2h1xRKgswBr9Dt757e7a/8AfzAGLsxiLU2e9Jn9XtrZyEw9eHf0GN3RvRInj", - "D2w34WsDAwmRlv/9gQNcTIW/Lq/wXIpxwqMsfDWtkdByklxw8Ay/+v+sxvZrqvO1npdrWtXG74FevxKt", - "7olqv1F66wS8NdqHLWdTQ/httJi7/SKrwG/XS7G9G2tnDyUTsE8bB/TvihoHKQh3zUwXURGxpP3B8zl8", - "tzEcK8xG/uBJYvYiTzJzL6DEbHScwzUowmOL8LGpqZi5DoyEhPAc1bsF1sIwjxk1t4ixmRbkgIHerWE+", - "47OQHR5K3InzaDv6m92v3dgAVjoTH7YZ4Jb6G+zihs/TaErFZAHk5nkitbmoE5ULYbi2KnBEbNlR4wuI", - "FIzQKJIKYq9m0jDoSFTzh5PnmNxMs9gGV0onisZM9yDikfvbtA3v5naIgYdq+2GP2Nru1e7Z2g5k0Wm8", - "J6FJbsngsIwbZvBcuMOz7x2U7Qz/oSjfPM/9ozZgYg/3dLj4HQ65dh4oya2V0m7AExm97keymiAtcOsr", - "i23GSv5aREkee2/u9JpAf6GYNV2ucNw2eI4NHgXCRV1KmTAqtntte0+vn8t430BXxXYGKfQ9vV7ZzTJo", - "A3ZUulHcEO7gbgFDOIigQmE/3X+kkCOaW9JMi7wbfs3sQjV8EIN4G4+0lh/SRcsHvM1G8DZrooxeu0H+", - "rmz38Q4Ex55Y39dGRIi3qaNoNFM7paNNoWhucv7tgowPIWBaQsDAsqzrcDVtM3UVTnz4i4xoctQ7ylVy", - "9OxommXps+EwMT9Opc6efU2lyr4NacqHVz9AzFnFTdva3rkV3rkB13L07OjHH3/8ETY8YHnL40o3+tmw", - "PPMHkfnuujHMgTOut/PWw9b3E3bFkgLkG0kx5pNcFRd6ZNlyzV7YkjpwuXEuK5F1WSEzKuiEaRu8sefC", - "klg7XjZlXPm4e+sjUHl1u6SaxQ4jFRxM3UmmOaYi8VdMM2oaJDZxIxcTIqSaIQw5VTwyP0E4dTOQhIpJ", - "bu4kELtZExopqTVxWR/1gNh0lBBKXM9FxGLrnV+4KLBrS1NEy1xBSRETmmeyD4usZiy28c2zKZsTOlGM", - "BedY5CULgI4wdzhRLFVMMwEobdyDlF7yhGecaXJJo082tLUVzD3MmOeSbaVM9XPBM7tSy2mgyFneHNL7", - "4kJrFsbl4YpoEuUJKrvMbrXDiOtgF4Y1m607ZxNHWQGnDN0jUa4UExGHv82MzL4j3Tm8eYchOOBdcxgn", - "aaoJExBkfy5zM0Oz22Z/RYyt8i+s4vEC+QLIZ6k+jRP5GXJ4GakzMcssJnZDSpKZ64zNLMkYsWMzukK3", - "ERVARTPrph4TJqZURDCQ0seGRdK2YfrRFm0HL2w+WYBXANVAvlMlBf9iitiBAiPAoLIpV3E/pSqbG07O", - "xlLNzMLiloJV32xqjzgXHpxxzBJ+xcB5xq16j0ypiO120fnMEGwkk4RFZmHtBtnHPofKVSyh1k6iP4V3", - "ySxKYIteioxnCTNd1EjReh4RGkVMa/PL2HHRcpLwWw1hICtPlH6vmaLRJ1xaObZ75VjViD27x4OqEcs5", - "aHAR8yse5zTRprDvGqWt14YpiKLzkrloN5Z8wN+iOdng9KomtMAB5BbnRnMra297XkXPgTlBCWCZqwat", - "dJ3Zy7JqqqQZEosJdWwlc53MDR8aaeUEsJZW7s/oHNxpzHLMZizmNGPJnNAryhOXxMOmnaiegcWwbd9t", - "E9NFCsSp/AzOOpiskbn51j3zqKDJPOORJmmuUqmN4MGmcNvc+eCi1xUnnpcI0sxzKmO7VRB5n4uJacmV", - "nVWbRBuOGUyR2gQGSCBrghW2ZojjhF3zS9cAPD9GTFDFpa6vjj76dvbt/wcAAP//2EX4d4ToAwA=", + "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/tsLsxtXLF83MMMP", + "uxUPMGD2RQV04VLQMRLyuY17HJp95yOlAwgNFwXscyvilVm6sSJdaHm8zzLTg0sdxubdlYnTl9nUCcYY", + "MvnO9llnXq0raJkXcs4zNvsyLDgoqbzrqHnBV7RYz9jKIvQM7gFREYIkgplNItiRpq6zB1HBd7QnfIl+", + "KHvfk3E9G+p/q02tSwbhqCB/liwE0vNi4fT5ZCiqXIS1m8d341h+7OQR2mHKgMMIIAPmz5Bz40iYjHZw", + "ku00dwsojZaSLH7X2SMBSAuepruePI6CNogt5XKnE8e5mqF2sHt2muIG3e4BEO9CwLj0mmhO8k5iF+Kp", + "dtNQO2qaLsaFTtQ7ks91f+teLPcBWyiw0W1NRDZZTMif0UX3i/vt/S/s1/d/enf+vPl4fBcE4UPx6fMG", + "LW5YpAUCqdov0HdHDzxcxygyP7z/JZFCUy4UUDba6ellGFX+AbZOk/szcgk93nesZir9UicF/4iE2IeC", + "zoMGeVJ3dMIwPLNTPO2dHzYc9HJNrhjefO9sd1ZDYVxFJ3/PMnpX7gdjo9+Jk/lfxF98Xl56Tt7REqhw", + "iI0W/kCVulMjuLjt3nKXpff7Zv/L+JoNX65jC2sNeQu1Gij4KJayOZTyXMoboiUiHsBzlcdnD25swcOT", + "+xlHUWXjXRgKBz7uKBzYoPCUYBjBO4ttVofyt1ESo28m7rXa8uWbCfzHh/EICJzZP+eFXOUQ551CDa2/", + "PH3yH989eXL88h/Hf/vri6OH/z97b8Lcxo30D38VvKy3KvbzkJRkO7uJt7aeUmQ78W5sa2M7W7umSgJn", + "QBLrITALzMhiXP7u/0KjgcFcPCQeOliViiUNbnQ3Go3u/r391+HJP3589QsCkjzvgLuRPs9kBm/Jlm2t", + "Z4MmH/Cv4fv9vKlBmvnCqR1GCS3hWRzm+gtXcFmhDCRwHNRsdgQJ2gal3Gxtrov895iL/Vt3D7d19+G2", + "1gJ98ZZOWUz+9v7d21OaTQi7MiuCMBiSsKvMDMn63yqZp+asB1oPUmnY+yaYUGtv44iQB+/gUmgwmwrw", + "YksnVFgPaZvSS8RM6UgqVlmHQPbUBEBNUoYSoclui1dj5AyX3w6TlgTMU05w4EXLAnQrKzDP14rrAa4+", + "mgvM1WWFup5ALiA3fhTU5KNmoxwgJPVnnhKZeKsbeT0aiAqKGE0SMuE6kwr8bfE2TxVz7cb9uwTqdksA", + "zm47glf9qKouWYMsqIoCBFVxAqBs4/1OgyzwgGczWOcPYbkClEXn0y6hl+MumXJh/WWm9CpkRW1VGAeW", + "rSDLTQC4id49KVXa5Sm0ZaHbV1KhDDqHxGNhy93y4O2gnOCiiOrZJ68gC2ousoEoHa9uHfxSmoHysbDm", + "xVB+eF1gAflcG12tW1IqSmLwrE2fPC6rIdfWJQq3PFQGzVL5mMZz9yu9HGPAsY1PNwwO7ktNznswwNuL", + "l2L18Z2gpUDXAUqPvtYtrgzb42CG2lITLqVmbBtVyA4WmHMOINdAgLaBIN2PBh32X+tfx8Wg8zjAJ7YH", + "n4/+bIMrKm/Ht7kb9LOiIk+o4k1C9gMoVL5ACTULFC0QPYCS7BIx4RDdAW60FpeoCADlpjQLufH0w9Gb", + "Ttf8Y648p0cv4P9v2vntBvmXj0MKClM4Bsqb1YpKuPKHz+E/c38ah4uFozWLARG8needjx9OLApX0MKT", + "oIVv84Cwlr9hlTirHUa7Sp7IORvFdLPQZaRA7uDaIzNaB+lvlWVcfeYhybYMif/BGiDeYEnsBSEYoMhk", + "C3ztQPg5VPDg7I1CZFyxENUS2j4fzs7L0mg+jF84JHTLIMNZiS4/dUrWhbMVktBWhX9ArkGObaTc+kA9", + "IJ4ZXaiewrKadgjVaKbxSZZfH789tlLh36bACwSdHQhIA/f84ODLly99TgXtSzU+MC31TEv6sc0/WjQd", + "wJTHZvunXNgLBtCcDdBsRvPTbYjEHz+cQDlo3wdh6hbcxs2gDs5jkkz2F4nsa6U2fVMSfS57YCD5rG7x", + "qXqSlsyi8w1WzhYGr069LFdD2Qly1qR5gCfZJmHbZSdeCTrPO0dP+k+fff8nWOfrtvZteS8qu0U2PS7Q", + "lIXfNUIhhEIibJpmM5tN3KayxlzXy7pYBRu8YXDe60nt3fHCUp5j5eVbE4BvReUM2eXOcMn1NOU9Fu2t", + "xqLFXV4PFm3QAbRb5zrb3Uo4sy6pp03meY3DiosxWkJHMknkFxeJfZLI3KYI1T7Sum4OLSR6ieGkvThO", + "U6P0/MKSRHbJF6mS+P+DaYH9o6Q4eY4Ezv4+Ojoc0Zj1jqIfWe9Z/Keo98OTP3/fi75/Ej3905+fHsVP", + "oyI48XkHoQh6aB8xw71kSttZHvUPO4F7lxciPTCpWCeskgSovOaUn5RaT7RlcZoKy3NKZ4mkcZ+4F4Iu", + "4SOC1jzCs8D89Lf3794Sia5jrTDgBVWYQQH0k8ia7d8n9qO15SBnhDsOZ6+lUvLO3JoLVhl0EAUQcgj/", + "R0sx6BCuB4Ia8nGa+y8fPpyGN9BqHUPMhVGs9nUJqHMzRMt4c4NJQY+FYvjWaWZG4wlT5iOkb/fZinPF", + "a2a5heOYGwGqi0eRshlwSRJfYGHWi4NpbVYFQAEzR++XCYe3XaTBCU1TJqo2ygo/hevTCxNzLRpdyIfh", + "NciyZMM1yBZuIsiSCMJZFO9NOcZEFVOwXSwaYOHzWQWtN78NHfkgRo5D6IIuUY1xS1v6hqBiaiAe+fD/", + "uPBNelwealkgLRjy9ZxGF2VM94kSZIS+MqwgDfLGyCHLMuaO+NurE/L06dMfy7OYI0EXslC7jKJcaIKS", + "CB9Qh+6EcrLLrrliAMfprDBScYu7IcYDUcyqsvJy2sff+lpOGbR0HcO8D5MPSR5rFmR2VoENNxN5iV22", + "HuzlbN0rJ17xLxrT8mEPscf2YwmapHy4hwAbi3Ru9+bpy27lFD+3Tx7XOMZLzvfzagZe6g3Fnthi326O", + "TeICcjz6+SJ0El6SRzqMaIDtDYFbw91ZwRLoNcvmoSCXJV4mBsEENwpumPcADqBU7ZEM8J1nOgQTgkuI", + "c/S/ftDBNUZle3OnRYw2One54LGFVWgDTELbIBZzuEl41pRfWlczgFQFy+++Ew+aNDeyzEnKcJPDpT0L", + "IflwmKuJuuqIVpN80ER96TYAtlo0cHOQ1YZkPhYllfjMZZABalmo0BMLAbo8PKnpcpJPqSC3BaL0rcxe", + "yVzEG4bJfyvN/TcX8Zqw8g+fNWPlm35euX5WAcw/fNYGmO+MDvUEMehR5T1EtNH7qRryTFE1MzfNiIO+", + "jT4SZZSWwaD3f58Oez+e/e+jwaBvf2pJxfIuQHhCgM4P9MpQ38pgiUFLvYRdsoTgtYFk9MpSv7+BYF4I", + "I3Ssol4tqi1gvdUKfbo4DD91qrtLKmmusCFUFaInmgUyh0qeySnNeATAzoW+HGJbcT0naeR6XSxL2rtz", + "oGxORmehsCFXwHlGr1ZMEoH7OE8neVHdIMwMWs7M4GVS8MFXsVx3KSED1RZH6fssY8jiH0vD2yRgVeCq", + "tUT+rvo6te3yalm6TumYvWFN7zP+JpYWYIb2jStIOe6wQsGH2rtojdBsVX6pKfMGJhEPJWFx7fIZxq96", + "OmX0M6N61suYUnQk1bRnfayKNG/8j7JIDTw1VmvJuoKXm7peW5X981VhrK6jlg0JvINqu2IX1Eq+YGM4", + "+n/YK2h5pVM89Rf4JLFGd6TUndHIJ+XhVce/5DKfJlRA4qlVnblcverxhncgsxJDdOekEBdkAxoEpqLq", + "gvhXEo6CgUCzmM1SBb41BYyhERRprqIJ1SxA+U9oQyJw6qeylICAGXiphfgAjW8HMLLaDQ+2HgfiVU0o", + "unfrvxdu/SMlp+cQhpQa8lt+nUoO1I0k9Zl5TzNgD+jA+vEW5lWkO5fgtZkpQup7ZeoX7a3PaXxVF/Ap", + "vTr/b05hr9vuVnZjiqMKqCact/MnxonG3t8VmI68ksqhbPbcpcELEUgLCigsRXJABDgFT8VpnmS8Vs2I", + "IiaK3GS5AERfFhM3mdqg+gGGToiB/YZe+UqdJlSjvZf88l7yiyw1Dt280eSwlF3mFB4NshOa0USOGwwy", + "bbft36tdLgI8X86X3B5ldRHUqKm40/j2+mkXisZOfLVN97d3cTDvlBnkjpZH8Yjd3vUpJb/f0QLNkw6r", + "rVFNYGACB0jfDcYxFjepNVzrnG3AhKozlUdZrljsbDLrNqW+sWbUAgAC5o35K1e3n3o4ubpSkVKjlts3", + "SChWfnEEoaoPUiUPFM1YRFWsD8Ah5gBz1/wd3rNa8c8R1W15k24F+WKL5ly3Tk3kXIsCWdmV0NofED0e", + "cSJsJJinxz55lzJFM0Ph5ko3zbMczHfsKkpyzS9ZFwJQBwLA2rEsvKShKwvNCMXkSTWqF02IJXI6hEj6", + "ICl3jIPU7lEukWMIsjx++2Jp5aC+XhUf9HmYcsAW1oLTEt3lVoy4cuUJoLtaU5Trfxe1iOE2S7bHxaL2", + "uHbQ+vUm9XzE+orP/twFE8uumEcQwgrLzlQsXroCnMis4dINL7WGptltrKNUN+SSd79tiUmKBxsrnYht", + "g2A6kGWEmAtlu7ksE8TMmIClCcXalKaLRdtAVGQb2Yu2WyLaLILZwjahVNCAA+XcC8e9cLx9wvENTYmp", + "M0dK/saiXJnCpxCDsqJw9LVdCItdAUGoiCYgKcGoz0XG1CVNmoSZKbce0xJYiHrg5YPdZxJy46ORrDLU", + "auqQed5p7nKDzcIAuh03reWH//r9ux/+dHj0AuOEW2y/rl0fTxwGEJMgftiP/RQCiIsnUqwfVvNtob9w", + "9XqAOxHM6qyRXArDdY05jsFqDTkgMJlMmP0hiGNEt9sZ4HS7jLPhfNxf0X8wRK15thi15ux/H/3f83P/", + "y+P/+f+DxXEzIPYqV5MQ7vsbKuiYxT/NFoAh8WhCbM5CMoUqOpzVQAzE7yCXHBSGRUS6eA5Rnq6cWRxb", + "Oya2QDIjjxCQMWaCDGdE5oocn742i6j04z40Zjue0xgm17XlsE6QAm6JmkHpecBO4P1ZLNJZw4IXLTet", + "+3upMhBezSfABdXRBdH5aMSv4CB1Dzy07FyipcqIVDHmU9MREzEX475Na3JhGg6bcRRp3U8MQZoSto5t", + "pj8Qb/Ik42nCbOOFQYVM6Qxs/f4E4hRSuE2nlGiWUgVWroTrrD8QPlmLkGjnxur1Meh82CuOvEds/Jx8", + "N5KyP6QKxvfd4wrKUGAohgIBvRfr2rToteSGIJNnKMqq5VdC9W/XQoAhyhqfRYxFcWH9yR+N8j/+mNl0", + "d4+X1gFt26ZMlBXpJJq7WEkRtHCGKmfdwnrkn45cWNAjIUVP5Eny+C/WC8muTL3GQNAh1jClmzXKcdY2", + "P67JGHZcGdkqWpcwYVc8kmNF0wmPMIcGa17MccaW7U0qp9bJ5XoeiLldJ/PmmTCt1zbJZO4ki65WnuH8", + "bkU7pTYoyksSqmxnsN/Q9wRe0WyYEc0I8FPPpY/0z8sgrnoxcy+Z6UQBnpC9DwwEXnwxx1IYcHRstM+X", + "IpIgYaGdF66ZuVp4fS5NC9Q8C3ZFo4zcwlk0+H+2JSWRDcRsxYOlreGMMJ5NmMLZSkUCYdgnx0nic3Zx", + "RMVyB+Jf3HFk66KNIThecLUwm04fXIHGsodjx6tMv3QXCYr0+DSVKrPuSkYD64x5NsmH4AcrUyZsJIss", + "fj6gKT+4fHrg0rx8azp3bErV9R0+GzkaNsPGe9Kvkn4xTSB1Uqb0gbgBqXutyFkPTc+YL9nS4GJ2qJVb", + "E08E+vN1fO6sv13hDIPGiKoCX7l/rxl7eln/DtgZGkMoYykHQXgfrHl60LUCVF9nrEGqgvkj3b6nYXWj", + "9x6H99DjcDfeerfDFW2+v6B3wMORWE4xBwiA8B/ZHKbgDUiqbn1tPnr/mOef5zrcNrlak1MqOYa5u6hG", + "vwBfqIZsMjK5xPxBm0c7X79f34284gLHynCbuqXzrsm+WTuEb6/XU11f2InrUziMW+9CFw52N8uFsVC3", + "fqVwnDtdpCJgrC7xbYki2rDfgv2/+ICsC5plhuQ8CXY8LChbG4b5K3n0UfBLpjS8JXy07zG/hjYr+PBe", + "qgxcz/yjhqokQJmbyC18fDns/fns02Hvx+PeL3/7+5u3p70Pv/f+ffb1yfffwvcXGHHD6V4FeCnZAhYv", + "13XMAyuqUatZE2APXCYxbztYQ5etpoZKj+s3LJgOnFkB37xdgvdrmRWW2NV1WRpgbXZgZ4B+QyvDXPsC", + "8saaDQsfBc2ziVT8D7bpQP3XAiIsIL7YkBi194d1hOwfNYfsh5NbOWr/qC1q/yMolQHm+8srI+Zo8p5l", + "CP18vfTbWIsMZTyDGwmory5nEsNeSEpnAFStfXcIIm8zctp44oGAgOL6EXMjiPtTNCCd2iEUE26FvTe3", + "L8G+tA+6nkoRR9h4osHSIw7puheZOgzSPrHA6JaZMYNeLnh2DgibVlLYUK6BwCtGfaF9hZXXGuf3UfDs", + "xNSvr6q3J6RM9UxHFvuzhA8GODJkgI/xgw56Wo/4FYvL9bpEqoEYdJJkOugY0ZVI+ZnkqW3Uw4N4iFGX", + "Cgf8Z2Jic1AxZbN094az8PmhT96zzLR5IfIkuTA/RQmjmB/8CpHn/FD+AuFzMAZGLxkxhJyLaELF2K5x", + "LSGZk6Wuhebc0JZwIFvN9cjGZofGW2mQGb8q9vZoUrcPTeouWrTaiXhOxpbrkfacBhcS/D5FyTpSlDRv", + "tmYqQ9v/tcA84Mknh2ZutcRyCuD5agjnML/XWPcD8H6j9hEWKdt/dZ+c2IDsQccafwcdIpU5M9Gpa9AJ", + "t24drd1ZA7uiGTuHoLdmE7v5TuB7xci+7KUOlZ/fjG5NldXXnZegb3tRfDQagcskVRr8WTuvpanL4/iC", + "ZvSaXFduZCH/Oa3+3AuLldXFSpfuNuIFTQNffDR6G+ag9DkpJ1QTShIuPrO4uG34cRGapiE3vKyVsNcz", + "xVfh4uY5vLetXGfgtmp1sK7Bdknr4qiVHPHkmneLchtLyF7MqtzgTggOPpCHgpd9WFPbeLNT4C2Q5ndT", + "uukcss2plQn3lKpWkCUYPCq5mVGYg/xOPh2J69lutktwh7s8EEWKJDPML1J9HiWI3rHKMP/pKjaP1HXr", + "2odrOhfjIsGeG1GbxPULGAyy6ym8Xeg6rsdxXl/wNjS0kAFpmp57EIAbiKumN880LQSUS8/svS6qH816", + "4B6cu4VemRKd5JqfgrhCYZ4Ofb5hw12IDOV817slCVRtoYYRhbP8qVxunvAt8iffZOsX7rdbYhrH5j67", + "+rZjvfkri617Q7lbWPLRpyGiVzbVcdMFwS2b76zbwRTos1USUtsa9pnurL5i9vOcMeJsuvMH6xraHz43", + "OHxSxadUzc7ZFG3mDbkpbBECRVopLNiYU6zwEtpsyt2k6Zidu0CSlUDsnUkYuwXc/+OgoTq9vaFpClde", + "GURrgtGQxYhqhc70XixiiJE1I2Hy+NLjCdQqddt0MrWfPD6r0PWETpHF8A5cse9DLrp9Frl7mUWuWZ1c", + "JnNZwcbX5+C7wLx39FAz+9ZiKyoY2yGjYsi8NTQoOk1dXqDQb5kco3TRX3gWTRAcRuPbQYaQs7F9BvVa", + "qgWfJccZSRjVNjuAbQYwKC3prWqlgpxwTjKVg+/dAVzMsVN3k0qVPFfw7HjOhJGEcckgYN+2mo0CqZI9", + "W9VMAGsH97RKTtnTorjrqW45aGZCHH0773nD+HXYz7lDLXNJm1r9QTelB7OahdnzNAVgIXij8nnkV91Z", + "HNZxmmLToSHyGLsIeyB+cPVt3kuPNZ4JJUJoJMqKIvreao2N6Qjwm1Ff+gtho+CRYiSbtpAJ+zIMiQ2i", + "ROYxETTjlw6s1WM3mWVxMgnhkiyYs29jII5PX9skP5rMZA7JEABXxWrBuovZhuxrO7TfhXZt8LzfEFjw", + "hEcM3UbtlnaOUxpNGHkCcEy5StD9BdGmKXwFvGmsqg9+fX3y8u37l70n/cP+JJsmwApMTfW70Xs7hcCF", + "xrsZ9WEZDqBgT456ONtAJhXLdnz6utPtlLCi+uDmY1qjKe887zyFP4E34QToOHRogpx85o9jlrVkdqVJ", + "Erry24RKXIrXced5J+E662ErpguXEr9VMS6KHARuulwKG0b/rVsjNEgLgCqhS6QfIOlat1zyPk9TqYya", + "V80jQBVz6SF4fAH/fmYz+4PZWftT4fZ+QR7hOfIYvhQ+8BemmXXkSyBFuoSBWClfAjzdpwk8v+KpwM0q", + "/ReTECCpmo473U6BETnX190nMYD3hxmQ2EiqacNuYDTfwv3oNI9r5Nz0lhuZoT+4I+pTQzYavfyCYcaM", + "pe8KZ0XXP5D0k8NDlyrBoX9VsTaff11yJHPCFUC8Lek8/q3beWZH1dSZH/3BTzR2SgFUOVpcpeqr9+zw", + "6eJKr6QaQg4UODN0Pp1SNfOMbzfZyB1qVIdPgdzBnKwEk7Ka4+SqB8ltBE2c/nXVy83lzHsbGb0N/bkq", + "5jRgPkLB06149iyLGsuhPReFgvrOTzKerW2X7ThKRo1v5cMUp1Ghs6P10lkTSVlTCUqpO0hRbottvOT6", + "SOpbt36eHXyFf1/H3yypJawpM8V7OcpsXGJhX5kRHtcpzxbylFc55UDOgQexF3PYfadKOcvKPQxSqAu0", + "Z014rRDXeTdIwtR4triGQz6r0FB9x9YqmxpVoJ9ZtoA6xiy7DaRxuC0ZdD8Jrdt5drTEVH6WglWosqCQ", + "9Z6UeQM1Wg/GAsqnjSatzrojslz/udzgy7fUubw1nvA2mD1rhKzhyHW7h/4BVdGEX8KR36xvHtsCAR/h", + "DbrOSdjWg5LweON9CCqFp4QSGWyPVNN8mHA9aSfVU1tgGVLFtvakej9J1VPClkg1TRcYBuHlNUlYTEzZ", + "NtugaWYtlsGNUlmaPjTjjt2XOu0cmw9nDcRw8JWmKd6p269KokwWLdelNF1OPpkOb7N0KtwZG0VUmj4E", + "wQT7Dju6JDWhOx6+T7YLmKIcePla8z76NfmnIJt8uVn4BB1t5nECzeHBQFst4vB2IB3SRVDDTGiWggpi", + "Y/9lksgvZm4BzvBzrPjJFD37q/XyWp+R/cQPZ9eGducQ+cDEcYlS62yEcuZaB3nR9AGSTauy6e3wtqAb", + "1axPPkzgmQs5zD2ygu+JodSZzBWRXwRWHAhXM3SFJWmuUqmZbrXt29o97667SSu/9/CFPndk7veeoOFY", + "mqi8XOLuvwNUCGzzRH/w1fVlrl2R1Flv6Bys5pxAUmcQpa/Rn6rgiFdSVWbBmQZHf8Wch6EPXBRBQ5BT", + "MuYjCDPIyAUbjViROO0CUra1adPBuJfRn4op31SJaj35inkte/IVNYYzMuLUC7+ZdQeafw66jLufTE2I", + "Qz7768f3L9Z4FEqd/WSGt8xJ2L19VxkcP9f3+gS9mcZa4e01SJ+FL9uuN16TJK2HIfI63zavn2302HXk", + "ueMT1w2j8bB1H+/BOevJbgNHrI00CY/QxjuYK7ZB/zDfybo8xMAxrOIIFriI7R3B/M134cJXL76uwnAG", + "sS/LXXs/s9nZX6ezXjzsQbLatd17cTS7v/bagTy4a28hHOrSye9O5yw4YOfcHGH3N3llLEfZ7uqyiFNt", + "vCZi9N89uSBaWMW5hNFyKJn7nv2x5gbW6NwV9LeMruWa3rt4rVczt1Ndfve7zZrHmGW3Z0cPdyIBHsjD", + "wwqUgh5VVU8pzdRuiWVT/lLXOq52Q6x7/6kW/ylYlrWehQdojW+9tYWys+cK31sZatPPtJNmmA7ngYlU", + "/26DiALXlK9xqJ/vkqA2LWcbUjDtVuSuQtt7CTzPg/V6LLGKOD6gadpzubRW4aSer3iPWKolleRu2KmW", + "rKzR06c5a+Wem5bhJpqmG+Aom0rzIJqw6LPMs57GFNxL+D98wiyYJ1iXvLd1zx65aO1YRrpvewC8A8zP", + "r313jweiMTWc7UMTWmvcZmaWScIiSDfhUv5PWTaRcTn5obJOFjh/a0fG+aGbhsUoHXQ0y/J00CFTGbMu", + "phTCTrTvwsJN6IH4wrOJGVI0oWrskBP8fvHplMWcZiyZ2S6xIRZXB+uz+7ucP6M8y1UZR9FtPyzLK6nI", + "RGrTlFtBNyHdJYrFXLEoNPRjvitvdv7426+YT4hNhyyOWRzUz7XNkBIlnInsXLNI2az6XPCM04T/wTDx", + "af8/sG4zmauBCETHAp8VpnqWGHpVcrsfYrmiWdi1QqsoThipeLfG0eM0nTs2nSdZo0oExbFqU6W7ZVHd", + "okxHmdkiMDci0VOpMposL8/d2JwYO4X6boggfj5qNsoBkd6LmpLkQ2nT0lImXQqRbMK4GoiyNNRdYhE4", + "7OdaoksqYkKjyALkmwI2VSQjE64zqWb9gXgnkhnKOm1EXS2HczWpKNcuoXMmCSXaZ3U2vRVHx9Jirbzm", + "91+oufc4mPatFG3NI1xKwLVX3Yu5pcScZzvLFkSvU9qB7rXYN9699NnSIMUcAF0oGb7TroiFo6OKFdCx", + "LCZUE8YhMdoooRkZMQZoRpAdqWcBilwXbU72KCncuNfl57FRkdLiR4IrNdeZYSVHkpLTSI9cYDKnc0yr", + "By6f8MGnrw4+3BYnj4DEAk8OXKvhzMGnLfLcvEBnDlv87JNk/z37Ky5Q14IHX6zRt8OOb0k3zvLEX16l", + "5lAe5UlCbH4067bnoUdjD/JYIQmEcQooQTGanGd8ys6Bpy6eE2wduBQG+Z2hOJr0AG4aSrUlUGJQtbQO", + "qyTnwzWxA2iCny0TxEY9XmAoeyfVBU6qFTG/OS++yhkEOFD6gMb/yXUGlo054fQOT6oo7TzgnSfblH5m", + "xCLpBaW0VU6Lo2ogsKUhTaiIqvI216wXUc008pbNYR1JZRR2e/42K7PQaK/o+H7or6gIwuSO/dx27J1U", + "GU2LLloqc8+VzsY8WHWWWaQ8rp+5kcnmB/SSCkc2BvQWOqDlNNfydtnM6Yw30x1+Zpkl0J/sJHbtGlpi", + "LByTbmcrV+LBRB6XbjolWt0+R1lAxQU3tyr2YtOdyrIRNrd1LlprbHQ43W0kDA2ApXfv1l2MZa/pLtB0", + "QzpZC+culW007LZPjku/F3YSDfl3kkRaKiByRFLFUspjp7FWVNn+AlUU2r9/WihQ+m1QQGEg7YckfH6Q", + "ameV5nd1Rh58jYqdWJhVpsymzSro7hirxVYZzu8ueEQuzzgPR7W8hZxyoFmWJcxcGQ8cymy7bQZdbgAe", + "Bh8li/rOcCtH5nxzjSUzMspFzOIy1+EzqUVJYSJOJRfgQ6FnIpooKfgflX4y03O5bf/xC88mAwEAnpDB", + "h2hp3ycUu2QiN5phJMeC23Qjwo8Foa94wrMZwG3CA8ZVCl4orYlQQ+HQc2PpFQtxTwXGJtzz4vJh71CM", + "3/u13LHv6/JS7AHlDnSOd6Fy61myJg+2L+kyRYWmYMNd7vYcVvAJFQIvO/cSSgXh02kOA+sSEFMykWMe", + "0QQkjAK0K2x0Ki9hGfTzsgDUA4EoxDqfFn/tkw/hKOzDanG9NYJMaVbpFKK3B2I4c7Hh8y0ApYW5bXaA", + "k1xpqVa1BJS2bmv2gHCrbodVIBjRUnYBu9oP1zJQYYUtSSh45rXSsWd9tJZLd9FrqHh/gqjC3Akvi4ke", + "wzwdEbc5y8OmVlxU7Os/GTGa5YpZlzjrC2fX7sG88wZkQzzZ1Gk9WPS6XxGeLPogo1c9APGbG+wn1ZgK", + "/gf8sYd1e0XVDZLRu6DnF7ZjhA9sfOCYU/yhXEnDvfLZZTxWYyOp4ErpVZEnGi9SS9DKpi4dc3Z/R1eO", + "NZLvvQ4YarqKbJ6QyzLRIkAuSmg+ZhCBYgu3aOYOkbKHTa7q7rii1mx7WTa9EpYezhzk+7LpFLH42Sfw", + "yXNKzNH61PCXMLJreeOBa+aidVguv1fG63m93LYXPpqZVEWer3+W4MRxGOayp31CamgWcnRdkEdTqQ0j", + "R+YEH3Gls8d9Am1QqGFWnCUx4ZqkSl5yc810UVcUU4l1Cbc5w3SQ+KtPjtOUod9gmHhsIDKJc3ZluwRD", + "z2xuMZehzJULGt2yi+kmldLXuI9Aaff4SlXXHj1IrhdJTnq+cV8s+93w5dSuMFhVoCdDZUOaRRMiR44z", + "Cjlj6O8kkbndEI3Z7Frj6SwbNojX5VQKAM21df53NbpxawTDhOVtabcHc21ofSkX3Eo3Vd/bSrf1TqiY", + "vRu1HjBtvaxncGdLaVZPmtHqkTAm9JKRIWOiOGch8EmZv2LokrnvQEwCPinIXCezu8OMlj9WYceKluLu", + "v4sRmV3JFiXFN7TBpJv+sn7DM3mPxnzD+IzFG1FWEn35IWKhn/N4WT3RlcfojUF+ePg04jH8y9anLb6y", + "Q9y1pdYP40Fl5QyER/0W9sp9XJMTFnbW6jCF3zea2BPntCPHJey9iZ7w091P51ns4o0pqvnEPPiKPy1A", + "fcYEk57uFmA+F+NebLr3A9gnBd1IUtA10tA8sOdFlDFm2W0hi8NtyqB9RHjdHL9WkkzN7bId87lCl8RC", + "AmXJjEiRWFC0XPDsHFL+WxuTC8KzOnOrd9TuqHlTbwXXOdC3ykwPz/doqxoAADwd2GtIq2sk3LLsQ7Rh", + "GTmap41CW45TAJvlXrALrD8sRMArW+CNE6kz7LYtY8kHuMDCoMiEaqLzKGIsNnLs3vKKJUkn6JHK1swv", + "Y3lpiouILccgbjSYocg62yXcckyRgs5ZY7xnsGJaJpdME0ajSfHWwWMmMj7iNqlS4bYHxkBVJDAZCOwQ", + "fZRdMj0kCRb7a2qXpEkemH3KQYADEboMwzDPXzDNx8Kad4aMRBauVgojAPgViOWRYnpCYGkvaeL8UdAm", + "4vaRcD0Qpgw4C7rGogmL++ctEqRY/VavoOu9H25IQPzsx1uVEts8UWujaDfB3E2x0SAFCkqZ5whUrEyb", + "MEgVv6QZW1I6JMkUTrcD067i8SJbdMpUz5x1OqURI6niESO+aotx2vXRK/poPktvbkf89dc35qg5NeO6", + "q4h+MPgHZoL89dc3qJUFJFKnflPM7O+6jJHzqLnVQlkj5w3ZKpGW32EvdtDbNlaGDNVIfrBmd95eWaO/", + "dZDfIkl78BUoblkL5mrEigbNJmJdfI3Bce0NmxsxbG6T2GAnF5zp40QOaVIMy9bpExdUY3+3QMaeeAnI", + "FKPgjwgVs0VHP46jRnyND5w4gPU9L15HLWh4AceFWBPmJF6RVN/9YSpjlpjfKm/gFcToyt8y+SBfxvda", + "2y3S2jx3b1aMlQ/MOU86zvWsMkIynJHXLwrBBtHL8KFVtg1Eo3Abs6ps2+25erg1he8hmukMUZUpaf2k", + "7ghn3kFty8zzU9+oA5itsQH3LzoeKzaGAZT8wY7b3MGO995gXllatCtlXzAsfS0wZqjb+8xm61PMgHF2", + "HqALo3hgZ7cXFyVf1TL0covVBKq2mkfg60bdt2CkO3Legr6bqMIeAXfeEOJ2r0YVTafVwVf4d1kDRgvd", + "oKXC9bxYi8JO99aJjVgnWilgrhMV1EL9ulFbvgXbe7gtKfBAgpPnUArGFLd4NrUIAnRP2g2lbMo1afXD", + "amtk+vCcktoo9tr3teIEXM65wgnKkVQI/AAZ71lGLo6jiKXZc1Ld7gvyKLjHPDaXkrE1cmQqj7JcsZj8", + "7f27t6HGX2owY1fZQaQvL0zVWH4RiaRW7dd0ygCI0VyWKDl5/zsBMCmdc5i4GeZA6FQxGusJYxkiD5qC", + "kUzyqdBdc9+A+1DXX/IuRkpOuySTXeLijLtn5JPz/Djncde7gZx/ZrPgN8PY3TNiw0xiPmUCIL/6/b6N", + "OOlawI3i9oftX+B4zNWN2dhd6yb5ZcJEUIprdz+C7fpOD8TFWMk8PR/Ozov+Luw8s4lijFz40f2P68YG", + "BLuOMjlmgKhjehwI22Uw24ZuSXOvLU4k90UiNnqfbV0glv3Quh3HH6Yyu6LTNLEd/2x2yAZ8l5yWig2D", + "josjcXH5bgfI19yVDYtkshsyRYknyiwBTwPdbJayLrQwEE8OnzztHR71Do8+HB4+h//+3a388Qj+eHj0", + "85++//efv//++NU/j//+y8ujJ2//dXjyjx9f/dKl0ZT1uIi6x9GUkdci6nfHadZ71styNZRdLtI86x49", + "qfV21NTbk7X09uSw1tuTpt6elnv76em//n3099+Of/znD7//+fT9kxfdcSKH7Kr7M/xDTqRKS73JPDPd", + "PTMny1tJgB17w1nr7raUqe/oyvuz2vqutj7P7DnomQPDfHWmuBjvzbuh/9UadYM0oWKJmF4o1mLNtU1s", + "0JgLHazrKdPbdC+Z0lUr7vyo3ltiRV2wHOuzeJ6ajnZt8DSDeGD2TsdQ9WebUyXjPMrICc1oIsfrRBsw", + "nbYaSs3HjdpJzS7vNjm/GUEjSSVU3H1bKW7guiiq4Qw5+Gr+WdpBzKzq/PhWHPISL9XQ797EuhET65oJ", + "Z65hdh5RjFm2e4o43KrQ2Ue11u24ayfH+dbfeRSJJuBdEOUmDMCaqWzlU3i7DHGvM1Feny+QWrd4xB/Q", + "OF6YDp/GcQ+Sz2stIw7qE7iu0RZV098le9j69pjqNvpoJlQcm3XYg7PNT0/tyGwk1QZOh2ZQ4TgG0DXo", + "2YaKLrw9WaK++wdFcV0D6tzRnc3333ZWwMeHhKIGNOkJcvtngf0dln3BHfA3NpWXLGCgkZLTVhYKLoNb", + "Z6Fua9s4z/2dc71E7EgjoIst3j89QTqNhZtBQE6BZtp0d9KHQJiH25bdDwXIr5nktnvPXZnyg7vvPSX+", + "TV6xV9ects59Dw70YTt8OF+RUtGEX7J2v6xjW8DZpfABs86d2NBDs5c+IB9BRwkhHWyLTNN8mHA9aSfT", + "U1tgIZliQ3syvbdk6ihhO2Sq5IgnixIIDO0OEVe6xQ6JxXq+0bW4t2yD9OyAH5jHRHVXG4kMV2iZsDHB", + "vlTbBO/nnyr9ELN1FD1wNMsyLsbWFOlqIzprpmSiCReXkkdsIMZMIMn1ybEoI05FVFhAimmeZDxNWG12", + "JGYjLljcJ8cDUflIuCYJF59tSGgQXk7TtE8+TLgu6ThcEwY8xfWExQMR58rho1Qa/k5bc5oDvVZsSrnQ", + "BYZtq/mzwksb9SMpc8GOPUpwvg1cVy5x991LGjlmARM2S++Dr3xJF5Im/nwnkhnReTSp8wwmHI7RmgaA", + "7oV7oJBZKQQbq7lPKReYk5GKwGU616YL/6tPymCqgUs/8PGIC5qY1Xb8r9usnHVOWawU8b0VcjOeL3RF", + "ep7r2lIl1kZb4m3Z/sPdScKHYvVbmbbm+6ksJC802O2QwjZlULvBib9DOn948Yz0RuqBzod+NRfAnJeL", + "bjAsodTRusITaJA9rRKJQH0StVsSiFBagDXGHbwP2911/EE4mL0vznxfnCrr1fm7tLWlm3jj1TFscEP3", + "RpQ44cB2k762YSBNpBV+v+cOLqbCj4srnEgxSniUNV9NKyS0mCTnHDwHX8Nfy7n96up8pefFmla58Tug", + "169Eqw9Etd8ovS3leGu0D1vOAseEbbSYu8Miq7jfrpdiu9fWzu4LTnhIG3vv3xU1DuIJd81MF1ERsaT9", + "wfMEvtscjiVmI//kSWL2Ik8ycy+gxGx0nMM1KMJji/CRqamYuQ4MhIT0HOW7BdbCNI8ZNbeIkZkWIERB", + "79Ywn/Fpkx0eStyK82g7+pvdr93YAFY6E++3GeCG+hvs4obP02hCxXiOy81JIrW5qBOVC2G4tixwRGzZ", + "UeMLiBSAiCMV5F7NpEWLcm9w+OB3gtCHmsU2uVI6VjRmugsZj9zPpm14N7dDbHioth8eEFvbvdo9W9uB", + "3D+kp20zOCzjhhk8F+7w7AUHZTvDf/Tl6+d5eNQ2mNibe9pf/PaHXDsPFOTWSmnX4ImMXvUiWQZIa7j1", + "FcU2YyV/LaIkj4M3d3pFoL+mnDXLXOG4bfAcG+w0pIsaSpkwKrZ7bftAr05k/NCcrvx2NlLoB3q1cphl", + "ow3YUelG/YZwB3frMISDaFQo7Ke77ynkiOaGNNMi7w6+ZnahajGIjf42AWktPqR9y3t/m43426yJMrrt", + "Bvnbst2HOxAcD8T6vjYiQn+bqheNZmqndLQpL5rrnH+7ION9CpiWFDCwLOs6XE3bTF02Ax/+KiOadLqd", + "XCWd551JlqXPDw4S88eJ1Nnzr6lU2bcDmvKDy6eQc1Zx07a2d26Fd27wa+k87/zwww8/wIY3WN7yuNSN", + "fn5QnPn9yHx33RjmwBnX/C8LrGp2SZPcGspDfHiSSRJNWPTZ3Em4qqDK9wtWboS2ro/8XeDN30vYJUu8", + "W3EkxYiPc+VNCLWWX9iSuqFdFyQT2SAZMqWCjpm26SK7LhFK1wHCcxV6+tuohNI735BqFjuvrMbBVMNy", + "6mPyUGMxzahpENH0uRgTIdUUHZ9TxSPzJ0jgbgaSUDHOzS0IskVrQiMltXZQ/Er3iQXAhOTleiYiFtt8", + "AD4ogl1ZKiZa5gpKipjQPJM9WGQ1ZbHNqJ5N2IzQsWKscY4eCa3BzckSgiaKpYppJsAvHPcgpUOe8Iwz", + "TYY0+myTadujoIsYfQ7eK2Wqlwue2ZVaTAOu34YhffBXaLMwDvkrokmUJ6heM7vVnrwbuzDCoN66C29x", + "lNUQBqK7JMqVYiLi8LOZkdl3pDvn4b7EEJyrX30Yx2mqCROQ1n8mczNDs9tmf0WMrfI/WCnGBhAKyBep", + "Po8S+QVQw4ycG5tlFmO7IQXJzHTGppZkjKCzGLLQbUQFUNHUBsbHhIkJCI+ZzIuoHhZJ24bpR1v/PnjT", + "C8kC4hCoBvKdKCn4H6aIHSgwAgwqm3AV91Kqspnh5Gwk1dQsLG4pvCOYTe0SFzSEM45Zwi8ZhOu4Ve+S", + "CRWx3S46mxqCjWSSsMgsrN0g+7zo/IAVS6i1zOjPzbtkFqVhi16KjGcJM11USNHGOqHwNH8ZOS5aTBJh", + "q01el6VH0bDXTNHoMy6tHNm9cqxqxJ7d437ZbOZCQriI+SWPc5poUzgMxtI2TsQURNE5ZC6/jiUfiPCo", + "T7ZxemWjXcOR50+k68ytqL3tefmeG+YEJYBlLmu0suzMXhZVUyXNkFhMqGMrmetkZvjQSCsngLW0cn9K", + "ZxDAY5ZjOmUxpxlLZoReUp442BALdFE+A/2wbd9tE9MedHEiv0B4EMJDMjffaiwgFTSZZTzSJM1VKrUR", + "PNgUbps7H1y+PH/iBdCTZp4TGdutglz/XIxNS67stNwkWo3MYDyYCgyQAE6DFbZmiKOEXfGhawAePCMm", + "qOJSV1dHd76dfft/AQAA//9a3d/1JgYEAA==", } // GetSwagger returns the content of the embedded swagger specification file diff --git a/api/v3/openapi.yaml b/api/v3/openapi.yaml index b6ecf9960f..2a469ac32c 100644 --- a/api/v3/openapi.yaml +++ b/api/v3/openapi.yaml @@ -19,6 +19,8 @@ servers: description: Cloud variables: {} tags: + - name: OpenMeter Governance + description: Governance evaluation of customers to check their feature access. - name: OpenMeter Defaults description: Organization-level default configuration. - name: OpenMeter Product Catalog @@ -1526,6 +1528,45 @@ paths: $ref: '#/components/schemas/MeterQueryRequest' x-internal: true x-unstable: true + /openmeter/governance/query: + post: + operationId: query-governance-access + summary: Query governance access + description: |- + Query feature access for a list of customers. + + The endpoint resolves each provided identifier to a customer and returns the + access status for the requested features, plus optional credit balance + availability. + + _Designed to be called on a fixed refresh interval and the query response is + intended to be cached._ + parameters: + - $ref: '#/components/parameters/CursorPaginationQuery' + responses: + '200': + description: The request has succeeded. + content: + application/json: + schema: + $ref: '#/components/schemas/GovernanceQueryResponse' + '400': + $ref: '#/components/responses/BadRequest' + '401': + $ref: '#/components/responses/Unauthorized' + '403': + $ref: '#/components/responses/Forbidden' + tags: + - OpenMeter Governance + requestBody: + required: true + content: + application/json: + schema: + $ref: '#/components/schemas/GovernanceQueryRequest' + x-private: true + x-internal: true + x-unstable: true /openmeter/llm-cost/overrides: get: operationId: list-llm-cost-overrides @@ -2850,20 +2891,8 @@ components: name: page in: query required: false - description: Determines which page of the collection to retrieve. schema: - type: object - properties: - size: - type: integer - description: The number of items to include per page. - after: - type: string - description: Request the next page of data, starting with the item after this parameter. - before: - type: string - description: Request the previous page of data, starting with the item before this parameter. - additionalProperties: false + $ref: '#/components/schemas/CursorPaginationQueryPage' style: deepObject PagePaginationQuery: name: page @@ -7434,6 +7463,20 @@ components: $ref: '#/components/schemas/PaginatedMeta' additionalProperties: false description: Page paginated response. + CursorPaginationQueryPage: + type: object + properties: + size: + type: integer + description: The number of items to include per page. + after: + type: string + description: Request the next page of data, starting with the item after this parameter. + before: + type: string + description: Request the previous page of data, starting with the item before this parameter. + additionalProperties: false + description: Determines which page of the collection to retrieve. CustomerPagePaginatedResponse: type: object required: @@ -7690,6 +7733,241 @@ components: description: Filter credit balance by currency. additionalProperties: false description: Filter options for getting a credit balance. + GovernanceFeatureAccess: + type: object + required: + - has_access + properties: + has_access: + type: boolean + description: |- + Whether the customer currently has access to the feature. + + `true` for boolean and static entitlements that are available, and for metered + entitlements with remaining balance. `false` when the feature is unavailable, + the usage limit has been reached, or (when applicable) credits have been + exhausted. + title: Has access + readOnly: true + reason: + allOf: + - $ref: '#/components/schemas/GovernanceFeatureAccessReason' + description: |- + Optional reason when the customer does not have access to the feature. Populated + when `has_access` is `false`. + title: Reason + readOnly: true + additionalProperties: false + description: Access status for a single feature. + GovernanceFeatureAccessReason: + type: object + required: + - code + - message + properties: + code: + allOf: + - $ref: '#/components/schemas/GovernanceFeatureAccessReasonCode' + description: Machine-readable error code. + title: Code + readOnly: true + message: + type: string + description: Human-readable description of the error. + title: Message + readOnly: true + attributes: + type: object + additionalProperties: {} + description: Additional structured context. + title: Attributes + readOnly: true + additionalProperties: false + description: Reason a feature is not accessible to a customer. + GovernanceFeatureAccessReasonCode: + type: string + enum: + - unknown + - usage_limit_reached + - feature_unavailable + - feature_not_found + - no_credit_available + description: Machine-readable reason code for denied feature access. + GovernanceQueryError: + type: object + required: + - code + - message + properties: + code: + allOf: + - $ref: '#/components/schemas/GovernanceQueryErrorCode' + description: Machine-readable error code. + title: Code + readOnly: true + message: + type: string + description: Human-readable description of the error. + title: Message + readOnly: true + attributes: + type: object + additionalProperties: {} + description: Additional structured context. + title: Attributes + readOnly: true + customer: + type: string + description: The customer identifier from the request that produced this error. + title: Customer identifier + readOnly: true + additionalProperties: false + description: Query error within a partially successful governance query response. + GovernanceQueryErrorCode: + type: string + enum: + - unknown + - customer_not_found + description: Error code for a governance query failure. + GovernanceQueryRequest: + type: object + required: + - customer + properties: + include_credits: + type: boolean + description: |- + Whether to include credit balance availability for each resolved customer. When + true, each feature evaluation includes credit balance checks. + + Defaults to `false`. + title: Include credits + default: false + customer: + allOf: + - $ref: '#/components/schemas/GovernanceQueryRequestCustomers' + title: Customer + feature: + allOf: + - $ref: '#/components/schemas/GovernanceQueryRequestFeatures' + title: Feature + additionalProperties: false + description: Query to evaluate feature access for a list of customers. + GovernanceQueryRequestCustomers: + type: object + required: + - keys + properties: + keys: + type: array + items: + type: string + minItems: 1 + maxItems: 100 + description: |- + Each entry can be a customer `key` or a usage-attribution subject `key`. + Identifiers that cannot be resolved to a customer are reported in the response + `errors` array. + title: Customer keys and usage-attribution subjects + additionalProperties: false + description: List of customer identifiers to evaluate access for. + GovernanceQueryRequestFeatures: + type: object + required: + - keys + properties: + keys: + type: array + items: + type: string + minItems: 1 + maxItems: 100 + description: List of feature keys to evaluate access for. + title: Feature Keys + additionalProperties: false + description: |- + Optional list of feature keys to evaluate access for. If omitted, all features + available in the organization are returned. Providing this list is recommended + to reduce the response size and the load on the backend services. + GovernanceQueryResponse: + type: object + required: + - data + - errors + - meta + properties: + data: + type: array + items: + $ref: '#/components/schemas/GovernanceQueryResult' + description: Access evaluation results, one entry per resolved customer. + title: Data + readOnly: true + errors: + type: array + items: + $ref: '#/components/schemas/GovernanceQueryError' + description: Partial errors encountered while processing the request. + title: Errors + readOnly: true + meta: + allOf: + - $ref: '#/components/schemas/CursorMeta' + description: |- + Pagination metadata. The endpoint may return a partial response if the full + response would exceed server-side limits. + title: Meta + readOnly: true + additionalProperties: false + description: Response of the governance query. + GovernanceQueryResult: + type: object + required: + - matched + - customer + - features + - updated_at + properties: + matched: + type: array + items: + type: string + description: |- + The list of identifiers from the request that resolved to this customer. Each + entry is either the customer `key` or one of its usage-attribution subject + `key`s. + + Duplicate or aliased identifiers that resolve to the same customer collapse to a + single result entry, with every requested identifier listed here. + title: Matched identifiers + readOnly: true + customer: + allOf: + - $ref: '#/components/schemas/BillingCustomer' + description: The customer the matched identifiers resolved to. + title: Customer + readOnly: true + features: + type: object + additionalProperties: + $ref: '#/components/schemas/GovernanceFeatureAccess' + description: |- + Map of features with their access status. + + Map keys are the feature keys requested in `feature.keys`, or every feature + `key` available in the organization when the feature filter was omitted. + title: Features + readOnly: true + updated_at: + allOf: + - $ref: '#/components/schemas/DateTime' + description: |- + Timestamp of the most recent change to the customer's access state reflected in + this result. + title: Updated at + readOnly: true + additionalProperties: false + description: Access evaluation result for a single resolved customer. ISO8601Duration: type: string pattern: ^P(?:\d+(?:\.\d+)?Y)?(?:\d+(?:\.\d+)?M)?(?:\d+(?:\.\d+)?W)?(?:\d+(?:\.\d+)?D)?(?:T(?:\d+(?:\.\d+)?H)?(?:\d+(?:\.\d+)?M)?(?:\d+(?:\.\d+)?S)?)?$ @@ -8672,34 +8950,32 @@ components: ProductCatalogValidationError: type: object required: - - field - code - message + - field properties: - field: - type: string - description: The path to the field. - title: Field - example: addons/pro/ratecards/token/featureKey - readOnly: true code: type: string - description: The machine readable code of the error. + description: Machine-readable error code. title: Code - example: invalid_feature_key readOnly: true message: type: string - description: The human readable description of the error. + description: Human-readable description of the error. title: Message - example: not found feature by key readOnly: true attributes: type: object additionalProperties: {} - description: Additional attributes. + description: Additional structured context. title: Attributes readOnly: true + field: + type: string + description: The path to the field. + title: Field + example: addons/pro/ratecards/token/featureKey + readOnly: true additionalProperties: false description: Validation errors providing detailed description of the issue. QueryFilterString: diff --git a/api/v3/server/routes.go b/api/v3/server/routes.go index 35940ce24a..7d5b7063d0 100644 --- a/api/v3/server/routes.go +++ b/api/v3/server/routes.go @@ -458,3 +458,9 @@ func (s *Server) GetOrganizationDefaultTaxCodes(w http.ResponseWriter, r *http.R func (s *Server) UpdateOrganizationDefaultTaxCodes(w http.ResponseWriter, r *http.Request) { s.taxcodesHandler.UpsertOrganizationDefaultTaxCodes().ServeHTTP(w, r) } + +// Governance + +func (s *Server) QueryGovernanceAccess(w http.ResponseWriter, r *http.Request, params api.QueryGovernanceAccessParams) { + unimplemented.QueryGovernanceAccess(w, r, params) +}