From 0296e93fee01e275a6a6c6dc94abd99f02313b1d Mon Sep 17 00:00:00 2001 From: archandatta <35818003+archandatta@users.noreply.github.com> Date: Tue, 4 Aug 2026 13:05:14 +0000 Subject: [PATCH] Report browser-control CDP commands in the control telemetry category MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit api_call covers browser control issued through the kernel-images API, but a client driving the browser over the CDP proxy — Playwright, Puppeteer, an SDK — produced nothing at all, so a session whose agent works over CDP showed connect, disconnect and nothing in between. The proxy now emits cdp_command under control for the methods that drive the browser: input gestures, navigation, dialog handling, file selection and screenshots. Configuration and the DOM/Runtime traffic a client library issues on the caller's behalf stay out, and the phases that duplicate a gesture (mouseMoved, keyUp, char) are dropped so one action reads as one event. Payloads are shape only: method, session, event type, coordinates, button and the length of submitted text. Never the text, the key or the URL — control is captured by default, and on a login page those are the credentials. Frames are rejected by a single scan for the method name before anything is unmarshalled, so a large Runtime.callFunctionOn costs a scan rather than a parse. The parsed top-level method decides classification, so a nested "method" key cannot spoof one. Co-Authored-By: Claude Opus 5 --- server/lib/devtoolsproxy/cdpcommand.go | 155 ++++ server/lib/devtoolsproxy/cdpcommand_test.go | 247 ++++++ server/lib/devtoolsproxy/proxy.go | 5 + server/lib/events/category_gen.go | 1 + server/lib/oapi/oapi.go | 911 +++++++++++--------- server/openapi.yaml | 68 +- 6 files changed, 988 insertions(+), 399 deletions(-) create mode 100644 server/lib/devtoolsproxy/cdpcommand.go create mode 100644 server/lib/devtoolsproxy/cdpcommand_test.go diff --git a/server/lib/devtoolsproxy/cdpcommand.go b/server/lib/devtoolsproxy/cdpcommand.go new file mode 100644 index 00000000..360bdb7a --- /dev/null +++ b/server/lib/devtoolsproxy/cdpcommand.go @@ -0,0 +1,155 @@ +package devtoolsproxy + +import ( + "bytes" + "encoding/json" + "time" + "unicode/utf8" + + "github.com/kernel/kernel-images/server/lib/events" + oapi "github.com/kernel/kernel-images/server/lib/oapi" +) + +// controlMethods are the CDP methods that drive the browser the way an agent +// does: input gestures, navigation, dialog handling, file selection and +// screenshots. Everything else a client sends over the proxy is either +// configuration (Emulation, Network.enable) or DOM/Runtime bookkeeping a +// library issues on the caller's behalf, so it stays out of the stream. +var controlMethods = map[string]struct{}{ + "Input.dispatchMouseEvent": {}, + "Input.dispatchKeyEvent": {}, + "Input.dispatchTouchEvent": {}, + "Input.dispatchDragEvent": {}, + "Input.insertText": {}, + "Input.synthesizeScrollGesture": {}, + "Input.synthesizeTapGesture": {}, + "Page.navigate": {}, + "Page.navigateToHistoryEntry": {}, + "Page.reload": {}, + "Page.captureScreenshot": {}, + "Page.handleJavaScriptDialog": {}, + "DOM.setFileInputFiles": {}, +} + +// skipEventTypes drops the phases that duplicate a gesture already reported. +// A click sends mousePressed and mouseReleased around a mouseMoved, and a +// keystroke sends rawKeyDown/keyDown then char then keyUp; reporting every +// phase multiplies the stream without saying anything the kept phase doesn't. +// mouseMoved also arrives in bulk from humanized cursor paths. +var skipEventTypes = map[string]struct{}{ + "mouseMoved": {}, + "keyUp": {}, + "char": {}, +} + +var methodKey = []byte(`"method"`) + +type cdpCommand struct { + Method string `json:"method"` + SessionId string `json:"sessionId"` + Params struct { + Type string `json:"type"` + X *float32 `json:"x"` + Y *float32 `json:"y"` + Button string `json:"button"` + Text string `json:"text"` + Key string `json:"key"` + } `json:"params"` +} + +// cdpCommandEvent builds the cdp_command event for a client-to-upstream frame, +// or reports false when the frame is not a browser-control command. Params are +// reported as shape only — coordinates, button, event type and the length of +// typed text — never the text or the key itself, which on a login page is the +// password. +func cdpCommandEvent(msg []byte) (events.Event, bool) { + if !mayBeControlCommand(msg) { + return events.Event{}, false + } + + var cmd cdpCommand + if err := json.Unmarshal(msg, &cmd); err != nil { + return events.Event{}, false + } + // The parsed top-level method decides, not the scanned one: a client is free + // to nest a "method" key inside params ahead of its own. + if _, ok := controlMethods[cmd.Method]; !ok { + return events.Event{}, false + } + if _, skip := skipEventTypes[cmd.Params.Type]; skip { + return events.Event{}, false + } + + data := oapi.BrowserCdpCommandEventData{ + Method: cmd.Method, + X: cmd.Params.X, + Y: cmd.Params.Y, + } + if cmd.SessionId != "" { + data.SessionId = &cmd.SessionId + } + if cmd.Params.Type != "" { + data.EventType = &cmd.Params.Type + } + if cmd.Params.Button != "" { + data.Button = &cmd.Params.Button + } + if text := cmd.Params.Text; text != "" { + length := utf8.RuneCountInString(text) + data.TextLength = &length + } + // A key of more than one rune is a named key — Enter, Tab, ArrowDown — which + // is worth reading back and cannot be a character someone typed. A + // single-rune key is typed input, and stays out for the same reason the text + // does. + if key := cmd.Params.Key; utf8.RuneCountInString(key) > 1 { + data.Key = &key + } + + payload, err := json.Marshal(data) + if err != nil { + return events.Event{}, false + } + return events.Event{ + Ts: time.Now().UnixMicro(), + Type: "cdp_command", + Category: events.Control, + Source: oapi.BrowserEventSource{Kind: oapi.KernelApi}, + Data: payload, + }, true +} + +// mayBeControlCommand rejects frames that cannot be a browser-control command +// without unmarshalling them, so the hot path — a large Runtime.callFunctionOn +// payload — costs one scan instead of a full parse. It reads the first "method" +// in the frame, which for every real client is the top-level one; a frame that +// nests its own ahead of it is decided by the parse in cdpCommandEvent. +func mayBeControlCommand(msg []byte) bool { + i := bytes.Index(msg, methodKey) + if i < 0 { + return false + } + rest := msg[i+len(methodKey):] + open := bytes.IndexByte(rest, '"') + if open < 0 || !bytes.Contains(rest[:open], []byte(":")) { + return false + } + rest = rest[open+1:] + end := bytes.IndexByte(rest, '"') + if end < 0 { + return false + } + _, ok := controlMethods[string(rest[:end])] + return ok +} + +func publishCdpCommand(publish EventPublisher, msg []byte) { + if publish == nil { + return + } + ev, ok := cdpCommandEvent(msg) + if !ok { + return + } + publish(ev) +} diff --git a/server/lib/devtoolsproxy/cdpcommand_test.go b/server/lib/devtoolsproxy/cdpcommand_test.go new file mode 100644 index 00000000..89238b1d --- /dev/null +++ b/server/lib/devtoolsproxy/cdpcommand_test.go @@ -0,0 +1,247 @@ +package devtoolsproxy + +import ( + "context" + "encoding/json" + "net/http" + "net/http/httptest" + "net/url" + "strings" + "testing" + "time" + + "github.com/coder/websocket" + "github.com/kernel/kernel-images/server/lib/events" + oapi "github.com/kernel/kernel-images/server/lib/oapi" + "github.com/kernel/kernel-images/server/lib/scaletozero" +) + +func TestCdpCommandEvent(t *testing.T) { + tests := []struct { + name string + frame string + want *oapi.BrowserCdpCommandEventData + }{ + { + name: "click reports coordinates and button", + frame: `{"id":7,"sessionId":"S1","method":"Input.dispatchMouseEvent","params":{"type":"mousePressed","x":120.5,"y":48,"button":"left","clickCount":1}}`, + want: &oapi.BrowserCdpCommandEventData{ + Method: "Input.dispatchMouseEvent", + SessionId: strPtr("S1"), + EventType: strPtr("mousePressed"), + X: float32Ptr(120.5), + Y: float32Ptr(48), + Button: strPtr("left"), + }, + }, + { + name: "insertText reports length, never the text", + frame: `{"id":8,"method":"Input.insertText","params":{"text":"hunter2"}}`, + want: &oapi.BrowserCdpCommandEventData{ + Method: "Input.insertText", + TextLength: intPtr(7), + }, + }, + { + name: "a typed character is counted, not captured", + frame: `{"id":9,"method":"Input.dispatchKeyEvent","params":{"type":"keyDown","key":"a","text":"a"}}`, + want: &oapi.BrowserCdpCommandEventData{ + Method: "Input.dispatchKeyEvent", + EventType: strPtr("keyDown"), + TextLength: intPtr(1), + }, + }, + { + name: "a named key is captured", + frame: `{"id":10,"method":"Input.dispatchKeyEvent","params":{"type":"keyDown","key":"Enter"}}`, + want: &oapi.BrowserCdpCommandEventData{ + Method: "Input.dispatchKeyEvent", + EventType: strPtr("keyDown"), + Key: strPtr("Enter"), + }, + }, + { + name: "navigation reports the method without the url", + frame: `{"id":10,"method":"Page.navigate","params":{"url":"https://example.com/reset?token=abc"}}`, + want: &oapi.BrowserCdpCommandEventData{Method: "Page.navigate"}, + }, + { + name: "mouseMoved is dropped as a duplicate phase", + frame: `{"id":11,"method":"Input.dispatchMouseEvent","params":{"type":"mouseMoved","x":1,"y":2}}`, + }, + { + name: "keyUp is dropped as a duplicate phase", + frame: `{"id":12,"method":"Input.dispatchKeyEvent","params":{"type":"keyUp","key":"a"}}`, + }, + { + name: "char is dropped as a duplicate phase", + frame: `{"id":13,"method":"Input.dispatchKeyEvent","params":{"type":"char","text":"a"}}`, + }, + { + name: "library bookkeeping is not browser control", + frame: `{"id":14,"method":"Runtime.callFunctionOn","params":{"functionDeclaration":"() => 1","objectId":"x"}}`, + }, + { + name: "configuration is not browser control", + frame: `{"id":15,"method":"Emulation.setDeviceMetricsOverride","params":{"width":1920,"height":1080}}`, + }, + { + name: "command results carry no method", + frame: `{"id":7,"result":{"nodeId":42}}`, + }, + { + name: "upstream events are not commands", + frame: `{"method":"Network.responseReceived","params":{"requestId":"1"}}`, + }, + { + name: "a nested method does not stand in for the real one", + frame: `{"id":16,"params":{"method":"Input.dispatchMouseEvent"},"method":"Runtime.evaluate"}`, + }, + { + name: "malformed frames are dropped", + frame: `{"id":17,"method":"Input.insertText","params":`, + }, + } + + for _, tc := range tests { + t.Run(tc.name, func(t *testing.T) { + ev, ok := cdpCommandEvent([]byte(tc.frame)) + if tc.want == nil { + if ok { + t.Fatalf("frame produced an event, want none: %s", ev.Data) + } + return + } + if !ok { + t.Fatal("frame produced no event") + } + if ev.Type != "cdp_command" { + t.Fatalf("type = %q, want cdp_command", ev.Type) + } + if ev.Category != events.Control { + t.Fatalf("category = %q, want control", ev.Category) + } + var got oapi.BrowserCdpCommandEventData + if err := json.Unmarshal(ev.Data, &got); err != nil { + t.Fatalf("unmarshal data: %v", err) + } + if diff := cdpCommandDataDiff(*tc.want, got); diff != "" { + t.Fatalf("data mismatch: %s", diff) + } + }) + } +} + +// The typed round trip above cannot catch a field the payload carries but the +// struct drops, and typed text is the one field that must never appear. +func TestCdpCommandEventOmitsSubmittedText(t *testing.T) { + for _, frame := range []string{ + `{"id":1,"method":"Input.insertText","params":{"text":"hunter2"}}`, + `{"id":2,"method":"Input.dispatchKeyEvent","params":{"type":"keyDown","key":"Q","text":"Q","unmodifiedText":"q"}}`, + `{"id":3,"method":"Page.navigate","params":{"url":"https://example.com/reset?token=abc"}}`, + `{"id":4,"method":"DOM.setFileInputFiles","params":{"files":["/tmp/passport.pdf"],"objectId":"x"}}`, + } { + ev, ok := cdpCommandEvent([]byte(frame)) + if !ok { + t.Fatalf("frame produced no event: %s", frame) + } + payload := string(ev.Data) + for _, secret := range []string{"hunter2", "Q", "token=abc", "passport"} { + if strings.Contains(payload, secret) { + t.Fatalf("payload %s leaked %q", payload, secret) + } + } + } +} + +func TestWebSocketProxyHandler_EmitsCdpCommandForClientControlTraffic(t *testing.T) { + echoSrv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + c, err := websocket.Accept(w, r, &websocket.AcceptOptions{OriginPatterns: []string{"*"}}) + if err != nil { + t.Errorf("accept failed: %v", err) + return + } + defer c.Close(websocket.StatusNormalClosure, "") + for { + mt, msg, err := c.Read(r.Context()) + if err != nil { + return + } + // Echo back a frame that names a control method, so the test fails + // if the proxy reports the upstream direction too. + if err := c.Write(r.Context(), mt, msg); err != nil { + return + } + } + })) + defer echoSrv.Close() + + u, _ := url.Parse(echoSrv.URL) + u.Scheme = "ws" + u.Path = "/devtools/browser/x" + + logger := silentLogger() + mgr := NewUpstreamManager("/dev/null", logger) + mgr.setCurrent(u.String()) + + rp := &recordingPublisher{} + proxySrv := httptest.NewServer(WebSocketProxyHandler(mgr, logger, false, scaletozero.NewNoopController(), rp.publish, nil)) + defer proxySrv.Close() + + pu, _ := url.Parse(proxySrv.URL) + pu.Scheme = "ws" + + ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second) + defer cancel() + conn, _, err := websocket.Dial(ctx, pu.String(), nil) + if err != nil { + t.Fatalf("dial proxy failed: %v", err) + } + + frames := []string{ + `{"id":1,"method":"Runtime.callFunctionOn","params":{"functionDeclaration":"() => 1"}}`, + `{"id":2,"method":"Input.dispatchMouseEvent","params":{"type":"mousePressed","x":10,"y":20,"button":"left"}}`, + `{"id":3,"method":"Input.dispatchMouseEvent","params":{"type":"mouseReleased","x":10,"y":20,"button":"left"}}`, + } + for i, frame := range frames { + if err := conn.Write(ctx, websocket.MessageText, []byte(frame)); err != nil { + t.Fatalf("write %d: %v", i, err) + } + if _, _, err := conn.Read(ctx); err != nil { + t.Fatalf("read %d: %v", i, err) + } + } + + if !waitForCondition(2*time.Second, func() bool { return len(commandEvents(rp.snapshot())) >= 2 }) { + t.Fatalf("expected 2 cdp_command events, got %d", len(commandEvents(rp.snapshot()))) + } + commands := commandEvents(rp.snapshot()) + if len(commands) != 2 { + t.Fatalf("cdp_command count = %d, want 2 (one per client gesture, none for the echoes)", len(commands)) + } + + _ = conn.Close(websocket.StatusNormalClosure, "bye") +} + +func commandEvents(evs []events.Event) []events.Event { + var out []events.Event + for _, ev := range evs { + if ev.Type == "cdp_command" { + out = append(out, ev) + } + } + return out +} + +func cdpCommandDataDiff(want, got oapi.BrowserCdpCommandEventData) string { + wantJSON, _ := json.Marshal(want) + gotJSON, _ := json.Marshal(got) + if string(wantJSON) == string(gotJSON) { + return "" + } + return "want " + string(wantJSON) + ", got " + string(gotJSON) +} + +func strPtr(s string) *string { return &s } +func intPtr(i int) *int { return &i } +func float32Ptr(f float32) *float32 { return &f } diff --git a/server/lib/devtoolsproxy/proxy.go b/server/lib/devtoolsproxy/proxy.go index df8b47eb..a7509e86 100644 --- a/server/lib/devtoolsproxy/proxy.go +++ b/server/lib/devtoolsproxy/proxy.go @@ -319,6 +319,11 @@ func WebSocketProxyHandler(mgr *UpstreamManager, logger *slog.Logger, logCDPMess logCDPMessage(logger, direction, mt, msg) } msgCount.Add(1) + // Client-to-upstream only: commands are what the caller drives the + // browser with, and upstream frames are events and command results. + if direction == "->" && mt == websocket.MessageText { + publishCdpCommand(publish, msg) + } return msg } diff --git a/server/lib/events/category_gen.go b/server/lib/events/category_gen.go index 3f964ba6..b0317bf2 100644 --- a/server/lib/events/category_gen.go +++ b/server/lib/events/category_gen.go @@ -7,6 +7,7 @@ import oapi "github.com/kernel/kernel-images/server/lib/oapi" var categoryByType = map[string]oapi.TelemetryEventCategory{ "api_call": oapi.TelemetryEventCategory("control"), "captcha_solve_result": oapi.TelemetryEventCategory("captcha"), + "cdp_command": oapi.TelemetryEventCategory("control"), "cdp_connect": oapi.TelemetryEventCategory("connection"), "cdp_disconnect": oapi.TelemetryEventCategory("connection"), "console_error": oapi.TelemetryEventCategory("console"), diff --git a/server/lib/oapi/oapi.go b/server/lib/oapi/oapi.go index 75ef85b6..dbd97ea9 100644 --- a/server/lib/oapi/oapi.go +++ b/server/lib/oapi/oapi.go @@ -140,6 +140,36 @@ func (e BrowserCaptchaSolveResultEventDataStatus) Valid() bool { } } +// Defines values for BrowserCdpCommandEventCategory. +const ( + BrowserCdpCommandEventCategoryControl BrowserCdpCommandEventCategory = "control" +) + +// Valid indicates whether the value is a known member of the BrowserCdpCommandEventCategory enum. +func (e BrowserCdpCommandEventCategory) Valid() bool { + switch e { + case BrowserCdpCommandEventCategoryControl: + return true + default: + return false + } +} + +// Defines values for BrowserCdpCommandEventType. +const ( + CdpCommand BrowserCdpCommandEventType = "cdp_command" +) + +// Valid indicates whether the value is a known member of the BrowserCdpCommandEventType enum. +func (e BrowserCdpCommandEventType) Valid() bool { + switch e { + case CdpCommand: + return true + default: + return false + } +} + // Defines values for BrowserCdpConnectEventCategory. const ( BrowserCdpConnectEventCategoryConnection BrowserCdpConnectEventCategory = "connection" @@ -370,13 +400,13 @@ func (e BrowserInteractionKeyEventType) Valid() bool { // Defines values for BrowserInteractionScrollSettledEventCategory. const ( - Interaction BrowserInteractionScrollSettledEventCategory = "interaction" + BrowserInteractionScrollSettledEventCategoryInteraction BrowserInteractionScrollSettledEventCategory = "interaction" ) // Valid indicates whether the value is a known member of the BrowserInteractionScrollSettledEventCategory enum. func (e BrowserInteractionScrollSettledEventCategory) Valid() bool { switch e { - case Interaction: + case BrowserInteractionScrollSettledEventCategoryInteraction: return true default: return false @@ -1687,7 +1717,7 @@ type BrowserCallStack struct { // Description Optional label for the stack trace (e.g. async cause). Description *string `json:"description,omitempty"` - // Parent Parent stack trace for async stacks. + // Parent CDP Runtime.StackTrace representing the JavaScript call stack at the time of an event. Fields use CDP naming conventions rather than snake_case to match the Chrome DevTools Protocol wire format. Parent *BrowserCallStack `json:"parent,omitempty"` } @@ -1745,6 +1775,57 @@ type BrowserCaptchaSolveResultEventDataCaptchaType string // BrowserCaptchaSolveResultEventDataStatus Terminal outcome. `success`: solver returned a usable solution. `failure`: solver returned an error (see `error_code`). `timeout`: solver did not return within the caller's wait budget. `abandoned`: caller cancelled or the page navigated away mid-solve. type BrowserCaptchaSolveResultEventDataStatus string +// BrowserCdpCommandEvent A browser-control command a client sent over the CDP WebSocket proxy: input gestures, navigation, dialog handling, file selection and screenshots. Configuration commands and the DOM/Runtime traffic a client library issues on the caller's behalf are not reported, and the phases that duplicate a gesture (`mouseMoved`, `keyUp`, `char`) are dropped so one action reads as one event. +type BrowserCdpCommandEvent struct { + Category BrowserCdpCommandEventCategory `json:"category"` + + // Data Per-command payload for `cdp_command` events. + Data *BrowserCdpCommandEventData `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 BrowserCdpCommandEventType `json:"type"` +} + +// BrowserCdpCommandEventCategory defines model for BrowserCdpCommandEvent.Category. +type BrowserCdpCommandEventCategory string + +// BrowserCdpCommandEventType defines model for BrowserCdpCommandEvent.Type. +type BrowserCdpCommandEventType string + +// BrowserCdpCommandEventData Per-command payload for `cdp_command` events. +type BrowserCdpCommandEventData struct { + // Button Mouse button named by the command (e.g. `left`, `right`, `middle`, `none`). + Button *string `json:"button,omitempty"` + + // EventType The command's `type` parameter for input dispatches (e.g. `mousePressed`, `keyDown`, `touchStart`). + EventType *string `json:"event_type,omitempty"` + + // Key Named key for a non-character key press (e.g. `Enter`, `Tab`, `ArrowDown`). Single-character keys are typed input and are never captured; those are counted by `text_length` instead. + Key *string `json:"key,omitempty"` + + // Method CDP method the client invoked (e.g. `Input.dispatchMouseEvent`, `Page.navigate`). + Method string `json:"method"` + + // SessionId CDP session the command was addressed to, when the client used a flattened session. Absent for browser-level commands. + SessionId *string `json:"session_id,omitempty"` + + // TextLength Number of characters the command submitted, for text and key dispatches. The text itself is never captured — on a login page it is the password. + TextLength *int `json:"text_length,omitempty"` + + // X Viewport x coordinate, for commands that carry one. + X *float32 `json:"x,omitempty"` + + // Y Viewport y coordinate, for commands that carry one. + Y *float32 `json:"y,omitempty"` +} + // BrowserCdpConnectEvent An external client (e.g. customer SDK, Playwright, Puppeteer) connected to the CDP WebSocket proxy on this VM. type BrowserCdpConnectEvent struct { Category BrowserCdpConnectEventCategory `json:"category"` @@ -2470,7 +2551,7 @@ type BrowserNetworkRequestEventData struct { // FrameId CDP frame identifier within the target. FrameId *string `json:"frame_id,omitempty"` - // Headers Request headers. + // Headers HTTP headers map forwarded as-is from CDP without normalization. Values are typically strings but may be any JSON type. Headers BrowserHttpHeaders `json:"headers"` // InitiatorType CDP Initiator.type indicating what caused the request, passed through as-is from Chrome. Known values include script, parser, preload, and other. @@ -2543,7 +2624,7 @@ type BrowserNetworkResponseEventData struct { // FrameId CDP frame identifier within the target. FrameId *string `json:"frame_id,omitempty"` - // Headers Response headers. + // Headers HTTP headers map forwarded as-is from CDP without normalization. Values are typically strings but may be any JSON type. Headers BrowserHttpHeaders `json:"headers"` // LoaderId CDP document loader identifier, reset on each navigation. @@ -3123,34 +3204,34 @@ type BrowserTargetType string // BrowserTelemetryCategoriesConfig Per-category telemetry capture settings for browser events. type BrowserTelemetryCategoriesConfig struct { - // Captcha Captcha solve attempt outcomes. + // Captcha Configuration for a single telemetry category. Captcha *BrowserTelemetryCategoryConfig `json:"captcha,omitempty"` - // Connection Client attach/detach lifecycle for the CDP proxy and live view. + // Connection Configuration for a single telemetry category. Connection *BrowserTelemetryCategoryConfig `json:"connection,omitempty"` - // Console Console output (log, warn, error) and uncaught exceptions. + // Console Configuration for a single telemetry category. Console *BrowserTelemetryCategoryConfig `json:"console,omitempty"` - // Control Agent-driven actions against the browser — computer-control calls, Playwright code execution, screenshots and clipboard access. + // Control Configuration for a single telemetry category. Control *BrowserTelemetryCategoryConfig `json:"control,omitempty"` - // Interaction User interaction events (clicks, keydowns, scroll). + // Interaction Configuration for a single telemetry category. Interaction *BrowserTelemetryCategoryConfig `json:"interaction,omitempty"` - // Network HTTP request/response metadata. + // Network Configuration for a single telemetry category. Network *BrowserTelemetryCategoryConfig `json:"network,omitempty"` - // Page Page lifecycle events (navigation, load, layout shifts, LCP). + // Page Configuration for a single telemetry category. 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 Configuration for a single telemetry category. Platform *BrowserTelemetryCategoryConfig `json:"platform,omitempty"` - // Screenshot Periodic base64-encoded viewport screenshots. High volume; off by default and opt-in. + // Screenshot Configuration for a single telemetry category. Screenshot *BrowserTelemetryCategoryConfig `json:"screenshot,omitempty"` - // System Browser VM health, such as out-of-memory kills and managed-service crashes. + // System Configuration for a single telemetry category. System *BrowserTelemetryCategoryConfig `json:"system,omitempty"` } @@ -4836,6 +4917,34 @@ func (t *KnownBrowserTelemetryEvent) MergeBrowserPlatformApiCallEvent(v BrowserP return err } +// AsBrowserCdpCommandEvent returns the union data inside the KnownBrowserTelemetryEvent as a BrowserCdpCommandEvent +func (t KnownBrowserTelemetryEvent) AsBrowserCdpCommandEvent() (BrowserCdpCommandEvent, error) { + var body BrowserCdpCommandEvent + err := json.Unmarshal(t.union, &body) + return body, err +} + +// FromBrowserCdpCommandEvent overwrites any union data inside the KnownBrowserTelemetryEvent as the provided BrowserCdpCommandEvent +func (t *KnownBrowserTelemetryEvent) FromBrowserCdpCommandEvent(v BrowserCdpCommandEvent) error { + v.Type = "cdp_command" + b, err := json.Marshal(v) + t.union = b + return err +} + +// MergeBrowserCdpCommandEvent performs a merge with any union data inside the KnownBrowserTelemetryEvent, using the provided BrowserCdpCommandEvent +func (t *KnownBrowserTelemetryEvent) MergeBrowserCdpCommandEvent(v BrowserCdpCommandEvent) error { + v.Type = "cdp_command" + 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 @@ -5050,6 +5159,8 @@ func (t KnownBrowserTelemetryEvent) ValueByDiscriminator() (interface{}, error) return t.AsBrowserApiCallEvent() case "captcha_solve_result": return t.AsBrowserCaptchaSolveResultEvent() + case "cdp_command": + return t.AsBrowserCdpCommandEvent() case "cdp_connect": return t.AsBrowserCdpConnectEvent() case "cdp_disconnect": @@ -19354,389 +19465,393 @@ func (sh *strictHandler) StreamTelemetryEvents(w http.ResponseWriter, r *http.Re // Base64 encoded, gzipped, json marshaled Swagger object var swaggerSpec = []string{ - "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==", + "H4sIAAAAAAAC/+y9iXIbR5Yo+iv58CbC5EwBpGS5Z5qKGy9oUmpzLEp8JGXPdNMPSFQdANmsyqzOzAIJ", + "O3TjfsT9wvmSF3lOZi1AFRYukj1XERPTMlG5njXP+lsvVlmuJEhreke/9TSYXEkD+B/f8+QS/lGAsW+0", + "Vtr9KVbSgrTunzzPUxFzK5Q8+LtR0v3NxDPIuPvXP2mY9I56//dBNf8B/WoOaLZPnz5FvQRMrEXuJukd", + "uQWZX7H3KeqdKDlJRfy5Vg/LuaXPpAUtefqZlg7LsSvQc9DMfxj13iv7VhUy+Uz7eK8sw/V67jf/OaGC", + "jWcnKssLC/o4dp8HQLmdJIlwf+LphVY5aCscAk14amB5hWM2dlMxNWGxn45xnM8wqxjcQ1xYYMZNLq3g", + "aboY9KJeXpv3t54f4P7ZnP2DTkBDwlJhrFtideYBe4P/EEoyY1VumJLMzoBNhDaWgbsZt6CwkJlN99i8", + "EAevTMgzGvki6tlFDr2jHteaL/BCNfyjEBqS3tHfyjP8Un6nxn8Hwr7vtbozoI9zccLT9M3cA3z5JmOe", + "pszOuGWJFnMweI4xjY3YjMskhYSNF/j3W9AS0r7I+BRMn+eCGcS1oxIOfYdbWqXh1iJ2kfLFnRbTmWWx", + "SsDfoVAyYibWANLMlDWMy4TFqcjHiuuE8TgGYwbMbd3Q9jIu+RRwGz+dMyGNBZ4wyIRlozzldqJ0NuS5", + "GLoTjQY3cgXiMbcwVXrh/g2yyNwN+u3WbtBYLeTU3WDC7UYqaLnlUzfMYb4qdAxbToAjr2jEp6hndSHd", + "dpNVkF3rApiY4EW4HbKJgDRhd9ywchRLCnD4asSvwFKRCWscPvoTjpVKgSOq2Rb8x60wKzIwlmc5E5J9", + "lOKeZSLWykCsZIKzuQvntnfUE9L+6VU1vZAWpoCch/5S3XYAT8t1L2G2NWHCqIJbeadb4vupB+AOrOXC", + "obAjiZwvUsUTNlGajUq0YuDmNavcxKH26lUSQJkpxpmwDi5WsZFnIhVdnKgERhFif07f/NuLP79k8Yxr", + "HlvQhu2NStCOmDDMgGV3M5BhzP6AHY+NA5vbLsxBL5iyM9DM7RG5ew3+NQwv6Mdh1oIHP/M07cepim9Z", + "+M6xQ4d3xBa0Q41MpKmoYYVfQxbZmHCg3MFQtGDzuWPkkDCtCgvfmGq/EZM8g4Rx4kjEZ/Bvhglryi3s", + "wWA6YKMLrRzHcHx5FLHRNb+Fq5K7jPZbT69J+LTuy+GB/52JxEmRiQDNJlplHZwwfJ2JJEnhjmtoXdRY", + "bouW2/7h+vqCBc2J0VfIMActlLVELLWDLN13uV4T1mvoxxHPleXx7eoWT04v2GUhHWcY4CfXmsfANOQa", + "HPIJOcW7+Xc+51c4jqSLcd8ybvFHNxqlqiRaGrC3jn8ZVhhgbgXJMzdRrKT7GSWv5ojLdsYlM5LfwjDm", + "BhlchnqAm/dkplUG7BTm10qlhl1oZVWsUnYnNDDiVe1CIU3faodWmzUBPM0EP46YQ1idKWNJ6jfk/TJv", + "SItMvieKWFnkr6BVf8wNJIw+ZEQ77E7YmSC9IhWyFQ+i3qSQKGjf86yF/9QgET5EEoqYYxNZbheMMBP5", + "BpdKLjJVmPJj04rCbjdbnMZ91nIW+rr9NPTbWdKOe/TfNXJs3V2h09XhHy/fuSO7swce5mebiLSNUJco", + "rHHNtX3Sco0riZrwbiO1pk63JIJWkDAn0cVSPoYUAYXbR6KySIHEA7lZyJjFvDDQzu9yrr0SuIVCUvGB", + "5buoUcxaPpLbeMavVDqHSzBFateooPgpM+5bxq11mMk0cJQMnDk6E+4GVGFjlcFgO82OZn2sZtdxjq9K", + "XqeS5y9+iOAcaryzZ1T41gFod90vYF9D/Ws70RpV0H8d7mWJkXlkn4NMlGYTnol0MXDiKilip+tJd+Op", + "g2mu1VwkoPsmh1hMRMwsN7dBB5JWMTsjZfCIgXv851oYYHOuBZfWOEanIRBXrNKU5wbCQBCazUEbJxLG", + "RXwLlu3NX7IDNv92P8LXGJcLx7SnTCr3dJujKCRW4y73VDk5cm79gSKWp1xI9uHkct+pqBpypS0pcCPU", + "Rf2bLKDJLBCow4NwZ/OXzf/81iFFoaWxInWYMQWwYKxTc9yU7cS9q1KLSh0xH2O5to6o2njOimqLD/1h", + "l+qfzuugw2/pBeyW5CItdODcozeXlx8uhyfHF9cnPxwPP76/+vDup+Pv370ZVYq9kswU9CreRa28Xj4H", + "G/lpRkd0Zs00uCtGVlsYPk7B/YBP9AEb+Z22fS39ofYMABtVl+F2PXKsRRW2GpeIBDGJxtc1AidQQH9j", + "2B0Xlo2LZAp2wEZ8zGWiJCSjI/8Ji7mMIU0hYV4K5nwKTPK5mCJH5Hd84RTwPq7ZxDd/bMfT6EjuGmmT", + "vahXLtaKUo7uWp8JHsrcGDF1d1LTTdiHnP+jgMgptpOCBLcpckcVzPFY09cwAQ0yhnaQ3sHYCAvDmTIt", + "YvMHRTppeQt3M9Dg75NI3kkLvIhk7fw5t7OWBxC3s+3nZ/9v4d6cXpmE+zgtktZlV3SJGq98wGMlyU9U", + "lnGZdCoX3pRV2qVi+p5x93Z2hEXUNQdCKKdn/gzjK4UcMdfqfnHEhMwLy6ZgbKGd6u8RDl+pieCpmtJz", + "VMhphAolM5ACqdturZqda8BOlJyIaeA9fjtk/3IbOP1wfuAfWU67mzjeUe41FWPN9YIJYwoorY4l/Yxh", + "xtMJ4xo8pRELjsrJ8xk34O1pSUGWX2A8HI3tjZz6D+dqDol7Rt/C4mPu/hHPuB7t48yJVmimMIopCd7O", + "57Q1dwiDf6OH3ee1wC2hwlf9rFs/S/KhR7vnVMta4PEAU5yn1qY6Vh2gWwsbF9a2PafOHYIz+tWbmLxx", + "O6zlZXIKE+tQH0107h9k2HH/kkpCh00Jt9Oh+l1Xi3xj2Mh9NGI5d08pCxrPRpwmESZHu5gJm0GyvNBg", + "TEmYp+pOun9aVcSzK6e3dGzpFhare3mPJ7+FBb38mVSyXxoc8e+5W61UUJx6SYa1sfufY63VHe5gf8Cu", + "hJym0BxukFe4vST+UMh0HWeCOUry3HGc5DWzM2UAf4lVIS3BY2Th3g5TkFM7GwVjP3GUlfNlYGeqw2RA", + "vxF4iYUKOVe3pSI7OnN7G4QLR+RAfHWHvOBTGATlouNyDRjTZdtEmwX93kAwxyV4khA0mVUR2XJrmywM", + "amOT1D1HnF7hp2mYeYNkS2EOpVxrVyVqt9mCCmSiUZO6xbm+39J8HZH1Ae4Jmg5LKlQdMIff+KOwBtKJ", + "ewU0gc3+63/9bye0OEvVVEjSK4R1H5KaYcyd0k041xjZ/erefxJwhxrVPYuV0omQ3AJts5SsKO1irvXC", + "CadWRX6xZubFI2ZeYqYeUzdxTSkh7rSWSAb33s/rkYUwOS6MVRlodnX6Y93pFrGLIs/BAuh9FtPc5GTo", + "UHdIqxCG/XQ+2FaAS1J2WmX4VwncIYHx1p5XAp8KE++KTkk5BpLK37EBUdgFF2Tlxa9FlkEiuIUU5UgM", + "iXsWjGrnHgXl1fDMPbs18OxJ0G03lXHpgr5qjWtxtkKNz4q2D9Qdq92uqo/Vb90a5EOdoxWCbuUfzcAY", + "PoUhaj/rpDPpM/ixYRpSvnBKApoSWtYFgT6zRGj6W7vDRQM3bVryz7PF8pwg3YuejYhNDONUGRgdNVUr", + "YQXiMP1RGRiwUZETdQ/jGZdTtOagr04UGdOABjdIyGjjdaXytYpcxir36FR30r04a6vFqkgTpiHAmE+5", + "0xPxEwl3LKxb3wLaqEZH5W/4emdKh3tleZHlZNWisyqJqlNpd/IHDr5e/ztScGWb2rOLXLhH+SK4rc2s", + "sO4I+02TVP0qe1Fv+abqf8I9oW9paUebKbGOx8voVmLAOoJU0qgUMN5rk5nF3Yj72FsGlWaOrRXTma17", + "heE+hpyQilzAb3x4BImbO+WEkBUytoj0xDMMiZdETNBqZomDmhnPne4Z/NJ+/eOLsxNOwPB/GXgDLE9T", + "s+9QKyncnKg8R6i2RozrqSFjCXrXhuhdq+Yut3090w4f98qzlb/Up6Y5UyEh8p7dyB9lWOi0ZR3vCJfK", + "Mh+WN04haGo0Et9JHN8AO9hX3PkfLSyXseCrrOyWlXRXnmifUVS2wsRJyjT9MOkd/W17mJwQX+l9ipaj", + "FxxRtFB8mpa0zvW0yNzMLFagY3pd0FnNgF1QcAhTMl3QQ5cO5qm9i3Ab8RSrD9olDzrRV8sTvBFR0YhA", + "qBm0K36E6IXUvfXGl7hCu5xFNtNuIQi36AaxOU8LiBhP7/jCsBvyMN30HnWLrfEbq3t5VwvX+HIXVTHI", + "jiCOleANeoXbmYa75h6fYGMN/1pg1LsHUJABpsWHU2Rc9jXwBDk9SSgvihqBuCWS3KHSkwiTp3zBhB2w", + "t6r8lUTc3j4JuagWkRwotE6g3JMoTdEiyiKvhMFE3KOwov15BSJiaHa46X0MI5ENHbGxUtlNz4n+2m97", + "QjrBmAkD++x6kYP/+B6NRE7glTFHN71WO98yz3QXusoaf1lhju/UdGulJVVT0kgqrSFV06i8XyEnqvqv", + "O65lxMDGg/3BF5DE4WBf5fBGOZyq6fNL4QY8fl8yeCdRukZUdSrZbo4I7bf4+NOqmM5YIScitRg1guyW", + "IjQHPlIA45gx6he32lCZ/JM82P1fM56mPp55WWIapyoD18zJqAG7AjJVmRziMlRuUqQpczjR4UB4Ft7+", + "FhnvMnhWobPZR04AibZgeQ0sWtmR/8hzuPB0RaKrnGCBJWZKCutecNKJijR1t9oP0tNbTNhZiHYgYWW5", + "noKNKEKW3jeVp5xBruKZo+67mfAxu7QTFceFdu/tlgcNTtXpXMFf6+HZtaAS2ky7/qN4Arpz1kTFBCv6", + "rjZ/xJxCgbE4wONZ7XSt60g+Hxr4R5sPUiqrpLcRCBm7RzhGWlXXRclLcVDJIvrM7QuScgNW5d79UxvZ", + "eglbcM9tXVn1cHhPYbROzVrU7oXCr1rnD7jpJ6otsWcsKkfe0FWd04SDcmb5eH/dikEubEHZ1zjCaShr", + "Y4k1pDDnkkLFZsIQKr8mj5b7YILRxiVMyIc99ShvotKCVH4L9k7p25oxcj1TqAGrfrHNI1couEZ81VWB", + "HY2sWs1BcoekGViO2oGH3MJhMxG6t4doTNUKxkGy+6yQO7RraiE4shZNh5wDw7m9I7dLNo3weuvcqzRR", + "4VV3+MyFTLpUlXCgAZqSgzmzLfXAi7HSieKZ64CNKH1kyHMxOmI/4n+w44uzYC/cc3xGz4Es1vTH/hQk", + "aFS3ws7ZCO4tSIcIoyMm5N/JaeP3U/42YKNUxTwd5pQkMzpiZmEsZMz/gelCSgcxnio5NSKBxnabNssk", + "70W9av/up7BQz/HW2kKtmm5AlW5ka1FSNuFDkGaEDI5bER0ceDo5IFFxdtqAd6CFJdpC4K+hmB+szX8A", + "JxtM9yGsLlYIBnN8ZjSSZTx30L3jOsEo2b7wmOJ271ibKmwZDExChv3E0wLK0IpgYyYtj40LyzK+YGNg", + "XC7Yv199eI8qUkPrWTkMZg1TENdJKuLbjY+lAl9M7tOgSQTv/lzwCgmR21W5HptfR6LayGNfSK1n+vpO", + "6nwn1a5+iJB9xtdSN2ye+M1EIZiqJUfp5OqKhV9Zzu0s2Njx7I6/pqhodagU07bkvfN3zPJpI8FoaTYH", + "sCLPQWPuGjGq7z9eX394H7HjiJ2e/bTfGbvTFp5iBHoHHNfz+fwdC0fManTIt06/NqimX4W+NCZ3Z3G3", + "mIt7SE27JW9tTM3DJ17Cw/ueWymqoE0QWvtMqqHgj7DYyPBuYUFJ6X8AdhfO85XZbcXsbmHxeVhdAy5P", + "zOha4zt/hAU5Eyrt80ePx3S3xIAwrjNi3/P41uQ8dq/2rjjHnblp4Hton59h9EVcmCrW8RYWiDE5BUI+", + "ktvi5Ou57dn7i4/XEbt+8x/Xx5dvunnusjoIj2AwV7FWaXoF1qawMUnBMRCVpszQ557hhHcTn9jqk1wZ", + "Uas/ghEDmH7wu2ZPq7fxlVFtxagI6kOPGJ+HZ3UA64m5l2NPwxYlhFZn9/0S030BAUrRq/yA7quQv7KF", + "WoLrLTrXWzz1et4e8wD+SWttUkdV2+W9xZQ/s3qFyELc5OEEgdVscxLVdm+NpRZPstRy7j1hSAk6f2i/", + "odUbXsua34k5ODV0Q5Q1S8Uc2FzAXRVuthQ67d7xkyINvPsbw36G8eX1SWnDeQ+3an/AfvDfKZkuXqOv", + "MzD0idI4SwrGMKok8rlDYNuu4ytL7mTJDiuGDis+Q/h2J2h2j4QNlvtGGOzKWbojYdd5Bt6VhLLqHxiw", + "q4bxvgzWNBEzinFmNZcGySvYv8epyFnMJRX2sncqGFHL2HIMGB9VWxrtZCzf4sI3B82vcof2oPltWUQV", + "PN8GlfFi5bhfgkV8DZXfnUt8loD5dQB6cl7xOwqcfyhXek1VoyBEzWuqukUpKl1ccUeP3Jb56+fkZT+t", + "cY8OnnPtc3Bqd2RV8PQ4qkiVsQN2jbqi1YvANr1DICRtF9KKNDj3hyU/dq9LjeUfB+xaA7foQRCyn2s1", + "xTxQX98RI5YtsD3Pr4ciSTHyYwrDlC9UYcMbZZ9xwwqpIRUoAmhlOwO5HQPze3ws9+q64a/sq5N9Beyo", + "y7RnZF9rIbSJfzXxqCub5RL/XkYrVAdDp1qMRDQsc1FKh27pHQ2/DOp+0KVRm29oc6aFv4ozKexbLtKN", + "zCDwNkqFcU+LMfgsnFT8Svv93JS2tPmvdLaRzhzAhhO8sucnszbw7EZkxkLejZI+4R5LGXg89PFMFnIy", + "BdNRvU2W4m0GBuxxYdWxtTyebWGTxU1sPu1lEHBbkVOrbG3QloY+YDySMLPSIgv3M14YS/ETafXIIRsS", + "lhMzA/ZesUmhqY7lspC+E2nqBXCZVBsy/r8ACbfd2lc63kjHJeA/GzF3AupZxGYDsX0NrUH116GnAydA", + "iQ4chgcCYHeggepaFHkZ3uJrck2KNF2gmFU6FJFtEmRd8ras+ITC9xIerYovnaqFZfBlHeQNMYJgGUyK", + "8h6mPMd4H9LvT5pqONbZM2DRnLIUbhgsKlbz+NbN5lUVNtFgZsFIIQzLlZD2i/KZrzxmZx7zWdnLY1hL", + "oNVtjQJY+Gzp+c8svwWkslq6d+lfaJLSNve7whvaNrn5fqoC452Gwhy0UImIayXggrUj+HznPihmOwqs", + "5nkiIlw6xFca3EiDa0HwxCTYBp3dKDCXLREU33MDf3rVBxmrBBJ28f4vWyJoeW3jhYWNWrpbe80Z35OE", + "OktS2BgZEaSZSELk9lJcBGffHR5mhv2jEGA93ZFNXSomZH+SYgsSX2Yfg++39Lb5pR9Lb0t+8K8Utkph", + "daPiM9KWx7t3iidCTtc+DVcRMKVR4RXrC1icTRp1QbDCW6qBJwt3Px73MPLJaY4cn7nuDSwVy7VQmo3C", + "2f0UI5yj7ikWdj9io0Kno4iNQl6U+3eZzjSinKuRBp9FTRUGq5IRr9moBRkxEy/nmholsVzlRYpYgklE", + "WOHMwLbVJp6IWDpB9FU+baQej6HP/wpdD6QnjhOigjebYFYnwDBiObURw2ymLY0oaqCjYtbtodfvQ6oW", + "pqrWfvMmLQn26OjN5eXw5MP7929Ors8+vB9evnn78erN6e59aBy7aOlDgx6s8ERUWkyF5GiBWmIjnc4r", + "t2qNS7Qv7E86uPSfXi9yqJkDcIWVtN96JovP+P1RqjtJ4aiGCYnFodmpT7OM2Fuw8Sxi//HDZcSoQlDE", + "ruwiBTMD97Y9y7DewDkkgkfsrXJjruHeXruXbcRq1B1VNeoids6lmOAOLzRMaI0Pdgaa2GSm9BaNPxqt", + "dWpYEVUIuTbeyF9haIG4rZQJ4MPyFR3Jcs/Pfuu7/sp4NzJeD7Tn57grcHliXhsyoDeWYSlTpVFPaNZ/", + "87fRyntmVfbcFrut59t9inp+GUeJnZzrLHwzwLI6QibY5BKTUlGjKUxzmw9mY8YzrJxr7JiYa3ACmHgM", + "1ixovQFhhhqoON86YkADn+f+xu/XFCn1pWRhhnYq6KqLjE8g76fhhoXuEm5y7JVFUuwvb64jdvHh6rqj", + "l5Aydhg4yrLZmDY8VglVl3azHFx8vC7fXZE7HJ9zkfJxCh3SiY7WjoIfSOKlmD49hony9YnCKAQDHgx1", + "7tpl4zXqAp5IEEeskOIfBTQaXFWem69C9/FC16Nx1ORKFQ9ZYQjbyWNqtLeDQPad+TTEIObVy++t23TN", + "Gll+iOjvgOLdADQsQlciYmVIBCbH35eR77Vb+CrgtxDwdF+fQ8IvQ+aJRbzDzlYgeUg00Lhip1hJrSwC", + "f352/oaq8Dy9lN9GenktRAVpsE7lyETWxXXLY4QJy8OTKHRnPZjZLI3Ycrvsrw+6371seaKWq2GaDqNA", + "61y1khQffoxY2Rh9/6EisOyPFEhrray74FM40dzM1pg3cz6Fb5ySKRPQoMuYt5jGsT0u2U3v+C5iV5Ln", + "/9dNL3j+99ndjKovVpaVMNj3fzCWSlSnTryxy9AQLnTD8Cv4HXitKaoF+tfLQYe6QNj0aETYOwilREYD", + "dhLSHn2tx7C1kZt+xAIPdgIZpNM6k20tmm6Cx8rbZUh8lbWdshZDiT1uPKOcbYXIbp61NeWsqgI0dR4f", + "wtxriP95q1ZVvdywUZd/HNlu8t/Mp7pLT7ldbADAqcpOqHTFO8WTLZwwpx/OGwNCtU5339itJylnxLlQ", + "Od+yOudT0Xnrob4S/HqCT1Q29FVM0H/x7LTfDaWn9lsk+bC8txZOQWFjWagIyCgKhko3CMlCBAy3vpza", + "CglM3H1E2BDCijmCeFkeU9zXnnt5ItSwFOP+gH00wEbWUIm0u2YMzuZuRs2TbdRE3mF6yLaVECiZpKMS", + "wgt/Lf7ZjSwNk5Uqf78FPQesaRZmmokJWp4qU+BcmIJje/qxSIVdDNgbHs8aAyi8jixvL/p+VXdo/fmY", + "ytfAge14SDP/6Jn5h8dmhyOby0sXWeGJs4FbeyfvrvY9apc5oxeg8QJkDOxaZIBd9I8vzj6vEFs+3lf5", + "tR3uuQv7zJj3LA4gHwe5epGnSzmbDYQGafViJXhzz3czOEQx02DHLAeNtZr3WzM867c6TMBykZrdU1oD", + "OdUujnFrtRgXFswGysMjrdLejCdDDbFTV7C75XqUblySL3kUQ0KhCVhPkVpkeicCBrJFvouyE1TC84eT", + "d1ftKI/qQksWbH1dEysdjD34Cnaw2sPuu+4mQhj7u6v9dtG/gpPe2rRjieZQrgn/XnWWaFxRWRG69XUk", + "spajtgKvovc2bN2cY7ycdLR0YL+XKtt3CyUozjeKi3fuGWUs82repEjZBRfumfPu5OL3Ki/8ub7KiQ1y", + "Is6fWzzUIfHEYiGN8weyYY/TFUoTRj+WDfvKSK3cRyTV9IH+351cVFUxxSS4NTqrxA/bmY17eVGiwuq8", + "W5UukCrpZpmnH86Z+6CFa9bW6ernJxPQHdu+xB+33fhrL7CxdEufXBK+SlGZv3UtMiGn/eM0VXd9csq3", + "l2oQv0J3DVOugXdsiIpEMfOPgjflQTX3phiV+owYR+uOwJRmc5GACj91lFx/XqFX35rjYd4M9/RyDxdq", + "U84eLPQ2SzrFN7/yq5f7siEvDcO/hAmv3PtXcbZBnCn+7A/tBix+58Y51DErdP6jmObel5mj21FsvU2J", + "79+6TL/IL/y8jn7ZCddaADbwKKv1T6jhpZDItcZY794y37PC90ALvTXqlrjlrjKflzss3dZXHrGeR1TA", + "emZO0QaX3Tx6D5PqMmA5fbFry6H3cMfWtx1i3BgxlT4PCEliQ+ehnGunFnef5wI/WD0SthspxvT3Wq+d", + "1z6DiHbQ0nXIdFSN3rWl0JM1Dvq8ntUKB6x6suY9FOdY07wqLNqaFNb7W0LfZXQEdzjiyt5FSwZ2NuNz", + "YGNlZyTnyjgi08Sdhsul9EALw2rTkycGe5lgRDA7kwnkThumrgb1xMDXjDMj5DQF5r6gygYUG5UooG6S", + "Y5SVwn7OGI+vbppd5cFnctVc8/GHHOQap6OEu1LBsXzsHoeen2CgBA4m3caXKwoJnNeK/oC4j3hN48w+", + "BQabEJzOG/W6hKlSQH01YbeF0D/PqEbBz03pnl5faiZ61hSnkioQ/Zxe2ZYEOmAnSpoiA+3eoZTjuqSn", + "YQOq0HRohnWRLBYLFNbpahwt+YKnOyWMPpVW1oTyV6VsPRFaPh4SXn9W4nuAToa7bNecrrsirBwNY0aS", + "J10kBiWB8k7kYlcloz2cK8g7CXfpolyKj59F87DCpi3mH8pzSj3vcd+UWikylPbNtKoxYaqa6ax7jieL", + "Aku5dTh8nIsTnqadHNoxHQJpxiWaIOtxpz+dM82ptNqMS5ZoMQ/Khv8kYjMuk1oyMDWw65M9s89z4Wsy", + "H2GJGY3sLxUTiBdxChE2Gvc981Ad8q932oxvslRWdXNf1FpLT8TU+4cG7HoGBg2eLFPGpguW+wvoC5kU", + "cVkWL9cKe5sbPoeIacB23761x37jsHzqOAV1bDBbM12/6mMZbx1sX1luN8v11z3kuRg6VH5GpnsFei7i", + "jXHfhLkJYr2IgcG9sFgfGO5zrPiULpwW7t4ByKd9nxnCTode3CrdrzI+zaywibqT+yxRqGz4Lpl1ReS/", + "/tf/pvDsahVc11CIN+jMZ3GgUak/FXPoF7kvEk8tXxO1LYoTtT4WwVtu8yued+K5R6bPEL7dBZfd653j", + "XpvVzpeOURY6Z2/uhcUEEURYI6YOXR0zx64e9065LgVMIRPQKfbBbUoLXZb4jGdcSkhR4Ue6oKwHIkhS", + "NOwiIqNyEEUsn3EDVRx5GSvBhKT3wB4+5svs2n1yqp6d4ka1T8JooyKcua2U+hZLD9gIibbIRywDLkk+", + "h4Mnwt0LvYQEpjBp98bA9w9nM+CpnS3KJrRY2nDARv6/w4Sc5RrmQhUmXZRjGis0mddoyucwbN9QgERZ", + "QNJHwZM1vqxZiVC2VDndagfL10xWdVy7EIXquU5EPdwmgJXKoBuVgZ3VijKa0lhR0hJdZy/q+XvoRT1/", + "olamlrea+c5OV7IO6AoG7HhcJUi33Y1bjBX5apHb1msS7onJUiXd0LLkJKdOGRdnpx0pVf4CJW/1bWo1", + "1TxrNtX0xwj36bs/YzVuUWTugZwV1oJ2/1pR8kbblBau7ynyVLGOFaGg+aCyH0WnAns9A/ZOyOLe653s", + "w4fz/q1IU6wGjHIPK5lVGVSy7ML80/mAXfnW1RgkMTpIYH5wm5npKFgZHJpxWZEDTr2k6wahkUGm9KIE", + "KBnoQqSZ93iV+SCmGPs5UeXmtmR3psjdRZntE6meSCKvXPdXgdwtkPGyhkplQ4cSzymQ28Gyuzx2+1wS", + "x81DdPcdiZU0VnPRRoE/z5q0ALFIyPoWSHHARlJJCOJimqoxT1ep5TUbZZDFNbEUT7Uq8vAlQh+xYybs", + "azaK88KAHbEDHKf0YpirVMQLMte9/3h+fEB/6LtnK0ik3Yo9K+m3bJhKk/Do+25w6D3OiUjKnmK+XZ0u", + "YkqFHCmV4dGORiwVEpoCxh0Wc0uz2MkW2if9odplRwf3bDjRAMPbcUs/OA0Q2sv7KxGS/Si+D/306uFH", + "bnMRS0BjRYUyBGzkZj96P/KkJmQNdN8Ydg5Z/0xOFEuKLB+wY2OKDBwkXuE6VNxL/AoDdhpMnyFHWUOc", + "cpFhR5LYKSChE5XJeJp6zz5mkXCWcj0FhNrQKsvT4e14hP1UjHU46sBPN06HdSB3S6Hix2ZcJ9TZFKtk", + "e2h6NhKQsA47ThVkcGflAY0valvv4F4j9/rWWhiX++XRoHiP92nY5fE5YdEjwPE8t7BJ8/HCMCg+7XPQ", + "jx2KyInKsvbZGEZt+cTmprjdy/g9e/Gd0/K1iWqyovFZRwEBY1pBegkG3wXMgCVh074rD+Y9U+C+uVSy", + "r40hOxb9C3XbWQaZ+8/9Abt2WqqvMZTPFkbEFferq4cOzQuDyl07EnU1j8yHlptb04anOauUjDEWgsdT", + "9g3YPp7SL5WprNbmnDDW0N27KckbuKQtNVB1dO22QC+MEfO+xjdZbhfrkNKblN23JxwfA9yy7zCgTji1", + "SLGxKtBJSlILkR2RVVjIzEMUG7dPpHB+f0ZzfFfeKteaL0hpEdMp6OEmAvDf1Z6i25Ci730qE8fJRicX", + "H4/Ye6fJu/9xBHE08hVsarKlBe5hj1sTWIloM2WA8TRVVG+j9PLWinf5fVvFhJyrW1KYK916wD5MrH/e", + "oFeaGzaq72TE9mrTeCKq1cIAvY9hSTGXLBGTCeh6+2ocFNM2/c/uTucitiIbsPNt6L9xb11llOt3R/yu", + "ZBHbqmSIULtpY8elm91DhCJIN1EVSoEV3Wx7uD+Gb26ihLUyYHum25Siq1xpi6a2BEQP0c2wrDmD1nmn", + "6kVsyCXknmzeFEuYXdaPaThgo96Yx7dOkZXJ0P8lPITvlL4F7f4w4xqS6r+xul2rhhh2HVwiJ/SUEGBO", + "0B/yEDtdqOBR+Vm8PwSThIWc0jM4OF46Hwk8t/Fs29fm8gkWfv+fonqHzaeYy6gUnmQiq1X6+Inq/d8f", + "PVmoWvboiRAzHz9L8H49eqZaK4DHz0XmkUfO82kND+kYsxstntQdmmR4CnKiTpm0QkvGDhXfaXugg3dq", + "CtMo1+OpPBmwM8nqVSR913QfUKNy2xfyiKlMWB9qJox/QO55T/3dTOG7jybfZynweWgDGlZUk4l/Erq1", + "/OKGwT2PrTfRxyU3Q5FgFVWUxP0dX5/8UKtz2bUb4yPXsNGxUz8JWmz026fRPsYHMan6Kn/d3JwGy4XE", + "AksMbe9OKpG5/Fr5wkZMaZYIQ32Xq6FzwWl3EVuogmUFVRdOcAv3eSpiYdnIHWTkZhgh8EcN9aS0Y22F", + "ZA9Brqp9adyCZp61D9jVKuAH7ENQWoMEuIVFedfLF73voBbkB1r2YMKLFGX8EcNy/XeARfvJ1+l9oOjx", + "MT5rVqVRrQdU5F/aEfMSZn/AfqZ83pHf0Siq3Dw1HHLgcHjkSeMIsQmtQwH1XzMuF+QvUD5i0x18MsGA", + "AmpGVc2356VJFMImqT9rxGo8fT9io4p5jSiQLPBFMk2pycSpXOFisMKaQ5oxuCtHr49VA3ZcHc8DLVTh", + "oA37U7E4Ba6J1mw7lOkwI99mpVaza4+6baXU39/7fvbJ5WCrORzCz0DDa8yXTtWdYbywKuPWx6w51R19", + "T7x+ZU0m02LL9sd7IGeudJ5PUQ/uc6V3lhVvcNQuHL4xYjcSfKv0Haf4FzUp76UGM6uIZVjQjiYSMBZr", + "FToALoXtYq3l2u0eMboAj72skCm+Kzz7SRcltjg4RqjD0YOLmJQbWlsPp/bQ9/KBuPbepMAGdHnKY9h3", + "gwPZ+EkoPthnlPi/WUW8v/5YDMNq1GULLd2Hr90rwLPU+grE4+uSJfBp0lJZIeMZl9N2XFM2zXdFjw/X", + "7y52R5GVUbuhiRt+gEUP/fUFJfwBIr8FyQQq8w4RqxDZCtTMrd7EvA8NbjVgP6A1lsFk4sTqXtik5QvD", + "hHRMcI4lDEHiZ5twa2sxeOIdkUFNgjdaK70rDVKJRXpqj7FZecKCi7PaFgbUeMu28f4A8tFT649VUGRg", + "jFehV9/O7e7/crUhTZ3x3FAnNvQCH1SRcd6PceBYgzRCyQMfxXaQCIMBbE4YvS5zJfyEWOLcqTU+hcBh", + "PLfCl2Sqd1xu7gSfz/WZWl+i7d1qP+Reold3udyfdtDwxat8GO6fynBqW/+DbwaNF+Cu2nF6fwnuP/z5", + "w4eiyIaTlE8Nwcdd0WbPXDhzAGGbseAkFfHtuSoM+BrsO8bajgtr24q+4JSMfiVjGykSKOlr95TCxPai", + "nnaKk9uqSJI02BbIgekouhVOsdt6R+Xaa2/VwG98qGNt1UTduf/EWAn8pHWBmUqT4S0sTNvxEorodT+7", + "87lv6z04adaaOXc1vHfJNCuLbIij/HLIlXpHL5Yp/T3mb6LJRmTgCSsHb1kK667aqu5XT/EfLFYYuMqr", + "egd0Y7mi8LnWmVqqQP/nQ2ZaQtf7npu6A0nzseI68cUgdq262Vp+98QL2ThMTrV3fSbT5vhlN2nrZqnf", + "qj4uLSEPMaDGfhaPuw7KcA9xYVHJyLn2/RyQ1Xs1mHp3kTZBD13P4m9kNUtO2f/kzSEZqakIMfUow9Hu", + "EvDV6D7wY3OueQYWtBncyDf+batk+TuNbBSlRttieAHkWs1F0hH7gaScOZ6xSZVZZVifol6i+XS74aea", + "T5dHZ2oO240+V3NYHo0eW8cmNg2+cB/+CIvaWBNrlW40vV3hV/VhYIdxoY3a+MK4AnuCH9ZHpwAbNcYr", + "95FH4VqUyGqMUrAfr2BYQw7X4Nu4b5o59EeqrrK8mgZsGycPB2nj3NWkG47p5MQ13NvyepapvL07RNQ7", + "0cAtnGKDEKUXDxOemUpgjaaRhNmZ+5DtqRi983jKiGEU279+993+gJ2SsEBZ8K/ffYdKHLfutdU76v1/", + "fzvs/+svv30bvfr0T+2Jv3bWEu49Nip13KbahPsQbSB49KVFDgb/vNkp5VZqu8xTSMHCBbezh93jhiOE", + "jSe4zNNv/DKkfzxs920OqLOVBKUqxySkBJYnikgkUAV+xQ7KTw9Q6xyw4zSfcVlkoEXMlGazRT4DOWA/", + "u7eMf4VGDZvW6mrC+NWSZfTi/V+P+3897P+5/8u//NN2JXFOSbvd8hm5VEcPjWzd8jy8HOi7qiJQR/Ej", + "bG0+1NzC5in910xjI3XJfviV7WV84aSbLNKUiQmalxKwEKP3f7910TuRtOHr8mr42dr9t17tsoB7Hn3e", + "ceUOXb7U4Umpbw3eBPe2qau5h8ua0Kn7ZKUw5BjsHYAMG3F6vA+55pqM5oo58cJ4qsrccYvVPjIhReY2", + "etgGk7W9xn3WIMZNsfDlyt5Ccp+jXA10Q24vWRkzbTKl7Ox/kOkfjc9opQ4WR6fQuzOMufE9D3BBZF8p", + "yKk/B7+nc7w4PDw8rJ3ru9aDPeYR446w0xumnRF/0FiiiqXCoNb6t/uILX6pvxhyLrQpYRe6iFBLBreJ", + "KQbpnDtN0qumjFuWAjeWvWS5Et5vW+50ecv1CLgyPuYlXl71H8unWfsjwbKBww6uy2j80QCbFRmX/VTc", + "AvsefhVY3lfPocJmhPAdX9BBmJDGAsdeNamQwDW9nnOVessV8m1cDW0QZpiDHhqYIqYROUA+RCIbZgZN", + "82IqVbNMWC3EuPF540jf7UiXZd0i3NcKBM9oF6vUsJE+V87ZfCQfdr+Syy0hbtG+sIasvy8fm4hsonuD", + "7Jy2x1409vpic9RGl+5QWvm2tbctTbzOqvOGnooXKV/cIRfeVhi0t+WrPT6rKTGrqSWgOukwx1BXn4N/", + "53NO/6S0qGpuesXiH2fcMB5jbI9V7Bvs9xKxb3xxgW/o8fqN97J8w+ZcCydu/cs0y1M4Yjc9fseFpZ4Z", + "U2XV3jcza3NzdHAA9M0gVtk3+6+ZBrTQ1z7HtOi9/dc3vbZYK6pnR3VN4gYe/mkFD8+JW/szotomsnol", + "sFJ7dxrWnw4bHP7bBn/fjGt4+Vvig8EN74gOoY/kEhZUp1u15AcsX0pgwEbIHoWd3lTdj+9B3d6tym96", + "9RlKYdgEySrwCze3Rxn8+8RGEtAt+7kKUYvUobkMWKsfrMVQnKi2Os7lZKqweWG3na1AhF8X5gD124aE", + "+SHYLrDd2dDIUvILtCHIW5HCmZyoVX4kzDARev2uUH5hBEL5WuzoL6o666M6UZ6hQuJjN0PZujKHJeEW", + "+r588mqCQSvfcceix/NYWJ+KHLGbXqLv7nXf/d9Nzz2Ibnp9fdfXffd/N732QMH2cMTvuYFGthnm4GM8", + "xepNbP3oDjrrKpKIX2E4XlhowZMrH2eIPw98KdawDQFmixDDEC7KUa+vLRYFPKjB0F96FzpRLGlHdtvb", + "qjgCuTa7OlZvg34cPXbYHmlLPHwoLMulHgrU3bCk3ermk78WOdRNbCeXb46v3/Si3s+XZ/i/p2/evcF/", + "XL55f3z+ZotELsrh6lRYsIPfSthAO3xPhfuvkKRYSF/+v6yYVHptffpraNPi+faPFCiNWZhVngEvM5V4", + "yiy/V1JliyPMYqRqAb5NXDW7sRp45uPCR9j3Df13SmeoWShZwhp1CLeVMaTqju2RAZ22RJZ1H2Q16r6H", + "UcQ0TLlOMEYBoxkUy4txKjABVdgBO+FpCrpf/dFfAMZafbi6Zgfl7g/8TyF9ssxVC/5tYehmXzMDwEZL", + "eynfo9ih2cx4DgP2E09FUnZjiHEzIQnBMD7l7u1BU4cLDhkesa/1hK3/sGlhcLiijpRUECeBn/E8d2jm", + "dIxQw2L70iCYTIhBUUOj0jkMg/BfO8MJDblyI0hbKSdL8mGssozLZNMcSX5CHzbHYtTWNmPxw/pYdzXb", + "Dj8tvy1noNCsodek1k9A36J2tTw+VdPtRr9T0zC2Fv5FvskNM5xV36Ofpm0e9JRsO8uPsGibg5wDZTG4", + "racjT0qjwGHUS8UchnMBd1sC+Z2Yw08C7pYgXU2zNbzDTKtA9xFttak2HvOchpzWRizPJqSwQ69fbzXZ", + "mRT2LX6/PJUGv8pO812GURsm3Xm+1bnqcdbbTHVVfh9mqleQ3K459lmSwvJox1mFnG53TX6edzSmeUlL", + "XX23bdeNH6/O4btS797zuxc1+23u1sU0jG5p3vfANolhxqVWXlv3q2rygtXOTLs3viqnifMd2qCUoxRP", + "dqk3H8bVaibvXI96dY4d7rGjcGy0UjVw14KMvailCtaGSdpqw0UrRYZ2LuDUi1bqIuxacsKnDLunzeI9", + "Pj9Iw/4U9ZSE7cvTLwvpT9Euw2qawZYD2xjJrkPr7GO3sS2ccLcJKpa85bg28thhaDuP2mGCirB3GLRE", + "ODuMbGD5LttcZnq7jA0sb/f16hzmQQB9yAztWu3ug0tldvehLYrrlpN0qDe7jV5VKncbv6KnPXD4A/hA", + "hya75eiGINkW4dqE0LZseunxucuw2gNi+2HLT48tR7a+gXYc+8Clu974Ww5vlcwPLexIbVHeCWPRoNli", + "/NOaL5iatJgShSTLNrYkoboQg23rP5Tm+hYffKkZtJTwTNV0OSWf53nqTe5rg/+X25lNS++NhXvb2X6q", + "o03Otch8E8dyR9TkktLOt7X7d7hE60u3WTLPudNKvlTQVsb17ROGbLnpQKNtMqmlvnRGcu0YvtVlLH9f", + "s5PTFiKGRTY4mQvPL16xeMZzi+3jbAres/kOA1l6Ry+9bzP894tNwMVtbAHNrRyb21SaqJ+QbhESf9RW", + "dFeTiQHbGkB0odVcGIrqpM+aV1eRYw1cDhGi5UiLiGXADWY0VdZa8D2h0LWMBa+1b/uELnVe2JnSwlIY", + "hF8/WHU9iGiCO+0QC4NrJkLyVPwKW5WRa3cjVRfSCjZVGLjw2QGXpUFi2f+4bdpCCAp+eLpC1wxbpyms", + "RIfvhoVPGIKG4dKPDD5LhLFcxtCISPjuuUPO3J53Cjl7fByWdxtWQVfun1zapVts9yRuQs8qpi1gGLPq", + "QWi67Uw7oevDY64TMHa4KXa8lhwZXNqbQq+jntHxpompuOTWcy4HQoQFotop2m7ow22dL+0QKfMXanvC", + "PvwYfGWwqlyp241Ye0ZtkMCEUI/B5jAPddt6lgtu45mPu34YxLsCr0+7A65LRvHy1eHu4dennWHXA3Y2", + "qbSgwvi86ZmYzsDYqpI1DQlcUQOij9eBvOP8T4fRt4fRy++iF4e/tG8Rr9Z7ATbBa+LDMjVMHO+gpFfx", + "KxALxsrGcwF3TqOrVD7fq8FpcJhk3M5pfPZslUO6qn9Wq5M4D5nFviBzdf4QdGEVA+m0CezHk/Ccckgk", + "3IVqmFVsGuIE3uUMeDIp0oiqToS/pB3o2RnvftoZ516izbcvD7eLel/OrXqY5N0QkR6kbhBbVFpsYSgM", + "fblNbg1FHbgPI/qWa2AWSwJuDnpdI0jLJKFsk0S9hQVVFWXGXY6X6NsL2Pb13/lYbje7WWRjleLiuNCA", + "veHxjLklQtOnMTBe+5aZIq8qYN4nyiqV3sg9A8D+48ULPMsic28YbBehpNkfMB/ZacrKrDe9S4z3u+lF", + "7KaHtkj654nVKf3rOPV/evvdTW9wQ/HcFPIrDAWkx7hBnhrldhmrbOxFlvE5VjTfv9gQKob/hav9yzUf", + "47Q7XOgSt8bbbeXXVHfuzT3ETxa8y5kPgWBmIR0fkVgaf1U0cT1txoH/7ZeopQ6fm4nraVF2w94eq7gZ", + "aqWaUdztxyiateaxUowbynIt5iKFKXSwHW6GhS/Csn7K0DTWfe2mkkWK0iPw+NXM8xBIshKahRcdSiqZ", + "GaRpeeVOFhTtvTfju7ZSF0pjQfzKYrTH66Fk+35GH5xDi1Az9eUDbNa5QM670eu3tgQeD7PfPi0D7I2c", + "C60kPjzKwGysdO6b3rVXVawwfyW4erd46m4AdodNEzg3kuGjYqZ5nehKgJXnWCXCte/BN+X5ux6D7RUr", + "4V7YYXuQ/kWo2RlalnQ0YMAQ6uH4T6/aIyj/9KoP0g1PGH3KxsVk0mEzoRDqbSdThe2e7FM39H4UVfr0", + "buC7ooYtiL2ytK3VsLcJMqr21WBqves3l+e99fPW4zj95z+evXvXi3pn7697Ue+Hjxebwzf92muQ+BJV", + "0YdKE6qqzC6u/7M/5vFtszz2chJIatq7Fpcdm2KVFhm1AF6X4BD1tLrbNJf7ZMesHJw1oo2uubGrnN/J", + "+oVt1Ui+RXSv9pH3VYphaO1isxQ89l8zznIDRaL65en3Lq7/c3+ZsZJmj4KojJubA0mkDnHZDrTQ4m8Z", + "cL7GVu0QaFFczuXaAaQrK7nPHr7Mp9YO9k24PoCfn9W8NnzsGBJnxs22jh5aawx/uCqB1dXrJlRxbht+", + "hb0H+2Wf75Yuk7X9lBbcohBJOyPGpvxDbtudNdRnZKXzjx+2g7+mk9Qst4XZtbJoraBlYUjKdnOlvBjm", + "cVtLa2NFhoHqJxcfWYFOrRx0DNLyaV0KSkwq3CBGq45folmlesaN75m3jY5CrRo6Uj2qHYfC96HuPu2+", + "zALpkOCt5paLCqa2kVpQdZOi7bfLom7AJkI+TOiccssdJ7vTggygS6hHWVZC5kVL5kjCLd9KsUjqq2xu", + "9lTO+8vGMz9KX3Tb8Rntxk23ekLvrelCkioFFj8Izp1Bb1uTij+KBl6l8eyiO129KfsbaMg1GMehas3t", + "fHqc0rVedV01uHeDZulOq5DFnaJVBYV2Z/m75pZW8m0cKbTWNtiKNZSMlCYXht3gwJteF8m6/bdIATKE", + "+zwXVWs5Fc8KedusSIfZimUO5JZETIkqCP/H2SHGKllQ03OaMtQypguQnrqXc3cGa/uEtSVGlYWkWWkj", + "QztFMhdG6cWRrwx8K9VdWN1Xzgq9FEEzEqtLdZ4bftSUmvZSXr2pFWsesDOqVoptS40vUVhIWjAujHW4", + "ucjBRA4NyPaKFQ2JxzRbLoUy71VF9CiU36/XW6/KuNdqlTcKzpfVwhslyMssmypyfm23ta7ay3SPntoH", + "j26ttiHvrabsbNFouquEE8UMgG7Pe50IiQla22hEldM+jOrShzaalkjVW/2zKSMcar83Sjhsrb8thRg8", + "eLNL94x6ZX2fbXdehSFewnSb8njbuaB+8IW3Q7DG1NtD1lT+6XBK/IzOiF0m2jJAgeb6xr3M8n4KEycI", + "tIRHhSzsMGerVzjcQhQudhPIHuJc0SWgN9S4ayJGqzRqVsLb1WGdWj68X+/j+UFp8auSWGcN12I8U4W0", + "A0aRKu4NjX83DMsfREzClDf+7uDQLsRpBxvqHv3kdhxvsX6i7mTL8kXevvhjgjLKWnzb2/c3UQW3vvpw", + "VTCwudTuRLHzlFtHSqxUUdyRa4kkAbmhsANFdFTuMj9oo7vff9ex7bcihQvQmcDQP/Ow/WOzynYbHPWx", + "pJx5zf7SMGTsWpyhpbzhn1692t+tmqG6k20uH7dX/AmdPGG/Hzv2u00iP+WU59XdkmeXnIi+WvsDKw2u", + "KaxQL8u5Y0MkXhiol1mhNiw5xI72k9KNsKMfou4Ux3qcbW6IekGbRvzY4UairC/eeiFOhXlrfuY2ftLi", + "kWVlT7QMYJHd9pI0jnDFHDabcEtq9/Oxcmy62CKspzNICW/gkdHME80zaA/Cuax02/CRA/EkdxQ7B61F", + "AiY8m/wN7Ndh/vJwkz241Toa3m4rdk18Ki3FNPvQY/eGpDhJUau6gz3HaiHWDGTiK63tGavyyEdkO4Hq", + "ni+RL3S5T+/GNFV3blRWpFbkWJpZhgYN5ZzmyYps1iyqO0VpZ/w+0OKZvCLa63afVkvX3YchjHQ9YNfC", + "MuP3WPxF/Apn8vz77h1gQkRojXf+/ZbItFzz8EVHWJk73XGRCLWZLk98Sx/uPqe6kdhIfS4SUAN2STRo", + "6tYBpyLxOTAu/Sgfj+jw5aJIDRz7v8a3YOtNKLB1JFY1YdhHZKzsrNaDYt9jC4VaNcPBhaEd9ZXs5Bct", + "vEHlj2UNSsfg5tl8k2dZBongFtIFc4SFsRqqsGyqeQyTImVmVlhHZr6mS4bBfWjwxM4osdK6wEZBeFTE", + "kXZn1SPSL4jkP0/FXLdW/iQVc6viLnIOqcp3jUi9xsKkNJSVTiOLfaxrVcTYUmGaltYswVy6tqx2szwQ", + "liz/R6fHoZ8pqaySIi5D1Bi5Wqqd8lgrQ0SYignUOwgTUQ7YR+P7cL/jxvZx5f7ZqY/BLHy+0dXVm2At", + "9QJCGCogSna3lVSHHZzK7ozBnvzLWhh25Wct1UWi9I07oaGfwhxSb2bDWj5YHzGv1UzykCulG3KjUFfJ", + "V0aqTj9gx3osrOY6lDfymrehxl5UK6mqDOQYZEKTDdjblaaZ6wo4RW2Vl3DHoPtoziO0YYmKMZQMyv7t", + "I28f/Gdf0uhg6S+nOG8tTDBiq3WbWhsObGtE/qOYYito/vvVh/elJbYNVKkw/orXl7Kiyn7kv1kGXbNp", + "RBtQCKbu7h9rDA7dfNt84DYgnJfMpV+F3EDYkuKOm1pLYOvEik+actpHKjLRkdthWxSoj1LcszK7kB47", + "jjUtFfOsLsprisiw7mrSY6u8qs9lCi9hfxVcww9wwnf16FuNLs3zVHTYqn/madqPsddayGbzRp3aZTY7", + "PTr4+ikpscmGAr6N5mD1xn/bRyxEvofUzq38qiatD5N8Xril3NgVocxOFdCBsB9dEI7NayEjhBmsFWqH", + "WwRH4kHoHK24s9RCY2er7OMqwd/CwlitbsG0Vm9uDRdqrzD9oESyEOFa7SMk0tUSyhwnuoeE4WEHN7LB", + "JHQBbC90D8xCCuFBEur47w/YFbWMLTMwbqQPmXcswK2Fag+XTIVXc229xk2xPfzb/zh09+Lz3PYHN7JW", + "URy7ILlbW+QkJe6UTvqOVybkVPYx2OXJhbSa991XtKC5kU6FkJwKNaJspJ9zXhgHp2vUm93eiEO7vawB", + "XWsnvaijrZNDRbxX7EtDwmCmMM6fOip1FNpUQ0cwMazHRWwrPuNO1rt34CJXTMi/+86ymlt4zTJhLL8F", + "0plQTqI6gnc25vGtyXkMFRKwwwH7INOFZ2Gm7QbYnhEpSJsuGvd0I6vPEDf26arK1/Lh4EUr1oc4pm1b", + "Wv2shYWyCdfDCH09tBoRPqEwbFjwob24PmFTcnLuYgp676jnFdMzp5gadnxx1ot6c9CGtnM4eDE4RDNy", + "DpLnonfU+3ZwOPjWl0XFgxyEBKwDashHJsS4xYZ4DnoKmEyFXxIKwL0wGAWjJJiIFbkTPmxp0pYUrrlw", + "L7UcNIYxJBERGZYsL6QVKd5c+fUpzK+VSg276aG6J4Wc3vSw2kIqJHZQVGPUmRI2honSoXY2PmB9riEi", + "U9nM+CxBK7KNZ2GVt74hoa9I971KFhT9WzVpq4pLHPzdkM2aJGaLwz3c5pJ2EY5Ed2gVy/BafS3nv930", + "+v1bocwt5fn0+76RdX+aFze9X/YfnppDG2pHq+o7R5+UnYdpnrjOy8PDFncH7p/gneAjqzyaB/ZyRe9P", + "Ue8VzdSmeZQrHnzPA01ST4FPUe+7bcZhfSHJUz8Ka5BnGXevot5HwstyiykvZDzzQHCb93vuRb37fqln", + "9at3VfX2cRNX+F02vNxEN4UB3Q9N46qNALbC0MIAo+ahrDIcllFEY17+PHB4F93IjQTFdqenG7krQZ2A", + "xu4l4RZYxiWf0mv11r+Z5UTzUOjY4zl7E3qDXvmeudGNzLW6X/SxvQUk5Yx0jnL+gKhoPD85vTgICf9K", + "7qOEwr7GkNxINIeEu9xI+xdV39KHkn+78GjTubYB/oD9GNIr/U+SZ2Bu5J5P4vPy9kSpWwHG3+NNj6z8", + "2D7Au/Bm5Qz018GNvAJgoXkENW6tdjKYKjVNoUTsA3KtlSnI4e8+rouSGN35v+dGxMeFnX2Yg/7B2vxN", + "6HpMd9C6YbRDuY/Nx3yqeQKmHOXF7jm/PyltDeYC9IXDk97Rty+j3oXKi9wcp6m6g+St0h91atCJvNoY", + "o/fLp6fifAFX/rDMbxnt3FkewwOLPFU86VcNf/tcJv0wm2OMyrQoSx9xGBUt1yxzPKacgv0qcsZ1PBNz", + "xwPg3mK3XTuDjBUyAc0OZiqDA2IyVcNlc3BTHB5+GztiwX9BdCPdm1I7LpjVVyDeL+QDlJWSt97Iz6is", + "0H2VrNMcy+SyhFg31yJHHzaqVjrrB3tbl95Sa9vcmSVdfeMUGAI/eRdjK+bcNkqebFOb6K1KHUwxkMEq", + "hl3rfYuRAK7doL7koTju/5X3fz3s/3kw7P/y24vo5Xfftcdb/CryIXajXtniXyuEDE27fMhvIXNKIKsI", + "rNz1HraLDRneGZdiAsaiEN+vWzLGQjpa3fQyKLcXddePWqsE1qD7ME3wRVsYeIkNhAqQRC38kKimJA70", + "e/PkS3PGFRZUQrOG5HvcOIZk9utssjzi1vzSv9gPxkFPbOeLb0J6u2RqqdXcUhtlQ35G32P5+OIMWyAM", + "2LH/FbUHCh1zKhHZ5KzgabrwvcxmKk1C5Pp9nBbGobdToSJmFJPKRxtgTgor2ZFhMZdkCUmBzwH7VIVI", + "HGNVboKpYiK0sb4LUejQHEDDRFkOhmyiofMydZ+/kaFRRmHQ24qt8Wee7hKgxDr3+qysjZgzRXWO3Gq3", + "sKBW2P66bmRw4eZ84Wbxng+mVSGTvtUiZ079lDGF9gPWfZCJmIuk4Kmfpo03f4/KZLNV9sNVybWW2dWV", + "qm6/D1NocMqONkxfkjpLQqC24K0EUMfpbkIMLqwmHS616Q7U2IRs1aD7mQDa0gH8gXCkpqahv3mg+y8K", + "wiuRFSkl+hJZUhd9v8cOe+auQCSz2oETJ91wvASenNRMcG3X+VTwbHb3R3AuvQDLJv1+SZSFK5T36Ot3", + "hyYLeBk+1mKNfOB9o5Gz+8KbVtZnIp52U+5DCQjNt6FopFXVJf1+eOLPZFkOXoGnAGjZeb8djmW0+DOB", + "cLWn/9bQe5L1a1Xx2iiVAtnnIrSHKl/9vxuU+EEkvj6PumuW/twJDxLNp6vCcNnPiwWGZEI5FYGpU/vq", + "qPTXOfWSh4qcbl/akoMMozDkckvrqZiHrsGkX6fADaACWG/GuKHfcptaVnYPfybcXelO/lDO4yb6nYhs", + "3EpVdZXAxJkP5d8JpaZgCaOGuS+M281m/gK2UUL3OUV0e63edurHCA26ivIQT3HNfwHbCALx6hGxm7DS", + "k2hIjto2abllrd9nIpSVWsKP03H9NbmTfVliOQ8lbBvgC5K5zEapeJV5EpBiXUJqPbeWVYc473IjGDSB", + "bLkWXVHmypDPoUraqlVDvJFtNQ4pIA/r8OUaZiDJfrBaTDFiBuBGus20F0Rk3FYuiamwg4kGSMDcWpUP", + "lJ4e3Lv/l2tl1cH9ixf0jzzlQh7QZAlMBjMSGT54bqak0qYeZuPDTsN5DSuMzwSJ/VVgzo/xxkYCk0pa", + "vUe+Qucz0ctyAdCHkgsCFLHl96SxkBpRt7ohXj4FZdT75HUxu2t+C1f1SNVnUWtX8ow/eSCuFWoYYnyQ", + "U158tdJmQ/GK7Ko2QHHLXxTiZVYKqwAUYgIfC2+Vpt1skFKs2dynIVOZiwPluENIjXZ/szVFtMasmypt", + "w2LaKFTrddVGjjOZX4VkqZpiBrQV8a1he1JZn3/vM7IqFGNjmPG5cETBF2zO9eI1swXaOzOMfKtX1cAY", + "N8y4qY5Czt+Qco0J2t4K7AMPokZVEB+ihV61hnF4r5wD9fVqgX2K00F7HAV3hTD+wExHIZaPLD39voYc", + "uGXvWb9PQXKHjLw19Gogf82ojcdehUznZ6LPWu79Q/mrR6/fibGNNlOpIwQebp36/pQaZYji7mCvPoL2", + "mQC3HKD7KGMPRYX+bgSjOxsZdx4FJh8V3s0Vq3LbwTnM3P+jwPPFckA68r3SoWcsX5SpYEzJGNgeBZhE", + "N9J70CvfWeRYDyZHeudpVNM7fcV0I34VcrrvjQPlQlX2KIN7Htt0cSNxuYYfUQNPhHT6hDCM33EsSFfV", + "ShpRlflCpyNczzMuzsZgbB8mE6Xtjaw6hZa15cOswWPkZkZl0T3P+BQYJaR877irg1JobK4z7DOTMKtu", + "5CiotCPfo4TLBd40W6iCJQqD3iW4HR9blgJ3irMMNnyKt3Ffoxd5DMxXHRvcyMsQCNWElbFOfdWFLIuC", + "owvxqBZPVYeNh0BEwRARKuhyGWKDVpBgPSgCBwlPkAmFQpcZW5SlcCOt5tIEFfuIiQnj6GbTVTiX2zc6", + "/twGuU6dYK2okmEGK0wmENuQZplxIR0+4NoU+h2Dx1X3J6lk/+X9vfc95lrlfOpE+uBGXmiYgM+9Vk4Q", + "Gsg5ZoKPqliQfx5R5tiBv6MR+lZ9PHOZPO19wX2rxXQKThW7kQQDoiQhEZ4hh7IkzTZxF275pKTfJwzr", + "oDCvYT1ccSka5/pt/998tlUzFo1lPGf/9b/+N8OofgMZl1bEWGf84vj65Ae2Gg3ZXhbcfzXsCI2t7YAi", + "EtjotxsKW73pHdUjY3/5NNpyQzi6dTcerNtsI3NMA3Wb9rfaaiuSEdvDUkQHVIjoAGw8CNnQVJI/hNCv", + "IhAlEZgo+Moxp7xMCVrmxlVWbjMMrUGpTSJtrRq4JurnTT0oy6CxNew+diItLrBiTzXFAON46BhVLsja", + "KLH9weaQoUcH9Dx/tA1mCbghQ887V2/Tcj341di2WCLKvzZ4vaNGpBMGD/scVs+cPSswA+bZWYiW86Vc", + "sKeAb8RYBYL6we7/mYNQij+8AQykbvwehj5Q6CQb+bDNA1oFgyxG+5SdPHL3lg8rkhiRVEAWSeD2sSXh", + "sHbGy2go4+QdfnCneZ5D1UxSLKV5dYHLl4lzwr2FjC/flW4yL97BC/eKC68V36U9KmIpdvVzRBVzojXL", + "Xh6++jcqRRpVpOcAGGPwNoW0II/wAKBdjFPoKB3fvMs1SluVUhduEJ0k1ViqC6BFTm7fJZwssWLPyciy", + "4pbPHcP2EXBPFLkxk/935apraEKeX76u1M0SC9zMKSz78AaP0fxfHf558zi3wVTEK++Fpwk7WNYewvui", + "854AFS73v8jLyxj9hOUzjldcf5ocoz5DD/+kVGjQGODzsZuaaJ4WZuXuya+zVbRcTT6XeRUtAfxe7j6X", + "Gbaly9hnxnm/ekjAXQXnR++PDq+pBhi+GE4/Olq9/ThbIs/EHMQauIVh2W4GEaloC/DCD8sCWc8V5dVc", + "ZSdkerGunhed83dkw6CTMo6ZgkntWreFHJWr2gJyp/jhc0OOVql3lnywk78EGh0xeRx1vto87r2yb1Uh", + "kyeMDsCdM/4YyAZ9fA1Q35La/fuGJ1Z8/G8ASv/G2RqKvrCco9DhrwIraU3BttXas4WWhnH217MLVr5a", + "aq+d8Igpax9V9RsDeg1Wg3r8+qdC/1XkmOmheQYWtMFeNl3dW0vqQ23ZqvJV4pSYcCh8h7px/ygAcZte", + "n6GSZRNLorq5ZVNlzF92UhL8vT7KA+huPZyxLCGGqFe/4D8i5npg1dmQe7cQooWn90Mx2thkC5QO7/g9", + "y3XtMZ8FZzvq1G6u/bWYfyPXoD77q7EJU5MJaMOMmEoxETHHwgkTbugpSwt6XfxGJlD/k/s31/Sa/VXk", + "3njE45mAOXbHBrs8CxJaezBdje7cHf1RCC/6bbXXY3lcjAgZsB/EdAaa/su4B3NSxMBMxtO0bloZF5ZZ", + "fgssVXIKenAj+wQJY4/Y/3TQpinYi4j5shUOsJCwvf/57eFh/7vDQ3b+/YHZdwN9WY7mwG8jNuYpl7FT", + "6dzIA4QA2/ufL76rjSXANYf+axTgGYZ8d9j/t8aglW2+iPCv5YiXh/1X5YgOiNSwZYjT9OrgqDrFhX9V", + "Jcf8VfWi2m+0ZfyHaetAsivf9NT7KMZ5vWSj+z+EeS6ZJndgoGheCrVJPONsMg+nK2Fnim25BvIKf/HI", + "QJVuKgW/Bym9m+ZZ3kELyqEuKapubH9AxPoL2PoJyn5yK9DbAbFSYSy+F0wnZr0TBuvCmwcKpD8mLlWn", + "bkGm6qGZUnWePyA2Ya45Qp6SXB+CPZmadz80z9UcX4HPGPH8FI9MjDCujDt/QEjiCZRmGtAv+DiGoIEn", + "pQGhlR9cAk+8+WA7doDbCaqpm//3whFUbMH2q15pj9JpUMC0Zhn+wdAJcxobLtAd0McAiZNhrdNFJ4dY", + "bTjyfClwHZ1NHlyjptbIwyes/QFBfQV2lVnUm5QcYBMUM0Mz0LY4QJ7p7uA4rCdkag5sX19B6SruhwST", + "z/PQkCnPRygZc9BRuyWoKU8W1VNqRh2hEwkYO9zQ/sV9I6R32nku6OsXetV7m8YvUe+hURbe+lhtdeei", + "JnQLT1bPBKFUljL5o7PLlhInE4+GuxFMMPWuLebE0cxE0YMyKes2CWsqW+9KdtQyBnaRD1l7n4x4diWO", + "pN5Dp1aRqopuUdtRyhPFJK2jmAei/l9FXiF+DYD/bciA1wuLLaHoAyjCG5s2kMSupuIuyrmRm0lns8m4", + "YSG+kUsm4u7CY97m+2Tk1xkhdz2DZVNUKYa2iAn7YmTdHsHVVXr5/fZBXL51od8blhXDYt0Onfp9/KZf", + "jdsf7FYRvbL2PQNDOfZ3+N+cqSyj64MZy91yabClF0mtPdxzvUVaOtBtD/0HFkvGYw/buiB9lOIfBay2", + "Tatb8e78dWwVrbjcn8HGM/bUFTu/EDrSYepmfV8yTU530vfwPg9+C0D55BsbAFX7WcZIlVcIuWRwQSOK", + "t5p4G0oJ6XV2lM1mk1dtrTYIlBQM/wcH5RX2Gwt5Bw+zfi6D8YDyNDsNZ1doaHpr3sy9UeWzQXPZCGbh", + "3tJuW61fm3wsV/gI9726WhKjq55ZalJ7tfs8VmwfzRM89W+9/+hfXb3p+1Je/evW9jXnkAjuOzRMsCkV", + "tuvxabF7y4xwv+EvDb7RFXbZ4gr99EdEZGpOtnzLvjZQYN1b47QWmwLIsELWNgbg05oSyFeMwZ8xHuFD", + "1eYktBDu7B7c6Mj0p1evuraJLXc7trW25zCR5zZ6xSPN0w+0zJT12f7owhpNbE4+h3jZXcLwUjU1B9XV", + "tztG1dQQ+XXw8iWU8V3N1uF2YFaeCKqa2G3cKmpfZqLSVN21x4zQequtQJcRAdOMyuRRMQkdS4UJdarW", + "kG63ZNplndrZ21erPhjm1B6r98Wk4js13VIcOsT6XUvANuniNk2ZvFdXb7YloTzliztN6ZlUaHaLksxl", + "W8KLcjSLHcNGH/VEg5nVmpIj8O4t41MupCGrQsiW0YXEwvBSSZaqmKczZezRn1++fElZ1DjrjBtsjGmQ", + "3X+T8yl8E7Fv/LzfUOLZN37Kb8oeVqEeiW9G66NocMZqc1iA2xZaVv0pAwK2GYH8FVTnPiEJ8xxv0JW1", + "vlDuTcs+3IW2J1WVl/t7LKFcHQHrZ1zhzgkjWpBzy0ITnq0h+XTbLHxvQLeTZyuWVa7whRClsYMuFKlK", + "pGv/ze+itnasssyxEbOQ8UwrqQqTbv3MDChgcn4nN+LAFX71rEiAS3xZLPBb6EID/PkLVwpahT5/FPh/", + "8/9AM8OtaBbkakWFHwVWdtpsYqhmXquZlk+OohDJY141DwK5O83vsnzxhx//kGEfjh2JqXsSW8Uq7fnh", + "OEl1NDZi5SV99t8GL+k8XzHz6WLPsBwLZxfX/9kfU5+Yp0BPY7ktui2zQbDQV58bO59ZWtKh2gSl/+UP", + "GQjvAcBMgNljkCMRW+hW+NV/G86Fx/nCehxtoUuP+36BnYvIGvmHNUBW8pUZj0GPwlRV2E12yep6VWHX", + "Gii/EE97hKGtPJsbtqXJLdy/KmxeWDTppGIC8SJO4atP6vl8UjW8V4Xd2X6oIcY6wdODyjfezqEp0f4y", + "fP+sdQ3KVTZXnV7ObPYDv1xFgy9UcKasg5BrmAt8/zICLiRsLhJQO7lmanjhMy07OWFIxayjxlqX5VkV", + "BlPmpAawhZJMVpU51RHjhuUcgwytYrWtYcSLL0ioMifCfGlo74ppmVeYcl7oTJFBjtvudOT9X4/7fz3s", + "/7n/y7/804P4MsLiIMtfPToZpkJ2D9kGdy1/7b8VUpgZJP3jtmb/IgNjeZY7WGDNuyZAJn7wgP2l4JpL", + "CwSGMbDLtyfffvvtnwfrvVGNrVxRjNKDduLjmx66EbeVl4cv1/EMLDcp0pQJLB871WBMxHJs5MOsXpCV", + "maq+Nq/7EqnpeOJ+WC2vXUynlHGN/YSwg6+QjLo5mFr3XL0g6qkOUUZAvmiJgPz0B07bpvLeBkkUMLD3", + "SZhVKkh0debYErAd1B6pepe5KuukWViN8qVXEkBWKDq0JtblLp8sCZWnaW3anS824/q227NI5zSMY/Pj", + "hPnKyZJw3Uf+ckmdlWs0jQWjJ0JitUrCCa5vQYeuA38HDLAVIWTcK5fnF6+cTIhnPLegw5jVhItzrm+f", + "W2FprPGMoaY77KHrrXeO91QS2v8xqtFxkpSYSbiC5VskE7If2HyFk7vTxkqH+JZw5+dGw+Yia9XmF+tE", + "oBeyf8CKi3gDZWuWOo/5QEXe67pEDpqdnWIDaOxHMhXGYo9qbDPhuNbgIXig8nVooPLnx4LaGg9/O/nw", + "4y/bBsSqvKkAbgsQE/MUrPoVtDpIhOHjdH0vSDImuKV+OqdSw24GLHGlmJslcgjCdZKifWPCfri+vmBW", + "88lExMy9KeyAnfA0DVWxji/OqPOFMG7KO6dR3vFbYMKyMcS8MMA+SnGr+cTSr7ywKuOhtw9+S+3NFqFc", + "T8g3/Om8tagVHfPKnfxa/RW06m0TbI7f963qu1Myf1fJk4DvLIEsV5ZUOz8z3iuEW61d0eAhoAW5HrKX", + "YKzSYHw5bFq8PGzZo6jaReR0JHWHDwG87+Z2SffHd4lIUiCQ09jysfLTOZPKl9XCjhjGv1BmkCaMO8C2", + "RiXJx0OPruMZgEcTPx525Scby9LVG0qWo5oldAcsfPzq8BUTk9p31K+jKo/e2vjuL2Cvy/08oxG+XOTK", + "ctvqQbxuP+BDlazV7pwd828BtaiqWb3ENLn2LbaoKgOBrBNUKH/9CgIMg3t3ncIhlwFbhe0RoxurZIHq", + "P6X8JK+Daac+hQbLaZzQJa4YsFbIqdkJOdgVjWIwh/rWHc6HW8GcSqKvIzbhKXaAB65NKIJYO21bl0V3", + "i010e3rR/z0FvZXL1Ettfz6n04Px/Q9c38OX+n4coRVtXf/AbqCsgOcvD1808fyOE6LXjMEVzr/2IbNu", + "3KEbJ6wb4EghhTiE1arc9oU8YrxSQWbcejpws9fpcY8vFdCndHCp7Iysr6TA6AIipnSgtUBeQfPY7ySr", + "1yRu3P+VssmL3d0Y/0Vhvxwl/u4p7ymNEg/fkIEvG1V69Tix2VB2aumK7WrqGRq5DOOS3JqVsavaAnlZ", + "IzblvnExJvaTLW15o3WmcEhUiF8bI6YSEgZyDqnKoVJa/bKG8ST4UF4evmr5fSJSeiTvSRWWD34Vn86M", + "335jKtIWpqJuJP1Xh4dOe5zzVCQEbt+/o51ax6kwlewkX/QzhWzQWrjEFwrZqM7pgdQagI3gyGm3jpmX", + "EI25Dl2QKnhTR9QYBkTfLe8ImpDHMeSIXoWtIL0e116TjAlbeUTvmWZjZZpwC5LYnRxXojqWkxgB62Kn", + "7rjNAIdqbSLpAXvD4xmbaJ5RigsWmlI6YyORHLHfDPzj082NTLjlR+y3AKS+wwj395sbOXISl6DjuyGV", + "bW5jMKafKamskiLGaIoctEFDfqyVMUss06fHv2acvePG9hGm/bNTsmdgv0avCbiBspLySIdobNBgiiyY", + "MOjYA3aqVU6bokhWQokpz01Q20ciGVGXNOyJ6C02IOaQ0G/CUL0mO+OSvWB8BjwJft/U7dUASPw0CoEd", + "d6AdKxFo/McTYFpHMZmAHrCTVOBXvsO71Ty+bZkNXchgIba43wF7i3lN1fFN0FGWrgxNoNWy1evCg8oB", + "A1PqDAC2B6Fdv0YfNRv9PxrylC/+B0/TEVU/aUyn0gRLVeMDxvFjj+HGAvetJ++Eu+8ZzzFFD1s6gwQt", + "YjZqcsIRda4Pmpe/PfDPJU+7P2LzNeqezfbc5wtsAumwjZodc5aouMhAulEju8hhRG1MS3Y+oq5tDueU", + "zsriV1VLQa/z/DNu6xQ/JqYWMYNKJe2HJm/tkowI1zzexlq4lw5lQz80VBBNk558v1KlmQGZsMMWeATw", + "htbC29JkxIxqEtacpwVlq2XgyExriLFiES3FLbnFBuya3wL2s48hwYUwaGdEeDMiwYstsWlhbJaKyzmG", + "xAur+ho8GlfLpcAltupERCInYp+mdBCaCYMlp6t66OS9roIeGkSwW4LpBSL+Lgg/YJdYuR9JmsWOn3DL", + "Xhy+fPUaB5TIzGucAPN7Cj3hMVCp74nQxhKxTzH/WHsuM+gs+0430h4nlqYPq9z+iEi7rST+uy2E0R8u", + "23X5BA6iV9jRvX/l6LHkAJsF/KdP/38AAAD//yfIAmm65AEA", } // GetSwagger returns the content of the embedded swagger specification file diff --git a/server/openapi.yaml b/server/openapi.yaml index 5ac232d6..abb0ed15 100644 --- a/server/openapi.yaml +++ b/server/openapi.yaml @@ -1724,7 +1724,7 @@ components: description: HTTP request/response metadata. control: $ref: "#/components/schemas/BrowserTelemetryCategoryConfig" - description: Agent-driven actions against the browser — computer-control calls, Playwright code execution, screenshots and clipboard access. + description: Agent-driven actions against the browser — computer-control calls, Playwright code execution, screenshots, clipboard access, and browser-control commands sent over the CDP proxy. platform: $ref: "#/components/schemas/BrowserTelemetryCategoryConfig" description: 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. @@ -2806,6 +2806,70 @@ components: truncated: type: boolean description: True if the data field was truncated due to size limits. + BrowserCdpCommandEventData: + type: object + description: Per-command payload for `cdp_command` events. + additionalProperties: false + required: [method] + properties: + method: + type: string + description: CDP method the client invoked (e.g. `Input.dispatchMouseEvent`, `Page.navigate`). + session_id: + type: string + description: CDP session the command was addressed to, when the client used a flattened session. Absent for browser-level commands. + event_type: + type: string + description: The command's `type` parameter for input dispatches (e.g. `mousePressed`, `keyDown`, `touchStart`). + x: + type: number + description: Viewport x coordinate, for commands that carry one. + y: + type: number + description: Viewport y coordinate, for commands that carry one. + button: + type: string + description: Mouse button named by the command (e.g. `left`, `right`, `middle`, `none`). + text_length: + type: integer + description: > + Number of characters the command submitted, for text and key + dispatches. The text itself is never captured — on a login page it + is the password. + key: + type: string + description: > + Named key for a non-character key press (e.g. `Enter`, `Tab`, + `ArrowDown`). Single-character keys are typed input and are never + captured; those are counted by `text_length` instead. + BrowserCdpCommandEvent: + type: object + description: > + A browser-control command a client sent over the CDP WebSocket proxy: + input gestures, navigation, dialog handling, file selection and + screenshots. Configuration commands and the DOM/Runtime traffic a client + library issues on the caller's behalf are not reported, and the phases + that duplicate a gesture (`mouseMoved`, `keyUp`, `char`) are dropped so + one action reads as one event. + required: [ts, type, category, source] + properties: + ts: + type: integer + format: int64 + description: Event timestamp in Unix microseconds. + type: + type: string + const: cdp_command + category: + type: string + const: control + source: + $ref: "#/components/schemas/BrowserEventSource" + data: + $ref: "#/components/schemas/BrowserCdpCommandEventData" + truncated: + type: boolean + description: True if the data field was truncated due to size limits. BrowserCdpConnectEvent: type: object description: An external client (e.g. customer SDK, Playwright, Puppeteer) connected to the CDP WebSocket proxy on this VM. @@ -3204,6 +3268,7 @@ components: - $ref: "#/components/schemas/BrowserMonitorInitFailedEvent" - $ref: "#/components/schemas/BrowserApiCallEvent" - $ref: "#/components/schemas/BrowserPlatformApiCallEvent" + - $ref: "#/components/schemas/BrowserCdpCommandEvent" - $ref: "#/components/schemas/BrowserCdpConnectEvent" - $ref: "#/components/schemas/BrowserCdpDisconnectEvent" - $ref: "#/components/schemas/BrowserLiveViewConnectEvent" @@ -3239,6 +3304,7 @@ components: monitor_init_failed: "#/components/schemas/BrowserMonitorInitFailedEvent" api_call: "#/components/schemas/BrowserApiCallEvent" platform_api_call: "#/components/schemas/BrowserPlatformApiCallEvent" + cdp_command: "#/components/schemas/BrowserCdpCommandEvent" cdp_connect: "#/components/schemas/BrowserCdpConnectEvent" cdp_disconnect: "#/components/schemas/BrowserCdpDisconnectEvent" live_view_connect: "#/components/schemas/BrowserLiveViewConnectEvent"