From c2ef7a13e2f66497030980c47d8fbf47d41a040c Mon Sep 17 00:00:00 2001 From: Sayan- <1415138+Sayan-@users.noreply.github.com> Date: Wed, 14 Oct 2026 21:47:12 +0000 Subject: [PATCH 01/15] Preserve network telemetry and wire metadata across navigation --- server/lib/cdpmonitor/README.md | 53 ++++- server/lib/cdpmonitor/cdp_proto.go | 24 ++ server/lib/cdpmonitor/computed.go | 10 +- server/lib/cdpmonitor/domains.go | 5 +- server/lib/cdpmonitor/extension_source.go | 36 +++ server/lib/cdpmonitor/handlers.go | 181 +++++++------- server/lib/cdpmonitor/monitor.go | 31 ++- server/lib/cdpmonitor/network_capture.go | 278 ++++++++++++++++++++++ server/lib/cdpmonitor/telemetry.go | 4 + server/lib/cdpmonitor/types.go | 30 +-- server/openapi.yaml | 15 +- 11 files changed, 553 insertions(+), 114 deletions(-) create mode 100644 server/lib/cdpmonitor/extension_source.go create mode 100644 server/lib/cdpmonitor/network_capture.go diff --git a/server/lib/cdpmonitor/README.md b/server/lib/cdpmonitor/README.md index a150a9a07..32b2a1f0f 100644 --- a/server/lib/cdpmonitor/README.md +++ b/server/lib/cdpmonitor/README.md @@ -64,8 +64,8 @@ startup, telemetry toggles, and shutdown. Additional regressions delay a cleanup command while PUT/PATCH/GET continue, fence old capture across coalesced revisions, and recover page/frame listeners after socket loss or failed cleanup. They check future navigations and the independent user CDP connection as well. Extension -background pages are included in discovery but are not validated by a real extension -fixture here. A delayed-Network-reply regression also verifies that pending +service-worker and page attribution are covered by an unpacked-extension browser +fixture. A delayed-Network-reply regression also verifies that pending attachments finish recovery before optional instrumentation starts, and that click events arrive without navigation through subsequent telemetry toggles. @@ -109,6 +109,53 @@ and fresh sessions after reconnect. Without the environment variable these tests skip, matching the other real-Chromium tests in this package. They exercise settled targets, not requests issued before their capture domains finish initializing. +## Network capture fidelity + +Top-level navigation retains requests until their terminal events. Only requests +belonging to the new loader seed its pending count; completions from the previous +navigation cannot make the new navigation idle. Same-process frame requests still +participate in their page's network-idle accounting. + +The collector joins `requestWillBeSentExtraInfo` and `responseReceivedExtraInfo` +by session, request ID, and redirect hop. Cached hops without ExtraInfo do not +consume the next hop's headers. A `network_request` waits at most one second for +wire headers, then uses the base headers so a hanging request remains visible. +`network_response.request_headers` retains wire request headers that arrive after +that initial event. Response capture waits at most one second for promised headers +before falling back to the base response. Capture remains best-effort when Chrome +omits events or a target disconnects. Redirects emit a response for each hop, +without a body. Request IDs remain the same across a redirect chain. + +`network_response.status` is the wire status when available. `effective_status` +is present when Chrome's effective response differs, such as wire 304 with an +effective 200 and a cached body. `headers` contains the wire response headers when +available rather than Chrome's merged cache headers. + +While optional telemetry is enabled, `Network.enable` requests durable body +storage with `maxTotalBufferSize` set to 10 MiB on each attached session. Disabling +telemetry stops new durable capture without disabling the Network domain used by +counters. Chrome may keep already-buffered bodies until eviction or disconnection. +Unsupported configuration is logged and ordinary capture continues. Bodies can +still be evicted under buffer pressure; `body_error` reports retrieval/decoding +failures separately from intentionally excluded or empty bodies. The 8 KiB/4 KiB +output caps are unchanged. + +Extension-target events carry `source.metadata.extension_id` and +`source.metadata.kernel_extension` (`"true"` or `"false"`). The latter identifies +the bundled extensions loaded from their fixed installation paths. Consumers can +filter these sources while retaining application workers and custom extensions. +Network events snapshot the request's document origin, falling back to the target +URL, so navigating into or out of an extension page does not relabel pending +requests. Content-script requests made through an ordinary page document are not +attributed to an extension. Attribution is a telemetry aid, not a security boundary. + +Run the browser regressions with: + +```sh +KERNEL_CDPMONITOR_CHROME_E2E=1 go test -race ./lib/cdpmonitor \ + -run '^TestNetwork(WireCapture|BodiesSurviveNavigation|ExtensionAttribution)$' -count=1 +``` + ## Event taxonomy **CDP-derived** (1-to-1 with a CDP notification): `console_log`, `console_error`, `network_request`, `network_response`, `network_loading_failed`, `proxy_error` (classified from a branded 502 or 403 response carrying the `X-Kernel-Proxy-Error` header), `page_tab_opened`, `page_navigation`, `page_dom_content_loaded`, `page_load`, `page_layout_shift`, `page_lcp`. `proxy_error` is an opt-in per-session/per-URL refinement of the raw `network` events: it is only observable while the network category (CDP collector) is running, so it is not a default-on alerting signal. @@ -358,7 +405,7 @@ Unless otherwise noted, events also include the nav context fields described abo | Event | Fields | | --- | --- | | `network_request` | `request_id`, `loader_id`, `frame_id`, `document_url`, `method`, `url`, `headers`, `initiator_type`. Optional: `post_data`, `resource_type`, `is_redirect` + `redirect_url`. | -| `network_response` | `request_id`, `loader_id`, `frame_id`, `method`, `url`, `status`, `headers`. Optional: `status_text`, `mime_type`, `resource_type`, `body` (truncated text body for textual MIME types). | +| `network_response` | `request_id`, `loader_id`, `frame_id`, `method`, `url`, `status`, `headers`. Optional: `status_text`, `mime_type`, `resource_type`, `body` (truncated text body for textual MIME types), `body_error`, `request_headers`, `effective_status`. | | `network_loading_failed` | `request_id`, `error_text`, `canceled`. Optional (absent when the request record was not found): `url`, `loader_id`, `frame_id`, `resource_type`. | | `proxy_error` | `request_id`, `code` (typed enum matching the metro header values), `status` (502, or 403 when the session's network policy blocks the destination). Optional: `raw_code` (sanitized original value when `code` is `unknown`), `url`, `loader_id`, `frame_id`, `method`, `resource_type`. Emitted when a 502 or 403 response carries the `X-Kernel-Proxy-Error` header. Unrecognized values are reported as `unknown`; all such values share one rate-limit slot. Emission is sampled to at most one per session+code+resource_type per second. WebSocket handshakes are not classified (documented non-goal). A CONNECT the proxy refuses outright, such as a `network_policy_denied` CONNECT to a port other than 443, is not classified either: Chromium does not expose the refusal, so it appears only as `network_loading_failed` with `net::ERR_TUNNEL_CONNECTION_FAILED`. | diff --git a/server/lib/cdpmonitor/cdp_proto.go b/server/lib/cdpmonitor/cdp_proto.go index 75fd2a86e..a17316438 100644 --- a/server/lib/cdpmonitor/cdp_proto.go +++ b/server/lib/cdpmonitor/cdp_proto.go @@ -162,6 +162,30 @@ type cdpNetworkRequestWillBeSentParams struct { RenderBlockingBehavior string `json:"renderBlockingBehavior,omitempty"` } +// cdpNetworkRequestWillBeSentExtraInfoParams mirrors Network.requestWillBeSentExtraInfo. +type cdpNetworkRequestWillBeSentExtraInfoParams struct { + RequestID string `json:"requestId"` + AssociatedCookies json.RawMessage `json:"associatedCookies"` + Headers json.RawMessage `json:"headers"` + ConnectTiming json.RawMessage `json:"connectTiming"` + ClientSecurityState json.RawMessage `json:"clientSecurityState,omitempty"` + SiteHasCookieInOtherPartition bool `json:"siteHasCookieInOtherPartition,omitempty"` + AppliedNetworkConditionsID string `json:"appliedNetworkConditionsId,omitempty"` +} + +// cdpNetworkResponseReceivedExtraInfoParams mirrors Network.responseReceivedExtraInfo. +type cdpNetworkResponseReceivedExtraInfoParams struct { + RequestID string `json:"requestId"` + BlockedCookies json.RawMessage `json:"blockedCookies"` + Headers json.RawMessage `json:"headers"` + ResourceIPAddressSpace string `json:"resourceIPAddressSpace"` + StatusCode int `json:"statusCode"` + HeadersText string `json:"headersText,omitempty"` + CookiePartitionKey json.RawMessage `json:"cookiePartitionKey,omitempty"` + CookiePartitionKeyOpaque bool `json:"cookiePartitionKeyOpaque,omitempty"` + ExemptedCookies json.RawMessage `json:"exemptedCookies,omitempty"` +} + // cdpNetworkResponseReceivedParams mirrors Network.responseReceived params. type cdpNetworkResponseReceivedParams struct { RequestID string `json:"requestId"` diff --git a/server/lib/cdpmonitor/computed.go b/server/lib/cdpmonitor/computed.go index 07ebfc474..1c5f8510d 100644 --- a/server/lib/cdpmonitor/computed.go +++ b/server/lib/cdpmonitor/computed.go @@ -138,8 +138,7 @@ func (s *computedState) stop() { // resetOnNavigation resets all state machines. Called on Page.frameNavigated. // Increments navSeq so any AfterFunc callbacks already running will discard their results. -// inflight seeds netPending; callers pass 0 because each session only tracks its -// own requests and starts fresh on navigation. +// inflight seeds netPending with requests already observed for the new loader. func (s *computedState) resetOnNavigation(inflight int, ctx navContext) error { s.mu.Lock() defer s.mu.Unlock() @@ -159,11 +158,8 @@ func (s *computedState) resetOnNavigation(inflight int, ctx navContext) error { return err } s.navData = navData - s.navMeta = map[string]string{ - MetadataKeyCDPSessionID: ctx.sessionID, - MetadataKeyTargetID: ctx.targetID, - MetadataKeyTargetType: ctx.targetType, - } + s.navMeta = targetMetadata(targetInfo{targetID: ctx.targetID, targetType: ctx.targetType, url: ctx.url}) + s.navMeta[MetadataKeyCDPSessionID] = ctx.sessionID stopTimer(s.netTimer) s.netTimer = nil diff --git a/server/lib/cdpmonitor/domains.go b/server/lib/cdpmonitor/domains.go index b2aa7e853..72f264288 100644 --- a/server/lib/cdpmonitor/domains.go +++ b/server/lib/cdpmonitor/domains.go @@ -133,9 +133,10 @@ func (m *Monitor) disableOptionalDomains(ctx context.Context, sessionID, scriptI if !exists { return nil } - var cleanupErr error + cleanupErr := m.configureBodyCapture(ctx, sessionID, false) if scriptID != "" { - _, cleanupErr = m.send(ctx, "Page.removeScriptToEvaluateOnNewDocument", map[string]any{"identifier": scriptID}, sessionID) + _, err := m.send(ctx, "Page.removeScriptToEvaluateOnNewDocument", map[string]any{"identifier": scriptID}, sessionID) + cleanupErr = errors.Join(cleanupErr, err) } if isPageLikeTarget(info.targetType) { if dirty { diff --git a/server/lib/cdpmonitor/extension_source.go b/server/lib/cdpmonitor/extension_source.go new file mode 100644 index 000000000..151a49483 --- /dev/null +++ b/server/lib/cdpmonitor/extension_source.go @@ -0,0 +1,36 @@ +package cdpmonitor + +import ( + "crypto/sha256" + "encoding/hex" + "net/url" + "strconv" + "strings" +) + +// These bundled extensions are loaded unpacked at fixed paths without a manifest +// key. Chromium derives their IDs from the first 128 bits of SHA-256(path). +var bundledExtensionIDs = map[string]bool{ + unpackedExtensionID("/home/kernel/extensions/kernel"): true, + unpackedExtensionID("/home/kernel/extensions/capmonster"): true, +} + +func unpackedExtensionID(path string) string { + sum := sha256.Sum256([]byte(path)) + return strings.Map(func(r rune) rune { + if r <= '9' { + return 'a' + r - '0' + } + return 'k' + r - 'a' + }, hex.EncodeToString(sum[:16])) +} + +func targetMetadata(info targetInfo) map[string]string { + metadata := map[string]string{MetadataKeyTargetID: info.targetID, MetadataKeyTargetType: info.targetType} + origin, err := url.Parse(info.url) + if err == nil && origin.Scheme == "chrome-extension" && origin.Host != "" { + metadata["extension_id"] = origin.Host + metadata["kernel_extension"] = strconv.FormatBool(bundledExtensionIDs[origin.Host]) + } + return metadata +} diff --git a/server/lib/cdpmonitor/handlers.go b/server/lib/cdpmonitor/handlers.go index 230c95ec5..c0e09d9fe 100644 --- a/server/lib/cdpmonitor/handlers.go +++ b/server/lib/cdpmonitor/handlers.go @@ -71,11 +71,15 @@ func (m *Monitor) publishEvent(eventType string, category oapi.TelemetryEventCat } } meta[MetadataKeyCDPSessionID] = sessionID - m.sessionsMu.RLock() - info := m.sessions[sessionID] - m.sessionsMu.RUnlock() - meta[MetadataKeyTargetID] = info.targetID - meta[MetadataKeyTargetType] = info.targetType + // Asynchronous network events carry the origin observed at request time. + if _, snapshotted := meta[MetadataKeyTargetID]; !snapshotted { + m.sessionsMu.RLock() + info := m.sessions[sessionID] + m.sessionsMu.RUnlock() + for k, v := range targetMetadata(info) { + meta[k] = v + } + } src.Metadata = &meta } m.publish(events.Event{ @@ -144,6 +148,16 @@ func (m *Monitor) dispatchEvent(msg cdpMessage) { if m.decodeParams(msg.Method, msg.Params, &p) { m.handleNetworkRequest(p, msg.SessionID) } + case "Network.requestWillBeSentExtraInfo": + var p cdpNetworkRequestWillBeSentExtraInfoParams + if m.decodeParams(msg.Method, msg.Params, &p) { + m.handleRequestExtraInfo(p, msg.SessionID) + } + case "Network.responseReceivedExtraInfo": + var p cdpNetworkResponseReceivedExtraInfoParams + if m.decodeParams(msg.Method, msg.Params, &p) { + m.handleResponseExtraInfo(p, msg.SessionID) + } case "Network.responseReceived": var p cdpNetworkResponseReceivedParams if m.decodeParams(msg.Method, msg.Params, &p) { @@ -439,8 +453,10 @@ func (m *Monitor) handleNetworkRequest(p cdpNetworkRequestWillBeSentParams, sess m.sessionsMu.RUnlock() cs := m.computedFor(sessionID) var navSeq int64 + countedNavSeq := -1 if cs != nil { - navSeq = int64(cs.currentNavSeq()) + countedNavSeq = cs.currentNavSeq() + navSeq = int64(countedNavSeq) } // Redirects reuse the same requestId and fire additional requestWillBeSent @@ -455,18 +471,21 @@ func (m *Monitor) handleNetworkRequest(p cdpNetworkRequestWillBeSentParams, sess addedAt = time.Now() } else { navSeq = existing.navSeq + countedNavSeq = existing.countedNavSeq + m.resolveNetworkHeadersLocked(existing.hop, p.RedirectHasExtraInfo) } m.pendingRequests[key] = networkReqState{ - sessionID: sessionID, - method: p.Request.Method, - url: p.Request.URL, - headers: p.Request.Headers, - postData: p.Request.PostData, - resourceType: p.Type, - loaderID: p.LoaderID, - frameID: p.FrameID, - navSeq: navSeq, - addedAt: addedAt, + sessionID: sessionID, + method: p.Request.Method, + url: p.Request.URL, + headers: p.Request.Headers, + postData: p.Request.PostData, + resourceType: p.Type, + loaderID: p.LoaderID, + frameID: p.FrameID, + navSeq: navSeq, + countedNavSeq: countedNavSeq, + addedAt: addedAt, } m.pendReqMu.Unlock() var hdrs oapi.BrowserHttpHeaders @@ -495,8 +514,25 @@ func (m *Monitor) handleNetworkRequest(p cdpNetworkRequestWillBeSentParams, sess payload.IsRedirect = ptrOf(true) payload.RedirectUrl = ptrOf(existing.url) } - data, _ := json.Marshal(payload) - m.publishEvent(EventNetworkRequest, events.Network, oapi.BrowserEventSource{Kind: oapi.Cdp}, "Network.requestWillBeSent", data, sessionID) + m.pendReqMu.Lock() + requestInfo := info + if p.DocumentURL != "" { + requestInfo.url = p.DocumentURL + } + hop := m.queueNetworkRequestLocked(key, payload, requestInfo) + state := m.pendingRequests[key] + state.hop = hop + m.pendingRequests[key] = state + m.pendReqMu.Unlock() + if isRedirect && len(p.RedirectResponse) != 0 { + var response cdpNetworkResponse + if json.Unmarshal(p.RedirectResponse, &response) == nil { + existing.status, existing.statusText = response.Status, response.StatusText + existing.resHeaders, existing.mimeType = response.Headers, response.MimeType + m.emitNetworkResponse(m.telemetryCtx, key, existing, info, true) + } + } + m.publishNetworkRequest(m.telemetryCtx, key, hop) if !isRedirect && cs != nil { cs.onRequest() } @@ -514,6 +550,7 @@ func (m *Monitor) handleResponseReceived(p cdpNetworkResponseReceivedParams, ses st.statusText = p.Response.StatusText st.resHeaders = p.Response.Headers st.mimeType = p.Response.MimeType + m.resolveNetworkHeadersLocked(st.hop, p.HasExtraInfo) m.pendingRequests[key] = st state, ok = st, true } @@ -554,7 +591,11 @@ func (m *Monitor) handleResponseReceived(p cdpNetworkResponseReceivedParams, ses navSeq = int64(cs.currentNavSeq()) } } - m.publishProxyError(sessionID, p.RequestID, code, p.Response.Status, navSeq, method, resType, url, frame, loader) + source := oapi.BrowserEventSource{Kind: oapi.Cdp} + if state.hop != nil { + source = state.hop.source + } + m.publishProxyError(source, sessionID, p.RequestID, code, p.Response.Status, navSeq, method, resType, url, frame, loader) } func (m *Monitor) handleLoadingFinished(ctx context.Context, p cdpNetworkLoadingFinishedParams, sessionID string) { @@ -571,71 +612,37 @@ func (m *Monitor) handleLoadingFinished(ctx context.Context, p cdpNetworkLoading m.sessionsMu.RLock() info := m.sessions[sessionID] m.sessionsMu.RUnlock() - if cs := m.computedFor(state.sessionID); cs != nil { - cs.onLoadingFinished() - } - // Fetch response body async to avoid blocking readLoop; binary types are skipped. - m.telemetryWg.Go(func() { - body := m.fetchResponseBody(ctx, p.RequestID, sessionID, state) - var hdrs oapi.BrowserHttpHeaders - _ = json.Unmarshal(state.resHeaders, &hdrs) - resPayload := oapi.BrowserNetworkResponseEventData{ - SessionId: sessionID, - TargetId: info.targetID, - TargetType: oapi.BrowserTargetType(info.targetType), - FrameId: ptrOf(state.frameID), - LoaderId: ptrOf(state.loaderID), - Url: ptrOf(state.url), - NavSeq: state.navSeq, - RequestId: p.RequestID, - Method: state.method, - Status: state.status, - Headers: hdrs, - } - if state.statusText != "" { - resPayload.StatusText = ptrOf(state.statusText) - } - if state.mimeType != "" { - resPayload.MimeType = ptrOf(state.mimeType) - } - if state.resourceType != "" { - resPayload.ResourceType = ptrOf(state.resourceType) - } - if body != "" { - resPayload.Body = ptrOf(body) - } - data, _ := json.Marshal(resPayload) - m.publishEvent(EventNetworkResponse, events.Network, oapi.BrowserEventSource{Kind: oapi.Cdp}, "Network.loadingFinished", data, sessionID) - }) + m.finishNetworkRequest(state) + m.emitNetworkResponse(ctx, key, state, info, false) } // fetchResponseBody retrieves and truncates the response body for textual resources. -func (m *Monitor) fetchResponseBody(ctx context.Context, requestID, sessionID string, state networkReqState) string { +func (m *Monitor) fetchResponseBody(ctx context.Context, requestID, sessionID string, state networkReqState) (string, error) { if !isTextualResource(state.resourceType, state.mimeType) { - return "" + return "", nil } result, err := m.send(ctx, "Network.getResponseBody", map[string]any{ "requestId": requestID, }, sessionID) if err != nil { - return "" + return "", err } var resp struct { Body string `json:"body"` Base64Encoded bool `json:"base64Encoded"` } - if json.Unmarshal(result, &resp) != nil { - return "" + if err := json.Unmarshal(result, &resp); err != nil { + return "", err } body := resp.Body if resp.Base64Encoded { decoded, err := base64.StdEncoding.DecodeString(body) if err != nil { - return "" + return "", err } body = string(decoded) } - return events.TruncateCaptured(body, bodyCapFor(state.mimeType)) + return events.TruncateCaptured(body, bodyCapFor(state.mimeType)), nil } func (m *Monitor) handleLoadingFailed(p cdpNetworkLoadingFailedParams, sessionID string) { @@ -644,6 +651,7 @@ func (m *Monitor) handleLoadingFailed(p cdpNetworkLoadingFailedParams, sessionID state, ok := m.pendingRequests[key] if ok { delete(m.pendingRequests, key) + m.resolveFailedHeadersLocked(state.hop) } m.pendReqMu.Unlock() @@ -677,12 +685,14 @@ func (m *Monitor) handleLoadingFailed(p cdpNetworkLoadingFailedParams, sessionID } } data, _ := json.Marshal(failPayload) - m.publishEvent(EventNetworkLoadingFailed, events.Network, oapi.BrowserEventSource{Kind: oapi.Cdp}, "Network.loadingFailed", data, sessionID) + source := oapi.BrowserEventSource{Kind: oapi.Cdp} + if state.hop != nil { + source = state.hop.source + } + m.publishEvent(EventNetworkLoadingFailed, events.Network, source, "Network.loadingFailed", data, sessionID) if ok { - if cs := m.computedFor(state.sessionID); cs != nil { - cs.onLoadingFinished() - } + m.finishNetworkRequest(state) } } @@ -742,7 +752,7 @@ func (m *Monitor) proxyErrorRateLimited(sessionID, code, resourceType string) bo // the published enum lists it. The metro egress proxy gains codes on its own // release cadence, so a value this image does not know is reported as unknown // with the sanitized header value in raw_code rather than dropped. -func (m *Monitor) publishProxyError(sessionID, requestID, code string, status int, navSeq int64, method, resourceType string, url, frameID, loaderID *string) { +func (m *Monitor) publishProxyError(source oapi.BrowserEventSource, sessionID, requestID, code string, status int, navSeq int64, method, resourceType string, url, frameID, loaderID *string) { var rawCode *string if code == proxyErrorUnknownCode || !oapi.BrowserProxyErrorEventDataCode(code).Valid() { raw := sanitizeProxyErrorRawCode(code) @@ -771,16 +781,20 @@ func (m *Monitor) publishProxyError(sessionID, requestID, code string, status in RawCode: rawCode, ResourceType: optPtr(resourceType), }) - m.publishEvent(EventProxyError, events.Network, oapi.BrowserEventSource{Kind: oapi.Cdp}, "Network.responseReceived", data, sessionID) + m.publishEvent(EventProxyError, events.Network, source, "Network.responseReceived", data, sessionID) } func (m *Monitor) handleFrameNavigated(p cdpPageFrameNavigatedParams, sessionID string) { // Pre-fetch target info and computedState before acquiring pendReqMu to // avoid a pendReqMu → sessionsMu ordering cycle. - m.sessionsMu.RLock() - info := m.sessions[sessionID] + m.sessionsMu.Lock() + info, tracked := m.sessions[sessionID] cs := m.computedStates[sessionID] - m.sessionsMu.RUnlock() + if tracked && (p.Frame.ParentID == "" || p.Frame.ID == info.targetID) { + info.url = p.Frame.URL + m.sessions[sessionID] = info + } + m.sessionsMu.Unlock() if info.targetType == "iframe" && p.Frame.ParentID == "" { p.Frame.ParentID = info.parentFrameID @@ -811,18 +825,20 @@ func (m *Monitor) handleFrameNavigated(p cdpPageFrameNavigatedParams, sessionID } m.pendReqMu.Lock() - for id, req := range m.pendingRequests { - if req.sessionID == sessionID { - delete(m.pendingRequests, id) + inflight := 0 + for key, req := range m.pendingRequests { + if req.sessionID != sessionID { + continue } + req.countedNavSeq = -1 + if cs != nil && req.loaderID == p.Frame.LoaderID { + req.countedNavSeq = cs.currentNavSeq() + 1 + inflight++ + } + m.pendingRequests[key] = req } - // Reset while holding pendReqMu so new requests arriving concurrently - // can't increment netPending before the reset completes. - // inflight=0: remaining pendingRequests belong to other target sessions; - // their loadingFinished events decrement those sessions' own state machines, - // not this one, so we start fresh. if cs != nil { - if err := cs.resetOnNavigation(0, navCtx); err != nil { + if err := cs.resetOnNavigation(inflight, navCtx); err != nil { m.log.Error("cdpmonitor: failed to build nav event payload", "err", err) } } @@ -950,5 +966,10 @@ func (m *Monitor) handleDetachedFromTarget(p cdpTargetDetachedFromTargetParams) delete(m.pendingRequests, key) } } + for key := range m.networkExchanges { + if key.sessionID == p.SessionID { + delete(m.networkExchanges, key) + } + } m.pendReqMu.Unlock() } diff --git a/server/lib/cdpmonitor/monitor.go b/server/lib/cdpmonitor/monitor.go index 4e2cfa63d..f66e7809a 100644 --- a/server/lib/cdpmonitor/monitor.go +++ b/server/lib/cdpmonitor/monitor.go @@ -68,8 +68,9 @@ type Monitor struct { sessions map[string]targetInfo // sessionID → targetInfo mainSessionID atomic.Value // string; set on first top-level frameNavigated, cleared on reconnect - pendReqMu sync.Mutex - pendingRequests map[networkRequestKey]networkReqState + pendReqMu sync.Mutex + pendingRequests map[networkRequestKey]networkReqState + networkExchanges map[networkRequestKey]*networkExchange computedStates map[string]*computedState // sessionID → state machine; guarded by sessionsMu @@ -114,6 +115,7 @@ func New(upstreamMgr UpstreamProvider, publish PublishFunc, displayNum int, log sessions: make(map[string]targetInfo), computedStates: make(map[string]*computedState), pendingRequests: make(map[networkRequestKey]networkReqState), + networkExchanges: make(map[networkRequestKey]*networkExchange), bindingLastSeen: make(map[string]time.Time), proxyLastEmit: make(map[string]time.Time), lifecycleCtx: context.Background(), @@ -292,6 +294,21 @@ func (m *Monitor) handleSurfaceEvent(conn *monitorConnection, event browsersurfa case browsersurface.EventSessionRemoved: m.handleDetachedFromTarget(cdpTargetDetachedFromTargetParams{SessionID: event.SessionID}) case browsersurface.EventProtocol: + if event.Message.Method == "Target.targetInfoChanged" { + var p struct { + TargetInfo cdpTargetTargetInfo `json:"targetInfo"` + } + if json.Unmarshal(event.Message.Params, &p) == nil { + m.sessionsMu.Lock() + for id, info := range m.sessions { + if info.targetID == p.TargetInfo.TargetID { + info.url, info.title = p.TargetInfo.URL, p.TargetInfo.Title + m.sessions[id] = info + } + } + m.sessionsMu.Unlock() + } + } if event.Message.Method == "Target.targetDestroyed" { var p struct { TargetID string `json:"targetId"` @@ -345,6 +362,7 @@ func (m *Monitor) clearState() { m.mainSessionID.Store(mainSessionUnset) m.pendReqMu.Lock() m.pendingRequests = make(map[networkRequestKey]networkReqState) + clear(m.networkExchanges) m.pendReqMu.Unlock() m.bindingRateMu.Lock() m.bindingLastSeen = make(map[string]time.Time) @@ -374,11 +392,14 @@ func (m *Monitor) sweepPendingRequests(ctx context.Context) { toSweep = append(toSweep, state) } } + for key, exchange := range m.networkExchanges { + if now.Sub(exchange.addedAt) > pendingRequestTTL { + delete(m.networkExchanges, key) + } + } m.pendReqMu.Unlock() for _, state := range toSweep { - if cs := m.computedFor(state.sessionID); cs != nil { - cs.onLoadingFinished() - } + m.finishNetworkRequest(state) } } } diff --git a/server/lib/cdpmonitor/network_capture.go b/server/lib/cdpmonitor/network_capture.go new file mode 100644 index 000000000..252291f19 --- /dev/null +++ b/server/lib/cdpmonitor/network_capture.go @@ -0,0 +1,278 @@ +package cdpmonitor + +import ( + "context" + "encoding/json" + "net/http" + "time" + + "github.com/kernel/kernel-images/server/lib/events" + "github.com/kernel/kernel-images/server/lib/oapi" +) + +const ( + networkHeaderWait = time.Second + maxOrphanExchanges = 8192 + maxExtraInfoPerExchange = 64 + durableBodyBufferSize = 10 * 1024 * 1024 +) + +// Chrome emits base events and ExtraInfo on independent streams. Redirects reuse +// request IDs; only hops whose response advertises ExtraInfo consume those queues. +// All exchange and hop fields are protected by pendReqMu. +type networkExchange struct { + addedAt time.Time + hops []*networkHop + requests []json.RawMessage + responses []cdpNetworkResponseReceivedExtraInfoParams + failed bool +} + +type networkHop struct { + exchange *networkExchange + request oapi.BrowserNetworkRequestEventData + source oapi.BrowserEventSource + known bool + hasExtra bool + requestHeaders json.RawMessage + responseExtra *cdpNetworkResponseReceivedExtraInfoParams + requestReady chan struct{} + responseReady chan struct{} + requestMatched bool + responseMatched bool + requestPublished bool +} + +func (m *Monitor) exchangeLocked(key networkRequestKey) *networkExchange { + e := m.networkExchanges[key] + if e == nil { + e = &networkExchange{addedAt: time.Now()} + m.networkExchanges[key] = e + } + return e +} + +func (m *Monitor) queueNetworkRequestLocked(key networkRequestKey, request oapi.BrowserNetworkRequestEventData, info targetInfo) *networkHop { + e := m.exchangeLocked(key) + metadata := targetMetadata(info) + h := &networkHop{ + exchange: e, + request: request, + source: oapi.BrowserEventSource{Kind: oapi.Cdp, Metadata: &metadata}, + requestReady: make(chan struct{}), + responseReady: make(chan struct{}), + } + e.hops = append(e.hops, h) + return h +} + +func (m *Monitor) handleRequestExtraInfo(p cdpNetworkRequestWillBeSentExtraInfoParams, sessionID string) { + key := networkRequestKey{sessionID, p.RequestID} + m.pendReqMu.Lock() + defer m.pendReqMu.Unlock() + if m.networkExchanges[key] == nil && len(m.networkExchanges) >= maxOrphanExchanges { + return + } + e := m.exchangeLocked(key) + if len(e.requests) >= maxExtraInfoPerExchange { + return + } + e.requests = append(e.requests, p.Headers) + e.matchHeaders() +} + +func (m *Monitor) handleResponseExtraInfo(p cdpNetworkResponseReceivedExtraInfoParams, sessionID string) { + key := networkRequestKey{sessionID, p.RequestID} + m.pendReqMu.Lock() + defer m.pendReqMu.Unlock() + if m.networkExchanges[key] == nil && len(m.networkExchanges) >= maxOrphanExchanges { + return + } + e := m.exchangeLocked(key) + if len(e.responses) >= maxExtraInfoPerExchange { + return + } + e.responses = append(e.responses, p) + e.matchHeaders() +} + +func (m *Monitor) resolveNetworkHeadersLocked(h *networkHop, hasExtra bool) { + if h == nil { + return + } + h.known, h.hasExtra = true, hasExtra + h.exchange.matchHeaders() +} + +func (m *Monitor) resolveFailedHeadersLocked(h *networkHop) { + if h == nil { + return + } + h.exchange.failed = true + // CORS failures can have ExtraInfo without a responseReceived event. + if !h.known { + h.known, h.hasExtra = true, true + } + h.exchange.matchHeaders() + if h.requestPublished { + delete(m.networkExchanges, networkRequestKey{h.request.SessionId, h.request.RequestId}) + } +} + +func (e *networkExchange) matchHeaders() { + for _, h := range e.hops { + if !h.known { + break + } + if h.requestMatched { + continue + } + if h.hasExtra { + if len(e.requests) == 0 { + break + } + h.requestHeaders, e.requests = e.requests[0], e.requests[1:] + } + h.requestMatched = true + close(h.requestReady) + } + for _, h := range e.hops { + if !h.known { + break + } + if h.responseMatched { + continue + } + if h.hasExtra { + if len(e.responses) == 0 { + break + } + extra := e.responses[0] + h.responseExtra, e.responses = &extra, e.responses[1:] + } + h.responseMatched = true + close(h.responseReady) + } +} + +func waitNetworkHeaders(ctx context.Context, ready ...<-chan struct{}) { + timer := time.NewTimer(networkHeaderWait) + defer timer.Stop() + for _, ch := range ready { + select { + case <-ch: + case <-ctx.Done(): + return + case <-timer.C: + return + } + } +} + +func (m *Monitor) publishNetworkRequest(ctx context.Context, key networkRequestKey, h *networkHop) { + m.telemetryWg.Go(func() { + waitNetworkHeaders(ctx, h.requestReady) + m.pendReqMu.Lock() + payload := h.request + if h.requestHeaders != nil { + payload.Headers = nil + _ = json.Unmarshal(h.requestHeaders, &payload.Headers) + } + h.requestPublished = true + if h.exchange.failed && m.networkExchanges[key] == h.exchange { + delete(m.networkExchanges, key) + } + m.pendReqMu.Unlock() + data, _ := json.Marshal(payload) + m.publishEvent(EventNetworkRequest, events.Network, h.source, "Network.requestWillBeSent", data, key.sessionID) + }) +} + +func (m *Monitor) emitNetworkResponse(ctx context.Context, key networkRequestKey, state networkReqState, info targetInfo, redirect bool) { + m.telemetryWg.Go(func() { + // Fetch before waiting for ExtraInfo so header ordering cannot delay retrieval. + var body string + var bodyErr error + if !redirect { + body, bodyErr = m.fetchResponseBody(ctx, key.requestID, key.sessionID, state) + } + h := state.hop + if h != nil { + waitNetworkHeaders(ctx, h.requestReady, h.responseReady) + } + var headers oapi.BrowserHttpHeaders + _ = json.Unmarshal(state.resHeaders, &headers) + payload := oapi.BrowserNetworkResponseEventData{ + SessionId: key.sessionID, + TargetId: info.targetID, + TargetType: oapi.BrowserTargetType(info.targetType), + FrameId: ptrOf(state.frameID), + LoaderId: ptrOf(state.loaderID), + Url: ptrOf(state.url), + NavSeq: state.navSeq, + RequestId: key.requestID, + Method: state.method, + Status: state.status, + Headers: headers, + StatusText: optPtr(state.statusText), + MimeType: optPtr(state.mimeType), + ResourceType: optPtr(state.resourceType), + Body: optPtr(body), + } + if bodyErr != nil { + payload.BodyError = ptrOf(bodyErr.Error()) + } + metadata := targetMetadata(info) + source := oapi.BrowserEventSource{Kind: oapi.Cdp, Metadata: &metadata} + if h != nil { + source = h.source + m.pendReqMu.Lock() + if h.requestHeaders != nil { + var requestHeaders oapi.BrowserHttpHeaders + _ = json.Unmarshal(h.requestHeaders, &requestHeaders) + payload.RequestHeaders = &requestHeaders + } + if h.responseExtra != nil { + payload.Headers = nil + _ = json.Unmarshal(h.responseExtra.Headers, &payload.Headers) + payload.Status = h.responseExtra.StatusCode + if payload.Status != state.status { + payload.EffectiveStatus = ptrOf(state.status) + payload.StatusText = optPtr(http.StatusText(payload.Status)) + } + } + if !redirect && m.networkExchanges[key] == h.exchange { + delete(m.networkExchanges, key) + } + m.pendReqMu.Unlock() + } + data, _ := json.Marshal(payload) + event := "Network.loadingFinished" + if redirect { + event = "Network.requestWillBeSent" + } + m.publishEvent(EventNetworkResponse, events.Network, source, event, data, key.sessionID) + }) +} + +func (m *Monitor) finishNetworkRequest(state networkReqState) { + if cs := m.computedFor(state.sessionID); cs != nil { + m.pendReqMu.Lock() + defer m.pendReqMu.Unlock() + cs.mu.Lock() + sameNavigation := state.countedNavSeq == cs.navSeq + cs.mu.Unlock() + if sameNavigation { + cs.onLoadingFinished() + } + } +} + +func (m *Monitor) configureBodyCapture(ctx context.Context, sessionID string, enabled bool) error { + size := 0 + if enabled { + size = durableBodyBufferSize + } + _, err := m.send(ctx, "Network.enable", map[string]any{"enableDurableMessages": enabled, "maxTotalBufferSize": size}, sessionID) + return err +} diff --git a/server/lib/cdpmonitor/telemetry.go b/server/lib/cdpmonitor/telemetry.go index 587a4987b..8a9b20dda 100644 --- a/server/lib/cdpmonitor/telemetry.go +++ b/server/lib/cdpmonitor/telemetry.go @@ -94,6 +94,7 @@ func (m *Monitor) applyTelemetry(state uint64) error { m.computedPublishMu.Unlock() m.pendReqMu.Lock() clear(m.pendingRequests) + clear(m.networkExchanges) m.pendReqMu.Unlock() m.mainSessionID.Store(mainSessionUnset) m.bindingRateMu.Lock() @@ -176,6 +177,9 @@ func (m *Monitor) enableOptionalCapture(ctx context.Context, sessionID string, i m.preparePageCapture(sessionID, info) ctx, cancel := context.WithTimeout(ctx, sendTimeout) defer cancel() + if err := m.configureBodyCapture(ctx, sessionID, true); err != nil && ctx.Err() == nil { + m.log.Warn("cdpmonitor: durable body capture unavailable", "session", sessionID, "err", err) + } m.enableDomains(ctx, sessionID, info.targetType) if isPageLikeTarget(info.targetType) { var rejection *cdpclient.Error diff --git a/server/lib/cdpmonitor/types.go b/server/lib/cdpmonitor/types.go index 98826012c..f9905c1ad 100644 --- a/server/lib/cdpmonitor/types.go +++ b/server/lib/cdpmonitor/types.go @@ -112,20 +112,22 @@ type networkRequestKey struct { // networkReqState holds request + response metadata until loadingFinished. type networkReqState struct { - sessionID string - method string - url string - headers json.RawMessage - postData string - resourceType string - loaderID string - frameID string - navSeq int64 - status int - statusText string - resHeaders json.RawMessage - mimeType string - addedAt time.Time // for TTL eviction + sessionID string + method string + url string + headers json.RawMessage + postData string + resourceType string + loaderID string + frameID string + navSeq int64 + countedNavSeq int + status int + statusText string + resHeaders json.RawMessage + mimeType string + addedAt time.Time // for TTL eviction + hop *networkHop } // navContext carries the identity of the navigation that owns a computedState. diff --git a/server/openapi.yaml b/server/openapi.yaml index 94f668576..5b0dd04de 100644 --- a/server/openapi.yaml +++ b/server/openapi.yaml @@ -2459,7 +2459,7 @@ components: description: URL of the document that initiated the request. headers: $ref: "#/components/schemas/BrowserHttpHeaders" - description: Request headers. + description: Request headers, enriched with wire headers when available before publication. resource_type: type: string description: CDP Network.ResourceType for the request, passed through as-is from Chrome. Known values include Document, Fetch, XHR, Script, Stylesheet, Image, Media, Font, TextTrack, EventSource, WebSocket, Manifest, Prefetch, Other, and more. @@ -2511,7 +2511,7 @@ components: description: HTTP method of the original request. status: type: integer - description: HTTP response status code. + description: HTTP response status code on the wire when available, otherwise the effective CDP status. status_text: type: string description: HTTP response status text (e.g. OK, Not Found). @@ -2524,12 +2524,21 @@ components: resource_type: type: string description: CDP Network.ResourceType for the request, passed through as-is from Chrome. Known values include Document, Fetch, XHR, Script, Stylesheet, Image, Media, Font, TextTrack, EventSource, WebSocket, Manifest, Prefetch, Other, and more. + request_headers: + $ref: "#/components/schemas/BrowserHttpHeaders" + description: Wire request headers when available, including headers that arrived after network_request was published. + effective_status: + type: integer + description: Effective CDP status when different from the wire status, such as 200 for a revalidated 304 response. body: type: string description: Truncated response body, present only for text MIME types. + body_error: + type: string + description: Response body retrieval or decoding error. Absent for successfully retrieved or intentionally excluded bodies. BrowserNetworkResponseEvent: type: object - description: A browser network response received event. Fired after the response body is fully received, not when headers arrive. + description: A browser network response received event. Fired after the response body is fully received, or when a redirect advances to the next request. required: [ts, type, category, source] properties: ts: From edee7a4fd369f42c801537d40cea4200011c470b Mon Sep 17 00:00:00 2001 From: Sayan- <1415138+Sayan-@users.noreply.github.com> Date: Wed, 14 Oct 2026 21:47:12 +0000 Subject: [PATCH 02/15] Cover network capture fidelity and lifecycle regressions --- server/lib/cdpmonitor/cdp_proto_test.go | 2 + server/lib/cdpmonitor/cdp_test.go | 5 +- server/lib/cdpmonitor/handlers_test.go | 4 +- server/lib/cdpmonitor/network_capture_test.go | 260 +++++++++++++++ server/lib/cdpmonitor/network_cleanup_test.go | 33 ++ .../network_fidelity_chrome_e2e_test.go | 295 ++++++++++++++++++ server/lib/cdpmonitor/surface_events_test.go | 5 +- .../Network_requestWillBeSentExtraInfo.json | 9 + .../Network_responseReceivedExtraInfo.json | 11 + 9 files changed, 616 insertions(+), 8 deletions(-) create mode 100644 server/lib/cdpmonitor/network_capture_test.go create mode 100644 server/lib/cdpmonitor/network_fidelity_chrome_e2e_test.go create mode 100644 server/lib/cdpmonitor/testdata/Network_requestWillBeSentExtraInfo.json create mode 100644 server/lib/cdpmonitor/testdata/Network_responseReceivedExtraInfo.json diff --git a/server/lib/cdpmonitor/cdp_proto_test.go b/server/lib/cdpmonitor/cdp_proto_test.go index 7a9d04900..0c9f535b3 100644 --- a/server/lib/cdpmonitor/cdp_proto_test.go +++ b/server/lib/cdpmonitor/cdp_proto_test.go @@ -29,6 +29,8 @@ func TestLayer1Roundtrip(t *testing.T) { {"Runtime.exceptionThrown", "Runtime_exceptionThrown.json", func() any { return new(cdpRuntimeExceptionThrownParams) }}, {"Runtime.bindingCalled", "Runtime_bindingCalled.json", func() any { return new(cdpRuntimeBindingCalledParams) }}, {"Network.requestWillBeSent", "Network_requestWillBeSent.json", func() any { return new(cdpNetworkRequestWillBeSentParams) }}, + {"Network.requestWillBeSentExtraInfo", "Network_requestWillBeSentExtraInfo.json", func() any { return new(cdpNetworkRequestWillBeSentExtraInfoParams) }}, + {"Network.responseReceivedExtraInfo", "Network_responseReceivedExtraInfo.json", func() any { return new(cdpNetworkResponseReceivedExtraInfoParams) }}, {"Network.responseReceived", "Network_responseReceived.json", func() any { return new(cdpNetworkResponseReceivedParams) }}, {"Network.loadingFinished", "Network_loadingFinished.json", func() any { return new(cdpNetworkLoadingFinishedParams) }}, {"Network.loadingFailed", "Network_loadingFailed.json", func() any { return new(cdpNetworkLoadingFailedParams) }}, diff --git a/server/lib/cdpmonitor/cdp_test.go b/server/lib/cdpmonitor/cdp_test.go index 11096facd..6694445aa 100644 --- a/server/lib/cdpmonitor/cdp_test.go +++ b/server/lib/cdpmonitor/cdp_test.go @@ -390,10 +390,7 @@ func simulateRequest(m *Monitor, id string) { }, "s1") } -// simulateFinished stores minimal state and sends Network.loadingFinished. +// simulateFinished completes the request without replacing its captured state. func simulateFinished(m *Monitor, id string) { - m.pendReqMu.Lock() - m.pendingRequests[networkRequestKey{"s1", id}] = networkReqState{sessionID: "s1", method: "GET", url: "https://example.com/" + id} - m.pendReqMu.Unlock() m.handleLoadingFinished(context.Background(), cdpNetworkLoadingFinishedParams{RequestID: id}, "s1") } diff --git a/server/lib/cdpmonitor/handlers_test.go b/server/lib/cdpmonitor/handlers_test.go index 02e4ff6e0..dfb0d8c03 100644 --- a/server/lib/cdpmonitor/handlers_test.go +++ b/server/lib/cdpmonitor/handlers_test.go @@ -410,8 +410,8 @@ func TestNetworkEvents(t *testing.T) { func TestProxyErrorUnknownCodesShareRateLimit(t *testing.T) { collector := newEventCollector() monitor := New(newTestUpstream(""), collector.publishFn(), 0, discardLogger, nil) - monitor.publishProxyError("sess", "req-a", "future_a", 502, 0, "GET", "Document", nil, nil, nil) - monitor.publishProxyError("sess", "req-b", "future_b", 502, 0, "GET", "Document", nil, nil, nil) + monitor.publishProxyError(oapi.BrowserEventSource{Kind: oapi.Cdp}, "sess", "req-a", "future_a", 502, 0, "GET", "Document", nil, nil, nil) + monitor.publishProxyError(oapi.BrowserEventSource{Kind: oapi.Cdp}, "sess", "req-b", "future_b", 502, 0, "GET", "Document", nil, nil, nil) collector.mu.Lock() defer collector.mu.Unlock() diff --git a/server/lib/cdpmonitor/network_capture_test.go b/server/lib/cdpmonitor/network_capture_test.go new file mode 100644 index 000000000..163ac4527 --- /dev/null +++ b/server/lib/cdpmonitor/network_capture_test.go @@ -0,0 +1,260 @@ +package cdpmonitor + +import ( + "context" + "encoding/json" + "fmt" + "testing" + "time" + + "github.com/kernel/kernel-images/server/lib/browsersurface" + "github.com/kernel/kernel-images/server/lib/cdpclient" + "github.com/kernel/kernel-images/server/lib/oapi" + "github.com/stretchr/testify/require" +) + +func sendNetworkFixture(t *testing.T, srv *testServer, method string, params any) { + t.Helper() + srv.sendToMonitor(t, map[string]any{"method": method, "params": params}) +} + +func TestNetworkHeadersFollowRedirectHops(t *testing.T) { + for _, order := range []string{"extras_first", "extras_last", "interleaved"} { + t.Run(order, func(t *testing.T) { + srv := newTestServer(t) + defer srv.close() + _, ec, cleanup := startMonitor(t, srv, nil) + defer cleanup() + send := func(method string, params any) { sendNetworkFixture(t, srv, method, params) } + extra := func(index int) { + send("Network.requestWillBeSentExtraInfo", map[string]any{"requestId": "r", "headers": map[string]string{"Cookie": fmt.Sprintf("hop=%d", index)}}) + send("Network.responseReceivedExtraInfo", map[string]any{"requestId": "r", "statusCode": []int{302, 200}[index], "headers": map[string]string{"X-Hop": fmt.Sprint(index)}}) + } + if order == "extras_first" { + extra(0) + extra(1) + } + send("Network.requestWillBeSent", cdpNetworkRequestWillBeSentParams{RequestID: "r", Request: cdpNetworkRequest{Method: "GET", URL: "https://example.com/start"}}) + if order == "interleaved" { + extra(0) + } + send("Network.requestWillBeSent", cdpNetworkRequestWillBeSentParams{RequestID: "r", RedirectHasExtraInfo: true, RedirectResponse: json.RawMessage(`{"status":302,"headers":{"Base":"redirect"}}`), Request: cdpNetworkRequest{Method: "GET", URL: "https://example.com/cached"}}) + // A cached redirect has no ExtraInfo; it must not consume the next hop's headers. + send("Network.requestWillBeSent", cdpNetworkRequestWillBeSentParams{RequestID: "r", RedirectResponse: json.RawMessage(`{"status":301,"headers":{"Base":"cached"}}`), Request: cdpNetworkRequest{Method: "GET", URL: "https://example.com/final"}}) + if order == "interleaved" { + extra(1) + } + send("Network.responseReceived", cdpNetworkResponseReceivedParams{RequestID: "r", HasExtraInfo: true, Response: cdpNetworkResponse{Status: 200}}) + send("Network.loadingFinished", cdpNetworkLoadingFinishedParams{RequestID: "r"}) + if order == "extras_last" { + extra(0) + extra(1) + } + for _, tc := range []struct { + path, cookie, header string + status int + }{{"start", "hop=0", "0", 302}, {"cached", "", "", 301}, {"final", "hop=1", "1", 200}} { + req := waitForNetworkURL(t, ec, EventNetworkRequest, "https://example.com/"+tc.path) + var request oapi.BrowserNetworkRequestEventData + require.NoError(t, json.Unmarshal(req.Data, &request)) + res := waitForNetworkURL(t, ec, EventNetworkResponse, "https://example.com/"+tc.path) + var response oapi.BrowserNetworkResponseEventData + require.NoError(t, json.Unmarshal(res.Data, &response)) + require.Equal(t, tc.status, response.Status) + if tc.cookie != "" { + require.Equal(t, tc.cookie, request.Headers["Cookie"]) + require.NotNil(t, response.RequestHeaders) + require.Equal(t, tc.cookie, (*response.RequestHeaders)["Cookie"]) + require.Equal(t, tc.header, response.Headers["X-Hop"]) + } else { + require.NotContains(t, request.Headers, "Cookie") + require.Nil(t, response.RequestHeaders) + require.Equal(t, "cached", response.Headers["Base"]) + } + } + }) + } +} + +func TestNetworkLateHeadersRemainOnResponse(t *testing.T) { + srv := newTestServer(t) + defer srv.close() + _, ec, cleanup := startMonitor(t, srv, nil) + defer cleanup() + sendNetworkFixture(t, srv, "Network.requestWillBeSent", cdpNetworkRequestWillBeSentParams{RequestID: "r", Request: cdpNetworkRequest{Method: "GET", URL: "https://example.com/slow", Headers: json.RawMessage(`{"Base":"value"}`)}}) + // A hanging request is still visible without waiting for a server response. + request := ec.waitFor(t, EventNetworkRequest, 2*time.Second) + var data oapi.BrowserNetworkRequestEventData + require.NoError(t, json.Unmarshal(request.Data, &data)) + require.Equal(t, "value", data.Headers["Base"]) + sendNetworkFixture(t, srv, "Network.requestWillBeSentExtraInfo", map[string]any{"requestId": "r", "headers": map[string]string{"Cookie": "late=true"}}) + sendNetworkFixture(t, srv, "Network.responseReceived", cdpNetworkResponseReceivedParams{RequestID: "r", HasExtraInfo: true, Response: cdpNetworkResponse{Status: 200}}) + sendNetworkFixture(t, srv, "Network.loadingFinished", cdpNetworkLoadingFinishedParams{RequestID: "r"}) + sendNetworkFixture(t, srv, "Network.responseReceivedExtraInfo", map[string]any{"requestId": "r", "headers": map[string]string{"X-Wire": "yes"}, "statusCode": 200}) + response := ec.waitFor(t, EventNetworkResponse, 2*time.Second) + var payload oapi.BrowserNetworkResponseEventData + require.NoError(t, json.Unmarshal(response.Data, &payload)) + require.NotNil(t, payload.RequestHeaders) + require.Equal(t, "late=true", (*payload.RequestHeaders)["Cookie"]) + require.Equal(t, "yes", payload.Headers["X-Wire"]) + ec.mu.Lock() + defer ec.mu.Unlock() + count := 0 + for _, event := range ec.events { + if event.Type == EventNetworkRequest { + count++ + } + } + require.Equal(t, 1, count, "late headers must not duplicate the request event") +} + +func TestNetworkBodyErrorsAreObservable(t *testing.T) { + srv := newTestServer(t) + defer srv.close() + _, ec, cleanup := startMonitor(t, srv, func(msg cdpMessage) any { + if msg.Method == "Network.getResponseBody" { + return map[string]any{"id": msg.ID, "error": map[string]any{"code": -32000, "message": "No resource with given identifier found"}} + } + return nil + }) + defer cleanup() + sendNetworkFixture(t, srv, "Network.requestWillBeSent", cdpNetworkRequestWillBeSentParams{RequestID: "r", Type: "Fetch", Request: cdpNetworkRequest{Method: "GET", URL: "https://example.com/api"}}) + sendNetworkFixture(t, srv, "Network.responseReceived", cdpNetworkResponseReceivedParams{RequestID: "r", Response: cdpNetworkResponse{Status: 200, MimeType: "application/json"}}) + sendNetworkFixture(t, srv, "Network.loadingFinished", cdpNetworkLoadingFinishedParams{RequestID: "r"}) + event := ec.waitFor(t, EventNetworkResponse, time.Second) + var response oapi.BrowserNetworkResponseEventData + require.NoError(t, json.Unmarshal(event.Data, &response)) + require.NotNil(t, response.BodyError) + require.Contains(t, *response.BodyError, "No resource with given identifier found") + require.Nil(t, response.Body) + require.Equal(t, 200, response.Status) +} + +func TestNavigationPreservesPendingResponsesAndIdleAccounting(t *testing.T) { + m, ec := newComputedMonitor(t) + defer m.Stop() + navigateMonitor(m, "https://example.com/old") + request := func(id, loader string) { + m.handleNetworkRequest(cdpNetworkRequestWillBeSentParams{RequestID: id, LoaderID: loader, Request: cdpNetworkRequest{Method: "GET", URL: "https://example.com/" + id}}, "s1") + } + request("old", "") + request("document", "new-loader") + m.handleResponseReceived(cdpNetworkResponseReceivedParams{RequestID: "document", Response: cdpNetworkResponse{Status: 200}}, "s1") + m.handleFrameNavigated(cdpPageFrameNavigatedParams{Frame: cdpPageFrame{ID: "f1", LoaderID: "new-loader", URL: "https://example.com/new"}}, "s1") + m.handleLoadingFinished(context.Background(), cdpNetworkLoadingFinishedParams{RequestID: "old"}, "s1") + // Finishing the previous loader must not make the new document idle. + checkpoint := ec.checkpoint() + ec.assertNone(t, EventNetworkIdle, checkpoint, 600*time.Millisecond) + m.handleLoadingFinished(context.Background(), cdpNetworkLoadingFinishedParams{RequestID: "document"}, "s1") + event := waitForNetworkURL(t, ec, EventNetworkResponse, "https://example.com/document") + var response oapi.BrowserNetworkResponseEventData + require.NoError(t, json.Unmarshal(event.Data, &response)) + require.Equal(t, 200, response.Status) + ec.waitForNew(t, EventNetworkIdle, checkpoint, time.Second) +} + +func TestExtensionSourceIdentifiesBundledAndCustomTargets(t *testing.T) { + for _, tc := range []struct{ url, id, managed string }{ + {"https://example.com/worker.js", "", ""}, + {"chrome-extension://aiefahdofckmjaelnjpjkffghapmnlof/background.js", "aiefahdofckmjaelnjpjkffghapmnlof", "true"}, + {"chrome-extension://" + unpackedExtensionID("/home/kernel/extensions/kernel") + "/background.js", unpackedExtensionID("/home/kernel/extensions/kernel"), "true"}, + {"chrome-extension://aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/background.js", "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "false"}, + } { + t.Run(tc.url, func(t *testing.T) { + metadata := targetMetadata(targetInfo{url: tc.url, targetType: "service_worker", targetID: "target"}) + require.Equal(t, tc.id, metadata["extension_id"]) + require.Equal(t, tc.managed, metadata["kernel_extension"]) + }) + } +} + +func TestSameProcessFrameRequestsParticipateInNetworkIdle(t *testing.T) { + m, ec := newComputedMonitor(t) + defer m.Stop() + navigateMonitor(m, "https://example.com/") + m.handleNetworkRequest(cdpNetworkRequestWillBeSentParams{RequestID: "child", LoaderID: "iframe-loader", FrameID: "child", Request: cdpNetworkRequest{Method: "GET", URL: "https://example.com/child"}}, "s1") + ec.assertNone(t, EventNetworkIdle, 0, 600*time.Millisecond) + m.handleLoadingFinished(context.Background(), cdpNetworkLoadingFinishedParams{RequestID: "child"}, "s1") + ec.waitFor(t, EventNetworkIdle, time.Second) +} + +func TestNetworkSourceSurvivesOriginChanges(t *testing.T) { + m, ec := newComputedMonitor(t) + defer m.Stop() + navigateMonitor(m, "about:blank") + extension := "chrome-extension://aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/page.html" + for index, document := range []string{extension, "https://example.com/"} { + id := fmt.Sprint(index) + m.handleNetworkRequest(cdpNetworkRequestWillBeSentParams{ + RequestID: id, DocumentURL: document, + Request: cdpNetworkRequest{Method: "GET", URL: document}, + }, "s1") + // Publication is delayed until after the next document replaces the target URL. + next := "https://example.com/" + if index == 1 { + next = extension + } + m.handleFrameNavigated(cdpPageFrameNavigatedParams{Frame: cdpPageFrame{ID: "f1", URL: next}}, "s1") + m.handleResponseReceived(cdpNetworkResponseReceivedParams{RequestID: id, Response: cdpNetworkResponse{Status: 200}}, "s1") + m.handleLoadingFinished(context.Background(), cdpNetworkLoadingFinishedParams{RequestID: id}, "s1") + for _, typ := range []string{EventNetworkRequest, EventNetworkResponse} { + event := waitForNetworkURL(t, ec, typ, document) + if index == 0 { + require.Equal(t, "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", (*event.Source.Metadata)["extension_id"]) + } else { + require.NotContains(t, *event.Source.Metadata, "extension_id") + require.NotContains(t, *event.Source.Metadata, "kernel_extension") + } + } + } +} + +func TestExtensionSourceTracksTargetAndRootFrameNavigation(t *testing.T) { + m, ec := newComputedMonitor(t) + defer m.Stop() + navigateMonitor(m, "about:blank") + extension := "chrome-extension://aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/page.html" + m.handleFrameNavigated(cdpPageFrameNavigatedParams{Frame: cdpPageFrame{ID: "f1", URL: extension}}, "s1") + m.handleFrameNavigated(cdpPageFrameNavigatedParams{Frame: cdpPageFrame{ID: "child", ParentID: "f1", URL: "https://example.com/"}}, "s1") + m.handleTargetCrashed("s1") + event := ec.waitFor(t, EventPageCrashed, time.Second) + require.Equal(t, "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", (*event.Source.Metadata)["extension_id"], "a child frame must not change the target origin") + + params, err := json.Marshal(map[string]any{"targetInfo": cdpTargetTargetInfo{TargetID: m.sessions["s1"].targetID, URL: "https://example.com/"}}) + require.NoError(t, err) + m.handleSurfaceEvent(nil, browsersurface.Event{Kind: browsersurface.EventProtocol, Message: cdpclient.Message{Method: "Target.targetInfoChanged", Params: params}}) + checkpoint := ec.checkpoint() + m.handleTargetCrashed("s1") + event = ec.waitForNew(t, EventPageCrashed, checkpoint, time.Second) + require.NotContains(t, *event.Source.Metadata, "extension_id") +} + +func TestProxyErrorSourceSurvivesOriginChanges(t *testing.T) { + extension := "chrome-extension://aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/page.html" + for _, document := range []string{extension, "https://example.com/"} { + t.Run(document, func(t *testing.T) { + m, ec := newComputedMonitor(t) + defer m.Stop() + navigateMonitor(m, document) + m.handleNetworkRequest(cdpNetworkRequestWillBeSentParams{ + RequestID: "r", DocumentURL: document, + Request: cdpNetworkRequest{Method: "GET", URL: "https://example.com/api"}, + }, "s1") + next := extension + if document == extension { + next = "https://example.com/" + } + navigateMonitor(m, next) + m.handleResponseReceived(cdpNetworkResponseReceivedParams{ + RequestID: "r", Response: cdpNetworkResponse{Status: 403, Headers: json.RawMessage(`{"x-kernel-proxy-error":"network_policy_denied"}`)}, + }, "s1") + event := ec.waitFor(t, EventProxyError, time.Second) + if document == extension { + require.Equal(t, "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", (*event.Source.Metadata)["extension_id"]) + } else { + require.NotContains(t, *event.Source.Metadata, "extension_id") + require.NotContains(t, *event.Source.Metadata, "kernel_extension") + } + }) + } +} diff --git a/server/lib/cdpmonitor/network_cleanup_test.go b/server/lib/cdpmonitor/network_cleanup_test.go index 468ffee8e..d9d473166 100644 --- a/server/lib/cdpmonitor/network_cleanup_test.go +++ b/server/lib/cdpmonitor/network_cleanup_test.go @@ -2,13 +2,46 @@ package cdpmonitor import ( "context" + "encoding/json" "sync" + "sync/atomic" "testing" "time" "github.com/stretchr/testify/require" ) +func TestDurableBodyDisableFailureReplacesConnection(t *testing.T) { + srv := newTestServer(t) + defer srv.close() + var failed atomic.Bool + m, _, cleanup := startMonitor(t, srv, func(msg cdpMessage) any { + var params struct { + EnableDurableMessages *bool `json:"enableDurableMessages"` + } + if msg.Method == "Network.enable" && json.Unmarshal(msg.Params, ¶ms) == nil && params.EnableDurableMessages != nil && !*params.EnableDurableMessages { + failed.Store(true) + return map[string]any{"id": msg.ID, "error": map[string]any{"code": -32000, "message": "fixture disable failure"}} + } + return nil + }) + defer cleanup() + srv.sendToMonitor(t, map[string]any{"method": "Target.attachedToTarget", "params": map[string]any{"sessionId": "s", "targetInfo": map[string]any{"targetId": "t", "type": "page"}}}) + require.Eventually(t, func() bool { + m.sessionsMu.RLock() + defer m.sessionsMu.RUnlock() + return m.optionalSessions["s"] == "test-script" + }, time.Second, time.Millisecond) + m.lifeMu.Lock() + old := m.conn + m.lifeMu.Unlock() + require.NoError(t, m.SetTelemetry(false)) + require.Eventually(t, func() bool { return failed.Load() && old.ctx.Err() != nil }, time.Second, time.Millisecond) + waitForTelemetryReconcile(t, m, false) + // A replacement connection releases session-owned body storage. + require.False(t, m.captureEnabled()) +} + func TestTelemetryCleanupAttemptsAllSessionsAfterError(t *testing.T) { srv := newTestServer(t) defer srv.close() diff --git a/server/lib/cdpmonitor/network_fidelity_chrome_e2e_test.go b/server/lib/cdpmonitor/network_fidelity_chrome_e2e_test.go new file mode 100644 index 000000000..2b00bb05c --- /dev/null +++ b/server/lib/cdpmonitor/network_fidelity_chrome_e2e_test.go @@ -0,0 +1,295 @@ +package cdpmonitor + +import ( + "context" + "encoding/json" + "fmt" + "net/http" + "net/http/httptest" + "os" + "path/filepath" + "strings" + "sync" + "testing" + "time" + + "github.com/kernel/kernel-images/server/lib/cdpclient" + "github.com/kernel/kernel-images/server/lib/oapi" + "github.com/stretchr/testify/require" +) + +func TestNetworkWireCapture(t *testing.T) { + if os.Getenv("KERNEL_CDPMONITOR_CHROME_E2E") == "" { + t.Skip("set KERNEL_CDPMONITOR_CHROME_E2E=1 to run real-Chromium network tests") + } + ctx, cancel := context.WithTimeout(context.Background(), 40*time.Second) + defer cancel() + var mu sync.Mutex + var wireHeaders http.Header + var statuses []int + stub := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + switch r.URL.Path { + case "/api": + mu.Lock() + wireHeaders = r.Header.Clone() + wireHeaders.Set("Host", r.Host) + status := 200 + if r.Header.Get("If-None-Match") != "" { + status = 304 + } + statuses = append(statuses, status) + mu.Unlock() + w.Header().Set("Content-Type", "application/json") + w.Header().Set("ETag", `"v1"`) + w.Header().Set("Cache-Control", "no-cache") + w.WriteHeader(status) + if status == 200 { + fmt.Fprint(w, `{"ok":true}`) + } + default: + w.Header().Set("Content-Type", "text/html") + fmt.Fprint(w, "local reproduction") + } + })) + defer stub.Close() + ws := launchChromium(t, ctx, findChromium(t), "--site-per-process") + driver := dialCDP(t, ctx, ws) + defer driver.close() + target := driver.call(t, ctx, "", "Target.createTarget", map[string]any{"url": "about:blank"}).targetID(t) + session := driver.call(t, ctx, "", "Target.attachToTarget", map[string]any{"targetId": target, "flatten": true}).sessionID(t) + ec := newEventCollector() + m := New(&staticUpstream{url: ws}, ec.publishFn(), 99, discardLogger, nil) + require.NoError(t, m.Start(ctx)) + defer m.Stop() + require.Eventually(t, func() bool { return driver.evalBool(ctx, session, "window.__kernelEventInjected === true") }, 10*time.Second, 20*time.Millisecond) + driver.call(t, ctx, session, "Page.navigate", map[string]any{"url": stub.URL + "/document"}) + require.Eventually(t, func() bool { + return driver.evalBool(ctx, session, fmt.Sprintf(`location.href === %q && document.readyState === "complete"`, stub.URL+"/document")) + }, 10*time.Second, 20*time.Millisecond) + driver.call(t, ctx, session, "Runtime.evaluate", map[string]any{"expression": `document.cookie="test_cookie=present; path=/"`}) + for range 2 { + result := driver.call(t, ctx, session, "Runtime.evaluate", map[string]any{"expression": `fetch("/api").then(r => r.text())`, "awaitPromise": true, "returnByValue": true}) + require.NotContains(t, string(result.raw), "exceptionDetails") + } + snapshot := func(typ, url string) []map[string]any { + ec.mu.Lock() + defer ec.mu.Unlock() + var out []map[string]any + for _, ev := range ec.events { + if ev.Type != typ { + continue + } + var p map[string]any + require.NoError(t, json.Unmarshal(ev.Data, &p)) + if p["url"] == url { + out = append(out, p) + } + } + return out + } + require.Eventually(t, func() bool { return len(snapshot(EventNetworkResponse, stub.URL+"/api")) == 2 }, 5*time.Second, 20*time.Millisecond) + mu.Lock() + require.Equal(t, []int{200, 304}, statuses) + require.Equal(t, "test_cookie=present", wireHeaders.Get("Cookie")) + mu.Unlock() + t.Run("document_response", func(t *testing.T) { + require.Eventually(t, func() bool { return len(snapshot(EventNetworkResponse, stub.URL+"/document")) == 1 }, time.Second, 20*time.Millisecond, "completed document load must emit a response") + }) + t.Run("cookie_header", func(t *testing.T) { + requests := snapshot(EventNetworkRequest, stub.URL+"/api") + require.Len(t, requests, 2) + headers := requests[0]["headers"].(map[string]any) + require.Contains(t, headers, "Cookie", "server received Cookie, telemetry must capture it") + }) + t.Run("wire_status", func(t *testing.T) { + responses := snapshot(EventNetworkResponse, stub.URL+"/api") + require.ElementsMatch(t, []any{float64(200), float64(304)}, []any{responses[0]["status"], responses[1]["status"]}) + for _, response := range responses { + if response["status"] == float64(304) { + require.Equal(t, float64(200), response["effective_status"]) + require.Equal(t, "Not Modified", response["status_text"]) + } + } + }) +} + +func TestNetworkBodiesSurviveNavigation(t *testing.T) { + if os.Getenv("KERNEL_CDPMONITOR_CHROME_E2E") == "" { + t.Skip("set KERNEL_CDPMONITOR_CHROME_E2E=1 to run real-Chromium network tests") + } + ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second) + defer cancel() + stub := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + if r.URL.Path == "/api" { + w.Header().Set("Content-Type", "application/json") + fmt.Fprint(w, `{"body":"retained"}`) + return + } + w.Header().Set("Content-Type", "text/html") + fmt.Fprint(w, "body retention") + })) + defer stub.Close() + ws := launchChromium(t, ctx, findChromium(t), "--site-per-process") + driver := dialCDP(t, ctx, ws) + defer driver.close() + target := driver.call(t, ctx, "", "Target.createTarget", map[string]any{"url": "about:blank"}).targetID(t) + session := driver.call(t, ctx, "", "Target.attachToTarget", map[string]any{"targetId": target, "flatten": true}).sessionID(t) + ec := newEventCollector() + m := New(&staticUpstream{url: ws}, ec.publishFn(), 99, discardLogger, nil) + require.NoError(t, m.Start(ctx)) + defer m.Stop() + require.Eventually(t, func() bool { return driver.evalBool(ctx, session, "window.__kernelEventInjected === true") }, 10*time.Second, 20*time.Millisecond) + driver.call(t, ctx, session, "Page.navigate", map[string]any{"url": stub.URL + "/document"}) + require.Eventually(t, func() bool { + return driver.evalBool(ctx, session, fmt.Sprintf(`location.href === %q && document.readyState === "complete"`, stub.URL+"/document")) + }, 5*time.Second, 20*time.Millisecond) + evaluateNetworkScript(t, ctx, driver, session, `fetch("/api").then(r=>r.text())`) + response := waitForNetworkURL(t, ec, EventNetworkResponse, stub.URL+"/api") + var payload oapi.BrowserNetworkResponseEventData + require.NoError(t, json.Unmarshal(response.Data, &payload)) + require.NotNil(t, payload.Body) + require.JSONEq(t, `{"body":"retained"}`, *payload.Body) + destination := strings.Replace(stub.URL, "127.0.0.1", "localhost", 1) + "/next" + driver.call(t, ctx, session, "Page.navigate", map[string]any{"url": destination}) + require.Eventually(t, func() bool { + return driver.evalBool(ctx, session, fmt.Sprintf(`location.href === %q && document.readyState === "complete"`, destination)) + }, 5*time.Second, 20*time.Millisecond) + // Retrieve through the monitor's own session after the renderer has changed. + body, err := m.fetchResponseBody(ctx, payload.RequestId, payload.SessionId, networkReqState{resourceType: "Fetch", mimeType: "application/json"}) + require.NoError(t, err) + require.JSONEq(t, `{"body":"retained"}`, body) + require.NoError(t, m.SetTelemetry(false)) + waitForTelemetryReconcile(t, m, false) + observer, err := cdpclient.DialWithEvents(ctx, ws) + require.NoError(t, err) + defer observer.Close() + attached, err := observer.Send(ctx, "Target.attachToTarget", map[string]any{"targetId": target, "flatten": true}, "") + require.NoError(t, err) + var observedSession struct { + SessionID string `json:"sessionId"` + } + require.NoError(t, json.Unmarshal(attached, &observedSession)) + _, err = observer.Send(ctx, "Network.enable", nil, observedSession.SessionID) + require.NoError(t, err) + before := m.NetworkSnapshot().Completed + evaluateNetworkScript(t, ctx, driver, session, `fetch("/api?after-disable").then(r=>r.text())`) + require.Eventually(t, func() bool { return m.NetworkSnapshot().Completed > before }, time.Second, 20*time.Millisecond) + var uncapturedRequestID string + for uncapturedRequestID == "" { + select { + case message := <-observer.Events(): + var p cdpNetworkRequestWillBeSentParams + if message.Method == "Network.requestWillBeSent" && json.Unmarshal(message.Params, &p) == nil && strings.HasSuffix(p.Request.URL, "/api?after-disable") { + uncapturedRequestID = p.RequestID + } + case <-ctx.Done(): + t.Fatal("missing request after capture was disabled") + } + } + driver.call(t, ctx, session, "Page.navigate", map[string]any{"url": stub.URL + "/back"}) + require.Eventually(t, func() bool { + return driver.evalBool(ctx, session, fmt.Sprintf(`location.href === %q && document.readyState === "complete"`, stub.URL+"/back")) + }, 5*time.Second, 20*time.Millisecond) + _, err = m.fetchResponseBody(ctx, uncapturedRequestID, payload.SessionId, networkReqState{resourceType: "Fetch", mimeType: "application/json"}) + require.Error(t, err, "disabled capture must not retain new bodies across navigation") +} + +func TestNetworkExtensionAttribution(t *testing.T) { + if os.Getenv("KERNEL_CDPMONITOR_CHROME_E2E") == "" { + t.Skip("set KERNEL_CDPMONITOR_CHROME_E2E=1 to run real-Chromium network tests") + } + ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second) + defer cancel() + stub := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + w.Header().Set("Content-Type", "application/json") + fmt.Fprint(w, `{"from":"extension"}`) + })) + defer stub.Close() + dir := t.TempDir() + require.NoError(t, os.WriteFile(filepath.Join(dir, "manifest.json"), []byte(`{"manifest_version":3,"name":"telemetry test","version":"1.0","background":{"service_worker":"background.js"},"host_permissions":["http://127.0.0.1/*"]}`), 0600)) + require.NoError(t, os.WriteFile(filepath.Join(dir, "background.js"), []byte(`chrome.runtime.onInstalled.addListener(() => {});`), 0600)) + require.NoError(t, os.WriteFile(filepath.Join(dir, "page.html"), []byte(`extension page`), 0600)) + ws := launchChromium(t, ctx, findChromium(t), "--enable-unsafe-extension-debugging") + c, err := cdpclient.Dial(ctx, ws) + require.NoError(t, err) + defer c.Close() + ec := newEventCollector() + m := New(&staticUpstream{url: ws}, ec.publishFn(), 99, discardLogger, nil) + require.NoError(t, m.Start(ctx)) + defer m.Stop() + extensionID, err := c.LoadUnpackedExtension(ctx, dir) + require.NoError(t, err) + var target string + require.Eventually(t, func() bool { + raw, err := c.Send(ctx, "Target.getTargets", nil, "") + if err != nil { + return false + } + var p struct { + Targets []cdpTargetTargetInfo `json:"targetInfos"` + } + if json.Unmarshal(raw, &p) != nil { + return false + } + for _, info := range p.Targets { + if info.Type == "service_worker" && strings.HasPrefix(info.URL, "chrome-extension://"+extensionID+"/") { + target = info.TargetID + return true + } + } + return false + }, 5*time.Second, 20*time.Millisecond) + driver := dialCDP(t, ctx, ws) + defer driver.close() + session := driver.call(t, ctx, "", "Target.attachToTarget", map[string]any{"targetId": target, "flatten": true}).sessionID(t) + // Wait for the collector's own attachment before driving the request. + require.Eventually(t, func() bool { + m.sessionsMu.RLock() + defer m.sessionsMu.RUnlock() + for sid, info := range m.sessions { + if info.targetID == target && m.networkReady[sid] { + return true + } + } + return false + }, 5*time.Second, 20*time.Millisecond) + evaluateNetworkScript(t, ctx, driver, session, fmt.Sprintf(`fetch(%q).then(r=>r.json())`, stub.URL+"/extension-api")) + request := waitForNetworkURL(t, ec, EventNetworkRequest, stub.URL+"/extension-api") + response := waitForNetworkURL(t, ec, EventNetworkResponse, stub.URL+"/extension-api") + var p map[string]any + require.NoError(t, json.Unmarshal(request.Data, &p)) + require.Equal(t, "service_worker", p["target_type"]) + require.Equal(t, target, p["target_id"]) + require.Equal(t, extensionID, (*request.Source.Metadata)["extension_id"]) + require.Equal(t, extensionID, (*response.Source.Metadata)["extension_id"]) + require.Equal(t, "false", (*request.Source.Metadata)["kernel_extension"]) + + page := driver.call(t, ctx, "", "Target.createTarget", map[string]any{"url": "about:blank"}).targetID(t) + pageSession := driver.call(t, ctx, "", "Target.attachToTarget", map[string]any{"targetId": page, "flatten": true}).sessionID(t) + require.Eventually(t, func() bool { return driver.evalBool(ctx, pageSession, "window.__kernelEventInjected === true") }, 5*time.Second, 20*time.Millisecond) + for index, destination := range []string{"chrome-extension://" + extensionID + "/page.html", stub.URL + "/page"} { + driver.call(t, ctx, pageSession, "Page.navigate", map[string]any{"url": destination}) + require.Eventually(t, func() bool { + return driver.evalBool(ctx, pageSession, fmt.Sprintf(`location.href === %q && document.readyState === "complete"`, destination)) + }, 5*time.Second, 20*time.Millisecond) + url := fmt.Sprintf("%s/page-api-%d", stub.URL, index) + evaluateNetworkScript(t, ctx, driver, pageSession, fmt.Sprintf(`fetch(%q).then(r=>r.json())`, url)) + for _, typ := range []string{EventNetworkRequest, EventNetworkResponse} { + event := waitForNetworkURL(t, ec, typ, url) + if index == 0 { + require.Equal(t, extensionID, (*event.Source.Metadata)["extension_id"]) + } else { + require.NotContains(t, *event.Source.Metadata, "extension_id") + require.NotContains(t, *event.Source.Metadata, "kernel_extension") + } + } + idle := waitForNetworkURL(t, ec, EventNetworkIdle, destination) + if index == 0 { + require.Equal(t, extensionID, (*idle.Source.Metadata)["extension_id"]) + require.Equal(t, "false", (*idle.Source.Metadata)["kernel_extension"]) + } else { + require.NotContains(t, *idle.Source.Metadata, "extension_id") + require.NotContains(t, *idle.Source.Metadata, "kernel_extension") + } + } +} diff --git a/server/lib/cdpmonitor/surface_events_test.go b/server/lib/cdpmonitor/surface_events_test.go index 72cf925cf..5014597d2 100644 --- a/server/lib/cdpmonitor/surface_events_test.go +++ b/server/lib/cdpmonitor/surface_events_test.go @@ -28,12 +28,13 @@ func TestSurfaceDropsNetworkEventsForUnknownAndRemovedSessions(t *testing.T) { m.sessions["session"] = targetInfo{targetID: "frame", targetType: "iframe"} m.handleSurfaceEvent(nil, event) require.Len(t, m.pendingRequests, 1) - require.Len(t, ec.events, 1) + ec.waitFor(t, EventNetworkRequest, 2*time.Second) + require.Equal(t, 1, ec.checkpoint()) m.handleSurfaceEvent(nil, browsersurface.Event{Kind: browsersurface.EventSessionRemoved, SessionID: "session"}) m.handleSurfaceEvent(nil, event) require.Empty(t, m.pendingRequests) - require.Len(t, ec.events, 1, "a removed session must not resume emitting metadata-free requests") + require.Equal(t, 1, ec.checkpoint(), "a removed session must not resume emitting metadata-free requests") } func TestSurfaceCarriesOOPIFParentFrameIntoNavigation(t *testing.T) { diff --git a/server/lib/cdpmonitor/testdata/Network_requestWillBeSentExtraInfo.json b/server/lib/cdpmonitor/testdata/Network_requestWillBeSentExtraInfo.json new file mode 100644 index 000000000..0800ffd5a --- /dev/null +++ b/server/lib/cdpmonitor/testdata/Network_requestWillBeSentExtraInfo.json @@ -0,0 +1,9 @@ +{ + "requestId": "149.2", + "associatedCookies": [], + "headers": {"Accept": "*/*", "Cookie": "session=test", "Host": "example.com"}, + "connectTiming": {"requestTime": 123.5}, + "clientSecurityState": {"initiatorIsSecureContext": true, "initiatorIPAddressSpace": "Public", "privateNetworkRequestPolicy": "Allow"}, + "siteHasCookieInOtherPartition": true, + "appliedNetworkConditionsId": "conditions" +} diff --git a/server/lib/cdpmonitor/testdata/Network_responseReceivedExtraInfo.json b/server/lib/cdpmonitor/testdata/Network_responseReceivedExtraInfo.json new file mode 100644 index 000000000..e533db8bc --- /dev/null +++ b/server/lib/cdpmonitor/testdata/Network_responseReceivedExtraInfo.json @@ -0,0 +1,11 @@ +{ + "requestId": "149.2", + "blockedCookies": [], + "headers": {"ETag": "v1"}, + "resourceIPAddressSpace": "Public", + "statusCode": 304, + "headersText": "HTTP/1.1 304 Not Modified\r\nETag: v1\r\n\r\n", + "cookiePartitionKey": {"topLevelSite": "https://example.com", "hasCrossSiteAncestor": false}, + "cookiePartitionKeyOpaque": true, + "exemptedCookies": [] +} From efc6aad13939dbd08839669114c562518566cfb6 Mon Sep 17 00:00:00 2001 From: Sayan- <1415138+Sayan-@users.noreply.github.com> Date: Wed, 14 Oct 2026 21:47:13 +0000 Subject: [PATCH 03/15] Regenerate network telemetry API types --- server/lib/oapi/oapi.go | 1404 ++++++++++++++++++++------------------- 1 file changed, 708 insertions(+), 696 deletions(-) diff --git a/server/lib/oapi/oapi.go b/server/lib/oapi/oapi.go index 22194a0c1..33bdf5a72 100644 --- a/server/lib/oapi/oapi.go +++ b/server/lib/oapi/oapi.go @@ -5298,7 +5298,7 @@ type BrowserNetworkRequestEventData struct { // FrameId CDP frame identifier within the target. FrameId *string `json:"frame_id,omitempty"` - // Headers Request headers. + // Headers Request headers, enriched with wire headers when available before publication. Headers BrowserHttpHeaders `json:"headers"` // InitiatorType CDP Initiator.type indicating what caused the request, passed through as-is from Chrome. Known values include script, parser, preload, and other. @@ -5341,7 +5341,7 @@ type BrowserNetworkRequestEventData struct { Url *string `json:"url,omitempty"` } -// BrowserNetworkResponseEvent A browser network response received event. Fired after the response body is fully received, not when headers arrive. +// BrowserNetworkResponseEvent A browser network response received event. Fired after the response body is fully received, or when a redirect advances to the next request. type BrowserNetworkResponseEvent struct { Category BrowserNetworkResponseEventCategory `json:"category"` Data *BrowserNetworkResponseEventData `json:"data,omitempty"` @@ -5368,6 +5368,12 @@ type BrowserNetworkResponseEventData struct { // Body Truncated response body, present only for text MIME types. Body *string `json:"body,omitempty"` + // BodyError Response body retrieval or decoding error. Absent for successfully retrieved or intentionally excluded bodies. + BodyError *string `json:"body_error,omitempty"` + + // EffectiveStatus Effective CDP status when different from the wire status, such as 200 for a revalidated 304 response. + EffectiveStatus *int `json:"effective_status,omitempty"` + // FrameId CDP frame identifier within the target. FrameId *string `json:"frame_id,omitempty"` @@ -5386,6 +5392,9 @@ type BrowserNetworkResponseEventData struct { // NavSeq Monotonically increasing navigation sequence number, incremented on each top-level navigation within the target. NavSeq int64 `json:"nav_seq"` + // RequestHeaders Wire request headers when available, including headers that arrived after network_request was published. + RequestHeaders *BrowserHttpHeaders `json:"request_headers,omitempty"` + // RequestId CDP request identifier matching the originating network_request event. RequestId string `json:"request_id"` @@ -5395,7 +5404,7 @@ type BrowserNetworkResponseEventData struct { // SessionId CDP session identifier for the target connection. SessionId string `json:"session_id"` - // Status HTTP response status code. + // Status HTTP response status code on the wire when available, otherwise the effective CDP status. Status int `json:"status"` // StatusText HTTP response status text (e.g. OK, Not Found). @@ -26639,710 +26648,713 @@ func (sh *strictHandler) GetWebMCPTools(w http.ResponseWriter, r *http.Request, // Base64 encoded, gzipped, json marshaled Swagger object var swaggerSpec = []string{ - "H4sIAAAAAAAC/+z9i3IbOZYoiv4KDs9EWJpNUrLrMd1ydJzrsuwuTfmha6m6ZrpVhwQzQRKtJJANICWx", - "6nrH/oj9hftLbqy1AGQmmUkm9bDLVZqYqLaSwMJrvbCwHr/2Er3ItRLK2d7Rrz0jbK6VFfjHdzz9IP5V", - "COteGaMNfEq0ckI5+CfP80wm3EmtDv5ptYJvNpmLBYd//ZsR095R7/8+KOEf0K/2gKB9/Pix30uFTYzM", - "AUjvCAZkfsTex37vpVbTTCafavQwHAx9opwwimefaOgwHDsT5koY5hv2e++0e60LlX6iebzTjuF4PfjN", - "NwdoL9L0ZWGdXvwkJm9fnp5rndlwUjCVNJUAgmenRufCOAkYNOWZFf1eXvn0a2+qTSJG+kqYayOdGCm+", - "EDbniYAfUzHlReZi1/rsXji9kAnPsiUzIs94IhjPMiZupHVSzZiDWTGpmJtLyyJgdi3dnL5NuEvm7Hou", - "FHOmEMNev+eWuegd9SZaZ4Ir2PPajHLu4Gh6R73/9x8vBn/ng18OB38eDQc///q0//TZnz7+WwnCOiPV", - "DCBYXZiwoOoC/pNf8TP8m4mb3AhrpYbZcsfEFc8K7oRlTjPOlFYDscjdknFj+JLpKUtw/3GRLBVTqXDH", - "LaxhwW/eCDVz897Rnw7x/9Ym9bHfM+JfhTQi7R39o7LGONufYx89+acgMvgO9uulXuSFE+ZFAgN2PfWV", - "o/NbD+vw4BhHeLhgcSOSwglmAbhyEs542FtFHd9hfV/fm1QYkbJMWgdDrEMeslf4D9hv63RuGW68YFNp", - "rGMCCAIGlE4s7DbyqW8I7NNCqhPq+TTuIh7c2saHNTTuttHXVpgXuXzJs+zVlafz1Z0ECiCkSY28AoyZ", - "Czahvn025yrNRMomS/x+KYwS2UAu+EzYAc8ls8hijuI5DIClGJ2FXeuz04wvr42czR1LdCr8Hkqt+swm", - "Rghl59pZxlXKkkzmE81NyniSCGuHDKZuaXoLrvhM4DT+9pZJZZ3gKRML6dg4z7ibarMY8VyOYEXj4YVa", - "O/GEOzHTZgn/FqpYwA766fZ+XsPxfi/lbivza9jlY+hWo9sOALDnGfX42O85UyiYbrp+ZOemEExOcSNg", - "hmwqRZaya25Z7MXSQgC+WvmLYJlcSGebuZNrwH+cCnNyIazjixxY4I9K3rCFTIy2ItEqRWiw4dz1jnpS", - "uW+/LsFL5cRMoMChL+Vuh+Np2O4VzHY2AOyX57aZu7ScxG6s5RRQGEgi58tM85RNtWHjiFZMAFy7zk0A", - "tde3kg6U2WKykA7OxWk29kykpIuXOhXjPkt4nouUccf+9PTPz9hk6YRlmbwUMKhZMu3mwkArVwB7oo0b", - "shehI/B8waRlSeGYVoyzZM4NT5wwbAJimJslkplQKQq28XA4/EfEmZ/HQ/ZiYuHsYc3VMWGhqBkMm+RT", - "WtCPo0UDMv3Es2yQZDq5ZKEd04S8xFsMzGQhs0xWUMuPoYrFhBApzmAkG0jiLUgDkTKjCyee2HK+fZTb", - "KePE1ohZ4TfLpLNxCntiOBuy8Tm/FGeRJ437bPyq8az2G/fBkCxrnCGglf+dyRSE0lQKw6ZGL1oYa2i9", - "kGmaiWtuROOg1nFXNOz79+fnpyzo34xaIf8dNhDqCu1VFrKy83G8+qlvIEegxTPHk8v1Kb48PmUfCgWM", - "ZohNzg1PBDMiNwLQEJWwuWAVPQcp00JbIBP4EXqjkFZEmkP2GtihZYUVDEZQfAGAEq3gZxTkhiNWuzlX", - "zCp+KUYJt8gvF6hWANyXc6MXgh2LK9RO2anRTic6Y9fSCEasr1nGZNlrwxf012bFAlczxcZ9BqhrFto6", - "UiJq6sPKEDorFuod0cbaIH8XRg8m3IqUUUNGVIR6qyQ1JZOqEQ/6vWmhUG6/44vNGmdoiMTUZ9owUjAJ", - "M5GDcKXVcqELGxvbRhSG2XRYDTRrWAu1bl4N/XaSNuMe/V0hx8bZFSZb7/7jhzewZFh74GYe2lRmTYS6", - "QmG1ba7Mk4arbUm/ft5NpFZXEVck2hoS5iQJWcYnIsODwukjUTmkQOKG3C5VwhJeWNHM73Juwt0xy95P", - "e0f/6KTplBzh489r0hdB1iaDmIRTwa92uLaZFZLbyIhyl8z5yznPMqFm4uS4aW/4vwpRwQhm59yQ+kuC", - "nzi2VoJdSSsnmWBJADhkLxRDBj6YGZmioE7mnCVcMSOcWdLNkbOpEXbOHLeXLBeGceeAdPrMagQ8jhBH", - "Mh2zBV+yiWDcWp1I1O0QzKLInMwzwcYACFui/LegEORGp0UiDHZGbmquBJOO8cRoaxlnOajSRqCGQxdY", - "ULH9B2lZzo2LmA1YHifFRC4tyBF24liqhWVKOyZVKhPuBC1LA6MDNqBNpSOgRCZQjUDGuYZQLSf1Qdgi", - "c60XmHgQYb/jgEZwVAs4A9YqAel14RK9gAucV8i0SgQeQ+Ucf+LSecKQlg6+XxManJZpcGJ95jRLBQ1B", - "9xOwRwBvL6cSxx37aY6szq7EyDpunEjHqJet/Ebgx4wWPBG4yVcyLXjGsIXBadDVCU5aJ0lhSsxADT6w", - "SsCscoldL0c0n7tejjYc6ONdqfWuFJChZAeEEHe9O/mj24FVrp7XLW5UkRBq16q2JW64ZvkeYbO6Y985", - "9PjY71W56y3x9+T4VteeqOyXuwEXN27I2ogXklVG1WcJMBNoQRcyT/heaAC+TYS7FqLOU8uLU9v94Hxl", - "oMDsG8TaGMdMx0fYACWHnqBISVeWk2SCG8anaI9bmeqQvdaGOX0pVGDVlhjsQnBlGS9vK9QIiNTfBJ4j", - "usAfdsBVOpjrLAVxRj3rc8D5KX4lZ0jc/Jovh2w85TIrjAhrCPLROk13bpqyAkNqJhPpyoPwq/AAUNG9", - "mfPCAnA4Mb88y67nMhMrkzFiwaUS6ZCNgUfowq3M4IktWw8ycSUydg3SZ1KkM4F2XSDqbbD5hKtUKzwj", - "OhrCOKFSry/owoUTSZmVMzz5zSuOGDjFNXMQ3mwiUCHEqVxLnCOcUyrtQloL8tSUWFIoIHWRDi9UwKEo", - "zFaOrY9aBHyaZvqacQP2CiYdaDNWOoFalHUyy5gRwK4YB31HpoQsfZSB+E/rNw31KcQvSSpKbjTiOHfs", - "es6dQPlZ21FYyazgJgVys0WSCEGz7/UjV6Z1AEcnhACao5Pt9XvxHNZ5dL93MwAYgytuFF0P/9GLHOUs", - "QI1fXkfw8dN5HCd+elEO+LHfuxYT2KvRXNsGTel7baNKlwdL6iorQo2oUdsPwHPu5uvAT7mbdwTO/r8F", - "MjJHXO0myQrY5a13phrrrxgiagx9B7sEQsON36Jg+oGJLiLn3aBcfgbdanUdj3rVVr2qqmQ/oD160wHt", - "rkgF7GtUo+rXht+tCkV0iDcnwK/1u9255/qAnbxwc22k405eCd/VSTAJPmepRsEAd9Ur0aCnzXhO76dt", - "lzZ/NbyeaytYKjKJKhqIInp6TIDDcSNwGJAsXDkRJMqaqobPhqO2hwSQyQObi0ROZUJPjPSeBjP2yok3", - "Y7/68OH9h9HLF6fnL79/Mfrx3dn7N3978d2bV+P9aOHXigSctTtZlc/X9nrswYyPgt5ghCuMQs5YWA66", - "pNUZPvjV9LC11sovas8KwcblZoz3a9qT75fKFHeV+lcNgmAOQsWqokit6EjUhCVcJSLLVrSWuu4I9vcB", - "jrmiB9Cyd1cEgCORxabV/hSUwwG3oKqJtMEi5b0QBJmsAc9akHSjMO+oKVzPhfEincZATo/jpPehLGyE", - "f9/6wt0UBODbVXa4bln2K7iUKmVG5No4MiDC8gh5h/CacCXTKkGjQYkepohhmAXP5C9w9sp5RdYKd8SE", - "csLkRlrBrriRXDkLe2mEp3eW6CzjuRWho5CGXQmDziGTIrkUju1dPWMH7Oqr/T4b461qxFU6glvVmO6b", - "dvWyFVm+JVW7UJnEKxAsk6Yc18otG+O74bhOMvOg8sA5hdO5elb/8ys418Io0PXh2GZCOGEdSrHqRHv9", - "Ho7RSGANR3hG5NBNyTPof5A7Uu+4vfxsKl112o86XUedzrO+T2Yoaz6p3ZU7ehJo1+zqeoctjdhowV/B", - "XetRt1+auCtGY7pXq1nWYPHBu7aXQWzB1RJ7WLxQJ1rZYiGMZYvCOpTA3MIXNDD7CdL86lZ1pg3LuTR+", - "7sAQuTHyCu0QKfDEn2AR3uDTrzxrJNoYkZEzW7THh7eUqPw1K8F9b1evvajMjC5yS4va+J5zHDQ6b0HQ", - "9H57xPjKShfcr0Z4S5J0Nr4OwAyExMeDsvVEsIW0lhw44j4wDtpZgqLQiKk2ouGFJSkMPZIFNdi12PN/", - "M2r+J9F3/Im3PC3dWeEBd08Bwwat5C2dIr16A7HWnmTQzJRwY5ZMaYIJb8akoFceCW0xQbK3+w+jR61N", - "+z6Uqe0c8VE1+q2rRmn+onB6KrPsbeOF86e5TOZ0UnrqXcu47wFODhkg00uutJIJz6iB56apuELf6UHu", - "fWb+P8/Sw6d/Fv/xVX3RCTcwV56mMP2Osz03cjYT5qVeLLhKbyFoz7iSDrFnHGAOHQEdM25mxYJka7k2", - "qfLCHTU1l2rDYvssl0qRQ9/cudweHRzMpJsXk2GiFwfkYBT8iw7W4BxMMj05CMDE5Kv/eJo+Tb/985++", - "SZ99m37152/S//jTJP3T9E/82bMJR5f9A++2OwowhvB1yF6RWcKvjTiGtCyhPWRzTq8vDp8TmDbMiJQn", + "H4sIAAAAAAAC/+z9i3IbObIoiv4KDs+KsLQ2Scnux5qRY+Jct2VPa7UfupZ6eq0Z9SHBKpDEqAjUAChJ", + "7L7esT9if+H+khuZCaCqyCqyqIfd7tbEhFskgcQrX0jk49deohe5VkI52zv6tWeEzbWyAj98x9MP4l+F", + "sO6VMdrAV4lWTigHf/I8z2TCndTq4J9WK/jOJnOx4PDXvxkx7R31/u+DEv4B/WoPCNrHjx/7vVTYxMgc", + "gPSOYEDmR+x97PdeajXNZPKpRg/DwdAnygmjePaJhg7DsTNhroRhvmG/906717pQ6SeaxzvtGI7Xg998", + "c4D2Ik1fFtbpxU9i8vbl6bnWmQ0nBVNJUwkgeHZqdC6Mk4BBU55Z0e/lla9+7U21ScRIXwlzbaQTI8UX", + "wuY8EfBjKqa8yFzsWp/dC6cXMuFZtmRG5BlPBONZxsSNtE6qGXMwKyYVc3NpWQTMrqWb03cT7pI5u54L", + "xZwpxLDX77llLnpHvYnWmeAK9rw2o5w7OJreUe///ceLwd/54JfDwZ9Hw8HPvz7tP332p4//VoKwzkg1", + "AwhWFyYsqLqA/+RX/Aw/M3GTG2Gt1DBb7pi44lnBnbDMacaZ0mogFrlbMm4MXzI9ZQnuPy6SpWIqFe64", + "hTUs+M0boWZu3jv60yH+b21SH/s9I/5VSCPS3tE/KmuMs/059tGTfwoig+9gv17qRV44YV4kMGDXU185", + "Or/1sA4PjnGEhwsWNyIpnGAWgCsn4YyHvVXU8R3W9/W9SYURKcukdTDEOuQhe4V/wH5bp3PLcOMFm0pj", + "HRNAEDCgdGJht5FPfUNgnxZSnVDPp3EX8eDWNj6soXG3jb62wrzI5UueZa+uPJ2v7iRQACFNauQVYMxc", + "sAn17bM5V2kmUjZZ4veXwiiRDeSCz4Qd8FwyiyzmKJ7DAFiK0VnYtT47zfjy2sjZ3LFEp8LvodSqz2xi", + "hFB2rp1lXKUsyWQ+0dykjCeJsHbIYOqWprfgis8ETuNvb5lU1gmeMrGQjo3zjLupNosRz+UIVjQeXqi1", + "E0+4EzNtlvC3UMUCdtBPt/fzGo73eyl3W5lfwy4fQ7ca3XYAgD3PqMfHfs+ZQsF00/UjOzeFYHKKGwEz", + "ZFMpspRdc8tiL5YWAvDVyl8Ey+RCOtvMnVwD/uNUmJMLYR1f5MACf1Tyhi1kYrQViVYpQoMN56531JPK", + "fft1CV4qJ2YCBQ59U+52OJ6G7V7BbGcDwH55bpu5S8tJ7MZaTgGFgSRyvsw0T9lUGzaOaMUEwLXr3ARQ", + "e30r6UCZLSYL6eBcnGZjz0RKunipUzHus4TnuUgZd+xPT//8jE2WTliWyUsBg5ol024uDLRyBbAn2rgh", + "exE6As8XTFqWFI5pxThL5tzwxAnDJiCGuVkimQmVomAbD4fDf0Sc+Xk8ZC8mFs4e1lwdExaKmsGwST6l", + "Bf04WjQg0088ywZJppNLFtoxTchLvMXATBYyy2QFtfwYqlhMCJHiDEaygSTegjQQKTO6cOKJLefbR7md", + "Mk5sjZgVfmeZdDZOYU8MZ0M2PueX4izypHGfjV81ntV+4z4YkmWNMwS08r8zmYJQmkph2NToRQtjDa0X", + "Mk0zcc2NaBzUOu6Khn3//vz8lAX9m1Er5L/DBkJdob3KQlZ2Po5XP/UN5Ai0eOZ4crk+xZfHp+xDoYDR", + "DLHJueGJYEbkRgAaohI2F6yi5yBlWmgLZAI/Qm8U0opIc8heAzu0rLCCwQiKLwBQohX8jILccMRqN+eK", + "WcUvxSjhFvnlAtUKgPtybvRCsGNxhdopOzXa6URn7FoawYj1NcuYLHtt+II+bVYscDVTbNxngLpmoa0j", + "JaKmPqwMobNiod4RbawN8ndh9GDCrUgZNWRERai3SlJTMqka8aDfmxYK5fY7vtiscYaGSEx9pg0jBZMw", + "EzkIV1otF7qwsbFtRGGYTYfVQLOGtVDr5tXQbydpM+7R5wo5Ns6uMNl69x8/vIElw9oDN/PQpjJrItQV", + "Cqttc2WeNFxtS/r1824itbqKuCLR1pAwJ0nIMj4RGR4UTh+JyiEFEjfkdqkSlvDCimZ+l3MT7o5Z9n7a", + "O/pHJ02n5Agff16TvgiyNhnEJJwKfmuHa5tZIbmNjCh3yZy/nPMsE2omTo6b9ob/qxAVjGB2zg2pvyT4", + "iWNrJdiVtHKSCZYEgEP2QjFk4IOZkSkK6mTOWcIVM8KZJd0cOZsaYefMcXvJcmEYdw5Ip8+sRsDjCHEk", + "0zFb8CWbCMat1YlE3Q7BLIrMyTwTbAyAsCXKfwsKQW50WiTCYGfkpuZKMOkYT4y2lnGWgyptBGo4dIEF", + "Fdt/IS3LuXERswHL46SYyKUFOcJOHEu1sExpx6RKZcKdoGVpYHTABrSpdASUyASqEcg41xCq5aQ+CFtk", + "rvUCEw8i7Hcc0AiOagFnwFolIL0uXKIXcIHzCplWicBjqJzjT1w6TxjS0sH3a0KD0zINTqzPnGapoCHo", + "fgL2CODt5VTiuGM/zZHV2ZUYWceNE+kY9bKV3wj8mNGCJwI3+UqmBc8YtjA4Dbo6wUnrJClMiRmowQdW", + "CZhVLrHr5Yjmc9fL0YYDfbwrtd6VAjKU7IAQ4q53J390O7DK1fO6xY0qEkLtWtW2xA3XLN8jbFZ37DuH", + "Hh/7vSp3vSX+nhzf6toTlf1yN+Dixg1ZG/FCssqo+iwBZgIt6ELmCd8LDcC3iXDXQtR5anlxarsfnK8M", + "FJh9g1gb45jp+AgboOTQExQp6cpykkxww/gU7XErUx2y19owpy+FCqzaEoNdCK4s4+VthRoBkfqbwHNE", + "F/hgB1ylg7nOUhBn1LM+B5yf4ldyhsTNr/lyyMZTLrPCiLCGIB+t03TnpikrMKRmMpGuPAi/Cg8AFd2b", + "OS8sAIcT88uz7HouM7EyGSMWXCqRDtkYeIQu3MoMntiy9SATVyJj1yB9JkU6E2jXBaLeBptPuEq1wjOi", + "oyGMEyr1+oIuXDiRlFk5w5PfvOKIgVNcMwfhzSYCFUKcyrXEOcI5pdIupLUgT02JJYUCUhfp8EIFHIrC", + "bOXY+qhFwFfTTF8zbsBewaQDbcZKJ1CLsk5mGTMC2BXjoO/IlJCljzIQ/7R+01CfQvySpKLkRiOOc8eu", + "59wJlJ+1HYWVzApuUiA3WySJEDT7Xj9yZVoHcHRCCKA5OtlevxfPYZ1H93s3A4AxuOJG0fXwH73IUc4C", + "1PjN6wg+fnUex4lfvSgH/NjvXYsJ7NVorm2DpvS9tlGly4MldZUVoUbUqO0H4Dl383Xgp9zNOwJn/98C", + "GZkjrnaTZAXs8tY7U431VwwRNYa+g10CoeHGb1Ew/cBEF5HzblAuP4NutbqOR71qq15VVbIf0B696YB2", + "V6QC9jWqUfVrw+9WhSI6xJsT4Nf63e7cc33ATl64uTbScSevhO/qJJgEn7NUo2CAu+qVaNDTZjyn99O2", + "S5u/Gl7PtRUsFZlEFQ1EET09JsDhuBE4DEgWrpwIEmVNVcNnw1HbQwLI5IHNRSKnMqEnRnpPgxl75cSb", + "sV99+PD+w+jli9Pzl9+/GP347uz9m7+9+O7Nq/F+tPBrRQLO2p2syudrez32YMZHQW8wwhVGIWcsLAdd", + "0uoMH/xqethaa+UXtWeFYONyM8b7Ne3J90tlirtK/asGQTAHoWJVUaRWdCRqwhKuEpFlK1pLXXcE+/sA", + "x1zRA2jZuysCwJHIYtNqfwrK4YBbUNVE2mCR8l4IgkzWgGctSLpRmHfUFK7nwniRTmMgp8dx0vtQFjbC", + "v2994W4KAvDtKjtctyz7FVxKlTIjcm0cGRBheYS8Q3hNuJJplaDRoEQPU8QwzIJn8hc4e+W8ImuFO2JC", + "OWFyI61gV9xIrpyFvTTC0ztLdJbx3IrQUUjDroRB55BJkVwKx/aunrEDdvXVfp+N8VY14iodwa1qTPdN", + "u3rZiizfkqpdqEziFQiWSVOOa+WWjfHdcFwnmXlQeeCcwulcPat//ArOtTAKdH04tpkQTliHUqw60V6/", + "h2M0EljDEZ4ROXRT8gz6H+SO1DtuLz+bSled9qNO11Gn86zvkxnKmk9qd+WOngTaNbu63mFLIzZa8Fdw", + "13rU7Zcm7orRmO7VapY1WHzwru1lEFtwtcQeFi/UiVa2WAhj2aKwDiUwt/ANGpj9BGl+das604blXBo/", + "d2CI3Bh5hXaIFHjiT7AIb/DpV541Em2MyMiZLdrjw1tKVP6aleC+t6vXXlRmRhe5pUVtfM85DhqdtyBo", + "er89YnxlpQvuVyO8JUk6G18HYAZC4uNB2Xoi2EJaSw4ccR8YB+0sQVFoxFQb0fDCkhSGHsmCGuxa7Pm/", + "GTX/k+g7/sRbnpburPCAu6eAYYNW8pZOkV69gVhrTzJoZkq4MUumNMGEN2NS0CuPhLaYINnb/YfRo9am", + "fR/K1HaO+Kga/dZVozR/UTg9lVn2tvHC+dNcJnM6KT31rmXc9wAnhwyQ6SVXWsmEZ9TAc9NUXKHv9CD3", + "PjP/n2fp4dM/i//4qr7ohBuYK09TmH7H2Z4bOZsJ81IvFlyltxC0Z1xJh9gzDjCHjoCOGTezYkGytVyb", + "VHnhjpqaS7VhsX2WS6XIoW/uXG6PDg5m0s2LyTDRiwNyMAr+RQdrcA4mmZ4cBGBi8tV/PE2fpt/++U/f", + "pM++Tb/68zfpf/xpkv5p+if+7NmEo8v+gXfbHQUYQ/h2yF6RWcKvjTiGtCyhPWRzTq8vDp8TmDbMiJQn", "qO6JRCJ1SMUyOYmzzI2+WR4A9qXc8YMkzUfl1i35ImuSSP6gR6hXjhJdNGni5OYCc/TNSQ31zwV+xgH/", "zpGCPWtQacBC5BJo3w/OkjWpUNEjPcBG4XReDvjEsv88e/9u8OH0JZOpf1kop5NweIVj/9S4f8RZvPiv", - "elOXtg4QF/i2QcYY74AhWJJJ+Bs/Kq28XO+gDydaKZG0+keeBHFK2wjOT3iCrOxXWxDpMinTql+Vt2k+", - "8h2Cv0Kaj1Jpw8chO7/WfhEW3cmDCx+6kIRtgONxwDk5epkg/5eW1lqJPXj67E8NHIGQZ4MyMeHJpVAp", - "UzqtefJ4OYn9/SsQ4L2n6XYUQf+8TQNig8pIQ/Yyk/iq6DR7+uxPpReufc44y7SaCVM666IKzYzgWRVG", - "t81YCDfXafUitMqjGrnqwnP83dy2ViTGuvPWT2FTaUOPQEMz6ZihAzUR8xhpNtCpm4uFFdlVK8nCZZfC", - "WhoPAPDY/1496Som4xnT2HggNRdnj5D+3dV3sRvOr9OxrGhO/owqmLtJfUrz8C+0TR7ra3xDvRdx5yEP", + "elOXtg4QF/i2QcYY74AhWJJJ+IxfKq28XO+gDydaKZG0+keeBHFK2wjOT3iCrOxXWxDpMinTql+Vt2k+", + "8h2Cv0Kaj1Jpw5dDdn6t/SIsupMHFz50IQnbAMfjgHNy9DJB/i8trbUSe/D02Z8aOAIhzwZlYsKTS6FS", + "pnRa8+TxchL7+1cgwHtP0+0ogv55mwbEBpWRhuxlJvFV0Wn29NmfSi9c+5xxlmk1E6Z01kUVmhnBsyqM", + "bpuxEG6u0+pFaJVHNXLVhef4u7ltrUiMdeetn8Km0oYegYZm0jFDB2oi5jHSbKBTNxcLK7KrVpKFyy6F", + "tTQeAOCx/7160lVMxjOmsfFAai7OHiH9u6vvYjecX6djWdGc/BlVMHeT+pTm4S+0TR7ra3xDvRdx5yEP", "kxroLUKvrdOj6NtF9IXZYbzdjdvIv6gp800/D2N5lItfmlxMPWWOZsUG5FqXh6FfKRLjq8hnFWTNfKdR", "nP1+RET9ELvJiUxbcb/iASB2lQrU9lEY7CIMHpnrl8ZcN7AnIIDfNVfqxIXOhHtJqQTsmfzlfvmRrcPu", "yJnWej3yqEce9XvmUXMB4akNvMZTAaMGgB3HJ6dt1o52TrdCUL8TntfvXcu06W0lbhv+vmXXrqVK9XXj", "sv32MWqyphlvicSNmmE5Qld+/BP2+E4XKrX3zY+rsLvz43qvR378yI//iPyYqKAbN87EtB3CDcu1RToG", "KJRKhSVam1Qq7oS9FYuv0ujvhsU7nbfu4vKWu9giNjzUTys0Iix0BrmNZZ+mfYbdGwz7NA2EHvJSiJTt", - "jekpHvJkLKSSC5AT+Ae/Kf+YFllG24rux95e5GOgkNOWPi6YiAqNSS0v5neWj14StroBBhQMWYwio6mx", - "PB1ihwDjfxKTM42+A8iqjkj0sZmwrjDC9oNDMaYjSSXP9Izyjkg162O+AGZF5pkbjFXJijRkkEZOzoJr", - "eqAJbAcTOH7/9sDn0GDO8Cn4S8S5ZnJiOLov2ULEHFXRP3oi5jybRv/0sOXDC/VeiYoPV9ue+JBxCoOp", - "iA964wmtrDOCL4KB0GIYWdpnieaZsEmQmd61CmPoaWRpWYZuOSpbloKHDhx+DL4ryJZFJhYYYp9Ut6tf", - "9ivlY5S1pft/olNKYYHNk4xbC44nfsu5glaXQuSsyCHzV5IVFvOIwM7hMza6oqxKmWGc1SjMdfw8SFy3", - "uUNqMC7xU2exWiGQR4fTdodTVDFwqz6Bm2nDsTRmGAo0V/chLacaPEeBD0HfBco4JKExUdZ4yF7xZB78", - "p9CFTSLvyMhNqyQfnudGX3klkfzdaJSj8n0XPxZZytBTijMrEiMc+z//638zWGxKWd/0IspgePLqg6uc", - "7TMjpsIYYWzfJ1exfebEIkdfUM85c+7msBzDZywJVzYAGn2V/FxgSO+KlfGE1sxZhnpDn3GiY/gHeaAm", - "EIjKZ30MS1HFAp0zYV4M0V3gGHNtfQ6gynZSYs0Fz3NABUh2ufok3/mdvcHXqd/2MLIV6NZ35f6KUbMz", - "xNUXiH6rzaAryA3mxH6rtroD8La7cb93/P7tcKqTogO4Y714DS3XAdjE6Cw7UU7/TYrrk+k7jCPuBPGs", - "sWvDEMK9lpk4AVUD/tFtvmerveqA8XtALMNnM8TgbXCx18tapyawqbQ53NCgjVe/OkE+Xu23CfgPYnkb", - "2KHbJtBvdWHFbYCXHTeBP9dFMr8N+LJjE3ixKIBdYqPXRi92XsWrVgBNw8mFQNqNDL3jKCer/RqBKyuM", - "Oxc3Xed+Ejs0gbNL5eYCFItTqZL5X0lf7wj6rLHz5mGItm87Tq335oHOeX7bUcqu9SFO+UwMJ6DdnOvX", - "RndBH+jyXaVHA0Dv61WmXOwG9eVqtw2gFc93B+w7NYHtJhoR2LpcRBCUc7JMpXeMV8JuML9v7NswSAhi", - "7Qb2nW+9AdC5/l5ap83ylXJmuRvYet+GQXIjlTvXp8evuwE+9e3TaQMwSmLWDdAHsa4FIRBQLsTkjZyK", - "ZJlkgiwjnUCeNfRsGsBx4wiDE2474udZvVMjWJ2/0TztJLkJZOzQAm73SVb71IGecwPR2Dxx8goQA//c", - "Dpbavaj1agSM5Lkb1Jdll2aQRnAnQi9yyusMu6HvhkF2nHilTyNQUC20veXUj5s6Nw6jc6HCU0xX6O8r", - "fapAP0Zjx5IykAYLH6QAVmInm2YHJexj/1bAmtTFHUE1qya7AtmkNd1ybc3q5C2BNersO8Jqv1nsCKib", - "Jrsj0O164K0Btip8t4bYrNx1B7ftBrkTpLW7827z2HpP7g5uk6K6G5SNiuntQDWoorsB2q4y7gavSVe8", - "HYR2tXA3eOtK3G79m7XJ3WBs0Mx2BaTz+4LToNftiISrV5gd57BFFe4ObZsCuCukFqVvZzAtKtjt4LTr", - "WrvC26q87QqwXV/rCmer+Xl3ULdHzu2W4NvAajNZd4e1wfD/8eem96C30Zdj20M2vFT7x1P/9n6z9E++", - "lh5srXAhwr3yYmoZV4zPhGqqD4RZGZ6vProev3+LzyPhXXqi9SU8n+J7N/xA7ltlgP+PJ5XRDCbLtjIV", - "6HlUepRVqlQddY4xb7XhtlqOG6yN7dbNDVbcdrt3i6G9g8l2i+lym8lxo6Ww7V2h+iay8XmjyUjYaudr", - "sdJtNpGt2rY2m6jq5qB1S1OLIabZ8tFgXqlZBDeZjdrMHo1Wi2aTwGZrxJYbf/NNvfUlcfUdsP3Frf2h", - "r98tELnKz9AFos0vRzFx42saet8WyqRCVeyEYWfHP1QrjfXZaZHnwglh9oPvYOnx2OC1Q84x0rK/vR12", - "9bjwDon34nRRrv7R6WKL0wVu1UMmbG04j1tkvI/40eSN4X1T24uJdfeSlbbRTbbiDwtHPa6BHAdfsCbn", - "EHLbKD1rUQw/tL/sx43ncRx9pLoziNKvSqSUl6YD6bNTLk2Za0ouFiKV3IkMy6gkIl33L9aq3AjydfsM", - "DGRlgx55yEYeUqLGw7KRplPZnZOUs13nJOVvj8zkPkoSlgvrVJVwIazlM7E9lxHdvrCxZUZkfCnSUIxp", - "fVyfLTCVhr41FzczgtumAl8/zZerMLEOBNQewk0fUdT2UTWSA29WSLf0UVvI7VzkxNGgQIuaYepkvLvJ", - "YoFOrJQDETMke7f/4JdMGOQog+G1ioEoNBr5BBoR8JrPuFSWYlCUuGZh3OoUhDHajI/ib+hKzbQJ+8ry", - "YpFTCmlaq0+1EdMZ+AWHuor+93rKA7bnlrkvCu2LRdp54WAJ+yvJyypb2ev3Vneq+gnn1Ov31mbUyPjX", + "jekpHvJkLKSSC5AT+IHflB+mRZbRtqL7sbcX+Rgo5LSljwsmokJjUsuL+Z3lo5eErW6AAQVDFqPIaGos", + "T4fYIcD4n8TkTKPvALKqIxJ9bCasK4yw/eBQjOlIUskzPaO8I1LN+pgvgFmReeYGY1WyIg0ZpJGTs+Ca", + "HmgC28EEjt+/PfA5NJgzfAr+EnGumZwYju5LthAxR1X0j56IOc+m0T89bPnwQr1XouLD1bYnPmScwmAq", + "4oPeeEIr64zgi2AgtBhGlvZZonkmbBJkpnetwhh6GllalqFbjsqWpeChA4cfg+8KsmWRiQWG2CfV7eqX", + "/Ur5GGVt6f6f6JRSWGDzJOPWguOJ33KuoNWlEDkrcsj8lWSFxTwisHP4jI2uKKtSZhhnNQpzHT8PEtdt", + "7pAajEv81FmsVgjk0eG03eEUVQzcqk/gZtpwLI0ZhgLN1X1Iy6kGz1HgQ9B3gTIOSWhMlDUeslc8mQf/", + "KXRhk8g7MnLTKsmH57nRV15JJH83GuWofN/FL4ssZegpxZkViRGO/Z//9b8ZLDalrG96EWUwPHn1wVXO", + "9pkRU2GMMLbvk6vYPnNikaMvqOecOXdzWI7hM5aEKxsAjb5Kfi4wpHfFynhCa+YsQ72hzzjRMfxBHqgJ", + "BKLyWR/DUlSxQOdMmBdDdBc4xlxbnwOosp2UWHPB8xxQAZJdrj7Jd35nb/B16rc9jGwFuvVdub9i1OwM", + "cfUFot9qM+gKcoM5sd+qre4AvO1u3O8dv387nOqk6ADuWC9eQ8t1ADYxOstOlNN/k+L6ZPoO44g7QTxr", + "7NowhHCvZSZOQNWAP7rN92y1Vx0wfh8Qy/DZDDF4G1zs9bLWqQlsKm0ONzRo49WvTpCPV/ttAv6DWN4G", + "dui2CfRbXVhxG+Blx03gz3WRzG8DvuzYBF4sCmCX2Oi10YudV/GqFUDTcHIhkHYjQ+84yslqv0bgygrj", + "zsVN17mfxA5N4OxSubkAxeJUqmT+V9LXO4I+a+y8eRii7duOU+u9eaBznt92lLJrfYhTPhPDCWg35/q1", + "0V3QB7p8V+nRAND7epUpF7tBfbnabQNoxfPdAftOTWC7iUYEti4XEQTlnCxT6R3jlbAbzO8b+zYMEoJY", + "u4F951tvAHSuv5fWabN8pZxZ7ga23rdhkNxI5c716fHrboBPfft02gCMkph1A/RBrGtBCASUCzF5I6ci", + "WSaZIMtIJ5BnDT2bBnDcOMLghNuO+HlW79QIVudvNE87SW4CGTu0gNt9ktU+daDn3EA0Nk+cvALEwI/b", + "wVK7F7VejYCRPHeD+rLs0gzSCO5E6EVOeZ1hN/TdMMiOE6/0aQQKqoW2t5z6cVPnxmF0LlR4iukK/X2l", + "TxXox2jsWFIG0mDhgxTASuxk0+yghH3s3wpYk7q4I6hm1WRXIJu0pluurVmdvCWwRp19R1jtN4sdAXXT", + "ZHcEul0PvDXAVoXv1hCblbvu4LbdIHeCtHZ33m0eW+/J3cFtUlR3g7JRMb0dqAZVdDdA21XG3eA16Yq3", + "g9CuFu4Gb12J261/sza5G4wNmtmugHR+X3Aa9LodkXD1CrPjHLaowt2hbVMAd4XUovTtDKZFBbsdnHZd", + "a1d4W5W3XQG262td4Ww1P+8O6vbIud0SfBtYbSbr7rA2GP4//tz0HvQ2+nJse8iGl2r/eOrf3m+W/snX", + "0oOtFS5EuFdeTC3jivGZUE31gTArw/PVR9fj92/xeSS8S0+0voTnU3zvhh/IfasM8P/xpDKawWTZVqYC", + "PY9Kj7JKlaqjzjHmrTbcVstxg7Wx3bq5wYrbbvduMbR3MNluMV1uMzlutBS2vStU30Q2Pm80GQlb7Xwt", + "VrrNJrJV29ZmE1XdHLRuaWoxxDRbPhrMKzWL4CazUZvZo9Fq0WwS2GyN2HLjb76pt74krr4Dtr+4tT/0", + "9bsFIlf5GbpAtPnlKCZufE1D79tCmVSoip0w7Oz4h2qlsT47LfJcOCHMfvAdLD0eG7x2yDlGWva3t8Ou", + "HhfeIfFenC7K1T86XWxxusCtesiErQ3ncYuM9xE/mrwxvG9qezGx7l6y0ja6yVb8YeGoxzWQ4+AL1uQc", + "Qm4bpWctiuGH9pf9uPE8jqOPVHcGUfpViZTy0nQgfXbKpSlzTcnFQqSSO5FhGZVEpOv+xVqVG0G+bp+B", + "gaxs0CMP2chDStR4WDbSdCq7c5JytuucpPztkZncR0nCcmGdqhIuhLV8JrbnMqLbFza2zIiML0UaijGt", + "j+uzBabS0HfNxc2M4LapwNdP8+UqTKwDAbWHcNNHFLV9VI3kwJsV0i19qS3kdi5y4mhQoEXNMHUy3t1k", + "sUAnVsqBiBmSvdt/8EsmDHKUwfBaxUAUGo18Ao0IeM1nXCpLMShKXLMwbnUKwhhtxkfxN3SlZtqEfWV5", + "scgphTSt1afaiOkM/IJDXUX/ez3lAdtzy9wXhfbFIu28cLCE/ZXkZZWt7PV7qztV/Qrn1Ov31mbUyPjX", "nIA34ZUt8pBFr9lJ2xPgtaCihdfcpKUe7PuwSeFC8h3v+yzSfq3Ux78KUVB9DHDnZ7ps6b2kc65kcinS", - "EDAlVWLEwvtx+6wQ6M7t54X+mIUq5w/foks3GSrIGDCVmcOqiRNKiMnThSxxzU8b6I85DcsjLua049mQ", - "nYfNhMHJi/W5L6RTjUgJhUWILuu7M2Qvsmu+jLVokIlhmc7gAA8rYNI9p+yd1Qa5ESmPdSxRSoJPukzm", - "wR8+sj1u2S/C6LYAj3Vf8k1oUZ50JLgqNvh8mylTuolpV09emorLvc9riJ7rhGbDJM2HYUYjf2zj1aiF", - "auk0OAeMS5OIGsF9npg8qmnjNjf4LbGSVZ6/ypojt9wisBuepW4dLxnNJlsiJCvtHmMid0qqRJneRkqn", - "oktGOLBLrmaFq8amObSSPCYL/D3n7ShtmU2ydxsm3RWDiOdsGiHYzI1YaCcYddg63KdL1PTHyGrSycHg", - "ToKh2YbeQVK0dXwUHY+i41F0PLToaHn6epQlt5ElBubflibhe/we7DLQtDZdOgiSIXXkTXUxwfToa9Ya", - "HK81bj8tc+nf32g36yP9F9PTqRWdltbHOylWLvPUDhiz2xSW61P47083hT+OvrDJMfJuqsIq5C5awnqf", - "RwXhUUF4VBDuMxF91sHwD60spvsoDwQJdchex/j1HQoWtKglq+T+qJH8oW+3NezcIrqCW1pzyR74OaSC", - "mXMrqgKnY82XkL+HWQcrxs3g/ryCpx+apa1wyNFi/hqfeiUvHDohmol0mM+GFh+L+IRn99r7TArrUk6Y", - "Xh///f7K/1Pn/gu5onYslgP78FYuxMvKS/4Kl9a5P9u3J29fsfBWDEyAU34K6cSiX7oinLx494IZMZMW", - "3ieqNvJqcqTn1d5PLBSMgmn6oif0rJBRsfOYoyOOXUmk9JmOwTug4XtIr9/jRSp1r9+DCk/wvzzPM/+E", + "EDAlVWLEwvtx+6wQ6M7t54X+mIUq5w/fRZduMlSQMWAqM4dVEyeUEJOnC1nimp820B9zGpZHXMxpx7Mh", + "Ow+bCYOTF+tzX0inGpESCosQXdZ3Z8heZNd8GWvRIBPDMp3BAR5WwKR7Ttk7qw1yI1Ie61iilASfdJnM", + "gz98ZHvcsl+E0W0BHuu+5JvQojzpSHBVbPD5NlOmdBPTrp68NBWXe5/XED3XCc2GSZoPw4xG/tjGq1EL", + "1dJpcA4YlyYRNYL7PDF5VNPGbW7wW2Ilqzx/lTVHbrlFYDc8S906XjKaTbZESFbaPcZE7pRUiTK9jZRO", + "RZeMcGCXXM0KV41Nc2gleUwW+HvO21HaMptk7zZMuisGEc/ZNEKwmRux0E4w6rB1uE+XqOmPkdWkk4PB", + "nQRDsw29g6Ro6/goOh5Fx6PoeGjR0fL09ShLbiNLDMy/LU3C9/h9sMtA09p06SBIhtSRN9XFBNOjr1lr", + "cLzWuP20zKV/f6PdrI/0X0xPp1Z0Wlof76RYucxTO2DMblNYrk/hvz/dFP44+sImx8i7qQqrkLtoCet9", + "HhWERwXhUUG4z0T0WQfDP7SymO6jPBAk1CF7HePXdyhY0KKWrJL7o0byh77d1rBzi+gKbmnNJXvg55AK", + "Zs6tqAqcjjVfQv4eZh2sGDeD+/MKnn5olrbCIUeL+Wt86pW8cOiEaCbSYT4bWnws4hOe3WvvMymsSzlh", + "en38+/2V/1Pn/htyRe1YLAf24a1ciJeVl/wVLq1zf7ZvT96+YuGtGJgAp/wU0olFv3RFOHnx7gUzYiYt", + "vE9UbeTV5EjPq72fWCgYBdP0RU/oWSGjYucxR0ccu5JI6TMdg3dAw/eQXr/Hi1TqXr8HFZ7gvzzPM/+E", "hPIFTfULneK5LIrMSeDMpTm/42l5n0ZyZmhGbOSVjJ7xGWelS2QaMjcx74hpvxycF1NeZLBdDpxHcSsL", "23XTtkRb3VqHbXJ23aLCNnd51GAfM0b+sUxOTXTwB042vj229I5Mas1XvxOfauj1yKoeWdXvutqM4bPR", "LjdgX5sf+gUvxlvegHFoUIa3Dw2tWoY+cWJRSRi32+gLuRAjr2R7FF65NUnrpEocc42XAsAAPS1nRfOk", - "iIYxaMyQNxVVZvhHRUeGDKpndAGwPnVe+wrummu138N57eCEvHpHKp26uTF8GfcPaB/XY0cLbi/X9+87", - "6bxPMdyeskxfi5S2quzK9p7+JdH5ss+e/SWT6rLPnn77l4W+EvttZ4fX2FgPedcUufWL8nqS3NWb8hEb", - "xzvouE9/vL8K/9Y51cUrL6LjuyfHbVch1oPQWuoCom5gt5zIHP43NGaXYomH8SJzcBYvncn67Ou/vBWO", - "99mf/nI2l1PXeiZfYjrphkcdeA2EM2E3ldzRwHlenp2xXN6IzHZ+MlluAL+8K/g2e1GFNnbQwZoSodyT", - "ChZA76SBlZ0eFbCdKvMWTo+MyAVvSjc/F940FZJCA9XNhBImJI+9FBhLLLir0XklyiOoeFtltgDUUbNI", - "rkEsUorsF1k23vdJaWPlcJzU48PK70W3vJuYDiygRUr/IJYrQvpSLCH0FcTypVj+mMM/DL/+wX9GKQ0i", - "4l7ks7SjS7HMebqZzICeZEzYroqFMDJh1LONwqQd2aUFvfhSLLtQMTrmUxcccJ2MKtAz7a20a4B/EMuJ", - "5iZloQnoApmYojLgg3G/+osqFjlP97s/a7VE5/9G1BbFFyJt3mjAsGo2bCLInM9E3ca/zKM9V4Zw5nHU", - "Fs/5BP7nhTH6OqDn629A//8B5l1142e8VGEa7gGQcl5bUUtWP1nSPWNE+a/r/vVfeK2PclmbxEwJtzZl", - "W0wW0jlfW55RAV5nRTbFp8UOV8T7VbCac5Tdk4pVAt9Jyap2e1SzdnIqKZzT6jZSDff8O+q+LtToB3wS", - "jEpRWBsUaVFoRwCePMZSLWma4RfkzvAP8GKB//VxQ/dRqKXvV7uNKftWxJwhzm7I3mk1gFgophXjbIxv", - "WG/1FXg5LwRXRLFw0ycR5g07bt6qAmYyudyueWK4MWlztJ8YGZhhWBvbe+YHw3sVfd5/1Dl/N/ZMkTne", - "5K35vTbyF60cz7xTJMOmfQrBRtT8aS7AetP1ek9DNV3ygVEk9zfQ3fToksu3aNLYYEWXxmmeksAf9/3f", - "H0QmePWDp+XVdd0Dy5lqn+5ghcZhszIUgTlMrjCizw5Rxei8m9s01HK/fis6aq7hD3NrDDil/i3H738l", - "TbQ0BpTXiz06XDrn/H6qf32hKilXM5gNz0YB/TbiaNm+gq6Dp7vhq5NZo/v5qVAMfiv9kP578HeWZ1yJ", - "PqlzMyOE3W2cZZdx/utu41xL65qHwVQO19IKZrTzOehWR1gnj0cr7uaUz/d0ySiB73TJqHZ7vGQ8PqY/", - "GjxbE7RGSmmR1NhgRVFD/0DMWTzu+79eqTT+GzQ0Etz45z0+UHbX0MIL+VQa6xjOg6FKc++qW7mDvxXV", - "zfBUFnbLfYQatW5T5+3xg226kdzbUF4+j7iaZQ1o8MH/vuHsb6E6/EF1xg2beF/K5DkoeG3DPLSG2XHw", - "O6qdAHKEILdbkDC/q6hOw64IVXy3bKP6FhX35Zp6uwN53EHvbaV2RhKlbGpZBuuWCv3aSWbg/dCOvWIh", - "LYgFEhtywc3Sn1L1RYSHffLEFFSd+1e578jHOmjfTYjTQSPvVqLkjpp5e37pThr6pu6Pmvpv/DngPlS4", - "ezCnPxrO/6iG8wcyk/9mjeJsImDTPdNEakLJ8JDOnu0c+tHr89Hr8/b2wo3l5u6olKyV1uikizT0elRB", - "Ho2Ff8QgwTVSaOT1RuQZTzAx70iohp36UDZghquZYEKlPl1Qq7WqAtQ6blwXsNhwC2Dy+YVDbZzrWfi5", - "MkfM3S/jaYbN2D5Cy8TLMaoT3nmUP4IfXcN+3LcTXXVSXQRWY5HVu0qqCLSbiKo0f5RNj7LpDymbIg38", - "ToLXb8ceYRMewLN4R6a4vWLxHRlkc3G6Tsyyresj43xknL9nxukzDo0oHdGtzVPraY/WLVS1vEe4io2Z", - "jx7OStVM6y23FspAOrK5EI2XFvqdeZdHhu3wMYzMJCyHj1jIp1VHT3gmRlOeOG02jIDNwgNSDhNnexfF", - "4eFX4in7RWtMN7D/u36Z/v3ZwXYSmq1V+e9NatZG2FFsrvR9lJuPcvNRbv5e5WaN2BsFZ27Iwj/N4ENr", - "TDD+jNLEFnlO4qQtEJjC/Dv4wkRe6DMDRPcxerfbYEwE+KnI+LKxet8x/MImwl0LoQLs/lq5vt+RKa5F", - "6zm7lrkgVWcnTeeBBfgNMAHHVSI6PQr7tvXBnjMyIV4FbLEMohd3mAPWsceuDcViS9SclxOKM4nJ73Pu", - "SxIKlXYe+kH1l35vuWF3117Gu+5tke8wfsedvQqTuZd9vQfFrSx1/yBaWwl+R5Wt2vFRX3vU137X3kK+", - "RGODVPe/RMGOXjJYOhYmi38VeWcx/8dWDEuW8vuxt/O8s8uhZo7nqxH7juf7f5xQwM2SsZYjqTGBzZeY", - "8d8ncur1e5jHqdfvlWmcev0eoFzHTOhV99q17cEf2WTFx5aXHrZfyHYprQCdQK8GAsSkILBnWI6rjwVw", - "CP+uuUl32bgNqLXmHvnF7FY1s0HIqx8SG4S/Ma9B+AOTGnTctlM+E9/B53P92uh7cvYHoMNJBeoWvbSh", - "/aM6+qiO/rH8FdaI4A+cbR/24iV5JJwlRghl5/oeWVOyCroLf2ro9MikdmJStIGjiVhqlY6uvB66OV+k", - "78TEjRMqrVpwQv/WtK+ZzFtLfAJKYwEkrRi1uaWCjaPgy+zmQTAJI7Zj9NC72wgtpUOrI2CTu6ziZjP8", - "m+CAeochlpuHWN5xiEcp+KUVMvSbsbt5pGTDrwlGg3VkATRHQzAQQcICT9sb/zMXM8g3kasZZZq4FpP8", - "fnJEwQ1iZAsz5YnoxthAIjt+KVQZNu77r9VlA47Xxu1a9Ik1odWoVOjcyYX8RYym2rQ5uoS5C5XoFDBh", - "yq+0Eal/BQLTPAMDUNsE/1XwTLomBqAX+O4HaOsbhTQbh4eUgy7T1i79Sf6Ontfuqhkpnj+MXuQB76IV", - "xS6POtHjxe1RZDWKLE8jrQIrNGiSWYu5W2T3I6O2iAo/iT/67TPTVtwjZwVwnfgpNXzkoo9c9A9o/kLs", - "/4Nznu+5SjPxn/yKn+EajyXP9Oz+WNG8EX4X3tTW85FZ7cKseJKIfIvVK8WdJazF5jShVNqF3OQh+cgI", - "fyeMsJnUWhxt9SJ3o92jAoVywqADp9OMM4LjUe/WkYK/H07dD5S6nWW/41dyxt096ovKQ+zClsu2j4z4", - "UWv8Xd+9DV+IxkW+z/m/CsGwQYWzbOAMzxlnmVYzYfyFWtINGjCPZ1UYd2LkgThbggunwhggEJ3JZHkb", - "o8IHD+KUIKwbFUIDRmM8WGq+ci1GAA5vsX7X05LirlN/kjzhr27Sp6IBfZEOhoYrylpy+0zcEUSLq6gX", - "UbB0I7jVqjzKgAs8y4QJ1eCgrDHm5F7mVD7FiEzzeyrPVJhshGtoeCM5w++xRrWwTiqa948f3oTZofyC", - "WfGJLjCPOPD98X5AHhuz80KnFuSpnMtXz+7t+hZ0gXP9vbROm+Ur5czy/jWDOvxd9ITVno9aw6PW8Luu", - "cQBo3rhITwcMW9SWE2gFZUDnwqEbyOx3bdSq7PF2BnlqpHLn+jSd3h9TzD3M49ddGGG19SPze2R+v+uw", - "J2lzCGeeC54KM5pq7YRp1805o4Y4X2rMroWB41Gp2KB3U9uRE4s8405svwXwAD50iUHgmSwzVfmfdr0F", - "hKJwo1QniNIjXbhMKrFpPqEt821xQmIxEWnaYSTHZzORjvJ0umkMasX2eJIIa+UkE/vs9Pg1DhWfe9vG", - "8me4yx7703yIPc5AniQ83+LnhI6PMGzGZQpbi4wo9G0DvuBmJtVoop3Ti/UBvsPvjFox/P9kvkNpDQ8e", - "A1DWgL8RU3dn0KbZ7/QDfL4zcKfzBv6r8zsAbtZlSknZbHrmMzHCnKq2CzL6QuRqtoKHLTiQ81yYVg/e", - "U/i14ru744IJeItbLcGODrW7gkbjxSixdoQbBF5xm2kEfV1hc6Ap7k3uDSDesY4IKd/iYoenNYLoqZnR", - "hdrgxFe2YTPD87lMLLF5BNF+JC2Ozqd8FiQE+Tj/vusjGa4snPBCp7erbppOzz2MtzptstZ8r69xnaVo", - "8JrQ3vgD/vOF/Y5b8e3X5L8avp1h9Nh92Ghua/34gFai+1PsvdWpg1IfWj4q9I8K/e9ZoZczpY0YJTyZ", - "b5EqRBFsssw5sUdYIHRr1eg06pcb3leiikxNf1MvLbTcZjsLruRWKcWlAkYnUkYdHp3Pz4T7SUzeyKlI", - "lkkmzty9vnvbBuhduH9zv0dZ8CgL/oDOQ03E8LvJxmJxNbfQute3ZF3vjg0YDsM43VDZ3nhq9C9CkbpN", - "tTYfTs0Oi+zAjB03joK7Em7vMRLI1gF3YsGrXR657yP3/Z3XTjfLkXLzEbodra/1NXyGAfPMJ3kR5oq3", - "ph+9azAsUF1rbBHNpS0YFtkahMPeT4ARv2k1273lN3JRLLynVmm+q4Z6Nzy18ps2W10dYLTZbYHXIjjr", - "LKxRZt4ujvXx3nDmdP5G81Sq2X2KqQi0m4iqNH8UT4/i6Y94OShp4A8eaAUc6WF05yrcrnzpUXN+ZE2P", - "rCnfon39QbjTygNhQzL7a8ZZ8D1J8Z1Qls+EX0xqy/pjZq/fq79kds1hSaWXmvN++h9p8uWOcUUsmDKC", - "flm5QIEDCtVxc1YCRBrKS7XEh/DgBIvVVL+YzLJhPb1+5Y+f5kJBLt6Z4SlsnzZyJlX8B/z80mhr34fv", - "wOvKP5yRiWv8c71noSyfih9N1wSsa3f3FjPC2tWdNtTG7l/MGYHFAVBYzXbaokrqlKNfu6X6qm4RdP8y", - "twiyk3XdqXqKmXVUat4h8j3yfb8cXggpcTpuzDk3M+FegOEeXPPxr3vR+AnUkNcgb9H5W/o8av2PWv8f", - "S+tvJITfUd0IWM4mdxpq8Tm8aFoLOsc5b76heA6aafsAzDQpwXbjpLUOj2z0kY3+IdlohQoeeeiXw0ON", - "4E6Er1o5cXO/zLQBfkeu2tjzkb0+stffe8CktmKk1SgVjifzbYlMFGXJssz3TMvtTsWkmM1gjoG3Ekhh", - "u6fx3kCMbenAbpYjcvoeZdK6TpFZeFjUiUEn5PaJVlM52xQDSINZYa6E6T7OCmwMQ6RfvHz5fad7KZS8", - "EsbybKSEu9bmckTRoCMyRm6vNUftLJsZroBjRYDMA2QEkHY2tHZzsbAiuxIWCaRLMrfbvF1UpdoDXA0q", - "cHeRYo+Xg9tIry6hhEBOXgdDusbtTkP4RAmhjYLDDnhGuknV801Lnvs5ok8eJfqXl/+FTzIoOwTMlVLI", - "AQYZnbVj9XfQmB5efFvEbgKVsr254GkmrGVaZcv99qQISWE3k44S11XywR6bsiyYkeOTzRkGJgFgtX6I", - "N/KvU2p7soFmB86fpEr1dcVz8/jktM27cS7TVKideQd1a5tYc9C+n9aNrzBODJBefiplTndwCG0QH436", - "lhLXo2scfNOpwDFTq26pHr7Iu7rOW89lectz+RIyxfV7La7Jfu3RJ3kDpRBujG4f3IL928Ja/EQQes35", - "W4GcyGBXFlJhCSDM9bfgN+Uf0yLL6MA+V2A5Ud8xXa8ezlKSNg3QTcls6fqobe6kbT5qgo+a4OcxnTfS", - "7+88ZV8DuXVhw+9zoQJXuk/uqytwuzHdeo9HXvtol/5D8q4qGbRk6VIia9ye0I1hEwaQRLqB39y3BH18", - "kfyNvUjqIpm/uhLKNftS4+/kMc3yObfii/EVdDBzjJbv9emPVyoN/3yrr0T490uuEtHZq7CedX3dZN8x", - "6foXs42QFd7zYdg9T3yjCTfwV+H0aKL15YKby/C3LSYUHQ3IqwqeVb9Ed/zQ2ukc6dUzf2i7kHBkPrlP", - "v3cpltfaVP41qgLpcmjreSCa89llzbkgvpizoowVsLOYrqLr7lQMCetpN6lZsGSt2BO+oCABsHoARgaj", - "B7HW+O/S5NFp17SyOhOvjNEGmef6xr2o3lihMRPQmmnDCpXwAkypZbEnJm4SgV1DdMqrhXTorg376a41", - "S6V1UiUOVRqrC5MIy66lm7NUTqfCwBaBOsjsnOfCDtmHQjm5EEM//ovTk5fAelK2578MaUbAkOw+y41O", - "C4CJ5NjHSlB9UFttHzUg63hyOXKGJ6KEHad9Pjf6WrG9uLb4SxU0wcykEn2W6KxYqL5fyqgwWcM4r6XI", - "Ui8fgRgTMMYHtZN6oo7FUQtoVHu5EzNtllU1yq+/8YRTf7PpYoRbxQK8FYGSgxPrCAV7nlEPTDUJW+ia", - "6nGfG9AWvO0TTnoKu0PlxEMvlha4P5hWNJML6eyw0dzsGl4pcCoMDtY6vsiZVOxHJW/YQiZGW5FoUKe6", - "aenOS8eVLR8hyvV+3qbHOBug9ssTjBu7SaVpPJNdzavYM9gEPvZ/XcEpIIoGis+ySOvxOsYSLUxCeiCt", - "1Q7ZKblN4EsS3YhoYZ7a2wgXtl46scCx17VU+sCN4Uu6JwF9NSWtgO+MErKGR1tqAHMxZOgt+RGiF1J3", - "54mvcIVhI4aQ1G+8BIRdhE4kGvqMZ9d8adlFDzHoonenXVzbvOZE4W+kEp9/o0oGuT5DeMHwjxl+ZlOZ", - "eQHq5kZc1+d4DxOrpeUKjLorw+RZdga9oDvS1nqYa7HgamAET5HTk4TyosjWLAwBSa51kaXMJ71HU8Nr", - "bVhNxO3tk5DrI4CpNNaV9pgKgXJPogSiQZT1/SOImMobFFY0v4Wwls9En+ED1EXvx9AT2dARm2i9uOgx", - "baq/7UmFBRilFfsMLhO+8U15IZwWCg0WF73aI1Ibz6wbMANr/HmNOb7Rs85KC9Qkpdtf1BoyPevH/ZVq", - "qsu/rrlRfSZcMtwffgZJHBb2KIe3yuHm0qL3LIVr5/HbksE7idINoqpVyQYYfRbz8BpdzOasUFOZUQlW", - "ZLdkhR6yMfKRMb6i6oJqELGaykREaJlU1gmePmc8yxjeU9iqxLSgKgtuGMioITsTZAW1uUjwtoU8sMgy", - "BjjRyFgeiLe/Rsa7ejzrpzPcyuqCxWA7y6thUevtljhceFpEoisNNoElLrSSThumsXhulsGuDoL0pOMZ", - "shXzM5nh+pSqjO43ZYg9E7lO0E3gei6TOXagmegkKUz0RagjfntFTDjl1XKYeEOUqjKZZv2nPQ80QG1P", - "At1nRljhGKyGJ/PK6hrHUfxqZMW/GnK6aaUdWRKyJZMqMYJbuNZXtsuC2UElQSXrUzOYl0jjBJzOvQG4", - "0rNxEzpwz1tYqwOF0TiVV4fG/dhgWg64uWZbZnvWoXLEQRrYyjptWCj6hO1vGjHIhQ6UTY8OVGQS3XOa", - "1VAjMnHFlaPbubSEys/JCQ0awM5UzgRoAX8j0ukHq1LZ1ns2e9LayhQqh1Xd2PqSSxTcIL6qqsBuj5yn", - "Rl8JxQFJF8Jx1A78yS0Bm4nQvT3EMOGNPJHy17Um0aypnXoQA2DrcioT6o+5PIIjVJtsGuP2VrmXb+G3", - "uhlxLmWTTzCpKmFBQ3wnGx95wcbia9Np8BuiEbxVq2SuQza+FAYerXgux0fsB/yDvTg9YRRqwPaMwH/R", - "iyJ9HJTJXcLM2VjcOKEAEcZHZSp3P5/4G5Q71QnP4K02EdaOj5hdWicWzH9gplAKTozDW423SpbTrRkX", - "kzRH43SYP/wUBur1e7WBGjXdgCrtyNagpGzDhyDNCBmAWxEdHHg6OSBRcXJcO+9ACyu0hYe/gWK+dy7/", - "XoBssO2LcKZYI5jvz89PfckqyxY8h9O95iZFN7KB9JgCswfWpgvHyJQrfyEhw/5GZmd8aF3mXn54LY9N", - "CscWfAkv1lwt8WEbWtXLIawt5kQ5YTgy7ZeZTC63XpYK+E8CTYMm4X0J2ZXkJRJSzg2E0O12JMuJ3PWG", - "1Limx3tS6z2psvUjPNkHvC21n80935msyETidEMxQChHFX5lOXfzYGPHtYuUiQwVrRaVYtZgyDl/+4Y5", - "PiOJpKdN0ODAijwXJuE2SK3vfjw/f/+uz1702fHJ31p0mEZl/m8Sq+uhtYi4n3ItA/eZM3KxaDEG3jTB", - "Fte5No7dDEoX5hpwWAvsos9C3Ihkyw2Al7cHvIKHNz0YqV+eNp3QxmtSBQV/EMutDO9SLCeam/RLYHdh", - "PY/MrhOzuxTLT8Pqaudyz4wOFrG2gT+IpX9njtrnDx6PaW+JAb2CKfbZdzy5tDlP4NbezIVuwU0D30P7", - "/JynFPxTOsVdimWoBWhtC3fqzm19ZNEmbnvy7vTH8z47f/Vf5y8+vGrnuavqoLgDgzlLjM6yM+FcJtKt", - "rMZia2apuWc44d7Ep65sEsNNrNO5BY8rBYHY/d82e1rfjUdG1YlR0amPPGJ8Gp7Vclj3zL2APY1umqKf", - "EM9vBhHTufMeL9y4yjsgtJoJC0jfRS3B8Zat4y3vezxvj7kF/6SxtqmjumnzXkvFM2bXt3DqvI9pWEFg", - "NV1WokfLLUMt72WoFVz2GBKPzi/aT2h9hzey5jfySoAa+pJMla0cOZNXgl1JcR0dsqhD6QcO9/hpkQXe", - "/cSyn8Tkw/nLaMN5Jy71/pB979vBI/RzfOsMDB1sOzHQVkKKT9v5IdHbWe/Km5u245Elt7JkwIoRYEXw", - "l39ATtx6NDsaacFM5i33OV9iyUxAvPHaWsYV4/PqVbr9ZeBNJJT194EhO6sZ743wQ1nv7IilhpG8gv17", - "kskc4y6ASNAVkCZFzn8x5GBcTmm8k7G8w4Yfx8CH7tyhDJaIXow7sIhTLuntqvFUJsu15X4OFrGyLY9c", - "ogOXKNHiEzCKpgO6d15RiQpqZRdpYdBePVo0JYfgWTZIMp1cstAuWoAizsJpLGSWycpB7FRbfRNXek6h", - "T/7ROtHGCJtrlWIsVBtX3PFFrroFG47uLb2yH1e4RwvPOffhXZU9cjq89ABVZNq6ITtHXdGZZWCb/kEg", - "NRoDdOCRLAuP+6PIj0UIDYNHfQWO7DPMUwWUjB4a5ApPScASerGoZt/IOdy9kanHLn4C1km4rgra3/Bg", - "jC/+ylWfSPdCtiiZZuhMMhOjjC914cK1x38s+4Qf9n1Wg6k0Yti4uhjBb4R1mrwZF0P2ApVUI7iDtGVo", - "N+BsaoSd+xUvOMTI+UuAbVwgCCsjbAGBcGLqYTMFdtmVB+CEGziYRe6W1Z/C2xWdjVaCPCI66oJ+tXfl", - "8m2Y+MjmW9l8wLOq7H9ANr/xhLbx+ToeUbBWU60M+B6JtFwYPj4myGxGQEHcOJHGh+/4ihx+GVbfi1d6", - "bd8hP7vtW3GipHvNZbaVaQYZkKD3rNIOWKJU0kl4W6X5fmpKW5n8I51tpTM4sNEUt+zhyazpeHYjMutE", - "3o6SFLvKtCnx0Pt9OZGTyZyW6m3X/gphCzOFWCEM9exgu8ZJbF/thyAqO5FTow5Soy0jBgL9tqSdR8u1", - "uJnzwjryM8nKyyDZ2hzIRTtk7zSbFoZUi1Vl5hpUCVJUmFbkeOVp+3OQcNOuPdLxVjqOB//JiLn1oB5E", - "bNYQG5ZYgFZartrTAQhQogPA8EAA7FoYwfAlq8ijG5AtMOEpODIvvQobMjDUCbIqeRtGvEfh+0Hc+cqy", - "sqoGlsFXdZBXxAiCBTUt4j7MeI5+UXQPerl2cTEixNiuaOXB8uQMTy4BmldV/D3AG3OkZbmWyn1WPvPI", - "Y3bmMZ+UvdyFtQRa7Wo8ge1bNZMwxy8FUlmEV3mHqZNSl/1d4w1Nk9y+P2V9s1aDai6M1KlMKsXMglUo", - "vI1feeehbhRYwrknIlxZxCMNbqXBjUdwzyTYdDq7UWCuGjxNqG7nQKhEpyJlp+/+2hFB47ZNlk5s1dJz", - "Ndu0xnckoU7STGz1IAnSDIxojf4jnH1zeLiw7F+FFM7THb09KM2kGkwzTHyLrso+SKGjJcoPfVd6W/EX", - "eKSwdQqrWkofkLY83vlq6huvhusImFGvcIv1iT5Opl5FRsTC3eaZETxdwv543EMPMdAcySwLd2ClWW4k", - "PEWEtXsQY4RRfVGXbr/PxoXBtK8hfgz+HcO+xhSbNjbCR5vDBowrqTWes3EDMmLEYs4N3NazJct1XmRl", - "LnjuWMKt6JqV456IpfWIHuXTVurxGPrwt9DNh3TP/lQJJvjadmZVAgw9VkNAtVl1G1w/OmGMNqNmF3W/", - "bJ82oPKbN2kp4Y6OXn34MHr5/t27Vy/PT96/G3149frHs1fHzT6oftKtAYphUZXowZjk0MVKIRwtUCts", - "pPWRD0atcInmgf1Khx98UwgfrJgDcIS18OhqxI+PjP5B6WsVcktJlWRFKtixD0fts9fCJfM++6/vP/QZ", - "ZVLqszO3zISdC+H6DKsE99lbkUreZ6819DkXN+4cbrZ9VqHuPjginOnkErq95UpOcYanRkxpjPduLgyx", - "yYU2YruhsXI2Nazolwi50S/Lb+EHAtNZyoTjs6joNAcVPjz7rc76kfFuZbz+0B6e466dyz3z2hApvjVd", - "TWhIegJZ/EMorN+NRt4zr0QZ7jLvaoTierp8vy0hEnEII/k5Adm2srmT0GYIbZhUqUyIm16T+lNYkd4L", - "z7Oeu+XcWOBDOeVHJIaEiSAat0vakRGpNCJxmyhH2lJU2GpOXz1lnAUIwy0FzBpCO+lHBqZNSjuEwK+l", - "CREIf3113men78/OmwVcrq0bBfbTfGYTnS5RtACUg9Mfz+MlrQ+L41dcZuBy1yLKaGnN+Eol/nmGMekV", - "V4bQC4+hzGtc2WzcRlOIe5LafVYoCZlmK5kMKs88jxL67hI6ps6tsbCS4awxhG7C2+ZaWbGD9KYOzIhE", - "YGJqf018LU00WHj6pIaI/nAo/s2AuvXx3RGx0i/AvxJ+HmWgsguP2kAHbYD261OoA6snc8/6AGBn4yH5", - "k6ihcclOMT3d1Kd+Y29P3r6i1EafVCXwM6vqBF1knZ5Wr1bZRm1mIRdtPDouOgCMW0WCE3bmYO4WWT+k", - "RoWOWIng8a74m5dEmGLLFbYFleJZUyuW6FS0ZIfEBi32hkZYlawg73/os3fasde6UOn+bQWmX0lJiBsl", - "I2Tafmk4PGm3v33xmXhimREqFUaY6E6XUD+2xxW76L247rMzxfP/66IXnAr2IcNOVsvVEjtLZ0U2hV1Y", - "giQFt+Yh+xCys4eyEH4EPwOvY/UrsRb0Bc82pmay0H1M2DsM2VzGkB3bR576dJthamMAP2aBYzMZ6wx2", - "NZYCgLtK59WTeJTMrZIZvaw9bjygVG48kd0e7TZkFCtzAFV5fIg0qCD+p00cBqPDqIgJWvmrlGsn/+18", - "qj37F8xiywEc68VLyh4C5ukO7zvH79/WOoSEqbDfAHCYRogIC1X5jglS74vOGxf1SPCbCT7Vi5FPJINP", - "Iw9O++2ndN9PImk+ivvWwCnII20RkjIycrDx9WoU83vLuPMZ7dZIYAr70WdGZNzJKzziVXlMLmV7Sjs6", - "NcyGuT9kP1rBxs5SlrrruntPQ9TTyv7XV7ZVE3mD4TRdk1FQ8E1LMoqnflv8JR1ZGmBNxZXACXMlMK1c", - "gDSXU7RTlYbDK2kLCB93fCIz6ZZD9gryWlY7kOce2emeDvyosGjz6ZjKo09CNx5Sj9d6YP7hsRlwZCsu", - "J8Wi8MRZw629l2/O9j1qx7DdU2FwA1Qi2LlciEwqAdkZP60QW13eo/zqhnuwYZ8Y8x7kbcm7WDZUtVsJ", - "m60htFDOLNf8Qvd8QYlDFDPVDpblwmC67P3GINvqro5S4bjM7O5RxYGcKhvHuHNGTgon7BbKwyWt096c", - "p+DmC+oKFs7cjNK1TfJZpxKRktcDprREIOHJAX3k+kzcgF0FCy55/vDyzVkzyqO60BCIXB3XJtoEY4+0", - "/qz2sAA/7ETwkH9ztt8s+tdw0lubdsySHTJm4feyuEdti2JS7sbbkWyqV954eCW9N2Hr9jDv1XimlQX7", - "uZQB1x2UoCTfKi7ewDXKOubVPMjhcMolXHPevDz9rcqLJC+Z0aOcaJcTSf7Q4qF6EvcsFrIkvyUb9jhd", - "ojRh9F3ZsE9O1ch9ZFqCD/T/5uVpmZhUTsMjSGui/lEzs4GbFyJJA9xO2SOUTttZ5vH7twwaNHDNyjjN", - "Nmoy5LRM+wP+2HXiz73ABsS3A3qS8ImiYmjYuVxINRu8yDJ9PaAn/Mb1Ai22p5HlRvCWCVGeLmb/VfC6", - "PChhb3N/qUKE9eASmAaX+VTo8FNL1vuHFXrVqQEPo9N7ALmHAzUpZ7cWetslnebbb/nlzX3VkJeF7p/D", - "hBfn/ijOtogzzR/8ol07i9+4cc7Na+j8pZjmylLK3Si2WimGEmus0S/yCw8X6Je95MZIgTVUYtKZKdUc", - "lQq51gRLDjjmy4b4MnShvEnVErda2OfTcoeV3XrkEZt5RHlYD8wpms5ltxe920l1FbCcWuxa9emduGab", - "Kz8xbq2cKR9ihCSxpfhTzg2oxe3rOcUG60uCAUIN8cog9rkPTqIZNBR+si2Ju3et6nRvtZs+7ctqiQNO", - "31v9JPKKrGheJRZ1JoXN7y2h9DU+BLc8xMXyUSsGdjbnV4JNtJuTnIt+RLaOO7Unl/gCLS2rgKeXGCwn", - "g/7D7ESlIhcq9YUlqjGHzxlnUK8sEzGxW/CNionWJigrpfuUPh6PzzS7yoNP9FRzzifvc6E2PDoqcR0V", - "HMcnTEd+AtuqsTPpNsQOhiE29FzTB8R9xGvqB+Wx4OJigys7r6UCk7aMLvUJnWEKoYSh1bWcq9siSb2+", - "VI8hrShOkSoQ/UCvbIovhbQlyhYLYSwzgsJnV/Q0rAEW6j7NMeWSM4I7Jh3oahwt+ZJnO8Wi3pdWVj/l", - "R6VsMxE6PhkRXn9S4ruFToazbNaczts8rICGMdjJky4Sg1aColTUclclo9mdK8g7Ja6zZRyKTx5E83DS", - "ZQ3mH4qKyjzvgTZRKxXXrZNpVGMCqIrprB3GvXmBZdwBDr/IJVRMbOXQwHToSBdcoQmy6nf6t7e1hLCp", - "kVdB2fBN+mzOVVqJM6YaggOyZw54Ln1a7CNmRILVoWYsk1ORLJNM9LHWuy9biOqQv73TZHydq5gwDlpU", - "qntP5cy/Dw3Z+VxYNHiyhbYOAvn9BgykSoskZtzLjYYhmeVXos+MwIrrvrrKfm2xfIaJYxNSwrsyXT/q", - "nRlvw/E9st521uu3C0pXjgClH5L5th3N7lm5kfhqKbnXFhLzcbO3oRgrOGIfMR4xnGg4CWYgDfdMf/3w", - "Fw7UfBxax7EwPxsnOhVjf8Lclr+BD3gcugnpb5sFnLiE6fSIA+PRIE0y4y2m+U6pyvgTy2LrPlaOCuvx", - "bAe/oeN8nIIvLXtKrObVjUhA+8Pcmx8CixrvHn8CB9oQfxKf39YZY2i9kGmaiWv+kFEWm6IgavtdiYXo", - "mA/s1Oib5StjtNlg5OQqFcjeb5aDjC+FCeEOTE98Udx6ooohq92h4RcQApoJSmI+19YNEB6dtGU8DkO5", - "Kcghe65tJe4oUAlGMPzXgGr0DnAFg1dUwJ4iQI4wpdIzun+sz9r2mTaMs68Pvyrn568WT2wMhcx1JpMl", - "3Zpp0FRYJ5UXWm/09eBKZ8VCxEziEhcCW53SWbITZ4NhHN16BtXwDfgb9IrwICt9xkrfxpJoD8l4vJzz", - "KghN0Toj+OKIFhmXh5IUIz7oeLDeRxn8AXpbAJDozJc5krHksGc40sI3rpjO3UAqZsRUKnqVCwFh/Hql", - "SHZdBrNUTHmRuQGsNxMGbR1gs+PZJ87Js4Llj8K4XRjDTo2QBh9SDDecx30/YulUNJYtj9yAGA20O9rE", - "Ukw9DrNawrGRadUZYgvbi3WjFxJ7YrYGaI+/oku3ParymxGyIZH2ax9RjI4KFXMM9KNRkLjXKBVKQq/c", - "aHjZN6NJxpPLTFpX+1ooI3gyJxDxqxFUq7DvYy9HLrP4gqYLF7+F/RlJBYeVCUcgbpb1iRkBWATgmqZd", - "5MTLSvDxS6rsyLO2ytd6wuIhe1E/H+Jf6NRQKTSR6JkCgpOWmRB4xy0r1CWEblai7GqwgPlxqD6Sinrh", - "9Ybz6fV7Gw+o1+81nhBxw7Ujqn6unFH1czgk0AXWTqn82HBMBKV+Tr1+b9NBwd115aSqnypHVf1cPyv4", - "hTZ8ncP0ezcD2N3BFTeo/ME2H5cb+l3c5crHDzDLH2uT9CG9p7jFx2GHT/2efVfb4PD1x9r+hq8fyu0l", - "V57zzJ7HldOnEKp9Ut1aZCL1WX2IO9sw5R/9bpXAw5djZV/HTQ0fX1bTZ4fhkGX9GDZ3t3hxOpwy3hk1", - "I4TUrE17imgo28iVdFDDYbOSRsS1EnKPgybo5hXJElUtqhqb9lky54YnThjLdOGsTAX7Bx/8cjj48+hn", - "Mgkkwoe8jPoMTCPaOvbt15WORMQLfvNGqJmb946+/RoeB50TBub//0Z4//5vDx3Hvik2/94i17ec5E5X", - "lJhgdU3u7X1z+AwV67uo1fu7Xn8QBeMaNvp0fBB55l0tmzLtoI8ZZmQ2cgHTwdpM/hYsbkRCCrouXF44", - "Jp1YoI5V6UClRBc8zyVlrkX5s0WNgVlh5H+YWigvv7UX5AYInT5GZXr5ji9gTOdNpFqJ7jrVOtjO3Wpr", - "WN322o+7WbpBgR5Nvv0a/r0lhe9KOosKReNBHDT1WKvwu2h+eVnVfEnpLcfrlxPdoPfCXvi0UTtanHwv", - "5rTHReHZJJGZh88+vDp9s36xamTT/8mvOKWhYAJYccibylkujJUWzoq9A53nn3g1RB+rC3Ue3RwmEt+Z", - "bWjvq2XBdF6cnkRrsLiRzvbxM8yOSXuhfOZ/baqfmRMmEF5IjIwR19iOpOKQnZaTQwXhQmGJAXklwsPc", - "YJbpCc8Yx1IG2tgjlmTa0s04BCraYLpgGXdgzRNZdqHIpYQ8X9nrQlGJhFQkGSdrimWFFeV7fhgCiwT3", - "fc4PqWYXCn5GoPWxawN8Z3giMrSYF5mTgzAO2BKvuBlfKGBr5IjLjHCcDlsa/9I/iD/j0o3OBtNMXzMr", - "Flw5mdghwWFSXaiKe4qwsQwDwfYHaJ+zaVgzlWGAhgNyG8h0wjPLUn2hlHaV3RkP4RwoE68RdPt5zsbh", - "92FutNNAEEOnz5Ca9vbHUATvQombXPvtxFdUj4JAtXB+meR2yN6IG3hdpdNG00YYhbDkQmVSXQa7hS/d", - "EbSZytGRTsDx+QZgAVYhHkYcHF6oF6Fj5kctS1IZlgl+JbxVBiF44js//vvz6sleqITDJlU6M+mw8qqT", - "ScVRSC5ybVxYFOmZzxHD0qXiC5lcqDG12dsfD9mrm9yQOA1JZqAj3WxcYRTsSOH0gjt6jh6y915Y2Qul", - "c+I0z4lvQBHC3Gh4XWFKl7Zm6MjGRuTZ8NpIJ/aGw+H+mGlzoeirWEiH7Jx+6eN0E62szoTXKMm+lujF", - "BN2u0Yi3EFAPX9oFaF9vqQIild0r9T46jZC4Dl6FKOd5yDCGZhJyDvgTeyu/618opGfPcGgHLeM+FVlI", - "EZ9ysdAqqmX6KhRfwO9PLAG7UL7BAN0ucazo0R84U1DhPLa0aG3C6xdo/Grh5+ceoqjVXgS4fe/9Gqoe", - "4gutX6eKrHrVVly1GBGrHFmR1Obx7WF/zRp/IxfFoqLdhBIWwYjEjqk3bP+3h0NSm6FP7+irw0MQgIr+", - "erpVbUMptFU22iLbXTSGTJFVKUhoHlfWIBTbNEFPKEx7lRATXfn4CKInTzjRyBNHec60t3tr49EbMVvp", - "0JXiHKl7r99DNbKjAbKqv5ZBGNwYvoS/g39aF8OkuHGsDPooZxZqkmqzbqmMNwGyVlakHeUB6B8eHg5g", - "PWCpZugEbfgyQJ8U0ynu5kS4ayFUuWe2EYm7PlWto271harR5EnGzXWjKnxmC2EtbIqs6vzRbtFA7XnW", - "fBH88eT4WbgCLsMmiRueOJK8g7nOcPMQWYOyhOlagz/rhYpTWC3bDWyaNAr0xpfFolLJ+zncddVM2CAg", - "ufIMEjkLxNDmmUykCxWY6pvojXueikABa2V1eTYqlbbNhnCEFq/ESDp+88gwHsEQUZUJYS/UXpwV6hKJ", - "zrBEcJHTwyG+5ZSTPQC8LWZzB6HCIqdb5YU6DxVgPViW8V8k+VYaZyO3RTgVTcHPsbYDFTS1jieXDSYQ", - "+Izlqzpjkq+81YDsc+HfVESVp4m0VqyrYXar7rV+gBJptzDj6kVwtzsboJ8SDd40qFKwv7BSvwBpl4KI", - "/UtQIoaZnh1INdUHqZgUM2wgjKk0uOZGHRAVl7ZYhIaWgJSsZ9St8eUoJKvbehvEhl0vg2HV/dVua7t7", - "JsyVTLZmoSM/mhRfFGQi8CaFRglxk6OuCCreCR4QSSzrdG79Ezm9C2szKFNb23nhUn2t9lmqUW0MCmDF", - "LfL//K//TRpZOQqO669ORKVZYCWDmbwSgyIHVFdW0g0p1V1f98h36K6Pew27+fjA1/rA55HpEySTazuX", - "W7jaAIi6r83KMkpPm1c30hGfBISl1+Z4T6ILZ9TbCpUKk6F0rvuumVjL1BM13i2RLoJ3ChAkiTO3JOtG", - "dIxj+Zz7ay3NPGRuYFKRKr+HWmG0/u9j29OTY38TpJepJipCyE219TsMPWRjJNoiH7OF4MqGB0dceIpC", - "mfyyJSZUNQzfQ0TKOJsLnrn5MrgIkAozZGP/dwDIWW7EldSFzZaxT22EOvMaz/iVGDVPKJxErJTpc/L5", - "21Eozomn7EhtdQbO8jlTZcHaNkShwrVTWU3+EY6V7FhWw222Un3SxtCJSEu0nSBSaR96/Z5fUSNTyxtd", - "j06O13Ig0hYM2YtJmdy9aW9gMFbk69V8G7eJ3McyraBrrK3JyXh2enLckuDVb6Dii+YH9ZnhC29RqS8j", - "7Kf32Uq8pgoOW4vCOWHgX2ueVeMuNZSrc+p7qtjEilDQvNeLH2SrOy0oiG+kKm68sxd7//7t4FJmmTBB", - "7qFlMh6CVPj6BCv+29shI8mRkmfA+CAVVweXCzsbh5gHQDOuSnJA0Cuet0FoLMRCm2U8UK2qty0ffxuz", - "U9pi4mEG41Rgd7bIYaOsSD+xRF7b7keB3C6QcbNGWi9GgBIPKZCbj2V3eQzzXBHH9UVEcdxkdrHOcNlE", - "gT/N67QgEpmSuS+Q4pCNlVYiiAtv6F+jludsvBCLpCKWkpnRRR5aeuMet2wuobJckhdWuDE7wH7aLL1v", - "BgUPvfvx7YsD+jAAJ3p4TJVZVrJnrfyULdNZGtzfvhke+vj3VFIVdgGjwgKtM0VCiZnHWi9waUdjlkm1", - "4mACi8VM14sEZAvNkz6Us2yk1oVYjKZGiNHlZH2jXxshGB1Z2BKp2A/yO+a9kKrJUGByfZYKI68Cd4PP", - "Y4B+9C74IXtTOO3DE8veisXgRE01S4tFPmQvrC3QfM++xnHIU0r+IobsOLjnhIzpRiQZlws0dySggFjU", - "vjizCzBOk0+Ov6Jn3MwEntrIacez0eUE3xaYdYCjcPy047TYa05DoeLH5tyk+GZhsRy4P005raykfnac", - "qt/gzOICra/ee6Eayb06tQbGBb/c+Sje4X5a9uHFW8KiOxzHw+zCNs3HC8Og+DTDoB9bFJGXerFohsZ4", - "xdurLm73FvyGPf0GfUNsvyIras1a3MmtbTzSD8LivYBZ4UjYNM/KH/OeLXDeXGk1MNZSVA39C3Xb+UIs", - "4M99eBEhp1yAls+XFl+oPNZU1UNA88KicteMRM0b7HQ+ctxe2iY8zVmpZKDtjlY5sMINcJV+qIWuuggT", - "xlraewBJsckr2lINVcfnMAW6YYyZj3x+hbb0DUjpA9yg7UuOlwHu2DdMKEcu45pNdKHSKLUQ2RFZdzHB", - "1yQozBMpnN+cEIxv1q3yzsjZTJjRNgLw7SpX0S6kSMKEqxQ42fjl6Y9H7B1o8vA/QBBH0dmqlC0N5x7m", - "2JnAIqLh2x7P4HEYmkXjaqXwmJ+300yqK31JCnOpWw/Z+6kLzkL4pm7ZuDqTMdurgPFEVPFvEmYfk6Qk", - "XLFUwitDeV/ynRKapv8Z9vRKJk4uhuxtF/pvNH+v1ouu7h3xu8giuqpkiFC7aWMvYtC/PxHKZ7WNqlAK", - "rOlm3c/9LnxzGyVslAHdmW5diq5zpQ6OZnSI/kS3n2UlNHVTrGy1pA4FqM55NMUSZsdqNrVw8H5PYsR7", - "r98DRzphev3ehCeXoNqqdOTbhKtxbGLn3Ii0/Btr9TXqjGEdIWTzJV0upLAvMV7zVkFyvsJIGQca4lis", - "cA7dh+ACEQJDW68NPHfJfPcggdW1LP1K1sstvaQRmNXZlQh2E6YLl+iFoOJL/n3NZwB+qHlkUlAOSJ7M", - "D1LhMPl6tO8F505AKIoVACUBLThQ7D7M0+pMPOQkaYTwuLuX6VmfwbNMnzxC93FW6w9xcR+d0dkd5kcA", - "Wqf3Ygaaib+r+SBgxmdcKutqIdLw2gHjFegCRlDpbbXPTjO+vDZY/bzuStBnNjFCKDvXzvZZksl8okEA", - "kzdYvxrpXALViwVXaShDeSVWjtFX/HTC8IfGsB8ptXIcKlhE95JMJpe2zy7FEp6JLC5UZ8DHP8awhQec", - "mHc4Rql+EN0NQjmjIaVwmj0kXp9i5sVIbGFjqml7qOjpSvkESEFM8wsh5A/JqLLMVqP+vQVyLdi/XoVq", - "L0bwV+P2+0HcdorU3x+yt80B+s+Znk5B+ntvI4RBgYO4LyXFPOTpCSN1KhM24VZ8+/UgOIABY8y1cVW6", - "HbLv5WzOKIBz6+xxrx5w5t+VKRvo1aQPj/tzxjHIYaCnA3/LQ8MTTs8/Dg+CkZ2M7sBgP25QUVpmtJtg", - "f1nFCbJrBzW0KuZphHVZ7iuNbfJ0kLZWm8yrDCm8drNqgV1mRUYSGZrRiR2RDxa53Ejr7VN7Xm5ez3Um", - "IvD90qez/AjI4C1OMJYf3JLzTrastpXCosbptPdZhPm9OH/5faUEcNtsrE/TxVVwhMTTYuNfP473YTmc", - "KT3Q+fP65MgPmILig9ugf407176KG9OGpdLiP3nZ9Upyml2fLXXBFgVVaU9xCsElaAwLAYdPNsbDHze7", - "vnRCsjSvS+rd0OysqiCinQsSeHpBGt/x4IdjcXWudWa9RkTGngYtkmoHiHTk/VQb8hPQD3CgiBlAfkFZ", - "rw9PUVhD9j7cwzNpXTzYyqkqsU/uc8iCxJUwS3iY8fYomgk8WydZEdNgVejIq8khcYRiYRFBpYAOZO00", - "IsPSgj55VmDhhSJ3sLTPpGNWLvIs+v7ii6Cv8AvJVSXicmp0jiDmcjYX1oU4d79tqDaNT1ReuGEqbQ7B", - "TW914au4wu3S0MPivFhwhZFgSWFKN3nALUyH6knrLLLlsbfMcs+qE27JJSU64hZGBWe6OikD1e5u0EEU", - "xW2kk193rOyE6LdB7/OSVTbw05hI4Wydw1WQLpzxpVg24R7OGNGvmj0gSDkr3BHLQMO9FvDfMhsHz7zn", - "hPW1MHTWZ+X1p8+C9uDvZftD9hNV6Rj7GY37pbtEhVkC37HChWqTR8g28ZUl8Pjn8EhK7+7BlxYWPp2S", - "QzgozBV4e/6uE+Oe+3in7lf12/0+G9sKimF6uKDA0BNPg/hH7jgRsOUUlKAhxjguzx9aqK1FE/arYkkm", - "uCHW5JpPmRYzXmglHYRERizGfHplVgbSBvbp6d6VMICzz4URz7EKSqavbd31H01g6MPBq1tWl6YNb8J+", - "eV2TcbVaCsDN9gZY3K6QXmGvEop12nidfxcwZ9QtwOlIxLcWVesaEeJ9vFB6VYid8YVgY48m4zJQBxMF", - "qiVD20xs32d5Vti6oaRC9Ot3y7phIIjBpqf/NN/5iFeFORzxoyb3x9DkalS5G2m81uaaU+Y4PY3nX+GL", - "TtOsfdRXLcfOSsJbzJJRwaIjRkzGSwhWqIwiDmkHMAaIOPJcGNFHRYceB7gKXSvjIWhPyR5FCXH2wMU6", - "BJeDbSuKJg+EQuR8Lnb/zWlCv+rDRuhWQTrQaKDhc4q9JJyrjEBoVkXugCpeMYzqXROha5ftTOnvz9+c", - "1tlwFxRZ67UbmkD3AzQA+e0LXO8W98cGJJPIPQERS/24PGoGo9cx731NIxiy7zmpytMpUPZemKTjS8uk", - "AkXjSuzHYJ+tuHVrSqwLtt32+NgrDl6mttAjPJyEVyPyCYf2Ysjeq8qOeLYKygbZnBxirK9NQPRwKURu", - "mdMpXz6xbCLm/Epqc8TkdroiAOS948+7D+QtL0F+4u6O+/75sanP/RAUew8qrL9oxq2iTFphE8vS6ahJ", - "wmfo6c8JE6DaMq/MVBrrAqiY+Ri3b84tk64EplKPXgAiyv5MTuPrkVTWcZUI75yc4PUNwITyEzy+x+II", - "XpDgMNLGiFOa3deHf25iILcktmsDm42185qRyccV2lLgngnHEG3hE6BO2HhfGR/fOOjWjZsD+lLYrAZ6", - "g9sH+AJgIO5EMBvBY3Rz3Lxy80OitbB74YT3vj788353ig0BWUEnFK9CvNkuUtPn18OH3IlPmhgcaEtG", - "gndj7zdlvbcZeYD7tEhr5+nj2xqjX1qcy+NoIwK94EjVwcf4oLQmey+5AxDmCjD7wGdsPUilxWStcEV7", - "HusCeIAyRLf72DeQUdxJX3648gy6MhN8nK1CanzVtE7kG6I8y72EhoQN5eaVnt46H4X9p3wjxlU/4D8F", - "eeTBVvd7cRMsZQmB9YeGsliMphmfWTof2KLtfp9hzeEIm56iX8ITDtpiuqaZWLn/Fc41FThFkIx+JVcO", - "ul4j76jsUyamrtfv4bMZTBWTY/p3anKPBRnceE74+tSS6+bcv5ljG/+iVxkVXqsw31TPg2kcAAIuR5di", - "2WT20ykl6oGfYX3QNtixUEYg1IptqSV0rHT8UcVihL1sLQj76Sqlv8PMqcjS5UJ4wsqF91sI4657Qtys", - "r+K/WKLxiYeXtf1ox3JNwVmNkJbrkP77NpBW0PWmB6BbkJReTG8XXRii91au4F6Kl8+x0C4kNtieq7st", - "ZO+lfx5+UT7L3sI9Jzwye9ytpnHhluXc4P2GE6v3xiGYSnCvpduxZ/EXqoSSU6W7mCEAI2Px6RSvXNQb", - "NgGvmtDA98254Qvh02G98hdireLv1LOWuAomFO1iPv9cc2QBkvICeMa2y8c6w4JQA8Nn3bofGz5b7b3Q", - "V6Jb77f6Sqz2Rn9gYBPbOp9Cwx/EstKXnsu3dTzDVtVuwo3IQL61q3AvsWG1dybE1jveGTTyKFyJQViP", - "gAneSWsYVpPDlfOt7TdBHiExVbcybk3tbGsrDwv5uSVJ0yiQ/aZlgpyAsOW4PU2Ruo1UbgR34lgaNLsu", - "byc8F415lqKmkQboDBqyPZ2g7zeuss8wRuo/vvlmv64b/8c336ASV8lOdzj4j59//ar/9cd/ay5y5eYN", - "wcQTqzPgNuUkoCGMkODSVwY5GP77dpdHGKlxMwvr9OInMXn78vRYTDEAWasdN5O8BCtTStwIEvP97LPz", - "/fzrs6+ad+BSqtW+e/Ao8P9L0ny/sQdyua2cqrIqTGPe+0jOgTbnSbNC7bTeyg0IIDxfhhzxaxsd3RBp", - "JL/CMG0/zLaDeBvWuMMZFCYb+V3Ev9u1n4VU3gf6acMDWnUxNZjbJg3bYkN2zR0nD7tSn3XX063g7Mct", - "q6FBmpZxLDLhxCl389sxky10HKg3xWHuk3pp4jGZ/u1m3+Tje7JWkaYsKhItIWFFfdKLrCV73UFseoBX", - "ryF7keVzroqFMDJh2rD5Mp8LNWQ/zUW09fRrz53ro0nrR0tXeSwf/PJi8PfDwZ8HP/+Pf+tWA/mYrngd", - "LXP17Zrj+2u7Uhuuz9SuLAHdUu0aU5mMDHdiO0jfmkFrAPz9L+Ddjfm5FFjn5BRfHlPhRIIBFvuNg17L", - "1M23j4bNNs6/cWtXtbyHudSCatJyoY0XWbrZNsbHCrjgV+96a/m2jqHJao6imBHJTwQus8H6RynznWag", - "YzEOodveb9xhedeYfuuw6Uw25lDyZaIwNK0s+LE6t2B2BMo1gnYI5rKIYel2obWb/4VseOiXAH3iYzTc", - "amENEw6UrJUfENlXhul3a0nFnh4e1tKKfdO4sLvc5GEJO13kmxlxyBeLXj96yv5x02fLn6vX5pxLY+PZ", - "ubnRxWzujccwiRnGQb2F65S/nzHuWCa4dewZy7X0jvBxpqtTrgYZxhCkZ1VZ/Gx9NRt/pLOs4TCca4MD", - "Mbn2DNAe/534BTY8KbCQR8BmPOFrvqSFoLlVcEw2nUkluPdAznXmH1yQb+NoaIizo1yYkRUzxDQiB5GP", - "kMhGC8p8KGdK1+vC1zIzVZrXlvTNjnQZC1XjvNZO8IRmsU4NW+lzbZ11S9Fhu6koTglxi+aVC8PCfvnw", - "T2QT7RNkb2l67GltrttT+bXqDtHU3dXovAJ4k2nzFdlLSrf8e0uku+Lp3zF/Ltw1KX/uQSWVLrStwCZT", - "Dn7EJwaMEIDfn8CN5EmfPfFJa5+QBeeJ9+14wq64kfhaQ+aZRZ6JI3bR49dcOvRxGs6003tP5s7l9ujg", - "QFCbYaIXT/af+4ygrNLcSZeJvf3nF73mbG404+02iHK3XvkemHH6C0w82YBRd0o/2RoxsoZR95uCMEx6", - "3ZpDsfIxO6yPzsPJ7VHRx/3ex5gqrSmNHYWW4nzLqMLqwhreWzABWzswHzTUEdq9p8Xr9xyfdEfycz5p", - "TaXXjFT+2efHPNM8fVtkTuacHOFWvZHjA1FDQidSK8o2zGlWIEh6/QSPA44Z76Je0CWa8zVlqIAfASK+", - "vPtT8CN5F9yDuV6IAwrkLB/07MFFcXj4VQL98V9i5eL0YvB3ss8MR4Off33af/bNN81Wml9kPsJ3r7Up", - "/l3mjJtkHlJ6c6m8d1Whcg7lP8qkl+Ws9zx/YN8cQjrf52SoDjklwA95Kqwb/tNqtV9N1DKRipvl1uty", - "nK4PCG06+ooWdriLSaSCCE1gX8tMQI6F9SOWdpRKs5k2UA9DH7Ro+mtWmBY6xZIuDcjIrQObpZxKH+YN", - "7WrpblLuxAB7N5nXGuUnLIssoRPpfNbCPrvopeb6xgzg/y96TBt20RuY64EZwP9f9Jpjiptx/TtuRS0x", - "FRwgedSt70RnC2q4e631g7Dj0WTpRAM9n/mQZPx5yA7ZtDINKWyHaOQQWc7xfloZrB/woHKGftPb0InC", - "zlsSYb0uq7qSI0wZj7w7+nF0mBJpdzy87VnGoW57qLthSfMTis8TBdnuK0aElx9evTh/1ev3fvpwgv97", - "/OrNK/zHh1fvXrx91TnFaKvi/QNUd1nz2mw+3+PmEiex1HvoHvxvRPCvIu2B/Hkod3SZkoTHpEY8Y47f", - "aKUXGK/iwQQvnhK6d+UhH64xGL7JqV6bBQo7reJZoy4MU5mITF+zPXoNpSnRM6l3sx2378O4z4yYcZOi", - "iyg6k2qWF5NMYq466cBZKMuEGZQf/Qagt+37s3N2EGd/4H8KmdZiWqvgXojlizAVlRWCjVfmEu0q19II", - "Zuc8F1gRTqax7qr3rPP5Sqrhy9LGDQ7JYBJfpP6JDWm6g/fMhdpSoyYW3d3sHVorRd0P8fijZA7TVDMx", - "Cmro5nAb6vYy9CLdeRUohuDvBPAMemwC5n26doB2Rj0iuDL2q3NIUb0vBs906YsNq33h+Lp2P45tIwSK", - "kPE1HbcAoLaVerBl/0zPuvV+o2ehbyUKh5xhtkA4KdujY0ATHHya7wrlB7FsgkGv0SMrnMtE2h0cPd2f", - "UbcAGBwTRxBj3PGQ38gr8TcprldOugTT+bwDpPVD94FFFVBbl/mWuhxXeqxCk0rGIn6dgEH1fKpQtwoq", - "ZqvfCd6H0GsL0J3hrcOqRqx3AVUGMQZIoc6jTLNtRcB8HbeTNBOrvYH7SzXrtk0ezhvqU9+kANAEs1kX", - "SN5atg4jPMl2A0KtAxQwR8X805shQJhoLU26753qxci7duEOdQJ0rBfe4+wNdqlBpIwOHVkCQHuDHVZ4", - "QQ0UJIfoDgha18EkeZfeSV7vpXmn2Wten3SZ46JD73excQuMHfaxhNW0l45PRjoXqhOocz55j20jiNWK", - "/NuA+PYr2k61KPJOhaYr+Zi64XtTZYD+WorYXbPv3ld5wFUB/7G/S7fKtnTs2MSEdu1aZT279W3gorsB", - "KNl5x36r2NO1WwNF7tC1mS3uAKDkJTt0WqHVHXrWiGOXaa7y2V36JvnufdYFxK0O9DYQmhXp3TtH/Xn3", - "rg26ckcgLRrVbr3X9djd+n8Q99P9FuyjRXnu2Lsmu7oiXJPc68rdV+67u3Sr3Fm6d1u97XTs2Xjt2rHv", - "LYdutSvcon/VyrFb90arS0cQjTrFbavzUHlgeOJCU3ODWdZg5bhpg5FXKnpzkFqF5L7Drjlf4kNKg5dP", - "1GnWJ8MyPVvNq8pzCDEn15VNMXYrDyl6Fl934dG/2bAcigw0POnKBT3WlTOq1hPs+iLT4nRRHbrJxvyW", - "gz71udxCFxySu9ybUyiAEwatxmklJrzVV3RHB9G2Z4x3lRcMmkKfav5xMuS+PcVC9bkThqHDxrBeqf6Z", - "930Ifz/ddritj5Urp9nJ8aHLA3N1hbSLIvVLbUR3PZ1a4RpdFE+NvpLWF+PEZvWtK8mxclxU4XDFl6vP", - "FoJbDFOupgHFxuR6gtkUzSX+QU47vHBzbaQjRys/frC3+yMiACHYGSJHpcJ6v51qgTQ/8JUb0nhsurDi", - "1AfhVT3j62fTNTowxN7cPiqwDULnaMC1IKzdsPAenVwxKumO7q2ppLDymsfSNw/t1Apz3smp9e6env5B", - "t3TrlBhQ71Z2sfmNdxt6ll6zAcOY07dC066QdkLX20d1pMK60bYQrUoWg+BssC24o9+zJtkGmCoEdYa5", - "siVxgH5lFU075K0fr2ZGWHtKJWp2c6n7ae7Dn//2ll0qTG420YVj0tkgjyGfBA7AKOfAkL3T1If+hrYi", - "m/Z9UgRpmQDNMRHof1Yt3LWmvk1l5oTZnNZKrM9DUnE6IxNfo5wrrIxwnUnrav7NfmVGTAsrbJkCC3MP", - "XOsiS6nyXhUTbEyBONNE9eRP7jPm3yypt18klqrbXhI2rrTpGN9fdg68qu/SX4VC/ev9D7Fm9Pom68ut", - "zOdEpaBiCxs8+jqsSF82ruUUgt98gM7tCLctQue4PTIn8vtnXx/uHqdz3BqfM2Qn01KZLayw1VydZVVJ", - "6hKEmxHIBbwq6z1Tvj3sf3XYf/ZN/+nhz81TxK31T1jbzmvq8ZsQ26cIAccnlKQxRz3TplTYDjD7Dzoy", - "UBKlZoFhxErGjaNf20fHpqWPIBVHLNcfvJqcZkLZgupd8pTnFHGrxHWoTFW6ICNO4F7OBU+nRYZFL8ov", - "WQt6tgZGHbcGREW0+erZYbfwqHWP7J3TFIDumVYdmKM3+HowlV22c0bKCIW80FcK9X4/FXjre0QhyOmI", - "I4F1cyrMuHWjwsZea/NRXjOyeJsTytHUVuYTsv10dmYMt55busijQtpcMR4SN6JlANuwsiJKmOsTyxyf", - "9GupnrRqnGVhsvZgvB8/vGkDjZRK6aF0LraXvfF3FkSK2jmuHNDPndD2jVxI1y1d0qorNQGwzW7w4VYf", - "Dz0kyyC0L3t3NCQ1EFyDjr1z1Eu/so6uG7azIKtt1b2tds2jebd1vNtoSuBNjInc9Sqp1TDHIhwosJ4Q", - "AYUfQxfMv3mhQg62LKsW+seehMCoPbEnHmue4E+2zjVQ2TKFsgjHXqignXFs7ZOiNPnFk1v8ty3ZG+px", - "BzsmlKYSaD60CC2DVPPM6bLGMUx3tbIYfPMBJqEC9ET6lKYAsTHFC5H61tSvwHHxmS9UaBuy10iA1b2U", - "ls15ngtlmVao5VfOiKv0QpEMh19CgWlcKqwxybQVKSWgxhOogJauAthnRa6m0L1Qc54ypXGOFCbVmOft", - "lowbAk22evZGwJF/NhPNSrqZ21lJtsQn+1bRxEC1vJaWgpJX7CZVPZRpww771JYbWHmek0F6cwjkBqNH", - "zJuy2Gb9gOTnOd7BLGyOt750N4Y0jx9CcAC6XS4mOsPBcaAhewX3MxiC2Tne2CaC8UrbSor/yZLdpNpp", - "nV2oPSsE+6+nT3EtywVIJp9qAuo7+jg/G8NWLnofMHbrogeREfh0Tf986UxG/3qR+U+vv7noDS8o5oTY", - "n7QUnpzgBHlmNcwy0YtJuFT6tDME73+4EHCBf+Fo/+OcTxDsj5bmTbwQ2EleqMQV0aJWBxuql3hYC6kK", - "W4MOma0R8AuWSScMz7yxHm8CMFWeJAJzr2NubMYzyS1muvQQBhc9aKtAa8uwyIDTK+Ot1APYgggrhIlY", - "0UyJOhHWguy6txBUHqs52KWCS47CGvrr92ZuZvVo5n80FOciSNzMioVYjSLfSg3cjozW9Vjk5mUU9aL0", - "KEyhK8uNvJKZmImWOxG3oBg2RI6sguQ+nyy0BlCQkQKutuECuraY6KK9FpiBGx1Satu5yGLedLyoFqrx", - "dSK5bhJx2mDl/PJVco9XA0n2PUTvmk+DSNW0gO12PaGu2tGr4Tjjmf36cfXAXqkrabRC43YML4a5Ym5U", - "bapbP+w1YP5agO9uMb3tB9geukvHuZUM7xS3y6tEFw8srmPYa5OmjW8Or+L62x4cmktbihvpRs2h5n6p", - "DJpgsGszBArjHU2+/bo5fqpSEouaskkBBVGH7WG8XYGB4tUK7GP76YE7we2Y6BnWJyHsVfH9toK99SOj", - "ciY1ptY7f/XhbW8z3GoUl2/+w8mbN71+7+Tdea/f+/7H0+3BW37sDUj8Ae1kt5UmFssvs9Pz/x5MKD62", - "dRsSnxNr5aIlrpkTZiEpIW5WLJTdlhKi3wMVegssaLJjbgmE2qeJbtixs5xfq+qGdSrM1iC6wY1lRcRS", - "OWMxcm65XQq+8K0ZZ7kVRaoHcfV7p+f/vb/KWMnsiIIoRqRcCZJILeKy+dDAPUwCpq4cnC9wUFkEvlqv", - "ZiTZ4UjXRoJmtx9mnR38vHaut+DnJxXPIHou4swCtE300FiM+P1ZPKyT48216Ju6g8eTMANuge5FymTp", - "4NIgZKPVsShk2syI0UDZaOY8Dw475c02zNx328EnqJXUHHeF3bUiTqWgSWFJyrZzpbwY5UnD+l5ZJxcY", - "pvry9EdWoONULkwilIO7erkMhalxtojRV0F8BsNH2CswpEI/kXbRUcCyt2gL9C5nHCrkhwL9NPsYA94i", - "wRvfgk7LM3W1wGJvZO/RskXaLIvaDzaV6nZC55g7zpxG1xexInzLivQSS8Stq0/c8U6KRVodZbjVlBLh", - "/rx1zXfSF2E6Pi+bBXDrK/QeQW1IUiZywgbBgWjYMR1eXIoRvAzi30V3OnsVAouZEbkRVihcUThBn6JF", - "m7ViuHc9zeiyVSILrKJRBRXNDplv6lNai7YHUmjM0NeJNURGSsAl2DCg40WvjWRh/g1SgJwt6OdgEMQt", - "SOaFuqwXF8CMOTEPT0cipjB1PP+72SEmOl16kw6CDLWsaAOUp+7VyP2mIu1UnqotLUJZBy3a9tBOkV5J", - "q83yyJc+BI+PMLpPgk4OFwbr2aFYXanzVfPVy6iCMWWHs5ViXUN2ggeKpmD0uoQBC0UDJpgBFrHJ4kMY", - "PQxLywKPIXNSpRgFVlkvK2P3Y53+Sh3vstx5pTp0rZZ8rC9cK5McI9jLmNRGpAaUalAM6kkcArVTNWPE", - "zI5VofDkCJe7ZL2oKDvb+XVrNm7ySxWmOesNWEztvJtGVDqGhl5t+tBW0xKpeuufbfSirfxeS0TYWX9b", - "cWO99WSb8kdX59m052W0zQcx2z1dd5t/zPf4vXQInnl7yIb8tS0eEz/B550AdXSCJVjwAq7zQSamIAiM", - "Endyi90BZqPnYdiFftjYbUd2m0chEw96S7mCOmI0SqN6UYNdnSIzx0c3m9+mvtdG/qIVpszHsRhf6EK5", - "ISNv6Cvhv1uG76d9psSM177DOTQLcZrBluy9f4MZJx3Gh8eyhuGLvHnwuzj+xrIK3e3726iCO+8zWdZ+", - "qA+1O1HsDLKzN+5aQYwduZZMU6G2JBdE+JVnPt9pqy+ib9cybQhGOhVmIdGN1N5u/jOji7zZBoc/+YxZ", - "hv21ZsjYNTVbQ6WKb7/+en+3whT6WgnTPFf8CR95wnx/bJlvlzRelFEqL/eWXqTp8dNX9rtlvvwNadWq", - "FVZ2U8NPeWFFNdUnasE2FwnQfhqfEXZ8h6g+5mNplaZniGpS1cPDza/1q7ftyuCNG+K4ca/tT+B6e58l", - "EGKRFrQMAPRhc1pUIFx5JbabcCO1e3gs9s2WHXyOWx3hcQfuGDE3NXwhmj2EP5S6bWgERzzNgWKvhDEy", - "FTZcm/wO7FfP/NnhNntwo3U03N3W7Jp4VVqJm/PhbU4H7xhZyfxK5a7LMD4mVOrzhe9Zp/O+j/oDgQrX", - "l74v17BP90ZwrodeC8yxilW2VCjmGWHaeysVUbGo7hQJuOA3gRZP1BnRXvvzaTl09fnQk+yWg914lgt+", - "g6kf5S/iRL39rn0GGHRrfcLKt991RKbVzP1PW3zeYXUvilTq7XT50pdJ5dCcqh9g4MaVTIUesg9Eg7Zq", - "HQAViV8JdBjBXj7mBfDltMiseOG/JpfCVSsA7wEQzGnIrHCWTbSbV8rd7nts8QVKayGH0tKMBlhytGOV", - "0DOn87uyBm0SAXC27+TJYiFSyR3YRoCwymASwxMxLTJm54UDMvMZHRcYeYAGT6yim2hjCvTGwaUijjQ/", - "Vt0hxJdI/tPUfYGx8nup+1KmdlRXItO5uIXbpvBdWXw0cprxWiZrtpKWcl0biObSjRXS6slBsfrcv1pf", - "HAYLrbTTSibRtY7RU0s5U54YbW0sToxOH3paIcohA+cxwDgGmYQHOPLg5NgHiBQ+ph2M0t5a6gWEtFQG", - "g+xua+G0OzwqwxqDPfnnjWfYlgNgJSsqhQhfSyMGmbgSGX2lTJ6l55rPmOpPLko35EYhq6pWK6sfshdm", - "Ip3hJiQ39Zq3xX4+U2qZF9QIxlMCRr61IZHr9vSt/aa8qzhjYQYwNCO0YalO0JVMpMGxeuztg//uE5oe", - "rHw5RrgV98Y+W8/a2uhY3NWI/KWYYsvT/M+z9++iJbbpqDJp/RZvTmSLR0Rw1o6uXv+z6VDoTGHv72oM", - "NoVKmr3Az4QLCOclc3xXoWcgrC4K7tsRCLqpSx+YD9pHJheyJX7YNShQPyp5w2IGC7rsAGtaKShRbpTX", - "FKELu65Ij06x+5/KFF4p/M/drqIlPMKXzCtoPC0XSkxr0hZSxbNskGCN/ZAxwRt1KptZg4/n60FS8LwL", - "ZWhqxeKVLjt291jo+3LgHXE3bqQv0Ab0alAHGBH1NcVLLQpfZ0eVL7bo5VYmh+Yx+TJbSFRbJiLBGz3c", - "dESWsYmYSx9vRAYUWywWpeAM3Ym91zeQzBVwhWFGWiDoRBfoUsD9E5iXmNKyifAvuJgLhk25dWjB4iGg", - "ixoYwdPnmK4bi91rJTw0pR2+/M0hbkQIxTJtUd+65kvL/CMxxmeA6PDRykZg4X3pnjM+CQ24bwOdUu6C", - "rRJpvhKQrbQrY3S4Zb8Io4cbBX1zFaXb6S9eRcm4dWuqFTvWguYHq3aVk2o4m11nvObiiuhI62jkACs1", - "bXe2rd+tKh1Ynp3Rl8I2VpJqdPpqPqdbpZwIfsrlPELKjUrqCZAnNyJluNjhhaqxelMIthdwbBGSjRyk", - "oabg/pCBtALpE4J8L5QP2ABGDmNRnJhiOtg+KuPVdort4be/HMK++IwY+8MLVY3+FzdIjrBDKOuvtUkH", - "FiMY0DXAe9LHlUvlDB9AKxrQXijgFIpTsn3UcOjnHPiOJd2U5kZyFuay4ejaQp4a66wDKuK+gojzyutc", - "WxdLnLcUS9CQK14lYjMungozSOYcNDZhYAzNpPonaWcYz/4cuKzjl4I0X9R2UKnEPQP3VyySWyIBOxyy", - "9/DgT4LINu0A27MyEwoqoFf36UKVzRA39mmros3jcPi0EeuDN1rXGvNUdpZK0ELJ27OolH2Sgsmbihhv", - "LkXcvpgTdaUpPxqkMCzMrqsJbjpBxdeFS/RCjLy3RqP+LeOYo5bH+s4hub4O3KZ6dKvrvFUOLWGMNrG0", - "+S1WRJ5aTdqwM4WlwiszMQjV+r1nV6h1YalKkjOCo2WWW5ZrJ5STHEwOEFiVYLCl9+TzLopFg7KEleYg", - "UbktJv7hxSsWnCmtBrxwGn9yLBVJxg0pVvgWiEnsdA7KFuhPhUPZS629Ql5e9SBCjlwjEuAnVBUN97HX", - "b5rFdv/8+i7HJW4+9Mtb5qvCnWzv0yQSgSXQCfTpUkSXpadQ58pnt8CrpRVGQihcVO63B/BUKvSVltzt", - "7wIgG0eoc/9azU739NmfdstOF+H0/b607/m5r6W+w1Z3u9uW4Cs321sWbq/vzOq7Cf9XIZgRU2FQEYVH", - "E0C9S1KQpWXihieOEqUYMZPW+Xsa+K1NBPA/oMQrnsk0ZGqw0TbDKvaE4FyJLzJY4y3tcActDwP+2YvG", - "gc2H8kIp7XCeu/qIQ++SM03EnF9JjZGg+AQUn4n+8fblKYMphUdRItaf90Lty4VOReYLaeZGO53obCj1", - "Qa35wbPDZ98Mnj4dPPvmgGwSBwDT/t/w333SqXA0WhpbWVvFllUOfC0mC57MpRKZ4EZBPdiZdPNiAqPD", - "j0l+8H+nMnGpmA5gHF4CBGXifC6s8MvlRrAicm0K4KTiQjFz1WTpzXdNhrOSwTb7oSVa0R0ImPv3UrU0", - "SwUVcpJXor2RTMWCBEV7G50L9ZM2WdrexAiegm7W3iJuiM9Q3tby40YUfW18foldH14b4zvehjslykip", - "EiM43s2bHkTFYiIwwSjCq7ruBJPJCs1uD9LZmNuFhoEMLzExxtRwqgpcsW9t5gRx7TTYZvqP3G934mcL", - "35dNNTzm2pLc8ecmknsQWv+A3FYYkbaOuxOpmwgPBxxeKNK7zsicjtl1wk1SG8oeAXMKPsgw10Yar/Pa", - "buKpyqBXY4Ibdc440W1qyhpWhORILWrqLaFiItztOrvPRVRdX301m/H4VpcuOrBuZ7F2v/vYJ0rrHr+4", - "ytI+rgX/v6rzG2+kC9iISA/Y1WfaMPAiLu3y5KkKb1mIjpVOZIWv+xx/DPVZwtm0WJ7h55gOpTZCi3/X", - "TIy6Jq9amfEuDA+LAN+Ru1O2nfvg6FuSy5R5Zcg1rMIlnlh/UMHXi0+eh2VH1lLqWMRYmrbjWqpUX995", - "R8LSCdw9bM4KjZfTjCdYQ8QKBgXi2kz1tnOSyzrh4052TqFVjrc17QgBbpy0kU68zGQ+0dykt7t9brbp", - "1aL5QgnYMOD2+0OzeesjyhQK5PDcoucfoU/oJeHF6Umv37sSxtJ0DodPh4dBheS57B31vhoeDr/yBVBx", - "IQchE+TBNOOz4C6YNPgLvhVmJjDFF7YkNiFupHWUnlDYPivylDvBVoA25JK8kpzZIhcGQ5bSPqkSWGS/", - "UE5muHOx9bG4QhxjFz182gWt4aKH2fszqQTqARPUT2LiLarVDjMLSU9RDYAzJA+yFD1GXTIPo7zG9dNR", - "COu+0+mSDGioMMdXPa8YQf1r+GajKF5Re8NurrChsCTaQ6fZArfVV23+x0VvMLiU2l5SLqLBIJUWhMVg", - "lhcXvZ/3b5+GhybUjFZlOy+SQr5ZHOfZ4WGDazPOn86bbllxaf6wVyvIf+z3vj48bKPwOOLBdzzQJGUw", - "/NjvfdOlH5bMUTzzvbDm/WLBwQOi9yPhZZxixguVzP0hwOT9nHv93s0gvqkOSh+K0s8BAJf4jUmSpdhO", - "N4UVppQfcSICJp0baWO+5dJJMEYMTnj8Geuu9y/UVoJiu9PThdqVoF4K47hULOwCW3DFZ3TBvvT+MWpq", - "eChp7PGcxdr+Z8IB97D9C4XJlwdGkO0yQKR1RPgBUVFOvjw+PQgJ5LXax2v+BN7VRXqh0OgR9nIr7Z+G", - "Y7w9+Xc3Q3Y5/CH7IaSA8z/hY8GF2vOJxvyrzEutL6Wwfh8veuTRe8Wzwj/sVDJ509fhhToTgoXrGGKy", - "KGcynGk9y0RE7APSlWIu5PCdtlRQojVY/3fcyuRF4ebvr4T53rn8FSbnSMMeNE4YVRVobH/MZ4anwsZe", - "Xuy+5Tcvo1+RPfW13SCpb793qvMit5A45Fqkr7X50YAq8Y9eWJuf3TDRi97PH++L8wVc+WKZ3yrawVru", - "wgOLHByoBiIQNTFDbZteU7AplSQ3bKGNYLEb+0XmjJtkLq/8hMSNMzxB54YFK1QqzIU6mOuFOCDmclAO", - "eXBRHB5+lQCR4L+gyARGTUHCCJVTNp+yOXn7gXEOT1BW3HqBBC8UXBeCb6/fF2B9YQ/R+yJD6pKGGWCx", - "CxHECdCsMJZ80IB6pgXyPoSCbJN4CqOd8ZMh9x7KZed1qhy1OnqYoJEUKJhldVDKAI5ucBfqVbk6f1tF", - "1G7gMtbJLGvI7x0kBsw5iAgQNTyVSli7k2pFJ13OaSNnpcADbtwBoNcgWMFK5rrpThDHoCHfBljdCPxp", - "Uw6DuJGE2sGMHPDlM1MzklB1QjV6asD2u1P0gKt0EPjD3am730DarCtl9y+UFS4SXTkCkZ9Ut7h+RNy/", - "UJ/w+rFKIy9U+iHy4C+YWvoN4pC2OO4kPqjxdPlbIKUt1MP2wKdO5na/KiXjEjsTl3frOZiEa0IzEb0K", - "mUwVw9wNIqXks3oaPYMY+WFbCikBE1Im4PIfklL7X70ggimARlw+WmVLL74gCjokKblJsgJC9Rho0Jgf", - "VmkfWIa2XxZx17KEK3KXygS/Eih7QtCldTq3wZ+Jsk8L2PqYKj4cDZOxLAl5MtKifP5sfNOTiCeFxcAa", - "EErJnEskqlRQDjUQlKVLIqbHorJJMNqlWKLBJWxXmVw850uA4p3cmdGFSgfOyJzB7UMllMUFS8fALK9k", - "WvDMg2ki5O/wLuFP50Vwgb/tTWKjE+76SDEB3y31WQQZEuj+htTWSAgMKaaRAKo43U6IIVqhTocJ1PMd", - "IbpUqbF+slj0F90bH+hAywHueo5vCfGJiiLdf9YjPJPo+A1nSGSJex7m2OL0uOshklX1AMRJ+zl+EDx9", - "WbHANm3nfZ0nDeKVfDrOFQNAaMP8kCgL1yjvztsPiyY32egC0mCMvuV+o427fcPrRvYHIp5mS/5tCQit", - "96EGpdPlJv12eOJP9LAQXIfv40Cp7mTrOcbEIA90hGuJR7qf3r2MX6nO1kSpODUG1VMnMpNuGY0+vxmU", - "+F6mPhW7vq5XEt0JD8CNf10YrgaDCEuWGUyfE5j6pHBOq350xciWpRmBw7yMIy96DLhTVEcSo9BxvjN5", - "JahAo9evM8GtIKcu+iwt41EJ/sdNny1/rmbFybk0jfer4xCa8EC4G+HflfMAoN+IyMaplEVc6Zg481lb", - "dkIpeIpHKKPc19ltZzN/Fa5WkfchRXRz6d9m6sendtqKuIj72Oa/Cld7zachiHTjSPeiIQG1bdNyY+ng", - "ByKUtdLEd9Nx/TbByj4vsbwNFXFrxxckc0w8VPIqey9HmhthLWQ628KqhV2ZCEZWTalsVHSci2mR6Mmp", - "zM9VKdhzoZrK8PgSVLgOI+ZCkf1gvd5Pn1khLpSbU+2b9Zo9jLvyRWom3XBqhEiFvXQ6H2ozO7iB/6Cb", - "4sHN06f0jzzjUh0QsFRMh3MSGT5Oeq6VNrYai+d9nMJ6LSusT/qT+K3A9E7W2yPpmHTa+Hjoi0g9EL2s", - "1qi6LbnggSK2/JY0FlxdzeqGeHkflFFJNtDK7M75pShzMT6UWruWUvKjP8SNQg3DfQ9ySoFajhTjYif4", - "otXgQbQmu8oJUAzxZz3xmICIlQcUnA/vet46y9rZIGXTZFc+4yRlND7QwB1CFkz45iqKaIVZ11XamsW0", - "VkvN66q1dJZkfpUKXglgaOZkcmnZntLOp1r1ybdKFIuRG5g16Iqb5XPmCrR3LjA8tppAGQNhMblSuRR6", - "+/drZZiLk6YR/E76tQTQPo4Tn2BqxuG9CAP19XIA7/GN9jiKAA0ZWwIzHYeAX7L0DAZG5II79o4NBhRJ", - "e8joQYduDfjvkMBk5eYZklo+EH1W0qzelr969PqNGNtoMqU6QsfDHeP3q1GGhB0t7NWH2T/Qwa1G8d/J", - "2EOh478ZwQhrI+POnY7JJwBp54plRcjw+sfgP5RjZBk9i4HUQ6avesoGqVB8hzhJkYba+8MLdWr0VGbA", - "PJVWYpG7ZcWZK37yD7PeyyM+IFp6y47Ph9bp/ABnRWnLLhQVLCgTyg2ZrwCOWeNoztASXJfpk58a5h1c", - "YlAgJiq4UOM48gjeAUfo/C1my7/kGFs4StJ8jPnDnINJY1dwOgvv7piZBRjkil+JT/FRrWWb06Y07ok2", - "K9syZK+iy8bAu2xUhwB3o+PTC1WZxpRiwzG8PsPofZg4bGV4roS5VGv5hgPDHAf/KoRZAg7whXDCMGkv", - "VAjgnyyZzlJhSI2wIe+IEY57eGV+OBoqiLHhhYqYNo6HMmaptLmXIJxNhHUDMZ1qU3NsIaeXOtaRdcg7", - "o5S76yOVywAgSgv1HTdEQNbH/1XLW47DZWNM+XQYV7h+x5a6YKm+UEo7pgTk23nhWCa4dbid/qqAnnDQ", - "HMO+J/HMYzLF1QQ01onc+oLKcBGSll53jyqIUJ5xH/cILWaeUFAQeywKbhR0djEZGmWCuVDOcGXDleaI", - "ySkYzziV7vdzg9kgzsCo3GRSmAoXZJgcUkynInEhg+GCI83THY7ycSSidILCyPRnNzf+rTc3Oucz7tBN", - "8BSpiaL4NCgeVgCmOcHGpaPGv48pKduBX/iY6kETfcW8pB7D4Kl2NhOg+l4o2lniXJEv1ZlWo/9n4DEv", - "QyP0ivcUYDGCqMXRoUr/gWd4NNKYfZmN/UTHodAtaFysUHAL9U6ia9SC+Bt5FbB0/9ZdosWQjausyfMl", - "S4ypyg20YSKTMznJmj0aYKunuL+NrIJKKHhVE2O/ekc95BG9EJrWa+GdmPAtyPGyQmDpWhgrLsUv5ZKa", - "Mgz8fCdPmJUgMzhyMQoU1+DAdP568CefXq7ukMsWPGf/53/9b2KeViy4cjLBwqqnL85ffs/WXcKb66D6", - "VqOW+IDKDMhNlY1/vSDf/YveUTU84OeP444TIqHSNBtPbF2msQCOjRp+s8UCfvaS2OtFY7aHtRcOqPLC", - "gXDJMKR/pSLHIdvMOllTvh3ie/AzJtGNOdA834laQpmGtO6LW+YaZlolItzzfDnKhrJGVQfWNuIHTyB8", - "cgizx3hw8H65ElVaBTrxyyjTJm10rNuv1Reuo24ICG0shT+kWvjPvvmmOS/NLzIfgeDoZkqoh43Evp7y", - "mwKqVisjeDk18nJqfTcdN8NfrAuCrMrtSKGwuL3jmksgRlD4pJ00QHg+t0PmhUx0H6bc9UZrx4RyRla9", - "4X1n+I89CLWHw03Yigz67yEPJf9xNva+6wenMemEHe9TOtYx7Fs+KkliXKmQT8ftPazCYtE51xcmt6Ba", - "YINrw/NcGFaZTy0jWttx9XtRs2og4w9v4mOxV67EimoltmhKQVHqswyTkQBRJZxozbFnh1//iWqv9UvS", - "gwNMMIKFVEXkEf4AaBaTTLTUyq3v5YarS5l9LuwgPhWWfSkRspE5OT+s4GTEij3QXGKJER8uCaQK+7bf", - "qQjvb+rBuq4xE798Xhr7IxbE/D+16+/wLvffrw//vL0fTDCTydqt+X6cb1Z1unDLbt0nEa5OxMtjoFLK", - "8jm3YuWC/oLux3h5Ke/GaBLzd+a61g/F+df2nl43O/mMVuRzDC5riGLycvehHiPWRfunxnk/esg4un6c", - "P3qvDL9h9WP4bDh955Cd5uV0RJ6pPUiMgJrCsb4+IlLR5OaIDWNFkIfydayPshMyPd1UwITW+Ruy5NFK", - "Gcdw6bSyrV1PjupzdDi5Y2z40CdHo5xyN7+zq0s8NFpiejfq/Hp7v3favQYH73v0kcGZM36Xkw36+IZD", - "fU1q92/7PGGSv4ej9HeczqfoK+kAhY5+kVg6ZCZcU3EhVxhM3vj3k1MWby2V2064xMRiD2XBqoBew3XX", - "Nj/+sTR/l/k201Ws6xUhkrbsdLyVgBITFtVm8/FOYHUsqRp8tpYC+3knJcHv653ewWHXwxpjzRREveoG", - "f4mY6w+ryoYYD4jml3xrjLYu7YDS4R6/57ipXOYXweUEdWqAtb8R8y/UBtRnf7cuZXo6FcYyK2cKk5Nh", - "jmGfmj0M6HXxC5WK6if4Nzd0m4UgRDIeQQoycQUzmQi3CgUJrdmltEJ3sEdfCuH11xKRVJaLflFD9r2c", - "zYWhv2xIgM/sAjPclqYVSCsLiaMZuIYKeOUZ0ElYd8T+J5w2gWBP+8znQoWDhdpQ//Orw8PBN4eH7O13", - "B3YfOnoTcb3jV3024RlXiUip5wGeANv7n0+/qfSlg6t3/Y++/8xCl28OB3+qdVqb5tM+fo09nh0Ovo49", - "Wk6kgi0jBNNi+A7/Kg3ffqt6/cpvNGX8h3WtVvDufNNT750Y5/mKje4PwjxXTJM7MFA0L4UETZ5x1pkH", - "6EpYirsr10Be4TcewDNt6krBb0FK76Z5xj1oQDn4jUlFyHrni/tnQSzw666sgPEJOQCsnd4OiJVJ6/C+", - "YFsx6420WAjX3lIgfZm4VK66AZnKi2ZG6TS+QGyCBdI7BYV63wZ7wEu+9aIJDuyn5Rk/hN//fVwyAU7F", - "uPMFniSuAB/48V3wbgzBCJ5GA0IjP4DIT28+6MYOcDpBNQX4vxWOoBMn3ICqM91Zp0EB0xhr+4WhE5wv", - "qz2B7oA+VpA4GVVKe7dyiPUK6w8XCNpSyv3WibpKUCFs8ws86jPh1plFtSr7AVZ9t3OZ74AD9DLd7iL6", - "gtKIlw/YPsuINqU3FgkmH+1kxEJ7PkIhycOWdDdBTbk3r56oGbW4TqTCutGWevfQRir/aOe5oE/i6lXv", - "LpXu+73bell462M51e1uFg0Qbpve82mzWbeS/uoLZ5cNiX6mHg13I5hg6t2Y/4qjmYk8NStZ7KR36wvO", - "CSsGrxUMbCMfsvbeG/HsShwlB3I6rgxWEr1bdDdKuSefpE0Uc0vU/7vM63nf/DJ/N2TAq7nYVlD0FhTh", - "jU1bSGJXU3Eb5Vyo7aSz3WRcsxBfqBUTcXuuNm/zvTfya/WQO5+LuGVht4IY6uAT9tnIutmDq61K4bvu", - "Tlw+A76fG8x5D+taAjoNBthmUPbbH+5WPLS09j0AQ3nh9/B3zlRW0fXWjOV6NUHeyo3EceNe25+w1QPd", - "RSpD7O6lcsuM8bjsxsIRPyoJFc8aykSUdHvtt6OTt+JqQWqXzNl9py3+TOhIi6ma9X3iQDXbSd/D/Tz4", - "NRzKRzqVTFDOq1WM1HmJkCsGFzSieKuJt6HEk95kR9luNvm6qbY4HSU5w3/hRwnbSniNHtS3MpWtHuNB", - "WaO80XB2hoam1/bVlTeqfLLTXDWCOXHjaLaN1q9tbyxneAnHZTSmBzh7FUqe62nl1u6juXv93lzwFFf9", - "a++/BmdnrwY+od3gvLFe/1uRSu6LGU8ZgMd6ZASO7a0ywv3ae2l4G11t1fQU+vFLRGTc6LVd9hmyAuvu", - "jNNGbnMgwzxxXQzAxxUlkK8Zgz+hP8L7siJ4JthCp4Lt6cTxjFGfPsPCB99+/fX+kFXrkn/79ddt01xQ", - "8eHGaf3jcPAfP//6Vf/rppCZzVFn92ievqVlJmYp/NKFNZrYQD4Hf9ld3PAyPbMH5dY3P4zqmSXya+Hl", - "KyjjK7Vuwu3ArDwRlGnEGwskNw9DZRqbfUZqxfsqhTlXESEGt0usLTdlNHcmbcjWtoF02yXTLuNU1t48", - "Wtlg5OuU9T6bVHyjZx3FISDWb1oCNkkXmDTFV5+dvepKQj4D9oGYGWGtTzaw1fEPgyixRwiTDd58Rmcs", - "z7gSLOPWVYtaYPi3j5gZshfhn0xph+rdnFs2EUJV+xiRa+MsG09l5oQR6RHDqjCN6WL+Ktw7Ws0rnNop", - "reUB3Q+ahtuQRbC2Yy3pAP2uPLErrTscZ7/XWL/+XECYN8D+21sISqSE7s6uDyUtMwKQLPF10bliHNhU", - "JkOeiPgnQBDZFPrEosq6cJg4gMbql0WWK6uB2j0UKSgtS0UmJ8JQ2RWlHbOwTXNhxFEI1LxZQkP4A7mQ", - "HwtrUmLSA4LFGSV4Y4nOl8FfqmreoimryvRYglnuEGpq5NSnSJaQwYSyOf3tLSsog560hIzTwooyQh/D", - "OK8RitGFE8wZPp3KhHFMJ0+/4xKG7FynfElf/HIgjUiiFwtMenCOdSmHJAS/o0iyl1SZF/IgGIPZ6scI", - "7AyTN42ZNv7Dd8ucWwueIuOQm+M048trA0HXTNzkGlbBLRv7GLWhEtce+t6vfpM/7o+PyARboTUQROPK", - "SXBlr4WxTFI2EUprgnWDfdoHqawT8M4yBc32mhs06UkMPw2hebi/J7Hsdb9MgkW5RtY5CSa5itVVA99A", - "buJYkSMA+FlgUitVRVLLeErlOsn3AjNG0klzZgpFBToCUzovS2VJW5bwwVoI0jFbmCsqTRQzJXhUi/kw", - "oAaDl3PPGQ+4QgefYM3hABYAGs9OwSHWcCRMN+fKsz2680b+GpFtIlimrWtigadFKwu8fxtZK/f7dGGB", - "HRnwq5qo8rj2eVN13Z3dg/TOI50f+PINHcqKmIl0hptllUskOhXkYTY1woZiED6FCgaQ8xkHLK/VpvUE", - "dKGAw+qEZ3Nt3dGfnz17RrSEUEGuc7ykABU+yflMPOmzJx4u/NODe0Ks4AmVAH9yoa64kRApbofh4xCo", - "GuvH7O0/ieRTmdLgGji8r0WOaeis4rmda+IzFyoAkupKXwoAtQfNPohpn6qc/D999itzciF04c5E8v+w", - "j/tPGLW2VCaFJ26lVPDc6GI296lxIEnSE8vsUiVzo5UubJjPi9OTYfh34AwxbxMAuWbc/15FOOS1F8Bh", - "XGFf6lT0cWP7OKvEEz/t3USnS59ygk7ACFtkkU3heZRHK63fQigO41M5BfRFLv3qSpgl5uGBoyYXROUB", - "aHMEFjlBJVxS9k6nYvhPG7gfCQjpLNPXKpwOvLOFSn5D9hLzz+DbEzzUoYbkQVOipEQrnx05Wz736YB0", - "JYNVaA2NAQcFpbqDwwMF0x9inyWG2zmm2fLFIUklZ5nWecgYFGGlWljURTimP7pQVAEnzmzIXmD6BB7g", - "43xi90shcovrDhuB4R1G+68NO4HiBY+GT7hKtSrlYBjCiw4ADsrKVYifCQI9zOlC4VoZWpXWF0vZVLCE", - "HB4qbiYvt90XqItcIFSWBlyg0wopt56ELk98Sqv6LsDlL2VP/I32SVBLeHbNl5bK21mvBF6oeJ4c7q0W", - "s0g+KZHsIlyML3pPhuyknnEsNOt7xgI4PSHtSzOufIo0qi9OUpU2F5URgeDIr2ng62x7hoyJZ6j6EAw3", - "1UbMvFbHJ5TC5kJFP6h6rW7Kc6FzoXwZLBHvMSGBmJ9RHvuE4kgXyopMoP7tf5CWFSo+dQ9LxhnmVlcX", - "6UD1tWeLAdqFwkLx7GTqxx/QjqC9jwKeEmGDVufLpNObSb/CMeopo2B/a6UKKSFK4OdDP1Pk1U77uWC2", - "aJpqSNcmbkD+S5ctEdNOOVLN0teeAlyC7oBnyMQAc1FUEZYFFCCGRwWnsI1fjBLX2PJCkXoNdDhkr3gy", - "XwFAu8bphE+crcKC07QeGCy/RAa2kgOvSuCwSi/U1rETDwoAaAUkapY+RxvNHUPUpMOUhRaHH7L3ORae", - "Y1CkLrIpOiScQgWz9JQ4tT8cwqXnYLupzjUcBIhopX2r/oXyWEuL1orwJpTpl5YlmbYiXeMm5R55bqzS", - "iPlPYFd9lD5dLJ5AFWC/88j9Eq5iYUo4HTp+xye2lLAl9uOuBs3hOYsukP5GF/PPcNew+YhnLyLdwshz", - "foXyY6GtY39aQQ37vJHrlMIi0YVyIHRgJy5URVsPhk0vR4LO8vXhnwlBq3zTPveB1MgoSOwfv3rz6vwV", - "W1f1tLEHv8I0Pw7Zu/psfRYfFy88oUhyUiYyJr4L9xUQ7c/pfgUINy+cxXhEPN8lwopwiEtJfyyEB00X", - "ETpZUWqYL8kS/xD3kLWxPlOOkoZ5gPLVnHwmKmL3+kr75/vL+RJXEYj0jVxI15pO5zxw5hWsL2llIpaa", - "0IflwgwC7WUA9l7LxZVTx1zBZzhLr2CtX2I6JtVtIr9WM+kbSfahBo6BMsVn84QGK3wmJjKZLNnp+7Pz", - "BroX646hMN76gdmHNH024YdtxHWQWuUC7y8qqmbjKld828P0vLTu5bHyRoCVLasM+0lU8wPvj0YljdwU", - "U6x6TUR5I5ml2pOo7UW8uOY2JNEYsu9icuPV0WoCmDmtSeuBqaMUm4gLZURhIeVXXTr7+xgLShDpMnF8", - "7lXbYPxcQ1xvHCYXoYqdz4uGo9qdp8zH2Gfcy8RdNobV9mWlhOy/ClF4WYQa04WiqyEoiFr5hcVjOfHa", - "sNKwPrxrPcHtGzk+eRJUH8p1S3NrjPqndClrSN/JPwT/Z9OD4m6EBsK+MaAfVtWAMPXXchi77bk87stO", - "75Kd/JJeRZXpy88U08B5ujIewkrkOu3+jafUCrbswcrLxBE+k7JUm0GbmlQWFTa+zW+iGm14tqmY+LLu", - "JluPAjbn12orDpxhqwdFAhzi82KBn0IbGuDPIv2NnT6/0/H/6v+BLomXMsu2osIPMss6iZsS8kahE92T", - "igJb3toD6lZHDqv5TRb8fP/DFxkiCuxIzhTPKOF88LS5PU5Szu2tWPmBmv1u8JLW84iZ9xenDvsJStP5", - "fw8mVIfgPtCTXsNavf6CYKFWnxo7H1ha0qKaBKX/5YtMmhPujjac2V2QI5UddCts9bvhXLicz6zH0RTa", - "9Ljvlk7Y4Ln8xTorl/KVWY9Bd8JUXbhtPszl9oJTwiZn5s/E0+7glBvXBt06uueG/deFywtHliA5FVQZ", - "7DF+5cHiVyp4rwu3s6+xEQlW1pwdlBbWZg5NppYPof2D5kCOo2yv07rqDO07fj6b1mdKTh8tYbkRVxLv", - "v4wOV6QM6ozqncI4KnjhszK2csKQtrGKGhvDm07KkNmYvzIcW/AkdTrmX+0HJxTyGa1MDU3QvniRXkjn", - "wgN4WfxuFa60EW57GS3kuM0BSnzwy4vB3w8Hfx78/D/+7VZ8Gc/iYJF/fefEWSWy+5Otcdf46+C1VNLO", - "RTp40eSKLhfCOr7I4SyiQ6+pgKbOQ/bXghuunKBjmAj24fXLr7766s/DzZErtamc0aPBrWbiHxxuOxGY", - "yrPDZ5t4hrTe2UFiWT/0/uyzPBPcCubMkt4q6YWjvt0fkJrQ46vhjaqYzSg7K1RFRAcyGIHc4y2biKk2", - "sFCHLuW1RcRsCU8bsiV8/IJTvFJBXIskis6E98OsMmldK6OCJ0o6bHH3h9iY12qTNAujUW7VtWRRaxT9", - "xlfpN3GW9/Y0i++glcXvuLELbi7b/ZhpnTb6f/nal4pw3WcJ4Sp4Q0WwWMdzKhVWtiKc4OZSmFCn+5/k", - "didDehmvXL49/RpkQjLnuRMm9Fl/g3/LzeVDKyy1MR4wLcUOc2i7673FfYqE9odRjV6kacRMwhUfSCXV", - "ILD5Eid3pw0UTFtSozw0GtYH2ag2P90kAr2Q/QKrM+EOMM5sYoRQVR7zHrwPqZZqWGYuDDs59u4ZPnJA", - "GCqf573Vb4MHOt+EBjp/eCyojHH7u5P3E/m80ThO53UFsPuB5Nn2kJv/5Ffcu6Gh43KILFMuhk14L272", - "4dXpmyE7ixW7qbTvXGT5EbjmjMfjf9oLBcMO4ePe/nPW9n8HBwyl8UK4uU5rvS56SSaTy4teU/eDA3YG", - "T0muMKIfqxP3w0UnFm3H0ph1qGvBNTACzhodbq+4zLBytp8SLKk4PPwq+b8GA/bdq7+evGN/ffXu1YcX", - "56+OcSfY21fn378/Zm9Ozs7ZYICNBRRxgB+P2DiOPe77PzA1RvxLLKQ7gYCcMXT6rizR54zOjtgYqij3", - "2Tg1XCpK+AJ/gub8Whv8AH/PtNM/mgz+CZ7EoGDBvymoSU5kJt3yzIcZwQ+4t/APUMHOIYazj1GV2YnK", - "C/wjN/AEKpbwb5sYnSHwhOew52fIVAIwjHjiE5yYj4Y55xPseC1dMvd/KHHt/4VOPP7fQtnCiA+CZ/6D", - "nMJdmcJNw1LfVhf9RvO0ugcZxtpWvviQu5M0w23+J3YuYmJX+GvuXP5X4XDPKZzpiI1XA7jG/fitRJfK", - "R56mLwvr9GK1NUBo/oVc0crfxlX0evXuuBtyXSiPJwOPJwFbUU/kEYcxKpUyEmVLJAmtYojtmPzyMKxl", - "avQvQl2ophC1JJOCKreXgLkNK/Il0X3Hof/Y97VjgXsmuNgLhaFuPE37GOlMFErbEWY/XD+CvX0sxZ+A", - "Hc9itFzF037811fn7IC6HDi/0zid9Qi6/VCsfUw+q74XtYBY/Zd6sdCKAeJMIa1wlZdxvKh6Gtu76IV6", - "s57BDBO9IC5CDSt4ugdfE40OvUYI9hdGTRoJs9I4k+qS/QX7DJVOhR1OpUr34J/sL4QGDP4YGp0J9pe/", - "/IVd9KDPRY/Br8++pf9SG3S9pDZvtalVrxgOhzRzOWV7/xdA2PdhfkpcMxREewQZnfWnoL9Wl4p8ZA/7", - "Pb9QYfaYIDEsdY1l7F30DtwiP8BwnFzNLnp9dPnrs6ffHh6WsOvsce9XgPqxwqvPdT6g6jgTqQDVfCDb", - "UvGFDyOQCx9PtdBpkYkYMM0K5SSWtxcU40NWY5IUnIL3IfYjVh+64lnhqwPLmdIGnFcFFtOnKxiFpZfs", - "fW84HO6P+8DHrQYR5FEcQ/xWGD+1HbJTqZRIgYG7ZI6+e564Sl/gQaKNGDMols9nNJ8LVZKlp4ywBWxM", - "69/bD3SRpDlQQm70FcaeFKqSTeFYXCHNeeSMfrYGNmshQuRdxn+RnptIDJ0sYwEroeVD9kFY4fr4zXvH", - "9mO8ow8C7LP379/2/QFQkH6odJvCvPSSIhKtI0/9NOTIw68vfzw5fkabOZIp0HB0xqOTssJIKhINrE5a", - "JlTqr+IrS1+NOi2zMMRYKcgWATfYK54Jf5k3BVAqYqC/kFcDKtdcMAHyi9MT+5xJnAEQlOUqneibjREq", - "ntd/AD3uYfTkygi1K3tdVcRK+354COMN9coxPIKMj39ib+V3wYJHu4tpbOnice5RxAgwZFjG4fpp5zwT", - "KUu5APYbwOO7DZqu8fsT60ErcZ1JJQapCKP6HgP4TFOhGklKqwEiUUFGlq8PD4e9T/ngXNvUblE2ez7M", - "hmGca6zy7Gli/0630KdffV6vxPoFoxIViopOR+dkm/BMOP2LMBrqTgPTa7/anBr/MOqzqWBKDYCAHvya", - "AZQ+XHa5STPc9Sn7/vz8NCZJIVd7DAIPTv+AvhiSLC2AvAbr+DXUmZOOTUTCCyvYj0peGj519OtKXBu0", - "xYx6ahmR3TOPv71tdOunZZ7Bys/134XRvS7O7Nh+4PQAVsn8XqX3cqJlYpRsGSDjvoqwq5Ut6mw3qB6t", - "UJtP9oOwThthmQI9JmO2tthwHazMok8JV8pML/Xp0jsGhRemmaAjp77x4eVvb5nSvpwgU0Kk1r+2zEWW", - "gqpzKRp5uLr76Qn1QIdHgO9+drFJp6xc/orIYq966fAhC42/Pvwaw4FjOxkiWal5s9T8q3DncT4PyN/j", - "IODS1ugNed68wNsajNeTcbXA75aIKySwXmGa3DiJrIqq0dCRtR4V2hL9CFLYSpw8syJy+orSQMG6pMal", - "z8MzdRWEEY5TP2kirljhIErc7oQc7Ix6+dj1OHXA+bArgPaevnziNpZkghsbkjw1I+afiTGMrdMGrjEe", - "xBhmQVCwzmuZdQnDrTHPTGYET5dlKmuC8Hx9PICViSlcVvx+NeZTgnOsI/yDKYhxmJc4z0/twndrivt8", - "lZU+k/H/R1zvHRlEU6a+M+G2cIRAI88On9bp85oTgVYcckpafR6zDjw7PIR+aEaxQMKZSAI16NwNpDpa", - "zVpGxAfQq3xkj5fJE3AcuqSHXI5WuBBriDdQzyMCWwga034rO3ge06/IKFO9urCJJ/0meUjhPh8H+c1z", - "jPt8mr79hKxwX+Ir5N3UlJpyWUmL33wtOFHerqB8QqnoKFFOgTx0+2wWUhhUs9KsTLTKzA7LVCjcQhiT", - "SJlQVyLTuSgvCX5Yy3ga/O+eHX7d8HtIYMn2lA7DB588bcq2T2zJkqQtuRKyrK8PDxnZJmXKffIjtBQ0", - "0/gkk7bUFMiP+YHc/WksHOIzufuX6/SH1Bi8i8eR02zRpBtONOEGhUjtvC0sRSViSFyhKYQcAfIkETmi", - "V+HKk96Ma89JNoapDG9P6zX68yfRgSR2J8e1iID1pBqWcXodrjvHl2MTSftcV/jwhwLOJzRbsLFMj9iv", - "Vvzr48WFAmf3I/ZrOKQBYAR8v7hQY9AU6HSYwoJNZJv0BtnBQivttJIJmmbDKwBPjLZ2hdF6EzPkRn3D", - "rRvgmQ5Ojn1KVrWMGgwrE+QBcSIdwrQxFHwRTEa07CE7xgR7MCmKgiSUmPHchmvSWKZjSo14FNJgGZEI", - "CWmN8DdpqS4gZmB9yvjcJ7hwc8plPbACFAoJz6O0s+xaGGAlZObGFUDjSQHpDIfsJb7tWWbnmBLHGUyb", - "tgYN3Y+FE4nD+Q7Za8y9Vy7fBt1qZcsoA20ctrzN+aOiJ0m8LApK9oGzfo7+zWz8/+BzzPIvPMvGVGWr", - "Bk5nqbDOXxhjFkGf+IPMzdcS9nvOcxFy0c2EEgbeRuqccDxkr7WJGqPfPeGvp552KVU05c9ke9CcUk8K", - "Y1lhfQEYnRQLoaAXPq6P9/s1dj4GLB4jzmmziEUWF6GEzNhrSv+O0zrGxsTU+jFVHoxLwJs4PUVC1Je3", - "teY6mKgXgnFM0ujzoNfoacje43uXYVaolB02nEc43lxbSZeBbjSJGU9qhIXPbURGAsjM+CdsPxT3mbWH", - "7JxfCgv9EpHiQPhwMCa8GZPgxVdwGlhYTOdsNTIkMM0OjPBoXA6XCQ44WcsgMyCQcEJzaZ02S9p69Jcn", - "z+fSYb5GBLsVMsDMguNdEH7IPsCsiKThtdUy7tjTw2dfP8cOEZl5hRMA4dnCTHki6LmEEgkisc+M4C7k", - "eX5aWeZKWADtSHOMUZb1fr5NNMAdorQ6Sfw3HYTRF1dVYXUFcKKUgn1wJpRjkQN0EvDeM4LcNgboVrHV", - "rEuX54rfIPWm9MYxzS6yXtS7T4776IBqc56IPjE/YeiROqZFXgjHYR+bk4mRDw35qOCz9UPaetcG2xQE", - "H2op+D2oZHq2w/tzYG+A3uERrd9WSjv6BOORpGwCRwLYXDlJyiBW/h38RcGRIwTOawNlA/xfQ8iUWv6G", - "MMJrZ1B6oDO7krzyQDisgFjpBA2hLAEmyobhC4sVH9ik8pjo++xZIdgY/R/H+97ZiarCLArrmAAhwyla", - "lp6LxSJ3YJ82fHmh9BS8CaWSFf3mxw9vAq7afh1J2V7p8cQV06FSlPcPIUTa9xm+w2qmhSL1iWZHex4L", - "AnCnvR/LkL31o2JmeDRau+j9EjQOS8AVxdagMm2rjli6cAM9HcQEaNTiOcNMplH/wFVJ64sygHqWCJ/S", - "+kJBPjLbMHQokICWMqlYg2cWuZNob1hhWgkcirzB6EYC7fohvSgwDGATCDlN8e+ad86ZcBdUamMEQp8K", - "jkUM9qVZoLnnTjHTLK2wzG1I7cvdfn6hwrOENt4Sx9M0uJ+F/NIEneq9eshaCbjLhD/L5OdUGliqovFq", - "/iL4Ea5ys11u5t4XDVlfkuYjIh/4q5rpgoqgSpdFUur1e6htQcu4G72jXsW3DcQVEk7vqPePXy8UY5dS", - "pUfsAga66PXhC+LPEfu1MNnIBwjaI/aPRl+5g3+/6P38EbvBlh4xhMnwMACqETwdwRpwon4AxiocC1rh", - "YkLG39qShrELpss/Q9o7Yr+CNIWeVGUU3M54mkoi1NNY5tQ/A9H86L+eXo8ooRLbGyHcPvsVVy3sx/3o", - "lLfn14ITOvIucP+0e3tlk0A0Q2zTZ79SLuuT9MgzF/uPw5+HTucj+gGi8PdpNvA/H3++wFJbPeCc24+5", - "wmbvdNQA4KHOGlfS7bChKa3sHk+ZeTa9AUZe6fmrP9zYjPSzCziVWIQMN8Sv6edNyFTFHQ+4jiHVU//Y", - "NSdjE0/5TOFYOypPpbpBcjBWicA+yEi5VJbsBsjDxXW2pLYVLesLM5SDAnY7la5FZz/4da0g8KruDr7X", - "lPC/qtRNljVFfcheqIoki29PlZjg+MzFVSIyiiOvS7gPFbf3EhE6JQjZkhikEoyeuBHEo/8M/zkc/Pnn", - "X5999bFbTHqDJbeChyF/7PCz5qiCKTDegCO7oQg5vG96Q7nCMjKUo5Unjuy3tWIyscY3Gca0zkZGTIfs", - "nVYDsKnYYgKmolQkGYcuV2TMpRCAUNAlmpqENL4eDBlpdF5knKpLUOZdlKFSzUYIl95IKAPTkL2nBPwA", - "90JBO1+u1gmzgDhan5WzqgZ7o6/iV3Lm36wr140qJZBQsIxP9JW4UM++PmQ/yO/i/ENO4GpZLM6cKRSV", - "m6GhY2GC+GQtFwLzwvgdKGnrQk3ETFJhD8Es3uDLuhyFS/RCjAp1qfS1Qr2YyokZ4eJbBc675nLYpHDS", - "IdcI8SGegWgAGmyDXzGyd37NVv2L8cWr4lz8FD2A86yw7Gs8CD0tH2zgCoDmcO98HL2OP6nPb7li6r7B", - "8deXmisfi6hIW8lnVcqERMwqSYLuqRUaw0cSbcrCMWuoP/wyslhBr68f7Bxe07to00GUjdhEzLjq46ud", - "xNoq/gIPdOdrMSrt2EQwPUHqTIcrbJpwnfEYsyTS27PqbqY3HsuHAT1UBrNVe9xk6W/BOhcKb0xYi2vJ", - "xGIiQHPyxWAUhbLgpUFbvFtRIMh7RY9yaCb2RNoPDyI+MmShlXTarFV+gthAHC8UH0ILPoaqkTJxoXBa", - "3AjPp0MedRi+H7rRpzBhFuYLXYXPs44g8BVrtaLIEIwPqFNWaoXEd3nYEG1K2PQSidOsbKKbiwXltUcP", - "fS9BhAUJRXWB8BnT2xdwHZaMQfxfhYiCkuBGIUrBLC2ydsXK1L9QsAeVAC4QTr7AF21Tn3LIQ7NohGpa", - "l48BSimbPBRFKuenfTW5UHprtZxci9tt3Xyx8bnp1Q1uT8266I9jQ/J3Qb1G1Ks5Azxe6zqlgL9vtt/Z", - "MNxU++9zKpfHnlnVuYfXk3asQ/Lx4/9/AJEO1cgp1QMA", + "iIYxaMyQNxVVZvijoiNDBtUzugBYnzqvfQV3zbXa7+G8dnBCXr0jlU7d3Bi+jPsHtI/rsaMFt5fr+/ed", + "dN6nGG5PWaavRUpbVXZle0//kuh82WfP/pJJddlnT7/9y0Jfif22s8NrbKyHvGuK3PpFeT1J7upN+YiN", + "4x103KcP76/C3zqnunjlRXR89+S47SrEehBaS11A1A3slhOZw39DY3YplngYLzIHZ/HSmazPvv7LW+F4", + "n/3pL2dzOXWtZ/IlppNueNSB10A4E3ZTyR0NnOfl2RnL5Y3IbOcnk+UG8Mu7gm+zF1VoYwcdrCkRyj2p", + "YAH0ThpY2elRAdupMm/h9MiIXPCmdPNz4U1TISk0UN1MKGFC8thLgbHEgrsanVeiPIKKt1VmC0AdNYvk", + "GsQipch+kWXjfZ+UNlYOx0k9Pqz8XnTLu4npwAJapPQPYrkipC/FEkJfQSxfiuWPOfxh+PUP/muU0iAi", + "7kU+Szu6FMucp5vJDOhJxoTtqlgIIxNGPdsoTNqRXVrQiy/FsgsVo2M+dcEB18moAj3T3kq7BvgHsZxo", + "blIWmoAukIkpKgM+GPerv6hikfN0v/uzVkt0/m9EbVF8IdLmjQYMq2bDJoLM+UzUbfzLPNpzZQhnHkdt", + "8ZxP4D8vjNHXAT1ffwP6/w8w76obP+OlCtNwD4CU89qKWrL6yZLuGSPKf133r//Ca32Uy9okZkq4tSnb", + "YrKQzvna8owK8Dorsik+LXa4It6vgtWco+yeVKwS+E5KVrXbo5q1k1NJ4ZxWt5FquOffUfd1oUY/4JNg", + "VIrC2qBIi0I7AvDkMZZqSdMMv0HuDH+AFwv818cN3Uehlr5f7Tam7FsRc4Y4uyF7p9UAYqGYVoyzMb5h", + "vdVX4OW8EFwRxcJNn0SYN+y4easKmMnkcrvmieHGpM3RfmJkYIZhbWzvmR8M71X09f6jzvm7sWeKzPEm", + "b83vtZG/aOV45p0iGTbtUwg2ouZPcwHWm67Xexqq6ZIPjCK5v4HupkeXXL5Fk8YGK7o0TvOUBP647z9/", + "EJng1S88La+u6x5YzlT7dAcrNA6blaEIzGFyhRF9dogqRufd3Kahlvv1W9FRcw0fzK0x4JT6txy//5U0", + "0dIYUF4v9uhw6Zzz+6n+9YWqpFzNYDY8GwX024ijZfsKug6e7oavTmaN7uenQjH4rfRD+u/B31mecSX6", + "pM7NjBB2t3GWXcb5r7uNcy2tax4GUzlcSyuY0c7noFsdYZ08Hq24m1M+39MlowS+0yWj2u3xkvH4mP5o", + "8GxN0BoppUVSY4MVRQ39AzFn8bjvP71SafwbNDQS3PjxHh8ou2to4YV8Ko11DOfBUKW5d9Wt3MHfiupm", + "eCoLu+U+Qo1at6nz9vjBNt1I7m0oL59HXM2yBjT44H/fcPa3UB3+oDrjhk28L2XyHBS8tmEeWsPsOPgd", + "1U4AOUKQ2y1ImN9VVKdhV4Qqvlu2UX2LivtyTb3dgTzuoPe2UjsjiVI2tSyDdUuFfu0kM/B+aMdesZAW", + "xAKJDbngZulPqfoiwsM+eWIKqs79q9x35GMdtO8mxOmgkXcrUXJHzbw9v3QnDX1T90dN/Tf+HHAfKtw9", + "mNMfDed/VMP5A5nJf7NGcTYRsOmeaSI1oWR4SGfPdg796PX56PV5e3vhxnJzd1RK1kprdNJFGno9qiCP", + "xsI/YpDgGik08noj8ownmJh3JFTDTn0oGzDD1UwwoVKfLqjVWlUBah03rgtYbLgFMPn8wqE2zvUs/FyZ", + "I+bul/E0w2ZsH6Fl4uUY1QnvPMofwY+uYT/u24muOqkuAquxyOpdJVUE2k1EVZo/yqZH2fSHlE2RBn4n", + "weu3Y4+wCQ/gWbwjU9xesfiODLK5OF0nZtnW9ZFxPjLO3zPj9BmHRpSO6NbmqfW0R+sWqlreI1zFxsxH", + "D2elaqb1llsLZSAd2VyIxksL/c68yyPDdvgYRmYSlsOXWMinVUdPeCZGU544bTaMgM3CA1IOE2d7F8Xh", + "4VfiKftFa0w3sP+7fpn+/dnBdhKarVX5701q1kbYUWyu9H2Um49y81Fu/l7lZo3YGwVnbsjCP83gi9aY", + "YPwZpYkt8pzESVsgMIX5d/CFibzQZwaI7mP0brfBmAjwU5HxZWP1vmP4hU2EuxZCBdj9tXJ9vyNTXIvW", + "c3Ytc0Gqzk6azgML8BtgAo6rRHR6FPZt64M9Z2RCvArYYhlEL+4wB6xjj10bisWWqDkvJxRnEpPf59yX", + "JBQq7Tz0g+ov/d5yw+6uvYx33dsi32H8jjt7FSZzL/t6D4pbWer+QbS2EvyOKlu146O+9qiv/a69hXyJ", + "xgap7n+Jgh29ZLB0LEwWPxV5ZzH/x1YMS5by+7G387yzy6FmjuerEfuO5/t/nFDAzZKxliOpMYHNl5jx", + "3ydy6vV7mMep1++VaZx6/R6gXMdM6FX32rXtwR/ZZMXHlpcetl/IdimtAJ1ArwYCxKQgsGdYjquPBXAI", + "/665SXfZuA2oteYe+cXsVjWzQcirHxIbhM+Y1yB8wKQGHbftlM/Ed/D1uX5t9D05+wPQ4aQCdYte2tD+", + "UR19VEf/WP4Ka0TwB862D3vxkjwSzhIjhLJzfY+sKVkF3YU/NXR6ZFI7MSnawNFELLVKR1deD92cL9J3", + "YuLGCZVWLTihf2va10zmrSU+AaWxAJJWjNrcUsHGUfBldvMgmIQR2zF66N1thJbSodURsMldVnGzGf5N", + "cEC9wxDLzUMs7zjEoxT80goZ+s3Y3TxSsuHXBKPBOrIAmqMhGIggYYGn7Y3/mYsZ5JvI1YwyTVyLSX4/", + "OaLgBjGyhZnyRHRjbCCRHb8Uqgwb9/3X6rIBx2vjdi36xJrQalQqdO7kQv4iRlNt2hxdwtyFSnQKmDDl", + "V9qI1L8CgWmegQGobYL/KngmXRMD0At89wO09Y1Cmo3DQ8pBl2lrl/4kf0fPa3fVjBTPH0Yv8oB30Ypi", + "l0ed6PHi9iiyGkWWp5FWgRUaNMmsxdwtsvuRUVtEhZ/EH/32mWkr7pGzArhO/JQaPnLRRy76BzR/Ifb/", + "wTnP91ylmfhPfsXPcI3Hkmd6dn+saN4Ivwtvauv5yKx2YVY8SUS+xeqV4s4S1mJzmlAq7UJu8pB8ZIS/", + "E0bYTGotjrZ6kbvR7lGBQjlh0IHTacYZwfGod+tIwd8Pp+4HSt3Ost/xKznj7h71ReUhdmHLZdtHRvyo", + "Nf6u796GL0TjIt/n/F+FYNigwlk2cIbnjLNMq5kw/kIt6QYNmMezKow7MfJAnC3BhVNhDBCIzmSyvI1R", + "4YMHcUoQ1o0KoQGjMR4sNV+5FiMAh7dYv+tpSXHXqT9JnvCpm/SpaEBfpIOh4Yqyltw+E3cE0eIq6kUU", + "LN0IbrUqjzLgAs8yYUI1OChrjDm5lzmVTzEi0/yeyjMVJhvhGhreSM7w+1ijWlgnFc37xw9vwuxQfsGs", + "+EQXmEcc+P54PyCPjdl5oVML8lTO5atn93Z9C7rAuf5eWqfN8pVyZnn/mkEd/i56wmrPR63hUWv4Xdc4", + "ADRvXKSnA4YtassJtIIyoHPh0A1k9rs2alX2eDuDPDVSuXN9mk7vjynmHubx6y6MsNr6kfk9Mr/fddiT", + "tDmEM88FT4UZTbV2wrTr5pxRQ5wvNWbXwsDxqFRs0Lup7ciJRZ5xJ7bfAngAH7rEIPBMlpmq/E+73gJC", + "UbhRqhNE6ZEuXCaV2DSf0Jb5tjghsZiINO0wkuOzmUhHeTrdNAa1Yns8SYS1cpKJfXZ6/BqHis+9bWP5", + "M9xlj/1pPsQeZyBPEp5v8XNCx0cYNuMyha1FRhT6tgFfcDOTajTRzunF+gDf4feMWjH8fzLfobSGB48B", + "KGvA34ipuzNo0+x3+gG+vjNwp/MG/qvzOwBu1mVKSdlseuYzMcKcqrYLMvpC5Gq2goctOJDzXJhWD95T", + "+LXiu7vjggl4i1stwY4OtbuCRuPFKLF2hBsEXnGbaQR9XWFzoCnuTe4NIN6xjggp3+Jih6c1guipmdGF", + "2uDEV7ZhM8PzuUwssXkE0X4kLY7Op3wWJAT5OP++6yMZriyc8EKnt6tumk7PPYy3Om2y1nyvr3GdpWjw", + "mtDe+AP++cJ+x6349mvyXw3fnWH02H3YaG5r/fiAVqL7U+y91amDUh9aPir0jwr971mhlzOljRglPJlv", + "kSpEEWyyzDmxR1ggdGvV6DTqlxveV6KKTE1/Uy8ttNxmOwuu5FYpxaUCRidSRh0enc/PhPtJTN7IqUiW", + "SSbO3L2+e9sG6F24f3O/R1nwKAv+gM5DTcTwu8nGYnE1t9C617dkXe+ODRgOwzjdUNneeGr0L0KRuk21", + "Nh9OzQ6L7MCMHTeOgrsSbu8xEsjWAXdiwatdHrnvI/f9nddON8uRcvMRuh2tr/U1fA0D5plP8iLMFW9N", + "P3rXYFigutbYIppLWzAssjUIh72fACN+02q2e8tv5KJYeE+t0nxXDfVueGrlN222ujrAaLPbAq9FcNZZ", + "WKPMvF0c6+O94czp/I3mqVSz+xRTEWg3EVVp/iieHsXTH/FyUNLAHzzQCjjSw+jOVbhd+dKj5vzImh5Z", + "U75F+/qDcKeVB8KGZPbXjLPge5LiO6Esnwm/mNSW9cfMXr9Xf8nsmsOSSi815/30P9Lkyx3jilgwZQT9", + "snKBAgcUquPmrASINJSXaokP4cEJFqupfjGZZcN6ev3Kh5/mQkEu3pnhKWyfNnImVfwDfn5ptLXvw/fA", + "68oPzsjENX5c71koy6fiR9M1Aeva3b3FjLB2dacNtbH7F3NGYHEAFFaznbaokjrl6Nduqb6qWwTdv8wt", + "guxkXXeqnmJmHZWad4h8j3zfL4cXQkqcjhtzzs1MuBdguAfXfPx0Lxo/gRryGuQtOn9Ln0et/1Hr/2Np", + "/Y2E8DuqGwHL2eROQy0+hxdNa0HnOOfNNxTPQTNtH4CZJiXYbpy01uGRjT6y0T8kG61QwSMP/XJ4qBHc", + "ifCtVk7c3C8zbYDfkas29nxkr4/s9fceMKmtGGk1SoXjyXxbIhNFWbIs8z3TcrtTMSlmM5hj4K0EUtju", + "abw3EGNbOrCb5YicvkeZtK5TZBYeFnVi0Am5faLVVM42xQDSYFaYK2G6j7MCG8MQ6RcvX37f6V4KJa+E", + "sTwbKeGutbkcUTToiIyR22vNUTvLZoYr4FgRIPMAGQGknQ2t3VwsrMiuhEUC6ZLM7TZvF1Wp9gBXgwrc", + "XaTY4+XgNtKrSyghkJPXwZCucbvTED5RQmij4LADnpFuUvV805Lnfo7ok0eJ/uXlf+GTDMoOAXOlFHKA", + "QUZn7Vj9HTSmhxffFrGbQKVsby54mglrmVbZcr89KUJS2M2ko8R1lXywx6YsC2bk+GRzhoFJAFitH+KN", + "/OuU2p5soNmB8yepUn1d8dw8Pjlt826cyzQVamfeQd3aJtYctO+ndeMrjBMDpJefSpnTHRxCG8RHo76l", + "xPXoGgffdCpwzNSqW6qHL/KurvPWc1ne8ly+hExx/V6La7Jfe/RJ3kAphBuj2we3YP+2sBY/EYRec/5W", + "ICcy2JWFVFgCCHP9LfhN+WFaZBkd2OcKLCfqO6br1cNZStKmAbopmS1dH7XNnbTNR03wURP8PKbzRvr9", + "nafsayC3Lmz4fS5U4Er3yX11BW43plvv8chrH+3Sf0jeVSWDlixdSmSN2xO6MWzCAJJIN/Cb+5agjy+S", + "v7EXSV0k81dXQrlmX2r8nTymWT7nVnwxvoIOZo7R8r0+fXil0vDnW30lwt8vuUpEZ6/Cetb1dZN9x6Tr", + "X8w2QlZ4z4dh9zzxjSbcwKfC6dFE68sFN5fhsy0mFB0NyKsKnlW/ie74obXTOdKrZ/7QdiHhyHxyn37v", + "Uiyvtan8NaoC6XJo63kgmvPZZc25IL6Ys6KMFbCzmK6i6+5UDAnraTepWbBkrdgTvqAgAbB6AEYGowex", + "1vh3afLotGtaWZ2JV8Zog8xzfeNeVG+s0JgJaM20YYVKeAGm1LLYExM3icCuITrl1UI6dNeG/XTXmqXS", + "OqkShyqN1YVJhGXX0s1ZKqdTYWCLQB1kds5zYYfsQ6GcXIihH//F6clLYD0p2/PfDGlGwJDsPsuNTguA", + "ieTYx0pQfVBbbR81IOt4cjlyhieihB2nfT43+lqxvbi2+EsVNMHMpBJ9luisWKi+X8qoMFnDOK+lyFIv", + "H4EYEzDGB7WTeqKOxVELaFR7uRMzbZZVNcqvv/GEU3+z6WKEW8UCvBWBkoMT6wgFe55RD0w1CVvomupx", + "nxvQFrztE056CrtD5cRDL5YWuD+YVjSTC+nssNHc7BpeKXAqDA7WOr7ImVTsRyVv2EImRluRaFCnumnp", + "zkvHlS0fIcr1ft6mxzgboPbLE4wbu0mlaTyTXc2r2DPYBD72f13BKSCKBorPskjr8TrGEi1MQnogrdUO", + "2Sm5TeBLEt2IaGGe2tsIF7ZeOrHAsde1VPqCG8OXdE8C+mpKWgHfM0rIGh5tqQHMxZCht+RHiF5I3Z0n", + "vsIVho0YQlK/8RIQdhE6kWjoM55d86VlFz3EoIvenXZxbfOaE4W/kUp8/o0qGeT6DOEFwz9m+JlNZeYF", + "qJsbcV2f4z1MrJaWKzDqrgyTZ9kZ9ILuSFvrYa7FgquBETxFTk8SyosiW7MwBCS51kWWMp/0Hk0Nr7Vh", + "NRG3t09Cro8AptJYV9pjKgTKPYkSiAZR1vePIGIqb1BY0fwWwlo+E32GD1AXvR9DT2RDR2yi9eKix7Sp", + "/rYnFRZglFbsM7hM+MY35YVwWig0WFz0ao9IbTyzbsAMrPHnNeb4Rs86Ky1Qk5Ruf1FryPSsH/dXqqku", + "P11zo/pMuGS4P/wMkjgs7FEOb5XDzaVF71kK187jtyWDdxKlG0RVq5INMPos5uE1upjNWaGmMqMSrMhu", + "yQo9ZGPkI2N8RdUF1SBiNZWJiNAyqawTPH3OeJYxvKewVYlpQVUW3DCQUUN2JsgKanOR4G0LeWCRZQxw", + "opGxPBBvf42Md/V41k9nuJXVBYvBdpZXw6LW2y1xuPC0iERXGmwCS1xoJZ02TGPx3CyDXR0E6UnHM2Qr", + "5mcyw/UpVRndb8oQeyZynaCbwPVcJnPsQDPRSVKY6ItQR/z2iphwyqvlMPGGKFVlMs36T3seaIDangS6", + "z4ywwjFYDU/mldU1jqP41ciKfzXkdNNKO7IkZEsmVWIEt3Ctr2yXBbODSoJK1qdmMC+Rxgk4nXsDcKVn", + "4yZ04J63sFYHCqNxKq8OjfuxwbQccHPNtsz2rEPliIM0sJV12rBQ9Anb3zRikAsdKJseHajIJLrnNKuh", + "RmTiiitHt3NpCZWfkxMaNICdqZwJ0AL+RqTTD1alsq33bPaktZUpVA6rurH1JZcouEF8VVWB3R45T42+", + "EooDki6E46gd+JNbAjYToXt7iGHCG3ki5a9rTaJZUzv1IAbA1uVUJtQfc3kER6g22TTG7a1yL9/Cb3Uz", + "4lzKJp9gUlXCgob4TjY+8oKNxdem0+A3RCN4q1bJXIdsfCkMPFrxXI6P2A/4gb04PWEUasD2jMC/6EWR", + "vhyUyV3CzNlY3DihABHGR2Uqdz+f+BuUO9UJz+CtNhHWjo+YXVonFsx/wUyhFJwYh7cab5Usp1szLiZp", + "jsbpMH/4KQzU6/dqAzVqugFV2pGtQUnZhg9BmhEyALciOjjwdHJAouLkuHbegRZWaAsPfwPFfO9c/r0A", + "2WDbF+FMsUYw35+fn/qSVZYteA6ne81Nim5kA+kxBWYPrE0XjpEpV/5CQob9jczO+NC6zL388FoemxSO", + "LfgSXqy5WuLDNrSql0NYW8yJcsJwZNovM5lcbr0sFfBPAk2DJuF9CdmV5CUSUs4NhNDtdiTLidz1htS4", + "psd7Uus9qbL1IzzZB7wttZ/NPd+ZrMhE4nRDMUAoRxV+ZTl382Bjx7WLlIkMFa0WlWLWYMg5f/uGOT4j", + "iaSnTdDgwIo8FybhNkit7348P3//rs9e9Nnxyd9adJhGZf5vEqvrobWIuJ9yLQP3mTNysWgxBt40wRbX", + "uTaO3QxKF+YacFgL7KLPQtyIZMsNgJe3B7yChzc9GKlfnjad0MZrUgUFfxDLrQzvUiwnmpv0S2B3YT2P", + "zK4Ts7sUy0/D6mrncs+MDhaxtoE/iKV/Z47a5w8ej2lviQG9gin22Xc8ubQ5T+DW3syFbsFNA99D+/yc", + "pxT8UzrFXYplqAVobQt36s5tfWTRJm578u70x/M+O3/1X+cvPrxq57mr6qC4A4M5S4zOsjPhXCbSrazG", + "YmtmqblnOOHexKeubBLDTazTuQWPKwWB2P3fNnta341HRtWJUdGpjzxifBqe1XJY98y9gD2NbpqinxDP", + "bwYR07nzHi/cuMo7ILSaCQtI30UtwfGWreMt73s8b4+5Bf+ksbapo7pp815LxTNm17dw6ryPaVhBYDVd", + "VqJHyy1DLe9lqBVc9hgSj84v2k9ofYc3suY38kqAGvqSTJWtHDmTV4JdSXEdHbKoQ+kHDvf4aZEF3v3E", + "sp/E5MP5y2jDeScu9f6Qfe/bwSP0c3zrDAwdbDsx0FZCik/b+SHR21nvypubtuORJbeyZMCKEWBF8Jd/", + "QE7cejQ7GmnBTOYt9zlfYslMQLzx2lrGFePz6lW6/WXgTSSU9feBITurGe+N8ENZ7+yIpYaRvIL9e5LJ", + "HOMugEjQFZAmRc5/MeRgXE5pvJOxvMOGH8fAh+7coQyWiF6MO7CIUy7p7arxVCbLteV+Dhaxsi2PXKID", + "lyjR4hMwiqYDundeUYkKamUXaWHQXj1aNCWH4Fk2SDKdXLLQLlqAIs7CaSxklsnKQexUW30TV3pOoU/+", + "0TrRxgiba5ViLFQbV9zxRa66BRuO7i29sh9XuEcLzzn34V2VPXI6vPQAVWTauiE7R13RmWVgm/5BIDUa", + "A3TgkSwLj/ujyI9FCA2DR30FjuwzzFMFlIweGuQKT0nAEnqxqGbfyDncvZGpxy5+AtZJuK4K2t/wYIwv", + "/spVn0j3QrYomWboTDITo4wvdeHCtcd/WfYJP+z7rAZTacSwcXUxgt8I6zR5My6G7AUqqUZwB2nL0G7A", + "2dQIO/crXnCIkfOXANu4QBBWRtgCAuHE1MNmCuyyKw/ACTdwMIvcLas/hbcrOhutBHlEdNQF/WrvyuXb", + "MPGRzbey+YBnVdn/gGx+4wlt4/N1PKJgraZaGfB9JNJyYfj4mCCzGQEFceNEGh++4yty+GVYfS9e6bV9", + "h/zstm/FiZLuNZfZVqYZZECC3rNKO2CJUkkn4W2V5vupKW1l8o90tpXO4MBGU9yyhyezpuPZjcisE3k7", + "SlLsKtOmxEPv9+VETiZzWqq3XfsrhC3MFGKFMNSzg+0aJ7F9tR+CqOxETo06SI22jBgI9NuSdh4t1+Jm", + "zgvryM8kKy+DZGtzIBftkL3TbFoYUi1WlZlrUCVIUWFakeOVp+3PQcJNu/ZIx1vpOB78JyPm1oN6ELFZ", + "Q2xYYgFaablqTwcgQIkOAMMDAbBrYQTDl6wij25AtsCEp+DIvPQqbMjAUCfIquRtGPEehe8Hcecry8qq", + "GlgGX9VBXhEjCBbUtIj7MOM5+kXRPejl2sXFiBBju6KVB8uTMzy5BGheVfH3AG/MkZblWir3WfnMI4/Z", + "mcd8UvZyF9YSaLWr8QS2b9VMwhy/FEhlEV7lHaZOSl32d403NE1y+/6U9c1aDaq5MFKnMqkUMwtWofA2", + "fuWdh7pRYAnnnohwZRGPNLiVBjcewT2TYNPp7EaBuWrwNKG6nQOhEp2KlJ2++2tHBI3bNlk6sVVLz9Vs", + "0xrfkYQ6STOx1YMkSDMwojX6j3D2zeHhwrJ/FVI4T3f09qA0k2owzTDxLboq+yCFjpYoP/Rd6W3FX+CR", + "wtYprGopfUDa8njnq6lvvBquI2BGvcIt1if6OJl6FRkRC3ebZ0bwdAn743EPPcRAcySzLNyBlWa5kfAU", + "EdbuQYwRRvVFXbr9PhsXBtO+hvgx+DuGfY0pNm1shI82hw0YV1JrPGfjBmTEiMWcG7itZ0uW67zIylzw", + "3LGEW9E1K8c9EUvrET3Kp63U4zH04W+hmw/pnv2pEkzwte3MqgQYeqyGgGqz6ja4fnTCGG1GzS7qftk+", + "bUDlN2/SUsIdHb368GH08v27d69enp+8fzf68Or1j2evjpt9UP2kWwMUw6Iq0YMxyaGLlUI4WqBW2Ejr", + "Ix+MWuESzQP7lQ4/+KYQPlgxB+AIa+HR1YgfHxn9g9LXKuSWkirJilSwYx+O2mevhUvmffZf33/oM8qk", + "1GdnbpkJOxfC9RlWCe6ztyKVvM9ea+hzLm7cOdxs+6xC3X1wRDjTySV0e8uVnOIMT42Y0hjv3VwYYpML", + "bcR2Q2PlbGpY0S8RcqNflt/CDwSms5QJx2dR0WkOKnx49lud9SPj3cp4/aE9PMddO5d75rUhUnxruprQ", + "kPQEsviHUFi/G428Z16JMtxl3tUIxfV0+X5bQiRinwllJOpZeA+4lkaE30gX41dcZujI5V+482IC6cnI", + "kPCx3/MrAqJvZZInoc0Q2jCpUoSAccKoPBVWpPfCMa3njTk3FrhYTtkViZ1hGonGzZZ2ZEQqjUjcJrqT", + "thQ0tpoRWE8ZZwHCcEv5s4bAUPqRgWGUkhYhcDwNEph/fXXeZ6fvz86bxWOurRsF5tV84hOdLlEwAZSD", + "0x/P4xWvD4uL59wiCGlpzdj+noRrhhHtFUeI0AuPocyKXNls3EZTiHuS+X1WKAl5ait5ECqPRI/y/e7y", + "PSberTHAkl2tMYRuot/mWlmxg+ynDsyIRGBaa3/JfC1NNHd4+qSGiP5wKP7Fgbr1mTaez0VsZTy94gqz", + "OOrSn6fCqj+9ilHZnUcdo4OOQfv1KZSM1ZO5Zy0DsLbxkPxJ1NC7ZLOY9G7qE8qxtydvX1HCpEYmCF19", + "usoG4VElHyOckeKKZwwvdYlGKw92reUnX3ncw07COzw4ocgqmy2ZuEE2mAJ02TI7MZ0KTPKLBYSaSo69", + "Ci3I3wdbEU2X+WKjWzaKVGrTh3kCr2bPDg99el4Dq5Mp7u1Xh1/H/W2OinkoFc3vuQc/7Ko96Gn1qptt", + "1C4XctEm9SK6BIARyUgVAZw6mLtF1g+paqEjVobYfHd/mO36CU7U1NXaFdW17wUuYGtogdp4qIlA8mLV", + "LoABqoV/lR4+WiF+Y1pKv9fGEfwDhsdaasUSnYqaYr2KI3g7uJaWdFfRwFVa0pbiby2GsMapVNLVvP+h", + "z95px17rQqX7t9XF/EaUHGmj0gUp4F8aDljd/ijLZ+KJZUaoVBhhop9nQv3YHlfsovfius/OFM//r4te", + "8HbZh9RPWS2JUOwsnRXZFHZhCUQH/vZD9iGUDfBnE0bwM/Dqe78SBETfIGrEnGEWuo8J+YchzdAY0rb7", + "kGifBzZMbQzgxywIfSZjAcyuVnwAcFcFb/UkHpW7VuUO3f89bjygYtd4Iru9Jm9IdVcmp6qKiBACU0H8", + "T5vRDkaHURETtPK3dNdO/tv5VHtaOpjFlgM41ouXlNYG3k06PDwev39b6xAy+cJ+A8BhGiEiLLwldszc", + "e1903rioR4LfTPCpXox8hiN8s3tw2m8/pft+q0vzUdy3Bk5BrpKLkC2UkeeXL6SkmN9bxp1PtbhGAlPY", + "jz4zIuOoxji9Jo/J13FPaUenhmla94fsRyvY2FlKn3hd9ztrCMdb2f/6yrZqIm8wzqtrlhSKCmvJkvLU", + "b4vX55GlAdZUfFycMFcC8x0GSHM5RRNoaZO+krbgGezORGbSLYfsFSRcrXYgl1IyAT8d+FFh0ebTMZVH", + "Z5luPKQeSPjA/MNjM+DIVlxOikXhibOGW3sv35zte9SOhotTYXADVCLYuVyITCoBaUM/rRBbXd6j/OqG", + "e7BhnxjzHuTR0/v+NpRbXInnriG0UM4s1xyW93ylE7K9VTtYlguDedz3G6O/q7s6SoXjMrO7h7sHcqps", + "HOPOGTkpnLBbKA+XtE57c56C/zmoK1jRdTNK1zbJp0NLREruOJhrFYGE1yx03ux7qylWAvP84eWbs2aU", + "R3WhIUK+Oq5NtAm2Imn9WUENDNqJELrx5my/WfSv4aQ3Vu2Yvj2kcsPvy6oztS2K2eIbb0eyqZB+4+GV", + "9N6ErdvzD6wG2q0s2M+lzATQQQlK8q3i4g1co6xjXs2D5CKnXMI1583L09+qvEjykhk9yol2OZHkDy0e", + "qidxz2IhS/JbsmGP0yVKE0bflQ37rGmN3EemJfhA/29enpYZc+U0vKO1VpAYNTMbuHkhkjTA7ZTWROm0", + "nWUev3/LoEED16yM02yjJkNOy7Q/4I9dJ/7cC2xAfDugFw2fwSzGLJ7LhVSzwYss09cD8g5pXC/QYnt+", + "Y24Eb5kQJZBj9l8Fr8uDEvY2v6wqRFgPLoFpiOVIhQ4/tZRjeFihV50a8DA6vQeQezhQk3J2a6G3XdJp", + "vv2WX97cVw15Wej+OUx4ce6P4myLONP8wS/atbP4jRvn3LyGzl+Kaa6s8d2NYqsljCjjyxr9Ir/wcIF+", + "2UtujBRY3CdmQ5pSMVypkGtNsBaGY76eja+PGOruVC1xqxWnPi13WNmtRx6xmUeUh/XAnKLpXHZ70bud", + "VFcBy6nFruXI3olrtrkkGePWypnysW9IEluqkuXcgFrcvp5T7t2lVpZEXl1U3L4yiH3uo+ZoBg0VyWxL", + "Rvldy43dW1GxT/uyWuKA0/dW2IscbiuaV4lFnUlh83tLqMmOD8EtD3GxrtmKgZ3N+ZVgE+3mJOeiG5Kt", + "407tySW+QEvLKuDpJQbrHKFrOjtRqciFSn3Fk2ow7HPGGRTSy0TMOBhcq2IGwAnKSuk+pY/H4zPNrvLg", + "Ez3VnPPJ+1yoDY+OSlxHBcfxCdORn8C2auxMug2xg2EIWj7X9AXiPuI19YO6bXBxsSFKgtdy1Elbhj1H", + "3/PrWFvT6loy4G0hzl5fqgc3VxSnSBWIfqBXNgU+Qz4dZYuFMJYZQXHdK3oaFqcLBcnmmAvMGcEdk45x", + "C2SZi0TybKcg6fvSyuqn/KiUbSZCxycjwutPSny30Mlwls2a03mbhxXQMPr9etJFYtBKUACUWu6qZDS7", + "cwV5p8R1toxD8cmDaB5OuqzB/EMBd5nnPdAmaqXiunUyjWpMAFUxnbXDuDcvsIw7wOEXuYRSnq0cGpgO", + "HemCKzRBVv1O//a2lqk4NfIqKBu+SZ/NuUorAfBU3HJA9swBz6XP137EjEiwbNmMZXIqkmWSiT6bykz4", + "epqoDvnbO03GF2CLmQyhRaXs/FTO/PvQkJ3PhUWDJ1to67Ily/0GDKRKiySmgsyNhiGZ5Veiz4zIM74M", + "ZX/2a4vlM8xonJAS3pXp+lHvzHgbju+R9bazXr9dUFN1BCj9kMy37Wh2TxePxFfLFb+2kJgonr0NVYLB", + "EfuI8YjhRMNJMANpuGf664e/cKDm49A6LrHFONGpGPsT5rb8DXzA49BNSH/b9PTEJUynRxwYjwZpkhlv", + "Mf98SuXvn1gWW/expFlYj2c7+B06zscp+JrHp8RqXt2IBLQ/TAr7IbCo8e5JNOBAG8JX4vPbOmMMrRcy", + "TTNxze8rSGPYJRtdJQqitt+VWIiOiepOjb5ZvjJGmw1GTq5Sgez9ZjnI+FKYEO7A9MRXa65nUBmy2h0a", + "fgEhoJmg7Ppzbd0A4dFJW8bjMJQ0hRyy59pWArAClWAEw38NqHj0AFcwwCWMfXzTEeb6ekb3j/VZW4x7", + "5ezrw6/K+fmrxRMbo2xznclkSbdmGjQV1knlhdYbfT240lmxEDHFvcSFwFandJbsxNlgGEe3nkE1fAM+", + "g14RHmSlT6Xq24QoLZ8lyss5r4LQFK0zgi+OaJFxeShJMeKDjgfzF5TBH6C3BQCJznz9LRlrYXuGIy18", + "xxXTuRtIxYyYSkWvciEyjl+vVG+vy2CWiikvMjeA9WbCoK0DbHY8+8TJolaw/FEYtwtj2CkfD/uAYrjh", + "PO77EUunorGefuQGxGig3dEmlmLqAanV2qKNTKvOEFvYXixovpDYExOBQHv8FV267VGV34yQDYm0X/sS", + "xeioUJU4vmAUJO41SoWS0Cs3Gl72zWiS8eQyk9bVvi2UETyZE4j4rRFURLPvQzdHLrP4gqYLF78L+zOS", + "Cg4rE45A3CzrEzMCsAjANU27yImXleDjN6myI8/aKt/WM2kP2Yv6+RD/QqeGSgWURM8UEJy0zITAO25Z", + "oS4h8rMSZVeDBcyPQ1mc1NtvArE0nE+v39t4QL1+r/GEiBuuHVH168oZVb8OhwS6wNoplV82HBNBqZ9T", + "r9/bdFBwd105qepXlaOqfl0/K/iFNnydw/R7NwPY3cEVN6j8wTYflxv6XdzlypcfYJY/1ibpI4JPcYuP", + "ww6f+j37rrbB4dsfa/sbvv1Qbi+58pxn9jyunL4KMesn1a1FJlKf1Ye4sw1T/tHvVgk8fHOs7Ou4qeHL", + "l9W87mE4ZFk/hs3dLXCeDqcMl0bNCCE1a9OeIhrqiXIlHRQX2aykEXGtZG3AQRN084pkiaoWlTNO+yyZ", + "c8MTJ4xlunBWpoL9gw9+ORz8efQzmQSSkM5p1GdgGtHWsW+/rnQkIl7wmzdCzdy8d/Tt1/A46JwwMP//", + "N8L793976GR8m5IU3Fvg+5aT3OmKEjP/rsm9vW8On6FifRe1en/X6w+iYFzDRp+ODyLPvKtlUxIn9DHD", + "VOFGLmA6WDTM34LFjUhIQdeFywvHpBML1LEqHSiFyILnuaSUyih/tqgxMCtMHBCm1u9RLP3WXpBaIHT6", + "GJXp5Tu+gDGdN5FqJbrrVOtgO3errWF122s/7mbpBgV6NPn2a/h7S27plbweFYrGgzho6rFWenrR/PKy", + "qvmS0luO1y8nukHvhb3wGcl2tDj5Xsxpj4vCs0kiMw+ffXh1+mb9YtXIpv+TX3HKYsEg7UsREvpylgtj", + "pYWzYu9A5/knXg3Rx+pCnUc3h4nEd2Yb2vsybjCdF6cn0RosbqSzffwaZsekvVC+JIU21a+ZEyYQXsjY", + "jRHX2I6k4pCdlpNDBeFCYe0LeSXCw9xglukJzxjHNDza2COWZNrSzTgEKtpgumAZd2DNE1l2ocilhDxf", + "2etCUe2OVCQZJ2uKZYUV5Xt+GAKrV1fyrFwo+BmB1seuDfCd4YnI0GJeZE4OwjhgS7ziZnyhgK2RIy4z", + "wnE6bGn8S/8g/oxLNzobTDN9zaxYcOVkYocEh0l1oSruKcLG+iAE2x+gfc6mYc1UHwQaDshtINMJzyxL", + "9YVS2lV2ZzyEc6AU0UbQ7ec5G4ffh7nRTgNBDJ0+Q2ra2x9DdcYLJW5y7bcTX1E9CgLVwvllktsheyNu", + "4HWVThtNG2EUwpILlUl1GewWvqZM0GYqR0c6AcfnG4AFWIV4GHFweKFehI6ZH7WslWZYJviV8FYZhOCJ", + "7/z478+rJ3uhEg6bVOnMpMOSwE4mFUchuci1cWFRpGc+RwxLl4ovZHKhxtRmb388ZK9uckPiNOSogY50", + "s3GFUbAjhdML7ug5esjee2FlL5TOidM8J74B1TFzo+F1hSld2pqhIxsbkWfDayOd2BsOh/tjps2Fom/F", + "Qjpk5/RLH6ebaGV1JrxGSfa1RC8m6HaNRryFSOZcSbsA7estleakepCl3kenEXIiwqsQJeMPyevQTELO", + "AX9ib+V3/QuF9OwZDu2ghcPH1FuhdkHKxUKrqJbpq1AVBL9/YgnYhfINBuh2iWNFj/7AmYIK57GlRWsT", + "Xr9A41cLPz/3EEWtKCjA7Xvv11COE19o/TpVZNWrtuKqxYhY5ciKpDaPbw/7a9b4G7koFhXtJtRWCUYk", + "dky9Yfu/PRyS2gx9ekdfHR6CAFT06elWtQ2l0FbZaItsd9EYkpBWpSCheVxZg1Bs0wQ9oTDtVULM+OXj", + "I4iePOFEI08c5TnT3u6tjUdvxGylQ1eKc6TuvX4P1ciOBsiq/loGYXBj+BI+B/+0LoZJceNYGfRRziwU", + "y9Vm3VIZbwJkraxIO8oD0D88PBzAesBSzdAJ2vBlgD4pMBldyibCXQuhyj2zjUjc9alqHXWrL1SNJs+W", + "ZH94OWULYS1siqzq/NFu0UDtedZ8Efzx5PhZuAIuwyaJG544kryDuc5w8xBZg7KEmYCDP+uFilNYrScP", + "bJo0CvTGl8WiUmL+Odx11UzYICC58gwSOQvE0OaZTKQLpcHqm+iNe56KQAFrZXV5NiqVts2GcIQWr8RI", + "On7zyDAewRBRlbmGL9RenBXqEonOsHZ1kdPDIb7llJM9ALwtZnMHocIip1vlhTpfSWXKMv6LJN9K42zk", + "tginoin4OdZ2oIKm1vHkssEEAl9jXbXOmOSzRjYg+1z4NxVR5WkirSWabJjdqnutH6BE2i3MuHoR3O3O", + "BuinRIM3DaoU7C+s1C9A2qUgYv8SlIhhpmcHUk31QSomxQwbCGMqDa65UQdExaUtFqGhJSAl6xl1a3w5", + "Csnqtt4GsWHXy2BYdX+129runglzJZOtWejIjybFFwWZCLxJoVFC3OSoK4KKd1LmFGXW6dz6J3J6F9Zm", + "UOZct/PCpfpa7bNUo9oYFMCKW+T/+V//mzSychQc11+diEqzwEoGM3klBkUOqK6spBtSqru+7pHv0F0f", + "9xp28/GBr/WBzyPTJ0gm13Yut3C1ARB1X5uVZZSeNq9upCM+CQhLr83xnkQXzqi3FSoVJkPpXPddM7HI", + "ridqvFsiXQTvFCBIEmduSdaN6BjH8jn311qaecjcwKQiVX6vnn1zH9uenhz7myC9TDVREUJuCL3uMvSQ", + "jZFoi3zMFoIrGx4cceEpCmXyy5aYj9UwfA8RKeNsLnjm5svgIkAqzJCN/ecAkLPciCupC5stY5/aCHXm", + "NZ7xKzFqnlA4iVjC1efk87ejUDUWT9mR2uoMnOVzpspKym2IQhWVp7Ka/CMcK9mxrIbbbKUsqo2hE5GW", + "aDtBpNI+9Po9v6JGppY3uh6dHK/lQKQtiFmlozV9dW9gMFbk62WmG7eJ3McyraBrLPrKyXh2enLckuDV", + "b6Dii+YH9ZnhC29RqS8j7Kf32Uq8pgoOW4vCOWHgrzXPqnGX4t7VOfU9VWxiRSho3uvFD7LVnRYUxDdS", + "FTfe2Yu9f/92cCmzTJgg99AyGQ9BKnx9ghX/7e2QkeRIyTNgfJCKq4PLhZ2NQ8wDoBlXJTkg6BXP2yA0", + "FmKhzTIeqFbV25aPv43ZKW0x8TBFTOxM7M4WOWyUFeknlshr2/0okNsFMm7WSOvFCFDiIQVy87HsLo9h", + "niviuL6IKI6bzC7WGS6bKPCneZ0WRCJTMvcFUhyysdJKBHHhDf1r1PKcjRdikVTEUjIzushDS2/c45bN", + "JZQ8TPLCCjdmB9hPm6X3zaDgoXc/vn1xQF8MwIkeHlNllpXsWSs/Zct0lgb3t2+Ghz7+PZUpaR8wKizQ", + "OlMklJh5rPUCl3Y0ZplUKw4msFjMdL1IQLbQPOmLcpaN1LoQi9HUCDG6nKxv9GsjBKMjC1siFftBfse8", + "F1I1GQpMrs9SQbnio0fsGKAfvQt+yN4UTvvwxLK3YjE4UVPN0mKRD9kLaws037OvcRzylJK/iCE7Du45", + "IeG6EUnG5QLNHQkoIBa1L87sAozT5JPjr+gZNzOBpzZy2vFsdDnBtwVmHeAoHD/tOC32mtNQqPixOTcp", + "vllYrFPvT1NOKyupnx2nwko4s7hA68tKX6hGcq9OrYFxwS93Pop3uJ+WfXjxlrDoDsfxMLuwTfPxwjAo", + "Ps0w6McWReSlXiyaoTFe8faqi9u9Bb9hT79B3xDbr8iKWrMWd3JrG4/0g7B4L2BWOBI2zbPyx7xnC5w3", + "V1oNjLUUVUN/oW47X4gFfNyHFxFyygVo+Xxp8YXKY01VPQQ0Lywqd81I1LzBTucjx+2lbcLTnJVKBtru", + "aJUDK9wAV+mHWuiqizBhrKW9B5AUm7yiLdVQdXwOU6Abxpj5yOdXaEvfgJQ+wA3avuR4GeCOfcOEcuQy", + "rtlEFyqNUguRHZF1FxN8TYLCPJHC+c0Jwfhm3SrvjJzNhBltIwDfrnIV7UKKJEy4SoGTjV+e/njE3oEm", + "D/8BgjiKzlalbGk49zDHzgQWEQ3f9ngGj8PQLBpXKzXt/LydZlJd6UtSmEvdesjeT11wFsI3dcvG1ZmM", + "2V4FjCeiin+TMPuYJCXhoeRNeV/ynRKaZqUizpVMnFwM2dsu9N9o/l4tZF7dO+J3kUV0VckQoXbTxl7E", + "oH9/IpTPahtVoRRY0826n/td+OY2StgoA7oz3boUXedKHRzN6BD9iW4/y0po6qZY2WptIQpQnfNoiiXM", + "jsVwauHg/Z7EiPdevweOdML0+r0JTy5BtVXpyLcJV+PYxM65EWn5GQu9NOqMYR0hZPMlXS6ksC8xXvNW", + "QXK+wkgZBxriWKxwDt2H4AIRAkNbrw08d8l89yCB1bUs/UrWCym9pBGY1dmVCHYTpguX6IWgKlT+fc1n", + "AH6oeWRSUA5InswPUuEw+Xq07wXnTkAoihUAJQEtOFdSXId5Wp2Jh5wkjRAed/cyPeszeJbpk0foPs5q", + "/SEu7qMzOrvD/AhA6/RezEAz8Xc1HwTM+IxLZV0tRBpeO2C8Al3ACCq9rfbZacaX1wbL8tddCfrMJkYI", + "Zefa2T5LMplPNAhg8gbrVyOdS6B6seAqDRVOr8TKMfpisk4Y/tAY9iOlVo5DBYvoXpLJ5NL22aVYwjOR", + "xYXqDPj4xxi28IAT8w7HKNUPortBKGc0pBROs4fE61PMvBiJLWxMNW0P1dNdKZ8AKYhpfiGE/CEZVZbZ", + "atS/t0CuBfvXq1DtxQj+atx+P4jbTpH6+0P2tjlA/znT0ylIf+9thDAocBD3paSYhzw9YaROZcIm3Ipv", + "vx4EBzBgjLk2rkq3Q/a9nM0ZBXBunT3u1QPO/LsyZQO9mpTVGXXhBno68Lc8NDzh9Pzj8CAY2cnoDgz2", + "4wYVpWVGuwn2l1Wc8KUjvRpaFfM0wros95XGNnk6SFurTeZVhhReu1m1djOzIiOJDM3oxI7IB4tcbqT1", + "9qk9Lzev5zoTEfh+6dNZfgnI4C1OMJYf3JLzTrastpXCosbptPdZhPm9OH/5faW6dNtsrE/TxVVwhMTT", + "YuNfP473YTmcKT3Q+fP65MgPmILig9ugf407176KGxYolRb/5GXXK8lpdn221AVbFNbhLHAKwSVoDAsB", + "h082xsMfN7u+dEKyNK9L6t3Q7KyqIKKdCxJ4ekEa3/Hgh2Nxda51Zr1GRMaeBi0yVFwdeT/VhvwE9AMc", + "KGIGkF9Q1uvDUxTWkL0P9/BMWhcPtnKqSuyT+xyyIHElzBIeZrw9imYCz9ZJVsQ0WBU68mpySByhyrKx", + "firQgaydRmRYWtAnzwosvFDkDpb2mXTMykWeRd9ffBH0xaMhuapEXE6NzhHEXM7mwroQ5+63DdWm8YnK", + "CzdMpc0huOmtLnwhYLhdGnpYnBcLrjASLClM6SYPuIXpUD1pnUW2PPaWWe5ZdcItuaRER9zCqOBMVydl", + "oNrdDTqIoriNdPLrjpWdEP026H1essoGfhoTKZytc7gK0oUzvhTLJtzDGSP6VbMHBClnhTtiGWi41wL+", + "LbNx8Mx7TlhfC0NnfVZef/osaA/+XrY/ZD9RlY6xn9G4X7pLVJgl8B0rXKg2eYRsE19ZAo9/Do+k9O4e", + "fGlh4dMpOYSDwlyBt+fvOjHuuY936n5Vv93vs7GtoBimhwsKDD3xNIh/5I4TAVtOQQkaYozj8vyhhdpa", + "NGG/KpZkghtiTa75lGkx44VW0kFIZMRizKdXZmUgbWCfnu5dCQM4+1wY8RyroGT62tZd/9EEhj4cvLpl", + "dWna8Cbsl9c1GVerpQDcbG+Axe0K6RX2KqFYp43X+XcBc0bdApyORHxrUbWuESHexwulV4XYGV8INvZo", + "Mi4DdTBRoFpSEd7Yvs/yrLB1Q0mF6NfvlnXDQBCDTU//ab7zEa8KczjiR03uj6HJ1ahyN9J4rc01p8xx", + "ehrPv8IXnaZZ+6ivWo6dlYS3mCWjgkVHjJiMlxCsUBlFHNIOYAwQceS5MKKPio4vfK1C18p4CNpTskdR", + "Qpw9cLEOweVg24qiyQOhEDmfi91/5zShX/VhI3SrIB1oNNDwOcVeEs5VRiA0qyJ3QBWvGEb1ronQtct2", + "pvT3529O62y4C4qs9doNTaD7ARqA/PYFrneL+2MDkknknoCIpX5cHjWD0euY976mEQzZ95xUZayLzvbC", + "JB1fWiYVx1rp+zHYZytu3ZoS64Jttz0+9oqDl6kt9AgPJ+HViHzCob0YsveqsiOerYKyQTYnhxjraxMQ", + "PVwKkVvmdMqXTyybiDm/ktocMbmdrggAee/48+4DectLkJ+4u+O+f35s6nM/BMXegwrrL5pxqyiTVtjE", + "snQ6apLwNfT054QJUG2ZV2YqjXUBVMx8jNs355ZJVwJTqUcvABFlPxgnw4VUKuu4SoR3Tk7w+gZgQvkJ", + "Ht9jcQQvSHAYaWPEKc3u68M/NzGQWxLbtYHNxtp5zcjk4wptKXDPhGOItvAVoE7YeF8ZH9846NaNmwP6", + "UtisBnqD2wf4AmAg7kQwG8FjdHPcvHLzQ6K1sHvhhPe+PvzzfneKDQFZQScUr0K82S5S0+fXw4fciU+a", + "GBxoS0aCd2PvN2W9txl5gPu0SGvn6ePbGqNfWpzL42gjAr3gSNXBx/igtCZ7L7kDEOYKMPvAZ2w9SKXF", + "ZK1wRXse6wJ4gDJEt/vYN5BR3ElffrjyDLoyE3ycrUJqfNW0TuQbojzLvYSGhA3l5pWe3jofhf2nfCPG", + "Vb/APwV55MFW93txEyxlCYH1h4ayWIymGZ9ZOh/You1+n2HN4QibnqJfwhMO2mK6pplYuf8VzjUVOEWQ", + "jH4lVw66XiPvqOxTJqau1+/hsxlMFZNj+ndqco8FGdx4Tvj61JLr5ty/mWMb/6JXGRVeqzDfVM+DaRwA", + "Ai5Hl2LZZPbTKSXqgZ9hfdA22LFQRiDUim2pJXSsdPxRxWKEvWwtCPvpKqW/w8ypyNLlQnjCyoX3Wwjj", + "rntC3Kyv4r9YovGJh5e1/WjHck3BWY2QluuQ/vs2kFbQ9aYHoFuQlF5MbxddGKL3Vq7gXoqXz7HQLiQ2", + "2J6ruy1k76V/Hn5RPsvewj0nPDJ73K2mceGW5dzg/YYTq/fGIZhKcK+l27Fn8ReqhJJTpbuYIQAjY/Hp", + "FK9c1Bs2Aa+a0MD3zbnhC+HTYb3yF2Kt4u/Us5a4CiYU7WI+/1xzZAGS8gJ4xrbLxzrDglADw2fduh8b", + "PlvtvdBXolvvt/pKrPZGf2BgE9s6n0LDH8Sy0peey7d1PMNW1W7CjchAvrWrcC+xYbV3JsTWO94ZNPIo", + "XIlBWI+ACd5JaxhWk8OV863tN0EeITFVtzJuTe1saysPC/m5JUnTKJD9pmWCnICw5bg9TZG6jVRuBHfi", + "WBo0uy5vJzwXjXmWoqaRBugMGrI9naDvN66yzzBG6j+++Wa/rhv/xzffoBJXyU53OPiPn3/9qv/1x39r", + "LnLl5g3BxBOrM+A25SSgIYyQ4NJXBjkY/vt2l0cYqXEzC+v04icxefvy9FhMMQBZqx03k7wEK1NK3AgS", + "8/3ss/P9/Ouzr5p34FKq1b578Cjw/0vSfL+xB3K5rZyqsipMY977SM6BNudJs0LttN7KDQggPF+GHPFr", + "Gx3dEGkkv8IwbT/MtoN4G9a4wxkUJhv5XcTP7drPQirvA/204QGtupgazG2Thm2xIbvmjpOHXanPuuvp", + "VnD245bV0CBNyzgWmXDilLv57ZjJFjoO1JviMPdJvTTxmEz/drNv8vE9WatIUxYViZaQsKI+6UXWkr3u", + "IDY9wKvXkL3I8jlXxUIYmTBt2HyZz4Uasp/mItp6+rXnzvXRpPWjpas8lg9+eTH4++Hgz4Of/8e/dauB", + "fExXvI6Wufp2zfH9tV2pDddnaleWgG6pdo2pTEaGO7EdpG/NoDUA/v4X8O7G/FwKrHNyii+PqXAiwQCL", + "/cZBr2Xq5ttHw2Yb59+4tata3sNcakE1abnQxoss3Wwb42MFXPCrd721fFvH0GQ1R1HMiOQnApfZYP2j", + "lPlOM9CxGIfQbe837rC8a0y/ddh0JhtzKPkyURiaVhb8WJ1bMDsC5RpBOwRzWcSwdLvQ2s3/QjY89EuA", + "PvExGm61sIYJB0rWyg+I7CvD9Lu1pGJPDw9racW+aVzYXW7ysISdLvLNjDjki0WvHz1l/7jps+XP1Wtz", + "zqWx8ezc3OhiNvfGY5jEDOOg3sJ1yt/PGHcsE9w69ozlWnpH+DjT1SlXgwxjCNKzqix+tr6ajT/SWdZw", + "GM61wYGYXHsGaI//TvwCG54UWMgjYDOe8DVf0kLQ3Co4JpvOpBLceyDnOvMPLsi3cTQ0xNlRLszIihli", + "GpGDyEdIZKMFZT6UM6XrdeFrmZkqzWtL+mZHuoyFqnFeayd4QrNYp4at9Lm2zrql6LDdVBSnhLhF88qF", + "YWG/fPgnson2CbK3ND32tDbX7an8WnWHaOruanReAbzJtPmK7CWlW/69JdJd8fTvmD8X7pqUP/egkkoX", + "2lZgkykHv8QnBowQgN+fwI3kSZ898Ulrn5AF54n37XjCrriR+FpD5plFnokjdtHj11w69HEazrTTe0/m", + "zuX26OBAUJthohdP9p/7jKCs0txJl4m9/ecXveZsbjTj7TaIcrde+R6YcfoLTDzZgFF3Sj/ZGjGyhlH3", + "m4IwTHrdmkOx8jE7rI/Ow8ntUdHH/d7HmCqtKY0dhZbifMuowurCGt5bMAFbOzAfNNQR2r2nxev3HJ90", + "R/JzPmlNpdeMVP7Z58c80zx9W2RO5pwc4Va9keMDUUNCJ1IryjbMaVYgSHr9BI8Djhnvol7QJZrzNWWo", + "gB8BIr68+1PwI3kX3IO5XogDCuQsH/TswUVxePhVAv3xL7FycXox+DvZZ4ajwc+/Pu0/++abZivNLzIf", + "4bvX2hT/LnPGTTIPKb25VN67qlA5h/IfZdLLctZ7nj+wbw4hne9zMlSHnBLghzwV1g3/abXaryZqmUjF", + "zXLrdTlO1weENh19RQs73MUkUkGEJrCvZSYgx8L6EUs7SqXZTBuoh6EPWjT9NStMC51iSZcGZOTWgc1S", + "TqUP84Z2tXQ3KXdigL2bzGuN8hOWRZbQiXQ+a2GfXfRSc31jBvD/ix7Thl30BuZ6YAbw/4tec0xxM65/", + "x62oJaaCAySPuvWd6GxBDXevtX4QdjyaLJ1ooOczH5KMPw/ZIZtWpiGF7RCNHCLLOd5PK4P1Ax5UztBv", + "ehs6Udh5SyKs12VVV3KEKeORd0c/jg5TIu2Oh7c9yzjUbQ91NyxpfkLxeaIg233FiPDyw6sX5696/d5P", + "H07wv8ev3rzCPz68evfi7avOKUZbFe8foLrLmtdm8/keN5c4iaXeQ/fgfyOCfxVpD+TPQ7mjy5QkPCY1", + "4hlz/EYrvcB4FQ8mePGU0L0rD/lwjcHwTU712ixQ2GkVzxp1YZjKRGT6mu3RayhNiZ5JvZvtuH0fxn1m", + "xIybFF1E0ZlUs7yYZBJz1UkHzkJZJsyg/NJvAHrbvj87Zwdx9gf+p5BpLaa1Cu6FWL4IU1FZIdh4ZS7R", + "rnItjWB2znOBFeFkGuuues86n6+kGr4sbdzgkAwm8UXqn9iQpjt4z1yoLTVqYtHdzd6htVLU/RCPP0rm", + "ME01E6Oghm4Ot6FuL0Mv0p1XgWII/k4Az6DHJmDep2sHaGfUI4IrY786hxTV+2LwTJe+2LDaF46va/fj", + "2DZCoAgZX9NxCwBqW6kHW/bP9Kxb7zd6FvpWonDIGWYLhJOyPToGNMHBp/muUH4QyyYY9Bo9ssK5TKTd", + "wdHT/Rl1C4DBMXEEMcYdD/mNvBJ/k+J65aRLMJ3PO0BaP3QfWFQBtXWZb6nLcaXHKjSpZCzi1wkYVM+n", + "CnWroGK2+p3gfQi9tgDdGd46rGrEehdQZRBjgBTqPMo021YEzNdxO0kzsdobuL9Us27b5OG8oT71TQoA", + "TTCbdYHkrWXrMMKTbDcg1DpAAXNUzD+9GQKEidbSpPveqV6MvGsX7lAnQMd64T3O3mCXGkTK6NCRJQC0", + "N9hhhRfUQM3l1HUHBK3rYJK8S+8kr/fSvNPsNa9Pusxx0aH3u9i4BcYO+1jCatpLxycjnQvVCdQ5n7zH", + "thHEakX+bUB8+xVtp1oUeadC05V8TN3wvakyQH8tReyu2XfvqzzgqoD/2N+lW2VbOnZsYkK7dq2ynt36", + "NnDR3QCU7Lxjv1Xs6dqtgSJ36NrMFncAUPKSHTqt0OoOPWvEscs0V/nsLn2TfPc+6wLiVgd6GwjNivTu", + "naP+vHvXBl25I5AWjWq33ut67G79P4j76X4L9tGiPHfsXZNdXRGuSe515e4r991dulXuLN27rd52OvZs", + "vHbt2PeWQ7faFW7Rv2rl2K17o9WlI4hGneK21XmoPDA8caGpucEsa7By3LTByCsVvTlIrUJy32HXnC/x", + "IaXByyfqNOuTYZmereZV5TmEmJPryqYYu5WHFD2Lr7vw6N9sWA5FBhqedOWCHuvKGVXrCXZ9kWlxuqgO", + "3WRjfstBn/pcbqELDsld7s0pFMAJg1bjtBIT3uoruqODaNszxrvKCwZNoU81/zgZct+eYqH63AnD0GFj", + "WK9U/8z7PoTPT7cdbutj5cppdnJ86PLAXF0h7aJI/VIb0V1Pp1a4RhfFU6OvpPXFOLFZfetKcqwcF1U4", + "XPHl6rOF4BbDlKtpQLExuZ5gNkVziR/IaYcXbq6NdORo5ccP9nZ/RAQgBDtD5KhUWO+3Uy2Q5ge+ckMa", + "j00XVpz6ILyqZ3z9bLpGB4bYm9tHBbZB6BwNuBaEtRsW3qOTK0Yl3dG9NZUUVl7zWPrmoZ1aYc47ObXe", + "3dPTP+iWbp0SA+rdyi42v/FuQ8/SazZgGHP6VmjaFdJO6Hr7qI5UWDfaFqJVyWIQnA22BXf0e9Yk2wBT", + "haDOMFe2JA7Qr6yiaYe89ePVzAhrT6lEzW4udT/Nffjz396yS4XJzSa6cJgpyctjyCeBAzDKOTBk7zT1", + "oc/QVmTTvk+KIC0ToDkmAv3PqoW71tS3qcycMJvTWon1eUgqTmdk4muUc4WVEa4zaV3Nv9mvzIhpYYUt", + "U2Bh7oFrXWQpVd6rYoKNKRBnmqie/Ml9xvybJfX2i8RSddtLwsaVNh3j+8vOgVf1XfqrUKh/vf8h1oxe", + "32R9uZX5nKgUVGxhg0dfhxXpy8a1nELwmw/QuR3htkXoHLdH5kR+/+zrw93jdI5b43OG7GRaKrOFFbaa", + "q7OsKkldgnAzArmAV2W9Z8q3h/2vDvvPvuk/Pfy5eYq4tf4Ja9t5TT1+E2L7FCHg+ISSNOaoB8W81Nwx", + "+w86MlASpWaBYcRKxo2jX9tHx6aljyAVRyzXH7yanGZC2YLqXfKU5xRxq8R1qExVuiAjTuBezgVPp0WG", + "RS/Kb7IW9GwNjDpuDYiKaPPVs8Nu4VHrHtk7pykA3TOtOjBHb/D1YCq7bOeMlBEKeaGvFOr9firw1veI", + "QpDTEUcC6+ZUmHHrRoWNvdbmo7xmZPE2h6khYGor8wnZfjo7M4Zbzy1d5FEhba4YD4kb0TKAbVhZESXM", + "9YmFEkf9WqonrRpnWZisPRjvxw9v2kAjpVJ6KJ2L7WVv/J0FkaJ2jisH9HMntH0jF9J1S5e06kpNAGyz", + "G3y41cdDD8kyCO3L3h0NSQ0E16Bj7xz10q+so+uG7SzIalt1b6td82jebR3vNpoSeBNjIne9Smo1zLEI", + "BwqsJ0RA4ZehC+bfvFAhB1uWVQv9Y09CYNSe2BOPNU/wJ1vnGqhsmUJZhGMvVNDOOLb2SVGa/OLJLf7b", + "luwN9biDHRNKUwk0H1qElkGqeeZ0WeMYprtaWQy3gvxLQgXoifQpTQFiY4oXIvWtqV+B4+IzX6jQNmSv", + "kQCreyktm/McM+VphVp+5Yy4Si8UyXD4JRSYxqXCGpNMW5FSAmo8gQpo6SqAfVbkagrdCzXnKVMa50hh", + "Uo153m7JuCHQZKtnbwQc+Wcz0aykm7mdlWRLfLJvFU0MVMtraSkoecVuUtVDQac77FNbbmDleU4G6c0h", + "kBuMHjFvymKb9QOSn+d4B7OwOd760t0Y0jx+CMEB6Ha5mOgMB8eBhuwV3M9gCGbneGObCMYrbSsp/idL", + "dpNqp3V2ofasEOy/nj7FtSwXIJl8qgmo7+jj/GwMW7nofcDYrYseREbg0zX9+dKZjP56kfmvXn9z0Rte", + "UMwJsT9pKTw5wQnyzGqYZaIXk3Cp9GlnCN7/cCHgAj/haP/jnE8Q7I+W5k28ENhJXqjEFdGiVgcbqpd4", + "WAupCluDDpmtEfALlkknwGucjPV4E4Cp8iQRmHsdc2MznklOhWA9hMFFj2FadLNAkyvyufp4K/UAtiDC", + "CmEiVjRTok6EtSC77i0ElcdqDnap4JKjsIb++r2Zm1k9mvkfDcW5CBI3s2IhVqPIt1IDtyOjdT0WuXkZ", + "Rb0oPQpT6MpyI69kJmai5U7ELSiGDZEjqyC5zycLrQEUZKSAq224gK4tJrporwVm4EaHlNp2LrKYNx0v", + "qoVqfJ1IrptEnDZYOb98ldzj1UCSfQ/Ru+bTIFI1LWC7XU+oq3b0ajjOeGa/flw9sFfqShqt0Lgdw4th", + "rpgbVZvq1g97DZi/FuC7W0xv+wG2h+7ScW4lwzvF7fIq0cUDi+sY9tqkaeObw6u4/rYHh+bSluJGulFz", + "qLlfKoMmGOzaDIHCeEeTb79ujp+qlMSipmxSTKct73IUxtsVGChercA+tp8euBPcjomeYX0Swl4V328r", + "2Fs/MipnUmNqvfNXH972NsOtRnH55j+cvHnT6/dO3p33+r3vfzzdHrzlx96AxB/QTnZbaULll9np+X8P", + "JhQf27oNic+JtXLREtfMCbOQlBA3KxbKbksJ0e+BCr0FFjTZMbcEQu3TRDfs2FnOr1V1wzoVZmsQ3eDG", + "siJiqZyxGDm33C4FX/jWjLPciiLVg7j6vdPz/95fZaxkdkRBFCNSrgRJpBZx2Xxo4B4mAVNXDs4XOKgs", + "Al+tVzOS7HCkayNBs9sPs84Ofl4711vw85OKZxA9F3FmAdomemgsRvz+LB7WyfHmWvRN3cHjSZgBt0D3", + "ImWydHBpELLR6lgUMm1mxGigbDRzngeHnfJmG2buu+3gE9RKao67wu5aEadS0KSwJGXbuVJejPKkYX2v", + "rJMLDFN9efojK9BxKhcmEcrBXb1chsLUOFvE6KsgPoPhI+wVGFKhn0i76Chg2Vu0BXqXMw4V8kOBfpp9", + "jAFvkeCNb0Gn5Zm6WmCxN7L3aNkibZZF7QebSnU7oXPMHQdOdm0kPbKvoB5l+pBYIm5dfeKOd1Is0uoo", + "w62mlAj3561rvpO+CNPxedksgFtfofcIakOSMpETNggORMOO6fDiUozgZRD/LrrT2asQWMyMyI2wQuGK", + "wgn6FC3arBXDvetpRpetEllgFY0qqGh2yHxTn9JatD2QQmOGvk6sITJSAi7BhgEdL3ptJAvzb5AC5GxB", + "PweDIG5BMi/UZb24AGbMiXl4OhIxhanj+d/NDjHR6dKbdBBkqGVFG6A8da9G7jcVaafyVG1pEco6aNG2", + "h3aK9EpabZZHvvQheHyE0X0SdHK4MFjPDsXqSp2vmq9eRhWMKTucrRTrGrITPFA0BaPXJQxYKBowwQyw", + "iE0WH8LoYVhaFngMmZMqxSiwynpZGbsf6/RX6niX5c4r1aFrteRjfeFameQYwV7GpDYiNaBUg2JQT+IQ", + "qJ2qGSNmdqwKhSdHuNwl60VF2dnOr1uzcZNfqjDNWW+mUmF6hi4aUekYGnq16UNbTUuk6q1/baMXbeX3", + "WiLCzvrbihvrrSfblD+6Os+mPS+jbT6I2e7putv8Y77H70uH4Jm3h2zIX9viMfETfL0ToI5OsAQLXsB1", + "PsjEFASBUeJObrE7wGz0PAy70A8bu+3IbvMoZOJBbylXUEeMRmlUL2qwq1Nk5vjoZvPb1PfayF+0wpT5", + "OBbjC10oN2TkDX0l/PeW4ftpnykx47Xv4RyahTjNYEv23r/BjJMO48NjWcPwRd48+F0cf2NZhe72/W1U", + "wZ33mSxrP9SH2p0odgbZ2Rt3rSDGjlxLpqlQW5ILIvzKM5/vtNUX0bdrmTYEI50Ks5DoRmpvN/+Z0UXe", + "bIPDn3zGLMP+WjNk7JqaraFSxbdff72/W2EKfa2EaZ4r/oSPPGG+P7bMt0saL8oolZd7Sy/S9PjpK/vd", + "Ml/+hrRq1Qoru6nhp7ywoprqE7Vgm4sEaD+Nzwg7vkNUH/OxtErTM0Q1qerh4ebX+tXbdmXwxg1x3LjX", + "9idwvb3PEgixSAtaBgD6sDktKhCuvBLbTbiR2j08Fvtmyw4+x62O8LgDd4yYmxq+EM0ewh9K3TY0giOe", + "5kCxV8IYmQobrk1+B/arZ/7scJs9uNE6Gu5ua3ZNvCqtxM358Dang3eMrGR+pXLXZRgfEyr1+cL3rNN5", + "30f9gUCF60vfl2vYp3sjONdDrwXmWMUqWyoU84ww7b2ViqhYVHeKBFzwm0CLJ+qMaK/9+bQcuvp8GEKV", + "Nh/sxrNc8BtM/Sh/ESfq7XftM8CgW+sTVr79riMyrWbuf9ri8w6re1GkUm+ny5e+TCqH5lT9AAM3rmQq", + "9JB9IBq0VesAqEj8SqDDCPbyMS+AL6dFZsUL/21yKVy1AvAeAMGchswKB55zbl4pd7vvscUXKK2FHEpL", + "MxpgydGOVULPnM7vyhq0SQTA2b6TJ4uFSCV3YBsBwiqDSQxPxLTImJ0XDsjMZ3RcYOQBGjyxim6ijSnQ", + "GweXijjS/Fh1hxBfIvlPU/cFxsrvpe5LmdpRXYlM5+IWbpvCd2Xx0chpxkPcC2ayZitpKde1gWgu3Vgh", + "rZ4cFKvP/av1xWGw0Eo7rWQSXesYPbWUM+WJ0dbG4sTo9KGnFaIcMnAeQ+8gyCQ8wJEHJ8c+QKTwMe1g", + "lPbWUi8gpKUyGGR3Wwun3eFRGdYY7Mk/bzzDthwAK1lRKUT4WhoxyMSVyOhbyuRZeq75jKn+5KJ0Q24U", + "sqpqtbL6IXthJtIZbkJyU695W+znM6WWeUGBQaYEjHxrQyLX7elb+015V3HGwgxgaEZow1KdoCuZSINj", + "9djbB//dJzQ9WPnmGOFW3Bv7bD1ra6NjcVcj8pdiii1P8z/P3r+Lltimo8qk9Vu8OZEtHhHBWTu6ev3P", + "pkOhM4W9v6sx2BQqafYCh2Lek2WFCZTvKvQMhNVFwX07AoEFTKUPzAftI5ML2RI/7BoUqB+VvGExgwVd", + "doA1rRSUKDfKa4rQhV1XpEen2P1PZQqvFP7nblfREh7hS+YVNJ6WCyWmNWkLqeJZNkiwxn7ImOCNOpXN", + "rMHH8/UgKXjehTI0tWLxSpcdu3ss9H058I64GzfSF2gDejWoA4yI+pripRaFr7Ojyhdb9HIrk0PzmHyZ", + "LSSqLROR4I0ebjrgZjoRc+njjciAYovFohScoTux9/oGkrkCrjDMSAsEnegCXQq4fwLzElNaNhH+BRdz", + "wbAptw4tWDwEdFEDI3j6HNN1Y7F7rYSHprTDlz9whpgIoVimLepb13xpmX8kxvgMEB0+WtkILLwv3XPG", + "J6EB922gU8pdsFUizVcCspV2ZYwOt+wXYfRwo6BvrqJ0O/3FqygZt25NtWLHWtD8YNWuclINZ7PrjNdc", + "XBEdaR2NHGClpu3OtvW7VaUDy7Mz+lLYxkpSjU5fzed0q5QTwU+5nEdIuVFJPQHy5EakDBc7vFA1Vm8K", + "wfYCji1CspGDNNQU3B8ykFYgfUKQ74XyARvAyGEsihNTTAfbR2W82k6xPfzuL4ewLz4jxv7wQlWj/8UN", + "kiPsEMr6a23SgcUIBnQN8J70ceVSOcMH0IoGtBcKOIXilGwfNRz6OQe+Y0k3pbmRnIW5bDi6tpCnxjrr", + "gIq4ryDivPI619bFEuctxRI05IpXidiMi6fCDJI5B41NGBhDM6n+SdoZxrM/By7r+KUgzRe1HVQqcc/A", + "/RWL5JZIwA6H7D08+JMgsk07wPaszISCCujVfbpQZTPEjX3aqmjzOBw+bcT64I3WtcY8lZ2lErRQ8vYs", + "KmWfpGDypiLGm0sRty/mRF1pyo8GKQwLs+tqgptOUPF14RK9ECPvrdGof8s45qjlsb5zSK6vA7epHt3q", + "Om+VQ0sYo00sbX6LFZGnVpM27ExhqfDKTAxCtX7v2RVqXViqkuSM4GiZBduLdkI5ycHkAIFVCQZbek8+", + "76JYNChLWGkOEpXbYuIfXrxiwZnSasALp/Enx1KRZNyQYoVvgZjETuegbIH+VDiUvdTaK+TlVQ8i5Mg1", + "IgF+QlXRcB97/aZZbPfPr+9yXOLmQ7+8Zb4q3Mn2Pk0iEVgCnUCfLkV0WXoKda58dgu8WlphJITCReV+", + "ewBPpUJfacnd/i4AsnGEOvev1ex0T5/9abfsdBFO3+9L+56f+1rqO2x1t7ttCb5ys71l4fb6zqy+m/B/", + "YTG+qTCoiMKjCaDeJSnIEnyQeeIoUYoRM2mdv6eB39pEAP8DSrzimUxDpgYbbTOsYk8IzpX4IoM13tIO", + "d9DyMODPXjQObD6UF0pph/Pc1UccepecaSLm/EpqjATFJ6D4TPSPty9PGapj/lGUiPXnvVD7cqFTkflC", + "mrnRTic6G0p9UGt+8Ozw2TeDp08Hz745IJvEAcC0/zf8u086FY5GS2Mra6vYssqBr8VkwZO5VCIT3Cio", + "BzuTbl5MYHT4MckP/u9UJi4V0wGMw0uAoEycz4UVfrncCFZErk0BnFRcKGaumiy9+a7JcFYy2GY/tEQr", + "ugMBc/9eqpZmqaBCTvJKtDeSqViQoGhvo3OhftImS9ubGMFT0M3aW8QN8RnK21p+3Iiir43PL7Hrw2tj", + "fMfbcKdEGSlVYgTHu3nTg6hYTAQmGEV4VdedYDJZodntQTobc7vQMJDhJSbGmBpOVYEr9q3NnCCunQbb", + "TP+R++1O/Gzh+7KphsdcW5I7/txEcg9C6x+Q2woj0tZxdyJ1E+HhgMMLRXrXGZnTMbtOuElqQ9kjYE7B", + "Bxnm2kjjdV7bTTxVGfRqTHCjzhknuk1NWcOKkBypRU29JVRMhLtdZ/e5iKrrq69mMx7f6tJFB9btLNbu", + "dx/7RGnd4xdXWdrHteD/V3V+4410ARsR6QG7+qAtgBdxaZcnT1V4y0J0rHQiK3zd5/hjqM8SzqbF8gw/", + "x3QotRFa/LtmYtQ1edXKjHdheFgE+I7cnbLt3AdH35JcpswrQ65hFS7xxPqDCr5efPI8LDuyllLHIsbS", + "tB3XUqX6+s47EpZO4O5hc1ZovJxmPMEaIlYwKBDXZqq3nZNc1gkfd7JzCq1yvK1pRwhw46SNdOJlJvOJ", + "5ia93e1zs02vFs0XSsCGAbffH5rNWx9RplAgh+cWPf8IfUIvCS9OT3r93pUwlqZzOHw6PAwqJM9l76j3", + "1fBw+JUvgIoLOQiZIA+mGZ8Fd8GkwV/wrTAzgSm+sCWxCXEjraP0hML2WZGn3Am2ArQhlySUArVFLgyG", + "LKV9UiWwyH6hnMxw52LrY3GFOMYuevi0C1rDRQ+z92dSCdQDJqifxMRbVKsdZhaSnqIaAGdIHmQpeoy6", + "ZB5GeY3rp6MQ1n2n0yUZ0FBhjq96XjGC+tfwnY2ieEXtDbu5wobCkmgPnWYL3FZftfkfF73B4FJqe0m5", + "iAaDVFoQFoNZXlz0ft6/fRoemlAzWpXtvEgK+WZxnGeHhw2uzTh/Om+6ZcWl+cNerSD/sd/7+vCwjcLj", + "iAff8UCTlMHwY7/3TZd+WDJH8cz3wpr3iwU3S7DiEV7GKWa8UMncHwJM3s+51+/dDOKb6qD0oSj9HABw", + "id+YJFmK7XRTWGFK+REnImDSuZE25lsunQRjxOCEx5+x7nr/Qm0lKLY7PV2oXQnqpTCOS8XCLrAFV3xG", + "F+xL7x+jpoaHksYez1ms7X8mHHAP279QmHx5YATZLgNEWkeEHxAV5eTL49ODkEBeq3285k/gXV2kFwqN", + "HmEvt9L+aTjG25N/dzNkl8Mfsh9CCjj/Ez4WXKg9n2jMv8q81PpSCuv38aJHHr1XPCv8w04lkzd9O7xQ", + "Z0KwcB1DTBblTIYzrWeZiIh9QLpSzIUcvqctFZRoDdb/HbcyeVG4+fsrYb53Ln+FyTnSsAeNE0ZVBRrb", + "H/OZ4amwsZcXu2/5zcvoV2RPfW03SOrb753qvMgtJA65FulrbX40oEr8oxfW5mc3TPSi9/PH++J8AVe+", + "WOa3inawlrvwwCIHB6qBCERNzFDbptcUbEolyQ1baCNY7MZ+kTnjJpnLKz8hceMMGHLdXCxYoVJhLtTB", + "XC/EATGXg3LIg4vi8PCrBIgE/4IiExg1BQkjVE7ZfMrm5O0Hxjk8QVlx6wUSvFBwXQi+vX5fgPWFPUTv", + "iwypSxpmgMUuRBAnBv3+LPmgAfVMC+R9CAXZJvEURjvjJ0PuPZTLzutUOWp19DBBIylQMMvqoJQBHN3g", + "LtSrcnX+toqo3cBlrJNZ1pDfO0gMmHMQESBqeCqVsHYn1YpOupzTRs5KgQfcuANAr0GwgpXMddOdII5B", + "Q74NsLoR+NOmHAZxIwm1gxk54MtnpmYkoeqEavTUgO13p+gBV+kg8Ie7U3e/gbRZV8ruXygrXCS6cgQi", + "P6lucf2IuH+hPuH1Y5VGXqj0Q+TBXzC19BvEIW1x3El8UOPp8rdASluoh+2BT53M7X5VSsYldiYu79Zz", + "MAnXhGYiehUymSqGuRtESsln9TR6BjHyw7YUUgImpEzA5T8kpfa/ekEEUwCNuHy0ypZefEEUdEhScpNk", + "BYTqMdCgMT+s0j6wDG2/LOKuZQlX5C6VCX4lUPaEoEvrdG6DPxNlnxaw9TFVfDgaJmNZEvJkpEX5/Nn4", + "picRTwqLgTUglJI5l0hUqaAcaiAoS5dETI9FZZNgtEuxRINL2K4yuXjOlwDFO7kzowuVDpyROcu4Eyqh", + "LC5YOgZmeSXTgmceTBMhf4d3CX86L4IL/G1vEhudcNdHign4bqnPIsiQQPc3pLZGQmBIMY0EUMXpdkIM", + "0Qp1Okygnu8I0aVKjfWTxaK/6N74QAdaDnDXc3xLiE9UFOn+sx7hmUTHbzhDIkvc8zDHFqfHXQ+RrKoH", + "IE7az/GD4OnLigW2aTvv6zxpEK/k03GuGABCG+aHRFm4Rnl33n5YNLnJRheQBmP0LfcbbdztG143sj8Q", + "8TRb8m9LQGi9DzUonS436bfDE3+ih4XgOnwfB0p1J1vPMSYGeaAjXEs80v307mX8SnW2JkrFqTGonjqR", + "mXTLaPT5zaDE9zL1qdj1db2S6E54AG7868JwNRhEWLLMYPqcwNQnhXNa9aMrRrYszQgc5mUcedFjwJ2i", + "OpIYhY7znckrQQUavX6dCW4FOXXR19IyHpXgf9z02fLnalacnEvTeL86DqEJD4S7Ef5dOQ8A+o2IbJxK", + "WcSVjokzn7VlJ5SCp3iEMsp9nd12NvNX4WoVeR9SRDeX/m2mfnxqp62Ii7iPbf6rcLXXfBqCSDeOdC8a", + "ElDbNi03lg5+IEJZK018Nx3XbxOs7PMSy9tQEbd2fEEyx8RDJa+y93KkuRHWQqazLaxa2JWJYGTVlMpG", + "Rce5mBaJnpzK/FyVgj0XqqkMjy9BheswYi4U2Q/W6/30mRXiQrk51b5Zr9nDuCtfpGbSDadGiFTYS6fz", + "oTazgxv4B90UD26ePqU/8oxLdUDAUjEdzklk+DjpuVba2GosnvdxCuu1rLA+6U/it8JmQuTW2yPpmHTa", + "+Hjoi0g9EL2s1qi6LbnggSK2/JY0FlxdzeqGeHkflFFJNtDK7M75pShzMT6UWruWUvKjP8SNQg3DfQ9y", + "SoFajhTjYif4otXgQbQmu8oJUAzxZz3xmICIlQcUnA/vet46y9rZIGXTZFc+4yRlND7QwB1CFkz4zlUU", + "0Qqzrqu0NYtprZaa11Vr6SzJ/CoVvBLA0MzJ5NKyPaWdT7Xqk2+VKBYjNzBr0BU3y+fMFWjvXGB4bDWB", + "MgbCYnKlcin09u/XyjAXJ00j+J30awmgfRwnPsHUjMN7EQbq6+UA3uMb7XEUARoytgRmOg4Bv2TpGQyM", + "yAV37B0bDCiS9pDRgw7dGvDvkMBk5eYZklo+EH1W0qzelr969PqNGNtoMqU6QsfDHeP3q1GGhB0t7NWH", + "2T/Qwa1G8d/J2EOh478ZwQhrI+POnY7JJwBp54plRcjw+sfgH8oxsoyexUDqIdNXPWWDVCi+Q5ykSEPt", + "/eGFOjV6KjNgnkorscjdsuLMFb/yD7PeyyM+IFp6y47Ph9bp/ABnRWnLLhQVLCgTyg2ZrwCOWeNoztAS", + "XJfpKz81zDu4xKBATFRwocZx5BG8A47Q+VvMln/JMbZwlKT5GPOHOQeTxq7gdBbe3TEzCzDIFb8Sn+Kj", + "Wss2p01p3BNtVrZlyF5Fl42Bd9moDgHuRsenF6oyjSnFhmN4fYbR+zBx2MrwXAlzqdbyDQeGOQ7+VQiz", + "BBzgC+GEYdJeqBDAP1kynaXCkBphQ94RIxz38Mr8cDRUEGPDCxUxbRwPZcxSaXMvQTibCOsGYjrVpubY", + "Qk4vdawj65B3Ril310cqlwFAlBbqO26IgKyP/6uWtxyHy8aY8ukwrnD9ji11wVJ9oZR2TAnIt/PCsUxw", + "63A7/VUBPeGgOYZ9T+KZx2SKqwlorBO59QWV4SIkLb3uHlUQoTzjPu4RWsw8oaAg9lgU3Cjo7GIyNMoE", + "c6Gc4cqGK80Rk1PG8VnTlN6TMBvEGRiVm0wKU+GCDJNDiulUJC5kMFxwpHm6w1E+jkSUTlAYmf7s5sa/", + "9eZG53zGHboJniI1URSfBsXDCsA0J9i4dNT49zElZTvwCx9TPWiir5iX1GMYPNXOZgJU3wtFO0ucK/Kl", + "OtNq9P8MPOZlaIRe8Z4CLEYQtTg6VOk/8AyPRhqzL7Oxn+g4FLoFjYsVCm6h3kl0jVoQfyOvApbu37pL", + "tBiycZU1eb5kiTFVuYE2TGRyJidZs0cDbPUU97eRVVAJBa9qYuxX76iHPKIXQtN6LbwTE74FOV5WCCxd", + "C2PFpfhNuaSmDAM/38kTZiXIDI5cjALFNTgwnb8e/Mmnl6s75LIFz9n/+V//m5inFQuunEywsOrpi/OX", + "37N1l/DmOqi+1aglPqAyA3JTZeNfL8h3/6J3VA0P+PnjuOOESKg0zcYTW5dpLIBjo4bfbLGAn70k9nrR", + "mO1h7YUDqrxwIFwyDOlfqchxyDazTtaUb4f4HvyMSXRjDjTPd6KWUKYhrfvilrmGmVaJCPc8X46yoaxR", + "1YG1jfjBEwifHMLsMR4cvF+uRJVWgU78Msq0SRsd6/Zr9YXrqBsCQhtL4Q+pFv6zb75pzkvzi8xHIDi6", + "mRLqYSOxr6f8poCq1coIXk6NvJxa303HzfAX64Igq3I7Uigsbu+45hKIERQ+aScNEJ7P7ZB5IRPdhyl3", + "vdHaMaGckVVveN8Z/rEHofZwuAlbkUH/PeSh5D/Oxt53/eA0Jp2w431KxzqGfctHJUmMKxXy6bi9h1VY", + "LDrn+sLklmWCGlwbnufCsMp8ahnR2o6r34uaVQMZf3gTH4u9ciVWVCuxRVMKilKfZZiMBIgq4URrjj07", + "/PpPVHutX5IeHGCCESykKiKP8AdAs5hkoqVWbn0vN1xdyuxzYQfxqbDsS4mQjczJ+WEFJyNW7IHmEkuM", + "+HBJIFXYt/1ORXh/Uw/WdY2Z+OXz0tgfsSDm/6ldf4d3uf9+ffjn7f1ggplM1m7N9+N8s6rThVt26z6J", + "cHUiXh4DlVKWz7kVKxf0F3Q/xstLeTdGk5i/M9e1/jwr7Nre0+tmJ5/RinyOwWUNUUxe7j7UY8S6aP/U", + "OO9HDxlH14/zR++V4TesfgyfDafvHLLTvJyOyDO1B4kRUFM41tdHRCqa3ByxYawI8lC+jvVRdkKmp5sK", + "mNA6f0OWPFop4xgunVa2tevJUX2ODid3jA0f+uRolFPu5nd2dYmHRktM70adX2/v90671+DgfY8+Mjhz", + "xu9yskEf33Cor0nt/m2fJ0zy93CU/o7T+RR9JR2g0NEvEkuHzIRrKi7kCoPJG/9+csriraVy2wmXmFjs", + "oSxYFdBruO7a5sc/lubvMt9muop1vSJE0padjrcSUGLCotpsPt4JrI4lVYPP1lJgP++kJPh9vdM7OOx6", + "WGOsmYKoV93gLxFz/WFV2RDjAdH8km+N0dalHVA63OP3HDeVy/wiuJygTg2w9jdi/oXagPrs79alTE+n", + "wlhm5UxhcjLMMexTs4cBvS5+oVJR/Qr+5oZusxCESMYjSEEmrmAmE+FWoSChNbuUVugO9uhLIbz+WiKS", + "ynLRL2rIvpezuTD0yYYE+MwuMMNtaVqBtLKQOJqBa6iAV54BnYR1R+x/wmkTCPa0z3wuVDhYqA31P786", + "PBx8c3jI3n53YPehozcR1zt+1WcTnnGViJR6HuAJsL3/+fSbSl86uHrX/+j7r1no8s3h4E+1TmvTfNrH", + "b2OPZ4eDr2OPlhOpYMsIwbQYvsNfpeHbb1WvX/mNpox/WNdqBe/ONz313olxnq/Y6P4gzHPFNLkDA0Xz", + "UkjQ5BlnnXmAroSluLtyDeQVfuMBPNOmrhT8FqT0bppn3IMGlIPfmFSErHe+uH8WxAK/7soKGJ+QA8Da", + "6e2AWJm0Du8LthWz3kiLhXDtLQXSl4lL5aobkKm8aGaUTuMLxCZYIL1TUKj3bbAHvORbL5rgwH5anvFD", + "+P3fxyUT4FSMO1/gSeIK8IEf3wXvxhCM4Gk0IDTyA4j89OaDbuwApxNUU4D/W+EIOnHCDag60511GhQw", + "jbG2Xxg6wfmy2hPoDuhjBYmTUaW0dyuHWK+w/nCBoC2l3G+dqKsEFcI2v8CjPhNunVlUq7IfYNV3O5f5", + "DjhAL9PtLqIvKI14+YDts4xoU3pjkWDy0U5GLLTnIxSSPGxJdxPUlHvz6omaUYvrRCqsG22pdw9tpPKP", + "dp4L+iSuXvXuUum+37utl4W3PpZT3e5m0QDhtuk9nzabdSvpr75wdtmQ6Gfq0XA3ggmm3o35rziamchT", + "s5LFTnq3vuCcsGLwWsHANvIha++9Ec+uxFFyIKfjymAl0btFd6OUe/JJ2kQxt0T9v8u8nvfNL/N3Qwa8", + "mottBUVvQRHe2LSFJHY1FbdRzoXaTjrbTcY1C/GFWjERt+dq8zbfeyO/Vg+587mIWxZ2K4ihDj5hn42s", + "mz242qoUvuvuxOUz4Pu5wZz3sK4loNNggG0GZb/94W7FQ0tr3wMwlBd+D3/nTGUVXW/NWK5XE+St3Egc", + "N+61/QlbPdBdpDLE7l4qt8wYj8tuLBzxo5JQ8ayhTERJt9d+Ozp5K64WpHbJnN132uLPhI60mKpZ3ycO", + "VLOd9D3cz4Nfw6F8pFPJBOW8WsVInZcIuWJwQSOKt5p4G0o86U12lO1mk6+baovTUZIz/Bd+lLCthNfo", + "QX0rU9nqMR6UNcobDWdnaGh6bV9deaPKJzvNVSOYEzeOZtto/dr2xnKGl3BcRmN6gLNXoeS5nlZu7T6a", + "u9fvzQVPcdW/9v5rcHb2auAT2g3OG+v1vxWp5L6Y8ZQBeKxHRuDY3ioj3K+9l4a30dVWTU+hH79ERMaN", + "XttlnyErsO7OOG3kNgcyzBPXxQB8XFEC+Zox+BP6I7wvK4Jngi10KtieThzPGPXpMyx88O3XX+8PWbUu", + "+bdff902zQUVH26c1j8OB//x869f9b9uCpnZHHV2j+bpW1pmYpbCL11Yo4kN5HPwl93FDS/TM3tQbn3z", + "w6ieWSK/Fl6+gjK+Uusm3A7MyhNBmUa8sUBy8zBUprHZZ6RWvK9SmHMVEWJwu8TaclNGc2fShmxtG0i3", + "XTLtMk5l7c2jlQ1Gvk5Z77NJxTd61lEcAmL9piVgk3SBSVN89dnZq64k5DNgH4iZEdb6ZANbHf8wiBJ7", + "hDDZ4M1ndMbyjCvBMm5dtagFhn/7iJkhexH+ZEo7VO/m3LKJEKrax4hcG2fZeCozJ4xIjxhWhWlMF/NX", + "4d7Ral7h1E5pLQ/oftA03IYsgrUda0kH6HfliV1p3eE4+73G+vXnIsvoxP72FoISKaG7s+tDScuMACRL", + "fF10rhgHNpXJkCcifgQIIptCn1hUWRcOEwfQWP2yyHJlNVC7hyIFpWWpyOREGCq7orRjFrZpLow4CoGa", + "N0toCB+QC/mxsCYlJj0gWJxRgjeW6HwZ/KWq5i2asqpMjyWY5Q6hpkZOfYpkCRlMKJvT396ygjLoSUvI", + "OC2sKCP0MYzzGqEYXTjBnOHTqUwYx3Ty9DsuYcjOdcqX9I1fDqQRSfRigUkPzrEu5ZCE4HcUSfaSKvNC", + "HgRjMFv9GIGdYfKmMdPGf/HdMufWgqfIOOTmOM348tpA0DUTN7mGVXDLxj5GbajEtYe+96vf5I/74yMy", + "wVZoDQTRuHISXNlrYSyTlE2E0ppg3WCf9kEq6wS8s0xBs73mBk16EsNPQ2ge7u9JLHvdL5NgUa6RdU6C", + "Sa5iddXAN5CbOFbkCAB+FpjUSlWR1DKeUrlO8r3AjJF00pyZQlGBjsCUzstSWdKWJXywFoJ0zBbmikoT", + "xUwJHtViPgyoweDl3HPGA67QwSdYcziABYDGs1NwiDUcCdPNufJsj+68kb9GZJsIlmnrmljgadHKAu/f", + "RtbK/T5dWGBHBvyqJqo8rn3eVF13Z/cgvfNI5we+fEOHsiJmIp3hZlnlEolOBXmYTY2woRiET6GCAeR8", + "xgHLa7VpPQFdKOCwOuHZXFt39Odnz54RLSFUkOscLylAhU9yPhNP+uyJhwt/enBPiBU8oRLgTy7UFTcS", + "IsXtMHw5BKrG+jF7+08i+VSmNLgGDu9rkWMaOqt4buea+MyFCoCkutKXAkDtQbMPYtqnKif/T5/9ypxc", + "CF24M5H8P+zj/hNGrS2VSeGJWykVPDe6mM19ahxIkvTEMrtUydxopQsb5vPi9GQY/g6cIeZtAiDXjPvf", + "qwiHvBbS3HBX2Jc6FX3c2D7OKvHET3s30enSp5ygEzDCFllkU3ge5dFK67cQisP4VE4BfZFLv7oSZol5", + "eOCoyQVReQDaHIFFTlAJl5S906kY/tMG7kcCQjrL9LUKpwPvbKGS35C9xPwz+PYED3WoIXnQlCgp0cpn", + "R86Wz306IF3JYBVaQ2PAQUGp7uDwQMH0h9hnieF2jmm2fHFIUslZpnUeMgZFWKkWFnURjumPLhRVwIkz", + "G7IXmD6BB/g4n9j9Uojc4rrDRmB4h9H+24adQPGCR8MnXKValXIwDOFFBwAHZeUqxM8EgR7mdKFwrQyt", + "SuuLpWwqWEIODxU3k5fb7gvURS4QKksDLtBphZRbT0KXJz6lVX0X4PKXsif+RvskqCU8u+ZLS+XtrFcC", + "L1Q8Tw73VotZJJ+USHYRLsYXvSdDdlLPOBaa9T1jAZyekPalGVc+RRrVFyepSpuLyohAcOTXNPB1tj1D", + "xsQzVH0IhptqI2Zeq+MTSmFzoaIfVL1WN+W50LlQvgyWiPeYkEDMzyiPfUJxpAtlRSZQ//Y/SMsKFZ+6", + "hyXjDHOrq4t0oPras8UA7UJhoXh2MvXjD2hH0N5HAU+JsEGr82XS6c2kX+EY9ZRRsL+1UoWUECXw86Gf", + "KfJqp/1cMFs0TTWkaxM3IP+ly5aIaaccqWbpa08BLkF3wDNkYoC5KKoIywIKEMOjglPYxi9GiWtseaFI", + "vQY6HLJXPJmvAKBd43TCJ85WYcFpWg8Mll8iA1vJgVclcFilF2rr2IkHBQC0AhI1S5+jjeaOIWrSYcpC", + "i8MP2fscC88xKFIX2RQdEk6hgll6SpzaHw7h0nOw3VTnGg4CRLTSvlX/QnmspUVrRXgTyvRLy5JMW5Gu", + "cZNyjzw3VmnE/Cewqz5Kny4WT6AKsN955H4JV7EwJZwOHb/jE1tK2BL7cVeD5vCcRRdIf6OL+We4a9h8", + "xLMXkW5h5Dm/Qvmx0NaxP62ghn3eyHVKYZHoQjkQOrATF6qirQfDppcjQWf5+vDPhKBVvmmf+0BqZBQk", + "9o9fvXl1/oqtq3ra2INfYZofh+xdfbY+i4+LF55QJDkpExkT34X7Coj253S/AoSbF85iPCKe7xJhRTjE", + "paQ/FsKDposInawoNcyXZIl/iHvI2lifKUdJwzxA+WpOPhMVsXt9pf3z/eV8iasIRPpGLqRrTadzHjjz", + "CtaXtDIRS03ow3JhBoH2MgB7r+XiyqljruAznKVXsNYvMR2T6jaRX6uZ9I0k+1ADx0CZ4rN5QoMVPhMT", + "mUyW7PT92XkD3Yt1x1AYb/3A7EOaPpvwwzbiOkitcoH3FxVVs3GVK77tYXpeWvfyWHkjwMqWVYb9JKr5", + "gfdHo5JGboopVr0moryRzFLtSdT2Il5ccxuSaAzZdzG58epoNQHMnNak9cDUUYpNxIUyorCQ8qsunf19", + "jAUliHSZOD73qm0wfq4hrjcOk4tQxc7nRcNR7c5T5mPsM+5l4i4bw2r7slJC9l+FKLwsQo3pQtHVEBRE", + "rfzC4rGceG1YaVgf3rWe4PaNHJ88CaoP5bqluTVG/VO6lDWk7+Qfgv/Z9KC4G6GBsG8M6IdVNSBM/bUc", + "xm57Lo/7stO7ZCe/pFdRZfryM8U0cJ6ujIewErlOu3/jKbWCLXuw8jJxhM+kLNVm0KYmlUWFjW/zm6hG", + "G55tKia+rLvJ1qOAzfm12ooDZ9jqQZEAh/i8WOCn0IYG+LNIf2Onz+90/L/6P9Al8VJm2VZU+EFmWSdx", + "U0LeKHSie1JRYMtbe0Dd6shhNb/Jgp/vf/giQ0SBHcmZ4hklnA+eNrfHScq5vRUrP1Cz3w1e0noeMfP+", + "4tRhP0FpOv/vwYTqENwHetJrWKvXXxAs1OpTY+cDS0taVJOg9L98kUlzwt3RhjO7C3KksoNuha1+N5wL", + "l/OZ9TiaQpse993SCRs8l79YZ+VSvjLrMehOmKoLt82HudxecErY5Mz8mXjaHZxy49qgW0f33LD/unB5", + "4cgSJKeCKoM9xq88WPxKBe914Xb2NTYiwcqas4PSwtrMocnU8iG0f9AcyHGU7XVaV52hfcfPZ9P6TMnp", + "oyUsN+JK4v2X0eGKlEGdUb1TGEcFL3xWxlZOGNI2VlFjY3jTSRkyG/NXhmMLnqROx/yr/eCEQj6jlamh", + "CdoXL9IL6Vx4AC+L363ClTbCbS+jhRy3OUCJD355Mfj74eDPg5//x7/dii/jWRws8q/vnDirRHZ/sjXu", + "Gn8dvJZK2rlIBy+aXNHlQljHFzmcRXToNRXQ1HnI/lpww5UTdAwTwT68fvnVV1/9ebg5cqU2lTN6NLjV", + "TPyDw20nAlN5dvhsE8+Q1js7SCzrh96ffZZnglvBnFnSWyW9cNS3+wNSE3p8NbxRFbMZZWeFqojoQAYj", + "kHu8ZRMx1QYW6tClvLaImC3haUO2hI9fcIpXKohrkUTRmfB+mFUmrWtlVPBESYct7v4QG/NabZJmYTTK", + "rbqWLGqNot/4Kv0mzvLenmbxHbSy+B03dsHNZbsfM63TRv8vX/tSEa77LCFcBW+oCBbreE6lwspWhBPc", + "XAoT6nT/k9zuZEgv45XLt6dfg0xI5jx3woQ+62/wb7m5fGiFpTbGA6al2GEObXe9t7hPkdD+MKrRizSN", + "mEm44gOppBoENl/i5O60gYJpS2qUh0bD+iAb1eanm0SgF7JfYHUm3AHGmU2MEKrKY96D9yHVUg3LzIVh", + "J8fePcNHDghD5fO8t/pt8EDnm9BA5w+PBZUxbn938n4inzcax+m8rgB2P5A82x5y85/8ins3NHRcDpFl", + "ysWwCe/FzT68On0zZGexYjeV9p2LLD8C15zxePxPe6Fg2CF8ubf/nLX97+CAoTReCDfXaa3XRS/JZHJ5", + "0WvqfnDAzuApyRVG9GN14n646MSi7Vgasw51LbgGRsBZo8PtFZcZVs72U4IlFYeHXyX/12DAvnv115N3", + "7K+v3r368OL81THuBHv76vz798fszcnZORsMsLGAIg7w4xEbx7HHff8BU2PET2Ih3QkE5Iyh03dliT5n", + "dHbExlBFuc/GqeFSUcIX+Aia82tt8Av4PNNO/2gy+BM8iUHBgr8pqElOZCbd8syHGcEPuLfwB6hg5xDD", + "2ceoyuxE5QV+yA08gYol/G0TozMEnvAc9vwMmUoAhhFPfIIT89Ew53yCHa+lS+b+gxLX/i904vF/C2UL", + "Iz4Invkv5BTuyhRuGpb6trroN5qn1T3IMNa28o0PuTtJM9zmf2LnIiZ2hU9z5/K/Cod7TuFMR2y8GsA1", + "7sfvSnSpfMnT9GVhnV6stgYIzb+QK1r527iKXq/eHXdDrgvl8WTg8SRgK+qJPOIwRqVSRqJsiSShVQyx", + "HZNfHoa1TI3+RagL1RSilmRSUOX2EjC3YUW+JLrvOPRf9n3tWOCeCS72QmGoG0/TPkY6E4XSdoTZD9eP", + "YG8fS/EnYMezGC1X8bQf//XVOTugLgfO7zROZz2Cbj8Uax+Tz6rvRS0gVv+lXiy0YoA4U0grXOVlHC+q", + "nsb2Lnqh3qxnMMNEL4iLUMMKnu7Bt4lGh14jBPsLoyaNhFlpnEl1yf6CfYZKp8IOp1Kle/An+wuhAYMP", + "Q6Mzwf7yl7+wix70uegx+PXZt/QvtUHXS2rzVpta9YrhcEgzl1O2938BhH0f5qfENUNBtEeQ0Vl/Cvpr", + "danIR/aw3/MLFWaPCRLDUtdYxt5F78At8gMMx8nV7KLXR5e/Pnv67eFhCbvOHvd+BagfK7z6XOcDqo4z", + "kQpQzQeyLRVf+DACufDxVAudFpmIAdOsUE5ieXtBMT5kNSZJwSl4H2I/YvWhK54VvjqwnCltwHlVYDF9", + "uoJRWHrJ3veGw+H+uA983GoQQR7FMcRvhfFT2yE7lUqJFBi4S+bou+eJq/QFHiTaiDGDYvl8RvO5UCVZ", + "esoIW8DGtP69/UAXSZoDJeRGX2HsSaEq2RSOxRXSnEfO6GdrYLMWIkTeZfwX6bmJxNDJMhawElo+ZB+E", + "Fa6P33nv2H6Md/RBgH32/v3bvj8ACtIPlW5TmJdeUkSideSpn4Ycefjtyx9Pjp/RZo5kCjQcnfHopKww", + "kopEA6uTlgmV+qv4ytJXo07LLAwxVgqyRcAN9opnwl/mTQGUihjoL+TVgMo1F0yA/OL0xD5nEmcABGW5", + "Sif6ZmOEiuf1H0CPexg9uTJC7cpeVxWx0r4fHsJ4Q71yDI8g4+Of2Fv5XbDg0e5iGlu6eJx7FDECDBmW", + "cbh+2jnPRMpSLoD9BvD4boOma/z+ifWglbjOpBKDVIRRfY8BfE1ToRpJSqsBIlFBRpavDw+HvU/54Fzb", + "1G5RNns+zIZhnGus8uxpYv9Ot9CnX31er8T6BaMSFYqKTkfnZJvwTDj9izAa6k4D02u/2pwa/zDqs6lg", + "Sg2AgB78mgGUPlx2uUkz3PUp+/78/DQmSSFXewwCD07/gL4YkiwtgLwG6/g11JmTjk1Ewgsr2I9KXho+", + "dfTrSlwbtMWMemoZkd0zj7+9bXTrp2WewcrP9d+F0b0uzuzYfuD0AFbJ/F6l93KiZWKUbBkg476KsKuV", + "LepsN6gerVCbT/aDsE4bYZkCPSZjtrbYcB2szKJPCVfKTC/16dI7BoUXppmgI6e+8eHlb2+Z0r6cIFNC", + "pNa/tsxFloKqcykaebi6++kJ9UCHR4DvfnaxSaesXP6KyGKveunwIQuNvz78GsOBYzsZIlmpebPU/Ktw", + "53E+D8jf4yDg0tboDXnevMDbGozXk3G1wO+WiCsksF5hmtw4iayKqtHQkbUeFdoS/QhS2EqcPLMicvqK", + "0kDBuqTGpc/DM3UVhBGOUz9pIq5Y4SBK3O6EHOyMevnY9Th1wPmwK4D2nr584jaWZIIbG5I8NSPmn4kx", + "jK3TBq4xHsQYZkFQsM5rmXUJw60xz0xmBE+XZSprgvB8fTyAlYkpXFb8fjXmU4JzrCP8gymIcZiXOM9P", + "7cJ3a4r7fJWVPpPx/0dc7x0ZRFOmvjPhtnCEQCPPDp/W6fOaE4FWHHJKWn0esw48OzyEfmhGsUDCmUgC", + "NejcDaQ6Ws1aRsQH0Kt8ZI+XyRNwHLqkh1yOVrgQa4g3UM8jAlsIGtN+Kzt4HtOvyChTvbqwiSf9JnlI", + "4T4fB/nNc4z7fJq+/YSscF/iK+Td1JSacllJi998LThR3q6gfEKp6ChRToE8dPtsFlIYVLPSrEy0yswO", + "y1Qo3EIYk0iZUFci07koLwl+WMt4Gvzvnh1+3fB7SGDJ9pQOwwefPG3Ktk9syZKkLbkSsqyvDw8Z2SZl", + "yn3yI7QUNNP4JJO21BTIj/mB3P1pLBziM7n7l+v0h9QYvIvHkdNs0aQbTjThBoVI7bwtLEUlYkhcoSmE", + "HAHyJBE5olfhypPejGvPSTaGqQxvT+s1+vMn0YEkdifHtYiA9aQalnF6Ha47x5djE0n7XFf48IcCzic0", + "W7CxTI/Yr1b86+PFhQJn9yP2azikAWAEfH9xocagKdDpMIUFm8g26Q2yg4VW2mklEzTNhlcAnhht7Qqj", + "9SZmyI36hls3wDMdnBz7lKxqGTUYVibIA+JEOoRpYyj4IpiMaNlDdowJ9mBSFAVJKDHjuQ3XpLFMx5Qa", + "8SikwTIiERLSGuFv0lJdQMzA+pTxuU9w4eaUy3pgBSgUEp5HaWfZtTDASsjMjSuAxpMC0hkO2Ut827PM", + "zjEljjOYNm0NGrofCycSh/MdsteYe69cvg261cqWUQbaOGx5m/NHRU+SeFkUlOwDZ/0c/ZvZ+P/B55jl", + "X3iWjanKVg2czlJhnb8wxiyCPvEHmZuvJez3nOci5KKbCSUMvI3UOeF4yF5rEzVGv3vCX0897VKqaMqf", + "yfagOaWeFMaywvoCMDopFkJBL3xcH+/3a+x8DFg8RpzTZhGLLC5CCZmx15T+Had1jI2JqfVjqjwYl4A3", + "cXqKhKgvb2vNdTBRLwTjmKTR50Gv0dOQvcf3LsOsUCk7bDiPcLy5tpIuA91oEjOe1AgLn9uIjASQmfFP", + "2H4o7jNrD9k5vxQW+iUixYHw4WBMeDMmwYuv4DSwsJjO2WpkSGCaHRjh0bgcLhMccLKWQWZAIOGE5tI6", + "bZa09egvT57PpcN8jQh2K2SAmQXHuyD8kH2AWRFJw2urZdyxp4fPvn6OHSIy8wonAMKzhZnyRNBzCSUS", + "RGKfGcFdyPP8tLLMlbAA2pHmGKMs6/18m2iAO0RpdZL4bzoIoy+uqsLqCuBEKQX74EwoxyIH6CTgvWcE", + "uW0M0K1iq1mXLs8Vv0HqTemNY5pdZL2od58c99EB1eY8EX1ifsLQI3VMi7wQjsM+NicTIx8a8lHBZ+uH", + "tPWuDbYpCD7UUvB7UMn0bIf358DeAL3DI1q/rZR29AnGI0nZBI4EsLlykpRBrPwc/EXBkSMEzmsDZQP8", + "pyFkSi1/QxjhtTMoPdCZXUleeSAcVkCsdIKGUJYAE2XD8IXFig9sUnlM9H32rBBsjP6P433v7ERVYRaF", + "dUyAkOEULUvPxWKRO7BPG768UHoK3oRSyYp+8+OHNwFXbb+OpGyv9HjiiulQKcr7hxAi7fsM32E100KR", + "+kSzoz2PBQG4096PZcje+lExMzwarV30fgkahyXgimJrUJm2VUcsXbiBng5iAjRq8ZxhJtOof+CqpPVF", + "GUA9S4RPaX2hIB+ZbRg6FEhAS5lUrMEzi9xJtDesMK0EDkXeYHQjgXb9kF4UGAawCYScpvi55p1zJtwF", + "ldoYgdCngmMRg31pFmjuuVPMNEsrLHMbUvtyt59fqPAsoY23xPE0De5nIb80Qad6rx6yVgLuMuFjmfyc", + "SgNLVTRezV8EP8JVbrbLzdz7oiHrS9J8ROQDn6qZLqgIqnRZJKVev4faFrSMu9E76lV820BcIeH0jnr/", + "+PVCMXYpVXrELmCgi14fvkH8OWK/FiYb+QBBe8T+0egrd/DvF72fP2I32NIjhjAZHgZANYKnI1gDTtQP", + "wFiFY0ErXEzI+Ftb0jB2wXT5Z0h7R+xXkKbQk6qMgtsZT1NJhHoay5z6ZyCaH/3r6fWIEiqxvRHC7bNf", + "cdXCftyPTnl7fi04oSPvAvdPu7dXNglEM8Q2ffYr5bI+SY88c7H/OPx56HQ+oh8gCn+fZgP/+fjzBZba", + "6gHn3H7MFTZ7p6MGAA911riSbocNTWll93jKzLPpDTDySs9f/eHGZqSfXcCpxCJkuCF+TT9vQqYq7njA", + "dQypnvrHrjkZm3jKZwrH2lF5KtUNkoOxSgT2QUbKpbJkN0AeLq6zJbWtaFlfmKEcFLDbqXQtOvvBr2sF", + "gVd1d/C9poT/VaVusqwp6kP2QlUkWXx7qsQEx2curhKRURx5XcJ9qLi9l4jQKUHIlsQglWD0xI0gHv1n", + "+Odw8Oeff3321cduMekNltwKHob8scPPmqMKpsB4A47shiLk8L7pDeUKy8hQjlaeOLLf1orJxBrfZBjT", + "OhsZMR2yd1oNwKZiiwmYilKRZBy6XJExl0IAQkGXaGoS0vh6MGSk0XmRcaouQZl3UYZKNRshXHojoQxM", + "Q/aeEvAD3AsF7Xy5WifMAuJofVbOqhrsjb6KX8mZf7OuXDeqlEBCwTI+0VfiQj37+pD9IL+L8w85gatl", + "sThzplBUboaGjoUJ4pO1XAjMC+N3oKStCzURM0mFPQSzeIMv63IULtELMSrUpdLXCvViKidmhItvFTjv", + "msthk8JJh1wjxId4BqIBaLANfsXI3vk1W/UvxhevinPxU/QAzrPCsq/xIPS0fLCBKwCaw73zcfQ6/qQ+", + "v+WKqfsGx19faq58LKIibSWfVSkTEjGrJAm6p1ZoDB9JtCkLx6yh/vDLyGIFvb5+sHN4Te+iTQdRNmIT", + "MeOqj692Emur+As80J2vxai0YxPB9ASpMx2usGnCdcZjzJJIb8+qu5neeCwfBvRQGcxW7XGTpb8F61wo", + "vDFhLa4lE4uJAM3JF4NRFMqClwZt8W5FgSDvFT3KoZnYE2k/PIj4yJCFVtJps1b5CWIDcbxQfAgt+Biq", + "RsrEhcJpcSM8nw551GH4fuhGX4UJszBf6Cp8nnUEga9YqxVFhmB8QJ2yUiskvsvDhmhTwqaXSJxmZRPd", + "XCworz166HsJIixIKKoLhM+Y3r6A67BkDOL/KkQUlAQ3ClEKZmmRtStWpv6Fgj2oBHCBcPIFvmib+pRD", + "HppFI1TTunwMUErZ5KEoUjk/7avJhdJbq+XkWtxu6+aLjc9Nr25we2rWRX8cG5K/C+o1ol7NGeDxWtcp", + "Bfx9s/3OhuGm2n+fU7k89syqzj28nrRjHZKPH///AwCGiQkbwtcDAA==", } // GetSwagger returns the content of the embedded swagger specification file From 01e236a951765da99bb9a05d82e8957d151e3338 Mon Sep 17 00:00:00 2001 From: Sayan- <1415138+Sayan-@users.noreply.github.com> Date: Wed, 14 Oct 2026 22:24:35 +0000 Subject: [PATCH 04/15] Preserve network capture state and causal event order --- server/lib/cdpmonitor/README.md | 4 ++ server/lib/cdpmonitor/handlers.go | 8 ++- server/lib/cdpmonitor/network_capture.go | 78 +++++++++++++++++------- 3 files changed, 66 insertions(+), 24 deletions(-) diff --git a/server/lib/cdpmonitor/README.md b/server/lib/cdpmonitor/README.md index 32b2a1f0f..edee06da5 100644 --- a/server/lib/cdpmonitor/README.md +++ b/server/lib/cdpmonitor/README.md @@ -126,6 +126,10 @@ before falling back to the base response. Capture remains best-effort when Chrom omits events or a target disconnects. Redirects emit a response for each hop, without a body. Request IDs remain the same across a redirect chain. +Responses, failures, and proxy errors for tracked requests publish after their +request event. Header correlation stays active for pending redirect responses +after the final request completes or fails, until their capture finishes. + `network_response.status` is the wire status when available. `effective_status` is present when Chrome's effective response differs, such as wire 304 with an effective 200 and a cached body. `headers` contains the wire response headers when diff --git a/server/lib/cdpmonitor/handlers.go b/server/lib/cdpmonitor/handlers.go index c0e09d9fe..0030bfcb7 100644 --- a/server/lib/cdpmonitor/handlers.go +++ b/server/lib/cdpmonitor/handlers.go @@ -595,7 +595,9 @@ func (m *Monitor) handleResponseReceived(p cdpNetworkResponseReceivedParams, ses if state.hop != nil { source = state.hop.source } - m.publishProxyError(source, sessionID, p.RequestID, code, p.Response.Status, navSeq, method, resType, url, frame, loader) + m.publishAfterNetworkRequest(state.hop, func() { + m.publishProxyError(source, sessionID, p.RequestID, code, p.Response.Status, navSeq, method, resType, url, frame, loader) + }) } func (m *Monitor) handleLoadingFinished(ctx context.Context, p cdpNetworkLoadingFinishedParams, sessionID string) { @@ -689,7 +691,9 @@ func (m *Monitor) handleLoadingFailed(p cdpNetworkLoadingFailedParams, sessionID if state.hop != nil { source = state.hop.source } - m.publishEvent(EventNetworkLoadingFailed, events.Network, source, "Network.loadingFailed", data, sessionID) + m.publishAfterNetworkRequest(state.hop, func() { + m.publishEvent(EventNetworkLoadingFailed, events.Network, source, "Network.loadingFailed", data, sessionID) + }) if ok { m.finishNetworkRequest(state) diff --git a/server/lib/cdpmonitor/network_capture.go b/server/lib/cdpmonitor/network_capture.go index 252291f19..1cd40ceed 100644 --- a/server/lib/cdpmonitor/network_capture.go +++ b/server/lib/cdpmonitor/network_capture.go @@ -21,11 +21,12 @@ const ( // request IDs; only hops whose response advertises ExtraInfo consume those queues. // All exchange and hop fields are protected by pendReqMu. type networkExchange struct { - addedAt time.Time - hops []*networkHop - requests []json.RawMessage - responses []cdpNetworkResponseReceivedExtraInfoParams - failed bool + addedAt time.Time + hops []*networkHop + requests []json.RawMessage + responses []cdpNetworkResponseReceivedExtraInfoParams + terminal bool + publications int // request/response publishers still using this exchange } type networkHop struct { @@ -40,7 +41,7 @@ type networkHop struct { responseReady chan struct{} requestMatched bool responseMatched bool - requestPublished bool + requestPublished chan struct{} } func (m *Monitor) exchangeLocked(key networkRequestKey) *networkExchange { @@ -56,13 +57,15 @@ func (m *Monitor) queueNetworkRequestLocked(key networkRequestKey, request oapi. e := m.exchangeLocked(key) metadata := targetMetadata(info) h := &networkHop{ - exchange: e, - request: request, - source: oapi.BrowserEventSource{Kind: oapi.Cdp, Metadata: &metadata}, - requestReady: make(chan struct{}), - responseReady: make(chan struct{}), + exchange: e, + request: request, + source: oapi.BrowserEventSource{Kind: oapi.Cdp, Metadata: &metadata}, + requestReady: make(chan struct{}), + responseReady: make(chan struct{}), + requestPublished: make(chan struct{}), } e.hops = append(e.hops, h) + e.publications++ return h } @@ -108,17 +111,28 @@ func (m *Monitor) resolveFailedHeadersLocked(h *networkHop) { if h == nil { return } - h.exchange.failed = true + h.exchange.terminal = true // CORS failures can have ExtraInfo without a responseReceived event. if !h.known { h.known, h.hasExtra = true, true } h.exchange.matchHeaders() - if h.requestPublished { - delete(m.networkExchanges, networkRequestKey{h.request.SessionId, h.request.RequestId}) + m.cleanupNetworkExchangeLocked(networkRequestKey{h.request.SessionId, h.request.RequestId}, h.exchange) +} + +func (m *Monitor) cleanupNetworkExchangeLocked(key networkRequestKey, e *networkExchange) { + if e.terminal && e.publications == 0 && m.networkExchanges[key] == e { + delete(m.networkExchanges, key) } } +func (m *Monitor) finishNetworkPublication(key networkRequestKey, e *networkExchange) { + m.pendReqMu.Lock() + defer m.pendReqMu.Unlock() + e.publications-- + m.cleanupNetworkExchangeLocked(key, e) +} + func (e *networkExchange) matchHeaders() { for _, h := range e.hops { if !h.known { @@ -171,6 +185,8 @@ func waitNetworkHeaders(ctx context.Context, ready ...<-chan struct{}) { func (m *Monitor) publishNetworkRequest(ctx context.Context, key networkRequestKey, h *networkHop) { m.telemetryWg.Go(func() { + defer m.finishNetworkPublication(key, h.exchange) + defer close(h.requestPublished) waitNetworkHeaders(ctx, h.requestReady) m.pendReqMu.Lock() payload := h.request @@ -178,27 +194,48 @@ func (m *Monitor) publishNetworkRequest(ctx context.Context, key networkRequestK payload.Headers = nil _ = json.Unmarshal(h.requestHeaders, &payload.Headers) } - h.requestPublished = true - if h.exchange.failed && m.networkExchanges[key] == h.exchange { - delete(m.networkExchanges, key) - } m.pendReqMu.Unlock() data, _ := json.Marshal(payload) m.publishEvent(EventNetworkRequest, events.Network, h.source, "Network.requestWillBeSent", data, key.sessionID) }) } +// The request publisher always drains, including on cancellation. Wait for its +// publication, not just header readiness, to preserve per-request event order. +func (m *Monitor) publishAfterNetworkRequest(h *networkHop, publish func()) { + if h == nil { + publish() + return + } + m.telemetryWg.Go(func() { + <-h.requestPublished + publish() + }) +} + func (m *Monitor) emitNetworkResponse(ctx context.Context, key networkRequestKey, state networkReqState, info targetInfo, redirect bool) { + h := state.hop + if h != nil { + m.pendReqMu.Lock() + h.exchange.publications++ + if !redirect { + h.exchange.terminal = true + } + m.pendReqMu.Unlock() + } m.telemetryWg.Go(func() { + if h != nil { + defer m.finishNetworkPublication(key, h.exchange) + } // Fetch before waiting for ExtraInfo so header ordering cannot delay retrieval. var body string var bodyErr error if !redirect { body, bodyErr = m.fetchResponseBody(ctx, key.requestID, key.sessionID, state) } - h := state.hop if h != nil { waitNetworkHeaders(ctx, h.requestReady, h.responseReady) + <-h.requestPublished } var headers oapi.BrowserHttpHeaders _ = json.Unmarshal(state.resHeaders, &headers) @@ -241,9 +278,6 @@ func (m *Monitor) emitNetworkResponse(ctx context.Context, key networkRequestKey payload.StatusText = optPtr(http.StatusText(payload.Status)) } } - if !redirect && m.networkExchanges[key] == h.exchange { - delete(m.networkExchanges, key) - } m.pendReqMu.Unlock() } data, _ := json.Marshal(payload) From b9be471e8c205cabdf18f5e4d816ec1758bacb6e Mon Sep 17 00:00:00 2001 From: Sayan- <1415138+Sayan-@users.noreply.github.com> Date: Wed, 14 Oct 2026 22:24:35 +0000 Subject: [PATCH 05/15] Cover late redirect headers and publication ordering --- server/lib/cdpmonitor/network_capture_test.go | 95 +++++++++++++++++++ 1 file changed, 95 insertions(+) diff --git a/server/lib/cdpmonitor/network_capture_test.go b/server/lib/cdpmonitor/network_capture_test.go index 163ac4527..24fddc58f 100644 --- a/server/lib/cdpmonitor/network_capture_test.go +++ b/server/lib/cdpmonitor/network_capture_test.go @@ -4,11 +4,13 @@ import ( "context" "encoding/json" "fmt" + "sync" "testing" "time" "github.com/kernel/kernel-images/server/lib/browsersurface" "github.com/kernel/kernel-images/server/lib/cdpclient" + "github.com/kernel/kernel-images/server/lib/events" "github.com/kernel/kernel-images/server/lib/oapi" "github.com/stretchr/testify/require" ) @@ -76,6 +78,99 @@ func TestNetworkHeadersFollowRedirectHops(t *testing.T) { } } +func TestTerminalRequestPreservesPendingRedirectHeaders(t *testing.T) { + for _, terminal := range []string{EventNetworkLoadingFailed, EventNetworkResponse} { + t.Run(terminal, func(t *testing.T) { + srv := newTestServer(t) + defer srv.close() + m, ec, cleanup := startMonitor(t, srv, nil) + defer cleanup() + send := func(method string, params any) { sendNetworkFixture(t, srv, method, params) } + send("Network.requestWillBeSent", cdpNetworkRequestWillBeSentParams{RequestID: "r", Request: cdpNetworkRequest{Method: "GET", URL: "https://example.com/start"}}) + send("Network.requestWillBeSentExtraInfo", cdpNetworkRequestWillBeSentExtraInfoParams{RequestID: "r", Headers: json.RawMessage(`{"Cookie":"hop=0"}`)}) + send("Network.requestWillBeSent", cdpNetworkRequestWillBeSentParams{RequestID: "r", RedirectHasExtraInfo: true, RedirectResponse: json.RawMessage(`{"status":302,"headers":{"Base":"redirect"}}`), Request: cdpNetworkRequest{Method: "GET", URL: "https://example.com/final"}}) + if terminal == EventNetworkLoadingFailed { + send("Network.requestWillBeSentExtraInfo", cdpNetworkRequestWillBeSentExtraInfoParams{RequestID: "r", Headers: json.RawMessage(`{"Cookie":"hop=1"}`)}) + send("Network.loadingFailed", cdpNetworkLoadingFailedParams{RequestID: "r", ErrorText: "net::ERR_ABORTED", Canceled: true}) + } else { + // A cached final response can finish before the redirect's ExtraInfo arrives. + send("Network.responseReceived", cdpNetworkResponseReceivedParams{RequestID: "r", Response: cdpNetworkResponse{Status: 200}}) + send("Network.loadingFinished", cdpNetworkLoadingFinishedParams{RequestID: "r"}) + } + waitForNetworkURL(t, ec, EventNetworkRequest, "https://example.com/final") + if terminal == EventNetworkLoadingFailed { + waitForNetworkURL(t, ec, terminal, "https://example.com/final") + } + send("Network.responseReceivedExtraInfo", cdpNetworkResponseReceivedExtraInfoParams{RequestID: "r", StatusCode: 302, Headers: json.RawMessage(`{"Set-Cookie":"redirect=true","X-Wire":"yes"}`)}) + event := waitForNetworkURL(t, ec, EventNetworkResponse, "https://example.com/start") + var response oapi.BrowserNetworkResponseEventData + require.NoError(t, json.Unmarshal(event.Data, &response)) + require.Equal(t, "redirect=true", response.Headers["Set-Cookie"]) + require.Equal(t, "yes", response.Headers["X-Wire"]) + waitForNetworkURL(t, ec, terminal, "https://example.com/final") + require.Eventually(t, func() bool { + m.pendReqMu.Lock() + defer m.pendReqMu.Unlock() + return len(m.networkExchanges) == 0 + }, time.Second, time.Millisecond, "completed captures must release their header state") + }) + } +} + +func TestCanceledRequestPublishesBeforeFailure(t *testing.T) { + srv := newTestServer(t) + defer srv.close() + _, ec, cleanup := startMonitor(t, srv, nil) + defer cleanup() + sendNetworkFixture(t, srv, "Network.requestWillBeSent", cdpNetworkRequestWillBeSentParams{RequestID: "r", Request: cdpNetworkRequest{Method: "GET", URL: "https://example.com/canceled"}}) + sendNetworkFixture(t, srv, "Network.loadingFailed", cdpNetworkLoadingFailedParams{RequestID: "r", ErrorText: "net::ERR_ABORTED", Canceled: true}) + request := ec.waitFor(t, EventNetworkRequest, 2*time.Second) + failure := ec.waitFor(t, EventNetworkLoadingFailed, 2*time.Second) + ec.mu.Lock() + defer ec.mu.Unlock() + var order []string + for _, event := range ec.events { + if event.Category == events.Network { + order = append(order, event.Type) + } + } + require.Equal(t, []string{EventNetworkRequest, EventNetworkLoadingFailed}, order) + require.LessOrEqual(t, request.Ts, failure.Ts) +} + +func TestResponseWaitsForRequestPublication(t *testing.T) { + ec := newEventCollector() + publish := ec.publishFn() + entered, release := make(chan struct{}), make(chan struct{}) + var once sync.Once + unblock := func() { once.Do(func() { close(release) }) } + m := New(newTestUpstream(""), func(event events.Event) (events.Envelope, bool) { + if event.Type == EventNetworkRequest { + close(entered) + <-release + } + return publish(event) + }, 0, discardLogger, nil) + defer m.Stop() + defer unblock() + m.handleNetworkRequest(cdpNetworkRequestWillBeSentParams{RequestID: "r", Request: cdpNetworkRequest{Method: "GET", URL: "https://example.com/image"}}, "s") + m.handleResponseReceived(cdpNetworkResponseReceivedParams{RequestID: "r", Response: cdpNetworkResponse{Status: 200}}, "s") + select { + case <-entered: + case <-time.After(time.Second): + t.Fatal("request publication did not start") + } + m.handleLoadingFinished(context.Background(), cdpNetworkLoadingFinishedParams{RequestID: "r"}, "s") + ec.assertNone(t, EventNetworkResponse, 0, 50*time.Millisecond) + unblock() + ec.waitFor(t, EventNetworkResponse, time.Second) + ec.mu.Lock() + defer ec.mu.Unlock() + require.Len(t, ec.events, 2) + require.Equal(t, EventNetworkRequest, ec.events[0].Type) + require.Equal(t, EventNetworkResponse, ec.events[1].Type) +} + func TestNetworkLateHeadersRemainOnResponse(t *testing.T) { srv := newTestServer(t) defer srv.close() From 8cf72bea47656624081bea24f76f08fe13d2c7df Mon Sep 17 00:00:00 2001 From: Sayan- <1415138+Sayan-@users.noreply.github.com> Date: Wed, 14 Oct 2026 23:50:30 +0000 Subject: [PATCH 06/15] Preserve base headers when wire headers are invalid --- server/lib/cdpmonitor/README.md | 34 +++++++++++++++++++----- server/lib/cdpmonitor/handlers.go | 8 +++++- server/lib/cdpmonitor/network_capture.go | 17 +++++++----- 3 files changed, 45 insertions(+), 14 deletions(-) diff --git a/server/lib/cdpmonitor/README.md b/server/lib/cdpmonitor/README.md index edee06da5..87332799c 100644 --- a/server/lib/cdpmonitor/README.md +++ b/server/lib/cdpmonitor/README.md @@ -121,19 +121,26 @@ by session, request ID, and redirect hop. Cached hops without ExtraInfo do not consume the next hop's headers. A `network_request` waits at most one second for wire headers, then uses the base headers so a hanging request remains visible. `network_response.request_headers` retains wire request headers that arrive after -that initial event. Response capture waits at most one second for promised headers -before falling back to the base response. Capture remains best-effort when Chrome -omits events or a target disconnects. Redirects emit a response for each hop, -without a body. Request IDs remain the same across a redirect chain. +that initial event. After body retrieval, response capture waits up to one second +total for both request and response headers, sharing one deadline. It then falls +back to the base headers for anything still missing or invalid. Capture remains +best-effort when Chrome omits events or a target disconnects. Redirects emit a +response for each hop, without a body. Request IDs remain the same across a +redirect chain. Responses, failures, and proxy errors for tracked requests publish after their -request event. Header correlation stays active for pending redirect responses -after the final request completes or fails, until their capture finishes. +request event. There is no ordering guarantee between different redirect hops: +a hop's response can publish before or after the next hop's request. +Header correlation stays active for pending redirect responses after the final +request completes or fails, until their capture finishes. `network_response.status` is the wire status when available. `effective_status` is present when Chrome's effective response differs, such as wire 304 with an effective 200 and a cached body. `headers` contains the wire response headers when -available rather than Chrome's merged cache headers. +available rather than Chrome's merged cache headers. When wire and effective status +differ, `status_text` uses the standard HTTP reason phrase for the wire status +(or is omitted for an unknown code), rather than the cached response's phrase. +Otherwise Chrome's original `status_text`, including a custom phrase, is retained. While optional telemetry is enabled, `Network.enable` requests durable body storage with `maxTotalBufferSize` set to 10 MiB on each attached session. Disabling @@ -160,6 +167,19 @@ KERNEL_CDPMONITOR_CHROME_E2E=1 go test -race ./lib/cdpmonitor \ -run '^TestNetwork(WireCapture|BodiesSurviveNavigation|ExtensionAttribution)$' -count=1 ``` +Bundled-extension attribution also has a browser regression that loads an actual +installed bundle and checks its Chromium-assigned ID. Run it once for each bundled +path (`/home/kernel/extensions/kernel` and `/home/kernel/extensions/capmonster`): + +```sh +KERNEL_CDPMONITOR_BUNDLED_EXTENSION_PATH=/home/kernel/extensions/kernel \ + go test -race ./lib/cdpmonitor -run '^TestNetworkBundledExtensionAttribution$' -count=1 +``` + +This requires the bundle at its installation path, with its normal manifest and +assets. It is separate from the general Chromium suite because the bundles are +not included in this source tree. An explicit path that cannot load fails the test. + ## Event taxonomy **CDP-derived** (1-to-1 with a CDP notification): `console_log`, `console_error`, `network_request`, `network_response`, `network_loading_failed`, `proxy_error` (classified from a branded 502 or 403 response carrying the `X-Kernel-Proxy-Error` header), `page_tab_opened`, `page_navigation`, `page_dom_content_loaded`, `page_load`, `page_layout_shift`, `page_lcp`. `proxy_error` is an opt-in per-session/per-URL refinement of the raw `network` events: it is only observable while the network category (CDP collector) is running, so it is not a default-on alerting signal. diff --git a/server/lib/cdpmonitor/handlers.go b/server/lib/cdpmonitor/handlers.go index 0030bfcb7..b46449110 100644 --- a/server/lib/cdpmonitor/handlers.go +++ b/server/lib/cdpmonitor/handlers.go @@ -794,6 +794,8 @@ func (m *Monitor) handleFrameNavigated(p cdpPageFrameNavigatedParams, sessionID m.sessionsMu.Lock() info, tracked := m.sessions[sessionID] cs := m.computedStates[sessionID] + // Chromium uses an OOPIF's root frame ID as its target ID; that root can + // still have a parentId, unlike a top-level page's root. if tracked && (p.Frame.ParentID == "" || p.Frame.ID == info.targetID) { info.url = p.Frame.URL m.sessions[sessionID] = info @@ -830,13 +832,17 @@ func (m *Monitor) handleFrameNavigated(p cdpPageFrameNavigatedParams, sessionID m.pendReqMu.Lock() inflight := 0 + nextSeq := -1 + if cs != nil { + nextSeq = cs.currentNavSeq() + 1 + } for key, req := range m.pendingRequests { if req.sessionID != sessionID { continue } req.countedNavSeq = -1 if cs != nil && req.loaderID == p.Frame.LoaderID { - req.countedNavSeq = cs.currentNavSeq() + 1 + req.countedNavSeq = nextSeq inflight++ } m.pendingRequests[key] = req diff --git a/server/lib/cdpmonitor/network_capture.go b/server/lib/cdpmonitor/network_capture.go index 1cd40ceed..8a0aeb2e1 100644 --- a/server/lib/cdpmonitor/network_capture.go +++ b/server/lib/cdpmonitor/network_capture.go @@ -191,8 +191,10 @@ func (m *Monitor) publishNetworkRequest(ctx context.Context, key networkRequestK m.pendReqMu.Lock() payload := h.request if h.requestHeaders != nil { - payload.Headers = nil - _ = json.Unmarshal(h.requestHeaders, &payload.Headers) + var headers oapi.BrowserHttpHeaders + if json.Unmarshal(h.requestHeaders, &headers) == nil && headers != nil { + payload.Headers = headers + } } m.pendReqMu.Unlock() data, _ := json.Marshal(payload) @@ -266,12 +268,15 @@ func (m *Monitor) emitNetworkResponse(ctx context.Context, key networkRequestKey m.pendReqMu.Lock() if h.requestHeaders != nil { var requestHeaders oapi.BrowserHttpHeaders - _ = json.Unmarshal(h.requestHeaders, &requestHeaders) - payload.RequestHeaders = &requestHeaders + if json.Unmarshal(h.requestHeaders, &requestHeaders) == nil && requestHeaders != nil { + payload.RequestHeaders = &requestHeaders + } } if h.responseExtra != nil { - payload.Headers = nil - _ = json.Unmarshal(h.responseExtra.Headers, &payload.Headers) + var responseHeaders oapi.BrowserHttpHeaders + if json.Unmarshal(h.responseExtra.Headers, &responseHeaders) == nil && responseHeaders != nil { + payload.Headers = responseHeaders + } payload.Status = h.responseExtra.StatusCode if payload.Status != state.status { payload.EffectiveStatus = ptrOf(state.status) From 6138f001eb72e853c4d89a119681f2da8c078a68 Mon Sep 17 00:00:00 2001 From: Sayan- <1415138+Sayan-@users.noreply.github.com> Date: Wed, 14 Oct 2026 23:50:30 +0000 Subject: [PATCH 07/15] Cover network capture contracts and bundled attribution --- server/lib/cdpmonitor/network_capture_test.go | 64 +++++++++++++++++++ .../lib/cdpmonitor/network_chrome_e2e_test.go | 3 + .../network_fidelity_chrome_e2e_test.go | 38 +++++++++++ 3 files changed, 105 insertions(+) diff --git a/server/lib/cdpmonitor/network_capture_test.go b/server/lib/cdpmonitor/network_capture_test.go index 24fddc58f..baaaccde0 100644 --- a/server/lib/cdpmonitor/network_capture_test.go +++ b/server/lib/cdpmonitor/network_capture_test.go @@ -203,6 +203,59 @@ func TestNetworkLateHeadersRemainOnResponse(t *testing.T) { require.Equal(t, 1, count, "late headers must not duplicate the request event") } +func TestNetworkMalformedWireHeadersPreserveBaseHeaders(t *testing.T) { + for _, wire := range []string{`[]`, `"invalid"`, `null`} { + t.Run(wire, func(t *testing.T) { + srv := newTestServer(t) + defer srv.close() + _, ec, cleanup := startMonitor(t, srv, nil) + defer cleanup() + sendNetworkFixture(t, srv, "Network.requestWillBeSent", cdpNetworkRequestWillBeSentParams{RequestID: "r", Request: cdpNetworkRequest{Method: "GET", URL: "https://example.com/", Headers: json.RawMessage(`{"X-Request":"base"}`)}}) + sendNetworkFixture(t, srv, "Network.requestWillBeSentExtraInfo", cdpNetworkRequestWillBeSentExtraInfoParams{RequestID: "r", Headers: json.RawMessage(wire)}) + sendNetworkFixture(t, srv, "Network.responseReceived", cdpNetworkResponseReceivedParams{RequestID: "r", HasExtraInfo: true, Response: cdpNetworkResponse{Status: 200, Headers: json.RawMessage(`{"X-Response":"base"}`)}}) + sendNetworkFixture(t, srv, "Network.responseReceivedExtraInfo", cdpNetworkResponseReceivedExtraInfoParams{RequestID: "r", StatusCode: 200, Headers: json.RawMessage(wire)}) + sendNetworkFixture(t, srv, "Network.loadingFinished", cdpNetworkLoadingFinishedParams{RequestID: "r"}) + var request oapi.BrowserNetworkRequestEventData + require.NoError(t, json.Unmarshal(ec.waitFor(t, EventNetworkRequest, time.Second).Data, &request)) + require.Equal(t, "base", request.Headers["X-Request"]) + var response oapi.BrowserNetworkResponseEventData + require.NoError(t, json.Unmarshal(ec.waitFor(t, EventNetworkResponse, time.Second).Data, &response)) + require.Equal(t, "base", response.Headers["X-Response"]) + require.Nil(t, response.RequestHeaders, "invalid wire headers must not be exposed as captured headers") + }) + } +} + +func TestNetworkWireStatusPreservesEffectiveStatus(t *testing.T) { + for _, tc := range []struct { + name string + wireStatus int + statusText string + effective *int + }{ + {"revalidated", 304, "Not Modified", ptrOf(200)}, + {"unchanged", 200, "Custom OK", nil}, + } { + t.Run(tc.name, func(t *testing.T) { + srv := newTestServer(t) + defer srv.close() + _, ec, cleanup := startMonitor(t, srv, nil) + defer cleanup() + sendNetworkFixture(t, srv, "Network.requestWillBeSent", cdpNetworkRequestWillBeSentParams{RequestID: "r", Request: cdpNetworkRequest{Method: "GET", URL: "https://example.com/"}}) + sendNetworkFixture(t, srv, "Network.requestWillBeSentExtraInfo", cdpNetworkRequestWillBeSentExtraInfoParams{RequestID: "r", Headers: json.RawMessage(`{}`)}) + sendNetworkFixture(t, srv, "Network.responseReceived", cdpNetworkResponseReceivedParams{RequestID: "r", HasExtraInfo: true, Response: cdpNetworkResponse{Status: 200, StatusText: "Custom OK", Headers: json.RawMessage(`{"X-Cached":"yes"}`)}}) + sendNetworkFixture(t, srv, "Network.responseReceivedExtraInfo", cdpNetworkResponseReceivedExtraInfoParams{RequestID: "r", StatusCode: tc.wireStatus, Headers: json.RawMessage(`{"ETag":"v1"}`)}) + sendNetworkFixture(t, srv, "Network.loadingFinished", cdpNetworkLoadingFinishedParams{RequestID: "r"}) + var response oapi.BrowserNetworkResponseEventData + require.NoError(t, json.Unmarshal(ec.waitFor(t, EventNetworkResponse, time.Second).Data, &response)) + require.Equal(t, tc.wireStatus, response.Status) + require.Equal(t, tc.effective, response.EffectiveStatus) + require.Equal(t, ptrOf(tc.statusText), response.StatusText) + require.Equal(t, oapi.BrowserHttpHeaders{"ETag": "v1"}, response.Headers) + }) + } +} + func TestNetworkBodyErrorsAreObservable(t *testing.T) { srv := newTestServer(t) defer srv.close() @@ -324,6 +377,17 @@ func TestExtensionSourceTracksTargetAndRootFrameNavigation(t *testing.T) { require.NotContains(t, *event.Source.Metadata, "extension_id") } +func TestExtensionSourceTracksOOPIFRootNavigation(t *testing.T) { + m, ec := newComputedMonitor(t) + defer m.Stop() + m.sessions["s1"] = targetInfo{targetID: "child", targetType: "iframe", parentFrameID: "parent"} + m.handleFrameNavigated(cdpPageFrameNavigatedParams{Frame: cdpPageFrame{ID: "child", ParentID: "parent", URL: "chrome-extension://aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/page.html"}}, "s1") + m.handleFrameNavigated(cdpPageFrameNavigatedParams{Frame: cdpPageFrame{ID: "nested", ParentID: "child", URL: "https://example.com/"}}, "s1") + m.handleTargetCrashed("s1") + event := ec.waitFor(t, EventPageCrashed, time.Second) + require.Equal(t, "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", (*event.Source.Metadata)["extension_id"]) +} + func TestProxyErrorSourceSurvivesOriginChanges(t *testing.T) { extension := "chrome-extension://aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/page.html" for _, document := range []string{extension, "https://example.com/"} { diff --git a/server/lib/cdpmonitor/network_chrome_e2e_test.go b/server/lib/cdpmonitor/network_chrome_e2e_test.go index f9e8cf44c..552f3d52b 100644 --- a/server/lib/cdpmonitor/network_chrome_e2e_test.go +++ b/server/lib/cdpmonitor/network_chrome_e2e_test.go @@ -199,6 +199,9 @@ func TestNetworkCaptureAcrossFrames(t *testing.T) { require.NotEmpty(t, request.SessionId) require.NotNil(t, request.FrameId) require.NotEmpty(t, *request.FrameId) + if frame.targetType == "iframe" { + require.Equal(t, frame.target, *request.FrameId, "Chromium uses the OOPIF root frame ID as its target ID") + } if aborted { event := waitForNetworkURL(t, ec, EventNetworkLoadingFailed, frame.origin+path) var failure oapi.BrowserNetworkLoadingFailedEventData diff --git a/server/lib/cdpmonitor/network_fidelity_chrome_e2e_test.go b/server/lib/cdpmonitor/network_fidelity_chrome_e2e_test.go index 2b00bb05c..249b12432 100644 --- a/server/lib/cdpmonitor/network_fidelity_chrome_e2e_test.go +++ b/server/lib/cdpmonitor/network_fidelity_chrome_e2e_test.go @@ -293,3 +293,41 @@ func TestNetworkExtensionAttribution(t *testing.T) { } } } + +func TestNetworkBundledExtensionAttribution(t *testing.T) { + dir := os.Getenv("KERNEL_CDPMONITOR_BUNDLED_EXTENSION_PATH") + if dir == "" { + t.Skip("set KERNEL_CDPMONITOR_BUNDLED_EXTENSION_PATH to a bundled extension at its installed path") + } + ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second) + defer cancel() + stub := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + w.Header().Set("Content-Type", "application/json") + fmt.Fprint(w, `{"from":"bundled-extension"}`) + })) + defer stub.Close() + ws := launchChromium(t, ctx, findChromium(t), "--enable-unsafe-extension-debugging") + c, err := cdpclient.Dial(ctx, ws) + require.NoError(t, err) + defer c.Close() + extensionID, err := c.LoadUnpackedExtension(ctx, dir) + require.NoError(t, err) + t.Logf("Chromium loaded %s as %s", dir, extensionID) + driver := dialCDP(t, ctx, ws) + defer driver.close() + target := driver.call(t, ctx, "", "Target.createTarget", map[string]any{"url": "chrome-extension://" + extensionID + "/manifest.json"}).targetID(t) + session := driver.call(t, ctx, "", "Target.attachToTarget", map[string]any{"targetId": target, "flatten": true}).sessionID(t) + ec := newEventCollector() + m := New(&staticUpstream{url: ws}, ec.publishFn(), 99, discardLogger, nil) + require.NoError(t, m.Start(ctx)) + defer m.Stop() + require.Eventually(t, func() bool { + return driver.evalBool(ctx, session, fmt.Sprintf(`location.hostname === %q && window.__kernelEventInjected === true`, extensionID)) + }, 5*time.Second, 20*time.Millisecond) + evaluateNetworkScript(t, ctx, driver, session, fmt.Sprintf(`fetch(%q).then(r=>r.json())`, stub.URL+"/bundled-api")) + for _, typ := range []string{EventNetworkRequest, EventNetworkResponse} { + event := waitForNetworkURL(t, ec, typ, stub.URL+"/bundled-api") + require.Equal(t, extensionID, (*event.Source.Metadata)["extension_id"]) + require.Equal(t, "true", (*event.Source.Metadata)["kernel_extension"]) + } +} From 9cb5740ad0eee449638248865add32bdc54eb31c Mon Sep 17 00:00:00 2001 From: Sayan- <1415138+Sayan-@users.noreply.github.com> Date: Thu, 15 Oct 2026 22:20:59 +0000 Subject: [PATCH 08/15] Preserve network event timing and status compatibility --- server/lib/cdpmonitor/README.md | 27 +++++++++++++-------- server/lib/cdpmonitor/handlers.go | 27 ++++++++++++++------- server/lib/cdpmonitor/network_capture.go | 31 +++++++++++++----------- server/openapi.yaml | 6 ++--- 4 files changed, 55 insertions(+), 36 deletions(-) diff --git a/server/lib/cdpmonitor/README.md b/server/lib/cdpmonitor/README.md index 215f73c58..ce207c511 100644 --- a/server/lib/cdpmonitor/README.md +++ b/server/lib/cdpmonitor/README.md @@ -128,19 +128,26 @@ best-effort when Chrome omits events or a target disconnects. Redirects emit a response for each hop, without a body. Request IDs remain the same across a redirect chain. +Network event timestamps record wall-clock time when the CDP event is observed, +before header collection, body retrieval, or publication waits. Response events +use observation of `loadingFinished`, or the redirect notification for redirects. +Timestamp differences therefore retain request duration despite delayed delivery. +Other event types may publish during these waits, so timestamps need not increase +in stream order. + Responses, failures, and proxy errors for tracked requests publish after their -request event. There is no ordering guarantee between different redirect hops: -a hop's response can publish before or after the next hop's request. +request event. Each redirect response publishes before the next hop's request. +Header waits run concurrently across hops and remain bounded by one second; +publication dependencies drain in order even when capture is canceled. Header correlation stays active for pending redirect responses after the final request completes or fails, until their capture finishes. -`network_response.status` is the wire status when available. `effective_status` -is present when Chrome's effective response differs, such as wire 304 with an -effective 200 and a cached body. `headers` contains the wire response headers when -available rather than Chrome's merged cache headers. When wire and effective status -differ, `status_text` uses the standard HTTP reason phrase for the wire status -(or is omitted for an unknown code), rather than the cached response's phrase. -Otherwise Chrome's original `status_text`, including a custom phrase, is retained. +`network_response.status` and `status_text` retain Chrome's effective response, +including custom reason phrases. `wire_status` adds the wire status when available: +a revalidated cached response has `status: 200`, `wire_status: 304`, and may carry +Chrome's cached body. Existing success checks can continue using `status`. +`headers` contains the wire response headers when available rather than Chrome's +merged cache headers. While optional telemetry is enabled, `Network.enable` requests durable body storage with `maxTotalBufferSize` set to 10 MiB on each attached session. Disabling @@ -431,7 +438,7 @@ Unless otherwise noted, events also include the nav context fields described abo | Event | Fields | | --- | --- | | `network_request` | `request_id`, `loader_id`, `frame_id`, `document_url`, `method`, `url`, `headers`, `initiator_type`. Optional: `post_data`, `resource_type`, `is_redirect` + `redirect_url`. | -| `network_response` | `request_id`, `loader_id`, `frame_id`, `method`, `url`, `status`, `headers`. Optional: `status_text`, `mime_type`, `resource_type`, `body` (truncated text body for textual MIME types), `body_error`, `request_headers`, `effective_status`. | +| `network_response` | `request_id`, `loader_id`, `frame_id`, `method`, `url`, `status`, `headers`. Optional: `status_text`, `mime_type`, `resource_type`, `body` (truncated text body for textual MIME types), `body_error`, `request_headers`, `wire_status`. | | `network_loading_failed` | `request_id`, `error_text`, `canceled`. Optional (absent when the request record was not found): `url`, `loader_id`, `frame_id`, `resource_type`. | | `proxy_error` | `request_id`, `code` (typed enum matching the metro header values), `status` (502, or 403 when the session's network policy blocks the destination). Optional: `raw_code` (sanitized original value when `code` is `unknown`), `url`, `loader_id`, `frame_id`, `method`, `resource_type`. Emitted when a 502 or 403 response carries the `X-Kernel-Proxy-Error` header. Unrecognized values are reported as `unknown`; all such values share one rate-limit slot. Emission is sampled to at most one per session+code+resource_type per second. WebSocket handshakes are not classified (documented non-goal). A CONNECT the proxy refuses outright, such as a `network_policy_denied` CONNECT to a port other than 443, is not classified either: Chromium does not expose the refusal, so it appears only as `network_loading_failed` with `net::ERR_TUNNEL_CONNECTION_FAILED`. | diff --git a/server/lib/cdpmonitor/handlers.go b/server/lib/cdpmonitor/handlers.go index b46449110..40906ada6 100644 --- a/server/lib/cdpmonitor/handlers.go +++ b/server/lib/cdpmonitor/handlers.go @@ -61,6 +61,10 @@ func (m *Monitor) logUnmarshalErr(method string, err error) { // publishEvent stamps common fields and publishes an event. func (m *Monitor) publishEvent(eventType string, category oapi.TelemetryEventCategory, source oapi.BrowserEventSource, sourceEvent string, data json.RawMessage, sessionID string) { + m.publishEventAt(time.Now(), eventType, category, source, sourceEvent, data, sessionID) +} + +func (m *Monitor) publishEventAt(observedAt time.Time, eventType string, category oapi.TelemetryEventCategory, source oapi.BrowserEventSource, sourceEvent string, data json.RawMessage, sessionID string) { src := source src.Event = &sourceEvent if sessionID != "" { @@ -83,7 +87,7 @@ func (m *Monitor) publishEvent(eventType string, category oapi.TelemetryEventCat src.Metadata = &meta } m.publish(events.Event{ - Ts: time.Now().UnixMicro(), + Ts: observedAt.UnixMicro(), Type: eventType, Category: category, Source: src, @@ -439,6 +443,7 @@ func (m *Monitor) handleTimelineEvent(p cdpPerformanceTimelineEventAddedParams, // This mirrors what CDP/DevTools itself exposes. Consumers should treat the // event stream as privileged data; opt-in redaction can be added later. func (m *Monitor) handleNetworkRequest(p cdpNetworkRequestWillBeSentParams, sessionID string) { + observedAt := time.Now() // Extract only the initiator type; the stack trace is too verbose and dominates event size. var initiatorType string var raw struct { @@ -519,26 +524,28 @@ func (m *Monitor) handleNetworkRequest(p cdpNetworkRequestWillBeSentParams, sess if p.DocumentURL != "" { requestInfo.url = p.DocumentURL } - hop := m.queueNetworkRequestLocked(key, payload, requestInfo) + hop := m.queueNetworkRequestLocked(key, payload, requestInfo, observedAt) state := m.pendingRequests[key] state.hop = hop m.pendingRequests[key] = state m.pendReqMu.Unlock() + var redirectPublished <-chan struct{} if isRedirect && len(p.RedirectResponse) != 0 { var response cdpNetworkResponse if json.Unmarshal(p.RedirectResponse, &response) == nil { existing.status, existing.statusText = response.Status, response.StatusText existing.resHeaders, existing.mimeType = response.Headers, response.MimeType - m.emitNetworkResponse(m.telemetryCtx, key, existing, info, true) + redirectPublished = m.emitNetworkResponse(m.telemetryCtx, observedAt, key, existing, info, true) } } - m.publishNetworkRequest(m.telemetryCtx, key, hop) + m.publishNetworkRequest(m.telemetryCtx, key, hop, redirectPublished) if !isRedirect && cs != nil { cs.onRequest() } } func (m *Monitor) handleResponseReceived(p cdpNetworkResponseReceivedParams, sessionID string) { + observedAt := time.Now() key := networkRequestKey{sessionID, p.RequestID} m.pendReqMu.Lock() var ( @@ -596,11 +603,12 @@ func (m *Monitor) handleResponseReceived(p cdpNetworkResponseReceivedParams, ses source = state.hop.source } m.publishAfterNetworkRequest(state.hop, func() { - m.publishProxyError(source, sessionID, p.RequestID, code, p.Response.Status, navSeq, method, resType, url, frame, loader) + m.publishProxyError(observedAt, source, sessionID, p.RequestID, code, p.Response.Status, navSeq, method, resType, url, frame, loader) }) } func (m *Monitor) handleLoadingFinished(ctx context.Context, p cdpNetworkLoadingFinishedParams, sessionID string) { + observedAt := time.Now() key := networkRequestKey{sessionID, p.RequestID} m.pendReqMu.Lock() state, ok := m.pendingRequests[key] @@ -615,7 +623,7 @@ func (m *Monitor) handleLoadingFinished(ctx context.Context, p cdpNetworkLoading info := m.sessions[sessionID] m.sessionsMu.RUnlock() m.finishNetworkRequest(state) - m.emitNetworkResponse(ctx, key, state, info, false) + m.emitNetworkResponse(ctx, observedAt, key, state, info, false) } // fetchResponseBody retrieves and truncates the response body for textual resources. @@ -648,6 +656,7 @@ func (m *Monitor) fetchResponseBody(ctx context.Context, requestID, sessionID st } func (m *Monitor) handleLoadingFailed(p cdpNetworkLoadingFailedParams, sessionID string) { + observedAt := time.Now() key := networkRequestKey{sessionID, p.RequestID} m.pendReqMu.Lock() state, ok := m.pendingRequests[key] @@ -692,7 +701,7 @@ func (m *Monitor) handleLoadingFailed(p cdpNetworkLoadingFailedParams, sessionID source = state.hop.source } m.publishAfterNetworkRequest(state.hop, func() { - m.publishEvent(EventNetworkLoadingFailed, events.Network, source, "Network.loadingFailed", data, sessionID) + m.publishEventAt(observedAt, EventNetworkLoadingFailed, events.Network, source, "Network.loadingFailed", data, sessionID) }) if ok { @@ -756,7 +765,7 @@ func (m *Monitor) proxyErrorRateLimited(sessionID, code, resourceType string) bo // the published enum lists it. The metro egress proxy gains codes on its own // release cadence, so a value this image does not know is reported as unknown // with the sanitized header value in raw_code rather than dropped. -func (m *Monitor) publishProxyError(source oapi.BrowserEventSource, sessionID, requestID, code string, status int, navSeq int64, method, resourceType string, url, frameID, loaderID *string) { +func (m *Monitor) publishProxyError(observedAt time.Time, source oapi.BrowserEventSource, sessionID, requestID, code string, status int, navSeq int64, method, resourceType string, url, frameID, loaderID *string) { var rawCode *string if code == proxyErrorUnknownCode || !oapi.BrowserProxyErrorEventDataCode(code).Valid() { raw := sanitizeProxyErrorRawCode(code) @@ -785,7 +794,7 @@ func (m *Monitor) publishProxyError(source oapi.BrowserEventSource, sessionID, r RawCode: rawCode, ResourceType: optPtr(resourceType), }) - m.publishEvent(EventProxyError, events.Network, source, "Network.responseReceived", data, sessionID) + m.publishEventAt(observedAt, EventProxyError, events.Network, source, "Network.responseReceived", data, sessionID) } func (m *Monitor) handleFrameNavigated(p cdpPageFrameNavigatedParams, sessionID string) { diff --git a/server/lib/cdpmonitor/network_capture.go b/server/lib/cdpmonitor/network_capture.go index 8a0aeb2e1..5fd3044b6 100644 --- a/server/lib/cdpmonitor/network_capture.go +++ b/server/lib/cdpmonitor/network_capture.go @@ -3,7 +3,6 @@ package cdpmonitor import ( "context" "encoding/json" - "net/http" "time" "github.com/kernel/kernel-images/server/lib/events" @@ -12,7 +11,7 @@ import ( const ( networkHeaderWait = time.Second - maxOrphanExchanges = 8192 + maxNetworkExchanges = 8192 maxExtraInfoPerExchange = 64 durableBodyBufferSize = 10 * 1024 * 1024 ) @@ -33,6 +32,7 @@ type networkHop struct { exchange *networkExchange request oapi.BrowserNetworkRequestEventData source oapi.BrowserEventSource + observedAt time.Time known bool hasExtra bool requestHeaders json.RawMessage @@ -53,13 +53,14 @@ func (m *Monitor) exchangeLocked(key networkRequestKey) *networkExchange { return e } -func (m *Monitor) queueNetworkRequestLocked(key networkRequestKey, request oapi.BrowserNetworkRequestEventData, info targetInfo) *networkHop { +func (m *Monitor) queueNetworkRequestLocked(key networkRequestKey, request oapi.BrowserNetworkRequestEventData, info targetInfo, observedAt time.Time) *networkHop { e := m.exchangeLocked(key) metadata := targetMetadata(info) h := &networkHop{ exchange: e, request: request, source: oapi.BrowserEventSource{Kind: oapi.Cdp, Metadata: &metadata}, + observedAt: observedAt, requestReady: make(chan struct{}), responseReady: make(chan struct{}), requestPublished: make(chan struct{}), @@ -73,7 +74,7 @@ func (m *Monitor) handleRequestExtraInfo(p cdpNetworkRequestWillBeSentExtraInfoP key := networkRequestKey{sessionID, p.RequestID} m.pendReqMu.Lock() defer m.pendReqMu.Unlock() - if m.networkExchanges[key] == nil && len(m.networkExchanges) >= maxOrphanExchanges { + if m.networkExchanges[key] == nil && len(m.networkExchanges) >= maxNetworkExchanges { return } e := m.exchangeLocked(key) @@ -88,7 +89,7 @@ func (m *Monitor) handleResponseExtraInfo(p cdpNetworkResponseReceivedExtraInfoP key := networkRequestKey{sessionID, p.RequestID} m.pendReqMu.Lock() defer m.pendReqMu.Unlock() - if m.networkExchanges[key] == nil && len(m.networkExchanges) >= maxOrphanExchanges { + if m.networkExchanges[key] == nil && len(m.networkExchanges) >= maxNetworkExchanges { return } e := m.exchangeLocked(key) @@ -183,11 +184,14 @@ func waitNetworkHeaders(ctx context.Context, ready ...<-chan struct{}) { } } -func (m *Monitor) publishNetworkRequest(ctx context.Context, key networkRequestKey, h *networkHop) { +func (m *Monitor) publishNetworkRequest(ctx context.Context, key networkRequestKey, h *networkHop, redirectPublished <-chan struct{}) { m.telemetryWg.Go(func() { defer m.finishNetworkPublication(key, h.exchange) defer close(h.requestPublished) waitNetworkHeaders(ctx, h.requestReady) + if redirectPublished != nil { + <-redirectPublished + } m.pendReqMu.Lock() payload := h.request if h.requestHeaders != nil { @@ -198,7 +202,7 @@ func (m *Monitor) publishNetworkRequest(ctx context.Context, key networkRequestK } m.pendReqMu.Unlock() data, _ := json.Marshal(payload) - m.publishEvent(EventNetworkRequest, events.Network, h.source, "Network.requestWillBeSent", data, key.sessionID) + m.publishEventAt(h.observedAt, EventNetworkRequest, events.Network, h.source, "Network.requestWillBeSent", data, key.sessionID) }) } @@ -215,7 +219,8 @@ func (m *Monitor) publishAfterNetworkRequest(h *networkHop, publish func()) { }) } -func (m *Monitor) emitNetworkResponse(ctx context.Context, key networkRequestKey, state networkReqState, info targetInfo, redirect bool) { +func (m *Monitor) emitNetworkResponse(ctx context.Context, observedAt time.Time, key networkRequestKey, state networkReqState, info targetInfo, redirect bool) <-chan struct{} { + published := make(chan struct{}) h := state.hop if h != nil { m.pendReqMu.Lock() @@ -226,6 +231,7 @@ func (m *Monitor) emitNetworkResponse(ctx context.Context, key networkRequestKey m.pendReqMu.Unlock() } m.telemetryWg.Go(func() { + defer close(published) if h != nil { defer m.finishNetworkPublication(key, h.exchange) } @@ -277,11 +283,7 @@ func (m *Monitor) emitNetworkResponse(ctx context.Context, key networkRequestKey if json.Unmarshal(h.responseExtra.Headers, &responseHeaders) == nil && responseHeaders != nil { payload.Headers = responseHeaders } - payload.Status = h.responseExtra.StatusCode - if payload.Status != state.status { - payload.EffectiveStatus = ptrOf(state.status) - payload.StatusText = optPtr(http.StatusText(payload.Status)) - } + payload.WireStatus = ptrOf(h.responseExtra.StatusCode) } m.pendReqMu.Unlock() } @@ -290,8 +292,9 @@ func (m *Monitor) emitNetworkResponse(ctx context.Context, key networkRequestKey if redirect { event = "Network.requestWillBeSent" } - m.publishEvent(EventNetworkResponse, events.Network, source, event, data, key.sessionID) + m.publishEventAt(observedAt, EventNetworkResponse, events.Network, source, event, data, key.sessionID) }) + return published } func (m *Monitor) finishNetworkRequest(state networkReqState) { diff --git a/server/openapi.yaml b/server/openapi.yaml index d366018e6..10b98cdb9 100644 --- a/server/openapi.yaml +++ b/server/openapi.yaml @@ -2573,7 +2573,7 @@ components: description: HTTP method of the original request. status: type: integer - description: HTTP response status code on the wire when available, otherwise the effective CDP status. + description: Effective HTTP response status reported by Chrome, including 200 for a cached response revalidated with a wire 304. status_text: type: string description: HTTP response status text (e.g. OK, Not Found). @@ -2589,9 +2589,9 @@ components: request_headers: $ref: "#/components/schemas/BrowserHttpHeaders" description: Wire request headers when available, including headers that arrived after network_request was published. - effective_status: + wire_status: type: integer - description: Effective CDP status when different from the wire status, such as 200 for a revalidated 304 response. + description: HTTP status received on the wire when available, such as 304 for a revalidated cached response whose effective status is 200. Does not change the meaning of status or the cached body. body: type: string description: Truncated response body, present only for text MIME types. From 9b286bef5d29c98ab29b24f0c49bb54afc9bc870 Mon Sep 17 00:00:00 2001 From: Sayan- <1415138+Sayan-@users.noreply.github.com> Date: Thu, 15 Oct 2026 22:20:59 +0000 Subject: [PATCH 09/15] Cover network timing and redirect order in regressions --- .github/workflows/server-test.yaml | 2 +- server/lib/cdpmonitor/handlers_test.go | 4 +- server/lib/cdpmonitor/network_capture_test.go | 159 +++++++++++++----- .../network_fidelity_chrome_e2e_test.go | 10 +- 4 files changed, 122 insertions(+), 53 deletions(-) diff --git a/.github/workflows/server-test.yaml b/.github/workflows/server-test.yaml index 667e969f7..0e92f023e 100644 --- a/.github/workflows/server-test.yaml +++ b/.github/workflows/server-test.yaml @@ -103,7 +103,7 @@ jobs: cache-dependency-path: server/go.sum - name: Run CDP telemetry browser regressions - run: go test -race ./lib/cdpmonitor -run '^(TestNetworkCapture|TestTelemetryConnection|TestProxyErrorE2E)' -count=1 -v + run: go test -race ./lib/cdpmonitor -run '^(TestNetworkCapture|TestNetworkWireCapture|TestNetworkBodiesSurviveNavigation|TestNetworkExtensionAttribution|TestTelemetryConnection|TestProxyErrorE2E)' -count=1 -v working-directory: server env: KERNEL_CDPMONITOR_CHROME_E2E: "1" diff --git a/server/lib/cdpmonitor/handlers_test.go b/server/lib/cdpmonitor/handlers_test.go index dfb0d8c03..9138a4d22 100644 --- a/server/lib/cdpmonitor/handlers_test.go +++ b/server/lib/cdpmonitor/handlers_test.go @@ -410,8 +410,8 @@ func TestNetworkEvents(t *testing.T) { func TestProxyErrorUnknownCodesShareRateLimit(t *testing.T) { collector := newEventCollector() monitor := New(newTestUpstream(""), collector.publishFn(), 0, discardLogger, nil) - monitor.publishProxyError(oapi.BrowserEventSource{Kind: oapi.Cdp}, "sess", "req-a", "future_a", 502, 0, "GET", "Document", nil, nil, nil) - monitor.publishProxyError(oapi.BrowserEventSource{Kind: oapi.Cdp}, "sess", "req-b", "future_b", 502, 0, "GET", "Document", nil, nil, nil) + monitor.publishProxyError(time.Now(), oapi.BrowserEventSource{Kind: oapi.Cdp}, "sess", "req-a", "future_a", 502, 0, "GET", "Document", nil, nil, nil) + monitor.publishProxyError(time.Now(), oapi.BrowserEventSource{Kind: oapi.Cdp}, "sess", "req-b", "future_b", 502, 0, "GET", "Document", nil, nil, nil) collector.mu.Lock() defer collector.mu.Unlock() diff --git a/server/lib/cdpmonitor/network_capture_test.go b/server/lib/cdpmonitor/network_capture_test.go index baaaccde0..ec768e19b 100644 --- a/server/lib/cdpmonitor/network_capture_test.go +++ b/server/lib/cdpmonitor/network_capture_test.go @@ -6,6 +6,7 @@ import ( "fmt" "sync" "testing" + "testing/synctest" "time" "github.com/kernel/kernel-images/server/lib/browsersurface" @@ -20,6 +21,77 @@ func sendNetworkFixture(t *testing.T, srv *testServer, method string, params any srv.sendToMonitor(t, map[string]any{"method": method, "params": params}) } +func TestNetworkTimestampsReflectObservation(t *testing.T) { + for _, typ := range []string{EventNetworkResponse, EventNetworkLoadingFailed, EventProxyError} { + t.Run(typ, func(t *testing.T) { + synctest.Test(t, func(t *testing.T) { + m, ec := newComputedMonitor(t) + defer m.Stop() + requestAt := time.Now().UnixMicro() + m.handleNetworkRequest(cdpNetworkRequestWillBeSentParams{RequestID: "r", Request: cdpNetworkRequest{Method: "GET", URL: "https://example.com/slow"}}, "s") + time.Sleep(400 * time.Millisecond) + terminalAt := time.Now().UnixMicro() + switch typ { + case EventNetworkResponse: + m.handleResponseReceived(cdpNetworkResponseReceivedParams{RequestID: "r", HasExtraInfo: true, Response: cdpNetworkResponse{Status: 200}}, "s") + m.handleLoadingFinished(context.Background(), cdpNetworkLoadingFinishedParams{RequestID: "r"}, "s") + case EventNetworkLoadingFailed: + m.handleLoadingFailed(cdpNetworkLoadingFailedParams{RequestID: "r", ErrorText: "net::ERR_ABORTED", Canceled: true}, "s") + case EventProxyError: + m.handleResponseReceived(cdpNetworkResponseReceivedParams{RequestID: "r", HasExtraInfo: true, Response: cdpNetworkResponse{Status: 502, Headers: json.RawMessage(`{"x-kernel-proxy-error":"proxy_connect_failed"}`)}}, "s") + } + time.Sleep(2 * time.Second) + synctest.Wait() + require.Equal(t, requestAt, ec.waitFor(t, EventNetworkRequest, time.Second).Ts) + require.Equal(t, terminalAt, ec.waitFor(t, typ, time.Second).Ts) + }) + }) + } +} + +func TestNetworkRedirectHopsPublishInOrder(t *testing.T) { + for _, mode := range []string{"late_headers", "missing_headers", "canceled"} { + t.Run(mode, func(t *testing.T) { + synctest.Test(t, func(t *testing.T) { + m, ec := newComputedMonitor(t) + defer m.Stop() + ctx, cancel := context.WithCancel(context.Background()) + defer cancel() + m.telemetryCtx = ctx + m.handleNetworkRequest(cdpNetworkRequestWillBeSentParams{RequestID: "r", Request: cdpNetworkRequest{Method: "GET", URL: "https://example.com/start"}}, "s") + m.handleNetworkRequest(cdpNetworkRequestWillBeSentParams{RequestID: "r", RedirectHasExtraInfo: true, RedirectResponse: json.RawMessage(`{"status":302}`), Request: cdpNetworkRequest{Method: "GET", URL: "https://example.com/end"}}, "s") + m.handleResponseReceived(cdpNetworkResponseReceivedParams{RequestID: "r", Response: cdpNetworkResponse{Status: 200}}, "s") + m.handleLoadingFinished(ctx, cdpNetworkLoadingFinishedParams{RequestID: "r"}, "s") + time.Sleep(200 * time.Millisecond) + if mode == "late_headers" { + m.handleRequestExtraInfo(cdpNetworkRequestWillBeSentExtraInfoParams{RequestID: "r", Headers: json.RawMessage(`{}`)}, "s") + m.handleResponseExtraInfo(cdpNetworkResponseReceivedExtraInfoParams{RequestID: "r", StatusCode: 302, Headers: json.RawMessage(`{}`)}, "s") + } else if mode == "canceled" { + cancel() + } + time.Sleep(2 * time.Second) + synctest.Wait() + ec.mu.Lock() + defer ec.mu.Unlock() + var sequence []string + for _, event := range ec.events { + var payload struct { + URL string `json:"url"` + } + require.NoError(t, json.Unmarshal(event.Data, &payload)) + sequence = append(sequence, event.Type+" "+payload.URL) + } + require.Equal(t, []string{ + EventNetworkRequest + " https://example.com/start", + EventNetworkResponse + " https://example.com/start", + EventNetworkRequest + " https://example.com/end", + EventNetworkResponse + " https://example.com/end", + }, sequence) + }) + }) + } +} + func TestNetworkHeadersFollowRedirectHops(t *testing.T) { for _, order := range []string{"extras_first", "extras_last", "interleaved"} { t.Run(order, func(t *testing.T) { @@ -81,38 +153,30 @@ func TestNetworkHeadersFollowRedirectHops(t *testing.T) { func TestTerminalRequestPreservesPendingRedirectHeaders(t *testing.T) { for _, terminal := range []string{EventNetworkLoadingFailed, EventNetworkResponse} { t.Run(terminal, func(t *testing.T) { - srv := newTestServer(t) - defer srv.close() - m, ec, cleanup := startMonitor(t, srv, nil) - defer cleanup() - send := func(method string, params any) { sendNetworkFixture(t, srv, method, params) } - send("Network.requestWillBeSent", cdpNetworkRequestWillBeSentParams{RequestID: "r", Request: cdpNetworkRequest{Method: "GET", URL: "https://example.com/start"}}) - send("Network.requestWillBeSentExtraInfo", cdpNetworkRequestWillBeSentExtraInfoParams{RequestID: "r", Headers: json.RawMessage(`{"Cookie":"hop=0"}`)}) - send("Network.requestWillBeSent", cdpNetworkRequestWillBeSentParams{RequestID: "r", RedirectHasExtraInfo: true, RedirectResponse: json.RawMessage(`{"status":302,"headers":{"Base":"redirect"}}`), Request: cdpNetworkRequest{Method: "GET", URL: "https://example.com/final"}}) - if terminal == EventNetworkLoadingFailed { - send("Network.requestWillBeSentExtraInfo", cdpNetworkRequestWillBeSentExtraInfoParams{RequestID: "r", Headers: json.RawMessage(`{"Cookie":"hop=1"}`)}) - send("Network.loadingFailed", cdpNetworkLoadingFailedParams{RequestID: "r", ErrorText: "net::ERR_ABORTED", Canceled: true}) - } else { - // A cached final response can finish before the redirect's ExtraInfo arrives. - send("Network.responseReceived", cdpNetworkResponseReceivedParams{RequestID: "r", Response: cdpNetworkResponse{Status: 200}}) - send("Network.loadingFinished", cdpNetworkLoadingFinishedParams{RequestID: "r"}) - } - waitForNetworkURL(t, ec, EventNetworkRequest, "https://example.com/final") - if terminal == EventNetworkLoadingFailed { + synctest.Test(t, func(t *testing.T) { + m, ec := newComputedMonitor(t) + defer m.Stop() + m.handleNetworkRequest(cdpNetworkRequestWillBeSentParams{RequestID: "r", Request: cdpNetworkRequest{Method: "GET", URL: "https://example.com/start"}}, "s") + m.handleRequestExtraInfo(cdpNetworkRequestWillBeSentExtraInfoParams{RequestID: "r", Headers: json.RawMessage(`{"Cookie":"hop=0"}`)}, "s") + m.handleNetworkRequest(cdpNetworkRequestWillBeSentParams{RequestID: "r", RedirectHasExtraInfo: true, RedirectResponse: json.RawMessage(`{"status":302,"headers":{"Base":"redirect"}}`), Request: cdpNetworkRequest{Method: "GET", URL: "https://example.com/final"}}, "s") + if terminal == EventNetworkLoadingFailed { + m.handleRequestExtraInfo(cdpNetworkRequestWillBeSentExtraInfoParams{RequestID: "r", Headers: json.RawMessage(`{"Cookie":"hop=1"}`)}, "s") + m.handleLoadingFailed(cdpNetworkLoadingFailedParams{RequestID: "r", ErrorText: "net::ERR_ABORTED", Canceled: true}, "s") + } else { + m.handleResponseReceived(cdpNetworkResponseReceivedParams{RequestID: "r", Response: cdpNetworkResponse{Status: 200}}, "s") + m.handleLoadingFinished(context.Background(), cdpNetworkLoadingFinishedParams{RequestID: "r"}, "s") + } + time.Sleep(200 * time.Millisecond) + m.handleResponseExtraInfo(cdpNetworkResponseReceivedExtraInfoParams{RequestID: "r", StatusCode: 302, Headers: json.RawMessage(`{"Set-Cookie":"redirect=true","X-Wire":"yes"}`)}, "s") + synctest.Wait() + event := waitForNetworkURL(t, ec, EventNetworkResponse, "https://example.com/start") + var response oapi.BrowserNetworkResponseEventData + require.NoError(t, json.Unmarshal(event.Data, &response)) + require.Equal(t, "redirect=true", response.Headers["Set-Cookie"]) + require.Equal(t, "yes", response.Headers["X-Wire"]) waitForNetworkURL(t, ec, terminal, "https://example.com/final") - } - send("Network.responseReceivedExtraInfo", cdpNetworkResponseReceivedExtraInfoParams{RequestID: "r", StatusCode: 302, Headers: json.RawMessage(`{"Set-Cookie":"redirect=true","X-Wire":"yes"}`)}) - event := waitForNetworkURL(t, ec, EventNetworkResponse, "https://example.com/start") - var response oapi.BrowserNetworkResponseEventData - require.NoError(t, json.Unmarshal(event.Data, &response)) - require.Equal(t, "redirect=true", response.Headers["Set-Cookie"]) - require.Equal(t, "yes", response.Headers["X-Wire"]) - waitForNetworkURL(t, ec, terminal, "https://example.com/final") - require.Eventually(t, func() bool { - m.pendReqMu.Lock() - defer m.pendReqMu.Unlock() - return len(m.networkExchanges) == 0 - }, time.Second, time.Millisecond, "completed captures must release their header state") + require.Empty(t, m.networkExchanges, "completed captures must release their header state") + }) }) } } @@ -226,15 +290,14 @@ func TestNetworkMalformedWireHeadersPreserveBaseHeaders(t *testing.T) { } } -func TestNetworkWireStatusPreservesEffectiveStatus(t *testing.T) { +func TestNetworkStatusRemainsCompatible(t *testing.T) { for _, tc := range []struct { name string - wireStatus int - statusText string - effective *int + wireStatus *int }{ - {"revalidated", 304, "Not Modified", ptrOf(200)}, - {"unchanged", 200, "Custom OK", nil}, + {"revalidated", ptrOf(304)}, + {"unchanged", ptrOf(200)}, + {"no_extra_info", nil}, } { t.Run(tc.name, func(t *testing.T) { srv := newTestServer(t) @@ -242,16 +305,22 @@ func TestNetworkWireStatusPreservesEffectiveStatus(t *testing.T) { _, ec, cleanup := startMonitor(t, srv, nil) defer cleanup() sendNetworkFixture(t, srv, "Network.requestWillBeSent", cdpNetworkRequestWillBeSentParams{RequestID: "r", Request: cdpNetworkRequest{Method: "GET", URL: "https://example.com/"}}) - sendNetworkFixture(t, srv, "Network.requestWillBeSentExtraInfo", cdpNetworkRequestWillBeSentExtraInfoParams{RequestID: "r", Headers: json.RawMessage(`{}`)}) - sendNetworkFixture(t, srv, "Network.responseReceived", cdpNetworkResponseReceivedParams{RequestID: "r", HasExtraInfo: true, Response: cdpNetworkResponse{Status: 200, StatusText: "Custom OK", Headers: json.RawMessage(`{"X-Cached":"yes"}`)}}) - sendNetworkFixture(t, srv, "Network.responseReceivedExtraInfo", cdpNetworkResponseReceivedExtraInfoParams{RequestID: "r", StatusCode: tc.wireStatus, Headers: json.RawMessage(`{"ETag":"v1"}`)}) + sendNetworkFixture(t, srv, "Network.responseReceived", cdpNetworkResponseReceivedParams{RequestID: "r", HasExtraInfo: tc.wireStatus != nil, Response: cdpNetworkResponse{Status: 200, StatusText: "Custom OK", Headers: json.RawMessage(`{"ETag":"v1"}`)}}) + if tc.wireStatus != nil { + sendNetworkFixture(t, srv, "Network.requestWillBeSentExtraInfo", cdpNetworkRequestWillBeSentExtraInfoParams{RequestID: "r", Headers: json.RawMessage(`{}`)}) + sendNetworkFixture(t, srv, "Network.responseReceivedExtraInfo", cdpNetworkResponseReceivedExtraInfoParams{RequestID: "r", StatusCode: *tc.wireStatus, Headers: json.RawMessage(`{"ETag":"v1"}`)}) + } sendNetworkFixture(t, srv, "Network.loadingFinished", cdpNetworkLoadingFinishedParams{RequestID: "r"}) - var response oapi.BrowserNetworkResponseEventData + var response map[string]any require.NoError(t, json.Unmarshal(ec.waitFor(t, EventNetworkResponse, time.Second).Data, &response)) - require.Equal(t, tc.wireStatus, response.Status) - require.Equal(t, tc.effective, response.EffectiveStatus) - require.Equal(t, ptrOf(tc.statusText), response.StatusText) - require.Equal(t, oapi.BrowserHttpHeaders{"ETag": "v1"}, response.Headers) + require.Equal(t, float64(200), response["status"]) + require.Equal(t, "Custom OK", response["status_text"]) + require.NotContains(t, response, "effective_status") + if tc.wireStatus != nil { + require.Equal(t, float64(*tc.wireStatus), response["wire_status"]) + } else { + require.NotContains(t, response, "wire_status") + } }) } } diff --git a/server/lib/cdpmonitor/network_fidelity_chrome_e2e_test.go b/server/lib/cdpmonitor/network_fidelity_chrome_e2e_test.go index 249b12432..c9794b26c 100644 --- a/server/lib/cdpmonitor/network_fidelity_chrome_e2e_test.go +++ b/server/lib/cdpmonitor/network_fidelity_chrome_e2e_test.go @@ -103,12 +103,12 @@ func TestNetworkWireCapture(t *testing.T) { }) t.Run("wire_status", func(t *testing.T) { responses := snapshot(EventNetworkResponse, stub.URL+"/api") - require.ElementsMatch(t, []any{float64(200), float64(304)}, []any{responses[0]["status"], responses[1]["status"]}) + require.ElementsMatch(t, []any{float64(200), float64(304)}, []any{responses[0]["wire_status"], responses[1]["wire_status"]}) for _, response := range responses { - if response["status"] == float64(304) { - require.Equal(t, float64(200), response["effective_status"]) - require.Equal(t, "Not Modified", response["status_text"]) - } + require.Equal(t, float64(200), response["status"]) + require.Equal(t, "OK", response["status_text"]) + require.JSONEq(t, `{"ok":true}`, response["body"].(string)) + require.NotContains(t, response, "effective_status") } }) } From 1271f74c2ae19f7f77ecfa8c1daa0699b32eef55 Mon Sep 17 00:00:00 2001 From: Sayan- <1415138+Sayan-@users.noreply.github.com> Date: Thu, 15 Oct 2026 22:20:59 +0000 Subject: [PATCH 10/15] Regenerate wire status API bindings --- server/lib/oapi/oapi.go | 936 ++++++++++++++++++++-------------------- 1 file changed, 468 insertions(+), 468 deletions(-) diff --git a/server/lib/oapi/oapi.go b/server/lib/oapi/oapi.go index 87934b711..7ce8bb43a 100644 --- a/server/lib/oapi/oapi.go +++ b/server/lib/oapi/oapi.go @@ -5371,9 +5371,6 @@ type BrowserNetworkResponseEventData struct { // BodyError Response body retrieval or decoding error. Absent for successfully retrieved or intentionally excluded bodies. BodyError *string `json:"body_error,omitempty"` - // EffectiveStatus Effective CDP status when different from the wire status, such as 200 for a revalidated 304 response. - EffectiveStatus *int `json:"effective_status,omitempty"` - // FrameId CDP frame identifier within the target. FrameId *string `json:"frame_id,omitempty"` @@ -5404,7 +5401,7 @@ type BrowserNetworkResponseEventData struct { // SessionId CDP session identifier for the target connection. SessionId string `json:"session_id"` - // Status HTTP response status code on the wire when available, otherwise the effective CDP status. + // Status Effective HTTP response status reported by Chrome, including 200 for a cached response revalidated with a wire 304. Status int `json:"status"` // StatusText HTTP response status text (e.g. OK, Not Found). @@ -5418,6 +5415,9 @@ type BrowserNetworkResponseEventData struct { // Url URL relevant to this event; page URL for navigation and page events, request URL for network events. Url *string `json:"url,omitempty"` + + // WireStatus HTTP status received on the wire when available, such as 304 for a revalidated cached response whose effective status is 200. Does not change the meaning of status or the cached body. + WireStatus *int `json:"wire_status,omitempty"` } // BrowserPageCrashedEvent A page's renderer process crashed (an "Aw, Snap!" failure) while the browser process itself stayed alive. Reported on the crashed page's session, with the session and target ids on `source.metadata`. Captured only while the `page` category is enabled. @@ -27172,470 +27172,470 @@ var swaggerSpec = []string{ "3IYSFbmy2LiMphD3dOb3WaEk4NRWcBAqj0SP5/vdz/cIvFsTgKW4WhMI3Y5+m2tlxQ5nP1VgRiQCYa39", "JfO1NNHc4fmTCiL5w6b4Fweq1mfaeDkXqZXx9IorRHHUpT9PRVR/ehWjsjqPOkYHHYPW61MoGas7c89a", "BlBt4yb5naiRdylmEfRu6gHl2NuTt8cEmNQoBKGqh6tsODyq7GOEM1Jc8YzhpS7RaOXBqjV88pXHPawk", - "vMODE4qsstmSiRsUgym0LltGJ6ZTgSC/mECoKeXYcShB/j5Yini6xIuNbtl4pFKZPowTZDV7dnjo4XkN", - "zE6muLZfHX4d17c5KuahVDS/5r75YVftQU+rV91so3a5kIu2Uy+SS2gwEhmpIkBTB3O3yPoBqhYqYmaI", - "zXf3h1mun2BHTV2tXVFd+/7ABWoNJVAbDzkR6LxYtQtggGrhX6WHj1aI35iW0u+1SQT/gOGplkqxRKei", - "pliv0gjeDq6lJd1VNEiVFthS/K3FENY4lApczfsf+uydduy1LlS6f1tdzC9EKZE2Kl0AAf/ScKDq9kdZ", - "PhNPLDNCpcIIE/08E6rH9rhiF70X1312pnj+f130grfLPkA/ZTUQoVhZOiuyKazCEpgO/O2H7ENIG+D3", - "JvTgR+DV934lCIi+QdKImGEWqo+J+IcBZmgMsO0+JNrjwIahjaH5MQuHPpMxAWZXKz40cFcFb3UnHpW7", - "VuUO3f89bTygYte4I7u9Jm+AuivBqapHRAiBqRD+p0W0g96hV6QErfwt3bWz/3Y51Q5LB6PYsgGv9OIl", - "wdrAu0mHh8dX79/WKgQkX1hvaHCYxhaxLbwldkTuvS8+b5zUI8NvZvhUL0Ye4Qjf7B6c99t36b7f6tJ8", - "FNetQVKQq+QioIUy8vzyiZQU82vLuPNQi2ssMIX16DMjMo5qjNNr5zH5Ou4p7WjXEKZ1f8h+tIKNnSX4", - "xOu631lDON7K+tdntlUTeYNxXl1RUigqrAUl5alfFq/Po0gDqqn4uDhhrgTiHYaW5nKKJtDSJn0lbcEz", - "WJ2JzKRbDtkxAK5WK5BLKZmAnw58rzBp8+mEyqOzTDcZUg8kfGD54akZaGQrLSfFovDMWaOtvZdvzvY9", - "aUfDxakwuAAqEexcLkQmlQDY0E97iK1O7/H86kZ7sGCfmPIe5NHT+/42pFtcieeuEbRQzizXHJb3fKYT", - "sr1VK1iWC4M47vuN0d/VVR2lwnGZ2d3D3QM7VRaOceeMnBRO2C2ch1Na5705T8H/HNQVzOi6maRri+Th", - "0BKRkjsOYq1iI+E1C503+95qipnAvHx4+easmeRRXWiIkK/2axNtgq1IWr9XkAODViKEbrw5228++tdo", - "0hurdoRvD1Bu+H2Zdaa2RBEtvvF2JJsS6TduXsnvTdS6HX9gNdBuZcJ+LCUSQAclKMm3Hhdv4BplHfNq", - "HoCLnHIJ15w3L09/q+dFkpfC6PGcaD8nkvyhj4fqTtzzsZAl+S3FsKfpkqSJou8qhj1qWqP0kWnZfOD/", - "Ny9PS8RcOQ3vaK0ZJEbNwgZuXkgkDe12gjVROm0Xma/ev2VQoEFqVvpptlGTIadl2B/wx64Df+4PbCB8", - "O6AXDY9gFmMWz+VCqtngRZbp6wF5hzTOF3ixHd+YG8FbBkQAcsz+q+D186Bse5tfVrVFmA9OgWmI5UiF", - "Dj+1pGN42EOvOjSQYbR7D3DuYUdNytmtD73tJ53m22/55c191ZCXheqfw4QXx/54nG05zjR/8It2bS9+", - "48Y5N6+R85dimitzfHfj2GoKI0J8WeNflBe+XeBf9pIbIwUm94loSFNKhisVSq0J5sJwzOez8fkRQ96d", - "qiVuNePUp5UOK6v1KCM2y4hysx5YUjTty24verc71VWgciqxazqyd+KabU5Jxri1cqZ87BuyxJasZDk3", - "oBa3z+eUe3eplSmRVxclt690Yp/7qDkaQUNGMtuCKL9rurF7Syr2aV9WSxpw+t4Se5HDbUXzKqmoMyts", - "fm8JOdnxIbjlIS7mNVsxsLM5vxJsot2czrnohmTrtFN7cokv0NKySvP0EoN5jtA1nZ2oVORCpT7jSTUY", - "9jnjDBLpZSIiDgbXqogAOMGzUrpP6ePx+Eyz63nwiZ5qzvnkfS7UhkdHJa6jguP4hOkoT2BZNVYm3YbE", - "wTAELZ9r+gJpH+ma6kHeNri42BAlwWsYddKWYc/R9/w65ta0ugYGvC3E2etL9eDmiuIUuQLJD/TKpsBn", - "wNNRtlgIY5kRFNe9oqdhcrqQkGyOWGDOCO6YdIxbYMtcJJJnOwVJ35dWVt/lR6VsMxM6PhkRXX9S5ruF", - "ToajbNaczts8rICH0e/Xsy4yg1aCAqDUclclo9mdK5x3Slxny9gVnzyI5uGkyxrMPxRwl3nZA2WiViqu", - "WwfTqMaEpiqms/Y27s0LLOMOaPhFLiGVZ6uEBqFDW7rgCk2QVb/Tv72tIRWnRl4FZcMX6bM5V2klAJ6S", - "Ww7InjngufR47UfMiATTls1YJqciWSaZ6LOpzITPp4nqkL+902B8AraIZAglKmnnp3Lm34eG7HwuLBo8", - "2UJbly1Z7hdgIFVaJBEKMjcaumSWX4k+MyLP+DKk/dmvTZbPENE4ISW8q9D1vd5Z8DZs36PobRe9frkg", - "p+oISPohhW/b1uwOF4/MV8OKX5tIBIpnb0OWYHDEPmI8UjjxcBLMQBrumf764S8cqPk4tI5LLDFOdCrG", - "foe5LX8DH/DYdRPR3xaenqSE6fSIA/1RJ01nxlvEn08p/f0Ty2LpPqY0C/PxYge/Q8f5OASf8/iURM3x", - "jUhA+0NQ2A9BRI13B9GADW0IX4nPb+uCMZReyDTNxDW/ryCNYRc0ukoURG29K7EQHYHqTo2+WR4bo80G", - "IydXqUDxfrMcZHwpTAh3YHriszXXEVSGrHaHhl/gENBMELr+XFs3wPZopy3jsRsCTSGH7Lm2lQCswCUY", - "wfBfA0oePcAZDHAKYx/fdIRYX8/o/rE+aotxr5x9ffhVOT5/tXhiY5RtrjOZLOnWTJ2mwjqp/KH1Rl8P", - "rnRWLESEuJc4EVjqlPaSnTgbDOPo1jOohm/AZ9ArwoOs9FCqvkyI0vIoUf6c8yoIDdE6I/jiiCYZp4cn", - "KUZ80PYgfkEZ/AF6W2gg0ZnPvyVjLmwvcKSF77hiOncDqZgRU6noVS5ExvHrlezt9TOYpWLKi8wNYL6Z", - "MGjrAJsdzz4xWNQKlT8exu2HMayUj4d9wGO4YT/u+xFLp6Ixn36UBiRooNzRJpFi6gGp1dyijUKrLhBb", - "xF5MaL6QWBOBQKA8/oou3faoKm9GKIZE2q99icfoqFCVOL5gFCTpNUqFklArNxpe9s1okvHkMpPW1b4t", - "lBE8mVMT8VsjKIlm34dujlxm8QVNFy5+F9ZnJBVsViYcNXGzrA/MCKAiaK5p2EVOsqxsPn6TKjvyoq3y", - "bR1Je8he1PeH5Bc6NVQyoCR6poDhpGUmBN5xywp1CZGflSi7Wlsg/DikxUm9/SYwS8P+9Pq9jRvU6/ca", - "d4ik4doWVb+u7FH167BJoAus7VL5ZcM2USv1fer1e5s2Cu6uKztV/aqyVdWv63sFv9CCr0uYfu9mAKs7", - "uOIGlT9Y5lflgn4XV7ny5QcY5Y+1QfqI4FNc4ldhhU/9mn1XW+Dw7Y+19Q3ffiiXl1x5zjN7HmdOX4WY", - "9ZPq0qIQqY/qQ1zZhiH/6FerbDx880rZ13FRw5cvq7juoTsUWT+Gxd0tcJ42pwyXRs0IW2rWpj1HNOQT", - "5Uo6SC6yWUkj5lpBbcBOE3TzimyJqhalM077LJlzwxMnjGW6cFamgv2DD345HPx59DOZBJIA5zTqMzCN", - "aOvYt19XKhITL/jNG6Fmbt47+vZreBx0ThgY//8b2/v3f3toML5NIAX3Fvi+ZSd3uqJE5N+1c2/vm8Nn", - "qFjfRa3e3/X6gyQY57DRp+ODyDPvatkE4oQ+ZggVbuQChoNJw/wtWNyIhBR0Xbi8cEw6sUAdq1KBIEQW", - "PM8lQSrj+bNFjYFRIXBAGFq/R7H0W2sBtECo9DEq08t3fAF9Om8i1Up016nWm+1crTaH1WWv/bibpRsU", - "6NHk26/h7y3Y0iu4HhWOxo04aKqxlnp60fzysqr5ktJb9tcvB7pB74W18IhkO1qcfC3mtKdF4cUksZlv", - "n304Pn2zfrFqFNP/ya84oVgwgH0pAqAvZ7kwVlrYK/YOdJ5/4tUQfawu1Hl0c5hIfGe2obxP4wbDeXF6", - "Eq3B4kY628evYXRM2gvlU1JoU/2aOWEC4wXEboy4xnJ0Kg7ZaTk4VBAuFOa+kFciPMwNZpme8IxxhOHR", - "xh6xJNOWbsYhUNEG0wXLuANrnsiyC0UuJeT5yl4XinJ3pCLJOFlTLCusKN/zQxeYvbqCs3Kh4GdstN53", - "rYPvDE9EhhbzInNyEPoBW+IVN+MLBWKNHHGZEY7TZkvjX/oH8WecutHZYJrpa2bFgisnEzukdphUF6ri", - "niJszA9CbfsNtM/ZNMyZ8oNAwQG5DWQ64Zllqb5QSrvK6oyHsA8EEW0E3X6es3H4fZgb7TQwxNDpM+Sm", - "vf0xZGe8UOIm13458RXVkyBwLexfJrkdsjfiBl5XabfRtBF6ISq5UJlUl8Fu4XPKBG2msnWkE3B8voG2", - "gKqQDiMNDi/Ui1Ax872WudIMywS/Et4qgy145jt/9ffn1Z29UAmHRapUZtJhSmAnk4qjkFzk2rgwKdIz", - "nyOFpUvFFzK5UGMqs7c/HrLjm9zQcRowaqAi3WxcYRSsSOH0gjt6jh6y9/6wshdK5yRpnpPcgOyYudHw", - "usKULm3NUJGNjciz4bWRTuwNh8P9MdPmQtG3YiEdinP6pY/DTbSyOhNeoyT7WqIXE3S7RiPeQiRzrqRd", - "gPb1llJzUj7IUu+j3QiYiPAqRGD8AbwOzSTkHPAn9lZ+179QyM9e4NAKWth8hN4KuQtSLhZaRbVMX4Ws", - "IPj9E0uNXShfYIBul9hX9OgPkimocJ5aWrQ24fULNH61yPNz36KoJQWFdvve+zWk48QXWj9PFUX1qq24", - "ajEiUTmyIqmN49vD/po1/kYuikVFuwm5VYIRib2i2rD83x4OSW2GOr2jrw4P4QBU9OnpVrUNT6GtZ6Mt", - "st2PxgBCWj0FiczjzBoOxTZN0DMK014lRMQvHx9B/OQZJxp5Yi/PmfZ2b208eSNlKx2qUpwjVe/1e6hG", - "djRAVvXXMgiDG8OX8Dn4p3UxTIobx8qgj3JkIVmuNuuWyngTIGtl5bQjHID+4eHhAOYDlmqGTtCGL0Pr", - "kwLB6FI2Ee5aCFWumW0k4q5PVeukW32hajR5toD94eWULYS1sCiyqvNHu0UDt+dZ80Xwx5NXz8IVcBkW", - "SdzwxNHJO5jrDBcPiTUoS4gEHPxZL1Qcwmo+eRDTpFGgN74sFpUU88/hrqtmwoYDkisvIFGyQAxtnslE", - "upAarL6I3rjnuQgUsFZRl2ejUmnbbAjH1uKVGFnHLx4ZxmMzxFQl1vCF2oujQl0i0Rnmri5yejjEt5xy", - "sAdAt8Vs7iBUWOR0q7xQ5ytQpizjv0jyrTTORmmL7VQ0BT/G2gpUyNQ6nlw2mEDga8yr1pmSPGpkA7HP", - "hX9TEVWZJtIa0GTD6Fbda30HJdFuEcbVi+BudzYgPyUavGlQpWB/YaV+AaddCkfsX4ISMcz07ECqqT5I", - "xaSYYQFhTKXANTfqgLi4tMVia2gJSMl6RtUaX44CWN3W2yAW7HoZDLPur1ZbW90zYa5kshWFjvxoUnxR", - "kInAmxQaJcRNjroiqHgnJaYos07n1j+R07uwNoMSc93OC5fqa7XPUo1qY1AAK26R/+d//W/SyMpesF9/", - "dSIuzYIoGczklRgUOZC6spJuSKnu+rpHvkN3fdxrWM3HB77WBz5PTJ8ATK5tX27hagNN1H1tVqZRetoc", - "30hHchIIll6b4z2JLpxRbytUKkyGp3Pdd83EJLueqfFuiXwRvFOAIek4c0uybkTHOJbPub/W0sgDcgOT", - "ilT5vTr65j6WPT155W+C9DLVxEXYckPodZeuh2yMTFvkY7YQXNnw4IgTT/FQJr9siXishuF7iEgZZ3PB", - "MzdfBhcBUmGGbOw/hwY5y424krqw2TLWqfVQF17jGb8So+YBhZ2IKVw9Jp+/HYWssbjLjtRWZ2AvnzNV", - "ZlJuIxTKqDyVVfCPsK1kx7IabrOVtKg2hk5EXqLlhCOV1qHX7/kZNQq1vNH16OTVGgYiLUFElY7W9NW1", - "gc5Yka+nmW5cJnIfy7SCqjHpKyfj2enJqxaAV7+Aii+aH9Rnhi+8RaU+jbCe3mcr8ZoqOGwtCueEgb/W", - "PKvGXZJ7V8fU91yxSRThQfNeL36Qre60oCC+kaq48c5e7P37t4NLmWXChHMPLZNxE6TC1yeY8d/eDhmd", - "HCl5BowPUnF1cLmws3GIeQAy46pkB2x6xfM2HBoLsdBmGTdUq+pty8ffRnRKW0x8myICO5O4s0UOC2VF", - "+olP5LXlfjyQ2w9kXKyR1osRkMRDHsjN27L7eQzjXDmO65OIx3GT2cU6w2UTB/40r/OCSGRK5r7AikM2", - "VlqJcFx4Q/8atzxn44VYJJVjKZkZXeShpDfuccvmElIeJnlhhRuzA6ynzdL7ZlDw0Lsf3744oC8G4EQP", - "j6kyy0rxrJUfsmU6S4P72zfDQx//nsqUtA/oFSZonSkSAmYea73AqR2NWSbVioMJTBaRrhcJnC00Tvqi", - "HGUjty7EYjQ1QowuJ+sL/doIwWjLwpJIxX6Q3zHvhVQFQ4HB9VkqCCs+esSOofWjd8EP2ZvCaR2eWPZW", - "LAYnaqpZWizyIXthbYHme/Y19kOeUvIXMWSvgntOAFw3Ism4XKC5IwEFxKL2xZldgHGafHL8FT3jZiZw", - "10ZOO56NLif4tsCsAxqF7acVp8lec+oKFT825ybFNwuLeer9bsppZSb1veOUWAlHFidofVrpC9XI7tWh", - "NQgu+OXOW/EO19OyDy/eEhXdYTseZhW2aT7+MAyKT3Mb9GOLIvJSLxbNrTFe8faqH7d7C37Dnn6DviG2", - "XzkrasVa3MmtbdzSD8LivYBZ4eiwaR6V3+Y9W+C4udJqYKylqBr6C3Xb+UIs4OM+vIiQUy60ls+XFl+o", - "PNVU1UMg88KictdMRM0L7HQ+ctxe2iY6zVmpZKDtjmY5sMINcJa+q4WuuggTxVpae2iSYpNXtKUaqY7P", - "YQh0wxgzH/l8jLb0DUTpA9yg7EuOlwHu2DdMKEcu45pNdKHSeGohsSOx7mKCr52gME7kcH5zQm18s26V", - "d0bOZsKMtjGAL1e5inZhRTpMuEpBko1fnv54xN6BJg//AYY4is5W5dnSsO9hjJ0ZLBIavu3xDB6HoVg0", - "rlZy2vlxO82kutKXpDCXuvWQvZ+64CyEb+qWjasjGbO9SjOeiSr+TcLsI0hKwkPKm/K+5CslNMxKRpwr", - "mTi5GLK3Xfi/0fy9msi8unYk76KI6KqSIUHtpo29iEH/fkcIz2obV+EpsKabdd/3u8jNbZyw8QzoLnTr", - "p+i6VOrgaEab6Hd0+15WQlM3xcpWcwtRgOqcR1MsUXZMhlMLB+/3JEa89/o9cKQTptfvTXhyCaqtSke+", - "TLgaxyJ2zo1Iy8+Y6KVRZwzzCCGbL+lyIYV9ifGatwqS8xlGyjjQEMdihXPoPgQXiBAY2npt4LlL5rsH", - "CazOZelnsp5I6SX1wKzOrkSwmzBduEQvBGWh8u9rHgH4ocaRSUEYkDyZH6TCIfh6tO8F504gKIoVACUB", - "LThXUlyHcVqdiYccJPUQHnf3Mj3rM3iW6ZNH6D6Oav0hLq6jMzq7w/iogdbhvZiBZuLvaj4ImPEZl8q6", - "Wog0vHZAfwW6gFGr9LbaZ6cZX14bTMtfdyXoM5sYIZSda2f7LMlkPtFwAJM3WL8a6Vw2qhcLrtKQ4fRK", - "rGyjTybrhOEPTWE/ErRy7CpYRPeSTCaXts8uxRKeiSxOVGcgxz/GsIUHHJh3OMZT/SC6G4R0RkOCcJo9", - "JF2fIvJiZLawMFXYHsqnu5I+ASCIaXwhhPwhBVWW2WrUv7dArgX717NQ7cUI/mrcfj8ct50i9feH7G1z", - "gP5zpqdTOP29txG2QYGDuC4lxzzk7gkjdSoTNuFWfPv1IDiAgWDMtXFVvh2y7+VsziiAc+voca0ecOTf", - "lZAN9GpSZmfUhRvo6cDf8tDwhMPzj8ODYGQnozsI2I8bVJSWEe12sL+s0oRPHenV0OoxTz2sn+U+09gm", - "Twdpa7nJvMqQwms3q+ZuZlZkdCJDMdqxI/LBIpcbab19as+fm9dznYnY+H7p01l+CcTgLU7Ql+/ckvNO", - "tqyWlcKixum091mE8b04f/l9Jbt022ish+niKjhC4m6x8a8fx/swHc6UHuj8eX1w5AdMQfHBbdC/xp1r", - "n8UNE5RKi3/ysuqV5DS6Plvqgi0K63AUOITgEjSGiYDDJxvj5o+bXV86EVma10/q3cjsrKogop0LADz9", - "QRrf8eCHV+LqXOvMeo2IjD0NWmTIuDryfqoN+AT0A2woUgawX1DW691TFNaQvQ/38ExaFze2sqtK7JP7", - "HIogcSXMEh5mvD2KRgLP1klWRBisCh95NTkAR6gybawfClQga6cRGaYW9OBZQYQXitzB0j6Tjlm5yLPo", - "+4svgj55NICrSqTl1Ogcm5jL2VxYF+Lc/bKh2jQ+UXnhhqm0OQQ3vdWFTwQMt0tDD4vzYsEVRoIlhSnd", - "5IG2EA7Vs9ZZFMtjb5nlXlQn3JJLSnTELYwKznR1Vgau3d2ggySKy0g7v+5Y2YnQb0Pe56WobJCnEUjh", - "bF3CVYgu7PGlWDbRHo4Yya+KHhBOOSvcEctAw70W8G+JxsEz7zlhfS4MnfVZef3ps6A9+HvZ/pD9RFk6", - "xn5E437pLlERliB3rHAh2+QRik18ZQky/jk8ktK7e/ClhYlPp+QQDgpzpb09f9eJcc99vFP3q/rtfp+N", - "bYXEEB4uKDD0xNNw/KN0nAhYcgpK0BBjHKfnNy3k1qIB+1mxJBPckGhyzbtMkxkvtJIOQiIjFSOeXonK", - "QNrAPj3du7INkOxzYcRzzIKS6Wtbd/1HExj6cPDqktVP04Y3YT+9rmBcrZYCSKxNZUY+AnDXJs+oWtke", - "+O4Yt2szx1irbMU6bfwdYqfRULXQTkehcOujb13DQj6KF1SvWrEzvhBs7MluXAb+IPCgWlJS31i+z/Ks", - "sHXDS0WIrN9V64aGcKw2uRKk+c4ks6ocwBY/aoZ/DM2wxpW7scZrba45IdHpadz/ipx1mkbto8hqmD0r", - "ALqIulGhoiNGQsafOKxQGUUw0gpgTBFJ+Lkwoo+Kk0+krULVSn/YtOdkT6JEOHvgsh2C1cFWFo863wiF", - "3Hlsd/+d00R+1YeSUK1CdKAhQcHnFMtJNFfpgcisStyBVLyiGdXFJkbXLtuZ09+fvzmti+EuJLJWazcy", - "geoHaFDyyxek3i3uow1EJlF6AiGW+na51Qx6r1Pe+5qGMWTfc1K9Mc862wuDdHxpmVQcc6/vx+ChrbR1", - "a06sH7O7rfGJd38tQQGw7QjoS2Cj18oGuY3L6POJwnM3STeiSLzF8AVGHymn/UUpLj3eUeAdazXJOdtb", - "QQUOn/DtcB/FNS2fR9W2TkODZA6z+Gw4EeyfWqr1q9Pa08yiExcT+1a0wOAovDNTkrNLZEmcQDwW6OUm", - "9NOM670JHT7sU83zs3wOan4OXK2smsH9O9FeTanajfZeeSXY63MtZwE8AoYXUKQgLC+G7L2qcKM/0kFx", - "DnsOG+PJljbzUojcMqdTvnxi2UTM+ZXU5ojJrtRAnmhe1vThaJGXoLshaY77/im9qc79CHP2Hq5j3mgS", - "l4pQ4cIiyjhAvBURp0DoGf2sc6FsiZE0lca60FSd6ecc6LFsTKVetEETUe8EQ3uQHVJZx1UivKN9gqYI", - "aCakUuHRtwB78EoMdiNtjJ6m0X19+OcmXriloL82sNiYB7KZmHyMrC2VvTPhGJItfAWkExZeKz/zK+Et", - "SJ6lS9WiQdbDTRr8WjCofCKYjc1jpH5cvHLxA2hgWL2ww3tfH/55v/tpEYILw31EHIfYyV00No8ViU4J", - "Ew8AGpzBy0MM7TzeB9B6z0mKZvAQX2v76WM1GyO5WgIlYm8janrBkauDv/xB+TLiPT4PQJFUQNkHHn34", - "IJUWgYfB3PA85rjwDcqA1ODjOEE/4k76VNqVJ/2VkaCjQbWlxhd660S+IWK5XEsoSNRQLl4ZtaDzUVh/", - "ws4xrvoF/inIuxSWut+Li2AJ8QbmHwrKYjGaZnxmaX9gibb7MIc5hy1scqt4Cc+RaFfsCpmyYssonGtK", - "1otNMvqV3JLIVISyo7JOmZi6Xr+HT8AwVAR69T4X5OoN+l/jPuFLagtu07n3/8Ay/nW60iu8vCJ2Ws83", - "09gBBA+PLsWyyYStUwKdgp9hflA22GTxjMBWK3bSljDI0olNFYsR1rI1QIGnq5z+DlGAUaTLhfCMlQvv", - "gxP6XffquVmfxX+xRONzJS/zVNKK5ZoCDRtbWq639N+3aWmFXG960HQLkdLr/+0iZUMk6or5x5/ipWsB", - "lAsgHdtx59vCT196V4cXpYvBLVzNgsOEp90qJBG3LOcG79acRL03dMJQgqs4WWa8iL9QZSs5ZW2MaBcY", - "5Y1uAHjdp9qwCGjmgAK+bs4NXwgP7XbsjTFaxd+pZg2EDQYUbbweS7E5SgZZeQEyY9vFd11gQdiM4bNu", - "1V8ZPlutvdBXolvtt/pKrNZG33YQE9sqn0LBH8SyUpdcP7ZVPMNS1WrCjeixZ2tV4V5iwWrtTIit9oUz", - "KORJuBJPsx7NFTzt1iisdg5X9re23tTyCJmpupRxaWp7W5t5mMjPLYBjo8D2m6YJ5wSE4MflaYo6b+Ry", - "I7gTr6TBJ4Tl7Q7PRSNmWNQ00tA6g4JsTycYx4Cz7DOM9/uPb77Zr+vG//HNN6jEVZAWDwf/8fOvX/W/", - "/vhvzQnb3LwhMH5idQbSphwEFIQeEpz6SicHw3/f7r4LPTUuZmGdXvwkJm9fnr4SUwym12rHxaRLeGVI", - "iRsByOTPHmny51+ffdW8ApdSrdbdgweu/1+S5vuNNVDKbZVUlVkhJH+479ucJ80KtdN6qzSgBuEpPuQ7", - "WFvo6FJLPfkZhmH7brZtxNswxx32oDDZyK8ifm7XfhZSeX/+pw2PwdXJ1NrcNmhYFhuQYnccPKxKfdRd", - "d7dCsx+3zIY6aZrGK5EJJ065m99OmGzh48C9KXZzn9xLA4+JIW43+iYT2sladqUyQU60hIQZ9UkvspYM", - "jAex6AFevYbsRZbPuSoWwsiEacPmy3wu1JD9NBfR1tOvPd2v9yat7y1dlbF88MuLwd8PB38e/Pw//q2b", - "pe4VXfE6WubqyzVHX4J2pTZcn6lcmc68JXM7wvKMDHdie5O+NIPS0PD3v0CkAmLNKbDOySm+oqfCiQSD", - "hfYbO72WqZtv7w2LbRx/49KuankPc6kF1aTlQhsvsnSzbYz1FnDBr9711rDjXkGRVbytiO7lBwKX2WD9", - "o/QPTjPQsRjPdEx86TBVcYSSO2zak414YD7lGYZZlslrVscWzI7AuUbQCsFYFhFiwS60dvO/kA0PfWyg", - "TnSsgFstzGHCLb5S+A5RfGUIJV0DyHt6eFiDyPumcWJ3ucnDFHa6yDcL4oB9jB5sesr+cdNny5+r1+ac", - "S2Pj3rm50cVs7o3HMIgZxvS9heuUv58x7lgmuHXsGcu19EEdcaSrQ64GzMZwumfVs/jZ+mw2/kh7WaNh", - "2NcGZ3hyUxugPf478QsseFJgUppAzbjD13xJE0Fzq+AInJ5JJbj3ps915h/7UG5jb2iIs6Mc/WBmSGnE", - "DiIfIZONFoTiKWcKje0tKGOV4rUpfbMjX8ak6ziutR08oVGsc8NW/lybZ91SdNhuKopDQtqiceXCsLBe", - "PpQZxUT7ANlbGh57WhvrdljKVt0hmrq7Gp1XGt5k2jwme0kZYnJvoNArUSsdsaDhrklY0AcVWGgoW2mb", - "TDn4JT4xYLQL/P4EbiRP+uyJB2B+QhacJ/4V9Qm74kbiaw2ZZxZ5Jo7YRY9fc+nQX284007vPZk7l9uj", - "gwNBZYaJXjzZf+7RbVmluJMuE3v7zy96zciENOLtNohytY59DURP/wJBVBso6k5Qqq3RT2sUdb9wmmHQ", - "69YcegqPSMc+0hQHt0cJTPd7HyPsXxMkI4VJ43jLCNnqxBreWxBMsL0xHwDXsbV7h3js9xyfdCfycz5p", - "hYVsJir/7PNjnmmevi0yJ3NOTpirnvXxgagBnIzUirIMc5oV2CS9foK3C0f0xqgXdIlMfk1oK/AjtIgv", - "734XfE/enfxgrhfigIKSywc9e3BRHB5+lUB9/EusXJxeDP5O9pnhaPDzr0/7z775ptlK84vMR/jutTbE", - "v8uccZPMAzw9l8p79hUq55DKpgRwLUe95+UD++YQoKmfk6E64KOAT/1UWDf8p9Vqvwo6NJGKm+XW63Ic", - "rvfxaNr6ihZ2uItJpEIITc2+lpkAvJD1LZZ2lEqzmTdQD0P/x2j6a1aYFjrF9EQNxMitA5ulnEoPWQDl", - "atBNKXdigLWbzGuN5ydMiyyhE+k8AmefXfRSc31jBvD/ix7Thl30BuZ6YAbw/4ve/i5uN9yKGsgabCB5", - "c66vRGcLarh7rdWDEPrRZOlEAz+f+fB6/HnIDtm0MgwpbIfI+oCSwPF+WumsH+igsod+0dvIiSAUWkDd", - "XpcZiskRpoyt3538ODrribQ7Hd52L2NXt93U3aik+QnFY55B5oaKEeHlh+MX58e9fu+nDyf431fHb47x", - "jw/H7168Pe4Ml9uqeP+g9LVa8xhu3t9Xzel6ov9eqB78b0TwryLtgfx5CAe9hNfhEaCLZ8zxG630AmOv", - "fDPBi6ds3bvykA/XmPwSwRlDmwUedlrFvUZdGIYyEZCrY49eQ2lI9EzqXbzH7esw7jMjZtyk6J6Mjsya", - "5cUkk4i7KB04C2WZMIPyS78A6On9/uycHcTRH/ifAmpghGgL/pCYigth1awQbLwylmhXuZZGMDvnucDs", - "hjKNOYS9Z53H3qmG4ksbFzgAG0H3YAp9YgPkfPCeuVBb8i3FBNKbPZNradX7AVtilMxhmGomRkEN3Rw6", - "RtVehlqkO682inASOzV4BjU2NeZ9unZo7YxqxObKOMbO4XH1uhgI1qUuFqzWhe3rWv1VLBtboGgvn590", - "SwNUtpLbuKyf6Vm32m/0LNStRJSRM8yWFk7K8ugY0NQOPs13beUHsWxqg16jR1Y4l4m0e3P0dH9G1ULD", - "4Jg4gnj5jpv8Rl6Jv0lxvbLTZTOd9zu0tL7pPkiu0tTWab6lKq8qNVZbk0rGhJSdGjtR0mdbXG0qZl7Y", - "qb0PodaWRndub72tKvpCl6bKgNzQUshZKtNsW0I7n5PwJM3Eam2Q/lLNui2Tb+cN1akvUmjQBLNZl5a8", - "tWy9jfAk260RKh1aAXNUxFLf3AKEPNcg/33tVC9G3rULV6hTQ6/0wnucvcEqtRYJnaSjSIDW3mCFFVlQ", - "awqATro3BKXrzSR5l9pJXq+leafRa14fdInX0qH2u1i4pY0d1rFsq2ktHZ+MdC5Up6bO+eQ9lo1N+Ijl", - "UUct59SXX9F2qgm+d0qaXsEW60bvTVku+mtwx7siSd9XqsvVA/5jf5dqlWXpWLFJCO1atSp6dqvbIEV3", - "a6AU5x3rrVJP12oNHLlD1WaxuEMDpSzZodIKr+5Qs8YcuwxzVc7uUjfJd6+zfkDcakNv00KzIr175ag/", - "7161QVfu2EiLRrVb7XU9drf6H8T9VL+F+GhRnjvWrp1dXQmu6dzrKt1X7ru7VKvcWbpXW73tdKzZeO3a", - "se4tu261K9yiftXKsVv1RqtLxyYadYrbZpqiVNfwxIWm5gazrMEsiNMGI69U9OYgtQpA1cOu+EXxIaXB", - "yyfqNOuDYZmerWIE8zzP/GPIxhi7lYcUPYuvu/Do32xYDgkzGp505YIe68oRVXNjdn2RaXG6qHbdZGN+", - "y0Gf+lxuoQsOQEX35hQKzQmDVuO0gkfQ6iu6o4No2zPGu8oLBg2hT/krORly355+DY8uuROGocOG93x4", - "g65y8LBIL4vh89Ntm9v6WLmym50cH7o8MFdnSKsoUj/VRnLX06kVrtFF8dToK2l9YlksVl+6kh0r20XZ", - "Old8ufpsIbjFMOUqpC0WJtcTRAY1l/iBnHZ44ebaSEeOVr7/YG/3W0QNhGBniByVCnNXd8pr0/zAVy5I", - "47bpwopTH4RX9Yyv703X6MAQe3P7qMC2FjpHA64FYe1Ghffo5IpRSXd0b00lhZXXPJa+eWinVhjzTk6t", - "d/f09A+6pVunxIB6t7KKzW+828iz9JoNFMacvhWZdm1pJ3K9fVRHKqwbbQvRqqAYBGeDbcEd/Z41ybaG", - "CQamc5srSxI76Fdm0bRC3vpxPDPC2lNKt7SbS91Pcx/+/Le37FIhUN9EFw5Ruvx5DHgS2AEjzIEhe6ep", - "Dn2GsiKb9j0ogrRMgOaYCPQ/qyahW1PfpjJzwmyGVBPr45CUaNHIxOfb5wqzfFxn0rqaf7OfmRHTwgpb", - "wq8h9sC1LrKUskhWKcFGOM+ZJq4nf3Kf/eFmSbX9JBHZZnt64zjTpm18f9k58Kq+Sn8VCvWv9z/E/Ofr", - "i6wvtwqfE5WCii1s8OjrMCN92TiXUwh+8wE6t2PctgidV+2ROVHeP/v6cPc4nVet8TlDdjItldnCClvF", - "nS0zpFKVcLgZgVLAq7LeM+Xbw/5Xh/1n3/SfHv7cPERcWv+EtW2/pp6+ibA9RAg4PuFJGvMtgGJeau6I", - "/oOODATg1XxgGLGCuHH0a3vvWLT0EaREn+X8g1eT00woW1DuVp7ynCJulbgOWdZKF2SkCVzLueDptMgw", - "gUv5TdZCnq2BUa9aA6Ii2Xz17LBbeNS6R/bOMAWge6ZVB+boDb4eTGWX7ZKREKFQFvqst97vp9Le+hpR", - "CHI64shg3ZwKM27dqLCx1tp4lNeMLN7mEBoChrYynoD209mZMdx6bukijwrpqOkejKChaBnAMqzM7hPG", - "+sRCuq5+DepJq8ZRFiZrD8b78cObtqaRUwkeSudiewonf2dBoqjt48oG/dyJbN/IhXTd4JJWXampAdvs", - "Bh9u9XHTA1gGkX1Zu6MhqYHhGnTsnaNe+pV5dF2wnQ+y2lLd22zXPJp3m8e7jaYE3iSYyF2vAq2G+J6w", - "oSB6QgQUfhmqIPbrhQoYbFkWMmKCyMeaRMCoPbEnnmqe4E+2LjVQ2TKFstiOvVBBO+NY2oOiNPnFk1v8", - "ty3oDfW4gx3B0Smdnw8tQssg5e9zuszXDcNdzZKHS0H+JSGb+UR6OF1osRHihVh9K+wwSFx85gvZBofs", - "NTJgdS2lZXOeI1KeVqjlV/aIq/RC0RkOv4Rk6ThVmGOSaStSAlPHHag0LV2lYY/wXQWrvFBznjKlcYwU", - "JtWI83ZLwQ2BJls9e2PDUX42M80K3MztrCRb4pN9qWhioLx0S0tBySt2k6oeCjrdYZ/KcgMzz3MySG8O", - "gdxg9Ii4KYtt1g8A8s/xDmZhcbz1pbsxpLn/EIIDrdvlYqIz7Bw78nis0AWzc7yxTQTjlbKVdBWTJbtJ", - "tdM6u1B7Vgj2X0+f4lyWCziZPNQE5Cr1cX42hq1c9D5g7NZFDyIj8Oma/nzpTEZ/vcj8V6+/uegNLyjm", - "hMSftBSenOAAeWY1jDLRi0m4VHrYGWrvf7gQcIGfsLf/cc4n2OyPlsZNshDESV6oxBXRolZvNmTi8W0t", - "pCpsrXVAVceGX7BMOgFe42Ssx5sADJUnicA8AojLzngmOSU19i0MLnoMIf7NAk2uKOfq/a3ktthCCCuM", - "iVTRzIk6EdbC2XVvIag8ZiaxSwWXHKULmzUkAuJmVo9m/kdDojlqiZtZsRCrUeRbuYHbkdG6HovcPI1C", - "1RObwmEKVVlu5JXMxEy03Im4BcWwIXJktUnu8WShNDQFiBRwtQ0X0LXJRBfttcAMXOgA527nIouY/XhR", - "LVTj60Ry3XTEaXMJsqd8ldzj1UCSfd+id82nTqRqmsB2u55QV+3k1bCdcc9+/bi6YcfqShqtFgSS7MOL", - "YayIjapNdemHvQbKXwvw3S2mt30D20N3aTu3suGd4nZ5lenihsV5DHttp2njm8NxnH/bg0NzmlZxI92o", - "OdTcT5VBEQx2bW6BwnhHk2+/bo6fqqR3o6JsUkBy32F7GG/XxkDxam3sY/vugTvB7YToGebaIepV8f22", - "Qr31LaPUPDWh1js//vC2t7ndahSXL/7DyZs3vX7v5N15r9/7/sfT7cFbvu8NRPwB7WS3PU0olTg7Pf/v", - "wYTiY1uXIfGYWCsXLXHNnDALSYC4WbFQdhskRL8HKvSWtqDIjtgS2GqfBrphxc5yfq2qC9YpyWDD0Q1u", - "LCtHLKXmFiPnlttPwRe+NOMst6JI9SDOfu/0/L/3VwUrmR3xIIoRKVeCTqSW47J508A9TAKlrmycT65R", - "mQS+Wq8ikuywpWs9QbHbd7MuDn5e29dbyPOTimcQPRdxZqG1TfzQmFj7/VncrBrMf2Wh/O+N90HweBJm", - "wC3wvUh9IgO8wTQcstHqWBQybRbEaKBsNHOeB4ed8mYbRu6r7eAT1MpqjrvC7pqNqZJMp7B0yrZLpbwY", - "5UnD/I6tkwsMU315+iMr0HEqFyYRysFdvZyGQmicLcfocTg+g+EjrBUYUqGeSLvoKP3eQizaAr3LEZuQ", - "Xt2nIaXRxxjwlhO88S3otNxTVwss9kb2Hk1bpM1nUfvGplLd7tB5xR0HSXZtJD2yr5AeIX1ITHe4rj5x", - "xzspFmm1l+FWU0ps9+etc76TvgjD8bhsFppbn6H3CGojkhLICQsEB6JhRzi8OBUjeBnEv4vudHYcAouZ", - "EbkRViicUdhBD9GizVpi57vuZnTZKokFZtGogopmh8w39SGtRdsDKzQi9HUSDVGQUuMSbBhQ8aLXxrIw", - "/oZTgJwt6OdgEMQlSOaFuqwnF0DEnIjD05GJKUwd9/9udoiJTpfepINNhjxqtADKc/dq5H6DGPep0dpg", - "EcocfNG2h3aK9EpabZZHPo0neHyE3j0IOjlcGMzNiMfqSo65mq9eRtm4CR3OVhLFDdkJbiiagtHrEjos", - "FHWYIAIsUpPFhzB6GJaWBRlD5qRKMgqrCRDGZ3n3qdbrOenL1P2VTOf9nncjpxI+V3Yt5XeMYC9jUhuJ", - "GkiqQTGogzgEbqfM3EiZHTOS4c4RLXdBvagoO9vldSsaN/mlCtOMegMWUzvvphGVjqGhVps+tNW0RKre", - "+tc2etFWfq8BEXbW31bcWG892Cb86Oo4m9a8jLb5IGa7w3W3+cd8j9+XDsEzbw/ZgF/b4jHxE3y9U0Md", - "nWCpLXgB1/kgE1M4CIwSd3KL3aHNRs/DsAr9sLDbtuw2j0ImbvSWdAV1wmg8jepJDXZ1iswcH91sfpv6", - "Xhv5i1YImY99Mb7QhXJDRt7QV8J/bxm+n/aZEjNe+x72ofkQpxFsQe/9G4w46dA/PJY1dF/kzZ3fxfE3", - "plXobt/fxhXceZ/JMvdDvavdmWLnJjt7464lxNhRask0FWoLuCC2X3nm85W2+iL6ci3DhmCkU2EWEt1I", - "7e3GPzO6yJttcPiTR8wy7K8t+Qq7QbM1ZKr49uuv93dLTKGvlTDNY8Wf8JEnjPfHlvF2gfEiRKm8XFt6", - "kabHT5/Z75Z4+Rtg1aoZVnZTw095YUUV6hO1YJuLBHg/jc8IO75DVB/zMbVK0zNEFVT18HDza/3qbbvS", - "eeOCOG7ca/sTuN7eZwqEmKQFLQPQ+rAZFhUYV16J7SbcyO2+PRbrZssOPsetjvC4AneMmJsavhDNHsIf", - "St02FIItnubAsVfCGJkKG65NfgX2q3v+7HCbPbjROhrubmt2TbwqrcTN+fA2p4N3jKwgv1Kq9TKMjwmV", - "erzwPet03vdRf3CgwvWl79M17NO9EZzrodYCMVYxy5YKyTxjm/beUkVULKo7RQIu+E3gxRN1RrzX/nxa", - "dl19PgyhSps3duNeLvgNQj/KX8SJevtd+wgw6NZ6wMq333UkplXk/qctPu8wuxdFKvV2vnzp06RyKE7Z", - "DzBw40qmQg/ZB+JBW7UOgIrErwQ6jGAtH/MC9HJaZFa88N8ml8JVs0/vQSOIaciscOA55+aVdLf7nlp8", - "gtJayKG0NKIBphztmCX0zOn8rqJBm0RAO9tX8mSxEKnkDmwjwFhlMInhiZgWGbPzwgGbeUTHBUYeoMET", - "s+gm2pgCvXFwqkgjzY9VdwjxJZb/NHlfoK/8XvK+lNCO6kpkOhe3cNsUviqLj0ZOMx7iXhDJmq3AUq5r", - "A9FcujFDWh0cFLPP/av1xWGw0Eo7rWQSXesYPbWUI+WJ0dbG5MTo9KGnFaYcMnAeQ+8gQBIeYM+Dk1c+", - "QKTwMe1glPbWUn9ASEtpMMjuthZOu8OjMswx2JN/3riHbRgAK6ioFCJ8LY0YZOJKZPQtIXmWnmseMdXv", - "XDzdUBoFVFWtVmY/ZC/MRDrDTQA39Zq3xXoeKbXEBQUBmVJj5FsbgFy3w7f2m3BXccTCDKBrRmTDUp2g", - "K5lIg2P12NsH/90Dmh6sfPMK2624N/bZOmpro2NxVyPyl2KKLXfzP8/ev4uW2KatyqT1S7wZyBa3iNpZ", - "27p6/s+mTaE9hbW/qzHYFCpp9gKHZN6TZUUIlO8q9AyE2UXBfTs2gm7q0gfmg/aRyYVsiR92DQrUj0re", - "sIhgQZcdEE0rCSXKhfKaIlRh15XTo1Ps/qcyhVcS/3O369ESHuFL4RU0npYLJcKatIVU8SwbJJhjPyAm", - "eKNOZTFr7eP++iYpeN6FNDS1ZPFKlxW7eyz0fTrwjrQbF9InaAN+NagDjIj7muKlFoXPs6PKF1v0civB", - "oXkEX2YLiWrLRCR4o4ebDriZTsRc+ngjMqDYYrEoD85QncR7fQHJXAFXGGakBYZOdIEuBdw/gfkTU1o2", - "Ef4FF7Fg2JRbhxYsHgK6qIARPH2OcN2Y7F4r4VtT2uHLHzhDTIRQLNMW9a1rvrTMPxJjfAYcHT5a2QhM", - "vC/dc8YnoQD3ZaBSyl2wVSLPVwKylXZljA637Bdh9HDjQd+cRel2+otXUTJu3ZpqxV5pQeODWbvKTjXs", - "za4jXnNxRXKkeTRKgJWctjvb1u+WlQ4sz87oS2EbM0k1On0179OtICeCn3I5jgC5UYGegPPkRqQMJzu8", - "UDVRbwrB9gKNLQLYyEEacgruDxmcVnD6hCDfC+UDNkCQQ18UJ6aYDraPSn+1lWJ7+N1fDmFdPCLG/vBC", - "VaP/xQ2yI6wQnvXX2qQDixEM6BrgPenjzKVyhg+gFHVoLxRICsUJbB81HPo5B7ljSTelsdE5C2PZsHVt", - "IU+NedaBFHFd4YjzyutcWxdTnLckS9CAFa8SsZkWT4UZJHMOGpsw0IdmUv2TtDOMZ38OUtbxS0GaL2o7", - "qFTimoH7KybJLYmAHQ7Ze3jwp4PINq0A27MyEwoyoFfX6UKVxZA29mmpos3jcPi0keqDN1rXHPM/icmL", - "ws3V91pfbuXv9peK0AxFo821voxUmGVEa0pcR2W+wZeHHFPTpofslbmEki3TefvylDLqQgbfs6hjfpL8", - "z5tyMm/OrNw+mRN1pQnuDRAZC7PrbILXUbix6MIleiFG3vmk8TohY5+jFt+DzhHGPq3dpvR6q/O8FSSY", - "MEabmKn9FjMix7Mm5d6ZwlIemZkY5EaDHSrkEgupOywlfXJGcDQ0gylJO6Gc5GBBgTixBGNHvWOi97gs", - "GnQ/TJwHuOu2mPh3JK8ncaa0GvDCafzJsVQkGTekJ+LTJmLy6Rx0R1AHC4eqBJX294vy5goBf+TpkYB4", - "pCRvuI69ftMotocb1Fc5TnHzpl/eEn4LV7K9TtMJDyKBdqBPdzy6+z2FtF0erANvylYYCZF98a6yPR6p", - "knCwNExvf+aAo36EV4hfq2B7T5/9aTewvdhO369L+5qf+9TwOyx1t6t62Xzlon7LPPT1lVl9BuL/wtyC", - "U2FQr4Y3ICC9S9L3JbhU88QR7osRM2mdv3aCG95EgPwDTrzimUwD8ISNpxOrmEeCryg+MGHKurTDlbrc", - "DPizF20dmzflhVLa4Th3dXmH2qVkmog5v5IaA1vxRSu+ev3j7ctThtqlf+MlZv15L6TyXOhUZD4vaG60", - "04nOhlIf1IofPDt89s3g6dPBs28OyMRyAG3a/xv+3ScVEXujqbGVuVVMc2XH12Ky4MlcKpEJbhSkt51J", - "Ny8m0Dv8mOQH/3cqE5eK6QD64WWDoBudz4UVfrrcCFZEqU3xqJQrKQJxTZbeGtlkBywFbLNbXaIVXelA", - "uH8vVUuxVFBeKnkl2gvJVCzooGgvo3OhftImS9uLGMFTUDXbS8QF8YDrbSU/biTR18bDZez6jtwYrvI2", - "XJHxjJQqMYKjqaHpfVcsJgLxUrG9qidSsACt8Oz2mKONUDXUDQDWRJyPqeGU5LhirtssCeLcqbPN/B+l", - "3+7Mzxa+LptqeJu2Jbvjz00s9yC8/gGlrTAibe13J1Y3sT3scHihSO86o9cBBAsKF2Nt6PoBYwou1TDW", - "Rh6vy9pux1NVQK+GODfqnHGg29SUNaoIWE8tauotW0Vc3+06u4dWqs6vPpvNdHyrSxdtWLe9WLvffewT", - "p3UPx1wVaR/XsAyO6/LG2xwDNSLRA3X1QVsAp+jymYEcb+FpDsmxUokeFeou1B9DupmwNy2GdPg5orvU", - "emhxV5uJUVcsrpUR7yLwMKfxHaU7gQfdh0TfgpVTwuSQp1tFSjyxfqOC6xqfPA/TjqKl1LFIsDQtx7VU", - "qb6+84qEqVNz97A4KzxeDjPuYI0QKxQUmGsz19vOmJ11xseV7IwIVva3FUWFGm4ctJFOvMxkPtHcpLe7", - "fW42UdaCE0NG29Dh9vtDs7XuI54pFJfipUXPv6mf0MPIi9OTXr93JYyl4RwOnw4PgwrJc9k76n01PBx+", - "5fO54kQOArDlwTTjs+D9mDS4P74VZibQjoclSUyIG2kdoS0K22dFnnIn2EqjDdCYkNnUFrkwGIGV9kmV", - "AKMD6O4yw5WLpV+JK6QxdtHDl2rQGi56mIwgk0qgHjBB/STiiFHqeRhZwHBFNQD2kBziUnSAdck89PIa", - "509bIaz7TqdLMqChwhwfKb1iBOm84Tsbj+IVtTes5ooYClOiNXSaLXBZfRLqf1z0BoNLqe0lQSsNBqm0", - "cFgMZnlx0ft5//aoQjSgZrIqy/kjKcDnYj/PDg8bPLVx/LTfdMuKU/ObvZoQ/2O/9/XhYRuHxx4PvuOB", - "JwmQ8WO/902XepgBSPHM18IU/osFN0uw4hFdxiFmvFDJ3G8CDN6Pudfv3QziE/GgdAkp3Tag4ZK+EfNZ", - "iu18U1hhyvMjDkTAoHMjbYSPLn0eYwDkhMefMY18/0JtZSi2Oz9dqF0Z6qUwjkvFwiqwBVd8RhfsS+/u", - "o6aGhwzNns7Zccg7fyYcSA/bv1CIJT0wgmyXoUWaR2w/ECqeky9fnR4EPHyt9vGaPwE3AZFeKDR6hLXc", - "yvunYRtvz/7dzZBdNn/IfgiIdv4nfCy4UHseN80/Mr3U+lIK69fxokcOylc8K/w7VQWYnL4dXqgzIVi4", - "jiEli3Ikw5nWs0xEwj4gXSlCO4fvaUkF4cbB/L/jVibwCvT+SpjvncuPw5MOrUHjgFFVgcL2x3xmeCps", - "rOWP3bf85mV0k7KnPlUdYBT3e6c6L3ILOCjXIn2tzY8GVIl/9MLc/OiGiV70fv54X5Iv0MoXK/xWyQ7m", - "chcZWOTgDzYQgalJGGrb9JqCRSnDumELbQSL1dgvMmfcJHN55QckbpwBQ66biwUrVCrMhTqY64U4IOFy", - "UHZ5cFEcHn6VAJPgX5AzA4PAAP9C5QROVBYn50UwzuEOyoqXMrDghYLrQnBV9usCoi+sITqTZMhd0jAD", - "InYhwnECPCuMJZc64J5pgbIPW0GxSTKF0cr4wZC3EkHzeZ0qR62OHiaoJwUKZpnslADN0avvQh2Xs/O3", - "VSTtBiljncyyBrjycGLAmMMRAUcNT6US1u6kWtFOl2PaKFkpjoIbdwDkNQhWsFK4broTxD6oy7ehrW4M", - "/rQJkiEuJJF2MCMHevnM3IwsVB1QjZ8aqP3uHD3gKh0E+XB37u43sDbrytn9C2WFi0xX9kDsJ9Utrh+R", - "9i/UJ7x+rPLIC5V+iDL4C+aWfsNxSEscVxIf1Hi6/C2w0hbuYXvgIihzu189JeMUOzOX91I6mIRrQjMT", - "HQdgVsUQikKkhKWrp9HRiZFbuaUIGTAhZQIu/wFj2//qDyIYAmjE5aNVtvTHFwR1B8yVmyQrIPKQgQaN", - "cLdK+zg5tP2ySLuWJVyR91cm+JXAsyfEkFqncxvcswhMW8DSR+T7sDVMxiwr5JhJk/Jw4PimJ5FOCotx", - "QnAoJXMukalSQZBwcFCWHpaI9kVZoKC3S7FEg0tYrhIrPedLaMX77DOjC5UOnJE5g9uHSgiUBjPhwCiv", - "ZFrwzDfTxMjf4V3C786L4NF/25vERp/i9Z4inuAt9VlsMuAB/4bU1sgIDDmmkQGqNN3OiCH4os6HCaQn", - "HiG5VLmxvrOYwxi9NR9oQ8sO7rqPb4nwiYsi33/WLTyT6McOe0hsiWsextjiw7nrJpJV9QCOk/Z9/CB4", - "+rJigW1azvvaT+rEK/m0nSsGgFCG+S7xLFzjvDsvP0yavH6jC0iDMfqW64027vYFrxvZH4h5mi35t2Ug", - "tN6HlJpOl4v025GJP9HDQvCEvo8NpTSarfsYcU4eaAvXcFS679699F9JNtfEqTg0BslgJzKTbhmNPr8Z", - "kvheph5ZXl/XE6PuRAcQlbB+GK7GtghLlhlEAwpCfVI4p1U/umJky9KMwGFcxlFQAMYPKkqLiUH1ON6Z", - "vBKUb9Lr15ngVpBTF30tLeNRCf7HTZ8tf66C/ORcmsb71asQafFAtBvbv6vkgYZ+I0c2DqXMSUvbxJkH", - "odmJpOApHlsZ5T5tcLuY+atwtQTDD3lEN2cybuZ+fGqnpYiTuI9l/qtwtdd86oJYN/Z0LxoScNs2LTdm", - "Qn4gRlnLtHw3HdcvE8zs8zLL25Dgt7Z94WSOOEqlrLL3sqW5EdYCcNsWUS3sykAwUGxKWbCi41xEeaIn", - "pxJurJJ/6EI1ZRXyGbVwHkbMhSL7wXr6oj6zQlwoN6dUPuspiBh35YvUTLrh1AiRCnvpdD7UZnZwA/+g", - "m+LBzdOn9EeecakOqLFUTIdzOjJ82PdcK21sNbTQ+ziF+VpWWI9hlPilQLQq6+2RtE06bXw89DmxHohf", - "VlNu3ZZdcEORWn5LGgvOrmZ1Q7q8D86oYCe0CrtzfilKaMmHUmvXEDI/+k3ceKhh9PJBToiuZU8xzHeC", - "L1oNHkRrZ1c5AAqJ/qw7HvGUWLlBwfnwrvuts6xdDBI4KLvyAJoE0HygQToEUE/4zlUU0Yqwrqu0NYtp", - "LTWc11Vr6JxkfpUKXgmga+ZkcmnZntLOI8d6LLGSxGLkBoIgXXGzfM5cgfbOBUb7VvGgMa4XsaLKqdDb", - "v58rQ2hRGkbwO+nX8Kx9WCo+wdSMw3uxDdTXyw68xzfa4yigNQDQBGE6DvHLZOkZDIzIBXfsHRsMKDD4", - "kNGDDt0a8O+Ax7Jy8wwYnQ/EnxXU2NvKV09evxFjGw2mVEdoe7hj/H41yoA/0iJePWrAA23cKijBnYw9", - "FAn/mzkYYW5k3LnTNnk8k3apWCa4DK9/DP4hyJRl9CwGVg/AZXUECqnw+A5xkiJlfquHF+rU6KnMQHgq", - "rcQid8uKM1f8yj/Mei+P+IBo6S07Ph9ap/MDHBWhsF0oyr9Q4uMNmU9ojiB4NGYoCa7L9JUfGsIoLjEo", - "EHEXLtQ49jyCd8AROn+L2fIvOcYWjpI0HyMcmnMwaKwKTmfh3R2BZkBArviVeMSSamrenBalcU20WVmW", - "ITuOLhsD77JR7QLcjV6dXqjKMKYUG45oARmCEcDAYSnDcyWMpZqaOGwYQjb8qxBmCTTAF8IJw6S9UAGP", - "YLJkOkuFITXCBhgVIxz37ZVwd9RVOMaGFypS2jhuypil0ub+BOFsIqwbiOlUm5pjCzm91KmOrEPeGaVc", - "XR+pXAYAEcrVd9wQA1kf/1fN1jkOl40xwQMxrnD+ji11wVJ9oZR2TAmAD3rhWCa4dbic/qqAnnBQHMO+", - "J3HPIzbkKp6OdSK3Pj80XISkpdfdowohlHvcxzVCi5lnFDyIPRUFNwrau4jtRsA2F8oZrmy40hwxOQXj", - "GYfljN6TMBqkGeiVm0wKU5GCDLEuxXQqEhcAGRcceZ7ucAQvkojSCQoj05/d3Pi33tzonM+4QzfBU+Qm", - "iuLToHhYAZTmBBuXjhr/PiaMuQM/8TGltyb+ijCrnsLgqXY2E6D6XihaWZJcUS7VhVaj/2eQMS9DIfSK", - "9xxgMYKoxdGhyv9BZngy0ggmzcZ+oOOQtxc0LlYouIV6J9E1bkH6jbIKRLp/6y7JYsjGVdHk5ZIlwVSV", - "BtowkcmZnGTNHg2w1FNc30ZRQRkhvKqJsV+9ox7KiF4ITeu1yE7ErwvneJnwsHQtjAmk4jfllJoQBn6+", - "kyfMSpAZbLkYBY5rcGA6fz34k0fLqzvksgXP2f/5X/+bhKcVC66cTDBP7OmL85ffs3WX8Oa0rr7UqCU+", - "oDICclNl418vyHf/ondUDQ/4+eO444DoUGkajWe2LsNYgMRGDb/ZYgE/+5PY60VjtoepJA4okcSBcMkw", - "oNlSzuYAnrPO1gQfRHIPfkZM4Ajp5uVO1BJKVNW6L24Jncy0SkS45/nsmg1ZmqoOrG3MD55A+OQQRo/x", - "4OD9ciWqvAp84qdRokBtdKzbr6VLrpNuCAhtzOw/pNT+z775phmX5heZj+Dg6GZKqIeNxLqe85sCqlYT", - "PfhzauTPqfXVdNwMf7EuHGRVaUcKhcXlHddcAjGCwmOQUgfh+dwOmT9kovswQfEbrR0TyhlZ9Yb3leEf", - "exBSKYebsBUZ1N9DGUr+42zsfdcPTiPohB3vE7rsGNYtH5UsMa4k/Kft9h5WYbLonOvzrFtQLbDAteF5", - "LgyrjKcG8Na2Xf1e1Kwa2PjDm/hY7JUrsaJaiS2aUlCU+ixDMBJgqoQTrzn27PDrP1EquX7JerCBCUaw", - "kKqIMsJvAI1ikomW1L/1tdxwdSnB9MIK4lNhWZdwnY3MyflhhSYjVeyB5hIzpvhwSWBVWLf9TjmFf1MP", - "1nWNmeTl89LYH6kg4v/Urr/Du9x/vz788/Z6MMBMJmu35vtxvlnV6cItu3WdRLg6kSyPgUopy+fcipUL", - "+gu6H+Plpbwbo0nM35nrWn+eFXZt7el1s5PPaOV8jsFlDVFM/tx9qMeI9aP9U9O87z0AqK5v54/eK8Mv", - "WH0bPhtN3zlkp3k6HYlnag8SIyBFcjhTiJCKJjdHLBgTnDyUr2O9l52I6emmfCw0z9+QJY9myjjBHlaW", - "tevOUbqRDjv3Cgs+9M5RL6fcze/s6hI3jaaY3o07v95e7512r8HB+x59ZHDkjN9lZ4M+vmFTX5Pa/dve", - "Txjk72Er/R2n8y76xEDAoaNfJGZCmQnXlCvJFQbBG/9+csriraVy2wmXmJi7osy/FchruO7a5vt/Jc3f", - "Zb7NdBXTlMUWSVt2Ot5KQIkJk2qz+XgnsDqVVA0+WzOb/byTkuDX9U7v4LDqYY4xBQySXnWBv0TK9ZtV", - "FUOMB0LzU741RVuXdiDpcI/fc9xULvOL4HKCOjW0tb+R8i/UBtJnf7cuZXo6FcYyK2cKwckQMtkjzYcO", - "vS5+oVJR/Qr+5oZusxCESMYjgCATVzCSiXCrrSCjNbuUVvgO1uhLYbz+GhBJZbroFzVk38vZXBj6ZAOe", - "P7MLRLgtTSsAKws42AxcQwW88gxoJ6w7Yv8TdpuaYE/7zGOhwsZCqqv/+dXh4eCbw0P29rsDuw8VvYm4", - "XvGrPpvwjKtEpFTzAHeA7f3Pp99U6tLG1av+R99/zUKVbw4Hf6pVWhvm0z5+G2s8Oxx8HWu07EiFWkbY", - "TIvhO/xVGr79UvX6ld9oyPiHda1W8O5y03PvnQTn+YqN7g8iPFdMkzsIUDQvBYAmLzjrwgN0Jcws3lVq", - "oKzwCw/NM23qSsFv4ZTeTfOMa9BAcvAbk4qI9c4X989CWODXXZkB4xNyAFjbvR0IK5PW4X3BtlLWG2kx", - "r6+95YH0ZdJSOesGYiovmhnBaXyB1AQTpHcKCvW+DfWAl3zrRRMc2E/LPX4Iv//7uGRCOxXjzhe4kzgD", - "fODHd8G7CQQjeBoNCI3yACI/vfmgmzjA4QTVFNr/rUgEnTjhBpRs6s46DR4wjbG2Xxg5wf6y2hPoDuRj", - "BR0no0qm8lYJsZ4w/uECQVsy098aqKtsKoRtfoFbfSbcurCoJpk/wCT2di7zHWiAXqbbXURfEIx4+YDt", - "UUa0Kb2x6GDy0U5GLLSXIxSSPGyBuwlqyr159UTNqMV1IhXWjbak74cyUvlHOy8FPYirV727JO7v927r", - "ZeGtj+VQt7tZNLRwW3jPp81m3Qr81RcuLhuAfqaeDHdjmGDq3Yh/xdHMRJ6aFRQ76d36gnPCisFrhQLb", - "2IesvffGPLsyRymBnI4zg5lE7xbdjVPuySdpE8fckvT/LvM67puf5u+GDXgVi22FRG/BEd7YtIUldjUV", - "t3HOhdrOOttNxjUL8YVaMRG3Y7V5m++9sV+rh9z5XMQlC6sVjqEOPmGfja2bPbjaki6+6+7E5RHw/dhg", - "zHuYphPIaTDAMoOy3v5wt1yopbXvAQTKC7+Gv3OhskqutxYs16sAeSs3EseNe21/wlIPdBepdLG7l8ot", - "EeNx2o2JI35UEjKeNaSJKPn22i9HJ2/F1fzaLpmz+4Yt/kzkSJOpmvU9cKCa7aTv4Xoe/Bo25SPtSiYI", - "82qVInVeEuSKwQWNKN5q4m0ocac32VG2m02+bkqVTltJzvBf+FbCshJdowf1rUxlq9t4UKZcbzScnaGh", - "6bU9vvJGlU+2m6tGMCduHI220fq17Y3lDC/hOI1GeICz45DBXU8rt3Yfzd3r9+aCpzjrX3v/NTg7Ox54", - "QLvBuQ//Xc1ykEruczNPGTSP+cioOba3Kgj3a++l4W10tVTTU+jHL5GQcaHXVtkjZAXR3ZmmjdzmQIY4", - "cV0MwK8qSiBfMwZ/Qn+E92WC80ywhU4F29OJ4xmjOn2GiQ++/frr/SGrpln/9uuv24a5oOTDjcP6x+Hg", - "P37+9av+100hM5ujzu7RPH1Ly0xEKfzSD2s0scH5HPxld3HDy/TMHpRL3/wwqmeW2K9Flq+QjM/Uuom2", - "g7DyTFDCiDcmSG7uhtI0NvuM1JL3VRJzrhJCDG6XmFtuymjskP/fD20D67afTLv0U5l7c29lgZHPU9b7", - "bKfiGz3reBwCYf2mT8Cm0wUGTfHVZ2fHXVnII2AfiJkR1nqwga2OfxhEiTVCmGzw5jM6Y3nGlWAZt66a", - "1ALDv33EzJC9CH8ypR2qd3Nu2UQIVa1jRK6Ns2w8lZkTRqRHDLPCNMLF/FW4dzSbYxzaKc3lAd0Pmrrb", - "gCJYW7EWOEC/Kk/sSukO29nvNeavPxcQ5g1t/+0tBCUSoLuz611Jy4wAIkt8XnSuGAcxlcmAExE/Qgsi", - "m0KdmFRZFw6BA6ivfplkuTIbyN1DkYLSslRkciIMpV1R2jELyzQXRhyFQM2bJRSEDyiFfF+YkxJBD6gt", - "zgjgjSU6XwZ/qap5i4asKsNjCaLcYaupkVMPkSwBwYTQnP72lhWEoCctEeO0sKKM0McwzmtsxejCCeYM", - "n05lwjjCydPvOIUhO9cpX9I3fjoAI5LoxQJBD84xL+WQDsHvKJLsJWXmBRwEYxCtfoyNnSF405hp47/4", - "bplza8FTZBywOU4zvrw2EHTNxE2uYRbcsrGPURsqce1b3/vVL/LH/fERmWArvAYH0biyE1zZa2Esk4Qm", - "QrAmmDfYwz5IZZ2Ad5YpaLbX3KBJT2L4aQjNw/U9iWmv+yUIFmGNrEsSBLmK2VWD3EBp4liRYwPws0BQ", - "K1UlUst4Suk6yfcCESNppzkzhaIEHUEonZepsqQtU/hgLgTpmC3MFaUmikgJntQiHgbkYPDn3HPGA63Q", - "xieYczg0Cw0aL07BIdZwZEw358qLPbrzRvkaiW0iWKataxKBp0WrCLx/G1mr9Pt0YYEdBfBx7ajytPZ5", - "obruLu7h9M4jnx/49A0d0oqYiXSGm2VVSiQ6FeRhNjXChmQQHkIFA8j5jAOV13LTega6UCBhdcKzubbu", - "6M/Pnj0jXsJW4VzneEkBLnyS85l40mdPfLvwp2/uCYmCJ5QC/MmFuuJGQqS4HYYvh8DVmD9mb/9JZJ/K", - "kAbXIOF9LnKEobOK53auSc5cqNCQVFf6UkBTe1Dsg5j2KcvJ/9NnvzInF0IX7kwk/w/7uP+EUWlLaVJ4", - "4lZSBc+NLmZzD40DIElPLLNLlcyNVrqwYTwvTk+G4e8gGSJuEzRyzbj/vUpwKGsvQMK4wr7UqejjwvZx", - "VIlnflq7iU6XHnKCdsAIW2RRTOF+lFsrrV9CSA7joZwC+aKUPr4SZok4PLDV5IKofAPaHIFFTlAKl5S9", - "06kY/tMG6UcHhHSW6WsVdgfe2UImvyF7ifgz+PYED3WoIfmmCSgp0cqjI2fL5x4OSFcQrEJpKAw0KAjq", - "DjYPFEy/iX2WGG7nCLPlk0OSSs4yrfOAGBTbSrWwqItwhD+6UJQBJ45syF4gfAIP7eN4YvVLIXKL8w4L", - "geEdRvtvG1YCjxfcGj7hKtWqPAdDF/7ogMZBWbkK8TPhQA9julA4V4ZWpfXJEpoKppDDTcXF5OWy+wR1", - "UQqEzNJAC7RbAXLrSajyxENa1VcBLn8pe+JvtE+CWsKza760lN7OeiXwQsX95HBvtYgi+aQksotwMb7o", - "PRmykzriWCjW94IFaHpC2pdmXHmINMovTqcqLS4qIwKbI7+mgc+z7QUyAs9Q9iHobqqNmHmtjk8IwuZC", - "RT+oeq5uwrnQuVA+DZaI95gAIOZHlMc6ITnShbIiE6h/+x+kZYWKT93DUnCGsdXVRdpQfe3FYmjtQmGi", - "eHYy9f0PaEXQ3kcBT4mwQavzadLpzaRfkRh1yChY31qqQgJECfJ86EeKstppPxZEi6ahBrg2cQPnv3TZ", - "EintlCPXLH3uKaAlqA50hkIMKBePKqKyQAIk8CjhFJbxk1HiGkteKFKvgQ+H7Jgn85UGaNU47fCJs9W2", - "YDetbwymXxIDW8HAqzI4zNIfauvUiRsFDWgFLGqWHqONxo4hatIhZKHF7ofsfY6J5xgkqYtiijYJh1Ch", - "LD0lSe03h2jpOdhuqmMNGwFHtNK+VP9CeaqlSWtFdBPS9EvLkkxbka5Jk3KNvDRWaaT8J7CqPkqfLhZP", - "IAuwX3mUfglXMTEl7A5tv+MTW56wJfXjqgbN4TmLLpD+RhfxZ7hrWHyksxeRb6HnOb/C82OhrWN/WiEN", - "+7xR6pSHRaIL5eDQgZW4UBVtPRg2/TkSdJavD/9MBFqVm/a5D6RGQUHH/qvjN8fnx2xd1dPGHvwKw/w4", - "ZO/qo/UoPi5eeEKS5KQEMia5C/cVONqf0/0KCG5eOIvxiLi/S2wrtkNSSvptITpouojQzopSw3xJlviH", - "uIes9fWZMEoaxgHKVzP4TFTE7vWV9s/3h/kSZxGY9I1cSNcKp3MeJPMK1Ze8MhFLTeTDcmEGgfcyaPZe", - "08WVQ0es4DMcpVew1i8xHUF1m9iv1Uz6RpJ9qEFi4Jni0TyhwIqciUAmkyU7fX923sD3Yt0xFPpb3zD7", - "kKbPJvqwjbQOp1Y5wfuLiqrZuMoZ33YzvSyte3msvBFgZsuqwH4S1fwg+6NRSaM0RYhVr4kobySzlHsS", - "tb1IF9fcBhCNIfsughuv9lY7gJnTmrQeGDqeYhNxoYwoLEB+1U9nfx9jQQkiXSb2z71qG4yfa4TrjcPk", - "IlSx8/mj4ah25ynxGPuM+zNxl4VhtXVZSSH7r0IU/ixCjelC0dUQFESt/MTitpx4bVhpmB/etZ7g8o0c", - "nzwJqg9h3dLYGqP+CS5ljeg7+YfgfzY9KO7GaHDYNwb0w6waCKb+Wg59tz2Xx3XZ6V2yk1/ScVSZvnyk", - "mAbJ01XwEFWi1Gn3bzylUrBkD5ZeJvbwmZSl2gja1KQyqbDxZX4T2WjDs03FxJd1N9l6ErA5v1ZbaeAM", - "Sz0oEWAXn5cK/BDayAB/FulvbPf5nbb/V/8HuiReyizbSgo/yCzrdNyULW88dKJ7UlFgyVt7QN1qy2E2", - "v8mEn+9/+CJDREEcyZniGQHOB0+b29MkYW5vpcoPVOx3Q5c0n0fKvL84dVhPUJrO/3swoTwE90Ge9BrW", - "6vUXDhYq9amp84FPS5pU00Hpf/kiQXPC3dGGPbsLcaSyg26FpX43kgun85n1OBpCmx733dIJGzyXv1hn", - "5fJ8ZdZT0J0oVRdumw9zubzglLDJmfkzybQ7OOXGuUG1ju65Yf114fLCkSVITgVlBnuMX3mw+JUK3evC", - "7exrbESCmTVnB6WFtVlCk6nlQyj/oBjIsZfteVpXnaF9xc9n0/pM4PTREpYbcSXx/stoc0XKIM+o3imM", - "o0IXHpWxVRIG2MYqaWwMbzopQ2YjfmXYtuBJ6nTEX+0HJxTyGa0MDU3QPnmRXkjnwgN4mfxutV1pY7vt", - "abRQ4jYHKPHBLy8Gfz8c/Hnw8//4t1vJZdyLg0X+9Z2Bs0pi9ztbk67x18FrqaSdi3TwoskVXS6EdXyR", - "w15Eh15TaZoqD9lfC264coK2YSLYh9cvv/rqqz8PN0eu1IZyRo8GtxqJf3C47UBgKM8On22SGdJ6ZweJ", - "af3Q+7PP8kxwK5gzS3qrpBeO+nJ/QG5Cj6+GN6piNiN0VsiKiA5k0AO5x1s2EVNtYKIOXcprk4hoCU8b", - "0BI+fsEQr5QQ1yKLojPh/QirTFrXKqjgiZI2W9z9ITbiWm06zUJvhK26Bha1xtFvfJZ+E0d5b0+z+A5a", - "mfyOC7vg5rLdj5nmaaP/l899qYjWPUoIV8EbKjaLeTynUmFmK6IJbi6FCXm6/0ludzLAy3jl8u3p13Am", - "JHOeO2FCnfU3+LfcXD60wlLr4wFhKXYYQ9td7y2uU2S0P4xq9CJNI2USrfhAKqkGQcyXNLk7b+DBtAUa", - "5aHJsN7JRrX56aYj0B+yX2B2JlwBxplNjBCqKmPeg/ch5VIN08yFYSevvHuGjxwQhtLneW/129CBzjeR", - "gc4fngoqfdz+7uT9RD5vNI7TeV0B7L4hebY95OY/+RX3bmjouBwiy5SLYRPei5t9OD59M2RnMWM3pfad", - "iyw/Atec8Xj8T3uhoNshfLm3/5y1/e/ggOFpvBBurtNarYteksnk8qLXVP3ggJ3BU5IrjOjH7MT9cNGJ", - "SdsxNWa91bXgGugBR40Ot1dcZpg52w8JplQcHn6V/F+DAfvu+K8n79hfj98df3hxfvwKV4K9PT7//v0r", - "9ubk7JwNBlhYQBIH+PGIjWPf477/gNAY8ZNYSHcCATljqPRdmaLPGZ0dsTFkUe6zcWq4VAT4Ah9Bc36t", - "DX4Bn2fa6R9NBn+CJzEoWPA3BTXJicykW575MCP4AdcW/gAV7BxiOPsYVZmdqLzAD7mBJ1CxhL9tYnSG", - "jSc8hzU/Q6ESGsOIJz7BgflomHM+wYrX0iVz/0GJa/8XOvH4v4WyhREfBM/8F3IKd2UKNw1TfVud9BvN", - "0+oaZBhrW/nGh9ydpBku8z+xchGBXeHT3Ln8r8LhmlM40xEbrwZwjfvxu5JcKl/yNH1ZWKcXq6WhheZf", - "yBWt/G1cJa/jd6+6EdeF8nQy8HQSqBX1RB5pGKNSCZEoWyJLaBVDbMfkl4dhLVOjfxHqQjWFqCWZFJS5", - "vWyY2zAjnxLdVxz6L/s+dyxIzwQne6Ew1I2naR8jnYlDaTnC6IfrW7C3j6n4E7DjWYyWq3jaj/96fM4O", - "qMqB8yuNw1mPoNsPydrH5LPqa1EJiNV/qRcLrRgQzhRghauyjONF1fPY3kUv5Jv1AmaY6AVJESpYodM9", - "+DbR6NBrhGB/YVSkkTErhTOpLtlfsM5Q6VTY4VSqdA/+ZH8hMmDwYWh0Jthf/vIXdtGDOhc9Br8++5b+", - "pTLoekll3mpTy14xHA5p5HLK9v4vaGHfh/kpcc3wINqjltFZfwr6a3WqKEf2sN7zCxVGjwCJYaprImPv", - "onfgFvkBhuPkanbR66PLX589/fbwsGy7Lh73foVWP1Zk9bnOB5QdZyIVkJoPZFsqvvBhBHLh46kWOi0y", - "EQOmWaGcxPT2gmJ8yGpMJwWn4H2I/YjZh654VvjswHKmtAHnVYHJ9OkKRmHppXjfGw6H++M+yHGr4Qjy", - "JI4hfiuCn8oO2alUSqQgwF0yR989z1ylL/Ag0UaMGSTL5zMaz4Uq2dJzRlgCNqb57+0HvkjSHDghN/oK", - "Y08KVUFTeCWukOc8cUY/WwOLtRAh8i7jv0gvTSSGTpaxgJXQ8iH7IKxwffzOe8f2Y7yjDwLss/fv3/b9", - "BlCQfsh0m8K49JIiEq0jT/00YOThty9/PHn1jBZzJFPg4eiMRztlhZGUJBpEnbRMqNRfxVemvhp1WqIw", - "xFgpQIuAG+wVz4S/zJsCOBUp0F/IqwGVay6Y0PKL0xP7nEkcATCU5Sqd6JuNESpe1n8APe5h9ORKD7Ur", - "e11VxEz7vnsI4w35yjE8goyPf2Jv5XfBgkerizC2dPE49yRiBBgyLONw/bRznomUpVyA+A3N47sNmq7x", - "+yfWN63EdSaVGKQi9OprDOBrGgrlSFJaDZCICjKyfH14OOx9ygfn2qJ2i7LZ82E2DONcY5ZnzxP7d7qF", - "Pv3q83ol1i8YlahQVHQ6OifbhGfC6V+E0ZB3GoRe+9Xm1PiHUY+mgpAa0AJ68GsGrfThsstNmuGqT9n3", - "5+enESSFXO0xCDw4/QP5YkiytNDkNVjHryHPnHRsIhJeWMF+VPLS8KmjX1fi2qAsIuqpZSR2Lzz+9rbR", - "rZ+meQYzP9d/F0b3ujizY/mB0wOYJfNrld7LjpbAKNkytIzrKsKqVpaos92gurVCbd7ZD8I6bYRlCvSY", - "jNnaZMN1sDKKPgGulEgv9eHSOwaFF6aZoC2nuvHh5W9vmdI+nSBTQqTWv7bMRZaCqnMpGmW4uvvuCfVA", - "m0cN333vYpFOqFz+ishirXrq8CELhb8+/BrDgWM5GSJZqXjzqflX4c7jeB5QvsdOwKWt0RvyvHmCtzUY", - "r4NxtbTfDYgrAFivCE1unERRRdloaMtatwptib4HKWwlTp5ZESV9RWmgYF1S49Ln4Zm62oQRjlM9aSKt", - "WOEgStzuRBzsjGr52PU4dKD5sCpA9p6/PHAbSzLBjQ0gT82E+WcSDGPrtIFrjG9iDKOgVjDPa4m6hOHW", - "iDOTGcHTZQllTS08X+8P2srEFC4rfr0a8ZRgH+sE/2AKYuzmJY7zU7vw3ZrjPl9mpc9k/P8R53tHAdGE", - "1Hcm3BaJEHjk2eHTOn9ec2LQikNOyavPI+rAs8NDqIdmFAssnIkkcIPO3UCqo1XUMmI+aL0qR/Z4CZ6A", - "/dAlPWA5WuFCrCHeQL2MCGIhaEz7reLgeYRfkfFM9erCJpn0m5Qhhft8EuQ3LzHu82n69gOywn2Jr5B3", - "U1NqymUFFr/5WnCivF1BeUCp6ChRDoE8dPtsFiAMqqg0KwOtCrPDEgqFWwhjEikT6kpkOhflJcF3axlP", - "g//ds8OvG34PAJZsT+nQffDJ06Ys+8SWIknaUiqhyPr68JCRbVKm3IMfoaWgmccnmbSlpkB+zA/k7k99", - "YRefyd2/nKffpMbgXdyOnEaLJt2wowk3eIjU9tvCVFQihiQVmkLIsUGeJCJH8ipcudObae05nY1hKMPb", - "83qN//xOdGCJ3dlxLSJgHVTDMk6vw3Xn+LJvYmmPdYUPf3jAeUCzBRvL9Ij9asW/Pl5cKHB2P2K/hk0a", - "AEXA9xcXagyaAu0OU5iwiWyT3iA7WGilnVYyQdNseAXgidHWrghab2IGbNQ33LoB7ung5JWHZFXLqMGw", - "EiAPmBP5EIaNoeCLYDKiaQ/ZKwTYg0FRFCSRxIznNlyTxjIdEzTiUYDBMiIREmCN8DdpKS8gIrA+ZXzu", - "AS7cnLCsB1aAQiHheZRWll0LA6KEzNw4Ayg8KQDOcMhe4tueZXaOkDjOIGzaWmvofiycSByOd8heI/Ze", - "OX0bdKuVJSME2thteZvzW0VPknhZFAT2gaN+jv7NbPz/4HPM8i88y8aUZavWnM5SYZ2/MEYUQQ/8Qebm", - "awnrPee5CFh0M6GEgbeRuiQcD9lrbaLG6FdP+Oup512Ciib8TLYHxQl6UhjLCusTwOikWAgFtfBxfbzf", - "r4nzMVDxGGlOm0VMsrgIKWTGXlP6dxzWKyxMQq0fofKgX2q8SdJTJER9eltzroOJeiEYR5BGj4Ne46ch", - "e4/vXYZZoVJ22LAfYXtzbSVdBrrxJCKe1BgLn9uIjQSwmfFP2L4r7pG1h+ycXwoL9RKRYkf4cDAmuhnT", - "wYuv4NSxsAjnbDUKJDDNDozwZFx2lwkONFlDkBlQk7BDc2mdNktaevSXJ8/n0mG+xgS7JTJAZMHxLgQ/", - "ZB9gVMTS8NpqGXfs6eGzr59jhUjMvCIJgPFsYaY8EfRcQkCCyOwzI7gLOM9PK9NcCQugFWmOMcqy3s+3", - "iQa4Q5RWpxP/TYfD6IvLqrA6A9hRgmAfnAnlWJQAnQ74azHhhZurg7nWl5XkPStJvBD9Uau+vzgjSia+", - "CdMpHsQgmwlnyQ1R5v6+HjDax4pfyRl32gwTIzAKhmd2CH4/9Fzd/DvBQwV/DjhvUW1KBpdiySoF43M4", - "me+PaqbImS7TQsOCaHzaiTq+NnImVQSEjxiRIadd4t+EwjQ9RLxaknGh3mqJ14sTX4EorbwyPyEoYglO", - "JdCqN6mcGnnFnWCXYmkZQcgL5YQpX40u1HlhPPAm5BRFl0WLJ2oYoSUxMvMmUajq9wRG7jADQ1mW9smb", - "GRB3kt5NMgF/05avPF9FoN/yicHjnWZ8dg9g9WvTVOhoY70vB1Qrxx+GrnOhUPABMYs0oIQuI/wkPPTQ", - "b7j5UrGn38RQlDr+PZlXoHCAPFX9lSWmcJmZcEx6kqjSXHSvdQZxcuuTKWE3D2uvTh7+qySnHz+8YXvj", - "H44/vDt+M3p7fP7h/ejF6cnouxdnx6MfP7wZ75M7N5KadPVuptOAcIxPzSK1Lfagn8TkBUiB70EIPMwt", - "sdbFJ74ervddF2/f+1124jeBxQ9biPQQxk3yFmmRLAZ6Ot1BwIPrG/nlDdBvbuu7XeD46BhOtQm/PuKo", - "o26NhpWTV32MMLA5T0SftFthiCUi7v1COA4HZTNaJDlJkhMi+iU95GPeWmebUE5Cshy/BhUofzu8vwil", - "htY7eEn0W2xjZdAHbknKJrAlIG8rO0kQkeXnILGA2AIyijaQF8Z/GgIUdvkbthHcWcKtFiqzK8krHiDD", - "ShMrlaAg5J3BTAjQfWExpQ+bVLxFfJ09KwQbo4P7eN97s1Lar0VhHRNwi+AEh0D+QGKROxD9hi8vlJ6C", - "u7hUsnKBBdHqadX260TK9kqXVq6YDqkAvQMgEdK+T+EQZjMtFN2PaXS05jHjC3faOyoO2VvfK4obfJV0", - "0b2xcqxB44qCJ1HPslVPW124gZ4OIsIllXjOEKo6XjBxVtL6rDtw/06Ez1lwoQBw0jZ0HTLg4FOIVKzB", - "9ZbOZ+0t50wrgV2Ruy+ZnKBcP+BHg8AAMYEtpyl+rrlfngl3QbmURnCro4ySkYJ97i0o7qVThBKnGZbg", - "tVS+XO3nFyq8O2vjn1p4mgb/4pBAgFqnhN6+Za0EGKvCxzK7BeV+l6potL2+CI7iq9Jsl0PVOxuj6EvS", - "fETsA5+qUEaU5Vq6LLJSr9/D6zSUjKvRO+pVnJfhPoKM0zvq/ePXC8XYpVTpEbuAji56ffgG6eeI/VqY", - "bOQjwO0R+0ejM/TBv1/0fv6I1WBJjxi2yXAzoFXQzUYwBxyo74CxisSCUjiZAOlem9IwVsF8KGfIe0fs", - "V7guQU1KIw1+xTxNJTHqacxj7d/5aXz0r+fXI0LMY3sjbLfPfsVZC/txP3pd7/m54ICOvI/zP+3eXlkk", - "MM0Qy/TZr5Ss4CQ98sLF/uPw56HT+Yh+AJiVfRoN/OfjzxeYS7EHknP7NlfE7J22Ghp4qL3GmXTbbChK", - "M7vHXWZeTG9oI6/U/NVvbixGF/AL2JWYZRIXxM/p503EVKUd33CdQqq7/rEr6G6TTPlM8bY7Kk+lukHn", - "YEwDhHVQkHKpLBmGUYaL62xJZSta1hf2EgoK2O1Uuhad/eDXtYzvq7o7BNdQRpeqUjdZ1hT1IXuhKidZ", - "vDpXQB+iHwNXicgIKKR+wn2oxDWVhNAJAWoL8lMFbSRxIwAc+Rn+ORz8+edfn331sRvoSMNTXYUOA0D4", - "8LOCEMIQGG+gkd1IhCKaNj2SX2GeMALh5omjB7patjAZEGno5UPrbGTEdMjeaTUAo7ktJvAWkIok41Dl", - "il7rKMYrZOyKbwlCGp/wi6zwOi8y7rzBBWEQ4AyVajbCdukRnCD2huw9ZViBdi8UlPP5yJ0wCwn6N8Eu", - "V9Vg/6rnjYeUx6u8blQ5gQ4Fy/hEX4kL9ezrQ/aD/C6OP4C+V/MecuZMoSifGHUdM89Ee5hcCAT+8itQ", - "8taFmoiZpMxNglk00ZaJlwqX6IUYFepSgRUQ9GIy9pHByEYduu5T3qRw0ibXGPGBLDhvX55SZxsCR1C8", - "82u2GkCCLg2V6JGnGOKRZ4VlX+NG6Gn5Ig9XAHzv9NElMayk94ntRn7GVH1DZEcwHUdvADJslnJWpUxI", - "pKySJeieWuExfAXXpswMtkb6wy8DphBqff1g+/CaHF+aNqIsxCZixlUf3TIkJs/yF3jgO59sV2nHJoLp", - "CXJnOlwR00TrjMegVJHeXlR3M73xmB8S+KHSma3a4yZLfwtGizfcmDDZ4pKJxUSA5uSzfSkX7Nxuri3e", - "rciy/l6R1wW+A3om7YcXbx/6t9BKOm3WUvtB8Df2F7LL0fOBEUGZuFDREE9yOiTKgO77oRp9FQbMwnih", - "qvCJNLAJdFNYTRk1BOMD6pSVZFDRjg4Lok3ZNj1S4TAri+jmYkGJSzAEy58gwsIJRYnf0E/F2xdwHpaM", - "QfxfhYgHJbUbD1GKVmw5a1esTP0LhY9oZYQuHE4+gyMtU5+ShECxaIRqmpcP8kwpXQhkvSvHp3260JBb", - "cTVfaEtcRd18sdGf4PgGl6dmXfTbsSG7h6BaI6rVnOIDr3Wdcnzct9jvbBhuSu76OZXLV15Y1aWH15N2", - "TDT18eP/fwC/2ytePuEDAA==", + "vMODE4qsstmSiRsUgym0LltG91BqkJ+Xb37Y9YTW0+p1MtuowS3kou1kiVsSGowbScc97NvB3C2yfoCD", + "hYqYfWHz/fhhlusnaUq7QbN62PeHGlBEKIEab8g7QDJ59e6NQaCFf/kdPt70f2OaAAKkuaZEf8fTqUDw", + "7fBc4OmXytfA4GniVQJ5dnjo8bATMvJWzvMrnskUhRveSDhpwV8dft0CGor9tZihGodWAYt5/0OfvdOO", + "vdaFSpsZC3oftS0Cth9n7DWRqvK+yiMWkgxwC9PxC1Cd8OpiXM+1FUzElfY9SQsLOGSvgmMzRgCTyr0Q", + "HNF89DSUDl7X1DbI8WGX594mlc8vQymUN+p2gDT/0nBg7Pa3Xz4TT2DtVCqMMNGdNKF6bI8rdtF7cd1n", + "Z4rn/9dFLzjV7APCVFbDKoqVpbMiw/kvQe6AW/+QfQgE6bcn9OBH4G8J/UqsEX2D3BGhySxUHxP/DwOa", + "0RjQ4X3ktYebDUMbQ/NjFnQLJmOeza6PBdDAXfXI1Z141CFbdUiMMvC08YD6Y+OO7PZovQFRr8TAqp6S", + "IdKmQvifFjgPeodekRK08sYA187+26+m7eh3MIotG/BKL14Seg48z3R433z1/m2tQgAMhvWGBodpbBHb", + "wstoR4Dg++Lzxkk9Mvxmhk/1YuSBlPBp8MF5v32X7vtJMM1Hcd0aJAV5ZC4CKCkjBzOfr0kxv7aMO4/o", + "uMYCU1iPPjMi46ijOL12HpNL5Z7SjnYN0WD3h+xHK9jYWUJpvK67tzVE/a2sf31mWzWRNxhO1hWMhYLP", + "WsBYnvpl8VcaFGlANRVXGifMlUBFLLQ0l1O0tJam7ytpC57B6kxkJt1yyI4B17VagTxXydL8dOB7hUmb", + "TydUHn1yusmQerziA8sPT81AI1tpOSkWhWfOGm3tvXxztu9JO4atnwqDC6ASwc7lQmRSCUAn/bSH2Or0", + "Hs+vbrQHC/aJKe9B3la9i3FDVseVsPEaQQvlzHLNL3rPJ1Qhi0O1gmW5MAgXv98YZF5d1VEqHJeZ3T2q", + "PrBTZeEYd87ISeGE3cJ5OKV13pvzFNzcQV3BxLGbSbq2SB51LREpGWcQ0hUbCY9m6CPa98ZZTDjm5cPL", + "N2fNJI/qQkMgfrVfm2gTzGXS+r2CVBu0EiFC5M3ZfvPRv0aT3l63I0p8QIzD78vkNrUliqD0jbcj2ZSv", + "v3HzSn5votbtMAer8XwrE/ZjKQEHOihBSb71uHgD1yjrmFfzAMPklEu45rx5efpbPS+SvBRGj+dE+zmR", + "5A99PFR34p6PhSzJbymGPU2XJE0UfVcx7MHZGqWPTMvmA/+/eXlaAvPKaXiua01UMWoWNnDzQiJpaLcT", + "eorSabvIfPX+LYMCDVKz0k+zMZ4MOS3D/oA/dh34c39gA+HbAT3qeKC0GBp5LhdSzQYvskxfD8gJpXG+", + "wIvtMMrcCN4yIMKpY/ZfBa+fB2Xb29y/qi3CfHAKTEPISCp0+Kkl68PDHnrVoYEMo917gHMPO2pSzm59", + "6G0/6TTffssvb+6rhrwsVP8cJrw49sfjbMtxpvmDX7Rre/EbN865eY2cvxTTXJlKvBvHVjMlEbDMGv+i", + "vPDtAv+yl9wYKTCHUARdmlLOXalQak0w5YZjPm2OT8MY0vtULXGria0+rXRYWa1HGbFZRpSb9cCSomlf", + "dnvRu92prgKVU4lds569E9dsc+Yzxq2VM+VD7JAltiQ/y7kBtbh9PqdYYH1K5DxGOfQrndjnPjiPRtCQ", + "+My2ANfvmtXs3nKXfdqX1ZIGnL63/GHk11vRvEoq6swKm99bQup3fAhueYiL6dNWDOxszq8Em2g3p3Mu", + "emLZOu3UnlziC7S0rNI8vcRgOiX0gGcnKhW5UKlPrFKNuX3OOIN8fZmIwIbBuywCDU7wrJTuU/p4PD7T", + "7HoefKKnmnM+eZ8LteHRUYnrqOA4PkGPLZInsKwaK5NuQ+JgGGKjzzV9gbSPdE31ID0cXFxsCMbgNSg8", + "acvo6ujifh1TeFpdwxzeFknt9aV6DHVFcYpcgeQHemVTfDXA9ihbLISxzAgKH1/R0zAHXsh7NkfIMWcE", + "d0w6xi2wZS4SybOdYrHvSyur7/KjUraZCR2fjIiuPynz3UInw1E2a07nbR5WwMPo+uxZF5lBK0FxVmq5", + "q5LR7M4VzjslrrNl7IpPHkTzcNJlDeYfiuvLvOyBMlErFdetg2lUY0JTFdNZexv35gWWcQc0/CKXkDG0", + "VUKD0KEtXXCFJsiq3+nf3tYAkVMjr4Ky4Yv02ZyrtBJnTzk0B2TPHPBcelj4I2ZEgtnRZiyTU5Esk0z0", + "2VRmwqftRHXI395pMD7PWwRMhBKV7PZTOfPvQ0N2PhcWDZ5soa3Lliz3CzCQKi2SiDiZGw1dMsuvRJ8Z", + "kWd8GbIL7dcmy2cInJyQEt5V6Ppe7yx4G7bvUfS2i16/XJC6dQQk/ZDCt21rdkelR+arQdKvTSTi0bO3", + "IRkxOGIfMR4pnHg4CWYgDfdMf/3wFw7UfBxaxyWWGCc6FWO/w9yWv4EPeOy6iehvi4JPUsJ0esSB/qiT", + "pjPjLcLcp5Rl/4llsXQfM6eF+Xixg9+h43wcgk+tfEqi5vhGJKD9IfbshyCixrtjdcCGNkTwxOe3dcEY", + "Si9kmmbimu8Yp9IYAgIbu2sURG29K7EQHfHwTo2+WR4bo80GIydXqUDxfrMcZHwpTAh3YHrik0LXgVqG", + "rHaHdhgB4oxmgkD859q6AbZHO20Zj90QNgs5ZGOgSVylwCUYwfBfA8pRPcAZDHAKYx/idYSQYs/o/rE+", + "aovhtZx9ffhVOT5/tXhiYzBvrjOZLOnWTJ2mwjqp/KH1Rl8PrnRWLERE0pc4EVjqlPaSnTgbDOPo1jOo", + "hm/AZ9ArwoOs9IitvkwIVPNgVP6c8yoIDdE6I/jiiCYZp4cnKUZ80PYgTEIZ/AF6W2gg0ZlP8yVjym0v", + "cCRG9HDFdO4GUjEjplLRq1wIDuTXK0ni62cwS8WUF5kbwHwzYdDWATY7nn1iTKoVKn88jNsPY1gpH3b7", + "gMdww37c9yOWTkVj2v4oDUjQQLmjTSLF1GNyqylMG4VWXSC2iL2YN30hsSbijUB5/BVduu1RVd6MUAyJ", + "tF/7Eo/RUaEqoXzBKEjSa5QKJaFWbjS87JvRJOPJZSatq31bKCN4Mqcm4rdGUK7Ovo9eHbnM4guaLlz8", + "LqzPSCrYrEw4auJmWR+YEUBF0FzTsIucZFnZfPwmVXbkRVvl2zpg95C9qO8PyS90aqgkWkn0TAHDyUok", + "KLesUJcQ/FqJsqu1BcKPQ/ad1NtvArM07E+v39u4Qb1+r3GHSBqubVH168oeVb8OmwS6wNoulV82bBO1", + "Ut+nXr+3aaPg7rqyU9WvKltV/bq+V/ALLfi6hOn3bgawuoMrblD5g2V+VS7od3GVK19+gFH+WBukD4o+", + "xSV+FVb41K/Zd7UFDt/+WFvf8O2HcnnJlec8s+dx5vRVCNs/qS4tCpH6qD7ElW0Y8o9+tcrGwzevlH0d", + "FzV8+bIKHx+6Q5H1Y1jc3bADaHPKiHHUjLClZm3ac0RD2lKupIMcJpuVNGKuFXAI7DRBN6/IlqhqUdbk", + "tA9BxYYnThjLdOGsTAX7Bx/8cjj48+hnMgkkIUZ71GdgGtHWsW+/rlQkJl7wmzdCzdy8d/Tt1/A46Jww", + "MP7/N7b37//20Jh/m3Aa7i32f8tO7nRFiQDDa+fe3jeHz1Cxvotavb/r9QdJMM5ho0/HB5Fn3tWyCSsK", + "fcwQkdzIBQwHc5P5W7C4EQkp6LpweeGYdGKBOlalAiGVLHieS0JuxvNnixoDo0LshDC0fo9AA7bWAnSF", + "UOljVKaX7/gC+nTeRKqV6K5TrTfbuVptDqvLXvtxN0s3KNCjybdfw99bIKxXoE0qHI0bcdBUYy3D9aL5", + "5WVV8yWlt+yvXw50g94La+GBz3a0OPlazGlPi8KLSWIz3z77cHz6Zv1i1Sim/5NfcQLyYID1UATcYM5y", + "Yay0sFfsHeg8/8SrIfpYXajz6OYwkfjObEN5ny0OhvPi9CRag8WNdLaPX8PomLQXyme+0Kb6NXPCBMYL", + "wOAYcY3l6FQcstNycKggXChMsSGvRHiYG8wyPeEZ44j2o409YkmmLd2MQ6CiDaYLlnEH1jyRZReKXErI", + "85W9LhSlCElFknGyplhWWFG+54cuMEl2BUnkQsHP2Gi971oH3xmeiAwt5kXm5CD0A7bEK27GFwrEGjni", + "MiMcp82Wxr/0D+LPOHWjs8E009fMigVXTiZ2SO0wqS5UxT1F2JiGhNr2G2ifs2mYM6UhgYIDchvIdMIz", + "y1J9oZR2ldUZD2EfCInaCLr9PGfj8PswN9ppYIih02fITXv7Y0gCeaHETa79cuIrqidB4FrYv0xyO2Rv", + "xA28rtJuo2kj9EJUcqEyqS6D3cKnrgnaTGXrAm4LPN9AW0BVSIeRBocX6kWomPley5RshmWCXwlvlcEW", + "PPOdv/r78+rOXqiEwyJVKjPpMPOwk0nFUUgucm1cmBTpmc+RwtKl4guZXKgxldnbHw/Z8U1u6DgNMD1Q", + "kW42rjAKVqRwesEdPUcP2Xt/WNkLpXOSNM9JbkASztxoeF1hSpe2ZqjIxkbk2fDaSCf2hsPh/phpc6Ho", + "W7GQDsU5/dLH4SZaWZ0Jr1GSfS3Riwm6XaMRbyEADUbaBWhfbykDKKWdLPU+2o0AvQivQgTiEzDy0ExC", + "zgF/Ym/ld/0LhfzsBQ6toIXNR4SvkCIh5WKhVVTL9FVIPoLfP7HU2IXyBQbodol9RY/+IJmCCueppUVr", + "E16/QONXizw/9y2KWu5RaLfvvV9D1k98ofXzVFFUr9qKqxYjEpUjK5LaOL497K9Z42/kolhUtJuQwiUY", + "kdgrqg3L/+3hkNRmqNM7+urwEA5ARZ+eblXb8BTaejbaItv9aAxYp9VTkMg8zqzhUGzTBD2jMO1VQgQ9", + "8/ERxE+ecaKRJ/bynGlv99bGkzdSttKhKsU5UvVev4dqZEcDZFV/LYMwuDF8CZ+Df1oXw6S4cawM+ihH", + "FnLyarNuqYw3AbJWVk47wgHoHx4eDmA+YKlm6ARt+DK0PimmU1zNiXDXQqhyzWwjEXd9qlon3eoLVaPJ", + "swVTEC+nbCGshUWRVZ0/2i0auD3Pmi+CP568ehaugMuwSOKGJ45O3sFcZ7h4SKxBWULA4eDPeqHiEFbT", + "1oOYJo0CvfFlsahksn/ukbdsOCC58gISJQvE0OaZTKQLGcjqi+iNe56LQAFrFXV5NiqVts2GcGwtXomR", + "dfzikWE8NkNMVUIaX6i9OCrUJRKdYYrsIqeHQ3zLKQd7AHRbzOYOQoVFTrfKC3W+gpjKMv6LJN9K42yU", + "tthORVPwY6ytQIVMrePJZYMJBL7G9G2dKcmDUzYQ+1z4NxVRlWkireFZNoxu1b3Wd1AS7RZhXL0I7nZn", + "A/JTosGbBlUK9hdW6hdw2qVwxP4lKBHDTM8OpJrqg1RMihkWEMZUClxzow6Ii0tbLLaGloCUrGdUrfHl", + "KKDybb0NYsGul8Ew6/5qtbXVPRPmSiZbUejIjybFFwWZCLxJoVFC3OSoK4KKd1JClzLrdG79Ezm9C2sz", + "KKHd7bxwqb5W+yzVqDYGBbDiFvl//tf/Jo2s7AX79Vcn4tIsiJLBTF6JQZEDqSsr6YaU6q6ve+Q7dNfH", + "vYbVfHzga33g88T0CcDk2vblFq420ETd12ZlGqWnzfGNdCQngWDptTnek+jCGfW2QqXCZHg6133XTMzl", + "65ka75bIF8E7BRiSjjO3JOtGdIxj+Zz7ay2NPCA3MKlIld+rA3DuY9nTk1f+JkgvU01chC03hF536XrI", + "xsi0RT5GPE4bHhxx4ikeyuSXLRGS1jB8DxEp42wueObmy+AiQCrMkI3959AgZ7kRV1IXNlvGOrUe6sJr", + "PONXYtQ8oLATMVOsx+Tzt6OQnBZ32ZHa6gzs5XOmyoTNbYRCiZunsgr+EbaV7FhWw222kn3VxtCJyEu0", + "nHCk0jr0+j0/o0ahlje6Hp28WsNApCWI4NXRmr66NtAZK/L1bNaNy0TuY5lWUDXmluVkPDs9edWCZOsX", + "UPFF84P6zPCFt6jUpxHW0/tsJV5TBYetReGcMPDXmmfVuEsO8eqY+p4rNokiPGje68UPstWdFhTEN1IV", + "N97Zi71//3ZwKbNMmHDuoWUyboJU+PoEM/7b2yGjkyMlz4DxQSquDi4XdjYOMQ9AZlyV7IBNr3jehkNj", + "IRbaLOOGalW9bfn424hOaYuJb1NEbGsSd7bIYaGsSD/xiby23I8HcvuBjIs10noxApJ4yAO5eVt2P49h", + "nCvHcX0S8ThuMrtYZ7hs4sCf5nVeEIlMydwXWHHIxkorEY4Lb+hf45bnbLwQi6RyLCUzo4s8lPTGPW7Z", + "XEJmxSQvrHBjdoD1tFl63wwKHnr349sXB/TFAJzo4TFVZlkpnrXyQ7ZMZ2lwf/tmeOjj31OZkvYBvcIE", + "rTNFQsDMY60XOLWjMcukWnEwgcki0vUigbOFxklflKNs5NaFWIymRojR5WR9oV8bIRhtWVgSqdgP8jvm", + "vZCqYCgwuD5LBcHlR4/YMbR+9C74IXtTOK3DE8veisXgRE01S4tFPmQvrC3QfM++xn7IU0r+Iipw4QFz", + "3ogk43KB5g6EB7eofXFmF2CcJp8cf0XPuJkJ3LWR045no8sJvi0w64BGYftpxWmy15y6QsWPzblJ8c3C", + "Yjp8v5tyWplJfe845W/CkcUJWp+9+kI1snt1aA2CC36581a8w/W07MOLt0RFd9iOh1mFbZqPPwyD4tPc", + "Bv3Yooi81ItFc2uM13H/K/PaW/Ab9vQb9A2x/cpZUSvW4k5ubeOWfhAW7wXMCkeHTfOo/Dbv2QLHzZVW", + "A2MtRdXQX6jbzhdiAR/34UWEnHKhtXy+tPhC5ammqh4CmRcWlbtmImpeYKfzkeP20jbRac5KJQNtdzTL", + "gRVugLP0XS101UWYKNbS2kOTFJu8oi3VSHV8DkOgG8aY+cjnY7SlbyBKH+AGZV9yvAxwx75hQjlyGdds", + "oguVxlMLiR2JdRcTfO0EhXEih/ObE2rjm3WrvDNyNhNmtI0BfLnKVbQLK9JhwlUKkmz88vTHI/YONHn4", + "DzDEUXS2Ks+Whn0PY+zMYJHQ8G2PZ/A4DMWicbWSOs+P22km1ZW+JIW51K2H7P3UBWchfFO3bFwdyZjt", + "VZrxTFTxbxJmH0FSEq5YKuGVobwv+UoJDdP/DGt6JRMnF0P2tgv/N5q/V/OlV9eO5F0UEV1VMiSo3bSx", + "FzHo3+8I4Vlt4yo8BdZ0s+77fhe5uY0TNp4B3YVu/RRdl0odHM1oE/2Obt/LSmjqpljZanolClCd82iK", + "JcqO+YBq4eD9nsSI916/B450wvT6vQlPLkG1VenIlwlX41jEzrkRafkZs0026oxhHiFk8yVdLqSwLzFe", + "81ZBcj7DSBkHGuJYrHAO3YfgAhECQ1uvDTx3yXz3IIHVuSz9TNZzSb2kHpjV2ZUIdhOmC5fohaBEXP59", + "zSMAP9Q4MikIA5In84NUOARfj/a94NwJBEWxAqAkoAXnSorrME6rM/GQg6QewuPuXqZnfQbPMn3yCN3H", + "Ua0/xMV1dEZndxgfNdA6vBcz0Ez8Xc0HATM+41JZVwuRhtcO6K9AFzBqld5W++w048trg9n/664EfWYT", + "I4Syc+1snyWZzCcaDmDyButXI53LRvViwVUaEqleiZVt9DlrnTD8oSnsR4JWjl0Fi+heksnk0vbZpVjC", + "M5HFieoM5PjHGLbwgAPzDsd4qh9Ed4OQzmhIEE6zh6TrU0RejMwWFqYK20Npe1fSJwAEMY0vhJA/pKDK", + "MluN+vcWyLVg/3oWqr0YwV+N2++H47ZTpP7+kL1tDtB/zvR0Cqe/9zbCNihwENel5JiH3D1hpE5lwibc", + "im+/HgQHMBCMuTauyrdD9r2czRkFcG4dPa7VA478uxKygV5NypRsunADPR34Wx4annB4/nF4EIzsZHQH", + "Aftxg4rSMqLdDvaXVZrw+eK8Glo95qmH9bPcZxrb5OkgbS03mVcZUnjtZtUU0cyKjE5kKEY7dkQ+WORy", + "I623T+35c/N6rjMRG98vfTrLL4EYvMUJ+vKdW3LeyZbVslJY1Did9j6LML4X5y+/rySxbhuN9TBdXAVH", + "SNwtNv7143gfpsOZ0gOdP68PjvyAKSg+uA3617hz7bO4YR5UafFPXla9kpxG12dLXbBFYR2OAocQXILG", + "MBFw+GRj3Pxxs+tLJyJL8/pJvRuZnVUVRLRzAYCnP0jjOx788EpcnWudWa8RkbGnQYsMiV1H3k+1AZ+A", + "foANRcoA9gvKer17isIasvfhHp5J6+LGVnZViX1yn0MRJK6EWcLDjLdH0Ujg2TrJigiDVeEjryYH4AhV", + "Zqf1Q4EKZO00IsPUgh48K4jwQpE7WNpn0jErF3kWfX/xRdDnqAZwVYm0nBqdYxNzOZsL60Kcu182VJvG", + "Jyov3DCVNofgpre68PmG4XZp6GFxXiy4wkiwpDClmzzQFsKhetY6i2J57C2z3IvqhFtySYmOuIVRwZmu", + "zsrAtbsbdJBEcRlp59cdKzsR+m3I+7wUlQ3yNAIpnK1LuArRhT2+FMsm2sMRI/lV0QPCKWeFO2IZaLjX", + "Av4t0Th45j0nrM+FobM+K68/fRa0B38v2x+ynyhLx9iPaNwv3SUqwhLkjhUuZJs8QrGJryxBxj+HR1J6", + "dw++tDDx6ZQcwkFhrrS35+86Me65j3fqflW/3e+zsa2QGMLDBQWGnngajn+UjhMBS05BCRpijOP0/KaF", + "3Fo0YD8rlmSCGxJNrnmXaTLjhVbSQUhkpGLE0ytRGUgb2Kene1e2AZJ9Lox4jllQMn1t667/aAJDHw5e", + "XbL6adrwJuyn1xWMq9VSAPm7qczIRwDu2uQZVSvbA98d43Zt5hhrla1Yp42/Q+w0GqoW2ukoFG599K1r", + "WMhH8YLqVSt2xheCjT3ZjcvAHwQeVEuGtp5Yvs/yrLB1w0tFiKzfVeuGhnCsNrkSpPnOJLOqHMAWP2qG", + "fwzNsMaVu7HGa22uOSHR6Wnc/4qcdZpG7aPIapg9KwC6iLpRoaIjRkLGnzisUBlFMNIKYEwRSfi5MKKP", + "ipPPpa1C1Up/2LTnZE+iRDh74LIdgtXBVhaPOt8Ihdx5bHf/ndNEftWHklCtQnSgIUHB5xTLSTRX6YHI", + "rErcgVS8ohnVxSZG1y7bmdPfn785rYvhLiSyVms3MoHqB2hQ8ssXpN4t7qMNRCZRegIhlvp2udUMeq9T", + "3vuahjFk33NSvTGJOtsLg3R8aZlUHBOr78fgoa20dWtOrB+zu63xiXd/LUEBsO0I6Etgo9fKBrmNy+jz", + "icJzN0k3oki8xfAFRh8pp/1FKS493lHgHWs1yTnbW0EFDp/w7XAfxTUtn0fVtk5Dg2QOs/hsOBHsn1qq", + "9avT2tPMohMXE/tWtMDgKLwzU5KzS2RJnEA8FujlJvTTjOu9CR0+7FPN87N8Dmp+DlytrJrB/TvRXk2p", + "2o32Xnkl2OtzLWcBPAKGF1CkICwvhuy9qnCjP9JBcQ57DhvjyZY281KI3DKnU758YtlEzPmV1OaIya7U", + "QJ5oXtb04WiRl6C7IWmO+/4pvanO/Qhz9h6uY95oEpeKUOHCIso4QLwVEadA6Bn9rHOhbImRNJXGutBU", + "nennHOixbEylXrRBE1HvBEN7kB1SWcdVIryjfYKmCGgmpFLh0bcAe/BKDHYjbYyeptF9ffjnJl64paC/", + "NrDYmAeymZh8jKwtlb0z4RiSLXwFpBMWXis/8yvhLUiepUvVokHWw00a/FowqHwimI3NY6R+XLxy8QNo", + "YFi9sMN7Xx/+eb/7aRGCC8N9RByH2MldNDaPFYlOCRMPABqcwctDDO083gfQes9JimbwEF9r++ljNRsj", + "uVoCJWJvI2p6wZGrg7/8Qfky4j0+D0CRVEDZBx59+CCVFoGHwdzwPOa48A3KgNTg4zhBP+JO+lTalSf9", + "lZGgo0G1pcYXeutEviFiuVxLKEjUUC5eGbWg81FYf8LOMa76Bf4pyLsUlrrfi4tgCfEG5h8KymIxmmZ8", + "Zml/YIm2+zCHOYctbHKreAnPkWhX7AqZsmLLKJxrStaLTTL6ldySyFSEsqOyTpmYul6/h0/AMFQEevU+", + "F+TqDfpf4z7hS2oLbtO59//AMv51utIrvLwidlrPN9PYAQQPjy7FssmErVMCnYKfYX5QNthk8YzAVit2", + "0pYwyNKJTRWLEdayNUCBp6uc/g5RgFGky4XwjJUL74MT+l336rlZn8V/sUTjcyUv81TSiuWaAg0bW1qu", + "t/Tft2lphVxvetB0C5HS6//tImVDJOqK+cef4qVrAZQLIB3bcefbwk9feleHF6WLwS1czYLDhKfdKiQR", + "tyznBu/WnES9N3TCUIKrOFlmvIi/UGUrOWVtjGgXGOWNbgB43afasAho5oACvm7ODV8ID+127I0xWsXf", + "qWYNhA0GFG28HkuxOUoGWXkBMmPbxXddYEHYjOGzbtVfGT5brb3QV6Jb7bf6SqzWRt92EBPbKp9CwR/E", + "slKXXD+2VTzDUtVqwo3osWdrVeFeYsFq7UyIrfaFMyjkSbgST7MezRU87dYorHYOV/a3tt7U8giZqbqU", + "cWlqe1ubeZjIzy2AY6PA9pumCecEhODH5WmKOm/kciO4E6+kwSeE5e0Oz0UjZljUNNLQOoOCbE8nGMeA", + "s+wzjPf7j2++2a/rxv/xzTeoxFWQFg8H//Hzr1/1v/74b80J29y8ITB+YnUG0qYcBBSEHhKc+konB8N/", + "3+6+Cz01LmZhnV78JCZvX56+ElMMptdqx8WkS3hlSIkbAcjkzx5p8udfn33VvAKXUq3W3YMHrv9fkub7", + "jTVQym2VVJVZISR/uO/bnCfNCrXTeqs0oAbhKT7kO1hb6OhSSz35GYZh+262bcTbMMcd9qAw2civIn5u", + "134WUnl//qcNj8HVydTa3DZoWBYbkGJ3HDysSn3UXXe3QrMft8yGOmmaxiuRCSdOuZvfTphs4ePAvSl2", + "c5/cSwOPiSFuN/omE9rJWnalMkFOtISEGfVJL7KWDIwHsegBXr2G7EWWz7kqFsLIhGnD5st8LtSQ/TQX", + "0dbTrz3dr/cmre8tXZWxfPDLi8HfDwd/Hvz8P/6tm6XuFV3xOlrm6ss1R1+CdqU2XJ+pXJnOvCVzO8Ly", + "jAx3YnuTvjSD0tDw979ApAJizSmwzskpvqKnwokEg4X2Gzu9lqmbb+8Ni20cf+PSrmp5D3OpBdWk5UIb", + "L7J0s22M9RZwwa/e9daw415BkVW8rYju5QcCl9lg/aP0D04z0LEYz3RMfOkwVXGEkjts2pONeGA+5RmG", + "WZbJa1bHFsyOwLlG0ArBWBYRYsEutHbzv5AND31soE50rIBbLcxhwi2+UvgOUXxlCCVdA8h7enhYg8j7", + "pnFid7nJwxR2usg3C+KAfYwebHrK/nHTZ8ufq9fmnEtj4965udHFbO6NxzCIGcb0vYXrlL+fMe5YJrh1", + "7BnLtfRBHXGkq0OuBszGcLpn1bP42fpsNv5Ie1mjYdjXBmd4clMboD3+O/ELLHhSYFKaQM24w9d8SRNB", + "c6vgCJyeSSW496bPdeYf+1BuY29oiLOjHP1gZkhpxA4iHyGTjRaE4ilnCo3tLShjleK1KX2zI1/GpOs4", + "rrUdPKFRrHPDVv5cm2fdUnTYbiqKQ0LaonHlwrCwXj6UGcVE+wDZWxoee1ob63ZYylbdIZq6uxqdVxre", + "ZNo8JntJGWJyb6DQK1ErHbGg4a5JWNAHFVhoKFtpm0w5+CU+MWC0C/z+BG4kT/rsiQdgfkIWnCf+FfUJ", + "u+JG4msNmWcWeSaO2EWPX3Pp0F9vONNO7z2ZO5fbo4MDQWWGiV482X/u0W1ZpbiTLhN7+88ves3IhDTi", + "7TaIcrWOfQ1ET/8CQVQbKOpOUKqt0U9rFHW/cJph0OvWHHoKj0jHPtIUB7dHCUz3ex8j7F8TJCOFSeN4", + "ywjZ6sQa3lsQTLC9MR8A17G1e4d47Pccn3Qn8nM+aYWFbCYq/+zzY55pnr4tMidzTk6Yq5718YGoAZyM", + "1IqyDHOaFdgkvX6CtwtH9MaoF3SJTH5NaCvwI7SIL+9+F3xP3p38YK4X4oCCkssHPXtwURwefpVAffxL", + "rFycXgz+TvaZ4Wjw869P+8+++abZSvOLzEf47rU2xL/LnHGTzAM8PZfKe/YVKueQyqYEcC1HveflA/vm", + "EKCpn5OhOuCjgE/9VFg3/KfVar8KOjSRipvl1utyHK738Wja+ooWdriLSaRCCE3NvpaZALyQ9S2WdpRK", + "s5k3UA9D/8do+mtWmBY6xfREDcTIrQObpZxKD1kA5WrQTSl3YoC1m8xrjecnTIssoRPpPAJnn130UnN9", + "Ywbw/4se04Zd9AbmemAG8P+L3v4ubjfcihrIGmwgeXOur0RnC2q4e63VgxD60WTpRAM/n/nwevx5yA7Z", + "tDIMKWyHyPqAksDxflrprB/ooLKHftHbyIkgFFpA3V6XGYrJEaaMrd+d/Dg664m0Ox3edi9jV7fd1N2o", + "pPkJxWOeQeaGihHh5YfjF+fHvX7vpw8n+N9Xx2+O8Y8Px+9evD3uDJfbqnj/oPS1WvMYbt7fV83peqL/", + "Xqge/G9E8K8i7YH8eQgHvYTX4RGgi2fM8Rut9AJjr3wzwYunbN278pAP15j8EsEZQ5sFHnZaxb1GXRiG", + "MhGQq2OPXkNpSPRM6l28x+3rMO4zI2bcpOiejI7MmuXFJJOIuygdOAtlmTCD8ku/AOjp/f7snB3E0R/4", + "nwJqYIRoC/6QmIoLYdWsEGy8MpZoV7mWRjA757nA7IYyjTmEvWedx96phuJLGxc4ABtB92AKfWID5Hzw", + "nrlQW/ItxQTSmz2Ta2nV+wFbYpTMYZhqJkZBDd0cOkbVXoZapDuvNopwEjs1eAY1NjXmfbp2aO2MasTm", + "yjjGzuFx9boYCNalLhas1oXt61r9VSwbW6BoL5+fdEsDVLaS27isn+lZt9pv9CzUrUSUkTPMlhZOyvLo", + "GNDUDj7Nd23lB7FsaoNeo0dWOJeJtHtz9HR/RtVCw+CYOIJ4+Y6b/EZeib9Jcb2y02Uznfc7tLS+6T5I", + "rtLU1mm+pSqvKjVWW5NKxoSUnRo7UdJnW1xtKmZe2Km9D6HWlkZ3bm+9rSr6QpemyoDc0FLIWSrTbFtC", + "O5+T8CTNxGptkP5Szbotk2/nDdWpL1Jo0ASzWZeWvLVsvY3wJNutESodWgFzVMRS39wChDzXIP997VQv", + "Rt61C1eoU0Ov9MJ7nL3BKrUWCZ2ko0iA1t5ghRVZUGsKgE66NwSl680keZfaSV6vpXmn0WteH3SJ19Kh", + "9rtYuKWNHdaxbKtpLR2fjHQuVKemzvnkPZaNTfiI5VFHLefUl1/RdqoJvndKml7BFutG701ZLvprcMe7", + "IknfV6rL1QP+Y3+XapVl6VixSQjtWrUqenar2yBFd2ugFOcd661ST9dqDRy5Q9VmsbhDA6Us2aHSCq/u", + "ULPGHLsMc1XO7lI3yXevs35A3GpDb9NCsyK9e+WoP+9etUFX7thIi0a1W+11PXa3+h/E/VS/hfhoUZ47", + "1q6dXV0Jrunc6yrdV+67u1Sr3Fm6V1u97XSs2Xjt2rHuLbtutSvcon7VyrFb9UarS8cmGnWK22aaolTX", + "8MSFpuYGs6zBLIjTBiOvVPTmILUKQNXDrvhF8SGlwcsn6jTrg2GZnq1iBPM8z/xjyMYYu5WHFD2Lr7vw", + "6N9sWA4JMxqedOWCHuvKEVVzY3Z9kWlxuqh23WRjfstBn/pcbqELDkBF9+YUCs0Jg1bjtIJH0OoruqOD", + "aNszxrvKCwYNoU/5KzkZct+efg2PLrkThqHDhvd8eIOucvCwSC+L4fPTbZvb+li5spudHB+6PDBXZ0ir", + "KFI/1UZy19OpFa7RRfHU6CtpfWJZLFZfupIdK9tF2TpXfLn6bCG4xTDlKqQtFibXE0QGNZf4gZx2eOHm", + "2khHjla+/2Bv91tEDYRgZ4gclQpzV3fKa9P8wFcuSOO26cKKUx+EV/WMr+9N1+jAEHtz+6jAthY6RwOu", + "BWHtRoX36OSKUUl3dG9NJYWV1zyWvnlop1YY805OrXf39PQPuqVbp8SAereyis1vvNvIs/SaDRTGnL4V", + "mXZtaSdyvX1URyqsG20L0aqgGARng23BHf2eNcm2hgkGpnObK0sSO+hXZtG0Qt76cTwzwtpTSre0m0vd", + "T3Mf/vy3t+xSIVDfRBcOUbr8eQx4EtgBI8yBIXunqQ59hrIim/Y9KIK0TIDmmAj0P6smoVtT36Yyc8Js", + "hlQT6+OQlGjRyMTn2+cKs3xcZ9K6mn+zn5kR08IKW8KvIfbAtS6ylLJIVinBRjjPmSauJ39yn/3hZkm1", + "/SQR2WZ7euM406ZtfH/ZOfCqvkp/FQr1r/c/xPzn64usL7cKnxOVgootbPDo6zAjfdk4l1MIfvMBOrdj", + "3LYInVftkTlR3j/7+nD3OJ1XrfE5Q3YyLZXZwgpbxZ0tM6RSlXC4GYFSwKuy3jPl28P+V4f9Z9/0nx7+", + "3DxEXFr/hLVtv6aevomwPUQIOD7hSRrzLYBiXmruiP6DjgwE4NV8YBixgrhx9Gt771i09BGkRJ/l/INX", + "k9NMKFtQ7lae8pwibpW4DlnWShdkpAlcy7ng6bTIMIFL+U3WQp6tgVGvWgOiItl89eywW3jUukf2zjAF", + "oHumVQfm6A2+Hkxll+2SkRChUBb6rLfe76fS3voaUQhyOuLIYN2cCjNu3aiwsdbaeJTXjCze5hAaAoa2", + "Mp6A9tPZmTHcem7pIo8K6ajpHoygoWgZwDKszO4TxvrEQrqufg3qSavGURYmaw/G+/HDm7amkVMJHkrn", + "YnsKJ39nQaKo7ePKBv3ciWzfyIV03eCSVl2pqQHb7AYfbvVx0wNYBpF9WbujIamB4Rp07J2jXvqVeXRd", + "sJ0PstpS3dts1zyad5vHu42mBN4kmMhdrwKthviesKEgekIEFH4ZqiD264UKGGxZFjJigsjHmkTAqD2x", + "J55qnuBPti41UNkyhbLYjr1QQTvjWNqDojT5xZNb/Lct6A31uIMdwdEpnZ8PLULLIOXvc7rM1w3DXc2S", + "h0tB/iUhm/lEejhdaLER4oVYfSvsMEhcfOYL2QaH7DUyYHUtpWVzniNSnlao5Vf2iKv0QtEZDr+EZOk4", + "VZhjkmkrUgJTxx2oNC1dpWGP8F0Fq7xQc54ypXGMFCbViPN2S8ENgSZbPXtjw1F+NjPNCtzM7awkW+KT", + "faloYqC8dEtLQckrdpOqHgo63WGfynIDM89zMkhvDoHcYPSIuCmLbdYPAPLP8Q5mYXG89aW7MaS5/xCC", + "A63b5WKiM+wcO/J4rNAFs3O8sU0E45WylXQVkyW7SbXTOrtQe1YI9l9Pn+Jclgs4mTzUBOQq9XF+Noat", + "XPQ+YOzWRQ8iI/Dpmv586UxGf73I/Fevv7noDS8o5oTEn7QUnpzgAHlmNYwy0YtJuFR62Blq73+4EHCB", + "n7C3/3HOJ9jsj5bGTbIQxEleqMQV0aJWbzZk4vFtLaQqbK11QFXHhl+wTDoBXuNkrMebAAyVJ4nAPAKI", + "y854JjklNfYtDC56DCH+zQJNrijn6v2t5LbYQggrjIlU0cyJOhHWwtl1byGoPGYmsUsFlxylC5s1JALi", + "ZlaPZv5HQ6I5aombWbEQq1HkW7mB25HRuh6L3DyNQtUTm8JhClVZbuSVzMRMtNyJuAXFsCFyZLVJ7vFk", + "oTQ0BYgUcLUNF9C1yUQX7bXADFzoAOdu5yKLmP14US1U4+tEct10xGlzCbKnfJXc49VAkn3fonfNp06k", + "aprAdrueUFft5NWwnXHPfv24umHH6koarRYEkuzDi2GsiI2qTXXph70Gyl8L8N0tprd9A9tDd2k7t7Lh", + "neJ2eZXp4obFeQx7badp45vDcZx/24NDc5pWcSPdqDnU3E+VQREMdm1ugcJ4R5Nvv26On6qkd6OibFJA", + "ct9hexhv18ZA8Wpt7GP77oE7we2E6Bnm2iHqVfH9tkK99S2j1Dw1odY7P/7wtre53WoUly/+w8mbN71+", + "7+Tdea/f+/7H0+3BW77vDUT8Ae1ktz1NKJU4Oz3/78GE4mNblyHxmFgrFy1xzZwwC0mAuFmxUHYbJES/", + "Byr0lragyI7YEthqnwa6YcXOcn6tqgvWKclgw9ENbiwrRyyl5hYj55bbT8EXvjTjLLeiSPUgzn7v9Py/", + "91cFK5kd8SCKESlXgk6kluOyedPAPUwCpa5snE+uUZkEvlqvIpLssKVrPUGx23ezLg5+XtvXW8jzk4pn", + "ED0XcWahtU380JhY+/1Z3KwazH9lofzvjfdB8HgSZsAt8L1IfSIDvME0HLLR6lgUMm0WxGigbDRzngeH", + "nfJmG0buq+3gE9TKao67wu6ajamSTKewdMq2S6W8GOVJw/yOrZMLDFN9efojK9BxKhcmEcrBXb2chkJo", + "nC3H6HE4PoPhI6wVGFKhnki76Cj93kIs2gK9yxGbkF7dpyGl0ccY8JYTvPEt6LTcU1cLLPZG9h5NW6TN", + "Z1H7xqZS3e7QecUdB0l2bSQ9sq+QHiF9SEx3uK4+ccc7KRZptZfhVlNKbPfnrXO+k74Iw/G4bBaaW5+h", + "9whqI5ISyAkLBAeiYUc4vDgVI3gZxL+L7nR2HAKLmRG5EVYonFHYQQ/Ros1aYue77mZ02SqJBWbRqIKK", + "ZofMN/UhrUXbAys0IvR1Eg1RkFLjEmwYUPGi18ayMP6GU4CcLejnYBDEJUjmhbqsJxdAxJyIw9ORiSlM", + "Hff/bnaIiU6X3qSDTYY8arQAynP3auR+gxj3qdHaYBHKHHzRtod2ivRKWm2WRz6NJ3h8hN49CDo5XBjM", + "zYjH6kqOuZqvXkbZuAkdzlYSxQ3ZCW4omoLR6xI6LBR1mCACLFKTxYcwehiWlgUZQ+akSjIKqwkQxmd5", + "96nW6znpy9T9lUzn/Z53I6cSPld2LeV3jGAvY1IbiRpIqkExqIM4BG6nzNxImR0zkuHOES13Qb2oKDvb", + "5XUrGjf5pQrTjHoDFlM776YRlY6hoVabPrTVtESq3vrXNnrRVn6vARF21t9W3FhvPdgm/OjqOJvWvIy2", + "+SBmu8N1t/nHfI/flw7BM28P2YBf2+Ix8RN8vVNDHZ1gqS14Adf5IBNTOAiMEndyi92hzUbPw7AK/bCw", + "27bsNo9CJm70lnQFdcJoPI3qSQ12dYrMHB/dbH6b+l4b+YtWCJmPfTG+0IVyQ0be0FfCf28Zvp/2mRIz", + "Xvse9qH5EKcRbEHv/RuMOOnQPzyWNXRf5M2d38XxN6ZV6G7f38YV3HmfyTL3Q72r3Zli5yY7e+OuJcTY", + "UWrJNBVqC7ggtl955vOVtvoi+nItw4ZgpFNhFhLdSO3txj8zusibbXD4k0fMMuyvLfkKu0GzNWSq+Pbr", + "r/d3S0yhr5UwzWPFn/CRJ4z3x5bxdoHxIkSpvFxbepGmx0+f2e+WePkbYNWqGVZ2U8NPeWFFFeoTtWCb", + "iwR4P43PCDu+Q1Qf8zG1StMzRBVU9fBw82v96m270nnjgjhu3Gv7E7je3mcKhJikBS0D0PqwGRYVGFde", + "ie0m3Mjtvj0W62bLDj7HrY7wuAJ3jJibGr4QzR7CH0rdNhSCLZ7mwLFXwhiZChuuTX4F9qt7/uxwmz24", + "0Toa7m5rdk28Kq3EzfnwNqeDd4ysIL9SqvUyjI8JlXq88D3rdN73UX9woML1pe/TNezTvRGc66HWAjFW", + "McuWCsk8Y5v23lJFVCyqO0UCLvhN4MUTdUa81/58WnZdfT4MoUqbN3bjXi74DUI/yl/EiXr7XfsIMOjW", + "esDKt991JKZV5P6nLT7vMLsXRSr1dr586dOkcihO2Q8wcONKpkIP2QfiQVu1DoCKxK8EOoxgLR/zAvRy", + "WmRWvPDfJpfCVbNP70EjiGnIrHDgOefmlXS3+55afILSWsihtDSiAaYc7Zgl9Mzp/K6iQZtEQDvbV/Jk", + "sRCp5A5sI8BYZTCJ4YmYFhmz88IBm3lExwVGHqDBE7PoJtqYAr1xcKpII82PVXcI8SWW/zR5X6Cv/F7y", + "vpTQjupKZDoXt3DbFL4qi49GTjMe4l4QyZqtwFKuawPRXLoxQ1odHBSzz/2r9cVhsNBKO61kEl3rGD21", + "lCPlidHWxuTE6PShpxWmHDJwHkPvIEASHmDPg5NXPkCk8DHtYJT21lJ/QEhLaTDI7rYWTrvDozLMMdiT", + "f964h20YACuoqBQifC2NGGTiSmT0LSF5lp5rHjHV71w83VAaBVRVrVZmP2QvzEQ6w00AN/Wat8V6Him1", + "xAUFAZlSY+RbG4Bct8O39ptwV3HEwgyga0Zkw1KdoCuZSINj9djbB//dA5oerHzzCtutuDf22Tpqa6Nj", + "cVcj8pdiii138z/P3r+Lltimrcqk9Uu8GcgWt4jaWdu6ev7Ppk2hPYW1v6sx2BQqafYCh2Tek2VFCJTv", + "KvQMhNlFwX07NoJu6tIH5oP2kcmFbIkfdg0K1I9K3rCIYEGXHRBNKwklyoXymiJUYdeV06NT7P6nMoVX", + "Ev9zt+vREh7hS+EVNJ6WCyXCmrSFVPEsGySYYz8gJnijTmUxa+3j/vomKXjehTQ0tWTxSpcVu3ss9H06", + "8I60GxfSJ2gDfjWoA4yI+5ripRaFz7Ojyhdb9HIrwaF5BF9mC4lqy0QkeKOHmw64mU7EXPp4IzKg2GKx", + "KA/OUJ3Ee30ByVwBVxhmpAWGTnSBLgXcP4H5E1NaNhH+BRexYNiUW4cWLB4CuqiAETx9jnDdmOxeK+Fb", + "U9rhyx84Q0yEUCzTFvWta760zD8SY3wGHB0+WtkITLwv3XPGJ6EA92WgUspdsFUiz1cCspV2ZYwOt+wX", + "YfRw40HfnEXpdvqLV1Eybt2aasVeaUHjg1m7yk417M2uI15zcUVypHk0SoCVnLY729bvlpUOLM/O6Eth", + "GzNJNTp9Ne/TrSAngp9yOY4AuVGBnoDz5EakDCc7vFA1UW8KwfYCjS0C2MhBGnIK7g8ZnFZw+oQg3wvl", + "AzZAkENfFCemmA62j0p/tZVie/jdXw5hXTwixv7wQlWj/8UNsiOsEJ7119qkA4sRDOga4D3p48ylcoYP", + "oBR1aC8USArFCWwfNRz6OQe5Y0k3pbHROQtj2bB1bSFPjXnWgRRxXeGI88rrXFsXU5y3JEvQgBWvErGZ", + "Fk+FGSRzDhqbMNCHZlL9k7QzjGd/DlLW8UtBmi9qO6hU4pqB+ysmyS2JgB0O2Xt48KeDyDatANuzMhMK", + "MqBX1+lClcWQNvZpqaLN43D4tJHqgzda1xzzP4nJi8LN1fdaX27l7/aXitAMRaPNtb6MVJhlRGtKXEdl", + "vsGXhxxT06aH7JW5hJIt03n78pQy6kIG37OoY36S/M+bcjJvzqzcPpkTdaUJ7g0QGQuz62yC11G4sejC", + "JXohRt75pPE6IWOfoxbfg84Rxj6t3ab0eqvzvBUkmDBGm5ip/RYzIsezJuXemcJSHpmZGORGgx0q5BIL", + "qTssJX1yRnA0NIMpSTuhnORgQYE4sQRjR71jove4LBp0P0ycB7jrtpj4dySvJ3GmtBrwwmn8ybFUJBk3", + "pCfi0yZi8ukcdEdQBwuHqgSV9veL8uYKAX/k6ZGAeKQkb7iOvX7TKLaHG9RXOU5x86Zf3hJ+C1eyvU7T", + "CQ8igXagT3c8uvs9hbRdHqwDb8pWGAmRffGusj0eqZJwsDRMb3/mgKN+hFeIX6tge0+f/Wk3sL3YTt+v", + "S/uan/vU8Dssdberetl85aJ+yzz09ZVZfQbi/8LcglNhUK+GNyAgvUvS9yW4VPPEEe6LETNpnb92ghve", + "RID8A0684plMA/CEjacTq5hHgq8oPjBhyrq0w5W63Az4sxdtHZs35YVS2uE4d3V5h9qlZJqIOb+SGgNb", + "8UUrvnr94+3LU4bapX/jJWb9eS+k8lzoVGQ+L2hutNOJzoZSH9SKHzw7fPbN4OnTwbNvDsjEcgBt2v8b", + "/t0nFRF7o6mxlblVTHNlx9disuDJXCqRCW4UpLedSTcvJtA7/JjkB/93KhOXiukA+uFlg6Abnc+FFX66", + "3AhWRKlN8aiUKykCcU2W3hrZZAcsBWyzW12iFV3pQLh/L1VLsVRQXip5JdoLyVQs6KBoL6NzoX7SJkvb", + "ixjBU1A120vEBfGA620lP24k0dfGw2Xs+o7cGK7yNlyR8YyUKjGCo6mh6X1XLCYC8VKxvaonUrAArfDs", + "9pijjVA11A0A1kScj6nhlOS4Yq7bLAni3Kmzzfwfpd/uzM8Wvi6banibtiW7489NLPcgvP4Bpa0wIm3t", + "dydWN7E97HB4oUjvOqPXAQQLChdjbej6AWMKLtUw1kYer8vabsdTVUCvhjg36pxxoNvUlDWqCFhPLWrq", + "LVtFXN/tOruHVqrOrz6bzXR8q0sXbVi3vVi7333sE6d1D8dcFWkf17AMjuvyxtscAzUi0QN19UFbAKfo", + "8pmBHG/haQ7JsVKJHhXqLtQfQ7qZsDcthnT4OaK71HpocVebiVFXLK6VEe8i8DCn8R2lO4EH3YdE34KV", + "U8LkkKdbRUo8sX6jgusanzwP046ipdSxSLA0Lce1VKm+vvOKhKlTc/ewOCs8Xg4z7mCNECsUFJhrM9fb", + "zpiddcbHleyMCFb2txVFhRpuHLSRTrzMZD7R3KS3u31uNlHWghNDRtvQ4fb7Q7O17iOeKRSX4qVFz7+p", + "n9DDyIvTk16/dyWMpeEcDp8OD4MKyXPZO+p9NTwcfuXzueJEDgKw5cE047Pg/Zg0uD++FWYm0I6HJUlM", + "iBtpHaEtCttnRZ5yJ9hKow3QmJDZ1Ba5MBiBlfZJlQCjA+juMsOVi6VfiSukMXbRw5dq0BouepiMIJNK", + "oB4wQf0k4ohR6nkYWcBwRTUA9pAc4lJ0gHXJPPTyGudPWyGs+06nSzKgocIcHym9YgTpvOE7G4/iFbU3", + "rOaKGApTojV0mi1wWX0S6n9c9AaDS6ntJUErDQaptHBYDGZ5cdH7ef/2qEI0oGayKsv5IynA52I/zw4P", + "Gzy1cfy033TLilPzm72aEP9jv/f14WEbh8ceD77jgScJkPFjv/dNl3qYAUjxzNfCFP6LBTdLsOIRXcYh", + "ZrxQydxvAgzej7nX790M4hPxoHQJKd02oOGSvhHzWYrtfFNYYcrzIw5EwKBzI22Ejy59HmMA5ITHnzGN", + "fP9CbWUotjs/XahdGeqlMI5LxcIqsAVXfEYX7Evv7qOmhocMzZ7O2XHIO38mHEgP279QiCU9MIJsl6FF", + "mkdsPxAqnpMvX50eBDx8rfbxmj8BNwGRXig0eoS13Mr7p2Ebb8/+3c2QXTZ/yH4IiHb+J3wsuFB7HjfN", + "PzK91PpSCuvX8aJHDspXPCv8O1UFmJy+HV6oMyFYuI4hJYtyJMOZ1rNMRMI+IF0pQjuH72lJBeHGwfy/", + "41Ym8Ar0/kqY753Lj8OTDq1B44BRVYHC9sd8ZngqbKzlj923/OZldJOypz5VHWAU93unOi9yCzgo1yJ9", + "rc2PBlSJf/TC3Pzohole9H7+eF+SL9DKFyv8VskO5nIXGVjk4A82EIGpSRhq2/SagkUpw7phC20Ei9XY", + "LzJn3CRzeeUHJG6cAUOum4sFK1QqzIU6mOuFOCDhclB2eXBRHB5+lQCT4F+QMwODwAD/QuUETlQWJ+dF", + "MM7hDsqKlzKw4IWC60JwVfbrAqIvrCE6k2TIXdIwAyJ2IcJxAjwrjCWXOuCeaYGyD1tBsUkyhdHK+MGQ", + "txJB83mdKketjh4mqCcFCmaZ7JQAzdGr70Idl7Pzt1Uk7QYpY53Msga48nBiwJjDEQFHDU+lEtbupFrR", + "Tpdj2ihZKY6CG3cA5DUIVrBSuG66E8Q+qMu3oa1uDP60CZIhLiSRdjAjB3r5zNyMLFQdUI2fGqj97hw9", + "4CodBPlwd+7uN7A268rZ/QtlhYtMV/ZA7CfVLa4fkfYv1Ce8fqzyyAuVfogy+Avmln7DcUhLHFcSH9R4", + "uvwtsNIW7mF74CIoc7tfPSXjFDszl/dSOpiEa0IzEx0HYFbFEIpCpISlq6fR0YmRW7mlCBkwIWUCLv8B", + "Y9v/6g8iGAJoxOWjVbb0xxcEdQfMlZskKyDykIEGjXC3Svs4ObT9ski7liVckfdXJviVwLMnxJBap3Mb", + "3LMITFvA0kfk+7A1TMYsK+SYSZPycOD4pieRTgqLcUJwKCVzLpGpUkGQcHBQlh6WiPZFWaCgt0uxRINL", + "WK4SKz3nS2jF++wzowuVDpyROYPbh0oIlAYz4cAor2Ra8Mw308TI3+Fdwu/Oi+DRf9ubxEaf4vWeIp7g", + "LfVZbDLgAf+G1NbICAw5ppEBqjTdzogh+KLOhwmkJx4huVS5sb6zmMMYvTUfaEPLDu66j2+J8ImLIt9/", + "1i08k+jHDntIbIlrHsbY4sO56yaSVfUAjpP2ffwgePqyYoFtWs772k/qxCv5tJ0rBoBQhvku8Sxc47w7", + "Lz9Mmrx+owtIgzH6luuNNu72Ba8b2R+IeZot+bdlILTeh5SaTpeL9NuRiT/Rw0LwhL6PDaU0mq37GHFO", + "HmgL13BUuu/evfRfSTbXxKk4NAbJYCcyk24ZjT6/GZL4XqYeWV5f1xOj7kQHEJWwfhiuxrYIS5YZRAMK", + "Qn1SOKdVP7piZMvSjMBhXMZRUADGDypKi4lB9TjembwSlG/S69eZ4FaQUxd9LS3jUQn+x02fLX+ugvzk", + "XJrG+9WrEGnxQLQb27+r5IGGfiNHNg6lzElL28SZB6HZiaTgKR5bGeU+bXC7mPmrcLUEww95RDdnMm7m", + "fnxqp6WIk7iPZf6rcLXXfOqCWDf2dC8aEnDbNi03ZkJ+IEZZy7R8Nx3XLxPM7PMyy9uQ4Le2feFkjjhK", + "payy97KluRHWAnDbFlEt7MpAMFBsSlmwouNcRHmiJ6cSbqySf+hCNWUV8hm1cB5GzIUi+8F6+qI+s0Jc", + "KDenVD7rKYgYd+WL1Ey64dQIkQp76XQ+1GZ2cAP/oJviwc3Tp/RHnnGpDqixVEyHczoyfNj3XCttbDW0", + "0Ps4hflaVliPYZT4pUC0KuvtkbRNOm18PPQ5sR6IX1ZTbt2WXXBDkVp+SxoLzq5mdUO6vA/OqGAntAq7", + "c34pSmjJh1Jr1xAyP/pN3HioYfTyQU6IrmVPMcx3gi9aDR5Ea2dXOQAKif6sOx7xlFi5QcH58K77rbOs", + "XQwSOCi78gCaBNB8oEE6BFBP+M5VFNGKsK6rtDWLaS01nNdVa+icZH6VCl4JoGvmZHJp2Z7SziPHeiyx", + "ksRi5AaCIF1xs3zOXIH2zgVG+1bxoDGuF7GiyqnQ27+fK0NoURpG8Dvp1/CsfVgqPsHUjMN7sQ3U18sO", + "vMc32uMooDUA0ARhOg7xy2TpGQyMyAV37B0bDCgw+JDRgw7dGvDvgMeycvMMGJ0PxJ8V1NjbyldPXr8R", + "YxsNplRHaHu4Y/x+NcqAP9IiXj1qwANt3CoowZ2MPRQJ/5s5GGFuZNy50zZ5PJN2qVgmuAyvfwz+IciU", + "ZfQsBlYPwGV1BAqp8PgOcZIiZX6rhxfq1OipzEB4Kq3EInfLijNX/Mo/zHovj/iAaOktOz4fWqfzAxwV", + "obBdKMq/UOLjDZlPaI4geDRmKAmuy/SVHxrCKC4xKBBxFy7UOPY8gnfAETp/i9nyLznGFo6SNB8jHJpz", + "MGisCk5n4d0dgWZAQK74lXjEkmpq3pwWpXFNtFlZliE7ji4bA++yUe0C3I1enV6oyjCmFBuOaAEZghHA", + "wGEpw3MljKWamjhsGEI2/KsQZgk0wBfCCcOkvVABj2CyZDpLhSE1wgYYFSMc9+2VcHfUVTjGhhcqUto4", + "bsqYpdLm/gThbCKsG4jpVJuaYws5vdSpjqxD3hmlXF0fqVwGABHK1XfcEANZH/9XzdY5DpeNMcEDMa5w", + "/o4tdcFSfaGUdkwJgA964VgmuHW4nP6qgJ5wUBzDvidxzyM25CqejnUitz4/NFyEpKXX3aMKIZR73Mc1", + "QouZZxQ8iD0VBTcK2ruI7UbANhfKGa5suNIcMTkF4xmH5YzekzAapBnolZtMClORggyxLsV0KhIXABkX", + "HHme7nAEL5KI0gkKI9Of3dz4t97c6JzPuEM3wVPkJori06B4WAGU5gQbl44a/z4mjLkDP/Expbcm/oow", + "q57C4Kl2NhOg+l4oWlmSXFEu1YVWo/9nkDEvQyH0ivccYDGCqMXRocr/QWZ4MtIIJs3GfqDjkLcXNC5W", + "KLiFeifRNW5B+o2yCkS6f+suyWLIxlXR5OWSJcFUlQbaMJHJmZxkzR4NsNRTXN9GUUEZIbyqibFfvaMe", + "yoheCE3rtchOxK8L53iZ8LB0LYwJpOI35ZSaEAZ+vpMnzEqQGWy5GAWOa3BgOn89+JNHy6s75LIFz9n/", + "+V//m4SnFQuunEwwT+zpi/OX37N1l/DmtK6+1KglPqAyAnJTZeNfL8h3/6J3VA0P+PnjuOOA6FBpGo1n", + "ti7DWIDERg2/2WIBP/uT2OtFY7aHqSQOKJHEgXDJMKDZUs7mAJ6zztYEH0RyD35GTOAI6eblTtQSSlTV", + "ui9uCZ3MtEpEuOf57JoNWZqqDqxtzA+eQPjkEEaP8eDg/XIlqrwKfOKnUaJAbXSs26+lS66TbggIbczs", + "P6TU/s+++aYZl+YXmY/g4OhmSqiHjcS6nvObAqpWEz34c2rkz6n11XTcDH+xLhxkVWlHCoXF5R3XXAIx", + "gsJjkFIH4fncDpk/ZKL7MEHxG60dE8oZWfWG95XhH3sQUimHm7AVGdTfQxlK/uNs7H3XD04j6IQd7xO6", + "7BjWLR+VLDGuJPyn7fYeVmGy6Jzr86xbUC2wwLXheS4Mq4ynBvDWtl39XtSsGtj4w5v4WOyVK7GiWokt", + "mlJQlPosQzASYKqEE6859uzw6z9RKrl+yXqwgQlGsJCqiDLCbwCNYpKJltS/9bXccHUpwfTCCuJTYVmX", + "cJ2NzMn5YYUmI1XsgeYSM6b4cElgVVi3/U45hX9TD9Z1jZnk5fPS2B+pIOL/1K6/w7vcf78+/PP2ejDA", + "TCZrt+b7cb5Z1enCLbt1nUS4OpEsj4FKKcvn3IqVC/oLuh/j5aW8G6NJzN+Z61p/nhV2be3pdbOTz2jl", + "fI7BZQ1RTP7cfajHiPWj/VPTvO89AKiub+eP3ivDL1h9Gz4bTd85ZKd5Oh2JZ2oPEiMgRXI4U4iQiiY3", + "RywYE5w8lK9jvZediOnppnwsNM/fkCWPZso4wR5WlrXrzlG6kQ479woLPvTOUS+n3M3v7OoSN42mmN6N", + "O7/eXu+ddq/BwfsefWRw5IzfZWeDPr5hU1+T2v3b3k8Y5O9hK/0dp/Mu+sRAwKGjXyRmQpkJ15QryRUG", + "wRv/fnLK4q2lctsJl5iYu6LMvxXIa7ju2ub7fyXN32W+zXQV05TFFklbdjreSkCJCZNqs/l4J7A6lVQN", + "Plszm/28k5Lg1/VO7+Cw6mGOMQUMkl51gb9EyvWbVRVDjAdC81O+NUVbl3Yg6XCP33PcVC7zi+Bygjo1", + "tLW/kfIv1AbSZ3+3LmV6OhXGMitnCsHJEDLZI82HDr0ufqFSUf0K/uaGbrMQhEjGI4AgE1cwkolwq60g", + "ozW7lFb4DtboS2G8/hoQSWW66Bc1ZN/L2VwY+mQDnj+zC0S4LU0rACsLONgMXEMFvPIMaCesO2L/E3ab", + "mmBP+8xjocLGQqqr//nV4eHgm8ND9va7A7sPFb2JuF7xqz6b8IyrRKRU8wB3gO39z6ffVOrSxtWr/kff", + "f81ClW8OB3+qVVob5tM+fhtrPDscfB1rtOxIhVpG2EyL4Tv8VRq+/VL1+pXfaMj4h3WtVvDuctNz750E", + "5/mKje4PIjxXTJM7CFA0LwWAJi8468IDdCXMLN5VaqCs8AsPzTNt6krBb+GU3k3zjGvQQHLwG5OKiPXO", + "F/fPQljg112ZAeMTcgBY270dCCuT1uF9wbZS1htpMa+vveWB9GXSUjnrBmIqL5oZwWl8gdQEE6R3Cgr1", + "vg31gJd860UTHNhPyz1+CL//+7hkQjsV484XuJM4A3zgx3fBuwkEI3gaDQiN8gAiP735oJs4wOEE1RTa", + "/61IBJ044QaUbOrOOg0eMI2xtl8YOcH+stoT6A7kYwUdJ6NKpvJWCbGeMP7hAkFbMtPfGqirbCqEbX6B", + "W30m3LqwqCaZP8Ak9nYu8x1ogF6m211EXxCMePmA7VFGtCm9sehg8tFORiy0lyMUkjxsgbsJasq9efVE", + "zajFdSIV1o22pO+HMlL5RzsvBT2Iq1e9uyTu7/du62XhrY/lULe7WTS0cFt4z6fNZt0K/NUXLi4bgH6m", + "ngx3Y5hg6t2If8XRzESemhUUO+nd+oJzworBa4UC29iHrL33xjy7MkcpgZyOM4OZRO8W3Y1T7sknaRPH", + "3JL0/y7zOu6bn+bvhg14FYtthURvwRHe2LSFJXY1FbdxzoXazjrbTcY1C/GFWjERt2O1eZvvvbFfq4fc", + "+VzEJQurFY6hDj5hn42tmz242pIuvuvuxOUR8P3YYMx7mKYTyGkwwDKDst7+cLdcqKW17wEEygu/hr9z", + "obJKrrcWLNerAHkrNxLHjXttf8JSD3QXqXSxu5fKLRHjcdqNiSN+VBIynjWkiSj59tovRydvxdX82i6Z", + "s/uGLf5M5EiTqZr1PXCgmu2k7+F6HvwaNuUj7UomCPNqlSJ1XhLkisEFjSjeauJtKHGnN9lRtptNvm5K", + "lU5bSc7wX/hWwrISXaMH9a1MZavbeFCmXG80nJ2hoem1Pb7yRpVPtpurRjAnbhyNttH6te2N5Qwv4TiN", + "RniAs+OQwV1PK7d2H83d6/fmgqc46197/zU4OzseeEC7wbkP/13NcpBK7nMzTxk0j/nIqDm2tyoI92vv", + "peFtdLVU01Poxy+RkHGh11bZI2QF0d2Zpo3c5kCGOHFdDMCvKkogXzMGf0J/hPdlgvNMsIVOBdvTieMZ", + "ozp9hokPvv366/0hq6ZZ//brr9uGuaDkw43D+sfh4D9+/vWr/tdNITObo87u0Tx9S8tMRCn80g9rNLHB", + "+Rz8ZXdxw8v0zB6US9/8MKpnltivRZavkIzP1LqJtoOw8kxQwog3Jkhu7obSNDb7jNSS91USc64SQgxu", + "l5hbbspo7JD/3w9tA+u2n0y79FOZe3NvZYGRz1PW+2yn4hs963gcAmH9pk/AptMFBk3x1Wdnx11ZyCNg", + "H4iZEdZ6sIGtjn8YRIk1Qphs8OYzOmN5xpVgGbeumtQCw799xMyQvQh/MqUdqndzbtlECFWtY0SujbNs", + "PJWZE0akRwyzwjTCxfxVuHc0m2Mc2inN5QHdD5q624AiWFuxFjhAvypP7ErpDtvZ7zXmrz8XEOYNbf/t", + "LQQlEqC7s+tdScuMACJLfF50rhgHMZXJgBMRP0ILIptCnZhUWRcOgQOor36ZZLkyG8jdQ5GC0rJUZHIi", + "DKVdUdoxC8s0F0YchUDNmyUUhA8ohXxfmJMSQQ+oLc4I4I0lOl8Gf6mqeYuGrCrDYwmi3GGrqZFTD5Es", + "AcGE0Jz+9pYVhKAnLRHjtLCijNDHMM5rbMXowgnmDJ9OZcI4wsnT7ziFITvXKV/SN346ACOS6MUCQQ/O", + "MS/lkA7B7yiS7CVl5gUcBGMQrX6MjZ0heNOYaeO/+G6Zc2vBU2QcsDlOM768NhB0zcRNrmEW3LKxj1Eb", + "KnHtW9/71S/yx/3xEZlgK7wGB9G4shNc2WthLJOEJkKwJpg32MM+SGWdgHeWKWi219ygSU9i+GkIzcP1", + "PYlpr/slCBZhjaxLEgS5itlVg9xAaeJYkWMD8LNAUCtVJVLLeErpOsn3AhEjaac5M4WiBB1BKJ2XqbKk", + "LVP4YC4E6ZgtzBWlJopICZ7UIh4G5GDw59xzxgOt0MYnmHM4NAsNGi9OwSHWcGRMN+fKiz2680b5Golt", + "IlimrWsSgadFqwi8fxtZq/T7dGGBHQXwce2o8rT2eaG67i7u4fTOI58f+PQNHdKKmIl0hptlVUokOhXk", + "YTY1woZkEB5CBQPI+YwDlddy03oGulAgYXXCs7m27ujPz549I17CVuFc53hJAS58kvOZeNJnT3y78Kdv", + "7gmJgieUAvzJhbriRkKkuB2GL4fA1Zg/Zm//SWSfypAG1yDhfS5yhKGziud2rknOXKjQkFRX+lJAU3tQ", + "7IOY9inLyf/TZ78yJxdCF+5MJP8P+7j/hFFpS2lSeOJWUgXPjS5mcw+NAyBJTyyzS5XMjVa6sGE8L05P", + "huHvIBkibhM0cs24/71KcChrL0DCuMK+1Kno48L2cVSJZ35au4lOlx5ygnbACFtkUUzhfpRbK61fQkgO", + "46GcAvmilD6+EmaJODyw1eSCqHwD2hyBRU5QCpeUvdOpGP7TBulHB4R0lulrFXYH3tlCJr8he4n4M/j2", + "BA91qCH5pgkoKdHKoyNny+ceDkhXEKxCaSgMNCgI6g42DxRMv4l9lhhu5wiz5ZNDkkrOMq3zgBgU20q1", + "sKiLcIQ/ulCUASeObMheIHwCD+3jeGL1SyFyi/MOC4HhHUb7bxtWAo8X3Bo+4SrVqjwHQxf+6IDGQVm5", + "CvEz4UAPY7pQOFeGVqX1yRKaCqaQw03FxeTlsvsEdVEKhMzSQAu0WwFy60mo8sRDWtVXAS5/KXvib7RP", + "glrCs2u+tJTeznol8ELF/eRwb7WIIvmkJLKLcDG+6D0ZspM64lgo1veCBWh6QtqXZlx5iDTKL06nKi0u", + "KiMCmyO/poHPs+0FMgLPUPYh6G6qjZh5rY5PCMLmQkU/qHqubsK50LlQPg2WiPeYACDmR5THOiE50oWy", + "IhOof/sfpGWFik/dw1JwhrHV1UXaUH3txWJo7UJhonh2MvX9D2hF0N5HAU+JsEGr82nS6c2kX5EYdcgo", + "WN9aqkICRAnyfOhHirLaaT8WRIumoQa4NnED57902RIp7ZQj1yx97imgJagOdIZCDCgXjyqiskACJPAo", + "4RSW8ZNR4hpLXihSr4EPh+yYJ/OVBmjVOO3wibPVtmA3rW8Mpl8SA1vBwKsyOMzSH2rr1IkbBQ1oBSxq", + "lh6jjcaOIWrSIWShxe6H7H2OiecYJKmLYoo2CYdQoSw9JUntN4do6TnYbqpjDRsBR7TSvlT/QnmqpUlr", + "RXQT0vRLy5JMW5GuSZNyjbw0Vmmk/Cewqj5Kny4WTyALsF95lH4JVzExJewObb/jE1uesCX146oGzeE5", + "iy6Q/kYX8We4a1h8pLMXkW+h5zm/wvNjoa1jf1ohDfu8UeqUh0WiC+Xg0IGVuFAVbT0YNv05EnSWrw//", + "TARalZv2uQ+kRkFBx/6r4zfH58dsXdXTxh78CsP8OGTv6qP1KD4uXnhCkuSkBDImuQv3FTjan9P9Cghu", + "XjiL8Yi4v0tsK7ZDUkr6bSE6aLqI0M6KUsN8SZb4h7iHrPX1mTBKGsYBylcz+ExUxO71lfbP94f5EmcR", + "mPSNXEjXCqdzHiTzCtWXvDIRS03kw3JhBoH3Mmj2XtPFlUNHrOAzHKVXsNYvMR1BdZvYr9VM+kaSfahB", + "YuCZ4tE8ocCKnIlAJpMlO31/dt7A92LdMRT6W98w+5Cmzyb6sI20DqdWOcH7i4qq2bjKGd92M70srXt5", + "rLwRYGbLqsB+EtX8IPujUUmjNEWIVa+JKG8ks5R7ErW9SBfX3AYQjSH7LoIbr/ZWO4CZ05q0Hhg6nmIT", + "caGMKCxAftVPZ38fY0EJIl0m9s+9ahuMn2uE643D5CJUsfP5o+Goducp8Rj7jPszcZeFYbV1WUkh+69C", + "FP4sQo3pQtHVEBRErfzE4raceG1YaZgf3rWe4PKNHJ88CaoPYd3S2Bqj/gkuZY3oO/mH4H82PSjuxmhw", + "2DcG9MOsGgim/loOfbc9l8d12eldspNf0nFUmb58pJgGydNV8BBVotRp9288pVKwZA+WXib28JmUpdoI", + "2tSkMqmw8WV+E9low7NNxcSXdTfZehKwOb9WW2ngDEs9KBFgF5+XCvwQ2sgAfxbpb2z3+Z22/1f/B7ok", + "Xsos20oKP8gs63TclC1vPHSie1JRYMlbe0DdasthNr/JhJ/vf/giQ0RBHMmZ4hkBzgdPm9vTJGFub6XK", + "D1Tsd0OXNJ9Hyry/OHVYT1Cazv97MKE8BPdBnvQa1ur1Fw4WKvWpqfOBT0uaVNNB6X/5IkFzwt3Rhj27", + "C3GksoNuhaV+N5ILp/OZ9TgaQpse993SCRs8l79YZ+XyfGXWU9CdKFUXbpsPc7m84JSwyZn5M8m0Ozjl", + "xrlBtY7uuWH9deHywpElSE4FZQZ7jF95sPiVCt3rwu3sa2xEgpk1ZwelhbVZQpOp5UMo/6AYyLGX7Xla", + "V52hfcXPZ9P6TOD00RKWG3El8f7LaHNFyiDPqN4pjKNCFx6VsVUSBtjGKmlsDG86KUNmI35l2LbgSep0", + "xF/tBycU8hmtDA1N0D55kV5I58IDeJn8brVdaWO77Wm0UOI2ByjxwS8vBn8/HPx58PP/+LdbyWXci4NF", + "/vWdgbNKYvc7W5Ou8dfBa6mknYt08KLJFV0uhHV8kcNeRIdeU2maKg/ZXwtuuHKCtmEi2IfXL7/66qs/", + "DzdHrtSGckaPBrcaiX9wuO1AYCjPDp9tkhnSemcHiWn90Puzz/JMcCuYM0t6q6QXjvpyf0BuQo+vhjeq", + "YjYjdFbIiogOZNADucdbNhFTbWCiDl3Ka5OIaAlPG9ASPn7BEK+UENcii6Iz4f0Iq0xa1yqo4ImSNlvc", + "/SE24lptOs1Cb4StugYWtcbRb3yWfhNHeW9Ps/gOWpn8jgu74Oay3Y+Z5mmj/5fPfamI1j1KCFfBGyo2", + "i3k8p1JhZiuiCW4uhQl5uv9JbncywMt45fLt6ddwJiRznjthQp31N/i33Fw+tMJS6+MBYSl2GEPbXe8t", + "rlNktD+MavQiTSNlEq34QCqpBkHMlzS5O2/gwbQFGuWhybDeyUa1+emmI9Afsl9gdiZcAcaZTYwQqipj", + "3oP3IeVSDdPMhWEnr7x7ho8cEIbS53lv9dvQgc43kYHOH54KKn3c/u7k/UQ+bzSO03ldAey+IXm2PeTm", + "P/kV925o6LgcIsuUi2ET3oubfTg+fTNkZzFjN6X2nYssPwLXnPF4/E97oaDbIXy5t/+ctf3v4IDhabwQ", + "bq7TWq2LXpLJ5PKi11T94ICdwVOSK4zox+zE/XDRiUnbMTVmvdW14BroAUeNDrdXXGaYOdsPCaZUHB5+", + "lfxfgwH77vivJ+/YX4/fHX94cX78CleCvT0+//79K/bm5OycDQZYWEASB/jxiI1j3+O+/4DQGPGTWEh3", + "AgE5Y6j0XZmizxmdHbExZFHus3FquFQE+AIfQXN+rQ1+AZ9n2ukfTQZ/gicxKFjwNwU1yYnMpFue+TAj", + "+AHXFv4AFewcYjj7GFWZnai8wA+5gSdQsYS/bWJ0ho0nPIc1P0OhEhrDiCc+wYH5aJhzPsGK19Ilc/9B", + "iWv/Fzrx+L+FsoURHwTP/BdyCndlCjcNU31bnfQbzdPqGmQYa1v5xofcnaQZLvM/sXIRgV3h09y5/K/C", + "4ZpTONMRG68GcI378buSXCpf8jR9WVinF6uloYXmX8gVrfxtXCWv43evuhHXhfJ0MvB0EqgV9UQeaRij", + "UgmRKFsiS2gVQ2zH5JeHYS1To38R6kI1haglmRSUub1smNswI58S3Vcc+i/7PncsSM8EJ3uhMNSNp2kf", + "I52JQ2k5wuiH61uwt4+p+BOw41mMlqt42o//enzODqjKgfMrjcNZj6DbD8nax+Sz6mtRCYjVf6kXC60Y", + "EM4UYIWrsozjRdXz2N5FL+Sb9QJmmOgFSREqWKHTPfg20ejQa4Rgf2FUpJExK4UzqS7ZX7DOUOlU2OFU", + "qnQP/mR/ITJg8GFodCbYX/7yF3bRgzoXPQa/PvuW/qUy6HpJZd5qU8teMRwOaeRyyvb+L2hh34f5KXHN", + "8CDao5bRWX8K+mt1qihH9rDe8wsVRo8AiWGqayJj76J34Bb5AYbj5Gp20eujy1+fPf328LBsuy4e936F", + "Vj9WZPW5zgeUHWciFZCaD2RbKr7wYQRy4eOpFjotMhEDplmhnMT09oJifMhqTCcFp+B9iP2I2YeueFb4", + "7MByprQB51WByfTpCkZh6aV43xsOh/vjPshxq+EI8iSOIX4rgp/KDtmpVEqkIMBdMkffPc9cpS/wINFG", + "jBkky+czGs+FKtnSc0ZYAjam+e/tB75I0hw4ITf6CmNPClVBU3glrpDnPHFGP1sDi7UQIfIu479IL00k", + "hk6WsYCV0PIh+yCscH38znvH9mO8ow8C7LP379/2/QZQkH7IdJvCuPSSIhKtI0/9NGDk4bcvfzx59YwW", + "cyRT4OHojEc7ZYWRlCQaRJ20TKjUX8VXpr4adVqiMMRYKUCLgBvsFc+Ev8ybAjgVKdBfyKsBlWsumNDy", + "i9MT+5xJHAEwlOUqneibjREqXtZ/AD3uYfTkSg+1K3tdVcRM+757COMN+coxPIKMj39ib+V3wYJHq4sw", + "tnTxOPckYgQYMizjcP20c56JlKVcgPgNzeO7DZqu8fsn1jetxHUmlRikIvTqawzgaxoK5UhSWg2QiAoy", + "snx9eDjsfcoH59qidouy2fNhNgzjXGOWZ88T+3e6hT796vN6JdYvGJWoUFR0Ojon24RnwulfhNGQdxqE", + "XvvV5tT4h1GPpoKQGtACevBrBq304bLLTZrhqk/Z9+fnpxEkhVztMQg8OP0D+WJIsrTQ5DVYx68hz5x0", + "bCISXljBflTy0vCpo19X4tqgLCLqqWUkdi88/va20a2fpnkGMz/XfxdG97o4s2P5gdMDmCXza5Xey46W", + "wCjZMrSM6yrCqlaWqLPdoLq1Qm3e2Q/COm2EZQr0mIzZ2mTDdbAyij4BrpRIL/Xh0jsGhRemmaAtp7rx", + "4eVvb5nSPp0gU0Kk1r+2zEWWgqpzKRpluLr77gn1QJtHDd9972KRTqhc/orIYq166vAhC4W/Pvwaw4Fj", + "ORkiWal486n5V+HO43geUL7HTsClrdEb8rx5grc1GK+DcbW03w2IKwBYrwhNbpxEUUXZaGjLWrcKbYm+", + "BylsJU6eWRElfUVpoGBdUuPS5+GZutqEEY5TPWkirVjhIErc7kQc7Ixq+dj1OHSg+bAqQPaevzxwG0sy", + "wY0NIE/NhPlnEgxj67SBa4xvYgyjoFYwz2uJuoTh1ogzkxnB02UJZU0tPF/vD9rKxBQuK369GvGUYB/r", + "BP9gCmLs5iWO81O78N2a4z5fZqXPZPz/Eed7RwHRhNR3JtwWiRB45Nnh0zp/XnNi0IpDTsmrzyPqwLPD", + "Q6iHZhQLLJyJJHCDzt1AqqNV1DJiPmi9Kkf2eAmegP3QJT1gOVrhQqwh3kC9jAhiIWhM+63i4HmEX5Hx", + "TPXqwiaZ9JuUIYX7fBLkNy8x7vNp+vYDssJ9ia+Qd1NTasplBRa/+VpworxdQXlAqegoUQ6BPHT7bBYg", + "DKqoNCsDrQqzwxIKhVsIYxIpE+pKZDoX5SXBd2sZT4P/3bPDrxt+DwCWbE/p0H3wydOmLPvEliJJ2lIq", + "ocj6+vCQkW1SptyDH6GloJnHJ5m0paZAfswP5O5PfWEXn8ndv5yn36TG4F3cjpxGiybdsKMJN3iI1Pbb", + "wlRUIoYkFZpCyLFBniQiR/IqXLnTm2ntOZ2NYSjD2/N6jf/8TnRgid3ZcS0iYB1UwzJOr8N15/iyb2Jp", + "j3WFD394wHlAswUby/SI/WrFvz5eXChwdj9iv4ZNGgBFwPcXF2oMmgLtDlOYsIlsk94gO1hopZ1WMkHT", + "bHgF4InR1q4IWm9iBmzUN9y6Ae7p4OSVh2RVy6jBsBIgD5gT+RCGjaHgi2AyomkP2SsE2INBURQkkcSM", + "5zZck8YyHRM04lGAwTIiERJgjfA3aSkvICKwPmV87gEu3JywrAdWgEIh4XmUVpZdCwOihMzcOAMoPCkA", + "znDIXuLbnmV2jpA4ziBs2lpr6H4snEgcjnfIXiP2Xjl9G3SrlSUjBNrYbXmb81tFT5J4WRQE9oGjfo7+", + "zWz8/+BzzPIvPMvGlGWr1pzOUmGdvzBGFEEP/EHm5msJ6z3nuQhYdDOhhIG3kbokHA/Za22ixuhXT/jr", + "qeddgoom/Ey2B8UJelIYywrrE8DopFgIBbXwcX2836+J8zFQ8RhpTptFTLK4CClkxl5T+ncc1issTEKt", + "H6HyoF9qvEnSUyREfXpbc66DiXohGEeQRo+DXuOnIXuP712GWaFSdtiwH2F7c20lXQa68SQintQYC5/b", + "iI0EsJnxT9i+K+6RtYfsnF8KC/USkWJH+HAwJroZ08GLr+DUsbAI52w1CiQwzQ6M8GRcdpcJDjRZQ5AZ", + "UJOwQ3NpnTZLWnr0lyfP59JhvsYEuyUyQGTB8S4EP2QfYFTE0vDaahl37Onhs6+fY4VIzLwiCYDxbGGm", + "PBH0XEJAgsjsMyO4CzjPTyvTXAkLoBVpjjHKst7Pt4kGuEOUVqcT/02Hw+iLy6qwOgPYUYJgH5wJ5ViU", + "AJ0O+Gsx4YWbq4O51peV5D0rSbwQ/VGrvr84I0omvgnTKR7EIJsJZ8kNUeb+vh4w2seKX8kZd9oMEyMw", + "CoZndgh+P/Rc3fw7wUMFfw44b1FtSgaXYskqBeNzOJnvj2qmyJku00LDgmh82ok6vjZyJlUEhI8YkSGn", + "XeLfhMI0PUS8WpJxod5qideLE1+BKK28Mj8hKGIJTiXQqjepnBp5xZ1gl2JpGUHIC+WEKV+NLtR5YTzw", + "JuQURZdFiydqGKElMTLzJlGo6vcERu4wA0NZlvbJmxkQd5LeTTIBf9OWrzxfRaDf8onB451mfHYPYPVr", + "01ToaGO9LwdUK8cfhq5zoVDwATGLNKCELiP8JDz00G+4+VKxp9/EUJQ6/j2ZV6BwgDxV/ZUlpnCZmXBM", + "epKo0lx0r3UGcXLrkylhNw9rr04e/qskpx8/vGF74x+OP7w7fjN6e3z+4f3oxenJ6LsXZ8ejHz+8Ge+T", + "OzeSmnT1bqbTgHCMT80itS32oJ/E5AVIge9BCDzMLbHWxSe+Hq73XRdv3/tdduI3gcUPW4j0EMZN8hZp", + "kSwGejrdQcCD6xv55Q3Qb27ru13g+OgYTrUJvz7iqKNujYaVk1d9jDCwOU9En7RbYYglIu79QjgOB2Uz", + "WiQ5SZITIvolPeRj3lpnm1BOQrIcvwYVKH87vL8IpYbWO3hJ9FtsY2XQB25JyiawJSBvKztJEJHl5yCx", + "gNgCMoo2kBfGfxoCFHb5G7YR3FnCrRYqsyvJKx4gw0oTK5WgIOSdwUwI0H1hMaUPm1S8RXydPSsEG6OD", + "+3jfe7NS2q9FYR0TcIvgBIdA/kBikTsQ/YYvL5Segru4VLJygQXR6mnV9utEyvZKl1aumA6pAL0DIBHS", + "vk/hEGYzLRTdj2l0tOYx4wt32jsqDtlb3yuKG3yVdNG9sXKsQeOKgidRz7JVT1tduIGeDiLCJZV4zhCq", + "Ol4wcVbS+qw7cP9OhM9ZcKEAcNI2dB0y4OBTiFSswfWWzmftLedMK4FdkbsvmZygXD/gR4PAADGBLacp", + "fq65X54Jd0G5lEZwq6OMkpGCfe4tKO6lU4QSpxmW4LVUvlzt5xcqvDtr459aeJoG/+KQQIBap4TevmWt", + "BBirwscyuwXlfpeqaLS9vgiO4qvSbJdD1Tsbo+hL0nxE7AOfqlBGlOVauiyyUq/fw+s0lIyr0TvqVZyX", + "4T6CjNM76v3j1wvF2KVU6RG7gI4uen34BunniP1amGzkI8DtEftHozP0wb9f9H7+iNVgSY8YtslwM6BV", + "0M1GMAccqO+AsYrEglI4mQDpXpvSMFbBfChnyHtH7Fe4LkFNSiMNfsU8TSUx6mnMY+3f+Wl89K/n1yNC", + "zGN7I2y3z37FWQv7cT96Xe/5ueCAjryP8z/t3l5ZJDDNEMv02a+UrOAkPfLCxf7j8Oeh0/mIfgCYlX0a", + "Dfzn488XmEuxB5Jz+zZXxOydthoaeKi9xpl022woSjO7x11mXkxvaCOv1PzVb24sRhfwC9iVmGUSF8TP", + "6edNxFSlHd9wnUKqu/6xK+huk0z5TPG2OypPpbpB52BMA4R1UJByqSwZhlGGi+tsSWUrWtYX9hIKCtjt", + "VLoWnf3g17WM76u6OwTXUEaXqlI3WdYU9SF7oSonWbw6V0Afoh8DV4nICCikfsJ9qMQ1lYTQCQFqC/JT", + "BW0kcSMAHPkZ/jkc/PnnX5999bEb6EjDU12FDgNA+PCzghDCEBhvoJHdSIQimjY9kl9hnjAC4eaJowe6", + "WrYwGRBp6OVD62xkxHTI3mk1AKO5LSbwFpCKJONQ5Ype6yjGK2Tsim8JQhqf8Ius8DovMu68wQVhEOAM", + "lWo2wnbpEZwg9obsPWVYgXYvFJTz+cidMAsJ+jfBLlfVYP+q542HlMervG5UOYEOBcv4RF+JC/Xs60P2", + "g/wujj+AvlfzHnLmTKEonxh1HTPPRHuYXAgE/vIrUPLWhZqImaTMTYJZNNGWiZcKl+iFGBXqUoEVEPRi", + "MvaRwchGHbruU96kcNIm1xjxgSw4b1+eUmcbAkdQvPNrthpAgi4NleiRpxjikWeFZV/jRuhp+SIPVwB8", + "7/TRJTGspPeJ7UZ+xlR9Q2RHMB1HbwAybJZyVqVMSKSskiXonlrhMXwF16bMDLZG+sMvA6YQan39YPvw", + "mhxfmjaiLMQmYsZVH90yJCbP8hd44DufbFdpxyaC6QlyZzpcEdNE64zHoFSR3l5UdzO98ZgfEvih0pmt", + "2uMmS38LRos33Jgw2eKSicVEgObks30pF+zcbq4t3q3Isv5ekdcFvgN6Ju2HF28f+rfQSjpt1lL7QfA3", + "9heyy9HzgRFBmbhQ0RBPcjokyoDu+6EafRUGzMJ4oarwiTSwCXRTWE0ZNQTjA+qUlWRQ0Y4OC6JN2TY9", + "UuEwK4vo5mJBiUswBMufIMLCCUWJ39BPxdsXcB6WjEH8X4WIByW1Gw9RilZsOWtXrEz9C4WPaGWELhxO", + "PoMjLVOfkoRAsWiEapqXD/JMKV0IZL0rx6d9utCQW3E1X2hLXEXdfLHRn+D4BpenZl3027Ehu4egWiOq", + "1ZziA691nXJ83LfY72wYbkru+jmVy1deWNWlh9eTdkw09fHj/38AgfCWxqXhAwA=", } // GetSwagger returns the content of the embedded swagger specification file From 0ef83461ef1484c00ac9bbfe667ccc527c69d804 Mon Sep 17 00:00:00 2001 From: Sayan- <1415138+Sayan-@users.noreply.github.com> Date: Fri, 23 Oct 2026 01:27:47 +0000 Subject: [PATCH 11/15] Keep Chrome's effective network responses --- server/lib/cdpmonitor/README.md | 19 ++++--- server/lib/cdpmonitor/cdp_proto.go | 13 ----- server/lib/cdpmonitor/handlers.go | 5 -- server/lib/cdpmonitor/network_capture.go | 65 ++++-------------------- server/openapi.yaml | 11 ++-- 5 files changed, 23 insertions(+), 90 deletions(-) diff --git a/server/lib/cdpmonitor/README.md b/server/lib/cdpmonitor/README.md index ce207c511..807cf56b6 100644 --- a/server/lib/cdpmonitor/README.md +++ b/server/lib/cdpmonitor/README.md @@ -116,14 +116,14 @@ belonging to the new loader seed its pending count; completions from the previou navigation cannot make the new navigation idle. Same-process frame requests still participate in their page's network-idle accounting. -The collector joins `requestWillBeSentExtraInfo` and `responseReceivedExtraInfo` +The collector joins `requestWillBeSentExtraInfo` to requests by session, request ID, and redirect hop. Cached hops without ExtraInfo do not consume the next hop's headers. A `network_request` waits at most one second for wire headers, then uses the base headers so a hanging request remains visible. `network_response.request_headers` retains wire request headers that arrive after that initial event. After body retrieval, response capture waits up to one second -total for both request and response headers, sharing one deadline. It then falls -back to the base headers for anything still missing or invalid. Capture remains +for request headers. Missing or invalid request headers fall back to the base +headers on the request event and are omitted from the response. Capture remains best-effort when Chrome omits events or a target disconnects. Redirects emit a response for each hop, without a body. Request IDs remain the same across a redirect chain. @@ -142,12 +142,11 @@ publication dependencies drain in order even when capture is canceled. Header correlation stays active for pending redirect responses after the final request completes or fails, until their capture finishes. -`network_response.status` and `status_text` retain Chrome's effective response, -including custom reason phrases. `wire_status` adds the wire status when available: -a revalidated cached response has `status: 200`, `wire_status: 304`, and may carry -Chrome's cached body. Existing success checks can continue using `status`. -`headers` contains the wire response headers when available rather than Chrome's -merged cache headers. +`network_response.status`, `status_text`, and `headers` retain Chrome's effective +response, including custom reason phrases and retained cache headers. A +revalidated cached response has `status: 200` and may carry Chrome's cached body. +Body capture is limited to selected textual resources and remains subject to +truncation and retrieval errors. While optional telemetry is enabled, `Network.enable` requests durable body storage with `maxTotalBufferSize` set to 10 MiB on each attached session. Disabling @@ -438,7 +437,7 @@ Unless otherwise noted, events also include the nav context fields described abo | Event | Fields | | --- | --- | | `network_request` | `request_id`, `loader_id`, `frame_id`, `document_url`, `method`, `url`, `headers`, `initiator_type`. Optional: `post_data`, `resource_type`, `is_redirect` + `redirect_url`. | -| `network_response` | `request_id`, `loader_id`, `frame_id`, `method`, `url`, `status`, `headers`. Optional: `status_text`, `mime_type`, `resource_type`, `body` (truncated text body for textual MIME types), `body_error`, `request_headers`, `wire_status`. | +| `network_response` | `request_id`, `loader_id`, `frame_id`, `method`, `url`, `status`, `headers`. Optional: `status_text`, `mime_type`, `resource_type`, `body` (truncated text body for textual MIME types), `body_error`, `request_headers`. | | `network_loading_failed` | `request_id`, `error_text`, `canceled`. Optional (absent when the request record was not found): `url`, `loader_id`, `frame_id`, `resource_type`. | | `proxy_error` | `request_id`, `code` (typed enum matching the metro header values), `status` (502, or 403 when the session's network policy blocks the destination). Optional: `raw_code` (sanitized original value when `code` is `unknown`), `url`, `loader_id`, `frame_id`, `method`, `resource_type`. Emitted when a 502 or 403 response carries the `X-Kernel-Proxy-Error` header. Unrecognized values are reported as `unknown`; all such values share one rate-limit slot. Emission is sampled to at most one per session+code+resource_type per second. WebSocket handshakes are not classified (documented non-goal). A CONNECT the proxy refuses outright, such as a `network_policy_denied` CONNECT to a port other than 443, is not classified either: Chromium does not expose the refusal, so it appears only as `network_loading_failed` with `net::ERR_TUNNEL_CONNECTION_FAILED`. | diff --git a/server/lib/cdpmonitor/cdp_proto.go b/server/lib/cdpmonitor/cdp_proto.go index a17316438..7fc374b36 100644 --- a/server/lib/cdpmonitor/cdp_proto.go +++ b/server/lib/cdpmonitor/cdp_proto.go @@ -173,19 +173,6 @@ type cdpNetworkRequestWillBeSentExtraInfoParams struct { AppliedNetworkConditionsID string `json:"appliedNetworkConditionsId,omitempty"` } -// cdpNetworkResponseReceivedExtraInfoParams mirrors Network.responseReceivedExtraInfo. -type cdpNetworkResponseReceivedExtraInfoParams struct { - RequestID string `json:"requestId"` - BlockedCookies json.RawMessage `json:"blockedCookies"` - Headers json.RawMessage `json:"headers"` - ResourceIPAddressSpace string `json:"resourceIPAddressSpace"` - StatusCode int `json:"statusCode"` - HeadersText string `json:"headersText,omitempty"` - CookiePartitionKey json.RawMessage `json:"cookiePartitionKey,omitempty"` - CookiePartitionKeyOpaque bool `json:"cookiePartitionKeyOpaque,omitempty"` - ExemptedCookies json.RawMessage `json:"exemptedCookies,omitempty"` -} - // cdpNetworkResponseReceivedParams mirrors Network.responseReceived params. type cdpNetworkResponseReceivedParams struct { RequestID string `json:"requestId"` diff --git a/server/lib/cdpmonitor/handlers.go b/server/lib/cdpmonitor/handlers.go index 40906ada6..e64cd199d 100644 --- a/server/lib/cdpmonitor/handlers.go +++ b/server/lib/cdpmonitor/handlers.go @@ -157,11 +157,6 @@ func (m *Monitor) dispatchEvent(msg cdpMessage) { if m.decodeParams(msg.Method, msg.Params, &p) { m.handleRequestExtraInfo(p, msg.SessionID) } - case "Network.responseReceivedExtraInfo": - var p cdpNetworkResponseReceivedExtraInfoParams - if m.decodeParams(msg.Method, msg.Params, &p) { - m.handleResponseExtraInfo(p, msg.SessionID) - } case "Network.responseReceived": var p cdpNetworkResponseReceivedParams if m.decodeParams(msg.Method, msg.Params, &p) { diff --git a/server/lib/cdpmonitor/network_capture.go b/server/lib/cdpmonitor/network_capture.go index 5fd3044b6..192b6e7b6 100644 --- a/server/lib/cdpmonitor/network_capture.go +++ b/server/lib/cdpmonitor/network_capture.go @@ -17,13 +17,12 @@ const ( ) // Chrome emits base events and ExtraInfo on independent streams. Redirects reuse -// request IDs; only hops whose response advertises ExtraInfo consume those queues. +// request IDs; only hops whose response advertises ExtraInfo consume the header queue. // All exchange and hop fields are protected by pendReqMu. type networkExchange struct { addedAt time.Time hops []*networkHop requests []json.RawMessage - responses []cdpNetworkResponseReceivedExtraInfoParams terminal bool publications int // request/response publishers still using this exchange } @@ -36,11 +35,8 @@ type networkHop struct { known bool hasExtra bool requestHeaders json.RawMessage - responseExtra *cdpNetworkResponseReceivedExtraInfoParams requestReady chan struct{} - responseReady chan struct{} requestMatched bool - responseMatched bool requestPublished chan struct{} } @@ -62,7 +58,6 @@ func (m *Monitor) queueNetworkRequestLocked(key networkRequestKey, request oapi. source: oapi.BrowserEventSource{Kind: oapi.Cdp, Metadata: &metadata}, observedAt: observedAt, requestReady: make(chan struct{}), - responseReady: make(chan struct{}), requestPublished: make(chan struct{}), } e.hops = append(e.hops, h) @@ -85,21 +80,6 @@ func (m *Monitor) handleRequestExtraInfo(p cdpNetworkRequestWillBeSentExtraInfoP e.matchHeaders() } -func (m *Monitor) handleResponseExtraInfo(p cdpNetworkResponseReceivedExtraInfoParams, sessionID string) { - key := networkRequestKey{sessionID, p.RequestID} - m.pendReqMu.Lock() - defer m.pendReqMu.Unlock() - if m.networkExchanges[key] == nil && len(m.networkExchanges) >= maxNetworkExchanges { - return - } - e := m.exchangeLocked(key) - if len(e.responses) >= maxExtraInfoPerExchange { - return - } - e.responses = append(e.responses, p) - e.matchHeaders() -} - func (m *Monitor) resolveNetworkHeadersLocked(h *networkHop, hasExtra bool) { if h == nil { return @@ -151,36 +131,15 @@ func (e *networkExchange) matchHeaders() { h.requestMatched = true close(h.requestReady) } - for _, h := range e.hops { - if !h.known { - break - } - if h.responseMatched { - continue - } - if h.hasExtra { - if len(e.responses) == 0 { - break - } - extra := e.responses[0] - h.responseExtra, e.responses = &extra, e.responses[1:] - } - h.responseMatched = true - close(h.responseReady) - } } -func waitNetworkHeaders(ctx context.Context, ready ...<-chan struct{}) { +func waitNetworkHeaders(ctx context.Context, ready <-chan struct{}) { timer := time.NewTimer(networkHeaderWait) defer timer.Stop() - for _, ch := range ready { - select { - case <-ch: - case <-ctx.Done(): - return - case <-timer.C: - return - } + select { + case <-ready: + case <-ctx.Done(): + case <-timer.C: } } @@ -242,11 +201,14 @@ func (m *Monitor) emitNetworkResponse(ctx context.Context, observedAt time.Time, body, bodyErr = m.fetchResponseBody(ctx, key.requestID, key.sessionID, state) } if h != nil { - waitNetworkHeaders(ctx, h.requestReady, h.responseReady) + waitNetworkHeaders(ctx, h.requestReady) <-h.requestPublished } var headers oapi.BrowserHttpHeaders _ = json.Unmarshal(state.resHeaders, &headers) + // Use Chrome's effective status and headers with its captured body. A wire + // 304 can omit cached headers; a separate wire response view is intentionally + // not exposed by browser telemetry. payload := oapi.BrowserNetworkResponseEventData{ SessionId: key.sessionID, TargetId: info.targetID, @@ -278,13 +240,6 @@ func (m *Monitor) emitNetworkResponse(ctx context.Context, observedAt time.Time, payload.RequestHeaders = &requestHeaders } } - if h.responseExtra != nil { - var responseHeaders oapi.BrowserHttpHeaders - if json.Unmarshal(h.responseExtra.Headers, &responseHeaders) == nil && responseHeaders != nil { - payload.Headers = responseHeaders - } - payload.WireStatus = ptrOf(h.responseExtra.StatusCode) - } m.pendReqMu.Unlock() } data, _ := json.Marshal(payload) diff --git a/server/openapi.yaml b/server/openapi.yaml index acf0d9785..b4315554f 100644 --- a/server/openapi.yaml +++ b/server/openapi.yaml @@ -2617,7 +2617,7 @@ components: description: URL of the document that initiated the request. headers: $ref: "#/components/schemas/BrowserHttpHeaders" - description: Request headers, enriched with wire headers when available before publication. + description: Request headers reported by Chrome, including browser-added headers available before publication. resource_type: type: string description: CDP Network.ResourceType for the request, passed through as-is from Chrome. Known values include Document, Fetch, XHR, Script, Stylesheet, Image, Media, Font, TextTrack, EventSource, WebSocket, Manifest, Prefetch, Other, and more. @@ -2669,13 +2669,13 @@ components: description: HTTP method of the original request. status: type: integer - description: Effective HTTP response status reported by Chrome, including 200 for a cached response revalidated with a wire 304. + description: Effective HTTP response status reported by Chrome, including 200 after successful cache revalidation. status_text: type: string description: HTTP response status text (e.g. OK, Not Found). headers: $ref: "#/components/schemas/BrowserHttpHeaders" - description: Response headers. + description: Effective response headers reported by Chrome, including retained cache headers after revalidation. mime_type: type: string description: MIME type of the response (e.g. text/html, application/json). @@ -2684,10 +2684,7 @@ components: description: CDP Network.ResourceType for the request, passed through as-is from Chrome. Known values include Document, Fetch, XHR, Script, Stylesheet, Image, Media, Font, TextTrack, EventSource, WebSocket, Manifest, Prefetch, Other, and more. request_headers: $ref: "#/components/schemas/BrowserHttpHeaders" - description: Wire request headers when available, including headers that arrived after network_request was published. - wire_status: - type: integer - description: HTTP status received on the wire when available, such as 304 for a revalidated cached response whose effective status is 200. Does not change the meaning of status or the cached body. + description: Captured request headers when available, including browser-added headers that arrived after network_request was published. body: type: string description: Truncated response body, present only for text MIME types. From 51ab43af4abf8fcc2901988af07a1432860fe0a4 Mon Sep 17 00:00:00 2001 From: Sayan- <1415138+Sayan-@users.noreply.github.com> Date: Fri, 23 Oct 2026 01:27:47 +0000 Subject: [PATCH 12/15] Cover effective response headers and cache behavior --- server/lib/cdpmonitor/cdp_proto_test.go | 1 - server/lib/cdpmonitor/network_capture_test.go | 39 +++++++++-------- .../network_fidelity_chrome_e2e_test.go | 42 +++++++++++++++++-- .../Network_responseReceivedExtraInfo.json | 11 ----- 4 files changed, 58 insertions(+), 35 deletions(-) delete mode 100644 server/lib/cdpmonitor/testdata/Network_responseReceivedExtraInfo.json diff --git a/server/lib/cdpmonitor/cdp_proto_test.go b/server/lib/cdpmonitor/cdp_proto_test.go index 0c9f535b3..87df22d6d 100644 --- a/server/lib/cdpmonitor/cdp_proto_test.go +++ b/server/lib/cdpmonitor/cdp_proto_test.go @@ -30,7 +30,6 @@ func TestLayer1Roundtrip(t *testing.T) { {"Runtime.bindingCalled", "Runtime_bindingCalled.json", func() any { return new(cdpRuntimeBindingCalledParams) }}, {"Network.requestWillBeSent", "Network_requestWillBeSent.json", func() any { return new(cdpNetworkRequestWillBeSentParams) }}, {"Network.requestWillBeSentExtraInfo", "Network_requestWillBeSentExtraInfo.json", func() any { return new(cdpNetworkRequestWillBeSentExtraInfoParams) }}, - {"Network.responseReceivedExtraInfo", "Network_responseReceivedExtraInfo.json", func() any { return new(cdpNetworkResponseReceivedExtraInfoParams) }}, {"Network.responseReceived", "Network_responseReceived.json", func() any { return new(cdpNetworkResponseReceivedParams) }}, {"Network.loadingFinished", "Network_loadingFinished.json", func() any { return new(cdpNetworkLoadingFinishedParams) }}, {"Network.loadingFailed", "Network_loadingFailed.json", func() any { return new(cdpNetworkLoadingFailedParams) }}, diff --git a/server/lib/cdpmonitor/network_capture_test.go b/server/lib/cdpmonitor/network_capture_test.go index ec768e19b..119e34f96 100644 --- a/server/lib/cdpmonitor/network_capture_test.go +++ b/server/lib/cdpmonitor/network_capture_test.go @@ -65,7 +65,6 @@ func TestNetworkRedirectHopsPublishInOrder(t *testing.T) { time.Sleep(200 * time.Millisecond) if mode == "late_headers" { m.handleRequestExtraInfo(cdpNetworkRequestWillBeSentExtraInfoParams{RequestID: "r", Headers: json.RawMessage(`{}`)}, "s") - m.handleResponseExtraInfo(cdpNetworkResponseReceivedExtraInfoParams{RequestID: "r", StatusCode: 302, Headers: json.RawMessage(`{}`)}, "s") } else if mode == "canceled" { cancel() } @@ -118,7 +117,7 @@ func TestNetworkHeadersFollowRedirectHops(t *testing.T) { if order == "interleaved" { extra(1) } - send("Network.responseReceived", cdpNetworkResponseReceivedParams{RequestID: "r", HasExtraInfo: true, Response: cdpNetworkResponse{Status: 200}}) + send("Network.responseReceived", cdpNetworkResponseReceivedParams{RequestID: "r", HasExtraInfo: true, Response: cdpNetworkResponse{Status: 200, Headers: json.RawMessage(`{"Base":"final"}`)}}) send("Network.loadingFinished", cdpNetworkLoadingFinishedParams{RequestID: "r"}) if order == "extras_last" { extra(0) @@ -127,7 +126,7 @@ func TestNetworkHeadersFollowRedirectHops(t *testing.T) { for _, tc := range []struct { path, cookie, header string status int - }{{"start", "hop=0", "0", 302}, {"cached", "", "", 301}, {"final", "hop=1", "1", 200}} { + }{{"start", "hop=0", "redirect", 302}, {"cached", "", "cached", 301}, {"final", "hop=1", "final", 200}} { req := waitForNetworkURL(t, ec, EventNetworkRequest, "https://example.com/"+tc.path) var request oapi.BrowserNetworkRequestEventData require.NoError(t, json.Unmarshal(req.Data, &request)) @@ -135,15 +134,15 @@ func TestNetworkHeadersFollowRedirectHops(t *testing.T) { var response oapi.BrowserNetworkResponseEventData require.NoError(t, json.Unmarshal(res.Data, &response)) require.Equal(t, tc.status, response.Status) + require.Equal(t, tc.header, response.Headers["Base"]) + require.NotContains(t, response.Headers, "X-Hop") if tc.cookie != "" { require.Equal(t, tc.cookie, request.Headers["Cookie"]) require.NotNil(t, response.RequestHeaders) require.Equal(t, tc.cookie, (*response.RequestHeaders)["Cookie"]) - require.Equal(t, tc.header, response.Headers["X-Hop"]) } else { require.NotContains(t, request.Headers, "Cookie") require.Nil(t, response.RequestHeaders) - require.Equal(t, "cached", response.Headers["Base"]) } } }) @@ -157,23 +156,25 @@ func TestTerminalRequestPreservesPendingRedirectHeaders(t *testing.T) { m, ec := newComputedMonitor(t) defer m.Stop() m.handleNetworkRequest(cdpNetworkRequestWillBeSentParams{RequestID: "r", Request: cdpNetworkRequest{Method: "GET", URL: "https://example.com/start"}}, "s") - m.handleRequestExtraInfo(cdpNetworkRequestWillBeSentExtraInfoParams{RequestID: "r", Headers: json.RawMessage(`{"Cookie":"hop=0"}`)}, "s") m.handleNetworkRequest(cdpNetworkRequestWillBeSentParams{RequestID: "r", RedirectHasExtraInfo: true, RedirectResponse: json.RawMessage(`{"status":302,"headers":{"Base":"redirect"}}`), Request: cdpNetworkRequest{Method: "GET", URL: "https://example.com/final"}}, "s") if terminal == EventNetworkLoadingFailed { - m.handleRequestExtraInfo(cdpNetworkRequestWillBeSentExtraInfoParams{RequestID: "r", Headers: json.RawMessage(`{"Cookie":"hop=1"}`)}, "s") m.handleLoadingFailed(cdpNetworkLoadingFailedParams{RequestID: "r", ErrorText: "net::ERR_ABORTED", Canceled: true}, "s") } else { m.handleResponseReceived(cdpNetworkResponseReceivedParams{RequestID: "r", Response: cdpNetworkResponse{Status: 200}}, "s") m.handleLoadingFinished(context.Background(), cdpNetworkLoadingFinishedParams{RequestID: "r"}, "s") } time.Sleep(200 * time.Millisecond) - m.handleResponseExtraInfo(cdpNetworkResponseReceivedExtraInfoParams{RequestID: "r", StatusCode: 302, Headers: json.RawMessage(`{"Set-Cookie":"redirect=true","X-Wire":"yes"}`)}, "s") + m.handleRequestExtraInfo(cdpNetworkRequestWillBeSentExtraInfoParams{RequestID: "r", Headers: json.RawMessage(`{"Cookie":"hop=0"}`)}, "s") + if terminal == EventNetworkLoadingFailed { + m.handleRequestExtraInfo(cdpNetworkRequestWillBeSentExtraInfoParams{RequestID: "r", Headers: json.RawMessage(`{"Cookie":"hop=1"}`)}, "s") + } synctest.Wait() event := waitForNetworkURL(t, ec, EventNetworkResponse, "https://example.com/start") var response oapi.BrowserNetworkResponseEventData require.NoError(t, json.Unmarshal(event.Data, &response)) - require.Equal(t, "redirect=true", response.Headers["Set-Cookie"]) - require.Equal(t, "yes", response.Headers["X-Wire"]) + require.Equal(t, "redirect", response.Headers["Base"]) + require.NotNil(t, response.RequestHeaders) + require.Equal(t, "hop=0", (*response.RequestHeaders)["Cookie"]) waitForNetworkURL(t, ec, terminal, "https://example.com/final") require.Empty(t, m.networkExchanges, "completed captures must release their header state") }) @@ -255,7 +256,7 @@ func TestNetworkLateHeadersRemainOnResponse(t *testing.T) { require.NoError(t, json.Unmarshal(response.Data, &payload)) require.NotNil(t, payload.RequestHeaders) require.Equal(t, "late=true", (*payload.RequestHeaders)["Cookie"]) - require.Equal(t, "yes", payload.Headers["X-Wire"]) + require.NotContains(t, payload.Headers, "X-Wire") ec.mu.Lock() defer ec.mu.Unlock() count := 0 @@ -277,7 +278,7 @@ func TestNetworkMalformedWireHeadersPreserveBaseHeaders(t *testing.T) { sendNetworkFixture(t, srv, "Network.requestWillBeSent", cdpNetworkRequestWillBeSentParams{RequestID: "r", Request: cdpNetworkRequest{Method: "GET", URL: "https://example.com/", Headers: json.RawMessage(`{"X-Request":"base"}`)}}) sendNetworkFixture(t, srv, "Network.requestWillBeSentExtraInfo", cdpNetworkRequestWillBeSentExtraInfoParams{RequestID: "r", Headers: json.RawMessage(wire)}) sendNetworkFixture(t, srv, "Network.responseReceived", cdpNetworkResponseReceivedParams{RequestID: "r", HasExtraInfo: true, Response: cdpNetworkResponse{Status: 200, Headers: json.RawMessage(`{"X-Response":"base"}`)}}) - sendNetworkFixture(t, srv, "Network.responseReceivedExtraInfo", cdpNetworkResponseReceivedExtraInfoParams{RequestID: "r", StatusCode: 200, Headers: json.RawMessage(wire)}) + sendNetworkFixture(t, srv, "Network.responseReceivedExtraInfo", map[string]any{"requestId": "r", "statusCode": 200, "headers": json.RawMessage(wire)}) sendNetworkFixture(t, srv, "Network.loadingFinished", cdpNetworkLoadingFinishedParams{RequestID: "r"}) var request oapi.BrowserNetworkRequestEventData require.NoError(t, json.Unmarshal(ec.waitFor(t, EventNetworkRequest, time.Second).Data, &request)) @@ -290,7 +291,7 @@ func TestNetworkMalformedWireHeadersPreserveBaseHeaders(t *testing.T) { } } -func TestNetworkStatusRemainsCompatible(t *testing.T) { +func TestNetworkResponseUsesEffectiveValues(t *testing.T) { for _, tc := range []struct { name string wireStatus *int @@ -305,22 +306,20 @@ func TestNetworkStatusRemainsCompatible(t *testing.T) { _, ec, cleanup := startMonitor(t, srv, nil) defer cleanup() sendNetworkFixture(t, srv, "Network.requestWillBeSent", cdpNetworkRequestWillBeSentParams{RequestID: "r", Request: cdpNetworkRequest{Method: "GET", URL: "https://example.com/"}}) - sendNetworkFixture(t, srv, "Network.responseReceived", cdpNetworkResponseReceivedParams{RequestID: "r", HasExtraInfo: tc.wireStatus != nil, Response: cdpNetworkResponse{Status: 200, StatusText: "Custom OK", Headers: json.RawMessage(`{"ETag":"v1"}`)}}) + sendNetworkFixture(t, srv, "Network.responseReceived", cdpNetworkResponseReceivedParams{RequestID: "r", HasExtraInfo: tc.wireStatus != nil, Response: cdpNetworkResponse{Status: 200, StatusText: "Custom OK", Headers: json.RawMessage(`{"ETag":"v1","Content-Type":"application/json","X-Cached":"retained"}`)}}) if tc.wireStatus != nil { sendNetworkFixture(t, srv, "Network.requestWillBeSentExtraInfo", cdpNetworkRequestWillBeSentExtraInfoParams{RequestID: "r", Headers: json.RawMessage(`{}`)}) - sendNetworkFixture(t, srv, "Network.responseReceivedExtraInfo", cdpNetworkResponseReceivedExtraInfoParams{RequestID: "r", StatusCode: *tc.wireStatus, Headers: json.RawMessage(`{"ETag":"v1"}`)}) + sendNetworkFixture(t, srv, "Network.responseReceivedExtraInfo", map[string]any{"requestId": "r", "statusCode": *tc.wireStatus, "headers": map[string]string{"ETag": "v1"}}) } sendNetworkFixture(t, srv, "Network.loadingFinished", cdpNetworkLoadingFinishedParams{RequestID: "r"}) var response map[string]any require.NoError(t, json.Unmarshal(ec.waitFor(t, EventNetworkResponse, time.Second).Data, &response)) require.Equal(t, float64(200), response["status"]) require.Equal(t, "Custom OK", response["status_text"]) + require.Equal(t, map[string]any{"ETag": "v1", "Content-Type": "application/json", "X-Cached": "retained"}, response["headers"]) require.NotContains(t, response, "effective_status") - if tc.wireStatus != nil { - require.Equal(t, float64(*tc.wireStatus), response["wire_status"]) - } else { - require.NotContains(t, response, "wire_status") - } + require.NotContains(t, response, "wire_status") + require.NotContains(t, response, "wire_headers") }) } } diff --git a/server/lib/cdpmonitor/network_fidelity_chrome_e2e_test.go b/server/lib/cdpmonitor/network_fidelity_chrome_e2e_test.go index c9794b26c..ce38a672f 100644 --- a/server/lib/cdpmonitor/network_fidelity_chrome_e2e_test.go +++ b/server/lib/cdpmonitor/network_fidelity_chrome_e2e_test.go @@ -27,6 +27,7 @@ func TestNetworkWireCapture(t *testing.T) { var mu sync.Mutex var wireHeaders http.Header var statuses []int + var cachedRequests int stub := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { switch r.URL.Path { case "/api": @@ -39,13 +40,24 @@ func TestNetworkWireCapture(t *testing.T) { } statuses = append(statuses, status) mu.Unlock() - w.Header().Set("Content-Type", "application/json") w.Header().Set("ETag", `"v1"`) w.Header().Set("Cache-Control", "no-cache") + if status == 200 { + w.Header().Set("Content-Type", "application/json") + w.Header().Set("X-Cached", "retained") + } w.WriteHeader(status) if status == 200 { fmt.Fprint(w, `{"ok":true}`) } + case "/cached": + mu.Lock() + cachedRequests++ + mu.Unlock() + w.Header().Set("Content-Type", "application/json") + w.Header().Set("Cache-Control", "max-age=3600") + w.Header().Set("X-Cached", "fresh") + fmt.Fprint(w, `{"cached":true}`) default: w.Header().Set("Content-Type", "text/html") fmt.Fprint(w, "local reproduction") @@ -101,14 +113,38 @@ func TestNetworkWireCapture(t *testing.T) { headers := requests[0]["headers"].(map[string]any) require.Contains(t, headers, "Cookie", "server received Cookie, telemetry must capture it") }) - t.Run("wire_status", func(t *testing.T) { + t.Run("effective_response", func(t *testing.T) { responses := snapshot(EventNetworkResponse, stub.URL+"/api") - require.ElementsMatch(t, []any{float64(200), float64(304)}, []any{responses[0]["wire_status"], responses[1]["wire_status"]}) for _, response := range responses { require.Equal(t, float64(200), response["status"]) require.Equal(t, "OK", response["status_text"]) + headers := response["headers"].(map[string]any) + require.Equal(t, "application/json", headers["Content-Type"]) + require.Equal(t, "retained", headers["X-Cached"]) require.JSONEq(t, `{"ok":true}`, response["body"].(string)) require.NotContains(t, response, "effective_status") + require.NotContains(t, response, "wire_status") + require.NotContains(t, response, "wire_headers") + } + }) + t.Run("fresh_cache", func(t *testing.T) { + for range 2 { + result := driver.call(t, ctx, session, "Runtime.evaluate", map[string]any{"expression": `fetch("/cached").then(r => r.text())`, "awaitPromise": true, "returnByValue": true}) + require.NotContains(t, string(result.raw), "exceptionDetails") + } + require.Eventually(t, func() bool { return len(snapshot(EventNetworkResponse, stub.URL+"/cached")) == 2 }, 5*time.Second, 20*time.Millisecond) + mu.Lock() + count := cachedRequests + mu.Unlock() + require.Equal(t, 1, count, "the second fetch must use the cache without contacting the server") + for _, response := range snapshot(EventNetworkResponse, stub.URL+"/cached") { + require.Equal(t, float64(200), response["status"]) + headers := response["headers"].(map[string]any) + require.Equal(t, "application/json", headers["Content-Type"]) + require.Equal(t, "fresh", headers["X-Cached"]) + require.JSONEq(t, `{"cached":true}`, response["body"].(string)) + require.NotContains(t, response, "wire_status") + require.NotContains(t, response, "wire_headers") } }) } diff --git a/server/lib/cdpmonitor/testdata/Network_responseReceivedExtraInfo.json b/server/lib/cdpmonitor/testdata/Network_responseReceivedExtraInfo.json deleted file mode 100644 index e533db8bc..000000000 --- a/server/lib/cdpmonitor/testdata/Network_responseReceivedExtraInfo.json +++ /dev/null @@ -1,11 +0,0 @@ -{ - "requestId": "149.2", - "blockedCookies": [], - "headers": {"ETag": "v1"}, - "resourceIPAddressSpace": "Public", - "statusCode": 304, - "headersText": "HTTP/1.1 304 Not Modified\r\nETag: v1\r\n\r\n", - "cookiePartitionKey": {"topLevelSite": "https://example.com", "hasCrossSiteAncestor": false}, - "cookiePartitionKeyOpaque": true, - "exemptedCookies": [] -} From 48ba41f41fa8ff7c28bf296267001f69051e421b Mon Sep 17 00:00:00 2001 From: Sayan- <1415138+Sayan-@users.noreply.github.com> Date: Fri, 23 Oct 2026 01:27:47 +0000 Subject: [PATCH 13/15] Regenerate network response API bindings --- server/lib/oapi/oapi.go | 1510 +++++++++++++++++++-------------------- 1 file changed, 753 insertions(+), 757 deletions(-) diff --git a/server/lib/oapi/oapi.go b/server/lib/oapi/oapi.go index cbeb1581f..e0f6bad81 100644 --- a/server/lib/oapi/oapi.go +++ b/server/lib/oapi/oapi.go @@ -5373,7 +5373,7 @@ type BrowserNetworkRequestEventData struct { // FrameId CDP frame identifier within the target. FrameId *string `json:"frame_id,omitempty"` - // Headers Request headers, enriched with wire headers when available before publication. + // Headers Request headers reported by Chrome, including browser-added headers available before publication. Headers BrowserHttpHeaders `json:"headers"` // InitiatorType CDP Initiator.type indicating what caused the request, passed through as-is from Chrome. Known values include script, parser, preload, and other. @@ -5449,7 +5449,7 @@ type BrowserNetworkResponseEventData struct { // FrameId CDP frame identifier within the target. FrameId *string `json:"frame_id,omitempty"` - // Headers Response headers. + // Headers Effective response headers reported by Chrome, including retained cache headers after revalidation. Headers BrowserHttpHeaders `json:"headers"` // LoaderId CDP document loader identifier, reset on each navigation. @@ -5464,7 +5464,7 @@ type BrowserNetworkResponseEventData struct { // NavSeq Monotonically increasing navigation sequence number, incremented on each top-level navigation within the target. NavSeq int64 `json:"nav_seq"` - // RequestHeaders Wire request headers when available, including headers that arrived after network_request was published. + // RequestHeaders Captured request headers when available, including browser-added headers that arrived after network_request was published. RequestHeaders *BrowserHttpHeaders `json:"request_headers,omitempty"` // RequestId CDP request identifier matching the originating network_request event. @@ -5476,7 +5476,7 @@ type BrowserNetworkResponseEventData struct { // SessionId CDP session identifier for the target connection. SessionId string `json:"session_id"` - // Status Effective HTTP response status reported by Chrome, including 200 for a cached response revalidated with a wire 304. + // Status Effective HTTP response status reported by Chrome, including 200 after successful cache revalidation. Status int `json:"status"` // StatusText HTTP response status text (e.g. OK, Not Found). @@ -5490,9 +5490,6 @@ type BrowserNetworkResponseEventData struct { // Url URL relevant to this event; page URL for navigation and page events, request URL for network events. Url *string `json:"url,omitempty"` - - // WireStatus HTTP status received on the wire when available, such as 304 for a revalidated cached response whose effective status is 200. Does not change the meaning of status or the cached body. - WireStatus *int `json:"wire_status,omitempty"` } // BrowserPageCrashedEvent A page's renderer process crashed (an "Aw, Snap!" failure) while the browser process itself stayed alive. Reported on the crashed page's session, with the session and target ids on `source.metadata`. Captured only while the `page` category is enabled. @@ -27603,756 +27600,755 @@ func (sh *strictHandler) GetWebMCPTools(w http.ResponseWriter, r *http.Request, // Base64 encoded, gzipped, json marshaled Swagger object var swaggerSpec = []string{ - "H4sIAAAAAAAC/+z9j3YbN7InAL8KlnvPsXSXpGTHyUzkM2c/x5YnvvEffZYyuXdGWRLsBkmMmkAPgJbE", - "5POefYh9wn2S71QVgO4mu8mm/thxojlzHJHEf1QVCoWqX/3aS/Qi10ooZ3tHv/aMsLlWVuCH73j6Qfyr", - "ENYdG6MNfJVo5YRy8CfP80wm3EmtDv5ptYLvbDIXCw5//ZsR095R778flO0f0K/2gFr7+PFjv5cKmxiZ", - "QyO9I+iQ+R57H/u9F1pNM5l8qt5Dd9D1a+WEUTz7RF2H7tipMJfCMF+w33un3StdqPQTjeOddgz768Fv", - "vji09jxNXxTW6cVPYvL2xcmZ1pkNOwVDSVMJTfDsxOhcGCeBgqY8s6Lfyytf/dqbapOIkb4U5spIJ0aK", - "L4TNeSLgx1RMeZG5WLU+uudOL2TCs2zJjMgzngjGs4yJa2mdVDPmYFRMKubm0rLYMLuSbk7fTbhL5uxq", - "LhRzphDDXr/nlrnoHfUmWmeCK1jz2ohy7mBreke9//WP54O/88Evh4NvR8PBz78+7j9+8ueP/1Y2YZ2R", - "agYtWF2YMKHqBP6DX/JT/MzEdW6EtVLDaLlj4pJnBXfCMqcZZ0qrgVjkbsm4MXzJ9JQluP44SZaKqVS4", - "4hbmsODXb4SauXnv6M+H+L+1QX3s94z4VyGNSHtH/6jMMY7251hHT/4piA2+g/V6oRd54YR5nkCHXXd9", - "Zev80sM8fHOMY3s4YXEtksIJZqFx5STs8bC3Sjq+wvq6vjepMCJlmbQOulhveciO8Q9Yb+t0bhkuvGBT", - "aaxjAhgCOpROLOw29qkvCKzTQqrXVPNxXEXcuLWFD3NoXG2jr6wwz3P5gmfZ8aXn89WVBA4gokmNvASK", - "mQs2obp9NucqzUTKJkv8/kIYJbKBXPCZsAOeS2ZRxBzFfRiASDE6C6vWZycZX14ZOZs7luhU+DWUWvWZ", - "TYwQys61s4yrlCWZzCeam5TxJBHWDhkM3dLwFlzxmcBh/O0tk8o6wVMmFtKxcZ5xN9VmMeK5HMGMxsNz", - "tbbjCXdips0S/haqWMAK+uH2fl6j8X4v5W6r8GtY5ZdQrca3HRrAmqdU42O/50yhYLjp+padmUIwOcWF", - "gBGyqRRZyq64ZbEWSwsB9GrlL4JlciGdbZZOroH+cSjMyYWwji9yEIE/KnnNFjIx2opEqxRbgwXnrnfU", - "k8p987RsXionZgIPHPqmXO2wPQ3LvULZzoYG++W+bZYuLTuxm2g5ARIGlsj5MtM8ZVNt2DiSFRPQrl2X", - "JkDa60tJG8psMVlIB/viNBt7IVLyxQudinGfJTzPRcq4Y39+/O0TNlk6YVkmLwR0apZMu7kwUMoVIJ5o", - "4YbseagIMl8waVlSOKYV4yyZc8MTJwybwDHMzRLZTKgUD7bxcDj8R6SZn8dD9nxiYe9hztU+YaKoGQyb", - "zqe0oB9HiwZi+oln2SDJdHLBQjmmiXhJthgYyUJmmayQlu9DFYsJEVIcwUg2sMRbOA1EyowunHhky/H2", - "8dxOGSexRsIKv7NMOhuHsCeGsyEbn/ELcRpl0rjPxseNe7XfuA6GzrLGEQJZ+d+ZTOFQmkph2NToRYtg", - "DaUXMk0zccWNaOzUOu6KhnX//uzshAX9m1EplL/DBkZd4b3KRFZWPvZX3/UN7Ai8eOp4crE+xBcvT9iH", - "QoGgGWKRM8MTwYzIjQAyRCVsLlhFz0HOtFAW2AR+hNp4SCtizSF7BeLQssIKBj0ovoCGEq3gZzzIDUeq", - "dnOumFX8QowSblFeLlCtgHZfzI1eCPZSXKJ2yk6MdjrRGbuSRjASfc1nTJa9MnxBnzYrFjibKRbuMyBd", - "s9DWkRJRUx9WutBZsVDviDfWOvm7MHow4VakjAoy4iLUWyWpKZlUjXTQ700Lhef2O77YrHGGgshMfaYN", - "IwWTKBMlCFdaLRe6sLGwbSRhGE2H2UCxhrlQ6ebZ0G+v02bao88VdmwcXWGy9eo/fngDU4a5B2nmW5vK", - "rIlRVzistsyVcVJ3tSXp1/e7idXqKuLKibZGhDmdhCzjE5HhRuHwkakcciBJQ26XKmEJL6xolnc5N+Hu", - "mGXvp72jf3TSdEqJ8PHntdMXm6wNBikJh4Lf2uHaYlZYbqMgyl0y5y/mPMuEmonXL5vWhv+rEBWKYHbO", - "Dam/dPCTxNZKsEtp5SQTLAkNDtlzxVCAD2ZGpnhQJ3POEq6YEc4s6ebI2dQIO2eO2wuWC8O4c8A6fWY1", - "NjyOLY5kOmYLvmQTwbi1OpGo22EziyJzMs8EG0NDWBLPfwsKQW50WiTCYGWUpuZSMOkYT4y2lnGWgypt", - "BGo4dIEFFdt/IS3LuXGRsoHK46CYyKWFc4S9dizVwjKlHZMqlQl3gqalQdCBGNCmUhFIIhOoRqDgXCOo", - "lp36IGyRudYLTNyIsN6xQyM4qgWcgWiVQPS6cIlewAXOK2RaJQK3obKPP3HpPGNISxvfrx0anKZpcGB9", - "5jRLBXVB9xOwR4BsL4cS+x37YY6szi7FyDpunEjHqJet/EbNjxlNeCJwkS9lWvCMYQmDw6CrE+y0TpLC", - "lJSBGnwQlUBZ5RS7Xo5oPLe9HG3Y0Ie7UutdKRBDKQ6IIG57d/Jbt4OoXN2vG9yoIiPUrlVtU9xwzfI1", - "wmJ1p74zqPGx36tK1xvS7+uXN7r2RGW/XA24uHFD1ka8kKwKqj5LQJhACbqQecb3hwbQ20S4KyHqMrW8", - "OLXdD85WOgrCvuFYG2Of6fgIC+DJoSd4pKQr00kywQ3jU7THrQx1yF5pw5y+ECqIaksCdiG4soyXtxUq", - "BEzqbwLPkFzggx1wlQ7mOkvhOKOa9THg+BS/lDNkbn7Fl0M2nnKZFUaEOYTz0TpNd24asgJDaiYT6cqN", - "8LPwDaCiez3nhYXGYcf89Cy7mstMrAzGiAWXSqRDNgYZoQu3MoJHtiw9yMSlyNgVnD6TIp0JtOsCU29r", - "m0+4SrXCPaKtIYoTKvX6gi5c2JGUWTnDnd8840iBU5wzh8ObTQQqhDiUK4ljhH1KpV1Ia+E8NSWVFApY", - "XaTDcxVoKB5mK9vWRy0Cvppm+opxA/YKJh1oM1Y6gVqUdTLLmBEgrhgHfUemRCx9PAPxT+sXDfUppC9J", - "KkpuNNI4d+xqzp3A87O2ojCTWcFNCuxmiyQRgkbf60epTPMAiU4EATxHO9vr9+I+rMvofu96AG0MLrlR", - "dD38Ry9KlNPQavzmVWw+fnUW+4lfPS87/NjvXYkJrNVorm2DpvS9tlGly4MldVUUoUbUqO2HxnPu5uuN", - "n3A379g4+/8WKMgcSbXrJCtglbfemWqiv2KIqAn0HewS2Bou/BYF03dMfBEl7wbl8jPoVqvzeNCrtupV", - "VSX7Hu3RmzZod0UqUF+jGlW/NvxuVSjiQ7w5AX2t3+3OvNQH6uSFm2sjHXfyUviqToJJ8BlLNR4McFe9", - "FA162ozn9H7admnzV8OrubaCpSKTqKLBUURPjwlIOG4EdgMnC1dOhBNlTVXDZ8NR20MCnMkDm4tETmVC", - "T4z0ngYj9sqJN2Mff/jw/sPoxfOTsxffPx/9+O70/Zu/Pf/uzfF4P1r4taIDztqdrMpna2s99s2Mj4Le", - "YIQrjELJWFgOuqTVGT741fSwtdLKT2rPCsHG5WKM92vak6+XyhRXlepXDYJgDkLFqqJIrehIVIQlXCUi", - "y1a0lrruCPb3Afa5ogfQtHdXBEAikcWm1f4UlMMBt6CqibTBIuW9EASZrIHOWoh042HeUVO4mgvjj3Tq", - "AyU99pPehbKwsf271hdupyCA3K6Kw3XLsp/BhVQpMyLXxpEBEaZHxDuE14RLmVYZGg1K9DBFAsMseCZ/", - "gb1XziuyVrgjJpQTJjfSCnbJjeTKWVhLIzy/s0RnGc+tCBWFNOxSGHQOmRTJhXBs7/IJO2CXX+332Rhv", - "VSOu0hHcqsZ037Srl60o8i2p2oXKJF6BYJo05DhXbtkY3w3HdZaZB5UH9inszuWT+sevYF8Lo0DXh22b", - "CeGEdXiKVQfa6/ewj0YGa9jCU2KHbkqeQf+D3JF6x+3FZ1PpqsN+0Ok66nRe9H0yQ1nzTu2u3NGTQLtm", - "V9c7bGnERgv+Cu1aT7r90sRdMRrTvVrNsgaLD961/RnEFlwtsYbFC3WilS0Wwli2KKzDE5hb+AYNzH6A", - "NL66VZ1pw3IujR87CERujLxEO0QKMvEnmIQ3+PQrzxqJNkZk5MwW7fHhLSUqf81KcN/b1WsvKjOji9zS", - "pDa+57wMGp23IGh6vz1ifGWmC+5nI7wlSTobXwdgBELi40FZeiLYQlpLDhxxHRgH7SzBo9CIqTai4YUl", - "KQw9kgU12LXY838zav4n0Xf8jrc8Ld1a4QF3TwHdBq3kLe0ivXoDs9aeZNDMlHBjlkxpahPejElBrzwS", - "2mKCbG/370ePWhv2XShT2yXig2r0W1eN0vx54fRUZtnbxgvnT3OZzGmn9NS7lnFfA5wcMiCmF1xpJROe", - "UQEvTVNxib7Tg9z7zPx/nqSHj78Vf/qqPumEGxgrT1MYfsfRnhk5mwnzQi8WXKU3OGhPuZIOqWcc2hw6", - "anTMuJkVCzpby7lJlRfuqKm4VBsm22e5VIoc+ubO5fbo4GAm3byYDBO9OCAHo+BfdLDWzsEk05OD0JiY", - "fPWnx+nj9Jtv//x1+uSb9Ktvv07/9OdJ+ufpn/mTJxOOLvsH3m13FNoYwrdDdkxmCT83khjSsoTWkM05", - "vb44fE5g2jAjUp6guicSidwhFcvkJI4yN/p6eQDUl3LHD5I0H5VLt+SLrOlE8hs9Qr1ylOiiSRMnNxcY", - "oy9Oaqh/LvAjDvR3hhzsRYNKAxWilED7fnCWrJ0KFT3SN9h4OJ2VHT6y7D9O378bfDh5wWTqXxbK4SQc", - "XuHYPzWuH0kWf/xXvalLWwccF/i2QcYY74AhWJJJ+IxfKq38ud5BH060UiJp9Y98HY5TWkZwfsIdZGW9", - "2oRIl0mZVv3qeZvmI18h+Cuk+SiVNnw5ZGdX2k/Cojt5cOFDF5KwDLA9DiQnRy8TlP/S0lwrsQePn/y5", - "QSIQ8WxQJiY8uRAqZUqnNU8ef05iff8KBHTvebqdRNA/b1OHWKDS05C9yCS+KjrNHj/5c+mFa58xzjKt", - "ZsKUzrqoQjMjeFZto9tiLISb67R6EVqVUY1SdeEl/m5uWysnxrrz1k9hUWlBj0BDM+mYoQM1MfMYeTbw", - "qZuLhRXZZSvLwmWXwloaNwDo2P9e3ekqJeMeU9+4ITUXZ0+Q/t3VV7Eb9q/TtqxoTn6PKpS7SX1K8/AX", - "2iZf6it8Q72T4863PExqTW859NoqPRx9uxx9YXQYb3ftNsovKsp80c8jWB7OxS/tXEw9Z45mxQbiWj8P", - "Q73ySIyvIp/1IGuWO43H2e/niKhvYrdzItNW3O3xAC12PRWo7MNhsMth8CBcvzThukE8AQP8rqVSJyl0", - "KtwLghKwp/KXu5VHtt52R8m0VutBRj3IqN+zjJoLCE9tkDWeCxgVAOp4+fqkzdrRLulWGOp3IvP6vSuZ", - "Nr2txGXD37es2pVUqb5qnLZfPkZF1jTjLZG4UTMse+gqj3/CGt/pQqX2ruVxte3u8rhe60EeP8jjP6I8", - "Ji7oJo0zMW1v4Zrl2iIfQysEpcISrU0qFXfC3kjEV3n0dyPinc5bV3F5w1VsOTZ8q5/20IhtoTPITSz7", - "NOxTrN5g2KdhYOsBl0KkbG9MT/GAk7GQSi7gnMAP/Lr8MC2yjJYV3Y+9vcjHQKGkLX1cEIgKjUktL+a3", - "Ph/9SdjqBhhIMKAYRUFTE3k6xA4Bxf8kJqcafQdQVB3R0cdmwrrCCNsPDsUIR5JKnukZ4Y5INesjXgCz", - "IvPCDfqqoCINGcDIyVlwTQ88geVgAC/fvz3wGBrMGT4Ff4k41kxODEf3JVuIiFEV/aMnYs6zafRPD0s+", - "PFfvlaj4cLWtiQ8ZpzCYyvFBbzyhlHVG8EUwEFoMI0v7LNE8EzYJZ6Z3rcIYeupZWpahW47KluXBQxsO", - "PwbfFRTLIhMLDLFPqsvVL+uV52M8a0v3/0SnBGGBxZOMWwuOJ37JuYJSF0LkrMgB+SvJCos4IrBy+IyN", - "riirp8wwjmoUxjp+Fk5ct7lCajAu8VOjWK0wyIPDabvDKaoYuFSfwM20YVsaEYYCz9V9SMuhBs9RkENQ", - "d4FnHLLQmDhrPGTHPJkH/yl0YZMoOzJy0yrZh+e50ZdeSSR/N+rlqHzfxS+LLGXoKcWZFYkRjv2///N/", - "GUw2JdQ3vYhnMDx59cFVzvaZEVNhjDC278FVbJ85scjRF9RLzpy7OUzH8BlLwpUNGo2+Sn4s0KV3xcp4", - "QnPmLEO9oc848TH8QR6oCQSi8lkfw1JUsUDnTBgXQ3IX2MdcW48BVFlOAtZc8DwHUgCwy9Un+c7v7A2+", - "Tv22h5GtjW59V+6vGDU7t7j6AtFvtRl0bXKDObHfqq3u0Hjb3bjfe/n+7XCqk6JDcy/14hWUXG/AJkZn", - "2Wvl9N+kuHo9fYdxxJ1aPG2s2tCFcK9kJl6DqgF/dBvv6WqtesP4fSAsw2czpOBt7WKtF7VKTc2m0uZw", - "Q4MyXv3q1PLL1XqbGv9BLG/Sdqi2qem3urDiJo2XFTc1f6aLZH6T5suKTc2LRQHiEgu9Mnqx8yyOWxto", - "6k4uBPJuFOgde3m9Wq+xcWWFcWfiuuvYX8cKTc3ZpXJzAYrFiVTJ/K+kr3ds+rSx8uZuiLdv2k+t9uaO", - "znh+017KqvUuTvhMDCeg3ZzpV0Z3IR+o8l2lRkOD3terhFzs1uqL1WobmlY8371hX6mp2W5HIza2fi5i", - "E4Q5WULpvcQrYbc2v2+s29BJCGLt1uw7X3pDQ2f6e2mdNstj5cxyt2brdRs6yY1U7kyfvHzVreETXz6d", - "NjRGIGbdGvog1rUgbASUCzF5I6ciWSaZIMtIpyZPG2o2deC4cUTBCbcd6fO0XqmxWZ2/0TztdHJTk7FC", - "S3O7D7Jap97oGTcQjc0TJy+BMPDj9map3PNarcaGkT13a/VFWaW5SSO4E6EWOeV1bruh7oZOdhx4pU5j", - "o6BaaHvDob9sqtzYjc6FCk8xXVt/X6lTbfRjNHYsCYE0WPgAAliJnWyaHZSwj/0bNdakLu7YVLNqsmsj", - "m7SmG86tWZ28YWONOvuObbXfLHZsqJsmu2Oj2/XAGzfYqvDduMVm5a57c9tukDu1tHZ33m0cW+/J3Zvb", - "pKju1spGxfRmTTWoors1tF1l3K29Jl3xZi20q4W7tbeuxO1Wv1mb3K2NDZrZrg3p/K7aadDrdiTC1SvM", - "jmPYogp3b22bArhrSy1K387NtKhgN2unXdfatb2tytuuDbbra13b2Wp+3r2pmxPndkvwTdpqM1l3b2uD", - "4f/jz03vQW+jL8e2h2x4qfaPp/7t/Xrpn3wtPdha4UKEe+XF1DKuGJ8J1ZQfCFEZnq0+ur58/xafR8K7", - "9ETrC3g+xfdu+IHct8oA/x9fV3ozCJZtZSrQ86j0KKtkqTrqHGPeasNttRw3WBvbrZsbrLjtdu8WQ3sH", - "k+0W0+U2k+NGS2Hbu0L1TWTj80aTkbDVztdipdtsIlu1bW02UdXNQeuWphZDTLPlo8G8UrMIbjIbtZk9", - "Gq0WzSaBzdaILTf+5pt660vi6jtg+4tb+0Nfv1sgclWeoQtEm1+OYuLa5zT0vi2EpEJZ7IRhpy9/qGYa", - "67OTIs+FE8LsB9/B0uOxwWuHnGOkZX97O+zqceEdEu/E6aKc/YPTxRanC1yq+wRsbdiPGyDeR/po8sbw", - "vqntycS6e8lK2+gmW/GHha0e15ocB1+wJucQctsoPWvxGL5vf9mPG/fjZfSR6i4gSr8qkRIuTQfWZydc", - "mhJrSi4WIpXciQzTqCQiXfcv1qpcCPJ1+wwCZGWBHmTIRhlSksb9ipGmXdldkpSjXZck5W8PwuQuUhKW", - "E+uUlXAhrOUzsR3LiG5fWNgyIzK+FGlIxrTer0cLTKWh75qTmxnBbVOCr5/my9U2MQ8E5B7CRR9R1PZR", - "NZIDb1bIt/SltoDtXOQk0SBBi5ohdDLe3WSxQCdWwkBEhGTv9h/8komCHCEYXqkYiEK9kU+gEYGu+YxL", - "ZSkGRYkrFvqtDkEYo834KP6GrtRMm7CuLC8WOUFI01w91EaEM/ATDnkV/e91yAO255a5Twrtk0XaeeFg", - "Cvsr4GWVpez1e6srVf0Kx9Tr99ZG1Cj415yAN9GVLfKAotfspO0Z8EpQ0sIrbtJSD/Z12KRwAXzH+z6L", - "tF9L9fGvQhSUHwPc+ZkuS3ov6ZwrmVyINARMSZUYsfB+3B4VAt25/bjQH7NQ5fjhu+jSTYYKMgZMZeYw", - "a+KEADF5upAlrflhA/8xp2F6JMWcdjwbsrOwmNA5ebE+84l0qhEpIbEI8WV9dYbseXbFlzEXDQoxTNMZ", - "HOBhBky6Z4TeWS2QG5HymMcST0nwSZfJPPjDR7HHLftFGN0W4LHuS76JLMqdjgxXpQaPt5kypZuEdnXn", - "pam43HtcQ/RcJzIbJmk+DCMa+W0br0YtVFOnwT5gXJpE0gju8yTkUU0bt7nBb4mVrMr8VdEcpeWWA7vh", - "WerG8ZLRbLIlQrJS7iEmcidQJUJ6Gymdii6IcGCXXEWFq8amObSSPIAF/p5xO0pbZtPZu42SbktBJHM2", - "9RBs5kYstBOMKmzt7tMBNf0xUE06ORjc6mBotqF3OCnaKj4cHQ9Hx8PRcd9HR8vT18NZcpOzxMD422AS", - "vsfvg10GitaGSxtBZ0ideFNdTBAefc1ag/21xu2nJZb+3fV2vd7TfzI9nVrRaWp9vJNi5jLP7UAxuw1h", - "uT6E//p0Q/jj6AubHCNvpyqsttxFS1iv86AgPCgIDwrCXQLRZx0M/1DKItxHuSHIqEP2Ksav75CwoEUt", - "WWX3B43kD327rVHnlqMruKU1p+yBnwMUzJxbUT1wOuZ8Cfg9zDqYMS4G9/sVPP3QLG2FQ4kW8Ws89Epe", - "OHRCNBPpEM+GJh+T+IRn99r7TArzUk6YXh//fn/p/9S5/4ZcUTsmy4F1eCsX4kXlJX9FSuvc7+3b12+P", - "WXgrBiHACZ9COrHol64Ir5+/e86MmEkL7xNVG3kVHOlZtfYjCwmjYJg+6Qk9K2SU7DxidMS+K0BKn2kb", - "vAMavof0+j1epFL3+j3I8AT/5Xme+SckPF/QVL/QKe7LosicBMlcmvM77pb3aSRnhmbCRlnJ6BmfcVa6", - "RKYBuYl5R0z75dC8mPIig+Vy4DyKS1nYrou2Jdrqxjpsk7PrFhW2ucqDBvuAGPnHMjk18cEfGGx8e2zp", - "LYXUmq9+JznVUOtBVD2Iqt91thnDZ6NdbsA+Nz/UC16MN7wBY9egDG/vGkq1dP3aiUUFMG633hdyIUZe", - "yfYkvHJrktZJlTjmGi8FQAF6Wo6KxkkRDWPQmAE3FVVm+KOiIwOC6ildAKyHzmufwW2xVvs9HNcOTsir", - "d6TSqZsbw5dx/YD3cT52tOD2Yn39vpPO+xTD7SnL9JVIaanKqmzv8V8SnS/77MlfMqku+uzxN39Z6Eux", - "37Z3eI2N+ZB3hcitX5TXQXJXb8pHbBzvoOM+fXh/Gf7WOeXFKy+i49uD47arEOtBaC15AVE3sFt2ZA7/", - "DYXZhVjiZjzPHOzFC2eyPnv6l7fC8T77819O53LqWvfkS4STbnjUgddA2BN2XcGOBsnz4vSU5fJaZLbz", - "k8lyQ/PL2zbfZi+q8MYOOlgTEModqWCh6Z00sLLSgwK2U2bewumREbngTXDzc+FNUwEUGrhuJpQwATz2", - "QmAsseCuxueVKI+g4m09swWQjppFdg3HIkFkP8+y8b4HpY2Zw3FQDw8rvxfd8nbHdBABLaf0D2K5ckhf", - "iCWEvsKxfCGWP+bwh+FXP/iv8ZSGI+JOzmdpRxdimfN0M5sBP8kI2K6KhTAyYVSzjcOkHdmlBb34Qiy7", - "cDE65lMV7HCdjSqtZ9pbadca/kEsJ5qblIUioAtkYorKgA/G/eovqljkPN3v/qzVEp3/G1FbFF+ItHmh", - "gcKqaNjEkDmfibqNf5lHe64M4czjqC2e8Qn857kx+iqQ56uvQf//AcZddeNnvFRhGu4BADmvraiB1U+W", - "dM8YEf513b/+C8/1UU5r0zFTtlsbsi0mC+mczy3PKAGvsyKb4tNihyvi3SpYzRhld6RilY3vpGRVqz2o", - "WTs5lRTOaXWTUw3X/Duqvn6o0Q/4JBiVojA3SNKi0I4AMnmMqVrSNMNvUDrDH+DFAv/1cUN3kail72e7", - "TSj7UiScIc5uyN5pNYBYKKYV42yMb1hv9SV4OS8EV8SxcNOnI8wbdty8VQXMZHKxXfPEcGPS5mg9MTIw", - "w7A2tvfEd4b3Kvp6/0Hn/N3YM0XmeJO35vfayF+0cjzzTpEMi/YpBBtJ86e5AOtN1+s9ddV0yQdBkdxd", - "R7fTo0sp36JJY4EVXRqHeUIH/rjvP38QmeDVLzwvr87rDkTOVHu4gxUeh8XK8AjMYXCFEX12iCpG59Xc", - "pqGW6/Vb0VFzDR/MjSnghOq3bL//lTTR0hhQXi/2aHNpn/O7yf71haqkXM1gNDwbBfLbSKNl+Qq5Dh7v", - "Rq9OZo3u5ydCMfit9EP6r8HfWZ5xJfqkzs2MEHa3fpZd+vnP2/VzJa1r7gahHK6kFcxo5zHoVntYZ48H", - "K+5myOc7umSUje90yahWe7hkPDymPxg8WwFaI6e0nNRYYEVRQ/9AxCwe9/2nY5XGv0FDo4MbP97hA2V3", - "DS28kE+lsY7hOBiqNHeuupUr+FtR3QxPZWG33EeoUOsydV4e39mmG8mddeXP5xFXs6yBDD743zfs/Q1U", - "hz+ozrhhEe9KmTwDBa+tm/vWMDt2fku1E5ocYZPbLUiI7yqqw7Arhyq+W7ZxfYuK+2JNvd2BPW6h97Zy", - "O6MTpSxqWQbzlgr92unMwPuhHXvFQlo4FujYkAtuln6Xqi8iPKyTZ6ag6ty9yn1LOdZB+24inA4aebcU", - "JbfUzNvxpTtp6JuqP2jqv/HngLtQ4e7AnP5gOP+jGs7vyUz+mzWKs4mARfdCE7kJT4b7dPZsl9APXp8P", - "Xp83txduTDd3S6VkLbVGJ12kodaDCvJgLPwjBgmusUKjrDciz3iCwLwjoRpW6kNZgBmuZoIJlXq4oFZr", - "VaVR67hxXZrFglsaJp9f2NTGsZ6GnytjROx+GXczLMb2HloGXvZRHfDOvfwR/Oga1uOuneiqg+pyYDUm", - "Wb3tSRUb7XZEVYo/nE0PZ9Mf8myKPPA7CV6/mXiERbgHz+IdheL2jMW3FJDNyek6Ccu2qg+C80Fw/p4F", - "p0ccGhEc0Y3NU+uwR+sWqhruEc5iI/LR/Vmpmnm95dZCCKQjmwvReGmh35l3eWRYDh/DyEzCcvgSE/m0", - "6ugJz8RoyhOnzYYesFh4QMph4GzvvDg8/Eo8Zr9ojXAD+7/rl+nfnx1sp0OzNSv/nZ2atR52PDZX6j6c", - "mw/n5sO5+Xs9N2vM3nhw5oYs/NMMvmiNCcaf8TSxRZ7TcdIWCExh/h18YaIs9MgA0X2M3u02GBOh/VRk", - "fNmYve8l/MImwl0JoULb/bV0fb8jU1yL1nN6JXNBqs5Oms49H+DXIAQcV4no9Cjsy9Y7e8bIhHgZqMUy", - "iF7cYQyYxx6rNiSLLUlzXg4ojiSC3+fcpyQUKu3c9b3qL/3ecsPqrr2Md13bIt+h/44rexkGcyfregeK", - "W5nq/l60trL5HVW2asUHfe1BX/tdewv5FI0Np7r/JR7s6CWDqWNhsPipyDsf839sxbAUKb8fezvPO7sc", - "auZ4vhqx73i+/8cJBdx8MtYwkhoBbL5ExH8P5NTr9xDHqdfvlTBOvX4PSK4jEnrVvXZtefBHNlnxseWl", - "h+0XslxKKyAn0KuBAREUBNYM03H1MQEO0d8VN+kuC7eBtNbcI7+Y1aoiGwRc/QBsED4jrkH4gKAGHZft", - "hM/Ed/D1mX5l9B05+0Ojw0ml1S16aUP5B3X0QR39Y/krrDHBHxhtH9biBXkknCZGCGXn+g5FU7LadBf5", - "1FDpQUjtJKRoAUcTsdQqHV16PXQzXqSvxMS1EyqtWnBC/VbY10zmrSk+gaQxAZJWjMrcUMHGXvBldnMn", - "CMKI5Rg99O7WQ0vq0GoPWOQ2s7je3P51cEC9RRfLzV0sb9nFwyn4pSUy9Iuxu3mkFMOvqI0G68gCeI66", - "YHAECQsybW/8z1zMAG8iVzNCmrgSk/xuMKLgBjGyhZnyRHQTbHAiO34hVBk27uuv5WUDidcm7Vr0ibVD", - "q1Gp0LmTC/mLGE21aXN0CWMXKtEpUMKUX2ojUv8KBKZ5BgagtgH+q+CZdE0CQC/w3Q/I1hcKMBuHh4RB", - "l2lrl34nf0fPa7fVjBTP70cv8g3vohXFKg860cPF7eHIajyyPI+0HlihQNOZtZi7RXY3Z9SWo8IP4o9+", - "+8y0FXcoWaG5TvKUCj5I0Qcp+gc0fyH1/8Elz/dcpZn4D37JT3GOLyXP9OzuRNG8sf0usqmt5oOw2kVY", - "8SQR+RarV4orS1SLxWlAqbQLuclD8kEQ/k4EYTOrtTja6kXuRrtHBQrlhEEHTqcZZ9SOJ70bRwr+fiR1", - "P3DqdpH9jl/KGXd3qC8q32IXsVyWfRDED1rj7/rubfhCNE7yfc7/VQiGBSqSZYNkeMY4y7SaCeMv1JJu", - "0EB5PKu2cStBHpizJbhwKowBBtGZTJY3MSp88E2cUAvrRoVQgFEf9wbNV87FCKDhLdbvOiwprjrVp5Mn", - "fOp2+lQ0oC/SwdBwRaglN0fijk20uIr6IwqmbgS3WpVbGWiBZ5kwIRscpDVGTO5lTulTjMg0v6P0TIXJ", - "RjiHhjeSU/w+5qgW1klF4/7xw5swOjy/YFR8ogvEEQe5P94PxGMjOi9UaiGeyr589eTOrm9BFzjT30vr", - "tFkeK2eWd68Z1NvfRU9YrfmgNTxoDb/rHAdA5o2T9HzAsERtOoFX8AzonDh0A5v9ro1alTXeLiBPjFTu", - "TJ+k07sTirlv8+WrLoKwWvpB+D0Iv9912JO0OYQzzwVPhRlNtXbCtOvmnFFBHC8VZlfCwPaoVGzQu6ns", - "yIlFnnEntt8CeGg+VIlB4Jkskar8T7veAkJSuFGqEyTpkS5cJpXYNJ5QlvmyOCCxmIg07dCT47OZSEd5", - "Ot3UB5ViezxJhLVykol9dvLyFXYVn3vb+vJ7uMsa+928jzXO4DxJeL7FzwkdH6HbjMsUlhYFUajb1viC", - "m5lUo4l2Ti/WO/gOv2dUiuH/k/kOqTV88xiAstb4GzF1t27aNPudfoCvb92403mD/NX5LRpu1mXKk7LZ", - "9MxnYoSYqrYLMfpE5Gq2QoctNJDzXJhWD94T+LXiu7vjhKnxFrdaajs61O7aNBovRom1I1wg8IrbzCPo", - "6wqLA0VxbXJvAPGOdcRI+RYXO9ytEURPzYwu1AYnvrIMmxmez2ViScxjE+1b0uLofMJn4YQgH+ffd34k", - "w5WFHV7o9GbZTdPpmW/jrU6brDXf6yucZ3k0eE1ob/wB/3xuv+NWfPOU/FfDd6cYPXYXNpqbWj8+oJXo", - "7hR7b3XqoNSHkg8K/YNC/3tW6OVMaSNGCU/mW04V4gg2WeacxCNMEKq1anQa9csN7ytRRaaiv6mXFppu", - "s50FZ3IjSHGpQNCJlFGFB+fzU+F+EpM3ciqSZZKJU3en7962ofUu0r+53sNZ8HAW/AGdh5qY4XeDxmJx", - "NjfQuteXZF3vjgUYdsM43VDZ3nhq9C9CkbpNuTbvT80Ok+wgjB03joK7Em7vMBLI1hvuJIJXqzxI3wfp", - "+zvPnW6WI+XmI3Q7Wp/rK/gaOswzD/IizCVvhR+9bTAscF1rbBGNpS0YFsUahMPeTYARv241273l13JR", - "LLynVmm+q4Z6Nzy18us2W129wWiz29Jey8FZF2GNZ+bN4lgf7g2nTudvNE+lmt3lMRUb7XZEVYo/HE8P", - "x9Mf8XJQ8sAfPNAKJNL96M7VdrvKpQfN+UE0PYimfIv29QeRTisPhA1g9leMs+B7kuI7oSyfCb8YaMv6", - "Y2av36u/ZHbFsKTUS824n/5HGny5YlyRCCZE0C8LCxQkoFAdF2clQKQhvVRLfAgPTrCYTfWLQZYN8+n1", - "Kx9+mgsFWLwzw1NYPm3kTKr4B/z8wmhr34fvQdaVH5yRiWv8uF6zUJZPxY+mKwDr2t29xYywdnWnBbWx", - "+hezR2BxABJWs52WqAKdcvRrN6iv6hJB9S9ziQCdrOtK1SFm1kmpeYXI98jX/XJkIUDidFyYM25mwj0H", - "wz245uOnO9H4qakhr7W8RedvqfOg9T9o/X8srb+REX5HeSNgOpvcaajE5/CiaU3oHMe8+YbiJWim7T0I", - "06RstpskrVV4EKMPYvQPKUYrXPAgQ78cGWoEdyJ8q5UT13crTBva7yhVG2s+iNcH8fp7D5jUVoy0GqXC", - "8WS+DchEEUqWZb5mWi53KibFbAZjDLKVmhS2O4z3BmZsgwO7Xo7I6XuUSes6RWbhZlElBpVQ2idaTeVs", - "UwwgdWaFuRSmez8rbWMYIv3iz5ffN9xLoeSlMJZnIyXclTYXI4oGHZExcnuuOSpn2cxwBRIrNsh8g4wa", - "pJUNpd1cLKzILoVFBukC5naTt4vqqXYPV4NKu7ucYg+Xg5ucXl1CCYGdvA6GfI3LnYbwibKFNg4OK+AF", - "6SZVzxctZe7niD55ONG/PPwXPskg7RAIV4KQAwoyOmun6u+gMD28+LJI3dRUyvbmgqeZsJZplS3320ER", - "ksJuZh0lrqrsgzU2oSyYkeOTzQgDk9BgNX+IN/Kvc2o72ECzA+dPUqX6quK5+fL1SZt341ymqVA7yw6q", - "1jaw5qB9P6xrn2GcBCC9/FTSnO7gENpwfDTqW0pcja6w8027AttMpbpBPXyRd3Wdt+7L8ob78iUgxfV7", - "La7Jfu7RJ3kDpxBtjG4e3IL128Ja/ECw9Zrzt4JzIoNVWUiFKYAQ62/Br8sP0yLLaMM+V2A5cd9Lul7d", - "n6Ukbeqgm5LZUvVB29xJ23zQBB80wc9jOm/k3985ZF8Du3URw+9zoYJUukvpqyvtdhO69RoPsvbBLv2H", - "lF1VNmhB6VIia1yeUI1hEQYtiXSDvLnrE/ThRfI39iKpi2R+fCmUa/alxt/JY5rlc27FF+Mr6GDkGC3f", - "69OHY5WGP9/qSxH+fsFVIjp7FdZR19dN9h1B17+YZQRUeC+HYfU8840m3MCnwunRROuLBTcX4bMtJhQd", - "DcSrCp5Vv4nu+KG00znyqxf+UHYhYcs8uE+/dyGWV9pU/hpVG+myaes4EM14dlkzFsQXs1eEWAEri3AV", - "XVenYkhYh92kYsGStWJP+IKCBMDqARQZjB4kWuPfpcmj06ppZXUmjo3RBoXn+sI9r95YoTATUJppwwqV", - "8AJMqWWyJyauE4FVQ3TK8UI6dNeG9XRXmqXSOqkShyqN1YVJhGVX0s1ZKqdTYWCJQB1kds5zYYfsQ6Gc", - "XIih7//5yesXIHpStue/GdKIQCDZfZYbnRbQJrJjHzNB9UFttX3UgKzjycXIGZ6Isu047LO50VeK7cW5", - "xV+qTVObmVSizxKdFQvV91MZFSZr6OeVFFnqz0dgxgSM8UHtpJqoY3HUAhrVXu7ETJtlVY3y82/c4dTf", - "bLoY4VapAG9FoOTgwDq2gjVPqQZCTcISuqZ83GemEEx62yfs9BRWh9KJh1osLXB9EFY0kwvp7LDR3Owa", - "XilwKAw21jq+yJlU7Eclr9lCJkZbkWhQp7pp6SGrycqSj5Dkej9v02OcDa32yx2MC7tJpWnck13Nq1gz", - "2AQ+9n9doSlgigaOz7LI6/E6xhItTEJ6IM3VDtkJuU3gSxLdiGhintvbGBeWXjqxwL7XtVT6ghvDl3RP", - "Av5qAq2A7xkBsoZHWyoAYzFk6C3lEZIXcnfnga9IhWEjhdCp33gJCKsIleho6DOeXfGlZec9pKDz3q1W", - "cW3xmoHC30glPv9ClQJyfYTwguEfM/zIpjLzB6ibG3FVH+MdDKwGyxUEdVeBybPsFGpBdeSt9TDXYsHV", - "wAieoqSnE8ofRbZmYQhEcqWLLGUe9B5NDa+0YbUjbm+fDrk+NjCVxrrSHlNhUO5ZlJpoOMr6/hFETOU1", - "HlY0voWwls9En+ED1Hnvx1ATxdARm2i9OO8xbaq/7UmFCRilFfsMLhO+8HV5IZwWCg0W573aI1KbzKwb", - "MINo/HlNOL7Rs85KS6Zn/vYXtYZMz/pxfaWa6vLTFTeqz4RLhvvDz3ASh4k9nMNbz+Hm1KJ3fArX9uO3", - "dQbvdJRuOKpalWxoo88iDq/RxWzOCjWVGaVgRXFLVughG6McGeMrqi4oBxGrqUzEhJZJZZ3g6TPGs4zh", - "PYWtnpgWVGXBDZsLI4bsVJAV1OYiwdsWysAiyxjQRKNguSfZ/goF7+r2rO/OcKuoCxaD7SKvRkWtt1uS", - "cOFpEZmuNNgEkbjQSjptmMbkuVkGqzoIpydtz5CtmJ/JDNcnqDK635Qh9kzkOkE3gau5TOZYgUaik6Qw", - "0RehTvjtGTFhl1fTYeINUarKYJr1n3YcaGi1HQS6z4ywwjGYDU/mldk19qP45ciKfzVgummlHVkSsiWT", - "KjGCW7jWV5bLgtlBJUEl61MxGJdI4wCczr0BuFKzcRE6SM8bWKsDh1E/lVeHxvXYYFoOtLlmW2Z71qFy", - "xOE0sJV52jBR9Anb39RjOBc6cDY9OlCSSXTPaVZDjcjEJVeObufSEik/Iyc0KAArU9kT4AX8jVinH6xK", - "ZVnv2exZa6tQqGxWdWHrUy5JcMPxVVUFdnvkPDH6UigORLoQjqN24HduCdRMjO7tIYYJb+SJnL+uNYlm", - "Te3ENzEAsS6nMqH6iOURHKHazqYxLm9VevkSfqmbCedCNvkEk6oSJjTEd7LxkT/YWHxtOgl+Q9SDt2qV", - "wnXIxhfCwKMVz+X4iP2AH9jzk9eMQg3YnhH4F70o0peDEtwljJyNxbUTCghhfFRCufvxxN8g3alOeAZv", - "tYmwdnzE7NI6sWD+C2YKpWDHOLzVeKtkOdyacTFJczROh/HDT6GjXr9X66hR0w2k0k5sDUrKNnoIpxkR", - "A0gr4oMDzycHdFS8flnb78ALK7yFm7+BY753Lv9ewNlg2yfhTLHGMN+fnZ34lFWWLXgOu3vFTYpuZAPp", - "KQVGD6JNF46RKVf+QocM+xuZnfGhdZn788NreWxSOLbgS3ix5mqJD9tQqp4OYW0yr5UThqPQfpHJ5GLr", - "ZamAfxIoGjQJ70vILiUviZAwN7CFbrcjWQ7ktjekxjk93JNa70mVpR/hzt7jbal9b+74zmRFJhKnG5IB", - "Qjqq8CvLuZsHGzvOXaRMZKhotagUswZDztnbN8zxGZ1IetrUGmxYkefCJNyGU+u7H8/O3r/rs+d99vL1", - "31p0mEZl/m8Ss+uhtYikn3ItHfeZM3KxaDEGXje1La5ybRy7HpQuzLXGYS6wih6FuJHIlhsaXt684RU6", - "vO5BT/1yt2mHNl6TKiT4g1huFXgXYjnR3KRfgrgL83kQdp2E3YVYfhpRV9uXOxZ0MIm1BfxBLP07c9Q+", - "f/B0TGtLAugYhthn3/HkwuY8EX3Gm6XQDaRpkHton5/zlIJ/Sqe4C7EMuQCtbZFO3aWtjyzaJG1fvzv5", - "8azPzo7/8+z5h+N2mbuqDopbCJjTxOgsOxXOZSLdKmoslmaWinuBE+5NfOrKIjHcxDqdW/C4UhCI3f9t", - "i6f11XgQVJ0EFe36yBPGp5FZLZt1x9ILxNPouin6Cen8ehApnTvv8cKNq7wDQqmZsED0XdQS7G/Z2t/y", - "rvvz9pgbyE/qa5s6qpsW75VUPGN2fQmnzvuYhhkEUdNlJnq03NLV8k66WqFlTyFx6/yk/YDWV3ijaH4j", - "LwWooS/IVNkqkTN5KdilFFfRIYsqlH7gcI+fFlmQ3Y8s+0lMPpy9iDacd+JC7w/Z974cPEI/w7fOINDB", - "thMDbeWCz4Tt/JDo7ay3lc1Ny/EgkltFMlDFCKgi+MvfoyRu3ZodjbRgJvOW+5wvMWUmEN54bS7jivF5", - "9Srd/jLwJjLK+vvAkJ3WjPdG+K6sd3bEVMPIXsH+PclkjnEXwCToCkiDIue/GHIwLoc03slY3mHBX8bA", - "h+7SoQyWiF6MO4iIEy7p7apxVybLtel+DhGxsiwPUqKDlCjJ4hMIiqYNunNZUYkKahUXaWHQXj1aNIFD", - "8CwbJJlOLlgoFy1AkWZhNxYyy2RlI3bKrb5JKj2j0Cf/aJ1oY4TNtUoxFqpNKu74Ilddgk1bpxMs9l2h", - "0mzX57fnDBgtE658tc98exT9jyoF0wafG8JPFuSJf0qSWh0x6RBOKXe2TLmACtxEX9I7kFYCSs11lto+", - "c0ZwLGuEFSoNmxfajyVZCPUzS/IFMAJmbzEi6EqYSl99hn7xpWt3bKxQqTCl2K9WQXn59PDbdforSzXE", - "MK2sxpA9d2yhrWNP/tfXXw0ek9NbBiqldcwzOeP4KEOk52cnrnnismWjiFhQzrbe0beHh396/O23T75+", - "+qenh99++9i75MNPjxvdRLmaFaAHNlwTYuzBdy9O2NM/gQHEVp+ZtRnG6rjez3FXB2/8l326yeDDLCwd", - "vtSJIb7fQQo/AUScisHLY6BflDjtTkMLqV7Tj48bPIiw5Q5ToILleYkE+8iCDYNPZCZhQ2sDjONbGxAI", - "8l90k1/r6+fvnrPwc815YVO3/Zgb1W80kPNMXgpVH9BxAaR38J0wmdzutVihzMqQ44pVCaCD1HgRz9kG", - "HSW5UPoqE+lMkFsYTDQ88zbGrUIBEgQiLQVJG4pBc1htaJhYpCoWHtmw20CacZrN53XAjfOvus2nt1lG", - "pTH6MgkVui05wa4yQnOfRqhUGGFaOwsFImG4uVgwp5l0luWR6+ATDEoYS5ZPboR65BiFKzG84xd1c2fT", - "KEa5wBOpKaGJLxIMq15KR5n5r0IU4NBV0I/QOS+pAUbYZxYCHblF0T6BwzjkREklBy9YlMfgDMActxd4", - "nCxx4ksmy7jmJQZDL3BFo2A7bFSRWtnzQLjkAEkDyqBJl7YwVMFVFfUtoIWtTqq2AnrivSeka1rmVcWr", - "5MNA3FVyaNqUBhLtwK8QddaElzUObIc+kbWZRPHEMm5d5M++jwFiEzHVRpSe3kM29uQZ28KDs1walYhG", - "WTAPoJVm4WnEd4F+l1fSiqOqU0i/vj8rnGj7TbtGruXMzbUVDFEgyRo0Li8Mw7W1brjvhFXoeoGpK1kf", - "+z2/RDeuXz0oRpfC2EZV42/0Q1CQwkLDwrhf8E5Tbaey1Zc8kyl3oqq08RmXyjbbAJPaObDDjCoHyMc+", - "xZo0gXwtm88GlsoUhQuIhT4JBen8t9v15cqoW1Z0A0u9JffUl5Vrd8tl/czjIlQREXRwkYLrZKaBbc7Q", - "yOrMMtgbvCdNajRGthfKySx4xY6iIUMETAXwhlUQATpDgFeYHLo2Uwwpoecm5OpTha2jswCtIbGKH4B1", - "Et55iAviCY2ussoFpQ+msxdkkUwz9MKeiVHGl7pw4b3Af1nWCT/seziwqTRi2Di7CH1lhHVe1CyG7Dla", - "d43gzvFkjg9unE2NsHM/4wVP5lJ567ltnGDClT8/qmJMwUG+4jmZcAMbs8jdsvpTOPZpb7QS5Erc0Yjq", - "Z3tb80gbJT7YR1rtI4HOqkaze7SPbNyhbVfuOh0RykGTTgbfRyYtJ4Z38QSFzQg4iBsn0ugxGt0vwy/D", - "qqPlSq3tK+RHt30pXivpXnGZbRWawXiSYNiZ0qBwMKmkk+CUSOP91Jy2MvgHPtvKZ7Bhoyku2f2zWdP2", - "7MZk1om8nSQJ9IVpU9KhD5hwIqeLAU3VO314tcsWZgpB9oiR0sHpAwexfbYfwlHZiZ0adZAabxkxEBjw", - "IO08unyI6zkvrCMH7ax8RaFHagfnoh2yd5pNC0OqxaoycwWqBCkqDG8V0gbe/hws3LRqD3y8lY/jxn8y", - "Zm7dqHs5NmuEDVMsQCstZ+35AA5Q4gOg8MAA7EoYwdAFrMij/7wtMFMARAAuvQoboMvqDFk9eRt6vMPD", - "94O49ZVlZVYNIoOv6iDHJAiC60FaxHWY8RwDCuge9GLt4mJEAKdZ0crDnd8ZnlxAa15V8fcAb16VluVa", - "KvdZ5cyDjNlZxnxS8XIb0RJ4teurIyzf6vsic/xCIJfF9ioOTHVW6rK+a7KhaZDb16dMDNzqiZALI3Uq", - "k0oW4FWD06X3uu/GgWU7d8SEK5N44MGtPLhxC+6YBZt2ZzcOzJseKSjh/UCoRKciZSfv/tqRQOOyTZZO", - "bNXSoe8Nc3xHJ9TrNBNbXa/DaSbTEBq64njN2deHhwvL/lVI4Tzf0Uuq0kyqwTTDjBEY4+ejeztaonzX", - "t+W3FUfbBw5b57CqpfQeecvT3RvNwXa78Wq4ToAZ1Qq3WI+Q93rqVWQkLFxtnhnB0yWsj6c9NMGD5khm", - "WbgDK81yI8GHJ8zdNzHGNqquqNLt99m4MJgvIQAvwN8RL2FMzzpjIzxMEyzAuIJJ94yNG4gRn6JybuC2", - "ni1ZrvMiK5MocccSbkVXOLs7YpbWLXo4n7Zyj6fQ+7+Fbt6kOw5ESBAZd9ueVRkw1FjFTtFmNd5mfevw", - "sW3UHNvpp+3xtiq/eZOWEu7o6PjDh9GL9+/eHb84e/3+3ejD8asfT49fNgdv+UG3InuESVWcYyI6uIsp", - "9jhaoFbESKt3HPRakRLNHfuZDj/4ooC7UTEHYA9ruELVUHkPKfSD0lcqgLJKlWRFKthLj+PSZ6+ES+Z9", - "9p/ff+gzgiDts1O3zISdC+H67PUC/aPeilTyPnuloc6ZuHZncLPtswp398GD9xT8JVyfveVKTnGEJ0ZM", - "qY/3bi4MicmFNmK7obGyNzWq6JcEuTGgwS/hB2qm8ykTtg+f+FvQOO5f/FZH/SB4twpev2n3L3HX9uWO", - "ZW2AWNqK8xgKkp5AFv+AIeNXo1H2zCvwHLuMuwrtsZ5nyi9LgPDoM6GMRD0L7wFX0ojwG+li/JLLDCMg", - "/At3XkwyGVzrPvZ7fkbA9K1C8nUoM4QyTKoUW0CAHVSeCivSO5GY1svGnBt08ckJlpzEGfoBNS62tCMj", - "UmmAlDbwnbTlQWOrqTT0FB2FqYXhlrzBDYgq9CMDwyihfWLjuBt0YP71+KzPTt6fnjUfj7m2bhSEV/OO", - "T3S6xIMJWjk4+fEsXvH6MLm4zy0HIU2tmdrf0+GaIRRUxREi1MJtKNOJVBYbl9EU4o7O/D4rlIQEDxUA", - "scoj0cP5fvvzPWasqAnAUlytCYRuR7/NtbJih7OfKjAjEoH5YPwl85U00dzh+ZMKIvnDpvgXB6qGbvsk", - "5yK1Mp5ecoXw57r056mI6k+vYlRW50HH6KBj0Hp9CiVjdWfuWMsAqm3cJL8TNfIuxSyiRU89EjN7+/rt", - "MSGNNgpBqDpq8Zz8UGMfI5yR4pJnDC91iUYrD1atJfZZedzDSsI7PDihyCqbLcGbFsRgCq3LltHdlxrk", - "5+WbH3Y9ofW0ep3MNmpwC7loO1niloQG40bScQ/7djB3i6wf8ihARUxbtvl+fD/L9ZM0pd2gWT3s+0MN", - "KCKU8MEDlLCLZPLq3RvRUwr/8jt8uOn/xjQBRBZu9Pg/nk4FZq0JzwWefql8LYsSTbxKIE8OD30imYSM", - "vJXzPLiO+xsJJy34q8OnLWj72F+LGapxaBWUxfc/9Nk77dgrXai0mbGg91HbImD7ccZeE6kq76s8EoJW", - "vjp86hegOuHVxbjCMAMRV9r3JC0s4JC9DI7NCJ1DKvdCcIyJ0NNQOnhdU9sgx4ddnnubVD6/DKVQ3qjb", - "QYqmF4YDY7e//VLYWoyvCO6kCdVje1yx897zqz47VTz/b+e94FSzD9CsWQ3kM1aWzooM578EuQPxsEP2", - "IRCk357Qgx+BvyX0K0H69A1yR8T0tVB9TPw/DDCgY0ir5CGLfJ6GMLQxND9mQbdgMiao7/pYAA3cVo9c", - "3YkHHbJVh8QoA08b96g/Nu7Ibo/WG6CoS/DY6ikZQtQrhP9pEaehd+gVKUGrEG7Tzv7br6btsNEwii0b", - "8FIvXhDsJDzPdHjffPn+ba1CyLQB6w0NDtPYIraFl9GOmTXuis8bJ/XA8JsZPtWLkUcgxafBe+f99l26", - "6yfBNB/FdWuQFOSRuQho/owczHyiU8X82jLuPBT6GgtMYT36zIiMo47i9Np5TC6Ve0o72jVMo7A/ZD9a", - "wcbOErz5Vd29rQEuY2X96zPbqom8wXCyriiGFHzWgmL42C+Lv9KgSAOqqbjSOGEuBSpioaW5nKKltTR9", - "X0pb8AxWB8MGl0N2zJN5rQJ5rpKl+fHA9wqTNp9OqDz45HSTIfV4xXuWH56agUa20nJSLArPnDXa2nvx", - "5nTfk3YEkjgRBhdAJYKdyYXIpBIA6/9pD7HV6T2cX91oDxbsE1PevbytFm3YNy9X8JZqBC2UM8s1v+g9", - "n4mQLA7VCpblwmCepf1GdKbqqo5S4bjM7O5wVIGdKgvHuHNGTgon7BbOwymt896cp+DmDuqKVHnhNpN0", - "bZE8XHEiUjLOYC4EbCQ8mqGPaN8bZ+Ggkl4+vHhz2kzyqC40IFhV+7WJNsFcJq3fK8hRRysRIkTenO43", - "H/1rNOntdTumVwpQy/h9mRWytkQxm1MbSs96X42bV/J7E7VuxwdbjedbmbAfS4nU1UEJSvKtx8UbDxzl", - "1TwA/zvhEq45b16c/FbPiyQvhdHDOdF+TiT5fR8P1Z2442MhS/IbimFP0yVJE0XfVgx7VONG6SPTsvnA", - "/29enJQZLeQ0PNe1ZngbNQsbuHkhkTS02wl2UOm0XWS+fP+WQYEGqVnpp9kYT4aclmET6lPXgT/zBzYQ", - "vh3Qo45HGI6hkWdyIdVs8DzL9NWAnFAa5wu82J5/hBvBWwZEAM/M/qvg9fOgbHub+1e1RZhPQDRklzIV", - "OvzUki7tfg+96tBAhtHu3cO5hx01KWc3PvS2n3Sab7/llzf3VUNeFqp/DhNeHPvDcbblONP83i/atb34", - "jRvn3LxGzl+Kae5dDMruxrHVFKMELLPGvygvfLvAv+wFN0YKTL4ZQZeQ3C2TCqXWBHPVOebzTfr85SEv", - "ZtUSt5oR9tNKh5XVepARm2VEuVn3LCma9mW3F72bneoqUDmV2DVd8DtxxTanDGbcWjkrMVal3ZY1OOcG", - "1OL2+ZxggfUpkfPYhL4vO7HPApIjjqAhY3Cz79ju6YDvLOnvp31ZLWnA6TtLvEt+vRXNq6Sizqyw+b3l", - "2D+o4ENwy0NczDu8YmAn1NiJdnM656Inlq3TTu3JJb5AS8sqzdNLDOYhRQ949lqlIhcq9RkJqzG3zxhn", - "VqpZJiKwYfAui0CDCEfLpPuUPh4PzzS7ngef6KnmjE/e50JteHRU4ioqOI5P0GOL5Aksq8bKpNuQOBiG", - "2OgzTV8g7SNdUz3IqwwXFxuCMXgNCk/aMro6urhfxdz3VteSdWyLpPb6Uj2GuqI4Ra5A8gO9sim+GmB7", - "lC0WwlhmBIWPr+hpiDweEgbPEXLMGcEdwv9bYMtcJJJnO8Vi35VWVt/lB6VsMxM6PhkRXX9S5ruBToaj", - "bNaczto8rICH0fXZsy4yg1aC4qzUclclo9mdK5x3Slxly9gVn9yL5uGka0qHQHF9mZc9UCZqpeKqdTCN", - "akxoqmI6a2/jzrzAMu6Ahp/nElLtt0poEDq0pQuu0ARZ9Tv929saIHJq5GVQNiLU+JyrtBJnT8nnB2TP", - "HPBc+nxKR8yIBNMKz1gmpyJZJpnos6nMhM93j+qQv73TYHyC5AiYCCXC0BAOfebfhxAD36LBE/OFZEuW", - "+wUYSJUWSUSczI2GLpnll6LPjMgzvgxpOfdrk+UzBE5OSAnvKnR9r7cWvA3b9yB620WvX64Rz+UISPo+", - "hW/b1uyezgmZr5bLaW0iMZETe+t9stER+4jxSOHEw0kwA2m4Z/rrh79woObj0DouscQ40akY+x3mtvwN", - "fMBj101Ef9P0USQlTKdHHOiPOmk6M95ifqiUGV048G+PpfuYnyLMx4sd/A4d5+MQSBCMT0jUHF+LBLQ/", - "xJ79EETUeHesDtjQhgie+Py2LhhD6YVM00xc8R3jVBpDQGBjd42CqK13JRaiIx7eidHXy2NjtNlg5OQq", - "FSjer5eDjC+FCeEOZT6QOlDLkNXu0A4jQJzRTBCI/1xbN8D2aKct47EbwmYhh2wMNImrFLgEIxj+c/AD", - "7QnOYIBTGPsQryOEFHtC94/1UVufFevp4Vfl+PzV4pGNwby5zmSypFszdZoK66Tyh9YbfTW41FmxEBFJ", - "X+JEYKlT2kv22tlgGEe3nkE1fAM+g14RHmSlR2z1ZUKgmgej8uecV0FoiNYZwRdHNMk4PTxJMeKDtgdh", - "EsrgD0y4FbOKZD4/rrQhcYkXOBIjerhiOncDqZgRU6noVS4EB/Kr2BAJuvoZzFIx5UXmBjDfTFCGLLDZ", - "8ewTY1KtUPnDYdx+GMNK+bDbezyGG/bjrh+xdNr0MFyRBiRooNzRJpFi6jG51dz/jUKrLhBbxN6Q/Y0C", - "LRcSayLeCJTHX9Gl2x5V5c3I55Lq177EY3RUqEooXzAKkvQapUJJqJUbDS/7ZjTJeHKRSetq3xbKCJ7M", - "qYn4LeUVFAhHIGdSjVxm8QVNFy5+F9ZnJFXImtinadQHZgRQETTXNOwiJ1lWNh+/SZUdedFW+bYO2D1k", - "z+v7Q/ILnRoqiVYSPVPAcLISCcotKxTku6pG2dXaAuHHIW1l6u03gVka9qfX723coEqCq9oOkTRc26Lq", - "15U9qn4dNgl0gbVdKr9s2CZqpb5PmJSrfaPg7rqyU9WvKltV/bq+V/ALLfi6hOn3rgewuoNLblD5g2V+", - "WS7od3GVK19+gFH+WBukD4o+wSV+GVb4xK/Zd7UFDt/+WFvf8O2HcnnJlecss2dx5vRVCNt/XV1aFCL1", - "UX2IK9sw5B/9apWNh29eKvsqLmr48kUVPj50hyLrx7C4u2EH0OaUEeOoGWFLzdq054iGfP9cSQc5TDYr", - "acRcK+AQ2GmCbl6RLVHVEibhmM8pmXPDEyeMZbpwVqaC/YMPfjkcfDv6mUwCSYjRHvUZ9ylIv3laqUhM", - "vODXb4SauXnv6Jun8DjonDAw/v8V2/v3f7tvzL9NOA13Fvu/ZSd3uqJEgOG1c2/v68MnqFjfRq3e3/X6", - "gyQY57DRp+ODyDPvatmSvVakiEhu5AKGg7nJ/C1YXIuEFHRduLxwDBO4wmArFQipZMHz3KeXxPNnixoD", - "o0LshDC0fo9AA7bWAnSFUOljVKaX7/gC+nTeRKqV6K5TrTfbuVptDqvLXvtxN0s3KNCjyTdP4e8tENYr", - "0CYVjsaNOGiqsar/0pZt13xJ6S3765cD3aD3wlp44LMdLU6+FnPa06LwYpLYzLfPPhyfvFm/WDWK6f/g", - "l5yAPJgAURxwgznLhbHSwl6xd6Dz/BOvhuhjda7OopvDROI7sw3lfbY4GM7zk9fRGiyupbOU/BlGx6Q9", - "Vz7zhTbVr5kTJjBeAAbHiGssR6fikJ2Ug0MF4Vxhig15KcLD3GCW6QnPMK2itdrYI5Zk2tLNOAQq2mC6", - "YBl3YM0TWXauyKWEPF/Zq0JRipBUJBk3Pl1kYUX5nh+6YDl38wqSyLmCn7HRet+1Dr4zPBEZWsyLzMlB", - "6AdsiZfcjM8ViDWfZdgIx2mzpfEv/YP4M07d6GwwzfQVs2LBlZOJHVI7TKpzVXFPETamIaG2/QbaZ2wa", - "5kxpSKDggNwGMJGsZak+V0q7yuqMh7APhERtBN1+nrFx+H2YG+00MMTQ6VPkpr39MSSBPFfiOtd+OX3+", - "ZiRB4FrYv0xyO2RvxDVmtsbdRtNG6IWo5FxlUl0Eu4VPXRO0mcrWBdwWeL6BtoCqkA4jDQ7P1fNQMfO9", - "linZDMsEvxTeKoMteOY7e/n3Z9WdPVcJh0WqVGbSDRlkqZVJxVFILnJtXJgU6ZnPkMLSpeILmZyrMZXZ", - "2x8P2fF1bug4DTA9UJFuNj7dNC+cXnBHz9FD9t4fVvZc6ZwkzTOSG5CEMzcaXleY0qWtGSqysRF5Nrwy", - "0om94XC4P2banCv6ViykQ3FOv/RxuIlWVmfCa5RkX0v0YoJu12jEWwhAg5F2AdrXW8oASmknS72PdiNA", - "L2KifdRBAkYemknIOeDP7K38rn+ukJ+9wCmz4BPCV0iRkHKx0CqqZfoyJB/B7x9Zauxc+QIDdLvEvqJH", - "f5BMQYXz1NKitQmvX6Dxq0Wen/kWRS33KLTrs8nHrJ/4QuvnqaKoXrUVVy1GJCpHViS1cXxz2F+zxmM2", - "/Yp2E1K4BCMSe0m1Yfm/ORxWM/B/dXi4Oen+WlbaVGw/G22R7X40BqzT6ilIZB5n1nAotmmCnlGY9ioh", - "gp75+AjiJ8840cgTe3nGtLd7a+PJGylb6VCV4hypeq/fk5Tqv7OWVdH3/DpyY/iyh7mK8adRF8OkuHas", - "DPooRxZy8mqzbqmMNwGyVlZOO8IB6B8eHg5gPmCpZugEbfgytD4pplNczYlwV0Kocs1sIxF3fapaJ93q", - "C1WjybMFUxAvp2whrIVFkVWdP9otGrg9z5ovgj++fvkkXAGXYZHENU8cnbyDuc5w8ZBYg7KEgMPBn/Vc", - "xSHg4YFRQRh4hGKaNAr0xpfFosyvZJ955C0bDkiuvIBEyQIxtHkmE+lCBrL6InrjnuciUMBaRV2ejUql", - "bbMhHFuLV2JkHb94ZBiPzRBTlZDG52ovjgp1iURnLNHGFDk9HOJbTjnYA6DbYjZ3Pis63irP1dkKYirL", - "+C+SfCuNs1HaYjsVTcGPsbYCFTK1jicXDSYQ+BrTt3WmJA9O2ZQlXPg3FVGVaSKt4VluT8YfOiiJdosw", - "rl4Ed7uzAfkp0eBNgyoF+wsr9Qs47VI4Yv8SlIhhpmcHUk31QSomxQwLCGMqBa64UQfExaUtFltDS0BK", - "1jOq1vhyFFD5tt4GsWDXy2CYdX+12trqngpzKZOtKHTkR5Pii4JMBN6k0CghrnPUFUHFe11ClzLrdG79", - "Ezm9C2szKKHd7bxwqb5S+yzVqDYGBbDiFvn//s//JY2s7AX79Vcn4tIsiJLBTF6KQZEDqSsr6YaU6q6v", - "e+Q7dNvHvYbVfHjga33g88T0CcDk2vblBq420ETd12ZlGqWnzfG1dCQngWDptTnek+jCGfW2QqXCZHg6", - "133XTMzl65ka75bIF8E7BRiSjjO3JOtGdIxj+Zz7ay2NPCA3MKlIld+rA3DuY9mT1y/9TZBeppq4CFtu", - "CL3u0vWQjZFpi3yMeJw2PDjixFM8lMkvWyIkrWH4HiJSxtlc8MzNl8FFgFSYIRv7z6FBznIjLqUubLaM", - "dWo91IXXeMYvxah5QGEnYqZYj8nnb0chOS3usiO11RnYy2dMlQmb2wiFEjdPZRX8I2wr2bGshttsJfuq", - "jaETkZdoOeFIpXXo9Xt+Ro1CLW90PXr9cg0DkZYggldHa/rq2kBnrMjXs1k3LhO5j2VaQdWYW5aT8ezk", - "9csWJFu/gIovmh/UZ4YvvEWlPo2wnt5nK/GaKjhs6Vyoib6GP9dcq8ZdkohXB9X3bLFJFuFJ814vfpCt", - "/rSgIb6Rqrj23l7s/fu3gwuZZcKEgw9Nk3EXpMLnJ5jy394OGR0dKbkGjA9ScXlwsbCzcQh6ADrjquQH", - "bHrF9TacGgux0GYZd1Sr6nXLB+BGeEpbTHybIoJbk7yzRQ4LZUX6iY/kteV+OJHbT2RcrJHWixGQxH2e", - "yM3bsvuBDONcOY/rk4jncZPdxTrDZRMH/jSv84JIZEr2vsCKQzZWWolwXnhL/xq3PGPjhVgklXMpmRld", - "5KGkt+5xy+YSUismeWGFG7MDrKfN0jtnUPTQux/fPj+gLwbgRQ+vqTLLSvmslR+yZTpLg//b18NDHwCf", - "ypTUD+gVJmidKRJCZh5rvcCpHY1ZJtWKhwlMFqGuFwkcLjRO+qIcZSO3LsRiNDVCjC4m6wv9ygjBaMvC", - "kkjFfpDfMe+GVEVDgcH1WSoILz+6xI6h9aN3wRHZ28JpHR5Z9lYsBq/VVLO0WORD9tzaAu337Cn2Q65S", - "8hdRwQsPoPNGJBmXC7R3ID64RfWLM7sA6zQ55fg7esbNTOCujZx2PBtdTPBxgVkHNArbTytOk73i1BVq", - "fmzOTYqPFhbz4fvdlNPKTOp7xymBE44sTtD69NXnqpHdq0NrEFzwy6234h2up2Ufnr8lKrrFdtzPKmxT", - "ffxhGDSf5jboxxZN5IVeLJpbY7wO/F+Z196CX7PHX6NziO1XzopasRZ/cmsbt/SDsHgxYFY4OmyaR+W3", - "ec8WOG6utBoYaymshv5C5Xa+EAv4uA9PIuSVC63l86XFJypPNVX9EMi8sKjdNRNR8wI7nY8ctxe2iU5z", - "VioZaLyjWQ6scAOcpe9qoas+wkSxltYemqTg5BVtqUaq4zMYAl0xxsyHPh+jMX0DUfoINyj7guNtgDv2", - "NRPKkc+4ZhNdqDSeWkjsSKy72OBrJyiMEzmcX7+mNr5eN8s7I2czYUbbGMCXq9xFu7AiHSZcpSDJxi9O", - "fjxi70CVh/8AQxxFb6vybGnY9zDGzgwWCQ0f93gGr8NQLFpXK7nz/LidZlJd6gtSmEvdesjeT13wFsJH", - "dcvG1ZGM2V6lGc9EFQcnYfYRJSXhiqUSnhnKC5OvlNAw/c+wppcycXIxZG+78H+j/Xs1YXp17UjeRRHR", - "VSVDgtpNG3seo/79jhCg1TauwlNgTTfrvu+3kZvbOGHjGdBd6NZP0XWp1MHTjDbR7+j2vazEpm4Klq3m", - "V6II1TmPtlii7JgQqBYP3u9JDHnv9XvgSSdMr9+b8OQCVFuVjnyZcDWOReycG5GWnzHdZKPOGOYRYjZf", - "0OVCCvsCAzZvFCXnU4yUgaAhkMUK59B/CC4QITK09drAc5fMd48SWJ3L0s9kPZnUC+qBWZ1dimA4Ybpw", - "iV4IysTlH9g8BPB9jSOTgkAgeTI/SIVD9PVo4AvenUBQFCwASgKacC6luArjtDoT9zlI6iG87u5letZn", - "8C7TJ5fQfRzV+ktcXEdndHaL8VEDrcN7PgPNxN/VfBQw4zMulXW1GGl47oD+CvQBo1bpcbXPTjK+vDKY", - "/r/uS9BnNjFCKDvXzvZZksl8ouEAJnewfjXUuWxULxZcpSGT6qVY2UaftNYJw++bwn4kbOXYVTCJ7iWZ", - "TC5sn12IJbwTWZyozkCOf4xxC/c4MO9xjKf6QfQ3CPmMhoThNLtPuj5B6MXIbGFhqrg9lLd3JX8CYBDT", - "+EIM+X0Kqiyz1bB/b4Fci/avp6HaiyH81cD9fjhuO4Xq7w/Z2+YI/WdMT6dw+nt3I2yDIgdxXUqOuc/d", - "E0bqVCZswq345ukgeICBYMy1cVW+HbLv5WzOKIJz6+hxre5x5N+VmA30bFLmZNOFG+jpwN/y0PCEw/Ov", - "w4NgZSerOwjYjxtUlJYR7Xawv6jShE8Y59XQ6jFPPayf5T7V2CZXB2lrycm8ypDCczer5ohmVmR0IkMx", - "2rEjcsIinxtpvX1qz5+bV3Odidj4funUWX4JxOAtTtCX79yS9062rJaVwqLG6bR3WoTxPT978X0li3Xb", - "aKzH6eIqeELibrHxrx/H+zAdzpQe6PxZfXDkCExR8cFv0D/HnWmfxg0ToUqLf/Ky6qXkNLo+W+qCLQrr", - "cBQ4hOATNIaJgMcnG+Pmj5t9XzoRWZrXT+rdyOy0qiCinQsQPP1BGh/y4IeX4vJM68x6jYiMPQ1aZMjs", - "OvKOqg0ABfQDbChSBrBfUNbr3VMY1pC9D/fwTFoXN7ayq0rsk/8ciiBxKcwSHma8PYpGAu/WSVZEHKwK", - "H3k1OSBHqDI9rR8KVCBrpxEZ5hb06FlBhBeK/MHSPpOOWbnIs+j8i0+CPkk1oKtKpOXU6BybmMvZXFgX", - "At39sqHaNH6t8sINU2lziG56qwufcBhul4ZeFufFgisMBUsKU/rJA20hHqpnrdMolsfeMsu9qE64JZ+U", - "6IlbGBW86eqsDFy7u0EHSRSXkXZ+3bOyE6HfhLzPSlHZIE8jksLpuoSrEF3Y4wuxbKI9HDGSXxU+IJxy", - "VrgjloGGeyXg3xKOg2fedcL6ZBg667Py+tNnQXvw97L9IfuJ0nSM/YjG/dJfoiIsQe5Y4UK6ySMUm/jK", - "EmT8M3gkpYf34EwLE59OySMcFOZKe3v+rhMDn/t4p+5X9dv9PhvbCokhPlxQYOiJp+H4R+k4EbDkFJWg", - "Icg4Ts9vWkiuRQP2s2JJJrgh0eSad5kmM15oJR3EREYqRkC9EpaBtIF9ert3ZRsg2efCiGeYBiXTV7bu", - "+48mMHTi4NUlq5+mDW/Cfnpd0bhaLQWQwJvKjHwI4K5NnlK1sj1w3jFu12aOsVbZinXa+DvETqOhaqGd", - "jkLhxkffuoaFfBQvqF61Yqd8IdjYk924jPxB5EG1ZGjrieX7LM8KWze8VITI+l21bmgIx2qTK0Ga70wy", - "q8oBbPGDZvjH0AxrXLkba7zS5ooTFJ2exv2vyFmnadQ+jKwG2rOCoIuwGxUqOmIkZPyJwwqVUQgjrQAG", - "FZGEnwsj+qg4+WTaKlSt9IdNe072JEqEswc+2yFaHWxl8ajzjVDMnQd39985TeRXfSgJ1SpEBxoSFHxG", - "wZxEc5UeiMyqxB1IxSuaUV1sYnTtsp05/f3Zm5O6GO5CImu1diMTqH6ABiW/fEHq3eA+2kBkEqUnEGKp", - "b5dbzaD3OuW9r2kYQ/Y9J9Ubs6izvTBIx5eWScUxs/p+jB7aSls35sT6MbvbGr/2/q8lKgC2HRF9CW30", - "Stkgt3EZfUJReO4m6UYUibcYvsDwI+W0vyjFpcc7CrxjrWY5Z3srsMDhE74d7qO4puXzsNrWaWiQzGEW", - "nw0ngv1TS7V+dVp7mll04mJi34oWGDyFd2ZKcnaJLIkTiMcCvdyEfpqBvTfBw4d9qrl+ls9Bzc+Bq5VV", - "M7p/J9qrKVW70d5LrwR7fa7lLIBHwPACihSE5cWQvVcVbvRHOijOYc9hYzzZ0mZeCJFb5nTKl48sm4g5", - "v5TaHDHZlRrIE83Lmj4cLfICdDckzXHfP6U31bkbYc7ew3XMG03iUhEsXFhEGQeItyLiFIg9o591LpQt", - "QZKm0lgXmqoz/ZwDPZaNqdSLNmgi6p2ZnMaXUKms4yoR3tM+QVMENBNyqfDoW4A9eCUGu5E2hk/T6J4e", - "ftvECzcU9FcGFhsTQTYTkw+StaWydyocQ7KFr4B0wsJr5Wd+KbwFybN0qVo0yHq4SYNfC0aVTwSzsXkM", - "1Y+LVy5+QA0Mqxd2eO/p4bf73U+LEF0Y7iPiOARP7qKxebBIdEqYeATQ4A1eHmJo5/E+gNZ7TlI4g8f4", - "WttPH6zZGMrVEikRextR0wuOXB0c5g/KlxHv8XkAiqQCyj7w8MMHqbSIPAzmhmcxyYVvUAaoBh/ICfoR", - "d9Ln0q486a+MBB0Nqi01vtBbJ/INIcvlWkJBooZy8cqwBZ2PwvoTeI5x1S/wT0HepbDU/V5cBEuQNzD/", - "UFAWi9E04zNL+wNLtN2HOcw5bGGTW8ULeI5Eu2JXzJQVW0bhXFO2XmyS0a/klkSmIpQdlXXKxNT1+j18", - "AoahItKr97kgV2/Q/xr3CV9SW4Cbzrz/B5bxr9OVXuHlFcHTer6Zxg4genh0IZZNJmydEuoU/Azzg7LB", - "JotnBLZasZO2xEGWTmyqWIywlq0hCjxe5fR3CAOMIl0uhGesXHgfnNDvulfP9fos/pMlGp8reZmoklYs", - "1xRp2NjScr2l/7pJSyvket2DpluIlF7/bxYqG0JRV8w//hQvXQugXEDp2A483xZ/+sK7OjwvXQxu4GoW", - "HCY87VYxibhlOTd4t+Yk6r2hE4YSXMXJMuNF/LkqW8kpbWOEu8Awb3QDwOs+1YZFQDMHFPB1c274Qnhs", - "t2NvjNEq/k41ayhsMKBo4/Vgis1RMsjKC5AZ2y6+6wILwmYMn3Wr/tLw2Wrthb4U3Wq/1ZditTb6toOY", - "2Fb5BAr+IJaVuuT6sa3iKZaqVhNuRI89W6sK9wILVmtnQmy1L5xCIU/ClXia9Wiu4Gm3RmG1c7iyv7X1", - "ppZHyEzVpYxLU9vb2szDRH5uQRwbBbbfNE04JyAGPy5PU9h5I5cbwZ14KQ0+ISxvdnguGkHDoqaRhtYZ", - "FGR7OsE4Bpxln2HA35++/nq/rhv/6euvUYmrQC0eDv70869f9Z9+/LfmjG1u3hAZP7E6A2lTDgIKQg8J", - "Tn2lk4Phv29334WeGhezsE4vfhKTty9OXoopRtNrteNi0iW8MqTEjQBl8mcPNfnzr0++al6BC6lW6+7B", - "A9f/L0nz/cYaKOW2SqrKrBCTP9z3bc6TZoXaab1VGlCD8BQfEh6sLXR0qaWe/AzDsH032zbibZjjDntQ", - "mGzkVxE/t2s/C6m8P//jhsfg6mRqbW4bNCyLDVCxOw4eVqU+6q67W6HZj1tmQ500TeOlyIQTJ9zNbyZM", - "tvBx4N4Uu7lL7qWBx8wQNxt9kwnt9Vp6pTJDTrSEhBn1SS+ylgyMB7HoAV69hux5ls+5KhbCyIRpw+bL", - "fC7UkP00F9HW06893a/3Jq3vLV2VsXzwy/PB3w8H3w5+/h//1s1S95KueB0tc/XlmqMvQbtSG67PVK7M", - "Z96Suh1xeUaGO7G9SV+aQWlo+PtfIFIBweYUWOfkFF/RU+FEgsFC+42dXsnUzbf3hsU2jr9xaVe1vPu5", - "1IJq0nKhjRdZutk2xnoLuOBX73pr4HEvocgq4FaE9/IDgctssP5R/genGehYjGc6Zr50mKs4YskdNu3J", - "RkAwn/MMwyzL7DWrYwtmR+BcI2iFYCyLiLFgF1q7+V/Ihoc+NlAnOlbArRbmMOEWXyl8hyi+MsSSriHk", - "PT48rGHkfd04sdvc5GEKO13kmwVxAD9GDzY9Zf+47rPlz9Vrc86lsXHv3NzoYjb3xmMYxAxj+t7Cdcrf", - "zxh3LBPcOvaE5Vr6oI440tUhVwNmYzjdk+pZ/GR9Nht/pL2s0TDsa4MzPLmpDdAe/534BRY8KTArTaBm", - "3OErvqSJoLlVcEROz6QS3HvT5zrzj30ot7E3NMTZUY5+MDOkNGIHkY+QyUYLgvGUM4XG9haYsUrx2pS+", - "3pEvY9Z1HNfaDr6mUaxzw1b+XJtn3VJ02G4qikNC2qJx5fjAROvlQ5lRTLQPkL2l4bHHtbFux6Vs1R2i", - "qbur0Xml4U2mzWOyl5QhJneGCr0StdIRDBrumgQGfVDBhYaylbbJlINf4hMDRrvA74/gRvKozx55BOZH", - "ZMF55F9RH7FLbiS+1pB5ZpFn4oid9/gVlw799YYz7fTeo7lzuT06OBBUZpjoxaP9Zx7ellWKY1LHvf1n", - "571maEIa8XYbRLlax74Gwqd/gSiqDRR1KyzV1uinNYq6WzzNMOh1aw49hUeoYx9pioPbowym+72PEfev", - "CZORwqRxvGWEbHViDe8tiCbY3pgPgOvY2p1jPPZ7jk+6E/kZn7TiQjYTlX/2+TGHsKe3ReZkzskJc9Wz", - "3pe0TehkpFaUZUBoFNgkvX6Ctwt3oqogdIlMfkVoK/AjtIgv734XfE/enfxgrhfigIKSywc9e3BeHB5+", - "lUB9/EusXJyeD/5O9pnhaPDzr4/7T77+utlK84vMR/jutTbEv8uccZPMAz49l8p79hUq55DLpkRwLUe9", - "5+UD+/oQsKmfkaE64KOAT/1UWDf8p9Vqvwo6NJGKm+XW63IcrvfxaNr6ihZ2uItJpEIITc2+kpkAvJD1", - "LZZ2lEqzmTdQD0P/x2j6a1aYFjrF/EQNxAgq6QIVaw9ZAOVq0E0pwPNi7SbzWuP5CdMiS+hEOg/B2Wfn", - "vdRcXZsB/P+8Bxf7897AXA3MAP5/3tvfxe2GW1FDWYMNJG/O9ZXobEENd6+1ehBCP5osnWjg51MfXo8/", - "D9khm1aGIYXtEFkfUBI43k8rnfUDHVT20C96GzkRhEILqNurMkUxOcKUsfW7kx9HZz2RdqfDm+5l7Oqm", - "m7oblTQ/oXjMM0jdUDEivPhw/PzsuNfv/fThNf735fGbY/zjw/G752+PO+PltireP0CqojWP4eb9fdmc", - "ryf674Xqwf9GBP8q0h7In4eA0Et4HR4BunjGHL/WSi8w9so3E7x4yta9Kw/5cI3JLxGcMbRZ4GGnVdxr", - "1IVhKBMByTr26DWUhkTPpN7Fe9y+DuM+M2LGTYruyejIrFleTDKJwIuQbOIFOrMNyi/9AqCn9/vTM3YQ", - "R3/gfwqogRGiLfhDYi4uhFWzQrDxyliiXeVKGsHsnOcC0xvKNCYR9p51HnunGoovbVzgAGwE3YMp9JEN", - "mPPBe+ZcbUm4FDNIb/ZMruVV7wdsiVEyh2GqmRgFNXRz6BhVexFqke682ijCSezU4CnU2NSY9+naobVT", - "qhGbK+MYO4fH1etiIFiXuliwWhe2r2v1l7FsbIGivXyC0i0NUNlKcuOyfqZn3Wq/0bNQtxJRRs4wW1p4", - "XZZHx4CmdvBpvmsrP4hlUxv0Gj2ywrlMpN2bo6f7U6oWGgbHxBHEy3fc5DfyUvxNiquVnS6b6bzfoaX1", - "TfdBcpWmtk7zLVV5Wamx2ppUMmak7NTYayV9usXVpmLqhZ3a+xBqbWl05/bW26qiL3RpqgzIDS2FpKUy", - "zbZltPNJCV+nmVitDdJfqlm3ZfLtvKE69UUKDZpgNuvSkreWrbcRnmS7NUKlQytgjopg6ptbgJDnGua/", - "r53qxci7duEKdWropV54j7M3WKXWIqGTdBQJ0NobrLAiC2pNAdBJ94agdL2ZJO9SO8nrtTTvNHrN64Mu", - "8Vo61H4XC7e0scM6lm01raXjk5HOherU1BmfvMeysQkfsTzqqOWc+PIr2k41w/dOWdMr2GLd6L0pzUV/", - "De54VyTpu8p1uXrAf+zvUq2yLB0rNgmhXatWRc9udRuk6G4NlOK8Y71V6ularYEjd6jaLBZ3aKCUJTtU", - "WuHVHWrWmGOXYa7K2V3qJvnuddYPiBtt6E1aaFakd68c9efdqzboyh0badGodqu9rsfuVv+DuJvqNxAf", - "Lcpzx9q1s6srwTWde12l+8p9d5dqlTtL92qrt52ONRuvXTvWvWHXrXaFG9SvWjl2q95odenYRKNOcdNU", - "U5TrGp640NTcYJY1mAZx2mDklYreHBCDkYCqh13xi+JDSoOXT9Rp1gfDMj1bxQjmeZ75x5CNMXYrDyl6", - "Fl934dG/2bAcEmY0POnKBT3WlSOqJsfs+iLT4nRR7brJxvyWgz71udxCFxyAiu7MKRSaEwatxmkFj6DV", - "V3RHB9G2Z4x3lRcMGkKfElhyMuS+PXkKjy65E4ahw4b3fHiDrnLwsEgvi+Hz422b2/pYubKbnRwfujww", - "V2dIqyhSP9VGctfTqRWu0UXxBEKMrM8si8XqS1eyY2W7KF3nii9Xny0EtximXIW0xcLkeoLIoOYCP5DT", - "Di/cXBvpyNHK9x/s7X6LqIEQ7AyRo1Jh8upOeW2aH/jKBWncNl1YceKD8Kqe8fW96RodGGJvbh4V2NZC", - "52jAtSCs3ajwDp1cMSrplu6tqaSw8prH0tf37dQKY97JqfX2np7+Qbd065QYUO9WVrH5jXcbeZZes4HC", - "mNM3ItOuLe1ErjeP6kiFdaNtIVoVFIPgbLAtuKPfsybZ1jDBwHRuc2VJYgf9yiyaVshbP45nRlh7QumW", - "dnOp+2nuw5//9pZdKATqm+jCIUqXP48BTwI7YIQ5MGTvNNWhz1BWZNO+B0VAlI6pxvQpunDVJHRr6ttU", - "Zk6YzZBqYn0ckjItGpn4hPtcYZaPq0xaV/Nv9jMzYlpYYUv4NcQeuNJFllIaySol2AjnOdPE9eRP7rM/", - "XC+ptp8kIttsz28cZ9q0je8vOgde1Vfpr0Kh/vX+h5gAfX2R9cVW4fNapaBiCxs8+jrMSF80zuUEgt98", - "gM7NGLctQudle2ROlPdPnh7uHqfzsjU+Z8heT0tltrDCVnFnyxSpVCUcbkagFPCqrPdM+eaw/9Vh/8nX", - "/ceHPzcPEZfWP2Ft26+pp28ibA8RAo5PeJLGfAugmJeaO6L/oCMDAXg1HxhGrCBuHP3a3jsWLX0EKdNn", - "Of/g1eQ0E8oWlLyVpzyniFslrkKWtdIFGWkC13IueDotMkzgUn6TtZBna2DUy9aAqEg2Xz057BYete6R", - "vTNMAeieadWBOXqDrwdT2WW7ZCREKJSFPu2t9/uptLe+RhSCnI44Mlg3p8KMWzcqbKy1Nh7lNSOLtzmE", - "hoChrYwnoP10dmYMt54busijQjpqugcjaChaBrAMK7P7hLE+spCuq1+DetKqcZSFydqD8X788KataeRU", - "gofSudiewsnfWZAoavu4skE/dyLbN3IhXTe4pFVXamrANrvBh1t93PQAlkFkX9buaEhaH3mTjr1z1Eu/", - "Mo+uC7bzQVZbqjub7ZpH827zeLfRlMCbBBO561Wg1RDfEzYURE+IgMIvQxXEfj1XAYMty0JGTBD5WJMI", - "GLUn9shTzSP8ydalBipbplAW27HnKmhnHEt7UJQmv3hyi/+mBb2hHnewIzg6pfPzoUVoGaT8fU6XCbth", - "uKtZ8nApyL8kpDOfSA+nCy02QrwQq2+FHQaJi898IdvgkL1CBqyupbRsznNEyoPrubOsskdcpeeKznD4", - "JWRLx6nCHJNMW5ESmDruQKVp6SoNe4TvKljluZrzlCmNY6QwqUactxsKbscnWyVo2XCUn81MswI3czMr", - "yZb4ZF8qmhgoL93SUlDyit2kqoeCTnfYp7LcwMzznAzSm0MgNxg9Im7KYpv1A4D8c7yDWVgcb33pbgxp", - "7j+E4EDrdrmY6Aw7x448Hit0wewcb2wTwXilbCVdxWTJrlPttM7O1Z4Vgv3n48c4l+UCTiYPNQG5Sn2c", - "n41hK+e9Dxi7dd6DyAh8uqY/XziT0V/PM//Vq6/Pe8Nzijkh8ScthScnOECeWQ2jTPRiEi6VHnaG2vsf", - "LgRc4Cfs7X+c8Qk2+6OlcZMsBHGSFypxRbSo1ZsNmXh8WwupCltrHVDVseHnLJNOgNc4GevxJgBD5Uki", - "MI8A4rIznklOSY19C4PzHkOIf7NAkyvKuXp/K7ktthDCCmMiVTRzok6EtXB2eZjGHZkxxJNuPHSpkzOf", - "RB+NvdwSIslGk+dxDBlss3c2Z4kU19KNmiNdT0KezGtJkY3DlqzN7dCSFPM32pCO/j2W8LTqMTsxhK9E", - "GPXJ6Dn7V6Ed70eATmGMNpgihYd8uWCIBDFBZ1gucxFEvDf9p4ZLxVK4ukkl2kLIU2HMaPLN0+Z4lEq6", - "LCrKJgUkSx22h0V2bQwOstbGmuJbN8NCVkj2zqKmeUymY5cK7uVKFzZryF3FzawegP+PhtyI1BI3s2Ih", - "VoEPtgpwbkdG63r4fPM0ClXPxQv6H1RluZGXMhMz0XKN5xbuMg3BTqtNcg+BDKWhKQBRAWtMsJmsTSZG", - "FTRzcshAYOcii2kmYB9MoRoJLblq0sq0uQBeKB/S93g19mnft+ijSagTqZomsN0ULdRlO3k1bGfcs18/", - "rm7YsbqURqsF4Xr7iHgYK8L5alNd+mGvgfLXYtJ3CkPvYx/wM0FQ5PxKDdk7wMXRhv0ijC5Blen52MsT", - "AB5OREbgFiCoclujEsg/mz9jlKq0TPONQU6Yir8wl/Ky/or07ZMnX331pyeHX31T16paKKw9HJ7obauc", - "uFUsPK9KhUhRcaGHzMt76S8p1ej0mBIgrJaPGEex35CM4Dd6Hj6ceXd75rVRK7gk3exUO8V8XSROVPQB", - "qYiTOp1Req/aKdM7O/7wtre53WokqC/+w+s3b3r93ut3Z71+7/sfT7YHgPq+NzDtB7S13/R4h7pgaDn7", - "r8GEYuxblyHxuHorxhpxxRxpq3BMZcVC2W2wMv0eXMO3tAVFdsSnwVb7NNANK3YK4ry6YJ0SlTboUuAK", - "t6LzUHp/MXJuuV0tee5LA9taUaR6EGe/d3L2X/urJx09XaBmEKPaLgWpCC36S/OmgYupBEpd2TifoKcy", - "CfR8WUU12mFL13qCYjfvZl0c/Ly2rzc4v15XvAvpyZnTob+JHxqT878/jZtVSxVSWSj/e6NNCbwmhRlw", - "C3wvUp8MBa0gDVpPfLkoCpk2C2J85Gh8KjkLTn+ldSyM3Ffbwa+wldUcd4XdNaNbJSFXYUmraJdKeTHK", - "k4b5HVsnFxjq/uLkR1ag82UuTCKUA3tfOQ2F8Fpbzv7jcOYH42lYK3iMgXq0XNt0MriuLdrAIsoRG2Fx", - "55lPZUyjjzgSN1Q7TvUipqG/4j5LYkgK16IVNL5Rn5R04mqAB/7xr0dLKZoB/11p2xgZMm7c2CiykfRS", - "qW52LL7kjoOsvTKSXIlWmIPwjCQmdV3XSrnjnVSftNrL9ut+bPfnrXO+lQYPw/HokxaaW5+h93tsI+MS", - "rg4LBDfJYUfQzzgVI3gJVbKLdnd6HOATmBG5EVYonNHKtUKbtfT1t93N6JhaEgtmPm68LTe7nb+pD2kN", - "UwQYq5GtOgmvKOqpcQmWWqh43msRKuiU2mSk5/9ChDFbLKKDHT3WoBUEV8PnSn4OVl18d/LOzrBBMu3k", - "KntfYg12pakldJSjn8NjDk4lmRfqop4YBu4tvXBx+pyCbr300a9xnEHZ8PaQXlzQTC6kj3HFAgkaLkRa", - "lqC416aJnRBSCjLn7eyKE50u/asCNhlSeRJ1Ki96V8FjGrQAn52zDZmnTAMbn5fQ7pheSqvN8shnkgan", - "w9C7z8NBPn8G0wOjVraS5rTmLp4tsVkCKLWVXKVD9hq5DV8j0fEfOiwUdZggCDmyukVfDPJNkpaFA4Be", - "NCr5kKwmTDLyufRR03W0C8LwcEZnlYho+tLnpo4hxj1M1BBwDyKISgmL0EgGwBkNemUdRyiI4iHUIE/U", - "jkkxceeIJbsAL1V05e2HaWtCCAqNEKYZeA0e7ey8m0JdxiaEWm3q9FZTMd0U1r+2MZCj8ntdfTNu19Fu", - "cYzaMtimFAbVcTateRnw+UHMds8Y0eai+T1+X8akzLwNcAOEeovT3k/w9U4NdYzDoLbACUvng0xM4ZQ2", - "StwqMmOHNhud38Mq9MPCbtuym/glmLjRWzLm1Amj8Ris59XZ1S8/c3x0vdk94ntt5C9aYdYW7IvxhS5A", - "taGAnEvhv7cMXXj6TIkZr30P+9CsYdEItgDI/w1GnHToH/w1Grov8ubObxN7EjP7dH+v28YV3Hm3/TL9", - "UL2r3Zli5yY7B4Ss5WTaUWrJNBVqC74ttl/xNPGVtrrD+3Itw4Z42BNhFhIjGezNxo8vWc0mXPzJgzYa", - "9teWlLnd0EEbkiV98/Tp/m65kfSVEqZ5rPgTPtqG8f7YMt4uSJIEapiXa0tOUeR/45PL3jBlywZkz2qS", - "r93U8BNeWFFFm0Yt2OYiAd5P49PZjm9vVX8yzO7V9PRWxfU+PNzsMLZqCql03rggjhv3yv4E0R93mYUn", - "5glDsw20PmxG5gbGlZdi+wtA5HbfHot1s2WHsJfWWCxcgVsGbU8NX4jmIJUPpW4bCsEWT3Pg2EthjEyF", - "DdcmvwL71T1/crjtOaHRuB7ubmtmcbwqrYRu+whrp4ODpqyAj2tc9jKSnAmV+pQVe9bpvO8Dz+FAhetL", - "32cM2qd7I8R3Qa0FwnxjokcV8knHNu2dZSuqGOR3CkZf8OvAi6/VKfFeuztE2XX1yTxEy27e2I17ueDX", - "iD4sfxGv1dvv2keAuA/WYya//a4jMa0mj3ncEnYFs3tepFJv58sXPlM3h+KUgAdjBy9lKvSQfSAetFXr", - "AKhIHLL1KF/Lh10CvZwUmRXP/bfJhXBVb4c9aARhdZkVDvwi3LyScX3fU4vPkV2LepeWRjTArNcdE1Wf", - "Op3fVjRokwhoZ/tKvl4sRCq5A9sIMFYZz2h4IqZFxuy8cMBmHlR4gcFvaI3GRO6JNqZAh1CcKtJIs1nv", - "FigTxPKfJvUY9JXfSeqxEl1YXYpM5+IGkQPCV2XxzRHdTqrJFNgKMvK6NhBt2RuTdNbxqTEB6r9aH5cG", - "C62000om0bub0UtdOVKeGG1tzI+PTlx6WmHKIQP/ZfT2AzD7AfY8eP3SxygWCxEN0t7o6w8IaSkTE9nd", - "1szUO/gkwByDsf/njXvYBkOzAsxNKBVX0ohBJi5FRt8SmHTpPO2dqvzOxdMNpVEA9tZqZfZD9txMpDPc", - "BHxtr3lbrOfBuktoahCQKTVG4R0BS3w7gni/CfobRyzMALpmRDYs1Qm6hoo0xPaMvX3w3z2m9sHKNy+x", - "3YqHfZ+tA4c3xrZ0NSJ/KabYcjf/4/T9u2iJbdqqTFq/xJux1HGLqJ21raunoG7aFNpTWPvbGoM3PAcJ", - "FwjOn8zx0Yve6DDBNTwUxUYwUkp6bBjQPvBxpPmQcQ0K1I9KXrMIokSXHRBNKzmNyoXymiJUYVeV06Pj", - "m9inMYXHvT8NXgA38OEohVfQeFoulIis1RbVy7NskGQ6uYigPd6oU1nMWvu4v75Jwm9xIRNaOSJpA4a/", - "V8W6pzZJYrbPDrQbF9LnCAV+NagDjIj7mkJ2F4VP9abK53R0kizzE/CI/88WEtWWiUjwRg83HXAbn4i5", - "9CGvZECxxWJRHpyhOon3+gKSuQKuMMxICwydgM2RLQT3T2D+xARPXuGf1xGOjE25pYdgHmKKqYARPH2G", - "GSMETynpPLWmtMOXP/ClmQihWKYt6ltXfImRf9ZnksCjwwNmGJFr45h0zxifhALcl4FKKXfBVok8X8EE", - "UdqVYaLcokf3cONB35zI72b6i1dRMm7dmmrFXmpB44NZu8pONezNriNe8wiHRns0j0YJsJJWfWfb+u0S", - "o4Ll2Rl9IWxjMsNGn8HmfboR6lGIOyjHEVCfKuhHcJ5coyN/xiHrRk3Um0KwvUBji4B3dZCGtLb7Qwan", - "FZw+AWfiXPmYQRDk0BeFKiumg+2j0l9tpdgefveXQ1gXD8q0PzxXVQAacY3sCCuEZ/2VNunAYhAdejj4", - "yJg4c6mc4QMoRR3acwWSQnHK94IaDv2cg9yxpJvS2OichbFs2Lq2qFuf83/1ZfkaFwvKB+V1rjHQcZEX", - "TpgmSe2WuYZ0JSoRm2nxRJhBMuegsQkDfWgm1T9JO0NIlWcgZR2/EKT5oraDSiWuGXhPY572kgjY4ZC9", - "hwd/Oohs0wqwPSszoVy2rK3TuSqLIW3s01JFm8fh8HEj1QdnxtVDHha0icV/EpPnhZur77W+2Mrf7S8V", - "oRkKiJ5rfRGpMMuI1iDYPijzDY5W5NecNj1kr8wllGyZztsXJ5TUHZLIn0Ydc2e0ysrdPHEjuJ7//A8K", - "5f/51ydffWwFf0Qi2A7+sJLcv30yr9WlJsTR20WdhhuLLlyiF2LknU8arxMy9jlq8T3oDHLRIUpxdZ43", - "QqUUxmgzCoLjBjMir6cm5d6ZwlIqs5kY5EaDHSqkswzZoyzlHXRGcDQ0gylJO6Gc5GBBgVDlBOELvNeo", - "d64tGnQ/zN0KqT9sMfHvSF5P4kxpNeCF0/iTY6lIMm5IT8SnTYSF1TnojqAOFg5VCSrt7xflzRVizsnT", - "o+L8hevY6zeNYnu0Sn2V4xQ3b/rFDREgcSXb6zSd8CASaAf6dMeju99jyBzp3RfxpmyFkRBcHu8q2+ML", - "KzlvS8P09mcOOOpHeIX4tYr3+vjJn3fDe43t9P26tK85LMKOS93tql42X7mo+8661XsrHEdTxsrKtDif", - "ToVBvRregID0Lkjfl+CRzxNH0GNGzKR1/toJbngTAfIPOPGSZzIN2Ec2nk6sYh4Jjrz4wIRZU9MOV+py", - "M+DPXrR1bN6U50pph+PcNWICapeSaSLm/FJqxFbAF6346vWPty9OGGqX/o2XmPXnvZBNeqFTkfnU1LnR", - "Tic6G0p9UCt+8OTwydeDx48HT74+IBPLAbRp/zv8u08qIvZGU2Mrc6uY5sqOr8RkwZO5VCIT3EAQwXAm", - "3byYQO/wY5If/PdUJi4V0wH0w8sGQTc6mwsr/HS5EayIUpviyyldX8SCnCy9NbLJDlgK2Ga3Org245UO", - "hPv3UrUUSwWlRpSXor2QTMWCDor2MjoX6idtsrS9iBE8BVWzvURcEJ/zo63kx40k+sp4xKZd35Ebo53e", - "hisynpFSJUZwNDU0ve+KxUQgZDe2V/VEChagFZ7dHrK2ES2NugHMtAg1NTV8RgKiPE43S4I4d+psM/9H", - "6bc787OFr8umGt6mbcnu+HMTy90Lr39AaSuMSFv73YnVTWwPOxyeK9K7Tul1APHqwsVYG7p+wJiCSzWM", - "tZHH67K22/FUFdCrkAWNOmcc6DY1ZY0qAtxgi5p6w1YRWn67zu7R/arzq89mMx3f6NJFG9ZtL9budx/7", - "xGndo3lXRdrHNWyS47q88TbHQI1I9EBdGIsPTtHlMwM53sLTHJJjpRI9KtRdqD+GjGdhb1oM6fBzBBir", - "9dDirjYTo65wkCsj3kXgYVr9W0p3wq+7C4m+Ba6tRGojT7eKlHhk/UYF1zU+eRamHUVLqWORYGlajiup", - "Un116xUJU6fm7mBxVni8HGbcwRohVigoMNdmrredYaPrjI8r2RmUsuxvK5AXNdw4aCOdeJHJfKK5SW92", - "+9xsoqxFjoak6qHD7feHZmvdRzxTKC7FS4uef1N/TQ8jz09e9/q9S2EsDedw+Hh4GFRInsveUe+r4eHw", - "K59SHCdy4OnoIPNXd/hy1hT09wFfXLy/hS/MSuclfM+IDggBqHx88uMZW+vDvyRr5T2aPGiwL4YPQfg6", - "YRbgUgMHOr3deHnlyz2yrCQR732VgFUrE+mMxC0b+1fAMbkwlOXHeCsAxbm8H62MA2HneECWJrTDQiFG", - "O5rHw3CVgGdm45cn9kh6BxANeeClCJLuQm6psNyw98Q5uB9PDg97aLZDNT0+jVLhg3/6+D4bFYAuaax8", - "Vz4aHwmp+UwIM4rbSxHgH/u9rw8f39mwCOq3YRhnDbSQoKoWwLvDwIbINPCcyc2S1nWFMlam0O9dD+LT", - "76B09SjdMeDQbDIAPvfWe1426Rl7dajBtc0TDPwkyeXGIJyjJQjnqnj3VG6ZdH2sLwMCxRQDOIILwVlk", - "swshPKhU5LU4Lv9aGCHQ/UDsUUnFMCIfCGHjw0SNozFTTgCE9VZCfDyGiQBcrA0YCGESqRZWPXJhMsB3", - "5+pcVTwxvPcLyzOuRHiIzUFOWWdX8iqEgTyLB7QwXqBSkoRMcJ/Zw10RENfMCHhhbmK402aGQ5H/nU6X", - "98Vr3xUqzQQReSnbvcL3+Rm+idO83KpRA1qqnx4etnUcZ3LwHQ8nqWdvqPftp5EZM6FE8FgGAroK7gc1", - "NtFAetow8a+CRwzoVKJThXJxylgGwaGrgjBY/8gYoZUIHAIc7h1NSE4efpo5R+aTaZX3apsH5k7r+NLG", - "Reh7cWQFeWlFL4gJ0iszAnPr4U3lNyj12TvvKnLFyzmtngWnrWdBl1PgY793ENJNHEwzPgsBIUlDRMhb", - "YWYCnzaxJBGVuJbWUQ4EYfusyFPuBFtptCFhxaXkzBY5JE602qR9sq7AOwwrlJMZTiqWfikuUe1m5z10", - "3oPlO+9hisBMKoGmkQmabCK6N51CMLKQWaVBYGLOlNDLK5z/zQXmiiUwrOaK8hGmRGvoNFvgsu5BuFef", - "/eO8NxhcSG0vCPB4MPDYi4NZXpz3ft6/OdYvDahZ0+4ktFeC13D8tN9keF49iUVa86y+jXD9uks9zMur", - "eBZ4r8omPxJdxiFmvFDJ3G+ClxIw5p2ZBjMxSbGdbworTHmljgMRMOjcSBuTOpVhIBETYsLjz0Ogu/65", - "2spQbHd+Ole7MtQLYRwoUGEV2IIrPqM3hwvvAa2mhtPjQGE8nbPjayeU9Xmfwee6f64ww9PACHrODS3S", - "PGL7gVDRdPDi5clByFKn1T7ecSbgOSnSc4X3nLCWW3n/JGzjzdm/+8tsl80fsh8Czrz/Cf0nztWeRzP3", - "fjcvtL6Qwvp1PO9RzNYlzwrvulNJF0bfDkFZFSxYqJGSRTmS4UzrWSYiYR+Q+SgmXArf05IKQnOH+X/H", - "rUzAMeb9pTDfO5cfBy8XWoPGAaP1BgrbH/OZ4amwsZa3RLzl1y+i57g98QnkIXNQv3ei8yK3gCx4JdJX", - "2vxoMoshwX5ufnTDRC96P3+8K8kXaOWLFX6rZCfF7WRgkYOL/EAEpiZhqG2TgwkWRZVSG7bQRrBYjf0i", - "c8ZNMpeXfkDi2hmeoIKzYIVKIZnFwVwvxAEJl4Oyy4Pz4vDwqwSYBP+CTJYYF2+WrFA5wX2WxSmeA94r", - "cQdlJXALWPBcgQW14Yob1hCvdRlylzSg0KGvtj9OjAjXPS+opgXKPmwFxSbJFEYr4wcTLiS61KlyNHQF", - "qCnoSYHNTcW0+ZRmDAMdztVxOTtvwEfSbpAy1sksa0giFk4MGHM4IuCo4alUwtqdVCva6XJMGyUrhZZy", - "4w6AvAbhYbCjrh36oC7fhra6MfjjJgixuJBE2uFlPdDLZ+ZmZKHqgGr81EDtt+foAVfpIMiH23N3v4G1", - "WVfO7p8rK1xkurIHYj+pbnD9iLR/rj7h9WOVR56r9EOUwV8wt/QbjkNa4riS6GPE0+VvgZW2cA/bg6gJ", - "mdv96ikZp9iZubzj9sEkXBOameg45J5QDNG5REoZbvQ0+n4zirSzFDQMr2qZgPeQkPnK/+oPIhgCaMSl", - "H0+29MdXhFJXTFwnWQFgDAw0aHwNUNpDB+BzOIu0a1nCFTnEo3kSz54Aq0F5APxjCaW4QjfLmI8ubA2T", - "MfcpmUhpUj5JF7o5SaSTwmLoNBxKyZxLZKpUEOAgHJRl0Ani51JuZujtQizxDSosV5nBLOdLaMWHMTKj", - "C5UOnJE5g9uHSginD/PTwigvZQpWNGqmiZG/w7uE353nyX1aXtd7igjdN9RnscmQ8uQ3pLZGRmDIMY0M", - "UKXpdkYM8ah1PkwymVyMkFyq3Fjf2RdQCANY7mlDyw5uu49vifCJiyLff9YtPJUY2gd7SGyJax7G2BLW", - "susm0kPzARwn7fv4QfD0ReVR+t5eJWInXslvfIEMZZjvkp5mVznv1ssPk6ZAqPjq2/A+f8P1xleq9gWv", - "+x3cE/M0OzfclIHQocEjODOny0X67cjEn8jXIgSH3cWGIu5a+z5G6Ld72sI1aLlP/IpYSQHf7CtgtWGX", - "0sqJzKRbRqPPb4YkvpepT56lrypIervSAQRqrh+Gq+G+mP1LpQSQGIT6pHAOnxK9d2q2LM0IHMZlHMVJ", - "oiOMwuhQwhnC8c7kJWbwcXOvX2eCW0F+7vS1RIcErwT/47rPlj9XcQ9zLk3j/eplCD69J9qN7d9W8kBD", - "v5EjG4dCWcULG7aJM4/LtxNJgXcitjLKEbtTqypprfkK4UqehJL3yPK1jrZwP76W01LESdzFMgcfnqTW", - "BbFu7OlONCTgtm1a7tsQr31PjBLbvxsd1y8TzOzzMgvMq8IsflzhZI7QkqWssneypZifF7Bst4hqYVcG", - "grHzU8pNHWMJIvAlPTmVCKyVrMDnqinXr89zjfMwYi4U2Q/Wkwr3mRXiXLk5JdhdTwzMuCtfpGbSDadG", - "iFTYC6fzoTazg2v4ByM3Dq4fP6Y/8oxLdUCNpWI6nNOR4ZFw5lppY6toC97tO8zXssJ6WMfELwUCeFpv", - "j6Rt0mnj46HPVH1P/LKaCPum7IIbitTyW9JYcHY1qxvS5V1wRgVOqlXYnfELUaJt35dauwYa/tFv4sZD", - "Dd0eD3ICuS97isgnE3zRanCqXju7ygGQL+Vn3fEIMcnKDQr+zbfdb51l7WKQ8NLZpccUp5wVBxqkQ8A5", - "h+9cRRGtCOu6SluzmNYStntdtQZYTuZXqeCVALpmTiYXlu0p7TyYvodXLUksBrMiLuQlN8tnzBVo71wg", - "AEo1RQZCnSB8ZjkVevv3c2WItk7DCH4n/VqKj9IhdlEzpLG92Abq62UHPggO7XGE8REw+YIwHfujwVt6", - "BgMjcsEde8cGA8JKOWT0oEO3BvxbNLqPnwbY8nvizwqQ/k3lqyev34ixjQZTqiO0PdwxfrcaZYBkaxGv", - "HkjpnjZuFafpVsYeAgf6zRyMMDcy7txqmzzEW7tUjNjS8SWRwT/kI78sfaRVGrFc66BcUuHxHaAjMIsf", - "rsXwXJ0YPZUZCE+llVjkbllx5opf+YdZ7+URHxAtvWXH50PrdH6AoyJg2nNF+cJKyOAheyltnvEl4gLT", - "mKEkRHPRV35oiCy9RJwEhKI6V+PY8wjeAUcYDydmy7/kCLcwStJ8jAixzsGgsSo4nYV3d8TeAwG54lfi", - "QdzK5yZM6QiL0rgm2qwsy5AdR5eNgXfZqHYB7kYvT85VZRhTgstBAKUM8Zlg4LCU4bnSx1tEH+iwYRht", - "8a9CmCXQAF8IJwyT9lwFiKbJkukM9GECpAsBDUY47tsrEYCpq3CMDc9VpLRx3JQxS6XN/QnC2URYNxDT", - "qTY1xxZyeqlTHVmHvDNKuboevKWMiSbgz++4IQayHhLBLDytOs3G4bIxJsRExhXO37GlLliqz9EjWwlA", - "VHzuWCa4dbic/qqAnnBQHJFwJnHPI1z2KsSgdSK3mH1eKrgISUuvu0cVQij3uI9rhBYzzyh4EHsqCm4U", - "tHcR7paw/s6VM1zZcKU5YnLKOD5rmtJ7EkaDNAO9cpNJYSpSkCH8t5hOReICRvWCI8/THY4Q1xJROkEh", - "WM+T62v/1psbnfMZd+gmeILc5GMJQPGwAijNCTYuHTX+3cesHfiJj/Et28OIReR5T2HwVDubCVB9zxWt", - "LEmuKJfqQqvR/zPImBehEAYKeg6wGFTd4uhQ5f8gMzwZacyvwcZ+oCg+kDTMpWCFgluodxJd4xak3yir", - "QKT7t+6SLIZsXBVNXi5ZEkxVaaANE5mcyUnW7NFA0U2wvo2igpJkeVUTw+F7Rz2UEb0Qrd9rkZ0I6RvO", - "8TKFeOlaGNOnxm/KKTWBLv18K0+Ylbh72HIxChzX4MB09mrwZw8gXHfIZQues//3f/4vCU8rFlw5mVjG", - "LTt5fvbie7buEt4YMR1KjVriAyojIDdVNv71nHz3z3tH1fCAnz+OOw6IDpWm0Xhm6zKMBUhs1PCbLRbw", - "sz+JvV40ZnuYXeuAcmsdCJcMA8B/ohcTqQKe4DpbE6IiyT34GdMkRJRbL3eillACzdd9cctsEhSM6O95", - "Pl99Q1bRqgNrG/ODJxA+OYTRI0QOeL9ciiqvAp/4aZTAmBsd6/aH1eiOOukGjIwqiv7zwd8JpG84Gvz8", - "6+P+k6+/bobq+0XmIzg4upkS6mEjsa7n/KYY89XcV/6cGvlzan01HTfDX6wLB1lV2pFCYXF5xzWXQIyg", - "8LDs1EF4PrdD5g+Z6D5M2YmM1o4JRWFe0RveV4Z/7EHq89yEm7AVGdTfQxlK/uNs7H3XD04iDpcd7xPg", - "/hjWLR9VY61R60QhStvtPazCZNE5V6okK1JhQbXAAleG5zmGuMXx1DBv27ar34uaVQMbf3gTH4u9ciVW", - "VCuxRVMKilKfZYjPBkyVcOI1x54cPv0zpT7ul6wHG5hgBAupiigj/AbQKCZZM5DH6lpuuLqU+MJhBfGp", - "sKxLqS6MzMn5YYUmI1XsgeYSk8h5BAlgVVi3/WGX5BS/qQfrusZM8vJZaeyPVBAhEWvX37sIgd1cDwaY", - "yWTt1nw3zjerOl1rHGYsEa5OJMtjoFLK8jm3YuWC/pzux3h5Ke/GaBKrxrjH9c+zwq6t/Q6xmZXzOQaX", - "NUQx+XP3vh4j1o/2T03zvveAKb++nT96rwy/YPVt+Gw0feuQnebpdCSeqT1IjOBOjMKZQoRUNLk5YsGY", - "8+2+fB3rvexETI83paijef6GLHk0U4qsZ2llWbvuHGVg67BzL7Hgfe8c9XLC3fzWri5x02iK6e248+n2", - "eu+0ewUO3nfoI4MjR0CFG+9s0Mc3bOorUrt/2/sJg/w9bKW/43TeRZ8rETh09IvMNwBJERoOZ39/fcLi", - "raVy2wmXmJjOq0xJGshruO7a5vt/Kc3fZb7NdBUzt8YWSVt2Ot5KQIkJk2qz+XgnsDqVVA0+W5O9/ryT", - "kuDX9Vbv4LDqYY4xKx6SXnWBv0TK9ZtVFUOMB0LzU74xRVuXdiDpcI/fc9xULvOL4HKCOjW0tb+R8s/V", - "BtJnf7cuZXo6FcYyK2cK8Voxi4RPvhM69Lr4uUpF9Sv4mxu6zUIQIhmPAJVVXCIMi3CrrSCjNbuUVvgO", - "1uhLYbz+GhBJZbroFzVk38vZXBj6ZEOKI2YXCPpfmlYAaR9SgzBwDRXwyjOgnbDuiP1v2G1qgj3uMw8P", - "DxsL2T//91eHh4OvDw/Z2+8O7D5U9CbiesWv+mzCM64SkVLNA9wBtve/H39dqUsbV6/6p77/moUqXx8O", - "/lyrtDbMx338NtZ4cjh4Gmu07EiFWkbYTIvhO/xVGr79UvX6ld9oyPiHda1W8O5y03PvrQTn2YqN7g8i", - "PFdMkzsIUDQvBcxKLzjrwgN0pddQoKvUQFnhFx6aZ9rUlYLfwim9m+YZ16CB5OA3JhUR660v7p+FsMCv", - "uzIDj2/I13dvB8LKpHV4X7CtlPVGWvcKS9zsQPoyaamcdQMxlRfNjOA0vkBqggnSOwWFet+EesBLvvWi", - "CQ7sJ+Ue34ff/11cMqGdinHnC9xJnAE+8OO74O0EghE8jQaERnkAkZ/efNBNHOBwgmoK7f9WJIJOnHAD", - "yr95a50GD5jGWNsvjJxgf1ntCXQH8rGCjpNRLoxPd2VbJcSpQBF7Uil6b4GgKx3dVmpUmgphm1/gVgPC", - "55qwYJWtO9BXShg7l/kONEAv0+0uos8ps0r5gO1RRrQpvbHoYAr40GKhvRyhkORhC9xNUFPuzKsnakYt", - "rhOpsG6EYuuoXRsS1knlH+28FPS49l71Hvb6W0Vbv3dTLwtvfSyHut3NoqGFm8J7Pm4261bgr75wcdkA", - "9DP1ZLgbwwRT70b8K45mJvLUrKDYSe/WF5wTVgxeKxTYxj5k7b0z5tmVOUoJ5HScGcwkerfobpxyRz5J", - "mzjmhqT/d5nXcd/8NH83bMCrWGwrJHoDjvDGpi0ssaupuI1zztV21tluMq5ZiM/Viom4HavN23zvjP1a", - "PeTO5iIuWVitcAx18An7bGzd7MHVlof6XXcnLp8UyI8NxryHmcuBnAYDLDMo6+0Pd0sPX1r77kGgPPdr", - "+DsXKqvkemPBcrUKkLdyI3HcuFf2Jyx1T3eRShe7e6ncEDEep92YS+tHJSEJbEPmrJJvr/xydPJWXElu", - "DlXZXcMWfyZypMlUzfoeOFDNdtL3cD0Pfg2b8pF2JROEebVKkTovCXLF4IJGFG818TaUuNOb7CjbzSZP", - "1yklbCU5w3/hWwnLSnSNHtQ3MpWtbuMBRSu3Gs5O0dD0yh5feqPKJ9vNVSMY+B/TaButX9veWE7xEo7T", - "aIQHOD1m1CycvuWt3Udz9/q9ueApzvrX3n8OTk+PBx7QbnDmw39XsxykkmNALTQIzWOKVmqO7a0Kwv3a", - "e2l4G10t1fQU+vFLJGRc6LVV9ghZQXR3pmkjtzmQIU5cFwPwy4oSyNeMwZ/QHyE69mPnC50KtqcTxzNG", - "dfoMEx988/Tp/pD5eAxUD795+rRtmNBKr2VY/zgc/OnnX7/qP20KmdkcdXaH5ukbWmYiSuGXflijiQ3O", - "5+Avu4sbXqZn9qBc+uaHUT2zxH4tsnyFZHzy+k20HYSVZ4ISRrxJWvWbu6HM1c0+I7V8xpVc5auEEIPb", - "JabbnTIaO5M2oLVtYN32k2mXfipzb+6tLDDyqVt7n+1UfKNnHY9DIKzf9AnYdLrAoCm++vT0uCsLeQTs", - "AzEzwloPNrDV8Q+DKLFGCJNdy3voM6SWSS0w/NtHzAzZ8/AnUz7J2ZxbNhFCVevELKNTmWFS6SOGWWHa", - "so2+o9kc49BOaC736H7Q1N0GFMHairXAAZaZIeulb57R80xkGe3Y395CUCIBuju73hVC8gORoVXCaYxZ", - "BDGVyYATET9CCyKbQh2hptokImW6cAgcQH31ATiCMvZWZgO5eyhSUFqWikxOhKG0K0o7ZmGZ5sKIoxCo", - "eb2Egg7T52bL0Bem6UbQA2qL+9yhLNH5MvhLVc1bNGRVGR5LEOUOW02NnHqIZJ/N84zKFISgJy0R47Sw", - "oozQxzBOStJpdOEEc4ZPpzJhHOHk6XecwpCd6ZQv6Rs/HYARSfRigaAHZ5iqe0iHoE9ribLm2gEOgjGI", - "Vj/Gxk4RvGnMtPFffLfMubXgKTIO2BwnGV9eGQi6ZuI61zALbtnYx6gNlbjyre/96hf54/74iEywFV6D", - "g2hc2Qmu7JUwlklCEyFYE6cTnXnYB6msE/DOMgXN9oqb1KeFdToGZeP6vk7FItdOxA30PN+UQZVArmLC", - "+SA3UJo4VuQ+Y7KgxMRVmoUyPKUM5uR7gYiRtNM8pmGMQumsTJUlbZnCB3MhSMdsYS4pNVFESvCkFvEw", - "IAeDP+eeMR5ohTbeZ3n0zUKDIVEuOMQa7uYhkSeJPbrzRvkaiW0iWKataxKBJ0WrCLx7G1mr9Pt0YYEd", - "BfBx7ajytPZ5obpuL+7h9M4jnx/49A0d0oqYiXSGm2VVSiQ6FeRhNjXChmQQHkIFA8gxUbKt5RoNDHSu", - "QMLqhGdzbd3Rt0+ePCFewlbnPnmpRSH6KOcz8ajPHvl24c+QupREwaMrMVkk+aNzdcmNhEhxOwxfDoGr", - "MX/M3v6jyD6VIQ2uQMJT3nyGMHRW8dzONcmZcxUakupSXwhoag+KfRDTPmU5+Z999itzciF04U5F8j/Z", - "x/1HjEpbSpPCE8eMmElEPKGs8Jj93UPjAEjSI8vsUiVzo5UubBjP85PXw/B3kAwRtwkauWLc/14lOJS1", - "5yBhXGFf6FT0cWH7OKrEMz+t3USnSw85QTtghC2yKKZwP8qtldYvoUjPlYdyCuSLUvr4UkBsJSBKmcJn", - "m1G+AW2OwCInKIVLyt7pVAz/aYP0owNCOsv0lQq7A+9sIZPfkL1A/Bl8ewpZiUPTBJSUaOXRkbPlMw8H", - "pCsIVqE0FAYaFAR1B5sHCqbfxD5LDLdzhNnyySFJJWeZ1nlADIptpVpY1EU4wh+dK8qAE0c2ZM8RPoGH", - "9nE8sTolLJeuXAgM7zDaf9uwEni84NbwCVepVuU5GLrwRwc0DsrKZYifCQd6GNO5wrlSTuf1yRKaCqaQ", - "w03FxeTlsvsEdVEK+CkgLdBuBcitR6HKIw9pVV8FuPyl7JG/0T4KagnPrvjSUno765XAcxX3k8O91SKK", - "5KOSyM7Dxfi892jIXtcRx0KxvhcsQNMT0r4048pDpAnm+MSfqrS4qIwIbI78mgZXUqX6KghkBJ6h7EPQ", - "3VQbMfNaHZ8QhM25in5QZUp8aINwLnQulE+DJeI9JgCI+RHlsU5IjnSurMgE6t/+B2lZoeJT97AUnGFs", - "dXWRNlRfebEYWjtXsDxD9nrq+x/QiqC9jwKeEmGDVudQHfVvJv2KxKhDRsH61lIVEiBKkOdDP1KU1U77", - "sSBaNA01wLWJazj/pcuWSGknHLlm6XNPAS1BdaAzFGJAuXhUEZUFEiCBRwmnsIyfjBJXWPJckXqN6b7Z", - "MU/mKw3QqnHa4dfOVtuC3bS+MZh+SQxsBQOvyuAwS3+orVMnbhQ0oBWwqFl6jDYaO4aoyZDQHLofsvc5", - "Jp5j0p2rKKZok3zu90hZekqS2m8O0dIzsN1Uxxo2Ao5opX2p/rnyVEuT1oroxs2paWlZkmkr0jVpUq6R", - "l8YqjZT/CFbVR+nTxeIRZAH2K4/SL+EqJqaE3aHtd3xiyxO2pH5c1aA5PGPRBdLf6CL+DHcNi4909rya", - "f53N+SWeHwttHfvzCmnYZ41SpzwsEl0oB4cOrMS5qmjrwbDpz5Ggszw9/JYItCo37TMfSI2Cgo79l8dv", - "js+O2bqqp409+BWG+XHI3tVH61F8XLzwhCTJSQlkTHIX7itwtD+j+xUQ3LxwFuMRcX+X2FZsh6SU9NtC", - "dNB0EaGdFaWG+YIs8fdxD1nr6zNhlDSMA5SvZvCZqIjd6Svtt3eH+RJnEZj0jVxI1wqncxYk8wrVl7wy", - "EUtN5MNyYQaB9zJo9k7TxZVDR6zgUxylV7DWLzEdQXWb2K/VTPpGkn2oQWLgmeLRPKHAipyJQCaTJTt5", - "f3rWwPdi3TEU+lvfMHufps8m+rCNtA6nVjnBu4uKqtm4yhnfdDO9LK17eay8EWBmy6rAfhTV/CD7o1FJ", - "ozRFiFWviShvJLOUexK1vUgXV9wGEI0h+y6CG6/2VjuAmdOatB4YOp5iE3GujCgsQH7VT2d/H2NBCSJd", - "JvbPvWobjJ9rhOuNw+QiVLHz+aPhqHbnKfEY+4z7M3GXhWG1dVlJIfuvQhT+LEKN6VzR1RAURK38xOK2", - "vPbasNIwP7xrPcLlGzk+eRRUH8K6pbE1Rv0TXMoa0XfyD8H/bHpQ3I3R4LBvDOiHWTUQTP21HPpuey6P", - "67LTu2Qnv6TjqDJ9+UgxDZKnq+AhqkSp0+7feEKlYMnuLb1M7OEzKUu1EbSpSWVSYePL3IJonjy5j8G/", - "Ivvd5tF7WRhNciH9sUcATSg5Cj6g5YVDyYaw4ko7SvrhjFzV4od3nGI3vEVV7JZZdzu0p2ub8yu1lbBP", - "sdS9UjZ28XlJ2w+hjbbx58/8CrG++/xW2/+r/wP9LC9klm0lhR9klnU6Q8uWd/eyvDcqg9H/JrOWvv/h", - "i4xzBfEjZ4pnhJof3IVuToMEHL6VCj9QsS+WDmn8D5R4d8H1sJ6g6Z3912BCyRPughzpCa/VVTEcHFTq", - "vqnxnk8/mkTTwed/+SKRfcIF14Y9ug0xpLKDroSlvljJhMP/zHoYDaFND/tu6YQN7tRfrAd1eV4y6ynm", - "VpSpC7fuWL0i2emyQk4EHHN5FMrJjD0+9N54NmYaQKR5fPT/KWbEoly5/epLuGV2zg26f9ligR0dMSN8", - "AQoBlqoQrFCI4VK5L6Wach/5bIPct4G2VenoDXzITgvEb9fTqRXuL4fexRQAttElDM3CYibRUNU/Vz5P", - "LpZm2rA33LoBuhAPXr8MXmS5EZdSF7bi7EvtQvdMqlTkQqXoxDA8V8fXmBedwDXcXJSLR5MZsuf0iker", - "bxnPrGbCe7hBaaEchiyL61waAZkvzv4rrIS0jF9ymWF6Kv9oxrhzPJk3J7ENHALOLpuc5O9E1PTX3Ylx", - "jYgSyvWU2oQJ4XKi60Z1s9DOurpuP1rhF6m+TbAmE0zN1WL1ov2tmbxi6IZU7punWyOJd5hX3St8yCAX", - "rQUaSkQqVCLIgduTnNXlnb/KB562iLvc3PtaQxvyMjh8xNmSE3s53drqfD5n/Eh7UK2jW34QcRW+z+RU", - "UEbAh7i1e4tbi7xWOWO03wDrUmHMznEHQM3oHXxQvrY0K0Jkdv0Qyt8rHnrsZXvO5lWO9xU/n337MyWq", - "iFbxcA5irBCshkgZ5BzWO4V0VejCI7S2XpcChGuVNDaGOr4uw+cjlm3YtuBV7nTEYu4HhzTyH68MDZ+j", - "fCIzvZDOBWeYMhHmarvSxnbbU+rhedocrMgHvzwf/P1w8O3g5//xbzfC1MO9OFjkT28NolcSu9/ZmsSN", - "vw5eSSXtXKSD501hKXIhrOOLHPYiOvebStNUecj+WnDDlRO0DRPBPrx68dVXX3073BzFVhvKKT0g3mgk", - "/vHxpgOBoTw5fLJJZkjrHZ8kpvhET/A+yzPBrWDOLMlvgV4768v9AbkJvT8b3quL2YyQmiFDKjqTQg9B", - "OZ+IqTb0urAk7iknEfWdxw36zscvGO6ZkmN7bQkBge5EWGXSulZBBe4KtNni9k4ZEeNu02kWeiOc5TXg", - "uDWOhhHSY34Y5Z25aZCuXk5+x4VdcHPRHtNA87TRF9TnwVVE6x4xiKvgGRmbxZy+U6kwyx3RBDcXwoSc", - "/f8kF1wZoKa8wvn25CmcCcmc506YUGfdH+ctNxf3rbDU+rhHiJodxtBmYnmL6xQZ7Q+jGj1P00iZRCs+", - "qFKqQRDzJU3uzht4MG2BSbpvMqx3slFtfrzpCPSH7BeYqQ1XgHFmEyOEqsqY9+CJTHmVwzRzYdjrl95V", - "y0cRCUOpNH3kyk3oQOebyEDn908FlT5ufnfyfhKfNzLP6byuAHbfkDzbHn73H/ySe5dUDGIIUabKxRAq", - "H9HBPhyfvBmy05i9n9J8z0WWH4Gb3ng8/qdFi2c2hC/39p+xtv8dHDA8jRfCzXVaq3XeSzKZXJz3mqof", - "HLBTeJF1hRH9mKm8Hy46PumrT5Nbb3Ut0A56wFGj8300U/ohwZSKw8Ovkv82GLDvjv/6+h376/G74w/P", - "z45f4kqwt8dn379/yd68Pj1jgwEWFpDQBX48YuPY97jvPyBMTvwkFtK9huC8MVT6rkzX6YzOjtgYMqr3", - "2Tg1XCoCf4KPoDm/0ga/gM8z7fSPJoM/IaoAFCz4mwIc5URm0i1Pfcgh/IBrC3+ACnYG8dx9jLDOXqu8", - "wA+5AU8CsYS/bWJ0ho17n6BTFCqhMYx+5BMcmI+MO+MTrHglXTL3H5S48n+hQ5//WyhbGPFB8Mx/Iadw", - "V6bQ8zDVt9VJv9E8ra5BhnH3lW98+O3rNMNl/idWLiLIM3yaO5f/VThccwptPGLj1WDOcT9+V5JL5Uue", - "pi8K6/RitTS00PwLuaWWv42r5HX87mU34jpXnk4Gnk4CtaKeWJraMUKd0MmyJbKEVjHcfkx+XxjiNjX6", - "F6HOVVO4apJJoVZs+NyGGY2x2dDm0H/Z915kID0TnOy5wrBXnqZ9RD0gDqXlCKMfrm/B3v6YpdImYMez", - "GDlbiboZ//X4jB1QlQPnVxqHsx5Nuz/2kZpj8l/3tagE4Ha80IuFVgwIZwqvIFVZxvGi6nls77wXck97", - "ATNM9IKkCBWs0OkefJtodO43QrC/MCrSyJiVwplUF+wvWGeodCrscCpVugd/sr8QGTD4MDQ6E+wvf/kL", - "O+9BnfMeg1+ffEP/Uhl0w6Yyb7WpZbIZDoc0cjlle/8NWtj3Ib9KXDE8iPaoZfT6m4L+Wp0qypE9rPfs", - "XIXRI1hqmOqayNg77x24RX6AoXm5mp33+uj+22ePvzk8LNuui8e9X6HVjxVZfabzAWXKmkgFpOaDWpeK", - "L3xIkVz42MqFTotMRPAE/yRohH9B8wZkOik4AXlAHFjMRHbJs8JnCpczpQ04ssPQwhWMICpK8b43HA73", - "x3187tNwBHkSxzejFcFPZYfsRCoFyeUxozL68XrmKuMCBok2YsxynlzwGY3nXK0/rfklYGOa/95+4Isk", - "zYETcqMvMQ6tUBVklZfiEnnOE2f0uTewWAsRonAz/ov00kRiGHUZF1yBmRiyD8IK18fvvKd8P8Y++4Dg", - "Pnv//m3fbwABdoSs1ymMSy8pOtk6itpJA14mfvvix9cvn9BijmQ6xldM79pKO2WFkZQwHkSdtEyo1F/F", - "V6a+GoFeIrLEuElAjoEb7CXPhL/MmwI4FSnQX8irwdVr7tjQ8vOT1/YZkzgCYCjLVTrR1xuj1bys/wB6", - "3P3oyZUealf2uqr4H6fv30WAgIlOpWcIDJUi4+Of2Vv5XbDg0eoipDVdPM48iRjxT3wv5HD9tHOeiZSl", - "XID4Dc3juw2arvH7R9Y3rcRVJpUYpCL06msM4GsaCuVLU1oNkIgKMrI8PTwc9j6ln0dtUbtF3O35kDuG", - "Me8x47vnif1b3UIff/V5nXnrF4xKhDgqOh0DFWzCM+H0L8JoyEEPQq/9anNi/GOpR1bCB29oAaN5NINW", - "+nDZ5SbNcNWn7Puzs5MImERhNwgIEQKAgHwRnkBaaPIKrONXkHNSOjYRCS+sYD8qeWH41NGvKzGuUBbR", - "NdUyErsXHn972xjiQ9M8hZmf6b8Lo3tdAluw/MDpAcyS+bVK72RHS5CkbBlaxnUVYVUrS9TZblDdWqE2", - "7+wHYZ02wjIFekzGbG2y4TpYGUWfwJdK1Kf6cOkdg0KN00zQllPd+PDyt7dMaZ9alCkhUutfW+YiS0HV", - "uRCNMlzdfveEuqfNo4Zvv3exSCeEPn9FZLEWS7SayllByzZkofDTw6cIDRDLyRDVTsWbT82/CncWx3OP", - "8j12Ap6jjU7GZ80TvKnBeB2Yr6X9bqB8Acx+RWhy4ySKKspMRVvWulVoS/Q9SGErmBnMiijpK0oDBe6T", - "Gpc+C8/U1SbIq8PH8wdascI50PB3Ig52SrU8jkUcOtB8WBUge89fHsSRJZngxgbAt2bC/JYEw9g6beAa", - "45sYwyioFcz5XCKwIfQCYk5lRvB0WcLaUwvP1vuDtjIxhcuKX69GZznYxzrB35uCGLt5geP81J6zN+a4", - "z5dl7TMZ/3/E+d5SQDShdp4Kt0UiBB55cvi4zp9XnBi04pBT8uqziEDy5PAQ6qEZxQILZyIJ3KBzN5Dq", - "aBXBkJgPWq/KkT1eAqlgP3RJD7iuVrgQd4w3UC8jglgIGtN+qzh4FqGYZDxTvbqwSSb9JmVI4T6fBPnN", - "S4y7fJq++YCscF/iK+Tt1JSacllJkdF8LXitvF1BeX/36ChRDoG8dvtsFuBMqghVKwOtCrPDEhaJW4gG", - "FCkT6lJkOhflJcF3axlPg//dk8OnDb8HMFu2p3ToPvjkaVOWfWRLkSRtKZVQZD09PGRkm5Qp90BoaClo", - "5vFJJm2pKZBv8z1F2VBf2MVnirIp5+k3qTEUHrcjp9GiSTfsaMINHiK1/bYwFZWIIUmFJjgJbJAniciR", - "vApX7vRmWntGZ2MYyvDmvF7jP78THVhid3bcFojjcdfwdbjuMF/2TSztce/w4Q8POA9uuGBjmR6xX634", - "18fzcwUO8Efs17BJA6AI+P78XI1BU6DdYQqTt5Ft0htkBwuttNNKJmiaDa8APDHa2hVB603MgJPcFFij", - "lmVoTRkiBMyJfAjDpkCIYDKiaQ/ZSwTbhEFRMDGRxIznNlyTxjIdE0zqUYDEi8ET+Ju0lCMU0ZgfMz73", - "YDch1mJgBSgUEp5HaWXZlTAgSsjMXUYTFQBtOmQv8G3PMjtHeCxnEEJxrTV0PxZOJA7HO2SvEIezGiHl", - "dauVJSM06thteZvzW0VPknhZFAT8g6N+hv7NbPw/KbDmLzzLxpRxr9aczlJhXRkGECgcQYDI3HwlYb3n", - "PBcBl3ImlDDwNlKXhOMhe6VN1Bj96gl/PfW8S7DxhKXL9qA4wdAKY1lhfTIonRQLoaAWPq6P9/s1cT4G", - "Kh4jzWmziAlXFyGd1NhrSv+Ow3qJhUmo9SNsJvRLjTdJeoqOqE/PbnNC/1CP3ZGW2To/Ddl7fO8yzAqV", - "ssOG/Qjbm2sr6TLQjScR/ajGWPjcRmwkgM2Mf8L2XXGPst8WpzQmuhnTwYuv4NSxsBi3ZTUKJDDNDmL8", - "UtldJjjQZA1NakBNwg7NpXXaLGnpbxnL1F+3vwDh70LwQ/YBRkUsDa+tlnHHHh8+efoMK0Ri5hVJAIxn", - "CzPliaDnEgIVRWafGcFdwHx/XJnmSlgArUhz3FGW9X6+STTALSK3Op34bzocRl9chpXVGcCOUjqGwalQ", - "jkUJ0OmAvxITXri5OphrfVFJ5LWS0A+RYLXq+4szIubimzCd4kEMsplwltwQZe7v6yFfw1jxSznjTpth", - "YgRGwfDMDsHvh56rm38nqLjgzwHnLapNyeBCLFmlYHwOJ/P9Uc0UOdNlinhYEI1PO1HH10bOpIrJISJe", - "bMhvmfg3oTBNny5CLcm4UG+1xO7Gia/AFVdemR8RLLkEpxJo1ZtUToy85E6wC7G0jNJJCBViLPHV6Fyd", - "FcaD8EKUJrosWjxRwwgtiZGZN4lCVb8nMHKH2VjKsrRP3syAGLT0bpIJ+Ju2fOX5KoJ+l08MHvs447M7", - "SFyxNk2FjjbW+3JAtXL8Yeg6FwoFHxCzSANi8DJC0cJDD/2Gmy8Ve/x1DEWp58Ig8woUDvDHqr+yxBQu", - "MxOOSU8SVZqL7rWImzVk9cmUELyHtVcnDwVYktOPH96wvfEPxx/eHb8ZvT0++/B+9Pzk9ei756fHox8/", - "vBnvkzs3kpp09W6m04B2jk/NIrUt9qCfxOQ5SIHvQQjczy2x1sUnvh6u910Xb9/7XXbiN5GXA7YQ6SGM", - "m+Qt0iJZDPR0uoOAB9c38ssboN/c1ne7wPHRMZxqUy6LmFMBdWs0rLx+2ccIA5vzRPRJuxWGWCLmwFgI", - "x+GgbEaOJSdJckJEv6T7fMxb62wTeFBInOXXoJLWww7vLkKpofUOXhL9FttYGfSBW5KyCWwJyNvKThJc", - "bPk5SCwgtgA4pA3kiPKfhgCLX/6GbQR3lnCrhcrsUvKKB8iw0sRKJSgIOagwKwp0X1hM78UmFW8RX2fP", - "CsHG6OA+3vferJQCEGEKBdwiOKGQkD+QWOQORL/hy3Olp+AuLpWsXGBBtHpatf06kbK90qWVK6ZDWlDv", - "AEiEtO/TuYTZTAtF92MaHa15zP7EnfaOikP21veK4gZfJV10b6wca9C4ouBJ1LNs1dNWF26gp4OIdksl", - "njGErY8XTJyVtD4DF9y/E+Hzl5wrAJ+1DV2HbFj4FCIVa3C9pfNZe8s500pgV+TuSyYnKNcPWPIgMEBM", - "YMtpip9r7penwp1TXrUR3Ooou2yk4Ii7kQR9JKYVoBmWQNZUvlztZ+cqvDtr459aeJoG/+KQTIRap+T+", - "vmWtBBirwscy000JAtN0nj4PjuKr0myXQ9U7G6PoS9J8ROwDn6oIYZTxXrosslKv38PrNJSMq9E76lWc", - "l+E+gozTO+r949dzxdiFVOkRO4eOznt9+Abp54j9Wphs5CPA7RH7R6Mz9MG/n/d+/ojVYEmPGLbJcDOg", - "VdDNRjAHHKjvgLGKxIJSOJmQ3qE2pWGsgrmRTpH3jtivcF2CmpRSHvyKeZpKYtSTmNPev/PT+Ohfz69H", - "BDTJ9kbYbp/9irMW9uN+9Lre83PBAR15H+d/2r29skhgmiGW6bNfKXHJ6/TICxf7j8Ofh07nI/oB0I32", - "aTTwn48/n2Ne1R5Izu3bXBGzt9pqaOC+9hpn0m2zoSjN7A53mXkxvaGNvFLzV7+5sRhdwM9hV2LGWVwQ", - "P6efNxFTlXZ8w3UKqe76x64A3E0y5TPF2+6oPJXqBp2DK/jDMCQulSXDMMpwcZUtqWxFy/rCXkJBAbuZ", - "Steisx/8KtONeQE+YHANZXeqKnWTZU1RH7LnqnKSxatzBfQh+jFwlYiMgELqJ9yHSlxTSQidULu2oHVV", - "0EYSNwLAkZ/hn8PBtz//+uSrj91ARxqe6ip0GJIFDD8rticMAfHnVmlkNxKhiKZNj+SXmDOQAPl54uiB", - "rpY5UAZEGnr50DobGTEdsndaDcBobosJvAWkIsk4VLmk1zqK8QrZ+0ocMGl88j+ywuu8yLjzBheEQYAz", - "VKrZCNulR3BCshyy95RtCdo9V1COvKeZE2YhQf8mCPaqGuxf9bzxkHL6ldeNKifQoWAZn+hLca6ePD1k", - "P8jv4vhDAohqDlTOnCkU5RakrmMWqmgPkwuBYGB+BUreOlcI42fpRciiibZMwla4RC/EqFAXCqyAoBeT", - "sY8MRjbq0CuI6w0KJ21yjRHvyYLz9sUJdbYhcATFO79iqwEk6NJQiR55jCEeeVZY9hQ3Qk/LF3m4AuB7", - "p48uiWElvU9sN/IzpuobIjuC6Th6A5Bhs5SzKmVCImWVLEH31AqP4Su4NmWWwDXSH34Z6KBQ6+m97cOG", - "fAdlIQDR5KqPbhkSE+n5CzzwnU+87XMb6AlyZzpcEdNE64zHoFSR3lxUdzO98ZgrFvih0pmt2uMmS38L", - "Ros33Jgw8eqSicVEgObkM/8pF+zcbq4t3q3Isv5ekdcFvgN6Ju2HF28f+rfQSjpt1tJ8QvA39hcyTdLz", - "gRFBmThX0RBPcjokzYHu+6EafRUGzMJ4oarwSXWwCXRTWEs8AcYH1CkrieGiHR0WRJuybXqkwmFWFtHN", - "xYKSGGEIlj9BhIUTipJAop+Kty/4NBloDOL/KkQ8KKndeIhStGLLWbtiZeqfK3xEKyN04XDy2VxpmfqU", - "MAiKRSNU07x8kGdKqYMgA2Y5Pu1TB4c8q6u5g1viKurmi43+BMfXuDw166Lfjg2ZfgTVGlGt5nQ/eK3r", - "lO/nrsV+Z8NwU6Lnz6lcvvTCqi49vJ60Y9K5jx///wMAlTv/+4EABAA=", + "H4sIAAAAAAAC/+z9jXYbN7IgAL8KlnvPsXSXpGTHyUzkM2c/x5YnvvGPPkuZ3DujLAl2gyRGTaAHQEti", + "8nnPPsQ+4T7Jd6oKQHeT3WRTP3acaM4cRySBwl9VoVC/v/YSvci1EsrZ3tGvPSNsrpUV+OE7nn4Q/yqE", + "dcfGaANfJVo5oRz8yfM8kwl3UquDf1qt4DubzMWCw1//ZsS0d9T77wcl/AP61R4QtI8fP/Z7qbCJkTkA", + "6R3BgMyP2PvY773QaprJ5FONHoaDoV8rJ4zi2ScaOgzHToW5FIb5hv3eO+1e6UKln2ge77RjOF4PfvPN", + "AdrzNH1RWKcXP4nJ2xcnZ1pnNpwUTCVNJYDg2YnRuTBOAgZNeWZFv5dXvvq1N9UmESN9KcyVkU6MFF8I", + "m/NEwI+pmPIic7FrfXbPnV7IhGfZkhmRZzwRjGcZE9fSOqlmzMGsmFTMzaVlETC7km5O3024S+bsai4U", + "c6YQw16/55a56B31JlpngivY89qMcu7gaHpHvf/1j+eDv/PBL4eDb0fDwc+/Pu4/fvLnj/9WgrDOSDUD", + "CFYXJiyouoD/4Jf8FD8zcZ0bYa3UMFvumLjkWcGdsMxpxpnSaiAWuVsybgxfMj1lCe4/LpKlYioV7riF", + "NSz49RuhZm7eO/rzIf5vbVIf+z0j/lVII9Le0T8qa4yz/Tn20ZN/CiKD72C/XuhFXjhhnicwYNdTXzk6", + "v/WwDg+OcYSHCxbXIimcYBaAKyfhjIe9VdTxHdb39b1JhREpy6R1MMQ65CE7xj9gv63TuWW48YJNpbGO", + "CSAIGFA6sbDbyKe+IbBPC6leU8/HcRfx4NY2PqyhcbeNvrLCPM/lC55lx5eezld3EiiAkCY18hIwZi7Y", + "hPr22ZyrNBMpmyzx+wthlMgGcsFnwg54LplFFnMUz2EALMXoLOxan51kfHll5GzuWKJT4fdQatVnNjFC", + "KDvXzjKuUpZkMp9oblLGk0RYO2QwdUvTW3DFZwKn8be3TCrrBE+ZWEjHxnnG3VSbxYjncgQrGg/P1dqJ", + "J9yJmTZL+FuoYgE76Kfb+3kNx/u9lLutzK9hl19CtxrddgCAPU+px8d+z5lCwXTT9SM7M4VgcoobATNk", + "UymylF1xy2IvlhYC8NXKXwTL5EI628ydXAP+41SYkwthHV/kwAJ/VPKaLWRitBWJVilCgw3nrnfUk8p9", + "87QEL5UTM4EXDn1T7nY4nobtXsFsZwPAfnlum7lLy0nsxlpOAIWBJHK+zDRP2VQbNo5oxQTAtevcBFB7", + "fSvpQJktJgvp4FycZmPPREq6eKFTMe6zhOe5SBl37M+Pv33CJksnLMvkhYBBzZJpNxcGWrkC2BNt3JA9", + "Dx2B5wsmLUsKx7RinCVzbnjihGETuIa5WSKZCZXixTYeDof/iDjz83jInk8snD2suTomLBQlg2HT/ZQW", + "9ONo0YBMP/EsGySZTi5YaMc0IS/xFgMzWcgskxXU8mOoYjEhRIozGMkGkngLt4FImdGFE49sOd8+3tsp", + "48TWiFnhd5ZJZ+MU9sRwNmTjM34hTiNPGvfZ+LjxrPYb98HQXdY4Q0Ar/zuTKVxKUykMmxq9aGGsofVC", + "pmkmrrgRjYNax13RsO/fn52dsCB/M2qF/HfYQKgrtFdZyMrOx/Hqp76BHIEWTx1PLtan+OLlCftQKGA0", + "Q2xyZngimBG5EYCGKITNBavIOUiZFtoCmcCP0BsvaUWkOWSvgB1aVljBYATFFwAo0Qp+xovccMRqN+eK", + "WcUvxCjhFvnlAsUKgPtibvRCsJfiEqVTdmK004nO2JU0ghHra75jsuyV4Qv6tFmwwNVMsXGfAeqahbaO", + "hIia+LAyhM6KhXpHtLE2yN+F0YMJtyJl1JARFaHcKklMyaRqxIN+b1oovLff8cVmiTM0RGLqM20YCZiE", + "mchBuNJqudCFjY1tIwrDbDqsBpo1rIVaN6+GfnudNuMefa6QY+PsCpOtd//xwxtYMqw9cDMPbSqzJkJd", + "obDaNlfmScPVtqRfP+8mUquLiCs32hoS5nQTsoxPRIYHhdNHonJIgcQNuV2qhCW8sKKZ3+XchLdjlr2f", + "9o7+0UnSKTnCx5/Xbl8EWZsMYhJOBb+1w7XNrJDcRkaUu2TOX8x5lgk1E69fNu0N/1chKhjB7JwbEn/p", + "4ieOrZVgl9LKSSZYEgAO2XPFkIEPZkameFEnc84SrpgRzizp5cjZ1Ag7Z47bC5YLw7hzQDp9ZjUCHkeI", + "I5mO2YIv2UQwbq1OJMp2CGZRZE7mmWBjAIQt8f63IBDkRqdFIgx2Rm5qLgWTjvHEaGsZZzmI0kaghEMP", + "WBCx/RfSspwbFzEbsDxOiolcWrhH2GvHUi0sU9oxqVKZcCdoWRoYHbABbSodASUygWIEMs41hGo5qQ/C", + "FplrfcDEgwj7HQc0gqNYwBmwVglIrwuX6AU84LxAplUi8Bgq5/gTl84ThrR08P3apcFpmQYn1mdOs1TQ", + "EPQ+AX0E8PZyKnHcsZ/myOrsUoys48aJdIxy2cpvBH7MaMETgZt8KdOCZwxbGJwGPZ3gpHWSFKbEDJTg", + "A6sEzCqX2PVxRPO57eNow4E+vJVa30oBGUp2QAhx27eTP7odWOXqed3gRRUJofasalvihmeW7xE2qzv2", + "nUGPj/1elbveEH9fv7zRsycK++VuwMONG9I24oNklVH1WQLMBFrQg8wTvr80AN8mwl0JUeep5cOp7X1w", + "tjJQYPYN19oYx0zHR9gAbw49wSslXVlOkgluGJ+iPm5lqkP2Shvm9IVQgVVbYrALwZVlvHytUCMgUv8S", + "eIboAh/sgKt0MNdZCtcZ9azPAeen+KWcIXHzK74csvGUy6wwIqwh3I/WaXpz05QVKFIzmUhXHoRfhQeA", + "gu71nBcWgMOJ+eVZdjWXmViZjBELLpVIh2wMPEIXbmUGj2zZepCJS5GxK7h9JkU6E6jXBaLeBptPuEq1", + "wjOioyGMEyr18oIuXDiRlFk5w5PfvOKIgVNcM4fLm00ECoQ4lSuJc4RzSqVdSGvhPjUllhQKSF2kw3MV", + "cCheZivH1kcpAr6aZvqKcQP6CiYdSDNWOoFSlHUyy5gRwK4YB3lHpoQsfbwD8U/rNw3lKcQvSSJKbjTi", + "OHfsas6dwPuztqOwklnBTQrkZoskEYJm3+tHrkzrAI5OCAE0Ryfb6/fiOazz6H7vegAwBpfcKHoe/qMX", + "OcppgBq/eRXBx6/O4jjxq+flgB/7vSsxgb0azbVtkJS+1zaKdHnQpK6yIpSIGqX9ADznbr4O/IS7eUfg", + "7P9bICNzxNWuk6yAXd76Zqqx/ooiosbQd9BLIDTc+C0Cph+Y6CJy3g3C5WeQrVbX8SBXbZWrqkL2Peqj", + "Nx3Q7oJUwL5GMar+bPjdilBEh/hyAvxaf9udea4P2MkLN9dGOu7kpfBdnQSV4DOWarwY4K16KRrktBnP", + "yX7a9mjzT8OrubaCpSKTKKLBVUSmxwQ4HDcCh4GbhSsnwo2yJqqh2XDUZkiAO3lgc5HIqUzIxEj2NJix", + "F068Gvv4w4f3H0Yvnp+cvfj++ejHd6fv3/zt+Xdvjsf7UcOvFV1w1u6kVT5b2+uxBzM+CnKDEa4wCjlj", + "YTnIklZnaPCryWFrrZVf1J4Vgo3LzRjv16Qn3y+VKe4q9a8qBEEdhIJVRZBakZGoCUu4SkSWrUgtddkR", + "9O8DHHNFDqBl7y4IAEcijU2r/ikIhwNuQVQTaYNGynshCFJZA561IOnGy7yjpHA1F8Zf6TQGcnocJ70L", + "YWEj/LuWF24nIADfrrLDdc2yX8GFVCkzItfGkQIRlkfIOwRrwqVMqwSNCiUyTBHDMAueyV/g7JXzgqwV", + "7ogJ5YTJjbSCXXIjuXIW9tIIT+8s0VnGcytCRyENuxQGnUMmRXIhHNu7fMIO2OVX+302xlfViKt0BK+q", + "Mb037epjK7J8S6J2oTKJTyBYJk05rpVbNka74bhOMvMg8sA5hdO5fFL/+BWca2EUyPpwbDMhnLAOb7Hq", + "RHv9Ho7RSGANR3hK5NBNyDPof5A7Eu+4vfhsIl112g8yXUeZzrO+T6Yoaz6p3YU7Mgm0S3Z1ucOWSmzU", + "4K/grvWo2y9V3BWlMb2r1Sxr0PjgW9vfQWzB1RJ7WHxQJ1rZYiGMZYvCOryBuYVvUMHsJ0jzq2vVmTYs", + "59L4uQND5MbIS9RDpMATf4JFeIVPv2LWSLQxIiNntqiPD7aUKPw1C8F9r1evWVRmRhe5pUVttOe8DBKd", + "1yBost8eMb6y0gX3qxFekySdjdYBmIGQaDwoW08EW0hryYEj7gPjIJ0leBUaMdVGNFhYksKQkSyIwa5F", + "n/+bEfM/ibzjT7zFtHRrgQfcPQUMG6SSt3SKZPUGYq2ZZFDNlHBjlkxpggk2YxLQK0ZCW0yQ7O3+/chR", + "a9O+C2FqO0d8EI1+66JRmj8vnJ7KLHvb+OD8aS6TOZ2UnnrXMu57gJNDBsj0giutZMIzauC5aSou0Xd6", + "kHufmf/Pk/Tw8bfiT1/VF51wA3PlaQrT7zjbMyNnM2Fe6MWCq/QGF+0pV9Ih9owDzKEjoGPGzaxY0N1a", + "rk2qvHBHTc2l2rDYPsulUuTQN3cut0cHBzPp5sVkmOjFATkYBf+igzU4B5NMTw4CMDH56k+P08fpN9/+", + "+ev0yTfpV99+nf7pz5P0z9M/8ydPJhxd9g+82+4owBjCt0N2TGoJvzbiGNKyhPaQzTlZXxyaE5g2zIiU", + "JyjuiUQidUjFMjmJs8yNvl4eAPal3PGDJM1H5dYt+SJrupH8QY9QrhwlumiSxMnNBebom5MY6s0FfsYB", + "/86Qgj1rUGnAQuQSqN8PzpK1W6EiR3qAjZfTWTngI8v+4/T9u8GHkxdMpt6yUE4n4WCFY//UuH/EWfz1", + "X/WmLnUdcF2gbYOUMd4BQ7Akk/AZv1Ra+Xu9gzycaKVE0uof+Tpcp7SN4PyEJ8jKfrUFkSyTMq361fs2", + "zUe+Q/BXSPNRKm34csjOrrRfhEV38uDChy4kYRvgeBxwTo5eJsj/paW1VmIPHj/5cwNHIOTZIExMeHIh", + "VMqUTmuePP6exP7eCgR472m6HUXQP2/TgNigMtKQvcgkWhWdZo+f/Ln0wrXPGGeZVjNhSmddFKGZETyr", + "wui2GQvh5jqtPoRWeVQjV114jr+b29bKjbHuvPVT2FTa0COQ0Ew6ZuhATcQ8RpoNdOrmYmFFdtlKsvDY", + "pbCWxgMAPPa/V0+6isl4xjQ2HkjNxdkjpLe7+i52w/l1OpYVycmfUQVzN4lPaR7+Qt3kS32FNtQ7ue48", + "5GFSA73l0mvr9HD17XL1hdlhvN2128i/qCnzTT8PY3m4F7+0ezH1lDmaFRuQa/0+DP3KKzFaRT7rRdbM", + "dxqvs9/PFVE/xG73RKatuNvrASB2vRWo7cNlsMtl8MBcvzTmuoE9AQH8rrlSJy50KtwLSiVgT+Uvd8uP", + "bB12R8601uuBRz3wqN8zj5oLCE9t4DWeChg1AOx4+fqkTdvRzulWCOp3wvP6vSuZNtlW4rbh71t27Uqq", + "VF81LttvH6Mma5LxlkjcKBmWI3Tlxz9hj+90oVJ71/y4Crs7P673euDHD/z4j8iPiQq6ceNMTNshXLNc", + "W6RjgEKpVFiitUml4k7YG7H4Ko3+bli803nrLi5vuIst14aH+mkvjQgLnUFuotmnaZ9i9wbFPk0DoYe8", + "FCJle2MyxUOejIVUcgH3BH7g1+WHaZFltK3ofuz1RT4GCjlt6eOCiahQmdRiMb/1/ehvwlY3wICCIYtR", + "ZDQ1lqdD7BBg/E9icqrRdwBZ1RFdfWwmrCuMsP3gUIzpSFLJMz2jvCNSzfqYL4BZkXnmBmNVsiINGaSR", + "k7Pgmh5oAtvBBF6+f3vgc2gwZ/gU/CXiXDM5MRzdl2whYo6q6B89EXOeTaN/etjy4bl6r0TFh6ttT3zI", + "OIXBVK4PsvGEVtYZwRdBQWgxjCzts0TzTNgk3JnetQpj6GlkaVmGbjkqW5YXDx04/Bh8V5Ati0wsMMQ+", + "qW5Xv+xX3o/xri3d/xOdUgoLbJ5k3FpwPPFbzhW0uhAiZ0UOmb+SrLCYRwR2Ds3Y6IqyessM46xGYa7j", + "Z+HGdZs7pAbjEj91FqsVAnlwOG13OEURA7fqE7iZNhxLY4ahQHN1H9JyqsFzFPgQ9F3gHYckNCbKGg/Z", + "MU/mwX8KXdgk8o6M3LRK8uF5bvSlFxLJ341GOSrtu/hlkaUMPaU4syIxwrH/93/+L4PFppT1TS/iHQwm", + "rz64ytk+M2IqjBHG9n1yFdtnTixy9AX1nDPnbg7LMXzGkvBkA6DRV8nPBYb0rlgZT2jNnGUoN/QZJzqG", + "P8gDNYFAVD7rY1iKKhbonAnzYojuAseYa+tzAFW2kxJrLnieAypAsstVk3xnO3uDr1O/zTCyFehWu3J/", + "RanZGeKqBaLfqjPoCnKDOrHfKq3uALztbdzvvXz/djjVSdEB3Eu9eAUt1wHYxOgse62c/psUV6+n7zCO", + "uBPE08auDUMI90pm4jWIGvBHt/mervaqA8bvA2IZPpshBm+Di71e1Do1gU2lzeGFBm28+NUJ8svVfpuA", + "/yCWN4Edum0C/VYXVtwEeNlxE/gzXSTzm4AvOzaBF4sC2CU2emX0YudVHLcCaBpOLgTSbmToHUd5vdqv", + "Ebiywrgzcd117q9jhyZwdqncXIBgcSJVMv8ryesdQZ82dt48DNH2Tcep9d480BnPbzpK2bU+xAmfieEE", + "pJsz/croLugDXb6r9GgA6H29ypSL3aC+WO22AbTi+e6AfacmsN2uRgS2fi8iCMo5WabSe4lPwm4wv2/s", + "2zBICGLtBvadb70B0Jn+XlqnzfJYObPcDWy9b8MguZHKnemTl6+6AT7x7dNpAzBKYtYN0AexLgUhEBAu", + "xOSNnIpkmWSCNCOdQJ429GwawHHjCIMTbjvi52m9UyNYnb/RPO10cxPI2KEF3O6TrPapAz3jBqKxeeLk", + "JSAGftwOlto9r/VqBIzkuRvUF2WXZpBGcCdCL3LK6wy7oe+GQXaceKVPI1AQLbS94dRfNnVuHEbnQgVT", + "TFfo7yt9qkA/RmXHkjKQBg0fpABWYiedZgch7GP/RsCaxMUdQTWLJrsC2SQ13XBtzeLkDYE1yuw7wmp/", + "WewIqJskuyPQ7XLgjQG2Cnw3htgs3HUHt+0FuROktbfzbvPY+k7uDm6ToLoblI2C6c1ANYiiuwHaLjLu", + "Bq9JVrwZhHaxcDd460Lcbv2bpcndYGyQzHYFpPO7gtMg1+2IhKtPmB3nsEUU7g5tmwC4K6QWoW9nMC0i", + "2M3gtMtau8LbKrztCrBdXusKZ6v6eXdQN0fO7Zrgm8BqU1l3h7VB8f/x5yZ70Nvoy7HNkA2Wam889bb3", + "66U3+Voy2FrhQoR7xWJqGVeMz4Rqqg+EWRmerRpdX75/i+aRYJeeaH0B5lO0d8MP5L5VBvj/+LoymsFk", + "2VamAj2PSo+ySpWqo84x5q063FbNcYO2sV27uUGL2673blG0d1DZblFdblM5btQUttkVqjaRjeaNJiVh", + "q56vRUu3WUW2qtvarKKqq4PWNU0tiphmzUeDeqWmEdykNmpTezRqLZpVApu1EVte/M0v9VZL4qodsN3i", + "1m7o63cLRK7yM3SBaPPLUUxc+5qG3reFMqlQFTth2OnLH6qVxvrspMhz4YQw+8F3sPR4bPDaIecYadnf", + "3g67elx4h8Q7cbooV//gdLHF6QK36j4Ttjacxw0y3kf8aPLG8L6p7cXEunvJStvoJlvxh4WjHtdAjoMv", + "WJNzCLltlJ61eA3ft7/sx43n8TL6SHVnEKVflUgpL00H0mcnXJoy15RcLEQquRMZllFJRLruX6xVuRHk", + "6/YZGMjKBj3wkI08pESN+2UjTaeyOycpZ7vOScrfHpjJXZQkLBfWqSrhQljLZ2J7LiN6fWFjy4zI+FKk", + "oRjT+rg+W2AqDX3XXNzMCG6bCnz9NF+uwsQ6EFB7CDd9RFHbR9VIDnxZId3Sl9pCbuciJ44GBVrUDFMn", + "49tNFgt0YqUciJgh2bv9B79kwiBHGQyvVAxEodHIJ9CIgNd8xqWyFIOixBUL41anIIzRZnwUf0NXaqZN", + "2FeWF4ucUkjTWn2qjZjOwC841FX0v9dTHrA9t8x9UWhfLNLOCwdL2F9JXlbZyl6/t7pT1a9wTr1+b21G", + "jYx/zQl4E17ZIg9Z9JqdtD0BXgkqWnjFTVrKwb4PmxQuJN/xvs8i7ddKffyrEAXVxwB3fqbLlt5LOudK", + "JhciDQFTUiVGLLwft88Kge7cfl7oj1mocv7wXXTpJkUFKQOmMnNYNXFCCTF5upAlrvlpA/0xp2F5xMWc", + "djwbsrOwmTA4ebE+84V0qhEpobAI0WV9d4bseXbFl7EWDTIxLNMZHOBhBUy6Z5S9s9ogNyLlsY4l3pLg", + "ky6TefCHj2yPW/aLMLotwGPdl3wTWpQnHQmuig0+32bKlG5i2tWTl6bicu/zGqLnOqHZMEnzYZjRyB/b", + "eDVqoVo6Dc4B49IkokZwnycmj2LauM0NfkusZJXnr7LmyC23XNgNZqkbx0tGtcmWCMlKu4eYyJ2SKlGm", + "t5HSqeiSEQ70kqtZ4aqxaQ61JA/JAn/PeTtKXWbT3bsNk26LQcRzNo0QdOZGLLQTjDpsHe7TJWr6Y2Q1", + "6eRgcKuLoVmH3uGmaOv4cHU8XB0PV8d9Xx0tpq+Hu+Qmd4mB+belSfgevw96GWhamy4dBN0hdeRNdTHB", + "9Ohr2hocrzVuPy1z6d/daNfrI/0n09OpFZ2W1sc3KVYu89QOGLPbFJbrU/ivTzeFP468sMkx8naiwirk", + "LlLCep8HAeFBQHgQEO4yEX3WQfEPrSym+ygPBAl1yF7F+PUdCha0iCWr5P4gkfyhX7c17NxydQW3tOaS", + "PfBzSAUz51ZUL5yONV9C/h5mHawYN4P78wqefqiWtsIhR4v5a3zqlbxw6IRoJtJhPhtafCziE8zuNftM", + "CutSTpheH/9+f+n/1Ln/hlxROxbLgX14KxfiRcWSv8Klde7P9u3rt8cs2IqBCXDKTyGdWPRLV4TXz989", + "Z0bMpAX7RFVHXk2O9Kza+5GFglEwTV/0hMwKGRU7jzk64tiVREqf6Ri8AxraQ3r9Hi9SqXv9HlR4gv/y", + "PM+8CQnvF1TVL3SK57IoMieBM5fq/I6n5X0ayZmhGbGRVzIy4zPOSpfINGRuYt4R0345OC+mvMhguxw4", + "j+JWFrbrpm2JtrqxDNvk7LpFhG3u8iDBPmSM/GOpnJro4A+cbHx7bOktmdSar34nPtXQ64FVPbCq33W1", + "GcNno11ewL42P/QLXow3fAHj0CAMbx8aWrUM/dqJRSVh3G6jL+RCjLyQ7VF45dUkrZMqccw1PgoAA/S0", + "nBXNkyIaxiAxQ95UFJnhj4qMDBlUT+kBYH3qvPYV3DbXar+H89rBCXn1jVQ6dXNj+DLuH9A+rseOFtxe", + "rO/fd9J5n2J4PWWZvhIpbVXZle09/kui82WfPflLJtVFnz3+5i8LfSn2284On7GxHvKuKXLrD+X1JLmr", + "L+UjNo5v0HGfPry/DH/rnOrilQ/R8e2T47aLEOtBaC11AVE2sFtOZA7/DY3ZhVjiYTzPHJzFC2eyPnv6", + "l7fC8T77819O53LqWs/kS0wn3WDUAWsgnAm7ruSOBs7z4vSU5fJaZLazyWS5AfzytuDb9EUV2thBBmtK", + "hHJHIlgAvZMEVnZ6EMB2qsxbOD0yIhe8Kd38XHjVVEgKDVQ3E0qYkDz2QmAsseCuRueVKI8g4m29swWg", + "jppFcg3XIqXIfp5l432flDZWDsdJPRhWfi+y5e2u6cACWm7pH8Ry5ZK+EEsIfYVr+UIsf8zhD8OvfvBf", + "4y0NV8Sd3M/Sji7EMufpZjIDepIxYbsqFsLIhFHPNgqTdmSXFuTiC7HsQsXomE9dcMB1MqpAz7TX0q4B", + "/kEsJ5qblIUmIAtkYorCgA/G/eovqljkPN3vbtZqic7/jYgtii9E2rzRgGHVbNhEkDmfibqOf5lHfa4M", + "4czjKC2e8Qn857kx+iqg56uvQf7/AeZddeNnvBRhGt4BkHJeW1FLVj9Z0jtjRPmv6/71X3itj3JZm66Z", + "Em5tyraYLKRzvrY8owK8zopsiqbFDk/EuxWwmnOU3ZGIVQLfSciqdnsQs3ZyKimc0+omtxru+XfUff1S", + "ox/QJBiForA2KNKiUI8APHmMpVrSNMNvkDvDH+DFAv/1cUN3Uail71e7jSn7VsScIc5uyN5pNYBYKKYV", + "42yMNqy3+hK8nBeCK6JYeOnTFeYVO27eKgJmMrnYLnliuDFJc7SfGBmYYVgb23viB8N3FX29/yBz/m70", + "mSJzvMlb83tt5C9aOZ55p0iGTfsUgo2o+dNcgPam6/Oehmp65AOjSO5uoNvJ0SWXb5GkscGKLI3TPKEL", + "f9z3nz+ITPDqF56WV9d1Byxnqn26gxUah83K8ArMYXKFEX12iCJG593cJqGW+/VbkVFzDR/MjTHghPq3", + "HL//lSTRUhlQPi/26HDpnPO7qf71hYqkXM1gNjwbBfTbiKNl+wq6Dh7vhq9OZo3u5ydCMfit9EP6r8Hf", + "WZ5xJfokzs2MEHa3cZZdxvnP241zJa1rHgZTOVxJK5jRzuegWx1hnTwetLibUz7f0SOjBL7TI6Pa7eGR", + "8WBMf1B4tiZojZTSclNjgxVBDf0DMWfxuO8/Has0/g0SGl3c+PEODZTdJbRgIZ9KYx3DeTAUae5cdCt3", + "8LciuhmeysJueY9Qo9Zt6rw9frBNL5I7G8rfzyOuZlkDGnzwv284+xuIDn9QmXHDJt6VMHkGAl7bMPct", + "YXYc/JZiJ4AcIcjtGiTM7yqq07ArlyraLduovkXEfbEm3u5AHreQe1upndGNUja1LIN1S4V+7XRn4PvQ", + "jr1gIS1cC3RtyAU3S39KVYsID/vkiSmIOncvct+Sj3WQvpsQp4NE3q1EyS0l8/b80p0k9E3dHyT137g5", + "4C5EuDtQpz8ozv+oivN7UpP/ZpXibCJg0z3TRGrCm+E+nT3bOfSD1+eD1+fN9YUby83dUihZK63RSRZp", + "6PUggjwoC/+IQYJrpNDI643IM55gYt6RUA079aFswAxXM8GESn26oFZtVQWoddy4LmCx4RbA5PMLh9o4", + "19Pwc2WOmLtfxtMMm7F9hJaJl2NUJ7zzKH8EP7qG/bhrJ7rqpLpcWI1FVm97U0Wg3a6oSvOHu+nhbvpD", + "3k2RBn4nwes3Y4+wCffgWbwjU9xesfiWDLK5OF0nZtnW9YFxPjDO3zPj9BmHRpSO6MbqqfW0R+saqlre", + "I1zFxsxH96elaqb1llcLZSAd2VyIxkcL/c68yyPDdmgMIzUJy+FLLOTTKqMnPBOjKU+cNhtGwGbBgJTD", + "xNneeXF4+JV4zH7RGtMN7P+uLdO/Pz3YTpdma1X+O7s1ayPseG2u9H24Nx/uzYd78/d6b9aIvfHizA1p", + "+KcZfNEaE4w/421iizyn66QtEJjC/Dv4wkRe6DMDRPcxstttUCYC/FRkfNlYve8l/MImwl0JoQLs/lq5", + "vt+RKq5F6jm9krkgUWcnSeeeL/BrYAKOq0R0Mgr7tvXBnjFSIV4GbLEMohd3mAPWsceuDcViS9SclxOK", + "M4nJ73PuSxIKlXYe+l7ll35vuWF31yzjXfe2yHcYv+POXobJ3Mm+3oHgVpa6vxeprQS/o8hW7fggrz3I", + "a79rbyFforHhVve/xIsdvWSwdCxMFj8Veedr/o8tGJYs5fejb+d5Z5dDzRzPVyP2Hc/3/zihgJtvxlqO", + "pMYENl9ixn+fyKnX72Eep16/V6Zx6vV7gHIdM6FX3WvXtgd/ZJMVH1teeth+IdultAJ0ArkaCBCTgsCe", + "YTmuPhbAIfy74ibdZeM2oNaae+QXs1vVzAYhr35IbBA+Y16D8AGTGnTcthM+E9/B12f6ldF35OwPQIeT", + "CtQtcmlD+wdx9EEc/WP5K6wRwR842z7sxQvySDhNjBDKzvUdsqZkFXQX/tTQ6YFJ7cSkaANHE7HUKh1d", + "ejl0c75I34mJaydUWtXghP6taV8zmbeW+ASUxgJIWjFqc0MBG0dBy+zmQTAJI7ZjZOjdbYSW0qHVEbDJ", + "bVZxvRn+dXBAvcUQy81DLG85xMMt+KUVMvSbsbt6pGTDrwhGg3ZkATRHQzC4goQFnrY3/mcuZpBvIlcz", + "yjRxJSb53eSIghfEyBZmyhPRjbHBjez4hVBl2Ljvv1aXDTheG7drkSfWLq1GoULnTi7kL2I01abN0SXM", + "XahEp4AJU36pjUi9FQhU8wwUQG0T/FfBM+maGIBeoN0P0NY3Cmk2Dg8pB12mrV36k/wdmdduKxkpnt+P", + "XOQB7yIVxS4PMtHDw+3hymq8sjyNtF5YoUHTnbWYu0V2N3fUlqvCT+KP/vrMtBV3yFkBXCd+Sg0fuOgD", + "F/0Dqr8Q+//gnOd7rtJM/Ae/5Ke4xpeSZ3p2d6xo3gi/C29q6/nArHZhVjxJRL5F65XizhLWYnOaUCrt", + "Qm7ykHxghL8TRthMai2OtnqRu9HuUYFCOWHQgdNpxhnB8ah340jB3w+n7gdK3c6y3/FLOePuDuVF5SF2", + "Yctl2wdG/CA1/q7f3oYvROMi3+f8X4Vg2KDCWTZwhmeMs0yrmTD+QS3pBQ2Yx7MqjFsx8kCcLcGFU2EM", + "EIjOZLK8iVLhgwdxQhDWlQqhAaMx7i01X7kWIwCHt2i/62lJcdepP9084VO326ciAX2RDoaGK8pacvNM", + "3BFEi6uov6Jg6UZwq1V5lAEXeJYJE6rBQVljzMm9zKl8ihGZ5ndUnqkw2QjX0GAjOcXvY41qYZ1UNO8f", + "P7wJs8P7C2bFJ7rAPOLA98f7AXlszM4LnVqQp3IuXz25s+dbkAXO9PfSOm2Wx8qZ5d1LBnX4u8gJqz0f", + "pIYHqeF3XeMA0LxxkZ4OGLaoLSfQCt4BnQuHbiCz37VSq7LH2xnkiZHKnemTdHp3TDH3MF++6sIIq60f", + "mN8D8/tdhz1Jm0M481zwVJjRVGsnTLtszhk1xPlSY3YlDByPSsUGuZvajpxY5Bl3YvsrgAfwoUsMAs9k", + "manK/7TrKyAUhRulOkGUHunCZVKJTfMJbZlvixMSi4lI0w4jOT6biXSUp9NNY1ArtseTRFgrJ5nYZycv", + "X+FQ0dzbNpY/w1322J/mfexxBvdJwvMtfk7o+AjDZlymsLXIiELfNuALbmZSjSbaOb1YH+A7/J5RK4b/", + "T+Y7lNbw4DEAZQ34GzF1twZtmv1OP8DXtwbudN7Af3V+C8DNskx5UzarnvlMjDCnqu2CjL4QuZqt4GEL", + "DuQ8F6bVg/cEfq347u64YALe4lZLsKND7a6gUXkxSqwd4QaBV9xmGkFfV9gcaIp7k3sFiHesI0LKt7jY", + "4WmNIHpqZnShNjjxlW3YzPB8LhNLbB5BtB9Ji6PzCZ+FG4J8nH/f9ZEMVxZOeKHTm1U3TadnHsZbnTZp", + "a77XV7jO8mrwktDe+AP++dx+x6345in5r4bvTjF67C50NDfVfnxALdHdCfZe69RBqA8tHwT6B4H+9yzQ", + "y5nSRowSnsy33CpEEWyyzDmxR1ggdGuV6DTKlxvsK1FEpqa/KUsLLbdZz4IruVFKcamA0YmUUYcH5/NT", + "4X4SkzdyKpJlkolTd6d2b9sAvQv3b+73cBc83AV/QOehJmL43WRjsbiaG0jd61uyLnfHBgyHYZxeqGxv", + "PDX6F6FI3KZam/cnZodFdmDGjhtHwV0Jt3cYCWTrgDux4NUuD9z3gfv+zmunm+VIufkI3Y7W1/oKvoYB", + "88wneRHmkremH71tMCxQXWtsEc2lLRgW2RqEw95NgBG/blXbveXXclEsvKdWqb6rhno3mFr5dZuurg4w", + "6uy2wGu5OOssrPHOvFkc68O74dTp/I3mqVSzu7ymItBuV1Sl+cP19HA9/REfByUN/MEDrYAj3Y/sXIXb", + "lS89SM4PrOmBNeVbpK8/CHdaMRA2JLO/YpwF35MU7YSyNBN+Makt68bMXr9Xt2R2zWFJpZea8376H2ny", + "5Y5xRSyYMoJ+WblAgQMK1XFzVgJEGspLtcSH8OAEi9VUv5jMsmE9vX7lw09zoSAX78zwFLZPGzmTKv4B", + "P78w2tr34XvgdeUHZ2TiGj+u9yyU5VPxo+magHXt7d6iRlh7utOG2tj9izkj0DgACqvZTltUSZ1y9Gu3", + "VF/VLYLuX+YWQXayrjtVTzGzjkrNO0S+R77vl8MLISVOx40542Ym3HNQ3INrPn66E4mfQA15DfIWmb+l", + "z4PU/yD1/7Gk/kZC+B3VjYDlbHKnoRafw4umtaBznPPmF4rnoJm298BMkxJsN05a6/DARh/Y6B+SjVao", + "4IGHfjk81AjuRPhWKyeu75aZNsDvyFUbez6w1wf2+nsPmNRWjLQapcLxZL4tkYmiLFmW+Z5pud2pmBSz", + "Gcwx8FYCKWz3NN4biLEtHdj1ckRO36NMWtcpMgsPizox6ITcPtFqKmebYgBpMCvMpTDdx1mBjWGI9Iu/", + "X37f6V4KJS+FsTwbKeGutLkYUTToiJSR22vNUTvLZoYr4FgRIPMAGQGknQ2t3VwsrMguhUUC6ZLM7Sa2", + "i+qtdg9PgwrcXW6xh8fBTW6vLqGEQE5eBkO6xu1OQ/hECaGNgsMOeEa6SdTzTUue+zmiTx5u9C8v/wuf", + "ZFB2CJgrpZADDDI6a8fq76AxGV58W8RuApWyvbngaSasZVply/32pAhJYTeTjhJXVfLBHpuyLJiR45PN", + "GQYmAWC1fohX8q9TanuygWYHzp+kSvVVxXPz5euTNu/GuUxToXbmHdStbWLNQft+Wte+wjgxQLL8VMqc", + "7uAQ2nB9NMpbSlyNrnDwTacCx0ytuqV6+CLf6jpvPZflDc/lS8gU1++1uCb7tUef5A2UQrgxunlwC/Zv", + "C2vxE0HoNedvBfdEBruykApLAGGuvwW/Lj9MiyyjA/tcgeVEfS/peXV/mpK0aYBuQmZL1wdpcydp80ES", + "fJAEP4/qvJF+f+cp+xrIrQsbfp8LFbjSXXJfXYHbjenWezzw2ge99B+Sd1XJoCVLlxJZ4/aEbgybMIAk", + "0g385q5v0AeL5G/MIqmLZH58KZRr9qXG38ljmuVzbsUX4yvoYOYYLd/r04djlYY/3+pLEf5+wVUiOnsV", + "1rOur6vsOyZd/2K2EbLCez4Mu+eJbzThBj4VTo8mWl8suLkIn20xoehoQF5V8Kz6TXTHD62dzpFePfOH", + "tgsJR+aT+/R7F2J5pU3lr1EVSJdDW88D0ZzPLmvOBfHFnBVlrICdxXQVXXenokhYT7tJzYIma0Wf8AUF", + "CYDWAzAyKD2Itca/S5VHp13TyupMHBujDTLP9Y17Xn2xQmMmoDXThhUq4QWoUstiT0xcJwK7huiU44V0", + "6K4N++muNEuldVIlDkUaqwuTCMuupJuzVE6nwsAWgTjI7Jznwg7Zh0I5uRBDP/7zk9cvgPWkbM9/M6QZ", + "AUOy+yw3Oi0AJpJjHytB9UFstX2UgKzjycXIGZ6IEnac9tnc6CvF9uLa4i9V0AQzk0r0WaKzYqH6fimj", + "wmQN47ySIkv9/QjEmIAyPoid1BNlLI5SQKPYy52YabOsilF+/Y0nnPqXTRcl3CoW4KsIhBycWEco2POU", + "emCqSdhC11SP+8wUgkmv+4STnsLuUDnx0IulBe4PphXN5EI6O2xUN7sGKwVOhcHBWscXOZOK/ajkNVvI", + "xGgrEg3iVDcpPVQ1WdnyEaJc7+dtcoyzAWq/PMG4sZtEmsYz2VW9ij2DTuBj/9cVnAKiaKD4LIu0Hp9j", + "LNHCJCQH0lrtkJ2Q2wRakuhFRAvz1N5GuLD10okFjr0updIX3Bi+pHcS0FdT0gr4nlFC1mC0pQYwF0OK", + "3pIfIXohdXee+ApXGDZiCN36jY+AsIvQia6GPuPZFV9adt5DDDrv3WoX1zavOVH4G6nE59+okkGuzxAs", + "GN6Y4Wc2lZm/QN3ciKv6HO9gYrW0XIFRd2WYPMtOoRd0R9paD3MtFlwNjOApcnq6ofxVZGsahoAkV7rI", + "UuaT3qOq4ZU2rHbF7e3TJddHAFNprCv1MRUC5Z5ECUTDVdb3RhAxldd4WdH8FsJaPhN9hgao896PoSey", + "oSM20Xpx3mPaVH/bkwoLMEor9hk8Jnzj6/JBOC0UKizOezUjUhvPrCswA2v8eY05vtGzzkJLpmf+9Rel", + "hkzP+nF/pZrq8tMVN6rPhEuG+8PPcBOHhT3cw1vv4ebSond8C9fO47d1B+90lW64qlqFbIDRZzEPr9HF", + "bM4KNZUZlWBFdkta6CEbIx8ZoxVVF1SDiNVEJiJCy6SyTvD0GeNZxvCdwlZvTAuisuCGzYURQ3YqSAtq", + "c5Hgawt5YJFlDHCikbHcE29/hYx39XjWT2e4ldUFjcF2llfDotbXLXG4YFpEoisVNoElLrSSThumsXhu", + "lsGuDsLtScczZCvqZ1LD9SlVGb1vyhB7JnKdoJvA1Vwmc+xAM9FJUpjoi1BH/PaKmHDKq+Uw8YUoVWUy", + "zfJPex5ogNqeBLrPjLDCMVgNT+aV1TWOo/jlyIp/NeR000o70iRkSyZVYgS38KyvbJcFtYNKgkjWp2Yw", + "L5HGCTidewVwpWfjJnTgnjfQVgcKo3EqVofG/digWg64uaZbZnvWoXDE4TawlXXasFD0CdvfNGK4FzpQ", + "NhkdqMgkuuc0i6FGZOKSK0evc2kJlZ+RExo0gJ2pnAnQAv5GpNMPWqWyrfds9qS1lSlUDqu6sfUllyi4", + "4fqqigK7GTlPjL4UigOSLoTjKB34k1sCNhOhe32IYcIreSLlr0tNollSO/EgBsDW5VQm1B9zeQRHqLa7", + "aYzbW+VevoXf6mbEuZBNPsEkqoQFDdFONj7yFxuL1qaT4DdEI3itVslch2x8IQwYrXgux0fsB/zAnp+8", + "ZhRqwPaMwL/IokhfDsrkLmHmbCyunVCACOOjMpW7n0/8Dcqd6oRnYKtNhLXjI2aX1okF818wUygFJ8bB", + "VuO1kuV0a8rFJM1ROR3mDz+FgXr9Xm2gRkk3oEo7sjUIKdvwIdxmhAzArYgODjydHNBV8fpl7bwDLazQ", + "Fh7+Bor53rn8ewF3g21fhDPFGsF8f3Z24ktWWbbgOZzuFTcpupENpMcUmD2wNl04Rqpc+QtdMuxvpHZG", + "Q+sy9/eHl/LYpHBswZdgseZqiYZtaFUvh7C2mNfKCcORab/IZHKx9bFUwD8JNA2ShPclZJeSl0hIOTcQ", + "QrfXkSwnctsXUuOaHt5Jre+kytaP8GTv8bXUfjZ3/GayIhOJ0w3FAKEcVfiV5dzNg44d1y5SJjIUtFpE", + "ilmDIufs7Rvm+IxuJD1tggYHVuS5MAm34db67sezs/fv+ux5n718/bcWGaZRmP+bxOp6qC0i7qdcy8B9", + "5oxcLFqUgddNsMVVro1j14PShbkGHNYCu+izEDci2XID4OXNAa/g4XUPRuqXp00ntPGZVEHBH8RyK8O7", + "EMuJ5ib9EthdWM8Ds+vE7C7E8tOwutq53DGjg0WsbeAPYuntzFH6/MHjMe0tMaBjmGKffceTC5vzRPQZ", + "b+ZCN+Cmge+hfn7OUwr+KZ3iLsQy1AK0toU7dee2PrJoE7d9/e7kx7M+Ozv+z7PnH47bee6qOChuwWBO", + "E6Oz7FQ4l4l0K6ux2JpZau4ZTng38akrm8RwE+t0bsHjSkEgdv+3zZ7Wd+OBUXViVHTqI48Yn4ZntRzW", + "HXMvYE+j66boJ8Tz60HEdO68xws3rmIHhFYzYQHpu4glON6ydbzlXY/n9TE34J801jZxVDdt3iupeMbs", + "+hZOnfcxDSsIrKbLSvRouWWo5Z0MtYLLHkPi0flF+wmt7/BG1vxGXgoQQ1+QqrKVI2fyUrBLKa6iQxZ1", + "KP3A4R0/LbLAux9Z9pOYfDh7EXU478SF3h+y7307MEI/Q1tnYOig24mBtnLBZ8J2NiR6PetteXPTdjyw", + "5FaWDFgxAqwI/vL3yIlbj2ZHJS2oybzmPudLLJkJiDdeW8u4onxefUq3WwbeREJZtw8M2WlNeW+EH8p6", + "Z0csNYzkFfTfk0zmGHcBRIKugDQpcv6LIQfjckrjnZTlHTb8ZQx86M4dymCJ6MW4A4s44ZJsV42nMlmu", + "LfdzsIiVbXngEh24RIkWn4BRNB3QnfOKSlRQK7tIC4P66tGiKTkEz7JBkunkgoV2UQMUcRZOYyGzTFYO", + "Yqfa6pu40jMKffJG60QbI2yuVYqxUG1ccUeLXHULNh2dTrDZd4VKs13Nb88ZEFomXGm1zzw8iv5HkYJp", + "g+aG8JMFfuJNSVKrIyYdplPKnS1LLqAAN9GXZAfSSkCruc5S22fOCI5tjbBCpeHwAvzYkoVQP7MkXwAj", + "YPUWI4KuhKmM1WfoF1+6dkdghUqFKdl+tQvyy6eH367jX9mqIYZpZTeG7LljC20de/K/vv5q8Jic3jIQ", + "Ka1jnsgZR6MMoZ5fnbjmicuWjSxiQTXbekffHh7+6fG33z75+umfnh5+++1j75IPPz1udBPlalaAHNjw", + "TIixB9+9OGFP/wQKEFs1M2szjN1xv5/jqQ7e+C/79JJBwyxsHVrqxBDtd1DCTwASp2Lw8hjwFzlOu9PQ", + "QqrX9OPjBg8ihNxhCdSwvC8RYR9Z0GHwicwkHGhtgnF+axMCRv6LbvJrff383XMWfq45L2wath9ro/qD", + "BnSeyUuh6hM6LgD1Dr4TJpPbvRYrmFmZctyxKgJ04Bov4j3bIKMkF0pfZSKdCXILg4UGM29j3Co0IEYg", + "0pKRtGUxaA6rDYCJRKps4ZENpw2oGZfZfF+HvHHeqtt8e5tlFBqjL5NQYdiSEuwqITSPaYRKhRGmdbDQ", + "ICKGm4sFc5pJZ1keqQ4+waSEsaT55EaoR45RuBLDN35RV3c2zWKUC7yRmgqa+CZBseq5dOSZ/ypEAQ5d", + "Bf0Ig/MSG2CGfWYh0JFbZO0TuIxDTZRUcvCCRX4MzgDMcXuB18kSF75ksoxrXmIw9AJ3NDK2w0YRqZU8", + "D4RLDhA1oA2qdOkIQxfcVVE/AtrY6qJqO6An3ntCuqZtXhW8SjoMyF1Fh6ZDaUDRDvQKUWdN+bLGgezQ", + "J7K2ksieWMati/TZ9zFAbCKm2ojS03vIxh49Iyy8OMutUYlo5AXzkLTSLDyO+CHQ7/JKWnFUdQrp189n", + "hRJtv+nUyLWcubm2gmEWSNIGjcsHw3BtrxveO2EXuj5g6kLWx37Pb9GN+1cvitGlMLZR1Pgb/RAEpLDR", + "sDHuF3zTVOFUjvqSZzLlTlSFNj7jUtlmHWBSuwd2WFHlAvnYp1iTpiRfy+a7gaUyReYCbKFPTEE6/+12", + "ebky65Yd3UBSb8k99WXl2d3yWD/zeRGqGRF0cJGC52SmgWzOUMnqzDLoG7wnTWo0RrYXyskseMWOoiJD", + "hJwK4A2rIAJ0hgleYXHo2kwxpJQ9NyFXn2raOroLUBsSu/gJWCfBzkNUEG9odJVVLgh9sJy9wItkmqEX", + "9kyMMr7UhQv2Av9l2Sf8sO/TgU2lEcPG1cXUV0ZY51nNYsieo3bXCO4cT+ZocONsaoSd+xUveDKXymvP", + "beMCE678/VFlYwou8hXPyYQbOJhF7pbVn8K1T2ejlSBX4o5KVL/a26pH2jDxQT/Sqh8JeFZVmt2jfmTj", + "CW17ctfxiLIcNMlk8H0k0nJh+BZPkNmMgIK4cSKNHqPR/TL8Mqw6Wq702r5Dfnbbt+K1ku4Vl9lWphmU", + "JwmGnSkNAgeTSjoJTok0309NaSuTf6CzrXQGBzaa4pbdP5k1Hc9uRGadyNtRkpK+MG1KPPQBE07k9DCg", + "pXqnDy922cJMIcgec6R0cPrASWxf7YdwVXYip0YZpEZbRgwEBjxIO48uH+J6zgvryEE7K60oZKR2cC/a", + "IXun2bQwJFqsCjNXIEqQoMLwVSFtoO3PQcJNu/ZAx1vpOB78JyPm1oO6l2uzhtiwxAKk0nLVng7gAiU6", + "AAwPBMCuhBEMXcCKPPrP2wIrBUAE4NKLsCF1WZ0gqzdvw4h3ePl+ELd+sqysqoFl8FUZ5JgYQXA9SIu4", + "DzOeY0ABvYNerD1cjAjJaVak8vDmd4YnFwDNiyr+HeDVq9KyXEvlPiufeeAxO/OYT8pebsNaAq12tTrC", + "9q3aF5njFwKpLMKrODDVSanL/q7xhqZJbt+fsjBwqydCLozUqUwqVYBXFU6X3uu+GwWWcO6ICFcW8UCD", + "W2lw4xHcMQk2nc5uFJg3GSmo4P1AqESnImUn7/7aEUHjtk2WTmyV0mHsDWt8RzfU6zQTW12vw20m0xAa", + "uuJ4zdnXh4cLy/5VSOE83ZElVWkm1WCaYcUIjPHz0b0dNVF+6NvS24qj7QOFrVNYVVN6j7Tl8e6N5qC7", + "3fg0XEfAjHqFV6zPkPd66kVkRCzcbZ4ZwdMl7I/HPVTBg+RIall4AyvNciPBhyes3YMYI4yqK6p0+302", + "LgzWSwiJF+DvmC9hTGadsRE+TRNswLiSk+4ZGzcgI5qicm7gtZ4tWa7zIiuLKHHHEm5F13R2d0QsrUf0", + "cD9tpR6Poff/Ct18SHcciJBgZtxtZ1YlwNBjNXeKNqvxNutHh8a2UXNsp1+2z7dV+c2rtJRwR0fHHz6M", + "Xrx/9+74xdnr9+9GH45f/Xh6/LI5eMtPujWzR1hUxTkmZgd3scQeRw3UChtp9Y6DUStconlgv9LhB98U", + "8m5U1AE4wlpeoWqovE8p9IPSVyokZZUqyYpUsJc+j0ufvRIumffZf37/oc8oBWmfnbplJuxcCNdnrxfo", + "H/VWpJL32SsNfc7EtTuDl22fVai7Dx68p+Av4frsLVdyijM8MWJKY7x3c2GITS60EdsVjZWzqWFFv0TI", + "jQENfgs/EJjOt0w4PjTxt2TjuH/2W531A+Pdynj9od0/x107lzvmtSHF0tY8j6EhyQmk8Q85ZPxuNPKe", + "eSU9xy7zrqb2WK8z5bclpvCoZjsnVtT33KfiWTPgaSrS2IdfcplhUIQ3eufFJJPB2+5jv+cXCXyglW++", + "Dm2G0IZJlSIEzLmD8lRhRXonTNR6dplzg14/OWUqJw6HrkGN+y/tyIhUGsCuDaQobXn32Gp1DT1F32GC", + "MNxSSrghyQr9yEBXSglAEfiVNCEW+K/HZ3128v70rPnGzLV1o8DPmpFgotMl3lUA5eDkx7P46uvD4uI5", + "t9yNtLRmAnhP922G2aEqvhGhFx5DWWGkstm4jaYQdyQG9FmhJNR8qOQUq9iNHq7821/5sYhFjSeWHGyN", + "IXSTBmyulRU7iAPUgRmRCCwR49+dr6SJGhBPn9QQ0R8OxRshqBt68iNSluTLeHrJFWZE16WLT4V7f3qp", + "o7I7D2JHB7GD9utTyB2rJ3PHggdgbeMh+ZOooXfJZjGB9NQnZ2ZvX789puSjjUwQuo5anCk/1MjHCGek", + "uOQZw3deolFuwK61Wj8r9j7sJLwPhBOKFLXZEhxsgQ2mAF22zO5+JKPj6VRgGY5yB7sJSbEUWAIKq9iJ", + "e/9C7wobZKMud76eVt+s2UYxcSEXbXdVPOQAMC6MBAjAhIO5W2T9UKwBOmJttM2P8Ps5gBch7YdZkVGJ", + "GQdhZLt86mMWqE4YHcPqkx+TthTe4Dx8UDD8xqQNTGjcGGhQUqm3UniMpvZbKPXJ4aHHh5Ideaqt02lj", + "blkcoUXf1TiZSjrH9z/02Tvt2CtdqHT/pvKV35SSA24UpKBE0gvDAcPbba8UNhbjG4I7Z0L92B5X7Lz3", + "/KrPThXP/9t5Lzi17ENq1KyWZDN2ls6KbAq7sAQChHjUIfsQTibU8/Mj+Bl4kbxfCZKnbxBNYk5dC93H", + "RAjDkIZzPGSRd/g6CWFqYwA/ZuEiZzIWiO+qrAcAtxXaVk/iQWBrFdjQy9/jxj0Ka40nspvReEMq6DJ5", + "a/W6CCHiFcT/tBmfYXQYFTFBqxDu0k7+2/lUe9pmmMWWA3ipFy8o7SOYRzrYF1++f1vrECpdwH4DwGEa", + "ISIsfPl1rGxxV3TeuKgHgt9M8KlejHwGUDTN3Tvtt5/SXZvk0nwU962BU5BH5CJk02fk4OULjSrm95Zx", + "51ORr5HAFPajz4zIOIpFTq/dx+TSuKe0o1PDMgb7Q/ajFWzsLKUXv6q7lzWkq1jZ//rKtkoibzCcq2sW", + "QQr+aski+Nhvi5flkKUB1lRcWZwwlwKDQwOkuZyiWrPUM19KW/AMdgfD9pZDdsyTea0DeY6SWvfxwI8K", + "izafjqk8+MR04yH1eMF75h8emwFHtuJyUiwKT5w13Np78eZ036N2TORwIgxugEoEO5MLkUklIK3+p73E", + "Vpf3cH91wz3YsE+Mefdi2yzacs+8XMl3VENooZxZrvkl7/lKgId4zVQ7WJYLg3WO9huzI1V3dZQKx2Vm", + "d08HFcipsnGMO2fkpHDCbqE8XNI67c15Cm7mIK5IlRduM0rXNsmnC05ESloKrEWAQIKFCn00+14TCheV", + "9PzhxZvTZpRHcaEhg1R1XJtoE/RG0vqzghpxtBMhQuPN6X7z1b+Gk15xtWN5o5DqGL8vqzLWtihWU2rL", + "krM+VuPhlfTehK3b83OtxtOtLNjPpcyU1UEISvKt18Ubn7jJi3mgojrhEp45b16c/FbviyQvmdHDPdF+", + "TyT5fV8P1ZO442shS/IbsmGP0yVKE0bflg37rMKN3EemJfhA/29enJQVJeQ02MZaK6yNmpkNvLwQSRrg", + "dkr7p3TazjJfvn/LoEED16yM06yjJkVOy7Qp61LXiT/zFzYgvh2QdcNn+I2hiWdyIdVs8DzL9NWAPD4a", + "1wu02F7/gxvBWyZECZaZ/VfB6/dBCXub+1UVIqwnZBRklzIVOvzUUq7sfi+96tSAh9Hp3cO9hwM1CWc3", + "vvS233Sab3/lly/3VUVeFrp/DhVenPvDdbblOtP83h/atbP4jSvn3LyGzl+Kau5dDIruRrHVEp+U2GWN", + "fpFfeLhAv+wFN0YKLH4Zkx4hulsmFXKtCdaKc8zXe/T1w0NdyqombrUi66flDiu79cAjNvOI8rDumVM0", + "nctuFr2b3eoqYDm12LVc7ztxxTaX7GXcWjkrc5xKu61qb84NiMXt6znBButLIk+tCX1fDmKfhUyKOIOG", + "ir3Njlq7l+O9s6K7n9ayWuKA03dW+JacaCuSV4lFnUlhs73l2BtU0BDcYoiLdX9XFOyUtXWi3ZzuueiS", + "ZOu4UzO5RAu0tKwCniwxWAcU3c3Za5WKXKjUVwSsxrw+Y5xZqWaZiIkFg5tVTPSH6WCZdJ/Sx+PBTLPr", + "ffCJTDVnfPI+F2qD0VGJqyjgOD5hOvIT2FaNnUm2IXYwDLHJZ5q+QNxHvKZ+UNcYHi42RD7wWio6acvo", + "5uhPfhVrz1tdK5axLZLZy0v1GOaK4BSpAtEP5Mqm+GZIm6NssSB3VwrfXpHTMPN3KNg7x5RfzgjuMP2+", + "BbLMRSJ5tlMs9F1JZfVTfhDKNhOh45MR4fUnJb4byGQ4y2bJ6azNwwpoGH2APekiMWglKKhJLXcVMprd", + "ucJ9p8RVtoxD8cm9SB5OuqZyBBREl3neA22iVCquWifTKMYEUBXVWTuMO/MCy7gDHH6eSyh138qhgenQ", + "kS64QhVk1e/0b29rCYlTIy+DsBFTfc+5Sitx7lT8fUD6zAHPpa9ndMSMSLCs74xlciqSZZKJPpvKTPh6", + "8ygO+dc7TcYXKI4JC6FFmBqmI595+xDmoLeo8MR6HdmS5X4DBlKlRRIzPuZGw5DM8kvRZ0bkGV+Gspj7", + "tcXyGSYuTkgI78p0/ai3ZrwNx/fAettZr9+uEc/lCFD6Pplv29HsXk4Jia9WS2ltIbGQEnvrfbLREfuI", + "8YjhRMNJUANpeGf654d/cKDk41A7LrHFONGpGPsT5rb8DXzA49BNSH/T8k3EJUwnIw6MR4M03RlvsT5T", + "yowuHPi3x9Z9rA8R1uPZDn6HjvNxCsQIxifEao6vRQLSH+Z+/RBY1Hj3XBlwoA2hLNH8ts4YQ+uFTNNM", + "XPEdAzYaIyPgYIddks5VoiBq+12JheiYj+7E6OvlsTHabFBycpUKZO/Xy0HGl8KEcIeyHkc9UcqQ1d7Q", + "8AtcApoJSqI/19YNEB6dtGU8DkO5UcghG+tJxF0KVIIRDP85+IHOBFcwwCWMfazTEab0ekLvj/VZW1+V", + "6unhV+X8/NPikY2Rs7nOZLKkVzMNmgrrpPKX1ht9NbjUWbEQMZO9xIXAVqd0luy1s0Exjm49g2r4BnwG", + "uSIYZKXPmOrbhIgtnwzK33NeBKEpWmcEXxzRIuPy8CbFiA86HsxJUAZ/YMGrWNUj8/VppQ2FQzzDkRa+", + "44rp3A2kYkZMpSKrXIib41cREDG6+h3MUjHlReYGsN5MUIUq0Nnx7BPnhFrB8ofLuP0yhp3yMa73eA03", + "nMddG7F02mQYrnADYjTQ7mgTS1kJe63W3m9kWnWG2ML2huxvFHG4kNgTk3tAe/wVXbrtUZXfjHwtp37t", + "S7xGR4WqRIEGpSBxr1EqlIReudFg2TejScaTi0xaV/u2UEbwZE4g4rdU109g7L+cSTVymUULmi5c/C7s", + "z0iqULWwT8uoT8wIwCIA1zTtIideVoKP36TKjjxrq3xbT5g9ZM/r50P8C50aKoVOEj1TQHCyEhLJLSsU", + "1JuqRtnVYAHz41A2MvX6m0AsDefT6/c2HlClwFTthIgbrh1R9evKGVW/DocEssDaKZVfNhwTQamfExbF", + "aj8oeLuunFT1q8pRVb+unxX8Qhu+zmH6vesB7O7gkhsU/mCbX5Yb+l3c5cqXH2CWP9Ym6aODT3CLX4Yd", + "PvF79l1tg8O3P9b2N3z7odxecuU5y+xZXDl9FWL/X1e3FplIfVYf4s42TPlHv1sl8PDNS2VfxU0NX76o", + "pm8PwyHL+jFs7m5h9XQ4Zeg0SkYIqVma9hTRUG+fK+mghshmIY2IayUTAw6aoJtXJEsUtYRJONZTSubc", + "8MQJY5kunJWpYP/gg18OB9+OfiaVQCJ8yMuoz7gvAfrN00pHIuIFv34j1MzNe0ffPAXjoHPCwPz/V4T3", + "7/923zn3NqUwuLMg+C0nudMTJSb4Xbv39r4+fIKC9W3E6v1dnz+IgnENG306Pog8866WLdVjRYoZwY1c", + "wHSwNph/BYtrkZCArguXF45hAVWYbKUDpQVZ8Dz35R3x/tkixsCsMIlAmFq/R7H0W3tBmoHQ6WMUppfv", + "+ALGdF5FqpXoLlOtg+3crbaG1W2v/bibphsE6NHkm6fw95YU0itZPyoUjQdx0NRjVf6lI9su+ZLQW47X", + "Lye6Qe6FvfBZxnbUOPlezGmPi8KzSSIzD599OD55s/6wamTT/8EvOWW0YAJYccjby1kujJUWzoq9A5nn", + "n/g0RB+rc3UW3RwmEu3MNrT31dpgOs9PXkdtsLiWzlLxZZgdk/Zc+coT2lS/Zk6YQHghMTdGXGM7uhWH", + "7KScHAoI5wpLXMhLEQxzg1mmJzzDsobWamOPWJJpSy/jEKhog+qCZdyBNk9k2bkilxLyfGWvCkUlOlKR", + "ZNz4co2FFaU9PwzBcu7mlZQa5wp+RqD1sWsDfGd4IjLUmBeZk4MwDugSL7kZnytga77KL6XTgaGl8Zb+", + "QfwZl250Nphm+opZseDKycQOCQ6T6lxV3FOEjWVACLY/QPuMTcOaqQwINByQ2wAWcrUs1edKaVfZnfEQ", + "zoEyQRtBr59nbBx+H+ZGOw0EMXT6FKlpb38MRRjPlbjOtd9OXz8ZURCoFs4vk9wO2RtxjZWl8bRRtRFG", + "ISw5V5lUF0Fv4UvHBGmmcnQkE3A03wAswCrEw4iDw3P1PHTM/KhlSTTDMsEvhdfKIARPfGcv//6serLn", + "KuGwSZXOTLohgyqxMqk4CslFro0LiyI58xliWLpUfCGTczWmNnv74yE7vs4NXachXw10pJeNL/fMC6cX", + "3JE5esje+8vKniudE6d5RnwDimDmRoN1hSld6pqhIxsbkWfDKyOd2BsOh/tjps25om/FQjpk5/RLH6eb", + "aGV1JrxESfq1RC8m6HaNSryFSOZcSbsA6estVeCkso+l3EenEfIcYqF7lEFCQjpUk5BzwJ/ZW/ld/1wh", + "PXuGU1ahp3RaoURBysVCqyiW6ctQ/AO/f2QJ2LnyDQbodoljRY/+wJmCCOexpUVqE16+QOVXCz8/8xBF", + "rfYnwPXV3GPVTbTQ+nWqyKpXdcVVjRGxypEVSW0e3xz217TxWM2+It2EEipBicReUm/Y/m8Oh9UK+F8d", + "Hm4uer9WFTYV2+9GW2S7X40hsWj1FiQ0jytruBTbJEFPKEx7kRDzgfn4CKInTzhRyRNHeca013tr49Eb", + "MVvp0JXiHKl7r1KHv6OUVZH3VmvzB/+0LopJce1YGfRRzizUxNVmXVMZXwKkrazcdpQHoH94eDiA9YCm", + "mqETtOHLAH1STKe4mxPhroRQ5Z7ZRiTuaqpaR92qhapR5dmSwA8fp2whrIVNkVWZP+otGqg9z5ofgj++", + "fvkkPAGXYZPENU8c3byDuc5w8xBZg7CE2X2DP+u5ilPAywOjgjDwCNk0SRTojS+LRVnfyD6Dt67CsvV0", + "QXLlGSRyFoihzTOZSBcqgNU30Sv3PBWBANbK6vJsVAptmxXhCC0+iZF0/OaRYjyCIaIq8wefq704K5Ql", + "Ep2xRBtT5GQ4RFtOOdkDwNtiNne+Kjm+Ks/V2Up6UpbxXyT5VhpnI7dFOBVJwc+xtgMVNLWOJxcNKhD4", + "GsundcYkn3qtqUq38DYVUeVpIq0lj9xeDD8MUCLtFmZcfQju9mYD9FOiwZsGRQr2F1bKF3DbpXDF/iUI", + "EcNMzw6kmuqDVEyKGTYQxlQaXHGjDoiKS10sQkNNQEraM+rWaDkKyeq2vgaxYdfHYFh1f7Xb2u6eCnMp", + "k61Z6MiPJkWLgkwEvqRQKSGuc5QVQcR7XeYJZdbp3HoTOdmFtRmUqdXtvHCpvlL7LNUoNgYBsOIW+f/+", + "z/8liawcBcf1Tyei0iywksFMXopBkQOqKyvphZTqrtY98h26rXGvYTcfDHytBj6PTJ8gmVzbudzA1QZA", + "1H1tVpZRetocX0tHfBIQlqzN8Z1ED84otxUqFSbD27nuu2ZiLV1P1Pi2RLoI3ilAkHSduSVpN6JjHMvn", + "3D9raeYhcwOTikT5vXru1n1se/L6pX8JkmWqiYoQckPodZehh2yMRFvkY7YQXNlgcMSFp3gpk1+2xNys", + "hqE9RKSMs7ngmZsvg4sAiTBDNvafA0DOciMupS5stox9aiPUmdd4xi/FqHlC4SRipVafk8+/jkJxWDxl", + "R2KrM3CWz5gqCya3IQoVTp7KavKPcKykx7IaXrOV6qc2hk5EWqLthCuV9qHX7/kVNTK1vNH16PXLtRyI", + "tAUxU3TUpq/uDQzGiny9mnTjNpH7WKYVdI21XTkpz05ev2xJ8Oo3UPFFs0F9ZvjCa1Tqywj76X22Ei+p", + "gsOWzoWa6Gv4c821atyliHd1Un1PFpt4Ed407/XiB9nqTwsS4hupimvv7cXev387uJBZJky4+FA1GU9B", + "KjQ/wZL/9nbI6OpIyTVgfJCKy4OLhZ2NQ9AD4BlXJT0g6BXX23BrLMRCm2U8Ua2qzy0fgBvTU9pi4mGK", + "mOWZ+J0tctgoK9JPfCWvbffDjdx+I+NmjbRejAAl7vNGbj6W3S9kmOfKfVxfRLyPm/Qu1hkumyjwp3md", + "FkQiU9L3BVIcsrHSSoT7wmv616jlGRsvxCKp3EvJzOgiDy29do9bNpdQ2jDJCyvcmB1gP22W3jmDoofe", + "/fj2+QF9MQAverCmyiwr+bNWfsqW6SwN/m9fDw99AHwqUxI/YFRYoHWmSCgz81jrBS7taMwyqVY8TGCx", + "mOp6kcDlQvOkL8pZNlLrQixGUyPE6GKyvtGvjBCMjixsiVTsB/kd825I1WwoMLk+SwUljo8usWOAfvQu", + "OCJ7XTjtwyPL3orF4LWaapYWi3zInltboP6ePcVxyFVK/iKG7GXwzwnZ141IMi4XqO/ANOQWxS/O7AK0", + "0+SU49/oGTczgac2ctrxbHQxQeMCsw5wFI6fdpwWe8VpKJT82JybFI0WFuvR+9OU08pK6mfHqVoSziwu", + "0Pry0eeqkdyrU2tgXPDLrY/iHe6nZR+evyUsusVx3M8ubBN9/GUYJJ9mGPRjiyTyQi8WzdAYr2fAr6xr", + "b8Gv2eOv0TnE9it3Ra1Ziz+5tY1H+kFYfBgwKxxdNs2z8se8ZwucN1daDYy1FFZDf6FwO1+IBXzcB5MI", + "eeUCtHy+tGii8lhTlQ8BzQuL0l0zEjVvsNP5yHF7YZvwNGelkIHKO1rlwAo3wFX6oRa66iNMGGtp7wEk", + "BSevSEs1VB2fwRToiTFmPvT5GJXpG5DSR7hB2xccXwPcsa+ZUI58xjWb6EKl8dZCZEdk3UUHX7tBYZ5I", + "4fz6NcH4el0t74yczYQZbSMA367yFu1CinSZcJUCJxu/OPnxiL0DUR7+AwRxFL2tyrul4dzDHDsTWEQ0", + "NO7xDKzD0CxqVyuF6vy8nWZSXeoLEphL2XrI3k9d8BZCo7pl4+pMxmyvAsYTUcXBSZh9zJKScMVSCWaG", + "8sHkOyU0Tf8z7OmlTJxcDNnbLvTfqP9eLVhe3Tvid5FFdBXJEKF2k8aex6h/fyKU0GobVeEtsCabdT/3", + "2/DNbZSw8Q7oznTrt+g6V+rgaUaH6E90+1lWYlM3BctWSw9RhOqcR10sYXasjFOLB+/3JIa89/o98KQT", + "ptfvTXhyAaKtSke+TXgaxyZ2zo1Iy89Y27FRZgzrCDGbL+hxIYV9gQGbN4qS8yVGykDQEMhihXPoPwQP", + "iBAZ2vps4LlL5rtHCayuZelX0lxnKZlzZnV2KYLihOnCJXoh7NCbWBWJOfc5j0wKSgLJk/lBKhxmX48K", + "vuDdCQhFwQIgJKAK51KKqzBPqzNxn5OkEYJ1dy/Tsz4Du0yfXEL3cVbrlri4j87o7BbzIwCt03s+A8nE", + "v9V8FDDjMy6VdbUYaTB3wHgF+oARVDKu9tlJxpdXBsvv130J+swmRghl59rZPksymU80XMDkDtavhjqX", + "QPViwVUaypZeipVj9BVinTD8vjHsR8qtHIcKKtG9JJPJhe2zC7EEO5HFheoM+PjHGLdwjxPzHsd4qx9E", + "f4NQz2hIOZxm94nXJ5h6MRJb2Jhq3h4qkrtSPwFyENP8Qgz5fTKqLLPVsH+vgVyL9q+XodqLIfzVwP1+", + "uG47hervD9nb5gj9Z0xPp3D7e3cjhEGRg7gvJcXc5+kJI3UqEzbhVnzzdBA8wIAx5tq4Kt0O2fdyNmcU", + "wbl19rhX9zjz78qcDWQ26YN1f844RjkM9HTgX3moeMLpeevwIGjZSesODPbjBhGlZUa7XewvqjhBeu0g", + "hlaveRph/S73pcY2uTpIWytO5kWGFMzdrFqQmVmR0Y0MzejEjsgJi3xupPX6qT1/b17NdSYi8P3SqbP8", + "EpDBa5xgLD+4Je+dbFltK4VFidNp77QI83t+9uL7SsnottlYn6eLq+AJiafFxr9+HO/DcjhTeqDzZ/XJ", + "kSMwRcUHv0FvjjvTvowbVh2VFv/kZddLyWl2fbbUBVsU1uEscArBJ2gMCwGPTzbGwx83+750QrI0r9/U", + "u6HZaVVARD0XZPD0F2k05MEPL8XlmdaZ9RIRKXsapMhQRnXkHVUbEhTQD3CgiBlAfkFYrw9PYVhD9j68", + "wzNpXTzYyqkqsU/+c8iCxKUwSzDMeH0UzQTs1klWxDxYFTryYnLIHKHKWrB+KtCBtJ1GZFhb0GfPCiy8", + "UOQPlvaZdMzKRZ5F5180CfqK0JBdVSIup0bnCGIuZ3NhXQh099uGYtP4tcoLN0ylzSG66a0ufHVfeF0a", + "sizOiwVXGAqWFKb0kwfcwnyonrROI1see80s96w64ZZ8UqInbmFU8KarkzJQ7e4KHURR3EY6+XXPyk6I", + "fhP0PitZZQM/jZkUTtc5XAXpwhlfiGUT7uGMEf2q6QPCLWeFO2IZSLhXAv4t03HwzLtOWF8MQ2d9Vj5/", + "+ixID/5dtj9kP1GZjrGf0bhf+ktUmCXwHStcKDd5hGwTrSyBxz8DIykZ3oMzLSx8OiWPcBCYK/D2/Fsn", + "Bj738U3dr8q3+302thUUw/xwQYAhE0/D9Y/ccSJgyykqQUOQcVyeP7RQXIsm7FfFkkxwQ6zJNZ8yLWa8", + "0Eo6iImMWIwJ9cq0DCQN7JPt3pUwgLPPhRHPsAxKpq9s3fcfVWDoxMGrW1a/TRtswn55XbNxtWoKoFo2", + "tRn5EMBdQZ5StxIeOO8YtyuYY+xVQrFOG/+G2Gk21C3A6cgUbnz1rUtYSEfxgepFK3bKF4KNPdqNy8gf", + "zDyolgx1PbF9n+VZYeuKlwoTWX+r1hUN4VptciVI851RZlU4gCN+kAz/GJJhjSp3I41X2lxxSkWnp/H8", + "K3zWaZq1DyOrJe1ZyaCLaTcqWHTEiMn4G4cVKqMQRtoBDCoiDj8XRvRRcPJ12FXoWhkPQXtK9ihKiLMH", + "PtshWh10ZfGq80Ao5s4nd/ffOU3oVzWUhG4VpAMJCRo+o2BOwrnKCIRmVeQOqOIFzSguNhG6dtnOlP7+", + "7M1JnQ13QZG1XruhCXQ/QIWS377A9W7wHm1AMoncExCxlLfLo2Yweh3z3tckjCH7npPojYXb2V6YpONL", + "y6TiWMx9P0YPbcWtG1Ni/ZrdbY9fe//XMisAwo4ZfSnb6JWygW/jNvqComDuJu5GGImvGL7A8CPltH8o", + "xa3HNwrYsVarnLO9lbTA4RPaDveRXdP2+bTa1mkASOowi2bDiWD/1FKtP53WTDOLTlRM5FuRAoOn8M5E", + "Sc4ukSRxAfFaIMtNGKc5sfem9PDhnGqun6U5qNkcuNpZNWf374R7NaFqN9x76YVgL8+13AVgBAwWUMQg", + "bC+G7L2qUKO/0kFwDmcOB+PRlg7zQojcMqdTvnxk2UTM+aXU5ojJrthAnmie1/ThapEXILshao773pTe", + "1OdumDl7D88xrzSJW0Vp4cImyjhBfBURpUDsGf2sc6FsmSRpKo11AVSd6Occ8LEEplLP2gBElDszOY2W", + "UKms4yoR3tM+QVUEgAm1VHj0LcARvBCDw0gbw6dpdk8Pv22ihRsy+isDm42FIJuRyQfJ2lLYOxWOIdrC", + "V4A6YeO18iu/FF6D5Em6FC0aeD28pMGvBaPKJ4LZCB5D9ePmlZsfsgaG3QsnvPf08Nv97rdFiC4M7xFx", + "HIInd5HYfLJIdEqY+AygwRu8vMRQz+N9AK33nKRwBp/ja+08fbBmYyhXS6REHG1EoBccqTo4zB+UlhHv", + "8XkAgqQCzD7w6YcPUmkx8zCoG57FIhceoAypGnwgJ8hH3ElfS7ti0l+ZCToaVCE1WuitE/mGkOVyL6Eh", + "YUO5eWXYgs5HYf8peY5x1S/wT0HepbDV/V7cBEspb2D9oaEsFqNpxmeWzge2aLsPc1hzOMImt4oXYI5E", + "vWLXnCkruozCuaZqvQiS0a/klkSqIuQdlX3KxNT1+j00AcNUMdOr97kgV2+Q/xrPCS2pLYmbzrz/B7bx", + "1unKqGB5xeRpPQ+mcQCIHh5diGWTClunlHUKfob1Qdugk8U7AqFW9KQtcZClE5sqFiPsZWsZBR6vUvo7", + "TAOMLF0uhCesXHgfnDDuulfP9foq/pMlGs2VvCxUSTuWa4o0bIS0XIf0XzeBtIKu1z0A3YKkZP2/Wahs", + "CEVdUf/4W7x0LYB2IUvH9sTzbfGnL7yrw/PSxeAGrmbBYcLjbjUnEbcs5wbf1pxYvVd0wlSCqzhpZjyL", + "P1cllJzKNsZ0FxjmjW4A+Nyn3rAJqOaABr5vzg1fCJ/b7dgrY7SKv1PPWhY2mFDU8fpkis1RMkjKC+AZ", + "2x6+6wwLwmYMn3Xr/tLw2Wrvhb4U3Xq/1ZditTf6tgOb2Nb5BBr+IJaVvuT6sa3jKbaqdhNuRMaerV2F", + "e4ENq70zIbbqF06hkUfhSjzNejRX8LRbw7DaPVw539p+E+QRElN1K+PW1M62tvKwkJ9bMo6NAtlvWibc", + "ExCDH7enKey8kcqN4E68lAZNCMubXZ6LxqRhUdJIA3QGDdmeTjCOAVfZZxjw96evv96vy8Z/+vprFOIq", + "qRYPB3/6+dev+k8//ltzxTY3b4iMn1idAbcpJwENYYQEl74yyMHw37e778JIjZtZWKcXP4nJ2xcnL8UU", + "o+m12nEz6RFemVLiRpBl8mefavLnX5981bwDF1Kt9t0DA9f/L0nz/cYeyOW2cqrKqjAnf3jv25wnzQK1", + "03orNyCAYIoPBQ/WNjq61NJIfoVh2n6YbQfxNqxxhzMoTDbyu4if26WfhVTen/9xgzG4upgazG2Thm2x", + "IVXsjpOHXanPuuvpVnD245bV0CBNy3gpMuHECXfzmzGTLXQcqDfFYe6SemnisTLEzWbfpEJ7vVZeqayQ", + "EzUhYUV9kousJQXjQWx6gE+vIXue5XOuioUwMmHasPkynws1ZD/NRdT19Gum+/XRpPWjpas8lg9+eT74", + "++Hg28HP/+PfumnqXtITr6Nmrr5dc/QlaBdqw/OZ2pX1zFtKt2NenpHhTmwH6VszaA2Av/8FIhUw2ZwC", + "7ZycohU9FU4kGCy03zjolUzdfPto2Gzj/Bu3dlXKu59HLYgmLQ/a+JCll21jrLeAB371rbeWPO4lNFlN", + "uBXTe/mJwGM2aP+o/oPTDGQsxjMdK186rFUcc8kdNp3JxoRgvuYZhlmW1WtW5xbUjkC5RtAOwVwWMceC", + "XWjt5n8hHR762ECf6FgBr1pYw4RbtFL4AZF9ZZhLupYh7/HhYS1H3teNC7vNSx6WsNNDvpkRh+TH6MGm", + "p+wf1322/Ln6bM65NDaenZsbXczmXnkMk5hhTN9beE759xnjjmWCW8eesFxLH9QRZ7o65WrAbAyne1K9", + "i5+sr2bjj3SWNRyGc21whic3tQHq478Tv8CGJwVWpQnYjCd8xZe0EFS3Co6Z0zOpBPfe9LnOvLEP+TaO", + "hoo4O8rRD2aGmEbkIPIREtloQWk85Uyhsr0lzVileW1JX+9Il7HqOs5r7QRf0yzWqWErfa6ts64pOmxX", + "FcUpIW7RvHI0MNF++VBmZBPtE2RvaXrscW2u2/NStsoOUdXdVem8AniTavOY9CVliMmdZYVeiVrpmAwa", + "3pqUDPqgkhca2lZgkyoHv0QTA0a7wO+P4EXyqM8e+QzMj0iD88hbUR+xS24kWmtIPbPIM3HEznv8ikuH", + "/nrDmXZ679HcudweHRwIajNM9OLR/jOf3pZVmmNRx739Z+e95tSENOPtOohyt459D0yf/gVmUW3AqFvl", + "Um2NflrDqLvNpxkmva7NIVN4THXsI01xcntUwXS/9zHm/WvKyUhh0jjfMkK2urAGewtmE2wH5gPgOkK7", + "8xyP/Z7jk+5IfsYnrXkhm5HKm31+zCHs6W2ROZlzcsJc9az3LW1TdjISK8o2wDQKBEnWT/B24U5UBYQu", + "kcmvKNsK/AgQ0fLuT8GP5N3JD+Z6IQ4oKLk06NmD8+Lw8KsE+uNfYuXh9Hzwd9LPDEeDn3993H/y9dfN", + "WppfZD5Cu9faFP8uc8ZNMg/56blU3rOvUDmHWjZlBtdy1nueP7CvDyE39TNSVIf8KOBTPxXWDf9ptdqv", + "Jh2aSMXNcutzOU7X+3g0HX1FCjvcRSVSQYQmsK9kJiBfyPoRSztKpdlMGyiHof9jVP01C0wLnWJ9ogZk", + "BJF0gYK1T1kA7Wqpm1JIz4u9m9RrjfcnLIs0oRPpfArOPjvvpebq2gzg/+c9eNif9wbmamAG8P/z3v4u", + "bjfcilqWNThA8uZc34nOGtTw9lrrByH0o8nSiQZ6PvXh9fjzkB2yaWUaUtgOkfUhSwLH92llsH7Ag8oZ", + "+k1vQydKodCS1O1VWaKYHGHK2Prd0Y+js55Iu+PhTc8yDnXTQ90NS5pNKD7nGZRuqCgRXnw4fn523Ov3", + "fvrwGv/78vjNMf7x4fjd87fHnfPltgreP0CpojWP4ebzfdlcryf674Xuwf9GBP8qkh7In4cSoZfpdXhM", + "0MUz5vi1VnqBsVceTPDiKaF7Vx7y4RqTXyI4Y2izwMtOq3jWKAvDVCYCinXskTWUpkRmUu/iPW7fh3Gf", + "GTHjJkX3ZHRk1iwvJpnExItQbOIFOrMNyi/9BqCn9/vTM3YQZ3/gfwpZA2OKtuAPibW4MK2aFYKNV+YS", + "9SpX0ghm5zwXWN5QprGIsPes87l3qqH40sYNDomNYHhQhT6yIed88J45V1sKLsUK0ps9k2t11fsht8Qo", + "mcM01UyMghi6OXSMur0IvUh2XgWK6SR2AngKPTYB8z5dO0A7pR4RXBnH2Dk8rt4XA8G69MWG1b5wfF27", + "v4xtIwSK9vIFSrcAoLaV4sZl/0zPuvV+o2ehbyWijJxhtkB4XbZHx4AmOGia7wrlB7FsgkHW6JEVzmUi", + "7Q6OTPen1C0ABsfEEcTLdzzkN/JS/E2Kq5WTLsF0Pu8Aaf3QfZBcBdTWZb6lLi8rPVahSSVjRcpOwF4r", + "6cstroKKpRd2gvch9NoCdGd467Cq2Re6gCoDcgOkULRUptm2ina+KOHrNBOrvYH7SzXrtk0ezhvqU9+k", + "ANAEtVkXSF5btg4jmGS7AaHWAQqoo2Iy9c0QIOS5lvPf9071YuRdu3CHOgF6qRfe4+wNdqlBpOwkHVkC", + "QHuDHVZ4QQ0UJDrpDgha18EkeZfeSV7vpXmn2Wten3SZr6VD73excQuMHfaxhNW0l45PRjoXqhOoMz55", + "j20jCB+xPOoo5Zz49ivSTrXC905V0yu5xbrhe1OZi/5auuNdM0nfVa3L1Qv+Y3+XbpVt6dixiQnt2rXK", + "enbr28BFdwNQsvOO/Vaxp2u3BorcoWszW9wBQMlLdui0Qqs79KwRxy7TXOWzu/RN8t37rF8QNzrQm0Bo", + "FqR37xzl5927NsjKHYG0SFS79V6XY3fr/0HcTfcbsI8W4blj79rd1RXhmu69rtx95b27S7fKm6V7t9XX", + "Tseejc+uHfvecOhWvcIN+le1HLt1b9S6dATRKFPctNQU1boGExeqmhvUsgbLIE4blLxSkc0BczBSouph", + "1/xF0ZDS4OUTZZr1ybBMz1ZzBPM8z7wxZGOM3YohRc+idReM/s2K5VAwo8GkKxdkrCtnVC2O2dUi0+J0", + "UR26Scf8loM89bncQhccEhXdmVMogBMGtcZpJR9Bq6/ojg6ibWaMdxULBk2hTwUsOSly3548BaNL7oRh", + "6LDhPR/eoKscGBbJshg+P952uK3GypXT7OT40MXAXF0h7aJI/VIb0V1Pp1a4RhfFEwgxsr6yLDarb11J", + "jpXjonKdK75cfbYQ3GKYcjWlLTYm1xPMDGou8AM57fDCzbWRjhyt/PhB3+6PiACEYGeIHJUKi1d3qmvT", + "bOArN6Tx2HRhxYkPwqt6xtfPpmt0YIi9uXlUYBuEztGAa0FYu2HhHTq5YlTSLd1bU0lh5TWPpa/v26kV", + "5ryTU+vtPT29Qbd065QYUO9WdrHZxrsNPUuv2YBhzOkboWlXSDuh682jOlJh3WhbiFYli0FwNtgW3NHv", + "WZNsA0xpYDrDXNmSOEC/soqmHfLaj+OZEdaeULml3Vzqfpr78Oe/vWUXChP1TXThMEuXv48hnwQOwCjn", + "wJC909SHPkNbkU37PikCZumYaiyfogtXLUK3Jr5NZeaE2ZxSTazPQ1KlRSMTX3CfK6zycZVJ62r+zX5l", + "RkwLK2yZfg1zD1zpIkupjGQVE2xM5znTRPXkT+6rP1wvqbdfJGa22V7fOK606RjfX3QOvKrv0l+FQvnr", + "/Q+xAPr6JuuLrczntUpBxBY2ePR1WJG+aFzLCQS/+QCdmxFuW4TOy/bInMjvnzw93D1O52VrfM6QvZ6W", + "wmxhha3mnS1LpFKXcLkZgVzAi7LeM+Wbw/5Xh/0nX/cfH/7cPEXcWm/C2nZeU4/fhNg+RQg4PuFNGust", + "gGBeSu6Y/QcdGSiBV/OFYcRKxo2jX9tHx6aljyBV+izXH7yanGZC2YKKt/KU5xRxq8RVqLJWuiAjTuBe", + "zgVPp0WGBVzKb7IW9GwNjHrZGhAV0earJ4fdwqPWPbJ3TlMAsmdadWCO3uDrwVR22c4ZKSMU8kJf9tb7", + "/VTgre8RhSCnI44E1s2pMOPWjQobe63NR3nJyOJrDlNDwNRW5hOy/XR2Zgyvnhu6yKNAOmp6B2PSUNQM", + "YBtWVvcJc31koVxXv5bqSavGWRYmaw/G+/HDmzbQSKmUHkrnYnsJJ/9mQaSonePKAf3cCW3fyIV03dIl", + "rbpSEwDb7AYfXvXx0EOyDEL7sndHRdL6zJtk7J2jXvqVdXTdsJ0vstpW3dlq1zyad1vHu42qBN7EmMhd", + "r5JaDfN7woEC6wkRUPhl6IK5X89VyMGWZaEiJrB87EkIjNITe+Sx5hH+ZOtcA4UtUyiLcOy5CtIZx9Y+", + "KUqTXzy5xX/Tkr2hHnewY3J0KufnQ4tQM0j1+5wuC3bDdFer5OFWkH9JKGc+kT6dLkBsTPFCpL417TBw", + "XDTzhWqDQ/YKCbC6l9KyOc8xUx48z51llTPiKj1XdIfDL6FaOi4V1phk2oqUkqnjCVRAS1cB7DN8V5NV", + "nqs5T5nSOEcKk2rM83ZDxu34ZCsHLQFH/tlMNCvpZm6mJdkSn+xbRRUD1aVbWgpKXtGbVOVQkOkO+9SW", + "G1h5npNCenMI5AalR8ybstim/YBE/jm+wSxsjte+dFeGNI8fQnAAul0uJjrDwXEgn48VhmB2ji+2iWC8", + "0rZSrmKyZNepdlpn52rPCsH+8/FjXMtyATeTTzUBtUp9nJ+NYSvnvQ8Yu3Xeg8gINF3Tny+cyeiv55n/", + "6tXX573hOcWcEPuTlsKTE5wgz6yGWSZ6MQmPSp92huD9DxcCLvATjvY/zvgEwf5oad7EC4Gd5IVKXBE1", + "anWwoRKPh7WQqrA16JBVHQE/Z5l0ArzGSVmPLwGYKk8SgXUEMC8745nkVNTYQxic9xim+DcLVLkin6uP", + "t1LbYgsirBAmYkUzJepEWAt3l0/TuCMxhnjSjZcuDXLmi+ijspdbykiyUeV5HEMG2/SdzVUixbV0o+ZI", + "15NQJ/NaUmTjsKVqc3tqSYr5G20oR/8eW3hc9Tk7MYSvzDDqi9Fz9q9CO96PCTqFMdpgiRQe6uWCIhLY", + "BN1hucxFYPFe9Z8aLhVL4ekmlWgLIU+FMaPJN0+b41Eq5bKoKZsUUCx12B4W2RUYXGStwJriWzenhayg", + "7J1FTfNYTMcuFbzLlS5s1lC7iptZPQD/Hw21EQkSN7NiIVYTH2xl4NyOjNb18PnmZRSqXosX5D/oynIj", + "L2UmZqLlGc8tvGUagp1WQXKfAhlaAyhIogLamKAzWVtMjCpopuRQgcDORRbLTMA5mEI1Ilpy1SSVaXMB", + "tFAa0vd4NfZp30P00SQ0iFRNC9iuihbqsh29Go4zntmvH1cP7FhdSqPVgvJ6+4h4mCum89WmuvXDXgPm", + "r8Wk7xSG3scx4GdKQZHzKzVk7yAvjjbsF2F0mVSZzMeen0Di4URklNwCGFVua1gC9WfzZ4xKlZZlvjHI", + "CUvxF+ZSXtatSN8+efLVV396cvjVN3WpqgXD2sPhCd+28olbxcLzKleIGBU3esg8v5f+kVKNTo8lAcJu", + "+YhxZPsNxQh+o/fhw513t3deG7aCS9LNbrVTrNdF7ERFH5AKO6njGZX3qt0yvbPjD297m+FWI0F98x9e", + "v3nT6/devzvr9Xvf/3iyPQDUj72BaD+grv2m1zv0BUXL2X8NJhRj37oNic+rt6KsEVfMkbQK11RWLJTd", + "llam34Nn+BZY0GTH/DQItU8T3bBjp8DOqxvWqVBpgywFrnArMg+V9xcj55bbxZLnvjWQrRVFqgdx9Xsn", + "Z/+1v3rTkekCJYMY1XYpSERokV+aDw1cTCVg6srB+QI9lUWg58tqVqMdjnRtJGh282HW2cHPa+d6g/vr", + "dcW7kEzOnC79TfTQWJz//Wk8rFqpkMpG+d8bdUrgNSnMgFuge5H6YiioBWmQeqLloihk2syI0cjRaCo5", + "C05/pXYszNx328GvsJXUHHeF3bWiW6UgV2FJqmjnSnkxypOG9R1bJxcY6v7i5EdWoPNlLkwilAN9X7kM", + "hem1ttz9x+HOD8rTsFdgjIF+tF3bZDJ4ri3akkWUMzbC4skzX8qYZh/zSNxQ7DjVi1iG/or7KomhKFyL", + "VNBooz4p8cTVEh5441+PtlI0J/x3pW5jZEi5cWOlyEbUS6W62bX4kjsOvPbKSHIlWiEOymcksajrulTK", + "He8k+qTVUbY/9yPcn7eu+VYSPEzHZ5+0AG59hd7vsQ2Ny3R12CC4SQ47Jv2MSzGCl6lKdpHuTo9D+gRm", + "RG6EFQpXtPKs0GatfP1tTzM6ppbIgpWPG1/LzW7nb+pTWsspAoTVSFadmFdk9QRcgqYWOp73WpgKOqU2", + "Ken5vzDDmC0W0cGOjDWoBcHd8LWSn4NWF+1O3tkZDkimnVxl74utwak0QUJHOfo5GHNwKcm8UBf1wjDw", + "bumFh9PnZHTrrY9+jfMMwobXh/TihmZyIX2MKzZIUHEh0rIFxb02LeyEMqUgcd5OrzjR6dJbFRBkKOVJ", + "2Kk8611NHtMgBfjqnG2ZecoysNG8hHrH9FJabZZHvpI0OB2G0X0dDvL5M1geGKWylTKnNXfxbIlgKUGp", + "rdQqHbLXSG1ojUTHfxiwUDRggknIkdQt+mKQb5K0LFwAZNGo1EOymnKSkc+lj5quZ7ugHB7O6KwSEU1f", + "+trUMcS4h4UaQt6DmESlTIvQiAZAGQ1yZT2PUGDFQ+hBnqgdi2LiyRFJdkm8VJGVt1+mrQUhKDRCmObE", + "a2C0s/NuAnUZmxB6tYnTW1XF9FJY/9rGQI7K73XxzbhdZ7vFMWrLZJtKGFTn2bTnZcDnBzHbvWJEm4vm", + "9/h9GZMy8zrADSnUW5z2foKvdwLUMQ6DYIETls4HmZjCLW2UuFVkxg4wG53fwy70w8ZuO7Kb+CWYeNBb", + "KubUEaPxGqzX1dnVLz9zfHS92T3ie23kL1ph1RYci/GFLkC0oYCcS+G/twxdePpMiRmvfQ/n0Cxh0Qy2", + "JJD/G8w46TA++Gs0DF/kzYPfJvYkVvbpbq/bRhXcebf9svxQfajdiWJnkJ0DQtZqMu3ItWSaCrUlvy3C", + "r3ia+E5b3eF9u5ZpQzzsiTALiZEM9mbzR0tWswoXf/JJGw37a0vJ3G7ZQRuKJX3z9On+brWR9JUSpnmu", + "+BMabcN8f2yZb5dMkpTUMC/3lpyiyP/GF5e9YcmWDZk9q0W+dhPDT3hhRTXbNErBNhcJ0H4aTWc72t6q", + "/mRY3avJ9FbN6314uNlhbFUVUhm8cUMcN+6V/QmiP+6yCk+sE4ZqG4A+bM7MDYQrL8V2C0Ckdg+Pxb7Z", + "skPYS2ssFu7ALYO2p4YvRHOQyodStg2N4IinOVDspTBGpsKGZ5Pfgf3qmT853GZOaFSuh7fbmlocn0or", + "ods+wtrp4KApK8nHNW57GUnOhEp9yYo963Te94HncKHC86XvKwbt07sR4rug1wLTfGOhRxXqSUeY9s6q", + "FVUU8jsFoy/4daDF1+qUaK/dHaIcumoyD9Gymw9241ku+DVmH5a/iNfq7XftM8C8D9bnTH77XUdkWi0e", + "87gl7ApW97xIpd5Oly98pW4OzakAD8YOXspU6CH7QDRoq9oBEJE4VOtRvpcPuwR8OSkyK577b5ML4are", + "DnsABNPqMisc+EW4eaXi+r7HFl8juxb1Li3NaIBVrzsWqj51Or8ta9AmEQBn+06+XixEKrkD3QgQVhnP", + "aHgipkXG7LxwQGY+qfACg99QG42F3BNtTIEOobhUxJFmtd4tskwQyX+a0mMwVn4npcfK7MLqUmQ6FzeI", + "HBC+K4s2R3Q7qRZTYCuZkdelgajL3liks56fGgug/qvVuDRYaKWdVjKJ3t2MLHXlTHlitLWxPj46celp", + "hSiHDPyX0dsPktkPcOTB65c+RrFYiKiQ9kpff0FIS5WYSO+2pqbewScB1hiU/T9vPMO2NDQribkpS8WV", + "NGKQiUuR0beUTLp0nvZOVf7k4u2G3Cgk9tZqZfVD9txMpDPchPzaXvK22M8n6y5TUwODTAkYhXeEXOLb", + "M4j3m1J/44yFGcDQjNCGpTpB11CRhtiesdcP/rvPqX2w8s1LhFvxsO+z9cThjbEtXZXIX4oqtjzN/zh9", + "/y5qYpuOKpPWb/HmXOp4RARn7ejqJaibDoXOFPb+tsrgDeYg4QLC+Zs5Gr3IRocFrsFQFIFgpJT0uWFA", + "+kDjSPMl4xoEqB+VvGYxiRI9doA1rdQ0KjfKS4rQhV1Vbo+ONrFPowqPZ38avABu4MNRMq8g8bQ8KDGz", + "VltUL8+yQZLp5CIm7fFKncpm1uDj+XqQlL/FhUpo5YykDTn8vSjWvbRJEqt9dsDduJG+RijQq0EZYETU", + "1xSyuyh8qTdVmtPRSbKsT8Bj/n+2kCi2TESCL3p46YDb+ETMpQ95JQWKLRaL8uIM3Ym91zeQ1BXwhGFG", + "WiDoBHSObCG4N4H5GxM8eYU3r2M6MjbllgzBPMQUUwMjePoMK0YInlLReYKmtEPLH/jSTIRQLNMW5a0r", + "vsTIP+srSeDV4RNmGJFr45h0zxifhAbct4FOKXdBV4k0X8kJorQrw0S5RY/u4caLvrmQ383kFy+iZNy6", + "NdGKvdSC5gerdpWTajibXWe85hEOQHu0jkYOsFJWfWfd+u0Ko4Lm2Rl9IWxjMcNGn8Hmc7pR1qMQd1DO", + "I2R9qmQ/gvvkGh35Mw5VN2qs3hSC7QUcW4R8VwdpKGu7P2RwW8HtE/JMnCsfMwiMHMaiUGXFdNB9VMar", + "7RTbw+/+cgj74pMy7Q/PVTUBjbhGcoQdwrv+Spt0YDGIDj0cfGRMXLlUzvABtKIB7bkCTqE41XtBCYd+", + "zoHvWJJNaW50z8JcNhxdW9Str/m/alm+xs2C9kF4nWsMdFzkhROmiVO7Za6hXIlKxGZcPBFmkMw5SGzC", + "wBiaSfVPks4wpcoz4LKOXwiSfFHaQaES9wy8p7FOe4kE7HDI3oPBny4i27QDbM/KTCiXLWv7dK7KZogb", + "+7RVUedxOHzciPXBmXH1kocNbSLxn8TkeeHm6nutL7bSd7ulIoChgOi51hcRC7OMcA2C7YMw3+BoRX7N", + "aZMhe2UtoWXLct6+OKGi7lBE/jTKmDtnq6y8zRM3guf5z/+gUP6ff33y1cfW5I+IBNuTP6wU929fzGt1", + "qSnj6O2iTsOLRRcu0Qsx8s4njc8JGccctfgedE5y0SFKcXWdN8pKKYzRZhQYxw1WRF5PTcK9M4WlUmYz", + "MciNBj1UKGcZqkdZqjvojOCoaAZVknZCOclBgwKhygmmL/Beo965tmiQ/bB2K5T+sMXE25G8nMSZ0mrA", + "C6fxJ8dSkWTckJyIpk1MC6tzkB1BHCwcihLU2r8vypcrxJyTp0fF+Qv3sddvmsX2aJX6Lsclbj70ixtm", + "gMSdbO/TdMMDS6AT6NMbj95+j6FypHdfxJeyFUZCcHl8q2yPL6zUvC0V09vNHHDVj/AJ8Ws13+vjJ3/e", + "Ld9rhNP3+9K+57AJO251t6d6Cb7yUPeDdev3VjiOqoyVnWlxPp0Kg3I12IAA9S5I3pfgkc8TR6nHjJhJ", + "6/yzE9zwJgL4H1DiJc9kGnIf2Xg7sYp6JDjyooEJq6amHZ7U5WHAn72o69h8KM+V0g7nuWvEBPQuOdNE", + "zPml1JhbAS1a0er1j7cvThhKl97GS8T6816oJr3Qqch8aercaKcTnQ2lPqg1P3hy+OTrwePHgydfH5CK", + "5QBg2v8O/+6TiIij0dLYytoqqrly4CsxWfBkLpXIBDcQRDCcSTcvJjA6/JjkB/89lYlLxXQA4/ASIMhG", + "Z3NhhV8uN4IVkWtTfDmV64u5ICdLr41s0gOWDLbZrQ6ezfikA+b+vVQtzVJBpRHlpWhvJFOxoIuivY3O", + "hfpJmyxtb2IET0HUbG8RN8TX/Ghr+XEjir4yPmPTrnbkxmint+GJjHekVIkRHFUNTfZdsZgITNmN8Kqe", + "SEEDtEKz20PWNmZLo2EgZ1pMNTU1nOrsV9R1mzlBXDsNtpn+I/fbnfjZwvdlUw22aVuSO/7cRHL3Qusf", + "kNsKI9LWcXcidRPh4YDDc0Vy1ylZBzBfXXgYa0PPD5hTcKmGuTbSeJ3Xdrueqgx6NWVBo8wZJ7pNTFnD", + "ipBusEVMvSFUTC2/XWb32f2q66uvZjMe3+jRRQfW7SzW3ncf+0Rp3aN5V1nax7XcJMd1fuN1jgEbEekB", + "uzAWH5yiSzMDOd6CaQ7RsdKJjAp1F+qPoeJZOJsWRTr8HBOM1UZocVebiVHXdJArM96F4WFZ/Vtyd8pf", + "dxccfUu6tjJTG3m6VbjEI+sPKriu8cmzsOzIWkoZixhL03ZcSZXqq1vvSFg6gbuDzVmh8XKa8QRriFjB", + "oEBcm6nedk4bXSd83MnOSSnL8bYm8iLAjZM20okXmcwnmpv0Zq/PzSrKWuRoKKoeBtz+fmjW1n3EO4Xi", + "Ujy36Hmb+msyjDw/ed3r9y6FsTSdw+Hj4WEQIXkue0e9r4aHw698SXFcyIHHo4PMP93hy1lT0N8HtLh4", + "fwvfmJXOS2jPiA4IIVH5+OTHM7Y2hrcka+U9mnzSYN8MDUFonTALcKmBC51sN55f+XaPLCtRxHtfJaDV", + "ykQ6I3bLxt4KOCYXhrL9GF8FIDiX76OVeWDaOR4yS1O2w0JhjnZUj4fpKgFmZuO3J45IcgcgDXngpZgk", + "3YXaUmG74eyJcvA8nhwe9lBth2J6NI1S44N/+vg+GwWALmWs/FA+Gh8RqflOCCuKx0sR4B/7va8PH9/Z", + "tCjVb8M0zhpwIUFRLSTvDhMbItGAOZObJe3rCmasLKHfux5E0++gdPUo3THg0mxSAD732ntegvSEvTrV", + "4NrmEQZ+kuRyYzCdo6UUzlX27rHcMun62F+GDBRTDOAILgRnkcwuhPBJpSKtxXl5a2FMge4nYo9KLIYZ", + "+UAIGw0TNYrGSjkhIazXEqLxGBYC6WJtyIEQFpFqYdUjFxYDdHeuzlXFE8N7v7A840oEQ2wOfMo6u1JX", + "IUzkWbyghfEMlYokZIL7yh7uihJxzYwAC3MTwZ02Exyy/O90urwvWvuuUGkmCMlL3u4Fvs9P8E2U5vlW", + "DRtQU/308LBt4LiSg+94uEk9eUO/bz8Nz5gJJYLHMiDQVXA/qJGJBtTThol/FTzmgE4lOlUoF5eMbTA5", + "dJURBu0fKSO0EoFCgMK9ownxycNPs+ZIfDKt0l7t8EDdaR1f2rgJfc+OrCAvregFMUF8ZUZgbT18qfwG", + "uT57511Frni5ptW74LT1LuhyC3zs9w5CuYmDacZnISAkaYgIeSvMTKBpE1sSUolraR3VQBC2z4o85U6w", + "FaANBSsuJWe2yKFwotUm7ZN2BewwrFBOZrio2PqluESxm5330HkPtu+8hyUCM6kEqkYmqLKJ2b3pFoKZ", + "hcoqDQwTa6aEUV7h+m/OMFc0gWE3V4SPsCTaQ6fZArd1D8K9+uwf573B4EJqe0EJjwcDn3txMMuL897P", + "+zfP9UsTapa0OzHtleA1nD+dNymeV29ikdY8q2/DXL/u0g/r8iqeBdqrksmPhJdxihkvVDL3h+C5BMx5", + "Z6LBSkxSbKebwgpTPqnjRARMOjfSxqJOZRhIzAkx4fHnIeBd/1xtJSi2Oz2dq10J6oUwDgSosAtswRWf", + "kc3hwntAq6nhZBwojMdzdnzthLK+7jP4XPfPFVZ4GhhB5twAkdYR4QdERdXBi5cnB6FKnVb7+MaZgOek", + "SM8VvnPCXm6l/ZNwjDcn/+6W2S6HP2Q/hDzz/if0nzhXez6bufe7eaH1hRTW7+N5j2K2LnlWeNedSrkw", + "+nYIwqpgQUONmCzKmQxnWs8yERH7gNRHseBS+J62VFA2d1j/d9zKBBxj3l8K871z+XHwcqE9aJwwam+g", + "sf0xnxmeCht7eU3EW379InqO2xNfQB4qB/V7JzovcguZBa9E+kqbH01mMSTYr83PbpjoRe/nj3fF+QKu", + "fLHMbxXtpLgdDyxycJEfiEDUxAy1bXIwwaYoUmrDFtoIFruxX2TOuEnm8tJPSFw7wxMUcBasUCkUsziY", + "64U4IOZyUA55cF4cHn6VAJHgX1DJEuPizZIVKqd0n2VziucAeyWeoKwEbgEJnivQoDY8ccMe4rMuQ+qS", + "BgQ69NX214kR4bnnGdW0QN6HUJBtEk9htDN+MuFBokuZKkdFV0g1BSMp0LmpWDafyoxhoMO5Oi5X5xX4", + "iNoNXMY6mWUNRcTCjQFzDlcEXDU8lUpYu5NoRSddzmkjZ6XQUm7cAaDXIBgGO8raYQwa8m2A1Y3AHzel", + "EIsbSagdLOsBXz4zNSMJVSdUo6cGbL89RQ+4SgeBP9yeuvsNpM26Unb/XFnhItGVIxD5SXWD50fE/XP1", + "CZ8fqzTyXKUfIg/+gqml33Ad0hbHnUQfI54ufwuktIV62B5ETcjc7ldvybjEzsTlHbcPJuGZ0ExEx6H2", + "hGKYnUukVOFGT6PvN6NIO0tBw2BVywTYQ0LlK/+rv4hgCiARl3482dJfXzGVumLiOskKSMbAQIJGa4DS", + "PnUAmsNZxF3LEq7IIR7Vk3j3hLQaVAfAG0uoxBW6WcZ6dOFomIy1T0lFSovyRbrQzUkinhQWQ6fhUkrm", + "XCJRpYISDsJFWQadYP5cqs0Mo12IJdqgwnaVFcxyvgQoPoyRGV2odOCMzBm8PlRCefqwPi3M8lKmoEUj", + "ME2E/B2+JfzpPE/uU/O6PlLM0H1DeRZBhpInvyGxNRICQ4ppJIAqTrcTYohHrdNhksnkYoToUqXG+sm+", + "gEYYwHJPB1oOcNtzfEuIT1QU6f6zHuGpxNA+OEMiS9zzMMeWsJZdD5EMzQdwnbSf4wfB0xcVo/S9WSXi", + "IF7Ib7RAhjbMD0mm2VXKu/X2w6IpECpafRvs8zfcb7RStW943e/gnoin2bnhpgSEDg0+gzNzutyk3w5P", + "/Il8LUJw2F0cKOZdaz/HmPrtno5wLbXcJ7YiVkrAN/sKWG3YpbRyIjPpllHp85tBie9l6otn6atKJr1d", + "8QACNdcvw9VwX6z+pVJKkBiY+qRwDk2J3js1W5ZqBA7zMo7iJNERRmF0KOUZwvnO5CVW8HFzL19ngltB", + "fu70tUSHBC8E/+O6z5Y/V/Me5lyaxvfVyxB8ek+4G+HflvMAoN/IlY1ToarihQ3HxJnPy7cTSoF3IkIZ", + "5Zi7U6sqaq35CuFOnoSW90jytYG2UD9ay2kr4iLuYpuDD09SG4JIN450JxISUNs2KfdtiNe+J0KJ8O9G", + "xvXbBCv7vMQC66oQi59XuJljasmSV9k7OVKszwu5bLewamFXJoKx81OqTR1jCWLiSzI5lRlYK1WBz1VT", + "rV9f5xrXYcRcKNIfrBcV7jMrxLlycyqwu14YmHFXWqRm0g2nRohU2Aun86E2s4Nr+AcjNw6uHz+mP/KM", + "S3VAwFIxHc7pyvCZcOZaaWOr2Ra823dYr2WF9WkdE78VmMDTen0kHZNOG42HvlL1PdHLaiHsm5ILHihi", + "y29JYsHV1bRuiJd3QRmVdFKtzO6MX4gy2/Z9ibVrScM/+kPceKmh2+NBTknuy5Fi5pMJWrQanKrX7q5y", + "AuRL+VlPPKaYZOUBBf/m2563zrJ2Nkj50tmlzylONSsONHCHkOccvnMVQbTCrOsibU1jWivY7mXVWsJy", + "Ur9KBVYCGJo5mVxYtqe088n0fXrVEsViMCvmhbzkZvmMuQL1nQtMgFItkYGpTjB9ZrkUsv37tTLMtk7T", + "CH4n/VqJj9IhdlFTpLG9CAPl9XIAHwSH+jjK8RFy8gVmOvZXg9f0DAZG5II79o4NBpQr5ZCRQYdeDfi3", + "aHQfPw1py++JPiuJ9G/KXz16/UaUbTSZUhyh4+GO8buVKENKthb26hMp3dPBreZpupWyh5ID/WYuRlgb", + "KXdudUw+xVs7V4y5paMlkcE/5CO/LH2kVRpzudaTckmF13dIHYFV/HAvhufqxOipzIB5Kq3EInfLijNX", + "/MobZr2XRzQgWrJlR/OhdTo/wFlRYtpzRfXCypTBQ/ZS2jzjS8wLTHOGlhDNRV/5qWFm6SXmScBUVOdq", + "HEcegR1whPFwYrb8S47pFkZJmo8xQ6xzMGnsCk5nwe6OufeAQa74lfgkbqW5CUs6wqY07ok2K9syZMfR", + "ZWPgXTaqQ4C70cuTc1WZxpTS5WACpQzzM8HEYSuDudLHW0Qf6HBgGG3xr0KYJeAAXwgnDJP2XIUUTZMl", + "0xnIw5SQLgQ0GOG4h1dmAKahwjU2PFcR08bxUMYslTb3NwhnE2HdQEyn2tQcW8jppY51pB3yzijl7vrk", + "LWVMNCX+/I4bIiDrUyKYhcdVp9k4PDbGlDGRcYXrd2ypC5bqc/TIVgIyKj53LBPcOtxO/1RATzhojplw", + "JvHMY7rs1RSD1oncYvV5qeAhJC1Zd48qiFCecR/3CDVmnlDwIvZYFNwo6OxiulvK9XeunOHKhifNEZNT", + "xtGsaUrvSZgN4gyMyk0mhalwQYbpv8V0KhIXclQvONI8veEo41oiSicoTNbz5Pra23pzo3M+4w7dBE+Q", + "mnwsAQgeVgCmOcHGpaPGv/uYtQO/8DHasn0asZh53mMYmGpnMwGi77minSXOFflSnWk1+n8GHvMiNMJA", + "QU8BFoOqWxwdqvQfeIZHI431NdjYTxTZB6KGuRSsUPAK9U6ia9SC+Bt5FbB0b+su0WLIxlXW5PmSJcZU", + "5QbaMJHJmZxkzR4NFN0E+9vIKqhIlhc1MRy+d9RDHtEL0fq9Ft6JKX3DPV6WEC9dC2P51PhNuaSmpEs/", + "38oTZiXuHo5cjALFNTgwnb0a/NknEK475LIFz9n/+z//l5inFQuunEws45adPD978T1bdwlvjJgOrUYt", + "8QGVGZCbKhv/ek6+++e9o2p4wM8fxx0nRJdK02w8sXWZxgI4Nkr4zRoL+NnfxF4uGrM9rK51QLW1DoRL", + "hiHBf6IXE6lCPsF1sqaMisT34GcskxCz3Hq+E6WEMtF83Re3rCZBwYj+nefr1TdUFa06sLYRP3gCockh", + "zB5T5ID3y6Wo0irQiV9GmRhzo2Pd/rAa3VFH3ZAjo5pF//ng75Skbzga/Pzr4/6Tr79uTtX3i8xHcHF0", + "UyXUw0ZiX0/5TTHmq7Wv/D018vfU+m46boa/WBcusiq3I4HC4vaOay6BGEHh07LTAMF8bofMXzLRfZiq", + "ExmtHROKwryiN7zvDP/Yg9TXuQkvYSsy6L+HPJT8x9nY+64fnMQ8XHa8Twn3x7Bv+agaa41SJzJROm7v", + "YRUWi865UiVZkQoLogU2uDI8zzHELc6nlvO27bj6vShZNZDxhzfRWOyFK7EiWoktklIQlPosw/xsQFQJ", + "J1pz7Mnh0z9T6eN+SXpwgAlGsJCoiDzCHwDNYpI1J/JY3csNT5cyv3DYQTQVln2p1IWROTk/rOBkxIo9", + "kFxiETmfQQJIFfZtf9ilOMVvymBdl5iJXz4rlf0RC2JKxNrz9y5CYDf3gwlmMll7Nd+N882qTNcahxlb", + "hKcT8fIYqJSyfM6tWHmgP6f3MT5eyrcxqsSqMe5x//OssGt7v0NsZuV+jsFlDVFM/t69L2PE+tX+qXHe", + "jx5yyq8f54/eK8NvWP0YPhtO3zpkp3k5HZFnag8SI7gTo3CnECIVTW6O2DDWfLsvX8f6KDsh0+NNJepo", + "nb8hTR6tlCLrWVrZ1q4nRxXYOpzcS2x43ydHo5xwN7+1q0s8NFpiejvqfLq93zvtXoGD9x36yODMMaHC", + "jU82yOMbDvUVid2/7fOESf4ejtK/cTqfoq+VCBQ6+kXmGxJJUTYczv7++oTFV0vltRMeMbGcV1mSNKDX", + "cN21zY//Upq/y3yb6ipWbo0QSVp2Or5KQIgJi2rT+XgnsDqWVBU+W4u9/ryTkOD39VZ2cNj1sMZYFQ9R", + "r7rBXyLm+sOqsiHGA6L5Jd8Yo61LO6B0eMfvOW4qj/lFcDlBmRpg7W/E/HO1AfXZ361LmZ5OhbHMypnC", + "fK1YRcIX3wkDeln8XKWi+hX8zQ29ZiEIkZRHkJVVXGIaFuFWoSChNbuUVugO9uhLIbz+WiKSynLRL2rI", + "vpezuTD0yYYSR8wuMOl/qVqBTPtQGoSBa6gAK8+ATsK6I/a/4bQJBHvcZz49PBwsVP/8318dHg6+Pjxk", + "b787sPvQ0auI6x2/6rMJz7hKREo9D/AE2N7/fvx1pS8dXL3rn/r+axa6fH04+HOt09o0H/fx29jjyeHg", + "aezRciIVbBkhmBbFd/irVHz7rer1K7/RlPEP61q14N35pqfeWzHOsxUd3R+Eea6oJndgoKheCjkrPeOs", + "Mw+QlV5Dg65cA3mF33gAz7SpCwW/hVt6N8kz7kEDysFvTCpC1ls/3D8LYoFfd2UFPr8hXz+9HRArk9bh", + "e8G2YtYbad0rbHGzC+nLxKVy1Q3IVD40M0qn8QViEyyQ7BQU6n0T7AEv+daHJjiwn5RnfB9+/3fxyAQ4", + "FeXOF3iSuAI08KNd8HYMwQieRgVCIz+AyE+vPujGDnA6QTQF+L8VjqATJ9yA6m/eWqbBC6Yx1vYLQyc4", + "X1Yzge6APlbQdTLKhfHlrmwrhzgVyGJPKk3vLRB0ZaDbco0KqBC2+QUeNWT4XGMWrHJ0B/pKCWPnMt8B", + "B8gy3e4i+pwqq5QGbJ9lRJvSG4suppAfWiy05yMUkjxsSXcTxJQ78+qJklGL60QqrBsh2zpql4aEdVJ5", + "o53ngj6vvRe9h73+VtbW793Uy8JrH8upbnezaIBw0/Sej5vVupX0V184u2xI9DP1aLgbwQRV78b8VxzV", + "TOSpWcliJ71bX3BOWFF4rWBgG/mQtvfOiGdX4ig5kNNxZbCS6N2iu1HKHfkkbaKYG6L+32Vez/vml/m7", + "IQNezcW2gqI3oAivbNpCEruqitso51xtJ53tKuOahvhcraiI23O1eZ3vnZFfq4fc2VzELQu7Fa6hDj5h", + "n42smz242upQv+vuxOWLAvm5wZz3sHI5oNNggG0GZb/94W7l4Utt3z0wlOd+D3/nTGUVXW/MWK5WE+St", + "vEgcN+6V/Qlb3dNbpDLE7l4qN8wYj8turKX1o5JQBLahclZJt1d+Ozp5K64UN4eu7K7TFn8mdKTFVNX6", + "PnGgmu0k7+F+HvwaDuUjnUomKOfVKkbqvETIFYULKlG81sTrUOJJb9KjbFebPF3HlHCU5Az/hR8lbCvh", + "NXpQ30hVtnqMBxSt3Ko4O0VF0yt7fOmVKp/sNFeVYOB/TLNt1H5ts7Gc4iMcl9GYHuD0mBFYuH3LV7uP", + "5u71e3PBU1z1r73/HJyeHg98QrvBmQ//Xa1ykEqOAbUAEMBjiVYCx/ZWGeF+zV4abKOrrZpMoR+/RETG", + "jV7bZZ8hK7Duzjht5DYHMswT10UB/LIiBPI1ZfAn9EeIjv04+EKngu3pxPGMUZ8+w8IH3zx9uj9kPh4D", + "xcNvnj5tmyZA6bVM6x+Hgz/9/OtX/adNITObo87uUD19Q81MzFL4pV/WqGKD+zn4y+7ihpfpmT0ot77Z", + "MKpnlsivhZevoIwvXr8JtwOz8kRQphFv4lb95mGocnWzz0itnnGlVvkqIsTgdonldqeM5s6kDdnaNpBu", + "+820yziVtTePVjYY+dKtvc92K77Rs47XISDWb/oGbLpdYNIUX316etyVhHwG7AMxM8Jan2xgq+MfBlFi", + "jxAmu1b30FdILYtaYPi3j5gZsufhT6Z8kbM5t2wihKr2iVVGpzLDotJHDKvCtFUbfUerOcapndBa7tH9", + "oGm4DVkEazvWkg6wrAxZb33zip5nIsvoxP72FoISKaG7s+tDYUp+QDLUSjiNMYvApjIZ8kTEjwBBZFPo", + "I9RUm0SkTBcOEwfQWH1IHEEVeyurgdo9FCkoLUtFJifCUNkVpR2zsE1zYcRRCNS8XkJDh+Vzs2UYC8t0", + "Y9IDgsV97VCW6HwZ/KWq6i2asqpMjyWY5Q6hpkZOfYpkX83zjNoUlEFPWkLGaWFFGaGPYZxUpNPowgnm", + "DJ9OZcI4ppOn33EJQ3amU76kb/xyII1IohcLTHpwhqW6h3QJ+rKWyGuuHeRBMAaz1Y8R2CkmbxozbfwX", + "3y1zbi14ioxDbo6TjC+vDARdM3Gda1gFt2zsY9SGSlx56Hu/+k3+uD8+IhVshdbgIhpXToIreyWMZZKy", + "iVBaE6cTnfm0D1JZJ8DOMgXJ9oqb1JeFdToGZeP+vk7FItdOxAP0NN9UQZWSXMWC84FvIDdxrMh9xWRB", + "hYmrOAtteEoVzMn3AjNG0knzWIYxMqWzslSWtGUJH6yFIB2zhbmk0kQxU4JHtZgPA2ow+HvuGeMBV+jg", + "fZVHDxYAhkK54BBruJuHQp7E9ujNG/lrRLaJYJm2rokFnhStLPDudWSt3O/ThQV2ZMDHtavK49rnTdV1", + "e3YPt3ce6fzAl2/oUFbETKQz3CyrXCLRqSAPs6kRNhSD8ClUMIAcCyXbWq3RQEDnCjisTng219Ydffvk", + "yROiJYQ698VLLTLRRzmfiUd99sjDhT9D6VJiBY+uxGSR5I/O1SU3EiLF7TB8OQSqxvoxe/uPIvlUpjS4", + "Ag5PdfMZpqGziud2ronPnKsASKpLfSEA1B40+yCmfapy8j/77Ffm5ELowp2K5H+yj/uPGLW2VCaFJ44Z", + "MZOY8YSqwmP1d58aB5IkPbLMLlUyN1rpwob5PD95PQx/B84Q8zYBkCvG/e9VhENeew4cxhX2hU5FHze2", + "j7NKPPHT3k10uvQpJ+gEjLBFFtkUnkd5tNL6LRTpufKpnAL6Ipc+vhQQWwkZpUzhq80oD0CbI9DICSrh", + "krJ3OhXDf9rA/eiCkM4yfaXC6YCdLVTyG7IXmH8GbU+hKnEATYmSEq18duRs+cynA9KVDFahNTQGHBSU", + "6g4ODwRMf4h9lhhu55hmyxeHJJGcZVrnIWNQhJVqYVEW4Zj+6FxRBZw4syF7jukTeICP84ndqWC5dOVG", + "YHiH0f7bhp3A6wWPhk+4SrUq78EwhL86ADgIK5chfiZc6GFO5wrXSjWd1xdL2VSwhBweKm4mL7fdF6iL", + "XMAvAXGBTiuk3HoUujzyKa3quwCPv5Q98i/aR0Es4dkVX1oqb2e9EHiu4nlyeLdazCL5qESy8/AwPu89", + "GrLX9YxjoVnfMxbA6QlJX5px5VOkCeb4xN+qtLkojAgER35NgyupUn0VGDImnqHqQzDcVBsx81Idn1AK", + "m3MV/aDKkvgAg/Jc6FwoXwZLxHdMSCDmZ5THPqE40rmyIhMof/sfpGWFiqbuYck4w9zq4iIdqL7ybDFA", + "O1ewPUP2eurHH9COoL6PAp4SYYNU51Ac9TaTfoVj1FNGwf7WShVSQpTAz4d+psirnfZzwWzRNNWQrk1c", + "w/0vXbZETDvhSDVLX3sKcAm6A54hEwPMxauKsCygADE8KjiFbfxilLjClueKxGss982OeTJfAUC7xumE", + "XztbhQWnaT0wWH6JDGwlB16VwGGV/lJbx048KACgFZCoWfocbTR3DFGToaA5DD9k73MsPMekO1eRTdEh", + "+drvEbP0lDi1PxzCpWegu6nONRwEXNFK+1b9c+WxlhatFeGNmxNoaVmSaSvSNW5S7pHnxiqNmP8IdtVH", + "6dPD4hFUAfY7j9wv4SoWpoTToeN3fGLLG7bEftzVIDk8Y9EF0r/oYv4Z7ho2H/HsebX+OpvzS7w/Fto6", + "9ucV1LDPGrlOeVkkulAOLh3YiXNVkdaDYtPfI0FmeXr4LSFolW/aZz6QGhkFXfsvj98cnx2zdVFPG3vw", + "K0zz45C9q8/WZ/Fx8cETiiQnZSJj4rvwXoGr/Rm9rwDh5oWzGI+I57tEWBEOcSnpj4XwoOkhQicrSgnz", + "BWni7+MdsjbWZ8pR0jAPEL6ak89EQexOrbTf3l3Ol7iKQKRv5EK61nQ6Z4Ezr2B9SSsTsdSEPiwXZhBo", + "LwOwd1ourpw65go+xVl6AWv9EdMxqW4T+bWqSd9I0g81cAy8U3w2T2iwwmdiIpPJkp28Pz1roHux7hgK", + "460fmL1P1WcTfthGXIdbq1zg3UVF1XRc5Ypvepiel9a9PFZsBFjZssqwH0UxP/D+qFTSyE0xxaqXRJRX", + "klmqPYnSXsSLK25DEo0h+y4mN14drXYBM6c1ST0wdbzFJuJcGVFYSPlVv539e4wFIYhkmTg+96JtUH6u", + "Ia5XDpOLUEXP56+Go9qbp8zH2Gfc34m7bAyr7ctKCdl/FaLwdxFKTOeKnoYgIGrlFxaP5bWXhpWG9eFb", + "6xFu38jxyaMg+lCuW5pbY9Q/pUtZQ/pO/iH4n00Gxd0IDS77xoB+WFUDwtSt5TB2m7k87stOdslOfknH", + "UWT68jPFNHCeroyHsBK5Trt/4wm1gi27t/IycYTPJCzVZtAmJpVFhY1vcwukefLkPib/ivR3m2fveWFU", + "yYXyxz4DaELFUdCAlhcOORumFVfaUdEPZ+SqFD+84xK7wRZV0Vtm3fXQHq9tzq/UVsQ+xVb3itk4xOdF", + "bT+FNtzGnz+zFWL99Pmtjv9X/wf6WV7ILNuKCj/ILOt0h5aQd/eyvDcsg9n/JquWvv/hi4xzBfYjZ4pn", + "lDU/uAvdHAcpcfhWLPxAzb5YPKT5P2Di3QXXw36CpHf2X4MJFU+4C3QkE16rq2K4OKjVfWPjPd9+tIim", + "i8//8kVm9gkPXBvO6DbIkMoOshK2+mI5E07/M8thNIU2Oey7pRM2uFN/sR7U5X3JrMeYW2GmLty6Y/UK", + "Z6fHCjkRcKzlUSgnM/b40Hvj2VhpADPNo9H/p1gRi2rl9quWcMvsnBt0/7LFAgc6Ykb4BhQCLFUhWKEw", + "h0vlvZRqqn3kqw1yDwN1q9KRDXzITgvM366nUyvcXw69iykk2EaXMFQLi5lERVX/XPk6udiaacPecOsG", + "6EI8eP0yeJHlRlxKXdiKsy/BheGZVKnIhUrRiWF4ro6vsS46Jddwc1FuHi1myJ6TFY923zKeWc2E93CD", + "1kI5DFkW17k0AipfnP1X2AlpGb/kMsPyVN5oxrhzPJk3F7ENFALOLpuc5O+E1fTX3YlxjwgTyv2U2oQF", + "4Xai60b1sFDPurpvP1rhN6l+TLAnEyzN1aL1ovOtqbxi6IZU7punWyOJd1hX3St8yKAWrQUcSkQqVCLI", + "gdujnNXlm79KBx63iLrc3PtaAwx5GRw+4mrJib1cbm13Pp8zfsQ96NbRLT+wuArdZ3IqqCLgQ9zavcWt", + "RVqr3DHaH4B1qTBm57gDwGb0Dj4orS3NghCpXT+E9veaDz2Osr1m8yrF+46fT7/9mQpVRK14uAcxVgh2", + "Q6QMag7rnUK6KnjhM7S2PpdCCtcqamwMdXxdhs/HXLbh2IJXudMxF3M/OKSR/3hlamiO8oXM9EI6F5xh", + "ykKYq3CljXDbS+rhfdocrMgHvzwf/P1w8O3g5//xbzfKqYdncbDIn946iV6J7P5kaxw3/jp4JZW0c5EO", + "njeFpciFsI4vcjiL6NxvKqCp85D9teCGKyfoGCaCfXj14quvvvp2uDmKrTaVUzIg3mgm3vh404nAVJ4c", + "PtnEM6T1jk8SS3yiJ3if5ZngVjBnluS3QNbO+nZ/QGpC788Ge3Uxm1GmZqiQis6kMEIQzidiqg1ZF5ZE", + "PeUiorzzuEHe+fgFp3um4theWsKEQHfCrDJpXSujAncFOmxxe6eMmONu020WRqM8y2uJ49YoGmZIxvww", + "yztz0yBZvVz8jhu74OaiPaaB1mmjL6ivg6sI133GIK6CZ2QEizV9p1JhlTvCCW4uhAk1+/9JLrgypJry", + "Aufbk6dwJyRznjthQp91f5y33Fzct8BSG+MeU9TsMIc2Fctb3KdIaH8Y0eh5mkbMJFzxQZVSDQKbL3Fy", + "d9rAi2lLmqT7RsP6IBvF5sebrkB/yX6BldpwBxhnNjFCqCqPeQ+eyFRXOSwzF4a9fuldtXwUkTBUStNH", + "rtwED3S+CQ10fv9YUBnj5m8n7yfxeSPznM7rAmD3A8mz7eF3/8EvuXdJxSCGEGWqXAyh8hEd7MPxyZsh", + "O43V+6nM91xk+RG46Y3H439a1HhmQ/hyb/8Za/vfwQHD23gh3FyntV7nvSSTycV5r6n7wQE7BYusK4zo", + "x0rl/fDQ8UVffZncOtS1QDsYAWeNzvdRTemnBEsqDg+/Sv7bYMC+O/7r63fsr8fvjj88Pzt+iTvB3h6f", + "ff/+JXvz+vSMDQbYWEBBF/jxiI3j2OO+/4BpcuInsZDuNQTnjaHTd2W5Tmd0dsTGUFG9z8ap4VJR8if4", + "CJLzK23wC/g8007/aDL4E6IKQMCCvynAUU5kJt3y1Iccwg+4t/AHiGBnEM/dxwjr7LXKC/yQG/AkEEv4", + "2yZGZwjc+wSdIlMJwDD6kU9wYj4y7oxPsOOVdMncf1Diyv+FDn3+b6FsYcQHwTP/hZzCW5lCz8NS31YX", + "/UbztLoHGcbdV77x4bev0wy3+Z/YuYhJnuHT3Ln8r8LhnlNo4xEbrwZzjvvxuxJdKl/yNH1RWKcXq60B", + "QvMv5JZa/jauotfxu5fdkOtceTwZeDwJ2IpyYqlqxwh1yk6WLZEktIrh9mPy+8IQt6nRvwh1rprCVZNM", + "CrWiw+c2rGiMYAPMof+y773IgHsmuNhzhWGvPE37mPWAKJS2I8x+uH4Ee/tjlkqbgB7PYuRsJepm/Nfj", + "M3ZAXQ6c32mczno07f7YR2qOyX/d96IWkLfjhV4stGKAOFOwglR5GceHqqexvfNeqD3tGcww0QviItSw", + "gqd78G2i0bnfCMH+wqhJI2FWGmdSXbC/YJ+h0qmww6lU6R78yf5CaMDgw9DoTLC//OUv7LwHfc57DH59", + "8g39S23QDZvavNWmVslmOBzSzOWU7f03gLDvQ36VuGJ4Ee0RZPT6m4L8Wl0q8pE97PfsXIXZY7LUsNQ1", + "lrF33jtwi/wAQ/NyNTvv9dH9t88ef3N4WMKus8e9XwHqxwqvPtP5gCplTaQCVPNBrUvFFz6kSC58bOVC", + "p0UmYvIEbxI0wlvQvAKZbgpOiTwgDixWIrvkWeErhcuZ0gYc2WFq4QlGKSpK9r43HA73x30092m4gjyK", + "o81ohfFT2yE7kUpBcXmsqIx+vJ64yriAQaKNGLOcJxd8RvM5V+umNb8FbEzr39sPdJGkOVBCbvQlxqEV", + "qpJZ5aW4RJrzyBl97g1s1kKEKNyM/yI9N5EYRl3GBVfSTAzZB2GF6+N33lO+H2OffUBwn71//7bvD4AS", + "doSq1ynMSy8pOtk6itpJQ75M/PbFj69fPqHNHMl0jFZM79pKJ2WFkVQwHlidtEyo1D/FV5a+GoFeZmSJ", + "cZOQOQZesJc8E/4xbwqgVMRA/yCvBlevuWMD5Ocnr+0zJnEGQFCWq3SirzdGq3le/wHkuPuRkysj1J7s", + "dVHxP07fv4sJAiY6lZ4gMFSKlI9/Zm/ld0GDR7uLKa3p4XHmUcSIf6K9kMPz0855JlKWcgHsN4BHuw2q", + "rvH7R9aDVuIqk0oMUhFG9T0G8DVNheqlKa0GiEQFKVmeHh4Oe5/Sz6O2qd0i7vZ8yB3DmPdY8d3TxP6t", + "XqGPv/q8zrz1B0YlQhwFnY6BCjbhmXD6F2E01KAHptf+tDkx3ljqMyuhwRsgYDSPZgClD49dbtIMd33K", + "vj87O4kJkyjsBhNChAAgQF9MTyAtgLwC7fgV1JyUjk1Ewgsr2I9KXhg+dfTrSowrtMXsmmoZkd0zj7+9", + "bQzxoWWewsrP9N+F0b0ugS3YfuD0AFbJ/F6ld3KiZZKkbBkg476KsKuVLeqsN6gerVCbT/aDsE4bYZkC", + "OSZjtrbY8ByszKJPyZfKrE/16ZIdg0KN00zQkVPfaHj521umtC8typQQqfXWlrnIUhB1LkQjD1e3Pz2h", + "7unwCPDtzy426ZShzz8RWezFEq2mclbQtg1ZaPz08CmmBojtZIhqp+bNt+ZfhTuL87lH/h4HAc/RRifj", + "s+YF3lRhvJ6YrwV+t6R8IZn9CtPkxklkVVSZio6s9ahQl+hHkMJWcmYwKyKnrwgNFLhPYlz6LJipqyDI", + "q8PH8wdcscI5kPB3Qg52Sr18Hos4dcD5sCuA9p6+fBJHlmSCGxsSvjUj5rfEGMbWaQPPGA9iDLMgKFjz", + "uczAhqkXMOdUZgRPl2Vae4LwbH08gJWJKTxW/H41OsvBOdYR/t4ExDjMC5znp/acvTHFfb4qa59J+f8j", + "rveWDKIpa+epcFs4QqCRJ4eP6/R5xYlAKw45Ja0+ixlInhweQj9Uo1gg4UwkgRp07gZSHa1mMCTiA+hV", + "PrLHy0QqOA490kNeVytciDvGF6jnEYEtBIlpv5UdPIupmGS8U724sIkn/SZ5SOE+Hwf5zXOMuzRN33xC", + "Vrgv0Qp5OzGlJlxWSmQ0PwteK69XUN7fPTpKlFMgr90+m4V0JtUMVSsTrTKzwzItErcQDShSJtSlyHQu", + "ykeCH9Yyngb/uyeHTxt+D8ls2Z7SYfjgk6dN2faRLVmStCVXQpb19PCQkW5SptwnQkNNQTONTzJpS0mB", + "fJvvKcqGxsIhPlOUTblOf0iNofB4HDnNFlW64UQTbvASqZ23haWoRAyJKzSlk0CAPElEjuhVuPKkN+Pa", + "M7obw1SGN6f1Gv35k+hAEruT47ZAHJ93Da3DdYf5cmwiaZ/3Dg1/eMH55IYLNpbpEfvVin99PD9X4AB/", + "xH4NhzQAjIDvz8/VGCQFOh2msHgb6Sa9Qnaw0Eo7rWSCqtlgBeCJ0dauMFqvYoY8yU2BNWpZhtaUIUJA", + "nEiHMG0KhAgqI1r2kL3EZJswKQomJpSY8dyGZ9JYpmNKk3oUUuLF4An8TVqqEYrZmB8zPvfJbkKsxcAK", + "ECgkmEdpZ9mVMMBKSM1dRhMVkNp0yF6gbc8yO8f0WM5gCsU1aOh+LJxIHM53yF5hHs5qhJSXrVa2jLJR", + "x2HL15w/KjJJ4mNRUOIfnPUz9G9m4/9JgTV/4Vk2pop7NXA6S4V1ZRhAwHBMAkTq5isJ+z3nuQh5KWdC", + "CQO2kTonHA/ZK22ixOh3T/jnqaddShtPuXTZHjSnNLTCWFZYXwxKJ8VCKOiFxvXxfr/GzseAxWPEOW0W", + "seDqIpSTGntJ6d9xWi+xMTG1fkybCeMS8CZOT9ER9eXZbU7oH+qxO9IyW6enIXuP9i7DrFApO2w4j3C8", + "ubaSHgPdaBKzH9UIC81tREYCyMx4E7Yfivss+21xSmPCmzFdvGgFp4GFxbgtq5EhgWp2EOOXyuEywQEn", + "a9mkBgQSTmgurdNmSVt/y1im/rr+BRB/F4Qfsg8wKyJpsLZaxh17fPjk6TPsEJGZVzgBEJ4tzJQngswl", + "lFQUiX1mBHch5/vjyjJXwgJoR5rjjrKs9/NNogFuEbnV6cZ/0+Ey+uIqrKyuAE6UyjEMToVyLHKAThf8", + "lZjwws3VwVzri0ohr5WCfpgJVqu+fzhjxly0CdMtHtggmwlnyQ1R5v69Huo1jBW/lDPutBkmRmAUDM/s", + "EPx+yFzd/Duligv+HHDfotiUDC7EklUaRnM4qe+PaqrImS5LxMOGaDTtRBlfGzmTKhaHiPliQ33LxNuE", + "wjJ9uQi1JOVCHWqZuxsXvpKuuGJlfkRpySU4lQBUr1I5MfKSO8EuxNIyKichVIixRKvRuTorjE/CC1Ga", + "6LJo8UYNM7TERmZeJQpd/ZnAzB1WYynb0jl5NQPmoCW7SSbgbzryFfNVTPpdmhh87uOMz+6gcMXaMhU6", + "2ljvywHdyvmHqetcKGR8gMwiDRmDlzEVLRh66Dc8fKnY469jKEq9FgapV6BxSH+s+itbTOEyM+GY9ChR", + "xbnoXot5s4asvpgyBe9hzerkUwGW6PTjhzdsb/zD8Yd3x29Gb4/PPrwfPT95Pfru+enx6McPb8b75M6N", + "qCZdfZjpNGQ7R1OzSG2LPugnMXkOXOB7YAL380qsDfGJn4frY9fZ2/f+lJ34TdTlgCNEfAjzJn6LuEga", + "Az2d7sDgwfWN/PIG6De31W4XKD46hlNvqmURayqgbI2Kldcv+xhhYHOeiD5Jt8IQScQaGAvhOFyUzZlj", + "yUmSnBDRL+k+jXlrg21KHhQKZ/k9qJT1sMO7i1BqgN7BS6Lfohsrgz7wSFI2gSMBfls5SUoXW34OHAuQ", + "LSQc0gZqRPlPQ0iLX/6GMII7S3jVQmd2KXnFA2RYAbHSCRpCDSqsigLDFxbLe7FJxVvE99mzQrAxOriP", + "9703K5UAxDSFAl4RnLKQkD+QWOQOWL/hy3Olp+AuLpWsPGCBtXpctf06krK90qWVK6ZDWVDvAEiItO/L", + "uYTVTAtF72OaHe15rP7EnfaOikP21o+K7Aatki66N1auNQCuKHgS5Sxb9bTVhRvo6SBmu6UWzximrY8P", + "TFyVtL4CF7y/E+Hrl5wrSD5rG4YO1bDQFCIVa3C9pftZe80500rgUOTuSyonaNcPueSBYQCbQMhpip9r", + "7penwp1TXbURvOqoumzE4Jh3IwnySCwrQCssE1lT+3K3n52rYHfWxptaeJoG/+JQTISgU3F/D1krAcqq", + "8LGsdFMmgWm6T58HR/FVbrbLpeqdjZH1JWk+IvKBT9UMYVTxXrosklKv38PnNLSMu9E76lWcl+E9goTT", + "O+r949dzxdiFVOkRO4eBznt9+Abx54j9Wphs5CPA7RH7R6Mz9MG/n/d+/ojdYEuPGMJkeBgAFWSzEawB", + "J+oHYKzCsaAVLiaUd6gtaRi7YG2kU6S9I/YrPJegJ5WUB79inqaSCPUk1rT3dn6aH/3r6fWIEk2yvRHC", + "7bNfcdXCftyPXtd7fi04oSPv4/xPu7dXNglEM8Q2ffYrFS55nR555mL/cfjz0Ol8RD9AdqN9mg385+PP", + "51hXtQecc/sxV9jsrY4aANzXWeNKuh02NKWV3eEpM8+mN8DIKz1/9Ycbm9ED/BxOJVacxQ3xa/p5EzJV", + "cccDrmNI9dQ/dk3A3cRTPlO87Y7CUylu0D24kn8YpsSlsqQYRh4urrIlta1IWV+YJRQEsJuJdC0y+8Gv", + "Mt1YF+ADBtdQdaeqUDdZ1gT1IXuuKjdZfDpXkj5EPwauEpFRopD6DfehEtdUIkKnrF1bsnVVso0kbgQJ", + "R36Gfw4H3/7865OvPnZLOtJgqqvgYSgWMPysuT1hCph/bhVHdkMRimjaZCS/xJqBlJCfJ44MdLXKgTJk", + "pCHLh9bZyIjpkL3TagBKc1tMwBaQiiTj0OWSrHUU4xWq95V5wKTxxf9IC6/zIuPOK1wwDQLcoVLNRgiX", + "jOCUyXLI3lO1JYB7rqAdeU8zJ8xCgvxNKdirYrC36nnlIdX0K58bVUqgS8EyPtGX4lw9eXrIfpDfxfmH", + "AhDVGqicOVMoqi1IQ8cqVFEfJhcCk4H5HShp61xhGj9LFiGLKtqyCFvhEr0Qo0JdKNACglxMyj5SGNko", + "Q69kXG8QOOmQa4R4Txqcty9OaLANgSPI3vkVWw0gQZeGSvTIYwzxyLPCsqd4EHpaWuThCYD2Th9dEsNK", + "ep9Yb+RXTN03RHYE1XH0BiDFZslnVcqERMwqSYLeqRUaQyu4NmWVwDXUH34Z2UGh19N7O4cN9Q7KRpBE", + "k6s+umVILKTnH/BAd77wtq9toCdInelwhU0TrjMeg1JFenNW3U31xmOtWKCHymC2qo+bLP0rGDXe8GLC", + "wqtLJhYTAZKTr/ynXNBzu7m2+LYizfp7RV4XaAf0RNoPFm8f+rfQSjpt1sp8QvA3jhcqTZL5wIggTJyr", + "qIgnPh2K5sDw/dCNvgoTZmG+0FX4ojoIAt0U1gpPgPIBZcpKYbioR4cN0aaETUYqnGZlE91cLKiIEYZg", + "+RtEWLihqAgk+ql4/YIvk4HKIP6vQsSLkuDGS5SiFVvu2hUtU/9coRGtjNCFy8lXc6Vt6lPBIGgWlVBN", + "6/JBnimVDoIKmOX8tC8dHOqsrtYObomrqKsvNvoTHF/j9tS0i/44NlT6EdRrRL2ay/3gs65TvZ+7Zvud", + "FcNNhZ4/p3D50jOrOvfwctKORec+fvz/DwDGktcSAQAEAA==", } // GetSwagger returns the content of the embedded swagger specification file From 54f0919fca8e6634a7830ccf34b8c96f0a7549ac Mon Sep 17 00:00:00 2001 From: Sayan- <1415138+Sayan-@users.noreply.github.com> Date: Fri, 23 Oct 2026 01:56:11 +0000 Subject: [PATCH 14/15] Preserve proxy error identity before delayed publication --- server/lib/cdpmonitor/handlers.go | 11 ++++++----- server/lib/cdpmonitor/handlers_test.go | 4 ++-- 2 files changed, 8 insertions(+), 7 deletions(-) diff --git a/server/lib/cdpmonitor/handlers.go b/server/lib/cdpmonitor/handlers.go index e64cd199d..7a672dd85 100644 --- a/server/lib/cdpmonitor/handlers.go +++ b/server/lib/cdpmonitor/handlers.go @@ -597,8 +597,12 @@ func (m *Monitor) handleResponseReceived(p cdpNetworkResponseReceivedParams, ses if state.hop != nil { source = state.hop.source } + // Detaching a target removes its session while publication may still be waiting. + m.sessionsMu.RLock() + info := m.sessions[sessionID] + m.sessionsMu.RUnlock() m.publishAfterNetworkRequest(state.hop, func() { - m.publishProxyError(observedAt, source, sessionID, p.RequestID, code, p.Response.Status, navSeq, method, resType, url, frame, loader) + m.publishProxyError(observedAt, source, info, sessionID, p.RequestID, code, p.Response.Status, navSeq, method, resType, url, frame, loader) }) } @@ -760,7 +764,7 @@ func (m *Monitor) proxyErrorRateLimited(sessionID, code, resourceType string) bo // the published enum lists it. The metro egress proxy gains codes on its own // release cadence, so a value this image does not know is reported as unknown // with the sanitized header value in raw_code rather than dropped. -func (m *Monitor) publishProxyError(observedAt time.Time, source oapi.BrowserEventSource, sessionID, requestID, code string, status int, navSeq int64, method, resourceType string, url, frameID, loaderID *string) { +func (m *Monitor) publishProxyError(observedAt time.Time, source oapi.BrowserEventSource, info targetInfo, sessionID, requestID, code string, status int, navSeq int64, method, resourceType string, url, frameID, loaderID *string) { var rawCode *string if code == proxyErrorUnknownCode || !oapi.BrowserProxyErrorEventDataCode(code).Valid() { raw := sanitizeProxyErrorRawCode(code) @@ -771,9 +775,6 @@ func (m *Monitor) publishProxyError(observedAt time.Time, source oapi.BrowserEve if m.proxyErrorRateLimited(sessionID, code, resourceType) { return } - m.sessionsMu.RLock() - info := m.sessions[sessionID] - m.sessionsMu.RUnlock() data, _ := json.Marshal(oapi.BrowserProxyErrorEventData{ SessionId: sessionID, TargetId: info.targetID, diff --git a/server/lib/cdpmonitor/handlers_test.go b/server/lib/cdpmonitor/handlers_test.go index 9138a4d22..467bff971 100644 --- a/server/lib/cdpmonitor/handlers_test.go +++ b/server/lib/cdpmonitor/handlers_test.go @@ -410,8 +410,8 @@ func TestNetworkEvents(t *testing.T) { func TestProxyErrorUnknownCodesShareRateLimit(t *testing.T) { collector := newEventCollector() monitor := New(newTestUpstream(""), collector.publishFn(), 0, discardLogger, nil) - monitor.publishProxyError(time.Now(), oapi.BrowserEventSource{Kind: oapi.Cdp}, "sess", "req-a", "future_a", 502, 0, "GET", "Document", nil, nil, nil) - monitor.publishProxyError(time.Now(), oapi.BrowserEventSource{Kind: oapi.Cdp}, "sess", "req-b", "future_b", 502, 0, "GET", "Document", nil, nil, nil) + monitor.publishProxyError(time.Now(), oapi.BrowserEventSource{Kind: oapi.Cdp}, targetInfo{}, "sess", "req-a", "future_a", 502, 0, "GET", "Document", nil, nil, nil) + monitor.publishProxyError(time.Now(), oapi.BrowserEventSource{Kind: oapi.Cdp}, targetInfo{}, "sess", "req-b", "future_b", 502, 0, "GET", "Document", nil, nil, nil) collector.mu.Lock() defer collector.mu.Unlock() From 15132ffcae1bb750a570785e0efcee276a8875d2 Mon Sep 17 00:00:00 2001 From: Sayan- <1415138+Sayan-@users.noreply.github.com> Date: Fri, 23 Oct 2026 01:56:11 +0000 Subject: [PATCH 15/15] Cover proxy error attribution after target detach --- server/lib/cdpmonitor/network_capture_test.go | 45 +++++++++++++++++++ 1 file changed, 45 insertions(+) diff --git a/server/lib/cdpmonitor/network_capture_test.go b/server/lib/cdpmonitor/network_capture_test.go index 119e34f96..baf65f51d 100644 --- a/server/lib/cdpmonitor/network_capture_test.go +++ b/server/lib/cdpmonitor/network_capture_test.go @@ -456,6 +456,51 @@ func TestExtensionSourceTracksOOPIFRootNavigation(t *testing.T) { require.Equal(t, "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", (*event.Source.Metadata)["extension_id"]) } +func TestProxyErrorIdentitySurvivesTargetDetach(t *testing.T) { + for _, targetType := range []string{targetTypePage, "service_worker"} { + t.Run(targetType, func(t *testing.T) { + synctest.Test(t, func(t *testing.T) { + m, ec := newComputedMonitor(t) + defer m.Stop() + m.sessions["s1"] = targetInfo{targetID: "test-target", targetType: targetType} + requestAt := time.Now().UnixMicro() + m.handleNetworkRequest(cdpNetworkRequestWillBeSentParams{ + RequestID: "r", Request: cdpNetworkRequest{Method: "GET", URL: "https://example.com/api"}, + }, "s1") + time.Sleep(400 * time.Millisecond) + responseAt := time.Now().UnixMicro() + m.handleResponseReceived(cdpNetworkResponseReceivedParams{ + RequestID: "r", HasExtraInfo: true, + Response: cdpNetworkResponse{Status: 502, Headers: json.RawMessage(`{"x-kernel-proxy-error":"proxy_connect_failed"}`)}, + }, "s1") + synctest.Wait() + require.Zero(t, ec.checkpoint(), "publication must still be waiting for request headers") + m.handleDetachedFromTarget(cdpTargetDetachedFromTargetParams{SessionID: "s1"}) + time.Sleep(time.Second) + synctest.Wait() + + ec.mu.Lock() + defer ec.mu.Unlock() + require.Len(t, ec.events, 2) + require.Equal(t, EventNetworkRequest, ec.events[0].Type) + require.Equal(t, requestAt, ec.events[0].Ts) + event := ec.events[1] + require.Equal(t, EventProxyError, event.Type) + require.Equal(t, responseAt, event.Ts) + var payload oapi.BrowserProxyErrorEventData + require.NoError(t, json.Unmarshal(event.Data, &payload)) + require.Equal(t, "s1", payload.SessionId) + require.Equal(t, "r", payload.RequestId) + require.Equal(t, "test-target", payload.TargetId) + require.Equal(t, oapi.BrowserTargetType(targetType), payload.TargetType) + require.NotNil(t, event.Source.Metadata) + require.Equal(t, payload.TargetId, (*event.Source.Metadata)[MetadataKeyTargetID]) + require.Equal(t, targetType, (*event.Source.Metadata)[MetadataKeyTargetType]) + }) + }) + } +} + func TestProxyErrorSourceSurvivesOriginChanges(t *testing.T) { extension := "chrome-extension://aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/page.html" for _, document := range []string{extension, "https://example.com/"} {