From 68530500adec78ac4839d3244bf8a55bbfbdfe96 Mon Sep 17 00:00:00 2001 From: rolosp <6114043+rolosp@users.noreply.github.com> Date: Wed, 6 May 2026 16:47:09 +0200 Subject: [PATCH 1/4] feat: convert package and dynamic price to unitconfig translation --- .../aip/src/productcatalog/ratecard.tsp | 13 ++ api/v3/api.gen.go | 122 +++++++++++ api/v3/handlers/plans/convert.go | 90 +++++--- api/v3/handlers/plans/convert_test.go | 198 ++++++++++++++++-- api/v3/handlers/plans/list.go | 5 - api/v3/openapi.yaml | 114 ++++++++++ e2e/plans_v3_test.go | 193 +++++++++++++++++ 7 files changed, 694 insertions(+), 41 deletions(-) diff --git a/api/spec/packages/aip/src/productcatalog/ratecard.tsp b/api/spec/packages/aip/src/productcatalog/ratecard.tsp index 3c0a88e99d..9460b58a29 100644 --- a/api/spec/packages/aip/src/productcatalog/ratecard.tsp +++ b/api/spec/packages/aip/src/productcatalog/ratecard.tsp @@ -4,6 +4,7 @@ import "../features/index.tsp"; import "../tax/codes.tsp"; import "../entitlements/index.tsp"; import "./price.tsp"; +import "./unitconfig.tsp"; namespace ProductCatalog; @@ -55,6 +56,18 @@ model RateCard { @summary("Price") price: Price; + /** + * Unit conversion configuration for the rate card. + * + * Synthesized on read for plans authored with v1 dynamic or package prices: + * dynamic prices map to a unit price with a multiply unit config, and package + * prices map to a unit price with a divide unit config. Not yet accepted on create + * or update. + */ + @visibility(Lifecycle.Read) + @summary("Unit config") + unit_config?: UnitConfig; + /** * The payment term of the rate card. In advance payment term can only be used for * flat prices. diff --git a/api/v3/api.gen.go b/api/v3/api.gen.go index 29cc01a137..99d1816dea 100644 --- a/api/v3/api.gen.go +++ b/api/v3/api.gen.go @@ -854,6 +854,48 @@ func (e BillingTaxBehavior) Valid() bool { } } +// Defines values for BillingUnitConfigOperation. +const ( + BillingUnitConfigOperationDivide BillingUnitConfigOperation = "divide" + BillingUnitConfigOperationMultiply BillingUnitConfigOperation = "multiply" +) + +// Valid indicates whether the value is a known member of the BillingUnitConfigOperation enum. +func (e BillingUnitConfigOperation) Valid() bool { + switch e { + case BillingUnitConfigOperationDivide: + return true + case BillingUnitConfigOperationMultiply: + return true + default: + return false + } +} + +// Defines values for BillingUnitConfigRoundingMode. +const ( + BillingUnitConfigRoundingModeCeiling BillingUnitConfigRoundingMode = "ceiling" + BillingUnitConfigRoundingModeFloor BillingUnitConfigRoundingMode = "floor" + BillingUnitConfigRoundingModeHalfUp BillingUnitConfigRoundingMode = "half_up" + BillingUnitConfigRoundingModeNone BillingUnitConfigRoundingMode = "none" +) + +// Valid indicates whether the value is a known member of the BillingUnitConfigRoundingMode enum. +func (e BillingUnitConfigRoundingMode) Valid() bool { + switch e { + case BillingUnitConfigRoundingModeCeiling: + return true + case BillingUnitConfigRoundingModeFloor: + return true + case BillingUnitConfigRoundingModeHalfUp: + return true + case BillingUnitConfigRoundingModeNone: + return true + default: + return false + } +} + // Defines values for BillingUsageBasedChargeType. const ( BillingUsageBasedChargeTypeUsageBased BillingUsageBasedChargeType = "usage_based" @@ -3072,6 +3114,14 @@ type BillingRateCard struct { // TaxConfig The tax config of the rate card. TaxConfig *BillingRateCardTaxConfig `json:"tax_config,omitempty"` + + // UnitConfig Unit conversion configuration for the rate card. + // + // Synthesized on read for plans authored with v1 dynamic or package prices: + // dynamic prices map to a unit price with a multiply unit config, and package + // prices map to a unit price with a divide unit config. Not yet accepted on create + // or update. + UnitConfig *BillingUnitConfig `json:"unit_config,omitempty"` } // BillingRateCardBooleanEntitlement The entitlement template of a boolean entitlement. @@ -3530,6 +3580,78 @@ type BillingTotals struct { Total Numeric `json:"total"` } +// BillingUnitConfig Unit conversion configuration. +// +// Transforms raw metered quantities into billing-ready units before pricing and +// entitlement evaluation. Applied at the rate card level so the same feature can +// be billed in different units across plans. +// +// Examples: +// +// - Meter bytes, bill GB: operation=divide, conversionFactor=1e9, +// rounding=ceiling, displayUnit="GB" +// - Meter seconds, bill hours: operation=divide, conversionFactor=3600, +// rounding=ceiling, displayUnit="hours" +// - Cost + 20% margin: operation=multiply, conversionFactor=1.2 +// - Bill per million tokens: operation=divide, conversionFactor=1e6, +// rounding=ceiling, displayUnit="M" +// +// v1 equivalents: +// +// - DynamicPrice(multiplier): operation=multiply, conversionFactor=multiplier + +// UnitPrice(amount=1) +// - PackagePrice(amount, quantityPerPkg): operation=divide, +// conversionFactor=quantityPerPkg, rounding=ceiling + UnitPrice(amount) +type BillingUnitConfig struct { + // ConversionFactor The factor used in the conversion operation. + // + // - For `divide`: `converted = raw / conversionFactor`. + // - For `multiply`: `converted = raw × conversionFactor`. + // + // Must be a positive non-zero value. + ConversionFactor Numeric `json:"conversion_factor"` + + // DisplayUnit A human-readable label for the converted unit shown on invoices and in the + // customer portal (e.g., "GB", "hours", "M tokens"). + // + // Optional. When omitted, no unit label is rendered. + DisplayUnit *string `json:"display_unit,omitempty"` + + // Operation The arithmetic operation to apply to the raw metered quantity. + Operation BillingUnitConfigOperation `json:"operation"` + + // Precision The number of decimal places to retain after rounding. + // + // Only meaningful when rounding is not "none". Defaults to 0 (round to whole + // numbers). + Precision *int `json:"precision,omitempty"` + + // Rounding The rounding mode applied to the converted quantity for invoicing. + // + // Defaults to none (no rounding). Entitlement checks always use the precise + // (unrounded) value. + Rounding *BillingUnitConfigRoundingMode `json:"rounding,omitempty"` +} + +// BillingUnitConfigOperation The arithmetic operation used to convert raw metered units into billing units. +// +// - `divide`: Divide the metered quantity by the conversion factor (e.g., bytes ÷ +// 1e9 = GB). +// - `multiply`: Multiply the metered quantity by the conversion factor (e.g., cost +// × 1.2 = cost + 20% margin). +type BillingUnitConfigOperation string + +// BillingUnitConfigRoundingMode The rounding mode applied to the converted quantity for invoicing. +// +// Rounding is applied only to the invoiced quantity. Entitlement balance checks +// use the precise decimal value after conversion. +// +// - `ceiling`: Round up to the next integer (typical for package-style billing). +// - `floor`: Round down to the previous integer. +// - `half_up`: Round to the nearest integer, with 0.5 rounding up. +// - `none`: No rounding; the converted value is used as-is. +type BillingUnitConfigRoundingMode string + // BillingUsageBasedCharge A usage-based charge for a customer. type BillingUsageBasedCharge struct { // AdvanceAfter The earliest time when the charge should be advanced again by background diff --git a/api/v3/handlers/plans/convert.go b/api/v3/handlers/plans/convert.go index 497bf7273f..4a8be7667c 100644 --- a/api/v3/handlers/plans/convert.go +++ b/api/v3/handlers/plans/convert.go @@ -18,28 +18,6 @@ import ( "github.com/openmeterio/openmeter/pkg/models" ) -var unsupportedV3PriceTypes = map[productcatalog.PriceType]struct{}{ - productcatalog.DynamicPriceType: {}, - productcatalog.PackagePriceType: {}, -} - -func hasUnsupportedV3Price(p plan.Plan) bool { - for _, phase := range p.Phases { - for _, rc := range phase.RateCards { - price := rc.AsMeta().Price - if price == nil { - continue - } - - if _, unsupported := unsupportedV3PriceTypes[price.Type()]; unsupported { - return true - } - } - } - - return false -} - func ToAPIBillingPlan(p plan.Plan) (api.BillingPlan, error) { validationIssues, _ := p.AsProductCatalogPlan().ValidationErrors() @@ -175,6 +153,13 @@ func ToAPIBillingRateCard(rc productcatalog.RateCard) (api.BillingRateCard, erro result.Entitlement = ent } + unitConfig, err := ToAPIBillingRateCardUnitConfig(meta.Price) + if err != nil { + return result, fmt.Errorf("failed to convert unit config: %w", err) + } + + result.UnitConfig = unitConfig + return result, nil } @@ -240,6 +225,44 @@ func ToAPIBillingRateCardEntitlement(t *productcatalog.EntitlementTemplate) (*ap return out, nil } +// ToAPIBillingRateCardUnitConfig synthesizes a v3 unit config from a v1 dynamic +// or package price. v3 does not surface dynamic or package prices directly; +// instead they are rendered as a unit price paired with a unit config that +// describes the conversion that v1 applied implicitly. +func ToAPIBillingRateCardUnitConfig(p *productcatalog.Price) (*api.BillingUnitConfig, error) { + if p == nil { + return nil, nil + } + + switch p.Type() { + case productcatalog.DynamicPriceType: + dynamic, err := p.AsDynamic() + if err != nil { + return nil, fmt.Errorf("failed to read dynamic price: %w", err) + } + + return &api.BillingUnitConfig{ + Operation: api.BillingUnitConfigOperationMultiply, + ConversionFactor: dynamic.Multiplier.String(), + }, nil + + case productcatalog.PackagePriceType: + pkg, err := p.AsPackage() + if err != nil { + return nil, fmt.Errorf("failed to read package price: %w", err) + } + + return &api.BillingUnitConfig{ + Operation: api.BillingUnitConfigOperationDivide, + ConversionFactor: pkg.QuantityPerPackage.String(), + Rounding: lo.ToPtr(api.BillingUnitConfigRoundingModeCeiling), + }, nil + + default: + return nil, nil + } +} + func ToAPIBillingPrice(p *productcatalog.Price) (api.BillingPrice, error) { var result api.BillingPrice @@ -310,10 +333,29 @@ func ToAPIBillingPrice(p *productcatalog.Price) (api.BillingPrice, error) { } case productcatalog.DynamicPriceType: - return result, models.NewGenericConflictError(fmt.Errorf("dynamic price is not supported in v3 API")) + // Dynamic prices are surfaced in v3 as a unit price of amount 1; the + // multiplier is carried separately on the rate card's unit config. + if err := result.FromBillingPriceUnit(api.BillingPriceUnit{ + Amount: "1", + Type: api.BillingPriceUnitType("unit"), + }); err != nil { + return result, fmt.Errorf("failed to set unit price for dynamic price: %w", err) + } case productcatalog.PackagePriceType: - return result, models.NewGenericConflictError(fmt.Errorf("package price is not supported in v3 API")) + // Package prices are surfaced in v3 as a unit price; the package size + // is carried separately on the rate card's unit config. + pkg, err := p.AsPackage() + if err != nil { + return result, fmt.Errorf("failed to read package price: %w", err) + } + + if err = result.FromBillingPriceUnit(api.BillingPriceUnit{ + Amount: pkg.Amount.String(), + Type: api.BillingPriceUnitType("unit"), + }); err != nil { + return result, fmt.Errorf("failed to set unit price for package price: %w", err) + } default: return result, fmt.Errorf("unknown price type: %s", p.Type()) diff --git a/api/v3/handlers/plans/convert_test.go b/api/v3/handlers/plans/convert_test.go index 50008362a4..508bc10508 100644 --- a/api/v3/handlers/plans/convert_test.go +++ b/api/v3/handlers/plans/convert_test.go @@ -530,25 +530,199 @@ func TestFromBillingPrice(t *testing.T) { assert.Equal(t, "volume", disc) }) - t.Run("dynamic price returns conflict error", func(t *testing.T) { - p := productcatalog.NewPriceFrom(productcatalog.DynamicPrice{}) + t.Run("dynamic price translates to unit price of amount 1", func(t *testing.T) { + p := productcatalog.NewPriceFrom(productcatalog.DynamicPrice{ + Multiplier: decimal.NewFromFloat(1.2), + }) - _, err := ToAPIBillingPrice(p) - require.Error(t, err) - assert.True(t, models.IsGenericConflictError(err)) - assert.Contains(t, err.Error(), "dynamic price is not supported in v3 API") + result, err := ToAPIBillingPrice(p) + require.NoError(t, err) + + disc, err := result.Discriminator() + require.NoError(t, err) + assert.Equal(t, "unit", disc) + + unit, err := result.AsBillingPriceUnit() + require.NoError(t, err) + assert.Equal(t, api.Numeric("1"), unit.Amount) + }) + + t.Run("package price translates to unit price with package amount", func(t *testing.T) { + p := productcatalog.NewPriceFrom(productcatalog.PackagePrice{ + Amount: decimal.NewFromFloat(0.5), + QuantityPerPackage: decimal.NewFromInt(1000), + }) + + result, err := ToAPIBillingPrice(p) + require.NoError(t, err) + + disc, err := result.Discriminator() + require.NoError(t, err) + assert.Equal(t, "unit", disc) + + unit, err := result.AsBillingPriceUnit() + require.NoError(t, err) + assert.Equal(t, api.Numeric("0.5"), unit.Amount) + }) +} + +func TestToAPIBillingRateCardUnitConfig(t *testing.T) { + t.Run("nil price has no unit config", func(t *testing.T) { + result, err := ToAPIBillingRateCardUnitConfig(nil) + require.NoError(t, err) + assert.Nil(t, result) + }) + + t.Run("flat price has no unit config", func(t *testing.T) { + p := productcatalog.NewPriceFrom(productcatalog.FlatPrice{Amount: decimal.NewFromFloat(5)}) + + result, err := ToAPIBillingRateCardUnitConfig(p) + require.NoError(t, err) + assert.Nil(t, result) + }) + + t.Run("unit price has no unit config", func(t *testing.T) { + p := productcatalog.NewPriceFrom(productcatalog.UnitPrice{Amount: decimal.NewFromFloat(0.05)}) + + result, err := ToAPIBillingRateCardUnitConfig(p) + require.NoError(t, err) + assert.Nil(t, result) }) - t.Run("package price returns conflict error", func(t *testing.T) { + t.Run("dynamic price produces multiply unit config", func(t *testing.T) { + p := productcatalog.NewPriceFrom(productcatalog.DynamicPrice{ + Multiplier: decimal.NewFromFloat(1.2), + }) + + result, err := ToAPIBillingRateCardUnitConfig(p) + require.NoError(t, err) + require.NotNil(t, result) + assert.Equal(t, api.BillingUnitConfigOperationMultiply, result.Operation) + assert.Equal(t, api.Numeric("1.2"), result.ConversionFactor) + assert.Nil(t, result.Rounding) + assert.Nil(t, result.Precision) + assert.Nil(t, result.DisplayUnit) + }) + + t.Run("package price produces divide unit config with ceiling rounding", func(t *testing.T) { p := productcatalog.NewPriceFrom(productcatalog.PackagePrice{ Amount: decimal.NewFromFloat(10), - QuantityPerPackage: decimal.NewFromInt(100), + QuantityPerPackage: decimal.NewFromInt(1000), }) - _, err := ToAPIBillingPrice(p) - require.Error(t, err) - assert.True(t, models.IsGenericConflictError(err)) - assert.Contains(t, err.Error(), "package price is not supported in v3 API") + result, err := ToAPIBillingRateCardUnitConfig(p) + require.NoError(t, err) + require.NotNil(t, result) + assert.Equal(t, api.BillingUnitConfigOperationDivide, result.Operation) + assert.Equal(t, api.Numeric("1000"), result.ConversionFactor) + require.NotNil(t, result.Rounding) + assert.Equal(t, api.BillingUnitConfigRoundingModeCeiling, *result.Rounding) + }) +} + +func TestFromRateCard_DynamicAndPackagePrices(t *testing.T) { + cadence, err := datetime.ISODurationString("P1M").Parse() + require.NoError(t, err) + + t.Run("dynamic price renders as unit price plus multiply unit config and preserves commitments", func(t *testing.T) { + minAmt := decimal.NewFromFloat(10) + maxAmt := decimal.NewFromFloat(100) + price := productcatalog.NewPriceFrom(productcatalog.DynamicPrice{ + Multiplier: decimal.NewFromFloat(1.2), + Commitments: productcatalog.Commitments{ + MinimumAmount: &minAmt, + MaximumAmount: &maxAmt, + }, + }) + + rc := &productcatalog.UsageBasedRateCard{ + RateCardMeta: productcatalog.RateCardMeta{ + Key: "tokens", + Name: "Tokens", + Price: price, + }, + BillingCadence: cadence, + } + + result, err := ToAPIBillingRateCard(rc) + require.NoError(t, err) + + disc, err := result.Price.Discriminator() + require.NoError(t, err) + assert.Equal(t, "unit", disc) + + unit, err := result.Price.AsBillingPriceUnit() + require.NoError(t, err) + assert.Equal(t, api.Numeric("1"), unit.Amount) + + require.NotNil(t, result.UnitConfig) + assert.Equal(t, api.BillingUnitConfigOperationMultiply, result.UnitConfig.Operation) + assert.Equal(t, api.Numeric("1.2"), result.UnitConfig.ConversionFactor) + assert.Nil(t, result.UnitConfig.Rounding) + + require.NotNil(t, result.Commitments) + assert.Equal(t, lo.ToPtr(api.Numeric("10")), result.Commitments.MinimumAmount) + assert.Equal(t, lo.ToPtr(api.Numeric("100")), result.Commitments.MaximumAmount) + }) + + t.Run("package price renders as unit price plus divide unit config and preserves commitments", func(t *testing.T) { + minAmt := decimal.NewFromFloat(5) + price := productcatalog.NewPriceFrom(productcatalog.PackagePrice{ + Amount: decimal.NewFromFloat(0.5), + QuantityPerPackage: decimal.NewFromInt(1000), + Commitments: productcatalog.Commitments{ + MinimumAmount: &minAmt, + }, + }) + + rc := &productcatalog.UsageBasedRateCard{ + RateCardMeta: productcatalog.RateCardMeta{ + Key: "api-calls", + Name: "API Calls", + Price: price, + }, + BillingCadence: cadence, + } + + result, err := ToAPIBillingRateCard(rc) + require.NoError(t, err) + + disc, err := result.Price.Discriminator() + require.NoError(t, err) + assert.Equal(t, "unit", disc) + + unit, err := result.Price.AsBillingPriceUnit() + require.NoError(t, err) + assert.Equal(t, api.Numeric("0.5"), unit.Amount) + + require.NotNil(t, result.UnitConfig) + assert.Equal(t, api.BillingUnitConfigOperationDivide, result.UnitConfig.Operation) + assert.Equal(t, api.Numeric("1000"), result.UnitConfig.ConversionFactor) + require.NotNil(t, result.UnitConfig.Rounding) + assert.Equal(t, api.BillingUnitConfigRoundingModeCeiling, *result.UnitConfig.Rounding) + + require.NotNil(t, result.Commitments) + assert.Equal(t, lo.ToPtr(api.Numeric("5")), result.Commitments.MinimumAmount) + assert.Nil(t, result.Commitments.MaximumAmount) + }) + + t.Run("unit price has no unit config on rate card", func(t *testing.T) { + price := productcatalog.NewPriceFrom(productcatalog.UnitPrice{ + Amount: decimal.NewFromFloat(0.05), + }) + + rc := &productcatalog.UsageBasedRateCard{ + RateCardMeta: productcatalog.RateCardMeta{ + Key: "api-calls", + Name: "API Calls", + Price: price, + }, + BillingCadence: cadence, + } + + result, err := ToAPIBillingRateCard(rc) + require.NoError(t, err) + assert.Nil(t, result.UnitConfig) }) } diff --git a/api/v3/handlers/plans/list.go b/api/v3/handlers/plans/list.go index 0829c64e00..0f664a7fc6 100644 --- a/api/v3/handlers/plans/list.go +++ b/api/v3/handlers/plans/list.go @@ -111,11 +111,6 @@ func (h *handler) ListPlans() ListPlansHandler { items := make([]api.BillingPlan, 0, len(result.Items)) for _, p := range result.Items { - // FIXME: For now we skip plans containing price types not representable in v3 (e.g., package, dynamic). We'll add full bidirectional transform later on. - if hasUnsupportedV3Price(p) { - continue - } - billingPlan, err := ToAPIBillingPlan(p) if err != nil { return ListPlansResponse{}, err diff --git a/api/v3/openapi.yaml b/api/v3/openapi.yaml index ac51ae1cc5..e68d897e14 100644 --- a/api/v3/openapi.yaml +++ b/api/v3/openapi.yaml @@ -5800,6 +5800,18 @@ components: - $ref: '#/components/schemas/BillingPrice' description: The price of the rate card. title: Price + unit_config: + allOf: + - $ref: '#/components/schemas/BillingUnitConfig' + description: |- + Unit conversion configuration for the rate card. + + Synthesized on read for plans authored with v1 dynamic or package prices: + dynamic prices map to a unit price with a multiply unit config, and package + prices map to a unit price with a divide unit config. Not yet accepted on create + or update. + title: Unit config + readOnly: true payment_term: allOf: - $ref: '#/components/schemas/BillingPricePaymentTerm' @@ -6585,6 +6597,108 @@ components: readOnly: true additionalProperties: false description: Totals contains the summaries of all calculations for a billing resource. + BillingUnitConfig: + type: object + required: + - operation + - conversion_factor + properties: + operation: + allOf: + - $ref: '#/components/schemas/BillingUnitConfigOperation' + description: The arithmetic operation to apply to the raw metered quantity. + title: Conversion operation + conversion_factor: + allOf: + - $ref: '#/components/schemas/Numeric' + description: |- + The factor used in the conversion operation. + + - For `divide`: `converted = raw / conversionFactor`. + - For `multiply`: `converted = raw × conversionFactor`. + + Must be a positive non-zero value. + title: Conversion factor + rounding: + allOf: + - $ref: '#/components/schemas/BillingUnitConfigRoundingMode' + description: |- + The rounding mode applied to the converted quantity for invoicing. + + Defaults to none (no rounding). Entitlement checks always use the precise + (unrounded) value. + title: Rounding mode + default: none + precision: + type: integer + description: |- + The number of decimal places to retain after rounding. + + Only meaningful when rounding is not "none". Defaults to 0 (round to whole + numbers). + title: Rounding precision (decimal places) + default: 0 + display_unit: + type: string + description: |- + A human-readable label for the converted unit shown on invoices and in the + customer portal (e.g., "GB", "hours", "M tokens"). + + Optional. When omitted, no unit label is rendered. + title: Display unit label + additionalProperties: false + description: |- + Unit conversion configuration. + + Transforms raw metered quantities into billing-ready units before pricing and + entitlement evaluation. Applied at the rate card level so the same feature can + be billed in different units across plans. + + Examples: + + - Meter bytes, bill GB: operation=divide, conversionFactor=1e9, + rounding=ceiling, displayUnit="GB" + - Meter seconds, bill hours: operation=divide, conversionFactor=3600, + rounding=ceiling, displayUnit="hours" + - Cost + 20% margin: operation=multiply, conversionFactor=1.2 + - Bill per million tokens: operation=divide, conversionFactor=1e6, + rounding=ceiling, displayUnit="M" + + v1 equivalents: + + - DynamicPrice(multiplier): operation=multiply, conversionFactor=multiplier + + UnitPrice(amount=1) + - PackagePrice(amount, quantityPerPkg): operation=divide, + conversionFactor=quantityPerPkg, rounding=ceiling + UnitPrice(amount) + BillingUnitConfigOperation: + type: string + enum: + - divide + - multiply + description: |- + The arithmetic operation used to convert raw metered units into billing units. + + - `divide`: Divide the metered quantity by the conversion factor (e.g., bytes ÷ + 1e9 = GB). + - `multiply`: Multiply the metered quantity by the conversion factor (e.g., cost + × 1.2 = cost + 20% margin). + BillingUnitConfigRoundingMode: + type: string + enum: + - ceiling + - floor + - half_up + - none + description: |- + The rounding mode applied to the converted quantity for invoicing. + + Rounding is applied only to the invoiced quantity. Entitlement balance checks + use the precise decimal value after conversion. + + - `ceiling`: Round up to the next integer (typical for package-style billing). + - `floor`: Round down to the previous integer. + - `half_up`: Round to the nearest integer, with 0.5 rounding up. + - `none`: No rounding; the converted value is used as-is. BillingUsageBasedCharge: type: object required: diff --git a/e2e/plans_v3_test.go b/e2e/plans_v3_test.go index 9d8a3e1f80..452fc3d586 100644 --- a/e2e/plans_v3_test.go +++ b/e2e/plans_v3_test.go @@ -4,9 +4,11 @@ import ( "net/http" "testing" + "github.com/samber/lo" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" + api "github.com/openmeterio/openmeter/api/client/go" apiv3 "github.com/openmeterio/openmeter/api/v3" ) @@ -443,3 +445,194 @@ func TestV3PlanInvalidCurrency(t *testing.T) { assert.Equal(t, http.StatusBadRequest, status, "problem: %+v", problem) assertValidationCode(t, problem, "currency_invalid") } + +// TestV3PlanReadTranslatesV1DynamicAndPackagePrices verifies the v3 read-side +// translation of v1 dynamic and package prices into a unit price plus a +// synthesized unit_config on the rate card. +// +// Mapping (api/v3/handlers/plans/convert.go): +// - dynamic(multiplier=m) → unit(amount=1) + unit_config{operation=multiply, conversion_factor=m} +// - package(amount=a, qpp=q) → unit(amount=a) + unit_config{operation=divide, conversion_factor=q, rounding=ceiling} +// +// Spend commitments (min/max amount) carried on the v1 price flow through to +// the v3 rate card's commitments field unchanged. +// +// The plan is authored via the v1 SDK and read via v3 GET and v3 LIST. The +// unit_config field is read-only on v3, so this test does not exercise a v3 +// write path for it. +func TestV3PlanReadTranslatesV1DynamicAndPackagePrices(t *testing.T) { + v1 := initClient(t) + v3 := newV3Client(t) + + suffix := uniqueKey("v3_translates_v1") + planKey := suffix + dynamicRCKey := "dynamic_rc_" + suffix + packageRCKey := "package_rc_" + suffix + + dynamicPrice := api.RateCardUsageBasedPrice{} + require.NoError(t, dynamicPrice.FromDynamicPriceWithCommitments(api.DynamicPriceWithCommitments{ + Type: api.DynamicPriceWithCommitmentsTypeDynamic, + Multiplier: lo.ToPtr(api.Numeric("1.2")), + MinimumAmount: lo.ToPtr(api.Numeric("10")), + MaximumAmount: lo.ToPtr(api.Numeric("100")), + })) + + dynamicRC := api.RateCard{} + require.NoError(t, dynamicRC.FromRateCardUsageBased(api.RateCardUsageBased{ + Type: api.RateCardUsageBasedTypeUsageBased, + Name: "Dynamic RC", + Key: dynamicRCKey, + BillingCadence: "P1M", + Price: &dynamicPrice, + })) + + packagePrice := api.RateCardUsageBasedPrice{} + require.NoError(t, packagePrice.FromPackagePriceWithCommitments(api.PackagePriceWithCommitments{ + Type: api.PackagePriceWithCommitmentsTypePackage, + Amount: "0.5", + QuantityPerPackage: "1000", + MinimumAmount: lo.ToPtr(api.Numeric("5")), + })) + + packageRC := api.RateCard{} + require.NoError(t, packageRC.FromRateCardUsageBased(api.RateCardUsageBased{ + Type: api.RateCardUsageBasedTypeUsageBased, + Name: "Package RC", + Key: packageRCKey, + BillingCadence: "P1M", + Price: &packagePrice, + })) + + planCreate := api.PlanCreate{ + Currency: api.CurrencyCode("USD"), + Name: "v1 Plan with Dynamic and Package Prices", + Key: planKey, + BillingCadence: "P1M", + Phases: []api.PlanPhase{ + { + Name: "Phase 1", + Key: "phase_1_" + suffix, + RateCards: []api.RateCard{dynamicRC, packageRC}, + }, + }, + } + + var planID string + + t.Run("Should create the v1 plan with dynamic and package rate cards", func(t *testing.T) { + resp, err := v1.CreatePlanWithResponse(t.Context(), planCreate) + require.NoError(t, err) + require.Equal(t, http.StatusCreated, resp.StatusCode(), "body: %s", resp.Body) + require.NotNil(t, resp.JSON201) + + planID = resp.JSON201.Id + }) + + t.Run("v3 GET should translate dynamic price to unit + multiply unit_config", func(t *testing.T) { + require.NotEmpty(t, planID) + + status, plan, problem := v3.GetPlan(planID) + require.Equal(t, http.StatusOK, status, "problem: %+v", problem) + require.NotNil(t, plan) + + rc := findRateCardByKey(t, plan, dynamicRCKey) + + assertUnitPriceAmount(t, rc, "1") + + require.NotNil(t, rc.UnitConfig, "expected synthesized unit_config") + assert.Equal(t, apiv3.BillingUnitConfigOperationMultiply, rc.UnitConfig.Operation) + assert.Equal(t, apiv3.Numeric("1.2"), rc.UnitConfig.ConversionFactor) + assert.Nil(t, rc.UnitConfig.Rounding, "dynamic translation does not set rounding") + + require.NotNil(t, rc.Commitments, "v1 commitments should round-trip via v3") + assert.Equal(t, lo.ToPtr(apiv3.Numeric("10")), rc.Commitments.MinimumAmount) + assert.Equal(t, lo.ToPtr(apiv3.Numeric("100")), rc.Commitments.MaximumAmount) + }) + + t.Run("v3 GET should translate package price to unit + divide+ceiling unit_config", func(t *testing.T) { + require.NotEmpty(t, planID) + + status, plan, problem := v3.GetPlan(planID) + require.Equal(t, http.StatusOK, status, "problem: %+v", problem) + require.NotNil(t, plan) + + rc := findRateCardByKey(t, plan, packageRCKey) + + assertUnitPriceAmount(t, rc, "0.5") + + require.NotNil(t, rc.UnitConfig, "expected synthesized unit_config") + assert.Equal(t, apiv3.BillingUnitConfigOperationDivide, rc.UnitConfig.Operation) + assert.Equal(t, apiv3.Numeric("1000"), rc.UnitConfig.ConversionFactor) + require.NotNil(t, rc.UnitConfig.Rounding, "package translation must set rounding=ceiling") + assert.Equal(t, apiv3.BillingUnitConfigRoundingModeCeiling, *rc.UnitConfig.Rounding) + + require.NotNil(t, rc.Commitments, "v1 commitments should round-trip via v3") + assert.Equal(t, lo.ToPtr(apiv3.Numeric("5")), rc.Commitments.MinimumAmount) + assert.Nil(t, rc.Commitments.MaximumAmount) + }) + + t.Run("v3 LIST should include the plan with both rate cards translated", func(t *testing.T) { + require.NotEmpty(t, planID) + + // Bump page size so a fresh fixture isn't pushed off page 1 on a shared DB. + status, page, problem := v3.ListPlans(withPageSize(1000)) + require.Equal(t, http.StatusOK, status, "problem: %+v", problem) + require.NotNil(t, page) + + var found *apiv3.BillingPlan + for i := range page.Data { + if page.Data[i].Id == planID { + found = &page.Data[i] + break + } + } + require.NotNil(t, found, "created plan not in list response (the v3 list handler should no longer skip plans with v1 dynamic/package prices)") + + dynRC := findRateCardByKey(t, found, dynamicRCKey) + assertUnitPriceAmount(t, dynRC, "1") + require.NotNil(t, dynRC.UnitConfig) + assert.Equal(t, apiv3.BillingUnitConfigOperationMultiply, dynRC.UnitConfig.Operation) + assert.Equal(t, apiv3.Numeric("1.2"), dynRC.UnitConfig.ConversionFactor) + + pkgRC := findRateCardByKey(t, found, packageRCKey) + assertUnitPriceAmount(t, pkgRC, "0.5") + require.NotNil(t, pkgRC.UnitConfig) + assert.Equal(t, apiv3.BillingUnitConfigOperationDivide, pkgRC.UnitConfig.Operation) + assert.Equal(t, apiv3.Numeric("1000"), pkgRC.UnitConfig.ConversionFactor) + require.NotNil(t, pkgRC.UnitConfig.Rounding) + assert.Equal(t, apiv3.BillingUnitConfigRoundingModeCeiling, *pkgRC.UnitConfig.Rounding) + }) +} + +// findRateCardByKey looks up a rate card by key across all phases of a plan. +// Fails the test if no match is found. +func findRateCardByKey(t *testing.T, plan *apiv3.BillingPlan, key string) *apiv3.BillingRateCard { + t.Helper() + + for i := range plan.Phases { + for j := range plan.Phases[i].RateCards { + rc := &plan.Phases[i].RateCards[j] + if rc.Key == key { + return rc + } + } + } + + require.FailNow(t, "rate card not found", "key=%s", key) + return nil +} + +// assertUnitPriceAmount asserts the rate card's price discriminates as "unit" +// and carries the given amount. Used to verify the synthesized unit price that +// replaces v1 dynamic and package prices on the v3 read path. +func assertUnitPriceAmount(t *testing.T, rc *apiv3.BillingRateCard, want string) { + t.Helper() + + disc, err := rc.Price.Discriminator() + require.NoError(t, err) + require.Equal(t, "unit", disc, "expected synthesized unit price") + + unit, err := rc.Price.AsBillingPriceUnit() + require.NoError(t, err) + assert.Equal(t, want, unit.Amount) +} From 76ec009d85581a7b70a4dbbcdbe75f66715717fb Mon Sep 17 00:00:00 2001 From: Andras Toth <4157749+tothandras@users.noreply.github.com> Date: Tue, 12 May 2026 11:28:23 +0200 Subject: [PATCH 2/4] fix: rate card reject unit config --- api/v3/handlers/plans/convert.go | 8 ++++++++ api/v3/handlers/plans/convert_test.go | 25 +++++++++++++++++++++++++ 2 files changed, 33 insertions(+) diff --git a/api/v3/handlers/plans/convert.go b/api/v3/handlers/plans/convert.go index 4a8be7667c..45b6dad838 100644 --- a/api/v3/handlers/plans/convert.go +++ b/api/v3/handlers/plans/convert.go @@ -601,6 +601,14 @@ func FromAPIBillingPlanPhase(p api.BillingPlanPhase) (productcatalog.Phase, erro } func FromAPIBillingRateCard(rc api.BillingRateCard) (productcatalog.RateCard, error) { + // unit_config is read-only: it is synthesized from v1 dynamic and package + // prices on the response path. Accepting it on create/update would silently + // drop the original v1 price semantics, so reject it explicitly until v3 + // authoring is designed. + if rc.UnitConfig != nil { + return nil, models.NewGenericValidationError(fmt.Errorf("unit_config is not accepted on create or update for rate card %q", rc.Key)) + } + priceType, err := rc.Price.Discriminator() if err != nil { return nil, fmt.Errorf("failed to read price type: %w", err) diff --git a/api/v3/handlers/plans/convert_test.go b/api/v3/handlers/plans/convert_test.go index 508bc10508..4148fff781 100644 --- a/api/v3/handlers/plans/convert_test.go +++ b/api/v3/handlers/plans/convert_test.go @@ -1301,6 +1301,31 @@ func TestToRateCard(t *testing.T) { require.NoError(t, err) assert.Equal(t, productcatalog.VolumeTieredPrice, tiered.Mode) }) + + t.Run("rejects unit_config on create/update", func(t *testing.T) { + var price api.BillingPrice + require.NoError(t, price.FromBillingPriceUnit(api.BillingPriceUnit{Amount: "1", Type: "unit"})) + + bc := api.ISO8601Duration("P1M") + + rc := api.BillingRateCard{ + Key: "tokens", + Name: "Tokens", + Price: price, + BillingCadence: &bc, + UnitConfig: &api.BillingUnitConfig{ + Operation: api.BillingUnitConfigOperationMultiply, + ConversionFactor: "1.2", + }, + } + + _, err := FromAPIBillingRateCard(rc) + require.Error(t, err) + var validationErr *models.GenericValidationError + assert.ErrorAs(t, err, &validationErr) + assert.Contains(t, err.Error(), "unit_config") + assert.Contains(t, err.Error(), "tokens") + }) } func TestToBillingPrice(t *testing.T) { From 3fce0ba3aa214c3515db6e38b2719fc7e7eef78d Mon Sep 17 00:00:00 2001 From: rolosp <6114043+rolosp@users.noreply.github.com> Date: Tue, 12 May 2026 15:20:40 +0200 Subject: [PATCH 3/4] test: moved the find ratecard by key util to the helpers --- e2e/plans_v3_test.go | 33 --------------------------------- e2e/v3helpers_test.go | 33 +++++++++++++++++++++++++++++++++ 2 files changed, 33 insertions(+), 33 deletions(-) diff --git a/e2e/plans_v3_test.go b/e2e/plans_v3_test.go index 452fc3d586..abe4f86c45 100644 --- a/e2e/plans_v3_test.go +++ b/e2e/plans_v3_test.go @@ -603,36 +603,3 @@ func TestV3PlanReadTranslatesV1DynamicAndPackagePrices(t *testing.T) { assert.Equal(t, apiv3.BillingUnitConfigRoundingModeCeiling, *pkgRC.UnitConfig.Rounding) }) } - -// findRateCardByKey looks up a rate card by key across all phases of a plan. -// Fails the test if no match is found. -func findRateCardByKey(t *testing.T, plan *apiv3.BillingPlan, key string) *apiv3.BillingRateCard { - t.Helper() - - for i := range plan.Phases { - for j := range plan.Phases[i].RateCards { - rc := &plan.Phases[i].RateCards[j] - if rc.Key == key { - return rc - } - } - } - - require.FailNow(t, "rate card not found", "key=%s", key) - return nil -} - -// assertUnitPriceAmount asserts the rate card's price discriminates as "unit" -// and carries the given amount. Used to verify the synthesized unit price that -// replaces v1 dynamic and package prices on the v3 read path. -func assertUnitPriceAmount(t *testing.T, rc *apiv3.BillingRateCard, want string) { - t.Helper() - - disc, err := rc.Price.Discriminator() - require.NoError(t, err) - require.Equal(t, "unit", disc, "expected synthesized unit price") - - unit, err := rc.Price.AsBillingPriceUnit() - require.NoError(t, err) - assert.Equal(t, want, unit.Amount) -} diff --git a/e2e/v3helpers_test.go b/e2e/v3helpers_test.go index aba9583ad0..b9c0a95a64 100644 --- a/e2e/v3helpers_test.go +++ b/e2e/v3helpers_test.go @@ -542,3 +542,36 @@ func assertInvalidParameterRule(t *testing.T, problem *v3Problem, rule string) { } assert.Failf(t, "invalid parameter rule not found", "expected %q, got %v", rule, rules) } + +// findRateCardByKey looks up a rate card by key across all phases of a plan. +// Fails the test if no match is found. +func findRateCardByKey(t *testing.T, plan *apiv3.BillingPlan, key string) *apiv3.BillingRateCard { + t.Helper() + + for i := range plan.Phases { + for j := range plan.Phases[i].RateCards { + rc := &plan.Phases[i].RateCards[j] + if rc.Key == key { + return rc + } + } + } + + require.FailNow(t, "rate card not found", "key=%s", key) + return nil +} + +// assertUnitPriceAmount asserts the rate card's price discriminates as "unit" +// and carries the given amount. Used to verify the synthesized unit price that +// replaces v1 dynamic and package prices on the v3 read path. +func assertUnitPriceAmount(t *testing.T, rc *apiv3.BillingRateCard, want string) { + t.Helper() + + disc, err := rc.Price.Discriminator() + require.NoError(t, err) + require.Equal(t, "unit", disc, "expected synthesized unit price") + + unit, err := rc.Price.AsBillingPriceUnit() + require.NoError(t, err) + assert.Equal(t, want, unit.Amount) +} From c24bcf80b89f40c81bf6c298689a3ac82dce009f Mon Sep 17 00:00:00 2001 From: rolosp <6114043+rolosp@users.noreply.github.com> Date: Wed, 17 Jun 2026 11:51:36 +0200 Subject: [PATCH 4/4] chore: updated generated types --- .../aip-client-javascript/src/index.ts | 6 +- .../src/models/schemas.ts | 107 +- .../aip-client-javascript/src/models/types.ts | 62 +- api/v3/api.gen.go | 1356 +++++++++-------- 4 files changed, 777 insertions(+), 754 deletions(-) diff --git a/api/spec/packages/aip-client-javascript/src/index.ts b/api/spec/packages/aip-client-javascript/src/index.ts index bb75327ab7..c98459f5f9 100644 --- a/api/spec/packages/aip-client-javascript/src/index.ts +++ b/api/spec/packages/aip-client-javascript/src/index.ts @@ -176,10 +176,10 @@ export type { ListCurrenciesParamsFilter, CurrencyCustom, CreateCurrencyCustomRequest, + UnitConfig, GovernanceQueryRequest, GovernanceFeatureAccessReason, GovernanceQueryError, - UnitConfig, AppCustomerData, UpsertAppCustomerDataRequest, CreditAdjustment, @@ -233,8 +233,8 @@ export type { CreateTaxCodeRequest, TaxCode, UpsertTaxCodeRequest, - GovernanceFeatureAccess, InvoiceUsageQuantityDetail, + GovernanceFeatureAccess, CustomerData, UpsertCustomerBillingDataRequest, CreditBalances, @@ -309,8 +309,8 @@ export type { CreateCreditGrantPurchaseInput, RateCardMeteredEntitlementInput, CreditGrantPurchaseInput, - GovernanceQueryRequestInput, UnitConfigInput, + GovernanceQueryRequestInput, IngestedEventInput, SubscriptionCancelInput, InvoiceUsageQuantityDetailInput, diff --git a/api/spec/packages/aip-client-javascript/src/models/schemas.ts b/api/spec/packages/aip-client-javascript/src/models/schemas.ts index 553c396d75..1ad2d68be3 100644 --- a/api/spec/packages/aip-client-javascript/src/models/schemas.ts +++ b/api/spec/packages/aip-client-javascript/src/models/schemas.ts @@ -812,6 +812,20 @@ export const planStatus = z 'The status of a plan. - `draft`: The plan has not yet been published and can be edited. - `active`: The plan is published and can be used in subscriptions. - `archived`: The plan is no longer available for use. - `scheduled`: The plan is scheduled to be published at a future date.', ) +export const unitConfigOperation = z + .enum(['divide', 'multiply']) + + .describe( + 'The arithmetic operation used to convert raw metered units into billing units. - `divide`: Divide the metered quantity by the conversion factor (e.g., bytes ÷ 1e9 = GB). - `multiply`: Multiply the metered quantity by the conversion factor (e.g., cost × 1.2 = cost + 20% margin).', + ) + +export const unitConfigRoundingMode = z + .enum(['ceiling', 'floor', 'half_up', 'none']) + + .describe( + 'The rounding mode applied to the converted quantity for invoicing. Rounding is applied only to the invoiced quantity. Entitlement balance checks use the precise decimal value after conversion. - `ceiling`: Round up to the next integer (typical for package-style billing). - `floor`: Round down to the previous integer. - `half_up`: Round to the nearest integer, with 0.5 rounding up. - `none`: No rounding; the converted value is used as-is.', + ) + export const rateCardStaticEntitlement = z .object({ type: z.literal('static').describe('The type of the entitlement template.'), @@ -1128,20 +1142,6 @@ export const collectionMethod = z 'Collection method specifies how the invoice should be collected (automatic or manual).', ) -export const unitConfigOperation = z - .enum(['divide', 'multiply']) - - .describe( - 'The arithmetic operation used to convert raw metered units into billing units. - `divide`: Divide the metered quantity by the conversion factor (e.g., bytes ÷ 1e9 = GB). - `multiply`: Multiply the metered quantity by the conversion factor (e.g., cost × 1.2 = cost + 20% margin).', - ) - -export const unitConfigRoundingMode = z - .enum(['ceiling', 'floor', 'half_up', 'none']) - - .describe( - 'The rounding mode applied to the converted quantity for invoicing. Rounding is applied only to the invoiced quantity. Entitlement balance checks use the precise decimal value after conversion. - `ceiling`: Round up to the next integer (typical for package-style billing). - `floor`: Round down to the previous integer. - `half_up`: Round to the nearest integer, with 0.5 rounding up. - `none`: No rounding; the converted value is used as-is.', - ) - export const priceType = z .enum(['free', 'flat', 'unit', 'graduated', 'volume']) @@ -2589,6 +2589,33 @@ export const createCurrencyCustomRequest = z }) .describe('CurrencyCustom create request.') +export const unitConfig = z + .object({ + operation: unitConfigOperation, + conversion_factor: numeric, + rounding: unitConfigRoundingMode.optional().default('none'), + precision: z + .number() + .int() + .optional() + .default(0) + + .describe( + 'The number of decimal places to retain after rounding. Only meaningful when rounding is not "none". Defaults to 0 (round to whole numbers).', + ), + display_unit: z + .string() + .optional() + + .describe( + 'A human-readable label for the converted unit shown on invoices and in the customer portal (e.g., "GB", "hours", "M tokens"). Optional. When omitted, no unit label is rendered.', + ), + }) + + .describe( + 'Unit conversion configuration. Transforms raw metered quantities into billing-ready units before pricing and entitlement evaluation. Applied at the rate card level so the same feature can be billed in different units across plans. Examples: - Meter bytes, bill GB: operation=divide, conversionFactor=1e9, rounding=ceiling, displayUnit="GB" - Meter seconds, bill hours: operation=divide, conversionFactor=3600, rounding=ceiling, displayUnit="hours" - Cost + 20% margin: operation=multiply, conversionFactor=1.2 - Bill per million tokens: operation=divide, conversionFactor=1e6, rounding=ceiling, displayUnit="M" v1 equivalents: - DynamicPrice(multiplier): operation=multiply, conversionFactor=multiplier + UnitPrice(amount=1) - PackagePrice(amount, quantityPerPkg): operation=divide, conversionFactor=quantityPerPkg, rounding=ceiling + UnitPrice(amount)', + ) + export const governanceQueryRequest = z .object({ include_credits: z @@ -2636,33 +2663,6 @@ export const governanceQueryError = z 'Query error within a partially successful governance query response.', ) -export const unitConfig = z - .object({ - operation: unitConfigOperation, - conversion_factor: numeric, - rounding: unitConfigRoundingMode.optional().default('none'), - precision: z - .number() - .int() - .optional() - .default(0) - - .describe( - 'The number of decimal places to retain after rounding. Only meaningful when rounding is not "none". Defaults to 0 (round to whole numbers).', - ), - display_unit: z - .string() - .optional() - - .describe( - 'A human-readable label for the converted unit shown on invoices and in the customer portal (e.g., "GB", "hours", "M tokens"). Optional. When omitted, no unit label is rendered.', - ), - }) - - .describe( - 'Unit conversion configuration. Transforms raw metered quantities into billing-ready units before pricing and entitlement evaluation. Applied at the rate card level so the same feature can be billed in different units across plans. Examples: - Meter bytes, bill GB: operation=divide, conversionFactor=1e9, rounding=ceiling, displayUnit="GB" - Meter seconds, bill hours: operation=divide, conversionFactor=3600, rounding=ceiling, displayUnit="hours" - Cost + 20% margin: operation=multiply, conversionFactor=1.2 - Bill per million tokens: operation=divide, conversionFactor=1e6, rounding=ceiling, displayUnit="M" v1 equivalents: - DynamicPrice(multiplier): operation=multiply, conversionFactor=multiplier + UnitPrice(amount=1) - PackagePrice(amount, quantityPerPkg): operation=divide, conversionFactor=quantityPerPkg, rounding=ceiling + UnitPrice(amount)', - ) - export const appCustomerData = z .object({ stripe: appCustomerDataStripe.optional(), @@ -3571,18 +3571,6 @@ export const currency = z .discriminatedUnion('type', [currencyFiat, currencyCustom]) .describe('Fiat or custom currency.') -export const governanceFeatureAccess = z - .object({ - has_access: z - .boolean() - - .describe( - '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.', - ), - reason: governanceFeatureAccessReason.optional(), - }) - .describe('Access status for a single feature.') - export const invoiceUsageQuantityDetail = z .object({ raw_quantity: numeric, @@ -3600,6 +3588,18 @@ export const invoiceUsageQuantityDetail = z 'Usage quantity details on an invoice line item when UnitConfig is in effect. Provides the full audit trail from raw meter output to the invoiced amount.', ) +export const governanceFeatureAccess = z + .object({ + has_access: z + .boolean() + + .describe( + '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.', + ), + reason: governanceFeatureAccessReason.optional(), + }) + .describe('Access status for a single feature.') + export const customerData = z .object({ billing_profile: profileReference.optional(), @@ -4313,6 +4313,7 @@ export const rateCard = z feature: featureReference.optional(), billing_cadence: iso8601Duration.optional(), price: price, + unit_config: unitConfig.optional(), payment_term: pricePaymentTerm.optional().default('in_arrears'), commitments: spendCommitments.optional(), discounts: rateCardDiscounts.optional(), diff --git a/api/spec/packages/aip-client-javascript/src/models/types.ts b/api/spec/packages/aip-client-javascript/src/models/types.ts index 6fc8b1777b..1b8ab146ac 100644 --- a/api/spec/packages/aip-client-javascript/src/models/types.ts +++ b/api/spec/packages/aip-client-javascript/src/models/types.ts @@ -1412,6 +1412,20 @@ export interface CreateCurrencyCustomRequest { code: string } +/** Unit conversion configuration. Transforms raw metered quantities into billing-ready units before pricing and entitlement evaluation. Applied at the rate card level so the same feature can be billed in different units across plans. Examples: - Meter bytes, bill GB: operation=divide, conversionFactor=1e9, rounding=ceiling, displayUnit="GB" - Meter seconds, bill hours: operation=divide, conversionFactor=3600, rounding=ceiling, displayUnit="hours" - Cost + 20% margin: operation=multiply, conversionFactor=1.2 - Bill per million tokens: operation=divide, conversionFactor=1e6, rounding=ceiling, displayUnit="M" v1 equivalents: - DynamicPrice(multiplier): operation=multiply, conversionFactor=multiplier + UnitPrice(amount=1) - PackagePrice(amount, quantityPerPkg): operation=divide, conversionFactor=quantityPerPkg, rounding=ceiling + UnitPrice(amount) */ +export interface UnitConfig { + /** The arithmetic operation to apply to the raw metered quantity. */ + operation: 'divide' | 'multiply' + /** The factor used in the conversion operation. - For `divide`: `converted = raw / conversionFactor`. - For `multiply`: `converted = raw × conversionFactor`. Must be a positive non-zero value. */ + conversion_factor: string + /** The rounding mode applied to the converted quantity for invoicing. Defaults to none (no rounding). Entitlement checks always use the precise (unrounded) value. */ + rounding: 'ceiling' | 'floor' | 'half_up' | 'none' + /** The number of decimal places to retain after rounding. Only meaningful when rounding is not "none". Defaults to 0 (round to whole numbers). */ + precision: number + /** A human-readable label for the converted unit shown on invoices and in the customer portal (e.g., "GB", "hours", "M tokens"). Optional. When omitted, no unit label is rendered. */ + display_unit?: string +} + /** Query to evaluate feature access for a list of customers. */ export interface GovernanceQueryRequest { /** Whether to include credit balance availability for each resolved customer. When true, each feature evaluation includes credit balance checks. Defaults to `false`. */ @@ -1447,20 +1461,6 @@ export interface GovernanceQueryError { customer?: string } -/** Unit conversion configuration. Transforms raw metered quantities into billing-ready units before pricing and entitlement evaluation. Applied at the rate card level so the same feature can be billed in different units across plans. Examples: - Meter bytes, bill GB: operation=divide, conversionFactor=1e9, rounding=ceiling, displayUnit="GB" - Meter seconds, bill hours: operation=divide, conversionFactor=3600, rounding=ceiling, displayUnit="hours" - Cost + 20% margin: operation=multiply, conversionFactor=1.2 - Bill per million tokens: operation=divide, conversionFactor=1e6, rounding=ceiling, displayUnit="M" v1 equivalents: - DynamicPrice(multiplier): operation=multiply, conversionFactor=multiplier + UnitPrice(amount=1) - PackagePrice(amount, quantityPerPkg): operation=divide, conversionFactor=quantityPerPkg, rounding=ceiling + UnitPrice(amount) */ -export interface UnitConfig { - /** The arithmetic operation to apply to the raw metered quantity. */ - operation: 'divide' | 'multiply' - /** The factor used in the conversion operation. - For `divide`: `converted = raw / conversionFactor`. - For `multiply`: `converted = raw × conversionFactor`. Must be a positive non-zero value. */ - conversion_factor: string - /** The rounding mode applied to the converted quantity for invoicing. Defaults to none (no rounding). Entitlement checks always use the precise (unrounded) value. */ - rounding: 'ceiling' | 'floor' | 'half_up' | 'none' - /** The number of decimal places to retain after rounding. Only meaningful when rounding is not "none". Defaults to 0 (round to whole numbers). */ - precision: number - /** A human-readable label for the converted unit shown on invoices and in the customer portal (e.g., "GB", "hours", "M tokens"). Optional. When omitted, no unit label is rendered. */ - display_unit?: string -} - /** App customer data. */ export interface AppCustomerData { /** Used if the customer has a linked Stripe app. */ @@ -2360,14 +2360,6 @@ export interface UpsertTaxCodeRequest { app_mappings: TaxCodeAppMapping[] } -/** Access status for a single feature. */ -export interface 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. */ - has_access: boolean - /** Optional reason when the customer does not have access to the feature. Populated when `has_access` is `false`. */ - reason?: GovernanceFeatureAccessReason -} - /** Usage quantity details on an invoice line item when UnitConfig is in effect. Provides the full audit trail from raw meter output to the invoiced amount. */ export interface InvoiceUsageQuantityDetail { /** The raw quantity as reported by the meter (native units). */ @@ -2382,6 +2374,14 @@ export interface InvoiceUsageQuantityDetail { applied_unit_config: UnitConfig } +/** Access status for a single feature. */ +export interface 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. */ + has_access: boolean + /** Optional reason when the customer does not have access to the feature. Populated when `has_access` is `false`. */ + reason?: GovernanceFeatureAccessReason +} + /** Billing customer data. */ export interface CustomerData { /** The billing profile for the customer. If not provided, the default billing profile will be used. */ @@ -2925,6 +2925,8 @@ export interface RateCard { billing_cadence?: string /** The price of the rate card. */ price: PriceFree | PriceFlat | PriceUnit | PriceGraduated | PriceVolume + /** Unit conversion configuration for the rate card. Synthesized on read for plans authored with v1 dynamic or package prices: dynamic prices map to a unit price with a multiply unit config, and package prices map to a unit price with a divide unit config. Not yet accepted on create or update. */ + unit_config?: UnitConfig /** The payment term of the rate card. In advance payment term can only be used for flat prices. */ payment_term: 'in_advance' | 'in_arrears' /** Spend commitments for this rate card. Only applicable to usage-based prices (unit, graduated, volume). */ @@ -3319,13 +3321,6 @@ export interface CreditGrantPurchaseInput { settlement_status?: 'pending' | 'authorized' | 'settled' } -export interface GovernanceQueryRequestInput { - /** Whether to include credit balance availability for each resolved customer. When true, each feature evaluation includes credit balance checks. Defaults to `false`. */ - include_credits?: boolean - customer: GovernanceQueryRequestCustomers - feature?: GovernanceQueryRequestFeatures -} - export interface UnitConfigInput { /** The arithmetic operation to apply to the raw metered quantity. */ operation: 'divide' | 'multiply' @@ -3339,6 +3334,13 @@ export interface UnitConfigInput { display_unit?: string } +export interface GovernanceQueryRequestInput { + /** Whether to include credit balance availability for each resolved customer. When true, each feature evaluation includes credit balance checks. Defaults to `false`. */ + include_credits?: boolean + customer: GovernanceQueryRequestCustomers + feature?: GovernanceQueryRequestFeatures +} + export interface IngestedEventInput { /** The original event ingested. */ event: EventInput @@ -3538,6 +3540,8 @@ export interface RateCardInput { billing_cadence?: string /** The price of the rate card. */ price: PriceFree | PriceFlat | PriceUnit | PriceGraduated | PriceVolume + /** Unit conversion configuration for the rate card. Synthesized on read for plans authored with v1 dynamic or package prices: dynamic prices map to a unit price with a multiply unit config, and package prices map to a unit price with a divide unit config. Not yet accepted on create or update. */ + unit_config?: UnitConfigInput /** The payment term of the rate card. In advance payment term can only be used for flat prices. */ payment_term?: 'in_advance' | 'in_arrears' /** Spend commitments for this rate card. Only applicable to usage-based prices (unit, graduated, volume). */ diff --git a/api/v3/api.gen.go b/api/v3/api.gen.go index 99d1816dea..c944abf570 100644 --- a/api/v3/api.gen.go +++ b/api/v3/api.gen.go @@ -11072,675 +11072,693 @@ func HandlerWithOptions(si ServerInterface, options ChiServerOptions) http.Handl // Base64 encoded, gzipped, json marshaled Swagger object var swaggerSpec = []string{ - "H4sIAAAAAAAC/+y975IbOZIn+CowTpuVZMukMiVVdZXGxtpUKaknt0tVufrTbTtFHRMZAZKYDAJRACIz", - "2W0yO9sP9wB3H+4l9i3uTeZJzuAOIBARCJJBMfWnS2s71qVkAHA4AIe7w/3n/xhlclVKwYTRoyf/GLFb", - "uioLBv/9QqpLnudMPMc/2r9d06KC/8iZobwYPRn9T1mRXBIhDVnSa0ZKplZcay4FMdL+ay7Vipgl14Rm", - "hksxGo+40IaKjI2ejK6kWDwximbsycM/Pnx08u3jHx7/8Y/fff/DDyePvn08Go+0oabSoyePjx+NR4Yb", - "S0dN2uj9+/HoZ2leyErkG+n8WRoCX/WO/933J989/uG744ffPj7+/uGjhw+/+7Yx/uN6/LozO/5bQSuz", - "lIr/nW2mIf6wl4zvHz3+46PHj/743XcPHx6ffPvD45PvG2Sc1GQ0+ntvSSmpoitmmIIVPK2UluqcLrig", - "lvX/o2JqbX/gYvRk9Bv8azwSdGU7K+mC2YGyJVtR+9EfFJuPnoz+5UG9RR7gr/pBsudz28N7S+sayMsZ", - "K3+5/E+WGftX+2uClJzpTPESdsaT0TNL+4oLpsnNkmdLYqkick7MkpFMFgWDPWS3lmJGcXbNJsDJHeZD", - "85zbxrQ4V7JkynC7z+e00Gw8KqM//WMkqtUlU13y3iwZUoQf2KHNurSjcWHYgimYPv87SzfFVnY63LCV", - "trPgIiuqHI4N9Jzq8n34kwzcTPH4/XikmC6l0DiLH2n+iv1WMW3svzIpDBPwn7QsC57BOjwolbws2Oq/", - "/ae2ZP5jx/Wvu36ulFS4+ZoT/pHmxA//fjw6lWJe8OzwpPiOewkJI78fR4JjdzJimdhz1FP0+WYPOnLU", - "krjb3OqmfZOLJOF49Gcp2MH5azvtHR5GjETwnmxNSPCNLG1/vztHQ8u+GUWivSnZP+KOSbXZfYqN1n3T", - "bF0dvm8g+Wme4zw2Ssxmf0/z/EgKQotC3mjCbg0TORcLoqvL8JkmN9wsiSWZGn5ZMFIW1P+1HmsqFDUs", - "oyrXVho2JXOmGDUsn1FchKL4ZT568utmhjyjhr3hKzZ6/65DtiBnr385+v674xNi+IppQ1clUaxUTDNh", - "YHmtvGbCcLMmMLr9U04NiGrFaP6LKNajJ0ZV7P14lFVKMZGtd6fuR14UXCxOXcNTmacItdeH75tkMg+X", - "IgXGw7XhtALf0wgWvWCfjl0w+kZ2NbpvX5m/lLghSPRnP23FtKxUxiZTMRUv6S1fVStycvzwMcmWVNHM", - "qkB2xBW9/YmJhVmOnthfw02qjeJiYVnE5nOrVFyz2VzJ1UHYZBfLTplQkQOfyM2SiWi5yCXL5IppEgaf", - "kL/ZT6warUuW8Tln+di2mArXxCrQJFd0brqcrBf/ue+QaEOVATKaszTyI82RayIkKaRYMLVlolPRbBe+", - "JlzkbM4FN6xY7zZvJvIwa57vPte3P509g3l2NqnX02e4d3btEMTomWv7xjZNczH+pHmq9YScUrtZyHSk", - "uVgUbDoiUpHpaFUVhpf23/HJP0Rv78ejKzZAfL1yB/EvbJ0SGOSKrXHrarbiR5Xgv1V2b9rTR8ySGvtj", - "pVkOynBuBcd8HQs2chZ/MhWKzZkVbww+Kqhh2pALCmt/Qa6Z0pGUcDvKblHbBw4O1w2cLP91pM07TsJs", - "xqOCXrJCb7twf8Kv3nvTo2PUcF0WdE3sr0n59SMzN4wJcgKUPvz2u34h9vDb78ajFRdBqCUkmr0+Z3B/", - "ps0Q+zuB37uXCBgmW7V/vLJeUcNOqQJNyTPuVei7NmSoUnSNRgsasYNO0GtslD472GNrGuRUrsrKsJxc", - "UrttJIol1hKNltdeWOgndh2OyAUI2Isn5KJ5LVygNDNEMzOBD92O63xJptXx8aPs34iQNxcwxr2LWPjG", - "PRGppuJCyBvXiDQ+vO8GUtmSX7O8OZSRjYE2iUbPwPGoKvNPqDwVVBuCJPQrBNe04Dm0nDGruya28E9c", - "G9tt/SnBT3fev+dK5lVmTqmhhVz8NfTjtOV+Vv61PWRikzuhgnTPaVUYOKXNOfw1Jacm5Exkiq2YsHs3", - "cZ269QORwIVVeaDrXmodJUmPgmK/VVxZs+ZXe0062TWOFezGhsFroZ5e+1qMVN9w0Bui6F3Ci9G9IpMC", - "i/feaRN3bPE+u3jibzia53il0IYFQqQo1kQKkLtH5MJffNsbrqSyNw4V2Ho0HjFh2f+ru0rtkrjOopnW", - "MhlmGrnAWP7KuWoGGlq2D1L6Toh3+HQtpZwaMBV3OhFo8r3v7uYVM1sNzjCll/bj9uYCOlxHvXvglb/V", - "h5udUpCgE3S5gBrgdr2veyK203pm2OoLoPd1uHV3uz8JaNz29kRFrHMV2kuteadNRT2LSesmfVN3vKR4", - "9a2ZIZdW4Smry4LrJcuhzwyPIMu5FXLNW/ZNQxA229Frygt6WTAyl8pqip2L802PVdJtGR1smMBoPEIa", - "7H+4DvsOuGJaD98P0Krj5uAm4R0/5WbdsPTtVwlaMlkJowYo8afYoMf34H5FtwMX5Nez17+QRyfffXd0", - "8u7e0phSP3nw4ObmZsK1nEi1eMC1PILfHSFHtqWeLM2quD8VtCiX9OihZfmKmsZ8HN1W8+aCnXQ58IIr", - "bYj9MdqzloNxNz/Zn09SjLENH3Z7fc0yKfKdun2Y6rZcSsFmfY8G5/bXhI2Bf/8ZW6V6ldrQYmZ5l+gU", - "foQlafSJf4aFTHRpj3uiMyshmDUFSyWvuZNLsfqY6Cz1KPG0LD/fK84ZLU/L8tPcc+0nk90dhFR7B/z4", - "H+3rQoAWPGu++23q7QxbnNcNOndJt8/ufN7BjDxhnR1l9bWcqhzV5O7CuRfRf3TcBctqRe0FSXMQy+y2", - "LCi+GHp3UWa1M3hPlllWoSvAHVrnh59MxRv7+5yzIicraiWXMJTbfmEBHnj/JDXU9rZkRQkdVJopUomc", - "KZjAVNwsqSE3TBhyo6RYTMhzkRVSM3JNFQcK4ZVXW7Gof6uoYuRS0eyKGT0hr5eyKnJyyeB6vOZWs6Sa", - "TEevrYZv6c6oZtMRXD45VywzlgLblyXm7dlkKlJ2XftU1+/IbX6+dY4VxUylhHtEVYoVyNGzZ+SSZlfI", - "UJz92I+O0nkqopdpNDijDmY8h7+xCQGGWz5qUlnOi9y5OQp2TYUhhVxoy04mCCVZpY1cMWVtRamMJtTe", - "y7piO05Yb9Bo/v3Nm3Ov1sR+ctiIE/JWs3lVoHFVUq3RDcWCkJmKS5mvLUeyJS9yUu9byxhK5gqegHK7", - "OuRlpa0i49iLq2ungmbWxslE78VO0HbPgl5KZcZ4JI7CkdDVakXVur3nyZmxDeyGE9JMRbakYsHIpXMt", - "hbMCyh71zcaE3WasNLAFC5nRgv8dlnYyFWH7kjvdvabX7IMlI/b3yfaOWkIsWKDI3eiQjL30eRd5j52U", - "6gptd2l8Ve6+Kne/c+Uu0p86Y4ALpyishKifxe04ObefrazahGrCipalHQJeyQ1TghYzLq4lz+Cv21S3", - "567NWWgyHmkq8kt5u73xa/fhGOYJ09vWAr97H07w+mcMLgLuvB+PpGC7P/HGHe7cwNG8e4sui96/27ic", - "zg26jzcjmM+0LDVcBJfYLd6BiuKzv71NpRD2hnCPL1zlRyVVZk00U9c8A7fBU9tJRgUGEloNS9pLnJb0", - "khcc7uCCXzGi18LOC9U38Lnba0ISv6GmQq+1NQnGNRli0T80EG7oLclokVWo2oxJzgp+zeCinQrcokyP", - "4yA0OSclXa/sOowJMxk4D+oQj/YxtCsf88UHS6xlhRyCjkOXSC82m9RhbW4HNY5sY4sGFXvDy/qz7oM6", - "LcvJLtd1+onr5+hpa9eehr2m1vu17yk1dg6nSGirCM5t7fzecWdbzovTXp8563PIgSnLWvm127dr06ak", - "4nAexTSmBULCUOAuzNITuLTqrL04r1geDhcJdHkuByWq8wXeSihqP2wOXm7uQbg7eC1ifYfvd17qLhuH", - "rX2XPdu2Qv36vBvr/Dt0h0n4A4o5a6cl1jKWS+691FPXUJPcELuz7XW9/rvzyq3ZFv74n2foNO8aEO1u", - "zp5BHEFDTtteZicPHz3+9rs/fv/DcWeLxK1TWpd745s5sT1bMbOU+TaSXCsv7Am2ImfPmrSVq42k9faS", - "VI/vajclbrYP3kEHO2xnsbQiTFhtRTdo7agF9aGwSjOy1qsU8LjxBm8YoqvSuS/IJT9CExgD1qyGslRS", - "OGOalNRYesjNkilGfimZeMkMU1PhZkxWVNAF08A1p2uQgs9Zts4KRm6WvMB4l3BykRyypCLHCUGbqWi8", - "vVORh71R6y0wh7OYA1JdzQt5AzEQJxN4LfF6nBsHX4XDOBqjvhQVmjsVb8lWxCyVrBbLmvKpAKNEk3vw", - "mEL+6//6v8HRY3v2/83y+1PxEEeN10WxjPFrpskNu1xKeUWENHzubAtN6KWsTOAVDEPQ56Gn4lG3u4wW", - "hQ7uLufR6PDz7BlObcUMtUJnKh6nKMNl96xl16CvQd/XnKJbxv3mPFFPz88sc9EWa+8OrsFBqSRYUJdr", - "YqerMTqqpOhTwWmWSi6s5cqlmIpKGF4kd0UmxZyrle6MZKl7en4GzLDkfoEBti4c0Km1g3WKyNZJRxTZ", - "g53hV6QeCxcDxB2PbV27dj7IqIfcrwG42wJwQSjPQELM7I6d2f3fpeY5fIchsJ2dbZsAKRBdil3m41pe", - "3fCicIcJFjL0Y3wM6w3lxl1qzBp89Xm3xhktirhVGJ1BDFkpuTDkks2lig6pWDjP+lR4oQfDOW+5M/9S", - "B9hIH92EtJWKlRQCUFiwRVEpClPOuW7PmVZGrqjhlvh1ICtI6TYT/D7GYFyQIYtKsTzcD3bHcbGIUpQu", - "pSwYFdEquonusI6BJR+8kg3mDljLLgUDVpPljcVkQleKtVaz1iTCda2JrrKMaT2vimI9FU7cAtVzLmgB", - "RMRqgKODQxjsiqor9MMjDR+6/l3WUWUnuFqxnFPDinV3yOTyHybS+suMtx0a1hq7A3tiW18343LsnYQO", - "NN5zz/S/otjG/g3Fh7YknAzvdvDYfPbxo3vFNTo/UKRYRAGMPZfTBnm32Xm0d6BbWW4PGxt4/BKpCM8a", - "HrQdo8y63uqB1j62cqoXxIBBuD8IcKbBeevtkTmjxgrar4rrV8X1UyuuX++8L+nO88+EXy+6xEW3Raz3", - "xNuchvWJAokhACaSNPEa2FmsLVlx9nEqmrbzYrqX/9iN3rwnaAaBC9s8tO4zeyVSrWXGQU33uWN+a0bv", - "C/j9Ti9fX6+qr1fV7+GqKvg1WyUjXM5EzjPwDN8smVkyFWQ+OkPd2YI8HNvL7qcssklXVF/ZbVHymUtp", - "7W5F/MZ3//T8DBJWYSdCrhC7LaV2dv0c4pPs9QkSes5uWuuw5+P517t7692Nl8DXqztpo0Y3WnTmOvt/", - "2x1vWXy6ZNmVrMxrfGTAh9w37NZAvPjQAEhsTgy7NSTHTW5FugmxPdrAq5fHd3KDk3khbxIX99wwNdPV", - "5YqbgYS8aVFge2o807gXE1zOy8oY3LZNAlZMa7ro2bb41kncNzjneyt6S04eHh9H5/V+W2A/PD7eKf5O", - "LzmEzs3oXsGobRYUUiw0zxnx/fqoyPil8HNjwSHWPkz8C1t/w9RKz+R85sLWZjTLWBkC/4dyRLGyoJkP", - "f/eRBDCIPY9uEEIXikFGMszo8+LJ++EC7WVSG3G3v/+WuI+JlaNwAUewdBhzzyEEv6yU1Q468ktj+8YN", - "xkxV7mTqtCh+e5amuUPs2zOkN3bzri5ZngPW4FJqs6OtdQq3UIuMZiD8aRARSaPQKFnUml2g1AkW3YgN", - "+UYH314Ulu1nQCsjR9GFuTf9p1LY+7pJ+JCrrM3uDDuM40H9kxlNy85WhJBilWazcL72U8d2n+85jv4S", - "Bn9lx34ahk5lBbhFtEt1zTWHCNx1FPLqg41gGrWYmLhI1JWEMI07n1U9UncSz120Tytk1zeBCPvVqhIu", - "psQvKZx4q7BF6cFGkrevyYqpbEmF0Q7ESDNjf5nCNp2OxvVWz2McSzgGU2Ek0Ut5AyyVaOc18EmiEwGZ", - "OGySEvt3zdE3drxf5q/daF2uvsKzqAO9EN+Nl1H3/vCvqLhpgLWhA4qP3N1Gb1/9RLgga1kpb5k9o3p5", - "KanKLdMNFws92fEC+ODTMTR5ddPx2CojpN7b73Kg+Z57ErpL738CM7QpFWJlqlcyfJT1Oo9Y2EP+VikW", - "JbF1L6Ml4m0e7io6b4jLFs3bpFUs3dzRSNAspGAHpLglJLrKX0eNDLoqcXc5bomaUKDwIDe9E0tvwX4e", - "es3XygvPlnXsL6QS6/A6iaa5B8hI6X0t0zUy2Q54qhsz/ZEt6TWXyp1bhzw0EuwaMtCa8/yb97pJouk1", - "2kItNQxCZXwAr1fNUBmGvjVefdC/A47z7q3Pd45hQcHXFs/Q/mHL9Lyl/PlOMdjyXGACpg958rP0H2yc", - "6f5iOj2TjnjwvyDqiv24kQ3hDhtkdm2yqbxsA9bsLS9eMYzc/kWcylWJvvwuyf4rchnT7g2sDplNI6a4", - "oWs9Go/4fBbk2wHoBiwDfD/Qw+VcrYY4bRRD+vF1yIoB0mMWo0vaa6740Td6Kn7t2EhPz89IjSJRpxPn", - "MtMT9OlOMrl6QEv+wHPwgefgA/SG3u9KUyeovCNsljWNusOdzF6jt3k23T7sPZo+s2+L2ds+krbbsbuI", - "4C2iYT97KQ1IBoJlTGuq1j6VcSqiXEYQXpm9fItZpRKwG1bfBpQIt8drzf5mKQm2TN90luafpcFYVg9a", - "V/HZCrLJNZkGH4RDKu08hRbc2sQhtCn5LPsWgTtr6E+HH2onq1gmRcYxWcFtHXym5aIRVIsM9jBvcVrP", - "mGRUGfgPqQgVayJh6RwcKW8A/ceJ+KAV3d326/oskoZ6dJDhALvPY4nqdcW8Ar75ZcSNMRixeitUtWLs", - "qGDGWO6+/oU8fnjyxxZ4NRekKkumMqpZbBRi0FdQzu2nQaKS8FRqvwGHWusLnI6d88yw2w9xqWx5Bkms", - "Q/TUYaT3N7cZ3n37iGhmalbVOutd6RebnD0fpvS+H4/YbWkte/f41jnEt9ETWoC3bHdEXCfxcX10TFZc", - "VIaBYHz4mCxlpbyG4MIZJiQWnv4be3JRFULQle8eJ2t2oMMl8U79/M0LUlCxqMCBTRc+qrwm++2Zd9dA", - "XtWcXBZUXCGwsvcLVf4J+VLJGx27eIjD939iRaWw305Hc4X/m7Meoemzk/ov/X+kEhWbqBiAoXrF1keA", - "YERKyp0nxxiaLT0mUFLiOxAdOIZGKneJcZ/8ZlSVGcgciNTQSQpepeUStb9vAHxt2ezwNeT9Y0LBPTZZ", - "TCzfMqpy5GClZ5dUXM3cC+l0dN8vUgto3ak6Pj+QFkUNXdQctoky25PUXuOK+Tt1JsUsa+iXBzzhSRU2", - "5bkbqMPCCYzc+aKhJVTaagj4llpPbUJeM/ZkKvp0PQ9vUCt8KG+OXF7EUUkX7E/uq6OK/5un78huJWSp", - "qZRIazKvEOjKKjSb5+bo9mtLK7O0l31GQ4ZkuJH4vE+jAT+Y58cROnNbuwXzKVwWS/Iwu3mn5/MafyT9", - "GlqT/2IRCPB35DAd7RCrl5qlobcznt+drvSG3p7l+2tKht5C7mdKQXKsOpg24V70mjaEe59LRcu5h73u", - "zROL5KnrYTryuocOFtwR/oT1pZob2KdGMe0gvIq1/ZsE3/tU0LJsXqv1MB/iJ3jFNMx6kMmKjew9sKOJ", - "eoqgfyjNMaOqdooIxnKPjdc5U+27T6qpgLgbSM8iVCQESzpmZZPVBS/kaFvZ44254dHBVizQFjAu1q7F", - "/rYUjAofRvbU2bMa4825vh1UYvu+j80t+5lX2sDiggebjtm1gVTNMsUSuuIpEog/w7iB/XZgB4rznzo8", - "nbnveZ6wJjZccHcl7Q4c4PtmB635hmqXpZ/fjVl32jDgeoVRw55hqyTM52ntBIEvgjODz+t9aGQEftTl", - "cBP744Mzn2KMEHcCmhAICfvm46wrLwpnEk0OpPu/dF04VR953feQ0ZHwB70LX6b32ssIuDN53eFmNADm", - "X6zJFONrpiPilRqHzeFEQHTTd7T5LRolFEzp0SpbymRLiUwqe9hiK2JNexcgMEyiO1OVMw5F6Xr7RE8J", - "fmS3t085bqtAnRfcyWgg9moTTT65cJsFbtoRjHvvX/wPM89E/PtRDfXZpdX2PNsDJ2i4pg7zj7T1Ldd5", - "x2xKDTjQWds+xVCp9J5dZqcA2sNxfzLahp0a8yvJxMY+7u7CViAzCIx3++qKbcV+YKgj6PW9QVp4BlJv", - "Ny1QNrTfGjVd0rhD6IownWHbhkXb2Q+9pVPr66W5S4vJq0zD3h078+TaP/Dnd/PG2Ed290B2aIsiD0jB", - "rlGL9o90fD4Ld8Y+j3PueJxLZWjhaN3vbc497MHLEfQd2TleQuEwwdzp2h3xLu+Ve5jubc2ZWw5p1lPx", - "q5eFcQdbXu68ZCiBqAeNpvo+BL5VmtWAYe6cjV3K0yU8WBtN5pVwAFrcrBERw2d7E3TZTUWzOGK4H4OD", - "1Qcyd+KsunhoPS5fYMzzNy+m4tfY8TuMB61HzH/B/3G/+gvsCEm4PxXuxsR/1/cQfm7PVB2/zgUwIziZ", - "L2hl5IUrFRm9LpZg3SmWz7BXbT9uu599Zb0kg7ZoRVPxa+squgsW1UTcd7g0njlG1nkca4SMddcpAqhw", - "5W1Ye93CxtKToVDHW4/4wVwZ9dHrOeR7chdndX8vj0ib3yboSlPRonIfEdT0yPkikDgg/3srYAfntasO", - "uZkb/9LcZF6RbFD8Ecz6U4/9Y+52WjhMnQa6CfejLXsG6u57EQgqYwLOvS959Cf3y50SFeXRdVWybXdH", - "88lwmHS/00kh3QOFff2ocqfERSR8gC1Xb2XdtOp2t7DA6d6ysva+eqZi493TSQVNmlsdWdrI82xYWw0u", - "hvW2/9xsgvVXXzRdYO02pkaAeR73QEv1adGnS6pS2WPhdsngg22lBOYFNbM524bo/6Kg5gVjbtDxqNJ0", - "wWbwbrel5Vv7JcS8ucYHKgnQpGhHkP8uMe/i6u8Nzm0oaoKN+7A9fgrosxG0h18OKwb+CoWPfN1ctwdd", - "rT38DODuoM6fdzldVsaXv8WqemTdqacbtefafYafAD5e5wsA0ouw86zdICSZVwpMVIcJC/4XdluC9wW7", - "c7ARPSS7X+Pd7i/SqCQgDDsKEBRxTRlkL+n3TjWW4Y00tBic02tPJzQMqyMW/gWEFlbtsBzyQAZU5HFd", - "2QvFaDEzfMVmcBAu3DexUdAKvJTyag8/hJtbDxbICmBWgs8QmEYLQIohOKBXPcPLkgvniJ3z/VVwf0Si", - "sapvYad72An4XpMzaSY8Ba53mb5pBq/8CMbR0bo33LK823bU9XMYKoHICX938b9N+aETZ729b+ID9I0G", - "hhwBvfBzC/8nbjnql1uOLRsPjtTmR6r50FODxS8uIYPNPWld2m6iN4PLdef150uDm2sWbf2oNIIfhhqG", - "8XkYVIiYSdo4VnM9FYFC790Jb39jwg0+fF3GZdtjVFJAeXVfYBomVlK/8PGJ0avdnFMTKi0dKMSVEdtr", - "K6o1PIqGiU4OB76jBkWG/lytmOJZ32unJVDBEnmS3UQmaa20ZqEjpKF1bpI8VoM2T/P/rLTZI5vyqd3p", - "OTeEhh4aEJFGkhW9YmRFRWUvhvAVhjJG4fYAtWt7uqQFFQ5Y53U48ZVmRxnVQciBjoXFEjPnDhhQX+fj", - "gDp9iciBrc0FJMW3QHu1R1u3FuZoQyLquSx4lgB6gmRtXH6r3WXS3taN0s+ZFLpalSH474hcSDHzUvbi", - "CTl1ra0aWTelmmgphf1fy7aFogIUXB+I4TvyaHebe5Mia6KScMBwdjh5oTPNjCngFWNQT9isodBGU0wt", - "QsRZUiJrN9zG0OhHPFz7KLLuXNbPx25mqNlGRnxLJ41G3NDp5dqLOM6aIbwbr4F4Uk6FTMFPReG+RnF2", - "fcDQH6vih7vWscbNirjR0Pu6GWaqQdi45lp32cNP207ei0rkXCwwBzvN/jl+4iO286B5eRyEcGLsl+7J", - "8IhcCCmsWvmzDD0EDHooMMj0GCMxMHi+gekAXWroxiGhOwW1NZbdEoBVeeTA2T3guh0GmntXRk97WZmA", - "I+S6cCHoN1wxrI4yZ2o8FS1AeAZ5Ru7KCgF1cAzvdzOiXZvItZJYtCajtx7TP9up7HsVIx9oUUhE8PMH", - "tXHh4ntDJJxyRW8EyeWNIHRBudDGWxhgzqm8BtgntYSDkIWpiIoRuIg/UF4yqhJWKtphh1CVgE0sDzrI", - "CrEHvwAEz+HRf35/bFd8g87rpNGiwSVUeb9Ccm4ve3LgWMLGRVHHE8ZntplZhfmhLEczrZbGtcGFbg2R", - "W1HoiJ0bpi7iOM0ke+e82KUWfVcmvXANbR8o0lxu0PCNnLijulx70byg4h19QNPNi/D95gCMwTpmrC4f", - "kDgkQf2D1b9oMvDC3lzhRkyu2peJRF4qLlWoqO3ilk6OO14fRW+O4PrxDZqrTX6SN0z5cv7wprPkiyVT", - "4ft2KuHJd0isFQF2xONjoNX9M5VlWFYqW1L9QRvh3PeRgOdBaUhclf0+1Ynca+4M75FHrev+5AMgYiM6", - "e6FiXehuVN6uGTbqDl8KM5bezlAT+BDC3tBbDDxICVF6mwgQrKmy2/eFVPU58tLRKYotPUyPsaxwo0ft", - "y+pPRRzrjgWEvMeBKHbNBOS8Z3KBkK8OdKzpKItinoKHA8U4jozR0Ljy+RizSKj5BlccHGd2coW8hOvO", - "gUDS2wzUrvAQ8CXg6o5H19Ly5A6D85GxN1QTHOpQ6L6tqy5S38Zem20g9Td1f6Bqq7XWuF6Haf6uVe0r", - "jMbtqt8+Zi/1pLjipquVGOkzcbN2wF/4N5gQzdi/1nZvF46hYu1bN2qq/jrioqzMzMgrJqyRKysT/fvd", - "jp6BV+5G+wtbd9N+3++0GJ0rfdiquOZ1FpduCau7KBJ0FiAxvLj2VnOqSEK/KC+4GDzf3qFtZ5vHT/Fh", - "++wT/p6t1ZB2W/rzWBEYgC3omjUKuwb0xA0zPpxJbM2MMpCBBjFp2xIXJVOzSnAzy6Q2M3gJwavSHdkL", - "bJlWQ2O/46wMLt097vuEb7gZ3R47QDegYgz1HsdB7w0/8h1n5nkcxtb6gOrZXZF9t4Nn3snkOMG08MRX", - "MuWX2w5cx3f6zZKk1cEzpHcQ1+R48u1xvJPcozvX5A8nx8eT42NUieCl3DmYQI/5w7f2R6zli4AXq8qS", - "ao+MvZat4KSCHMPF03msJMeA4TEVLaPq30BlhnIljHYTHk4mxxOXpuX8WbMPUqz9+Xfol69Dt1uV7VCO", - "uPasISXbVZiuLvJuJxnXWzQovrXbRoB3AJcM2OxDC5xnupDZ1cagojUziCk7mYp7F/UTODWweVxi57yy", - "WgFgPXVFje9qxcz9RGBSTAn3EQSmWDsoW7szWcEXPC0a+mkqqTbjyM+SIpiKfCp6SA7kYg95il73E96P", - "iq0oF9ZWqQQcTef3H09FgwrwAVmel1Rr/wqF6m9qjEg5Jq/CEP7BgoOOMme8FVnlljuOrHLEjrxa36f4", - "drbQbs7v2gocnlDWtRBpUyeGIvH9hh8ZZveNp4KLrKhyD3nmzc1i7Z8i8M0j8TgWQTAOi3iity0gyjYT", - "AoaMsy3rIK1IKeM+BANN9yERGLBA+UaH1xtv4e5Awvt69+yyhFvNqW2iuE/shfuuXyJ3RKCHlA6SD8EQ", - "fNngSPa1X4vrf6e6aX/tXohTnyYej6MzW9dy83dd6rhun/rWo/tGUaHpPomg4fXK1F3U7gZNKNFcLIog", - "zVbyGinrgLNPRRxBctrpFW1VvlpVxiqId6mMv+YLYTdBM/CwOYEJQdjra+Z9mzSvhT0RbEHtj1PhflUs", - "r7LwxLxJQS/YzH21x2t/rUD7u8EhxUMN6lCfJ+JrT0GgbaZc4N54hCPs3GCL+ed6GzsyUkoRBmYe8oUn", - "VITHeNAmh+DyxTHTj4K/00fLtn3kdxwFXayGNGxttq91/D6vhx5fMm4Pwym6NyDPpef51CW6dG+KD3D0", - "1jIgVHFLeXe7MrV7gUYEbdVP2jPemtmTmLRTRFDHDLFm4b0fJPUGP8gRucA/xI39X+yZgxhwa4bNGTxK", - "N6wX971i9iKzWnNGK23VuWDGuAvjkoERo5vaCRKNqVMwYGRSbMpHikRQ2wlOAVPP1bSq42U3Zybh57vK", - "L/wYw213bGPpOlQ2UqvPYbIXaX+/yTkQi+lDOb961gUMg27K3Xh0e7SQR9uW347lJtSTmtYaiJyZyL6j", - "pELEarBOLisDCrq1OQqOYDtgglOxngoPvZCIJ+8IyccNGflo+zau57BnfkRnr7dzvHO2a5BHl7WfTiWp", - "NfqI4zuURd5w/z/rXvsx3wbedYe559P3tpX88Z0dyGxv4mW1ouLI9goS3oGuQ23c2nJCVIZUf2Oiq2xJ", - "qCbT0dvX5JksCqqmI0RGfl4piejGQ4vXrleXsg9/CX7bOq/0RFwcp+vBg010p/KH6QguuzAlnNB//a//", - "7X6wU4OJ7abObLmWoz0U8hDx+GyvhpvSUZwO4lWVTgbxDvIbroehlWDdKatDgGl99BqJVynovT65s+cN", - "8vVkfz3Zn+XJBr3vYOd6h6Octg3CaQV65x3tikOAxlaNB+O22ypPAJsi2lCRU5UntJ4GQ8aRxOvXeNA/", - "t1eFaqZClQMucn7N8wpyqu0GWFDh8nY07iv7oa4uUYwRI0lZUKHxcQbCBimCAJo6emVrCZvh0G6uXdqQ", - "bVfyamG7TMhbHyVj6C36kD1YA6jMPnPadRMG+2d0IQ30HSV46Lg93szMYFl+jY7/eI6uK7beZp48d49p", - "rYCuLzYWekXVug93+U1Uu7oJvNze3dHGPXcNnkOfKQydzz8yFIFeqDGKX1Z7VR8IRXRsT0+jjhLgxej9", - "cbVU4ENGoAQa5BkDKpRsAgo5tZddw1tYBbd1vAaYjdwYdq9AU3seNmoFSM+zjfjSyYvU3xVhSjk1NPFk", - "U5azgF49EMu0QV1i35Rld3TPwM6P8DzjLuFSyTkvhvuWz7Hdxifq6DZ2w0Qp91GqXAcBIQazbPfggQ8C", - "dGPrwvYT2hiN6EbfN/w04HWE+NM7CThNo9MlUQp22NjbyykeEKu1XQ0xue7tr/D1OMTKucqBrcpHMWwj", - "1sDyauxUcGHtIJZVio1b9T8AP2dOMzYhb5YQXYTFPwKAalRTzUirvadGj9TgS4/6kpMCYuigIhTqxq7A", - "OfK/uzUczJks76JMfKs0ZndX/RIXvHShIB4DfVNJkTdLplkol0mhsLm2axWKp4SqBVARs4PjHjTYp+dn", - "e9fDbO/9Fi+HnoM0rOmhT0Ma1DR9KFy9kd2gSDtdAyaIgGt2ybiaitb+HTucLIfU1zaW4FnLmXDwgQ8n", - "WnJtpFpPpsLqFq4oAIK98xZ4Zltgc00KLhyUFfXIhLQs0WzsRzc48DHZBFK93ynpA6T+8D3a0bSG7cXh", - "WtiE/CKiNbQCDuz5vzMlp0IqspKKee1Mj8HLIUX4CzQAqLVLVkgcWQq2AbrCNZxdsXVfQQU3GIpcwPjw", - "c8m75LtiiWxVmrWrCytxqlPRUC0dXEgiYyImdqc8mPYqvcYRfFqMU0zcX8lf2DoK8qqzZRo7JebKhn3y", - "XEDv9mQ/heO6FxRz1Is/9Qr66QM0ThjEds2bD+HamikZmijYuZ4QjDe1ssBy+r+//uVnUlKlbaMa4aDx", - "RBW1B3+DE4reh44h9lGN1ybieUh5Gv2DTOsAg5cyZ4Wejp6QX6ejRWmOvsVaifY/H8vp6B15P9rqgRz7", - "NK+ZM7F3E0sNIzuNqoXdkiu2TnGhMa06ZmIFc0pZfkuqZ7iuSVggrGIQi+4l1ZEHz9QkTchTqONNbM+w", - "yhcOEfgCpfgFrvpFa9mfsZKJHEpV+cAjaOxkUevzeII+5iy5EhEa8V6BMdHG3yEkZuM64Ly3hsg4D3W8", - "cRrrs9tZ3y2apU2rcyc7nrtsSqDZ83GDb/kFUvzTTy/fyCvWF09jf6od5j/99BJTSAopr6oGaC7kH4bE", - "Q2uv02zJZpZ54R83igPImmJUS4GRCw5SGP5Ll1JothvRbwU3p3KwMteaQUu+kOc0W5Kcr5gAPe6es1zV", - "GOyHYkxMYMh9ezVOxWWUwUmoJozD6aNeWmJaDoRiwzqRhZJVeXS5Jj62BfxoU3FvVZkKwt/ZbVZUml+n", - "qsQDGYmKmjgY/GotSxw11I4FKYgCMStolbOjR0ffHmkpBIPysVYMYxULnxU8FV5mGUWzqyiUGMaYkJcd", - "avG+vYDfZ35yF7ElD0I6Wfq30aY7vZc9nAMFYimLHG8fP/3EfBzzQQ5OReipXuo5qEI7TK07o0DPKO28", - "zFzU1CBJ1t3p566nVAlcLYtrltur8wh3qBu2RkEJGz+nhl5SzSbkXJYuv5EL4k+fnorAM7/7wXpA5joD", - "ObfcXHHB8rHf8TBSvOnhqcn+dSpaO98BqSBX2S3NDFlRky2Z3gwY62fpGQGHAyjsPRF22mEarVMhSyYo", - "x2NBhVkqWfJs6HHwnW/YNv6T9KE491NIbp5Wy72PRsyHjcdjKijpOR4Dppqc4cZzAtt2tteln7rJEmkF", - "uCFqAY7bIcWMvrWu206F20VgGsHdh7/q+xNy4e40SHajgtCCU7Q3L+DLi7H9BI+b+2Yqoo/wCr3YwOaa", - "Wek9VV/bTdZ++D6qWbCvkI172GGCPfPavJc2a1ONyNag10A6r5WQsVZTFKn3+ZQKuEHP6xflgwvs7CHm", - "E9V7vWI2K5lCiIhD5O1AljQYb3YAYgdwi80Fefv6WePduP6kZG5PwEt8rSfeKXEwwhbq8JsGeQiycTeE", - "RUIkQdIZ/NogxkF83A012HkvOb/gzw16glZ/RySF/nupehW+iAhrP6m0ljDBx+1H+SWgXO5pgjwlc37r", - "TnEQOgHV4O7y6l70jhpYuY/sdIifSfGJv+0oQXfJxHf8jznfAhNpTC+VEBscH8+9pYbL4cG2XdqhsldY", - "vhZ05bTIlt27KT3C3hpDtXsIiwBu7dSytQMPVbilp/M9LZaNeRPNIjGDj1BBDZmzUFvDJTv3eqVpfk1F", - "xmYhu/IgiYuMqoLD2xBfsbjcNRZJqQMJcfQcQWKhEAPNrqyCJHIATMuY1u5Fsc/8eYp9YBqp5SPuVJyR", - "VexchbfBMWJP8dRtLGSCuathkFY5kE1UJ9s34hSY4kOQME8LqVl+jq22xCbAR/GS4COGJkZuLK7SaP+7", - "jBBMQeLWq50K/8viWNV9gpC2RZwEZ7a8Ef7BbvsGDCG0XyMUd4lQtNeaPbHDX2WdPH8WOujJ9fa/t/Et", - "ursr6qrzMtP/xpJ8AIS+xw5D1I6beRQDP9iL+okmZVLOq6KYaaauecbuQmTZ/sekEigioQo/jOVl2M4C", - "90VVFK3GB4f8vWt051AFDaqvO0iZywCBkjcNI4fUZ/YJcMWQinx2ucdz30ts+2Pfo189DTeKD4icy6KQ", - "N1aEoWTYtJwvQ9PPKB4XI09mhqnVHuGFPPP4Mm9sBwnE3wgD0M+npe813IvR597jzvajqw8a0P62+xF0", - "XYEK6opbNovwDqXtFTXslKr83PfXqDHcS7RX1pKv8Ak+phsg1NudCb4al70l8TJ5DVEt7tB06X3dEXIR", - "It1qUC6d43ONd/QyrRW9bpZw6Odl68MPAZ+O61mmWdiHOb19p/pux6M4vnE436LG27S4RiAlOJel4gtr", - "RrO8e1dH18ENDRWI0N1Jp6LRGd9SMjGmcvRhwNvD0LZ7d0nn0wF5dqGzkFTmq8VGEBtv0K/STW6AtLZZ", - "CHJO1h1+i7lv4aM4YrkzlcTHX2RWxV4JCAEBxZkaDb2igYwSEMEiTaojXtPaZsdi7sq71tXcfwH1Og/8", - "7RntoRfNm3e01aPzrGFCDEBoaFoGoKFDvmGTAO1ilhHCFJJgrd5DNbk4VzKvMnNKDS3kYhI6vICoRmsN", - "yAqDbi9cmdI5Z0U+ngos5+iL+G4evuNbKpnK7G5LlXw+D78Fy6dt+KB2ce/4v/7P/+fk+Pj+pFV/ISq/", - "cBx4L6rVpbVp3/euU21obVixc+reAofANds2TZC5kiltD5oil5XmgmkdabZtPxzEI7PhFyGM+zQ0TwgD", - "F+o8l8peHoo1MgpqZxxUk+BzIhjLXRmADeKP1wDdPqq7tJRMdgknHBRGmMzZS4k86T0BLjs5iip0pPWa", - "Cj+xBS2coaB6IETC9LrvqvR2xvP9Vu4NvUWsc9NnL+GP32hSAJGe8VlI5aiTe8tKlVIzDcjHa7Kirl69", - "NEumpgJPhwtmvmHfKObf6Q1TzGWNELOUmjmE207HG7OMWltxMGYjZqA4locT0d1fB8qu7k+r/rGZJdAN", - "cG+P+W4LU+JV3gcI36yJNtJXlc6ZobzQxFNkJabbFlDlzrVoL55dXKsc+vILIAbV+kMBN2rd76yxNXs8", - "qD9b0YPF2y1xre0MiAJ6KW+Ex+J0arDf+GZNcplVGOu5cTMWdGgWwTnk9rtYHUKJYauy8HVzY516Q45/", - "RvOQX7cT+85e/2L1tGebrVbvunfddyki9oZZYNxJWVCRyhT0tP3uHfdZZKS2mfU1dX9YYbvDVx7vQp/W", - "kZcFxFlmcsV0AGuPSiU1i8bA51AQgAtykSs6Nxe9SPj1Dnheu14MVRAyxJpTNfIw+4HYj/KqYPmOE1bZ", - "kl+zPD1lxLqBFm7KjkHe/8FFzuZccMOK9W4MYCIP0z8oSMMhMkiegobHIRCRrfiRU/tiWCBX06pxQYZD", - "T87iD6aiNtLtJ1bwa1Pz8JopHWuDls0OkNsNHJ5V3Kde4Yqly5cNOLGkuq/2MvADPyCwy1gw4uxqKCvp", - "MBghvrYm5Ck2IvqGm2w5FTLLKqVRL6XGpXfkWBe6+X49IU8NKRjVmJiH3fBaK9o5qy1SGM6x2B5w4gzb", - "nkSe4HqOo2416FLJmb3DxWLGhLWS80aRQjxi6ZykUskjbGon4Fo7vTdxn5/Xn/uRUplCd+L29fVgEEF2", - "ZpZMzOqixZvdwhAsbedi9+ZfIRbeFeC/SHTXrnfuvANzrrQB8S4AYApLW+RMEQ4J8e4pLO7VbqaLJ67K", - "f10cvY6utXvNlyn2dW03OEzrab38MCe23VAbXdhNxzVKrVO5KiEl9JLqukQya11aUJvESe/AZbwCn5CL", - "5q194T08mhlXHMDfS/ZjIW/ItDo+fpSRVrtJs2ZKq1vX6N+IkDdYECquiGJkPCyRairSIxl5cd8N5K+/", - "xlBGNgbaza//JRQ4tBY4eimZUlIla+xpqARQf0rw07bCw/A6LBVmBocLDJYJMJWnoqwuC66XAwRn06/4", - "10DEc0tDsoC+W4e/tulNiFN3iTYLvaYtNise3Ocu6b4o5A1ZywrhAa6YAwHQwdmJaPBwM1VCwPw7Bl5c", - "3rV3Jo7KbgHYvSF76qk3XORtAzNymrsr6d1mY/h8jxp0zZudQLJLdKEDnzUyF/wl8PE3ui7Yrom8ZsrV", - "loYkmsbbVKnkAr08XYv6c4j6GfwyvZs1n7eewIC7G8wYYL6qREuFJ3ZHotYPEgW/W9E1kb72Zh6liIf4", - "oehVbQfMtH8KrDS7IWewIdPqa7xhm36BISqkD0iI0RBehZ63YSE46YAyICJ4y7nuq0HU1B9orXlFikA4", - "30ta1xWCGkDhNsD6ew5sIodaXt1Kad7oTLYCA4uLlgetfaPH3QhJCikWTLWQFirNuvpJ3LC2pzEyKqLH", - "QJFsiGXzV65/IgZuxOXIPFlWyPoeN6Vfn/vQmnaJbo5AWZuC4ufFVvR/6OdFgdWDFWM7fW6/G48WiuaV", - "vV92afPn8DE8he9E1lv73Xh0LYtqtRNhf8UvDxSZX891x2j8mpdDGsAshzSoWTmklefNphMf6B9Y1rkA", - "/Y9n7K4LxjYLVM0b4zbD33cP6wgdxFEd2yM69k2nqXfVQCYrxvqYvO9E1S6hKwMzL1tbdNgkQztiOESi", - "Ic32ZgGYCPtXrwKi0e7cOe5dH+GYrCLOXaSTbTEhLvkTbg1U16eCapJVq6qAqmWuZaYkPAvaVuRSViKn", - "irvwB9CgMM3Gw+84E8zbyeGiH7c7IPeqcmbkDLfHfWtVTAW7LUE/hQssk+KaIXK980RZKZlQXW3PPTcy", - "/BQVcHasRB42PVpA34c4tGyfbzjG+CcdWm+Azq7ttederS+bPU8m8m3bxo2jZNO+yFagLG1JoRqbZeYy", - "kCDyaEaVYrRBQPqmB54Ofd3GcBZYU68Q1ctvtSW8Qr2BBdu56eCEDsJyk3sQ2eZicBVsRfzX/VDtWDOD", - "VsVU7Hoo4jMAzsjkAZiKLSegpm2/iGO8odMpAWEtI2a4LYmS5NTBVEqRRU8p/jgxiHZoBMu/SHTp4gE/", - "aBaoNiRnAcmYO82ijCAGoVUQne7LZrhheiLRqh7inn9bgpsF4M99sVpwVf9WUXRxedTaTApDufChJX5y", - "Z3NSoSkbHq78+siSiSNMb7gXTFv74/3GTIECP9zmSICwFMPObM1MB94KcW4hMRYOTXtxnBG/9bRNBR63", - "xjECRxaWI/cXjZsgXE9sspiQP//oC5Db3XK5Nkzf/7gaXb1zD6rRgcFxtxqdU6+H7QJs1NV17IRcPGK8", - "6+FoUh+sH/CAMHAnJJnjEYX3sAJzxBHMF720+Lz1Beoz0RX2xSszzqK9O02mhiEfDrzuoGa1F68Y78uM", - "4WKh4zoV6IeRwihZaJ8oNhULJljtGOygtut90dGflmVIdOh703JhxD5qyaeycN0G0p18CYFK4W2iH2+y", - "jsj2EO9hgqln269BR18L424qnFWBTa32CzfuOZNAvBcVNDNN0HkXf+tHTh7WqahD37+QB9Ybqa7mhbwZ", - "zMm/+YabYzV9/03BjBEdUc2G4a+EYQtEcxij3K4F0va7pymsh2Ju+YberZMU67Qr0ztlI3z9pH3wzrdl", - "1YXOAX69jpUHdDbHukmUu3sXNHhvxBYKDL29i9GhTNWmkdv6C70NaViIROtZs31DndOF/T9MWnzlYWuH", - "ptEsLMt85qPHA0w8D7vCMsOUSHfsulriimF3G+MdPFkv7cdtzgFBrqPtvNq3EktLA/yoBVm6+tmguizh", - "dXSo6yzYOC6yUDdCCzHSqQZ2R4efg62QyudPf/KQfa8b+Mn4935AuGjiO0jBjuwtNxX3hBRHimWVsvf/", - "fXzyj5JzameY3hbxL1crbgB3fHgkYMlEfhp1kEgBt5+QaJBa2EQzRvT8Rh4hOPWPMJYNJzIV96wdOq79", - "o2NnWTY8QA16vnCQGH80dkeJ6eymPoCY6GjsTVaEyL4pSc0dwJA2s1BUuNoVoYamiqIRAE0uzxFZwZqx", - "EIfV3jOvUMBocuEO9YV73NesUTbteYKECCFn98k7yJsgoc8MW20pYJAC10kujYfTUfW1/fsJwrkLgBQf", - "jxw934x3eBJqSeIz4bHoml9GVV6CBjUVPUL3IwOuJPdXwFj5ABQHf+o3ojk41RKH2EhSjeawOeKpzrDf", - "oj/8iL6S5y3BNiyqMSmwMMsAu29XldjnNT81SOxjjMtRHPJ9v3ud7Ac5kAQKbSzyZ5Px78p+HuLJ42fo", - "0q4hBhzg24y/zOaKMXLJ5lJFlesNVUbH6g3YxVMRKzcFaK73hDQBO0EDpr7LSjAOxIVqKEJFKmF4gRpU", - "eI6dCna7pJU2kKD/fvsOaB2S/nJI4Qz4JcfUgni5SXzjWYLpFRMBYnsqajWdG82K+ZhoSTi8IssVN3Zu", - "S6a2BsT5Q7GbkEoIg3Go/LJbFy/x62YXrmTMbj0ghn5DSzpMeNsGEneMK9tE4qAOEox+v4MISlB+SGHt", - "a7xtFNZcz7Scm1nBV9w0EgrSKfdzYj8n8DmezIqNnQu0rv5WadaoisCumfC1ASNyIP80nNp/reuOrSgX", - "Qaw0QLLC4Mn3gWgW/Q+1KLm8zGI0W7o/4ePi2L/GO+K/0e712kujqQAJ7aF5tXGCqCjkDcLtCoSl8lWu", - "FNPMaMsEtW4M5QNQLhqrcOH52mDrFWNlKMiF2LgQAeAXQtmJsPxfpwIQLW64DgX4uSY5E9xHfYBHMhAb", - "r4DlNPq2R09GuawuCzZq3SyNOsythajvm8OoAF5U7YJOBXWth2LN7easgOVDIJBrWnjiE6fLbhzXJUE2", - "TsgzPE7eFVwHB/W6PjrVrj1Y3Z6KTg8C4B7JLpvRATfoPnulWHbof9mPXlCTFmPs9VgB8acdrsIfh3D1", - "pZvbcKK6mZ5C1rhaF0/Iz7LuA2P7HdQrxl3piycEyWCRitjIfITcIhSnkEArYl/lVDgpFB25mIIABubH", - "2xT813+XHvJK65aT3L06ZbtnZ55RTSjWoMS1npBXUM+W5RgeB+WHA/Cqv7dQsv6rvejmVdEpDDvngh0t", - "FAZ3OSkcXrr4qsRuMNJkLSs1FfJGEL3WDo+w9uOhbXgoieo0tz0DNxxndzgdtXk8fPW3mM4tPzVb0muO", - "evJuQDw/+hbg98Wzu6klTCVve7xaDMq2SI1Wuni38lgiG9xXDP8yEsL9Dkvnvkd9x5uvDXnaL146XvZh", - "+yrtge8YcAEunmv3sXfRQnvqgrYwJtOpRaHcAX6wkhqzC338W1+RFvf77LDhiPEMQDtr0R/Iq8mqYaNj", - "gl0o2R2TuIHJfVQ2uL7Rzn/dxqcdsF9iHI5+VDWRLaU6ENxNHZRmO/VRUa7sj+SoXcJ9DoGQrejJOH/w", - "Gz0V4VmsfmpbZwUDXBfM79b+esPIXcAWgU28lDe12qExNDKjRYZ1HwFjYSWFo9PLpFNaMJFTRVZSmCW5", - "d4LJ92BcwZ/uPyEXD48ffnt0fHJ0fPLm+PgJ/P//uLCtY3YTKgS/ZkpTtSb3crquN4zmC3ufVuV9GBL+", - "jOBA9/w3R3Vh1Zyu7+9QsMMt4heB+4VznB3o8TrwtX7F1q19v61CBrGdf/5heZ8mJq4sqDjUWsGTYM86", - "kdcMwEmbyNZt5OuQtN0LQY9DfBJQ9C9P3zk84E0sBAcA3+x6ZL8gfJdU4F9/xF8sFsftuzmsxrvd9IRT", - "KjIslj0o4A9qt6IVCB0g4IfeqEUYvtonsi+m9nnOzRvspvXiu1qxnFPTxZ06mwOWgQPyzDtbCAQHzMFa", - "p76bYj3ZWdU6hfzUD2FhDZmiv+ph/xR6mCWutfPG3a0X8uLcxRXCRdpcDbqSw85pROAhQ1IRX5GqFxce", - "G+aeCFww0hHanchcqo8QcrgrJZB9joUrGypf9M8rtg6JsX6BIBHxUpol3LCNZZuKs2dhtSrdfKJp6YZ3", - "gGdu2RABmH/ufIBJpITnPgrlviBVNYBnj95wJ5v1UGoryA9Yqr9EwPUO2CZAffO5s6I6d0ejM3I2n4r0", - "gpIN6xnpxwcEag1ciiYWUz62s6JivSO7puLz4peLyWsA1iWn34KQTbMgeYUgGO1UpEBoN9K2EZ+uc1i/", - "2kQfYhPdhbLb2EfwQyImywWPi3Z5KFEX2zX0ymOETsgLqaaiRwPF/UazjJX2xF3DgpCcgd/SvbjF309F", - "g55uTkBU/Qdke+DTuyGq9p7ZJL7ZMJ0bURfNB63kRgh60xRELpqsXjWsVMJu74QEwW4cJmhCDkVRF4GU", - "zoIidxyFuy4jiPAPcFF7tUehFfXVUvpqKX21lL5aSl8tpa+W0ldL6aul9NVS+mIspS0Gwo4KZWQqdUON", - "4s1rCSJoc7j84bxtJemkmXQ2R6ke3hGalpcvXlCVpUQQpXVis1IHce83n1UCMfQOIopu6aoELsWvGYNS", - "BNI8eS6q1dYI/0jz3cZj6G9nPrvU5jCnsUstBM3dMtJxPWL3VMQPMS41mt2aWcjStpryDh25qjFTYVu3", - "9OwY+zHid3ecTVGg6arOH2DY1Jdxo3poVI4I06NC4b5OeWeXNOteH+tePoLaufPTbEwz3pvlvgUJsBbB", - "R1Rc6ukiUv+mCAMgDidol2aP+dlmnfHueF7bioSfWZpsP4mqHgkEiFarjkTf3ovj3rsEZ9O9tVrj5trx", - "LumD0G9s2rpwnJchAS+ei/Cf/l15V+j4OFq3qw/RW+Kjf+vyznb4uLIZyoW1vdQQcYzeYgG4rKjyGngz", - "IMXCvZ2zfCp87l4KGtfd7XBJ+f/ePI9TrwgN2O4QB50zbS9Pd8+qJCTdzGUIJlbpJf4C0fNlCbHimIri", - "Ox+KNejm8rQsXddxPYenboh4BBKI6wLLfP4Adl/h5j4K3NzvBeXhiwy92rEyU0MQbbhcuhJkmFzcSaR1", - "ZaRPoBkKIgYJMr1onU7cLV05xiD0uG7jnjQAgV3DGowimUPmOusCRuTbU3bClKMRti3KHgk7rxl4zf31", - "VOvhdRaP3py1M7SQdp2/8268TSVwXpDaw55A6oq1hfBEERYzdAeunWZnzWw6358rS+UY8o0OwKa+Kz9g", - "e1kvo8Qk5ry7s/0RAMOKek/xWegKOVcqlmGJi1T5Td8qggmsl7QBLbTpQwyHVbxk+9P/GtvvQjR+2kNo", - "58f26duNvHY+WM8+BClQA9AFwGrwDl74YbH0Y/jnjOcXLddh9Kk15PVUWBYwyB12roAL5PAEv4JMdC3T", - "XWjDi4LccKHtwFPRacoXQiqWJ0VOxK59w9o3L1/g29mzFAHextoqw7o7fphQ27r32wmnfRnA4TpwLrRL", - "hmnkpWKRU4x1h4vV/UjF+O7xHjfBzqL/dX1Q987YnEtFsJ9d+eQKZZJfPbPe3VsaU+onDx7kMtOTsENX", - "Dwy9tf93BLf8/aaP0Nxm+ezkGP8fIHMay9XRk9H/AT9Np/k/vn//h9HdMPAMC2g7jNfT3uvcFdrmTNVq", - "AhFSrWjB/27voGjD3AgfUyIVX3DYIDlqclORy6zy6c/RBnn0cKsK6omWhhZD0yixkUek8+/4qxVi6luF", - "rCiIf3mHt3hMs/RXZFCt77gog7F0YnxOW6sPASX0lulxBBpImwmimxw+dT0HF4swgwEPS71LKwV8en5Z", - "OXlRL5aPg9iYpuVCJZC89z4P9y7pzZk9zaBqKVktlv7Vo8H3+NVlI/2ubaA/LNfHnEEYdBOpAU6sJham", - "OgseorsgGRCMXf5xnjvcB1l2Nn2dR9tH/3NPpluh1iyCz+uuZ1FYAtcdB92AmZyJjTO5Y/qbqG2xwOuj", - "902LykPSN4drY5M4dDFtHyAN3yDlbfsTZWST6327qe+stAVsVwC0RZrn34brGt5qf6Sa5SgeB0Mux8B1", - "DpcYrzn/Wpu43hBAcwbcPojrB9BMqCo4gwpQK9Z4t1WLWOd0ozu8KnuNXNLsaqFkZW2AUsmMac3FYuOd", - "5yBAcQbv60S7oZhLp4XULD93mEYb0aFdoaBoTpeskGJhT8tkh9RuD5z0JaR2u1rmu7PRtTjtB0XynYbo", - "L+BhM/DKDdsO9BtiqPvorW1o+yF0TN4IrIkWk7Qt0/xr9ZfPAGa7VnJa91xXJPZibjtUvZlz+Q/Dje72", - "7UGj0Qfd4ce8KoqZQ7m/C1E1B4T6SjigrNwj6nvZ1Tl6ffv8RVUUrcaHe15xoUuHOjhvHLIYHpj2vQPP", - "qwaLFCIYeYicGsVaGvyN0L3iO1dU0AXLZ5d7RBe+xLY/9sUY1tNwo3g/zVwWhbwJUGDrTcv5MjT9jCDG", - "7xZzu3s2A+D2HR5ADGyy2n7r5GXyGvAZ3eJ1qXvdOWwfPXCxl3NtYKz9USVQx92IJ1HwOYPIrhayxHah", - "VWNK6DbW0r6JOdu0iEZ8F7y7Oe+YYbGmOO6IpRvajQDuBIvtGqX1gSjyG9HjgzO1ha/Z3SWdT4P9uO8+", - "cV7BhK60WCi2AOZdSnnlyjIrRgtM8EHHYJRwt2XnvEk12B3nsB4glEgFAFjQQHbCixX8t4rNwgONe9Do", - "FLn9rYpeceKMks5iJD4e/W4iADxAZB2uHN3QkXkTxFhDJ+lcEGm9rWNzdiV2U70MhyEuoBBD6zY01lG/", - "y+BvcTW84fWoOsXuUm8jRWHvsT2kpyfuNHTx2g3Tp+CEDxPV90LRvPfjDyg/52kKL3BbSKpfvjZTtG8p", - "Ok+PK0OyhRpf5mQzLfsUpfN0vKG3W2gw9Hbj+O+379Z6Qzwt+EKk6xxAHIv/2eHYYjNnopdMQAnzggsM", - "hQX1XhIqvF4PumqMc92M8r9Z8mxJVozCgxE15IZhMe+Qg0Yh79b1hjDpU+ESR1k738apd1hWgtyzFPO6", - "Qg0QeB8iOUUefp4KV//G/b6tzAKmP24tkrCB0U99D23VaN8O29rHISoo7D7ch3YX2LGpLMIu7fcSwDt0", - "HMJ6tIPHj07EVAw/Eh0BH9KbBxtBr3zLjXZQnT7tDohXrcJUJrupV9H3UTS35/+7HaGiO9Pdb90/AMJ1", - "WOd3vv57Mr4hPN59aO2jDarCMOb6jhq6RODgUt6AdMff+lgGbyYi5NUlHk3iW+sDVaL6BmwA5f0jMLQl", - "Xg9/SaJChTUkGnVWRudvTv49UZiNQwGUyKFBRSi1BrGKBXWujXoNfGZMh5ypaMQt1nstZE5gVOK8KqD+", - "SebSiFZVYXhZNO1uTZb0GpS1gi+WpliTnM/B7DF1fQukWjejdM5PnsUlRlyxjGQEjlfUk1vN79rtW72r", - "gQ7b6d5P2dDFaKeOdWL3VkbOnFrSWO9U5FsoiC+Jbbeihme0KNaEa+3qwHj1qAYhyRWdG7wUyJJqUlLt", - "w0q7hfPtt9HVE+2+42fpqoDNa8QPjx7dK1YCugd0691G9tMVFRUtiGLXnN3sufjAyYViGl6CHae3svA1", - "PndGTcMiXbp6N6kqz39KsCu1+3hrH+yw9ZyxgZ6Vp/Gy7rkXz1N2SXcvRq6v+sismFnKHNLggZ6paGy0", - "TRbpDNumb6/uEK0d0ygOAEPPGiNvv9W6lLzbmfmvmcjdEf6kTNdM5Buuurtgth0ylGBIZaflVRSQEAmE", - "R5slAgogtOpiycA1ySs2IX/jZkm0XEV2tCwqvDe4+UZD0dCpiCodR4KjM8OWCEHadrpADreF6n2z19bY", - "Zm0mT8Ugf8YmETNuboSBfpLu6enanl3m7muI7jCdgbboponssAViP83w7M3BOoM7hLM7elpwPpooXts/", - "MVi9oyyLtX/Pd7sFKa+1yAkWzbaHNt96IT+H72p9Boetg4OdxMSE3A5SBC1LAOMj7vCPpwKiAFwWR1Dr", - "sBdH09h3V6N/kWtOfaM39DatHTExlyprzSmdGoBf7jGXvzXpjEvBYd0nRMEQ0qCyEvvHghUBkRCyMu3x", - "J1PhKMM6dLrWyK3YthToMSymZ6fnCS1LD3OjY3yoqVjSa0YojFTILJomuN4QCaekPO/ADOyiTsXuzZQq", - "hSLgnML/4evenjCH51BCz3dClOslcfiooYAfMCAb+rT1blWnNq8Y9rapkzC1l/bj9p0F9LiOUqKq8Tg+", - "NIbR3eVwpDzwC6wrvOsxkcPzkHbmYbj7Ibnohq5dBj1o2S71MWp92/qJiUTlrrmSq4NFo+DgwfqFqnZd", - "0tM0NzWMh8cPH3nEv5Mn8P8nx8cn/9FIJKPK4FPr4UI5Rb6V/D6+DiL+uehWkoSlgOkk95kU84Jn5rlS", - "gzI2qWbYxF7Z7XvOUA5ekJp2Pwz6SbTxdnP9xZUUiydG0Yw9OXn46PG33/3x+x+Om6ER4ePHxz/UYqdv", - "GO+Tq3/1mUfwv9Ar05B69Pj4h9SbyzvgjzY/Us315y+tPKWfSGDJShi1TmdH/Xr2+hfy6OS7745O6gSw", - "m5ubCddyItXiAdfyCH7PsBvMApsszaq4T2hRLunRQ+J+mwrIm/aAm+ZGHhXMGMi6gg8csAakoRRaRle2", - "q+R4zQSHFMvG+Xr7uhV11Yi5etjIOvv16dF/vPvHQ0w5a5teiPj6NM+lcJUvhkpw23Qr7OvwsOIQ07t7", - "dHEWRTLRPD9ySkAixPhzgKtwkmUgHACw+8y13YAIEH/S5ImekFN04E5HmotFwaYjIhWZjryLdTpqxPYc", - "oLfD4i8+BcxPyFjUbMWPMISGIG/xZTdKpXeZjut4W5Cz+JOpiFC8AjohuUC4oIs2ziH2AQoGh4rcdnAf", - "GFxjGmIN6piTXzRgCFTfzajKddojFApY6u4RHHI1+OjvGM3nVei7A93TkvwuPghjbppHrBH8E80meUGA", - "OAtxpwCnsJ94bPaxVU5a82iPwFjo/GlZhphF3Q8UUrjcYLf9wTLkug0eMUExGV6nel4J3HsNPAI4mz50", - "kPT+f3rB+2UeP6sXFHyPpJhzqkxfgDkQjwl2wtDMEC7QoRnXLPAjJ7eJFZ0ex9CSeRPHp+3zULolEasT", - "wFa/oziK+kRCYGBE5BjPW73R+2UB2teRDGjSGICj63DMTY7WeUHNbM56naA45ouCmhesNfS4EWC6sX07", - "v9B38aFBOxuo2+YU3ULYuwQUt4ua7krOvpXytsV+Ajs03yqrQ8D/7GAehF2DaEHeWuIgfrx+AcmkNuQS", - "qOd6KgKFCRhmbgLScp25EKG7glzwX2hmQE+6EPLmIkDouiLx78ejOadmIHrNDoq97bWl3Ycw7TDRiVdO", - "DlYV2nYN2kwYzJHQrbJRz9vRsEGAQHbw0/w/Kw2ZzHvuzlYv2xWKg8FZ/FlRAWi+QEJIf98rZ3QP487t", - "+kWDCj35qlTsrVSk78lISXZ7Z9ueho3xgheWiIHb2bWqTxruLVjkhKMWI+oTBshPfMVNp4cadpVnPplT", - "O1EY/g2ulxCS5N5DGr3E4U4YKrb2rRtOmV9HXJSVmRl5xYTVKmRlon+/29EOasFLdsyd7WtxXqlsD9Rm", - "3wz2ln8xN0ytdOPwJWTMNeUFveQFN+tZKQu+jyhAwRb1dI4dNcvJSjHzOeyj7s0tjJKFL84T0F4yabVc", - "7Nm98WdS6GpVugerZsz4RTTGxZ7ybYtgO20JtTJwvhaqJVOzSnB7vWgzg6tuXynumXcyOR6l1B2nMZRW", - "2cKNbwcODpTwhJmk1aEbXiToBRy348m3x2hjxPeG/eUPJ8fHk+NjhClEZBAfEWR//db+OCH2EkDAEF/k", - "ZQH73QoMKsixrwDQ1H3I8djSPxUX8woiEF1AwL8JKdgF4UIbRvPO2p9MjvtKaWXr3QThh9zrf0Z580Ve", - "6Y4R/zQ3OrstuWJ6KFCKiwN6FvIgkzzIfbhDO4SpcfE4Ejq7VLBrpvBXwEoBBTxcvzssUvfaBoCC+KDs", - "KcBfYCcvXfRNZ/Ludx801rxXvljnTKm4VNysG1EbJ8edqBdFb45yeSOIb9BkAPlJ3jDlqzlC1MOSL5ZM", - "he8nccgZF+bkOyTWbnM74vEx0Or+2S2SMx6VsW4w5GAn1Ivu8p6jnYo3MCVuS9VeGwTr0ORec7P5Ki0X", - "IJ3vT/ZNau6QOiy92WuhuBp2n7yQilz4Uj2IkOoxMi/C7HAOepyIZgrIR1F9GiMJE7pS9sZSimWGKHbN", - "BGTsZnIhOFbawtoqncpJbnu1VNQG2jMCokAFJrOk5htXAYehgrwo5CXIzhCBZRvClYtYwD12QUs87G0o", - "7IvvnF4u2jQZIFShfxXIsEUYTwWiv9lVxpAlXPtiDYvPchz20+BKt5FvfGBWCJKb7AcrjCvmrZCd0IV3", - "oOT9BrCAxEpucO/FGsahFPIXHOAbXNhZ0+c06Tybj0e3Rwt51POWHoaCvvZUBxt9bH9dd7wY6HLB3rfq", - "W8+6albtERt8V6Zv7PAa0R6AnJkYP44sqxUVR4rRHIy5+M23fomYCtPT35joKlsSqsl09PY1eSaLgir/", - "Yv28UhLfvoc+zqxXl7JIzwp/2zqv9EScn9X1gNNKTeUP0xEcojAlnNB//a//7X6wU4OJ7eEQ6gMd9tvd", - "g67tt9G9l3/XusF5rpge/kb61LXb/Lzkem9XKZ2Qt975AwibIq9xAlJFa8NgH8F3kKDRzWa8mdjPLB5m", - "h8IryUqzX7DNsKJqPWMrF4CYBLWynxD4pHdvNmGuoMFz6DOF+QJPh9QgkPM+GB/+wMIT3tOoo+5O9eVR", - "jCR+RGaVZQDDAkq8whCivT0O/bWrvm5FTQPaBlo1hu0PAOmXWQ6qbz+R5XH+tkmsL+NMfeBZguXcfRM5", - "3r20rbbha0HXdUEbD8bYrWcD5xHxcyAxgGdLt724bpZfb1dhGbd71oYansU7DkitsZQ+owJO3tc6+Ai7", - "RXgruDmV2iTYH3ZnydQR+ILBudpQ2uG+IdMRpss5NYP6ovtxuzGRaiqmo6JYTUf2yBdSXpGqxE5Ddbuf", - "fnqJf8mpoXY56zXFrbBQsiqPLtdgS7uD1sK9wgH3FAqpeIaBoqGghswZ649ZSHlyZwhIP0PkzkFC2d/h", - "vg5AOuYLPe4O9j6M0g8g9jTd4DPBWt6ArfzpsYu/aOBddwI24e6C87oPe/fu8XYdmGKdsfslA/BuA9z9", - "Z4PK/Uz0bnzYnhmmVvtB0LpM3je2g4QLPHo49/OZN++Fhsoefe4C81Dazpp4mvuCaJ/7/k6b8Jw9KLr+", - "btgR9/M83eAr0u5hkHY/V2DXPZFRQ9Tr5wuLmlYcu/kDmzFDu2CgDanTf8rHvSphv97qjKl99FU0brZq", - "qQ5xd5AYgq6fRi17dNP6i1CvudJ16CVo/pPPRrNaMaG5FBvC3P6RaNYg9We6Yjn5769/+fmcmiVhtyWA", - "BEkBT/vs1liS3DOkrEory9yDcLCU0D1izSSY01/YWofgGJeO5IL6NdcGUE4wL1FgJAj8WomcKZ1ZDb/J", - "hxDPFqbyh0koEdvegkDKrF8gIKl+ZV0tJV9KKVr8ZnZjqeSqNKOtdzn0rmcHTeCGsGrNfS4Ymp7OU+/p", - "x3HBAp5XBYQZXvGSyCIPP3WKtI6hJN2SayMVz2jhvoTwQ19jajL6HVWghl0984kIXXoSR6R9QjAuLJwL", - "LhZMW80bWPuNhiMSvAXrkMgevnPtpSK6Wo0JvV6MyYqLMUxwRW/jHapdiUTI6iNSAWp79GjjokRLqlzY", - "nP82BBK4Ky3D8lx1z+Mm8c1gN/8yhBAk0HYqGlLT8yGwslU9tT5Wf5iE0NQ93oFcbe1IpDeOf/8FdV5Q", - "8QEJxqH59ovKfjUwlXabF9IneyZM0rKgjQTjp/DpZ3JX2UMxsxTOymHhPptTby1LrlgduFpQQWCAdiaK", - "4xtG3+pW+K0PQmpYwbZ93d9+tVhuZ79VFADm09eRC5UKp3iOJnFMsT/HjsQa2AyW257CqcBE5yOfX+pT", - "oTEPbc5ZkYfzK1fcgO/ZHl9Iie40mwqwxt2XY1KJgq+43Wp+Mh2i3FNuHecVir3chkajVPjX55t3gIe3", - "u3E3y5X9RcrOL84ZhRLXhw4B9e5O1727hWJo00rj5cJ1R9T82Gx8987PGFqhTczn+ZD8iYEGUFp8CMwA", - "yMI0yID/dCr+yUAG4Mj3AAzUd4N2QFHIJoXoa4quSvcG1YABI0/dBaVvuMmWUyGzrFLaWUUBvghwr1tv", - "EBPy1JCCUbChmOuGa49Slg+FNrBi59xfbisuzrBtJL/P6zmOusA4pZIzK1PEYrYr9J1P1C+VPMKmgN+E", - "raPc6daRPq8/9yMl0dR61cTIVdKWo2GV+yV7N/hwcKyoFWq1r6cr3dGdtL2IXbcITT/Zbtj97iRP8w4I", - "ETOXSZ44KD7mwu7msgTDG/wKPkBYD92zjqynZem6jnE5nroh4hFIIK67gX8XIRGfr4rlLLh4A/Vv5r4c", - "/WG7ulvcaGe96+sT8z/hE/PX2q5fn5b/eZ+Wv5Y1/frY+rk8tn4ZZSjv6r21WXyxrrmY0HVybn6kBd3D", - "yqjzdS+xA3sW4tSYJExCcRCkmlMHbxC/PSCqAcuJ4oulIULeTMgzpvi1LzSbFYyqkLWGycdY/2ANpl7B", - "FxzBF1xRVbtMWANBVQVrVVE5gQz9VPn5wwHCdLp2BYUOzkLItr20l4HPR7+sgLFCGrJmJubvhJzhg512", - "nJwKekM5mMseNwNYDXtCKhelTOYVKBG1RPWFT2Pc5DRP+yAJaoaMo/0Vw2g1Nuio9whgZu9njxtc0/qJ", - "kIOBgDeKCk3hYHwou04rpaW6Y4ZF9O7LNqRzP541g5QHhqhIwQxV64AbIgitQX02CNsw2E7CoSmzdrfn", - "Wqxwo463YIa0Uljb14pizKNE/3r2+pfHD0/+2I9EbX898sPFUNRT0UxjDRjUcf+NT/pgqKdiAw71s6ae", - "/KihJT9KAFE/6gGidpR8/jIossU/gQCqz2GiChD07EoWUQgQ6ky5pAu2+2G3nOzQCF1sJu7cjdIC8OIq", - "BZ759tWZN/HhCwIDREgXJTXLURJ1bUt3UGV8194Eu93cm/2grzdRFU63c+Xlu8Yhu+ay0htH8B/tPYrm", - "f0+IFOe7Yzn0S+Cj6BSfHIee8D2ps+KuBXAomkr/Hqi34v+omFr77TDgDD9jhqkVF0y7qAIg3VsbdXEu", - "I4liRnF2nSrcWRcVS/Cjuai2b3tkxnVZmeARsvIh1DvkdnkUdaGJiUXA4M3NwzZWeuvQLhVnh7HTGwDS", - "60PMA5YFjeLxSgYaSAx1EGIGkohzLl/zC5DVSOinktU+NX6/Z6yQHP/R3rGCk69bFePVi9NHjx79UCsi", - "RspCTzgzc9BFrM7xQM0z+9F9goLLLqi1cY6ghLp7NudiKt6+Od25XkyQgaGnyMngqCKW8KM3fJX0bfhZ", - "veCsyBHxCmurrwf5PcdbFq+FDvzbQXyrf4VoQLTDizVhv1W00GTBr5kgr16cHsHsa27XblguCHD5/Xi0", - "MAckBYoBRwB8EKk8kBx2h/RIhUzyV+ow2ooDs6pgWu/Lp+LQfKqJ+RAmJWoP9cG6ynja9viCHLjnx7nv", - "YuUgfHVCnhYFqc+QtUWmQrr3rH/10E2E3VI4CVKwGt/Vl59elVRx3az74jlD4PgTd/6bGD4OPm+CPwZe", - "Rh8d8ZU1iFCDtqbNaMHNsrqEmkyyZAKuZC7r/35AS/7g+tEDD81nGZdCsOiI2sRHGIO0Y/gRDY8cYC2L", - "qfC4VQGyOxa9xyc/UPb4eH70+OG33x/9cX7y7dEPj384Ofr+8cP544f0j/l3NNv+FuKLevmRPPHkL+kn", - "M/eiNrhcXEZLhw9LHNIJRJWG1AwiodogPEtQv2lUAjIJZEZ+qCewXYHbmYvndPiywQPY8XPmrGCfjj4Y", - "fQt9n76C0oCHLlSCUg7lrxgZXzEyfpcYGeNRVeafUAaCbwZJ6BMzXaNlHFDJavndmEg/yodbUruc4JN4", - "xbSrbTTgAsJGGCzqzwQsyG+2y36jtafMhP2ZKHmze1heZxbyJmXcHiwl7nVcz9ROkuPW5RKz1Q5UefR5", - "XXW0M0jK6t5pgV0ZoiHqhZI3PjtRDVzqYXJmWw2SVVkBKLYd0D193EOB/f/9vySIjfsT8nNVFBhz4yOh", - "HZhueA6cigBsC4p4JleX3k8s57XqBJtwq4fx4+UZRHN3GcAmCZX2DP5OVkwDfxD9P+Kb5QcEULHbsqBc", - "YK3udT1GBsmdlmeXUNBKy+LaRSfdSQowgqj4jqJMRntvu/w6K9SvmZqQCweD5uCHPVTajOcXaCJZ6aqu", - "Wd5ayM7xuLsyx2DVXVbZFTObJ3N3pYoHkQDn6FBHtQloV2eURgWUOyIMCRijyGjEudQFkBt7bYO4a+mJ", - "Q6+zkJAiCXU6REd1jKudtB90tlR92cxZENNoc7+Gs/KSlmeGdSFpg0fBklmWxdo7LqJj5HZCcI2v6G1M", - "CTxyNBTWqK2fR4LNe1kZiXqszxoEwkQ8n72zn+uY001id/fhun3x+frmven/SXzyAfrRbXzYbvsBQH40", - "r/wLqS55njNxx4XPwziHqnz+KF35vDHOoNLnj/pKn/+ZmUYo3zlVdKUjX//QmlREuixMK8sXWGyyxih3", - "4VSHqHONgi96mnh+Szc4VTdGHCYf6/4sBbvjjWOHONCeOTlO7xk/xJDtcnLcu12sLiAsqe4wP80yjyo9", - "wFyARgQH9bmHkBref2MuqZ7RMFhfVd0IEhdX1xRrsqSaYNMQLeFGmYqpuLD6+gXiP2OGHiiM6K1BmxtD", - "ZF3AI4T6eBMBES9sW6fOTEWjBVxQiq2c9uy3P7kAvlzUMf+Rn6gSdfeIXI4qEiS3w2Qg3FIxmi1ZPiZS", - "kXstdL/7oYpXCM+cCna7pJU2qKA3HQb1pfnvgVfJMsSKUT0EKqJnv7zCbjY4h3CgKCfCL2suGZppMLP0", - "spJzWaJbzkEEXNS7B2prOfZvYoQnsXXTRNvwXVJmbJrvUB0TWEDjvQH2KXTJLwunfMaA1q0oDo8evUnR", - "7KiMT8N3RBtVZXZsrHTMbs0mlj2th0uwZlgxjY2M7DGIX9JsyQWrixwwK4pDLYo+sk9dHoOzg7vi5d+b", - "pRMSvnkYaNMYL13f2+L4XUlUT8rgLZaOjOwwxp2uUBk2Z4KzvM7tgh4bSRHiSsgbEYoogyyaOREUpQ1E", - "siv6q5BmNpeVADeknKFsmjXDrtuWfz1NMHbqi3j3AwQN3SawghhCYEuqDIdKNLqCac6rgizCYOik2qCx", - "/1OcqZqld3OUvEjq8eB6We5eXjlTtadehVgvCiWc8ipjOdp4W0/ZabfjlC/qizvoreXqPnyHxXHKVGc/", - "zykvfNnVzpEOrrH6nO5wIvfLa8YzaSRh17SooFh0Q+i4CRSAvzcPW0WnLIZ6j+21/90E/KbRySrqUU7s", - "hw70wlfhjceJbHoXVOjEo25AVCR5GdTeOiCxZeTEBWaxEBfNlsQ7aqMSKH9bWg0RtjJ+41fFLZM9Atzn", - "7rQGyZYsu+oWW4x0rDpXNaZSb4fGCGu8w/noLOewjflTa8dFMkQ39mu9T7t78oqtE+bJc8tQJowKeFS1", - "0kYurtj6AmDxXJp2VGTEV/LAjyZTcRbT5BLY0P1eL2pDJwRrRTGXklA/0MDlNhUXIM/0BQFHUuMtrSs1", - "6a3HXXHVErswLEEAW0YgWmbfnLowF621B17uvu4vohrXA5Y9GBxe4szrjPXedSdn8xp1jBZFqIk9rdUf", - "z2ypFlTwv7uqpbAaplKC5RNyDkE2AasKKACUnEyuVpD3PRUQpW3vwMbKQSQ68BeC9SXNfcjYJc2umAiJ", - "7nrXPfrTgOl/8DbxjsC/WFIOtg328tT6ZqGgaOvm3PVl2rk0InGJz6B6DAF3ePpLiPZoC99dX7C7E7ZX", - "w/t+XeQZunTbvmI886ksGNCMUcfRhAlAhYA3mpslLwDlHCxP2LANIJJ96Pd+sl7ynyOd/c7unV9RQwJe", - "AnS+m/lD3BNZKbkwZEXX7sjWxkN9DrnDqa+KAh4U8a838C7KbjPmICeYOtI8dy4cvVl/7PfNM8+QXid9", - "eovs5Zzr7OSmny65jT9UQeskH/S8ebtLBh6FqLEmaOO2jq7CXayFSMXb+0Guzy/6PlHbKxKzOqSrcOUl", - "LHpFXZRf6W5SxRpeQvijCslJXJAL7/uyP12AU5Bdg+aPf58KVDQ2308ddyS+75EbqgMg5waOhjs4sTXd", - "QqUtQn/5xquYtghjNQduzVqHtWoWuF8VhP0y3vUJB2XLymRI6NH9GopjmdNsK/CtGkhLpwWH6DHeVscc", - "dd4fqekqdkjLoqClRq+dx0L1hwvIHuN2wIWLlrc2ky2jWE6WDG25/mu4V750z0tCwh44wO1NCGrzT7lS", - "W2ZlkPC/pKJb0e4bHZ8HeDMsWIabfSpg5ZFzm/bjW5wGYOO0RKrfjpGvIpICDQ6kBG0bqrSb9nP2+hcC", - "EX3+mzoBKJeZnuR8weG1xcdxavv3auUD/h7YD+yXD344Pj4+efz990cnjx6Ep9MHasa1nNkRZr4o/gzT", - "DyZLs7rvMbabIevnJ/8zTgxysxg1ko3P7/3pyXSa/zf4n4n9r/t/+p/3/5T468vkX/+W/Osz+OubxC//", - "PqDv1/f/dP9Pf4gtyjaXU/6eM4cQ/vyaAVTDZ4k7ANEKXCwaxH4C0IEzcU0Lnp/7ZMnTpeQ7vva3rn9o", - "qGMGtNE7O+c2nqqH1nGfu6hzSHxpvmO6wNaezhoi0T3C1G0hPcSzB7NqduqqKhJuOI6sqxNNNaK/RE43", - "+N93O4yAMqFJ7KXM11sdi9EcNBwHoHUclmOXNX/GSmt+CrPHsue+bXvl2wGSv7/FD6yZwViwFjty5ZAb", - "A/dD2B/Rgu2yN1zmic8eGLQ3PmD9HAB9o/H3KaD21EIDpnx4M15hRjgV5PsoS+JOV35Fb2cFcgzR9vFc", - "wH9/GnHg+bnTkiNg/kdfco/Tv/eSY4iAh6L+eKvNRbTaXMysKmdc9ZBZIW+Yyqhm7t9VWTb+jVXr/ddh", - "o3DxiTaKW4VdNsprQ0VOVf7x9sgdiPWNFQpwwq9gwQ/I7V2Yq3fZi7FNKAXbpehC3xq+Hw9r2JQSg1s3", - "rpWhrSMldWjTpq4DQW5Nn/V2taSxK/YRGGFnjEdcz/xQXAMK5XeP3X+7NzL4hzVOZw7SgeuZF4bwD6tS", - "+P8CUBr4b7ex4L/dpoT/riruxp3/lgtPAUR64ANxXWnKcgbcvzXaJX4PiZ0j7+PRM8UW7BbBJ+3U3aAe", - "GWsmmLmR6moWv07O/i4FmxVcm76vM56r2WUhs6v2Fz5Z2Y4bmYD7aFc//fTyVGpASS2GPiD+9JJgu3RQ", - "c/Pr+iWv9onkrBgTNllMxmQ6WpTm6PF0ZP8zK2iVs6NHR98eaSkEM9NRMscmnTv6c5Qz2hrjz+dv/Bin", - "MAZ5NPmWvO4fozevMCXAYl6eY4rVUKBQeRWlZ4H/WUAqp5tHzoRcOTO8hIfwKyYSjmiaLdnMrv2sZGoG", - "Xx0EB9P2S2y/Dm840EDuvX397D7kzODgN4obdhejQ8cbhueirMxhBz6zXW4YUlbm4GP+An1uGBQvUgd/", - "f7hxX/luidxMQftktNie4MqGI/PLNVOK5wwLCgw8NLg89rAgWAKE35dMHdmDqkuaBXRsN8qEOMThEuud", - "gCwd4xmbCiiI6QPlydncHkHfktDC7v41YbdcG02a6ZKtrggVeQ2tOCbckBteFFB7E52tne5DrC/032ji", - "0pgPkUiwJc3ytAEGCQ+oHof2cAU0/4YPL1zXk/cV4MJorbEPlA+YGJndllwxDePB0iUxrU+pkAIKcuLy", - "1i8KycsJO0pfUa24O+zPfprsqYzukp1mn7qIEo8UjcsGMSCxdhDs4sR7ufvlwTUTuWze49vvztBvxON6", - "bo3cxtZ+2yA4zgOQ/oD3XlGjI6BgUCyTKh/XCAT+xR+/CbLPPQh7TFknMODdLvrzR4OSOf3/2fsW5jZu", - "JP+vgj/rquLckpRkO9nEV1tXimwn3o1jXWTv1q2pkqAZkJzzEJgMZmQxLn/3f6G7gcG8yCFFinpVpWJJ", - "g0cD6G4Aje7+2dwwLofCcDM5tldREOxJEXfC4898rtmo9+Hk5aj3bSM1W9UluJwNimQhIRtXLEiG1Srs", - "HT4kF4/N+B3ecu3ULaZ1A6GltOWVlVato5m7B6ysaNqinq12qCdovzm11th7oeZW6t5qwSbnGvpU04y1", - "3gs7yop9R4E4wbqNDOhSfwKHBeYmZMSskYYNv3n/6mVpWaSQmq5U1b2hbWOgaatpkfYsL8v2jhO3EC3X", - "VW3ENhX2IubtGqXZLQzfMueGfkyg1uhXXmWk1a/dx8V8rXPzLg6q9mKsEiF5hDdjLrNpqpIoWPvWXW//", - "XSLk4Rts/3Bh+6vduF2CrTYfJi8P1PfPqmmg/IzjfPDn/uBHyDt+8PVJ8etgeHb6n97Xv9B7/OLEHUgY", - "05lKhXO0gwwx0mY18vE4cgsfjO5HcIVxBdFXKEXcV8HTYArfg1Rp7RqbJ2anqYH8qzFDwzw7GHz/zHsP", - "wDhO8qbGHB3gijOCIFxcqE9KShFk+MtM6Cn92awcOFyNemej3nAkfZeLLz0hL3svepnQ5AZVSq7wnZdc", - "gVavaV0jnQHott5seLaZSpg8xFNefJlaJxa73zGg308w2y21XK1HXxRXrlgEVK8zyq8tS4b4f1taM8QN", - "alizYixbiqPHjtnF3HdVPHG4BzaUnPFUvDCfBuyctqNz+IVge+HncSR5jD9S4sZzU6XqX++36RzowcE2", - "QVOHqz1csBxKZz9xvbUFMVvhhWm/Kd0Lz85WC9Zbcumwi+E6NethuimnhFo0HQUkzLZmBOOEEOrnBiw1", - "5UQPhNVUzvPQX1k86gA6J9hC9/5JTJYthQc2s90FybyONrEsbRhUi2bHp6G2RjZXxRor5E0iILatSofp", - "etFKIZnR1pSIa78pT1643u5mp3OFNcS5a58FdJl9VaS6sEHo6Av5kjwfV42/c77SXhIN6wfsoiua4Vna", - "E0Za5/LmNvM4WxnbuWncbbE4i2KbWjMy+pO8NU5rjax1QMKpGkexRTS87We4JObybN1ekzSa8XR+JmaU", - "o2flFjAvghdGcEZhBGvS1CZ74Be8JZ6IyPeYCeikPaTnbFULXGlobSoZe7W4qF42PacW3rwcrpparmFq", - "l/dv+6H5WMsmtMaQIRkjpBkwf4aoG0vCsLeGmWytsVNWaTwrqXSno0cCkBaUpm0PHnvBUwjhuWx14DhW", - "09UaJ5+1hrjkhOOyIG5DwdgAm8ao5LXULnhUrbdDrbnTtE2cb0bdkn4uW1z1VrLotbOQd0onYEQxnAzZ", - "f6OR7qP9dvpR/HH6tw8nL6vPx9sgCJ+K37ys0GK7RVrAlar+Br09euDpuoki8+H0Y6BkxiOpgbLeWo8v", - "q1HlnmDLNNk/4yyhzXvL20yxv5RJwT8iIfRU0CpoECm1JQlDB81W9bTx+SCH0Is5+yTw7rs17iy6Qs+K", - "1vk9jvm2DBDmjL4VM/M9sRif5BduJre0BNrvYukJf8Utda1KcHFbv+Y6S+/4ZvPL+FasvlyHlNsaIhdK", - "QCj4LBaKMeB5TtVnlinMeQAPVi5Ju3dj856e7GfsReeVl2FAD3zegh5YofANQ0eCD5TdrJzPn/wkev8x", - "tO/VNC//MYQfvvZ7QOAZ/TlJ1SwBT+8QgLR+/v67f//1u+8OX//r8B+/vDp4+tv/7h/9z4+vfyFUkhc9", - "cDjSZ5nK4DUZxRZ9GzR7T3/1X/AXDQ1yzRdu7UAltER7sZ/tz5/BrkoZWODQq9nsCuK1DYdys7S5LpLg", - "U0L2r/1HzK27j7m1EfyL3/hMhOzvJ+9+O+bZlIkrMyOEhaGYuMoMSeiBm6o8MXs98LqXTAPvm2BCrb2O", - "E0wevIQrqcFsKsGPLZlyiT7SmNRLhiLVgUpFZR483VNTADVN6WuEJrstXY1JMmyGO0pb4glPOcWBUy1L", - "IK5QYZ5tFNwDnH10JClbFyp1PYVsQJZ+UtTsgxbjHHAk9acoYSp2Vjf2ZjySFSgxHsdsGulMpeBxS7d5", - "ngrbbji8S8hutwTl7LbDeNW3quqUNeiCqiogZBWrAMo23m806AKHejaHeX7vlyuQWXQ+6zN+OemzWSTR", - "Y2bGr3xR1HiEsYjZKeS58VA3yb8n4am2mQqxLHT7WqWkg84g9Zjfcr9MPBJlFRcnaM8hew15UHOZjWRp", - "e7Xz4KbSEBpNJJoXff3hzgJL2GdtiLV+6VBRUoOnbefJw/IxZO2zROGYR4dBM1UuqvHM/sovJxRyjBHq", - "RsDBganJfQ8IvL2gKXge3wlkCnTtQfXotW5xZeweizXUlpyw0zHjpqGFkFgQzgWoXCMJpw1C6n4y6ok/", - "0MMukqPetx5IMW58Lv6zDbOovBxfFy7QzymXeczTqEnJvocDlStQgs6CgxaoHoBKtqmYiES7gZtTi01V", - "BKhyM5750nj8/uBtr2/+MVee44OX8P+37fJ2jQzMhz4H+UkcvcMbnopK4PL7L+A/c3+a+JNF1JrJgBje", - "3oveh/dHCMXltfDUa+HrIjSs7jeskmS1Y2lX2ZMkZ6vAbohfxgrsjkg7eEZ0kf5amcbVR+6zbAtJ0Z+i", - "AecNpgQvCB6BMlMtGLYj6cZQAYXDG4XMolT40JbQ9tnF/KysjRZj+fkkkVsGu5iX+PJjr2RdOF0hDW1V", - "+Xvs6mXZJs6tE+pQ8Qx1/vEUptW0w7gmM41Ls/zm8LdD1Ar/NgVeEvLsSEIiuBd7e58/fx5GXPKhSid7", - "pqWBaUl/ixlIi6Y9rPLQLP8sknjBAJ7DEM1mSD/dBkv84f0RlIP2XRimbgFv3A704CIhydRwmcpeK7np", - "25Lqs/kDPc2HZ4uP1Z20ZBZdbLCytjB4dRpkeXqhel7WmiT3QCXbNGy77qQrQe9F7+Dp8Nnz776HeV63", - "ta/dvahwiTBBLvAUYvAapeCDITExS7I55hPHZNaU7bqri5W3wFtG6F1Pa+9OFjp5jpWnb0MovpUjpy8u", - "d0ZK1jspPwLS3mpAWlrlzQDSeh1Au3Wpw+5WApu1aT0xnecam1UkJ2QJHas4Vp9tLPZRrHJMEqpdrHXd", - "HFpo9JLAKbw4zhJz6PlFxLHqs88qjcP/B8MC+0fp4OQkEiT7u+Bgf8xDMTgIfhSD5+H3weCHp3/9bhB8", - "9zR49v1fnx2Ez4IiPPFFj8AIBmQfMeReilTjKA+G+z3PvcspkQGYVNAJq6QBKq855Sel1h2tK1JTYXlO", - "+DxWPBwy+0LQZ9GYkTWPRZlnfvr7ybvfmCLXsVYs8IIrDFEA/iSzZvv3EX5EWw5Jhr/isPcil7J35tZc", - "iMqoRziAkEX4/7SSox6L9Ehywz725P7L+/fH/g20Wscwc2EUq33tgHduSETBWxhOCudYKEZvnWZkPJyK", - "1HyEBO4uX3GeRjWz3FI6FsaA6uJRpGwG7MjiSyzMenk4LeZVABwws/V+nkbwtks8OOVJImTVRlmRJ39+", - "Bn5qrmXU+XLoX4NQJBuuQVi4iSFLKohGUbw35RQVVQwBu1hGYOHzWUWuN79dWPYhlByL0QVd0jHGTm3p", - "G8GKpSP5xCUACAvfpG/LpJYV0hKS13MaXZYz3aVKUAH5yoiCNdhbo4dQZMwd8ffXR+zZs2c/lkexQIMu", - "FaF2HcUjqRlpInpAvbA7lNVdOOepAEBOa4VRaYTIG3IyksWoKjOvZkP6bajVTEBL6xjmXaC8z/JUs2Cz", - "0wp2uBnIK+qydWMv5+teOfWKe9GYlTd7iD7GjyVwkvLm7kNsLDtz2zdPV/ZGdvEzfPJYYxsvOd8vqul5", - "qTcUe4rFvl4fncQG5DgI9GX4JFFJH2k/ogGW14du9VdnBUugO1k2k0JSFjud6AUTXCu4YdEDOMBStUcy", - "wPco0z6cEFxCrKP/+kEHa1CFvdndIiQbnb1cRCECK7RBJpFtkIpZ5CTaa8ovrasZQKqK5Z+uEwebtDCy", - "zGpKf5H9qT31QfmIzNVUXZWi1TQfNFGfui3ArRYNXB9mtSGdD+KkMpe7DHJAdQULPUIQ0O4ApabLaT7j", - "kt0WkNLfVPZa5TLcMlD+b8rcf3MZbggtf/95M1q+6ee17WcVyPz9522Q+dboUE8RQx5VzkNEm3M/Ty+i", - "LOXp3Nw0gwjO2+QjUcZpGY0G//1xf/Dj6V+ejEZD/KklGcs7D+OJIDrf8yvDfSvDJXotDWJxKWJG1waW", - "8SvkfncDocwQRungQb1aVCNkPZ4KXcI4Cj+1R3ebVtJcYX2wKsJPNBNkNpU8UzOeRQFAOxfnZR/dKtIL", - "0kZu1sWydHq3DpTN6egQDBuyBZxl/GrFNBG0jovOJC+rC0S5Qcu5GZxO8j64Kih1lwpyUN0gla7PMoos", - "/bFE3jYhqzxXrQ4ZvOrz1LbKq+XpOuYT8VY0vc+4m1hSwBniG5eXdNyihYIPtXPRGpPZqvxSU5YNSiPu", - "a8Li2uVyjF8NdCL4J8H1fJCJNOVjlc4G6GNVJHqL/iyrVM9TY7WW0BW83NR6bVXWz1UFWm1HLQvieQfV", - "VgUnFDWftzAR+X/gFbQ80wnt+kt8kkSjO1Ji92iSkzJ5Vfo7TvNxzCWknlrVmcvWq25vdAcyM3FB7pwc", - "4oIwoEFSMqo+qP9UwVYwkmQWwzxV4FtTABkaRZHkaTDlWng4/zFvSAXO3VA6KQgYgdNahBDQ+HYAlNVu", - "eLD0RIg7akLRR7f+e+HWP07V7AzCkBLDft3nqeRA3chSn4TzNAPxgA7Qj7cwrxLf2RSvzULhc99rU79o", - "b3NO46u6gM/41dkfOYe1brtb4cIUWxVwjT9u609MAw2dvysIHXutUouzObCXBqdEIDEo4LAU6QEJ4hQ8", - "FWd5nEW1akYVCVlkJ8slYPqKkNnB1Igaeig6Pgr2W37lKvWacI0eveS7e8kvs9RYfPNGk0Mnu8wxPBpk", - "RzzjsZo0GGTabtv/rHa5DPK8my85bmV1FdR4UrG78e310y4OGjvx1Tbd397JobxThsgdTU8aBeL2zk8p", - "/f2OJmiRdlhtjmoKgxI4QAJvMI6JsOlYE2mdiy2YUHWW5kGWpyK0NplNm1Lfohm1gICAcVMGy9Xtpw5Q", - "rn6oSLg5luMbJBQrvziCUtV7Sar2Up6JgKeh3gOHmD3KXfMPeM9qRUAnXLfuJt0K9sUNmnPtPDWxcy0K", - "ZGVXQrQ/EH48IUVgJJjjxyF7l4iUZ4bDzZVulmc5mO/EVRDnOroUfQhAHUmAa6ey8JJGriw8Y5ySJ9W4", - "XjZhlqjZBUTSe2m5QyJS20e5WE0gyPLwt5edDwf1+ar4oC9ClQOxQAtOS3SXnTFmy5UHQO5qTVGufyxr", - "kcJtOrYXyWXtRdqC69eb1Isx6ys++wsnTHadMYchRBW6jlQun7oCnsjMYeeGO82hafYm5lGl15SSd7/f", - "kJAUDzaonRi2wSgdSBclZkPZrq/LJDMjZmBpIrU248ly1TaSFd3GHlXbLVFtiGG2tE0o5TVgYTkfleOj", - "crx9yvEtT5ips0BL/i6CPDWFjyEGZUXl6GrbEBacAcm4DKagKcGoH8lMpJc8blJmptxmTEtgIRqAlw91", - "nynIjk9Gsgqp1dQhi7zT7OWGmgUC+j07rO7kvzl598P3+wcvKU64xfZr23XxxH4AMfPihx3txxBAXDyR", - "Un2/mmuL/IWr1wNaCW9Up43sUhiua8JxCFZryAFByWT87A9eHCO53c4BqdtmnPXHY/9K/oM+bs3z5bg1", - "p3958t8vztwv3/7nf3iTY0fA8CpX0xD2+1su+USEP82XwCFFwZRhzkI2gyraH9VIjuQ/QS9ZMAzERDp/", - "AVGetpyZHKwdMiwQz9kTgmQMhWQXc6bylB0evzGTmOpvh9AYdrygMUqui+WojpcCrkNNr/QiaCfw/iwm", - "6bRhwouWm+b9RKUZKK/mHeCc6+Cc6Xw8jq5gI7UPPLzsXKJVmjGVhpRPTQdChpGcDDGtyblp2G/GciS6", - "nxiGNCWwDjYzHMm3eZxFSSyw8cKgwmZ8DrZ+twNFHFK4zWacaZHwFKxccaSz4Ui6ZC1SkZ2bqtdp0PnF", - "oNjynojJC/bNWKnhBU+Bvm++reAMeYZiKODxezGvTZNeS24IOnlOqqxafiVc//ZTCAhE+cSHmLGkLtCf", - "/Mk4//PPOaa7+7bzGRDbNmWCrEgn0dzFSgdBBDRMc9EvrEfu6ciGBT2RSg5kHsff/hd6IeHM1GuMJL+g", - "GqZ084lykrWNL9JsAiueGt0qW6cwFldRoCYpT6ZRQDk0RPNkTjLRtTeV2mOd6tbzSC7sOl40zlhovbFB", - "xgsHWXS18ggXdyvbObXhoNyRUVW7gP1OvifwioZhRjxjIE8Dmz7SPS+DuhqEwr5kJtMUEIXwPjCSdPGl", - "HEt+wNGhOX2+koECDQvtvLTNLDyF18fSNEHNoxBXPMjYLRxFg/9nW1IS1cDMqB6Qty7mTETZVKQ0WpUy", - "TxkO2WEcu5xdEeFi2Q3xv+x2hHXJxuBtLzRblE1nCK5AEzUg2ukqMyzdRbwig2iWqDRDdyVzAutNomya", - "X4AfrEqExEgWVfy8x5No7/LZnk3z8rVp38GUqpvbfLayNWxHjB9Zv8r6xTCB1VmZ00fyGqzuTkXWemh6", - "pnzJyIPLxaFWbkMy4Z2f1/G5Q3+7whmGjBHVA3zl/r1h9Omu/h2wMjyEUMZSDgL/Pljz9OAbhaheh1Yv", - "VcFiSm/e07C60I8eh/fQ43A33nq3wxVtsb+gc8AjSlBSzAYCMPwHmMMUvAFZ1a2vzUfvfxb559kOb5pd", - "0eSUqIjC3G1Uo5uAz1xDNhkVX1L+oO3jnW/er+9aXnGeY6W/TP3Sftdk36xtwrfX66l+XtiJ65NPxq13", - "ofOJ3c10USzUrZ8ponOnk1QEjK02MVS9CEWsT0k3wJEm39wu9K7hZnDjNEPZ2k5q/sqefJDRpUg1vEJ8", - "wJecX31rF3w4UWkGTmvuOSStpE5ZmALOf7bZH/z19OP+4MfDwS9//8fb344H7/85+Pfpl6ffffVfboDi", - "hnNBFRqmZEVYPl3rGBZWPICtZoeANbA5yJzVYQNdthopKj1u3iRhOrAGCXott6nh1zJIdFjVTdkoYG52", - "YKGAfn37xELLBMnGhk0SHyTPs6lKoz/FtkP830iIzYDIZMNiHG8emwj2P2gO9vcHt3K8/0FbvP8HOI56", - "ePGvroya4/GJyAg0er3E3VSLXahwDncZOPjabEuCemEJnwPEtXbdEQA95vLESOSRhFDk+hZzLXj8YzI9", - "HSMJxYBbIfPNvU2Kz+1E15MwEoWNOxpMPSGYbnqSuUUvHTJESUdhptx7uYyyM8DmRE2BQWAjSZeT+kS7", - "CivPNY3vg4yyI1O/PqvOEpGIdGA6QtTQErIYINCwET3jj3rkoz2OrkRYrtdnKh3JUS+OZ6OeUV2xUp9Y", - "nmCjDljEgZPaJDrgeRMyzF4lUszvPbiY+w8XQ3YiMtPmuczj+Nz8FMSCU2bxK8Ksc6T8FwTeAQ2CXwpm", - "GDmXwZTLCc5xLZWZ1aW2heas0sg4kOdmPbbBvNJ0n/Vy6lfV3iMO1e3DobqLtrB2Jl6Q62U91l7Q4FKG", - "f0xusonkJs2LrUWa0avBWjAg8FiUQzO3WmPZA+DZatjoML43VPc9yH7j6cMvUrYc6yE7wlDuUQ/NxqMe", - "U6nZM8kdbNTzl24Trd1Z03zKM3EG4XLNxnnzncH3inm+66WODj+/m7M1T/G8bv0LXdvLIqvJfFxmqRLx", - "p+2yliQ2A+RLnvE1pa7cyFL5s6f6M6csVj4uVrq0txGnaBrk4oM5t1H2SpfNcso14yyO5CcRFrcNRxfj", - "SeJLw6taCbyepdEqUtw8hhNsZR3CsWqVWNtgu6a1EdipGkfxmneLchsddC/lY25wRATXIMhgEZW9XxNs", - "vNmd8BZo87up3XQOeerSlRn3mKet8ExAPB1yM3Ng9jJDuUQmtmdcbJsaj1Z5JIvkSobMzyr9NI4J92MV", - "Mv9lKzZTaru17cM1PZKTIjWfpahN47oJ9IjsOw5vV7pW6onO9RVvQ0NLBZAnyZmDD7iGump6LU2SQkHZ", - "xM7OX6P60cwHrcGZneiVOdFqrsXJiysc5vjQZSo20kWYUtbrvV/SQNUWauhSNMqfyuUWKd8i8/J1ln7p", - "etsp5mFo7rOrLzvVWzyz1LozlNuJZR9cAiN+hUmSmy4IdtpcZ/0eJU+fr5LKGmvgA99pfcbw8wIaaTT9", - "xcTahh43n2tsPkkazXg6PxMzspk3ZLXAIgyKtHKYtzDHVOEVtNmU9UnziTizISgrwd9bkzB1+8G0dOg1", - "VOe3tzxJ4MqrvDhPMBqKkPCwyA3fqUUKTkIzEqWdLz2eQK1St007U/vO4/IRrad0ivyHd+CKfR+y2D3m", - "n7uX+eeaj5Ndcp4VYry+BN8F4b2jm5pZtxZbUSHYFlOVgu3R0JDyWWIzCvkez+yQtIv+HGXBlGBlNL0d", - "ZARWG+IzqDulImwtO8xYLLjGvALYDKBXIuutaqWCbHJWM5XD9u0GXIyxV3ewSlJ1lsKz45mQRhOGJYMA", - "vm01GwWSVA2wqhkA1fbuaZVstMdFcdtT3XLQLIREfbvsOcP4OuJn3aG6XNJmeH7QTYnF8GRh1jxJAJII", - "3qhcBvpVV5bIOkwSato3RB5SF34PzBFXX+ZH7bHBPaHECI1MWTmInuCpsTGRAX0zx5fhUsApeKQYq6Yl", - "FBJfhiElQhCrPGSSZ9GlhXl1qE9mWqxOIqAlhIE+PH6DOYH0SM5VDskTAIcFz766T9mJ8I0dWu1Daxhs", - "75ah9A5WEGZK/kNJaQbrQK9G+f7+0++Zu2oev+n1ewXW0/5wf3gAbmKJkDyJei96z4b7AACV8GwK3OS7", - "FUFOPfPHichaMrPyOPZd8TEhUqTkm7D3ohdHOhtQK6YLm9K+9XhaFNnz3GwjJTEM/mu/ttwQ1k8HM5sI", - "30PCRbdadpIniUrNYauaB4CnwqZ3iMJz+PeTmOMPhj/xp8Jt/Zw9IW3+LXwpfNjPTTObyHfAinQHI7lS", - "vgN4QE9ieAQl3RyZWfqDkgigDuiZjnv9XoHxuNBX3SUhgFeAObDhWKWzhtWgaLyl69FrpmtsneW6UWb4", - "D25q+tiwjSZfO4/MUIjkXeEyaPsHln66v29THVj0ripW5osvHSlZEG4ASqaj8/fXfu85UtXUmaN+7yce", - "2q0Zqhwsr1L1mHu+/2x5pdcqvYAcJqC5dT6b8XTuBB8X2egmbjbwj55uopyqjJKqGqV+NcjNhch5+Jiz", - "EvlQVUxYIGqMg3dZ8dRYViwojwMbM0JnjJ9UON/YmiIdJUPC1/IGRsOocNXBZrmqiYHQPEE66Q7yj11i", - "jG5cl4G+9ut71d4X+PdN+BUZKxZNWSNO1DjDmMHCgjFnUVjnMyzk+Kyyg4EOAx9dp8Ko+16VT7rqNAoD", - "qCur501YqhBzeTcYwNR4vryGRSWrcEx9xa6hdxoPMz+LbAkvTER2Gxhh/6b0y/1kq37v+UGHofyspKjw", - "YMEh19nz8gbeQ/+/AkKnjQPxrLkjJtz8DtvgCddph70xCXAWjEdB8AXBsus2t+89ngbT6BI27+Zz4iEW", - "8KSG7rl1uaG2HpT2pnvpQzgcOE4oscG2GDPJL+JIT9sZ8xgLdGFMauuRMe8nYzpO2ApjJskS0xy8QMax", - "CJkp22adM81sxDa3VZ5KkodmXsF1qXPKoflw2sAMe194ktDNt/2KI8ts0XLNSZJu2sh0eJt1UeHW16iQ", - "kuQhqCFYd1jRjtxEbmn0TteuYIpy4O2KBnby73FPIpi+uFn5eB1t8XnAI/OaLwSBCkX1AYAeCR5N/2D6", - "7zLXMFnKonJ4NQzrzBM4yGG2ARXH6rMZo4eJ/IIqfjRFT/+GfmWbe1A4cuTs+lHBumA+sI2vpBPqCos0", - "Oh6QIN+95LHdd5YcmYqm94htWg/x7hUCC1qq5kZCQa5Jl9ELL3q7GE6dqzxl6rOkiiNpa/rOtyzJ00Rp", - "oVtfNrD2wDkIb/ONw/kUQ587euxwvqc+LU1cXi5x919BKgy2fabf+2L7MtfZQOlscGFduhbs9UpnkBdA", - "kwdXIRGvVVoZRSQ0hBakwvo0ulBJ6TUE+S/DaAyBDRk7F+OxKJK8nUN6ubZ7i0d3l5NqMeTrHldbd75i", - "XF13vqLGxZyNI+6U3xwdkBbvgzY78EdTEyKfT//24eTlBrdCpbOfDHlddsL+7bs0Ev2Rvtc76PXuBhXZ", - "3oD2Wfqub3uLapqkdTMkWY9uWtZPt7rtWvbc8Y5ryWjcbO3He7DPOrbbwhaLsS3+Ftp427XFtnrZpU42", - "5Q0H99vKnddzh3u8+bqb79KJr158bYWLOUTbdLv2fhLz07/N5oPwYgCJdTd27yVqdn/tRUIe3LW3UA51", - "7eRWp3fqbbALbo6w+tu8Mpbjend1WaShNl4TKd7wnlwQEQJyIWO0bErmvoc/1tziGp3dvP66nLVs048u", - "b5s9meNQu69+v/nkMRHZ7VnR/Z1ogAfyxLMCp5AXWtW7TIt0t8yyLR+ztbar3TDro89Zi88ZTMtG98I9", - "ssa33tp83Tmwhe+tDsWEN+2s6SfgeWAq1b3bEPrBmvo19M/nu2SobevZhqRPu1W5q/D2owZe5PW7nkis", - "oo73eJIMbPauVSRp4CreI5FqSV65G3GqpUdr9KlqzpP5KE1dpIknyRYkCpN37gVTEXxSeTbQlPS7g//D", - "R8q7eUR12QnWPX1iIRZCFegh9gAIC4QIoF13345kYzI67EMzXmscc0GrOBYBJLiwIAMzkU1VWE63mKKT", - "BY0f7cg0PnLTQDzVUU+LLE9GPTZToehTEiPqRLsuEOBCj+TnKJsakoIpTycWq8GtVzSbiTDimYjn2CU1", - "JMIqsQ5PwGYZGudZnpYxH+3yw7S8VimbKm2asjNoB6T7LBVhlIrAN/RThi1ndv7w+6+UwUjMLkQYitCr", - "n2vMyRLEkZDZmRZBinn8IxllEY+jPwWlWh3+H8zbXOXpSHqqY4nPikgHyAyDKrvdD7VcOVngXJFVlAZM", - "XLxb4+hhkiykTedx1ngkguJUtanS3bKo3qBOJ53ZojC3otETlWY87q7PLW1WjR1DfUsiqJ8PWoxzQM93", - "qqak+UjbtLSUKZu+JJuKKB3JsjbUfYaYH/i5llqTy5DxIEAwf1MAk1MKNo10ptL5cCTfyXhOuk4bVVfL", - "Gl1NYxppm0I6U4wz7fJIm96KraOzWivP+f1XavY9DoZ9K1VbM4WdFFx71Uc110nNObFDsWB6k9oOzl7L", - "oxDsSx+WBi1mIe98zfCNtkUQAI+nooC5FSHjmokIUrGNY56xsRCAnwSZmQYIiWS7aAtnIE1h6d6Un8dW", - "VUqLHwnN1EJnhpUcSUpOIwN2TsmyziiRH7h8wgeXMNv7cFucPDwW8zw5aK4u5hawbZnn5jk5c2Dx049K", - "/HH6N5qgPgIdn2/QtwPp6+jGWR74q6vEbMrjPI4ZZmRDtz0Hdho6WMkKSxBwlMcJqeDxWRbNxBnI1PkL", - "Rq2DlAKR3xiO4/EAoLGhVFuyKAFVS/OwSjpAmhMkoAkqt8wQW/V4AVIenVSXOKlW1Pz2XVUrPS4/ILaq", - "/bt4JLTXRjOkHbv5AA2NRzn4cn9cfIjTtuegWjleAaia3uPh/+U6A6PdgnwbFpytKG2DO6yT5ox/Egxh", - "Kb1SGu9dxSlsJKmlCx5zGVSPErkWg4BroWnbwITwgUrNXRSPls1iCI0Oio7vlRzC4A7d2HYskRVqWq5Z", - "pTL3/D7VmOCuLjLL7kWbF24SssVZAVhFIhuzAhT7HEqabflmxazfjG6OZ8jSKMyFDlIaRxoBADI+S0DZ", - "EKqjLsApABYYSnX1J3ctdj6Kv+SZeB/NRON1YwNH/Z9FhkL3E45/157cJWVBNOl2VWFLPJiUDCXDRIlz", - "b15LIOLqEkNLFZy1yQSCqoGau3HNsJE4GnvX94d7E7mMPeT53UdhFLQ8XkyXXEx9PtmI5HZKjex3O2SH", - "pd8Ls6aGNGRxrJALzH6YpCLhUWhP4ZXj+XDJ8Rrav38na+D023CoBkLaN0n4/CCP0lWe39UeufclKFZi", - "abqtspg2H6t3J1gtTwv++O6CA3N3wXk4R8tbKCl7WmRZLMw1eM/CULfbm8hDDvCjyIegqG/fWdTY7G+2", - "sXjOxrkMRViWOvJqwIugkGGiIgkuT3oug2mqZPRnpZ/M9Fxu2338HGXTkQSEX0htxrTC58RUXAqZm5Nh", - "oCYywuxA0tFC2HhRHGVzwOOF98arBJzGWnM9+8phYGkZFBNxTxXGNrxpw/Jmb2HOT9xc7thVvbsWe0Ap", - "VK2frH+4dSJZ0wc3r+mylEvNwS7d7fbsV3D5TzynWOu4wCWLZrMcCOszUFMqVpMo4DFomBTg8KjRmbqE", - "adAvygpQjyTBlOt8Vvx1yN77VKAfRHG9NYos1aLSKSRbGMmLuU3lsNgCUJqY22YHOMpTrdJVLQGlpbsx", - "e4C/VLfDKuBR1MkugLP9cC0DFVG4IQ0FXhmoHQfoUtktO82goeL9iXn0U528KgZ6COO0TNwW2wKLWvEo", - "Q2cdNhY8y1OBHqzouopz92DcMjy2YY5t6rzuTXrdDZB2Fr2X8asBoHwujM1V6YTL6E/444DqDoqqW2Sj", - "d17P9JhE+KKNDxwLij+UK6m/Vi4ZlANzbWQV+0rX3Wq6IFiwA69s69KxYPV3dOXYIPve6/i+pqvI9hm5", - "rBMRLHYZ0sNEQMAYFm45mVvI2gE1uap38oqnZuylazY0Kn0xZ5oQfDtmP6Xipx/BhdYeYg42dwx/BZSt", - "5TwLntTL5qFbOr4sqqfhs8teuFRnKi3S8v1rKiRTsyjLRNi3ZJjLnnaZ+qFZSKl3zp7MlDaCHJgdfByl", - "Ovt2yKANDjXMjIs4ZJFmSaouI3PNtEGSnDL/9VmEKf60l6dvyA6TRJCbr58ncCQzRWO2ZfuMIkUxFaBN", - "KGjLeY3esEf4Ng+lb2gdgdPu8ZWqfnp0KNpOJVnt6SCtUfxWgpDF+QQbCrRreOqCZ8GUqbGVg0KrGG47", - "ilWO068p1WRrsCsKXYMy7XaAAChxrPOX1bjEzgiQCZPZ0u4AxtrQeif/+Eo3Vcf4Srf1Tricvxu3bidt", - "vWyGuNNO56indY55PxWWMab8UrALIWSxq0JUYmr+SnGF5nYDAUP0gKByHc/vjuihfKwifJUzib3tLoeG", - "tyVbjiSuoS1mxHVX82vuwI+w8NcMnlq+EOUjoSt/MUdePYvCrqdCW55Cq0b5/v6zIArhX7G5s+FrJHHX", - "dllHxoNKmespj/qd67X9uBb2PDXd6gxF37eaY5dGsCOnJOq9iXvo090PuylWcUX+ad4N977QT0vg5ymz", - "q+OyJeDzBZXLjfCOgMdsvFvJxrs2xyxCnV/GBxOR3RYm2L9J/fKYeKFuRr8GAybmVtgOPl/hQoY4W1k8", - "Z0rGiOmYyyg7AxwNtATZ8D8867b6MO2Od7dl0V9na75R0Xl4HkJb3MsBI20PLwut7opwF8LHYSMgarzo", - "FAltWbkAeKN7IRww2zARnmTcgCQcKZ1Rt21Jf97DNROIYlOumc6DQIjQaK17KxnIklatE5ddSzom6lKk", - "kstAdBMH2zel9EJ3tzhC+ShyNloLifPNTYVW8aXQTPBgWrw2RKGQWTSOMAtZ4TgHBrq0yPgzktQheQnb", - "7JPEACJ0V8c+S+LcM8WUw/BG0nfaBTLPXgodTSSaXC4ECxBJW0kj7tEVqNxxKvSUwTPfJY+tRwjZKeyq", - "sUiPpCkD7nq2sWAqwuFZi74oZr/VL2e9F7wtqYOfHb1VnXCTu2WNinazyN1UEg0yX3DKIlecYmbaHqaT", - "NLrkmej4Uh3HM9jL9ky7aRQusw8nIh2YnU0nPBAsSaNAMFe1xWBs+xgUfTTvnNe37f3661uzsRwbuu4q", - "BCYQ/8DMgr/++pbOYB6L1LnfFDPru56BcBHvtloNa8y7Jfshce476gWJvmkDoi8+jcwGc3bnbYg1blud", - "2ZZp0b0vwF9drYqrsSYZGZtYc/mFhOh6NDZuxdi4PdaCdVuyO09idcHjggisM2Q2QAV/Rwxvx6oM9IU5", - "qo8Zl/NlmzjRUWO1xudDImBzj3frbPAN78s0ERuCW6XLTjq0f5ipUMTmt8oLcwUsvfK3TD3Id+fH89ct", - "On856d6k0ipvhgseVawbV4UedjFnb14WagzifuFDqyYbyUZVNhFVTbbbPXP/xo5uD9GYZpiqzEnXZWzL", - "Jos2YSyzyJ97q65TWGMLjlN8MknFBAgoeVIdtjlSHT76UbmD0LJVKXtRUem1MMah7uCTmG/u0AVisvNA", - "VqDige3LTl2UvDzLiOIt1g6o2mrWgK9bdYUCSnfkCAV9N3EFKvw7b8Cwq1fjiqbdau8L/NvVFNHCN2Rz", - "sD0vPzNRp492hq3YGVo5YKHTEtSi03Tj2fgWLO/+TWmBBxLEu4BTKPa2xbeoRRGQg9BuOGVbzkGrb1Y3", - "xqYPzy2ojWM73s6K/a6bw4NVi2OVEnoJ5LYXGTs/DAKRZC9YdXHP2RPv1vKtuYJM0ICRpXmQ5akI2d9P", - "3v3mn+9LDWbiKtsL9OW5qRqqzzJWHA/5ms8EoImaqxFnRyf/ZICIpvMIBm7IHEmdpIKHeipERvCZpmCg", - "4nwmdd/cLuD203dXuvNxqmZ9lqk+s9G3/VP20XpjnEVh37lmnH0Sc+83I8b9U4bhGGE0ExJw64bDIUZm", - "9BE1prjrUfvnRI+5qAmMaEW3xM9TIb1Skba3IViub/RInk9SlSdnF/Ozor9zHGc2TYVg5466/7TdYJis", - "7ShTEwGwUKbHkcQuvdE2dMuae21x7Lgv+q/R/+vG1V/ZE6zfs/JhKosrPkti7Phns0IYBl1yJCoWDDou", - "NsDl5fs9YF9zMzYikqm+LxQlmSiLBBj5+9k8EX1oYSSf7j99Ntg/GOwfvN/ffwH//btf+eMB/HH/4Ofv", - "v/v3X7/77vD1vw7/8curg6e//e/+0f/8+PqXPg9mYhDJoH8YzAR7I4Nhf5Jkg+eDLE8vVD+SSZ71D57W", - "ejto6u3pRnp7ul/r7WlTb8/Kvf307H//ffCP3w9//NcP//zr8cnTl/1JrC7EVf9n+IcdqTQp9abyzHT3", - "3OwjvykG4ji4mLeubkuZ+oquvD6rze9q8/Mcdz0nHBQOq7M0kpNH063vE7X2SSCJuewQ6QrFWiy12MQW", - "DbXQwaaeIJ299lKkumqhXRzreksspEumY3PWzGPT0a6NmYaIB2bLtAJVf4A5TlWYBxk74hmP1WQ97y4p", - "PkMXrSZP83GrFk+zprtNR28oaGSgmMu7b/WkBVyPfxr2h70v5p/OLlpmDhdHfRKBHd6Tod9H0+hWTKPX", - "YpOF5tNFLDAR2e7Xf/9GFcpjrGfd2npN5ltskV3Ef2SW3QULbsMoq0Warbyf3iz73+ssiutLAXHr1jbr", - "PR6GSxO38zAcQJp0rVUQwbEHXMV4yxHR3fgG1PrNidBt9ICMuTw08/AII7Y4kbJls7FKr635mwF8wxDA", - "wKAfDKBcesdBFr77m0BxqQJe3NHNyvXftg/Ax4eE7gU86Rhy23oef4dJXnJT+13M1KXwxGWcqlmrwHhX", - "thsXmH5r2zTOx5vhZlnWsobHF1u7JTr2s2ePyHQJUfTNnGhvjg+BDfdvWi8/FPC4Zpbb5m10ZT73bqj3", - "lNW3eRFe/Qx047L24GAFtiF1i49EaTCNLkW7R9MhFrC2InoMrMsiNfTQLJYPyJfOcoLPB9thyiS/iCM9", - "bWfKYyywlCmpoUemvLdMaTlhG0yZqnEULwuQv8D1YLZ0iyWQig1coxtxA7kJRkOCH5hnQXVVG1mKZqhL", - "6JQUn6ttgk/wT5V+mFk6Tp4qWmRZJCdoDLS1CckzS1WsWSQvVRSIkZwISSw3ZIeyjE4UcIlwBrM8zqIk", - "FrXRsVCMIynCITscycpHFmkWR/IThkV6AdU8SYbs/TTSpdNKpJkAmYr0VIQjGeapRdeoNPyNRhOXBUhO", - "xYxHUhd4p60myYosbdUDoywFO/bFoPE2SF25xN13zGiUmCVC2Ky9975EHd0xmuTznYznTOfBtC4zlPY2", - "JJsXgH8XbnRSZaUwZKpmPyWRpOyBXHqOxLk2XbhfXRoCUw0c3UGOx5HksZltK/+6zRZZl5TlR6Do0Va4", - "HS8SviI/L3QcqTJrow3wtiz//u404UOx1q3MW4v9QpayF5nedshh2zKNXWPH3yGfP7yYPn6t44HOL9xs", - "LoHELhfdovt+qaNNufFzLztYxWOfP+gkYY0hA6Ul2GCEwInf7q4jBXxiHv1xFvvjVIW/rmFKS1uyBTRe", - "Xv0Gt3RzJZ3nE7ab5K8NhDSxlv/9nru9mAo/Lq9wpOQ4joKs+XJcYaHlLLlg69v74v9azqdXv1BUel5+", - "1is3fgduFivx6gO5XGyV3zo535qzB5ZDSBW/jRaDu19kFRfczXJsf+3z4X1BtfZ549EDeMUTB3OMu1To", - "lj5ndRLD8t99H8m13NMWy2l1R1nBh2fjUrqkjzvgvlYTtGXb16M7W7ry1nZdKQu4DETc7thwBN/xsl0S", - "HvavKI7NYpnrdySNbAVTEeZgAAnouMiisamZCsZTMZIK0tWUrQpUi+7jGU8zxsdmoIBZBr3j7GTRrOkF", - "DkrcinPgzdybcL12Y/1b6Sx6vw2A17w3wSpu+RwbTLmcLHCkO4qVFppxluZSGqktb/QyRHHU9PapJKA2", - "qRSMZJlCRDP7+k5P/UcEvalFiMnGkknKQ6H7kAHM/mzaBv8YJLHBRQU/PCCxxrXavVgjIfcPjeymBRym", - "ccsCnku7eQ68jbJd4D+48vX93N9qGx7Xmnt6NLg8bnLtMlCwWyunrSETGb8aBKoM4tdgbSmKbed97I0M", - "4jz0vG34FYP+mrI6dTGdRNjgGTXYa0ifdqFULLi8WXPJe351pMKH5m7plrORQ9/zqzZoytag58a3F8ul", - "W/UYpBXcrasgEdF4oMBPd99H0DLNNXmmRd/tfclwomoxwo2edh5rLd+kXcuPnnZb8bTbEGf02x/Cbsty", - "7+9AcTwQi+HGmIg87ar+c1qkO+WjbfnPrbP/7YKNH5MttSRbgmnZ1OZq2hbpZTOk568q4HGv38vTuPei", - "N82y5MXeXmz+OFU6e/ElUWn2dY8n0d7lM8jBnEambY137pTu3OCS1nvR++GHH36ABa9FC2LoF77YT/Ae", - "VHSpX+ztfcG/fx3yJBp+UnIy/WMYqFlDt9RAqePcHFuFzGdmlvCXvNfvcfO/mUAnstMmwooZPYpVHtbI", - "cseSYWC+25kw8kuLUnuQKyDfxSWPc7Tlq7GLKdAsUyyYiuCTuTZFKRsLnuWpRYgfFtqmESG+YQxeqNEg", - "Fpcidl6CgZLjaJKnzspRa/klltS91kVjAcbrsRmXfCI05nzt2zxJaNzEkXhvO7r2uDO44FqE1mW0kZhq", - "hGCdJof8F/KMmwYZ4rRGcsKkSmcUlZGkUWD+BJgLhpCYy0luLmqQ4F0zHqRKa2ZBXvWQIfos4A3ouQxE", - "iClFXMSWuEJBY1rlKZSUIeN5pgYwyelMhAiCkE3FnPFJKkTjGB0wYYMHJDKCZqlIUqGFhKAVWoOEX0Rx", - "lEVCswsefML897hb9Qky07qKJiId5DLKcKaW84Dtt4Gk9+6WbybGepEGPA7ymG4AApfasXdjF0Zf1Vu3", - "sXeWsxpi1HSfBXmaChlE8LMZkVl34jsbftOBBOuHXCfjMEk0ExKQOOYqNyM0q23WV4bUavSnKAUAAqgI", - "+6zST+NYfQZYP6OKJ2aa5QQXpGCZuc7EDFnG6GIEcIZuAy6Bi2aYfyNkQk5BecxVXoQcikBhG6Yfjc7H", - "8OzoswUESXEN7DtNlYz+NEWQUBAEICqbRmk4SHiazY0kZ2OVzszE0pLCU4dZ1D6zEY004lDE0aWAWEI7", - "63025TLE5eLzmWHYQMWxAE2PC4QvoDZIIRUxR+OR/tS8SmZSGpbolcyiLBamiworYiAmKU/zl7GVouUs", - "4bfa5BJeerf1e81SHnyiqVVjXCsrqkbt4RoPy5Y9G68WyTC6jMKcx9oU9iNFNQaxmYKkOi+ETciF7APh", - "Z/XBNg6vbFesj+/I7UjrjK2ofdPjcj03jAlKgMhc1nil68heFVWTVBmSRMi4FSuV63hu5NBoK6uAtUK9", - "P+NziC400zGbiTDimYjnjF/yKLZIP4hNU94DHdnYd9vAtHPgn6rPELtI+K3CjrcaqMwlj+dZFGiW5Gmi", - "tFE81BQtm90fbDpNt+N52LBmnFMV4lIBPEckJ6YlW3ZWbpIMW4YYh38EBDKAVkFla0gcx+IqurANwJts", - "ICRPI6Wrs6N7X0+//v8AAAD//3IE3gOiOAQA", + "H4sIAAAAAAAC/+y975IbOZIn+CowTp+VZMOkMiVVdZfGytayUlJPbpeqcvWn226KOiYyAiQxCgLRACIz", + "2WUyO9sP9wB3H+Yl9vs9wLzJPMka3AEEIgJBMpjMKqlbazvWpWQAcDgAh7vD/ee/jDK5KqVgwujRs19G", + "7JauyoLBf7+U6ornORMv8I/2b9e0qOA/cmYoL0bPRv+nrEguiZCGLOk1IyVTK641l4IYaf81l2pFzJJr", + "QjPDpRiNR1xoQ0XGRs9GH6RYPDOKZuzZ498/fnLy9dNvn/7+99/84dtvT558/XQ0HmlDTaVHz54ePxmP", + "DDeWjpq00ceP49GP0ryUlcg30vmjNAS+6h3/mz+cfPP022+OH3/99PgPj588fvzN143xn9bj153Z8d8J", + "WpmlVPxvbDMN8Ye9ZPzhydPfP3n65PfffPP48fHJ198+PflDg4yTmoxGfx8tKSVVdMUMU7CCZ5XSUl3Q", + "BRfUsv5/VEyt7Q9cjJ6N/gr/Go8EXdnOSrpgdqBsyVbUfvQ7xeajZ6N/elRvkUf4q36U7PnC9vDR0roG", + "8nLGyp+u/p1lxv7V/pogJWc6U7yEnfFs9NzSvuKCaXKz5NmSWKqInBOzZCSTRcFgD9mtpZhRnF2zCXBy", + "h/nQPOe2MS0ulCyZMtzu8zktNBuPyuhPv4xEtbpiqkve2yVDivADO7RZl3Y0LgxbMAXT539j6abYyk6H", + "G7bSdhZcZEWVw7GBnlNdfgx/koGbKR5/HI8U06UUGmfxPc1fs79WTBv7r0wKwwT8Jy3LgmewDo9KJa8K", + "tvrnf9eWzF92XP+66xdKSYWbrznh72lO/PAfx6MzKeYFzw5Piu+4l5Aw8sdxJDh2JyOWiT1HPUWfb/ao", + "I0ctibvNrW7aN7lIEo5Hf5SCHZy/ttPe4WHESATvydaEBN/I0vb3u3M0tOybUSTam5L9V9wxqTa7T7HR", + "um+aravD9w0kn+Y5zmOjxGz2d5rnR1IQWhTyRhN2a5jIuVgQXV2FzzS54WZJLMnU8KuCkbKg/q/1WFOh", + "qGEZVbm20rApmTPFqGH5jOIiFMVP89Gznzcz5Dk17C1fsdHH9x2yBTl/89PRH745PiGGr5g2dFUSxUrF", + "NBMGltfKayYMN2sCo9s/5dSAqFaM5j+JYj16ZlTFPo5HWaUUE9l6d+q+50XBxeLMNTyTeYpQe334vkkm", + "83ApUmA8XBtOK/A9jWDRC/bbsQtG38iuRvftK/OnEjcEif7sp62YlpXK2GQqpuIVveWrakVOjh8/JdmS", + "KppZFciOuKK3PzCxMMvRM/truEm1UVwsLIvYfG6Vims2myu5Ogib7GLZKRMqcuATuVkyES0XuWKZXDFN", + "wuAT8hf7iVWjdckyPucsH9sWU+GaWAWa5IrOTZeT9eK/8B0SbagyQEZzlkb+SnPkmghJCikWTG2Z6FQ0", + "24WvCRc5m3PBDSvWu82biTzMmue7z/XdD+fPYZ6dTer19BnunV07BDF67tq+tU3TXIw/aZ5qPSFn1G4W", + "Mh1pLhYFm46IVGQ6WlWF4aX9d3zyD9Hbx/HoAxsgvl67g/gntk4JDPKBrXHrarbiR5Xgf63s3rSnj5gl", + "NfbHSrMclOHcCo75OhZs5Dz+ZCoUmzMr3hh8VFDDtCGXFNb+klwzpSMp4XaU3aK2Dxwcrhs4Wf7rSJt3", + "nITZjEcFvWKF3nbh/oBfffSmR8eo4bos6JrYX5Py63tmbhgT5AQoffz1N/1C7PHX34xHKy6CUEtINHt9", + "zuD+TJsh9ncCv3cvETBMtmr/eGW9poadUQWakmfc69B3bchQpegajRY0YgedoDfYKH12sMfWNMiZXJWV", + "YTm5onbbSBRLrCUaLa+9sNDP7DockUsQsJfPyGXzWrhEaWaIZmYCH7od1/mSTKvj4yfZd0TIm0sY48Fl", + "LHzjnohUU3Ep5I1rRBofPnQDqWzJr1neHMrIxkCbRKNn4HhUlflvqDwVVBuCJPQrBNe04Dm0nDGruya2", + "8A9cG9tt/SnBT3fevxdK5lVmzqihhVz8OfTjtOV+Vv65PWRikzuhgnTPaVUYOKXNOfw5Jacm5Fxkiq2Y", + "sHs3cZ269QORwIVVeaDrXmodJUmPgmJ/rbiyZs3P9pp0smscK9iNDYPXQj299rUYqb7hoDdE0fuEF6N7", + "RSYFFu+90ybu2OJ9dvnM33A0z/FKoQ0LhEhRrIkUIHePyKW/+LY3XEllbxwqsPVoPGLCsv9nd5XaJXGd", + "RTOtZTLMNHKBsfy1c9UMNLRsH6T0nRDv8OlaSjk1YCrudCLQ5PvY3c0rZrYanGFKr+zH7c0FdLiOevfA", + "a3+rDzc7pSBBJ+hyATXA7Xpf90Rsp/XcsNVnQO+bcOvudn8S0Ljt7YmKWOcqtJda806binoWk9ZN+rbu", + "eEnx6lszQ66swlNWVwXXS5ZDnxkeQZZzK+Sat+zbhiBstqPXlBf0qmBkLpXVFDsX59seq6TbMjrYMIHR", + "eIQ02P9wHfYdcMW0Hr4foFXHzcFNwjt+xs26YenbrxK0ZLISRg1Q4s+wQY/vwf2KbgcuyM/nb34iT06+", + "+ebo5P2DpTGlfvbo0c3NzYRrOZFq8YhreQS/O0KObEs9WZpV8XAqaFEu6dFjy/IVNY35OLqt5s0FO+ly", + "4CVX2hD7Y7RnLQfjbn6wP5+kGGMbPu72+oZlUuQ7dfs41W25lILN+h4NLuyvCRsD//4jtkr1KrWhxczy", + "LtEp/AhL0ugT/wwLmejSHvdEZ1ZCMGsKlkpecyeXYvUx0VnqUeK0LD/dK84ZLadl+dvcc+0nk90dhFR7", + "B/z4l/Z1IUALnjXf/Tb1do4tLuoGnbuk22d3Pu9hRp6wzo6y+lpOVY5qcnfh3IvoLx13wbJaUXtB0hzE", + "MrstC4ovht5dlFntDN6TZZZV6Apwh9b54SdT8db+PuesyMmKWsklDOW2X1iAR94/SQ21vS1ZUUIHlWaK", + "VCJnCiYwFTdLasgNE4bcKCkWE/JCZIXUjFxTxYFCeOXVVizqv1ZUMXKlaPaBGT0hb5ayKnJyxeB6vOZW", + "s6SaTEdvrIZv6c6oZtMRXD45VywzlgLblyXm3flkKlJ2XftU1+/IbX6+c44VxUylhHtEVYoVyNHz5+SK", + "Zh+QoTj7sR8dpfNURC/TaHBGHcx4Dn9jEwIMt3zUpLKcF7lzcxTsmgpDCrnQlp1MEEqyShu5YsrailIZ", + "Tai9l3XFdpyw3qDR/OvbtxderYn95LARJ+SdZvOqQOOqpFqjG4oFITMVVzJfW45kS17kpN63ljGUzBU8", + "AeV2dcirSltFxrEXV9dOBc2sjZOJ3oudoO2eBb2UyozxSByFI6Gr1YqqdXvPk3NjG9gNJ6SZimxJxYKR", + "K+daCmcFlD3qm40Ju81YaWALFjKjBf8bLO1kKsL2Jfe6e02v2QdLRuzvk+0dtYRYsECRu9EhGXvp8z7y", + "Hjsp1RXa7tL4otx9Ue7+wZW7SH/qjAEunKKwEqJ+Frfj5Nx+trJqE6oJK1qWdgh4JTdMCVrMuLiWPIO/", + "blPdXrg256HJeKSpyK/k7fbGb9yHY5gnTG9bC/zuYzjB6x8xuAi483E8koLt/sQbd7hzA0fz7i26LPr4", + "fuNyOjfoPt6MYD7TstRwEVxht3gHKorP/vY2lULYG8I9vnCVH5VUmTXRTF3zDNwGp7aTjAoMJLQalrSX", + "OC3pFS843MEF/8CIXgs7L1TfwOdurwlJ/IaaCr3W1iQY12SIRf/QQLihtySjRVahajMmOSv4NYOLdipw", + "izI9joPQ5JyUdL2y6zAmzGTgPKhDPNrH0K58zBcfLLGWFXIIOg5dIr3YbFKHtbkd1DiyjS0aVOwNL+vP", + "uw/qtCwnu1zX6SeuH6OnrV17GvaaWu/XvqfU2DmcIqGtIji3tfN7x51tOS9Oe33urM8hB6Ysa+XXbt+u", + "TZuSisN5FNOYFggJQ4G7MEtP4NKqs/bi/MDycLhIoMtzOShRnS/wVkJRe7c5eLm5B+Hu4LWI9R1+3Hmp", + "u2wctvZd9mzbCvXr826s8+/QHSbhDyjmrJ2WWMtYLrn3Uk9dQ01yQ+zOtjf1+u/OK7dmW/jjf56h07xr", + "QLS7OX8OcQQNOW17mZ08fvL0629+/4dvjztbJG6d0rrcG9/Mie3ZipmlzLeR5Fp5YU+wFTl/3qStXG0k", + "rbeXpHp8X7spcbPdeQcd7LCdx9KKMGG1Fd2gtaMW1IfCKs3IWq9SwOPGW7xhiK5K574gV/wITWAMWLMa", + "ylJJ4YxpUlJj6SE3S6YY+alk4hUzTE2FmzFZUUEXTAPXnK5BCj5n2TorGLlZ8gLjXcLJRXLIkoocJwRt", + "pqLx9k5FHvZGrbfAHM5jDkj1YV7IG4iBOJnAa4nX49w4+CocxtEY9aWo0NypeEu2ImapZLVY1pRPBRgl", + "mjyAxxTyX//P/wuOHtuz/2+WP5yKxzhqvC6KZYxfM01u2NVSyg9ESMPnzrbQhF7JygRewTAEfR56Kp50", + "u8toUejg7nIejQ4/z5/j1FbMUCt0puJpijJcds9adg36GvR9zSm6ZdxvzhN1enFumYu2WHt3cA0OSiXB", + "grpaEztdjdFRJUWfCk6zVHJhLVcuxVRUwvAiuSsyKeZcrXRnJEvd6cU5MMOS+xkG2LpwQKfWDtYpIlsn", + "HVFkD3aGX5F6LFwMEHc8tnXt2vkgox5yvwTgbgvABaE8Awkxszt2Zvd/l5oX8B2GwHZ2tm0CpEB0KXaZ", + "j2t5dcOLwh0mWMjQj/ExrDeUG3epMWvw1efdGme0KOJWYXQGMWSl5MKQKzaXKjqkYuE861PhhR4M57zl", + "zvxLHWAjfXQT0lYqVlIIQGHBFkWlKEw557o9Z1oZuaKGW+LXgawgpdtM8PsYg3FBhiwqxfJwP9gdx8Ui", + "SlG6krJgVESr6Ca6wzoGltx5JRvMHbCWXQoGrCbLG4vJhK4Ua61mrUmE61oTXWUZ03peFcV6Kpy4Barn", + "XNACiIjVAEcHhzDYFVUf0A+PNNx1/buso8pOcLViOaeGFevukMnlP0yk9ecZbzs0rDV2B/bEtr5pxuXY", + "OwkdaLznnul/RbGN/RuKD21JOBne7+Cx+eTjR/eKa3R+oEixiAIYey6nDfJus/No70C3stweNjbw+CVS", + "EZ43PGg7Rpl1vdUDrX1s5VQviAGDcH8Q4EyD89bbI3NGjRW0XxTXL4rrb624frnzPqc7zz8TfrnoEhfd", + "FrHeE29zFtYnCiSGAJhI0sRrYGextmTF2cepaNrOi+le/mM3evOeoBkELmzz0LrP7JVItZYZBzXd5475", + "rRm9L+D3O718fbmqvlxV/whXVcGv2SoZ4XIucp6BZ/hmycySqSDz0Rnqzhbk4dhedj9lkU26ovqD3RYl", + "n7mU1u5WxG9896cX55CwCjsRcoXYbSm1s+vnEJ9kr0+Q0HN201qHPR/Pv9zdW+9uvAS+XN1JGzW60aIz", + "19n/2+54y+KzJcs+yMq8wUcGfMh9y24NxIsPDYDE5sSwW0Ny3ORWpJsQ26MNvHp5fCc3OJkX8iZxcc8N", + "UzNdXa24GUjI2xYFtqfGM417McHlvKqMwW3bJGDFtKaLnm2Lb53EfYNzfrCit+Tk8fFxdF4ftgX24+Pj", + "neLv9JJD6NyM7hWM2mZBIcVC85wR36+PioxfCj81Fhxi7cPEP7P1N0yt9EzOZy5sbUazjJUh8H8oRxQr", + "C5r58HcfSQCD2PPoBiF0oRhkJMOMPi2efBwu0F4ltRF3+/tvifuYWDkKF3AES4cx9xxC8MtKWe2gI780", + "tm/cYMxU5U6mTovid+dpmjvEvjtHemM37+qK5TlgDS6lNjvaWmdwC7XIaAbCnwURkTQKjZJFrdkFSp1g", + "0Y3YkK908O1FYdl+BrQychRdmHvTfyaFva+bhA+5ytrszrDDOB7UP5nRtOxsRQgpVmk2C+drP3Vs9/le", + "4OivYPDXduzTMHQqK8Atol2qa645ROCuo5BXH2wE06jFxMRFoq4khGnc+6zqkbqTeOGifVohu74JRNiv", + "VpVwMSV+SeHEW4UtSg82krx7Q1ZMZUsqjHYgRpoZ+8sUtul0NK63eh7jWMIxmAojiV7KG2CpRDuvgU8S", + "nQjIxGGTlNi/b46+teP9NH/jRuty9TWeRR3ohfhuvIy694d/RcVNA6wNHVB85O42evf6B8IFWctKecvs", + "OdXLK0lVbpluuFjoyY4XwJ1Px9Dk1U3HY6uMkHpvv8uB5nvhSeguvf8JzNCmVIiVqV7J8Kus10XEwh7y", + "t0qxKImtexktEW/zcFfRRUNctmjeJq1i6eaORoJmIQU7IMUtIdFV/jpqZNBVibvLcUvUhAKFB7npnVh6", + "B/bz0Gu+Vl54tqxjfyGVWIfXSTTNPUBGSu9rma6RyXbAU92Y6fdsSa+5VO7cOuShkWDXkIHWnOdfvNdN", + "Ek2v0RZqqWEQKuMDeL1qhsow9K3x6oP+HXCcd299unMMCwq+tniG9g9bpuct5U93isGW5wITMH3Ik5+l", + "/2DjTPcX0+mZdMSD/wVRV+zHjWwId9ggs2uTTeVlG7Bmb3nxmmHk9k/iTK5K9OV3SfZfkauYdm9gdchs", + "GjHFDV3r0XjE57Mg3w5AN2AZ4PuBHi7najXEaaMY0o+vQ1YMkB6zGF3SXnPFj77SU/Fzx0Y6vTgnNYpE", + "nU6cy0xP0Kc7yeTqES35I8/BR56Dj9Ab+rArTZ2g8o6wWdY06g53MnuN3ubZdPuw92j6zL4tZm/7SNpu", + "x+4igreIhv3spTQgGQiWMa2pWvtUxqmIchlBeGX28i1mlUrAblh9G1Ai3B6vNfubpSTYMn3TWZp/lAZj", + "WT1oXcVnK8gm12QafBAOqbTzFFpwaxOH0Kbks+w7BO6soT8dfqidrGKZFBnHZAW3dfCZlotGUC0y2MO8", + "xWk9Y5JRZeA/pCJUrImEpXNwpLwB9B8n4oNWdH/br+uzSBrq0UGGA+w+jyWq1xXzCvjmlxE3xmDE6q1Q", + "1Yqxo4IZY7n75ify9PHJ71vg1VyQqiyZyqhmsVGIQV9BObefBolKwlOp/QYcaq0vcDp2zjPDbu/iUtny", + "DJJYh+ipw0jvb24zvPv2EdHM1Kyqddb70i82OXvupvR+HI/YbWkte/f41jnEt9ETWoC3bHdEXCfxcX1y", + "TFZcVIaBYHz8lCxlpbyG4MIZJiQWnv4be3JRFULQlW+eJmt2oMMl8U794u1LUlCxqMCBTRc+qrwm+925", + "d9dAXtWcXBVUfEBgZe8XqvwT8pWSNzp28RCH7//Mikphv52O5gr/N2c9QtNnJ/Vf+r+kEhWbqBiAofqB", + "rY8AwYiUlDtPjjE0W3pMoKTEdyA6cAyNVO4S4z75zagqM5A5EKmhkxS8Ssslan/fAPjastnha8j7x4SC", + "B2yymFi+ZVTlyMFKz66o+DBzL6TT0UO/SC2gdafq+PxAWhQ1dFFz2CbKbE9Se40r5u/UmRSzrKFfHvCE", + "J1XYlOduoA4LJzBy54uGllBpqyHgW2o9tQl5w9izqejT9Ty8Qa3wobw5cnkRRyVdsP/mvjqq+HeeviO7", + "lZClplIircm8RqArq9Bsnpuj268trczSXvYZDRmS4Ubi8z6NBvxgnh9H6Mxt7RbMp3BZLMnD7Oadns8b", + "/JH0a2hN/otFIMDfkcN0tEOsXmqWht7OeH5/utJbenue768pGXoLuZ8pBcmx6mDahHvRa9oQ7n0uFS3n", + "Hva6N08skqeuh+nI6x46WHBH+BPWl2puYJ8axbSD8CrW9m8SfO9TQcuyea3Ww9zFT/CaaZj1IJMVG9l7", + "YEcT9QxB/1CaY0ZV7RQRjOUeG69zptp3n1RTAXE3kJ5FqEgIlnTMyiarC17I0bayxxtzw6ODrVigLWBc", + "rF2L/W0pGBU+jOyp8+c1xptzfTuoxPZ9H5tb9jOvtIHFBQ82HbNrA6maZYoldMUzJBB/hnED++3ADhTn", + "33V4OnPf8zxhTWy44O5L2h04wPftDlrzDdUuSz+/H7PurGHA9Qqjhj3DVkmYz7PaCQJfBGcGn9f70MgI", + "/KjL4Sb2x50zn2KMEHcCmhAICfvm11lXXhTOJJocSPd/5bpwqj7yuu8hoyPhD3oXvkrvtVcRcGfyusPN", + "aADMv1iTKcbXTEfEKzUOm8OJgOim72jzWzRKKJjSo1W2lMmWEplU9rDFVsSa9i5AYJhEd6YqZxyK0vX2", + "iZ4S/Mhub59y3FaBOi+4k9FA7NUmmnxy4TYL3LQjGPfeP/kfZp6J+PejGuqzS6vtebYHTtBwTR3mH2nr", + "W67zjtmUGnCgs7Z9iqFS6QO7zE4BtIfj4WS0DTs15leSiY193N2FrUBmEBjv99UV24r9wFBH0Ot7g7Tw", + "DKTeblqgbGi/NWq6pHGH0BVhOsO2DYu2sx96S6fW10tznxaTV5mGvTt25sm1f+DP7+eNsY/s7oHs0BZF", + "HpCCXaMW7R/p+HwW7ox9Hufc8biQytDC0brf25x72IOXI+g7snO8hMJhgrnTtTviXd4r9zDd25oztxzS", + "rKfiZy8L4w62vNx5yVACUY8aTfVDCHyrNKsBw9w5G7uUpyt4sDaazCvhALS4WSMihs/2Juiym4pmccRw", + "PwYHqw9k7sRZdfHQely+wJgXb19Oxc+x43cYD1qPmP+E/+N+9RfYEZLwcCrcjYn/ru8h/NyeqTp+nQtg", + "RnAyX9LKyEtXKjJ6XSzBulMsn2Gv2n7cdj/7ynpJBm3Riqbi59ZVdB8sqol46HBpPHOMrPM41ggZ665T", + "BFDhytuw9rqFjaUnQ6GOtx7xg7ky6qPXc8j35C7O6uFeHpE2v03QlaaiReU+IqjpkfNFIHFA/rdWwA7O", + "a1cdcjM3/qm5ybwi2aD4VzDrzzz2j7nfaeEwdRroJtyPtuwZqLvvRSCojAk4977k0R/cL/dKVJRH11XJ", + "tt0dzSfDYdL9XieFdA8U9vWjyr0SF5FwB1uu3sq6adXtbmGB071lZe199UzFxrunkwqaNLc6srSR59mw", + "thpcDOtt/7nZBOuvvmi6wNptTI0A8zzugZbq06LPllSlssfC7ZLBB9tKCcwLamZztg3R/2VBzUvG3KDj", + "UaXpgs3g3W5Ly3f2S4h5c40PVBKgSdGOIP9dYt7H1d8bnNtQ1AQb92F7/BDQZyNoD78cVgz8GQof+bq5", + "bg+6Wnv4GcDdQZ0/73K6qowvf4tV9ci6U083as+1+ww/AXy8zhcApBdh51m7QUgyrxSYqA4TFvwv7LYE", + "7wt252Ajekh2v8a73V+kUUlAGHYUICjimjLIXtLvnWosw1tpaDE4p9eeTmgYVkcs/AsILazaYTnkgQyo", + "yOO6speK0WJm+IrN4CBcum9io6AVeCnlhz38EG5uPVggK4BZCT5DYBotACmG4IBe9QwvSy6cI3bO91fB", + "/R6Jxqq+hZ3uYSfge03OpJnwFLjeZfqmGbz2IxhHR+vecMvyfttR1y9gqAQiJ/zdxf825YdOnPX2vokP", + "0FcaGHIE9MLPLfyfuOWoX245tmw8OFKb76nmQ08NFr+4ggw296R1ZbuJ3gyu1p3Xn88Nbq5ZtPVXpRH8", + "MNQwjM/DoELETNLGsZrrqQgUeu9OePsbE27w4esqLtseo5ICyqv7AtMwsZL6pY9PjF7t5pyaUGnpQCGu", + "jNheW1Gt4VE0THRyOPAdNSgy9MdqxRTP+l47LYEKlsiT7CYySWulNQsdIQ2tc5PksRq0Oc3/vdJmj2zK", + "U7vTc24IDT00ICKNJCv6gZEVFZW9GMJXGMoYhdsD1K7t6YoWVDhgnTfhxFeaHWVUByEHOhYWS8ycO2BA", + "fZ1fB9Tpc0QObG0uICm+BdqrPdq6tTBHGxJRL2TBswTQEyRr4/Jb7S6T9rZulH7OpNDVqgzBf0fkUoqZ", + "l7KXz8iZa23VyLop1URLKez/WrYtFBWg4PpADN+RR7vb3JsUWROVhAOGs8PJC51pZkwBrxiDesJmDYU2", + "mmJqESLOkhJZu+E2hkbf4+HaR5F157J+PnYzQ802MuJbOmk04oZOr9ZexHHWDOHdeA3Ek3IqZAp+Kgr3", + "NYqz6wOG/lgVP9y1jjVuVsSNht7XzTBTDcLGNde6yx5+2nbyXlYi52KBOdhp9s/xEx+xnQfNy+MghBNj", + "v3RPhkfkUkhh1cofZeghYNBDgUGmxxiJgcHzDUwH6FJDNw4J3SmorbHslgCsyiMHzu4B1+0w0Ny7Mnra", + "y8oEHCHXhQtBv+GKYXWUOVPjqWgBwjPIM3JXVgiog2P4sJsR7dpErpXEojUZvfWY/tFOZd+rGPlAi0Ii", + "gp8/qI0LF98bIuGUK3ojSC5vBKELyoU23sIAc07lNcA+qSUchCxMRVSMwEX8gfKSUZWwUtEOO4SqBGxi", + "edBBVog9+BkgeA6P/vP7Y7viG3ReJ40WDS6hyvsFknN72ZMDxxI2Loo6njA+s83MKswPZTmaabU0rg0u", + "dGuI3IpCR+zcMHUZx2km2TvnxS616Lsy6aVraPtAkeZyg4Zv5MQd1eXay+YFFe/oA5puXoTvNwdgDNYx", + "Y3X5gMQhCeofrP5lk4GX9uYKN2Jy1T5PJPJScalCRW0Xt3Ry3PH6KHpzBNePb9BcbfKDvGHKl/OHN50l", + "XyyZCt+3UwlPvkFirQiwIx4fA63un6ksw7JS2ZLqO22EC99HAp4HpSFxVfb7VCfyoLkzvEceta6HkztA", + "xEZ09kLFutDdqLxdM2zUHb4UZiy9naEmcBfC3tJbDDxICVF6mwgQrKmy2/elVPU58tLRKYotPUyPsaxw", + "o0fty+pPRRzrjgWEvMeBKHbNBOS8Z3KBkK8OdKzpKItinoKHA8U4jozR0Ljy+RizSKj5ClccHGd2coW8", + "guvOgUDS2wzUrvAQ8Dng6o5H19Ly5B6D85GxN1QTHOpQ6L6tqy5S38Zem20g9Td1f6Bqq7XWuF6Haf6u", + "Ve0rjMbtqt8+Zi/1pLjipquVGOkzcbN2wF/4N5gQzdi/1nZvF46hYu1bN2qq/jzioqzMzMgPTFgjV1Ym", + "+vf7HT0Dr92N9ie27qb9ftxpMTpX+rBVcc3rLC7dElb3USToPEBieHHtreZUkYR+UV5wMXi+vUPbzjaP", + "n+LD9tkn/D1bqyHttvQXsSIwAFvQNWsUdg3oiRtmfDiT2JoZZSADDWLStiUuS6ZmleBmlkltZvASglel", + "O7KX2DKthsZ+x1kZXLp73PcJ33Azuj12gG5AxRjqPY6D3ht+5HvOzPM4jK31AdWzuyL7bgfPvJPJcYJp", + "4YmvZMovtx24ju/0myVJq4NnSO8grsnx5OvjeCe5R3euye9Ojo8nx8eoEsFLuXMwgR7zu6/tj1jLFwEv", + "VpUl1R4Zey1bwUkFOYaLp/NYSY4Bw2MqWkbVd6AyQ7kSRrsJDyeT44lL03L+rNmdFGt//h365ZvQ7VZl", + "O5Qjrj1rSMl2Faari7zfScb1Fg2Kb+22EeAdwCUDNvvQAueZLmT2YWNQ0ZoZxJSdTMWDy/oJnBrYPC6x", + "c15ZrQCwnrqixne1YuZhIjAppoT7CAJTrB2Urd2ZrOALnhYN/TSVVJtx5GdJEUxFPhU9JAdysYc8Ra/7", + "Ce9HxVaUC2urVAKOpvP7j6eiQQX4gCzPS6q1f4VC9Tc1RqQck9dhCP9gwUFHmTPeiqxyyx1HVjliR16t", + "71N8O1toN+d3bQUOTyjrWoi0qRNDkfh+w48Ms/vGU8FFVlS5hzzz5max9k8R+OaReByLIBiHRTzR2xYQ", + "ZZsJAUPG2ZZ1kFaklHEfgoGm+5AIDFigfKPD6623cHcg4WO9e3ZZwq3m1DZR3Cf2wn3XL5E7ItBDSgfJ", + "h2AIvmxwJPvar8X1v1PdtL92L8SpTxOPx9GZrWu5+bsudVy3T33r0X2rqNB0n0TQ8Hpl6i5qd4MmlGgu", + "FkWQZit5jZR1wNmnIo4gOev0irYqX60qYxXE+1TG3/CFsJugGXjYnMCEIOz1NfO+TZrXwp4ItqD2x6lw", + "vyqWV1l4Yt6koBds5r7a47W/VqD93eCQ4qEGdajPE/G1pyDQNlMucG88whF2brDF/HO9jR0ZKaUIAzMP", + "+cITKsJjPGiTQ3D54pjpR8F/0EfLtn3kdxwFXayGNGxtti91/D6thx5fMm4Pwym6NyDPpef51CW6dG+K", + "Ozh6axkQqrilvLtdmdq9QCOCtuon7RlvzexJTNopIqhjhliz8N4PknqDH+SIXOIf4sb+L/bMQQy4NcPm", + "DB6lG9aL+14xe5FZrTmjlbbqXDBj3IVxxcCI0U3tBInG1CkYMDIpNuUjRSKo7QSngKnnalrV8bKbM5Pw", + "813lF36M4bY7trF0HSobqdXnMNmLtH/c5ByIxfShnF896wKGQTflbjy6PVrIo23Lb8dyE+pJTWsNRM5N", + "ZN9RUiFiNVgnV5UBBd3aHAVHsB0wwalYT4WHXkjEk3eE5NOGjHyyfRvXc9gzP6Kz19s53jnbNcijy9rf", + "TiWpNfqI4zuURd5w/z/vXvsx3wbedYe559P3tpX88Z0dyGxv4mW1ouLI9goS3oGuQ23c2nJCVIZUf2Oi", + "q2xJqCbT0bs35LksCqqmI0RGflEpiejGQ4vXrldXsg9/CX7bOq/0RFwcp+vBg010p/K76QguuzAlnNB/", + "/c//5X6wU4OJ7abObLmWoz0U8hDx+GyvhpvSUZwO4lWVTgbxDvIbroehlWDdKatDgGl99BqJVynovT65", + "s+cN8uVkfznZn+TJBr3vYOd6h6Octg3CaQV65x3tikOAxlaNB+O22ypPAJsi2lCRU5UntJ4GQ8aRxOvX", + "eNA/t1eFaqZClQMucn7N8wpyqu0GWFDh8nY07iv7oa6uUIwRI0lZUKHxcQbCBimCAJo6emVrCZvh0G6u", + "XdqQbVfyamG7TMg7HyVj6C36kD1YA6jMPnPadRMG+3t0IQ30HSV46Lg93szMYFl+iY7/9RxdH9h6m3ny", + "wj2mtQK6PttY6BVV6z7c5bdR7eom8HJ7d0cb98I1eAF9pjB0Pv3IUAR6ocYoflXtVX0gFNGxPZ1GHSXA", + "i9H742qpwIeMQAk0yDMGVCjZBBRyai+7hrewCm7reA0wG7kx7F6BpvY8bNQKkJ7nG/GlkxepvyvClHJq", + "aOLJpixnAb16IJZpg7rEvinL7uiegZ0f4XnGXcKlknNeDPctX2C7jU/U0W3sholS7qNUuQ4CQgxm2e7B", + "Ax8E6MbWhe0ntDEa0Y2+b/hpwOsI8af3EnCaRqdLohTssLG3l1M8IFZruxpict3bX+HrcYiVc5UDW5WP", + "YthGrIHl1dip4MLaQSyrFBu36n8Afs6cZmxC3i4hugiLfwQA1aimmpFWe0+NHqnBVx71JScFxNBBRSjU", + "jV2Bc+R/d2s4mDNZ3keZ+FZpzO6u+ikueOlCQTwG+qaSIm+XTLNQLpNCYXNt1yoUTwlVC6AiZgfHPWiw", + "pxfne9fDbO/9Fi+HnoM0rOmhT0Ma1DR9KFy9kd2gSDtdAyaIgGt2ybiaitb+HTucLIfU1zaW4FnLmXDw", + "gQ8nWnJtpFpPpsLqFq4oAIK98xZ4Zltgc00KLhyUFfXIhLQs0WzsRzc48DHZBFK93ynpA6S++x7taFrD", + "9uJwLWxCfhLRGloBB/b835iSUyEVWUnFvHamx+DlkCL8BRoA1NoVKySOLAXbAF3hGs4+sHVfQQU3GIpc", + "wPjwc8m75LtiiWxVmrWrCytxqlPRUC0dXEgiYyImdqc8mPYqvcERfFqMU0zcX8mf2DoK8qqzZRo7JebK", + "hn3yQkDv9mSfwnHdC4o56sWfegX99AEaJwxiu+bNh3BtzZQMTRTsXE8IxptaWWA5/d/f/PQjKanStlGN", + "cNB4oorag7/BCUXvQ8cQ+6jGaxPxPKQ8jX4h0zrA4JXMWaGno2fk5+loUZqjr7FWov3Pp3I6ek8+jrZ6", + "IMc+zWvmTOzdxFLDyE6jamG35ANbp7jQmFYdM7GCOaUsvyXVM1zXJCwQVjGIRfeS6siDZ2qSJuQU6ngT", + "2zOs8qVDBL5EKX6Jq37ZWvbnrGQih1JVPvAIGjtZ1Po8nqCPOUuuRIRGvFdgTLTxdwiJ2bgOOO+tITLO", + "Qx1vnMb67HbWd4tmadPq3MmO5y6bEmj2fNzgW36JFP/ww6u38gPri6exP9UO8x9+eIUpJIWUH6oGaC7k", + "H4bEQ2uv02zJZpZ54R83igPImmJUS4GRCw5SGP5Ll1JothvR7wQ3Z3KwMteaQUu+kBc0W5Kcr5gAPe6B", + "s1zVGOyHYkxMYMhDezVOxVWUwUmoJozD6aNeWmJaDoRiwzqRhZJVeXS1Jj62BfxoU/FgVZkKwt/ZbVZU", + "ml+nqsQDGYmKmjgY/GotSxw11I4FKYgCMStolbOjJ0dfH2kpBIPysVYMYxULnxU8FV5mGUWzD1EoMYwx", + "Ia861OJ9ewm/z/zkLmNLHoR0svRvo013eq96OAcKxFIWOd4+fvqJ+TjmgxycitBTvdRzUIV2mFp3RoGe", + "Udp5mbmoqUGSrLvTL1xPqRK4WhbXLLdX5xHuUDdsjYISNn5ODb2imk3IhSxdfiMXxJ8+PRWBZ373g/WA", + "zHUGcm65ueKC5WO/42GkeNPDU5P961S0dr4DUkGusluaGbKiJlsyvRkw1s/SMwIOB1DYeyLstMM0WqdC", + "lkxQjseCCrNUsuTZ0OPgO9+wbfwn6UNx4aeQ3DytlnsfjZgPG4/HVFDSczwGTDU5w43nBLbtbK9LP3WT", + "JdIKcEPUAhy3Q4oZfWtdt50Kt4vANIK7D3/VDyfk0t1pkOxGBaEFp2hvXsKXl2P7CR43981URB/hFXq5", + "gc01s9J7qr62m6y9+z6qWbCvkI172GGCPfPavJc2a1ONyNag10A6r5WQsVZTFKn3+ZQKuEHP6xflgwvs", + "7CHmE9V7vWI2K5lCiIhD5O1AljQYb3YAYgdwi80FeffmeePduP6kZG5PwEt8rSfeK3Ewwhbq8JsGeQiy", + "cT+ERUIkQdI5/NogxkF83A812HkvOT/hzw16glZ/TySF/nupeh2+iAhrP6m0ljDBx+1H+RWgXO5pgpyS", + "Ob91pzgInYBqcH95dS97Rw2s3Ed2OsTPpPjE33aUoLtk4jv+x5xvgYk0ppdKiA2OjxfeUsPl8GDbLu1Q", + "2SssXwu6clpky+7dlB5hb42h2j2ERQC3dmrZ2oGHKtzS0/meFsvGvIlmkZjBR6ighsxZqK3hkp17vdI0", + "v6YiY7OQXXmQxEVGVcHhbYivWFzuGouk1IGEOHqOILFQiIFmH6yCJHIATMuY1u5Fsc/8OcU+MI3U8hF3", + "Ks7IKnauwtvgGLFTPHUbC5lg7moYpFUOZBPVyfaNOAWm+BAkzLNCapZfYKstsQnwUbwk+IihiZEbi6s0", + "2v9DRgimIHHr1U6F/2VxrOo+QUjbIk6CM1veCP9gt30DhhDaLxGKu0Qo2mvNntjhr7JOnj8PHfTkevvf", + "2/gW3d0VddV5mel/Y0k+AELfY4chasfNPIqBH+xl/USTMinnVVHMNFPXPGP3IbJs/2NSCRSRUIUfxvIy", + "bGeB+7Iqilbjg0P+3je6c6iCBtXXHaTMVYBAyZuGkUPqM/sEuGJIRT672uO57xW2/b7v0a+ehhvFB0TO", + "ZVHIGyvCUDJsWs5XoeknFI+LkSczw9Rqj/BCnnl8mbe2gwTib4QB6OfT0vca7sXoc+9xZ/vR1QcNaH/b", + "/Qi6rkAFdcUtm0V4h9L2mhp2RlV+4ftr1BjuJdora8lX+AQf0w0Q6u3eBF+Ny96SeJm8hqgWd2i69L7p", + "CLkIkW41KJfO8bnGO3qV1oreNEs49POy9eFdwKfjepZpFvZhTm/fqb7b8SiObxzOt6jxNi2uEUgJzmWp", + "+MKa0Szv3tXRdXBDQwUidHfSqWh0xreUTIypHN0NeHsY2nbvLul8OiDPLnQWksp8tdgIYuMt+lW6yQ2Q", + "1jYLQc7JusPvMPctfBRHLHemkvj4s8yq2CsBISCgOFOjoVc0kFECIlikSXXEa1rb7FjMXXnXupr7L6Be", + "54G/PaM99LJ58462enSeN0yIAQgNTcsANHTIN2wSoF3MMkKYQhKs1XuoJpcXSuZVZs6ooYVcTEKHlxDV", + "aK0BWWHQ7aUrUzrnrMjHU4HlHH0R383Dd3xLJVOZ3W2pks8X4bdg+bQNH9QuHhz/1//9/50cHz+ctOov", + "ROUXjgPvRbW6sjbtx951qg2tDSt2Qd1b4BC4ZtumCTJXMqXtQVPkqtJcMK0jzbbth4N4ZDb8IoRxT0Pz", + "hDBwoc5zqezloVgjo6B2xkE1CT4ngrHclQHYIP54DdDto7pLS8lkl3DCQWGEyZy9lMiT3hPgspOjqEJH", + "Wq+p8ANb0MIZCqoHQiRMr/uuSm9nPN9v5d7SW8Q6N332Ev74lSYFEOkZn4VUjjq5t6xUKTXTgHy8Jivq", + "6tVLs2RqKvB0uGDmG/aVYv6d3jDFXNYIMUupmUO47XS8McuotRUHYzZiBopjeTgR3f11oOzq/rTq75tZ", + "At0A9/aY77cwJV7lfYDwzZpoI31V6ZwZygtNPEVWYrptAVXuXIv24tnFtcqhL78AYlCt7wq4Uet+542t", + "2eNB/dGKHizebolrbWdAFNBLeSM8FqdTg/3GN2uSy6zCWM+Nm7GgQ7MILiC338XqEEoMW5WFr5sb69Qb", + "cvwzmof8up3Yd/7mJ6unPd9stXrXveu+SxGxN8wC407KgopUpqCn7R/ecZ9FRmqbWV9S94cVtjt85fEu", + "9GkdeVlAnGUmV0wHsPaoVFKzaAx8DgUBuCCXuaJzc9mLhF/vgBe168VQBSFDrDlVIw+zH4j9KK8Klu84", + "YZUt+TXL01NGrBto4absGOT9H1zkbM4FN6xY78YAJvIw/YOCNBwig+QUNDwOgYhsxY+c2hfDArmaVo0L", + "Mhx6ch5/MBW1kW4/sYJfm5qH10zpWBu0bHaA3G7g8KziPvUKVyxdPm/AiSXVfbWXgR/4AYFdxoIRZ1dD", + "WUmHwQjxtTUhp9iI6BtusuVUyCyrlEa9lBqX3pFjXejm+/WEnBpSMKoxMQ+74bVWtHNWW6QwXGCxPeDE", + "ObY9iTzB9RxH3WrQpZIze4eLxYwJayXnjSKFeMTSOUmlkkfY1E7AtXZ6b+I+v6g/9yOlMoXuxe3r68Eg", + "guzMLJmY1UWLN7uFIVjazsXuzT9DLLwrwH+Z6K5d79x5B+ZcaQPiXQDAFJa2yJkiHBLi3VNY3KvdTJfP", + "XJX/ujh6HV1r95ovU+zr2m5wmNbTenU3J7bdUBtd2E3HNUqtM7kqISX0iuq6RDJrXVpQm8RJ78BlvAKf", + "kcvmrX3pPTyaGVccwN9L9mMhb8i0Oj5+kpFWu0mzZkqrW9foOyLkDRaEiiuiGBkPS6SaivRIRl4+dAP5", + "668xlJGNgXbz638OBQ6tBY5eSqaUVMkaexoqAdSfEvy0rfAwvA5LhZnB4QKDZQJM5akoq6uC6+UAwdn0", + "K/45EPHC0pAsoO/W4c9tehPi1F2izUKvaYvNigf3uUu6Lwp5Q9ayQniAD8yBAOjg7EQ0eLiZKiFg/h0D", + "Ly7v2jsTR2W3AOzekD311Bsu8raBGTnN3ZX0frMxfLFHDbrmzU4g2SW60IHPGpkL/hL4+CtdF2zXRF4z", + "5WpLQxJN422qVHKBXp6uRf0pRP0MfpnezZrPW09gwN0NZgwwX1WipcITuyNR6weJgt+t6JpIX3szj1LE", + "Q/xQ9Kq2A2ba3wVWmt2QM9iQafU13rBNv8AQFdIHJMRoCK9Dz9uwEJx0QBkQEbzlXPfVIGrqD7TWvCJF", + "IJzvJa3rCkENoHAbYP09BzaRQy2vbqU0b3QmW4GBxUXLg9a+0eNuhCSFFAumWkgLlWZd/SRuWNvTGBkV", + "0WOgSDbEsvkr1z8RAzficmSeLCtkfY+b0q8vfGhNu0Q3R6CsTUHx82Ir+j/087LA6sGKsZ0+t9+NRwtF", + "88reL7u0+WP4GJ7CdyLrnf1uPLqWRbXaibA/45cHisyv57pjNH7NyyENYJZDGtSsHNLK82bTiQ/0Dyzr", + "XID+xzN23wVjmwWq5o1xm+Hvu4d1hA7iqI7tER37ptPUu2ogkxVjfUzed6Jql9CVgZmXrS06bJKhHTEc", + "ItGQZnuzAEyE/atXAdFod+4c966PcExWEecu0sm2mBCX/Am3BqrrU0E1yapVVUDVMtcyUxKeBW0rciUr", + "kVPFXfgDaFCYZuPhd5wJ5u3kcNGP2x2QB1U5M3KG2+OhtSqmgt2WoJ/CBZZJcc0Qud55oqyUTKiutuee", + "Gxl+igo4O1YiD5seLaDvLg4t2+dbjjH+SYfWW6Cza3vtuVfry2bPk4l827Zx4yjZtC+yFShLW1KoxmaZ", + "uQwkiDyaUaUYbRCQvumBp0NftzGcBdbUK0T18lttCa9Qb2DBdm46OKGDsNzkAUS2uRhcBVsR//UwVDvW", + "zKBVMRW7Hor4DIAzMnkApmLLCahp2y/iGG/odEpAWMuIGW5LoiQ5czCVUmTRU4o/TgyiHRrB8i8TXbp4", + "wDvNAtWG5CwgGXOnWZQRxCC0CqLTfdkMN0xPJFrVQ9zz70pwswD8uS9WC67qv1YUXVwetTaTwlAufGiJ", + "n9z5nFRoyoaHK78+smTiCNMbHgTT1v74sDFToMAPtzkSICzFsDNbM9OBt0KcW0iMhUPTXhxnxG89bVOB", + "x61xjMCRheXI/UXjJgjXE5ssJuSP3/sC5Ha3XK0N0w9/XY2u3rkH1ejA4Lhfjc6p18N2ATbq6jp2Qi4e", + "Md71cDSpD9YPeEAYuBOSzPGIwntYgTniCOaLXlp83voM9ZnoCvvslRln0d6fJlPDkA8HXndQs9qLV4z3", + "ZcZwsdBxnQr0w0hhlCy0TxSbigUTrHYMdlDb9b7o6KdlGRId+t60XBixj1ryqSxct4F0J59DoFJ4m+jH", + "m6wjsj3Ee5hg6tn2S9DRl8K4mwpnVWBTq/3CjXvOJBDvRQXNTBN03sXf+pGTh3Uq6tD3z+SB9UaqD/NC", + "3gzm5F98w82xmr7/pmDGiI6oZsPwV8KwBaI5jFFu1wJp+93TFNZDMbd8Q+/WSYp12pXpnbIRvn7SPnjn", + "27LqQucAv17HygM6m2PdJMrdvQ8avDdiCwWG3t7H6FCmatPIbf2F3oY0LESi9azZvqEu6ML+HyYtvvaw", + "tUPTaBaWZT7z0eMBJp6HXWGZYUqkO3ZdLXHFsLuN8Q6erFf24zbngCDX0XZe7VuJpaUB/qoFWbr62aC6", + "LOF1dKjrLNg4LrJQN0ILMdKpBnZHh5+DrZDK50//5iH7Xjfwk/Hv/YBw0cR3kIId2VtuKh4IKY4Uyypl", + "7/+H+OQfJefUzjC9LeJfrlbcAO748EjAkon8LOogkQJuPyHRILWwiWaM6PmNPEJw6h9hLBtOZCoeWDt0", + "XPtHx86ybHiAGvR85iAx/mjsjhLT2U19ADHR0dibrAiRfVOSmjuAIW1moahwtStCDU0VRSMAmlyeI7KC", + "NWMhDqu9Z16jgNHk0h3qS/e4r1mjbNqLBAkRQs7uk3eQN0FCnxu22lLAIAWuk1waD6ej6mv7HycI5z4A", + "Unw8cvR8M97hSaglic+Fx6JrfhlVeQka1FT0CN1fGXAlub8CxsodUBz8qd+I5uBUSxxiI0k1mkN4UtmT", + "sNoRmnqSQHRL4fM0uhiXTQrt/n6zFmbJNCQjSoG4uz5IXRNamaVU/khfnxAPe2m/oNkH0FRhFzyrITHx", + "D2RF8YUkfufBmshkVRWGl8XaQ4NaMsdwwFynU7G9E6hbzOIuJuRHF79Fs4yVBqeERiQUNEITclN49Lu6", + "t83BaTUYwhZV73t0a71o3UHDAlCTdwsmhGD37QIg+wRepAaJ3cFx5ZBDhmJ0b/790CGSmK6N8/jJgDO4", + "Cq2HeJ36Ebq0a4ixIfiM5vWOuWKMXLG5VLU2DtkROtZEwYUxFbEeWoCR8UBIE2AuNJQ/cAkkxuHtUA31", + "wkglDC9Q2Q0v51PBbpe00gawFD5u3wGtQ9JfuSqcAb/keNTj5SaxcmIJph+YCGjoU1FbVNxoVszHREvC", + "4cFfrrixc1sytTV20R+K3e6ThDAYhyI9u3XxCr9uduGq++zWA5Y7aCi0h4lE3EDijiGAm0gc1EGC0R93", + "EEEJyg8prH05vo3CmuuZlnMzK/iKm0buRxodYU7s5wQ+x5NZsbHzVteF+irNGgUs2DUTvoxjRA6kCodT", + "+y91ibgV5SKIlQaeWRg8+ZQTzaL/TR0ll5dZjGZL9yd8Bx77wAlH/FfaBRp4aTQVIKE9irI2ThAVhbxB", + "ZGSBCGK+IJlimhltmaDWjaF8rNBlYxUuPV8bbP3AWBlqpyGMMQRr+IVQdiIs/5epAPCRG66Z/5prkjPB", + "fYAOOI8DsfEKWE7jM8To2SiX1VXBRq2bpVEyu7UQ9X1zGBXAi6pdgMSgBPlQWMDd/EqwfIjZck0LT3zi", + "dNmN47okyMYJeY7HyXvt6ziuXi9VpzC5xxXcU9HpAWvcIy9pM5DjBt1nr2zYDv2v+oEmatJiOMQegy3+", + "tMNV+OMQrr5ycxtOVDcpV8gaAu3yGflR1n1gGoZD5cUQOX35jCAZLFIRG0mqkAaG4hRynUXsVp4KJ4Wi", + "IxdTEHDb/Hib4jT779JDXmndyp+7FxJt9+wsaaoJxXKhuNYT8hpKD1szdMkEgUrRASPX31soWf/FXnTz", + "qujU8J1zwY4WCuPwnBQOj5J8VWI3GBS0lpWaCnkjiF5rBx1Zu1y9GX8Yieo0tz1jbBxndzgdtSdj+Opv", + "8XK0nhTYkl5z1JN3w0z63rcAFz2e3U0tYSp52znZYlC2RWq0Mvu7ReISifu+uPvnkbvvd1gapiDqO958", + "bXTafvHSeRAZtq/SjyUdAy4g+3PtPvbedGhPXXwdhs86tShUpsAPVlJjIqgPVeyrp+N+nx02cjSeAWhn", + "LfoDeTVZNcJ3TLCL+rtnEjcwuY/KBtc32vlv2lDCA/ZLDJnSD4AnsqVUB0ImquMHbac+gM1VaJIctUu4", + "zyFmtRXoGqd6fqWnIrxg1q+i66xgAMGDqfjaX28YZA0wMLCJl/KmVjs0RrFmtMiwRCfAYaykcHR6mXRG", + "CyZyqshKCrMkD04QJwGMK/jTw2fk8vHx46+Pjk+Ojk/eHh8/g///b5e2dcxuQoXg10xpqtbkQU7X9YbR", + "fGHv06p8CEPCnxHH6YH/5qiugZvT9cMdaqu4RfwsINpwjrMDxRkEvtYBB7q177cVMyG2808/gvK3CV8s", + "CyoOtVbwetuzTuQNAxzZJgh5G6Q85Nf3VgvAIX4T/PrPT985PDZRLAQHYBTtemQ/IyieVIxmf3BmLBbH", + "7bs5rMb73fSEMyoyrGs+KDYTyuyiFQgdIDaL3qhFGL7aJwgzpvZFzs1b7Kb1OL9asZxT04UIO58D7ITD", + "XM07WwgEB8zBWqe+m2I92VnVOoNU4ruwsEa30V/0sL8LPcwS19p54+7WCymM7uIKkT1trgZdycEcNYIl", + "kSGp4LxI1YtrxA1zTwQuGOkI7U5kLtWvEB26KyUAFIA1RhsqX/TPD2wdcpj9AkHO6JU0S7hhG8s2FefP", + "w2pVuvlE09IN7wF63rIhwpr/1PkAk0gJz30Uyn3xxGqs1R694V4266HUVpAfsFR/imoMOAyigMrO586K", + "6twdjc7I+Xwq0gtKNqxnpB8fEFM3cCmaWEz52M6KivWO7JqKT4tfLnyygS2YnH4L7TfNguQVgrjBU5HC", + "C95I20Yowc5h/WIT3cUmug9lt7GP4IeeGEQEt2lW8hJ1XWRDP3g41wl5KdVU9GiguN9CtN81LAjJGfgt", + "3Ytb/P1UNOjppm9EhZpAtgc+vR+iau+Z+OObDdO5ESDT3GklN1YLME1B5KLJ6lXDojLs9l5IEOzGwbcm", + "5FAUdRFI6SwocsdRuOsyggi/g4vaqz0KragvltIXS+mLpfTFUvpiKX2xlL5YSl8spS+W0mdjKW0xEHZU", + "KCNTqRtqFG9eSxBBm8OleudtK0knzaTzOUr18I7QtLx8nYmqLCXiXa0Tm5W6agR+81klEEPvIKLolq5K", + "4FL8mjEoRSDNkxeiWm2N8I803208hv525rPLQg9zGrssUNDcLSMd1yN2T0X8EOOy2NmtmYWEeqsp79CR", + "K/AzFbZ1S8+OYTojfnfH2RQFmi7AfQfDpr6MG4Veo8pRmB4Vaix2KnG7/Gb3+lj38iuonTs/zcY0471Z", + "7ls7AstG/IqKSz1dLKqwKcIAiMMJ2qXZY362WWe8e57Xtnru55Ym20+iAEsCrKPVqiPRt/fiuPc+wdl0", + "b63WuLl2vEv6qh00Nm1d48/LkADtz0X4T/+uvCvKfxyt29WH6C3x0b91JW47fFyEDuXC2l5qCA5Hb7FW", + "X1ZUeY2RGkB94d7OWT4VPncvhWLs7na4pPx/b57HmVeEBmx3iIPOmbaXp7tnVRI9cOYyBBOr9Ap/gej5", + "soRYcUxF8Z0PhYV0czktS9d1XHrj1A0Rj0ACcV0MoE8fa/ALMuCvggz4jwLI8VmGXu1YRKshiDZcLl0J", + "Mkwu7iTSujLSJ9AMxXuDBJleYFUn7paucmYQely3IWoa2M2uYY0bkswhc511sT3y7Sk7YcrRCNsWZY+E", + "nTcMvOb+eqr18DqLR2/O2hla87zO33k/3qYSOC9I7WFPgKrF2kJ4ogiLGboD106zs2Y2ne/PVRBzDPlK", + "Bwxa35UfsL2sV1FiEnPe3dn+YI1hRb2n+Dx0hZwrFcuwGkmqUqpvFSE61kvaQIHa9CGGwypesv3pf4Pt", + "dyEaP+0htPNj+/TtRl47H6xnH4IUqLECA7Y4eAcv/bBYpTP8c8bzy5brMPrUGvJ6KiwLGOQOO1fAJXJ4", + "gl9BJrqW6S604UVBbrjQduCp6DTlCyEVy5MiJ2LXvmHtm5cv8O38eYoAb2NtlWHdHT9MqG3d++2E074M", + "4HAdOBfaFcM08lKxyCnGusPF6n6kYnzzdI+bYGfR/6Y+qHtnbM6lItjPrnxyNU3Jz55Z7x8sjSn1s0eP", + "cpnpSdihq0eG3tr/O4Jb/mHTR2hus3x2coz/D0BUjeXq6Nno/4KfptP8lz98/N3ofhh4jrXOHRzvWe91", + "7mqic6ZqNYEIqVa0AEyseMPcCB9TIhVfcNggOWpyU5HLrPLpz9EGefJ4qwrqiZaGFkPTKLGRBw/07/ir", + "FZY/sApZURD/8g5v8Zhm6a/IoFrfc/0MY+nE+Jy2Vh8CSugt0+MI35E2E0Q3OXzq0hsuFmEGAx6WepdW", + "CqUE+FXl5EW9WD4OYmOalguVQPI++jzc+6Q3Z/Y0g6qlZLVY+lePBt/jV5eN9Lu2gf6wXL/mDMKgm0gN", + "cGI1sTDVWfAQ3QfJADbt8o/z3OE+yLKz6es82j76X3gy3Qq1ZhF8Xvc9i8ISuO446AbM5FxsnMk9099E", + "bYsFXh+9b1tUHpK+OVwbm8Shi2m7gzR8i5S37U+UkU2u9+2mvrPSFrBdAdAWaZ5/G67rCNRyj/JUfYCX", + "6IJWVOi5VCtNFL0JEEFRTSkujPTX4RFudYTQc+IxwtieihjNg9nlw5HIqdtkzulQY8sV7JoVRLsnMbqq", + "AbgyKqbiCo1VPFU5n4NxYnwpLCjziEicGACEupV/RwewMqx/hVW0yB+/f0Ysy4Cq7xAgcxwx6CXNjFTf", + "nbBvx1OhZCVyLhbfZYzbycNmKwu6tlz9bjr64/fTUT2MZpkUuR9oKSuldxrryTfHxzsMBh3ieGdSG/LP", + "5PHx/0FWVC24iMfxyKGpWU0e2+Z2T0FNspVdU5C+H5jQOzLmmx1ofWXpnIrrE2JP1zUt7Hl0a/IcMVAB", + "g/aBI5Yz9XDHOdQtyD9jwULsCc/udycQtHiBGKnxL+NQf+uCqYsPi4eJ6ULsc3O4ZqMxac+c/DNp0/Aw", + "he7jep3NoduDiUroLZSKrKvCYaiMn58r6P1SKnKJU718Ri7rwl7fwcl/1GH25SQ08yuSavif/5FsORWv", + "XKwdJaXUHKqzCimOAA0TJHsLNsgT7piEupPdVrNKpCDyTsmyWlEBMgmQ4sHBXofQBzoBATeYJy4oRrvS", + "hBhdEIIES6nszQOF9MYED7n9X3f+7H++cidmOnoI8/SvFs634cAxx0RIHBnJgtgskbfLSnp3fv1lClIm", + "rOUd8JB/Cn30uIYVN8sVMzyrtw5AC5dlXZg3cUese5axphnQM1nG6ygxl/R7nAxoD3itOcv4ihZWwLsi", + "MopBJTPUAPxhxEUQxZqsGBVcLOZVgSFB/gsf3DMdCSnYdNTEuDsmD+BD+983S1mwqUAadKOWwGvfWZgL", + "edCk8GEi2mw88kTcYen80FFwmU+bthNKopmHuUO8WUvJ6xSPXMOxCd4cYGnMIzsMeSBk6PbhhMR4swA5", + "pgktbuhaByxN5BSDYg3QkOUPu0f/dUxpRyurt9E4IUl3Upp+ik/Pjhvf+9cdpxobH7WPWC9yRRFd+F4Q", + "ss8RgTvGXgz8dp60rC33vOgBtYX85/8/FSfsW/Id+eP3DzGML5LFrzxM+F4jZFKbqfjP/yAnk8fkO/hn", + "Q614GEcQ4JxG45EfflP0QM/OTXL/7vv0dXTKffu4mLiPgqwFVmPreshT3MJT0dq8QQqhMYKip+apX3On", + "EFw+I0AOqUo/PASuOXlAHph1yTOKt5TDcj/SZl2ERxm3yvNCShV6y+3dFWC12TWXlfZ94vdLWsxnVRla", + "hMGpYjqMP8a0i+PJ1zXfq3LikBwFQwRH/9O/tNYAOeAfn6g+4k0cNWTBaDwC4kfjkSNqNEYxtWnHaLpg", + "31PNcnQADa7/E0NzuyI56MjzN3vCgYfVHGawpAd53Aa8RqoKzqAc8Yo1IlPVIvaqu9EdIq89rFc0+7AA", + "3kOQasa0tlt8k1fP1aPAGXysoUSGosqeFVKz/MKhtm4sVeSq1kZzumKFFAt7TUx2AK/y0LCfA3iVUkxk", + "A7IBzlyLs37YV99pyG8BHjZTS9yw7VSmIbqDz0/ZVvot6L3yRmCB7pikbVhaX0qRfgI1n2o3buvy7IrE", + "3gJQzucyc0FNw4oYdfv2FYwwyqbDj3lVFDNXcu0+RNUcyqVVwkEB5768m5ddnaPXt89fVkXRany4ADKn", + "lhzq4Lx12Ml4YNr3Dkd1ASrmY2WskBsyiv3Q8DdC98pgW1FBFyyfXe2RP/UK237fl0VVT8ON4rXbuSwK", + "eRPAjteblvNVaPoJ1bu63wJQ3bMZqj/d4wHE1A1+zdonL5PXYKN406RD3ZvOYfvVU7N6OdeG/t0fNw91", + "3I2IeQWfM8hdaWHnbRdaNWqebqPJ7gs9sE2LaGSwQGShe/83LNYUxx2xdEO7OY6ddJhd81DuWNJsYymz", + "EC7SqiDQ3SWdT8ML2b77xMU9JHSlxUKxBTDvSsoP1pYQOVGMFghhgKEPEaTIlp3zNtVgdyT3egBvEWKJ", + "C9BAdqqIIfhfKzYLIWguZKvzpPXXKopTi3PmO4uR+Hj0DxPj7CHw64TM6IaOzJsgxho6SeeCSOttHZuz", + "K7Gb6mU4DHGJuLh4SENjHfX79/4Sl2YfXhy5U3k9Ff1VFPYe20N6euLOQhdv3DB9Ck74MFEKPlRw/zi+", + "Qy10T1OIMdxCUh3bt5mifeuie3pcTcwt1Piam5tp2adCuqfjLb3dQoOhtxvH/7h9t9Yb4rTgC5Gu5AZe", + "af+zq9SBzZyJXjL03RVcYLKfc0fT8LzV8eA385hvljxbwnuJxgv7hkGEU42yQQFZyPWGhaCmwkHjsDai", + "gFPvsHAeeYA+2lAuFQh8CLlqIg8/T4Urxup+31ZIDgFetpaB28DoU99DWzXat8O29nGIGnG7D3fX7gI7", + "NhV+26X9XgJ4h45D4oJ2BcCiEzEVw49ER8AHAKfBRtBr33KjHVQDRLkD4lWrMJXJbupV9H2Ur+r5/37H", + "Yjid6e637ncoUjGs83tf/z0Z3xAe7+9a3XWDqjCMub6jhi4ROLiUN/ieCb/1sQzeTERADkk8msS31h1V", + "ovoGbLxp/xIY2hKvh78kUaHCKnmNyITRxduTf028q3Mo8Rg5NKgIdb8hG6ug/tU1rIHP/e+QMxWNzKx6", + "r4XccHxrm1cFVHjMHFCCe4Jt2t2aLOk1KGsFXyxNsa7D5eoKfki1buYhXJw8j4sounKAyRwDr6gnt5rf", + "tdu3elcDHbbTvZ+yoYvVMfteIUvs3srImVNLGuudyu35i0/Al8S2W1HDM1oUa8K1dpUuvXpUwyzmis4N", + "XgpkSTUpqfaJc53Sn/BtdPVEu+/4ebpEffMa8cOjR/cDKwG/ELr1biP76YqKihZEsWvObvZcfODkQjEN", + "sa6O01tZ+AafO6OmYZGuXEVPlnc16f+WYFdq9/HWPthh6zljAz0rp/Gy7rkXL1J2SXcvRq6v+sismFnK", + "HIC+gJ6paGy0TRbpDNumb6/uEK0d03i2h6FnjZG332pdSt7vzPw3TOTuCP+mTNdM5Buuuvtgth0yFJlL", + "xUPkVRSQEAmEJ5slAgogtOpiycA1ySs2IX/hZkm0XEV2tCwqvDe4+UpDwMxUwAtiBsGUkeDozLAlQpC2", + "nS6Qw22het/stTW2WZvJUzHIn7FJxIybG2Ggn6R7erq2Z5e5+xqiO0xnoC26aSI7bIHYTzMcn2awzuAO", + "4eyenhacjybKSK16Ym9D4LKlvNYiQYllwh7afOuF/AK+q/UZHLZOf3QSEyGHOlh4tCwBbpy4wz+eCogC", + "cHnqQa3DXhxNY99djW9Mrjn1jd7S27R2xMRcqqw1p3TyM365x1z+0qQzLnaNlW0R509Ig8pK7B8LVgRE", + "QsjKtMefTIWjDCtt6yiBpWTKUqDHsJienZ4ntCw9kKeOEXCnYkmvGaEwUiGzaJrgekOsz5LyvAOktos6", + "Fbs3U6oUioALCv+Hr3t7ArlfQJFw3wlRrpfE4aOGAkLaALyns9a7VQ3etGLY26ZOwtRe2Y/bdxbQ4zpK", + "iarG4/jQGEZ3l8OR8tCWsK7wrsdEDs9D2pmH4e7nIe46JKn5PKuo9W3rJyYStYnnSq4OFo2CgwfrF+p2", + "d0lP09zUMB4fP37iMc1PnsH/nxwfn/xbAyqDKoNPrYcL5RT5VvL7+DqI+BeiWysflgKmk9xnUswLnpkX", + "Sg3CpKGaYRN7ZbfvOUM5eEFq2v0w6CfRxtvN9RcfpFg8M4pm7NnJ4ydPv/7m93/49rgZGhE+fnr8bS12", + "+obxPrn6V4+tAP8LvTIN4ApPj79Nvbm8B/5o8z3VXH/60spT+hsJLFkJo9Zp/Iefz9/8RJ6cfPPN0UkN", + "cXFzczPhWk6kWjziWh7B7xl2gzgXk6VZFQ8JLcolPXpM3G9TAchQvqSAuZFHBTMYTQ8fOOhASLQvtIyu", + "bFer/poJDiAyjfP17k0r6qoRc/W4gavx8+nRv73/5TGCarRNL6xpcZrnUrjafkMluG26tbDF8LDiENO7", + "e3RxFkUy0Tw/ckpAIsT4UwDkc5JlIOAZsPvctd2AeRZ/0uSJnpAzdOBOR5qLRcGmIyIVmfosFzYdNWJ7", + "DtDbYRHmT6GqAWCyaLbiRxhCQ5C3+LIbgYU5LJd1vC3IefzJVEQ4xQF/nVwiIOplG8kd+8BMSk3c4D4w", + "uEZtx3S6mJOfNSSioobNMqpy3ZPS5LPbdfcIDrkafPR3jFf6OvTdASdtSX4XH4QxN80j1gj+iWaTvCBA", + "nIW4UwCM2088NvvYKietebRHYCx0flqWIWZR90MhFg79yG1/sAy5bsPjTVBMhtepnlcC914DjwDOpg8d", + "JL3/v73g/TyPn9ULCr5HUswFVaYvwByIRwgRYWhmCBfo0IyrsvmRk9vEik6P1G7JvInj0/Z5KN2SiNUJ", + "YKvfURxFfSIhMDAicoznrd7o/bIA7etIBjRpDKVx6nDMTY7WeUHNbM56naA45suCmpesNfS4EWC6sX07", + "v9B3cdegnQ3UbXOKbiHsfaLYkIua7krOvpXytsV+Ajs03yqrQ8D/7GAehF2DaEHeWuIgfrx+AYF05iug", + "nuupCBQmCs1wE2rJ1JkLUf0KkAv+C80M6EmXQt5chiIh4CyEi2LOqRmIz7mDYm97bWn3Nc6Fn+jEKyeH", + "AhiBrkGbCYM5Erp1BOt5Oxo2CBDAPzrN/73SgNW05+5s9bJdoTgYYN8fFRVQrwRICABfe+WM7mHcuV2/", + "aFChJ1+Uir2VivQ9GSnJbu9s29OwMV7ywhIxcDu7VvVJw70Fi5xw1GJEfcIA+YGvuOn0UBeW4JlP5tRO", + "FIZ/g+slhCS595BGL3G4E4aKrX3rhlPm5xEXZWVmCJQzGo9kZaJ/v9/RDmoB6HfMne1rcVGpbI+6NL4Z", + "7C3/Ym6YWunG4UvImGvKC3rFC27Ws1IWfB9RgIIt6ukCO2oiv0gx8znso+7NLYyShS8/GvAsM2m1XOzZ", + "vfFnUuhqVQagqDhm/DIa43JP+bZFsJ21hFoZOF8L1ZIpgICa2ftoBlfdvlLcM+9kcjxKqTtOYyitsoUb", + "H4CZAhqMf8JM0urw2y8T9AJS9fHk62O0MeJ7w/7yu5Pj48nxMQKxI/ahjwiyv35tf5wQewkgBocvY7mA", + "/W4FBhXk2Nc4a+o+5Hhs6Z+KyznCeriAgO8A8INwoQ2jeWftTybHfcWCs/VugvAu9/ofUd58lle6Y8Tf", + "zY3ObkuumB4KlOLigJ5XG2HHch/u0A5halw8joQuLhW7Zgp/BawUUMDD9bvDInWvbQAoiA/KngL8pUM+", + "ctE3ncm/9LhHGDTWvFc+W+dMqbhU3KwbURsnHaC354reHAGqkW/QZAD5Qd4w5evVQ9TDki+WTIXvJ3HI", + "GRfm5Bsk1m5zO+LxMdDq/pkCZitj3WDIwU6oF93lvUA7FW9gStyWqr02CNahyYPmZvNQdQjH9HCyb1Jz", + "h9Rh6c1eC8XVsPsEcCB9MVKsAeGrAFyG2eEc9DgRzRSQj6IKnEYSJjSAvUqlWGaIYtdMQMZuJheCI3gs", + "Vo/s1IZ126ulojbq2SAgCtSYNUtqvnI1PhkqyItCXoHsDBFYtiFcuVjtpMcuaImHvQ2FfSvYpJeLNk0G", + "CFXoXwUybBHGU4H41naVMWQJ175Yw+KzHIf9bSrntJFvfGBWCJKb7Fc4BVfMWyE71U/ZgZKPG8ACEiu5", + "wb0XaxiHUshfcoBvcGFnTZ/TpPNsPh7dHi3kUc9behgK+tpTHWz0sf113fFioMsFe9+qbz3vqlm1R2zw", + "XZm+scNrRHsAcm5i/Lg2+m385lu/REyF6elvTHSVLQnVZDp694Y8l0VBlX+xflEpiW/fQx9n1qsrWaRn", + "hb9tnVd6Is7P6nrAaaWm8rvpCA5RmBJO6L/+5/9yP9ipwcT2cAj1lVXx292Dru230b2Xf8sW94ALNM8V", + "08PfSE9du83PS673erUcjCJ5550/UEMAMJQ9GueoC/cXBvsVfAcJGt1sxpuJ/cTiYXYoLenrPf1dlJgs", + "FV9RtZ6xlQtATIJa2U8IfNK7N5swV9DgBfSZwnyBp0NqsFTNPhgf/sDCE95p1FF3p/oCkEYSP2IN2AuU", + "BMRbLwV8pa1rSGapQNQ0oG2gVWPY/gCQfpnloPr2E1ke52+bxPo8ztQdzxIs5+6byPEOikdsw9eCruuS", + "nR6MsVuxE84j4udAYgDPlm57cT0VdQJGeARtevvjnrWhhmfxjsM6F6qm9ZMpUet9rYOPsFsExKvWJsH+", + "sDtLpo4qLKeiTauQir1vyHSE6XJOzaBkzm9Z3mw3JlJNxXRUFKvpyB75QsoPpCqx01C/+4cfXuFfcmqo", + "Xc56TXErLJSsyqOrNdjS7qC1cK9wwD2FQiqeYaBoKKghc8b6YxZSntwZ1pSZIXLnIKHs73Bf6Swd84Ue", + "91C5Rm5DcztNN/hEsJY3YCv/9tjFnzXwrjsBm3B3wXndh717/3i7Dkyxztj9nAF4twHu/r1B5X4iejc+", + "bM8MU6v9IGhdJu9b20HCBR49nPv5zJv3QkNljz53gXkobWdNPM19QbQvfH9nTXjOHhRdfzfsiPt5kW7w", + "BWn3MEi7nyqw657IqCHq9dOFRU0rjt38gc2YoV0w0IbU6T/l416VsF9vdcbUPvoqGjdbtVSHuDtIDEHX", + "p1HLHt20/gI3j5FQSMk/xYHmP/lkNKsVE5pLsSHM7ZdEswapP9IVy8l/f/PTjxfULAm7LQEkSAp42me3", + "xpLkniFlVVpZ5h6Eg6WE7hFrJsGc/sTWOgTHuHQkF9SvuTZYFgjyEgVGgsCvlciZ0pnV8Jt8CPFsYSq/", + "m/j48M4WBFJm/QIBSfUr66rF+rp90eI3sxtLJVelGW29y6F3PTtoAjeEVWvuc8HQ9HSeek8/jgsW8Lwq", + "IMzwAy+JLPLw0/l8Klq+BloUZMm1kQqKIeGXEH7oq+hOfh2nzaehiMGunvlEhC49iSPSPiEYFxbOBRcL", + "pq3mDaz9SsMRCd6CdUhkD9+59lIRXa3GhF4vxmTFxRgmuKK38Q7Vrgi8K9SnALU9erRxUaIlVS5szn8b", + "AgnclZZhAeK653GT+Gawm38ZQggSaDsVDanp+RBYCcr8QkhXdLE+Vr+bhNDUPd6B0KyKL4PG8e+/oC4K", + "Ku6QYByab7+o7FcDU2m3eSF9smfCJC0L2kgwPoVPP5G7yh6KmaVwVg4L99mcemtZ8oHVgasFFQQGaGei", + "OL5h9K1uhd/6IKSGFWzb1/3tV4vldubL3aWvIxcqFZXbBJM4ptifY0diDWwGy21P4VRgovORzy/1qdCY", + "hzbnrMjD+XWFUfH4Qkp0p9lU3DRKqFai4CveqP/XJso95dZxXqHYy21olKzL+enmHeDh7W7czXJlf5Gy", + "84tzRnMmhpSr2S0E1Ls7XffuFoqhTSuNlwvXHVHzfbPx/Ts/Y2iFNjGf5kPybww0gNLiLjADIAvTIAP+", + "U1+z9+8GZACOfA/AQH03aAcU5SqDIvqaoqvSvUE1YMDIqbug9A032XIqZJZVSjurKMAXAe516w1iQk4N", + "KRgFG4q5bqCkNUqvodAGVuxc+MttxcU5to3k90U9x1EXGKdUcmZliljMdoW+84n6pZJH2BTwm7B1lDvd", + "OtIX9ed+pCSaWq+aGLlK2nI0rHK/ZO8GHw6OFbVCrfb1dKU7upO2F7HrFqHpJ9sNu9+d5GneASFi5jLJ", + "EwfFx1zY3VyWYHiDX8EHCOuhe9aRdVqWrusYl+PUDRGPQAJx3Q38DxES8emqWM6CizdQ/2buy9Eftqu7", + "xY121ru+PDH/HT4xf6nt+uVp+e/3aflLWdMvj62fymPr51GG8r7eW5vFF+uaiwldJ+fme1rQPayMOl/3", + "CjuwZyFOjUnCJBQHQao5c/AG8dsDohqwnCi+WBoi5M2EPGeKX/tCs1nBqApZa5h8jPUP1mDqFXzBEXzB", + "FVW1y4Q1EFRVsFYVlRPI0E+Vnz8cIEyna1dQ6OAshGzbK3sZ+Hz0qwoYK6Qha2Zi/k7IOT7YacfJqaA3", + "lIO57HEzgNWwJ6RyUcpkXoESUUtUX/g0xk1O87QPkqBmyDjaXzGMVmODjnqPAGb2fvK4wTWtvxFyMBDw", + "VlGhKRyMu7LrrFJaqntmWETvvmxDOvfjWTNIeWCIihTMULUOuCGC0BrUZ4OwDYPtJByaMmt3e67FCjfq", + "eAtmSCuFtX2tKMY8SvTP529+evr45Pf9SNT21yM/XAxFPRXNNNaAQR333/ikD4Z6KjbgUD9v6slPGlry", + "kwQQ9ZMeIGpHyacvgyJb/DcQQPU5TFQBgp5dySIKAUKdKZd0wXY/7JaTHRqhi83EXbhRWgBeXKXAM9+9", + "PvcmPnxBYIAI6aKkZjlKoq5t6Q6qjO/am2C3m3uzH/T1JqrC6XauvHzXOGTXXFZ64wj+o71H0fxvCZHi", + "fHcsh34JfBSd4pPj0BO+J3VW3LUADkVT6d8D9Vb8HxVTa78dBpzh58wwteKCaRdVAKR7a6MuzmUkUcwo", + "zq5ThTvromIJfjQX1fZtj8y4LisTPEJWPoR6h9wuj6IuNDGxCBi8uXnYxkpvHdql4uwwdnoDQHp9iHnA", + "sqBRPF7JQAOJoQ5CzEAScc7la34GshoJ/a1ktU+N3+8ZKyTH/2rvWMHJ162K8frl2ZMnT76tFREjZaEn", + "nJk56CJW53ik5pn96CFBwWUX1No4R1BC3T2bczEV796e7VwvJsjA0FPkZHBUEUv40Vu+Svo2/Kxeclbk", + "iHiFtdXXg/ye4y2L10IH/utBfKt/hmhAtMOLNWF/rWihyYJfM0Fevzw7gtnX3K7dsFwQ4PLH8WhhDkgK", + "FAOOAPggUnkgOewe6ZEKmeSv1GG0FQdmVcG03pdPxaH5VBNzFyYlag/1wbrKeNr2+IIceODHeehi5SB8", + "dUJOi4LUZ8jaIlMh3XvWv3joJsJuKZwEKViN7+rLT69Kqrhu1n3xnCFw/Ik7/00MHwefN8EfAy+jj474", + "yhpEqEFb02a04GZZXUFNJlkyAVcyl/V/P6Ilf3T95JGH5rOMSyFYdERt4iOMQdox/IiGRw6wlsVUeNyq", + "ANkdi97jk28pe3o8P3r6+Os/HP1+fvL10bdPvz05+sPTx/Onj+nv829otv0txBf18iN54smf0k9m7kVt", + "cLm4jJYOH5Y4pBOIKg2pGURCtUF4lqB+06gEZBLIjPxQT2C7ArczF8/p8GWDB7Dj58xZwX47+mD0LfT9", + "9hWUBjx0oRKUcih/wcj4gpHxD4mRMR5VZf4bykDwzSAJfWKma7SMAypZLb8bE+lH+XBLapcTfBKvmXa1", + "jQZcQNgIg0X9mYAF+avtst9o7SkzYX8mSt7sHpbXmYW8SRm3B0uJexPXM7WT5Lh1ucRstQNVHn1RVx3t", + "DJKyundaYFeGaIh6oeSNz05UA5d6mJzZVoNkVVYAim0HdE8fD1Bg/+d/kCA2Hk7Ij1VRYMyNj4R2YLrh", + "OXAqArAtKOKZXF15P7Gc16oTbMKtHsZfL88gmrvLADZJqLTn8HeyYhr4g+j/Ed8sPyCAit2WBeUCa3Wv", + "6zEySO60PLuCglZaFtcuOuleUoARRMV3FGUy2nvb5ddZoX7N1IRcOhg0Bz/sodJmPL9EE8lKV3XN8tZC", + "do7H/ZU5Bqvuqso+MLN5MvdXqngQCXCODnVUm4B2dUZpVEC5I8KQgDGKjEacS10AubHXNoi7lp449DoL", + "CSmSUKdDdFTHuNpJ+0FnS9WXzZwFMY029xs4K69oeW5YF5I2eBQsmWVZrL3jIjpGbicE1/iK3saUwCNH", + "Q2GN2vp5JNi8l5WRqMf6vEEgTMTz2Tv7uY453SR2dx+u2xefrm/em/6/iU8+QD+6jQ/bbT8AyF/NK/9S", + "qiue50zcc+HzMM6hKp8/SVc+b4wzqPT5k77S539kphHKd0EVXenI1z+0JhWRLgvTyvIFFpusMcpdONUh", + "6lyj4IueJl7c0g1O1Y0Rh8nHuj9Kwe5549ghDrRnTo7Te8YPMWS7nBz3bherCwhLqjvMp1nmUaUHmAvQ", + "iOCgPvcQUsP7b8wl1TMaBuurqhtB4uLqmmJNllQTbBqiJdwoUzEVl1Zfv0T8Z8zQA4URvTVoc2OIrAt4", + "hFAfbyIg4oVt69SZqWi0gAtKsZXTnv32J5fAl8s65j/yE1Wi7h6Ry1FFguR2mAyEWypGsyXLx0Qq8qCF", + "7vcwVPEK4ZlTwW6XtNIGFfSmw6C+NP818CpZhlgxqodARfTsl9fYzQbnEA4U5UT4Zc0lQzMNZpZeVnIh", + "S3TLOYiAy3r3QG0tx/5NjPAktm6aaBu+T8qMTfMdqmMCC2i8N8A+hS75VeGUzxjQuhXF4dGjNymaHZXx", + "NHxHtFFVZsfGSsfs1mxi2Wk9XII1w4ppbGRkj0H8imZLLlhd5IBZURxqUfSRfebyGJwd3BUv/9osnZDw", + "zcNAm8Z45freFsfvSqJ6UgZvsXRkZIcx7nSFyrA5E5zldW4X9NhIihAfhLwRoYgyyKKZE0FR2kAku6K/", + "Cmlmc1kJcEPKGcqmWTPsum3519MEY6e+iHc/QNDQbQIriCEEtqTKcKhEoyuY5rwqyCIMhk6qDRr738WZ", + "qll6P0fJi6QeD66X5e7llTNVe+pViPWiUMIprzKWo4239ZSddTtO+aI+u4PeWq7uw3dYHKdMdfbznPLC", + "l13tHOngGqvP6Q4ncr+8ZjyTRhJ2TYsKikU3hI6bQAH4e/OwVXTKYqj32F77303AbxqdrKIe5cTedaCX", + "vgpvPE5k07ugQicedQOiIsnLoPbWAYktIycuMIuFuGi2JN5RG5VA+cvSaoiwlfEbvypumewR4D53pzVI", + "tmTZh26xxUjHqnNVYyr1dmiMsMY7nI/Ocg7bmD+0dlwkQ3Rjv9b7tLsnP7B1wjx5YRnKhFEBj6pW2sjl", + "B7a+BFg8l6YdFRnxlTzwo8lUnMc0uQQ2dL/Xi9rQCcFaUcylJNQPNHC5TcUlyDN9ScCR1HhL60pNeutx", + "V1y1xC4MSxDAlhGIltk3py7MRWvtgZe7r/vLqMb1gGUPBoeXOPM6Y7133cn5vEYdo0URamJPa/XHM1uq", + "BRX8b65qKayGqZRg+YRcQJBNwKoCCgAlJ5OrFeR9TwVEads7sLFyEIkO/IVgfUlzHzJ2RbMPTIREd73r", + "Hv1hwPTvvE28I/BPlpSDbYO9PLW+WSgo2ro5d32Zdi6NSFziM6geQ8Adnv4Soj3awnfXF+zuhO3V8LFf", + "F3mOLt22rxjPfCoLBjRj1HE0YQJQIeCN5mbJC0A5B8sTNmwDiGQf+r2frJf8F0hnv7N751fUkICXAJ3v", + "Zv4Q90RWSi4MWdG1O7K18VCfQ+5w6quigAdF/OsNvIuy24w5yAmmjjTPnQtHb9Yf+33zzDOk10mf3iJ7", + "Oec6O7npp0tu47sqaJ3kg543b3fJwKMQNdYEbdzW0VW4i7UQqXh7P8j1+UU/Jmp7RWJWh3QVrryERa+o", + "i/Ir3U2qWMNLCH9UITmJC3LpfV/2p0twCrJr0Pzx71OBisbm+6njjsT3PXJDdQDk3MDRcAcntqZbqLRF", + "6C/feBXTFmGs5sCtWeuwVs0C96uCsF/Guz7hoGxZmQwJPbpfQ3Esc5ptBb5VA2nptOAQPcbb6pijzvsj", + "NV3FDmlZFLTU6LXzWKj+cAHZY9wOuHDR8tZmsmUUy8mSoS3Xfw33ypfueUlI2AMHuL0NQW3+KVdqy6wM", + "Ev6XVHQr2n2l4/MAb4YFy3CzTwWsPHJu0358h9MAbJyWSPXbMfJVRFKgwYGUoG1DlXbTfs7f/EQgos9/", + "UycA5TLTk5wvOLy2+DhObf9erXzA3yP7gf3y0bfHx8cnT//wv9n7Gt42bqT/r8K/cECT5yTZzkuvzYND", + "4TpJm7um8VMnV9xFhkztUhLPK3K73LWtBvnuf3CG5HLfpJUsWX4Disb28mVIzgzJ4cxvvusdPN9zT6d7", + "yZArOdQ9DG1S/CGGH/Sn6eypxdguuqwfH/zbDwwyo+gUgo2Pn/zwajAI/wr/9PVPT3/499Mfav76vvav", + "v9f+9TX89WPNl59XaPvk6Q9Pf/iLf6Msz3KdveedQQh/c8EAquFW4g6AtwIXkwKxOwAdeCcuaMTDYxss", + "eTSVvOVrf2n7h4rKn4AyemdFbv2hWmgdU9x4nUPgS/Ed0zi2NjRWUInmESavC+EhdnowqqZVU1lUY4bj", + "OHV5oKlC9BfP6Ab/nrboAXVCkdiRDOdLDYveGBSIA9DadcvRZs1fs1hfP0W6xrKHtm555csOkg9v8d3U", + "DKEvWIuWs7JJxkB+cPzhLVgb3jCRJzZ6YCXeuMb6GQD6QuXv6oDa6xYaMOXdm/EMI8KpIN95URJbXfkZ", + "vRpGOGOIto9yAT/vRh3Y+Wy15AiYf+NLbnH6115ydBGwUNQ3t9pceKvNxVAf5VKTPWQYyUuWBFQx83sW", + "x4XfMWu9Le0YhYsdMYpZhTaMcpJSEdIkvDke2YJaX5ihAAf8Gyz4Bme7zeSqNrzo3wmlYG2SLjSt4dfu", + "ahWLWmLl2oVtZdXa3iF11arFsw44uRVt1suPJQWuWEdhOM7odrga2q64AhTKb1+Yn80bGfyiL6dDA+nA", + "1dAqQ/hFHynsTwBKAz8bxoKfDVPCz1nGTb/jP0JhKQBPD3wgzjNN6ZkB82+OdonlIbCzY208apiwCbtC", + "8Ek9dNOpRcYaCpZeyuR86L9ODv+Ugg0jrtKm0gEPk+EoksF5uYQNVtb9elfAdU5Xv/zy/kgqQEmNVn1A", + "/OU9wXr1Ts3F0vlLXm4TCVnUJaw/6XfJoDOJ096LQUf/GEQ0C1nvee9lT0khWDro1MbY1MeO/urFjJb6", + "+On4o+3jCPogz/svyUlzH41xhXUKzJ/LYwyxWhUoVJ574VlgfxYQymnGETIhZ+YaHsND+DkTNYZoGkzZ", + "UK/9MGbJEEptBAdTt0t0uwZv2NFAnnw6ef0UYmaw88uEp2wbvUPDC7rnIs7SzXb8Tje5oEuZpRvv8wO0", + "uaBT3EgN/P3m+v3NNkvkYgrKklGa9ppZWSAyHy5YkvCQYUKBFYUGl0cLC4IlgPt9zJKeFlQV08ChY5te", + "+sQgDseY7wR0aRdlbCAgIaZ1lCfvxloEbU1CI839c8KuuEoVKYZLlpoiVIQ5tGKX8JRc8iiC3JtobK00", + "73x9of1CFRPGvIlAgiVhlkcFMEh4QLU4tJtLoPk7PrxwlQ/eZoBzvZX63lA8YE3P7CrmCVPQHyxdLab1", + "ERVSQEJOXN78RaF2c8KG6reokt8dtqeL1rYUe3tJq9HXbUQ1jxSFzQYxIDF3EHBxzXu5+bJ3wUQoi/v4", + "8r3TtevNcT62Qmxjid8WKI5jB6S/wnuvyNERUDEkLJBJ2M0RCOyLP5Zxus88CFtMWaMw4N3O+/ONQckc", + "WWwYh6HQ3wzG9ioKgjzJ405odEnnigw6n05eDzpPa6nZqi7B5axRJAsJ2bhiQTKsViEf8CE5f2zG7/CW", + "a6duMa0bCC01W15RaVU6mrl7wMqKpinq2WqHKkD7zam12t5zNbdS91YL1jnXmE8VzVjpPbejrNg3D9gJ", + "1q1lQAf9CRwW6JuQFrNaGjb85v2Lh9KySCHVXanKe0PTxmCmraJFmlFelu0dJ24hGq6rSottwuxFzNs1", + "CrObG75FRjX9CKBW61deZqTVr93H+Xytc/POD6r2YixjJijHmzEV6TSRMQ/WvnVX2/8QM3H4Dts/XNj+", + "ajduB7DV5MPk4UB9+7wMA+UjjtPen/u97wF3/ODrk/zXXn94+j/e17+a9/jFwB1IGFGpTJhztAOEGGFR", + "jfx8HJlNH4zuR3CFcQXRVyjBvK+MJsEUvgeJVMo1No/1TlNJ8i/HBA3z5KD37XPvPQDjOI03NWJ0gCvO", + "AIJwcaHOpRAsSPGXGVNT82e9cuBwNegMB53+QPguF186TFx0XnVSpowbVAFc4aUHrmBWr25duUoh6bba", + "bHi2nkqYPMynvPgytU4sdrdlQL8PMNsOWq7Soy+KK1fMA6rXGeXXhiXD/H9bWjPMG1SzZvlYthRHjx2T", + "0dx3VTxxeQ9sKDmhCXulP/XImdmOzuAXk7YXfh5zQSP80QA3nukqZf96v03nQA8OtjGaOlzt/oLlkCr9", + "kaqtLYjeCke6/Tq4F5oOVwvWW3LpsIvhOtXrobspQkItmo48Jcy2ZgTjhDDVzw1YaopADyZXUxHnobuy", + "eFQT6JxgC+37N2KybCm8ZDPbXZDU62gTy9KUg2rR7Pg0VNbIYlWssULeJELGtlXp0F0vWikkk29Nibj2", + "63DywvV2NzudK6whzl3zLKDL7Jsc6sIGoaMv5Gvj+bhq/J3zlfZANKwfsIuuqE/P0gwYaZ3L69vMonTl", + "3M51426KxVkU29SIyOhP8tY4rTGy1iUSTuSYRzaj4W0/w8URFcN1e40TPqPJfMhmBqNn5RYQF8ELIxia", + "MII1aWqSPfAL3hJPcON7TBh00hzSM1zVAlcYWpNKxl5tXlQPTc+phXev+6tCy9VM7fL+bT9mPtayCa0x", + "ZABjBJgB/WeIurEk9DtrmMnWGrtBlcazkkx2OnokAGlBadr24LEXPIWYfC5bHTiOVXe1xslnrSEuOeE4", + "FMRtKBgbYFMblbyW2gWPqvV2qDV3mqaJ882oW9LPRYur2gqKXjMLead0kxiR9Sd98gMa6T7bb6ef2R+n", + "f/908rr8fLwNgvCp+N3rEi22W6QFXKmqb9Dboweeruso0h9OPwdSpJQLBZR11np8WY0q9wRbpMn+GWcJ", + "bd5b3mby/aVICv4RCTFPBY2CBpFSW5IwdNBsVE8bnw/jEDqak3OGd9+tcWfeFXpWNM7vcUS3ZYDQZ/St", + "mJnvicX4JBu5mdzSEii/i6Un/BW31LUqwcVt/ZrrLL3jm80v43u2+nIdGmxriFwoJELBZ7GQjSGf51Re", + "klQi5gE8WDmQdu/G5j092c/Yi8pKL8OQPfBFQ/bAEoXvCDoSfDLoZkU8f+Mn0flL375Xm3n5Sx9++Nrt", + "AIFD8+c4kbMYPL1DSKT107cv//O3ly8P3/5++M+f3xw8+/Xf+0f/9/3bn01WklcdcDhSw1Sm8JqMYou+", + "DYp8NH/1X/AXDQ2w5nO3dqASWjJ7sY/2589gW6UMLHDo1ax3BfHahkO5XtpM5SD4BpD9a/cx59bdz7m1", + "kfwXv9IZC8k/Tj78ekzTKWFXekZMLgxJ2FWqSUIP3ERmsd7rgdc9MA28b4IJtfI6btLkwUu4FArMpgL8", + "2OIpFegjjaBeImSJCmTCSvPg6Z6KAqhoSl8j1NltzdXYSIZFuDOwJZ7wFCEOnGpZkuIKFeZwo8k9wNlH", + "cWHQulCpqymgAVn6jaImnxQbZ5BHUp3zmMjIWd3Iu/FAlFKJ0SgiU65SmYDHrbnN04TZdsP+Xcrsdkuy", + "nN32NF7Vrao8ZTW6oKwKTGYVqwCKNt5vFOgCl/VsDvP80S+XZ2ZR2axL6MWkS2ZcoMfMjF75oqjwCGMz", + "ZieAc+Nl3TT+PTFNlEUqxLLQ7VuZGB00BOgxv+VukXgkyioualJ79slbwEHNRDoQhe3VzoObSk0onwg0", + "L/r6w50FlrDP2inWuoVDRUENnjadJw+Lx5C1zxK5Y545DOqpclGNQ/srvZiYkGOMUNcCDg5Mde57QODt", + "TZqC5/GdpEyBrr1UPWqtW1wxd4/NNdQETtjqmHHTqYWQWBDOBVm5BgJOGyZT95NBh/2BHnZcDDpPvSTF", + "uPG5+M+mnEXF5fi6cIF+SqjIIprwOiX7EQ5UrkAhdRYctED1QKpkC8VkSLQbuD61WKgiyCo3o6kvjccf", + "D953uvoffeU5PngN/3/fLG/XQGA+9DnIB3H0Dm94Kiokl99/Bf/p+9PEnyxDrZ4MiOHtvOp8+niEqbi8", + "Fp55LXxdlA2r/Q2rIFnNubTL7GkkZ6uJ3TB/Gclzd3Dl0jOii/TX0jSuPnKfZRtI4n+ymjxvMCV4QfAI", + "FKlsyGE7EG4MpaRweKMQKU+Yn9oS2h6O5sOiNlqcy88nybhlkNG8wJefOwXrwukKMLRl5e+xq4eybTi3", + "SqjLiqep84+nMK26HUKVMdM4mOV3h78eolb4jy7w2mSeHQgAgnu1t3d5ednnVNC+TCZ7uqWebkk9RQTS", + "vGkvV3mol3/GBV4wgOcwRLM+pZ9qSkv86eMRlIP2XRimakjeuJ3Ug4uEJJX9ZSp7LXDT9wXVZ/EDPc2H", + "Z4vP5Z20YBZdbLCytjB4deqlWTKSHQ+1Js68pJJNGrZZd5orQedV5+BZ//mLl9/CPK/b2tf2XlS4RAiQ", + "CzyFOXi1UvCTIRE2i9M54okjmLVBu27rYuUt8JYz9K6ntXcnC608x4rTt6EsvqUjpy8ud0ZK1jspPyak", + "vdUJac0qbyYhrdcBtFuVOuxupWSzFtYT4TzX2Ky4mBhL6FhGkby0sdhHkcwQJFS5WOuqOTTX6AWBk3hx", + "nMX60PMziyLZJZcyicL/B8MC+0fh4OQkEiT7ZXCwP6Yh6x0E37Pei/DboPfds7+97AUvnwXPv/3b84Pw", + "eZCHJ77qmGQEPWMf0eResEThKA/6+x3PvcspkR6YVNAJq6ABSq85xSelxh2tbaam3PIc03kkadgn9oWg", + "S/iYGGse4alnfvrHyYdfiTSuY425wHOu0ERB8ieR1tu/j/Aj2nKMZPgrDnsvcin5oG/NuagMOiYPIKAI", + "/1dJMegQrgaCavaxJ/efP3489m+g5TqamXOjWOVri3znmkQUvIXhpHCOhWLmrVOPjIZTluiPAODu8Iqz", + "hFfMckvpWBgDqvJHkaIZsCWLL7Ewq+XhtIirAHnA9NZ7OeXwtmt4cErjmImyjbIkT/789HxormXU+XLo", + "X4NQJGuuQVi4jiELKsiMIn9vykxUVD4E7GIZgbnPZzlzvf5tZNnHZMmxObqgS3OMsVNb+GbSiiUD8cQB", + "AIS5b9LTIqlFhbSE5PWcRpdhpjuoBBkYXxmWswZ5r/UQioy+I/729og8f/78++IoFmjQpSLUrKMoF4oY", + "TWQeUEd2h7K6C+c8YZCQ01phZMIx84aYDEQ+qtLMy1nf/NZXcsagpXUM8y5Q3md5UzNns9NS7nA9kDem", + "y8aNvYjXvTL0invRmBU3e4g+xo+F5CTFzd1PsbHszG3fPF3ZG9nFh/jkscY2XnC+X1TT81KvKfYMi329", + "fnYSG5DjUqAvy0/CC/pI+RENsLx+6lZ/dVawBLqTZT0pRsoipxO9YIJrBTcsegCHtFTNkQzwnafKTycE", + "lxDr6L9+0MEaVGFvdrcIjY3OXi54iIkVmlImGdugKWYzJ5m9pvjSupoBpKxY/uU6cWmTFkaWWU3pL7I/", + "tad+Uj5D5mqqrkzRapoPmqhO3RbSreYNXD/Nag2cD+ZJJQ67DDCg2iYLPcIkoO0TlOoup9mMCnJbkpT+", + "KtO3MhPhlhPl/yr1/TcT4Yay5e+/qM+Wr/t5a/tZJWX+/oumlPnW6FCFiDEeVc5DROlzP01GPE1oMtc3", + "zYDDedv4SBTztAwGvR8+7/e+P/3rk8Ggjz81gLF88HI8mRSdH+mV5r6V0yV6LfUidsEiYq4NJKVXyP3u", + "BmKQIbTSwYN6uajClPV4KnSAcSb81B7dLaykvsL6yapM/kQ9QXpTyVI5oykPILVzfl72s1txtQA2crMu", + "loXTu3WgrIejw2TYgBYwTOnVijARZh0XnUlelxfIYIMWsRmcTvI+uCoodRcSMKhukErXZzGLrPljgbxt", + "pqzyXLVaIHhV56lplVfD6TqmE/ae1b3PuJtYnKczxDcuD3TcZgsFH2rnojU2ZqviS01RNgyMuK8J82uX", + "wxi/6qmY0XNG1byXsiShY5nMeuhjlQO98T+LKtXz1FitJXQFLza1Xlul9XNVgVbbUcOCeN5BlVXBCUXN", + "5y0MN/4feAUtznRsdv0lPkms1h0ptnu0kZMieWX6W07zcUQFQE+t6sxl65W3N3MH0jMxMu6cFOKCMKBB", + "GDCqLqj/RMJWMBDGLIY4VeBbkycy1IoizpJgShXz8vxHtAYKnLqhtFIQMAKntUyGgNq3A6CscsODpTeE", + "uKMmFH10678Xbv3jRM6GEIYUa/ZrP08FB+paljpnztMMxAM6QD/e3Lxq+M5CvNYLhc99b3X9vL3NOY2v", + "6gI+o1fDPzIKa910t8KFybcq4Bp/3Naf2Aw0dP6uIHTkrUxsns2evTQ4JQLAoJCHJYcHNClOwVNxlkUp", + "r1TTqoiJHJ0sE5DTl4XEDqZCVN/LouNnwX5Pr1ylTl1eo0cv+fZe8sssNTa/ea3JoZVd5hgeDdIjmtJI", + "TmoMMk237X+Vu1yW8rydLzluZVUVVHtSsbvx7fXTzg8aO/HV1t3f3skxuFOayB1NT8IDdnvnpwB/v6MJ", + "WqQdVpujisIwAA4A4A3GMRbWHWu4UhnbgglVpUkWpFnCQmuT2bQp9T2aUfMUEDBug2C5uv3UJZSrHipi", + "qo/l+AYJxYovjqBU1V6cyL2EpiygSaj2wCFmz2DX/BPesxozoJu8bu1NuqXcFzdozrXzVMfOlSiQlV0J", + "0f5g8sebTBEYCeb4sU8+xCyhqeZwfaWbZWkG5jt2FUSZ4hesCwGoAwHp2k1ZeEkzriw0JdSAJ1W4XtTl", + "LJGzEUTSe7DcoSFS2Ue5SE4gyPLw19etDwfV+Sr5oC/KKgdigRachuguO2PElisOwLir1UW5/rGsRRNu", + "07I9Lpa1x5VNrl9tUi3OWV/y2V84YaLtjLkcQqZC25GK5VOXpyfSc9i64VZzqJu9iXmUyTWl5MNvNyQk", + "+YMNaieCbRADB9JGidlQtuvrMkH0iAlYmoxam9F4uWobiJJuI4+q7ZaoNsxhtrRNKOU1YNNyPirHR+V4", + "+5TjexoTXWeBlvyNBVmiCx9DDMqKytHVtiEsOAOCUBFMQVOCUZ+LlCUXNKpTZrrcZkxLYCHqgZeP6T6V", + "gI5vjGQlUsvQIYu80+zlxjQLBHQ7dljtyX938uG7b/cPXps44Qbbr23XxRP7AcTEix92tB9DAHH+RGrq", + "+9VcW8ZfuHw9MCvhjeq0ll1yw3VFOA7Bag0YEAZMxkd/8OIYjdvtHDJ1W8RZfzz2r8Z/0M9b82J53prT", + "vz754dXQ/fL0f/7iTY4dAcGrXEVD2O/vqaATFv44X5IOiQdTgpiFZAZVlD+qgRiIf4FesskwMCfS2SuI", + "8rTl9ORg7ZBggWhOnpiUjCETZDQnMkvI4fE7PYmJetqHxrDjBY0ZcF0sZ+p4EHAtanqlF6V2Au/PfJJO", + "ayY8b7lu3k9kkoLyqt8BzqgKzojKxmN+BRupfeChRecSJZOUyCQ0eGoqYCLkYtJHWJMz3bDfjOVIdD/R", + "DKlLYB1spj8Q77Mo5XHEsPHcoEJmdA62frcDcQoQbrMZJYrFNAErV8RV2h8IB9YipLFzm+pVGlQ26uVb", + "3hM2eUW+GUvZH9EE6PvmaSnPkGcohgIev+fzWjfpFXBD0Mlzo8rK5VfK6998CgGBKJ74MGesURfoT/5k", + "nP355xzh7p62PgNi27pMkOZwEvVdrHQQxISGSca6ufXIPR3ZsKAnQoqeyKLo6f+iFxLOTLXGQNCRqaFL", + "158oJ2nT+LgiE1jxROtW0TiFEbvigZwkNJ7ywGBosPrJnKSsbW8yscc62a7ngVjYdbRonBFTamODjBYO", + "Mu9q5REu7lY0c2rNQbklo8pmAfvN+J7AKxqGGdGUgDz1LHyke14GddULmX3JjKcJZBTC+8BAmIuvwVjy", + "A44O9enzjQgkaFho57VtZuEpvDqWugmqHwW7okFKbuEoavw/m0BJZA0zo3pA3hrNCePplCVmtDIhnjLs", + "k8Mocphd3OTFshvi/9rtCOsaG4O3vZjZMmg6fXAFmsieod1cZfqFu4hXpMdnsUxSdFfSJ7DOhKfTbAR+", + "sDJmAiNZZP7zHo353sXzPQvz8rVu30FI1c1tPlvZGrYjxo+sX2b9fJjA6qTI6QNxDVZ3pyJrPdQ9G7xk", + "5MHl4lAptyGZ8M7P6/jcob9d7gxjjBHlA3zp/r3h7NNt/TtgZWgIoYwFDAL/Pljx9KAbTVG9Dq0eVMFi", + "Sm/e07C80I8eh/fQ43A33nq3wxVtsb+gc8AzlKCk6A0E0vAfIIYpeAOSsltfk4/e/y3yz7Md3jS7oskp", + "ltyEuduoRjcBl1QBmoyMLgx+0PbznW/er+9aXnGeY6W/TN3Cfldn36xswrfX66l6XtiJ65NPxq13ofOJ", + "3c10mVioWz9Ths6dTlIeMLbaxJjqeShidUraJRyp881tQ+8abgY3TjOUreyk+q/kySfBL1ii4BXiE77k", + "/OJbu+DDiUxScFpzzyFJCTplIQSc/2yz3/vb6ef93veHvZ//8c/3vx73Pv6r95/TL89efvVfboDimnNB", + "OTVMwYqwfLrWMSyseABbzQ4Ba2AxyJzVYQNdNhopSj1u3iShO7AGCfNabqHh1zJItFjVTdkoYG52YKGA", + "fn37xELLhJGNDZskPgmapVOZ8D/ZtkP83wmIzYDIZM1iFG8emwj2P6gP9vcHt3K8/0FTvP8nOI56+eLf", + "XGk1R6MTlpqk0esBd5taZCTDOdxl4OBr0ZaY6YXEdA4prpXrziSgRyxPjEQeCAhFrm4x10qPf2xMT8dI", + "Qj7gxpT5+t4m2GUz0VUQRkNh7Y4GU28ymG56kqnNXtonmCUdhdlg72WCp0PIzYmaAoPABsJcTqoT7Sqs", + "PNdmfJ8ET490/eqsOktEzJKe7gizhhYyi0EGGjIwz/iDjvHRHvMrFhbrdYlMBmLQiaLZoKNVVyTlOcli", + "bNQlFnHJSS2IDnjehATRq1iC+N690dx/uOiTE5bqNs9EFkVn+qcgYtQgi1+ZnHWOlP+FwDuggdELRjQj", + "ZyKYUjHBOa5AmVldaluoR5VGxgGcm/XYBnGlzX3Ww9Qvq73HPFS3Lw/VXbSFNTPxAqyX9Vh7QYNLGf4R", + "3GQT4Cb1i61YkppXg7XSgMBjUQbN3GqNZQ+Aw9Vyo8P43pm6H0H2a08ffpGi5Vj1yRGGcg86aDYedIhM", + "9J5p3MEGHX/pNtHanTXNJzRlQwiXqzfO6+8EvpfM820vdebw85s+W9MEz+vWv9C1vSyy2piPiyxVIP60", + "Wdbi2CJAvqYpXVPqio0slT97qh86ZbHycbHUpb2NOEVTIxef9LnNoFc6NMspVYSSiItzFua3DUcXoXHs", + "S8ObSgm8niV8FSmuH8MJtrIO4Vi1TKxtsFnT2gjsRI55tObdothGC91r8JhrHBHBNQgQLHjR+zXGxuvd", + "CW+BNr+b2k1lgFOXrMy4xzRpTM8ExJtDbqoPzB4ylAMysT3jYltoPLPKA5GDK2kyL2VyPo5M3o9VyPzd", + "Vqyn1HZr24drOheTHJrPUtSkcd0EekR2HYc3K10r9YbO9RVvTUNLBZDG8dClD7iGuqp7LY3jXEFZYGfn", + "r1H+qOfDrMHQTvTKnGg112Lw4hKHOT50SMVaukxOKev13i1ooHILlexSZpQ/FsstUr458vJ1ln7petsp", + "pmGo77OrL7upt3hmTevOUG4nlnxyAEb0CkGS6y4IdtpcZ92OAU+frwJljTXwge+0OmP4eQGNZjTdxcTa", + "hh43n2tsPnHCZzSZD9nM2MxrUC2wCIEijRzmLcyxqfAG2qxDfVJ0woY2BGWl9PfWJGy6/aRbOvQaqvLb", + "exrHcOWVXpwnGA1ZaPJhGTd8pxZNcBKakQzsfOHxBGoVuq3bmZp3HodHtJ7SyfEP78AV+z6g2D3iz91L", + "/Ln642QbzLNcjNeX4LsgvHd0U9Pr1mArygXb5lQ1wfZoaEjoLLaIQr7HMzk02kVd8jSYmrQyyrwdpCZZ", + "bYjPoO6UimlryWFKIkYV4gpgM5C9EllvVSsVoMlZzVQM27cbcD7GTtXBKk7kMIFnxyETWhOGBYMAvm3V", + "GwXiRPawqh6Aqe3d00potMd5cdtT1XJQL4SG+mbZc4bxdcTPukO1uaTN8Pyg6oDF8GSh1zyOISURvFE5", + "BPpVV9aQdRjHpmnfEHlouvB7II646jI/ao8N7gkFRqhlytJB9ARPjbVABuabPr70lyacgkeKsaxbQibw", + "ZRggEYJIZiERNOUXNs2ry/qkp8XqJJNoCdNAHx6/Q0wgNRBzmQF4AuRhwbOv6hp0Inxjh1a70BoG27tl", + "KLyD5YTpkv+UQujBuqRXg2x//9m3xF01j991up0819N+f79/AG5iMRM05p1Xnef9fUgAFdN0CtzkuxUB", + "pp7+44SlDcisNIp8V3wEROJSvAs7rzoRV2nPtKK7sJD2jcfTvMie52bLpcAw+K/dynJDWL85mFkgfC8T", + "LrrVkpMsjmWiD1tlHACaMAvvwMMz+PeczfEHzZ/4U+62fkaeGG3+FL7kPuxnuplN4B2QHO5gIFbCO4AH", + "9DiCR1Cjm7mepT8MiADqgI7uuNPt5DkeF/qqOxACeAWYAxuOZTKrWQ0Tjbd0PTr1dI2ts1w7yjT/wU1N", + "HWu2UcbXziMzZCz+kLsM2v6BpZ/t71uoA5u9q5wr89WXlpQsCDcAJdPS+ftrt/MCqarrzFG/9yMN7dYM", + "VQ6WVyl7zL3Yf7680luZjADDBDS3ymYzmsyd4OMia91E9Qb+2dNNBlOVGFBVrdSvepm+EDkPH31WMj5U", + "JRMWiBqh4F2WPzUWFQvKY8/GjJgzxo8ynG9sTZGOgiHha3EDM8MocdXBZrmqjoHQPGF00h3kH7vEGN24", + "LgN97Vb3qr0v8O+78CsyVsTqUCNO5DjFmMHcgjEnPKzyGRZyfFbawUCHgY+uU2Gm+06ZT9rqNBMGUFVW", + "L+pyqULM5d1gAF3jxfIaNitZiWOqK3YNvVN7mPmJpUt4YcLS28AI+zelX+4nW3U7Lw5aDOUnKViJB3MO", + "uc6el9XwHvr/5Sl0mjgQz5o7YsLN77A1nnCtdtgbkwBnwXgUBF8QLLtuc/veo0kw5RewedefEw+xgCc1", + "5p5blRvT1oPS3uZe+hAOB44TCmywLcaMs1HE1bSZMY+xQBvGNG09Mub9ZEzHCVthzDheYpqDF8goYiHR", + "ZZusc7qZjdjmtspTcfzQzCu4LlVOOdQfTmuYYe8LjWNz822+4ogiWzRcc+K4nTbSHd5mXZS79dUqpDh+", + "CGoI1h1WtCU3Gbc0807XrGDycuDtigZ249/jnkQQvrhe+XgdbfF5wCPzmi8EgQxZ+QHAPBI8mv7B9N9m", + "rmGypM3K4dXQrDOP4SCHaAMyiuSlHqOXE/mVqfhZFz39O/qVbe5B4ciRs+tHBeuC+cA2voJOqCoso9Hx", + "gAR494JGdt9ZcmTKm94zbNN4iHevEFjQUjXXEgpybXSZeeFFbxfNqXOZJUReClNxIGxN3/mWxFkSS8VU", + "48sG1u45B+FtvnE4n2Loc0ePHc731KeljsuLJe7+K0iJwbbP9HtfbF/6OhtIlfZG1qVrwV4vVQq4AMp4", + "cOUS8VYmpVFwpiC0IGHWp9GFSgqvIcC/DPkYAhtScsbGY5aDvJ0BvFzTvcWju81JNR/ydY+rjTtfPq62", + "O19eYzQnY06d8pujA9LifdCiA3/WNSHy+fTvn05eb3ArlCr9UZPXZifs3r5Lo6Gfq3u9g17vblCS7Q1o", + "n6Xv+rY3XtEkjZuhkXV+07J+utVt17LnjndcS0btZms/3oN91rHdFrZYjG3xt9Da264tttXLrulkU95w", + "cL8t3Xk9d7jHm6+7+S6d+PLF11YYzSHapt2195zNT/8+m/fCUQ+AdTd27zXU7P7ai4Q8uGtvrhyq2smt", + "TufU22AX3Bxh9bd5ZSzG9e7qsmiGWntNNPGG9+SCiCkgFzJGw6ak73v4Y8UtrtbZzeuvzVnLNv3o8rbZ", + "kzkOtf3qd+tPHhOW3p4V3d+JBnggTzwrcIrxQit7lymW7JZZtuVjttZ2tRtmffQ5a/A5g2nZ6F64Z6zx", + "jbc2X3f2bOF7q0MR8KaZNX0AngemUt27jcl+sKZ+Df3z+S4Zatt6tgb0abcqdxXeftTAi7x+1xOJVdTx", + "Ho3jnkXvWkWSeq7iPRKpBvDK3YhTBR6t1qeqHifzUZraSBON4y1IFIJ37gVTFpzLLO0pA/rdwv/hs8Hd", + "PDJ1yQnWPX1iUyyEMlB97AEyLJiMAMp193QgasHosA9FaKVxxIKWUcQCALiwSQZmLJ3KsAi3mKCThRk/", + "2pHN+IybBuZTHXQUS7N40CEzGbKuATEynSjXBSa4UANxydOpJimY0mRiczW49eKzGQs5TVk0xy5NQyws", + "E+vyCViUoXGWZkkx56NdfpiWtzIhU6l0U3YG7YBUlyQs5AkLfEO/QdhyZudPv/1iEIzYbMTCkIVe/Uwh", + "JksQcSbSoWJBgjj+XPCU04j/yQzUav+/MG9zmSUD4amOJT4rLOkhM/TK7HY/1HLpZIFzZayiZsCGi3dr", + "HD2M44W0qSxKa49EUNxUrat0tyyqN6jTjc5sUJhb0eixTFIatdfnljarxo6hviUR1M8nxcYZZM93qqag", + "+Yy2aWgplRa+JJ0yngxEURuqLsGcH/i5Aq1JRUhoEGAyf10AwSkZmXKVymTeH4gPIpobXae0qqugRpdh", + "TLmyENKpJJQohyOte8u3jtZqrTjn91+p2fc4GPatVG31FLZScM1VH9VcKzXnxA7FgqhNajs4ey2PQrAv", + "fVgatJhNeedrhm+ULYIJ8GjC8jS3LCRUEcYBim0c0ZSMGYP8SYDM1MOUSLaLpnAGoyks3Zvy89iqSmnw", + "IzEztdCZYSVHkoLTSI+cGbCsoQHyA5dP+OAAs70Pt8XJw2Mxz5PDzNVobhO2LfPcPDPOHFj89LNkf5z+", + "3UxQFxMdn23QtwPpa+nGWRz4m6tYb8rjLIoIIrKh255Ldhq6tJIlljCJozxOSBiNhimfsSHI1NkrYloH", + "KQUiv9EcR6MepMaGUk1gUQyqFuZhFThAMydIQF2q3CJDbNXjBUh5dFJd4qRaUvPbd1Ut9bj8gNio9u/i", + "kdBeG/WQduzmAzTUHuXgy/1x8TGctj0H1dLxCpKqqT0a/jdTKRjtFuBt2ORseWkb3GGdNGf0nBFMS+mV", + "Unjvyk9hA2FaGtGIiqB8lMgU6wVUMWW2DQSED2Si76J4tKwXQ2i0l3d8r+QQBnfoxrZjiSxR03DNKpS5", + "5/epWoC7qsgsuxdtXriNkC1GBSAliaxFBcj3OZQ02/LNilm3Prs5niELo9AXOoA05goTAKR0FoOyMVkd", + "VZ6cAtICQ6m2/uSuxdZH8dc0ZR/5jNVeNzZw1P+JpSh0P+L4d+3JXVAWhibVrCpsiQcDyVAwTBQ49+a1", + "BGZcXWJoKSdnrTOBoGowzd24ZthIHI296/vDvQksYy/z/O6jMHJaHi+mSy6mPp9sRHJbQSP73fbJYeH3", + "3KypAIYsiiRygd4P44TFlIf2FF46nveXHK+h/ft3sgZOvw2HaiCkeZOEzw/yKF3m+V3tkXtfgnwllsJt", + "FcW0/li9O8FqeFrwx3cXHJjbC87DOVreQknZUyxNI6avwXs2DXWzvcl4yEH+KONDkNe37yxyrPc321g0", + "J+NMhCwsSp3xasCLIBNhLLkAlyc1F8E0kYL/Weon1T0X23YfL3k6HQjI8AvQZkRJfE5M2AUTmT4ZBnIi", + "OKIDCUeLyY3HI57OIR8vvDdexeA01oj17CuHnqWll0/EPVUY2/CmDYubvU1zfuLmcseu6u212AOCULV+", + "sv7h1olkRR/cvKZLEyoUBbt0u9uzX8Hhn3hOsdZxgQrCZ7MMCOsSUFMykhMe0Ag0TALp8EyjM3kB06Be", + "FRWgGgiTplxls/yvffLRpwL9IPLrrVZkiWKlTgFsYSBGcwvlsNgCUJiY22YHOMoSJZNVLQGFpbsxe4C/", + "VLfDKuBR1MougLP9cC0DJVG4IQ0FXhmoHXvoUtkOnaZXU/H+xDz6UCdv8oEewjgtEzfFtsCiljzK0FmH", + "jBlNs4ShByu6ruLcPRi3DI9tiGObKq97k151AzQ7i9pL6VUPsnwujM2VyYQK/if8sWfq9vKqW2SjD17P", + "5jHJ5BetfeBYUPyhXEn9tXJgUC6Zay2r2Fe69lbTBcGCLXhlW5eOBau/oyvHBtn3Xsf31V1Fts/IRZ2I", + "yWKXZXqYMAgYw8INJ3ObsrZnmlzVO3nFUzP20hYNzZQezYkyGXxbop+a4qefwYXWHmIONncMfwOUreU8", + "C57Uy+ahHRxfyqswfHbZc5fqVCY5LN/vUyaInPE0ZWHXkqEve8oh9UOzAKl3Rp7MpNKCHOgdfMwTlT7t", + "E2iDQg094ywKCVckTuQF19dMGyRJDfJfl3CE+FMeTl+fHMYxM26+Pk7gQKTSjNmW7RITKYpQgBZQ0Jbz", + "Gr1hj/BtHkrfmXUETrvHV6rq6dFl0XYqyWpPl9IaxW+lFLI4n2BDgXY1T41oGkyJHFs5yLWK5rajSGY4", + "/cpATTYGu6LQ1SjTdgcISCWOdf66GpfYGQEyYTIb2u3BWGtab+UfX+qm7Bhf6rbaCRXzD+PG7aSpl80Q", + "d9rqHPWsyjEfp8wyxpReMDJiTOS7KkQlJvqvJq5Q324gYMg8IMhMRfO7I3ooH6sIX+lMYm+7y1PD25IN", + "RxLX0BYRcd3V/Jo78GNa+GsGTy1fiOKR0JUfzZFXhzxseyq05U1o1SDb338e8BD+ZZs7G75FEndtl3Vk", + "PCjIXE95VO9cb+3HtXLPm6YbnaHM961i7JoR7MgpyfRexz3m090Pu8lXcUX+qd8N976Yn5aknzfIro7L", + "liSfz6lcboR3BDyi8W4FjXdtjlmUdX4ZH0xYeluYYP8m9csj8ELVjH4NBoz1rbA5+XyJCwnm2UqjOZEi", + "wpyOmeDpEPJooCXIhv/hWbfRh2l3vLsti/46W/ONis7D8xDa4l4OOdL28LLQ6K4IdyF8HNYCIseLTpHQ", + "lpULSG90L4QDZhsmwpOMG5CEI6lS020T6M9HuGYCUWRKFVFZEDAWaq11byUDWdKqdcNl15KOibxgiaAi", + "YO3EwfZtIL3Q3S3iKB85ZqO1kDjf3IQpGV0wRRgNpvlrAw+ZSPmYIwpZ7jgHBrokR/wZCNOh8RK26JOG", + "AVjoro5dEkeZZ4ophuENhO+0C2QOXzPFJwJNLiNGAsykLYUWd34FKnecMDUl8Mx3QSPrEWLsFHbVCFcD", + "ocuAu55tLJiysD9s0Bf57Df65az3grcldfCTo7esE25yt6xQ0WwWuZtKokbmc05Z5IqTz0zTw3Sc8Aua", + "spYv1VE0g71sT7eb8HCZfThmSU/vbCqmASNxwgNGXNUGg7Hto5f3Ub9zXt+298sv7/XGcqzpuqspMIH4", + "B2YW/OWX9+YM5rFIlft1Mb2+6xkIF/Fuo9Wwwrxbsh8azv1gekGib9qA6ItPLbPBnN15G2KF21ZntmVa", + "dO8L8Fdbq+JqrGmMjHWsufxCYuh6NDZuxdi4PdaCdVuyO08iOaJRTgTW6RMboIK/Yw5vx6oE9IU+qo8J", + "FfNlm7iho8Jqtc+HhoDNPd6ts8HXvC+bidhQulVz2Un69g8zGbJI/1Z6YS4lSy/9LZUP8t358fx1i85f", + "Tro3qbSKm+GCRxXrxlWih4zm5N3rXI1B3C98aNRkA1GryiasrMl2u2fu39jR7SEa0zRTFTnpuoxt2WTR", + "JoxlFvlzb9V1CmtswXGKTiYJmwABBU+qwyZHqsNHPyp3EFq2KkUvKlN6rRzjULd3zuabO3SBmOw8kBWo", + "eGD7slMXBS/PYkbxBmsHVG00a8DXrbpCAaU7coSCvuu4AhX+nTdg2NWrcEXdbrX3Bf5ta4po4Btjc7A9", + "Lz8zmU4f7QxbsTM0csBCpyWoZU7TtWfjW7C8+zelBR5IEO8CTjGxtw2+RQ2KwDgI7YZTtuUctPpmdWNs", + "+vDcgpo4tuXtLN/v2jk8WLU4lonJXgLY9iwlZ4dBwOL0FSkv7hl54t1anuoryAQNGGmSBWmWsJD84+TD", + "r/75vtBgyq7SvUBdnOmqobwUkaR4yFd0xiCbqL4aUXJ08i8CGdFUxmHgmsyBUHHCaKimjKUmfaYuGMgo", + "mwnV1bcLuP103ZXubJzIWZekskts9G33lHy23hhDHnada8bwnM2937QYd08JhmOEfMYE5K3r9/sYmdHF", + "rDH5Xc+0f2bo0Rc1hhGt6JZ4OWXCK8WVvQ3Bcn2jBuJsksgsHo7mw7y/MxxnOk0YI2eOuv+x3WCYrO0o", + "lRMGaaF0jwOBXXqjremW1Pfa4NhxX/Rfrf/Xjau/oidYt2PlQ1dmV3QWR9jxT3qFMAy64EiULxh0nG+A", + "y8t3O8C++masRSSVXV8oCjJRFAkw8nfTecy60MJAPNt/9ry3f9DbP/i4v/8K/vtPt/THA/jj/sFP3778", + "z99evjx8+/vhP39+c/Ds13/vH/3f929/7tJgxnpcBN3DYMbIOxH0u5M47b3opVkykl0u4iztHjyr9HZQ", + "19uzjfT2bL/S27O63p4Xe/vx+b//c/DP3w6///27f/3t+OTZ6+4kkiN21f0J/iFHMokLvcks1d290PvI", + "r5KAOPZG88bVbShTXdGV12e1+V1tfl7grueEw4TDqjThYvJouvV9otY+CcQRFS0iXaFYg6UWm9iioRY6", + "2NQTpLPXXrBElS20i2Ndb4mFdMl0bM6aeaw72rUxUxPxwGyZVqCqDzDHiQyzICVHNKWRnKzn3SXYJXTR", + "aPLUH7dq8dRruls4ek1BLQNFVNx9q6dZwPX4p2Z/2Pui/2ntoqXncHHUpyGwxXsy9PtoGt2KafRabLLQ", + "fLqIBSYs3f3679+oQnmM9axaW6/JfIstsov4z5hld8GC2zDKKpakK++nN8v+9xpFcX0pMNy6tc16j4bh", + "UuB2GoY9gElXSgYcjj3gKkYbjojuxtczrd+cCN1GD8iIikM9D49pxBYDKVs2G8vk2pq/PoFvGEIyMOgH", + "AyiX3nGQhe/+JpBfqoAXd3Szcv037QPw8SFl9wKedAy5bT2Pv8MkL7mp/cZm8oJ54jJO5KxRYLwr240L", + "TLexbTPOx5vhZlnWsobHF1u7JTr2s2cPrruEKPp6TrQ3x4fAhvs3rZcfSvK4epbb5m10ZT73bqj3lNW3", + "eRFe/Qx047L24NIKbEPqFh+JkmDKL1izR9MhFrC2IvMYWJVF09BDs1g+IF86ywk+H2yHKeNsFHE1bWbK", + "YyywlClNQ49MeW+Z0nLCNpgykWMeLQuQH+F6EFu6wRJoivVcoxtxA7kJRkOCH5hnQXlVa1nKzFCb0CnB", + "Lsttgk/wj6V+iF46ajxVFEtTLiZoDLS1TSbPNJGRIlxcSB6wgZgwYViuTw5FMTtRQAWmM5hlUcrjiFVG", + "R0I25oKFfXI4EKWPhCsScXGOYZFeQDWN4z75OOWqcFrhijCQKa6mLByIMEtsdo1Sw98oNHHZBMkJm1Eu", + "VJ7vtNEkWZKlrXpgFKVgx74YZrw1UlcscfcdM2olZokQ1mvvvS+8pTtGnXx+ENGcqCyYVmXGwN6GxuYF", + "yb9zNzoh00IYsqlmP8VcGPRAKjxH4kzpLtyvDoZAVwNHd5DjMRc00rNt5V812SKrkrL8CMQfbYXb8SKh", + "K/LzQseRMrPW2gBvy/Lv704TPhRr3cq8tdgvZCl7GdPbDjlsW6axa+z4O+TzhxfTR691PFDZyM3mkpTY", + "xaJbdN8vdLQpN37qoYOVPPbpgwYJqw0ZKCzBBiMETvx2dx0p4BPz6I+z2B+nLPxVDVNY2oItoPby6je4", + "pZur0Xk+YbsBf60hpI61/O/33O1FV/h+eYUjKcYRD9L6y3GJhZaz5IKtb++L/2sRT696oSj1vPysV2z8", + "DtwsVuLVB3K52Cq/tXK+1WcPLIcpVfw2GgzufpFVXHA3y7Hdtc+H9yWrtc8bjx7AK544iGPcpUK39Dmr", + "lRgW/+77SK7lnrZYTss7ygo+PBuX0iV93AH3tYqgLdu+Ht3ZkpW3tutKWUBFwKJmx4Yj+I6X7YLwkN95", + "FOnF0tdvLrRsBVMWZmAACcxxkfCxrpkwQhM2EBLgaopWBVPL3MdTmqSEjvVAIWcZ9I6zk/JZ3QsclLgV", + "58CbuTfheu3G+rfSWfR+GwCveW+CVdzyOTaYUjFZ4Eh3FEnFFKEkyYTQUlvc6EWI4qjM26cUkLVJJmAk", + "SyVmNLOv7+ap/8ik3lQsRLCxeJLQkKkuIIDZn3Xb4B+DJNa4qOCHByTWuFa7F2sk5P5lI7tpAYdp3LKA", + "Z8Junj1vo2wW+E+ufHU/97famse1+p4eDS6Pm1yzDOTs1shpa8hESq96gSwm8auxtuTFtvM+9k4EURZ6", + "3jb0ikB/dahObUwnHBscmgY7NfBpIykjRsXNmks+0qsjGT40d0u3nLUc+pFeNaWmbAx6rn17sVy6VY9B", + "s4K7dRU0RNQeKPDT3fcRtExzTZ5p0Hd7X1KcqEqMcK2nncdayzdp1/Kjp91WPO02xBnd5oew27Lc+ztQ", + "HA/EYrgxJjKedmX/OcWSnfLRtvzn1tn/dsHGj2BLDWBLMC2b2lx12yy5qE/p+YsMaNTpdrIk6rzqTNM0", + "frW3F+k/TqVKX32JZZJ+3aMx37t4DhjMCddtK7xzJ+bODS5pnVed77777jtY8Eq0IIZ+4Yv9BO9BeZfq", + "1d7eF/z71z6Nef9cisn0j34gZzXdmgYKHWf62MpENtOzhL9knW6H6v/NGDqRndYRls/oUSSzsEKWO5b0", + "A/3dzoSWX7MolQe5POU7u6BRhrZ8OXYxBYqkkgRTFpzraxNPyJjRNEtshvh+rm1qM8TXjMELNepF7IJF", + "zkswkGLMJ1nirByVll9jSdVpXDQSYLwemVFBJ0wh5mvX4iShcRNH4r3tqMrjTm9EFQuty2gtMeUIwSpN", + "LvNfSFOqGySYp5WLCREymZmojDjhgf4T5FzQhERUTDJ9UQOAd0VokEiliE3yqvoEs89CvgE1FwELEVLE", + "RWyxKxQ0omSWQEkREpqlsgeTnMxYiEkQ0imbEzpJGKsdo0tMWOMBiYygSMLihCkmIGjFrEFMRzziKWeK", + "jGhwjvj3uFt1TcpM6yoas6SXCZ7iTC3nAdtvDUkf3S1fT4z1Ig1oFGSRuQEwXGrH3rVdaH1Vbd3G3lnO", + "qolRU10SZEnCRMDhZz0ive6G72z4TQsSrB9ylYzDOFaECcjEMZeZHqFebb2+IjSt8j9ZIQAQkoqQS5mc", + "jyN5CWn9tCqe6GkWE1yQnGXmKmUzZBmtizGBM3QbUAFcNEP8jZAwMQXlMZdZHnLIAolt6H4UOh/Ds6PP", + "FhAkRRWw7zSRgv+piyChIAhAVDrlSdiLaZLOtSSnY5nM9MSaJYWnDr2oXWIjGs2IQxbxCwaxhHbWu2RK", + "RYjLReczzbCBjCIGmh4XCF9AbZBCwiKKxiN1Xr9KelJqluiNSHkaMd1FiRUxENMoT/2XsZWi5Szht1rn", + "El54t/V7TRManJuplWNcKyuqWu3hGveLlj0br8ZFyC94mNFI6cJ+pKjCIDZd0KjOEbOAXMg+EH5WHWzt", + "8Ip2xer4jtyOtM7Y8to3PS7Xc82YoASIzEWFV9qO7E1eNU6kJomFhFqxkpmK5loOtbayClhJ1PszOofo", + "Qj0dsxkLOU1ZNCf0gvLIZvrB3DTFPdCRjX03DUw5B/6pvITYRZO/ldnxlgOVqaDRPOWBInGWxFJpxWOa", + "Mstm9wcLp+l2PC83rB7nVIa4VJCeg4uJbsmWnRWbNIYtTYzLfwQEEkitgspWkziO2BUf2QbgTTZggiZc", + "qvLsqM7X06//PwAA//84ceA8L0cEAA==", } // GetSwagger returns the content of the embedded swagger specification file