From 1806a1f5279bd6c35b10aa21f09023e4a598ab1d Mon Sep 17 00:00:00 2001 From: Robert Boros Date: Fri, 10 Jul 2026 16:10:35 +0200 Subject: [PATCH 1/4] feat: invoice delete v3 endpoints --- .../packages/aip-client-javascript/README.md | 16 +- .../src/funcs/invoices.ts | 157 +++ .../src/models/operations/invoices.ts | 20 + .../src/models/schemas.ts | 48 + .../aip-client-javascript/src/sdk/internal.ts | 95 ++ .../aip-client-javascript/src/sdk/invoices.ts | 92 ++ .../packages/aip/src/invoices/operations.tsp | 85 ++ api/v3/api.gen.go | 1011 ++++++++++------- api/v3/client/README.md | 4 + api/v3/client/invoices.go | 117 ++ api/v3/handlers/billinginvoices/action.go | 100 ++ api/v3/handlers/billinginvoices/convert.go | 28 +- api/v3/handlers/billinginvoices/handler.go | 1 + api/v3/openapi.yaml | 153 +++ api/v3/server/routes.go | 21 + e2e/billinginvoices_v3_test.go | 742 +++++++++++- openmeter/billing/service/invoice.go | 4 +- 17 files changed, 2244 insertions(+), 450 deletions(-) create mode 100644 api/spec/packages/aip-client-javascript/src/sdk/invoices.ts create mode 100644 api/v3/handlers/billinginvoices/action.go diff --git a/api/spec/packages/aip-client-javascript/README.md b/api/spec/packages/aip-client-javascript/README.md index ceb1b5f796..1faa1531b3 100644 --- a/api/spec/packages/aip-client-javascript/README.md +++ b/api/spec/packages/aip-client-javascript/README.md @@ -425,12 +425,16 @@ they can change or be removed without notice or semver consideration. ### Internal Invoices -| Method | HTTP | Description | -| --------------------------------- | ------------------------------------------------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -| `client.internal.invoices.list` | `GET /openmeter/billing/invoices` | List billing invoices. Returns a page of invoices. Gathering invoices are never included. Use `filter` to narrow by status, customer, dates, or service period start. Use `sort` to control ordering. | -| `client.internal.invoices.get` | `GET /openmeter/billing/invoices/{invoiceId}` | Get a billing invoice by ID. Returns the full invoice resource including line items, status details, totals, and workflow configuration snapshot. | -| `client.internal.invoices.update` | `PUT /openmeter/billing/invoices/{invoiceId}` | Update a billing invoice. Only the mutable fields of the invoice can be edited: description, labels, supplier, customer, workflow settings, and top-level lines. Top-level lines are matched by `id`; lines without an `id` are created, and existing lines omitted from `lines` are deleted. Detailed (child) lines are always computed and cannot be edited directly. Only invoices in draft status can be updated. | -| `client.internal.invoices.delete` | `DELETE /openmeter/billing/invoices/{invoiceId}` | Delete a billing invoice. Only standard invoices in draft status can be deleted. Deleting an invoice will also delete all associated line items and workflow configuration. | +| Method | HTTP | Description | +| --------------------------------------------- | ------------------------------------------------------------------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | +| `client.internal.invoices.list` | `GET /openmeter/billing/invoices` | List billing invoices. Returns a page of invoices. Gathering invoices are never included. Use `filter` to narrow by status, customer, dates, or service period start. Use `sort` to control ordering. | +| `client.internal.invoices.get` | `GET /openmeter/billing/invoices/{invoiceId}` | Get a billing invoice by ID. Returns the full invoice resource including line items, status details, totals, and workflow configuration snapshot. | +| `client.internal.invoices.update` | `PUT /openmeter/billing/invoices/{invoiceId}` | Update a billing invoice. Only the mutable fields of the invoice can be edited: description, labels, supplier, customer, workflow settings, and top-level lines. Top-level lines are matched by `id`; lines without an `id` are created, and existing lines omitted from `lines` are deleted. Detailed (child) lines are always computed and cannot be edited directly. Only invoices in draft status can be updated. | +| `client.internal.invoices.delete` | `DELETE /openmeter/billing/invoices/{invoiceId}` | Delete a billing invoice. Only standard invoices in draft status can be deleted. Deleting an invoice will also delete all associated line items and workflow configuration. | +| `client.internal.invoices.advance` | `POST /openmeter/billing/invoices/{invoiceId}/advance` | Advance a billing invoice. Advances the invoice to the next workflow state. The next state is determined by the invoice's current status and workflow configuration. Only invoices in draft or issued status can be advanced. | +| `client.internal.invoices.approve` | `POST /openmeter/billing/invoices/{invoiceId}/approve` | Approve a billing invoice. This call instantly sends the invoice to the customer using the configured billing profile app. This call is valid in two invoice statuses: - draft: the invoice will be sent to the customer, the invoice state becomes issued - manual_approval_needed: the invoice will be sent to the customer, the invoice state becomes issued | +| `client.internal.invoices.retry` | `POST /openmeter/billing/invoices/{invoiceId}/retry` | Retry sending a billing invoice. Retry advancing the invoice after a failed attempt. The action can be called when the invoice's statusDetails' actions field contain the "retry" action. | +| `client.internal.invoices.snapshotQuantities` | `POST /openmeter/billing/invoices/{invoiceId}/snapshot-quantities` | Snapshot quantities for usage-based line items. This call will snapshot the quantities for all usage based line items in the invoice. This call is only valid in draft.waiting_for_collection status, where the collection period can be skipped using this action. | ### Internal Currencies diff --git a/api/spec/packages/aip-client-javascript/src/funcs/invoices.ts b/api/spec/packages/aip-client-javascript/src/funcs/invoices.ts index 81c415d882..b158836cd0 100644 --- a/api/spec/packages/aip-client-javascript/src/funcs/invoices.ts +++ b/api/spec/packages/aip-client-javascript/src/funcs/invoices.ts @@ -15,6 +15,14 @@ import type { UpdateInvoiceResponse, DeleteInvoiceRequest, DeleteInvoiceResponse, + AdvanceInvoiceRequest, + AdvanceInvoiceResponse, + ApproveInvoiceRequest, + ApproveInvoiceResponse, + RetryInvoiceRequest, + RetryInvoiceResponse, + SnapshotQuantitiesInvoiceRequest, + SnapshotQuantitiesInvoiceResponse, } from '../models/operations/invoices.js' /** @@ -158,3 +166,152 @@ export function deleteInvoice( await http(client).delete(path, options) }) } + +/** + * Advance billing invoice's next status + * + * Advance a billing invoice. + * + * Advances the invoice to the next workflow state. The next state is determined by + * the invoice's current status and workflow configuration. Only invoices in draft + * or issued status can be advanced. + * + * POST /openmeter/billing/invoices/{invoiceId}/advance + */ +export function advanceInvoice( + client: Client, + req: AdvanceInvoiceRequest, + options?: RequestOptions, +): Promise> { + return request(() => { + const path = `openmeter/billing/invoices/${(() => { + if (req.invoiceId === undefined) { + throw new Error('missing path parameter: invoiceId') + } + return encodeURIComponent(String(req.invoiceId)) + })()}/advance` + return http(client) + .post(path, options) + .json() + .then((data) => { + if (client._options.validate) { + assertValid(schemas.advanceInvoiceResponseWire, data) + } + return fromWire(data, schemas.advanceInvoiceResponse) + }) + }) +} + +/** + * Send the invoice to the customer + * + * Approve a billing invoice. + * + * This call instantly sends the invoice to the customer using the configured + * billing profile app. + * + * This call is valid in two invoice statuses: + * + * - draft: the invoice will be sent to the customer, the invoice state becomes + * issued + * - manual_approval_needed: the invoice will be sent to the customer, the invoice + * state becomes issued + * + * POST /openmeter/billing/invoices/{invoiceId}/approve + */ +export function approveInvoice( + client: Client, + req: ApproveInvoiceRequest, + options?: RequestOptions, +): Promise> { + return request(() => { + const path = `openmeter/billing/invoices/${(() => { + if (req.invoiceId === undefined) { + throw new Error('missing path parameter: invoiceId') + } + return encodeURIComponent(String(req.invoiceId)) + })()}/approve` + return http(client) + .post(path, options) + .json() + .then((data) => { + if (client._options.validate) { + assertValid(schemas.approveInvoiceResponseWire, data) + } + return fromWire(data, schemas.approveInvoiceResponse) + }) + }) +} + +/** + * Retry advancing the invoice after a failed attempt + * + * Retry sending a billing invoice. + * + * Retry advancing the invoice after a failed attempt. + * + * The action can be called when the invoice's statusDetails' actions field contain + * the "retry" action. + * + * POST /openmeter/billing/invoices/{invoiceId}/retry + */ +export function retryInvoice( + client: Client, + req: RetryInvoiceRequest, + options?: RequestOptions, +): Promise> { + return request(() => { + const path = `openmeter/billing/invoices/${(() => { + if (req.invoiceId === undefined) { + throw new Error('missing path parameter: invoiceId') + } + return encodeURIComponent(String(req.invoiceId)) + })()}/retry` + return http(client) + .post(path, options) + .json() + .then((data) => { + if (client._options.validate) { + assertValid(schemas.retryInvoiceResponseWire, data) + } + return fromWire(data, schemas.retryInvoiceResponse) + }) + }) +} + +/** + * Snapshot quantities for usage based line items + * + * Snapshot quantities for usage-based line items. + * + * This call will snapshot the quantities for all usage based line items in the + * invoice. + * + * This call is only valid in draft.waiting_for_collection status, where the + * collection period can be skipped using this action. + * + * POST /openmeter/billing/invoices/{invoiceId}/snapshot-quantities + */ +export function snapshotQuantitiesInvoice( + client: Client, + req: SnapshotQuantitiesInvoiceRequest, + options?: RequestOptions, +): Promise> { + return request(() => { + const path = `openmeter/billing/invoices/${(() => { + if (req.invoiceId === undefined) { + throw new Error('missing path parameter: invoiceId') + } + return encodeURIComponent(String(req.invoiceId)) + })()}/snapshot-quantities` + return http(client) + .post(path, options) + .json() + .then((data) => { + if (client._options.validate) { + assertValid(schemas.snapshotQuantitiesInvoiceResponseWire, data) + } + return fromWire(data, schemas.snapshotQuantitiesInvoiceResponse) + }) + }) +} diff --git a/api/spec/packages/aip-client-javascript/src/models/operations/invoices.ts b/api/spec/packages/aip-client-javascript/src/models/operations/invoices.ts index d0f9d05104..c592ff2a97 100644 --- a/api/spec/packages/aip-client-javascript/src/models/operations/invoices.ts +++ b/api/spec/packages/aip-client-javascript/src/models/operations/invoices.ts @@ -55,3 +55,23 @@ export type DeleteInvoiceRequest = { invoiceId: string } export type DeleteInvoiceResponse = void + +export type AdvanceInvoiceRequest = { + invoiceId: string +} +export type AdvanceInvoiceResponse = Invoice + +export type ApproveInvoiceRequest = { + invoiceId: string +} +export type ApproveInvoiceResponse = Invoice + +export type RetryInvoiceRequest = { + invoiceId: string +} +export type RetryInvoiceResponse = Invoice + +export type SnapshotQuantitiesInvoiceRequest = { + invoiceId: string +} +export type SnapshotQuantitiesInvoiceResponse = Invoice 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 ee0e8114ab..8b7655b9bf 100644 --- a/api/spec/packages/aip-client-javascript/src/models/schemas.ts +++ b/api/spec/packages/aip-client-javascript/src/models/schemas.ts @@ -6149,6 +6149,30 @@ export const deleteInvoicePathParams = z.object({ invoiceId: ulid, }) +export const advanceInvoicePathParams = z.object({ + invoiceId: ulid, +}) + +export const advanceInvoiceResponse = invoice + +export const approveInvoicePathParams = z.object({ + invoiceId: ulid, +}) + +export const approveInvoiceResponse = invoice + +export const retryInvoicePathParams = z.object({ + invoiceId: ulid, +}) + +export const retryInvoiceResponse = invoice + +export const snapshotQuantitiesInvoicePathParams = z.object({ + invoiceId: ulid, +}) + +export const snapshotQuantitiesInvoiceResponse = invoice + export const createTaxCodeBody = createTaxCodeRequest export const createTaxCodeResponse = taxCode @@ -12711,6 +12735,30 @@ export const deleteInvoicePathParamsWire = z.object({ invoiceId: ulidWire, }) +export const advanceInvoicePathParamsWire = z.object({ + invoiceId: ulidWire, +}) + +export const advanceInvoiceResponseWire = invoiceWire + +export const approveInvoicePathParamsWire = z.object({ + invoiceId: ulidWire, +}) + +export const approveInvoiceResponseWire = invoiceWire + +export const retryInvoicePathParamsWire = z.object({ + invoiceId: ulidWire, +}) + +export const retryInvoiceResponseWire = invoiceWire + +export const snapshotQuantitiesInvoicePathParamsWire = z.object({ + invoiceId: ulidWire, +}) + +export const snapshotQuantitiesInvoiceResponseWire = invoiceWire + export const createTaxCodeBodyWire = createTaxCodeRequestWire export const createTaxCodeResponseWire = taxCodeWire diff --git a/api/spec/packages/aip-client-javascript/src/sdk/internal.ts b/api/spec/packages/aip-client-javascript/src/sdk/internal.ts index d0468b85d6..50956af3b8 100644 --- a/api/spec/packages/aip-client-javascript/src/sdk/internal.ts +++ b/api/spec/packages/aip-client-javascript/src/sdk/internal.ts @@ -9,6 +9,10 @@ import { getInvoice, updateInvoice, deleteInvoice, + advanceInvoice, + approveInvoice, + retryInvoice, + snapshotQuantitiesInvoice, } from '../funcs/invoices.js' import { listCurrencies, @@ -30,6 +34,14 @@ import type { UpdateInvoiceResponse, DeleteInvoiceRequest, DeleteInvoiceResponse, + AdvanceInvoiceRequest, + AdvanceInvoiceResponse, + ApproveInvoiceRequest, + ApproveInvoiceResponse, + RetryInvoiceRequest, + RetryInvoiceResponse, + SnapshotQuantitiesInvoiceRequest, + SnapshotQuantitiesInvoiceResponse, } from '../models/operations/invoices.js' import type { ListCurrenciesRequest, @@ -192,6 +204,89 @@ export class InternalInvoices { ): Promise { return unwrap(await deleteInvoice(this._client, request, options)) } + + /** + * Advance billing invoice's next status + * + * Advance a billing invoice. + * + * Advances the invoice to the next workflow state. The next state is determined by + * the invoice's current status and workflow configuration. Only invoices in draft + * or issued status can be advanced. + * + * POST /openmeter/billing/invoices/{invoiceId}/advance + */ + async advance( + request: AdvanceInvoiceRequest, + options?: RequestOptions, + ): Promise { + return unwrap(await advanceInvoice(this._client, request, options)) + } + + /** + * Send the invoice to the customer + * + * Approve a billing invoice. + * + * This call instantly sends the invoice to the customer using the configured + * billing profile app. + * + * This call is valid in two invoice statuses: + * + * - draft: the invoice will be sent to the customer, the invoice state becomes + * issued + * - manual_approval_needed: the invoice will be sent to the customer, the invoice + * state becomes issued + * + * POST /openmeter/billing/invoices/{invoiceId}/approve + */ + async approve( + request: ApproveInvoiceRequest, + options?: RequestOptions, + ): Promise { + return unwrap(await approveInvoice(this._client, request, options)) + } + + /** + * Retry advancing the invoice after a failed attempt + * + * Retry sending a billing invoice. + * + * Retry advancing the invoice after a failed attempt. + * + * The action can be called when the invoice's statusDetails' actions field contain + * the "retry" action. + * + * POST /openmeter/billing/invoices/{invoiceId}/retry + */ + async retry( + request: RetryInvoiceRequest, + options?: RequestOptions, + ): Promise { + return unwrap(await retryInvoice(this._client, request, options)) + } + + /** + * Snapshot quantities for usage based line items + * + * Snapshot quantities for usage-based line items. + * + * This call will snapshot the quantities for all usage based line items in the + * invoice. + * + * This call is only valid in draft.waiting_for_collection status, where the + * collection period can be skipped using this action. + * + * POST /openmeter/billing/invoices/{invoiceId}/snapshot-quantities + */ + async snapshotQuantities( + request: SnapshotQuantitiesInvoiceRequest, + options?: RequestOptions, + ): Promise { + return unwrap( + await snapshotQuantitiesInvoice(this._client, request, options), + ) + } } export class InternalCurrencies { diff --git a/api/spec/packages/aip-client-javascript/src/sdk/invoices.ts b/api/spec/packages/aip-client-javascript/src/sdk/invoices.ts new file mode 100644 index 0000000000..598c815bad --- /dev/null +++ b/api/spec/packages/aip-client-javascript/src/sdk/invoices.ts @@ -0,0 +1,92 @@ +import { type Client } from '../core.js' +import { unwrap, type RequestOptions } from '../lib/types.js' +import { + listInvoices, + getInvoice, + updateInvoice, + deleteInvoice, + advanceInvoice, + approveInvoice, + retryInvoice, + snapshotQuantitiesInvoice, +} from '../funcs/invoices.js' +import type { + ListInvoicesRequest, + ListInvoicesResponse, + GetInvoiceRequest, + GetInvoiceResponse, + UpdateInvoiceRequest, + UpdateInvoiceResponse, + DeleteInvoiceRequest, + DeleteInvoiceResponse, + AdvanceInvoiceRequest, + AdvanceInvoiceResponse, + ApproveInvoiceRequest, + ApproveInvoiceResponse, + RetryInvoiceRequest, + RetryInvoiceResponse, + SnapshotQuantitiesInvoiceRequest, + SnapshotQuantitiesInvoiceResponse, +} from '../models/operations/invoices.js' + +export class Invoices { + constructor(private readonly _client: Client) {} + + async list( + request?: ListInvoicesRequest, + options?: RequestOptions, + ): Promise { + return unwrap(await listInvoices(this._client, request, options)) + } + + async get( + request: GetInvoiceRequest, + options?: RequestOptions, + ): Promise { + return unwrap(await getInvoice(this._client, request, options)) + } + + async update( + request: UpdateInvoiceRequest, + options?: RequestOptions, + ): Promise { + return unwrap(await updateInvoice(this._client, request, options)) + } + + async delete( + request: DeleteInvoiceRequest, + options?: RequestOptions, + ): Promise { + return unwrap(await deleteInvoice(this._client, request, options)) + } + + async advance( + request: AdvanceInvoiceRequest, + options?: RequestOptions, + ): Promise { + return unwrap(await advanceInvoice(this._client, request, options)) + } + + async approve( + request: ApproveInvoiceRequest, + options?: RequestOptions, + ): Promise { + return unwrap(await approveInvoice(this._client, request, options)) + } + + async retry( + request: RetryInvoiceRequest, + options?: RequestOptions, + ): Promise { + return unwrap(await retryInvoice(this._client, request, options)) + } + + async snapshotQuantities( + request: SnapshotQuantitiesInvoiceRequest, + options?: RequestOptions, + ): Promise { + return unwrap( + await snapshotQuantitiesInvoice(this._client, request, options), + ) + } +} diff --git a/api/spec/packages/aip/src/invoices/operations.tsp b/api/spec/packages/aip/src/invoices/operations.tsp index 494a58fee2..d61b0158c6 100644 --- a/api/spec/packages/aip/src/invoices/operations.tsp +++ b/api/spec/packages/aip/src/invoices/operations.tsp @@ -151,4 +151,89 @@ interface InvoicesOperations { | Shared.DeleteResponse | Common.NotFound | Common.ErrorResponses; + + /** + * Advance a billing invoice. + * + * Advances the invoice to the next workflow state. The next state is determined by + * the invoice's current status and workflow configuration. Only invoices in draft + * or issued status can be advanced. + */ + @post + @route("/{invoiceId}/advance") + @operationId("advance-invoice") + @summary("Advance billing invoice's next status") + @extension(Shared.UnstableExtension, true) + @extension(Shared.InternalExtension, true) + @extension(Shared.PrivateExtension, true) + advance(@path invoiceId: Shared.ULID): + | Shared.GetResponse + | Common.NotFound + | Common.ErrorResponses; + + /** + * Approve a billing invoice. + * + * This call instantly sends the invoice to the customer using the configured + * billing profile app. + * + * This call is valid in two invoice statuses: + * + * - draft: the invoice will be sent to the customer, the invoice state becomes + * issued + * - manual_approval_needed: the invoice will be sent to the customer, the invoice + * state becomes issued + */ + @post + @route("/{invoiceId}/approve") + @operationId("approve-invoice") + @summary("Send the invoice to the customer") + @extension(Shared.UnstableExtension, true) + @extension(Shared.InternalExtension, true) + @extension(Shared.PrivateExtension, true) + approve(@path invoiceId: Shared.ULID): + | Shared.GetResponse + | Common.NotFound + | Common.ErrorResponses; + + /** + * Retry sending a billing invoice. + * + * Retry advancing the invoice after a failed attempt. + * + * The action can be called when the invoice's statusDetails' actions field contain + * the "retry" action. + */ + @post + @route("/{invoiceId}/retry") + @operationId("retry-invoice") + @summary("Retry advancing the invoice after a failed attempt") + @extension(Shared.UnstableExtension, true) + @extension(Shared.InternalExtension, true) + @extension(Shared.PrivateExtension, true) + retry(@path invoiceId: Shared.ULID): + | Shared.GetResponse + | Common.NotFound + | Common.ErrorResponses; + + /** + * Snapshot quantities for usage-based line items. + * + * This call will snapshot the quantities for all usage based line items in the + * invoice. + * + * This call is only valid in draft.waiting_for_collection status, where the + * collection period can be skipped using this action. + */ + @post + @route("/{invoiceId}/snapshot-quantities") + @operationId("snapshot-quantities-invoice") + @summary("Snapshot quantities for usage based line items") + @extension(Shared.UnstableExtension, true) + @extension(Shared.InternalExtension, true) + @extension(Shared.PrivateExtension, true) + snapshotQuantities(@path invoiceId: Shared.ULID): + | Shared.GetResponse + | Common.NotFound + | Common.ErrorResponses; } diff --git a/api/v3/api.gen.go b/api/v3/api.gen.go index 874ad23a8b..41bf9bd609 100644 --- a/api/v3/api.gen.go +++ b/api/v3/api.gen.go @@ -9572,6 +9572,18 @@ type ServerInterface interface { // Update a billing invoice // (PUT /openmeter/billing/invoices/{invoiceId}) UpdateInvoice(w http.ResponseWriter, r *http.Request, invoiceId ULID) + // Advance billing invoice's next status + // (POST /openmeter/billing/invoices/{invoiceId}/advance) + AdvanceInvoice(w http.ResponseWriter, r *http.Request, invoiceId ULID) + // Send the invoice to the customer + // (POST /openmeter/billing/invoices/{invoiceId}/approve) + ApproveInvoice(w http.ResponseWriter, r *http.Request, invoiceId ULID) + // Retry advancing the invoice after a failed attempt + // (POST /openmeter/billing/invoices/{invoiceId}/retry) + RetryInvoice(w http.ResponseWriter, r *http.Request, invoiceId ULID) + // Snapshot quantities for usage based line items + // (POST /openmeter/billing/invoices/{invoiceId}/snapshot-quantities) + SnapshotQuantitiesInvoice(w http.ResponseWriter, r *http.Request, invoiceId ULID) // List currencies // (GET /openmeter/currencies) ListCurrencies(w http.ResponseWriter, r *http.Request, params ListCurrenciesParams) @@ -9890,6 +9902,30 @@ func (_ Unimplemented) UpdateInvoice(w http.ResponseWriter, r *http.Request, inv w.WriteHeader(http.StatusNotImplemented) } +// Advance billing invoice's next status +// (POST /openmeter/billing/invoices/{invoiceId}/advance) +func (_ Unimplemented) AdvanceInvoice(w http.ResponseWriter, r *http.Request, invoiceId ULID) { + w.WriteHeader(http.StatusNotImplemented) +} + +// Send the invoice to the customer +// (POST /openmeter/billing/invoices/{invoiceId}/approve) +func (_ Unimplemented) ApproveInvoice(w http.ResponseWriter, r *http.Request, invoiceId ULID) { + w.WriteHeader(http.StatusNotImplemented) +} + +// Retry advancing the invoice after a failed attempt +// (POST /openmeter/billing/invoices/{invoiceId}/retry) +func (_ Unimplemented) RetryInvoice(w http.ResponseWriter, r *http.Request, invoiceId ULID) { + w.WriteHeader(http.StatusNotImplemented) +} + +// Snapshot quantities for usage based line items +// (POST /openmeter/billing/invoices/{invoiceId}/snapshot-quantities) +func (_ Unimplemented) SnapshotQuantitiesInvoice(w http.ResponseWriter, r *http.Request, invoiceId ULID) { + w.WriteHeader(http.StatusNotImplemented) +} + // List currencies // (GET /openmeter/currencies) func (_ Unimplemented) ListCurrencies(w http.ResponseWriter, r *http.Request, params ListCurrenciesParams) { @@ -10719,6 +10755,106 @@ func (siw *ServerInterfaceWrapper) UpdateInvoice(w http.ResponseWriter, r *http. handler.ServeHTTP(w, r) } +// AdvanceInvoice operation middleware +func (siw *ServerInterfaceWrapper) AdvanceInvoice(w http.ResponseWriter, r *http.Request) { + + var err error + + // ------------- Path parameter "invoiceId" ------------- + var invoiceId ULID + + err = runtime.BindStyledParameterWithOptions("simple", "invoiceId", chi.URLParam(r, "invoiceId"), &invoiceId, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true, Type: "string", Format: ""}) + if err != nil { + siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "invoiceId", Err: err}) + return + } + + handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + siw.Handler.AdvanceInvoice(w, r, invoiceId) + })) + + for i := len(siw.HandlerMiddlewares) - 1; i >= 0; i-- { + handler = siw.HandlerMiddlewares[i](handler) + } + + handler.ServeHTTP(w, r) +} + +// ApproveInvoice operation middleware +func (siw *ServerInterfaceWrapper) ApproveInvoice(w http.ResponseWriter, r *http.Request) { + + var err error + + // ------------- Path parameter "invoiceId" ------------- + var invoiceId ULID + + err = runtime.BindStyledParameterWithOptions("simple", "invoiceId", chi.URLParam(r, "invoiceId"), &invoiceId, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true, Type: "string", Format: ""}) + if err != nil { + siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "invoiceId", Err: err}) + return + } + + handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + siw.Handler.ApproveInvoice(w, r, invoiceId) + })) + + for i := len(siw.HandlerMiddlewares) - 1; i >= 0; i-- { + handler = siw.HandlerMiddlewares[i](handler) + } + + handler.ServeHTTP(w, r) +} + +// RetryInvoice operation middleware +func (siw *ServerInterfaceWrapper) RetryInvoice(w http.ResponseWriter, r *http.Request) { + + var err error + + // ------------- Path parameter "invoiceId" ------------- + var invoiceId ULID + + err = runtime.BindStyledParameterWithOptions("simple", "invoiceId", chi.URLParam(r, "invoiceId"), &invoiceId, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true, Type: "string", Format: ""}) + if err != nil { + siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "invoiceId", Err: err}) + return + } + + handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + siw.Handler.RetryInvoice(w, r, invoiceId) + })) + + for i := len(siw.HandlerMiddlewares) - 1; i >= 0; i-- { + handler = siw.HandlerMiddlewares[i](handler) + } + + handler.ServeHTTP(w, r) +} + +// SnapshotQuantitiesInvoice operation middleware +func (siw *ServerInterfaceWrapper) SnapshotQuantitiesInvoice(w http.ResponseWriter, r *http.Request) { + + var err error + + // ------------- Path parameter "invoiceId" ------------- + var invoiceId ULID + + err = runtime.BindStyledParameterWithOptions("simple", "invoiceId", chi.URLParam(r, "invoiceId"), &invoiceId, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true, Type: "string", Format: ""}) + if err != nil { + siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "invoiceId", Err: err}) + return + } + + handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + siw.Handler.SnapshotQuantitiesInvoice(w, r, invoiceId) + })) + + for i := len(siw.HandlerMiddlewares) - 1; i >= 0; i-- { + handler = siw.HandlerMiddlewares[i](handler) + } + + handler.ServeHTTP(w, r) +} + // ListCurrencies operation middleware func (siw *ServerInterfaceWrapper) ListCurrencies(w http.ResponseWriter, r *http.Request) { @@ -13061,6 +13197,18 @@ func HandlerWithOptions(si ServerInterface, options ChiServerOptions) http.Handl r.Group(func(r chi.Router) { r.Put(options.BaseURL+"/openmeter/billing/invoices/{invoiceId}", wrapper.UpdateInvoice) }) + r.Group(func(r chi.Router) { + r.Post(options.BaseURL+"/openmeter/billing/invoices/{invoiceId}/advance", wrapper.AdvanceInvoice) + }) + r.Group(func(r chi.Router) { + r.Post(options.BaseURL+"/openmeter/billing/invoices/{invoiceId}/approve", wrapper.ApproveInvoice) + }) + r.Group(func(r chi.Router) { + r.Post(options.BaseURL+"/openmeter/billing/invoices/{invoiceId}/retry", wrapper.RetryInvoice) + }) + r.Group(func(r chi.Router) { + r.Post(options.BaseURL+"/openmeter/billing/invoices/{invoiceId}/snapshot-quantities", wrapper.SnapshotQuantitiesInvoice) + }) r.Group(func(r chi.Router) { r.Get(options.BaseURL+"/openmeter/currencies", wrapper.ListCurrencies) }) @@ -13740,434 +13888,441 @@ var swaggerSpec = []string{ "757Li5bHshOo1qfDYpXrk7kYCvMMFivGwsrbF7ZyX6t+JKjeC6+8L3rKGFcaftCyqLWVyMc7Ix2sfNnW", "MQPi3Lrq7UvVoDrdr3zaKRjukl4DsbURgua8bRVG+sIn/Bl1Pc9uiXk6KRW9YotLqrozNMLx0PXjO/O1", "m+Ku+RM90O0KddgB2IdIu6VOWb/3pNqTjyzOYcYfApKHahuPsvtvWHZ3nL5PbH/VJbKXrcv0kOL7o7T+", - "KK2PlNYLnrD9xPROGZcnrE+ihaGP8uuj/NqSX0Px5vcnwob03z3MHqn0/2fvfXTbyLG9wVfhCgN08l1J", - "tpN0T3cGg4HbSbpzO+l42sk07rQCma6iJF6XyOpilW11I8CHfYVdYF9i32Lf5D7JgueQLFYVS1LJku3E", - "BgbTsaqKfw8PDw/P+f1sFMBmRo77fKVt4xbTeGuxPuuCzcPNiG4cMGiUMdwAiXEGredqJFwLA7SCPHfM", - "gaVW8NjKQIvaNxTL4UbzVMjLU0cJB2F9GDPphmJLMUOdB6IQOU/WHYnKKFgu1IRiFhUV5LQ6tafN4RsJ", - "nrso0nL8sBWqSFmmHA3OhNO8IwD2GnamLrUWpFACSdm+D+0d67YQvKBouJR1lZkmNCm1y36bNixZswAw", - "eBj/d6EADHHDpVsrZc27kG2MzQ8ZFUDdB01wCJobHTI2iFExK2FaaYUaPtyNbmwAhvcybxMzsrNKpkEw", - "XvFEN6LrzR5+Va40lC2Y5EC8KW6SgTiKN3zO80YJJXMTj+wBShlF5/6GCDKXJmzCuiul+CnImL69sF9X", - "Yst+63GRFvkYkeh6/Z4scu/vj2uGc9QYahpRG6vn4rjIog0oGu1nIFup5zpXlcUX0DEXlCf0jCc8X4xT", - "mfBNVAEqNq+kYyyomhYqxdjyLbXngyITvwOMjuScEdNGk8IVSaGKeeqQGH0cl1OvjtPhTpwoRzWllrqR", - "L5VqyjLAWBzr/WgMW92mWtwO3sFwvxeyBY0RkbLMLh9APnRwazYTI9hWQ5ByGmgvUEHsD7/ex1AJf9/Q", - "T/5ysL8/3N9HphMEF7YJn/rp1/ohUMYZkCtrxUxB3o0ds2/pfqvmENnv6/aPxOkEcbNMvtffAVHLJdnU", - "5/5guD8M8Byb6V9LEV5nX/8B9c1nuaWbgfhidvTSPt6x18nfalBZeeZ2Q0JLezTHU4FeWrpYPKRcpTxj", - "qsyVXa/VJjf1xfILzNg6BOpptZUumCY00SrZBcvwKRdTc2pwNsMaktW0NcCT6a/uDXedVwYP0WSENjr/", - "yqIhYiJzdTPsGqFrWWGWR+q+jtk8lTmsk3O2CBpIJfOgVRWOHqg8/WWsUBavBaC8dWnIZK4IFeTH9++P", - "ybP974jNqrC6kcgJ2EHU5InFBQZAmo47hDN6zup+BEUUnTCDDZsthp+1h1RmPF9UsgoPGhC5LzJ6OQA8", - "SPtBVUjIG3nJMpu/CVl5Mz6dscy9P/RTxbnID77Bxmr9pWvc34e2mj9DkLapb/R10dgBuzEQeIFOCRMh", - "RMyyK6MK8eZDkUfVBWlBfhHI8vFwU79lo6ndPJh29eBsaDkBBG3jpDPsWZY/6dT1Dvug+oEsZMfENBJ2", - "rWl5Z0IBTL7MMhblJGMXTIBPMZJTwRF2HxnyK44qLwq4dvaoMAHi7VKf8AnE6n+FYwuOK925RJ7BpugS", - "i/WHYEshT1zLga+mQjc+AW7K/ReeLlo9C0IqXfsskG6T0B8JZAbRs4wptTj3yQImn8VY7e1wDtavEW3i", - "sEtuH25GOYczZvedtZjn1mjJpyX3AYGZXHKB75uO2zppveI0h0x8TCOrOBObpNn93tVgKgctuV6uKihr", - "Qzu/Usbq7C8zFh19aVh6+zbqQtjtZYh1cJLXubeoaB3M308UKsPXRyJvKa9PVBHNCFVk1PtwQl7IJKGZ", - "TXN6WWQSE6a6RvQv5mcyCfcKn63sV7gjxuVvSsBuhbryl1EPJNt1CTv0P//n/2se6K5BxzZwv7WxxFkZ", - "xPCYTaXPBtesGdNiSPc7ZdnBB8vjWUyx5TRhs4bkg08bj1wQFlU8EObiKrsBF02gjaY3/eWNvWOhMGtQ", - "ZAdPKJ+xBT+n2WLM5iZdPRi0oF8h8EqrbFbDGOCDl1Bm6HIa7rJpjpR7m0QY25UK8WiHXkFNSbVE1rkk", - "tsaSeABaUvoNzPK3jKEXAAlVgI6pXIXDV5Vq29MF25WViULaMOnHUk6tUFWfx5q65lqC6VxfiMzYAQnW", - "UjvPUlSU1OM2zqzJPA7rEYPZAEZGn/5RvLgaiRKux90kVy9V/JJVTnMe+RKHfF1Z2dY7Q7VvXdqdl7CZ", - "BOTdUKEsMiedKcsGBdLCqbxGCKf3GzLqIeicsS8omfArFle/6xOZjcSolyTzUU8v+UTKc1KkWChEUejB", - "evPmLf4S05zq6SznFEVhmskiHZwt4GRrFlotTgYr3EwpGKHcRCWgkKx0j0+nGZt2TOyAog+9L1ty/so3", - "DGW/BGId62CAERzemajXOROKS7HkVvbPwGeVpv5M5ywm/3ny7udjms8Iu0oBZ1YKcOqyq1w3yThXZJHq", - "rcW4uZzE4TajxQ369BNbKHeXY0AATCqt4ipHmhhAAxF4cQFP9ak8U5HMWG0c3PWr68pfhjauvSGC0JRx", - "e4gaNtXOrGEPtTxu3uRXMUXSTM7TvLdSl0DparxV2CS4A1DcIjDgEjZHHdt+rBc0yaRI4Fb8nKdEJrF7", - "9HoyEjWdTZOEzLjKZQbkOPgm3JZbVtXhzWx+d2MjAKke2wSKZnsCS6S+QvAa060LLqZM6d0VhvYrBUvE", - "ad2Fg49y75nvZUZUMe8TejHtkzkXfejgXB9CSglVhhTcELdlhI6Ef+o1QQ0pzcwtr33XuUdNhGWEhLRl", - "yf1q46t3s/ZojcB/8O1IVLSmHQc3lBBwPRXSkPCVy+ovQxdJscFBGiMp/c2gsvzbN6jjhIprwPq4z1dv", - "VPqtjgA2q6w5C7ESyBJIE1qB9TmEV+/IXqUXxVi3cJx2u8RYfo2mh+SclXEWCRUEKqhHlZpxs/ev1WgR", - "e7VSyVTQ35flbWTU06uxpT8Lb0fmAsijX4QLZL/Fdh2bJpYwyzDdehWOBMILDSyqiwUgQvSHCWdJ7Nav", - "IcrE5QtARI3PRuKyQqlZiITPeYUPrt4o4wsrb6+s1U+v3EdBnsa7GyaHi7cpuMv1yuYqZW2XXURjJrqk", - "dax3+W9dd6Z4swv57Bj2npmrhqr5vvrx7hPTfECzemPupkPuluG9UFtcB9wLdGEY2su+ajlcvxhoL1jy", - "LbBe5d6gDDyrYYpEzOOMzlNzlq+A75JDs0GpS55Hs5GQUVRkypyKHGgoUCfV8kOH5DAnCaNwhmKmGKA4", - "Ru3VFVBMq51ju7nNuXiN33r6+7jsY68JR5lmcpxB+Mh4XcBpC4+VZnKAnwJqKn7tIRbVlvRx+bqtKYhh", - "3GomelfedT3qZrldszevVDvfgGulVrq/mtods5uWTdqHN69fNDrJ4yXN9nlKrmHwNoq5a4ZvA9y6YQB3", - "1T7LrTZnBlXh/Mghwi4f4N4JNhmpG1dtltI/l1lJOZ9vQlda4amJef4ei2mNXNTLy3Sp5LEnh46ZyUy7", - "PjqmMc1Z31BcMoBrNXlWJqasZMfXFm3CRTWx0LSkJs3W5vJNRnyzXcjN2tpMtO3CXAN8cGxgHgK7gb2g", - "0So7TcG7hKGcJspCdVXMplmHaWqK9iEfD00Vfg3ENa6ppe/F/cndPUcYN4UvQC3CHPP8e6TF7irFZdyo", - "5dU+W3hJbbuDHM4Yjd+JZIGbvZ43frGVPL0jk9xRntMxJhmYQeCkgSHSyYLoKl1q/zylUa7qiOv7w/39", - "XqC1hlBwmw0GIxwCQM+0YNnY97MiB8+qkDlZsJxcZvpw7ejFExYDUbg2FzM2EsHH5pKOTAq4ZjuT8pzZ", - "0HC/v1+3dRezkuMddte0ybgBTbOpu2u30umi5KsNP2hpeVu6hhG3smPljPqAM5WV0Wtdexghe+fx4cu2", - "3hJCPDTgfUaFokC0dN3hOioyBbz8uxwwr72bDhu2c7Mxq8KNdrwUlYLlNFu4xCqhj5Q267Fdy5dZRGst", - "8arHZn0/Td2Ew1r7K5KqaqGg9f0sY8yyAfz2+uTdsycHf21nHNBPB7Y6n3JgJKrhoI5rwC+/8kob3QCQ", - "Q7XxDbyoGgpPK2bC0wDhwNMWwgHTkruvgzwH2y0ooHIdBljwoGRD2UfhSrrR5ZRO2fqLXY9ko41QxPLG", - "HZtaahnOPAvBzH345bXd6+ENAhV4GSMpzWe9YFr6iuL0C2uXJtjV8tL0C22liSIBS806fgKReuyCy0It", - "rcG+tHEtiv8RUCnmeMhiKJfAS94qPth3JaEHszHj5gsYIa8r7TJQiuI/C5YtrDh0WMMvWM6yORdMmXss", - "aLoNWyzJKU0aFmcXIbbxklQzMB7VSdVl6yXTL+nDnI9F6wdH0sz19GTUBMMEJgEBGJdXW5nplVUbUO01", - "6g4LAETEu1s25DL3IkBSBhaInzLg/C/BlHwTafkZ6Gps6G3pahvNvpnj1MWz35jn1EXjNNmPfnl19PTp", - "0+9KQySXMlFDzvIJ2CLa5tjLJpF+6TFBxaUnNKY5G+gjj72o4WIkPrw/WpsXzOlAV5LnSjOtIrrhg/d8", - "HgTTsr16xVkSY3YtzIRYdApQ6q+YvBq21O9bCYL6F8Sf6L5E+rjPfi9oosiUXzBBfnl1NIDel6NdZmBz", - "QWCUP/V703yLTeGqilAAsXEdm8N22B6Z4SDZLbVb25ItD1XClNp0nJJtj1PZmOsMUoBjrg33Rvrd1ssX", - "9MAjW89jE50BAVNDcpgkpFxD6AqSxkP7N5sCSdgVhZUgBSsBcAzmoZynNOOqeg9iR4bA8idm/Vdz4Uyq", - "/hAfurH0XhrwuT4QoQWtjza9Kc9nxRlw78mUCdiSuSz/vUdTvnfxdM/CAOiBC+WeNFRt4CW89V7zwps6", - "Ly+clsVI2PxPB/jmq979g+8oe7Y/GTx78vW3g79ODr4efPfsu4PBt8+eTJ49oX+Nv6HRamewJW+0NdnG", - "k5/CGK0mfLwzLWhEUwOgQ0yOEvhHXTAwkcAqCziY1ApNFvAC4zXNttAv1kW7YyaCyEIb6EUxDHkrY5aw", - "22sf1L6ifbfPlNfBl4tGUMhn/5Dd8pDdci+zW/o9vMe+LR0DvhlsQpuaaR5a+i6RuNTflY605+eYKdXT", - "CT6JX5gyHHYdNiD8CMOT7JqACfldF9l+aG3B4dSPSSYv178jb/RCXoYOt1tLwjjxeat1JzmKLpeYH7El", - "tNiXJbt0o5LQqXutCTZ0c13Mi0xe2siNrONUd9Mzq0Ba52kBqGG6QnP18QgV9v/3/xCnNh4Pyc9FkiBu", - "jY29M6A07vJ4JBxADBjikZyfWT+xnJSmEwjhSg/jzUW2en03OWd5MMn5BfxO5kzB+CA8ojduejwAsZ9d", - "pQnlAtxrs0VZRwTpRHrMzoC4UMnkwsDh7yTpDInQbEFe7ozet01Gh1bqFywbklOTwGxgfGyS85jHp3hE", - "0to1u2BxbSIby2N3dPZwqjsronOWL+/M7ijpOzUB1tG2lmo1Fb3MYfKI8hsqDBvQR5VRCc8sie4rsrZE", - "3dXsxK7bmQuBloQaG6JhOvpwsPULnRWwuMtHFtQ0nrlPYK28penrnM2bS8Z6FHQz0zRZWMeFt4yMJDjX", - "+Jxe+S2BS46Kwep9a/sRGOaNThkB3u0XlQZCR+w4W2c/V/5IVxu7vg/XyMXd9c3bo/+t+OQdaMNmC8bC", - "NtyYR/6VzM54HDPxMss6wXJRxfCTT/0/G5gSdiMtvUCuHp+DvvrKuRTT53lGI/b84MnTZ19/89dvv9uH", - "O6ec5nix6V5+tv+0DNpsrcdmKpeP7eUC/BeKZQpcbM/2nwZdj5/6vR9YXokfPKYZnSvPz98VsJtIk/Oj", - "9fgUCYVLnC8TSrWNwEJUet61xMsrusShujTMscmytGEbulQ/KYmYhuQdgJRLA7/pwR6nMssnMuHSeHpH", - "Qh+LT9kVV7n6O0zEqfch5IIU2q6BWw8Wl0MevI38QQq249Whq9jSwjjYDy8MW0WXNXGw37omtLEjdFON", - "xjqMIot01eE8BB8RrNSm82Bkf6tJMKNqTF1lbfTwHlpPGcs6o4rgpy4cxNQyEiNxqg8kpwhNhUkvYBGj", - "OwqdCkg6Y+IyIZbJnoEwiVx/a+y1kah8ATswsoHoxW4Fjpwa6XR4xp4jrBBl8YimhjYg5ItCZyAqNGM0", - "mrEYwlsf1SiIHzscdxdFOhLsakYLleMJpOoRKa2CH91YBfn0M0ZVlySUFnn5BYtZ4v3Cijy8ZzutsWR4", - "DoWehaeVHMsU/Y4m6/a0lB5AVzfDv2wgbBNr26knhh+DOmNZf7sa0TAE1JcNOIBDkfwsMda1j7VVC1Ox", - "wFbLLOmGTXzo3iMqz4pI142U/ewqXzZkh2V1gaHphrq5dCBbTvxvaTTjgpXAi0yrYgda2dbsI8MMZg76", - "TfXyYxXOMXD5ABUtq+OtKXtVeoMhxbFN6Sxi4dDPxsCY1eW4gWImOItLtkQosUIzJs6FvBSOTxV00dio", - "II+Iy9Nd3q9C5uOJLAT4WeUYddO4fPNjwCNSdhNOc+VGvP4Cgg+NEGhFDDG+Kc1yDpC1qoBuToqETF1l", - "6IVbciT5ItZUOaS7WUpWJbW4qK0uN1fLnGXlVUTmgtkoYD3HRcRiPMSuXGVHzYJDzrbPbqHXpqt5s+8m", - "xxhTDXmeUJ5Y4p3Gkna+v3KdrrEiN8sNxDWZS8K0zQ50YRWlYzqQAKTVxImKCh2LShnbSP5NB6zQqCCh", - "snf+uW5FrywPk1+P57QwUZNGPapK1ndwLJ3ZW0Zc1o5SPsUQInbTaEasJ9pDZ/11pi1EEGV8x86KmSa9", - "BEwdql5JNGPReZO5wrOxSvZXv5Vqdba5m+M11kdjOrsJ5puaxHk6RFXktZTTpkyes0XgePJSDyim8xqI", - "l9JoI6fnbHEKKWqG+NjDP7Ugo/jScCRe+20yeFR4v1BOasUmhNNKxkzORXkDBZvbSJyCPlOnBDxllcvC", - "ptakVxbKwNAqNJENnALWA4EAdG19aibV1uYexnL9eX/lsZx1mHZ34LAax3M9tM47eT0pgXxokjhWtFFp", - "/tjBltmUCv6HoYCB2ciLTLB4SI4hisjBv0ALAHgikvM5MCmPBLgv9B5YmTkItUcOmxkjiaQuO/CMRudM", - "OOpota6MvunQ/WuLifV2/qSbsjUx2MgVbT9zzCO1nXPdq3fj0vDUJd7zqj5EFOLqTyGcpa58172ib3ZY", - "bw2f2m2RF+izrjvDcc2H0nzAMkYbRxEmAIcOLqEuZzwBtgg4eRpeHC+vf5P2Wz9Za/NfYjvbvflrXxO7", - "DMOP/TVSm4i5A0wlFzmZU0v8Ux4eynXIUWomRZLAjSn+egkXv+wqYobEnWUDxWPjwlHL7cf2ywdmB6T1", - "FiIsIhs55xqSXPXTBcX4ugZaI7ui5VLfbDJw60VzfQSt7NbeVrjOacEz8Ta+cWzzi34KwI57ala5fBye", - "WQ2LXlETxpianTRjFS8h/Ji57CsuyKn1felHp+AUZBdg+ePvI4GGxvL9qeGOxAtMckmVw7hbMqJuDw6I", - "ppmo8InQbr7+LIZPhL6ZA7tmacNqMwvcrxnENTPe9Ak7Y0vrZMhYUu0WihkyY9k6Hi+9ChIO4XG8bo6Z", - "1ll/JDCHlQ5pmSQ0Vei1s/CCdnFBs/soDjhx3vSWx2Q9UCwmM4ZnufZtuFW/NNdLQMNuOYLvvYvas3fV", - "QBbNIqBinlHRBNv/SvnrAS5GExahsI8EzDyO3DJ5/IDdILQJum3F0fNVeFqgMgIhRVtH/2vmNb0+eUcg", - "ZNG+U2Y4xTJSw5hPOdy22EBVpX8v5jaicU+/oN/c+25/f//g2bffDg6e7rn74b1szJUc6xrGlmFwjPkV", - "w1k+f2xha6sx+ccH/+VnPple9CrZ1MeP/vF8NIr/A/4z1P96/I//evyPwK9vg7/+Gvz1Bfz6PvDkxw5l", - "nzz+x+N//MU/UdZHOeTveW1Ad19eMMCiuJPAChCOwcW00thbQFV4LS5owuNjmw16NJM8YhA987xToloE", - "Hyp/AOqAeI1163cVwqx/L5h53YTVQ2ZP9R7TRO62FFZRieYSpvwW8l/s8GDa0FpFFUnADcdx6MpMWkX0", - "i8pzusF/P65RA+qEamPPZLxY6Vj0+qBgOUBb+2461pnzFyzVx0+RbzDtsf22PvP1CND7N/luaMZQF8zF", - "mqOyTcFAeXDy4U3YOrJhUmtsekQn2bjG/DlST+/jb0OofqGJBphmd2c8x5R3Ksi3XhrITmd+Tq/GCY4Y", - "AljjuoB/3446sOO51pQjsuKNT7kFdNx4yjFEwKK73txsc+HNNhdjbcrlBpB/nMhLlkVUMfN3kaaVv5FJ", - "z77tBIWLWxIUMwvrCMpJTkVMs/jmZGQHan0p6Dd2+BeY8C2O9jqDq9aRRf9MKAVbB8e8bQ4/9bt9WNUS", - "nb+ubCtdv/aM1K6fVm0dCHKr+qxXmyUVqdhEYTjJ6Pe4GtuquBqfUcW+eWb+be7I4A99OB0bzAquxlYZ", - "wh/apLD/AtQd+LcRLPi3423lalwU3NQ7+T0WtgUQ6YEXxCV5ix4ZcP+Oy5xMeB8yV3vWx6PGGZuyK/0I", - "u24qtdBfY8HyS5mdj/3byfEfUrBxwlXe9nbE42x8lsjovP6GzcbW9XpHwE2sq9dI1XvnAWhMO28n1v3N", - "m7dHUuVvZcySrresb94S/C4c3t6g87eOL+c4ilnSJ2w4HfbJqDdN88GzUU//M0poEbPB08HXAyWFYDmS", - "5DbRuIIZxD97mcO1On44fm/rOII6yNPh1+SkvY7W7NJVY3mMiXZdcWrluZekB056AQm9ph8xE3JuhDCF", - "aIFzJgLeehrN2FgvkHHKsjG8tRVMU10u0eVCG1nZBvLow8kLJLfHyi8znrNd1A4FL6mei7TIt1vxa13k", - "kiplkW+9zndQ5pJK0drQCnyr9f5iiyVyeQvqK6M27IFRWbJk3l2wLOMxQ8DyjosGp0cvFoTMgESMlGUD", - "vVBVSiMrLtLUMiQfECUlRZ4F2HD6uMZGAoj4StbsiV6C9ktCEy39C4J5CaSaNFsrilARlwCbfcJziwBv", - "UtrjRvEuIBrKr3xiktm3kVKyLu8zRgh+6vfYZMKA8mR7xH2/4u0UV2XnLfOUq61W95ayQgM1s6uUZ0xB", - "fTB149AOdkSFFEAEiNNbXrsENycsKLxF1YITsTz9arCk1NtL1up9aCMK3ORUNhtEAkXOEpDiQFCBebJ3", - "wUQsq/v46r3TleuNcdm3SoZrTd6WKA7du84AQaLEyEDFkLFIZnG/xKGwYRH4jtN95tbcIgsbhQGXm97P", - "NwYodGQRgipo4Q30mt0qCPKoTM6hSO8x6n04eTHqPQ62Zqe6BKczoEiWNmTrigWbYbUKJL1BprS9kcfn", - "cOFth255W7eQYGy2vKrSalQ0d+eAzoqmLffdaocmt8DNqbVg7aWa61S91YKhCCTzqKEZm0QDztnUsW4e", - "sRP8NiiADgAWJCzSJyG9zIJt2HJgwBsPq2eZQgodqep7Q9vGYIatoUXasX5W7R0nbiJajqtKL9uM2YOY", - "t2tURre8HRAF1e1HGL1g8H1dkLofu4/L8drk5F0aqvZgLFMmKMeTMRX5LJMpjzY+dTfLf5cycfgayz9c", - "Wn63E7eDWWsL9PLQwL55WgcD83Hn6eCP/cF3gD5/8OlR+edgOP74v7yn/2GCFpbDt2DDiMplxlw0IuAE", - "CYtt5XMQF5a2FGO04AjjXsSAqgw5sxjNohk8jzKplCtskeqdpkEuLicEby/IweCbp96lCSa7mpBzRGqB", - "eKURZCrjRJ1LIViU4x9zpmbmZz1zEJU26o1HveFIVDnImbjoPe/lTJlYsQrExtcexIaZvdC8cpUD55na", - "bqK+HkoYvJJqrP0wtUlWfn9NaIdKLv1aAIOBHPxyKXb+sMw636SXn1qm7Ag4hnY0Z0hgFJizsi87QlTA", - "isnZwo/nPHHsFzbfntCMPdePBuTUbEen8IehC4V/T7igCf7TwHee6k/qSQh+mS7LAKKQU3R1uK+HS6ZD", - "qvx7qnY2IXorPNPlh0B/aD7ultG44tBhJ8NVCtgSXOvQmr+idThKYqBdjQgmUwGllboBT00VcwOrbSB+", - "7Bjpo6z1nGGFXddjk7fpBEtYv2qzLlfNvcdxtFsJyL2Kdskut2x0/DbcFgxMvQ3LsGC02sPPRqIyfqQj", - "EkywEB82ZQOx9CTnvS6la8d11cvEE+eG70xVu/JDmJTxZjaEHc4Ogotj1z4KGL39skRdsXgIeN/6wtyu", - "dk0FdWH7Hp6LDUl3iT5hKqR2cFab5xAus0jyzqSmoX63pYUtS7NrRT/1B3lnktaa5G1ppdNMTnjCxp+H", - "pZwmVIw3rTXN+JxmizGbG7ioziUgRIeX0TI2GS0btqlt7UGI+o5kgpsweMKgkvbssnFXP+daexHWClp4", - "xnzkSqcWXr8YdoVx7LAXlvXbesx4bOR526DLAHwKiBf6Z0gAs00Y9jZwRm7Ud4PgjgaizG6199gAbAuu", - "pl13HmsZGqpytvOOY1+R+baz5bNRF1dYOA5xdBcKxuZ6BRPkN1K7ENy32Q614U7TNnAmOmxnqhlL3+5d", - "5Vqic7awtZdUJ05gd7sjwGmopvuVKnbc24oysl0HZQx1ozpCqIcxokKPwTG7uxaZ2gwGNbqBNzrCd3Wp", - "eXO/8uju39bsaBVUL3bUTmBbV0hjhYWXDadD8g+8C/jNPvv4G/v9498/nLyoR6nsokEYkfL6Ra0ttlps", - "C0RsNkNddtceiJAJtUg/+PhbJEVOuVDQst5Gd7zdWuUiPaptsj/jKOHV2o7trNLAqjYFf8SGmBvJ1oUG", - "Was7WmEYLN+6P299PExwvueV3Jl0llVhAFfr+B4ndFduR31I3clt1hdyMXVSnLmR3NEUKL+KlUfcjjbl", - "Rh+B52LzLzeZeic325/Gt6z7dB0aIgXIIquwbuHte8wmQB49k5ckl4g/A/fijhHEc1l4N9z2MdaiiloA", - "ClDVPmuhqq218DXBeKUPBmmySh5jwrF6fxnasBgzLn8Zwj8+9XvQwLH5Oc3kPIWsmxhYG3/45ut///Xr", - "rw9f/Xr4048vD578/F/7R//87tWPhgLreQ/iGtUYMNhtoIUJoVLkvfnVDxRa1jVAbi9TjKCVUJLZi33k", - "VX8E11XKIAKH3pfhiDOvbDiV6qktVMm4Ytg/PvUfCB4/f4LHrZAt/UznLCb/efLu52Oazwi70iNiiJck", - "YVe5bhIG+meySPVeD7LuARuhwwXuEBpBOIaTFQJupFBwbyAgXDadUYGpGAiwKGKWqUhmrDYOnu5pKICG", - "pvQ1QujiwviGzMqwaKMGQspbPFW4GadaVvAposIcb5VJCmIKFRcGORGVupoBMpttv1HU5INikwJIi9U5", - "T4lMnNuZvJ6MRI23kiYJmXGVywwC+407i2bMlhsPPyca0TtCqXnXOSObW1V9yAK6oK4KDI2XVQDVS46v", - "FOgCR7G5gHF+779X0oCpYt4n9GLaJ3MuMDBvTq/8pajQhMEcYEAts5hQlTDClGbKosbiu1DtK5kZHTQG", - "GEi/5H618dgoq7io4ZEekleASV2IfCQq26sdBzeUuqF8KtC/7usPZwusEJ+N+Tz7FaOiogY/ttmTh1Uz", - "ZGNbooz/NcagHiqXYT62f9KLqYF/QLQQvcAhTjIUJQwNvLvJy2iP30rOMlTt8cKpjU5xVaI4S2zXBhS7", - "lplx0zx22FhYnEsoIEcCrA0g81fk0ajHfsdAXi5GvcceIz5ufC4Xv40grzodn5ZO0A8ZFUVCMx5Ssu/B", - "oHIvVHgawdAC1QO8/BYWzzTRbuDaarGwcUBhOqe5vxqP3x+87fX1f/SR5/jgBfz/2/b1dg00/ENfgnxA", - "Xc94Q6tIn6Ge2jPU/nP4nz4/Tf3BMq3VgwF4Cr3nvQ/vj5D30SvhiVfCp2XUi+ufsCorq83t1RRPs3J2", - "yiJqLipKHiWuHBcwZmJ8qg1j9577ItvSJP4HC5CKwpDgAcFroMhlC2H6SLg+1BhI8UQhcp4xn0cZyh6f", - "LcZVbbScONZvkolLImeLilz+1qt4Fz52gASvK39PXD3GAyO5zYY6ClbdOt88hWHV5RCqjJvGQd6/Pvz5", - "ELXCv/ULLwzN+UgAKOfzvb3Ly8shp4IOZTbd0yUNdEnqMaJBl0VzhYkXuSSxnv45F3jAAJnDTPAwf6xq", - "48D/8P4I3oPyXba3amEK3g3P7bJFksvhKpW9EdD024rqs1iunuZD2+K3+k5acYsud1hZXxjcOg3yIjuT", - "PQ9BLC08BuM2DduuO82RoPe8d/Bk+PTZ19/AOG9a2qf1wwhxihCsHGQKCd+1UvCJ6Qibp/kCuR2QWMAw", - "D6wbY+hN8I7p4DfT2re3FtYKnawO35Yo42smp79cPptVspml/MB+fqfZz80sb4f93KsAuV0bqw6r68Rs", - "biGWEVp5g82Ki6nxhE5kkshLC/lwlMgCAZuVg3RoukNLjV5ZcBIPjvNUGz0/siSRfXIpsyT+P6Bb4P+o", - "GE5uRcLK/jo62J/QmA0Oou/Y4Fn8TTT49slfvx5EXz+Jnn7z16cH8dOozIJ+bqOFBsY/opt7wTKFvTwY", - "7ve8+EanRAbgUsEoxIoGqN3mVK+UWne0dVnzSs9zSheJpPGQ2BuCPuETYrx5hOee++k/T979TKSJnWxC", - "wDWkQjcKiPhEHvZ/H+FD9OWYleHPOOy9KKXknT41l0tl1DOcrIDo/t9KilGPcDUSVIuPtdx/fP/+2D+B", - "1r/Rwlw6xRpPW/voaUqaU1x4S7PWwY6F18xdp+4ZjWcs0w+BTMNhxxcZb7jlVrZjaaq5Ki9Fqm7ANUV8", - "hYdZrc7aR/gW4GTUW+/ljMPdrpHBGU1TJuo+ytp68sdn4MMkrmqdvw79YxAuycAxCF8OCWRFBZlelPdN", - "hUm+LLuAVaxqYBn0XLspgL/OrPgYxjLLlwhVGjPGDm3lmaF4zEbikcMZicvYpMfVplYV0oombxY1vYq/", - "wiGyyMjEyrBSNMhbrYdwyegz4i+vjsjTp0+/q/ZiiQZduYTadRTlQhGjicwF6pndoazuwjHPGJAjWy+M", - "zDiyIInpSJS9qo28nA/NX0Ml5wxK2sQx7/A4fJE3X5Zi9rFCiYRb70tTZevGXuVO6Izw5G405tXNHkAO", - "8GGFKKq6uft0R6tsbnvn6d69kV18jFceG2zjleyTZV96aRqB157ga5+uzxRlM9J+cRp2BVcUr+gj5af0", - "wPT6NNr+7HTwBDrLMtwUs8oSpxO9bJprZfcsuwAHisD2VB54znPlU7vBIcSGlm+edbNBq7A2u1vExkdn", - "Dxc8RpKbNvo64xs0r1kWO7PXVG9auzlA6orlX64SR2G3NLXSakp/kv2h/egTpJpmdlN19RZ103xQRHPo", - "dkB9XRZwfcrrAGoYclYTB5EIUHPrEjcfISHz+mTRuspZMaeC3BXC6J9l/koWIi6FYL2kdaqYleQ/G2wu", - "uclCLS2Bn6U+/xYiRs2lcirqGPjnUkyf5xmN2PODJ0+fff3NX7/9br8a4+lefrb/7JMbjno9r2w91uwp", - "H1s2LfivgT4BQq1n+89C/uqPeoSM06GJRGUiqlyEiNJ2P83OeJ7RbKFPmhEHe9vESFQ5s0ajwT9+2x98", - "9/E/Ho1GQ/xXC+bTO49vz9Alv6dXWvo6U9d6JQ0SdsESYo4NJKdXKP3uBGIAaLTSQUO9/qqCmzn0cZa4", - "lCb/2pruFr1WH2F94kDDZasHSG8qRS7nNOcR0OyX9rLPNMjVEnTa7YZYVqx3G0AZRr0EIIYxYISMc3rV", - "EY3GzOMym+RFfYIMBHEVAsbpJO+B+wRX3YUEqLsbbKWrs8robX6sNG+X9IFeqNYaQIHNcWqb5W5wgMd0", - "yt6y0P2MO4mlJbUs3nF5BBCWuRliqF2I1sS4rao3NdW1YSgdfE1YHrsc38PVQKWMnjOqFoOcZRmdyGw+", - "wBirEk+S/1FVqV6kRreSMBS8WtRmZdXmz30KbbUVtUyIFx3UmBUcUNR83sRwE/+BR9DqSKdm118Rk8SC", - "4Uip3aPNOqk2r97+NYf5OKECEO66BnPZ7+rbmzkD6ZE4M+GcFPKCMKFBGMy7Pqj/TMJWMBLGLYZweBBb", - "U5LKakWRFlk0o4rBwYrbIgPmpOvKWgoCerDqvIetapzuYNpNI5yZCa8+hPR/ESH9k0zOx5CClGrRW3+c", - "KsHTQZE6Zy7KDJYGVIAxvKVr1cidRZEOLwhf+l7p78vythcw3jX8e06vxr8XFOa67VyFE1NuUyA1fr9t", - "LLHpaOxiXWHRkVcys3zHA3tgcAoEsIeBD6tEIDVU0xClOC+SnDc+02qIiRIAsRDArc5iYjvTaNTQYzOD", - "TdNRIl+5j3ohfrmHCPn1I+RXeWneGASsoLthLZ/MMVwY5Ec0p4mcBpwxbSftf9Wr7K1w3KwXR47bWFMF", - "Ba0UuxPf3Rjt0si4lThtXf2dZ9/Sjbyl4cnuNDtZhWHjlgZomXboNkYNhWHAG4AjABxjLA6ZNYDNsgP3", - "qcqzIsqLjMXWH7NtN+pbdKGWLDPQbwOS29136og9m0ZFSrVZjveP8Fr1thGUqtpLM7mX0ZxFNIvVHgTD", - "7Bngpp/gLqutRa8Mv+b67twavc4NunLtOIXEuZEB0jmMEH0PGNVvyWgwC8zJ45C8S1lGcy3h+jg3L/IC", - "XHfsKkoKxS9YH5JPR0IKRqR5F27RTBgLzQk1QEwNqRchWiQ5P4Mseg/5PzaNVPZCLpFTSLA8/PnF2sZB", - "c7xq8efL2D1hWaD3piWzy44Yse9VO2BC1UIZrr+vKtGk2qxZHheryuOKwGxNAkVWja1V8fpLB0ysO2KO", - "psx8sG5PxeqhKxnQ9BiuXfBaY6iLvYlxlNk1V8m7X25okZSXNaidCJZBDBTIOkrMprFdX5cJontMwMtk", - "1NqcpqtV20jUdBt5UG13RLUhaPfKMuEtrwBLj/ygHB+U491Tjm9pSvQ3S7TkLywqMv3yMeSfdFSO7mub", - "voIjIAgV0Qw0JTj0uchZdkGTkDLT723HtQQeogFE+JjqcwkEHMZJVmtqHTZkWWSaPdyYYqEB/Z7t1vrN", - "f33y7ttv9g9emBzhFt+vLdflEvvJw8TLHXZtP4bk4fJ61Hzvf+bKMrHC9eOBmQmvVx+D4lI6rhuL4xC8", - "1oD/YIBkfOQHL4fRhNwuCC19l5X+2F9N7KBPjfVsNTXWx/949I/nY/fH4//1F29wbA8IHuUaGuJEZjks", - "orAmOqUqOiWqmEz4FSh0e9FAqwEOSmY5kVlsML1UxIQ+wQ8RWuNUF+wXY0cGQyD0wOg38BssZjgSb4sk", - "52nCsPDyYE/mdAE+Z6cJOQUYsfmcEsVSmoG3JeEqH46EAwwR0vhbzefNNqjibFCq3kds+px8NZFyeEYz", - "aN9Xj2uUWp7DEl7wxr0c19CgNwD2QDcszJKqv79CR9VZI9p2w39BzHLF8kB6ZCO2GNP8aFL88ccCIdce", - "r22LYNnI9FFCGoSr6GSQIHdnVrB+6cVwVxg2NeWRkGIgiiR5/DeMhMGRaX4xEvTMfKHfDls207ytf1yR", - "Kcx4pte4aB3ChF3xSE4zms54ZHAcWHgwpzlbtzaZWfNCrlfzSCytOlnWz4QptbVOJks7WVbVuYfLqxXt", - "khow2NYUVNm+wH4x8Q9wm4OpLjQnsJ4GFsLQXXOCuhrEzN6opbMMyLPQLh0JcwAzOD/BloS6F24Du6JR", - "TrbehkD8XxsohQwIEi5NnNezBWE8n7HMtFVmxFNEQ3KYJA6ziRv6NbsZ/c1uBfitOWd6qt301aCpDCEU", - "ZCoHpu3GnB1W7FHvlQGfpxLRvlOqd+HelOez4gziIGXKBGYyyPLfezTlexdP9yzMx6eQzkdIze0p/p2o", - "5d0soS9NcMtGgqCSqpyOxDUE1dkT1v+jazZotyhBq4W58d6WJNoD1t0kYgqjpcpwBnOc9PF6AyeoLVOU", - "r3tDDzNDY0hEq2SQ+xZ9466ebpXHfJO2eonmy1t6s3Fi9Ul+iBf7/OPFWqjQ6onJNx17dSuBRSvHYnk0", - "mAuvMi3DlaQ3l0u6UOQA0Skh1ovUg7baIrD+uSz6ylZ40+KMwX2p5CaB2earuQG4pApwQmRyYZBhAiKh", - "D/xjuL4OD6d+TuB5bUDX9Vc2trpfaM6OaBYvC4X6xdXaC+NxJVy0pDzZp/X5h85Y0mF07BngPWQ8NkjG", - "OReFLKoJ6L/V9s7ek/0nXwcwZrwtq3ylCjVTyu4B2KjhYp+sLvZpS7H7S4p92tqUj5tO5nsz2idsOofU", - "0vY5ta8GZvTOhw6GAu/aI+5MSJ4NvPNiN31d0a9MkyfWlUUZcq02ZuHuBlw1Dd1bibpqV0KdUa+sZrKx", - "Kl7JnmqsWd6TCYu0ePhvj/UAjnmb4n39wmncSh0w7HjCg8jkskFnLJFiaoFQ1poeNBWWxGiZhjeboNsX", - "WMlOcjtzEpfbQtAgdt30TV63TTQEomxHf9XoryUvdT3XVWwCYlKmej8c027imLaJ2ejyBNCHYXFL+5Xk", - "Nmcx7rcvpCUWZP12rbIpuEavktI7H5PsN/Z2NgGTWHrnR8q081YHqfRPdBsY83mZ190ckvXYm0LJDqH2", - "wruNFa1/JY8+CH7BMgWhoh/wmvmNfwUCD05klkNErcPZymqYTkuxKf075f3BXz/+tj/47nDw43/+9Pbn", - "48H7fw3+/fHPJ19/8q+VocWBY22ds6ri3l5jE9/A493Rn9DNQQ5zYMERnTt8C1W2es9rNW7fV64rsJ5y", - "E8pjOSu26CmHbtyCnxzq9b3kS/3jRoy37Bj/IGiRz2TG/2C7hgl5LSDHC9ANtDRQ9HltAzDkIAwY4neu", - "M2bIQRtmyAc4eh7GccaU6n6PAF81IiGCdtIRzxcV+IeKQVNqMqAGyToA1R/hB7jrNRaJeYpID1yQ316f", - "vCNPD775ZnDw8ZEdMcBHVxLg0bmSA3huGjIA/JDhLJ8nj0cCGKoGT7zoqDJNBNv9qd/Ttv5BcwRe8Uzl", - "pOZe0iPoF/NGPz4IXuZzwZ40Sz1hkRTxWsU+CRWbzqRg4xJ5oWar6KceLIxL+Yfff7YIBs1SpcppMg4n", - "4hzDQ5d448rEn9vybbRIBwo70T8TmaHqMkZDeXunv1lDudqVYKwowzH+q8zOJ0lneGvztYGtUYKmaibd", - "iejSFFrlXwTft4PXkBZpVbE853Au1zsNBHkzKriYTorEBonTRB8cFgPjU7JE0s9HwiGEkDM2oxdcFhgr", - "mdKFPoi60ofkSCYJi/CAmfCpgMcA5EGvSCoTHi1GQlc/pfmMZRj+uKfHfMITNrjUe0YkRcT09gjhmBmD", - "bbZkDWuYcrZxHXb2JXPkwFpOTKcCyqAEdHHjaiF/7KiF8V+UK1MbbYt5J/y8Sqttc4+xlCWNPa5N0tKm", - "1l/uLuPN8buO0PPG0IGAoy+DwVqoDUijfmINp1yiQVMugpHwVkHKsoEdES2QU6Anu2BjC+/Elc2kJ1QR", - "jgiJVUGGEBeQZAs1hYBYAQdLkcsxjS/sLu+wbPHI3giig9CaXNZgoyCJskJ7Tye5oTmJMzrJDd89mVFF", - "UqqqfBlezJz/chVa93j/RRBa1xRsfRO2/lySM0bOWQr3QVCsYaKHV+dUaHM5YxecXap6VPALHxvYBB9v", - "oHWPaZYvjFXRGTDskESlDpMTuwkyVcI16OKbM2rEZEw9I6jDurZWUHMBm16V23H9VFqv+eNaA/SeXuFp", - "07D5dFii5jPEorSBxNq4VcS2qxo3Lew1B4yh3gqKLJUm4oeOhINSM8ZSAO6sE3xX6cSwB2rEeW4x7n7W", - "MpdoixgaxyvfoMmnZvJS2COSQynldiRiGRVz8KSuFs+a6j6a0WzKDv11vaHqDGp66uDpnMHgwOY8SZ+z", - "fCZjQJyD9oxERdOEJsR+O8Zvwy7NZhU1jeFjumPV40rNAUqxRqZwvSUfO07BCROx2XdudegVE7G1ttjN", - "DLmucmx+D7K3xQUbw6ZS2xaeLt8XcB8qsX/s/sAViQs2JL/yfEaUnLPSiJRJYSg586+UyaU2OP4WJMhs", - "H40e1jYSbNtaO8m2BamUno0EZAgEHfrDORc0R9fDnKapsW+DK2QDe3GZ0ulXhWIja7S5nko868XPSIbe", - "HO5P/Z4U7Jqm8LKufepfx8QOdKpdQI4SqVi8UZraYSU9zZK04XWYpU7TVSjHfWveh4xciDCC45K2XgnN", - "S+Y1/Pqq9oiJwKlq16RVgaaH29w56+1Ef7Vr4qtA89vGtVPjX4rmNXJJ3rNE2gCu84eMivzlVc4yQRMt", - "pAnTkrsZ7ab5ipzJGO02CC+xXAnM1FLxAWB11t4HJi7EER0JABJtilnpuexk2GF3j03osad8sQUnWGp4", - "LgW7bG9007g2LVwy9AYS/4OiU2bxZHjnaOq3qOThjOdy2MBFzWJDsWayahwGP3knPPD+iAoyoxeM/MEy", - "ORJ6t5SZ4xpRfXJWYCKyZR/RH4CDCGM2dPHSKzAwWfjh+JwtWuJFbGWlm8n1JW42/wix55CADywjIbGr", - "I4GA9648KCoQh+w3dr1gk9osnWANhhbe6RAzRD/pnq4AQKuMSruYvOAKDjddLUv7XdXNZ8yHSkBKDZmV", - "ZRETeRDG59g9I7Et3gO2xmRxba092v+f//1/HezvPzYRsyYo1eSiu4CDKobtp36vsPBB16U5+9nBKeIS", - "KATPFWI9A8chY+SMTbScW0sKNg1lSKawU4rk0nDCDs4gVSGBpPhHQuZkktCcTBiwmH6wTIa5cYFSBauJ", - "FCLnCTrN6ByGi6uRYFczWhh6ivZT3yuEYtq2EqbEYDwNyRFw0eA1m/H36nEaR1Ll5g4PYR5HwoQINsXF", - "fdBZF5v+fRA8P9LfNyfRRaunLBvoigi0rOq3Jh8UI6MeWvijnhHwCb/CSNnyuz6R2UiMekkyH/W0uCZS", - "npMixUIBclSPwJs3b/EXS5FBcOrxzMAyZO8dnC38tLQhOWG5LvNUFElyqv8VJYwa3uArrmDoXVP+Bg5B", - "aAPTmldvdIWIZlRMcYwbREX2ltOWsExwjLF55PO+rC85J7XrAqspv1I+oLO1VVzgtj2nAQGKUkVIVnbm", - "6dJbyFnV21VvPshJ7PxIQM0Swly3TjNXWX/tmI9+75x1uDe09tZykFy3BpzhZOPEAIXAntBdN7V9+c54", - "m0ungd3r9ezYaxq9F8oiJ1QXNCQfRMLPmfVU2S8wBh+q47liyQSTqw0AgkMFAEauMxbRQlXFwV0+zSks", - "GBab2zJYADwf3iEIWK3Ex7RmiHWQz1aDrjmr3Y02crbwCH2M7VAJgICvKtXW8d4xspsvc08Y3fEmmKFw", - "SHKZmhsKuO+FWFqtDIRzEemJeUmjGb7gQ6LbvBV0RfRJvkjNbUSTLsoLVM7kfCRq2YHkhQWIfBTNeBI/", - "NhszXPohx08hYpaRU4skOYYXTmFJgBwqE766zGmicipimuHHy+feHvDNFzB+Tc8FDHpHZ0Ww5LUmcMMw", - "cReXXLMc3VLGHdY3i+xq1+MUCCOsWLAdFlRp+gZYNFrMW7uNB0OuvQL7PWMGjTsp7dWI5qZYUJHNkwdX", - "MEhfqXADX5Ufo/jwiHUdNYMPG2wcWufgGQJxcGAoEU2iIoEmwfL0bnvtpLqrXoc/C+weevS7NtFKJgRc", - "QgGB5gLlSasABptWftPkjMiqjuqWdeNZ27WgzMBbNu8mwz/XVSed1rtt0E6UiSt85bhU1E9Xr+SXt2vU", - "A/RunaJhoxTb2u3sC9ssWFZgSNq2a00B4vDcnVzQjCQU/GL6C32+IqpIU3OUxPKocOefkYDZzSUB4iWe", - "D8lLezTCmbBhEqDFqa3zK0VOzUSAJwUjMEwediVeBozwzyJPuDGBG+QetW/4K7KQ2vSq3Qxwl3AaFhZs", - "S+ZS35KlejEgnWxm/7aj5RIAK7Ae80hegJUM9nAZjNQnKqVCODczzRLObLgj3iPkciRAvGnunjARExpl", - "UgEmqZ5onmOv8ZLklcFBtadbDoBiRlzzqh9/nuaLvrm6nDMqFDnVgnxKLnmSgBfFgRyd5vK0EidY6WM7", - "E/F7j20YNWJtmjzdWbmtrViyHnXSeyQGXn6/aQ4OlkS4OuG+6K69jWzm1KoVEth+r8t8G3agNOVyq04S", - "F8Hr6rsTrD9d9SisiRAniRFNkyjgxQ9CRB7eO7rkdq2PkMvGOR5+ePn+b25rkAIA/vTCBfQARQqRMAVe", - "1TThEYd0jquUipjFQ/Iy5pggc8Gp28JYddeBqFaaRzPUKqc8Pu3jXqVKJ4mA3+Fd40Dpg+LH1ywgnfGe", - "2HmGmxNs+Ei4o0lVbKFIu5ktM1HMDa2egwIKhKR/KoQETDy9p7KYxDxjUY6BN+tdbDTO/Z+qYduhTFnY", - "5nn3lXViv1u9pGwVXymELozydZfWSDTXVllxm2p94VvuxvttA9FwVwGAS4DCNvonFBZjbfyVOrbfu/Sj", - "u7urJxtmsCSE99dgqHe54Uc0RcYLmrsBdAg4FpbbdsMFozcvsszY9kuN63YL18mVe0OjP9fzWzdCqKpj", - "sKzrzZ1k06lqCecPGzotLYUrUb1jYHJt6dX1dxNL9wpWu73MqUUt+6H7Zvl4scsET2j6PRsz3xLB/4gW", - "uRyYGOS+idVFa+BxMLx/JB41Iq/6JC4QseIx8NuWYfwu0kkV0UyvuPLbkXDJAX0/1NpOdr+WMoBogYbv", - "LCDKbc6CNYQWqMI3M2Pg05XGyx2wAGI+Z0JxKZZx6gQ+q97E0jmLiUPjZVcpTBqQ00nCrnLdJEwgzGSR", - "6h0YEc5LXx76vGOaU+jTT2yhHBSsQWA2ADgKCNDgBjdJZ1QY4mn9FI72KpIZq42Di7NxXfnL0PpWGpP/", - "OR4u228Kl9BlbybaSwpcba0/8ENvgR+6fbKPrTO5FtORGRNmmetykkBA7Cqv86sEoIEmGWPrvK1f6/em", - "GY0LvXmt8ckP7t0+RB6s8ckH/Vq/dyGTYr5Oq/6FL27H31r2c70I0nIUO7wPPezwfjmIHT6yw/JxuXxB", - "27vpDP0JupwC2U4QNLONgCDApcQQHKNwJ5V6HWgQ1riWB8bFO/knAFgqXT0sxlg23V01xrC8uo1xxljb", - "GG/aT92Kjfq5onuleHbro/uO5Bw8hNhkd7WQ42ESvKA2vgvjnvCmHa/dDa02QlRxlmnjFHVsRAXBEJ2R", - "0FZpMS8SChY5fgleRKbgK3ImC30O5MaNCGj2GOmkDU7CGy4D55zt1wsgj4p0nMsxCsdj9H4bMwruXrXh", - "c8EAB9AeeiDcLTDVnGWqDXkQoBwmxhKzQ4ljSA5zkjCqMA4U2sfLlK2OrgaY5PfmLF5le3FgeywLYidu", - "JqnlBrPhssRhWyG273nnUKtD62nXA1qYySzHXpt+uG3Be0irMRKVucAC3FiTR1r9jPFXmWE4H/z12FnM", - "iuVD8ivcaK0rkb4AYsh6SPpGYoX4lW3b6E4b98XwpbvT5d5YGHnAVYzZHTGRIvKO0FaUmYDQm8pVfKBI", - "CBNyQ7pRJ3CzDnYCwgPX6kSqFYQ31qXWMm/2aiGDoX54c7qNDfZDCtFMEFcXJUXsfGYlpCteg1gmEpSe", - "snOvJ3BGg6SVPt7U2OmRKRMDJmIWk0d4g6NQOz+u9BRa4EDHVpnCMBPdFmw5lgiXYEIlbLgprJj63OBa", - "W638RwLXWmUNgQMD0/6sijf9g42BDadD8sP3AAXMKKSanC1yph7frCVVCu5WLSkw8HdqSRmjtiNxMark", - "hpHhs/l7Mg8Lk9p7wpjlLJv7t4cDb9lDZFWS4NyPhLVDvNShz8yQ8Lavz92KMAfIHZkQzYiojtB1uvku", - "+sn5lNrTPIw7N1sf1u97+4VHcL1GqJdxa3kejxBh85KRaRRw10H9qjdd17vF8G7BOl4sa21xYjjNMV6K", - "ZIzGAzjylCgopz60wylur7AO7CUE3rkCu4pVCgar5HGfKDw6uQslldOFQgSfCusDejbJ6TlbnEIKjL3O", - "tTHjiIoiZA4oGa73plwE8cWRQD9wc3+rwHZ0v6KpYX8E0F1NXoHW0ZcQ7+5PiJrJIonRvNY28oQIxgB2", - "yAVnNUyJ3wvmICMM5W4FJqRJyhN0Jr9hU5oYV3LWAjfbXmZOr8Y8vs6g+XggbVmw+uFXiiTQ1BpMRuHn", - "ZVh8D4C8XwBlH+QmynzGspHATDGTk3jJvsoYHuGBzBFD+GDTlIoRBMhrFNxmFyqW5YbdZBPPN5LaFFDM", - "nb7UsRCBY7sPdiB+eW2+hZ0vPNf+K1U4YuUSN0c9DPEY9bTEjnpzQ/g46lWCebdQ2ucfDrgrZosGcPla", - "/BUtGSUVkVrJAGDWWpragKcXNKcbrrpqISvXn02iGm8A/mZGrFalzeJydzGhozGY19VIMUDWoiTh4pzF", - "ZXJXed9O09RfDS8bbyAmYcZTdt0+nGApmzQcP6031hbYrmntBoKWxGaTXy1jDd1rMGj+bENJg9i0Kr+t", - "MXVawM8+vyC9u6HduoeP+QZHGz4Dnbs4gEa4mDWunBUJk10zaEeijJ7dLECrhgCzIlXVBfw0IRZNi9o0", - "rhdy5RrZdxLernTtqjft3FzxBgpauQBpmo4tpPx11FXIOE/TUkHZA4JzRNUf6vGwuch2oDtLotVcy6nw", - "ahIWztd9PcGTj+G17lc0UL0E60UtVNVf/X31vWXK1w7m9aZ+5XxvnO59W4neEeAhRF2wn80XbeDP5vGS", - "NrrItaWNtQU97DrX2HXSjM9pthizuYFTD+ZH6lcIvNIqYdVkSPjgJZS53axyi1n0OaSVt285xwkV1zhX", - "u88/h7P1JJPzcZpQMU5nVLFtphWfM6dFdAUEKsAQyRIs0fD+nLFIzpki9ILyxGEgWsLdyiWn/r4sb5O1", - "PadX4+XsRPZSRDhMHmBH8luMMDMeJ7BzhiVUDMkrmY2ESQup016ivYTx+vaK24b86g8J+AMan40EXAKb", - "N/ukEBbu2d3d1BvVRrD5ll6R35eRbN6RINCAHVkX2OXLePMV/Dks3s90U9Pz1uIkKhe2MmiQ7mpL7xIZ", - "nacBIsAhOTTaRV3yPJqNhIyiIjPBUiVGIeL0OfMU7yird3xYzCaXfNbKTqg4tpopeMt3XPYxcNeXZnKc", - "Ae7VmAmtCeO1MdPTTA7wUwwQga+9A5pWTBVDwL1ua2q6DMKL0LS+fe25oOFNlp+9/1rndGYifgPiZC0L", - "PedpCjdEEL9vA49V15k1zTpMU1O074E8NFX4NRDXuOY0P2iPLe4JFUEICmU7FGKTHcUAIp6zhdk+lymz", - "f0kee4ikW4K+u5A8RuQ7P9Y/gHyIaUtjGv93ofJuHBsVfFFovO6LARg9LAtE486CYQsJjLnV9v8oL8sm", - "w5eqzKjKMYUioR4wJnYHApKqgH6nuvxTAAgv0hSYop+7oh0RGdZhr5BV31Y2coRP4ELre6Cn7h24eBO5", - "AuwH58T2kr2gwUPyejIS9hPd9gxi0RKW6/qqyPjYjNiGGM3pgqjcRY5BwS3AiZ/gdmsiQyqACcy6AuqN", - "KJFFTIQfvIv8XnrERRn8YjLdkX778Pg1oUkiL9VILGQBPAViqgUNzk6qT34vWLYwIIFQKqajzanQNdhl", - "XMkxKRum3/xJCqEXy1vbmFGxv//kG+JcFceve/3eBcsUdmt/uD88gJSElAma8t7z3tPh/nAfmf1mINQ+", - "Y5k+RsGPU5aHErVVDtFHHp+8Xh4w+6/j3vNewlU+MKXoKjIKBavW1VG+sucRV3Ip/qmHCtIPaupCZrkz", - "7F1OuAkTdESV5MSKM/Cfl2ddiJd7rlfCANK14b/nbIH/0PoN/1WyX5+SR2Y5PoYnJRX2qY3pOqUqOiWq", - "mEz4VQX0jlavCqApMouNlKmICb3QUHpOdT9PR6IsxoJtWGo7CvsTfoPFYHJamkCsjVF1XI8SCJql6n7e", - "0xX3+j1URSs5rWWW29HvqXwBYjiR2TwwG8iVt3o+euF2TSwP33ot0/IHJ311rMVGGRo/r5kxY+m7ko3Q", - "1g8i/WR/H6kOQCEZgyYxMQZ7/63QMlivJUtoyUHJrEmn+qnfe4atClXmWr/3PfVRnp7tH6z+pE7G92z/", - "6eqPXsnsjMcxQ0NUFfM5zRZu4eMka91EtQH4m6ebjjMZF1FOjmhOEznVRsHVoNAHagdRaijXArR7PkxQ", - "eUddVSy4HgeWc97YqN/LeLG1OcV2VBxRn6oGkOlGTaoOtitVIQFC95aF5fz85MdOMUzuxgL0qd/cq/b+", - "hP++jj+hYGmDIWBjykluEDScB2xBeNyUM3zJyVltBwMdBvSfToWZ6nt1OVlXp5m4waayehaw/RED5PMQ", - "AP3Fs9Vf/CzzV7Iw3ASlxDRn7Bp6J2jM/MDyFbIwZfldEIT9m9IvX6ZY9XvPDtboyg/6oFWVwVJCrrPn", - "Fa1QkcCMuVQC0da8JSHc/g4bCKFca4e9sRXgPGAPC8FfCFZcd7l979EsmvEL2LzDduIhvuCtGnPOba4b", - "U9a90t7mXHofjAMnCRUx2JVgpsVZwtWsXTCP8YV1BNOU9SCYX6ZgOknYiWCm6QrXHNxgJwmLiX63zTun", - "i9mKb26nMpWm9829gvPSlJRD/eBjQBj2/qRpak6+7UccURWLlmNOmq6njXSFd1kXlfGgQYWUpvdBDcG8", - "w4yuKU3mOmPP3vAsVzOOtdy8DRdLv4DrVxGqVyLcTLrH5AcgMvc/MYjqFywr6feBpukUXcKnI5FLImiW", - "yUt9OEKqvL4LSusjSyUCilfRn5HaEQtTMstPAdVZC1cmE3Sbm9DJgHJ0A7DDyws3BhvcXribC8jgxDuI", - "pbcVVSjmMQzOw72FvbdYPRWADYTwf27wUUR/Q5n8+Jtkv3/8O0Bc9nFaTv23rMSOefzx7/sHPx2/+P7b", - "n4bDYeUlN50ff5vm7OPfn+w/eWbpPPefw//+fbq9OxQDNnrrtyimHfdso6+rz6Cathe6DuoW7ENIYhU0", - "sdvu1SDN+AXNWfnDUhOyruf3/jT/WuE/f2EcsfW2l2CydcRjoN9H3FfD2WpiJT0c64Qh3aAPnp8kI0ET", - "JZ3vN0l8Go+khAqnIm7Bw2316lve6XUsHTcwD5797RonbbK002Ww7A6g3hBtb7x+UTFqAAywSFzsScmw", - "VyIZlaLZtyKPJDGqT3KZ00T1EZD9cjnkdthAvyOiu3VD3WwBIW3/uhzre2Gw3/CCWHox0a7o9VKYF8iY", - "YNDDTRSiw0g33MvANvDcj6nsE4yB7GtrEdMTfZO+kexowLor3FBqSN5Xf0CUoho9w9/ImuwMLMgvZLgY", - "SlKhjQgYSMm/MBIBAgZkEl61Y3rEusHbodtTDbu4IQowrd3wHdH6mukeeTbbFMMNGq8m95Kvck+U75VB", - "rTaJzcVtLpRhrAo4AbyKdugG8Jp5zTDGSMasfu43kYwP53w4568z1jBYkkwaX2jRWaRw24SGoEwSean7", - "iOG8MP3PzYe/6Vc//h03te2d2I9cc277zG7zjO/Zob2iE5oar5yfNl23pmrbM5LTetnooiXxRduwhV6k", - "iINqzhMYiW6YXMWULGSREXkpzIcjYb/0k8w9EKyWCEz8euAS4XcZi+ly56HOWwrKdDnWfltCgl594/OP", - "1qwJ2I3I/d6ftrrX8ae9SKoc+KNX7fhS5QTeM8mK5aJ4JbNaR7hJKMncScXBgQmvIEAmjPkEwDtycsom", - "EwbsSmNkbIT7hzYDomz3OkZ52eXrWuWt+1/Zr3X3v/KLswWZcOpU4AJz7ZbvhiNhtkP9JRCgfPz7h5MX", - "W9wQpcq/181bZz/s3737bdN+rr7offR6Z47a2t6OAlqZhWAr5A1l0rolmuXOb3q5f9zp5msl9Jb3XduM", - "4JZrH34Bu60Tu91stOhk8zfS4MnXvrbTg6+pZFvpe3DWrZ1/vRvxh1OwOwWvHPj6Idh+cLYAeJn1jsDn", - "bPHx7/PFID4b8HibZ2DTmts/AmND7t0RuFQOIQVln3709tglR0iY/V2eHasIdrd1arSE3aHzogHY+kJO", - "isjpu1QwWjYlferDfzbiEIL3+F5965hbtuiHm/yd3OSvPfv9sOUxZfndmdH9W9EA9+SKu4OkmNvp+oWn", - "YtntCsuukuI22q5uR1gfkuRakuRgWLa6F9qAvdZTm687B/blL1aHIrRzu2j6UNP3TKW6CxxAr95Yv8a+", - "fX6bArVrPRuAN79dldtFth808LI05c2WRBd1vEfTdGBx6ruspIH78AtaUi00LbeznBpEAMEksDAjzMNq", - "Wmc10TTdwYpCmpq9aMaic1nkA8WU4gaLbsWFzW+GYebIfEtO8NuPj2Z5nqrne3uxjNQQaxhGcr5ncAaV", - "q+7xSARpF7AORWijcLgbsiiGYurQDucsn8m4SiySYbSF6T/6kU3/TLwGBn+OeorlRTrqkbmMWd+gdptK", - "SoRHE1U+Eja2NZrRbIpkut588fmcxZzmLFlglQ4asd5YvAYfCUezNinyImMVyF87/TAsr2RGZhK41OwI", - "2g6pPskYBrh67mMDQ+nczh9+eWMgu9n8jMUxi73vC2UIbRPORD5WLMpYjmCKPOc04X8wQyo0/G8Yt4Us", - "spHwVMeK4BWWDVAYBnVx+zLUcs2ywLEyXlHTYSPFt+scPUzTpW1TRZIHTSJ43Xwa+ujz8qjeoE43OrNF", - "Ye5Eo6cyy2myvj63bbNq7Bi+t00E9fNBsUmRaI3gVE1F8xlt01JSLi3eaj5jPCtRZ1Ebqr7Wp8I+bnDJ", - "UBETGkX6n/iCTXuYcZXLbDE0eRKZSR368MubBj9anbCHK0uWlktCiXKMabq2cutYW61Vx/zLV2r2Pg66", - "fSdVW7iFaym49k8f1Nxaas4tO1wWRG1T20VI8L8qI8He9OHbjdxC+8JXyr6CtO40YyVdL4sJVYRx4B6Y", - "JDQnE8aINqIAShoCDmNXRVtqg9EUtt3bivPYqUppiSMxI7U0mKFTIEklaKQBnjCEwE944KjhvAd3JcjD", - "EzEvksOMlYPSWBm/GUQ5sJlzFCJht4hIcITtWzOYs9rxl1ep3pQhPxeB3jFyz9G5x0gvzc2olCJxQZOi", - "KgkZo8k453M2hjV1+pyY0mGVQiO/0hJHkwEwq8NbbejWDD6tjEMX/gszJtiA3qcmp0VVIHYa8QJNeQhV", - "XRGqWlPzq3aY7tGptRpWG4Stav5zNAHtMVF36ZbDeqANQdMNnnw5IT1G0jYQ5fXMJ2BDUXslocqSE+Kh", - "ZWcp33Y50iYIc07PmT7eFTTx3lJ4riqtrJEwJZ3RhIqobioUig0iqhziDzIcRjLLkLOkddlBoQOPHeZL", - "WnfQuZKo5pZXYK01Lceoyjtf+HkpiLjfXDK7XspmSS0HJSS19RfEPCl3MVxXtuSbXVQNexMPbmgRVnqh", - "j2eAhcEV8lfmdJ6CanmBoeWq5FYFFiZ4a93ocFfi2ob1C5qz93zOgoeHLRjuP7Acl9j32P/bjsuuqAbT", - "JtWuGOwb9wdgxnczVCR31zoB+MdWOUk85rVW9wUqAlPcjeuBreTA2HO6392bIE7yiOduP4OibMvDoXLF", - "odKXk+2fKJF1qcJ6SA4rf5cOSAUI50kicc71XpdmLKU8tvZ0zdAerjCUofwvz0auMFPepnkMDWnfAOHx", - "l3+JsP/d6g+OpJgkHCgig1Z0fZHczIa592dUTtRKoO8Gd2nAor69dddyR+D373OIRF5/Xd0fq/LW18Ve", - "yTu7Zylm291IJrANeM4taa773l6PyIne7GxhyYJMChGzuLrGTDACnviYiFPJBUQqqYWIZpkU/I9aPUDO", - "Wy3bPbzk+Wwk9OuITkaUxFvAjF0wUWijMJJTwRHdR7i20AvKE3rGE54vAEMRrgmvUkOD24Ia6KuCgW3L", - "oByIL1Q97Aqy0Fv5L81gnrixvOUI8/V11v0DNKxYum5JNvTBLem1C8njdkX2L8njmv7tk4nMJoznNhw0", - "Y3OK+F8Fxnf6Hu9/GaJvoLyeyOySZvEgkfKci2mf8Ewrnkzxs4SVuGJDcmRMfZpkjMYLEkmhijmLR+Js", - "YbiysVZSCAqoSSwm//O//29kHK82ynrOEGxFN5zFGK0K3RkJXYXSCu1UjwWLT9399SRn0GA1JMcV9cp9", - "0nIWk8sZEyNx2uRuB95zZEDva2VrIrkGZzQ6Z7HPV54syuhZFzCmPOZx87RKVI785Abl9dTcmdsTvw26", - "xW79zaOgTxE7oq91uFYUQHIxKbARONTuZGY5NyJjvw4hriRbYEmqgEC1SZFA8TDPgvCYzVOZw4DhC81N", - "Qr9+H6zF7W8Hek2Fj4EPqv5zOfaBYr1JszbPqFAU7hbX85L6HziYKi9xwbHxCMLnBq67T8AmlYmc8ogm", - "YE5msbZGTaFzeQF7nnpetXYV4tY75WN+HZL3fiswVq10Y+LmwWqVAiAO7BQGbme5p7cyMHfN33tUZEpm", - "XT2+lam7Mb+vP1V3w/vrtWgt/y+O9v31ANeWwk70EcTJoeE7wCD39fDCBoEPv5wsdB986mXZ0UPopxXZ", - "tmxDmMJajC+agmTCaF5kDHMKMJmAGnvsngTKeWJDnNg0Jdsb9GZgttlH1F5OrwaRjJlaipYgsykV/A/4", - "cWC+HZSf7lCM3nk1m4CA9/TqCKoNCM6S1++Lb9GfKwfPl9MrYueqKSo20mI5G3vQI7aGZOzKe7Rkrm/J", - "d7RFYf2i86tDPqVti21V37ELtjKWgospA98HvtxiY0N5XEwHpsiuuSAd7V+sZV3sSfP22YKoAmzSdRGn", - "zesff4OEBWugHGzPoH4JLdsoVQHyVlaNw3rgpzlvgp7aaS8TWHKZlSCov86YsARHfdsMfWxTjiMFigUA", - "01PyaC6VXraR3p0nPFP54yGBMih8oUecJeBVSjN5wfWB0dEtGZzVPuEIqKo8VNQhOUxTZpIqfFRWIH3F", - "Ptt3wfmVO+BVC99q3/MKveH8m93yYuI8gqR9wYejpmVoVRJxKsnqyrf2CS6/TrEuOJ7gDYFytUyd0Tya", - "ETmx66DUKlrajhJZ4PArA+zbCi2Aiy6gTNczFyJdE37zH92kxI4INBMGs6XcAfQ1UPpa2Ui1auppSLVq", - "m5VQsXg3ad1O2mrZTuM+rmU1PWlKzPsZs4IxoxeMnDEmyl0VcsAz/avJ4tYnF0jPNPe+slDJ4vNZerg+", - "uiy+mk1iT7LLrRKaJO7M22KSuIJ2iD/ujt3X3IHP2eLU59paysNt3O0PeOSeQbh6IqomoXv/bIGyOubx", - "ulahfd8kso6K/f2nEY/hv2x7tuErbOJte1hdM+4VQLmnPJonrFf24UZBsqbo1oBW83yniOamB7cUWGpq", - "D0mPefT5Jz2Ws9hRfsK74d6f5l/rsqub17V+43Eri3nZytUOdteAB+zznWCfbywxSwnJV8jBlOV3RQj2", - "b1K/PMDcNF3k1xDAVJ8Kl1CAV6XQMBDlyaKM4yoEz8dAXISeoDUJq29Pdnflv99ka77RpXP/Ajt3uJcD", - "L+UeHhZagzPhLIQXv3qByMkyKxLKsusC+OS+iMUBow0DcUNhcGZij6TKTbVtEGvv4ZgJjSIzqjASksVa", - "a32xKwNF0qp1I2XXWh1TecEyQUXE1lsOtm4DoIiBawnH9VEi5FoPiUupyJiSyQVThNFoVt428JiJnE84", - "Yj6WIXDgoMtKfLWRMBWa2GGL9WsEgMXu6NgnaVJ4rphqmvRI+LkW0MzxC6b4VKDL5YyRiCYJi4kUernz", - "K1C5k4ypGQHGvgua2GgP46ews0a4Ggn9DgTe2cKiGYuH4xZ9UY5+a8zNZjd4O1IHP7j21nXCTe6WjVa0", - "u0U+TyURWPOlpCwLsylHpo1jMs34Bc3ZmqSTSTKHvWxPl5vxeJV/OGXZQO9sKqURI2nGI0bcpy0OY1vH", - "oKwjvHNe37f35s1bvbEc63Z9rrTD0Ph75hZ88+atscE8EWlKv35Nz+9mDsJlstvqNWwI7478h0Zy35la", - "sNE37UD0l09Q2GDMPnsfYkPaugvbKi269yfI17pexW6iaZyMIdFcfSAx7XpwNu7E2bg70YJ5W7E7TxN5", - "RpOyEfjNkNhUE/wbIoBKTUtAX2hTfUKoWKzaxE07GqIWvD40Ddje5d0mG3zgftkMxJbIrc1hJxvaH+Yy", - "Zon+q3bDzCDVkl+wcYlTXP6Wy3t57/xgf90h+8ut7m0qrepmuORSxYZx1dpDzhbk9YtSjQFcAzxo1WQj", - "EVRlU1bXZLe7Z+7fmOl2H51pWqiqknRdwbZismwTxneWxXPvNHQKv9hB4BSdTjM2hQY8RFJ1j6RaNS/V", - "OCrz9tmCnLPFigAq881v52zx8e/zBcrY4Jwttmd2wUK59aRUaMU925mdwqjEeRqC2OX+Dvi01bEBT3ca", - "DAUtvaVQKKg7JBWo8j97F4advYZUhParvT/hv+s6I1rkxngdbM2rrSZT6YOnYSeehlYJWBq2BF8Zezpo", - "Hd+B6d2/KS1wT1J0l0iKybVtiS5qUQQmROh2JGVX4UHdN6sbE9P7FxjUJrFrns/K/W69kAerFicyM2xR", - "wDXCcnJ6GEUszZ+T+uSekkfeqeWxPoJM0YWRZ0WUFxmLyX+evPvZt+8rBebsKt+L1MWp/jSWlyKRFI18", - "RecM2Jv10YiSo5N/EWCgVAWHjutmjoRKAXZtxlhu6Ir1i5FMirlQfX26gNNP3x3qTieZnPdJLvvE5t/2", - "P5LfbDzGmMd9F5wxPmcL7y+9jPsfCSZkxHzOBPCEDodDzM3oI0tXedYz5Z+a9uiDGsOcVgxMvJwx4b3F", - "lT0NwXR9pUbidJrJIh2fLcZlfafYz3yWMUZOXev+l60GE2VtRbmcMqDh0zWOBFbp9TZQLQnX2hLa8aXo", - "v2AE2I2rv2osWL9n14f+mF3ReZpgxT/oGcJE6EooUTlhUHG5Aa5+v98D8dUnY71Ectn3F0VlTVSXBLj5", - "+/kiZX0oYSSe7D95Otg/GOwfvN/ffw7/+3e/9uMB/Lh/8MM3X//7r19/ffjq18Offnx58OTn/9o/+ud3", - "r37s02jOBlxE/cNozshrEQ370zQfPBvkRXYm+1ykRd4/eNKo7SBU25Ot1PZkv1Hbk1BtT6u1ff/0v/59", - "8NMvh9/9+u2//np88uRFf5rIM3bV/wH+Q45kllZqk0Wuq3um95GfJYHlODhbtM5uyzvNGe08P93Gt9v4", - "PMNdzy0OkxCr8oyL6YPz1o+K2tgSSBMq1sh1hddafLVYxA5dtVDBti4hnccW8GA7+WjviId0xXBsz5t5", - "rCu6bWembsQ982XaBdW8gjnOZFxEOTmiOU3kdHOWFF1Fq8tTP9ypx1PP6e2SiugWBAUooeLz93qaCdxM", - "fgL7w96f+j9rB2npMVye92kauMaNMtT74BrdiWv0WmKy1H26TASmLL/9+d+/UYXykO3Z9LZeU/iWe2SX", - "yZ9xy96GCO7CKatYlnfeT29W/L9o1MTNV4GR1p1t1ns0jleCsNM4HgDkuVIy4mD2QLAYbTER3YlvYEq/", - "uSV0F2MgEyoO9Tg8UD8uh0m2YjaR2bU1f5hQPY6B0hHqwRTKlWccFOHPfxMoD1Ugi7d0snL1t+0D8PA+", - "EZeDTDqB3LWex79hkFec1H5hc3nBvOUyyeS8dcF4R7YbXzD91rJNPx9OhtsVWSsanlzs7JToxM/aHlxX", - "CXn0YUm0J8f7IIb7N62X7wvHZ1jkdnka7Szn3gn1CxX1XR6Eu9tAN77W7h2NwC5W3XKTKItm/IK1RzQd", - "4gvWV2QuA5tr0RR03zyW9yiWzkqCLwe7Ecq0OEu4mrUL5TG+sFIoTUEPQvnFCqWVhF0IZSYnPFmVIn+G", - "80Hs2y2eQPPawBW6lTCQmxA0bPA9iyyoz2pQpMwIkROW51xM18qhEuyyXjgEB39fq5DoOaQmZEWZCsAW", - "sF8bes48k4myNMYjMWXCkTYfiiotUUQFMhvMiyTnacIa3SQxm3DB4iE5HInaQ8IVSbg4x/xIL7eapumQ", - "vJ9xVTFbuCIMFhdXMxaPRFxklmijVvBXCn1dluIemaJVSWLa6pusLaqdhmJUl8MtB2WY/gaWX/WNzz9C", - "I7hi1l2NYX2+9ydfM0AjtFCB2FsV0ay5eAwUbmy8YPmM5l5gnZB5JTHZfGYfpVwYREEqvNDiQukq3J8O", - "mkB/BqHvsKAnXNBED7tVBKrNO9lcMquNIv7gPdxNXAndVLCXxpTUpTboHrwrcrB/e7rxvjjyNhey5bEj", - "K+XMuOduUdR25T67hjFwiwJ///L+6HYsB1WcuWFdwY5dfXWHsf6VirYV8089MLFaeD+915hiwfyCyhRs", - "MZ3gxC/3ttMK/MY8BO8sD96pL/6mqqlMbcVfEDzg+gXu6HRrlJ/fsNvBig00JCRa/vMvPEZGf/Dd6g+O", - "pJgkPMrDB+iaCK0WySVb396f/p9V+L3mEaNW82qjr1r4Z3DW6CSr9+S4sVN5WytSV9seNowSKFj8Qlrc", - "8/4rXQJ2tyuy/V0ZiAS7tImZOBIBO/EBqe+m6cH9VfMQSN3RFiNuRa9UR10jqb0w6uVqJmDRdYhZ2sHW", - "uKuLkoak3tJdSaMdq3bo+xB2vRWTEu9k6gtssN5+HyaZWXoRv5ZNUP3dj+7eKLB2+WKum7e3tpL7K+v4", - "DAJvN1yp9zsQt6udfd1VFlERsaQ9JOsInqNFV1k85FeeJHqytI3HhV5b0YzFBbhcI6NoCJ/oLzNGaMZG", - "QgLQVtXFab4yRl9OtZU60R0FvkWoHUcn5/NQyAC8cScOpTfjxMH5up07iU4H4y/7WuKaOy7M4o4P1dGM", - "iumSEOCjRCqmCCVZIYRetdWtX8S4HJUxDKQAxjmZwUksl8jGaMOFTGzSkaEN1oc4gElMpxmNmeoDdqH9", - "ty4bIvuwiYHgOnxwj5Y1ztXtL2tsyJfHpHjTCxyGcccLvBB28xx4G2X7gv/g3m/u5/5WG7jyD9f04P19", - "2OTa10Apbq2StsGayOnVIJJVAtKA57d8bTeX9a9FlBSxFxVIrwjUF8KjW8dbybHAsSmwFwB+PJMyYVTc", - "rIfyPb06kvF9CxR30xmU0Pf0aoVLMegktDK504BmM1+3G8lsGhE0H/DR5x/CbEWkk4S06LK9P3MclgZy", - "QTDa1xOk1RuwK/kh2ncn0b4byUG//X79rkzu/i0ohXvi+9tQZEzcbj0aV7HsVqVmV9G4m+xktyG0D/Bu", - "LfBuMCybbZO6JJZdhEmD38iIJr1+r8iS3vPeLM/T53t7if5xJlX+/M9UZvmnPZryvYungPGecV22wpNx", - "Zk7GEJ3Qe9779ttvv4XpbWQjY2opBvlM8bRSVqme7+39ib9/GtKUD8+lmM5+H0ZyHqjWFFCpuNDGJRPF", - "XI8J/lH0+j2q/2/OMO70Y6hh5fgdJbKIG81yBsYw0s/tSOjVaqagcW0mL1gm9LmMsAuaFOhxlxOXoaRI", - "Lkk0Y9G5PtzwjEwYzYsMPIJMgQPP6JaycWWhgfPTOy+DcZCwC5a4gJFIigmfFpnzRTRKfoFvql7rpJEI", - "84HJnAo6ZQoxpfs2gAhdkNgT7wZGNa5gBmdUsdiGmwcbU89AbrbJcYvGNKe6QIJM0FxMiZDZ3OR4pRmP", - "9E/A6aIbklAxLfRxCggkFKFRJpUilkZaDQnyWwOfiVqIiMUIWeQSQdkV3sgSJYsM3hQxoUUuBzDI2ZzF", - "SLKSz9iC0GnGWLCPjvo0EDSNgqBIxtKMKSYgBc7MQUrPeMJzzhQ5o9E58mvg3tQ3pLw2aihl2aAQPMeR", - "Wi0Dtt5Ak967s7geGBtQFNEkKhJjuTOcaifewSq0dmqWflRkGRMRN6MJzdWTuk6J5beBgm2+gksLtrIb", - "SK7Fum1W4Bo1N5IhmvUfpqkiTAB30EIWesy0/GiJ0f2E4vkfrJKpDDRI5FJm55NEXgIRKRc5m+qJE1Oc", - "4lIIFypnc2y61u5IOg/VRlSAXM4RMSgmTMxAHS1kUeZGs0hiGboehaFtcN3oCxokcVIFC2KWScH/0K9g", - "Q2FpQaPyGc/iQUqzfKF1Qz6R2Vz1nZDAFYcWkz6xqdemxzFL+AWDpGc7/H0yoyLG6aGLuV4CkUwSBnsH", - "qhq8+bQpUxlLKDqN1Hl4uvSgBKbopch5njBdRU24MWPcqGP9y8Suy9Wy4ZcaCjus3Nf6teYZjc7N0MoJ", - "zpVd/FqR4hwPqx49m0/LRcwveFzQROmX/ZR2hUm2+kWjjM+YhRBE8YH02GZng92r+hNDC9rucZv0rfz6", - "pvvlag70Cd6AJXPRkJV1e/ay/DTNpG4Siwm1y0oWKlnodai1k1XpSuJOMqcLyH7WwzGfs5jTnCULQi8o", - "Tyw3GbJpVXdV12ysu61jykWHzuQlROkZzmlm+1tHVKCCJoucR4qkRZZKpRWPKcpMm91xLACw20M9Pmvd", - "z5mMcaqAUEir0iF5a9+dV4s0Li7dGMfYBg0kQAaFylY3cZKwK35mC4BNIGKCZlyq+uio3qePn/7/AAAA", - "//9wu2aaUkAFAA==", + "KK2PlNYLnrD9xPROGZcnrE+ihaGP8uuj/NqSX0Px5vcnwob03z3MHqn0/2fvDXTbyJH+wVfhCQtM8v8k", + "2U4yszNZLBYeJ5nJN8nEO0528O0okOluSuLnFtnT7LatGQT4417hDriXuLe4N/me5MAqks3uZktqWbKd", + "2MBiJ1Z3k0WyqlgsVv3KRgFsZuS4z1faNk6YxluL9VkXbB5uRjRxUEGjjOEGSIwzoJ6rkXAUBsoK8txV", + "Diy1gletDLSofUOxHG40T4W8PHUl4SCsD2Mm3VRsKWao80QUIufJujNRmQVbCzWhmEVFBTmtLu1pc/pG", + "gucuirScP6RCFSnLlCuDM+E07wiAvYadqVutBSmUQFJ27EN7x7otBC9oGi5lXWeGhGZJ7XLchoYlMgsA", + "g4fxfxcKwBA3FN1aK2vehWxjbn7IqIDSfUCCQ9Dc6JCxQYyKkYRphQo1fLgb3dgADO9l3iZmeGcVTwNj", + "vOKJJqLrzR5+VUoa8hYsciDeFDfJQBzFGz7neaOFsnITj+wBShlF5/6GCDKXJmzCuiut+CnImL69sF9X", + "Yst+63GRFvkYkeh6/Z4scu/vj2uGc9Qq1DSiNlavxXGRRRuUaLSfAW+lnutcVYQvoGMuKE/oGU94vhin", + "MuGbqAJUbF5Lx9hQNS1UirGtt9SeD4qV+B1gdCTnjBgaTQpXJIUq5qlDYvRxXE69Pk6HO3GiHNWUWupm", + "vlSqKcsAY3Gs96MxbHWbanE7eQfD/V7IFjRGRMoyKz6AfOjg1mwmRpBWUyDlNEAvlILYH369j6ES/r6h", + "n/zlYH9/uL+PlU4QXNgmfOqnX+uHUDLOgFxZK2YK/G7smH1b7rdqDpH9vqZ/JE4niJtl8r3+DohaLsmm", + "vvYHw/1hoM6xWf61FOF19vUfUN98llu6mYgvZkcv7eMde538rQaVlWduNzi0tEdzPBVo0dLN4iHlKuUZ", + "U2Wu7HpUm9zUF8svMGPrEKin1VaGYEhoolWyC5bhUy6m5tTgbIY1OKtpa4An05fuDXedVwYP0WSENgb/", + "yqIhYiJzdTPsGqFrq8Isj9R9HbN5KnOQk3O2CBpIZeVBqypceaDy9JexQlm8FoDy1q1hJXNFqCA/vn9/", + "TJ7tf0dsVoXVjUROwA6iJk8sLjAA0gzcIZzRc1b3Iyii6IQZbNhsMfysPaQy4/miklV40IDIfZHRywHg", + "QdoPqkxC3shLltn8TcjKm/HpjGXu/aGfKs5FfvANEqv1l+5xfx9oNX+GIG1T3+jrorEDdmMg8AKdEiZC", + "iBixK6MK8eZDkUdVgbQgvwhk+Xi4qd+yQWo3D6aVHlwNzSeAoG2cdKZ6lq2fdOpGh2NQ/UAWsqvENBJW", + "1jS/M6EAJl9mGYtykrELJsCnGMmp4Ai7jxXyK44qLwq4dvaoVALE26U+4ROI1f8K5xYcV3pwiTyDTdEl", + "FusPwZbCOnEtB76aCt34BLhp7b/wctHqWRBS6dpXgXRbhP5IYGUQvcqYUotrnyxg8VmM3d5OzcH6NaJN", + "HHbJ7cPNSs7hitl9Z63Kc2tQ8mnJfUBgJZdc4Pum47ZOWq84zSETH9PIKs7EZtHsfu9qMJWDllwv1xW0", + "taGdX2ljdfaXmYuOvjRsvX0bdSHs9jLEOjjJ69wTKloH8/cThcrw9ZHIW9rrE1VEM0IVGfU+nJAXMklo", + "ZtOcXhaZxISprhH9i/mZTMKjwmcrxxUeiHH5mxZwWKGh/GXUA852Q8IB/c//+f+aB3poMLAN3G9tVeIs", + "D2J4zKbcZ4Nr1oxpMUX3O2XZwQfL41lMs+UyIVlD8sEvG4+1ICyqeCDMxXV2Ay6aAI1mNP3lxN6xUJg1", + "SmQHTyifsQU/p9lizOYmXT0YtKBfIfBKK29Wwxjgg5fQZuhyGu6yaY4l9zaJMLaSCvFoh15DTU61haxz", + "SWyPZeEBoKT0GxjxtxVDLwASqgAdU7kKh68q3banC7YrKxOFtGHSjy05tUJVfR4ydU1ZguVcn4nM3EER", + "rKV2ni1RUZYet3FmzcrjII8YzAYwMvr0j+zF1UiUcD3uJrl6qeK3rHKa88jnOKzXlZW03plS+9al3VmE", + "zSJg3Q0VyiJz3JmybFBgWTiV1wrC6f2GjHoIOmfsC0om/IrF1e/6RGYjMeolyXzU0yKfSHlOihQbhSgK", + "PVlv3rzFX2KaU72c5ZoiK0wzWaSDswWcbI2g1eJksMPNlIJhyk1UAjLJSvf4dJqxacfEDmj60PuyJeev", + "fMOU7JdQWMc6GGAGh3cm6nXOhOJSLLmV/TPwWYXUn+mcxeQ/T979fEzzGWFXKeDMSgFOXXaVa5KMc0UW", + "qd5ajJvLcRxuM5rdYEw/sYVydzkGBMCk0iquciwTA2ggAi8u4Kk+lWcqkhmrzYO7fnVD+cvQxrU3WBBI", + "GbeHqCGpdmVN9VBbx81b/CqmSJrJeZr3VuoSaF2NtwqbBHcAilsEBhRhc9Sx9GO/oEkmRQK34uc8JTKJ", + "3aPXk5Go6WyaJGTGVS4zKI6Db8Jtua2qOryZze9ubATA1WObQNGkJyAidQnBa0wnF1xMmdK7K0ztVwpE", + "xGndhYOPcu+Z72VGVDHvE3ox7ZM5F30Y4FwfQkoOVaYouCnclhE6Ev6p1wQ1pDQzt7z2XeceNRGWERak", + "LVvuV4mv3s3aozUC/8G3I1HRmnYe3FRCwPVUSFOErxSrvwxdJMUGB2mMpPQ3g4r4t29QxwkV14D1cZ+v", + "3qj0Wx0BbFZZcxZiJZAlkCa0AutzCK/ekb1KC8VYUzhOu11iLL9G01Nyzso4i4QKAh3Uo0rNvNn712q0", + "iL1aqWQq6O/L9jYy6unV2JY/C29H5gLIK78IF8g+xVaODYklzDIst5bCkUB4oYFFdbEARIj+MOEsiZ38", + "mkKZKL4ARNT4bCQuKyU1C5HwOa/Ug6sTZXxh5e2VtfrplfsoWKfx7obJofA2GXe5XtlcpaztsotozESX", + "tI71Lv+t6840b3YhvzqGvWfmqqFqvq9+vPvENB/QrE7M3XTI3TK8F2qL64B7gS4MQ3vZV20N1y8G2gtE", + "vgXWq9wblIFnNZUiEfM4o/PUnOUr4Lvk0GxQ6pLn0WwkZBQVmTKnIgcaCqWTavmhQ3KYk4RROEMx0wyU", + "OEbt1RVQTKudY7u5zbl4jd96+vu4HGOvCUeZZnKcQfjIeF3AaQuPlWZygJ8Caip+7SEW1UT6uHzd9hTE", + "MG41E70r77oedavcrtmbV6qdb8C1UivdX03tjtlNyxbtw5vXLxqD5PESsv06JdcweBvN3DXDtwFu3TCA", + "u2qf5VabM4OqcH7kEGGXD3DvBJuM1I2rNkvpn8uspJzPNylXWqlTE/P8PTbTGrmoxcsMqaxjTw5dZSaz", + "7PromMY0Z31T4pIBXKvJszIxZWV1fG3RJlxUEwsNJTVutjaXbzLim+1MbmRrM9a2grkG+ODYwDwEdgN7", + "QaNVdpqCdwlDOU2UheqqmA1Zh2lqmvYhHw9NF34PxBHX1NL34v7k7p4jjJvCZ6AWZo55/j2Wxe7KxWXc", + "qK2rfbbwktp2BzmcMRq/E8kCN3u9bvxiK3l6Rya5ozynY0wyVAaBkwaGSCcLort0qf3zlEa5qiOu7w/3", + "93sBak1BwW0SDEY4BICeacayse9nRQ6eVSFzsmA5ucz04dqVF09YDIXCtbmYsZEIPjaXdGRSwDXbmZTn", + "zIaG++P9um24mJUc73C4hibjBjRkU3fXbrnTRclXCT9oobwtXcOwWzmwckV9wJmKZPRaZQ8jZO88PnxJ", + "6y0hxAMB7zMqFIVCS9edrqMiU1CXf5cT5tG76bQhnZvNWRVutOOlqBQsp9nCJVYJfaS0WY/tWr7MIlpL", + "xKsem/X9NHUTDnvtr0iqqoWC1vezjDFbDeC31yfvnj05+Gt7xQH9dGC780sOjEQ1HNTVGvDbr7zSVm4A", + "ikO11Rt4UTUUnlbMhKeBggNPWwoOGEruvg7yHGy3oIBKOQxUwYOWTck+ClfSjSGndMrWF3Y9kw0aoYnl", + "xB2bXmoZzjwLwcx9+OW13evhDQIdeBkjKc1nvWBa+orm9AtrtybY1fLW9AttrYkiAUvNOn4CkXrsgstC", + "Le3BvrRxL4r/EVAp5njIYmiXwEueFB/su5bQg9lYcfMFzJA3lHYeKFnxnwXLFpYdOsjwC5azbM4FU+Ye", + "C0i3YYtlcUqThsXZRajaeFlUMzAf1UXVbWuR6Zflw5yPResHV6SZ6+XJqAmGCSwCAjAu77ay0iu7NqDa", + "a/QdZgCIiHe3bFjL3IsASRlYIH7KgPO/BFPyTaTlZ6CrkdDb0tU2mn0zx6mLZ78xz6mLxmlWP/rl1dHT", + "p0+/Kw2RXMpEDTnLJ2CLaJtjL5tE+qXHBBWXXtCY5mygjzz2ooaLkfjw/mjtumBOB7qWPFeaoYpowgfv", + "+TwIpmVH9YqzJMbsWlgJsegUoNRfsXg1bKnftxIE9S+IP9FjifRxn/1e0ESRKb9ggvzy6mgAoy9nu8zA", + "5oLALH/q96b5FknhqopQALFxHclhO6RHZjhJdkvtRluy5alKmFKbzlOy7XkqibnOJAVqzLXh3kh/2Fp8", + "QQ88sv08NtEZEDA1JIdJQkoZQleQNB7av9kUSMKuKEiCFKwEwDGYh3Ke0oyr6j2InRkC4k+M/Fdz4Uyq", + "/hAfurn0XhrwuT4QoQWtjza9Kc9nxRnU3pMpE7Alc1n+e4+mfO/i6Z6FAdATF8o9aajawEt4673mhTd1", + "Xl44LYuRsPmfDvDNV737B99R9mx/Mnj25OtvB3+dHHw9+O7ZdweDb589mTx7Qv8af0Oj1c5gW7zR9mSJ", + "Jz+FMVpN+HjnsqARTQ2ADjE5SuAfdcHAREJVWcDBpJZpsoAXGK9ptoV+sS7aHTMRRBbaQAvFMOStjFnC", + "bo8+6H0FfbdfKa+DLxeNoJDP/iG75SG75V5mt/R7eI99WzoGfDNIQpuaaR5a+i6RuNTflYG05+eYJdXL", + "CT6JX5gyNew6bED4EYYnWZmABfldN9l+aG3B4dSPSSYv178jb4xCXoYOt1tLwjjx61brQXJkXS4xP2JL", + "aLEvy+rSjU5Cp+61FtiUm+tiXmTy0kZuZB2XupueWQXSOk8LQA3THZqrj0eosP+//4c4tfF4SH4ukgRx", + "a2zsnQGlcZfHI+EAYsAQj+T8zPqJ5aQ0nYAJV3oYby6y1Ru7yTnLg0nOL+B3MmcK5gfhEb150/MBiP3s", + "Kk0oF+Bemy3KPiJIJ9JzdgaFC5VMLgwc/k6SzrAQmm3Iy53R+7bJ6NBK/YJlQ3JqEpgNjI9Nch7z+BSP", + "SFq7Zhcsri1kQzx2V84eTnVnRXTO8uWD2V1J+k4kgBxtS1SrqehlDpNXKL+hwpCAPqqMSnhmWei+wmtL", + "1F3NTuy6nbkQaEmosSEapqMPB1u/0FkBi7t8ZkFN45n7BGTlLU1f52zeFBnrUdBkpmmysI4LT4wMJzjX", + "+Jxe+ZTAJUfFYPW+teMITPNGp4xA3e0XFQJhIHaerbOfK3+mq8Su78M1fHF3ffP26H8rPnkH2rCZwFjY", + "hhvzyL+S2RmPYyZeZlknWC6qGH7yqf9nA1PCbqSlF8j149egr75yLsX0eZ7RiD0/ePL02dff/PXb7/bh", + "zimnOV5supef7T8tgzZb+7GZyuVje7kA/4VmmQIX27P9p0HX46d+7weWV+IHj2lG58rz83cF7CbS5Pxo", + "PT7FgsIlzpcJpdpGYCEqPe9a4uUVXeJQXRrm2KyytCENXbqflIWYhuQdgJRLA7/pwR6nMssnMuHSeHpH", + "Qh+LT9kVV7n6OyzEqfch5IIU2q6BWw8Wl1MevI38QQq2Y+nQXWxJMA72w4Jhu+giEwf7rTKhjR2hSTUa", + "6zCKLNJVh/MQfESwU5vOg5H9rSbBjKoxdZ21lYf30HrKWNYZVQQ/deEgppeRGIlTfSA5RWgqTHoBixjd", + "UehUwKIzJi4TYpnsGQiTyPW3xl4bicoXsANjNRAt7JbhyKnhTodn7DnCClE2j2hqaANCvigMBqJCM0aj", + "GYshvPVRrQTxY4fj7qJIR4JdzWihcjyBVD0ipVXwo5urYD39jFHVJQmlhV9+wWaWeL+wIw/v2S5rLBme", + "Q2Fk4WUlxzJFv6PJuj0tuQfQ1c30L5sIS2JtO/XY8GNQZywbb1cjGqaA+rwBB3Bokp8lxrr2sbZqYSoW", + "2GqZJd2wiQ/de0TlWRHpvrFkP7vKl03ZYdldYGq6oW4unciWE/9bGs24YCXwItOq2IFWtpF9ZCqDmYN+", + "U738WIVzDFw+QEfL+nhr2l6V3mCK4lhSOrNYOPSzMTFGulxtoJgJzuKyWiK0WCkzJs6FvBSuniroorFR", + "QV4hLk93eb8KmY8nshDgZ5Vj1E3j8s2PAY9IOUw4zZUb8foCBB8aJtCKGGJ8U5rlHCBrVQHDnBQJmbrO", + "0Au35EjyRchUOaW7ESWrklpc1FaXm6tlzrLyKiJzwWwUsJ7jImIxHmJXStlRs+GQs+2zE/TacjVv9t3i", + "GGOqwc8TyhNbeKch0s73V8rpGhK5WW4gymQuCdM2O5QLqygdM4AEIK0mjlVU6FhU8thG/G8GYJlGBQsq", + "e+ef63b0ytZh8vvxnBYmatKoR1XJ+g7OpTN7y4jL2lHKLzGEiN00mhHrifbQWX+daQsRWBnfsatilkmL", + "gOlD1TuJZiw6b1au8GyssvqrT6VanW3u1ngN+WgsZzfGfFPjOE+HqAq/lnza5MlztggcT17qCcV0XgPx", + "Uhpt5PScLU4hRc0UPvbwTy3IKL40HInXPk0GjwrvF8pFrdiEcFrJmMm5KG+gYHMbiVPQZ+qUgKesclnY", + "1Jr0ykIZmLIKTWQDp4D1RCAAXduYmkm1tbWHuVx/3V95Vc46LLs7cFiN47keWtedvJ6UQD40SVxVtFFp", + "/tjJltmUCv6HKQEDq5EXmWDxkBxDFJGDfwEKAHgikvM5VFIeCXBf6D2wsnIQao81bGaMJJK67MAzGp0z", + "4UpHq3V59E2H4V+bTay38ydNytbYYCNXtP3MVR6p7ZzrXr0bl4anLvGeV/UhohClP4VwlrryXfeKvjlg", + "vTV8ardFXqDPuu4MR5kPpfmAZYw2jiJMAA4dXEJdzngC1SLg5Gnq4nh5/ZvQb/1kreS/RDrbvflrXxO7", + "DMOP/TVSm4i5A0wlFzmZU1v4pzw8lHLIkWsmRZLAjSn+egkXv+wqYqaIO8sGisfGhaOW24/tlw/MTkjr", + "LUSYRTZyzjU4ueqnC7LxdQ20RnZFy6W+2WTg1ovm+gha2a29rXCd04Jn4m1849jmF/0UgB331Kxy+Tg8", + "sxoWvaImjDE1O2nGKl5C+DFz2VdckFPr+9KPTsEpyC7A8sffRwINjeX7U8MdiReY5JIqh3G3ZEbdHhxg", + "TbNQ4ROh3Xz9VQyfCH0zB3bN0obVZha4XzOIa2a86RN2xpbWyZCxpNotFDNlxrJ1dby0FCQcwuN43Rwz", + "1Fl/JFQOKx3SMkloqtBrZ+EFrXAB2X1kB1w4b3nLY7KeKBaTGcOzXPs23KpfmvIS0LBbjuB776L27F01", + "FItmEZRinlHRBNv/SvnyABejCYuQ2UcCVh5nbhk/fsBhENoE3bbs6PkqPC1QmYGQoq2j/zXzml6fvCMQ", + "smjfKTOcYhmpYcynHG5bbKCq0r8XcxvRuKdf0G/ufbe/v3/w7NtvBwdP99z98F425kqOdQ9jW2FwjPkV", + "w1k+f2xha6sx+ccH/+VnPplR9CrZ1MeP/vF8NIr/A/4z1P96/I//evyPwK9vg7/+Gvz1Bfz6PvDkxw5t", + "nzz+x+N//MU/UdZnOeTveW1Ad19eMMCiuJPAChCOwcW0QuwtoCq8Fhc04fGxzQY9mkkeMYieed4pUS2C", + "D5U/AXVAvIbc+kOFMOvfC2ZeN2H1kNlTvcc0kbstjVVUormEKb+F/Bc7PZg2tFZTRRJww3GcujKTVhH9", + "ovKcbvDfj2v0gDqhSuyZjBcrHYveGBSIA9Dad8uxzpq/YKk+fop8g2WP7bf1la9HgN6/xXdTM4a+YC3W", + "nJVtMgbyg+MPb8HW4Q2TWmPTIzrxxjXWzxX19D7+NoTqF1pogGl2d8ZzTHmngnzrpYHsdOXn9Gqc4Iwh", + "gDXKBfz7dtSBnc+1lhyRFW98yS2g48ZLjiECFt315labC2+1uRhrUy43gPzjRF6yLKKKmb+LNK38jZX0", + "7NuOUbi4JUYxq7AOo5zkVMQ0i2+OR3ag1peCfuOAf4EF3+JsrzO5ah1e9M+EUrB1cMzb1vBTv9uHVS3R", + "+evKttL1a89I7fpp1daBILeqz3q1WVLhik0UhuOMfo+rse2Kq/EZVeybZ+bf5o4M/tCH07HBrOBqbJUh", + "/KFNCvsvQN2BfxvGgn+7uq1cjYuCm34nv8fCUgCRHnhBXBZv0TMD7t9xmZMJ70Pmas/6eNQ4Y1N2pR/h", + "0E2nFvprLFh+KbPzsX87Of5DCjZOuMrb3o54nI3PEhmd19+w2di6X+8IuIl19RpL9d55ABpD5+3Eur95", + "8/ZIqvytjFnS9Zb1zVuC34XD2xvl/K3jyzmOYpb0CRtOh30y6k3TfPBs1NP/jBJaxGzwdPD1QEkhWI5F", + "cptoXMEM4p+9zOFaHz8cv7d9HEEf5Onwa3LS3kdrdumquTzGRLuuOLXy3EvSAye9gIReM46YCTk3TJhC", + "tMA5EwFvPY1mbKwFZJyybAxvbQXTVLdLdLtAIytpII8+nLzA4vbY+WXGc7aL3qHhJd1zkRb5djt+rZtc", + "0qUs8q33+Q7aXNIpWhtagW+1319ss0Qup6AuGbVpD8zKEpF5d8GyjMcMAcs7Cg0ujxYWhMyARIyUZQMt", + "qCqlkWUXaXoZkg+IkpJinQXYcPooYyMBhfjKqtkTLYL2S0ITzf0LgnkJpJo0W2uKUBGXAJt9wnOLAG9S", + "2uNG8y4gGtqvfGKS2beRUrJu3WeMEPzU77HJhEHJk+0V7vsVb6e4KgdvK0+53mp9bykrNNAzu0p5xhT0", + "B0s3Du1gR1RIAYUAcXnLa5fg5oQNhbeoWnAitqdfDbaUenvJWqMPbUSBm5zKZoNIoFizBLg4EFRgnuxd", + "MBHL6j6+eu907XpzXI6tkuFa47clikOPrjNAkCgxMlAxZCySWdwvcShsWAS+43SfuTW3yMJGYcDlpvfz", + "jQEKHVmEoApaeAO9ZrcKgjwqk3MolvcY9T6cvBj1Hgep2akuweUMKJKlhGxdsSAZVqtA0htkStsbeXwO", + "F9526pbTuoUEY7PlVZVWo6O5Owd0VjRtue9WOzRrC9ycWgv2Xqq5Tt1bLRiKQDKPGpqxWWjAOZs69s0j", + "doLfBhnQAcACh0X6JKTFLEjDlgMD3nhYPcsUUuhIVd8b2jYGM20NLdKO9bNq7zhxC9FyXFVabDNmD2Le", + "rlGZ3fJ2QBRU048wesHg+zojdT92H5fztcnJuzRU7cFYpkxQjidjKvJZJlMebXzqbrb/LmXi8DW2f7i0", + "/W4nbgez1hbo5aGBffO0Dgbm487TwR/7g+8Aff7g06Pyz8Fw/PF/eU//wwQtLIdvQcKIymXGXDQi4AQJ", + "i23l1yAubNlSjNGCI4x7EQOqMqyZxWgWzeB5lEmlXGOLVO80jeLickLw9oIcDL556l2aYLKrCTlHpBaI", + "VxpBpjIu1LkUgkU5/jFnamZ+1isHUWmj3njUG45EtQY5Exe9572cKRMrVoHY+NqD2DCrF1pXrnKoeaa2", + "m6ivpxImryw11n6Y2iQrv78mtEMll34tgMFADn4pip0/LLPONxnlp5YlO4IaQztaMyxgFFizciw7QlTA", + "jsnZwo/nPHHVL2y+PaEZe64fDcip2Y5O4Q9TLhT+PeGCJvhPA995qj+pJyH4bbosA4hCTtHV4b4eLlkO", + "qfLvqdrZguit8Ey3HwL9ofm4W0bjikOHXQzXKWBLcK1Da/6K1ukoCwPtakYwmQpKWqkb8NRUMTew2wbi", + "x46RPspezxl22FUem3WbTrCF9bs2crlq7b0aR7vlgNzraJfV5ZbNjk/DbcHA1GlYhgWj1R5+NhKV+SMd", + "kWCCjfiwKRuwpcc573UrXQeuu17Gnrg2fGeq2rUfwqSMN7Mh7HR2YFycu/ZZwOjtlyXqisVDwPvWF+Z2", + "tWsqqAvb9/BcbEi6S/QJl0JqB2e1eQ7hNosk71zUNDTutrSwZWl2rein/iTvjNNak7xtWek0kxOesPHn", + "YSmnCRXjTXtNMz6n2WLM5gYuqnMLCNHhZbSMTUbLhjS1yR6EqO+IJ7gJgycMOmnPLht39XOutRdhr6CF", + "Z8xHrnRq4fWLYVcYxw57Ydm/7cfMx0aetw2GDMCngHihf4YEMEvCsLeBM3KjsRsEdzQQZXaro0cCkBaU", + "pl0PHnsZmlLlbOcDx7Fi5dvOls9GQ1xh4TjE0V0oGJvrFUyQ30jtQnDfZjvUhjtN28SZ6LCdqWZsfbt3", + "lWuxztnC9l6WOnEMu9sdAU5DNd2vVLHj0VaUkR06KGPoG9URQj2MERV6DI7Z3VFkejMY1OgG3ugI39Wl", + "5q39yqO7f1uzIymoXuyoncC2ruDGShVeNpwOyT/wLuA3++zjb+z3j3//cPKiHqWyC4IwIuX1ixottluk", + "BSI2m6Euu6MHImRCFOkHH3+LpMgpFwoo6210x9uNKhfpUaXJ/oyzhFdrO7azSgOrSgr+iISYG8lWQYOs", + "1R1JGAbLt+7PW58PE5zveSV3xp1lVxjA1Tq/xwndldtRH1J3cpv1hVxMnRRnbiZ3tATK72LlEbejTbnR", + "R+C52PzLTZbe8c32l/Et675ch6aQAmSRVapu4e17zCZQPHomL0kuEX8G7sVdRRDPZeHdcNvH2IsqagEo", + "UKr2WUup2hqFrwnGK30wSJPV4jEmHKv3l6ENizHz8pch/ONTvwcEjs3PaSbnKWTdxFC18Ydvvv73X7/+", + "+vDVr4c//fjy4MnP/7V/9M/vXv1oSmA970FcoxoDBrsNtDAhVIq8N7/6gULLhgbI7WWKEVAJLZm92Ede", + "9WdwXaUMLHDofRmOOPPahlOpXtpClRVXTPWPT/2HAo+ff4HHrRRb+pnOWUz+8+Tdz8c0nxF2pWfEFF6S", + "hF3lmiQM9M9kkeq9HnjdAzZChwvcITSCcExNVgi4kULBvYGAcNl0RgWmYiDAoohZpiKZsdo8eLqnoQAa", + "mtLXCKGLC+MbMpJh0UYNhJQnPFW4GadaVtRTRIU53molKYgpVFwY5ERU6moGyGyWfqOoyQfFJgUULVbn", + "PCUycW5n8noyErW6lTRJyIyrXGYQ2G/cWTRjtt14+DmVEb0jJTXves3I5lZVn7KALqirAlPGyyqA6iXH", + "Vwp0gSuxuYB5fu+/V5YBU8W8T+jFtE/mXGBg3pxe+aKo0ITBHGBALbOYUJUwwpRmyqLG4rvQ7SuZGR00", + "BhhIv+V+lXgkyiouaupID8krwKQuRD4Sle3VzoObSk0onwr0r/v6w9kCK9hn43qe/YpRUVGDH9vsycOq", + "GbKxLVHG/xpjUE+VyzAf2z/pxdTAPyBaiBZwiJMMRQkDgXc3eRnt8VvJWYauvbpwaqNTXLVQnC1s1wYU", + "u5aZcdN17JBYEM4lJSBHAqwNKOavyKNRj/2OgbxcjHqPvYr4uPG5XPy2AnnV5fi0dIF+yKgoEprxkJJ9", + "DwaVe6FSpxEMLVA9UJffwuIZEu0Grq0WCxsHJUznNPel8fj9wdteX/9HH3mOD17A/79tl7droOEf+hzk", + "A+p6xhtaRfoM9dSeofafw//0+WnqT5ahVk8G4Cn0nvc+vD/Cuo9eC0+8Fj4tK724/gmrIlltbq8mexrJ", + "2WkVUXNRUdZR4srVAsZMjE+1aew+cp9lW0jif7BAUVGYEjwgeASKXLYUTB8JN4ZaBVI8UYicZ8yvowxt", + "j88W46o2Wl441ifJxCWRs0WFL3/rVbwLHztAgteVv8euXsUDw7lNQl0JVk2db57CtOp2CFXGTeMg718f", + "/nyIWuHf+oUXpsz5SAAo5/O9vcvLyyGngg5lNt3TLQ10S+oxokGXTXOFiRe5JLFe/jkXeMAAnsNM8HD9", + "WNVWA//D+yN4D9p32d6qpVLwburcLhOSXA5XqeyNgKbfVlSfxXL1NB/aFr/Vd9KKW3S5w8r6wuDWaZAX", + "2ZnseQhiaeFVMG7TsO260xwJes97B0+GT599/Q3M86atfVo/jBCXCMHKgaew4LtWCn5hOsLmab7A2g5Y", + "WMBUHlg3xtBb4B2Xg99Ma9+eLKwVOlmdvi2VjK+ZnL64fDZSspml/FD9/E5XPzervJ3q514HWNu1IXXY", + "XafK5hZiGaGVN9isuJgaT+hEJom8tJAPR4ksELBZOUiHpju01OgVgZN4cJyn2uj5kSWJ7JNLmSXx/wHD", + "Av9HxXByEgmS/XV0sD+hMRscRN+xwbP4m2jw7ZO/fj2Ivn4SPf3mr08P4qdRmQX93EYLDYx/RJN7wTKF", + "ozwY7ve8+EanRAbgUsEoxIoGqN3mVK+UWne0davmlZ7nlC4SSeMhsTcEfcInxHjzCM8999N/nrz7mUgT", + "O9mEgGtwhSYKCvGJPOz/PsKH6MsxkuGvOOy9yKXknT41l6Iy6pmarIDo/t9KilGPcDUSVLOPtdx/fP/+", + "2D+B1r/RzFw6xRpPW8foaUqaUxS8pVnrYMfCa+auU4+MxjOW6YdQTMNhxxcZb7jlVtKxNNVclZciVTfg", + "miy+wsOsVmftI3wL1GTUW+/ljMPdruHBGU1TJuo+ypo8+fMz8GESV1Hny6F/DEKRDByD8OUQQ1ZUkBlF", + "ed9UmOTLcgjYxSoCy6Dn2k0B/HVm2cdULLP1EqFLY8bYqa08MyUes5F45HBG4jI26XGV1KpCWkHyZlHT", + "q+pXOEQWGZlYGVayBnmr9RCKjD4j/vLqiDx9+vS76iiWaNCVItSuoygXihhNZC5Qz+wOZXUXznnGoDiy", + "9cLIjGMVJDEdiXJUtZmX86H5a6jknEFLmzjmHR6Hz/Lmy5LNPlZKIuHW+9J02bqxV2sndEZ4cjca8+pm", + "DyAH+LBSKKq6ufvljlbZ3PbO0717I7v4GK88NtjGK9kny7700jQCrz3B1z5dv1KUzUj7xWnYFbWieEUf", + "KT+lB5bXL6Ptr04HT6CzLMOkGClLnE70smmuld2z7AIcSgS2p/LAc54rv7QbHEJsaPnmWTcbUIW92d0i", + "Nj46e7jgMRa5aStfZ3yD5jVbxc7sNdWb1m4OkLpi+ZfrxJWwW5paaTWlv8j+1H70C6QaMrupujpF3TQf", + "NNGcuh2Uvi4buH7J6wBqGNasJg4iEaDm1i3cfIQFmdcvFq27nBVzKshdKRj9s8xfyULEJROsl7ROFbOc", + "/GejmktuslBLS+Bnqc+/hYhRc6mcijoG/rkU0+d5RiP2/ODJ02dff/PXb7/br8Z4upef7T/75Kaj3s8r", + "2481e8rHtpoW/NdAn0BBrWf7z0L+6o96hozToYlEZSKqXISI0nY/zc54ntFsoU+aEQd728RIVGtmjUaD", + "f/y2P/ju4388Go2G+K8WzKd3Xr09Uy75Pb3S3Ne5dK3X0iBhFywh5thAcnqF3O9OIAaARisdNNTrryq4", + "mUMfZ4lLafKvrelu0Wv1EdYvHGhq2eoJ0ptKkcs5zXkEZfZLe9mvNMjVEnTa7YZYVqx3G0AZRr0EIIYx", + "YISMc3rVEY3GrOMym+RFfYEMBHEVAsbpJO+B+wSl7kIC1N0NUun6rFb0Nj9WyNtl+UAvVGsNoMDmPLWt", + "cjc4wGM6ZW9Z6H7GncTSsrQs3nF5BSBs5WaIoXYhWhPjtqre1FRlw5R08DVheexy9R6uBipl9JxRtRjk", + "LMvoRGbzAcZYlXiS/I+qSvUiNbq1hKHg1aY2a6u2fu5ToNV21LIgXnRQY1VwQlHzeQvDTfwHHkGrM52a", + "XX9FTBILhiOldo82clIlr07/mtN8nFABCHddg7nsd/XtzZyB9EycmXBOCnlBmNAgDOZdH9R/JmErGAnj", + "FkM4PIitKYvKakWRFlk0o4rBwYrbJgPmpBvKWgoCRrDqvIdUNU53sOyGCGdmwqsPIf1fREj/JJPzMaQg", + "pZr11p+nSvB0kKXOmYsyA9GADjCGt3StGr6zKNJhgfC575X+vmxvewHjXcO/5/Rq/HtBYa3bzlW4MOU2", + "BVzjj9vGEpuBxi7WFYSOvJKZrXc8sAcGp0AAexjqYZUIpKbUNEQpzosk543PtBpiogRALATUVmcxsYNp", + "EDX0qpnBpulKIl+5j3qh+nIPEfLrR8iv8tK8MQhYQXfDWj6ZY7gwyI9oThM5DThj2k7a/6p32VvhuFkv", + "jhy3saYKClopdie+uzHapZFxK3Hauvs7X31LE3lL05Pd6epklQobtzRBy7RDtzlqKAwD3gA1AsAxxuKQ", + "WQPYLDtwn6o8K6K8yFhs/THbdqO+RRdqWWUGxm1Acrv7Tl1hz6ZRkVJtluP9I7xWvW0Epar20kzuZTRn", + "Ec1itQfBMHsGuOknuMtqo+iVqa+5vju3Vl7nBl25dp5C7NzIAOkcRoi+B4zqt8VoMAvM8eOQvEtZRnPN", + "4fo4Ny/yAlx37CpKCsUvWB+ST0dCCkakeRdu0UwYC80JNUBMDa4XobJIcn4GWfQe8n9siFT2Qi6RU0iw", + "PPz5xdrGQXO+avHny6p7glig96Yls8vOGLHvVQdgQtVCGa6/r2rRpNqs2R4Xq9rjisBqTQJNVo2tVfH6", + "SydMrDtjrkyZ+WDdkYrVU1dWQNNzuHbDa82hbvYm5lFm15SSd7/ckJCUlzWonQi2QQwUyDpKzKaxXV+X", + "CaJHTMDLZNTanKarVdtI1HQbeVBtd0S1IWj3yjbhLa8BWx75QTk+KMe7pxzf0pTob5ZoyV9YVGT65WPI", + "P+moHN3XNn0FZ0AQKqIZaEpw6HORs+yCJiFlpt/bjmsJPEQDiPAx3ecSCnAYJ1mN1DpsyLLINHu4Mc0C", + "Af2eHdb65L8+efftN/sHL0yOcIvv17brcon95GHi5Q472o8hebi8HjXf+5+5tkyscP14YFbCG9XHILuU", + "juuGcByC1xrwHwyQjI/84OUwmpDbBaGl77IyHvuriR30S2M9W10a6+N/PPrH87H74/H/+os3OXYEBI9y", + "DQ1xIrMchCisiU6pik6JKiYTfgUK3V400GqAg5JZTmQWG0wvFTGhT/BDhNY41Q37zdiZwRAIPTH6DfwG", + "mxmOxNsiyXmaMGy8PNiTOV2Az9lpQk4BRmw+p0SxlGbgbUm4yocj4QBDhDT+VvN5kwZVnA1K1fuITZ+T", + "ryZSDs9oBvR99bhWUstzWMIL3ryX8xqa9AbAHuiGhRGp+vsrdFS9akTbbvgviFmuWB5YHtmwLcY0P5oU", + "f/yxQMi1x2vbItg2VvooIQ3CXXQySLB2Z1awfunFcFcYNjXlkZBiIIokefw3jITBmWl+MRL0zHyh3w5b", + "NtO8bXxckSmseKZlXLROYcKueCSnGU1nPDI4Diw8mdOcrdubzKx5IdfreSSWdp0sG2fClNraIJOlgyy7", + "6jzC5d2Kdk4NGGxrMqpsF7BfTPwD3OZgqgvNCcjTwEIYumtOUFeDmNkbtXSWQfEstEtHwhzADM5PkJLQ", + "8MI0sCsa5WTrNATi/9pAKWSAkVA0cV3PFoTxfMYyQ6vMiKeIhuQwSRxmEzfl1+xm9De7FeC35pzpqXYz", + "VoOmMoRQkKkcGNqNOTus2KPeKwM+TyWifadU78K9Kc9nxRnEQcqUCcxkkOW/92jK9y6e7lmYj08hnY+Q", + "mttT/DtRy7sRoS+NcUsigVFJlU9H4hqM6uwJ6//RPRu0W+Sg1czceG9LHO0B624SMYXRUmU4gzlO+ni9", + "gRPUlkuUr3tDDytDY0hEq2SQ+xZ9466ebrWO+Sa0eonmyym92Tix+iI/xIt9/vFiLaXQ6onJNx17dSuB", + "RSvnYnk0mAuvMpShJOnN5ZIuFDlAdEqI9SL1oK22CKx/Lou+sh3eNDtjcF8quUlgtvlqbgIuqQKcEJlc", + "GGSYAEvoA/8Yrq/D06mfE3hem9B1/ZWNre4XmrMjmsXLQqF+cb32wnhcCRctKU/2aX39YTC26DA69gzw", + "HlY8NkjGOReFLKoJ6L/V9s7ek/0nXwcwZrwtq3ylCjVT8u4B2KjhZp+sbvZpS7P7S5p92krKx00X872Z", + "7RM2nUNqafua2lcDK3rnQwdDgXftEXcmJM8G3nmxm76u6FeWyWPrilCGXKuNVbi7AVdNQ/dWoq7alVBn", + "1CurmWysiteypxprlvdkwiLNHv7bYz2BY96meF+/cBq30gdMO57wIDK5JOiMJVJMLRDKWsuDpsKSGC1D", + "eJMETV9Akh3ndq5JXG4LQYPYDdM3ed020WCIko7+qtlfi1/qeq4r2wTYpEz1fjim3cQxbROz0eUJoA/D", + "4pb2K8ltzmLcbxekJRZk/Xatsik4oldx6Z2PSfaJvZ1NwCSW3vmZMnTe6iSV/oluE2M+L/O6m1OyXvWm", + "ULJDiF54tyHR+lfy6IPgFyxTECr6Aa+Z3/hXIPDgRGY5RNQ6nK2shum0FJvSv1PeH/z142/7g+8OBz/+", + "509vfz4evP/X4N8f/3zy9Sf/WhkoDhxr6zWrKu7tNTbxDTzeHf0J3RzksAYWHNG5w7fQZav3vNbj9n3l", + "ugPrKTehPLZmxRY95TCMW/CTQ7++l3ypf9yw8ZYd4x8ELfKZzPgfbNcwIa8F5HgBuoHmBoo+r20AhhyE", + "AUP8wXXGDDlowwz5AEfPwzjOmFLd7xHgq0YkRNBOOuL5ogL/UDFoSk0GpUGyDkD1R/gB7noNITFPEemB", + "C/Lb65N35OnBN98MDj4+sjMG+OhKAjw6V3IAzw0hA8APGc7yefJ4JKBC1eCJFx1Vpokg3Z/6PW3rHzRn", + "4BXPVE5q7iU9g34zb/Tjg+BlPhfsSbPVExZJEa/V7JNQs+lMCjYukRdqtop+6sHCuJR/+P1ni2DQbFWq", + "nCbjcCLOMTx0iTeuTfy5Ld9Gs3SgsRP9M5EZqi5jNJS3d/qbNZSrlQRjRZka47/K7HySdIa3Nl8b2Bol", + "aKpm0p2ILk2j1fqL4Pt28BrSIq0qlucczuV6p4Egb0YFF9NJkdggcZrog8NiYHxKtpD085FwCCHkjM3o", + "BZcFxkqmdKEPoq71ITmSScIiPGAmfCrgMQB50CuSyoRHi5HQ3U9pPmMZhj/u6Tmf8IQNLvWeEUkRMb09", + "QjhmxmCbLauGNUw5S1yHnX3JGjmwlhMzqIAyKAFd3LxayB87a2H8F+Xa1EbbYt4JP69CtSX3GFtZQuxx", + "bZGWklp/uTuPN+fvOkzPG1MHDI6+DAayUJuQRv/EGk65RIOmFIKR8KQgZdnAzohmyCmUJ7tgYwvvxJXN", + "pCdUEY4IiVVGhhAX4GQLNYWAWAEHS5HLMY0v7C7vsGzxyN4IooPQmlzWYKMgibJS9p5OclPmJM7oJDf1", + "7smMKpJSVa2X4cXM+S9XoXWP918EoXVNw9Y3YfvPJTlj5JylcB8EzZpK9PDqnAptLmfsgrNLVY8KfuFj", + "A5vg4w207jHN8oWxKjoDhh2SqNRhcmI3QaZKuAbdfHNFDZuMqWcEdZBrawU1BdiMqtyO66fSes8f15qg", + "9/QKT5ummk8HETWfIRalDSTWxq0ilq5q3LSw1xwwh3orKLJUmogfOhIOSs0YSwG4s07wXaUTwx6oEee5", + "xbj7WfNcoi1iII5XvkGTT83kpbBHJIdSyu1MxDIq5uBJXc2eNdV9NKPZlB36cr2h6gxqeurg6ZzB4MDm", + "PE6fs3wmY0CcA3pGoqJpQgtivx3jt2GXZrOLmsbwMd2x63Gl50BJsUamcJ2Sjx2X4ISJ2Ow7tzr1ionY", + "WlvsZqZcdzk2vwert8UFG8OmUtsWni7fF3AfKrF/7P7AFYkLNiS/8nxGlJyz0oiUSWFKcuZfKZNLbXD8", + "LUiQ2T4aI6xtJEjbWjvJthmp5J6NGGQIBTr0h3MuaI6uhzlNU2PfBiVkA3txmdLpV5liI2u0KU8lnvXi", + "ZyyG3pzuT/2eFOyapvCyoX3qX8fEDgyqnUGOEqlYvFGa2mElPc0WacPrMFs6TXehXO1b8z5k5EKEERyX", + "tPVKaF5WXsOvr2qPmAicqnZdtCpAepjmzllvJ/qrXRe+CpDfNq+diH8pmtfIZfGeJdwGcJ0/ZFTkL69y", + "lgmaaCZNmObczcpumq/ImYzRboPwElsrgZleKj4A7M7a+1CJC3FERwKARJtsVnouOxl2ONxjE3rsKV+k", + "4ARbDa+lYJftRDeNa0Phkqk3kPgfFJ0yiyfDO0dTv0UlD2c8l8MGLmoWmxJrJqvGYfCTd8ID74+oIDN6", + "wcgfLJMjoXdLmblaI6pPzgpMRLbVR/QH4CDCmA3dvPQaDCwWfjg+Z4uWeBHbWelmcmOJm+QfIfYcFuAD", + "y0hIHOpIIOC9aw+aCsQh+8SuF2xSW6UT7MGUhXc6xEzRT3qkKwDQKrPSziYvuILDTVfL0n5XdfMZ86ES", + "kFJDZmVZxEQehPE5ds9IbJv3gK0xWVxba4/2/+d//18H+/uPTcSsCUo1uegu4KCKYfup3yssfNB1y5z9", + "7OAUUQQKwXOFWM9Q45AxcsYmms+tJQWbhjJFpnBQiuTS1IQdnEGqQgJJ8Y+EzMkkoTmZMKhi+sFWMsyN", + "C5QqkCZSiJwn6DSjc5gurkaCXc1oYcpTtJ/6XiEU07aVMCUG42lIjqAWDV6zGX+vnqdxJFVu7vAQ5nEk", + "TIhgk13cB511sRnfB8HzI/19cxFdtHrKsoHuiABlVb81+aAYGfXQwh/1DINP+BVGypbf9YnMRmLUS5L5", + "qKfZNZHynBQpNgqQo3oG3rx5i7/YEhkElx7PDCzD6r2Ds4WfljYkJyzXbZ6KIklO9b+ihFFTN/iKK5h6", + "R8rfwCEINDCtefVGV4hoRsUU57hRqMjectoWljGOMTaP/Lov63POSe26wGrKr5QP6GxtFRe4bc9pUABF", + "qSLEKzvzdOkt5Kzq7aqTD3wSOz8SlGYJYa5bp5nrrL92zEe/d8463Btae2s5SK6TAWc42TgxQCGwJ3Q3", + "TG1fvjPe5tJpYPd6vTr2mkbvhbLICdUNDckHkfBzZj1V9guMwYfueK5YMsHkagOA4FABoCLXGYtooars", + "4C6f5hQEhsXmtgwEgOfDOwQBq5X4mNYMsQ782WrQNVe1u9FGzhZeQR9jO1QCIOCrSrd1vHeM7ObL3BNG", + "d7wJZigcklym5oYC7nshllYrA+FcRHphXtJohi/4kOg2bwVdEX2SL1JzG9EsF+UFKmdyPhK17EDywgJE", + "PopmPIkfm40ZLv2wxk8hYpaRU4skOYYXTkEkgA+VCV9d5jRRORUxzfDj5WtvD/jmC5i/pucCJr2jsyLY", + "8loLuGGYuItLrlmOTpRxh/XNIivtep4CYYQVC7aDQJWmb6CKRot5a7fxYMi112C/Z8ygcSelvRrR3DQL", + "KrJ58uAKJukrFSbwVfkxsg+PWNdZM/iwQeLQOgfPELCDA0OJaBIVCZAE4und9tpFdVe9Dn8Wqnvo2e9K", + "ouVMCLiEBgLkQsmTVgYMklZ+06wZkVUd1S1y41nbtaDMwFs27ybDP9dVJ53k3RK0E2XiGl85LxX109Ur", + "+eXtGvUAvVsv0bBRim3tdvaFJQvECgxJS7vWFMAOz93JBc1IQsEvpr/Q5yuiijQ1R0lsjwp3/hkJWN1c", + "Eii8xPMheWmPRrgSNkwCtDi1fX6lyKlZCPCkYASGycOuxMuAEf5Z5Ak3FnCD3KP2DX9FFlKbXrWbAe4S", + "TsOCwLZkLvVtsVQvBqSTzezfdrRcAmAH1mMeyQuwksEeLoOR+kSlVAjnZqZZwpkNd8R7hFyOBLA3zd0T", + "JmJCo0wqwCTVC81zHDVekrwyOKj2dMsBUMywa17148/TfNE3V5dzRoUip5qRT8klTxLwojiQo9Ncnlbi", + "BCtjbK9E/N6rNowasbZMnu6s3NZWLFmvdNJ7LAy8/H7THBxsEeHqgvusu/Y2splTq9ZIYPu9buXbsAOl", + "yZdbdZK4CF7X352o+tNVj4JMhGqSGNY0iQJe/CBE5OG9o0tu1/oIa9k4x8MPL9//zW0NUgDAnxZcQA9Q", + "pBAJU+BVTRMecUjnuEqpiFk8JC9jjgkyF5y6LYxVdx2IaqV5NEOtcsrj0z7uVap0kgj4Hd41DpQ+KH58", + "zQLSGe+JXWe4OUHCR8IdTapsC03azWyZiWJuaPUaFNAgJP1TISRg4uk9lcUk5hmLcgy8We9io3Hu/1QN", + "2w5lysI2z7tL1on9brVI2S6+UghdGOXritZINGWr7LhNtb7wLXfj/baBaLirAMAlQGEb/RMKi7E2/kod", + "2+9d+tHd3dWTDTNYEsL7azDUu9zwI5pixQuauwl0CDgWltsOwwWjNy+yzNz2S43rdgs3yJV7Q2M81/Nb", + "N0KoqnOwbOjNnWTTpWoJ5w8bOi2UwpWo3jEwubb06vq7iS33Cla7vcypRS37oftGfLzYZYInNP2ejZlv", + "ieB/RItcDkwMct/E6qI18DgY3j8SjxqRV30SF4hY8Rjq25Zh/C7SSRXRTEtc+e1IuOSAvh9qbRe7X0sZ", + "QLRAU+8swMptzoI1mBZKhW9mxsCnK42XO2ABxHzOhOJSLKupE/isehNL5ywmDo2XXaWwaFCcThJ2lWuS", + "MIEwk0Wqd2BEOC99eejzjmlOYUw/sYVyULAGgdkA4CgogAY3uEk6o8IUntZP4WivIpmx2jy4OBs3lL8M", + "rW+lsfif4+Gy/aZwSbnszVh7SYOrrfWH+tBbqA/dvtjH1plci+nIjAmzzHU5SSAgdpXX+VUC0ECTjLF1", + "3tav9XvTjMaF3rzW+OQH924fIg/W+OSDfq3fu5BJMV+Hqn/hi9vxt5bjXC+CtJzFDu/DCDu8X05ih4/s", + "tHxczl9AezedoT9Bl1Mg2wmCZrYREAS4lBiCYxTupNKvAw3CHtfywLh4J/8EAKLS1cNijGUz3FVzDOLV", + "bY4zxtrmeNNxaio2GueK4ZXs2W2M7juSc/AQIsnuaiHHwyR4QW18F8Y94U07XrubstoIUcVZpo1T1LER", + "FQRDdEZCW6XFvEgoWOT4JXgRmYKvyJks9DmQGzcioNljpJM2OAlvuAycc7Zfb4A8KtJxLsfIHI/R+23M", + "KLh71YbPBQMcQHvogXC3wFJzlqk25EGAcpgYS8xOJc4hOcxJwqjCOFCgj5cpWx1dDbDI781ZvFrtxYHt", + "sSyInbgZp5YbzIZiidO2gm3f886hVofW064ntDCLWc69Nv1w24L3sKzGSFTWAhtwc00eafUzxl9lhuF8", + "8NdjZzErlg/Jr3CjtS5H+gyIIesh7huJFexX0rbRnTbui+FLd6fLvbkw/IBSjNkdMZEi8o7QlpWZgNCb", + "ylV8oEkIE3JTutEgcLMODgLCA9caRKoVhDfXpdYyb/ZqIYOhcXhruo0N9kMK0UwQVxclRex8ZiWkK16D", + "2EokyD3l4F5P4IwGSSt9vKmxyyNTJgZMxCwmj/AGR6F2flwZKVDgQMdWmcKwEt0EtpxLhEswoRI23BQk", + "pr42KGurlf9IoKxVZAgcGJj2Z1W8GR9sDGw4HZIfvgcoYEYh1eRskTP1+GYtqZJxt2pJgYG/U0vKGLUd", + "CxejSm4YGX41f4/nQTCpvSeMWc6yuX97OPDEHiKrkgTXfiSsHeKlDn1mhoS3fX3uVoQ5QO7IhGhGRHWE", + "rtPku+gn51NqT/Mw7txsfVi/7+0XXoHrNUK9jFvL83iECjYvmZlGA3cd1K9603W9WwzvFqzjxbLWFiem", + "pjnGS5GM0XgAR54SBeXUh3Y4xe0V5MBeQuCdK1RXsUrBYJU87hOFRyd3oaRyulCI4FOp+oCeTXJ6zhan", + "kAJjr3NtzDiiogiZA0qGG71pF0F8cSbQD9zc3yqwHd2vaGrYHwF0V5NXoHX0JcS7+wuiZrJIYjSvtY08", + "IYIxgB1ywVkNU+L3gjnICFNytwIT0izKE3Qmv2FTmhhXctYCN9veZk6vxjy+zqT5eCBtWbD64VeKJEBq", + "DSaj8PMyLL4HQN4voGQf5CbKfMaykcBMMZOTeMm+yhge4aGYI4bwwaYpFSMIkNdouM0uVCzLTXWTTTzf", + "WNSmgGbu9KWOhQgc232wQ+GX1+Zb2PnCa+2/UoUjVi5xc9TDEI9RT3PsqDc3BR9HvUow7xZa+/zDAXdV", + "2aIBXL5W/YqWjJIKS62sAGBkLU1twNMLmtMNpa7ayEr5s0lU4w3A38yM1bq0WVzuLiZ0NAbzuhopBsha", + "lCRcnLO4TO4q79tpmvrS8LLxBmISZjxl1x3DCbayCeH4aZ1Y22C7prUbCFoSmy1+tY01dK/BoPmzDSUN", + "YtOq9W2NqdMCfvb5BendDe3WPXzMNzja8Bno3MUBNMLFrHHlrEhY7JpBOxJl9OxmAVo1BJgVqaou4KcJ", + "sWgoatO4XsiVI7LvOLxd6VqpN3RurngDDa0UQJqmYwspfx11FTLO07RUUPaA4BxR9Yd6Pmwusp3ozpxo", + "NdfyUng1Dgvn676e4MnH1LXuVzRQvQXrRS1U1V/9ffW9ZcrXTub1ln7lem+c7n1bid4R4CFEXbCfzRdt", + "4M/m8RIaXeTaUmJtQw+7zjV2nTTjc5otxmxu4NSD+ZH6FQKvtHJYNRkSPngJbW43q9xiFn0OaeXtW85x", + "QsU1ztXu88/hbD3J5HycJlSM0xlVbJtpxefMaRHdAYEOMESyBEs0dX/OWCTnTBF6QXniMBBtwd3KJaf+", + "vmxvE9me06vx8upE9lJEOEweqI7kU4wwM15NYOcMS6gYklcyGwmTFlIve4n2Esbr2ytuG/KrPyTgD2h8", + "NhJwCWze7JNCWLhnd3dTJ6qtwOZbekV+X1Zk844EgQbsyDrDLhfjzSX4cxDez3RT0+vW4iQqBVsZNEh3", + "taV3iYzO00AhwCE5NNpFXfI8mo2EjKIiM8FSJUYh4vQ58xTvKKt3fNjMJpd81spOqDi2mil4y3dcjjFw", + "15dmcpwB7tWYCa0J47Ux09NMDvBTDBCBr70DmlZMFUPAvW57aroMwkJoqG+XPRc0vIn42fuvdU5nJuI3", + "wE7WstBrnqZwQwTx+zbwWHVdWUPWYZqapn0P5KHpwu+BOOKay/ygPba4J1QYIciU7VCIzeooBhDxnC3M", + "9rlMmf1L8thDJN0S9N2F5DEi3/mx/gHkQ0xbGtP4vwuVd6uxUcEXBeL1WAzA6GHZIBp3FgxbSKiYW6X/", + "R3lZkgxfqjKjKscUioR6wJg4HAhIqgL6ner2TwEgvEhTqBT93DXtCpFhH/YKWfVtZyNX8AlcaH0P9NS9", + "AxdvIleA/eCc2F6yFxA8JK8nI2E/0bRnEIuWsFz3V0XGRzJiG2I0pwuichc5Bg23ACd+gtutiQypACYw", + "6wpKb0SJLGIi/OBdrO+lZ1yUwS8m0x3Lbx8evyY0SeSlGomFLKBOgZhqRoOzk+qT3wuWLQxIILSK6Whz", + "KnQPVowrOSYlYfrNn6QQWljeWmJGxf7+k2+Ic1Ucv+71excsUzis/eH+8ABSElImaMp7z3tPh/vDfazs", + "NwOm9iuW6WMU/DhleShRW+UQfeTVk9fiAav/Ou497yVc5QPTiu4io9CwapWO8pU9r3All+Kfeqog/aCm", + "LmSWO8Pe5YSbMEFXqJKcWHaG+uflWRfi5Z5rSRhAujb895wt8B9av+G/yurXp+SREcfH8KQshX1qY7pO", + "qYpOiSomE35VAb2j1asCIEVmseEyFTGhBQ2551SP83QkymYs2IYtbUdhf8JvsBlMTksTiLUxqo7rWQJG", + "s6W6n/d0x71+D1XRyprWMsvt7PdUvgA2nMhsHlgNrJW3ej16Ybomtg7fepRp/oOTvjrWbKNMGT+PzJix", + "9F1ZjdD2Dyz9ZH8fSx2AQjIGTWJiDPb+W6FlsB4lS8qSg5JZs5zqp37vGVIV6sxRv/c99VGenu0frP6k", + "Xozv2f7T1R+9ktkZj2OGhqgq5nOaLZzg4yJr3US1Afibp5uOMxkXUU6OaE4TOdVGwdWg0AdqB1FqSq4F", + "yu75MEHlHXVVsaA8DmzNeWOjfi/jxdbWFOmoOKI+VQ0gM4waVx1sl6tCDITuLQvL+fnxj11iWNyNGehT", + "v7lX7f0J/30df0LG0gZDwMaUk9wgaDgP2ILwuMln+JLjs9oOBjoMyn86FWa679X5ZF2dZuIGm8rqWcD2", + "RwyQz4MB9BfPVn/xs8xfycLUJig5prli19A7QWPmB5av4IUpy+8CI+zflH75Mtmq33t2sMZQftAHrSoP", + "lhxynT2vaIWKhMqYSzkQbc1bYsLt77CBEMq1dtgbkwDnAXsQBF8QLLvucvveo1k04xeweYftxEN8wZMa", + "c85tyo1p615pb3MuvQ/GgeOEChvsijHT4izhatbOmMf4wjqMadp6YMwvkzEdJ+yEMdN0hWsObrCThMVE", + "v9vmndPNbMU3t1OeStP75l7BdWlyyqF+8DHADHt/0jQ1J9/2I46oskXLMSdN19NGusO7rIvKeNCgQkrT", + "+6CGYN1hRdfkJnOdsWdveJarGVe13LwNF0u/gOtXEaolEW4m3WPyAxQy9z8xiOoXLCvL70OZplN0CZ+O", + "RC6JoFkmL/XhCEvl9V1QWh+rVCKgeBX9GUs7YmNKZvkpoDpr5spkgm5zEzoZUI5uAnZ4eeHmYIPbC3dz", + "ARmceAex9LaiCsU8hsl5uLew9xarlwKwgRD+z00+suhvyJMff5Ps949/B4jLPi7Lqf+W5dgxjz/+ff/g", + "p+MX33/703A4rLzklvPjb9Ocffz7k/0nz2w5z/3n8L9/n27vDsWAjd76LYqh455t9HX1GVTT9kLXQd2C", + "fQhJrIImdtu9GqQZv6A5K39YakLW9fzen+ZfK/znL4wjtk57CSZbRzyG8vuI+2pqtppYSQ/HOmFYbtAH", + "z0+SkaCJks73myR+GY+khAqnIm7Bw2316tu60+tYOm5iHjz72zVO2nhpp2Kw7A6gToi2N16/qBg1AAZY", + "JC72pKywVyIZlazZtyyPRWJUn+Qyp4nqIyD75XLI7bCBfkdYd+uGutkCQtr+dTnX98Jgv2GBWHox0a7o", + "tSjMC6yYYNDDTRSiw0g3tZeh2sBzP6ayTzAGsq+tRUxP9E36RrKjAeuu1IZSQ/K++gOiFNXKM/yNrFmd", + "gQXrC5laDGVRoY0KMJCy/sJIBAowYCXhVTumV1g3eDt0e6phFzdEgUprN3xHtL5mukeezTbFcEeM1z1T", + "a2DJ7RG+0KLazFNVUWQmeFawq9zTTRiu+t4+wHhbrkrcNq2DEJzQNPSVIpg36iR7ie3aohOg6j4eE2vq", + "wYw8oB/Mkwfb4cu+DDOMXWPrr1TJn4W6M2KapplcesmLL7SI6fsZ13wPhrg+ceb65MlEHJRbl8BaKFvz", + "rUQsa0CVgW+81ocyCFFckPxSlhWrYUqdPwjk83kVZM1EowPSV42cfrX6NagPk45pyxLpVrFa/RgnjCZj", + "BAvbsJuRqPRjFElTYeDkPyiMLzu0jmmjul1e7oquyFieLdo1xS/6MUg/Zu6E9AW+g/ug1QF21HQCketk", + "gsY8zXM2T3OH00ojUwQKNtkI78/qhZW+UkYZ4JlAfWU+s9nGBscYrYFRD0Y06pmXmhs2PH+Qvi9a+rqz", + "5F2RR+ugGpT40u3S6VBKPTDqicwqNeFLj1lt44V9zSGG6hmqtQIIyJCVVW/JXODYsmSsuaVD3pvb12Hz", + "Hl5SDhnAE5mNa6lpheobME9o1ntqq82ihlDnPE0BQ6MsBdgi5oGJfBD6L3vLXSYNDR6+QYE3eEZ81ZV/", + "+V6ZKGqBYVwu5EKZKtCBi3Wvox1erXtkXjM1MJIxq9+lm+zAh7tzuDtfZ65hsiSZNL7QrLNIIYITL1dk", + "kshLPUZMkYXlf24+/E2/+vHvaJ9u7xb8yJFz2/fgFrvrnl2EV3RCU+OV69Om69ZUbXuGc1qNFZeBiC9a", + "whZaSLG2iLmjw+xuRErRzLqQRUbkpTAfjoT90gdu84ClW7Ia8euBA5fbZX6jw6ODPm8p0dHhlvm0hBi9", + "+sbnnwFZY7Ab4fu9P2132oqPpMrB/l6140uVg2ViLG5PKF7JrDYQbkAaMnf75yC2hdcQoP3HfAKAmDk5", + "ZZMJg4rF40km56cY09dmQJR0r2Mjl0O+rpHcuv+V41p3/yu/OFuQCadOBS4Qv2b5bjgSZjvUX0JR0Y9/", + "/3DyYosbolT595q8dfbD/t2LGTf0c/VF76PXO4nUZHs7CmhlZr/tkDeUSeuWaMSd37S4f9zp5ms59Jb3", + "XUtGcMu1D7+A3dax3W42WvSX+xtp8ORrX9vpwdd0si1IHDjr1s6/XpT5wynYnYJXTnz9EGw/OFsAZOt6", + "R+Bztvj49/liEJ8NeLzNM7Ch5vaPwEjIvTsCl8ohpKDs04/eHrvkCAmrv8uzYxUV/rZOjWaowfOiufP/", + "Qk6KLbexPmO0bEr61If/bMT2B2Pjvf7WMbds0w/R8TuJjl979fthy2PK8ruzovu3ogHuSdh4B04xEd/1", + "IGLFsttlll0BzWy0Xd0Osz4Az7QAz8C0bHUvtEEOrac2X3cO7MtfrA7FckntrOmXb7pnKtVd4EBFqI31", + "a+zb57fJULvWs4GSYbercrvw9oMGXgb9tZlIdFHHezRNB7b2WxdJGrgPvyCRail9ejvi1CiuFwRWCVdZ", + "fZCmdaSJpukOJApLv+5FMxadyyIfKKYUN/juKy5sfjNVW4/Mt+QEv/34aJbnqXq+txfLSA2xh2Ek53sG", + "u1+57h6PRLCUIfahCG00DndDNsBSTF0FgTnLZzKuFuvMMNrCjB/9yGZ8Jl4Dk6dGPcXyIh31yFzGrG8q", + "YZlOyqoJJlN7JGy+aDSj2dSljdj14vM5iznNWbLALl25gTqxeA0+Eq50+aTIi4xVyujY5YdpeSUzMpNQ", + "n9zOoB2Q6pOMYdKo5z42UfvO7fzhlzemDBabn7E4ZrH3faGwsE+UcCbysWJRxnIsUMBzThP+BzOFeof/", + "DfO2kEU2Ep7qWBG8wrIBMsOgzm5fhlquWRY4V8YragZsuPh2naOHabqUNlUkedAkgtfNp6GPPi+P6g3q", + "dKMzWxTmTjR6KrOcJuvrc0ubVWPH8L0lEdTPB8UmRaI1glM1Fc1ntE1LS7m0NUzyGeNZWckFtaHqa30q", + "7ONGfVYqYkKjSP8TX7AJETOucpkthgZ7IDNwHB9+edOoOV5P5+PKFiDPJaFEuSrkurdy61hbrVXn/MtX", + "avY+DoZ9J1VbmMK1FFz7pw9qbi0158QOxYKobWo7sL1WZyTYmz58u4HXY1/4StlXSD6jOeB0uCLuLCZU", + "Ecahnt8koTmZMEa0EeUnKtku2lIbjKawdG8rzmOnKqUljsTM1NJghk6BJJWgkQYg4RACP+GBK7fuPbgr", + "QR4ei3mRHGauHDzlyvjNIHKgRaOhEAm7RZS/I6RvzWDO6sBfXqV6UwbMKyyehpF7mS1mHxNmEplqLHFB", + "k6LKCRmjyTjnczYGmTp9TkzrIKVA5Fea42gy0G9hUlRbxSgGn1bmoUtNSTMnSEDvU7NOZJUhdhrxAqQ8", + "hKquCFWtqflVO0z36NRaD6sNwlY1/zmagPaYqId0y2E9QEPQdIMnX05Ij+G0DVh5PfMJKoyqvbJI6ZIT", + "4qGteFq+7XDHTBDmnJ4zA0fivaXwXFVaWSNhWjqjCRVR3VQoFBtEtERNgRKxJJJZhunUrWIHjQ68iqtf", + "ktzB4Mrir7csgTVqWo5RlXe+8PNSsIpdU2R2LcpGpJYD/ZOa/AVxRMtdDOXKtnyzQtUPgLkUGR41qqPQ", + "xzPAl+SKaOtQ5XSOOE0vMLRclfA1CLGm31o3Oty1uLZh/YLm7D2fs+DhYQuG+w8sRxH7Hsd/23HZFdVg", + "aFLtisG+cX9AW303Q4Vzd60ToKb3KieJV8281X2BisA0d+N6YCs5MPac7g/3JooRe8Xcbz+DoqTl4VC5", + "4lDp88n2T5RYydjvZEgOK3+XDkgFVcOSROKa670uzVhKeWzt6ZqhPVxhKEP7X56NDHx9F8xjIKR9A4TH", + "X/4lwv53qz84kmKScK32wlZ0XUhuZsPc+zMqF2pl8ayqFIct6tuTu5Y7An98n0Mk8vpydX+syluXiz3F", + "8jxh+nS7x65sYnSbG8kEtmkzy179l9/b6xE50ZudbSxZkEkhYhZXZcwEI+CJj4k4lRzBbdVCRLNMCv5H", + "rR9Atq227R5e8nyG6JuITkaUxFvAjF0wUWijMJJTwRHdRzha6AXlCT3jCc8XgNQN14RXKcR6tSLx+6pg", + "YGkZlBPxhaqHXZUB8CT/pZnMEzeXtxxhvr7Oun9FAiqWrhPJhj64Jb12IXncrsj+JXlc0799MpHZhAFC", + "qDlIzinifxUY3+l7vHUDAEOsCNUfXtIsHiRSnnMx7ROeacWTKX6WsBJXbEiOjKlPk4zReEEiKVQxB5jy", + "hUGJxF5JISigJrGY/M///r8RzbRKlPWcIdiKJpzFGK0KwxkJ3YXSCu1UzwWLT9399SRnQLAakuOKeuWK", + "CGk9ngYIeSROjZodl57QU/3qqZCCnfa1sjWRXIMzGp2zmMjM1/8uetYFjCkypwuicp4k9imMTmZcH1IT", + "Quey0OcpiAc7NXfm9sRvg25xWH8jF2YtKEkRO6KvdbhWFFA4clIgETjV7mRm61hGxn4dGhxpbEkVEKg2", + "KRJoHtZZEB6zeSpzmDB8oblJ6Nfvg7W4/e1Ay1T4GPig6j+XYx8o1ps0a/OMCmXg2NfykvofOJgqL3HB", + "VbgVhM9NCaw+AZtUJnLKI5qAOZnF2ho1jc7lBex56nnV2lVYC84pH/PrkLz3qcBYtdKNiZsHq3UKgDiw", + "Uxi4neWe3srE3DV/71GRKZl19fhWlu7G/L7+Ut0N769H0Vr+X5zt++sBronCTvQRxMmh4TvAIPf18MIG", + "gQ+/nCx0H3zqZTnQQxinZdm2bENYwlqML5qCZMJoXmQMcwowmYAae+yeBMp5bEMc2zQ525v0ZmC22UfU", + "Xk6vBpGMmVqKliCzKRX8D/hxYL4dlJ/ukI3eeT2bgID39OoIug0wzpLX74tv0V8rB8+X0yti16rJKjbS", + "ou0ubEmy9hqcsSvv0ZK1viXf0RaZ9YvOrw75lLbNtlV9xy7YylgKLqYMfB/4couNDe1xMR2YJrvmgnS0", + "f7GXdbEnzdtnC6IKsEnXRZw2r3/8DRIWrIFysD2D+iVQtlGqAuStrJqH9cBPc94EPbXLXiaw5DIrQVB/", + "nTFhiwb3LRn62KZcjRRoFgBMT8mjuVRabCO9O094pvLHQwJtUPhCzzhLwKuUZvKC6wOjK2FscFb7hCOg", + "qvJQUYfkME1tYTcflXUkcmnGbN8F51fugFctfKt9z2v0hvNvdmlwvjbrCJz2BR+OmpahVUnEqSSrK9/a", + "Jyh+nWJdcD7BGwLtap46o3k0I3Ji5aDUKprbjhJZ4PQrA+zbCi2AQhdQpuuZC5HuCb/5j25cYmcEyITJ", + "bGl3AGMNtL5WNlKtm3oaUq3bZidULN5NWreTtl62Q9zHtaymJ02OeT9jljFm9IKRM8ZEuatCDnimfzVZ", + "3PrkAumZ5t5XFipZfD6ih/LRRfhqNok9yS63SmiSuDNvi0niGtoh/rg7dl9zBz5ni1O/1lY1gbS2NRt3", + "+wMeuWcQrl6Iqkno3j9bIK+OebyuVWjfN4mso2J//2nEY/gv255t+ApJvG0PqyPjXgGUe8qjecJ6ZR9u", + "FCRrmm4NaDXPd4pobkZwS4GlpvcQ95hHn3/SY7mKHfknvBvu/Wn+1UA1D0GGl1ym9RsPRG4Z9POSytUO", + "dkfAA/b5TrDPN+aY/rJA3hV8MGX5XWGC/ZvULw8wN00X+TUYMNWnwtbw2DoXmgpEebIo47gKwfMxFC4y", + "JeRNMjbauq2hp7fHu7vy32+yNd+o6Ny/wM4d7uVQl3IPDwutwZlwFsKLXy0gcrLMioS2rFxAPbkvQjhg", + "tmEibigMzizskVS56bYNYu09HDOBKDKjCiMhWay11hcrGciSVq0bLruWdEzlBcsEFRFbTxxs3wZAEQPX", + "Eo7yUSLkWg+JS6nImJLJBVOE0WhW3jbwmImcTzhiPpYhcOCgy0p8tZEwHZrYYYv1axiAxe7o2CdpUniu", + "mGqa9Ej4uRZA5vgFU3wq0OVyxkhEk4TFRAot7vwKVO4kY2pGoGLfBU1stIfxU9hVI1yNhH4HAu9sY9GM", + "xcNxi74oZ7815mazG7wdqYMfHL11nXCTu2WDina3yOepJAIyX3LKsjCbcmbaakymGb+gOVuz6GSSzGEv", + "29PtZjxe5R9OWTbQO5tKacRImvGIEfdpi8PY9jEo+wjvnNf37b1581ZvLMears+17DAQf8/cgm/evDU2", + "mMciTe7Xr+n13cxBuIx3W72GDebdkf/QcO470wsSfdMORF98gswGc/bZ+xAb3Nad2VZp0b0/gb/W9Sp2", + "Y03jZAyx5uoDiaHrwdm4E2fj7lgL1m3F7jxN5BlNSiLwmyGxqSb4N0QAlZqWgL7QpvqEULFYtYkbOhqs", + "Frw+NARs7/Jukw0+cL9sJmJLxa3NYScb2h/mMmaJ/qt2w8wg1ZJfsHGJU1z+lst7ee/8YH/dIfvLSfc2", + "lVZ1M1xyqWLDuGr0kLMFef2iVGMA1wAPWjXZSARV2ZTVNdnt7pn7N2a63UdnmmaqKiddl7EtmyzbhPGd", + "ZfHcOw2dwi92EDhFp9OMTYGAh0iq7pFUq9alGkdl3j5bkHO2WBFAZb757ZwtPv59vkAeG5yzxfbMLhCU", + "W09KBSru2c7sFEYlztMUiF3u74BPWx0b8HSnwVBA6S2FQkHfIa5Alf/ZuzDs6jW4IrRf7f0J/13XGdHC", + "N8brYHtebTWZTh88DTvxNLRywNKwJfjK2NNB6/gOLO/+TWmBe5Kiu4RTTK5tS3RRiyIwIUK3wym7Cg/q", + "vlndGJvev8CgNo5d83xW7nfrhTxYtTiRmakWBbVGWE5OD6OIpflzUl/cU/LIO7U81keQKbow8qyI8iJj", + "MfnPk3c/+/Z9pcGcXeV7kbo41Z/G8lIkkqKRr+icQfVmfTSi5OjkXwQqUKqCw8A1mSOhUoBdmzGWm3LF", + "+sVIJsVcqL4+XcDpp+8OdaeTTM77JJd9YvNv+x/JbzYeY8zjvgvOGJ+zhfeXFuP+R4IJGTGfMwF1QofD", + "IeZm9LFKV3nWM+2fGnr0QY1hTisGJl7OmPDe4sqehmC5vlIjcTrNZJGOzxbjsr9THGc+yxgjp466/2W7", + "wURZ21EupwzK8OkeRwK79EYb6JaEe20J7fhS9F8wAuzG1V81Fqzfs/KhP2ZXdJ4m2PEPeoUwEboSSlQu", + "GHRcboCr3+/3gH31yViLSC77vlBUZKIqEuDm7+eLlPWhhZF4sv/k6WD/YLB/8H5//zn879/92o8H8OP+", + "wQ/ffP3vv3799eGrXw9/+vHlwZOf/2v/6J/fvfqxT6M5G3AR9Q+jOSOvRTTsT9N88GyQF9mZ7HORFnn/", + "4Emjt4NQb0+20tuT/UZvT0K9Pa329v3T//r3wU+/HH7367f/+uvxyZMX/Wkiz9hV/wf4DzmSWVrpTRa5", + "7u6Z3kd+lgTEcXC2aF3dlneaK9p5fbrNb7f5eYa7nhMOkxCr8oyL6YPz1o+K2tgSSBMq1sh1hddafLXY", + "xA5dtdDBti4hnccW8GA7+WjviId0xXRsz5t5rDu6bWemJuKe+TKtQDWvYI4zGRdRTo5oThM53bxKiu6i", + "1eWpH+7U46nX9HaLimgKggyUUPH5ez3NAm7GP4H9Ye9P/Z+1g7T0HC7P+zQErnGjDP0+uEZ34hq9Fpss", + "dZ8uY4Epy29//fdvVKE8ZHs2va3XZL7lHtll/GfcsrfBgrtwyiqW5Z3305tl/y8aNXFzKTDcurPNeo/G", + "8UoQdhrHA4A8V0pGHMweCBajLSaiO/ENTOs3J0J3MQYyoeJQz8ND6cflMMmWzSYyu7bmDxdUj2Mo6Qj9", + "YArlyjMOsvDnvwmUhyrgxVs6Wbn+2/YBeHifCpcDTzqG3LWex79hklec1H5hc3nBPHGZZHLeKjDeke3G", + "Babf2rYZ58PJcLssa1nD44udnRId+1nbg+suIY8+zIn25Hgf2HD/pvXyfanxGWa5XZ5GO/O5d0L9Qll9", + "lwfh7jbQjcvavSsjsAupW24SZdGMX7D2iKZDfMH6isxlYFMWTUP3zWN5j2LpLCf4fLAbpkyLs4SrWTtT", + "HuMLK5nSNPTAlF8sU1pO2AVTZnLCk1Up8me4HsS+3eIJNK8NXKNbCQO5CUZDgu9ZZEF9VYMsZWaInLA8", + "52K6Vg6VYJf1xiE4+Ptah0SvITUhK8p0ALaA/dqU58wzmShbxngkpky4os2HolqWKKICKxvMiyTnacIa", + "wyQxm3DB4iE5HInaQ8IVSbg4x/xIL7eapumQvJ9xVTFbuCIMhIurGYtHIi4yW2ij1vBXCn1dtsQ9VopW", + "ZRHTVt9kTah2GopRFYdbDsow4w2IX/WNzz9CIygx60pjWJ/v/cnXDNAICSoU9lZFNGsKj4HCjY0XLJ/R", + "3AusEzKvJCabz+yjlAuDKEiFF1pcKN2F+9NBE+jPIPQdBHrCBU30tFtFoNq8k02RWW0U8Qfv4W7iSuim", + "jL00pqTOtUH34F3hg/3b0433xZG3OZMtjx1ZyWfGPXeLrLYr99k1jIFbZPj7l/dHt2M5qOLMTeuK6tjV", + "V3cY61/paFsx/9QDE6uF99N7jSkWzC+oLMEW0wlO/HZvO63AJ+YheGd58E5d+JuqprK0FX9B8IDrN7ij", + "061Rfj5ht4MVGyAkxFr+8y88RkZ/8N3qD46kmCQ8ysMH6BoLrWbJJVvf3p/+n1X4veYRo9bzaqOv2vhn", + "cNboxKv35LixU35bK1JX2x42jBJKsPiNtLjn/Ve6BOxul2X7uzIQCQ5pEzNxJAJ24gNS302XB/el5iGQ", + "uqMtRpxEr1RHXSOpvTDq5WomYNF1iFnawda4q4uSBqfe0l1Jg45VO/R9CLveikmJdzJ1ARust9+Hi8ws", + "vYhfyyao/u5Hd28UWLtcmOvm7a1Jcn9lH59B4O2Gknq/A3G72tnXlbKIiogl7SFZR/AcLbqK8JBfeZLo", + "xdI2HhdatqIZiwtwuUZG0RA+0V9mjNCMjYQEoK2qi9N8ZYy+nGordaIHCvUWoXecnZzPQyED8MadOJTe", + "jBMH1+t27iQ6HYy/7GuJa+64sIo7PlRHMyqmS0KAjxKpmCKUZIUQWmqrW7+IURyVMQykgIpzMoOTWC6x", + "GqMNFzKxSUembLA+xAFMYjrNaMxUH7AL7b912xDZhyQGguvwwT0Sa1yr2xdrJOTLq6R40wIO07hjAS+E", + "3TwH3kbZLvAf3PvN/dzfagNX/uGeHry/D5tcuwyU7NbKaRvIRE6vBpGsFiANeH7L13ZzWf9aREkRe1GB", + "9IpAfyE8unW8lRwbHJsGewHgxzMpE0bFzXoo39OrIxnft0Bxt5xBDn1Pr1a4FINOQsuTOw1oNut1u5HM", + "hoig+YCPPv8QZssinTikRZft/ZnjtDSQC4LRvh4jrd6AXcsP0b47ifbdiA/67ffrd2Vx929BKdwT39+G", + "LGPiduvRuIplt8o1u4rG3WQnuw2mfYB3a4F3g2nZbJvULbHsIlw0+I2MaNLr94os6T3vzfI8fb63l+gf", + "Z1Llz/9MZZZ/2qMp37t4ChjvGddtKzwZZ+ZkDNEJvee9b7/99ltY3kY2MqaWYpDPFE8rZZfq+d7en/j7", + "pyFN+fBciuns92Ek54FuTQOVjgttXDJRzPWc4B9Fr9+j+v/mDONOP4YIK+fvKJFF3CDLGRjDSD+3M6Gl", + "1SxB49pMXrBM6HMZYRc0KdDjLicuQ0mRXJJoxqJzfbjhGZkwmhcZeASZAgee0S0lcWWjgfPTOy+DcZCw", + "C5a4gJFIigmfFpnzRTRafoFvql7ropEI84HJnAo6ZQoxpfs2gAhdkDgS7wZGNa5gBmdUsdiGmweJqWcg", + "N2lytUVjmlPdIMFK0FxMiZDZ3OR4pRmP9E9Q00UTklAxLfRxCgpIKEKjTCpFbBlpNSRY3xrqmaiFiFiM", + "kEUuEZRd4Y0sUbLI4E0RE1rkcgCTnM1ZjEVW8hlbEDrNGAuO0ZU+DQRNIyMokrE0Y4oJSIEza5DSM57w", + "nDNFzmh0jvU1cG/qm6K8NmooZdmgEDzHmVrNA7bfAEnv3VlcT4wNKIpoEhWJsdwZLrVj72AXWjs1Wz8q", + "soyJiJvZBHL1oq7TYvltoGGbr+DSgi3vBpJrsW+bFbhGz41kiGb/h2mqCBNQO2ghCz1nmn80x+hxQvP8", + "D1bJVIYySORSZueTRF5CIVIucjbVCyemuMQlEy5UzuZIutbuWHQeuo2oAL6cI2JQTJiYgTpayKLMjWaR", + "xDZ0PwpD2+C60Wc0SOKkCgRilknB/9CvIKEgWkBUPuNZPEhpli+0bsgnMpurvmMSuOLQbNInNvXajDhm", + "Cb9gkPRsp79PZlTEuDx0MdciEMkkYbB3oKrBm0+bMpWxhKLTSJ2Hl0tPSmCJXoqc5wnTXdSYGzPGjTrW", + "v0ysXK7mDb/VUNhh5b7W7zXPaHRuplZOcK2s8GtFims8rHr0bD4tFzG/4HFBE6Vf9lPaFSbZ6heNMj5j", + "FkIQ2QfSY5uDDQ6v6k8MCbTd4zYZW/n1TY/L9RwYE7wBInPR4JV1R/ay/DTNpCaJxYRasZKFShZaDrV2", + "sipdSdxJ5nQB2c96OuZzFnOas2RB6AXlia1NhtW0qruqIxv7bhuYctGhM3kJUXqm5jSz460jKlBBk0XO", + "I0XSIkul0orHNGWWze44FgDY7aFePWs9zpmMcamgoJBWpUPy1r47rzZpXFyaGFexDQgkUAwKla0mcZKw", + "K35mG4BNIGKCZlyq+uyo3qePn/7/AAAA//96PGsWpk8FAA==", } // GetSwagger returns the content of the embedded swagger specification file diff --git a/api/v3/client/README.md b/api/v3/client/README.md index d30ba7331b..410ca137eb 100644 --- a/api/v3/client/README.md +++ b/api/v3/client/README.md @@ -221,6 +221,10 @@ The full call path, HTTP route, and a short description are listed below. | `om.Invoices.Get` | `GET /openmeter/billing/invoices/{invoiceId}` | Get a billing invoice by ID. Returns the full invoice resource including line items, status details, totals, and workflow configuration snapshot. | | `om.Invoices.Update` | `PUT /openmeter/billing/invoices/{invoiceId}` | Update a billing invoice. Only the mutable fields of the invoice can be edited: description, labels, supplier, customer, workflow settings, and top-level lines. Top-level lines are matched by `id`; lines without an `id` are created, and existing lines omitted from `lines` are deleted. Detailed (child) lines are always computed and cannot be edited directly. Only invoices in draft status can be updated. | | `om.Invoices.Delete` | `DELETE /openmeter/billing/invoices/{invoiceId}` | Delete a billing invoice. Only standard invoices in draft status can be deleted. Deleting an invoice will also delete all associated line items and workflow configuration. | +| `om.Invoices.Advance` | `POST /openmeter/billing/invoices/{invoiceId}/advance` | Advance a billing invoice. Advances the invoice to the next workflow state. The next state is determined by the invoice's current status and workflow configuration. Only invoices in draft or issued status can be advanced. | +| `om.Invoices.Approve` | `POST /openmeter/billing/invoices/{invoiceId}/approve` | Approve a billing invoice. This call instantly sends the invoice to the customer using the configured billing profile app. This call is valid in two invoice statuses: - draft: the invoice will be sent to the customer, the invoice state becomes issued - manual_approval_needed: the invoice will be sent to the customer, the invoice state becomes issued | +| `om.Invoices.Retry` | `POST /openmeter/billing/invoices/{invoiceId}/retry` | Retry sending a billing invoice. Retry advancing the invoice after a failed attempt. The action can be called when the invoice's statusDetails' actions field contain the "retry" action. | +| `om.Invoices.SnapshotQuantities` | `POST /openmeter/billing/invoices/{invoiceId}/snapshot-quantities` | Snapshot quantities for usage-based line items. This call will snapshot the quantities for all usage based line items in the invoice. This call is only valid in draft.waiting_for_collection status, where the collection period can be skipped using this action. | ### Tax diff --git a/api/v3/client/invoices.go b/api/v3/client/invoices.go index b3538c3be4..f66bc5d3d3 100644 --- a/api/v3/client/invoices.go +++ b/api/v3/client/invoices.go @@ -163,3 +163,120 @@ func (s *InvoicesService) Delete(ctx context.Context, invoiceID string) error { _, err = s.client.doRaw(req) return err } + +// Advance a billing invoice. +// +// Advances the invoice to the next workflow state. The next state is determined by +// the invoice's current status and workflow configuration. Only invoices in draft +// or issued status can be advanced. +func (s *InvoicesService) Advance(ctx context.Context, invoiceID string) (*Invoice, error) { + if invoiceID == "" { + return nil, fmt.Errorf("openmeter: %s must not be empty: %w", "invoiceID", ErrEmptyID) + } + + path := "/openmeter/billing/invoices/{invoiceId}/advance" + + path = replacePathParam(path, "invoiceId", invoiceID) + + req, err := s.client.newRequestWithContentType(ctx, http.MethodPost, path, nil, nil, "", "application/json") + if err != nil { + return nil, err + } + + var out Invoice + if err := s.client.doJSON(req, &out); err != nil { + return nil, err + } + + return &out, nil +} + +// Approve a billing invoice. +// +// This call instantly sends the invoice to the customer using the configured +// billing profile app. +// +// This call is valid in two invoice statuses: +// +// - draft: the invoice will be sent to the customer, the invoice state becomes +// issued +// - manual_approval_needed: the invoice will be sent to the customer, the invoice +// state becomes issued +func (s *InvoicesService) Approve(ctx context.Context, invoiceID string) (*Invoice, error) { + if invoiceID == "" { + return nil, fmt.Errorf("openmeter: %s must not be empty: %w", "invoiceID", ErrEmptyID) + } + + path := "/openmeter/billing/invoices/{invoiceId}/approve" + + path = replacePathParam(path, "invoiceId", invoiceID) + + req, err := s.client.newRequestWithContentType(ctx, http.MethodPost, path, nil, nil, "", "application/json") + if err != nil { + return nil, err + } + + var out Invoice + if err := s.client.doJSON(req, &out); err != nil { + return nil, err + } + + return &out, nil +} + +// Retry sending a billing invoice. +// +// Retry advancing the invoice after a failed attempt. +// +// The action can be called when the invoice's statusDetails' actions field contain +// the "retry" action. +func (s *InvoicesService) Retry(ctx context.Context, invoiceID string) (*Invoice, error) { + if invoiceID == "" { + return nil, fmt.Errorf("openmeter: %s must not be empty: %w", "invoiceID", ErrEmptyID) + } + + path := "/openmeter/billing/invoices/{invoiceId}/retry" + + path = replacePathParam(path, "invoiceId", invoiceID) + + req, err := s.client.newRequestWithContentType(ctx, http.MethodPost, path, nil, nil, "", "application/json") + if err != nil { + return nil, err + } + + var out Invoice + if err := s.client.doJSON(req, &out); err != nil { + return nil, err + } + + return &out, nil +} + +// Snapshot quantities for usage-based line items. +// +// This call will snapshot the quantities for all usage based line items in the +// invoice. +// +// This call is only valid in draft.waiting_for_collection status, where the +// collection period can be skipped using this action. +func (s *InvoicesService) SnapshotQuantities(ctx context.Context, invoiceID string) (*Invoice, error) { + if invoiceID == "" { + return nil, fmt.Errorf("openmeter: %s must not be empty: %w", "invoiceID", ErrEmptyID) + } + + path := "/openmeter/billing/invoices/{invoiceId}/snapshot-quantities" + + path = replacePathParam(path, "invoiceId", invoiceID) + + req, err := s.client.newRequestWithContentType(ctx, http.MethodPost, path, nil, nil, "", "application/json") + if err != nil { + return nil, err + } + + var out Invoice + if err := s.client.doJSON(req, &out); err != nil { + return nil, err + } + + return &out, nil +} diff --git a/api/v3/handlers/billinginvoices/action.go b/api/v3/handlers/billinginvoices/action.go new file mode 100644 index 0000000000..25adb1a77a --- /dev/null +++ b/api/v3/handlers/billinginvoices/action.go @@ -0,0 +1,100 @@ +package billinginvoices + +import ( + "context" + "fmt" + "net/http" + "slices" + + api "github.com/openmeterio/openmeter/api/v3" + "github.com/openmeterio/openmeter/api/v3/apierrors" + "github.com/openmeterio/openmeter/openmeter/billing" + "github.com/openmeterio/openmeter/pkg/framework/commonhttp" + "github.com/openmeterio/openmeter/pkg/framework/transport/httptransport" + "github.com/openmeterio/openmeter/pkg/models" +) + +type ProgressAction string + +const ( + InvoiceProgressActionApprove ProgressAction = "approve" + InvoiceProgressActionRetry ProgressAction = "retry" + InvoiceProgressActionAdvance ProgressAction = "advance" + InvoiceProgressActionSnapshotQuantities ProgressAction = "snapshot_quantities" +) + +var ( + InvoiceProgressActions = []ProgressAction{ + InvoiceProgressActionApprove, + InvoiceProgressActionRetry, + InvoiceProgressActionAdvance, + InvoiceProgressActionSnapshotQuantities, + } + invoiceProgressOperationNames = map[ProgressAction]string{ + InvoiceProgressActionAdvance: "advance-invoice", + InvoiceProgressActionApprove: "approve-invoice", + InvoiceProgressActionRetry: "retry-invoice", + InvoiceProgressActionSnapshotQuantities: "snapshot-quantities-invoice", + } +) + +type ( + ProgressInvoiceRequest struct { + Invoice billing.InvoiceID + } + ProgressInvoiceResponse = api.BillingInvoice + ProgressInvoiceParams = string + ProgressInvoiceHandler httptransport.HandlerWithArgs[ProgressInvoiceRequest, ProgressInvoiceResponse, ProgressInvoiceParams] +) + +func (h *handler) ProgressInvoice(action ProgressAction) ProgressInvoiceHandler { + return httptransport.NewHandlerWithArgs( + func(ctx context.Context, r *http.Request, params ProgressInvoiceParams) (ProgressInvoiceRequest, error) { + ns, err := h.resolveNamespace(ctx) + if err != nil { + return ProgressInvoiceRequest{}, fmt.Errorf("failed to resolve namespace: %w", err) + } + + if !slices.Contains(InvoiceProgressActions, action) { + return ProgressInvoiceRequest{}, fmt.Errorf("invalid action: %s", action) + } + + return ProgressInvoiceRequest{ + Invoice: billing.InvoiceID{ + ID: params, + Namespace: ns, + }, + }, nil + }, + func(ctx context.Context, request ProgressInvoiceRequest) (ProgressInvoiceResponse, error) { + var invoice billing.StandardInvoice + var err error + + switch action { + case InvoiceProgressActionApprove: + invoice, err = h.service.ApproveInvoice(ctx, request.Invoice) + case InvoiceProgressActionRetry: + invoice, err = h.service.RetryInvoice(ctx, request.Invoice) + case InvoiceProgressActionAdvance: + invoice, err = h.service.AdvanceInvoice(ctx, request.Invoice) + case InvoiceProgressActionSnapshotQuantities: + invoice, err = h.service.ForceCollectInvoice(ctx, request.Invoice) + default: + return ProgressInvoiceResponse{}, models.NewGenericValidationError(fmt.Errorf("invalid action: %s", action)) + } + + if err != nil { + return ProgressInvoiceResponse{}, err + } + + return ToAPIStandardInvoice(invoice) + }, + commonhttp.JSONResponseEncoderWithStatus[ProgressInvoiceResponse](http.StatusOK), + httptransport.AppendOptions( + h.options, + httptransport.WithOperationName(invoiceProgressOperationNames[action]), + httptransport.WithErrorEncoder(apierrors.GenericErrorEncoder()), + httptransport.WithErrorEncoder(errorEncoder()), + )..., + ) +} diff --git a/api/v3/handlers/billinginvoices/convert.go b/api/v3/handlers/billinginvoices/convert.go index e48674b60d..31577392cf 100644 --- a/api/v3/handlers/billinginvoices/convert.go +++ b/api/v3/handlers/billinginvoices/convert.go @@ -30,33 +30,35 @@ import ( // ToAPIBillingInvoice converts a billing.Invoice domain union to the v3 API type. func ToAPIBillingInvoice(inv billing.Invoice) (api.BillingInvoice, error) { - var out api.BillingInvoice - switch inv.Type() { case billing.InvoiceTypeStandard: std, err := inv.AsStandardInvoice() if err != nil { - return out, fmt.Errorf("reading standard invoice: %w", err) - } - - stdAPI, err := toAPIStandardInvoice(std) - if err != nil { - return out, err - } - - if err := out.FromBillingInvoiceStandard(stdAPI); err != nil { - return out, fmt.Errorf("setting standard invoice union: %w", err) + return api.BillingInvoice{}, fmt.Errorf("reading standard invoice: %w", err) } + return ToAPIStandardInvoice(std) default: genericInv, _ := inv.AsGenericInvoice() - return out, billing.NotFoundError{ + return api.BillingInvoice{}, billing.NotFoundError{ ID: genericInv.GetID(), Entity: billing.EntityInvoice, Err: fmt.Errorf("unsupported invoice type %q", inv.Type()), } } +} + +func ToAPIStandardInvoice(std billing.StandardInvoice) (api.BillingInvoice, error) { + var out api.BillingInvoice + stdAPI, err := toAPIStandardInvoice(std) + if err != nil { + return out, err + } + + if err := out.FromBillingInvoiceStandard(stdAPI); err != nil { + return out, fmt.Errorf("setting standard invoice union: %w", err) + } return out, nil } diff --git a/api/v3/handlers/billinginvoices/handler.go b/api/v3/handlers/billinginvoices/handler.go index 189b2e3b56..92fc1b28ce 100644 --- a/api/v3/handlers/billinginvoices/handler.go +++ b/api/v3/handlers/billinginvoices/handler.go @@ -12,6 +12,7 @@ type Handler interface { GetBillingInvoice() GetBillingInvoiceHandler UpdateBillingInvoice() UpdateBillingInvoiceHandler DeleteBillingInvoice() DeleteBillingInvoiceHandler + ProgressInvoice(action ProgressAction) ProgressInvoiceHandler } type handler struct { diff --git a/api/v3/openapi.yaml b/api/v3/openapi.yaml index d2c3142efc..1cf2fbfc67 100644 --- a/api/v3/openapi.yaml +++ b/api/v3/openapi.yaml @@ -496,6 +496,159 @@ paths: x-private: true x-internal: true x-unstable: true + /openmeter/billing/invoices/{invoiceId}/advance: + post: + operationId: advance-invoice + summary: Advance billing invoice's next status + description: |- + Advance a billing invoice. + + Advances the invoice to the next workflow state. The next state is determined by + the invoice's current status and workflow configuration. Only invoices in draft + or issued status can be advanced. + parameters: + - name: invoiceId + in: path + required: true + schema: + $ref: '#/components/schemas/ULID' + responses: + '200': + description: Invoice response. + content: + application/json: + schema: + $ref: '#/components/schemas/BillingInvoice' + '400': + $ref: '#/components/responses/BadRequest' + '401': + $ref: '#/components/responses/Unauthorized' + '403': + $ref: '#/components/responses/Forbidden' + '404': + $ref: '#/components/responses/NotFound' + tags: + - OpenMeter Billing Settings + x-private: true + x-internal: true + x-unstable: true + /openmeter/billing/invoices/{invoiceId}/approve: + post: + operationId: approve-invoice + summary: Send the invoice to the customer + description: |- + Approve a billing invoice. + + This call instantly sends the invoice to the customer using the configured + billing profile app. + + This call is valid in two invoice statuses: + + - draft: the invoice will be sent to the customer, the invoice state becomes + issued + - manual_approval_needed: the invoice will be sent to the customer, the invoice + state becomes issued + parameters: + - name: invoiceId + in: path + required: true + schema: + $ref: '#/components/schemas/ULID' + responses: + '200': + description: Invoice response. + content: + application/json: + schema: + $ref: '#/components/schemas/BillingInvoice' + '400': + $ref: '#/components/responses/BadRequest' + '401': + $ref: '#/components/responses/Unauthorized' + '403': + $ref: '#/components/responses/Forbidden' + '404': + $ref: '#/components/responses/NotFound' + tags: + - OpenMeter Billing Settings + x-private: true + x-internal: true + x-unstable: true + /openmeter/billing/invoices/{invoiceId}/retry: + post: + operationId: retry-invoice + summary: Retry advancing the invoice after a failed attempt + description: |- + Retry sending a billing invoice. + + Retry advancing the invoice after a failed attempt. + + The action can be called when the invoice's statusDetails' actions field contain + the "retry" action. + parameters: + - name: invoiceId + in: path + required: true + schema: + $ref: '#/components/schemas/ULID' + responses: + '200': + description: Invoice response. + content: + application/json: + schema: + $ref: '#/components/schemas/BillingInvoice' + '400': + $ref: '#/components/responses/BadRequest' + '401': + $ref: '#/components/responses/Unauthorized' + '403': + $ref: '#/components/responses/Forbidden' + '404': + $ref: '#/components/responses/NotFound' + tags: + - OpenMeter Billing Settings + x-private: true + x-internal: true + x-unstable: true + /openmeter/billing/invoices/{invoiceId}/snapshot-quantities: + post: + operationId: snapshot-quantities-invoice + summary: Snapshot quantities for usage based line items + description: |- + Snapshot quantities for usage-based line items. + + This call will snapshot the quantities for all usage based line items in the + invoice. + + This call is only valid in draft.waiting_for_collection status, where the + collection period can be skipped using this action. + parameters: + - name: invoiceId + in: path + required: true + schema: + $ref: '#/components/schemas/ULID' + responses: + '200': + description: Invoice response. + content: + application/json: + schema: + $ref: '#/components/schemas/BillingInvoice' + '400': + $ref: '#/components/responses/BadRequest' + '401': + $ref: '#/components/responses/Unauthorized' + '403': + $ref: '#/components/responses/Forbidden' + '404': + $ref: '#/components/responses/NotFound' + tags: + - OpenMeter Billing Settings + x-private: true + x-internal: true + x-unstable: true /openmeter/currencies: get: operationId: list-currencies diff --git a/api/v3/server/routes.go b/api/v3/server/routes.go index f5650ba460..3ff437abb8 100644 --- a/api/v3/server/routes.go +++ b/api/v3/server/routes.go @@ -4,6 +4,7 @@ import ( "net/http" api "github.com/openmeterio/openmeter/api/v3" + "github.com/openmeterio/openmeter/api/v3/handlers/billinginvoices" currencieshandler "github.com/openmeterio/openmeter/api/v3/handlers/currencies" chargeshandler "github.com/openmeterio/openmeter/api/v3/handlers/customers/charges" customerscreditshandler "github.com/openmeterio/openmeter/api/v3/handlers/customers/credits" @@ -189,6 +190,26 @@ func (s *Server) DeleteInvoice(w http.ResponseWriter, r *http.Request, invoiceId s.billingInvoicesHandler.DeleteBillingInvoice().With(invoiceId).ServeHTTP(w, r) } +func (s *Server) AdvanceInvoice(w http.ResponseWriter, r *http.Request, invoiceId api.ULID) { + s.billingInvoicesHandler.ProgressInvoice(billinginvoices.InvoiceProgressActionAdvance). + With(invoiceId).ServeHTTP(w, r) +} + +func (s *Server) ApproveInvoice(w http.ResponseWriter, r *http.Request, invoiceId api.ULID) { + s.billingInvoicesHandler.ProgressInvoice(billinginvoices.InvoiceProgressActionApprove). + With(invoiceId).ServeHTTP(w, r) +} + +func (s *Server) RetryInvoice(w http.ResponseWriter, r *http.Request, invoiceId api.ULID) { + s.billingInvoicesHandler.ProgressInvoice(billinginvoices.InvoiceProgressActionRetry). + With(invoiceId).ServeHTTP(w, r) +} + +func (s *Server) SnapshotQuantitiesInvoice(w http.ResponseWriter, r *http.Request, invoiceId api.ULID) { + s.billingInvoicesHandler.ProgressInvoice(billinginvoices.InvoiceProgressActionSnapshotQuantities). + With(invoiceId).ServeHTTP(w, r) +} + // Customer Billing func (s *Server) GetCustomerBilling(w http.ResponseWriter, r *http.Request, customerId api.ULID) { diff --git a/e2e/billinginvoices_v3_test.go b/e2e/billinginvoices_v3_test.go index 8753b5b1fe..9206ef4e6f 100644 --- a/e2e/billinginvoices_v3_test.go +++ b/e2e/billinginvoices_v3_test.go @@ -15,6 +15,7 @@ import ( api "github.com/openmeterio/openmeter/api/client/go" v3sdk "github.com/openmeterio/openmeter/api/v3/client" + "github.com/openmeterio/openmeter/openmeter/billing" ) // TestV3GetBillingInvoice exercises GET /api/v3/openmeter/billing/invoices/{invoiceId}. @@ -624,13 +625,12 @@ func TestV3UpdateBillingInvoice(t *testing.T) { }) c.requireStatus(http.StatusCreated, err) - f, err := c.Features.Create(t.Context(), v3sdk.CreateFeatureRequest{ + feature, err = c.Features.Create(t.Context(), v3sdk.CreateFeatureRequest{ Key: uniqueKey("listinv_feature"), Name: gofakeit.ProductName(), Meter: &v3sdk.FeatureMeterReferenceInput{ID: meter.ID}, }) c.requireStatus(http.StatusCreated, err) - feature = f plan, err := c.Plans.Create(t.Context(), v3sdk.CreatePlanRequest{ Key: uniqueKey("listinv_plan"), @@ -1190,3 +1190,741 @@ func TestV3DeleteBillingInvoice(t *testing.T) { assert.NotNil(t, problem) }) } + +// TestV3AdvanceBillingInvoice exercises POST /api/v3/openmeter/billing/invoices/{invoiceId}/advance +// Flow: +// - Create a customer (v3) +// - Create a standard invoice with draft status (v1) +// - Apply the advance operation via v3 POST and assert 200 +// - Attempt to advance the same invoice again and assert 400 +// - Attempt to advance a gathering invoice via v3 POST and assert 400 +func TestV3AdvanceBillingInvoice(t *testing.T) { + c := newV3Client(t) + v1 := initClient(t) + + var ( + customerID string + planID string + invoiceID string // standard invoice ID + gatheringInvoiceID string // gathering invoice ID + ) + + t.Run("Should create a customer", func(t *testing.T) { + key := uniqueKey("advanceinv_customer") + + customer, err := c.Customers.Create(t.Context(), v3sdk.CreateCustomerRequest{ + Key: key, + Name: gofakeit.ProductName(), + Currency: lo.ToPtr("USD"), + }) + c.requireStatus(http.StatusCreated, err) + require.NotNil(t, customer) + customerID = customer.ID + }) + + t.Run("Should pin the customer to a short-draft-period billing profile", func(t *testing.T) { + require.NotEmpty(t, customerID, "depends on customer creation") + + // A short, nonzero draft period parks the invoice in draft.waiting_auto_approval + // right after creation (auto-advance is otherwise instantaneous with the default + // P0D draft period, which would leave nothing in draft to advance). Once the + // period elapses, the first advance call unblocks trigger_next and drives the + // invoice forward; the second call then finds no further automatic transition. + // + // The default profile's payment settings auto-charge via CollectionMethodChargeAutomatically, + // which (with credits enabled in e2e) settles the invoice to "paid" synchronously + // the moment it's advanced past issued — leaving nothing observable to assert on. + // Overriding payment to send_invoice (same as the manual-approval profiles used + // elsewhere in this file) stops that auto-settlement, so advancing lands on a real, + // inspectable non-final status instead. + profile := createNewBillingProfileFromDefault(t, c, uniqueKey("advance_invoice"), func(profile *v3sdk.CreateBillingProfileRequest) { + profile.Name = uniqueKey("advance_invoice_profile") + if profile.Workflow.Invoicing == nil { + profile.Workflow.Invoicing = &v3sdk.WorkflowInvoicingSettings{} + } + profile.Workflow.Invoicing.AutoAdvance = lo.ToPtr(true) + profile.Workflow.Invoicing.DraftPeriod = lo.ToPtr("PT5S") + + sendInvoice := lo.Must(v3sdk.WorkflowPaymentSettingsFromWorkflowPaymentSendInvoiceSettings(v3sdk.WorkflowPaymentSendInvoiceSettings{ + CollectionMethod: v3sdk.CollectionMethodSendInvoice, + })) + profile.Workflow.Payment = &sendInvoice + }) + + _, err := c.Customers.Billing.Update(t.Context(), customerID, v3sdk.UpsertCustomerBillingDataRequest{ + BillingProfile: &v3sdk.ProfileReference{ID: profile.ID}, + }) + c.requireStatus(http.StatusOK, err) + }) + + t.Run("Should create a single gathering invoice", func(t *testing.T) { + require.NotEmpty(t, customerID, "depends on customer creation") + + now := time.Now().UTC() + price := api.RateCardUsageBasedPrice{} + require.NoError(t, price.FromFlatPriceWithPaymentTerm(api.FlatPriceWithPaymentTerm{ + Amount: api.Numeric("10.00"), + Type: api.FlatPriceWithPaymentTermTypeFlat, + PaymentTerm: lo.ToPtr(api.PricePaymentTermInAdvance), + })) + + invoiceAt := now.Add(time.Hour) + lineResp, err := v1.CreatePendingInvoiceLineWithResponse(t.Context(), customerID, api.InvoicePendingLineCreateInput{ + Currency: "USD", + Lines: []api.InvoicePendingLineCreate{ + { + Name: uniqueKey("advance_inv_gathering_line"), + InvoiceAt: invoiceAt, + Period: api.Period{ + From: now.Add(-24 * time.Hour), + To: invoiceAt, + }, + Price: &price, + }, + }, + }) + require.NoError(t, err) + require.Equal(t, http.StatusCreated, lineResp.StatusCode(), "line: %s", string(lineResp.Body)) + require.NotNil(t, lineResp.JSON201) + + gatheringInvoiceID = (*lineResp.JSON201).Invoice.Id + require.NotEmpty(t, gatheringInvoiceID) + }) + + t.Run("Should create meter, feature, plan, and subscription", func(t *testing.T) { + require.NotEmpty(t, customerID, "depends on customer creation") + + // An active subscription is what actually drives the billing-worker's sync + // loop for this customer; without one, a raw past-due pending line just sits + // in the gathering invoice forever (nothing else periodically collects it). + meter, err := c.Meters.Create(t.Context(), v3sdk.CreateMeterRequest{ + Key: uniqueKey("advanceinv_meter"), + Name: gofakeit.ProductName(), + Aggregation: v3sdk.MeterAggregationCount, + EventType: uniqueKey("advanceinv_event"), + }) + c.requireStatus(http.StatusCreated, err) + + feature, err := c.Features.Create(t.Context(), v3sdk.CreateFeatureRequest{ + Key: uniqueKey("advanceinv_feature"), + Name: gofakeit.ProductName(), + Meter: &v3sdk.FeatureMeterReferenceInput{ID: meter.ID}, + }) + c.requireStatus(http.StatusCreated, err) + + plan, err := c.Plans.Create(t.Context(), v3sdk.CreatePlanRequest{ + Key: uniqueKey("advanceinv_plan"), + Name: gofakeit.ProductName(), + Currency: "USD", + BillingCadence: "P1M", + Phases: []v3sdk.PlanPhaseInput{{ + Key: uniqueKey("inv_phase_1"), + Name: uniqueKey("Test Phase"), + RateCards: []v3sdk.RateCardInput{validUnitRateCard(*feature)}, + }}, + }) + c.requireStatus(http.StatusCreated, err) + planID = plan.ID + + plan, err = c.Plans.Publish(t.Context(), planID) + c.requireStatus(http.StatusOK, err) + assert.Equal(t, v3sdk.PlanStatusActive, plan.Status) + + _, err = c.Subscriptions.Create(t.Context(), v3sdk.SubscriptionCreate{ + Customer: v3sdk.SubscriptionChangeCustomer{ID: lo.ToPtr(customerID)}, + Plan: v3sdk.SubscriptionChangePlan{ID: lo.ToPtr(planID)}, + }) + c.requireStatus(http.StatusCreated, err) + }) + + t.Run("Should create a standard invoice in draft status", func(t *testing.T) { + require.NotEmpty(t, customerID, "depends on customer creation") + + now := time.Now().UTC() + price := api.RateCardUsageBasedPrice{} + require.NoError(t, price.FromFlatPriceWithPaymentTerm(api.FlatPriceWithPaymentTerm{ + Amount: api.Numeric("10.00"), + Type: api.FlatPriceWithPaymentTermTypeFlat, + PaymentTerm: lo.ToPtr(api.PricePaymentTermInAdvance), + })) + + lineResp, err := v1.CreatePendingInvoiceLineWithResponse(t.Context(), customerID, api.InvoicePendingLineCreateInput{ + Currency: "USD", + Lines: []api.InvoicePendingLineCreate{{ + Name: uniqueKey("advanceinv_line"), + InvoiceAt: now.Add(-10 * time.Hour), + Period: api.Period{ + From: now.Add(-24 * time.Hour), + To: now.Add(-2 * time.Hour), + }, + Price: &price, + }}, + }) + require.NoError(t, err) + require.Equal(t, http.StatusCreated, lineResp.StatusCode()) + + ctx := t.Context() + customers := api.InvoiceListParamsCustomers{customerID} + assert.EventuallyWithT(t, func(co *assert.CollectT) { + listResp, err := v1.ListInvoicesWithResponse(ctx, &api.ListInvoicesParams{ + Customers: &customers, + PageSize: lo.ToPtr(api.PaginationPageSize(100)), + }) + require.NoError(co, err) + require.Equal(co, http.StatusOK, listResp.StatusCode()) + + invoice, found := lo.Find(listResp.JSON200.Items, func(inv api.Invoice) bool { + return inv.Status == api.InvoiceStatusDraft + }) + assert.True(co, found, "charges have not advanced a pending line into a standard invoice yet") + if found { + invoiceID = invoice.Id + } + }, time.Minute, time.Second) + require.NotEmpty(t, invoiceID) + }) + + t.Run("Should advance the standard invoice via v3 POST", func(t *testing.T) { + require.NotEmpty(t, invoiceID, "depends on invoice creation") + + // The invoice rests in draft.waiting_auto_approval until the draft period + // (PT5S) elapses, so retry until the state machine's guard clears. + assert.EventuallyWithT(t, func(co *assert.CollectT) { + inv, err := c.Invoices.Advance(t.Context(), invoiceID) + require.Equal(co, http.StatusOK, c.statuses.last()) + require.NoError(co, err) + require.NotNil(co, inv) + + stdInv, err := inv.AsInvoiceStandard() + require.NoError(co, err) + assert.Equal(co, invoiceID, stdInv.ID) + // send_invoice payment settings prevent auto-settlement, so advancing + // should land on a real non-final status (e.g. issued/payment_processing), + // not race straight through to paid. + assert.NotEqual(co, v3sdk.InvoiceStandardStatusPaid, stdInv.Status) + }, 20*time.Second, time.Second) + }) + + t.Run("Should return 400 when advancing the same invoice again", func(t *testing.T) { + require.NotEmpty(t, invoiceID, "depends on invoice advance") + + inv, err := c.Invoices.Advance(t.Context(), invoiceID) + require.Equal(t, http.StatusBadRequest, c.statuses.last()) + require.Error(t, err) + assert.Nil(t, inv) + }) + + t.Run("Should return 400 when advancing a gathering invoice via v3 POST", func(t *testing.T) { + require.NotEmpty(t, gatheringInvoiceID, "depends on gathering invoice creation") + + inv, err := c.Invoices.Advance(t.Context(), gatheringInvoiceID) + require.Equal(t, http.StatusBadRequest, c.statuses.last()) + require.Error(t, err) + assert.Nil(t, inv) + }) +} + +// pinBillingProfileFromDefault clones the default billing profile with the given edits (see +// createNewBillingProfileFromDefault) and pins the customer to it. Returns the created profile. +func pinBillingProfileFromDefault(t *testing.T, c *v3Client, customerID, keyPrefix string, edit func(*v3sdk.CreateBillingProfileRequest)) v3sdk.Profile { + t.Helper() + + profile := createNewBillingProfileFromDefault(t, c, keyPrefix, edit) + + _, err := c.Customers.Billing.Update(t.Context(), customerID, v3sdk.UpsertCustomerBillingDataRequest{ + BillingProfile: &v3sdk.ProfileReference{ID: profile.ID}, + }) + c.requireStatus(http.StatusOK, err) + + return profile +} + +// createFlatPendingLine posts a single flat, in-advance $10 pending line for the customer and +// returns the (gathering) invoice ID it landed on. +func createFlatPendingLine(t *testing.T, v1 *api.ClientWithResponses, customerID, name string, invoiceAt time.Time, period api.Period) string { + t.Helper() + + price := api.RateCardUsageBasedPrice{} + require.NoError(t, price.FromFlatPriceWithPaymentTerm(api.FlatPriceWithPaymentTerm{ + Amount: api.Numeric("10.00"), + Type: api.FlatPriceWithPaymentTermTypeFlat, + PaymentTerm: lo.ToPtr(api.PricePaymentTermInAdvance), + })) + + lineResp, err := v1.CreatePendingInvoiceLineWithResponse(t.Context(), customerID, api.InvoicePendingLineCreateInput{ + Currency: "USD", + Lines: []api.InvoicePendingLineCreate{{ + Name: name, + InvoiceAt: invoiceAt, + Period: period, + Price: &price, + }}, + }) + require.NoError(t, err) + require.Equal(t, http.StatusCreated, lineResp.StatusCode(), "line: %s", string(lineResp.Body)) + require.NotNil(t, lineResp.JSON201) + + invoiceID := (*lineResp.JSON201).Invoice.Id + require.NotEmpty(t, invoiceID) + + return invoiceID +} + +// invoicePendingLinesNow explicitly triggers billing.Service.InvoicePendingLines for the customer +// (POST /billing/invoices/invoice), converting any currently-due pending lines into a standard +// invoice, and returns that invoice. A raw pending line just sits in the gathering invoice until +// something explicitly asks for it to be invoiced — nothing in this stack does that on a schedule +// (no cron, no ticker), so tests must trigger it themselves rather than poll and hope. asOf is +// optional; pass nil to invoice everything already due as of now, or a future time to force lines +// that aren't due yet (e.g. a subscription's next-period charge) to be included. +func invoicePendingLinesNow(t *testing.T, v1 *api.ClientWithResponses, customerID string, asOf *time.Time) api.Invoice { + t.Helper() + + invoiceResp, err := v1.InvoicePendingLinesActionWithResponse(t.Context(), api.InvoicePendingLinesActionInput{ + CustomerId: customerID, + AsOf: asOf, + }) + require.NoError(t, err) + require.Equal(t, http.StatusCreated, invoiceResp.StatusCode(), "invoice pending lines: %s", string(invoiceResp.Body)) + require.NotNil(t, invoiceResp.JSON201) + require.Len(t, *invoiceResp.JSON201, 1) + + return (*invoiceResp.JSON201)[0] +} + +// TestV3ApproveBillingInvoice exercises POST /api/v3/openmeter/billing/invoices/{invoiceId}/approve +// Flow: +// - Create a customer (v3) +// - Create a standard invoice with draft status (v1) +// - Apply the approve operation via v3 POST and assert 200 +// - Attempt to approve the same invoice again and assert 400 +// - Attempt to approve a gathering invoice via v3 POST and assert 400 +// - Create a standard invoice with manual_approval_needed status (v1) +// - Apply the approve operation via v3 POST and assert 200 +// - Attempt to approve the same invoice again and assert 400 +// - Attempt to approve a gathering invoice via v3 POST and assert 400 +func TestV3ApproveBillingInvoice(t *testing.T) { + c := newV3Client(t) + v1 := initClient(t) + + var ( + customerID string + gatheringInvoiceID string + invoiceID string + manualApprovalInvoiceID string + ) + + t.Run("Should create a customer", func(t *testing.T) { + key := uniqueKey("approveinv_customer") + + customer, err := c.Customers.Create(t.Context(), v3sdk.CreateCustomerRequest{ + Key: key, + Name: gofakeit.ProductName(), + Currency: lo.ToPtr("USD"), + }) + c.requireStatus(http.StatusCreated, err) + require.NotNil(t, customer) + customerID = customer.ID + }) + + t.Run("Should pin the customer to an auto-advance billing profile", func(t *testing.T) { + require.NotEmpty(t, customerID, "depends on customer creation") + + // Approve bypasses the draft-period wall-clock gate entirely (it's the manual + // override for early issuance), so the draft period just needs to not have + // elapsed by the time we call approve — it doesn't need to be short like in the + // advance test. send_invoice keeps the post-approve status inspectable/non-final + // instead of racing straight through to paid via credit auto-settlement. + pinBillingProfileFromDefault(t, c, customerID, uniqueKey("approve_invoice"), func(profile *v3sdk.CreateBillingProfileRequest) { + if profile.Workflow.Invoicing == nil { + profile.Workflow.Invoicing = &v3sdk.WorkflowInvoicingSettings{} + } + profile.Workflow.Invoicing.AutoAdvance = lo.ToPtr(true) + profile.Workflow.Invoicing.DraftPeriod = lo.ToPtr("PT5M") + + sendInvoice := lo.Must(v3sdk.WorkflowPaymentSettingsFromWorkflowPaymentSendInvoiceSettings(v3sdk.WorkflowPaymentSendInvoiceSettings{ + CollectionMethod: v3sdk.CollectionMethodSendInvoice, + })) + profile.Workflow.Payment = &sendInvoice + }) + }) + + t.Run("Should create a single gathering invoice", func(t *testing.T) { + require.NotEmpty(t, customerID, "depends on customer creation") + + now := time.Now().UTC() + invoiceAt := now.Add(time.Hour) + gatheringInvoiceID = createFlatPendingLine(t, v1, customerID, uniqueKey("approve_inv_gathering_line"), invoiceAt, api.Period{ + From: now.Add(-24 * time.Hour), + To: invoiceAt, + }) + }) + + t.Run("Should create a standard invoice in draft status", func(t *testing.T) { + require.NotEmpty(t, customerID, "depends on customer creation") + + now := time.Now().UTC() + createFlatPendingLine(t, v1, customerID, uniqueKey("approveinv_line"), now.Add(-10*time.Hour), api.Period{ + From: now.Add(-24 * time.Hour), + To: now.Add(-2 * time.Hour), + }) + + // Flat lines have a nil CollectionAt, so invoicing them cascades straight past + // draft.waiting_for_collection to draft.waiting_auto_approval (AutoAdvance). + invoice := invoicePendingLinesNow(t, v1, customerID, nil) + require.Equal(t, api.InvoiceStatusDraft, invoice.Status) + require.Equal(t, string(billing.StandardInvoiceStatusDraftWaitingAutoApproval), invoice.StatusDetails.ExtendedStatus) + invoiceID = invoice.Id + }) + + t.Run("Should approve the standard invoice via v3 POST", func(t *testing.T) { + require.NotEmpty(t, invoiceID, "depends on invoice creation") + + inv, err := c.Invoices.Approve(t.Context(), invoiceID) + c.requireStatus(http.StatusOK, err) + require.NotNil(t, inv) + + stdInv, err := inv.AsInvoiceStandard() + require.NoError(t, err) + assert.Equal(t, invoiceID, stdInv.ID) + }) + + t.Run("Should return 400 when approving the same invoice again", func(t *testing.T) { + require.NotEmpty(t, invoiceID, "depends on invoice approval") + + inv, err := c.Invoices.Approve(t.Context(), invoiceID) + require.Equal(t, http.StatusBadRequest, c.statuses.last()) + require.Error(t, err) + assert.Nil(t, inv) + }) + + t.Run("Should return 400 when approving a gathering invoice via v3 POST", func(t *testing.T) { + require.NotEmpty(t, gatheringInvoiceID, "depends on gathering invoice creation") + + inv, err := c.Invoices.Approve(t.Context(), gatheringInvoiceID) + require.Equal(t, http.StatusBadRequest, c.statuses.last()) + require.Error(t, err) + assert.Nil(t, inv) + }) + + t.Run("Should pin the customer to a manual-approval billing profile", func(t *testing.T) { + require.NotEmpty(t, customerID, "depends on customer creation") + + pinBillingProfileFromDefault(t, c, customerID, uniqueKey("approve_invoice_manual"), func(profile *v3sdk.CreateBillingProfileRequest) { + if profile.Workflow.Invoicing == nil { + profile.Workflow.Invoicing = &v3sdk.WorkflowInvoicingSettings{} + } + profile.Workflow.Invoicing.AutoAdvance = lo.ToPtr(false) + + sendInvoice := lo.Must(v3sdk.WorkflowPaymentSettingsFromWorkflowPaymentSendInvoiceSettings(v3sdk.WorkflowPaymentSendInvoiceSettings{ + CollectionMethod: v3sdk.CollectionMethodSendInvoice, + })) + profile.Workflow.Payment = &sendInvoice + }) + }) + + t.Run("Should create a standard invoice with manual_approval_needed status", func(t *testing.T) { + require.NotEmpty(t, customerID, "depends on customer creation") + + now := time.Now().UTC() + createFlatPendingLine(t, v1, customerID, uniqueKey("approveinv_manual_line"), now.Add(-10*time.Hour), api.Period{ + From: now.Add(-24 * time.Hour), + To: now.Add(-2 * time.Hour), + }) + + invoice := invoicePendingLinesNow(t, v1, customerID, nil) + require.Equal(t, api.InvoiceStatusDraft, invoice.Status) + require.Equal(t, "draft.manual_approval_needed", invoice.StatusDetails.ExtendedStatus) + manualApprovalInvoiceID = invoice.Id + }) + + t.Run("Should approve the manual-approval-needed invoice via v3 POST", func(t *testing.T) { + require.NotEmpty(t, manualApprovalInvoiceID, "depends on invoice creation") + + inv, err := c.Invoices.Approve(t.Context(), manualApprovalInvoiceID) + c.requireStatus(http.StatusOK, err) + require.NotNil(t, inv) + + stdInv, err := inv.AsInvoiceStandard() + require.NoError(t, err) + assert.Equal(t, manualApprovalInvoiceID, stdInv.ID) + }) + + t.Run("Should return 400 when approving the manual-approval-needed invoice again", func(t *testing.T) { + require.NotEmpty(t, manualApprovalInvoiceID, "depends on invoice approval") + + inv, err := c.Invoices.Approve(t.Context(), manualApprovalInvoiceID) + require.Equal(t, http.StatusBadRequest, c.statuses.last()) + require.Error(t, err) + assert.Nil(t, inv) + }) + + t.Run("Should return 400 when approving a gathering invoice via v3 POST again", func(t *testing.T) { + require.NotEmpty(t, gatheringInvoiceID, "depends on gathering invoice creation") + + inv, err := c.Invoices.Approve(t.Context(), gatheringInvoiceID) + require.Equal(t, http.StatusBadRequest, c.statuses.last()) + require.Error(t, err) + assert.Nil(t, inv) + }) +} + +// TestV3RetryBillingInvoice exercises POST /api/v3/openmeter/billing/invoices/{invoiceId}/retry +// Flow: +// - Create a customer (v3) +// - Create a standard invoice with draft status (v1) +// - Attempt to retry it and assert 400 (retry is only valid from a failed/invalid state; +// that state can't be reliably reproduced through the public API without a mocked +// invoicing app or line engine, so this test covers retry's rejection behavior) +// - Attempt to retry a gathering invoice via v3 POST and assert 400 +func TestV3RetryBillingInvoice(t *testing.T) { + c := newV3Client(t) + v1 := initClient(t) + + var ( + customerID string + gatheringInvoiceID string + invoiceID string + ) + + t.Run("Should create a customer", func(t *testing.T) { + key := uniqueKey("retryinv_customer") + + customer, err := c.Customers.Create(t.Context(), v3sdk.CreateCustomerRequest{ + Key: key, + Name: gofakeit.ProductName(), + Currency: lo.ToPtr("USD"), + }) + c.requireStatus(http.StatusCreated, err) + require.NotNil(t, customer) + customerID = customer.ID + }) + + t.Run("Should pin the customer to an auto-advance billing profile", func(t *testing.T) { + require.NotEmpty(t, customerID, "depends on customer creation") + + pinBillingProfileFromDefault(t, c, customerID, uniqueKey("retry_invoice"), func(profile *v3sdk.CreateBillingProfileRequest) { + if profile.Workflow.Invoicing == nil { + profile.Workflow.Invoicing = &v3sdk.WorkflowInvoicingSettings{} + } + profile.Workflow.Invoicing.AutoAdvance = lo.ToPtr(true) + profile.Workflow.Invoicing.DraftPeriod = lo.ToPtr("PT5M") + + sendInvoice := lo.Must(v3sdk.WorkflowPaymentSettingsFromWorkflowPaymentSendInvoiceSettings(v3sdk.WorkflowPaymentSendInvoiceSettings{ + CollectionMethod: v3sdk.CollectionMethodSendInvoice, + })) + profile.Workflow.Payment = &sendInvoice + }) + }) + + t.Run("Should create a single gathering invoice", func(t *testing.T) { + require.NotEmpty(t, customerID, "depends on customer creation") + + now := time.Now().UTC() + invoiceAt := now.Add(time.Hour) + gatheringInvoiceID = createFlatPendingLine(t, v1, customerID, uniqueKey("retry_inv_gathering_line"), invoiceAt, api.Period{ + From: now.Add(-24 * time.Hour), + To: invoiceAt, + }) + }) + + t.Run("Should create a standard invoice in draft status", func(t *testing.T) { + require.NotEmpty(t, customerID, "depends on customer creation") + + now := time.Now().UTC() + createFlatPendingLine(t, v1, customerID, uniqueKey("retryinv_line"), now.Add(-10*time.Hour), api.Period{ + From: now.Add(-24 * time.Hour), + To: now.Add(-2 * time.Hour), + }) + + // Flat lines have a nil CollectionAt, so invoicing them cascades straight past + // draft.waiting_for_collection to draft.waiting_auto_approval (AutoAdvance). + invoice := invoicePendingLinesNow(t, v1, customerID, nil) + require.Equal(t, api.InvoiceStatusDraft, invoice.Status) + require.Equal(t, string(billing.StandardInvoiceStatusDraftWaitingAutoApproval), invoice.StatusDetails.ExtendedStatus) + invoiceID = invoice.Id + }) + + t.Run("Should return 400 when retrying a non-retryable draft invoice", func(t *testing.T) { + require.NotEmpty(t, invoiceID, "depends on invoice creation") + + inv, err := c.Invoices.Retry(t.Context(), invoiceID) + require.Equal(t, http.StatusBadRequest, c.statuses.last()) + require.Error(t, err) + assert.Nil(t, inv) + }) + + t.Run("Should return 400 when retrying a gathering invoice via v3 POST", func(t *testing.T) { + require.NotEmpty(t, gatheringInvoiceID, "depends on gathering invoice creation") + + inv, err := c.Invoices.Retry(t.Context(), invoiceID) + require.Equal(t, http.StatusBadRequest, c.statuses.last()) + require.Error(t, err) + assert.Nil(t, inv) + }) +} + +// TestV3SnapshotQuantitiesBillingInvoice exercises POST /api/v3/openmeter/billing/invoices/{invoiceId}/snapshot-quantities +// Flow: +// - Create a customer (v3) +// - Create a standard invoice with a usage-based line resting in draft.waiting_for_collection (v1) +// - Apply the snapshot-quantities (force-collect) operation via v3 POST and assert 200 +// - Attempt to snapshot-quantities the same invoice again and assert 400 +// - Attempt to snapshot-quantities a gathering invoice via v3 POST and assert 400 +func TestV3SnapshotQuantitiesBillingInvoice(t *testing.T) { + c := newV3Client(t) + v1 := initClient(t) + + var ( + customerID string + gatheringInvoiceID string + invoiceID string + subscriptionID string + feature *v3sdk.Feature + ) + + t.Run("Should create a customer", func(t *testing.T) { + key := uniqueKey("snapshotinv_customer") + + customer, err := c.Customers.Create(t.Context(), v3sdk.CreateCustomerRequest{ + Key: key, + Name: gofakeit.ProductName(), + Currency: lo.ToPtr("USD"), + }) + c.requireStatus(http.StatusCreated, err) + require.NotNil(t, customer) + customerID = customer.ID + }) + + t.Run("Should pin the customer to a billing profile with a 1-day collection interval", func(t *testing.T) { + require.NotEmpty(t, customerID, "depends on customer creation") + + // Preserve the cloned Collection.Alignment (subscription-aligned by default) and + // only override Interval — replacing the whole Collection struct drops Alignment, + // which then fails collection-config validation with a 500 (an anchored + // alignment requires AnchoredAlignmentDetail). send_invoice avoids racing to paid + // once force-collected. + pinBillingProfileFromDefault(t, c, customerID, uniqueKey("snapshot_invoice"), func(profile *v3sdk.CreateBillingProfileRequest) { + if profile.Workflow.Collection == nil { + profile.Workflow.Invoicing = &v3sdk.WorkflowInvoicingSettings{} + } + profile.Workflow.Collection.Interval = lo.ToPtr("P1D") + + sendInvoice := lo.Must(v3sdk.WorkflowPaymentSettingsFromWorkflowPaymentSendInvoiceSettings(v3sdk.WorkflowPaymentSendInvoiceSettings{ + CollectionMethod: v3sdk.CollectionMethodSendInvoice, + })) + profile.Workflow.Payment = &sendInvoice + }) + }) + + t.Run("Should create meter, feature, plan, and subscription", func(t *testing.T) { + require.NotEmpty(t, customerID, "depends on customer creation") + + // A raw manually-created usage-based pending line (no subscription behind it) + // isn't ratable — the customer has no usage attribution / subject keys to query + // usage against, and the server 500s trying to calculate it. A subscription's own + // usage-based rate card line doesn't have this problem, so drive the test invoice + // through a subscription instead of a manual pending line. + meter, err := c.Meters.Create(t.Context(), v3sdk.CreateMeterRequest{ + Key: uniqueKey("snapshotinv_meter"), + Name: gofakeit.ProductName(), + Aggregation: v3sdk.MeterAggregationCount, + EventType: uniqueKey("snapshotinv_event"), + }) + c.requireStatus(http.StatusCreated, err) + + feature, err = c.Features.Create(t.Context(), v3sdk.CreateFeatureRequest{ + Key: uniqueKey("snapshotinv_feature"), + Name: gofakeit.ProductName(), + Meter: &v3sdk.FeatureMeterReferenceInput{ID: meter.ID}, + }) + c.requireStatus(http.StatusCreated, err) + + plan, err := c.Plans.Create(t.Context(), v3sdk.CreatePlanRequest{ + Key: uniqueKey("snapshotinv_plan"), + Name: gofakeit.ProductName(), + Currency: "USD", + BillingCadence: "P1M", + Phases: []v3sdk.PlanPhaseInput{{ + Key: uniqueKey("snapshotinv_phase_1"), + Name: uniqueKey("Test Phase"), + RateCards: []v3sdk.RateCardInput{validUnitRateCard(*feature)}, + }}, + }) + c.requireStatus(http.StatusCreated, err) + planID := plan.ID + + plan, err = c.Plans.Publish(t.Context(), planID) + c.requireStatus(http.StatusOK, err) + assert.Equal(t, v3sdk.PlanStatusActive, plan.Status) + + sub, err := c.Subscriptions.Create(t.Context(), v3sdk.SubscriptionCreate{ + Customer: v3sdk.SubscriptionChangeCustomer{ID: lo.ToPtr(customerID)}, + Plan: v3sdk.SubscriptionChangePlan{ID: lo.ToPtr(planID)}, + }) + c.requireStatus(http.StatusCreated, err) + subscriptionID = sub.ID + }) + + t.Run("Should create a standard invoice from the subscription's usage-based line", func(t *testing.T) { + require.NotEmpty(t, customerID, "depends on customer creation") + require.NotEmpty(t, subscriptionID, "depends on subscription creation") + + // Billing cadences are restricted to weekly-or-longer presets, so the + // subscription's first-period line naturally isn't due for a week+. Canceling + // the subscription immediately settles its current (short, just-started) period, + // making the line due right away — the same mechanism the credit-then-invoice + // cancellation flow in TestInvoiceEditFlatFeeManualOverrides relies on (that test + // sleeps briefly before canceling to let the subscription's charge materialize first). + time.Sleep(2 * time.Second) + + _, err := c.Subscriptions.Cancel(t.Context(), subscriptionID, v3sdk.SubscriptionCancel{}) + c.requireStatus(http.StatusOK, err) + + invoice := invoicePendingLinesNow(t, v1, customerID, nil) + require.Equal(t, api.InvoiceStatusDraft, invoice.Status) + require.Equal(t, "draft.waiting_for_collection", invoice.StatusDetails.ExtendedStatus) + invoiceID = invoice.Id + }) + + t.Run("Should create a single gathering invoice", func(t *testing.T) { + require.NotEmpty(t, customerID, "depends on customer creation") + + now := time.Now().UTC() + invoiceAt := now.Add(time.Hour) + gatheringInvoiceID = createFlatPendingLine(t, v1, customerID, uniqueKey("snapshot_inv_gathering_line"), invoiceAt, api.Period{ + From: now.Add(-24 * time.Hour), + To: invoiceAt, + }) + }) + + t.Run("Should snapshot-quantities the standard invoice via v3 POST", func(t *testing.T) { + require.NotEmpty(t, invoiceID, "depends on invoice creation") + + inv, err := c.Invoices.SnapshotQuantities(t.Context(), invoiceID) + c.requireStatus(http.StatusOK, err) + require.NotNil(t, inv) + + stdInv, err := inv.AsInvoiceStandard() + require.NoError(t, err) + assert.Equal(t, invoiceID, stdInv.ID) + }) + + t.Run("Should return 400 when snapshot-quantities-ing the same invoice again", func(t *testing.T) { + require.NotEmpty(t, invoiceID, "depends on invoice snapshot-quantities") + + inv, err := c.Invoices.SnapshotQuantities(t.Context(), invoiceID) + require.Equal(t, http.StatusBadRequest, c.statuses.last()) + require.Error(t, err) + assert.Nil(t, inv) + }) + + t.Run("Should return 400 when snapshot-quantities-ing a gathering invoice via v3 POST", func(t *testing.T) { + require.NotEmpty(t, gatheringInvoiceID, "depends on gathering invoice creation") + + inv, err := c.Invoices.SnapshotQuantities(t.Context(), gatheringInvoiceID) + require.Equal(t, http.StatusBadRequest, c.statuses.last()) + require.Error(t, err) + assert.Nil(t, inv) + }) +} diff --git a/openmeter/billing/service/invoice.go b/openmeter/billing/service/invoice.go index 23a1774cd4..ed14ab9d41 100644 --- a/openmeter/billing/service/invoice.go +++ b/openmeter/billing/service/invoice.go @@ -475,7 +475,9 @@ func (s *Service) withLockedInvoiceStateMachine( } if invoiceHeader.Type() != billing.InvoiceTypeStandard { - return billing.StandardInvoice{}, fmt.Errorf("invoice[%s] is not a standard invoice, state machine should not be used for manipulation", in.InvoiceID.ID) + return billing.StandardInvoice{}, billing.ValidationError{ + Err: fmt.Errorf("invoice[%s] is not a standard invoice, state machine should not be used for manipulation", in.InvoiceID.ID), + } } standardInvoice, err := invoiceHeader.AsStandardInvoice() From 352c4446a662d219a8f7fba2db8ddc05486bd2c0 Mon Sep 17 00:00:00 2001 From: Robert Boros Date: Tue, 14 Jul 2026 12:29:52 +0200 Subject: [PATCH 2/4] fix: failing test --- e2e/billinginvoices_v3_test.go | 141 ++++----------------------------- 1 file changed, 17 insertions(+), 124 deletions(-) diff --git a/e2e/billinginvoices_v3_test.go b/e2e/billinginvoices_v3_test.go index 9206ef4e6f..d8176ccffa 100644 --- a/e2e/billinginvoices_v3_test.go +++ b/e2e/billinginvoices_v3_test.go @@ -1204,7 +1204,6 @@ func TestV3AdvanceBillingInvoice(t *testing.T) { var ( customerID string - planID string invoiceID string // standard invoice ID gatheringInvoiceID string // gathering invoice ID ) @@ -1229,14 +1228,9 @@ func TestV3AdvanceBillingInvoice(t *testing.T) { // right after creation (auto-advance is otherwise instantaneous with the default // P0D draft period, which would leave nothing in draft to advance). Once the // period elapses, the first advance call unblocks trigger_next and drives the - // invoice forward; the second call then finds no further automatic transition. - // - // The default profile's payment settings auto-charge via CollectionMethodChargeAutomatically, - // which (with credits enabled in e2e) settles the invoice to "paid" synchronously - // the moment it's advanced past issued — leaving nothing observable to assert on. - // Overriding payment to send_invoice (same as the manual-approval profiles used - // elsewhere in this file) stops that auto-settlement, so advancing lands on a real, - // inspectable non-final status instead. + // invoice forward through every further auto-advance-eligible transition in one + // shot — including settlement — so it lands on "paid" directly; the second call + // then finds no further transition available. profile := createNewBillingProfileFromDefault(t, c, uniqueKey("advance_invoice"), func(profile *v3sdk.CreateBillingProfileRequest) { profile.Name = uniqueKey("advance_invoice_profile") if profile.Workflow.Invoicing == nil { @@ -1261,127 +1255,27 @@ func TestV3AdvanceBillingInvoice(t *testing.T) { require.NotEmpty(t, customerID, "depends on customer creation") now := time.Now().UTC() - price := api.RateCardUsageBasedPrice{} - require.NoError(t, price.FromFlatPriceWithPaymentTerm(api.FlatPriceWithPaymentTerm{ - Amount: api.Numeric("10.00"), - Type: api.FlatPriceWithPaymentTermTypeFlat, - PaymentTerm: lo.ToPtr(api.PricePaymentTermInAdvance), - })) - invoiceAt := now.Add(time.Hour) - lineResp, err := v1.CreatePendingInvoiceLineWithResponse(t.Context(), customerID, api.InvoicePendingLineCreateInput{ - Currency: "USD", - Lines: []api.InvoicePendingLineCreate{ - { - Name: uniqueKey("advance_inv_gathering_line"), - InvoiceAt: invoiceAt, - Period: api.Period{ - From: now.Add(-24 * time.Hour), - To: invoiceAt, - }, - Price: &price, - }, - }, - }) - require.NoError(t, err) - require.Equal(t, http.StatusCreated, lineResp.StatusCode(), "line: %s", string(lineResp.Body)) - require.NotNil(t, lineResp.JSON201) - - gatheringInvoiceID = (*lineResp.JSON201).Invoice.Id - require.NotEmpty(t, gatheringInvoiceID) - }) - - t.Run("Should create meter, feature, plan, and subscription", func(t *testing.T) { - require.NotEmpty(t, customerID, "depends on customer creation") - - // An active subscription is what actually drives the billing-worker's sync - // loop for this customer; without one, a raw past-due pending line just sits - // in the gathering invoice forever (nothing else periodically collects it). - meter, err := c.Meters.Create(t.Context(), v3sdk.CreateMeterRequest{ - Key: uniqueKey("advanceinv_meter"), - Name: gofakeit.ProductName(), - Aggregation: v3sdk.MeterAggregationCount, - EventType: uniqueKey("advanceinv_event"), - }) - c.requireStatus(http.StatusCreated, err) - - feature, err := c.Features.Create(t.Context(), v3sdk.CreateFeatureRequest{ - Key: uniqueKey("advanceinv_feature"), - Name: gofakeit.ProductName(), - Meter: &v3sdk.FeatureMeterReferenceInput{ID: meter.ID}, - }) - c.requireStatus(http.StatusCreated, err) - - plan, err := c.Plans.Create(t.Context(), v3sdk.CreatePlanRequest{ - Key: uniqueKey("advanceinv_plan"), - Name: gofakeit.ProductName(), - Currency: "USD", - BillingCadence: "P1M", - Phases: []v3sdk.PlanPhaseInput{{ - Key: uniqueKey("inv_phase_1"), - Name: uniqueKey("Test Phase"), - RateCards: []v3sdk.RateCardInput{validUnitRateCard(*feature)}, - }}, - }) - c.requireStatus(http.StatusCreated, err) - planID = plan.ID - - plan, err = c.Plans.Publish(t.Context(), planID) - c.requireStatus(http.StatusOK, err) - assert.Equal(t, v3sdk.PlanStatusActive, plan.Status) - - _, err = c.Subscriptions.Create(t.Context(), v3sdk.SubscriptionCreate{ - Customer: v3sdk.SubscriptionChangeCustomer{ID: lo.ToPtr(customerID)}, - Plan: v3sdk.SubscriptionChangePlan{ID: lo.ToPtr(planID)}, + gatheringInvoiceID = createFlatPendingLine(t, v1, customerID, uniqueKey("advance_inv_gathering_line"), invoiceAt, api.Period{ + From: now.Add(-24 * time.Hour), + To: invoiceAt, }) - c.requireStatus(http.StatusCreated, err) }) t.Run("Should create a standard invoice in draft status", func(t *testing.T) { require.NotEmpty(t, customerID, "depends on customer creation") now := time.Now().UTC() - price := api.RateCardUsageBasedPrice{} - require.NoError(t, price.FromFlatPriceWithPaymentTerm(api.FlatPriceWithPaymentTerm{ - Amount: api.Numeric("10.00"), - Type: api.FlatPriceWithPaymentTermTypeFlat, - PaymentTerm: lo.ToPtr(api.PricePaymentTermInAdvance), - })) - - lineResp, err := v1.CreatePendingInvoiceLineWithResponse(t.Context(), customerID, api.InvoicePendingLineCreateInput{ - Currency: "USD", - Lines: []api.InvoicePendingLineCreate{{ - Name: uniqueKey("advanceinv_line"), - InvoiceAt: now.Add(-10 * time.Hour), - Period: api.Period{ - From: now.Add(-24 * time.Hour), - To: now.Add(-2 * time.Hour), - }, - Price: &price, - }}, + createFlatPendingLine(t, v1, customerID, uniqueKey("advanceinv_line"), now.Add(-10*time.Hour), api.Period{ + From: now.Add(-24 * time.Hour), + To: now.Add(-2 * time.Hour), }) - require.NoError(t, err) - require.Equal(t, http.StatusCreated, lineResp.StatusCode()) - - ctx := t.Context() - customers := api.InvoiceListParamsCustomers{customerID} - assert.EventuallyWithT(t, func(co *assert.CollectT) { - listResp, err := v1.ListInvoicesWithResponse(ctx, &api.ListInvoicesParams{ - Customers: &customers, - PageSize: lo.ToPtr(api.PaginationPageSize(100)), - }) - require.NoError(co, err) - require.Equal(co, http.StatusOK, listResp.StatusCode()) - invoice, found := lo.Find(listResp.JSON200.Items, func(inv api.Invoice) bool { - return inv.Status == api.InvoiceStatusDraft - }) - assert.True(co, found, "charges have not advanced a pending line into a standard invoice yet") - if found { - invoiceID = invoice.Id - } - }, time.Minute, time.Second) - require.NotEmpty(t, invoiceID) + // A raw pending line just sits in the gathering invoice until something + // explicitly asks for it to be invoiced (see invoicePendingLinesNow). + invoice := invoicePendingLinesNow(t, v1, customerID, nil) + require.Equal(t, api.InvoiceStatusDraft, invoice.Status) + invoiceID = invoice.Id }) t.Run("Should advance the standard invoice via v3 POST", func(t *testing.T) { @@ -1398,10 +1292,9 @@ func TestV3AdvanceBillingInvoice(t *testing.T) { stdInv, err := inv.AsInvoiceStandard() require.NoError(co, err) assert.Equal(co, invoiceID, stdInv.ID) - // send_invoice payment settings prevent auto-settlement, so advancing - // should land on a real non-final status (e.g. issued/payment_processing), - // not race straight through to paid. - assert.NotEqual(co, v3sdk.InvoiceStandardStatusPaid, stdInv.Status) + // AutoAdvance cascades through every further auto-advance-eligible + // transition in one call, so the invoice lands straight on "paid". + assert.Equal(co, v3sdk.InvoiceStandardStatusPaid, stdInv.Status) }, 20*time.Second, time.Second) }) From 0f98e640a12afa8af5c612c28ca84a1cf81ccc7d Mon Sep 17 00:00:00 2001 From: Robert Boros Date: Wed, 15 Jul 2026 10:57:50 +0200 Subject: [PATCH 3/4] fix: make action response straightforward --- .../packages/aip/src/invoices/operations.tsp | 8 +- api/v3/api.gen.go | 870 +++++++++--------- api/v3/openapi.yaml | 8 +- 3 files changed, 443 insertions(+), 443 deletions(-) diff --git a/api/spec/packages/aip/src/invoices/operations.tsp b/api/spec/packages/aip/src/invoices/operations.tsp index d61b0158c6..71c4880f9e 100644 --- a/api/spec/packages/aip/src/invoices/operations.tsp +++ b/api/spec/packages/aip/src/invoices/operations.tsp @@ -167,7 +167,7 @@ interface InvoicesOperations { @extension(Shared.InternalExtension, true) @extension(Shared.PrivateExtension, true) advance(@path invoiceId: Shared.ULID): - | Shared.GetResponse + | Invoice | Common.NotFound | Common.ErrorResponses; @@ -192,7 +192,7 @@ interface InvoicesOperations { @extension(Shared.InternalExtension, true) @extension(Shared.PrivateExtension, true) approve(@path invoiceId: Shared.ULID): - | Shared.GetResponse + | Invoice | Common.NotFound | Common.ErrorResponses; @@ -212,7 +212,7 @@ interface InvoicesOperations { @extension(Shared.InternalExtension, true) @extension(Shared.PrivateExtension, true) retry(@path invoiceId: Shared.ULID): - | Shared.GetResponse + | Invoice | Common.NotFound | Common.ErrorResponses; @@ -233,7 +233,7 @@ interface InvoicesOperations { @extension(Shared.InternalExtension, true) @extension(Shared.PrivateExtension, true) snapshotQuantities(@path invoiceId: Shared.ULID): - | Shared.GetResponse + | Invoice | Common.NotFound | Common.ErrorResponses; } diff --git a/api/v3/api.gen.go b/api/v3/api.gen.go index 41bf9bd609..2681df9b49 100644 --- a/api/v3/api.gen.go +++ b/api/v3/api.gen.go @@ -13888,441 +13888,441 @@ var swaggerSpec = []string{ "757Li5bHshOo1qfDYpXrk7kYCvMMFivGwsrbF7ZyX6t+JKjeC6+8L3rKGFcaftCyqLWVyMc7Ix2sfNnW", "MQPi3Lrq7UvVoDrdr3zaKRjukl4DsbURgua8bRVG+sIn/Bl1Pc9uiXk6KRW9YotLqrozNMLx0PXjO/O1", "m+Ku+RM90O0KddgB2IdIu6VOWb/3pNqTjyzOYcYfApKHahuPsvtvWHZ3nL5PbH/VJbKXrcv0kOL7o7T+", - "KK2PlNYLnrD9xPROGZcnrE+ihaGP8uuj/NqSX0Px5vcnwob03z3MHqn0/2fvDXTbyJH+wVfhCQtM8v8k", - "2U4yszNZLBYeJ5nJN8nEO0528O0okOluSuLnFtnT7LatGQT4417hDriXuLe4N/me5MAqks3uZktqWbKd", - "2MBiJ1Z3k0WyqlgsVv3KRgFsZuS4z1faNk6YxluL9VkXbB5uRjRxUEGjjOEGSIwzoJ6rkXAUBsoK8txV", - "Diy1gletDLSofUOxHG40T4W8PHUl4SCsD2Mm3VRsKWao80QUIufJujNRmQVbCzWhmEVFBTmtLu1pc/pG", - "gucuirScP6RCFSnLlCuDM+E07wiAvYadqVutBSmUQFJ27EN7x7otBC9oGi5lXWeGhGZJ7XLchoYlMgsA", - "g4fxfxcKwBA3FN1aK2vehWxjbn7IqIDSfUCCQ9Dc6JCxQYyKkYRphQo1fLgb3dgADO9l3iZmeGcVTwNj", - "vOKJJqLrzR5+VUoa8hYsciDeFDfJQBzFGz7neaOFsnITj+wBShlF5/6GCDKXJmzCuiut+CnImL69sF9X", - "Yst+63GRFvkYkeh6/Z4scu/vj2uGc9Qq1DSiNlavxXGRRRuUaLSfAW+lnutcVYQvoGMuKE/oGU94vhin", - "MuGbqAJUbF5Lx9hQNS1UirGtt9SeD4qV+B1gdCTnjBgaTQpXJIUq5qlDYvRxXE69Pk6HO3GiHNWUWupm", - "vlSqKcsAY3Gs96MxbHWbanE7eQfD/V7IFjRGRMoyKz6AfOjg1mwmRpBWUyDlNEAvlILYH369j6ES/r6h", - "n/zlYH9/uL+PlU4QXNgmfOqnX+uHUDLOgFxZK2YK/G7smH1b7rdqDpH9vqZ/JE4niJtl8r3+DohaLsmm", - "vvYHw/1hoM6xWf61FOF19vUfUN98llu6mYgvZkcv7eMde538rQaVlWduNzi0tEdzPBVo0dLN4iHlKuUZ", - "U2Wu7HpUm9zUF8svMGPrEKin1VaGYEhoolWyC5bhUy6m5tTgbIY1OKtpa4An05fuDXedVwYP0WSENgb/", - "yqIhYiJzdTPsGqFrq8Isj9R9HbN5KnOQk3O2CBpIZeVBqypceaDy9JexQlm8FoDy1q1hJXNFqCA/vn9/", - "TJ7tf0dsVoXVjUROwA6iJk8sLjAA0gzcIZzRc1b3Iyii6IQZbNhsMfysPaQy4/miklV40IDIfZHRywHg", - "QdoPqkxC3shLltn8TcjKm/HpjGXu/aGfKs5FfvANEqv1l+5xfx9oNX+GIG1T3+jrorEDdmMg8AKdEiZC", - "iBixK6MK8eZDkUdVgbQgvwhk+Xi4qd+yQWo3D6aVHlwNzSeAoG2cdKZ6lq2fdOpGh2NQ/UAWsqvENBJW", - "1jS/M6EAJl9mGYtykrELJsCnGMmp4Ai7jxXyK44qLwq4dvaoVALE26U+4ROI1f8K5xYcV3pwiTyDTdEl", - "FusPwZbCOnEtB76aCt34BLhp7b/wctHqWRBS6dpXgXRbhP5IYGUQvcqYUotrnyxg8VmM3d5OzcH6NaJN", - "HHbJ7cPNSs7hitl9Z63Kc2tQ8mnJfUBgJZdc4Pum47ZOWq84zSETH9PIKs7EZtHsfu9qMJWDllwv1xW0", - "taGdX2ljdfaXmYuOvjRsvX0bdSHs9jLEOjjJ69wTKloH8/cThcrw9ZHIW9rrE1VEM0IVGfU+nJAXMklo", - "ZtOcXhaZxISprhH9i/mZTMKjwmcrxxUeiHH5mxZwWKGh/GXUA852Q8IB/c//+f+aB3poMLAN3G9tVeIs", - "D2J4zKbcZ4Nr1oxpMUX3O2XZwQfL41lMs+UyIVlD8sEvG4+1ICyqeCDMxXV2Ay6aAI1mNP3lxN6xUJg1", - "SmQHTyifsQU/p9lizOYmXT0YtKBfIfBKK29Wwxjgg5fQZuhyGu6yaY4l9zaJMLaSCvFoh15DTU61haxz", - "SWyPZeEBoKT0GxjxtxVDLwASqgAdU7kKh68q3banC7YrKxOFtGHSjy05tUJVfR4ydU1ZguVcn4nM3EER", - "rKV2ni1RUZYet3FmzcrjII8YzAYwMvr0j+zF1UiUcD3uJrl6qeK3rHKa88jnOKzXlZW03plS+9al3VmE", - "zSJg3Q0VyiJz3JmybFBgWTiV1wrC6f2GjHoIOmfsC0om/IrF1e/6RGYjMeolyXzU0yKfSHlOihQbhSgK", - "PVlv3rzFX2KaU72c5ZoiK0wzWaSDswWcbI2g1eJksMPNlIJhyk1UAjLJSvf4dJqxacfEDmj60PuyJeev", - "fMOU7JdQWMc6GGAGh3cm6nXOhOJSLLmV/TPwWYXUn+mcxeQ/T979fEzzGWFXKeDMSgFOXXaVa5KMc0UW", - "qd5ajJvLcRxuM5rdYEw/sYVydzkGBMCk0iquciwTA2ggAi8u4Kk+lWcqkhmrzYO7fnVD+cvQxrU3WBBI", - "GbeHqCGpdmVN9VBbx81b/CqmSJrJeZr3VuoSaF2NtwqbBHcAilsEBhRhc9Sx9GO/oEkmRQK34uc8JTKJ", - "3aPXk5Go6WyaJGTGVS4zKI6Db8Jtua2qOryZze9ubATA1WObQNGkJyAidQnBa0wnF1xMmdK7K0ztVwpE", - "xGndhYOPcu+Z72VGVDHvE3ox7ZM5F30Y4FwfQkoOVaYouCnclhE6Ev6p1wQ1pDQzt7z2XeceNRGWERak", - "LVvuV4mv3s3aozUC/8G3I1HRmnYe3FRCwPVUSFOErxSrvwxdJMUGB2mMpPQ3g4r4t29QxwkV14D1cZ+v", - "3qj0Wx0BbFZZcxZiJZAlkCa0AutzCK/ekb1KC8VYUzhOu11iLL9G01Nyzso4i4QKAh3Uo0rNvNn712q0", - "iL1aqWQq6O/L9jYy6unV2JY/C29H5gLIK78IF8g+xVaODYklzDIst5bCkUB4oYFFdbEARIj+MOEsiZ38", - "mkKZKL4ARNT4bCQuKyU1C5HwOa/Ug6sTZXxh5e2VtfrplfsoWKfx7obJofA2GXe5XtlcpaztsotozESX", - "tI71Lv+t6840b3YhvzqGvWfmqqFqvq9+vPvENB/QrE7M3XTI3TK8F2qL64B7gS4MQ3vZV20N1y8G2gtE", - "vgXWq9wblIFnNZUiEfM4o/PUnOUr4Lvk0GxQ6pLn0WwkZBQVmTKnIgcaCqWTavmhQ3KYk4RROEMx0wyU", - "OEbt1RVQTKudY7u5zbl4jd96+vu4HGOvCUeZZnKcQfjIeF3AaQuPlWZygJ8Caip+7SEW1UT6uHzd9hTE", - "MG41E70r77oedavcrtmbV6qdb8C1UivdX03tjtlNyxbtw5vXLxqD5PESsv06JdcweBvN3DXDtwFu3TCA", - "u2qf5VabM4OqcH7kEGGXD3DvBJuM1I2rNkvpn8uspJzPNylXWqlTE/P8PTbTGrmoxcsMqaxjTw5dZSaz", - "7PromMY0Z31T4pIBXKvJszIxZWV1fG3RJlxUEwsNJTVutjaXbzLim+1MbmRrM9a2grkG+ODYwDwEdgN7", - "QaNVdpqCdwlDOU2UheqqmA1Zh2lqmvYhHw9NF34PxBHX1NL34v7k7p4jjJvCZ6AWZo55/j2Wxe7KxWXc", - "qK2rfbbwktp2BzmcMRq/E8kCN3u9bvxiK3l6Rya5ozynY0wyVAaBkwaGSCcLort0qf3zlEa5qiOu7w/3", - "93sBak1BwW0SDEY4BICeacayse9nRQ6eVSFzsmA5ucz04dqVF09YDIXCtbmYsZEIPjaXdGRSwDXbmZTn", - "zIaG++P9um24mJUc73C4hibjBjRkU3fXbrnTRclXCT9oobwtXcOwWzmwckV9wJmKZPRaZQ8jZO88PnxJ", - "6y0hxAMB7zMqFIVCS9edrqMiU1CXf5cT5tG76bQhnZvNWRVutOOlqBQsp9nCJVYJfaS0WY/tWr7MIlpL", - "xKsem/X9NHUTDnvtr0iqqoWC1vezjDFbDeC31yfvnj05+Gt7xQH9dGC780sOjEQ1HNTVGvDbr7zSVm4A", - "ikO11Rt4UTUUnlbMhKeBggNPWwoOGEruvg7yHGy3oIBKOQxUwYOWTck+ClfSjSGndMrWF3Y9kw0aoYnl", - "xB2bXmoZzjwLwcx9+OW13evhDQIdeBkjKc1nvWBa+orm9AtrtybY1fLW9AttrYkiAUvNOn4CkXrsgstC", - "Le3BvrRxL4r/EVAp5njIYmiXwEueFB/su5bQg9lYcfMFzJA3lHYeKFnxnwXLFpYdOsjwC5azbM4FU+Ye", - "C0i3YYtlcUqThsXZRajaeFlUMzAf1UXVbWuR6Zflw5yPResHV6SZ6+XJqAmGCSwCAjAu77ay0iu7NqDa", - "a/QdZgCIiHe3bFjL3IsASRlYIH7KgPO/BFPyTaTlZ6CrkdDb0tU2mn0zx6mLZ78xz6mLxmlWP/rl1dHT", - "p0+/Kw2RXMpEDTnLJ2CLaJtjL5tE+qXHBBWXXtCY5mygjzz2ooaLkfjw/mjtumBOB7qWPFeaoYpowgfv", - "+TwIpmVH9YqzJMbsWlgJsegUoNRfsXg1bKnftxIE9S+IP9FjifRxn/1e0ESRKb9ggvzy6mgAoy9nu8zA", - "5oLALH/q96b5FknhqopQALFxHclhO6RHZjhJdkvtRluy5alKmFKbzlOy7XkqibnOJAVqzLXh3kh/2Fp8", - "QQ88sv08NtEZEDA1JIdJQkoZQleQNB7av9kUSMKuKEiCFKwEwDGYh3Ke0oyr6j2InRkC4k+M/Fdz4Uyq", - "/hAfurn0XhrwuT4QoQWtjza9Kc9nxRnU3pMpE7Alc1n+e4+mfO/i6Z6FAdATF8o9aajawEt4673mhTd1", - "Xl44LYuRsPmfDvDNV737B99R9mx/Mnj25OtvB3+dHHw9+O7ZdweDb589mTx7Qv8af0Oj1c5gW7zR9mSJ", - "Jz+FMVpN+HjnsqARTQ2ADjE5SuAfdcHAREJVWcDBpJZpsoAXGK9ptoV+sS7aHTMRRBbaQAvFMOStjFnC", - "bo8+6H0FfbdfKa+DLxeNoJDP/iG75SG75V5mt/R7eI99WzoGfDNIQpuaaR5a+i6RuNTflYG05+eYJdXL", - "CT6JX5gyNew6bED4EYYnWZmABfldN9l+aG3B4dSPSSYv178jb4xCXoYOt1tLwjjx61brQXJkXS4xP2JL", - "aLEvy+rSjU5Cp+61FtiUm+tiXmTy0kZuZB2XupueWQXSOk8LQA3THZqrj0eosP+//4c4tfF4SH4ukgRx", - "a2zsnQGlcZfHI+EAYsAQj+T8zPqJ5aQ0nYAJV3oYby6y1Ru7yTnLg0nOL+B3MmcK5gfhEb150/MBiP3s", - "Kk0oF+Bemy3KPiJIJ9JzdgaFC5VMLgwc/k6SzrAQmm3Iy53R+7bJ6NBK/YJlQ3JqEpgNjI9Nch7z+BSP", - "SFq7Zhcsri1kQzx2V84eTnVnRXTO8uWD2V1J+k4kgBxtS1SrqehlDpNXKL+hwpCAPqqMSnhmWei+wmtL", - "1F3NTuy6nbkQaEmosSEapqMPB1u/0FkBi7t8ZkFN45n7BGTlLU1f52zeFBnrUdBkpmmysI4LT4wMJzjX", - "+Jxe+ZTAJUfFYPW+teMITPNGp4xA3e0XFQJhIHaerbOfK3+mq8Su78M1fHF3ffP26H8rPnkH2rCZwFjY", - "hhvzyL+S2RmPYyZeZlknWC6qGH7yqf9nA1PCbqSlF8j149egr75yLsX0eZ7RiD0/ePL02dff/PXb7/bh", - "zimnOV5supef7T8tgzZb+7GZyuVje7kA/4VmmQIX27P9p0HX46d+7weWV+IHj2lG58rz83cF7CbS5Pxo", - "PT7FgsIlzpcJpdpGYCEqPe9a4uUVXeJQXRrm2KyytCENXbqflIWYhuQdgJRLA7/pwR6nMssnMuHSeHpH", - "Qh+LT9kVV7n6OyzEqfch5IIU2q6BWw8Wl1MevI38QQq2Y+nQXWxJMA72w4Jhu+giEwf7rTKhjR2hSTUa", - "6zCKLNJVh/MQfESwU5vOg5H9rSbBjKoxdZ21lYf30HrKWNYZVQQ/deEgppeRGIlTfSA5RWgqTHoBixjd", - "UehUwKIzJi4TYpnsGQiTyPW3xl4bicoXsANjNRAt7JbhyKnhTodn7DnCClE2j2hqaANCvigMBqJCM0aj", - "GYshvPVRrQTxY4fj7qJIR4JdzWihcjyBVD0ipVXwo5urYD39jFHVJQmlhV9+wWaWeL+wIw/v2S5rLBme", - "Q2Fk4WUlxzJFv6PJuj0tuQfQ1c30L5sIS2JtO/XY8GNQZywbb1cjGqaA+rwBB3Bokp8lxrr2sbZqYSoW", - "2GqZJd2wiQ/de0TlWRHpvrFkP7vKl03ZYdldYGq6oW4unciWE/9bGs24YCXwItOq2IFWtpF9ZCqDmYN+", - "U738WIVzDFw+QEfL+nhr2l6V3mCK4lhSOrNYOPSzMTFGulxtoJgJzuKyWiK0WCkzJs6FvBSuniroorFR", - "QV4hLk93eb8KmY8nshDgZ5Vj1E3j8s2PAY9IOUw4zZUb8foCBB8aJtCKGGJ8U5rlHCBrVQHDnBQJmbrO", - "0Au35EjyRchUOaW7ESWrklpc1FaXm6tlzrLyKiJzwWwUsJ7jImIxHmJXStlRs+GQs+2zE/TacjVv9t3i", - "GGOqwc8TyhNbeKch0s73V8rpGhK5WW4gymQuCdM2O5QLqygdM4AEIK0mjlVU6FhU8thG/G8GYJlGBQsq", - "e+ef63b0ytZh8vvxnBYmatKoR1XJ+g7OpTN7y4jL2lHKLzGEiN00mhHrifbQWX+daQsRWBnfsatilkmL", - "gOlD1TuJZiw6b1au8GyssvqrT6VanW3u1ngN+WgsZzfGfFPjOE+HqAq/lnza5MlztggcT17qCcV0XgPx", - "Uhpt5PScLU4hRc0UPvbwTy3IKL40HInXPk0GjwrvF8pFrdiEcFrJmMm5KG+gYHMbiVPQZ+qUgKesclnY", - "1Jr0ykIZmLIKTWQDp4D1RCAAXduYmkm1tbWHuVx/3V95Vc46LLs7cFiN47keWtedvJ6UQD40SVxVtFFp", - "/tjJltmUCv6HKQEDq5EXmWDxkBxDFJGDfwEKAHgikvM5VFIeCXBf6D2wsnIQao81bGaMJJK67MAzGp0z", - "4UpHq3V59E2H4V+bTay38ydNytbYYCNXtP3MVR6p7ZzrXr0bl4anLvGeV/UhohClP4VwlrryXfeKvjlg", - "vTV8ardFXqDPuu4MR5kPpfmAZYw2jiJMAA4dXEJdzngC1SLg5Gnq4nh5/ZvQb/1kreS/RDrbvflrXxO7", - "DMOP/TVSm4i5A0wlFzmZU1v4pzw8lHLIkWsmRZLAjSn+egkXv+wqYqaIO8sGisfGhaOW24/tlw/MTkjr", - "LUSYRTZyzjU4ueqnC7LxdQ20RnZFy6W+2WTg1ovm+gha2a29rXCd04Jn4m1849jmF/0UgB331Kxy+Tg8", - "sxoWvaImjDE1O2nGKl5C+DFz2VdckFPr+9KPTsEpyC7A8sffRwINjeX7U8MdiReY5JIqh3G3ZEbdHhxg", - "TbNQ4ROh3Xz9VQyfCH0zB3bN0obVZha4XzOIa2a86RN2xpbWyZCxpNotFDNlxrJ1dby0FCQcwuN43Rwz", - "1Fl/JFQOKx3SMkloqtBrZ+EFrXAB2X1kB1w4b3nLY7KeKBaTGcOzXPs23KpfmvIS0LBbjuB776L27F01", - "FItmEZRinlHRBNv/SvnyABejCYuQ2UcCVh5nbhk/fsBhENoE3bbs6PkqPC1QmYGQoq2j/zXzml6fvCMQ", - "smjfKTOcYhmpYcynHG5bbKCq0r8XcxvRuKdf0G/ufbe/v3/w7NtvBwdP99z98F425kqOdQ9jW2FwjPkV", - "w1k+f2xha6sx+ccH/+VnPplR9CrZ1MeP/vF8NIr/A/4z1P96/I//evyPwK9vg7/+Gvz1Bfz6PvDkxw5t", - "nzz+x+N//MU/UdZnOeTveW1Ad19eMMCiuJPAChCOwcW0QuwtoCq8Fhc04fGxzQY9mkkeMYieed4pUS2C", - "D5U/AXVAvIbc+kOFMOvfC2ZeN2H1kNlTvcc0kbstjVVUormEKb+F/Bc7PZg2tFZTRRJww3GcujKTVhH9", - "ovKcbvDfj2v0gDqhSuyZjBcrHYveGBSIA9Dad8uxzpq/YKk+fop8g2WP7bf1la9HgN6/xXdTM4a+YC3W", - "nJVtMgbyg+MPb8HW4Q2TWmPTIzrxxjXWzxX19D7+NoTqF1pogGl2d8ZzTHmngnzrpYHsdOXn9Gqc4Iwh", - "gDXKBfz7dtSBnc+1lhyRFW98yS2g48ZLjiECFt315labC2+1uRhrUy43gPzjRF6yLKKKmb+LNK38jZX0", - "7NuOUbi4JUYxq7AOo5zkVMQ0i2+OR3ag1peCfuOAf4EF3+JsrzO5ah1e9M+EUrB1cMzb1vBTv9uHVS3R", - "+evKttL1a89I7fpp1daBILeqz3q1WVLhik0UhuOMfo+rse2Kq/EZVeybZ+bf5o4M/tCH07HBrOBqbJUh", - "/KFNCvsvQN2BfxvGgn+7uq1cjYuCm34nv8fCUgCRHnhBXBZv0TMD7t9xmZMJ70Pmas/6eNQ4Y1N2pR/h", - "0E2nFvprLFh+KbPzsX87Of5DCjZOuMrb3o54nI3PEhmd19+w2di6X+8IuIl19RpL9d55ABpD5+3Eur95", - "8/ZIqvytjFnS9Zb1zVuC34XD2xvl/K3jyzmOYpb0CRtOh30y6k3TfPBs1NP/jBJaxGzwdPD1QEkhWI5F", - "cptoXMEM4p+9zOFaHz8cv7d9HEEf5Onwa3LS3kdrdumquTzGRLuuOLXy3EvSAye9gIReM46YCTk3TJhC", - "tMA5EwFvPY1mbKwFZJyybAxvbQXTVLdLdLtAIytpII8+nLzA4vbY+WXGc7aL3qHhJd1zkRb5djt+rZtc", - "0qUs8q33+Q7aXNIpWhtagW+1319ss0Qup6AuGbVpD8zKEpF5d8GyjMcMAcs7Cg0ujxYWhMyARIyUZQMt", - "qCqlkWUXaXoZkg+IkpJinQXYcPooYyMBhfjKqtkTLYL2S0ITzf0LgnkJpJo0W2uKUBGXAJt9wnOLAG9S", - "2uNG8y4gGtqvfGKS2beRUrJu3WeMEPzU77HJhEHJk+0V7vsVb6e4KgdvK0+53mp9bykrNNAzu0p5xhT0", - "B0s3Du1gR1RIAYUAcXnLa5fg5oQNhbeoWnAitqdfDbaUenvJWqMPbUSBm5zKZoNIoFizBLg4EFRgnuxd", - "MBHL6j6+eu907XpzXI6tkuFa47clikOPrjNAkCgxMlAxZCySWdwvcShsWAS+43SfuTW3yMJGYcDlpvfz", - "jQEKHVmEoApaeAO9ZrcKgjwqk3MolvcY9T6cvBj1Hgep2akuweUMKJKlhGxdsSAZVqtA0htkStsbeXwO", - "F9526pbTuoUEY7PlVZVWo6O5Owd0VjRtue9WOzRrC9ycWgv2Xqq5Tt1bLRiKQDKPGpqxWWjAOZs69s0j", - "doLfBhnQAcACh0X6JKTFLEjDlgMD3nhYPcsUUuhIVd8b2jYGM20NLdKO9bNq7zhxC9FyXFVabDNmD2Le", - "rlGZ3fJ2QBRU048wesHg+zojdT92H5fztcnJuzRU7cFYpkxQjidjKvJZJlMebXzqbrb/LmXi8DW2f7i0", - "/W4nbgez1hbo5aGBffO0Dgbm487TwR/7g+8Aff7g06Pyz8Fw/PF/eU//wwQtLIdvQcKIymXGXDQi4AQJ", - "i23l1yAubNlSjNGCI4x7EQOqMqyZxWgWzeB5lEmlXGOLVO80jeLickLw9oIcDL556l2aYLKrCTlHpBaI", - "VxpBpjIu1LkUgkU5/jFnamZ+1isHUWmj3njUG45EtQY5Exe9572cKRMrVoHY+NqD2DCrF1pXrnKoeaa2", - "m6ivpxImryw11n6Y2iQrv78mtEMll34tgMFADn4pip0/LLPONxnlp5YlO4IaQztaMyxgFFizciw7QlTA", - "jsnZwo/nPHHVL2y+PaEZe64fDcip2Y5O4Q9TLhT+PeGCJvhPA995qj+pJyH4bbosA4hCTtHV4b4eLlkO", - "qfLvqdrZguit8Ey3HwL9ofm4W0bjikOHXQzXKWBLcK1Da/6K1ukoCwPtakYwmQpKWqkb8NRUMTew2wbi", - "x46RPspezxl22FUem3WbTrCF9bs2crlq7b0aR7vlgNzraJfV5ZbNjk/DbcHA1GlYhgWj1R5+NhKV+SMd", - "kWCCjfiwKRuwpcc573UrXQeuu17Gnrg2fGeq2rUfwqSMN7Mh7HR2YFycu/ZZwOjtlyXqisVDwPvWF+Z2", - "tWsqqAvb9/BcbEi6S/QJl0JqB2e1eQ7hNosk71zUNDTutrSwZWl2rein/iTvjNNak7xtWek0kxOesPHn", - "YSmnCRXjTXtNMz6n2WLM5gYuqnMLCNHhZbSMTUbLhjS1yR6EqO+IJ7gJgycMOmnPLht39XOutRdhr6CF", - "Z8xHrnRq4fWLYVcYxw57Ydm/7cfMx0aetw2GDMCngHihf4YEMEvCsLeBM3KjsRsEdzQQZXaro0cCkBaU", - "pl0PHnsZmlLlbOcDx7Fi5dvOls9GQ1xh4TjE0V0oGJvrFUyQ30jtQnDfZjvUhjtN28SZ6LCdqWZsfbt3", - "lWuxztnC9l6WOnEMu9sdAU5DNd2vVLHj0VaUkR06KGPoG9URQj2MERV6DI7Z3VFkejMY1OgG3ugI39Wl", - "5q39yqO7f1uzIymoXuyoncC2ruDGShVeNpwOyT/wLuA3++zjb+z3j3//cPKiHqWyC4IwIuX1ixottluk", - "BSI2m6Euu6MHImRCFOkHH3+LpMgpFwoo6210x9uNKhfpUaXJ/oyzhFdrO7azSgOrSgr+iISYG8lWQYOs", - "1R1JGAbLt+7PW58PE5zveSV3xp1lVxjA1Tq/xwndldtRH1J3cpv1hVxMnRRnbiZ3tATK72LlEbejTbnR", - "R+C52PzLTZbe8c32l/Et675ch6aQAmSRVapu4e17zCZQPHomL0kuEX8G7sVdRRDPZeHdcNvH2IsqagEo", - "UKr2WUup2hqFrwnGK30wSJPV4jEmHKv3l6ENizHz8pch/ONTvwcEjs3PaSbnKWTdxFC18Ydvvv73X7/+", - "+vDVr4c//fjy4MnP/7V/9M/vXv1oSmA970FcoxoDBrsNtDAhVIq8N7/6gULLhgbI7WWKEVAJLZm92Ede", - "9WdwXaUMLHDofRmOOPPahlOpXtpClRVXTPWPT/2HAo+ff4HHrRRb+pnOWUz+8+Tdz8c0nxF2pWfEFF6S", - "hF3lmiQM9M9kkeq9HnjdAzZChwvcITSCcExNVgi4kULBvYGAcNl0RgWmYiDAoohZpiKZsdo8eLqnoQAa", - "mtLXCKGLC+MbMpJh0UYNhJQnPFW4GadaVtRTRIU53molKYgpVFwY5ERU6moGyGyWfqOoyQfFJgUULVbn", - "PCUycW5n8noyErW6lTRJyIyrXGYQ2G/cWTRjtt14+DmVEb0jJTXves3I5lZVn7KALqirAlPGyyqA6iXH", - "Vwp0gSuxuYB5fu+/V5YBU8W8T+jFtE/mXGBg3pxe+aKo0ITBHGBALbOYUJUwwpRmyqLG4rvQ7SuZGR00", - "BhhIv+V+lXgkyiouaupID8krwKQuRD4Sle3VzoObSk0onwr0r/v6w9kCK9hn43qe/YpRUVGDH9vsycOq", - "GbKxLVHG/xpjUE+VyzAf2z/pxdTAPyBaiBZwiJMMRQkDgXc3eRnt8VvJWYauvbpwaqNTXLVQnC1s1wYU", - "u5aZcdN17JBYEM4lJSBHAqwNKOavyKNRj/2OgbxcjHqPvYr4uPG5XPy2AnnV5fi0dIF+yKgoEprxkJJ9", - "DwaVe6FSpxEMLVA9UJffwuIZEu0Grq0WCxsHJUznNPel8fj9wdteX/9HH3mOD17A/79tl7droOEf+hzk", - "A+p6xhtaRfoM9dSeofafw//0+WnqT5ahVk8G4Cn0nvc+vD/Cuo9eC0+8Fj4tK724/gmrIlltbq8mexrJ", - "2WkVUXNRUdZR4srVAsZMjE+1aew+cp9lW0jif7BAUVGYEjwgeASKXLYUTB8JN4ZaBVI8UYicZ8yvowxt", - "j88W46o2Wl441ifJxCWRs0WFL3/rVbwLHztAgteVv8euXsUDw7lNQl0JVk2db57CtOp2CFXGTeMg718f", - "/nyIWuHf+oUXpsz5SAAo5/O9vcvLyyGngg5lNt3TLQ10S+oxokGXTXOFiRe5JLFe/jkXeMAAnsNM8HD9", - "WNVWA//D+yN4D9p32d6qpVLwburcLhOSXA5XqeyNgKbfVlSfxXL1NB/aFr/Vd9KKW3S5w8r6wuDWaZAX", - "2ZnseQhiaeFVMG7TsO260xwJes97B0+GT599/Q3M86atfVo/jBCXCMHKgaew4LtWCn5hOsLmab7A2g5Y", - "WMBUHlg3xtBb4B2Xg99Ma9+eLKwVOlmdvi2VjK+ZnL64fDZSspml/FD9/E5XPzervJ3q514HWNu1IXXY", - "XafK5hZiGaGVN9isuJgaT+hEJom8tJAPR4ksELBZOUiHpju01OgVgZN4cJyn2uj5kSWJ7JNLmSXx/wHD", - "Av9HxXByEgmS/XV0sD+hMRscRN+xwbP4m2jw7ZO/fj2Ivn4SPf3mr08P4qdRmQX93EYLDYx/RJN7wTKF", - "ozwY7ve8+EanRAbgUsEoxIoGqN3mVK+UWne0davmlZ7nlC4SSeMhsTcEfcInxHjzCM8999N/nrz7mUgT", - "O9mEgGtwhSYKCvGJPOz/PsKH6MsxkuGvOOy9yKXknT41l6Iy6pmarIDo/t9KilGPcDUSVLOPtdx/fP/+", - "2D+B1r/RzFw6xRpPW8foaUqaUxS8pVnrYMfCa+auU4+MxjOW6YdQTMNhxxcZb7jlVtKxNNVclZciVTfg", - "miy+wsOsVmftI3wL1GTUW+/ljMPdruHBGU1TJuo+ypo8+fMz8GESV1Hny6F/DEKRDByD8OUQQ1ZUkBlF", - "ed9UmOTLcgjYxSoCy6Dn2k0B/HVm2cdULLP1EqFLY8bYqa08MyUes5F45HBG4jI26XGV1KpCWkHyZlHT", - "q+pXOEQWGZlYGVayBnmr9RCKjD4j/vLqiDx9+vS76iiWaNCVItSuoygXihhNZC5Qz+wOZXUXznnGoDiy", - "9cLIjGMVJDEdiXJUtZmX86H5a6jknEFLmzjmHR6Hz/Lmy5LNPlZKIuHW+9J02bqxV2sndEZ4cjca8+pm", - "DyAH+LBSKKq6ufvljlbZ3PbO0717I7v4GK88NtjGK9kny7700jQCrz3B1z5dv1KUzUj7xWnYFbWieEUf", - "KT+lB5bXL6Ptr04HT6CzLMOkGClLnE70smmuld2z7AIcSgS2p/LAc54rv7QbHEJsaPnmWTcbUIW92d0i", - "Nj46e7jgMRa5aStfZ3yD5jVbxc7sNdWb1m4OkLpi+ZfrxJWwW5paaTWlv8j+1H70C6QaMrupujpF3TQf", - "NNGcuh2Uvi4buH7J6wBqGNasJg4iEaDm1i3cfIQFmdcvFq27nBVzKshdKRj9s8xfyULEJROsl7ROFbOc", - "/GejmktuslBLS+Bnqc+/hYhRc6mcijoG/rkU0+d5RiP2/ODJ02dff/PXb7/br8Z4upef7T/75Kaj3s8r", - "2481e8rHtpoW/NdAn0BBrWf7z0L+6o96hozToYlEZSKqXISI0nY/zc54ntFsoU+aEQd728RIVGtmjUaD", - "f/y2P/ju4388Go2G+K8WzKd3Xr09Uy75Pb3S3Ne5dK3X0iBhFywh5thAcnqF3O9OIAaARisdNNTrryq4", - "mUMfZ4lLafKvrelu0Wv1EdYvHGhq2eoJ0ptKkcs5zXkEZfZLe9mvNMjVEnTa7YZYVqx3G0AZRr0EIIYx", - "YISMc3rVEY3GrOMym+RFfYEMBHEVAsbpJO+B+wSl7kIC1N0NUun6rFb0Nj9WyNtl+UAvVGsNoMDmPLWt", - "cjc4wGM6ZW9Z6H7GncTSsrQs3nF5BSBs5WaIoXYhWhPjtqre1FRlw5R08DVheexy9R6uBipl9JxRtRjk", - "LMvoRGbzAcZYlXiS/I+qSvUiNbq1hKHg1aY2a6u2fu5ToNV21LIgXnRQY1VwQlHzeQvDTfwHHkGrM52a", - "XX9FTBILhiOldo82clIlr07/mtN8nFABCHddg7nsd/XtzZyB9EycmXBOCnlBmNAgDOZdH9R/JmErGAnj", - "FkM4PIitKYvKakWRFlk0o4rBwYrbJgPmpBvKWgoCRrDqvIdUNU53sOyGCGdmwqsPIf1fREj/JJPzMaQg", - "pZr11p+nSvB0kKXOmYsyA9GADjCGt3StGr6zKNJhgfC575X+vmxvewHjXcO/5/Rq/HtBYa3bzlW4MOU2", - "BVzjj9vGEpuBxi7WFYSOvJKZrXc8sAcGp0AAexjqYZUIpKbUNEQpzosk543PtBpiogRALATUVmcxsYNp", - "EDX0qpnBpulKIl+5j3qh+nIPEfLrR8iv8tK8MQhYQXfDWj6ZY7gwyI9oThM5DThj2k7a/6p32VvhuFkv", - "jhy3saYKClopdie+uzHapZFxK3Hauvs7X31LE3lL05Pd6epklQobtzRBy7RDtzlqKAwD3gA1AsAxxuKQ", - "WQPYLDtwn6o8K6K8yFhs/THbdqO+RRdqWWUGxm1Acrv7Tl1hz6ZRkVJtluP9I7xWvW0Epar20kzuZTRn", - "Ec1itQfBMHsGuOknuMtqo+iVqa+5vju3Vl7nBl25dp5C7NzIAOkcRoi+B4zqt8VoMAvM8eOQvEtZRnPN", - "4fo4Ny/yAlx37CpKCsUvWB+ST0dCCkakeRdu0UwYC80JNUBMDa4XobJIcn4GWfQe8n9siFT2Qi6RU0iw", - "PPz5xdrGQXO+avHny6p7glig96Yls8vOGLHvVQdgQtVCGa6/r2rRpNqs2R4Xq9rjisBqTQJNVo2tVfH6", - "SydMrDtjrkyZ+WDdkYrVU1dWQNNzuHbDa82hbvYm5lFm15SSd7/ckJCUlzWonQi2QQwUyDpKzKaxXV+X", - "CaJHTMDLZNTanKarVdtI1HQbeVBtd0S1IWj3yjbhLa8BWx75QTk+KMe7pxzf0pTob5ZoyV9YVGT65WPI", - "P+moHN3XNn0FZ0AQKqIZaEpw6HORs+yCJiFlpt/bjmsJPEQDiPAx3ecSCnAYJ1mN1DpsyLLINHu4Mc0C", - "Af2eHdb65L8+efftN/sHL0yOcIvv17brcon95GHi5Q472o8hebi8HjXf+5+5tkyscP14YFbCG9XHILuU", - "juuGcByC1xrwHwyQjI/84OUwmpDbBaGl77IyHvuriR30S2M9W10a6+N/PPrH87H74/H/+os3OXYEBI9y", - "DQ1xIrMchCisiU6pik6JKiYTfgUK3V400GqAg5JZTmQWG0wvFTGhT/BDhNY41Q37zdiZwRAIPTH6DfwG", - "mxmOxNsiyXmaMGy8PNiTOV2Az9lpQk4BRmw+p0SxlGbgbUm4yocj4QBDhDT+VvN5kwZVnA1K1fuITZ+T", - "ryZSDs9oBvR99bhWUstzWMIL3ryX8xqa9AbAHuiGhRGp+vsrdFS9akTbbvgviFmuWB5YHtmwLcY0P5oU", - "f/yxQMi1x2vbItg2VvooIQ3CXXQySLB2Z1awfunFcFcYNjXlkZBiIIokefw3jITBmWl+MRL0zHyh3w5b", - "NtO8bXxckSmseKZlXLROYcKueCSnGU1nPDI4Diw8mdOcrdubzKx5IdfreSSWdp0sG2fClNraIJOlgyy7", - "6jzC5d2Kdk4NGGxrMqpsF7BfTPwD3OZgqgvNCcjTwEIYumtOUFeDmNkbtXSWQfEstEtHwhzADM5PkJLQ", - "8MI0sCsa5WTrNATi/9pAKWSAkVA0cV3PFoTxfMYyQ6vMiKeIhuQwSRxmEzfl1+xm9De7FeC35pzpqXYz", - "VoOmMoRQkKkcGNqNOTus2KPeKwM+TyWifadU78K9Kc9nxRnEQcqUCcxkkOW/92jK9y6e7lmYj08hnY+Q", - "mttT/DtRy7sRoS+NcUsigVFJlU9H4hqM6uwJ6//RPRu0W+Sg1czceG9LHO0B624SMYXRUmU4gzlO+ni9", - "gRPUlkuUr3tDDytDY0hEq2SQ+xZ9466ebrWO+Sa0eonmyym92Tix+iI/xIt9/vFiLaXQ6onJNx17dSuB", - "RSvnYnk0mAuvMpShJOnN5ZIuFDlAdEqI9SL1oK22CKx/Lou+sh3eNDtjcF8quUlgtvlqbgIuqQKcEJlc", - "GGSYAEvoA/8Yrq/D06mfE3hem9B1/ZWNre4XmrMjmsXLQqF+cb32wnhcCRctKU/2aX39YTC26DA69gzw", - "HlY8NkjGOReFLKoJ6L/V9s7ek/0nXwcwZrwtq3ylCjVT8u4B2KjhZp+sbvZpS7P7S5p92krKx00X872Z", - "7RM2nUNqafua2lcDK3rnQwdDgXftEXcmJM8G3nmxm76u6FeWyWPrilCGXKuNVbi7AVdNQ/dWoq7alVBn", - "1CurmWysiteypxprlvdkwiLNHv7bYz2BY96meF+/cBq30gdMO57wIDK5JOiMJVJMLRDKWsuDpsKSGC1D", - "eJMETV9Akh3ndq5JXG4LQYPYDdM3ed020WCIko7+qtlfi1/qeq4r2wTYpEz1fjim3cQxbROz0eUJoA/D", - "4pb2K8ltzmLcbxekJRZk/Xatsik4oldx6Z2PSfaJvZ1NwCSW3vmZMnTe6iSV/oluE2M+L/O6m1OyXvWm", - "ULJDiF54tyHR+lfy6IPgFyxTECr6Aa+Z3/hXIPDgRGY5RNQ6nK2shum0FJvSv1PeH/z142/7g+8OBz/+", - "509vfz4evP/X4N8f/3zy9Sf/WhkoDhxr6zWrKu7tNTbxDTzeHf0J3RzksAYWHNG5w7fQZav3vNbj9n3l", - "ugPrKTehPLZmxRY95TCMW/CTQ7++l3ypf9yw8ZYd4x8ELfKZzPgfbNcwIa8F5HgBuoHmBoo+r20AhhyE", - "AUP8wXXGDDlowwz5AEfPwzjOmFLd7xHgq0YkRNBOOuL5ogL/UDFoSk0GpUGyDkD1R/gB7noNITFPEemB", - "C/Lb65N35OnBN98MDj4+sjMG+OhKAjw6V3IAzw0hA8APGc7yefJ4JKBC1eCJFx1Vpokg3Z/6PW3rHzRn", - "4BXPVE5q7iU9g34zb/Tjg+BlPhfsSbPVExZJEa/V7JNQs+lMCjYukRdqtop+6sHCuJR/+P1ni2DQbFWq", - "nCbjcCLOMTx0iTeuTfy5Ld9Gs3SgsRP9M5EZqi5jNJS3d/qbNZSrlQRjRZka47/K7HySdIa3Nl8b2Bol", - "aKpm0p2ILk2j1fqL4Pt28BrSIq0qlucczuV6p4Egb0YFF9NJkdggcZrog8NiYHxKtpD085FwCCHkjM3o", - "BZcFxkqmdKEPoq71ITmSScIiPGAmfCrgMQB50CuSyoRHi5HQ3U9pPmMZhj/u6Tmf8IQNLvWeEUkRMb09", - "QjhmxmCbLauGNUw5S1yHnX3JGjmwlhMzqIAyKAFd3LxayB87a2H8F+Xa1EbbYt4JP69CtSX3GFtZQuxx", - "bZGWklp/uTuPN+fvOkzPG1MHDI6+DAayUJuQRv/EGk65RIOmFIKR8KQgZdnAzohmyCmUJ7tgYwvvxJXN", - "pCdUEY4IiVVGhhAX4GQLNYWAWAEHS5HLMY0v7C7vsGzxyN4IooPQmlzWYKMgibJS9p5OclPmJM7oJDf1", - "7smMKpJSVa2X4cXM+S9XoXWP918EoXVNw9Y3YfvPJTlj5JylcB8EzZpK9PDqnAptLmfsgrNLVY8KfuFj", - "A5vg4w207jHN8oWxKjoDhh2SqNRhcmI3QaZKuAbdfHNFDZuMqWcEdZBrawU1BdiMqtyO66fSes8f15qg", - "9/QKT5ummk8HETWfIRalDSTWxq0ilq5q3LSw1xwwh3orKLJUmogfOhIOSs0YSwG4s07wXaUTwx6oEee5", - "xbj7WfNcoi1iII5XvkGTT83kpbBHJIdSyu1MxDIq5uBJXc2eNdV9NKPZlB36cr2h6gxqeurg6ZzB4MDm", - "PE6fs3wmY0CcA3pGoqJpQgtivx3jt2GXZrOLmsbwMd2x63Gl50BJsUamcJ2Sjx2X4ISJ2Ow7tzr1ionY", - "WlvsZqZcdzk2vwert8UFG8OmUtsWni7fF3AfKrF/7P7AFYkLNiS/8nxGlJyz0oiUSWFKcuZfKZNLbXD8", - "LUiQ2T4aI6xtJEjbWjvJthmp5J6NGGQIBTr0h3MuaI6uhzlNU2PfBiVkA3txmdLpV5liI2u0KU8lnvXi", - "ZyyG3pzuT/2eFOyapvCyoX3qX8fEDgyqnUGOEqlYvFGa2mElPc0WacPrMFs6TXehXO1b8z5k5EKEERyX", - "tPVKaF5WXsOvr2qPmAicqnZdtCpAepjmzllvJ/qrXRe+CpDfNq+diH8pmtfIZfGeJdwGcJ0/ZFTkL69y", - "lgmaaCZNmObczcpumq/ImYzRboPwElsrgZleKj4A7M7a+1CJC3FERwKARJtsVnouOxl2ONxjE3rsKV+k", - "4ARbDa+lYJftRDeNa0Phkqk3kPgfFJ0yiyfDO0dTv0UlD2c8l8MGLmoWmxJrJqvGYfCTd8ID74+oIDN6", - "wcgfLJMjoXdLmblaI6pPzgpMRLbVR/QH4CDCmA3dvPQaDCwWfjg+Z4uWeBHbWelmcmOJm+QfIfYcFuAD", - "y0hIHOpIIOC9aw+aCsQh+8SuF2xSW6UT7MGUhXc6xEzRT3qkKwDQKrPSziYvuILDTVfL0n5XdfMZ86ES", - "kFJDZmVZxEQehPE5ds9IbJv3gK0xWVxba4/2/+d//18H+/uPTcSsCUo1uegu4KCKYfup3yssfNB1y5z9", - "7OAUUQQKwXOFWM9Q45AxcsYmms+tJQWbhjJFpnBQiuTS1IQdnEGqQgJJ8Y+EzMkkoTmZMKhi+sFWMsyN", - "C5QqkCZSiJwn6DSjc5gurkaCXc1oYcpTtJ/6XiEU07aVMCUG42lIjqAWDV6zGX+vnqdxJFVu7vAQ5nEk", - "TIhgk13cB511sRnfB8HzI/19cxFdtHrKsoHuiABlVb81+aAYGfXQwh/1DINP+BVGypbf9YnMRmLUS5L5", - "qKfZNZHynBQpNgqQo3oG3rx5i7/YEhkElx7PDCzD6r2Ds4WfljYkJyzXbZ6KIklO9b+ihFFTN/iKK5h6", - "R8rfwCEINDCtefVGV4hoRsUU57hRqMjectoWljGOMTaP/Lov63POSe26wGrKr5QP6GxtFRe4bc9pUABF", - "qSLEKzvzdOkt5Kzq7aqTD3wSOz8SlGYJYa5bp5nrrL92zEe/d8463Btae2s5SK6TAWc42TgxQCGwJ3Q3", - "TG1fvjPe5tJpYPd6vTr2mkbvhbLICdUNDckHkfBzZj1V9guMwYfueK5YMsHkagOA4FABoCLXGYtooars", - "4C6f5hQEhsXmtgwEgOfDOwQBq5X4mNYMsQ782WrQNVe1u9FGzhZeQR9jO1QCIOCrSrd1vHeM7ObL3BNG", - "d7wJZigcklym5oYC7nshllYrA+FcRHphXtJohi/4kOg2bwVdEX2SL1JzG9EsF+UFKmdyPhK17EDywgJE", - "PopmPIkfm40ZLv2wxk8hYpaRU4skOYYXTkEkgA+VCV9d5jRRORUxzfDj5WtvD/jmC5i/pucCJr2jsyLY", - "8loLuGGYuItLrlmOTpRxh/XNIivtep4CYYQVC7aDQJWmb6CKRot5a7fxYMi112C/Z8ygcSelvRrR3DQL", - "KrJ58uAKJukrFSbwVfkxsg+PWNdZM/iwQeLQOgfPELCDA0OJaBIVCZAE4und9tpFdVe9Dn8Wqnvo2e9K", - "ouVMCLiEBgLkQsmTVgYMklZ+06wZkVUd1S1y41nbtaDMwFs27ybDP9dVJ53k3RK0E2XiGl85LxX109Ur", - "+eXtGvUAvVsv0bBRim3tdvaFJQvECgxJS7vWFMAOz93JBc1IQsEvpr/Q5yuiijQ1R0lsjwp3/hkJWN1c", - "Eii8xPMheWmPRrgSNkwCtDi1fX6lyKlZCPCkYASGycOuxMuAEf5Z5Ak3FnCD3KP2DX9FFlKbXrWbAe4S", - "TsOCwLZkLvVtsVQvBqSTzezfdrRcAmAH1mMeyQuwksEeLoOR+kSlVAjnZqZZwpkNd8R7hFyOBLA3zd0T", - "JmJCo0wqwCTVC81zHDVekrwyOKj2dMsBUMywa17148/TfNE3V5dzRoUip5qRT8klTxLwojiQo9Ncnlbi", - "BCtjbK9E/N6rNowasbZMnu6s3NZWLFmvdNJ7LAy8/H7THBxsEeHqgvusu/Y2splTq9ZIYPu9buXbsAOl", - "yZdbdZK4CF7X352o+tNVj4JMhGqSGNY0iQJe/CBE5OG9o0tu1/oIa9k4x8MPL9//zW0NUgDAnxZcQA9Q", - "pBAJU+BVTRMecUjnuEqpiFk8JC9jjgkyF5y6LYxVdx2IaqV5NEOtcsrj0z7uVap0kgj4Hd41DpQ+KH58", - "zQLSGe+JXWe4OUHCR8IdTapsC03azWyZiWJuaPUaFNAgJP1TISRg4uk9lcUk5hmLcgy8We9io3Hu/1QN", - "2w5lysI2z7tL1on9brVI2S6+UghdGOXritZINGWr7LhNtb7wLXfj/baBaLirAMAlQGEb/RMKi7E2/kod", - "2+9d+tHd3dWTDTNYEsL7azDUu9zwI5pixQuauwl0CDgWltsOwwWjNy+yzNz2S43rdgs3yJV7Q2M81/Nb", - "N0KoqnOwbOjNnWTTpWoJ5w8bOi2UwpWo3jEwubb06vq7iS33Cla7vcypRS37oftGfLzYZYInNP2ejZlv", - "ieB/RItcDkwMct/E6qI18DgY3j8SjxqRV30SF4hY8Rjq25Zh/C7SSRXRTEtc+e1IuOSAvh9qbRe7X0sZ", - "QLRAU+8swMptzoI1mBZKhW9mxsCnK42XO2ABxHzOhOJSLKupE/isehNL5ywmDo2XXaWwaFCcThJ2lWuS", - "MIEwk0Wqd2BEOC99eejzjmlOYUw/sYVyULAGgdkA4CgogAY3uEk6o8IUntZP4WivIpmx2jy4OBs3lL8M", - "rW+lsfif4+Gy/aZwSbnszVh7SYOrrfWH+tBbqA/dvtjH1plci+nIjAmzzHU5SSAgdpXX+VUC0ECTjLF1", - "3tav9XvTjMaF3rzW+OQH924fIg/W+OSDfq3fu5BJMV+Hqn/hi9vxt5bjXC+CtJzFDu/DCDu8X05ih4/s", - "tHxczl9AezedoT9Bl1Mg2wmCZrYREAS4lBiCYxTupNKvAw3CHtfywLh4J/8EAKLS1cNijGUz3FVzDOLV", - "bY4zxtrmeNNxaio2GueK4ZXs2W2M7juSc/AQIsnuaiHHwyR4QW18F8Y94U07XrubstoIUcVZpo1T1LER", - "FQRDdEZCW6XFvEgoWOT4JXgRmYKvyJks9DmQGzcioNljpJM2OAlvuAycc7Zfb4A8KtJxLsfIHI/R+23M", - "KLh71YbPBQMcQHvogXC3wFJzlqk25EGAcpgYS8xOJc4hOcxJwqjCOFCgj5cpWx1dDbDI781ZvFrtxYHt", - "sSyInbgZp5YbzIZiidO2gm3f886hVofW064ntDCLWc69Nv1w24L3sKzGSFTWAhtwc00eafUzxl9lhuF8", - "8NdjZzErlg/Jr3CjtS5H+gyIIesh7huJFexX0rbRnTbui+FLd6fLvbkw/IBSjNkdMZEi8o7QlpWZgNCb", - "ylV8oEkIE3JTutEgcLMODgLCA9caRKoVhDfXpdYyb/ZqIYOhcXhruo0N9kMK0UwQVxclRex8ZiWkK16D", - "2EokyD3l4F5P4IwGSSt9vKmxyyNTJgZMxCwmj/AGR6F2flwZKVDgQMdWmcKwEt0EtpxLhEswoRI23BQk", - "pr42KGurlf9IoKxVZAgcGJj2Z1W8GR9sDGw4HZIfvgcoYEYh1eRskTP1+GYtqZJxt2pJgYG/U0vKGLUd", - "CxejSm4YGX41f4/nQTCpvSeMWc6yuX97OPDEHiKrkgTXfiSsHeKlDn1mhoS3fX3uVoQ5QO7IhGhGRHWE", - "rtPku+gn51NqT/Mw7txsfVi/7+0XXoHrNUK9jFvL83iECjYvmZlGA3cd1K9603W9WwzvFqzjxbLWFiem", - "pjnGS5GM0XgAR54SBeXUh3Y4xe0V5MBeQuCdK1RXsUrBYJU87hOFRyd3oaRyulCI4FOp+oCeTXJ6zhan", - "kAJjr3NtzDiiogiZA0qGG71pF0F8cSbQD9zc3yqwHd2vaGrYHwF0V5NXoHX0JcS7+wuiZrJIYjSvtY08", - "IYIxgB1ywVkNU+L3gjnICFNytwIT0izKE3Qmv2FTmhhXctYCN9veZk6vxjy+zqT5eCBtWbD64VeKJEBq", - "DSaj8PMyLL4HQN4voGQf5CbKfMaykcBMMZOTeMm+yhge4aGYI4bwwaYpFSMIkNdouM0uVCzLTXWTTTzf", - "WNSmgGbu9KWOhQgc232wQ+GX1+Zb2PnCa+2/UoUjVi5xc9TDEI9RT3PsqDc3BR9HvUow7xZa+/zDAXdV", - "2aIBXL5W/YqWjJIKS62sAGBkLU1twNMLmtMNpa7ayEr5s0lU4w3A38yM1bq0WVzuLiZ0NAbzuhopBsha", - "lCRcnLO4TO4q79tpmvrS8LLxBmISZjxl1x3DCbayCeH4aZ1Y22C7prUbCFoSmy1+tY01dK/BoPmzDSUN", - "YtOq9W2NqdMCfvb5BendDe3WPXzMNzja8Bno3MUBNMLFrHHlrEhY7JpBOxJl9OxmAVo1BJgVqaou4KcJ", - "sWgoatO4XsiVI7LvOLxd6VqpN3RurngDDa0UQJqmYwspfx11FTLO07RUUPaA4BxR9Yd6Pmwusp3ozpxo", - "NdfyUng1Dgvn676e4MnH1LXuVzRQvQXrRS1U1V/9ffW9ZcrXTub1ln7lem+c7n1bid4R4CFEXbCfzRdt", - "4M/m8RIaXeTaUmJtQw+7zjV2nTTjc5otxmxu4NSD+ZH6FQKvtHJYNRkSPngJbW43q9xiFn0OaeXtW85x", - "QsU1ztXu88/hbD3J5HycJlSM0xlVbJtpxefMaRHdAYEOMESyBEs0dX/OWCTnTBF6QXniMBBtwd3KJaf+", - "vmxvE9me06vx8upE9lJEOEweqI7kU4wwM15NYOcMS6gYklcyGwmTFlIve4n2Esbr2ytuG/KrPyTgD2h8", - "NhJwCWze7JNCWLhnd3dTJ6qtwOZbekV+X1Zk844EgQbsyDrDLhfjzSX4cxDez3RT0+vW4iQqBVsZNEh3", - "taV3iYzO00AhwCE5NNpFXfI8mo2EjKIiM8FSJUYh4vQ58xTvKKt3fNjMJpd81spOqDi2mil4y3dcjjFw", - "15dmcpwB7tWYCa0J47Ux09NMDvBTDBCBr70DmlZMFUPAvW57aroMwkJoqG+XPRc0vIn42fuvdU5nJuI3", - "wE7WstBrnqZwQwTx+zbwWHVdWUPWYZqapn0P5KHpwu+BOOKay/ygPba4J1QYIciU7VCIzeooBhDxnC3M", - "9rlMmf1L8thDJN0S9N2F5DEi3/mx/gHkQ0xbGtP4vwuVd6uxUcEXBeL1WAzA6GHZIBp3FgxbSKiYW6X/", - "R3lZkgxfqjKjKscUioR6wJg4HAhIqgL6ner2TwEgvEhTqBT93DXtCpFhH/YKWfVtZyNX8AlcaH0P9NS9", - "AxdvIleA/eCc2F6yFxA8JK8nI2E/0bRnEIuWsFz3V0XGRzJiG2I0pwuichc5Bg23ACd+gtutiQypACYw", - "6wpKb0SJLGIi/OBdrO+lZ1yUwS8m0x3Lbx8evyY0SeSlGomFLKBOgZhqRoOzk+qT3wuWLQxIILSK6Whz", - "KnQPVowrOSYlYfrNn6QQWljeWmJGxf7+k2+Ic1Ucv+71excsUzis/eH+8ABSElImaMp7z3tPh/vDfazs", - "NwOm9iuW6WMU/DhleShRW+UQfeTVk9fiAav/Ou497yVc5QPTiu4io9CwapWO8pU9r3All+Kfeqog/aCm", - "LmSWO8Pe5YSbMEFXqJKcWHaG+uflWRfi5Z5rSRhAujb895wt8B9av+G/yurXp+SREcfH8KQshX1qY7pO", - "qYpOiSomE35VAb2j1asCIEVmseEyFTGhBQ2551SP83QkymYs2IYtbUdhf8JvsBlMTksTiLUxqo7rWQJG", - "s6W6n/d0x71+D1XRyprWMsvt7PdUvgA2nMhsHlgNrJW3ej16Ybomtg7fepRp/oOTvjrWbKNMGT+PzJix", - "9F1ZjdD2Dyz9ZH8fSx2AQjIGTWJiDPb+W6FlsB4lS8qSg5JZs5zqp37vGVIV6sxRv/c99VGenu0frP6k", - "Xozv2f7T1R+9ktkZj2OGhqgq5nOaLZzg4yJr3US1Afibp5uOMxkXUU6OaE4TOdVGwdWg0AdqB1FqSq4F", - "yu75MEHlHXVVsaA8DmzNeWOjfi/jxdbWFOmoOKI+VQ0gM4waVx1sl6tCDITuLQvL+fnxj11iWNyNGehT", - "v7lX7f0J/30df0LG0gZDwMaUk9wgaDgP2ILwuMln+JLjs9oOBjoMyn86FWa679X5ZF2dZuIGm8rqWcD2", - "RwyQz4MB9BfPVn/xs8xfycLUJig5prli19A7QWPmB5av4IUpy+8CI+zflH75Mtmq33t2sMZQftAHrSoP", - "lhxynT2vaIWKhMqYSzkQbc1bYsLt77CBEMq1dtgbkwDnAXsQBF8QLLvucvveo1k04xeweYftxEN8wZMa", - "c85tyo1p615pb3MuvQ/GgeOEChvsijHT4izhatbOmMf4wjqMadp6YMwvkzEdJ+yEMdN0hWsObrCThMVE", - "v9vmndPNbMU3t1OeStP75l7BdWlyyqF+8DHADHt/0jQ1J9/2I46oskXLMSdN19NGusO7rIvKeNCgQkrT", - "+6CGYN1hRdfkJnOdsWdveJarGVe13LwNF0u/gOtXEaolEW4m3WPyAxQy9z8xiOoXLCvL70OZplN0CZ+O", - "RC6JoFkmL/XhCEvl9V1QWh+rVCKgeBX9GUs7YmNKZvkpoDpr5spkgm5zEzoZUI5uAnZ4eeHmYIPbC3dz", - "ARmceAex9LaiCsU8hsl5uLew9xarlwKwgRD+z00+suhvyJMff5Ps949/B4jLPi7Lqf+W5dgxjz/+ff/g", - "p+MX33/703A4rLzklvPjb9Ocffz7k/0nz2w5z/3n8L9/n27vDsWAjd76LYqh455t9HX1GVTT9kLXQd2C", - "fQhJrIImdtu9GqQZv6A5K39YakLW9fzen+ZfK/znL4wjtk57CSZbRzyG8vuI+2pqtppYSQ/HOmFYbtAH", - "z0+SkaCJks73myR+GY+khAqnIm7Bw2316tu60+tYOm5iHjz72zVO2nhpp2Kw7A6gToi2N16/qBg1AAZY", - "JC72pKywVyIZlazZtyyPRWJUn+Qyp4nqIyD75XLI7bCBfkdYd+uGutkCQtr+dTnX98Jgv2GBWHox0a7o", - "tSjMC6yYYNDDTRSiw0g3tZeh2sBzP6ayTzAGsq+tRUxP9E36RrKjAeuu1IZSQ/K++gOiFNXKM/yNrFmd", - "gQXrC5laDGVRoY0KMJCy/sJIBAowYCXhVTumV1g3eDt0e6phFzdEgUprN3xHtL5mukeezTbFcEeM1z1T", - "a2DJ7RG+0KLazFNVUWQmeFawq9zTTRiu+t4+wHhbrkrcNq2DEJzQNPSVIpg36iR7ie3aohOg6j4eE2vq", - "wYw8oB/Mkwfb4cu+DDOMXWPrr1TJn4W6M2KapplcesmLL7SI6fsZ13wPhrg+ceb65MlEHJRbl8BaKFvz", - "rUQsa0CVgW+81ocyCFFckPxSlhWrYUqdPwjk83kVZM1EowPSV42cfrX6NagPk45pyxLpVrFa/RgnjCZj", - "BAvbsJuRqPRjFElTYeDkPyiMLzu0jmmjul1e7oquyFieLdo1xS/6MUg/Zu6E9AW+g/ug1QF21HQCketk", - "gsY8zXM2T3OH00ojUwQKNtkI78/qhZW+UkYZ4JlAfWU+s9nGBscYrYFRD0Y06pmXmhs2PH+Qvi9a+rqz", - "5F2RR+ugGpT40u3S6VBKPTDqicwqNeFLj1lt44V9zSGG6hmqtQIIyJCVVW/JXODYsmSsuaVD3pvb12Hz", - "Hl5SDhnAE5mNa6lpheobME9o1ntqq82ihlDnPE0BQ6MsBdgi5oGJfBD6L3vLXSYNDR6+QYE3eEZ81ZV/", - "+V6ZKGqBYVwu5EKZKtCBi3Wvox1erXtkXjM1MJIxq9+lm+zAh7tzuDtfZ65hsiSZNL7QrLNIIYITL1dk", - "kshLPUZMkYXlf24+/E2/+vHvaJ9u7xb8yJFz2/fgFrvrnl2EV3RCU+OV69Om69ZUbXuGc1qNFZeBiC9a", - "whZaSLG2iLmjw+xuRErRzLqQRUbkpTAfjoT90gdu84ClW7Ia8euBA5fbZX6jw6ODPm8p0dHhlvm0hBi9", - "+sbnnwFZY7Ab4fu9P2132oqPpMrB/l6140uVg2ViLG5PKF7JrDYQbkAaMnf75yC2hdcQoP3HfAKAmDk5", - "ZZMJg4rF40km56cY09dmQJR0r2Mjl0O+rpHcuv+V41p3/yu/OFuQCadOBS4Qv2b5bjgSZjvUX0JR0Y9/", - "/3DyYosbolT595q8dfbD/t2LGTf0c/VF76PXO4nUZHs7CmhlZr/tkDeUSeuWaMSd37S4f9zp5ms59Jb3", - "XUtGcMu1D7+A3dax3W42WvSX+xtp8ORrX9vpwdd0si1IHDjr1s6/XpT5wynYnYJXTnz9EGw/OFsAZOt6", - "R+Bztvj49/liEJ8NeLzNM7Ch5vaPwEjIvTsCl8ohpKDs04/eHrvkCAmrv8uzYxUV/rZOjWaowfOiufP/", - "Qk6KLbexPmO0bEr61If/bMT2B2Pjvf7WMbds0w/R8TuJjl979fthy2PK8ruzovu3ogHuSdh4B04xEd/1", - "IGLFsttlll0BzWy0Xd0Osz4Az7QAz8C0bHUvtEEOrac2X3cO7MtfrA7FckntrOmXb7pnKtVd4EBFqI31", - "a+zb57fJULvWs4GSYbercrvw9oMGXgb9tZlIdFHHezRNB7b2WxdJGrgPvyCRail9ejvi1CiuFwRWCVdZ", - "fZCmdaSJpukOJApLv+5FMxadyyIfKKYUN/juKy5sfjNVW4/Mt+QEv/34aJbnqXq+txfLSA2xh2Ek53sG", - "u1+57h6PRLCUIfahCG00DndDNsBSTF0FgTnLZzKuFuvMMNrCjB/9yGZ8Jl4Dk6dGPcXyIh31yFzGrG8q", - "YZlOyqoJJlN7JGy+aDSj2dSljdj14vM5iznNWbLALl25gTqxeA0+Eq50+aTIi4xVyujY5YdpeSUzMpNQ", - "n9zOoB2Q6pOMYdKo5z42UfvO7fzhlzemDBabn7E4ZrH3faGwsE+UcCbysWJRxnIsUMBzThP+BzOFeof/", - "DfO2kEU2Ep7qWBG8wrIBMsOgzm5fhlquWRY4V8YragZsuPh2naOHabqUNlUkedAkgtfNp6GPPi+P6g3q", - "dKMzWxTmTjR6KrOcJuvrc0ubVWPH8L0lEdTPB8UmRaI1glM1Fc1ntE1LS7m0NUzyGeNZWckFtaHqa30q", - "7ONGfVYqYkKjSP8TX7AJETOucpkthgZ7IDNwHB9+edOoOV5P5+PKFiDPJaFEuSrkurdy61hbrVXn/MtX", - "avY+DoZ9J1VbmMK1FFz7pw9qbi0158QOxYKobWo7sL1WZyTYmz58u4HXY1/4StlXSD6jOeB0uCLuLCZU", - "Ecahnt8koTmZMEa0EeUnKtku2lIbjKawdG8rzmOnKqUljsTM1NJghk6BJJWgkQYg4RACP+GBK7fuPbgr", - "QR4ei3mRHGauHDzlyvjNIHKgRaOhEAm7RZS/I6RvzWDO6sBfXqV6UwbMKyyehpF7mS1mHxNmEplqLHFB", - "k6LKCRmjyTjnczYGmTp9TkzrIKVA5Fea42gy0G9hUlRbxSgGn1bmoUtNSTMnSEDvU7NOZJUhdhrxAqQ8", - "hKquCFWtqflVO0z36NRaD6sNwlY1/zmagPaYqId0y2E9QEPQdIMnX05Ij+G0DVh5PfMJKoyqvbJI6ZIT", - "4qGteFq+7XDHTBDmnJ4zA0fivaXwXFVaWSNhWjqjCRVR3VQoFBtEtERNgRKxJJJZhunUrWIHjQ68iqtf", - "ktzB4Mrir7csgTVqWo5RlXe+8PNSsIpdU2R2LcpGpJYD/ZOa/AVxRMtdDOXKtnyzQtUPgLkUGR41qqPQ", - "xzPAl+SKaOtQ5XSOOE0vMLRclfA1CLGm31o3Oty1uLZh/YLm7D2fs+DhYQuG+w8sRxH7Hsd/23HZFdVg", - "aFLtisG+cX9AW303Q4Vzd60ToKb3KieJV8281X2BisA0d+N6YCs5MPac7g/3JooRe8Xcbz+DoqTl4VC5", - "4lDp88n2T5RYydjvZEgOK3+XDkgFVcOSROKa670uzVhKeWzt6ZqhPVxhKEP7X56NDHx9F8xjIKR9A4TH", - "X/4lwv53qz84kmKScK32wlZ0XUhuZsPc+zMqF2pl8ayqFIct6tuTu5Y7An98n0Mk8vpydX+syluXiz3F", - "8jxh+nS7x65sYnSbG8kEtmkzy179l9/b6xE50ZudbSxZkEkhYhZXZcwEI+CJj4k4lRzBbdVCRLNMCv5H", - "rR9Atq227R5e8nyG6JuITkaUxFvAjF0wUWijMJJTwRHdRzha6AXlCT3jCc8XgNQN14RXKcR6tSLx+6pg", - "YGkZlBPxhaqHXZUB8CT/pZnMEzeXtxxhvr7Oun9FAiqWrhPJhj64Jb12IXncrsj+JXlc0799MpHZhAFC", - "qDlIzinifxUY3+l7vHUDAEOsCNUfXtIsHiRSnnMx7ROeacWTKX6WsBJXbEiOjKlPk4zReEEiKVQxB5jy", - "hUGJxF5JISigJrGY/M///r8RzbRKlPWcIdiKJpzFGK0KwxkJ3YXSCu1UzwWLT9399SRnQLAakuOKeuWK", - "CGk9ngYIeSROjZodl57QU/3qqZCCnfa1sjWRXIMzGp2zmMjM1/8uetYFjCkypwuicp4k9imMTmZcH1IT", - "Quey0OcpiAc7NXfm9sRvg25xWH8jF2YtKEkRO6KvdbhWFFA4clIgETjV7mRm61hGxn4dGhxpbEkVEKg2", - "KRJoHtZZEB6zeSpzmDB8oblJ6Nfvg7W4/e1Ay1T4GPig6j+XYx8o1ps0a/OMCmXg2NfykvofOJgqL3HB", - "VbgVhM9NCaw+AZtUJnLKI5qAOZnF2ho1jc7lBex56nnV2lVYC84pH/PrkLz3qcBYtdKNiZsHq3UKgDiw", - "Uxi4neWe3srE3DV/71GRKZl19fhWlu7G/L7+Ut0N769H0Vr+X5zt++sBronCTvQRxMmh4TvAIPf18MIG", - "gQ+/nCx0H3zqZTnQQxinZdm2bENYwlqML5qCZMJoXmQMcwowmYAae+yeBMp5bEMc2zQ525v0ZmC22UfU", - "Xk6vBpGMmVqKliCzKRX8D/hxYL4dlJ/ukI3eeT2bgID39OoIug0wzpLX74tv0V8rB8+X0yti16rJKjbS", - "ou0ubEmy9hqcsSvv0ZK1viXf0RaZ9YvOrw75lLbNtlV9xy7YylgKLqYMfB/4couNDe1xMR2YJrvmgnS0", - "f7GXdbEnzdtnC6IKsEnXRZw2r3/8DRIWrIFysD2D+iVQtlGqAuStrJqH9cBPc94EPbXLXiaw5DIrQVB/", - "nTFhiwb3LRn62KZcjRRoFgBMT8mjuVRabCO9O094pvLHQwJtUPhCzzhLwKuUZvKC6wOjK2FscFb7hCOg", - "qvJQUYfkME1tYTcflXUkcmnGbN8F51fugFctfKt9z2v0hvNvdmlwvjbrCJz2BR+OmpahVUnEqSSrK9/a", - "Jyh+nWJdcD7BGwLtap46o3k0I3Ji5aDUKprbjhJZ4PQrA+zbCi2AQhdQpuuZC5HuCb/5j25cYmcEyITJ", - "bGl3AGMNtL5WNlKtm3oaUq3bZidULN5NWreTtl62Q9zHtaymJ02OeT9jljFm9IKRM8ZEuatCDnimfzVZ", - "3PrkAumZ5t5XFipZfD6ih/LRRfhqNok9yS63SmiSuDNvi0niGtoh/rg7dl9zBz5ni1O/1lY1gbS2NRt3", - "+wMeuWcQrl6Iqkno3j9bIK+OebyuVWjfN4mso2J//2nEY/gv255t+ApJvG0PqyPjXgGUe8qjecJ6ZR9u", - "FCRrmm4NaDXPd4pobkZwS4GlpvcQ95hHn3/SY7mKHfknvBvu/Wn+1UA1D0GGl1ym9RsPRG4Z9POSytUO", - "dkfAA/b5TrDPN+aY/rJA3hV8MGX5XWGC/ZvULw8wN00X+TUYMNWnwtbw2DoXmgpEebIo47gKwfMxFC4y", - "JeRNMjbauq2hp7fHu7vy32+yNd+o6Ny/wM4d7uVQl3IPDwutwZlwFsKLXy0gcrLMioS2rFxAPbkvQjhg", - "tmEibigMzizskVS56bYNYu09HDOBKDKjCiMhWay11hcrGciSVq0bLruWdEzlBcsEFRFbTxxs3wZAEQPX", - "Eo7yUSLkWg+JS6nImJLJBVOE0WhW3jbwmImcTzhiPpYhcOCgy0p8tZEwHZrYYYv1axiAxe7o2CdpUniu", - "mGqa9Ej4uRZA5vgFU3wq0OVyxkhEk4TFRAot7vwKVO4kY2pGoGLfBU1stIfxU9hVI1yNhH4HAu9sY9GM", - "xcNxi74oZ7815mazG7wdqYMfHL11nXCTu2WDina3yOepJAIyX3LKsjCbcmbaakymGb+gOVuz6GSSzGEv", - "29PtZjxe5R9OWTbQO5tKacRImvGIEfdpi8PY9jEo+wjvnNf37b1581ZvLMears+17DAQf8/cgm/evDU2", - "mMciTe7Xr+n13cxBuIx3W72GDebdkf/QcO470wsSfdMORF98gswGc/bZ+xAb3Nad2VZp0b0/gb/W9Sp2", - "Y03jZAyx5uoDiaHrwdm4E2fj7lgL1m3F7jxN5BlNSiLwmyGxqSb4N0QAlZqWgL7QpvqEULFYtYkbOhqs", - "Frw+NARs7/Jukw0+cL9sJmJLxa3NYScb2h/mMmaJ/qt2w8wg1ZJfsHGJU1z+lst7ee/8YH/dIfvLSfc2", - "lVZ1M1xyqWLDuGr0kLMFef2iVGMA1wAPWjXZSARV2ZTVNdnt7pn7N2a63UdnmmaqKiddl7EtmyzbhPGd", - "ZfHcOw2dwi92EDhFp9OMTYGAh0iq7pFUq9alGkdl3j5bkHO2WBFAZb757ZwtPv59vkAeG5yzxfbMLhCU", - "W09KBSru2c7sFEYlztMUiF3u74BPWx0b8HSnwVBA6S2FQkHfIa5Alf/ZuzDs6jW4IrRf7f0J/13XGdHC", - "N8brYHtebTWZTh88DTvxNLRywNKwJfjK2NNB6/gOLO/+TWmBe5Kiu4RTTK5tS3RRiyIwIUK3wym7Cg/q", - "vlndGJvev8CgNo5d83xW7nfrhTxYtTiRmakWBbVGWE5OD6OIpflzUl/cU/LIO7U81keQKbow8qyI8iJj", - "MfnPk3c/+/Z9pcGcXeV7kbo41Z/G8lIkkqKRr+icQfVmfTSi5OjkXwQqUKqCw8A1mSOhUoBdmzGWm3LF", - "+sVIJsVcqL4+XcDpp+8OdaeTTM77JJd9YvNv+x/JbzYeY8zjvgvOGJ+zhfeXFuP+R4IJGTGfMwF1QofD", - "IeZm9LFKV3nWM+2fGnr0QY1hTisGJl7OmPDe4sqehmC5vlIjcTrNZJGOzxbjsr9THGc+yxgjp466/2W7", - "wURZ21EupwzK8OkeRwK79EYb6JaEe20J7fhS9F8wAuzG1V81Fqzfs/KhP2ZXdJ4m2PEPeoUwEboSSlQu", - "GHRcboCr3+/3gH31yViLSC77vlBUZKIqEuDm7+eLlPWhhZF4sv/k6WD/YLB/8H5//zn879/92o8H8OP+", - "wQ/ffP3vv3799eGrXw9/+vHlwZOf/2v/6J/fvfqxT6M5G3AR9Q+jOSOvRTTsT9N88GyQF9mZ7HORFnn/", - "4Emjt4NQb0+20tuT/UZvT0K9Pa329v3T//r3wU+/HH7367f/+uvxyZMX/Wkiz9hV/wf4DzmSWVrpTRa5", - "7u6Z3kd+lgTEcXC2aF3dlneaK9p5fbrNb7f5eYa7nhMOkxCr8oyL6YPz1o+K2tgSSBMq1sh1hddafLXY", - "xA5dtdDBti4hnccW8GA7+WjviId0xXRsz5t5rDu6bWemJuKe+TKtQDWvYI4zGRdRTo5oThM53bxKiu6i", - "1eWpH+7U46nX9HaLimgKggyUUPH5ez3NAm7GP4H9Ye9P/Z+1g7T0HC7P+zQErnGjDP0+uEZ34hq9Fpss", - "dZ8uY4Epy29//fdvVKE8ZHs2va3XZL7lHtll/GfcsrfBgrtwyiqW5Z3305tl/y8aNXFzKTDcurPNeo/G", - "8UoQdhrHA4A8V0pGHMweCBajLSaiO/ENTOs3J0J3MQYyoeJQz8ND6cflMMmWzSYyu7bmDxdUj2Mo6Qj9", - "YArlyjMOsvDnvwmUhyrgxVs6Wbn+2/YBeHifCpcDTzqG3LWex79hklec1H5hc3nBPHGZZHLeKjDeke3G", - "Babf2rYZ58PJcLssa1nD44udnRId+1nbg+suIY8+zIn25Hgf2HD/pvXyfanxGWa5XZ5GO/O5d0L9Qll9", - "lwfh7jbQjcvavSsjsAupW24SZdGMX7D2iKZDfMH6isxlYFMWTUP3zWN5j2LpLCf4fLAbpkyLs4SrWTtT", - "HuMLK5nSNPTAlF8sU1pO2AVTZnLCk1Up8me4HsS+3eIJNK8NXKNbCQO5CUZDgu9ZZEF9VYMsZWaInLA8", - "52K6Vg6VYJf1xiE4+Ptah0SvITUhK8p0ALaA/dqU58wzmShbxngkpky4os2HolqWKKICKxvMiyTnacIa", - "wyQxm3DB4iE5HInaQ8IVSbg4x/xIL7eapumQvJ9xVTFbuCIMhIurGYtHIi4yW2ij1vBXCn1dtsQ9VopW", - "ZRHTVt9kTah2GopRFYdbDsow4w2IX/WNzz9CIygx60pjWJ/v/cnXDNAICSoU9lZFNGsKj4HCjY0XLJ/R", - "3AusEzKvJCabz+yjlAuDKEiFF1pcKN2F+9NBE+jPIPQdBHrCBU30tFtFoNq8k02RWW0U8Qfv4W7iSuim", - "jL00pqTOtUH34F3hg/3b0433xZG3OZMtjx1ZyWfGPXeLrLYr99k1jIFbZPj7l/dHt2M5qOLMTeuK6tjV", - "V3cY61/paFsx/9QDE6uF99N7jSkWzC+oLMEW0wlO/HZvO63AJ+YheGd58E5d+JuqprK0FX9B8IDrN7ij", - "061Rfj5ht4MVGyAkxFr+8y88RkZ/8N3qD46kmCQ8ysMH6BoLrWbJJVvf3p/+n1X4veYRo9bzaqOv2vhn", - "cNboxKv35LixU35bK1JX2x42jBJKsPiNtLjn/Ve6BOxul2X7uzIQCQ5pEzNxJAJ24gNS302XB/el5iGQ", - "uqMtRpxEr1RHXSOpvTDq5WomYNF1iFnawda4q4uSBqfe0l1Jg45VO/R9CLveikmJdzJ1ARust9+Hi8ws", - "vYhfyyao/u5Hd28UWLtcmOvm7a1Jcn9lH59B4O2Gknq/A3G72tnXlbKIiogl7SFZR/AcLbqK8JBfeZLo", - "xdI2HhdatqIZiwtwuUZG0RA+0V9mjNCMjYQEoK2qi9N8ZYy+nGordaIHCvUWoXecnZzPQyED8MadOJTe", - "jBMH1+t27iQ6HYy/7GuJa+64sIo7PlRHMyqmS0KAjxKpmCKUZIUQWmqrW7+IURyVMQykgIpzMoOTWC6x", - "GqMNFzKxSUembLA+xAFMYjrNaMxUH7AL7b912xDZhyQGguvwwT0Sa1yr2xdrJOTLq6R40wIO07hjAS+E", - "3TwH3kbZLvAf3PvN/dzfagNX/uGeHry/D5tcuwyU7NbKaRvIRE6vBpGsFiANeH7L13ZzWf9aREkRe1GB", - "9IpAfyE8unW8lRwbHJsGewHgxzMpE0bFzXoo39OrIxnft0Bxt5xBDn1Pr1a4FINOQsuTOw1oNut1u5HM", - "hoig+YCPPv8QZssinTikRZft/ZnjtDSQC4LRvh4jrd6AXcsP0b47ifbdiA/67ffrd2Vx929BKdwT39+G", - "LGPiduvRuIplt8o1u4rG3WQnuw2mfYB3a4F3g2nZbJvULbHsIlw0+I2MaNLr94os6T3vzfI8fb63l+gf", - "Z1Llz/9MZZZ/2qMp37t4ChjvGddtKzwZZ+ZkDNEJvee9b7/99ltY3kY2MqaWYpDPFE8rZZfq+d7en/j7", - "pyFN+fBciuns92Ek54FuTQOVjgttXDJRzPWc4B9Fr9+j+v/mDONOP4YIK+fvKJFF3CDLGRjDSD+3M6Gl", - "1SxB49pMXrBM6HMZYRc0KdDjLicuQ0mRXJJoxqJzfbjhGZkwmhcZeASZAgee0S0lcWWjgfPTOy+DcZCw", - "C5a4gJFIigmfFpnzRTRafoFvql7ropEI84HJnAo6ZQoxpfs2gAhdkDgS7wZGNa5gBmdUsdiGmweJqWcg", - "N2lytUVjmlPdIMFK0FxMiZDZ3OR4pRmP9E9Q00UTklAxLfRxCgpIKEKjTCpFbBlpNSRY3xrqmaiFiFiM", - "kEUuEZRd4Y0sUbLI4E0RE1rkcgCTnM1ZjEVW8hlbEDrNGAuO0ZU+DQRNIyMokrE0Y4oJSIEza5DSM57w", - "nDNFzmh0jvU1cG/qm6K8NmooZdmgEDzHmVrNA7bfAEnv3VlcT4wNKIpoEhWJsdwZLrVj72AXWjs1Wz8q", - "soyJiJvZBHL1oq7TYvltoGGbr+DSgi3vBpJrsW+bFbhGz41kiGb/h2mqCBNQO2ghCz1nmn80x+hxQvP8", - "D1bJVIYySORSZueTRF5CIVIucjbVCyemuMQlEy5UzuZIutbuWHQeuo2oAL6cI2JQTJiYgTpayKLMjWaR", - "xDZ0PwpD2+C60Wc0SOKkCgRilknB/9CvIKEgWkBUPuNZPEhpli+0bsgnMpurvmMSuOLQbNInNvXajDhm", - "Cb9gkPRsp79PZlTEuDx0MdciEMkkYbB3oKrBm0+bMpWxhKLTSJ2Hl0tPSmCJXoqc5wnTXdSYGzPGjTrW", - "v0ysXK7mDb/VUNhh5b7W7zXPaHRuplZOcK2s8GtFims8rHr0bD4tFzG/4HFBE6Vf9lPaFSbZ6heNMj5j", - "FkIQ2QfSY5uDDQ6v6k8MCbTd4zYZW/n1TY/L9RwYE7wBInPR4JV1R/ay/DTNpCaJxYRasZKFShZaDrV2", - "sipdSdxJ5nQB2c96OuZzFnOas2RB6AXlia1NhtW0qruqIxv7bhuYctGhM3kJUXqm5jSz460jKlBBk0XO", - "I0XSIkul0orHNGWWze44FgDY7aFePWs9zpmMcamgoJBWpUPy1r47rzZpXFyaGFexDQgkUAwKla0mcZKw", - "K35mG4BNIGKCZlyq+uyo3qePn/7/AAAA//96PGsWpk8FAA==", + "KK2PlNYLnrD9xPROGZcnrE+ihaGP8uuj/NqSX0Px5vcnwob03z3MHqn0/2fvfXTbyLG9wVfhCgN08l1J", + "tpN0T3cGg4HbSbpzO+l42sk07rQCma6iJF6XyOpilW11I8CHfYVdYF9i32Lf5D7JgueQLFYVS1LJku3E", + "BgbTsaqKfw8PDw/P+f1sFMBmRo77fKVt4xbTeGuxPuuCzcPNiG4cMGiUMdwAiXEGredqJFwLA7SCPHfM", + "gaVW8NjKQIvaNxTL4UbzVMjLU0cJB2F9GDPphmJLMUOdB6IQOU/WHYnKKFgu1IRiFhUV5LQ6tafN4RsJ", + "nrso0nL8sBWqSFmmHA3OhNO8IwD2GnamLrUWpFACSdm+D+0d67YQvKBouJR1lZkmNCm1y36bNixZswAw", + "eBj/d6EADHHDpVsrZc27kG2MzQ8ZFUDdB01wCJobHTI2iFExK2FaaYUaPtyNbmwAhvcybxMzsrNKpkEw", + "XvFEN6LrzR5+Va40lC2Y5EC8KW6SgTiKN3zO80YJJXMTj+wBShlF5/6GCDKXJmzCuiul+CnImL69sF9X", + "Yst+63GRFvkYkeh6/Z4scu/vj2uGc9QYahpRG6vn4rjIog0oGu1nIFup5zpXlcUX0DEXlCf0jCc8X4xT", + "mfBNVAEqNq+kYyyomhYqxdjyLbXngyITvwOMjuScEdNGk8IVSaGKeeqQGH0cl1OvjtPhTpwoRzWllrqR", + "L5VqyjLAWBzr/WgMW92mWtwO3sFwvxeyBY0RkbLMLh9APnRwazYTI9hWQ5ByGmgvUEHsD7/ex1AJf9/Q", + "T/5ysL8/3N9HphMEF7YJn/rp1/ohUMYZkCtrxUxB3o0ds2/pfqvmENnv6/aPxOkEcbNMvtffAVHLJdnU", + "5/5guD8M8Byb6V9LEV5nX/8B9c1nuaWbgfhidvTSPt6x18nfalBZeeZ2Q0JLezTHU4FeWrpYPKRcpTxj", + "qsyVXa/VJjf1xfILzNg6BOpptZUumCY00SrZBcvwKRdTc2pwNsMaktW0NcCT6a/uDXedVwYP0WSENjr/", + "yqIhYiJzdTPsGqFrWWGWR+q+jtk8lTmsk3O2CBpIJfOgVRWOHqg8/WWsUBavBaC8dWnIZK4IFeTH9++P", + "ybP974jNqrC6kcgJ2EHU5InFBQZAmo47hDN6zup+BEUUnTCDDZsthp+1h1RmPF9UsgoPGhC5LzJ6OQA8", + "SPtBVUjIG3nJMpu/CVl5Mz6dscy9P/RTxbnID77Bxmr9pWvc34e2mj9DkLapb/R10dgBuzEQeIFOCRMh", + "RMyyK6MK8eZDkUfVBWlBfhHI8vFwU79lo6ndPJh29eBsaDkBBG3jpDPsWZY/6dT1Dvug+oEsZMfENBJ2", + "rWl5Z0IBTL7MMhblJGMXTIBPMZJTwRF2HxnyK44qLwq4dvaoMAHi7VKf8AnE6n+FYwuOK925RJ7BpugS", + "i/WHYEshT1zLga+mQjc+AW7K/ReeLlo9C0IqXfsskG6T0B8JZAbRs4wptTj3yQImn8VY7e1wDtavEW3i", + "sEtuH25GOYczZvedtZjn1mjJpyX3AYGZXHKB75uO2zppveI0h0x8TCOrOBObpNn93tVgKgctuV6uKihr", + "Qzu/Usbq7C8zFh19aVh6+zbqQtjtZYh1cJLXubeoaB3M308UKsPXRyJvKa9PVBHNCFVk1PtwQl7IJKGZ", + "TXN6WWQSE6a6RvQv5mcyCfcKn63sV7gjxuVvSsBuhbryl1EPJNt1CTv0P//n/2se6K5BxzZwv7WxxFkZ", + "xPCYTaXPBtesGdNiSPc7ZdnBB8vjWUyx5TRhs4bkg08bj1wQFlU8EObiKrsBF02gjaY3/eWNvWOhMGtQ", + "ZAdPKJ+xBT+n2WLM5iZdPRi0oF8h8EqrbFbDGOCDl1Bm6HIa7rJpjpR7m0QY25UK8WiHXkFNSbVE1rkk", + "tsaSeABaUvoNzPK3jKEXAAlVgI6pXIXDV5Vq29MF25WViULaMOnHUk6tUFWfx5q65lqC6VxfiMzYAQnW", + "UjvPUlSU1OM2zqzJPA7rEYPZAEZGn/5RvLgaiRKux90kVy9V/JJVTnMe+RKHfF1Z2dY7Q7VvXdqdl7CZ", + "BOTdUKEsMiedKcsGBdLCqbxGCKf3GzLqIeicsS8omfArFle/6xOZjcSolyTzUU8v+UTKc1KkWChEUejB", + "evPmLf4S05zq6SznFEVhmskiHZwt4GRrFlotTgYr3EwpGKHcRCWgkKx0j0+nGZt2TOyAog+9L1ty/so3", + "DGW/BGId62CAERzemajXOROKS7HkVvbPwGeVpv5M5ywm/3ny7udjms8Iu0oBZ1YKcOqyq1w3yThXZJHq", + "rcW4uZzE4TajxQ369BNbKHeXY0AATCqt4ipHmhhAAxF4cQFP9ak8U5HMWG0c3PWr68pfhjauvSGC0JRx", + "e4gaNtXOrGEPtTxu3uRXMUXSTM7TvLdSl0DparxV2CS4A1DcIjDgEjZHHdt+rBc0yaRI4Fb8nKdEJrF7", + "9HoyEjWdTZOEzLjKZQbkOPgm3JZbVtXhzWx+d2MjAKke2wSKZnsCS6S+QvAa060LLqZM6d0VhvYrBUvE", + "ad2Fg49y75nvZUZUMe8TejHtkzkXfejgXB9CSglVhhTcELdlhI6Ef+o1QQ0pzcwtr33XuUdNhGWEhLRl", + "yf1q46t3s/ZojcB/8O1IVLSmHQc3lBBwPRXSkPCVy+ovQxdJscFBGiMp/c2gsvzbN6jjhIprwPq4z1dv", + "VPqtjgA2q6w5C7ESyBJIE1qB9TmEV+/IXqUXxVi3cJx2u8RYfo2mh+SclXEWCRUEKqhHlZpxs/ev1WgR", + "e7VSyVTQ35flbWTU06uxpT8Lb0fmAsijX4QLZL/Fdh2bJpYwyzDdehWOBMILDSyqiwUgQvSHCWdJ7Nav", + "IcrE5QtARI3PRuKyQqlZiITPeYUPrt4o4wsrb6+s1U+v3EdBnsa7GyaHi7cpuMv1yuYqZW2XXURjJrqk", + "dax3+W9dd6Z4swv57Bj2npmrhqr5vvrx7hPTfECzemPupkPuluG9UFtcB9wLdGEY2su+ajlcvxhoL1jy", + "LbBe5d6gDDyrYYpEzOOMzlNzlq+A75JDs0GpS55Hs5GQUVRkypyKHGgoUCfV8kOH5DAnCaNwhmKmGKA4", + "Ru3VFVBMq51ju7nNuXiN33r6+7jsY68JR5lmcpxB+Mh4XcBpC4+VZnKAnwJqKn7tIRbVlvRx+bqtKYhh", + "3GomelfedT3qZrldszevVDvfgGulVrq/mtods5uWTdqHN69fNDrJ4yXN9nlKrmHwNoq5a4ZvA9y6YQB3", + "1T7LrTZnBlXh/Mghwi4f4N4JNhmpG1dtltI/l1lJOZ9vQlda4amJef4ei2mNXNTLy3Sp5LEnh46ZyUy7", + "PjqmMc1Z31BcMoBrNXlWJqasZMfXFm3CRTWx0LSkJs3W5vJNRnyzXcjN2tpMtO3CXAN8cGxgHgK7gb2g", + "0So7TcG7hKGcJspCdVXMplmHaWqK9iEfD00Vfg3ENa6ppe/F/cndPUcYN4UvQC3CHPP8e6TF7irFZdyo", + "5dU+W3hJbbuDHM4Yjd+JZIGbvZ43frGVPL0jk9xRntMxJhmYQeCkgSHSyYLoKl1q/zylUa7qiOv7w/39", + "XqC1hlBwmw0GIxwCQM+0YNnY97MiB8+qkDlZsJxcZvpw7ejFExYDUbg2FzM2EsHH5pKOTAq4ZjuT8pzZ", + "0HC/v1+3dRezkuMddte0ybgBTbOpu2u30umi5KsNP2hpeVu6hhG3smPljPqAM5WV0Wtdexghe+fx4cu2", + "3hJCPDTgfUaFokC0dN3hOioyBbz8uxwwr72bDhu2c7Mxq8KNdrwUlYLlNFu4xCqhj5Q267Fdy5dZRGst", + "8arHZn0/Td2Ew1r7K5KqaqGg9f0sY8yyAfz2+uTdsycHf21nHNBPB7Y6n3JgJKrhoI5rwC+/8kob3QCQ", + "Q7XxDbyoGgpPK2bC0wDhwNMWwgHTkruvgzwH2y0ooHIdBljwoGRD2UfhSrrR5ZRO2fqLXY9ko41QxPLG", + "HZtaahnOPAvBzH345bXd6+ENAhV4GSMpzWe9YFr6iuL0C2uXJtjV8tL0C22liSIBS806fgKReuyCy0It", + "rcG+tHEtiv8RUCnmeMhiKJfAS94qPth3JaEHszHj5gsYIa8r7TJQiuI/C5YtrDh0WMMvWM6yORdMmXss", + "aLoNWyzJKU0aFmcXIbbxklQzMB7VSdVl6yXTL+nDnI9F6wdH0sz19GTUBMMEJgEBGJdXW5nplVUbUO01", + "6g4LAETEu1s25DL3IkBSBhaInzLg/C/BlHwTafkZ6Gps6G3pahvNvpnj1MWz35jn1EXjNNmPfnl19PTp", + "0+9KQySXMlFDzvIJ2CLa5tjLJpF+6TFBxaUnNKY5G+gjj72o4WIkPrw/WpsXzOlAV5LnSjOtIrrhg/d8", + "HgTTsr16xVkSY3YtzIRYdApQ6q+YvBq21O9bCYL6F8Sf6L5E+rjPfi9oosiUXzBBfnl1NIDel6NdZmBz", + "QWCUP/V703yLTeGqilAAsXEdm8N22B6Z4SDZLbVb25ItD1XClNp0nJJtj1PZmOsMUoBjrg33Rvrd1ssX", + "9MAjW89jE50BAVNDcpgkpFxD6AqSxkP7N5sCSdgVhZUgBSsBcAzmoZynNOOqeg9iR4bA8idm/Vdz4Uyq", + "/hAfurH0XhrwuT4QoQWtjza9Kc9nxRlw78mUCdiSuSz/vUdTvnfxdM/CAOiBC+WeNFRt4CW89V7zwps6", + "Ly+clsVI2PxPB/jmq979g+8oe7Y/GTx78vW3g79ODr4efPfsu4PBt8+eTJ49oX+Nv6HRamewJW+0NdnG", + "k5/CGK0mfLwzLWhEUwOgQ0yOEvhHXTAwkcAqCziY1ApNFvAC4zXNttAv1kW7YyaCyEIb6EUxDHkrY5aw", + "22sf1L6ifbfPlNfBl4tGUMhn/5Dd8pDdci+zW/o9vMe+LR0DvhlsQpuaaR5a+i6RuNTflY605+eYKdXT", + "CT6JX5gyHHYdNiD8CMOT7JqACfldF9l+aG3B4dSPSSYv178jb/RCXoYOt1tLwjjxeat1JzmKLpeYH7El", + "tNiXJbt0o5LQqXutCTZ0c13Mi0xe2siNrONUd9Mzq0Ba52kBqGG6QnP18QgV9v/3/xCnNh4Pyc9FkiBu", + "jY29M6A07vJ4JBxADBjikZyfWT+xnJSmEwjhSg/jzUW2en03OWd5MMn5BfxO5kzB+CA8ojduejwAsZ9d", + "pQnlAtxrs0VZRwTpRHrMzoC4UMnkwsDh7yTpDInQbEFe7ozet01Gh1bqFywbklOTwGxgfGyS85jHp3hE", + "0to1u2BxbSIby2N3dPZwqjsronOWL+/M7ijpOzUB1tG2lmo1Fb3MYfKI8hsqDBvQR5VRCc8sie4rsrZE", + "3dXsxK7bmQuBloQaG6JhOvpwsPULnRWwuMtHFtQ0nrlPYK28penrnM2bS8Z6FHQz0zRZWMeFt4yMJDjX", + "+Jxe+S2BS46Kwep9a/sRGOaNThkB3u0XlQZCR+w4W2c/V/5IVxu7vg/XyMXd9c3bo/+t+OQdaMNmC8bC", + "NtyYR/6VzM54HDPxMss6wXJRxfCTT/0/G5gSdiMtvUCuHp+DvvrKuRTT53lGI/b84MnTZ19/89dvv9uH", + "O6ec5nix6V5+tv+0DNpsrcdmKpeP7eUC/BeKZQpcbM/2nwZdj5/6vR9YXokfPKYZnSvPz98VsJtIk/Oj", + "9fgUCYVLnC8TSrWNwEJUet61xMsrusShujTMscmytGEbulQ/KYmYhuQdgJRLA7/pwR6nMssnMuHSeHpH", + "Qh+LT9kVV7n6O0zEqfch5IIU2q6BWw8Wl0MevI38QQq249Whq9jSwjjYDy8MW0WXNXGw37omtLEjdFON", + "xjqMIot01eE8BB8RrNSm82Bkf6tJMKNqTF1lbfTwHlpPGcs6o4rgpy4cxNQyEiNxqg8kpwhNhUkvYBGj", + "OwqdCkg6Y+IyIZbJnoEwiVx/a+y1kah8ATswsoHoxW4Fjpwa6XR4xp4jrBBl8YimhjYg5ItCZyAqNGM0", + "mrEYwlsf1SiIHzscdxdFOhLsakYLleMJpOoRKa2CH91YBfn0M0ZVlySUFnn5BYtZ4v3Cijy8ZzutsWR4", + "DoWehaeVHMsU/Y4m6/a0lB5AVzfDv2wgbBNr26knhh+DOmNZf7sa0TAE1JcNOIBDkfwsMda1j7VVC1Ox", + "wFbLLOmGTXzo3iMqz4pI142U/ewqXzZkh2V1gaHphrq5dCBbTvxvaTTjgpXAi0yrYgda2dbsI8MMZg76", + "TfXyYxXOMXD5ABUtq+OtKXtVeoMhxbFN6Sxi4dDPxsCY1eW4gWImOItLtkQosUIzJs6FvBSOTxV00dio", + "II+Iy9Nd3q9C5uOJLAT4WeUYddO4fPNjwCNSdhNOc+VGvP4Cgg+NEGhFDDG+Kc1yDpC1qoBuToqETF1l", + "6IVbciT5ItZUOaS7WUpWJbW4qK0uN1fLnGXlVUTmgtkoYD3HRcRiPMSuXGVHzYJDzrbPbqHXpqt5s+8m", + "xxhTDXmeUJ5Y4p3Gkna+v3KdrrEiN8sNxDWZS8K0zQ50YRWlYzqQAKTVxImKCh2LShnbSP5NB6zQqCCh", + "snf+uW5FrywPk1+P57QwUZNGPapK1ndwLJ3ZW0Zc1o5SPsUQInbTaEasJ9pDZ/11pi1EEGV8x86KmSa9", + "BEwdql5JNGPReZO5wrOxSvZXv5Vqdba5m+M11kdjOrsJ5puaxHk6RFXktZTTpkyes0XgePJSDyim8xqI", + "l9JoI6fnbHEKKWqG+NjDP7Ugo/jScCRe+20yeFR4v1BOasUmhNNKxkzORXkDBZvbSJyCPlOnBDxllcvC", + "ptakVxbKwNAqNJENnALWA4EAdG19aibV1uYexnL9eX/lsZx1mHZ34LAax3M9tM47eT0pgXxokjhWtFFp", + "/tjBltmUCv6HoYCB2ciLTLB4SI4hisjBv0ALAHgikvM5MCmPBLgv9B5YmTkItUcOmxkjiaQuO/CMRudM", + "OOpota6MvunQ/WuLifV2/qSbsjUx2MgVbT9zzCO1nXPdq3fj0vDUJd7zqj5EFOLqTyGcpa58172ib3ZY", + "bw2f2m2RF+izrjvDcc2H0nzAMkYbRxEmAIcOLqEuZzwBtgg4eRpeHC+vf5P2Wz9Za/NfYjvbvflrXxO7", + "DMOP/TVSm4i5A0wlFzmZU0v8Ux4eynXIUWomRZLAjSn+egkXv+wqYobEnWUDxWPjwlHL7cf2ywdmB6T1", + "FiIsIhs55xqSXPXTBcX4ugZaI7ui5VLfbDJw60VzfQSt7NbeVrjOacEz8Ta+cWzzi34KwI57ala5fBye", + "WQ2LXlETxpianTRjFS8h/Ji57CsuyKn1felHp+AUZBdg+ePvI4GGxvL9qeGOxAtMckmVw7hbMqJuDw6I", + "ppmo8InQbr7+LIZPhL6ZA7tmacNqMwvcrxnENTPe9Ak7Y0vrZMhYUu0WihkyY9k6Hi+9ChIO4XG8bo6Z", + "1ll/JDCHlQ5pmSQ0Vei1s/CCdnFBs/soDjhx3vSWx2Q9UCwmM4ZnufZtuFW/NNdLQMNuOYLvvYvas3fV", + "QBbNIqBinlHRBNv/SvnrAS5GExahsI8EzDyO3DJ5/IDdILQJum3F0fNVeFqgMgIhRVtH/2vmNb0+eUcg", + "ZNG+U2Y4xTJSw5hPOdy22EBVpX8v5jaicU+/oN/c+25/f//g2bffDg6e7rn74b1szJUc6xrGlmFwjPkV", + "w1k+f2xha6sx+ccH/+VnPple9CrZ1MeP/vF8NIr/A/4z1P96/I//evyPwK9vg7/+Gvz1Bfz6PvDkxw5l", + "nzz+x+N//MU/UdZHOeTveW1Ad19eMMCiuJPAChCOwcW00thbQFV4LS5owuNjmw16NJM8YhA987xToloE", + "Hyp/AOqAeI1163cVwqx/L5h53YTVQ2ZP9R7TRO62FFZRieYSpvwW8l/s8GDa0FpFFUnADcdx6MpMWkX0", + "i8pzusF/P65RA+qEamPPZLxY6Vj0+qBgOUBb+2461pnzFyzVx0+RbzDtsf22PvP1CND7N/luaMZQF8zF", + "mqOyTcFAeXDy4U3YOrJhUmtsekQn2bjG/DlST+/jb0OofqGJBphmd2c8x5R3Ksi3XhrITmd+Tq/GCY4Y", + "AljjuoB/3446sOO51pQjsuKNT7kFdNx4yjFEwKK73txsc+HNNhdjbcrlBpB/nMhLlkVUMfN3kaaVv5FJ", + "z77tBIWLWxIUMwvrCMpJTkVMs/jmZGQHan0p6Dd2+BeY8C2O9jqDq9aRRf9MKAVbB8e8bQ4/9bt9WNUS", + "nb+ubCtdv/aM1K6fVm0dCHKr+qxXmyUVqdhEYTjJ6Pe4GtuquBqfUcW+eWb+be7I4A99OB0bzAquxlYZ", + "wh/apLD/AtQd+LcRLPi3423lalwU3NQ7+T0WtgUQ6YEXxCV5ix4ZcP+Oy5xMeB8yV3vWx6PGGZuyK/0I", + "u24qtdBfY8HyS5mdj/3byfEfUrBxwlXe9nbE42x8lsjovP6GzcbW9XpHwE2sq9dI1XvnAWhMO28n1v3N", + "m7dHUuVvZcySrresb94S/C4c3t6g87eOL+c4ilnSJ2w4HfbJqDdN88GzUU//M0poEbPB08HXAyWFYDmS", + "5DbRuIIZxD97mcO1On44fm/rOII6yNPh1+SkvY7W7NJVY3mMiXZdcWrluZekB056AQm9ph8xE3JuhDCF", + "aIFzJgLeehrN2FgvkHHKsjG8tRVMU10u0eVCG1nZBvLow8kLJLfHyi8znrNd1A4FL6mei7TIt1vxa13k", + "kiplkW+9zndQ5pJK0drQCnyr9f5iiyVyeQvqK6M27IFRWbJk3l2wLOMxQ8DyjosGp0cvFoTMgESMlGUD", + "vVBVSiMrLtLUMiQfECUlRZ4F2HD6uMZGAoj4StbsiV6C9ktCEy39C4J5CaSaNFsrilARlwCbfcJziwBv", + "UtrjRvEuIBrKr3xiktm3kVKyLu8zRgh+6vfYZMKA8mR7xH2/4u0UV2XnLfOUq61W95ayQgM1s6uUZ0xB", + "fTB149AOdkSFFEAEiNNbXrsENycsKLxF1YITsTz9arCk1NtL1up9aCMK3ORUNhtEAkXOEpDiQFCBebJ3", + "wUQsq/v46r3TleuNcdm3SoZrTd6WKA7du84AQaLEyEDFkLFIZnG/xKGwYRH4jtN95tbcIgsbhQGXm97P", + "NwYodGQRgipo4Q30mt0qCPKoTM6hSO8x6n04eTHqPQ62Zqe6BKczoEiWNmTrigWbYbUKJL1BprS9kcfn", + "cOFth255W7eQYGy2vKrSalQ0d+eAzoqmLffdaocmt8DNqbVg7aWa61S91YKhCCTzqKEZm0QDztnUsW4e", + "sRP8NiiADgAWJCzSJyG9zIJt2HJgwBsPq2eZQgodqep7Q9vGYIatoUXasX5W7R0nbiJajqtKL9uM2YOY", + "t2tURre8HRAF1e1HGL1g8H1dkLofu4/L8drk5F0aqvZgLFMmKMeTMRX5LJMpjzY+dTfLf5cycfgayz9c", + "Wn63E7eDWWsL9PLQwL55WgcD83Hn6eCP/cF3gD5/8OlR+edgOP74v7yn/2GCFpbDt2DDiMplxlw0IuAE", + "CYtt5XMQF5a2FGO04AjjXsSAqgw5sxjNohk8jzKplCtskeqdpkEuLicEby/IweCbp96lCSa7mpBzRGqB", + "eKURZCrjRJ1LIViU4x9zpmbmZz1zEJU26o1HveFIVDnImbjoPe/lTJlYsQrExtcexIaZvdC8cpUD55na", + "bqK+HkoYvJJqrP0wtUlWfn9NaIdKLv1aAIOBHPxyKXb+sMw636SXn1qm7Ag4hnY0Z0hgFJizsi87QlTA", + "isnZwo/nPHHsFzbfntCMPdePBuTUbEen8IehC4V/T7igCf7TwHee6k/qSQh+mS7LAKKQU3R1uK+HS6ZD", + "qvx7qnY2IXorPNPlh0B/aD7ultG44tBhJ8NVCtgSXOvQmr+idThKYqBdjQgmUwGllboBT00VcwOrbSB+", + "7Bjpo6z1nGGFXddjk7fpBEtYv2qzLlfNvcdxtFsJyL2Kdskut2x0/DbcFgxMvQ3LsGC02sPPRqIyfqQj", + "EkywEB82ZQOx9CTnvS6la8d11cvEE+eG70xVu/JDmJTxZjaEHc4Ogotj1z4KGL39skRdsXgIeN/6wtyu", + "dk0FdWH7Hp6LDUl3iT5hKqR2cFab5xAus0jyzqSmoX63pYUtS7NrRT/1B3lnktaa5G1ppdNMTnjCxp+H", + "pZwmVIw3rTXN+JxmizGbG7ioziUgRIeX0TI2GS0btqlt7UGI+o5kgpsweMKgkvbssnFXP+daexHWClp4", + "xnzkSqcWXr8YdoVx7LAXlvXbesx4bOR526DLAHwKiBf6Z0gAs00Y9jZwRm7Ud4PgjgaizG6199gAbAuu", + "pl13HmsZGqpytvOOY1+R+baz5bNRF1dYOA5xdBcKxuZ6BRPkN1K7ENy32Q614U7TNnAmOmxnqhlL3+5d", + "5Vqic7awtZdUJ05gd7sjwGmopvuVKnbc24oysl0HZQx1ozpCqIcxokKPwTG7uxaZ2gwGNbqBNzrCd3Wp", + "eXO/8uju39bsaBVUL3bUTmBbV0hjhYWXDadD8g+8C/jNPvv4G/v9498/nLyoR6nsokEYkfL6Ra0ttlps", + "C0RsNkNddtceiJAJtUg/+PhbJEVOuVDQst5Gd7zdWuUiPaptsj/jKOHV2o7trNLAqjYFf8SGmBvJ1oUG", + "Was7WmEYLN+6P299PExwvueV3Jl0llVhAFfr+B4ndFduR31I3clt1hdyMXVSnLmR3NEUKL+KlUfcjjbl", + "Rh+B52LzLzeZeic325/Gt6z7dB0aIgXIIquwbuHte8wmQB49k5ckl4g/A/fijhHEc1l4N9z2MdaiiloA", + "ClDVPmuhqq218DXBeKUPBmmySh5jwrF6fxnasBgzLn8Zwj8+9XvQwLH5Oc3kPIWsmxhYG3/45ut///Xr", + "rw9f/Xr4048vD578/F/7R//87tWPhgLreQ/iGtUYMNhtoIUJoVLkvfnVDxRa1jVAbi9TjKCVUJLZi33k", + "VX8E11XKIAKH3pfhiDOvbDiV6qktVMm4Ytg/PvUfCB4/f4LHrZAt/UznLCb/efLu52Oazwi70iNiiJck", + "YVe5bhIG+meySPVeD7LuARuhwwXuEBpBOIaTFQJupFBwbyAgXDadUYGpGAiwKGKWqUhmrDYOnu5pKICG", + "pvQ1QujiwviGzMqwaKMGQspbPFW4GadaVvAposIcb5VJCmIKFRcGORGVupoBMpttv1HU5INikwJIi9U5", + "T4lMnNuZvJ6MRI23kiYJmXGVywwC+407i2bMlhsPPyca0TtCqXnXOSObW1V9yAK6oK4KDI2XVQDVS46v", + "FOgCR7G5gHF+779X0oCpYt4n9GLaJ3MuMDBvTq/8pajQhMEcYEAts5hQlTDClGbKosbiu1DtK5kZHTQG", + "GEi/5H618dgoq7io4ZEekleASV2IfCQq26sdBzeUuqF8KtC/7usPZwusEJ+N+Tz7FaOiogY/ttmTh1Uz", + "ZGNbooz/NcagHiqXYT62f9KLqYF/QLQQvcAhTjIUJQwNvLvJy2iP30rOMlTt8cKpjU5xVaI4S2zXBhS7", + "lplx0zx22FhYnEsoIEcCrA0g81fk0ajHfsdAXi5GvcceIz5ufC4Xv40grzodn5ZO0A8ZFUVCMx5Ssu/B", + "oHIvVHgawdAC1QO8/BYWzzTRbuDaarGwcUBhOqe5vxqP3x+87fX1f/SR5/jgBfz/2/b1dg00/ENfgnxA", + "Xc94Q6tIn6Ge2jPU/nP4nz4/Tf3BMq3VgwF4Cr3nvQ/vj5D30SvhiVfCp2XUi+ufsCorq83t1RRPs3J2", + "yiJqLipKHiWuHBcwZmJ8qg1j9577ItvSJP4HC5CKwpDgAcFroMhlC2H6SLg+1BhI8UQhcp4xn0cZyh6f", + "LcZVbbScONZvkolLImeLilz+1qt4Fz52gASvK39PXD3GAyO5zYY6ClbdOt88hWHV5RCqjJvGQd6/Pvz5", + "ELXCv/ULLwzN+UgAKOfzvb3Ly8shp4IOZTbd0yUNdEnqMaJBl0VzhYkXuSSxnv45F3jAAJnDTPAwf6xq", + "48D/8P4I3oPyXba3amEK3g3P7bJFksvhKpW9EdD024rqs1iunuZD2+K3+k5acYsud1hZXxjcOg3yIjuT", + "PQ9BLC08BuM2DduuO82RoPe8d/Bk+PTZ19/AOG9a2qf1wwhxihCsHGQKCd+1UvCJ6Qibp/kCuR2QWMAw", + "D6wbY+hN8I7p4DfT2re3FtYKnawO35Yo42smp79cPptVspml/MB+fqfZz80sb4f93KsAuV0bqw6r68Rs", + "biGWEVp5g82Ki6nxhE5kkshLC/lwlMgCAZuVg3RoukNLjV5ZcBIPjvNUGz0/siSRfXIpsyT+P6Bb4P+o", + "GE5uRcLK/jo62J/QmA0Oou/Y4Fn8TTT49slfvx5EXz+Jnn7z16cH8dOozIJ+bqOFBsY/opt7wTKFvTwY", + "7ve8+EanRAbgUsEoxIoGqN3mVK+UWne0dVnzSs9zSheJpPGQ2BuCPuETYrx5hOee++k/T979TKSJnWxC", + "wDWkQjcKiPhEHvZ/H+FD9OWYleHPOOy9KKXknT41l0tl1DOcrIDo/t9KilGPcDUSVIuPtdx/fP/+2D+B", + "1r/Rwlw6xRpPW/voaUqaU1x4S7PWwY6F18xdp+4ZjWcs0w+BTMNhxxcZb7jlVrZjaaq5Ki9Fqm7ANUV8", + "hYdZrc7aR/gW4GTUW+/ljMPdrpHBGU1TJuo+ytp68sdn4MMkrmqdvw79YxAuycAxCF8OCWRFBZlelPdN", + "hUm+LLuAVaxqYBn0XLspgL/OrPgYxjLLlwhVGjPGDm3lmaF4zEbikcMZicvYpMfVplYV0oombxY1vYq/", + "wiGyyMjEyrBSNMhbrYdwyegz4i+vjsjTp0+/q/ZiiQZduYTadRTlQhGjicwF6pndoazuwjHPGJAjWy+M", + "zDiyIInpSJS9qo28nA/NX0Ml5wxK2sQx7/A4fJE3X5Zi9rFCiYRb70tTZevGXuVO6Izw5G405tXNHkAO", + "8GGFKKq6uft0R6tsbnvn6d69kV18jFceG2zjleyTZV96aRqB157ga5+uzxRlM9J+cRp2BVcUr+gj5af0", + "wPT6NNr+7HTwBDrLMtwUs8oSpxO9bJprZfcsuwAHisD2VB54znPlU7vBIcSGlm+edbNBq7A2u1vExkdn", + "Dxc8RpKbNvo64xs0r1kWO7PXVG9auzlA6orlX64SR2G3NLXSakp/kv2h/egTpJpmdlN19RZ103xQRHPo", + "dkB9XRZwfcrrAGoYclYTB5EIUHPrEjcfISHz+mTRuspZMaeC3BXC6J9l/koWIi6FYL2kdaqYleQ/G2wu", + "uclCLS2Bn6U+/xYiRs2lcirqGPjnUkyf5xmN2PODJ0+fff3NX7/9br8a4+lefrb/7JMbjno9r2w91uwp", + "H1s2LfivgT4BQq1n+89C/uqPeoSM06GJRGUiqlyEiNJ2P83OeJ7RbKFPmhEHe9vESFQ5s0ajwT9+2x98", + "9/E/Ho1GQ/xXC+bTO49vz9Alv6dXWvo6U9d6JQ0SdsESYo4NJKdXKP3uBGIAaLTSQUO9/qqCmzn0cZa4", + "lCb/2pruFr1WH2F94kDDZasHSG8qRS7nNOcR0OyX9rLPNMjVEnTa7YZYVqx3G0AZRr0EIIYxYISMc3rV", + "EY3GzOMym+RFfYIMBHEVAsbpJO+B+wRX3YUEqLsbbKWrs8robX6sNG+X9IFeqNYaQIHNcWqb5W5wgMd0", + "yt6y0P2MO4mlJbUs3nF5BBCWuRliqF2I1sS4rao3NdW1YSgdfE1YHrsc38PVQKWMnjOqFoOcZRmdyGw+", + "wBirEk+S/1FVqV6kRreSMBS8WtRmZdXmz30KbbUVtUyIFx3UmBUcUNR83sRwE/+BR9DqSKdm118Rk8SC", + "4Uip3aPNOqk2r97+NYf5OKECEO66BnPZ7+rbmzkD6ZE4M+GcFPKCMKFBGMy7Pqj/TMJWMBLGLYZweBBb", + "U5LKakWRFlk0o4rBwYrbIgPmpOvKWgoCerDqvIetapzuYNpNI5yZCa8+hPR/ESH9k0zOx5CClGrRW3+c", + "KsHTQZE6Zy7KDJYGVIAxvKVr1cidRZEOLwhf+l7p78vythcw3jX8e06vxr8XFOa67VyFE1NuUyA1fr9t", + "LLHpaOxiXWHRkVcys3zHA3tgcAoEsIeBD6tEIDVU0xClOC+SnDc+02qIiRIAsRDArc5iYjvTaNTQYzOD", + "TdNRIl+5j3ohfrmHCPn1I+RXeWneGASsoLthLZ/MMVwY5Ec0p4mcBpwxbSftf9Wr7K1w3KwXR47bWFMF", + "Ba0UuxPf3Rjt0si4lThtXf2dZ9/Sjbyl4cnuNDtZhWHjlgZomXboNkYNhWHAG4AjABxjLA6ZNYDNsgP3", + "qcqzIsqLjMXWH7NtN+pbdKGWLDPQbwOS29136og9m0ZFSrVZjveP8Fr1thGUqtpLM7mX0ZxFNIvVHgTD", + "7Bngpp/gLqutRa8Mv+b67twavc4NunLtOIXEuZEB0jmMEH0PGNVvyWgwC8zJ45C8S1lGcy3h+jg3L/IC", + "XHfsKkoKxS9YH5JPR0IKRqR5F27RTBgLzQk1QEwNqRchWiQ5P4Mseg/5PzaNVPZCLpFTSLA8/PnF2sZB", + "c7xq8efL2D1hWaD3piWzy44Yse9VO2BC1UIZrr+vKtGk2qxZHheryuOKwGxNAkVWja1V8fpLB0ysO2KO", + "psx8sG5PxeqhKxnQ9BiuXfBaY6iLvYlxlNk1V8m7X25okZSXNaidCJZBDBTIOkrMprFdX5cJontMwMtk", + "1NqcpqtV20jUdBt5UG13RLUhaPfKMuEtrwBLj/ygHB+U491Tjm9pSvQ3S7TkLywqMv3yMeSfdFSO7mub", + "voIjIAgV0Qw0JTj0uchZdkGTkDLT723HtQQeogFE+JjqcwkEHMZJVmtqHTZkWWSaPdyYYqEB/Z7t1vrN", + "f33y7ttv9g9emBzhFt+vLdflEvvJw8TLHXZtP4bk4fJ61Hzvf+bKMrHC9eOBmQmvVx+D4lI6rhuL4xC8", + "1oD/YIBkfOQHL4fRhNwuCC19l5X+2F9N7KBPjfVsNTXWx/949I/nY/fH4//1F29wbA8IHuUaGuJEZjks", + "orAmOqUqOiWqmEz4FSh0e9FAqwEOSmY5kVlsML1UxIQ+wQ8RWuNUF+wXY0cGQyD0wOg38BssZjgSb4sk", + "52nCsPDyYE/mdAE+Z6cJOQUYsfmcEsVSmoG3JeEqH46EAwwR0vhbzefNNqjibFCq3kds+px8NZFyeEYz", + "aN9Xj2uUWp7DEl7wxr0c19CgNwD2QDcszJKqv79CR9VZI9p2w39BzHLF8kB6ZCO2GNP8aFL88ccCIdce", + "r22LYNnI9FFCGoSr6GSQIHdnVrB+6cVwVxg2NeWRkGIgiiR5/DeMhMGRaX4xEvTMfKHfDls207ytf1yR", + "Kcx4pte4aB3ChF3xSE4zms54ZHAcWHgwpzlbtzaZWfNCrlfzSCytOlnWz4QptbVOJks7WVbVuYfLqxXt", + "khow2NYUVNm+wH4x8Q9wm4OpLjQnsJ4GFsLQXXOCuhrEzN6opbMMyLPQLh0JcwAzOD/BloS6F24Du6JR", + "TrbehkD8XxsohQwIEi5NnNezBWE8n7HMtFVmxFNEQ3KYJA6ziRv6NbsZ/c1uBfitOWd6qt301aCpDCEU", + "ZCoHpu3GnB1W7FHvlQGfpxLRvlOqd+HelOez4gziIGXKBGYyyPLfezTlexdP9yzMx6eQzkdIze0p/p2o", + "5d0soS9NcMtGgqCSqpyOxDUE1dkT1v+jazZotyhBq4W58d6WJNoD1t0kYgqjpcpwBnOc9PF6AyeoLVOU", + "r3tDDzNDY0hEq2SQ+xZ9466ebpXHfJO2eonmy1t6s3Fi9Ul+iBf7/OPFWqjQ6onJNx17dSuBRSvHYnk0", + "mAuvMi3DlaQ3l0u6UOQA0Skh1ovUg7baIrD+uSz6ylZ40+KMwX2p5CaB2earuQG4pApwQmRyYZBhAiKh", + "D/xjuL4OD6d+TuB5bUDX9Vc2trpfaM6OaBYvC4X6xdXaC+NxJVy0pDzZp/X5h85Y0mF07BngPWQ8NkjG", + "OReFLKoJ6L/V9s7ek/0nXwcwZrwtq3ylCjVTyu4B2KjhYp+sLvZpS7H7S4p92tqUj5tO5nsz2idsOofU", + "0vY5ta8GZvTOhw6GAu/aI+5MSJ4NvPNiN31d0a9MkyfWlUUZcq02ZuHuBlw1Dd1bibpqV0KdUa+sZrKx", + "Kl7JnmqsWd6TCYu0ePhvj/UAjnmb4n39wmncSh0w7HjCg8jkskFnLJFiaoFQ1poeNBWWxGiZhjeboNsX", + "WMlOcjtzEpfbQtAgdt30TV63TTQEomxHf9XoryUvdT3XVWwCYlKmej8c027imLaJ2ejyBNCHYXFL+5Xk", + "Nmcx7rcvpCUWZP12rbIpuEavktI7H5PsN/Z2NgGTWHrnR8q081YHqfRPdBsY83mZ190ckvXYm0LJDqH2", + "wruNFa1/JY8+CH7BMgWhoh/wmvmNfwUCD05klkNErcPZymqYTkuxKf075f3BXz/+tj/47nDw43/+9Pbn", + "48H7fw3+/fHPJ19/8q+VocWBY22ds6ri3l5jE9/A493Rn9DNQQ5zYMERnTt8C1W2es9rNW7fV64rsJ5y", + "E8pjOSu26CmHbtyCnxzq9b3kS/3jRoy37Bj/IGiRz2TG/2C7hgl5LSDHC9ANtDRQ9HltAzDkIAwY4neu", + "M2bIQRtmyAc4eh7GccaU6n6PAF81IiGCdtIRzxcV+IeKQVNqMqAGyToA1R/hB7jrNRaJeYpID1yQ316f", + "vCNPD775ZnDw8ZEdMcBHVxLg0bmSA3huGjIA/JDhLJ8nj0cCGKoGT7zoqDJNBNv9qd/Ttv5BcwRe8Uzl", + "pOZe0iPoF/NGPz4IXuZzwZ40Sz1hkRTxWsU+CRWbzqRg4xJ5oWar6KceLIxL+Yfff7YIBs1SpcppMg4n", + "4hzDQ5d448rEn9vybbRIBwo70T8TmaHqMkZDeXunv1lDudqVYKwowzH+q8zOJ0lneGvztYGtUYKmaibd", + "iejSFFrlXwTft4PXkBZpVbE853Au1zsNBHkzKriYTorEBonTRB8cFgPjU7JE0s9HwiGEkDM2oxdcFhgr", + "mdKFPoi60ofkSCYJi/CAmfCpgMcA5EGvSCoTHi1GQlc/pfmMZRj+uKfHfMITNrjUe0YkRcT09gjhmBmD", + "bbZkDWuYcrZxHXb2JXPkwFpOTKcCyqAEdHHjaiF/7KiF8V+UK1MbbYt5J/y8Sqttc4+xlCWNPa5N0tKm", + "1l/uLuPN8buO0PPG0IGAoy+DwVqoDUijfmINp1yiQVMugpHwVkHKsoEdES2QU6Anu2BjC+/Elc2kJ1QR", + "jgiJVUGGEBeQZAs1hYBYAQdLkcsxjS/sLu+wbPHI3giig9CaXNZgoyCJskJ7Tye5oTmJMzrJDd89mVFF", + "UqqqfBlezJz/chVa93j/RRBa1xRsfRO2/lySM0bOWQr3QVCsYaKHV+dUaHM5YxecXap6VPALHxvYBB9v", + "oHWPaZYvjFXRGTDskESlDpMTuwkyVcI16OKbM2rEZEw9I6jDurZWUHMBm16V23H9VFqv+eNaA/SeXuFp", + "07D5dFii5jPEorSBxNq4VcS2qxo3Lew1B4yh3gqKLJUm4oeOhINSM8ZSAO6sE3xX6cSwB2rEeW4x7n7W", + "MpdoixgaxyvfoMmnZvJS2COSQynldiRiGRVz8KSuFs+a6j6a0WzKDv11vaHqDGp66uDpnMHgwOY8SZ+z", + "fCZjQJyD9oxERdOEJsR+O8Zvwy7NZhU1jeFjumPV40rNAUqxRqZwvSUfO07BCROx2XdudegVE7G1ttjN", + "DLmucmx+D7K3xQUbw6ZS2xaeLt8XcB8qsX/s/sAViQs2JL/yfEaUnLPSiJRJYSg586+UyaU2OP4WJMhs", + "H40e1jYSbNtaO8m2BamUno0EZAgEHfrDORc0R9fDnKapsW+DK2QDe3GZ0ulXhWIja7S5nko868XPSIbe", + "HO5P/Z4U7Jqm8LKufepfx8QOdKpdQI4SqVi8UZraYSU9zZK04XWYpU7TVSjHfWveh4xciDCC45K2XgnN", + "S+Y1/Pqq9oiJwKlq16RVgaaH29w56+1Ef7Vr4qtA89vGtVPjX4rmNXJJ3rNE2gCu84eMivzlVc4yQRMt", + "pAnTkrsZ7ab5ipzJGO02CC+xXAnM1FLxAWB11t4HJi7EER0JABJtilnpuexk2GF3j03osad8sQUnWGp4", + "LgW7bG9007g2LVwy9AYS/4OiU2bxZHjnaOq3qOThjOdy2MBFzWJDsWayahwGP3knPPD+iAoyoxeM/MEy", + "ORJ6t5SZ4xpRfXJWYCKyZR/RH4CDCGM2dPHSKzAwWfjh+JwtWuJFbGWlm8n1JW42/wix55CADywjIbGr", + "I4GA9648KCoQh+w3dr1gk9osnWANhhbe6RAzRD/pnq4AQKuMSruYvOAKDjddLUv7XdXNZ8yHSkBKDZmV", + "ZRETeRDG59g9I7Et3gO2xmRxba092v+f//1/HezvPzYRsyYo1eSiu4CDKobtp36vsPBB16U5+9nBKeIS", + "KATPFWI9A8chY+SMTbScW0sKNg1lSKawU4rk0nDCDs4gVSGBpPhHQuZkktCcTBiwmH6wTIa5cYFSBauJ", + "FCLnCTrN6ByGi6uRYFczWhh6ivZT3yuEYtq2EqbEYDwNyRFw0eA1m/H36nEaR1Ll5g4PYR5HwoQINsXF", + "fdBZF5v+fRA8P9LfNyfRRaunLBvoigi0rOq3Jh8UI6MeWvijnhHwCb/CSNnyuz6R2UiMekkyH/W0uCZS", + "npMixUIBclSPwJs3b/EXS5FBcOrxzMAyZO8dnC38tLQhOWG5LvNUFElyqv8VJYwa3uArrmDoXVP+Bg5B", + "aAPTmldvdIWIZlRMcYwbREX2ltOWsExwjLF55PO+rC85J7XrAqspv1I+oLO1VVzgtj2nAQGKUkVIVnbm", + "6dJbyFnV21VvPshJ7PxIQM0Swly3TjNXWX/tmI9+75x1uDe09tZykFy3BpzhZOPEAIXAntBdN7V9+c54", + "m0ungd3r9ezYaxq9F8oiJ1QXNCQfRMLPmfVU2S8wBh+q47liyQSTqw0AgkMFAEauMxbRQlXFwV0+zSks", + "GBab2zJYADwf3iEIWK3Ex7RmiHWQz1aDrjmr3Y02crbwCH2M7VAJgICvKtXW8d4xspsvc08Y3fEmmKFw", + "SHKZmhsKuO+FWFqtDIRzEemJeUmjGb7gQ6LbvBV0RfRJvkjNbUSTLsoLVM7kfCRq2YHkhQWIfBTNeBI/", + "NhszXPohx08hYpaRU4skOYYXTmFJgBwqE766zGmicipimuHHy+feHvDNFzB+Tc8FDHpHZ0Ww5LUmcMMw", + "cReXXLMc3VLGHdY3i+xq1+MUCCOsWLAdFlRp+gZYNFrMW7uNB0OuvQL7PWMGjTsp7dWI5qZYUJHNkwdX", + "MEhfqXADX5Ufo/jwiHUdNYMPG2wcWufgGQJxcGAoEU2iIoEmwfL0bnvtpLqrXoc/C+weevS7NtFKJgRc", + "QgGB5gLlSasABptWftPkjMiqjuqWdeNZ27WgzMBbNu8mwz/XVSed1rtt0E6UiSt85bhU1E9Xr+SXt2vU", + "A/RunaJhoxTb2u3sC9ssWFZgSNq2a00B4vDcnVzQjCQU/GL6C32+IqpIU3OUxPKocOefkYDZzSUB4iWe", + "D8lLezTCmbBhEqDFqa3zK0VOzUSAJwUjMEwediVeBozwzyJPuDGBG+QetW/4K7KQ2vSq3Qxwl3AaFhZs", + "S+ZS35KlejEgnWxm/7aj5RIAK7Ae80hegJUM9nAZjNQnKqVCODczzRLObLgj3iPkciRAvGnunjARExpl", + "UgEmqZ5onmOv8ZLklcFBtadbDoBiRlzzqh9/nuaLvrm6nDMqFDnVgnxKLnmSgBfFgRyd5vK0EidY6WM7", + "E/F7j20YNWJtmjzdWbmtrViyHnXSeyQGXn6/aQ4OlkS4OuG+6K69jWzm1KoVEth+r8t8G3agNOVyq04S", + "F8Hr6rsTrD9d9SisiRAniRFNkyjgxQ9CRB7eO7rkdq2PkMvGOR5+ePn+b25rkAIA/vTCBfQARQqRMAVe", + "1TThEYd0jquUipjFQ/Iy5pggc8Gp28JYddeBqFaaRzPUKqc8Pu3jXqVKJ4mA3+Fd40Dpg+LH1ywgnfGe", + "2HmGmxNs+Ei4o0lVbKFIu5ktM1HMDa2egwIKhKR/KoQETDy9p7KYxDxjUY6BN+tdbDTO/Z+qYduhTFnY", + "5nn3lXViv1u9pGwVXymELozydZfWSDTXVllxm2p94VvuxvttA9FwVwGAS4DCNvonFBZjbfyVOrbfu/Sj", + "u7urJxtmsCSE99dgqHe54Uc0RcYLmrsBdAg4FpbbdsMFozcvsszY9kuN63YL18mVe0OjP9fzWzdCqKpj", + "sKzrzZ1k06lqCecPGzotLYUrUb1jYHJt6dX1dxNL9wpWu73MqUUt+6H7Zvl4scsET2j6PRsz3xLB/4gW", + "uRyYGOS+idVFa+BxMLx/JB41Iq/6JC4QseIx8NuWYfwu0kkV0UyvuPLbkXDJAX0/1NpOdr+WMoBogYbv", + "LCDKbc6CNYQWqMI3M2Pg05XGyx2wAGI+Z0JxKZZx6gQ+q97E0jmLiUPjZVcpTBqQ00nCrnLdJEwgzGSR", + "6h0YEc5LXx76vGOaU+jTT2yhHBSsQWA2ADgKCNDgBjdJZ1QY4mn9FI72KpIZq42Di7NxXfnL0PpWGpP/", + "OR4u228Kl9BlbybaSwpcba0/8ENvgR+6fbKPrTO5FtORGRNmmetykkBA7Cqv86sEoIEmGWPrvK1f6/em", + "GY0LvXmt8ckP7t0+RB6s8ckH/Vq/dyGTYr5Oq/6FL27H31r2c70I0nIUO7wPPezwfjmIHT6yw/JxuXxB", + "27vpDP0JupwC2U4QNLONgCDApcQQHKNwJ5V6HWgQ1riWB8bFO/knAFgqXT0sxlg23V01xrC8uo1xxljb", + "GG/aT92Kjfq5onuleHbro/uO5Bw8hNhkd7WQ42ESvKA2vgvjnvCmHa/dDa02QlRxlmnjFHVsRAXBEJ2R", + "0FZpMS8SChY5fgleRKbgK3ImC30O5MaNCGj2GOmkDU7CGy4D55zt1wsgj4p0nMsxCsdj9H4bMwruXrXh", + "c8EAB9AeeiDcLTDVnGWqDXkQoBwmxhKzQ4ljSA5zkjCqMA4U2sfLlK2OrgaY5PfmLF5le3FgeywLYidu", + "JqnlBrPhssRhWyG273nnUKtD62nXA1qYySzHXpt+uG3Be0irMRKVucAC3FiTR1r9jPFXmWE4H/z12FnM", + "iuVD8ivcaK0rkb4AYsh6SPpGYoX4lW3b6E4b98XwpbvT5d5YGHnAVYzZHTGRIvKO0FaUmYDQm8pVfKBI", + "CBNyQ7pRJ3CzDnYCwgPX6kSqFYQ31qXWMm/2aiGDoX54c7qNDfZDCtFMEFcXJUXsfGYlpCteg1gmEpSe", + "snOvJ3BGg6SVPt7U2OmRKRMDJmIWk0d4g6NQOz+u9BRa4EDHVpnCMBPdFmw5lgiXYEIlbLgprJj63OBa", + "W638RwLXWmUNgQMD0/6sijf9g42BDadD8sP3AAXMKKSanC1yph7frCVVCu5WLSkw8HdqSRmjtiNxMark", + "hpHhs/l7Mg8Lk9p7wpjlLJv7t4cDb9lDZFWS4NyPhLVDvNShz8yQ8Lavz92KMAfIHZkQzYiojtB1uvku", + "+sn5lNrTPIw7N1sf1u97+4VHcL1GqJdxa3kejxBh85KRaRRw10H9qjdd17vF8G7BOl4sa21xYjjNMV6K", + "ZIzGAzjylCgopz60wylur7AO7CUE3rkCu4pVCgar5HGfKDw6uQslldOFQgSfCusDejbJ6TlbnEIKjL3O", + "tTHjiIoiZA4oGa73plwE8cWRQD9wc3+rwHZ0v6KpYX8E0F1NXoHW0ZcQ7+5PiJrJIonRvNY28oQIxgB2", + "yAVnNUyJ3wvmICMM5W4FJqRJyhN0Jr9hU5oYV3LWAjfbXmZOr8Y8vs6g+XggbVmw+uFXiiTQ1BpMRuHn", + "ZVh8D4C8XwBlH+QmynzGspHATDGTk3jJvsoYHuGBzBFD+GDTlIoRBMhrFNxmFyqW5YbdZBPPN5LaFFDM", + "nb7UsRCBY7sPdiB+eW2+hZ0vPNf+K1U4YuUSN0c9DPEY9bTEjnpzQ/g46lWCebdQ2ucfDrgrZosGcPla", + "/BUtGSUVkVrJAGDWWpragKcXNKcbrrpqISvXn02iGm8A/mZGrFalzeJydzGhozGY19VIMUDWoiTh4pzF", + "ZXJXed9O09RfDS8bbyAmYcZTdt0+nGApmzQcP6031hbYrmntBoKWxGaTXy1jDd1rMGj+bENJg9i0Kr+t", + "MXVawM8+vyC9u6HduoeP+QZHGz4Dnbs4gEa4mDWunBUJk10zaEeijJ7dLECrhgCzIlXVBfw0IRZNi9o0", + "rhdy5RrZdxLernTtqjft3FzxBgpauQBpmo4tpPx11FXIOE/TUkHZA4JzRNUf6vGwuch2oDtLotVcy6nw", + "ahIWztd9PcGTj+G17lc0UL0E60UtVNVf/X31vWXK1w7m9aZ+5XxvnO59W4neEeAhRF2wn80XbeDP5vGS", + "NrrItaWNtQU97DrX2HXSjM9pthizuYFTD+ZH6lcIvNIqYdVkSPjgJZS53axyi1n0OaSVt285xwkV1zhX", + "u88/h7P1JJPzcZpQMU5nVLFtphWfM6dFdAUEKsAQyRIs0fD+nLFIzpki9ILyxGEgWsLdyiWn/r4sb5O1", + "PadX4+XsRPZSRDhMHmBH8luMMDMeJ7BzhiVUDMkrmY2ESQup016ivYTx+vaK24b86g8J+AMan40EXAKb", + "N/ukEBbu2d3d1BvVRrD5ll6R35eRbN6RINCAHVkX2OXLePMV/Dks3s90U9Pz1uIkKhe2MmiQ7mpL7xIZ", + "nacBIsAhOTTaRV3yPJqNhIyiIjPBUiVGIeL0OfMU7yird3xYzCaXfNbKTqg4tpopeMt3XPYxcNeXZnKc", + "Ae7VmAmtCeO1MdPTTA7wUwwQga+9A5pWTBVDwL1ua2q6DMKL0LS+fe25oOFNlp+9/1rndGYifgPiZC0L", + "PedpCjdEEL9vA49V15k1zTpMU1O074E8NFX4NRDXuOY0P2iPLe4JFUEICmU7FGKTHcUAIp6zhdk+lymz", + "f0kee4ikW4K+u5A8RuQ7P9Y/gHyIaUtjGv93ofJuHBsVfFFovO6LARg9LAtE486CYQsJjLnV9v8oL8sm", + "w5eqzKjKMYUioR4wJnYHApKqgH6nuvxTAAgv0hSYop+7oh0RGdZhr5BV31Y2coRP4ELre6Cn7h24eBO5", + "AuwH58T2kr2gwUPyejIS9hPd9gxi0RKW6/qqyPjYjNiGGM3pgqjcRY5BwS3AiZ/gdmsiQyqACcy6AuqN", + "KJFFTIQfvIv8XnrERRn8YjLdkX778Pg1oUkiL9VILGQBPAViqgUNzk6qT34vWLYwIIFQKqajzanQNdhl", + "XMkxKRum3/xJCqEXy1vbmFGxv//kG+JcFceve/3eBcsUdmt/uD88gJSElAma8t7z3tPh/nAfmf1mINQ+", + "Y5k+RsGPU5aHErVVDtFHHp+8Xh4w+6/j3vNewlU+MKXoKjIKBavW1VG+sucRV3Ip/qmHCtIPaupCZrkz", + "7F1OuAkTdESV5MSKM/Cfl2ddiJd7rlfCANK14b/nbIH/0PoN/1WyX5+SR2Y5PoYnJRX2qY3pOqUqOiWq", + "mEz4VQX0jlavCqApMouNlKmICb3QUHpOdT9PR6IsxoJtWGo7CvsTfoPFYHJamkCsjVF1XI8SCJql6n7e", + "0xX3+j1URSs5rWWW29HvqXwBYjiR2TwwG8iVt3o+euF2TSwP33ot0/IHJ311rMVGGRo/r5kxY+m7ko3Q", + "1g8i/WR/H6kOQCEZgyYxMQZ7/63QMlivJUtoyUHJrEmn+qnfe4atClXmWr/3PfVRnp7tH6z+pE7G92z/", + "6eqPXsnsjMcxQ0NUFfM5zRZu4eMka91EtQH4m6ebjjMZF1FOjmhOEznVRsHVoNAHagdRaijXArR7PkxQ", + "eUddVSy4HgeWc97YqN/LeLG1OcV2VBxRn6oGkOlGTaoOtitVIQFC95aF5fz85MdOMUzuxgL0qd/cq/b+", + "hP++jj+hYGmDIWBjykluEDScB2xBeNyUM3zJyVltBwMdBvSfToWZ6nt1OVlXp5m4waayehaw/RED5PMQ", + "AP3Fs9Vf/CzzV7Iw3ASlxDRn7Bp6J2jM/MDyFbIwZfldEIT9m9IvX6ZY9XvPDtboyg/6oFWVwVJCrrPn", + "Fa1QkcCMuVQC0da8JSHc/g4bCKFca4e9sRXgPGAPC8FfCFZcd7l979EsmvEL2LzDduIhvuCtGnPOba4b", + "U9a90t7mXHofjAMnCRUx2JVgpsVZwtWsXTCP8YV1BNOU9SCYX6ZgOknYiWCm6QrXHNxgJwmLiX63zTun", + "i9mKb26nMpWm9829gvPSlJRD/eBjQBj2/qRpak6+7UccURWLlmNOmq6njXSFd1kXlfGgQYWUpvdBDcG8", + "w4yuKU3mOmPP3vAsVzOOtdy8DRdLv4DrVxGqVyLcTLrH5AcgMvc/MYjqFywr6feBpukUXcKnI5FLImiW", + "yUt9OEKqvL4LSusjSyUCilfRn5HaEQtTMstPAdVZC1cmE3Sbm9DJgHJ0A7DDyws3BhvcXribC8jgxDuI", + "pbcVVSjmMQzOw72FvbdYPRWADYTwf27wUUR/Q5n8+Jtkv3/8O0Bc9nFaTv23rMSOefzx7/sHPx2/+P7b", + "n4bDYeUlN50ff5vm7OPfn+w/eWbpPPefw//+fbq9OxQDNnrrtyimHfdso6+rz6Cathe6DuoW7ENIYhU0", + "sdvu1SDN+AXNWfnDUhOyruf3/jT/WuE/f2EcsfW2l2CydcRjoN9H3FfD2WpiJT0c64Qh3aAPnp8kI0ET", + "JZ3vN0l8Go+khAqnIm7Bw2316lve6XUsHTcwD5797RonbbK002Ww7A6g3hBtb7x+UTFqAAywSFzsScmw", + "VyIZlaLZtyKPJDGqT3KZ00T1EZD9cjnkdthAvyOiu3VD3WwBIW3/uhzre2Gw3/CCWHox0a7o9VKYF8iY", + "YNDDTRSiw0g33MvANvDcj6nsE4yB7GtrEdMTfZO+kexowLor3FBqSN5Xf0CUoho9w9/ImuwMLMgvZLgY", + "SlKhjQgYSMm/MBIBAgZkEl61Y3rEusHbodtTDbu4IQowrd3wHdH6mukeeTbbFMMdMV73DNfAktsjfKFF", + "tZmnqqLITPCsYFe5p5swXPW9fYDxtlyVuG1aByE4oSnoK0Uwb9St7CW2a4tOANZ9PCbW1IPpeUA/mCf3", + "0XYAABQT5T2jQBQRlWhLX+itmJHwmnx/pUpBLdSdWa9pmsmlt734Qst6fT/jegGARa6Pnrk+gjIRBxew", + "y2QtlCV/K6HLGphl4CSv1aEMVBQXJL+UJXU1DKlzDMFCfV5FWzNh6QD5VWtOv0qDDXrE5GVafiJdKtLW", + "j3HAaDJG1LANqxmJSj1GozQ1Bw7+g+a4H5rjhGkzu33h3BWlkbE8W7SrjF/0Y1ADmMsTUhz4Du6MVhnY", + "XtMJxLKTCZr3NM/ZPM0dciuNDC0UbLsR3qjVqZa+UkYr4ClBfWU+s/nHBtkY7YNRD3o06pmXmls4PH9Y", + "hvdjGXaXzbuyMK3valBCT7cvUwdg6uFUT2RWoYsvnWm1rRh2OgcmqkeoVgqAI0PCVr0kc7djGctYc5OH", + "lDi308N2PrykHJKDJzIb17LWCtU3OJ9QrPfUEtGiqlDnPE0BXqNkCWxZ74GBfFj992QTXrYsGsJ8gyvf", + "YB7xVWEB5XtlMqkFj3H5kgtlmKIDl+9eRTu8fveaec30wUjGrH7fbjIIH+7X4X59nbGGwZJk0vhCi84i", + "hShPvICRSSIvdR8xjRam/7n58Df96se/o8W6vZvyI9ec274rt/he9+yyvKITmhqvnJ82XbematszktNq", + "tbgsRXzRNmyhFynyj5h7PMwARzQVLawLWWREXgrz4UjYL31wNw98uiXzEb8eOAC6XeZAOsw6qPOWkiEd", + "tpnflpCgV9/4/LMkawJ2I3K/96etTpvzkVQ5GOKrdnypcrBMjOntLYpXMqt1hBsgh8zdEDoYbuEVBIwA", + "MZ8AaGZOTtlkwoDVeDzJ5PwU4/7aDIiy3esYy2WXr2stt+5/Zb/W3f/KL84WZMKpU4ELxLhZvhuOhNkO", + "9ZdAPPrx7x9OXmxxQ5Qq/143b539sH/34spN+7n6ovfR651Eamt7OwpoZfa/rZA3lEnrlmiWO7/p5f5x", + "p5uvldBb3ndtM4Jbrn34Bey2Tux2s9GiB93fSIMnX/vaTg++ppJtwebAWbd2/vUi0R9Owe4UvHLg64dg", + "+8HZAmBd1zsCn7PFx7/PF4P4bMDjbZ6BTWtu/wiMDbl3R+BSOYQUlH360dtjlxwhYfZ3eXasIsff1qnR", + "dDV4XjThAF/ISbHlftYXjJZNSZ/68J+N+P9g/LxX3zrmli36IYJ+JxH0a89+P2x5TFl+d2Z0/1Y0wD0J", + "Le8gKSYqvB5orFh2u8KyKzCajbar2xHWB3CaFnAaGJat7oU22qH11ObrzoF9+YvVoUip1C6aPsXTPVOp", + "7gIHWKM21q+xb5/fpkDtWs8GaMVuV+V2ke0HDbwMHmyzJdFFHe/RNB1YfrguK2ngPvyCllQLPertLKcG", + "AV8QfCXMxPqwmtZZTTRNd7CikB52L5qx6FwW+UAxpbjBgF9xYfObYXY9Mt+SE/z246NZnqfq+d5eLCM1", + "xBqGkZzvGXx/5ap7PBJBukOsQxHaKBzuhmykpZg6loE5y2cyrhJ6ZhhtYfqPfmTTPxOvgQlWo55ieZGO", + "emQuY9Y3bFmmkpJZwWRzj4TNKY1mNJu6jBI7X3w+ZzGnOUsWWKWjJKg3Fq/BR8LRm0+KvMhYhWrHTj8M", + "yyuZkZkEDnM7grZDqk8yhomlnvvYxPE7t/OHX94Yqiw2P2NxzGLv+0Ih+U+UcCbysWJRxnIkMeA5pwn/", + "gxky3+F/w7gtZJGNhKc6VgSvsGyAwjCoi9uXoZZrlgWOlfGKmg4bKb5d5+hhmi5tmyqSPGgSwevm09BH", + "n5dH9QZ1utGZLQpzJxo9lVlOk/X1uW2bVWPH8L1tIqifD4pNikRrBKdqKprPaJuWknJpeU7yGeNZyfaC", + "2lD1tT4V9nGDw5WKmNAo0v/EF2xmxIyrXGaLocEnyAxkx4df3jR4yeuZflxZkvJcEkqUYyrXtZVbx9pq", + "rTrmX75Ss/dx0O07qdrCLVxLwbV/+qDm1lJzbtnhsiBqm9oObK/VGQn2pg/fbmD62Be+UvYVks9oDlge", + "juidxYQqwjhw/k0SmpMJY0QbUX7Gkq2iLbXBaArb7m3FeexUpbTEkZiRWhrM0CmQpBI00gAtHELgJzxw", + "lOzeg7sS5OGJmBfJYcbKQViujN8MogtaxBoKkbBbRAI8wvatGcxZ7fjLq1RvyoCLhQRrGLmXWcL7mDCT", + "yFQTiQuaFFVJyBhNxjmfszGsqdPnxJQOqxQa+ZWWOJoM9FuYFNXGKsXg08o4dOGdNGOCDeh9anJJVgVi", + "pxEv0JSHUNUVoao1Nb9qh+kenVqrYbVB2KrmP0cT0B4TdZduOawH2hA03eDJlxPSYyRtA1Fez3wCFlK1", + "VxKZLjkhHlpW1PJth01mgjDn9JwZpBLvLYXnqtLKGglT0hlNqIjqpkKh2CCiJaAK0MiSSGYZ5lW3Ljso", + "dOCxsn5J6w46VxLE3vIKrLWm5RhVeecLPy8Fme6aS2bXS9ksqeVkAKS2/oJYo+UuhuvKlnyzi6ofgHcp", + "MjxqVHuhj2eAQckV0dahyukcIZxeYGi5KgFtEIZNv7VudLgrcW3D+gXN2Xs+Z8HDwxYM9x9Yjkvse+z/", + "bcdlV1SDaZNqVwz2jfsD7Oq7GSqSu2udALzfq5wkHuN5q/sCFYEp7sb1wFZyYOw53e/uTRAWe4Tvt59B", + "Ubbl4VC54lDpy8n2T5TIduxXMiSHlb9LB6QCZrEkkTjneq9LM5ZSHlt7umZoD1cYylD+l2cjg1zfBfMY", + "GtK+AcLjL/8SYf+71R8cSTFJuFZ7YSu6vkhuZsPc+zMqJ2olwVZ1FYct6ttbdy13BH7/PodI5PXX1f2x", + "Km99XewplucJ06fbPXZlE6Pb3EgmsE2bWfbqv/zeXo/Iid7sbGHJgkwKEbO4usZMMAKe+JiIU8kR91Yt", + "RDTLpOB/1OoB0Ntq2e7hJc9niMeJ6GRESbwFzNgFE4U2CiM5FRzRfYRrC72gPKFnPOH5AtC84ZrwKoVY", + "r1a0fl8VDGxbBuVAfKHqYVdUAd7Kf2kG88SN5S1HmK+vs+4fkUDF0nVLsqEPbkmvXUgetyuyf0ke1/Rv", + "n0xkNmEAFWoOknOK+F8Fxnf6Hm9dAAATK0L1h5c0iweJlOdcTPuEZ1rxZIqfJazEFRuSI2Pq0yRjNF6Q", + "SApVzAHBfGFQIrFWUggKqEksJv/zv/9vhDWtNsp6zhBsRTecxRitCt0ZCV2F0grtVI8Fi0/d/fUkZ9Bg", + "NSTHFfXKFRHSejwNNPJInBo1Oy49oaf61VMhBTvta2VrIrkGZzQ6ZzGRma//XfSsCxhTZE4XROU8SexT", + "6J3MuD6kJoTOZaHPUxAPdmruzO2J3wbdYrf+Ri7MXFCSInZEX+twrSiAXHJSYCNwqN3JzHJdRsZ+HRpk", + "aSwJ4EqVmhQJFA/zLAiP2TyVOQwYvtDcJPTr98Fa3P52oNdU+Bj4oOo/l2MfKNabNGvzjAplANrX8pL6", + "HziYKi9xwbHgCsLnhiarT8AmlYmc8ogmYE5msbZGTaFzeQF7nnpetXYV8sU55WN+HZL3fiswVq10Y+Lm", + "wWqVAiAO7BQGbme5p7cyMHfN33tUZEpmXT2+lam7Mb+vP1V3w/vrtWgt/y+O9v31ANeWwk70EcTJoeE7", + "wCD39fDCBoEPv5wsdB986mXZ0UPopxXZtmxDmMJajC+agmTCaF5kDHMKMJmAGnvsngTKeWJDnNg0Jdsb", + "9GZgttlH1F5OrwaRjJlaipYgsykV/A/4cWC+HZSf7lCM3nk1m4CA9/TqCKoNCM6S1++Lb9GfKwfPl9Mr", + "YueqKSo20qLtLmxJsvYakrEr79GSub4l39EWhfWLzq8O+ZS2LbZVfccu2MpYCi6mDHwf+HKLjQ3lcTEd", + "mCK75oJ0tH+xlnWxJ83bZwuiCrBJ10WcNq9//A0SFqyBcrA9g/oltGyjVAXIW1k1DuuBn+a8CXpqp71M", + "YMllVoKg/jpjwhIL920z9LFNOY4UKBYATE/Jo7lUetlGenee8Ezlj4cEyqDwhR5xloBXKc3kBdcHRkdz", + "bHBW+4QjoKryUFGH5DBNLdWbj8o6Erk0fbbvgvMrd8CrFr7VvucVesP5N7s0OF+beQRJ+4IPR03L0Kok", + "4lSS1ZVv7RNcfp1iXXA8wRsC5WqZOqN5NCNyYtdBqVW0tB0lssDhVwbYtxVaABddQJmuZy5Euib85j+6", + "SYkdEWgmDGZLuQPoa6D0tbKRatXU05Bq1TYroWLxbtK6nbTVsp3GfVzLanrSlJj3M2YFY0YvGDljTJS7", + "KuSAZ/pXk8WtTy6QnmnufWWhksXns/RwfXRZfDWbxJ5kl1slNEncmbfFJHEF7RB/3B27r7kDn7PFqc+1", + "VU0grW3Nxt3+gEfuGYSrJ6JqErr3zxYoq2Mer2sV2vdNIuuo2N9/GvEY/su2Zxu+wibetofVNeNeAZR7", + "yqN5wnplH24UJGuKbg1oNc93imhuenBLgaWm9pD0mEeff9JjOYsd5Se8G+79af7VQDUPQYaXUqb1Gw9E", + "bhn087KVqx3srgEP2Oc7wT7fWGL6ywJ5V8jBlOV3RQj2b1K/PMDcNF3k1xDAVJ8KW8Nj61JoGIjyZFHG", + "cRWC52MgLjKk8iYZG23d1tDT25PdXfnvN9mab3Tp3L/Azh3u5cBLuYeHhdbgTDgL4cWvXiByssyKhLLs", + "ugA+uS9iccBow0DcUBicmdgjqXJTbRvE2n1kdkeRtGrdSNm1VsdUXrBMUBGx9ZaDrdsAKGLgWsJxfZQI", + "udZD4lIqMqZkcsEUYTSalbcNPGYi5xOOmI9lCBw46LISX20kTIUmdthi/RoBYLE7OvZJmhSeK6aaJj0S", + "fq4FNHP8gik+FehyOWMkoknCYiKFXu78ClTuJGNqRoCx74ImNtrD+CnsrBGuRkK/A4F3trBoxuLhuEVf", + "lKPfGnOz2Q3ejtTBD669dZ1wk7tloxXtbpHPU0kE1nwpKcvCbMqRaeOYTDN+QXO2JulkksxhL9vT5WY8", + "XuUfTlk20DubSmnESJrxiBH3aYvD2NYxKOsI75zX9+29efNWbyzHul2fK+0wNP6euQXfvHlrbDBPRJrS", + "r1/T87uZg3CZ7LZ6DRvCuyP/oZHcd6YWbPRNOxD95RMUNhizz96H2JC27sK2Sovu/Qnyta5XsZtoGidj", + "SDRXH0hMux6cjTtxNu5OtGDeVuzO00Se0aRsBH4zJDbVBP+GCKBS0xLQF9pUnxAqFqs2cdOOhqgFrw9N", + "A7Z3ebfJBh+4XzYDsSVya3PYyYb2h7mMWaL/qt0wM0i15BdsXOIUl7/l8l7eOz/YX3fI/nKre5tKq7oZ", + "LrlUsWFctfaQswV5/aJUYwDXAA9aNdlIBFXZlNU12e3umfs3ZrrdR2eaFqqqJF1XsK2YLNuE8Z1l8dw7", + "DZ3CL3YQOEWn04xNoQEPkVTdI6lWzUs1jsq8fbYg52yxIoDKfPPbOVt8/Pt8gTI2OGeL7ZldsFBuPSkV", + "WnHPdmanMCpxnoYgdrm/Az5tdWzA050GQ0FLbykUCuoOSQWq/M/ehWFnryEVof1q70/477rOiBa5MV4H", + "W/Nqq8lU+uBp2ImnoVUCloYtwVfGng5ax3dgevdvSgvckxTdJZJicm1bootaFIEJEbodSdlVeFD3zerG", + "xPT+BQa1Seya57Nyv1sv5MGqxYnMDFsUcI2wnJweRhFL8+ekPrmn5JF3anmsjyBTdGHkWRHlRcZi8p8n", + "73727ftKgTm7yvcidXGqP43lpUgkRSNf0TkD9mZ9NKLk6ORfBBgoVcGh47qZI6FSgF2bMZYbumL9YiST", + "Yi5UX58u4PTTd4e600km532Syz6x+bf9j+Q3G48x5nHfBWeMz9nC+0sv4/5HggkZMZ8zATyhw+EQczP6", + "yNJVnvVM+aemPfqgxjCnFQMTL2dMeG9xZU9DMF1fqZE4nWaySMdni3FZ3yn2M59ljJFT17r/ZavBRFlb", + "US6nDGj4dI0jgVV6vQ1US8K1toR2fCn6LxgBduPqrxoL1u/Z9aE/Zld0niZY8Q96hjARuhJKVE4YVFxu", + "gKvf7/dAfPXJWC+RXPb9RVFZE9UlAW7+fr5IWR9KGIkn+0+eDvYPBvsH7/f3n8P//t2v/XgAP+4f/PDN", + "1//+69dfH7769fCnH18ePPn5v/aP/vndqx/7NJqzARdR/zCaM/JaRMP+NM0HzwZ5kZ3JPhdpkfcPnjRq", + "OwjV9mQrtT3Zb9T2JFTb02pt3z/9r38f/PTL4Xe/fvuvvx6fPHnRnybyjF31f4D/kCOZpZXaZJHr6p7p", + "feRnSWA5Ds4WrbPb8k5zRjvPT7fx7TY+z3DXc4vDJMSqPONi+uC89aOiNrYE0oSKNXJd4bUWXy0WsUNX", + "LVSwrUtI57EFPNhOPto74iFdMRzb82Ye64pu25mpG3HPfJl2QTWvYI4zGRdRTo5oThM53ZwlRVfR6vLU", + "D3fq8dRzerukIroFQQFKqPj8vZ5mAjeTn8D+sPen/s/aQVp6DJfnfZoGrnGjDPU+uEZ34hq9lpgsdZ8u", + "E4Epy29//vdvVKE8ZHs2va3XFL7lHtll8mfcsrchgrtwyiqW5Z3305sV/y8aNXHzVWCkdWeb9R6N45Ug", + "7DSOBwB5rpSMOJg9ECxGW0xEd+IbmNJvbgndxRjIhIpDPQ4P1I/LYZKtmE1kdm3NHyZUj2OgdIR6MIVy", + "5RkHRfjz3wTKQxXI4i2drFz9bfsAPLxPxOUgk04gd63n8W8Y5BUntV/YXF4wb7lMMjlvXTDeke3GF0y/", + "tWzTz4eT4XZF1oqGJxc7OyU68bO2B9dVQh59WBLtyfE+iOH+Tevl+8LxGRa5XZ5GO8u5d0L9QkV9lwfh", + "7jbQja+1e0cjsItVt9wkyqIZv2DtEU2H+IL1FZnLwOZaNAXdN4/lPYqls5Lgy8FuhDItzhKuZu1CeYwv", + "rBRKU9CDUH6xQmklYRdCmckJT1alyJ/hfBD7dosn0Lw2cIVuJQzkJgQNG3zPIgvqsxoUKTNC5ITlORfT", + "tXKoBLusFw7Bwd/XKiR6DqkJWVGmArAF7NeGnjPPZKIsjfFITJlwpM2HokpLFFGBzAbzIsl5mrBGN0nM", + "JlyweEgOR6L2kHBFEi7OMT/Sy62maTok72dcVcwWrgiDxcXVjMUjEReZJdqoFfyVQl+XpbhHpmhVkpi2", + "+iZri2qnoRjV5XDLQRmmv4HlV33j84/QCK6YdVdjWJ/v/cnXDNAILVQg9lZFNGsuHgOFGxsvWD6juRdY", + "J2ReSUw2n9lHKRcGUZAKL7S4ULoK96eDJtCfQeg7LOgJFzTRw24VgWrzTjaXzGqjiD94D3cTV0I3Feyl", + "MSV1qQ26B++KHOzfnm68L468zYVseezISjkz7rlbFLVduc+uYQzcosDfv7w/uh3LQRVnblhXsGNXX91h", + "rH+lom3F/FMPTKwW3k/vNaZYML+gMgVbTCc48cu97bQCvzEPwTvLg3fqi7+paipTW/EXBA+4foE7Ot0a", + "5ec37HawYgMNCYmW//wLj5HRH3y3+oMjKSYJj/LwAbomQqtFcsnWt/en/2cVfq95xKjVvNroqxb+GZw1", + "OsnqPTlu7FTe1orU1baHDaMECha/kBb3vP9Kl4Dd7Ypsf1cGIsEubWImjkTATnxA6rtpenB/1TwEUne0", + "xYhb0SvVUddIai+MermaCVh0HWKWdrA17uqipCGpt3RX0mjHqh36PoRdb8WkxDuZ+gIbrLffh0lmll7E", + "r2UTVH/3o7s3Cqxdvpjr5u2treT+yjo+g8DbDVfq/Q7E7WpnX3eVRVRELGkPyTqC52jRVRYP+ZUniZ4s", + "beNxoddWNGNxAS7XyCgawif6y4wRmrGRkAC0VXVxmq+M0ZdTbaVOdEeBbxFqx9HJ+TwUMgBv3IlD6c04", + "cXC+budOotPB+Mu+lrjmjguzuONDdTSjYrokBPgokYopQklWCKFXbXXrFzEuR2UMAymAcU5mcBLLJbIx", + "2nAhE5t0ZGiD9SEOYBLTaUZjpvqAXWj/rcuGyD5sYiC4Dh/co2WNc3X7yxob8uUxKd70Aodh3PECL4Td", + "PAfeRtm+4D+495v7ub/VBq78wzU9eH8fNrn2NVCKW6ukbbAmcno1iGSVgDTg+S1f281l/WsRJUXsRQXS", + "KwL1hfDo1vFWcixwbArsBYAfz6RMGBU366F8T6+OZHzfAsXddAYl9D29WuFSDDoJrUzuNKDZzNftRjKb", + "RgTNB3z0+YcwWxHpJCEtumzvzxyHpYFcEIz29QRp9QbsSn6I9t1JtO9GctBvv1+/K5O7fwtK4Z74/jYU", + "GRO3W4/GVSy7VanZVTTuJjvZbQjtA7xbC7wbDMtm26QuiWUXYdLgNzKiSa/fK7Kk97w3y/P0+d5eon+c", + "SZU//zOVWf5pj6Z87+IpYLxnXJet8GScmZMxRCf0nve+/fbbb2F6G9nImFqKQT5TPK2UVarne3t/4u+f", + "hjTlw3MpprPfh5GcB6o1BVQqLrRxyUQx12OCfxS9fo/q/5szjDv9GGpYOX5HiSziRrOcgTGM9HM7Enq1", + "miloXJvJC5YJfS4j7IImBXrc5cRlKCmSSxLNWHSuDzc8IxNG8yIDjyBT4MAzuqVsXFlo4Pz0zstgHCTs", + "giUuYCSSYsKnReZ8EY2SX+Cbqtc6aSTCfGAyp4JOmUJM6b4NIEIXJPbEu4FRjSuYwRlVLLbh5sHG1DOQ", + "m21y3KIxzakukCATNBdTImQ2NzleacYj/RNwuuiGJFRMC32cAgIJRWiUSaWIpZFWQ4L81sBnohYiYjFC", + "FrlEUHaFN7JEySKDN0VMaJHLAQxyNmcxkqzkM7YgdJoxFuyjoz4NBE2jICiSsTRjiglIgTNzkNIznvCc", + "M0XOaHSO/Bq4N/UNKa+NGkpZNigEz3GkVsuArTfQpPfuLK4HxgYURTSJisRY7gyn2ol3sAqtnZqlHxVZ", + "xkTEzWhCc/WkrlNi+W2gYJuv4NKCrewGkmuxbpsVuEbNjWSIZv2HaaoIE8AdtJCFHjMtP1pidD+heP4H", + "q2QqAw0SuZTZ+SSRl0BEykXOpnrixBSnuBTChcrZHJuutTuSzkO1ERUgl3NEDIoJEzNQRwtZlLnRLJJY", + "hq5HYWgbXDf6ggZJnFTBgphlUvA/9CvYUFha0Kh8xrN4kNIsX2jdkE9kNld9JyRwxaHFpE9s6rXpccwS", + "fsEg6dkOf5/MqIhxeuhirpdAJJOEwd6BqgZvPm3KVMYSik4jdR6eLj0ogSl6KXKeJ0xXURNuzBg36lj/", + "MrHrcrVs+KWGwg4r97V+rXlGo3MztHKCc2UXv1akOMfDqkfP5tNyEfMLHhc0UfplP6VdYZKtftEo4zNm", + "IQRRfCA9ttnZYPeq/sTQgrZ73CZ9K7++6X65mgN9gjdgyVw0ZGXdnr0sP00zqZvEYkLtspKFShZ6HWrt", + "ZFW6kriTzOkCsp/1cMznLOY0Z8mC0AvKE8tNhmxa1V3VNRvrbuuYctGhM3kJUXqGc5rZ/tYRFaigySLn", + "kSJpkaVSacVjijLTZnccCwDs9lCPz1r3cyZjnCogFNKqdEje2nfn1SKNi0s3xjG2QQMJkEGhstVNnCTs", + "ip/ZAmATiJigGZeqPjqq9+njp/8/AAD//8ZzZinKTwUA", } // GetSwagger returns the content of the embedded swagger specification file diff --git a/api/v3/openapi.yaml b/api/v3/openapi.yaml index 1cf2fbfc67..e471ae9986 100644 --- a/api/v3/openapi.yaml +++ b/api/v3/openapi.yaml @@ -514,7 +514,7 @@ paths: $ref: '#/components/schemas/ULID' responses: '200': - description: Invoice response. + description: The request has succeeded. content: application/json: schema: @@ -556,7 +556,7 @@ paths: $ref: '#/components/schemas/ULID' responses: '200': - description: Invoice response. + description: The request has succeeded. content: application/json: schema: @@ -593,7 +593,7 @@ paths: $ref: '#/components/schemas/ULID' responses: '200': - description: Invoice response. + description: The request has succeeded. content: application/json: schema: @@ -631,7 +631,7 @@ paths: $ref: '#/components/schemas/ULID' responses: '200': - description: Invoice response. + description: The request has succeeded. content: application/json: schema: From 109359261563fdbde7c5cb258622655ac26fe310 Mon Sep 17 00:00:00 2001 From: Robert Boros Date: Wed, 15 Jul 2026 13:58:03 +0200 Subject: [PATCH 4/4] fix: response descriptions --- .../packages/aip/src/invoices/operations.tsp | 9 + api/v3/api.gen.go | 241 +++++++++--------- api/v3/openapi.yaml | 10 +- 3 files changed, 136 insertions(+), 124 deletions(-) diff --git a/api/spec/packages/aip/src/invoices/operations.tsp b/api/spec/packages/aip/src/invoices/operations.tsp index 71c4880f9e..8600a8a282 100644 --- a/api/spec/packages/aip/src/invoices/operations.tsp +++ b/api/spec/packages/aip/src/invoices/operations.tsp @@ -158,6 +158,8 @@ interface InvoicesOperations { * Advances the invoice to the next workflow state. The next state is determined by * the invoice's current status and workflow configuration. Only invoices in draft * or issued status can be advanced. + * + * @returns The updated invoice after advancing to the next state. */ @post @route("/{invoiceId}/advance") @@ -183,6 +185,8 @@ interface InvoicesOperations { * issued * - manual_approval_needed: the invoice will be sent to the customer, the invoice * state becomes issued + * + * @returns The updated invoice after sending to the customer. */ @post @route("/{invoiceId}/approve") @@ -203,6 +207,8 @@ interface InvoicesOperations { * * The action can be called when the invoice's statusDetails' actions field contain * the "retry" action. + * + * @returns The updated invoice after retrying the action. */ @post @route("/{invoiceId}/retry") @@ -224,6 +230,9 @@ interface InvoicesOperations { * * This call is only valid in draft.waiting_for_collection status, where the * collection period can be skipped using this action. + * + * @returns The updated invoice with the snapshot quantities for usage based line + * items. */ @post @route("/{invoiceId}/snapshot-quantities") diff --git a/api/v3/api.gen.go b/api/v3/api.gen.go index 2681df9b49..6654acf957 100644 --- a/api/v3/api.gen.go +++ b/api/v3/api.gen.go @@ -14203,126 +14203,127 @@ var swaggerSpec = []string{ "YNDDTRSiw0g33MvANvDcj6nsE4yB7GtrEdMTfZO+kexowLor3FBqSN5Xf0CUoho9w9/ImuwMLMgvZLgY", "SlKhjQgYSMm/MBIBAgZkEl61Y3rEusHbodtTDbu4IQowrd3wHdH6mukeeTbbFMMdMV73DNfAktsjfKFF", "tZmnqqLITPCsYFe5p5swXPW9fYDxtlyVuG1aByE4oSnoK0Uwb9St7CW2a4tOANZ9PCbW1IPpeUA/mCf3", - "0XYAABQT5T2jQBQRlWhLX+itmJHwmnx/pUpBLdSdWa9pmsmlt734Qst6fT/jegGARa6Pnrk+gjIRBxew", - "y2QtlCV/K6HLGphl4CSv1aEMVBQXJL+UJXU1DKlzDMFCfV5FWzNh6QD5VWtOv0qDDXrE5GVafiJdKtLW", - "j3HAaDJG1LANqxmJSj1GozQ1Bw7+g+a4H5rjhGkzu33h3BWlkbE8W7SrjF/0Y1ADmMsTUhz4Du6MVhnY", - "XtMJxLKTCZr3NM/ZPM0dciuNDC0UbLsR3qjVqZa+UkYr4ClBfWU+s/nHBtkY7YNRD3o06pmXmls4PH9Y", - "hvdjGXaXzbuyMK3valBCT7cvUwdg6uFUT2RWoYsvnWm1rRh2OgcmqkeoVgqAI0PCVr0kc7djGctYc5OH", - "lDi308N2PrykHJKDJzIb17LWCtU3OJ9QrPfUEtGiqlDnPE0BXqNkCWxZ74GBfFj992QTXrYsGsJ8gyvf", - "YB7xVWEB5XtlMqkFj3H5kgtlmKIDl+9eRTu8fveaec30wUjGrH7fbjIIH+7X4X59nbGGwZJk0vhCi84i", - "hShPvICRSSIvdR8xjRam/7n58Df96se/o8W6vZvyI9ec274rt/he9+yyvKITmhqvnJ82XbematszktNq", - "tbgsRXzRNmyhFynyj5h7PMwARzQVLawLWWREXgrz4UjYL31wNw98uiXzEb8eOAC6XeZAOsw6qPOWkiEd", - "tpnflpCgV9/4/LMkawJ2I3K/96etTpvzkVQ5GOKrdnypcrBMjOntLYpXMqt1hBsgh8zdEDoYbuEVBIwA", - "MZ8AaGZOTtlkwoDVeDzJ5PwU4/7aDIiy3esYy2WXr2stt+5/Zb/W3f/KL84WZMKpU4ELxLhZvhuOhNkO", - "9ZdAPPrx7x9OXmxxQ5Qq/143b539sH/34spN+7n6ovfR651Eamt7OwpoZfa/rZA3lEnrlmiWO7/p5f5x", - "p5uvldBb3ndtM4Jbrn34Bey2Tux2s9GiB93fSIMnX/vaTg++ppJtwebAWbd2/vUi0R9Owe4UvHLg64dg", - "+8HZAmBd1zsCn7PFx7/PF4P4bMDjbZ6BTWtu/wiMDbl3R+BSOYQUlH360dtjlxwhYfZ3eXasIsff1qnR", - "dDV4XjThAF/ISbHlftYXjJZNSZ/68J+N+P9g/LxX3zrmli36IYJ+JxH0a89+P2x5TFl+d2Z0/1Y0wD0J", - "Le8gKSYqvB5orFh2u8KyKzCajbar2xHWB3CaFnAaGJat7oU22qH11ObrzoF9+YvVoUip1C6aPsXTPVOp", - "7gIHWKM21q+xb5/fpkDtWs8GaMVuV+V2ke0HDbwMHmyzJdFFHe/RNB1YfrguK2ngPvyCllQLPertLKcG", - "AV8QfCXMxPqwmtZZTTRNd7CikB52L5qx6FwW+UAxpbjBgF9xYfObYXY9Mt+SE/z246NZnqfq+d5eLCM1", - "xBqGkZzvGXx/5ap7PBJBukOsQxHaKBzuhmykpZg6loE5y2cyrhJ6ZhhtYfqPfmTTPxOvgQlWo55ieZGO", - "emQuY9Y3bFmmkpJZwWRzj4TNKY1mNJu6jBI7X3w+ZzGnOUsWWKWjJKg3Fq/BR8LRm0+KvMhYhWrHTj8M", - "yyuZkZkEDnM7grZDqk8yhomlnvvYxPE7t/OHX94Yqiw2P2NxzGLv+0Ih+U+UcCbysWJRxnIkMeA5pwn/", - "gxky3+F/w7gtZJGNhKc6VgSvsGyAwjCoi9uXoZZrlgWOlfGKmg4bKb5d5+hhmi5tmyqSPGgSwevm09BH", - "n5dH9QZ1utGZLQpzJxo9lVlOk/X1uW2bVWPH8L1tIqifD4pNikRrBKdqKprPaJuWknJpeU7yGeNZyfaC", - "2lD1tT4V9nGDw5WKmNAo0v/EF2xmxIyrXGaLocEnyAxkx4df3jR4yeuZflxZkvJcEkqUYyrXtZVbx9pq", - "rTrmX75Ss/dx0O07qdrCLVxLwbV/+qDm1lJzbtnhsiBqm9oObK/VGQn2pg/fbmD62Be+UvYVks9oDlge", - "juidxYQqwjhw/k0SmpMJY0QbUX7Gkq2iLbXBaArb7m3FeexUpbTEkZiRWhrM0CmQpBI00gAtHELgJzxw", - "lOzeg7sS5OGJmBfJYcbKQViujN8MogtaxBoKkbBbRAI8wvatGcxZ7fjLq1RvyoCLhQRrGLmXWcL7mDCT", - "yFQTiQuaFFVJyBhNxjmfszGsqdPnxJQOqxQa+ZWWOJoM9FuYFNXGKsXg08o4dOGdNGOCDeh9anJJVgVi", - "pxEv0JSHUNUVoao1Nb9qh+kenVqrYbVB2KrmP0cT0B4TdZduOawH2hA03eDJlxPSYyRtA1Fez3wCFlK1", - "VxKZLjkhHlpW1PJth01mgjDn9JwZpBLvLYXnqtLKGglT0hlNqIjqpkKh2CCiJaAK0MiSSGYZ5lW3Ljso", - "dOCxsn5J6w46VxLE3vIKrLWm5RhVeecLPy8Fme6aS2bXS9ksqeVkAKS2/oJYo+UuhuvKlnyzi6ofgHcp", - "MjxqVHuhj2eAQckV0dahyukcIZxeYGi5KgFtEIZNv7VudLgrcW3D+gXN2Xs+Z8HDwxYM9x9Yjkvse+z/", - "bcdlV1SDaZNqVwz2jfsD7Oq7GSqSu2udALzfq5wkHuN5q/sCFYEp7sb1wFZyYOw53e/uTRAWe4Tvt59B", - "Ubbl4VC54lDpy8n2T5TIduxXMiSHlb9LB6QCZrEkkTjneq9LM5ZSHlt7umZoD1cYylD+l2cjg1zfBfMY", - "GtK+AcLjL/8SYf+71R8cSTFJuFZ7YSu6vkhuZsPc+zMqJ2olwVZ1FYct6ttbdy13BH7/PodI5PXX1f2x", - "Km99XewplucJ06fbPXZlE6Pb3EgmsE2bWfbqv/zeXo/Iid7sbGHJgkwKEbO4usZMMAKe+JiIU8kR91Yt", - "RDTLpOB/1OoB0Ntq2e7hJc9niMeJ6GRESbwFzNgFE4U2CiM5FRzRfYRrC72gPKFnPOH5AtC84ZrwKoVY", - "r1a0fl8VDGxbBuVAfKHqYVdUAd7Kf2kG88SN5S1HmK+vs+4fkUDF0nVLsqEPbkmvXUgetyuyf0ke1/Rv", - "n0xkNmEAFWoOknOK+F8Fxnf6Hm9dAAATK0L1h5c0iweJlOdcTPuEZ1rxZIqfJazEFRuSI2Pq0yRjNF6Q", - "SApVzAHBfGFQIrFWUggKqEksJv/zv/9vhDWtNsp6zhBsRTecxRitCt0ZCV2F0grtVI8Fi0/d/fUkZ9Bg", - "NSTHFfXKFRHSejwNNPJInBo1Oy49oaf61VMhBTvta2VrIrkGZzQ6ZzGRma//XfSsCxhTZE4XROU8SexT", - "6J3MuD6kJoTOZaHPUxAPdmruzO2J3wbdYrf+Ri7MXFCSInZEX+twrSiAXHJSYCNwqN3JzHJdRsZ+HRpk", - "aSwJ4EqVmhQJFA/zLAiP2TyVOQwYvtDcJPTr98Fa3P52oNdU+Bj4oOo/l2MfKNabNGvzjAplANrX8pL6", - "HziYKi9xwbHgCsLnhiarT8AmlYmc8ogmYE5msbZGTaFzeQF7nnpetXYV8sU55WN+HZL3fiswVq10Y+Lm", - "wWqVAiAO7BQGbme5p7cyMHfN33tUZEpmXT2+lam7Mb+vP1V3w/vrtWgt/y+O9v31ANeWwk70EcTJoeE7", - "wCD39fDCBoEPv5wsdB986mXZ0UPopxXZtmxDmMJajC+agmTCaF5kDHMKMJmAGnvsngTKeWJDnNg0Jdsb", - "9GZgttlH1F5OrwaRjJlaipYgsykV/A/4cWC+HZSf7lCM3nk1m4CA9/TqCKoNCM6S1++Lb9GfKwfPl9Mr", - "YueqKSo20qLtLmxJsvYakrEr79GSub4l39EWhfWLzq8O+ZS2LbZVfccu2MpYCi6mDHwf+HKLjQ3lcTEd", - "mCK75oJ0tH+xlnWxJ83bZwuiCrBJ10WcNq9//A0SFqyBcrA9g/oltGyjVAXIW1k1DuuBn+a8CXpqp71M", - "YMllVoKg/jpjwhIL920z9LFNOY4UKBYATE/Jo7lUetlGenee8Ezlj4cEyqDwhR5xloBXKc3kBdcHRkdz", - "bHBW+4QjoKryUFGH5DBNLdWbj8o6Erk0fbbvgvMrd8CrFr7VvucVesP5N7s0OF+beQRJ+4IPR03L0Kok", - "4lSS1ZVv7RNcfp1iXXA8wRsC5WqZOqN5NCNyYtdBqVW0tB0lssDhVwbYtxVaABddQJmuZy5Euib85j+6", - "SYkdEWgmDGZLuQPoa6D0tbKRatXU05Bq1TYroWLxbtK6nbTVsp3GfVzLanrSlJj3M2YFY0YvGDljTJS7", - "KuSAZ/pXk8WtTy6QnmnufWWhksXns/RwfXRZfDWbxJ5kl1slNEncmbfFJHEF7RB/3B27r7kDn7PFqc+1", - "VU0grW3Nxt3+gEfuGYSrJ6JqErr3zxYoq2Mer2sV2vdNIuuo2N9/GvEY/su2Zxu+wibetofVNeNeAZR7", - "yqN5wnplH24UJGuKbg1oNc93imhuenBLgaWm9pD0mEeff9JjOYsd5Se8G+79af7VQDUPQYaXUqb1Gw9E", - "bhn087KVqx3srgEP2Oc7wT7fWGL6ywJ5V8jBlOV3RQj2b1K/PMDcNF3k1xDAVJ8KW8Nj61JoGIjyZFHG", - "cRWC52MgLjKk8iYZG23d1tDT25PdXfnvN9mab3Tp3L/Azh3u5cBLuYeHhdbgTDgL4cWvXiByssyKhLLs", - "ugA+uS9iccBow0DcUBicmdgjqXJTbRvE2n1kdkeRtGrdSNm1VsdUXrBMUBGx9ZaDrdsAKGLgWsJxfZQI", - "udZD4lIqMqZkcsEUYTSalbcNPGYi5xOOmI9lCBw46LISX20kTIUmdthi/RoBYLE7OvZJmhSeK6aaJj0S", - "fq4FNHP8gik+FehyOWMkoknCYiKFXu78ClTuJGNqRoCx74ImNtrD+CnsrBGuRkK/A4F3trBoxuLhuEVf", - "lKPfGnOz2Q3ejtTBD669dZ1wk7tloxXtbpHPU0kE1nwpKcvCbMqRaeOYTDN+QXO2JulkksxhL9vT5WY8", - "XuUfTlk20DubSmnESJrxiBH3aYvD2NYxKOsI75zX9+29efNWbyzHul2fK+0wNP6euQXfvHlrbDBPRJrS", - "r1/T87uZg3CZ7LZ6DRvCuyP/oZHcd6YWbPRNOxD95RMUNhizz96H2JC27sK2Sovu/Qnyta5XsZtoGidj", - "SDRXH0hMux6cjTtxNu5OtGDeVuzO00Se0aRsBH4zJDbVBP+GCKBS0xLQF9pUnxAqFqs2cdOOhqgFrw9N", - "A7Z3ebfJBh+4XzYDsSVya3PYyYb2h7mMWaL/qt0wM0i15BdsXOIUl7/l8l7eOz/YX3fI/nKre5tKq7oZ", - "LrlUsWFctfaQswV5/aJUYwDXAA9aNdlIBFXZlNU12e3umfs3ZrrdR2eaFqqqJF1XsK2YLNuE8Z1l8dw7", - "DZ3CL3YQOEWn04xNoQEPkVTdI6lWzUs1jsq8fbYg52yxIoDKfPPbOVt8/Pt8gTI2OGeL7ZldsFBuPSkV", - "WnHPdmanMCpxnoYgdrm/Az5tdWzA050GQ0FLbykUCuoOSQWq/M/ehWFnryEVof1q70/477rOiBa5MV4H", - "W/Nqq8lU+uBp2ImnoVUCloYtwVfGng5ax3dgevdvSgvckxTdJZJicm1bootaFIEJEbodSdlVeFD3zerG", - "xPT+BQa1Seya57Nyv1sv5MGqxYnMDFsUcI2wnJweRhFL8+ekPrmn5JF3anmsjyBTdGHkWRHlRcZi8p8n", - "73727ftKgTm7yvcidXGqP43lpUgkRSNf0TkD9mZ9NKLk6ORfBBgoVcGh47qZI6FSgF2bMZYbumL9YiST", - "Yi5UX58u4PTTd4e600km532Syz6x+bf9j+Q3G48x5nHfBWeMz9nC+0sv4/5HggkZMZ8zATyhw+EQczP6", - "yNJVnvVM+aemPfqgxjCnFQMTL2dMeG9xZU9DMF1fqZE4nWaySMdni3FZ3yn2M59ljJFT17r/ZavBRFlb", - "US6nDGj4dI0jgVV6vQ1US8K1toR2fCn6LxgBduPqrxoL1u/Z9aE/Zld0niZY8Q96hjARuhJKVE4YVFxu", - "gKvf7/dAfPXJWC+RXPb9RVFZE9UlAW7+fr5IWR9KGIkn+0+eDvYPBvsH7/f3n8P//t2v/XgAP+4f/PDN", - "1//+69dfH7769fCnH18ePPn5v/aP/vndqx/7NJqzARdR/zCaM/JaRMP+NM0HzwZ5kZ3JPhdpkfcPnjRq", - "OwjV9mQrtT3Zb9T2JFTb02pt3z/9r38f/PTL4Xe/fvuvvx6fPHnRnybyjF31f4D/kCOZpZXaZJHr6p7p", - "feRnSWA5Ds4WrbPb8k5zRjvPT7fx7TY+z3DXc4vDJMSqPONi+uC89aOiNrYE0oSKNXJd4bUWXy0WsUNX", - "LVSwrUtI57EFPNhOPto74iFdMRzb82Ye64pu25mpG3HPfJl2QTWvYI4zGRdRTo5oThM53ZwlRVfR6vLU", - "D3fq8dRzerukIroFQQFKqPj8vZ5mAjeTn8D+sPen/s/aQVp6DJfnfZoGrnGjDPU+uEZ34hq9lpgsdZ8u", - "E4Epy29//vdvVKE8ZHs2va3XFL7lHtll8mfcsrchgrtwyiqW5Z3305sV/y8aNXHzVWCkdWeb9R6N45Ug", - "7DSOBwB5rpSMOJg9ECxGW0xEd+IbmNJvbgndxRjIhIpDPQ4P1I/LYZKtmE1kdm3NHyZUj2OgdIR6MIVy", - "5RkHRfjz3wTKQxXI4i2drFz9bfsAPLxPxOUgk04gd63n8W8Y5BUntV/YXF4wb7lMMjlvXTDeke3GF0y/", - "tWzTz4eT4XZF1oqGJxc7OyU68bO2B9dVQh59WBLtyfE+iOH+Tevl+8LxGRa5XZ5GO8u5d0L9QkV9lwfh", - "7jbQja+1e0cjsItVt9wkyqIZv2DtEU2H+IL1FZnLwOZaNAXdN4/lPYqls5Lgy8FuhDItzhKuZu1CeYwv", - "rBRKU9CDUH6xQmklYRdCmckJT1alyJ/hfBD7dosn0Lw2cIVuJQzkJgQNG3zPIgvqsxoUKTNC5ITlORfT", - "tXKoBLusFw7Bwd/XKiR6DqkJWVGmArAF7NeGnjPPZKIsjfFITJlwpM2HokpLFFGBzAbzIsl5mrBGN0nM", - "JlyweEgOR6L2kHBFEi7OMT/Sy62maTok72dcVcwWrgiDxcXVjMUjEReZJdqoFfyVQl+XpbhHpmhVkpi2", - "+iZri2qnoRjV5XDLQRmmv4HlV33j84/QCK6YdVdjWJ/v/cnXDNAILVQg9lZFNGsuHgOFGxsvWD6juRdY", - "J2ReSUw2n9lHKRcGUZAKL7S4ULoK96eDJtCfQeg7LOgJFzTRw24VgWrzTjaXzGqjiD94D3cTV0I3Feyl", - "MSV1qQ26B++KHOzfnm68L468zYVseezISjkz7rlbFLVduc+uYQzcosDfv7w/uh3LQRVnblhXsGNXX91h", - "rH+lom3F/FMPTKwW3k/vNaZYML+gMgVbTCc48cu97bQCvzEPwTvLg3fqi7+paipTW/EXBA+4foE7Ot0a", - "5ec37HawYgMNCYmW//wLj5HRH3y3+oMjKSYJj/LwAbomQqtFcsnWt/en/2cVfq95xKjVvNroqxb+GZw1", - "OsnqPTlu7FTe1orU1baHDaMECha/kBb3vP9Kl4Dd7Ypsf1cGIsEubWImjkTATnxA6rtpenB/1TwEUne0", - "xYhb0SvVUddIai+MermaCVh0HWKWdrA17uqipCGpt3RX0mjHqh36PoRdb8WkxDuZ+gIbrLffh0lmll7E", - "r2UTVH/3o7s3Cqxdvpjr5u2treT+yjo+g8DbDVfq/Q7E7WpnX3eVRVRELGkPyTqC52jRVRYP+ZUniZ4s", - "beNxoddWNGNxAS7XyCgawif6y4wRmrGRkAC0VXVxmq+M0ZdTbaVOdEeBbxFqx9HJ+TwUMgBv3IlD6c04", - "cXC+budOotPB+Mu+lrjmjguzuONDdTSjYrokBPgokYopQklWCKFXbXXrFzEuR2UMAymAcU5mcBLLJbIx", - "2nAhE5t0ZGiD9SEOYBLTaUZjpvqAXWj/rcuGyD5sYiC4Dh/co2WNc3X7yxob8uUxKd70Aodh3PECL4Td", - "PAfeRtm+4D+495v7ub/VBq78wzU9eH8fNrn2NVCKW6ukbbAmcno1iGSVgDTg+S1f281l/WsRJUXsRQXS", - "KwL1hfDo1vFWcixwbArsBYAfz6RMGBU366F8T6+OZHzfAsXddAYl9D29WuFSDDoJrUzuNKDZzNftRjKb", - "RgTNB3z0+YcwWxHpJCEtumzvzxyHpYFcEIz29QRp9QbsSn6I9t1JtO9GctBvv1+/K5O7fwtK4Z74/jYU", - "GRO3W4/GVSy7VanZVTTuJjvZbQjtA7xbC7wbDMtm26QuiWUXYdLgNzKiSa/fK7Kk97w3y/P0+d5eon+c", - "SZU//zOVWf5pj6Z87+IpYLxnXJet8GScmZMxRCf0nve+/fbbb2F6G9nImFqKQT5TPK2UVarne3t/4u+f", - "hjTlw3MpprPfh5GcB6o1BVQqLrRxyUQx12OCfxS9fo/q/5szjDv9GGpYOX5HiSziRrOcgTGM9HM7Enq1", - "miloXJvJC5YJfS4j7IImBXrc5cRlKCmSSxLNWHSuDzc8IxNG8yIDjyBT4MAzuqVsXFlo4Pz0zstgHCTs", - "giUuYCSSYsKnReZ8EY2SX+Cbqtc6aSTCfGAyp4JOmUJM6b4NIEIXJPbEu4FRjSuYwRlVLLbh5sHG1DOQ", - "m21y3KIxzakukCATNBdTImQ2NzleacYj/RNwuuiGJFRMC32cAgIJRWiUSaWIpZFWQ4L81sBnohYiYjFC", - "FrlEUHaFN7JEySKDN0VMaJHLAQxyNmcxkqzkM7YgdJoxFuyjoz4NBE2jICiSsTRjiglIgTNzkNIznvCc", - "M0XOaHSO/Bq4N/UNKa+NGkpZNigEz3GkVsuArTfQpPfuLK4HxgYURTSJisRY7gyn2ol3sAqtnZqlHxVZ", - "xkTEzWhCc/WkrlNi+W2gYJuv4NKCrewGkmuxbpsVuEbNjWSIZv2HaaoIE8AdtJCFHjMtP1pidD+heP4H", - "q2QqAw0SuZTZ+SSRl0BEykXOpnrixBSnuBTChcrZHJuutTuSzkO1ERUgl3NEDIoJEzNQRwtZlLnRLJJY", - "hq5HYWgbXDf6ggZJnFTBgphlUvA/9CvYUFha0Kh8xrN4kNIsX2jdkE9kNld9JyRwxaHFpE9s6rXpccwS", - "fsEg6dkOf5/MqIhxeuhirpdAJJOEwd6BqgZvPm3KVMYSik4jdR6eLj0ogSl6KXKeJ0xXURNuzBg36lj/", - "MrHrcrVs+KWGwg4r97V+rXlGo3MztHKCc2UXv1akOMfDqkfP5tNyEfMLHhc0UfplP6VdYZKtftEo4zNm", - "IQRRfCA9ttnZYPeq/sTQgrZ73CZ9K7++6X65mgN9gjdgyVw0ZGXdnr0sP00zqZvEYkLtspKFShZ6HWrt", - "ZFW6kriTzOkCsp/1cMznLOY0Z8mC0AvKE8tNhmxa1V3VNRvrbuuYctGhM3kJUXqGc5rZ/tYRFaigySLn", - "kSJpkaVSacVjijLTZnccCwDs9lCPz1r3cyZjnCogFNKqdEje2nfn1SKNi0s3xjG2QQMJkEGhstVNnCTs", - "ip/ZAmATiJigGZeqPjqq9+njp/8/AAD//8ZzZinKTwUA", + "0XZ4PytXp51OOsFQRT0oJgUyr8zil3xjZqS/JvtfqbL7hbozazlNM7n0JhhfaFnL72dcLw6w1vWxNNfH", + "Uybi4OJ2Wa6FssRwJaxZA88MHOi1OpSBkeKC5JeypLWGIXVOI1jEz6tIbCZkHeDAas3pVymyQceYnE3L", + "XaRLRUr7MQ4YTcaIKLZhNSNRqcdom6ZWwcF/0Cq+VlHGu1kb3y85QI9p07x9Qd0VZZKxPFu0q5Jf9GM3", + "fWGFgu94G4fXa7OpkAkeCWies3maO7RXGhkqKdiqI7yFq9MzfaWMtsCThfrKfGZzlg0aMtoUox70aNQz", + "LzW3fXj+sDz9+YEhsVNnx+2LXZrd5fWuLFbrAxuUENbtS9cBoXp41xOZVWjnS6dcbduGXdGBkuoRqpUC", + "IMuQ+FUvydwRWeYz1jQIILXOWQWw9Q8vKYck44nMxrXst0L1DV4oFOs9tYS2qD7UOU9TgOko2QZbdEBg", + "IB80gkfQW4GkDcmPN+sjgQL0Be/la44Eyv8NKgsDt8RXRSSU75V5rBa3xqVqLpQhqQ7c+3sV7fDm32vm", + "NTMXIxmz+lW/SV58uNqHq/11xhoGS5JJ4wstOosUAkzx7kcmibzUfcQMXpj+5+bD3/SrH/+Ohu/2LumP", + "XHNu+5reQovds3v6ik5oarxyftp03Zqqbc9ITquh4xIk8UXbsIVepEh9Yq4QMfkcgVy0sC5kkRF5KcyH", + "I2G/9HHlPNzrlqRL/HrgsO92mX7p4PKgzlvKw3Swan5bQoJefePzT9CsCdiNyP3en7Y6fQKIpMrBdl+1", + "40uVg2VirHVvUbySWa0j3GBIZO5y0iGAC68gsAxjPgG8zpycssmEAaHyeJLJ+SmGHLYZEGW717Gvyy5f", + "18Bu3f/Kfq27/5VfnC3IhFOnAhcIr7N8NxwJsx3qL4Hz9OPfP5y82OKGKFX+vW7eOvth/+6FtJv2c/VF", + "76PXO4nU1vZ2FNBK4AFbIW8ok9Yt0Sx3ftPL/eNON18robe879pmBLdc+/AL2G2d2O1mo0VHvL+RBk++", + "9rWdHnxNJdtC7IGzbu386wXBP5yC3Sl45cDXD8H2g7MFIMqudwQ+Z4uPf58vBvHZgMfbPAOb1tz+ERgb", + "cu+OwKVyCCko+/Sjt8cuOULC7O/y7FgFrb+tU6PpavC8aKINvpCTYss1ry8YLZuSPvXhPxupB8HQfa++", + "dcwtW/RD8P5OgvfXnv1+2PKYsvzuzOj+rWiAexLV3kFSTEB6PcZZsex2hWVXODgbbVe3I6wPuDgtuDgw", + "LFvdC22AROupzdedA/vyF6tDkc2pXTR9dql7plLdBQ4QVm2sX2PfPr9Ngdq1ng0wmt2uyu0i2w8aeBky", + "2WZLoos63qNpOrDUdF1W0sB9+AUtqRZm1ttZTg3uvyDuS5gE9mE1rbOaaJruYEUhM+1eNGPRuSzygWJK", + "cQM/v+LC5jdDKntkviUn+O3HR7M8T9Xzvb1YRmqINQwjOd8z1ALKVfd4JIJMi1iHIrRRONwN2eBMMXUE", + "B3OWz2Rc5RLNMNrC9B/9yKZ/Jl4Dc7tGPcXyIh31yFzGrG+IukwlJamDSSQfCZvOGs1oNnUJK3a++HzO", + "Yk5zliywSseGUG8sXoOPhGNWnxR5kbEKy4+dfhiWVzIjMwn06XYEbYdUn2QMc1o997FJB3Bu5w+/vDEs", + "XWx+xuKYxd73hULeoSjhTORjxaKM5cifwHNOE/4HMzzCw/+GcVvIIhsJT3WsCF5h2QCFYVAXty9DLdcs", + "Cxwr4xU1HTZSfLvO0cM0Xdo2VSR50CSC182noY8+L4/qDep0ozNbFOZONHoqs5wm6+tz2zarxo7he9tE", + "UD8fFJsUidYITtVUNJ/RNi0l5dJSrOQzxrOSaAa1oeprfSrs4wZ9LBUxoVGk/4kv2FDyGVe5zBZDA42Q", + "GbSQD7+8aVCi1xMJubL86LkklChHkq5rK7eOtdVadcy/fKVm7+Og23dStYVbuJaCa//0Qc2tpebcssNl", + "QdQ2tR3YXqszEuxNH77dgBOyL3yl7Cskn9EcYEQcxzyLCVWEcaAbnCQ0JxPGiDai/CQnW0VbaoPRFLbd", + "24rz2KlKaYkjMSO1NJihUyBJJWikgZc4hMBPeODY4L0HdyXIwxMxL5LDjJVDz1wZvxkENrRgORQiYbcI", + "QniE7VszmLPa8ZdXqd6UAZILud0wci+zXPsxYSaRqSYSFzQpqpKQMZqMcz5nY1hTp8+JKR1WKTTyKy1x", + "NBnotzApqo3QisGnlXHoQnlpxgQb0PvUpLGsCsROI16gKQ+hqitCVWtqftUO0z06tVbDaoOwVc1/jiag", + "PSbqLt1yWA+0IWi6wZMvJ6THSNoGorye+QQEqGqv5FBdckI8tISs5dsOFs0EYc7pOTNAKN5bCs9VpZU1", + "EqakM5pQEdVNhUKxQURLvBZgsCWRzDJMxW5ddlDowCOE/ZLWHXSu5Ka95RVYa03LMaryzhd+XgqS7DWX", + "zK6XsllSy3kISG39BWFOy10M15Ut+WYXVT+AElNkeNSo9kIfzwD+kiuirUOV0zkiRL3A0HJV4uIgApx+", + "a93ocFfi2ob1C5qz93zOgoeHLRjuP7Acl9j32P/bjsuuqAbTJtWuGOwb9wdT1nczVCR31zoBKMdXOUk8", + "svVW9wUqAlPcjeuBreTA2HO6392b4Er2uOZvP4OibMvDoXLFodKXk+2fKJFo2a9kSA4rf5cOSAWkZkki", + "cc71XpdmLKU8tvZ0zdAerjCUofwvz0YGub4L5jE0pH0DhMdf/iXC/nerPziSYpJwrfbCVnR9kdzMhrn3", + "Z1RO1Epur+oqDlvUt7fuWu4I/P59DpHI66+r+2NV3vq62FMszxOmT7d77MomRre5kUxgmzaz7NV/+b29", + "HpETvdnZwpIFmRQiZnF1jZlgBDzxMRGnkiOsrlqIaJZJwf+o1QOYutWy3cNLns8Q1hPRyYiSeAuYsQsm", + "Cm0URnIqOKL7CNcWekF5Qs94wvMFAInDNeFVCrFerUQBvioY2LYMyoH4QtXDrlgKvJX/0gzmiRvLW44w", + "X19n3T8Og4ql65ZkQx/ckl67kDxuV2T/kjyu6d8+mchswgBd1Bwk5xTxvwqM7/Q93roAwDdWhOoPL2kW", + "DxIpz7mY9gnPtOLJFD9LWIkrNiRHxtSnScZovCCRFKqYA0D6wqBEYq2kEBRQk1hM/ud//9+IhFptlPWc", + "IdiKbjiLMVoVujMSugqlFdqpHgsWn7r760nOoMFqSI4r6pUrIqT1eBqE5ZE4NWp2XHpCT/Wrp0IKdtrX", + "ytZEcg3OaHTOYiIzX/+76FkXMKbInC6IynmS2KfQO5lxfUhNCJ3LQp+nIB7s1NyZ2xO/DbrFbv2NXJi5", + "oCRF7Ii+1uFaUQCv5aTARuBQu5OZpdmMjP06NADVWJIqIFBtUiRQPMyzIDxm81TmMGD4QnOT0K/fB2tx", + "+9uBXlPhY+CDqv9cjn2gWG/SrM0zKpTBeV/LS+p/4GCqvMQFR8ArCJ8bhq4+AZtUJnLKI5qAOZnF2ho1", + "hc7lBex56nnV2lVIVeeUj/l1SN77rcBYtdKNiZsHq1UKgDiwUxi4neWe3srA3DV/71GRKZl19fhWpu7G", + "/L7+VN0N76/XorX8vzja99cDXFsKO9FHECeHhu8Ag9zXwwsbBD78crLQffCpl2VHD6GfVmTbsg1hCmsx", + "vmgKkgmjeZExzCnAZAJq7LF7EijniQ1xYtOUbG/Qm4HZZh9Rezm9GkQyZmopWoLMplTwP+DHgfl2UH66", + "QzF659VsAgLe06sjqDYgOEtevy++RX+uHDxfTq+InaumqNhIi7a7sCXJ2mtIxq68R0vm+pZ8R1sU1i86", + "vzrkU9q22Fb1HbtgK2MpuJgy8H3gyy02NpTHxXRgiuyaC9LR/sVa1sWeNG+fLYgqwCZdF3HavP7xN0hY", + "sAbKwfYM6pfQso1SFSBvZdU4rAd+mvMm6Kmd9jKBJZdZCYL664wJy2nct83QxzblOFKgWAAwPSWP5lLp", + "ZRvp3XnCM5U/HhIog8IXesRZAl6lNJMXXB8YHcOywVntE46AqspDRR2SwzS1jHE+KutI5NL02b4Lzq/c", + "Aa9a+Fb7nlfoDeff7NLgfG3mESTtCz4cNS1Dq5KIU0lWV761T3D5dYp1wfEEbwiUq2XqjObRjMiJXQel", + "VtHSdpTIAodfGWDfVmgBXHQBZbqeuRDpmvCb/+gmJXZEoJkwmC3lDqCvgdLXykaqVVNPQ6pV26yEisW7", + "Set20lbLdhr3cS2r6UlTYt7PmBWMGb1g5IwxUe6qkAOe6V9NFrc+uUB6prn3lYVKFp/P0sP10WXx1WwS", + "e5JdbpXQJHFn3haTxBW0Q/xxd+y+5g58zhanPtdWNYG0tjUbd/sDHrlnEK6eiKpJ6N4/W6Csjnm8rlVo", + "3zeJrKNif/9pxGP4L9uebfgKm3jbHlbXjHsFUO4pj+YJ65V9uFGQrCm6NaDVPN8pornpwS0FlpraQ9Jj", + "Hn3+SY/lLHaUn/BuuPen+VcD1TwEGV5KmdZvPBC5ZdDPy1audrC7Bjxgn+8E+3xjiekvC+RdIQdTlt8V", + "Idi/Sf3yAHPTdJFfQwBTfSpsDY+tS6FhIMqTRRnHVQiej4G4yHDTm2RstHVbQ09vT3Z35b/fZGu+0aVz", + "/wI7d7iXAy/lHh4WWoMz4SyEF796gcjJMisSyrLrAvjkvojFAaMNA3FDYXBmYo+kyk21bRBr7+GYCY0i", + "M6owEpLFWmt9sSsDRdKqdSNl11odU3nBMkFFxNZbDrZuA6CIgWsJx/VRIuRaD4lLqciYkskFU4TRaFbe", + "NvCYiZxPOGI+liFw4KDLSny1kTAVmthhi/VrBIDF7ujYJ2lSeK6Yapr0SPi5FtDM8Qum+FSgy+WMkYgm", + "CYuJFHq58ytQuZOMqRkBxr4LmthoD+OnsLNGuBoJ/Q4E3tnCohmLh+MWfVGOfmvMzWY3eDtSBz+49tZ1", + "wk3ulo1WtLtFPk8lEVjzpaQsC7MpR6aNYzLN+AXN2Zqkk0kyh71sT5eb8XiVfzhl2UDvbCqlESNpxiNG", + "3KctDmNbx6CsI7xzXt+39+bNW72xHOt2fa60w9D4e+YWfPPmrbHBPBFpSr9+Tc/vZg7CZbLb6jVsCO+O", + "/IdGct+ZWrDRN+1A9JdPUNhgzD57H2JD2roL2yotuvcnyNe6XsVuommcjCHRXH0gMe16cDbuxNm4O9GC", + "eVuxO08TeUaTshH4zZDYVBP8GyKASk1LQF9oU31CqFis2sRNOxqiFrw+NA3Y3uXdJht84H7ZDMSWyK3N", + "YScb2h/mMmaJ/qt2w8wg1ZJfsHGJU1z+lst7ee/8YH/dIfvLre5tKq3qZrjkUsWGcdXaQ84W5PWLUo0B", + "XAM8aNVkIxFUZVNW12S3u2fu35jpdh+daVqoqpJ0XcG2YrJsE8Z3lsVz7zR0Cr/YQeAUnU4zNoUGPERS", + "dY+kWjUv1Tgq8/bZgpyzxYoAKvPNb+ds8fHv8wXK2OCcLbZndsFCufWkVGjFPduZncKoxHkagtjl/g74", + "tNWxAU93GgwFLb2lUCioOyQVqPI/exeGnb2GVIT2q70/4b/rOiNa5MZ4HWzNq60mU+mDp2EnnoZWCVga", + "tgRfGXs6aB3fgendvyktcE9SdJdIism1bYkualEEJkTodiRlV+FB3TerGxPT+xcY1Caxa57Pyv1uvZAH", + "qxYnMjNsUcA1wnJyehhFLM2fk/rknpJH3qnlsT6CTNGFkWdFlBcZi8l/nrz72bfvKwXm7Crfi9TFqf40", + "lpcikRSNfEXnDNib9dGIkqOTfxFgoFQFh47rZo6ESgF2bcZYbuiK9YuRTIq5UH19uoDTT98d6k4nmZz3", + "SS77xObf9j+S32w8xpjHfRecMT5nC+8vvYz7HwkmZMR8zgTwhA6HQ8zN6CNLV3nWM+WfmvbogxrDnFYM", + "TLycMeG9xZU9DcF0faVG4nSaySIdny3GZX2n2M98ljFGTl3r/petBhNlbUW5nDKg4dM1jgRW6fU2UC0J", + "19oS2vGl6L9gBNiNq79qLFi/Z9eH/phd0XmaYMU/6BnCROhKKFE5YVBxuQGufr/fA/HVJ2O9RHLZ9xdF", + "ZU1UlwS4+fv5ImV9KGEknuw/eTrYPxjsH7zf338O//t3v/bjAfy4f/DDN1//+69ff3346tfDn358efDk", + "5//aP/rnd69+7NNozgZcRP3DaM7IaxEN+9M0Hzwb5EV2JvtcpEXeP3jSqO0gVNuTrdT2ZL9R25NQbU+r", + "tX3/9L/+ffDTL4ff/frtv/56fPLkRX+ayDN21f8B/kOOZJZWapNFrqt7pveRnyWB5Tg4W7TObss7zRnt", + "PD/dxrfb+DzDXc8tDpMQq/KMi+mD89aPitrYEkgTKtbIdYXXWny1WMQOXbVQwbYuIZ3HFvBgO/lo74iH", + "dMVwbM+beawrum1npm7EPfNl2gXVvII5zmRcRDk5ojlN5HRzlhRdRavLUz/cqcdTz+ntkoroFgQFKKHi", + "8/d6mgncTH4C+8Pen/o/awdp6TFcnvdpGrjGjTLU++Aa3Ylr9FpistR9ukwEpiy//fnfv1GF8pDt2fS2", + "XlP4lntkl8mfccvehgjuwimrWJZ33k9vVvy/aNTEzVeBkdadbdZ7NI5XgrDTOB4A5LlSMuJg9kCwGG0x", + "Ed2Jb2BKv7kldBdjIBMqDvU4PFA/LodJtmI2kdm1NX+YUD2OgdIR6sEUypVnHBThz38TKA9VIIu3dLJy", + "9bftA/DwPhGXg0w6gdy1nse/YZBXnNR+YXN5wbzlMsnkvHXBeEe2G18w/dayTT8fTobbFVkrGp5c7OyU", + "6MTP2h5cVwl59GFJtCfH+yCG+zetl+8Lx2dY5HZ5Gu0s594J9QsV9V0ehLvbQDe+1u4djcAuVt1ykyiL", + "ZvyCtUc0HeIL1ldkLgOba9EUdN88lvcols5Kgi8HuxHKtDhLuJq1C+UxvrBSKE1BD0L5xQqllYRdCGUm", + "JzxZlSJ/hvNB7NstnkDz2sAVupUwkJsQNGzwPYssqM9qUKTMCJETludcTNfKoRLssl44BAd/X6uQ6Dmk", + "JmRFmQrAFrBfG3rOPJOJsjTGIzFlwpE2H4oqLVFEBTIbzIsk52nCGt0kMZtwweIhORyJ2kPCFUm4OMf8", + "SC+3mqbpkLyfcVUxW7giDBYXVzMWj0RcZJZoo1bwVwp9XZbiHpmiVUli2uqbrC2qnYZiVJfDLQdlmP4G", + "ll/1jc8/QiO4YtZdjWF9vvcnXzNAI7RQgdhbFdGsuXgMFG5svGD5jOZeYJ2QeSUx2XxmH6VcGERBKrzQ", + "4kLpKtyfDppAfwah77CgJ1zQRA+7VQSqzTvZXDKrjSL+4D3cTVwJ3VSwl8aU1KU26B68K3Kwf3u68b44", + "8jYXsuWxIyvlzLjnblHUduU+u4YxcIsCf//y/uh2LAdVnLlhXcGOXX11h7H+lYq2FfNPPTCxWng/vdeY", + "YsH8gsoUbDGd4MQv97bTCvzGPATvLA/eqS/+pqqpTG3FXxA84PoF7uh0a5Sf37DbwYoNNCQkWv7zLzxG", + "Rn/w3eoPjqSYJDzKwwfomgitFsklW9/en/6fVfi95hGjVvNqo69a+Gdw1ugkq/fkuLFTeVsrUlfbHjaM", + "EihY/EJa3PP+K10Cdrcrsv1dGYgEu7SJmTgSATvxAanvpunB/VXzEEjd0RYjbkWvVEddI6m9MOrlaiZg", + "0XWIWdrB1riri5KGpN7SXUmjHat26PsQdr0VkxLvZOoLbLDefh8mmVl6Eb+WTVD93Y/u3iiwdvlirpu3", + "t7aS+yvr+AwCbzdcqfc7ELernX3dVRZREbGkPSTrCJ6jRVdZPORXniR6srSNx4VeW9GMxQW4XCOjaAif", + "6C8zRmjGRkIC0FbVxWm+MkZfTrWVOtEdBb5FqB1HJ+fzUMgAvHEnDqU348TB+bqdO4lOB+Mv+1rimjsu", + "zOKOD9XRjIrpkhDgo0QqpgglWSGEXrXVrV/EuByVMQykAMY5mcFJLJfIxmjDhUxs0pGhDdaHOIBJTKcZ", + "jZnqA3ah/bcuGyL7sImB4Dp8cI+WNc7V7S9rbMiXx6R40wschnHHC7wQdvMceBtl+4L/4N5v7uf+Vhu4", + "8g/X9OD9fdjk2tdAKW6tkrbBmsjp1SCSVQLSgOe3fG03l/WvRZQUsRcVSK8I1BfCo1vHW8mxwLEpsBcA", + "fjyTMmFU3KyH8j29OpLxfQsUd9MZlND39GqFSzHoJLQyudOAZjNftxvJbBoRNB/w0ecfwmxFpJOEtOiy", + "vT9zHJYGckEw2tcTpNUbsCv5Idp3J9G+G8lBv/1+/a5M7v4tKIV74vvbUGRM3G49Glex7FalZlfRuJvs", + "ZLchtA/wbi3wbjAsm22TuiSWXYRJg9/IiCa9fq/Ikt7z3izP0+d7e4n+cSZV/vzPVGb5pz2a8r2Lp4Dx", + "nnFdtsKTcWZOxhCd0Hve+/bbb7+F6W1kI2NqKQb5TPG0Ulapnu/t/Ym/fxrSlA/PpZjOfh9Gch6o1hRQ", + "qbjQxiUTxVyPCf5R9Po9qv9vzjDu9GOoYeX4HSWyiBvNcgbGMNLP7Ujo1WqmoHFtJi9YJvS5jLALmhTo", + "cZcTl6GkSC5JNGPRuT7c8IxMGM2LDDyCTIEDz+iWsnFloYHz0zsvg3GQsAuWuICRSIoJnxaZ80U0Sn6B", + "b6pe66SRCPOByZwKOmUKMaX7NoAIXZDYE+8GRjWuYAZnVLHYhpsHG1PPQG62yXGLxjSnukCCTNBcTImQ", + "2dzkeKUZj/RPwOmiG5JQMS30cQoIJBShUSaVIpZGWg0J8lsDn4laiIjFCFnkEkHZFd7IEiWLDN4UMaFF", + "LgcwyNmcxUiyks/YgtBpxliwj476NBA0jYKgSMbSjCkmIAXOzEFKz3jCc84UOaPROfJr4N7UN6S8Nmoo", + "ZdmgEDzHkVotA7beQJPeu7O4HhgbUBTRJCoSY7kznGon3sEqtHZqln5UZBkTETejCc3Vk7pOieW3gYJt", + "voJLC7ayG0iuxbptVuAaNTeSIZr1H6apIkwAd9BCFnrMtPxoidH9hOL5H6ySqQw0SORSZueTRF4CESkX", + "OZvqiRNTnOJSCBcqZ3NsutbuSDoP1UZUgFzOETEoJkzMQB0tZFHmRrNIYhm6HoWhbXDd6AsaJHFSBQti", + "lknB/9CvYENhaUGj8hnP4kFKs3yhdUM+kdlc9Z2QwBWHFpM+sanXpscxS/gFg6RnO/x9MqMixumhi7le", + "ApFMEgZ7B6oavPm0KVMZSyg6jdR5eLr0oASm6KXIeZ4wXUVNuDFj3Khj/cvErsvVsuGXGgo7rNzX+rXm", + "GY3OzdDKCc6VXfxakeIcD6sePZtPy0XML3hc0ETpl/2UdoVJtvpFo4zPmIUQRPGB9NhmZ4Pdq/oTQwva", + "7nGb9K38+qb75WoO9AnegCVz0ZCVdXv2svw0zaRuEosJtctKFipZ6HWotZNV6UriTjKnC8h+1sMxn7OY", + "05wlC0IvKE8sNxmyaVV3VddsrLutY8pFh87kJUTpGc5pZvtbR1SggiaLnEeKpEWWSqUVjynKTJvdcSwA", + "sNtDPT5r3c+ZjHGqgFBIq9IheWvfnVeLNC4u3RjH2AYNJEAGhcpWN3GSsCt+ZguATSBigmZcqvroqN6n", + "j5/+/wAAAP//z1irH0VQBQA=", } // GetSwagger returns the content of the embedded swagger specification file diff --git a/api/v3/openapi.yaml b/api/v3/openapi.yaml index e471ae9986..1b43ee28f1 100644 --- a/api/v3/openapi.yaml +++ b/api/v3/openapi.yaml @@ -514,7 +514,7 @@ paths: $ref: '#/components/schemas/ULID' responses: '200': - description: The request has succeeded. + description: The updated invoice after advancing to the next state. content: application/json: schema: @@ -556,7 +556,7 @@ paths: $ref: '#/components/schemas/ULID' responses: '200': - description: The request has succeeded. + description: The updated invoice after sending to the customer. content: application/json: schema: @@ -593,7 +593,7 @@ paths: $ref: '#/components/schemas/ULID' responses: '200': - description: The request has succeeded. + description: The updated invoice after retrying the action. content: application/json: schema: @@ -631,7 +631,9 @@ paths: $ref: '#/components/schemas/ULID' responses: '200': - description: The request has succeeded. + description: |- + The updated invoice with the snapshot quantities for usage based line + items. content: application/json: schema: