From 950bf7eca393f8e91c7495432cc16c432a6b5021 Mon Sep 17 00:00:00 2001 From: archandatta <35818003+archandatta@users.noreply.github.com> Date: Fri, 31 Jul 2026 20:33:17 +0000 Subject: [PATCH] Split platform-induced API calls out of the control telemetry category MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Every documented operation emitted api_call under `control`, so the platform's own traffic — recorder polling, profile save/restore, telemetry publishing — buried the agent's browser actions. Operations now carry `x-telemetry-category` in openapi.yaml and categorygen emits the operation -> category map alongside the event-type map, so a new endpoint without a classification fails generation. Browser-control calls keep emitting api_call under `control`; VM-management calls emit platform_api_call under a new `platform` category, which is opt-in and out of the default set. api_call data also gains an optional `code` field, recorded for executePlaywrightCode and clipped to 8 KB on a rune boundary, so the event says what actually ran. Co-Authored-By: Claude Opus 5 --- server/cmd/api/api/middleware.go | 68 +- server/cmd/api/api/middleware_test.go | 108 +++- server/cmd/api/api/playwright.go | 2 + server/cmd/api/api/telemetry.go | 3 + server/cmd/api/api/telemetry_test.go | 1 + server/e2e/e2e_otlp_storage_test.go | 7 +- server/lib/events/category_gen.go | 68 ++ server/lib/events/category_test.go | 47 ++ server/lib/events/event.go | 4 + server/lib/oapi/oapi.go | 865 ++++++++++++++------------ server/openapi.yaml | 107 +++- server/scripts/categorygen/main.go | 57 +- 12 files changed, 920 insertions(+), 417 deletions(-) create mode 100644 server/lib/events/category_test.go diff --git a/server/cmd/api/api/middleware.go b/server/cmd/api/api/middleware.go index a558199a..eb410eeb 100644 --- a/server/cmd/api/api/middleware.go +++ b/server/cmd/api/api/middleware.go @@ -6,6 +6,7 @@ import ( "net/http" "sync/atomic" "time" + "unicode/utf8" chiMiddleware "github.com/go-chi/chi/v5/middleware" @@ -18,7 +19,33 @@ import ( type telemetryCtxKey struct{} type telemetryRequestCtx struct { - operationID string + operationID string + code string + codeTruncated bool +} + +// maxAPICallCodeBytes caps the source recorded on an api_call event. Playwright +// snippets are small in practice; the cap keeps a pathological one from eating +// the envelope size limit and nulling the whole payload. +const maxAPICallCodeBytes = 8192 + +// RecordTelemetryCode attaches code submitted with the request to its api_call +// event, clipped to maxAPICallCodeBytes. It is a no-op when telemetry is off or +// the request is not one the middleware tracks. +func RecordTelemetryCode(ctx context.Context, code string) { + tc, ok := ctx.Value(telemetryCtxKey{}).(*telemetryRequestCtx) + if !ok { + return + } + if len(code) > maxAPICallCodeBytes { + code, tc.codeTruncated = code[:maxAPICallCodeBytes], true + // Drop a rune the cut landed inside, so the recorded code stays valid + // UTF-8 instead of ending in a replacement character. + for len(code) > 0 && !utf8.ValidString(code) { + code = code[:len(code)-1] + } + } + tc.code = code } // Process-wide toggle for the api_call middleware. Flipped by @@ -35,9 +62,12 @@ func DisableTelemetryMiddleware() { telemetryMiddlewareEnabled.Store(false) } // TelemetryMiddlewareEnabled reports the current state. func TelemetryMiddlewareEnabled() bool { return telemetryMiddlewareEnabled.Load() } -// TelemetryHTTPMiddleware emits a BrowserApiCallEvent per documented operation, -// capturing the final status and wall-clock duration. publish is wired to -// TelemetrySession.Publish; the middleware ignores the returns. +// TelemetryHTTPMiddleware emits one event per documented operation, capturing +// the final status and wall-clock duration. Operations that drive the browser +// emit api_call under control; operations that manage the VM emit +// platform_api_call under platform, per the operation's x-telemetry-category in +// openapi.yaml. publish is wired to TelemetrySession.Publish; the middleware +// ignores the returns. func TelemetryHTTPMiddleware(publish func(events.Event) (events.Envelope, bool)) func(http.Handler) http.Handler { return func(next http.Handler) http.Handler { return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { @@ -55,23 +85,39 @@ func TelemetryHTTPMiddleware(publish func(events.Event) (events.Envelope, bool)) if tc.operationID == "" { return } - data, _ := json.Marshal(oapi.BrowserApiCallEventData{ + eventData := oapi.BrowserApiCallEventData{ RequestId: chiMiddleware.GetReqID(ctx), OperationId: tc.operationID, Status: ww.Status(), DurationMs: float32(time.Since(start).Microseconds()) / 1000.0, - }) + } + if tc.code != "" { + eventData.Code = &tc.code + } + data, _ := json.Marshal(eventData) + eventType, category := apiCallEvent(tc.operationID) publish(events.Event{ - Ts: time.Now().UnixMicro(), - Type: "api_call", - Category: events.Control, - Source: oapi.BrowserEventSource{Kind: oapi.KernelApi}, - Data: data, + Ts: time.Now().UnixMicro(), + Type: eventType, + Category: category, + Source: oapi.BrowserEventSource{Kind: oapi.KernelApi}, + Data: data, + Truncated: tc.codeTruncated, }) }) } } +// apiCallEvent resolves the event type and category for an operation. An +// operation missing from the generated map falls back to platform so an +// unclassified route cannot dilute the control stream. +func apiCallEvent(operationID string) (string, oapi.TelemetryEventCategory) { + if cat, ok := events.CategoryForOperation(operationID); ok && cat == events.Control { + return "api_call", events.Control + } + return "platform_api_call", events.Platform +} + // TelemetryStrictMiddleware records the matched OpenAPI operationId onto the // per-request scratch so TelemetryHTTPMiddleware can include it in the event. func TelemetryStrictMiddleware() oapi.StrictMiddlewareFunc { diff --git a/server/cmd/api/api/middleware_test.go b/server/cmd/api/api/middleware_test.go index 972967f4..ee934dd2 100644 --- a/server/cmd/api/api/middleware_test.go +++ b/server/cmd/api/api/middleware_test.go @@ -5,6 +5,7 @@ import ( "encoding/json" "net/http" "net/http/httptest" + "strings" "sync" "testing" @@ -37,21 +38,23 @@ func (rp *recordingPublisher) snapshot() []events.Event { return out } -// Mirrors the oapi-codegen strict dispatcher: middleware chain -> inner -// handler -> response write. -func fakeStrictHandler(operationID string, status int, mws []oapi.StrictMiddlewareFunc) http.Handler { +// Mirrors the oapi-codegen strict dispatcher, running body inside the handler so +// a test can act on the request context the way a real handler does. +func fakeStrictHandlerFunc(operationID string, status int, body func(ctx context.Context)) http.Handler { inner := oapi.StrictHandlerFunc(func(ctx context.Context, w http.ResponseWriter, r *http.Request, request any) (any, error) { + body(ctx) return nil, nil }) - for _, mw := range mws { - inner = mw(inner, operationID) - } + inner = TelemetryStrictMiddleware()(inner, operationID) return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { _, _ = inner(r.Context(), w, r, nil) w.WriteHeader(status) }) } +// noBody is the handler body for tests that only exercise the middleware. +func noBody(context.Context) {} + // Flips the package-level toggle on for the test, restoring prior state // via t.Cleanup. func withTelemetryMiddlewareEnabled(t *testing.T) { @@ -70,9 +73,9 @@ func withTelemetryMiddlewareEnabled(t *testing.T) { func TestTelemetryMiddleware_EmitsApiCallEventOnDocumentedRoute(t *testing.T) { withTelemetryMiddlewareEnabled(t) rp := &recordingPublisher{} - chain := chiHandler(t, rp.publish, "ProcessExec", http.StatusOK) + chain := chiHandler(t, rp.publish, "ClickMouse", http.StatusOK, noBody) - req := httptest.NewRequest(http.MethodPost, "/process/exec", nil) + req := httptest.NewRequest(http.MethodPost, "/computer/click_mouse", nil) rec := httptest.NewRecorder() chain.ServeHTTP(rec, req) @@ -88,18 +91,97 @@ func TestTelemetryMiddleware_EmitsApiCallEventOnDocumentedRoute(t *testing.T) { OperationID string `json:"operation_id"` Status int `json:"status"` DurationMs float64 `json:"duration_ms"` + Code *string `json:"code"` } require.NoError(t, json.Unmarshal(ev.Data, &data)) assert.NotEmpty(t, data.RequestID, "request_id should be set by chi RequestID middleware") - assert.Equal(t, "ProcessExec", data.OperationID) + assert.Equal(t, "ClickMouse", data.OperationID) assert.Equal(t, http.StatusOK, data.Status) assert.GreaterOrEqual(t, data.DurationMs, 0.0) + assert.Nil(t, data.Code, "code is only recorded by handlers that submit code") +} + +func TestTelemetryMiddleware_EmitsPlatformApiCallForVMOperations(t *testing.T) { + withTelemetryMiddlewareEnabled(t) + rp := &recordingPublisher{} + chain := chiHandler(t, rp.publish, "ProcessExec", http.StatusOK, noBody) + + req := httptest.NewRequest(http.MethodPost, "/process/exec", nil) + chain.ServeHTTP(httptest.NewRecorder(), req) + + captured := rp.snapshot() + require.Len(t, captured, 1) + assert.Equal(t, "platform_api_call", captured[0].Type) + assert.Equal(t, events.Platform, captured[0].Category) +} + +// An operation the generated map does not know about must not land in control, +// which is the stream callers read to see what the agent did. +func TestTelemetryMiddleware_UnknownOperationIsPlatform(t *testing.T) { + withTelemetryMiddlewareEnabled(t) + rp := &recordingPublisher{} + chain := chiHandler(t, rp.publish, "SomeRouteAddedLater", http.StatusOK, noBody) + + chain.ServeHTTP(httptest.NewRecorder(), httptest.NewRequest(http.MethodPost, "/whatever", nil)) + + captured := rp.snapshot() + require.Len(t, captured, 1) + assert.Equal(t, events.Platform, captured[0].Category) +} + +func TestTelemetryMiddleware_RecordsSubmittedCode(t *testing.T) { + withTelemetryMiddlewareEnabled(t) + rp := &recordingPublisher{} + code := "await page.goto('https://example.com')" + chain := chiHandler(t, rp.publish, "ExecutePlaywrightCode", http.StatusOK, func(ctx context.Context) { + RecordTelemetryCode(ctx, code) + }) + + chain.ServeHTTP(httptest.NewRecorder(), httptest.NewRequest(http.MethodPost, "/playwright/execute", nil)) + + captured := rp.snapshot() + require.Len(t, captured, 1) + assert.Equal(t, events.Control, captured[0].Category) + assert.False(t, captured[0].Truncated) + var data struct { + Code *string `json:"code"` + } + require.NoError(t, json.Unmarshal(captured[0].Data, &data)) + require.NotNil(t, data.Code) + assert.Equal(t, code, *data.Code) +} + +func TestTelemetryMiddleware_ClipsOversizedCode(t *testing.T) { + withTelemetryMiddlewareEnabled(t) + rp := &recordingPublisher{} + // Ends on a multi-byte rune straddling the cap so the clip has to back off. + oversized := strings.Repeat("x", maxAPICallCodeBytes-1) + strings.Repeat("é", 10) + chain := chiHandler(t, rp.publish, "ExecutePlaywrightCode", http.StatusOK, func(ctx context.Context) { + RecordTelemetryCode(ctx, oversized) + }) + + chain.ServeHTTP(httptest.NewRecorder(), httptest.NewRequest(http.MethodPost, "/playwright/execute", nil)) + + captured := rp.snapshot() + require.Len(t, captured, 1) + assert.True(t, captured[0].Truncated) + var data struct { + Code string `json:"code"` + } + require.NoError(t, json.Unmarshal(captured[0].Data, &data)) + assert.Equal(t, strings.Repeat("x", maxAPICallCodeBytes-1), data.Code) +} + +// RecordTelemetryCode is called from handlers that also serve requests the +// middleware is not tracking, so it must tolerate a bare context. +func TestRecordTelemetryCode_NoopWithoutRequestScratch(t *testing.T) { + RecordTelemetryCode(context.Background(), "await page.goto('https://example.com')") } func TestTelemetryMiddleware_CapturesNonOKStatus(t *testing.T) { withTelemetryMiddlewareEnabled(t) rp := &recordingPublisher{} - chain := chiHandler(t, rp.publish, "ProcessExec", http.StatusInternalServerError) + chain := chiHandler(t, rp.publish, "ProcessExec", http.StatusInternalServerError, noBody) req := httptest.NewRequest(http.MethodPost, "/process/exec", nil) rec := httptest.NewRecorder() @@ -131,7 +213,7 @@ func TestTelemetryMiddleware_SkipsUndocumentedRoutes(t *testing.T) { func TestTelemetryMiddleware_ShortCircuitsWhenDisabled(t *testing.T) { DisableTelemetryMiddleware() rp := &recordingPublisher{} - chain := chiHandler(t, rp.publish, "ProcessExec", http.StatusOK) + chain := chiHandler(t, rp.publish, "ProcessExec", http.StatusOK, noBody) req := httptest.NewRequest(http.MethodPost, "/process/exec", nil) rec := httptest.NewRecorder() @@ -142,9 +224,9 @@ func TestTelemetryMiddleware_ShortCircuitsWhenDisabled(t *testing.T) { // Builds the same middleware stack as main.go: RequestID -> HTTP middleware -> // strict dispatch -> inner handler. -func chiHandler(t *testing.T, publish func(events.Event) (events.Envelope, bool), operationID string, status int) http.Handler { +func chiHandler(t *testing.T, publish func(events.Event) (events.Envelope, bool), operationID string, status int, body func(ctx context.Context)) http.Handler { t.Helper() - inner := fakeStrictHandler(operationID, status, []oapi.StrictMiddlewareFunc{TelemetryStrictMiddleware()}) + inner := fakeStrictHandlerFunc(operationID, status, body) telemetry := TelemetryHTTPMiddleware(publish)(inner) return chiMiddleware.RequestID(telemetry) } diff --git a/server/cmd/api/api/playwright.go b/server/cmd/api/api/playwright.go index de7368ab..395a45ed 100644 --- a/server/cmd/api/api/playwright.go +++ b/server/cmd/api/api/playwright.go @@ -144,6 +144,8 @@ func (s *ApiService) ExecutePlaywrightCode(ctx context.Context, request oapi.Exe }, nil } + RecordTelemetryCode(ctx, request.Body.Code) + timeout := 60 * time.Second if request.Body.TimeoutSec != nil && *request.Body.TimeoutSec > 0 { timeout = time.Duration(*request.Body.TimeoutSec) * time.Second diff --git a/server/cmd/api/api/telemetry.go b/server/cmd/api/api/telemetry.go index 52dc6b1f..a31fcf40 100644 --- a/server/cmd/api/api/telemetry.go +++ b/server/cmd/api/api/telemetry.go @@ -221,6 +221,7 @@ func categoryFields(b *oapi.BrowserTelemetryCategoriesConfig) []categoryField { {events.Page, b.Page}, {events.Interaction, b.Interaction}, {events.Control, b.Control}, + {events.Platform, b.Platform}, {events.Connection, b.Connection}, {events.System, b.System}, {events.Screenshot, b.Screenshot}, @@ -332,6 +333,7 @@ func disabledConfig() oapi.BrowserTelemetryConfig { Page: off(), Interaction: off(), Control: off(), + Platform: off(), Connection: off(), System: off(), Screenshot: off(), @@ -363,6 +365,7 @@ func telemetryConfigToOAPI(cfg telemetry.TelemetryConfig) oapi.BrowserTelemetryC Page: enabled(events.Page), Interaction: enabled(events.Interaction), Control: enabled(events.Control), + Platform: enabled(events.Platform), Connection: enabled(events.Connection), System: enabled(events.System), Screenshot: enabled(events.Screenshot), diff --git a/server/cmd/api/api/telemetry_test.go b/server/cmd/api/api/telemetry_test.go index 5b7261cf..e5a7cbeb 100644 --- a/server/cmd/api/api/telemetry_test.go +++ b/server/cmd/api/api/telemetry_test.go @@ -29,6 +29,7 @@ func allCategoriesDisabled() *oapi.BrowserTelemetryCategoriesConfig { Page: off(), Interaction: off(), Control: off(), + Platform: off(), Connection: off(), System: off(), Screenshot: off(), diff --git a/server/e2e/e2e_otlp_storage_test.go b/server/e2e/e2e_otlp_storage_test.go index afd703cb..8610e07d 100644 --- a/server/e2e/e2e_otlp_storage_test.go +++ b/server/e2e/e2e_otlp_storage_test.go @@ -99,7 +99,8 @@ func (c *otlpMockCollector) snapshot() (auths, instanceName, eventNames []string } // enableControlExport turns on the control category (so api_call events flow) -// and OTLP export, then makes a few API calls to generate exportable events. +// and OTLP export, then makes a few browser-control calls to generate +// exportable events. func enableControlExport(t *testing.T, ctx context.Context, client *instanceoapi.ClientWithResponses) { t.Helper() tr := true @@ -113,9 +114,9 @@ func enableControlExport(t *testing.T, ctx context.Context, client *instanceoapi }) require.NoError(t, err) require.Equal(t, http.StatusCreated, resp.StatusCode(), "put telemetry: %s", string(resp.Body)) - // Each API call emits an api_call (control) event, which OTLP exports. + // Browser-control calls emit api_call (control) events, which OTLP exports. for i := 0; i < 3; i++ { - _, _ = client.GetTelemetryWithResponse(ctx) + _, _ = client.TakeScreenshotWithResponse(ctx, instanceoapi.TakeScreenshotJSONRequestBody{}) time.Sleep(50 * time.Millisecond) } } diff --git a/server/lib/events/category_gen.go b/server/lib/events/category_gen.go index b02132f9..3f964ba6 100644 --- a/server/lib/events/category_gen.go +++ b/server/lib/events/category_gen.go @@ -34,6 +34,7 @@ var categoryByType = map[string]oapi.TelemetryEventCategory{ "page_navigation": oapi.TelemetryEventCategory("page"), "page_navigation_settled": oapi.TelemetryEventCategory("page"), "page_tab_opened": oapi.TelemetryEventCategory("page"), + "platform_api_call": oapi.TelemetryEventCategory("platform"), "service_crashed": oapi.TelemetryEventCategory("system"), "system_oom_kill": oapi.TelemetryEventCategory("system"), } @@ -44,3 +45,70 @@ func CategoryForType(eventType string) (oapi.TelemetryEventCategory, bool) { c, ok := categoryByType[eventType] return c, ok } + +var categoryByOperationID = map[string]oapi.TelemetryEventCategory{ + "BatchComputerAction": oapi.TelemetryEventCategory("control"), + "ChromiumConfigure": oapi.TelemetryEventCategory("platform"), + "ClickMouse": oapi.TelemetryEventCategory("control"), + "CreateDirectory": oapi.TelemetryEventCategory("platform"), + "DeleteDirectory": oapi.TelemetryEventCategory("platform"), + "DeleteFile": oapi.TelemetryEventCategory("platform"), + "DeleteRecording": oapi.TelemetryEventCategory("platform"), + "DisableScaleToZero": oapi.TelemetryEventCategory("platform"), + "DownloadDirZip": oapi.TelemetryEventCategory("platform"), + "DownloadDirZstd": oapi.TelemetryEventCategory("platform"), + "DownloadRecording": oapi.TelemetryEventCategory("platform"), + "DragMouse": oapi.TelemetryEventCategory("control"), + "EnableScaleToZero": oapi.TelemetryEventCategory("platform"), + "ExecutePlaywrightCode": oapi.TelemetryEventCategory("control"), + "FileInfo": oapi.TelemetryEventCategory("platform"), + "GetMousePosition": oapi.TelemetryEventCategory("control"), + "GetTelemetry": oapi.TelemetryEventCategory("platform"), + "ListFiles": oapi.TelemetryEventCategory("platform"), + "ListRecorders": oapi.TelemetryEventCategory("platform"), + "LogsStream": oapi.TelemetryEventCategory("platform"), + "MarkRecording": oapi.TelemetryEventCategory("platform"), + "MoveMouse": oapi.TelemetryEventCategory("control"), + "MovePath": oapi.TelemetryEventCategory("platform"), + "PatchChromiumFlags": oapi.TelemetryEventCategory("platform"), + "PatchChromiumPolicies": oapi.TelemetryEventCategory("platform"), + "PatchDisplay": oapi.TelemetryEventCategory("platform"), + "PatchTelemetry": oapi.TelemetryEventCategory("platform"), + "PressKey": oapi.TelemetryEventCategory("control"), + "ProcessExec": oapi.TelemetryEventCategory("platform"), + "ProcessKill": oapi.TelemetryEventCategory("platform"), + "ProcessResize": oapi.TelemetryEventCategory("platform"), + "ProcessSpawn": oapi.TelemetryEventCategory("platform"), + "ProcessStatus": oapi.TelemetryEventCategory("platform"), + "ProcessStdin": oapi.TelemetryEventCategory("platform"), + "ProcessStdoutStream": oapi.TelemetryEventCategory("platform"), + "PublishTelemetryEvent": oapi.TelemetryEventCategory("platform"), + "PutTelemetry": oapi.TelemetryEventCategory("platform"), + "ReadClipboard": oapi.TelemetryEventCategory("control"), + "ReadFile": oapi.TelemetryEventCategory("platform"), + "Scroll": oapi.TelemetryEventCategory("control"), + "SetCursor": oapi.TelemetryEventCategory("control"), + "SetFilePermissions": oapi.TelemetryEventCategory("platform"), + "StartFsWatch": oapi.TelemetryEventCategory("platform"), + "StartRecording": oapi.TelemetryEventCategory("platform"), + "StopFsWatch": oapi.TelemetryEventCategory("platform"), + "StopRecording": oapi.TelemetryEventCategory("platform"), + "StreamFsEvents": oapi.TelemetryEventCategory("platform"), + "StreamTelemetryEvents": oapi.TelemetryEventCategory("platform"), + "TakeScreenshot": oapi.TelemetryEventCategory("control"), + "TypeText": oapi.TelemetryEventCategory("control"), + "UploadExtensionsAndRestart": oapi.TelemetryEventCategory("platform"), + "UploadFiles": oapi.TelemetryEventCategory("platform"), + "UploadZip": oapi.TelemetryEventCategory("platform"), + "UploadZstd": oapi.TelemetryEventCategory("platform"), + "WriteClipboard": oapi.TelemetryEventCategory("control"), + "WriteFile": oapi.TelemetryEventCategory("platform"), +} + +// CategoryForOperation returns the category an api_call event carries for +// the given operation, named as oapi-codegen names it (ProcessExec for +// operationId processExec). ok is false for an unknown operation. +func CategoryForOperation(operationID string) (oapi.TelemetryEventCategory, bool) { + c, ok := categoryByOperationID[operationID] + return c, ok +} diff --git a/server/lib/events/category_test.go b/server/lib/events/category_test.go new file mode 100644 index 00000000..8745723f --- /dev/null +++ b/server/lib/events/category_test.go @@ -0,0 +1,47 @@ +package events + +import ( + "testing" + + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" + + oapi "github.com/kernel/kernel-images/server/lib/oapi" +) + +// The api_call/platform_api_call split is only meaningful if the operation map +// and the event-type map agree on which category each type carries. +func TestCategoryMapsAgreeOnAPICallSplit(t *testing.T) { + cat, ok := CategoryForType("api_call") + require.True(t, ok) + assert.Equal(t, Control, cat) + + cat, ok = CategoryForType("platform_api_call") + require.True(t, ok) + assert.Equal(t, Platform, cat) +} + +func TestCategoryForOperation(t *testing.T) { + require.NotEmpty(t, categoryByOperationID, "generator produced no operations") + + // Sampled rather than exhaustive: the spec is the source of truth for the + // full mapping, and restating all of it here would just be a second copy. + control, ok := CategoryForOperation("ExecutePlaywrightCode") + require.True(t, ok) + assert.Equal(t, Control, control) + + platform, ok := CategoryForOperation("StartRecording") + require.True(t, ok) + assert.Equal(t, Platform, platform) + + _, ok = CategoryForOperation("NotAnOperation") + assert.False(t, ok) +} + +// Every operation must land in one of the two api_call categories: any other +// category would produce an event type nothing publishes. +func TestOperationCategoriesAreAPICallCategories(t *testing.T) { + for operationID, cat := range categoryByOperationID { + assert.Contains(t, []oapi.TelemetryEventCategory{Control, Platform}, cat, "operation %s", operationID) + } +} diff --git a/server/lib/events/event.go b/server/lib/events/event.go index ab4f4270..496594a6 100644 --- a/server/lib/events/event.go +++ b/server/lib/events/event.go @@ -18,6 +18,7 @@ const ( Page = oapi.TelemetryEventCategory("page") Interaction = oapi.TelemetryEventCategory("interaction") Control = oapi.TelemetryEventCategory("control") + Platform = oapi.TelemetryEventCategory("platform") Connection = oapi.TelemetryEventCategory("connection") System = oapi.TelemetryEventCategory("system") Screenshot = oapi.TelemetryEventCategory("screenshot") @@ -34,6 +35,7 @@ var UserCategories = []oapi.TelemetryEventCategory{ Page, Interaction, Control, + Platform, Connection, System, Screenshot, @@ -44,6 +46,8 @@ var UserCategories = []oapi.TelemetryEventCategory{ // per-category settings: the lightweight operational signals. CDP categories // (console/network/page/interaction) and screenshot are excluded so the default // never starts the CDP collector or emits high-volume streams; they are opt-in. +// Platform is excluded too: those calls are mostly platform-induced bookkeeping +// (recording, profile save) that drowns out the agent's own actions. var DefaultCategories = []oapi.TelemetryEventCategory{ Control, Connection, diff --git a/server/lib/oapi/oapi.go b/server/lib/oapi/oapi.go index 038414a3..75ef85b6 100644 --- a/server/lib/oapi/oapi.go +++ b/server/lib/oapi/oapi.go @@ -1028,6 +1028,36 @@ func (e BrowserPageTabOpenedEventType) Valid() bool { } } +// Defines values for BrowserPlatformApiCallEventCategory. +const ( + Platform BrowserPlatformApiCallEventCategory = "platform" +) + +// Valid indicates whether the value is a known member of the BrowserPlatformApiCallEventCategory enum. +func (e BrowserPlatformApiCallEventCategory) Valid() bool { + switch e { + case Platform: + return true + default: + return false + } +} + +// Defines values for BrowserPlatformApiCallEventType. +const ( + PlatformApiCall BrowserPlatformApiCallEventType = "platform_api_call" +) + +// Valid indicates whether the value is a known member of the BrowserPlatformApiCallEventType enum. +func (e BrowserPlatformApiCallEventType) Valid() bool { + switch e { + case PlatformApiCall: + return true + default: + return false + } +} + // Defines values for BrowserServiceCrashedEventCategory. const ( BrowserServiceCrashedEventCategorySystem BrowserServiceCrashedEventCategory = "system" @@ -1449,6 +1479,7 @@ const ( PublishEventRequestCategoryMonitor PublishEventRequestCategory = "monitor" PublishEventRequestCategoryNetwork PublishEventRequestCategory = "network" PublishEventRequestCategoryPage PublishEventRequestCategory = "page" + PublishEventRequestCategoryPlatform PublishEventRequestCategory = "platform" PublishEventRequestCategoryScreenshot PublishEventRequestCategory = "screenshot" PublishEventRequestCategorySystem PublishEventRequestCategory = "system" ) @@ -1472,6 +1503,8 @@ func (e PublishEventRequestCategory) Valid() bool { return true case PublishEventRequestCategoryPage: return true + case PublishEventRequestCategoryPlatform: + return true case PublishEventRequestCategoryScreenshot: return true case PublishEventRequestCategorySystem: @@ -1491,6 +1524,7 @@ const ( TelemetryEventCategoryMonitor TelemetryEventCategory = "monitor" TelemetryEventCategoryNetwork TelemetryEventCategory = "network" TelemetryEventCategoryPage TelemetryEventCategory = "page" + TelemetryEventCategoryPlatform TelemetryEventCategory = "platform" TelemetryEventCategoryScreenshot TelemetryEventCategory = "screenshot" TelemetryEventCategorySystem TelemetryEventCategory = "system" ) @@ -1514,6 +1548,8 @@ func (e TelemetryEventCategory) Valid() bool { return true case TelemetryEventCategoryPage: return true + case TelemetryEventCategoryPlatform: + return true case TelemetryEventCategoryScreenshot: return true case TelemetryEventCategorySystem: @@ -1586,7 +1622,7 @@ type BatchComputerActionRequest struct { Actions []ComputerAction `json:"actions"` } -// BrowserApiCallEvent An HTTP call handled by the kernel-images-api server. +// BrowserApiCallEvent A call that drives the browser, handled by the kernel-images-api server: computer-control actions, Playwright code execution, screenshots and clipboard access. Calls that manage the VM instead emit `platform_api_call`. type BrowserApiCallEvent struct { Category BrowserApiCallEventCategory `json:"category"` @@ -1612,10 +1648,13 @@ type BrowserApiCallEventType string // BrowserApiCallEventData Per-call payload for `api_call` events. type BrowserApiCallEventData struct { + // Code Source submitted to `executePlaywrightCode`, clipped to 8192 characters (`truncated` is set when clipped). Absent for every other operation. + Code *string `json:"code,omitempty"` + // DurationMs Wall-clock duration of the handler in milliseconds. DurationMs float32 `json:"duration_ms"` - // OperationId OpenAPI operationId of the matched route (e.g. `processExec`, `takeScreenshot`). + // OperationId Matched route's operation, named as the server names its handler (e.g. `ProcessExec`, `TakeScreenshot`). OperationId string `json:"operation_id"` // RequestId Per-request identifier from the kernel-images-api request middleware. @@ -2947,6 +2986,30 @@ type BrowserPageTabOpenedEventData struct { Url string `json:"url"` } +// BrowserPlatformApiCallEvent A call that manages the browser VM rather than driving the browser, handled by the kernel-images-api server: recording lifecycle, filesystem and process management, telemetry and browser configuration. These are mostly platform-induced (e.g. profile save, replay capture) rather than agent actions. +type BrowserPlatformApiCallEvent struct { + Category BrowserPlatformApiCallEventCategory `json:"category"` + + // Data Per-call payload for `api_call` events. + Data *BrowserApiCallEventData `json:"data,omitempty"` + + // Source Provenance metadata identifying which producer emitted the event. + Source BrowserEventSource `json:"source"` + + // Truncated True if the data field was truncated due to size limits. + Truncated *bool `json:"truncated,omitempty"` + + // Ts Event timestamp in Unix microseconds. + Ts int64 `json:"ts"` + Type BrowserPlatformApiCallEventType `json:"type"` +} + +// BrowserPlatformApiCallEventCategory defines model for BrowserPlatformApiCallEvent.Category. +type BrowserPlatformApiCallEventCategory string + +// BrowserPlatformApiCallEventType defines model for BrowserPlatformApiCallEvent.Type. +type BrowserPlatformApiCallEventType string + // BrowserServiceCrashedEvent A managed service exited unexpectedly. Intentional stops (e.g. operator-initiated shutdown) do not produce this event — only unexpected exits and terminal restart-give-up transitions do. type BrowserServiceCrashedEvent struct { Category BrowserServiceCrashedEventCategory `json:"category"` @@ -3069,7 +3132,7 @@ type BrowserTelemetryCategoriesConfig struct { // Console Console output (log, warn, error) and uncaught exceptions. Console *BrowserTelemetryCategoryConfig `json:"console,omitempty"` - // Control Agent-driven actions against the browser, such as inbound calls to the kernel-images-api server. + // Control Agent-driven actions against the browser — computer-control calls, Playwright code execution, screenshots and clipboard access. Control *BrowserTelemetryCategoryConfig `json:"control,omitempty"` // Interaction User interaction events (clicks, keydowns, scroll). @@ -3081,6 +3144,9 @@ type BrowserTelemetryCategoriesConfig struct { // Page Page lifecycle events (navigation, load, layout shifts, LCP). Page *BrowserTelemetryCategoryConfig `json:"page,omitempty"` + // Platform Calls that manage the VM rather than drive the browser (recording, filesystem, process, telemetry and browser configuration). Mostly platform-induced; off by default and opt-in. + Platform *BrowserTelemetryCategoryConfig `json:"platform,omitempty"` + // Screenshot Periodic base64-encoded viewport screenshots. High volume; off by default and opt-in. Screenshot *BrowserTelemetryCategoryConfig `json:"screenshot,omitempty"` @@ -3094,7 +3160,7 @@ type BrowserTelemetryCategoryConfig struct { Enabled *bool `json:"enabled,omitempty"` } -// BrowserTelemetryConfig Telemetry configuration for a browser. Selection is opt-in. Omit the browser key (or send an empty object) to capture the default set: lightweight operational signals (control, connection, system, captcha). Within `browser`, only the categories you set enabled: true are captured; anything omitted is off. The CDP categories (console, network, page, interaction) and `screenshot` are off by default and must be opted into. A `browser` config with nothing enabled clears the telemetry configuration. The `monitor` category (CDP collector health) is not configurable here; it flows automatically whenever a CDP category is captured. +// BrowserTelemetryConfig Telemetry configuration for a browser. Selection is opt-in. Omit the browser key (or send an empty object) to capture the default set: lightweight operational signals (control, connection, system, captcha). Within `browser`, only the categories you set enabled: true are captured; anything omitted is off. The CDP categories (console, network, page, interaction), `screenshot` and `platform` are off by default and must be opted into. A `browser` config with nothing enabled clears the telemetry configuration. The `monitor` category (CDP collector health) is not configurable here; it flows automatically whenever a CDP category is captured. type BrowserTelemetryConfig struct { // Browser Per-category telemetry capture settings for browser events. Browser *BrowserTelemetryCategoriesConfig `json:"browser,omitempty"` @@ -3755,7 +3821,7 @@ type TelemetryState struct { // AppliedAt Wall-clock time at which the current configuration was applied. Omitted when telemetry is not configured. AppliedAt *time.Time `json:"applied_at,omitempty"` - // Config Telemetry configuration for a browser. Selection is opt-in. Omit the browser key (or send an empty object) to capture the default set: lightweight operational signals (control, connection, system, captcha). Within `browser`, only the categories you set enabled: true are captured; anything omitted is off. The CDP categories (console, network, page, interaction) and `screenshot` are off by default and must be opted into. A `browser` config with nothing enabled clears the telemetry configuration. The `monitor` category (CDP collector health) is not configurable here; it flows automatically whenever a CDP category is captured. + // Config Telemetry configuration for a browser. Selection is opt-in. Omit the browser key (or send an empty object) to capture the default set: lightweight operational signals (control, connection, system, captcha). Within `browser`, only the categories you set enabled: true are captured; anything omitted is off. The CDP categories (console, network, page, interaction), `screenshot` and `platform` are off by default and must be opted into. A `browser` config with nothing enabled clears the telemetry configuration. The `monitor` category (CDP collector health) is not configurable here; it flows automatically whenever a CDP category is captured. Config BrowserTelemetryConfig `json:"config"` // Seq Process-monotonic sequence number of the last published event. Does not reset across configuration changes. @@ -4742,6 +4808,34 @@ func (t *KnownBrowserTelemetryEvent) MergeBrowserApiCallEvent(v BrowserApiCallEv return err } +// AsBrowserPlatformApiCallEvent returns the union data inside the KnownBrowserTelemetryEvent as a BrowserPlatformApiCallEvent +func (t KnownBrowserTelemetryEvent) AsBrowserPlatformApiCallEvent() (BrowserPlatformApiCallEvent, error) { + var body BrowserPlatformApiCallEvent + err := json.Unmarshal(t.union, &body) + return body, err +} + +// FromBrowserPlatformApiCallEvent overwrites any union data inside the KnownBrowserTelemetryEvent as the provided BrowserPlatformApiCallEvent +func (t *KnownBrowserTelemetryEvent) FromBrowserPlatformApiCallEvent(v BrowserPlatformApiCallEvent) error { + v.Type = "platform_api_call" + b, err := json.Marshal(v) + t.union = b + return err +} + +// MergeBrowserPlatformApiCallEvent performs a merge with any union data inside the KnownBrowserTelemetryEvent, using the provided BrowserPlatformApiCallEvent +func (t *KnownBrowserTelemetryEvent) MergeBrowserPlatformApiCallEvent(v BrowserPlatformApiCallEvent) error { + v.Type = "platform_api_call" + b, err := json.Marshal(v) + if err != nil { + return err + } + + merged, err := runtime.JSONMerge(t.union, b) + t.union = merged + return err +} + // AsBrowserCdpConnectEvent returns the union data inside the KnownBrowserTelemetryEvent as a BrowserCdpConnectEvent func (t KnownBrowserTelemetryEvent) AsBrowserCdpConnectEvent() (BrowserCdpConnectEvent, error) { var body BrowserCdpConnectEvent @@ -5010,6 +5104,8 @@ func (t KnownBrowserTelemetryEvent) ValueByDiscriminator() (interface{}, error) return t.AsBrowserPageNavigationSettledEvent() case "page_tab_opened": return t.AsBrowserPageTabOpenedEvent() + case "platform_api_call": + return t.AsBrowserPlatformApiCallEvent() case "service_crashed": return t.AsBrowserServiceCrashedEvent() case "system_oom_kill": @@ -19258,382 +19354,389 @@ func (sh *strictHandler) StreamTelemetryEvents(w http.ResponseWriter, r *http.Re // Base64 encoded, gzipped, json marshaled Swagger object var swaggerSpec = []string{ - "H4sIAAAAAAAC/+y9iXIbR5Yo+iv58CbC5AwAUrbcc1uKiRc0KbU51sJHUvZMN/2AZNUBkM2qzOrMLJCw", - "QxP3I+4X3i95kedk1gJkYeEiyXMVMTEtE5XrWfOsv/cSlRdKgrSm9+L3ngZTKGkA/+MHnp7DP0ow9pXW", - "Srs/JUpakNb9kxdFJhJuhZIHfzdKur+ZZAY5d//6Jw2T3ove/31Qz39Av5oDmu3jx4/9Xgom0aJwk/Re", - "uAWZX7H3sd87VnKSieRTrR6Wc0ufSgta8uwTLR2WYxeg56CZ/7Dfe6fsa1XK9BPt452yDNfrud/854QK", - "Npkdq7woLeijxH0eAOV2kqbC/YlnZ1oVoK1wCDThmYHlFY7YtZuKqQlL/HSM43yGWcXgDpLSAjNucmkF", - "z7LFsNfvFY15f+/5Ae6f7dnf6xQ0pCwTxrolVmceslf4D6EkM1YVhinJ7AzYRGhjGbibcQsKC7nZdI/t", - "C3HwyoU8pZHP+j27KKD3ose15gu8UA3/KIWGtPfib9UZfq2+U9d/B8K+H7S6NaCPCnHMs+zV3AN86SYl", - "+/Hy8owlPMvYjMs0g5RdL/AwN6AlZAOR8ymYAS8EM4hYq1eZcAtTpRfu3yDL3G3N4ZhWWWNrxmohp25r", - "Kbcb0Suy/RM3zKGUKnUCW06AIy9oxMd+z+pSuu2mq3dxqUtgYoJndztkEwFZym65YdUolpbgEMGI34Bl", - "IhfWuOvwJ7xWKgOOMLQRxMKtMCtyMJbnBROSfZDijuUi0cpAomSKs02UzrntvegJaf/0vJ5eSAtTQJKm", - "v9S3zQsxcjCMXPcSylgTJuzXcKvudEtEOvEA3IFmz0APEMsKvsgUT9lEaTYO+x4zcPOaVdxKS43caZRH", - "bvQXnmWDJFPJDQvfOYp1ECRk1u6Sc5FlonG//oSyzK/pNt16tIiI4MX7AuTR2SmrvjpNwyK5Y0OQMq0c", - "v9mD4XTIxoVWCRjjWMS4z8aW38BFogGkmSk73m/soKYITXwwur67Of87E6ljaBMBmk20yjvoNHydizTN", - "4JZriC5qLLdl5FaRIwQhzugrlqi0OUuFi0vo1TjI0r1W6/VbMF2DcQ7dLixPbla3eHxyxs5L6WhpiJ9c", - "ap4A01BoMO6K5BTv5t/5nF/gOGJxxn3LuMUf3Whk8JKwb8heO4o3rDTA3AqS526iREn3MwoBze0MNLMz", - "LpmR/AZGCTfIEhAXcN7jmVY5sBOYXyqVGXamlVWJytit0MCIuodXMsJGs+y15jlsIZTwNBP8uM8c9ulc", - "GUsCqCV6lpZQWZnLd4T5K4v8FbQaXHMDKaMPGdEIuxV2JkjEZUJG8aDfm5QSxdE7nsPq3A1IhA/d/UKf", - "Kc0gL+yCEWYiY+BSyUWuSlN9bKIo7HazxWncZ5Gz0Nfx09Bvp2kc9+i/G+QY3V2ps9XhH87fuCO7swc2", - "4mebiCxGqEsU1rrmxj5pudaV9NvwjpFaW71YYtqrnJCYPcv4NWQIKNw+EpVFCiQeyM1CJizhpYE4vyu4", - "Dgpolr2f9F78bSthXnOEj7+uCBicsrUZxCTcCv7VDFcus0FyaxlRYZMZv1DZHM7BlJntUqdYQp8y475l", - "3FqH2kwDRznBmSNU4a5QlTZROWypTNGsD1WmOs7xVa/q1Kv8xY8QnCONd/aEOtY6AO2ubgXsa2lcsRN1", - "a1/h63AvS5zQI/scZKo0m/BcZIuhk3dpmYA2TLobzxxMC63mIgU9MAUkYiISZrm5QS5omJBWMTsThhmw", - "Lxi4h2yhhQE251pwaY3jlBoCcSUqy3hhIAwEodkctHEy5bpMbsCyvfm37IDNv9vvMy5TxuXCcf0pk8qy", - "RM1RlhKvcpd7opwgemv9gfqsyLiQ7P3x+T4TxqkVSjss5YaNlVMAxiS/A5rMAoE6PAh3Nv+2/Z/fOaQo", - "tTRWZA4zpgDWvX37PZwyTty7ar+oFRLzMZZr64gqxnNWdGB8tI6clre6EOJjA3T4LWqE7uE74SIrdaX+", - "vjo/f38+Oj46uzz+8Wj04d3F+zc/H/3w5tV4f8iOrp1y5gaZMnFK8k566eXyOdjYTzN+QWfWTIO7YmS1", - "peHXGbgf8KU+ZGO/09jX0h9qzwCwcX0Zbtdjx1pUaetxqUgRk2h8U6VwAgX0N4bdcmHZdZlOwQ7ZmF9z", - "mSoJ6fiF/4QlXCaQufe2F6MFnwKTfC6myBH5LV84DX6Aa7bxzR/b8TQ6krtG2mSv36sWi6KUo7voO8ND", - "mRsjpu5OGsoNe1/wf5TQd5rxpCTJb8rCUQVzPNYMNExAg0wgDtJbuDbCwmimTERs/qhIqa1u4XYGGvx9", - "Esk7aYEXka6dv+B2FnlBcTvbfn72/5agK20U7pKsTKPLrugSDV55j9dOWhwrKSGx3bYauPMmviQTjpCI", - "5JLSWJWDZhcnP/XZWcYXt1pMZ7bPzsqiAAug990jxs0NKSOWiQ+cX+D6QiG/LLS6W5AZSxj289utjTxu", - "Ure/GKp9VShWFYq0GPlbe0o9Ii1OhEl2Rae0GgNpbV/YgCjsjAt6VeHXIs8hFdxCtmCFhgRSR0XjxrnH", - "wVpq3BPIWA08fxR020UTXrmgr0rwWpytUeOTou09Nd96t0vKb+skj290rBF0K7tjDsbwKYwSVcYolJ7t", - "bm5Hgv5jp41mfOEUBJS8kXVBoI0qFZr+FjdwaOAm9sj/ZbZYnhOkE4BsTGxilGTKOCUKvyLOIaSwAnGY", - "/qiM087Kgqh7lMy4nKLyg7YxUeZMA+qnkJKOAwa1d6ero5RGLmOVBpaqW8mMaq6WqDJL3XvAw5hPuZCG", - "jHoSbllYt7kFVOnGL6rfWCqcJqnDvbKizAtSAumsSlq4s6NKTfMHDrZV/ztScK3K7dlFIZyCt/DOEmZm", - "pXVH2G9rcM2r7PV7yzfV/BPuCW05SzvaTIlNPF5GtwoD1hGkkkZlgK6+TpPHNX3rbsR97BVppZlja+V0", - "ZptWWLhLoCCkIpPrq1zYWtzcKieErJCJRaQnnmFIvKRigkqmJQ5qZrwAM6zswH79o7PTY07A8H8Z+vcK", - "zzKz71DLvU4Ny2AOWZ+5O+0zrqeGnopoKhqhAameu9r25Uw7fNyrzlb90pya5syEhL63pPb9UUalziLr", - "eMOze1N4j6x7unhNjUYyroFxfEDFjcdReenO/2BhuYwFX2Vlt6yku/JE+4SiMgqTXe2pOPKY+ErvY3/Z", - "W+CIIkLxWVbROtfTMnczs0SBTuh1QWc1Q3ZGzhimZLZwby7pUdlTexfhtvwXq+/XJYs10VfEONXyYLQs", - "/o33X82PEL2Qurfe+BJXiMtZZDNxL0K4RTeIzXnmXtg8u+ULw67IIHPVe9AtRv0lq3t503CPfL6Lqhlk", - "h9NkxVnC7AxdeRpu23t8hI21zFGBUW9tZ6/cFP0e0taqyaPMuRxo4ClyepJQXhSRTrcsVm9R6UmFKTK+", - "YMIO2WtV/Uoibm+fhFy/EYwSKLRJoNyTKE0REWV9r4TBRNyhsKL9eQWiz9DscNX7EEYiG3rBrpXKr3pO", - "9Dd+2xPSCcZcGNhnl4sC/Md3THiBV/n4rnok2TbwTHehq6zx1xXm+EZNt1ZaMjUljaTWGjI17Vf3K+RE", - "1f91y7XsM7DJcH/4GSRxONhXObxRDmdq+vRSuAWPL0sG7yRK14iqTiXbzdFnBTcGH39aldMZK+VEZBad", - "LMhuKSJi6A3rY/SpqNIbI1sqk3+SM/eeA56+ZDzLGPpH2LLENE5VBq6Zk1FDdgFkqjIFJJVrelJmGXM4", - "EWUsT8TbXyPjXQbPKnQ2m5QJIP0tWF4Li1Z25D/yHC48XZHo6ni/wBJzJYV1LzjpREWWuVsdBOnpLSbs", - "NDgHSFhZrqdg+xSRQu8b78nAp16hkpmj7tuZ8DEytBOVJKV27+3IgwanijoqHJTx12Y4VMMHQ5uJ6z+K", - "p6A7Z01VQrCi7xrz95lTKNB1BTyZNU4XXUfy+cjAP1ZXeaukskp6G4GQiXuEo2Oyvi6KW02CStanz9y+", - "IK02YFUxQPRojoxewhbc05tfOu8lmGea4WeewmidhrUoeh/0VXT+gJt+osYSe8aicuQNXfU5TTgoZ5Zf", - "769bMciFLSj7Ekc4DWVt7I6GDOZckmd1Jgyh8ktyLLkPJhjdU8HE0QL+RqTTryxI1bdgb5W+aRgj1zOF", - "BrCaF9s+co2Ca8RXUxXY0ciq1Rwkd0iag+WoHXjILRw2E6F7e4hm4I08FeWvak0Q19RCLEHD+YycA8On", - "vMe5SzaN8Xqb3KsyUeFVxxHnRsi0S1UJBxqiKTmYM2Ohfl6MVU4Uz1yHbEzhmiNeiPEL9hP+Bzs6Ow32", - "wj3HZ/QcyGJNfxxMQYJGdSvsnI3hzoJ0iDB+wYT8Ozlt/H6q34ZsnKmEZyMflDp+wczCWMiZ/wPTpZQO", - "YjxTcmpECq3ttm2WadHr9+r9u5/CQj3HWxsLRTXdgCrdyBZRUjbhQ5BmhAyOWxEdHHg6OSBRcXrSgneg", - "hSXaQuCvoZgfrS1+BCcbTPchrC5XCAZjamc0kuW8cNC95TrFoJKB8Jjidu9YmyptFTtDQob9zLPSqTwa", - "lZ9gYyYtj12XluV8wa6Bcblg/37x/h2qSC2tZ+UwmDBCKQTHmUhuNj6WSnwxuU+DJsELWzotby54jYTI", - "7erYys2vI1Fv5KEvpOiZvr6TOt9JjasfIWSf8LXUDZtHfjMZyCCxKhITfHxxwcKvrOB2FmzseHbHXzNU", - "tDpUimksWP7tG2b5tBXQuzSbA1hZFKAxVpwY1Q8fLi/fv+uzoz47Of25Q4eJKvM/CyPQO+C4nk/l6li4", - "z6xGh3x0+rvY3HCLUT13g0QpnQrJbftU7izuFgtxB5mJW/IWayZe3H/iJTy867mV+jW0CUJrn0kNFPwJ", - "FhsZ3g0srhXX6R+B3YXzfGV2WzG7G1h8GlbXgssjMzp3iJUL/AkW5Eyotc+fPB7T3RIDeuW22Gc/8OTG", - "FDxxr/Y4F7oHNw18D+3zM4y+SEpDdnhKWVogxhQajOngTttzW5x8Pbc9fXf24bLPLl/9x+XR+atunrus", - "DsIDGMxFolWWXYC1GaQbWY3Br5mhzz3DCe8mPrH1J4UyopF6ihEDQk77XzZ7Wr2Nr4xqK0ZFUB95xPg0", - "PKsDWI/MvRx7GkWUEFqd3Q0qTPcJexTRXvsB3VdTMA7pt1FLcL1F53qLx17P22PuwT9prU3qqIpd3muM", - "kDerV4gsxE0eThBYzTYnUbF7ay21eJSllnPdCEMq0PlD+w2t3vBa1vxGzMGpoRuirFkm5sDmAm7rcLOl", - "0Gn3jp+UWeDd3xj2C1yfXx5XNpx3cKP2h+xH/52S2eIl+joDQ58ojbNkYAyjzN1PHQIbu46vLLmTJTus", - "GDms+ATh252g2T0SNljuW2GwK2fpjoRd5xl4UxHKqn9gyC5axvsqWNP0mVGMM6u5NEhewf59nYmCJVwi", - "kWAooDeiVrHlGDA+rrc03slYvsWFbw6aX+UO8aD5bVlEHTwfg8r1YuW4n4NFfA2V351LfJKA+XUAenRe", - "8QUFzt+XK730FTtC1LymKheUotLFFXf0yG2Z7vWWvOwnDe7RwXMufQ5O446sCp4eRxWZMnbILlFXtHoR", - "2KZ3CKRaFQWkrJRWZMG5P6r4sXtdai3mYIbsUgO36EEQclBoNXXP81BiCSOWLbA9z69HIs0w8mMKo4wv", - "VGnDG2WfccNKqSETKAJoZTsDuR0D83t8KPfquuGv7KuTfQXsaMq0J2RfayG0iX+18agrm+Uc/15FK9QH", - "Q6dagkQ0qnJRKodu5R0NvwybftClUZtvaHOmhb+KUynsay6yjcwg8DZKhXFPi2vwWTiZ+I32+6kpbWnz", - "X+lsI505gI0meGVPT2Yx8OxGZMZC0Y2SOdiZwmz2Cg99PJOFgkzBdFRvk6V4m6EBe1RadWQtT2Zb2GRx", - "E5tPex4E3FbkFJWtLdrSMACMRxJmVllk4W7GS2MpfiKrHzlkQ8LqG2bI3ik2KTXVjVoW0rciy7wArpJq", - "PW1/DhKO3dpXOt5IxxXgPxkxdwLqScRmC7F9yYlh/deRpwMnQIkOHIYHAmC3oIGhh6YsqvAWX8JiUmbZ", - "AsWs0qFoW5sgm5I3suIjCt9zeLAqvnSqCMvgyzrIK2IEwTKYltU9THmB8T6k3x+31XAsS2PAojllKdww", - "WFSs5smNm82rKmyiwcyCkUIYVigh7WflM195zM485pOyl4ewlkCr2xoFsB7j0vOfWX4DSGWNdO/Kv9Am", - "pW3ud4U3xDa5+X7qgp6dhsICtFCpSJipvg3WjuDznfugmO0osJ7nkYhw6RBfaXAjDa4FwSOTYAw6u1Fg", - "ISMRFD9wA396PgCZqBRSdvbuL1siaHVt1wsLG7V0t/aaM74jCXWaZrAxMiJIM5GGyO2luAjOvj88zA37", - "RynAerojm7pUTMjBJBPTmWW+rC0G32/pbfNLP5TelvzgXylslcKaRsUnpC2Pd28UT4Wcrn0ariJgRqPC", - "K9YXsDidtOqCuNvmmQaeLtz9eNzDyCenOXJ85ro3sFSs0EJpNg5n91OMcY6mp1jY/T4blzob99k45EW5", - "f1fpTGPKuRpr8FnU7gLGjZIRL9k4goyYiVdwTTXyWaGKMkMswSQiblnCDWxbbeKRiKUTRF/l00bq8Rj6", - "9K/Q9UB65DghKnizCWZNAgwjllMbMcxmGin83AAd1X6Mh16/C6lamKra+M2btCTYFy9enZ+Pjt+/e/fq", - "+PL0/bvR+avXHy5enexe992xi0jdd/RghSei0mIqJEcL1BIb6XReuVUbXCK+sD/p8Nx/erkooGEOwBVW", - "0n6bmSw+4/cnqW4lhaMaJiTWUmQnPs2yz16DTWZ99h8/nvcZVQjqswu7yMDMwL1tT3OsN/AWUsH77LVy", - "Yy7hzl66l22fNai7X9eo67O3XIoJ7vBMw4TWeG9noIlN5kpvUWi7Vcq+gRX9GiHXxhv5Kwzdb7aVMgF8", - "WL6iI1nu6dlvc9dfGe9GxuuB9vQcdwUuj8xrQwb0xjIsVao06gnt+m/+NqK8Z9bInttl383Mu9Xi7/5a", - "Qobd0K3k9+TItpPNnYZvhliDR8gUmyFhBiuqP6Vpn+nePM947lZwbRwfKjQ4aU0MCQscRK9LmJEGquS3", - "jnLQGuhFhfH7NWVG/YtYmCFOMuS36WgD4p063LBQudlNjo0sSOT95dVln529v7jsKPSvjB0F9hOH2bVK", - "Fyha3CwHZx8uq0da3x2Oz7nI+HUGHaKMjhbH1/ckHjPMtb6GifLFjMIoBAMeDBX0xmXjNeoSHklq91kp", - "xT9KaHWfqN08XyX0wyW0R+N+m4XVDGeFIWwnvKkLzg7S27fN0ZCAmNfPxNdu0w3TZfUhor8DivcZ0LA+", - "+h0RK0PWMHkJP48y0LiFr9rAFtoA3denUAeWIfPI+oDDziiQPCRaaFyzUyy7NvElzdjb07evqGTPJ1UJ", - "/M6aOsE2ss4rOCrIjnXaTC7yLh5dHTpMWF0VCU53Mwczm2d9ttyE8etb8YuXRI/UPS1M02FviM7VqHbx", - "/qc+q9pt7t9XYFadCgIhrpWMZ3wKx5qb2RrLacGn8I1TSWUKGnQVTpfQOLbHJbvqHd322YXkxf911QtB", - "BfvsdkaFHWujTRgsrIFs4m4Bq19nThiy89CaxWumYQW/A69j9Rs5BM1K06HkEDbwHBP2DkOVkvGQHYeM", - "Sl9GMmxt7KYfs8CxnfgG6XTUdFtjqZvgodJ5GRJfJXOnZMYoZY8bTyiVoxDZzWm3plJWXdumyeNDBH0D", - "8T9tQay6qwpHOqKnlO0m/818qruqldvFBgCcqPyYqmK8UTzdwr9z8v5ta0AoBOru2004TKsZcS5U5bcs", - "/PlYdB491FeCX0/wqcpHvkAKukaenPa7ofTYLpG0GFX3FuEUFJGWh2KDjAJsqCqEkCwE13DrK7WtkMDE", - "3Ucfe01YMUcQL8tjCinbc+9UhBpWedwfsg8G2Ngaqr522w7viWTzLHdRap1soybyBjNPti2yQHkqHUUW", - "nvlr8Y90ZGmYB1WHEljQc8ByaWGmmZignao2HM6FKTl2mr0WmbCLIXvFk1lrAEXukZ3u2cCv6g6tPx1T", - "+RqTsB0Paac2PTH/8NjscGRz5eoyLz1xtnBr7/jNxb5H7Sod9Qw0XoBMgF2KHLAh7tHZ6acVYsvH+yq/", - "tsM9d2GfGPOexLfkQyxXL/JkKR20hdAgrV6sxIXu+UYJhyhmWuyYFaCxDPR+NHm0eaujFCwXmdk9WzaQ", - "U+PiGLdWi+vSgtlAeXikVdqb8XSkIXHqipBFadejdOuSfDWlBFKKesBSjThJcDlgjFzf9zN0gkp4/nD8", - "5iKO8qguRBJsm+uaROlg7MFXsIPVnlO68CZChPybi/246F/BSW9t2rH6c6gEhX+vm1a0rqgqNh19HYlY", - "0/Io8Gp6j2Hr5vTl5XympQP7vdSJxFsoQUmxUVy8cc8oY5lX8yZlxs64cM+cN8dnX6q88Of6Kic2yImk", - "eGrx0ITEI4uFLCnuyYY9TtcoTRj9UDbsiy5FuY9I6+kD/b85PqsLbopJcIJ0FqAfxZmNe3lRDsTqvFtV", - "RZAq7WaZJ+/fMvdBhGs21ulqFShT0B3bPscft934Sy+wqWswuSR8AaQqNexS5EJOB0dZpm4H5MKPV4EQ", - "v0F3eVSugXdsiOpPMfOPkrflQT33pvCX5owYouuOwJRmc5GCCj91VHN/WqHX3JrjYd4M9/hyDxeKKWf3", - "FnqbJZ3im1/59ct92ZCXheGfw4RX7f2rONsgzhR/8od2CxZfuHEOdcwanf8oprl3VVLqdhTb7IDiW8Mu", - "0y/yi3ehRf7+kB1zrQVgb5CqEcCEemkKiVzrGkvpW+bbYfj2aqFtR9MSt9yw5tNyh6Xb+soj1vOIGlhP", - "zClicNnNo3c/qS4DltMXu3Yzege3bH1HI8aNEVPpU4yQJDY0NSq4dmpx93nO8IPVI2Enk/Ka/t5o4/PS", - "JyfRDiINjUxHQepduxU9Wk+iT+tZrXHAqkfrC0RRkQ3Nq8airUlhvb8ltHRGR3CHI65qi7RkYGczPgd2", - "reyM5FwVR2TauNNyuVQeaGFYY3ryxGCbFIwfZqcyhcJpw9QwoZlz+JJxZoScZsDcF1Q0gWKjUgXUqPIa", - "ZaWwnzLG46ubZld58IlcNZf8+n0Bco3TUcJtpeBYfu0eh56fYKAEDibdxldCCrmhl4r+gLiPeE3jzD6F", - "EZsQys5bpcCEqbNLfaFit4XQms+oVi3RTZmkXl9q55A2FKeKKhD9nF4Zyy8dsmMlTZmDdu9QSp9d0tOw", - "t1XoZzTDkksW6xAK63Q1jpZ8wbOdclEfSytrQ/mrUraeCC2/HhFef1Liu4dOhruMa06XXRFWjoYx2cmT", - "LhKDkkBZKnKxq5IRD+cK8k7CbbaoluLXT6J5WGGziPmHsqIyz3vcN5VWigwlvpmoGhOmapjOuud4rCiw", - "C9BzkWyMUs255FNIsSSzSIDBnbBYKBXuCix9ky2czuC0FsQq33CDQm8dNnGr9KBOfTOz0qbqVu6zVCFr", - "9O0Cm2zzf//P/0XBpPUquK6hgFTQuY85xyfwYCrmMCgLXy2bel+malsuSK3+HsoHI7f5lRF2MkKPTJ8g", - "2LQLLrsXfsa9tss+Lx2jqvjMXt0Ji+HsiLDuBckz1BGwvcGdUwWqtPtSpqAzbAgaLFNEc7qqdZjMuJSQ", - "oXqCdEEx2kSQxBbtgtrRZ2ICySJxGvqMG6ijXivPLhOStJc9fHpUmYP75AI6PcGNah8yHqMinDlWU3qL", - "pYdsjERbFmOWA5fGN9Gng6fC3QvpbQITLrTTiFBb42wGPLOzRdWNE2u8DdnY/3eYkLNCw1yo0mSLakxr", - "hTbzGk/5HEbxDQVIVJX0fMwu2Q6r4n0IZUslpK12sHzJZF3QsgtRqLCle8LV5oUAVqoHbVQOdtaoTmeq", - "p1VFS3SdvX7P30Ov3/MnijK1ImqUOD1ZiZGmKxiyo+s6+TN2N24xVhar1T6j1yScQswyJd3QqvYep5YB", - "Z6cnHQkg/gIlj3pitJpqnre7C/pjhPv0bXCxLLEoc6fO56W1oN2/qF3rgFxsA16I8TY1Vpt76nuqWMeK", - "UNC8V/lPIsvW1E58I2R5x2hL7P37t4MbkWVYFhXlHpZ0qvM9ZNWO9ue3Q3bhe/iiS3d8kML84CY303F4", - "Ezk047ImB5y6YkV+TS80csiVXlQAJXNCiIvx9vkqet2U135OrBvPbcXuTFm4izLbp308kkReue6vArlb", - "IONljZTKRw4lnlIgx8Gyuzx2+1wSx+1DdDdgSJQ0VnMRo8BfZm1agESkZCsIpDhkY6kkBHExzdQ1z1ap", - "5SUb55AnDbGUTLUqi/AlQh+xYybsSzZOitKAHbMDHKf0YlSoTCQLMi68+/D26ID+MEi1mINE2q3Zs5J+", - "y4apDGMNZlyy74eH3j+WirRqruT7dukyocStsVI5Hu3FmGVCQlvAuMNiJlyeONlC+6Q/1LvsaGWdjyYa", - "YHRzHWmMpQFCn21/JUKyn8QPobFYM1jCba7PUtCYLV4FrIzd7C/ejT2pCdkA3TeGvYV8cConiqVlXgzZ", - "kTFlDg4Sz3EdqnIkfoMhOwmGmpBRqSHJuMixNUPiFJDQksfkPMu8HxJj3jnL3LMLoTayyvJsdHM9xsYS", - "xjocdeCnG6fDOpC7pVDxYzOuU2rxiOWCPTQ9GwlI2IQdp+oYuLPqgMZX92y2sm6Qe3NrEcblfnkwKN7h", - "fRp2fvSWsOgB4HiaW9ik+XhhGBSf+Bz0Y4cicqzyPD4bwxgTn4bZFrd7Ob9jz753Wr42/YasaH3Wke5s", - "TBSk52DwXcAMWBI28V15MO+ZEvfNpZIDbUyfTUQG9C/UbWc55O4/94fs0mmpvn5KMVsYkdTcr6keOjQv", - "DSp3cSTq6qJXjCw3NyaGpwWrlYxrrIiNpxwYsAM8pV8qV3mj3zNhrKG7d1OS72JJW2qh6vjSbYFeGGPm", - "PSOv8sIu1iGlN4C5b485Pga4Zd9j+I9wapFi16pElw5JLUR2RFZhger+7qrYuH0ihfO7U5rj++pWudZ8", - "QUqLmE5BjzYRgP+u8RTdhhR9E0iZOk42Pj778IK9c5q8+x9HEC/GvrpAQ7ZE4B72uDWBVYg2UwYYzzJF", - "1QEqn1SjMJHft1VMyLm6IYW51q2H7P3E+ucN+tC4YePmTsZsrzGNJ6JG5j7ofQyiSLhkqZhMQDf7+OKg", - "hLbpf3Z3OheJFfmQvd2G/lv31lVPtnl3xO8qFrGtSoYItZs2dlQ5BT1EKN5tE1WhFFjRzbaH+0P45iZK", - "WCsDtme6bSm6ypW26O5JQPQQ3QzLhul6nS29WXKDDNjuyeZNsYTZVbWLlruo37vmyY1TZGU68n8JD+Fb", - "pW9Auz/MuIa0/m+s3BXVEMOuQ8ePY3pKCDDHSk7E9D52ulBvoG4j4ns+Y0qjkFN6BgevY+cjgRc2me0e", - "97Z8loU/yWrxlWNagRmVzSFYSZgqbaJyoFIsjTaFT7gP6tFIftGDFCymYlbWvOBscehTaHW3QJWgavEY", - "9mkUeUmeapO0grueorRsL1PTPrvlWvap0Og+7sqxgHI6swzuEih8dAztz2qVPeH+jqZOEfFPM2oQbRif", - "ciGNbVbq6DNTJjMnYIQkbSDhWWaCM3rFEuV7YfpifXXT8ac7yQfKiqqWCsbKvSQTyY3psxtYpOpWuhcR", - "tjXex82FalpPt7FmbfKDquBLqEQypOir6VMi4RkGTVeUES6mGXFD9QqXMp/fHJ/RJTVq4z/hLkNThet2", - "GftQqL5Ry94M2Y9iOmNzlZU5vGRqMnHiM4UJLzNLZRcLOxCSdk+GuafbeQgp+/mtN9zX1KJKO1CTgX9o", - "oO2DSg+Rf3IQ7Lxk93VU/3GNlOzY0W7ShgaFrEw0rQZNqCl7aIVIBg0Vw4mZoID6YKHvp1E+x8uxdMhO", - "JWvWgPQN0n2AC0HsBVO5sD70SxhvItnzzPx2ptCyQZPvswz4PHT8DCuqycQbPdxafnHD4I4n1juhkkpe", - "o9LjmJgugfZ3dHn8Y6NKZddujI8kw57G7oFF0GLj3z+O9zFeh0k1UMXL9uY0WMdb0R+D3iWnd5FD6FL5", - "QkNMaZYKQy2W66FzwWl3fbZQJctLKiSc4hbuikwkwrKxO8jYzTBG4I9bCnhlqd0Kye6DXHWn0iSCZl6Y", - "DNnFKuCH7H14lgUd5wYW1V0vX/S+g1rQkNB27YnfgH3BsDL/LWB9fvLmey8/+jSNz2JVWb/R7qnvbUl9", - "5nWo/SH7hfJrx35H437tyGzgkAOHwyNPGi8Qm9D+GVD/JeNyQR4x5SMo3cEnkyGr+k7V8+15vaQfwhip", - "FWu/Kd5IcRjXPJEMrhFOiIhyDe6a0Zdp1ZAd1UfygAqVMGiT/iQsyYBroi8bhywdYOy7qDTqZu1RM62M", - "2vd7xrhPjjRbz+GQfAYaXmLOcqZuDeOlVTm3Pm7MPUjRo8qb19RmLBEPjT/etqEznZr8x34P7pz42XWm", - "VzgqzLINwbVG7EZ2r5W+5RoZkppU99KAmVXEJixoRwcpGIv1Ah0Al0JnsTpy43ZfMLoAj7GslBm+lj3L", - "yRYVtjg49lG9IDMCMSY3tLEeTu2h72UCceq9SYn95YqMJ+DQuyIVPwnF6PqsDv83q4jfN00gYViDomyp", - "pfvwpXvbejbaXIH4elOaBN5Mby+noc+4nMZxTdms2BU93l++OdsdRVZG7YYmbvgB6qP++sLT8h5iPoJk", - "Ap+oDhHrMNUa1Myt3sa89y1uNWQ/oo+BwWTiROle2KTlC/fucIxvjmUEQeJnm3Bra9F37N3rQTWCV+5t", - "tisNUplDMiBdYy/ylAXHfb0tDBPz/hrjvVwUeUKdPVZBkYMx/oGwahGKB7VUq41o6pwXhhqtYWzDwURk", - "QNLOe+cOHGuQRih5UGjlfj5IhSkyvmBOAL2s8hX8hFiU3KkyPozfYTy3wpdFajZUbu8EjULNmaL2lXgz", - "2veFl+L1XS63nx22IkxUMQr3T6UwtW3+wfd6xgtwV+04vb8E9x/+/OFDUeajScanhuDjrmizvzmcOYAw", - "ZgI7du/Tt6o04Kum7xjvel1aGyu8glMy+pVMyKQ8oKRv3FMGE9vr97RTltxWRZpmwWJGbnlH0VE44dO6", - "o3rspbfV4TfetNBY1T3Fe/0eRgDhJ9EFZipLRzewMLHjpRRV635253PfNlts0qwNJ8VqiO2Sw0GW+Yis", - "BbQccqXei2fLlP4OcyjRECly8IRVgLeXhnVXLbB3q6f4D5Yo5QQ3r2sO0I0VioJCozNF6jb/531mWkLX", - "u56bugNJi2vFdeoLMuxa+TJaAvfYC9kkTE71b3020eYYYjdpdLPUTlUf1Tane7gFEj+Lx10HZbiDpLSo", - "ZBRc+w4MyOq9GkytuUiboMetZ/FXsp6loAx88lGSjNRkF6IWZDjaXQK+FN0HfmzBNc/BgjbDK/nKv2eV", - "rH6nka3C0GgxDy+AQqu5SDsimpCUc8czNqkyqwzrY7+Xaj7dbviJ5tPl0bmaw3aj36o5LI/GOATHJjYN", - "PnMf/gSLxliyBW4aeIFfNYeBHSWlNmrjC+MC7DF+2BydAWzUGC/cRx6FG7FPq5F3wSuygmEtOdyAb+u+", - "aebQ/qi+yupqWrBtnTwcJMa560k3HNPJiUu4s9X1LFN5vJ9Dv3esgVs4wZYeSi/uJzxzlcIaTSMNszP3", - "IdtTCcac4Cn7DGMz//X77/eH7ISEBcqCf/3+e1TiuHWvrd6L3v/3t8PBv/76+3f95x//KZ58a2eRJIZr", - "ozLHbepNuA/R7oFHX1rkYPjPm12tbqXYZZ5ABhbOuJ3d7x43HCFsPMVlHn/j55Cg7Jveb/cxt+rpSpKQ", - "DotUaXnVifokEqgKvmIH1acHqHUO2VFWzLgsc9AiYUqz2aKYgRyyX9xbxr9C+y071upqwvjV0mX04oPf", - "jgZ/PRz8efDrv/zTdmVpTki73fIZuVTLDg1r3fI8vBzou7oqT0cBIuxcPtLcwuYp/ddMY590yX78je3l", - "fOGkmyyzjIkJmpdSsJBgTMt+dNFbkcbwdXk1/Gzt/qNXuyzgnkafd1y5Q5evdHhS6qMhyeDeNk0193BZ", - "Ezpxn6wUZ7wGewsgw0acHu8TCbgmQ7liTrwwnqkqf9tixY1cSJG7jR7GYLK2lbjP3MNoQBa+XNlb8Pk6", - "ytVAN+T2kleZACZXys7+jcz9aHBGy3SwODqF3p3hmhvfdwAXRPaVgZz6c/A7Osezw8PDw8a5vo8e7CGP", - "GHeEnd4wcUb8XmOZKJYJg1rr3+76bPFr88VQcKFNBbvQyYPaIrhNTDH07K3TJL1qyrhlGXBj2besUMJH", - "I1Q7Xd5yM66zivr6Fi+v/o/l06z9kWDZwmEH14hjmM3KnMtBJm6A/QC/CSyxq+dQYzNC+JYv6CBMSGOB", - "Y7+YTEjg3rNcqMxbrpBv42pogzCjAvTIwBQxjcgBihES2Sg3aJoXU6napboagfOtz1tH+n5HuqxqB+G+", - "ViB4SrtYpYaN9LlyzvYj+bD7lVxtCXGL9oV1XP19+YhbZBPdG2RvaXvsWWuvzzbHInXpDpWVb1t729LE", - "66w6r+ipeJbxxS1y4W2FQbyRXuPxWU+JuXqRNIG0wxxDnXUO/p3POf2Tkv3quekVi3+cccN4ghFrVrFv", - "sOdKn33jE/y/ocfrN97L8g2bcy2cuPUv07zI4AW76vFbLiz1rZgqq/a+mVlbmBcHB0DfDBOVf7P/kmlA", - "C33jc0xN3tt/edWLRRBSTTmqLZK08PBPK3j4lri1PyOqbSJvVuOqtHenYf3psMXhv2vx9824hpe/JT4Y", - "3PCO6BA6Py5hQX26VUt+wPKltBzsc+xR2OlN9f34FtPxjlF+06vPUEouIEjW4Yy4uT3Kot8nNpKCjuzn", - "IsTiUgPmKgyzebCIoThVsVrK1WQ+7mrL2UpE+HWhDdC8bUiZH4IN/uLOhlbunV8ghiCvRQancqJW+ZEw", - "o1To9btC+YVRB9VrsaMjqOqsUepEeY4KiY9IDqXjqsyslFsY+BLGq2kzUb7jjkWP52thfYJ9n131Un17", - "pwfu/6567kF01Rvo24EeuP+76sXDX+NBtj9wA60cyokIMRSrN7H1ozvorKtIIn6D0fXCQgRPLnz0LP48", - "9OVQwzYEmC0CZ0MQNEe9vrFYP+BBA4b+0rvQiSKkO3I2X1cuIEauza6G1NugH0ePHbYo2hIP7wvLaqn7", - "AnU3LIlb3XxK46KApont+PzV0eWrXr/3y/kp/u/Jqzev8B/nr94dvX21RXoiZSZ2KizYRW8lbCAO3xPh", - "/iuk3pbSl+CvqhZVXlsfDhhapXi+/ROF/2NEZ509w6v8O54xy++UVPniBebmUg0M36qtnt1YDTz32Q5j", - "7L2G/julc9QslKxgjTqE28o1ZOqW7ZEBnbZElnUfWDXuvodxn2mYcp1ijAJGMyhWlNeZwLRqYYfsmGcZ", - "6EH9R38BGF/1/uKSHVS7P/A/haTgKgMz+LeFoZt9yQwAGy/tpXqPYk9lM+MFDNnPPBNp1REhwc2E1Jpm", - "6K0w1QWHvKXE11vC9nsYRxocrqgjpTXESeDnvCgcmjkdoxAjt9aG8ISjQrjrIZTqh2DyEYZ6j4LwXzuD", - "jw6/cCNIW6kmS4uRj7baNEdaHNOHzbHueNsOP6m+rWagkKqR14bWT0Dfooa0PD5T0+1Gv1HTMLYRtkX+", - "xQ0znNbfo68lNg96O7ad5SdYxOYgA39VVG3r6cgb0ioU2O9lYg6juYDbLYH8RszhZwG3S5Cup9ka3mGm", - "VaD7qLTGVBuP+ZaGnDRGLM8mpLAjryNvNdmpFPY1fr88lQa/yk7znYdRGybdeb7VuZqR39tMdVF9H2Zq", - "VmLcriX1aZrB8mjHHYWcbndNfp43NKZ9SUvdcbdtko0fr87he0Hv3mm712/3rdytG2gYHWmCd892g2HG", - "pZZYW/d9avOC1Q5HuzeQqqZJih3aiVSjFE93qdsexjVqD+9c13l1jh3usaMAa3+l+t6uhQ0bmW7bIVus", - "wlp/pdTGrlVMfBa6e1cs3qHuT+rtx35PSdg+K2NZun7s7zKsIdK3HBjjALsObdL9bmMjLGy3CWpeuuW4", - "GF7vMDTOXHaYoKbIHQYtYfwOI1tYvss2l7nVLmMDr9p9vSZruBdA7zNDXB3dfXClhe4+NKJxbjlJh16y", - "2+hVbXC38SsK1j2H34MPdKigW45uvQe3ZbVLr7fthy0r8FuOjL4kdhx7z6W7XrtbDo+KyfsW7qQmHW+E", - "sWjai5jBtOYLpiYRo5qQZOPFvFmq+zHctr5HZbiOeKMrMR0p0Zqp6XLJBV4UmTc+rw2DX26uNa38GBbu", - "bGczpI6mLZci9y0Fqx1Ry0UqK7CtBbzDOdhcOmbTe8udivC5wpdyrm8eMXjJTQcarXRpIwmkM6Zpx0Cm", - "LrPxu4bFmLbQZ1hEhZPh7O3Zc5bMeGGxmZnNwPv43mBIR+/Ft97LF/772Sbg4ja2gOZWLr5tKok0T0i3", - "CKk/ahTd1WRiwEZDac60mgtD8Y30WfvqanJsgMshQn855qDPcuAGc3uaJQOofCY6WbnFScmThM5lXtqZ", - "0sJSQIBfP9g3PYhoglvtEAvDTCZC8kz8BluVCYw7VOoLiYJNlQbOfJz8efWsX/bEbRvAH8Jj7x+43zXD", - "1gH7K3HSu2HhIwZjYeDwA8OwUmEslwm0fPPfP3XwldvzTsFXD49I8g60OvzI/ZNLu3SLcZ/aJvSso7sC", - "hjGr7oWm2860E7reP/o4BWNHm6KoG2mCwbm7KQi53zM62TQxFQ/des7lkICwQL9xitgNvb9p8qUdYkb+", - "Qk042PufgtcIVpUrdbMRa0+pKQ+YEPQw3BzwoG6iZznjNpn5COT7QbwrBPmkO/S4YhTfPj/cPRD5pDMA", - "echOJ7UWVBqfQTwT0xkYW1cqpyGBK2pA9PE6kHch/+mw/91h/9vv+88Of41vEa/W29I3wWviAxQ1TBzv", - "oPRP8RsQC64qITmNrlb5MP8aPY6UbhvnND6PtM6mXNU/69VJnIccW19wuz5/CD+wioF02gR2h0l5QdkU", - "Em5DtdM6SgtxAu9yBjydlFmfai6Ev2Qd6NkZ+X3SGfFdoc133x5uF/+9nGV0P8m7ITY7SN0gtqgK08JQ", - "QPZy09YGijpwH/bpW66BWSz5uDn8c40grdJl8k0S9QYWVDWWGXc5XqJvL2Dj67/xUc1udrPIrxUVpsKF", - "huwVT2bMLRFaEF0D441vmSmLusLpXaqsUtmV3DMA7D+ePcOzLHL3hsF2IEqa/SHzMY6mqrx71TvHyLer", - "Xp9d9dAwSP88tjqjfx1l/k+vv7/qDa8ospmCX4Wh0OwEN8gzo9wuE5Vfe5FlfLYRzfcvNgRN4X/hav9y", - "ya9x2h0udIlb4+1G+TXVFXx1B8mjhbFyd7wcQ6UX0vERia0PVkUT19N2RPTfIlXWaCaup2XVm3l7rOJm", - "pJVqxzPHj1G2ewlgzRQ3lBVazEUGU+hgO9yMSl+OZP2UoYWp+9pNJcsMpUfg8as52HT2SJASXnQoKGRm", - "kGXVlTtZUMY7QSa3saIPSmPDg9pitMebQVX7fkYfpkKLUGvv5QNs1rlAzrvR6/dYKouH2e8flwH2Ss6F", - "VhIfHlWIMlay9y3Y4lUza8xfCTPeLbK4G4DdAcQEzo1k+KDoYd4kugpg1TlWiXDte/BVdf6ux2C8Iinc", - "CTuKh6ufhZqsoSVNR4MNDCYeXf/peTyWsFFGjj5l1+Vk0mEzoWDibSdTpe2e7GM39H4SdSLxbuC7oIY8", - "iL2ysq01sLcNMqp11WJqvctX52976+dtRjT6z386ffOm1++dvrvs9Xs/fjjbHMjo116DxOeoit5XmlDV", - "bHZ2+Z+Da57ctMufL6dDZCbeQ7fqyJWorMypIe26UP9+T6vbTXO5T3bMT8FZ+7TRNTd2UfBb2bywrYoZ", - "RkT3aldzX4UaRtYuNkvBI/8146wwUKZqUJ1+7+zyP/eXGStp9iiIquizOZBE6hCXcaCFhnPLgPPVphqH", - "QIviclbTDiBdWcl9dv9lPkb7qbfheg9+ftrw2vBrx5A4M262dfQQrSH9/qICVlcvo1ClOzb8Aou9Dqqu", - "05Geh439VBbcshRpnBFji/gRt3FnDfWRWens5Ift4K/pJDXLbWl2ravZKOdYGpKy3VypKEdFEmuwbKzI", - "MWT7+OwDK9GpVYBOQFo+jTXyXytG645uol2FfMaN74m4jY5CrTg6kh7qHYfGBqGvAu2+yofokOBRc8tZ", - "DVPbCrKvu4XR9uOyqBuwqZD3Ezon3HLHyW61IAPoEupRvpGQRRnJoUi55VspFmlzlc3NvKp5f9145gfp", - "i247PrfbuOlWT+i9NV1IUieD4gfBuTPsbWtS8UfRwOuEll10p4tXVf8KDYUG4zhUo3mhTxRTeqVQ8kOh", - "WbnTamRxp4iqoBB3lr9pb2kl88SRQjTLfyvWUDFSmlwYdoUDr3pdJOv2H5ECZAj3GR+q0VIsmZXypl2b", - "DfP2qmzALYmYUjYQ/g+zQ1yrdEEtuGnKUMmXLkB66l7OYhmu7QMXSxGqyiizykaGdop0LozSixe+Lu6N", - "VLdhdV9DKvTKBM1IrC5VOW75UTMqbk8Z5qZRqnjITqluJ7alNb5YXylpwaQ01uHmogDTd2hAtles7Uc8", - "pt1SK5TLr6um90N7hWaN97pufasTQFWIu1VPvEoyqYPO17bQ6yo3TJfnSXz44H55G9K+GhrOFr2OuyoY", - "UaAA6Hja50RIzE/aRg2qPfVhVJcStNGeRPrd6p9NFdbQ+L1VwWBrpW0pruDem126Z1Qmm/uM3XkdCHgO", - "022qw23nd/rR15oOERpTbwRZU/imwxPxC3ogdploy6gEmusb9xwrBhlMHPfXEh4Up7DDnFFXcLiFfrjY", - "TSC7j0dFV4DeUOKtjRhREdQuBLerlzqzfHS33rHzo9LiNyWxzBiuxXiuSmmHjMJT3MMZ/24YZv/3mYQp", - "b/3dwSEuuWkHG8r+/Ox2nGyxfqpuZWT5sogv/pBIjKoU3fZG/U1Uwa0vvlvXy2svtTtR7Dzl1uERK0UE", - "d+RaIk1BbqhrQGEctY/MD9ro4/ffdWz7tcjgDHQuMN7P3G//2IE0bnij5qSUMq7ZX1rWi11rE0Sq+/3p", - "+fP93Yr5qVsZ8/O4veJP6NkJ+/3Qsd9t8tgppbqo75bcueQ59MXK71lob01dgWZVyh27XPHSQLPKCHUe", - "KSBxtJ9WvoMdnQ9NTziWo4z5Hpr1XFpBY4cbibK5ePRCnArz2vzCbfKotROrwpZoDsAas/GKLI5wxRw2", - "220ravfzsWpsttgilqczMglv4IEhzBPNc4hH3pzXum34yIF4UjiKnYPWIgUT3kr+BvabMP/2cJMROGoS", - "DQ+2FWMmvo+WApl9vLF7OFJwpGgUncFGco24agYy9YXG9oxVRd+HYTuBSo2YqM4j9fjgWaZu3ai8zKwo", - "sDKxDP0JqjnNo9WYbJhRdwrNzvldoMVTeUG01+0zrZdu+gxD7Oh6wK6FZc7vsPaJ+A1O5dsfuneAWRCh", - "3+HbH7ZEpuWSf886Ysnc6Y7KVKjNdHnsu9hw9zmVTcTu+HORghqyc6JB0zQJOBWJz4Fx6Uf5IESHL2dl", - "ZuDI/zW5AdvswYD9QLGoB8M2GtfKzhotGPY9tlB8VTsGXBja0UDJTn4R4Q2qeChrUDoBN8/mmzzNc0gF", - "t5AtmCMsDNBQpWVTzROYlBkzs9I6MvMlTXKM6EMrJzYGSZTWJfbJwaMijsQ9VA/IuSCS/zQFY91axaMU", - "jK1rm8g5ZKrYNQz1Euty0lBWeYosNidvFNFiS3VZIp1Jgo10bVXpdnUcrNj9j043wyBXUlklRVLFpTHy", - "r9Q75YlWhogwExNotoX2vQ7ZB+Obq7/hxg5w5cHpiQ+8LH2S0cXFq2Ai9QJCGKqfSca2lfyGHTzJ7ozB", - "iPzrWhh2JWUtlQWinI1boWGQwRwyb2bDUjZYHrBolAzykKukG3KjUFbIFwaqTz9kR/paWM11qO7jNW9q", - "kOdLBdWFcRyDTGmyIXu90gl1Xf2ifqzwEO4Y9ADNeYQ2LFUJxo9B1ZR/7O2D/+wr+hws/eUE523EBvbZ", - "atmiaL39bS3HX7T9tQbhv1+8f1eZX2PwyYTx97q+fBNVsyNPzTK82o0SYpAgQLoLf6gFOPRljnm7bcAy", - "L44rDwo5fLANwy03jebO1skSnx7lVI5M5KIji8NGtKYPUtyxKo+QXjiOHy0VsKwvyquHyKVuGyJjqwyq", - "T2X/rmB/EZzA93C3d/WlW40jLYpMdBiof+FZNkiwv1jIW/OWnMZltjsaOvj6KSmFyYaita2GWM1md9vH", - "JvR936Sd29dVTevuKe68RMu4sSuSmJ0ooANhD7YgEdvXQpYHM1wryQ63CIPEg9A5oriz1DZiZ1Psw6qf", - "38DCWK1uwEQrFkcDg+JVle+VMhZiWet9hJS5RuqY40R3kDI87PBKtpiELoHthY55eUgWPEhD7fr9Ibug", - "1qhVrsWV9MHxjgW4tVDX4ZKp8FRurNe6KbaHf/u3Q3cvPqNtf3glG1W0sfOPu7VFQVLiVul04HhlSu5j", - "H21dnVxIq/nAfUULmivp9AbJqTghCkT6ueClcXC6RGXZ7Y04tNvLGtBFu8f1O1oZOVTEe8VeLCQMZgoj", - "+qmLUEdxSTVyBJPAelzEBvEz7gS8e/wtCsWE/LvvoKq5hZcsF8byGyBFCeUk6iB4Z9c8uTEFT6BGAnY4", - "ZO9ltvAszMRugO0ZkYG02aJ1T1ey/gxxY5+uqnoiHw6fRbE+RCxt28bpFy0sVI2n7kfo66HViuUJxVDD", - "gvftP/URW56TRxeTzXsvel4bPcX+6Ozo7LTX781BG9rO4fDZ8BBtxwVIXojei953w8Phd74UKB7kIKRa", - "HVATOrIbJhHD4VvQU8C0KfySUADuhMF4FyXB9FlZOOHDliaNJGvNhXueFaAxYCHtE5Fhme5SWpFRi/3w", - "9QnML5XKDLvqobonhZxe9bCuQiYkdg1U16gzpewaJkqHetH4avVZhYhMVdPe0xRNxzaZhVVe+yZ8voLb", - "DypdUJxv3ZisLiNx8HdDhmqSmBEve7jNJe0iHInu0CqW47X6+sV/u+oNBjdCmRvK6BkMfMPmwbQor3q/", - "7t8/CYc2FEer+jtHn5SHhwmduM63h4cRHwfun+Cd4suqOpoH9nIV64/93nOaKaZ5VCse/MADTVId/Y/9", - "3vfbjMOyPpJnfhTW3c5z7p5CvQ+El9UWM17KZOaB4Dbv94zDauytWjhuoorSgB6ENmj1MoDNHbQwwKgd", - "JqttgVU00DWvfh46rOpfyY3kwnanliu5K7kcg8Z+HOEWQnN590i58c9gOdE8lO71WMxehW6XF74LbP9K", - "FlrdLQbYsAHSakY6RzV/QEO0hx+fnB2ExH1sS62BOvVCeiXRwhHuciNln9WdOO9L3HHRENOotgH+kP0U", - "0iT9T5LnYK7knk/G89L0WKkbAcbf41WPDPdYEN975WbVDPTX4ZW8AGChHQK1Iq13MpwqNc2gQuwD8pZV", - "qcTh7z4+i5IR3fl/4EYkR6WdvZ+D/tHa4lXo40t3EN0wmpbcx+ZDMdU8BVON8kL1Lb87riwJ5gz0mcOT", - "3ovvvu33zlRRFuYoy9QtpK+V/qAzg37h1VYPvV8/PhZfC7jyh2Vty2jnztLN4coiUzwd1A1qB1ymg/Ct", - "Y3vKRBSdDziMimxrljsOUk3BfhMF4zqZibmjcLiz2B3WziBnpUxBs4OZyuGAWEjdINgcXJWHh98ljhTw", - "X9C/ku49qB2Py5srEN8W8h6KRsU5r+QnVDTovirGaI5keu7veB1PIs8cNlZWOh8EW1mXztFoM9yZy1x/", - "45QPAj+5AxMr5ty2CpNsU0HotcocTDHywCqGXdZ9S4wArt2gvuRSOBr8lQ9+Oxz8eTga/Pr7s/63338f", - "D5D4TRQj7J68ssW/1ggZmkz5wNxSFpTmVZNPtes9bG8a8rBzLsUEjEURvd+0QlwL6Shxk1Zfba/fXeVp", - "rQLXgO79tLhnsWDtChsIFSDtR7gdUU1FHOio5unn5nsrLKiCZgPJ97hxDMnsN5lgdUTPDf1b+uA66Hhx", - "rvcqpJhLppYany019TXk9vMdf4/OTrEg/5Ad+V9R8lMkl1NnyFpmBc+yhe+sNVNZGqLH75KsNA55nfrT", - "Z0YxqbzzH/NCWMVsDEu4JBtFBnwO2DUpBMYYqwoTjAgToY31PXFCv+Bw8UxUJVnIWhn6AFMv9CsZ2jaU", - "Bp2f2Kh95qkqBUpuc+/C2g6IeUtUa8itdgMLaszsr+tKBo9qwRduFu+IYFqVMh1YLQrmVEeZUHg9YO0F", - "mYq5SEue+WlinPcHVATbjZvvrwautZmurlT3nr2fMoJTdjQF+py0VxECNamOEkATp5fIbKkndCC2NuDq", - "btBPBK9Iu+l7gok6aIZm2oGsPyuELkReZpRLS1TXbJcfNySuwIjMVQeO1XeD6Rx4etwwbcVu67HA1e4U", - "j9BaentVDd/9kiinVujmwbfrDk2W5SoWa8XK13WdaBvsvs+2cfKJUD9uAb0v+qPVM1RVtKrRdv+LYVi/", - "kEE2GNO3gFfVgz0Opipw+okgtNrdfWvgPMr6japwMTqjmO65CI2CqtfyFwPxH0Xq69Oo22bpyzaYGx3o", - "O7U+LLuFWgtmDwSGSn2K+5WTymluPBScdMtqS14hDD2Qy72Lp2Ie2sOSYpoBN4C6VbPr3obGujGNp2oT", - "/USoudKG+r58w030hYhL3EpdVJTAxBEOSxgzBUsIMyp8WdduJvEXsK0CsE8pHuOVZuO0i1EHdNLqEI9x", - "i38B2wps8JoHMYuw0jbKh6OVTfphVYj2idB8pdDtw7RDfwvuZJ8X1d+G+qot6ASpWGVN1JzGbAMxrIlH", - "zcPW8tEQblytg2585JkNf3+VskF28jp3qFGJ70rG6utRiBjWgCs0zEDSu3m1kF+fGYAr6TYTL8bHuK3N", - "6FNhhxMNkIK5saoYKj09uHP/r9DKqoO7Z8/oH0XGhTygyVKYDGfEz30410xJpU0z8MNHP4bzuhe1T0hI", - "/FVg6onxJjSCgkqjHg9fHfKJyGG5+OR9qQEBitjyJWkLJOObtiTEyy0Qv9nIrItVXfIbuGiGRj6JxriS", - "zfrRw2itxMFA1oOCsq/rlTZbN1cES70Bio79rACtch9YDaAQhLYBnCrLupkY5emyuc9lpQIJB8rRdsiv", - "dX+zDR2vwUnb2mLLztcqcerVwFairG/2L1mmpphGa0VyY9ieVNYncfu0nhqD2DXM+Fw4lOYLNud68ZLZ", - "Eq10OUZSNesxYMwUpm3URyF3Y8jbxSxfb7v0ru5+q56ED/lBT0/LpLlXzYGqcL3APsV9oBWJgoVCLHhg", - "heMQG0YGjMFAQwHcsndsMKCgq0NGHgRSyMmHMI5xyIuQLvtE5NdI4L4vd/To9YXYkGgzta5A4OHWacY7", - "aHMh6LeDOfqAyyeCy3I854OMHBRE+MVILXc2Mmqsg4KPEe7maXWZ5eBuZO7/URjyYjk8GblW5SIyli+q", - "bCCmZAJsjwIS+lfS+2Rrb0zfMQ7Mj/PuuH5D5/OVso34Tcjpvn81VwvVCYQM7nhis8WVxOVanikNPBXS", - "yXL3enbvcYyiDmuMqbp4qbMxrufZDmfXYOwAJhOl7ZWs+yxWNcXDrMFL4WZGRc09bPgUGKUn/OB4owNC", - "aO2sc+wvkjKrruQ4qJNj35uCywXeNFuokqUKQ6AluB0fWZYBd0qrDIZlis9wX6Nf8hqYrzY1vJLnIXCm", - "DStjneqoS1kVg0a31YtG/E0TNh4CfXKv91E5lssQG0ZBgnWACBwk+kCmFBhbJe1QzPqVtJpLE9TbF0xM", - "GEfXjq7Df9y+0dnkNsh15sRiTXQMkxgB27WHTLucC+nwAdemQOAEPK66P0klB9/e3Xl/V6FVwadOIA+v", - "5JmGCfj0W+XEmIGCYzLwuI4u+OcxJQ8d+Dsaoz/PR7dW+bPeuziwWkyn4PSkK0kwIEoSEuEZ0ugq0owJ", - "q3DLxxX9PmKgAIUFjZrhbUvxHZevB//D5960Y5dYzgv2v//n/2IY420g59KKBOtLnx1dHv/IVqPn4uWg", - "/VejjkDJxg7Ix83Gv19REONV70UzTvLXj+MtN4Sjo7vxYN1mG7ljGqiZxN9Jqy0oxmwPq9EcUC2aA7DJ", - "MCTEUin2EFC9ikAUUm76wT+LacVVgsgyN64TM9thSy1KbRNptFrcmjiSV80wH4NWyLD7xEmspMSiLfUU", - "Q4wMoWPUmQFr4472h5uDUB4cIvL08RsYM+6GjDzvXL1Ny/XwN2Nj0SmUgmvweset2BkMNvVpjJ45e1Zg", - "hsyzsxB/5at5YC1534CvDhz0g93/MwehBHvQ4A1kbvweutsp1I6NfZjfAa2Cjv3xPiWojt29FaOaJMYk", - "FZBFErh9PEM4rJ3xKr7GOHmHH9xqXhRQNxEUS0k/XeDylcKccI+Q8fmbyvvjxTt44V5z4bXiu7IF9VmG", - "3dwcUSWcaM2ybw+f/w8qQdmvSc8BMMFgXwqjQB7hAUC7uM6go2R4+y7XKG11glW4QfQe1GMpNVyLgpyV", - "SzhZYcWek5FV0SWfSYRtA+COKHJjMvcX5aJqaUKeX76s1c0KC9zMGSz7roYPUeyfH/558zi3wUwkK8+B", - "x3GWL2sP4fnQeU+ACpf7X+TlVUx3yooZxytuvjyOUJ+hZ3taKTT4lPfZuW1NtMhKs3L3oRjaQUP6VlH2", - "kXBuL1WfysAZ6R31iTHarx6SLVeB9cF7WcNbqXXJnw1jHxy73HEchxoTc5Bo4BZGVYsQRJMyFjGEH1b1", - "jZ4qbKi9yk6o8mxdOSY65xdkXqCTMo45X/X1B7hQLaEt4HKCHz41XGiVZq+/e/ulK5DQEdOHUdbzzePe", - "KftalTJ9RIc27pzxbrgFPXgNyF6TuvtlQwuL7f03ABTCo4KRr9jlqGv0m8ASRVOwsSJmttTSMM7+enrG", - "qrdA4w0RngZVUZm6MF5AjeFqDIlf/0Tov4oCI/I1z8GCNtgZpKsXZkU5qINaVen6TjUIh8LXnRv3jxKQ", - "HdCbLpQIbONAv2nE2FRy8NedhLO/1wc5vdythzNWtZkQsZoX/EfESw+sJgtxrwFCtPCgjeOrsekWCBve", - "vnuW68YDOA/OYdRD3Vz7a/H6Sq5BbPZXY1OmJhPQhhkxlWIiEo6p5xNu6PlHC3r99Uqm0PyT+zfX9AL8", - "TRTe4MKTmYA5dhIGuzwLklE8MqtBVe6O/ihk1f99tS9edVyMYBiyH8V0Bpr+q+pxz0zOs6xpjrguLbP8", - "Blim5BT08EoOCBLGvmD/5aBNU7BnfeYT/x1gIWV7//Xd4eHg+8ND9vaHA7PvBvrCBu2B3/XZNc+4TJwq", - "5UYeIATY3n89+74xlgDXHvqv/QDPMOT7w8H/aA1a2eazPv61GvHt4eB5NaIDIg1sGeE0vSY46q5a4V91", - "pSZ/Vb1+4zfaMv7DxLo17MoVPfU+iC1eLtm1/g9hjUvmvIo9osEl1G7wbLHNGpwWg+X6t+UJyAn8tSJ7", - "VLot0L8ECbubTljdQQShUMsTdV+qPyDa/AVs8wRVZ60V6FVokwljUU83nXjzRhgshW3uKUz+mJhSnzqC", - "KvXzLaPaJH9AXMFsXYQ8JRKu4kau5t3Pt9D1/glDYx/j6YahqLW54w8IJzwB9jlHL9c6YtbA0+rRHaXl", - "c+Cpf3JvR8q4WFAJ3fxfCjWrxIId1P2cHqRLIOuP5nH9wZAFs8Za7roKOQwQox81yu53Uvdq94OnS0Lq", - "aLNw7+oaja4CPmXoDwjIC7CrhN7smHCAHRnMTBQVhMkD2h2EhXVOTMNR6nPHla7jS0gg+FB9DbnyPIBy", - "2YYdVSeCevBo0SOVRtLhok/B2NGGThPuG9+CvuJgvmqaV2i36THR793Xm+89+fVWdy7HQLfwaJUYEEpV", - "EYY/OquLFGeYeH2tSQ7BtLm2yAxHwwvFoGEzcaonI6ypbZsr6SvL+NVFHGTdfDTS2BX102YzjkalnDpG", - "Qm1HB48U2bKOHu6J2H8VRY3WDQD+t0Fy3ix4tISiK/jujSsbEH5X02gXXVzJzYSx2UTasoheySWTaHe5", - "I2/jfDTi6oyiupzBsumlEiFbxA19NqKNR/l0FWt9t32gj+9w5veGxYywvK9Dp8EAvxnU4/aHu9VQDnB4", - "EnZx5O/wvznLWEbXDrZxu1yQaOkl0OgR9VRvgEgbqu1he8/iqXjsaEf4D1L8o4RYI/iaKm/9dWwVr7Zc", - "r90mM/bYNf4+E7LRYZpGal+oSU4bmhje1sHv4co/+jLmQEVKlvFNFTW6LRkp0PDgLQ3e7lDBcZ3tYbOp", - "4XmssD4BioKd/+CAusCWQiGuPGbtWwbSAeXIdZqSqKH5a/OKPvuEsFo2C1m4s7TbqD1okz/gAp+2vtlO", - "JOe0bnqjJo23sM8hxP6vPMVT/977j8HFxauBLx80uIy2ongLqeC+2voEu8pg6w2fkri3zMT2W5674KVb", - "YXURp9zHPyKaUneh5Vv2JU+I7VYY6x7z64OMsCjPNgbPk4byxVeMn5/Q7/2+bkgQOnx2Nvds9U750/Pn", - "XdvEjpgd21rbEpSIbxuJ/0Bz7D2tGVVJqD+6GEWzlJOcIR6yDtXK1NQc1Bcbd9GpqSHS6eDDSwjhuwut", - "w9zAaDyK1/VtY5ymH19morJM3cYjD1pd0Rt9+JbBjAkeVdqemIR2gcIwv7U1hNktVXZZp3H2+Gr1B6OC", - "2tT0PptEe6OmW4oyh1hftPSKSQa3acqhvLh4RQRSZHxxqyntjYpGblFetWr+dVaNZoljtugLnWgws0a/", - "XwTNnWV8yoU09BIPWQi6lFjCWSrJMpXwbKaMffHnb7/9lrJTcdYZN9hzziCr/qbgU/imz77x835DCT3f", - "+Cm/qTrFhCoNvs+jj8XAGevNYalcW2pZt34L6BUznPgrqM99TNLhKV52K2t9pqyHyD7chcaTVarL/RLL", - "odZHwLIDF7hzwogIcnoCIZ6E1NH90PcNttxCT1bfp1rhM+FBawddGFBXM9b+my+iDG6i8txxCbOQyUwr", - "qUoTqt4GAJuC38qNEL7Ar54UxLjE54Wx30IXkPHnz1z8ZBW2fA1wf/f/wLf5jWhXEIoC+ieBpWg2v8vr", - "mdeqhJUmX5Yifchj4V4Adaf5IiuVvv/pDxlf4FiJmLqXplUsqK3dGEeFATbi3Dl99t8G6+g8X/Hu8QKU", - "sL4EZ2eX/zm4plYKm5HPWG7LblNkYPn01afGvSeWY3SomAjzv/who5Q9AJgJx+sGfSq20Gnwq/82XAeP", - "85n1J9pCl/70wwJbd5D57Q9rcaslHyM8W4uHqrSbDHH15anSrrXIfSZ+9ADLUnU2N2xLG1O4XVXaoqSu", - "+pmYQLJIMvjqQHk6B0oDq1VplwxmGhIsFzo9qJ2wce5KmcPn4fsnTdSuVtlcW3Y53dMP/Hwp2p+ptkWV", - "2F1omAt8MzICLqRsLlJQDT9CA+o+uayTi4Xssybg13rPTutYiSoNLwAlVG6xqkoj7TNuWMExzswq1tga", - "hkX4umW+7X/fl6mi3s+r8wpTzQud2QnILeP+Lz747Wjw18PBnwe//ss/3Yun4k0f5MXzB+ch1KjsgyVb", - "nLH6dfBaSOxuPziKdYgWORjL88LBgrr6twAy8YOH7C8l11xaIDBcAzt/ffzdd9/9ebjeddLaygUFstxr", - "Jz4I5r4bcVv59vDbdRwBq9KJLGMCq0xONRjTZwU2wmBWL8hoSsUh29d9DlYvBkcT98NqDd1yOqUkU+zH", - "ga0jhWR1p/3QtlEviHrqQ1RBcM8iQXAf/8CZqlTD1yCJUuf1LVhRJkjsdCYeEigdTB6o8laJBOskUViN", - "UkRXovNX6DV0vNTVLh8tM49nWXPa9rXlXN90O7noFIZx7JiZMl8cVRKe+sBNLqkdZ4MesSbsREgsSEfw", - "5PoGdCgL/nfqy191lfZK3duz546fJzNeWNBhzGo0/Fuub55alWit8YSxhDvsoesF9RbvqSKS/2OUlqM0", - "rTCTcAWrTUgm5CCw6BonlzF/pWlwJFr1qZGsvchadfXZOuHkxd8fsKga3kDV+KDJQd5TleamlC9As9MT", - "7BqK7QCmwlhsbIpV3h1PGq5CWRXrgKyKp4dxY437v0h89OjnrbFvVdFWvOi6TcIzsOo30OogFYZfZ+s7", - "lNHz2k3081uq8+lmwFo5irlZ+g64XKcZvvgn7MfLyzNmNZ9MRMKcpm6H7JhnWSivc3R2SlXlhXFT3jo9", - "7ZbfABOWXUPCSwPsgxQ3mk8s/Rqa9Se+F9oN+L4+i1D3I6Rp/fw2Wh2HjnnhTn6p/gpa9baJBMbvB1YN", - "3CmZv6v0UYBzmkJeKEsKk58Z7xXCrTauaLgKOJDr4XYOxioNxleapamro1TNO+o1+k7zULeoPONttjdD", - "+jLq8iLNgABKYysF/+e3TCpffQeLzRuv1c8gSxl3YIsGpsiHwwbkE4GGJt4EGQsZ5E7r31ibqtnDrBrV", - "rk45ZOHj54fPmZg0vqNC93Vd4Wi3pr+Avaz284QG42qRC8tt1FN1GT/gfVWX1YZw3fNXxV6X2BnXvm8M", - "pYgTQDoBgVIt4RamVLwa7txlCYcYBmwddUUs6FqlC1SZKQ8ifRlMGc0pNFhO44SuMMGAtUJOzU6gZxc0", - "isEcmlt3+OoXpDQyoo0XbMIz7NYLXJtQ56xx2ljjL3eLbWR6gubWFLNULdOsUfvp3B/3xuY/cLEBXyN3", - "HRmVsUZVYDfQTcDibw+ftbH4lhMaNwyXNUa/9PGMbtyhGyesG+AQPYMkxDyqwg6EfMF4Lfpn3Hosd7M3", - "qW2PL1WNpvxWqeyMbImkOOgS+kzpQEmBeILE3+8kmpckCNz/VVLDC8TdmPZZaT8fnX3xdPWYz/T7b8jA", - "540JvFgn8lpqSCOHK64enqJRx7jnN35aG3fqBcib12dT7vtgYh4y2Y6Wt9Ek+UOiMfzaGDGVkDKQc8hU", - "AbWy6Jc1jKfB3v/t4fPI7xOR0bNxT6qwfPAB+PxM/PYbUxOuMDXtImE/Pzx0WtucZyIlYPqS9HFavM6E", - "qeUe+TyfyPFPa+ESn8nxX5/TAykaHIvgKGi3jlVXEE24Do09anhTi74EhkS9Ef2dJuRJAgWiV2lrSK/H", - "tZckQcJWHtBOod2nkybcgiSWiW0lNmA5swsk9dueA2u7yeuZiWCH7BVPZmyieU65A1ixRumcjUX6gv1u", - "4B8fr65kyi1/wX4PIBg4eLu/X13JsZOWdPe+fUfVVTEBYwa5ksoqKRL0yRegDRqdE62MWWJ3Ppv3JePs", - "DTd2gBAbnJ6QDQAbjHkp7gbKWkIjleEDXYMp8/Dsp2MP2YlWBW2K4hAJ4FNemKBQj0U6prY+2MTL2zBA", - "zCGl34Shwi92xiV7xvgMeBo8kJnbqwGQ+Gk/hAfcgnaMQqApG0+A8fLlZAJ6yI4zgV/5dsBW8+QmMhs6", - "M8FCYnG/Q/YaE0bq45ugXyxdGZr86mVrvd+DygEDM5EMANbEp12/RG8pG/8/GoqML/6NZ9mYSjG0plNZ", - "inVi8WnhuK3HX2OB+15pt8Ld94wXmNmEHURBghYJG7f53JjaHAetyd8e+IeMp8yfsFsQ9WJle+7zBXYt", - "c9hGvTU5S1VS5iDdqLFdFDCmvnsVsx5TmyGHc0rnVZ2dugeW11f+Gbd1gh8Ty+ozgwoh7YcmjzblRIRr", - "H29jMctzh7KhgQ8qd6ZNT77BntLMgEzZYQQeAbyhk+W2NNlnRrUJa86zktKAcnBkpjUkWD6FluKWnDxD", - "dslvAJsfJ5DiQhj6MSa8GZNYxQ6stDB298PlHEPipVUDDR6N6+Uy4BJ7yyEikcNrQFM6CM2EwYqwdTFi", - "8qPW7vcWEeyWl3eGiL8Lwg/ZOZbNRpJmieMn3LJnh98+f4kDKmTmDU6AmRWlnvAEqM7uRGhjidinmJSp", - "PZcZdtZcphuJRxtl2f3KJj8gXmsref5mC2H0h0sSXD6Bg+gFNhAeXDh69BzAjf7/AwAA//+h1kcbJdIB", - "AA==", + "H4sIAAAAAAAC/+y9i3IbOXow+io4PKkaKWlSssezycqVOqWR5B1lLFtHkmeSXc0hwW6QxKob6AHQlDhT", + "TuUh8oR5klP4PqAvJJpsUpI9zu+qVNYjNq7fFd/1914ss1wKJozuHf3eU0znUmgG//E9Ta7YrwXT5kwp", + "qeyfYikME8b+k+Z5ymNquBQHf9dS2L/peMYyav/1D4pNeke9//ugmv8Af9UHONvHjx+jXsJ0rHhuJ+kd", + "2QWJW7H3MeqdSDFJefypVvfL2aXPhWFK0PQTLe2XI9dMzZki7sOo906aN7IQySfaxztpCKzXs7+5zxEV", + "TDw7kVleGKaOY/u5B5TdSZJw+yeaXiqZM2W4RaAJTTVbXuGYjO1URE5I7KYjFObTxEjCHlhcGEa0nVwY", + "TtN0MehFvbw27+89N8D+szn7e5UwxRKScm3sEqszD8gZ/INLQbSRuSZSEDNjZMKVNoTZm7ELcsMyveke", + "mxdi4ZVxcY4jX0Q9s8hZ76hHlaILuFDFfi24Yknv6G/lGX4pv5PjvzPEvu+VvNdMHef8hKbp2dwBfPkm", + "Y5qmxMyoIYnic6bhHGMcG5EZFUnKEjJewN/vmBIs7fOMTpnu05wTDbh2VMKhb3FLydTfWkQuU7q4V3w6", + "MySWCXN3yKWIiI4VY0LPpNGEioTEKc/HkqqE0DhmWg+I3brG7WVU0CmDbfx0QbjQhtGEsIwbMspTaiZS", + "ZUOa86E90WhwK1YgHlPDplIt7L+ZKDJ7g267tRvURnExtTeYULORCgK3fGqHWcyXhYpZxwlg5DWO+Bj1", + "jCqE3W6yCrIbVTDCJ3ARdodkwlmakHuqSTmKJAWz+Kr5b4ykPONGW3x0JxxLmTIKqGYC+A9bIYZnTBua", + "5YQL8kHwB5LxWEnNYikSmM1eODW9ox4X5k+vqum5MGzKgPPgX6rb9uAJXPcSZhvtJ4wquJV32hHfTx0A", + "t2AtlxaFLUnkdJFKmpCJVGRUohVhdl69yk0saq9eJQKU6GKccWPhYiQZOSZS0cWJTNgoAuzP8Zt/efHn", + "lySeUUVjw5Qme6MStCPCNdHMkPsZE37M/oAcj7UFm90umzO1INLMmCJ2j8Dda/CvYXiBPw6zAB78TNO0", + "H6cyviP+O8sOLd4hW1AWNTKepryGFW4NUWRjxIFyB0MewOYLy8hZQpQsDPtGV/uNiKAZSwhFjoR8Bv6m", + "CTe63MIeG0wHZHSppOUYli+PIjK6oXfsuuQuo/3g6RUKn+C+LB643wlPrBSZcKbIRMmshRP6rzOeJCm7", + "p4oFF9WGmiJw2z/c3FwSrzkR/AoY5iBAWUvEUjvI0n2X6zVhvYZ+LPFcGxrfrW7x5PSSXBXCcoYBfHKj", + "aMyIYrliFvm4mMLd/Bud02sYh9JF228JNfCjHQ1SVSAtDcgby780KTQjdgVBMztRLIX9GSSvooDLZkYF", + "0YLesWFMNTC4DPQAO+/JTMmMkVM2v5Ey1eRSSSNjmZJ7rhhBXhUWCmn6Rlm02qwJwGkm8HFELMKqTGqD", + "Ur8h75d5Q1pk4h1SxMoif2VK9sdUs4TghwRph9xzM+OoV6RcBPEg6k0KAYL2Hc0C/KcGCf8hkFBELJvI", + "crMgiJnAN6iQYpHJQpcf6yAK2910OI39LHAW/Dp8GvztPAnjHv53jRyDuytUujr8w9Vbe2R7ds/D3GwT", + "noYIdYnCGtdc2ycu17iSqAnvEKk1dbolEbSChDmKLpLSMUsBULB9ICoDFIg8kOqFiElMC83C/C6nymv9", + "afp+0jv6WyfVpOIIH39ZEZcwZWMzgEmwFfirHqxcZo3k1jKi3MQzei3TObtiukjNGh0WPiXafkuoMRa1", + "iWIURAslllC5vUJZmFhmbNBNNcRZH6satpzjq5bYqiW6ix8COIcK7uwZNcZ1ANpeefTY19AfQydao0u6", + "r/29LHFCh+xzJhKpyIRmPF0MrLxLitgqi8LeeGphmis55wlTfZ2zmE94TAzVd16JEkYSM0Nt8ogwYZjK", + "FdeMzKniVBhtOaVinrhimaY018wPZFyROVPaypRxEd8xQ/bmL8kBmX+7H8FzjoqF5fpTIqR9+81BliKv", + "spd7Kq0gujDuQBHJU8oFeX9ytW91XMVyqQxqgCNQZt2jzqPJzBOoxQN/Z/OXzf/81iJFoYQ2PLWYMWXM", + "MG2snmSnDBP3tloxaIXIfLShyliiCvGcFd0YLAXDtrdDOq+DDr7FJ7RdkvK0UJ71j86urt5fDU+OL29O", + "fjgefnh3/f7tT8ffvz0bVS8DKYgu8Fm9jV56s3wOMnLTjI7wzIooZq8YWG2h6Thl9gd44w/IyO009LVw", + "h9rTjJFRdRl21yPLWmRhqnEJTwCTcHxdpbAChalvNLmn3JBxkUyZGZARHVORSMGS0ZH7hMRUxCxNWUKc", + "GM3plBFB53wKHJHe04XV4PuwZhPf3LEtT8Mj2WvETfaiXrlYEKUs3QXfGQ7KVGs+tXdSU27I+5z+WrDI", + "asaTAiW/LnJLFcTyWN1XbMIUEzELg/SejTU3bDiTOiA2f5Co1Ja3cD9jirn7RJK30gIuIlk7f07NLPCC", + "ombWfX7y/xb20eq0UfYQp0USXHZFl6jxyh1eO0l+IoVgcatyIQh7cHbVOOWWkJDk4kIbmTFFrk9/rBu5", + "InJZ5DkzjKl9+4ixc+OjHl4pp5fkZza+lsAvcyUfFmg75Jr8dDHoarKyk9r9hVDtq0KxqlAk+dDd2nPq", + "EUl+ynW8LTol5RiWVPaFDYhCLinHVxV8zbOMJZwali5IrljMEktFo9q5R95Ere0TSBvFaPYk6LaNJrxy", + "QV+V4LU4W6HGJ0XbHTXfardLym/jJO1q767GyApBO9kjM6Y1nbJhLIsQheKz3c5tSdB9bLXRlC6sggCS", + "N7Au42CjSrjCv4UNHIpRHXrk/zxbLM/JhBWAZIRsYhinUlslCr5CzsEFNxxwGP8otdXOihypexjPqJiC", + "8gO2MV5kRDHQT1mCOg7ToL1bXR2kNHAZIxUjibwXRMv6arEs0sS+BxyM6ZRyodGoJ9g98evWtwAq3eio", + "/I0k3GqSyt8ryYssRyUQzyqFYQ9mWKpp7sDetup+BwquVLk9s8i5VfAW3kysZ4WxR9hvanD1q+xFveWb", + "qv8J9gS2nKUdbabEOh4vo1uJAesIUgotUwb+1VaTh/PQ2RuxHztFWipi2VoxnZm6FZY9xCxHpEKT65lz", + "R6C4uZdWCBkuYgNIjzxDo3hJ+ASUTIMcVM9ozvSgtAO79Y8vz08oAsP9ZeDeKzRN9b5FLfs61SRlc5ZG", + "xN5pRKiaanwqgqloCAakau5y2zczZfFxrzxb+Ut9apwz5YJFzpIauaMMC5UG1nGGZ/umcG5w+3RxmhqO", + "JFQxQuEBtYVH0Z7/0cJyGQu+ysp2WYl35Yj2GUVlECbb2lNh5Anyld7HaNlbYIkiQPFpWtI6VdMiszOT", + "WDIV4+sCz6oH5BKdMUSKdIFOQjyYo/Y2wm34L1bfr0sWa6SvgHGq4cFoWPxr77+KHwF6AXV33vgSVwjL", + "WWAzYS+Cv0U7iMxpal/YNL2nC01u0SBz23vULQb9Jat7eVtzj3y+i6oYZIvTZMVZgtEYZqbYfXOPT7Cx", + "hjnKM+rOdvbSTRH1gLZWTR5FRkVfMZoAp0cJ5URRI/ClRJJ7UHoSrvOULgg3A/JGlr+iiNvbRyEX1SKA", + "PIXWCZQ6EsUpAqIsckoYm/AHEFa4P6dARATMDre9D34ksKEjMpYyu+1Z0V/7bY8LKxgzrtk+uVnkzH38", + "QLgTeKWP77aHkm0Dz7QXusoaf1lhjm/ltLPSksopaiSV1pDKaVTeLxcTWf3XPVUiIszEg/3BZ5DE/mBf", + "5fBGOZzK6fNL4QY8/lgyeCtRukZUtSrZdo6I5FRrePwpWUxnpBATnhpwsgC7xYiIgTOsQ9wQRNnAVhsq", + "k3uS+6C614SmqYsfWpaY2qrKjCpiZdSAXDM0VemcxaVrelKkKbE4EWQsz8Tb3wDjXQbPKnQ2m5QRIFEH", + "ltfAopUduY8ch/NPVyC6KqLSs8RMCm7sC05YUZGm9lb7Xno6iwk5984BFFaGqikzEUak4PvGeTLgqZfL", + "eGap+37GXYwM7kTGcaHsezvwoIGpgo4KC2X4tR4OVfPB4GbC+o+kCVOtsyYyRljhd7X5I2IVCnBdMRrP", + "aqcLriPofKjZr4EgMymkkcLZCLiI7SMcHJPVdWGwcOxVsgg/s/tiSbkBI/M+oEd9ZPASOnBPZ35pvRdv", + "nqmHnzkKw3Vq1qLgfeBXwfk9brqJakvsaQPKkTN0VefU/qCUGDreX7eilwsdKPsGRlgNZW3sjmIpm1OB", + "ntUZ14jKr9GxZD+YQHRPCRNLC/Abkk5UWpDKb5m5l+quZoxczxRqwKpfbPPIFQquEV91VWBLI6uScyao", + "RdKMGQragYPcwmIzErqzhygIjfbGQbT7rJA7C2tqPpag5nwGzgHhU87j3CabRnC9de5VmqjgqsOIc8dF", + "0qaq+AMNwJTszZmhUD8nxkonimOuAzLCcM0hzfnoiPwI/0GOL8+9vXDP8hk1Z2ixxj/2p0wwBeqW3zkZ", + "sQfDhEWE0RHh4u/otHH7KX8bkFEqY5oOcwxKHR0RvdCGZcT9gahCCAsxmkox1Txhje02bZZJ3ot61f7t", + "T36hnuWttYWCmq5HlXZkCygpm/DBSzNEBsutkA4OHJ0coKg4P23A29PCEm0B8NdQzA/G5D8wKxt0+yGM", + "KlYIBmJqZziSZDS30L2nKoGgkj53mGJ3b1mbLEwZO4NChvxE08KqPAqUH29jRi2PjAtDMrogY0aoWJB/", + "u37/DlSkhtazchjI0sHkiJOUx3cbH0sFvJjsp16ToLkprJY357RCQuB2VWzl5tcRrzby2BdS8Exf30mt", + "76Ta1Q8Bss/4WmqHzRO/mTRLWWxkICb45Pqa+F9JTs3M29jh7Ja/pqBotagU01Cw/MVbYui0EdC7NJsF", + "WJHnTEGsODKq7z/c3Lx/F5HjiJye/9SiwwSV+Z+45uAdsFzP5c+1LBwRo8AhH5z+ITQ3u4eonod+LKVK", + "uKCmeSp7FnuLOX9gqQ5b8hZrJl7sPvESHj707EpRBW2E0NpnUg0Ff2SLjQzvji0wCewLYHf+PF+ZXSdm", + "d8cWn4bVNeDyxIzOHmLlAn9kC3QmVNrnjw6P8W6RAZ3ZLUbkexrf6ZzG9tUe5kI7cFPP98A+P4Poi7jQ", + "aIfHlKUFYEyumNYt3Kk7t4XJ13Pb83eXH24icnP27zfHV2ftPHdZHWSPYDDXsZJpes2MSVmykdVo+Jpo", + "/NwxHP9uohNTfZJLzWv5vhAxwMU0+mOzp9Xb+MqoOjEqhPrQIcan4VktwHpi7mXZ0zCghODq5KFfYrpL", + "2MOI9soPaL+aMm2RvotaAustWtdbPPV6zh6zA//EtTapozJ0eW8gQl6vXiGwEDu5P4FnNV1OIkP31lhq", + "8SRLLee6IYaUoHOHdhtaveG1rPktnzOrhm6IsiYpnzMy5+y+CjdbCp227/hJkXre/Y0mP7Px1c1JacN5", + "x+7k/oD84L6TIl28Bl+nZ+gTqWCWlGlNMHP3U4fAhq7jK0tuZckWK4YWKz5B+HYraLaPhPWW+0YY7MpZ", + "2iNh13kG3paEsuofGJDrhvG+DNbUEdGSUGIUFRrIy9u/xynPSUwFFtIw99IbUcvYcggYH1VbGm1lLO9w", + "4ZuD5le5QzhoviuLqILnQ1AZL1aO+zlYxNdQ+e25xCcJmF8HoCfnFX+gwPldudJrrNLAfNS8wioXmKLS", + "xhW39Mh1TPe6QC/7aY17tPCcG5eDU7sjI72nx1JFKrUZkBvQFY1aeLbpHAKJklDLpRCGp965Pyz5sX1d", + "Kii3NCA3ilEDHgQu+rmSU/s89/WUIGLZMLLn+PWQJylEfkzZMKULWRj/RtknVJNCKJZyEAG4spkx0Y2B", + "uT0+lnu13fBX9tXKvjx21GXaM7KvtRDaxL+aeNSWzXIFfy+jFaqDgVMtBiIalrkopUO39I76XwZ1P+jS", + "qM03tDnTwl3FueDmDeXpRmbgeRumwtinxZi5LJyU/4b7/dSUtrT5r3S2kc4swIYTuLLnJ7MQeLYjMm1Y", + "3o6SGTMzCdnsJR66eCbDcjQF41GdTRbjbQaamePCyGNjaDzrYJOFTWw+7ZUXcJ3IKShbG7SlWJ9BPBLX", + "s9Iiyx5mtNAG4yfS6pGDNiSovqEH5J0kk0Jh3ahlIX3P09QJ4DKp1tH25yDh0K19peONdFwC/pMRcyug", + "nkVsNhDblZwYVH8dOjqwAhTpwGK4JwByzxQj4KEp8jK8xZWwmBRpugAxK5Uv2tYkyLrkDaz4hML3ij1a", + "FV86VYBl0GUd5AwZgbcMJkV5D1OaQ7wP6vcnTTUcytJoZsCcshRu6C0qRtH4zs7mVBUyUUzPvJGCa5JL", + "Lsxn5TNfeczWPOaTspfHsBZPq12NAlCPcen5Twy9Y0BltXTv0r/QJKUu97vCG0Kb3Hw/VUHPVkNhzhSX", + "CY9rpYW9tcP7fOcuKKYbBVbzPBERLh3iKw1upMG1IHhiEgxBZzsKzEUgguJ7qtmfXvWZiGXCEnL57i8d", + "EbS8tvHCsI1aul17zRnfoYQ6T1K2MTLCSzOe+MjtpbgISr47PMw0+bXgzDi6Q5u6kISL/iSFkt+urC0E", + "33f0trmlH0tvS37wrxS2SmF1o+Iz0pbDu7eSJlxM1z4NVxEwxVH+FesKWJxPGnVB7G3TVDGaLOz9ONyD", + "yCerOVJ45to3sJAkV1wqMvJnd1OMYI66p5ib/YiMCpWOIjLyeVH232U60whzrkaKuSxqewGjWsmI12QU", + "QEbIxMupwsYEJJd5kQKWQBIRNSSmmnWtNvFExNIKoq/yaSP1OAx9/lfoeiA9cZwQFrzZBLM6AfoRy6mN", + "EGYzDRR+roEOaz+GQ6/f+VQtSFWt/eZMWoKZo6Ozq6vhyft3785Obs7fvxtenb35cH12un3dd8suAnXf", + "wYPln4hS8SkXFCxQS2yk1XllV61xifDC7qSDK/fpzSJnNXMArLCS9lvPZHEZvz8KeS8wHFUTLqCWIjl1", + "aZYRecNMPIvIv/9wFRGsEBSRa7NImZ4x+7Y9z6DewAVLOI3IG2nH3LAHc2NfthGpUXdU1aiLyAUVfAI7", + "vFRsgmu8NzOmkE1mUnUotN0oZV/DiqhCyLXxRu4KfcuhrlLGgw/KV7Qkyz0/+63v+ivj3ch4HdCen+Ou", + "wOWJea3PgN5YhqVMlQY9oVn/zd1GkPfMatlz2+y7nnm3WvzdXYvPsBvYldyeLNm2srlz/80AavBwkUAH", + "KshgBfWn0M0z7czztONuOVXQzihXzEprZEhQ4CB4XVwPFcNKfusoB6yBTlRot19dpNg0ivgZwiSDfpuW", + "NiDOqUM18ZWb7eTQyAJF3l/ObiJy+f76pqXQv9Rm6NlPGGZjmSxAtNhZDi4/3JSPtMgejs4pT+k4ZS2i", + "DI8Wxtf3KB5TyLUes4l0xYz8KAADHAwU9NplwzWqgj2R1I5IIfivBWt0n6jcPF8l9OMltEPjqMnCKoaz", + "whC6CW/sgrOF9HZtcxSLGZ9Xz8Q3dtM102X5IaC/BYrzGeCwCPyOgJU+axi9hJ9HGajdwldtoIM2gPf1", + "KdSBZcg8sT5gsTMIJAeJBhpX7BTKrk1cSTNycX5xhiV7PqlK4HZW1wm6yDqn4EgvO9ZpMxnP2nh0eWg/", + "YXlVKDjtzRzMTJZGZLnz5de34h9eEj1R9zQ/TYu9IThXrdrF+x8jUvY43d9VYJadCjwhrpWMl3TKThTV", + "szWW05xO2TdWJRUJU0yV4XQxjiN7VJDb3vF9RK4Fzf+v254PKtgn9zMs7FgZbfxgbjRLJ/YWoPp1aoUh", + "ufKtWZxm6ldwO3A6VlTLIahXmvYlh6Br6gixd+CrlIwG5MRnVLoykn5rIzv9iHiObcU3E1ZHTboaS+0E", + "j5XOy5D4KplbJTNEKTvceEapHITIdk67NZWyqto2dR7vI+hriP9pC2JVXVUo0BE+pUw7+W/mU+1Vrewu", + "NgDgVGYnWBXjraRJB//O6fuLxgBfCNTet51wkJQzwlygyncs/PlUdB481FeCX0/wicyGrkAKuEaenfbb", + "ofTULpEkH5b3FuAUGJGW+WKDBANssCoEF8QH11DjKrWtkMDE3kcEvSYMnwOIl+UxhpTt2XcqQA2qPO4P", + "yAfNyMhorL523wzvCWTzLHdRapxsoybyFjJPuhZZwDyVliILL9y1uEc6sDTIg6pCCQxTcwbl0vxMMz4B", + "O1VlOJxzXVDoNDvmKTeLATmj8awxACP30E73ou9WtYdWn46pfI1J6MZDmqlNz8w/HDZbHNlcubrICkec", + "DdzaO3l7ve9Qu0xHvWQKLkDEjNzwjEFD3OPL808rxJaP91V+dcM9e2GfGPOexbfkQixXL/J0KR20gdBM", + "GLVYiQvdc40SDkHMNNgxyZmCMtD7weTR+q0OE2YoT/X22bKenGoXR6gxio8Lw/QGyoMjrdLejCZDxWKr", + "rnCRF2Y9SjcuyVVTilmCUQ9QqhEm8S4HiJGLXD9DK6i44w8nb6/DKA/qQiDBtr6ujqXyxh54BVtY7Vml", + "C27CR8i/vd4Pi/4VnHTWpi2rP/tKUPD3qmlF44rKYtPB1xEPNS0PAq+i9xC2bk5fXs5nWjqw20uVSNxB", + "CYrzjeLirX1GaUOcmjcpUnJJuX3mvD25/KPKC3eur3Jig5yI8+cWD3VIPLFYSON8RzbscLpCacTox7Jh", + "V3QpyH14Uk3v6f/tyWVVcJNPvBOktQD9MMxs7MsLcyBW5+1UFUHIpJ1lnr6/IPaDANesrdPWKlAkTLVs", + "+wp+7Lrx105gY9dgdEm4AkhlatgNz7iY9o/TVN730YUfrgLBf2Pt5VGpYrRlQ1h/iuhfC9qUB9Xcm8Jf", + "6jNCiK49ApGKzHnCpP+ppZr78wq9+tYsD3NmuKeXe7BQSDnbWehtlnSSbn7lVy/3ZUNe6od/DhNeufev", + "4myDOJP02R/aDVj8wY1zoGNW6PylmObelUmp3Si23gHFtYZdpl/gF+98i/z9ATmhSnEGvUHKRgAT7KXJ", + "BXCtMZTSN8S1w3Dt1XzbjrolbrlhzaflDku39ZVHrOcRFbCemVOE4LKdR283qS48luMX23YzesfuyfqO", + "RoRqzafCpRgBSWxoapRTZdXi9vNcwgerR4JOJsUY/15r4/PaJSfhDgINjXRLQeptuxU9WU+iT+tZrXDA", + "yCfrC4RRkTXNq8KizqSw3t/iWzqDI7jFEVe2RVoysJMZnTMylmaGcq6MI9JN3Gm4XEoPNNekNj16YqBN", + "CsQPk3ORsNxqw9gwoZ5z+JpQormYpozYL7BoAsZGJZJho8oxyEpuPmWMx1c3zbby4BO5am7o+H3OxBqn", + "o2D3pYJj6Ng+Dh0/gUAJGIy6jauE5HNDbyT+AXAf8BrH6X0MI9Y+lJ02SoFxXWWXukLFdgu+NZ+WjVqi", + "mzJJnb7UzCGtKU4lVQD6Wb0ylF86ICdS6CJjyr5DMX12SU+D3la+n9EMSi4ZqEPIjdXVKFjyOU23ykV9", + "Kq2sCeWvStl6IjR0PES8/qTEt4NOBrsMa043bRFWloYh2cmRLhCDFAyzVMRiWyUjHM7l5Z1g9+miXIqO", + "n0XzMNykAfMPZkWljvfYb0qtFBhKeDNBNcZPVTOdtc/xZFFgKTUWh49zfkLTtJVDW6aDIM2oABNkPe70", + "pwuiKFZtm1FBEsXnXtlwn0RkRkVSyzPG3nh9tGf2ac5duecjqF6jgP2lfMLiRZyyCHqYu3Z8oA651ztu", + "xvVvKgvG2S9qXasnfOr8QwNyM2MaDJ4kk9qkC5K7C+hzkRRxWXEvVxLapms6ZxFRDDqJu64h+43D0qnl", + "FNgMQndmum7VxzLeOti+stx2luuue0hzPrSo/IxM95qpOY83xn0j5iaA9TxmhD1wA6WH2UMOxaTShdXC", + "7TsA+LRrYYPYadGLGqn6VTKpnhUmkfdinyQSlA3XgLOuiPzPf/03hmdXq8C6GkO8mcpcFgcYlfpTPmf9", + "Inf157GbbCK7ojhS62MRPHCbX/G8Fc8dMn2C8O02uGxfSh322iykvnSMsoY6OXvgBhJEAGE1n1p0tcwc", + "GoY8WOW6FDCFSJhKocVuU1qosnpoPKNCsBQUfqALzHpAgkRFwywiNCp7UUTyGdWsiiMvYyUIF/ge2IPH", + "fJmLu49O1fNT2KhySRghKoKZQ1XaOyw9ICMg2iIfkYxRgfLZHzzh9l7wJcQhhUnZNwa8fyiZMZqa2aLs", + "bwtVEwdk5P7bT0hJrticy0Kni3JMY4Um8xpN6ZwNwxvykChrU7ooeLTGl+UwAcoGi7IbZWH5moiqRGwb", + "omCp2Amvh9t4sGKFdS0zZma1eo+6NFaUtITX2Yt67h56Uc+dKMjU8qCZ7/x0JesAr2BAjsdVOnXobuxi", + "pMhX6+cGr4nbJyZJpbBDy2qWFJtwXJ6ftqRUuQsUNOjbVHKqaNbs1+mO4e/TNZaGQt+8yOwDOSuMYcr+", + "a0XJG3WpWlzfU+SoYh0rAkHzXmY/8lYF9mbGyFsuigend5L37y/6dzxNodAwyD0oklZlUImywfNPFwNy", + "7bpiQ5DE6CBh84O7TE9H3spg0YyKihxg6iVd1wuNjGVSLUqAooHOR5o5j1eZD6KLsZsTVG5qSnani9xe", + "lO6eSPVEEnnlur8K5HaBDJc1lDIbWpR4ToEcBsv28tjuc0kcNw/R3tIklkIbRXmIAn+eNWmBxTxB65sn", + "xQEZCSmYFxfTVI5pukotr8koY1lcE0vxVMki918C9AE7Zty8JqM4LzQzI3IA46RaDHOZ8niB5rp3Hy6O", + "D/APfftsZQJot2LPUrgtayLTxD/6vhscOo9zwpOyXZnrhKeKGFMhR1JmcLSjEUm5YE0BYw8LuaVZbGUL", + "7hP/UO2ypTl8NpwoxoZ340CrOcWY71zvroQL8iP/3rfqq4cf2c1FJGEK6i+UIWAjO/vRu5EjNS5qoPtG", + "kwuW9c/FRJKkyPIBOda6yJiFxCtYB+uG8d/YgJx606fPUVYsTinPoNlJbBUQ3+RKZzRNnWcfskgoSama", + "MoDa0EhD0+HdeAStWrSxOGrBjzeOh7Ugt0uB4kdmVCXYNBUKcDtoOjbikbAOO4r1ZmBn5QG1q5dbbw5f", + "I/f61gKMy/7yaFC8g/vU5Or4ArHoEeB4nlvYpPk4YegVn/Ac+GOLInIisyw8G4GoLZfY3BS3exl9IC++", + "s1q+0lFNVjQ+aykgoHUQpFdMw7uAaGZQ2IR35cC8pwvYNxVS9JXWaMfCf4FuO8tYZv9zf0BurJbqKhLl", + "s4XmccX96uqhRfNCg3IXRqK2vpT50FB9p0N4mpNKyRhDjXk4ZV8z04dTuqUymdU6qCPGarx7OyV6A5e0", + "pQaqjm7sFvCFMSLO13iW5WaxDimdSdl+e0LhMUAN+Q4C6rhViyQZywKcpCi1ANkBWblhWEl7W8XG7hMo", + "nD6c4xzflbdKlaILVFr4dMrUcBMBuO9qT9EupOjaqorEcrLRyeWHI/LOavL2fyxBHI1cvY6abAnA3e+x", + "M4GViDaTmhGaphLrbZRe3lqpL7dvIwkXc3mHCnOlWw/I+4lxzxvwSlNNRvWdjMhebRpHRLVaGEztQ1hS", + "TAVJ+GTCVL0zNgyKcZvuZ3uncx4bng3IRRf6b9xbW4Xm+t0hvytZRFeVDBBqO23suHSzO4hgBOkmqgIp", + "sKKbdYf7Y/jmJkpYKwO6M92mFF3lSh365SIQHUQ3w7LmDFrnnaoXsUGXkH2yOVMsYnZZP6bhgI16Yxrf", + "WUVWJEP3F/8Qvpfqjin7hxlVLKn+G2rhBTVEv2vvEjnBpwRn+gT8IbvY6XwFj8rP4vwhkCTMxRSfwd7x", + "0vpIoLmJZ9tHki6fZeFOslrO6ARXIFqmc+atJEQWJpYZw+JGtcafz7gP7HqKkQYHCTOQ3Fxa87z70qJP", + "ruQD+q3Kpql+n1qi3/G5Nokr2OvJC0P2UjmNyD1VIsLSvfuwK8sCiunMEPYQs9zFm+H+jJLpM+7veGoV", + "Efc0c142QqeUC20aPsj/+a//9v0XVd/tC9yWOiKXKV3cKygvDtZj9sDiAk0vVUV/tKPFKc/H0opcGiOr", + "gvqYVZ//5zvqB0xELJfy1sy9OOXxnY7IHVsk8l7oyHUS34fN+QJ2z7exejuAg7LGki/+M8CAx+lzYukl", + "5CmUpOMvph7khiVCl4oNvD25xEsqHa7PyXbSVNd95M56uOIab9Zs2iv93XUvd+RFZSe/9v6AXITd2a+J", + "nEys5E7YhBapwRqquelzAfdSa9PxjNDz/V3GzY4avmdGnQgH5Ac+nZG5TIuMbdw9WjSfb+ffVwEO6PGI", + "iC7imdVjZWH6ctJ3LzQwGmEVNHTs9r2BHA3mlo98XKNetOxoOzF9UscJtEl7FbIutHGFQDIf1uUK2e6Y", + "w2CuG5W8nAKQDMi5IPVytESz1Dcp1g5iR0Rm3LgoVK6dbWnPScH7mQSTEE6+T1JG5775sF9RTibOWmTX", + "cotrwh5obJz3Li4VHdAWjcTStLC/45uTH2oFc9t2o11QK7RXty9ThBYZ/f5xtA+hg0TIvsxfNzenmLFC", + "CRxZ4JazCit60m6kq3lGpCIJ19jtvRo65xR3F5GFLEhWYE3zBLbwkKc85oaM7EFGdoYRAH/UeLmUJu5O", + "SLYLclVNk+MAmjm2NCDXq4AfkPf+Peu51x1blHe9fNH7FmpetQSjvyN+zcwRgSYh9wxkOYZBuPAIcAZr", + "l1Av06jWeS4inqk65XN/QH7GVP+R29EoqjzANRyy4LB45EjjCLAJDMce9V8TKhboSpQumNsefDKBWCNs", + "gVfNt+cUushHVGNX6Kgu9vcjMqoY4ghjTD1fR6t1gCsC0oyZvXJwCBs5IMfV8RzQfIEe3LA7FYlTRhXS", + "mglDGQ8zcs2dauX89rDHX2qBLpVjkvvojTTVHBbhZ0yx11BKIZX3mtDCyIwaF85qX/Xglqb1K2symYCb", + "yx2va0Rf63PoY9RjD1YUbTvTGYzys3QhvsaI7UjwjVT3FEPj5KS8lxrMjESWYZiyNJEwbaCMqQXgUkQ/", + "FG2v3e4RwQtw2EsKkYLJwbGfdFFii4VjBCoY2mKQSdmhtfVgagd9Jx+Qa+9NCmh7mac0ZvZxUZKNmwRT", + "B1yymfubkcj763YkP6xGXaZQwn74mnBYDhh+bQXk8XXJ4vk0PmDtM2dGxTSMa9Kk+bbo8f7m7eX2KLIy", + "ajs0scMPQGd31+ff5zuI/ACScXjnW0SsoucrUBO7ehPz3je41YD8AI4awiYTK1b3/CYNXWjChWWCc6hu", + "ygR8tgm3OovBExej4NUkdmYfuNvSIFZfRSvcmBqIofHRD9W24DnqnF7auQoxfAcbDq2CImNau0fUqlkt", + "HBlUrjbEqTOaa+z/CAEiB9Vzwrk4DyxrEJpLceACXA8SriG21Qqj12UalZsQeiVYtcZlF1mMp4a7am31", + "Pu/NnYBlrT5T0EgV7pH9PncSvbrL5a7Yg0aYjsyH/v6xQq8y9T+4FvRwAfaqLad3l2D/w53ff8iLbDhJ", + "6VQjfOwVbXba+zN7EIbsiCf2DX8hC81cM4ctw/DHhTGhelAwJcFf0Q6PigRI+to9pWxielEPjCB2qzxJ", + "Um92xNgGS9FBOIH5oaWo9Y0zeMI3zj5TWzWR9/Y/IYwKPgkuMJNpMrxjCx06XoLB/vZnez77bb3zL85a", + "8/SsRv4veW1EkQ3RooLLAVfqHb1YpvR3kNoN1lyeMUdYOXNGZ7/uqhn7YfUU/05iCW98WpVCwRvLJUbW", + "BmcKlJP/j11mWkLXh56dugVJ0fjl6sRsW5A3WJn7xAnZyrIGOU0uyXFzaoOdNLhZZ+w7ruxyO/hWvMnQ", + "4a6FMloHQcnIqXKNYYDVOzUYOwaiNoEPXcfib0U1S46FQdDRizJSoe0MOyPCaHsJ8Gq0H7ixOVU0Y4Yp", + "PbgVZ+5tK0X5O45s1KsHt4N/AeRKznnSEhYGpJxZnrFJlVllWB+jXqLotNvwU0Wny6MzOWfdRl/IOVse", + "DcEclk1sGnxpP/yRLWpj0V66aeA1fFUfxswwLpSWG18Y18ycwIf10SljGzXGa/uRQ+FaANlq+KJ3La1g", + "WEMO1+DbuG+c2Xdlq66yvJoGbBsn9wcJce5q0g3HtHLihj2Y8nqWqTzcZibqnShGDTuFTkNSLXYTnplM", + "2BpNI/GzE/sh2ZMxBO7AKSMCAa7//N13+wNyisICZME/f/cdKHHU2NdW76j3//3tsP/Pv/z+bfTq4z+E", + "awKYWSATZKxlarlNtQn7IdhA4OhLixwM/nGzv9quFLrMU5Yywy6pme12jxuO4DeewDJPv/Erbynfbfch", + "3/T5Su5ilX7ms4XLE0UoErA5hyQH5acHoHUOyHGaz6goMqZ4TKQis0U+Y2JAfrZvGfcKjRo2rdXVuHar", + "JcvoRfu/Hff/etj/c/+Xf/qHbtWyTlG77fiMXCqxCUa2dnnuXw74XVUsrKUu2kQxPRsqatjmKd3XxH5t", + "J/7hN7KX0YWVbqJIU8InYF5KmGExBAbtBxe950kIX5dXg8/W7j94tcsC7nn0ecuVW3T5UodHpT4Y183s", + "26au5h4ua0Kn9pOVmrFjZu4ZE34jVo932RhUodFcEiteCE1lWVbCQCGgjAue2Y0ehmDiS3UOM92aUAwh", + "lcR/ubI37zi3lKsY3pDdS1amU+hMSjP7VzT9g/EZrNTe4mgVenuGMdWuHQosCOwrZWLqzkEf8BwvDg8P", + "D2vn+i54sMc8YuwRtnrDhBnxewXV60jKNWitf3uIyOKX+oshp1zpEna+wRB2a7GbmEL83oXVJJ1qSqgh", + "KaPakJckl9yFdJQ7Xd5yPTi2DJ17CZdX/cfyadb+iLBs4LCFa8B5TmZFRkU/5XeMfM9+41D5W81Zhc0A", + "4Xu6wIMQLrRhFNpYpVww6rzvuUyd5Qr4NqwGNgg9zJkaajYFTENyYPkQiGyYaTDN86mQzQqCteyDxueN", + "I323JV2WJc1gXysQPMddrFLDRvpcOWfzkXzY/koutwS4hfuC8tLuvlzYMrCJ9g2SC9weedHY64vNAV1t", + "ukNp5etqb1uaeJ1V5wyfilV8SVdhEO7vWXt8LoWsBHItkhZzDDb8Ovg3Oqf4T4x5qebGVyz8cUa1i3Ox", + "v38DraAi8o2rO/INPl6/cV6Wb8icKm7FrXuZZnnKjshtj95TbrCdzlQauffNzJhcHx0cMPxmEMvsm/3X", + "RDGw0Nc+h4oJe/uvb3uhMEwsdYklj+IGHv5pBQ8vkFtXoT0YF10VCSy1d6th/emwweG/bfD3zbgGl98R", + "HzRseEt08A1pWwOXVi35HsuXcpug/bpDYas3VffjOt+HG9m5Ta8+QzFDAyFZxYTC5vawuMc+spGEqcB+", + "rn1AM/aFL2NZ6wcLGIoTGSrxXk7mgtc6zlYAwq8Lc2D122YJcUOg72jY2dBIYHQLhBDkDU/ZuZjIVX7E", + "9TDhav2uQH5BBEL5WmxpVCxbSydbUZ6BQuLCun1FyzK9LaGG9V1l9dXcoyDfscfCx/OYG1elICK3vUTd", + "P6i+/b/bnn0Q3fb66r6v+vb/bnvhGOJwpPL3VLNGIiqU54B4itWb6Pzo9jrrKpLw39hwvDAsgCfXLgQZ", + "fh64Ks1+G5zpDtHHPpKcgl5fWyzyeFCDobv0NnTCMPOWxNc3Vd0UdG229cnvgn4UPHbQOa0jHu4Ky3Kp", + "XYG6HZaErW4uL3SRs7qJ7eTq7PjmrBf1fr46h/89PXt7Bv+4Ont3fHHWIccT0ztbFRZo7rkSNhCG7ym3", + "/+XzlwvhOoOUxdRKr60LmfQdnBzf/hFzKCBBu0pBomUSI02JoQ9SyGxxBAnOWEjEdZCsZtdGMZq5lJER", + "tIQE/51UGWgWUpSwBh3CbmXMUnlP9tCAjltCy7oLshq138MoIopNqUogRgGiGSTJi3HKITedmwE5oWnK", + "VL/6o7sAiLV6f31DDsrdH7iffGZ1mcbq/dtc482+JpoxMlraS/kehVbvekZzNiA/0ZQnZaOWGDbj85Pq", + "8ctclxfsk79iVwYOuoJCrK13uIKOlFQQR4Gf0Ty3aGZ1DF/epnvVIMgzhqCoIcTLD73wXzuDC7G/tiNQ", + "WyknS/Khi7zaNEeSn+CH9bH2eF2Hn5bfljNgeNXQaUPrJ8BvQUNaHp/KabfRb+XUj62FcKF/ccMM59X3", + "4GsJzQPejq6z/MgWoTnQwF/Weuw8HXpDGvVLo17K52w45+y+I5Df8jn7ibP7JUhX03SGt59pFeguKq02", + "1cZjXuCQ09qI5dm44GbodOROk50Lbt7A98tTKeZW2Wq+Kz9qw6Rbz7c6Vz0KvMtU1+X3fqZ6gdhunfLP", + "k5Qtj7bckYtpt2ty87zFMc1LWmra3bV3P3y8OodrUd9xklqb+V7UbKe7XZNiPzrQm3PHLqh+xqVOfZ3b", + "0TV5wWrjte372pXTxPkWXY7KUZIm27ST8ONqJdG3Lje/OscW99hSFzpaKQq6bb3VXhQocrdhklDpx2il", + "htjW9dl60UrZk20ryriKAPZ5sngHTwjUkj9GPSlY90SPZSH9MdpmWE0z6DgwxEi2HVpnH9uNDXDC7Sao", + "WHLHcSHy2GJomEdtMUFF2FsMWiKcLUY2sHybbS4zvW3Gepa3/Xp1DrMTQHeZIazVbj+4VGa3HxpQXDtO", + "0qLebDd6VancbvyKnrbj8B34QIsm23F0Q5B0RbiQEOrKppcekN2HLb8hOo4MPma2HLvj0m0P7o7DgyJ2", + "1wKs2L7oLdcGrIsBS5xSdEHkJGDX4wLNzJDejPVbBl3rtJS284BDvBTxgVK7qZwul86geZ46+/faSPzl", + "toPT0pVi2INpbRPX0s7qhmeu2Wq5I2xGi+UhuhrhW/yT9aVDZsULatWLzxVBlVF194TxU3Y6psBQmNTy", + "UFrDqraMpWqzXL+rGa1xCxGBYjgUbXcXl69IPKO5gTaPJmXOzfgWokp6Ry+do9H/94tNwIVtdIBmJy9j", + "l4ow9RPiLbLEHTWI7nIy0cwEo3kulZxzjSGW+Fnz6ipyrIHLIkK0HPYQkYxRDelF9dIPWAYV/LyQdK9c", + "ezbwb9PCzKTiBmMS3PrexOpAhBPcK4tYEOky4YKm/DfWqdxj2KdTXUgQbLLQ7NKF6l+VloVlZ2DXHAIf", + "obt77kDbDJ1zBlZCtbfDwieMB4PY5UdGgiVcGypi1ggP+O6547/snreK/3p8UJTz4VURUPafVJilWwy7", + "9TahZxVg5jGMGLkTmnadaSt03T0AOmHaDDcFctcyFb1/eVMcdNTTKt40MRaB7TznclSCXyCqnSJ0Q+/v", + "6nxpi7CVv2B7IvL+R++4YqvKlbzbiLXn2K6MaR93MdgccyHvgme5pCaeuSDo3SDeFgV92h79XDKKl68O", + "t4+FPm2NgR6Q80mlBRXaJTHP+HTGtKkqzuMQzxUVA/RxOpDzYv/pMPr2MHr5XfTi8JfwFuFqnTl/E7wm", + "LkZSsYnlHZiByn9jyILLilZWo6tUPtdTxWpwkPEb5jQulbVK6FzVP6vVUZz7NF9XOL06v4+AMJIwYbUJ", + "6JuV0BwTOgS791Vrq0AxwAm4yxmjyaRIIywB4f+StqBna/D5aWvQeYk237487BaCvpzotJvk3RAe7qWu", + "F1tYAnChMSZ8uZ11DUUtuA8j/JYqRgyU7twcgbpGkJYZO9kmiXrHFlj9l2h7OU6idxew4fXfusBqO7te", + "ZGOZwuKw0ICc0XhG7BK+OduYEVr7lugiryrVPiTSSJneij3NGPn3Fy/gLIvMvmGgrYsUen9AXJilLiso", + "3/auIPjutheR2x4YFfGfJ0al+K/j1P3pzXe3vcEtBldj/C3XGB0ewwZpqqXdZSyzsRNZ2iU84Xz/ZHzc", + "FvwXrPZPN3QM025xoUvcGm43yK+x6NXZA4ufLJKW2uNlEK29EJaPCGhhsSqaqJo2g7L/FqiWhzNRNS3K", + "rvXdsYrqoZKyGVIdPkbR7AkBZVvsUJIrPucpm7IWtkP1sHAVUdZP6Zs726/tVKJIQXp4Hr+aBo5nD8RJ", + "wUX7+kZ6xtK0vHIrC4pwj9z4PlR3QipoXFFZjPZoPa5r383oImVwES5CB9isczExb0ev30PZNA5mv39c", + "BtiZmHMlBTw8yihp6EjgmlOGq59WmL8S6bxdcHM7ANtjmBGcG8nwUQHMtE50JcDKc6wS4dr34Fl5/rbH", + "YLiyLHvgZhiOmL/0tXV9a6GWRikQzzwc/+lVOJyxVtUOPyXjYjJpsZlgPHPXyWRh2if72A69H3mVy7wd", + "+K6xsRJgryhtazXsbYIMS281mFrv5uzqord+3npQpfv8x/O3b3tR7/zdTS/q/fDhcnMspVt7DRJfgSq6", + "qzTB6ufk8uY/+mMa3zXL2C9nZKQ63F287KwWy7TIsFX3umyDqKfk/aa57CdbpsjArBFudM2NXef0XtQv", + "rFNtxYDo/hgt27VcNXE2NGaxWQoeu68JJblmRSL75en3Lm/+Y3+ZsaJmD4KoDICbM5RILeIyDDTfinMZ", + "cK7gVe0QYFFcTqzaAqQrK9nPdl9mlR38sgLXHfj5ec1rQ8eWIVGi7Wzr6CFYC/z9dQmstp5Uvtp6aPg1", + "9Ajtl/34A91ga/spLbhFwZMwI6ZWHR9SE3bWYD+glQ5dbtgW/ppWUjPUFHrbMp+16pKFRinbzpXyYpjH", + "odbz2vAMosZPLj+QApxaOVMxE4ZO61JQQIbfBjFadebjzWryM6pdb8suOgq2VGnJu6h27BtU+P4YuPsy", + "JaNFggfNLZcVTE0jzr/q+obbD8uidsAmXOwmdE6poZaT3SuOBtAl1MOUJy7yIpDGkVBDOykWSX2VzU3Z", + "ynl/2XjmR+mLdjsuvVzb6VZP6Lw1bUhS5aPCB965M+h1Nam4oyhGq5yabXSn67OyD4liuWLacqhaE0qX", + "qybVSj3rx0KzdKdVyGJPEVRBWdhZ/ra5pZXkF0sKwUIDnVhDyUhxcq7JLQy87bWRrN1/QAqgIdwlncha", + "a7h4Voi7Znk4SB0sExI7EjFmjQD8H2eHGMtkAaLJJaL4wsJ4AcJR93IizWBtP79QllJZ1ZmUNjKwUyRz", + "rqVaHLkyvXdC3vvVXRkr3/OUKYJidanocsOPmmIRckxy17XKyQNyjqVDob2wdvUCC4ELxoU2FjcXOdOR", + "RQO0vUJ5QeQxzdZovu1BVdw+8m0y6qX4q/4DtQLvjeYOZYnwRqXzMuWlCoFf2xWxrRAy3qOj9sGjWyBu", + "SEKrKTsdGsK31VPCmAGmwkmoEy4gW6qLRlQ57f2oNn1oo2kJVb3VP+sywqH2e6OeQmf9bSnEYOfNLt0z", + "6JX1fYbuvIonvGLTLrXqurmgfnBVsH2wxtTZQ9aU4WlxSvwMzohtJuoYoIBzfWNfZnk/ZRMrCJRgjwpZ", + "2GLOoFfY30LkL3YTyHZxrqgS0BsKzjURIyiNmmXptnVYp4YOH9b7eH6Qiv8mBRQ9g7UIzWQhzIBgpIp9", + "Q8PfNYFaBBERbEobf7dwCAtx3MGGIkQ/2R3HHdZP5L0ILF/k4cUfE5RRFsbrbt/fRBXUuFLAVfW+5lLb", + "E8XWU3aOlFgpabgl1+JJwsSGKgsY0VG5y9ygje5+913Ltt/wlF0ylXEI/dO77R+ayoZtcNhvFhPYFflL", + "w5CxbaWEQK3BP716tb9daUF5L0IuH7tX+AmcPH6/H1r22yWrHhO88+pu0bOLTkRXOn3Hsn9rqhzUa2Ru", + "2biMFprVa55gT5ScxZb2k9KNsKUfou4Uh+KYITdEvbpMI37scCNR1hcPXohVYd7on6mJn7SSY1lmEywD", + "UPE2XB/GEi6fs80m3JLa3XykHJsuOoT1tAYpwQ08Mpp5omjGwkE4V5Vu6z+yIJ7klmLnTCmeQIcZeDa5", + "G9ivw/zl4SZ7cNA66t9uK3ZNeCotxTS70GP7hsQ4SV4rgQO9AWsh1oSJxJU929NG5pGLyLYCFVtnYdVJ", + "7PdG01Te21FZkRqeQ51k4bsllHPqJ6t4WbOobhWlndEHT4vn4hppr919Wi1ddx/6MNL1gF0Ly4w+QCUW", + "/hs7Fxfft+8AEiJ8C8uL7zsi03IBwhctYWX2dMdFwuVmujxx/XWo/RyLOGqeMDLnCZMDcoU0qOvWAasi", + "0TkjVLhRLh7R4stlkWp27P4a3zFT7wgBLV6hxAiBph5jaWa1hhD7Dlsw1KoZDs417qgvRSu/CPAGmT+W", + "NUgVMzvP5ps8zzKWcGpYuiCWsCBWQxaGTBWN2aRIiZ4VxpKZK7CSQXAfGDyhTUkslSqgaw8cFXAk7Kx6", + "RPoFkvynKV9r18qfpHxtVWlFzFkq820jUm+gSigOJaXTyEC/+VpJL7JUJSbQJ8WbS9fWuG7W6oH64b+2", + "ehz6mRTSSMHjMkSNoKul2imNldRIhCmfsHqnbyTKAfmgXb/8t1SbPqzcPz91MZiFyze6vj7z1lInILjG", + "ap5od1tJddjCqWzP6O3Jv6yFYVt+1lKRIkzfuOeK9VM2Z6kzs0FhHShWmNcKGDnIldINuJEvcuTKFFWn", + "H5BjNeZGUeVrDTnNG1v3ucJFVZkeyyATnGxA3qw0t11XTSkKlUGCHTPVB3Meog1JZAyhZNC1C1v+O/vg", + "P7r6QgdLfzmFeWthghFZLaIUrP7f1Yj8pZhiK2j+2/X7d6UlNgSqlGt3xevrSmGZPfTfLIOu2cEhBBSE", + "qb37xxqDfdftkA/ceIRzkrn0q6AbCPpD3FNda91trFhxSVNW+0h5xltyO0xAgfog+AMpswvxsWNZ01Jl", + "zeqinKYIDOu+Jj065VV9KlN4Cftr7xrewQnf1jBvNbo0z1PeYqv+maZpP4bGZz6bzRl1apfZbLto4eum", + "xMQm46vpNjp11bvwdY9YiFxDp6376pXd9HaUfE64pVSbFaFMTiXDA0FzOC8cm9eCRgg9WCvUDjsER8JB", + "8BxB3FnqZ7G1VfZxZdnv2EIbJe+YDpZSDoYLhcs975RI5iNcq334RLpaQpnlRA8sIXDYwa1oMAlVMLLn", + "W/llPoXwIPFF9fcH5Br7t5YZGLfChcxbFmDXArWHCiL9q7m2XuOmyB787V8P7b24PLf9wa2olfeGlkT2", + "1hY5Sol7qZK+5ZUJOpVdDHZ5ci6Mon37FS6ob4VVIQTFqokgG/HnnBbawukG9Ga7N+TQdi9rQBdsaxe1", + "9FiyqAj3Ck1iUBjMJMT5Y3ujlqqXcmgJJmbrcRHa/8+olfX2HbjIJeHi767Nq6KGvSYZ14beMdSZQE6C", + "OgJ3Nqbxnc5pzCokIIcD8l6kC8fCdOgGyJ7mKRMmXTTu6VZUnwFu7ONVla/lw8GLINb7OKau/aV+Vtyw", + "siPWboS+HlqNCB9fpdUvuGtjrI/Qrx6du5CC3jvqOcX03Cqmmhxfnvei3pwpjds5HLwYHIIZOWeC5rx3", + "1Pt2cDj41tUohYMc+ASsA+yOhybEOGBDvGBqyiCZCr5EFGAPXEMUjBRMR6TIrfAhS5MGUrjm3L7UcqYg", + "jCGJkMigfnghDE/h5sqvT9n8RspUk9seqHuCi+ltD6otpFxAO0M5Bp0pIWM2kcoXsoYHrMs1BGQqOwuf", + "J2BFNvHMr/LGdQd0peW+l8kCo3+rjmlVcYmDv2u0WaPEDDjc/W0uaRf+SHiHRpIMrtUVVv7bba/fv+NS", + "32GeT7/vukr3p3lx2/tlf/fUHNxQGK2q7yx9YnYepHnCOi8PDwPuDtg/wjuBR1Z5NAfs5fLaH6PeK5wp", + "pHmUKx58Tz1NYoH/j1Hvuy7joFCQoKkbBQXBs4zaV1HvA+JlucWUFiKeOSDYzbs996LeQ7/Us/rVu6p6", + "+9iJK/wuu09uoptCM9X3HdyqjTDoS6G4ZgQ7eZLKcFhGEY1p+fPA4l10KzYSFNmenm7FtgR1whS0EvG3", + "4Hvk22fMnXszi4mivuqww3Ny5ht1XrsGttGtyJV8WPSh1wRLyhnxHOX8HlHBeH5yenngE/6l2AcJBU2G", + "WXIrwBzi73Ij7V9WTUR3Jf+w8AjpXF2APyA/+vRK95OgGdO3Ys8l8Tl5eyLlHWfa3eNtD638UMvfufBm", + "5Qz418GtuGaM+E4O2EW12slgKuU0ZSViH6BrrUxB9n93cV2YxGjP/z3VPD4uzOz9nKkfjMnPfAtivIPg", + "hsEOZT/WH/KpognT5Sgndi/ow0lpa9CXTF1aPOkdffsy6l3KvMj1cZrKe5a8keqDSjU4kVe7VPR++fhU", + "nM/jyhfL/JbRzp7lMTywyFNJk37VfbdPRdL3s1nGKHVAWfoAw7CCuCKZ5THlFOQ3nhOq4hmfWx7AHgy0", + "vjUzlpFCJEyRg5nM2AEymar7sT64LQ4Pv40tscC/WHQr7JtSWS6Y1VdA3s/FDspKyVtvxSdUVvC+Stap", + "j0VyVUKsnWuhow+6RkuV9b29rU1vqfVQbs2Srr6xCgyCH72LseFzaholT7rUJnojUwtTCGQwkkALedfv", + "w4NrO6gveSiO+3+l/d8O+38eDPu//P4ievndd+F4i994PoTW0Ctb/GuFkL6Dlgv5LUSOCWQVgZW73oPe", + "rT7DO6OCT5g2IMT365aMMReWVje9DMrtRe31o9YqgTXo7qYJvgiFgZfYgKjAkijAD5FqSuIAvzdNPjdn", + "XGFBJTRrSL5HtWVIer/OJssjduaX7sV+MPZ6Ypgvnvn0dkHkUt+3pZ7GGv2MruHx8eU59CMYkGP3K2gP", + "GDpmVSK0yRlO03ThGovNZJr4yPWHOC20RW+rQkVESyKkizaAnBRSsiNNYirQEpIyOmfQNMpH4mgjc+1N", + "FROutHEtgXy7ZA8awstyMGgT9W2QsRX8rfBdKwoN3lboUz9zdJcwTKyzr8/K2gg5U1jnyK52xxbYl9pd", + "163wLtycLuwszvNBlCxE0jeK58SqnyLG0H4GdR9Ewuc8KWjqpgnx5u9BmWz2rd5dlVxrmV1dqWq9u5tC", + "A1O29ET6nNRZEgL26A4SQB2n2wnRu7CadLjUM9tTYxOyVbfsZwJooB33jnDEDqO+2bin+88KwmueFSkm", + "+iJZYkt7t8cWe+a2QESz2oEVJ+1wvGI0OamZ4ELX+VTwbLbaB3AuvQDLjvluSZCFK5T36Ou3h0YLeBk+", + "FrBG7njfYORsv/CmlfWZiCdsyt2VgMB864tGGlld0h+HJ/6MlmXvFXgKgJZt8MNwLKPFnwmEqw32O0Pv", + "SdavVcULUSoGss+579VUvvr/MCjxA09cfR553yz9uRUeJIpOV4Xhsp8XCgyJBHMqPFPHXtJR6a+z6iX1", + "FTntvpRBBxlEYYjl/tJTPvctfFG/ThnVDBTAemfEDc2PQ2pZ2cr7mXB3pVX4rpzHTvQHEdmwlarqKoKJ", + "EhfKvxVKTZlBjBrmrjBuO5v5CzONErrPKaLDtXrD1A8RGngV5SGe4pr/wkwjCMSpR8hu/EpPoiFZatuk", + "5Za1fp+JUFZqCT9Ox3XXZE/2eYnlwpewbYDPS+YyG6XiVfpJQAp1CbGH3FpW7eO8y41A0ASw5Vp0RZkr", + "gz6HKmmrVg3xVoRqHGJAHtThyxWbMYH2g9ViihHRjN0Ku5lwQURCTeWSmHIzmCjGEqbvjMwHUk0PHuz/", + "y5U08uDhxQv8R55SLg5wsoRNBjMUGS54biaFVLoeZuPCTv15NSm0ywSJ3VVAzo92xkYEk0yC3iNXofOZ", + "6GW5AOiu5AIABWz5I2ksqEbUrW6Al09BGfWGd23M7obeset6pOqzqLUrecYfHRDXCjUIMT7IMS++Wmmz", + "oXhFdlUbwLjlzwrxMiuFVADyMYGPhbdM03Y2iCnWZO7SkLHMxYG03MGnRtu/mZoiWmPWTZW2YTFtFKp1", + "umojxxnNr1yQVE4hA9rw+E6TPSGNy793GVkVipExm9E5t0RBF2RO1eI1MQXYOzOIfKtX1YAYN8i4qY6C", + "zl+fcg0J2s4K7AIPokZVEBeiBV61hnF4r5wD9PVqgX2M0wF7HAZ3+TB+z0xHPpYPLT39vmI5o4a8I/0+", + "BskdEvTW4KsB/TWjEI+99pnOz0Sftdz7XfmrQ68/iLENN1OpIwgeaqz6/pQapY/ibmGvLoL2mQC3HKD7", + "KGMPRoX+YQSjPRsadx4FJhcV3s4Vq3Lb3jlM7P/DwPPFckA68L3SoacNXZSpYESKmJE9DDCJboXzoFe+", + "s8iyHkiOdM7TqKZ3uorpmv/GxXTfGQfKharsUcIeaGzSxa2A5Rp+RMVowoXVJ7gm9J5CQbqqVtIIq8wX", + "Kh3Beo5xUTJm2vTZZCKVuRVVy8+ytryf1XuM7MygLNrnGZ0yggkp31vuaqHku4yrDPrMJMTIWzHyKu3I", + "9SihYgE3TRayIImEoHfB7I6PDUkZtYqz8DZ8jLexX4MXecyIqzo2uBVXPhCqCSttrPqqClEWBQcX4lEt", + "nqoOGweBCIMhIlDQxTLEBkGQQD0oBAcKTyYSDIUuM7YwS+FWGEWF9ir2EeETQsHNpqpwLrtvcPzZDVKV", + "WsFaUSWBDFY2mbDY+DTLjHJh8QHWxtDvmDlctX8SUvRfPjw432OuZE6nVqQPbsWlYhPmcq+lFYSa5RQy", + "wUdVLMg/jjBz7MDd0Qh8qy6euUyedr7gvlF8OmVWFbsVCAOkJC4Anj6HsiTNkLjzt3xS0u8ThnVgmNew", + "Hq64FI1z86b/Ly7bqhmLRjKak//5r/8mENWvWUaF4THUGb88vjn5gaxGQ4bLgruvhi2hsbUdYEQCGf1+", + "i2Grt72jemTsLx9HHTcEo4O7cWDtso3MMg3QbcJvtdVWJCOyB6WIDrAQ0QEz8cBnQ2NJfh9Cv4pAmESg", + "I+8rh5zyMiVomRtXWbnNMLQGpTaJNFg1cE3Uz1k9KEuDsdXvPrYiLS6gYk81xQDiePAYVS7I2iix/cHm", + "kKFHB/Q8f7QNZAnYIUPHO1dv01A1+E2bUCwR5l9ruN5RI9IJgoddDqtjzo4V6AFx7MxHy7lSLtBTwDVi", + "rAJB3WD7//SBL8Xv3wCapXb8HoQ+YOgkGbmwzQNcBYIsRvuYnTyy95YPK5IYoVQAFongdrEl/rBmRsto", + "KG3lHXxwr2ies6qZJF9K82oDlysTZ4V7gIyv3pZuMifemRPuFRdeK75Le1REUujqZ4kqpkhrhrw8fPUv", + "WIo0qkjPAjCG4G0MaQEe4QCAuxinrKV0fPMu1yhtVUqdv0FwklRjsS6A4jm6fZdwssSKPSsjy4pbLncM", + "2kewB6TIjZn8fyhXXUMTcvzydaVullhgZ07Zsg9v8BjN/9XhnzePsxtMebzyXniasINl7cG/L1rviYHC", + "Zf8XeHkZo5+QfEbhiutPk2PQZ/Dhn5QKDRgDXD52UxPN00Kv3D36dTpFy9Xkc5lXEQjgd3L3ucywgS5j", + "nxjn3eo+AXcVnB+cP9q/phpg+Gw4/eho9fBxOiLPRB/EilHDhmW7GUCkIhTgBR+WBbKeK8qrucpWyPRi", + "XT0vPOcfyIaBJyUUMgWT2rV2hRyWq+oAuVP48Lkhh6vUO0vu7OQvgYZHTB5Hna82j3snzRtZiOQJowNg", + "54Q+BrJeH18D1Deodv+x4QkVH/8XgNK9cTpD0RWWsxQ6/I1DJa0pM6Fae6ZQQhNK/np+ScpXS+214x8x", + "Ze2jqn6jR6/BalCPW/+Uq7/yHDI9FM2YYUpDL5u27q0l9YG2bGT5KrFKjD8UvEPtuF8LBriNr09fybKJ", + "JVHd3LKpMuYvWykJ7l4f5QG0t+7PWJYQA9SrX/CXiLkOWHU2ZN8tiGj+6b0rRmuTdEBp/47fM1TVHvOZ", + "d7aDTm3n2l+L+bdiDeqTv2qTEDmZMKWJ5lPBJzymUDhhQjU+ZXFBp4vfioTV/2T/TRW+Zn/juTMe0XjG", + "2Ry6YzOzPAsQWjiYrkZ39o6+FMKLfl/t9VgeFyJCBuQHPp0xhf+l7YM5KWJGdEbTtG5aGReGGHrHSCrF", + "lKnBregjJLQ5Iv9poY1TkBcRcWUrLGBZQvb+89vDw/53h4fk4vsDvW8HurIczYHfRmRMUypiq9LZkQcA", + "AbL3ny++q41FwDWH/nPk4emHfHfY/5fGoJVtvojgr+WIl4f9V+WIFojUsGUI0/Tq4Kg6xfl/VSXH3FX1", + "otpvuGX4hw51INmWbzrqfRTjvFmy0f0fwjyXTJNbMFAwL/naJI5xNpmH1ZWgM0VXrgG8wl08MFCpmkrB", + "H0FKb6d5lncQQDnQJXnVje0LRKy/MFM/QdlPbgV6WyBWyrWB94Juxay3XENdeL2jQPoycak6dQCZqodm", + "itV5vkBsglxzgDwmue6CPZmctz80L+QcXoHPGPH8FI9MiDCujDtfICThBFIRxcAv+DiGoBhNSgNCkB9c", + "MZo480E3dgDb8aqpnf+PwhFkbJjpV73SHqXTgIAJZhl+YegEOY0NF+gW6KMZipNhrdNFK4dYbTjyfClw", + "LZ1Ndq5RU2vk4RLWvkBQXzOzyizqTUoOoAmKnoEZqCsOoGe6PTgO6gnpmgPb1VeQqor7QcHk8jwUy6Tj", + "I5iMOWip3eLVlCeL6ik1o5bQiYRpM9zQ/sV+w4Vz2jku6OoXOtW7S+OXqLdrlIWzPlZb3bqoCd7Ck9Uz", + "ASiVpUy+dHYZKHEycWi4HcF4U+/aYk4UzEwYPSiSsm4TN7qy9a5kRy1jYBv5oLX3yYhnW+JI6j10ahWp", + "qugW2Y1SnigmaR3F7Ij6f+V5hfg1AP6vIQNaLyy2hKI7UIQzNm0giW1NxW2Ucys2k85mk3HDQnwrlkzE", + "7YXHnM33ycivNULuZsaWTVGlGOoQE/bZyDocwdVWevld9yAu17rQ7Q3KikGxbotO/T5806/G7Q+2q4he", + "WfuegaEcuzv8X85UltF1Z8Zyv1wabOlFUmsP91xvkUAHuu7Q37FYMhx7GOqC9EHwXwu22jatbsW7d9fR", + "KVpxuT+DiWfkqSt2fiZ0xMPUzfquZJqYbqXvwX0e/O6B8tE1NmBY7WcZI2VeIeSSwQWMKM5q4mwoJaTX", + "2VE2m01ehVptICgxGP4LB+U19BvzeQe7WT+XwXiAeZqthrNrMDS90WdzZ1T5ZNBcNoIZ9mBwt0Hr1yYf", + "yzU8wl2vrkBidNUzS05qr3aXxwrto2kCp/699+/96+uzvivl1b8Jtq+5YAmnrkPDBJpSQbselxa7t8wI", + "9xv+Uu8bXWGXAVfoxy8RkbE52fItu9pAnnV3xmnFNwWQQYWsLgbg05oSSFeMwZ8wHuF91ebEtxBu7R7c", + "6Mj0p1ev2rYJLXdbtrW25zCSZxe94pHm6R0tM2V9ti9dWIOJzcpnHy+7TRheKqf6oLr6sGNUTjWSXwsv", + "X0IZ19VsHW57ZuWIoKqJHeJWUXiZiUxTeR+OGcH1VluBLiMCpBmVyaN84juWcu3rVK0h3XbJtM06tbOH", + "V6s+GObYHqv32aTiWzntKA4tYv2hJWBIuthNYybv9fVZVxLKU7q4V5ieiYVmO5RkLtsSXpajSWwZNvio", + "J4rpWa0pOQDvwRA6pVxotCr4bBlVCCgML6QgqYxpOpPaHP355cuXmEUNs86ohsaYGtj9Nzmdsm8i8o2b", + "9xtMPPvGTflN2cPK1yNxzWhdFA3MWG0OCnCbQomqP6VHwJARyF1Bde4TlDDP8QZdWesz5d4E9mEvNJxU", + "VV7uH7GEcnUEqJ9xDTtHjAggZ8dCE46tAfm02yxcb0C7k2crllWu8JkQpbGDNhSpSqQr980forZ2LLPM", + "shG9EPFMSSELnXZ+ZnoU0Dm9Fxtx4Bq+elYkgCU+Lxa4LbShAfz8mSsFrUKfPgr8v7t/gJnhjjcLcgVR", + "4UcOlZ02mxiqmddqpuWToyh48phXzU4gt6f5Q5Yvfv/jFxn2YdkRn9onsZGk0p53x0mso7ERK6/ws/81", + "eInn+YqZTxd7BuVYKLm8+Y/+GPvEPAV6akNN0W6Z9YIFv/rU2PnM0hIPFRKU7pcvMhDeAYBoD7PHIEfC", + "O+hW8NX/Gs4Fx/nMehxuoU2P+34BnYvQGvnFGiAr+Uq0w6BHYaoszCa7ZHW9sjBrDZSfiac9wtBWns0O", + "62hy8/cvC5MXBkw6KZ+weBGn7KtP6vl8UjW8l4XZ2n6oWAx1gqcHlW88zKEx0f7Kf/+sdQ3KVTZXnV7O", + "bHYDP19Fg89UcKasg5ArNufw/iUIXJaQOU+Y3Mo1U8MLl2nZygl9KmYdNda6LM+rMJgyJ9WDzZdkMrLM", + "qY4I1SSnEGRoJKltDSJeXEFCmVkR5kpDO1dMYF6uy3lZa4oMcNyw05H2fzvu//Ww/+f+L//0DzvxZYDF", + "QZa/enQyTIXsDrIN7lr+2n/DBdczlvSPQ83+eca0oVluYQE175oAmbjBA/KXgioqDEMwjBm5enPy7bff", + "/nmw3hvV2Mo1xijttBMX37TrRuxWXh6+XMczoNwkT1PCoXzsVDGtI5JDIx9i1AKtzFj1tXndV0BNxxP7", + "w2p57WI6xYxr6CcEHXy5INjNQde656oFUk91iDIC8kUgAvLjF5y2jeW9NZAog8DeJ2FWKUfR1Zpji8C2", + "UHuk6l3mqqyTZn41zJdeSQBZoWjfmliVu3yyJFSaprVpt77YjKq7ds8inlMTCs2PE+IqJwvEdRf5SwV2", + "Vq7RNBSMnnAB1SoRJ6i6Y8p3Hfg7gwBb7kPGnXJ5cfnKyoR4RnPDlB+zmnBxQdXdcyssjTWeMdR0iz20", + "vfUu4J5KQvs/RjU6TpISMxFXoHyLIFz0PZuvcHJ72ljpEB8Id35uNGwuslZtfrFOBDoh+wVWXIQbKFuz", + "1HnMeyzyXtclcqbI+Sk0gIZ+JFOuDfSohjYTlmsNdsEDma9DA5k/PxbU1tj97eTCjz9vGxAj86YC2BUg", + "OqYpM/I3puRBwjUdp+t7QaIxwS710wWWGrYzQIkrSewskUUQqpIU7BsT8sPNzSUxik4mPCb2TWEG5ISm", + "qa+KdXx5jp0vuLZT3luN8p7eMcINGbOYFpqRD4LfKTox+CstjMyo7+0D32J7s4Uv1+PzDX+6CBa1wmNe", + "25PfyL8yJXtdgs3h+76RfXtK4u4qeRLwnScsy6VB1c7NDPfK/K3WrmiwC2iZWA/ZK6aNVEy7cti4eHnY", + "skdRtYvI6kjyHh4CcN/N7aLuD+8SnqQMQY5jy8fKTxdESFdWCzpiaPdCmbE0IdQCNhiVJB4PPbyOZwAe", + "Tvx42JWfbCxLV28oWY5qltAdEP/xq8NXhE9q32G/jqo8erDx3V+YuSn384xG+HKRa0NN0IN4Ez7grkrW", + "anfOlvk7QC2qalYvMU2qXIstrMqAIGsFFchftwJnmrAHe53cIpdmpgrbQ0Y3lskC1H9M+Ulee9NOfQrF", + "DMVxXJW4opkxXEz1VshBrnEUYXNW37rFeX8rkFOJ9HVEJjSFDvCMKu2LINZOG+qyaG+xiW5PL/q/x6C3", + "cpl6qe1P53TaGd+/4PoertT34witCHX9Y2YDZXk8f3n4oonn9xQRvWYMrnD+tQuZteMO7Thu7ABLCimL", + "fVitzE2fiyNCKxVkRo2jAzt7nR736FIBfUwHF9LM0PqKCowqWESk8rTmyctrHvutZPUaxY39v1I2ObG7", + "HeO/LMzno8Q/POU9pVFi9w1p9nmjSq8fJzYbyk4tXTGspp6DkUsTKtCtWRm7qi2glzUiU+oaF0NiP9rS", + "ljdaZwqHSIXwtdZ8KlhCmJizVOasUlrdsprQxPtQXh6+Cvw+4Sk+kveE9Mt7v4pLZ4Zvv9EVaXNdUTeQ", + "/qvDQ6s9zmnKEwS3698RptZxynUlO9EX/UwhG7gWLPGZQjaqczogBQOwARw57tYy8xKiMVW+C1IFb+yI", + "GrMB0nfgHYET0jhmOaBXYSpIr8e11yhj/FYe0Xum2VgZJ+xAEtuT40pUx3ISI4O62Kk9bjPAoVobSXpA", + "zmg8IxNFM0xxgUJTUmVkxJMj8rtmv368vRUJNfSI/O6B1LcYYf9+eytGVuIidFw3pLLNbcy07mdSSCMF", + "jyGaImdKgyE/VlLrJZbp0uNfE0reUm36ANP++SnaM6Bfo9ME7EBRSXmgQzA2KKaLzJsw8NgDcqpkjpvC", + "SFZEiSnNtVfbRzwZYZc06InoLDaMz1mCv3GN9ZrMjArygtAZo4n3+6Z2r5oxAZ9GPrDjninLSjgY/+EE", + "kNZRTCZMDchJyuEr1+HdKBrfBWYDFzIzLDaw3wF5A3lN1fG111GWrgxMoNWy1evCgcoCA1LqNGPQHgR3", + "/Rp81GT0/yiWp3TxrzRNR1j9pDGdTBMoVQ0PGMuPHYZrw6hrPXnP7X3PaA4petDSmQmmeExGTU44ws71", + "XvNyt8fcc8nR7o/QfA27Z5M9+/kCmkBabMNmx5QkMi4yJuyokVnkbIRtTEt2PsKubRbnpMrK4ldVS0Gn", + "8/wjbOsUPkamFhENSiXuBycPdkkGhGseb2Mt3CuLsr4fGiiIuklPrl+pVEQzkZDDADw8eH1r4a40GREt", + "m4Q1p2mB2WoZs2SmFIuhYhEuRQ26xQbkht4x6GcfswQWgqCdEeLNCAUvtMTGhaFZKixnGRItjOwr5tC4", + "Wi5lVECrTkAkdCL2cUoLoRnXUHK6qoeO3usq6KFBBNslmF4C4m+D8ANyBZX7gaRJbPkJNeTF4ctXr2FA", + "icy0xgkgv6dQExozLPU94UobJPYp5B8rx2UGrWXf8UbCcWJpulvl9kdE2nWS+G87CKMvLtt1+QQWotfQ", + "0b1/bemx5ACbBfzHj/9/AAAA///4CDpyLeABAA==", } // GetSwagger returns the content of the embedded swagger specification file diff --git a/server/openapi.yaml b/server/openapi.yaml index aa693a1b..5ac232d6 100644 --- a/server/openapi.yaml +++ b/server/openapi.yaml @@ -7,6 +7,7 @@ paths: post: summary: Start a screen recording. Only one recording per ID can be registered at a time. operationId: startRecording + x-telemetry-category: platform requestBody: required: false content: @@ -27,6 +28,7 @@ paths: post: summary: Execute a command synchronously operationId: processExec + x-telemetry-category: platform requestBody: required: true content: @@ -48,6 +50,7 @@ paths: post: summary: Execute a command asynchronously operationId: processSpawn + x-telemetry-category: platform requestBody: required: true content: @@ -69,6 +72,7 @@ paths: get: summary: Get process status operationId: processStatus + x-telemetry-category: platform parameters: - name: process_id in: path @@ -93,6 +97,7 @@ paths: get: summary: Stream process stdout over SSE operationId: processStdoutStream + x-telemetry-category: platform parameters: - name: process_id in: path @@ -123,6 +128,7 @@ paths: post: summary: Write to process stdin operationId: processStdin + x-telemetry-category: platform parameters: - name: process_id in: path @@ -153,6 +159,7 @@ paths: post: summary: Send signal to process operationId: processKill + x-telemetry-category: platform parameters: - name: process_id in: path @@ -183,6 +190,7 @@ paths: post: summary: Resize a PTY-backed process operationId: processResize + x-telemetry-category: platform parameters: - name: process_id in: path @@ -213,6 +221,7 @@ paths: post: summary: Stop the recording operationId: stopRecording + x-telemetry-category: platform requestBody: required: false content: @@ -237,6 +246,7 @@ paths: type: string pattern: "^[a-zA-Z0-9-]+$" operationId: downloadRecording + x-telemetry-category: platform responses: "200": description: Recording file @@ -276,6 +286,7 @@ paths: get: summary: List all recorders operationId: listRecorders + x-telemetry-category: platform responses: "200": description: List of recorders @@ -291,6 +302,7 @@ paths: post: summary: Delete a previously recorded video file operationId: deleteRecording + x-telemetry-category: platform requestBody: required: false content: @@ -315,6 +327,7 @@ paths: Records a named point in time during an active recording. At finalize the markers are injected into the output MP4 as chapter markers. operationId: markRecording + x-telemetry-category: platform requestBody: required: true content: @@ -342,6 +355,7 @@ paths: post: summary: Simulate a mouse click action on the host computer operationId: clickMouse + x-telemetry-category: control requestBody: required: true content: @@ -359,6 +373,7 @@ paths: post: summary: Move the mouse cursor to the specified coordinates on the host computer operationId: moveMouse + x-telemetry-category: control requestBody: required: true content: @@ -376,6 +391,7 @@ paths: post: summary: Capture a screenshot of the host computer operationId: takeScreenshot + x-telemetry-category: control requestBody: required: false content: @@ -398,6 +414,7 @@ paths: post: summary: Hide or show the cursor operationId: setCursor + x-telemetry-category: control requestBody: required: true content: @@ -419,6 +436,7 @@ paths: post: summary: Get the current mouse cursor position on the host computer operationId: getMousePosition + x-telemetry-category: control responses: "200": description: Current mouse position @@ -432,6 +450,7 @@ paths: post: summary: Type text on the host computer operationId: typeText + x-telemetry-category: control requestBody: required: true content: @@ -454,6 +473,7 @@ paths: the X11 keysym definitions at https://cgit.freedesktop.org/xorg/proto/x11proto/plain/keysymdef.h The server honors millisecond-level durations using fractional sleeps under the hood. operationId: pressKey + x-telemetry-category: control requestBody: required: true content: @@ -476,6 +496,7 @@ paths: When both horizontal and vertical deltas are provided, the server applies them sequentially (vertical then horizontal) and batches wheel events using `xdotool click --repeat N --delay 0