From 02ad34d548ec225c2daa338713df364e19cc7192 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 | 178 ++++ server/lib/devtoolsproxy/cdpcommand_test.go | 284 +++++++ server/lib/devtoolsproxy/proxy.go | 5 + server/lib/events/category_gen.go | 1 + server/lib/oapi/oapi.go | 881 +++++++++++--------- server/openapi.yaml | 68 +- 6 files changed, 1036 insertions(+), 381 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..94935bb9 --- /dev/null +++ b/server/lib/devtoolsproxy/cdpcommand.go @@ -0,0 +1,178 @@ +package devtoolsproxy + +import ( + "bytes" + "encoding/json" + "strings" + "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 = lookup(` + 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 say nothing the kept phases don't. A +// click arrives as mouseMoved, mousePressed, mouseReleased and a keystroke as +// rawKeyDown/keyDown, char, keyUp; press and release are worth having (a +// long-held button is visible in the gap), the rest is filler. mouseMoved also +// arrives in bulk from humanized cursor paths. +var skipEventTypes = lookup(`mouseMoved keyUp char`) + +// namedKeys are the KeyboardEvent.key values worth reading back: keys that +// command the page rather than type into it. This is an allowlist rather than a +// "more than one character" rule because key for typed input can itself be +// multi-rune — a decomposed "é" is two runes and is the letter someone typed, +// so a length rule would publish it. +var namedKeys = lookup(` + Enter Tab Escape Backspace Delete Insert + Home End PageUp PageDown ArrowUp ArrowDown ArrowLeft ArrowRight + Shift Control Alt Meta CapsLock NumLock ScrollLock + ContextMenu Pause PrintScreen + F1 F2 F3 F4 F5 F6 F7 F8 F9 F10 F11 F12 +`) + +// lookup builds a membership set from a whitespace-separated list, so the lists +// above read as lists. +func lookup(words string) map[string]struct{} { + out := make(map[string]struct{}) + for _, word := range strings.Fields(words) { + out[word] = struct{}{} + } + return out +} + +var methodKey = []byte(`"method"`) + +// cdpCommand is the subset of a CDP command frame this package reports. Params +// covers every allowlisted method with one shape rather than a type per method: +// the fields are the ones worth reporting, and a method that carries none of +// them reports its name alone. +type cdpCommand struct { + Method string `json:"method"` + SessionId string `json:"sessionId"` + Params cdpParams `json:"params"` +} + +type cdpParams 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"` +} + +// 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 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, + SessionId: nilIfEmpty(cmd.SessionId), + EventType: nilIfEmpty(cmd.Params.Type), + Button: nilIfEmpty(cmd.Params.Button), + X: cmd.Params.X, + Y: cmd.Params.Y, + } + if n := utf8.RuneCountInString(cmd.Params.Text); n > 0 { + data.TextLength = &n + } + if _, named := namedKeys[cmd.Params.Key]; named { + data.NamedKey = &cmd.Params.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 +} + +func nilIfEmpty(s string) *string { + if s == "" { + return nil + } + return &s +} + +// mayBeControlCommand rejects frames that cannot be a browser-control command +// without unmarshalling them, so the hot path — a large Runtime.callFunctionOn +// payload — costs a scan instead of a full parse. It checks every "method" the +// frame contains, not just the first: a client is free to serialize params (or +// a value that reads like the key) ahead of its own method, and a frame whose +// real method is a control method must not be dropped because something else +// matched first. Passing here only buys a parse; cdpCommandEvent decides. +func mayBeControlCommand(msg []byte) bool { + for off := 0; off < len(msg); { + i := bytes.Index(msg[off:], methodKey) + if i < 0 { + return false + } + off += i + len(methodKey) + rest := msg[off:] + open := bytes.IndexByte(rest, '"') + if open < 0 { + return false + } + // A colon is the only thing that may sit between the key and its value. + if !bytes.Contains(rest[:open], []byte(":")) { + continue + } + value := rest[open+1:] + end := bytes.IndexByte(value, '"') + if end < 0 { + return false + } + if _, ok := controlMethods[string(value[:end])]; ok { + return true + } + } + return false +} + +func publishCdpCommand(publish EventPublisher, msg []byte) { + if publish == nil { + return + } + if ev, ok := cdpCommandEvent(msg); ok { + publish(ev) + } +} diff --git a/server/lib/devtoolsproxy/cdpcommand_test.go b/server/lib/devtoolsproxy/cdpcommand_test.go new file mode 100644 index 00000000..9e555470 --- /dev/null +++ b/server/lib/devtoolsproxy/cdpcommand_test.go @@ -0,0 +1,284 @@ +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"), + NamedKey: 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: "a nested method ahead of the real one does not hide it", + frame: `{"id":17,"params":{"method":"Foo.bar","type":"mousePressed","x":4,"y":9},"method":"Input.dispatchMouseEvent"}`, + want: &oapi.BrowserCdpCommandEventData{ + Method: "Input.dispatchMouseEvent", + EventType: strPtr("mousePressed"), + X: float32Ptr(4), + Y: float32Ptr(9), + }, + }, + { + name: "a param value that looks like the method key does not hide it", + frame: `{"id":18,"params":{"text":"method"},"method":"Input.insertText"}`, + want: &oapi.BrowserCdpCommandEventData{ + Method: "Input.insertText", + TextLength: intPtr(6), + }, + }, + { + name: "a decomposed character is not mistaken for a named key", + frame: `{"id":19,"method":"Input.dispatchKeyEvent","params":{"type":"keyDown","key":"é"}}`, + want: &oapi.BrowserCdpCommandEventData{ + Method: "Input.dispatchKeyEvent", + EventType: strPtr("keyDown"), + }, + }, + { + 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) + } + } + + // Close and wait for cdp_disconnect rather than for a count: the disconnect + // is published after the pump has drained, so any event the upstream + // direction wrongly produced has already been recorded by the time the + // count is asserted. + _ = conn.Close(websocket.StatusNormalClosure, "bye") + if !waitForCondition(5*time.Second, func() bool { + for _, ev := range rp.snapshot() { + if ev.Type == "cdp_disconnect" { + return true + } + } + return false + }) { + t.Fatal("proxy never published cdp_disconnect") + } + + commands := commandEvents(rp.snapshot()) + if len(commands) != 2 { + t.Fatalf("cdp_command count = %d, want 2 (the two client gestures, none for the echoes or for Runtime.callFunctionOn)", len(commands)) + } +} + +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 e7fa54b5..47df9d79 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 ef7a89c2..4614fb1c 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 @@ -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 add nothing (`mouseMoved`, `keyUp`, `char`) are dropped, so a click reads as a press and a release rather than three frames. +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"` + + // Method CDP method the client invoked (e.g. `Input.dispatchMouseEvent`, `Page.navigate`). + Method string `json:"method"` + + // NamedKey Key that commands the page rather than typing into it (e.g. `Enter`, `Tab`, `ArrowDown`, `F5`). Keys that produce a character are never captured; those are counted by `text_length`. Distinct from `interaction_key.key`, which does report the character typed. + NamedKey *string `json:"named_key,omitempty"` + + // SessionId CDP session identifier the command was addressed to. Absent for browser-level commands. + SessionId *string `json:"session_id,omitempty"` + + // TextLength Number of characters the command submitted, for text and key dispatches. The submitted text itself is never captured. + 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"` @@ -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,384 +19465,394 @@ func (sh *strictHandler) StreamTelemetryEvents(w http.ResponseWriter, r *http.Re // Base64 encoded, gzipped, json marshaled Swagger object var swaggerSpec = []string{ - "H4sIAAAAAAAC/+y9i3IbOZYo+CtY7kSUNJOkZJerZ1qOGxsqSe7SlGVrJblqplu1JJgJkmhlAtkAkhKr", - "whP3I+4X3i/ZwDlAPkgkmaQkP+Y6YmLaJSae54nz/KMXyyyXggmje0d/9BTTuRSawX/8SJMr9o+CaXOm", - "lFT2T7EUhglj/0nzPOUxNVyKg79rKezfdDxjGbX/+ifFJr2j3v99UM1/gL/qA5zt48ePUS9hOlY8t5P0", - "juyCxK3Y+xj1TqSYpDz+VKv75ezS58IwJWj6iZb2y5FrpuZMEfdh1HsnzRtZiOQT7eOdNATW69nf3OeI", - "CiaencgsLwxTx7H93APK7iRJuP0TTS+VzJky3CLQhKaaLa9wTMZ2KiInJHbTEQrzaWIkYQ8sLgwj2k4u", - "DKdpuhj0ol5em/ePnhtg/9mc/b1KmGIJSbk2donVmQfkDP7BpSDayFwTKYiZMTLhShvC7M3YBblhmd50", - "j80LsfDKuDjHkS+inlnkrHfUo0rRBVyoYv8ouGJJ7+hv5Rl+K7+T478zxL4flbzXTB3n/ISm6dncAXz5", - "JmOapsTMqCGJ4nOm4RxjHBuRGRVJyhIyXsDf75gSLO3zjE6Z7tOcEw24dlTCoW9xS8nU31pELlO6uFd8", - "OjMklglzd8iliIiOFWNCz6TRhIqExCnPx5KqhNA4ZloPiN26xu1lVNApg238ckG40IbRhLCMGzLKU2om", - "UmVDmvOhPdFocCtWIB5Tw6ZSLey/mSgye4Nuu7Ub1EZxMbU3mFCzkQoCt3xqh1nMl4WKWccJYOQ1jvgY", - "9YwqhN1usgqyG1UwwidwEXaHZMJZmpB7qkk5iiQFs/iq+e+MpDzjRlt8dCccS5kyCqhmAvgPWyGGZ0wb", - "muWEC/JB8AeS8VhJzWIpEpjNXjg1vaMeF+ZPr6rpuTBsyoDz4F+q2/bgCVz3EmYb7SeMKriVd9oR308d", - "ALdgLZcWhS1J5HSRSpqQiVRkVKIVYXZevcpNLGqvXiUClOhinHFj4WIkGTkmUtHFiUzYKCIxzXOWEGrI", - "v73480syXhimScrvmF1ULYg0M6bsV6aw7AkvbkCO/cA5TS1maBIXxjIkSuIZVTS23HFs+TFVCyAzJhJt", - "oToaDAZ/K3Hmt9GAHI+1hb09c31Ne1AQETUkqpFJgT8OswAy/UrTtB+nMr4j/jvLUy3yIm9RdicZT1Ne", - "Qy23hiiyMSJSuYMhD5DEhZUGLCFKFoZ9p6v9RkTQzN4psjVkVvA3TbjR5Rb22GA6IKNLJS3bscx9FJHR", - "Db1j1yWLGu0HT69QggX3ZZHJ/U54YkXRhDNFJkpmLezUf53xJEnZPVUsuKg21BSB2/7p5uaSePWL4FfA", - "dQcB8lyiuNpBlu67XK8J6zVEaCnw2tD4bnWLJ6eX5KoQlr0M4JMbRWNGFMsVs8jHxRTu5t/pnF7DOBRR", - "2n5ricP+aEeDaBZIkAPyxjJBTQrNiF1B0MxOFEthfwbxrSjgsplRQbSgd2wYUw1cMgNlws57MlMyY+SU", - "zW+kTDW5VNLIWKbknitGkOGFJUuavlEWrTarE3CaCXwcEYuwKpPaoOrQUBqWGUxaZOIdUsTKIn9lSvbH", - "VLOE4IcEaYfcczPjqJykXATxIOpNCgHS+h3NAkysBgn/IZBQRCybyHKzcLwI+AYVUiwyWejyYx1EYbub", - "DqexnwXOgl+HT4O/nSdh3MP/rpFjcHeFSleHf7h6a49sz+55mJttwtMQoS5RWOOaa/vE5RpXEjXhHSK1", - "pmK4JMdWkDBH+UdSOmYpAAq2D0RlgAKRB1K9EDGJaaFZmN/lVDlNsoNWU/GB5buoUcxaPpKbeEavZTpn", - "V0wXqVmjx8KnRNtvCTXGYiZRjIJkoMTSGbc3IAsTy4wNuqmHOOtj1cOWc3zTFFs1RXfxQwDnUMGdPaPW", - "uA5A2yuQHvsaOmToRGv0Sfe1v5clRuaQfc5EIhWZ0Iyni4EVV0kRM6WJsDeeWpjmSs55wlRf5yzmEx4T", - "Q/Wd14GEkcTMuCaamSPChGEqV1wzMqeKU2G0ZXSKeeKKZZrSXDM/kHFF5kxpKxLGRXzHDNmbvyQHZP79", - "fgS6JhULy7SnREj7/puDKERWYy/3VFo5cmHcgSKSp5QL8v7kat9qsorlUhlU4Eagi7qHnUeTmSdQiwf+", - "zuYvm//5vUWKQglteGoxY8qYYdpYNcdOGSbubZVaUOqQ+WhDlbFEFeI5K6otWAuGbe+HdF4HHXyLz2i7", - "JOVpoTznHp1dXb2/Gp4cX96c/HQ8/PDu+v3bX45/fHs22i8VeymILvBpvY1aebN8DjJy04yO8MyKKGav", - "GFhtoek4ZfYHeOcPyMjtNPS1cIfa04yRUXUZdtcjy1pkYapxCU8Ak3B8XSOwAoWp7zS5p9yQcZFMmRmQ", - "ER1TkUjBktGR+4TEVMQsTVlCnBTM6ZQRQed8ChyR3tOFVcD7sGYT39yxLU/DI9lrxE32ol65WBClLN0F", - "nwkOylRrPrV3UtNNyPuc/qNgkVVsJwUKbl3kliqI5bG6r9iEKSZiFgbpPRtrbthwJnVAbP4kUSctb+F+", - "xhRz94kkb6UFXESydv6cmlngAUTNrPv85P8t7JvTKZPsIU6LJLjsii5R45U7PFaS/EQKweJW5UIQ9uBs", - "q3HKLSEhycWFNjJjilyf/lw3dEXksshzZhhT+/YNYufGxz88Mk4vya9sfC2BX+ZKPizQfsg1+eVi0NVs", - "ZSe1+wuh2jeFYlWhSPKhu7Xn1COS/JTreFt0SsoxLKnMAxsQhVxSjo8i+JpnGUs4NSxdkFyxmCWWika1", - "c4+8mVrbF4w2itHsSdBtG0145YK+KcFrcbZCjU+KtjtqvtVul5Tfxkna1d5dbYkVgnYyJ2ZMazplw1gW", - "IQrFV7ed25Kg+9hqoyldWAUBJG9gXcbBxJRwhX8L2ycUozr0Rv91tliekwkrAMkI2cQwTqW2ShR8hZyD", - "C2444DD+UWqrnRU5UvcwnlExBeUHTFu8yIhioJ+yBHUcpkF7t7o6SGngMkYqRhJ5L4iW9dViWaSJfQ84", - "GNMp5UKjTU6we+LXrW8BVLrRUfkbSbjVJJW/V5IXWY5KIJ5VCsMezLBU09yBvWnU/Q4UXKlye2aRc6vg", - "LbyVV88KY4+w39Tg6lfZi3rLN1X/E+wJTDFLO9pMiXU8Xka3EgPWEaQUWqYMfKytJg/npbM3Yj92irRU", - "xLK1YjozdSMqe4hZjkiFFtMz55JAcXMvrRAyXMQGkB55hkbxkvAJKJkGOaie0ZzpQWnGdesfX56fUASG", - "+8vAvVdomup9i1r2dapJyuYsjYi904hQNdX4VARj1BCMUdXc5bZvZsri4155tvKX+tQ4Z8oFi5whNHJH", - "GRYqDazj7Mb2TeFc4fbp4jQ1HEmoYoTCA2oLr6I9/6OF5TIWfJOV7bIS78oR7TOKyiBMrKRM0/eT3tHf", - "usPkBPlK72O0bOy3RBGg+DQtaZ2qaZHZmUksmYrxdYFn1QNyib4UIkW6sG8u4VDZUXsb4TbcD6vv1yWD", - "M9JXwDjVcEA0DPa191/FjwC9gLo7b3yJK4TlLLCZsBPA36IdhH7TiND0ni40uUWDzG3vUbcYdHes7uVt", - "zbvx+S6qYpAtPo8VXwdGZJiZYvfNPT7BxhrmKM+ot/c3RD2grVWTR5FR0VeMJsDpUUI5UdQIfimR5B6U", - "noTrPKULws2AvJHlryji9vZRyEW1KCBPoXUCpaXX/k1dTFeiLHJKGJvwB/TVw/6cAhERMDvc9j74kcCG", - "jshYyuy2Z0V/7bc9LqxgzLhm++RmkTP38QPhTuCVLrrbHkq2DTzTXugqa/xthTm+ldPOSksqp6iRVFpD", - "KqdReb9cTGT1X/dUiYgwEw/2B59BEvuDfZPDG+VwKqfPL4Ub8PiyZPBWonSNqGpVsu0cEcmp1vD4U7KY", - "zkghJjw14GQBdosBDQNnWB+BT0UWzhjZUJnck9wH1r0mNE1d+M+yxNRWVWZUESujBuSaoalK5ywuPcuT", - "Ik2JxYkgY3km3v4GGO8yeFahs9mkjACJOrC8Bhat7Mh95Dicf7oC0VVRlZ4lZlJwY19wwoqKNLW32vfS", - "01lMyLl3DqCwMlRNmYkwoATfN86TAU+9XMYzS933M+5CXHAnMo4LZd/bgQcNTBV0VFgow6/1aKaaDwY3", - "E9Z/JE2Yap01kTHCCr+rzR8Rq1CA64rReFY7XXAdQedDzf4RiBGTQhopnI2Ai9g+wsExWV0XBgzHXiWL", - "8DO7L5aUGzAy7wN61EcGL6ED93Tml9Z78eaZevSYozBcp2YtCt4HfhWc3+Omm6i2xJ42oBw5Q1d1Tu0P", - "Somh4/11K3q50IGyb2CE1VDWht4olrI5FehZnXGNqPwaHUv2gwkE55QwsbQAvyHpRKUFqfyWmXup7mrG", - "yPVMoQas+sU2j1yh4BrxVVcFtjSyKjlnglokzZihoB04yC0sNiOhO3uIgvBobxxEu88KubOwpuZjCWrO", - "Z+AcEP3kPM5tsmkE11vnXqWJCq46jDh3XCRtqoo/0ABMyd6cGYrUc2KsdKI45jogI4y2HNKcj47Iz/Af", - "5Pjy3NsL9yyfUXOGFmv8Y3/KBFOgbvmdkxF7MExYRBgdES7+jk4bt5/ytwEZpTKm6TDHmNLREdELbVhG", - "3B+IKoSwEKOpFFPNE9bYbtNmmeS9qFft3/7kF+pZ3lpbKKjpelRpR7aAkrIJH7w0Q2Sw3Arp4MDRyQGK", - "ivPTBrw9LSzRFgB/DcX8ZEz+E7OyQbcfwqhihWAgJHaGI0lGcwvde6oSCCrpc4cpdveWtcnClLEzKGTI", - "LzQtrMqjQPnxNmbU8si4MCSjCzJmhIoF+ffr9+9ARWpoPSuHgUwdTJA4SXl8t/GxVMCLyX7qNQkfBT7n", - "tEJC4HZVaOTm1xGvNvLYF1LwTN/eSa3vpNrVDwGyz/haaofNE7+ZNEtZbGQgpPfk+pr4X0lOzczb2OHs", - "lr+moGi1qBTTUKz7xVti6LQRj7s0mwVYkedMQag3MqofP9zcvH8XkeOInJ7/0qLDBJX5X7jm4B2wXM/l", - "0LUsHBGjwCEfnP4hNDe7h6ieh34spUq4oKZ5KnsWe4s5f2CpDlvyFmsmXuw+8RIePvTsSlEFbYTQ2mdS", - "DQV/ZouNDO+OLTAR7Ctgd/4835hdJ2Z3xxafhtU14PLEjM4eYuUCf2YLl4RVap8/OzzGu0UGdGa3GJEf", - "aXyncxrbV3uYC+3ATT3fA/v8DKIv4kKjHR4zjhaAMbliWrdwp+7cFiZfz23P311+uInIzdl/3BxfnbXz", - "3GV1kD2CwVzHSqbpNTMmZclGVqPha6Lxc8dw/LuJTkz1SS41r+X8QsQAF9Poy2ZPq7fxjVF1YlQI9aFD", - "jE/Ds1qA9cTcy7KnYUAJwdXJQ7/EdJdvhxHtlR/QfjVl2iJ9F7UE1lu0rrd46vWcPWYH/olrbVJHZejy", - "3kCEvF69QmAhdnJ/As9qupxEhu6tsdTiSZZaTlVDDClB5w7tNrR6w2tZ81s+Z1YN3RBlTVI+Z2TO2X0V", - "brYUOm3f8ZMi9bz7O01+ZeOrm5PShvOO3cn9AfnJfSdFungNvk7P0CdSwSwp05pg4u2nDoENXcc3ltzK", - "ki1WDC1WfILw7VbQbB8J6y33jTDYlbO0R8Ku8wy8LQll1T8wINcN430ZrKkjoiWhxCgqNJCXt3+PU56T", - "mAospmHupTeilrHlEDA+qrY02spY3uHCNwfNr3KHcNB8VxZRBc+HoDJerBz3c7CIb6Hy23OJTxIwvw5A", - "T84rvqDA+V250mssssB81LzCIhWYotLGFbf0yHVM97pAL/tpjXu08Jwbl4NTuyMjvafHUkUqtRmQG9AV", - "jVp4tukcAomSUJelEIan3rk/LPmxfV0qKLk0IDeKUQMeBC76uZJT+zz3NZUgYtkwsuf49ZAnKUR+TNkw", - "pQtZGP9G2SdUk0IolnIQAbiymTHRjYG5PT6We7Xd8Df21cq+PHbUZdozsq+1ENrEv5p41JbNcgV/L6MV", - "qoOBUy0GIhqWuSilQ7f0jvpfBnU/6NKozTe0OdPCXcW54OYN5elGZuB5G6bC2KfFmLksnJT/jvv91JS2", - "tPlvdLaRzizAhhO4sucnsxB4tiMybVjejpIZMzMJ2ewlHrp4JsNyNAXjUZ1NFuNtBpqZ48LIY2NoPOtg", - "k4VNbD7tlRdwncgpKFsbtKVYn0E8Etez0iLLHma00AbjJ9LqkYM2JKi+oQfknSSTQmHZp2Uhfc/T1Ang", - "MqnW0fbnIOHQrX2j4410XAL+kxFzK6CeRWw2ENuVnBhUfx06OrACFOnAYrgnAHLPFCPgoSnyMrzFlbCY", - "FGm6ADErla+51iTIuuQNrPiEwveKPVoVXzpVgGXQZR3kDBmBtwwmRXkPU5pDvA/q9ydNNRzK0mhmwJyy", - "FG7oLSpG0fjOzuZUFTJRTM+8kYJrkksuzGflM994zNY85pOyl8ewFk+rXY0CUE5x6flPDL1jQGW1dO/S", - "v9AkpS73u8IbQpvcfD9VPc5WQ2HOFJcJj2vlhb21w/t85y4ophsFVvM8EREuHeIbDW6kwbUgeGISDEFn", - "OwrMRSCC4keq2Z9e9ZmIZcIScvnuLx0RtLy28cKwjVq6XXvNGd+hhDpPUrYxMsJLM574yO2luAhKfjg8", - "zDT5R8GZcXSHNnUhCRf9SQplv11VWgi+7+htc0s/lt6W/ODfKGyVwupGxWekLYd3byVNuJiufRquImCK", - "o/wr1hWwOJ806oLY26apYjRZ2PtxuAeRT1ZzpPDMtW9gIUmuuFRk5M/uphjBHHVPMTf7ERkVKh1FZOTz", - "ouy/y3SmEeZcjRRzWdT2Aka1khGvySiAjJCJl1OFzQlILvMiBSyBJCJqSEw161pt4omIpRVE3+TTRupx", - "GPr8r9D1QHriOCEseLMJZnUC9COWUxshzGYaqNtcAx3WfgyHXr/zqVqQqlr7zZm0BDNHR2dXV8OT9+/e", - "nZ3cnL9/N7w6e/Ph+ux0+7Ltll0EyraDB8s/EaXiUy4oWKCW2Eir88quWuMS4YXdSQdX7tObRc5q5gBY", - "YSXtt57J4jJ+fxbyXmA4qiZcQC1FcurSLCPyhpl4FpH/+OkqIlghKCLXZpEyPWP2bXueQb2BC5ZwGpE3", - "0o65YQ/mxr5sI1Kj7qiqUReRCyr4BHZ4qdgE13hvZkwhm8yk6lAnu1GJvoYVUYWQa+ON3BX6tkNdpYwH", - "H5SvaEmWe372W9/1N8a7kfE6oD0/x12ByxPzWp8BvbEMS5kqDXpCs/6bu40g75lV2XMddlvPt/sY9dwy", - "lhJbOde5/2YAZXW4SKCxFCSlgkZT6OY2d2Zj2jGsnCroUpQrZgUw8hioWRC8Aa6HimFxvnXEAAY+x/21", - "268uUuwFRfwMYSpAV0xLYw7np6Ga+GLMdnJoLYFS7C9nNxG5fH9901J6X2oz9Bxl2WyMGx7LZAHSws5y", - "cPnhpnx3RfZwdE55Sscpa5FOeLQwCr5HiZdC+vSYTaSrT+RHARjgYKBz1y4brlEV7IkEcUQKwf9RsEY/", - "iMpz803oPl7oOjSOmlyp4iErDKGbPMa+NFsIZNfIRrGY8Xn18ntjN12zRpYfAvpboDg3AA6LwJUIWOkT", - "gdHx93nke+0Wvgn4DgIe7+tTSPhlyDyxiLfYGQSSg0QDjSt2CpXUJq5KGbk4vzjDKjxPL+W7SC+nhUgv", - "DdapHBnP2rhueQw/YXl4FIX2rAczk6URWW5R+e1B98XLlifqUOanaTEKBOeqlaR4/3NEymak+7uKwLKd", - "gCettbLukk7ZiaJ6tsa8mdMp+84qmSJhiqky5i3GcWSPCnLbO76PyLWg+f912/Oe/31yP8Pqi5VlxQ/m", - "RrN0Ym8BSlSnVryRK98/xemafgW3A6c1RbVA/3o5aF8XCNqbjhB7B76UyGhATnzao6v16Lc2stOPiOfB", - "ViAzYbXOpKtF007wWHm7DIlvsrZV1kIoscONZ5SzQYhs51lbU86qKkBT5/E+zL2G+J+2alXV+oQCHeHj", - "yLST/2Y+1V56yu5iAwBOZXaCpSveSpp0cMKcvr9oDPDVOu192wkHSTkjzAXKecfqnE9F58FDfSP49QSf", - "yGzoqpiA/+LZab8dSk/tt0jyYXlvAU6BYWOZrwhIMArG9c8VxEfAUOPKqa2QwMTeRwQNIQyfA4iX5THG", - "fe3ZlydADUox7g/IB83IyGgskXbfjMEJpNwstzpqnGyjJvIW0kO6VkLAZJKWSggv3LW4ZzewNEhWqvz9", - "hqk5g5pmfqYZn4DlqTIFzrkuKHRzHfOUm8WAnNF41hiA4XVoeXvRd6vaQ6tPx1S+BQ504yHN/KNn5h8O", - "my2ObC4vXWSFI84Gbu2dvL3ed6hd5oxeMgUXIGJGbnjGoOns8eX5pxViy8f7Jr+64Z69sE+Mec/iAHJx", - "kKsXebqUs9lAaCaMWqwEb+65bgaHIGYa7JjkTEGt5v1ghmf9VocJM5SnevuUVk9OtYsj1BjFx4VhegPl", - "wZFWaW9Gk6FisVVXuMgLsx6lG5fkSh7FLMHQBKinCJN4JwIEskWu6aAVVNzxh5O312GUB3UhkAVbX1fH", - "UnljD7yCLaz2rNIFN+HD2N9e74dF/wpOOmvTliWafbkm+HvVWaJxRWVF6ODriIcagweBV9F7CFs35xgv", - "Jx0tHdjtpcr27aAExflGcfHWPqO0IU7NmxQpuaTcPnPenlx+qfLCneubnNggJ+L8ucVDHRJPLBbSON+R", - "DTucrlAaMfqxbNhVRgpyH55U03v6f3tyWVXF5BPv1mitEj8MMxv78sJEhdV5O5UuEDJpZ5mn7y+I/SDA", - "NWvrtPXzEwlTLdu+gh+7bvy1E9jY2hddEq5KUZm/dcMzLqb94zSV9310yodLNfDfWXsNU6oYbdkQFoki", - "+h8FbcqDau5NMSr1GSGO1h6BSEXmPGHS/9RScv15hV59a5aHOTPc08s9WCiknO0s9DZLOkk3v/Krl/uy", - "IS/1wz+HCa/c+zdxtkGcSfrsD+0GLL5w4xzomBU6fy2muXdl5mg3iq23KXH9W5fpF/jFO9/Hfn9ATqhS", - "nEEDj7Ja/wQbXnIBXGsM9e4NcT0rXA8031ujbolb7irzabnD0m194xHreUQFrGfmFCG4bOfR202qC4/l", - "+MW2LYfesXuyvu0QoVrzqXB5QEASGzoP5VRZtbj9PJfwweqRoN1IMca/13rtvHYZRLiDQNch3VI1etuW", - "Qk/WOOjTelYrHDDyyZr3YJxjTfOqsKgzKaz3t/i+y+AIbnHElb2LlgzsZEbnjIylmaGcK+OIdBN3Gi6X", - "0gPNNalNj54Y6GUCEcHkXCQst9owdjWoJwa+JpRoLqYpI/YLrGyAsVGJZNhNcgyykptPGePxzU2zrTz4", - "RK6aGzp+nzOxxuko2H2p4Bg6to9Dx08gUAIGo27jyhX5BM4biX8A3Ae8xnF6HwODtQ9Op416XVxXKaCu", - "mrDdgu+fp2Wj4OemdE+nLzUTPWuKU0kVgH5WrwwlgQ7IiRS6yJiy71DMcV3S06ABlW86NIO6SAaKBXJj", - "dTUKlnxO060SRp9KK2tC+ZtStp4IDR0PEa8/KfHtoJPBLsOa001bhJWlYchIcqQLxCAFw7wTsdhWyQiH", - "c3l5J9h9uiiXouNn0TwMN2nA/IN5TqnjPfabUisFhhLeTFCN8VPVTGftczxZFFhKjcXh45yf0DRt5dCW", - "6SBIMyrABFmPO/3lgiiKpdVmVJBE8blXNtwnEZlRkdSSgbGBXR/tmX2ac1eT+QhKzChgfymfsHgRpyyC", - "RuOuZx6oQ+71jptxTZbKqm72i1pr6QmfOv/QgNzMmAaDJ8mkNumC5O4C+lwkRVyWxcuVhN7mms5ZRBSD", - "dt+utcd+47B0ajkFdmzQnZmuW/WxjLcOtm8st53luuse0pwPLSo/I9O9ZmrO441x34i5CWA9jxlhD9xA", - "fWD2kEPFp3RhtXD7DgA+7frMIHZa9KJGqn6V8alnhUnkvdgniQRlw3XJrCsi//t//i8Mz65WgXU1hngz", - "lbksDjAq9ad8zvpF7orEY8vXRHZFcaTWxyJ44Da/4Xkrnjtk+gTh221w2b7eOey1We186RhloXNy9sAN", - "JIgAwmo+tehqmTl09XiwynUpYAqRMJVCH9ymtFBlic94RoVgKSj8QBeY9YAEiYqGWURoVPaiiOQzqlkV", - "R17GShAu8D2wB4/5Mrt2H52q56ewUeWSMEJUBDOHSql3WHpARkC0RT4iGaMC5bM/eMLtveBLiEMKk7Jv", - "DHj/UDJjNDWzRdmEFkobDsjI/befkJJcsTmXhU4X5ZjGCk3mNZrSORuGN+QhURaQdFHwaI0va1YClA1W", - "TjfKwvI1EVUd1zZEwXquE14Pt/FgxTLoWmbMzGpFGXVprChpCa+zF/XcPfSinjtRkKnlQTPf+elK1gFe", - "wYAcj6sE6dDd2MVIka8WuQ1eE7dPTJJKYYeWJScpdsq4PD9tSalyFyho0Lep5FTRrNlU0x3D36fr/gzV", - "uHmR2QdyVhjDlP3XipI36lJauL6nyFHFOlYEgua9zH7mrQrszYyRt1wUD07vJO/fX/TveJpCNWCQe1DJ", - "rMqgEmUX5l8uBuTata6GIInRQcLmB3eZno68lcGiGRUVOcDUS7quFxoZy6RalABFA52PNHMerzIfRBdj", - "Nyeo3NSU7E4Xub0o3T2R6okk8sp1fxPI7QIZLmsoZTa0KPGcAjkMlu3lsd3nkjhuHqK970gshTaK8hAF", - "/jpr0gKLeYLWN0+KAzISUjAvLqapHNN0lVpek1HGsrgmluKpkkXuvwToA3bMuHlNRnFeaGZG5ADGSbUY", - "5jLl8QLNde8+XBwf4B/69tnKBNBuxZ6lcFvWRKaJf/T9MDh0HueEJ2VPMdeuThUxpkKOpMzgaEcjknLB", - "mgLGHhZyS7PYyhbcJ/6h2mVLB/dsOFGMDe/GgX5wijHfXt5dCRfkZ/6j76dXDz+ym4tIwhRUVChDwEZ2", - "9qN3I0dqXNRA950mFyzrn4uJJEmR5QNyrHWRMQuJV7AOFvfiv7MBOfWmT5+jrFicUp5BR5LYKiC+E5XO", - "aJo6zz5kkVCSUjVlALWhkYamw7vxCPqpaGNx1IIfbxwPa0FulwLFj8yoSrCzKVTJdtB0bMQjYR12FCvI", - "wM7KA2pX1Lbewb1G7vWtBRiX/eXRoHgH96nJ1fEFYtEjwPE8t7BJ83HC0Cs+4TnwxxZF5ERmWXg2AlFb", - "LrG5KW73MvpAXvxgtXylo5qsaHzWUkBA6yBIr5iGdwHRzKCwCe/KgXlPF7BvKqToK63RjoX/At12lrHM", - "/uf+gNxYLdXVGMpnC83jivvV1UOL5oUG5S6MRG3NI/OhofpOh/A0J5WSMYZC8HDKvmamD6d0S2Uyq7U5", - "R4zVePd2SvQGLmlLDVQd3dgt4AtjRJyv8SzLzWIdUjqTsv32hMJjgBryAwTUcasWSTKWBThJUWoBsgOy", - "csMyvYtiY/cJFE4fznGOH8pbpUrRBSotfDplariJANx3tadoF1J0vU9FYjnZ6OTywxF5ZzV5+z+WII5G", - "roJNTbYE4O732JnASkSbSc0ITVOJ9TZKL2+teJfbt5GEi7m8Q4W50q0H5P3EuOcNeKWpJqP6TkZkrzaN", - "I6JaLQym9iEsKaaCJHwyYarevhoGxbhN97O90zmPDc8G5KIL/Tfura2Mcv3ukN+VLKKrSgYItZ02dly6", - "2R1EMIJ0E1WBFFjRzbrD/TF8cxMlrJUB3ZluU4qucqUOTW0RiA6im2FZcwat807Vi9igS8g+2ZwpFjG7", - "rB/TcMBGvTGN76wiK5Kh+4t/CN9LdceU/cOMKpZU/w3V7YIaot+1d4mc4FOCM30C/pBd7HS+gkflZ3H+", - "EEgS5mKKz2DveGl9JNDcxLOur83lEyzc/j9G9Q6bTzGXlil7komMkunjJ6r3f3/0ZL5q2aMnAsx8/Cze", - "+/XomWqtAB4/F5pHHjnPxzU8pGXMdrR4UndoouHJy4k6ZeIKgYwdLL4TeqAz59TkulGux1F5MiDngtSr", - "SLqu6S6gRuamz8URkRk3LtSMa/eA3HOe+vuZhHcfTr5PUkbnvg2oX1FOJu5JaNdyi2vCHmhsnIk+LrkZ", - "iAQjsaIk7O/45uSnWp3Ltt1oF7kGjY6t+onQIqM/Po72IT6ICNmX+evm5hQzlAsosETA9m6lEprLb6Qr", - "bESkIgnX2He5GjrnFHcXkYUsSFZgdeEEtvCQpzzmhozsQUZ2hhEAf9RQT0o7Vick2wW5qvalcQDNHGsf", - "kOtVwA/Ie6+0eglwxxblXS9f9L6FmpcfYNljE1qkIOOPCJTrv2dQtB99nc4HCh4f7bJmZRrVekBF7qUd", - "ESdh9gfkV8znHbkdjaLKzVPDIQsOi0eONI4Am8A65FH/NaFigf4C6SI27cEnEwgowGZU1Xx7TppEPmwS", - "+7NGpMbT9yMyqpjXCAPJPF9E05ScTKzK5S8GKqxZpBkze+Xg9TFyQI6r4zmg+SocuGF3KhKnjCqkNROG", - "Mh5m5Nqs1Gp27WG3rRT7+zvfzz66HEw1h0X4GVPsNeRLp/JeE1oYmVHjYtas6g6+J1q/siaTCdiy3fF2", - "5MyVzvMx6rGHXKqtZcUZjNqGwzdGbEeCb6S6pxj/IiflvdRgZiSyDMOUpYmEaQO1Ci0Al8J2odZy7XaP", - "CF6Aw15SiBTeFY79pIsSWywcI9Dh8MGFTMoOra0HUzvoO/mAXHtvUkADujylMdu3gz3ZuEkwPthllLi/", - "GYm8v/5Y9MNq1GUKJeyHr+0rwLHU+grI4+uSxfNp1FJJIeIZFdMwrkmT5tuix/ubt5fbo8jKqO3QxA4/", - "gKKH7vq8Er6DyA8gGQdl3iJiFSJbgZrY1ZuY977BrQbkJ7DGEjaZWLG65zdp6EITLiwTnEMJQybgs024", - "1VkMnjhHpFeT2JlSUm1Lg1hiEZ/aY2hWnhDv4qy2BQE1zrKtnT8AffTY+mMVFBnT2qnQq2/nsPu/XG2I", - "U2c019iJDbzAB1VknPNjHFjWIDSX4sBFsR0kXEMAmxVGr8tcCTchlDi3ao1LIbAYTw13JZnqHZebO4Hn", - "c32m4Es03K32fe4kenWXy/1pBw1fvMyH/v6xDKcy9T+4ZtBwAfaqLad3l2D/w53ff8iLbDhJ6VQjfOwV", - "bfbM+TN7EIaMBScpj+8uZKGZq8G+ZaztuDAmVPQFpiT4KxrbUJEASV+7p5RNTC/qKas42a3yJEm9bQEd", - "mJaig3CK7dZbKtfeOKsGfONCHWurJvLe/ifESsAnwQVmMk2Gd2yhQ8dLMKLX/mzPZ7+t9+DEWWvm3NXw", - "3iXTrCiyIYxyywFX6h29WKb0d5C/CSYbnjFHWDlzliW/7qqt6mH1FP9BYgmBq7Sqd4A3lksMnwvOFKgC", - "/Z+7zLSErg89O3ULkuZjSVXiikFsW3UzWH73xAnZ2E+OtXddJtPm+GU7aXCz2G9VHZeWkF0MqLGbxeGu", - "hTJ7YHFhQMnIqXL9HIDVOzUYe3ehNoEPXcfib0U1S47Z/+jNQRmpsAgx9iiD0fYS4NVoP3Bjc6poxgxT", - "enArztzbVorydxzZKEoNtkX/AsiVnPOkJfYDSDmzPGOTKrPKsD5GvUTRabfhp4pOl0dncs66jb6Qc7Y8", - "Gjy2lk1sGnxpP/yZLWpjdaxkutH0dg1f1YcxM4wLpeXGF8Y1MyfwYX10ythGjfHafuRQuBYlshqj5O3H", - "KxjWkMM1+DbuG2f2/ZGqqyyvpgHbxsn9QUKcu5p0wzGtnLhhD6a8nmUqD3eHiHonilHDTqFBiFSL3YRn", - "JhO2RtNI/OzEfkj2ZAzeeThlRCCK7V9/+GF/QE5RWIAs+NcffgAljhr72uod9f6/vx32//W3P76PXn38", - "p3Dir5kFwr3HWqaW21SbsB+CDQSOvrTIweCfNzul7EqhyzxlKTPskprZbve44Qh+4wks8/Qbv/LpH7vt", - "PuSAOl9JUKpyTHxKYHmiCEUCVuCX5KD89AC0zgE5TvMZFUXGFI+JVGS2yGdMDMiv9i3jXqFRw6a1uhrX", - "brVkGb1o//fj/l8P+3/u//Yv/9StJM4parcdn5FLdfTAyNYuz/3LAb+rKgK1FD+C1uZDRQ3bPKX7miho", - "pC7IT7+TvYwurHQTRZoSPgHzUsIMi8H7vx9c9J4nIXxdXg0+W7v/4NUuC7jn0ectV27R5UsdHpX6YPAm", - "s2+bupp7uKwJndpPVgpDjpm5Z0z4jVg93oVcU4VGc0mseCE0lWXuuIFqHxkXPLMbPQzBZG2vcZc1CHFT", - "xH+5sjef3GcpVzG8IbuXrIyZ1pmUZvY/0PQPxmewUnuLo1Xo7RnGVLueB7AgsK+Uiak7B33Ac7w4PDw8", - "rJ3rh+DBHvOIsUfY6g0TZsTvFZSoIinXoLX+7SEii9/qL4accqVL2PkuItiSwW5iCkE6F1aTdKopoYak", - "jGpDXpJccue3LXe6vOV6BFwZH/MSLq/6j+XTrP0RYdnAYQvXZTT+oBmZFRkV/ZTfMfIj+51DeV81ZxU2", - "A4Tv6QIPQrjQhlHoVZNywajC13MuU2e5Ar4Nq4ENQg9zpoaaTQHTkBxYPgQiG2YaTPN8KmSzTFgtxLjx", - "eeNIP2xJl2XdItjXCgTPcRer1LCRPlfO2XwkH7a/ksstAW7hvqCGrLsvF5sIbKJ9g+QCt0deNPb6YnPU", - "RpvuUFr5utrbliZeZ9U5w6fiZUoX98CFuwqDcFu+2uOzmhKymgIB1UmLOQa7+hz8O51T/CemRVVz4ysW", - "/jijmtAYYnuMJN9Bv5eIfOeKC3yHj9fvnJflOzKniltx616mWZ6yI3Lbo/eUG+yZMZVG7n03MybXRwcH", - "DL8ZxDL7bv81UQws9LXPIS16b//1bS8Ua4X17LCuSdzAwz+t4OEFcmt3RlDbeFavBFZq71bD+tNhg8N/", - "3+Dvm3ENLr8jPmjY8Jbo4PtILmFBdbpVS77H8qUEBmiE7FDY6k3V/bge1OFuVW7Tq89QDMNGSFaBX7C5", - "Pczg30c2kjAV2M+1j1rEDs1lwFr9YAFDcSJDdZzLyWRh8sJ0na0AhF8X5sDqt80S4oZAu8Cws6GRpeQW", - "CCHIG56yczGRq/yI62HC1fpdgfyCCITytdjSX1S21ke1ojwDhcTFbvqydWUOS0IN67vyyasJBkG+Y4+F", - "j+cxNy4VOSK3vUTdP6i+/b/bnn0Q3fb66r6v+vb/bnvhQMFwOOKPVLNGthnk4EM8xepNdH50e511FUn4", - "72w4XhgWwJNrF2cIPw9cKVa/Dc50hxBDHy5KQa+vLRZ5PKjB0F16GzphLGlLdtubqjgCujbbOlZ3QT8K", - "Hjtoj9QRD3eFZbnUrkDdDkvCVjeX/LXIWd3EdnJ1dnxz1ot6v16dw/+enr09g39cnb07vjjrkMiFOVyt", - "Cgt08FsJGwjD95Tb//JJioVw5f/Likml19alv/o2LY5v/4yB0pCFWeUZ0DJTiabE0AcpZLY4gixGrBbg", - "2sRVs2ujGM1cXPgI+r6B/06qDDQLKUpYgw5htzJmqbwne2hAxy2hZd0FWY3a72EUEcWmVCUQowDRDJLk", - "xTjlkIDKzYCc0DRlql/90V0AxFq9v74hB+XuD9xPPn2yzFXz/m2u8WZfE80YGS3tpXyPQodmPaM5G5Bf", - "aMqTshtDDJvxSQia0Cm1bw+c2l+wz/CIXa0naP0HTQu9wxV0pKSCOAr8jOa5RTOrY/gaFt1Lg0AyIQRF", - "DbVM52zohf/aGU5wyLUdgdpKOVmSD13k1aY5kvwEP6yPtcfrOvy0/LacAcOrhk4bWj8Bfgsa0vL4VE67", - "jX4rp35sLYQL/YsbZjivvgdfS2ge8HZ0neVntgjNgQb+sqBb5+nQG9IoUhj1Uj5nwzln9x2B/JbP2S+c", - "3S9BupqmM7z9TKtAd1Fptak2HvMCh5zWRizPxgU3Q6cjd5rsXHDzBr5fnkoxt8pW8135URsm3Xq+1bnq", - "sdJdprouv/cz1atAdmtwfZ6kbHm05Y5cTLtdk5vnLY5pXtJSZ96uLbfh49U5XGfp7ft296Jmz8ztOpH6", - "0YEGfDu2OvQzLrXj6txzqskLVrsrbd+8qpwmzrdoZVKOkjTZpma8H1ere7x1TenVOba4x5bir9FK5b9t", - "iyr2okAlqw2ThOq7RSuFgrYuwtSLVmobbFs2wqX92ufJ4h08IVBL/hj1pGDdS8wvC+mP0TbDappBx4Eh", - "RrLt0Dr72G5sgBNuN0HFkjuOC5HHFkPDPGqLCSrC3mLQEuFsMbKB5dtsc5npbTPWs7zt16tzmJ0AussM", - "Ya12+8GlMrv90IDi2nGSFvVmu9GrSuV241f0tB2H78AHWjTZjqMbgqQrwoWEUFc2vfSA7D5s+Q3RcWTw", - "MbPl2B2XbntwdxweFLG7VlnEHiVvuTZgXQxY4pSiCyInAbseF2hmhv4gWKRh0LUYQ2k7DzjESxEfqKeZ", - "yulyfjzN89TZv9dG4i/3FpuWrhTDHkxrL6iWnjU3PHMdFcsdYcdJzAHvaoRv8U/Wlw6ZFS+oVS8+VwRV", - "RtXdE8ZP2emYAkNhUstDaQ2r2jKWqs1y/a5mtMYtRAQqXlC03V1cviLxjOYGermZlDk341uIKukdvXSO", - "Rv/fLzYBF7bRAZqdvIxdyj7UT4i3yBJ31CC6y8lEMxOM5rlUcs41hljiZ82rq8ixBi6LCNFy2ENEMkY1", - "pBdVplPmGjSBnxeqTyvXgwn827QwM6m4wZgEt743sToQ4QT3yiIWRLpMuKAp/511qukW9ulUFxIEmyw0", - "u3Sh+lelZWHZGdg1h8BH6O6eO9A2Q+ecgZVQ7e2w8AnjwSB2+ZGRYAnXhoqYNcIDfnju+C+7563ivx4f", - "FOV8eFUElP0nFWbpFsNuvU3oWQWYeQwjRu6Epl1n2gpddw+ATpg2w02B3LVMRe9f3hQHHfW0ijdNjJUe", - "O8+5HJXgF4hqpwjd0Pu7Ol/aImzlL9iDhLz/2Tuu2KpyJe82Yu059iRi2sddDDbHXMi74FkuqYlnLgh6", - "N4i3RUGftkc/l4zi5avD7WOhT1tjoAfkfFJpQYV2ScwzPp0xbaqy0jjEc0XFAH2cDuS82H86jL4/jF7+", - "EL04/C28RbhaZ87fBK+Ji5FUbGJ5B2ag8t8ZsmAoMzzn7N5qdJXK5xonWA0OMn7DnMalslYJnav6Z7U6", - "inOf5uuqI1fn9xEQRhImrDYBzXESmmNCh2D3vjRlFSgGOAF3OWM0mRRphCUg/F/SFvRsDT4/bQ06L9Hm", - "+5eH3ULQlxOddpO8G8LDvdT1YgvrfC00xoQv96ytoagF92GE31LFiIH6fJsjUNcI0jJjJ9skUe/YAkt8", - "Em0vx0n07gI2vP5bF1htZ9eLbCxTWBwWGpAzGs+IXcJ3YBozQmvfEl3kVTnKh0QaKdNbsacZI//x4gWc", - "ZZHZNwz0bpBC7w+IC7PUZZnU294VBN/d9iJy2wOjIv7zxKgU/3Wcuj+9+eG2N7jF4GqMv+Uao8Nj2CBN", - "tbS7jGU2diJLu4QnnO9fjI/bgv+C1f7lho5h2i0udIlbw+0G+TUWgTt7YPGTRdJSe7wMorUXwvIRAXXq", - "V0UTVdNmUPbffosCRfHsTFRNi7I1dXesonqopGyGVIePUTQLv0PZFjuU5IrPecqmrIXtUD0sXEWU9VP6", - "Dq72azuVKFKQHp7Hr6aB49kDcVJw0b6+kZ6xNC2v3MqCItwIM74P1Z2QCqrTVxajPVqP69p3M7pIGVwE", - "O5svH2CzzsXEvB29/ghl0ziY/fFxGWBnYs6VFPDwKKOkoey460AXLnFYYf5KpPN2wc3tAGyPYUZwbiTD", - "RwUw0zrRlQArz7FKhGvfg2fl+dseg+HykeyBm2E4Yv7SF9D0/UNauiFAPPNw/KdX4XDGP73qM2GHJwQ/", - "JeNiMmmxmWA8c9fJZGHaJ/vYDr2feZXLvB34rrF7CmCvKG1rNextggxLbzWYWu/m7Oqit37eelCl+/zn", - "87dve1Hv/N1NL+r99OFycyylW3sNEl+BKrqrNMESx+Ty5j/7YxrfNWtVL2dkpDrcQrhsnxTLtMiwH++6", - "bIOop+T9prnsJ1umyMCsEW50zY1d5/Re1C+sU1f3gOheberuSgazoTGLzVLw2H1NKMk1KxLZL0+/d3nz", - "n/vLjBU1exBEZQDcnKFEahGXYaD5fnvLgHMFr2qHAIvicmLVFiBdWcl+tvsyH4Pt5Jtw3YGfn9e8NnRs", - "GRIl2s62jh6CBX/fX5fAams840sqh4ZfQyPAftl0O9Dysbaf0oJbFDwJM2LokD+kJuyswaYfK2143LAt", - "/DWtpGaoKfS2ZT5r1SULjVK2nSvlxTCPQ/2lteEZRI2fXH4gBTi1cqZiJgyd1qWggAy/DWK0ar/FmyWj", - "Z1S7BnZddBTsm9CSd1Ht2Feh90XwcfdlSkaLBA+aWy4rmJpGnH/V2gm3H5ZF7YBNuNhN6JxSQy0nu1cc", - "DaBLqIcpT1zkRSCNI6GGdlIskvoqmzsvlfP+tvHMj9IX7XZcerm2062e0Hlr2pCkykeFD7xzZ9DralJx", - "R1GMVjk12+hO12dlswHFcsW05VC1TnMuV02qWuO4toLY20GzdKdVyGJPEVRBWdhZ/ra5pZXkF0sKwUID", - "nVhDyUhxcq7JLQy87bWRrN1/QAqgIdwlncha/6d4Voi7Znk4SB0sExI7EjFmjQD8H2eHGMtkgR3IcUpf", - "WBgvQDjqXk6kGaxt2hXKUiqrOpPSRgZ2imTOtVSLI1em907Ie7+6K2PlGxsyRVCsLhVdbvhRU+ygi0nu", - "ulY5eUDOsXQo9BDVrl5gIXDBuNDG4uYiZzqyaIC2VygviDym2f/I11yvypNHvhZ+vfh5VVO9Vji8Uf29", - "LN3dqAdeprxUIfBrW5+1FULGe3TUPnh0n7MNSWg1ZadD1+e2ekoYM8BUOAl1wgVkS3XRiCqnvR/Vpg9t", - "NC2hqrf6Z11GONR+b9RT6Ky/LYUY7LzZpXsGvbK+z9CdV/GEV2zapVZdNxfUT64Ktg/WmDp7yJoyPC1O", - "iV/BGbHNRB0DFHCu7+zLLO+nbGIFgRLsUSELW8wZ9Ar7W4j8xW4C2S7OFVUCekPBuSZiBKVRsyzdtg7r", - "1NDhw3ofz09S8d+lgKJnsBahmSyEGRCMVLFvaPi7JlCLICKCTWnj7xYOYSGOO9hQhOgXu+O4w/qJvBeB", - "5Ys8vPhjgjLKwnjd7fubqIIaVwq4qt7XXGp7oth6ys6REislDbfkWjxJmNhQZQEjOip3mRu00d3vvmvZ", - "9hueskumMg6hf3q3/UPnyLANDptKYgK7In9pGDK2rZQQqDX4p1ev9rcrLSjvRcjlY/cKP4GTx+/3Q8t+", - "u2TVY4J3Xt0tenbRiehKp+9Y9m9NlYN6jcwtuxPRQrN6zRPsiZKz2NJ+UroRtvRD1J3iUBwz5IaoV5dp", - "xI8dbiTK+uLBC7EqzBv9KzXxk1ZyLMtsgmUAKt6G68NYwuVzttmEW1K7m4+UY9NFh7Ce1iAluIFHRjNP", - "FM1YOAjnqtJt/UcWxJPcUuycKcUTpv2zyd3Afh3mLw832YOD1lH/dluxa8JTaSmm2YUe2zckxknyWgkc", - "aABWC7EmTCSu7NmeNjKPXES2Faj2+RK5qpP7+G5MU3lvR2VFangOdZKF75ZQzqmfrOJlzaK6VZR2Rh88", - "LZ6La6S9dvdptXTdfejDSNcDdi0sM/oAlVj47+xcXPzYvgNIiPB96i5+7IhMywUIX7SEldnTHRcJl5vp", - "8sT116H2cyziCF3N5zxhckCukAZ13TpgVSQ6Z4QKN8rFI1p8uSxSzY7dX+M7ZuodIaCPI5QYIdDUYyzN", - "rNYQYt9hC4ZaNcPBucYd9aVo5RcB3iDzx7IGqWJm59l8k+dZxhJODUsXxBIWxGrIwpCpojGbFCnRs8JY", - "MnMFVjII7gODJ7QpiaVSBXTtgaMCjoSdVY9Iv0CS/zTla+1a+ZOUr60qrYg5S2W+bUTqDVQJxaGkdBoZ", - "aCpdK+lFlqrEBPqkeHPp2hrXzVo9UD/8H60eh34mhTRS8LgMUSPoaql2SmMlNRJhyies3s4XiXJAPmjX", - "FPst1aYPK/fPT10MZuHyja6vz7y11AkIrrGaJ9rdVlIdtnAq2zN6e/Jva2HYlp+1VKQI0zfuuWL9lM1Z", - "6sxsUFgHihXmtQJGDnKldANu5IscuTJF1ekH5FiNuVFU+VpDTvPW2GULCxdVZXosg0xwsgF5s9LBcl01", - "pShUBgl2zFQfzHmINiSRMYSSsbKZ+sjZB//Z1Rc6WPrLKcxbCxOMyGoRpWD1/65G5K/FFFtB89+v378r", - "LbEhUKVcuyteX1cKy+yh/2YZdM0ODiGgIEzt3T/WGOxb64Z84MYjnJPMpV8F3UDQH+Ke6lp/XmPFikua", - "stpHyjPektthAgrUB8EfSJldiI8dy5qWKmtWF+U0RWBY9zXp0Smv6lOZwkvYX3vX8A5O+LaGeavRpXme", - "8hZb9a80TfsxND7z2WzOqFO7zGbbRQtfNyUmNhlfTbfRqaveha97xELkGjpt3Vev6pi6m+Rzwi2l2qwI", - "ZXIqGR4ImsN54di8FjRC6MFaoXbYITgSDoLnCOLOUj+Lra2yjyvLfscW2ih5x3SwlHIwXChc7nmnRDIf", - "4VrtwyfS1RLKLCd6gPb/KV0MbkWDSaiCkT3fyi/zKYQHiS+qvz8g19i/tczAuBUuZN6yALsWqD1UEOlf", - "zbX1GjdF9uBv/+PQ3ovLc9sf3IpaeW9oSWRvbZGjlLiXKulbXpmgU9nFYJcn58Io2rdf4YL6VlgVQlCs", - "mgiyEX/OaaEtnG5Ab7Z7Qw5t97IGdMG2dlFLjyWLinCv0CQGhcFMQpw/tjdqqXoph5ZgYrYeF6HH94xa", - "WW/fgYtcEi7+7tq8KmrYa5JxbegdQ50J5CSoI3BnYxrf6ZzGrEICcjgg70W6cCxMh26A7GmeMmHSReOe", - "bkX1GeDGPl5V+Vo+HLwIYr2PY+raX+pXxQ0rO2LtRujrodWI8PFVWv2CuzbG+ggdwtG5CynovaOeU0zP", - "rWKqyfHleS/qzZnSuJ3DwYvBIZiRcyZozntHve8Hh4PvXY1SOMiBT8A6wO54aEKMAzbEC6amDJKp4EtE", - "AfbANUTBSMF0RIrcCh+yNGkghWvO7UstZwrCGJIIiQzqhxfC8BRurvz6lM1vpEw1ue2Buie4mN72oNpC", - "ygW0M5Rj0JkSMmYTqXwha3jAulxDQKays/B5AlZkE8/8Km9cd0BXWu5HmSww+rfqmFYVlzj4u0abNUrM", - "gMPd3+aSduGPhHdoJMngWl1h5b/d9vr9Oy71Heb59Puuq3R/mhe3vd/2d0/NwQ2F0ar6ztInZudBmies", - "8/LwMODugP0jvBN4ZJVHc8BeLq/9Meq9wplCmke54sGP1NMkFvj/GPV+6DIOCgUJmrpRUBA8y6h9FfU+", - "IF6WW0xpIeKZA4LdvNtzL+o99Es9q1+9q6q3j524wu+y++Qmuik0U33fwa3aCIO+FIprRrCTJ6kMh2UU", - "0ZiWPw8s3kW3YiNBke3p6VZsS1AnTEErEX8LJKOCTvG1eufezGKiqK867PCcnPlGndeugW10K3IlHxZ9", - "6DXBknJGPEc5v0dUMJ6fnF4e+IR/KfZBQkGTYZbcCjCH+LvcSPuXVRPRXck/LDxCOlcX4A/Izz690v0k", - "aMb0rdhzSXxO3p5IeceZdvd420MrP9Tydy68WTkD/nVwK64ZI76TA3ZRrXYymEo5TVmJ2AfoWitTkP3f", - "XVwXJjHa8/9INY+PCzN7P2fqJ2PyM9+CGO8guGGwQ9mP9Yd8qmjCdDnKid0L+nBS2hr0JVOXFk96R9+/", - "jHqXMi9yfZym8p4lb6T6oFINTuTVLhW93z4+FefzuPLVMr9ltLNneQwPLPJU0qRfdd/tU5H0/WyWMUod", - "UJY+wDCsIK5IZnlMOQX5neeEqnjG55YHsAcDrW/NjGWkEAlT5GAmM3aATKbqfqwPbovDw+9jSyzwLxbd", - "CvumVJYLZvUVkPdzsYOyUvLWW/EJlRW8r5J16mORXJUQa+da6OiDrtFSZX1vb2vTW2o9lFuzpKtvrAKD", - "4EfvYmz4nJpGyZMutYneyNTCFAIZjCTQQt71+/Dg2g7qSx6K4/5faf/3w/6fB8P+b3+8iF7+8EM43uJ3", - "ng+hNfTKFv9aIaTvoOVCfguRYwJZRWDlrvegd6vP8M6o4BOmDQjx/bolY8yFpdVNL4Nye1F7/ai1SmAN", - "urtpgi9CYeAlNiAqsCQK8EOkmpI4wO9Nk8/NGVdYUAnNGpLvUW0Zkt6vs8nyiJ35pXuxH4y9nhjmi2c+", - "vV0QudT3bamnsUY/o2t4fHx5Dv0IBuTY/QraA4aOWZUIbXKG0zRduMZiM5kmPnL9IU4LbdHbqlAR0ZII", - "6aINICeFlOxIk5gKtISkjM4ZNI3ykTjayFx7U8WEK21cSyDfLtmDhvCyHAzaRH0bZGwFfyt814pCg7cV", - "+tTPHN0lDBPr7OuzsjZCzhTWObKr3bEF9qV213UrvAs3pws7i/N8ECULkfSN4jmx6qeIMbSfQd0HkfA5", - "TwqaumlCvPlHUCabfat3VyXXWmZXV6pa7+6m0MCULT2RPid1loSAPbqDBFDH6XZC9C6sJh0u9cz21NiE", - "bNUt+5kAGmjHvSMcscOobzbu6f6zgvCaZ0WKib5IltjS3u2xxZ65LRDRrHZgxUk7HK8YTU5qJrjQdT4V", - "PJut9gGcSy/AsmO+WxJk4QrlPfr67aHRAl6GjwWskTveNxg52y+8aWV9JuIJm3J3JSAw3/qikUZWl/Tl", - "8MRf0bLsvQJPAdCyDX4YjmW0+DOBcLXBfmfoPcn6tap4IUrFQPY5972aylf/F4MSP/HE1eeR983Sn1vh", - "QaLodFUYLvt5ocCQSDCnwjN17CUdlf46q15SX5HT7ksZdJBBFIZY7i895XPfwhf165RRzUABrHdG3ND8", - "OKSWla28nwl3V1qF78p57ERfiMiGrVRVVxFMlLhQ/q1QasoMYtQwd4Vx29nMX5hplNB9ThEdrtUbpn6I", - "0MCrKA/xFNf8F2YaQSBOPUJ241d6Eg3JUtsmLbes9ftMhLJSS/hxOq67Jnuyz0ssF76EbQN8XjKX2SgV", - "r9JPAlKoS4g95Nayah/nXW4EgiaALdeiK8pcGfQ5VElbtWqItyJU4xAD8qAOX67YjAm0H6wWU4yIZuxW", - "2M2ECyISaiqXxJSbwUQxljB9Z2Q+kGp68GD/X66kkQcPL17gP/KUcnGAkyVsMpihyHDBczMppNL1MBsX", - "durPq0mhXSZI7K4Ccn60MzYimGQS9B65Cp3PRC/LBUB3JRcAKGDLl6SxoBpRt7oBXj4FZdQb3rUxuxt6", - "x67rkarPotau5Bl/dEBcK9QgxPggx7z4aqXNhuIV2VVtAOOWPyvEy6wUUgHIxwQ+Ft4yTdvZIKZYk7lL", - "Q8YyFwfScgefGm3/ZmqKaI1ZN1XahsW0UajW6aqNHGc0v3JBUjmFDGjD4ztN9oQ0Lv/eZWRVKEbGbEbn", - "3BIFXZA5VYvXxBRg78wg8q1eVQNi3CDjpjoKOn99yjUkaDsrsAs8iBpVQVyIFnjVGsbhvXIO0NerBfYx", - "TgfscRjc5cP4PTMd+Vg+tPT0+4rljBryjvT7GCR3SNBbg68G9NeMQjz22mc6PxN91nLvd+WvDr2+EGMb", - "bqZSRxA81Fj1/Sk1Sh/F3cJeXQTtMwFuOUD3UcYejAr9YgSjPRsadx4FJhcV3s4Vq3Lb3jlM7P/DwPPF", - "ckA68L3SoacNXZSpYESKmJE9DDCJboXzoFe+s8iyHkiOdM7TqKZ3uorpmv/OxXTfGQfKharsUcIeaGzS", - "xa2A5Rp+RMVowoXVJ7gm9J5CQbqqVtIIq8wXKh3Beo5xUTJm2vTZZCKVuRVVy8+ytryf1XuM7MygLNrn", - "GZ0yggkpP1ruaqHku4yrDPrMJMTIWzHyKu3I9SihYgE3TRayIImEoHfB7I6PDUkZtYqz8DZ8jLexX4MX", - "ecyIqzo2uBVXPhCqCSttrPqqClEWBQcX4lEtnqoOGweBCIMhIlDQxTLEBkGQQD0oBAcKTyYSDIUuM7Yw", - "S+FWGEWF9ir2EeETQsHNpqpwLrtvcPzZDVKVWsFaUSWBDFY2mbDY+DTLjHJh8QHWxtDvmDlctX8SUvRf", - "Pjw432OuZE6nVqQPbsWlYhPmcq+lFYSa5RQywUdVLMg/jzBz7MDd0Qh8qy6euUyedr7gvlF8OmVWFbsV", - "CAOkJC4Anj6HsiTNkLjzt3xS0u8ThnVgmNewHq64FI1z86b/by7bqhmLRjKak//9P/8Xgah+zTIqDI+h", - "zvjl8c3JT2Q1GjJcFtx9NWwJja3tACMSyOiPWwxbve0d1SNjf/s46rghGB3cjQNrl21klmmAbhN+q622", - "IhmRPShFdICFiA6YiQc+GxpL8vsQ+lUEwiQCHXlfOeSUlylBy9y4yspthqE1KLVJpMGqgWuifs7qQVka", - "jK1+97EVaXEBFXuqKQYQx4PHqHJB1kaJ7Q82hww9OqDn+aNtIEvADhk63rl6m4aqwe/ahGKJMP9aw/WO", - "GpFOEDzsclgdc3asQA+IY2c+Ws6VcoGeAq4RYxUI6gbb/6cPfCl+/wbQLLXj9yD0AUMnyciFbR7gKhBk", - "MdrH7OSRvbd8WJHECKUCsEgEt4st8Yc1M1pGQ2kr7+CDe0XznFXNJPlSmlcbuFyZOCvcA2R89bZ0kznx", - "zpxwr7jwWvFd2qMikkJXP0tUMUVaM+Tl4at/w1KkUUV6FoAxBG9jSAvwCAcA3MU4ZS2l45t3uUZpq1Lq", - "/A2Ck6Qai3UBFM/R7buEkyVW7FkZWVbccrlj0D6CPSBFbszk/6JcdQ1NyPHL15W6WWKBnTllyz68wWM0", - "/1eHf948zm4w5fHKe+Fpwg6WtQf/vmi9JwYKl/1f4OVljH5C8hmFK64/TY5Bn8GHf1IqNGAMcPnYTU00", - "Twu9cvfo1+kULVeTz2VeRSCA38nd5zLDBrqMfWKcd6v7BNxVcH5w/mj/mmqA4bPh9KOj1cPH6Yg8E30Q", - "K0YNG5btZgCRilCAF3xYFsh6riiv5ipbIdOLdfW88JxfkA0DT0ooZAomtWvtCjksV9UBcqfw4XNDDlep", - "d5bc2clfAg2PmDyOOl9tHvdOmjeyEMkTRgfAzgl9DGS9Pr4GqG9Q7f6y4QkVH/8bgNK9cTpD0RWWsxQ6", - "/J1DJa0pM6Fae6ZQQhNK/np+ScpXS+214x8xZe2jqn6jR6/BalCPW/+Uq7/yHDI9FM2YYUpDL5u27q0l", - "9YG2bGT5KrFKjD8UvEPtuH8UDHAbX5++kmUTS6K6uWVTZczftlIS3L0+ygNob92fsSwhBqhXv+CvEXMd", - "sOpsyL5bENH803tXjNYm6YDS/h2/Z6iqPeYz72wHndrOtb8W82/FGtQnf9UmIXIyYUoTzaeCT3hMoXDC", - "hGp8yuKCThe/FQmr/8n+myp8zf7Oc2c8ovGMszl0x2ZmeRYgtHAwXY3u7B19LYQX/bHa67E8LkSEDMhP", - "fDpjCv9L2wdzUsSM6Iymad20Mi4MMfSOkVSKKVODW9FHSGhzRP7LQhunIC8i4spWWMCyhOz91/eHh/0f", - "Dg/JxY8Het8OdGU5mgO/j8iYplTEVqWzIw8AAmTvv178UBuLgGsO/dfIw9MP+eGw/2+NQSvbfBHBX8sR", - "Lw/7r8oRLRCpYcsQpunVwVF1ivP/qkqOuavqRbXfcMvwDx3qQLIt33TU+yjGebNko/s/hHkumSa3YKBg", - "XvK1SRzjbDIPqytBZ4quXAN4hbt4YKBSNZWCL0FKb6d5lncQQDnQJXnVje0rRKy/MFM/QdlPbgV6WyBW", - "yrWB94Juxay3XENdeL2jQPo6cak6dQCZqodmitV5vkJsglxzgDwmue6CPZmctz80L+QcXoHPGPH8FI9M", - "iDCujDtfISThBFIRxcAv+DiGoBhNSgNCkB9cMZo480E3dgDb8aqpnf9L4QgyNsz0q15pj9JpQMAEswy/", - "MnSCnMaGC3QL9NEMxcmw1umilUOsNhx5vhS4ls4mO9eoqTXycAlrXyGor5lZZRb1JiUH0ARFz8AM1BUH", - "0DPdHhwH9YR0zYHt6itIVcX9oGByeR6KZdLxEUzGHLTUbvFqypNF9ZSaUUvoRMK0GW5o/2K/4cI57RwX", - "dPULnerdpfFL1Ns1ysJZH6utbl3UBG/hyeqZAJTKUiZfO7sMlDiZODTcjmC8qXdtMScKZiaMHhRJWbeJ", - "G13Zeleyo5YxsI180Nr7ZMSzLXEk9R46tYpUVXSL7EYpTxSTtI5idkT9v/K8QvwaAP/bkAGtFxZbQtEd", - "KMIZmzaQxLam4jbKuRWbSWezybhhIb4VSybi9sJjzub7ZOTXGiF3M2PLpqhSDHWICftsZB2O4Gorvfyu", - "exCXa13o9gZlxaBYt0Wnfh++6Vfj9gfbVUSvrH3PwFCO3R3+N2cqy+i6M2O5Xy4NtvQiqbWHe663SKAD", - "XXfo71gsGY49DHVB+iD4Pwq22jatbsW7d9fRKVpxuT+DiWfkqSt2fiZ0xMPUzfquZJqYbqXvwX0e/OGB", - "8tE1NmBY7WcZI2VeIeSSwQWMKM5q4mwoJaTX2VE2m01ehVptICgxGP4rB+U19BvzeQe7WT+XwXiAeZqt", - "hrNrMDS90WdzZ1T5ZNBcNoIZ9mBwt0Hr1yYfyzU8wl2vrkBidNUzS05qr3aXxwrto2kCp/6j9x/96+uz", - "vivl1b8Jtq+5YAmnrkPDBJpSQbselxa7t8wI9xv+Uu8bXWGXAVfox68RkbE52fItu9pAnnV3xmnFNwWQ", - "QYWsLgbg05oSSFeMwZ8wHuF91ebEtxBu7R7c6Mj0p1ev2rYJLXdbtrW25zCSZxe94pHm6R0tM2V9tq9d", - "WIOJzcpnHy+7TRheKqf6oLr6sGNUTjWSXwsvX0IZ19VsHW57ZuWIoKqJHeJWUXiZiUxTeR+OGcH1VluB", - "LiMCpBmVyaN84juWcu3rVK0h3XbJtM06tbOHV6s+GObYHqv32aTiWzntKA4tYn3REjAkXeymMZP3+vqs", - "KwnlKV3cK0zPxEKzHUoyl20JL8vRJLYMG3zUE8X0rNaUHID3YAidUi40WhV8towqBBSGF1KQVMY0nUlt", - "jv788uVLzKKGWWdUQ2NMDez+u5xO2XcR+c7N+x0mnn3npvyu7GHl65G4ZrQuigZmrDYHBbhNoUTVn9Ij", - "YMgI5K6gOvcJSpjneIOurPWZcm8C+7AXGk6qKi/3SyyhXB0B6mdcw84RIwLI2bHQhGNrQD7tNgvXG9Du", - "5NmKZZUrfCZEaeygDUWqEunKffNF1NaOZZZZNqIXIp4pKWSh087PTI8COqf3YiMOXMNXz4oEsMTnxQK3", - "hTY0gJ8/c6WgVejTR4H/D/cPMDPc8WZBriAq/MyhstNmE0M181rNtHxyFAVPHvOq2Qnk9jRfZPni9z9/", - "lWEflh3xqX0SG0kq7Xl3nMQ6Ghux8go/+2+Dl3ieb5j5dLFnUI6Fksub/+yPsU/MU6CnNtQU7ZZZL1jw", - "q0+Nnc8sLfFQIUHpfvkqA+EdAIj2MHsMciS8g24FX/234VxwnM+sx+EW2vS4HxfQuQitkV+tAbKSr0Q7", - "DHoUpsrCbLJLVtcrC7PWQPmZeNojDG3l2eywjiY3f/+yMHlhwKST8gmLF3HKvvmkns8nVcN7WZit7YeK", - "xVAneHpQ+cbDHBoT7a/8989a16BcZXPV6eXMZjfw81U0+EwFZ8o6CLlicw7vX4LAZQmZ84TJrVwzNbxw", - "mZatnNCnYtZRY63L8rwKgylzUj3YfEkmI8uc6ohQTXIKQYZGktrWIOLFFSSUmRVhrjS0c8UE5uW6nJe1", - "psgAxw07HWn/9+P+Xw/7f+7/9i//tBNfBlgcZPmrRyfDVMjuINvgruWv/TdccD1jSf841OyfZ0wbmuUW", - "FlDzrgmQiRs8IH8pqKLCMATDmJGrNyfff//9nwfrvVGNrVxjjNJOO3HxTbtuxG7l5eHLdTwDyk3yNCUc", - "ysdOFdM6Ijk08iFGLdDKjFVfm9d9BdR0PLE/rJbXLqZTzLiGfkLQwZcLgt0cdK17rlog9VSHKCMgXwQi", - "ID9+xWnbWN5bA4kyCOx9EmaVchRdrTm2CGwLtUeq3mWuyjpp5lfDfOmVBJAVivatiVW5yydLQqVpWpt2", - "64vNqLpr9yziOTWh0Pw4Ia5yskBcd5G/VGBn5RpNQ8HoCRdQrRJxgqo7pnzXgb8zCLDlPmTcKZcXl6+s", - "TIhnNDdM+TGrCRcXVN09t8LSWOMZQ0232EPbW+8C7qkktP9jVKPjJCkxE3EFyrcIwkXfs/kKJ7enjZUO", - "8YFw5+dGw+Yia9XmF+tEoBOyX2HFRbiBsjVLnce8xyLvdV0iZ4qcn0IDaOhHMuXaQI9qaDNhudZgFzyQ", - "+To0kPnzY0Ftjd3fTi78+PO2ATEybyqAXQGiY5oyI39nSh4kXNNxur4XJBoT7FK/XGCpYTsDlLiSxM4S", - "WQShKknBvjEhP93cXBKj6GTCY2LfFGZATmia+qpYx5fn2PmCazvlvdUo7+kdI9yQMYtpoRn5IPidohOD", - "v9LCyIz63j7wLbY3W/hyPT7f8JeLYFErPOa1PfmN/CtTstcl2By+7xvZt6ck7q6SJwHfecKyXBpU7dzM", - "cK/M32rtiga7gJaJ9ZC9YtpIxbQrh42Ll4ctexRVu4isjiTv4SEA993cLur+8C7hScoQ5Di2fKz8ckGE", - "dGW1oCOGdi+UGUsTQi1gg1FJ4vHQw+t4BuDhxI+HXfnJxrJ09YaS5ahmCd0B8R+/OnxF+KT2HfbrqMqj", - "Bxvf/YWZm3I/z2iELxe5NtQEPYg34QPuqmStdudsmb8D1KKqZvUS06TKtdjCqgwIslZQgfx1K3CmCXuw", - "18ktcmlmqrA9ZHRjmSxA/ceUn+S1N+3Up1DMUBzHVYkrmhnDxVRvhRzkGkcRNmf1rVuc97cCOZVIX0dk", - "QlPoAM+o0r4IYu20oS6L9hab6Pb0ov9HDHorl6mX2v50Tqed8f0rru/hSn0/jtCKUNc/ZjZQlsfzl4cv", - "mnh+TxHRa8bgCudfu5BZO+7QjuPGDrCkkLLYh9XK3PS5OCK0UkFm1Dg6sLPX6XGPLhXQx3RwIc0Mra+o", - "wKiCRUQqT2uevLzmsd9KVq9R3Nj/K2WTE7vbMf7Lwnw+SvziKe8pjRK7b0izzxtVev04sdlQdmrpimE1", - "9RyMXJpQgW7NythVbQG9rBGZUte4GBL70Za2vNE6UzhEKoSvteZTwRLCxJylMmeV0uqW1YQm3ofy8vBV", - "4PcJT/GRvCekX977VVw6M3z7na5Im+uKuoH0Xx0eWu1xTlOeILhd/44wtY5TrivZib7oZwrZwLVgic8U", - "slGd0wEpGIAN4Mhxt5aZlxCNqfJdkCp4Y0fUmA2QvgPvCJyQxjHLAb0KU0F6Pa69Rhnjt/KI3jPNxso4", - "YQeS2J4cV6I6lpMYGdTFTu1xmwEO1dpI0gNyRuMZmSiaYYoLFJqSKiMjnhyRPzT7x8fbW5FQQ4/IHx5I", - "fYsR9u+3t2JkJS5Cx3VDKtvcxkzrfiaFNFLwGKIpcqY0GPJjJbVeYpkuPf41oeQt1aYPMO2fn6I9A/o1", - "Ok3ADhSVlAc6BGODYrrIvAkDjz0gp0rmuCmMZEWUmNJce7V9xJMRdkmDnojOYsP4nCX4G9dYr8nMqCAv", - "CJ0xmni/b2r3qhkT8GnkAzvumbKshIPxH04AaR3FZMLUgJykHL5yHd6NovFdYDZwITPDYgP7HZA3kNdU", - "HV97HWXpysAEWi1bvS4cqCwwIKVOMwbtQXDXr8FHTUb/j2J5Shf/g6bpCKufNKaTaQKlquEBY/mxw3Bt", - "GHWtJ++5ve8ZzSFFD1o6M8EUj8moyQlH2Lnea17u9ph7Ljna/Rmar2H3bLJnP19AE0iLbdjsmJJExkXG", - "hB01MoucjbCNacnOR9i1zeKcVFlZ/KpqKeh0nn+GbZ3Cx8jUIqJBqcT94OTBLsmAcM3jbayFe2VR1vdD", - "AwVRN+nJ9SuVimgmEnIYgIcHr28t3JUmI6Jlk7DmNC0wWy1jlsyUYjFULMKlqEG32IDc0DsG/exjlsBC", - "ELQzQrwZoeCFlti4MDRLheUsQ6KFkX3FHBpXy6WMCmjVCYiETsQ+TmkhNOMaSk5X9dDRe10FPTSIYLsE", - "00tA/G0QfkCuoHI/kDSJLT+hhrw4fPnqNQwokZnWOAHk9xRqQmOGpb4nXGmDxD6F/GPluMygtew73kg4", - "TixNd6vc/ohIu04S/20HYfTVZbsun8BC9Bo6uvevLT2WHGCzgP/48f8PAAD//5rpNaO72wEA", + "H4sIAAAAAAAC/+y9iXIbR5Yo+iv58CbC5EwBpGS5Z5qKGy9oUmpzLEp8JGXPdNMPSFQdANmsyqzOzAIJ", + "OzRxP+J+4f2SF3lOZi1AFRYukj1XERPTMlG5njXP+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", + "obAjiZwvUsUTNlGajUq0YuDmNavcxKH26lUSQJkpxpmwDi5WsZFnIhVdnKgERhGLeZ5Dwrhl//bizy/Z", + "eGHBsFTcgltUL5iyM9DuK1s49kQXN2DHYeCcpw4zDIsL6xgSZ/GMax477jh2/JjrBZIZyMQ4qI4Gg8Hf", + "Spz5ZTRgx2PjYO/OXF/THRRFRA2JamRS0I/DrAWZfuZp2o9TFd+y8J3jqQ55ibdot5NMpKmooZZfQxbZ", + "mBCp3MFQtJDEuZMGkDCtCgvfmGq/EZM8c3dKbI2YFf7NMGFNuYU9GEwHbHShlWM7jrmPIja65rdwVbKo", + "0X7r6TVJsNZ9OWTyvzOROFE0EaDZRKusg52GrzORJCnccQ2tixrLbdFy2z9cX1+woH4x+gq57qCFPJco", + "rnaQpfsu12vCeg0ROgq8sjy+Xd3iyekFuyykYy8D/ORa8xiYhlyDQz4hp3g3/87n/ArHkYgy7ltHHO5H", + "NxpFsySCHLC3jgkaVhhgbgXJMzdRrKT7GcW35ojLdsYlM5LfwjDmBrlkhsqEm/dkplUG7BTm10qlhl1o", + "ZVWsUnYnNDBieO2SJU3faodWm9UJPM0EP46YQ1idKWNJdWgoDcsMJi0y+Z4oYmWRv4JW/TE3kDD6kBHt", + "sDthZ4KUk1TIVjyIepNCorR+z7MWJlaDRPgQSShijk1kuV14XoR8g0slF5kqTPmxaUVht5stTuM+azkL", + "fd1+GvrtLGnHPfrvGjm27q7Q6erwj5fv3JHd2QMP87NNRNpGqEsU1rjm2j5pucaVRE14t5FaUzFckmMr", + "SJiT/GMpH0OKgMLtI1FZpEDigdwsZMxiXhho53c5116T3EKrqfjA8l3UKGYtH8ltPONXKp3DJZgitWv0", + "WPyUGfct49Y6zGQaOEoGzhydCXcDqrCxymCwnXpIsz5WPew4x1dNsVNT9Bc/RHAONd7ZM2qN6wC0uwIZ", + "sK+hQ7adaI0+6b8O97LEyDyyz0EmSrMJz0S6GDhxlRQxaMOku/HUwTTXai4S0H2TQywmImaWm9ugA0mr", + "mJ0JwwzYIwbSgs61MMDmXAsurXGMTkMgrlilKc8NhIEgNJuDNk4kjIv4Fizbm79kB2z+7X6EuiaXC8e0", + "p0wq9/6boygkVuMu91Q5OXJu/YEilqdcSPbh5HLfabIacqUtKXAj1EX9wy6gySwQqMODcGfzl83//NYh", + "RaGlsSJ1mDEFsGCsU3PclO3EvatSi0odMR9jubaOqNp4zopqi9aCYdf7IZ3XQYff0jPaLclFWujAuUdv", + "Li8/XA5Pji+uT344Hn58f/Xh3U/H3797M9ovFXslmSnoab2LWnm9fA428tOMjujMmmlwV4ystjB8nIL7", + "Ad/5AzbyO237WvpD7RkANqouw+165FiLKmw1LhEJYhKNr2sETqCA/sawOy4sGxfJFOyAjfiYy0RJSEZH", + "/hMWcxlDmkLCvBTM+RSY5HMxRY7I7/jCKeB9XLOJb/7YjqfRkdw10iZ7Ua9crBWlHN21PhM8lLkxYuru", + "pKabsA85/0cBkVNsJwUJblPkjiqY47Gmr2ECGmQM7SC9g7ERFoYzZVrE5g+KdNLyFu5moMHfJ5G8kxZ4", + "Ecna+XNuZy0PIG5n28/P/t/CvTm9Mgn3cVokrcuu6BI1XvmAx0qSn6gs4zLpVC68Paw0bsX0vXtip8IR", + "FlHXHAihnJ75M4yvFHLEXKv7xRETMi8sm4Jxz3cTBYTDV2oieKqm9BwVchqhQskMpEDqtlurZiwbsBMl", + "J2IaeI/fDhnR3AZOP5wf+EeW0+4mjneUe03FWHO9YMKYAkrTZUk/Y5jxdMK4Bk9pxIKjcvJ8xg14oxxP", + "kB6Rw++NnNoP52oOiXs+38LiY+7+Ec+4Hu3jjIlWee4mM4o2FN86Hc1t3TDO3BuQTsGZhhTcA63+brMz", + "DeAfT5/ZwreEJV9Vt27VLcmHHiOfU2NrgccDTH2ekJuaWnWAbgVtXFjb9tI6dzTA6FdvffLG87CWF9cp", + "TKyjDjQBun+Qzcf9SyoJHeYm3E6HVnhdLfKNYSP30Yjl3FGLBY1nIyaUCJOjycyEzSDlXjjqK2n3VN1J", + "90+rinh25VSaji1lYGeq47VNv9HxifsIOVe3pQ44OnMbGoQN4eUhPN3KF3wKgyCXOxbHGx7ewmJ1/R9h", + "QUyqZI+lGGrwlEXuuBdqtMKWypRThckIOHb/c6y1ugtX8vY7p538CAvPBXPSuxsWV+SfMK9ZbF8zO1MG", + "8JdYFdISaows3NthCnJqZ6MBOxXGChlbUihHjs40+VLcKQe3sBhF7G4m4hlLFAQVmW64XNxdU0IMclXJ", + "A2O6DKloIKHf6wbLOvY6FsSThFCFWdUwGgc5mcIcSinZrpjUTr26DzJ7oLUsnMk0dlFa1COyZcC9RbFx", + "C4sadg+YI4ma9d19JqyBdOJeF03wNK6rxt7uV7f3k4A7vPV7FiulEyG5BdpJDdcc5nGtF0zJds1/sWbm", + "xSNmXmKxnj438VIpIe40r0gG99677OmY6CQujFUZaHZ1+mPd1RexiyLPwQLofRbT3OT+6NCPSA0Rhv10", + "PthWrEvSjlol+1e53CGX8daeVy6fChPvik5JOQaSykGyAVHYBRdkFsavRZZBIriFdOE0yRgSx9hHtXOP", + "grZreObe6Rp49iTotpsiuXRBX3XJtThbocZnRdsHapTVbleVyuq3br3yod7UCkG3cqhmYAyfwhAVkXUC", + "mLQ4/NgpGylfQMI42h5a1gWBilUiNP2t3UOjgZs23fnn2WJ5TpAJJAM2IjYxjFNlYHTUVCiFFYjD9Edl", + "YMBGRU7UPYxnXE7R/IPOPVFkTANa6CAhK4/Xd8rnLXIZq9xrVd1J91KtrRarIk2YhgBjPuVCGtK/JNyx", + "sG59C2jUGh2Vv+Fznykd7pXlRZaTGYzOqiRqR6Whyh84OIf970jBlTFrzymy7hW/CH5uMyusO8J+04ZV", + "v8pe1Fu+qfqfcE/ojFra0WZKrOPxMrqVGLCOIJU0KgWMMttkl3E34j72pkSlmWNrxXRm625kuI8hJ6Qi", + "n/EbrxaSuLlTTgiR7o16MPIMQ+IlERM0s1nioGbGc6deBke2X//44uyEEzD8XwbeYsvT1OyHd4JhqB9H", + "qI9GjOupIesKuuOG6I6r5i63fT3TDh/3yrOVv9SnpjlTISHyruDIH2VY6LRlHe85l8oyHww4TiFoajQS", + "nywc1fwdrC7u/I8WlstY8FVWdstKuitPtM8oKlth4iRlmn6Y9I7+tj1MToiv9D5Fy+EOjihaKD5NS1rn", + "elpkbmYWK9AxvS7orGbALiiahCmZLtjdDKRHZU/tXYTbCMBYfbMuudyJvlqe0Y0QjEbIQs0CXvEjRC+k", + "7q03vsQV2uUsspn2V364RTeIIscixtM7vjDshlxSN71H3WJrwMfqXt7V4ju+3EVVDLIj6mMl2oNe4Xam", + "4a65xyfYWMMhFxj17hEXZGNpcfoUGZd9DTxBTk8SyouiRvhviSR3qPQkwuQpXzBhB+ytKn8lEbe3T0Iu", + "qsVBBwqtEygv4xbf1sV0Jcoir4TBRNxTtCLuzysQEUOzw03vYxiJbOiIjZXKbnpO9Nd+2xPSCcZMGNhn", + "14sc/Mf3aP1xAq8MUrrptZrLlnmmu9BV1vjLCnN8p6ZbKy2pmpJGUmkNqZpG5f0KOVHVf91xLSMGNh7s", + "D76AJA4H+yqHN8rhVE2fXwo34PH7ksE7idI1oqpTyXZzRCznZImeaVVMZ6yQE5FaDDNBdkshnQMfWjDC", + "qBJVeGNkQ2XyT/KQWvCa8TT1AdDLEtM4VRm4Zk5GDdgVkKnK5BCXsXWTIk2Zw4kuO/xz8Pa3yHiXwbMK", + "nc1OdQJItAXLa2DRyo78R57DhacrEl3lGgssMVNSWPeCk05UpKm71X6Qnt5iws6CY4KEleV6CjYirzC9", + "byrXOoNcxTNH3eQyQVGNO1FxXOjS7N9EfJyq00GCv9bdI7UoFNpMu/6jeAK6c9ZExQQr+q42f8ScQoHB", + "O8DjWe10HR6x+dDAP9o8k1JZJb2NQMjYPcIxNKu6LkqZioNKFtFnbl+QlBuwKvcentrI1kvYgns+wB0V", + "KIzWqVmL2h1N+FXr/AE3/US1JfaMReXIG7qqc5pwUM4sH++vWzHIhS0o+xpHOA1lbfCxhhTmXFJs2UwY", + "QuXX5NN0H0wwPLmECXm2px7lTVRakMpvwd4pfVszRq5nCjVg1S+2eeQKBdeIr7oqsKORVas5SO6QNAPL", + "UTvwkFs4bCZC9/YQjQliwThIdp8Vcod2TS1EU9bC75BzYPy3dxN3yaYRXm+de5UmKrzqdsS5FTLpUlXC", + "gQZoSg7mzLZcBS/GSieKZ64DNqJ8kyHPxeiI/Yj/wY4vzoK9cM/xGT0HsljTH/tTkKBR3Qo7ZyO4tyAd", + "IoyOmJB/J6eN30/524CNUhXzdJhTVs3oiJmFsZAx/wemCykdxHiq5NSIBBrbbdosk7wX9ar9u5/CQj3H", + "W2sLtWq6AVW6ka1FSdmED0GaETI4bkV0cODp5IBExdlpA96BFpZoC4G/hmJ+sDb/AZxsMN2HsLpYIRhM", + "CprRSJbx3EH3jusEw2r7wmOK271jbaqwZfQwCRn2E08Lp/JoVH6CjZm0PDYuLMv4go2Bcblg/3714T2q", + "SA2tZ+UwZ1VYw0kq4tuNj6UCX0wYL+Y1iZAHNxe8QkLkdlVyyObXUS2+4rEvpNYzfX0ndb6T6qEtCNln", + "fC11w+aJ30wUs6lakppOrq5Y+JXl3M6CjR3P7vhriopWh0oxbcv2O3/HLJ82MpKWZnMAK/IcNCa7EaP6", + "/uP19Yf3ETuO2OnZT/ud4Tlt4SlGoHfAcT1fRaBj4YhZjQ751unXBtX0q9CXxuTuLO4Wc3EPqWm35K2N", + "qXn4xEt4eN9zK0UVtAlCa59JNRT8ERYbGd4tLCgV/g/A7sJ5vjK7rZjdLSw+D6trwOWJGV1nyCWloZfa", + "548ej+luiQFhcGXEvufxrcl57F7t7VzoAdw08D20z88w+iIuDNnhKed6gRiTUwTjI7ktTr6e2569v/h4", + "HbHrN/9xfXz5ppvnLquD8AgGcxVrlaZXYG0KG7MaHANRacoMfe4ZTng38YmtPsmVEbWqJxgxgPkKv2v2", + "tHobXxnVVoyKoD70iPF5eFYHsJ6Yezn2NGxRQmh1dt8vMd1XHKCcvsoP6L7yuTzbqCW43qJzvcVTr+ft", + "MQ/gn7TWJnVUtV3eW8wRNKtXiCzETR5OEFjNNidRbffWWGrxJEstJ+sThpSg84f2G1q94bWs+Z2Yg1ND", + "N0RZs1TMgc0F3FXhZkuh0+4dPynSwLu/MexnGF9en5Q2nPdwq/YH7Af/nZLp4jX6OgNDnyiNs6RgDKPS", + "I587BLbtOr6y5E6W7LBi6LDiM4Rvd4Jm90jYYLlvhMGunKU7EnadZ+BdSSir/oEBu2oY78tgTePTDq3m", + "0iB5Bfv3OBU5i7mkcmL2TgUjahlbjgHjo2pLo52M5Vtc+Oag+VXu0B40vy2LqILn26AyXqwc90uwiK+h", + "8rtzic8SML8OQE/OK35HgfMP5UqvqcwUhKh5TWW6KEWliyvu6JHbMuH9nLzspzXu0cFzrn0OTu2OrAqe", + "HkcVqTJ2wK5RV7R6Edimdwj4bG9WSCvS4NwflvzYvS41Fp0csGsN3KIHQch+rtUUM8F9VUmMWLbA9jy/", + "HookxciPKQxTvlCFDW+UfcYNK6SGVKAIoJXtDOR2DMzv8bHcq+uGv7KvTvYVsKMu056Rfa2F0Cb+1cSj", + "rmyWS/x7Ga1QHQydajES0bDMRSkduqV3NPwyqPtBl0ZtvqHNmRb+Ks6ksG+5SDcyg8DbKBXGPS3G4LNw", + "UvEr7fdzU9rS5r/S2UY6cwAbTvDKnp/M2sCzG5EZC3k3SvoyA1jgwOOhj2eykJMpmI7qbbIUbzMwYI8L", + "q46t5fFsC5ssbmLzaS+DgNuKnFpla4O2NPQB45GEmZUWWbif8cJYip9Iq0cO2ZCw/pgZsPeKTQpNxQ6W", + "hfSdSFMvgMukWk/bX4KE227tKx1vpOMS8J+NmDsB9Sxis4HYvujWoPrr0NOBE6BEBw7DAwGwO9DA0ENT", + "5GV4iy/iNSnSdIFiVulQdbZJkHXJ27LiEwrfS3i0Kr50qhaWwZd1kDfECIJlMCnKe5jyHON9SL8/aarh", + "WJjPgEVzylK4YbCoWM3jWzebV1XYRIOZBSOFMCxXQtovyme+8pidecxnZS+PYS2BVrc1CmCltKXnP7P8", + "FpDKaunepX+hSUrb3O8Kb2jb5Ob7qSqSdxoKc9BCJSKu1YwL1o7g8537oJjtKLCa54mIcOkQX2lwIw2u", + "BcETk2AbdHajwFy2RFB8zw386VUfZKwSSNjF+79siaDltY0XFjZq6W7tNWd8TxLqLElhY2REkGYiCZHb", + "S3ERnH13eJgZ9o9CgPV0RzZ1qZiQ/UmKjU98XX4Mvt/S2+aXfiy9LfnBv1LYKoXVjYrPSFse794pngg5", + "Xfs0XEXAlEaFV6wvYHE2adQFwdJsqQaeLNz9eNzDyCenOXJ85ro3sFQs10JpNgpn91OMcI66p1jY/YiN", + "Cp2OIjYKeVHu32U604hyrkYafBY11R2sSka8ZqMWZMRMvJxras/EcpUXKWIJJhFhhTMD21abeCJi6QTR", + "V/m0kXo8hj7/K3Q9kJ44TogK3myCWZ0Aw4jl1EYMs5m2dK6ogY6qX7eHXr8PqVqYqlr7zZu0JNijozeX", + "l8OTD+/fvzm5Pvvwfnj55u3HqzenuzeuceyipXENerDCE1FpMRWSowVqiY10Oq/cqjUu0b6wP+ng0n96", + "vcihZg7AFVbSfuuZLD7j90ep7iSFoxomJFaTZqc+zTJib8HGs4j9xw+XEaMKQRG7sosUzAzc2/Ysw3oD", + "55AIHrG3yo25hnt77V62EatRd1TVqIvYOZdigju80DChNT7YGWhik5nSW3QKafTiqWFFVCHk2ngjf4Wh", + "8eK2UiaAD8tXdCTLPT/7re/6K+PdyHg90J6f467A5Yl5bciA3liGpUyVRj2hWf/N30Yr75lV2XNb7Lae", + "b/cp6vllHCV2cq6z8M0Ay+oImWBrTUxKRY2mMM1tPpiNGc+wcq6xT2OuwQlg4jFYs6D1BoQZaqDifOuI", + "AQ18nvsbv19TpNQNk4UZ2qmgqxo0PoG8n4YbFtpRuMmxuRZJsb+8uY7YxYer647mQ8rYYeAoy2Zj2vBY", + "JQuUFm6Wg4uP1+W7K3KH43MuUj5OoUM60dHaUfADSbwU06fHMFG+PlEYhWDAg6HOXbtsvEZdwBMJ4ogV", + "UvyjgEZHrMpz81XoPl7oejSOmlyp4iErDGE7eUyd+XYQyL6Vn4YYxLx6+b11m65ZI8sPEf0dULwbgIZF", + "6EpErAyJwOT4+zLyvXYLXwX8FgKe7utzSPhlyDyxiHfY2QokD4kGGlfsFCuplXXez8/O31AVnqeX8ttI", + "L6+FqCAN1qkcmci6uG55jDBheXgShe6sBzObpRFbbtL99UH3u5ctT9SjNUzTYRRonatWkuLDjxEr27Hv", + "P1QElg2VAmmtlXUXfAonmpvZGvNmzqfwjVMyZQIadBnzFtM4tsclu+kd30XsSvL8/7rpBc//PrubUfXF", + "yrISBvvGDsZSierUiTd2GTrIhTZHfgW/A681RbVA/3o56FAXCLskjQh7B6GUyGjATkLao6/1GLY2ctOP", + "WODBTiCDdFpnsq1F003wWHm7DImvsrZT1mIosceNZ5SzrRDZzbO2ppxVVYCmzuNDmHsN8T9v1aqq+RtH", + "OqLHke0m/818qrv0lNvFBgCcquyESle8UzzZwglz+uG8MSBU63T3jT2KknJGnAuV8y2rcz4Vnbce6ivB", + "ryf4RGVDX8UE/RfPTvvdUHpqv0WSD8t7a+EUFDaWhYqAjKJgqHSDkCxEwHDry6mtkMDE3UeEDSGsmCOI", + "l+UxxX3tuZcnQg1LMe4P2EcDbGQNlUi7a8bgbO5m1DzZRk3kHaaHbFsJgZJJOiohvPDX4p/dyNIwWany", + "91vQc8CaZmGmmZig5akyBc6FKTj2sx+LVNjFgL3h8awxgMLryPL2ou9XdYfWn4+pfA0c2I6HNPOPnpl/", + "eGx2OLK5vHSRFZ44G7i1d/Luat+jdpkzegEaL0DGwK5FBth2//ji7PMKseXjfZVf2+Geu7DPjHnP4gDy", + "cZCrF3m6lLPZQGiQVi9Wgjf3fDeDQxQzDXbMctBYq3m/NcOzfqvDBCwXqdk9pTWQU+3iGLdWi3FhwWyg", + "PDzSKu3NeDLUEDt1BRt5rkfpxiX5kkcxJBSagPUUqRuodyJgIFvk2y5jR0zPH07eXbWjPKoLLVmw9XVN", + "rHQw9uAr2MFqD3vyupsIYezvrvbbRf8KTnpr044lmkO5Jvx71VmicUVlRejW15HIWo7aCryK3tuwdXOO", + "8XLS0dKB/V6qbN8tlKA43ygu3rlnlLHMq3mTImUXXLhnzruTi9+rvPDn+ionNsiJOH9u8VCHxBOLhTTO", + "H8iGPU5XKE0Y/Vg27CsjtXIfkVTTB/p/d3JRVcUUk+DW6KwSP2xnNu7lRYkKq/NuVbpAqqSbZZ5+OGfu", + "gxauWVunq5+fTEB3bPsSf9x246+9wMbSLX1ySfgqRWX+1rXIhJz2j9NU3fXJKd9eqkH8Ct01TLkG3rEh", + "KhLFzD8K3pQH1dybYlTqM2IcrTsCU5rNRQIq/NRRcv15hV59a46HeTPc08s9XKhNOXuw0Nss6RTf/Mqv", + "Xu7Lhrw0DP8SJrxy71/F2QZxpvizP7QbsPidG+dQx6zQ+Y9imntfZo5uR7H1NiW+f+sy/SK/8PM6+mUn", + "XGsB2MCjrNY/oYaXQiLXGmO9e8t8zwrfAy301qhb4pa7ynxe7rB0W195xHoeUQHrmTlFG1x28+g9TKrL", + "gOX0xa4th97DHVvfdohxY8RU+jwgJIkNnYdyrp1a3H2eC/xg9UjYbqQY099rvXZe+wwi2kFL1yHTUTV6", + "15ZCT9Y46PN6ViscsOrJmvdQnGNN86qwaGtSWO9vCX2X0RHc4YgrexctGdjZjM+BjZWdkZwr44hME3ca", + "LpfSAy0Mq01PnhjsZYIRwexMJpA7bZi6GtQTA18zzoyQ0xSY+4IqG1BsVKKAukmOUVYK+zljPL66aXaV", + "B5/JVXPNxx9ykGucjhLuSgXH8rF7HHp+goESOJh0G1+uKCRwXiv6A+I+4jWNM/sUGGxCcDpv1OsSpkoB", + "9dWE3RZC/zyjGgU/N6V7en2pmehZU5xKqkD0c3plWxLogJ0oaYoMtHuHUo7rkp6GDahC06EZ1kWyWCxQ", + "WKercbTkC57ulDD6VFpZE8pflbL1RGj5eEh4/VmJ7wE6Ge6yXXO67oqwcjSMGUmedJEYlATKO5GLXZWM", + "9nCuIO8k3KWLcik+fhbNwwqbtph/KM8p9bzHfVNqpchQ2jfTqsaEqWqms+45niwKLOXW4fBxLk54mnZy", + "aMd0CKQZl2iCrMed/nTONKfSajMuWaLFPCgb/pOIzbhMasnA1MCuT/bMPs+Fr8l8hCVmNLK/VEwgXsQp", + "RNho3PfMQ3XIv95pM77JUlnVzX1Ray09EVPvHxqw6xkYNHiyTBmbLljuL6AvZFLEZVm8XCvsbW74HCKm", + "Adt9+9Ye+43D8qnjFNSxwWzNdP2qj2W8dbB9ZbndLNdf95DnYuhQ+RmZ7hXouYg3xn0T5iaI9SIGBvfC", + "Yn1guM+x4lO6cFq4ewcgn/Z9Zgg7HXpxq3S/yvg0s8Im6k7us0ShsuG7ZNYVkf/9P/8XhWdXq+C6hkK8", + "QWc+iwONSv2pmEO/yH2ReGr5mqhtUZyo9bEI3nKbX/G8E889Mn2G8O0uuOxe7xz32qx2vnSMstA5e3Mv", + "LCaIIMIaMXXo6pg5dvW4d8p1KWAKmYBOsQ9uU1rossRnPONSQooKP9IFZT0QQZKiYRcRGZWDKGL5jBuo", + "4sjLWAkmJL0H9vAxX2bX7pNT9ewUN6p9EkYbFeHMbaXUt1h6wEZItEU+YhlwSfI5HDwR7l7oJSQwhUm7", + "Nwa+fzibAU/tbFE2ocXShgM28v8dJuQs1zAXqjDpohzTWKHJvEZTPodh+4YCJMoCkj4KnqzxZc1KhLKl", + "yulWO1i+ZrKq49qFKFTPdSLq4TYBrFQG3agM7KxWlNGUxoqSlug6e1HP30Mv6vkTtTK1vNXMd3a6knVA", + "VzBgx+MqQbrtbtxirMhXi9y2XpNwT0yWKumGliUnOXXKuDg77Uip8hcoeatvU6up5lmzqaY/RrhP3/0Z", + "q3GLInMP5KywFrT714qSN9qmtHB9T5GninWsCAXNB5X9KDoV2OsZsHdCFvde72QfPpz3b0WaYjVglHtY", + "yazKoJJlF+afzgfsyreuxiCJ0UEC84PbzExHwcrg0IzLihxw6iVdNwiNDDKlFyVAyUAXIs28x6vMBzHF", + "2M+JKje3JbszRe4uymyfSPVEEnnlur8K5G6BjJc1VCobOpR4ToHcDpbd5bHb55I4bh6iu+9IrKSxmos2", + "Cvx51qQFiEVC1rdAigM2kkpCEBfTVI15ukotr9kogyyuiaV4qlWRhy8R+ogdM2Ffs1GcFwbsiB3gOKUX", + "w1ylIl6Que79x/PjA/pD3z1bQSLtVuxZSb9lw1SahEffd4ND73FORFL2FPPt6nQRUyrkSKkMj3Y0YqmQ", + "0BQw7rCYW5rFTrbQPukP1S47Orhnw4kGGN6OW/rBaYDQXt5fiZDsR/F96KdXDz9ym4tYAhorKpQhYCM3", + "+9H7kSc1IWug+8awc8j6Z3KiWFJk+YAdG1Nk4CDxCteh4l7iVxiw02D6DDnKGuKUiww7ksROAQmdqEzG", + "09R79jGLhLOU6ykg1IZWWZ4Ob8cj7KdirMNRB366cTqsA7lbChU/NuM6oc6mWCXbQ9OzkYCEddhxqiCD", + "OysPaHxR23oH9xq517fWwrjcL48GxXu8T8Muj88Jix4Bjue5hU2ajxeGQfFpn4N+7FBETlSWtc/GMGrL", + "JzY3xe1exu/Zi++clq9NVJMVjc86CggY0wrSSzD4LmAGLAmb9l15MO+ZAvfNpZJ9bQzZsehfqNvOMsjc", + "f+4P2LXTUn2NoXy2MCKuuF9dPXRoXhhU7tqRqKt5ZD603NyaNjzNWaVkjLEQPJ6yb8D28ZR+qUxltTbn", + "hLGG7t5NSd7AJW2pgaqja7cFemGMmPc1vslyu1iHlN6k7L494fgY4JZ9hwF1wqlFio1VgU5SklqI7Iis", + "wkJmHqLYuH0ihfP7M5rju/JWudZ8QUqLmE5BDzcRgP+u9hTdhhR971OZOE42Orn4eMTeO03e/Y8jiKOR", + "r2BTky0tcA973JrASkSbKQOMp6miehull7dWvMvv2yom5FzdksJc6dYD9mFi/fMGvdLcsFF9JyO2V5vG", + "E1GtFgbofQxLirlkiZhMQNfbV+OgmLbpf3Z3OhexFdmAnW9D/4176yqjXL874ncli9hWJUOE2k0bOy7d", + "7B4iFEG6iapQCqzoZtvD/TF8cxMlrJUB2zPdphRd5UpbNLUlIHqIboZlzRm0zjtVL2JDLiH3ZPOmWMLs", + "sn5MwwEb9cY8vnWKrEyG/i/hIXyn9C1o94cZ15BU/43V7Vo1xLDr4BI5oaeEAHOC/pCH2OlCBY/Kz+L9", + "IZgkLOSUnsHB8dL5SOC5jWfbvjaXT7Dw+/8U1TtsPsVcRqXwJBNZrdLHT1Tv//7oyULVskdPhJj5+FmC", + "9+vRM9VaATx+LjKPPHKeT2t4SMeY3WjxpO7QJMNTkBN1yqQVWjJ2qPhO2wMdvFNTmEa5Hk/lyYCdSVav", + "Ium7pvuAGpXbvpBHTGXC+lAzYfwDcs976u9mCt99NPk+S4HPQxvQsKKaTPyT0K3lFzcM7nlsvYk+LrkZ", + "igSrqKIk7u/4+uSHWp3Lrt0YH7mGjY6d+knQYqPfPo32MT6ISdVX+evm5jRYLiQWWGJoe3dSiczl18oX", + "NmJKs0QY6rtcDZ0LTruL2EIVLCuounCCW7jPUxELy0buICM3wwiBP2qoJ6UdayskewhyVe1L4xY086x9", + "wK5WAT9gH4LSGiTALSzKu16+6H0HtSA/0LIHE16kKOOPGJbrvwMs2k++Tu8DRY+P8VmzKo1qPaAi/9KO", + "mJcw+wP2M+XzjvyORlHl5qnhkAOHwyNPGkeITWgdCqj/mnG5IH+B8hGb7uCTCQYUUDOqar49L02iEDZJ", + "/VkjVuPp+xEbVcxrRIFkgS+SaUpNJk7lCheDFdYc0ozBXTl6fawasOPqeB5ooQoHbdifisUpcE20Ztuh", + "TIcZ+TYrtZpde9RtK6X+/t73s08uB1vN4RB+BhpeY750qu4M44VVGbc+Zs2p7uh74vUrazKZFlu2P94D", + "OXOl83yKenCfK72zrHiDo3bh8I0Ru5HgW6XvOMW/qEl5LzWYWUUsw4J2NJGAsVir0AFwKWwXay3XbveI", + "0QV47GWFTPFd4dlPuiixxcExQh2OHlzEpNzQ2no4tYe+lw/EtfcmBTagy1Mew74bHMjGT0LxwT6jxP/N", + "KuL99cdiGFajLlto6T587V4BnqXWVyAeX5csgU+TlsoKGc+4nLbjmrJpvit6fLh+d7E7iqyM2g1N3PAD", + "LHrory8o4Q8Q+S1IJlCZd4hYhchWoGZu9SbmfWhwqwH7Aa2xDCYTJ1b3wiYtXxgmpGOCcyxhCBI/24Rb", + "W4vBE++IDGoSvNFa6V1pkEos0lN7jM3KExZcnNW2MKDGW7aN9weQj55af6yCIgNjvAq9+nZud/+Xqw1p", + "6oznhjqxoRf4oIqM836MA8capBFKHvgotoNEGAxgc8LodZkr4SfEEudOrfEpBA7juRW+JFO943JzJ/h8", + "rs/U+hJt71b7IfcSvbrL5f60g4YvXuXDcP9UhlPb+h98M2i8AHfVjtP7S3D/4c8fPhRFNpykfGoIPu6K", + "NnvmwpkDCNuMBSepiG/PVWHA12DfMdZ2XFjbVvQFp2T0KxnbSJFASV+7pxQmthf1tFOc3FZFkqTBtkAO", + "TEfRrXCK3dY7Ktdee6sGfuNDHWurJurO/SfGSuAnrQvMVJoMb2Fh2o6XUESv+9mdz31b78FJs9bMuavh", + "vUumWVlkQxzll0Ou1Dt6sUzp7zF/E002IgNPWDl4y1JYd9VWdb96iv9gscLAVV7VO6AbyxWFz7XO1FIF", + "+j8fMtMSut733NQdSJqPFdeJLwaxa9XN1vK7J17IxmFyqr3rM5k2xy+7SVs3S/1W9XFpCXmIATX2s3jc", + "dVCGe4gLi0pGzrXv54Cs3qvB1LuLtAl66HoWfyOrWXLK/idvDslITUWIqUcZjnaXgK9G94Efm3PNM7Cg", + "zeBGvvFvWyXL32lkoyg12hbDCyDXai6SjtgPJOXM8YxNqswqw/oU9RLNp9sNP9V8ujw6U3PYbvS5msPy", + "aPTYOjaxafCF+/BHWNTGmlirdKPp7Qq/qg8DO4wLbdTGF8YV2BP8sD46BdioMV65jzwK16JEVmOUgv14", + "BcMacrgG38Z908yhP1J1leXVNGDbOHk4SBvnribdcEwnJ67h3pbXs0zl7d0hot6JBm7hFBuEKL14mPDM", + "VAJrNI0kzM7ch2xPxeidx1NGDKPY/vW77/YH7JSEBcqCf/3uO1TiuHWvrd5R7//722H/X3/57dvo1ad/", + "ak/8tbOWcO+xUanjNtUm3IdoA8GjLy1yMPjnzU4pt1LbZZ5CChYuuJ097B43HCFsPMFlnn7jlyH942G7", + "b3NAna0kKFU5JiElsDxRRCKBKvArdlB+eoBa54Adp/mMyyIDLWKmNJst8hnIAfvZvWX8KzRq2LRWVxPG", + "r5Ysoxfv/3rc/+th/8/9X/7ln7YriXNK2u2Wz8ilOnpoZOuW5+HlQN9VFYE6ih9ha/Oh5hY2T+m/Zhob", + "qUv2w69sL+MLJ91kkaZMTNC8lICFGL3/+62L3omkDV+XV8PP1u6/9WqXBdzz6POOK3fo8qUOT0p9a/Am", + "uLdNXc09XNaETt0nK4Uhx2DvAGTYiNPjfcg112Q0V8yJF8ZTVeaOW6z2kQkpMrfRwzaYrO017rMGMW6K", + "hS9X9haS+xzlaqAbcnvJyphpkyllZ/+DTP9ofEYrdbA4OoXenWHMje95gAsi+0pBTv05+D2d48Xh4eFh", + "7VzftR7sMY8Yd4Sd3jDtjPiDxhJVLBUGtda/3Uds8Uv9xZBzoU0Ju9BFhFoyuE1MMUjn3GmSXjVl3LIU", + "uLHsJcuV8H7bcqfLW65HwJXxMS/x8qr/WD7N2h8Jlg0cdnBdRuOPBtisyLjsp+IW2Pfwq8DyvnoOFTYj", + "hO/4gg7ChDQWOPaqSYUErun1nKvUW66Qb+NqaIMwwxz00MAUMY3IAfIhEtkwM2iaF1OpmmXCaiHGjc8b", + "R/puR7os6xbhvlYgeEa7WKWGjfS5cs7mI/mw+5Vcbglxi/aFNWT9ffnYRGQT3Rtk57Q99qKx1xeboza6", + "dIfSyretvW1p4nVWnTf0VLxI+eIOufC2wqC9LV/t8VlNiVlNLQHVSYc5hrr6HPw7n3P6J6VFVXPTKxb/", + "OOOG8Rhje6xi32C/l4h944sLfEOP12+8l+UbNudaOHHrX6ZZnsIRu+nxOy4s9cyYKqv2vplZm5ujgwOg", + "bwaxyr7Zf800oIW+9jmmRe/tv77ptcVaUT07qmsSN/DwTyt4eE7c2p8R1TaR1SuBldq707D+dNjg8N82", + "+PtmXMPL3xIfDG54R3QIfSSXsKA63aolP2D5UgIDNkL2KOz0pup+fA/q9m5VftOrz1AKwyZIVoFfuLk9", + "yuDfJzaSgG7Zz1WIWqQOzWXAWv1gLYbiRLXVcS4nU4XNC7vtbAUi/LowB6jfNiTMD8F2ge3OhkaWkl+g", + "DUHeihTO5ESt8iNhhonQ63eF8gsjEMrXYkd/UdVZH9WJ8gwVEh+7GcrWlTksCbfQ9+WTVxMMWvmOOxY9", + "nsfC+lTkiN30En13r/vu/2567kF00+vru77uu/+76bUHCraHI37PDTSyzTAHH+MpVm9i60d30FlXkUT8", + "CsPxwkILnlz5OEP8eeBLsYZtCDBbhBiGcFGOen1tsSjgQQ2G/tK70IliSTuy295WxRHItdnVsXob9OPo", + "scP2SFvi4UNhWS71UKDuhiXtVjef/LXIoW5iO7l8c3z9phf1fr48w/89ffPuDf7j8s374/M3WyRyUQ5X", + "p8KCHfxWwgba4Xsq3H+FJMVC+vL/ZcWk0mvr019DmxbPt3+kQGnMwqzyDHiZqcRTZvm9kipbHGEWI1UL", + "8G3iqtmN1cAzHxc+wr5v6L9TOkPNQskS1qhDuK2MIVV3bI8M6LQlsqz7IKtR9z2MIqZhynWCMQoYzaBY", + "XoxTgQmowg7YCU9T0P3qj/4CMNbqw9U1Oyh3f+B/CumTZa5a8G8LQzf7mhkANlraS/kexQ7NZsZzGLCf", + "eCqSshtDjJsJSQiG8Sl3bw+aOlxwyPCIfa0nbP2HTQuDwxV1pKSCOAn8jOe5QzOnY4QaFtuXBsFkQgyK", + "GhqVzmEYhP/aGU5oyJUbQdpKOVmSD2OVZVwmm+ZI8hP6sDkWo7a2GYsf1se6q9l2+Gn5bTkDhWYNvSa1", + "fgL6FrWr5fGpmm43+p2ahrG18C/yTW6Y4az6Hv00bfOgp2TbWX6ERdsc5Bwoi8FtPR15UhoFDqNeKuYw", + "nAu42xLI78QcfhJwtwTpapqt4R1mWgW6j2irTbXxmOc05LQ2Ynk2IYUdev16q8nOpLBv8fvlqTT4VXaa", + "7zKM2jDpzvOtzlWPs95mqqvy+zBTvYLkds2xz5IUlkc7zirkdLtr8vO8ozHNS1rq6rttu278eHUO35V6", + "957fvajZb3O3LqZhdEvzvge2SQwzLrXy2rpfVZMXrHZm2r3xVTlNnO/QBqUcpXiyS735MK5WM3nnetSr", + "c+xwjx2FY6OVqoG7FmTsRS1VsDZM0lYbLlopMrRzAadetFIXYdeSEz5l2D1tFu/x+UEa9qeopyRsX55+", + "WUh/inYZVtMMthzYxkh2HVpnH7uNbeGEu01QseQtx7WRxw5D23nUDhNUhL3DoCXC2WFkA8t32eYy09tl", + "bGB5u69X5zAPAuhDZmjXancfXCqzuw9tUVy3nKRDvdlt9KpSudv4FT3tgcMfwAc6NNktRzcEybYI1yaE", + "tmXTS4/PXYbVHhDbD1t+emw5svUNtOPYBy7d9cbfcnirZH5oYUdqi/JOGIsGzRbjn9Z8wdSkxZQoJFm2", + "sSUJ1YUYbFv/oTTXt/jgS82gpYRnqqbLKfk8z1Nvcl8b/L/czmxaem8s3NvO9lMdbXKuReabOJY7oiaX", + "lHa+rd2/wyVaX7rNknnOnVbypYK2Mq5vnzBky00HGm2TSS31pTOSa8fwrS5j+fuanZy2EDEsssHJXHh+", + "8YrFM55bbB9nU/CezXcYyNI7eul9m+G/X2wCLm5jC2hu5djcptJE/YR0i5D4o7aiu5pMDNjWAKILrebC", + "UFQnfda8uooca+ByiBAtR1pELANuMKOpstaC7wmFrmUseK192yd0qfPCzpQWlsIg/PrBqutBRBPcaYdY", + "GFwzEZKn4lfYqoxcuxupupBWsKnCwIXPDrgsDRLL/sdt0xZCUPDD0xW6Ztg6TWElOnw3LHzCEDQMl35k", + "8FkijOUyhkZEwnfPHXLm9rxTyNnj47C827AKunL/5NIu3WK7J3ETelYxbQHDmFUPQtNtZ9oJXR8ec52A", + "scNNseO15Mjg0t4Ueh31jI43TUzFJbeeczkQIiwQ1U7RdkMfbut8aYdImb9Q2xP24cfgK4NV5UrdbsTa", + "M2qDBCaEegw2h3mo29azXHAbz3zc9cMg3hV4fdodcF0yipevDncPvz7tDLsesLNJpQUVxudNz8R0BsZW", + "laxpSOCKGhB9vA7kHed/Ooy+PYxefhe9OPylfYt4td4LsAleEx+WqWHieAclvYpfgVgwVjaeC7hzGl2l", + "8vleDU6DwyTjdk7js2erHNJV/bNancR5yCz2BZmr84egC6sYSKdNYD+ehOeUQyLhLlTDrGLTECfwLmfA", + "k0mRRlR1Ivwl7UDPznj308449xJtvn15uF3U+3Ju1cMk74aI9CB1g9ii0mILQ2Hoy21yayjqwH0Y0bdc", + "A7NYEnBz0OsaQVomCWWbJOotLKiqKDPucrxE317Atq//zsdyu9nNIhurFBfHhQbsDY9nzC0Rmj6NgfHa", + "t8wUeVUB8z5RVqn0Ru4ZAPYfL17gWRaZe8Nguwglzf6A+chOU1ZmveldYrzfTS9iNz20RdI/T6xO6V/H", + "qf/T2+9ueoMbiuemkF9hKCA9xg3y1Ci3y1hlYy+yjM+xovn+xYZQMfwvXO1frvkYp93hQpe4Nd5uK7+m", + "unNv7iF+suBdznwIBDML6fiIxNL4q6KJ62kzDvxvv0QtdfjcTFxPi7Ib9vZYxc1QK9WM4m4/RtGsNY+V", + "YtxQlmsxFylMoYPtcDMsfBGW9VOGprHuazeVLFKUHoHHr2aeh0CSldAsvOhQUsnMIE3LK3eyoGjvvRnf", + "tZW6UBoL4lcWoz1eDyXb9zP64BxahJqpLx9gs84Fct6NXr+1JfB4mP32aRlgb+RcaCXx4VEGZmOlc9/0", + "rr2qYoX5K8HVu8VTdwOwO2yawLmRDB8VM83rRFcCrDzHKhGufQ++Kc/f9Rhsr1gJ98IO24P0L0LNztCy", + "pKMBA4ZQD8d/etUeQfmnV32QbnjC6FM2LiaTDpsJhVBvO5kqbPdkn7qh96Oo0qd3A98VNWxB7JWlba2G", + "vU2QUbWvBlPrXb+5PO+tn7cex+k///Hs3bte1Dt7f92Lej98vNgcvunXXoPEl6iKPlSaUFVldnH9n/0x", + "j2+b5bGXk0BS0961uOzYFKu0yKgF8LoEh6in1d2mudwnO2bl4KwRbXTNjV3l/E7WL2yrRvItonu1j7yv", + "UgxDaxebpeCx/5pxlhsoEtUvT793cf2f+8uMlTR7FERl3NwcSCJ1iMt2oIUWf8uA8zW2aodAi+JyLtcO", + "IF1ZyX328GU+tXawb8L1Afz8rOa14WPHkDgzbrZ19NBaY/jDVQmsrl43oYpz2/Ar7D3YL/t8t3SZrO2n", + "tOAWhUjaGTE25R9y2+6soT4jK51//LAd/DWdpGa5LcyulUVrBS0LQ1K2myvlxTCP21paGysyDFQ/ufjI", + "CnRq5aBjkJZP61JQYlLhBjFadfwSzSrVM258z7xtdBRq1dCR6lHtOBS+D3X3afdlFkiHBG81t1xUMLWN", + "1IKqmxRtv10WdQM2EfJhQueUW+442Z0WZABdQj3KshIyL1oyRxJu+VaKRVJfZXOzp3LeXzae+VH6otuO", + "z2g3brrVE3pvTReSVCmw+EFw7gx625pU/FE08CqNZxfd6epN2d9AQ67BOA5Va27n0+OUrvWq66rBvRs0", + "S3dahSzuFK0qKLQ7y981t7SSb+NIobW2wVasoWSkNLkw7AYH3vS6SNbtv0UKkCHc57moWsupeFbI22ZF", + "OsxWLHMgtyRiSlRB+D/ODjFWyYKantOUoZYxXYD01L2cuzNY2yesLTGqLCTNShsZ2imSuTBKL458ZeBb", + "qe7C6r5yVuilCJqRWF2q89zwo6bUtJfy6k2tWPOAnVG1UmxbanyJwkLSgnFhrMPNRQ4mcmhAtlesaEg8", + "ptlyKZR5ryqiR6H8fr3eelXGvVarvFFwvqwW3ihBXmbZVJHza7utddVepnv01D54dGu1DXlvNWVni0bT", + "XSWcKGYAdHve60RITNDaRiOqnPZhVJc+tNG0RKre6p9NGeFQ+71RwmFr/W0pxODBm126Z9Qr6/tsu/Mq", + "DPESptuUx9vOBfWDL7wdgjWm3h6ypvJPh1PiZ3RG7DLRlgEKNNc37mWW91OYOEGgJTwqZGGHOVu9wuEW", + "onCxm0D2EOeKLgG9ocZdEzFapVGzEt6uDuvU8uH9eh/PD0qLX5XEOmu4FuOZKqQdMIpUcW9o/LthWP4g", + "YhKmvPF3B4d2IU472FD36Ce343iL9RN1J1uWL/L2xR8TlFHW4tvevr+JKrj11YergoHNpXYnip2n3DpS", + "YqWK4o5cSyQJyA2FHSiio3KX+UEb3f3+u45tvxUpXIDOBIb+mYftH5tVttvgqI8l5cxr9peGIWPX4gwt", + "5Q3/9OrV/m7VDNWdbHP5uL3iT+jkCfv92LHfbRL5Kac8r+6WPLvkRPTV2h9YaXBNYYV6Wc4dGyLxwkC9", + "zAq1YckhdrSflG6EHf0Qdac41uNsc0PUC9o04scONxJlffHWC3EqzFvzM7fxkxaPLCt7omUAi+y2l6Rx", + "hCvmsNmEW1K7n4+VY9PFFmE9nUFKeAOPjGaeaJ5BexDOZaXbho8ciCe5o9g5aC0SMOHZ5G9gvw7zl4eb", + "7MGt1tHwdluxa+JTaSmm2YceuzckxUmKWtUd7DlWC7FmIBNfaW3PWJVHPiLbCVT3fIl8oct9ejemqbpz", + "o7IitSLH0swyNGgo5zRPVmSzZlHdKUo74/eBFs/kFdFet/u0WrruPgxhpOsBuxaWGb/H4i/iVziT5993", + "7wATIkJrvPPvt0Sm5ZqHLzrCytzpjotEqM10eeJb+nD3OdWNxEbqc5GAGrBLokFTtw44FYnPgXHpR/l4", + "RIcvF0Vq4Nj/Nb4FW29Cga0jsaoJwz4iY2VntR4U+x5bKNSqGQ4uDO2or2Qnv2jhDSp/LGtQOgY3z+ab", + "PMsySAS3kC6YIyyM1VCFZVPNY5gUKTOzwjoy8zVdMgzuQ4MndkaJldYFNgrCoyKOtDurHpF+QST/eSrm", + "urXyJ6mYWxV3kXNIVb5rROo1Fialoax0GlnsY12rIsaWCtO0tGYJ5tK1ZbWb5YGwZPk/Oj0O/UxJZZUU", + "cRmixsjVUu2Ux1oZIsJUTKDeQZiIcsA+Gt+H+x03to8r989OfQxm4fONrq7eBGupFxDCUAFRsrutpDrs", + "4FR2Zwz25F/WwrArP2upLhKlb9wJDf0U5pB6MxvW8sH6iHmtZpKHXCndkBuFukq+MlJ1+gE71mNhNdeh", + "vJHXvA019qJaSVVlIMcgE5pswN6uNM1cV8Apaqu8hDsG3UdzHqENS1SMoWRQ9m8fefvgP/uSRgdLfznF", + "eWthghFbrdvU2nBgWyPyH8UUW0Hz368+vC8tsW2gSoXxV7y+lBVV9iP/zTLomk0j2oBCMHV3/1hjcOjm", + "2+YDtwHhvGQu/SrkBsKWFHfc1FoCWydWfNKU0z5SkYmO3A7bokB9lOKeldmF9NhxrGmpmGd1UV5TRIZ1", + "V5MeW+VVfS5TeAn7q+AafoATvqtH32p0aZ6nosNW/TNP036MvdZCNps36tQus9np0cHXT0mJTTYU8G00", + "B6s3/ts+YiHyPaR2buVXNWl9mOTzwi3lxq4IZXaqgA6E/eiCcGxeCxkhzGCtUDvcIjgSD0LnaMWdpRYa", + "O1tlH1cJ/hYWxmp1C6a1enNruFB7hekHJZKFCNdqHyGRrpZQ5jjRPSQMDzu4kQ0moQtge6F7YBZSCA+S", + "UMd/f8CuqGVsmYFxI33IvGMBbi1Ue7hkKryaa+s1bort4d/+x6G7F5/ntj+4kbWK4tgFyd3aIicpcad0", + "0ne8MiGnso/BLk8upNW8776iBc2NdCqE5FSoEWUj/Zzzwjg4XaPe7PZGHNrtZQ3oWjvpRR1tnRwq4r1i", + "XxoSBjOFcf7UUamj0KYaOoKJYT0uYlvxGXey3r0DF7liQv7dd5bV3MJrlglj+S2QzoRyEtURvLMxj29N", + "zmOokIAdDtgHmS48CzNtN8D2jEhB2nTRuKcbWX2GuLFPV1W+lg8HL1qxPsQxbdvS6mctLJRNuB5G6Ouh", + "1YjwCYVhw4IP7cX1CZuSk3MXU9B7Rz2vmJ45xdSw44uzXtSbgza0ncPBi8EhmpFzkDwXvaPet4PDwbe+", + "LCoe5CAkYB1QQz4yIcYtNsRz0FPAZCr8klAA7oXBKBglwUSsyJ3wYUuTtqRwzYV7qeWgMYwhiYjIsGR5", + "Ia1I8ebKr09hfq1UathND9U9KeT0pofVFlIhsYOiGqPOlLAxTJQOtbPxAetzDRGZymbGZwlakW08C6u8", + "9Q0JfUW671WyoOjfqklbVVzi4O+GbNYkMVsc7uE2l7SLcCS6Q6tYhtfqazn/7abX798KZW4pz6ff942s", + "+9O8uOn9sv/w1BzaUDtaVd85+qTsPEzzxHVeHh62uDtw/wTvBB9Z5dE8sJcren+Keq9opjbNo1zx4Hse", + "aJJ6CnyKet9tMw7rC0me+lFYgzzLuHsV9T4SXpZbTHkh45kHgtu833Mv6t33Sz2rX72rqrePm7jC77Lh", + "5Sa6KQzofmgaV20EsBWGFgYYNQ9lleGwjCIa8/LngcO76EZuJCi2Oz3dyF0J6gQ0di8Jt8AyLvmUXqu3", + "/s0sJ5qHQscez9mb0Bv0yvfMjW5krtX9oo/tLSApZ6RzlPMHREXj+cnpxUFI+FdyHyUU9jWG5EaiOSTc", + "5Ubav6j6lj6U/NuFR5vOtQ3wB+zHkF7pf5I8A3Mj93wSn5e3J0rdCjD+Hm96ZOXH9gHehTcrZ6C/Dm7k", + "FQALzSOocWu1k8FUqWkKJWIfkGutTEEOf/dxXZTE6M7/PTciPi7s7MMc9A/W5m9C12O6g9YNox3KfWw+", + "5lPNEzDlKC92z/n9SWlrMBegLxye9I6+fRn1LlRe5OY4TdUdJG+V/qhTg07k1cYYvV8+PRXnC7jyh2V+", + "y2jnzvIYHljkqeJJv2r42+cy6YfZHGNUpkVZ+ojDqGi5ZpnjMeUU7FeRM67jmZg7HgD3Frvt2hlkrJAJ", + "aHYwUxkcEJOpGi6bg5vi8PDb2BEL/guiG+nelNpxway+AvF+IR+grJS89UZ+RmWF7qtkneZYJpclxLq5", + "Fjn6sFG10lk/2Nu69JZa2+bOLOnqG6fAEPjJuxhbMee2UfJkm9pEb1XqYIqBDFYx7FrvW4wEcO0G9SUP", + "xXH/r7z/62H/z4Nh/5ffXkQvv/uuPd7iV5EPsRv1yhb/WiFkaNrlQ34LmVMCWUVg5a73sF1syPDOuBQT", + "MBaF+H7dkjEW0tHqppdBub2ou37UWiWwBt2HaYIv2sLAS2wgVIAkauGHRDUlcaDfmydfmjOusKASmjUk", + "3+PGMSSzX2eT5RG35pf+xX4wDnpiO198E9LbJVNLreaW2igb8jP6HsvHF2fYAmHAjv2vqD1Q6JhTicgm", + "ZwVP04XvZTZTaRIi1+/jtDAOvZ0KFTGjmFQ+2gBzUljJjgyLuSRLSAp8DtinKkTiGKtyE0wVE6GN9V2I", + "QofmABomynIwZBMNnZep+/yNDI0yCoPeVmyNP/N0lwAl1rnXZ2VtxJwpqnPkVruFBbXC9td1I4MLN+cL", + "N4v3fDCtCpn0rRY5c+qnjCm0H7Dug0zEXCQFT/00bbz5e1Qmm62yH65KrrXMrq5Udft9mEKDU3a0YfqS", + "1FkSArUFbyWAOk53E2JwYTXpcKlNd6DGJmSrBt3PBNCWDuAPhCM1NQ39zQPdf1EQXomsSCnRl8iSuuj7", + "PXbYM3cFIpnVDpw46YbjJfDkpGaCa7vOp4Jns7s/gnPpBVg26fdLoixcobxHX787NFnAy/CxFmvkA+8b", + "jZzdF960sj4T8bSbch9KQGi+DUUjraou6ffDE38my3LwCjwFQMvO++1wLKPFnwmEqz39t4bek6xfq4rX", + "RqkUyD4XoT1U+er/3aDEDyLx9XnUXbP05054kGg+XRWGy35eLDAkE8qpCEyd2ldHpb/OqZc8VOR0+9KW", + "HGQYhSGXW1pPxTx0DSb9OgVuABXAejPGDf2W29Sysnv4M+HuSnfyh3IeN9HvRGTjVqqqqwQmznwo/04o", + "NQVLGDXMfWHcbjbzF7CNErrPKaLba/W2Uz9GaNBVlId4imv+C9hGEIhXj4jdhJWeRENy1LZJyy1r/T4T", + "oazUEn6cjuuvyZ3syxLLeShh2wBfkMxlNkrFq8yTgBTrElLrubWsOsR5lxvBoAlky7XoijJXhnwOVdJW", + "rRrijWyrcUgBeViHL9cwA0n2g9ViihEzADfSbaa9ICLjtnJJTIUdTDRAAubWqnyg9PTg3v2/XCurDu5f", + "vKB/5CkX8oAmS2AymJHI8MFzMyWVNvUwGx92Gs5rWGF8JkjsrwJzfow3NhKYVNLqPfIVOp+JXpYLgD6U", + "XBCgiC2/J42F1Ii61Q3x8ikoo94nr4vZXfNbuKpHqj6LWruSZ/zJA3GtUMMQ44Oc8uKrlTYbildkV7UB", + "ilv+ohAvs1JYBaAQE/hYeKs07WaDlGLN5j4NmcpcHCjHHUJqtPubrSmiNWbdVGkbFtNGoVqvqzZynMn8", + "KiRL1RQzoK2Ibw3bk8r6/HufkVWhGBvDjM+FIwq+YHOuF6+ZLdDemWHkW72qBsa4YcZNdRRy/oaUa0zQ", + "9lZgH3gQNaqC+BAt9Ko1jMN75Ryor1cL7FOcDtrjKLgrhPEHZjoKsXxk6en3NeTALXvP+n0Kkjtk5K2h", + "VwP5a0ZtPPYqZDo/E33Wcu8fyl89ev1OjG20mUodIfBw69T3p9QoQxR3B3v1EbTPBLjlAN1HGXsoKvR3", + "Ixjd2ci48ygw+ajwbq5YldsOzmHm/h8Fni+WA9KR75UOPWP5okwFY0rGwPYowCS6kd6DXvnOIsd6MDnS", + "O0+jmt7pK6Yb8auQ031vHCgXqrJHGdzz2KaLG4nLNfyIGngipNMnhGH8jmNBuqpW0oiqzBc6HeF6nnFx", + "NgZj+zCZKG1vZNUptKwtH2YNHiM3MyqL7nnGp8AoIeV7x10dlEJjc51hn5mEWXUjR0GlHfkeJVwu8KbZ", + "QhUsURj0LsHt+NiyFLhTnGWw4VO8jfsavchjYL7q2OBGXoZAqCasjHXqqy5kWRQcXYhHtXiqOmw8BCIK", + "hohQQZfLEBu0ggTrQRE4SHiCTCgUuszYoiyFG2k1lyao2EdMTBhHN5uuwrncvtHx5zbIdeoEa0WVDDNY", + "YTKB2IY0y4wL6fAB16bQ7xg8rro/SSX7L+/vve8x1yrnUyfSBzfyQsMEfO61coLQQM4xE3xUxYL884gy", + "xw78HY3Qt+rjmcvkae8L7lstplNwqtiNJBgQJQmJ8Aw5lCVptom7cMsnJf0+YVgHhXkN6+GKS9E412/7", + "/+azrZqxaCzjOfvf//N/MYzqN5BxaUWMdcYvjq9PfmCr0ZDtZcH9V8OO0NjaDigigY1+u6Gw1ZveUT0y", + "9pdPoy03hKNbd+PBus02Msc0ULdpf6uttiIZsT0sRXRAhYgOwMaDkA1NJflDCP0qAlESgYmCrxxzysuU", + "oGVuXGXlNsPQGpTaJNLWqoFron7e1IOyDBpbw+5jJ9LiAiv2VFMMMI6HjlHlgqyNEtsfbA4ZenRAz/NH", + "22CWgBsy9Lxz9TYt14NfjW2LJaL8a4PXO2pEOmHwsM9h9czZswIzYJ6dhWg5X8oFewr4RoxVIKgf7P6f", + "OQil+MMbwEDqxu9h6AOFTrKRD9s8oFUwyGK0T9nJI3dv+bAiiRFJBWSRBG4fWxIOa2e8jIYyTt7hB3ea", + "5zlUzSTFUppXF7h8mTgn3FvI+PJd6Sbz4h28cK+48FrxXdqjIpZiVz9HVDEnWrPs5eGrf6NSpFFFeg6A", + "MQZvU0gL8ggPANrFOIWO0vHNu1yjtFUpdeEG0UlSjaW6AFrk5PZdwskSK/acjCwrbvncMWwfAfdEkRsz", + "+X9XrrqGJuT55etK3SyxwM2cwrIPb/AYzf/V4Z83j3MbTEW88l54mrCDZe0hvC867wlQ4XL/i7y8jNFP", + "WD7jeMX1p8kx6jP08E9KhQaNAT4fu6mJ5mlhVu6e/DpbRcvV5HOZV9ESwO/l7nOZYVu6jH1mnPerhwTc", + "VXB+9P7o8JpqgOGL4fSjo9Xbj7Ml8kzMQayBWxiW7WYQkYq2AC/8sCyQ9VxRXs1VdkKmF+vqedE5f0c2", + "DDop45gpmNSudVvIUbmqLSB3ih8+N+RolXpnyQc7+Uug0RGTx1Hnq83j3iv7VhUyecLoANw544+BbNDH", + "1wD1Landv294YsXH/wag9G+craHoC8s5Ch3+KrCS1hRsW609W2hpGGd/Pbtg5aul9toJj5iy9lFVvzGg", + "12A1qMevfyr0X0WOmR6aZ2BBG+xl09W9taQ+1JatKl8lTokJh8J3qBv3jwIQt+n1GSpZNrEkqptbNlXG", + "/GUnJcHf66M8gO7WwxnLEmKIevUL/iNirgdWnQ25dwshWnh6PxSjjU22QOnwjt+zXNce81lwtqNO7eba", + "X4v5N3IN6rO/GpswNZmANsyIqRQTEXMsnDDhhp6ytKDXxW9kAvU/uX9zTa/ZX0XujUc8ngmYY3dssMuz", + "IKG1B9PV6M7d0R+F8KLfVns9lsfFiJAB+0FMZ6Dpv4x7MCdFDMxkPE3rppVxYZnlt8BSJaegBzeyT5Aw", + "9oj9l4M2TcFeRMyXrXCAhYTt/de3h4f97w4P2fn3B2bfDfRlOZoDv43YmKdcxk6lcyMPEAJs779efFcb", + "S4BrDv3XKMAzDPnusP9vjUEr23wR4V/LES8P+6/KER0QqWHLEKfp1cFRdYoL/6pKjvmr6kW132jL+A/T", + "1oFkV77pqfdRjPN6yUb3fwjzXDJN7sBA0bwUapN4xtlkHk5Xws4U23IN5BX+4pGBKt1UCn4PUno3zbO8", + "gxaUQ11SVN3Y/oCI9Rew9ROU/eRWoLcDYqXCWHwvmE7MeicM1oU3DxRIf0xcqk7dgkzVQzOl6jx/QGzC", + "XHOEPCW5PgR7MjXvfmieqzm+Ap8x4vkpHpkYYVwZd/6AkMQTKM00oF/wcQxBA09KA0IrP7gEnnjzwXbs", + "ALcTVFM3/++FI6jYgu1XvdIepdOggGnNMvyDoRPmNDZcoDugjwESJ8Nap4tODrHacOT5UuA6Ops8uEZN", + "rZGHT1j7A4L6Cuwqs6g3KTnAJihmhmagbXGAPNPdwXFYT8jUHNi+voLSVdwPCSaf56EhU56PUDLmoKN2", + "S1BTniyqp9SMOkInEjB2uKH9i/tGSO+081zQ1y/0qvc2jV+i3kOjLLz1sdrqzkVN6BaerJ4JQqksZfJH", + "Z5ctJU4mHg13I5hg6l1bzImjmYmiB2VS1m0S1lS23pXsqGUM7CIfsvY+GfHsShxJvYdOrSJVFd2itqOU", + "J4pJWkcxD0T9v4q8QvwaAP/bkAGvFxZbQtEHUIQ3Nm0giV1NxV2UcyM3k85mk3HDQnwjl0zE3YXHvM33", + "ycivM0LuegbLpqhSDG0RE/bFyLo9gqur9PL77YO4fOtCvzcsK4bFuh069fv4Tb8atz/YrSJ6Ze17BoZy", + "7O/wvzlTWUbXBzOWu+XSYEsvklp7uOd6i7R0oNse+g8slozHHrZ1QfooxT8KWG2bVrfi3fnr2Cpacbk/", + "g41n7Kkrdn4hdKTD1M36vmSanO6k7+F9HvwWgPLJNzYAqvazjJEqrxByyeCCRhRvNfE2lBLS6+wom80m", + "r9pabRAoKRj+Dw7KK+w3FvIOHmb9XAbjAeVpdhrOrtDQ9Na8mXujymeD5rIRzMK9pd22Wr82+Viu8BHu", + "e3W1JEZXPbPUpPZq93ms2D6aJ3jq33r/0b+6etP3pbz6163ta84hEdx3aJhgUyps1+PTYveWGeF+w18a", + "fKMr7LLFFfrpj4jI1Jxs+ZZ9baDAurfGaS02BZBhhaxtDMCnNSWQrxiDP2M8woeqzUloIdzZPbjRkelP", + "r151bRNb7nZsa23PYSLPbfSKR5qnH2iZKeuz/dGFNZrYnHwO8bK7hOGlamoOqqtvd4yqqSHy6+DlSyjj", + "u5qtw+3ArDwRVDWx27hV1L7MRKWpumuPGaH1VluBLiMCphmVyaNiEjqWChPqVK0h3W7JtMs6tbO3r1Z9", + "MMypPVbvi0nFd2q6pTh0iPW7loBt0sVtmjJ5r67ebEtCecoXd5rSM6nQ7BYlmcu2hBflaBY7ho0+6okG", + "M6s1JUfg3VvGp1xIQ1aFkC2jC4mF4aWSLFUxT2fK2KM/v3z5krKocdYZN9gY0yC7/ybnU/gmYt/4eb+h", + "xLNv/JTflD2sQj0S34zWR9HgjNXmsAC3LbSs+lMGBGwzAvkrqM59QhLmOd6gK2t9odybln24C21Pqiov", + "9/dYQrk6AtbPuMKdE0a0IOeWhSY8W0Py6bZZ+N6AbifPViyrXOELIUpjB10oUpVI1/6b30Vt7VhlmWMj", + "ZiHjmVZSFSbd+pkZUMDk/E5uxIEr/OpZkQCX+LJY4LfQhQb48xeuFLQKff4o8P/m/4FmhlvRLMjVigo/", + "CqzstNnEUM28VjMtnxxFIZLHvGoeBHJ3mt9l+eIPP/4hwz4cOxJT9yS2ilXa88NxkupobMTKS/rsvw1e", + "0nm+YubTxZ5hORbOLq7/sz+mPjFPgZ7Gclt0W2aDYKGvPjd2PrO0pEO1CUr/yx8yEN4DgJkAs8cgRyK2", + "0K3wq/82nAuP84X1ONpClx73/QI7F5E18g9rgKzkKzMegx6Fqaqwm+yS1fWqwq41UH4hnvYIQ1t5Njds", + "S5NbuH9V2LywaNJJxQTiRZzCV5/U8/mkanivCruz/VBDjHWCpweVb7ydQ1Oi/WX4/lnrGpSrbK46vZzZ", + "7Ad+uYoGX6jgTFkHIdcwF/j+ZQRcSNhcJKB2cs3U8MJnWnZywpCKWUeNtS7LsyoMpsxJDWALJZmsKnOq", + "I8YNyzkGGVrFalvDiBdfkFBlToT50tDeFdMyrzDlvNCZIoMct93pyPu/Hvf/etj/c/+Xf/mnB/FlhMVB", + "lr96dDJMhewesg3uWv7afyukMDNI+sdtzf5FBsbyLHewwJp3TYBM/OAB+0vBNZcWCAxjYJdvT7799ts/", + "D9Z7oxpbuaIYpQftxMc3PXQjbisvD1+u4xlYblKkKRNYPnaqwZiI5djIh1m9ICszVX1tXvclUtPxxP2w", + "Wl67mE4p4xr7CWEHXyEZdXMwte65ekHUUx2ijIB80RIB+ekPnLZN5b0NkihgYO+TMKtUkOjqzLElYDuo", + "PVL1LnNV1kmzsBrlS68kgKxQdGhNrMtdPlkSKk/T2rQ7X2zG9W23Z5HOaRjH5scJ85WTJeG6j/zlkjor", + "12gaC0ZPhMRqlYQTXN+CDl0H/g4YYCtCyLhXLs8vXjmZEM94bkGHMasJF+dc3z63wtJY4xlDTXfYQ9db", + "7xzvqSS0/2NUo+MkKTGTcAXLt0gmZD+w+Qond6eNlQ7xLeHOz42GzUXWqs0v1olAL2T/gBUX8QbK1ix1", + "HvOBirzXdYkcNDs7xQbQ2I9kKozFHtXYZsJxrcFD8EDl69BA5c+PBbU1Hv528uHHX7YNiFV5UwHcFiAm", + "5ilY9StodZAIw8fp+l6QZExwS/10TqWG3QxY4koxN0vkEITrJEX7xoT9cH19wazmk4mImXtT2AE74Wka", + "qmIdX5xR5wth3JR3TqO847fAhGVjiHlhgH2U4lbziaVfeWFVxkNvH/yW2pstQrmekG/403lrUSs65pU7", + "+bX6K2jV2ybYHL/vW9V3p2T+rpInAd9ZAlmuLKl2fma8Vwi3WruiwUNAC3I9ZC/BWKXB+HLYtHh52LJH", + "UbWLyOlI6g4fAnjfze2S7o/vEpGkQCCnseVj5adzJpUvq4UdMYx/ocwgTRh3gG2NSpKPhx5dxzMAjyZ+", + "POzKTzaWpas3lCxHNUvoDlj4+NXhKyYmte+oX0dVHr218d1fwF6X+3lGI3y5yJXlttWDeN1+wIcqWavd", + "OTvm3wJqUVWzeolpcu1bbFFVBgJZJ6hQ/voVBBgG9+46hUMuA7YK2yNGN1bJAtV/SvlJXgfTTn0KDZbT", + "OKFLXDFgrZBTsxNysCsaxWAO9a07nA+3gjmVRF9HbMJT7AAPXJtQBLF22rYui+4Wm+j29KL/ewp6K5ep", + "l9r+fE6nB+P7H7i+hy/1/ThCK9q6/oHdQFkBz18evmji+R0nRK8Zgyucf+1DZt24QzdOWDfAkUIKcQir", + "VbntC3nEeKWCzLj1dOBmr9PjHl8qoE/p4FLZGVlfSYHRBURM6UBrgbyC5rHfSVavSdy4/ytlkxe7uzH+", + "i8J+OUr83VPeUxolHr4hA182qvTqcWKzoezU0hXb1dQzNHIZxiW5NStjV7UF8rJGbMp942JM7Cdb2vJG", + "60zhkKgQvzZGTCUkDOQcUpVDpbT6ZQ3jSfChvDx81fL7RKT0SN6TKiwf/Co+nRm//cZUpC1MRd1I+q8O", + "D532OOepSAjcvn9HO7WOU2Eq2Um+6GcK2aC1cIkvFLJRndMDqTUAG8GR024dMy8hGnMduiBV8KaOqDEM", + "iL5b3hE0IY9jyBG9CltBej2uvSYZE7byiN4zzcbKNOEWJLE7Oa5EdSwnMQLWxU7dcZsBDtXaRNID9obH", + "MzbRPKMUFyw0pXTGRiI5Yr8Z+MenmxuZcMuP2G8BSH2HEe7vNzdy5CQuQcd3Qyrb3MZgTD9TUlklRYzR", + "FDlog4b8WCtjllimT49/zTh7x43tI0z7Z6dkz8B+jV4TcANlJeWRDtHYoMEUWTBh0LEH7FSrnDZFkayE", + "ElOem6C2j0Qyoi5p2BPRW2xAzCGh34Shek12xiV7wfgMeBL8vqnbqwGQ+GkUAjvuQDtWItD4jyfAtI5i", + "MgE9YCepwK98h3ereXzbMhu6kMFCbHG/A/YW85qq45ugoyxdGZpAq2Wr14UHlQMGptQZAGwPQrt+jT5q", + "Nvp/NOQpX/wPnqYjqn7SmE6lCZaqxgeM48cew40F7ltP3gl33zOeY4oetnQGCVrEbNTkhCPqXB80L397", + "4J9LnnZ/xOZr1D2b7bnPF9gE0mEbNTvmLFFxkYF0o0Z2kcOI2piW7HxEXdsczimdlcWvqpaCXuf5Z9zW", + "KX5MTC1iBpVK2g9N3tolGRGuebyNtXAvHcqGfmioIJomPfl+pUozAzJhhy3wCOANrYW3pcmIGdUkrDlP", + "C8pWy8CRmdYQY8UiWopbcosN2DW/BexnH0OCC2HQzojwZkSCF1ti08LYLBWXcwyJF1b1NXg0rpZLgUts", + "1YmIRE7EPk3pIDQTBktOV/XQyXtdBT00iGC3BNMLRPxdEH7ALrFyP5I0ix0/4Za9OHz56jUOKJGZ1zgB", + "5vcUesJjoFLfE6GNJWKfYv6x9lxm0Fn2nW6kPU4sTR9Wuf0RkXZbSfx3WwijP1y26/IJHESvsKN7/8rR", + "Y8kBNgv4T5/+/wAAAP//87QaCzDlAQA=", } // GetSwagger returns the content of the embedded swagger specification file diff --git a/server/openapi.yaml b/server/openapi.yaml index 4c0d53aa..40298304 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 identifier the command was addressed to. 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 submitted text itself is never captured. + named_key: + type: string + description: > + Key that commands the page rather than typing into it (e.g. `Enter`, + `Tab`, `ArrowDown`, `F5`). Keys that produce a character are never + captured; those are counted by `text_length`. Distinct from + `interaction_key.key`, which does report the character typed. + 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 add nothing (`mouseMoved`, `keyUp`, `char`) are dropped, so a click + reads as a press and a release rather than three frames. + 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"