From 43551548c1cbde07be340b8ae3672c13268e8c1b Mon Sep 17 00:00:00 2001 From: archandatta <35818003+archandatta@users.noreply.github.com> Date: Thu, 16 Jul 2026 12:37:56 +0000 Subject: [PATCH 1/9] Externalize OTLP batch knobs (queue size, export interval, timeout) Co-Authored-By: Claude Opus 4.8 --- server/cmd/api/main.go | 17 ++++++++++------- server/cmd/config/config.go | 18 ++++++++++++++++++ server/cmd/config/config_test.go | 16 ++++++++++++++++ server/lib/events/otlpstorage.go | 18 +++++++++++++++++- 4 files changed, 61 insertions(+), 8 deletions(-) diff --git a/server/cmd/api/main.go b/server/cmd/api/main.go index 0ebe40fd..2b9eeaea 100644 --- a/server/cmd/api/main.go +++ b/server/cmd/api/main.go @@ -142,13 +142,16 @@ func main() { } slogger.Info("OTLP export enabled", "endpoint", config.OTLPEndpoint, "path", config.OTLPPath) otlpWriter = events.NewOTLPStorageWriter(eventStream, events.OTLPConfig{ - Endpoint: config.OTLPEndpoint, - URLPath: config.OTLPPath, - Insecure: config.OTLPInsecure, - Headers: headers, - ServiceName: config.OTLPServiceName, - InstanceName: config.InstanceName, - Metro: config.MetroName, + Endpoint: config.OTLPEndpoint, + URLPath: config.OTLPPath, + Insecure: config.OTLPInsecure, + Headers: headers, + ServiceName: config.OTLPServiceName, + InstanceName: config.InstanceName, + Metro: config.MetroName, + MaxQueueSize: config.OTLPMaxQueueSize, + ExportInterval: config.OTLPExportInterval, + ExportTimeout: config.OTLPExportTimeout, }, slogger) if err := otlpWriter.Start(ctx); err != nil { // Best-effort sink: a failed exporter must not take down the browser. diff --git a/server/cmd/config/config.go b/server/cmd/config/config.go index fe2240ff..eabba77a 100644 --- a/server/cmd/config/config.go +++ b/server/cmd/config/config.go @@ -60,6 +60,12 @@ type Config struct { OTLPPath string `envconfig:"BTEL_OTLP_PATH" default:"/v1/logs"` OTLPInsecure bool `envconfig:"BTEL_OTLP_INSECURE" default:"false"` OTLPServiceName string `envconfig:"BTEL_OTLP_SERVICE_NAME" default:"kernel-browser"` + // OTLP batch tuning. Defaults match the OTel SDK's, so leaving these unset + // preserves prior behavior. MaxQueueSize is the backpressure buffer: once + // full, the oldest records are dropped (see the drop metric). + OTLPMaxQueueSize int `envconfig:"BTEL_OTLP_MAX_QUEUE_SIZE" default:"2048"` + OTLPExportInterval time.Duration `envconfig:"BTEL_OTLP_EXPORT_INTERVAL" default:"1s"` + OTLPExportTimeout time.Duration `envconfig:"BTEL_OTLP_EXPORT_TIMEOUT" default:"30s"` // Platform-injected identity, reused to stamp the OTLP Resource. These are // the same envs the VM already receives. InstanceJWT string `envconfig:"KERNEL_INSTANCE_JWT" default:""` @@ -101,6 +107,9 @@ func (c *Config) LogValue() slog.Value { slog.Bool("otlp_insecure", c.OTLPInsecure), slog.String("otlp_instance_jwt", otlpJWT), slog.String("otlp_service_name", c.OTLPServiceName), + slog.Int("otlp_max_queue_size", c.OTLPMaxQueueSize), + slog.Duration("otlp_export_interval", c.OTLPExportInterval), + slog.Duration("otlp_export_timeout", c.OTLPExportTimeout), slog.String("otlp_instance_name", c.InstanceName), slog.String("otlp_metro", c.MetroName), ) @@ -144,6 +153,15 @@ func validate(config *Config) error { if config.DevToolsProxyAddr == "" { return fmt.Errorf("DEVTOOLS_PROXY_ADDR is required") } + if config.OTLPMaxQueueSize <= 0 { + return fmt.Errorf("BTEL_OTLP_MAX_QUEUE_SIZE must be greater than 0") + } + if config.OTLPExportInterval <= 0 { + return fmt.Errorf("BTEL_OTLP_EXPORT_INTERVAL must be greater than 0") + } + if config.OTLPExportTimeout <= 0 { + return fmt.Errorf("BTEL_OTLP_EXPORT_TIMEOUT must be greater than 0") + } return nil } diff --git a/server/cmd/config/config_test.go b/server/cmd/config/config_test.go index e8674d12..0654e690 100644 --- a/server/cmd/config/config_test.go +++ b/server/cmd/config/config_test.go @@ -34,6 +34,9 @@ func TestLoad(t *testing.T) { DevToolsProxyAddr: "127.0.0.1:9222", OTLPPath: "/v1/logs", OTLPServiceName: "kernel-browser", + OTLPMaxQueueSize: 2048, + OTLPExportInterval: time.Second, + OTLPExportTimeout: 30 * time.Second, }, }, { @@ -70,6 +73,9 @@ func TestLoad(t *testing.T) { DevToolsProxyAddr: "127.0.0.1:9876", OTLPPath: "/v1/logs", OTLPServiceName: "kernel-browser", + OTLPMaxQueueSize: 2048, + OTLPExportInterval: time.Second, + OTLPExportTimeout: 30 * time.Second, }, }, { @@ -95,6 +101,9 @@ func TestLoad(t *testing.T) { DevToolsProxyAddr: "10.0.0.1:1234", OTLPPath: "/v1/logs", OTLPServiceName: "kernel-browser", + OTLPMaxQueueSize: 2048, + OTLPExportInterval: time.Second, + OTLPExportTimeout: 30 * time.Second, }, }, { @@ -118,6 +127,13 @@ func TestLoad(t *testing.T) { }, wantErr: true, }, + { + name: "non-positive otlp queue size", + env: map[string]string{ + "BTEL_OTLP_MAX_QUEUE_SIZE": "0", + }, + wantErr: true, + }, { name: "missing ffmpeg path (set to empty)", env: map[string]string{ diff --git a/server/lib/events/otlpstorage.go b/server/lib/events/otlpstorage.go index 66e2f88a..3108c4e5 100644 --- a/server/lib/events/otlpstorage.go +++ b/server/lib/events/otlpstorage.go @@ -6,6 +6,7 @@ import ( "log/slog" "sync" "sync/atomic" + "time" "go.opentelemetry.io/otel/attribute" "go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploghttp" @@ -44,6 +45,11 @@ type OTLPConfig struct { ServiceName string InstanceName string Metro string + + // Batch tuning. Zero values fall back to the SDK defaults. + MaxQueueSize int + ExportInterval time.Duration + ExportTimeout time.Duration } // loggingExporter wraps the OTLP exporter to (1) split each export into @@ -166,9 +172,19 @@ func newOTLPStorage(ctx context.Context, cfg OTLPConfig, log *slog.Logger) (*otl } res := resource.NewSchemaless(attrs...) + procOpts := []sdklog.BatchProcessorOption{sdklog.WithExportMaxBatchSize(defaultOTLPMaxBatchRecords)} + if cfg.MaxQueueSize > 0 { + procOpts = append(procOpts, sdklog.WithMaxQueueSize(cfg.MaxQueueSize)) + } + if cfg.ExportInterval > 0 { + procOpts = append(procOpts, sdklog.WithExportInterval(cfg.ExportInterval)) + } + if cfg.ExportTimeout > 0 { + procOpts = append(procOpts, sdklog.WithExportTimeout(cfg.ExportTimeout)) + } processor := sdklog.NewBatchProcessor( &loggingExporter{Exporter: exporter, log: log}, - sdklog.WithExportMaxBatchSize(defaultOTLPMaxBatchRecords), + procOpts..., ) provider := sdklog.NewLoggerProvider( sdklog.WithResource(res), From db6db67a359116dd8445a373801d3e14d3aeab20 Mon Sep 17 00:00:00 2001 From: archandatta <35818003+archandatta@users.noreply.github.com> Date: Thu, 16 Jul 2026 12:48:06 +0000 Subject: [PATCH 2/9] Add per-session OTLP export toggle to the telemetry API Export is off by default and gated on the toggle, independent of whether an endpoint is provisioned, so an always-injected relay does not export by default. Writer lifecycle moves under a runtime-toggleable controller. Co-Authored-By: Claude Opus 4.8 --- server/cmd/api/api/api.go | 16 + server/cmd/api/api/api_test.go | 2 +- server/cmd/api/api/display_test.go | 2 +- server/cmd/api/api/telemetry.go | 91 +++- server/cmd/api/api/telemetry_test.go | 89 +++- server/cmd/api/main.go | 35 +- server/lib/events/otlpstorage.go | 57 +++ server/lib/oapi/oapi.go | 741 ++++++++++++++------------- server/lib/telemetry/telemetry.go | 8 +- server/openapi.yaml | 24 + 10 files changed, 662 insertions(+), 403 deletions(-) diff --git a/server/cmd/api/api/api.go b/server/cmd/api/api/api.go index b9b0a346..353d032f 100644 --- a/server/cmd/api/api/api.go +++ b/server/cmd/api/api/api.go @@ -30,6 +30,16 @@ type cdpMonitorController interface { var _ cdpMonitorController = (*cdpmonitor.Monitor)(nil) +// OTLPExporter controls the optional OTLP export sink. Nil when no export +// endpoint is provisioned on the VM. Implemented by *events.OTLPExportController. +type OTLPExporter interface { + Start(ctx context.Context) error + Stop(ctx context.Context) error + Running() bool +} + +var _ OTLPExporter = (*events.OTLPExportController)(nil) + type ApiService struct { // defaultRecorderID is used whenever the caller doesn't specify an explicit ID. defaultRecorderID string @@ -89,6 +99,7 @@ type ApiService struct { eventStream *events.EventStream telemetrySession *telemetry.TelemetrySession cdpMonitor cdpMonitorController + otlpExport OTLPExporter monitorMu sync.Mutex lifecycleCtx context.Context lifecycleCancel context.CancelFunc @@ -105,6 +116,7 @@ func New( telemetrySession *telemetry.TelemetrySession, eventStream *events.EventStream, displayNum int, + otlpExport OTLPExporter, ) (*ApiService, error) { switch { case recordManager == nil: @@ -138,6 +150,7 @@ func New( eventStream: eventStream, telemetrySession: telemetrySession, cdpMonitor: mon, + otlpExport: otlpExport, lifecycleCtx: ctx, lifecycleCancel: cancel, }, nil @@ -367,6 +380,9 @@ func (s *ApiService) Shutdown(ctx context.Context) error { s.monitorMu.Lock() s.lifecycleCancel() s.cdpMonitor.Stop() + if s.otlpExport != nil { + _ = s.otlpExport.Stop(ctx) + } s.telemetrySession.Stop() s.monitorMu.Unlock() return s.recordManager.StopAll(ctx) diff --git a/server/cmd/api/api/api_test.go b/server/cmd/api/api/api_test.go index 4f2c2165..42c00717 100644 --- a/server/cmd/api/api/api_test.go +++ b/server/cmd/api/api/api_test.go @@ -321,7 +321,7 @@ func newTelemetrySession(t *testing.T) (*telemetry.TelemetrySession, *events.Eve func newSvc(t *testing.T, mgr recorder.RecordManager) (*ApiService, error) { t.Helper() ts, es := newTelemetrySession(t) - return New(mgr, newMockFactory(), newTestUpstreamManager(), scaletozero.NewNoopController(), newMockNekoClient(t), ts, es, 0) + return New(mgr, newMockFactory(), newTestUpstreamManager(), scaletozero.NewNoopController(), newMockNekoClient(t), ts, es, 0, nil) } func TestApiService_PatchChromiumFlags(t *testing.T) { diff --git a/server/cmd/api/api/display_test.go b/server/cmd/api/api/display_test.go index 154b6359..c37700c3 100644 --- a/server/cmd/api/api/display_test.go +++ b/server/cmd/api/api/display_test.go @@ -36,7 +36,7 @@ func testFFmpegFactory(t *testing.T, tempDir string) recorder.FFmpegRecorderFact func newTestServiceWithFactory(t *testing.T, mgr recorder.RecordManager, factory recorder.FFmpegRecorderFactory) *ApiService { t.Helper() ts, es := newTelemetrySession(t) - svc, err := New(mgr, factory, newTestUpstreamManager(), scaletozero.NewNoopController(), newMockNekoClient(t), ts, es, 0) + svc, err := New(mgr, factory, newTestUpstreamManager(), scaletozero.NewNoopController(), newMockNekoClient(t), ts, es, 0, nil) require.NoError(t, err) return svc } diff --git a/server/cmd/api/api/telemetry.go b/server/cmd/api/api/telemetry.go index 4ea50992..562777cf 100644 --- a/server/cmd/api/api/telemetry.go +++ b/server/cmd/api/api/telemetry.go @@ -2,6 +2,8 @@ package api import ( "context" + "log/slog" + "time" oapi "github.com/kernel/kernel-images/server/lib/oapi" "github.com/nrednav/cuid2" @@ -12,6 +14,9 @@ import ( "github.com/kernel/kernel-images/server/lib/telemetry" ) +// otlpStopTimeout bounds how long a runtime export toggle-off waits to drain. +const otlpStopTimeout = 5 * time.Second + // GetTelemetry handles GET /telemetry. // Returns the current telemetry configuration. Returns 404 if telemetry is not configured. func (s *ApiService) GetTelemetry(_ context.Context, _ oapi.GetTelemetryRequestObject) (oapi.GetTelemetryResponseObject, error) { @@ -62,6 +67,7 @@ func (s *ApiService) PutTelemetry(ctx context.Context, req oapi.PutTelemetryRequ logger.FromContext(ctx).Error("failed to apply telemetry state", "err", err) return oapi.PutTelemetry500JSONResponse{InternalErrorJSONResponse: oapi.InternalErrorJSONResponse{Message: "failed to start telemetry"}}, nil } + s.reconcileExport(cfg.ExportOTLP) if wasActive { return oapi.PutTelemetry200JSONResponse(s.buildTelemetryResponse()), nil @@ -80,12 +86,12 @@ func (s *ApiService) PatchTelemetry(ctx context.Context, req oapi.PatchTelemetry return oapi.PatchTelemetry404JSONResponse{NotFoundErrorJSONResponse: oapi.NotFoundErrorJSONResponse{Message: "telemetry is not configured"}}, nil } - if req.Body == nil || req.Body.Browser == nil { + if req.Body == nil { return oapi.PatchTelemetry200JSONResponse(s.buildTelemetryResponse()), nil } prev := s.telemetrySession.Config() - cfg, allDisabled := mergeTelemetryConfig(prev, req.Body.Browser) + cfg, allDisabled := mergeTelemetryConfig(prev, req.Body) if allDisabled { s.telemetrySession.Stop() s.stopTelemetryState() @@ -100,6 +106,7 @@ func (s *ApiService) PatchTelemetry(ctx context.Context, req oapi.PatchTelemetry logger.FromContext(ctx).Error("failed to apply telemetry state", "err", err) return oapi.PatchTelemetry500JSONResponse{InternalErrorJSONResponse: oapi.InternalErrorJSONResponse{Message: "failed to apply telemetry"}}, nil } + s.reconcileExport(cfg.ExportOTLP) return oapi.PatchTelemetry200JSONResponse(s.buildTelemetryResponse()), nil } @@ -137,14 +144,39 @@ func (s *ApiService) rollbackTelemetry(wasActive bool, prev telemetry.TelemetryC } s.telemetrySession.UpdateConfig(prev) _ = s.reconcileTelemetryState(prev.Categories) + s.reconcileExport(prev.ExportOTLP) +} + +// reconcileExport starts or stops the OTLP export sink to match the desired +// state. Export is best-effort: a failed start is logged, never surfaced as an +// error, so it cannot fail a telemetry apply. No-op when no export endpoint is +// provisioned on the VM. +func (s *ApiService) reconcileExport(enabled bool) { + if s.otlpExport == nil { + if enabled { + slog.Default().Warn("otlp export enabled but no endpoint provisioned; export inactive") + } + return + } + switch { + case enabled && !s.otlpExport.Running(): + if err := s.otlpExport.Start(s.lifecycleCtx); err != nil { + slog.Default().Error("otlp export failed to start", "err", err) + } + case !enabled && s.otlpExport.Running(): + ctx, cancel := context.WithTimeout(context.Background(), otlpStopTimeout) + defer cancel() + _ = s.otlpExport.Stop(ctx) + } } -// stopTelemetryState tears down the collector and middleware after a session is -// cleared. +// stopTelemetryState tears down the collector, export sink, and middleware +// after a session is cleared. func (s *ApiService) stopTelemetryState() { if s.cdpMonitor.IsRunning() { s.cdpMonitor.Stop() } + s.reconcileExport(false) DisableTelemetryMiddleware() } @@ -203,11 +235,12 @@ func containsCategory(cats []oapi.TelemetryEventCategory, target oapi.TelemetryE // the categories explicitly enabled there are captured (anything omitted is off). Returns the // config, whether the result is empty (stop signal), and any error. func telemetryConfigFromOAPI(cfg *oapi.BrowserTelemetryConfig) (telemetry.TelemetryConfig, bool, error) { + exportOTLP := exportOTLPFromOAPI(cfg) if cfg == nil || cfg.Browser == nil { // No per-category settings: resolve to the explicit default set so the // effective categories are known before the collector is reconciled. cats := append([]oapi.TelemetryEventCategory(nil), events.DefaultCategories...) - return telemetry.TelemetryConfig{Categories: cats}, false, nil + return telemetry.TelemetryConfig{Categories: cats, ExportOTLP: exportOTLP}, false, nil } cats := make([]oapi.TelemetryEventCategory, 0, len(events.UserCategories)) @@ -219,13 +252,22 @@ func telemetryConfigFromOAPI(cfg *oapi.BrowserTelemetryConfig) (telemetry.Teleme if len(cats) == 0 { return telemetry.TelemetryConfig{}, true, nil } - return telemetry.TelemetryConfig{Categories: cats}, false, nil + return telemetry.TelemetryConfig{Categories: cats, ExportOTLP: exportOTLP}, false, nil +} + +// exportOTLPFromOAPI reads the OTLP export toggle from a config, defaulting to +// false (off) when the export block is omitted. +func exportOTLPFromOAPI(cfg *oapi.BrowserTelemetryConfig) bool { + if cfg != nil && cfg.Export != nil && cfg.Export.Otlp != nil && cfg.Export.Otlp.Enabled != nil { + return *cfg.Export.Otlp.Enabled + } + return false } // mergeTelemetryConfig applies patch overrides onto current, returning the merged config and // whether every configurable category ended up disabled (stop signal). Only categories with an // explicit Enabled field in patch are changed; omitted categories keep their current state. -func mergeTelemetryConfig(current telemetry.TelemetryConfig, patch *oapi.BrowserTelemetryCategoriesConfig) (telemetry.TelemetryConfig, bool) { +func mergeTelemetryConfig(current telemetry.TelemetryConfig, patch *oapi.BrowserTelemetryConfig) (telemetry.TelemetryConfig, bool) { userCat := categorySetOf(events.UserCategories) active := make(map[oapi.TelemetryEventCategory]struct{}, len(current.Categories)) for _, c := range current.Categories { @@ -234,17 +276,25 @@ func mergeTelemetryConfig(current telemetry.TelemetryConfig, patch *oapi.Browser } } - for _, f := range categoryFields(patch) { - if f.config == nil || f.config.Enabled == nil { - continue // not mentioned in patch — keep current state - } - if *f.config.Enabled { - active[f.category] = struct{}{} - } else { - delete(active, f.category) + if patch.Browser != nil { + for _, f := range categoryFields(patch.Browser) { + if f.config == nil || f.config.Enabled == nil { + continue // not mentioned in patch — keep current state + } + if *f.config.Enabled { + active[f.category] = struct{}{} + } else { + delete(active, f.category) + } } } + // Export follows the same patch semantics: an omitted toggle is unchanged. + exportOTLP := current.ExportOTLP + if patch.Export != nil && patch.Export.Otlp != nil && patch.Export.Otlp.Enabled != nil { + exportOTLP = *patch.Export.Otlp.Enabled + } + if len(active) == 0 { return telemetry.TelemetryConfig{}, true } @@ -252,7 +302,7 @@ func mergeTelemetryConfig(current telemetry.TelemetryConfig, patch *oapi.Browser for c := range active { cats = append(cats, c) } - return telemetry.TelemetryConfig{Categories: cats}, false + return telemetry.TelemetryConfig{Categories: cats, ExportOTLP: exportOTLP}, false } // disabledConfig returns a BrowserTelemetryConfig with every configurable category explicitly disabled. @@ -272,6 +322,14 @@ func disabledConfig() oapi.BrowserTelemetryConfig { Screenshot: off(), Captcha: off(), }, + Export: exportConfigToOAPI(false), + } +} + +// exportConfigToOAPI renders the OTLP export toggle for API responses. +func exportConfigToOAPI(enabled bool) *oapi.BrowserTelemetryExportConfig { + return &oapi.BrowserTelemetryExportConfig{ + Otlp: &oapi.BrowserTelemetryOTLPExportConfig{Enabled: lo.ToPtr(enabled)}, } } @@ -295,5 +353,6 @@ func telemetryConfigToOAPI(cfg telemetry.TelemetryConfig) oapi.BrowserTelemetryC Screenshot: enabled(events.Screenshot), Captcha: enabled(events.Captcha), }, + Export: exportConfigToOAPI(cfg.ExportOTLP), } } diff --git a/server/cmd/api/api/telemetry_test.go b/server/cmd/api/api/telemetry_test.go index 258b6987..29258bf5 100644 --- a/server/cmd/api/api/telemetry_test.go +++ b/server/cmd/api/api/telemetry_test.go @@ -358,7 +358,7 @@ func (m *mockRecordManager) StopAll(_ context.Context) error func newTestService(t *testing.T, mgr recorder.RecordManager) *ApiService { t.Helper() ts, es := newTelemetrySession(t) - svc, err := New(mgr, newMockFactory(), newTestUpstreamManager(), scaletozero.NewNoopController(), newMockNekoClient(t), ts, es, 0) + svc, err := New(mgr, newMockFactory(), newTestUpstreamManager(), scaletozero.NewNoopController(), newMockNekoClient(t), ts, es, 0, nil) require.NoError(t, err) svc.cdpMonitor = &stubCdpMonitor{} return svc @@ -427,3 +427,90 @@ func TestTelemetryCollectorFailureLeavesConfigUnchanged(t *testing.T) { assert.ElementsMatch(t, before, svc.telemetrySession.Config().Categories, "failed PATCH must not change the persisted config") }) } + +// stubOTLPExporter records start/stop calls for export-toggle tests. +type stubOTLPExporter struct { + running bool + starts int + stops int + startErr error +} + +func (s *stubOTLPExporter) Start(context.Context) error { + if s.startErr != nil { + return s.startErr + } + s.starts++ + s.running = true + return nil +} + +func (s *stubOTLPExporter) Stop(context.Context) error { + s.stops++ + s.running = false + return nil +} + +func (s *stubOTLPExporter) Running() bool { return s.running } + +func TestTelemetryExportToggle(t *testing.T) { + ctx := context.Background() + tr, fa := true, false + exportOn := func() *oapi.BrowserTelemetryConfig { + return &oapi.BrowserTelemetryConfig{ + Browser: &oapi.BrowserTelemetryCategoriesConfig{Console: &oapi.BrowserTelemetryCategoryConfig{Enabled: &tr}}, + Export: &oapi.BrowserTelemetryExportConfig{Otlp: &oapi.BrowserTelemetryOTLPExportConfig{Enabled: &tr}}, + } + } + + t.Run("PUT enables export, PATCH disables it", func(t *testing.T) { + svc := newTestService(t, newMockRecordManager()) + exp := &stubOTLPExporter{} + svc.otlpExport = exp + + resp, err := svc.PutTelemetry(ctx, oapi.PutTelemetryRequestObject{Body: exportOn()}) + require.NoError(t, err) + r := resp.(oapi.PutTelemetry201JSONResponse) + assert.True(t, exp.Running(), "export should be running after enable") + assert.True(t, *r.Config.Export.Otlp.Enabled, "response should report export enabled") + + presp, err := svc.PatchTelemetry(ctx, oapi.PatchTelemetryRequestObject{ + Body: &oapi.BrowserTelemetryConfig{Export: &oapi.BrowserTelemetryExportConfig{Otlp: &oapi.BrowserTelemetryOTLPExportConfig{Enabled: &fa}}}, + }) + require.NoError(t, err) + p := presp.(oapi.PatchTelemetry200JSONResponse) + assert.False(t, exp.Running(), "export should stop after disable") + assert.False(t, *p.Config.Export.Otlp.Enabled) + }) + + t.Run("export defaults off when unspecified", func(t *testing.T) { + svc := newTestService(t, newMockRecordManager()) + exp := &stubOTLPExporter{} + svc.otlpExport = exp + + _, err := svc.PutTelemetry(ctx, oapi.PutTelemetryRequestObject{}) + require.NoError(t, err) + assert.False(t, exp.Running(), "export must stay off without an explicit toggle") + assert.Equal(t, 0, exp.starts) + }) + + t.Run("enabling export with no endpoint provisioned is a no-op", func(t *testing.T) { + svc := newTestService(t, newMockRecordManager()) // otlpExport left nil + _, err := svc.PutTelemetry(ctx, oapi.PutTelemetryRequestObject{Body: exportOn()}) + require.NoError(t, err, "a missing endpoint must not fail the telemetry apply") + }) + + t.Run("clearing the session stops export", func(t *testing.T) { + svc := newTestService(t, newMockRecordManager()) + exp := &stubOTLPExporter{} + svc.otlpExport = exp + + _, err := svc.PutTelemetry(ctx, oapi.PutTelemetryRequestObject{Body: exportOn()}) + require.NoError(t, err) + require.True(t, exp.Running()) + + _, err = svc.PutTelemetry(ctx, oapi.PutTelemetryRequestObject{Body: &oapi.BrowserTelemetryConfig{Browser: allCategoriesDisabled()}}) + require.NoError(t, err) + assert.False(t, exp.Running(), "clearing telemetry should stop export") + }) +} diff --git a/server/cmd/api/main.go b/server/cmd/api/main.go index 2b9eeaea..36e2aab3 100644 --- a/server/cmd/api/main.go +++ b/server/cmd/api/main.go @@ -134,14 +134,23 @@ func main() { } // Optional OTLP export sink. Independent of S2; both can run together. - var otlpWriter *events.OTLPStorageWriter + // Constructed when an endpoint is provisioned, but left stopped: export is + // off until turned on per-session via the telemetry API, so a VM that always + // has the relay injected does not export (and get dropped) by default. + var otlpExporter api.OTLPExporter if config.OTLPEndpoint != "" { headers := map[string]string{} if config.InstanceJWT != "" { headers["Authorization"] = "Bearer " + config.InstanceJWT } - slogger.Info("OTLP export enabled", "endpoint", config.OTLPEndpoint, "path", config.OTLPPath) - otlpWriter = events.NewOTLPStorageWriter(eventStream, events.OTLPConfig{ + slogger.Info("OTLP export available", "endpoint", config.OTLPEndpoint, "path", config.OTLPPath) + // The OTel log SDK reports batch-queue drops through its global logger at + // logr V(1), which slog renders just below Info, so a default Info handler + // would swallow it. Wire it to a handler that admits that level so records + // dropped under sustained backpressure are observable, not silently lost. + otelDiag := slog.NewTextHandler(os.Stdout, &slog.HandlerOptions{Level: slog.LevelInfo - 1}) + otel.SetLogger(logr.FromSlogHandler(otelDiag)) + otlpExporter = events.NewOTLPExportController(eventStream, events.OTLPConfig{ Endpoint: config.OTLPEndpoint, URLPath: config.OTLPPath, Insecure: config.OTLPInsecure, @@ -153,18 +162,6 @@ func main() { ExportInterval: config.OTLPExportInterval, ExportTimeout: config.OTLPExportTimeout, }, slogger) - if err := otlpWriter.Start(ctx); err != nil { - // Best-effort sink: a failed exporter must not take down the browser. - slogger.Error("OTLP export disabled: storage writer failed to start", "err", err) - otlpWriter = nil - } else { - // Export is running, so route the OTel log SDK's global logger (which - // reports batch-queue drops at logr V(1), just below slog Info) to a - // handler that admits that level, making drops observable. Only touched - // on success, so a failed start leaves the process-wide logger alone. - otelDiag := slog.NewTextHandler(os.Stdout, &slog.HandlerOptions{Level: slog.LevelInfo - 1}) - otel.SetLogger(logr.FromSlogHandler(otelDiag)) - } } apiService, err := api.New( @@ -176,6 +173,7 @@ func main() { telemetrySession, eventStream, config.DisplayNum, + otlpExporter, ) if err != nil { slogger.Error("failed to create api service", "err", err) @@ -387,13 +385,6 @@ func main() { } } - if otlpWriter != nil { - stopCtx, stopCancel := context.WithTimeout(context.Background(), 10*time.Second) - defer stopCancel() - if err := otlpWriter.Stop(stopCtx); err != nil { - slogger.Error("otlp storage writer stop failed", "err", err) - } - } } func mustFFmpeg() { diff --git a/server/lib/events/otlpstorage.go b/server/lib/events/otlpstorage.go index 3108c4e5..39e2dce2 100644 --- a/server/lib/events/otlpstorage.go +++ b/server/lib/events/otlpstorage.go @@ -278,3 +278,60 @@ func (w *OTLPStorageWriter) Stop(ctx context.Context) error { } return w.storage.Close(ctx) } + +// OTLPExportController starts and stops OTLP export on demand so it can be +// toggled at runtime via the telemetry API. The underlying writer is one-shot, +// so each enable builds a fresh one. Safe for concurrent use. +type OTLPExportController struct { + es *EventStream + cfg OTLPConfig + log *slog.Logger + + mu sync.Mutex + writer *OTLPStorageWriter + cancel context.CancelFunc +} + +func NewOTLPExportController(es *EventStream, cfg OTLPConfig, log *slog.Logger) *OTLPExportController { + return &OTLPExportController{es: es, cfg: cfg, log: log} +} + +// Start begins export, or is a no-op if already running. parent governs the +// read loop; the controller derives a cancelable child so Stop can halt the +// loop even when parent is still live (a runtime toggle-off). +func (c *OTLPExportController) Start(parent context.Context) error { + c.mu.Lock() + defer c.mu.Unlock() + if c.writer != nil { + return nil + } + runCtx, cancel := context.WithCancel(parent) + w := NewOTLPStorageWriter(c.es, c.cfg, c.log) + if err := w.Start(runCtx); err != nil { + cancel() + return err + } + c.writer, c.cancel = w, cancel + return nil +} + +// Stop drains and shuts down a running exporter, or is a no-op if stopped. ctx +// bounds shutdown time. +func (c *OTLPExportController) Stop(ctx context.Context) error { + c.mu.Lock() + defer c.mu.Unlock() + if c.writer == nil { + return nil + } + c.cancel() + err := c.writer.Stop(ctx) + c.writer, c.cancel = nil, nil + return err +} + +// Running reports whether export is currently active. +func (c *OTLPExportController) Running() bool { + c.mu.Lock() + defer c.mu.Unlock() + return c.writer != nil +} diff --git a/server/lib/oapi/oapi.go b/server/lib/oapi/oapi.go index a65298b0..20daaaeb 100644 --- a/server/lib/oapi/oapi.go +++ b/server/lib/oapi/oapi.go @@ -3034,6 +3034,21 @@ type BrowserTelemetryCategoryConfig struct { type BrowserTelemetryConfig struct { // Browser Per-category telemetry capture settings for browser events. Browser *BrowserTelemetryCategoriesConfig `json:"browser,omitempty"` + + // Export Forwarding of captured telemetry to an external destination. Independent of what is captured: export is off unless explicitly enabled here, even when a destination endpoint is provisioned on the VM. In PATCH requests an omitted field leaves the current setting unchanged. + Export *BrowserTelemetryExportConfig `json:"export,omitempty"` +} + +// BrowserTelemetryExportConfig Forwarding of captured telemetry to an external destination. Independent of what is captured: export is off unless explicitly enabled here, even when a destination endpoint is provisioned on the VM. In PATCH requests an omitted field leaves the current setting unchanged. +type BrowserTelemetryExportConfig struct { + // Otlp OTLP/HTTP export settings. + Otlp *BrowserTelemetryOTLPExportConfig `json:"otlp,omitempty"` +} + +// BrowserTelemetryOTLPExportConfig OTLP/HTTP export settings. +type BrowserTelemetryOTLPExportConfig struct { + // Enabled Whether captured telemetry is forwarded to the configured OTLP endpoint. Off by default. Has no effect (export stays inactive) when no endpoint is provisioned on the VM. + Enabled *bool `json:"enabled,omitempty"` } // ChromiumConfigureError Failure from batched chromium configure — includes which phase failed. @@ -18844,367 +18859,371 @@ func (sh *strictHandler) StreamTelemetryEvents(w http.ResponseWriter, r *http.Re // Base64 encoded, gzipped, json marshaled Swagger object var swaggerSpec = []string{ - "H4sIAAAAAAAC/+y9iXIjOXYo+isIPke0ZJOUqpexpyocL9RS1bTctehJqm57Rv1IKPOQxCgTyAGQlNgd", - "5bgfcb/wfskLnAPkQiK5aKnFryIcnmoxsZ4VZ/2jl6i8UBKkNb3nf/Q0mEJJA/gfP/L0HP5RgrEvtVba", - "/SlR0oK07p+8KDKRcCuUPPi7UdL9zSQzyLn71z9pmPSe9/6vg3r+A/rVHNBsHz586PdSMIkWhZuk99wt", - "yPyKvQ/93rGSk0wkH2v1sJxb+lRa0JJnH2npsBy7AD0HzfyH/d5bZV+pUqYfaR9vlWW4Xs/95j8nVLDJ", - "7FjlRWlBHyXu8wAot5M0Fe5PPDvTqgBthUOgCc8MLK9wxK7dVExNWOKnYxznM8wqBneQlBaYcZNLK3iW", - "LYa9fq9ozPtHzw9w/2zP/k6noCFlmTDWLbE685C9xH8IJZmxqjBMSWZnwCZCG8vA3YxbUFjIzaZ7bF+I", - "g1cu5CmNfNbv2UUBvec9rjVf4IVq+EcpNKS953+rzvBb9Z26/jsQ9v2o1a0BfVSIY55lL+ce4Es3KdlP", - "l5dnLOFZxmZcphmk7HqBh7kBLSEbiJxPwQx4IZhBxFq9yoRbmCq9cP8GWeZuaw7HtMoaWzNWCzl1W0u5", - "3Yheke2fuGEOpVSpE9hyAhx5QSM+9HtWl9JtN129i0tdAhMTPLvbIZsIyFJ2yw2rRrG0BIcIRvwOLBO5", - "sMZdhz/htVIZcIShjSAWboVZkYOxPC+YkOy9FHcsF4lWBhIlU5xtonTObe95T0j7p+/r6YW0MAUkafpL", - "fdu8ECMHw8h1L6GMNWHCfg236k63RKQTD8AdaPYM9ACxrOCLTPGUTZRm47DvMQM3r1nFrbTUyJ1GeeRG", - "f+VZNkgyldyw8J2jWAdBQmbtLjkXWSYa9+tPKMv8mm7TrUeLiAhevCtAHp2dsuqr0zQskjs2BCnTyvGb", - "PRhOh2xcaJWAMY5FjPtsbPkNXCQaQJqZsuP9xg5qitDEB6Pru5vzvzOROoY2EaDZRKu8g07D17lI0wxu", - "uYboosZyW0ZuFTlCEOKMvmKJSpuzVLi4hF6Ngyzda7VevwXTNRjn0O3C8uRmdYvHJ2fsvJSOlob4yaXm", - "CTANhQbjrkhO8W7+g8/5BY4jFmfct4xb/NGNRgYvCfuG7JWjeMNKA8ytIHnuJkqUdD+jENDczkAzO+OS", - "GclvYJRwgywBcQHnPZ5plQM7gfmlUplhZ1pZlaiM3QoNjKh7eCUjbDTLXmmewxZCCU8zwY/7zGGfzpWx", - "JIBaomdpCZWVuXxLmL+yyF9Bq8E1N5Ay+pARjbBbYWeCRFwmZBQP+r1JKVEcveU5rM7dgET40N0v9JnS", - "DPLCLhhhJjIGLpVc5Ko01ccmisJuN1ucxn0WOQt9HT8N/XaaxnGP/rtBjtHdlTpbHf7+/LU7sjt7YCN+", - "tonIYoS6RGGta27sk5ZrXUm/De8YqbXViyWmvcoJidmzjF9DhoDC7SNRWaRA4oHcLGTCEl4aiPO7guug", - "gGbZu0nv+d+2EuY1R/jw24qAwSlbm0FMwq3gX81w5TIbJLeWERU2mfELlc3hHEyZ2S51iiX0KTPuW8at", - "dajNNHCUE5w5QhXuClVpE5XDlsoUzfpQZarjHF/1qk69yl/8CME50nhnT6hjrQPQ7upWwL6WxhU7Ubf2", - "Fb4O97LECT2yz0GmSrMJz0W2GDp5l5YJaMOku/HMwbTQai5S0ANTQCImImGWmxvkgoYJaRWzM2GYAfuc", - "gXvIFloYYHOuBZfWOE6pIRBXorKMFwbCQBCazUEbJ1Ouy+QGLNubf8sO2Py7/T7jMmVcLhzXnzKpLEvU", - "HGUp8Sp3uSfKCaI31h+oz4qMC8neHZ/vM2GcWqG0w1Ju2Fg5BWBM8jugySwQqMODcGfzb9v/+Z1DilJL", - "Y0XmMGMKYN3bt9/DKePEvav2i1ohMR9jubaOqGI8Z0UHxkfryGl5qwshPjZAh9+iRugevhMuslJX6u/L", - "8/N356Pjo7PL45+ORu/fXrx7/cvRj69fjveH7OjaKWdukCkTpyTvpJdeLp+Djf004+d0Zs00uCtGVlsa", - "fp2B+wFf6kM29juNfS39ofYMABvXl+F2PXasRZW2HpeKFDGJxjdVCidQQH9j2C0Xll2X6RTskI35NZep", - "kpCOn/tPWMJlApl7b3sxWvApMMnnYoockd/yhdPgB7hmG9/8sR1PoyO5a6RN9vq9arEoSjm6i74zPJS5", - "MWLq7qSh3LB3Bf9HCX2nGU9KkvymLBxVMMdjzUDDBDTIBOIgvYVrIyyMZspExOZPipTa6hZuZ6DB3yeR", - "vJMWeBHp2vkLbmeRFxS3s+3nZ/9PCbrSRuEuyco0uuyKLtHglfd47aTFsZISEtttq4E7b+JLMuEIiUgu", - "KY1VOWh2cfJzn51lfHGrxXRm++ysLAqwAHrfPWLc3JAyYpn4wPkVri8U8stCq7sFmbGEYb+82drI4yZ1", - "+4uh2leFYlWhSIuRv7Wn1CPS4kSYZFd0SqsxkNb2hQ2Iws64oFcVfi3yHFLBLWQLVmhIIHVUNG6cexys", - "pcY9gYzVwPNHQbddNOGVC/qqBK/F2Ro1Pira3lPzrXe7pPy2TvL4RscaQbeyO+ZgDJ/CKFFljELp2e7m", - "diToP3baaMYXTkFAyRtZFwTaqFKh6W9xA4cGbmKP/F9ni+U5QToByMbEJkZJpoxTovAr4hxCCisQh+mP", - "yjjtrCyIukfJjMspKj9oGxNlzjSgfgop6ThgUHt3ujpKaeQyVmlgqbqVzKjmaokqs9S9BzyM+ZQLacio", - "J+GWhXWbW0CVbvy8+o2lwmmSOtwrK8q8ICWQzqqkhTs7qtQ0f+BgW/W/IwXXqtyeXRTCKXgL7yxhZlZa", - "d4T9tgbXvMpev7d8U80/4Z7QlrO0o82U2MTjZXSrMGAdQSppVAbo6us0eVzTt+5G3MdekVaaObZWTme2", - "aYWFuwQKQioyub7Mha3Fza1yQsgKmVhEeuIZhsRLKiaoZFrioGbGCzDDyg7s1z86Oz3mBAz/l6F/r/As", - "M/sOtdzr1LAM5pD1mbvTPuN6auipiKaiERqQ6rmrbV/OtMPHveps1S/NqWnOTEjoe0tq3x9lVOosso43", - "PLs3hffIuqeL19RoJOMaGMcHVNx4HJWX7vwPFpbLWPBVVnbLSrorT7RPKCqjMNnVnoojj4mv9D70l70F", - "jigiFJ9lFa1zPS1zNzNLFOiEXhd0VjNkZ+SMYUpmC/fmkh6VPbV3EW7Lf7H6fl2yWBN9RYxTLQ9Gy+Lf", - "eP/V/AjRC6l7640vcYW4nEU2E/cihFt0g9icZ+6FzbNbvjDsigwyV70H3WLUX7K6l9cN98inu6iaQXY4", - "TVacJczO0JWn4ba9x0fYWMscFRj11nb2yk3R7yFtrZo8ypzLgQaeIqcnCeVFEel0y2L1FpWeVJgi4wsm", - "7JC9UtWvJOL29knI9RvBKIFCmwTKPYnSFBFR1vdKGEzEHQor2p9XIPoMzQ5XvfdhJLKh5+xaqfyq50R/", - "47c9IZ1gzIWBfXa5KMB/fMeEF3iVj++qR5JtA890F7rKGn9bYY6v1XRrpSVTU9JIaq0hU9N+db9CTlT9", - "X7dcyz4Dmwz3h59AEoeDfZXDG+VwpqZPL4Vb8Pi8ZPBOonSNqOpUst0cfVZwY/Dxp1U5nbFSTkRm0cmC", - "7JYiIobesD5Gn4oqvTGypTL5Jzlz7zng6QvGs4yhf4QtS0zjVGXgmjkZNWQXQKYqU0BSuaYnZZYxhxNR", - "xvJEvP0VMt5l8KxCZ7NJmQDS34LltbBoZUf+I8/hwtMVia6O9wssMVdSWPeCk05UZJm71UGQnt5iwk6D", - "c4CEleV6CrZPESn0vvGeDHzqFSqZOeq+nQkfI0M7UUlSavfejjxocKqoo8JBGX9thkM1fDC0mbj+o3gK", - "unPWVCUEK/quMX+fOYUCXVfAk1njdNF1JJ+PDPxjdZU3SiqrpLcRCJm4Rzg6JuvrorjVJKhkffrM7QvS", - "agNWFQNEj+bI6CVswT29+aXzXoJ5phl+5imM1mlYi6L3QV9F5w+46SdqLLFnLCpH3tBVn9OEg3Jm+fX+", - "uhWDXNiCsi9xhNNQ1sbuaMhgziV5VmfCECq/IMeS+2CC0T0VTBwt4G9EOv3KglR9C/ZW6ZuGMXI9U2gA", - "q3mx7SPXKLhGfDVVgR2NrFrNQXKHpDlYjtqBh9zCYTMRureHaAbeyFNR/qrWBHFNLcQSNJzPyDkwfMp7", - "nLtk0xivt8m9KhMVXnUccW6ETLtUlXCgIZqSgzkzFurnxVjlRPHMdcjGFK454oUYP2c/43+wo7PTYC/c", - "c3xGz4Es1vTHwRQkaFS3ws7ZGO4sSIcI4+dMyL+T08bvp/ptyMaZSng28kGp4+fMLIyFnPk/MF1K6SDG", - "MyWnRqTQ2m7bZpkWvX6v3r/7KSzUc7y1sVBU0w2o0o1sESVlEz4EaUbI4LgV0cGBp5MDEhWnJy14B1pY", - "oi0E/hqK+cna4idwssF0H8LqcoVgMKZ2RiNZzgsH3VuuUwwqGQiPKW73jrWp0laxMyRk2C88K53Ko1H5", - "CTZm0vLYdWlZzhfsGhiXC/YfF+/eoorU0npWDoMJI5RCcJyJ5GbjY6nEF5P7NGgSvLCl0/LmgtdIiNyu", - "jq3c/DoS9UYe+kKKnunrO6nzndS4+hFC9glfS92weeQ3k4EMEqsiMcHHFxcs/MoKbmfBxo5nd/w1Q0Wr", - "Q6WYxoLl37xmlk9bAb1LszmAlUUBGmPFiVH9+P7y8t3bPjvqs5PTXzp0mKgy/4swAr0Djuv5VK6OhfvM", - "anTIR6e/i80NtxjVczdIlNKpkNy2T+XO4m6xEHeQmbglb7Fm4sX9J17Cw7ueW6lfQ5sgtPaZ1EDBn2Gx", - "keHdwOJacZ1+CewunOcrs9uK2d3A4uOwuhZcHpnRuUOsXODPsCBnQq19/uzxmO6WGNBLt8U++5EnN6bg", - "iXu1x7nQPbhp4Hton59h9EVSGrLDU8rSAjGm0GBMB3fantvi5Ou57enbs/eXfXb58j8vj85fdvPcZXUQ", - "HsBgLhKtsuwCrM0g3chqDH7NDH3uGU54N/GJrT8plBGN1FOMGBBy2v+82dPqbXxlVFsxKoL6yCPGx+FZ", - "HcB6ZO7l2NMoooTQ6uxuUGG6T9ijiPbaD+i+moJxSL+NWoLrLTrXWzz2et4ecw/+SWttUkdV7PJeYYS8", - "Wb1CZCFu8nCCwGq2OYmK3VtrqcWjLLWc60YYUoHOH9pvaPWG17Lm12IOTg3dEGXNMjEHNhdwW4ebLYVO", - "u3f8pMwC7/7GsF/h+vzyuLLhvIUbtT9kP/nvlMwWL9DXGRj6RGmcJQNjGGXufuwQ2Nh1fGXJnSzZYcXI", - "YcVHCN/uBM3ukbDBct8Kg105S3ck7DrPwOuKUFb9A0N20TLeV8Gaps+MYpxZzaVB8gr27+tMFCzhEokE", - "QwG9EbWKLceA8XG9pfFOxvItLnxz0Pwqd4gHzW/LIurg+RhUrhcrx/0ULOJrqPzuXOKjBMyvA9Cj84rP", - "KHD+vlzpha/YEaLmNVW5oBSVLq64o0duy3SvN+RlP2lwjw6ec+lzcBp3ZFXw9DiqyJSxQ3aJuqLVi8A2", - "vUMg1aooIGWltCILzv1RxY/d61JrMQczZJcauEUPgpCDQqupe56HEksYsWyB7Xl+PRJphpEfUxhlfKFK", - "G94o+4wbVkoNmUARQCvbGcjtGJjf40O5V9cNf2VfnewrYEdTpj0h+1oLoU38q41HXdks5/j3KlqhPhg6", - "1RIkolGVi1I5dCvvaPhl2PSDLo3afEObMy38VZxKYV9xkW1kBoG3USqMe1pcg8/CycTvtN+PTWlLm/9K", - "ZxvpzAFsNMEre3oyi4FnNyIzFopulMzBzhRms1d46OOZLBRkCqajepssxdsMDdij0qoja3ky28Imi5vY", - "fNrzIOC2IqeobG3RloYBYDySMLPKIgt3M14aS/ETWf3IIRsSVt8wQ/ZWsUmpqW7UspC+FVnmBXCVVOtp", - "+1OQcOzWvtLxRjquAP/RiLkTUE8iNluI7UtODOu/jjwdOAFKdOAwPBAAuwUNDD00ZVGFt/gSFpMyyxYo", - "ZpUORdvaBNmUvJEVH1H4nsODVfGlU0VYBl/WQV4SIwiWwbSs7mHKC4z3If3+uK2GY1kaAxbNKUvhhsGi", - "YjVPbtxsXlVhEw1mFowUwrBCCWk/KZ/5ymN25jEflb08hLUEWt3WKID1GJee/8zyG0Aqa6R7V/6FNilt", - "c78rvCG2yc33Uxf07DQUFqCFSkXCTPVtsHYEn+/cB8VsR4H1PI9EhEuH+EqDG2lwLQgemQRj0NmNAgsZ", - "iaD4kRv40/cDkIlKIWVnb/+yJYJW13a9sLBRS3drrznjW5JQp2kGGyMjgjQTaYjcXoqL4OyHw8PcsH+U", - "AqynO7KpS8WEHEwyMZ1Z5svaYvD9lt42v/RD6W3JD/6VwlYprGlUfELa8nj3WvFUyOnap+EqAmY0Krxi", - "fQGL00mrLoi7bZ5p4OnC3Y/HPYx8cpojx2euewNLxQotlGbjcHY/xRjnaHqKhd3vs3Gps3GfjUNelPt3", - "lc40ppyrsQafRe0uYNwoGfGCjSPIiJl4BddUI58VqigzxBJMIuKWJdzAttUmHolYOkH0VT5tpB6PoU//", - "Cl0PpEeOE6KCN5tg1iTAMGI5tRHDbKaRws8N0FHtx3jo9duQqoWpqo3fvElLgn3+/OX5+ej43du3L48v", - "T9+9HZ2/fPX+4uXJ7nXfHbuI1H1HD1Z4IiotpkJytEAtsZFO55VbtcEl4gv7kw7P/aeXiwIa5gBcYSXt", - "t5nJ4jN+f5bqVlI4qmFCYi1FduLTLPvsFdhk1mf/+dN5n1GFoD67sIsMzAzc2/Y0x3oDbyAVvM9eKTfm", - "Eu7spXvZ9lmDuvt1jbo+e8OlmOAOzzRMaI13dgaa2GSu9BaFtlul7BtY0a8Rcm28kb/C0P1mWykTwIfl", - "KzqS5Z6e/TZ3/ZXxbmS8HmhPz3FX4PLIvDZkQG8sw1KlSqOe0K7/5m8jyntmjey5XfbdzLxbLf7uryVk", - "2A3dSn5Pjmw72dxp+GaINXiETLEZEmawovpTmvaZ7s3zjOduBdfG8aFCg5PWxJCwwEH0uoQZaaBKfuso", - "B62BXlQYv19TZtS/iIUZ4iRDfpuONiDeqcMNC5Wb3eTYyIJE3l9eXvbZ2buLy45C/8rYUWA/cZhdq3SB", - "osXNcnD2/rJ6pPXd4fici4xfZ9AhyuhocXx9R+Ixw1zra5goX8wojEIw4MFQQW9cNl6jLuGRpHaflVL8", - "o4RW94nazfNVQj9cQns07rdZWM1wVhjCdsKbuuDsIL192xwNCYh5/Ux85TbdMF1WHyL6O6B4nwEN66Pf", - "EbEyZA2Tl/DTKAONW/iqDWyhDdB9fQx1YBkyj6wPOOyMAslDooXGNTvFsmsTX9KMvTl985JK9nxUlcDv", - "rKkTbCPrvIKjguxYp83kIu/i0dWhw4TVVZHgdDdzMLN51mfLTRi/vhU/e0n0SN3TwjQd9oboXI1qF+9+", - "7rOq3eb+fQVm1akgEOJayXjGp3Ci8mNKPH+teLqFCfXk3ZvWgFBrz6GPm3CYVjPiXCgtt6ytV/Dpgwvr", - "dR7qq7TrlHYY+ZuqfORrEKD18Umtjuuh9NhWx7QYVfcWYXwU9JGHel6MfNiUeC0kC/5rbn0xpBUSmLj7", - "6GM5dyvmCOJALiH8lKI29pwqiFDDQmr7Q/beABtbQwWObtse9EjA/HKjktbJNhL7awzu3jaPmULBO/KY", - "n/lr8Xow2mIx1aD21lnQc8CKRGGmmZjgU7B+m8+FKTk2c7wWmbCLIXvJk1lrAAXH0FP42cCv6g6tPx5T", - "+er2246HtLMHnph/eGx2OLK5OGyZl544W7i1d/z6Yt+jdpXxdQYaL0AmwC5FDthz8ujs9OMKseXjfZVf", - "2+Geu7CPjHlPYr71UUyrF3mylHHVQmiQVi9WQq/2fC3yQxQzLXbMCtBYaXU/mp/VvNVRCpaLzOyekBbI", - "qXFxjFurxXVpwWygPDzSKu3NeDrSkDh1RciitOtRunVJvmBJAik5FrEaGk4SrHoYhtL3LcOcoBKePxy/", - "voijPKoLkRy25romUTq8p4TxsNrD/uruJkIQ6uuL/bjoX8FJ/6DbscBqKLaCf6/rwreuqKrnGq1XIGJ9", - "gaPAq+k9hq2bMwSXUwaWDuz3UufqbaEEJcVGcfGa66l7THs1b1Jm7IwL98x5fXz2ucoLf66vcmKDnEiK", - "pxYPTUg8sljIkuKebNjjdI3ShNEPZcO+rkmU+4i0nj7Q/+vjs7qmnZgEO2NnjedRnNm4l1fV9n1p3q0S", - "j6VKu1nmybs3zH0Q4ZqNdbq6cckUdMe2z/HHbTf+wgtsasxJVj9fY6TKvrgUuZDTwVGWqdsBecniidbi", - "d+iuQMg18I4NUYkXZv5R8rY8qOfe5GFuzohRcO4ITGk2Fymo8FNHweSnFXrNrTkeRtB7ArmHC8WUs3sL", - "vc2STvHNr/z65b5syMvC8E9hwqv2/lWcbRBnij/5Q7sFi8/cOIc6Zo3OX4pp7m2V97UdxTabDPjui8v0", - "i/zibehCvT9kx1xrAVh+v6q1PaF2dUIi17rGatWW+YrzvoNRqIzftMQt94T4uNxh6ba+8oj1PKIG1hNz", - "ihhcdst0uZ9Ur3ut4xe7Ngx5C7dsfdMQVvVSr17vG/qGFFw7tbj7PGf4weqRqCP7Nf290SnjhY//px1E", - "eoZ0tODfuSHIo7X9+LjdPGocsOrRWm9Q4FFD86qxaGtSWO9vCV1TMUCowxFXdR5ZMrCzGZ8Du1Z2RnKu", - "ctWbNu60XC5V63xhWGN68sRgJwIM0WOnMoXCacNUk7yZ1vOCcWaEnGbA3BeUl0zhB6kC6gV3jbJSbN3h", - "9Kub5lPIg4/kqrnk1+8KkGucjhJuKwXH8mv3OPT8xF2rwsGk2/hiIyH96lLRHxD3Ea9pnNmnSD0TokV5", - "q9qOMHUCl68F6rYQul8Z1SrXtylZy+tL7TSthuJUUQWin9MrYylcQ3aspClz0O4dShlqS3oato8JLUNm", - "WNXEYqkvYZ2uxtGSL3i2U7rXY2llbSh/VcrWE6Hl1yPC649KfPfQyXCXcc3pcqXVl9fIHA1jPoEnXSQG", - "JYECweViVyWj7gYUa10m4TZbVEvx6yfRPKywWcT8Q4kHmec97ptKK0WGEt9MVI0JUzVMZ91zLKPIWh1m", - "DYpcgJ6LBI41N7M1DDrnkk8hxaqnIgEGd8JiLUK4K7C6RLZwOoPTWhCrfE17im5z2MSt0oM6u6Tqps9S", - "hazRd+Rqss3/87/+N8Wf1qvguga5rgWd+7BOfAIPpmIOg7LwBWmpvVyqtuWC1E3roXwwcptfGWEnI/TI", - "NEroup6QEXbBZffaqrjXdmXVpWNURVXZyzthMWIUEda9IHmGOgJWEL9zqkCV2VrKFHSGPfeCZYpoTlfl", - "xJIZlxIyVE+QLij5hAiS2KJdUMfnTEwgWSROQ59xQ7Zu2nnw7DIhSXvZw6dHlZyzTy6g0xPcqIZCYdXE", - "CBXhzLGyrVssPWRjJNqyGLMcuDS+TzUdPBXuXkhvExjTrJ1GhNoaZzPgmZ0tqoZ3WEZpyMb+v8OEnBUa", - "5kKVJltUY1ortJnXeMrnMIpvKECiKlbFHBcKxZiq+lgIZUtVWq12sHzBZF0zrgtRqHace8LV5oUAViq5", - "alQOdtYoAGWqp1VFS3SdvX7P30Ov3/MnijK1ImqUOD2pCvnSHsMVDNnRdZ1fFbsbtxgri9WCetFrwpbh", - "LFPSDa3KW3Gqyn12etIRY+0vUPKoJ0arqeZ5u4GXP0a4T99pEit/ijJ36nxeWgva/Ys6Ig7IxTbghRhv", - "U8awuae+p4p1rAgFzTuV/yyybE15stdClneMtsTevXszuBFZhpUHUe5h1ZQKCEJWHR9/eTNkF80W+eOD", - "FOYHN7mZjsObyKEZlzU54NQVK/JreqGRQ670ogIomRNCXIy3z3u3GVqu/JxYmpnbit2ZsnAXZeK85Akl", - "8sp1fxXI3QIZL2ukVD5yKPGUAjkOlt3lsdvnkjhuH6K7xnmipLGaixgF/jpr0wIkIiVbQSDFIRtLJSGI", - "i2mmrnm2Si0v2DiHPGmIpWSqVVmELxH6iB0zYV+wcVKUBuyYHeA4pRejQmUiWZBx4e37N0cH9IdBqsUc", - "JNJuzZ6V9Fs2TGUYazDjkv0wPPT+sVSkVf8S3xpHlwl1mxorlePRno9ZJiS0BYw7LCab5ImTLbRP+kO9", - "y45usfloogFGN9eR3jMaILSy9VciJPtZ/Bh69zSDJdzm+iwFjQmZVcDK2M3+/O3Yk5qQDdB9Y9gbyAen", - "cqJYWubFkB0ZU+bgIPE9rkOFRMTvMGQnwVATkpY0JBkXOVY/T5wCErpemJxnmfdDYsw7Z5l7diHURlZZ", - "no1ursdYu91Yh6MO/HTjdFgHcrcUKn5sxnVKXdSwIqeHpmcjAQmbsOOUgI47qw5ofAG9ZrfYBrk3txZh", - "XO6XB4PiLd6nYedHbwiLHgCOp7mFTZqPF4ZB8YnPQT92KCLHKs/jszGMMSGdeknc7uX8jj37wWn52vQb", - "sqL1WUdGoTFRkJ6DwXcBM2BJ2MR35cG8Z0rcN5dKDrQxfTYRGdC/ULed5ZC7/9wfskunpfoSBcVsYURS", - "c7+meujQvMTG+B1I1NWoqhhZbm5MDE8LVisZ11h0Fk85MGAHeEq/VK7yRktVwlhDd++mJN/FkrbUQtXx", - "pdsCvTDGzHtGXuaFXaxDSm8Ac98ec3wMcMt+wPAf4dQixa5ViS4dklqI7IiswgKV1txVsXH7RArnd6c0", - "xw/VrXKt+YKUFjGdgh5tIgD/XeMpug0p+j5rMnWcbHx89v45e+s0efc/jiCej30Cb0O2ROAe9rg1gVWI", - "NlMGGM8yRQm4lU+qUfvD79sqJuRc3ZDCXOvWQ/ZuYv3zBn1o3LBxcydjtteYxhNRIzkW9D4GUSRcslRM", - "JqCbrTJxUELb9D+7O52LxIp8yN5sQ/+te+sq2di8O+J3FYvYViVDhNpNGzuqnIIeIhTvtomqUAqs6Gbb", - "w/0hfHMTJayVAdsz3bYUXeVKWzTQIyB6iG6GZcN0vc6W3sxqJwO2e7J5UyxhdpVQ3nIX9XvXPLlxiqxM", - "R/4v4SF8q/QNaPeHGdeQ1v+NxXGiGmLYdSiqf0xPCQHmWMmJmN7HTudfI41K/b6tKqY0Yrd991wIXsfO", - "RwIvbDLbPe5t+SwLf5LV+gbHtAIzKptDsJIwVdpE5UDVDhqdwJ5wH9QGjfyiBylYTMWsrHnB2eLQp9Dq", - "boEqQdVFLezTKPKSPNUmaQV3PUVp2V6mpn12y7XsUy2/fdyVYwHldGYZ3CVQ+OgY2p/VKnvC/R1NnSLi", - "n2bUg9UwPuVCGtusYNhnpkxmTsAISdpAwrPMBGf0iiXKt5vz9bDqvr5Pd5L3lBVVLRWMlXvY5N302Q0s", - "UnUr3YsIO4fu4+ZCwZqn21iz/O9BVVMhB8tTbvmQoq+mT4mEZxg0XVFGuJhmxA2VBFvKfH59fEaX1Cg/", - "/YS7DHXLr9uVokMt6Ea5aDNkP4npjM1VVubwgqnJxInPFCa8zCxVNivsQEjaPRnmnm7nIaTslzfecF9T", - "iyrtQE0G/qGBtg+q7kH+yUGw85Ld11H9hzVSsmNHu0kbGhSyMtG0GjShpuyhFSIZNNI9FdKYCQqo1Qz6", - "foI4w39Te/AhO5WsWWbN9yD2AS4EsedM5cL60C9hvIlkzzPz25lCywZNvs8y4PPQVC+sqCYTb/Rwa/nF", - "DYM7nljvhEoqeY1Kj2NiugTa39Hl8U+NQnBduzE+kgzbhroHFkGLjf/4MN7HeB0m1UAVL9qb02Adb0V/", - "DHqXnN5FDqFLxehumdIsFYa6mNZD54LT7vpsoUqWl1SrM8Ut3BWZSIRlY3eQsZthjMAftxTwylK7FZLd", - "B7nqZoBJBM28MBmyi1XAD9m78CwLOs4NLKq7Xr7ofQe1oCGh7doTvwH7nGHx61vAEtjkzfdefvRpGp/F", - "qrJ+o6NK39uSqJ99MuP7Q/Yr5deO/Y7G/dqR2cAhBw6HR540niM2of0zoP4LxuWCPGLKR1C6g08mQ1a1", - "dqnn2/N6ST+EMVK3w35TvJHiMK55IhlcI5wQEeUa3DWjL9OqITuqj+QBFSph0Cb9SViSAddEXzYOWTrA", - "2DcqGNfoukf9ajLfZZwY4z450mw9h0PyGWh4gTnLmbo1jJdW5dz6uDH3IEWPKm9eU5uxRDw0/njbhs50", - "avJRUjn27rjASuGl0+V2JJVX1M6IHpzX2B40ZcHRV10QYFiJt+8abxUnTzUV217l0DkY4xWK1Rdk3Ale", - "rTaiqXNeGOp9gr7Qg4nIgKjDW/MP4M6CNELJg0Ir9/NBKkyR8QVzCPuiim/2E2KdUMf6fNivAwW3wpdR", - "afY4bO8EH5HNmaLvsXh/uHeFp/r6Lpc7wg1bHmlVjML9U3UqbZt/8O0X8QLcVfd71SW4//DnDx+KMh9N", - "Mj41BB93RZv9U+HMAYSxJ/Ox02ffqNKAL2S6Y3zcdWltrFADTsnoVzI5EbNBztC4pwwm1j3qHXN1WxVp", - "moUXNrnxbrlOo3BCVbyjoNulf9vjN/4p0ljVqe69fg8jBvCT6AIzlaWjG1iY2PFSisJzP7vzuW+bXa9o", - "1oZRczUkb8lAKct8RK8LWg55bu/5s2VKf4s5V2i4EDl4wirA21fCuqsWm7vVU/wnS5TSKTrUq5gBvLFC", - "URBZdKZIKcX/us9MS+h613NTdyBpca24Tn0C9444Gq9Kd+wVpiRMTiXpfPbB5phDN2l0s9ThTB/Vb9R7", - "mBF9u2LtcddBGe4gKS3aZQuufVFkZPVebFK3DNIqSRn2LP5K1rMUlLFLPo3V/tE02l0CapbuAz+24Jrn", - "YEGb4ZV86fVfJavfaWSrViNa2ILGUGg1F2lHBASScu54xiYZu8qwPvR7qebT7YafaD5dHp2rOWw3+o2a", - "w/Jo9Fs6NrFp8Jn78GdYNMaS7WDTwAv8qjkM7CgptVEbNZILsMf4YXN0BiTg1g50H3kUbsRKrEbqBCvq", - "Coa15HADvq37pplDR4L6KquracG2dfJwkBjnrifdcEwnJy7hzlbXs0zl8RLL/d6xBm7hBKtsK724n/DM", - "VQprNI00zM7ch2xPJeijxlP2GcZy/esPP+wP2QkJC5QF//rDD6jEcWtBu+n+378dDv71tz++63//4Z/i", - "yXp2Fgl6vjYqc9ym3oT7EN9JePSlRQ6G/7zZNeNWil3mCWRg4Yzb2f3uccMRwsZTXObxN34OCcq+6f12", - "H3PDnK4kFeiwSOMk7CgrZlyWOWiRuGf6bFGE/vQN+PPB70eDvx4O/jz47V/+abs6Eyekfm75al8qToUv", - "5W6BG1R7+q4us9FRUQS7fY40t7B5Sv8109hbVLKffmd7OV848SPLLGNigu/FFCwk6KTejy56K9IYQi2v", - "hp+t3X/0apcl0NMo3I5tdijblZJNWnc0xhDc46Ophx4uqyon7pOVamvXYG8BZNiIU7R9ZDDX1mOv4/+M", - "Z6pKyLSYQp8LKXK30cMYTNa23/SpOBjew8KXK3sLThxHWhrohtxe8iq01+RK2dm/k/0OLUhoagomBKdx", - "uzNccwMpRqbjgshfMpBTfw5+R+d4dnh4eNg41w/Rgz3kleGOsNMjI84p32ms+8IyYVCt/Ntdny1+a6r0", - "BRfaVLAL1a9vZyKjTUwxluSNU/W87si4ZRlwY9m31KAX3YvVTpe33AzUqsI4vsXLq/9j+TRrfyRYtnDY", - "wTXi6WGzMudykIkbYD/C7wJrZuo51NiMEL7lCzoIE9JY4FhjPRMSuHcVFSrzVqxfMe7BrYZGAjMqQI8M", - "TBHTiBygGCGRjXKDtjYxlapde6cRCdv6vHWkH3aky6oYCO5rBYKntItVathInyvnbL9iD7ufsdWWELdo", - "X1iY0d+XD6FDNtG9QfaGtseetfb6bHNwQZdwr8xw2xrEliZeZ3Z5SW+5s4wvbpELbysM4s1nGq/DekpM", - "vonE/aYd9hKqRn/wH3zO6Z+UvVPPTc9M/OOMG8axSbj7/ZuCT+GbPvvGZ+x+Q6/Lb7zZ9Bs251o4ceuf", - "jnmRwXN21eO3XFi0Rg+nyqq9b2bWFub5wQHQN8NE5d/sv2AabKkla3yOuYZ7+y+uerGQICoSRcUCkhYe", - "/mkFD98Qt/ZnxCeMb+AcosmDes2EYX86bHH471r8fTOu4eVviQ8GN7wjOoRuSUtYUJ9u1QMXsHwpzh57", - "A3oUdnpTfT++LWO8y4Lf9Oo7kaKFCZJ1fBJubo/SYveJjaSgI/u5CMF11LSwiqtqHixiyU1VrDhqNZkP", - "pNhyNuqKv85XCc3bhrTVSD/uOGsl0/gFYgjySmRwKidqlR8JM0qFXr8rlF/oRqyecx1dtFRn0UEnynNU", - "SHyIYagFVaVapNzCwNckXY2Dj/Iddyx63V4L6zNm++yql+rbOz1w/3fVcw+bq95A3w70wP3fVS8ezxaP", - "mvuRG2glRU1EcIqu3sTWr+Kgs64iifgdRtcLCxE8ufDhcPjz0Nc3DNsQYLaIhAtRjRz1+sZi/YAHDRj6", - "S+9CJwp57EjCelX5aDDzcgpdTRy3QT8+mVAC89Z4eF9YVkvdF6i7YUncLOZzlBYFNG1gx+cvjy5f9vq9", - "X89P8X9PXr5+if84f/n26M3LLfKNKNWoU2HBzjPLPsgO+J4I918hl66UvqZ2VYak8s/6+J7Q+8Dz7Z8p", - "nhdDtOpweF4l1PCMWX6npMoXzzHZjpLafeO9enZjNfDchy+PU245uZCVzlGzULKCNeoQbivXkKlbtkcW", - "btoSmb59pMS4+x7GfaZhynWaOc1FTdzCrCivM4F5ksIO2THPMtCD+o/+AjBg4t3FJTuodn/gfwpZflVK", - "VairIgzd7AtmANh4aS/VexT7EJoZL2DIfuGZSKsS5wluJsTKN2PphKkuOCQiJL6AyjcmNNsJHlHUkdIa", - "4iTwc14Ugprr80KM3FobHNtHhXDXQyjVD9GhI4zdHAXhv3YGH+554UaQtlJNlhYjHz6xaY60OKYPm2Pd", - "8bYdflJ9W81AMRIjrw2tn4C+RQ1peXymptuNfq2mYWwjDoMcgBtmOK2/R2dIbB50R2w7y8+wiM1BFviq", - "StLW05G7olX5q9/LxBxGcwG3WwL5tZjDLwJulyBdT7M1vMNMq0D3YSaNqTYe8w0NOWmMWJ5NSGFD6/Kt", - "JjuVwjZ7+NdTafCr7DTfeRi1YdKd51udqxnKuc1UF9X3YaZmabXt2jiephksj17qGH/P1vyNCUMn5J27", - "TLfm8P0Td+9O2et39qW6ZwewMONSl5qtW7G0qXm16cjuPV2qaZJihwr/1SjF011KKYdxjXKgO5daXZ1j", - "h3vsqInYXymItWutsUbySSgls3OZnl5/Jft918ICPjHUvQwWb1F7JwX1Q7+nJGwfKL0sHz/0dxnWEMpb", - "DozR8K5Dm5S729gIE9ptgpobbjkuhtc7DI0zlx0mqClyh0FLGL/LcstcZ5exgefsvl6TxO8FmPvMEFcM", - "dx9c6YO7D43ofltO0qEh7DZ6VS/bbfyKqnPP4feg5w5lcMvRrZfZtixz6R21/bBlVXrLkVGdfsex91y6", - "69255fCouLtvTTyqf/9aGItGtohBSmu+cM//VfOWkGRtxZQ0Sqkfbps6X5mQI37hStxGqh9marqczdxo", - "9bw2Yny5b8208ihYuLOdfUY6+iFcitx366p2RN3MKGN3W1t0h5uuuXTMuoYBFmc+mvW80u2XzfHbhtmG", - "ILb7h9d2zbB1WO1KNONukSiPGJGB4X0PjMVIhbFcJtBy0P3w1BEYbs87RWA8PCzBW9HrGAT3Ty7t0i3G", - "Deub0LMO8QgYxqy6F5puO9NO6Hr/GMEUjB1tinUEY7G3vJKVh2dTqGC/Z3SyaWIqCbb1nMt+wbBAv3GK", - "2A29u2nypR0cx3+h0trs3c9Vn/ZVvq5uNmLtKZXaBxM8n8PNXk91Ez3LGbfJzIch3g/iXXGIJ93xhxWj", - "+Pb7w92jEU86oxCH7HQScvX6rDQ+y3QmpjMwtq4/SkMCV9SA6OOFrPcj/emw/91h/9sf+s8Of4tvEa/W", - "G9Q2wWvio5Q0TBzvoCQt8TsQC67qGzglpApAPdCAxxQGg77nEOc0PturznlaDXKtV6cimSETzpfRrM8f", - "fJBWMZCmpMqoPOUFxTxLuA01zOpQDcQJvMsZ8HRSZn3KpAx/yTrQszP886Qz7LNCm+++PdwuCHQ5F+B+", - "kndDgGaQukFsUW2FhaGozOVWbA0UdeA+7NO3XAOzWMhpcwzYGkFaBbXnmyTqDSyoFhwz7nK8RN9ewMbX", - "f+1DG93sZpFfKyo3gQv5xutuidBY4BoYb3zLTFnUdcvuUmWVyq7kngFg//nsGZ5lkbMUJljkW0mzP2Q+", - "0MlU9fSueucY/nLV67OrHtok6J/HVmf0r6PM/+nVD1e94RWFN1IEnDAUn5ngBnlmlNtlovJrL7KMzwmg", - "+f7FhsgJ/C9c7V8u+TVOu8OFLnFrvN0ov6ZqQS/vIHm0WDbujpdjvORCOj4isaDxqmjietoOi/xbpHYK", - "zcT1tKw6Lm6PVdyMtFLtoMb4Mcp2hWDMhHZDWaHFXGQwhQ62w82o9EnG66cMjcnc124qWWYoPQKPX82U", - "pLNHIhXwokOZADODLKuu3MmCMt7fKbmNVWxQGssY14/VPd6MrNj3M3pfNS1CDTuXD7BZ5wI570avP2Lx", - "7B5mf3xYBthLORdaSXx4VHGKWJ/WN1aJ18KqMX8l1nC38MJuAHZHERI4N5Lhg0IIeZPoKoBV51glwrXv", - "wZfV+bseg/E6Y3An7Cges3oWKq2FQvMdZbMxonB0/afv4wFFjeIw9Cm7LieTjg5eFFG47WSqtN2TfeiG", - "3s+iTvfbDXwXVGYfsVdW3X0a2NsGGVWwaDG13uXL8ze99fM2w5r85z+fvn7d6/dO3172+r2f3p9tjmby", - "a69B4nNURe8rTagWJju7/K/BNU9u2kVNl2OiMxPvjFf12UhUVubUZm5dvG+/p9XtprncJzsGqeOsfdro", - "mhu7KPitbF7YViWKIqJ7tVepry0JI2sXm6Xgkf+acVYYKFM1qE6/d3b5X/vLjJU0exREVQjKHEgidYjL", - "ONBCG5llwNGDpnkIDJtaTm3YAaQrK7nP7r/Mh2iX1DZc78HPTxsGY37tGBJnxs22jh6ilSHfXVTA6upQ", - "EGpvxoZfYAm3QdVLMtLJqLGfyo5bliKNM2Js/DriNm4npurwK/0a/LAdTMWdpGa5LXftQ3/cKNJUGpKy", - "3VypKEdFEmubaKzIMW7z+Ow9K9GeXoBOQFo+hWiX8jVitO7TItq1RWfc+E5H2+goVGC7I/K53nEoVxyq", - "JdPuq6DoDgkeNbec1TC1rUjbugcIbT8ui7oBmwp5P6Fzwi13nOxWCzKALqEeJR0IWZSRQOqUW76VYpE2", - "V9ncoqOa97eNZ36Qvui24xM8jZtu9YTuCwuyC0nqjDD8gPnPh71tTSr+KBp4HdW+i+508bKqSq2h0GAc", - "h2q0JPLZIkqvlD98KDQrx1qNLO4UURUU4n661+0trYSfO1KIpvpuxRoqRkqTC8OucOBVr4tk3f4jUoAM", - "4T7sWzUahSSzUt60Kyhh8k6VErQlEVPcNsL/YXaIa5UuqLEmTRnq89EFSE/dy6Hs63uBx/IEquKIrLKR", - "oZ0inQuj9OK5r3Z3I9VtWN1XegkdsKoWzUu1C3lpZ0oLi9mVGZWspTRT0yhAOGSnCFBqNmd8Sa1S0oJJ", - "aazDzUUBpu/QgGyvWIGLeEy7UUYoglvXQu2HosnNyq11NdpWfd+qvGarSmgVaV5Hnq5tjNNVRJAuz5P4", - "8MFdcDbkfqxvBr1tnRGqLQE6nvs1ERKTFLZRg+oCEmFUlxK00Z5E+t3qn01VCaPxeyuNeWulrd6tH3TP", - "zS7dMyqTzX3G7ryOQTqH6TY1nLbzO/3kK0iGeh5TbwRZU/2iwxPxK3ogdploy6gEmusb43usTxz31xIe", - "FKeww5xRV3C4hX642E0gu49HRVeA3lCIqY0YURHULte0q5c6s3x0t96x85PS4nclsRgQrsV4rkpph4zC", - "U9zDGf9uGKYA95mEKW/93cEhLrlpBxtqf/zidpxssX6qbmVk+bKIL/6QSIyqYNT2Rv1NVMGtL5FZV7Vq", - "L7U7Uew85dbhESulvnbkWiJNQW5IbqYwjtpH5gdt9PH77zq2/UpkcAY6F9hz3Nxv/9hXLG54o5ZjlDeq", - "2V9a1otdE5QjNbj+9P33+7uV3FK3MubncXvFn9CzE/b7vmO/2ySzUl5lUd8tuXPJc4gu9fS+5bDWJBc3", - "a8ft2LuClwaapQaonngBiaP9tPId7Oh8aHrCsWhczPfQLOrQCho73EiUzcWjF+JUmFfmV26TR61wVpWf", - "Q3MAVoKMl2VwhCvmsNluW1G7n49VY7PFFrE8nZFJeAMPrJM20TyHeOTNea3bho8ciCeFo9g5aC1SMOGt", - "5G9gvwnzbw83GYGjJtHwYIsYMxsKLCDtPVK1Ntx0QOhTeUEI3O14rPfRdLyFAMz1t7P2QnJ+h1UExO9w", - "Kt/82L0DjGIOrYDe/LglRJaLZz3rCMhypzsqU6E2I/exL/DO3edUgAwbx85FCmrIzgmRTfNd7fQMPgf3", - "8KdRPpLPPaXPyszAkf9rcgN1HXJIqVUWpsczA9awa2VnjVrq+75GFAUptfFFGNrRwL3Ih1vW27+wqngo", - "fSmdgJtn802e5jmkglvIFtjzGaMcVGnZVPMEJmVWtbj3xQFyDItDU6GQGNehdYkl5PGoiCNxN88u1REJ", - "YG5DT1gasc7il3PIVLFrrOUlVqCjoaxyh1jsq9koF8OWKhBEemcEQ+DaAqftOhBYPPYfnbb0Qa6kskqK", - "pAq+YuREqHfKE62MqRqtNzsa+jY97L3xfUFfc2MHuPLg9MRHF5Y+iP/i4mWwA3rzpzBUKY4sSisdfHdw", - "l7ozBkvpb2th2JX0sFQAg0pf3QoNgwzmkHlbEhZtwEJYRaM4hoccA5nieZBbhAIavgRGffohO9LXwmqu", - "Qx0Lr15SbxdfFKMuAeEYWEqTDdmrlSZe6yp19GMlNnDHoAdosyK0YalKMEgKqn6yY28E+2dfu+Jg6S8n", - "OG8jAK7PVgt0bGp+vdY8+lkbGWsQ/sfFu7eVjTEGn0wYf6/rC5VQ3SZyRyzDq12zOwYJAqS78Kdr9n0B", - "NmCZF5eVm6Cz97d1vN73y6z6f2/f/ht7fbe6f7caf7cqIfsXqw4Nw2l3PsR1xx7hT2vkrWB/ETyd9/Ap", - "d7VUWQ2WLIpMdFhhf+VZNkgyldzQldXmisZltpvxOPj6KSlPx4byjPWOlvq0bO+A7/sWHjt3XvH9Vu4t", - "7rxEy7ixK5K47pStwYANErF9LfS8jvei3+Fp6Y9P54jizlIF853tjQ+r83sDC2O1ugETrc0ZjX6J1w+9", - "V15UCNis9xHywhr5UY4T3WHb44wvhleyxSR0CWwv9LvNQ0bcQRqqNO8P2QV19aoSCq6kjwB3LMCtRT3Q", - "JVPhPdhYr3VTbA//9u+H7l582tb+8Eo26sViEwp3a4uCpMSt0ik2dk7JR+pDiquTC2k1H7ivaEFzJZ3e", - "IDmV4UKBSD8XvDQOTpfY4MrtzbeMN6H6bBR00Z5f/Y6uGg4V8V6xLQAJg5nCsHVqaNFRRk2NHMEksB4X", - "sbfpjDsB73T9RaGYkH/3zb/cq/8Fy4Wx/AZIUUI5iToI3tk1T25MwROokYAdDtk7mS08CzOxG2B7RmQg", - "bbZo3dOVrD9D3Ninq6qesIfDZ1GsD2E523YU+VULC1UPlPsR+npotQJWQtm/sOB9W6F8wG6d5LbEeq29", - "5z2vjZ5ia092dHba6/fmoA1t53D4bHiIBtICJC9E73nvu+Hh8Dtf9A4PchDyiQ6oHxIZx5KIdewN6Clg", - "bhB+SSgAd8JgUIeSYPqsLJzwYUuTRjKS5sI9zwrQ6JVP+0RkWJC2lFZk1B02fH0C80ulMsOueqjuSSGn", - "Vz3MW86ExAZW6hp1ppRdw0TpUBkV7UU+dQ6Rqeo3d5qifdQms7DKK98Pytcq+lGlCwpmrXvk1GnaB383", - "ZI0liRlxJYfbXNIuwpHoDq1iOV6rr9T5t6veYHAjlLmhtJXBwPcaHEyL8qr32/79M01oQ3G0qr9z9EnJ", - "Zpi1iOt8e3gYMeTj/gneKb6sqqN5YC/Xa/3Q731PM8U0j2rFgx95oEmqGP2h3/thm3FYNkPyzI/CCrN5", - "zt1TqPee8LLaYsZLmcw8ENzm/Z5xWI29VTexTVRRGtCD0JGnXgawjLkWBhh1ZmO1ra4Kebnm1c9Dh1X9", - "K7mRXNju1HIldyWXY9BYeT7cQuiL6h4pvgG9kBPNQ5FKj8XsZWi8duF7Y/evJDZ5HmBpckirGekc1fwB", - "DdHoe3xydhCy07GjogZ27TRpSK8kWjjCXW6k7LO6Kdx9iTsuGmIa1TbAH7KfQy6g/0nyHMyV3PMZZ16a", - "Hit1I8D4e7zqUV9JLP3sXU+zagb66/BKXgCwUPibuuLVOxlOlZpmUCH2AbmEqnzZ8HcfhEQZd+78P3Ij", - "kqPSzt7NQf9kbfEydJqlO4huGE1L7mPzvphqnoKpRnmh+obfHVeWBHMG+szhSe/5d9/2e2eqKAtzlGXq", - "FtJXSr/XmUHn52pR895vHx6LrwVc+WJZ2zLaubN0c7iyyBRPB3WvxAGX6SB869ieMhFF5z0Oo3KymuWO", - "g1RTsN9FwbhOZmLuKBzuLDYqtDPIWSlT0OxgpnI4IBZS96o0B1fl4eF3iSMF/Bf0r6R7D2rH4/LmCsS3", - "hbyHolFxziv5ERUNuq+KMZojmZ77O17Hk/Iys6LAHp9K54NgK+vSORodLzsTdutvnPJB4KcAycSKObet", - "6hvt6eNFpF+pzMEU3etWsSLjCfji7wFcu0F9yaVwNPgrH/x+OPjzcDT47Y9n/W9/+CEeBfC7KEbYyHNl", - "i3+tETK0U/HRp6UsKJepJp9q13vYaS8kG+dcigkYiyJ6v2mFuBbSUeImrb7anq/GHXuZrFXgGtC9nxb3", - "LBaRXGEDoQKk/Qi3I6qpiAOjVXn6qfneCguqoNlA8j1uHEMy+00mWB3Rc0P/lj64DjpenOu9DHnUkqml", - "Fj9L/SUNueV888mjs1MsPT1kR/5XlPwUruTUGbKWWeF7KosMMBwrhEjfJVlpHPI69Qfbp0vFFAYWYPJD", - "3UXbsIRLslFg93XsDxKiP4xVhQlGhInQxvruD6F1Zbh4Jqq6I2StDC0pqS3vlQwFykuDzknsGTzzVJUC", - "ZXC5d2FtB8TkHCqo41a7gQX1CPXXdSWDx7PgCzeLd0QwrUqZDqwWBXOqo0wohhywwIBMxVykJc/8NDHO", - "+yMqgu0eovdXA9faTFdXqtsg3k8ZwSk72l98StqrCIH6pUYJoInTS2S21J40EFsbcHVj0ieCV6Tz6T3B", - "RL3iQl/XQNafFEIXIi8zShglqmt2bo4bEldgROaqA8fqu8F0Djw9bpi2Yrf1WOBqNy1GaC29varew35J", - "lFMrdPPg23WHJstylWm0YuXruk60DXbfZ9s4+USoH7eA3hf90erps8uwoWkFhc+GYf1KBtlgTN8CXlU7", - "4DiYqujgJ4LQaqPhrYHzKOs3Sp/F6IwCl+citMSoXsufDcR/EqkvwqJum/Ud22BuN7qOa31YWwq1FgyR", - "DwyVOnL2KyeV09x4qKroltWWvEIYeiCXu3ROxTw0QiTFNANuAHWrZn+pDS0kYxpP1RD1iVBzteX3PfmG", - "m+gzEZe4lbpyJoGJIxyWMGYKlhBmVHXi72QSfwHbqnL6lOIxXk41TrsYdUAnrQ7xGLf4F7CtwAaveRCz", - "CCtto3y0O8jHL7eqtvpEaL7am/5B2qG/BXeyT4vqb0IR0RZ0glSsUgNqTmO2gVira/8aPhrCgat10I2P", - "PLPh76/yEshOXifINMrNXclYETkKEcNCZ4WGGUh6N69Wq+szA3Al3WbiFecYt7UZfSrscKIBUjA3VhVD", - "pacHd+7/FVpZdXD37Bn9o8i4kAc0WQqT4Yz4uQ/nmimptGkGfvjox3Be96L2UfeJvwrMrzDehEZQUGnU", - "4+FLID4ROSxXWLwvNSBAEVs+J22BZHzTloR4uQXiN1v2dLGqS34DF83QyCfRGFdSNj94GK2VOBjIelBQ", - "inG90mbr5opgqTdA0bGfFKBVbgKrARSC0DaAU2VZNxOjZFQ29wmbVAXgQDnaDkmk7m+2oeM1OGlbW2zZ", - "+Vp1PL0a2MoG9W2tJcvUFHNFrUhuDNuTyvpMZTJxNjCIXcOMz4VDab5gc64XL5gt0Urnu/g3ig5gzBSm", - "VdRHIXdjSE7FVFZvu/Su7n6raIIP+UFPT8ukuVfNgapwvcA+xX2gFYmChUIseGCF4xAbRgaMwUBDAdyy", - "t2wwoKCrQ0YeBFLIyYcwjnHIi5AT+kTk18hSvi939Oj1mdiQaDO1rkDg4dZpxjtocyHot4M5+oDLJ4LL", - "cjzng4wcFET42UgtdzYyaqyDgo8R7uZpdS3h4G5k7v9RGPJiOTwZuVblIjKWOwXNqqLAZIwE2B4FJPSv", - "pPfJ1t6YvmMcmL/m3XH9hs7ny0Eb8buQ033/aq4WElWxMQZ3PLHZ4krici3PlAaeCulkuXs9u/c4RlGH", - "NcZUQrvU2RjX82yHs2swdgCTidL2Stb9yKrC2WHW4KVwM6Oi5h42fAqM0hN+dLzRASE0MdU5zzDU1Kor", - "OQ7q5Ng3YOBygTfNFqpkqcIQaAlux0eWZcCd0iqDYZniM9zX6Je8BuZLKg2v5HkInGnDinr/61JWFY/R", - "bfW8EX/ThI2HQJ/c631UjuUyxIZRkGCxGwIHiT6QKQXGVkk7FLN+Ja3m0gT19jkTE8bRtaPr8B+3b3Q2", - "uQ1ynTmxWBMdwyRDwMbEIRMu50I6fMC1KRA4AY+r7k9SycG3d3fe31VoVfCpE8jDK3mmYYKqtbseJ8YM", - "FBwzXsd1dME/jyl56MDf0Rj9eT66lcgmg+BdHFgtplNwetKVJBgQJQmJ8PQJrHX4fkxYhVs+ruj3EQMF", - "KCxo1AxvW4rvuHw1+Defe9OOXWI5L9j/+V//m2GMt4GcSysSLKJ8dnR5/BNbjZ6L1zz2X406AiUbOyAf", - "Nxv/cUVBjFe95804yd8+jLfcEI6O7saDdZtt5I5poGYSfyet9lkYsz0suXJABVcOwCbDkLBK9cZDQPUq", - "AlFIuekH/yym/VYJIsvcWNSsuBW21KLUNpFGS6KtiSN52QzzMWiFDLtPnMRKSqxMUk8xxMgQOkadGbA2", - "7mh/uDkI5cEhIk8fv4Ex427IyPPO1du0XA9/NzYWnYJpX2Dweset2BkMNvVpjJ45e1ZghsyzsxB/5UtW", - "YMF03+CqDhz0g93/MweNxvmowRvI3Pg9dLdTqB0b+zC/A1oFHfvjfUpQHbt7K0Y1SYxJKiCLJHD7eIZw", - "WDvjVXyNcfIOP7jVvChgpZH/RnD5clhOuEfI+Px15f3x4h28cK+58FrxXdmC+iwDOSX7fMKJ1iz79vD7", - "f6M6i/2a9BwAEwz2pTAK5BEeALSL6ww66mK373KN0lYnWIUbRO9BPZZyuLUoyFm5hJMVVuw5GVlVFvKZ", - "RFgbH+6IIjcmc39WLqqWJuT55Yta3aywwM2cwbLvavgQxf77wz9vHuc2mIlk5TnwOM7yZe0hPB867wlQ", - "4XL/i7y8iulOWTHjeMXNl8cR6jP0bE8rhQaf8j47t62JFllpVu4+VPw6aEjfKso+Es7tpepTGTgjDZI+", - "Mkb71UOy5Sqw3nsva3grtS75k2Hsg2OXO47jUGNiDhIN3MKo6oOBaFLGIobww6qIz1OFDbVX2QlVnq2r", - "OUTn/IzMC3RSxjHnq77+AJcUHNvcAi4n+OFTw4VWaTa0u7dfugIJHTF9GGV9v3ncW2VfqVKmj+jQxp0z", - "3g23oAevAdkrUnc/b2hhRbn/AYBCeFQwUrfSacyOuka/CywhNAUbq9RlSy0N4+yvp2esegs03hDhaVAV", - "lamrvwXUGK7GkPj1T4T+qygwIl/zHCxog+0vuho+VpSDOqhVla7vVINwKHzduXH/KAHZAb3pQh28Ng70", - "m0aMTXX1fttJOPt7fZDTy916OGNVOwkRq3nBXyJeemA1WYh7DRCihQdtHF+NTbdA2PD23bNcNx7AeXAO", - "ox7q5tpfi9dXcg1is78amzI1mYA2zIipFBORcEw9n3BDzz9a0OuvVzKF5p/cv7mmF+DvovAGF57MBMyx", - "XS7Y5VmQjOKRWQ2qcnf0pZBV/4/V5m/VcTGCYch+EtMZaPqvqoc0MznPsqY54rq0zPIbYJmSU9DDKzkg", - "SBj7nP23gzZNwZ71mU/8d4CFlO3993eHh4MfDg/Zmx8PzL4b6AsbtAd+12fXPOMycaqUG3mAEGB7//3s", - "h8ZYAlx76L/2AzzDkB8OB//WGrSyzWd9/Gs14tvDwffViA6INLBlhNP0muCoW0eFf9WVmvxV9fqN32jL", - "+A8Ta0mwK1f01Psgtni5ZNf6/wlrXDLnVewRDS6hdoNni23WUDWT35YnICfw17rS1/5zkbC76YR1Q/1V", - "hEItr9Gt/wtEm7+AbZ6gah+1Ar0KbTJhLOrpphNvXguD9Z7NPYXJl4kp9akjqFI/3zKqTfIF4gpm6yLk", - "KZFwFTewUX7X8y20dn/C0NjHeLphKGpt7vgC4YQnwGbe6OVaR8waeFo9uqO0fA489U/u7UgZFwsqoZv/", - "c6FmlViwg7pp0YN0CWT90TyuLwxZMGus5a6rkMMAMfpRo7Z8J3Wvlvh/uiSkjl4C966u0Sid71OGvkBA", - "XoBdJfRmW4ADbDtgZqKoIEwe0O4gLKxzYhqOUp87rnQdX0ICwYfqa8iV5wGUyzbsqDoR1INHix6pNJIO", - "F30Kxo42tFNw3/g+6xUH81XTvEK7TSOFfu++3nzvya+3unM5BrqFR6vEgFCqijB86awuUpxh4vW1JjkE", - "0+baIjMcDS8Ug4Yds6mejLCmtm2upK8s41cXcZB189FIY1fUT5sdJxqVcuoYCbUdHTxSZMs6ergnYv9V", - "FDVaNwD4PwbJebPg0RKKruC7N65sQPhdTaNddHElNxPGZhNpyyJ6JZdMot3ljryN89GIqzOK6nIGy6aX", - "SoRsETf0yYg2HuXTVaz17faBPr6Nl98bFjPC8r4OnQYD/GZQj9sf7lZDOcDhSdjFkb/D/+EsYxldO9jG", - "7XJBoqWXQKMR0lO9ASK9lraH7T2Lp+Kxo23P30vxjxJiDYJqqrz117FVvNpyvXabzNhj1/j7RMhGh2ka", - "qX2hJjltaGJ4Wwd/hCv/4MuYAxUpWcY3VdTotmSkQMODtzR4u0MFx3W2h82mhu9jhfUJUBTs/IUD6gJb", - "/oS48pi1bxlIB5Qj12lKoq7dr8xL+uwjwmrZLGThztJuo/agTf6AC3za+mY7kZzTuumNmjTewj6HEJuc", - "8hRP/UfvPwcXFy8HvnzQ4DLaiuINpIL7ausT7CqDrTd8SuLeMhPbb3nugpduhdVFnHIfvkQ0pe5Cy7fs", - "S54Q260w1j3m1wcZYVGebQyeJw3li68YPz+i3/td3ZAgtLHs7GDZ6p3yp++/79omtn3s2NbavpdEfNtI", - "/AeaY+9pzahKQn3pYhTNUk5yhnjIOlQrU1NzUF9s3EWnpoZIp4MPLyGE7y60DnMDo/EoXte3jXb1jy8z", - "UVmmbuORB63W340+ectgxgSPKm1PTEI7P2GY39oawuyWKrus0zh7fLX6g1FBbWp6n0yivVbTLUWZQ6zP", - "WnrFJIPbNOVQXly8JAIpMr641ZT2RkUjtyivWjX/OqtGs8QxW/SFTjSYWaOpLYLmzjI+5UIaeomHLARd", - "SizhLJVkmUp4NlPGPv/zt99+S9mpOOuMG+w5Z5BVf1PwKXzTZ9/4eb+hhJ5v/JTfVJ1iQpUG34fRx2Lg", - "jPXmsFSuLbWsW78F9IoZTvwV1Oc+JunwFC+7lbU+UdZDZB/uQuPJKtXlfo7lUOsjYNmBC9w5YUQEOT2B", - "EE9C6uh+6PsGW26hJ6vvU63wifCgtYMuDKirGWv/zWdRBjdRee64hFnIZKaVVKUJVW8DgE3Bb+VGCF/g", - "V08KYlzi08LYb6ELyPjzJy5+sgpbvga4f/h/4Nv8RrQrCEUB/bPAUjSb3+X1zGtVwkqTL0uRPuSxcC+A", - "utN8lpVK3/38RcYXOFYipu6laRULams3xlFhgI04d06f/Y/BOjrPV7x7vAAlrC/B2dnlfw2uqZXCZuQz", - "ltuy2xQZWD599bFx74nlGB0qJsL8L19klLIHADPheN2gT8UWOg1+9T+G6+BxPrH+RFvo0p9+XGDrDjK/", - "fbEWt1ryMcKztXioSrvJEFdfnirtWovcJ+JHD7AsVWdzw7a0MYXbVaUtSuqqn4kJJIskg68OlKdzoDSw", - "WpV2yWCmIcFyodOD2gkb566UOXwevn/SRO1qlc21ZZfTPf3AT5ei/YlqW1SJ3YWGucA3IyPgQsrmIgXV", - "8CM0oO6Tyzq5WMg+awJ+rfesclr51XWzyT5VIfNN/FvVXMtQq9t7BarhXY4sZHpxNxYf/H40+Ovh4M+D", - "3/7ln+7FGvHCDvLi+wenE9QY6WMeWwyu+nXwSkhsUj84ijV6FjkYy/PCMTlqzo+W3XpqGjxkfym55tIC", - "xctdAzt/dfzdd9/9ebjeA9LaygXFo9xrJz6W5b4bcVv59vDbdYSNxeVEljGBxSKnGozpswL7WTCrF2T7", - "pBqP7es+B6sXg6OJ+2G1FG45nVKuKLbVwA6QQrK6YX7ovqgXRAT1IapYtmeRWLYPX3DCKZXiNUiL1EB9", - "C46SCZIenfmD556wzUP7U1T5AOsESliNMj1XguxX6DU0rtTVLh8twY5nWXPa9rWtdECNhN49tfBtL7JW", - "9j5bR6KeCXyBFaLwBqoq7jVfG7J3VHK2yesK0Oz0BFsgYm3zqTAWuzRiyWrHQYarUFbFOiCr4ulh3Fjj", - "/uqVD4X7tAXDrSra4oeu2yQ8A6t+B60OfD/7tW1C6K3gJvrlDRUtdDNg4Q/F3Cx9B1yu0wyfLxP20+Xl", - "GbOaTyYiYUoyYYfsmGdZqBVydHZKJbKFcVPeOml1y2+ACcuuIeGlAfZeihvNJ5Z+DZ3HE9/Y6QZ8k5JF", - "KGIQck5+eRMt9UHHvHAnv1R/Ba1624Q14vcDqwbulMzfVfoowDlNIS+UJbHhZ8Z7hXCrjSsargIO5Hq4", - "nYOxSoPxZTNp6uooVSeCeo2+47/qFlUIvM32ZkhrQI1GpBkQQGlspeb88oZJ5UuJYOVs43WbGWQp4w5s", - "US+7fDhsQD4RaGjiTZCxkEHudJ+NhXaaDZmqUe1Se0MWPv7+8HsmJo3vqGp3XSQ12nrmL2Avq/08ofWr", - "WuTCchs1u1/GD3hf3W21u1X3/FXlyiV2xrVvgkH5rgSQTkCgVEu4hSlV4oU7d1nCIYbB+hHNOirsWqUL", - "rCZLQd3pi/CSa06hwXIaJ3SFCYY69JudQM98X38Gc2hu3eGrX5ByYog2njPs8s+SDLg2oWhT47SxLkbu", - "FtvI9ASdeikAo1qmWXDz49ly743NX3DmtC/4uY6MyljXHbAb6CZg8beHz9pYfMsJjRtWmBqjX/jgLDfu", - "0I0T1g1wiJ5BEgK4VGEHQj5nvBb9M249lrvZm9S2x5dK4FKynlQWg/sdETvFQZfQZ0oHSgrEEyT+fifR", - "vCBB4P6vkhpeIO7GtM9K++no7LOnq13zl55mQwY+bYDTxTqR11JDGgkpcfXwVP4d+3VwSb4AJkJuar0A", - "uSb6bMp9Uz9MqkywIPnyNpokf0g0hl8bI6YSUgZyDpkqoFYW/bKG8TSYO789/D7y+0Rk9GzckyosH0pc", - "+2Qz/PYbUxOuMDXtImF/f3jotLY5z0TKq+75Hc0+zsrrTJha7pED54m8mLQWLvGJvJj1OT2QopF+CI6C", - "dutYdQXRhOvQpaCGN/UbS2BI1BvR32lCniRQIHqVtob0elx7QRIkbOUBteHbTQdpwi1IYpnYVhydyxZ/", - "kNQ8eA6s7fOrZyaCHbKXPJmxieY5BUJj+Q2lczYW6XP2h4F/fLi6kim3/Dn7I4Bg4ODt/n51JcdOWtLd", - "+14EVYu4BIwZ5Eoqq6RI0MFYgDZoeku0MmaJ3fnUxBeMs9fc2AFCbHB6QjYA7JbkpbgbKGsJjVSGD3QN", - "pszDs5+OPWQnWhW0KQqqIoBPeWGCQj0W6Zh6lGBHIm/DADGHlH4ThqpY2BmX7BnjM+BpCPnO3F4NgMRP", - "+8HXeQvaMQqBectVn/jrcjIBPWTHmcCvfG9Tq3lyE5nNKQspWEgs7nfIXmH0e318E/SLpStDk1+9bK33", - "e1A5YGBahQHAAt+06xes4Maw8f+tocj44t95lo0pr7w1ncpSLHqJTwvHbT3+GgvcN366Fe6+Z7zANA1s", - "hwgStEjYuM3nxtSzNWhN/vbAP2Q8Zf6MrU+osSTbc58vsAWTwzZqFMhZqpIyB+lGje2igDE1EauY9Zh6", - "pjicUzqviobUDX28vvLPuK0T/JhYVp8ZVAhpPzR5tMMgIlz7eBsr8507lA3dSFC5M2168t3ClGYGZMoO", - "I/AI4A1t+balyT4zqk1Yc56VlNOQgyMzrSHBWhC0FHdrCGmH7JLfAHZyTSDFhdCPPSa8GZNYxXaStDC2", - "KsPlHEPipVUDDR6N6+Uy4BIbZSEikdl/QFM6CM2EwfKWdWVV8ibVTsgWEeyWZHSGiL8Lwg/ZOdYARpJm", - "ieMn3LJnh99+/wIHVMjMG5wAw8RLPeEJUNHQidDGErFPMcNMey4z7CwgSzcSD53IsvvVgH1A8MlW8vz1", - "FsLoi8t4Wj6Bg+gF+s8HF44ePQdwo/+/AAAA//+OVZodEMEBAA==", + "H4sIAAAAAAAC/+y9iXIjOXYo+isIPke0ZJOUqrp67KkKxwu1pJqWuxY9SdVtz6gfCWYekhglgRwASYnd", + "UY77EfcL75e8wDlALiSSi5Za/CrC4akWE+tZcdY/Ooma5UqCtKbz8o+OBpMraQD/40eeXsA/CjD2VGul", + "3Z8SJS1I6/7J8zwTCbdCyYO/GyXd30wyhRl3//onDePOy87/dVDNf0C/mgOa7ePHj91OCibRIneTdF66", + "BZlfsfOx2zlWcpyJ5FOtHpZzS59JC1ry7BMtHZZjl6DnoJn/sNt5p+xrVcj0E+3jnbIM1+u43/znhAo2", + "mR6rWV5Y0EeJ+zwAyu0kTYX7E8/OtcpBW+EQaMwzA8srHLGRm4qpMUv8dIzjfIZZxeAOksICM25yaQXP", + "skW/0+3ktXn/6PgB7p/N2d/rFDSkLBPGuiVWZ+6zU/yHUJIZq3LDlGR2CmwstLEM3M24BYWFmdl0j80L", + "cfCaCXlGI591O3aRQ+dlh2vNF3ihGv5RCA1p5+XfyjP8Vn6nRn8Hwr4ftbo1oI9yccyz7HTuAb50k5L9", + "dHV1zhKeZWzKZZpBykYLPMwNaAlZT8z4BEyP54IZRKzVq0y4hYnSC/dvkMXMbc3hmFZZbWvGaiEnbmsp", + "txvRK7L9EzfMoZQqdAJbToAjL2nEx27H6kK67aard3GlC2BijGd3O2RjAVnKbrlh5SiWFuAQwYjfgWVi", + "Jqxx1+FPOFIqA44wtBHEwq0wK2ZgLJ/lTEj2QYo7NhOJVgYSJVOcbaz0jNvOy46Q9k8vqumFtDABJGn6", + "S3XbPBcDB8PIdS+hjDVhwm4Ft/JOt0SkEw/AHWj2HHQPsSzni0zxlI2VZsOw7yEDN69Zxa200MidBrPI", + "jf7Ks6yXZCq5YeE7R7EOgoTM2l3yTGSZqN2vP6EsZiO6TbceLSIiePE+B3l0fsbKr87SsMjMsSFImVaO", + "3+xBf9Jnw1yrBIxxLGLYZUPLb+Ay0QDSTJUd7td2UFGEJj4YXd/dnP+didQxtLEAzcZazVroNHw9E2ma", + "wS3XEF3UWG6LyK0iRwhCnNFXLFFpfZYSF5fQq3aQpXst1+s2YLoG4xy6XVqe3Kxu8fjknF0U0tFSHz+5", + "0jwBpiHXYNwVyQnezX/wOb/EccTijPuWcYs/utHI4CVhX5+9dhRvWGGAuRUkn7mJEiXdzygENLdT0MxO", + "uWRG8hsYJNwgS0BcwHmPp1rNgJ3A/EqpzLBzraxKVMZuhQZG1N2/lhE2mmWvNZ/BFkIJTzPGj7vMYZ+e", + "KWNJADVEz9ISKitm8h1h/soifwWteiNuIGX0ISMaYbfCTgWJuEzIKB50O+NCojh6x2ewOncNEuFDd7/Q", + "ZUozmOV2wQgzkTFwqeRipgpTfmyiKOx2s8Vp3GeRs9DX8dPQb2dpHPfov2vkGN1dobPV4R8u3rgju7MH", + "NuJnG4ssRqhLFNa45to+abnGlXSb8I6RWlO9WGLaq5yQmD3L+AgyBBRuH4nKIgUSD+RmIROW8MJAnN/l", + "XAcFNMvejzsv/7aVMK84wsffVgQMTtnYDGISbgX/avorl1kjubWMKLfJlF+qbA4XYIrMtqlTLKFPmXHf", + "Mm6tQ22mgaOc4MwRqnBXqAqbqBlsqUzRrA9VplrO8U2vatWr/MUPEJwDjXf2hDrWOgDtrm4F7GtoXLET", + "tWtf4etwL0uc0CP7HGSqNBvzmcgWfSfv0iIBbZh0N545mOZazUUKumdySMRYJMxyc4Nc0DAhrWJ2Kgwz", + "YF8ycA/ZXAsDbM614NIaxyk1BOJKVJbx3EAYCEKzOWjjZMqoSG7Asr35c3bA5t/vdxmXKeNy4bj+hEll", + "WaLmKEuJV7nLPVFOEL21/kBdlmdcSPb++GKfCePUCqUdlnLDhsopAEOS3wFNpoFAHR6EO5s/b/7n9w4p", + "Ci2NFZnDjAmAdW/fbgenjBP3rtovaoXEfIzl2jqiivGcFR0YH60Dp+WtLoT4WAMdfosaoXv4jrnICl2q", + "v6cXF+8vBsdH51fHPx0NPry7fP/ml6Mf35wO9/vsaOSUMzfIFIlTknfSS6+Wz8GGfprhSzqzZhrcFSOr", + "LQwfZeB+wJd6nw39TmNfS3+oPQPAhtVluF0PHWtRha3GpSJFTKLxdZXCCRTQ3xl2y4VloyKdgO2zIR9x", + "mSoJ6fCl/4QlXCaQufe2F6M5nwCTfC4myBH5LV84Db6HazbxzR/b8TQ6krtG2mSn2ykXi6KUo7voO8ND", + "mRsjJu5OasoNe5/zfxTQdZrxuCDJb4rcUQVzPNb0NIxBg0wgDtJbGBlhYTBVJiI2f1Kk1Ja3cDsFDf4+", + "ieSdtMCLSNfOn3M7jbyguJ1uPz/7fwrQpTYKd0lWpNFlV3SJGq+8x2snzY+VlJDYdlsN3HkTX5IJR0hE", + "cklhrJqBZpcnP3fZecYXt1pMprbLzos8Bwug990jxs0NKSOWiQ+cX2F0qZBf5lrdLciMJQz75e3WRh43", + "qdtfDNW+KRSrCkWaD/ytPaUekeYnwiS7olNajoG0si9sQBR2zgW9qvBrMZtBKriFbMFyDQmkjoqGtXMP", + "g7XUuCeQsRr47FHQbRdNeOWCvinBa3G2Qo1Pirb31Hyr3S4pv42TPL7RsULQreyOMzCGT2CQqCJGofRs", + "d3M7EvQfO2004wunIKDkjawLAm1UqdD0t7iBQwM3sUf+r9PF8pwgnQBkQ2ITgyRTxilR+BVxDiGFFYjD", + "9EdlnHZW5ETdg2TK5QSVH7SNiWLGNKB+CinpOGBQe3e6Okpp5DJWaWCpupXMqPpqiSqy1L0HPIz5hAtp", + "yKgn4ZaFdetbQJVu+LL8jaXCaZI63CvLi1lOSiCdVUkLd3ZQqmn+wMG26n9HCq5UuT27yIVT8BbeWcLM", + "tLDuCPtNDa5+lZ1uZ/mm6n/CPaEtZ2lHmymxjsfL6FZiwDqCVNKoDNDV12ryGNG37kbcx16RVpo5tlZM", + "prZuhYW7BHJCKjK5ns6ErcTNrXJCyAqZWER64hmGxEsqxqhkWuKgZspzMP3SDuzXPzo/O+YEDP+Xvn+v", + "8Cwz+w613OvUsAzmkHWZu9Mu43pi6KmIpqIBGpCqucttX021w8e98mzlL/Wpac5MSOh6S2rXH2VQ6Cyy", + "jjc8uzeF98i6p4vX1Ggk4xoYxwdU3HgclZfu/A8WlstY8E1WtstKuitPtE8oKqMw2dWeiiOPia90PnaX", + "vQWOKCIUn2UlrXM9KWZuZpYo0Am9Luisps/OyRnDlMwW7s0lPSp7am8j3Ib/YvX9umSxJvqKGKcaHoyG", + "xb/2/qv4EaIXUvfWG1/iCnE5i2wm7kUIt+gGsTnP3AubZ7d8Ydg1GWSuOw+6xai/ZHUvb2rukc93URWD", + "bHGarDhLmJ2iK0/DbXOPj7CxhjkqMOqt7eylm6LbQdpaNXkUMy57GniKnJ4klBdFpNMti9VbVHpSYfKM", + "L5iwffZalb+SiNvbJyHXrQWjBAqtEyj3JEpTRERZ1ythMBZ3KKxof16B6DI0O1x3PoSRyIZespFSs+uO", + "E/213/aEdIJxJgzss6tFDv7jOya8wCt9fNcdkmwbeKa70FXW+NsKc3yjJlsrLZmakEZSaQ2ZmnTL+xVy", + "rKr/uuVadhnYpL/f/wySOBzsmxzeKIczNXl6KdyAx5clg3cSpWtEVauS7ebospwbg48/rYrJlBVyLDKL", + "ThZktxQR0feG9SH6VFThjZENlck/yZl7zwFPXzGeZQz9I2xZYhqnKgPXzMmoPrsEMlWZHJLSNT0usow5", + "nIgylifi7a+R8S6DZxU6m03KBJDuFiyvgUUrO/IfeQ4Xnq5IdFW8X2CJMyWFdS846URFlrlb7QXp6S0m", + "7Cw4B0hYWa4nYLsUkULvG+/JwKderpKpo+7bqfAxMrQTlSSFdu/tyIMGp4o6KhyU8dd6OFTNB0Obies/", + "iqegW2dNVUKwou9q83eZUyjQdQU8mdZOF11H8vnAwD9WV3mrpLJKehuBkIl7hKNjsrouiltNgkrWpc/c", + "viAtN2BV3kP0qI+MXsIW3NObX1rvJZhn6uFnnsJonZq1KHof9FV0/oCbfqLaEnvGonLkDV3VOU04KGeW", + "j/bXrRjkwhaUfYUjnIayNnZHQwZzLsmzOhWGUPkVOZbcB2OM7ilh4mgBfyPS6ZYWpPJbsLdK39SMkeuZ", + "Qg1Y9YttHrlCwTXiq64K7Ghk1WoOkjsknYHlqB14yC0cNhOhe3uIZuCNPCXlr2pNENfUQixBzfmMnAPD", + "p7zHuU02DfF669yrNFHhVccR50bItE1VCQfqoyk5mDNjoX5ejJVOFM9c+2xI4ZoDnovhS/Yz/gc7Oj8L", + "9sI9x2f0HMhiTX/sTUCCRnUr7JwN4c6CdIgwfMmE/Ds5bfx+yt/6bJiphGcDH5Q6fMnMwliYMf8Hpgsp", + "HcR4puTEiBQa223aLNO80+1U+3c/hYU6jrfWFopqugFV2pEtoqRswocgzQgZHLciOjjwdHJAouLspAHv", + "QAtLtIXAX0MxP1mb/wRONpj2Q1hdrBAMxtROaSSb8dxB95brFINKesJjitu9Y22qsGXsDAkZ9gvPCqfy", + "aFR+go2ZtDw2Kiyb8QUbAeNywf7j8v07VJEaWs/KYTBhhFIIjjOR3Gx8LBX4YnKfBk2C57ZwWt5c8AoJ", + "kdtVsZWbX0ei2shDX0jRM317J7W+k2pXP0DIPuFrqR02j/xmMpBBYlUkJvj48pKFX1nO7TTY2PHsjr9m", + "qGi1qBSTWLD82zfM8kkjoHdpNgewIs9BY6w4MaofP1xdvX/XZUdddnL2S4sOE1XmfxFGoHfAcT2fytWy", + "cJdZjQ756PR3sbnhFqN67nqJUjoVktvmqdxZ3C3m4g4yE7fkLdZMvLj/xEt4eNdxK3UraBOE1j6Taij4", + "Myw2MrwbWIwU1+nXwO7Ceb4xu62Y3Q0sPg2ra8DlkRmdO8TKBf4MC3ImVNrnzx6P6W6JAZ26LXbZjzy5", + "MTlP3Ks9zoXuwU0D30P7/BSjL5LCkB2eUpYWiDG5BmNauNP23BYnX89tz96df7jqsqvT/7w6ujht57nL", + "6iA8gMFcJlpl2SVYm0G6kdUY/JoZ+twznPBu4mNbfZIrI2qppxgxIOSk+2Wzp9Xb+MaotmJUBPWBR4xP", + "w7NagPXI3Muxp0FECaHV2V2vxHSfsEcR7ZUf0H01AeOQfhu1BNdbtK63eOz1vD3mHvyT1tqkjqrY5b3G", + "CHmzeoXIQtzk4QSB1WxzEhW7t8ZSi0dZajnXjTCkBJ0/tN/Q6g2vZc1vxBycGrohypplYg5sLuC2Cjdb", + "Cp127/hxkQXe/Z1hv8Lo4uq4tOG8gxu132c/+e+UzBav0NcZGPpYaZwlA2MYZe5+6hDY2HV8Y8mtLNlh", + "xcBhxScI324Fze6RsMFy3wiDXTlLeyTsOs/Am5JQVv0DfXbZMN6XwZqmy4xinFnNpUHyCvbvUSZylnCJ", + "RIKhgN6IWsaWY8D4sNrScCdj+RYXvjlofpU7xIPmt2URVfB8DCqjxcpxPweL+BYqvzuX+CQB8+sA9Oi8", + "4gsKnL8vV3rlK3aEqHlNVS4oRaWNK+7okdsy3estedlPatyjhedc+Ryc2h1ZFTw9jioyZWyfXaGuaPUi", + "sE3vEEi1ynNIWSGtyIJzf1DyY/e61FrMwfTZlQZu0YMgZC/XauKe56HEEkYsW2B7nl8PRJph5McEBhlf", + "qMKGN8o+44YVUkMmUATQynYKcjsG5vf4UO7VdsPf2Fcr+wrYUZdpT8i+1kJoE/9q4lFbNssF/r2MVqgO", + "hk61BIloUOailA7d0jsafunX/aBLozbf0OZMC38VZ1LY11xkG5lB4G2UCuOeFiPwWTiZ+J32+6kpbWnz", + "3+hsI505gA3GeGVPT2Yx8OxGZMZC3o6SM7BThdnsJR76eCYLOZmC6ajeJkvxNn0D9qiw6shanky3sMni", + "Jjaf9iIIuK3IKSpbG7SloQcYjyTMtLTIwt2UF8ZS/ERWPXLIhoTVN0yfvVNsXGiqG7UspG9FlnkBXCbV", + "etr+HCQcu7VvdLyRjkvAfzJibgXUk4jNBmL7khP96q8DTwdOgBIdOAwPBMBuQQNDD02Rl+EtvoTFuMiy", + "BYpZpUPRtiZB1iVvZMVHFL4X8GBVfOlUEZbBl3WQU2IEwTKYFuU9THiO8T6k3x831XAsS2PAojllKdww", + "WFSs5smNm82rKmyswUyDkUIYlish7WflM994zM485pOyl4ewlkCr2xoFsB7j0vOfWX4DSGW1dO/Sv9Ak", + "pW3ud4U3xDa5+X6qgp6thsIctFCpSJgpvw3WjuDznfugmO0osJrnkYhw6RDfaHAjDa4FwSOTYAw6u1Fg", + "LiMRFD9yA3960QOZqBRSdv7uL1siaHlto4WFjVq6W3vNGd+RhDpLM9gYGRGkmUhD5PZSXARnPxwezgz7", + "RyHAerojm7pUTMjeOBOTqWW+rC0G32/pbfNLP5Telvzg3yhslcLqRsUnpC2Pd28UT4WcrH0ariJgRqPC", + "K9YXsDgbN+qCuNvmmQaeLtz9eNzDyCenOXJ85ro3sFQs10JpNgxn91MMcY66p1jY/S4bFjobdtkw5EW5", + "f5fpTEPKuRpq8FnU7gKGtZIRr9gwgoyYiZdzTTXyWa7yIkMswSQiblnCDWxbbeKRiKUVRN/k00bq8Rj6", + "9K/Q9UB65DghKnizCWZ1AgwjllMbMcxmEin8XAMd1X6Mh16/C6lamKpa+82btCTYly9PLy4Gx+/fvTs9", + "vjp7/25wcfr6w+Xpye513x27iNR9Rw9WeCIqLSZCcrRALbGRVueVW7XGJeIL+5P2L/ynV4scauYAXGEl", + "7beeyeIzfn+W6lZSOKphQmItRXbi0yy77DXYZNpl//nTRZdRhaAuu7SLDMwU3Nv2bIb1Bt5CKniXvVZu", + "zBXc2Sv3su2yGnV3qxp1XfaWSzHGHZ5rGNMa7+0UNLHJmdJbFNpulLKvYUW3Qsi18Ub+CkP3m22lTAAf", + "lq9oSZZ7evZb3/U3xruR8XqgPT3HXYHLI/PakAG9sQxLmSqNekKz/pu/jSjvmday53bZdz3zbrX4u7+W", + "kGHXdyv5PTmybWVzZ+GbPtbgETLFZkiYwYrqT2GaZ7o3zzOeu+VcG8eHcg1OWhNDwgIH0esSZqCBKvmt", + "oxy0BnpRYfx+TZFR/yIWZoiTDPltWtqAeKcONyxUbnaTYyMLEnl/Ob3qsvP3l1cthf6VsYPAfuIwG6l0", + "gaLFzXJw/uGqfKR13eH4nIuMjzJoEWV0tDi+vifxmGGu9QjGyhczCqMQDHgwVNBrl43XqAt4JKndZYUU", + "/yig0X2icvN8k9APl9AejbtNFlYxnBWGsJ3wpi44O0hv3zZHQwJiXj0TX7tN10yX5YeI/g4o3mdAw7ro", + "d0SsDFnD5CX8PMpA7Ra+aQNbaAN0X59CHViGzCPrAw47o0DykGigccVOseza2Jc0Y2/P3p5SyZ5PqhL4", + "ndV1gm1knVdwVJAd67SZmZi18ejy0GHC8qpIcLqbOZjaWdZly00Yv70Vv3hJ9Ejd08I0LfaG6Fy1ahfv", + "f+6yst3m/n0FZtmpIBDiWsl4zidwombHlHj+RvF0CxPqyfu3jQGh1p5DHzdhPy1nxLlQWm5ZWy/nkwcX", + "1ms91Ddp1yrtMPI3VbOBr0GA1scntTquh9JjWx3TfFDeW4TxUdDHLNTzYuTDpsRrIVnwX3PriyGtkMDY", + "3UcXy7lbMUcQB3IJ4acUtbHnVEGEGhZS2++zDwbY0BoqcHTb9KBHAuaXG5U0TraR2N9gcPe2ecwUCt6S", + "x/zMX4vXg9EWi6kGlbfOgp4DViQKM03FGJ+C1dt8LkzBsZnjSGTCLvrslCfTxgAKjqGn8LOeX9UdWn86", + "pvLN7bcdD2lmDzwx//DY7HBkc3HYYlZ44mzg1t7xm8t9j9plxtc5aLwAmQC7EjPAnpNH52efVogtH++b", + "/NoO99yFfWLMexLzrY9iWr3Ik6WMqwZCg7R6sRJ6tedrkR+imGmwY5aDxkqr+9H8rPqtDlKwXGRm94S0", + "QE61i2PcWi1GhQWzgfLwSKu0N+XpQEPi1BUh88KuR+nGJfmCJQmk5FjEamg4SbDqYRhK17cMc4JKeP5w", + "/OYyjvKoLkRy2OrrmkTp8J4SxsNqD/uru5sIQahvLvfjon8FJ/2DbscCq6HYCv69qgvfuKKynmu0XoGI", + "9QWOAq+i9xi2bs4QXE4ZWDqw30uVq7eFEpTkG8XFG64n7jHt1bxxkbFzLtwz583x+ZcqL/y5vsmJDXIi", + "yZ9aPNQh8chiIUvye7Jhj9MVShNGP5QN+7omUe4j0mr6QP9vjs+rmnZiHOyMrTWeB3Fm415eZdv3pXm3", + "SjyWKm1nmSfv3zL3QYRr1tZp68YlU9At277AH7fd+CsvsKkxJ1n9fI2RMvviSsyEnPSOskzd9shLFk+0", + "Fr9DewVCroG3bIhKvDDzj4I35UE19yYPc31GjIJzR2BKs7lIQYWfWgomP63Qq2/N8TCC3hPIPVwoppzd", + "W+htlnSKb37lVy/3ZUNeFoZ/DhNeufdv4myDOFP8yR/aDVh84cY51DErdP5aTHPvyryv7Si23mTAd19c", + "pl/kF+9CF+r9PjvmWgvA8vtlre0xtasTErnWCKtVW+YrzvsORqEyft0St9wT4tNyh6Xb+sYj1vOIClhP", + "zClicNkt0+V+Ur3qtY5f7Now5B3csvVNQ1jZS718vW/oG5Jz7dTi9vOc4werR6KO7CP6e61Txisf/087", + "iPQMaWnBv3NDkEdr+/Fpu3lUOGDVo7XeoMCjmuZVYdHWpLDe3xK6pmKAUIsjruw8smRgZ1M+BzZSdkpy", + "rnTVmybuNFwuZet8YVhtevLEYCcCDNFjZzKF3GnDVJO8ntbzinFmhJxkwNwXlJdM4QepAuoFN0JZKbbu", + "cPrNTfM55MEnctVc8dH7HOQap6OE21LBsXzkHoeen7hrVTiYdBtfbCSkX10p+gPiPuI1jTP7FKlnQrQo", + "b1TbEaZK4PK1QN0WQvcroxrl+jYla3l9qZmmVVOcSqpA9HN6ZSyFq8+OlTTFDLR7h1KG2pKehu1jQsuQ", + "KVY1sVjqS1inq3G05Aue7ZTu9VhaWRPK35Sy9URo+WhAeP1Jie8eOhnuMq45Xa20+vIamaNhzCfwpIvE", + "oCRQILhc7KpkVN2AYq3LJNxmi3IpPnoSzcMKm0XMP5R4kHne474ptVJkKPHNRNWYMFXNdNY+xzKKrNVh", + "1qDIJei5SOBYczNdw6BnXPIJpFj1VCTA4E5YrEUIdzlWl8gWTmdwWgtila9pT9FtDpu4VbpXZZeU3fRZ", + "qpA1+o5cdbb5f/7X/6b402oVXNcg17WgZz6sE5/AvYmYQ6/IfUFaai+Xqm25IHXTeigfjNzmN0bYygg9", + "Mg0Suq4nZIRtcNm9tirutVlZdekYZVFVdnonLEaMIsK6FyTPUEfACuJ3ThUoM1sLmYLOsOdesEwRzemy", + "nFgy5VJChuoJ0gUlnxBBElu0C+r4nIkxJIvEaehTbsjWTTsPnl0mJGkve/j0KJNz9skFdHaCG9WQK6ya", + "GKEinDlWtnWLpftsiERb5EM2Ay6N71NNB0+FuxfS2wTGNGunEaG2xtkUeGani7LhHZZR6rOh/+8wIWe5", + "hrlQhckW5ZjGCk3mNZzwOQziGwqQKItVMceFQjGmsj4WQtlSlVarHSxfMVnVjGtDFKod555wlXkhgJVK", + "rho1AzutFYAy5dOqpCW6zk634++h0+34E0WZWh41SpydlIV8aY/hCvrsaFTlV8Xuxi3Giny1oF70mrBl", + "OMuUdEPL8lacqnKfn520xFj7C5Q86onRaqL5rNnAyx8j3KfvNImVP0Uxc+r8rLAWtPsXdUTskYutx3Mx", + "3KaMYX1PXU8V61gRCpr3avazyLI15cneCFncMdoSe//+be9GZBlWHkS5h1VTSiAIWXZ8/OVtn13WW+QP", + "D1KYH9zMzGQY3kQOzbisyAGnLlmRX9MLjRnMlF6UACVzQoiL8fZ57zZDy5WfE0szc1uyO1Pk7qJMnJc8", + "oUReue5vArldIONlDZSaDRxKPKVAjoNld3ns9rkkjpuHaK9xnihprOYiRoG/Tpu0AIlIyVYQSLHPhlJJ", + "COJikqkRz1ap5RUbzmCW1MRSMtGqyMOXCH3Ejqmwr9gwyQsDdsgOcJzSi0GuMpEsyLjw7sPbowP6Qy/V", + "Yg4Sabdiz0r6LRumMow1mHLJfugfev9YKtKyf4lvjaOLhLpNDZWa4dFeDlkmJDQFjDssJpvMEidbaJ/0", + "h2qXLd1iZ4OxBhjcjCK9ZzRAaGXrr0RI9rP4MfTuqQdLuM11WQoaEzLLgJWhm/3lu6EnNSFroPvOsLcw", + "653JsWJpMcv77MiYYgYOEi9wHSokIn6HPjsJhpqQtKQhybiYYfXzxCkgoeuFmfEs835IjHnnLHPPLoTa", + "wCrLs8HNaIi12411OOrATzdOh3Ugd0uh4semXKfURQ0rcnpoejYSkLAOO04J6Liz8oDGF9Crd4utkXt9", + "axHG5X55MCje4X0adnH0lrDoAeB4mlvYpPl4YRgUn/gc9GOLInKsZrP4bAxjTEinXhK3ezN+x5794LR8", + "bbo1WdH4rCWj0JgoSC/A4LuAGbAkbOK78mDeMwXum0sle9qYLhuLDOhfqNtOZzBz/7nfZ1dOS/UlCvLp", + "woik4n519dCheYGN8VuQqK1RVT6w3NyYGJ7mrFIyRlh0Fk/ZM2B7eEq/1EzNai1VCWMN3b2bknwXS9pS", + "A1WHV24L9MIYMu8ZOZ3ldrEOKb0BzH17zPExwC37AcN/hFOLFBupAl06JLUQ2RFZhQUqrbmrYuP2iRTO", + "785ojh/KW+Va8wUpLWIyAT3YRAD+u9pTdBtS9H3WZOo42fD4/MNL9s5p8u5/HEG8HPoE3ppsicA97HFr", + "AisRbaoMMJ5lihJwS59UrfaH37dVTMi5uiGFudKt++z92PrnDfrQuGHD+k6GbK82jSeiWnIs6H0Moki4", + "ZKkYj0HXW2XioIS26X92dzoXiRWzPnu7Df037q2tZGP97ojflSxiW5UMEWo3beyodAp6iFC82yaqQimw", + "opttD/eH8M1NlLBWBmzPdJtSdJUrbdFAj4DoIboZljXT9Tpbej2rnQzY7snmTbGE2WVCecNd1O2MeHLj", + "FFmZDvxfwkP4Vukb0O4PU64hrf4bi+NENcSw61BU/5ieEgLMsZJjMbmPnc6/RmqV+n1bVUxpxG777rkQ", + "vI6tjwSe22S6e9zb8lkW/iSr9Q2OaQVmVDaHYCVhqrCJmgFVO6h1AnvCfVAbNPKLHqRgMRWztOYFZ4tD", + "n1yruwWqBGUXtbBPo8hL8lSbpBXc9eSFZXuZmnTZLdeyS7X89nFXjgUUk6llcJdA7qNjaH9Wq+wJ93c0", + "cYqIf5pRD1bD+IQLaWy9gmGXmSKZOgEjJGkDCc8yE5zRK5Yo327O18Oq+vo+3Uk+UFZUuVQwVu5hk3fT", + "ZTewSNWtdC8i7By6j5sLBWuebmP18r8HZU2FGViecsv7FH01eUokPMeg6ZIywsXUI26oJNhS5vOb43O6", + "pFr56SfcZahbPmpWig61oGvlok2f/SQmUzZXWTGDV0yNx058pjDmRWapsllue0LS7skw93Q7DyFlv7z1", + "hvuKWlRhe2rc8w8NtH1QdQ/yT/aCnZfsvo7qP66Rki072k3a0KCQlYmm1aAJ1WUPrRDJoJHuqZDGTFBA", + "rWbQ9xPEGf6b2oP32Zlk9TJrvgexD3AhiL1kaiasD/0SxptI9jwzv50qtGzQ5PssAz4PTfXCimo89kYP", + "t5Zf3DC444n1TqiklNeo9Dgmpgug/R1dHf9UKwTXthvjI8mwbah7YBG02PCPj8N9jNdhUvVU/qq5OQ3W", + "8Vb0x6B3yeld5BC6UozulinNUmGoi2k1dC447a7LFqpgs4Jqdaa4hbs8E4mwbOgOMnQzDBH4w4YCXlpq", + "t0Ky+yBX1QwwiaCZFyZ9drkK+D57H55lQce5gUV518sXve+gFjQktF174jdgXzIsfn0LWAKbvPney48+", + "TeOzWFXWrXVU6XpbEvWzT6Z8v89+pfzaod/RsFs5Mms45MDh8MiTxkvEJrR/BtR/xbhckEdM+QhKd/Dx", + "uM/K1i7VfHteL+mGMEbqdtitizdSHIYVTySDa4QTIqKMwF0z+jKt6rOj6kgeUKESBm3Sn4QlGXBN9GXj", + "kKUDDH2jgmGFrnvUrybzXcaJMe6TI81Wczgkn4KGV5iznKlbw3hh1YxbHzfmHqToUeX1a2oyloiHxh9v", + "29CZVk3+Y7cDd0787DrTKY4Ks2xDcI0Ru5Hda6VvuUaGpMblvdRgZhWxCQva0UEKxmJJLgfApdBZLEBa", + "u92XjC7AYywrJDYPDywnW5TY4uDYRfWCzAi8vg4DmWLbHyz9rtVcGKEkpKG05y9vI/zXbToQDPHeOscP", + "/JPeR06LnnI5ieODslm+KwjfX7053x2MK6N2A6UbfoA6o7/28Py7hyiOIILAZ6RDliqUNBAjpMytXkKq", + "z9432Emf/YROAAbjsZN1e2GHli/cw8BxpjnsE/DdZxshvrVwOvYO8KC8wKl7Pe1KJdRAjEw8I2zIm7Lg", + "Wq9uAQO5vEfFeD8UxYZQeftVQMzAGK/Cr9ps4mEn5WoDmnrGc0PdhjD64GAsMiB55P1nB454pbvBg1wr", + "9/NBKkye8QVzIuJVmVHgJ8TKvE7Z8IH2Dt+5Fb5wUb2raHMnaLapzxS1gMQ7Mr7PvZyt7nK5B2O/EQOi", + "8kG4f6oHp239D77hKV6Au2rHi/0luP/w5w8fimI2GGd8Ygg+7oo2e4TDmQMIY0aqY/eCfKsKA7508I4R", + "qaPC2lhpFJyS0a9k5CXxjrK4dk8ZjG2n29FOnXFbFWmaBZsWOc4dPUfhhI/flhKKV96aht/4x39tVfdY", + "7nQ7GKODn0QXmKosHdzAwsSOl1Lcq/vZnc99W+8zR7PW3AirQbBLLgFZzAb0nqflkC11Xj5bpvR3mOWI", + "pkIxA09YOXiLZlh31UZ6t3qK/2SJUk608qoqAN1YrihsMzpTpHjpf91npiV0veu4qVuQNB8prlNfMmFH", + "HI3XgTz2IjYJk1MRSJ/vsznK100a3Sz1FNRHlVXoHoZ73yBce9x1UIY7SAqLnpCca1+GHFm9V1SpPw3p", + "EvT89Cz+Wlaz5JQjT17E1Y7tNNpdAr7l3Ad+bM41n4EFbfrX8tS/OJUsf6eRjeqoaNMOOjpKybQl5ghJ", + "eeZ4xiZFZpVhfex2Us0n2w0/0XyyPHqm5rDd6LdqDsujMVLAsYlNg8/dhz/DojaWrHWbBl7iV/VhYAdJ", + "oY3a+Aa4BHuMH9ZHZwAb9cVL95FH4Vp00mpsXPBbrGBYQw7X4Nu4b5o59ACprrK8mgZsGycPB4lx7mrS", + "Dcd0cuIK7mx5PctUHi9q3u0ca+AWTrCuvdKL+wnPmUphjaaRhtmZ+5DtqQSjQvCUXYbRk//6ww/7fXZC", + "wgJlwb/+8AMqcdy691DnZef//dth719/++P77ouP/xRPj7XTSJrByKjMcZtqE+5DtEzg0ZcWOej/82Zn", + "qFspdpknkIGFc26n97vHDUcIG09xmcff+AUkKPsm99t9zPF5tpLGo8MitZOwoyyfclnMQIuEKc2mi3wK", + "chn+vPf7Ue+vh70/9377l3/arrLLCamfW77ylsrBoW2qXeAG1Z6+qwrbtNTwwf66A80tbJ7Sf800dvOV", + "7Kff2d6ML5z4kUWWMTFGC00KFhIMC9mPLnor0hhCLa+Gn63df/RqlyXQ0yjcjm22KNulkk1adzSqF9zj", + "o66HHi6rKifuk5X6hiOwtwAybMQp2j4Wn2vrsdfxf8YzVaZAWyxaMRNSzNxGD2MwWdvw1ie/YUAdC1+u", + "7C24TR1paaAbcnuZlcH0ZqaUnf47WczRZovG3WC0cxq3O8OIG//UxwWRv2QgJ/4c/I7O8ezw8PCwdq4f", + "ogd7yCvDHWGnR0acU77XWGmJZcKgWvm3uy5b/FZX6XMutClhF+rN305FRpuYYPTWW6fqed2Rccsy4May", + "59QSG4085U6Xt1wPjSwDp57j5VX/sXyatT8SLBs47OAa8a2yaTHjspeJG2A/wu8Cq9TqOVTYjBC+5Qs6", + "CBPSWODY1SATErh3zuYq82bHXzHSyK2GRgIzyEEPDEwQ04gcIB8gkQ1mBq3bYiJVs9pVLfa88XnjSD/s", + "SJdl+R3c1woEz2gXq9SwkT5Xztl8xR62P2PLLSFu0b6wFKq/Lx+0imyifYPsLW2PPWvs9dnmcJ424V6a", + "4bY1iC1NvM7sckpvufOML26RC28rDOLtnmqvw2pKTHeLRNqnLfYS6v9w8B98zumflC9XzU3PTPzjlBvG", + "sS2/+/27nE/guy77zufIf0evy++8o+I7NudaOHHrn46zPIOX7LrDb7mw6P/pT5RVe99Nrc3Ny4MDoG/6", + "iZp9t/+KabCFlqz2OWb37u2/uu7EgvCoLBuV50gaePinFTx8S9zanxGfML5lesjfCOo1E4b96bDB4b9v", + "8PfNuIaXvyU+GNzwjugQ+pMtYUF1ulVDe8DypcwW7MbpUdjpTdX9+Eao8b4mftOr70SKzydIVhGBuLk9", + "SkTfJzaSgo7s5zKEs1Kb0DKSsX6wiCU3VbFyxOVkPnRpy9kKRPh10QFQv21ImR+Cbaji3oBG+ppfIIYg", + "r0UGZ3KsVvmRMINU6PW7QvmFjvvyOdfSt061lvl0onyGCokP6g3V18rkppRb6PkqwKuZJ1G+445Fr9uR", + "sD5HvcuuO6m+vdM993/XHfewue709G1P99z/XXfiEaTxONUfuYFGGuJYhDCE1ZvY+lUcdNZVJBG/w2C0", + "sBDBk0sfgIo/931F0bANAWaL2NMQR8xRr68t1g14UIOhv/Q2dKIg45a0x9elj4aR57Gtbeo26MfRpwbp", + "9nh4X1iWS90XqLthSdws5rMCFznUbWDHF6dHV6edbufXizP835PTN6f4j4vTd0dvT7fI8KPkvlaFBXs9", + "rXje4/A9Ee6/QvZqIX0V+7LwT+lU9RF1oduI59s/UwQ9BkVWCSi8TGHjGbP8Tkk1W7zE9FYqI+G9o9Xs", + "xmrgM58wMEy55RS0ofQMNQslS1ijDuG2MoJM3bI9snDTlsj07WOThu33MOwyDROuU3TzY0CAYnkxygRm", + "JgvbZ8c8y0D3qj/6C8AQpfeXV+yg3P2B/ynk1ZZJjMH9LAzd7CtmANhwaS/lexQ7f5opz6HPfuGZSMum", + "AgluJmSn1KNXhSkvOKT+JL5k0XcmtLcKHlHUkdIK4iTwZzzPHZo5HSMXA7fWhuiBo1y46yGU6oZ47AFG", + "Sw+C8F87gw+wvnQjSFspJ0vzgQ9Y2jRHmh/Th/Wx7njbDj8pvy1noKikgdeG1k9A36KGtDw+U5PtRr9R", + "kzC2FvlEDsANM5xV36MzJDYPuiO2neVnWMTmIAt8WZds6+nIXdGotdftZGIOg7mA2y2B/EbM4RcBt0uQ", + "rqbZGt5hplWg+8Cu2lQbj/mWhpzURizPJqSwA68jbzXZmRS21u2/NpUGv8pO812EURsm3Xm+1bnqwdPb", + "THVZfh9mqhcz3K5x6lmawfJoxx2FnGx3TX6eNzSmeUnLvcd37uvemMN3LN29H2yn29oJ7p4998KMS32h", + "tm5+1KTm1TY/u3dRKqdJ8h16apSjFE93KV4extUK8O5c3Hh1jh3usaUKaXelBN2u1f1q6V6heNPOhbE6", + "3ZV6E7uW8vCp2O5lsHiH2jspqB+7HSVh+9SEZfn4sbvLsJpQ3nJgjIZ3HVqn3N3GRpjQbhNU3HDLcTG8", + "3mFonLnsMEFFkTsMWsL4XZZb5jq7jA08Z/f16iR+L8DcZ4a4Yrj74FIf3H1oRPfbcpIWDWG30at62W7j", + "V1Sdew6/Bz23KINbjm68zLZlmUvvqO2HLavSW46M6vQ7jr3n0m3vzi2HR8XdfatQUseJN8JYNLJFDFJa", + "84V7/q+at4QkayslHdhgNdyqWEVpQo74hUtxG6k3mqnJcv2AWnP1tRHjy52iJqVHwcKdbe3s09KB5ErM", + "fH+8ckfUP5By5Le1Rbe46epLx6xrGGBx7qNZL0rdftkcv22YbQhiu394bdsMW4fVrkQz7haJ8ogRGRje", + "98BYjFQYy2UCDQfdD08dgeH2vFMExsPDErwVvYpBcP/k0i7dYtywvgk9qxCPgGHMqnuh6bYz7YSu948R", + "TMHYwaZYx1pKV/DwbAoV7HaMTjZNTEX4tp5z2S8YFujWThG7ofc3db60g+P4L1TMnr3/OZiOYZWvq5uN", + "WHtGzS3ABM9nf7PXU91Ez3LObTL1YYj3g3hbHOJJe/xhySievzjcPRrxpDUKsc/OxiHZr8sK47P8pmIy", + "BWOrir80JHBFDYg+Xsh6P9KfDrvfH3af/9B9dvhbfIt4td6gtgleYx+lpGHseAclaYnfgVhwWVHEKSFl", + "AOqBBjymMIyy4uKcxmd7VTlPq0Gu1epUljZkwvnCtdX5gw/SKgbSFFSLmKc8p5hnCbehamAVqoE4gXc5", + "BZ6Oi6xLucvhL1kLeraGf560hn2WaPP988PtgkCXcwHuJ3k3BGgGqRvEFlUzWRiKylxuflhDUQfuwy59", + "yzUwi6XTNseArRGkZVD7bJNEvYEFVV9kxl2Ol+jbC9j4+m98aKOb3SxmI0UFXnChPjvlyZS5JUIrjxEw", + "XvuWmSKvKgXepcoqlV3LPQPA/vPZMzzLYsZSGGNZfSXNfp/5QCdTVrC87lxg+Mt1p8uuO2iToH8eW53R", + "v44y/6fXP1x3+tcU3kgRcMJQfGaCG+SZUW6XiZqNvMgyPieA5vsXGyIn8L9wtX+54iOcdocLXeLWeLtR", + "fk31uU7vIHm0WDbujjfDeMmFdHxEYgnxVdHE9aQZFvm3SLUimonrSVH2ON0eq7gZaKWaQY3xYxTNmtxY", + "e8ANZbkWc5HBBFrYDjeDwqf1r58ytAJ0X7upZJGh9Ag8fjVTks4eiVTAiw6FOcwUsqy8cicLinhHteQ2", + "lpitNBYOrx6re7weWbHvZ/S+alqEWuQuH2CzzgVy3o5ef8Ti2T3M/vi4DLBTORdaSXx4lHGKWBHatzKK", + "V5+rMH8l1nC38MJ2ALZHERI4N5Lhg0IIeZ3oSoCV51glwrXvwdPy/G2PwXhlP7gTdhCPWT0PtQ1Da4eW", + "QvUYUTgY/elFPKCoVo6JPmWjYjxu6ZlHEYXbTqYK2z7Zx3bo/SyqdL/dwHdJjS0Qe2VZBKGGvU2QUc2Y", + "BlPrXJ1evO2sn7ce1uQ///nszZtOt3P27qrT7fz04XxzNJNfew0SX6Aqel9pQtVn2fnVf/VGPLlplhFe", + "jonOTLwXZdnZJlFZMaPGjuvifbsdrW43zeU+2TFIHWft0kbX3Nhlzm9l/cK2KgoWEd2r3YF9NVcYWLvY", + "LAWP/NeMs9xAkapeefq986v/2l9mrKTZoyAqQ1DmQBKpRVzGgRYaNy0DzldtqR0Cw6aWUxt2AOnKSu6z", + "+y/zMdqXuAnXe/Dzs5rBmI8cQ+LMuNnW0UO0Fuv7yxJYbT1BQrXb2PBLLJrYK7u3RnqH1fZT2nGLQqRx", + "Roytlgfcxu3E1I9hpUOKH7aDqbiV1Cy3hdm1Pl2tLFphSMq2c6W8GORJrFGpsWKGcZvH5x9Ygfb0HHQC", + "0vJJrCH2WjFadUYSzWq+U258b7FtdBQqad8S+VztOBQID/XJafdlUHSLBI+aW84rmNpGpG3VdYe2H5dF", + "7YBNhbyf0DnhljtOdqsFGUCXUI+SDoTMi0ggdcot30qxSOurbG6KU87728YzP0hfdNvxCZ7GTbd6QveF", + "BdmGJFVGGH7A/Of9zrYmFX8UDbyKat9Fd7o8LevAa8g1GMehak3AfLaI0isFRx8KzdKxViGLO0VUBYW4", + "n+5Nc0sr4eeOFKKpvluxhpKR0uTCsGsceN1pI1m3/4gUIEO4D/tWtdY8ybSQN80KSpi8U6YEbUnEFLeN", + "8H+YHWKk0gW1sqUpQ0VMugDpqXs5lH199/1YnkBZjpSVNjK0U6RzYZRevPT1JW+kug2r+0ovoedc2RR9", + "qVooL+xUaWExuzKjItGUZmpqJT/77Izq32F7R+NLahWSFkwKYx1uLnIwXYcGZHvFClzEY5qtaULZ6ar6", + "cDeUKa/XSq7qPzcqapcFbRt1ectI8yrydG0rqraynXR5nsT7D+47tSH3Y3379W3rjFBtCdDx3K+xkJik", + "sI0aVBWQCKPalKCN9iTS71b/bMpKGLXfG2nMWytt1W79oHtudumeUZms7zN251UM0gVMtqnhtJ3f6Sdf", + "szXU85h4I8ia6hctnohf0QOxy0RbRiXQXN+551jey2DsuL+W8KA4hR3mjLqCwy10w8VuAtl9PCq6BPSG", + "QkxNxIiKoGa5pl291Jnlg7v1jp2flBa/K4nFgHAtxmeqkLbPKDzFPZzx74ZhCnCXSZjwxt8dHOKSm3aw", + "ofbHL27HyRbrp+pWRpYv8vjiD4nEKAtGbW/U30QV3PoSmVVVq+ZSuxPFzlNuHR6xUuprR64l0hTkhuRm", + "CuOofGR+0EYfv/+uZduvRQbnoGcCu/yb++0fO/nFDW/U5I/yRjX7S8N6sWuCcqQG159evNjfreSWupUx", + "P4/bK/6Enp2w3w8t+90mmZXyKvPqbsmdS55DX1D4nuWw1iQX12vH7dgthhcG6qUGqIJ/Domj/bT0Hezo", + "fKh7wrFoXMz3UC/q0AgaO9xIlPXFoxfiVJjX5lduk0etcFaWn0NzAFaCjJdlcIQr5rDZbltSu5+PlWOz", + "xRaxPK2RSXgDD6yTNtZ8BvHIm4tKtw0fORCPc0exc9BapGDCW8nfwH4d5s8PNxmBoybR8GCLGDNrCiwg", + "7T1StTbcdEDoM3lJCNzueKz2UXe8hQDM9bez9kJm/A6rCIjf4Uy+/bF9BxjFHJpvvf1xS4gsF8961hKQ", + "5U53VKRCbUbuY99SgbvPqQAZtmqeixRUn10QIpv6u9rpGXwO7uFPo3wkn3tKnxeZgSP/1+QGbL3YODan", + "w/R4ZsAaNlJ2Wis3vu9rRFGQUhNfhKEd9dyLvL9lEfFLq/KH0pfSCbh5Nt/k2WwGqeAWsgV2WccoB1VY", + "NtE8gXGRMTMtrFP+fHGAGYbFoalQSIzr0LrApg14VMSRuJtnl+qIBDC3oScsjVhl8cs5ZCrfNdbyCivQ", + "0VBWukMsdrKtlYthSxUIIiXygyFwbYHTZh0ILB77j1Zbem+mpLJKiqQMvmLkRKh2yhOtDBFJJsZQ7yHq", + "G2OxD8Z34n3Dje3hyr2zEx9dWPgg/svL02AH9OZPYahSHFmUVnpm7+AudWcMltLf1sKwLelhqQAGlb66", + "FRp6Gcwh87YkLNqAhbDyWnEMD7mqRwAGToTQOrl0+j470iNhNdehjoVXL6mbki+KUZWAcAwspcn67PVK", + "27x1lTq6sRIbuGPQPbRZEdqwVCUYJAVlB+ehN4L9s69dcbD0lxOctxYA12WrBTo2tZtfax79oo2MFQj/", + "4/L9u9LGGINPJoy/1/WFSqhuE7kjluHVrNkdgwQB0l3407XXvwQbsMyLy9JN0Npt3zpe7zvUlh33t2+4", + "j931G/32G632G5WQ631UkEvh7nyI645d+Z/WyFvC/jJ4Ou/hU25rYrQaLJnnmWixwv7Ks6yXZCq5oSur", + "zBW1y2y2v3Lw9VNSno4N5RkbnVnqnZG2d8B3fQuPnXsdlR2O7inuvETLuLErkrjqTa/BgA0SsXkt9Lw2", + "/bWS7HCLWD88CJ0jijtLFcx3tjc+rM7vDSyM1eoGTLQ2ZzT6JV4/9F55USFgs9pHyAur5Uc5TnSHjcYz", + "vuhfywaT0AWwvdBhehYy4g7SUKV5v88uqY9emVBwLX0EuGMBbi3UdbhkKrwHa+s1bort4d/+/dDdi0/b", + "2u9fy1q9WGxC4W5tkZOUuFU6xVbqKflIfUhxeXIhreY99xUtaK6l0xskpzJcKBDp55wXxsHpClvKub0R", + "h3Z7WQO6aCOjbktXDYeKeK/YFoCEwVRh2Do1tGgpo6YGjmASWI+L2E14yp2Ad7r+IldMyL/7dnvu1f+K", + "zYSx/AZIUUI5iToI3tmIJzcm5wlUSMAO++y9zBaehZnYDbA9IzKQNls07ulaVp8hbuzTVZVP2MP+syjW", + "h7CcbTuK/KqFhbIHyv0IfT20GgEroexfWPC+rVA+Yn9ccltivdbOy47XRs+wmS47Oj/rdDtz0Ia2c9h/", + "1j9EA2kOkuei87Lzff+w/70veocHOQj5RAfUD4mMY0nEOvYW9AQwNwi/JBSAO2EwqENJMF1W5E74sKVJ", + "IxlJc+GeZzlo9MqnXSIyLEhbSCsy6sccvj6B+ZVSmWHXHVT3pJCT6w7mLWdCYgMrNUKdKWUjGCsdKqOi", + "vcinziEylR0ez1K0j9pkGlZ57ftB+VpFP6p0QcGsVY+cKk374O+GrLEkMSOu5HCbS9pFOBLdoVVshtfq", + "K3X+7brT690IZW4obaXX8909e5O8uO78tn//TBPaUBytqu8cfVKyGWYt4jrPDw8jhnzcP8E7xZdVeTQP", + "7OV6rR+7nRc0U0zzKFc8+JEHmqSK0R+7nR+2GYdlMyTP/CisMDubcfcU6nwgvCy3mPFCJlMPBLd5v2cc", + "VmFv2U1sE1UUBnQvdOSplgEsY66FAUad2VhlqytDXka8/LnvsKp7LTeSC9udWq7lruRyDBorz4dbCJ2I", + "3SPlxj+D5VjzUKTSYzE7DY3XLn07wu61xLbqPSxNDmk5I52jnD+gIRp9j0/OD0J2OvYw1cBGTpOG9Fqi", + "hSPc5UbKPq+awt2XuOOiIaZRbQP8Pvs55AL6nySfgbmWez7jzEvTY6VuBBh/j9cd6uSKpZ+962lazkB/", + "7V/LSwAWCn9TV7xqJ/2JUpMMSsQ+IJdQmS8b/u6DkCjjzp3/R25EclTY6fs56J+szU9DQ0m6g+iG0bTk", + "PjYf8onmKZhylBeqb/ndcWlJMOegzx2edF5+/7zbOVd5kZujLFO3kL5W+oPODDo/V4uad377+Fh8LeDK", + "V8valtHOnaWdwxV5pnjaq3ol9rhMe+Fbx/aUiSg6H3AYlZPVbOY4SDkF+13kjOtkKuaOwuHOYqNCO4UZ", + "K2QKmh1M1QwOiIVUvSrNwXVxePh94kgB/wXda+neg9rxuFl9BeLbQt5D0Sg557X8hIoG3VfJGM2RTC/8", + "Ha/jSbMisyLHHp9Kz3rBVtamc9Q6XrYm7FbfOOWDwE8BkokVc24b1Tea08eLSL9WmYMputetYnnGE/DF", + "3wO4doP6kkvhqPdX3vv9sPfn/qD32x/Pus9/+CEeBfC7yAfYyHNli3+tEDK0U/HRp4XMKZepIp9y13vY", + "aS8kG8+4FGMwFkX0ft0KMRLSUeImrb7cnq/GHXuZrFXgatC9nxb3LBaRXGIDoQKk3Qi3I6opiQOjVXn6", + "ufneCgsqoVlD8j1uHEMy+3UmWB7Rc0P/lj4YBR0vzvVOQx61ZGqpxc9Sf0lDbjnffPLo/AxLT/fZkf8V", + "JT+FKzl1hqxlVvgu5iIDDMcKIdJ3SVYYh7xO/ekyo5hUTGFgASY/VH3rDUu4JBsFdr/G/iAh+sNYlZtg", + "RBgLbazv/hBaV4aLZ6KsO0LWytCSktryXstQoLww6JzEnsFTT1UpUAaXexdWdkBMzqGCOm61G1hQj1B/", + "XdcyeDxzvnCzeEcE06qQac9qkTOnOsqEYsgBCwzIVMxFWvDMTxPjvD+iItjsIXp/NXCtzXR1paoN4v2U", + "EZyypf3F56S9khCoX2qUAOo4vURmS+1JA7E1AVc1Jn0ieEU6n94TTNQrLvR1DWT9WSF0KWZFRgmjRHX1", + "zs1xQ+IKjMhcdeBYfTuYLoCnxzXTVuy2HgtczabFCK2lt1fZe9gviXJqhW4efLvu0GRZLjONVqx8bdeJ", + "tsH2+2waJ58I9eMW0PuiP1o9fXYZNjQtofDFMKxfySAbjOlbwKtsBxwHUxkd/EQQWm00vDVwHmX9Wumz", + "GJ1R4PJchJYY5Wv5i4H4TyL1RVjUbb2+YxPMzUbXca0Pa0uh1oIh8oGhUkfObumkcpobD1UV3bLaklcI", + "Qw/kcpfOiZiHRoikmGbADaBuVe8vtaGFZEzjKRuiPhFqrrb8viffcBN9IeISt1JVziQwcYTDEsZMwBLC", + "DMpO/K1M4i9gG1VOn1I8xsupxmkXow7opOUhHuMW/wK2EdjgNQ9iFmGlbZSPZgf5+OWW1VafCM1Xe9M/", + "SDv0t+BO9nlR/W0oItqATpCKZWpAxWnMNhBrdO1fw0dDOHC5DrrxkWfW/P1lXgLZyasEmVq5uWsZKyJH", + "IWJY6CzXMAVJ7+bVanVdZgCupdtMvOIc47Yyo0+E7Y81QArmxqq8r/Tk4M79v1wrqw7unj2jf+QZF/KA", + "Jkth3J8SP/fhXFMllTb1wA8f/RjO617UPuo+8VeB+RXGm9AICiqNejx8CcQnIoflCov3pQYEKGLLl6Qt", + "kIyv25IQL7dA/HrLnjZWdcVv4LIeGvkkGuNKyuZHD6O1EgcDWQ9ySjGuVtps3VwRLNUGKDr2swK0zE1g", + "FYBCENoGcKosa2dilIzK5j5hk6oAHChH2yGJ1P3N1nS8GidtaosNO1+jjqdXAxvZoL6ttWSZmmCuqBXJ", + "jWF7UlmfqUwmzhoGsRFM+Vw4lOYLNud68YrZAq10vot/regAxkxhWkV1FHI3huRUTGX1tkvv6u42iib4", + "kB/09DRMmnvlHKgKVwvsU9wHWpEoWCjEggdWOAyxYWTA6PU05MAte8d6PQq6OmTkQSCFnHwIwxiHvAw5", + "oU9EfrUs5ftyR49eX4gNiTZT6QoEHm6dZryDNheCfluYow+4fCK4LMdzPsjIQUGEX4zUcmcjo8Y6KPgY", + "4XaeVtUSDu5G5v4fhSEvlsOTkWuVLiJjuVPQrMpzTMZIgO1RQEL3WnqfbOWN6TrGgflr3h3Xrel8vhy0", + "Eb8LOdn3r+ZyIVEWG2NwxxObLa4lLtfwTGngqZBOlrvXs3uPYxR1WGNIJbQLnQ1xPc92OBuBsT0Yj5W2", + "17LqR1YWzg6zBi+FmxkVNfew4RNglJ7wo+ONDgihiame8QxDTa26lsOgTg59AwYuF3jTbKEKlioMgZbg", + "dnxkWQbcKa0yGJYpPsN9jX7JETBfUql/LS9C4EwTVtT7XxeyrHiMbquXtfibOmw8BLrkXu+iciyXIdaP", + "ggSL3RA4SPSBTCkwtkzaoZj1a2k1lyaoty+ZGDOOrh1dhf+4faOzyW2Q68yJxYroGCYZAjYmDplwMy6k", + "wwdcmwKBE/C46v4klew9v7vz/q5cq5xPnEDuX8tzDWNUrd31ODFmIOeY8Tqsogv+eUjJQwf+joboz/PR", + "rUQ2GQTvYs9qMZmA05OuJcGAKElIhKdPYK3C92PCKtzycUm/jxgoQGFBg3p421J8x9Xr3r/53Jtm7BKb", + "8Zz9n//1vxnGeBuYcWlFgkWUz4+ujn9iq9Fz8ZrH/qtBS6BkbQfk42bDP64piPG687IeJ/nbx+GWG8LR", + "0d14sG6zjZljGqiZxN9Jq30WhmwPS64cUMGVA7BJPySsUr3xEFC9ikAUUm66wT+Lab9lgsgyNxYVK26E", + "LTUotUmk0ZJoa+JITuthPgatkGH3iZNYSYGVSaop+hgZQseoMgPWxh3t9zcHoTw4ROTp4zcwZtwNGXje", + "uXqbluv+78bGolMw7QsMXu+wETuDwaY+jdEzZ88KTJ95dhbir3zJCiyY7htcVYGDfrD7f+ag1jgfNXgD", + "mRu/h+52CrVjQx/md0CroGN/uE8JqkN3b/mgIokhSQVkkQRuH88QDmunvIyvMU7e4Qe3muc5rDTy3wgu", + "Xw7LCfcIGV+8Kb0/XryDF+4VF14rvktbUJdlICdkn0840Zplzw9f/BvVWexWpOcAmGCwL4VRII/wAKBd", + "jDJoqYvdvMs1SluVYBVuEL0H1VjK4dYiJ2flEk6WWLHnZGRZWchnEmFtfLgjityYzP1FuagampDnl68q", + "dbPEAjdzBsu+q/5DFPsXh3/ePM5tMBPJynPgcZzly9pDeD603hOgwuX+F3l5GdOdsnzK8YrrL48j1Gfo", + "2Z6WCg0+5X12blMTzbPCrNx9qPh1UJO+ZZR9JJzbS9WnMnBGGiR9Yoz2q4dky1VgffBe1vBWalzyZ8PY", + "B8cutxzHocbYHCQauIVB2QcD0aSIRQzhh2URn6cKG2qushOqPFtXc4jO+QWZF+ikjGPOV3X9AS4pOLa5", + "BVxO8MOnhgutUm9od2+/dAkSOmL6MMp6sXncO2Vfq0Kmj+jQxp0z3g63oAevAdlrUne/bGhhRbn/AYBC", + "eJQwUrfSacyOuga/CywhNAEbq9RlCy0N4+yvZ+esfAvU3hDhaVAWlamqvwXU6K/GkPj1T4T+q8gxIl/z", + "GVjQBttftDV8LCkHdVCrSl3fqQbhUPi6c+P+UQCyA3rThTp4TRzo1o0Ym+rq/baTcPb3+iCnl7v1cMay", + "dhIiVv2Cv0a89MCqsxD3GiBECw/aOL4am26BsOHtu2e5rj2AZ8E5jHqom2t/LV5fyzWIzf5qbMrUeAza", + "MCMmUoxFwjH1fMwNPf9oQa+/XssU6n9y/+aaXoC/i9wbXHgyFTDHdrlgl2dBMopHZtWoyt3R10JW3T9W", + "m7+Vx8UIhj77SUymoOm/yh7SzMx4ltXNEaPCMstvgGVKTkD3r2WPIGHsS/bfDto0BXvWZT7x3wEWUrb3", + "398fHvZ+ODxkb388MPtuoC9s0Bz4fZeNeMZl4lQpN/IAIcD2/vvZD7WxBLjm0H/tBniGIT8c9v6tMWhl", + "m8+6+NdyxPPD3otyRAtEatgywGk6dXBUraPCv6pKTf6qOt3ab7Rl/IeJtSTYlSt66n0QW7xasmv9/4Q1", + "LpnzSvaIBpdQu8GzxSZrKJvJb8sTkBP4a13pa/+lSNjddMKqof4qQqGWV+vW/xWizV/A1k9Qto9agV6J", + "NpkwFvV004o3b4TBes/mnsLk68SU6tQRVKmebxnVJvkKcQWzdRHylEi4ihvYKL/t+RZauz9haOxjPN0w", + "FLUyd3yFcMITYDNv9HKtI2YNPC0f3VFavgCe+if3dqSMiwWV0M3/pVCzSizYXtW06EG6BLL+aB7XV4Ys", + "mDXWcNeVyGGAGP2gVlu+lbpXS/w/XRJSSy+Be1fXqJXO9ylDXyEgL8GuEnq9LcABth0wU5GXECYPaHsQ", + "FtY5MTVHqc8dV7qKLyGB4EP1NcyU5wGUy9ZvqToR1INHix4pNZIWF30Kxg42tFNw3/g+6yUH81XTvEK7", + "TSOFbue+3nzvya+2unM5BrqFR6vEgFAqizB87awuUpxh7PW1OjkE0+baIjMcDS8Ug4Yds6mejLCmsm2u", + "pK8s41cbcZB189FIY1fUT+sdJ2qVcqoYCbUdHTxSZMs6ergnYv9V5BVa1wD4PwbJeb3g0RKKruC7N65s", + "QPhdTaNtdHEtNxPGZhNpwyJ6LZdMou3ljryN89GIqzWK6moKy6aXUoRsETf02Yg2HuXTVqz13faBPr6N", + "l98bFjPC8r4OnXo9/KZXjdvv71ZDOcDhSdjFkb/D/+EsYxldW9jG7XJBoqWXQK0R0lO9ASK9lraH7T2L", + "p+Kxo23PP0jxjwJiDYIqqrz117FVvNpyvXabTNlj1/j7TMhGh6kbqX2hJjmpaWJ4Wwd/hCv/6MuYAxUp", + "WcY3lVfotmSkQMODtzR4u0MJx3W2h82mhhexwvoEKAp2/soBdYktf0JceczatwykA8qRazUlUdfu1+aU", + "PvuEsFo2C1m4s7TbqD1okz/gEp+2vtlOJOe0anqjxrW3sM8hxCanPMVT/9H5z97l5WnPlw/qXUVbUbyF", + "VHBfbX2MXWWw9YZPSdxbZmL7Dc9d8NKtsLqIU+7j14im1F1o+ZZ9yRNiuyXGusf8+iAjLMqzjcHzpKZ8", + "8RXj5yf0e7+vGhKENpatHSwbvVP+9OJF2zax7WPLttb2vSTi20biP9Ace09rRlkS6msXo2iWcpIzxENW", + "oVqZmpiD6mLjLjo1MUQ6LXx4CSF8d6F1mBsYjUfxqr5ttKt/fJmxyjJ1G488aLT+rvXJWwYzJniUaXti", + "HNr5CcP81tYQZrtU2WWd2tnjq1UfDHJqU9P5bBLtjZpsKcocYn3R0ismGdymKYfy8vKUCCTP+OJWU9ob", + "FY3corxq2fzrvBzNEsds0Rc61mCmtaa2CJo7y/iEC2noJR6yEHQhsYSzVJJlKuHZVBn78s/Pnz+n7FSc", + "dcoN9pwzyKq/y/kEvuuy7/y831FCz3d+yu/KTjGhSoPvw+hjMXDGanNYKtcWWlat3wJ6xQwn/gqqcx+T", + "dHiKl93KWp8p6yGyD3eh8WSV8nK/xHKo1RGw7MAl7pwwIoKcnkCIJyF1tD/0fYMtt9CT1fcpV/hMeNDY", + "QRsGVNWMtf/miyiDm6jZzHEJs5DJVCupChOq3gYAm5zfyo0QvsSvnhTEuMTnhbHfQhuQ8efPXPxkFbZ8", + "DXD/8P/At/mNaFYQigL6Z4GlaDa/y6uZ16qEpSZfFCJ9yGPhXgB1p/kiK5W+//mrjC9wrERM3EvTKhbU", + "1naMo8IAG3Hugj77H4N1dJ5vePd4AUpYX4Kz86v/6o2olcJm5DOW26LdFBlYPn31qXHvieUYHSomwvwv", + "X2WUsgcAM+F47aBPxRY6DX71P4br4HE+s/5EW2jTn35cYOsOMr99tRa3SvIxwrO1eKgKu8kQV12eKuxa", + "i9xn4kcPsCyVZ3PDtrQxhdtVhc0L6qqfiTEkiySDbw6Up3Og1LBaFXbJYKYhwXKhk4PKCRvnrpQ5fBG+", + "f9JE7XKVzbVll9M9/cDPl6L9mWpblInduYa5wDcjI+BCyuYiBVXzI9Sg7pPLWrlYyD6rA36t96x0WvnV", + "db3JPlUh8038G9Vci1Cr23sFyuFtjixkenE3Fu/9ftT762Hvz73f/uWf7sUa8cIOZvmLB6cTVBjpYx4b", + "DK78tfdaSGxS3zuKNXoWMzCWz3LH5Kg5P1p2q6lpcJ/9peCaSwsULzcCdvH6+Pvvv/9zf70HpLGVS4pH", + "uddOfCzLfTfitvL88Pk6wsbiciLLmMBikRMNxnRZjv0smNULsn1SjcfmdV+A1Yve0dj9sFoKt5hMKFcU", + "22pgB0ghWdUwP3Rf1AsiguoQZSzbs0gs28evOOGUSvEapEVqoL4FR8kESY/W/MELT9jmof0pynyAdQIl", + "rEaZnitB9iv0GhpX6nKXj5Zgx7OsPm3z2lY6oEZC755a+DYXWSt7n60jUc8EvsIKUXgDZRX3iq/12Xsq", + "OVvndTlodnaCLRCxtvlEGItdGrFkteMg/VUoq3wdkFX+9DCurXF/9cqHwn3eguFW5U3xQ9dtEp6BVb+D", + "Vge+n/3aNiH0VnAT/fKWiha6GbDwh2Julq4DLtdphs+XMfvp6uqcWc3HY5EwJZmwfXbMsyzUCjk6P6MS", + "2cK4KW+dtLrlN8CEZSNIeGGAfZDiRvOxpV9D5/HEN3a6Ad+kZBGKGISck1/eRkt90DEv3cmv1F9Bq842", + "YY34fc+qnjsl83eVPgpwzlKY5cqS2PAz471CuNXaFfVXAQdyPdwuwFilwfiymTR1eZSyE0G1RtfxX3WL", + "KgTeZnMzpDWgRiPSDAigNLZUc355y6TypUSwcrbxus0UspRxB7aol10+HDYgnwg0NPEmyFjIYOZ0n42F", + "duoNmcpRzVJ7fRY+fnH4golx7Tuq2l0VSY22nvkL2KtyP09o/SoXubTcRs3uV/ED3ld3W+1u1T5/Wbly", + "iZ1x7ZtgUL4rAaQVECjVEm5hQpV44c5dlnCIYbB+RL2OChupdIHVZCmoO30VXnL1KTRYTuOELjHBUId+", + "sxPome/rz2AO9a07fPULUk4M0cZLhl3+WZIB1yYUbaqdNtbFyN1iE5meoFMvBWCUy9QLbn46W+69sfkr", + "zpz2BT/XkVER67oDdgPdBCx+fvisicW3nNC4ZoWpMPqVD85y4w7dOGHdAIfoGSQhgEvltifkS8Yr0T/l", + "1mO5m71ObXt8qQQuJetJZTG43xGxUxx0AV2mdKCkQDxB4u+3Es0rEgTu/0qp4QXibkz7vLCfj86+eLra", + "NX/paTZk4PMGOF2uE3kNNaSWkBJXD8/k37FfB5fkC2Ai5KZWC5Brossm3Df1w6TKBAuSL2+jTvKHRGP4", + "tTFiIiFlIOeQqRwqZdEvaxhPg7nz+eGLyO9jkdGzcU+qsHwoce2TzfDb70xFuMJUtIuE/eLw0Gltc56J", + "lJfd81uafZwXo0yYSu6RA+eJvJi0Fi7xmbyY1Tk9kKKRfgiOnHbrWHUJ0YTr0KWggjf1G0ugT9Qb0d9p", + "Qp4kkCN6FbaC9Hpce0USJGzlAbXhm00HacItSGKZ2FYcncsWf5DUPHgOrOnzq2Ymgu2zU55M2VjzGQVC", + "Y/kNpWdsKNKX7A8D//h4fS1TbvlL9kcAQc/B2/39+loOnbSku/e9CMoWcQkY05spqaySIkEHYw7aoOkt", + "0cqYJXbnUxNfMc7ecGN7CLHe2QnZALBbkpfibqCsJDRSGT7QNZhiFp79dOw+O9Eqp01RUBUBfMJzExTq", + "oUiH1KMEOxJ5GwaIOaT0mzBUxcJOuWTPGJ8CT0PId+b2agAkftoNvs5b0I5RCMxbLvvEj4rxGHSfHWcC", + "v/K9Ta3myU1kNqcspGAhsbjfPnuN0e/V8U3QL5auDE1+1bKV3u9B5YCBaRUGAAt8065fsZwbw4b/t4Y8", + "44t/51k2pLzyxnQqS7HoJT4tHLf1+GsscN/46Va4+57yHNM0sB0iSNAiYcMmnxtSz9agNfnbA/+Q8ZT5", + "M7Y+ocaSbM99vsAWTA7bqFEgZ6lKihlIN2poFzkMqYlYyayH1DPF4ZzSs7JoSNXQx+sr/4zbOsGPiWV1", + "mUGFkPZDk0c7DCLCNY+3sTLfhUPZ0I0ElTvTpCffLUxpZkCm7DACjwDe0JZvW5rsMqOahDXnWUE5DTNw", + "ZKY1JFgLgpbibg0hbZ9d8RvATq4JpLgQ+rGHhDdDEqvYTpIWxlZluJxjSLywqqfBo3G1XAZcYqMsRCQy", + "+/doSgehqTBY3rKqrErepMoJ2SCC3ZKMzhHxd0H4PrvAGsBI0ixx/IRb9uzw+YtXOKBEZl7jBBgmXugx", + "T4CKho6FNpaIfYIZZtpzmX5rAVm6kXjoRJbdrwbsA4JPtpLnb7YQRl9dxtPyCRxEL9F/3rt09Og5gBv9", + "/wUAAP//8UsmpYLEAQA=", } // GetSwagger returns the content of the embedded swagger specification file diff --git a/server/lib/telemetry/telemetry.go b/server/lib/telemetry/telemetry.go index 576c8ecd..55a9577a 100644 --- a/server/lib/telemetry/telemetry.go +++ b/server/lib/telemetry/telemetry.go @@ -15,6 +15,9 @@ type TelemetryConfig struct { // captures events.DefaultCategories. Monitor is added automatically when // any CDP category is present and is not configurable here. Categories []oapi.TelemetryEventCategory + // ExportOTLP forwards captured events to the configured OTLP endpoint. + // Off by default and independent of what is captured. + ExportOTLP bool } // TelemetrySession manages a telemetry session against a shared EventStream. @@ -31,6 +34,7 @@ type TelemetrySession struct { id string sessionStartSeq uint64 categories map[oapi.TelemetryEventCategory]struct{} + exportOTLP bool appliedAt time.Time } @@ -68,6 +72,7 @@ func (s *TelemetrySession) Start(telemetrySessionID string, cfg TelemetryConfig) s.sessionStartSeq = s.es.Seq() s.appliedAt = time.Now() s.categories = categorySet(cfg.Categories) + s.exportOTLP = cfg.ExportOTLP } // publishLocked stamps telemetry_session_id into ev.Source.Metadata and forwards to the bus. @@ -133,7 +138,7 @@ func (s *TelemetrySession) Config() TelemetryConfig { for c := range s.categories { cats = append(cats, c) } - return TelemetryConfig{Categories: cats} + return TelemetryConfig{Categories: cats, ExportOTLP: s.exportOTLP} } // AppliedAt returns when the current configuration was applied, or the zero @@ -149,6 +154,7 @@ func (s *TelemetrySession) UpdateConfig(cfg TelemetryConfig) { s.mu.Lock() defer s.mu.Unlock() s.categories = categorySet(cfg.Categories) + s.exportOTLP = cfg.ExportOTLP } // CategoryEnabled reports whether events in category c are currently captured. diff --git a/server/openapi.yaml b/server/openapi.yaml index 4f56b0e6..7164fc9e 100644 --- a/server/openapi.yaml +++ b/server/openapi.yaml @@ -1592,6 +1592,30 @@ components: properties: browser: $ref: "#/components/schemas/BrowserTelemetryCategoriesConfig" + export: + $ref: "#/components/schemas/BrowserTelemetryExportConfig" + additionalProperties: false + BrowserTelemetryExportConfig: + type: object + description: > + Forwarding of captured telemetry to an external destination. Independent + of what is captured: export is off unless explicitly enabled here, even + when a destination endpoint is provisioned on the VM. In PATCH requests + an omitted field leaves the current setting unchanged. + properties: + otlp: + $ref: "#/components/schemas/BrowserTelemetryOTLPExportConfig" + additionalProperties: false + BrowserTelemetryOTLPExportConfig: + type: object + description: OTLP/HTTP export settings. + properties: + enabled: + type: boolean + description: > + Whether captured telemetry is forwarded to the configured OTLP + endpoint. Off by default. Has no effect (export stays inactive) when + no endpoint is provisioned on the VM. additionalProperties: false BrowserTelemetryCategoriesConfig: type: object From 3222e74a252bc9630075b1b7266a8421ff3d7f01 Mon Sep 17 00:00:00 2001 From: archandatta <35818003+archandatta@users.noreply.github.com> Date: Thu, 16 Jul 2026 12:57:42 +0000 Subject: [PATCH 3/9] Add OTLP export drop/failure/exported metrics Surfaces queue-overflow drops (previously log-only) plus export failures and exported counts as Prometheus counters, owned above the writer so they stay monotonic across export toggles. Co-Authored-By: Claude Opus 4.8 --- server/cmd/api/main.go | 17 ++++-- server/lib/events/otlpmetrics.go | 88 +++++++++++++++++++++++++++ server/lib/events/otlpmetrics_test.go | 26 ++++++++ server/lib/events/otlpstorage.go | 28 ++++++--- server/lib/events/otlpstorage_test.go | 16 +++-- server/lib/metrics/otlp.go | 37 +++++++++++ server/lib/metrics/otlp_test.go | 29 +++++++++ 7 files changed, 220 insertions(+), 21 deletions(-) create mode 100644 server/lib/events/otlpmetrics.go create mode 100644 server/lib/events/otlpmetrics_test.go create mode 100644 server/lib/metrics/otlp.go create mode 100644 server/lib/metrics/otlp_test.go diff --git a/server/cmd/api/main.go b/server/cmd/api/main.go index 36e2aab3..f283c973 100644 --- a/server/cmd/api/main.go +++ b/server/cmd/api/main.go @@ -138,6 +138,7 @@ func main() { // off until turned on per-session via the telemetry API, so a VM that always // has the relay injected does not export (and get dropped) by default. var otlpExporter api.OTLPExporter + var otlpMetrics *events.OTLPMetrics if config.OTLPEndpoint != "" { headers := map[string]string{} if config.InstanceJWT != "" { @@ -146,10 +147,11 @@ func main() { slogger.Info("OTLP export available", "endpoint", config.OTLPEndpoint, "path", config.OTLPPath) // The OTel log SDK reports batch-queue drops through its global logger at // logr V(1), which slog renders just below Info, so a default Info handler - // would swallow it. Wire it to a handler that admits that level so records - // dropped under sustained backpressure are observable, not silently lost. + // would swallow it. Wire it to a handler that admits that level and counts + // drops into otlpMetrics, so backpressure is both logged and scrapable. + otlpMetrics = &events.OTLPMetrics{} otelDiag := slog.NewTextHandler(os.Stdout, &slog.HandlerOptions{Level: slog.LevelInfo - 1}) - otel.SetLogger(logr.FromSlogHandler(otelDiag)) + otel.SetLogger(logr.FromSlogHandler(events.NewDropCountingHandler(otelDiag, otlpMetrics))) otlpExporter = events.NewOTLPExportController(eventStream, events.OTLPConfig{ Endpoint: config.OTLPEndpoint, URLPath: config.OTLPPath, @@ -161,6 +163,7 @@ func main() { MaxQueueSize: config.OTLPMaxQueueSize, ExportInterval: config.OTLPExportInterval, ExportTimeout: config.OTLPExportTimeout, + Metrics: otlpMetrics, }, slogger) } @@ -298,11 +301,15 @@ func main() { // logging (scrapes would drown the logs). rMetrics := chi.NewRouter() rMetrics.Use(chiMiddleware.Recoverer) - rMetrics.Method(http.MethodGet, "/metrics", metrics.Handler(slogger, + metricsCollectors := []metrics.Collector{ metrics.NewChromeCollector(upstreamMgr), metrics.NewGPUCollector(), metrics.NewSystemCollector(), - )) + } + if otlpMetrics != nil { + metricsCollectors = append(metricsCollectors, metrics.NewOTLPCollector(otlpMetrics)) + } + rMetrics.Method(http.MethodGet, "/metrics", metrics.Handler(slogger, metricsCollectors...)) srvMetrics := &http.Server{ Addr: fmt.Sprintf("0.0.0.0:%d", config.MetricsPort), Handler: rMetrics, diff --git a/server/lib/events/otlpmetrics.go b/server/lib/events/otlpmetrics.go new file mode 100644 index 00000000..08b38dcb --- /dev/null +++ b/server/lib/events/otlpmetrics.go @@ -0,0 +1,88 @@ +package events + +import ( + "context" + "log/slog" + "sync/atomic" +) + +// OTLPMetrics holds process-lifetime counters for the OTLP export sink. It is +// owned above the export writer so the counts stay monotonic across export +// enable/disable cycles (the writer is rebuilt on each enable). Safe for +// concurrent use. +type OTLPMetrics struct { + dropped atomic.Uint64 + failures atomic.Uint64 + exported atomic.Uint64 +} + +// Dropped returns records dropped from the batch queue under backpressure. +func (m *OTLPMetrics) Dropped() uint64 { return m.dropped.Load() } + +// Failures returns export requests that returned an error. +func (m *OTLPMetrics) Failures() uint64 { return m.failures.Load() } + +// Exported returns records that were successfully exported. +func (m *OTLPMetrics) Exported() uint64 { return m.exported.Load() } + +// The OTel batch log processor reports queue-overflow drops only through its +// global logger as `Warn("dropped log records", "dropped", n)` and resets its +// internal counter each report, so this message is the sole place the count is +// observable. dropCountingHandler reads n off that record into an OTLPMetrics. +const ( + otlpDroppedLogMsg = "dropped log records" + otlpDroppedLogAttr = "dropped" +) + +type dropCountingHandler struct { + slog.Handler + metrics *OTLPMetrics +} + +// NewDropCountingHandler wraps base so OTel batch-queue drop reports are summed +// into metrics before being logged as usual. +func NewDropCountingHandler(base slog.Handler, metrics *OTLPMetrics) slog.Handler { + return &dropCountingHandler{Handler: base, metrics: metrics} +} + +func (h *dropCountingHandler) Handle(ctx context.Context, r slog.Record) error { + if r.Message == otlpDroppedLogMsg { + r.Attrs(func(a slog.Attr) bool { + if a.Key != otlpDroppedLogAttr { + return true + } + if n := attrUint64(a.Value); n > 0 { + h.metrics.dropped.Add(n) + } + return false + }) + } + return h.Handler.Handle(ctx, r) +} + +// attrUint64 reads a non-negative integer from a slog value regardless of how +// the logr bridge typed it (uint64, int64, or a boxed int). +func attrUint64(v slog.Value) uint64 { + switch v.Kind() { + case slog.KindUint64: + return v.Uint64() + case slog.KindInt64: + if n := v.Int64(); n > 0 { + return uint64(n) + } + default: + switch x := v.Any().(type) { + case uint64: + return x + case int64: + if x > 0 { + return uint64(x) + } + case int: + if x > 0 { + return uint64(x) + } + } + } + return 0 +} diff --git a/server/lib/events/otlpmetrics_test.go b/server/lib/events/otlpmetrics_test.go new file mode 100644 index 00000000..4ebfc472 --- /dev/null +++ b/server/lib/events/otlpmetrics_test.go @@ -0,0 +1,26 @@ +package events + +import ( + "log/slog" + "testing" + + "github.com/stretchr/testify/assert" +) + +// TestDropCountingHandler_CountsDrops confirms the handler sums the SDK's +// drop-report count and ignores unrelated log records. +func TestDropCountingHandler_CountsDrops(t *testing.T) { + m := &OTLPMetrics{} + h := NewDropCountingHandler(slog.NewTextHandler(discard{}, nil), m) + log := slog.New(h) + + log.Warn(otlpDroppedLogMsg, otlpDroppedLogAttr, uint64(5)) + log.Warn(otlpDroppedLogMsg, otlpDroppedLogAttr, 3) // boxed int, as the logr bridge may pass it + log.Info("something else", "dropped", 99) // unrelated message must not count + + assert.Equal(t, uint64(8), m.Dropped()) +} + +type discard struct{} + +func (discard) Write(p []byte) (int, error) { return len(p), nil } diff --git a/server/lib/events/otlpstorage.go b/server/lib/events/otlpstorage.go index 39e2dce2..e5f9d8ba 100644 --- a/server/lib/events/otlpstorage.go +++ b/server/lib/events/otlpstorage.go @@ -5,7 +5,6 @@ import ( "fmt" "log/slog" "sync" - "sync/atomic" "time" "go.opentelemetry.io/otel/attribute" @@ -50,31 +49,36 @@ type OTLPConfig struct { MaxQueueSize int ExportInterval time.Duration ExportTimeout time.Duration + + // Metrics accumulates export counters. When nil a throwaway is used so the + // sink still runs; callers that scrape metrics pass a shared instance. + Metrics *OTLPMetrics } // loggingExporter wraps the OTLP exporter to (1) split each export into // sub-requests under maxOTLPExportBytes so a batch of large records can't exceed -// the target's HTTP body limit, and (2) surface export-time failures (network / -// customer-endpoint errors) with a running failure count. Queue drops under -// sustained backpressure are best-effort (the SDK drops the oldest record, -// bounded by the batch queue size) and are reported separately by the SDK's -// global logger, which main wires to our logger so they are observable. +// the target's HTTP body limit, and (2) record export outcomes into the shared +// OTLPMetrics (failures and successfully exported records). Queue drops under +// sustained backpressure are counted separately, via the SDK's global logger, +// which main wires through NewDropCountingHandler. type loggingExporter struct { sdklog.Exporter - log *slog.Logger - failures atomic.Uint64 + log *slog.Logger + metrics *OTLPMetrics } func (e *loggingExporter) Export(ctx context.Context, records []sdklog.Record) error { var firstErr error for _, chunk := range chunkBySize(records, maxOTLPExportBytes) { if err := e.Exporter.Export(ctx, chunk); err != nil { - n := e.failures.Add(1) + n := e.metrics.failures.Add(1) e.log.Warn("otlp export failed", "records", len(chunk), "err", err, "total_failures", n) if firstErr == nil { firstErr = err } + continue } + e.metrics.exported.Add(uint64(len(chunk))) } return firstErr } @@ -182,8 +186,12 @@ func newOTLPStorage(ctx context.Context, cfg OTLPConfig, log *slog.Logger) (*otl if cfg.ExportTimeout > 0 { procOpts = append(procOpts, sdklog.WithExportTimeout(cfg.ExportTimeout)) } + metrics := cfg.Metrics + if metrics == nil { + metrics = &OTLPMetrics{} + } processor := sdklog.NewBatchProcessor( - &loggingExporter{Exporter: exporter, log: log}, + &loggingExporter{Exporter: exporter, log: log, metrics: metrics}, procOpts..., ) provider := sdklog.NewLoggerProvider( diff --git a/server/lib/events/otlpstorage_test.go b/server/lib/events/otlpstorage_test.go index 1fae232f..6da56b4b 100644 --- a/server/lib/events/otlpstorage_test.go +++ b/server/lib/events/otlpstorage_test.go @@ -27,18 +27,22 @@ func (s stubExporter) Export(context.Context, []sdklog.Record) error { return s. func (s stubExporter) Shutdown(context.Context) error { return nil } func (s stubExporter) ForceFlush(context.Context) error { return nil } -// TestLoggingExporter_CountsExportFailures confirms the wrapper surfaces export -// failures (the reason it exists) and leaves the counter untouched on success. +// TestLoggingExporter_CountsExportFailures confirms the wrapper records export +// failures and successfully exported records into the shared metrics. func TestLoggingExporter_CountsExportFailures(t *testing.T) { recs := []sdklog.Record{recordOfSize(10)} - failing := &loggingExporter{Exporter: stubExporter{err: errors.New("boom")}, log: slog.Default()} + fm := &OTLPMetrics{} + failing := &loggingExporter{Exporter: stubExporter{err: errors.New("boom")}, log: slog.Default(), metrics: fm} require.Error(t, failing.Export(context.Background(), recs)) require.Error(t, failing.Export(context.Background(), recs)) - assert.Equal(t, uint64(2), failing.failures.Load()) + assert.Equal(t, uint64(2), fm.Failures()) + assert.Equal(t, uint64(0), fm.Exported()) - ok := &loggingExporter{Exporter: stubExporter{}, log: slog.Default()} + om := &OTLPMetrics{} + ok := &loggingExporter{Exporter: stubExporter{}, log: slog.Default(), metrics: om} require.NoError(t, ok.Export(context.Background(), recs)) - assert.Equal(t, uint64(0), ok.failures.Load()) + assert.Equal(t, uint64(0), om.Failures()) + assert.Equal(t, uint64(1), om.Exported()) } // TestOTLPStorageWriter_ExportsEvents drives the full sink against a local HTTP diff --git a/server/lib/metrics/otlp.go b/server/lib/metrics/otlp.go new file mode 100644 index 00000000..a4f3efe9 --- /dev/null +++ b/server/lib/metrics/otlp.go @@ -0,0 +1,37 @@ +package metrics + +import "context" + +// OTLPSource exposes the OTLP export sink's lifetime counters. Implemented by +// *events.OTLPMetrics. +type OTLPSource interface { + Dropped() uint64 + Failures() uint64 + Exported() uint64 +} + +// OTLPCollector reports OTLP export health: records dropped under backpressure, +// failed export requests, and records successfully exported. All are +// process-lifetime counters with no labels; the scraper attaches instance +// identity. +type OTLPCollector struct { + src OTLPSource +} + +func NewOTLPCollector(src OTLPSource) *OTLPCollector { + return &OTLPCollector{src: src} +} + +func (c *OTLPCollector) Name() string { return "otlp" } + +func (c *OTLPCollector) Collect(_ context.Context, w *Writer) error { + w.Metric("kernel_otlp_records_dropped_total", "OTLP telemetry records dropped due to export queue overflow.", "counter") + w.Sample("kernel_otlp_records_dropped_total", nil, float64(c.src.Dropped())) + + w.Metric("kernel_otlp_export_failures_total", "OTLP export requests that returned an error.", "counter") + w.Sample("kernel_otlp_export_failures_total", nil, float64(c.src.Failures())) + + w.Metric("kernel_otlp_records_exported_total", "OTLP telemetry records successfully exported.", "counter") + w.Sample("kernel_otlp_records_exported_total", nil, float64(c.src.Exported())) + return nil +} diff --git a/server/lib/metrics/otlp_test.go b/server/lib/metrics/otlp_test.go new file mode 100644 index 00000000..9622b5ef --- /dev/null +++ b/server/lib/metrics/otlp_test.go @@ -0,0 +1,29 @@ +package metrics + +import ( + "context" + "strings" + "testing" + + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" +) + +type stubOTLPSource struct{ dropped, failures, exported uint64 } + +func (s stubOTLPSource) Dropped() uint64 { return s.dropped } +func (s stubOTLPSource) Failures() uint64 { return s.failures } +func (s stubOTLPSource) Exported() uint64 { return s.exported } + +func TestOTLPCollector(t *testing.T) { + w := &Writer{} + err := NewOTLPCollector(stubOTLPSource{dropped: 7, failures: 2, exported: 42}).Collect(context.Background(), w) + require.NoError(t, err) + + out := string(w.Bytes()) + assert.Contains(t, out, "kernel_otlp_records_dropped_total 7") + assert.Contains(t, out, "kernel_otlp_export_failures_total 2") + assert.Contains(t, out, "kernel_otlp_records_exported_total 42") + assert.Contains(t, out, "# TYPE kernel_otlp_records_dropped_total counter") + assert.Equal(t, 1, strings.Count(out, "# TYPE kernel_otlp_records_dropped_total")) +} From b6fc09396d23cf0374a3c304e95e93245610d4f6 Mon Sep 17 00:00:00 2001 From: archandatta <35818003+archandatta@users.noreply.github.com> Date: Thu, 16 Jul 2026 12:58:26 +0000 Subject: [PATCH 4/9] Map service-crash and OOM events to ERROR severity in OTLP converter Co-Authored-By: Claude Opus 4.8 --- server/lib/events/otlpconvert.go | 4 ++++ server/lib/events/otlpconvert_test.go | 2 ++ 2 files changed, 6 insertions(+) diff --git a/server/lib/events/otlpconvert.go b/server/lib/events/otlpconvert.go index a49ed4fa..0668ebf5 100644 --- a/server/lib/events/otlpconvert.go +++ b/server/lib/events/otlpconvert.go @@ -127,6 +127,10 @@ func otlpSeverity(eventType string) (log.Severity, string) { switch { case eventType == "console_error": return log.SeverityError, "ERROR" + // Process-death and OOM events are failures a consumer alerts on, so they + // map to ERROR rather than the default INFO. + case eventType == "service_crashed", eventType == "system_oom_kill": + return log.SeverityError, "ERROR" case strings.HasSuffix(eventType, "_failed"): return log.SeverityWarn, "WARN" default: diff --git a/server/lib/events/otlpconvert_test.go b/server/lib/events/otlpconvert_test.go index 83d8718f..4c5621a6 100644 --- a/server/lib/events/otlpconvert_test.go +++ b/server/lib/events/otlpconvert_test.go @@ -113,6 +113,8 @@ func TestToLogRecord_StructuredBody(t *testing.T) { func TestToLogRecord_Severity(t *testing.T) { cases := map[string]log.Severity{ "console_error": log.SeverityError, + "service_crashed": log.SeverityError, + "system_oom_kill": log.SeverityError, "network_loading_failed": log.SeverityWarn, "monitor_init_failed": log.SeverityWarn, "network_response": log.SeverityInfo, From 059b9268ea0b25599a48ea595feb070f92fe4446 Mon Sep 17 00:00:00 2001 From: archandatta <35818003+archandatta@users.noreply.github.com> Date: Thu, 16 Jul 2026 13:01:44 +0000 Subject: [PATCH 5/9] Emit page_crashed telemetry on renderer crash Detects Inspector.targetCrashed (an 'Aw, Snap!' renderer crash that leaves the browser process alive, so no service_crashed fires) and emits a page_crashed event, mapped to ERROR severity in the OTLP converter. Co-Authored-By: Claude Opus 4.8 --- server/lib/cdpmonitor/domains.go | 5 + server/lib/cdpmonitor/handlers.go | 19 + server/lib/cdpmonitor/handlers_test.go | 35 ++ server/lib/cdpmonitor/types.go | 1 + server/lib/events/category_gen.go | 1 + server/lib/events/otlpconvert.go | 6 +- server/lib/oapi/oapi.go | 831 ++++++++++++++----------- server/openapi.yaml | 41 ++ 8 files changed, 569 insertions(+), 370 deletions(-) diff --git a/server/lib/cdpmonitor/domains.go b/server/lib/cdpmonitor/domains.go index d8277969..00073695 100644 --- a/server/lib/cdpmonitor/domains.go +++ b/server/lib/cdpmonitor/domains.go @@ -38,6 +38,11 @@ func (m *Monitor) enableDomains(ctx context.Context, sessionID string, targetTyp m.log.Warn("cdpmonitor: failed to enable CDP domain", "method", "Page.enable", "session", sessionID, "err", err) } + // Inspector.targetCrashed reports a renderer crash on this session. + if _, err := m.send(ctx, "Inspector.enable", nil, sessionID); err != nil && ctx.Err() == nil { + m.log.Warn("cdpmonitor: failed to enable CDP domain", "method", "Inspector.enable", "session", sessionID, "err", err) + } + if _, err := m.send(ctx, "Runtime.addBinding", map[string]any{ "name": bindingName, }, sessionID); err != nil && ctx.Err() == nil { diff --git a/server/lib/cdpmonitor/handlers.go b/server/lib/cdpmonitor/handlers.go index 6c13dfc9..d0af3685 100644 --- a/server/lib/cdpmonitor/handlers.go +++ b/server/lib/cdpmonitor/handlers.go @@ -169,9 +169,28 @@ func (m *Monitor) dispatchEvent(msg cdpMessage) { if m.decodeParams(msg.Method, msg.Params, &p) { m.handleDetachedFromTarget(p) } + case "Inspector.targetCrashed": + // No params; the crashed page is identified by the session it fires on. + m.handleTargetCrashed(msg.SessionID) } } +// handleTargetCrashed publishes a page_crashed event for a renderer crash on +// sessionID. The URL comes from the tracked target info; target id and type are +// stamped into source metadata by publishEvent. +func (m *Monitor) handleTargetCrashed(sessionID string) { + m.sessionsMu.RLock() + info := m.sessions[sessionID] + m.sessionsMu.RUnlock() + + data, _ := json.Marshal(oapi.BrowserPageCrashedEventData{ + TargetId: info.targetID, + TargetType: oapi.BrowserTargetType(info.targetType), + Url: info.url, + }) + m.publishEvent(EventPageCrashed, events.Page, oapi.BrowserEventSource{Kind: oapi.Cdp}, "Inspector.targetCrashed", data, sessionID) +} + func (m *Monitor) handleConsole(p cdpRuntimeConsoleAPICalledParams, sessionID string) { text := "" if len(p.Args) > 0 { diff --git a/server/lib/cdpmonitor/handlers_test.go b/server/lib/cdpmonitor/handlers_test.go index d9c760d5..49cc38b9 100644 --- a/server/lib/cdpmonitor/handlers_test.go +++ b/server/lib/cdpmonitor/handlers_test.go @@ -334,6 +334,41 @@ func TestTabOpened(t *testing.T) { }) } +func TestTargetCrashed(t *testing.T) { + srv := newTestServer(t) + defer srv.close() + + _, ec, cleanup := startMonitor(t, srv, nil) + defer cleanup() + + srv.sendToMonitor(t, map[string]any{ + "method": "Target.attachedToTarget", + "params": map[string]any{ + "sessionId": "sess-crash", + "targetInfo": map[string]any{ + "targetId": "target-crash", "type": "page", + "url": "https://crash.example.com", "attached": true, + }, + "waitingForDebugger": false, + }, + }) + ec.waitFor(t, "page_tab_opened", 2*time.Second) + + srv.sendToMonitor(t, map[string]any{ + "method": "Inspector.targetCrashed", + "sessionId": "sess-crash", + "params": map[string]any{}, + }) + ev := ec.waitFor(t, "page_crashed", 2*time.Second) + assert.Equal(t, events.Page, ev.Category) + assert.Equal(t, "Inspector.targetCrashed", *ev.Source.Event) + var data map[string]any + require.NoError(t, json.Unmarshal(ev.Data, &data)) + assert.Equal(t, "target-crash", data["target_id"]) + assert.Equal(t, "page", data["target_type"]) + assert.Equal(t, "https://crash.example.com", data["url"]) +} + func TestBindingAndTimeline(t *testing.T) { withMonitor := func(t *testing.T) (*testServer, *eventCollector) { t.Helper() diff --git a/server/lib/cdpmonitor/types.go b/server/lib/cdpmonitor/types.go index 1cdce741..83eff1e2 100644 --- a/server/lib/cdpmonitor/types.go +++ b/server/lib/cdpmonitor/types.go @@ -27,6 +27,7 @@ const ( EventLayoutShift = "page_layout_shift" // PerformanceTimeline event of type "layout-shift" EventLCP = "page_lcp" // PerformanceTimeline event of type "largest-contentful-paint" EventTabOpened = "page_tab_opened" // Target.attachedToTarget for type=page + EventPageCrashed = "page_crashed" // Inspector.targetCrashed (renderer process crash) ) // Computed events — synthetic events derived by computed.go state machines. diff --git a/server/lib/events/category_gen.go b/server/lib/events/category_gen.go index 06d641fb..b02132f9 100644 --- a/server/lib/events/category_gen.go +++ b/server/lib/events/category_gen.go @@ -25,6 +25,7 @@ var categoryByType = map[string]oapi.TelemetryEventCategory{ "network_loading_failed": oapi.TelemetryEventCategory("network"), "network_request": oapi.TelemetryEventCategory("network"), "network_response": oapi.TelemetryEventCategory("network"), + "page_crashed": oapi.TelemetryEventCategory("page"), "page_dom_content_loaded": oapi.TelemetryEventCategory("page"), "page_layout_settled": oapi.TelemetryEventCategory("page"), "page_layout_shift": oapi.TelemetryEventCategory("page"), diff --git a/server/lib/events/otlpconvert.go b/server/lib/events/otlpconvert.go index 0668ebf5..2b30d27a 100644 --- a/server/lib/events/otlpconvert.go +++ b/server/lib/events/otlpconvert.go @@ -127,9 +127,9 @@ func otlpSeverity(eventType string) (log.Severity, string) { switch { case eventType == "console_error": return log.SeverityError, "ERROR" - // Process-death and OOM events are failures a consumer alerts on, so they - // map to ERROR rather than the default INFO. - case eventType == "service_crashed", eventType == "system_oom_kill": + // Process-death, renderer-crash, and OOM events are failures a consumer + // alerts on, so they map to ERROR rather than the default INFO. + case eventType == "service_crashed", eventType == "system_oom_kill", eventType == "page_crashed": return log.SeverityError, "ERROR" case strings.HasSuffix(eventType, "_failed"): return log.SeverityWarn, "WARN" diff --git a/server/lib/oapi/oapi.go b/server/lib/oapi/oapi.go index 20daaaeb..49e6b446 100644 --- a/server/lib/oapi/oapi.go +++ b/server/lib/oapi/oapi.go @@ -758,6 +758,36 @@ func (e BrowserNetworkResponseEventType) Valid() bool { } } +// Defines values for BrowserPageCrashedEventCategory. +const ( + BrowserPageCrashedEventCategoryPage BrowserPageCrashedEventCategory = "page" +) + +// Valid indicates whether the value is a known member of the BrowserPageCrashedEventCategory enum. +func (e BrowserPageCrashedEventCategory) Valid() bool { + switch e { + case BrowserPageCrashedEventCategoryPage: + return true + default: + return false + } +} + +// Defines values for BrowserPageCrashedEventType. +const ( + PageCrashed BrowserPageCrashedEventType = "page_crashed" +) + +// Valid indicates whether the value is a known member of the BrowserPageCrashedEventType enum. +func (e BrowserPageCrashedEventType) Valid() bool { + switch e { + case PageCrashed: + return true + default: + return false + } +} + // Defines values for BrowserPageDomContentLoadedEventCategory. const ( BrowserPageDomContentLoadedEventCategoryPage BrowserPageDomContentLoadedEventCategory = "page" @@ -970,13 +1000,13 @@ func (e BrowserPageNavigationSettledEventType) Valid() bool { // Defines values for BrowserPageTabOpenedEventCategory. const ( - BrowserPageTabOpenedEventCategoryPage BrowserPageTabOpenedEventCategory = "page" + Page BrowserPageTabOpenedEventCategory = "page" ) // Valid indicates whether the value is a known member of the BrowserPageTabOpenedEventCategory enum. func (e BrowserPageTabOpenedEventCategory) Valid() bool { switch e { - case BrowserPageTabOpenedEventCategoryPage: + case Page: return true default: return false @@ -2514,6 +2544,40 @@ type BrowserNetworkResponseEventData struct { Url *string `json:"url,omitempty"` } +// BrowserPageCrashedEvent A page's renderer process crashed (CDP Inspector.targetCrashed) — the "Aw, Snap!" failure — while the browser process itself stayed alive, so no service_crashed fires. Emitted on the crashed page's attached session; the CDP session and target ids are on `source.metadata`. +type BrowserPageCrashedEvent struct { + Category BrowserPageCrashedEventCategory `json:"category"` + Data *BrowserPageCrashedEventData `json:"data,omitempty"` + + // Source Provenance metadata identifying which producer emitted the event. + Source BrowserEventSource `json:"source"` + + // Truncated True if the data field was truncated due to size limits. + Truncated *bool `json:"truncated,omitempty"` + + // Ts Event timestamp in Unix microseconds. + Ts int64 `json:"ts"` + Type BrowserPageCrashedEventType `json:"type"` +} + +// BrowserPageCrashedEventCategory defines model for BrowserPageCrashedEvent.Category. +type BrowserPageCrashedEventCategory string + +// BrowserPageCrashedEventType defines model for BrowserPageCrashedEvent.Type. +type BrowserPageCrashedEventType string + +// BrowserPageCrashedEventData defines model for BrowserPageCrashedEventData. +type BrowserPageCrashedEventData struct { + // TargetId CDP target identifier of the crashed page. + TargetId string `json:"target_id"` + + // TargetType CDP target type of the page that produced the event. + TargetType BrowserTargetType `json:"target_type"` + + // Url URL the page was on when its renderer process crashed. + Url string `json:"url"` +} + // BrowserPageDomContentLoadedEvent A browser DOMContentLoaded event (CDP Page.domContentEventFired). type BrowserPageDomContentLoadedEvent struct { Category BrowserPageDomContentLoadedEventCategory `json:"category"` @@ -4265,6 +4329,34 @@ func (t *KnownBrowserTelemetryEvent) MergeBrowserPageTabOpenedEvent(v BrowserPag return err } +// AsBrowserPageCrashedEvent returns the union data inside the KnownBrowserTelemetryEvent as a BrowserPageCrashedEvent +func (t KnownBrowserTelemetryEvent) AsBrowserPageCrashedEvent() (BrowserPageCrashedEvent, error) { + var body BrowserPageCrashedEvent + err := json.Unmarshal(t.union, &body) + return body, err +} + +// FromBrowserPageCrashedEvent overwrites any union data inside the KnownBrowserTelemetryEvent as the provided BrowserPageCrashedEvent +func (t *KnownBrowserTelemetryEvent) FromBrowserPageCrashedEvent(v BrowserPageCrashedEvent) error { + v.Type = "page_crashed" + b, err := json.Marshal(v) + t.union = b + return err +} + +// MergeBrowserPageCrashedEvent performs a merge with any union data inside the KnownBrowserTelemetryEvent, using the provided BrowserPageCrashedEvent +func (t *KnownBrowserTelemetryEvent) MergeBrowserPageCrashedEvent(v BrowserPageCrashedEvent) error { + v.Type = "page_crashed" + b, err := json.Marshal(v) + if err != nil { + return err + } + + merged, err := runtime.JSONMerge(t.union, b) + t.union = merged + return err +} + // AsBrowserPageLayoutShiftEvent returns the union data inside the KnownBrowserTelemetryEvent as a BrowserPageLayoutShiftEvent func (t KnownBrowserTelemetryEvent) AsBrowserPageLayoutShiftEvent() (BrowserPageLayoutShiftEvent, error) { var body BrowserPageLayoutShiftEvent @@ -4879,6 +4971,8 @@ func (t KnownBrowserTelemetryEvent) ValueByDiscriminator() (interface{}, error) return t.AsBrowserNetworkRequestEvent() case "network_response": return t.AsBrowserNetworkResponseEvent() + case "page_crashed": + return t.AsBrowserPageCrashedEvent() case "page_dom_content_loaded": return t.AsBrowserPageDomContentLoadedEvent() case "page_layout_settled": @@ -18859,371 +18953,374 @@ func (sh *strictHandler) StreamTelemetryEvents(w http.ResponseWriter, r *http.Re // Base64 encoded, gzipped, json marshaled Swagger object var swaggerSpec = []string{ - "H4sIAAAAAAAC/+y9iXIjOXYo+isIPke0ZJOUqrp67KkKxwu1pJqWuxY9SdVtz6gfCWYekhglgRwASYnd", - "UY77EfcL75e8wDlALiSSi5Za/CrC4akWE+tZcdY/Ooma5UqCtKbz8o+OBpMraQD/40eeXsA/CjD2VGul", - "3Z8SJS1I6/7J8zwTCbdCyYO/GyXd30wyhRl3//onDePOy87/dVDNf0C/mgOa7ePHj91OCibRIneTdF66", - "BZlfsfOx2zlWcpyJ5FOtHpZzS59JC1ry7BMtHZZjl6DnoJn/sNt5p+xrVcj0E+3jnbIM1+u43/znhAo2", - "mR6rWV5Y0EeJ+zwAyu0kTYX7E8/OtcpBW+EQaMwzA8srHLGRm4qpMUv8dIzjfIZZxeAOksICM25yaQXP", - "skW/0+3ktXn/6PgB7p/N2d/rFDSkLBPGuiVWZ+6zU/yHUJIZq3LDlGR2CmwstLEM3M24BYWFmdl0j80L", - "cfCaCXlGI591O3aRQ+dlh2vNF3ihGv5RCA1p5+XfyjP8Vn6nRn8Hwr4ftbo1oI9yccyz7HTuAb50k5L9", - "dHV1zhKeZWzKZZpBykYLPMwNaAlZT8z4BEyP54IZRKzVq0y4hYnSC/dvkMXMbc3hmFZZbWvGaiEnbmsp", - "txvRK7L9EzfMoZQqdAJbToAjL2nEx27H6kK67aard3GlC2BijGd3O2RjAVnKbrlh5SiWFuAQwYjfgWVi", - "Jqxx1+FPOFIqA44wtBHEwq0wK2ZgLJ/lTEj2QYo7NhOJVgYSJVOcbaz0jNvOy46Q9k8vqumFtDABJGn6", - "S3XbPBcDB8PIdS+hjDVhwm4Ft/JOt0SkEw/AHWj2HHQPsSzni0zxlI2VZsOw7yEDN69Zxa200MidBrPI", - "jf7Ks6yXZCq5YeE7R7EOgoTM2l3yTGSZqN2vP6EsZiO6TbceLSIiePE+B3l0fsbKr87SsMjMsSFImVaO", - "3+xBf9Jnw1yrBIxxLGLYZUPLb+Ay0QDSTJUd7td2UFGEJj4YXd/dnP+didQxtLEAzcZazVroNHw9E2ma", - "wS3XEF3UWG6LyK0iRwhCnNFXLFFpfZYSF5fQq3aQpXst1+s2YLoG4xy6XVqe3Kxu8fjknF0U0tFSHz+5", - "0jwBpiHXYNwVyQnezX/wOb/EccTijPuWcYs/utHI4CVhX5+9dhRvWGGAuRUkn7mJEiXdzygENLdT0MxO", - "uWRG8hsYJNwgS0BcwHmPp1rNgJ3A/EqpzLBzraxKVMZuhQZG1N2/lhE2mmWvNZ/BFkIJTzPGj7vMYZ+e", - "KWNJADVEz9ISKitm8h1h/soifwWteiNuIGX0ISMaYbfCTgWJuEzIKB50O+NCojh6x2ewOncNEuFDd7/Q", - "ZUozmOV2wQgzkTFwqeRipgpTfmyiKOx2s8Vp3GeRs9DX8dPQb2dpHPfov2vkGN1dobPV4R8u3rgju7MH", - "NuJnG4ssRqhLFNa45to+abnGlXSb8I6RWlO9WGLaq5yQmD3L+AgyBBRuH4nKIgUSD+RmIROW8MJAnN/l", - "XAcFNMvejzsv/7aVMK84wsffVgQMTtnYDGISbgX/avorl1kjubWMKLfJlF+qbA4XYIrMtqlTLKFPmXHf", - "Mm6tQ22mgaOc4MwRqnBXqAqbqBlsqUzRrA9VplrO8U2vatWr/MUPEJwDjXf2hDrWOgDtrm4F7GtoXLET", - "tWtf4etwL0uc0CP7HGSqNBvzmcgWfSfv0iIBbZh0N545mOZazUUKumdySMRYJMxyc4Nc0DAhrWJ2Kgwz", - "YF8ycA/ZXAsDbM614NIaxyk1BOJKVJbx3EAYCEKzOWjjZMqoSG7Asr35c3bA5t/vdxmXKeNy4bj+hEll", - "WaLmKEuJV7nLPVFOEL21/kBdlmdcSPb++GKfCePUCqUdlnLDhsopAEOS3wFNpoFAHR6EO5s/b/7n9w4p", - "Ci2NFZnDjAmAdW/fbgenjBP3rtovaoXEfIzl2jqiivGcFR0YH60Dp+WtLoT4WAMdfosaoXv4jrnICl2q", - "v6cXF+8vBsdH51fHPx0NPry7fP/ml6Mf35wO9/vsaOSUMzfIFIlTknfSS6+Wz8GGfprhSzqzZhrcFSOr", - "LQwfZeB+wJd6nw39TmNfS3+oPQPAhtVluF0PHWtRha3GpSJFTKLxdZXCCRTQ3xl2y4VloyKdgO2zIR9x", - "mSoJ6fCl/4QlXCaQufe2F6M5nwCTfC4myBH5LV84Db6HazbxzR/b8TQ6krtG2mSn2ykXi6KUo7voO8ND", - "mRsjJu5OasoNe5/zfxTQdZrxuCDJb4rcUQVzPNb0NIxBg0wgDtJbGBlhYTBVJiI2f1Kk1Ja3cDsFDf4+", - "ieSdtMCLSNfOn3M7jbyguJ1uPz/7fwrQpTYKd0lWpNFlV3SJGq+8x2snzY+VlJDYdlsN3HkTX5IJR0hE", - "cklhrJqBZpcnP3fZecYXt1pMprbLzos8Bwug990jxs0NKSOWiQ+cX2F0qZBf5lrdLciMJQz75e3WRh43", - "qdtfDNW+KRSrCkWaD/ytPaUekeYnwiS7olNajoG0si9sQBR2zgW9qvBrMZtBKriFbMFyDQmkjoqGtXMP", - "g7XUuCeQsRr47FHQbRdNeOWCvinBa3G2Qo1Pirb31Hyr3S4pv42TPL7RsULQreyOMzCGT2CQqCJGofRs", - "d3M7EvQfO2004wunIKDkjawLAm1UqdD0t7iBQwM3sUf+r9PF8pwgnQBkQ2ITgyRTxilR+BVxDiGFFYjD", - "9EdlnHZW5ETdg2TK5QSVH7SNiWLGNKB+CinpOGBQe3e6Okpp5DJWaWCpupXMqPpqiSqy1L0HPIz5hAtp", - "yKgn4ZaFdetbQJVu+LL8jaXCaZI63CvLi1lOSiCdVUkLd3ZQqmn+wMG26n9HCq5UuT27yIVT8BbeWcLM", - "tLDuCPtNDa5+lZ1uZ/mm6n/CPaEtZ2lHmymxjsfL6FZiwDqCVNKoDNDV12ryGNG37kbcx16RVpo5tlZM", - "prZuhYW7BHJCKjK5ns6ErcTNrXJCyAqZWER64hmGxEsqxqhkWuKgZspzMP3SDuzXPzo/O+YEDP+Xvn+v", - "8Cwz+w613OvUsAzmkHWZu9Mu43pi6KmIpqIBGpCqucttX021w8e98mzlL/Wpac5MSOh6S2rXH2VQ6Cyy", - "jjc8uzeF98i6p4vX1Ggk4xoYxwdU3HgclZfu/A8WlstY8E1WtstKuitPtE8oKqMw2dWeiiOPia90PnaX", - "vQWOKCIUn2UlrXM9KWZuZpYo0Am9Luisps/OyRnDlMwW7s0lPSp7am8j3Ib/YvX9umSxJvqKGKcaHoyG", - "xb/2/qv4EaIXUvfWG1/iCnE5i2wm7kUIt+gGsTnP3AubZ7d8Ydg1GWSuOw+6xai/ZHUvb2rukc93URWD", - "bHGarDhLmJ2iK0/DbXOPj7CxhjkqMOqt7eylm6LbQdpaNXkUMy57GniKnJ4klBdFpNMti9VbVHpSYfKM", - "L5iwffZalb+SiNvbJyHXrQWjBAqtEyj3JEpTRERZ1ythMBZ3KKxof16B6DI0O1x3PoSRyIZespFSs+uO", - "E/213/aEdIJxJgzss6tFDv7jOya8wCt9fNcdkmwbeKa70FXW+NsKc3yjJlsrLZmakEZSaQ2ZmnTL+xVy", - "rKr/uuVadhnYpL/f/wySOBzsmxzeKIczNXl6KdyAx5clg3cSpWtEVauS7ebospwbg48/rYrJlBVyLDKL", - "ThZktxQR0feG9SH6VFThjZENlck/yZl7zwFPXzGeZQz9I2xZYhqnKgPXzMmoPrsEMlWZHJLSNT0usow5", - "nIgylifi7a+R8S6DZxU6m03KBJDuFiyvgUUrO/IfeQ4Xnq5IdFW8X2CJMyWFdS846URFlrlb7QXp6S0m", - "7Cw4B0hYWa4nYLsUkULvG+/JwKderpKpo+7bqfAxMrQTlSSFdu/tyIMGp4o6KhyU8dd6OFTNB0Obies/", - "iqegW2dNVUKwou9q83eZUyjQdQU8mdZOF11H8vnAwD9WV3mrpLJKehuBkIl7hKNjsrouiltNgkrWpc/c", - "viAtN2BV3kP0qI+MXsIW3NObX1rvJZhn6uFnnsJonZq1KHof9FV0/oCbfqLaEnvGonLkDV3VOU04KGeW", - "j/bXrRjkwhaUfYUjnIayNnZHQwZzLsmzOhWGUPkVOZbcB2OM7ilh4mgBfyPS6ZYWpPJbsLdK39SMkeuZ", - "Qg1Y9YttHrlCwTXiq64K7Ghk1WoOkjsknYHlqB14yC0cNhOhe3uIZuCNPCXlr2pNENfUQixBzfmMnAPD", - "p7zHuU02DfF669yrNFHhVccR50bItE1VCQfqoyk5mDNjoX5ejJVOFM9c+2xI4ZoDnovhS/Yz/gc7Oj8L", - "9sI9x2f0HMhiTX/sTUCCRnUr7JwN4c6CdIgwfMmE/Ds5bfx+yt/6bJiphGcDH5Q6fMnMwliYMf8Hpgsp", - "HcR4puTEiBQa223aLNO80+1U+3c/hYU6jrfWFopqugFV2pEtoqRswocgzQgZHLciOjjwdHJAouLspAHv", - "QAtLtIXAX0MxP1mb/wRONpj2Q1hdrBAMxtROaSSb8dxB95brFINKesJjitu9Y22qsGXsDAkZ9gvPCqfy", - "aFR+go2ZtDw2Kiyb8QUbAeNywf7j8v07VJEaWs/KYTBhhFIIjjOR3Gx8LBX4YnKfBk2C57ZwWt5c8AoJ", - "kdtVsZWbX0ei2shDX0jRM317J7W+k2pXP0DIPuFrqR02j/xmMpBBYlUkJvj48pKFX1nO7TTY2PHsjr9m", - "qGi1qBSTWLD82zfM8kkjoHdpNgewIs9BY6w4MaofP1xdvX/XZUdddnL2S4sOE1XmfxFGoHfAcT2fytWy", - "cJdZjQ756PR3sbnhFqN67nqJUjoVktvmqdxZ3C3m4g4yE7fkLdZMvLj/xEt4eNdxK3UraBOE1j6Taij4", - "Myw2MrwbWIwU1+nXwO7Ceb4xu62Y3Q0sPg2ra8DlkRmdO8TKBf4MC3ImVNrnzx6P6W6JAZ26LXbZjzy5", - "MTlP3Ks9zoXuwU0D30P7/BSjL5LCkB2eUpYWiDG5BmNauNP23BYnX89tz96df7jqsqvT/7w6ujht57nL", - "6iA8gMFcJlpl2SVYm0G6kdUY/JoZ+twznPBu4mNbfZIrI2qppxgxIOSk+2Wzp9Xb+MaotmJUBPWBR4xP", - "w7NagPXI3Muxp0FECaHV2V2vxHSfsEcR7ZUf0H01AeOQfhu1BNdbtK63eOz1vD3mHvyT1tqkjqrY5b3G", - "CHmzeoXIQtzk4QSB1WxzEhW7t8ZSi0dZajnXjTCkBJ0/tN/Q6g2vZc1vxBycGrohypplYg5sLuC2Cjdb", - "Cp127/hxkQXe/Z1hv8Lo4uq4tOG8gxu132c/+e+UzBav0NcZGPpYaZwlA2MYZe5+6hDY2HV8Y8mtLNlh", - "xcBhxScI324Fze6RsMFy3wiDXTlLeyTsOs/Am5JQVv0DfXbZMN6XwZqmy4xinFnNpUHyCvbvUSZylnCJ", - "RIKhgN6IWsaWY8D4sNrScCdj+RYXvjlofpU7xIPmt2URVfB8DCqjxcpxPweL+BYqvzuX+CQB8+sA9Oi8", - "4gsKnL8vV3rlK3aEqHlNVS4oRaWNK+7okdsy3estedlPatyjhedc+Ryc2h1ZFTw9jioyZWyfXaGuaPUi", - "sE3vEEi1ynNIWSGtyIJzf1DyY/e61FrMwfTZlQZu0YMgZC/XauKe56HEEkYsW2B7nl8PRJph5McEBhlf", - "qMKGN8o+44YVUkMmUATQynYKcjsG5vf4UO7VdsPf2Fcr+wrYUZdpT8i+1kJoE/9q4lFbNssF/r2MVqgO", - "hk61BIloUOailA7d0jsafunX/aBLozbf0OZMC38VZ1LY11xkG5lB4G2UCuOeFiPwWTiZ+J32+6kpbWnz", - "3+hsI505gA3GeGVPT2Yx8OxGZMZC3o6SM7BThdnsJR76eCYLOZmC6ajeJkvxNn0D9qiw6shanky3sMni", - "Jjaf9iIIuK3IKSpbG7SloQcYjyTMtLTIwt2UF8ZS/ERWPXLIhoTVN0yfvVNsXGiqG7UspG9FlnkBXCbV", - "etr+HCQcu7VvdLyRjkvAfzJibgXUk4jNBmL7khP96q8DTwdOgBIdOAwPBMBuQQNDD02Rl+EtvoTFuMiy", - "BYpZpUPRtiZB1iVvZMVHFL4X8GBVfOlUEZbBl3WQU2IEwTKYFuU9THiO8T6k3x831XAsS2PAojllKdww", - "WFSs5smNm82rKmyswUyDkUIYlish7WflM994zM485pOyl4ewlkCr2xoFsB7j0vOfWX4DSGW1dO/Sv9Ak", - "pW3ud4U3xDa5+X6qgp6thsIctFCpSJgpvw3WjuDznfugmO0osJrnkYhw6RDfaHAjDa4FwSOTYAw6u1Fg", - "LiMRFD9yA3960QOZqBRSdv7uL1siaHlto4WFjVq6W3vNGd+RhDpLM9gYGRGkmUhD5PZSXARnPxwezgz7", - "RyHAerojm7pUTMjeOBOTqWW+rC0G32/pbfNLP5Telvzg3yhslcLqRsUnpC2Pd28UT4WcrH0ariJgRqPC", - "K9YXsDgbN+qCuNvmmQaeLtz9eNzDyCenOXJ85ro3sFQs10JpNgxn91MMcY66p1jY/S4bFjobdtkw5EW5", - "f5fpTEPKuRpq8FnU7gKGtZIRr9gwgoyYiZdzTTXyWa7yIkMswSQiblnCDWxbbeKRiKUVRN/k00bq8Rj6", - "9K/Q9UB65DghKnizCWZ1AgwjllMbMcxmEin8XAMd1X6Mh16/C6lamKpa+82btCTYly9PLy4Gx+/fvTs9", - "vjp7/25wcfr6w+Xpye513x27iNR9Rw9WeCIqLSZCcrRALbGRVueVW7XGJeIL+5P2L/ynV4scauYAXGEl", - "7beeyeIzfn+W6lZSOKphQmItRXbi0yy77DXYZNpl//nTRZdRhaAuu7SLDMwU3Nv2bIb1Bt5CKniXvVZu", - "zBXc2Sv3su2yGnV3qxp1XfaWSzHGHZ5rGNMa7+0UNLHJmdJbFNpulLKvYUW3Qsi18Ub+CkP3m22lTAAf", - "lq9oSZZ7evZb3/U3xruR8XqgPT3HXYHLI/PakAG9sQxLmSqNekKz/pu/jSjvmday53bZdz3zbrX4u7+W", - "kGHXdyv5PTmybWVzZ+GbPtbgETLFZkiYwYrqT2GaZ7o3zzOeu+VcG8eHcg1OWhNDwgIH0esSZqCBKvmt", - "oxy0BnpRYfx+TZFR/yIWZoiTDPltWtqAeKcONyxUbnaTYyMLEnl/Ob3qsvP3l1cthf6VsYPAfuIwG6l0", - "gaLFzXJw/uGqfKR13eH4nIuMjzJoEWV0tDi+vifxmGGu9QjGyhczCqMQDHgwVNBrl43XqAt4JKndZYUU", - "/yig0X2icvN8k9APl9AejbtNFlYxnBWGsJ3wpi44O0hv3zZHQwJiXj0TX7tN10yX5YeI/g4o3mdAw7ro", - "d0SsDFnD5CX8PMpA7Ra+aQNbaAN0X59CHViGzCPrAw47o0DykGigccVOseza2Jc0Y2/P3p5SyZ5PqhL4", - "ndV1gm1knVdwVJAd67SZmZi18ejy0GHC8qpIcLqbOZjaWdZly00Yv70Vv3hJ9Ejd08I0LfaG6Fy1ahfv", - "f+6yst3m/n0FZtmpIBDiWsl4zidwombHlHj+RvF0CxPqyfu3jQGh1p5DHzdhPy1nxLlQWm5ZWy/nkwcX", - "1ms91Ddp1yrtMPI3VbOBr0GA1scntTquh9JjWx3TfFDeW4TxUdDHLNTzYuTDpsRrIVnwX3PriyGtkMDY", - "3UcXy7lbMUcQB3IJ4acUtbHnVEGEGhZS2++zDwbY0BoqcHTb9KBHAuaXG5U0TraR2N9gcPe2ecwUCt6S", - "x/zMX4vXg9EWi6kGlbfOgp4DViQKM03FGJ+C1dt8LkzBsZnjSGTCLvrslCfTxgAKjqGn8LOeX9UdWn86", - "pvLN7bcdD2lmDzwx//DY7HBkc3HYYlZ44mzg1t7xm8t9j9plxtc5aLwAmQC7EjPAnpNH52efVogtH++b", - "/NoO99yFfWLMexLzrY9iWr3Ik6WMqwZCg7R6sRJ6tedrkR+imGmwY5aDxkqr+9H8rPqtDlKwXGRm94S0", - "QE61i2PcWi1GhQWzgfLwSKu0N+XpQEPi1BUh88KuR+nGJfmCJQmk5FjEamg4SbDqYRhK17cMc4JKeP5w", - "/OYyjvKoLkRy2OrrmkTp8J4SxsNqD/uru5sIQahvLvfjon8FJ/2DbscCq6HYCv69qgvfuKKynmu0XoGI", - "9QWOAq+i9xi2bs4QXE4ZWDqw30uVq7eFEpTkG8XFG64n7jHt1bxxkbFzLtwz583x+ZcqL/y5vsmJDXIi", - "yZ9aPNQh8chiIUvye7Jhj9MVShNGP5QN+7omUe4j0mr6QP9vjs+rmnZiHOyMrTWeB3Fm415eZdv3pXm3", - "SjyWKm1nmSfv3zL3QYRr1tZp68YlU9At277AH7fd+CsvsKkxJ1n9fI2RMvviSsyEnPSOskzd9shLFk+0", - "Fr9DewVCroG3bIhKvDDzj4I35UE19yYPc31GjIJzR2BKs7lIQYWfWgomP63Qq2/N8TCC3hPIPVwoppzd", - "W+htlnSKb37lVy/3ZUNeFoZ/DhNeufdv4myDOFP8yR/aDVh84cY51DErdP5aTHPvyryv7Si23mTAd19c", - "pl/kF+9CF+r9PjvmWgvA8vtlre0xtasTErnWCKtVW+YrzvsORqEyft0St9wT4tNyh6Xb+sYj1vOIClhP", - "zClicNkt0+V+Ur3qtY5f7Now5B3csvVNQ1jZS718vW/oG5Jz7dTi9vOc4werR6KO7CP6e61Txisf/087", - "iPQMaWnBv3NDkEdr+/Fpu3lUOGDVo7XeoMCjmuZVYdHWpLDe3xK6pmKAUIsjruw8smRgZ1M+BzZSdkpy", - "rnTVmybuNFwuZet8YVhtevLEYCcCDNFjZzKF3GnDVJO8ntbzinFmhJxkwNwXlJdM4QepAuoFN0JZKbbu", - "cPrNTfM55MEnctVc8dH7HOQap6OE21LBsXzkHoeen7hrVTiYdBtfbCSkX10p+gPiPuI1jTP7FKlnQrQo", - "b1TbEaZK4PK1QN0WQvcroxrl+jYla3l9qZmmVVOcSqpA9HN6ZSyFq8+OlTTFDLR7h1KG2pKehu1jQsuQ", - "KVY1sVjqS1inq3G05Aue7ZTu9VhaWRPK35Sy9URo+WhAeP1Jie8eOhnuMq45Xa20+vIamaNhzCfwpIvE", - "oCRQILhc7KpkVN2AYq3LJNxmi3IpPnoSzcMKm0XMP5R4kHne474ptVJkKPHNRNWYMFXNdNY+xzKKrNVh", - "1qDIJei5SOBYczNdw6BnXPIJpFj1VCTA4E5YrEUIdzlWl8gWTmdwWgtila9pT9FtDpu4VbpXZZeU3fRZ", - "qpA1+o5cdbb5f/7X/6b402oVXNcg17WgZz6sE5/AvYmYQ6/IfUFaai+Xqm25IHXTeigfjNzmN0bYygg9", - "Mg0Suq4nZIRtcNm9tirutVlZdekYZVFVdnonLEaMIsK6FyTPUEfACuJ3ThUoM1sLmYLOsOdesEwRzemy", - "nFgy5VJChuoJ0gUlnxBBElu0C+r4nIkxJIvEaehTbsjWTTsPnl0mJGkve/j0KJNz9skFdHaCG9WQK6ya", - "GKEinDlWtnWLpftsiERb5EM2Ay6N71NNB0+FuxfS2wTGNGunEaG2xtkUeGani7LhHZZR6rOh/+8wIWe5", - "hrlQhckW5ZjGCk3mNZzwOQziGwqQKItVMceFQjGmsj4WQtlSlVarHSxfMVnVjGtDFKod555wlXkhgJVK", - "rho1AzutFYAy5dOqpCW6zk634++h0+34E0WZWh41SpydlIV8aY/hCvrsaFTlV8Xuxi3Giny1oF70mrBl", - "OMuUdEPL8lacqnKfn520xFj7C5Q86onRaqL5rNnAyx8j3KfvNImVP0Uxc+r8rLAWtPsXdUTskYutx3Mx", - "3KaMYX1PXU8V61gRCpr3avazyLI15cneCFncMdoSe//+be9GZBlWHkS5h1VTSiAIWXZ8/OVtn13WW+QP", - "D1KYH9zMzGQY3kQOzbisyAGnLlmRX9MLjRnMlF6UACVzQoiL8fZ57zZDy5WfE0szc1uyO1Pk7qJMnJc8", - "oUReue5vArldIONlDZSaDRxKPKVAjoNld3ns9rkkjpuHaK9xnihprOYiRoG/Tpu0AIlIyVYQSLHPhlJJ", - "COJikqkRz1ap5RUbzmCW1MRSMtGqyMOXCH3Ejqmwr9gwyQsDdsgOcJzSi0GuMpEsyLjw7sPbowP6Qy/V", - "Yg4Sabdiz0r6LRumMow1mHLJfugfev9YKtKyf4lvjaOLhLpNDZWa4dFeDlkmJDQFjDssJpvMEidbaJ/0", - "h2qXLd1iZ4OxBhjcjCK9ZzRAaGXrr0RI9rP4MfTuqQdLuM11WQoaEzLLgJWhm/3lu6EnNSFroPvOsLcw", - "653JsWJpMcv77MiYYgYOEi9wHSokIn6HPjsJhpqQtKQhybiYYfXzxCkgoeuFmfEs835IjHnnLHPPLoTa", - "wCrLs8HNaIi12411OOrATzdOh3Ugd0uh4semXKfURQ0rcnpoejYSkLAOO04J6Liz8oDGF9Crd4utkXt9", - "axHG5X55MCje4X0adnH0lrDoAeB4mlvYpPl4YRgUn/gc9GOLInKsZrP4bAxjTEinXhK3ezN+x5794LR8", - "bbo1WdH4rCWj0JgoSC/A4LuAGbAkbOK78mDeMwXum0sle9qYLhuLDOhfqNtOZzBz/7nfZ1dOS/UlCvLp", - "woik4n519dCheYGN8VuQqK1RVT6w3NyYGJ7mrFIyRlh0Fk/ZM2B7eEq/1EzNai1VCWMN3b2bknwXS9pS", - "A1WHV24L9MIYMu8ZOZ3ldrEOKb0BzH17zPExwC37AcN/hFOLFBupAl06JLUQ2RFZhQUqrbmrYuP2iRTO", - "785ojh/KW+Va8wUpLWIyAT3YRAD+u9pTdBtS9H3WZOo42fD4/MNL9s5p8u5/HEG8HPoE3ppsicA97HFr", - "AisRbaoMMJ5lihJwS59UrfaH37dVTMi5uiGFudKt++z92PrnDfrQuGHD+k6GbK82jSeiWnIs6H0Moki4", - "ZKkYj0HXW2XioIS26X92dzoXiRWzPnu7Df037q2tZGP97ojflSxiW5UMEWo3beyodAp6iFC82yaqQimw", - "opttD/eH8M1NlLBWBmzPdJtSdJUrbdFAj4DoIboZljXT9Tpbej2rnQzY7snmTbGE2WVCecNd1O2MeHLj", - "FFmZDvxfwkP4Vukb0O4PU64hrf4bi+NENcSw61BU/5ieEgLMsZJjMbmPnc6/RmqV+n1bVUxpxG777rkQ", - "vI6tjwSe22S6e9zb8lkW/iSr9Q2OaQVmVDaHYCVhqrCJmgFVO6h1AnvCfVAbNPKLHqRgMRWztOYFZ4tD", - "n1yruwWqBGUXtbBPo8hL8lSbpBXc9eSFZXuZmnTZLdeyS7X89nFXjgUUk6llcJdA7qNjaH9Wq+wJ93c0", - "cYqIf5pRD1bD+IQLaWy9gmGXmSKZOgEjJGkDCc8yE5zRK5Yo327O18Oq+vo+3Uk+UFZUuVQwVu5hk3fT", - "ZTewSNWtdC8i7By6j5sLBWuebmP18r8HZU2FGViecsv7FH01eUokPMeg6ZIywsXUI26oJNhS5vOb43O6", - "pFr56SfcZahbPmpWig61oGvlok2f/SQmUzZXWTGDV0yNx058pjDmRWapsllue0LS7skw93Q7DyFlv7z1", - "hvuKWlRhe2rc8w8NtH1QdQ/yT/aCnZfsvo7qP66Rki072k3a0KCQlYmm1aAJ1WUPrRDJoJHuqZDGTFBA", - "rWbQ9xPEGf6b2oP32Zlk9TJrvgexD3AhiL1kaiasD/0SxptI9jwzv50qtGzQ5PssAz4PTfXCimo89kYP", - "t5Zf3DC444n1TqiklNeo9Dgmpgug/R1dHf9UKwTXthvjI8mwbah7YBG02PCPj8N9jNdhUvVU/qq5OQ3W", - "8Vb0x6B3yeld5BC6UozulinNUmGoi2k1dC447a7LFqpgs4Jqdaa4hbs8E4mwbOgOMnQzDBH4w4YCXlpq", - "t0Ky+yBX1QwwiaCZFyZ9drkK+D57H55lQce5gUV518sXve+gFjQktF174jdgXzIsfn0LWAKbvPney48+", - "TeOzWFXWrXVU6XpbEvWzT6Z8v89+pfzaod/RsFs5Mms45MDh8MiTxkvEJrR/BtR/xbhckEdM+QhKd/Dx", - "uM/K1i7VfHteL+mGMEbqdtitizdSHIYVTySDa4QTIqKMwF0z+jKt6rOj6kgeUKESBm3Sn4QlGXBN9GXj", - "kKUDDH2jgmGFrnvUrybzXcaJMe6TI81Wczgkn4KGV5iznKlbw3hh1YxbHzfmHqToUeX1a2oyloiHxh9v", - "29CZVk3+Y7cDd0787DrTKY4Ks2xDcI0Ru5Hda6VvuUaGpMblvdRgZhWxCQva0UEKxmJJLgfApdBZLEBa", - "u92XjC7AYywrJDYPDywnW5TY4uDYRfWCzAi8vg4DmWLbHyz9rtVcGKEkpKG05y9vI/zXbToQDPHeOscP", - "/JPeR06LnnI5ieODslm+KwjfX7053x2MK6N2A6UbfoA6o7/28Py7hyiOIILAZ6RDliqUNBAjpMytXkKq", - "z9432Emf/YROAAbjsZN1e2GHli/cw8BxpjnsE/DdZxshvrVwOvYO8KC8wKl7Pe1KJdRAjEw8I2zIm7Lg", - "Wq9uAQO5vEfFeD8UxYZQeftVQMzAGK/Cr9ps4mEn5WoDmnrGc0PdhjD64GAsMiB55P1nB454pbvBg1wr", - "9/NBKkye8QVzIuJVmVHgJ8TKvE7Z8IH2Dt+5Fb5wUb2raHMnaLapzxS1gMQ7Mr7PvZyt7nK5B2O/EQOi", - "8kG4f6oHp239D77hKV6Au2rHi/0luP/w5w8fimI2GGd8Ygg+7oo2e4TDmQMIY0aqY/eCfKsKA7508I4R", - "qaPC2lhpFJyS0a9k5CXxjrK4dk8ZjG2n29FOnXFbFWmaBZsWOc4dPUfhhI/flhKKV96aht/4x39tVfdY", - "7nQ7GKODn0QXmKosHdzAwsSOl1Lcq/vZnc99W+8zR7PW3AirQbBLLgFZzAb0nqflkC11Xj5bpvR3mOWI", - "pkIxA09YOXiLZlh31UZ6t3qK/2SJUk608qoqAN1YrihsMzpTpHjpf91npiV0veu4qVuQNB8prlNfMmFH", - "HI3XgTz2IjYJk1MRSJ/vsznK100a3Sz1FNRHlVXoHoZ73yBce9x1UIY7SAqLnpCca1+GHFm9V1SpPw3p", - "EvT89Cz+Wlaz5JQjT17E1Y7tNNpdAr7l3Ad+bM41n4EFbfrX8tS/OJUsf6eRjeqoaNMOOjpKybQl5ghJ", - "eeZ4xiZFZpVhfex2Us0n2w0/0XyyPHqm5rDd6LdqDsujMVLAsYlNg8/dhz/DojaWrHWbBl7iV/VhYAdJ", - "oY3a+Aa4BHuMH9ZHZwAb9cVL95FH4Vp00mpsXPBbrGBYQw7X4Nu4b5o59ACprrK8mgZsGycPB4lx7mrS", - "Dcd0cuIK7mx5PctUHi9q3u0ca+AWTrCuvdKL+wnPmUphjaaRhtmZ+5DtqQSjQvCUXYbRk//6ww/7fXZC", - "wgJlwb/+8AMqcdy691DnZef//dth719/++P77ouP/xRPj7XTSJrByKjMcZtqE+5DtEzg0ZcWOej/82Zn", - "qFspdpknkIGFc26n97vHDUcIG09xmcff+AUkKPsm99t9zPF5tpLGo8MitZOwoyyfclnMQIuEKc2mi3wK", - "chn+vPf7Ue+vh70/9377l3/arrLLCamfW77ylsrBoW2qXeAG1Z6+qwrbtNTwwf66A80tbJ7Sf800dvOV", - "7Kff2d6ML5z4kUWWMTFGC00KFhIMC9mPLnor0hhCLa+Gn63df/RqlyXQ0yjcjm22KNulkk1adzSqF9zj", - "o66HHi6rKifuk5X6hiOwtwAybMQp2j4Wn2vrsdfxf8YzVaZAWyxaMRNSzNxGD2MwWdvw1ie/YUAdC1+u", - "7C24TR1paaAbcnuZlcH0ZqaUnf47WczRZovG3WC0cxq3O8OIG//UxwWRv2QgJ/4c/I7O8ezw8PCwdq4f", - "ogd7yCvDHWGnR0acU77XWGmJZcKgWvm3uy5b/FZX6XMutClhF+rN305FRpuYYPTWW6fqed2Rccsy4May", - "59QSG4085U6Xt1wPjSwDp57j5VX/sXyatT8SLBs47OAa8a2yaTHjspeJG2A/wu8Cq9TqOVTYjBC+5Qs6", - "CBPSWODY1SATErh3zuYq82bHXzHSyK2GRgIzyEEPDEwQ04gcIB8gkQ1mBq3bYiJVs9pVLfa88XnjSD/s", - "SJdl+R3c1woEz2gXq9SwkT5Xztl8xR62P2PLLSFu0b6wFKq/Lx+0imyifYPsLW2PPWvs9dnmcJ424V6a", - "4bY1iC1NvM7sckpvufOML26RC28rDOLtnmqvw2pKTHeLRNqnLfYS6v9w8B98zumflC9XzU3PTPzjlBvG", - "sS2/+/27nE/guy77zufIf0evy++8o+I7NudaOHHrn46zPIOX7LrDb7mw6P/pT5RVe99Nrc3Ny4MDoG/6", - "iZp9t/+KabCFlqz2OWb37u2/uu7EgvCoLBuV50gaePinFTx8S9zanxGfML5lesjfCOo1E4b96bDB4b9v", - "8PfNuIaXvyU+GNzwjugQ+pMtYUF1ulVDe8DypcwW7MbpUdjpTdX9+Eao8b4mftOr70SKzydIVhGBuLk9", - "SkTfJzaSgo7s5zKEs1Kb0DKSsX6wiCU3VbFyxOVkPnRpy9kKRPh10QFQv21ImR+Cbaji3oBG+ppfIIYg", - "r0UGZ3KsVvmRMINU6PW7QvmFjvvyOdfSt061lvl0onyGCokP6g3V18rkppRb6PkqwKuZJ1G+445Fr9uR", - "sD5HvcuuO6m+vdM993/XHfewue709G1P99z/XXfiEaTxONUfuYFGGuJYhDCE1ZvY+lUcdNZVJBG/w2C0", - "sBDBk0sfgIo/931F0bANAWaL2NMQR8xRr68t1g14UIOhv/Q2dKIg45a0x9elj4aR57Gtbeo26MfRpwbp", - "9nh4X1iWS90XqLthSdws5rMCFznUbWDHF6dHV6edbufXizP835PTN6f4j4vTd0dvT7fI8KPkvlaFBXs9", - "rXje4/A9Ee6/QvZqIX0V+7LwT+lU9RF1oduI59s/UwQ9BkVWCSi8TGHjGbP8Tkk1W7zE9FYqI+G9o9Xs", - "xmrgM58wMEy55RS0ofQMNQslS1ijDuG2MoJM3bI9snDTlsj07WOThu33MOwyDROuU3TzY0CAYnkxygRm", - "JgvbZ8c8y0D3qj/6C8AQpfeXV+yg3P2B/ynk1ZZJjMH9LAzd7CtmANhwaS/lexQ7f5opz6HPfuGZSMum", - "AgluJmSn1KNXhSkvOKT+JL5k0XcmtLcKHlHUkdIK4iTwZzzPHZo5HSMXA7fWhuiBo1y46yGU6oZ47AFG", - "Sw+C8F87gw+wvnQjSFspJ0vzgQ9Y2jRHmh/Th/Wx7njbDj8pvy1noKikgdeG1k9A36KGtDw+U5PtRr9R", - "kzC2FvlEDsANM5xV36MzJDYPuiO2neVnWMTmIAt8WZds6+nIXdGotdftZGIOg7mA2y2B/EbM4RcBt0uQ", - "rqbZGt5hplWg+8Cu2lQbj/mWhpzURizPJqSwA68jbzXZmRS21u2/NpUGv8pO812EURsm3Xm+1bnqwdPb", - "THVZfh9mqhcz3K5x6lmawfJoxx2FnGx3TX6eNzSmeUnLvcd37uvemMN3LN29H2yn29oJ7p4998KMS32h", - "tm5+1KTm1TY/u3dRKqdJ8h16apSjFE93KV4extUK8O5c3Hh1jh3usaUKaXelBN2u1f1q6V6heNPOhbE6", - "3ZV6E7uW8vCp2O5lsHiH2jspqB+7HSVh+9SEZfn4sbvLsJpQ3nJgjIZ3HVqn3N3GRpjQbhNU3HDLcTG8", - "3mFonLnsMEFFkTsMWsL4XZZb5jq7jA08Z/f16iR+L8DcZ4a4Yrj74FIf3H1oRPfbcpIWDWG30at62W7j", - "V1Sdew6/Bz23KINbjm68zLZlmUvvqO2HLavSW46M6vQ7jr3n0m3vzi2HR8XdfatQUseJN8JYNLJFDFJa", - "84V7/q+at4QkayslHdhgNdyqWEVpQo74hUtxG6k3mqnJcv2AWnP1tRHjy52iJqVHwcKdbe3s09KB5ErM", - "fH+8ckfUP5By5Le1Rbe46epLx6xrGGBx7qNZL0rdftkcv22YbQhiu394bdsMW4fVrkQz7haJ8ogRGRje", - "98BYjFQYy2UCDQfdD08dgeH2vFMExsPDErwVvYpBcP/k0i7dYtywvgk9qxCPgGHMqnuh6bYz7YSu948R", - "TMHYwaZYx1pKV/DwbAoV7HaMTjZNTEX4tp5z2S8YFujWThG7ofc3db60g+P4L1TMnr3/OZiOYZWvq5uN", - "WHtGzS3ABM9nf7PXU91Ez3LObTL1YYj3g3hbHOJJe/xhySievzjcPRrxpDUKsc/OxiHZr8sK47P8pmIy", - "BWOrir80JHBFDYg+Xsh6P9KfDrvfH3af/9B9dvhbfIt4td6gtgleYx+lpGHseAclaYnfgVhwWVHEKSFl", - "AOqBBjymMIyy4uKcxmd7VTlPq0Gu1epUljZkwvnCtdX5gw/SKgbSFFSLmKc8p5hnCbehamAVqoE4gXc5", - "BZ6Oi6xLucvhL1kLeraGf560hn2WaPP988PtgkCXcwHuJ3k3BGgGqRvEFlUzWRiKylxuflhDUQfuwy59", - "yzUwi6XTNseArRGkZVD7bJNEvYEFVV9kxl2Ol+jbC9j4+m98aKOb3SxmI0UFXnChPjvlyZS5JUIrjxEw", - "XvuWmSKvKgXepcoqlV3LPQPA/vPZMzzLYsZSGGNZfSXNfp/5QCdTVrC87lxg+Mt1p8uuO2iToH8eW53R", - "v44y/6fXP1x3+tcU3kgRcMJQfGaCG+SZUW6XiZqNvMgyPieA5vsXGyIn8L9wtX+54iOcdocLXeLWeLtR", - "fk31uU7vIHm0WDbujjfDeMmFdHxEYgnxVdHE9aQZFvm3SLUimonrSVH2ON0eq7gZaKWaQY3xYxTNmtxY", - "e8ANZbkWc5HBBFrYDjeDwqf1r58ytAJ0X7upZJGh9Ag8fjVTks4eiVTAiw6FOcwUsqy8cicLinhHteQ2", - "lpitNBYOrx6re7weWbHvZ/S+alqEWuQuH2CzzgVy3o5ef8Ti2T3M/vi4DLBTORdaSXx4lHGKWBHatzKK", - "V5+rMH8l1nC38MJ2ALZHERI4N5Lhg0IIeZ3oSoCV51glwrXvwdPy/G2PwXhlP7gTdhCPWT0PtQ1Da4eW", - "QvUYUTgY/elFPKCoVo6JPmWjYjxu6ZlHEYXbTqYK2z7Zx3bo/SyqdL/dwHdJjS0Qe2VZBKGGvU2QUc2Y", - "BlPrXJ1evO2sn7ce1uQ///nszZtOt3P27qrT7fz04XxzNJNfew0SX6Aqel9pQtVn2fnVf/VGPLlplhFe", - "jonOTLwXZdnZJlFZMaPGjuvifbsdrW43zeU+2TFIHWft0kbX3Nhlzm9l/cK2KgoWEd2r3YF9NVcYWLvY", - "LAWP/NeMs9xAkapeefq986v/2l9mrKTZoyAqQ1DmQBKpRVzGgRYaNy0DzldtqR0Cw6aWUxt2AOnKSu6z", - "+y/zMdqXuAnXe/Dzs5rBmI8cQ+LMuNnW0UO0Fuv7yxJYbT1BQrXb2PBLLJrYK7u3RnqH1fZT2nGLQqRx", - "Roytlgfcxu3E1I9hpUOKH7aDqbiV1Cy3hdm1Pl2tLFphSMq2c6W8GORJrFGpsWKGcZvH5x9Ygfb0HHQC", - "0vJJrCH2WjFadUYSzWq+U258b7FtdBQqad8S+VztOBQID/XJafdlUHSLBI+aW84rmNpGpG3VdYe2H5dF", - "7YBNhbyf0DnhljtOdqsFGUCXUI+SDoTMi0ggdcot30qxSOurbG6KU87728YzP0hfdNvxCZ7GTbd6QveF", - "BdmGJFVGGH7A/Of9zrYmFX8UDbyKat9Fd7o8LevAa8g1GMehak3AfLaI0isFRx8KzdKxViGLO0VUBYW4", - "n+5Nc0sr4eeOFKKpvluxhpKR0uTCsGsceN1pI1m3/4gUIEO4D/tWtdY8ybSQN80KSpi8U6YEbUnEFLeN", - "8H+YHWKk0gW1sqUpQ0VMugDpqXs5lH199/1YnkBZjpSVNjK0U6RzYZRevPT1JW+kug2r+0ovoedc2RR9", - "qVooL+xUaWExuzKjItGUZmpqJT/77Izq32F7R+NLahWSFkwKYx1uLnIwXYcGZHvFClzEY5qtaULZ6ar6", - "cDeUKa/XSq7qPzcqapcFbRt1ectI8yrydG0rqraynXR5nsT7D+47tSH3Y3379W3rjFBtCdDx3K+xkJik", - "sI0aVBWQCKPalKCN9iTS71b/bMpKGLXfG2nMWytt1W79oHtudumeUZms7zN251UM0gVMtqnhtJ3f6Sdf", - "szXU85h4I8ia6hctnohf0QOxy0RbRiXQXN+551jey2DsuL+W8KA4hR3mjLqCwy10w8VuAtl9PCq6BPSG", - "QkxNxIiKoGa5pl291Jnlg7v1jp2flBa/K4nFgHAtxmeqkLbPKDzFPZzx74ZhCnCXSZjwxt8dHOKSm3aw", - "ofbHL27HyRbrp+pWRpYv8vjiD4nEKAtGbW/U30QV3PoSmVVVq+ZSuxPFzlNuHR6xUuprR64l0hTkhuRm", - "CuOofGR+0EYfv/+uZduvRQbnoGcCu/yb++0fO/nFDW/U5I/yRjX7S8N6sWuCcqQG159evNjfreSWupUx", - "P4/bK/6Enp2w3w8t+90mmZXyKvPqbsmdS55DX1D4nuWw1iQX12vH7dgthhcG6qUGqIJ/Domj/bT0Hezo", - "fKh7wrFoXMz3UC/q0AgaO9xIlPXFoxfiVJjX5lduk0etcFaWn0NzAFaCjJdlcIQr5rDZbltSu5+PlWOz", - "xRaxPK2RSXgDD6yTNtZ8BvHIm4tKtw0fORCPc0exc9BapGDCW8nfwH4d5s8PNxmBoybR8GCLGDNrCiwg", - "7T1StTbcdEDoM3lJCNzueKz2UXe8hQDM9bez9kJm/A6rCIjf4Uy+/bF9BxjFHJpvvf1xS4gsF8961hKQ", - "5U53VKRCbUbuY99SgbvPqQAZtmqeixRUn10QIpv6u9rpGXwO7uFPo3wkn3tKnxeZgSP/1+QGbL3YODan", - "w/R4ZsAaNlJ2Wis3vu9rRFGQUhNfhKEd9dyLvL9lEfFLq/KH0pfSCbh5Nt/k2WwGqeAWsgV2WccoB1VY", - "NtE8gXGRMTMtrFP+fHGAGYbFoalQSIzr0LrApg14VMSRuJtnl+qIBDC3oScsjVhl8cs5ZCrfNdbyCivQ", - "0VBWukMsdrKtlYthSxUIIiXygyFwbYHTZh0ILB77j1Zbem+mpLJKiqQMvmLkRKh2yhOtDBFJJsZQ7yHq", - "G2OxD8Z34n3Dje3hyr2zEx9dWPgg/svL02AH9OZPYahSHFmUVnpm7+AudWcMltLf1sKwLelhqQAGlb66", - "FRp6Gcwh87YkLNqAhbDyWnEMD7mqRwAGToTQOrl0+j470iNhNdehjoVXL6mbki+KUZWAcAwspcn67PVK", - "27x1lTq6sRIbuGPQPbRZEdqwVCUYJAVlB+ehN4L9s69dcbD0lxOctxYA12WrBTo2tZtfax79oo2MFQj/", - "4/L9u9LGGINPJoy/1/WFSqhuE7kjluHVrNkdgwQB0l3407XXvwQbsMyLy9JN0Npt3zpe7zvUlh33t2+4", - "j931G/32G632G5WQ631UkEvh7nyI645d+Z/WyFvC/jJ4Ou/hU25rYrQaLJnnmWixwv7Ks6yXZCq5oSur", - "zBW1y2y2v3Lw9VNSno4N5RkbnVnqnZG2d8B3fQuPnXsdlR2O7inuvETLuLErkrjqTa/BgA0SsXkt9Lw2", - "/bWS7HCLWD88CJ0jijtLFcx3tjc+rM7vDSyM1eoGTLQ2ZzT6JV4/9F55USFgs9pHyAur5Uc5TnSHjcYz", - "vuhfywaT0AWwvdBhehYy4g7SUKV5v88uqY9emVBwLX0EuGMBbi3UdbhkKrwHa+s1bort4d/+/dDdi0/b", - "2u9fy1q9WGxC4W5tkZOUuFU6xVbqKflIfUhxeXIhreY99xUtaK6l0xskpzJcKBDp55wXxsHpClvKub0R", - "h3Z7WQO6aCOjbktXDYeKeK/YFoCEwVRh2Do1tGgpo6YGjmASWI+L2E14yp2Ad7r+IldMyL/7dnvu1f+K", - "zYSx/AZIUUI5iToI3tmIJzcm5wlUSMAO++y9zBaehZnYDbA9IzKQNls07ulaVp8hbuzTVZVP2MP+syjW", - "h7CcbTuK/KqFhbIHyv0IfT20GgEroexfWPC+rVA+Yn9ccltivdbOy47XRs+wmS47Oj/rdDtz0Ia2c9h/", - "1j9EA2kOkuei87Lzff+w/70veocHOQj5RAfUD4mMY0nEOvYW9AQwNwi/JBSAO2EwqENJMF1W5E74sKVJ", - "IxlJc+GeZzlo9MqnXSIyLEhbSCsy6sccvj6B+ZVSmWHXHVT3pJCT6w7mLWdCYgMrNUKdKWUjGCsdKqOi", - "vcinziEylR0ez1K0j9pkGlZ57ftB+VpFP6p0QcGsVY+cKk374O+GrLEkMSOu5HCbS9pFOBLdoVVshtfq", - "K3X+7brT690IZW4obaXX8909e5O8uO78tn//TBPaUBytqu8cfVKyGWYt4jrPDw8jhnzcP8E7xZdVeTQP", - "7OV6rR+7nRc0U0zzKFc8+JEHmqSK0R+7nR+2GYdlMyTP/CisMDubcfcU6nwgvCy3mPFCJlMPBLd5v2cc", - "VmFv2U1sE1UUBnQvdOSplgEsY66FAUad2VhlqytDXka8/LnvsKp7LTeSC9udWq7lruRyDBorz4dbCJ2I", - "3SPlxj+D5VjzUKTSYzE7DY3XLn07wu61xLbqPSxNDmk5I52jnD+gIRp9j0/OD0J2OvYw1cBGTpOG9Fqi", - "hSPc5UbKPq+awt2XuOOiIaZRbQP8Pvs55AL6nySfgbmWez7jzEvTY6VuBBh/j9cd6uSKpZ+962lazkB/", - "7V/LSwAWCn9TV7xqJ/2JUpMMSsQ+IJdQmS8b/u6DkCjjzp3/R25EclTY6fs56J+szU9DQ0m6g+iG0bTk", - "PjYf8onmKZhylBeqb/ndcWlJMOegzx2edF5+/7zbOVd5kZujLFO3kL5W+oPODDo/V4uad377+Fh8LeDK", - "V8valtHOnaWdwxV5pnjaq3ol9rhMe+Fbx/aUiSg6H3AYlZPVbOY4SDkF+13kjOtkKuaOwuHOYqNCO4UZ", - "K2QKmh1M1QwOiIVUvSrNwXVxePh94kgB/wXda+neg9rxuFl9BeLbQt5D0Sg557X8hIoG3VfJGM2RTC/8", - "Ha/jSbMisyLHHp9Kz3rBVtamc9Q6XrYm7FbfOOWDwE8BkokVc24b1Tea08eLSL9WmYMputetYnnGE/DF", - "3wO4doP6kkvhqPdX3vv9sPfn/qD32x/Pus9/+CEeBfC7yAfYyHNli3+tEDK0U/HRp4XMKZepIp9y13vY", - "aS8kG8+4FGMwFkX0ft0KMRLSUeImrb7cnq/GHXuZrFXgatC9nxb3LBaRXGIDoQKk3Qi3I6opiQOjVXn6", - "ufneCgsqoVlD8j1uHEMy+3UmWB7Rc0P/lj4YBR0vzvVOQx61ZGqpxc9Sf0lDbjnffPLo/AxLT/fZkf8V", - "JT+FKzl1hqxlVvgu5iIDDMcKIdJ3SVYYh7xO/ekyo5hUTGFgASY/VH3rDUu4JBsFdr/G/iAh+sNYlZtg", - "RBgLbazv/hBaV4aLZ6KsO0LWytCSktryXstQoLww6JzEnsFTT1UpUAaXexdWdkBMzqGCOm61G1hQj1B/", - "XdcyeDxzvnCzeEcE06qQac9qkTOnOsqEYsgBCwzIVMxFWvDMTxPjvD+iItjsIXp/NXCtzXR1paoN4v2U", - "EZyypf3F56S9khCoX2qUAOo4vURmS+1JA7E1AVc1Jn0ieEU6n94TTNQrLvR1DWT9WSF0KWZFRgmjRHX1", - "zs1xQ+IKjMhcdeBYfTuYLoCnxzXTVuy2HgtczabFCK2lt1fZe9gviXJqhW4efLvu0GRZLjONVqx8bdeJ", - "tsH2+2waJ58I9eMW0PuiP1o9fXYZNjQtofDFMKxfySAbjOlbwKtsBxwHUxkd/EQQWm00vDVwHmX9Wumz", - "GJ1R4PJchJYY5Wv5i4H4TyL1RVjUbb2+YxPMzUbXca0Pa0uh1oIh8oGhUkfObumkcpobD1UV3bLaklcI", - "Qw/kcpfOiZiHRoikmGbADaBuVe8vtaGFZEzjKRuiPhFqrrb8viffcBN9IeISt1JVziQwcYTDEsZMwBLC", - "DMpO/K1M4i9gG1VOn1I8xsupxmkXow7opOUhHuMW/wK2EdjgNQ9iFmGlbZSPZgf5+OWW1VafCM1Xe9M/", - "SDv0t+BO9nlR/W0oItqATpCKZWpAxWnMNhBrdO1fw0dDOHC5DrrxkWfW/P1lXgLZyasEmVq5uWsZKyJH", - "IWJY6CzXMAVJ7+bVanVdZgCupdtMvOIc47Yyo0+E7Y81QArmxqq8r/Tk4M79v1wrqw7unj2jf+QZF/KA", - "Jkth3J8SP/fhXFMllTb1wA8f/RjO617UPuo+8VeB+RXGm9AICiqNejx8CcQnIoflCov3pQYEKGLLl6Qt", - "kIyv25IQL7dA/HrLnjZWdcVv4LIeGvkkGuNKyuZHD6O1EgcDWQ9ySjGuVtps3VwRLNUGKDr2swK0zE1g", - "FYBCENoGcKosa2dilIzK5j5hk6oAHChH2yGJ1P3N1nS8GidtaosNO1+jjqdXAxvZoL6ttWSZmmCuqBXJ", - "jWF7UlmfqUwmzhoGsRFM+Vw4lOYLNud68YrZAq10vot/regAxkxhWkV1FHI3huRUTGX1tkvv6u42iib4", - "kB/09DRMmnvlHKgKVwvsU9wHWpEoWCjEggdWOAyxYWTA6PU05MAte8d6PQq6OmTkQSCFnHwIwxiHvAw5", - "oU9EfrUs5ftyR49eX4gNiTZT6QoEHm6dZryDNheCfluYow+4fCK4LMdzPsjIQUGEX4zUcmcjo8Y6KPgY", - "4XaeVtUSDu5G5v4fhSEvlsOTkWuVLiJjuVPQrMpzTMZIgO1RQEL3WnqfbOWN6TrGgflr3h3Xrel8vhy0", - "Eb8LOdn3r+ZyIVEWG2NwxxObLa4lLtfwTGngqZBOlrvXs3uPYxR1WGNIJbQLnQ1xPc92OBuBsT0Yj5W2", - "17LqR1YWzg6zBi+FmxkVNfew4RNglJ7wo+ONDgihiame8QxDTa26lsOgTg59AwYuF3jTbKEKlioMgZbg", - "dnxkWQbcKa0yGJYpPsN9jX7JETBfUql/LS9C4EwTVtT7XxeyrHiMbquXtfibOmw8BLrkXu+iciyXIdaP", - "ggSL3RA4SPSBTCkwtkzaoZj1a2k1lyaoty+ZGDOOrh1dhf+4faOzyW2Q68yJxYroGCYZAjYmDplwMy6k", - "wwdcmwKBE/C46v4klew9v7vz/q5cq5xPnEDuX8tzDWNUrd31ODFmIOeY8Tqsogv+eUjJQwf+joboz/PR", - "rUQ2GQTvYs9qMZmA05OuJcGAKElIhKdPYK3C92PCKtzycUm/jxgoQGFBg3p421J8x9Xr3r/53Jtm7BKb", - "8Zz9n//1vxnGeBuYcWlFgkWUz4+ujn9iq9Fz8ZrH/qtBS6BkbQfk42bDP64piPG687IeJ/nbx+GWG8LR", - "0d14sG6zjZljGqiZxN9Jq30WhmwPS64cUMGVA7BJPySsUr3xEFC9ikAUUm66wT+Lab9lgsgyNxYVK26E", - "LTUotUmk0ZJoa+JITuthPgatkGH3iZNYSYGVSaop+hgZQseoMgPWxh3t9zcHoTw4ROTp4zcwZtwNGXje", - "uXqbluv+78bGolMw7QsMXu+wETuDwaY+jdEzZ88KTJ95dhbir3zJCiyY7htcVYGDfrD7f+ag1jgfNXgD", - "mRu/h+52CrVjQx/md0CroGN/uE8JqkN3b/mgIokhSQVkkQRuH88QDmunvIyvMU7e4Qe3muc5rDTy3wgu", - "Xw7LCfcIGV+8Kb0/XryDF+4VF14rvktbUJdlICdkn0840Zplzw9f/BvVWexWpOcAmGCwL4VRII/wAKBd", - "jDJoqYvdvMs1SluVYBVuEL0H1VjK4dYiJ2flEk6WWLHnZGRZWchnEmFtfLgjityYzP1FuagampDnl68q", - "dbPEAjdzBsu+q/5DFPsXh3/ePM5tMBPJynPgcZzly9pDeD603hOgwuX+F3l5GdOdsnzK8YrrL48j1Gfo", - "2Z6WCg0+5X12blMTzbPCrNx9qPh1UJO+ZZR9JJzbS9WnMnBGGiR9Yoz2q4dky1VgffBe1vBWalzyZ8PY", - "B8cutxzHocbYHCQauIVB2QcD0aSIRQzhh2URn6cKG2qushOqPFtXc4jO+QWZF+ikjGPOV3X9AS4pOLa5", - "BVxO8MOnhgutUm9od2+/dAkSOmL6MMp6sXncO2Vfq0Kmj+jQxp0z3g63oAevAdlrUne/bGhhRbn/AYBC", - "eJQwUrfSacyOuga/CywhNAEbq9RlCy0N4+yvZ+esfAvU3hDhaVAWlamqvwXU6K/GkPj1T4T+q8gxIl/z", - "GVjQBttftDV8LCkHdVCrSl3fqQbhUPi6c+P+UQCyA3rThTp4TRzo1o0Ym+rq/baTcPb3+iCnl7v1cMay", - "dhIiVv2Cv0a89MCqsxD3GiBECw/aOL4am26BsOHtu2e5rj2AZ8E5jHqom2t/LV5fyzWIzf5qbMrUeAza", - "MCMmUoxFwjH1fMwNPf9oQa+/XssU6n9y/+aaXoC/i9wbXHgyFTDHdrlgl2dBMopHZtWoyt3R10JW3T9W", - "m7+Vx8UIhj77SUymoOm/yh7SzMx4ltXNEaPCMstvgGVKTkD3r2WPIGHsS/bfDto0BXvWZT7x3wEWUrb3", - "398fHvZ+ODxkb388MPtuoC9s0Bz4fZeNeMZl4lQpN/IAIcD2/vvZD7WxBLjm0H/tBniGIT8c9v6tMWhl", - "m8+6+NdyxPPD3otyRAtEatgywGk6dXBUraPCv6pKTf6qOt3ab7Rl/IeJtSTYlSt66n0QW7xasmv9/4Q1", - "LpnzSvaIBpdQu8GzxSZrKJvJb8sTkBP4a13pa/+lSNjddMKqof4qQqGWV+vW/xWizV/A1k9Qto9agV6J", - "NpkwFvV004o3b4TBes/mnsLk68SU6tQRVKmebxnVJvkKcQWzdRHylEi4ihvYKL/t+RZauz9haOxjPN0w", - "FLUyd3yFcMITYDNv9HKtI2YNPC0f3VFavgCe+if3dqSMiwWV0M3/pVCzSizYXtW06EG6BLL+aB7XV4Ys", - "mDXWcNeVyGGAGP2gVlu+lbpXS/w/XRJSSy+Be1fXqJXO9ylDXyEgL8GuEnq9LcABth0wU5GXECYPaHsQ", - "FtY5MTVHqc8dV7qKLyGB4EP1NcyU5wGUy9ZvqToR1INHix4pNZIWF30Kxg42tFNw3/g+6yUH81XTvEK7", - "TSOFbue+3nzvya+2unM5BrqFR6vEgFAqizB87awuUpxh7PW1OjkE0+baIjMcDS8Ug4Yds6mejLCmsm2u", - "pK8s41cbcZB189FIY1fUT+sdJ2qVcqoYCbUdHTxSZMs6ergnYv9V5BVa1wD4PwbJeb3g0RKKruC7N65s", - "QPhdTaNtdHEtNxPGZhNpwyJ6LZdMou3ljryN89GIqzWK6moKy6aXUoRsETf02Yg2HuXTVqz13faBPr6N", - "l98bFjPC8r4OnXo9/KZXjdvv71ZDOcDhSdjFkb/D/+EsYxldW9jG7XJBoqWXQK0R0lO9ASK9lraH7T2L", - "p+Kxo23PP0jxjwJiDYIqqrz117FVvNpyvXabTNlj1/j7TMhGh6kbqX2hJjmpaWJ4Wwd/hCv/6MuYAxUp", - "WcY3lVfotmSkQMODtzR4u0MJx3W2h82mhhexwvoEKAp2/soBdYktf0JceczatwykA8qRazUlUdfu1+aU", - "PvuEsFo2C1m4s7TbqD1okz/gEp+2vtlOJOe0anqjxrW3sM8hxCanPMVT/9H5z97l5WnPlw/qXUVbUbyF", - "VHBfbX2MXWWw9YZPSdxbZmL7Dc9d8NKtsLqIU+7j14im1F1o+ZZ9yRNiuyXGusf8+iAjLMqzjcHzpKZ8", - "8RXj5yf0e7+vGhKENpatHSwbvVP+9OJF2zax7WPLttb2vSTi20biP9Ace09rRlkS6msXo2iWcpIzxENW", - "oVqZmpiD6mLjLjo1MUQ6LXx4CSF8d6F1mBsYjUfxqr5ttKt/fJmxyjJ1G488aLT+rvXJWwYzJniUaXti", - "HNr5CcP81tYQZrtU2WWd2tnjq1UfDHJqU9P5bBLtjZpsKcocYn3R0ismGdymKYfy8vKUCCTP+OJWU9ob", - "FY3corxq2fzrvBzNEsds0Rc61mCmtaa2CJo7y/iEC2noJR6yEHQhsYSzVJJlKuHZVBn78s/Pnz+n7FSc", - "dcoN9pwzyKq/y/kEvuuy7/y831FCz3d+yu/KTjGhSoPvw+hjMXDGanNYKtcWWlat3wJ6xQwn/gqqcx+T", - "dHiKl93KWp8p6yGyD3eh8WSV8nK/xHKo1RGw7MAl7pwwIoKcnkCIJyF1tD/0fYMtt9CT1fcpV/hMeNDY", - "QRsGVNWMtf/miyiDm6jZzHEJs5DJVCupChOq3gYAm5zfyo0QvsSvnhTEuMTnhbHfQhuQ8efPXPxkFbZ8", - "DXD/8P/At/mNaFYQigL6Z4GlaDa/y6uZ16qEpSZfFCJ9yGPhXgB1p/kiK5W+//mrjC9wrERM3EvTKhbU", - "1naMo8IAG3Hugj77H4N1dJ5vePd4AUpYX4Kz86v/6o2olcJm5DOW26LdFBlYPn31qXHvieUYHSomwvwv", - "X2WUsgcAM+F47aBPxRY6DX71P4br4HE+s/5EW2jTn35cYOsOMr99tRa3SvIxwrO1eKgKu8kQV12eKuxa", - "i9xn4kcPsCyVZ3PDtrQxhdtVhc0L6qqfiTEkiySDbw6Up3Og1LBaFXbJYKYhwXKhk4PKCRvnrpQ5fBG+", - "f9JE7XKVzbVll9M9/cDPl6L9mWpblInduYa5wDcjI+BCyuYiBVXzI9Sg7pPLWrlYyD6rA36t96x0WvnV", - "db3JPlUh8038G9Vci1Cr23sFyuFtjixkenE3Fu/9ftT762Hvz73f/uWf7sUa8cIOZvmLB6cTVBjpYx4b", - "DK78tfdaSGxS3zuKNXoWMzCWz3LH5Kg5P1p2q6lpcJ/9peCaSwsULzcCdvH6+Pvvv/9zf70HpLGVS4pH", - "uddOfCzLfTfitvL88Pk6wsbiciLLmMBikRMNxnRZjv0smNULsn1SjcfmdV+A1Yve0dj9sFoKt5hMKFcU", - "22pgB0ghWdUwP3Rf1AsiguoQZSzbs0gs28evOOGUSvEapEVqoL4FR8kESY/W/MELT9jmof0pynyAdQIl", - "rEaZnitB9iv0GhpX6nKXj5Zgx7OsPm3z2lY6oEZC755a+DYXWSt7n60jUc8EvsIKUXgDZRX3iq/12Xsq", - "OVvndTlodnaCLRCxtvlEGItdGrFkteMg/VUoq3wdkFX+9DCurXF/9cqHwn3eguFW5U3xQ9dtEp6BVb+D", - "Vge+n/3aNiH0VnAT/fKWiha6GbDwh2Julq4DLtdphs+XMfvp6uqcWc3HY5EwJZmwfXbMsyzUCjk6P6MS", - "2cK4KW+dtLrlN8CEZSNIeGGAfZDiRvOxpV9D5/HEN3a6Ad+kZBGKGISck1/eRkt90DEv3cmv1F9Bq842", - "YY34fc+qnjsl83eVPgpwzlKY5cqS2PAz471CuNXaFfVXAQdyPdwuwFilwfiymTR1eZSyE0G1RtfxX3WL", - "KgTeZnMzpDWgRiPSDAigNLZUc355y6TypUSwcrbxus0UspRxB7aol10+HDYgnwg0NPEmyFjIYOZ0n42F", - "duoNmcpRzVJ7fRY+fnH4golx7Tuq2l0VSY22nvkL2KtyP09o/SoXubTcRs3uV/ED3ld3W+1u1T5/Wbly", - "iZ1x7ZtgUL4rAaQVECjVEm5hQpV44c5dlnCIYbB+RL2OChupdIHVZCmoO30VXnL1KTRYTuOELjHBUId+", - "sxPome/rz2AO9a07fPULUk4M0cZLhl3+WZIB1yYUbaqdNtbFyN1iE5meoFMvBWCUy9QLbn46W+69sfkr", - "zpz2BT/XkVER67oDdgPdBCx+fvisicW3nNC4ZoWpMPqVD85y4w7dOGHdAIfoGSQhgEvltifkS8Yr0T/l", - "1mO5m71ObXt8qQQuJetJZTG43xGxUxx0AV2mdKCkQDxB4u+3Es0rEgTu/0qp4QXibkz7vLCfj86+eLra", - "NX/paTZk4PMGOF2uE3kNNaSWkBJXD8/k37FfB5fkC2Ai5KZWC5Brossm3Df1w6TKBAuSL2+jTvKHRGP4", - "tTFiIiFlIOeQqRwqZdEvaxhPg7nz+eGLyO9jkdGzcU+qsHwoce2TzfDb70xFuMJUtIuE/eLw0Gltc56J", - "lJfd81uafZwXo0yYSu6RA+eJvJi0Fi7xmbyY1Tk9kKKRfgiOnHbrWHUJ0YTr0KWggjf1G0ugT9Qb0d9p", - "Qp4kkCN6FbaC9Hpce0USJGzlAbXhm00HacItSGKZ2FYcncsWf5DUPHgOrOnzq2Ymgu2zU55M2VjzGQVC", - "Y/kNpWdsKNKX7A8D//h4fS1TbvlL9kcAQc/B2/39+loOnbSku/e9CMoWcQkY05spqaySIkEHYw7aoOkt", - "0cqYJXbnUxNfMc7ecGN7CLHe2QnZALBbkpfibqCsJDRSGT7QNZhiFp79dOw+O9Eqp01RUBUBfMJzExTq", - "oUiH1KMEOxJ5GwaIOaT0mzBUxcJOuWTPGJ8CT0PId+b2agAkftoNvs5b0I5RCMxbLvvEj4rxGHSfHWcC", - "v/K9Ta3myU1kNqcspGAhsbjfPnuN0e/V8U3QL5auDE1+1bKV3u9B5YCBaRUGAAt8065fsZwbw4b/t4Y8", - "44t/51k2pLzyxnQqS7HoJT4tHLf1+GsscN/46Va4+57yHNM0sB0iSNAiYcMmnxtSz9agNfnbA/+Q8ZT5", - "M7Y+ocaSbM99vsAWTA7bqFEgZ6lKihlIN2poFzkMqYlYyayH1DPF4ZzSs7JoSNXQx+sr/4zbOsGPiWV1", - "mUGFkPZDk0c7DCLCNY+3sTLfhUPZ0I0ElTvTpCffLUxpZkCm7DACjwDe0JZvW5rsMqOahDXnWUE5DTNw", - "ZKY1JFgLgpbibg0hbZ9d8RvATq4JpLgQ+rGHhDdDEqvYTpIWxlZluJxjSLywqqfBo3G1XAZcYqMsRCQy", - "+/doSgehqTBY3rKqrErepMoJ2SCC3ZKMzhHxd0H4PrvAGsBI0ixx/IRb9uzw+YtXOKBEZl7jBBgmXugx", - "T4CKho6FNpaIfYIZZtpzmX5rAVm6kXjoRJbdrwbsA4JPtpLnb7YQRl9dxtPyCRxEL9F/3rt09Og5gBv9", - "/wUAAP//8UsmpYLEAQA=", + "H4sIAAAAAAAC/+y9CXMjt3Yw+lfw+FJlKSEpjT2+yZ2p1CtZ0lwrnkVP0tjJvfIjwe5DEldNoA2gKdGu", + "SeVH5Bfml7zCOUAvJJqLllnyTVUqdyw21rPirH90EjXLlQRpTefFHx0NJlfSAP7HDzy9gN8KMPZUa6Xd", + "nxIlLUjr/snzPBMJt0LJg78bJd3fTDKFGXf/+gcN486Lzv99UM1/QL+aA5rtw4cP3U4KJtEid5N0XrgF", + "mV+x86HbOVZynInkY60elnNLn0kLWvLsIy0dlmOXoOegmf+w23mr7CtVyPQj7eOtsgzX67jf/OeECjaZ", + "HqtZXljQR4n7PADK7SRNhfsTz861ykFb4RBozDMDyyscsZGbiqkxS/x0jON8hlnF4A6SwgIzbnJpBc+y", + "Rb/T7eS1ef/o+AHun83Z3+kUNKQsE8a6JVZn7rNT/IdQkhmrcsOUZHYKbCy0sQzczbgFhYWZ2XSPzQtx", + "8JoJeUYjn3U7dpFD50WHa80XeKEafiuEhrTz4m/lGX4tv1OjvwNh3w9a3RrQR7k45ll2OvcAX7pJyX68", + "ujpnCc8yNuUyzSBlowUe5ga0hKwnZnwCpsdzwQwi1upVJtzCROmF+zfIYua25nBMq6y2NWO1kBO3tZTb", + "jegV2f6JG+ZQShU6gS0nwJGXNOJDt2N1Id1209W7uNIFMDHGs7sdsrGALGW33LByFEsLcIhgxO/AMjET", + "1rjr8CccKZUBRxjaCGLhVpgVMzCWz3ImJHsvxR2biUQrA4mSKc42VnrGbedFR0j7p+fV9EJamACSNP2l", + "um2ei4GDYeS6l1DGmjBht4JbeadbItKJB+AONHsOuodYlvNFpnjKxkqzYdj3kIGb16ziVlpo5E6DWeRG", + "f+FZ1ksyldyw8J2jWAdBQmbtLnkmskzU7tefUBazEd2mW48WERG8eJeDPDo/Y+VXZ2lYZObYEKRMK8dv", + "9qA/6bNhrlUCxjgWMeyyoeU3cJloAGmmyg73azuoKEITH4yu727O/85E6hjaWIBmY61mLXQavp6JNM3g", + "lmuILmost0XkVpEjBCHO6CuWqLQ+S4mLS+hVO8jSvZbrdRswXYNxDt0uLU9uVrd4fHLOLgrpaKmPn1xp", + "ngDTkGsw7orkBO/m3/icX+I4YnHGfcu4xR/daGTwkrCvz145ijesMMDcCpLP3ESJku5nFAKa2yloZqdc", + "MiP5DQwSbpAlIC7gvMdTrWbATmB+pVRm2LlWViUqY7dCAyPq7l/LCBvNsleaz2ALoYSnGePHXeawT8+U", + "sSSAGqJnaQmVFTP5ljB/ZZG/gla9ETeQMvqQEY2wW2GngkRcJmQUD7qdcSFRHL3lM1iduwaJ8KG7X+gy", + "pRnMcrtghJnIGLhUcjFThSk/NlEUdrvZ4jTus8hZ6Ov4aei3szSOe/TfNXKM7q7Q2erw9xev3ZHd2QMb", + "8bONRRYj1CUKa1xzbZ+0XONKuk14x0itqV4sMe1VTkjMnmV8BBkCCrePRGWRAokHcrOQCUt4YSDO73Ku", + "gwKaZe/GnRd/20qYVxzhw68rAganbGwGMQm3gn81/ZXLrJHcWkaU22TKL1U2hwswRWbb1CmW0KfMuG8Z", + "t9ahNtPAUU5w5ghVuCtUhU3UDLZUpmjWhypTLef4qle16lX+4gcIzoHGO3tCHWsdgHZXtwL2NTSu2Ina", + "ta/wdbiXJU7okX0OMlWajflMZIu+k3dpkYA2TLobzxxMc63mIgXdMzkkYiwSZrm5QS5omJBWMTsVhhmw", + "Lxi4h2yuhQE251pwaY3jlBoCcSUqy3huIAwEodkctHEyZVQkN2DZ3vxbdsDm3+13GZcp43LhuP6ESWVZ", + "ouYoS4lXucs9UU4QvbH+QF2WZ1xI9u74Yp8J49QKpR2WcsOGyikAQ5LfAU2mgUAdHoQ7m3/b/M/vHFIU", + "WhorMocZEwDr3r7dDk4ZJ+5dtV/UCon5GMu1dUQV4zkrOjA+WgdOy1tdCPGxBjr8FjVC9/Adc5EVulR/", + "Ty8u3l0Mjo/Or45/PBq8f3v57vXPRz+8Ph3u99nRyClnbpApEqck76SXXi2fgw39NMMXdGbNNLgrRlZb", + "GD7KwP2AL/U+G/qdxr6W/lB7BoANq8twux461qIKW41LRYqYROPrKoUTKKC/MeyWC8tGRToB22dDPuIy", + "VRLS4Qv/CUu4TCBz720vRnM+ASb5XEyQI/JbvnAafA/XbOKbP7bjaXQkd420yU63Uy4WRSlHd9F3hocy", + "N0ZM3J3UlBv2Lue/FdB1mvG4IMlvitxRBXM81vQ0jEGDTCAO0lsYGWFhMFUmIjZ/VKTUlrdwOwUN/j6J", + "5J20wItI186fczuNvKC4nW4/P/t/C9ClNgp3SVak0WVXdIkar7zHayfNj5WUkNh2Ww3ceRNfkglHSERy", + "SWGsmoFmlyc/ddl5xhe3WkymtsvOizwHC6D33SPGzQ0pI5aJD5xfYHSpkF/mWt0tyIwlDPv5zdZGHjep", + "218M1b4qFKsKRZoP/K09pR6R5ifCJLuiU1qOgbSyL2xAFHbOBb2q8Gsxm0EquIVswXINCaSOioa1cw+D", + "tdS4J5CxGvjsUdBtF0145YK+KsFrcbZCjY+KtvfUfKvdLim/jZM8vtGxQtCt7I4zMIZPYJCoIkah9Gx3", + "czsS9B87bTTjC6cgoOSNrAsCbVSp0PS3uIFDAzexR/4v08XynCCdAGRDYhODJFPGKVH4FXEOIYUViMP0", + "R2WcdlbkRN2DZMrlBJUftI2JYsY0oH4KKek4YFB7d7o6SmnkMlZpYKm6lcyo+mqJKrLUvQc8jPmEC2nI", + "qCfhloV161tAlW74ovyNpcJpkjrcK8uLWU5KIJ1VSQt3dlCqaf7Awbbqf0cKrlS5PbvIhVPwFt5Zwsy0", + "sO4I+00Nrn6VnW5n+abqf8I9oS1naUebKbGOx8voVmLAOoJU0qgM0NXXavIY0bfuRtzHXpFWmjm2Vkym", + "tm6FhbsEckIqMrmezoStxM2tckLICplYRHriGYbESyrGqGRa4qBmynMw/dIO7Nc/Oj875gQM/5e+f6/w", + "LDP7DrXc69SwDOaQdZm70y7jemLoqYimogEakKq5y21fTbXDx73ybOUv9alpzkxI6HpLatcfZVDoLLKO", + "Nzy7N4X3yLqni9fUaCTjGhjHB1TceByVl+78DxaWy1jwVVa2y0q6K0+0TygqozDZ1Z6KI4+Jr3Q+dJe9", + "BY4oIhSfZSWtcz0pZm5mlijQCb0u6Kymz87JGcOUzBbuzSU9KntqbyPchv9i9f26ZLEm+ooYpxoejIbF", + "v/b+q/gRohdS99YbX+IKcTmLbCbuRQi36AaxOc/cC5tnt3xh2DUZZK47D7rFqL9kdS+va+6RT3dRFYNs", + "cZqsOEuYnaIrT8Ntc4+PsLGGOSow6q3t7KWbottB2lo1eRQzLnsaeIqcniSUF0Wk0y2L1VtUelJh8owv", + "mLB99kqVv5KI29snIdetBaMECq0TKPckSlNERFnXK2EwFncorGh/XoHoMjQ7XHfeh5HIhl6wkVKz644T", + "/bXf9oR0gnEmDOyzq0UO/uM7JrzAK3181x2SbBt4prvQVdb46wpzfK0mWystmZqQRlJpDZmadMv7FXKs", + "qv+65Vp2Gdikv9//BJI4HOyrHN4ohzM1eXop3IDH5yWDdxKla0RVq5Lt5uiynBuDjz+tismUFXIsMotO", + "FmS3FBHR94b1IfpUVOGNkQ2VyT/JmXvPAU9fMp5lDP0jbFliGqcqA9fMyag+uwQyVZkcktI1PS6yjDmc", + "iDKWJ+Ltr5DxLoNnFTqbTcoEkO4WLK+BRSs78h95Dheerkh0VbxfYIkzJYV1LzjpREWWuVvtBenpLSbs", + "LDgHSFhZridguxSRQu8b78nAp16ukqmj7tup8DEytBOVJIV27+3IgwanijoqHJTx13o4VM0HQ5uJ6z+K", + "p6BbZ01VQrCi72rzd5lTKNB1BTyZ1k4XXUfy+cDAb6urvFFSWSW9jUDIxD3C0TFZXRfFrSZBJevSZ25f", + "kJYbsCrvIXrUR0YvYQvu6c0vrfcSzDP18DNPYbROzVoUvQ/6Kjp/wE0/UW2JPWNROfKGruqcJhyUM8tH", + "++tWDHJhC8q+whFOQ1kbu6MhgzmX5FmdCkOo/JIcS+6DMUb3lDBxtIC/Eel0SwtS+S3YW6VvasbI9Uyh", + "Bqz6xTaPXKHgGvFVVwV2NLJqNQfJHZLOwHLUDjzkFg6bidC9PUQz8EaekvJXtSaIa2ohlqDmfEbOgeFT", + "3uPcJpuGeL117lWaqPCq44hzI2TapqqEA/XRlBzMmbFQPy/GSieKZ659NqRwzQHPxfAF+wn/gx2dnwV7", + "4Z7jM3oOZLGmP/YmIEGjuhV2zoZwZ0E6RBi+YEL+nZw2fj/lb302zFTCs4EPSh2+YGZhLMyY/wPThZQO", + "YjxTcmJECo3tNm2Wad7pdqr9u5/CQh3HW2sLRTXdgCrtyBZRUjbhQ5BmhAyOWxEdHHg6OSBRcXbSgHeg", + "hSXaQuCvoZgfrc1/BCcbTPshrC5WCAZjaqc0ks147qB7y3WKQSU94THF7d6xNlXYMnaGhAz7mWeFU3k0", + "Kj/BxkxaHhsVls34go2Acblg/3b57i2qSA2tZ+UwmDBCKQTHmUhuNj6WCnwxuU+DJsFzWzgtby54hYTI", + "7arYys2vI1Ft5KEvpOiZvr6TWt9JtasfIGSf8LXUDptHfjMZyCCxKhITfHx5ycKvLOd2GmzseHbHXzNU", + "tFpUikksWP7Na2b5pBHQuzSbA1iR56AxVpwY1Q/vr67eve2yoy47Ofu5RYeJKvM/CyPQO+C4nk/lalm4", + "y6xGh3x0+rvY3HCLUT13vUQpnQrJbfNU7izuFnNxB5mJW/IWayZe3H/iJTy867iVuhW0CUJrn0k1FPwJ", + "FhsZ3g0sRorr9Etgd+E8X5ndVszuBhYfh9U14PLIjM4dYuUCf4IFORMq7fMnj8d0t8SATt0Wu+wHntyY", + "nCfu1R7nQvfgpoHvoX1+itEXSWHIDk8pSwvEmFyDMS3caXtui5Ov57Znb8/fX3XZ1em/Xx1dnLbz3GV1", + "EB7AYC4TrbLsEqzNIN3Iagx+zQx97hlOeDfxsa0+yZURtdRTjBgQctL9vNnT6m18ZVRbMSqC+sAjxsfh", + "WS3AemTu5djTIKKE0Orsrldiuk/Yo4j2yg/ovpqAcUi/jVqC6y1a11s89nreHnMP/klrbVJHVezyXmGE", + "vFm9QmQhbvJwgsBqtjmJit1bY6nFoyy1nOtGGFKCzh/ab2j1htey5tdiDk4N3RBlzTIxBzYXcFuFmy2F", + "Trt3/LjIAu/+xrBfYHRxdVzacN7Cjdrvsx/9d0pmi5fo6wwMfaw0zpKBMYwydz92CGzsOr6y5FaW7LBi", + "4LDiI4Rvt4Jm90jYYLlvhMGunKU9EnadZ+B1SSir/oE+u2wY78tgTdNlRjHOrObSIHkF+/coEzlLuEQi", + "wVBAb0QtY8sxYHxYbWm4k7F8iwvfHDS/yh3iQfPbsogqeD4GldFi5bifgkV8DZXfnUt8lID5dQB6dF7x", + "GQXO35crvfQVO0LUvKYqF5Si0sYVd/TIbZnu9Ya87Cc17tHCc658Dk7tjqwKnh5HFZkyts+uUFe0ehHY", + "pncIpFrlOaSskFZkwbk/KPmxe11qLeZg+uxKA7foQRCyl2s1cc/zUGIJI5YtsD3PrwcizTDyYwKDjC9U", + "YcMbZZ9xwwqpIRMoAmhlOwW5HQPze3wo92q74a/sq5V9Beyoy7QnZF9rIbSJfzXxqC2b5QL/XkYrVAdD", + "p1qCRDQoc1FKh27pHQ2/9Ot+0KVRm29oc6aFv4ozKewrLrKNzCDwNkqFcU+LEfgsnEz8Tvv92JS2tPmv", + "dLaRzhzABmO8sqcnsxh4diMyYyFvR8kZ2KnCbPYSD308k4WcTMF0VG+TpXibvgF7VFh1ZC1PplvYZHET", + "m097EQTcVuQUla0N2tLQA4xHEmZaWmThbsoLYyl+IqseOWRDwuobps/eKjYuNNWNWhbStyLLvAAuk2o9", + "bX8KEo7d2lc63kjHJeA/GjG3AupJxGYDsX3JiX7114GnAydAiQ4chgcCYLeggaGHpsjL8BZfwmJcZNkC", + "xazSoWhbkyDrkjey4iMK3wt4sCq+dKoIy+DLOsgpMYJgGUyL8h4mPMd4H9Lvj5tqOJalMWDRnLIUbhgs", + "Klbz5MbN5lUVNtZgpsFIIQzLlZD2k/KZrzxmZx7zUdnLQ1hLoNVtjQJYj3Hp+c8svwGkslq6d+lfaJLS", + "Nve7whtim9x8P1VBz1ZDYQ5aqFQkzJTfBmtH8PnOfVDMdhRYzfNIRLh0iK80uJEG14LgkUkwBp3dKDCX", + "kQiKH7iBPz3vgUxUCik7f/uXLRG0vLbRwsJGLd2tveaMb0lCnaUZbIyMCNJMpCFyeykugrPvDw9nhv1W", + "CLCe7simLhUTsjfOxGRqmS9ri8H3W3rb/NIPpbclP/hXClulsLpR8Qlpy+Pda8VTISdrn4arCJjRqPCK", + "9QUszsaNuiDutnmmgacLdz8e9zDyyWmOHJ+57g0sFcu1UJoNw9n9FEOco+4pFna/y4aFzoZdNgx5Ue7f", + "ZTrTkHKuhhp8FrW7gGGtZMRLNowgI2bi5VxTjXyWq7zIEEswiYhblnAD21abeCRiaQXRV/m0kXo8hj79", + "K3Q9kB45TogK3myCWZ0Aw4jl1EYMs5lECj/XQEe1H+Oh129DqhamqtZ+8yYtCfbFi9OLi8Hxu7dvT4+v", + "zt69HVycvnp/eXqye913xy4idd/RgxWeiEqLiZAcLVBLbKTVeeVWrXGJ+ML+pP0L/+nVIoeaOQBXWEn7", + "rWey+Izfn6S6lRSOapiQWEuRnfg0yy57BTaZdtm//3jRZVQhqMsu7SIDMwX3tj2bYb2BN5AK3mWvlBtz", + "BXf2yr1su6xG3d2qRl2XveFSjHGH5xrGtMY7OwVNbHKm9BaFthul7GtY0a0Qcm28kb/C0P1mWykTwIfl", + "K1qS5Z6e/dZ3/ZXxbmS8HmhPz3FX4PLIvDZkQG8sw1KmSqOe0Kz/5m8jynumtey5XfZdz7xbLf7uryVk", + "2PXdSn5Pjmxb2dxZ+KaPNXiETLEZEmawovpTmOaZ7s3zjOduOdfG8aFcg5PWxJCwwEH0uoQZaKBKfuso", + "B62BXlQYv19TZNS/iIUZ4iRDfpuWNiDeqcMNC5Wb3eTYyIJE3l9Or7rs/N3lVUuhf2XsILCfOMxGKl2g", + "aHGzHJy/vyofaV13OD7nIuOjDFpEGR0tjq/vSDxmmGs9grHyxYzCKAQDHgwV9Npl4zXqAh5JandZIcVv", + "BTS6T1Runq8S+uES2qNxt8nCKoazwhC2E97UBWcH6e3b5mhIQMyrZ+Irt+ma6bL8ENHfAcX7DGhYF/2O", + "iJUha5i8hJ9GGajdwldtYAttgO7rY6gDy5B5ZH3AYWcUSB4SDTSu2CmWXRv7kmbszdmbUyrZ81FVAr+z", + "uk6wjazzCo4KsmOdNjMTszYeXR46TFheFQlOdzMHUzvLumy5CePXt+JnL4keqXtamKbF3hCdq1bt4t1P", + "XVa229y/r8AsOxUEQlwrGc/5BI41N9M1ltOcT+Abp5LKFDToMpwuoXFsj3Rvk2PaTp/SePyk++x//uu/", + "EXWuO0e3XXYpef5/XXfKNiPu19spVX+sLDthBWENZGN3VVgiOxNzIA+5wsh7kcAgbGIsNJiqALFXbcOv", + "/gilvdZray/LCIVGyepQu4gKdCjJhkQK/VDyZLitFdWt+1CxvQyiryK7VWRj+LKH+ROK6yhEdvPmrSmh", + "VRW9qTP/EFpfQ+iPWymrarfCsUMuvbFsO1/YzMDay125XWwAwImaHVO5jNeKp1s4fk7evWkMCBVC3X27", + "CftpOSPOhTr+lhVBH4vOo4f6SvDrCT5Vs4GvnII+kyen/XYoPbavJM0H5b1FOAWFqs1CFUJGkTdULkJI", + "FqJuuPUl3FZIwEnNtItNKKyYI4iXZTDFmu25ByxCDcs/7vfZewNsaA2VZbttxv1E0nyW2ys1TrZRRXmN", + "KSnbVl+gBJaW6gvP/LX41zuyNEyQqmIMLOg5YB21MNNUjNGAVVkU58IUHFvQjkQm7KLPTnkybQygkD4y", + "4D3r+VXdofXHYypfgxW24yHNnKcn5h8emx2ObC5pXcwKT5wN3No7fn2571G7zFM9B40XIBNgV2IG2Cn3", + "6Pzs4wqx5eN9lV/b4Z67sI+MeU/idPKxl6sXebKUJ9pAaJBWL1YCRvd8B4VDFDMNdsxy0Fgfej+aVVq/", + "1UEKlovM7J5GG8ipdnHuFanFqLBgNlAeHmmV9qY8HWhInLoiZF7Y9SjduCRfZimBlMIhsIYjThJ8ERg8", + "1/WNDp2gEp4/HL++jKM8qguRzNv6uiZROliBhPGw2nNKF95ECJ1/fbkfF/0rOOnNUDuWhQ4lovDvVTeL", + "xhWVVaijryMR62YeBV5F7zFs3ZzXvJzotHRgv5cqw3gLJSjJN4qL1+4ZZSzzat64yNg5F+6Z8/r4/HOV", + "F/5cX+XEBjmR5E8tHuqQeGSxkCX5Pdmwx+kKpQmjH8qGfTWmKPcRaTV9oP/Xx+dVJU4xDt6R1sr0gziz", + "cS8vSo5YnXercglSpe0s8+TdG+Y+iHDN2jptPQRlCrpl2xf447Ybf+kFNrUTJl+Fr4xU5oxdiZmQk95R", + "lqnbHvn24+UhxO/QXjeVa+AtG6LCVMz8VvCmPKjm3hQXU58RY3fdEZjSbC5SUOGnljLvTyv06ltzPMyb", + "4R5f7uFCMeXs3kJvs6RTfPMrv3q5LxvysjD8U5jwyr1/FWcbxJniT/7QbsDiMzfOoY5ZofOXYpp7W2ar", + "bkex9dYovmfsMv0iv3gbeufv99kx11oANg0pOwSMqcmmkMi1Rlhj3zLfJ8P3XQv9POqWuOVONh+XOyzd", + "1lcesZ5HVMB6Yk4Rg8tuHr37SXUZsJy+2LXN0Vu4ZetbHTFujJhIn3uEJLGh21HOtVOL289zjh+sHglb", + "nBQj+nutv89Ln7VEO4h0OjItlap3bWP0aM2KPq5ntcIBqx6tYRCFS9Y0rwqLtiaF9f6WEGqBjuAWR1zZ", + "L2nJwM6mfA5spOyU5FwZYGSauNNwuZQeaGFYbXryxGD/FAwsZmcyhdxpw9RJoZ6M+JJxZoScZMDcF1RN", + "gYKmUgXUwXKEslLYjxnj8dVNs6s8+Eiumis+epeDXON0lHBbKjiWj9zj0PMTDJTAwaTb+BJJIQjpStEf", + "EPcRr2mc2af4YhNi3HkjQknUwph8BWO3hdCzz6hGkdFNKaZeX2oml9YUp5IqEP2cXhlLPO2zYyVNMQPt", + "3qGUV7ukp2HTq9DoaIq1mCwWKBTW6WocLfmCZzslqT6WVtaE8lelbD0RWj4aEF5/VOK7h06Gu4xrTldt", + "EVaOhjELypMuEoOSQOkrcrGrkhEP5wryTsJttiiX4qMn0TyssFnE/EPpUpnnPe6bUitFhhLfTFSNCVPV", + "TGftczxWFNglhYBuCl+dccknGPOJnzO4ExYrqMJdjjVxsoXTGZzWgljlO3FQTK7DJm6V7lU5cWZa2FTd", + "yn2WKmSNvo9gnW3+z3/9N0XNV6vguoYCTEHPfDA6PoF7EzGHXpH7MtrUFDNV23JB6gH4UD4Yuc2vjLCV", + "ES6FHz8hI2yDy+4VoXGvzXrQS8coS0Gz0zthMc4dEda9IHmGOgL2PbhzqkCZj1/IFHSGnUKDZYpoTpdF", + "EJMplxIyVE+QLihljgiS2KJdUJ/6TIwhWSROQ59yA1XUa+nZZUKS9rKHT48ypXCfXEBnJ7hRDbnCWq8R", + "KsKZY8Wmt1i6z4ZItEU+ZDPg0vju+nTwVLh7Ib1NYCaGdhoRamucTYFndroo23Ri8bc+G/r/DhNylmuY", + "C1WYbFGOaazQZF7DCZ/DIL6hAImyxJ6P2SXbYVnVD6Fsqba01Q6WL5msKl22IQpVvHRPuMq8EMBKhaKN", + "moGd1srWmfJpVdISXWen2/H30Ol2/ImiTC2PGiXOTlZipOkK+uxoVGWFxu7GLcaKfLUMaPSahFOIWaak", + "G1oW5ePUS+D87KQlM8RfoORRT4xWE81nzbaD/hjhPn1/XKxXLIqZU+dnhbWg3b+oj2uPXGw9novhNsVX", + "63vqeqpYx4pQ0LxTs59Elq0pqvhayOKO0ZbYu3dvejciy7BeKso9rPVU5XjIsk/tz2/67NI390WX7vAg", + "hfnBzcxMhuFN5NCMy4occOqSFfk1vdCYwUzpRQlQMieEuBhvny+j100x8nNiQXluS3ZnitxdlInzkieU", + "yCvX/VUgtwtkvKyBUrOBQ4mnFMhxsOwuj90+l8Rx8xDtnRkSJY3VXMQo8JdpkxYgESnZCgIp9tlQKglB", + "XEwyNeLZKrW8ZMMZzJKaWEomWhV5+BKhj9gxFfYlGyZ5YcAO2QGOU3oxyFUmkgUZF96+f3N0QH/opVrM", + "QSLtVuxZSb9lw1SGsQZTLtn3/UPvH0tFWnZd8g29dJFQj7yhUjM82oshy4SEpoBxh8UUuVniZAvtk/5Q", + "7bKlx/VsMNYAg5tRpGOWBggNuP2VCMl+Ej+EjmP1YAm3uS5LQWMaeRmwMnSzv3g79KQmZA103xj2Bma9", + "MzlWLC1meZ8dGVPMwEHiOa5D5Y/E79BnJ8FQE1ItNSQZFzPs2ZA4BST06jEznmXeD4kx75xl7tmFUBtY", + "ZXk2uBkNseOEsQ5HHfjpxumwDuRuKVT82JTrlHo/Yh1hD03PRgIS1mHHqWwG7qw8oPFlP+s9rmvkXt9a", + "hHG5Xx4Mird4n4ZdHL0hLHoAOJ7mFjZpPl4YBsUnPgf92KKIHKvZLD4bwxgT0qmXxO3ejN+xZ987LV+b", + "bk1WND5ryYM2JgrSCzD4LmAGLAmb+K48mPdMgfvmUsmeNqbLxiID+hfqttMZzNx/7vfZldNSfWGVfLow", + "Iqm4X109dGheGFTu4kjU1l4vH1hubkwMT3NWKRkjLJWNp+wZsD08pV9qpma1RtCEsYbu3k1JvoslbamB", + "qsMrtwV6YQyZ94ycznK7WIeU3gDmvj3m+Bjgln2P4T/CqUWKjVSBLh2SWojsiKzCAhUE3lWxcftECud3", + "ZzTH9+Wtcq35gpQWMZmAHmwiAP9d7Sm6DSn67pAydZxseHz+/gV76zR59z+OIF4MfdmBmmyJwD3scWsC", + "KxFtqgwwnmWKygaUPqlaxSK/b6uYkHN1QwpzpVv32bux9c8b9KFxw4b1nQzZXm0aT0S1lH7Q+xhEkXDJ", + "UjEeg643+MVBCW3T/+zudC4SK2Z99mYb+m/cW1uh2frdEb8rWcS2Khki1G7a2FHpFPQQoXi3TVSFUmBF", + "N9se7g/hm5soYa0M2J7pNqXoKlfaou0nAdFDdDMsa6brdbb0ei0OMmC7J5s3xRJml2UwGu6ibmfEkxun", + "yMp04P8SHsK3St+Adn+Ycg1p9d9Y0iuqIYZdh1Ygx/SUEGCOlRyLyX3sdP41Uusv4ptBY0qjkBN6Bgev", + "Y+sjgec2me4e97Z8loU/yWpVlmNagRmVzSFYSZgqbKJmQDVaav0Ln3Af1LyR/KIHKVhMxSytecHZ4tAn", + "1+pugSpB2fsx7NMo8pI81SZpBXc9eWHZXqYmXXbLtexSBdJ93JVjAcVkahncJZD76Bjan9Uqe8L9HU2c", + "IuKfZtQ52jA+4UIaW6/O0WWmSKZOwAhJ2kDCs8wEZ/SKJco3yfRV/Kpu5E93kveUFVUuFYyVe0kmkhvT", + "ZTewSNWtdC8i7He8j5sLZbaebmP1ouUHZSWYUFWkT9FXk6dEwnMMmi4pI1xMPeKGChkuZT6/Pj6nS6oV", + "zX/CXYZuC6NmfftQwb5W5N702Y9iMmVzlRUzeMnUeOzEZwpjXmSW6jHmtick7Z4Mc0+38xBS9vMbb7iv", + "qEUVtqfGPf/QQNsH1SQi/2Qv2HnJ7uuo/sMaKdmyo92kDQ0KWZloWg2aUF320AqRDBrpngppzAQF1CAL", + "fT9BnOG/UY6lfXYmWb04pO+c7gNcCGIvmJoJ60O/hPEmkj3PzG+nCi0bNPk+y4DPQyvQsKIaj73Rw63l", + "FzcM7nhivRMqKeU1Kj2OiekCaH9HV8c/1spXtu3G+EgybHbsHlgELTb848NwH+N1mFQ9lb9sbk6DdbwV", + "/THoXXJ6FzmErhSju2VKs1QY6r1cDZ0LTrvrsoUq2KygCsMpbuEuz0QiLBu6gwzdDEME/rChgJeW2q2Q", + "7D7IVbUwTSJo5oVJn12uAr7P3oVnWdBxbmBR3vXyRe87qAUNCW3XnvgN2BcMS/bfAhbuJ2++9/KjT9P4", + "LFaVdWt9oLreltRlXofa77NfKL926Hc07FaOzBoOOXA4PPKk8QKxCe2fAfVfMi4X5BFTPoLSHXw87rOy", + "IVU1357XS7ohjJF6tHbr4o0Uh2HFE8ngGuGEiCgjcNeMvkyr+uyoOpIHVKiEQZv0J2FJBlwTfdk4ZOkA", + "Q99eZVih6x512cqor79njPvkSLPVHA7Jp6DhJeYsZ+rWMF5YNePWx425Byl6VHn9mpqMJeKh8cfbNnSm", + "VZP/0O3AnRM/u850iqPCLNsQXGPEbmT3SulbrpEhqXF5LzWYWUVswoJ2dJCCsVhI0AFwKXQWyybXbvcF", + "owvwGMsKmeFr2bOcbFFii4NjF9ULMiPw+joMZIrNyrBhhVZzYYSSVdW2n99E+K/bdCAY4r11jh/4J72P", + "nBY95XISxwdls3xXEL67en2+OxhXRu0GSjf8AHVGf+3h+XcPURxBBIHPSIcsVShpIEZImVu9hFSfvWuw", + "kz77EZ0ADMZjJ+v2wg4tX7iHgeNMc9gn4LvPNkJ8a+F07B3gQXmBU/d62pVKfP1BNPGMsI14yoJrvboF", + "DOTyHhXj/VAUG0JNOVYBMQNjvAq/arOJh52Uqw1o6hnPDfVIw+iDg7HIgOSR958dOOKV7gYPcq3czwep", + "MHnGF8yJiJdlRoGfEOuJO2XDB9o7fOdW+MJF9V7IzZ2g2aY+U9QCEu8j+y73cra6y+XOsf1GDIjKB+H+", + "qYqltvU/+DbNeAHuqh0v9pfg/sOfP3woitlgnPGJIfi4K9rsEQ5nDiCMGamO3QvyjSoM+ILnO0akjgpr", + "Y6VRcEpGv5KRl8Q7yuLaPWUwtp1uRzt1xm1VpGkWbFrkOHf0HIUTPn5bCr9eeWsafuMf/7VV3WO50+1g", + "jA5+El1gqrJ0cAMLEzteSnGv7md3PvdtvTsmzVpzI6wGwS65BGQxG9B7npZDttR58WyZ0t9iliOaCsUM", + "PGHl4C2aYd1VG+nd6in+nSVKOdHKq6oAdGO5orDN6EyRksv/cZ+ZltD1ruOmbkHSfKS4Tn3JhF1rU0ar", + "1x57EZuEyal0rc/32Rzl6yaNbpY6oeqjyip0D8N94mfxuOugDHeQFBY9ITnXvnkCsnqvqFJXLdIl6Pnp", + "Wfy1rGbJKUeevIgkITVZbqh7GI52l4BvOfeBH5tzzWdgQZv+tTz1L04ly99pZKOmM9q0g46OUjJtiTlC", + "Up45nrFJkVllWB+6nVTzyXbDTzSfLI+eqTlsN/qNmsPyaIwUcGxi0+Bz9+FPsKiNJWvdpoGX+FV9GNhB", + "UmijNr4BLsEe44f10RnARn3x0n3kUbgWnbQaGxf8FisY1pDDNfg27ptmDp2Lqqssr6YB28bJw0FinLua", + "dMMxnZy4gjtbXs8ylcdbMXQ7xxq4hRPsxqH04n7Cc6ZSWKNppGF25j5keyrBqBA8ZZdh9OQ/f//9fp+d", + "kLBAWfDP33+PShy37j3UedH5//522PvnX//4rvv8wz/E02PtNJJmMDIqc9ym2oT7EC0TePSlRQ76/7jZ", + "GepWil3mCWRg4Zzb6f3uccMRwsZTXObxN34BCcq+yf12H3N8nq2k8eiwSO0k7CjLp1wWM9AiYUqz6SKf", + "glyGP+/9ftT762Hvz71f/+kftqvsckLq55avvKVycGibahe4QbWn76rCNi01fLAr+EBzC5un9F8zjT3I", + "Jfvxd7Y34wsnfmSRZUyM0UKTgoUEw0L2o4veijSGUMur4Wdr9x+92mUJ9DQKt2ObLcp2qWST1h2N6gX3", + "+KjroYfLqsqJ+2SlvuEI7C2ADBtxiraPxefaeux1/J/xTJUp0BaLVsyEFDO30cMYTNa26fbJbxhQx8KX", + "K3sLblNHWhrohtxeZmUwvZkpZaf/ShZztNmicTcY7ZzG7c4w4sY/9XFB5C8ZyIk/B7+jczw7PDw8rJ3r", + "++jBHvLKcEfY6ZER55TvNFZaYpkwqFb+7a7LFr/WVfqcC21K2IUuGdTowG1igtFbb5yq53VHxi3LgBvL", + "vqVG/mjkKXe6vOV6aGQZOPUtXl71H8unWfsjwbKBww6uEd8qmxYzLnuZuAH2A/wusEqtnkOFzQjhW76g", + "gzAhjQWOvVgyIYF752yuMm92/AUjjdxqaCQwgxz0wMAEMY3IAfIBEtlgRl0ZxESqZrWrWux54/PGkb7f", + "kS7L8ju4rxUIntEuVqlhI32unLP5ij1sf8aWW0Lcon1hKVR/Xz5oFdlE+wbZG9oee9bY67PN4Txtwr00", + "w21rEFuaeJ3Z5ZTecucZX9wiF95WGMSb1NVeh9WUmO4WibRPW+wl1LXm4N/4nNM/KV+umpuemfjHKTeM", + "Jxj0ZRX7BtuRdNk3Pkf+G3pdfuMdFd+wOdfCiVv/dJzlGbxg1x1+y4Wl1g8TZdXeN1Nrc/Pi4ADom36i", + "Zt/sv2QabKElq32O2b17+y+vO7EgPCrLRuU5kgYe/mkFD98Qt/ZnxCeMmNULWpXqNROG/emwweG/a/D3", + "zbiGl78lPhjc8I7oELoqLmFBdbpVQ3vA8qXMFuwh7FHY6U3V/fj2zfFuTH7Tq+9Eis8nSFYRgbi5PUpE", + "3yc2koKO7OcyhLNSc+MykrF+sIglN1WxcsTlZD50acvZCkT4ddEBUL9tSJkfgs3z4t6ARvqaXyCGIK9E", + "BmdyrFb5kTCDVOj1u0L5hY778jnX0m1TtZb5dKJ8hgqJD+oN1dfK5KaUW+j5KsCrmSdRvuOORa/bkbA+", + "R73Lrjupvr3TPfd/1x33sLnu9PRtT/fc/1134hGk8TjVH7iBRhriWIQwhNWb2PpVHHTWVSQRv8NgtLAQ", + "wZNLH4CKP/d9RdGwDQFmi9jTEEfMUa+vLdYNeFCDob/0NnSiIOOWtMdXpY+GkeexrdnzNujH0aeGXX62", + "xMP7wrJc6r5A3Q1L4mYxnxW4yKFuAzu+OD26Ou10O79cnOH/npy+PsV/XJy+PXpzukWGHyX3tSos2KFu", + "xfMeh++JcP8VslcL6avYl4V/Sqeqj6gL3UY83/6JIugxKLJKQOFlChvPmOV3SqrZ4gWmt1IZCe8drWY3", + "VgOf+YSBIbYiQweb0jPULJQsYY06hNvKCDJ1y/bIwk1bItO3j00att/DsMs0TLhO0c2PAQGK5cUoE5iZ", + "LGyfHfMsA92r/ugvAEOU3l1esYNy9wf+p5BXWyYxBvezMHSzL5kBYMOlvZTvUexXbKY8hz77mWciLZsK", + "JLiZkJ1Sj14VprzgkPqT+JJF2NoOQzGDRxR1pLSCOAn8Gc9zh2ZOx8jFwK21IXrgKBfuegiluiEee4DR", + "0oMg/NfO4AOsL90I0lbKydJ84AOWNs2R5sf0YX2sO962w0/Kb8sZKCpp4LWh9RPQt6ghLY/P1GS70a/V", + "JIytRT6RA3DDDGfV9+gMic2D7ohtZ/kJFrE5yAJf1iXbejpyVzRq7XU7mZjDYC7gdksgvxZz+FnA7RKk", + "q2m2hneYaRXoPrCrNtXGY76hISe1EcuzCSnswOvIW012JoV9hd8vT6XBr7LTfBdh1IZJd55vda568PQ2", + "U12W34eZ6sUMt2v3fJZmsDzacUchJ9tdk5/nNY1pXtJS59ltG1Djx6tz+D7Lu3ex7nSbrR93a6gZRkf6", + "yN2zY1+Ycamr1Natk5q8YLVJ0O49mMppknyHjhzlKMXTXUqfh3G18r07l0ZenWOHe2ypYdpdKWC3a23A", + "WrLYdsgWK1LWXalWsWshEJ/I7d4Vi7eo+5N6+6HbURK2T2xYlq4fursMq4n0LQfGOMCuQ+t0v9vYCAvb", + "bYKKl245LobXOwyNM5cdJqgocodBSxi/w8gGlu+yzWVutcvYwKt2X6/OGu4F0PvMEFdHdx9caqG7D41o", + "nFtO0qKX7DZ6VRvcbfyKgnXP4ffgAy0q6JajG+/BbVnt0utt+2HLCvyWI6MviR3H3nPpttfulsOjYvK+", + "tS+pz8VrYSya9iJmMK35gqlxxKgmJNl4KdXBBlvlViUySsN1xBtdiulIldNMTZarFvA8z7zxeW2c+nJ/", + "qknpx7BwZ1v7CbX0PbkSM9+Vr9wRdS2kzPxtLeAtzsH60jGbHoZ1nPsY2ovyRbHsBNg2uDeEzt0/qLdt", + "hq2DeVdiKHeLf3nEOBAMKnxgBEgqjOUygYZb8Punjvtwe94p7uPhwRDedl9FPrh/cmmXbjFuzt+EnlVg", + "ScAwZtW90HTbmXZC1/tHJqZg7GBThGUtkSz4lTYFKHY7RiebJqbSf1vPueyNDAt0a6eI3dC7mzpf2sFd", + "/Rcqoc/e/RQM1rDK19XNRqw9o5YaYIK/tb/Z16puomc55zaZ+uDH+0G8LfrxpD3qsWQU3z4/3D0G8qQ1", + "9rHPzsYhxbDLCuNzC6diMgVjqzrDNCRwRQ2IPl7Ieu/Vnw673x12v/2+++zw1/gW8Wq9GW8TvMY+NkrD", + "2PEOSg0TvwOx4LKOiVNCyrDXAw14TGEY5eLFOY3PMasyrVZDa6vVqRhuyL/z5XKr8wfPp1UMpCmoAjJP", + "eU6R1hJuQ63CKkAEcQLvcgo8HRdZlzKmw1+yFvRsDTo9aQ02LdHmu28Ptws9Xc5AuJ/k3RAWGqRuEFtU", + "Q2VhKBZ0ueViDUUduA+79C3XwCwWbNscebZGkJah9LNNEvUGFlTzkRl3OV6iby9g4+u/9gGVbnazmI0U", + "lZXBhfrslCdT5pYIDURGwHjtW2aKvKpPeJcqq1R2LfcMAPv3Z8/wLIsZS2GMxfyVNPt95sOrTFk387pz", + "gUE3150uu+6gTYL+eWx1Rv86yvyfXn1/3elfU1Alxd0JQ1GhCW6QZ0a5XSZqNvIiy/hMBJrvn2yI18D/", + "wtX+6YqPcNodLnSJW+PtRvk1VQU7vYPk0SLouDveDKM0F9LxEYmFy1dFE9eTZjDm3yI1kmgmridF2Vl1", + "e6ziZqCVaoZSxo9RNCuBY8UDN5TlWsxFBhNoYTvcDApfTGD9lKEBofvaTSWLDKVH4PGr+Zl09kh8BF50", + "KAdippBl5ZU7WVDE+7glt7F0cKWxXHn1WN3j9XiOfT+j95DTItSYd/kAm3UukPN29PojFkXvYfbHh2WA", + "ncq50Eriw6OMjsQ61L6BUrzmXYX5KxGOuwU1tgOwPXaRwLmRDB8UuMjrRFcCrDzHKhGufQ+eludvewzG", + "6wnCnbCDeKTseaioGBpKtJTHxzjGwehPz+NhTLUiUPQpGxXjcUunPopj3HYyVdj2yT60Q+8nUSUZ7ga+", + "S2qngdgry9ILNextgowq1TSYWufq9OJNZ/289WAq//lPZ69fd7qds7dXnW7nx/fnm2Oo/NprkPgCVdH7", + "ShOqecvOr/6jN+LJTbN48XIkdmbiHTDLfjqJyooZtZNcF2Xc7Wh1u2ku98mOofE4a5c2uubGLnN+K+sX", + "tlUpsojoXu1J7GvIwsDaxWYpeOS/ZpzlBopU9crT751f/cf+MmMlzR4FURn4MgeSSC3iMg600C5qGXC+", + "VkztEBistZxQsQNIV1Zyn91/mQ/RbshNuN6Dn5/VDMZ85BgSZ8bNto4eohVg312WwGrrRBJq7MaGX2Kp", + "xl7ZMzbSsay2n9KOWxQijTNibPA84DZuJ6YuECt9WfywHUzFraRmuS3MrlXxasXYCkNStp0r5cUgT2Lt", + "UY0VM4wWPT5/zwq0p+egE5CWT2JtuNeK0aofk2jWEJ5y4zuabaOjUCH9lnjrasehLHmoik67L0OxWyR4", + "1NxyXsHUNuJ7q14/tP24LGoHbCrk/YTOCbfccbJbLcgAuoR6lOogZF5EwrdTbvlWikVaX2VzK55y3l83", + "nvlB+qLbjk8rNW661RO6LyzINiSp8tDwA+Y/73e2Nan4o2jgVSz9LrrT5WlZfV5DrsE4DlVrPeZzVJRe", + "KXP6UGiWjrUKWdwpoiooxP10r5tbWgl6d6QQTTDeijWUjJQmF4Zd48DrThvJuv1HpAAZwn2wuao1BEqm", + "hbxp1m3ClKEyEWlLIqZocYT/w+wQI5UuqIEuTRnqcNIFSE/dywH063v+x7ITyiKorLSRoZ0inQuj9OKF", + "r2p5I9VtWN3Xlwmd7spW7Es1Snlhp0oLizmdGZWmpuRWUys02mdnVHUPm0oaX8irkLRgUhjrcHORg+k6", + "NCDbK9b9Ih7TbIgTil1XNY+7oTh6vUJzVXW6Uce7LKPbqAZcxrdX8a5rG2C1FQuly/Mk3n9wt6sNGSfr", + "m75vW92EKlqAjmecjYXE1Iht1KCqbEUY1aYEbbQnkX63+mdT1t+o/d5Int5aaat26wfdc7NL94zKZH2f", + "sTuvYpAuYLJN5ajt/E4/+kqxoYrIxBtB1tTcaPFE/IIeiF0m2jIqgeb6xj3H8l4GY8f9tYQHxSnsMGfU", + "FRxuoRsudhPI7uNR0SWgN5R/aiJGVAQ1i0Tt6qXOLB/crXfs/Ki0+F1JLEGEazE+U4W0fUbhKe7hjH83", + "DBOPu0zChDf+7uAQl9y0gw0VR352O062WD9VtzKyfJHHF39IJEZZpmp7o/4mquDWF+asamk1l9qdKHae", + "cuvwiJUCYztyLZGmIDekVFMYR+Uj84M2+vj9dy3bfiUyOAc9EwZrbt5v/9g/MG54o9aClK2q2V8a1otd", + "06Ijlb/+9Pz5/m6FvtStjPl53F7xJ/TshP2+b9nvNim0lM2ZV3dL7lzyHPoyxvcswrUmpblesW7HHjW8", + "MFAvcEB9A3JIHO2npe9gR+dD3ROOpepivod6KYlG0NjhRqKsLx69EKfCvDK/cJs8al21sugdmgOw/mS8", + "GIQjXDGHzXbbktr9fKwcmy22iOVpjUzCG3hgdbax5jOIR95cVLpt+MiBeJw7ip2D1iIFE95K/gb26zD/", + "9nCTEThqEg0Ptogxs6bAAtLeI9WIw00HhD6Tl4TA7Y7Hah91x1sIwFx/O2svZMbvsHaB+B3O5Jsf2neA", + "Ucyh5debH7aEyHLJrmctAVnudEdFKtRm5D72jRy4+5zKnmGD6LlIQfXZBSGyqb+rnZ7B5+Ae/jTKR/K5", + "p/R5kRk48n9NbsDWS5xjSzxMymcGrGEjZae1Iuf7vjIVBSk18UUY2lHPvcj7W5Yuv7Qqfyh9KZ2Am2fz", + "TZ7NZpAKbiFbYG93jHJQhWUTzRMYFxkz08I65c+XJJhhWByaCoXEuA6tC2wVgUdFHIm7eXapyUgAcxt6", + "woKMVe0AOYdM5bvGWl5h3Tsaykp3iMX+ubUiNWyp7kGkMH8wBK4tq9qsPoEla39rtaX3Zkoqq6RIyuAr", + "Rk6Eaqc80coQkWRiDPXOpb4dF3tvfP/f19zYHq7cOzvx0YWFD+K/vDwNdkBv/hSG6tORRWmlU/cO7lJ3", + "xmAp/XUtDNuSHpbKblDBrVuhoZfBHDJvS8JSEVh+K6+V5PCQqzoTYOBECK2TS6fvsyM9ElZzHapnePWS", + "ejj5UhxV4QnHwFKarM9erTTrW1cfpBsr7IE7Bt1DmxWhDUtVgkFSUPaNHnoj2D/6ihkHS385wXlrAXBd", + "tloWZFOT+7Xm0c/ayFiB8N8u370tbYwx+GTC+HtdXx6FqkWRO2IZXs1K4TFIECDdhT9dU/9LsAHLvLgs", + "3QStPf6t4/W+L27Z53/7Nv/Y07/R5b/R4L9Rf7nevQW5FO7Oh7j2Yxwm0nn3oxh5S9hfBk/nPXzKba2T", + "VoMl8zwTLVbYX3iW9ZJMJTd0ZZW5onaZzaZbDr5+SsrTsaEoZKMfTL0f0/YO+K5vHLJzh6Wyr9I9xZ2X", + "aBk3dkUSVx3xNRiwQSI2r4We16a/VpIdbhHrhwehc0RxZ6lu+s72xodVF76BhbFa3YCJVgSNRr/Eq5be", + "Ky8qBGxW+wh5YbX8KMeJ7rC9ecYX/WvZYBK6ALYX+lrPQkbcQRpqQ+/32SV17ysTCq6ljwB3LMCthboO", + "l0yF92BtvcZNsT38278eunvxaVv7/WtZq1KLrS/crS1ykhK3SqfYwD0lH6kPKS5PLqTVvOe+ogXNtXR6", + "g+RU/AsFIv2c88I4OF1hIzu3N+LQbi9rQBdtn9Rt6eXhUBHvFZsRkDCYKgxbpzYaLcXb1MARTALrcRF7", + "GE+5E/BO11/kign5d9/kz736X7KZMJbfAClKKCdRB8E7G/HkxuQ8gQoJ2GGfvZPZwrMwE7sBtmdEBtJm", + "i8Y9XcvqM8SNfbqq8gl72H8WxfoQlrNtH5NftLBQdl65H6Gvh1YjYCUUGwwL3rcBywfsyktuS6wS23nR", + "8droGbbwZUfnZ51uZw7a0HYO+8/6h2ggzUHyXHRedL7rH/a/86X28CAHIZ/ogLowkXEsiVjH3oCeAOYG", + "4ZeEAnAnDAZ1KAmmy4rcCR+2NGkkI2ku3PMsB41e+bRLRIZlcAtpRUZdoMPXJzC/Uioz7LqD6p4UcnLd", + "wbzlTEhsm6VGqDOlbARjpUM9VrQX+dQ5RKayr+RZivZRm0zDKq98FypfIekHlS4omLXqzFOlaR/83ZA1", + "liRmxJUcbnNJuwhHoju0is3wWn190L9dd3q9G6HMDaWt9Hq+p2hvkhfXnV/3759pQhuKo1X1naNPSjbD", + "rEVc59vDw4ghH/dP8E7xZVUezQN7uUrsh27nOc0U0zzKFQ9+4IEmqU71h27n+23GYdkMyTM/Cuvazmbc", + "PYU67wkvyy1mvJDJ1APBbd7vGYdV2Fv2MNtEFYUB3Qt9gKplAIuna2GAUT84VtnqypCXES9/7jus6l7L", + "jeTCdqeWa7kruRyDxnr34RZC/2P3SLnxz2A51jyUxvRYzE5Du7dL3wSxey2xmXsPC6JDWs5I5yjnD2iI", + "Rt/jk/ODkJ2OnVM1sJHTpCG9lmjhCHe5kbLPq1Z09yXuuGiIaVTbAL/Pfgq5gP4nyWdgruWezzjz0vRY", + "qRsBxt/jdYf6x2LBae96mpYz0F/71/ISgIVy49SLr9pJf6LUJIMSsQ/IJVTmy4a/+yAkyrhz5/+BG5Ec", + "FXb6bg76R2vz09DGku4gumE0LbmPzft8onkKphzlheobfndcWhLMOehzhyedF9992+2cq7zIzVGWqVtI", + "Xyn9XmcGnZ+rpdQ7v354LL4WcOWLZW3LaOfO0s7hijxTPO1VHRp7XKa98K1je8pEFJ33OIyK2Go2cxyk", + "nIL9LnLGdTIVc0fhcGexPaKdwowVMgXNDqZqBgfEQqoOmebgujg8/C5xpID/gu61dO9B7XjcrL4C8W0h", + "76FolJzzWn5ERYPuq2SM5kimF/6O1/GkWZFZkWNnUaVnvWAra9M5an02WxN2q2+c8kHgpwDJxIo5t43q", + "G83p46WrX6nMwRTd61axPOMJ+JLzAVy7QX3JpXDU+yvv/X7Y+3N/0Pv1j2fdb7//Ph4F8LvIB9g+dGWL", + "f60QMjRx8dGnhcwpl6kin3LXe9jfLyQbz7gUYzAWRfR+3QoxEtJR4iatvtyerwEee5msVeBq0L2fFvcs", + "FpFcYgOhAqTdCLcjqimJA6NVefqp+d4KCyqhWUPyPW4cQzL7dSZYHtFzQ/+WPhgFHS/O9U5DHrVkaqmx", + "0FJXS0NuOd/y8uj8DAte99mR/xUlP4UrOXWGrGVW+N7pIgMMxwoh0ndJVhiHvE796TKjmFRMYWABJj9U", + "3fINS7gkGwX23MauJCH6w1iVm2BEGAttrO85ERpmhotnoqw7QtbK0AiTmgFfy1AWvTDonMROxVNPVSlQ", + "Bpd7F1Z2QEzOoYI6brUbWFBnUn9d1zJ4PHO+cLN4RwTTqpBpz2qRM6c6yoRiyAELDMhUzEVa8MxPE+O8", + "P6Ai2Oxcen81cK3NdHWlqvni/ZQRnLKl6canpL2SEKhLa5QA6ji9RGZLTVEDsTUBV7VDfSJ4Rfqt3hNM", + "1KEudJMNZP1JIXQpZkVGCaNEdfV+0XFD4gqMyFx14Fh9O5gugKfHNdNW7LYeC1zNVskIraW3V9nx2C+J", + "cmqFbh58u+7QZFkuM41WrHxt14m2wfb7bBonnwj14xbQ+6I/Wj19dhm2US2h8NkwrF/IIBuM6VvAq2xC", + "HAdTGR38RBBabW+8NXAeZf1a6bMYnVHg8lyERhzla/mzgfiPIvVFWNRtvb5jE8zN9tpxrQ9rS6HWgiHy", + "gaFSH9Bu6aRymhsPVRXdstqSVwhDD+Ryb9CJmIf2i6SYZsANoG5V72q1oXFlTOMp27A+EWquNhq/J99w", + "E30m4hK3UlXOJDBxhMMSxkzAEsIMyv7/rUziL2AbVU6fUjzGy6nGaRejDuik5SEe4xb/ArYR2OA1D2IW", + "YaVtlI9m3/r45ZbVVp8IzVc74j9IO/S34E72aVH9TSgi2oBOkIplakDFacw2EKsa3K/noyEcuFwH3fjI", + "M2v+/jIvgezkVYJMrdzctYwVkaMQMSx0lmuYgqR382q1ui4zANfSbSZecY5xW5nRJ8L2xxogBXNjVd5X", + "enJw5/5frpVVB3fPntE/8owLeUCTpTDuT4mf+3CuqZJKm3rgh49+DOd1L2ofdZ/4q8D8CuNNaAQFlUY9", + "Hr4E4hORw3KFxftSAwIUseVz0hZIxtdtSYiXWyB+vVFQG6u64jdwWQ+NfBKNcSVl84OH0VqJg4GsBzml", + "GFcrbbZurgiWagMUHftJAVrmJrAKQCEIbQM4VZa1MzFKRmVzn7BJVQAOlKPtkETq/mZrOl6Nkza1xYad", + "r1HH06uBjWxQ30xbskxNMFfUiuTGsD2prM9UJhNnDYPYCKZ8LhxK8wWbc714yWyBVroZRlLViw5gzBSm", + "VVRHIXdjSE7FVFZvu/Su7m6jaIIP+UFPT8OkuVfOgapwtcA+xX2gFYmChUIseGCFwxAbRgaMXk9DDtyy", + "t6zXo6CrQ0YeBFLIyYcwjHHIy5AT+kTkV8tSvi939Oj1mdiQaDOVrkDg4dZpxjtocyHot4U5+oDLJ4LL", + "cjzng4wcFET42UgtdzYyaqyDgo8RbudpVS3h4G5k7v9RGPJiOTwZuVbpIjKWOwXNqjzHZIwE2B4FJHSv", + "pffJVt6YrmMcmL/m3XHdms7ny0Eb8buQk33/ai4XEmWxMQZ3PLHZ4lricg3PlAaeCulkuXs9u/c4RlGH", + "NYZUQrvQ2RDX82yHsxEY24PxWGl7Las+ZmXh7DBr8FK4mVFRcw8bPgFG6Qk/ON7ogBBap+oZzzDU1Kpr", + "OQzq5NA3YOBygTfNFqpgqcIQaAlux0eWZcCd0iqDYZniM9zX6JccAfMllfrX8iIEzjRhZaxTHXUhy4rH", + "6LZ6UYu/qcPGQ6BL7vUuKsdyGWL9KEiw2A2Bg0QfyJQCY8ukHYpZv5ZWc2mCevuCiTHj6NrRVfiP2zc6", + "m9wGuc6cWKyIjmGSIWA75JAJN+NCOnzAtSkQOAGPq+5PUsnet3d33t+Va5XziRPI/Wt5rmGMqrW7HifG", + "DOQcM16HVXTBPw4peejA39EQ/Xk+upXIJoPgXexZLSYTcHrStSQYECUJifD0CaxV+H5MWIVbPi7p9xED", + "BSgsaFAPb1uK77h61fsXn3vTjF1iM56z//mv/2YY421gxqUVCRZRPj+6Ov6RrUbPxWse+68GLYGStR2Q", + "j5sN/7imIMbrzot6nOSvH4ZbbghHR3fjwbrNNmaOaaBmEn8nrfZZGLI9LLlyQAVXDsAm/ZCwSvXGQ0D1", + "KgJRSLnpBv8spv2WCSLL3FhUrLgRttSg1CaRRkuirYkjOa2H+Ri0QobdJ05iJQVWJqmm6GNkCB2jygxY", + "G3e0398chPLgEJGnj9/AmHE3ZOB55+ptWq77vxsbi07BtC8weL3DRuwMBpv6NEbPnD0rMH3m2VmIv/Il", + "K7Bgum9wVQUO+sHu/5mDWrt+1OANZG78HrrbKdSODX2Y3wGtgo794T4lqA7dveWDiiSGJBWQRRK4fTxD", + "OKyd8jK+xjh5hx/cap7nUDXpEktJP23g8uWwnHCPkPHF69L748U7eOFeceG14ru0BXVZBnJC9vmEE61Z", + "9u3h83+hOovdivQcABMM9qUwCuQRHgC0i1EGLXWxm3e5RmmrEqzCDaL3oBpLOdxa5OSsXMLJEiv2nIws", + "Kwv5TCKsjQ93RJEbk7k/KxdVQxPy/PJlpW6WWOBmzmDZd9V/iGL//PDPm8e5DWYiWXkOPI6zfFl7CM+H", + "1nsCVLjc/yIvL2O6U5ZPOV5x/eVxhPoMPdvTUqHBp7zPzm1qonlWmJW7DxW/DmrSt4yyj4Rze6n6VAbO", + "SIOkj4zRfvWQbLkKrPfeyxreSo1L/mQY++DY5ZbjONQYm4NEA7cwKPtgIJoUsYgh/LAs4vNUYUPNVXZC", + "lWfrag7ROT8j8wKdlHHM+aquP8AlBcc2t4DLCX741HChVeoN7e7tly5BQkdMH0ZZzzePe6vsK1XI9BEd", + "2rhzxtvhFvTgNSB7Reru5w0trCj3vwBQCI8SRupWOo3ZUdfgd4ElhCZgY5W6bKGlYZz99eyclW+B2hsi", + "PA3KojJV9beAGv3VGBK//onQfxU5RuRrPgML2mD7i7aGjyXloA5qVanrO9UgHApfd27cbwUgO6A3XaiD", + "18SBbt2Isamu3q87CWd/rw9yerlbD2csaychYtUv+EvESw+sOgtxrwFCtPCgjeOrsekWCBvevnuW69oD", + "eBacw6iHurn21+L1tVyD2OyvxqZMjcegDTNiIsVYJBxTz8fc0POPFvT667VMof4n92+u6QX4u8i9wYUn", + "UwFzbJcLdnkWJKN4ZFaNqtwdfSlk1f1jtflbeVyMYOizH8VkCpr+q+whzcyMZ1ndHDEqLLP8Blim5AR0", + "/1r2CBLGvmD/6aBNU7BnXeYT/x1gIWV7//nd4WHv+8ND9uaHA7PvBvrCBs2B33XZiGdcJk6VciMPEAJs", + "7z+ffV8bS4BrDv3nboBnGPL9Ye9fGoNWtvmsi38tR3x72HtejmiBSA1bBjhNpw6OqnVU+FdVqclfVadb", + "+422jP8wsZYEu3JFT70PYotXS3at/0NY45I5r2SPaHAJtRs8W2yyhrKZ/LY8ATmBv9aVvvafi4TdTSes", + "GuqvIhRqebVu/V8g2vwFbP0EZfuoFeiVaJMJY1FPN61481oYrPds7ilMvkxMqU4dQZXq+ZZRbZIvEFcw", + "WxchT4mEq7iBjfLbnm+htfsThsY+xtMNQ1Erc8cXCCc8ATbzRi/XOmLWwNPy0R2l5QvgqX9yb0fKuFhQ", + "Cd38nws1q8SC7VVNix6kSyDrj+ZxfWHIglljDXddiRwGiNEParXlW6l7tcT/0yUhtfQSuHd1jVrpfJ8y", + "9AUC8hLsKqHX2wIcYNsBMxV5CWHygLYHYWGdE1NzlPrccaWr+BISCD5UX8NMeR5AuWz9lqoTQT14tOiR", + "UiNpcdGnYOxgQzsF943vs15yMF81zSu02zRS6Hbu6833nvxqqzuXY6BbeLRKDAilsgjDl87qIsUZxl5f", + "q5NDMG2uLTLD0fBCMWjYMZvqyQhrKtvmSvrKMn61EQdZNx+NNHZF/bTecaJWKaeKkVDb0cEjRbaso4d7", + "IvZfRV6hdQ2A/2uQnNcLHi2h6Aq+e+PKBoTf1TTaRhfXcjNhbDaRNiyi13LJJNpe7sjbOB+NuFqjqK6m", + "sGx6KUXIFnFDn4xo41E+bcVa324f6OPbePm9YTEjLO/r0KnXw2961bj9/m41lAMcnoRdHPk7/F/OMpbR", + "tYVt3C4XJFp6CdQaIT3VGyDSa2l72N6zeCoeO9r2/L0UvxUQaxBUUeWtv46t4tWW67XbZMoeu8bfJ0I2", + "OkzdSO0LNclJTRPD2zr4I1z5B1/GHKhIyTK+qbxCtyUjBRoevKXB2x1KOK6zPWw2NTyPFdYnQFGw8xcO", + "qEts+RPiymPWvmUgHVCOXKspibp2vzKn9NlHhNWyWcjCnaXdRu1Bm/wBl/i09c12IjmnVdMbNa69hX0O", + "ITY55Sme+o/Ov/cuL097vnxQ7yraiuINpIL7autj7CqDrTd8SuLeMhPbb3jugpduhdVFnHIfvkQ0pe5C", + "y7fsS54Q2y0x1j3m1wcZYVGebQyeJzXli68YPz+i3/td1ZAgtLFs7WDZ6J3yp+fP27aJbR9btrW27yUR", + "3zYS/4Hm2HtaM8qSUF+6GEWzlJOcIR6yCtXK1MQcVBcbd9GpiSHSaeHDSwjhuwutw9zAaDyKV/Vto139", + "48uMVZap23jkQaP1d61P3jKYMcGjTNsT49DOTxjmt7aGMNulyi7r1M4eX636YJBTm5rOJ5Nor9VkS1Hm", + "EOuzll4xyeA2TTmUl5enRCB5xhe3mtLeqGjkFuVVy+Zf5+Voljhmi77QsQYzrTW1RdDcWcYnXEhDL/GQ", + "haALiSWcpZIsUwnPpsrYF3/+9ttvKTsVZ51ygz3nDLLqb3I+gW+67Bs/7zeU0PONn/KbslNMqNLg+zD6", + "WAycsdoclsq1hZZV67eAXjHDib+C6tzHJB2e4mW3stYnynqI7MNdaDxZpbzcz7EcanUELDtwiTsnjIgg", + "pycQ4klIHe0Pfd9gyy30ZPV9yhU+ER40dtCGAVU1Y+2/+SzK4CZqNnNcwixkMtVKqsKEqrcBwCbnt3Ij", + "hC/xqycFMS7xaWHst9AGZPz5Exc/WYUtXwPcP/w/8G1+I5oVhKKA/klgKZrN7/Jq5rUqYanJF4VIH/JY", + "uBdA3Wk+y0ql7376IuMLHCsRE/fStIoFtbUd46gwwEacu6DP/tdgHZ3nK949XoAS1pfg7PzqP3ojaqWw", + "GfmM5bZoN0UGlk9ffWzce2I5RoeKiTD/yxcZpewBwEw4XjvoU7GFToNf/a/hOnicT6w/0Rba9KcfFti6", + "g8xvX6zFrZJ8jPBsLR6qwm4yxFWXpwq71iL3ifjRAyxL5dncsC1tTOF2VWHzgrrqZ2IMySLJ4KsD5ekc", + "KDWsVoVdMphpSLBc6OSgcsLGuStlDl+E7580UbtcZXNt2eV0Tz/w06Vof6LaFmVid65hLvDNyAi4kLK5", + "SEHV/Ag1qPvkslYuFrLP6oBf6z0rnVZ+dV1vsk9VyHwT/0Y11yLU6vZegXJ4myMLmV7cjcV7vx/1/nrY", + "+3Pv13/6h3uxRrywg1n+/MHpBBVG+pjHBoMrf+29EhKb1PeOYo2exQyM5bPcMTlqzo+W3WpqGtxnfym4", + "5tICxcuNgF28Ov7uu+/+3F/vAWls5ZLiUe61Ex/Lct+NuK18e/jtOsLG4nIiy5jAYpETDcZ0WY79LJjV", + "C7J9Uo3H5nVfgNWL3tHY/bBaCreYTChXFNtqYAdIIVnVMD90X9QLIoLqEGUs27NILNuHLzjhlErxGqRF", + "aqC+BUfJBEmP1vzBC0/Y5qH9Kcp8gHUCJaxGmZ4rQfYr9BoaV+pyl4+WYMezrD5t89pWOqBGQu+eWvg2", + "F1kre5+tI1HPBL7AClF4A2UV94qv9dk7Kjlb53U5aHZ2gi0Qsbb5RBiLXRqxZLXjIP1VKKt8HZBV/vQw", + "rq1xf/XKh8J92oLhVuVN8UPXbRKegVW/g1YHvp/92jYh9FZwE/38hooWuhmw8IdibpauAy7XaYbPlzH7", + "8erqnFnNx2ORMCWZsH12zLMs1Ao5Oj+jEtnCuClvnbS65TfAhGUjSHhhgL2X4kbzsaVfQ+fxxDd2ugHf", + "pGQRihiEnJOf30RLfdAxL93Jr9RfQavONmGN+H3Pqp47JfN3lT4KcM5SmOXKktjwM+O9QrjV2hX1VwEH", + "cj3cLsBYpcH4spk0dXmUshNBtUbX8V91iyoE3mZzM6Q1oEYj0gwIoDS2VHN+fsOk8qVEsHK28brNFLKU", + "cQe2qJddPhw2IJ8INDTxJshYyGDmdJ+NhXbqDZnKUc1Se30WPn5++JyJce07qtpdFUmNtp75C9ircj9P", + "aP0qF7m03EbN7lfxA95Xd1vtbtU+f1m5comdce2bYFC+KwGkFRAo1RJuYUKVeOHOXZZwiGGwfkS9jgob", + "qXSB1WQpqDt9GV5y9Sk0WE7jhC4xwVCHfrMT6Jnv689gDvWtO3z1C1JODNHGC4Zd/lmSAdcmFG2qnTbW", + "xcjdYhOZnqBTLwVglMvUC25+PFvuvbH5C86c9gU/15FREeu6A3YD3QQs/vbwWROLbzmhcc0KU2H0Sx+c", + "5cYdunHCugEO0TNIQgCXym1PyBeMV6J/yq3Hcjd7ndr2+FIJXErWk8picL8jYqc46AK6TOlASYF4gsTf", + "byWalyQI3P+VUsMLxN2Y9nlhPx2dffZ0tWv+0tNsyMCnDXC6XCfyGmpILSElrh6eyb9jvw4uyRfARMhN", + "rRYg10SXTbhv6odJlQkWJF/eRp3kD4nG8GtjxERCykDOIVM5VMqiX9YwngZz57eHzyO/j0VGz8Y9qcLy", + "ocS1TzbDb78xFeEKU9EuEvbzw0Ontc15JlJeds9vafZxXowyYSq5Rw6cJ/Ji0lq4xCfyYlbn9ECKRvoh", + "OHLarWPVJUQTrkOXggre1G8sgT5Rb0R/pwl5kkCO6FXYCtLrce0lSZCwlQfUhm82HaQJtyCJZWJbcXQu", + "W/xBUvPgObCmz6+amQi2z055MmVjzWcUCI3lN5SesaFIX7A/DPz24fpaptzyF+yPAIKeg7f7+/W1HDpp", + "SXfvexGULeISMKY3U1JZJUWCDsYctEHTW6KVMUvszqcmvmScvebG9hBivbMTsgFgtyQvxd1AWUlopDJ8", + "oGswxSw8++nYfXaiVU6boqAqAviE5yYo1EORDqlHCXYk8jYMEHNI6TdhqIqFnXLJnjE+BZ6GkO/M7dUA", + "SPy0G3ydt6AdoxCYt1z2iR8V4zHoPjvOBH7le5tazZObyGxOWUjBQmJxv332CqPfq+OboF8sXRma/Kpl", + "K73fg8oBA9MqDAAW+KZdv2Q5N4YN/x8NecYX/8qzbEh55Y3pVJZi0Ut8Wjhu6/HXWOC+8dOtcPc95Tmm", + "aWA7RJCgRcKGTT43pJ6tQWvytwf+IeMp8ydsfUKNJdme+3yBLZgctlGjQM5SlRQzkG7U0C5yGFITsZJZ", + "D6lnisM5pWdl0ZCqoY/XV/4Rt3WCHxPL6jKDCiHthyaPdhhEhGseb2NlvguHsqEbCSp3pklPvluY0syA", + "TNlhBB4BvKEt37Y02WVGNQlrzrOCchpm4MhMa0iwFgQtxd0aQto+u+I3gJ1cE0hxIfRjDwlvhiRWsZ0k", + "LYytynA5x5B4YVVPg0fjarkMuMRGWYhIZPbv0ZQOQlNhsLxlVVmVvEmVE7JBBLslGZ0j4u+C8H12gTWA", + "kaRZ4vgJt+zZ4bfPX+KAEpl5jRNgmHihxzwBKho6FtpYIvYJZphpz2X6rQVk6UbioRNZdr8asA8IPtlK", + "nr/eQhh9cRlPyydwEL1E/3nv0tGj5wBu9P8fAAD//4OkftquyQEA", } // GetSwagger returns the content of the embedded swagger specification file diff --git a/server/openapi.yaml b/server/openapi.yaml index 7164fc9e..b6237457 100644 --- a/server/openapi.yaml +++ b/server/openapi.yaml @@ -2171,6 +2171,45 @@ components: truncated: type: boolean description: True if the data field was truncated due to size limits. + BrowserPageCrashedEventData: + type: object + additionalProperties: false + required: [target_id, target_type, url] + properties: + target_id: + type: string + description: CDP target identifier of the crashed page. + target_type: + $ref: "#/components/schemas/BrowserTargetType" + url: + type: string + description: URL the page was on when its renderer process crashed. + BrowserPageCrashedEvent: + type: object + description: > + A page's renderer process crashed (CDP Inspector.targetCrashed) — the + "Aw, Snap!" failure — while the browser process itself stayed alive, so + no service_crashed fires. Emitted on the crashed page's attached + session; the CDP session and target ids are on `source.metadata`. + required: [ts, type, category, source] + properties: + ts: + type: integer + format: int64 + description: Event timestamp in Unix microseconds. + type: + type: string + const: page_crashed + category: + type: string + const: page + source: + $ref: "#/components/schemas/BrowserEventSource" + data: + $ref: "#/components/schemas/BrowserPageCrashedEventData" + truncated: + type: boolean + description: True if the data field was truncated due to size limits. BrowserPageLayoutShiftEventData: allOf: - $ref: "#/components/schemas/BrowserEventContext" @@ -3024,6 +3063,7 @@ components: - $ref: "#/components/schemas/BrowserPageDomContentLoadedEvent" - $ref: "#/components/schemas/BrowserPageLoadEvent" - $ref: "#/components/schemas/BrowserPageTabOpenedEvent" + - $ref: "#/components/schemas/BrowserPageCrashedEvent" - $ref: "#/components/schemas/BrowserPageLayoutShiftEvent" - $ref: "#/components/schemas/BrowserPageLcpEvent" - $ref: "#/components/schemas/BrowserPageLayoutSettledEvent" @@ -3057,6 +3097,7 @@ components: page_dom_content_loaded: "#/components/schemas/BrowserPageDomContentLoadedEvent" page_load: "#/components/schemas/BrowserPageLoadEvent" page_tab_opened: "#/components/schemas/BrowserPageTabOpenedEvent" + page_crashed: "#/components/schemas/BrowserPageCrashedEvent" page_layout_shift: "#/components/schemas/BrowserPageLayoutShiftEvent" page_lcp: "#/components/schemas/BrowserPageLcpEvent" page_layout_settled: "#/components/schemas/BrowserPageLayoutSettledEvent" From 55b64012e945dd7a8e6a03e1f218b16bb8092fb3 Mon Sep 17 00:00:00 2001 From: archandatta <35818003+archandatta@users.noreply.github.com> Date: Thu, 16 Jul 2026 13:06:34 +0000 Subject: [PATCH 6/9] Add build-tagged live OTLP export test Exercises the export path end-to-end against a real dockerized collector: severity mapping, category exclusion, promoted attributes, export counters, and a forced queue overflow proving the drop metric. Run with -tags livetest. Co-Authored-By: Claude Opus 4.8 --- server/lib/events/otlp_livetest_test.go | 152 ++++++++++++++++++++++++ 1 file changed, 152 insertions(+) create mode 100644 server/lib/events/otlp_livetest_test.go diff --git a/server/lib/events/otlp_livetest_test.go b/server/lib/events/otlp_livetest_test.go new file mode 100644 index 00000000..80cac367 --- /dev/null +++ b/server/lib/events/otlp_livetest_test.go @@ -0,0 +1,152 @@ +//go:build livetest + +// Live end-to-end test of the OTLP export path against a real dockerized +// OpenTelemetry collector. Run with: go test -tags livetest -run TestLiveOTLPExport ./lib/events/ +package events + +import ( + "context" + "encoding/json" + "io" + "log/slog" + "net" + "os" + "os/exec" + "strings" + "testing" + "time" + + "github.com/go-logr/logr" + "go.opentelemetry.io/otel" + + oapi "github.com/kernel/kernel-images/server/lib/oapi" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" +) + +func TestLiveOTLPExport(t *testing.T) { + const container = "kernel-otlp-livetest" + _ = exec.Command("docker", "rm", "-f", container).Run() + + run := exec.Command("docker", "run", "-d", "--name", container, "-p", "4318:4318", + "otel/opentelemetry-collector-contrib", + "--set=receivers.otlp.protocols.http.endpoint=0.0.0.0:4318", + "--set=exporters.debug.verbosity=detailed", + "--set=service.pipelines.logs.receivers=[otlp]", + "--set=service.pipelines.logs.exporters=[debug]", + ) + out, err := run.CombinedOutput() + require.NoError(t, err, "docker run: %s", out) + t.Cleanup(func() { _ = exec.Command("docker", "rm", "-f", container).Run() }) + time.Sleep(4 * time.Second) // let the collector bind 4318 + + es, err := NewEventStream(EventStreamConfig{RingCapacity: 1024}) + require.NoError(t, err) + m := &OTLPMetrics{} + ctrl := NewOTLPExportController(es, OTLPConfig{ + Endpoint: "127.0.0.1:4318", + Insecure: true, + ServiceName: "kernel-browser", + InstanceName: "live-inst", + Metro: "live-metro", + MaxQueueSize: 256, + ExportInterval: 500 * time.Millisecond, + ExportTimeout: 5 * time.Second, + Metrics: m, + }, slog.New(slog.NewTextHandler(os.Stdout, nil))) + + require.NoError(t, ctrl.Start(context.Background())) + require.True(t, ctrl.Running()) + + publish := func(typ string, cat oapi.TelemetryEventCategory, data any) { + b, _ := json.Marshal(data) + es.Publish(Envelope{Event: Event{Ts: time.Now().UnixMicro(), Type: typ, Category: cat, Source: oapi.BrowserEventSource{Kind: oapi.Cdp}, Data: b}}) + } + publish("page_crashed", Page, oapi.BrowserPageCrashedEventData{TargetId: "t1", TargetType: "page", Url: "https://crash.example.com"}) + publish("system_oom_kill", System, map[string]any{"process_name": "chromium", "pid": 42}) + publish("network_response", Network, map[string]any{"url": "https://ok.example.com", "status": 200, "method": "GET"}) + publish("monitor_screenshot", Screenshot, map[string]any{"data": "BASE64"}) // excluded category + + time.Sleep(2 * time.Second) + require.NoError(t, ctrl.Stop(context.Background())) // drains + flushes + assert.False(t, ctrl.Running()) + + logs, err := exec.Command("docker", "logs", container).CombinedOutput() + require.NoError(t, err) + got := string(logs) + t.Logf("collector received:\n%s", lastLines(got, 60)) + + // #2: crash/OOM land as ERROR, normal events as INFO. + assert.Contains(t, got, "page_crashed", "renderer crash event should reach the collector") + assert.Contains(t, got, "system_oom_kill") + assert.Contains(t, got, "network_response") + assert.Contains(t, got, "SeverityText: ERROR", "crash/OOM must be ERROR severity") + // excluded category must never be exported + assert.NotContains(t, got, "monitor_screenshot", "screenshot category must be excluded") + // promoted attribute from the converter + assert.Contains(t, got, "http.response.status_code") + + // #6: exported counter advanced, nothing failed or dropped. + assert.GreaterOrEqual(t, m.Exported(), uint64(3), "3 non-excluded events should export") + assert.Equal(t, uint64(0), m.Failures()) + assert.Equal(t, uint64(0), m.Dropped()) + t.Logf("metrics: exported=%d failures=%d dropped=%d", m.Exported(), m.Failures(), m.Dropped()) +} + +func lastLines(s string, n int) string { + lines := strings.Split(strings.TrimRight(s, "\n"), "\n") + if len(lines) > n { + lines = lines[len(lines)-n:] + } + return strings.Join(lines, "\n") +} + +// TestLiveOTLPDropMetric forces a real batch-queue overflow (tiny queue + a +// hung endpoint that blocks exports) and asserts the drop-counting log handler +// increments OTLPMetrics.Dropped via the OTel SDK's global logger. +func TestLiveOTLPDropMetric(t *testing.T) { + // A TCP server that accepts and then hangs, so each export blocks until the + // export timeout and the queue backs up. + ln, err := net.Listen("tcp", "127.0.0.1:0") + require.NoError(t, err) + defer ln.Close() + go func() { + for { + c, err := ln.Accept() + if err != nil { + return + } + _ = c // hold it open, never respond + } + }() + + m := &OTLPMetrics{} + // Mirror main.go: the SDK reports drops just below Info, so the base handler + // must admit that level or slog short-circuits before the counter runs. + base := slog.NewTextHandler(io.Discard, &slog.HandlerOptions{Level: slog.LevelInfo - 1}) + otel.SetLogger(logr.FromSlogHandler(NewDropCountingHandler(base, m))) + t.Cleanup(func() { otel.SetLogger(logr.Discard()) }) + + es, err := NewEventStream(EventStreamConfig{RingCapacity: 4096}) + require.NoError(t, err) + ctrl := NewOTLPExportController(es, OTLPConfig{ + Endpoint: ln.Addr().String(), + Insecure: true, + MaxQueueSize: 4, // tiny buffer: overflow under a flood while export blocks + ExportInterval: 50 * time.Millisecond, + ExportTimeout: 2 * time.Second, + Metrics: m, + }, slog.New(slog.NewTextHandler(io.Discard, nil))) + require.NoError(t, ctrl.Start(context.Background())) + + for i := 0; i < 2000; i++ { + es.Publish(Envelope{Event: Event{Ts: time.Now().UnixMicro(), Type: "network_response", Category: Network, Source: oapi.BrowserEventSource{Kind: oapi.Cdp}, Data: []byte(`{"status":200}`)}}) + } + time.Sleep(2 * time.Second) + stopCtx, cancel := context.WithTimeout(context.Background(), 3*time.Second) + defer cancel() + _ = ctrl.Stop(stopCtx) + + t.Logf("metrics: exported=%d failures=%d dropped=%d", m.Exported(), m.Failures(), m.Dropped()) + assert.Greater(t, m.Dropped(), uint64(0), "queue overflow should be counted as drops") +} From 0ebe6c096cc76b5ac1eeaf187c9e1cccff666890 Mon Sep 17 00:00:00 2001 From: archandatta <35818003+archandatta@users.noreply.github.com> Date: Thu, 16 Jul 2026 13:43:30 +0000 Subject: [PATCH 7/9] Review: consumer-facing export spec wording, ctx-aware export logging, crash guard - Drop 'on the VM' from the public export spec descriptions. - Thread request ctx into export reconcile; log via the context logger, and drain with context.WithoutCancel so a toggle-off outlives the request. - Still emit page_crashed (and warn) if a crash fires on an untracked session. Co-Authored-By: Claude Opus 4.8 --- server/cmd/api/api/telemetry.go | 40 +-- server/lib/cdpmonitor/handlers.go | 8 +- server/lib/oapi/oapi.go | 428 +++++++++++++++--------------- server/openapi.yaml | 8 +- 4 files changed, 246 insertions(+), 238 deletions(-) diff --git a/server/cmd/api/api/telemetry.go b/server/cmd/api/api/telemetry.go index 562777cf..98e83a50 100644 --- a/server/cmd/api/api/telemetry.go +++ b/server/cmd/api/api/telemetry.go @@ -2,7 +2,6 @@ package api import ( "context" - "log/slog" "time" oapi "github.com/kernel/kernel-images/server/lib/oapi" @@ -46,7 +45,7 @@ func (s *ApiService) PutTelemetry(ctx context.Context, req oapi.PutTelemetryRequ if allDisabled { if wasActive { s.telemetrySession.Stop() - s.stopTelemetryState() + s.stopTelemetryState(ctx) } return oapi.PutTelemetry200JSONResponse(oapi.TelemetryState{Config: disabledConfig(), Seq: int64(s.telemetrySession.Seq())}), nil } @@ -63,11 +62,11 @@ func (s *ApiService) PutTelemetry(ctx context.Context, req oapi.PutTelemetryRequ } if err := s.reconcileTelemetryState(cfg.Categories); err != nil { - s.rollbackTelemetry(wasActive, prev) + s.rollbackTelemetry(ctx, wasActive, prev) logger.FromContext(ctx).Error("failed to apply telemetry state", "err", err) return oapi.PutTelemetry500JSONResponse{InternalErrorJSONResponse: oapi.InternalErrorJSONResponse{Message: "failed to start telemetry"}}, nil } - s.reconcileExport(cfg.ExportOTLP) + s.reconcileExport(ctx, cfg.ExportOTLP) if wasActive { return oapi.PutTelemetry200JSONResponse(s.buildTelemetryResponse()), nil @@ -94,7 +93,7 @@ func (s *ApiService) PatchTelemetry(ctx context.Context, req oapi.PatchTelemetry cfg, allDisabled := mergeTelemetryConfig(prev, req.Body) if allDisabled { s.telemetrySession.Stop() - s.stopTelemetryState() + s.stopTelemetryState(ctx) return oapi.PatchTelemetry200JSONResponse(oapi.TelemetryState{Config: disabledConfig(), Seq: int64(s.telemetrySession.Seq())}), nil } @@ -102,11 +101,11 @@ func (s *ApiService) PatchTelemetry(ctx context.Context, req oapi.PatchTelemetry // reconcile and roll back on collector-start failure. s.telemetrySession.UpdateConfig(cfg) if err := s.reconcileTelemetryState(cfg.Categories); err != nil { - s.rollbackTelemetry(true, prev) + s.rollbackTelemetry(ctx, true, prev) logger.FromContext(ctx).Error("failed to apply telemetry state", "err", err) return oapi.PatchTelemetry500JSONResponse{InternalErrorJSONResponse: oapi.InternalErrorJSONResponse{Message: "failed to apply telemetry"}}, nil } - s.reconcileExport(cfg.ExportOTLP) + s.reconcileExport(ctx, cfg.ExportOTLP) return oapi.PatchTelemetry200JSONResponse(s.buildTelemetryResponse()), nil } @@ -136,47 +135,50 @@ func (s *ApiService) reconcileTelemetryState(cats []oapi.TelemetryEventCategory) // A fresh session is torn down; an updated session is reverted to prev. Reverting // never requires a fallible collector start (the failed start left it stopped), // so the reconcile here cannot fail. -func (s *ApiService) rollbackTelemetry(wasActive bool, prev telemetry.TelemetryConfig) { +func (s *ApiService) rollbackTelemetry(ctx context.Context, wasActive bool, prev telemetry.TelemetryConfig) { if !wasActive { s.telemetrySession.Stop() - s.stopTelemetryState() + s.stopTelemetryState(ctx) return } s.telemetrySession.UpdateConfig(prev) _ = s.reconcileTelemetryState(prev.Categories) - s.reconcileExport(prev.ExportOTLP) + s.reconcileExport(ctx, prev.ExportOTLP) } // reconcileExport starts or stops the OTLP export sink to match the desired // state. Export is best-effort: a failed start is logged, never surfaced as an -// error, so it cannot fail a telemetry apply. No-op when no export endpoint is -// provisioned on the VM. -func (s *ApiService) reconcileExport(enabled bool) { +// error, so it cannot fail a telemetry apply. No-op when no export destination +// is configured. +func (s *ApiService) reconcileExport(ctx context.Context, enabled bool) { if s.otlpExport == nil { if enabled { - slog.Default().Warn("otlp export enabled but no endpoint provisioned; export inactive") + logger.FromContext(ctx).Warn("otlp export enabled but no destination configured; export inactive") } return } switch { case enabled && !s.otlpExport.Running(): + // Root the export on the app lifecycle, not this request; only its logs + // carry the request context. if err := s.otlpExport.Start(s.lifecycleCtx); err != nil { - slog.Default().Error("otlp export failed to start", "err", err) + logger.FromContext(ctx).Error("otlp export failed to start", "err", err) } case !enabled && s.otlpExport.Running(): - ctx, cancel := context.WithTimeout(context.Background(), otlpStopTimeout) + // Draining must outlive the request, so bound it independently. + stopCtx, cancel := context.WithTimeout(context.WithoutCancel(ctx), otlpStopTimeout) defer cancel() - _ = s.otlpExport.Stop(ctx) + _ = s.otlpExport.Stop(stopCtx) } } // stopTelemetryState tears down the collector, export sink, and middleware // after a session is cleared. -func (s *ApiService) stopTelemetryState() { +func (s *ApiService) stopTelemetryState(ctx context.Context) { if s.cdpMonitor.IsRunning() { s.cdpMonitor.Stop() } - s.reconcileExport(false) + s.reconcileExport(ctx, false) DisableTelemetryMiddleware() } diff --git a/server/lib/cdpmonitor/handlers.go b/server/lib/cdpmonitor/handlers.go index d0af3685..94ee6c66 100644 --- a/server/lib/cdpmonitor/handlers.go +++ b/server/lib/cdpmonitor/handlers.go @@ -180,9 +180,15 @@ func (m *Monitor) dispatchEvent(msg cdpMessage) { // stamped into source metadata by publishEvent. func (m *Monitor) handleTargetCrashed(sessionID string) { m.sessionsMu.RLock() - info := m.sessions[sessionID] + info, tracked := m.sessions[sessionID] m.sessionsMu.RUnlock() + // A crash on a session we never attached to shouldn't happen, but if it + // does, still emit the event (the crash is real) rather than a record with + // empty identity. + if !tracked { + m.log.Warn("cdpmonitor: target crashed on untracked session", "session", sessionID) + } data, _ := json.Marshal(oapi.BrowserPageCrashedEventData{ TargetId: info.targetID, TargetType: oapi.BrowserTargetType(info.targetType), diff --git a/server/lib/oapi/oapi.go b/server/lib/oapi/oapi.go index 49e6b446..e239bf17 100644 --- a/server/lib/oapi/oapi.go +++ b/server/lib/oapi/oapi.go @@ -3099,11 +3099,11 @@ type BrowserTelemetryConfig struct { // Browser Per-category telemetry capture settings for browser events. Browser *BrowserTelemetryCategoriesConfig `json:"browser,omitempty"` - // Export Forwarding of captured telemetry to an external destination. Independent of what is captured: export is off unless explicitly enabled here, even when a destination endpoint is provisioned on the VM. In PATCH requests an omitted field leaves the current setting unchanged. + // Export Forwarding of captured telemetry to an external destination. Independent of what is captured: export is off unless explicitly enabled here, even when an export destination is configured. In PATCH requests an omitted field leaves the current setting unchanged. Export *BrowserTelemetryExportConfig `json:"export,omitempty"` } -// BrowserTelemetryExportConfig Forwarding of captured telemetry to an external destination. Independent of what is captured: export is off unless explicitly enabled here, even when a destination endpoint is provisioned on the VM. In PATCH requests an omitted field leaves the current setting unchanged. +// BrowserTelemetryExportConfig Forwarding of captured telemetry to an external destination. Independent of what is captured: export is off unless explicitly enabled here, even when an export destination is configured. In PATCH requests an omitted field leaves the current setting unchanged. type BrowserTelemetryExportConfig struct { // Otlp OTLP/HTTP export settings. Otlp *BrowserTelemetryOTLPExportConfig `json:"otlp,omitempty"` @@ -3111,7 +3111,7 @@ type BrowserTelemetryExportConfig struct { // BrowserTelemetryOTLPExportConfig OTLP/HTTP export settings. type BrowserTelemetryOTLPExportConfig struct { - // Enabled Whether captured telemetry is forwarded to the configured OTLP endpoint. Off by default. Has no effect (export stays inactive) when no endpoint is provisioned on the VM. + // Enabled Whether captured telemetry is forwarded to the configured OTLP destination. Off by default. Has no effect (export stays inactive) when no export destination is configured. Enabled *bool `json:"enabled,omitempty"` } @@ -19110,217 +19110,217 @@ var swaggerSpec = []string{ "IVU1357XS7ohjJF6tHbr4o0Uh2HFE8ngGuGEiCgjcNeMvkyr+uyoOpIHVKiEQZv0J2FJBlwTfdk4ZOkA", "Q99eZVih6x512cqor79njPvkSLPVHA7Jp6DhJeYsZ+rWMF5YNePWx425Byl6VHn9mpqMJeKh8cfbNnSm", "VZP/0O3AnRM/u850iqPCLNsQXGPEbmT3SulbrpEhqXF5LzWYWUVswoJ2dJCCsVhI0AFwKXQWyybXbvcF", - "owvwGMsKmeFr2bOcbFFii4NjF9ULMiPw+joMZIrNyrBhhVZzYYSSVdW2n99E+K/bdCAY4r11jh/4J72P", - "nBY95XISxwdls3xXEL67en2+OxhXRu0GSjf8AHVGf+3h+XcPURxBBIHPSIcsVShpIEZImVu9hFSfvWuw", - "kz77EZ0ADMZjJ+v2wg4tX7iHgeNMc9gn4LvPNkJ8a+F07B3gQXmBU/d62pVKfP1BNPGMsI14yoJrvboF", - "DOTyHhXj/VAUG0JNOVYBMQNjvAq/arOJh52Uqw1o6hnPDfVIw+iDg7HIgOSR958dOOKV7gYPcq3czwep", - "MHnGF8yJiJdlRoGfEOuJO2XDB9o7fOdW+MJF9V7IzZ2g2aY+U9QCEu8j+y73cra6y+XOsf1GDIjKB+H+", - "qYqltvU/+DbNeAHuqh0v9pfg/sOfP3woitlgnPGJIfi4K9rsEQ5nDiCMGamO3QvyjSoM+ILnO0akjgpr", - "Y6VRcEpGv5KRl8Q7yuLaPWUwtp1uRzt1xm1VpGkWbFrkOHf0HIUTPn5bCr9eeWsafuMf/7VV3WO50+1g", - "jA5+El1gqrJ0cAMLEzteSnGv7md3PvdtvTsmzVpzI6wGwS65BGQxG9B7npZDttR58WyZ0t9iliOaCsUM", - "PGHl4C2aYd1VG+nd6in+nSVKOdHKq6oAdGO5orDN6EyRksv/cZ+ZltD1ruOmbkHSfKS4Tn3JhF1rU0ar", - "1x57EZuEyal0rc/32Rzl6yaNbpY6oeqjyip0D8N94mfxuOugDHeQFBY9ITnXvnkCsnqvqFJXLdIl6Pnp", - "Wfy1rGbJKUeevIgkITVZbqh7GI52l4BvOfeBH5tzzWdgQZv+tTz1L04ly99pZKOmM9q0g46OUjJtiTlC", - "Up45nrFJkVllWB+6nVTzyXbDTzSfLI+eqTlsN/qNmsPyaIwUcGxi0+Bz9+FPsKiNJWvdpoGX+FV9GNhB", - "UmijNr4BLsEe44f10RnARn3x0n3kUbgWnbQaGxf8FisY1pDDNfg27ptmDp2Lqqssr6YB28bJw0FinLua", - "dMMxnZy4gjtbXs8ylcdbMXQ7xxq4hRPsxqH04n7Cc6ZSWKNppGF25j5keyrBqBA8ZZdh9OQ/f//9fp+d", - "kLBAWfDP33+PShy37j3UedH5//522PvnX//4rvv8wz/E02PtNJJmMDIqc9ym2oT7EC0TePSlRQ76/7jZ", - "GepWil3mCWRg4Zzb6f3uccMRwsZTXObxN34BCcq+yf12H3N8nq2k8eiwSO0k7CjLp1wWM9AiYUqz6SKf", - "glyGP+/9ftT762Hvz71f/+kftqvsckLq55avvKVycGibahe4QbWn76rCNi01fLAr+EBzC5un9F8zjT3I", - "Jfvxd7Y34wsnfmSRZUyM0UKTgoUEw0L2o4veijSGUMur4Wdr9x+92mUJ9DQKt2ObLcp2qWST1h2N6gX3", - "+KjroYfLqsqJ+2SlvuEI7C2ADBtxiraPxefaeux1/J/xTJUp0BaLVsyEFDO30cMYTNa26fbJbxhQx8KX", - "K3sLblNHWhrohtxeZmUwvZkpZaf/ShZztNmicTcY7ZzG7c4w4sY/9XFB5C8ZyIk/B7+jczw7PDw8rJ3r", - "++jBHvLKcEfY6ZER55TvNFZaYpkwqFb+7a7LFr/WVfqcC21K2IUuGdTowG1igtFbb5yq53VHxi3LgBvL", - "vqVG/mjkKXe6vOV6aGQZOPUtXl71H8unWfsjwbKBww6uEd8qmxYzLnuZuAH2A/wusEqtnkOFzQjhW76g", - "gzAhjQWOvVgyIYF752yuMm92/AUjjdxqaCQwgxz0wMAEMY3IAfIBEtlgRl0ZxESqZrWrWux54/PGkb7f", - "kS7L8ju4rxUIntEuVqlhI32unLP5ij1sf8aWW0Lcon1hKVR/Xz5oFdlE+wbZG9oee9bY67PN4Txtwr00", - "w21rEFuaeJ3Z5ZTecucZX9wiF95WGMSb1NVeh9WUmO4WibRPW+wl1LXm4N/4nNM/KV+umpuemfjHKTeM", - "Jxj0ZRX7BtuRdNk3Pkf+G3pdfuMdFd+wOdfCiVv/dJzlGbxg1x1+y4Wl1g8TZdXeN1Nrc/Pi4ADom36i", - "Zt/sv2QabKElq32O2b17+y+vO7EgPCrLRuU5kgYe/mkFD98Qt/ZnxCeMmNULWpXqNROG/emwweG/a/D3", - "zbiGl78lPhjc8I7oELoqLmFBdbpVQ3vA8qXMFuwh7FHY6U3V/fj2zfFuTH7Tq+9Eis8nSFYRgbi5PUpE", - "3yc2koKO7OcyhLNSc+MykrF+sIglN1WxcsTlZD50acvZCkT4ddEBUL9tSJkfgs3z4t6ARvqaXyCGIK9E", - "BmdyrFb5kTCDVOj1u0L5hY778jnX0m1TtZb5dKJ8hgqJD+oN1dfK5KaUW+j5KsCrmSdRvuOORa/bkbA+", - "R73Lrjupvr3TPfd/1x33sLnu9PRtT/fc/1134hGk8TjVH7iBRhriWIQwhNWb2PpVHHTWVSQRv8NgtLAQ", - "wZNLH4CKP/d9RdGwDQFmi9jTEEfMUa+vLdYNeFCDob/0NnSiIOOWtMdXpY+GkeexrdnzNujH0aeGXX62", - "xMP7wrJc6r5A3Q1L4mYxnxW4yKFuAzu+OD26Ou10O79cnOH/npy+PsV/XJy+PXpzukWGHyX3tSos2KFu", - "xfMeh++JcP8VslcL6avYl4V/Sqeqj6gL3UY83/6JIugxKLJKQOFlChvPmOV3SqrZ4gWmt1IZCe8drWY3", - "VgOf+YSBIbYiQweb0jPULJQsYY06hNvKCDJ1y/bIwk1bItO3j00att/DsMs0TLhO0c2PAQGK5cUoE5iZ", - "LGyfHfMsA92r/ugvAEOU3l1esYNy9wf+p5BXWyYxBvezMHSzL5kBYMOlvZTvUexXbKY8hz77mWciLZsK", - "JLiZkJ1Sj14VprzgkPqT+JJF2NoOQzGDRxR1pLSCOAn8Gc9zh2ZOx8jFwK21IXrgKBfuegiluiEee4DR", - "0oMg/NfO4AOsL90I0lbKydJ84AOWNs2R5sf0YX2sO962w0/Kb8sZKCpp4LWh9RPQt6ghLY/P1GS70a/V", - "JIytRT6RA3DDDGfV9+gMic2D7ohtZ/kJFrE5yAJf1iXbejpyVzRq7XU7mZjDYC7gdksgvxZz+FnA7RKk", - "q2m2hneYaRXoPrCrNtXGY76hISe1EcuzCSnswOvIW012JoV9hd8vT6XBr7LTfBdh1IZJd55vda568PQ2", - "U12W34eZ6sUMt2v3fJZmsDzacUchJ9tdk5/nNY1pXtJS59ltG1Djx6tz+D7Lu3ex7nSbrR93a6gZRkf6", - "yN2zY1+Ycamr1Natk5q8YLVJ0O49mMppknyHjhzlKMXTXUqfh3G18r07l0ZenWOHe2ypYdpdKWC3a23A", - "WrLYdsgWK1LWXalWsWshEJ/I7d4Vi7eo+5N6+6HbURK2T2xYlq4fursMq4n0LQfGOMCuQ+t0v9vYCAvb", - "bYKKl245LobXOwyNM5cdJqgocodBSxi/w8gGlu+yzWVutcvYwKt2X6/OGu4F0PvMEFdHdx9caqG7D41o", - "nFtO0qKX7DZ6VRvcbfyKgnXP4ffgAy0q6JajG+/BbVnt0utt+2HLCvyWI6MviR3H3nPpttfulsOjYvK+", - "tS+pz8VrYSya9iJmMK35gqlxxKgmJNl4KdXBBlvlViUySsN1xBtdiulIldNMTZarFvA8z7zxeW2c+nJ/", - "qknpx7BwZ1v7CbX0PbkSM9+Vr9wRdS2kzPxtLeAtzsH60jGbHoZ1nPsY2ovyRbHsBNg2uDeEzt0/qLdt", - "hq2DeVdiKHeLf3nEOBAMKnxgBEgqjOUygYZb8Punjvtwe94p7uPhwRDedl9FPrh/cmmXbjFuzt+EnlVg", - "ScAwZtW90HTbmXZC1/tHJqZg7GBThGUtkSz4lTYFKHY7RiebJqbSf1vPueyNDAt0a6eI3dC7mzpf2sFd", - "/Rcqoc/e/RQM1rDK19XNRqw9o5YaYIK/tb/Z16puomc55zaZ+uDH+0G8LfrxpD3qsWQU3z4/3D0G8qQ1", - "9rHPzsYhxbDLCuNzC6diMgVjqzrDNCRwRQ2IPl7Ieu/Vnw673x12v/2+++zw1/gW8Wq9GW8TvMY+NkrD", - "2PEOSg0TvwOx4LKOiVNCyrDXAw14TGEY5eLFOY3PMasyrVZDa6vVqRhuyL/z5XKr8wfPp1UMpCmoAjJP", - "eU6R1hJuQ63CKkAEcQLvcgo8HRdZlzKmw1+yFvRsDTo9aQ02LdHmu28Ptws9Xc5AuJ/k3RAWGqRuEFtU", - "Q2VhKBZ0ueViDUUduA+79C3XwCwWbNscebZGkJah9LNNEvUGFlTzkRl3OV6iby9g4+u/9gGVbnazmI0U", - "lZXBhfrslCdT5pYIDURGwHjtW2aKvKpPeJcqq1R2LfcMAPv3Z8/wLIsZS2GMxfyVNPt95sOrTFk387pz", - "gUE3150uu+6gTYL+eWx1Rv86yvyfXn1/3elfU1Alxd0JQ1GhCW6QZ0a5XSZqNvIiy/hMBJrvn2yI18D/", - "wtX+6YqPcNodLnSJW+PtRvk1VQU7vYPk0SLouDveDKM0F9LxEYmFy1dFE9eTZjDm3yI1kmgmridF2Vl1", - "e6ziZqCVaoZSxo9RNCuBY8UDN5TlWsxFBhNoYTvcDApfTGD9lKEBofvaTSWLDKVH4PGr+Zl09kh8BF50", - "KAdippBl5ZU7WVDE+7glt7F0cKWxXHn1WN3j9XiOfT+j95DTItSYd/kAm3UukPN29PojFkXvYfbHh2WA", - "ncq50Eriw6OMjsQ61L6BUrzmXYX5KxGOuwU1tgOwPXaRwLmRDB8UuMjrRFcCrDzHKhGufQ+eludvewzG", - "6wnCnbCDeKTseaioGBpKtJTHxzjGwehPz+NhTLUiUPQpGxXjcUunPopj3HYyVdj2yT60Q+8nUSUZ7ga+", - "S2qngdgry9ILNextgowq1TSYWufq9OJNZ/289WAq//lPZ69fd7qds7dXnW7nx/fnm2Oo/NprkPgCVdH7", - "ShOqecvOr/6jN+LJTbN48XIkdmbiHTDLfjqJyooZtZNcF2Xc7Wh1u2ku98mOofE4a5c2uubGLnN+K+sX", - "tlUpsojoXu1J7GvIwsDaxWYpeOS/ZpzlBopU9crT751f/cf+MmMlzR4FURn4MgeSSC3iMg600C5qGXC+", - "VkztEBistZxQsQNIV1Zyn91/mQ/RbshNuN6Dn5/VDMZ85BgSZ8bNto4eohVg312WwGrrRBJq7MaGX2Kp", - "xl7ZMzbSsay2n9KOWxQijTNibPA84DZuJ6YuECt9WfywHUzFraRmuS3MrlXxasXYCkNStp0r5cUgT2Lt", - "UY0VM4wWPT5/zwq0p+egE5CWT2JtuNeK0aofk2jWEJ5y4zuabaOjUCH9lnjrasehLHmoik67L0OxWyR4", - "1NxyXsHUNuJ7q14/tP24LGoHbCrk/YTOCbfccbJbLcgAuoR6lOogZF5EwrdTbvlWikVaX2VzK55y3l83", - "nvlB+qLbjk8rNW661RO6LyzINiSp8tDwA+Y/73e2Nan4o2jgVSz9LrrT5WlZfV5DrsE4DlVrPeZzVJRe", - "KXP6UGiWjrUKWdwpoiooxP10r5tbWgl6d6QQTTDeijWUjJQmF4Zd48DrThvJuv1HpAAZwn2wuao1BEqm", - "hbxp1m3ClKEyEWlLIqZocYT/w+wQI5UuqIEuTRnqcNIFSE/dywH063v+x7ITyiKorLSRoZ0inQuj9OKF", - "r2p5I9VtWN3Xlwmd7spW7Es1Snlhp0oLizmdGZWmpuRWUys02mdnVHUPm0oaX8irkLRgUhjrcHORg+k6", - "NCDbK9b9Ih7TbIgTil1XNY+7oTh6vUJzVXW6Uce7LKPbqAZcxrdX8a5rG2C1FQuly/Mk3n9wt6sNGSfr", - "m75vW92EKlqAjmecjYXE1Iht1KCqbEUY1aYEbbQnkX63+mdT1t+o/d5Int5aaat26wfdc7NL94zKZH2f", - "sTuvYpAuYLJN5ajt/E4/+kqxoYrIxBtB1tTcaPFE/IIeiF0m2jIqgeb6xj3H8l4GY8f9tYQHxSnsMGfU", - "FRxuoRsudhPI7uNR0SWgN5R/aiJGVAQ1i0Tt6qXOLB/crXfs/Ki0+F1JLEGEazE+U4W0fUbhKe7hjH83", - "DBOPu0zChDf+7uAQl9y0gw0VR352O062WD9VtzKyfJHHF39IJEZZpmp7o/4mquDWF+asamk1l9qdKHae", - "cuvwiJUCYztyLZGmIDekVFMYR+Uj84M2+vj9dy3bfiUyOAc9EwZrbt5v/9g/MG54o9aClK2q2V8a1otd", - "06Ijlb/+9Pz5/m6FvtStjPl53F7xJ/TshP2+b9nvNim0lM2ZV3dL7lzyHPoyxvcswrUmpblesW7HHjW8", - "MFAvcEB9A3JIHO2npe9gR+dD3ROOpepivod6KYlG0NjhRqKsLx69EKfCvDK/cJs8al21sugdmgOw/mS8", - "GIQjXDGHzXbbktr9fKwcmy22iOVpjUzCG3hgdbax5jOIR95cVLpt+MiBeJw7ip2D1iIFE95K/gb26zD/", - "9nCTEThqEg0Ptogxs6bAAtLeI9WIw00HhD6Tl4TA7Y7Hah91x1sIwFx/O2svZMbvsHaB+B3O5Jsf2neA", - "Ucyh5debH7aEyHLJrmctAVnudEdFKtRm5D72jRy4+5zKnmGD6LlIQfXZBSGyqb+rnZ7B5+Ae/jTKR/K5", - "p/R5kRk48n9NbsDWS5xjSzxMymcGrGEjZae1Iuf7vjIVBSk18UUY2lHPvcj7W5Yuv7Qqfyh9KZ2Am2fz", - "TZ7NZpAKbiFbYG93jHJQhWUTzRMYFxkz08I65c+XJJhhWByaCoXEuA6tC2wVgUdFHIm7eXapyUgAcxt6", - "woKMVe0AOYdM5bvGWl5h3Tsaykp3iMX+ubUiNWyp7kGkMH8wBK4tq9qsPoEla39rtaX3Zkoqq6RIyuAr", - "Rk6Eaqc80coQkWRiDPXOpb4dF3tvfP/f19zYHq7cOzvx0YWFD+K/vDwNdkBv/hSG6tORRWmlU/cO7lJ3", - "xmAp/XUtDNuSHpbKblDBrVuhoZfBHDJvS8JSEVh+K6+V5PCQqzoTYOBECK2TS6fvsyM9ElZzHapnePWS", - "ejj5UhxV4QnHwFKarM9erTTrW1cfpBsr7IE7Bt1DmxWhDUtVgkFSUPaNHnoj2D/6ihkHS385wXlrAXBd", - "tloWZFOT+7Xm0c/ayFiB8N8u370tbYwx+GTC+HtdXx6FqkWRO2IZXs1K4TFIECDdhT9dU/9LsAHLvLgs", - "3QStPf6t4/W+L27Z53/7Nv/Y07/R5b/R4L9Rf7nevQW5FO7Oh7j2Yxwm0nn3oxh5S9hfBk/nPXzKba2T", - "VoMl8zwTLVbYX3iW9ZJMJTd0ZZW5onaZzaZbDr5+SsrTsaEoZKMfTL0f0/YO+K5vHLJzh6Wyr9I9xZ2X", - "aBk3dkUSVx3xNRiwQSI2r4We16a/VpIdbhHrhwehc0RxZ6lu+s72xodVF76BhbFa3YCJVgSNRr/Eq5be", - "Ky8qBGxW+wh5YbX8KMeJ7rC9ecYX/WvZYBK6ALYX+lrPQkbcQRpqQ+/32SV17ysTCq6ljwB3LMCthboO", - "l0yF92BtvcZNsT38278eunvxaVv7/WtZq1KLrS/crS1ykhK3SqfYwD0lH6kPKS5PLqTVvOe+ogXNtXR6", - "g+RU/AsFIv2c88I4OF1hIzu3N+LQbi9rQBdtn9Rt6eXhUBHvFZsRkDCYKgxbpzYaLcXb1MARTALrcRF7", - "GE+5E/BO11/kign5d9/kz736X7KZMJbfAClKKCdRB8E7G/HkxuQ8gQoJ2GGfvZPZwrMwE7sBtmdEBtJm", - "i8Y9XcvqM8SNfbqq8gl72H8WxfoQlrNtH5NftLBQdl65H6Gvh1YjYCUUGwwL3rcBywfsyktuS6wS23nR", - "8droGbbwZUfnZ51uZw7a0HYO+8/6h2ggzUHyXHRedL7rH/a/86X28CAHIZ/ogLowkXEsiVjH3oCeAOYG", - "4ZeEAnAnDAZ1KAmmy4rcCR+2NGkkI2ku3PMsB41e+bRLRIZlcAtpRUZdoMPXJzC/Uioz7LqD6p4UcnLd", - "wbzlTEhsm6VGqDOlbARjpUM9VrQX+dQ5RKayr+RZivZRm0zDKq98FypfIekHlS4omLXqzFOlaR/83ZA1", - "liRmxJUcbnNJuwhHoju0is3wWn190L9dd3q9G6HMDaWt9Hq+p2hvkhfXnV/3759pQhuKo1X1naNPSjbD", - "rEVc59vDw4ghH/dP8E7xZVUezQN7uUrsh27nOc0U0zzKFQ9+4IEmqU71h27n+23GYdkMyTM/Cuvazmbc", - "PYU67wkvyy1mvJDJ1APBbd7vGYdV2Fv2MNtEFYUB3Qt9gKplAIuna2GAUT84VtnqypCXES9/7jus6l7L", - "jeTCdqeWa7kruRyDxnr34RZC/2P3SLnxz2A51jyUxvRYzE5Du7dL3wSxey2xmXsPC6JDWs5I5yjnD2iI", - "Rt/jk/ODkJ2OnVM1sJHTpCG9lmjhCHe5kbLPq1Z09yXuuGiIaVTbAL/Pfgq5gP4nyWdgruWezzjz0vRY", - "qRsBxt/jdYf6x2LBae96mpYz0F/71/ISgIVy49SLr9pJf6LUJIMSsQ/IJVTmy4a/+yAkyrhz5/+BG5Ec", - "FXb6bg76R2vz09DGku4gumE0LbmPzft8onkKphzlheobfndcWhLMOehzhyedF9992+2cq7zIzVGWqVtI", - "Xyn9XmcGnZ+rpdQ7v354LL4WcOWLZW3LaOfO0s7hijxTPO1VHRp7XKa98K1je8pEFJ33OIyK2Go2cxyk", - "nIL9LnLGdTIVc0fhcGexPaKdwowVMgXNDqZqBgfEQqoOmebgujg8/C5xpID/gu61dO9B7XjcrL4C8W0h", - "76FolJzzWn5ERYPuq2SM5kimF/6O1/GkWZFZkWNnUaVnvWAra9M5an02WxN2q2+c8kHgpwDJxIo5t43q", - "G83p46WrX6nMwRTd61axPOMJ+JLzAVy7QX3JpXDU+yvv/X7Y+3N/0Pv1j2fdb7//Ph4F8LvIB9g+dGWL", - "f60QMjRx8dGnhcwpl6kin3LXe9jfLyQbz7gUYzAWRfR+3QoxEtJR4iatvtyerwEee5msVeBq0L2fFvcs", - "FpFcYgOhAqTdCLcjqimJA6NVefqp+d4KCyqhWUPyPW4cQzL7dSZYHtFzQ/+WPhgFHS/O9U5DHrVkaqmx", - "0FJXS0NuOd/y8uj8DAte99mR/xUlP4UrOXWGrGVW+N7pIgMMxwoh0ndJVhiHvE796TKjmFRMYWABJj9U", - "3fINS7gkGwX23MauJCH6w1iVm2BEGAttrO85ERpmhotnoqw7QtbK0AiTmgFfy1AWvTDonMROxVNPVSlQ", - "Bpd7F1Z2QEzOoYI6brUbWFBnUn9d1zJ4PHO+cLN4RwTTqpBpz2qRM6c6yoRiyAELDMhUzEVa8MxPE+O8", - "P6Ai2Oxcen81cK3NdHWlqvni/ZQRnLKl6canpL2SEKhLa5QA6ji9RGZLTVEDsTUBV7VDfSJ4Rfqt3hNM", - "1KEudJMNZP1JIXQpZkVGCaNEdfV+0XFD4gqMyFx14Fh9O5gugKfHNdNW7LYeC1zNVskIraW3V9nx2C+J", - "cmqFbh58u+7QZFkuM41WrHxt14m2wfb7bBonnwj14xbQ+6I/Wj19dhm2US2h8NkwrF/IIBuM6VvAq2xC", - "HAdTGR38RBBabW+8NXAeZf1a6bMYnVHg8lyERhzla/mzgfiPIvVFWNRtvb5jE8zN9tpxrQ9rS6HWgiHy", - "gaFSH9Bu6aRymhsPVRXdstqSVwhDD+Ryb9CJmIf2i6SYZsANoG5V72q1oXFlTOMp27A+EWquNhq/J99w", - "E30m4hK3UlXOJDBxhMMSxkzAEsIMyv7/rUziL2AbVU6fUjzGy6nGaRejDuik5SEe4xb/ArYR2OA1D2IW", - "YaVtlI9m3/r45ZbVVp8IzVc74j9IO/S34E72aVH9TSgi2oBOkIplakDFacw2EKsa3K/noyEcuFwH3fjI", - "M2v+/jIvgezkVYJMrdzctYwVkaMQMSx0lmuYgqR382q1ui4zANfSbSZecY5xW5nRJ8L2xxogBXNjVd5X", - "enJw5/5frpVVB3fPntE/8owLeUCTpTDuT4mf+3CuqZJKm3rgh49+DOd1L2ofdZ/4q8D8CuNNaAQFlUY9", - "Hr4E4hORw3KFxftSAwIUseVz0hZIxtdtSYiXWyB+vVFQG6u64jdwWQ+NfBKNcSVl84OH0VqJg4GsBzml", - "GFcrbbZurgiWagMUHftJAVrmJrAKQCEIbQM4VZa1MzFKRmVzn7BJVQAOlKPtkETq/mZrOl6Nkza1xYad", - "r1HH06uBjWxQ30xbskxNMFfUiuTGsD2prM9UJhNnDYPYCKZ8LhxK8wWbc714yWyBVroZRlLViw5gzBSm", - "VVRHIXdjSE7FVFZvu/Su7m6jaIIP+UFPT8OkuVfOgapwtcA+xX2gFYmChUIseGCFwxAbRgaMXk9DDtyy", - "t6zXo6CrQ0YeBFLIyYcwjHHIy5AT+kTkV8tSvi939Oj1mdiQaDOVrkDg4dZpxjtocyHot4U5+oDLJ4LL", - "cjzng4wcFET42UgtdzYyaqyDgo8RbudpVS3h4G5k7v9RGPJiOTwZuVbpIjKWOwXNqjzHZIwE2B4FJHSv", - "pffJVt6YrmMcmL/m3XHdms7ny0Eb8buQk33/ai4XEmWxMQZ3PLHZ4lricg3PlAaeCulkuXs9u/c4RlGH", - "NYZUQrvQ2RDX82yHsxEY24PxWGl7Las+ZmXh7DBr8FK4mVFRcw8bPgFG6Qk/ON7ogBBap+oZzzDU1Kpr", - "OQzq5NA3YOBygTfNFqpgqcIQaAlux0eWZcCd0iqDYZniM9zX6JccAfMllfrX8iIEzjRhZaxTHXUhy4rH", - "6LZ6UYu/qcPGQ6BL7vUuKsdyGWL9KEiw2A2Bg0QfyJQCY8ukHYpZv5ZWc2mCevuCiTHj6NrRVfiP2zc6", - "m9wGuc6cWKyIjmGSIWA75JAJN+NCOnzAtSkQOAGPq+5PUsnet3d33t+Va5XziRPI/Wt5rmGMqrW7HifG", - "DOQcM16HVXTBPw4peejA39EQ/Xk+upXIJoPgXexZLSYTcHrStSQYECUJifD0CaxV+H5MWIVbPi7p9xED", - "BSgsaFAPb1uK77h61fsXn3vTjF1iM56z//mv/2YY421gxqUVCRZRPj+6Ov6RrUbPxWse+68GLYGStR2Q", - "j5sN/7imIMbrzot6nOSvH4ZbbghHR3fjwbrNNmaOaaBmEn8nrfZZGLI9LLlyQAVXDsAm/ZCwSvXGQ0D1", - "KgJRSLnpBv8spv2WCSLL3FhUrLgRttSg1CaRRkuirYkjOa2H+Ri0QobdJ05iJQVWJqmm6GNkCB2jygxY", - "G3e0398chPLgEJGnj9/AmHE3ZOB55+ptWq77vxsbi07BtC8weL3DRuwMBpv6NEbPnD0rMH3m2VmIv/Il", - "K7Bgum9wVQUO+sHu/5mDWrt+1OANZG78HrrbKdSODX2Y3wGtgo794T4lqA7dveWDiiSGJBWQRRK4fTxD", - "OKyd8jK+xjh5hx/cap7nUDXpEktJP23g8uWwnHCPkPHF69L748U7eOFeceG14ru0BXVZBnJC9vmEE61Z", - "9u3h83+hOovdivQcABMM9qUwCuQRHgC0i1EGLXWxm3e5RmmrEqzCDaL3oBpLOdxa5OSsXMLJEiv2nIws", - "Kwv5TCKsjQ93RJEbk7k/KxdVQxPy/PJlpW6WWOBmzmDZd9V/iGL//PDPm8e5DWYiWXkOPI6zfFl7CM+H", - "1nsCVLjc/yIvL2O6U5ZPOV5x/eVxhPoMPdvTUqHBp7zPzm1qonlWmJW7DxW/DmrSt4yyj4Rze6n6VAbO", - "SIOkj4zRfvWQbLkKrPfeyxreSo1L/mQY++DY5ZbjONQYm4NEA7cwKPtgIJoUsYgh/LAs4vNUYUPNVXZC", - "lWfrag7ROT8j8wKdlHHM+aquP8AlBcc2t4DLCX741HChVeoN7e7tly5BQkdMH0ZZzzePe6vsK1XI9BEd", - "2rhzxtvhFvTgNSB7Reru5w0trCj3vwBQCI8SRupWOo3ZUdfgd4ElhCZgY5W6bKGlYZz99eyclW+B2hsi", - "PA3KojJV9beAGv3VGBK//onQfxU5RuRrPgML2mD7i7aGjyXloA5qVanrO9UgHApfd27cbwUgO6A3XaiD", - "18SBbt2Isamu3q87CWd/rw9yerlbD2csaychYtUv+EvESw+sOgtxrwFCtPCgjeOrsekWCBvevnuW69oD", - "eBacw6iHurn21+L1tVyD2OyvxqZMjcegDTNiIsVYJBxTz8fc0POPFvT667VMof4n92+u6QX4u8i9wYUn", - "UwFzbJcLdnkWJKN4ZFaNqtwdfSlk1f1jtflbeVyMYOizH8VkCpr+q+whzcyMZ1ndHDEqLLP8Blim5AR0", - "/1r2CBLGvmD/6aBNU7BnXeYT/x1gIWV7//nd4WHv+8ND9uaHA7PvBvrCBs2B33XZiGdcJk6VciMPEAJs", - "7z+ffV8bS4BrDv3nboBnGPL9Ye9fGoNWtvmsi38tR3x72HtejmiBSA1bBjhNpw6OqnVU+FdVqclfVadb", - "+422jP8wsZYEu3JFT70PYotXS3at/0NY45I5r2SPaHAJtRs8W2yyhrKZ/LY8ATmBv9aVvvafi4TdTSes", - "GuqvIhRqebVu/V8g2vwFbP0EZfuoFeiVaJMJY1FPN61481oYrPds7ilMvkxMqU4dQZXq+ZZRbZIvEFcw", - "WxchT4mEq7iBjfLbnm+htfsThsY+xtMNQ1Erc8cXCCc8ATbzRi/XOmLWwNPy0R2l5QvgqX9yb0fKuFhQ", - "Cd38nws1q8SC7VVNix6kSyDrj+ZxfWHIglljDXddiRwGiNEParXlW6l7tcT/0yUhtfQSuHd1jVrpfJ8y", - "9AUC8hLsKqHX2wIcYNsBMxV5CWHygLYHYWGdE1NzlPrccaWr+BISCD5UX8NMeR5AuWz9lqoTQT14tOiR", - "UiNpcdGnYOxgQzsF943vs15yMF81zSu02zRS6Hbu6833nvxqqzuXY6BbeLRKDAilsgjDl87qIsUZxl5f", - "q5NDMG2uLTLD0fBCMWjYMZvqyQhrKtvmSvrKMn61EQdZNx+NNHZF/bTecaJWKaeKkVDb0cEjRbaso4d7", - "IvZfRV6hdQ2A/2uQnNcLHi2h6Aq+e+PKBoTf1TTaRhfXcjNhbDaRNiyi13LJJNpe7sjbOB+NuFqjqK6m", - "sGx6KUXIFnFDn4xo41E+bcVa324f6OPbePm9YTEjLO/r0KnXw2961bj9/m41lAMcnoRdHPk7/F/OMpbR", - "tYVt3C4XJFp6CdQaIT3VGyDSa2l72N6zeCoeO9r2/L0UvxUQaxBUUeWtv46t4tWW67XbZMoeu8bfJ0I2", - "OkzdSO0LNclJTRPD2zr4I1z5B1/GHKhIyTK+qbxCtyUjBRoevKXB2x1KOK6zPWw2NTyPFdYnQFGw8xcO", - "qEts+RPiymPWvmUgHVCOXKspibp2vzKn9NlHhNWyWcjCnaXdRu1Bm/wBl/i09c12IjmnVdMbNa69hX0O", - "ITY55Sme+o/Ov/cuL097vnxQ7yraiuINpIL7autj7CqDrTd8SuLeMhPbb3jugpduhdVFnHIfvkQ0pe5C", - "y7fsS54Q2y0x1j3m1wcZYVGebQyeJzXli68YPz+i3/td1ZAgtLFs7WDZ6J3yp+fP27aJbR9btrW27yUR", - "3zYS/4Hm2HtaM8qSUF+6GEWzlJOcIR6yCtXK1MQcVBcbd9GpiSHSaeHDSwjhuwutw9zAaDyKV/Vto139", - "48uMVZap23jkQaP1d61P3jKYMcGjTNsT49DOTxjmt7aGMNulyi7r1M4eX636YJBTm5rOJ5Nor9VkS1Hm", - "EOuzll4xyeA2TTmUl5enRCB5xhe3mtLeqGjkFuVVy+Zf5+Voljhmi77QsQYzrTW1RdDcWcYnXEhDL/GQ", - "haALiSWcpZIsUwnPpsrYF3/+9ttvKTsVZ51ygz3nDLLqb3I+gW+67Bs/7zeU0PONn/KbslNMqNLg+zD6", - "WAycsdoclsq1hZZV67eAXjHDib+C6tzHJB2e4mW3stYnynqI7MNdaDxZpbzcz7EcanUELDtwiTsnjIgg", - "pycQ4klIHe0Pfd9gyy30ZPV9yhU+ER40dtCGAVU1Y+2/+SzK4CZqNnNcwixkMtVKqsKEqrcBwCbnt3Ij", - "hC/xqycFMS7xaWHst9AGZPz5Exc/WYUtXwPcP/w/8G1+I5oVhKKA/klgKZrN7/Jq5rUqYanJF4VIH/JY", - "uBdA3Wk+y0ql7376IuMLHCsRE/fStIoFtbUd46gwwEacu6DP/tdgHZ3nK949XoAS1pfg7PzqP3ojaqWw", - "GfmM5bZoN0UGlk9ffWzce2I5RoeKiTD/yxcZpewBwEw4XjvoU7GFToNf/a/hOnicT6w/0Rba9KcfFti6", - "g8xvX6zFrZJ8jPBsLR6qwm4yxFWXpwq71iL3ifjRAyxL5dncsC1tTOF2VWHzgrrqZ2IMySLJ4KsD5ekc", - "KDWsVoVdMphpSLBc6OSgcsLGuStlDl+E7580UbtcZXNt2eV0Tz/w06Vof6LaFmVid65hLvDNyAi4kLK5", - "SEHV/Ag1qPvkslYuFrLP6oBf6z0rnVZ+dV1vsk9VyHwT/0Y11yLU6vZegXJ4myMLmV7cjcV7vx/1/nrY", - "+3Pv13/6h3uxRrywg1n+/MHpBBVG+pjHBoMrf+29EhKb1PeOYo2exQyM5bPcMTlqzo+W3WpqGtxnfym4", - "5tICxcuNgF28Ov7uu+/+3F/vAWls5ZLiUe61Ex/Lct+NuK18e/jtOsLG4nIiy5jAYpETDcZ0WY79LJjV", - "C7J9Uo3H5nVfgNWL3tHY/bBaCreYTChXFNtqYAdIIVnVMD90X9QLIoLqEGUs27NILNuHLzjhlErxGqRF", - "aqC+BUfJBEmP1vzBC0/Y5qH9Kcp8gHUCJaxGmZ4rQfYr9BoaV+pyl4+WYMezrD5t89pWOqBGQu+eWvg2", - "F1kre5+tI1HPBL7AClF4A2UV94qv9dk7Kjlb53U5aHZ2gi0Qsbb5RBiLXRqxZLXjIP1VKKt8HZBV/vQw", - "rq1xf/XKh8J92oLhVuVN8UPXbRKegVW/g1YHvp/92jYh9FZwE/38hooWuhmw8IdibpauAy7XaYbPlzH7", - "8erqnFnNx2ORMCWZsH12zLMs1Ao5Oj+jEtnCuClvnbS65TfAhGUjSHhhgL2X4kbzsaVfQ+fxxDd2ugHf", - "pGQRihiEnJOf30RLfdAxL93Jr9RfQavONmGN+H3Pqp47JfN3lT4KcM5SmOXKktjwM+O9QrjV2hX1VwEH", - "cj3cLsBYpcH4spk0dXmUshNBtUbX8V91iyoE3mZzM6Q1oEYj0gwIoDS2VHN+fsOk8qVEsHK28brNFLKU", - "cQe2qJddPhw2IJ8INDTxJshYyGDmdJ+NhXbqDZnKUc1Se30WPn5++JyJce07qtpdFUmNtp75C9ircj9P", - "aP0qF7m03EbN7lfxA95Xd1vtbtU+f1m5comdce2bYFC+KwGkFRAo1RJuYUKVeOHOXZZwiGGwfkS9jgob", - "qXSB1WQpqDt9GV5y9Sk0WE7jhC4xwVCHfrMT6Jnv689gDvWtO3z1C1JODNHGC4Zd/lmSAdcmFG2qnTbW", - "xcjdYhOZnqBTLwVglMvUC25+PFvuvbH5C86c9gU/15FREeu6A3YD3QQs/vbwWROLbzmhcc0KU2H0Sx+c", - "5cYdunHCugEO0TNIQgCXym1PyBeMV6J/yq3Hcjd7ndr2+FIJXErWk8picL8jYqc46AK6TOlASYF4gsTf", - "byWalyQI3P+VUsMLxN2Y9nlhPx2dffZ0tWv+0tNsyMCnDXC6XCfyGmpILSElrh6eyb9jvw4uyRfARMhN", - "rRYg10SXTbhv6odJlQkWJF/eRp3kD4nG8GtjxERCykDOIVM5VMqiX9YwngZz57eHzyO/j0VGz8Y9qcLy", - "ocS1TzbDb78xFeEKU9EuEvbzw0Ontc15JlJeds9vafZxXowyYSq5Rw6cJ/Ji0lq4xCfyYlbn9ECKRvoh", - "OHLarWPVJUQTrkOXggre1G8sgT5Rb0R/pwl5kkCO6FXYCtLrce0lSZCwlQfUhm82HaQJtyCJZWJbcXQu", - "W/xBUvPgObCmz6+amQi2z055MmVjzWcUCI3lN5SesaFIX7A/DPz24fpaptzyF+yPAIKeg7f7+/W1HDpp", - "SXfvexGULeISMKY3U1JZJUWCDsYctEHTW6KVMUvszqcmvmScvebG9hBivbMTsgFgtyQvxd1AWUlopDJ8", - "oGswxSw8++nYfXaiVU6boqAqAviE5yYo1EORDqlHCXYk8jYMEHNI6TdhqIqFnXLJnjE+BZ6GkO/M7dUA", - "SPy0G3ydt6AdoxCYt1z2iR8V4zHoPjvOBH7le5tazZObyGxOWUjBQmJxv332CqPfq+OboF8sXRma/Kpl", - "K73fg8oBA9MqDAAW+KZdv2Q5N4YN/x8NecYX/8qzbEh55Y3pVJZi0Ut8Wjhu6/HXWOC+8dOtcPc95Tmm", - "aWA7RJCgRcKGTT43pJ6tQWvytwf+IeMp8ydsfUKNJdme+3yBLZgctlGjQM5SlRQzkG7U0C5yGFITsZJZ", - "D6lnisM5pWdl0ZCqoY/XV/4Rt3WCHxPL6jKDCiHthyaPdhhEhGseb2NlvguHsqEbCSp3pklPvluY0syA", - "TNlhBB4BvKEt37Y02WVGNQlrzrOCchpm4MhMa0iwFgQtxd0aQto+u+I3gJ1cE0hxIfRjDwlvhiRWsZ0k", - "LYytynA5x5B4YVVPg0fjarkMuMRGWYhIZPbv0ZQOQlNhsLxlVVmVvEmVE7JBBLslGZ0j4u+C8H12gTWA", - "kaRZ4vgJt+zZ4bfPX+KAEpl5jRNgmHihxzwBKho6FtpYIvYJZphpz2X6rQVk6UbioRNZdr8asA8IPtlK", - "nr/eQhh9cRlPyydwEL1E/3nv0tGj5wBu9P8fAAD//4OkftquyQEA", + "owvwGMsKmeFr2bOcbFFii4NjF9ULMiMQY3JDa+vh1B76QSY0eK4bFoiE+G2dyweeSW8ipzlPuZzEcUDZ", + "LN8VbO+uXp/vDrqVUbuBzw0/QD3R31d48t1D/EaAL/Dp6BCkCh+tQMDc6k2MeNfgIn32I9r+GYzHTsTt", + "hU1avnDvAceQ5rBPMHefbYL51iLp2Lu9g8oCp+7NtCtt+KqDaNgZYfPwlAWHerUtDN/yfhTjvU8UEUKt", + "OFZBMQNjvOK+aqmJB5uUqw1o6hnPDXVGw5iDg7HIgKSQ95odOJKVRih5kGvlfj5IhckzvmBOMLws8wj8", + "hFhF3KkYPrzeYTy3wpcrqndAbu4EjTX1maJ2j3j32He5l67VXS73i+03Ij9UPgj3T7Urta3/wTdnxgtw", + "V+04sL8E9x/+/OFDUcwG44xPDMHHXdFmP3A4cwBhzDR17N6Nb1RhwJc53zEOdVRYGyuIglMy+pVMuyTU", + "UQLX7imDse10O9opMW6rIk2zYMkid7mj6Cic8MnbUu71ytvQ8Bv/5K+t6p7InW4HI3Pwk+gCU5WlgxtY", + "mNjxUop2dT+787lv6z0xadaa82A19HXJESCL2YBe8bQccqXOi2fLlP4WcxvRQChm4AkrB2/HDOuuWkbv", + "Vk/x7yxRyglUXtUCoBvLFQVrRmeKFFr+j/vMtISudx03dQuS5iPFdeoLJexakTJas/bYC9kkTE4Fa32W", + "z+bYXjdpdLPU/1QfVbage5jrEz+Lx10HZbiDpLDo/8i59i0TkNV79ZR6aZE2QY9Oz+KvZTVLTpnx5Dsk", + "GanJXkM9w3C0uwR8wbkP/Nicaz4DC9r0r+Wpf2cqWf5OIxuVnNGSHTTzXKu5SFsijZCUZ45nbFJlVhnW", + "h24n1Xyy3fATzSfLo2dqDtuNfqPmsDwa4wMcm9g0+Nx9+BMsamPJRrdp4CV+VR8GdpAU2qiNmv8l2GP8", + "sD46A9ioMV66jzwK12KSViPigrdiBcMacrgG38Z908yhX1F1leXVNGDbOHk4SIxzV5NuOKaTE1dwZ8vr", + "WabyeAOGbudYA7dwgj04lF7cT3jOVAprNI00zM7ch2xPJRgLgqfsMoyZ/Ofvv9/vsxMSFigL/vn771GJ", + "49a9gjovOv/f3w57//zrH991n3/4h3hSrJ1GkgtGRmWO21SbcB+iPQKPvrTIQf8fN7tA3UqxyzyBDCyc", + "czu93z1uOELYeIrLPP7GLyBB2Te53+5j7s6zleQdHRapnYQdZfmUy2IGWiRMaTZd5FOQy/Dnvd+Pen89", + "7P259+s//cN29VxOSP3c8p23VAQOLVLtAjeo9vRdVc6mpXIP9gIfaG5h85T+a6ax87hkP/7O9mZ84cSP", + "LLKMiTHaZVKwkGAwyH500VuRxhBqeTX8bO3+o1e7LIGeRuF2bLNF2S6VbNK6o7G84B4fdT30cFlVOXGf", + "rFQ1HIG9BZBhI07R9hH4XFuPvY7/M56pMvHZYqmKmZBi5jZ6GIPJ2ubcPuUNw+hY+HJlb8FZ6khLA92Q", + "28usDKE3M6Xs9F/JTo6WWjTpBlOd07jdGUbc+EL8uCDylwzkxJ+D39E5nh0eHh7WzvV99GAPeWW4I+z0", + "yIhzynca6yuxTBhUK/9212WLX+sqfc6FNiXsQm8Mam/gNjHBmK03TtXzuiPjlmXAjWXfUvt+NPOUO13e", + "cj0gsgyX+hYvr/qP5dOs/ZFg2cBhB9eIR5VNixmXvUzcAPsBfhdYm1bPocJmhPAtX9BBmJDGAscOLJmQ", + "wL1LNleZNy39gvFFbjU0EphBDnpgYIKYRuQA+QCJbDCjXgxiIlWzxlUt4rzxeeNI3+9Il2XRHdzXCgTP", + "aBer1LCRPlfO2XzFHrY/Y8stIW7RvrAAqr8vH6qKbKJ9g+wNbY89a+z12eYgnjbhXprhtjWILU28zuxy", + "Sm+584wvbpELbysM4q3paq/DakpMcovE16ct9hLqVXPwb3zO6Z+UJVfNTc9M/OOUG8YTDPWyin2DTUi6", + "7BufGf8NvS6/8e6Jb9ica+HErX86zvIMXrDrDr/lwlLDh4myau+bqbW5eXFwAPRNP1Gzb/ZfMg220JLV", + "Psec3r39l9edWOgdFWOjohxJAw//tIKHb4hb+zPiE0bM6mWsSvWaCcP+dNjg8N81+PtmXMPL3xIfDG54", + "R3QIvRSXsKA63aqpPWD5Uj4Ldg72KOz0pup+fNPmeA8mv+nVdyJF5RMkqzhA3NwepZ/vExtJQUf2cxmC", + "WKmlcRm/WD9YxJKbqlgR4nIyH7C05WwFIvy6mACo3zakzA/Blnlxb0Ajac0vEEOQVyKDMzlWq/xImEEq", + "9PpdofxCd335nGvpsalai3s6UT5DhcSH8oaaa2VKU8ot9Hzt39V8kyjfccei1+1IWJ+Z3mXXnVTf3ume", + "+7/rjnvYXHd6+rane+7/rjvxuNF4dOoP3EAj+XAsQvDB6k1s/SoOOusqkojfYTBaWIjgyaUPO8Wf+76O", + "aNiGALNFxGmIHuao19cW6wY8qMHQX3obOlFocUuy46vSR8PI99jW4nkb9OPoUsPePlvi4X1hWS51X6Du", + "hiVxs5jPBVzkULeBHV+cHl2ddrqdXy7O8H9PTl+f4j8uTt8evTndIq+PUvpaFRbsS7fib4/D90S4/wo5", + "q4X0tevLcj+lW9XH0YUeI55v/0Rx8xgKWaWd8DJxjWfM8jsl1WzxApNaqXiE711WzW6sBj7zaQJDbECG", + "DjalZ6hZKFnCGnUIt5URZOqW7ZGFm7ZEpm8fkTRsv4dhl2mYcJ2icx/DABTLi1EmMB9Z2D475lkGulf9", + "0V8ABia9u7xiB+XuD/xPIZu2TF0MDmhh6GZfMgPAhkt7Kd+j2KXYTHkOffYzz0RathJIcDMhJ6UesypM", + "ecEh4SfxhYqwoR0GYAaPKOpIaQVxEvgznucOzZyOkYuBW2tD/MBRLtz1EEp1QxT2AGOkB0H4r53Bh1Vf", + "uhGkrZSTpfnAhyltmiPNj+nD+lh3vG2Hn5TfljNQLNLAa0PrJ6BvUUNaHp+pyXajX6tJGFuLdyIH4IYZ", + "zqrv0RkSmwfdEdvO8hMsYnOQBb6sRrb1dOSuaFTY63YyMYfBXMDtlkB+Lebws4DbJUhX02wN7zDTKtB9", + "OFdtqo3HfENDTmojlmcTUtiB15G3muxMCvsKv1+eSoNfZaf5LsKoDZPuPN/qXPWQ6W2muiy/DzPVSxhu", + "1+T5LM1gebTjjkJOtrsmP89rGtO8pKV+s9u2ncaPV+fw3ZV3713d6TYbPu7WRjOMjnSPu2efvjDjUi+p", + "rRsmNXnBamug3TsvldMk+Q59OMpRiqe7FDwP42pFe3cuiLw6xw732FK5tLtStm7XioC1FLHtkC1Wmqy7", + "UqNi1/IfPn3bvSsWb1H3J/X2Q7ejJGyfzrAsXT90dxlWE+lbDoxxgF2H1ul+t7ERFrbbBBUv3XJcDK93", + "GBpnLjtMUFHkDoOWMH6HkQ0s32Wby9xql7GBV+2+Xp013Aug95khro7uPrjUQncfGtE4t5ykRS/ZbfSq", + "Nrjb+BUF657D78EHWlTQLUc33oPbstql19v2w5YV+C1HRl8SO46959Jtr90th0fF5H0rXlJ3i9fCWDTt", + "RcxgWvMFU+OIUU1IsvFiwikVzOhvWxijNFxHvNGlmI7UNs3UZLlWAc/zzBuf18apL3elmpR+DAt3trWL", + "UEu3kysx8734yh1Rr0LKx9/WAt7iHKwvHbPpYVjHuY+hvShfFMtOgG2De0Po3P2Dettm2DqYdyWGcrf4", + "l0eMA8GgwgdGgKTCWC4TaLgFv3/quA+3553iPh4eDOFt91Xkg/snl3bpFuPm/E3oWQWWBAxjVt0LTbed", + "aSd0vX9kYgrGDjZFWNZSiIJfaVOAYrdjdLJpYir4t/Wcy97IsEC3dorYDb27qfOlHdzVf6HC+ezdT8Fg", + "Dat8Xd1sxNozaqQBJvhb+5t9reomepZzbpOpD368H8Tboh9P2qMeS0bx7fPD3WMgT1pjH/vsbBySDLus", + "MD67cComUzC2qi5MQwJX1IDo44Ws91796bD73WH32++7zw5/jW8Rr9ab8TbBa+xjozSMHe+g1DDxOxAL", + "LquXOCWkDHs90IDHFIZRKl6c0/gcsyrTajW0tlqdSuCG/DtfJLc6f/B8WsVAmoLqHvOU5xRpLeE2VCis", + "AkQQJ/Aup8DTcZF1KU86/CVrQc/WoNOT1mDTEm2++/Zwu9DT5QyE+0neDWGhQeoGsUWVUxaGYkGXGy3W", + "UNSB+7BL33INzGKZts2RZ2sEaRlKP9skUW9gQZUemXGX4yX69gI2vv5rH1DpZjeL2UhRMRlcqM9OeTJl", + "bonQNmQEjNe+ZabIq6qEd6mySmXXcs8AsH9/9gzPspixFMZYwl9Js99nPrzKlNUyrzsXGHRz3emy6w7a", + "JOifx1Zn9K+jzP/p1ffXnf41BVVS3J0wFBWa4AZ5ZpTbZaJmIy+yjM9EoPn+yYZ4DfwvXO2frvgIp93h", + "Qpe4Nd5ulF9TLbDTO0geLYKOu+PNMEpzIR0fkViufFU0cT1pBmP+LVIZiWbielKU/VS3xypuBlqpZihl", + "/BhFs/431jlwQ1muxVxkMIEWtsPNoPAlBNZPGdoOuq/dVLLIUHoEHr+an0lnj8RH4EWHIiBmCllWXrmT", + "BUW8e1tyG0sIVxqLlFeP1T1ej+fY9zN6DzktQu14lw+wWecCOW9Hrz9iUfQeZn98WAbYqZwLrSQ+PMro", + "SKw+7dsmxSvdVZi/EuG4W1BjOwDbYxcJnBvJ8EGBi7xOdCXAynOsEuHa9+Bpef62x2C8iiDcCTuIR8qe", + "hzqKoY1ES1F8jGMcjP70PB7GVCv9RJ+yUTEet/TnozjGbSdThW2f7EM79H4SVZLhbuC7pCYaiL2yLL5Q", + "w94myKg+TYOpda5OL9501s9bD6byn/909vp1p9s5e3vV6XZ+fH++OYbKr70GiS9QFb2vNKFKt+z86j96", + "I57cNEsWL0diZybe97LsopOorJhRE8l1Ucbdjla3m+Zyn+wYGo+zdmmja27sMue3sn5hWxUgi4ju1U7E", + "vnIsDKxdbJaCR/5rxlluoEhVrzz93vnVf+wvM1bS7FEQlYEvcyCJ1CIu40ALTaKWAecrxNQOgcFaywkV", + "O4B0ZSX32f2X+RDtgdyE6z34+VnNYMxHjiFxZtxs6+ghWvf13WUJrLb+I6Gybmz4JRZo7JWdYiN9ymr7", + "Ke24RSHSOCPGts4DbuN2Yur9sNKNxQ/bwVTcSmqW28LsWguvVoKtMCRl27lSXgzyJNYU1Vgxw2jR4/P3", + "rEB7eg46AWn5JNZ8e60YrbowiWbl4Ck3vo/ZNjoKlc9vibeudhyKkYda6LT7MhS7RYJHzS3nFUxtI763", + "6vBD24/LonbApkLeT+iccMsdJ7vVggygS6hHqQ5C5kUkfDvllm+lWKT1VTY34Cnn/XXjmR+kL7rt+LRS", + "46ZbPaH7woJsQ5IqDw0/YP7zfmdbk4o/igZexdLvojtdnpY15zXkGozjULWGYz5HRemV4qYPhWbpWKuQ", + "xZ0iqoJC3E/3urmllaB3RwrRBOOtWEPJSGlyYdg1DrzutJGs239ECpAh3Aebq1oboGRayJtm3SZMGSoT", + "kbYkYooWR/g/zA4xUumC2ubSlKH6Jl2A9NS9HEC/vtN/LDuhLH3KShsZ2inSuTBKL174WpY3Ut2G1X19", + "mdDfrmzAvlSZlBd2qrSwmNOZUUFqSm41tfKifXZGtfawlaTxhbwKSQsmhbEONxc5mK5DA7K9Yt0v4jHN", + "NjihxHVV6bgbSqLX6zJXtaYb1bvL4rmNGsBlfHsV77q27VVbiVC6PE/i/Qf3uNqQcbK+1fu21U2oogXo", + "eMbZWEhMjdhGDarKVoRRbUrQRnsS6XerfzZl/Y3a743k6a2Vtmq3ftA9N7t0z6hM1vcZu/MqBukCJttU", + "jtrO7/Sjrw8bqohMvBFkTc2NFk/EL+iB2GWiLaMSaK5v3HMs72UwdtxfS3hQnMIOc0ZdweEWuuFiN4Hs", + "Ph4VXQJ6Q/mnJmJERVCzSNSuXurM8sHdesfOj0qL35XEEkS4FuMzVUjbZxSe4h7O+HfDMPG4yyRMeOPv", + "Dg5xyU072FBx5Ge342SL9VN1KyPLF3l88YdEYpRlqrY36m+iCm59Yc6qllZzqd2JYucptw6PWCkwtiPX", + "EmkKckNKNYVxVD4yP2ijj99/17LtVyKDc9AzYbDm5v32j10D44Y3aihI2aqa/aVhvdg1LTpS+etPz5/v", + "71boS93KmJ/H7RV/Qs9O2O/7lv1uk0JL2Zx5dbfkziXPoS9kfM8iXGtSmusV63bsTMMLA/UCB9QtIIfE", + "0X5a+g52dD7UPeFYqi7me6iXkmgEjR1uJMr64tELcSrMK/MLt8mj1lUri96hOQDrT8aLQTjCFXPYbLct", + "qd3Px8qx2WKLWJ7WyCS8gQdWZxtrPoN45M1FpduGjxyIx7mj2DloLVIw4a3kb2C/DvNvDzcZgaMm0fBg", + "ixgzawosIO09Uo043HRA6DN5SQjc7nis9lF3vIUAzPW3s/ZCZvwOaxeI3+FMvvmhfQcYxRwafb35YUuI", + "LJfsetYSkOVOd1SkQm1G7mPfvoG7z6nsGbaFnosUVJ9dECKb+rva6Rl8Du7hT6N8JJ97Sp8XmYEj/9fk", + "Bmy9yDk2wsOkfGbAGjZSdlqrcb7vK1NRkFITX4ShHfXci7y/ZenyS6vyh9KX0gm4eTbf5NlsBqngFrIF", + "dnTHKAdVWDbRPIFxkTEzLaxT/nxJghmGxaGpUEiM69C6wAYReFTEkbibZ5eajAQwt6EnLMhY1Q6Qc8hU", + "vmus5RXWvaOhrHSHWOyaWytSw5bqHkRK8wdD4Nqyqs3qE1iy9rdWW3pvpqSySoqkDL5i5ESodsoTrQwR", + "SSbGUO9X6ptwsffGd/19zY3t4cq9sxMfXVj4IP7Ly9NgB/TmT2GoPh1ZlFb6c+/gLnVnDJbSX9fCsC3p", + "YansBhXcuhUaehnMIfO2JCwVgeW38lpJDg85BjLF8yC3CGU7fOGN6vR9dqRHwmquQ/UMr15S5yZfiqMq", + "POEYWEqT9dmrlRZ96+qDdGOFPXDHoHtosyK0YalKMEgKym7RQ28E+0dfMeNg6S8nOG8tAK7LVsuCbGpt", + "v9Y8+lkbGSsQ/tvlu7eljTEGn0wYf6/ry6NQtShyRyzDq1kpPAYJAqS78Kdr5X8JNmCZF5elm6C1s791", + "vN53wy27+2/f3B87+Td6+zfa+jfqL9f7tyCXwt35ENd+jMNE+u1+FCNvCfvL4Om8h0+5rWHSarBknmei", + "xQr7C8+yXpKp5IaurDJX1C6z2WrLwddPSXk6NhSFbHSEqXdh2t4B3/WNQ3buq1R2U7qnuPMSLePGrkji", + "qg++BgM2SMTmtdDz2vTXSrLDLWL98CB0jijuLNVN39ne+LDqwjewMFarGzDRiqDR6Jd41dJ75UWFgM1q", + "HyEvrJYf5TjRHTY1z/iify0bTEIXwPZCN+tZyIg7SENt6P0+u6SefWVCwbX0EeCOBbi1UNfhkqnwHqyt", + "17gptod/+9dDdy8+bWu/fy1rVWqx9YW7tUVOUuJW6RTbtqfkI/UhxeXJhbSa99xXtKC5lk5vkJyKf6FA", + "pJ9zXhgHpytsX+f2Rhza7WUN6KLtk7otvTwcKuK9YjMCEgZThWHr1EajpXibGjiCSWA9LmLn4il3At7p", + "+otcMSH/7lv7uVf/SzYTxvIbIEUJ5STqIHhnI57cmJwnUCEBO+yzdzJbeBZmYjfA9ozIQNps0bina1l9", + "hrixT1dVPmEP+8+iWB/CcrbtY/KLFhbKziv3I/T10GoErIRig2HB+zZg+YC9eMltiVViOy86Xhs9w8a9", + "7Oj8rNPtzEEb2s5h/1n/EA2kOUiei86Lznf9w/53vtQeHuQg5BMdUBcmMo4lEevYG9ATwNwg/JJQAO6E", + "waAOJcF0WZE74cOWJo1kJM2Fe57loNErn3aJyLAMbiGtyKj3c/j6BOZXSmWGXXdQ3ZNCTq47mLecCYlt", + "s9QIdaaUjWCsdKjHivYinzqHyFR2kzxL0T5qk2lY5ZXvQuUrJP2g0gUFs1adeao07YO/G7LGksSMuJLD", + "bS5pF+FIdIdWsRleq68P+rfrTq93I5S5obSVXs93Eu1N8uK68+v+/TNNaENxtKq+c/RJyWaYtYjrfHt4", + "GDHk4/4J3im+rMqjeWAvV4n90O08p5limke54sEPPNAk1an+0O18v804LJsheeZHYV3b2Yy7p1DnPeFl", + "ucWMFzKZeiC4zfs947AKe8seZpuoojCge6EPULUMYPF0LQww6gfHKltdGfIy4uXPfYdV3Wu5kVzY7tRy", + "LXcll2PQWO8+3ELoeuweKTf+GSzHmofSmB6L2Wlo93bp2yB2ryW2cO9hQXRIyxnpHOX8AQ3R6Ht8cn4Q", + "stOxX6oGNnKaNKTXEi0c4S43UvZ51YruvsQdFw0xjWob4PfZTyEX0P8k+QzMtdzzGWdemh4rdSPA+Hu8", + "7lDXWCw47V1P03IG+mv/Wl4CsFBunHrxVTvpT5SaZFAi9gG5hMp82fB3H4REGXfu/D9wI5Kjwk7fzUH/", + "aG1+GhpZ0h1EN4ymJfexeZ9PNE/BlKO8UH3D745LS4I5B33u8KTz4rtvu51zlRe5OcoydQvpK6Xf68yg", + "83O1lHrn1w+PxdcCrnyxrG0Z7dxZ2jlckWeKp72qQ2OPy7QXvnVsT5mIovMeh1ERW81mjoOUU7DfRc64", + "TqZi7igc7iy2R7RTmLFCpqDZwVTN4IBYSNUh0xxcF4eH3yWOFPBf0L2W7j2oHY+b1Vcgvi3kPRSNknNe", + "y4+oaNB9lYzRHMn0wt/xOp40KzIrcuwsqvSsF2xlbTpHrc9ma8Ju9Y1TPgj8FCCZWDHntlF9ozl9vHT1", + "K5U5mKJ73SqWZzwBX3I+gGs3qC+5FI56f+W93w97f+4Per/+8az77fffx6MAfhf5ANuHrmzxrxVChiYu", + "Pvq0kDnlMlXkU+56D/v7hWTjGZdiDMaiiN6vWyFGQjpK3KTVl9vzNcBjL5O1ClwNuvfT4p7FIpJLbCBU", + "gLQb4XZENSVxYLQqTz8131thQSU0a0i+x41jSGa/zgTLI3pu6N/SB6Og48W53mnIo5ZMLTUWWupqacgt", + "51teHp2fYcHrPjvyv6Lkp3Alp86QtcwK3zFdZIDhWCFE+i7JCuOQ16k/XWYUk4opDCzA5IeqR75hCZdk", + "o8Cu29iVJER/GKtyE4wIY6GN9T0nQsPMcPFMlHVHyFoZGmFSM+BrGcqiFwadk9ipeOqpKgXK4HLvwsoO", + "iMk5VFDHrXYDC+pM6q/rWgaPZ84XbhbviGBaFTLtWS1y5lRHmVAMOWCBAZmKuUgLnvlpYpz3B1QEm51L", + "768GrrWZrq5UNV+8nzKCU7Y03fiUtFcSAnVpjRJAHaeXyGypKWogtibgqnaoTwSvSL/Ve4KJOtSFbrKB", + "rD8phC7FrMgoYZSort4vOm5IXIERmasOHKtvB9MF8PS4ZtqK3dZjgavZKhmhtfT2Kjse+yVRTq3QzYNv", + "1x2aLMtlptGKla/tOtE22H6fTePkE6F+3AJ6X/RHq6fPLsM2qiUUPhuG9QsZZIMxfQt4lU2I42Aqo4Of", + "CEKr7Y23Bs6jrF8rfRajMwpcnovQiKN8LX82EP9RpL4Ii7qt13dsgrnZXjuu9WFtKdRaMEQ+MFTqA9ot", + "nVROc+OhqqJbVlvyCmHogVzuDToR89B+kRTTDLgB1K3qXa02NK6MaTxlG9YnQs3VRuP35Btuos9EXOJW", + "qsqZBCaOcFjCmAlYQphB2f+/lUn8BWyjyulTisd4OdU47WLUAZ20PMRj3OJfwDYCG7zmQcwirLSN8tHs", + "Wx+/3LLa6hOh+WpH/Adph/4W3Mk+Laq/CUVEG9AJUrFMDag4jdkGYlWD+/V8NIQDl+ugGx95Zs3fX+Yl", + "kJ28SpCplZu7lrEichQihoXOcg1TkPRuXq1W12UG4Fq6zcQrzjFuKzP6RNj+WAOkYG6syvtKTw7u3P/L", + "tbLq4O7ZM/pHnnEhD2iyFMb9KfFzH841VVJpUw/88NGP4bzuRe2j7hN/FZhfYbwJjaCg0qjHw5dAfCJy", + "WK6weF9qQIAitnxO2gLJ+LotCfFyC8SvNwpqY1VX/AYu66GRT6IxrqRsfvAwWitxMJD1IKcU42qlzdbN", + "FcFSbYCiYz8pQMvcBFYBKAShbQCnyrJ2JkbJqGzuEzapCsCBcrQdkkjd32xNx6tx0qa22LDzNep4ejWw", + "kQ3qm2lLlqkJ5opakdwYtieV9ZnKZOKsYRAbwZTPhUNpvmBzrhcvmS3QSjfDSKp60QGMmcK0iuoo5G4M", + "yamYyuptl97V3W0UTfAhP+jpaZg098o5UBWuFtinuA+0IlGwUIgFD6xwGGLDyIDR62nIgVv2lvV6FHR1", + "yMiDQAo5+RCGMQ55GXJCn4j8alnK9+WOHr0+ExsSbabSFQg83DrNeAdtLgT9tjBHH3D5RHBZjud8kJGD", + "ggg/G6nlzkZGjXVQ8DHC7TytqiUc3I3M/T8KQ14shycj1ypdRMZyp6BZleeYjJEA26OAhO619D7ZyhvT", + "dYwD89e8O65b0/l8OWgjfhdysu9fzeVCoiw2xuCOJzZbXEtcruGZ0sBTIZ0sd69n9x7HKOqwxpBKaBc6", + "G+J6nu1wNgJjezAeK22vZdXHrCycHWYNXgo3Mypq7mHDJ8AoPeEHxxsdEELrVD3jGYaaWnUth0GdHPoG", + "DFwu8KbZQhUsVRgCLcHt+MiyDLhTWmUwLFN8hvsa/ZIjYL6kUv9aXoTAmSasjHWqoy5kWfEY3VYvavE3", + "ddh4CHTJvd5F5VguQ6wfBQkWuyFwkOgDmVJgbJm0QzHr19JqLk1Qb18wMWYcXTu6Cv9x+0Znk9sg15kT", + "ixXRMUwyBGyHHDLhZlxIhw+4NgUCJ+Bx1f1JKtn79u7O+7tyrXI+cQK5fy3PNYxRtXbX48SYgZxjxuuw", + "ii74xyElDx34OxqiP89HtxLZZBC8iz2rxWQCTk+6lgQDoiQhEZ4+gbUK348Jq3DLxyX9PmKgAIUFDerh", + "bUvxHVevev/ic2+asUtsxnP2P//13wxjvA3MuLQiwSLK50dXxz+y1ei5eM1j/9WgJVCytgPycbPhH9cU", + "xHjdeVGPk/z1w3DLDeHo6G48WLfZxswxDdRM4u+k1T4LQ7aHJVcOqODKAdikHxJWqd54CKheRSAKKTfd", + "4J/FtN8yQWSZG4uKFTfClhqU2iTSaEm0NXEkp/UwH4NWyLD7xEmspMDKJNUUfYwMoWNUmQFr4472+5uD", + "UB4cIvL08RsYM+6GDDzvXL1Ny3X/d2Nj0SmY9gUGr3fYiJ3BYFOfxuiZs2cFps88OwvxV75kBRZM9w2u", + "qsBBP9j9P3NQa9ePGryBzI3fQ3c7hdqxoQ/zO6BV0LE/3KcE1aG7t3xQkcSQpAKySAK3j2cIh7VTXsbX", + "GCfv8INbzfMcqiZdYinppw1cvhyWE+4RMr54XXp/vHgHL9wrLrxWfJe2oC7LQE7IPp9wojXLvj18/i9U", + "Z7FbkZ4DYILBvhRGgTzCA4B2McqgpS528y7XKG1VglW4QfQeVGMph1uLnJyVSzhZYsWek5FlZSGfSYS1", + "8eGOKHJjMvdn5aJqaEKeX76s1M0SC9zMGSz7rvoPUeyfH/558zi3wUwkK8+Bx3GWL2sP4fnQek+ACpf7", + "X+TlZUx3yvIpxyuuvzyOUJ+hZ3taKjT4lPfZuU1NNM8Ks3L3oeLXQU36llH2kXBuL1WfysAZaZD0kTHa", + "rx6SLVeB9d57WcNbqXHJnwxjHxy73HIchxpjc5Bo4BYGZR8MRJMiFjGEH5ZFfJ4qbKi5yk6o8mxdzSE6", + "52dkXqCTMo45X9X1B7ik4NjmFnA5wQ+fGi60Sr2h3b390iVI6Ijpwyjr+eZxb5V9pQqZPqJDG3fOeDvc", + "gh68BmSvSN39vKGFFeX+FwAK4VHCSN1KpzE76hr8LrCE0ARsrFKXLbQ0jLO/np2z8i1Qe0OEp0FZVKaq", + "/hZQo78aQ+LXPxH6ryLHiHzNZ2BBG2x/0dbwsaQc1EGtKnV9pxqEQ+Hrzo37rQBkB/SmC3XwmjjQrRsx", + "NtXV+3Un4ezv9UFOL3fr4Yxl7SRErPoFf4l46YFVZyHuNUCIFh60cXw1Nt0CYcPbd89yXXsAz4JzGPVQ", + "N9f+Wry+lmsQm/3V2JSp8Ri0YUZMpBiLhGPq+Zgbev7Rgl5/vZYp1P/k/s01vQB/F7k3uPBkKmCO7XLB", + "Ls+CZBSPzKpRlbujL4Wsun+sNn8rj4sRDH32o5hMQdN/lT2kmZnxLKubI0aFZZbfAMuUnIDuX8seQcLY", + "F+w/HbRpCvasy3zivwMspGzvP787POx9f3jI3vxwYPbdQF/YoDnwuy4b8YzLxKlSbuQBQoDt/eez72tj", + "CXDNof/cDfAMQ74/7P1LY9DKNp918a/liG8Pe8/LES0QqWHLAKfp1MFRtY4K/6oqNfmr6nRrv9GW8R8m", + "1pJgV67oqfdBbPFqya71fwhrXDLnlewRDS6hdoNni03WUDaT35YnICfw17rS1/5zkbC76YRVQ/1VhEIt", + "r9at/wtEm7+ArZ+gbB+1Ar0SbTJhLOrpphVvXguD9Z7NPYXJl4kp1akjqFI93zKqTfIF4gpm6yLkKZFw", + "FTewUX7b8y20dn/C0NjHeLphKGpl7vgC4YQnwGbe6OVaR8waeFo+uqO0fAE89U/u7UgZFwsqoZv/c6Fm", + "lViwvapp0YN0CWT90TyuLwxZMGus4a4rkcMAMfpBrbZ8K3Wvlvh/uiSkll4C966uUSud71OGvkBAXoJd", + "JfR6W4ADbDtgpiIvIUwe0PYgLKxzYmqOUp87rnQVX0ICwYfqa5gpzwMol63fUnUiqAePFj1SaiQtLvoU", + "jB1saKfgvvF91ksO5qumeYV2m0YK3c59vfnek19tdedyDHQLj1aJAaFUFmH40lldpDjD2OtrdXIIps21", + "RWY4Gl4oBg07ZlM9GWFNZdtcSV9Zxq824iDr5qORxq6on9Y7TtQq5VQxEmo7OnikyJZ19HBPxP6ryCu0", + "rgHwfw2S83rBoyUUXcF3b1zZgPC7mkbb6OJabiaMzSbShkX0Wi6ZRNvLHXkb56MRV2sU1dUUlk0vpQjZ", + "Im7okxFtPMqnrVjr2+0DfXwbL783LGaE5X0dOvV6+E2vGrff362GcoDDk7CLI3+H/8tZxjK6trCN2+WC", + "REsvgVojpKd6A0R6LW0P23sWT8VjR9uev5fitwJiDYIqqrz117FVvNpyvXabTNlj1/j7RMhGh6kbqX2h", + "JjmpaWJ4Wwd/hCv/4MuYAxUpWcY3lVfotmSkQMODtzR4u0MJx3W2h82mhuexwvoEKAp2/sIBdYktf0Jc", + "eczatwykA8qRazUlUdfuV+aUPvuIsFo2C1m4s7TbqD1okz/gEp+2vtlOJOe0anqjxrW3sM8hxCanPMVT", + "/9H5997l5WnPlw/qXUVbUbyBVHBfbX2MXWWw9YZPSdxbZmL7Dc9d8NKtsLqIU+7Dl4im1F1o+ZZ9yRNi", + "uyXGusf8+iAjLMqzjcHzpKZ88RXj50f0e7+rGhKENpatHSwbvVP+9Px52zax7WPLttb2vSTi20biP9Ac", + "e09rRlkS6ksXo2iWcpIzxENWoVqZmpiD6mLjLjo1MUQ6LXx4CSF8d6F1mBsYjUfxqr5ttKt/fJmxyjJ1", + "G488aLT+rvXJWwYzJniUaXtiHNr5CcP81tYQZrtU2WWd2tnjq1UfDHJqU9P5ZBLttZpsKcocYn3W0ism", + "GdymKYfy8vKUCCTP+OJWU9obFY3corxq2fzrvBzNEsds0Rc61mCmtaa2CJo7y/iEC2noJR6yEHQhsYSz", + "VJJlKuHZVBn74s/ffvstZafirFNusOecQVb9Tc4n8E2XfePn/YYSer7xU35TdooJVRp8H0Yfi4EzVpvD", + "Urm20LJq/RbQK2Y48VdQnfuYpMNTvOxW1vpEWQ+RfbgLjSerlJf7OZZDrY6AZQcuceeEERHk9ARCPAmp", + "o/2h7xtsuYWerL5PucInwoPGDtowoKpmrP03n0UZ3ETNZo5LmIVMplpJVZhQ9TYA2OT8Vm6E8CV+9aQg", + "xiU+LYz9FtqAjD9/4uInq7Dla4D7h/8Hvs1vRLOCUBTQPwksRbP5XV7NvFYlLDX5ohDpQx4L9wKoO81n", + "Wan03U9fZHyBYyVi4l6aVrGgtrZjHBUG2IhzF/TZ/xqso/N8xbvHC1DC+hKcnV/9R29ErRQ2I5+x3Bbt", + "psjA8umrj417TyzH6FAxEeZ/+SKjlD0AmAnHawd9KrbQafCr/zVcB4/zifUn2kKb/vTDAlt3kPnti7W4", + "VZKPEZ6txUNV2E2GuOryVGHXWuQ+ET96gGWpPJsbtqWNKdyuKmxeUFf9TIwhWSQZfHWgPJ0DpYbVqrBL", + "BjMNCZYLnRxUTtg4d6XM4Yvw/ZMmaperbK4tu5zu6Qd+uhTtT1TbokzszjXMBb4ZGQEXUjYXKaiaH6EG", + "dZ9c1srFQvZZHfBrvWel08qvrutN9qkKmW/i36jmWoRa3d4rUA5vc2Qh04u7sXjv96PeXw97f+79+k//", + "cC/WiBd2MMufPzidoMJIH/PYYHDlr71XQmKT+t5RrNGzmIGxfJY7JkfN+dGyW01Ng/vsLwXXXFqgeLkR", + "sItXx999992f++s9II2tXFI8yr124mNZ7rsRt5VvD79dR9hYXE5kGRNYLHKiwZguy7GfBbN6QbZPqvHY", + "vO4LsHrROxq7H1ZL4RaTCeWKYlsN7AApJKsa5ofui3pBRFAdooxlexaJZfvwBSecUileg7RIDdS34CiZ", + "IOnRmj944QnbPLQ/RZkPsE6ghNUo03MlyH6FXkPjSl3u8tES7HiW1adtXttKB9RI6N1TC9/mImtl77N1", + "JOqZwBdYIQpvoKziXvG1PntHJWfrvC4Hzc5OsAUi1jafCGOxSyOWrHYcpL8KZZWvA7LKnx7GtTXur175", + "ULhPWzDcqrwpfui6TcIzsOp30OrA97Nf2yaE3gpuop/fUNFCNwMW/lDMzdJ1wOU6zfD5MmY/Xl2dM6v5", + "eCwSpiQTts+OeZaFWiFH52dUIlsYN+Wtk1a3/AaYsGwECS8MsPdS3Gg+tvRr6Dye+MZON+CblCxCEYOQ", + "c/Lzm2ipDzrmpTv5lforaNXZJqwRv+9Z1XOnZP6u0kcBzlkKs1xZEht+ZrxXCLdau6L+KuBArofbBRir", + "NBhfNpOmLo9SdiKo1ug6/qtuUYXA22xuhrQG1GhEmgEBlMaWas7Pb5hUvpQIVs42XreZQpYy7sAW9bLL", + "h8MG5BOBhibeBBkLGcyc7rOx0E69IVM5qllqr8/Cx88PnzMxrn1HVburIqnR1jN/AXtV7ucJrV/lIpeW", + "26jZ/Sp+wPvqbqvdrdrnLytXLrEzrn0TDMp3JYC0AgKlWsItTKgSL9y5yxIOMQzWj6jXUWEjlS6wmiwF", + "dacvw0uuPoUGy2mc0CUmGOrQb3YCPfN9/RnMob51h69+QcqJIdp4wbDLP0sy4NqEok2108a6GLlbbCLT", + "E3TqpQCMcpl6wc2PZ8u9NzZ/wZnTvuDnOjIqYl13wG6gm4DF3x4+a2LxLSc0rllhKox+6YOz3LhDN05Y", + "N8AhegZJCOBSue0J+YLxSvRPufVY7mavU9seXyqBS8l6UlkM7ndE7BQHXUCXKR0oKRBPkPj7rUTzkgSB", + "+79SaniBuBvTPi/sp6Ozz56uds1fepoNGfi0AU6X60ReQw2pJaTE1cMz+Xfs18El+QKYCLmp1QLkmuiy", + "CfdN/TCpMsGC5MvbqJP8IdEYfm2MmEhIGcg5ZCqHSln0yxrG02Du/PbweeT3scjo2bgnVVg+lLj2yWb4", + "7TemIlxhKtpFwn5+eOi0tjnPRMrL7vktzT7Oi1EmTCX3yIHzRF5MWguX+ERezOqcHkjRSD8ER067day6", + "hGjCdehSUMGb+o0l0CfqjejvNCFPEsgRvQpbQXo9rr0kCRK28oDa8M2mgzThFiSxTGwrjs5liz9Iah48", + "B9b0+VUzE8H22SlPpmys+YwCobH8htIzNhTpC/aHgd8+XF/LlFv+gv0RQNBz8HZ/v76WQyct6e59L4Ky", + "RVwCxvRmSiqrpEjQwZiDNmh6S7QyZond+dTEl4yz19zYHkKsd3ZCNgDsluSluBsoKwmNVIYPdA2mmIVn", + "Px27z060ymlTFFRFAJ/w3ASFeijSIfUowY5E3oYBYg4p/SYMVbGwUy7ZM8anwNMQ8p25vRoAiZ92g6/z", + "FrRjFALzlss+8aNiPAbdZ8eZwK98b1OreXITmc0pCylYSCzut89eYfR7dXwT9IulK0OTX7Vspfd7UDlg", + "YFqFAcAC37TrlyznxrDh/6Mhz/jiX3mWDSmvvDGdylIseolPC8dtPf4aC9w3froV7r6nPMc0DWyHCBK0", + "SNiwyeeG1LM1aE3+9sA/ZDxl/oStT6ixJNtzny+wBZPDNmoUyFmqkmIG0o0a2kUOQ2oiVjLrIfVMcTin", + "9KwsGlI19PH6yj/itk7wY2JZXWZQIaT90OTRDoOIcM3jbazMd+FQNnQjQeXONOnJdwtTmhmQKTuMwCOA", + "N7Tl25Ymu8yoJmHNeVZQTsMMHJlpDQnWgqCluFtDSNtnV/wGsJNrAikuhH7sIeHNkMQqtpOkhbFVGS7n", + "GBIvrOpp8GhcLZcBl9goCxGJzP49mtJBaCoMlresKquSN6lyQjaIYLcko3NE/F0Qvs8usAYwkjRLHD/h", + "lj07/Pb5SxxQIjOvcQIMEy/0mCdARUPHQhtLxD7BDDPtuUy/tYAs3Ug8dCLL7lcD9gHBJ1vJ89dbCKMv", + "LuNp+QQOopfoP+9dOnr0HMCN/v8DAAD//0nYDMOkyQEA", } // GetSwagger returns the content of the embedded swagger specification file diff --git a/server/openapi.yaml b/server/openapi.yaml index b6237457..2c94c895 100644 --- a/server/openapi.yaml +++ b/server/openapi.yaml @@ -1600,8 +1600,8 @@ components: description: > Forwarding of captured telemetry to an external destination. Independent of what is captured: export is off unless explicitly enabled here, even - when a destination endpoint is provisioned on the VM. In PATCH requests - an omitted field leaves the current setting unchanged. + when an export destination is configured. In PATCH requests an omitted + field leaves the current setting unchanged. properties: otlp: $ref: "#/components/schemas/BrowserTelemetryOTLPExportConfig" @@ -1614,8 +1614,8 @@ components: type: boolean description: > Whether captured telemetry is forwarded to the configured OTLP - endpoint. Off by default. Has no effect (export stays inactive) when - no endpoint is provisioned on the VM. + destination. Off by default. Has no effect (export stays inactive) + when no export destination is configured. additionalProperties: false BrowserTelemetryCategoriesConfig: type: object From f779d5f5631b40c28e5e331e08b9cde9a6d27ed2 Mon Sep 17 00:00:00 2001 From: archandatta <35818003+archandatta@users.noreply.github.com> Date: Thu, 16 Jul 2026 13:43:30 +0000 Subject: [PATCH 8/9] Review: cover drop metric with a real-SDK unit test; drop docker live test Forces a real batch-queue overflow against a local hung listener so CI exercises the SDK->global-logger->counter chain every run; an SDK message rename now fails here instead of silently zeroing the metric. Removes the build-tagged docker live test (its coverage is now unit-side). Co-Authored-By: Claude Opus 4.8 --- server/lib/events/otlp_livetest_test.go | 152 ------------------------ server/lib/events/otlpmetrics_test.go | 59 +++++++++ 2 files changed, 59 insertions(+), 152 deletions(-) delete mode 100644 server/lib/events/otlp_livetest_test.go diff --git a/server/lib/events/otlp_livetest_test.go b/server/lib/events/otlp_livetest_test.go deleted file mode 100644 index 80cac367..00000000 --- a/server/lib/events/otlp_livetest_test.go +++ /dev/null @@ -1,152 +0,0 @@ -//go:build livetest - -// Live end-to-end test of the OTLP export path against a real dockerized -// OpenTelemetry collector. Run with: go test -tags livetest -run TestLiveOTLPExport ./lib/events/ -package events - -import ( - "context" - "encoding/json" - "io" - "log/slog" - "net" - "os" - "os/exec" - "strings" - "testing" - "time" - - "github.com/go-logr/logr" - "go.opentelemetry.io/otel" - - oapi "github.com/kernel/kernel-images/server/lib/oapi" - "github.com/stretchr/testify/assert" - "github.com/stretchr/testify/require" -) - -func TestLiveOTLPExport(t *testing.T) { - const container = "kernel-otlp-livetest" - _ = exec.Command("docker", "rm", "-f", container).Run() - - run := exec.Command("docker", "run", "-d", "--name", container, "-p", "4318:4318", - "otel/opentelemetry-collector-contrib", - "--set=receivers.otlp.protocols.http.endpoint=0.0.0.0:4318", - "--set=exporters.debug.verbosity=detailed", - "--set=service.pipelines.logs.receivers=[otlp]", - "--set=service.pipelines.logs.exporters=[debug]", - ) - out, err := run.CombinedOutput() - require.NoError(t, err, "docker run: %s", out) - t.Cleanup(func() { _ = exec.Command("docker", "rm", "-f", container).Run() }) - time.Sleep(4 * time.Second) // let the collector bind 4318 - - es, err := NewEventStream(EventStreamConfig{RingCapacity: 1024}) - require.NoError(t, err) - m := &OTLPMetrics{} - ctrl := NewOTLPExportController(es, OTLPConfig{ - Endpoint: "127.0.0.1:4318", - Insecure: true, - ServiceName: "kernel-browser", - InstanceName: "live-inst", - Metro: "live-metro", - MaxQueueSize: 256, - ExportInterval: 500 * time.Millisecond, - ExportTimeout: 5 * time.Second, - Metrics: m, - }, slog.New(slog.NewTextHandler(os.Stdout, nil))) - - require.NoError(t, ctrl.Start(context.Background())) - require.True(t, ctrl.Running()) - - publish := func(typ string, cat oapi.TelemetryEventCategory, data any) { - b, _ := json.Marshal(data) - es.Publish(Envelope{Event: Event{Ts: time.Now().UnixMicro(), Type: typ, Category: cat, Source: oapi.BrowserEventSource{Kind: oapi.Cdp}, Data: b}}) - } - publish("page_crashed", Page, oapi.BrowserPageCrashedEventData{TargetId: "t1", TargetType: "page", Url: "https://crash.example.com"}) - publish("system_oom_kill", System, map[string]any{"process_name": "chromium", "pid": 42}) - publish("network_response", Network, map[string]any{"url": "https://ok.example.com", "status": 200, "method": "GET"}) - publish("monitor_screenshot", Screenshot, map[string]any{"data": "BASE64"}) // excluded category - - time.Sleep(2 * time.Second) - require.NoError(t, ctrl.Stop(context.Background())) // drains + flushes - assert.False(t, ctrl.Running()) - - logs, err := exec.Command("docker", "logs", container).CombinedOutput() - require.NoError(t, err) - got := string(logs) - t.Logf("collector received:\n%s", lastLines(got, 60)) - - // #2: crash/OOM land as ERROR, normal events as INFO. - assert.Contains(t, got, "page_crashed", "renderer crash event should reach the collector") - assert.Contains(t, got, "system_oom_kill") - assert.Contains(t, got, "network_response") - assert.Contains(t, got, "SeverityText: ERROR", "crash/OOM must be ERROR severity") - // excluded category must never be exported - assert.NotContains(t, got, "monitor_screenshot", "screenshot category must be excluded") - // promoted attribute from the converter - assert.Contains(t, got, "http.response.status_code") - - // #6: exported counter advanced, nothing failed or dropped. - assert.GreaterOrEqual(t, m.Exported(), uint64(3), "3 non-excluded events should export") - assert.Equal(t, uint64(0), m.Failures()) - assert.Equal(t, uint64(0), m.Dropped()) - t.Logf("metrics: exported=%d failures=%d dropped=%d", m.Exported(), m.Failures(), m.Dropped()) -} - -func lastLines(s string, n int) string { - lines := strings.Split(strings.TrimRight(s, "\n"), "\n") - if len(lines) > n { - lines = lines[len(lines)-n:] - } - return strings.Join(lines, "\n") -} - -// TestLiveOTLPDropMetric forces a real batch-queue overflow (tiny queue + a -// hung endpoint that blocks exports) and asserts the drop-counting log handler -// increments OTLPMetrics.Dropped via the OTel SDK's global logger. -func TestLiveOTLPDropMetric(t *testing.T) { - // A TCP server that accepts and then hangs, so each export blocks until the - // export timeout and the queue backs up. - ln, err := net.Listen("tcp", "127.0.0.1:0") - require.NoError(t, err) - defer ln.Close() - go func() { - for { - c, err := ln.Accept() - if err != nil { - return - } - _ = c // hold it open, never respond - } - }() - - m := &OTLPMetrics{} - // Mirror main.go: the SDK reports drops just below Info, so the base handler - // must admit that level or slog short-circuits before the counter runs. - base := slog.NewTextHandler(io.Discard, &slog.HandlerOptions{Level: slog.LevelInfo - 1}) - otel.SetLogger(logr.FromSlogHandler(NewDropCountingHandler(base, m))) - t.Cleanup(func() { otel.SetLogger(logr.Discard()) }) - - es, err := NewEventStream(EventStreamConfig{RingCapacity: 4096}) - require.NoError(t, err) - ctrl := NewOTLPExportController(es, OTLPConfig{ - Endpoint: ln.Addr().String(), - Insecure: true, - MaxQueueSize: 4, // tiny buffer: overflow under a flood while export blocks - ExportInterval: 50 * time.Millisecond, - ExportTimeout: 2 * time.Second, - Metrics: m, - }, slog.New(slog.NewTextHandler(io.Discard, nil))) - require.NoError(t, ctrl.Start(context.Background())) - - for i := 0; i < 2000; i++ { - es.Publish(Envelope{Event: Event{Ts: time.Now().UnixMicro(), Type: "network_response", Category: Network, Source: oapi.BrowserEventSource{Kind: oapi.Cdp}, Data: []byte(`{"status":200}`)}}) - } - time.Sleep(2 * time.Second) - stopCtx, cancel := context.WithTimeout(context.Background(), 3*time.Second) - defer cancel() - _ = ctrl.Stop(stopCtx) - - t.Logf("metrics: exported=%d failures=%d dropped=%d", m.Exported(), m.Failures(), m.Dropped()) - assert.Greater(t, m.Dropped(), uint64(0), "queue overflow should be counted as drops") -} diff --git a/server/lib/events/otlpmetrics_test.go b/server/lib/events/otlpmetrics_test.go index 4ebfc472..ac70e739 100644 --- a/server/lib/events/otlpmetrics_test.go +++ b/server/lib/events/otlpmetrics_test.go @@ -1,10 +1,18 @@ package events import ( + "context" + "io" "log/slog" + "net" "testing" + "time" + "github.com/go-logr/logr" + oapi "github.com/kernel/kernel-images/server/lib/oapi" "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" + "go.opentelemetry.io/otel" ) // TestDropCountingHandler_CountsDrops confirms the handler sums the SDK's @@ -24,3 +32,54 @@ func TestDropCountingHandler_CountsDrops(t *testing.T) { type discard struct{} func (discard) Write(p []byte) (int, error) { return len(p), nil } + +// TestOTLPMetrics_CountsRealDrops forces a real batch-queue overflow through +// the OTel SDK and asserts the drop count reaches OTLPMetrics via the global +// logger. This exercises the full SDK -> global logger -> counting handler +// chain every run, so an SDK bump that renames the drop-report message fails +// here instead of silently zeroing the metric. No external services: a local +// listener accepts and hangs so each export blocks and the tiny queue overflows. +func TestOTLPMetrics_CountsRealDrops(t *testing.T) { + ln, err := net.Listen("tcp", "127.0.0.1:0") + require.NoError(t, err) + defer ln.Close() + go func() { + for { + c, err := ln.Accept() + if err != nil { + return + } + _ = c // hold open, never respond + } + }() + + m := &OTLPMetrics{} + // The SDK reports drops just below Info, so the base handler must admit that + // level or slog short-circuits before the counter runs (mirrors main.go). + base := slog.NewTextHandler(io.Discard, &slog.HandlerOptions{Level: slog.LevelInfo - 1}) + otel.SetLogger(logr.FromSlogHandler(NewDropCountingHandler(base, m))) + t.Cleanup(func() { otel.SetLogger(logr.Discard()) }) + + es, err := NewEventStream(EventStreamConfig{RingCapacity: 4096}) + require.NoError(t, err) + ctrl := NewOTLPExportController(es, OTLPConfig{ + Endpoint: ln.Addr().String(), + Insecure: true, + MaxQueueSize: 4, // tiny buffer overflows while the first export blocks + ExportInterval: 50 * time.Millisecond, + ExportTimeout: time.Second, + Metrics: m, + }, slog.New(slog.NewTextHandler(io.Discard, nil))) + require.NoError(t, ctrl.Start(context.Background())) + t.Cleanup(func() { + stopCtx, cancel := context.WithTimeout(context.Background(), 2*time.Second) + defer cancel() + _ = ctrl.Stop(stopCtx) + }) + + for i := 0; i < 2000; i++ { + es.Publish(Envelope{Event: Event{Ts: time.Now().UnixMicro(), Type: "network_response", Category: Network, Source: oapi.BrowserEventSource{Kind: oapi.Cdp}, Data: []byte(`{"status":200}`)}}) + } + require.Eventually(t, func() bool { return m.Dropped() > 0 }, 4*time.Second, 100*time.Millisecond, + "queue overflow should be counted as drops via the SDK global logger") +} From 5e56d6a82996bb38fbc5bc3b6447cc21eaa649ad Mon Sep 17 00:00:00 2001 From: archandatta <35818003+archandatta@users.noreply.github.com> Date: Thu, 16 Jul 2026 14:04:00 +0000 Subject: [PATCH 9/9] Document that page_crashed requires the page category; drop em dashes Co-Authored-By: Claude Opus 4.8 --- server/lib/oapi/oapi.go | 738 ++++++++++++++++++++-------------------- server/openapi.yaml | 8 +- 2 files changed, 373 insertions(+), 373 deletions(-) diff --git a/server/lib/oapi/oapi.go b/server/lib/oapi/oapi.go index e239bf17..ab35ca36 100644 --- a/server/lib/oapi/oapi.go +++ b/server/lib/oapi/oapi.go @@ -2544,7 +2544,7 @@ type BrowserNetworkResponseEventData struct { Url *string `json:"url,omitempty"` } -// BrowserPageCrashedEvent A page's renderer process crashed (CDP Inspector.targetCrashed) — the "Aw, Snap!" failure — while the browser process itself stayed alive, so no service_crashed fires. Emitted on the crashed page's attached session; the CDP session and target ids are on `source.metadata`. +// 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. type BrowserPageCrashedEvent struct { Category BrowserPageCrashedEventCategory `json:"category"` Data *BrowserPageCrashedEventData `json:"data,omitempty"` @@ -18953,374 +18953,374 @@ func (sh *strictHandler) StreamTelemetryEvents(w http.ResponseWriter, r *http.Re // Base64 encoded, gzipped, json marshaled Swagger object var swaggerSpec = []string{ - "H4sIAAAAAAAC/+y9CXMjt3Yw+lfw+FJlKSEpjT2+yZ2p1CtZ0lwrnkVP0tjJvfIjwe5DEldNoA2gKdGu", - "SeVH5Bfml7zCOUAvJJqLllnyTVUqdyw21rPirH90EjXLlQRpTefFHx0NJlfSAP7HDzy9gN8KMPZUa6Xd", - "nxIlLUjr/snzPBMJt0LJg78bJd3fTDKFGXf/+gcN486Lzv99UM1/QL+aA5rtw4cP3U4KJtEid5N0XrgF", - "mV+x86HbOVZynInkY60elnNLn0kLWvLsIy0dlmOXoOegmf+w23mr7CtVyPQj7eOtsgzX67jf/OeECjaZ", - "HqtZXljQR4n7PADK7SRNhfsTz861ykFb4RBozDMDyyscsZGbiqkxS/x0jON8hlnF4A6SwgIzbnJpBc+y", - "Rb/T7eS1ef/o+AHun83Z3+kUNKQsE8a6JVZn7rNT/IdQkhmrcsOUZHYKbCy0sQzczbgFhYWZ2XSPzQtx", - "8JoJeUYjn3U7dpFD50WHa80XeKEafiuEhrTz4m/lGX4tv1OjvwNh3w9a3RrQR7k45ll2OvcAX7pJyX68", - "ujpnCc8yNuUyzSBlowUe5ga0hKwnZnwCpsdzwQwi1upVJtzCROmF+zfIYua25nBMq6y2NWO1kBO3tZTb", - "jegV2f6JG+ZQShU6gS0nwJGXNOJDt2N1Id1209W7uNIFMDHGs7sdsrGALGW33LByFEsLcIhgxO/AMjET", - "1rjr8CccKZUBRxjaCGLhVpgVMzCWz3ImJHsvxR2biUQrA4mSKc42VnrGbedFR0j7p+fV9EJamACSNP2l", - "um2ei4GDYeS6l1DGmjBht4JbeadbItKJB+AONHsOuodYlvNFpnjKxkqzYdj3kIGb16ziVlpo5E6DWeRG", - "f+FZ1ksyldyw8J2jWAdBQmbtLnkmskzU7tefUBazEd2mW48WERG8eJeDPDo/Y+VXZ2lYZObYEKRMK8dv", - "9qA/6bNhrlUCxjgWMeyyoeU3cJloAGmmyg73azuoKEITH4yu727O/85E6hjaWIBmY61mLXQavp6JNM3g", - "lmuILmost0XkVpEjBCHO6CuWqLQ+S4mLS+hVO8jSvZbrdRswXYNxDt0uLU9uVrd4fHLOLgrpaKmPn1xp", - "ngDTkGsw7orkBO/m3/icX+I4YnHGfcu4xR/daGTwkrCvz145ijesMMDcCpLP3ESJku5nFAKa2yloZqdc", - "MiP5DQwSbpAlIC7gvMdTrWbATmB+pVRm2LlWViUqY7dCAyPq7l/LCBvNsleaz2ALoYSnGePHXeawT8+U", - "sSSAGqJnaQmVFTP5ljB/ZZG/gla9ETeQMvqQEY2wW2GngkRcJmQUD7qdcSFRHL3lM1iduwaJ8KG7X+gy", - "pRnMcrtghJnIGLhUcjFThSk/NlEUdrvZ4jTus8hZ6Ov4aei3szSOe/TfNXKM7q7Q2erw9xev3ZHd2QMb", - "8bONRRYj1CUKa1xzbZ+0XONKuk14x0itqV4sMe1VTkjMnmV8BBkCCrePRGWRAokHcrOQCUt4YSDO73Ku", - "gwKaZe/GnRd/20qYVxzhw68rAganbGwGMQm3gn81/ZXLrJHcWkaU22TKL1U2hwswRWbb1CmW0KfMuG8Z", - "t9ahNtPAUU5w5ghVuCtUhU3UDLZUpmjWhypTLef4qle16lX+4gcIzoHGO3tCHWsdgHZXtwL2NTSu2Ina", - "ta/wdbiXJU7okX0OMlWajflMZIu+k3dpkYA2TLobzxxMc63mIgXdMzkkYiwSZrm5QS5omJBWMTsVhhmw", - "Lxi4h2yuhQE251pwaY3jlBoCcSUqy3huIAwEodkctHEyZVQkN2DZ3vxbdsDm3+13GZcp43LhuP6ESWVZ", - "ouYoS4lXucs9UU4QvbH+QF2WZ1xI9u74Yp8J49QKpR2WcsOGyikAQ5LfAU2mgUAdHoQ7m3/b/M/vHFIU", - "WhorMocZEwDr3r7dDk4ZJ+5dtV/UCon5GMu1dUQV4zkrOjA+WgdOy1tdCPGxBjr8FjVC9/Adc5EVulR/", - "Ty8u3l0Mjo/Or45/PBq8f3v57vXPRz+8Ph3u99nRyClnbpApEqck76SXXi2fgw39NMMXdGbNNLgrRlZb", - "GD7KwP2AL/U+G/qdxr6W/lB7BoANq8twux461qIKW41LRYqYROPrKoUTKKC/MeyWC8tGRToB22dDPuIy", - "VRLS4Qv/CUu4TCBz720vRnM+ASb5XEyQI/JbvnAafA/XbOKbP7bjaXQkd420yU63Uy4WRSlHd9F3hocy", - "N0ZM3J3UlBv2Lue/FdB1mvG4IMlvitxRBXM81vQ0jEGDTCAO0lsYGWFhMFUmIjZ/VKTUlrdwOwUN/j6J", - "5J20wItI186fczuNvKC4nW4/P/t/C9ClNgp3SVak0WVXdIkar7zHayfNj5WUkNh2Ww3ceRNfkglHSERy", - "SWGsmoFmlyc/ddl5xhe3WkymtsvOizwHC6D33SPGzQ0pI5aJD5xfYHSpkF/mWt0tyIwlDPv5zdZGHjep", - "218M1b4qFKsKRZoP/K09pR6R5ifCJLuiU1qOgbSyL2xAFHbOBb2q8Gsxm0EquIVswXINCaSOioa1cw+D", - "tdS4J5CxGvjsUdBtF0145YK+KsFrcbZCjY+KtvfUfKvdLim/jZM8vtGxQtCt7I4zMIZPYJCoIkah9Gx3", - "czsS9B87bTTjC6cgoOSNrAsCbVSp0PS3uIFDAzexR/4v08XynCCdAGRDYhODJFPGKVH4FXEOIYUViMP0", - "R2WcdlbkRN2DZMrlBJUftI2JYsY0oH4KKek4YFB7d7o6SmnkMlZpYKm6lcyo+mqJKrLUvQc8jPmEC2nI", - "qCfhloV161tAlW74ovyNpcJpkjrcK8uLWU5KIJ1VSQt3dlCqaf7Awbbqf0cKrlS5PbvIhVPwFt5Zwsy0", - "sO4I+00Nrn6VnW5n+abqf8I9oS1naUebKbGOx8voVmLAOoJU0qgM0NXXavIY0bfuRtzHXpFWmjm2Vkym", - "tm6FhbsEckIqMrmezoStxM2tckLICplYRHriGYbESyrGqGRa4qBmynMw/dIO7Nc/Oj875gQM/5e+f6/w", - "LDP7DrXc69SwDOaQdZm70y7jemLoqYimogEakKq5y21fTbXDx73ybOUv9alpzkxI6HpLatcfZVDoLLKO", - "Nzy7N4X3yLqni9fUaCTjGhjHB1TceByVl+78DxaWy1jwVVa2y0q6K0+0TygqozDZ1Z6KI4+Jr3Q+dJe9", - "BY4oIhSfZSWtcz0pZm5mlijQCb0u6Kymz87JGcOUzBbuzSU9KntqbyPchv9i9f26ZLEm+ooYpxoejIbF", - "v/b+q/gRohdS99YbX+IKcTmLbCbuRQi36AaxOc/cC5tnt3xh2DUZZK47D7rFqL9kdS+va+6RT3dRFYNs", - "cZqsOEuYnaIrT8Ntc4+PsLGGOSow6q3t7KWbottB2lo1eRQzLnsaeIqcniSUF0Wk0y2L1VtUelJh8owv", - "mLB99kqVv5KI29snIdetBaMECq0TKPckSlNERFnXK2EwFncorGh/XoHoMjQ7XHfeh5HIhl6wkVKz644T", - "/bXf9oR0gnEmDOyzq0UO/uM7JrzAK3181x2SbBt4prvQVdb46wpzfK0mWystmZqQRlJpDZmadMv7FXKs", - "qv+65Vp2Gdikv9//BJI4HOyrHN4ohzM1eXop3IDH5yWDdxKla0RVq5Lt5uiynBuDjz+tismUFXIsMotO", - "FmS3FBHR94b1IfpUVOGNkQ2VyT/JmXvPAU9fMp5lDP0jbFliGqcqA9fMyag+uwQyVZkcktI1PS6yjDmc", - "iDKWJ+Ltr5DxLoNnFTqbTcoEkO4WLK+BRSs78h95Dheerkh0VbxfYIkzJYV1LzjpREWWuVvtBenpLSbs", - "LDgHSFhZridguxSRQu8b78nAp16ukqmj7tup8DEytBOVJIV27+3IgwanijoqHJTx13o4VM0HQ5uJ6z+K", - "p6BbZ01VQrCi72rzd5lTKNB1BTyZ1k4XXUfy+cDAb6urvFFSWSW9jUDIxD3C0TFZXRfFrSZBJevSZ25f", - "kJYbsCrvIXrUR0YvYQvu6c0vrfcSzDP18DNPYbROzVoUvQ/6Kjp/wE0/UW2JPWNROfKGruqcJhyUM8tH", - "++tWDHJhC8q+whFOQ1kbu6MhgzmX5FmdCkOo/JIcS+6DMUb3lDBxtIC/Eel0SwtS+S3YW6VvasbI9Uyh", - "Bqz6xTaPXKHgGvFVVwV2NLJqNQfJHZLOwHLUDjzkFg6bidC9PUQz8EaekvJXtSaIa2ohlqDmfEbOgeFT", - "3uPcJpuGeL117lWaqPCq44hzI2TapqqEA/XRlBzMmbFQPy/GSieKZ659NqRwzQHPxfAF+wn/gx2dnwV7", - "4Z7jM3oOZLGmP/YmIEGjuhV2zoZwZ0E6RBi+YEL+nZw2fj/lb302zFTCs4EPSh2+YGZhLMyY/wPThZQO", - "YjxTcmJECo3tNm2Wad7pdqr9u5/CQh3HW2sLRTXdgCrtyBZRUjbhQ5BmhAyOWxEdHHg6OSBRcXbSgHeg", - "hSXaQuCvoZgfrc1/BCcbTPshrC5WCAZjaqc0ks147qB7y3WKQSU94THF7d6xNlXYMnaGhAz7mWeFU3k0", - "Kj/BxkxaHhsVls34go2Acblg/3b57i2qSA2tZ+UwmDBCKQTHmUhuNj6WCnwxuU+DJsFzWzgtby54hYTI", - "7arYys2vI1Ft5KEvpOiZvr6TWt9JtasfIGSf8LXUDptHfjMZyCCxKhITfHx5ycKvLOd2GmzseHbHXzNU", - "tFpUikksWP7Na2b5pBHQuzSbA1iR56AxVpwY1Q/vr67eve2yoy47Ofu5RYeJKvM/CyPQO+C4nk/lalm4", - "y6xGh3x0+rvY3HCLUT13vUQpnQrJbfNU7izuFnNxB5mJW/IWayZe3H/iJTy867iVuhW0CUJrn0k1FPwJ", - "FhsZ3g0sRorr9Etgd+E8X5ndVszuBhYfh9U14PLIjM4dYuUCf4IFORMq7fMnj8d0t8SATt0Wu+wHntyY", - "nCfu1R7nQvfgpoHvoX1+itEXSWHIDk8pSwvEmFyDMS3caXtui5Ov57Znb8/fX3XZ1em/Xx1dnLbz3GV1", - "EB7AYC4TrbLsEqzNIN3Iagx+zQx97hlOeDfxsa0+yZURtdRTjBgQctL9vNnT6m18ZVRbMSqC+sAjxsfh", - "WS3AemTu5djTIKKE0Orsrldiuk/Yo4j2yg/ovpqAcUi/jVqC6y1a11s89nreHnMP/klrbVJHVezyXmGE", - "vFm9QmQhbvJwgsBqtjmJit1bY6nFoyy1nOtGGFKCzh/ab2j1htey5tdiDk4N3RBlzTIxBzYXcFuFmy2F", - "Trt3/LjIAu/+xrBfYHRxdVzacN7Cjdrvsx/9d0pmi5fo6wwMfaw0zpKBMYwydz92CGzsOr6y5FaW7LBi", - "4LDiI4Rvt4Jm90jYYLlvhMGunKU9EnadZ+B1SSir/oE+u2wY78tgTdNlRjHOrObSIHkF+/coEzlLuEQi", - "wVBAb0QtY8sxYHxYbWm4k7F8iwvfHDS/yh3iQfPbsogqeD4GldFi5bifgkV8DZXfnUt8lID5dQB6dF7x", - "GQXO35crvfQVO0LUvKYqF5Si0sYVd/TIbZnu9Ya87Cc17tHCc658Dk7tjqwKnh5HFZkyts+uUFe0ehHY", - "pncIpFrlOaSskFZkwbk/KPmxe11qLeZg+uxKA7foQRCyl2s1cc/zUGIJI5YtsD3PrwcizTDyYwKDjC9U", - "YcMbZZ9xwwqpIRMoAmhlOwW5HQPze3wo92q74a/sq5V9Beyoy7QnZF9rIbSJfzXxqC2b5QL/XkYrVAdD", - "p1qCRDQoc1FKh27pHQ2/9Ot+0KVRm29oc6aFv4ozKewrLrKNzCDwNkqFcU+LEfgsnEz8Tvv92JS2tPmv", - "dLaRzhzABmO8sqcnsxh4diMyYyFvR8kZ2KnCbPYSD308k4WcTMF0VG+TpXibvgF7VFh1ZC1PplvYZHET", - "m097EQTcVuQUla0N2tLQA4xHEmZaWmThbsoLYyl+IqseOWRDwuobps/eKjYuNNWNWhbStyLLvAAuk2o9", - "bX8KEo7d2lc63kjHJeA/GjG3AupJxGYDsX3JiX7114GnAydAiQ4chgcCYLeggaGHpsjL8BZfwmJcZNkC", - "xazSoWhbkyDrkjey4iMK3wt4sCq+dKoIy+DLOsgpMYJgGUyL8h4mPMd4H9Lvj5tqOJalMWDRnLIUbhgs", - "Klbz5MbN5lUVNtZgpsFIIQzLlZD2k/KZrzxmZx7zUdnLQ1hLoNVtjQJYj3Hp+c8svwGkslq6d+lfaJLS", - "Nve7whtim9x8P1VBz1ZDYQ5aqFQkzJTfBmtH8PnOfVDMdhRYzfNIRLh0iK80uJEG14LgkUkwBp3dKDCX", - "kQiKH7iBPz3vgUxUCik7f/uXLRG0vLbRwsJGLd2tveaMb0lCnaUZbIyMCNJMpCFyeykugrPvDw9nhv1W", - "CLCe7simLhUTsjfOxGRqmS9ri8H3W3rb/NIPpbclP/hXClulsLpR8Qlpy+Pda8VTISdrn4arCJjRqPCK", - "9QUszsaNuiDutnmmgacLdz8e9zDyyWmOHJ+57g0sFcu1UJoNw9n9FEOco+4pFna/y4aFzoZdNgx5Ue7f", - "ZTrTkHKuhhp8FrW7gGGtZMRLNowgI2bi5VxTjXyWq7zIEEswiYhblnAD21abeCRiaQXRV/m0kXo8hj79", - "K3Q9kB45TogK3myCWZ0Aw4jl1EYMs5lECj/XQEe1H+Oh129DqhamqtZ+8yYtCfbFi9OLi8Hxu7dvT4+v", - "zt69HVycvnp/eXqye913xy4idd/RgxWeiEqLiZAcLVBLbKTVeeVWrXGJ+ML+pP0L/+nVIoeaOQBXWEn7", - "rWey+Izfn6S6lRSOapiQWEuRnfg0yy57BTaZdtm//3jRZVQhqMsu7SIDMwX3tj2bYb2BN5AK3mWvlBtz", - "BXf2yr1su6xG3d2qRl2XveFSjHGH5xrGtMY7OwVNbHKm9BaFthul7GtY0a0Qcm28kb/C0P1mWykTwIfl", - "K1qS5Z6e/dZ3/ZXxbmS8HmhPz3FX4PLIvDZkQG8sw1KmSqOe0Kz/5m8jynumtey5XfZdz7xbLf7uryVk", - "2PXdSn5Pjmxb2dxZ+KaPNXiETLEZEmawovpTmOaZ7s3zjOduOdfG8aFcg5PWxJCwwEH0uoQZaKBKfuso", - "B62BXlQYv19TZNS/iIUZ4iRDfpuWNiDeqcMNC5Wb3eTYyIJE3l9Or7rs/N3lVUuhf2XsILCfOMxGKl2g", - "aHGzHJy/vyofaV13OD7nIuOjDFpEGR0tjq/vSDxmmGs9grHyxYzCKAQDHgwV9Npl4zXqAh5JandZIcVv", - "BTS6T1Runq8S+uES2qNxt8nCKoazwhC2E97UBWcH6e3b5mhIQMyrZ+Irt+ma6bL8ENHfAcX7DGhYF/2O", - "iJUha5i8hJ9GGajdwldtYAttgO7rY6gDy5B5ZH3AYWcUSB4SDTSu2CmWXRv7kmbszdmbUyrZ81FVAr+z", - "uk6wjazzCo4KsmOdNjMTszYeXR46TFheFQlOdzMHUzvLumy5CePXt+JnL4keqXtamKbF3hCdq1bt4t1P", - "XVa229y/r8AsOxUEQlwrGc/5BI41N9M1ltOcT+Abp5LKFDToMpwuoXFsj3Rvk2PaTp/SePyk++x//uu/", - "EXWuO0e3XXYpef5/XXfKNiPu19spVX+sLDthBWENZGN3VVgiOxNzIA+5wsh7kcAgbGIsNJiqALFXbcOv", - "/gilvdZray/LCIVGyepQu4gKdCjJhkQK/VDyZLitFdWt+1CxvQyiryK7VWRj+LKH+ROK6yhEdvPmrSmh", - "VRW9qTP/EFpfQ+iPWymrarfCsUMuvbFsO1/YzMDay125XWwAwImaHVO5jNeKp1s4fk7evWkMCBVC3X27", - "CftpOSPOhTr+lhVBH4vOo4f6SvDrCT5Vs4GvnII+kyen/XYoPbavJM0H5b1FOAWFqs1CFUJGkTdULkJI", - "FqJuuPUl3FZIwEnNtItNKKyYI4iXZTDFmu25ByxCDcs/7vfZewNsaA2VZbttxv1E0nyW2ys1TrZRRXmN", - "KSnbVl+gBJaW6gvP/LX41zuyNEyQqmIMLOg5YB21MNNUjNGAVVkU58IUHFvQjkQm7KLPTnkybQygkD4y", - "4D3r+VXdofXHYypfgxW24yHNnKcn5h8emx2ObC5pXcwKT5wN3No7fn2571G7zFM9B40XIBNgV2IG2Cn3", - "6Pzs4wqx5eN9lV/b4Z67sI+MeU/idPKxl6sXebKUJ9pAaJBWL1YCRvd8B4VDFDMNdsxy0Fgfej+aVVq/", - "1UEKlovM7J5GG8ipdnHuFanFqLBgNlAeHmmV9qY8HWhInLoiZF7Y9SjduCRfZimBlMIhsIYjThJ8ERg8", - "1/WNDp2gEp4/HL++jKM8qguRzNv6uiZROliBhPGw2nNKF95ECJ1/fbkfF/0rOOnNUDuWhQ4lovDvVTeL", - "xhWVVaijryMR62YeBV5F7zFs3ZzXvJzotHRgv5cqw3gLJSjJN4qL1+4ZZSzzat64yNg5F+6Z8/r4/HOV", - "F/5cX+XEBjmR5E8tHuqQeGSxkCX5Pdmwx+kKpQmjH8qGfTWmKPcRaTV9oP/Xx+dVJU4xDt6R1sr0gziz", - "cS8vSo5YnXercglSpe0s8+TdG+Y+iHDN2jptPQRlCrpl2xf447Ybf+kFNrUTJl+Fr4xU5oxdiZmQk95R", - "lqnbHvn24+UhxO/QXjeVa+AtG6LCVMz8VvCmPKjm3hQXU58RY3fdEZjSbC5SUOGnljLvTyv06ltzPMyb", - "4R5f7uFCMeXs3kJvs6RTfPMrv3q5LxvysjD8U5jwyr1/FWcbxJniT/7QbsDiMzfOoY5ZofOXYpp7W2ar", - "bkex9dYovmfsMv0iv3gbeufv99kx11oANg0pOwSMqcmmkMi1Rlhj3zLfJ8P3XQv9POqWuOVONh+XOyzd", - "1lcesZ5HVMB6Yk4Rg8tuHr37SXUZsJy+2LXN0Vu4ZetbHTFujJhIn3uEJLGh21HOtVOL289zjh+sHglb", - "nBQj+nutv89Ln7VEO4h0OjItlap3bWP0aM2KPq5ntcIBqx6tYRCFS9Y0rwqLtiaF9f6WEGqBjuAWR1zZ", - "L2nJwM6mfA5spOyU5FwZYGSauNNwuZQeaGFYbXryxGD/FAwsZmcyhdxpw9RJoZ6M+JJxZoScZMDcF1RN", - "gYKmUgXUwXKEslLYjxnj8dVNs6s8+Eiumis+epeDXON0lHBbKjiWj9zj0PMTDJTAwaTb+BJJIQjpStEf", - "EPcRr2mc2af4YhNi3HkjQknUwph8BWO3hdCzz6hGkdFNKaZeX2oml9YUp5IqEP2cXhlLPO2zYyVNMQPt", - "3qGUV7ukp2HTq9DoaIq1mCwWKBTW6WocLfmCZzslqT6WVtaE8lelbD0RWj4aEF5/VOK7h06Gu4xrTldt", - "EVaOhjELypMuEoOSQOkrcrGrkhEP5wryTsJttiiX4qMn0TyssFnE/EPpUpnnPe6bUitFhhLfTFSNCVPV", - "TGftczxWFNglhYBuCl+dccknGPOJnzO4ExYrqMJdjjVxsoXTGZzWgljlO3FQTK7DJm6V7lU5cWZa2FTd", - "yn2WKmSNvo9gnW3+z3/9N0XNV6vguoYCTEHPfDA6PoF7EzGHXpH7MtrUFDNV23JB6gH4UD4Yuc2vjLCV", - "ES6FHz8hI2yDy+4VoXGvzXrQS8coS0Gz0zthMc4dEda9IHmGOgL2PbhzqkCZj1/IFHSGnUKDZYpoTpdF", - "EJMplxIyVE+QLihljgiS2KJdUJ/6TIwhWSROQ59yA1XUa+nZZUKS9rKHT48ypXCfXEBnJ7hRDbnCWq8R", - "KsKZY8Wmt1i6z4ZItEU+ZDPg0vju+nTwVLh7Ib1NYCaGdhoRamucTYFndroo23Ri8bc+G/r/DhNylmuY", - "C1WYbFGOaazQZF7DCZ/DIL6hAImyxJ6P2SXbYVnVD6Fsqba01Q6WL5msKl22IQpVvHRPuMq8EMBKhaKN", - "moGd1srWmfJpVdISXWen2/H30Ol2/ImiTC2PGiXOTlZipOkK+uxoVGWFxu7GLcaKfLUMaPSahFOIWaak", - "G1oW5ePUS+D87KQlM8RfoORRT4xWE81nzbaD/hjhPn1/XKxXLIqZU+dnhbWg3b+oj2uPXGw9novhNsVX", - "63vqeqpYx4pQ0LxTs59Elq0pqvhayOKO0ZbYu3dvejciy7BeKso9rPVU5XjIsk/tz2/67NI390WX7vAg", - "hfnBzcxMhuFN5NCMy4occOqSFfk1vdCYwUzpRQlQMieEuBhvny+j100x8nNiQXluS3ZnitxdlInzkieU", - "yCvX/VUgtwtkvKyBUrOBQ4mnFMhxsOwuj90+l8Rx8xDtnRkSJY3VXMQo8JdpkxYgESnZCgIp9tlQKglB", - "XEwyNeLZKrW8ZMMZzJKaWEomWhV5+BKhj9gxFfYlGyZ5YcAO2QGOU3oxyFUmkgUZF96+f3N0QH/opVrM", - "QSLtVuxZSb9lw1SGsQZTLtn3/UPvH0tFWnZd8g29dJFQj7yhUjM82oshy4SEpoBxh8UUuVniZAvtk/5Q", - "7bKlx/VsMNYAg5tRpGOWBggNuP2VCMl+Ej+EjmP1YAm3uS5LQWMaeRmwMnSzv3g79KQmZA103xj2Bma9", - "MzlWLC1meZ8dGVPMwEHiOa5D5Y/E79BnJ8FQE1ItNSQZFzPs2ZA4BST06jEznmXeD4kx75xl7tmFUBtY", - "ZXk2uBkNseOEsQ5HHfjpxumwDuRuKVT82JTrlHo/Yh1hD03PRgIS1mHHqWwG7qw8oPFlP+s9rmvkXt9a", - "hHG5Xx4Mird4n4ZdHL0hLHoAOJ7mFjZpPl4YBsUnPgf92KKIHKvZLD4bwxgT0qmXxO3ejN+xZ987LV+b", - "bk1WND5ryYM2JgrSCzD4LmAGLAmb+K48mPdMgfvmUsmeNqbLxiID+hfqttMZzNx/7vfZldNSfWGVfLow", - "Iqm4X109dGheGFTu4kjU1l4vH1hubkwMT3NWKRkjLJWNp+wZsD08pV9qpma1RtCEsYbu3k1JvoslbamB", - "qsMrtwV6YQyZ94ycznK7WIeU3gDmvj3m+Bjgln2P4T/CqUWKjVSBLh2SWojsiKzCAhUE3lWxcftECud3", - "ZzTH9+Wtcq35gpQWMZmAHmwiAP9d7Sm6DSn67pAydZxseHz+/gV76zR59z+OIF4MfdmBmmyJwD3scWsC", - "KxFtqgwwnmWKygaUPqlaxSK/b6uYkHN1QwpzpVv32bux9c8b9KFxw4b1nQzZXm0aT0S1lH7Q+xhEkXDJ", - "UjEeg643+MVBCW3T/+zudC4SK2Z99mYb+m/cW1uh2frdEb8rWcS2Khki1G7a2FHpFPQQoXi3TVSFUmBF", - "N9se7g/hm5soYa0M2J7pNqXoKlfaou0nAdFDdDMsa6brdbb0ei0OMmC7J5s3xRJml2UwGu6ibmfEkxun", - "yMp04P8SHsK3St+Adn+Ycg1p9d9Y0iuqIYZdh1Ygx/SUEGCOlRyLyX3sdP41Uusv4ptBY0qjkBN6Bgev", - "Y+sjgec2me4e97Z8loU/yWpVlmNagRmVzSFYSZgqbKJmQDVaav0Ln3Af1LyR/KIHKVhMxSytecHZ4tAn", - "1+pugSpB2fsx7NMo8pI81SZpBXc9eWHZXqYmXXbLtexSBdJ93JVjAcVkahncJZD76Bjan9Uqe8L9HU2c", - "IuKfZtQ52jA+4UIaW6/O0WWmSKZOwAhJ2kDCs8wEZ/SKJco3yfRV/Kpu5E93kveUFVUuFYyVe0kmkhvT", - "ZTewSNWtdC8i7He8j5sLZbaebmP1ouUHZSWYUFWkT9FXk6dEwnMMmi4pI1xMPeKGChkuZT6/Pj6nS6oV", - "zX/CXYZuC6NmfftQwb5W5N702Y9iMmVzlRUzeMnUeOzEZwpjXmSW6jHmtick7Z4Mc0+38xBS9vMbb7iv", - "qEUVtqfGPf/QQNsH1SQi/2Qv2HnJ7uuo/sMaKdmyo92kDQ0KWZloWg2aUF320AqRDBrpngppzAQF1CAL", - "fT9BnOG/UY6lfXYmWb04pO+c7gNcCGIvmJoJ60O/hPEmkj3PzG+nCi0bNPk+y4DPQyvQsKIaj73Rw63l", - "FzcM7nhivRMqKeU1Kj2OiekCaH9HV8c/1spXtu3G+EgybHbsHlgELTb848NwH+N1mFQ9lb9sbk6DdbwV", - "/THoXXJ6FzmErhSju2VKs1QY6r1cDZ0LTrvrsoUq2KygCsMpbuEuz0QiLBu6gwzdDEME/rChgJeW2q2Q", - "7D7IVbUwTSJo5oVJn12uAr7P3oVnWdBxbmBR3vXyRe87qAUNCW3XnvgN2BcMS/bfAhbuJ2++9/KjT9P4", - "LFaVdWt9oLreltRlXofa77NfKL926Hc07FaOzBoOOXA4PPKk8QKxCe2fAfVfMi4X5BFTPoLSHXw87rOy", - "IVU1357XS7ohjJF6tHbr4o0Uh2HFE8ngGuGEiCgjcNeMvkyr+uyoOpIHVKiEQZv0J2FJBlwTfdk4ZOkA", - "Q99eZVih6x512cqor79njPvkSLPVHA7Jp6DhJeYsZ+rWMF5YNePWx425Byl6VHn9mpqMJeKh8cfbNnSm", - "VZP/0O3AnRM/u850iqPCLNsQXGPEbmT3SulbrpEhqXF5LzWYWUVswoJ2dJCCsVhI0AFwKXQWyybXbvcF", - "owvwGMsKmeFr2bOcbFFii4NjF9ULMiMQY3JDa+vh1B76QSY0eK4bFoiE+G2dyweeSW8ipzlPuZzEcUDZ", - "LN8VbO+uXp/vDrqVUbuBzw0/QD3R31d48t1D/EaAL/Dp6BCkCh+tQMDc6k2MeNfgIn32I9r+GYzHTsTt", - "hU1avnDvAceQ5rBPMHefbYL51iLp2Lu9g8oCp+7NtCtt+KqDaNgZYfPwlAWHerUtDN/yfhTjvU8UEUKt", - "OFZBMQNjvOK+aqmJB5uUqw1o6hnPDXVGw5iDg7HIgKSQ95odOJKVRih5kGvlfj5IhckzvmBOMLws8wj8", - "hFhF3KkYPrzeYTy3wpcrqndAbu4EjTX1maJ2j3j32He5l67VXS73i+03Ij9UPgj3T7Urta3/wTdnxgtw", - "V+04sL8E9x/+/OFDUcwG44xPDMHHXdFmP3A4cwBhzDR17N6Nb1RhwJc53zEOdVRYGyuIglMy+pVMuyTU", - "UQLX7imDse10O9opMW6rIk2zYMkid7mj6Cic8MnbUu71ytvQ8Bv/5K+t6p7InW4HI3Pwk+gCU5WlgxtY", - "mNjxUop2dT+787lv6z0xadaa82A19HXJESCL2YBe8bQccqXOi2fLlP4WcxvRQChm4AkrB2/HDOuuWkbv", - "Vk/x7yxRyglUXtUCoBvLFQVrRmeKFFr+j/vMtISudx03dQuS5iPFdeoLJexakTJas/bYC9kkTE4Fa32W", - "z+bYXjdpdLPU/1QfVbage5jrEz+Lx10HZbiDpLDo/8i59i0TkNV79ZR6aZE2QY9Oz+KvZTVLTpnx5Dsk", - "GanJXkM9w3C0uwR8wbkP/Nicaz4DC9r0r+Wpf2cqWf5OIxuVnNGSHTTzXKu5SFsijZCUZ45nbFJlVhnW", - "h24n1Xyy3fATzSfLo2dqDtuNfqPmsDwa4wMcm9g0+Nx9+BMsamPJRrdp4CV+VR8GdpAU2qiNmv8l2GP8", - "sD46A9ioMV66jzwK12KSViPigrdiBcMacrgG38Z908yhX1F1leXVNGDbOHk4SIxzV5NuOKaTE1dwZ8vr", - "WabyeAOGbudYA7dwgj04lF7cT3jOVAprNI00zM7ch2xPJRgLgqfsMoyZ/Ofvv9/vsxMSFigL/vn771GJ", - "49a9gjovOv/f3w57//zrH991n3/4h3hSrJ1GkgtGRmWO21SbcB+iPQKPvrTIQf8fN7tA3UqxyzyBDCyc", - "czu93z1uOELYeIrLPP7GLyBB2Te53+5j7s6zleQdHRapnYQdZfmUy2IGWiRMaTZd5FOQy/Dnvd+Pen89", - "7P259+s//cN29VxOSP3c8p23VAQOLVLtAjeo9vRdVc6mpXIP9gIfaG5h85T+a6ax87hkP/7O9mZ84cSP", - "LLKMiTHaZVKwkGAwyH500VuRxhBqeTX8bO3+o1e7LIGeRuF2bLNF2S6VbNK6o7G84B4fdT30cFlVOXGf", - "rFQ1HIG9BZBhI07R9hH4XFuPvY7/M56pMvHZYqmKmZBi5jZ6GIPJ2ubcPuUNw+hY+HJlb8FZ6khLA92Q", - "28usDKE3M6Xs9F/JTo6WWjTpBlOd07jdGUbc+EL8uCDylwzkxJ+D39E5nh0eHh7WzvV99GAPeWW4I+z0", - "yIhzynca6yuxTBhUK/9212WLX+sqfc6FNiXsQm8Mam/gNjHBmK03TtXzuiPjlmXAjWXfUvt+NPOUO13e", - "cj0gsgyX+hYvr/qP5dOs/ZFg2cBhB9eIR5VNixmXvUzcAPsBfhdYm1bPocJmhPAtX9BBmJDGAscOLJmQ", - "wL1LNleZNy39gvFFbjU0EphBDnpgYIKYRuQA+QCJbDCjXgxiIlWzxlUt4rzxeeNI3+9Il2XRHdzXCgTP", - "aBer1LCRPlfO2XzFHrY/Y8stIW7RvrAAqr8vH6qKbKJ9g+wNbY89a+z12eYgnjbhXprhtjWILU28zuxy", - "Sm+584wvbpELbysM4q3paq/DakpMcovE16ct9hLqVXPwb3zO6Z+UJVfNTc9M/OOUG8YTDPWyin2DTUi6", - "7BufGf8NvS6/8e6Jb9ica+HErX86zvIMXrDrDr/lwlLDh4myau+bqbW5eXFwAPRNP1Gzb/ZfMg220JLV", - "Psec3r39l9edWOgdFWOjohxJAw//tIKHb4hb+zPiE0bM6mWsSvWaCcP+dNjg8N81+PtmXMPL3xIfDG54", - "R3QIvRSXsKA63aqpPWD5Uj4Ldg72KOz0pup+fNPmeA8mv+nVdyJF5RMkqzhA3NwepZ/vExtJQUf2cxmC", - "WKmlcRm/WD9YxJKbqlgR4nIyH7C05WwFIvy6mACo3zakzA/Blnlxb0Ajac0vEEOQVyKDMzlWq/xImEEq", - "9PpdofxCd335nGvpsalai3s6UT5DhcSH8oaaa2VKU8ot9Hzt39V8kyjfccei1+1IWJ+Z3mXXnVTf3ume", - "+7/rjnvYXHd6+rane+7/rjvxuNF4dOoP3EAj+XAsQvDB6k1s/SoOOusqkojfYTBaWIjgyaUPO8Wf+76O", - "aNiGALNFxGmIHuao19cW6wY8qMHQX3obOlFocUuy46vSR8PI99jW4nkb9OPoUsPePlvi4X1hWS51X6Du", - "hiVxs5jPBVzkULeBHV+cHl2ddrqdXy7O8H9PTl+f4j8uTt8evTndIq+PUvpaFRbsS7fib4/D90S4/wo5", - "q4X0tevLcj+lW9XH0YUeI55v/0Rx8xgKWaWd8DJxjWfM8jsl1WzxApNaqXiE711WzW6sBj7zaQJDbECG", - "DjalZ6hZKFnCGnUIt5URZOqW7ZGFm7ZEpm8fkTRsv4dhl2mYcJ2icx/DABTLi1EmMB9Z2D475lkGulf9", - "0V8ABia9u7xiB+XuD/xPIZu2TF0MDmhh6GZfMgPAhkt7Kd+j2KXYTHkOffYzz0RathJIcDMhJ6UesypM", - "ecEh4SfxhYqwoR0GYAaPKOpIaQVxEvgznucOzZyOkYuBW2tD/MBRLtz1EEp1QxT2AGOkB0H4r53Bh1Vf", - "uhGkrZSTpfnAhyltmiPNj+nD+lh3vG2Hn5TfljNQLNLAa0PrJ6BvUUNaHp+pyXajX6tJGFuLdyIH4IYZ", - "zqrv0RkSmwfdEdvO8hMsYnOQBb6sRrb1dOSuaFTY63YyMYfBXMDtlkB+Lebws4DbJUhX02wN7zDTKtB9", - "OFdtqo3HfENDTmojlmcTUtiB15G3muxMCvsKv1+eSoNfZaf5LsKoDZPuPN/qXPWQ6W2muiy/DzPVSxhu", - "1+T5LM1gebTjjkJOtrsmP89rGtO8pKV+s9u2ncaPV+fw3ZV3713d6TYbPu7WRjOMjnSPu2efvjDjUi+p", - "rRsmNXnBamug3TsvldMk+Q59OMpRiqe7FDwP42pFe3cuiLw6xw732FK5tLtStm7XioC1FLHtkC1Wmqy7", - "UqNi1/IfPn3bvSsWb1H3J/X2Q7ejJGyfzrAsXT90dxlWE+lbDoxxgF2H1ul+t7ERFrbbBBUv3XJcDK93", - "GBpnLjtMUFHkDoOWMH6HkQ0s32Wby9xql7GBV+2+Xp013Aug95khro7uPrjUQncfGtE4t5ykRS/ZbfSq", - "Nrjb+BUF657D78EHWlTQLUc33oPbstql19v2w5YV+C1HRl8SO46959Jtr90th0fF5H0rXlJ3i9fCWDTt", - "RcxgWvMFU+OIUU1IsvFiwikVzOhvWxijNFxHvNGlmI7UNs3UZLlWAc/zzBuf18apL3elmpR+DAt3trWL", - "UEu3kysx8734yh1Rr0LKx9/WAt7iHKwvHbPpYVjHuY+hvShfFMtOgG2De0Po3P2Dettm2DqYdyWGcrf4", - "l0eMA8GgwgdGgKTCWC4TaLgFv3/quA+3553iPh4eDOFt91Xkg/snl3bpFuPm/E3oWQWWBAxjVt0LTbed", - "aSd0vX9kYgrGDjZFWNZSiIJfaVOAYrdjdLJpYir4t/Wcy97IsEC3dorYDb27qfOlHdzVf6HC+ezdT8Fg", - "Dat8Xd1sxNozaqQBJvhb+5t9reomepZzbpOpD368H8Tboh9P2qMeS0bx7fPD3WMgT1pjH/vsbBySDLus", - "MD67cComUzC2qi5MQwJX1IDo44Ws91796bD73WH32++7zw5/jW8Rr9ab8TbBa+xjozSMHe+g1DDxOxAL", - "LquXOCWkDHs90IDHFIZRKl6c0/gcsyrTajW0tlqdSuCG/DtfJLc6f/B8WsVAmoLqHvOU5xRpLeE2VCis", - "AkQQJ/Aup8DTcZF1KU86/CVrQc/WoNOT1mDTEm2++/Zwu9DT5QyE+0neDWGhQeoGsUWVUxaGYkGXGy3W", - "UNSB+7BL33INzGKZts2RZ2sEaRlKP9skUW9gQZUemXGX4yX69gI2vv5rH1DpZjeL2UhRMRlcqM9OeTJl", - "bonQNmQEjNe+ZabIq6qEd6mySmXXcs8AsH9/9gzPspixFMZYwl9Js99nPrzKlNUyrzsXGHRz3emy6w7a", - "JOifx1Zn9K+jzP/p1ffXnf41BVVS3J0wFBWa4AZ5ZpTbZaJmIy+yjM9EoPn+yYZ4DfwvXO2frvgIp93h", - "Qpe4Nd5ulF9TLbDTO0geLYKOu+PNMEpzIR0fkViufFU0cT1pBmP+LVIZiWbielKU/VS3xypuBlqpZihl", - "/BhFs/431jlwQ1muxVxkMIEWtsPNoPAlBNZPGdoOuq/dVLLIUHoEHr+an0lnj8RH4EWHIiBmCllWXrmT", - "BUW8e1tyG0sIVxqLlFeP1T1ej+fY9zN6DzktQu14lw+wWecCOW9Hrz9iUfQeZn98WAbYqZwLrSQ+PMro", - "SKw+7dsmxSvdVZi/EuG4W1BjOwDbYxcJnBvJ8EGBi7xOdCXAynOsEuHa9+Bpef62x2C8iiDcCTuIR8qe", - "hzqKoY1ES1F8jGMcjP70PB7GVCv9RJ+yUTEet/TnozjGbSdThW2f7EM79H4SVZLhbuC7pCYaiL2yLL5Q", - "w94myKg+TYOpda5OL9501s9bD6byn/909vp1p9s5e3vV6XZ+fH++OYbKr70GiS9QFb2vNKFKt+z86j96", - "I57cNEsWL0diZybe97LsopOorJhRE8l1Ucbdjla3m+Zyn+wYGo+zdmmja27sMue3sn5hWxUgi4ju1U7E", - "vnIsDKxdbJaCR/5rxlluoEhVrzz93vnVf+wvM1bS7FEQlYEvcyCJ1CIu40ALTaKWAecrxNQOgcFaywkV", - "O4B0ZSX32f2X+RDtgdyE6z34+VnNYMxHjiFxZtxs6+ghWvf13WUJrLb+I6Gybmz4JRZo7JWdYiN9ymr7", - "Ke24RSHSOCPGts4DbuN2Yur9sNKNxQ/bwVTcSmqW28LsWguvVoKtMCRl27lSXgzyJNYU1Vgxw2jR4/P3", - "rEB7eg46AWn5JNZ8e60YrbowiWbl4Ck3vo/ZNjoKlc9vibeudhyKkYda6LT7MhS7RYJHzS3nFUxtI763", - "6vBD24/LonbApkLeT+iccMsdJ7vVggygS6hHqQ5C5kUkfDvllm+lWKT1VTY34Cnn/XXjmR+kL7rt+LRS", - "46ZbPaH7woJsQ5IqDw0/YP7zfmdbk4o/igZexdLvojtdnpY15zXkGozjULWGYz5HRemV4qYPhWbpWKuQ", - "xZ0iqoJC3E/3urmllaB3RwrRBOOtWEPJSGlyYdg1DrzutJGs239ECpAh3Aebq1oboGRayJtm3SZMGSoT", - "kbYkYooWR/g/zA4xUumC2ubSlKH6Jl2A9NS9HEC/vtN/LDuhLH3KShsZ2inSuTBKL174WpY3Ut2G1X19", - "mdDfrmzAvlSZlBd2qrSwmNOZUUFqSm41tfKifXZGtfawlaTxhbwKSQsmhbEONxc5mK5DA7K9Yt0v4jHN", - "NjihxHVV6bgbSqLX6zJXtaYb1bvL4rmNGsBlfHsV77q27VVbiVC6PE/i/Qf3uNqQcbK+1fu21U2oogXo", - "eMbZWEhMjdhGDarKVoRRbUrQRnsS6XerfzZl/Y3a743k6a2Vtmq3ftA9N7t0z6hM1vcZu/MqBukCJttU", - "jtrO7/Sjrw8bqohMvBFkTc2NFk/EL+iB2GWiLaMSaK5v3HMs72UwdtxfS3hQnMIOc0ZdweEWuuFiN4Hs", - "Ph4VXQJ6Q/mnJmJERVCzSNSuXurM8sHdesfOj0qL35XEEkS4FuMzVUjbZxSe4h7O+HfDMPG4yyRMeOPv", - "Dg5xyU072FBx5Ge342SL9VN1KyPLF3l88YdEYpRlqrY36m+iCm59Yc6qllZzqd2JYucptw6PWCkwtiPX", - "EmkKckNKNYVxVD4yP2ijj99/17LtVyKDc9AzYbDm5v32j10D44Y3aihI2aqa/aVhvdg1LTpS+etPz5/v", - "71boS93KmJ/H7RV/Qs9O2O/7lv1uk0JL2Zx5dbfkziXPoS9kfM8iXGtSmusV63bsTMMLA/UCB9QtIIfE", - "0X5a+g52dD7UPeFYqi7me6iXkmgEjR1uJMr64tELcSrMK/MLt8mj1lUri96hOQDrT8aLQTjCFXPYbLct", - "qd3Px8qx2WKLWJ7WyCS8gQdWZxtrPoN45M1FpduGjxyIx7mj2DloLVIw4a3kb2C/DvNvDzcZgaMm0fBg", - "ixgzawosIO09Uo043HRA6DN5SQjc7nis9lF3vIUAzPW3s/ZCZvwOaxeI3+FMvvmhfQcYxRwafb35YUuI", - "LJfsetYSkOVOd1SkQm1G7mPfvoG7z6nsGbaFnosUVJ9dECKb+rva6Rl8Du7hT6N8JJ97Sp8XmYEj/9fk", - "Bmy9yDk2wsOkfGbAGjZSdlqrcb7vK1NRkFITX4ShHfXci7y/ZenyS6vyh9KX0gm4eTbf5NlsBqngFrIF", - "dnTHKAdVWDbRPIFxkTEzLaxT/nxJghmGxaGpUEiM69C6wAYReFTEkbibZ5eajAQwt6EnLMhY1Q6Qc8hU", - "vmus5RXWvaOhrHSHWOyaWytSw5bqHkRK8wdD4Nqyqs3qE1iy9rdWW3pvpqSySoqkDL5i5ESodsoTrQwR", - "SSbGUO9X6ptwsffGd/19zY3t4cq9sxMfXVj4IP7Ly9NgB/TmT2GoPh1ZlFb6c+/gLnVnDJbSX9fCsC3p", - "YansBhXcuhUaehnMIfO2JCwVgeW38lpJDg85BjLF8yC3CGU7fOGN6vR9dqRHwmquQ/UMr15S5yZfiqMq", - "POEYWEqT9dmrlRZ96+qDdGOFPXDHoHtosyK0YalKMEgKym7RQ28E+0dfMeNg6S8nOG8tAK7LVsuCbGpt", - "v9Y8+lkbGSsQ/tvlu7eljTEGn0wYf6/ry6NQtShyRyzDq1kpPAYJAqS78Kdr5X8JNmCZF5elm6C1s791", - "vN53wy27+2/f3B87+Td6+zfa+jfqL9f7tyCXwt35ENd+jMNE+u1+FCNvCfvL4Om8h0+5rWHSarBknmei", - "xQr7C8+yXpKp5IaurDJX1C6z2WrLwddPSXk6NhSFbHSEqXdh2t4B3/WNQ3buq1R2U7qnuPMSLePGrkji", - "qg++BgM2SMTmtdDz2vTXSrLDLWL98CB0jijuLNVN39ne+LDqwjewMFarGzDRiqDR6Jd41dJ75UWFgM1q", - "HyEvrJYf5TjRHTY1z/iify0bTEIXwPZCN+tZyIg7SENt6P0+u6SefWVCwbX0EeCOBbi1UNfhkqnwHqyt", - "17gptod/+9dDdy8+bWu/fy1rVWqx9YW7tUVOUuJW6RTbtqfkI/UhxeXJhbSa99xXtKC5lk5vkJyKf6FA", - "pJ9zXhgHpytsX+f2Rhza7WUN6KLtk7otvTwcKuK9YjMCEgZThWHr1EajpXibGjiCSWA9LmLn4il3At7p", - "+otcMSH/7lv7uVf/SzYTxvIbIEUJ5STqIHhnI57cmJwnUCEBO+yzdzJbeBZmYjfA9ozIQNps0bina1l9", - "hrixT1dVPmEP+8+iWB/CcrbtY/KLFhbKziv3I/T10GoErIRig2HB+zZg+YC9eMltiVViOy86Xhs9w8a9", - "7Oj8rNPtzEEb2s5h/1n/EA2kOUiei86Lznf9w/53vtQeHuQg5BMdUBcmMo4lEevYG9ATwNwg/JJQAO6E", - "waAOJcF0WZE74cOWJo1kJM2Fe57loNErn3aJyLAMbiGtyKj3c/j6BOZXSmWGXXdQ3ZNCTq47mLecCYlt", - "s9QIdaaUjWCsdKjHivYinzqHyFR2kzxL0T5qk2lY5ZXvQuUrJP2g0gUFs1adeao07YO/G7LGksSMuJLD", - "bS5pF+FIdIdWsRleq68P+rfrTq93I5S5obSVXs93Eu1N8uK68+v+/TNNaENxtKq+c/RJyWaYtYjrfHt4", - "GDHk4/4J3im+rMqjeWAvV4n90O08p5limke54sEPPNAk1an+0O18v804LJsheeZHYV3b2Yy7p1DnPeFl", - "ucWMFzKZeiC4zfs947AKe8seZpuoojCge6EPULUMYPF0LQww6gfHKltdGfIy4uXPfYdV3Wu5kVzY7tRy", - "LXcll2PQWO8+3ELoeuweKTf+GSzHmofSmB6L2Wlo93bp2yB2ryW2cO9hQXRIyxnpHOX8AQ3R6Ht8cn4Q", - "stOxX6oGNnKaNKTXEi0c4S43UvZ51YruvsQdFw0xjWob4PfZTyEX0P8k+QzMtdzzGWdemh4rdSPA+Hu8", - "7lDXWCw47V1P03IG+mv/Wl4CsFBunHrxVTvpT5SaZFAi9gG5hMp82fB3H4REGXfu/D9wI5Kjwk7fzUH/", - "aG1+GhpZ0h1EN4ymJfexeZ9PNE/BlKO8UH3D745LS4I5B33u8KTz4rtvu51zlRe5OcoydQvpK6Xf68yg", - "83O1lHrn1w+PxdcCrnyxrG0Z7dxZ2jlckWeKp72qQ2OPy7QXvnVsT5mIovMeh1ERW81mjoOUU7DfRc64", - "TqZi7igc7iy2R7RTmLFCpqDZwVTN4IBYSNUh0xxcF4eH3yWOFPBf0L2W7j2oHY+b1Vcgvi3kPRSNknNe", - "y4+oaNB9lYzRHMn0wt/xOp40KzIrcuwsqvSsF2xlbTpHrc9ma8Ju9Y1TPgj8FCCZWDHntlF9ozl9vHT1", - "K5U5mKJ73SqWZzwBX3I+gGs3qC+5FI56f+W93w97f+4Per/+8az77fffx6MAfhf5ANuHrmzxrxVChiYu", - "Pvq0kDnlMlXkU+56D/v7hWTjGZdiDMaiiN6vWyFGQjpK3KTVl9vzNcBjL5O1ClwNuvfT4p7FIpJLbCBU", - "gLQb4XZENSVxYLQqTz8131thQSU0a0i+x41jSGa/zgTLI3pu6N/SB6Og48W53mnIo5ZMLTUWWupqacgt", - "51teHp2fYcHrPjvyv6Lkp3Alp86QtcwK3zFdZIDhWCFE+i7JCuOQ16k/XWYUk4opDCzA5IeqR75hCZdk", - "o8Cu29iVJER/GKtyE4wIY6GN9T0nQsPMcPFMlHVHyFoZGmFSM+BrGcqiFwadk9ipeOqpKgXK4HLvwsoO", - "iMk5VFDHrXYDC+pM6q/rWgaPZ84XbhbviGBaFTLtWS1y5lRHmVAMOWCBAZmKuUgLnvlpYpz3B1QEm51L", - "768GrrWZrq5UNV+8nzKCU7Y03fiUtFcSAnVpjRJAHaeXyGypKWogtibgqnaoTwSvSL/Ve4KJOtSFbrKB", - "rD8phC7FrMgoYZSort4vOm5IXIERmasOHKtvB9MF8PS4ZtqK3dZjgavZKhmhtfT2Kjse+yVRTq3QzYNv", - "1x2aLMtlptGKla/tOtE22H6fTePkE6F+3AJ6X/RHq6fPLsM2qiUUPhuG9QsZZIMxfQt4lU2I42Aqo4Of", - "CEKr7Y23Bs6jrF8rfRajMwpcnovQiKN8LX82EP9RpL4Ii7qt13dsgrnZXjuu9WFtKdRaMEQ+MFTqA9ot", - "nVROc+OhqqJbVlvyCmHogVzuDToR89B+kRTTDLgB1K3qXa02NK6MaTxlG9YnQs3VRuP35Btuos9EXOJW", - "qsqZBCaOcFjCmAlYQphB2f+/lUn8BWyjyulTisd4OdU47WLUAZ20PMRj3OJfwDYCG7zmQcwirLSN8tHs", - "Wx+/3LLa6hOh+WpH/Adph/4W3Mk+Laq/CUVEG9AJUrFMDag4jdkGYlWD+/V8NIQDl+ugGx95Zs3fX+Yl", - "kJ28SpCplZu7lrEichQihoXOcg1TkPRuXq1W12UG4Fq6zcQrzjFuKzP6RNj+WAOkYG6syvtKTw7u3P/L", - "tbLq4O7ZM/pHnnEhD2iyFMb9KfFzH841VVJpUw/88NGP4bzuRe2j7hN/FZhfYbwJjaCg0qjHw5dAfCJy", - "WK6weF9qQIAitnxO2gLJ+LotCfFyC8SvNwpqY1VX/AYu66GRT6IxrqRsfvAwWitxMJD1IKcU42qlzdbN", - "FcFSbYCiYz8pQMvcBFYBKAShbQCnyrJ2JkbJqGzuEzapCsCBcrQdkkjd32xNx6tx0qa22LDzNep4ejWw", - "kQ3qm2lLlqkJ5opakdwYtieV9ZnKZOKsYRAbwZTPhUNpvmBzrhcvmS3QSjfDSKp60QGMmcK0iuoo5G4M", - "yamYyuptl97V3W0UTfAhP+jpaZg098o5UBWuFtinuA+0IlGwUIgFD6xwGGLDyIDR62nIgVv2lvV6FHR1", - "yMiDQAo5+RCGMQ55GXJCn4j8alnK9+WOHr0+ExsSbabSFQg83DrNeAdtLgT9tjBHH3D5RHBZjud8kJGD", - "ggg/G6nlzkZGjXVQ8DHC7TytqiUc3I3M/T8KQ14shycj1ypdRMZyp6BZleeYjJEA26OAhO619D7ZyhvT", - "dYwD89e8O65b0/l8OWgjfhdysu9fzeVCoiw2xuCOJzZbXEtcruGZ0sBTIZ0sd69n9x7HKOqwxpBKaBc6", - "G+J6nu1wNgJjezAeK22vZdXHrCycHWYNXgo3Mypq7mHDJ8AoPeEHxxsdEELrVD3jGYaaWnUth0GdHPoG", - "DFwu8KbZQhUsVRgCLcHt+MiyDLhTWmUwLFN8hvsa/ZIjYL6kUv9aXoTAmSasjHWqoy5kWfEY3VYvavE3", - "ddh4CHTJvd5F5VguQ6wfBQkWuyFwkOgDmVJgbJm0QzHr19JqLk1Qb18wMWYcXTu6Cv9x+0Znk9sg15kT", - "ixXRMUwyBGyHHDLhZlxIhw+4NgUCJ+Bx1f1JKtn79u7O+7tyrXI+cQK5fy3PNYxRtXbX48SYgZxjxuuw", - "ii74xyElDx34OxqiP89HtxLZZBC8iz2rxWQCTk+6lgQDoiQhEZ4+gbUK348Jq3DLxyX9PmKgAIUFDerh", - "bUvxHVevev/ic2+asUtsxnP2P//13wxjvA3MuLQiwSLK50dXxz+y1ei5eM1j/9WgJVCytgPycbPhH9cU", - "xHjdeVGPk/z1w3DLDeHo6G48WLfZxswxDdRM4u+k1T4LQ7aHJVcOqODKAdikHxJWqd54CKheRSAKKTfd", - "4J/FtN8yQWSZG4uKFTfClhqU2iTSaEm0NXEkp/UwH4NWyLD7xEmspMDKJNUUfYwMoWNUmQFr4472+5uD", - "UB4cIvL08RsYM+6GDDzvXL1Ny3X/d2Nj0SmY9gUGr3fYiJ3BYFOfxuiZs2cFps88OwvxV75kBRZM9w2u", - "qsBBP9j9P3NQa9ePGryBzI3fQ3c7hdqxoQ/zO6BV0LE/3KcE1aG7t3xQkcSQpAKySAK3j2cIh7VTXsbX", - "GCfv8INbzfMcqiZdYinppw1cvhyWE+4RMr54XXp/vHgHL9wrLrxWfJe2oC7LQE7IPp9wojXLvj18/i9U", - "Z7FbkZ4DYILBvhRGgTzCA4B2McqgpS528y7XKG1VglW4QfQeVGMph1uLnJyVSzhZYsWek5FlZSGfSYS1", - "8eGOKHJjMvdn5aJqaEKeX76s1M0SC9zMGSz7rvoPUeyfH/558zi3wUwkK8+Bx3GWL2sP4fnQek+ACpf7", - "X+TlZUx3yvIpxyuuvzyOUJ+hZ3taKjT4lPfZuU1NNM8Ks3L3oeLXQU36llH2kXBuL1WfysAZaZD0kTHa", - "rx6SLVeB9d57WcNbqXHJnwxjHxy73HIchxpjc5Bo4BYGZR8MRJMiFjGEH5ZFfJ4qbKi5yk6o8mxdzSE6", - "52dkXqCTMo45X9X1B7ik4NjmFnA5wQ+fGi60Sr2h3b390iVI6Ijpwyjr+eZxb5V9pQqZPqJDG3fOeDvc", - "gh68BmSvSN39vKGFFeX+FwAK4VHCSN1KpzE76hr8LrCE0ARsrFKXLbQ0jLO/np2z8i1Qe0OEp0FZVKaq", - "/hZQo78aQ+LXPxH6ryLHiHzNZ2BBG2x/0dbwsaQc1EGtKnV9pxqEQ+Hrzo37rQBkB/SmC3XwmjjQrRsx", - "NtXV+3Un4ezv9UFOL3fr4Yxl7SRErPoFf4l46YFVZyHuNUCIFh60cXw1Nt0CYcPbd89yXXsAz4JzGPVQ", - "N9f+Wry+lmsQm/3V2JSp8Ri0YUZMpBiLhGPq+Zgbev7Rgl5/vZYp1P/k/s01vQB/F7k3uPBkKmCO7XLB", - "Ls+CZBSPzKpRlbujL4Wsun+sNn8rj4sRDH32o5hMQdN/lT2kmZnxLKubI0aFZZbfAMuUnIDuX8seQcLY", - "F+w/HbRpCvasy3zivwMspGzvP787POx9f3jI3vxwYPbdQF/YoDnwuy4b8YzLxKlSbuQBQoDt/eez72tj", - "CXDNof/cDfAMQ74/7P1LY9DKNp918a/liG8Pe8/LES0QqWHLAKfp1MFRtY4K/6oqNfmr6nRrv9GW8R8m", - "1pJgV67oqfdBbPFqya71fwhrXDLnlewRDS6hdoNni03WUDaT35YnICfw17rS1/5zkbC76YRVQ/1VhEIt", - "r9at/wtEm7+ArZ+gbB+1Ar0SbTJhLOrpphVvXguD9Z7NPYXJl4kp1akjqFI93zKqTfIF4gpm6yLkKZFw", - "FTewUX7b8y20dn/C0NjHeLphKGpl7vgC4YQnwGbe6OVaR8waeFo+uqO0fAE89U/u7UgZFwsqoZv/c6Fm", - "lViwvapp0YN0CWT90TyuLwxZMGus4a4rkcMAMfpBrbZ8K3Wvlvh/uiSkll4C966uUSud71OGvkBAXoJd", - "JfR6W4ADbDtgpiIvIUwe0PYgLKxzYmqOUp87rnQVX0ICwYfqa5gpzwMol63fUnUiqAePFj1SaiQtLvoU", - "jB1saKfgvvF91ksO5qumeYV2m0YK3c59vfnek19tdedyDHQLj1aJAaFUFmH40lldpDjD2OtrdXIIps21", - "RWY4Gl4oBg07ZlM9GWFNZdtcSV9Zxq824iDr5qORxq6on9Y7TtQq5VQxEmo7OnikyJZ19HBPxP6ryCu0", - "rgHwfw2S83rBoyUUXcF3b1zZgPC7mkbb6OJabiaMzSbShkX0Wi6ZRNvLHXkb56MRV2sU1dUUlk0vpQjZ", - "Im7okxFtPMqnrVjr2+0DfXwbL783LGaE5X0dOvV6+E2vGrff362GcoDDk7CLI3+H/8tZxjK6trCN2+WC", - "REsvgVojpKd6A0R6LW0P23sWT8VjR9uev5fitwJiDYIqqrz117FVvNpyvXabTNlj1/j7RMhGh6kbqX2h", - "JjmpaWJ4Wwd/hCv/4MuYAxUpWcY3lVfotmSkQMODtzR4u0MJx3W2h82mhuexwvoEKAp2/sIBdYktf0Jc", - "eczatwykA8qRazUlUdfuV+aUPvuIsFo2C1m4s7TbqD1okz/gEp+2vtlOJOe0anqjxrW3sM8hxCanPMVT", - "/9H5997l5WnPlw/qXUVbUbyBVHBfbX2MXWWw9YZPSdxbZmL7Dc9d8NKtsLqIU+7Dl4im1F1o+ZZ9yRNi", - "uyXGusf8+iAjLMqzjcHzpKZ88RXj50f0e7+rGhKENpatHSwbvVP+9Px52zax7WPLttb2vSTi20biP9Ac", - "e09rRlkS6ksXo2iWcpIzxENWoVqZmpiD6mLjLjo1MUQ6LXx4CSF8d6F1mBsYjUfxqr5ttKt/fJmxyjJ1", - "G488aLT+rvXJWwYzJniUaXtiHNr5CcP81tYQZrtU2WWd2tnjq1UfDHJqU9P5ZBLttZpsKcocYn3W0ism", - "GdymKYfy8vKUCCTP+OJWU9obFY3corxq2fzrvBzNEsds0Rc61mCmtaa2CJo7y/iEC2noJR6yEHQhsYSz", - "VJJlKuHZVBn74s/ffvstZafirFNusOecQVb9Tc4n8E2XfePn/YYSer7xU35TdooJVRp8H0Yfi4EzVpvD", - "Urm20LJq/RbQK2Y48VdQnfuYpMNTvOxW1vpEWQ+RfbgLjSerlJf7OZZDrY6AZQcuceeEERHk9ARCPAmp", - "o/2h7xtsuYWerL5PucInwoPGDtowoKpmrP03n0UZ3ETNZo5LmIVMplpJVZhQ9TYA2OT8Vm6E8CV+9aQg", - "xiU+LYz9FtqAjD9/4uInq7Dla4D7h/8Hvs1vRLOCUBTQPwksRbP5XV7NvFYlLDX5ohDpQx4L9wKoO81n", - "Wan03U9fZHyBYyVi4l6aVrGgtrZjHBUG2IhzF/TZ/xqso/N8xbvHC1DC+hKcnV/9R29ErRQ2I5+x3Bbt", - "psjA8umrj417TyzH6FAxEeZ/+SKjlD0AmAnHawd9KrbQafCr/zVcB4/zifUn2kKb/vTDAlt3kPnti7W4", - "VZKPEZ6txUNV2E2GuOryVGHXWuQ+ET96gGWpPJsbtqWNKdyuKmxeUFf9TIwhWSQZfHWgPJ0DpYbVqrBL", - "BjMNCZYLnRxUTtg4d6XM4Yvw/ZMmaperbK4tu5zu6Qd+uhTtT1TbokzszjXMBb4ZGQEXUjYXKaiaH6EG", - "dZ9c1srFQvZZHfBrvWel08qvrutN9qkKmW/i36jmWoRa3d4rUA5vc2Qh04u7sXjv96PeXw97f+79+k//", - "cC/WiBd2MMufPzidoMJIH/PYYHDlr71XQmKT+t5RrNGzmIGxfJY7JkfN+dGyW01Ng/vsLwXXXFqgeLkR", - "sItXx999992f++s9II2tXFI8yr124mNZ7rsRt5VvD79dR9hYXE5kGRNYLHKiwZguy7GfBbN6QbZPqvHY", - "vO4LsHrROxq7H1ZL4RaTCeWKYlsN7AApJKsa5ofui3pBRFAdooxlexaJZfvwBSecUileg7RIDdS34CiZ", - "IOnRmj944QnbPLQ/RZkPsE6ghNUo03MlyH6FXkPjSl3u8tES7HiW1adtXttKB9RI6N1TC9/mImtl77N1", - "JOqZwBdYIQpvoKziXvG1PntHJWfrvC4Hzc5OsAUi1jafCGOxSyOWrHYcpL8KZZWvA7LKnx7GtTXur175", - "ULhPWzDcqrwpfui6TcIzsOp30OrA97Nf2yaE3gpuop/fUNFCNwMW/lDMzdJ1wOU6zfD5MmY/Xl2dM6v5", - "eCwSpiQTts+OeZaFWiFH52dUIlsYN+Wtk1a3/AaYsGwECS8MsPdS3Gg+tvRr6Dye+MZON+CblCxCEYOQ", - "c/Lzm2ipDzrmpTv5lforaNXZJqwRv+9Z1XOnZP6u0kcBzlkKs1xZEht+ZrxXCLdau6L+KuBArofbBRir", - "NBhfNpOmLo9SdiKo1ug6/qtuUYXA22xuhrQG1GhEmgEBlMaWas7Pb5hUvpQIVs42XreZQpYy7sAW9bLL", - "h8MG5BOBhibeBBkLGcyc7rOx0E69IVM5qllqr8/Cx88PnzMxrn1HVburIqnR1jN/AXtV7ucJrV/lIpeW", - "26jZ/Sp+wPvqbqvdrdrnLytXLrEzrn0TDMp3JYC0AgKlWsItTKgSL9y5yxIOMQzWj6jXUWEjlS6wmiwF", - "dacvw0uuPoUGy2mc0CUmGOrQb3YCPfN9/RnMob51h69+QcqJIdp4wbDLP0sy4NqEok2108a6GLlbbCLT", - "E3TqpQCMcpl6wc2PZ8u9NzZ/wZnTvuDnOjIqYl13wG6gm4DF3x4+a2LxLSc0rllhKox+6YOz3LhDN05Y", - "N8AhegZJCOBSue0J+YLxSvRPufVY7mavU9seXyqBS8l6UlkM7ndE7BQHXUCXKR0oKRBPkPj7rUTzkgSB", - "+79SaniBuBvTPi/sp6Ozz56uds1fepoNGfi0AU6X60ReQw2pJaTE1cMz+Xfs18El+QKYCLmp1QLkmuiy", - "CfdN/TCpMsGC5MvbqJP8IdEYfm2MmEhIGcg5ZCqHSln0yxrG02Du/PbweeT3scjo2bgnVVg+lLj2yWb4", - "7TemIlxhKtpFwn5+eOi0tjnPRMrL7vktzT7Oi1EmTCX3yIHzRF5MWguX+ERezOqcHkjRSD8ER067day6", - "hGjCdehSUMGb+o0l0CfqjejvNCFPEsgRvQpbQXo9rr0kCRK28oDa8M2mgzThFiSxTGwrjs5liz9Iah48", - "B9b0+VUzE8H22SlPpmys+YwCobH8htIzNhTpC/aHgd8+XF/LlFv+gv0RQNBz8HZ/v76WQyct6e59L4Ky", - "RVwCxvRmSiqrpEjQwZiDNmh6S7QyZond+dTEl4yz19zYHkKsd3ZCNgDsluSluBsoKwmNVIYPdA2mmIVn", - "Px27z060ymlTFFRFAJ/w3ASFeijSIfUowY5E3oYBYg4p/SYMVbGwUy7ZM8anwNMQ8p25vRoAiZ92g6/z", - "FrRjFALzlss+8aNiPAbdZ8eZwK98b1OreXITmc0pCylYSCzut89eYfR7dXwT9IulK0OTX7Vspfd7UDlg", - "YFqFAcAC37TrlyznxrDh/6Mhz/jiX3mWDSmvvDGdylIseolPC8dtPf4aC9w3froV7r6nPMc0DWyHCBK0", - "SNiwyeeG1LM1aE3+9sA/ZDxl/oStT6ixJNtzny+wBZPDNmoUyFmqkmIG0o0a2kUOQ2oiVjLrIfVMcTin", - "9KwsGlI19PH6yj/itk7wY2JZXWZQIaT90OTRDoOIcM3jbazMd+FQNnQjQeXONOnJdwtTmhmQKTuMwCOA", - "N7Tl25Ymu8yoJmHNeVZQTsMMHJlpDQnWgqCluFtDSNtnV/wGsJNrAikuhH7sIeHNkMQqtpOkhbFVGS7n", - "GBIvrOpp8GhcLZcBl9goCxGJzP49mtJBaCoMlresKquSN6lyQjaIYLcko3NE/F0Qvs8usAYwkjRLHD/h", - "lj07/Pb5SxxQIjOvcQIMEy/0mCdARUPHQhtLxD7BDDPtuUy/tYAs3Ug8dCLL7lcD9gHBJ1vJ89dbCKMv", - "LuNp+QQOopfoP+9dOnr0HMCN/v8DAAD//0nYDMOkyQEA", + "H4sIAAAAAAAC/+z9iXIjOXYwCr8Kfv6OaMkmKVV19dhTFY4bakk1LXctupKq255RXxLMPCQxSgI5AJIS", + "u6Mc30N8T/g9yQ2cA+RCIrloqcW3IhyeajGxnhVn/aOTqFmuJEhrOi//6GgwuZIG8D9+5OkF/KMAY0+1", + "Vtr9KVHSgrTunzzPM5FwK5Q8+LtR0v3NJFOYcfevf9Iw7rzs/P8PqvkP6FdzQLN9/Pix20nBJFrkbpLO", + "S7cg8yt2PnY7x0qOM5F8qtXDcm7pM2lBS559oqXDcuwS9Bw08x92O++Ufa0KmX6ifbxTluF6Hfeb/5xQ", + "wSbTYzXLCwv6KHGfB0C5naSpcH/i2blWOWgrHAKNeWZgeYUjNnJTMTVmiZ+OcZzPMKsY3EFSWGDGTS6t", + "4Fm26He6nbw27x8dP8D9szn7e52ChpRlwli3xOrMfXaK/xBKMmNVbpiSzE6BjYU2loG7GbegsDAzm+6x", + "eSEOXjMhz2jks27HLnLovOxwrfkCL1TDPwqhIe28/Ft5ht/K79To70DY96NWtwb0US6OeZadzj3Al25S", + "sp+urs5ZwrOMTblMM0jZaIGHuQEtIeuJGZ+A6fFcMIOItXqVCbcwUXrh/g2ymLmtORzTKqttzVgt5MRt", + "LeV2I3pFtn/ihjmUUoVOYMsJcOQljfjY7VhdSLfddPUurnQBTIzx7G6HbCwgS9ktN6wcxdICHCIY8Tuw", + "TMyENe46/AlHSmXAEYY2gli4FWbFDIzls5wJyT5IccdmItHKQKJkirONlZ5x23nZEdL+6UU1vZAWJoAk", + "TX+pbpvnYuBgGLnuJZSxJkzYreBW3umWiHTiAbgDzZ6D7iGW5XyRKZ6ysdJsGPY9ZODmNau4lRYaudNg", + "FrnRX3mW9ZJMJTcsfOco1kGQkFm7S56JLBO1+/UnlMVsRLfp1qNFRAQv3ucgj87PWPnVWRoWmTk2BCnT", + "yvGbPehP+myYa5WAMY5FDLtsaPkNXCYaQJqpssP92g4qitDEB6Pru5vzvzOROoY2FqDZWKtZC52Gr2ci", + "TTO45RqiixrLbRG5VeQIQYgz+oolKq3PUuLiEnrVDrJ0r+V63QZM12CcQ7dLy5Ob1S0en5yzi0I6Wurj", + "J1eaJ8A05BqMuyI5wbv5Dz7nlziOWJxx3zJu8Uc3Ghm8JOzrs9eO4g0rDDC3guQzN1GipPsZhYDmdgqa", + "2SmXzEh+A4OEG2QJiAs47/FUqxmwE5hfKZUZdq6VVYnK2K3QwIi6+9cywkaz7LXmM9hCKOFpxvhxlzns", + "0zNlLAmghuhZWkJlxUy+I8xfWeSvoFVvxA2kjD5kRCPsVtipIBGXCRnFg25nXEgUR+/4DFbnrkEifOju", + "F7pMaQaz3C4YYSYyBi6VXMxUYcqPTRSF3W62OI37LHIW+jp+GvrtLI3jHv13jRyjuyt0tjr8w8Ubd2R3", + "9sBG/GxjkcUIdYnCGtdc2yct17iSbhPeMVJrqhdLTHuVExKzZxkfQYaAwu0jUVmkQOKB3CxkwhJeGIjz", + "u5zroIBm2ftx5+XfthLmFUf4+NuKgMEpG5tBTMKt4F9Nf+UyayS3lhHlNpnyS5XN4QJMkdk2dYol9Ckz", + "7lvGrXWozTRwlBOcOUIV7gpVYRM1gy2VKZr1ocpUyzm+6VWtepW/+AGCc6Dxzp5Qx1oHoN3VrYB9DY0r", + "dqJ27St8He5liRN6ZJ+DTJVmYz4T2aLv5F1aJKANk+7GMwfTXKu5SEH3TA6JGIuEWW5ukAsaJqRVzE6F", + "YQbsSwbuIZtrYYDNuRZcWuM4pYZAXInKMp4bCANBaDYHbZxMGRXJDVi2N3/ODtj8+/0u4zJlXC4c158w", + "qSxL1BxlKfEqd7knygmit9YfqMvyjAvJ3h9f7DNhnFqhtMNSbthQOQVgSPI7oMk0EKjDg3Bn8+fN//ze", + "IUWhpbEic5gxAbDu7dvt4JRx4t5V+0WtkJiPsVxbR1QxnrOiA+OjdeC0vNWFEB9roMNvUSN0D98xF1mh", + "S/X39OLi/cXg+Oj86vino8GHd5fv3/xy9OOb0+F+nx2NnHLmBpkicUryTnrp1fI52NBPM3xJZ9ZMg7ti", + "ZLWF4aMM3A/4Uu+zod9p7GvpD7VnANiwugy366FjLaqw1bhUpIhJNL6uUjiBAvo7w265sGxUpBOwfTbk", + "Iy5TJSEdvvSfsITLBDL33vZiNOcTYJLPxQQ5Ir/lC6fB93DNJr75YzueRkdy10ib7HQ75WJRlHJ0F31n", + "eChzY8TE3UlNuWHvc/6PArpOMx4XJPlNkTuqYI7Hmp6GMWiQCcRBegsjIywMpspExOZPipTa8hZup6DB", + "3yeRvJMWeBHp2vlzbqeRFxS30+3nZ/93AbrURuEuyYo0uuyKLlHjlfd47aT5sZISEttuq4E7b+JLMuEI", + "iUguKYxVM9Ds8uTnLjvP+OJWi8nUdtl5kedgAfS+e8S4uSFlxDLxgfMrjC4V8stcq7sFmbGEYb+83drI", + "4yZ1+4uh2jeFYlWhSPOBv7Wn1CPS/ESYZFd0SssxkFb2hQ2Iws65oFcVfi1mM0gFt5AtWK4hgdRR0bB2", + "7mGwlhr3BDJWA589CrrtogmvXNA3JXgtzlao8UnR9p6ab7XbJeW3cZLHNzpWCLqV3XEGxvAJDBJVxCiU", + "nu1ubkeC/mOnjWZ84RQElLyRdUGgjSoVmv4WN3Bo4Cb2yP91ulieE6QTgGxIbGKQZMo4JQq/Is4hpLAC", + "cZj+qIzTzoqcqHuQTLmcoPKDtjFRzJgG1E8hJR0HDGrvTldHKY1cxioNLFW3khlVXy1RRZa694CHMZ9w", + "IQ0Z9STcsrBufQuo0g1flr+xVDhNUod7ZXkxy0kJpLMqaeHODko1zR842Fb970jBlSq3Zxe5cArewjtL", + "mJkW1h1hv6nB1a+y0+0s31T9T7gntOUs7WgzJdbxeBndSgxYR5BKGpUBuvpaTR4j+tbdiPvYK9JKM8fW", + "isnU1q2wcJdATkhFJtfTmbCVuLlVTghZIROLSE88w5B4ScUYlUxLHNRMeQ6mX9qB/fpH52fHnIDh/9L3", + "7xWeZWbfoZZ7nRqWwRyyLnN32mVcTww9FdFUNEADUjV3ue2rqXb4uFeerfylPjXNmQkJXW9J7fqjDAqd", + "Rdbxhmf3pvAeWfd08ZoajWRcA+P4gIobj6Py0p3/wcJyGQu+ycp2WUl35Yn2CUVlFCa72lNx5DHxlc7H", + "7rK3wBFFhOKzrKR1rifFzM3MEgU6odcFndX02Tk5Y5iS2cK9uaRHZU/tbYTb8F+svl+XLNZEXxHjVMOD", + "0bD4195/FT9C9ELq3nrjS1whLmeRzcS9COEW3SA255l7YfPsli8MuyaDzHXnQbcY9Zes7uVNzT3y+S6q", + "YpAtTpMVZwmzU3Tlabht7vERNtYwRwVGvbWdvXRTdDtIW6smj2LGZU8DT5HTk4Tyooh0umWxeotKTypM", + "nvEFE7bPXqvyVxJxe/sk5Lq1YJRAoXUC5Z5EaYqIKOt6JQzG4g6FFe3PKxBdhmaH686HMBLZ0Es2Ump2", + "3XGiv/bbnpBOMM6EgX12tcjBf3zHhBd4pY/vukOSbQPPdBe6yhp/W2GOb9Rka6UlUxPSSCqtIVOTbnm/", + "Qo5V9V+3XMsuA5v09/ufQRKHg32TwxvlcKYmTy+FG/D4smTwTqJ0jahqVbLdHF2Wc2Pw8adVMZmyQo5F", + "ZtHJguyWIiL63rA+RJ+KKrwxsqEy+Sc5c+854OkrxrOMoX+ELUtM41Rl4Jo5GdVnl0CmKpNDUrqmx0WW", + "MYcTUcbyRLz9NTLeZfCsQmezSZkA0t2C5TWwaGVH/iPP4cLTFYmuivcLLHGmpLDuBSedqMgyd6u9ID29", + "xYSdBecACSvL9QRslyJS6H3jPRn41MtVMnXUfTsVPkaGdqKSpNDuvR150OBUUUeFgzL+Wg+HqvlgaDNx", + "/UfxFHTrrKlKCFb0XW3+LnMKBbqugCfT2umi60g+Hxj4x+oqb5VUVklvIxAycY9wdExW10Vxq0lQybr0", + "mdsXpOUGrMp7iB71kdFL2IJ7evNL670E80w9/MxTGK1TsxZF74O+is4fcNNPVFtiz1hUjryhqzqnCQfl", + "zPLR/roVg1zYgrKvcITTUNbG7mjIYM4leVanwhAqvyLHkvtgjNE9JUwcLeBvRDrd0oJUfgv2VumbmjFy", + "PVOoAat+sc0jVyi4RnzVVYEdjaxazUFyh6QzsBy1Aw+5hcNmInRvD9EMvJGnpPxVrQnimlqIJag5n5Fz", + "YPiU9zi3yaYhXm+de5UmKrzqOOLcCJm2qSrhQH00JQdzZizUz4ux0onimWufDSlcc8BzMXzJfsb/YEfn", + "Z8FeuOf4jJ4DWazpj70JSNCoboWdsyHcWZAOEYYvmZB/J6eN30/5W58NM5XwbOCDUocvmVkYCzPm/8B0", + "IaWDGM+UnBiRQmO7TZtlmne6nWr/7qewUMfx1tpCUU03oEo7skWUlE34EKQZIYPjVkQHB55ODkhUnJ00", + "4B1oYYm2EPhrKOYna/OfwMkG034Iq4sVgsGY2imNZDOeO+jecp1iUElPeExxu3esTRW2jJ0hIcN+4Vnh", + "VB6Nyk+wMZOWx0aFZTO+YCNgXC7Yf1y+f4cqUkPrWTkMJoxQCsFxJpKbjY+lAl9M7tOgSfDcFk7Lmwte", + "ISFyuyq2cvPrSFQbeegLKXqmb++k1ndS7eoHCNknfC21w+aR30wGMkisisQEH19esvAry7mdBhs7nt3x", + "1wwVrRaVYhILln/7hlk+aQT0Ls3mAFbkOWiMFSdG9eOHq6v377rsqMtOzn5p0WGiyvwvwgj0Djiu51O5", + "WhbuMqvRIR+d/i42N9xiVM9dL1FKp0Jy2zyVO4u7xVzcQWbilrzFmokX9594CQ/vOm6lbgVtgtDaZ1IN", + "BX+GxUaGdwOLkeI6/RrYXTjPN2a3FbO7gcWnYXUNuDwyo3OHWLnAn2FBzoRK+/zZ4zHdLTGgU7fFLvuR", + "Jzcm54l7tce50D24aeB7aJ+fYvRFUhiyw1PK0gIxJtdgTAt32p7b4uTrue3Zu/MPV112dfqfV0cXp+08", + "d1kdhAcwmMtEqyy7BGszSDeyGoNfM0Ofe4YT3k18bKtPcmVELfUUIwaEnHS/bPa0ehvfGNVWjIqgPvCI", + "8Wl4VguwHpl7OfY0iCghtDq765WY7hP2KKK98gO6ryZgHNJvo5bgeovW9RaPvZ63x9yDf9Jam9RRFbu8", + "1xghb1avEFmImzycILCabU6iYvfWWGrxKEst57oRhpSg84f2G1q94bWs+Y2Yg1NDN0RZs0zMgc0F3Fbh", + "Zkuh0+4dPy6ywLu/M+xXGF1cHZc2nHdwo/b77Cf/nZLZ4hX6OgNDHyuNs2RgDKPM3U8dAhu7jm8suZUl", + "O6wYOKz4BOHbraDZPRI2WO4bYbArZ2mPhF3nGXhTEsqqf6DPLhvG+zJY03SZUYwzq7k0SF7B/j3KRM4S", + "LpFIMBTQG1HL2HIMGB9WWxruZCzf4sI3B82vcod40Py2LKIKno9BZbRYOe7nYBHfQuV35xKfJGB+HYAe", + "nVd8QYHz9+VKr3zFjhA1r6nKBaWotHHFHT1yW6Z7vSUv+0mNe7TwnCufg1O7I6uCp8dRRaaM7bMr1BWt", + "XgS26R0CqVZ5DikrpBVZcO4PSn7sXpdaizmYPrvSwC16EITs5VpN3PM8lFjCiGULbM/z64FIM4z8mMAg", + "4wtV2PBG2WfcsEJqyASKAFrZTkFux8D8Hh/Kvdpu+Bv7amVfATvqMu0J2ddaCG3iX008astmucC/l9EK", + "1cHQqZYgEQ3KXJTSoVt6R8Mv/bofdGnU5hvanGnhr+JMCvuai2wjMwi8jVJh3NNiBD4LJxO/034/NaUt", + "bf4bnW2kMwewwRiv7OnJLAae3YjMWMjbUXIGdqowm73EQx/PZCEnUzAd1dtkKd6mb8AeFVYdWcuT6RY2", + "WdzE5tNeBAG3FTlFZWuDtjT0AOORhJmWFlm4m/LCWIqfyKpHDtmQsPqG6bN3io0LTXWjloX0rcgyL4DL", + "pFpP25+DhGO39o2ON9JxCfhPRsytgHoSsdlAbF9yol/9deDpwAlQogOH4YEA2C1oYOihKfIyvMWXsBgX", + "WbZAMat0KNrWJMi65I2s+IjC9wIerIovnSrCMviyDnJKjCBYBtOivIcJzzHeh/T746YajmVpDFg0pyyF", + "GwaLitU8uXGzeVWFjTWYaTBSCMNyJaT9rHzmG4/Zmcd8UvbyENYSaHVbowDWY1x6/jPLbwCprJbuXfoX", + "mqS0zf2u8IbYJjffT1XQs9VQmIMWKhUJM+W3wdoRfL5zHxSzHQVW8zwSES4d4hsNbqTBtSB4ZBKMQWc3", + "CsxlJILiR27gTy96IBOVQsrO3/1lSwQtr220sLBRS3drrznjO5JQZ2kGGyMjgjQTaYjcXoqL4OyHw8OZ", + "Yf8oBFhPd2RTl4oJ2RtnYjK1zJe1xeD7Lb1tfumH0tuSH/wbha1SWN2o+IS05fHujeKpkJO1T8NVBMxo", + "VHjF+gIWZ+NGXRB32zzTwNOFux+Pexj55DRHjs9c9waWiuVaKM2G4ex+iiHOUfcUC7vfZcNCZ8MuG4a8", + "KPfvMp1pSDlXQw0+i9pdwLBWMuIVG0aQETPxcq6pRj7LVV5kiCWYRMQtS7iBbatNPBKxtILom3zaSD0e", + "Q5/+FboeSI8cJ0QFbzbBrE6AYcRyaiOG2UwihZ9roKPaj/HQ63chVQtTVWu/eZOWBPvy5enFxeD4/bt3", + "p8dXZ+/fDS5OX3+4PD3Zve67YxeRuu/owQpPRKXFREiOFqglNtLqvHKr1rhEfGF/0v6F//RqkUPNHIAr", + "rKT91jNZfMbvz1LdSgpHNUxIrKXITnyaZZe9BptMu+w/f7roMqoQ1GWXdpGBmYJ7257NsN7AW0gF77LX", + "yo25gjt75V62XVaj7m5Vo67L3nIpxrjDcw1jWuO9nYImNjlTeotC241S9jWs6FYIuTbeyF9h6H6zrZQJ", + "4MPyFS3Jck/Pfuu7/sZ4NzJeD7Sn57grcHlkXhsyoDeWYSlTpVFPaNZ/87cR5T3TWvbcLvuuZ96tFn/3", + "1xIy7PpuJb8nR7atbO4sfNPHGjxCptgMCTNYUf0pTPNM9+Z5xnO3nGvj+FCuwUlrYkhY4CB6XcIMNFAl", + "v3WUg9ZALyqM368pMupfxMIMcZIhv01LGxDv1OGGhcrNbnJsZEEi7y+nV112/v7yqqXQvzJ2ENhPHGYj", + "lS5QtLhZDs4/XJWPtK47HJ9zkfFRBi2ijI4Wx9f3JB4zzLUewVj5YkZhFIIBD4YKeu2y8Rp1AY8ktbus", + "kOIfBTS6T1Runm8S+uES2qNxt8nCKoazwhC2E97UBWcH6e3b5mhIQMyrZ+Jrt+ma6bL8ENHfAcX7DGhY", + "F/2OiJUha5i8hJ9HGajdwjdtYAttgO7rU6gDy5B5ZH3AYWcUSB4SDTSu2CmWXRv7kmbs7dnbUyrZ80lV", + "Ar+zuk6wjazzCo4KsmOdNjMTszYeXR46TFheFQlOdzMHUzvLumy5CeO3t+IXL4keqXtamKbF3hCdq1bt", + "4v3PXVa229y/r8AsOxUEQlwrGc/5BI41N9M1ltOcT+A7p5LKFDToMpwuoXFsj0t23Tm67bJLyfP/33Un", + "BBXss9spFXasjDZhsLAGsrG7Bax+nTlhyC5CaxavmYYV/A68jtWt5RDUK02HkkPYwHNI2NsPVUqGfXYc", + "Mip9GcmwtaGbfsgCx3biG6TTUdNtjaVugodK52VIfJPMrZIZo5Q9bjyhVI5CZDen3ZpKWVVtmzqPDxH0", + "NcT/tAWxqq4qHOmInlK2nfw386n2qlZuFxsAcKJmx1QV443i6Rb+nZP3bxsDQiFQd99uwn5azohzoSq/", + "ZeHPx6Lz6KG+Efx6gk/VbOALpKBr5Mlpvx1Kj+0SSfNBeW8RTkERabNQbJBRgA1VhRCSheAabn2lthUS", + "GLv76GKvCSvmCOJleUwhZXvunYpQwyqP+332wQAbWkPV126b4T2RbJ7lLkqNk23URN5g5sm2RRYoT6Wl", + "yMIzfy3+kY4sDfOgqlACC3oOWC4tzDQVY7RTVYbDuTAFx06zI5EJu+izU55MGwMoco/sdM96flV3aP3p", + "mMq3mITteEgztemJ+YfHZocjmytXF7PCE2cDt/aO31zue9Qu01HPQeMFyATYlZgBNsQ9Oj/7tEJs+Xjf", + "5Nd2uOcu7BNj3pP4lnyI5epFniylgzYQGqTVi5W40D3fKOEQxUyDHbMcNJaB3o8mj9ZvdZCC5SIzu2fL", + "BnKqXRzj1moxKiyYDZSHR1qlvSlPBxoSp64ImRd2PUo3LslXU0ogpagHLNWIkwSXA8bIdX0/QyeohOcP", + "x28u4yiP6kIkwba+rkmUDsYefAU7WO05pQtvIkTIv7ncj4v+FZz01qYdqz+HSlD496ppReOKymLT0deR", + "iDUtjwKvovcYtm5OX17OZ1o6sN9LlUi8hRKU5BvFxRv3jDKWeTVvXGTsnAv3zHlzfP6lygt/rm9yYoOc", + "SPKnFg91SDyyWMiS/J5s2ON0hdKE0Q9lw77oUpT7iLSaPtD/m+PzquCmGAcnSGsB+kGc2biXF+VArM67", + "VVUEqdJ2lnny/i1zH0S4Zm2dtlaBMgXdsu0L/HHbjb/yApu6BpNLwhdAKlPDrsRMyEnvKMvUbY9c+PEq", + "EOJ3aC+PyjXwlg1R/Slm/lHwpjyo5t4U/lKfEUN03RGY0mwuUlDhp5Zq7k8r9OpbczzMm+EeX+7hQjHl", + "7N5Cb7OkU3zzK796uS8b8rIw/HOY8Mq9fxNnG8SZ4k/+0G7A4gs3zqGOWaHz12Kae1cmpW5HsfUOKL41", + "7DL9Ir94F1rk7/fZMddaAPYGKRsBjKmXppDItUZYSt8y3w7Dt1cLbTvqlrjlhjWfljss3dY3HrGeR1TA", + "emJOEYPLbh69+0l1GbCcvti1m9E7uGXrOxoxboyYSJ9ihCSxoalRzrVTi9vPc44frB4JO5kUI/p7rY3P", + "K5+cRDuINDQyLQWpd+1W9Gg9iT6tZ7XCAaserS8QRUXWNK8Ki7YmhfX+ltDSGR3BLY64si3SkoGdTfkc", + "2EjZKcm5Mo7INHGn4XIpPdDCsNr05InBNikYP8zOZAq504apYUI95/AV48wIOcmAuS+oaALFRqUKqFHl", + "CGWlsJ8yxuObm2ZXefCJXDVXfPQ+B7nG6SjhtlRwLB+5x6HnJxgogYNJt/GVkEJu6JWiPyDuI17TOLNP", + "YcQmhLLzRikwYarsUl+o2G0htOYzqlFLdFMmqdeXmjmkNcWppApEP6dXxvJL++xYSVPMQLt3KKXPLulp", + "2Nsq9DOaYskli3UIhXW6GkdLvuDZTrmoj6WVNaH8TSlbT4SWjwaE15+U+O6hk+Eu45rTVVuElaNhTHby", + "pIvEoCRQlopc7KpkxMO5gryTcJstyqX46Ek0DytsFjH/UFZU5nmP+6bUSpGhxDcTVWPCVDXTWfscjxUF", + "dgl6LpKNUaozLvkEUizJLBJgcCcsFkqFuxxL32QLpzM4rQWxyjfcoNBbh03cKt2rUt/MtLCpupX7LFXI", + "Gn27wDrb/D//639TMGm1Cq5rKCAV9MzHnOMTuDcRc+gVua+WTb0vU7UtF6RWfw/lg5Hb/MYIWxmhR6ZP", + "EGzaBpfdCz/jXptln5eOUVZ8Zqd3wmI4OyKse0HyDHUEbG9w51SBMu2+kCnoDBuCBssU0Zwuax0mUy4l", + "ZKieIF1QjDYRJLFFu6B29JkYQ7JInIY+5QaqqNfSs8uEJO1lD58eZebgPrmAzk5wo9qHjMeoCGeO1ZTe", + "Yuk+GyLRFvmQzYBL45vo08FT4e6F9DaBCRfaaUSorXE2BZ7Z6aLsxok13vps6P87TMhZrmEuVGGyRTmm", + "sUKTeQ0nfA6D+IYCJMpKej5ml2yHZfE+hLKlEtJWO1i+YrIqaNmGKFTY0j3hKvNCACvVgzZqBnZaq05n", + "yqdVSUt0nZ1ux99Dp9vxJ4oytTxqlDg7WYmRpivos6NRlfwZuxu3GCvy1Wqf0WsSTiFmmZJuaFl7j1PL", + "gPOzk5YEEH+Bkkc9MVpNNJ81uwv6Y4T79G1wsSyxKGZOnZ8V1oJ2/6J2rT1ysfV4Lobb1Fit76nrqWId", + "K0JB817NfhZZtqZ24hshiztGW2Lv37/t3Ygsw7KoKPewpFOV7yHLdrS/vO2zS9/DF126w4MU5gc3MzMZ", + "hjeRQzMuK3LAqUtW5Nf0QmMGM6UXJUDJnBDiYrx9voxeN8XIz4l147kt2Z0pcndRZvu0j0eSyCvX/U0g", + "twtkvKyBUrOBQ4mnFMhxsOwuj90+l8Rx8xDtDRgSJY3VXMQo8NdpkxYgESnZCgIp9tlQKglBXEwyNeLZ", + "KrW8YsMZzJKaWEomWhV5+BKhj9gxFfYVGyZ5YcAO2QGOU3oxyFUmkgUZF959eHt0QH/opVrMQSLtVuxZ", + "Sb9lw1SGsQZTLtkP/UPvH0tFWjZX8n27dJFQ4tZQqRke7eWQZUJCU8C4w2Im3CxxsoX2SX+odtnSyno2", + "GGuAwc0o0hhLA4Q+2/5KhGQ/ix9DY7F6sITbXJeloDFbvAxYGbrZX74belITsga67wx7C7PemRwrlhaz", + "vM+OjClm4CDxAtehKkfid+izk2CoCRmVGpKMixm2ZkicAhJa8pgZzzLvh8SYd84y9+xCqA2ssjwb3IyG", + "2FjCWIejDvx043RYB3K3FCp+bMp1Si0esVywh6ZnIwEJ67DjVB0Dd1Ye0PjqnvVW1jVyr28twrjcLw8G", + "xTu8T8Mujt4SFj0AHE9zC5s0Hy8Mg+ITn4N+bFFEjtVsFp+NYYyJT8Nsitu9Gb9jz35wWr423ZqsaHzW", + "ku5sTBSkF2DwXcAMWBI28V15MO+ZAvfNpZI9bUyXjUUG9C/UbaczmLn/3O+zK6el+vop+XRhRFJxv7p6", + "6NC8MKjcxZGorYtePrDc3JgYnuasUjJGWBEbT9kzYHt4Sr/UTM1q/Z4JYw3dvZuSfBdL2lIDVYdXbgv0", + "whgy7xk5neV2sQ4pvQHMfXvM8THALfsBw3+EU4sUG6kCXToktRDZEVmFBar7u6ti4/aJFM7vzmiOH8pb", + "5VrzBSktYjIBPdhEAP672lN0G1L0TSBl6jjZ8Pj8w0v2zmny7n8cQbwc+uoCNdkSgXvY49YEViLaVBlg", + "PMsUVQcofVK1wkR+31YxIefqhhTmSrfus/dj65836EPjhg3rOxmyvdo0nohqmfug9zGIIuGSpWI8Bl3v", + "44uDEtqm/9nd6VwkVsz67O029N+4t7Z6svW7I35XsohtVTJEqN20saPSKeghQvFum6gKpcCKbrY93B/C", + "NzdRwloZsD3TbUrRVa60RXdPAqKH6GZY1kzX62zp9ZIbZMB2TzZviiXMLqtdNNxF3c6IJzdOkZXpwP8l", + "PIRvlb4B7f4w5RrS6r+xcldUQwy7Dh0/jukpIcAcKzkWk/vY6UK9gaqNiO/5jCmNQk7oGRy8jq2PBJ7b", + "ZLp73NvyWRb+JKvFV45pBWZUNodgJWGqsImaAZViqbUpfMJ9UI9G8osepGAxFbO05gVni0OfXKu7BaoE", + "ZYvHsE+jyEvyVJukFdz15IVle5madNkt17JLhUb3cVeOBRSTqWVwl0Duo2Nof1ar7An3dzRxioh/mlGD", + "aMP4hAtpbL1SR5eZIpk6ASMkaQMJzzITnNErlijfC9MX66uajj/dST5QVlS5VDBW7iWZSG5Ml93AIlW3", + "0r2IsK3xPm4uVNN6uo3Va5MflAVfQiWSPkVfTZ4SCc8xaLqkjHAx9Ygbqle4lPn85vicLqlWG/8Jdxma", + "KoyaZexDofpaLXvTZz+JyZTNVVbM4BVT47ETnymMeZFZKruY256QtHsyzD3dzkNI2S9vveG+ohZV2J4a", + "9/xDA20fVHqI/JO9YOclu6+j+o9rpGTLjnaTNjQoZGWiaTVoQnXZQytEMmioGE7MBAXUBwt9P7XyOV6O", + "pX12Jlm9BqRvkO4DXAhiL5maCetDv4TxJpI9z8xvpwotGzT5PsuAz0PHz7CiGo+90cOt5Rc3DO54Yr0T", + "KinlNSo9jonpAmh/R1fHP9WqVLbtxvhIMuxp7B5YBC02/OPjcB/jdZhUPZW/am5Og3W8Ff0x6F1yehc5", + "hK6ULzTElGapMNRiuRo6F5x212ULVbBZQYWEU9zCXZ6JRFg2dAcZuhmGCPxhQwEvLbVbIdl9kKvqVJpE", + "0MwLkz67XAV8n70Pz7Kg49zAorzr5Yved1ALGhLarj3xG7AvGVbmvwWsz0/efO/lR5+m8VmsKuvW2j11", + "vS2py7wOtd9nv1J+7dDvaNitHJk1HHLgcHjkSeMlYhPaPwPqv2JcLsgjpnwEpTv4eNxnZd+par49r5d0", + "QxgjtWLt1sUbKQ7DiieSwTXCCRFRRuCuGX2ZVvXZUXUkD6hQCYM26U/Ckgy4JvqyccjSAYa+i0qtbtYe", + "NdPKqH2/Z4z75Eiz1RwOyaeg4RXmLGfq1jBeWDXj1seNuQcpelR5/ZqajCXiofHH2zZ0plWT/9jtwJ0T", + "P7vOdIqjwizbEFxjxG5k91rpW66RIalxeS81mFlFbMKCdnSQgrFYL9ABcCl0Fqsj1273JaML8BjLCpnh", + "a9mznGxRYouDYxfVCzIjEGNyQ2vr4dQe+kEmNHiuGxaIhPhtncsHnklvIqc5T7mcxHFA2SzfFWzvr96c", + "7w66lVG7gc8NP0A90d9XePLdQ/xGgC/w6egQpAofrUDA3OpNjHjf4CJ99hPa/hmMx07E7YVNWr5w7wHH", + "kOZY3g8kfrYJ5luLpGPv9g4qC5y6N9OutEHlB8mwM8Ie4SkLDvVqWxi+5f0oxnufKCKEOm6sgmIGxnjF", + "fdVSEw82KVcb0NQznhtqgIYxBwdjkQFJIe81O3AkK41Q8iDXyv18kAqTZ3zBnGB4VeYR+AmxWLhTMXx4", + "vcN4boUvV1RvdNzcCRpr6jNF7R7xJrHvcy9dq7tcbgvbb0R+qHwQ7p9KVGpb/4PvwYwX4K7acWB/Ce4/", + "/PnDh6KYDcYZnxiCj7uizX7gcOYAwphp6ti9G9+qwoCvZr5jHOqosDZWEAWnZPQrmXZJqKMErt1TBmPb", + "6Xa0U2LcVkWaZsGSRe5yR9FROOGTt6Wq65W3oeE3/slfW9U9kTvdDkbm4CfRBaYqSwc3sDCx46UU7ep+", + "dudz39ZbX9KsNefBaujrkiNAFrMBveJpOeRKnZfPlin9HeY2ooFQzMATVg7ejhnWXbWM3q2e4j9ZopQT", + "qLyqBUA3lisK1ozOFKmn/F/3mWkJXe86buoWJM1HiuvUF0rYtSJltDTtsReySZic6tL6LJ/Nsb1u0uhm", + "qc2pPqpsQfcw1yd+Fo+7DspwB0lh0f+Rc+07IyCr9+optcwibYIenZ7FX8tqlpwy48l3SDJSk72GWoPh", + "aHcJ+IJzH/ixOdd8Bha06V/LU//OVLL8nUY2CjajJTto5rlWc5G2RBohKc8cz9ikyqwyrI/dTqr5ZLvh", + "J5pPlkfP1By2G/1WzWF5NMYHODaxafC5+/BnWNTGko1u08BL/Ko+DOwgKbRRGzX/S7DH+GF9dAawUWO8", + "dB95FK7FJK1GxAVvxQqGNeRwDb6N+6aZQ1ui6irLq2nAtnHycJAY564m3XBMJyeu4M6W17NM5fE+C93O", + "sQZu4QRbbSi9uJ/wnKkU1mgaaZiduQ/ZnkowFgRP2WUYM/mvP/yw32cnJCxQFvzrDz+gEsetewV1Xnb+", + "n78d9v71tz++7774+E/xpFg7jSQXjIzKHLepNuE+RHsEHn1pkYP+P292gbqVYpd5AhlYOOd2er973HCE", + "sPEUl3n8jV9AgrJvcr/dx9ydZyvJOzosUjsJO8ryKZfFDLRImNJsusinIJfhz3u/H/X+etj7c++3f/mn", + "7eq5nJD6ueU7b6kIHFqk2gVuUO3pu6qcTUvlHmz5PdDcwuYp/ddMY4NxyX76ne3N+MKJH1lkGRNjtMuk", + "YCHBYJD96KK3Io0h1PJq+Nna/UevdlkCPY3C7dhmi7JdKtmkdUdjecE9Pup66OGyqnLiPlmpajgCewsg", + "w0acou0j8Lm2Hnsd/2c8U2Xis8VSFTMhxcxt9DAGk7U9uH3KG4bRsfDlyt6Cs9SRlga6IbeXWRlCb2ZK", + "2em/k50cLbVo0g2mOqdxuzOMuPEF+3FB5C8ZyIk/B7+jczw7PDw8rJ3rh+jBHvLKcEfY6ZER55TvNdZX", + "YpkwqFb+7a7LFr/VVfqcC21K2IUWGNRPwG1igjFbb52q53VHxi3LgBvLnlOXfjTzlDtd3nI9ILIMl3qO", + "l1f9x/Jp1v5IsGzgsINrxKPKpsWMy14mboD9CL8LrE2r51BhM0L4li/oIExIY4Fjo5VMSODeJZurzJuW", + "fsX4IrcaGgnMIAc9MDBBTCNygHyARDaYGbRpi4lUzRpXtYjzxueNI/2wI12WRXdwXysQPKNdrFLDRvpc", + "OWfzFXvY/owtt4S4RfvCAqj+vnyoKrKJ9g2yt7Q99qyx12ebg3jahHtphtvWILY08Tqzyym95c4zvrhF", + "LrytMIh3oKu9DqspMcktEl+ftthLqCXNwX/wOad/UpZcNTc9M/GPU24YTzDUyyr2HTYr6bLvfGb8d/S6", + "/M67J75jc66FE7f+6TjLM3jJrjv8lgtLDR8myqq976bW5ublwQHQN/1Ezb7bf8U02EJLVvscc3r39l9d", + "d2Khd1SMjYpyJA08/NMKHr4lbu3PiE8YMauXsSrVayYM+9Nhg8N/3+Dvm3ENL39LfDC44R3RIbRMXMKC", + "6nSrpvaA5Uv5LNgg2KOw05uq+/G9meOtlvymV9+JFJVPkKziAHFze5R+vk9sJAUd2c9lCGKlzsVl/GL9", + "YBFLbqpiRYjLyXzA0pazFYjw62ICoH7bkDI/BDvjxb0BjaQ1v0AMQV6LDM7kWK3yI2EGqdDrd4XyC931", + "5XOupZWmai3u6UT5DBUSH8obaq6VKU0pt9DztX9X802ifMcdi163I2F9ZnqXXXdSfXune+7/rjvuYXPd", + "6enbnu65/7vuxONG49GpP3IDjeTDsQjBB6s3sfWrOOisq0gifofBaGEhgieXPuwUf+77OqJhGwLMFhGn", + "IXqYo15fW6wb8KAGQ3/pbehEocUtyY6vSx8NI99jWyfnbdCPo0sNe/tsiYf3hWW51H2BuhuWxM1iPhdw", + "kUPdBnZ8cXp0ddrpdn69OMP/PTl9c4r/uDh9d/T2dIu8Pkrpa1VYsP3cir89Dt8T4f4r5KwW0teuL8v9", + "lG5VH0cXeox4vv0zxc1jKGSVdsLLxDWeMcvvlFSzxUtMaqXiEb7HWTW7sRr4zKcJDLFpGTrYlJ6hZqFk", + "CWvUIdxWRpCpW7ZHFm7aEpm+fUTSsP0ehl2mYcJ1is59DANQLC9GmcB8ZGH77JhnGehe9Ud/ARiY9P7y", + "ih2Uuz/wP4Vs2jJ1MTighaGbfcUMABsu7aV8j2IzYjPlOfTZLzwTadlKIMHNhJyUesyqMOUFh4SfxBcq", + "wr51GIAZPKKoI6UVxEngz3ieOzRzOkYuBm6tDfEDR7lw10Mo1Q1R2AOMkR4E4b92Bh9WfelGkLZSTpbm", + "Ax+mtGmOND+mD+tj3fG2HX5SflvOQLFIA68NrZ+AvkUNaXl8pibbjX6jJmFsLd6JHIAbZjirvkdnSGwe", + "dEdsO8vPsIjNQRb4shrZ1tORu6JRYa/bycQcBnMBt1sC+Y2Ywy8CbpcgXU2zNbzDTKtA9+Fctak2HvMt", + "DTmpjVieTUhhB15H3mqyMynsa/x+eSoNfpWd5rsIozZMuvN8q3PVQ6a3meqy/D7MVC9huF0v57M0g+XR", + "jjsKOdnumvw8b2hM85KW2spu210aP16dwzdR3r1FdafbbPi4WxvNMDrSPe6effrCjEu9pLZumNTkBaut", + "gXbvvFROk+Q79OEoRyme7lLwPIyrFe3duSDy6hw73GNL5dLuStm6XSsC1lLEtkO2WGmy7kqNil3Lf/j0", + "bfeuWLxD3Z/U24/djpKwfTrDsnT92N1lWE2kbzkwxgF2HVqn+93GRljYbhNUvHTLcTG83mFonLnsMEFF", + "kTsMWsL4HUY2sHyXbS5zq13GBl61+3p11nAvgN5nhrg6uvvgUgvdfWhE49xykha9ZLfRq9rgbuNXFKx7", + "Dr8HH2hRQbcc3XgPbstql15v2w9bVuC3HBl9Sew49p5Lt712txweFZP3rXhJ3S3eCGPRtBcxg2nNF0yN", + "I0Y1IcnGiwmnVDCjv21hjNJwHfFGl2I6Uts0U5PlWgU8zzNvfF4bp77clWpS+jEs3NnWLkIt3U6uxMz3", + "4it3RL0KKR9/Wwt4i3OwvnTMpodhHec+hvaifFEsOwG2De4NoXP3D+ptm2HrYN6VGMrd4l8eMQ4Egwof", + "GAGSCmO5TKDhFvzhqeM+3J53ivt4eDCEt91XkQ/un1zapVuMm/M3oWcVWBIwjFl1LzTddqad0PX+kYkp", + "GDvYFGFZSyEKfqVNAYrdjtHJpomp4N/Wcy57I8MC3dopYjf0/qbOl3ZwV/+FCuez9z8HgzWs8nV1sxFr", + "z6iRBpjgb+1v9rWqm+hZzrlNpj748X4Qb4t+PGmPeiwZxfMXh7vHQJ60xj722dk4JBl2WWF8duFUTKZg", + "bFVdmIYErqgB0ccLWe+9+tNh9/vD7vMfus8Of4tvEa/Wm/E2wWvsY6M0jB3voNQw8TsQCy6rlzglpAx7", + "PdCAxxSGUSpenNP4HLMq02o1tLZanUrghvw7XyS3On/wfFrFQJqC6h7zlOcUaS3hNlQorAJEECfwLqfA", + "03GRdSlPOvwla0HP1qDTk9Zg0xJtvn9+uF3o6XIGwv0k74aw0CB1g9iiyikLQ7Ggy40WayjqwH3YpW+5", + "BmaxTNvmyLM1grQMpZ9tkqg3sKBKj8y4y/ESfXsBG1//jQ+odLObxWykqJgMLtRnpzyZMrdEaBsyAsZr", + "3zJT5FVVwrtUWaWya7lnANh/PnuGZ1nMWApjLOGvpNnvMx9eZcpqmdedCwy6ue502XUHbRL0z2OrM/rX", + "Ueb/9PqH607/moIqKe5OGIoKTXCDPDPK7TJRs5EXWcZnItB8/2JDvAb+F672L1d8hNPucKFL3BpvN8qv", + "qRbY6R0kjxZBx93xZhiluZCOj0gsV74qmrieNIMx/xapjEQzcT0pyn6q22MVNwOtVDOUMn6Moln/G+sc", + "uKEs12IuMphAC9vhZlD4EgLrpwxtB93XbipZZCg9Ao9fzc+ks0fiI/CiQxEQM4UsK6/cyYIi3r0tuY0l", + "hCuNRcqrx+oer8dz7PsZvYecFqF2vMsH2KxzgZy3o9cfsSh6D7M/Pi4D7FTOhVYSHx5ldCRWn/Ztk+KV", + "7irMX4lw3C2osR2A7bGLBM6NZPigwEVeJ7oSYOU5Volw7XvwtDx/22MwXkUQ7oQdxCNlz0MdxdBGoqUo", + "PsYxDkZ/ehEPY6qVfqJP2agYj1v681Ec47aTqcK2T/axHXo/iyrJcDfwXVITDcReWRZfqGFvE2RUn6bB", + "1DpXpxdvO+vnrQdT+c9/PnvzptPtnL276nQ7P3043xxD5ddeg8QXqIreV5pQpVt2fvVfvRFPbpoli5cj", + "sTMT73tZdtFJVFbMqInkuijjbker201zuU92DI3HWbu00TU3dpnzW1m/sK0KkEVE92onYl85FgbWLjZL", + "wSP/NeMsN1Ckqleefu/86r/2lxkrafYoiMrAlzmQRGoRl3GghSZRy4DzFWJqh8BgreWEih1AurKS++z+", + "y3yM9kBuwvUe/PysZjDmI8eQODNutnX0EK37+v6yBFZb/5FQWTc2/BILNPbKTrGRPmW1/ZR23KIQaZwR", + "Y1vnAbdxOzH1fljpxuKH7WAqbiU1y21hdq2FVyvBVhiSsu1cKS8GeRJrimqsmGG06PH5B1agPT0HnYC0", + "fBJrvr1WjFZdmESzcvCUG9/HbBsdhcrnt8RbVzsOxchDLXTafRmK3SLBo+aW8wqmthHfW3X4oe3HZVE7", + "YFMh7yd0TrjljpPdakEG0CXUo1QHIfMiEr6dcsu3UizS+iqbG/CU8/628cwP0hfddnxaqXHTrZ7QfWFB", + "tiFJlYeGHzD/eb+zrUnFH0UDr2Lpd9GdLk/LmvMacg3GcahawzGfo6L0SnHTh0KzdKxVyOJOEVVBIe6n", + "e9Pc0krQuyOFaILxVqyhZKQ0uTDsGgded9pI1u0/IgXIEO6DzVWtDVAyLeRNs24TpgyViUhbEjFFiyP8", + "H2aHGKl0QW1zacpQfZMuQHrqXg6gX9/pP5adUJY+ZaWNDO0U6VwYpRcvfS3LG6luw+q+vkzob1c2YF+q", + "TMoLO1VaWMzpzKggNSW3mlp50T47o1p72ErS+EJehaQFk8JYh5uLHEzXoQHZXrHuF/GYZhucUOK6qnTc", + "DSXR63WZq1rTjerdZfHcRg3gMr69indd2/aqrUQoXZ4n8f6De1xtyDhZ3+p92+omVNECdDzjbCwkpkZs", + "owZVZSvCqDYlaKM9ifS71T+bsv5G7fdG8vTWSlu1Wz/onptdumdUJuv7jN15FYN0AZNtKkdt53f6ydeH", + "DVVEJt4IsqbmRosn4lf0QOwy0ZZRCTTXd+45lvcyGDvuryU8KE5hhzmjruBwC91wsZtAdh+Pii4BvaH8", + "UxMxoiKoWSRqVy91Zvngbr1j5yelxe9KYgkiXIvxmSqk7TMKT3EPZ/y7YZh43GUSJrzxdweHuOSmHWyo", + "OPKL23GyxfqpupWR5Ys8vvhDIjHKMlXbG/U3UQW3vjBnVUurudTuRLHzlFuHR6wUGNuRa4k0BbkhpZrC", + "OCofmR+00cfvv2vZ9muRwTnomTBYc/N++8eugXHDGzUUpGxVzf7SsF7smhYdqfz1pxcv9ncr9KVuZczP", + "4/aKP6FnJ+z3Q8t+t0mhpWzOvLpbcueS59AXMr5nEa41Kc31inU7dqbhhYF6gQPqFpBD4mg/LX0HOzof", + "6p5wLFUX8z3US0k0gsYONxJlffHohTgV5rX5ldvkUeuqlUXv0ByA9SfjxSAc4Yo5bLbbltTu52Pl2Gyx", + "RSxPa2QS3sADq7ONNZ9BPPLmotJtw0cOxOPcUewctBYpmPBW8jewX4f588NNRuCoSTQ82CLGzJoCC0h7", + "j1QjDjcdEPpMXhICtzseq33UHW8hAHP97ay9kBm/w9oF4nc4k29/bN8BRjGHRl9vf9wSIsslu561BGS5", + "0x0VqVCbkfvYt2/g7nMqe4ZtoeciBdVnF4TIpv6udnoGn4N7+NMoH8nnntLnRWbgyP81uQFbL3KOjfAw", + "KZ8ZsIaNlJ3Wapzv+8pUFKTUxBdhaEc99yLvb1m6/NKq/KH0pXQCbp7NN3k2m0EquIVsgR3dMcpBFZZN", + "NE9gXGTMTAvrlD9fkmCGYXFoKhQS4zq0LrBBBB4VcSTu5tmlJiMBzG3oCQsyVrUD5Bwyle8aa3mFde9o", + "KCvdIRa75taK1LClugeR0vzBELi2rGqz+gSWrP1Hqy29N1NSWSVFUgZfMXIiVDvliVaGiCQTY6j3K/VN", + "uNgH47v+vuHG9nDl3tmJjy4sfBD/5eVpsAN686cwVJ+OLEor/bl3cJe6MwZL6W9rYdiW9LBUdoMKbt0K", + "Db0M5pB5WxKWisDyW3mtJIeHHAOZ4nmQW4SyHb7wRnX6PjvSI2E116F6hlcvqXOTL8VRFZ5wDCylyfrs", + "9UqLvnX1Qbqxwh64Y9A9tFkR2rBUJRgkBWW36KE3gv2zr5hxsPSXE5y3FgDXZatlQTa1tl9rHv2ijYwV", + "CP/j8v270sYYg08mjL/X9eVRqFoUuSOW4dWsFB6DBAHSXfjTtfK/BBuwzIvL0k3Q2tnfOl7vu+GW3f23", + "b+6Pnfwbvf0bbf0b9Zfr/VuQS+HufIhrP8ZhIv12P4mRt4T9ZfB03sOn3NYwaTVYMs8z0WKF/ZVnWS/J", + "VHJDV1aZK2qX2Wy15eDrp6Q8HRuKQjY6wtS7MG3vgO/6xiE791UquyndU9x5iZZxY1ckcdUHX4MBGyRi", + "81roeW36ayXZ4RaxfngQOkcUd5bqpu9sb3xYdeEbWBir1Q2YaEXQaPRLvGrpvfKiQsBmtY+QF1bLj3Kc", + "6A6bmmd80b+WDSahC2B7oZv1LGTEHaShNvR+n11Sz74yoeBa+ghwxwLcWqjrcMlUeA/W1mvcFNvDv/37", + "obsXn7a137+WtSq12PrC3doiJylxq3SKbdtT8pH6kOLy5EJazXvuK1rQXEunN0hOxb9QINLPOS+Mg9MV", + "tq9zeyMO7fayBnTR9kndll4eDhXxXrEZAQmDqcKwdWqj0VK8TQ0cwSSwHhexc/GUOwHvdP1FrpiQf/et", + "/dyr/xWbCWP5DZCihHISdRC8sxFPbkzOE6iQgB322XuZLTwLM7EbYHtGZCBttmjc07WsPkPc2KerKp+w", + "h/1nUawPYTnb9jH5VQsLZeeV+xH6emg1AlZCscGw4H0bsHzEXrzktsQqsZ2XHa+NnmHjXnZ0ftbpduag", + "DW3nsP+sf4gG0hwkz0XnZef7/mH/e19qDw9yEPKJDqgLExnHkoh17C3oCWBuEH5JKAB3wmBQh5JguqzI", + "nfBhS5NGMpLmwj3PctDolU+7RGRYBreQVmTU+zl8fQLzK6Uyw647qO5JISfXHcxbzoTEtllqhDpTykYw", + "VjrUY0V7kU+dQ2Qqu0mepWgftck0rPLad6HyFZJ+VOmCglmrzjxVmvbB3w1ZY0liRlzJ4TaXtItwJLpD", + "q9gMr9XXB/3bdafXuxHK3FDaSq/nO4n2Jnlx3flt//6ZJrShOFpV3zn6pGQzzFrEdZ4fHkYM+bh/gneK", + "L6vyaB7Yy1ViP3Y7L2immOZRrnjwIw80SXWqP3Y7P2wzDstmSJ75UVjXdjbj7inU+UB4WW4x44VMph4I", + "bvN+zziswt6yh9kmqigM6F7oA1QtA1g8XQsDjPrBscpWV4a8jHj5c99hVfdabiQXtju1XMtdyeUYNNa7", + "D7cQuh67R8qNfwbLseahNKbHYnYa2r1d+jaI3WuJLdx7WBAd0nJGOkc5f0BDNPoen5wfhOx07JeqgY2c", + "Jg3ptUQLR7jLjZR9XrWiuy9xx0VDTKPaBvh99nPIBfQ/ST4Dcy33fMaZl6bHSt0IMP4erzvUNRYLTnvX", + "07Scgf7av5aXACyUG6defNVO+hOlJhmUiH1ALqEyXzb83QchUcadO/+P3IjkqLDT93PQP1mbn4ZGlnQH", + "0Q2jacl9bD7kE81TMOUoL1Tf8rvj0pJgzkGfOzzpvPz+ebdzrvIiN0dZpm4hfa30B50ZdH6ullLv/Pbx", + "sfhawJWvlrUto507SzuHK/JM8bRXdWjscZn2wreO7SkTUXQ+4DAqYqvZzHGQcgr2u8gZ18lUzB2Fw53F", + "9oh2CjNWyBQ0O5iqGRwQC6k6ZJqD6+Lw8PvEkQL+C7rX0r0HteNxs/oKxLeFvIeiUXLOa/kJFQ26r5Ix", + "miOZXvg7XseTZkVmRY6dRZWe9YKtrE3nqPXZbE3Yrb5xygeBnwIkEyvm3DaqbzSnj5eufq0yB1N0r1vF", + "8own4EvOB3DtBvUll8JR76+89/th78/9Qe+3P551n//wQzwK4HeRD7B96MoW/1ohZGji4qNPC5lTLlNF", + "PuWu97C/X0g2nnEpxmAsiuj9uhViJKSjxE1afbk9XwM89jJZq8DVoHs/Le5ZLCK5xAZCBUi7EW5HVFMS", + "B0ar8vRz870VFlRCs4bke9w4hmT260ywPKLnhv4tfTAKOl6c652GPGrJ1FJjoaWulobccr7l5dH5GRa8", + "7rMj/ytKfgpXcuoMWcus8B3TRQYYjhVCpO+SrDAOeZ3602VGMamYwsACTH6oeuQblnBJNgrsuo1dSUL0", + "h7EqN8GIMBbaWN9zIjTMDBfPRFl3hKyVoREmNQO+lqEsemHQOYmdiqeeqlKgDC73LqzsgJicQwV13Go3", + "sKDOpP66rmXweOZ84WbxjgimVSHTntUiZ051lAnFkAMWGJCpmIu04JmfJsZ5f0RFsNm59P5q4Fqb6epK", + "VfPF+ykjOGVL043PSXslIVCX1igB1HF6icyWmqIGYmsCrmqH+kTwivRbvSeYqENd6CYbyPqzQuhSzIqM", + "EkaJ6ur9ouOGxBUYkbnqwLH6djBdAE+Pa6at2G09FriarZIRWktvr7LjsV8S5dQK3Tz4dt2hybJcZhqt", + "WPnarhNtg+332TROPhHqxy2g90V/tHr67DJso1pC4YthWL+SQTYY07eAV9mEOA6mMjr4iSC02t54a+A8", + "yvq10mcxOqPA5bkIjTjK1/IXA/GfROqLsKjben3HJpib7bXjWh/WlkKtBUPkA0OlPqDd0knlNDceqiq6", + "ZbUlrxCGHsjl3qATMQ/tF0kxzYAbQN2q3tVqQ+PKmMZTtmF9ItRcbTR+T77hJvpCxCVupaqcSWDiCIcl", + "jJmAJYQZlP3/W5nEX8A2qpw+pXiMl1ON0y5GHdBJy0M8xi3+BWwjsMFrHsQswkrbKB/NvvXxyy2rrT4R", + "mq92xH+QduhvwZ3s86L621BEtAGdIBXL1ICK05htIFY1uF/PR0M4cLkOuvGRZ9b8/WVeAtnJqwSZWrm5", + "axkrIkchYljoLNcwBUnv5tVqdV1mAK6l20y84hzjtjKjT4TtjzVACubGqryv9OTgzv2/XCurDu6ePaN/", + "5BkX8oAmS2HcnxI/9+FcUyWVNvXADx/9GM7rXtQ+6j7xV4H5Fcab0AgKKo16PHwJxCcih+UKi/elBgQo", + "YsuXpC2QjK/bkhAvt0D8eqOgNlZ1xW/gsh4a+SQa40rK5kcPo7USBwNZD3JKMa5W2mzdXBEs1QYoOvaz", + "ArTMTWAVgEIQ2gZwqixrZ2KUjMrmPmGTqgAcKEfbIYnU/c3WdLwaJ21qiw07X6OOp1cDG9mgvpm2ZJma", + "YK6oFcmNYXtSWZ+pTCbOGgaxEUz5XDiU5gs253rxitkCrXQzjKSqFx3AmClMq6iOQu7GkJyKqazeduld", + "3d1G0QQf8oOenoZJc6+cA1XhaoF9ivtAKxIFC4VY8MAKhyE2jAwYvZ6GHLhl71ivR0FXh4w8CKSQkw9h", + "GOOQlyEn9InIr5alfF/u6NHrC7Eh0WYqXYHAw63TjHfQ5kLQbwtz9AGXTwSX5XjOBxk5KIjwi5Fa7mxk", + "1FgHBR8j3M7TqlrCwd3I3P+jMOTFcngycq3SRWQsdwqaVXmOyRgJsD0KSOheS++TrbwxXcc4MH/Nu+O6", + "NZ3Pl4M24nchJ/v+1VwuJMpiYwzueGKzxbXE5RqeKQ08FdLJcvd6du9xjKIOawyphHahsyGu59kOZyMw", + "tgfjsdL2WlZ9zMrC2WHW4KVwM6Oi5h42fAKM0hN+dLzRASG0TtUznmGoqVXXchjUyaFvwMDlAm+aLVTB", + "UoUh0BLcjo8sy4A7pVUGwzLFZ7iv0S85AuZLKvWv5UUInGnCylinOupClhWP0W31shZ/U4eNh0CX3Otd", + "VI7lMsT6UZBgsRsCB4k+kCkFxpZJOxSzfi2t5tIE9fYlE2PG0bWjq/Aft290NrkNcp05sVgRHcMkQ8B2", + "yCETbsaFdPiAa1MgcAIeV92fpJK953d33t+Va5XziRPI/Wt5rmGMqrW7HifGDOQcM16HVXTBPw8peejA", + "39EQ/Xk+upXIJoPgXexZLSYTcHrStSQYECUJifD0CaxV+H5MWIVbPi7p9xEDBSgsaFAPb1uK77h63fs3", + "n3vTjF1iM56z//O//jfDGG8DMy6tSLCI8vnR1fFPbDV6Ll7z2H81aAmUrO2AfNxs+Mc1BTFed17W4yR/", + "+zjcckM4OrobD9ZttjFzTAM1k/g7abXPwpDtYcmVAyq4cgA26YeEVao3HgKqVxGIQspNN/hnMe23TBBZ", + "5saiYsWNsKUGpTaJNFoSbU0cyWk9zMegFTLsPnESKymwMkk1RR8jQ+gYVWbA2rij/f7mIJQHh4g8ffwG", + "xoy7IQPPO1dv03Ld/93YWHQKpn2BwesdNmJnMNjUpzF65uxZgekzz85C/JUvWYEF032Dqypw0A92/88c", + "1Nr1owZvIHPj99DdTqF2bOjD/A5oFXTsD/cpQXXo7i0fVCQxJKmALJLA7eMZwmHtlJfxNcbJO/zgVvM8", + "h6pJl1hK+mkDly+H5YR7hIwv3pTeHy/ewQv3iguvFd+lLajLMpATss8nnGjNsueHL/6N6ix2K9JzAEww", + "2JfCKJBHeADQLkYZtNTFbt7lGqWtSrAKN4jeg2os5XBrkZOzcgknS6zYczKyrCzkM4mwNj7cEUVuTOb+", + "olxUDU3I88tXlbpZYoGbOYNl31X/IYr9i8M/bx7nNpiJZOU58DjO8mXtITwfWu8JUOFy/4u8vIzpTlk+", + "5XjF9ZfHEeoz9GxPS4UGn/I+O7epieZZYVbuPlT8OqhJ3zLKPhLO7aXqUxk4Iw2SPjFG+9VDsuUqsD54", + "L2t4KzUu+bNh7INjl1uO41BjbA4SDdzCoOyDgWhSxCKG8MOyiM9ThQ01V9kJVZ6tqzlE5/yCzAt0UsYx", + "56u6/gCXFBzb3AIuJ/jhU8OFVqk3tLu3X7oECR0xfRhlvdg87p2yr1Uh00d0aOPOGW+HW9CD14DsNam7", + "Xza0sKLc/wBAITxKGKlb6TRmR12D3wWWEJqAjVXqsoWWhnH217NzVr4Fam+I8DQoi8pU1d8CavRXY0j8", + "+idC/1XkGJGv+QwsaIPtL9oaPpaUgzqoVaWu71SDcCh83blx/ygA2QG96UIdvCYOdOtGjE119X7bSTj7", + "e32Q08vdejhjWTsJEat+wV8jXnpg1VmIew0QooUHbRxfjU23QNjw9t2zXNcewLPgHEY91M21vxavr+Ua", + "xGZ/NTZlajwGbZgREynGIuGYej7mhp5/tKDXX69lCvU/uX9zTS/A30XuDS48mQqYY7tcsMuzIBnFI7Nq", + "VOXu6Gshq+4fq83fyuNiBEOf/SQmU9D0X2UPaWZmPMvq5ohRYZnlN8AyJSeg+9eyR5Aw9iX7bwdtmoI9", + "6zKf+O8ACynb++/vDw97Pxwesrc/Hph9N9AXNmgO/L7LRjzjMnGqlBt5gBBge//97IfaWAJcc+i/dgM8", + "w5AfDnv/1hi0ss1nXfxrOeL5Ye9FOaIFIjVsGeA0nTo4qtZR4V9VpSZ/VZ1u7TfaMv7DxFoS7MoVPfU+", + "iC1eLdm1/j/CGpfMeSV7RINLqN3g2WKTNZTN5LflCcgJ/LWu9LX/UiTsbjph1VB/FaFQy6t16/8K0eYv", + "YOsnKNtHrUCvRJtMGIt6umnFmzfCYL1nc09h8nViSnXqCKpUz7eMapN8hbiC2boIeUokXMUNbJTf9nwL", + "rd2fMDT2MZ5uGIpamTu+QjjhCbCZN3q51hGzBp6Wj+4oLV8AT/2TeztSxsWCSujm/1KoWSUWbK9qWvQg", + "XQJZfzSP6ytDFswaa7jrSuQwQIx+UKst30rdqyX+ny4JqaWXwL2ra9RK5/uUoa8QkJdgVwm93hbgANsO", + "mKnISwiTB7Q9CAvrnJiao9TnjitdxZeQQPCh+hpmyvMAymXrt1SdCOrBo0WPlBpJi4s+BWMHG9opuG98", + "n/WSg/mqaV6h3aaRQrdzX2++9+RXW925HAPdwqNVYkAolUUYvnZWFynOMPb6Wp0cgmlzbZEZjoYXikHD", + "jtlUT0ZYU9k2V9JXlvGrjTjIuvlopLEr6qf1jhO1SjlVjITajg4eKbJlHT3cE7H/KvIKrWsA/B+D5Lxe", + "8GgJRVfw3RtXNiD8rqbRNrq4lpsJY7OJtGERvZZLJtH2ckfexvloxNUaRXU1hWXTSylCtogb+mxEG4/y", + "aSvW+m77QB/fxsvvDYsZYXlfh069Hn7Tq8bt93eroRzg8CTs4sjf4f9wlrGMri1s43a5INHSS6DWCOmp", + "3gCRXkvbw/aexVPx2NG25x+k+EcBsQZBFVXe+uvYKl5tuV67TabssWv8fSZko8PUjdS+UJOc1DQxvK2D", + "P8KVf/RlzIGKlCzjm8ordFsyUqDhwVsavN2hhOM628NmU8OLWGF9AhQFO3/lgLrElj8hrjxm7VsG0gHl", + "yLWakqhr92tzSp99Qlgtm4Us3FnabdQetMkfcIlPW99sJ5JzWjW9UePaW9jnEGKTU57iqf/o/Gfv8vK0", + "58sH9a6irSjeQiq4r7Y+xq4y2HrDpyTuLTOx/YbnLnjpVlhdxCn38WtEU+outHzLvuQJsd0SY91jfn2Q", + "ERbl2cbgeVJTvviK8fMT+r3fVw0JQhvL1g6Wjd4pf3rxom2b2PaxZVtr+14S8W0j8R9ojr2nNaMsCfW1", + "i1E0SznJGeIhq1CtTE3MQXWxcRedmhginRY+vIQQvrvQOswNjMajeFXfNtrVP77MWGWZuo1HHjRaf9f6", + "5C2DGRM8yrQ9MQ7t/IRhfmtrCLNdquyyTu3s8dWqDwY5tanpfDaJ9kZNthRlDrG+aOkVkwxu05RDeXl5", + "SgSSZ3xxqyntjYpGblFetWz+dV6OZoljtugLHWsw01pTWwTNnWV8woU09BIPWQi6kFjCWSrJMpXwbKqM", + "ffnn58+fU3YqzjrlBnvOGWTV3+V8At912Xd+3u8ooec7P+V3ZaeYUKXB92H0sRg4Y7U5LJVrCy2r1m8B", + "vWKGE38F1bmPSTo8xctuZa3PlPUQ2Ye70HiySnm5X2I51OoIWHbgEndOGBFBTk8gxJOQOtof+r7Bllvo", + "yer7lCt8Jjxo7KANA6pqxtp/80WUwU3UbOa4hFnIZKqVVIUJVW8DgE3Ob+VGCF/iV08KYlzi88LYb6EN", + "yPjzZy5+sgpbvga4f/h/4Nv8RjQrCEUB/bPAUjSb3+XVzGtVwlKTLwqRPuSxcC+AutN8kZVK3//8VcYX", + "OFYiJu6laRULams7xlFhgI04d0Gf/Y/BOjrPN7x7vAAlrC/B2fnVf/VG1EphM/IZy23RbooMLJ+++tS4", + "98RyjA4VE2H+l68yStkDgJlwvHbQp2ILnQa/+h/DdfA4n1l/oi206U8/LrB1B5nfvlqLWyX5GOHZWjxU", + "hd1kiKsuTxV2rUXuM/GjB1iWyrO5YVvamMLtqsLmBXXVz8QYkkWSwTcHytM5UGpYrQq7ZDDTkGC50MlB", + "5YSNc1fKHL4I3z9pona5yubassvpnn7g50vR/ky1LcrE7lzDXOCbkRFwIWVzkYKq+RFqUPfJZa1cLGSf", + "1QG/1ntWOq386rreZJ+qkPkm/o1qrkWo1e29AuXwNkcWMr24G4v3fj/q/fWw9+feb//yT/dijXhhB7P8", + "xYPTCSqM9DGPDQZX/tp7LSQ2qe8dxRo9ixkYy2e5Y3LUnB8tu9XUNLjP/lJwzaUFipcbAbt4ffz999//", + "ub/eA9LYyiXFo9xrJz6W5b4bcVt5fvh8HWFjcTmRZUxgsciJBmO6LMd+FszqBdk+qcZj87ovwOpF72js", + "flgthVtMJpQrim01sAOkkKxqmB+6L+oFEUF1iDKW7Vkklu3jV5xwSqV4DdIiNVDfgqNkgqRHa/7ghSds", + "89D+FGU+wDqBElajTM+VIPsVeg2NK3W5y0dLsONZVp+2eW0rHVAjoXdPLXybi6yVvc/WkahnAl9hhSi8", + "gbKKe8XX+uw9lZyt87ocNDs7wRaIWNt8IozFLo1YstpxkP4qlFW+Dsgqf3oY19a4v3rlQ+E+b8Fwq/Km", + "+KHrNgnPwKrfQasD389+bZsQeiu4iX55S0UL3QxY+EMxN0vXAZfrNMPny5j9dHV1zqzm47FImJJM2D47", + "5lkWaoUcnZ9RiWxh3JS3Tlrd8htgwrIRJLwwwD5IcaP52NKvofN44hs73YBvUrIIRQxCzskvb6OlPuiY", + "l+7kV+qvoFVnm7BG/L5nVc+dkvm7Sh8FOGcpzHJlSWz4mfFeIdxq7Yr6q4ADuR5uF2Cs0mB82UyaujxK", + "2YmgWqPr+K+6RRUCb7O5GdIaUKMRaQYEUBpbqjm/vGVS+VIiWDnbeN1mClnKuANb1MsuHw4bkE8EGpp4", + "E2QsZDBzus/GQjv1hkzlqGapvT4LH784fMHEuPYdVe2uiqRGW8/8BexVuZ8ntH6Vi1xabqNm96v4Ae+r", + "u612t2qfv6xcucTOuPZNMCjflQDSCgiUagm3MKFKvHDnLks4xDBYP6JeR4WNVLrAarIU1J2+Ci+5+hQa", + "LKdxQpeYYKhDv9kJ9Mz39Wcwh/rWHb76BSknhmjjJcMu/yzJgGsTijbVThvrYuRusYlMT9CplwIwymXq", + "BTc/nS333tj8FWdO+4Kf68ioiHXdAbuBbgIWPz981sTiW05oXLPCVBj9ygdnuXGHbpywboBD9AySEMCl", + "ctsT8iXjleifcuux3M1ep7Y9vlQCl5L1pLIY3O+I2CkOuoAuUzpQUiCeIPH3W4nmFQkC93+l1PACcTem", + "fV7Yz0dnXzxd7Zq/9DQbMvB5A5wu14m8hhpSS0iJq4dn8u/Yr4NL8gUwEXJTqwXINdFlE+6b+mFSZYIF", + "yZe3USf5Q6Ix/NoYMZGQMpBzyFQOlbLolzWMp8Hc+fzwReT3scjo2bgnVVg+lLj2yWb47XemIlxhKtpF", + "wn5xeOi0tjnPRMrL7vktzT7Oi1EmTCX3yIHzRF5MWguX+ExezOqcHkjRSD8ER067day6hGjCdehSUMGb", + "+o0l0CfqjejvNCFPEsgRvQpbQXo9rr0iCRK28oDa8M2mgzThFiSxTGwrjs5liz9Iah48B9b0+VUzE8H2", + "2SlPpmys+YwCobH8htIzNhTpS/aHgX98vL6WKbf8JfsjgKDn4O3+fn0th05a0t37XgRli7gEjOnNlFRW", + "SZGggzEHbdD0lmhlzBK786mJrxhnb7ixPYRY7+yEbADYLclLcTdQVhIaqQwf6BpMMQvPfjp2n51oldOm", + "KKiKAD7huQkK9VCkQ+pRgh2JvA0DxBxS+k0YqmJhp1yyZ4xPgach5DtzezUAEj/tBl/nLWjHKATmLZd9", + "4kfFeAy6z44zgV/53qZW8+QmMptTFlKwkFjcb5+9xuj36vgm6BdLV4Ymv2rZSu/3oHLAwLQKA4AFvmnX", + "r1jOjWHD/0tDnvHFv/MsG1JeeWM6laVY9BKfFo7bevw1Frhv/HQr3H1PeY5pGtgOESRokbBhk88NqWdr", + "0Jr87YF/yHjK/Blbn1BjSbbnPl9gCyaHbdQokLNUJcUMpBs1tIschtRErGTWQ+qZ4nBO6VlZNKRq6OP1", + "lX/GbZ3gx8SyusygQkj7ocmjHQYR4ZrH21iZ78KhbOhGgsqdadKT7xamNDMgU3YYgUcAb2jLty1NdplR", + "TcKa86ygnIYZODLTGhKsBUFLcbeGkLbPrvgNYCfXBFJcCP3YQ8KbIYlVbCdJC2OrMlzOMSReWNXT4NG4", + "Wi4DLrFRFiISmf17NKWD0FQYLG9ZVVYlb1LlhGwQwW5JRueI+LsgfJ9dYA1gJGmWOH7CLXt2+PzFKxxQ", + "IjOvcQIMEy/0mCdARUPHQhtLxD7BDDPtuUy/tYAs3Ug8dCLL7lcD9gHBJ1vJ8zdbCKOvLuNp+QQOopfo", + "P+9dOnr0HMCN/n8DAAD//wL6kKOLyQEA", } // GetSwagger returns the content of the embedded swagger specification file diff --git a/server/openapi.yaml b/server/openapi.yaml index 2c94c895..33004b05 100644 --- a/server/openapi.yaml +++ b/server/openapi.yaml @@ -2187,10 +2187,10 @@ components: BrowserPageCrashedEvent: type: object description: > - A page's renderer process crashed (CDP Inspector.targetCrashed) — the - "Aw, Snap!" failure — while the browser process itself stayed alive, so - no service_crashed fires. Emitted on the crashed page's attached - session; the CDP session and target ids are on `source.metadata`. + 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. required: [ts, type, category, source] properties: ts: