diff --git a/server/cmd/api/api/browser_repl.go b/server/cmd/api/api/browser_repl.go index 3ee1aa53..b365c974 100644 --- a/server/cmd/api/api/browser_repl.go +++ b/server/cmd/api/api/browser_repl.go @@ -61,6 +61,14 @@ const ( // and metadata, so 48 MiB leaves ample headroom while still bounding // memory on protocol corruption. browserReplMaxResponseBytes = 48 << 20 + + // maxBrowserReplIdempotentResults caps the responses kept for retries. + // Executions are serialized, so a retry targets one of the latest, and a + // response can be up to browserReplMaxResponseBytes. + maxBrowserReplIdempotentResults = 4 + // maxBrowserReplIdempotentPending caps the keyed executions waiting or + // running, each holding a request of up to maxBrowserReplBodyBytes. + maxBrowserReplIdempotentPending = 8 ) // browserReplChild tracks the owned REPL child process. The API process is @@ -81,6 +89,8 @@ type browserReplManager struct { child *browserReplChild // guarded by admission customToolsMu sync.RWMutex customToolsReplID string + + idempotent *idempotentCalls[oapi.ExecuteBrowserReplResponseObject] } func newBrowserReplManager() *browserReplManager { @@ -88,9 +98,10 @@ func newBrowserReplManager() *browserReplManager { admission := make(chan struct{}, 1) admission <- struct{}{} return &browserReplManager{ - admission: admission, - lifecycle: lifecycle, - stop: stop, + admission: admission, + lifecycle: lifecycle, + stop: stop, + idempotent: newIdempotentCalls[oapi.ExecuteBrowserReplResponseObject](maxBrowserReplIdempotentResults, maxBrowserReplIdempotentPending), } } @@ -636,7 +647,46 @@ func StrictBrowserReplBodyMiddleware(next http.Handler) http.Handler { // ExecuteBrowserRepl implements POST /repl through the REPL subsystem. func (s *ApiService) ExecuteBrowserRepl(ctx context.Context, request oapi.ExecuteBrowserReplRequestObject) (oapi.ExecuteBrowserReplResponseObject, error) { - return s.browserRepl.Execute(ctx, request) + if request.Params.IdempotencyKey == nil || request.Body == nil { + return s.browserRepl.Execute(ctx, request) + } + + key := *request.Params.IdempotencyKey + if err := validateIdempotencyKey(key); err != nil { + return oapi.ExecuteBrowserRepl400JSONResponse{ + BadRequestErrorJSONResponse: oapi.BadRequestErrorJSONResponse{Message: err.Error()}, + }, nil + } + timeoutSec := 60 + if request.Body.TimeoutSec != nil { + timeoutSec = *request.Body.TimeoutSec + } + fingerprint := idempotencyFingerprint(struct { + Code string + Reset bool + TimeoutSec int + }{request.Body.Code, request.Body.Reset != nil && *request.Body.Reset, timeoutSec}) + resp, err := s.browserRepl.idempotent.Do(ctx, key, fingerprint, + func(ctx context.Context) (oapi.ExecuteBrowserReplResponseObject, error) { + defer s.holdScaleToZero(ctx)() + return s.browserRepl.Execute(ctx, request) + }, + func(resp oapi.ExecuteBrowserReplResponseObject) bool { + // Every other response is returned before the code reaches the REPL. + _, ran := resp.(oapi.ExecuteBrowserRepl200JSONResponse) + return ran + }) + switch { + case errors.Is(err, errIdempotencyKeyReused): + return oapi.ExecuteBrowserRepl422JSONResponse{ + IdempotencyKeyReusedErrorJSONResponse: oapi.IdempotencyKeyReusedErrorJSONResponse{Message: err.Error()}, + }, nil + case errors.Is(err, errIdempotentCallsBusy): + return oapi.ExecuteBrowserRepl429JSONResponse{ + IdempotentCallsBusyErrorJSONResponse: oapi.IdempotentCallsBusyErrorJSONResponse{Message: err.Error()}, + }, nil + } + return resp, err } func (m *browserReplManager) Execute(ctx context.Context, request oapi.ExecuteBrowserReplRequestObject) (oapi.ExecuteBrowserReplResponseObject, error) { diff --git a/server/cmd/api/api/browser_repl_lifecycle_test.go b/server/cmd/api/api/browser_repl_lifecycle_test.go index a29fc323..dea13628 100644 --- a/server/cmd/api/api/browser_repl_lifecycle_test.go +++ b/server/cmd/api/api/browser_repl_lifecycle_test.go @@ -1024,3 +1024,71 @@ func (f *fakeCDPServer) evalExpression(expr string, sessionID string) any { return expr } } + +func TestBrowserReplIdempotencyKey(t *testing.T) { + svc := newBrowserReplSvc(t) + initial := requireExec(t, svc, `var keyedRuns = 0`, nil) + + execute := func(ctx context.Context, key, code string) (oapi.ExecuteBrowserReplResponseObject, error) { + return svc.ExecuteBrowserRepl(ctx, oapi.ExecuteBrowserReplRequestObject{ + Params: oapi.ExecuteBrowserReplParams{IdempotencyKey: &key}, + Body: &oapi.ExecuteBrowserReplJSONRequestBody{Code: code}, + }) + } + const code = `keyedRuns++; await new Promise(resolve => setTimeout(resolve, 300)); repl.write(JSON.stringify(keyedRuns))` + + // Without a key, a disconnect mid-execution destroys the REPL. With one, + // the execution finishes and the retry gets its result. + ctx, cancel := context.WithCancel(context.Background()) + firstDone := make(chan error, 1) + go func() { + _, err := execute(ctx, "k1", code) + firstDone <- err + }() + require.Eventually(t, func() bool { return browserReplBusy(svc) }, time.Second, 10*time.Millisecond) + cancel() + require.ErrorIs(t, <-firstDone, context.Canceled) + + resp, err := execute(context.Background(), "k1", code) + require.NoError(t, err) + retried, ok := resp.(oapi.ExecuteBrowserRepl200JSONResponse) + require.True(t, ok, "expected 200, got %T", resp) + require.True(t, retried.Success, "execution failed: %v", retried.Error) + assert.Nil(t, retried.ReplTerminated) + assert.Equal(t, initial.ReplId, retried.ReplId) + requireExec(t, svc, `repl.write(JSON.stringify(keyedRuns))`, float64(1)) + + resp, err = execute(context.Background(), "k1", `keyedRuns++`) + require.NoError(t, err) + assert.IsType(t, oapi.ExecuteBrowserRepl422JSONResponse{}, resp) + requireExec(t, svc, `repl.write(JSON.stringify(keyedRuns))`, float64(1)) +} + +// Aborting a hung keyed cell frees the REPL once the abandon grace period +// passes, instead of after the cell's timeout. +func TestBrowserReplAbandonedKeyedCellIsTerminated(t *testing.T) { + svc := newBrowserReplSvc(t) + svc.browserRepl.idempotent.abandonGrace = 200 * time.Millisecond + initial := requireExec(t, svc, `var before = 1`, nil) + + key := "hung" + timeoutSec := 300 + ctx, cancel := context.WithCancel(context.Background()) + done := make(chan error, 1) + go func() { + _, err := svc.ExecuteBrowserRepl(ctx, oapi.ExecuteBrowserReplRequestObject{ + Params: oapi.ExecuteBrowserReplParams{IdempotencyKey: &key}, + Body: &oapi.ExecuteBrowserReplJSONRequestBody{Code: `await new Promise(() => {})`, TimeoutSec: &timeoutSec}, + }) + done <- err + }() + require.Eventually(t, func() bool { return browserReplBusy(svc) }, time.Second, 10*time.Millisecond) + cancel() + require.ErrorIs(t, <-done, context.Canceled) + + start := time.Now() + reset := true + fresh := executeBrowserRepl(t, svc, &oapi.ExecuteBrowserReplJSONRequestBody{Reset: &reset}) + assert.Less(t, time.Since(start), 10*time.Second) + assert.NotEqual(t, initial.ReplId, fresh.ReplId) +} diff --git a/server/cmd/api/api/idempotency.go b/server/cmd/api/api/idempotency.go new file mode 100644 index 00000000..c4408c55 --- /dev/null +++ b/server/cmd/api/api/idempotency.go @@ -0,0 +1,222 @@ +package api + +import ( + "context" + "crypto/sha256" + "encoding/json" + "errors" + "fmt" + "sync" + "time" +) + +const ( + maxIdempotencyKeyLength = 255 + + // idempotencyRetention bounds how long a finished call's result is kept + // for retries. Clients retry within seconds. + idempotencyRetention = 10 * time.Minute + + // idempotencyAbandonGrace is how long a call keeps running after its last + // caller disconnects, waiting for a retry to collect it. The SDKs wait at + // most 8 seconds between retries. + idempotencyAbandonGrace = 10 * time.Second +) + +var ( + errIdempotencyKeyReused = errors.New("Idempotency-Key was already used for a different request") + errIdempotentCallsBusy = errors.New("too many calls with a new Idempotency-Key are waiting or running; retry later") + errIdempotentCallAbandoned = errors.New("no caller is waiting for this call") +) + +// idempotentCalls runs each Idempotency-Key at most once. A call with a key +// already seen gets the first call's response instead of running again, so a +// client can retry after losing a response without repeating side effects. +// +// Only responses the caller marks as kept are remembered. Every other outcome +// means the call did not run, so the key is released and a retry runs fresh. +type idempotentCalls[R any] struct { + // maxFinished caps the remembered results, oldest dropped first. Calls + // still running are never dropped. + maxFinished int + // maxPending caps calls waiting or running. They outlive their callers, + // so nothing else bounds them. + maxPending int + retention time.Duration + // abandonGrace is how long a call keeps running with no caller waiting + // for it before it is cancelled. + abandonGrace time.Duration + now func() time.Time + + mu sync.Mutex + calls map[string]*idempotentCall[R] + finished []string // keys of kept results, oldest first + pending int +} + +type idempotentCall[R any] struct { + fingerprint [sha256.Size]byte + done chan struct{} + finishedAt time.Time + resp R + err error + + cancel context.CancelCauseFunc + waiters int // guarded by mu + abandon *time.Timer // guarded by mu; set while no caller waits +} + +func newIdempotentCalls[R any](maxFinished, maxPending int) *idempotentCalls[R] { + return &idempotentCalls[R]{ + maxFinished: maxFinished, + maxPending: maxPending, + retention: idempotencyRetention, + abandonGrace: idempotencyAbandonGrace, + now: time.Now, + calls: make(map[string]*idempotentCall[R]), + } +} + +func validateIdempotencyKey(key string) error { + if key == "" || len(key) > maxIdempotencyKeyLength { + return fmt.Errorf("Idempotency-Key must be 1 to %d characters", maxIdempotencyKeyLength) + } + for i := 0; i < len(key); i++ { + if key[i] < 0x20 || key[i] > 0x7e { + return errors.New("Idempotency-Key must be printable ASCII") + } + } + return nil +} + +// idempotencyFingerprint identifies a request's parameters, so a key reused +// for a different request can be refused. +func idempotencyFingerprint(request any) [sha256.Size]byte { + b, err := json.Marshal(request) + if err != nil { + panic(fmt.Sprintf("idempotency fingerprint: %v", err)) + } + return sha256.Sum256(b) +} + +// Do runs call under key, or returns the response of the call already made +// with it, waiting for that call if it is still running. A caller that +// disconnects does not cancel call: it keeps running while any caller waits +// on the key, and for abandonGrace after the last one leaves, so a retry can +// collect the result. Then its context is cancelled, as a caller's +// disconnect would cancel an unkeyed call. keep reports whether a response +// shows the call ran; any other response releases the key. Do returns +// errIdempotencyKeyReused when key was used with a different fingerprint, and +// errIdempotentCallsBusy without running call when too many are pending. +func (c *idempotentCalls[R]) Do(ctx context.Context, key string, fingerprint [sha256.Size]byte, call func(context.Context) (R, error), keep func(R) bool) (R, error) { + var zero R + c.mu.Lock() + c.expireLocked() + entry, ok := c.calls[key] + switch { + case ok && entry.fingerprint != fingerprint: + c.mu.Unlock() + return zero, errIdempotencyKeyReused + case ok: + c.attachLocked(entry) + case c.pending >= c.maxPending: + c.mu.Unlock() + return zero, errIdempotentCallsBusy + default: + var callCtx context.Context + entry = &idempotentCall[R]{fingerprint: fingerprint, done: make(chan struct{}), waiters: 1} + callCtx, entry.cancel = context.WithCancelCause(context.WithoutCancel(ctx)) + c.calls[key] = entry + c.pending++ + go c.run(callCtx, key, entry, call, keep) + } + c.mu.Unlock() + defer c.detach(entry) + + select { + case <-entry.done: + return entry.resp, entry.err + case <-ctx.Done(): + return zero, context.Cause(ctx) + } +} + +// attachLocked records a caller waiting on entry. The caller must hold mu. +func (c *idempotentCalls[R]) attachLocked(entry *idempotentCall[R]) { + entry.waiters++ + if entry.abandon != nil { + entry.abandon.Stop() + entry.abandon = nil + } +} + +// detach records that a caller stopped waiting on entry. When it was the last +// one and the call is still running, the call is cancelled unless another +// caller attaches within abandonGrace. +func (c *idempotentCalls[R]) detach(entry *idempotentCall[R]) { + c.mu.Lock() + defer c.mu.Unlock() + entry.waiters-- + select { + case <-entry.done: + return + default: + } + if entry.waiters > 0 { + return + } + var timer *time.Timer + timer = time.AfterFunc(c.abandonGrace, func() { + c.mu.Lock() + defer c.mu.Unlock() + if entry.abandon == timer { + entry.cancel(errIdempotentCallAbandoned) + } + }) + entry.abandon = timer +} + +// run makes the call for entry, then keeps or releases its result. +func (c *idempotentCalls[R]) run(ctx context.Context, key string, entry *idempotentCall[R], call func(context.Context) (R, error), keep func(R) bool) { + entry.resp, entry.err = runRecovered(ctx, call) + entry.cancel(nil) + c.mu.Lock() + defer c.mu.Unlock() + if entry.abandon != nil { + entry.abandon.Stop() + entry.abandon = nil + } + c.pending-- + if entry.err == nil && keep(entry.resp) { + entry.finishedAt = c.now() + c.finished = append(c.finished, key) + for len(c.finished) > c.maxFinished { + delete(c.calls, c.finished[0]) + c.finished = c.finished[1:] + } + } else { + delete(c.calls, key) + } + close(entry.done) +} + +// runRecovered turns a panic in call into an error. call runs off the request +// goroutine, outside the router's panic recovery. +func runRecovered[R any](ctx context.Context, call func(context.Context) (R, error)) (resp R, err error) { + defer func() { + if p := recover(); p != nil { + err = fmt.Errorf("panic: %v", p) + } + }() + return call(ctx) +} + +// expireLocked drops kept results older than the retention period. The caller +// must hold mu. +func (c *idempotentCalls[R]) expireLocked() { + cutoff := c.now().Add(-c.retention) + for len(c.finished) > 0 && c.calls[c.finished[0]].finishedAt.Before(cutoff) { + delete(c.calls, c.finished[0]) + c.finished = c.finished[1:] + } +} diff --git a/server/cmd/api/api/idempotency_test.go b/server/cmd/api/api/idempotency_test.go new file mode 100644 index 00000000..8f7a61d0 --- /dev/null +++ b/server/cmd/api/api/idempotency_test.go @@ -0,0 +1,219 @@ +package api + +import ( + "context" + "errors" + "strings" + "sync/atomic" + "testing" + "time" + + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" +) + +func keepAll(int) bool { return true } + +func TestIdempotentCallsRunOncePerKey(t *testing.T) { + c := newIdempotentCalls[int](4, 4) + fp := idempotencyFingerprint("request") + var runs atomic.Int32 + call := func(context.Context) (int, error) { return int(runs.Add(1)), nil } + + first, err := c.Do(context.Background(), "k", fp, call, keepAll) + require.NoError(t, err) + again, err := c.Do(context.Background(), "k", fp, call, keepAll) + require.NoError(t, err) + assert.Equal(t, first, again) + assert.EqualValues(t, 1, runs.Load()) + + other, err := c.Do(context.Background(), "other", fp, call, keepAll) + require.NoError(t, err) + assert.Equal(t, 2, other) +} + +func TestIdempotentCallsRejectDifferentRequest(t *testing.T) { + c := newIdempotentCalls[int](4, 4) + call := func(context.Context) (int, error) { return 1, nil } + _, err := c.Do(context.Background(), "k", idempotencyFingerprint("a"), call, keepAll) + require.NoError(t, err) + _, err = c.Do(context.Background(), "k", idempotencyFingerprint("b"), call, keepAll) + assert.ErrorIs(t, err, errIdempotencyKeyReused) +} + +func TestIdempotentCallsReleaseKeyWhenNotKept(t *testing.T) { + c := newIdempotentCalls[int](4, 4) + fp := idempotencyFingerprint("request") + var runs atomic.Int32 + call := func(context.Context) (int, error) { return int(runs.Add(1)), nil } + keepNone := func(int) bool { return false } + + _, err := c.Do(context.Background(), "k", fp, call, keepNone) + require.NoError(t, err) + _, err = c.Do(context.Background(), "k", fp, call, keepAll) + require.NoError(t, err) + assert.EqualValues(t, 2, runs.Load()) + + failing := func(context.Context) (int, error) { runs.Add(1); return 0, errors.New("boom") } + _, err = c.Do(context.Background(), "failing", fp, failing, keepAll) + require.Error(t, err) + _, err = c.Do(context.Background(), "failing", fp, failing, keepAll) + require.Error(t, err) + assert.EqualValues(t, 4, runs.Load()) +} + +func TestIdempotentCallsRecoverPanics(t *testing.T) { + c := newIdempotentCalls[int](4, 4) + fp := idempotencyFingerprint("request") + _, err := c.Do(context.Background(), "k", fp, func(context.Context) (int, error) { panic("boom") }, keepAll) + require.ErrorContains(t, err, "panic: boom") + resp, err := c.Do(context.Background(), "k", fp, func(context.Context) (int, error) { return 1, nil }, keepAll) + require.NoError(t, err) + assert.Equal(t, 1, resp, "a panicked call releases its key") +} + +// A caller that disconnects does not stop the call; a retry gets its result. +func TestIdempotentCallsSurviveCallerCancellation(t *testing.T) { + c := newIdempotentCalls[int](4, 4) + fp := idempotencyFingerprint("request") + release := make(chan struct{}) + var runs atomic.Int32 + call := func(ctx context.Context) (int, error) { + runs.Add(1) + <-release + return 7, ctx.Err() + } + + ctx, cancel := context.WithCancel(context.Background()) + done := make(chan error, 1) + go func() { + _, err := c.Do(ctx, "k", fp, call, keepAll) + done <- err + }() + require.Eventually(t, func() bool { return runs.Load() == 1 }, time.Second, 5*time.Millisecond) + cancel() + assert.ErrorIs(t, <-done, context.Canceled) + + retry := make(chan int, 1) + go func() { + resp, err := c.Do(context.Background(), "k", fp, call, keepAll) + assert.NoError(t, err) + retry <- resp + }() + close(release) + assert.Equal(t, 7, <-retry) + assert.EqualValues(t, 1, runs.Load()) +} + +func TestIdempotentCallsForgetOldResults(t *testing.T) { + c := newIdempotentCalls[int](2, 4) + now := time.Now() + c.now = func() time.Time { return now } + fp := idempotencyFingerprint("request") + var runs atomic.Int32 + call := func(context.Context) (int, error) { return int(runs.Add(1)), nil } + do := func(key string) int { + t.Helper() + resp, err := c.Do(context.Background(), key, fp, call, keepAll) + require.NoError(t, err) + return resp + } + + do("a") + do("b") + do("c") + assert.Equal(t, 4, do("a"), "the oldest result is dropped past the cap") + assert.Equal(t, 3, do("c")) + + now = now.Add(idempotencyRetention + time.Second) + assert.Equal(t, 5, do("c"), "results expire after the retention period") +} + +// A call no caller waits on is cancelled after the grace period, unless a +// retry attaches first. +func TestIdempotentCallsCancelAbandonedCall(t *testing.T) { + c := newIdempotentCalls[int](4, 4) + c.abandonGrace = 100 * time.Millisecond + fp := idempotencyFingerprint("request") + started := make(chan struct{}, 1) + stopped := make(chan error, 1) + hung := func(ctx context.Context) (int, error) { + started <- struct{}{} + <-ctx.Done() + stopped <- context.Cause(ctx) + return 0, context.Cause(ctx) + } + + ctx, cancel := context.WithCancel(context.Background()) + done := make(chan error, 1) + go func() { + _, err := c.Do(ctx, "k", fp, hung, keepAll) + done <- err + }() + <-started + cancel() + require.ErrorIs(t, <-done, context.Canceled) + + // A retry within the grace period keeps the call alive while it waits. + retryCtx, cancelRetry := context.WithTimeout(context.Background(), 300*time.Millisecond) + defer cancelRetry() + _, err := c.Do(retryCtx, "k", fp, hung, keepAll) + require.ErrorIs(t, err, context.DeadlineExceeded) + select { + case <-stopped: + t.Fatal("the call was cancelled while a retry waited on it") + default: + } + + // With no caller left, the call is cancelled after the grace period. + select { + case cause := <-stopped: + assert.ErrorIs(t, cause, errIdempotentCallAbandoned) + case <-time.After(2 * time.Second): + t.Fatal("the abandoned call was not cancelled") + } + require.Eventually(t, func() bool { + c.mu.Lock() + defer c.mu.Unlock() + _, ok := c.calls["k"] + return !ok + }, time.Second, 5*time.Millisecond, "a cancelled call releases its key") +} + +// Pending calls outlive their callers, so new keys are refused past the cap. +// A retry of a pending key still waits for it. +func TestIdempotentCallsCapPending(t *testing.T) { + c := newIdempotentCalls[int](4, 1) + fp := idempotencyFingerprint("request") + release := make(chan struct{}) + blocked := func(context.Context) (int, error) { <-release; return 1, nil } + + ctx, cancel := context.WithCancel(context.Background()) + cancel() + _, err := c.Do(ctx, "running", fp, blocked, keepAll) + require.ErrorIs(t, err, context.Canceled) + + _, err = c.Do(context.Background(), "new", fp, blocked, keepAll) + require.ErrorIs(t, err, errIdempotentCallsBusy) + + retry := make(chan int, 1) + go func() { + resp, err := c.Do(context.Background(), "running", fp, blocked, keepAll) + assert.NoError(t, err) + retry <- resp + }() + close(release) + assert.Equal(t, 1, <-retry) + + resp, err := c.Do(context.Background(), "new", fp, func(context.Context) (int, error) { return 2, nil }, keepAll) + require.NoError(t, err) + assert.Equal(t, 2, resp, "finishing a call frees its pending slot") +} + +func TestValidateIdempotencyKey(t *testing.T) { + assert.NoError(t, validateIdempotencyKey("stainless-node-retry-0f3c2a1e")) + assert.Error(t, validateIdempotencyKey("")) + assert.Error(t, validateIdempotencyKey(strings.Repeat("k", maxIdempotencyKeyLength+1))) + assert.Error(t, validateIdempotencyKey("bad\nkey")) + assert.Error(t, validateIdempotencyKey("ключ")) +} diff --git a/server/cmd/api/api/playwright.go b/server/cmd/api/api/playwright.go index c91f0eb9..74aa545c 100644 --- a/server/cmd/api/api/playwright.go +++ b/server/cmd/api/api/playwright.go @@ -56,7 +56,42 @@ func (s *ApiService) ExecutePlaywrightCode(ctx context.Context, request oapi.Exe if request.Body.Executor != nil { name = *request.Body.Executor } - return s.executePlaywrightOnExecutor(ctx, name, request.Body.Code, timeout) + if request.Params.IdempotencyKey == nil { + return s.executePlaywrightOnExecutor(ctx, name, request.Body.Code, timeout) + } + + key := *request.Params.IdempotencyKey + if err := validateIdempotencyKey(key); err != nil { + return oapi.ExecutePlaywrightCode400JSONResponse{ + BadRequestErrorJSONResponse: oapi.BadRequestErrorJSONResponse{Message: err.Error()}, + }, nil + } + fingerprint := idempotencyFingerprint(struct { + Executor string + Code string + Timeout time.Duration + }{name, request.Body.Code, timeout}) + resp, err := s.playwrightExecutors.idempotent.Do(ctx, key, fingerprint, + func(ctx context.Context) (oapi.ExecutePlaywrightCodeResponseObject, error) { + defer s.holdScaleToZero(ctx)() + return s.executePlaywrightOnExecutor(ctx, name, request.Body.Code, timeout) + }, + func(resp oapi.ExecutePlaywrightCodeResponseObject) bool { + // Every other response is returned before the code reaches an executor. + _, ran := resp.(oapi.ExecutePlaywrightCode200JSONResponse) + return ran + }) + switch { + case errors.Is(err, errIdempotencyKeyReused): + return oapi.ExecutePlaywrightCode422JSONResponse{ + IdempotencyKeyReusedErrorJSONResponse: oapi.IdempotencyKeyReusedErrorJSONResponse{Message: err.Error()}, + }, nil + case errors.Is(err, errIdempotentCallsBusy): + return oapi.ExecutePlaywrightCode429JSONResponse{ + IdempotentCallsBusyErrorJSONResponse: oapi.IdempotentCallsBusyErrorJSONResponse{Message: err.Error()}, + }, nil + } + return resp, err } func playwrightResult(resp *playwrightDaemonResponse) oapi.ExecutePlaywrightResult { diff --git a/server/cmd/api/api/playwright_executors.go b/server/cmd/api/api/playwright_executors.go index 76d49bea..f0a17753 100644 --- a/server/cmd/api/api/playwright_executors.go +++ b/server/cmd/api/api/playwright_executors.go @@ -29,6 +29,12 @@ const ( maxPlaywrightExecutors = 8 + // maxPlaywrightIdempotentResults caps the responses kept for retries across + // all executors, and maxPlaywrightIdempotentPending the keyed calls waiting + // or running. + maxPlaywrightIdempotentResults = 16 + maxPlaywrightIdempotentPending = 32 + // playwrightExecutorResponseGrace is added to the execution timeout when // setting the socket deadline, giving the daemon time to report its own // timeout before the API treats the process as unresponsive. @@ -173,6 +179,8 @@ type playwrightExecutorManager struct { mu sync.Mutex executors map[string]*playwrightExecutor closed bool + + idempotent *idempotentCalls[oapi.ExecutePlaywrightCodeResponseObject] } func newPlaywrightExecutorManager(tabs playwrightExecutorTabs) *playwrightExecutorManager { @@ -182,6 +190,7 @@ func newPlaywrightExecutorManager(tabs playwrightExecutorTabs) *playwrightExecut socketDir: os.TempDir(), responseGrace: playwrightExecutorResponseGrace, executors: make(map[string]*playwrightExecutor), + idempotent: newIdempotentCalls[oapi.ExecutePlaywrightCodeResponseObject](maxPlaywrightIdempotentResults, maxPlaywrightIdempotentPending), } e := newPlaywrightExecutor(defaultPlaywrightExecutor) e.pinned = true diff --git a/server/cmd/api/api/playwright_executors_test.go b/server/cmd/api/api/playwright_executors_test.go index 3a9d0364..3ea443b5 100644 --- a/server/cmd/api/api/playwright_executors_test.go +++ b/server/cmd/api/api/playwright_executors_test.go @@ -9,6 +9,7 @@ import ( "path/filepath" "slices" "sync" + "sync/atomic" "testing" "time" @@ -24,12 +25,14 @@ import ( // kills the process. FAKE_START_DELAY_MS delays listening on the socket. A tab // exists while its file exists in FAKE_TABS_DIR (see // fakeExecutorTabs); a missing tab is answered with tab_missing. Every result -// carries the process ID so tests can tell when a process is replaced. +// carries the process ID so tests can tell when a process is replaced, and the +// number of calls the process has run. const fakePlaywrightDaemon = ` const fs = require('fs'); const net = require('net'); const path = require('path'); const socketPath = process.env.PLAYWRIGHT_DAEMON_SOCKET; +let calls = 0; const server = net.createServer(socket => { let buffer = ''; socket.on('data', data => { @@ -50,10 +53,11 @@ const server = net.createServer(socket => { if (req.code === 'hang') { for (;;) {} } if (req.code === 'exit') { process.exit(1); } const ms = Number(req.code.split(':')[1] || 0); + const call = ++calls; if (ms > req.timeout_ms) { setTimeout(() => respond({ success: false, error: 'timed out', timed_out: true }), req.timeout_ms); } else { - setTimeout(() => respond({ success: true, result: { pid: process.pid } }), ms); + setTimeout(() => respond({ success: true, result: { pid: process.pid, calls: call } }), ms); } } }); @@ -681,3 +685,97 @@ func TestPlaywrightExecutorRejectsCallsAfterShutdown(t *testing.T) { assert.Empty(t, entries, "no tab should be opened after shutdown") assert.Empty(t, m.List()) } + +func TestPlaywrightExecuteIdempotencyKey(t *testing.T) { + m, _ := newTestPlaywrightExecutorManager(t) + svc, err := newSvc(t, recorder.NewFFmpegManager()) + require.NoError(t, err) + svc.playwrightExecutors = m + + execute := func(ctx context.Context, key, code string, executor *string) (oapi.ExecutePlaywrightCodeResponseObject, error) { + request := oapi.ExecutePlaywrightCodeRequestObject{ + Body: &oapi.ExecutePlaywrightCodeJSONRequestBody{Code: code, Executor: executor}, + } + if key != "" { + request.Params.IdempotencyKey = &key + } + return svc.ExecutePlaywrightCode(ctx, request) + } + calls := func(resp oapi.ExecutePlaywrightCodeResponseObject) int { + t.Helper() + ok, isOK := resp.(oapi.ExecutePlaywrightCode200JSONResponse) + require.True(t, isOK, "expected 200, got %T", resp) + require.True(t, ok.Success, "execution failed: %v", ok.Error) + raw, err := json.Marshal(ok.Result) + require.NoError(t, err) + var result struct { + Calls int `json:"calls"` + } + require.NoError(t, json.Unmarshal(raw, &result)) + return result.Calls + } + + stz := &countingScaleToZero{} + svc.stz = stz + + // The first caller disconnects while its call runs; the retry gets that + // call's result instead of running the code again. The call keeps the VM + // awake without its caller. + ctx, cancel := context.WithCancel(context.Background()) + firstDone := make(chan error, 1) + go func() { + _, err := execute(ctx, "k1", "sleep:300", nil) + firstDone <- err + }() + require.Eventually(t, func() bool { return m.List()[0].busy }, 2*time.Second, 5*time.Millisecond) + cancel() + require.ErrorIs(t, <-firstDone, context.Canceled) + assert.EqualValues(t, 1, stz.holds.Load()) + + resp, err := execute(context.Background(), "k1", "sleep:300", nil) + require.NoError(t, err) + assert.Equal(t, 1, calls(resp)) + require.Eventually(t, func() bool { return stz.holds.Load() == 0 }, time.Second, 5*time.Millisecond) + defaultName := defaultPlaywrightExecutor + resp, err = execute(context.Background(), "k1", "sleep:300", &defaultName) + require.NoError(t, err) + assert.Equal(t, 1, calls(resp), "naming the default executor is the same request") + + resp, err = execute(context.Background(), "", "sleep:0", nil) + require.NoError(t, err) + assert.Equal(t, 2, calls(resp), "the retries did not run the code") + + resp, err = execute(context.Background(), "k1", "sleep:0", nil) + require.NoError(t, err) + assert.IsType(t, oapi.ExecutePlaywrightCode422JSONResponse{}, resp) + + resp, err = execute(context.Background(), "bad\nkey", "sleep:0", nil) + require.NoError(t, err) + assert.IsType(t, oapi.ExecutePlaywrightCode400JSONResponse{}, resp) + + // A call rejected before it reaches an executor does not use up its key. + for i := 1; i <= maxPlaywrightExecutors; i++ { + name := fmt.Sprintf("e%d", i) + _, err := execute(context.Background(), "", "sleep:0", &name) + require.NoError(t, err) + } + ninth := "ninth" + resp, err = execute(context.Background(), "k2", "sleep:0", &ninth) + require.NoError(t, err) + assert.IsType(t, oapi.ExecutePlaywrightCode409JSONResponse{}, resp) + _, err = m.Delete(context.Background(), "e1") + require.NoError(t, err) + resp, err = execute(context.Background(), "k2", "sleep:0", &ninth) + require.NoError(t, err) + assert.Equal(t, 1, calls(resp)) +} + +// countingScaleToZero counts holds taken with Disable and released with Enable. +type countingScaleToZero struct { + holds atomic.Int32 +} + +func (c *countingScaleToZero) Disable(context.Context) error { c.holds.Add(1); return nil } +func (c *countingScaleToZero) Enable(context.Context) error { c.holds.Add(-1); return nil } +func (c *countingScaleToZero) Pin(context.Context) error { return nil } +func (c *countingScaleToZero) Unpin(context.Context) error { return nil } diff --git a/server/cmd/api/api/scaletozero.go b/server/cmd/api/api/scaletozero.go index 9e840914..755e0a19 100644 --- a/server/cmd/api/api/scaletozero.go +++ b/server/cmd/api/api/scaletozero.go @@ -2,6 +2,7 @@ package api import ( "context" + "time" "github.com/kernel/kernel-images/server/lib/logger" oapi "github.com/kernel/kernel-images/server/lib/oapi" @@ -22,3 +23,20 @@ func (s *ApiService) EnableScaleToZero(ctx context.Context, _ oapi.EnableScaleTo } return oapi.EnableScaleToZero204Response{}, nil } + +// holdScaleToZero keeps the VM awake until the returned release is called, for +// work that can outlive the request that started it. Failing to take the hold +// is logged rather than failing the work. +func (s *ApiService) holdScaleToZero(ctx context.Context) (release func()) { + if err := s.stz.Disable(ctx); err != nil { + logger.FromContext(ctx).Error("failed to disable scale-to-zero", "err", err) + return func() {} + } + return func() { + releaseCtx, cancel := context.WithTimeout(context.WithoutCancel(ctx), 5*time.Second) + defer cancel() + if err := s.stz.Enable(releaseCtx); err != nil { + logger.FromContext(ctx).Error("failed to enable scale-to-zero", "err", err) + } + } +} diff --git a/server/e2e/e2e_audio_sample_rate_test.go b/server/e2e/e2e_audio_sample_rate_test.go index 2497b5e7..cdbc770d 100644 --- a/server/e2e/e2e_audio_sample_rate_test.go +++ b/server/e2e/e2e_audio_sample_rate_test.go @@ -41,7 +41,7 @@ func TestBrowserAudioSampleRate(t *testing.T) { client, err := c.APIClient() require.NoError(t, err) - rsp, err := client.ExecutePlaywrightCodeWithResponse(ctx, instanceoapi.ExecutePlaywrightCodeJSONRequestBody{ + rsp, err := client.ExecutePlaywrightCodeWithResponse(ctx, nil, instanceoapi.ExecutePlaywrightCodeJSONRequestBody{ Code: fmt.Sprintf(` await page.goto(%q); await context.grantPermissions(['microphone']); diff --git a/server/e2e/e2e_browser_repl_test.go b/server/e2e/e2e_browser_repl_test.go index 3d31e32e..af9e38ed 100644 --- a/server/e2e/e2e_browser_repl_test.go +++ b/server/e2e/e2e_browser_repl_test.go @@ -38,7 +38,7 @@ func replJSONWrite(t *testing.T, r *instanceoapi.BrowserReplResult) any { func executeBrowserRepl(t *testing.T, ctx context.Context, client *instanceoapi.ClientWithResponses, body instanceoapi.ExecuteBrowserReplJSONRequestBody) *instanceoapi.BrowserReplResult { t.Helper() - rsp, err := client.ExecuteBrowserReplWithResponse(ctx, body) + rsp, err := client.ExecuteBrowserReplWithResponse(ctx, nil, body) require.NoError(t, err, "Browser REPL request error: %v", err) require.Equal(t, http.StatusOK, rsp.StatusCode(), "unexpected status for Browser REPL: %s body=%s", rsp.Status(), string(rsp.Body)) require.NotNil(t, rsp.JSON200, "expected JSON200 response, got nil") diff --git a/server/e2e/e2e_chromium_configure_test.go b/server/e2e/e2e_chromium_configure_test.go index 985d1021..a69f05da 100644 --- a/server/e2e/e2e_chromium_configure_test.go +++ b/server/e2e/e2e_chromium_configure_test.go @@ -323,7 +323,7 @@ func TestChromiumConfigureStartURLBare(t *testing.T) { require.Eventually(t, func() bool { timeoutSec := 3 - pwResp, err := client.ExecutePlaywrightCodeWithResponse(ctx, instanceoapi.ExecutePlaywrightRequest{ + pwResp, err := client.ExecutePlaywrightCodeWithResponse(ctx, nil, instanceoapi.ExecutePlaywrightRequest{ Code: "return page.url();", TimeoutSec: &timeoutSec, }) diff --git a/server/e2e/e2e_custom_webmcp_test.go b/server/e2e/e2e_custom_webmcp_test.go index b8efba07..dcfa732f 100644 --- a/server/e2e/e2e_custom_webmcp_test.go +++ b/server/e2e/e2e_custom_webmcp_test.go @@ -59,7 +59,7 @@ func testCustomWebMCPTargetBinding(t *testing.T, ctx context.Context, client *in assert.Fail(collect, "tool not registered on owner tab") }, 10*time.Second, 200*time.Millisecond) - selected, err := client.ExecuteBrowserReplWithResponse(ctx, instanceoapi.ExecuteBrowserReplJSONRequestBody{ + selected, err := client.ExecuteBrowserReplWithResponse(ctx, nil, instanceoapi.ExecuteBrowserReplJSONRequestBody{ Code: `const unrelated = (await listTabs()).find(tab => tab.url.endsWith('/target-binding/other')); if (!unrelated) throw new Error('unrelated tab not found'); await switchTab(unrelated.targetId); @@ -80,7 +80,7 @@ func testCustomWebMCPTargetBinding(t *testing.T, ctx context.Context, client *in require.Equal(t, instanceoapi.WebMCPInvocationResultStatusCompleted, result.JSON200.Status) require.Equal(t, map[string]any{"marker": "owner", "url": urls[0]}, result.JSON200.Output) - attached, err := client.ExecuteBrowserReplWithResponse(ctx, instanceoapi.ExecuteBrowserReplJSONRequestBody{ + attached, err := client.ExecuteBrowserReplWithResponse(ctx, nil, instanceoapi.ExecuteBrowserReplJSONRequestBody{ Code: `const current = await currentTab(); if (!current.url.endsWith('/target-binding/other')) throw new Error('custom tool changed attached tab to ' + current.url);`, @@ -107,7 +107,7 @@ func testCustomWebMCPTargetBinding(t *testing.T, ctx context.Context, client *in func testCustomWebMCPSlowPage(t *testing.T, ctx context.Context, client *instanceoapi.ClientWithResponses) { t.Helper() - patched, err := client.ExecuteBrowserReplWithResponse(ctx, instanceoapi.ExecuteBrowserReplJSONRequestBody{ + patched, err := client.ExecuteBrowserReplWithResponse(ctx, nil, instanceoapi.ExecuteBrowserReplJSONRequestBody{ Code: `const owner = (await listTabs()).find(tab => tab.url.endsWith('/target-binding/owner')); await switchTab(owner.targetId); const tree = await cdp('Page.getFrameTree'); @@ -177,7 +177,7 @@ func testCustomWebMCPSlowPage(t *testing.T, ctx context.Context, client *instanc `, new(bool)) }() - before, err := client.ExecuteBrowserReplWithResponse(ctx, instanceoapi.ExecuteBrowserReplJSONRequestBody{ + before, err := client.ExecuteBrowserReplWithResponse(ctx, nil, instanceoapi.ExecuteBrowserReplJSONRequestBody{ Code: `repl.write('before page invocation');`, }) require.NoError(t, err) @@ -204,7 +204,7 @@ func testCustomWebMCPSlowPage(t *testing.T, ctx context.Context, client *instanc `, new(string)) short := 1 - cell, err := client.ExecuteBrowserReplWithResponse(ctx, instanceoapi.ExecuteBrowserReplJSONRequestBody{ + cell, err := client.ExecuteBrowserReplWithResponse(ctx, nil, instanceoapi.ExecuteBrowserReplJSONRequestBody{ Code: `repl.write('should not run on the wrong tab');`, TimeoutSec: &short, }) require.NoError(t, err) @@ -233,7 +233,7 @@ func testCustomWebMCPSlowPage(t *testing.T, ctx context.Context, client *instanc return owner.evaluate(() => document.body.dataset.slowDone); `, &done) require.Equal(t, "true", done) - after, err := client.ExecuteBrowserReplWithResponse(ctx, instanceoapi.ExecuteBrowserReplJSONRequestBody{Code: `repl.write('still alive');`}) + after, err := client.ExecuteBrowserReplWithResponse(ctx, nil, instanceoapi.ExecuteBrowserReplJSONRequestBody{Code: `repl.write('still alive');`}) require.NoError(t, err) require.Equal(t, http.StatusOK, after.StatusCode(), "%s", after.Body) require.Equal(t, before.JSON200.ReplId, after.JSON200.ReplId) @@ -306,7 +306,7 @@ func testCustomWebMCPInvokesAcrossNavigation(t *testing.T, ctx context.Context, require.Contains(t, *invalid.JSON200.ErrorText, "input failed JSON Schema validation") replTimeout := 20 - replResult, err := client.ExecuteBrowserReplWithResponse(ctx, instanceoapi.ExecuteBrowserReplJSONRequestBody{ + replResult, err := client.ExecuteBrowserReplWithResponse(ctx, nil, instanceoapi.ExecuteBrowserReplJSONRequestBody{ Code: fmt.Sprintf(`const result = await webmcp.invokeTool(%q, {origin: 'SFO'}, {timeoutSec: 10}); if (result.status !== 'completed' || result.output.url !== 'http://127.0.0.1:10001/fixture/results') throw new Error(JSON.stringify(result)); @@ -351,7 +351,7 @@ func testCustomWebMCPInvokesAcrossNavigation(t *testing.T, ctx context.Context, require.NotNil(t, tools.JSON200.Tools[0].Source.TargetId) targetID := *tools.JSON200.Tools[0].Source.TargetId - patched, err := client.ExecuteBrowserReplWithResponse(ctx, instanceoapi.ExecuteBrowserReplJSONRequestBody{ + patched, err := client.ExecuteBrowserReplWithResponse(ctx, nil, instanceoapi.ExecuteBrowserReplJSONRequestBody{ Code: fmt.Sprintf(`await js(() => { const prototype = Object.getPrototypeOf(document.modelContext); const original = prototype.registerTool; @@ -378,7 +378,7 @@ func testCustomWebMCPInvokesAcrossNavigation(t *testing.T, ctx context.Context, for _, tool := range beforeRecovery.JSON200.Tools { require.NotEqual(t, "recover_registration", tool.Tool.Name) } - restored, err := client.ExecuteBrowserReplWithResponse(ctx, instanceoapi.ExecuteBrowserReplJSONRequestBody{ + restored, err := client.ExecuteBrowserReplWithResponse(ctx, nil, instanceoapi.ExecuteBrowserReplJSONRequestBody{ Code: fmt.Sprintf(`await js(() => { window.__allowCustomRegistration = true; }, {targetId: %q});`, targetID), }) require.NoError(t, err) @@ -405,7 +405,7 @@ func testCustomWebMCPInvokesAcrossNavigation(t *testing.T, ctx context.Context, require.Equal(t, http.StatusOK, recovered.StatusCode(), "%s", recovered.Body) require.Equal(t, map[string]any{"origin": "SFO"}, recovered.JSON200.Output) - pageResult, err := client.ExecuteBrowserReplWithResponse(ctx, instanceoapi.ExecuteBrowserReplJSONRequestBody{ + pageResult, err := client.ExecuteBrowserReplWithResponse(ctx, nil, instanceoapi.ExecuteBrowserReplJSONRequestBody{ Code: `const pageTool = (await webmcp.listTools()).find(tool => tool.tool.name === 'recover_registration'); const nativeResult = await webmcp.invokeTool(pageTool.tool_ref, {origin: 'SFO'}); if (nativeResult.status !== 'completed' || nativeResult.output.origin !== 'SFO') throw new Error(JSON.stringify(nativeResult));`, @@ -438,7 +438,7 @@ func testCustomWebMCPInvokesAcrossNavigation(t *testing.T, ctx context.Context, }, 10*time.Second, 200*time.Millisecond) shortTimeout := 3 - deadline, err := client.ExecuteBrowserReplWithResponse(ctx, instanceoapi.ExecuteBrowserReplJSONRequestBody{ + deadline, err := client.ExecuteBrowserReplWithResponse(ctx, nil, instanceoapi.ExecuteBrowserReplJSONRequestBody{ Code: fmt.Sprintf(`try { await webmcp.invokeTool(%q, {}, {timeoutSec:30}); throw new Error('expected a deadline error'); diff --git a/server/e2e/e2e_display_resize_window_test.go b/server/e2e/e2e_display_resize_window_test.go index 34ff5e1c..8009d9b6 100644 --- a/server/e2e/e2e_display_resize_window_test.go +++ b/server/e2e/e2e_display_resize_window_test.go @@ -49,7 +49,7 @@ func getRendererViewport(ctx context.Context, c *TestContainer) (rendererViewpor })); ` timeout := 5 - rsp, err := client.ExecutePlaywrightCodeWithResponse(ctx, instanceoapi.ExecutePlaywrightRequest{ + rsp, err := client.ExecutePlaywrightCodeWithResponse(ctx, nil, instanceoapi.ExecutePlaywrightRequest{ Code: code, TimeoutSec: &timeout, }) @@ -505,7 +505,7 @@ func navigateBlank(t *testing.T, ctx context.Context, c *TestContainer) { require.NoError(t, err) timeout := 5 require.EventuallyWithT(t, func(collect *assert.CollectT) { - rsp, err := client.ExecutePlaywrightCodeWithResponse(ctx, instanceoapi.ExecutePlaywrightRequest{ + rsp, err := client.ExecutePlaywrightCodeWithResponse(ctx, nil, instanceoapi.ExecutePlaywrightRequest{ Code: `await page.goto('about:blank'); return true;`, TimeoutSec: &timeout, }) diff --git a/server/e2e/e2e_playwright_test.go b/server/e2e/e2e_playwright_test.go index a24a60b6..0acf5376 100644 --- a/server/e2e/e2e_playwright_test.go +++ b/server/e2e/e2e_playwright_test.go @@ -52,7 +52,7 @@ func TestPlaywrightExecuteAPI(t *testing.T) { Code: playwrightCode, } - rsp, err := client.ExecutePlaywrightCodeWithResponse(ctx, req) + rsp, err := client.ExecutePlaywrightCodeWithResponse(ctx, nil, req) require.NoError(t, err, "playwright execute request error: %v", err) require.Equal(t, http.StatusOK, rsp.StatusCode(), "unexpected status for playwright execute: %s body=%s", rsp.Status(), string(rsp.Body)) require.NotNil(t, rsp.JSON200, "expected JSON200 response, got nil") @@ -89,7 +89,7 @@ func TestPlaywrightExecuteAPI(t *testing.T) { t.Log("playwright execute API test passed") t.Log("verifying @playwright/test assertions in the Playwright execution scope") - expectRsp, err := client.ExecutePlaywrightCodeWithResponse(ctx, instanceoapi.ExecutePlaywrightCodeJSONRequestBody{ + expectRsp, err := client.ExecutePlaywrightCodeWithResponse(ctx, nil, instanceoapi.ExecutePlaywrightCodeJSONRequestBody{ Code: ` const { expect } = await import('@playwright/test'); await page.setContent('

hello kernel

'); @@ -112,7 +112,7 @@ func TestPlaywrightExecuteAPI(t *testing.T) { require.EqualValues(t, 3, expectRsp.JSON200.Result, "expected expect.poll to run until the condition passed") t.Log("verifying WebMCP helpers in the Playwright execution scope") - webmcpRsp, err := client.ExecutePlaywrightCodeWithResponse(ctx, instanceoapi.ExecutePlaywrightCodeJSONRequestBody{ + webmcpRsp, err := client.ExecutePlaywrightCodeWithResponse(ctx, nil, instanceoapi.ExecutePlaywrightCodeJSONRequestBody{ Code: ` const tools = await webmcp.listTools(); let failure; @@ -157,7 +157,7 @@ func TestPlaywrightExecuteAPI(t *testing.T) { require.NotEmpty(t, helperResult.Failure.Message) t.Log("verifying existing code may declare its own webmcp binding") - shadowedWebMCPRsp, err := client.ExecutePlaywrightCodeWithResponse(ctx, instanceoapi.ExecutePlaywrightCodeJSONRequestBody{ + shadowedWebMCPRsp, err := client.ExecutePlaywrightCodeWithResponse(ctx, nil, instanceoapi.ExecutePlaywrightCodeJSONRequestBody{ Code: ` const webmcp = 'user-defined'; return webmcp; @@ -176,7 +176,7 @@ func TestPlaywrightExecuteAPI(t *testing.T) { // signal). Uses a `data:` URL for the second tab so the assertion doesn't // depend on a second outbound network request. t.Log("verifying page binds to the foreground tab") - openSecondTabRsp, err := client.ExecutePlaywrightCodeWithResponse(ctx, instanceoapi.ExecutePlaywrightCodeJSONRequestBody{ + openSecondTabRsp, err := client.ExecutePlaywrightCodeWithResponse(ctx, nil, instanceoapi.ExecutePlaywrightCodeJSONRequestBody{ Code: ` const second = await context.newPage(); await second.goto('data:text/html,second-tab'); @@ -191,7 +191,7 @@ func TestPlaywrightExecuteAPI(t *testing.T) { // A fresh execute call must bind `page` to the newest tab, which is also // the foreground one right after opening it. - urlRsp, err := client.ExecutePlaywrightCodeWithResponse(ctx, instanceoapi.ExecutePlaywrightCodeJSONRequestBody{ + urlRsp, err := client.ExecutePlaywrightCodeWithResponse(ctx, nil, instanceoapi.ExecutePlaywrightCodeJSONRequestBody{ Code: `return page.url();`, }) require.NoError(t, err, "url request error: %v", err) @@ -206,7 +206,7 @@ func TestPlaywrightExecuteAPI(t *testing.T) { // assumption this change removes. Tab-creation order alone can't // distinguish this case from the one above -- only the CDP `tabActive` // signal can. - bringToFrontRsp, err := client.ExecutePlaywrightCodeWithResponse(ctx, instanceoapi.ExecutePlaywrightCodeJSONRequestBody{ + bringToFrontRsp, err := client.ExecutePlaywrightCodeWithResponse(ctx, nil, instanceoapi.ExecutePlaywrightCodeJSONRequestBody{ Code: ` const first = context.pages().find(candidate => candidate.url().includes('example.com') @@ -221,7 +221,7 @@ func TestPlaywrightExecuteAPI(t *testing.T) { require.NotNil(t, bringToFrontRsp.JSON200) require.True(t, bringToFrontRsp.JSON200.Success, "expected bring-to-front success=true") - refocusedUrlRsp, err := client.ExecutePlaywrightCodeWithResponse(ctx, instanceoapi.ExecutePlaywrightCodeJSONRequestBody{ + refocusedUrlRsp, err := client.ExecutePlaywrightCodeWithResponse(ctx, nil, instanceoapi.ExecutePlaywrightCodeJSONRequestBody{ Code: `return page.url();`, }) require.NoError(t, err, "refocused url request error: %v", err) @@ -235,7 +235,7 @@ func TestPlaywrightExecuteAPI(t *testing.T) { t.Log("verifying page resolution across browser contexts") // Keep a newer blank page behind the foreground page so the newest-page // fallback cannot satisfy the active-page assertion. - openSecondContextRsp, err := client.ExecutePlaywrightCodeWithResponse(ctx, instanceoapi.ExecutePlaywrightCodeJSONRequestBody{ + openSecondContextRsp, err := client.ExecutePlaywrightCodeWithResponse(ctx, nil, instanceoapi.ExecutePlaywrightCodeJSONRequestBody{ Code: ` const firstContext = browser.contexts()[0]; const secondContext = await browser.newContext(); @@ -268,7 +268,7 @@ func TestPlaywrightExecuteAPI(t *testing.T) { require.Zero(t, setupResult.FirstContextPageCount, "expected the first context to remain open without pages") require.Equal(t, 2, setupResult.SecondContextPageCount, "expected a foreground page and a newer fallback page in the second context") - crossContextRsp, err := client.ExecutePlaywrightCodeWithResponse(ctx, instanceoapi.ExecutePlaywrightCodeJSONRequestBody{ + crossContextRsp, err := client.ExecutePlaywrightCodeWithResponse(ctx, nil, instanceoapi.ExecutePlaywrightCodeJSONRequestBody{ Code: `return { url: page.url(), contextPageUrls: page.context().pages().map(candidate => candidate.url()) };`, }) require.NoError(t, err, "cross-context request error: %v", err) @@ -332,7 +332,7 @@ func TestPlaywrightExecuteTimeoutReturnsPromptlyAndRecovers(t *testing.T) { setupReq := instanceoapi.ExecutePlaywrightCodeJSONRequestBody{ Code: `return await page.evaluate(() => document.body.dataset.timeoutMutation = "initial");`, } - setupRsp, err := client.ExecutePlaywrightCodeWithResponse(ctx, setupReq) + setupRsp, err := client.ExecutePlaywrightCodeWithResponse(ctx, nil, setupReq) require.NoError(t, err) require.Equal(t, http.StatusOK, setupRsp.StatusCode()) require.NotNil(t, setupRsp.JSON200) @@ -349,7 +349,7 @@ await page.evaluate(() => document.body.dataset.timeoutMutation = "late"); t.Log("executing playwright code expected to exceed timeout") start := time.Now() - timeoutRsp, err := client.ExecutePlaywrightCodeWithResponse(ctx, timeoutReq) + timeoutRsp, err := client.ExecutePlaywrightCodeWithResponse(ctx, nil, timeoutReq) elapsed := time.Since(start) require.NoError(t, err, "playwright timeout request should return an API response") @@ -368,7 +368,7 @@ await page.evaluate(() => document.body.dataset.timeoutMutation = "late"); } t.Log("executing normal playwright code after timed-out request") - recoveryRsp, err := client.ExecutePlaywrightCodeWithResponse(ctx, recoveryReq) + recoveryRsp, err := client.ExecutePlaywrightCodeWithResponse(ctx, nil, recoveryReq) require.NoError(t, err, "playwright recovery request error: %v", err) require.Equal(t, http.StatusOK, recoveryRsp.StatusCode(), "unexpected status for playwright recovery execute: %s body=%s", recoveryRsp.Status(), string(recoveryRsp.Body)) require.NotNil(t, recoveryRsp.JSON200, "expected JSON200 recovery response, got nil") @@ -384,7 +384,7 @@ await page.evaluate(() => document.body.dataset.timeoutMutation = "late"); // Wait past the abandoned script's delay. A response-only timeout lets that // script wake up and mutate the page after the caller has moved on. time.Sleep(2 * time.Second) - lateRsp, err := client.ExecutePlaywrightCodeWithResponse(ctx, recoveryReq) + lateRsp, err := client.ExecutePlaywrightCodeWithResponse(ctx, nil, recoveryReq) require.NoError(t, err) require.Equal(t, http.StatusOK, lateRsp.StatusCode()) require.NotNil(t, lateRsp.JSON200) @@ -400,7 +400,7 @@ await page.evaluate(() => document.body.dataset.timeoutMutation = "late"); Code: `while (true) {}`, TimeoutSec: &timeoutSec, } - blockedRsp, err := client.ExecutePlaywrightCodeWithResponse(ctx, blockedReq) + blockedRsp, err := client.ExecutePlaywrightCodeWithResponse(ctx, nil, blockedReq) require.NoError(t, err) require.Equal(t, http.StatusOK, blockedRsp.StatusCode()) require.NotNil(t, blockedRsp.JSON200) @@ -408,7 +408,7 @@ await page.evaluate(() => document.body.dataset.timeoutMutation = "late"); for i := range 3 { start := time.Now() - rsp, err := client.ExecutePlaywrightCodeWithResponse(ctx, recoveryReq) + rsp, err := client.ExecutePlaywrightCodeWithResponse(ctx, nil, recoveryReq) require.NoError(t, err) require.Equal(t, http.StatusOK, rsp.StatusCode()) require.NotNil(t, rsp.JSON200) @@ -447,7 +447,7 @@ func TestPlaywrightDaemonRecovery(t *testing.T) { code := `return await page.evaluate(() => navigator.userAgent);` req := instanceoapi.ExecutePlaywrightCodeJSONRequestBody{Code: code} - rsp, err := client.ExecutePlaywrightCodeWithResponse(ctx, req) + rsp, err := client.ExecutePlaywrightCodeWithResponse(ctx, nil, req) if err != nil { return fmt.Errorf("request error: %w", err) } @@ -561,7 +561,7 @@ func testPlaywrightExecutors(t *testing.T, ctx context.Context, client *instance if executor != "" { body.Executor = &executor } - rsp, err := client.ExecutePlaywrightCodeWithResponse(ctx, body) + rsp, err := client.ExecutePlaywrightCodeWithResponse(ctx, nil, body) require.NoError(t, err) require.Equal(t, http.StatusOK, rsp.StatusCode(), "body=%s", string(rsp.Body)) require.NotNil(t, rsp.JSON200) @@ -623,7 +623,7 @@ func testPlaywrightExecutors(t *testing.T, ctx context.Context, client *instance t.Log("verifying an executor keeps its process and tab after a timeout") before := execute("a", `return process.pid;`) timeoutSec := 1 - timedOutRsp, err := client.ExecutePlaywrightCodeWithResponse(ctx, instanceoapi.ExecutePlaywrightCodeJSONRequestBody{ + timedOutRsp, err := client.ExecutePlaywrightCodeWithResponse(ctx, nil, instanceoapi.ExecutePlaywrightCodeJSONRequestBody{ Code: `await page.waitForTimeout(3000);`, Executor: lo.ToPtr("a"), TimeoutSec: &timeoutSec, diff --git a/server/e2e/e2e_recording_audio_test.go b/server/e2e/e2e_recording_audio_test.go index ad76633f..428cc503 100644 --- a/server/e2e/e2e_recording_audio_test.go +++ b/server/e2e/e2e_recording_audio_test.go @@ -191,7 +191,7 @@ func recordReplayAudio(t *testing.T, ctx context.Context, c *TestContainer, play }() playwrightStart := time.Now() - runResp, err := client.ExecutePlaywrightCodeWithResponse(ctx, instanceoapi.ExecutePlaywrightCodeJSONRequestBody{ + runResp, err := client.ExecutePlaywrightCodeWithResponse(ctx, nil, instanceoapi.ExecutePlaywrightCodeJSONRequestBody{ Code: playwrightCode, }) t.Logf("[replay-audio] playwright took %s", time.Since(playwrightStart)) diff --git a/server/e2e/e2e_webmcp_test.go b/server/e2e/e2e_webmcp_test.go index ac73d4d9..e7a622cd 100644 --- a/server/e2e/e2e_webmcp_test.go +++ b/server/e2e/e2e_webmcp_test.go @@ -159,7 +159,7 @@ func testWebMCPDeclarative(t *testing.T, ctx context.Context, client *instanceoa func executeWebMCPPlaywright(t *testing.T, ctx context.Context, client *instanceoapi.ClientWithResponses, code string, result any) { t.Helper() - rsp, err := client.ExecutePlaywrightCodeWithResponse(ctx, instanceoapi.ExecutePlaywrightCodeJSONRequestBody{Code: code}) + rsp, err := client.ExecutePlaywrightCodeWithResponse(ctx, nil, instanceoapi.ExecutePlaywrightCodeJSONRequestBody{Code: code}) require.NoError(t, err) require.Equal(t, http.StatusOK, rsp.StatusCode(), "%s", rsp.Body) require.NotNil(t, rsp.JSON200) diff --git a/server/e2e/e2e_zip_transfer_bench_test.go b/server/e2e/e2e_zip_transfer_bench_test.go index dc72fce6..bd873317 100644 --- a/server/e2e/e2e_zip_transfer_bench_test.go +++ b/server/e2e/e2e_zip_transfer_bench_test.go @@ -212,7 +212,7 @@ func populateUserData(ctx context.Context, client *instanceoapi.ClientWithRespon return result; ` req := instanceoapi.ExecutePlaywrightCodeJSONRequestBody{Code: code} - rsp, err := client.ExecutePlaywrightCodeWithResponse(ctx, req) + rsp, err := client.ExecutePlaywrightCodeWithResponse(ctx, nil, req) if err != nil { return fmt.Errorf("playwright execute failed: %w", err) } diff --git a/server/lib/oapi/oapi.go b/server/lib/oapi/oapi.go index e0f6bad8..db5e4f7e 100644 --- a/server/lib/oapi/oapi.go +++ b/server/lib/oapi/oapi.go @@ -7235,12 +7235,21 @@ type WriteClipboardRequest struct { Text string `json:"text"` } +// IdempotencyKey defines model for IdempotencyKey. +type IdempotencyKey = string + // BadRequestError defines model for BadRequestError. type BadRequestError = Error // ConflictError defines model for ConflictError. type ConflictError = Error +// IdempotencyKeyReusedError defines model for IdempotencyKeyReusedError. +type IdempotencyKeyReusedError = Error + +// IdempotentCallsBusyError defines model for IdempotentCallsBusyError. +type IdempotentCallsBusyError = Error + // InternalError defines model for InternalError. type InternalError = Error @@ -7384,6 +7393,18 @@ type LogsStreamParams struct { // LogsStreamParamsSource defines parameters for LogsStream. type LogsStreamParamsSource string +// ExecutePlaywrightCodeParams defines parameters for ExecutePlaywrightCode. +type ExecutePlaywrightCodeParams struct { + // IdempotencyKey Makes retrying the call safe. A call with a key already used returns the first call's + // response instead of running the code again, waiting for it if it is still running. A call + // with a key keeps running for 10 seconds after its last caller disconnects, so a retry can + // collect its response; after that it is cancelled like a call without a key. A response is + // kept for 10 minutes once the call finishes, and only the most recent responses are kept. A call that did not run, + // such as one rejected with 400, 409 or 429, does not use up its key. Keys are scoped to this + // endpoint and are lost when the API process restarts. + IdempotencyKey *IdempotencyKey `json:"Idempotency-Key,omitempty"` +} + // DeletePlaywrightExecutorParams defines parameters for DeletePlaywrightExecutor. type DeletePlaywrightExecutorParams struct { // CloseTab Close the executor's tab. Defaults to true. @@ -7405,6 +7426,18 @@ type DownloadRecordingParams struct { Id *string `form:"id,omitempty" json:"id,omitempty"` } +// ExecuteBrowserReplParams defines parameters for ExecuteBrowserRepl. +type ExecuteBrowserReplParams struct { + // IdempotencyKey Makes retrying the call safe. A call with a key already used returns the first call's + // response instead of running the code again, waiting for it if it is still running. A call + // with a key keeps running for 10 seconds after its last caller disconnects, so a retry can + // collect its response; after that it is cancelled like a call without a key. A response is + // kept for 10 minutes once the call finishes, and only the most recent responses are kept. A call that did not run, + // such as one rejected with 400, 409 or 429, does not use up its key. Keys are scoped to this + // endpoint and are lost when the API process restarts. + IdempotencyKey *IdempotencyKey `json:"Idempotency-Key,omitempty"` +} + // StreamTelemetryEventsParams defines parameters for StreamTelemetryEvents. type StreamTelemetryEventsParams struct { // Replay Pass `all` to start from the oldest retained event. Ring buffer caps at 1024; older events are evicted and surface as a first `id` greater than 1. @@ -10158,9 +10191,9 @@ type ClientInterface interface { PutNetworkEgressPolicy(ctx context.Context, body PutNetworkEgressPolicyJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) // ExecutePlaywrightCodeWithBody request with any body - ExecutePlaywrightCodeWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) + ExecutePlaywrightCodeWithBody(ctx context.Context, params *ExecutePlaywrightCodeParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) - ExecutePlaywrightCode(ctx context.Context, body ExecutePlaywrightCodeJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) + ExecutePlaywrightCode(ctx context.Context, params *ExecutePlaywrightCodeParams, body ExecutePlaywrightCodeJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) // ListPlaywrightExecutors request ListPlaywrightExecutors(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error) @@ -10226,9 +10259,9 @@ type ClientInterface interface { StopRecording(ctx context.Context, body StopRecordingJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) // ExecuteBrowserReplWithBody request with any body - ExecuteBrowserReplWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) + ExecuteBrowserReplWithBody(ctx context.Context, params *ExecuteBrowserReplParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) - ExecuteBrowserRepl(ctx context.Context, body ExecuteBrowserReplJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) + ExecuteBrowserRepl(ctx context.Context, params *ExecuteBrowserReplParams, body ExecuteBrowserReplJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) // DisableScaleToZero request DisableScaleToZero(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error) @@ -11014,8 +11047,8 @@ func (c *Client) PutNetworkEgressPolicy(ctx context.Context, body PutNetworkEgre return c.Client.Do(req) } -func (c *Client) ExecutePlaywrightCodeWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) { - req, err := NewExecutePlaywrightCodeRequestWithBody(c.Server, contentType, body) +func (c *Client) ExecutePlaywrightCodeWithBody(ctx context.Context, params *ExecutePlaywrightCodeParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) { + req, err := NewExecutePlaywrightCodeRequestWithBody(c.Server, params, contentType, body) if err != nil { return nil, err } @@ -11026,8 +11059,8 @@ func (c *Client) ExecutePlaywrightCodeWithBody(ctx context.Context, contentType return c.Client.Do(req) } -func (c *Client) ExecutePlaywrightCode(ctx context.Context, body ExecutePlaywrightCodeJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) { - req, err := NewExecutePlaywrightCodeRequest(c.Server, body) +func (c *Client) ExecutePlaywrightCode(ctx context.Context, params *ExecutePlaywrightCodeParams, body ExecutePlaywrightCodeJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) { + req, err := NewExecutePlaywrightCodeRequest(c.Server, params, body) if err != nil { return nil, err } @@ -11326,8 +11359,8 @@ func (c *Client) StopRecording(ctx context.Context, body StopRecordingJSONReques return c.Client.Do(req) } -func (c *Client) ExecuteBrowserReplWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) { - req, err := NewExecuteBrowserReplRequestWithBody(c.Server, contentType, body) +func (c *Client) ExecuteBrowserReplWithBody(ctx context.Context, params *ExecuteBrowserReplParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) { + req, err := NewExecuteBrowserReplRequestWithBody(c.Server, params, contentType, body) if err != nil { return nil, err } @@ -11338,8 +11371,8 @@ func (c *Client) ExecuteBrowserReplWithBody(ctx context.Context, contentType str return c.Client.Do(req) } -func (c *Client) ExecuteBrowserRepl(ctx context.Context, body ExecuteBrowserReplJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) { - req, err := NewExecuteBrowserReplRequest(c.Server, body) +func (c *Client) ExecuteBrowserRepl(ctx context.Context, params *ExecuteBrowserReplParams, body ExecuteBrowserReplJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) { + req, err := NewExecuteBrowserReplRequest(c.Server, params, body) if err != nil { return nil, err } @@ -13188,18 +13221,18 @@ func NewPutNetworkEgressPolicyRequestWithBody(server string, contentType string, } // NewExecutePlaywrightCodeRequest calls the generic ExecutePlaywrightCode builder with application/json body -func NewExecutePlaywrightCodeRequest(server string, body ExecutePlaywrightCodeJSONRequestBody) (*http.Request, error) { +func NewExecutePlaywrightCodeRequest(server string, params *ExecutePlaywrightCodeParams, body ExecutePlaywrightCodeJSONRequestBody) (*http.Request, error) { var bodyReader io.Reader buf, err := json.Marshal(body) if err != nil { return nil, err } bodyReader = bytes.NewReader(buf) - return NewExecutePlaywrightCodeRequestWithBody(server, "application/json", bodyReader) + return NewExecutePlaywrightCodeRequestWithBody(server, params, "application/json", bodyReader) } // NewExecutePlaywrightCodeRequestWithBody generates requests for ExecutePlaywrightCode with any type of body -func NewExecutePlaywrightCodeRequestWithBody(server string, contentType string, body io.Reader) (*http.Request, error) { +func NewExecutePlaywrightCodeRequestWithBody(server string, params *ExecutePlaywrightCodeParams, contentType string, body io.Reader) (*http.Request, error) { var err error serverURL, err := url.Parse(server) @@ -13224,6 +13257,21 @@ func NewExecutePlaywrightCodeRequestWithBody(server string, contentType string, req.Header.Add("Content-Type", contentType) + if params != nil { + + if params.IdempotencyKey != nil { + var headerParam0 string + + headerParam0, err = runtime.StyleParamWithOptions("simple", false, "Idempotency-Key", *params.IdempotencyKey, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationHeader, Type: "string", Format: ""}) + if err != nil { + return nil, err + } + + req.Header.Set("Idempotency-Key", headerParam0) + } + + } + return req, nil } @@ -13873,18 +13921,18 @@ func NewStopRecordingRequestWithBody(server string, contentType string, body io. } // NewExecuteBrowserReplRequest calls the generic ExecuteBrowserRepl builder with application/json body -func NewExecuteBrowserReplRequest(server string, body ExecuteBrowserReplJSONRequestBody) (*http.Request, error) { +func NewExecuteBrowserReplRequest(server string, params *ExecuteBrowserReplParams, body ExecuteBrowserReplJSONRequestBody) (*http.Request, error) { var bodyReader io.Reader buf, err := json.Marshal(body) if err != nil { return nil, err } bodyReader = bytes.NewReader(buf) - return NewExecuteBrowserReplRequestWithBody(server, "application/json", bodyReader) + return NewExecuteBrowserReplRequestWithBody(server, params, "application/json", bodyReader) } // NewExecuteBrowserReplRequestWithBody generates requests for ExecuteBrowserRepl with any type of body -func NewExecuteBrowserReplRequestWithBody(server string, contentType string, body io.Reader) (*http.Request, error) { +func NewExecuteBrowserReplRequestWithBody(server string, params *ExecuteBrowserReplParams, contentType string, body io.Reader) (*http.Request, error) { var err error serverURL, err := url.Parse(server) @@ -13909,6 +13957,21 @@ func NewExecuteBrowserReplRequestWithBody(server string, contentType string, bod req.Header.Add("Content-Type", contentType) + if params != nil { + + if params.IdempotencyKey != nil { + var headerParam0 string + + headerParam0, err = runtime.StyleParamWithOptions("simple", false, "Idempotency-Key", *params.IdempotencyKey, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationHeader, Type: "string", Format: ""}) + if err != nil { + return nil, err + } + + req.Header.Set("Idempotency-Key", headerParam0) + } + + } + return req, nil } @@ -14613,9 +14676,9 @@ type ClientWithResponsesInterface interface { PutNetworkEgressPolicyWithResponse(ctx context.Context, body PutNetworkEgressPolicyJSONRequestBody, reqEditors ...RequestEditorFn) (*PutNetworkEgressPolicyResponse, error) // ExecutePlaywrightCodeWithBodyWithResponse request with any body - ExecutePlaywrightCodeWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*ExecutePlaywrightCodeResponse, error) + ExecutePlaywrightCodeWithBodyWithResponse(ctx context.Context, params *ExecutePlaywrightCodeParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*ExecutePlaywrightCodeResponse, error) - ExecutePlaywrightCodeWithResponse(ctx context.Context, body ExecutePlaywrightCodeJSONRequestBody, reqEditors ...RequestEditorFn) (*ExecutePlaywrightCodeResponse, error) + ExecutePlaywrightCodeWithResponse(ctx context.Context, params *ExecutePlaywrightCodeParams, body ExecutePlaywrightCodeJSONRequestBody, reqEditors ...RequestEditorFn) (*ExecutePlaywrightCodeResponse, error) // ListPlaywrightExecutorsWithResponse request ListPlaywrightExecutorsWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*ListPlaywrightExecutorsResponse, error) @@ -14681,9 +14744,9 @@ type ClientWithResponsesInterface interface { StopRecordingWithResponse(ctx context.Context, body StopRecordingJSONRequestBody, reqEditors ...RequestEditorFn) (*StopRecordingResponse, error) // ExecuteBrowserReplWithBodyWithResponse request with any body - ExecuteBrowserReplWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*ExecuteBrowserReplResponse, error) + ExecuteBrowserReplWithBodyWithResponse(ctx context.Context, params *ExecuteBrowserReplParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*ExecuteBrowserReplResponse, error) - ExecuteBrowserReplWithResponse(ctx context.Context, body ExecuteBrowserReplJSONRequestBody, reqEditors ...RequestEditorFn) (*ExecuteBrowserReplResponse, error) + ExecuteBrowserReplWithResponse(ctx context.Context, params *ExecuteBrowserReplParams, body ExecuteBrowserReplJSONRequestBody, reqEditors ...RequestEditorFn) (*ExecuteBrowserReplResponse, error) // DisableScaleToZeroWithResponse request DisableScaleToZeroWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*DisableScaleToZeroResponse, error) @@ -15691,6 +15754,8 @@ type ExecutePlaywrightCodeResponse struct { JSON200 *ExecutePlaywrightResult JSON400 *BadRequestError JSON409 *PlaywrightExecutorLimitError + JSON422 *IdempotencyKeyReusedError + JSON429 *IdempotentCallsBusyError JSON500 *InternalError } @@ -16081,6 +16146,8 @@ type ExecuteBrowserReplResponse struct { JSON200 *BrowserReplResult JSON400 *BadRequestError JSON413 *BadRequestError + JSON422 *IdempotencyKeyReusedError + JSON429 *IdempotentCallsBusyError JSON500 *InternalError } @@ -16937,16 +17004,16 @@ func (c *ClientWithResponses) PutNetworkEgressPolicyWithResponse(ctx context.Con } // ExecutePlaywrightCodeWithBodyWithResponse request with arbitrary body returning *ExecutePlaywrightCodeResponse -func (c *ClientWithResponses) ExecutePlaywrightCodeWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*ExecutePlaywrightCodeResponse, error) { - rsp, err := c.ExecutePlaywrightCodeWithBody(ctx, contentType, body, reqEditors...) +func (c *ClientWithResponses) ExecutePlaywrightCodeWithBodyWithResponse(ctx context.Context, params *ExecutePlaywrightCodeParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*ExecutePlaywrightCodeResponse, error) { + rsp, err := c.ExecutePlaywrightCodeWithBody(ctx, params, contentType, body, reqEditors...) if err != nil { return nil, err } return ParseExecutePlaywrightCodeResponse(rsp) } -func (c *ClientWithResponses) ExecutePlaywrightCodeWithResponse(ctx context.Context, body ExecutePlaywrightCodeJSONRequestBody, reqEditors ...RequestEditorFn) (*ExecutePlaywrightCodeResponse, error) { - rsp, err := c.ExecutePlaywrightCode(ctx, body, reqEditors...) +func (c *ClientWithResponses) ExecutePlaywrightCodeWithResponse(ctx context.Context, params *ExecutePlaywrightCodeParams, body ExecutePlaywrightCodeJSONRequestBody, reqEditors ...RequestEditorFn) (*ExecutePlaywrightCodeResponse, error) { + rsp, err := c.ExecutePlaywrightCode(ctx, params, body, reqEditors...) if err != nil { return nil, err } @@ -17161,16 +17228,16 @@ func (c *ClientWithResponses) StopRecordingWithResponse(ctx context.Context, bod } // ExecuteBrowserReplWithBodyWithResponse request with arbitrary body returning *ExecuteBrowserReplResponse -func (c *ClientWithResponses) ExecuteBrowserReplWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*ExecuteBrowserReplResponse, error) { - rsp, err := c.ExecuteBrowserReplWithBody(ctx, contentType, body, reqEditors...) +func (c *ClientWithResponses) ExecuteBrowserReplWithBodyWithResponse(ctx context.Context, params *ExecuteBrowserReplParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*ExecuteBrowserReplResponse, error) { + rsp, err := c.ExecuteBrowserReplWithBody(ctx, params, contentType, body, reqEditors...) if err != nil { return nil, err } return ParseExecuteBrowserReplResponse(rsp) } -func (c *ClientWithResponses) ExecuteBrowserReplWithResponse(ctx context.Context, body ExecuteBrowserReplJSONRequestBody, reqEditors ...RequestEditorFn) (*ExecuteBrowserReplResponse, error) { - rsp, err := c.ExecuteBrowserRepl(ctx, body, reqEditors...) +func (c *ClientWithResponses) ExecuteBrowserReplWithResponse(ctx context.Context, params *ExecuteBrowserReplParams, body ExecuteBrowserReplJSONRequestBody, reqEditors ...RequestEditorFn) (*ExecuteBrowserReplResponse, error) { + rsp, err := c.ExecuteBrowserRepl(ctx, params, body, reqEditors...) if err != nil { return nil, err } @@ -18872,6 +18939,20 @@ func ParseExecutePlaywrightCodeResponse(rsp *http.Response) (*ExecutePlaywrightC } response.JSON409 = &dest + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 422: + var dest IdempotencyKeyReusedError + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON422 = &dest + + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 429: + var dest IdempotentCallsBusyError + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON429 = &dest + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 500: var dest InternalError if err := json.Unmarshal(bodyBytes, &dest); err != nil { @@ -19554,6 +19635,20 @@ func ParseExecuteBrowserReplResponse(rsp *http.Response) (*ExecuteBrowserReplRes } response.JSON413 = &dest + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 422: + var dest IdempotencyKeyReusedError + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON422 = &dest + + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 429: + var dest IdempotentCallsBusyError + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON429 = &dest + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 500: var dest InternalError if err := json.Unmarshal(bodyBytes, &dest); err != nil { @@ -20179,7 +20274,7 @@ type ServerInterface interface { PutNetworkEgressPolicy(w http.ResponseWriter, r *http.Request) // Execute Playwright/TypeScript code against the browser // (POST /playwright/execute) - ExecutePlaywrightCode(w http.ResponseWriter, r *http.Request) + ExecutePlaywrightCode(w http.ResponseWriter, r *http.Request, params ExecutePlaywrightCodeParams) // List Playwright executors // (GET /playwright/executors) ListPlaywrightExecutors(w http.ResponseWriter, r *http.Request) @@ -20227,7 +20322,7 @@ type ServerInterface interface { StopRecording(w http.ResponseWriter, r *http.Request) // Execute JavaScript in the Browser REPL // (POST /repl) - ExecuteBrowserRepl(w http.ResponseWriter, r *http.Request) + ExecuteBrowserRepl(w http.ResponseWriter, r *http.Request, params ExecuteBrowserReplParams) // Idempotently disable scale to zero on this VM. // (POST /scaletozero/disable) DisableScaleToZero(w http.ResponseWriter, r *http.Request) @@ -20515,7 +20610,7 @@ func (_ Unimplemented) PutNetworkEgressPolicy(w http.ResponseWriter, r *http.Req // Execute Playwright/TypeScript code against the browser // (POST /playwright/execute) -func (_ Unimplemented) ExecutePlaywrightCode(w http.ResponseWriter, r *http.Request) { +func (_ Unimplemented) ExecutePlaywrightCode(w http.ResponseWriter, r *http.Request, params ExecutePlaywrightCodeParams) { w.WriteHeader(http.StatusNotImplemented) } @@ -20611,7 +20706,7 @@ func (_ Unimplemented) StopRecording(w http.ResponseWriter, r *http.Request) { // Execute JavaScript in the Browser REPL // (POST /repl) -func (_ Unimplemented) ExecuteBrowserRepl(w http.ResponseWriter, r *http.Request) { +func (_ Unimplemented) ExecuteBrowserRepl(w http.ResponseWriter, r *http.Request, params ExecuteBrowserReplParams) { w.WriteHeader(http.StatusNotImplemented) } @@ -21480,8 +21575,34 @@ func (siw *ServerInterfaceWrapper) PutNetworkEgressPolicy(w http.ResponseWriter, // ExecutePlaywrightCode operation middleware func (siw *ServerInterfaceWrapper) ExecutePlaywrightCode(w http.ResponseWriter, r *http.Request) { + var err error + + // Parameter object where we will unmarshal all parameters from the context + var params ExecutePlaywrightCodeParams + + headers := r.Header + + // ------------- Optional header parameter "Idempotency-Key" ------------- + if valueList, found := headers[http.CanonicalHeaderKey("Idempotency-Key")]; found { + var IdempotencyKey IdempotencyKey + n := len(valueList) + if n != 1 { + siw.ErrorHandlerFunc(w, r, &TooManyValuesForParamError{ParamName: "Idempotency-Key", Count: n}) + return + } + + err = runtime.BindStyledParameterWithOptions("simple", "Idempotency-Key", valueList[0], &IdempotencyKey, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationHeader, Explode: false, Required: false, Type: "string", Format: ""}) + if err != nil { + siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "Idempotency-Key", Err: err}) + return + } + + params.IdempotencyKey = &IdempotencyKey + + } + handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { - siw.Handler.ExecutePlaywrightCode(w, r) + siw.Handler.ExecutePlaywrightCode(w, r, params) })) for _, middleware := range siw.HandlerMiddlewares { @@ -21826,8 +21947,34 @@ func (siw *ServerInterfaceWrapper) StopRecording(w http.ResponseWriter, r *http. // ExecuteBrowserRepl operation middleware func (siw *ServerInterfaceWrapper) ExecuteBrowserRepl(w http.ResponseWriter, r *http.Request) { + var err error + + // Parameter object where we will unmarshal all parameters from the context + var params ExecuteBrowserReplParams + + headers := r.Header + + // ------------- Optional header parameter "Idempotency-Key" ------------- + if valueList, found := headers[http.CanonicalHeaderKey("Idempotency-Key")]; found { + var IdempotencyKey IdempotencyKey + n := len(valueList) + if n != 1 { + siw.ErrorHandlerFunc(w, r, &TooManyValuesForParamError{ParamName: "Idempotency-Key", Count: n}) + return + } + + err = runtime.BindStyledParameterWithOptions("simple", "Idempotency-Key", valueList[0], &IdempotencyKey, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationHeader, Explode: false, Required: false, Type: "string", Format: ""}) + if err != nil { + siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "Idempotency-Key", Err: err}) + return + } + + params.IdempotencyKey = &IdempotencyKey + + } + handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { - siw.Handler.ExecuteBrowserRepl(w, r) + siw.Handler.ExecuteBrowserRepl(w, r, params) })) for _, middleware := range siw.HandlerMiddlewares { @@ -22408,6 +22555,10 @@ type BadRequestErrorJSONResponse Error type ConflictErrorJSONResponse Error +type IdempotencyKeyReusedErrorJSONResponse Error + +type IdempotentCallsBusyErrorJSONResponse Error + type InternalErrorJSONResponse Error type NotFoundErrorJSONResponse Error @@ -24029,7 +24180,8 @@ func (response PutNetworkEgressPolicy500JSONResponse) VisitPutNetworkEgressPolic } type ExecutePlaywrightCodeRequestObject struct { - Body *ExecutePlaywrightCodeJSONRequestBody + Params ExecutePlaywrightCodeParams + Body *ExecutePlaywrightCodeJSONRequestBody } type ExecutePlaywrightCodeResponseObject interface { @@ -24063,6 +24215,28 @@ func (response ExecutePlaywrightCode409JSONResponse) VisitExecutePlaywrightCodeR return json.NewEncoder(w).Encode(response) } +type ExecutePlaywrightCode422JSONResponse struct { + IdempotencyKeyReusedErrorJSONResponse +} + +func (response ExecutePlaywrightCode422JSONResponse) VisitExecutePlaywrightCodeResponse(w http.ResponseWriter) error { + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(422) + + return json.NewEncoder(w).Encode(response) +} + +type ExecutePlaywrightCode429JSONResponse struct { + IdempotentCallsBusyErrorJSONResponse +} + +func (response ExecutePlaywrightCode429JSONResponse) VisitExecutePlaywrightCodeResponse(w http.ResponseWriter) error { + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(429) + + return json.NewEncoder(w).Encode(response) +} + type ExecutePlaywrightCode500JSONResponse struct{ InternalErrorJSONResponse } func (response ExecutePlaywrightCode500JSONResponse) VisitExecutePlaywrightCodeResponse(w http.ResponseWriter) error { @@ -24768,7 +24942,8 @@ func (response StopRecording500JSONResponse) VisitStopRecordingResponse(w http.R } type ExecuteBrowserReplRequestObject struct { - Body *ExecuteBrowserReplJSONRequestBody + Params ExecuteBrowserReplParams + Body *ExecuteBrowserReplJSONRequestBody } type ExecuteBrowserReplResponseObject interface { @@ -24802,6 +24977,28 @@ func (response ExecuteBrowserRepl413JSONResponse) VisitExecuteBrowserReplRespons return json.NewEncoder(w).Encode(response) } +type ExecuteBrowserRepl422JSONResponse struct { + IdempotencyKeyReusedErrorJSONResponse +} + +func (response ExecuteBrowserRepl422JSONResponse) VisitExecuteBrowserReplResponse(w http.ResponseWriter) error { + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(422) + + return json.NewEncoder(w).Encode(response) +} + +type ExecuteBrowserRepl429JSONResponse struct { + IdempotentCallsBusyErrorJSONResponse +} + +func (response ExecuteBrowserRepl429JSONResponse) VisitExecuteBrowserReplResponse(w http.ResponseWriter) error { + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(429) + + return json.NewEncoder(w).Encode(response) +} + type ExecuteBrowserRepl500JSONResponse struct{ InternalErrorJSONResponse } func (response ExecuteBrowserRepl500JSONResponse) VisitExecuteBrowserReplResponse(w http.ResponseWriter) error { @@ -26725,9 +26922,11 @@ func (sh *strictHandler) PutNetworkEgressPolicy(w http.ResponseWriter, r *http.R } // ExecutePlaywrightCode operation middleware -func (sh *strictHandler) ExecutePlaywrightCode(w http.ResponseWriter, r *http.Request) { +func (sh *strictHandler) ExecutePlaywrightCode(w http.ResponseWriter, r *http.Request, params ExecutePlaywrightCodeParams) { var request ExecutePlaywrightCodeRequestObject + request.Params = params + var body ExecutePlaywrightCodeJSONRequestBody if err := json.NewDecoder(r.Body).Decode(&body); err != nil { sh.options.RequestErrorHandlerFunc(w, r, fmt.Errorf("can't decode JSON body: %w", err)) @@ -27204,9 +27403,11 @@ func (sh *strictHandler) StopRecording(w http.ResponseWriter, r *http.Request) { } // ExecuteBrowserRepl operation middleware -func (sh *strictHandler) ExecuteBrowserRepl(w http.ResponseWriter, r *http.Request) { +func (sh *strictHandler) ExecuteBrowserRepl(w http.ResponseWriter, r *http.Request, params ExecuteBrowserReplParams) { var request ExecuteBrowserReplRequestObject + request.Params = params + var body ExecuteBrowserReplJSONRequestBody if err := json.NewDecoder(r.Body).Decode(&body); err != nil { sh.options.RequestErrorHandlerFunc(w, r, fmt.Errorf("can't decode JSON body: %w", err)) @@ -27600,755 +27801,763 @@ func (sh *strictHandler) GetWebMCPTools(w http.ResponseWriter, r *http.Request, // Base64 encoded, gzipped, json marshaled Swagger object var swaggerSpec = []string{ - "H4sIAAAAAAAC/+z9jXYbN7IgAL8KlnvPsXSXpGTHyUzkM2c/x5YnvvGPPkuZ3DujLAl2gyRGTaAHQEti", - "8nnPPsQ+4T7Jd6oKQHeT3WRTP3acaM4cRySBwl9VoVC/v/YSvci1EsrZ3tGvPSNsrpUV+OE7nn4Q/yqE", - "dcfGaANfJVo5oRz8yfM8kwl3UquDf1qt4DubzMWCw1//ZsS0d9T77wcl/AP61R4QtI8fP/Z7qbCJkTkA", - "6R3BgMyP2PvY773QaprJ5FONHoaDoV8rJ4zi2ScaOgzHToW5FIb5hv3eO+1e6UKln2ge77RjOF4PfvPN", - "AdrzNH1RWKcXP4nJ2xcnZ1pnNpwUTCVNJYDg2YnRuTBOAgZNeWZFv5dXvvq1N9UmESN9KcyVkU6MFF8I", - "m/NEwI+pmPIic7FrfXbPnV7IhGfZkhmRZzwRjGcZE9fSOqlmzMGsmFTMzaVlETC7km5O3024S+bsai4U", - "c6YQw16/55a56B31JlpngivY89qMcu7gaHpHvf/1j+eDv/PBL4eDb0fDwc+/Pu4/fvLnj/9WgrDOSDUD", - "CFYXJiyouoD/4Jf8FD8zcZ0bYa3UMFvumLjkWcGdsMxpxpnSaiAWuVsybgxfMj1lCe4/LpKlYioV7riF", - "NSz49RuhZm7eO/rzIf5vbVIf+z0j/lVII9Le0T8qa4yz/Tn20ZN/CiKD72C/XuhFXjhhnicwYNdTXzk6", - "v/WwDg+OcYSHCxbXIimcYBaAKyfhjIe9VdTxHdb39b1JhREpy6R1MMQ65CE7xj9gv63TuWW48YJNpbGO", - "CSAIGFA6sbDbyKe+IbBPC6leU8/HcRfx4NY2PqyhcbeNvrLCPM/lC55lx5eezld3EiiAkCY18hIwZi7Y", - "hPr22ZyrNBMpmyzx+wthlMgGcsFnwg54LplFFnMUz2EALMXoLOxan51kfHll5GzuWKJT4fdQatVnNjFC", - "KDvXzjKuUpZkMp9oblLGk0RYO2QwdUvTW3DFZwKn8be3TCrrBE+ZWEjHxnnG3VSbxYjncgQrGg/P1dqJ", - "J9yJmTZL+FuoYgE76Kfb+3kNx/u9lLutzK9hl19CtxrddgCAPU+px8d+z5lCwXTT9SM7M4VgcoobATNk", - "UymylF1xy2IvlhYC8NXKXwTL5EI628ydXAP+41SYkwthHV/kwAJ/VPKaLWRitBWJVilCgw3nrnfUk8p9", - "87QEL5UTM4EXDn1T7nY4nobtXsFsZwPAfnlum7lLy0nsxlpOAIWBJHK+zDRP2VQbNo5oxQTAtevcBFB7", - "fSvpQJktJgvp4FycZmPPREq6eKFTMe6zhOe5SBl37M+Pv33CJksnLMvkhYBBzZJpNxcGWrkC2BNt3JA9", - "Dx2B5wsmLUsKx7RinCVzbnjihGETuIa5WSKZCZXixTYeDof/iDjz83jInk8snD2suTomLBQlg2HT/ZQW", - "9ONo0YBMP/EsGySZTi5YaMc0IS/xFgMzWcgskxXU8mOoYjEhRIozGMkGkngLt4FImdGFE49sOd8+3tsp", - "48TWiFnhd5ZJZ+MU9sRwNmTjM34hTiNPGvfZ+LjxrPYb98HQXdY4Q0Ar/zuTKVxKUykMmxq9aGGsofVC", - "pmkmrrgRjYNax13RsO/fn52dsCB/M2qF/HfYQKgrtFdZyMrOx/Hqp76BHIEWTx1PLtan+OLlCftQKGA0", - "Q2xyZngimBG5EYCGKITNBavIOUiZFtoCmcCP0BsvaUWkOWSvgB1aVljBYATFFwAo0Qp+xovccMRqN+eK", - "WcUvxCjhFvnlAsUKgPtibvRCsJfiEqVTdmK004nO2JU0ghHra75jsuyV4Qv6tFmwwNVMsXGfAeqahbaO", - "hIia+LAyhM6KhXpHtLE2yN+F0YMJtyJl1JARFaHcKklMyaRqxIN+b1oovLff8cVmiTM0RGLqM20YCZiE", - "mchBuNJqudCFjY1tIwrDbDqsBpo1rIVaN6+GfnudNuMefa6QY+PsCpOtd//xwxtYMqw9cDMPbSqzJkJd", - "obDaNlfmScPVtqRfP+8mUquLiCs32hoS5nQTsoxPRIYHhdNHonJIgcQNuV2qhCW8sKKZ3+XchLdjlr2f", - "9o7+0UnSKTnCx5/Xbl8EWZsMYhJOBb+1w7XNrJDcRkaUu2TOX8x5lgk1E69fNu0N/1chKhjB7JwbEn/p", - "4ieOrZVgl9LKSSZYEgAO2XPFkIEPZkameFEnc84SrpgRzizp5cjZ1Ag7Z47bC5YLw7hzQDp9ZjUCHkeI", - "I5mO2YIv2UQwbq1OJMp2CGZRZE7mmWBjAIQt8f63IBDkRqdFIgx2Rm5qLgWTjvHEaGsZZzmI0kaghEMP", - "WBCx/RfSspwbFzEbsDxOiolcWrhH2GvHUi0sU9oxqVKZcCdoWRoYHbABbSodASUygWIEMs41hGo5qQ/C", - "FplrfcDEgwj7HQc0gqNYwBmwVglIrwuX6AU84LxAplUi8Bgq5/gTl84ThrR08P3apcFpmQYn1mdOs1TQ", - "EPQ+AX0E8PZyKnHcsZ/myOrsUoys48aJdIxy2cpvBH7MaMETgZt8KdOCZwxbGJwGPZ3gpHWSFKbEDJTg", - "A6sEzCqX2PVxRPO57eNow4E+vJVa30oBGUp2QAhx27eTP7odWOXqed3gRRUJofasalvihmeW7xE2qzv2", - "nUGPj/1elbveEH9fv7zRsycK++VuwMONG9I24oNklVH1WQLMBFrQg8wTvr80AN8mwl0JUeep5cOp7X1w", - "tjJQYPYN19oYx0zHR9gAbw49wSslXVlOkgluGJ+iPm5lqkP2Shvm9IVQgVVbYrALwZVlvHytUCMgUv8S", - "eIboAh/sgKt0MNdZCtcZ9azPAeen+KWcIXHzK74csvGUy6wwIqwh3I/WaXpz05QVKFIzmUhXHoRfhQeA", - "gu71nBcWgMOJ+eVZdjWXmViZjBELLpVIh2wMPEIXbmUGj2zZepCJS5GxK7h9JkU6E6jXBaLeBptPuEq1", - "wjOioyGMEyr18oIuXDiRlFk5w5PfvOKIgVNcM4fLm00ECoQ4lSuJc4RzSqVdSGvhPjUllhQKSF2kw3MV", - "cCheZivH1kcpAr6aZvqKcQP6CiYdSDNWOoFSlHUyy5gRwK4YB3lHpoQsfbwD8U/rNw3lKcQvSSJKbjTi", - "OHfsas6dwPuztqOwklnBTQrkZoskEYJm3+tHrkzrAI5OCAE0Ryfb6/fiOazz6H7vegAwBpfcKHoe/qMX", - "OcppgBq/eRXBx6/O4jjxq+flgB/7vSsxgb0azbVtkJS+1zaKdHnQpK6yIpSIGqX9ADznbr4O/IS7eUfg", - "7P9bICNzxNWuk6yAXd76Zqqx/ooiosbQd9BLIDTc+C0Cph+Y6CJy3g3C5WeQrVbX8SBXbZWrqkL2Peqj", - "Nx3Q7oJUwL5GMar+bPjdilBEh/hyAvxaf9udea4P2MkLN9dGOu7kpfBdnQSV4DOWarwY4K16KRrktBnP", - "yX7a9mjzT8OrubaCpSKTKKLBVUSmxwQ4HDcCh4GbhSsnwo2yJqqh2XDUZkiAO3lgc5HIqUzIxEj2NJix", - "F068Gvv4w4f3H0Yvnp+cvfj++ejHd6fv3/zt+Xdvjsf7UcOvFV1w1u6kVT5b2+uxBzM+CnKDEa4wCjlj", - "YTnIklZnaPCryWFrrZVf1J4Vgo3LzRjv16Qn3y+VKe4q9a8qBEEdhIJVRZBakZGoCUu4SkSWrUgtddkR", - "9O8DHHNFDqBl7y4IAEcijU2r/ikIhwNuQVQTaYNGynshCFJZA561IOnGy7yjpHA1F8Zf6TQGcnocJ70L", - "YWEj/LuWF24nIADfrrLDdc2yX8GFVCkzItfGkQIRlkfIOwRrwqVMqwSNCiUyTBHDMAueyV/g7JXzgqwV", - "7ogJ5YTJjbSCXXIjuXIW9tIIT+8s0VnGcytCRyENuxQGnUMmRXIhHNu7fMIO2OVX+302xlfViKt0BK+q", - "Mb037epjK7J8S6J2oTKJTyBYJk05rpVbNka74bhOMvMg8sA5hdO5fFL/+BWca2EUyPpwbDMhnLAOb7Hq", - "RHv9Ho7RSGANR3hK5NBNyDPof5A7Eu+4vfhsIl112g8yXUeZzrO+T6Yoaz6p3YU7Mgm0S3Z1ucOWSmzU", - "4K/grvWo2y9V3BWlMb2r1Sxr0PjgW9vfQWzB1RJ7WHxQJ1rZYiGMZYvCOryBuYVvUMHsJ0jzq2vVmTYs", - "59L4uQND5MbIS9RDpMATf4JFeIVPv2LWSLQxIiNntqiPD7aUKPw1C8F9r1evWVRmRhe5pUVttOe8DBKd", - "1yBost8eMb6y0gX3qxFekySdjdYBmIGQaDwoW08EW0hryYEj7gPjIJ0leBUaMdVGNFhYksKQkSyIwa5F", - "n/+bEfM/ibzjT7zFtHRrgQfcPQUMG6SSt3SKZPUGYq2ZZFDNlHBjlkxpggk2YxLQK0ZCW0yQ7O3+/chR", - "a9O+C2FqO0d8EI1+66JRmj8vnJ7KLHvb+OD8aS6TOZ2UnnrXMu57gJNDBsj0giutZMIzauC5aSou0Xd6", - "kHufmf/Pk/Tw8bfiT1/VF51wA3PlaQrT7zjbMyNnM2Fe6MWCq/QGF+0pV9Ih9owDzKEjoGPGzaxY0N1a", - "rk2qvHBHTc2l2rDYPsulUuTQN3cut0cHBzPp5sVkmOjFATkYBf+igzU4B5NMTw4CMDH56k+P08fpN9/+", - "+ev0yTfpV99+nf7pz5P0z9M/8ydPJhxd9g+82+4owBjCt0N2TGoJvzbiGNKyhPaQzTlZXxyaE5g2zIiU", - "JyjuiUQidUjFMjmJs8yNvl4eAPal3PGDJM1H5dYt+SJrupH8QY9QrhwlumiSxMnNBebom5MY6s0FfsYB", - "/86Qgj1rUGnAQuQSqN8PzpK1W6EiR3qAjZfTWTngI8v+4/T9u8GHkxdMpt6yUE4n4WCFY//UuH/EWfz1", - "X/WmLnUdcF2gbYOUMd4BQ7Akk/AZv1Ra+Xu9gzycaKVE0uof+Tpcp7SN4PyEJ8jKfrUFkSyTMq361fs2", - "zUe+Q/BXSPNRKm34csjOrrRfhEV38uDChy4kYRvgeBxwTo5eJsj/paW1VmIPHj/5cwNHIOTZIExMeHIh", - "VMqUTmuePP6exP7eCgR472m6HUXQP2/TgNigMtKQvcgkWhWdZo+f/Ln0wrXPGGeZVjNhSmddFKGZETyr", - "wui2GQvh5jqtPoRWeVQjV114jr+b29bKjbHuvPVT2FTa0COQ0Ew6ZuhATcQ8RpoNdOrmYmFFdtlKsvDY", - "pbCWxgMAPPa/V0+6isl4xjQ2HkjNxdkjpLe7+i52w/l1OpYVycmfUQVzN4lPaR7+Qt3kS32FNtQ7ue48", - "5GFSA73l0mvr9HD17XL1hdlhvN2128i/qCnzTT8PY3m4F7+0ezH1lDmaFRuQa/0+DP3KKzFaRT7rRdbM", - "dxqvs9/PFVE/xG73RKatuNvrASB2vRWo7cNlsMtl8MBcvzTmuoE9AQH8rrlSJy50KtwLSiVgT+Uvd8uP", - "bB12R8601uuBRz3wqN8zj5oLCE9t4DWeChg1AOx4+fqkTdvRzulWCOp3wvP6vSuZNtlW4rbh71t27Uqq", - "VF81LttvH6Mma5LxlkjcKBmWI3Tlxz9hj+90oVJ71/y4Crs7P673euDHD/z4j8iPiQq6ceNMTNshXLNc", - "W6RjgEKpVFiitUml4k7YG7H4Ko3+bli803nrLi5vuIst14aH+mkvjQgLnUFuotmnaZ9i9wbFPk0DoYe8", - "FCJle2MyxUOejIVUcgH3BH7g1+WHaZFltK3ofuz1RT4GCjlt6eOCiahQmdRiMb/1/ehvwlY3wICCIYtR", - "ZDQ1lqdD7BBg/E9icqrRdwBZ1RFdfWwmrCuMsP3gUIzpSFLJMz2jvCNSzfqYL4BZkXnmBmNVsiINGaSR", - "k7Pgmh5oAtvBBF6+f3vgc2gwZ/gU/CXiXDM5MRzdl2whYo6q6B89EXOeTaN/etjy4bl6r0TFh6ttT3zI", - "OIXBVK4PsvGEVtYZwRdBQWgxjCzts0TzTNgk3JnetQpj6GlkaVmGbjkqW5YXDx04/Bh8V5Ati0wsMMQ+", - "qW5Xv+xX3o/xri3d/xOdUgoLbJ5k3FpwPPFbzhW0uhAiZ0UOmb+SrLCYRwR2Ds3Y6IqyessM46xGYa7j", - "Z+HGdZs7pAbjEj91FqsVAnlwOG13OEURA7fqE7iZNhxLY4ahQHN1H9JyqsFzFPgQ9F3gHYckNCbKGg/Z", - "MU/mwX8KXdgk8o6M3LRK8uF5bvSlFxLJ341GOSrtu/hlkaUMPaU4syIxwrH/93/+L4PFppT1TS/iHQwm", - "rz64ytk+M2IqjBHG9n1yFdtnTixy9AX1nDPnbg7LMXzGkvBkA6DRV8nPBYb0rlgZT2jNnGUoN/QZJzqG", - "P8gDNYFAVD7rY1iKKhbonAnzYojuAseYa+tzAFW2kxJrLnieAypAsstVk3xnO3uDr1O/zTCyFehWu3J/", - "RanZGeKqBaLfqjPoCnKDOrHfKq3uALztbdzvvXz/djjVSdEB3Eu9eAUt1wHYxOgse62c/psUV6+n7zCO", - "uBPE08auDUMI90pm4jWIGvBHt/mervaqA8bvA2IZPpshBm+Di71e1Do1gU2lzeGFBm28+NUJ8svVfpuA", - "/yCWN4Edum0C/VYXVtwEeNlxE/gzXSTzm4AvOzaBF4sC2CU2emX0YudVHLcCaBpOLgTSbmToHUd5vdqv", - "Ebiywrgzcd117q9jhyZwdqncXIBgcSJVMv8ryesdQZ82dt48DNH2Tcep9d480BnPbzpK2bU+xAmfieEE", - "pJsz/croLugDXb6r9GgA6H29ypSL3aC+WO22AbTi+e6AfacmsN2uRgS2fi8iCMo5WabSe4lPwm4wv2/s", - "2zBICGLtBvadb70B0Jn+XlqnzfJYObPcDWy9b8MguZHKnemTl6+6AT7x7dNpAzBKYtYN0AexLgUhEBAu", - "xOSNnIpkmWSCNCOdQJ429GwawHHjCIMTbjvi52m9UyNYnb/RPO10cxPI2KEF3O6TrPapAz3jBqKxeeLk", - "JSAGftwOlto9r/VqBIzkuRvUF2WXZpBGcCdCL3LK6wy7oe+GQXaceKVPI1AQLbS94dRfNnVuHEbnQgVT", - "TFfo7yt9qkA/RmXHkjKQBg0fpABWYiedZgch7GP/RsCaxMUdQTWLJrsC2SQ13XBtzeLkDYE1yuw7wmp/", - "WewIqJskuyPQ7XLgjQG2Cnw3htgs3HUHt+0FuROktbfzbvPY+k7uDm6ToLoblI2C6c1ANYiiuwHaLjLu", - "Bq9JVrwZhHaxcDd460Lcbv2bpcndYGyQzHYFpPO7gtMg1+2IhKtPmB3nsEUU7g5tmwC4K6QWoW9nMC0i", - "2M3gtMtau8LbKrztCrBdXusKZ6v6eXdQN0fO7Zrgm8BqU1l3h7VB8f/x5yZ70Nvoy7HNkA2Wam889bb3", - "66U3+Voy2FrhQoR7xWJqGVeMz4Rqqg+EWRmerRpdX75/i+aRYJeeaH0B5lO0d8MP5L5VBvj/+LoymsFk", - "2VamAj2PSo+ySpWqo84x5q063FbNcYO2sV27uUGL2673blG0d1DZblFdblM5btQUttkVqjaRjeaNJiVh", - "q56vRUu3WUW2qtvarKKqq4PWNU0tiphmzUeDeqWmEdykNmpTezRqLZpVApu1EVte/M0v9VZL4qodsN3i", - "1m7o63cLRK7yM3SBaPPLUUxc+5qG3reFMqlQFTth2OnLH6qVxvrspMhz4YQw+8F3sPR4bPDaIecYadnf", - "3g67elx4h8Q7cbooV//gdLHF6QK36j4Ttjacxw0y3kf8aPLG8L6p7cXEunvJStvoJlvxh4WjHtdAjoMv", - "WJNzCLltlJ61eA3ft7/sx43n8TL6SHVnEKVflUgpL00H0mcnXJoy15RcLEQquRMZllFJRLruX6xVuRHk", - "6/YZGMjKBj3wkI08pESN+2UjTaeyOycpZ7vOScrfHpjJXZQkLBfWqSrhQljLZ2J7LiN6fWFjy4zI+FKk", - "oRjT+rg+W2AqDX3XXNzMCG6bCnz9NF+uwsQ6EFB7CDd9RFHbR9VIDnxZId3Sl9pCbuciJ44GBVrUDFMn", - "49tNFgt0YqUciJgh2bv9B79kwiBHGQyvVAxEodHIJ9CIgNd8xqWyFIOixBUL41anIIzRZnwUf0NXaqZN", - "2FeWF4ucUkjTWn2qjZjOwC841FX0v9dTHrA9t8x9UWhfLNLOCwdL2F9JXlbZyl6/t7pT1a9wTr1+b21G", - "jYx/zQl4E17ZIg9Z9JqdtD0BXgkqWnjFTVrKwb4PmxQuJN/xvs8i7ddKffyrEAXVxwB3fqbLlt5LOudK", - "JhciDQFTUiVGLLwft88Kge7cfl7oj1mocv7wXXTpJkUFKQOmMnNYNXFCCTF5upAlrvlpA/0xp2F5xMWc", - "djwbsrOwmTA4ebE+84V0qhEpobAI0WV9d4bseXbFl7EWDTIxLNMZHOBhBUy6Z5S9s9ogNyLlsY4l3pLg", - "ky6TefCHj2yPW/aLMLotwGPdl3wTWpQnHQmuig0+32bKlG5i2tWTl6bicu/zGqLnOqHZMEnzYZjRyB/b", - "eDVqoVo6Dc4B49IkokZwnycmj2LauM0NfkusZJXnr7LmyC23XNgNZqkbx0tGtcmWCMlKu4eYyJ2SKlGm", - "t5HSqeiSEQ70kqtZ4aqxaQ61JA/JAn/PeTtKXWbT3bsNk26LQcRzNo0QdOZGLLQTjDpsHe7TJWr6Y2Q1", - "6eRgcKuLoVmH3uGmaOv4cHU8XB0PV8d9Xx0tpq+Hu+Qmd4mB+belSfgevw96GWhamy4dBN0hdeRNdTHB", - "9Ohr2hocrzVuPy1z6d/daNfrI/0n09OpFZ2W1sc3KVYu89QOGLPbFJbrU/ivTzeFP468sMkx8naiwirk", - "LlLCep8HAeFBQHgQEO4yEX3WQfEPrSym+ygPBAl1yF7F+PUdCha0iCWr5P4gkfyhX7c17NxydQW3tOaS", - "PfBzSAUz51ZUL5yONV9C/h5mHawYN4P78wqefqiWtsIhR4v5a3zqlbxw6IRoJtJhPhtafCziE8zuNftM", - "CutSTpheH/9+f+n/1Ln/hlxROxbLgX14KxfiRcWSv8Klde7P9u3rt8cs2IqBCXDKTyGdWPRLV4TXz989", - "Z0bMpAX7RFVHXk2O9Kza+5GFglEwTV/0hMwKGRU7jzk64tiVREqf6Ri8AxraQ3r9Hi9SqXv9HlR4gv/y", - "PM+8CQnvF1TVL3SK57IoMieBM5fq/I6n5X0ayZmhGbGRVzIy4zPOSpfINGRuYt4R0345OC+mvMhguxw4", - "j+JWFrbrpm2JtrqxDNvk7LpFhG3u8iDBPmSM/GOpnJro4A+cbHx7bOktmdSar34nPtXQ64FVPbCq33W1", - "GcNno11ewL42P/QLXow3fAHj0CAMbx8aWrUM/dqJRSVh3G6jL+RCjLyQ7VF45dUkrZMqccw1PgoAA/S0", - "nBXNkyIaxiAxQ95UFJnhj4qMDBlUT+kBYH3qvPYV3DbXar+H89rBCXn1jVQ6dXNj+DLuH9A+rseOFtxe", - "rO/fd9J5n2J4PWWZvhIpbVXZle09/kui82WfPflLJtVFnz3+5i8LfSn2284On7GxHvKuKXLrD+X1JLmr", - "L+UjNo5v0HGfPry/DH/rnOrilQ/R8e2T47aLEOtBaC11AVE2sFtOZA7/DY3ZhVjiYTzPHJzFC2eyPnv6", - "l7fC8T77819O53LqWs/kS0wn3WDUAWsgnAm7ruSOBs7z4vSU5fJaZLazyWS5AfzytuDb9EUV2thBBmtK", - "hHJHIlgAvZMEVnZ6EMB2qsxbOD0yIhe8Kd38XHjVVEgKDVQ3E0qYkDz2QmAsseCuRueVKI8g4m29swWg", - "jppFcg3XIqXIfp5l432flDZWDsdJPRhWfi+y5e2u6cACWm7pH8Ry5ZK+EEsIfYVr+UIsf8zhD8OvfvBf", - "4y0NV8Sd3M/Sji7EMufpZjIDepIxYbsqFsLIhFHPNgqTdmSXFuTiC7HsQsXomE9dcMB1MqpAz7TX0q4B", - "/kEsJ5qblIUmIAtkYorCgA/G/eovqljkPN3vbtZqic7/jYgtii9E2rzRgGHVbNhEkDmfibqOf5lHfa4M", - "4czjKC2e8Qn857kx+iqg56uvQf7/AeZddeNnvBRhGt4BkHJeW1FLVj9Z0jtjRPmv6/71X3itj3JZm66Z", - "Em5tyraYLKRzvrY8owK8zopsiqbFDk/EuxWwmnOU3ZGIVQLfSciqdnsQs3ZyKimc0+omtxru+XfUff1S", - "ox/QJBiForA2KNKiUI8APHmMpVrSNMNvkDvDH+DFAv/1cUN3Uail71e7jSn7VsScIc5uyN5pNYBYKKYV", - "42yMNqy3+hK8nBeCK6JYeOnTFeYVO27eKgJmMrnYLnliuDFJc7SfGBmYYVgb23viB8N3FX29/yBz/m70", - "mSJzvMlb83tt5C9aOZ55p0iGTfsUgo2o+dNcgPam6/Oehmp65AOjSO5uoNvJ0SWXb5GkscGKLI3TPKEL", - "f9z3nz+ITPDqF56WV9d1Byxnqn26gxUah83K8ArMYXKFEX12iCJG593cJqGW+/VbkVFzDR/MjTHghPq3", - "HL//lSTRUhlQPi/26HDpnPO7qf71hYqkXM1gNjwbBfTbiKNl+wq6Dh7vhq9OZo3u5ydCMfit9EP6r8Hf", - "WZ5xJfokzs2MEHa3cZZdxvnP241zJa1rHgZTOVxJK5jRzuegWx1hnTwetLibUz7f0SOjBL7TI6Pa7eGR", - "8WBMf1B4tiZojZTSclNjgxVBDf0DMWfxuO8/Has0/g0SGl3c+PEODZTdJbRgIZ9KYx3DeTAUae5cdCt3", - "8LciuhmeysJueY9Qo9Zt6rw9frBNL5I7G8rfzyOuZlkDGnzwv284+xuIDn9QmXHDJt6VMHkGAl7bMPct", - "YXYc/JZiJ4AcIcjtGiTM7yqq07ArlyraLduovkXEfbEm3u5AHreQe1upndGNUja1LIN1S4V+7XRn4PvQ", - "jr1gIS1cC3RtyAU3S39KVYsID/vkiSmIOncvct+Sj3WQvpsQp4NE3q1EyS0l8/b80p0k9E3dHyT137g5", - "4C5EuDtQpz8ozv+oivN7UpP/ZpXibCJg0z3TRGrCm+E+nT3bOfSD1+eD1+fN9YUby83dUihZK63RSRZp", - "6PUggjwoC/+IQYJrpNDI643IM55gYt6RUA079aFswAxXM8GESn26oFZtVQWoddy4LmCx4RbA5PMLh9o4", - "19Pwc2WOmLtfxtMMm7F9hJaJl2NUJ7zzKH8EP7qG/bhrJ7rqpLpcWI1FVm97U0Wg3a6oSvOHu+nhbvpD", - "3k2RBn4nwes3Y4+wCffgWbwjU9xesfiWDLK5OF0nZtnW9YFxPjDO3zPj9BmHRpSO6MbqqfW0R+saqlre", - "I1zFxsxH96elaqb1llcLZSAd2VyIxkcL/c68yyPDdmgMIzUJy+FLLOTTKqMnPBOjKU+cNhtGwGbBgJTD", - "xNneeXF4+JV4zH7RGtMN7P+uLdO/Pz3YTpdma1X+O7s1ayPseG2u9H24Nx/uzYd78/d6b9aIvfHizA1p", - "+KcZfNEaE4w/421iizyn66QtEJjC/Dv4wkRe6DMDRPcxstttUCYC/FRkfNlYve8l/MImwl0JoQLs/lq5", - "vt+RKq5F6jm9krkgUWcnSeeeL/BrYAKOq0R0Mgr7tvXBnjFSIV4GbLEMohd3mAPWsceuDcViS9SclxOK", - "M4nJ73PuSxIKlXYe+l7ll35vuWF31yzjXfe2yHcYv+POXobJ3Mm+3oHgVpa6vxeprQS/o8hW7fggrz3I", - "a79rbyFforHhVve/xIsdvWSwdCxMFj8Veedr/o8tGJYs5fejb+d5Z5dDzRzPVyP2Hc/3/zihgJtvxlqO", - "pMYENl9ixn+fyKnX72Eep16/V6Zx6vV7gHIdM6FX3WvXtgd/ZJMVH1teeth+IdultAJ0ArkaCBCTgsCe", - "YTmuPhbAIfy74ibdZeM2oNaae+QXs1vVzAYhr35IbBA+Y16D8AGTGnTcthM+E9/B12f6ldF35OwPQIeT", - "CtQtcmlD+wdx9EEc/WP5K6wRwR842z7sxQvySDhNjBDKzvUdsqZkFXQX/tTQ6YFJ7cSkaANHE7HUKh1d", - "ejl0c75I34mJaydUWtXghP6taV8zmbeW+ASUxgJIWjFqc0MBG0dBy+zmQTAJI7ZjZOjdbYSW0qHVEbDJ", - "bVZxvRn+dXBAvcUQy81DLG85xMMt+KUVMvSbsbt6pGTDrwhGg3ZkATRHQzC4goQFnrY3/mcuZpBvIlcz", - "yjRxJSb53eSIghfEyBZmyhPRjbHBjez4hVBl2Ljvv1aXDTheG7drkSfWLq1GoULnTi7kL2I01abN0SXM", - "XahEp4AJU36pjUi9FQhU8wwUQG0T/FfBM+maGIBeoN0P0NY3Cmk2Dg8pB12mrV36k/wdmdduKxkpnt+P", - "XOQB7yIVxS4PMtHDw+3hymq8sjyNtF5YoUHTnbWYu0V2N3fUlqvCT+KP/vrMtBV3yFkBXCd+Sg0fuOgD", - "F/0Dqr8Q+//gnOd7rtJM/Ae/5Ke4xpeSZ3p2d6xo3gi/C29q6/nArHZhVjxJRL5F65XizhLWYnOaUCrt", - "Qm7ykHxghL8TRthMai2OtnqRu9HuUYFCOWHQgdNpxhnB8ah340jB3w+n7gdK3c6y3/FLOePuDuVF5SF2", - "Yctl2wdG/CA1/q7f3oYvROMi3+f8X4Vg2KDCWTZwhmeMs0yrmTD+QS3pBQ2Yx7MqjFsx8kCcLcGFU2EM", - "EIjOZLK8iVLhgwdxQhDWlQqhAaMx7i01X7kWIwCHt2i/62lJcdepP9084VO326ciAX2RDoaGK8pacvNM", - "3BFEi6uov6Jg6UZwq1V5lAEXeJYJE6rBQVljzMm9zKl8ihGZ5ndUnqkw2QjX0GAjOcXvY41qYZ1UNO8f", - "P7wJs8P7C2bFJ7rAPOLA98f7AXlszM4LnVqQp3IuXz25s+dbkAXO9PfSOm2Wx8qZ5d1LBnX4u8gJqz0f", - "pIYHqeF3XeMA0LxxkZ4OGLaoLSfQCt4BnQuHbiCz37VSq7LH2xnkiZHKnemTdHp3TDH3MF++6sIIq60f", - "mN8D8/tdhz1Jm0M481zwVJjRVGsnTLtszhk1xPlSY3YlDByPSsUGuZvajpxY5Bl3YvsrgAfwoUsMAs9k", - "manK/7TrKyAUhRulOkGUHunCZVKJTfMJbZlvixMSi4lI0w4jOT6biXSUp9NNY1ArtseTRFgrJ5nYZycv", - "X+FQ0dzbNpY/w1322J/mfexxBvdJwvMtfk7o+AjDZlymsLXIiELfNuALbmZSjSbaOb1YH+A7/J5RK4b/", - "T+Y7lNbw4DEAZQ34GzF1twZtmv1OP8DXtwbudN7Af3V+C8DNskx5UzarnvlMjDCnqu2CjL4QuZqt4GEL", - "DuQ8F6bVg/cEfq347u64YALe4lZLsKND7a6gUXkxSqwd4QaBV9xmGkFfV9gcaIp7k3sFiHesI0LKt7jY", - "4WmNIHpqZnShNjjxlW3YzPB8LhNLbB5BtB9Ji6PzCZ+FG4J8nH/f9ZEMVxZOeKHTm1U3TadnHsZbnTZp", - "a77XV7jO8mrwktDe+AP++dx+x6345in5r4bvTjF67C50NDfVfnxALdHdCfZe69RBqA8tHwT6B4H+9yzQ", - "y5nSRowSnsy33CpEEWyyzDmxR1ggdGuV6DTKlxvsK1FEpqa/KUsLLbdZz4IruVFKcamA0YmUUYcH5/NT", - "4X4SkzdyKpJlkolTd6d2b9sAvQv3b+73cBc83AV/QOehJmL43WRjsbiaG0jd61uyLnfHBgyHYZxeqGxv", - "PDX6F6FI3KZam/cnZodFdmDGjhtHwV0Jt3cYCWTrgDux4NUuD9z3gfv+zmunm+VIufkI3Y7W1/oKvoYB", - "88wneRHmkremH71tMCxQXWtsEc2lLRgW2RqEw95NgBG/blXbveXXclEsvKdWqb6rhno3mFr5dZuurg4w", - "6uy2wGu5OOssrPHOvFkc68O74dTp/I3mqVSzu7ymItBuV1Sl+cP19HA9/REfByUN/MEDrYAj3Y/sXIXb", - "lS89SM4PrOmBNeVbpK8/CHdaMRA2JLO/YpwF35MU7YSyNBN+Makt68bMXr9Xt2R2zWFJpZea8376H2ny", - "5Y5xRSyYMoJ+WblAgQMK1XFzVgJEGspLtcSH8OAEi9VUv5jMsmE9vX7lw09zoSAX78zwFLZPGzmTKv4B", - "P78w2tr34XvgdeUHZ2TiGj+u9yyU5VPxo+magHXt7d6iRlh7utOG2tj9izkj0DgACqvZTltUSZ1y9Gu3", - "VF/VLYLuX+YWQXayrjtVTzGzjkrNO0S+R77vl8MLISVOx40542Ym3HNQ3INrPn66E4mfQA15DfIWmb+l", - "z4PU/yD1/7Gk/kZC+B3VjYDlbHKnoRafw4umtaBznPPmF4rnoJm298BMkxJsN05a6/DARh/Y6B+SjVao", - "4IGHfjk81AjuRPhWKyeu75aZNsDvyFUbez6w1wf2+nsPmNRWjLQapcLxZL4tkYmiLFmW+Z5pud2pmBSz", - "Gcwx8FYCKWz3NN4biLEtHdj1ckRO36NMWtcpMgsPizox6ITcPtFqKmebYgBpMCvMpTDdx1mBjWGI9Iu/", - "X37f6V4KJS+FsTwbKeGutLkYUTToiJSR22vNUTvLZoYr4FgRIPMAGQGknQ2t3VwsrMguhUUC6ZLM7Sa2", - "i+qtdg9PgwrcXW6xh8fBTW6vLqGEQE5eBkO6xu1OQ/hECaGNgsMOeEa6SdTzTUue+zmiTx5u9C8v/wuf", - "ZFB2CJgrpZADDDI6a8fq76AxGV58W8RuApWyvbngaSasZVply/32pAhJYTeTjhJXVfLBHpuyLJiR45PN", - "GQYmAWC1fohX8q9TanuygWYHzp+kSvVVxXPz5euTNu/GuUxToXbmHdStbWLNQft+Wte+wjgxQLL8VMqc", - "7uAQ2nB9NMpbSlyNrnDwTacCx0ytuqV6+CLf6jpvPZflDc/lS8gU1++1uCb7tUef5A2UQrgxunlwC/Zv", - "C2vxE0HoNedvBfdEBruykApLAGGuvwW/Lj9MiyyjA/tcgeVEfS/peXV/mpK0aYBuQmZL1wdpcydp80ES", - "fJAEP4/qvJF+f+cp+xrIrQsbfp8LFbjSXXJfXYHbjenWezzw2ge99B+Sd1XJoCVLlxJZ4/aEbgybMIAk", - "0g385q5v0AeL5G/MIqmLZH58KZRr9qXG38ljmuVzbsUX4yvoYOYYLd/r04djlYY/3+pLEf5+wVUiOnsV", - "1rOur6vsOyZd/2K2EbLCez4Mu+eJbzThBj4VTo8mWl8suLkIn20xoehoQF5V8Kz6TXTHD62dzpFePfOH", - "tgsJR+aT+/R7F2J5pU3lr1EVSJdDW88D0ZzPLmvOBfHFnBVlrICdxXQVXXenokhYT7tJzYIma0Wf8AUF", - "CYDWAzAyKD2Itca/S5VHp13TyupMHBujDTLP9Y17Xn2xQmMmoDXThhUq4QWoUstiT0xcJwK7huiU44V0", - "6K4N++muNEuldVIlDkUaqwuTCMuupJuzVE6nwsAWgTjI7Jznwg7Zh0I5uRBDP/7zk9cvgPWkbM9/M6QZ", - "AUOy+yw3Oi0AJpJjHytB9UFstX2UgKzjycXIGZ6IEnac9tnc6CvF9uLa4i9V0AQzk0r0WaKzYqH6fimj", - "wmQN47ySIkv9/QjEmIAyPoid1BNlLI5SQKPYy52YabOsilF+/Y0nnPqXTRcl3CoW4KsIhBycWEco2POU", - "emCqSdhC11SP+8wUgkmv+4STnsLuUDnx0IulBe4PphXN5EI6O2xUN7sGKwVOhcHBWscXOZOK/ajkNVvI", - "xGgrEg3iVDcpPVQ1WdnyEaJc7+dtcoyzAWq/PMG4sZtEmsYz2VW9ij2DTuBj/9cVnAKiaKD4LIu0Hp9j", - "LNHCJCQH0lrtkJ2Q2wRakuhFRAvz1N5GuLD10okFjr0updIX3Bi+pHcS0FdT0gr4nlFC1mC0pQYwF0OK", - "3pIfIXohdXee+ApXGDZiCN36jY+AsIvQia6GPuPZFV9adt5DDDrv3WoX1zavOVH4G6nE59+okkGuzxAs", - "GN6Y4Wc2lZm/QN3ciKv6HO9gYrW0XIFRd2WYPMtOoRd0R9paD3MtFlwNjOApcnq6ofxVZGsahoAkV7rI", - "UuaT3qOq4ZU2rHbF7e3TJddHAFNprCv1MRUC5Z5ECUTDVdb3RhAxldd4WdH8FsJaPhN9hgao896PoSey", - "oSM20Xpx3mPaVH/bkwoLMEor9hk8Jnzj6/JBOC0UKizOezUjUhvPrCswA2v8eY05vtGzzkJLpmf+9Rel", - "hkzP+nF/pZrq8tMVN6rPhEuG+8PPcBOHhT3cw1vv4ebSond8C9fO47d1B+90lW64qlqFbIDRZzEPr9HF", - "bM4KNZUZlWBFdkta6CEbIx8ZoxVVF1SDiNVEJiJCy6SyTvD0GeNZxvCdwlZvTAuisuCGzYURQ3YqSAtq", - "c5Hgawt5YJFlDHCikbHcE29/hYx39XjWT2e4ldUFjcF2llfDotbXLXG4YFpEoisVNoElLrSSThumsXhu", - "lsGuDsLtScczZCvqZ1LD9SlVGb1vyhB7JnKdoJvA1Vwmc+xAM9FJUpjoi1BH/PaKmHDKq+Uw8YUoVWUy", - "zfJPex5ogNqeBLrPjLDCMVgNT+aV1TWOo/jlyIp/NeR000o70iRkSyZVYgS38KyvbJcFtYNKgkjWp2Yw", - "L5HGCTidewVwpWfjJnTgnjfQVgcKo3EqVofG/digWg64uaZbZnvWoXDE4TawlXXasFD0CdvfNGK4FzpQ", - "NhkdqMgkuuc0i6FGZOKSK0evc2kJlZ+RExo0gJ2pnAnQAv5GpNMPWqWyrfds9qS1lSlUDqu6sfUllyi4", - "4fqqigK7GTlPjL4UigOSLoTjKB34k1sCNhOhe32IYcIreSLlr0tNollSO/EgBsDW5VQm1B9zeQRHqLa7", - "aYzbW+VevoXf6mbEuZBNPsEkqoQFDdFONj7yFxuL1qaT4DdEI3itVslch2x8IQwYrXgux0fsB/zAnp+8", - "ZhRqwPaMwL/IokhfDsrkLmHmbCyunVCACOOjMpW7n0/8Dcqd6oRnYKtNhLXjI2aX1okF818wUygFJ8bB", - "VuO1kuV0a8rFJM1ROR3mDz+FgXr9Xm2gRkk3oEo7sjUIKdvwIdxmhAzArYgODjydHNBV8fpl7bwDLazQ", - "Fh7+Bor53rn8ewF3g21fhDPFGsF8f3Z24ktWWbbgOZzuFTcpupENpMcUmD2wNl04Rqpc+QtdMuxvpHZG", - "Q+sy9/eHl/LYpHBswZdgseZqiYZtaFUvh7C2mNfKCcORab/IZHKx9bFUwD8JNA2ShPclZJeSl0hIOTcQ", - "QrfXkSwnctsXUuOaHt5Jre+kytaP8GTv8bXUfjZ3/GayIhOJ0w3FAKEcVfiV5dzNg44d1y5SJjIUtFpE", - "ilmDIufs7Rvm+IxuJD1tggYHVuS5MAm34db67sezs/fv+ux5n718/bcWGaZRmP+bxOp6qC0i7qdcy8B9", - "5oxcLFqUgddNsMVVro1j14PShbkGHNYCu+izEDci2XID4OXNAa/g4XUPRuqXp00ntPGZVEHBH8RyK8O7", - "EMuJ5ib9EthdWM8Ds+vE7C7E8tOwutq53DGjg0WsbeAPYuntzFH6/MHjMe0tMaBjmGKffceTC5vzRPQZ", - "b+ZCN+Cmge+hfn7OUwr+KZ3iLsQy1AK0toU7dee2PrJoE7d9/e7kx7M+Ozv+z7PnH47bee6qOChuwWBO", - "E6Oz7FQ4l4l0K6ux2JpZau4ZTng38akrm8RwE+t0bsHjSkEgdv+3zZ7Wd+OBUXViVHTqI48Yn4ZntRzW", - "HXMvYE+j66boJ8Tz60HEdO68xws3rmIHhFYzYQHpu4glON6ydbzlXY/n9TE34J801jZxVDdt3iupeMbs", - "+hZOnfcxDSsIrKbLSvRouWWo5Z0MtYLLHkPi0flF+wmt7/BG1vxGXgoQQ1+QqrKVI2fyUrBLKa6iQxZ1", - "KP3A4R0/LbLAux9Z9pOYfDh7EXU478SF3h+y7307MEI/Q1tnYOig24mBtnLBZ8J2NiR6PetteXPTdjyw", - "5FaWDFgxAqwI/vL3yIlbj2ZHJS2oybzmPudLLJkJiDdeW8u4onxefUq3WwbeREJZtw8M2WlNeW+EH8p6", - "Z0csNYzkFfTfk0zmGHcBRIKugDQpcv6LIQfjckrjnZTlHTb8ZQx86M4dymCJ6MW4A4s44ZJsV42nMlmu", - "LfdzsIiVbXngEh24RIkWn4BRNB3QnfOKSlRQK7tIC4P66tGiKTkEz7JBkunkgoV2UQMUcRZOYyGzTFYO", - "Yqfa6pu40jMKffJG60QbI2yuVYqxUG1ccUeLXHULNh2dTrDZd4VKs13Nb88ZEFomXGm1zzw8iv5HkYJp", - "g+aG8JMFfuJNSVKrIyYdplPKnS1LLqAAN9GXZAfSSkCruc5S22fOCI5tjbBCpeHwAvzYkoVQP7MkXwAj", - "YPUWI4KuhKmM1WfoF1+6dkdghUqFKdl+tQvyy6eH367jX9mqIYZpZTeG7LljC20de/K/vv5q8Jic3jIQ", - "Ka1jnsgZR6MMoZ5fnbjmicuWjSxiQTXbekffHh7+6fG33z75+umfnh5+++1j75IPPz1udBPlalaAHNjw", - "TIixB9+9OGFP/wQKEFs1M2szjN1xv5/jqQ7e+C/79JJBwyxsHVrqxBDtd1DCTwASp2Lw8hjwFzlOu9PQ", - "QqrX9OPjBg8ihNxhCdSwvC8RYR9Z0GHwicwkHGhtgnF+axMCRv6LbvJrff383XMWfq45L2wath9ro/qD", - "BnSeyUuh6hM6LgD1Dr4TJpPbvRYrmFmZctyxKgJ04Bov4j3bIKMkF0pfZSKdCXILg4UGM29j3Co0IEYg", - "0pKRtGUxaA6rDYCJRKps4ZENpw2oGZfZfF+HvHHeqtt8e5tlFBqjL5NQYdiSEuwqITSPaYRKhRGmdbDQ", - "ICKGm4sFc5pJZ1keqQ4+waSEsaT55EaoR45RuBLDN35RV3c2zWKUC7yRmgqa+CZBseq5dOSZ/ypEAQ5d", - "Bf0Ig/MSG2CGfWYh0JFbZO0TuIxDTZRUcvCCRX4MzgDMcXuB18kSF75ksoxrXmIw9AJ3NDK2w0YRqZU8", - "D4RLDhA1oA2qdOkIQxfcVVE/AtrY6qJqO6An3ntCuqZtXhW8SjoMyF1Fh6ZDaUDRDvQKUWdN+bLGgezQ", - "J7K2ksieWMati/TZ9zFAbCKm2ojS03vIxh49Iyy8OMutUYlo5AXzkLTSLDyO+CHQ7/JKWnFUdQrp189n", - "hRJtv+nUyLWcubm2gmEWSNIGjcsHw3BtrxveO2EXuj5g6kLWx37Pb9GN+1cvitGlMLZR1Pgb/RAEpLDR", - "sDHuF3zTVOFUjvqSZzLlTlSFNj7jUtlmHWBSuwd2WFHlAvnYp1iTpiRfy+a7gaUyReYCbKFPTEE6/+12", - "ebky65Yd3UBSb8k99WXl2d3yWD/zeRGqGRF0cJGC52SmgWzOUMnqzDLoG7wnTWo0RrYXyskseMWOoiJD", - "hJwK4A2rIAJ0hgleYXHo2kwxpJQ9NyFXn2raOroLUBsSu/gJWCfBzkNUEG9odJVVLgh9sJy9wItkmqEX", - "9kyMMr7UhQv2Av9l2Sf8sO/TgU2lEcPG1cXUV0ZY51nNYsieo3bXCO4cT+ZocONsaoSd+xUveDKXymvP", - "beMCE678/VFlYwou8hXPyYQbOJhF7pbVn8K1T2ejlSBX4o5KVL/a26pH2jDxQT/Sqh8JeFZVmt2jfmTj", - "CW17ctfxiLIcNMlk8H0k0nJh+BZPkNmMgIK4cSKNHqPR/TL8Mqw6Wq702r5Dfnbbt+K1ku4Vl9lWphmU", - "JwmGnSkNAgeTSjoJTok0309NaSuTf6CzrXQGBzaa4pbdP5k1Hc9uRGadyNtRkpK+MG1KPPQBE07k9DCg", - "pXqnDy922cJMIcgec6R0cPrASWxf7YdwVXYip0YZpEZbRgwEBjxIO48uH+J6zgvryEE7K60oZKR2cC/a", - "IXun2bQwJFqsCjNXIEqQoMLwVSFtoO3PQcJNu/ZAx1vpOB78JyPm1oO6l2uzhtiwxAKk0nLVng7gAiU6", - "AAwPBMCuhBEMXcCKPPrP2wIrBUAE4NKLsCF1WZ0gqzdvw4h3ePl+ELd+sqysqoFl8FUZ5JgYQXA9SIu4", - "DzOeY0ABvYNerD1cjAjJaVak8vDmd4YnFwDNiyr+HeDVq9KyXEvlPiufeeAxO/OYT8pebsNaAq12tTrC", - "9q3aF5njFwKpLMKrODDVSanL/q7xhqZJbt+fsjBwqydCLozUqUwqVYBXFU6X3uu+GwWWcO6ICFcW8UCD", - "W2lw4xHcMQk2nc5uFJg3GSmo4P1AqESnImUn7/7aEUHjtk2WTmyV0mHsDWt8RzfU6zQTW12vw20m0xAa", - "uuJ4zdnXh4cLy/5VSOE83ZElVWkm1WCaYcUIjPHz0b0dNVF+6NvS24qj7QOFrVNYVVN6j7Tl8e6N5qC7", - "3fg0XEfAjHqFV6zPkPd66kVkRCzcbZ4ZwdMl7I/HPVTBg+RIall4AyvNciPBhyes3YMYI4yqK6p0+302", - "LgzWSwiJF+DvmC9hTGadsRE+TRNswLiSk+4ZGzcgI5qicm7gtZ4tWa7zIiuLKHHHEm5F13R2d0QsrUf0", - "cD9tpR6Poff/Ct18SHcciJBgZtxtZ1YlwNBjNXeKNqvxNutHh8a2UXNsp1+2z7dV+c2rtJRwR0fHHz6M", - "Xrx/9+74xdnr9+9GH45f/Xh6/LI5eMtPujWzR1hUxTkmZgd3scQeRw3UChtp9Y6DUStconlgv9LhB98U", - "8m5U1AE4wlpeoWqovE8p9IPSVyokZZUqyYpUsJc+j0ufvRIumffZf37/oc8oBWmfnbplJuxcCNdnrxfo", - "H/VWpJL32SsNfc7EtTuDl22fVai7Dx68p+Av4frsLVdyijM8MWJKY7x3c2GITS60EdsVjZWzqWFFv0TI", - "jQENfgs/EJjOt0w4PjTxt2TjuH/2W531A+Pdynj9od0/x107lzvmtSHF0tY8j6EhyQmk8Q85ZPxuNPKe", - "eSU9xy7zrqb2WK8z5bclpvCoZjsnVtT33KfiWTPgaSrS2IdfcplhUIQ3eufFJJPB2+5jv+cXCXyglW++", - "Dm2G0IZJlSIEzLmD8lRhRXonTNR6dplzg14/OWUqJw6HrkGN+y/tyIhUGsCuDaQobXn32Gp1DT1F32GC", - "MNxSSrghyQr9yEBXSglAEfiVNCEW+K/HZ3128v70rPnGzLV1o8DPmpFgotMl3lUA5eDkx7P46uvD4uI5", - "t9yNtLRmAnhP922G2aEqvhGhFx5DWWGkstm4jaYQdyQG9FmhJNR8qOQUq9iNHq7821/5sYhFjSeWHGyN", - "IXSTBmyulRU7iAPUgRmRCCwR49+dr6SJGhBPn9QQ0R8OxRshqBt68iNSluTLeHrJFWZE16WLT4V7f3qp", - "o7I7D2JHB7GD9utTyB2rJ3PHggdgbeMh+ZOooXfJZjGB9NQnZ2ZvX789puSjjUwQuo5anCk/1MjHCGek", - "uOQZw3deolFuwK61Wj8r9j7sJLwPhBOKFLXZEhxsgQ2mAF22zO5+JKPj6VRgGY5yB7sJSbEUWAIKq9iJ", - "e/9C7wobZKMud76eVt+s2UYxcSEXbXdVPOQAMC6MBAjAhIO5W2T9UKwBOmJttM2P8Ps5gBch7YdZkVGJ", - "GQdhZLt86mMWqE4YHcPqkx+TthTe4Dx8UDD8xqQNTGjcGGhQUqm3UniMpvZbKPXJ4aHHh5Ideaqt02lj", - "blkcoUXf1TiZSjrH9z/02Tvt2CtdqHT/pvKV35SSA24UpKBE0gvDAcPbba8UNhbjG4I7Z0L92B5X7Lz3", - "/KrPThXP/9t5Lzi17ENq1KyWZDN2ls6KbAq7sAQChHjUIfsQTibU8/Mj+Bl4kbxfCZKnbxBNYk5dC93H", - "RAjDkIZzPGSRd/g6CWFqYwA/ZuEiZzIWiO+qrAcAtxXaVk/iQWBrFdjQy9/jxj0Ka40nspvReEMq6DJ5", - "a/W6CCHiFcT/tBmfYXQYFTFBqxDu0k7+2/lUe9pmmMWWA3ipFy8o7SOYRzrYF1++f1vrECpdwH4DwGEa", - "ISIsfPl1rGxxV3TeuKgHgt9M8KlejHwGUDTN3Tvtt5/SXZvk0nwU962BU5BH5CJk02fk4OULjSrm95Zx", - "51ORr5HAFPajz4zIOIpFTq/dx+TSuKe0o1PDMgb7Q/ajFWzsLKUXv6q7lzWkq1jZ//rKtkoibzCcq2sW", - "QQr+aski+Nhvi5flkKUB1lRcWZwwlwKDQwOkuZyiWrPUM19KW/AMdgfD9pZDdsyTea0DeY6SWvfxwI8K", - "izafjqk8+MR04yH1eMF75h8emwFHtuJyUiwKT5w13Np78eZ036N2TORwIgxugEoEO5MLkUklIK3+p73E", - "Vpf3cH91wz3YsE+Mefdi2yzacs+8XMl3VENooZxZrvkl7/lKgId4zVQ7WJYLg3WO9huzI1V3dZQKx2Vm", - "d08HFcipsnGMO2fkpHDCbqE8XNI67c15Cm7mIK5IlRduM0rXNsmnC05ESloKrEWAQIKFCn00+14TCheV", - "9PzhxZvTZpRHcaEhg1R1XJtoE/RG0vqzghpxtBMhQuPN6X7z1b+Gk15xtWN5o5DqGL8vqzLWtihWU2rL", - "krM+VuPhlfTehK3b83OtxtOtLNjPpcyU1UEISvKt18Ubn7jJi3mgojrhEp45b16c/FbviyQvmdHDPdF+", - "TyT5fV8P1ZO442shS/IbsmGP0yVKE0bflg37rMKN3EemJfhA/29enJQVJeQ02MZaK6yNmpkNvLwQSRrg", - "dkr7p3TazjJfvn/LoEED16yM06yjJkVOy7Qp61LXiT/zFzYgvh2QdcNn+I2hiWdyIdVs8DzL9NWAPD4a", - "1wu02F7/gxvBWyZECZaZ/VfB6/dBCXub+1UVIqwnZBRklzIVOvzUUq7sfi+96tSAh9Hp3cO9hwM1CWc3", - "vvS233Sab3/lly/3VUVeFrp/DhVenPvDdbblOtP83h/atbP4jSvn3LyGzl+Kau5dDIruRrHVEp+U2GWN", - "fpFfeLhAv+wFN0YKLH4Zkx4hulsmFXKtCdaKc8zXe/T1w0NdyqombrUi66flDiu79cAjNvOI8rDumVM0", - "nctuFr2b3eoqYDm12LVc7ztxxTaX7GXcWjkrc5xKu61qb84NiMXt6znBButLIk+tCX1fDmKfhUyKOIOG", - "ir3Njlq7l+O9s6K7n9ayWuKA03dW+JacaCuSV4lFnUlhs73l2BtU0BDcYoiLdX9XFOyUtXWi3ZzuueiS", - "ZOu4UzO5RAu0tKwCniwxWAcU3c3Za5WKXKjUVwSsxrw+Y5xZqWaZiIkFg5tVTPSH6WCZdJ/Sx+PBTLPr", - "ffCJTDVnfPI+F2qD0VGJqyjgOD5hOvIT2FaNnUm2IXYwDLHJZ5q+QNxHvKZ+UNcYHi42RD7wWio6acvo", - "5uhPfhVrz1tdK5axLZLZy0v1GOaK4BSpAtEP5Mqm+GZIm6NssSB3VwrfXpHTMPN3KNg7x5RfzgjuMP2+", - "BbLMRSJ5tlMs9F1JZfVTfhDKNhOh45MR4fUnJb4byGQ4y2bJ6azNwwpoGH2APekiMWglKKhJLXcVMprd", - "ucJ9p8RVtoxD8cm9SB5OuqZyBBREl3neA22iVCquWifTKMYEUBXVWTuMO/MCy7gDHH6eSyh138qhgenQ", - "kS64QhVk1e/0b29rCYlTIy+DsBFTfc+5Sitx7lT8fUD6zAHPpa9ndMSMSLCs74xlciqSZZKJPpvKTPh6", - "8ygO+dc7TcYXKI4JC6FFmBqmI595+xDmoLeo8MR6HdmS5X4DBlKlRRIzPuZGw5DM8kvRZ0bkGV+Gspj7", - "tcXyGSYuTkgI78p0/ai3ZrwNx/fAettZr9+uEc/lCFD6Pplv29HsXk4Jia9WS2ltIbGQEnvrfbLREfuI", - "8YjhRMNJUANpeGf654d/cKDk41A7LrHFONGpGPsT5rb8DXzA49BNSH/T8k3EJUwnIw6MR4M03RlvsT5T", - "yowuHPi3x9Z9rA8R1uPZDn6HjvNxCsQIxifEao6vRQLSH+Z+/RBY1Hj3XBlwoA2hLNH8ts4YQ+uFTNNM", - "XPEdAzYaIyPgYIddks5VoiBq+12JheiYj+7E6OvlsTHabFBycpUKZO/Xy0HGl8KEcIeyHkc9UcqQ1d7Q", - "8AtcApoJSqI/19YNEB6dtGU8DkO5UcghG+tJxF0KVIIRDP85+IHOBFcwwCWMfazTEab0ekLvj/VZW1+V", - "6unhV+X8/NPikY2Rs7nOZLKkVzMNmgrrpPKX1ht9NbjUWbEQMZO9xIXAVqd0luy1s0Exjm49g2r4BnwG", - "uSIYZKXPmOrbhIgtnwzK33NeBKEpWmcEXxzRIuPy8CbFiA86HsxJUAZ/YMGrWNUj8/VppQ2FQzzDkRa+", - "44rp3A2kYkZMpSKrXIib41cREDG6+h3MUjHlReYGsN5MUIUq0Nnx7BPnhFrB8ofLuP0yhp3yMa73eA03", - "nMddG7F02mQYrnADYjTQ7mgTS1kJe63W3m9kWnWG2ML2huxvFHG4kNgTk3tAe/wVXbrtUZXfjHwtp37t", - "S7xGR4WqRIEGpSBxr1EqlIReudFg2TejScaTi0xaV/u2UEbwZE4g4rdU109g7L+cSTVymUULmi5c/C7s", - "z0iqULWwT8uoT8wIwCIA1zTtIideVoKP36TKjjxrq3xbT5g9ZM/r50P8C50aKoVOEj1TQHCyEhLJLSsU", - "1JuqRtnVYAHz41A2MvX6m0AsDefT6/c2HlClwFTthIgbrh1R9evKGVW/DocEssDaKZVfNhwTQamfExbF", - "aj8oeLuunFT1q8pRVb+unxX8Qhu+zmH6vesB7O7gkhsU/mCbX5Yb+l3c5cqXH2CWP9Ym6aODT3CLX4Yd", - "PvF79l1tg8O3P9b2N3z7odxecuU5y+xZXDl9FWL/X1e3FplIfVYf4s42TPlHv1sl8PDNS2VfxU0NX76o", - "pm8PwyHL+jFs7m5h9XQ4Zeg0SkYIqVma9hTRUG+fK+mghshmIY2IayUTAw6aoJtXJEsUtYRJONZTSubc", - "8MQJY5kunJWpYP/gg18OB9+OfiaVQCJ8yMuoz7gvAfrN00pHIuIFv34j1MzNe0ffPAXjoHPCwPz/V4T3", - "7/923zn3NqUwuLMg+C0nudMTJSb4Xbv39r4+fIKC9W3E6v1dnz+IgnENG306Pog8866WLdVjRYoZwY1c", - "wHSwNph/BYtrkZCArguXF45hAVWYbKUDpQVZ8Dz35R3x/tkixsCsMIlAmFq/R7H0W3tBmoHQ6WMUppfv", - "+ALGdF5FqpXoLlOtg+3crbaG1W2v/bibphsE6NHkm6fw95YU0itZPyoUjQdx0NRjVf6lI9su+ZLQW47X", - "Lye6Qe6FvfBZxnbUOPlezGmPi8KzSSIzD599OD55s/6wamTT/8EvOWW0YAJYccjby1kujJUWzoq9A5nn", - "n/g0RB+rc3UW3RwmEu3MNrT31dpgOs9PXkdtsLiWzlLxZZgdk/Zc+coT2lS/Zk6YQHghMTdGXGM7uhWH", - "7KScHAoI5wpLXMhLEQxzg1mmJzzDsobWamOPWJJpSy/jEKhog+qCZdyBNk9k2bkilxLyfGWvCkUlOlKR", - "ZNz4co2FFaU9PwzBcu7mlZQa5wp+RqD1sWsDfGd4IjLUmBeZk4MwDugSL7kZnytga77KL6XTgaGl8Zb+", - "QfwZl250Nphm+opZseDKycQOCQ6T6lxV3FOEjWVACLY/QPuMTcOaqQwINByQ2wAWcrUs1edKaVfZnfEQ", - "zoEyQRtBr59nbBx+H+ZGOw0EMXT6FKlpb38MRRjPlbjOtd9OXz8ZURCoFs4vk9wO2RtxjZWl8bRRtRFG", - "ISw5V5lUF0Fv4UvHBGmmcnQkE3A03wAswCrEw4iDw3P1PHTM/KhlSTTDMsEvhdfKIARPfGcv//6serLn", - "KuGwSZXOTLohgyqxMqk4CslFro0LiyI58xliWLpUfCGTczWmNnv74yE7vs4NXachXw10pJeNL/fMC6cX", - "3JE5esje+8vKniudE6d5RnwDimDmRoN1hSld6pqhIxsbkWfDKyOd2BsOh/tjps25om/FQjpk5/RLH6eb", - "aGV1JrxESfq1RC8m6HaNSryFSOZcSbsA6estVeCkso+l3EenEfIcYqF7lEFCQjpUk5BzwJ/ZW/ld/1wh", - "PXuGU1ahp3RaoURBysVCqyiW6ctQ/AO/f2QJ2LnyDQbodoljRY/+wJmCCOexpUVqE16+QOVXCz8/8xBF", - "rfYnwPXV3GPVTbTQ+nWqyKpXdcVVjRGxypEVSW0e3xz217TxWM2+It2EEipBicReUm/Y/m8Oh9UK+F8d", - "Hm4uer9WFTYV2+9GW2S7X40hsWj1FiQ0jytruBTbJEFPKEx7kRDzgfn4CKInTzhRyRNHeca013tr49Eb", - "MVvp0JXiHKl7r1KHv6OUVZH3VmvzB/+0LopJce1YGfRRzizUxNVmXVMZXwKkrazcdpQHoH94eDiA9YCm", - "mqETtOHLAH1STKe4mxPhroRQ5Z7ZRiTuaqpaR92qhapR5dmSwA8fp2whrIVNkVWZP+otGqg9z5ofgj++", - "fvkkPAGXYZPENU8c3byDuc5w8xBZg7CE2X2DP+u5ilPAywOjgjDwCNk0SRTojS+LRVnfyD6Dt67CsvV0", - "QXLlGSRyFoihzTOZSBcqgNU30Sv3PBWBANbK6vJsVAptmxXhCC0+iZF0/OaRYjyCIaIq8wefq704K5Ql", - "Ep2xRBtT5GQ4RFtOOdkDwNtiNne+Kjm+Ks/V2Up6UpbxXyT5VhpnI7dFOBVJwc+xtgMVNLWOJxcNKhD4", - "GsundcYkn3qtqUq38DYVUeVpIq0lj9xeDD8MUCLtFmZcfQju9mYD9FOiwZsGRQr2F1bKF3DbpXDF/iUI", - "EcNMzw6kmuqDVEyKGTYQxlQaXHGjDoiKS10sQkNNQEraM+rWaDkKyeq2vgaxYdfHYFh1f7Xb2u6eCnMp", - "k61Z6MiPJkWLgkwEvqRQKSGuc5QVQcR7XeYJZdbp3HoTOdmFtRmUqdXtvHCpvlL7LNUoNgYBsOIW+f/+", - "z/8liawcBcf1Tyei0iywksFMXopBkQOqKyvphZTqrtY98h26rXGvYTcfDHytBj6PTJ8gmVzbudzA1QZA", - "1H1tVpZRetocX0tHfBIQlqzN8Z1ED84otxUqFSbD27nuu2ZiLV1P1Pi2RLoI3ilAkHSduSVpN6JjHMvn", - "3D9raeYhcwOTikT5vXru1n1se/L6pX8JkmWqiYoQckPodZehh2yMRFvkY7YQXNlgcMSFp3gpk1+2xNys", - "hqE9RKSMs7ngmZsvg4sAiTBDNvafA0DOciMupS5stox9aiPUmdd4xi/FqHlC4SRipVafk8+/jkJxWDxl", - "R2KrM3CWz5gqCya3IQoVTp7KavKPcKykx7IaXrOV6qc2hk5EWqLthCuV9qHX7/kVNTK1vNH16PXLtRyI", - "tAUxU3TUpq/uDQzGiny9mnTjNpH7WKYVdI21XTkpz05ev2xJ8Oo3UPFFs0F9ZvjCa1Tqywj76X22Ei+p", - "gsOWzoWa6Gv4c821atyliHd1Un1PFpt4Ed407/XiB9nqTwsS4hupimvv7cXev387uJBZJky4+FA1GU9B", - "KjQ/wZL/9nbI6OpIyTVgfJCKy4OLhZ2NQ9AD4BlXJT0g6BXX23BrLMRCm2U8Ua2qzy0fgBvTU9pi4mGK", - "mOWZ+J0tctgoK9JPfCWvbffDjdx+I+NmjbRejAAl7vNGbj6W3S9kmOfKfVxfRLyPm/Qu1hkumyjwp3md", - "FkQiU9L3BVIcsrHSSoT7wmv616jlGRsvxCKp3EvJzOgiDy29do9bNpdQ2jDJCyvcmB1gP22W3jmDoofe", - "/fj2+QF9MQAverCmyiwr+bNWfsqW6SwN/m9fDw99AHwqUxI/YFRYoHWmSCgz81jrBS7taMwyqVY8TGCx", - "mOp6kcDlQvOkL8pZNlLrQixGUyPE6GKyvtGvjBCMjixsiVTsB/kd825I1WwoMLk+SwUljo8usWOAfvQu", - "OCJ7XTjtwyPL3orF4LWaapYWi3zInltboP6ePcVxyFVK/iKG7GXwzwnZ141IMi4XqO/ANOQWxS/O7AK0", - "0+SU49/oGTczgac2ctrxbHQxQeMCsw5wFI6fdpwWe8VpKJT82JybFI0WFuvR+9OU08pK6mfHqVoSziwu", - "0Pry0eeqkdyrU2tgXPDLrY/iHe6nZR+evyUsusVx3M8ubBN9/GUYJJ9mGPRjiyTyQi8WzdAYr2fAr6xr", - "b8Gv2eOv0TnE9it3Ra1Ziz+5tY1H+kFYfBgwKxxdNs2z8se8ZwucN1daDYy1FFZDf6FwO1+IBXzcB5MI", - "eeUCtHy+tGii8lhTlQ8BzQuL0l0zEjVvsNP5yHF7YZvwNGelkIHKO1rlwAo3wFX6oRa66iNMGGtp7wEk", - "BSevSEs1VB2fwRToiTFmPvT5GJXpG5DSR7hB2xccXwPcsa+ZUI58xjWb6EKl8dZCZEdk3UUHX7tBYZ5I", - "4fz6NcH4el0t74yczYQZbSMA367yFu1CinSZcJUCJxu/OPnxiL0DUR7+AwRxFL2tyrul4dzDHDsTWEQ0", - "NO7xDKzD0CxqVyuF6vy8nWZSXeoLEphL2XrI3k9d8BZCo7pl4+pMxmyvAsYTUcXBSZh9zJKScMVSCWaG", - "8sHkOyU0Tf8z7OmlTJxcDNnbLvTfqP9eLVhe3Tvid5FFdBXJEKF2k8aex6h/fyKU0GobVeEtsCabdT/3", - "2/DNbZSw8Q7oznTrt+g6V+rgaUaH6E90+1lWYlM3BctWSw9RhOqcR10sYXasjFOLB+/3JIa89/o98KQT", - "ptfvTXhyAaKtSke+TXgaxyZ2zo1Iy89Y27FRZgzrCDGbL+hxIYV9gQGbN4qS8yVGykDQEMhihXPoPwQP", - "iBAZ2vps4LlL5rtHCayuZelX0lxnKZlzZnV2KYLihOnCJXoh7NCbWBWJOfc5j0wKSgLJk/lBKhxmX48K", - "vuDdCQhFwQIgJKAK51KKqzBPqzNxn5OkEYJ1dy/Tsz4Du0yfXEL3cVbrlri4j87o7BbzIwCt03s+A8nE", - "v9V8FDDjMy6VdbUYaTB3wHgF+oARVDKu9tlJxpdXBsvv130J+swmRghl59rZPksymU80XMDkDtavhjqX", - "QPViwVUaypZeipVj9BVinTD8vjHsR8qtHIcKKtG9JJPJhe2zC7EEO5HFheoM+PjHGLdwjxPzHsd4qx9E", - "f4NQz2hIOZxm94nXJ5h6MRJb2Jhq3h4qkrtSPwFyENP8Qgz5fTKqLLPVsH+vgVyL9q+XodqLIfzVwP1+", - "uG47hervD9nb5gj9Z0xPp3D7e3cjhEGRg7gvJcXc5+kJI3UqEzbhVnzzdBA8wIAx5tq4Kt0O2fdyNmcU", - "wbl19rhX9zjz78qcDWQ26YN1f844RjkM9HTgX3moeMLpeevwIGjZSesODPbjBhGlZUa7XewvqjhBeu0g", - "hlaveRph/S73pcY2uTpIWytO5kWGFMzdrFqQmVmR0Y0MzejEjsgJi3xupPX6qT1/b17NdSYi8P3SqbP8", - "EpDBa5xgLD+4Je+dbFltK4VFidNp77QI83t+9uL7SsnottlYn6eLq+AJiafFxr9+HO/DcjhTeqDzZ/XJ", - "kSMwRcUHv0FvjjvTvowbVh2VFv/kZddLyWl2fbbUBVsU1uEscArBJ2gMCwGPTzbGwx83+750QrI0r9/U", - "u6HZaVVARD0XZPD0F2k05MEPL8XlmdaZ9RIRKXsapMhQRnXkHVUbEhTQD3CgiBlAfkFYrw9PYVhD9j68", - "wzNpXTzYyqkqsU/+c8iCxKUwSzDMeH0UzQTs1klWxDxYFTryYnLIHKHKWrB+KtCBtJ1GZFhb0GfPCiy8", - "UOQPlvaZdMzKRZ5F5180CfqK0JBdVSIup0bnCGIuZ3NhXQh099uGYtP4tcoLN0ylzSG66a0ufHVfeF0a", - "sizOiwVXGAqWFKb0kwfcwnyonrROI1see80s96w64ZZ8UqInbmFU8KarkzJQ7e4KHURR3EY6+XXPyk6I", - "fhP0PitZZQM/jZkUTtc5XAXpwhlfiGUT7uGMEf2q6QPCLWeFO2IZSLhXAv4t03HwzLtOWF8MQ2d9Vj5/", - "+ixID/5dtj9kP1GZjrGf0bhf+ktUmCXwHStcKDd5hGwTrSyBxz8DIykZ3oMzLSx8OiWPcBCYK/D2/Fsn", - "Bj738U3dr8q3+302thUUw/xwQYAhE0/D9Y/ccSJgyykqQUOQcVyeP7RQXIsm7FfFkkxwQ6zJNZ8yLWa8", - "0Eo6iImMWIwJ9cq0DCQN7JPt3pUwgLPPhRHPsAxKpq9s3fcfVWDoxMGrW1a/TRtswn55XbNxtWoKoFo2", - "tRn5EMBdQZ5StxIeOO8YtyuYY+xVQrFOG/+G2Gk21C3A6cgUbnz1rUtYSEfxgepFK3bKF4KNPdqNy8gf", - "zDyolgx1PbF9n+VZYeuKlwoTWX+r1hUN4VptciVI851RZlU4gCN+kAz/GJJhjSp3I41X2lxxSkWnp/H8", - "K3zWaZq1DyOrJe1ZyaCLaTcqWHTEiMn4G4cVKqMQRtoBDCoiDj8XRvRRcPJ12FXoWhkPQXtK9ihKiLMH", - "PtshWh10ZfGq80Ao5s4nd/ffOU3oVzWUhG4VpAMJCRo+o2BOwrnKCIRmVeQOqOIFzSguNhG6dtnOlP7+", - "7M1JnQ13QZG1XruhCXQ/QIWS377A9W7wHm1AMoncExCxlLfLo2Yweh3z3tckjCH7npPojYXb2V6YpONL", - "y6TiWMx9P0YPbcWtG1Ni/ZrdbY9fe//XMisAwo4ZfSnb6JWygW/jNvqComDuJu5GGImvGL7A8CPltH8o", - "xa3HNwrYsVarnLO9lbTA4RPaDveRXdP2+bTa1mkASOowi2bDiWD/1FKtP53WTDOLTlRM5FuRAoOn8M5E", - "Sc4ukSRxAfFaIMtNGKc5sfem9PDhnGqun6U5qNkcuNpZNWf374R7NaFqN9x76YVgL8+13AVgBAwWUMQg", - "bC+G7L2qUKO/0kFwDmcOB+PRlg7zQojcMqdTvnxk2UTM+aXU5ojJrthAnmie1/ThapEXILshao773pTe", - "1OdumDl7D88xrzSJW0Vp4cImyjhBfBURpUDsGf2sc6FsmSRpKo11AVSd6Occ8LEEplLP2gBElDszOY2W", - "UKms4yoR3tM+QVUEgAm1VHj0LcARvBCDw0gbw6dpdk8Pv22ihRsy+isDm42FIJuRyQfJ2lLYOxWOIdrC", - "V4A6YeO18iu/FF6D5Em6FC0aeD28pMGvBaPKJ4LZCB5D9ePmlZsfsgaG3QsnvPf08Nv97rdFiC4M7xFx", - "HIInd5HYfLJIdEqY+AygwRu8vMRQz+N9AK33nKRwBp/ja+08fbBmYyhXS6REHG1EoBccqTo4zB+UlhHv", - "8XkAgqQCzD7w6YcPUmkx8zCoG57FIhceoAypGnwgJ8hH3ElfS7ti0l+ZCToaVCE1WuitE/mGkOVyL6Eh", - "YUO5eWXYgs5HYf8peY5x1S/wT0HepbDV/V7cBEspb2D9oaEsFqNpxmeWzge2aLsPc1hzOMImt4oXYI5E", - "vWLXnCkruozCuaZqvQiS0a/klkSqIuQdlX3KxNT1+j00AcNUMdOr97kgV2+Q/xrPCS2pLYmbzrz/B7bx", - "1unKqGB5xeRpPQ+mcQCIHh5diGWTClunlHUKfob1Qdugk8U7AqFW9KQtcZClE5sqFiPsZWsZBR6vUvo7", - "TAOMLF0uhCesXHgfnDDuulfP9foq/pMlGs2VvCxUSTuWa4o0bIS0XIf0XzeBtIKu1z0A3YKkZP2/Wahs", - "CEVdUf/4W7x0LYB2IUvH9sTzbfGnL7yrw/PSxeAGrmbBYcLjbjUnEbcs5wbf1pxYvVd0wlSCqzhpZjyL", - "P1cllJzKNsZ0FxjmjW4A+Nyn3rAJqOaABr5vzg1fCJ/b7dgrY7SKv1PPWhY2mFDU8fpkis1RMkjKC+AZ", - "2x6+6wwLwmYMn3Xr/tLw2Wrvhb4U3Xq/1ZditTf6tgOb2Nb5BBr+IJaVvuT6sa3jKbaqdhNuRMaerV2F", - "e4ENq70zIbbqF06hkUfhSjzNejRX8LRbw7DaPVw539p+E+QRElN1K+PW1M62tvKwkJ9bMo6NAtlvWibc", - "ExCDH7enKey8kcqN4E68lAZNCMubXZ6LxqRhUdJIA3QGDdmeTjCOAVfZZxjw96evv96vy8Z/+vprFOIq", - "qRYPB3/6+dev+k8//ltzxTY3b4iMn1idAbcpJwENYYQEl74yyMHw37e778JIjZtZWKcXP4nJ2xcnL8UU", - "o+m12nEz6RFemVLiRpBl8mefavLnX5981bwDF1Kt9t0DA9f/L0nz/cYeyOW2cqrKqjAnf3jv25wnzQK1", - "03orNyCAYIoPBQ/WNjq61NJIfoVh2n6YbQfxNqxxhzMoTDbyu4if26WfhVTen/9xgzG4upgazG2Thm2x", - "IVXsjpOHXanPuuvpVnD245bV0CBNy3gpMuHECXfzmzGTLXQcqDfFYe6SemnisTLEzWbfpEJ7vVZeqayQ", - "EzUhYUV9kousJQXjQWx6gE+vIXue5XOuioUwMmHasPkynws1ZD/NRdT19Gum+/XRpPWjpas8lg9+eT74", - "++Hg28HP/+PfumnqXtITr6Nmrr5dc/QlaBdqw/OZ2pX1zFtKt2NenpHhTmwH6VszaA2Av/8FIhUw2ZwC", - "7ZycohU9FU4kGCy03zjolUzdfPto2Gzj/Bu3dlXKu59HLYgmLQ/a+JCll21jrLeAB371rbeWPO4lNFlN", - "uBXTe/mJwGM2aP+o/oPTDGQsxjMdK186rFUcc8kdNp3JxoRgvuYZhlmW1WtW5xbUjkC5RtAOwVwWMceC", - "XWjt5n8hHR762ECf6FgBr1pYw4RbtFL4AZF9ZZhLupYh7/HhYS1H3teNC7vNSx6WsNNDvpkRh+TH6MGm", - "p+wf1322/Ln6bM65NDaenZsbXczmXnkMk5hhTN9beE759xnjjmWCW8eesFxLH9QRZ7o65WrAbAyne1K9", - "i5+sr2bjj3SWNRyGc21whic3tQHq478Tv8CGJwVWpQnYjCd8xZe0EFS3Co6Z0zOpBPfe9LnOvLEP+TaO", - "hoo4O8rRD2aGmEbkIPIREtloQWk85Uyhsr0lzVileW1JX+9Il7HqOs5r7QRf0yzWqWErfa6ts64pOmxX", - "FcUpIW7RvHI0MNF++VBmZBPtE2RvaXrscW2u2/NStsoOUdXdVem8AniTavOY9CVliMmdZYVeiVrpmAwa", - "3pqUDPqgkhca2lZgkyoHv0QTA0a7wO+P4EXyqM8e+QzMj0iD88hbUR+xS24kWmtIPbPIM3HEznv8ikuH", - "/nrDmXZ679HcudweHRwIajNM9OLR/jOf3pZVmmNRx739Z+e95tSENOPtOohyt459D0yf/gVmUW3AqFvl", - "Um2NflrDqLvNpxkmva7NIVN4THXsI01xcntUwXS/9zHm/WvKyUhh0jjfMkK2urAGewtmE2wH5gPgOkK7", - "8xyP/Z7jk+5IfsYnrXkhm5HKm31+zCHs6W2ROZlzcsJc9az3LW1TdjISK8o2wDQKBEnWT/B24U5UBYQu", - "kcmvKNsK/AgQ0fLuT8GP5N3JD+Z6IQ4oKLk06NmD8+Lw8KsE+uNfYuXh9Hzwd9LPDEeDn3993H/y9dfN", - "WppfZD5Cu9faFP8uc8ZNMg/56blU3rOvUDmHWjZlBtdy1nueP7CvDyE39TNSVIf8KOBTPxXWDf9ptdqv", - "Jh2aSMXNcutzOU7X+3g0HX1FCjvcRSVSQYQmsK9kJiBfyPoRSztKpdlMGyiHof9jVP01C0wLnWJ9ogZk", - "BJF0gYK1T1kA7Wqpm1JIz4u9m9RrjfcnLIs0oRPpfArOPjvvpebq2gzg/+c9eNif9wbmamAG8P/z3v4u", - "bjfcilqWNThA8uZc34nOGtTw9lrrByH0o8nSiQZ6PvXh9fjzkB2yaWUaUtgOkfUhSwLH92llsH7Ag8oZ", - "+k1vQydKodCS1O1VWaKYHGHK2Prd0Y+js55Iu+PhTc8yDnXTQ90NS5pNKD7nGZRuqCgRXnw4fn523Ov3", - "fvrwGv/78vjNMf7x4fjd87fHnfPltgreP0CpojWP4ebzfdlcryf674Xuwf9GBP8qkh7In4cSoZfpdXhM", - "0MUz5vi1VnqBsVceTPDiKaF7Vx7y4RqTXyI4Y2izwMtOq3jWKAvDVCYCinXskTWUpkRmUu/iPW7fh3Gf", - "GTHjJkX3ZHRk1iwvJpnExItQbOIFOrMNyi/9BqCn9/vTM3YQZ3/gfwpZA2OKtuAPibW4MK2aFYKNV+YS", - "9SpX0ghm5zwXWN5QprGIsPes87l3qqH40sYNDomNYHhQhT6yIed88J45V1sKLsUK0ps9k2t11fsht8Qo", - "mcM01UyMghi6OXSMur0IvUh2XgWK6SR2AngKPTYB8z5dO0A7pR4RXBnH2Dk8rt4XA8G69MWG1b5wfF27", - "v4xtIwSK9vIFSrcAoLaV4sZl/0zPuvV+o2ehbyWijJxhtkB4XbZHx4AmOGia7wrlB7FsgkHW6JEVzmUi", - "7Q6OTPen1C0ABsfEEcTLdzzkN/JS/E2Kq5WTLsF0Pu8Aaf3QfZBcBdTWZb6lLi8rPVahSSVjRcpOwF4r", - "6cstroKKpRd2gvch9NoCdGd467Cq2Re6gCoDcgOkULRUptm2ina+KOHrNBOrvYH7SzXrtk0ezhvqU9+k", - "ANAEtVkXSF5btg4jmGS7AaHWAQqoo2Iy9c0QIOS5lvPf9071YuRdu3CHOgF6qRfe4+wNdqlBpOwkHVkC", - "QHuDHVZ4QQ0UJDrpDgha18EkeZfeSV7vpXmn2Wten3SZr6VD73excQuMHfaxhNW0l45PRjoXqhOoMz55", - "j20jCB+xPOoo5Zz49ivSTrXC905V0yu5xbrhe1OZi/5auuNdM0nfVa3L1Qv+Y3+XbpVt6dixiQnt2rXK", - "enbr28BFdwNQsvOO/Vaxp2u3BorcoWszW9wBQMlLdui0Qqs79KwRxy7TXOWzu/RN8t37rF8QNzrQm0Bo", - "FqR37xzl5927NsjKHYG0SFS79V6XY3fr/0HcTfcbsI8W4blj79rd1RXhmu69rtx95b27S7fKm6V7t9XX", - "Tseejc+uHfvecOhWvcIN+le1HLt1b9S6dATRKFPctNQU1boGExeqmhvUsgbLIE4blLxSkc0BczBSouph", - "1/xF0ZDS4OUTZZr1ybBMz1ZzBPM8z7wxZGOM3YohRc+idReM/s2K5VAwo8GkKxdkrCtnVC2O2dUi0+J0", - "UR26Scf8loM89bncQhccEhXdmVMogBMGtcZpJR9Bq6/ojg6ibWaMdxULBk2hTwUsOSly3548BaNL7oRh", - "6LDhPR/eoKscGBbJshg+P952uK3GypXT7OT40MXAXF0h7aJI/VIb0V1Pp1a4RhfFEwgxsr6yLDarb11J", - "jpXjonKdK75cfbYQ3GKYcjWlLTYm1xPMDGou8AM57fDCzbWRjhyt/PhB3+6PiACEYGeIHJUKi1d3qmvT", - "bOArN6Tx2HRhxYkPwqt6xtfPpmt0YIi9uXlUYBuEztGAa0FYu2HhHTq5YlTSLd1bU0lh5TWPpa/v26kV", - "5ryTU+vtPT29Qbd065QYUO9WdrHZxrsNPUuv2YBhzOkboWlXSDuh682jOlJh3WhbiFYli0FwNtgW3NHv", - "WZNsA0xpYDrDXNmSOEC/soqmHfLaj+OZEdaeULml3Vzqfpr78Oe/vWUXChP1TXThMEuXv48hnwQOwCjn", - "wJC909SHPkNbkU37PikCZumYaiyfogtXLUK3Jr5NZeaE2ZxSTazPQ1KlRSMTX3CfK6zycZVJ62r+zX5l", - "RkwLK2yZfg1zD1zpIkupjGQVE2xM5znTRPXkT+6rP1wvqbdfJGa22V7fOK606RjfX3QOvKrv0l+FQvnr", - "/Q+xAPr6JuuLrczntUpBxBY2ePR1WJG+aFzLCQS/+QCdmxFuW4TOy/bInMjvnzw93D1O52VrfM6QvZ6W", - "wmxhha3mnS1LpFKXcLkZgVzAi7LeM+Wbw/5Xh/0nX/cfH/7cPEXcWm/C2nZeU4/fhNg+RQg4PuFNGust", - "gGBeSu6Y/QcdGSiBV/OFYcRKxo2jX9tHx6aljyBV+izXH7yanGZC2YKKt/KU5xRxq8RVqLJWuiAjTuBe", - "zgVPp0WGBVzKb7IW9GwNjHrZGhAV0earJ4fdwqPWPbJ3TlMAsmdadWCO3uDrwVR22c4ZKSMU8kJf9tb7", - "/VTgre8RhSCnI44E1s2pMOPWjQobe63NR3nJyOJrDlNDwNRW5hOy/XR2Zgyvnhu6yKNAOmp6B2PSUNQM", - "YBtWVvcJc31koVxXv5bqSavGWRYmaw/G+/HDmzbQSKmUHkrnYnsJJ/9mQaSonePKAf3cCW3fyIV03dIl", - "rbpSEwDb7AYfXvXx0EOyDEL7sndHRdL6zJtk7J2jXvqVdXTdsJ0vstpW3dlq1zyad1vHu42qBN7EmMhd", - "r5JaDfN7woEC6wkRUPhl6IK5X89VyMGWZaEiJrB87EkIjNITe+Sx5hH+ZOtcA4UtUyiLcOy5CtIZx9Y+", - "KUqTXzy5xX/Tkr2hHnewY3J0KufnQ4tQM0j1+5wuC3bDdFer5OFWkH9JKGc+kT6dLkBsTPFCpL417TBw", - "XDTzhWqDQ/YKCbC6l9KyOc8xUx48z51llTPiKj1XdIfDL6FaOi4V1phk2oqUkqnjCVRAS1cB7DN8V5NV", - "nqs5T5nSOEcKk2rM83ZDxu34ZCsHLQFH/tlMNCvpZm6mJdkSn+xbRRUD1aVbWgpKXtGbVOVQkOkO+9SW", - "G1h5npNCenMI5AalR8ybstim/YBE/jm+wSxsjte+dFeGNI8fQnAAul0uJjrDwXEgn48VhmB2ji+2iWC8", - "0rZSrmKyZNepdlpn52rPCsH+8/FjXMtyATeTTzUBtUp9nJ+NYSvnvQ8Yu3Xeg8gINF3Tny+cyeiv55n/", - "6tXX573hOcWcEPuTlsKTE5wgz6yGWSZ6MQmPSp92huD9DxcCLvATjvY/zvgEwf5oad7EC4Gd5IVKXBE1", - "anWwoRKPh7WQqrA16JBVHQE/Z5l0ArzGSVmPLwGYKk8SgXUEMC8745nkVNTYQxic9xim+DcLVLkin6uP", - "t1LbYgsirBAmYkUzJepEWAt3l0/TuCMxhnjSjZcuDXLmi+ijspdbykiyUeV5HEMG2/SdzVUixbV0o+ZI", - "15NQJ/NaUmTjsKVqc3tqSYr5G20oR/8eW3hc9Tk7MYSvzDDqi9Fz9q9CO96PCTqFMdpgiRQe6uWCIhLY", - "BN1hucxFYPFe9Z8aLhVL4ekmlWgLIU+FMaPJN0+b41Eq5bKoKZsUUCx12B4W2RUYXGStwJriWzenhayg", - "7J1FTfNYTMcuFbzLlS5s1lC7iptZPQD/Hw21EQkSN7NiIVYTH2xl4NyOjNb18PnmZRSqXosX5D/oynIj", - "L2UmZqLlGc8tvGUagp1WQXKfAhlaAyhIogLamKAzWVtMjCpopuRQgcDORRbLTMA5mEI1Ilpy1SSVaXMB", - "tFAa0vd4NfZp30P00SQ0iFRNC9iuihbqsh29Go4zntmvH1cP7FhdSqPVgvJ6+4h4mCum89WmuvXDXgPm", - "r8Wk7xSG3scx4GdKQZHzKzVk7yAvjjbsF2F0mVSZzMeen0Di4URklNwCGFVua1gC9WfzZ4xKlZZlvjHI", - "CUvxF+ZSXtatSN8+efLVV396cvjVN3WpqgXD2sPhCd+28olbxcLzKleIGBU3esg8v5f+kVKNTo8lAcJu", - "+YhxZPsNxQh+o/fhw513t3deG7aCS9LNbrVTrNdF7ERFH5AKO6njGZX3qt0yvbPjD297m+FWI0F98x9e", - "v3nT6/devzvr9Xvf/3iyPQDUj72BaD+grv2m1zv0BUXL2X8NJhRj37oNic+rt6KsEVfMkbQK11RWLJTd", - "llam34Nn+BZY0GTH/DQItU8T3bBjp8DOqxvWqVBpgywFrnArMg+V9xcj55bbxZLnvjWQrRVFqgdx9Xsn", - "Z/+1v3rTkekCJYMY1XYpSERokV+aDw1cTCVg6srB+QI9lUWg58tqVqMdjnRtJGh282HW2cHPa+d6g/vr", - "dcW7kEzOnC79TfTQWJz//Wk8rFqpkMpG+d8bdUrgNSnMgFuge5H6YiioBWmQeqLloihk2syI0cjRaCo5", - "C05/pXYszNx328GvsJXUHHeF3bWiW6UgV2FJqmjnSnkxypOG9R1bJxcY6v7i5EdWoPNlLkwilAN9X7kM", - "hem1ttz9x+HOD8rTsFdgjIF+tF3bZDJ4ri3akkWUMzbC4skzX8qYZh/zSNxQ7DjVi1iG/or7KomhKFyL", - "VNBooz4p8cTVEh5441+PtlI0J/x3pW5jZEi5cWOlyEbUS6W62bX4kjsOvPbKSHIlWiEOymcksajrulTK", - "He8k+qTVUbY/9yPcn7eu+VYSPEzHZ5+0AG59hd7vsQ2Ny3R12CC4SQ47Jv2MSzGCl6lKdpHuTo9D+gRm", - "RG6EFQpXtPKs0GatfP1tTzM6ppbIgpWPG1/LzW7nb+pTWsspAoTVSFadmFdk9QRcgqYWOp73WpgKOqU2", - "Ken5vzDDmC0W0cGOjDWoBcHd8LWSn4NWF+1O3tkZDkimnVxl74utwak0QUJHOfo5GHNwKcm8UBf1wjDw", - "bumFh9PnZHTrrY9+jfMMwobXh/TihmZyIX2MKzZIUHEh0rIFxb02LeyEMqUgcd5OrzjR6dJbFRBkKOVJ", - "2Kk8611NHtMgBfjqnG2ZecoysNG8hHrH9FJabZZHvpI0OB2G0X0dDvL5M1geGKWylTKnNXfxbIlgKUGp", - "rdQqHbLXSG1ojUTHfxiwUDRggknIkdQt+mKQb5K0LFwAZNGo1EOymnKSkc+lj5quZ7ugHB7O6KwSEU1f", - "+trUMcS4h4UaQt6DmESlTIvQiAZAGQ1yZT2PUGDFQ+hBnqgdi2LiyRFJdkm8VJGVt1+mrQUhKDRCmObE", - "a2C0s/NuAnUZmxB6tYnTW1XF9FJY/9rGQI7K73XxzbhdZ7vFMWrLZJtKGFTn2bTnZcDnBzHbvWJEm4vm", - "9/h9GZMy8zrADSnUW5z2foKvdwLUMQ6DYIETls4HmZjCLW2UuFVkxg4wG53fwy70w8ZuO7Kb+CWYeNBb", - "KubUEaPxGqzX1dnVLz9zfHS92T3ie23kL1ph1RYci/GFLkC0oYCcS+G/twxdePpMiRmvfQ/n0Cxh0Qy2", - "JJD/G8w46TA++Gs0DF/kzYPfJvYkVvbpbq/bRhXcebf9svxQfajdiWJnkJ0DQtZqMu3ItWSaCrUlvy3C", - "r3ia+E5b3eF9u5ZpQzzsiTALiZEM9mbzR0tWswoXf/JJGw37a0vJ3G7ZQRuKJX3z9On+brWR9JUSpnmu", - "+BMabcN8f2yZb5dMkpTUMC/3lpyiyP/GF5e9YcmWDZk9q0W+dhPDT3hhRTXbNErBNhcJ0H4aTWc72t6q", - "/mRY3avJ9FbN6314uNlhbFUVUhm8cUMcN+6V/QmiP+6yCk+sE4ZqG4A+bM7MDYQrL8V2C0Ckdg+Pxb7Z", - "skPYS2ssFu7ALYO2p4YvRHOQyodStg2N4IinOVDspTBGpsKGZ5Pfgf3qmT853GZOaFSuh7fbmlocn0or", - "ods+wtrp4KApK8nHNW57GUnOhEp9yYo963Te94HncKHC86XvKwbt07sR4rug1wLTfGOhRxXqSUeY9s6q", - "FVUU8jsFoy/4daDF1+qUaK/dHaIcumoyD9Gymw9241ku+DVmH5a/iNfq7XftM8C8D9bnTH77XUdkWi0e", - "87gl7ApW97xIpd5Oly98pW4OzakAD8YOXspU6CH7QDRoq9oBEJE4VOtRvpcPuwR8OSkyK577b5ML4are", - "DnsABNPqMisc+EW4eaXi+r7HFl8juxb1Li3NaIBVrzsWqj51Or8ta9AmEQBn+06+XixEKrkD3QgQVhnP", - "aHgipkXG7LxwQGY+qfACg99QG42F3BNtTIEOobhUxJFmtd4tskwQyX+a0mMwVn4npcfK7MLqUmQ6FzeI", - "HBC+K4s2R3Q7qRZTYCuZkdelgajL3liks56fGgug/qvVuDRYaKWdVjKJ3t2MLHXlTHlitLWxPj46celp", - "hSiHDPyX0dsPktkPcOTB65c+RrFYiKiQ9kpff0FIS5WYSO+2pqbewScB1hiU/T9vPMO2NDQribkpS8WV", - "NGKQiUuR0beUTLp0nvZOVf7k4u2G3Cgk9tZqZfVD9txMpDPchPzaXvK22M8n6y5TUwODTAkYhXeEXOLb", - "M4j3m1J/44yFGcDQjNCGpTpB11CRhtiesdcP/rvPqX2w8s1LhFvxsO+z9cThjbEtXZXIX4oqtjzN/zh9", - "/y5qYpuOKpPWb/HmXOp4RARn7ejqJaibDoXOFPb+tsrgDeYg4QLC+Zs5Gr3IRocFrsFQFIFgpJT0uWFA", - "+kDjSPMl4xoEqB+VvGYxiRI9doA1rdQ0KjfKS4rQhV1Vbo+ONrFPowqPZ38avABu4MNRMq8g8bQ8KDGz", - "VltUL8+yQZLp5CIm7fFKncpm1uDj+XqQlL/FhUpo5YykDTn8vSjWvbRJEqt9dsDduJG+RijQq0EZYETU", - "1xSyuyh8qTdVmtPRSbKsT8Bj/n+2kCi2TESCL3p46YDb+ETMpQ95JQWKLRaL8uIM3Ym91zeQ1BXwhGFG", - "WiDoBHSObCG4N4H5GxM8eYU3r2M6MjbllgzBPMQUUwMjePoMK0YInlLReYKmtEPLH/jSTIRQLNMW5a0r", - "vsTIP+srSeDV4RNmGJFr45h0zxifhAbct4FOKXdBV4k0X8kJorQrw0S5RY/u4caLvrmQ383kFy+iZNy6", - "NdGKvdSC5gerdpWTajibXWe85hEOQHu0jkYOsFJWfWfd+u0Ko4Lm2Rl9IWxjMcNGn8Hmc7pR1qMQd1DO", - "I2R9qmQ/gvvkGh35Mw5VN2qs3hSC7QUcW4R8VwdpKGu7P2RwW8HtE/JMnCsfMwiMHMaiUGXFdNB9VMar", - "7RTbw+/+cgj74pMy7Q/PVTUBjbhGcoQdwrv+Spt0YDGIDj0cfGRMXLlUzvABtKIB7bkCTqE41XtBCYd+", - "zoHvWJJNaW50z8JcNhxdW9Str/m/alm+xs2C9kF4nWsMdFzkhROmiVO7Za6hXIlKxGZcPBFmkMw5SGzC", - "wBiaSfVPks4wpcoz4LKOXwiSfFHaQaES9wy8p7FOe4kE7HDI3oPBny4i27QDbM/KTCiXLWv7dK7KZogb", - "+7RVUedxOHzciPXBmXH1kocNbSLxn8TkeeHm6nutL7bSd7ulIoChgOi51hcRC7OMcA2C7YMw3+BoRX7N", - "aZMhe2UtoWXLct6+OKGi7lBE/jTKmDtnq6y8zRM3guf5z/+gUP6ff33y1cfW5I+IBNuTP6wU929fzGt1", - "qSnj6O2iTsOLRRcu0Qsx8s4njc8JGccctfgedE5y0SFKcXWdN8pKKYzRZhQYxw1WRF5PTcK9M4WlUmYz", - "MciNBj1UKGcZqkdZqjvojOCoaAZVknZCOclBgwKhygmmL/Beo965tmiQ/bB2K5T+sMXE25G8nMSZ0mrA", - "C6fxJ8dSkWTckJyIpk1MC6tzkB1BHCwcihLU2r8vypcrxJyTp0fF+Qv3sddvmsX2aJX6Lsclbj70ixtm", - "gMSdbO/TdMMDS6AT6NMbj95+j6FypHdfxJeyFUZCcHl8q2yPL6zUvC0V09vNHHDVj/AJ8Ws13+vjJ3/e", - "Ld9rhNP3+9K+57AJO251t6d6Cb7yUPeDdev3VjiOqoyVnWlxPp0Kg3I12IAA9S5I3pfgkc8TR6nHjJhJ", - "6/yzE9zwJgL4H1DiJc9kGnIf2Xg7sYp6JDjyooEJq6amHZ7U5WHAn72o69h8KM+V0g7nuWvEBPQuOdNE", - "zPml1JhbAS1a0er1j7cvThhKl97GS8T6816oJr3Qqch8aercaKcTnQ2lPqg1P3hy+OTrwePHgydfH5CK", - "5QBg2v8O/+6TiIij0dLYytoqqrly4CsxWfBkLpXIBDcQRDCcSTcvJjA6/JjkB/89lYlLxXQA4/ASIMhG", - "Z3NhhV8uN4IVkWtTfDmV64u5ICdLr41s0gOWDLbZrQ6ezfikA+b+vVQtzVJBpRHlpWhvJFOxoIuivY3O", - "hfpJmyxtb2IET0HUbG8RN8TX/Ghr+XEjir4yPmPTrnbkxmint+GJjHekVIkRHFUNTfZdsZgITNmN8Kqe", - "SEEDtEKz20PWNmZLo2EgZ1pMNTU1nOrsV9R1mzlBXDsNtpn+I/fbnfjZwvdlUw22aVuSO/7cRHL3Qusf", - "kNsKI9LWcXcidRPh4YDDc0Vy1ylZBzBfXXgYa0PPD5hTcKmGuTbSeJ3Xdrueqgx6NWVBo8wZJ7pNTFnD", - "ipBusEVMvSFUTC2/XWb32f2q66uvZjMe3+jRRQfW7SzW3ncf+0Rp3aN5V1nax7XcJMd1fuN1jgEbEekB", - "uzAWH5yiSzMDOd6CaQ7RsdKJjAp1F+qPoeJZOJsWRTr8HBOM1UZocVebiVHXdJArM96F4WFZ/Vtyd8pf", - "dxccfUu6tjJTG3m6VbjEI+sPKriu8cmzsOzIWkoZixhL03ZcSZXqq1vvSFg6gbuDzVmh8XKa8QRriFjB", - "oEBcm6nedk4bXSd83MnOSSnL8bYm8iLAjZM20okXmcwnmpv0Zq/PzSrKWuRoKKoeBtz+fmjW1n3EO4Xi", - "Ujy36Hmb+msyjDw/ed3r9y6FsTSdw+Hj4WEQIXkue0e9r4aHw698SXFcyIHHo4PMP93hy1lT0N8HtLh4", - "fwvfmJXOS2jPiA4IIVH5+OTHM7Y2hrcka+U9mnzSYN8MDUFonTALcKmBC51sN55f+XaPLCtRxHtfJaDV", - "ykQ6I3bLxt4KOCYXhrL9GF8FIDiX76OVeWDaOR4yS1O2w0JhjnZUj4fpKgFmZuO3J45IcgcgDXngpZgk", - "3YXaUmG74eyJcvA8nhwe9lBth2J6NI1S44N/+vg+GwWALmWs/FA+Gh8RqflOCCuKx0sR4B/7va8PH9/Z", - "tCjVb8M0zhpwIUFRLSTvDhMbItGAOZObJe3rCmasLKHfux5E0++gdPUo3THg0mxSAD732ntegvSEvTrV", - "4NrmEQZ+kuRyYzCdo6UUzlX27rHcMun62F+GDBRTDOAILgRnkcwuhPBJpSKtxXl5a2FMge4nYo9KLIYZ", - "+UAIGw0TNYrGSjkhIazXEqLxGBYC6WJtyIEQFpFqYdUjFxYDdHeuzlXFE8N7v7A840oEQ2wOfMo6u1JX", - "IUzkWbyghfEMlYokZIL7yh7uihJxzYwAC3MTwZ02Exyy/O90urwvWvuuUGkmCMlL3u4Fvs9P8E2U5vlW", - "DRtQU/308LBt4LiSg+94uEk9eUO/bz8Nz5gJJYLHMiDQVXA/qJGJBtTThol/FTzmgE4lOlUoF5eMbTA5", - "dJURBu0fKSO0EoFCgMK9ownxycNPs+ZIfDKt0l7t8EDdaR1f2rgJfc+OrCAvregFMUF8ZUZgbT18qfwG", - "uT57511Frni5ptW74LT1LuhyC3zs9w5CuYmDacZnISAkaYgIeSvMTKBpE1sSUolraR3VQBC2z4o85U6w", - "FaANBSsuJWe2yKFwotUm7ZN2BewwrFBOZrio2PqluESxm5330HkPtu+8hyUCM6kEqkYmqLKJ2b3pFoKZ", - "hcoqDQwTa6aEUV7h+m/OMFc0gWE3V4SPsCTaQ6fZArd1D8K9+uwf573B4EJqe0EJjwcDn3txMMuL897P", - "+zfP9UsTapa0OzHtleA1nD+dNymeV29ikdY8q2/DXL/u0g/r8iqeBdqrksmPhJdxihkvVDL3h+C5BMx5", - "Z6LBSkxSbKebwgpTPqnjRARMOjfSxqJOZRhIzAkx4fHnIeBd/1xtJSi2Oz2dq10J6oUwDgSosAtswRWf", - "kc3hwntAq6nhZBwojMdzdnzthLK+7jP4XPfPFVZ4GhhB5twAkdYR4QdERdXBi5cnB6FKnVb7+MaZgOek", - "SM8VvnPCXm6l/ZNwjDcn/+6W2S6HP2Q/hDzz/if0nzhXez6bufe7eaH1hRTW7+N5j2K2LnlWeNedSrkw", - "+nYIwqpgQUONmCzKmQxnWs8yERH7gNRHseBS+J62VFA2d1j/d9zKBBxj3l8K871z+XHwcqE9aJwwam+g", - "sf0xnxmeCht7eU3EW379InqO2xNfQB4qB/V7JzovcguZBa9E+kqbH01mMSTYr83PbpjoRe/nj3fF+QKu", - "fLHMbxXtpLgdDyxycJEfiEDUxAy1bXIwwaYoUmrDFtoIFruxX2TOuEnm8tJPSFw7wxMUcBasUCkUsziY", - "64U4IOZyUA55cF4cHn6VAJHgX1DJEuPizZIVKqd0n2VziucAeyWeoKwEbgEJnivQoDY8ccMe4rMuQ+qS", - "BgQ69NX214kR4bnnGdW0QN6HUJBtEk9htDN+MuFBokuZKkdFV0g1BSMp0LmpWDafyoxhoMO5Oi5X5xX4", - "iNoNXMY6mWUNRcTCjQFzDlcEXDU8lUpYu5NoRSddzmkjZ6XQUm7cAaDXIBgGO8raYQwa8m2A1Y3AHzel", - "EIsbSagdLOsBXz4zNSMJVSdUo6cGbL89RQ+4SgeBP9yeuvsNpM26Unb/XFnhItGVIxD5SXWD50fE/XP1", - "CZ8fqzTyXKUfIg/+gqml33Ad0hbHnUQfI54ufwuktIV62B5ETcjc7ldvybjEzsTlHbcPJuGZ0ExEx6H2", - "hGKYnUukVOFGT6PvN6NIO0tBw2BVywTYQ0LlK/+rv4hgCiARl3482dJfXzGVumLiOskKSMbAQIJGa4DS", - "PnUAmsNZxF3LEq7IIR7Vk3j3hLQaVAfAG0uoxBW6WcZ6dOFomIy1T0lFSovyRbrQzUkinhQWQ6fhUkrm", - "XCJRpYISDsJFWQadYP5cqs0Mo12IJdqgwnaVFcxyvgQoPoyRGV2odOCMzBm8PlRCefqwPi3M8lKmoEUj", - "ME2E/B2+JfzpPE/uU/O6PlLM0H1DeRZBhpInvyGxNRICQ4ppJIAqTrcTYohHrdNhksnkYoToUqXG+sm+", - "gEYYwHJPB1oOcNtzfEuIT1QU6f6zHuGpxNA+OEMiS9zzMMeWsJZdD5EMzQdwnbSf4wfB0xcVo/S9WSXi", - "IF7Ib7RAhjbMD0mm2VXKu/X2w6IpECpafRvs8zfcb7RStW943e/gnoin2bnhpgSEDg0+gzNzutyk3w5P", - "/Il8LUJw2F0cKOZdaz/HmPrtno5wLbXcJ7YiVkrAN/sKWG3YpbRyIjPpllHp85tBie9l6otn6atKJr1d", - "8QACNdcvw9VwX6z+pVJKkBiY+qRwDk2J3js1W5ZqBA7zMo7iJNERRmF0KOUZwvnO5CVW8HFzL19ngltB", - "fu70tUSHBC8E/+O6z5Y/V/Me5lyaxvfVyxB8ek+4G+HflvMAoN/IlY1ToarihQ3HxJnPy7cTSoF3IkIZ", - "5Zi7U6sqaq35CuFOnoSW90jytYG2UD9ay2kr4iLuYpuDD09SG4JIN450JxISUNs2KfdtiNe+J0KJ8O9G", - "xvXbBCv7vMQC66oQi59XuJljasmSV9k7OVKszwu5bLewamFXJoKx81OqTR1jCWLiSzI5lRlYK1WBz1VT", - "rV9f5xrXYcRcKNIfrBcV7jMrxLlycyqwu14YmHFXWqRm0g2nRohU2Aun86E2s4Nr+AcjNw6uHz+mP/KM", - "S3VAwFIxHc7pyvCZcOZaaWOr2Ra823dYr2WF9WkdE78VmMDTen0kHZNOG42HvlL1PdHLaiHsm5ILHihi", - "y29JYsHV1bRuiJd3QRmVdFKtzO6MX4gy2/Z9ibVrScM/+kPceKmh2+NBTknuy5Fi5pMJWrQanKrX7q5y", - "AuRL+VlPPKaYZOUBBf/m2563zrJ2Nkj50tmlzylONSsONHCHkOccvnMVQbTCrOsibU1jWivY7mXVWsJy", - "Ur9KBVYCGJo5mVxYtqe088n0fXrVEsViMCvmhbzkZvmMuQL1nQtMgFItkYGpTjB9ZrkUsv37tTLMtk7T", - "CH4n/VqJj9IhdlFTpLG9CAPl9XIAHwSH+jjK8RFy8gVmOvZXg9f0DAZG5II79o4NBpQr5ZCRQYdeDfi3", - "aHQfPw1py++JPiuJ9G/KXz16/UaUbTSZUhyh4+GO8buVKENKthb26hMp3dPBreZpupWyh5ID/WYuRlgb", - "KXdudUw+xVs7V4y5paMlkcE/5CO/LH2kVRpzudaTckmF13dIHYFV/HAvhufqxOipzIB5Kq3EInfLijNX", - "/MobZr2XRzQgWrJlR/OhdTo/wFlRYtpzRfXCypTBQ/ZS2jzjS8wLTHOGlhDNRV/5qWFm6SXmScBUVOdq", - "HEcegR1whPFwYrb8S47pFkZJmo8xQ6xzMGnsCk5nwe6OufeAQa74lfgkbqW5CUs6wqY07ok2K9syZMfR", - "ZWPgXTaqQ4C70cuTc1WZxpTS5WACpQzzM8HEYSuDudLHW0Qf6HBgGG3xr0KYJeAAXwgnDJP2XIUUTZMl", - "0xnIw5SQLgQ0GOG4h1dmAKahwjU2PFcR08bxUMYslTb3NwhnE2HdQEyn2tQcW8jppY51pB3yzijl7vrk", - "LWVMNCX+/I4bIiDrUyKYhcdVp9k4PDbGlDGRcYXrd2ypC5bqc/TIVgIyKj53LBPcOtxO/1RATzhojplw", - "JvHMY7rs1RSD1oncYvV5qeAhJC1Zd48qiFCecR/3CDVmnlDwIvZYFNwo6OxiulvK9XeunOHKhifNEZNT", - "xtGsaUrvSZgN4gyMyk0mhalwQYbpv8V0KhIXclQvONI8veEo41oiSicoTNbz5Pra23pzo3M+4w7dBE+Q", - "mnwsAQgeVgCmOcHGpaPGv/uYtQO/8DHasn0asZh53mMYmGpnMwGi77minSXOFflSnWk1+n8GHvMiNMJA", - "QU8BFoOqWxwdqvQfeIZHI431NdjYTxTZB6KGuRSsUPAK9U6ia9SC+Bt5FbB0b+su0WLIxlXW5PmSJcZU", - "5QbaMJHJmZxkzR4NFN0E+9vIKqhIlhc1MRy+d9RDHtEL0fq9Ft6JKX3DPV6WEC9dC2P51PhNuaSmpEs/", - "38oTZiXuHo5cjALFNTgwnb0a/NknEK475LIFz9n/+z//l5inFQuunEws45adPD978T1bdwlvjJgOrUYt", - "8QGVGZCbKhv/ek6+++e9o2p4wM8fxx0nRJdK02w8sXWZxgI4Nkr4zRoL+NnfxF4uGrM9rK51QLW1DoRL", - "hiHBf6IXE6lCPsF1sqaMisT34GcskxCz3Hq+E6WEMtF83Re3rCZBwYj+nefr1TdUFa06sLYRP3gCockh", - "zB5T5ID3y6Wo0irQiV9GmRhzo2Pd/rAa3VFH3ZAjo5pF//ng75Skbzga/Pzr4/6Tr79uTtX3i8xHcHF0", - "UyXUw0ZiX0/5TTHmq7Wv/D018vfU+m46boa/WBcusiq3I4HC4vaOay6BGEHh07LTAMF8bofMXzLRfZiq", - "ExmtHROKwryiN7zvDP/Yg9TXuQkvYSsy6L+HPJT8x9nY+64fnMQ8XHa8Twn3x7Bv+agaa41SJzJROm7v", - "YRUWi865UiVZkQoLogU2uDI8zzHELc6nlvO27bj6vShZNZDxhzfRWOyFK7EiWoktklIQlPosw/xsQFQJ", - "J1pz7Mnh0z9T6eN+SXpwgAlGsJCoiDzCHwDNYpI1J/JY3csNT5cyv3DYQTQVln2p1IWROTk/rOBkxIo9", - "kFxiETmfQQJIFfZtf9ilOMVvymBdl5iJXz4rlf0RC2JKxNrz9y5CYDf3gwlmMll7Nd+N882qTNcahxlb", - "hKcT8fIYqJSyfM6tWHmgP6f3MT5eyrcxqsSqMe5x//OssGt7v0NsZuV+jsFlDVFM/t69L2PE+tX+qXHe", - "jx5yyq8f54/eK8NvWP0YPhtO3zpkp3k5HZFnag8SI7gTo3CnECIVTW6O2DDWfLsvX8f6KDsh0+NNJepo", - "nb8hTR6tlCLrWVrZ1q4nRxXYOpzcS2x43ydHo5xwN7+1q0s8NFpiejvqfLq93zvtXoGD9x36yODMMaHC", - "jU82yOMbDvUVid2/7fOESf4ejtK/cTqfoq+VCBQ6+kXmGxJJUTYczv7++oTFV0vltRMeMbGcV1mSNKDX", - "cN21zY//Upq/y3yb6ipWbo0QSVp2Or5KQIgJi2rT+XgnsDqWVBU+W4u9/ryTkOD39VZ2cNj1sMZYFQ9R", - "r7rBXyLm+sOqsiHGA6L5Jd8Yo61LO6B0eMfvOW4qj/lFcDlBmRpg7W/E/HO1AfXZ361LmZ5OhbHMypnC", - "fK1YRcIX3wkDeln8XKWi+hX8zQ29ZiEIkZRHkJVVXGIaFuFWoSChNbuUVugO9uhLIbz+WiKSynLRL2rI", - "vpezuTD0yYYSR8wuMOl/qVqBTPtQGoSBa6gAK8+ATsK6I/a/4bQJBHvcZz49PBwsVP/8318dHg6+Pjxk", - "b787sPvQ0auI6x2/6rMJz7hKREo9D/AE2N7/fvx1pS8dXL3rn/r+axa6fH04+HOt09o0H/fx29jjyeHg", - "aezRciIVbBkhmBbFd/irVHz7rer1K7/RlPEP61q14N35pqfeWzHOsxUd3R+Eea6oJndgoKheCjkrPeOs", - "Mw+QlV5Dg65cA3mF33gAz7SpCwW/hVt6N8kz7kEDysFvTCpC1ls/3D8LYoFfd2UFPr8hXz+9HRArk9bh", - "e8G2YtYbad0rbHGzC+nLxKVy1Q3IVD40M0qn8QViEyyQ7BQU6n0T7AEv+daHJjiwn5RnfB9+/3fxyAQ4", - "FeXOF3iSuAI08KNd8HYMwQieRgVCIz+AyE+vPujGDnA6QTQF+L8VjqATJ9yA6m/eWqbBC6Yx1vYLQyc4", - "X1Yzge6APlbQdTLKhfHlrmwrhzgVyGJPKk3vLRB0ZaDbco0KqBC2+QUeNWT4XGMWrHJ0B/pKCWPnMt8B", - "B8gy3e4i+pwqq5QGbJ9lRJvSG4suppAfWiy05yMUkjxsSXcTxJQ78+qJklGL60QqrBsh2zpql4aEdVJ5", - "o53ngj6vvRe9h73+VtbW793Uy8JrH8upbnezaIBw0/Sej5vVupX0V184u2xI9DP1aLgbwQRV78b8VxzV", - "TOSpWcliJ71bX3BOWFF4rWBgG/mQtvfOiGdX4ig5kNNxZbCS6N2iu1HKHfkkbaKYG6L+32Vez/vml/m7", - "IQNezcW2gqI3oAivbNpCEruqitso51xtJ53tKuOahvhcraiI23O1eZ3vnZFfq4fc2VzELQu7Fa6hDj5h", - "n42smz242upQv+vuxOWLAvm5wZz3sHI5oNNggG0GZb/94W7l4Utt3z0wlOd+D3/nTGUVXW/MWK5WE+St", - "vEgcN+6V/Qlb3dNbpDLE7l4qN8wYj8turKX1o5JQBLahclZJt1d+Ozp5K64UN4eu7K7TFn8mdKTFVNX6", - "PnGgmu0k7+F+HvwaDuUjnUomKOfVKkbqvETIFYULKlG81sTrUOJJb9KjbFebPF3HlHCU5Az/hR8lbCvh", - "NXpQ30hVtnqMBxSt3Ko4O0VF0yt7fOmVKp/sNFeVYOB/TLNt1H5ts7Gc4iMcl9GYHuD0mBFYuH3LV7uP", - "5u71e3PBU1z1r73/HJyeHg98QrvBmQ//Xa1ykEqOAbUAEMBjiVYCx/ZWGeF+zV4abKOrrZpMoR+/RETG", - "jV7bZZ8hK7Duzjht5DYHMswT10UB/LIiBPI1ZfAn9EeIjv04+EKngu3pxPGMUZ8+w8IH3zx9uj9kPh4D", - "xcNvnj5tmyZA6bVM6x+Hgz/9/OtX/adNITObo87uUD19Q81MzFL4pV/WqGKD+zn4y+7ihpfpmT0ot77Z", - "MKpnlsivhZevoIwvXr8JtwOz8kRQphFv4lb95mGocnWzz0itnnGlVvkqIsTgdonldqeM5s6kDdnaNpBu", - "+820yziVtTePVjYY+dKtvc92K77Rs47XISDWb/oGbLpdYNIUX316etyVhHwG7AMxM8Jan2xgq+MfBlFi", - "jxAmu1b30FdILYtaYPi3j5gZsufhT6Z8kbM5t2wihKr2iVVGpzLDotJHDKvCtFUbfUerOcapndBa7tH9", - "oGm4DVkEazvWkg6wrAxZb33zip5nIsvoxP72FoISKaG7s+tDYUp+QDLUSjiNMYvApjIZ8kTEjwBBZFPo", - "I9RUm0SkTBcOEwfQWH1IHEEVeyurgdo9FCkoLUtFJifCUNkVpR2zsE1zYcRRCNS8XkJDh+Vzs2UYC8t0", - "Y9IDgsV97VCW6HwZ/KWq6i2asqpMjyWY5Q6hpkZOfYpkX83zjNoUlEFPWkLGaWFFGaGPYZxUpNPowgnm", - "DJ9OZcI4ppOn33EJQ3amU76kb/xyII1IohcLTHpwhqW6h3QJ+rKWyGuuHeRBMAaz1Y8R2CkmbxozbfwX", - "3y1zbi14ioxDbo6TjC+vDARdM3Gda1gFt2zsY9SGSlx56Hu/+k3+uD8+IhVshdbgIhpXToIreyWMZZKy", - "iVBaE6cTnfm0D1JZJ8DOMgXJ9oqb1JeFdToGZeP+vk7FItdOxAP0NN9UQZWSXMWC84FvIDdxrMh9xWRB", - "hYmrOAtteEoVzMn3AjNG0knzWIYxMqWzslSWtGUJH6yFIB2zhbmk0kQxU4JHtZgPA2ow+HvuGeMBV+jg", - "fZVHDxYAhkK54BBruJuHQp7E9ujNG/lrRLaJYJm2rokFnhStLPDudWSt3O/ThQV2ZMDHtavK49rnTdV1", - "e3YPt3ce6fzAl2/oUFbETKQz3CyrXCLRqSAPs6kRNhSD8ClUMIAcCyXbWq3RQEDnCjisTng219Ydffvk", - "yROiJYQ698VLLTLRRzmfiUd99sjDhT9D6VJiBY+uxGSR5I/O1SU3EiLF7TB8OQSqxvoxe/uPIvlUpjS4", - "Ag5PdfMZpqGziud2ronPnKsASKpLfSEA1B40+yCmfapy8j/77Ffm5ELowp2K5H+yj/uPGLW2VCaFJ44Z", - "MZOY8YSqwmP1d58aB5IkPbLMLlUyN1rpwob5PD95PQx/B84Q8zYBkCvG/e9VhENeew4cxhX2hU5FHze2", - "j7NKPPHT3k10uvQpJ+gEjLBFFtkUnkd5tNL6LRTpufKpnAL6Ipc+vhQQWwkZpUzhq80oD0CbI9DICSrh", - "krJ3OhXDf9rA/eiCkM4yfaXC6YCdLVTyG7IXmH8GbU+hKnEATYmSEq18duRs+cynA9KVDFahNTQGHBSU", - "6g4ODwRMf4h9lhhu55hmyxeHJJGcZVrnIWNQhJVqYVEW4Zj+6FxRBZw4syF7jukTeICP84ndqWC5dOVG", - "YHiH0f7bhp3A6wWPhk+4SrUq78EwhL86ADgIK5chfiZc6GFO5wrXSjWd1xdL2VSwhBweKm4mL7fdF6iL", - "XMAvAXGBTiuk3HoUujzyKa3quwCPv5Q98i/aR0Es4dkVX1oqb2e9EHiu4nlyeLdazCL5qESy8/AwPu89", - "GrLX9YxjoVnfMxbA6QlJX5px5VOkCeb4xN+qtLkojAgER35NgyupUn0VGDImnqHqQzDcVBsx81Idn1AK", - "m3MV/aDKkvgAg/Jc6FwoXwZLxHdMSCDmZ5THPqE40rmyIhMof/sfpGWFiqbuYck4w9zq4iIdqL7ybDFA", - "O1ewPUP2eurHH9COoL6PAp4SYYNU51Ac9TaTfoVj1FNGwf7WShVSQpTAz4d+psirnfZzwWzRNNWQrk1c", - "w/0vXbZETDvhSDVLX3sKcAm6A54hEwPMxauKsCygADE8KjiFbfxilLjClueKxGss982OeTJfAUC7xumE", - "XztbhQWnaT0wWH6JDGwlB16VwGGV/lJbx048KACgFZCoWfocbTR3DFGToaA5DD9k73MsPMekO1eRTdEh", - "+drvEbP0lDi1PxzCpWegu6nONRwEXNFK+1b9c+WxlhatFeGNmxNoaVmSaSvSNW5S7pHnxiqNmP8IdtVH", - "6dPD4hFUAfY7j9wv4SoWpoTToeN3fGLLG7bEftzVIDk8Y9EF0r/oYv4Z7ho2H/HsebX+OpvzS7w/Fto6", - "9ucV1LDPGrlOeVkkulAOLh3YiXNVkdaDYtPfI0FmeXr4LSFolW/aZz6QGhkFXfsvj98cnx2zdVFPG3vw", - "K0zz45C9q8/WZ/Fx8cETiiQnZSJj4rvwXoGr/Rm9rwDh5oWzGI+I57tEWBEOcSnpj4XwoOkhQicrSgnz", - "BWni7+MdsjbWZ8pR0jAPEL6ak89EQexOrbTf3l3Ol7iKQKRv5EK61nQ6Z4Ezr2B9SSsTsdSEPiwXZhBo", - "LwOwd1ourpw65go+xVl6AWv9EdMxqW4T+bWqSd9I0g81cAy8U3w2T2iwwmdiIpPJkp28Pz1roHux7hgK", - "460fmL1P1WcTfthGXIdbq1zg3UVF1XRc5Ypvepiel9a9PFZsBFjZssqwH0UxP/D+qFTSyE0xxaqXRJRX", - "klmqPYnSXsSLK25DEo0h+y4mN14drXYBM6c1ST0wdbzFJuJcGVFYSPlVv539e4wFIYhkmTg+96JtUH6u", - "Ia5XDpOLUEXP56+Go9qbp8zH2Gfc34m7bAyr7ctKCdl/FaLwdxFKTOeKnoYgIGrlFxaP5bWXhpWG9eFb", - "6xFu38jxyaMg+lCuW5pbY9Q/pUtZQ/pO/iH4n00Gxd0IDS77xoB+WFUDwtSt5TB2m7k87stOdslOfknH", - "UWT68jPFNHCeroyHsBK5Trt/4wm1gi27t/IycYTPJCzVZtAmJpVFhY1vcwukefLkPib/ivR3m2fveWFU", - "yYXyxz4DaELFUdCAlhcOORumFVfaUdEPZ+SqFD+84xK7wRZV0Vtm3fXQHq9tzq/UVsQ+xVb3itk4xOdF", - "bT+FNtzGnz+zFWL99Pmtjv9X/wf6WV7ILNuKCj/ILOt0h5aQd/eyvDcsg9n/JquWvv/hi4xzBfYjZ4pn", - "lDU/uAvdHAcpcfhWLPxAzb5YPKT5P2Di3QXXw36CpHf2X4MJFU+4C3QkE16rq2K4OKjVfWPjPd9+tIim", - "i8//8kVm9gkPXBvO6DbIkMoOshK2+mI5E07/M8thNIU2Oey7pRM2uFN/sR7U5X3JrMeYW2GmLty6Y/UK", - "Z6fHCjkRcKzlUSgnM/b40Hvj2VhpADPNo9H/p1gRi2rl9quWcMvsnBt0/7LFAgc6Ykb4BhQCLFUhWKEw", - "h0vlvZRqqn3kqw1yDwN1q9KRDXzITgvM366nUyvcXw69iykk2EaXMFQLi5lERVX/XPk6udiaacPecOsG", - "6EI8eP0yeJHlRlxKXdiKsy/BheGZVKnIhUrRiWF4ro6vsS46Jddwc1FuHi1myJ6TFY923zKeWc2E93CD", - "1kI5DFkW17k0AipfnP1X2AlpGb/kMsPyVN5oxrhzPJk3F7ENFALOLpuc5O+E1fTX3YlxjwgTyv2U2oQF", - "4Xai60b1sFDPurpvP1rhN6l+TLAnEyzN1aL1ovOtqbxi6IZU7punWyOJd1hX3St8yKAWrQUcSkQqVCLI", - "gdujnNXlm79KBx63iLrc3PtaAwx5GRw+4mrJib1cbm13Pp8zfsQ96NbRLT+wuArdZ3IqqCLgQ9zavcWt", - "RVqr3DHaH4B1qTBm57gDwGb0Dj4orS3NghCpXT+E9veaDz2Osr1m8yrF+46fT7/9mQpVRK14uAcxVgh2", - "Q6QMag7rnUK6KnjhM7S2PpdCCtcqamwMdXxdhs/HXLbh2IJXudMxF3M/OKSR/3hlamiO8oXM9EI6F5xh", - "ykKYq3CljXDbS+rhfdocrMgHvzwf/P1w8O3g5//xbzfKqYdncbDIn946iV6J7P5kaxw3/jp4JZW0c5EO", - "njeFpciFsI4vcjiL6NxvKqCp85D9teCGKyfoGCaCfXj14quvvvp2uDmKrTaVUzIg3mgm3vh404nAVJ4c", - "PtnEM6T1jk8SS3yiJ3if5ZngVjBnluS3QNbO+nZ/QGpC788Ge3Uxm1GmZqiQis6kMEIQzidiqg1ZF5ZE", - "PeUiorzzuEHe+fgFp3um4theWsKEQHfCrDJpXSujAncFOmxxe6eMmONu020WRqM8y2uJ49YoGmZIxvww", - "yztz0yBZvVz8jhu74OaiPaaB1mmjL6ivg6sI133GIK6CZ2QEizV9p1JhlTvCCW4uhAk1+/9JLrgypJry", - "Aufbk6dwJyRznjthQp91f5y33Fzct8BSG+MeU9TsMIc2Fctb3KdIaH8Y0eh5mkbMJFzxQZVSDQKbL3Fy", - "d9rAi2lLmqT7RsP6IBvF5sebrkB/yX6BldpwBxhnNjFCqCqPeQ+eyFRXOSwzF4a9fuldtXwUkTBUStNH", - "rtwED3S+CQ10fv9YUBnj5m8n7yfxeSPznM7rAmD3A8mz7eF3/8EvuXdJxSCGEGWqXAyh8hEd7MPxyZsh", - "O43V+6nM91xk+RG46Y3H439a1HhmQ/hyb/8Za/vfwQHD23gh3FyntV7nvSSTycV5r6n7wQE7BYusK4zo", - "x0rl/fDQ8UVffZncOtS1QDsYAWeNzvdRTemnBEsqDg+/Sv7bYMC+O/7r63fsr8fvjj88Pzt+iTvB3h6f", - "ff/+JXvz+vSMDQbYWEBBF/jxiI3j2OO+/4BpcuInsZDuNQTnjaHTd2W5Tmd0dsTGUFG9z8ap4VJR8if4", - "CJLzK23wC/g8007/aDL4E6IKQMCCvynAUU5kJt3y1Iccwg+4t/AHiGBnEM/dxwjr7LXKC/yQG/AkEEv4", - "2yZGZwjc+wSdIlMJwDD6kU9wYj4y7oxPsOOVdMncf1Diyv+FDn3+b6FsYcQHwTP/hZzCW5lCz8NS31YX", - "/UbztLoHGcbdV77x4bev0wy3+Z/YuYhJnuHT3Ln8r8LhnlNo4xEbrwZzjvvxuxJdKl/yNH1RWKcXq60B", - "QvMv5JZa/jauotfxu5fdkOtceTwZeDwJ2IpyYqlqxwh1yk6WLZEktIrh9mPy+8IQt6nRvwh1rprCVZNM", - "CrWiw+c2rGiMYAPMof+y773IgHsmuNhzhWGvPE37mPWAKJS2I8x+uH4Ee/tjlkqbgB7PYuRsJepm/Nfj", - "M3ZAXQ6c32mczno07f7YR2qOyX/d96IWkLfjhV4stGKAOFOwglR5GceHqqexvfNeqD3tGcww0QviItSw", - "gqd78G2i0bnfCMH+wqhJI2FWGmdSXbC/YJ+h0qmww6lU6R78yf5CaMDgw9DoTLC//OUv7LwHfc57DH59", - "8g39S23QDZvavNWmVslmOBzSzOWU7f03gLDvQ36VuGJ4Ee0RZPT6m4L8Wl0q8pE97PfsXIXZY7LUsNQ1", - "lrF33jtwi/wAQ/NyNTvv9dH9t88ef3N4WMKus8e9XwHqxwqvPtP5gCplTaQCVPNBrUvFFz6kSC58bOVC", - "p0UmYvIEbxI0wlvQvAKZbgpOiTwgDixWIrvkWeErhcuZ0gYc2WFq4QlGKSpK9r43HA73x30092m4gjyK", - "o81ohfFT2yE7kUpBcXmsqIx+vJ64yriAQaKNGLOcJxd8RvM5V+umNb8FbEzr39sPdJGkOVBCbvQlxqEV", - "qpJZ5aW4RJrzyBl97g1s1kKEKNyM/yI9N5EYRl3GBVfSTAzZB2GF6+N33lO+H2OffUBwn71//7bvD4AS", - "doSq1ynMSy8pOtk6itpJQ75M/PbFj69fPqHNHMl0jFZM79pKJ2WFkVQwHlidtEyo1D/FV5a+GoFeZmSJ", - "cZOQOQZesJc8E/4xbwqgVMRA/yCvBlevuWMD5Ocnr+0zJnEGQFCWq3SirzdGq3le/wHkuPuRkysj1J7s", - "dVHxP07fv4sJAiY6lZ4gMFSKlI9/Zm/ld0GDR7uLKa3p4XHmUcSIf6K9kMPz0855JlKWcgHsN4BHuw2q", - "rvH7R9aDVuIqk0oMUhFG9T0G8DVNheqlKa0GiEQFKVmeHh4Oe5/Sz6O2qd0i7vZ8yB3DmPdY8d3TxP6t", - "XqGPv/q8zrz1B0YlQhwFnY6BCjbhmXD6F2E01KAHptf+tDkx3ljqMyuhwRsgYDSPZgClD49dbtIMd33K", - "vj87O4kJkyjsBhNChAAgQF9MTyAtgLwC7fgV1JyUjk1Ewgsr2I9KXhg+dfTrSowrtMXsmmoZkd0zj7+9", - "bQzxoWWewsrP9N+F0b0ugS3YfuD0AFbJ/F6ld3KiZZKkbBkg476KsKuVLeqsN6gerVCbT/aDsE4bYZkC", - "OSZjtrbY8ByszKJPyZfKrE/16ZIdg0KN00zQkVPfaHj521umtC8typQQqfXWlrnIUhB1LkQjD1e3Pz2h", - "7unwCPDtzy426ZShzz8RWezFEq2mclbQtg1ZaPz08CmmBojtZIhqp+bNt+ZfhTuL87lH/h4HAc/RRifj", - "s+YF3lRhvJ6YrwV+t6R8IZn9CtPkxklkVVSZio6s9ahQl+hHkMJWcmYwKyKnrwgNFLhPYlz6LJipqyDI", - "q8PH8wdcscI5kPB3Qg52Sr18Hos4dcD5sCuA9p6+fBJHlmSCGxsSvjUj5rfEGMbWaQPPGA9iDLMgKFjz", - "uczAhqkXMOdUZgRPl2Vae4LwbH08gJWJKTxW/H41OsvBOdYR/t4ExDjMC5znp/acvTHFfb4qa59J+f8j", - "rveWDKIpa+epcFs4QqCRJ4eP6/R5xYlAKw45Ja0+ixlInhweQj9Uo1gg4UwkgRp07gZSHa1mMCTiA+hV", - "PrLHy0QqOA490kNeVytciDvGF6jnEYEtBIlpv5UdPIupmGS8U724sIkn/SZ5SOE+Hwf5zXOMuzRN33xC", - "Vrgv0Qp5OzGlJlxWSmQ0PwteK69XUN7fPTpKlFMgr90+m4V0JtUMVSsTrTKzwzItErcQDShSJtSlyHQu", - "ykeCH9Yyngb/uyeHTxt+D8ls2Z7SYfjgk6dN2faRLVmStCVXQpb19PCQkW5SptwnQkNNQTONTzJpS0mB", - "fJvvKcqGxsIhPlOUTblOf0iNofB4HDnNFlW64UQTbvASqZ23haWoRAyJKzSlk0CAPElEjuhVuPKkN+Pa", - "M7obw1SGN6f1Gv35k+hAEruT47ZAHJ93Da3DdYf5cmwiaZ/3Dg1/eMH55IYLNpbpEfvVin99PD9X4AB/", - "xH4NhzQAjIDvz8/VGCQFOh2msHgb6Sa9Qnaw0Eo7rWSCqtlgBeCJ0dauMFqvYoY8yU2BNWpZhtaUIUJA", - "nEiHMG0KhAgqI1r2kL3EZJswKQomJpSY8dyGZ9JYpmNKk3oUUuLF4An8TVqqEYrZmB8zPvfJbkKsxcAK", - "ECgkmEdpZ9mVMMBKSM1dRhMVkNp0yF6gbc8yO8f0WM5gCsU1aOh+LJxIHM53yF5hHs5qhJSXrVa2jLJR", - "x2HL15w/KjJJ4mNRUOIfnPUz9G9m4/9JgTV/4Vk2pop7NXA6S4V1ZRhAwHBMAkTq5isJ+z3nuQh5KWdC", - "CQO2kTonHA/ZK22ixOh3T/jnqaddShtPuXTZHjSnNLTCWFZYXwxKJ8VCKOiFxvXxfr/GzseAxWPEOW0W", - "seDqIpSTGntJ6d9xWi+xMTG1fkybCeMS8CZOT9ER9eXZbU7oH+qxO9IyW6enIXuP9i7DrFApO2w4j3C8", - "ubaSHgPdaBKzH9UIC81tREYCyMx4E7Yfivss+21xSmPCmzFdvGgFp4GFxbgtq5EhgWp2EOOXyuEywQEn", - "a9mkBgQSTmgurdNmSVt/y1im/rr+BRB/F4Qfsg8wKyJpsLZaxh17fPjk6TPsEJGZVzgBEJ4tzJQngswl", - "lFQUiX1mBHch5/vjyjJXwgJoR5rjjrKs9/NNogFuEbnV6cZ/0+Ey+uIqrKyuAE6UyjEMToVyLHKAThf8", - "lZjwws3VwVzri0ohr5WCfpgJVqu+fzhjxly0CdMtHtggmwlnyQ1R5v69Huo1jBW/lDPutBkmRmAUDM/s", - "EPx+yFzd/Duligv+HHDfotiUDC7EklUaRnM4qe+PaqrImS5LxMOGaDTtRBlfGzmTKhaHiPliQ33LxNuE", - "wjJ9uQi1JOVCHWqZuxsXvpKuuGJlfkRpySU4lQBUr1I5MfKSO8EuxNIyKichVIixRKvRuTorjE/CC1Ga", - "6LJo8UYNM7TERmZeJQpd/ZnAzB1WYynb0jl5NQPmoCW7SSbgbzryFfNVTPpdmhh87uOMz+6gcMXaMhU6", - "2ljvywHdyvmHqetcKGR8gMwiDRmDlzEVLRh66Dc8fKnY469jKEq9FgapV6BxSH+s+itbTOEyM+GY9ChR", - "xbnoXot5s4asvpgyBe9hzerkUwGW6PTjhzdsb/zD8Yd3x29Gb4/PPrwfPT95Pfru+enx6McPb8b75M6N", - "qCZdfZjpNGQ7R1OzSG2LPugnMXkOXOB7YAL380qsDfGJn4frY9fZ2/f+lJ34TdTlgCNEfAjzJn6LuEga", - "Az2d7sDgwfWN/PIG6De31W4XKD46hlNvqmURayqgbI2Kldcv+xhhYHOeiD5Jt8IQScQaGAvhOFyUzZlj", - "yUmSnBDRL+k+jXlrg21KHhQKZ/k9qJT1sMO7i1BqgN7BS6Lfohsrgz7wSFI2gSMBfls5SUoXW34OHAuQ", - "LSQc0gZqRPlPQ0iLX/6GMII7S3jVQmd2KXnFA2RYAbHSCRpCDSqsigLDFxbLe7FJxVvE99mzQrAxOriP", - "9703K5UAxDSFAl4RnLKQkD+QWOQOWL/hy3Olp+AuLpWsPGCBtXpctf06krK90qWVK6ZDWVDvAEiItO/L", - "uYTVTAtF72OaHe15rP7EnfaOikP21o+K7Aatki66N1auNQCuKHgS5Sxb9bTVhRvo6SBmu6UWzximrY8P", - "TFyVtL4CF7y/E+Hrl5wrSD5rG4YO1bDQFCIVa3C9pftZe80500rgUOTuSyonaNcPueSBYQCbQMhpip9r", - "7penwp1TXbURvOqoumzE4Jh3IwnySCwrQCssE1lT+3K3n52rYHfWxptaeJoG/+JQTISgU3F/D1krAcqq", - "8LGsdFMmgWm6T58HR/FVbrbLpeqdjZH1JWk+IvKBT9UMYVTxXrosklKv38PnNLSMu9E76lWcl+E9goTT", - "O+r949dzxdiFVOkRO4eBznt9+Abx54j9Wphs5CPA7RH7R6Mz9MG/n/d+/ojdYEuPGMJkeBgAFWSzEawB", - "J+oHYKzCsaAVLiaUd6gtaRi7YG2kU6S9I/YrPJegJ5WUB79inqaSCPUk1rT3dn6aH/3r6fWIEk2yvRHC", - "7bNfcdXCftyPXtd7fi04oSPv4/xPu7dXNglEM8Q2ffYrFS55nR555mL/cfjz0Ol8RD9AdqN9mg385+PP", - "51hXtQecc/sxV9jsrY4aANzXWeNKuh02NKWV3eEpM8+mN8DIKz1/9Ycbm9ED/BxOJVacxQ3xa/p5EzJV", - "cccDrmNI9dQ/dk3A3cRTPlO87Y7CUylu0D24kn8YpsSlsqQYRh4urrIlta1IWV+YJRQEsJuJdC0y+8Gv", - "Mt1YF+ADBtdQdaeqUDdZ1gT1IXuuKjdZfDpXkj5EPwauEpFRopD6DfehEtdUIkKnrF1bsnVVso0kbgQJ", - "R36Gfw4H3/7865OvPnZLOtJgqqvgYSgWMPysuT1hCph/bhVHdkMRimjaZCS/xJqBlJCfJ44MdLXKgTJk", - "pCHLh9bZyIjpkL3TagBKc1tMwBaQiiTj0OWSrHUU4xWq95V5wKTxxf9IC6/zIuPOK1wwDQLcoVLNRgiX", - "jOCUyXLI3lO1JYB7rqAdeU8zJ8xCgvxNKdirYrC36nnlIdX0K58bVUqgS8EyPtGX4lw9eXrIfpDfxfmH", - "AhDVGqicOVMoqi1IQ8cqVFEfJhcCk4H5HShp61xhGj9LFiGLKtqyCFvhEr0Qo0JdKNACglxMyj5SGNko", - "Q69kXG8QOOmQa4R4Txqcty9OaLANgSPI3vkVWw0gQZeGSvTIYwzxyLPCsqd4EHpaWuThCYD2Th9dEsNK", - "ep9Yb+RXTN03RHYE1XH0BiDFZslnVcqERMwqSYLeqRUaQyu4NmWVwDXUH34Z2UGh19N7O4cN9Q7KRpBE", - "k6s+umVILKTnH/BAd77wtq9toCdInelwhU0TrjMeg1JFenNW3U31xmOtWKCHymC2qo+bLP0rGDXe8GLC", - "wqtLJhYTAZKTr/ynXNBzu7m2+LYizfp7RV4XaAf0RNoPFm8f+rfQSjpt1sp8QvA3jhcqTZL5wIggTJyr", - "qIgnPh2K5sDw/dCNvgoTZmG+0FX4ojoIAt0U1gpPgPIBZcpKYbioR4cN0aaETUYqnGZlE91cLKiIEYZg", - "+RtEWLihqAgk+ql4/YIvk4HKIP6vQsSLkuDGS5SiFVvu2hUtU/9coRGtjNCFy8lXc6Vt6lPBIGgWlVBN", - "6/JBnimVDoIKmOX8tC8dHOqsrtYObomrqKsvNvoTHF/j9tS0i/44NlT6EdRrRL2ay/3gs65TvZ+7Zvud", - "FcNNhZ4/p3D50jOrOvfwctKORec+fvz/DwDGktcSAQAEAA==", + "H4sIAAAAAAAC/+z9i3IjN7IggP4KlnsiWjpLUup22zNWx8Tedj/GOu6HbksenzMjLwlWgSRGRaAGQEmi", + "fXtjP2K/cL/kRmYCqCqyiizq0e22NTHRFkkg8cpMJPL5ay/Ri1wroZztHf3ay7nhC+GEwU/HqVjk2gmV", + "LH8QS/gmFTYxMndSq95R7y2/EJYZ4cxSqhlzc8ESnmXM8qkYsuf04Uq6OePsQiwZz4zg6ZIVVqTQrTDK", + "Yq+pNNZh80f2XBlhc62sYFJZJ3jK9JSZQqk4hk4F4zMuVZ9dceng+6k2TDomp/ivZdbJLAu9wlzOVWUy", + "F0LkNsKF/o8PmRWJVqllfOoEALQs435mwrBU2kQrJRJn+8xqxmntLOHqXCU6y0TisFNYwTMPyM258xNL", + "uEpElomUZfJCMF5uki4cTQ2mW+6BPVcXIndhhgupCics0yoR5Y5PpZJ2LmyfcZUyrbIl/rbQ1jEjEqFc", + "hGgZN4IByHhEOL1UpkxpBzvSP1e2SOaMwzCCGfFPkTiR0lE+PTzss6eH3zJt2NMn3/ZZqoXFnoUVrMhx", + "A3AVP4glDWYTnYuUOc3cHNYjVJprqRxOFhpkMM+ruVA46+cnxyw3OhEWd9Jx4+zwXPX6PQlYNxc8FabX", + "7ym+EL2jKpYOAE37PZvMxYIDvi749RuhZm7eO3ry9df93kKq8Plxv+eWOQCwzkg16338+LHfi7sEvb/j", + "6Qfxr0JY98oYbeCrRCsnlIM/eZ5nMuFACwf/tEAQv1ZG/jcjpr2j3n8/KAnsgH61BwQNx6sT1Hc8ZX7E", + "3sd+74VW00wmn2r0MBwMXSf9DwJI9hNN42wu2MqZsitu69wDqAHID/eKEDOV06kwgOoVLlZdinvBs8x+", + "V9jlp1qJ1mzB1RKpzAZOqMTV2vqACAIr06bkW2eBwCvU+cxzHemGuDzlhFE8+0RrCsOxU2EuhWG+Yb/3", + "TrvXulCfCkveacdwvB785psDtOdp+qKwTi9+EpO3L07OtM5soCmYSppKAMGzE6NzYZwEWp/yzIp+L698", + "9Wtvqk0iRvpSmCsjnRgBv7E5TwTdhFNeZC52rc/uudMLCQe3ZEbkGU8Eg1MU19LiGTuYFZMKGSKLgAlF", + "8LsJd8nc80RTiGEvsquJ1pngCva8NqOcOzia3lHvf/3j+eDvfPDL4eDb0XDw86+P+4+f/Pnjv/XWOF6/", + "Z3VhwoKqC/gPfslP8TMT17kR1kqt6KIQlzwruBOWOQ3orNVALHIHSGz4Ei7rBPcfF8lSAXcTQLWwhgpD", + "/vMh/m+dDQMX/lchjUh7R/+orDHO9ufYR0/gaoKFfAf79UIv8sIJ8zyBAbue+srR+a2HdXhwjCM8XLC4", + "FknhBLMAXDkJZzzsraKO77C+r+9NKgxe/tbBEOuQh+wV/gH7bZ3OLdOqIiQJIAgYUDqxsNvIp74hsE8L", + "qY6pZ3kB4sGtbXxYQ+NuG31lhXmeS+Cpry49na/uZEW6MPJSkLA3ob59NucqBUFoQsLKhTBKZAO54DNh", + "BzyXzCKLOYrnMACWYnQWdq3PTjK+vDJyNnckFYqwdX1mEyOEsnPtLMoZSSbzieYmZTxJhLVDhtcBTW/B", + "FZ+RPPW3t1HuFAvp2DjPuJtqsxjxXI5gRWMSRuonnnAnZtqglCxUsYAd9NPt/byG4/1eyt1W5tewyy+h", + "W41uOwDAnqfU42O/50yhYLrp+pGdmUKAEA0bATNkUymyFK/f2IulhQB8tfIXwTK5kM42cyfXgP84Febk", + "QljHFzmwwB+VvGYLmRjtpW+ABhvOXe+oJ5X75mkJXionZgIvHPqm3O1wPA3bvYLZzgaA/fLcNnOXlpPY", + "jbWcAAoDSeR8mWlOUsw4ohUTANeucxNA7fWtpANltpgspHMkX489Eynp4oVOxbjPEp6DCM4d+/Pjb5+w", + "ydIJSy8QcSnMkmk3FwZauQLYE20cPRCwI/B8ge+XwjGtGGfJnBueOGHYBK5hbpZIZkKleLGNh8PhPyLO", + "/DwesucTC2cPa66OCQtFyWDYdD+lBf04WjQg0088ywZJppMLFtoxTchLvMXATBYyy2QFtfwYqlhMCJHi", + "DEYybXrkumQuUmZ04cQjW863j/d2yjixNWJW+J3FN1CYwp4YzoZsfMYvxGnkSeM+G79qPKv9xn3wkm7j", + "DAGt/O9MpnApTaUwbGr0ooWxhtYLmaaZuOJGNA5qHXdFw75/f3Z2Ur5QqRXy32EDoa7QXmUhKzsfx6uf", + "+gZyBFo8dTy5WJ/ii5cn7EOhgNEMscmZ4YlgRuRGABoGXUJFziHVBbQFMoEfoTde0opIc8heAzu0+NKF", + "ERRfAKBEK/gZL3LDEavdnCtmFb8Qo4Rb5JcLFCsA7ou50QvBXopLlE7ZidFOJxrUAEYwYn3Nd0yWvTZ8", + "QZ82CxakFsDGfQaoa1AZgEJETXxYGUJnxUK9I9pYG+TvwujBhFuRMmrIiIpQbpUkpmRSNeJBvzctFN7b", + "7/DdvkHiDA2RmPpMG0YCJmEmvf2UVsuFLmxsbBtRGGbTYTXQrGEt1Lp5NfTbcdqMe/S5Qo6NsytMtt79", + "xw9vYMmw9sDNPLSpzJoIdYXCattcmScNV9uSfv28m0itLiKu3GhrSJjTTcgyPhEZHhROH4nKIQUSN+R2", + "qRKW8MKKZn6XcxPejln2fto7+kcnSafkCB9/Xrt9EWRtMohJOBX81g7XNrNCchsZUe6SOX8x51km1Ewc", + "v2zaG/6vQlQwgtk5NyT+0sVPHFsrwS6llZNMsCQAHLLniiEDH8yMTPGiTuacJVx5bYBXLkyNsHPmuL1g", + "uTCMOwekg9pKADyOEEcyHbMFX7KJYNxanUgeVXyLInMyzwQbAyBsife/BYEgNzotEmGwM3JTcymYdIwn", + "RlvLOMtBlDYCJRyv1OMufCEty7lxEbMBy+OkmMilhXuEHbtSryhVKhPuBC1LA6PzepKyI6BEJlCMQMa5", + "hlAtJ/VB2CJzrQ+YeBBhv+OARnAUCzgD1ioB6XXhEr2AB5wXyFBHC8dQOcefuHSeMKSlg+/XLg1OyzQ4", + "sT5zmqWChqD3CegjgLeXU4njjv00R1Znl2KEmlORjlEuW/mNwI8ZLXgicJMvZVrwjGELg9OgpxOctE6S", + "wpSYgRJ8YJWAWeUSuz6OaD63fRxtONCHt1LrWykgQ8kOCCFu+3byR7cDq1w9rxu8qCIh1J5VbUvc8Mzy", + "PcJmdce+M+jxsd+rctcb4u/xyxs9e6KwX+4GPNy4IW0jPkhWGVWfJcBMoAU9yDzh+0sD8G0i3JUQdZ5a", + "Ppza3gdnKwMFZt9wrY1xzHR8hA3w5tATvFLSleUkmeDG29P4ylSH7LU2zOkLoQKrtsRgF4Iry3j5WqFG", + "QKT+JfAM0QU+2AFX6WCusxSuM+pZnwPOT/FLOUPi5ld8OWTjKZdZYURYQ7gfrdP05qYpK1CkZjKRrjwI", + "vwoPAAXd6zkvLACHE/PLs+xqLjOxMhkjFlwqkQ7ZGHiELtzKDB7ZsvUgE5ciQxsDmxTpTKBeF4h6G2w+", + "4SrVCs+IjoYwTqhUpBXDJR0ks3KGJ795xREDp7hmDpc3mwgUCHEqVxLnCOeUSruQ1sJ9akosKRSQukiH", + "5yrgULzMVo6tj1IEfDXN9BXjBvQVYD5hz5mVTqAU5Q3GaOpkHOQdmRKykE0V/7R+01CeQvySJKLkRiOO", + "czBjcifw/qztKKxkVnCTArnZIkmEoNn3+pEr0zqAoxNCAM3Ryfb6vXgO6zy637seAIzBJTeKnof/6EWO", + "chqgxm9eR/Dxq7M4TvzqeTngx37vSkxgr0ZzbRskpe+1jSJdHjSpq6wIJaJGaT8Az7mbrwM/4W7eETj7", + "/xbIyBxxteskK2CXt76Zaqy/ooioMfQd9BIIDTd+i4DpBya6iJx3g3D5GWSr1XU8yFVb5aqqkH2P+uhN", + "B7S7IBWwr1GMqj8bfrciFNEhvpwAv9bfdmee6wN28sLNtZGOO3kpfFcnQSX4jKUaLwZ4q16KBjltxnOy", + "n7Y92vzT8GqurWCpyCSKaHAVkekxAQ7HjcBh4Gbhyolwo6yJamg2HLUZEuBOHthcJHIqEzIxkj0NZuyF", + "E6/GfvXhw/sPoxfPT85efP989OO70/dv/vb8uzevxvtRw68VXXDW7qRVPlvb67EHMz4KcgM5jSFnLCwH", + "WdLqDA1+NTlsrbXyi9qzQrBxuRnj/Zr05PtFZwvsX1UIkiPYI1sVpFZkJGpS8fOqSi112RH07wMcc0UO", + "oGXvLggARyKNTav+KQiHA25BVBNpg0bKeyEIUlkDnrUg6cbLvKOkcDUXJniy4RjI6XGc9C6EhY3w71pe", + "uJ2AAHy7yg7XNct+BRdSpcyIXBtHCkRYHiHvEKwJlzKtEjQqlMgwRQzDLHgmf4GzV94pj1nhjphQTpjc", + "SCvYJTeSK2dhL43w9M4SnWU8tyJ0FNKwS2HQOWRSJBfCsb3LJ+yAXX6132djfFWNuEpH8Koa03vTrj62", + "Isv37ouFyiQ+gWCZNOW4Vm7ZGO2G4zrJzIPIA+cUTufySf3jV3CuhVEg68OxzYRwwjq8xaoT7fV7OEYj", + "gTUc4SmRQzchz6D/Qe5IvOP24rOJdNVpP8h0HWU6z/o+maKs+aR2F+7IJNAu2dXlDlsqsVGDv4K71qNu", + "v1RxV5TG9K5Ws6xB44NvbX8HkW8k9CB36kQrWyyEsWxRWIc3MLfwDSqY/QRpfnWtOtOG5VwaP3dgiNwY", + "eYl6iBR44k+wCK/w6VfMGok2RmTkzBb18cGWEoW/ZiG47/XqNYvKzOgit7Sojfacl0Gi8xoETfbbI8ZX", + "VrrgfjWi4pUerAMwAyHReFC2ngi2kNaSA0fcB8ZBOiOncSOm2ogGC0tSGDKSBTHYtejzfzNi/ieRd/yJ", + "t5iWbi3wgLungGGDVPKWTpGs3kCsNZMMqpkSbsySKU0wwWZMAnrFSGiLCZK93b8fOWpt2nchTG3niA+i", + "0W9dNErz54XTU5llbxsfnD/NZTKnk9JT71rGfQ9wcsgAmV5wpZVMeEYNPDdNxSX6Tg9y7zPz/3mSHj7+", + "Vvzpq/qiE25grjxNYfodZ3tm5GwmzAu9WHCV3uCiPeVKOsSecYA5dAR0zLiZFQu6W8u1SZUX7qipuVQb", + "FttnuVSKHPrmzuX26OBgJt28mAwTvTggB6PgX3SwBudgkunJQQAmJl/96XH6OP3m2z9/nT75Jv3q26/T", + "P/15kv55+mf+5MmEo8v+gXfbHQUYQ/h2yF6RWsKvjTiGtCyhPWRzTtYXh+YEjG0QKcdoolQkEqlDKpbJ", + "SZxlbvT18gCwL+WOHyRpPiq3bskXWdON5A96hHLlKNFFkyRObi4wR9+cxFBvLvAzDvh3hhTsWYNKAxYi", + "l0D9fnCWrN0KFTnSA2y8nM7KAR9Z9h+n798NPpy8YDL1loVyOgkHKxz7p8b9I87ir/+qN3Wp66BIuKiM", + "iVFVSSbhM36ptPL3egd52Ie8tflHHofrlLYRnJ/wBFnZr7YgkmVSplW/et+m+ch3CP4KaT4qA+7GQ3Z2", + "pf0iLLqTBxc+dCEJ2wDH44BzcvQyQf4vffRYJfbg8ZM/N3AEQp4NwsSEJxdCpUzptObJ4+9J7O+tQID3", + "nqbbUQT98zYNiA0qIw3Zi0zmPpju8ZM/l1649hnjLNNqJkzprIsiNDOCZ1UY3TZjIdxcp9WH0CqPauSq", + "C8/xd3PbWrkx1p23fgqbSht6BBKaSccMHaiJmMdIs4FO3VwsrMguW0kWHrsU1tJ4AIDH/vfqSVcxGc+Y", + "xsYDqbk4e4T0dlffxW44v07HsiI5+TOqYO4m8SnNw1+om3ypr9CGeifXnYc8TGqgt1x6bZ0err5drr4w", + "O4y3u3Yb+Rc1Zb7p52EsD/fil3Yvpp4yR7NiA3Kt34ehX3klRqvIZ73ImvlO43X2+7ki6ofY7Z7ItBV3", + "ez0AxK63ArV9uAx2uQwemOuXxlw3sCcggN81V+rEhU6Fe0GpBOyp/OVu+ZGtw+7ImdZ6PfCoBx71e+ZR", + "cwHhqQ28xlMBowaAHS+PT9q0He2cboWgfic8r9+7kmmTbSVuG/6+ZdeupEr1VeOy/fYxarImGW+JxI2S", + "YTlCV378E/b4ThcqtXfNj6uwu/Pjeq8HfvzAj/+I/JiooBs3zsS0HcI1y7VFOgYolEqFJVqbVCruhL0R", + "i6/S6O+GxTudt+7i8oa72HJteKif9tKIsNAZ5CaafZr2KXZvUOzTNBB6yEshUrY3JlM85MlYSCUXcE/g", + "B35dfpgWWUbbiu7HXl/kY6CQ05Y+LpiICpVJLRbzW9+P/iZsdQMMKBiyGEVGU2N5OsQOAcb/JCanGn0H", + "kFUd0dXHZsK6wgjbDw7FmI4klTzTM8o7ItWsj/kCmBWZZ24wViUr0pBBwj85C67pgSawHUzg5fu3Bz6H", + "BnOGT8FfIs41kxPD0X3JFiLmqIr+0RMx59k0+qeHLR+eq/dKVHy42vbEh4xTGEzl+vAp8Xwr64zgi6Ag", + "tBhGlvZZonkmbBLuTO9ahTH0NLK0lHISE2XGi4cOHH4MvivIlkUmFpTms7pd/bJfeT/Gu7Z0/090Siks", + "sHmScWvB8cRvOVfQClKRsiKHzF9JVljMIwI7h2ZsdEVZvWWGcVajMNfxs3Djus0dUoNxiZ86i9UKgTw4", + "nLY7nKKIgVv1CdxMG46lMcNQoLm6D2k51eA52sc0uUYu8I5DEhoTZY2H7BVP5sF/Cl3YpLBlutqSfHie", + "G33phUTyd6NRjkr7Ln5ZZClDTynOrEiMcOz//Z//y2CxKWV904t4B4PJqw+ucrbPjJgKY4SxfZ9cxfaZ", + "E4scfUE958y5m8NyDJ+xJDzZAGj0VfJzgSG9K1bGE1ozZxnKDX3GiY7hD/JATSAQlc/6GJaiigU6Z8K8", + "GKK7wDHm2vocQJXtpMSaC57ngAqQ7HLVJN/Zzt7g69RvM4xsBbrVrtxfUWp2hrhqgei36gy6gtygTuy3", + "Sqs7AG97G/d7L9+/HU51UnQA91IvXkPLdQA2MTrLjpXTf5Pi6nj6DuOIO0E8bezaMIRwr2UmjkHUgD+6", + "zfd0tVcdMH4fEMvw2QwxeBtc7PWi1qkJbCptDi80aOPFr06QX6722wT8B7G8CezQbRPot7qw4ibAy46b", + "wJ/pIpnfBHzZsQm8WBTALrHRa6MXO6/iVSuApuHkQiDtRobecZTj1X6NwJUVxp2J665zP44dmsDZpXJz", + "AYLFiVTJ/K8kr3cEfdrYefMwRNs3HafWe/NAZzy/6Shl1/oQJ3wmhhOQbs70a6O7oA90+a7SowGg9/Uq", + "Uy52g/pitdsG0IrnuwP2nZrAdrsaEdj6vYggKOdkmUrvJT4Ju8H8vrFvwyAhiLUb2He+9QZAZ/p7aZ02", + "y1fKmeVuYOt9GwbJjVTuTJ+8fN0N8Ilvn04bgFESs26APoh1KQiBgHAhJm/kVCTLJBOkGekE8rShZ9MA", + "jhtHGJxw2xE/T+udGsHq/I3maaebm0DGDi3gdp9ktU8d6Bk3EI3NEycvATHw43aw1O55rVcjYCTP3aC+", + "KLs0gzSCOxF6kVNeZ9gNfTcMsuPEK30agYJooe0Np/6yqXPjMDoXKphiukJ/X+lTBfoxKjuWlIE0aPgg", + "BbASO+k0OwhhH/s3AtYkLu4Iqlk02RXIJqnphmtrFidvCKxRZt8RVvvLYkdA3STZHYFulwNvDLBV4Lsx", + "xGbhrju4bS/InSCtvZ13m8fWd3J3cJsE1d2gbBRMbwaqQRTdDdB2kXE3eE2y4s0gtIuFu8FbF+J2698s", + "Te4GY4Nktisgnd8VnAa5bkckXH3C7DiHLaJwd2jbBMBdIbUIfTuDaRHBbganXdbaFd5W4W1XgO3yWlc4", + "W9XPu4O6OXJu1wTfBFabyro7rA2K/48/N9mD3kZfjm2GbLBUe+Opt71fL73J15LB1goXItwrFlPLuGJ8", + "JlRTfSDMyvBs1ej68v1bNI8Eu/RE6wswn6K9G34g960ywP/H48poBpNlW5kK9DwqPcoqVaqOOseYt+pw", + "WzXHDdrGdu3mBi1uu967RdHeQWW7RXW5TeW4UVPYZleo2kQ2mjealISter4WLd1mFdmqbmuziqquDlrX", + "NLUoYpo1Hw3qlZpGcJPaqE3t0ai1aFYJbNZGbHnxN7/UWy2Jq3bAdotbu6Gv3y0QucrP0AWizS8H0hT7", + "mobet4UyqVAVO2HY6csfqpXG+uykyHPhhDD7wXew9Hhs8Noh5xhp2d/eDrt6XHiHxDtxuihX/+B0scXp", + "ArfqPhO2NpzHDTLeR/xo8sbwvqntxcS6e8lK2+gmW/GHhaMe10COgy9Yk3MIuW2UnrV4Dd+3v+zHjefx", + "MvpIdWcQpV+VSCkvTQfSZydcmjLXlFwsRCq5ExmWUUlEuu5frFW5EeTr9hkYyMoGPfCQjTykRI37ZSNN", + "p7I7Jylnu85Jyt8emMldlCQsF9apKuFCWMtnYnsuI3p9YWPLjMj4UqShGNP6uD5bYCoNfddc3MwIbpsK", + "fP00X67CxDoQUHsIN31EUdtH1UgOfFkh3dKX2kJu5yInjgYFWtQMUyfj200Wi1D1XaSUIdm7/Qe/ZMIg", + "RxkMr1QMRKHRyCfQiIDXfMalshSDosQVC+NWpyCM0WZ8FH9DV2qmTdhXlheLnFJI01p9qo2YzsAvONRV", + "9L/XUx6wPbfMfVFoXyzSzgsHS9hfSV5W2cpev7e6U9WvcE69fm9tRo2Mf80JeBNe2SIPWfSanbQ9AV4J", + "Klp4xU1aysG+D5sULiTf8b7PIu3XSn38qxAF1ccAd36my5beSzrnSiYXIg0BU1IlRiy8H7fPCoHu3H5e", + "6I9ZqHL+8F106SZFBSkDpjJzWDVxQgkxebqQJa75aQP9MadhecTFnHY8G7KzsJkwOHmxPvOFdKoRKaGw", + "CNFlfXeG7Hl2xZexFg0yMSzTGRzgYQVMumeUvbPaIDci5bGOJd6S4JMuk3nwh49sj1v2izC6LcBj3Zd8", + "E1qUJx0JrooNPt9mypRuYtrVk5em4nLv8xqi5zqh2TBJ82GY0cgf23g1aqFaOg3OAePSJKJGcJ8nJo9i", + "2rjNDX5LrGSV56+y5sgtt1zYDWapG8dLRrXJlgjJSruHmMidkipRpreR0qnokhEO9JKrWeGqsWkOtSQP", + "yQJ/z3k7Sl1m0927DZNui0HEczaNEHTmRiy0E4w6bB3u0yVq+mNkNenkYHCri6FZh97hpmjr+HB1PFwd", + "D1fHfV8dLaavh7vkJneJgfm3pUn4Hr8PehloWpsuHQTdIXXkTXUxwfToa9oaHK81bj8tc+nf3WjX6yP9", + "J9PTqRWdltbHNylWLvPUDhiz2xSW61P4r083hT+OvLDJMfJ2osIq5C5SwnqfBwHhQUB4EBDuMhF91kHx", + "D60spvsoDwQJdchex/j1HQoWtIglq+T+IJH8oV+3NezccnUFt7Tmkj3wc0gFM+dWVC+cjjVfQv4eZh2s", + "GDeD+/MKnn6olrbCIUeL+Wt86pW8cOiEaCbSYT4bWnws4hPM7jX7TArrUk6YXh//fn/p/9S5/4ZcUTsW", + "y4F9eCsX4kXFkr/CpXXuz/bt8dtXLNiKgQlwyk8hnVj0S1eE4+fvnjMjZtKCfaKqI68mR3pW7f3IQsEo", + "mKYvekJmhYyKncccHXHsSiKlz3QM3gEN7SG9fo8XqdS9fg8qPMF/eZ5n3oSE9wuq6hc6xXNZFJmTwJlL", + "dX7H0/I+jeTM0IzYyCsZmfEZZ6VLZBoyNzHviGm/HJwXU15ksF0OnEdxKwvbddO2RFvdWIZtcnbdIsI2", + "d3mQYB8yRv6xVE5NdPAHTja+Pbb0lkxqzVe/E59q6PXAqh5Y1e+62ozhs9EuL2Bfmx/6BS/GG76AcWgQ", + "hrcPDa1ahj52YlFJGLfb6Au5ECMvZHsUXnk1SeukShxzjY8CwAA9LWdF86SIhjFIzJA3FUVm+KMiI0MG", + "1VN6AFifOq99BbfNtdrv4bx2cEJefSOVTt3cGL6M+we0j+uxowW3F+v795103qcYXk9Zpq9ESltVdmV7", + "j/+S6HzZZ0/+kkl10WePv/nLQl+K/bazw2dsrIe8a4rc+kN5PUnu6kv5iI3jG3Tcpw/vL8PfOqe6eOVD", + "dHz75LjtIsR6EFpLXUCUDeyWE5nDf0NjdiGWeBjPMwdn8cKZrM+e/uWtcLzP/vyX07mcutYz+RLTSTcY", + "dcAaCGfCriu5o4HzvDg9Zbm8FpntbDJZbgC/vC34Nn1RhTZ2kMGaEqHckQgWQO8kgZWdHgSwnSrzFk6P", + "jMgFb0o3PxdeNRWSQgPVzYQSJiSPvRAYSyy4q9F5JcojiHhb72wBqKNmkVzDtUgpsp9n2XjfJ6WNlcNx", + "Ug+Gld+LbHm7azqwgJZb+gexXLmkL8QSQl/hWr4Qyx9z+MPwqx/813hLwxVxJ/eztKMLscx5upnMgJ5k", + "TNiuioUwMmHUs43CpB3ZpQW5+EIsu1AxOuZTFxxwnYwq0DPttbRrgH8Qy4nmJmWhCcgCmZiiMOCDcb/6", + "iyoWOU/3u5u1WqLzfyNii+ILkTZvNGBYNRs2EWTOZ6Ku41/mUZ8rQzjzOEqLZ3wC/3lujL4K6Pn6a5D/", + "f4B5V934GS9FmIZ3AKSc11bUktVPlvTOGFH+67p//Rde66Nc1qZrpoRbm7ItJgvpnK8tz6gAr7Mim6Jp", + "scMT8W4FrOYcZXckYpXAdxKyqt0exKydnEoK57S6ya2Ge/4ddV+/1OgHNAlGoSisDYq0KNQjAE8eY6mW", + "NM3wG+TO8Ad4scB/fdzQXRRq6fvVbmPKvhUxZ4izG7J3Wg0gFoppxTgbow3rrb4EL+eF4IooFl76dIV5", + "xY6bt4qAmUwutkueGG5M0hztJ0YGZhjWxvae+MHwXUVf7z/InL8bfabIHG/y1vxeG/mLVo5n3imSYdM+", + "hWAjav40F6C96fq8p6GaHvnAKJK7G+h2cnTJ5VskaWywIkvjNE/owh/3/ecPIhO8+oWn5dV13QHLmWqf", + "7mCFxmGzMrwCc5hcYUSfHaKI0Xk3t0mo5X79VmTUXMMHc2MMOKH+LcfvfyVJtFQGlM+LPTpcOuf8bqp/", + "faEiKVczmA3PRgH9NuJo2b6CroPHu+Grk1mj+/mJUAx+K/2Q/mvwd5ZnXIk+iXMzI4TdbZxll3H+83bj", + "XEnrmofBVA5X0gpmtPM56FZHWCePBy3u5pTPd/TIKIHv9Miodnt4ZDwY0x8Unq0JWiOltNzU2GBFUEP/", + "QMxZPO77T69UGv8GCY0ubvx4hwbK7hJasJBPpbGO4TwYijR3LrqVO/hbEd0MT2Vht7xHqFHrNnXeHj/Y", + "phfJnQ3l7+cRV7OsAQ0++N83nP0NRIc/qMy4YRPvSpg8AwGvbZj7ljA7Dn5LsRNAjhDkdg0S5ncV1WnY", + "lUsV7ZZtVN8i4r5YE293II9byL2t1M7oRimbWpbBuqVCv3a6M/B9aMdesJAWrgW6NuSCm6U/papFhId9", + "8sQURJ27F7lvycc6SN9NiNNBIu9WouSWknl7fulOEvqm7g+S+m/cHHAXItwdqNMfFOd/VMX5PanJf7NK", + "cTYRsOmeaSI14c1wn86e7Rz6wevzwevz5vrCjeXmbimUrJXW6CSLNPR6EEEelIV/xCDBNVJo5PVG5BlP", + "MDHvSKiGnfpQNmCGq5lgQqU+XVCrtqoC1DpuXBew2HALYPL5hUNtnOtp+LkyR8zdL+Nphs3YPkLLxMsx", + "qhPeeZQ/gh9dw37ctRNddVJdLqzGIqu3vaki0G5XVKX5w930cDf9Ie+mSAO/k+D1m7FH2IR78CzekSlu", + "r1h8SwbZXJyuE7Ns6/rAOB8Y5++ZcfqMQyNKR3Rj9dR62qN1DVUt7xGuYmPmo/vTUjXTesurhTKQjmwu", + "ROOjhX5n3uWRYTs0hpGahOXwJRbyaZXRE56J0ZQnTpsNI2CzYEDKYeJs77w4PPxKPGa/aI3pBvZ/15bp", + "358ebKdLs7Uq/53dmrURdrw2V/o+3JsP9+bDvfl7vTdrxN54ceaGNPzTDL5ojQnGn/E2sUWe03XSFghM", + "Yf4dfGEiL/SZAaL7GNntNigTAX4qMr5srN73En5hE+GuhFABdn+tXN/vSBXXIvWcXslckKizk6Rzzxf4", + "NTABx1UiOhmFfdv6YM8YqRAvA7ZYBtGLO8wB69hj14ZisSVqzssJxZnE5Pc59yUJhUo7D32v8ku/t9yw", + "u2uW8a57W+Q7jN9xZy/DZO5kX+9AcCtL3d+L1FaC31Fkq3Z8kNce5LXftbeQL9HYcKv7X+LFjl4yWDoW", + "JoufirzzNf/HFgxLlvL70bfzvLPLoWaO56sR+47n+3+cUMDNN2MtR1JjApsvMeO/T+TU6/cwj1Ov3yvT", + "OPX6PUC5jpnQq+61a9uDP7LJio8tLz1sv5DtUloBOoFcDQSISUFgz7AcVx8L4BD+XXGT7rJxG1BrzT3y", + "i9mtamaDkFc/JDYInzGvQfiASQ06btsJn4nv4Osz/droO3L2B6DDSQXqFrm0of2DOPogjv6x/BXWiOAP", + "nG0f9uIFeSScJkYIZef6DllTsgq6C39q6PTApHZiUrSBo4lYapWOLr0cujlfpO/ExLUTKq1qcEL/1rSv", + "mcxbS3wCSmMBJK0YtbmhgI2joGV28yCYhBHbMTL07jZCS+nQ6gjY5DaruN4M/zo4oN5iiOXmIZa3HOLh", + "FvzSChn6zdhdPVKy4dcEo0E7sgCaoyEYXEHCOkinN/5nLmaQbyJXM8o0cSUm+d3kiIIXxMgWZsoT0Y2x", + "wY3s+IVQZdi4779Wlw04Xhu3a5En1i6tRqFC504u5C9iNNWmzdElzF2oRKeACVN+qY1IvRVIXwrDQAHU", + "NsF/FTyTrokB6AXa/QBtfaOQZuPwkHLQZdrapT/J35F57baSkeL5/chFHvAuUlHs8iATPTzcHq6sxivL", + "00jrhRUaNN1Zi7lbZHdzR225Kvwk/uivz0xbcYecFcB14qfU8IGLPnDRP6D6C7H/D855vucqzcR/8Et+", + "imt8KXmmZ3fHiuaN8LvwpraeD8xqp4JHSSLyLVqvFHeWsBab04RSaRdyk4fkAyP8nTDCZlJrcbTVi9yN", + "do8KFMoJgw6cTjPOCI5HvRtHCv5+OHU/UOp2lv2OX8oZd3coLyoPsQtbLts+MOIHqfF3/fY2fCEaF/k+", + "5/8qBMMGFc6ygTM8Y5xlWs2E8Q9qSS9owDyeVWHcipEH4mwJLpwKY4BAdCaT5U2UCh88iBOCsK5UCA0Y", + "jXFvqfnKtRgBOLxF+11PS4q7Tv3p5gmfut0+FQnoi3QwNFxR1pKbZ+KOIFpcRf0VBUs3glutyqMMuMCz", + "TJhQDQ7KGmNO7mVO5VOMyDS/o/JMhclGuIYGG8kpfh9rVAvrpKJ5//jhTZgd3l8wKz7RBeYRB74/3g/I", + "Y2N2XujUgjyVc/nqyZ093/xGizP9vbROm+Ur5czy7iWDOvxd5ITVng9Sw4PU8HuWGgSgeeMiPR0wbFFb", + "TqAVvAM6Fw7dQGa/a6VWZY+3M8gTI5U70yfp9O6YYu5hvnzdhRFWWz8wvwfm97sOe5I2h3DmueCpMKOp", + "1k6YdtmcM2qI86XG7EoYwYxQqdggd1PbkROLPONObH8F8AA+dIlB4JksM1X5n3Z9BYSicKNUJ4jSI124", + "TCqxaT6hLfNtcUJiMRFp2mEkx2czkY7ydLppDGrF9niSAG+fZGKfnbx8jUNFc2/bWP4Md9ljf5r3sccZ", + "3CcJz7f4OaHjIwybcZnC1iIjCn3bgC+4mUk1mmjn9GJ9gO/we0atGP4/me9QWsODxwCUNeBvxNTdGrRp", + "9jv9AF/fGrjTeQP/1fktADfLMuVN2ax65jMxwpyqtgsy+kLkaraChy04kPNcmFYP3hP4teK7u+OCCXiL", + "Wy3Bjg61u4JG5cUosXaEGwRecZtpBH1dYXOgKe5N7hUg3rGOCCnf4mKHpzWC6KmZ0YXa4MRXtmEzw/O5", + "TCyxeQSxQbvS7Oh8wmfhhiAf5993fSTDlYUTXuj0ZtVN0+mZh/FWp03amu/1Fa6zvBq8JLQ3/oB/Prff", + "cSu+eUr+q+G7U4weuwsdzU21Hx9QS3R3gr3XOnUQ6kPLB4H+QaD/PQv0cqa0EaOEJ/MttwpRBJssc07s", + "ERYI3VolOo3y5Qb7ShSRqelvytJCy23Ws+BKbpRSXCpgdCJl1OHB+fxUuJ/E5I2cimSZZOLU3and2zZA", + "78L9m/s93AUPd8Ef0HmoiRh+N9lYLK7mBlL3+pasy92xAcNhGKcXKtsbT43+RSgSt6nW5v2J2WGRHZix", + "48ZRcFfC7R1GAtk64E4seLXLA/d94L6/89rpZjlSbj5Ct6P1tb6Gr2HAPPNJXoS55K3pR28bDAtU1xpb", + "RHNpC4ZFtgbhsHcTYMSvW9V2b/m1XBQL76lVqu+qod4NplZ+3aarqwOMOrst8FouzjoLa7wzbxbH+vBu", + "OHU6f6N5KtXsLq+pCLTbFVVp/nA9PVxPf8THQUkDf/BAK+BI9yM7V+F25UsPkvMDa3pgTfkW6esPwp1W", + "DIQNyeyvGGfB9yRFO6EszYRfTGrLujGz1+/VLZldc1hS6aXmvJ/+R5p8uWNcEQumjKBfVi5Q4IBCddyc", + "lQCRhvJSLfEhPDjBYjXVLyazbFhPr1/58NNcKMjFOzM8he3TRs6kin/Azy+MtvZ9+B54XfnBGZm4xo/r", + "PQtl+VT8aLomYF17u7eoEdae7rShNnb/Ys4INA6Awmq20xZVUqcc/dot1Vd1i6D7l7lFkJ2s607VU8ys", + "o1LzDpHvke/75fBCSInTcWPOuJkJ9xwU9+Caj5/uROInUENeg7xF5m/p8yD1P0j9fyypv5EQfkd1I2A5", + "m9xpqMXn8KJpLegc57z5heI5aKbtPTDTpATbjZPWOjyw0Qc2+odkoxUqeOChXw4PNYI7Eb7Vyonru2Wm", + "DfA7ctXGng/s9YG9/t4DJrUVI61GqXA8mW9LZKIoS5ZlvmdabncqJsVsBnMMvJVACts9jfcGYmxLB3a9", + "HJHT9yiT1nWKzMLDok4MOiG3T7SaytmmGEAazApzKUz3cVZgYxgi/eLvl993updCyUthLM9GSrgrbS5G", + "FA06ImXk9lpz1M6ymeHKiZRFgMwDZASQdja0dnOxsCK7FBYJpEsyt5vYLqq32j08DSpwd7nFHh4HN7m9", + "uoQSAjl5GQzpGrc7DeETJYQ2Cg474BnpJlHPNy157ueIPnm40b+8/C98konRRABzpRRygEFGZ+1Y/R00", + "JsOLb4vYTaBStjcXPM3gptIqW+63J0VICruZdJS4qpIP9tiUZcGMHJ9szjAwCQCr9UO8kn+dUtuTDTQ7", + "cP4kVaqvKp6bL49P2rwb5zJNhdqZd1C3tok1B+37aV37CuPEAMnyUylzuoNDaMP10ShvKXE1usLBN50K", + "HDO16pbq4Yt8q+u89VyWNzyXLyFTXL/X4prs1x59kjdQCuHG6ObBLdi/LazFTwSh15y/FdwTGezKQios", + "AYS5/hb8uvwwLbKMDuxzBZYT9b2k59X9aUrSpgG6CZktXR+kzZ2kzQdJ8EES/Dyq80b6/Z2n7Gsgty5s", + "+H0uVOBKd8l9dQVuN6Zb7/HAax/00n9I3lUlg5YsXUpkjdsTujFswgCSSDfwm7u+QR8skr8xi6Qukvmr", + "S6Fcsy81/k4e0yyfcyu+GF9BBzPHaPlenz68Umn4862+FOHvF1wlorNXYT3r+rrKvmPS9S9mGyErvOfD", + "sHue+EYTbuBT4fRoovXFgpuL8NkWE4qOBuRVBc+q30R3/NDa6Rzp1TN/aLuQcGQ+uU+/dyGWV9pU/hpV", + "gXQ5tPU8EM357LLmXBBfzFlRxgrYWUxX0XV3KoqE9bSb1Cxoslb0CV9QkABoPQAjg9KDWGv8u1R5dNo1", + "razOxCtjtEHmub5xz6svVmjMBLRm2rBCJbwAVWpZ7ImJ60Rg1xCd8mohHbprw366K81SaZ1UiUORxurC", + "JMKyK+nmLJXTqTCwRSAOMjvnubBD9qFQTi7E0I///OT4BbCelO35b4Y0I2BIdp/lRqcFwERy7GMlqD6I", + "rbaPEpB1PLkYOcMTUcKO0z6bG32l2F5cW/ylCppgZlKJPkt0VixU3y9lVJisYZzXUmSpvx+BGBNQxgex", + "k3qijMVRCmgUe7kTM22WVTHKr7/xhFP/sumihFvFAnwVgZCDE+sIBXueUg9MNQlb6JrqcZ8ZkBa87hNO", + "egq7Q+XEQy+WFrg/mFY0kwvp7LBR3ewarBQ4FQYHax1f5Ewq9qOS12whE6OtSDSIU92k9FDVZGXLR4hy", + "vZ+3yTHOBqj98gTjxm4SaRrPZFf1KvYMOoGP/V9XcAqIooHisyzSenyOsUQLk5AcSGu1Q3ZCbhNoSaIX", + "ES3MU3sb4cLWSycWOPa6lEpfcGP4kt5JQF9NSSvge0YJWYPRlhrAXAwpekt+hOiF1N154itcYdiIIXTr", + "Nz4Cwi5CJ7oa+oxnV3xp2XkPMei8d6tdXNu85kThb6QSn3+jSga5PkOwYHhjhp/ZVGb+AnVzI67qc7yD", + "idXScgVG3ZVh8iw7hV7QHWlrPcy1WHA1MIKnyOnphvJXka1pGAKSXOkiS5lPeo+qhtfasNoVt7dPl1wf", + "AUylsa7Ux1QIlHsSJRANV1nfG0HEVF7jZUXzWwhr+Uz0GRqgzns/hp7Iho7YROvFeY9pU/1tTyoswCit", + "2GfwmPCNr8sH4bRQqLA479WMSG08s67ADKzx5zXm+EbPOgstUJOUXn9Rasj0rB/3V6qpLj9dcaP6TLhk", + "uD/8DDdxWNjDPbz1Hm4uLXrHt3DtPH5bd/BOV+mGq6pVyAYYfRbz8BpdzOasUFOZUQlWZLekhR6yMfKR", + "MVpRdUE1iFhNZCIitEwq6wRPnzGeZQzfKWz1xrQgKgtu2FwYMWSngrSgNhcJvraQBxZZxgAnGhnLPfH2", + "18h4V49n/XSGW1ld0BhsZ3k1LGp93RKHC6ZFJLpSYRNY4kIr6bRhGovnZhns6iDcnnQ8Q7aifiY1XJ9S", + "ldH7pgyxZyLXCboJXM1lMscONBOdJIWJvgh1xG+viAmnvFoOE1+IUlUm0yz/tOeBBqjtSaD7zAgrHIPV", + "8GReWV3jOIpfjqz4V0NON620I01CtmRSJUZwC8/6ynZZUDuoJIhkfWoG8xJpnIDTuVcAV3o2bkIH7nkD", + "bXWgMBqnYnVo3I8NquWAm2u6ZbZnHQpHHG4DW1mnDQtFn7D9TSOGe6EDZZPRgYpMontOsxhqRCYuuXL0", + "OpeWUPkZOaFBA9iZypkALeBv2M72g1apbOs9mz1pbWUKlcOqbmx9ySUKbri+qqLAbkbOE6MvheKApAvh", + "OEoH/uSWgM1E6F4fYpjwSp5I+etSk2iW1E48iAGwdTmVCfXHXB7BEartbhrj9la5l2/ht7oZcS5kk08w", + "iSphQUO0k42P/MXGorXpJPgN0Qheq1Uy1yEbXwgDRiuey/ER+wE/sOcnx4xCDdieEfgXWRTpy0GZ3CXM", + "nI3FtRMKEGF8VKZy9/OJv0G5U53wDGy1ibB2fMTs0jqxYP4LZgql4MQ42Gq8VrKcbk25mKQ5KqfD/OGn", + "MFCv36sN1CjpBlRpR7YGIWUbPoTbjJABuBXRwYGnkwO6Ko5f1s470MIKbeHhb6CY753LvxdwN9j2RThT", + "rBHM92dnJ75klWULnsPpXnGTohvZQHpMgdkDa9OFY6TKlb/QJcP+RmpnNLQuc39/eCmPTQrHFnzJJoJx", + "tUTDNrSql0NYW8yxcsJwZNovMplcbH0sFfBPAk2DJOF9Cdml5CUSIrcjCN1eR7KcyG1fSI1rengntb6T", + "Kls/wpO9x9dS+9nc8ZvJikwkTjcUA4RyVOFXlnM3Dzp2XLtImchQ0GoRKWYNipyzt2+Y4zO6kfS0CRoc", + "WJHnwiTchlvrux/Pzt6/67Pnffby+G8tMkyjMP83idX1UFtE3E+5loH7zBm5WLQoA6+bYIurXBvHrgel", + "C3MNOKwFdtFnIW5EsuUGwMubA17Bw+sejNQvT5tOaOMzqYKCP4jlVoZ3IZYTzU36JbC7sJ4HZteJ2V2I", + "5adhdbVzuWNGB4tY28AfxNLbmaP0+YPHY9pbYkCvYIp99h1PLmzOE9FnvJkL3YCbBr6H+vk5Tyn4p3SK", + "uxDLUAvQ2hbu1J3b+siiTdz2+N3Jj2d9dvbqP8+ef3jVznNXxUFxCwZzmhidZafCuUykW1mNxdbMUnPP", + "cMK7iU9d2SSGm1incwseVwoCsfu/bfa0vhsPjKoTo6JTH3nE+DQ8q+Ww7ph7AXsaXTdFPyGeXw8ipnPn", + "PV64cRU7ILSaCQtI30UswfGWreMt73o8r4+5Af+ksbaJo7pp815LxTNm17dw6ryPaVhBYDVdVqJHyy1D", + "Le9kqBVc9hgSj84v2k9ofYc3suY38lKAGPqCVJWtHDmTl4JdSnEVHbKoQ+kHDu/4aZEF3v3Isp/E5MPZ", + "i6jDeScu9P6Qfe/bgRH6Gdo6A0MH3U4MtJWQ4tN2NiR6PetteXPTdjyw5FaWDFgxAqwI/vL3yIlbj2ZH", + "JS2oybzmPudLLJkJiDdeW8u4onxefUq3WwbeREJZtw8M2WlNeW+EH8p6Z0csNYzkFfTfk0zmGHcBRIKu", + "gDQpcv6LIQfjckrjnZTlHTb8ZQx86M4dymCJ6MW4A4s44ZJsV42nMlmuLfdzsIiVbXngEh24RIkWn4BR", + "NB3QnfOKSlRQK7tIC4P66tGiKTkEz7JBkunkgoV2UQMUcRZOYyGzTFYOYqfa6pu40jMKffJG60QbI2yu", + "VYqxUG1ccUeLXHULNh2dTrDZd4VKs13Nb88ZEFomXGm1zzw8iv5HkYJpg+aG8JMFfuJNSVKrIyYdplPK", + "nS1LLqAAN9GXZAfSSkCruc5S22fOCI5tjbBCpeHwAvzYkoVQP7MkXwAjYPUWI4KuhKmM1WfoF1+6dkdg", + "hUqFKdl+tQvyy6eH367jX9mqIYZpZTeG7LljC20de/K/vv5q8Jic3jIQKa1jnsgZR6MMoZ5fnbjmicuW", + "jSxiQTXbekffHh7+6fG33z75+umfnh5+++1j75IPPz1udBPlalaAHNjwTIixB9+9OGFP/wQKEFs1M2sz", + "jN1xv5/jqQ7e+C/79JJBwyxsHVrqxBDtd1DCTwASp2Lw8hXgL3KcdqehhVTH9OPjBg8ihNxhCdSwvC8R", + "YR9Z0GHwicwkHGhtgnF+axMCRv6LbvJrPX7+7jkLP9ecFzYN24+1Uf1BAzrP5KVQ9Qm9KgD1Dr4TJpPb", + "vRYrmFmZctyxKgJ04Bov4j3bIKMkF0pfZSKdCXILg4UGM29j3Co0IEYg0pKRtGUxaA6rDYCJRKps4ZEN", + "pw2oGZfZfF+HvHHeqtt8e5tlFBp9O2aFCsOWlGBXCaF5TCNUKowwrYOFBhEx3FwsmNNMOsvySHXwCSYl", + "jCXNJzdCPXKMwpUYvvGLurqzaRajXOCN1FTQxDcJilXPpSPP/FchCpGiORh+hMF5iQ0wwz6zEOjILbL2", + "CVzGoSZKKjl4wSI/BmcA5ri9wOtkiQtfAn8PKtwlBkMvcEcjYztsFJFayfNAuOQAUQPaoEqXjjB0wV0V", + "9SOgja0uqrYDeuK9J6Rr2uZVwaukw4DcVXRoOpQGFO1ArxB11pQvaxzIDn0iayuJ7Ill3LpIn30fA8Qm", + "YqqNKD29h2zs0TPCwouz3BqViEZeMA9JK83C44gfAv0ur6QVR1WnkH79fFYo0fabTo1cy5mbaysYZoEk", + "bdC4fDAM1/a64b0TdqHrA6YuZH3s9/wW3bh/9aIYXQpjG0WNv9EPQUAKGw0b437BN00VTuWoL3kmU+5E", + "VWjjMy6VbdYBJrV7YIcVVS6Qj32KNWlK8rVsvhtYKlNkLsAW+sQUpPPfbpeXK7Nu2dENJPWW3FNfVp7d", + "LY/1M58XoZoRQQcXKXhOZhrI5gyVrM4sg77Be9KkRmNke6GczIJX7CgqMkTIqQDesAoiQGdGWMx3kaNr", + "M8WQUvbchFx9qmnr6C5AbUjs4idgnQQ7D1FBvKHRVVa5IPTBcvYCL5Jphl7YMzHK+FIXLtgL/Jdln/DD", + "vk8HNpVGDBtXF1NfGWGdZzWLIXuO2l0juHM8maPBjbOpEXbuV7zgyVwqrz23jQtMuPL3R5WNKbjIVzwn", + "E27gYBa5W1Z/Ctc+nY1WglyJOypR/Wpvqx5pw8QH/UirfiTgWVVpdo/6kY0ntO3JXccjynLQJJPB95FI", + "y4XhWzxBZjMyAolBpNFjNLpfhl+GVUfLlV7bd8jPbvtWHCvpXnOZbWWaQXmSYNiZ0iBwMKmkk+CUSPP9", + "1JS2MvkHOttKZ3Bgoylu2f2TWdPx7EZk1om8HSUp6QvTpsRDHzDhRE4PA1qqd/rwYpctzBSC7DFHSgen", + "D5zE9tV+CFdlJ3JqlEFqtGXEQGDAg7Tz6PIhrue8sI4ctLPSikJGagf3oh2yd5pNC0OixaowcwWiBAkq", + "DF8V0gba/hwk3LRrD3S8lY7jwX8yYm49qHu5NmuIDUssQCotV+3pAC5QogPA8EAA7EoYwdAFrMij/7wt", + "sFIARAAuvQgbUpfVCbJ68zaMeIeX7wdx6yfLyqoaWAZflUFeESMIrgdpEfdhxnMMKKB30Iu1h4sRITnN", + "ilQe3vzO8OQCoHlRxb8DvHpVWpZrqdxn5TMPPGZnHvNJ2cttWEug1a5WR9i+Vfsic/xCIJVFeBUHpjop", + "ddnfNd7QNMnt+1MWBm71RMiFkTqVSaUK8KrC6dJ73XejwBLOHRHhyiIeaHArDW48gjsmwabT2Y0C8yYj", + "BRW8HwiV6FSk7OTdXzsiaNy2ydKJrVI6jL1hje/ohjpOM7HV9TrcZqBEa3S85uzrw8OFZf8qpHCe7siS", + "qjSTajDNsGIExvj56N6Omig/9G3pbcXR9oHC1imsqim9R9ryePdGc9DdbnwariNgRr3CK9ZnyDueehEZ", + "EQt3m2dG8HQJ++NxD1XwIDmSWhbewEqz3Ejw4Qlr9yDGCKPqiirdfp+NC4P1EkLiBfg75ksYk1lnbIRP", + "0wQbMK7kpHvGxg3IiKaonBt4rWdLluu8yMoiStyxhFvRNZ3dHRFL6xE93E9bqcdj6P2/Qjcf0h0HIiSY", + "GXfbmVUJMPRYzZ2izWq8zfrRobFt1Bzb6Zft821VfvMqLSXc0dGrDx9GL96/e/fqxdnx+3ejD69e/3j6", + "6mVz8JafdGtmj7CoinNMzA7uYok9jhqoFTbS6h0Ho1a4RPPAfqXDD74p5N2oqANwhLW8QtVQeZ9S6Ael", + "r1RIyipVkhWpYC99Hpc+ey1cMu+z//z+Q59RCtI+O3XLTNi5EK7PjhfoH/VWpJL32WsNfc7EtTuDl22f", + "Vai7Dx68p+Av4frsLVdyijM8MWJKY7x3c2GITS60EdsVjZWzqWFFv0TIjQENfgs/EJjOt0w4PjTxt2Tj", + "uH/2W531A+Pdynj9od0/x107lzvmtSHF0tY8j6EhyQmk8Q85ZPxuNPKeeSU9xy7zrqb2WK8z5bclpvCo", + "ZjsnVtT33KfiWTPgaSrS2IdfcplhUIQ3eufFBFL9km7hY7/nFwl8oJVvHoc2Q2jDpEoRAubcQXmqsCK9", + "EyZqPbvMuUGvn5wylROHQ9egxv2XdmREKg1g1wZSlLa8e2y1uoaeou8wQRhuKSXckGSFfmTcMp8AFIFf", + "SRNigf/66qzPTt6fnjXfmLm2bhT4WTMSTHS6xLsKoByc/HgWlmL7sLh4zi13Iy2tmQDe032bYXaoim9E", + "6IXHUFYYqWw2bqMpxB2JAX1WKAk1Hyo5xSp2o4cr//ZXfixiUeOJJQdbYwjdpAGba2XFDuIAdWBGJAJL", + "xPh352tpogbE0yc1RPSHQ/FGCOqGnvyIlCX5Mp5ecpUIGyIn0cWnwr0/vdRR2Z0HsaOD2EH79SnkjtWT", + "uWPBA7C28ZD8SdTQu2SzmEB66pMzs7fHb19R8tFGJghdRy3OlB9q5GOEM1Jc8ozhOy/RKDdg11qtnxV7", + "H3YS3gfCCUWK2mwJDrbABlOALltmdz+S0avpVGAZjnIHuwlJsRRYAgqr2Il7/0LvChtkoy53vp5W36zZ", + "RjFxIRdtd1U85AAwLowECMCEg7lbZP1QrAE6Ym20zY/w+zmAFyHth1mRUYkZB2Fku3zqYxaoThgdw+qT", + "H5O2FN7gPHxQMPzGpA1MaNwYaFBSqbdSeIym9lso9cnhoceHkh15qq3TadPVQiO06LsaJ1NJ5/j+hz57", + "px17rQuV7t9UvvKbUnLAjYIUlEh6YThgeLvtlcLGYnxDcOdMqB/b44qd955f9dmp4vl/O+8Fp5Z9SI2a", + "1ZJsxs7SWZFNYReWQIAQjzpkH8LJhHp+fgQ/Ay+S9ytB8vQNoknMqWuh+5gIYRjScI6HLPIOXychTG0M", + "4McsXORMxgLxXZX1AOC2QtvqSTwIbK0CG3r5e9y4R2Gt8UR2MxpvSAVdJm+tXhchRLyC+J824zOMDqMi", + "JmgVwl3ayX87n2pP2wyz2HIAL/XiBaV9BPNIB/viy/dvax1CpQvYbwA4TCNEhIUvv46VLe6KzhsX9UDw", + "mwk+1YuRzwCKprl7p/32U7prk1yaj+K+NXAK8ohchGz6jBy8fKFRxfzeMu58KvI1EpjCfvSZERlHscjp", + "tfuYXBr3lHZ0aljGYH/IfrSCjZ2l9OJXdfeyhnQVK/tfX9lWSeQNhnN1zSJIwV8tWQQf+23xshyyNMCa", + "iiuLE+ZSYHBogDSXU1RrlnrmS2kLnsHuYNjecshe8WRe60Ceo6TWfTzwo8KizadjKg8+Md14SD1e8J75", + "h8dmwJGtuJwUi8ITZw239l68Od33qB0TOZwIgxugEsHO5EJkUglIq/9pL7HV5T3cX91wDzbsE2Pevdg2", + "i7bcMy9X8h3VEFooZ5Zrfsl7vhLgIV4z1Q6W5cJgnaP9xuxI1V0dpcJxmdnd00EFcqpsHOPOGTkpnLBb", + "KA+XtE57c56CmzmIK1LlhduM0rVN8umCE5GSlgJrESCQYKFCH82+14RipVzPH168OW1GeRQXGjJIVce1", + "iTZBbyStPyuoEUc7ESI03pzuN1/9azjpFVc7ljcKqY7x+7IqY22LYjWltiw562M1Hl5J703Yuj0/1wrZ", + "ri7Yz6XMlNVBCEryrdfFG5+4yYt5oKI64RKeOW9enPxW74skL5nRwz3Rfk8k+X1fD9WTuONrIUvyG7Jh", + "j9MlShNG35YN+6zCjdxHpiX4QP9vXpyUFSXkNNjGWiusjZqZDby8EEka4HZK+6d02s4yX75/y6BBA9es", + "jNOsoyZFTsu0KetS14k/8xc2IL4dkHXDZ/iNoYlnciHVbPA8y/TVgDw+GtcLtNhe/4MbwVsmRAmWmf1X", + "wev3QQl7m/tVFSKsJ2QUZJcyFTr81FKu7H4vverUgIfR6d3DvYcDNQlnN770tt90mm9/5Zcv91VFXha6", + "fw4VXpz7w3W25TrT/N4f2rWz+I0r59y8hs5fimruXQyK7kax1RKflNhljX6RX3i4QL/sBTdGCix+GZMe", + "IbpbJhVyrQnWinPM13v09cNDXcqqJm61Iuun5Q4ru/XAIzbziPKw7plTNJ3Lbha9m93qKmA5tdi1XO87", + "ccU2l+xl3Fo5K3OcSrutam/ODYjF7es5wQbrSyJPrQl9Xw5in4VMijiDhoq9zY5au5fjvbOiu5/Wslri", + "gNN3VviWnGgrkleJRZ1JYbO95ZU3qKAhuMUQF+v+rijYKWvrRLs53XPRJcnWcadmcokWaGlZBTxZYrAO", + "KLqbs2OVilyo1FcErMa8PmOcWalmmYiJBYObVUz0h+lgmXSf0sfjwUyz633wiUw1Z3zyPhdqg9FRiaso", + "4Dg+YTryE9hWjZ1JtiF2MAyxyWeavkDcR7ymflDXGB4uNkQ+8FoqOmnL6OboT34Va89bXSuWsS2S2ctL", + "9RjmiuAUqQLRD+TKpvhmSJujbLEgd1cK316R0zDzdyjYO8eUX84I7jD9vgWyzEUiebZTLPRdSWX1U34Q", + "yjYToeOTEeH1JyW+G8hkOMtmyemszcMKaBh9gD3pIjFoJSioSS13FTKa3bnCfafEVbaMQ/HJvUgeTrqm", + "cgQURJd53gNtolQqrlon0yjGBFAV1Vk7jDvzAsu4Axx+nksodd/KoYHp0JEuuEIVZNXv9G9vawmJUyMv", + "g7ARU33PuUorce5U/H1A+swBz6WvZ3TEjEiwrO+MZXIqkmWSiT6bykz4evMoDvnXO03GFyiOCQuhRZga", + "piOfefsQ5qC3qPDEeh3ZkuV+AwZSpUUSMz7mRsOQzPJL0WdG5BlfhrKY+7XF8hkmLk5ICO/KdP2ot2a8", + "Dcf3wHrbWa/frhHP5QhQ+j6Zb9vR7F5OCYmvVktpbSGxkBJ7632y0RH7iPGI4UTDSVADaXhn+ueHf3Cg", + "5ONQOy6xxTjRqRj7E+a2/A18wOPQTUh/0/JNxCVMJyMOjEeDNN0Zb7E+U8qMLhz4t8fWfawPEdbj2Q5+", + "h47zcQrECMYnxGpeXYsEpD/M/fohsKjx7rky4EAbQlmi+W2dMYbWC5mmmbjiOwZsNEZGwMEOuySdq0RB", + "1Pa7EgvRMR/didHXy1fGaLNByclVKpC9Xy8HGV8KE8Idynoc9UQpQ1Z7Q8MvcAloJiiJ/lxbN0B4dNKW", + "8TgM5UYhh2ysJxF3KVAJRjD85+AHOhNcwQCXMPaxTkeY0usJvT/WZ219Vaqnh1+V8/NPi0c2Rs7mOpPJ", + "kl7NNGgqrJPKX1pv9NXgUmfFQsRM9hIXAlud0lmyY2eDYhzdegbV8A34DHJFMMhKnzHVtwkRWz4ZlL/n", + "vAhCU7TOCL44okXG5eFNihEfdDyYk6AM/sCCV7GqR+br00obCod4hiMtfMcV07kbSMWMmEpFVrkQN8ev", + "IiBidPU7mKViyovMDWC9maAKVaCz49knzgm1guUPl3H7ZQw75WNc7/EabjiPuzZi6bTJMFzhBsRooN3R", + "JpayEvZarb3fyLTqDLGF7Q3Z3yjicCGxJyb3gPb4K7p026Mqvxn5Wk792pd4jY4KVYkCDUpB4l6jVCgJ", + "vXKjwbJvRpOMJxeZtK72baGM4MmcQMRvqa6fwNh/OZNq5DKLFjRduPhd2J+RVKFqYZ+WUZ+YEYBFAK5p", + "2kVOvKwEH79JlR151lb5tp4we8ie18+H+Bc6NVQKnSR6poDgZCUkkltWKKg3VY2yq8EC5sehbGTq9TeB", + "WBrOp9fvbTygSoGp2gkRN1w7ourXlTOqfh0OCWSBtVMqv2w4JoJSPycsitV+UPB2XTmp6leVo6p+XT8r", + "+IU2fJ3D9HvXA9jdwSU3KPzBNr8sN/S7uMuVLz/ALH+sTdJHB5/gFr8MO3zi9+y72gaHb3+s7W/49kO5", + "veTKc5bZs7hy+irE/h9XtxaZSH1WH+LONkz5R79bJfDwzUtlX8dNDV++qKZvD8Mhy/oxbO5uYfV0OGXo", + "NEpGCKlZmvYU0VBvnyvpoIbIZiGNiGslEwMOmqCbVyRLFLWESTjWU0rm3PDECWOZLpyVqWD/4INfDgff", + "jn4mlUAifMjLqM+4LwH6zdNKRyLiBb9+I9TMzXtH3zwF46BzwsD8/1eE9+//dt859zalMLizIPgtJ7nT", + "EyUm+F279/a+PnyCgvVtxOr9XZ8/iIJxDRt9Oj6IPPOuli3VY0WKGcGNXMB0sDaYfwWLa5GQgK4LlxeO", + "YQFVmGylA6UFWfA89+Ud8f7ZIsbArDCJQJhav0ex9Ft7QZqB0OljFKaX7/gCxnReRaqV6C5TrYPt3K22", + "htVtr/24m6YbBOjR5Jun8PeWFNIrWT8qFI0HcdDUY1X+pSPbLvmS0FuO1y8nukHuhb3wWcZ21Dj5Xsxp", + "j4vCs0kiMw+ffXh18mb9YdXIpv+DX3LKaMEEsOKQt5ezXBgrLZwVewcyzz/xaYg+VufqLLo5TCTamW1o", + "76u1wXSenxxHbbC4ls5S8WWYHZP2XPnKE9pUv2ZOmEB4ITE3RlxjO7oVh+yknBwKCOcKS1zISxEMc4NZ", + "pic8w7KG1mpjj1iSaUsv4xCoaIPqgmXcgTZPZNm5IpcS8nxlrwtFJTpSkWTc+HKNhRWlPT8MwXLu5pWU", + "GucKfkag9bFrA3xneCIy1JgXmZODMA7oEi+5GZ8rYGu+yi+l04GhpfGW/kH8GZdudDaYZvqKWbHgysnE", + "DgkOk+pcVdxThI1lQAi2P0D7jE3DmqkMCDQckNsAFnK1LNXnSmlX2Z3xEM6BMkEbQa+fZ2wcfh/mRjsN", + "BDF0+hSpaW9/DEUYz5W4zrXfTl8/GVEQqBbOL5PcDtkbcY2VpfG0UbURRiEsOVeZVBdBb+FLxwRppnJ0", + "JBNwNN8ALMAqxMOIg8Nz9Tx0zPyoZUk0wzLBL4XXyiAET3xnL//+rHqy5yrhsEmVzky6IYMqsTKpOArJ", + "Ra6NC4siOfMZYli6VHwhk3M1pjZ7++Mhe3WdG7pOQ74a6EgvG1/umRdOL7gjc/SQvfeXlT1XOidO84z4", + "BhTBzI0G6wpTutQ1Q0c2NiLPhldGOrE3HA73x0ybc0XfioV0yM7plz5ON9HK6kx4iZL0a4leTNDtGpV4", + "C5HMuZJ2AdLXW6rASWUfS7mPTiPkOcRC9yiDhIR0qCYh54A/s7fyu/65Qnr2DKesQk/ptEKJgpSLhVZR", + "LNOXofgHfv/IErBz5RsM0O0Sx4oe/YEzBRHOY0uL1Ca8fIHKrxZ+fuYhilrtT4Drq7nHqptoofXrVJFV", + "r+qKqxojYpUjK5LaPL457K9p47GafUW6CSVUghKJvaTesP3fHA6rFfC/OjzcXPR+rSpsKrbfjbbIdr8a", + "Q2LR6i1IaB5X1nAptkmCnlCY9iIh5gPz8RFET55wopInjvKMaa/31sajN2K20qErxTlS916lDn9HKasi", + "763W5g/+aV0Uk+LasTLoo5xZqImrzbqmMr4ESFtZue0oD0D/8PBwAOsBTTVDJ2jDlwH6pJhOcTcnwl0J", + "oco9s41I3NVUtY66VQtVo8qzJYEfPk7ZQlgLmyKrMn/UWzRQe541PwR/PH75JDwBl2GTxDVPHN28g7nO", + "cPMQWYOwhNl9gz/ruYpTwMsDo4Iw8AjZNEkU6I0vi0VZ38g+g7euwrL1dEFy5RkkchaIoc0zmUgXKoDV", + "N9Er9zwVgQDWyurybFQKbZsV4QgtPomRdPzmkWI8giGiKvMHn6u9OCuUJRKdsUQbU+RkOERbTjnZA8Db", + "YjZ3vio5virP1dlKelKW8V8k+VYaZyO3RTgVScHPsbYDFTS1jicXDSoQ+BrLp3XGJJ96ralKt/A2FVHl", + "aSKtJY/cXgw/DFAi7RZmXH0I7vZmA/RTosGbBkUK9hdWyhdw26Vwxf4lCBHDTM8OpJrqg1RMihk2EMZU", + "Glxxow6IiktdLEJDTUBK2jPq1mg5Csnqtr4GsWHXx2BYdX+129rungpzKZOtWejIjyZFi4JMBL6kUCkh", + "rnOUFUHEOy7zhDLrdG69iZzswtoMytTqdl64VF+pfZZqFBuDAFhxi/x//+f/kkRWjoLj+qcTUWkWWMlg", + "Ji/FoMgB1ZWV9EJKdVfrHvkO3da417CbDwa+VgOfR6ZPkEyu7Vxu4GoDIOq+NivLKD1tXl1LR3wSEJas", + "zfGdRA/OKLcVKhUmw9u57rtmYi1dT9T4tkS6CN4pQJB0nbklaTeiYxzL59w/a2nmIXMDk4pE+b167tZ9", + "bHty/NK/BMky1URFCLkh9LrL0EM2RqIt8jFbCK5sMDjiwlO8lMkvW2JuVsPQHiJSxtlc8MzNl8FFgESY", + "IRv7zwEgZ7kRl1IXNlvGPrUR6sxrPOOXYtQ8oXASsVKrz8nnX0ehOCyesiOx1Rk4y2dMlQWT2xCFCidP", + "ZTX5RzhW0mNZDa/ZSvVTG0MnIi3RdsKVSvvQ6/f8ihqZWt7oenT8ci0HIm1BzBQdtemrewODsSJfrybd", + "uE3kPpZpBV1jbVdOyrOT45ctCV79Biq+aDaozwxfeI1KfRlhP73PVuIlVXDY0rlQE30Nf665Vo27FPGu", + "TqrvyWITL8Kb5r1e/CBb/WlBQnwjVXHtvb3Y+/dvBxcyy4QJFx+qJuMpSIXmJ1jy394OGV0dKbkGjA9S", + "cXlwsbCzcQh6ADzjqqQHBL3iehtujYVYaLOMJ6pV9bnlA3BjekpbTDxMEbM8E7+zRQ4bZUX6ia/kte1+", + "uJHbb2TcrJHWixGgxH3eyM3HsvuFDPNcuY/ri4j3cZPexTrDZRMF/jSv04JIZEr6vkCKQzZWWolwX3hN", + "/xq1PGPjhVgklXspmRld5KGl1+5xy+YSShsmeWGFG7MD7KfN0jtnUPTQux/fPj+gLwbgRQ/WVJllJX/W", + "yk/ZMp2lwf/t6+GhD4BPZUriB4wKC7TOFAllZh5rvcClHY1ZJtWKhwksFlNdLxK4XGie9EU5y0ZqXYjF", + "aGqEGF1M1jf6tRGC0ZGFLZGK/SC/Y94NqZoNBSbXZ6mgxPHRJXYM0I/eBUdkrwunfXhk2VuxGByrqWZp", + "sciH7Lm1Berv2VMch1yl5C9iyF4G/5yQfd2IJONygfoOTENuUfzizC5AO01OOf6NnnEzE3hqI6cdz0YX", + "EzQuMOsAR+H4acdpsVechkLJj825SdFoYbEevT9NOa2spH52nKol4cziAq0vH32uGsm9OrUGxgW/3Poo", + "3uF+Wvbh+VvColscx/3swjbRx1+GQfJphkE/tkgiL/Ri0QyN8XoG/Mq69hb8mj3+Gp1DbL9yV9SatfiT", + "W9t4pB+ExYcBs8LRZdM8K3/Me7bAeXOl1cBYS2E19BcKt/OFWMDHfTCJkFcuQMvnS4smKo81VfkQ0Lyw", + "KN01I1HzBjudjxy3F7YJT3NWChmovKNVDqxwA1ylH2qhqz7ChLGW9h5AUnDyirRUQ9XxGUyBnhhj5kOf", + "X6EyfQNS+gg3aPuC42uAO/Y1E8qRz7hmE12oNN5aiOyIrLvo4Gs3KMwTKZxfHxOMr9fV8s7I2UyY0TYC", + "8O0qb9EupEiXCVcpcLLxi5Mfj9g7EOXhP0AQR9HbqrxbGs49zLEzgUVEQ+Mez8A6DM2idrVSqM7P22km", + "1aW+IIG5lK2H7P3UBW8hNKpbNq7OZMz2KmA8EVUcnITZxywpCVcslWBmKB9MvlNC0/Q/w55eysTJxZC9", + "7UL/jfrv1YLl1b0jfhdZRFeRDBFqN2nseYz69ydCCa22URXeAmuyWfdzvw3f3EYJG++A7ky3fouuc6UO", + "nmZ0iP5Et59lJTZ1U7BstfQQRajOedTFEmbHyji1ePB+T2LIe6/fA086YXr93oQnFyDaqnTk24SncWxi", + "59yItPyMtR0bZcawjhCz+YIeF1LYFxiweaMoOV9ipAwEDYEsVjiH/kPwgAiRoa3PBp67ZL57lMDqWpZ+", + "Jc11lpI5Z1ZnlyIoTpguXKIXwg69iVWRmHOf88ikoCSQPJkfpMJh9vWo4AvenYBQFCwAQgKqcC6luArz", + "tDoT9zlJGiFYd/cyPeszsMv0ySV0H2e1bomL++iMzm4xPwLQOr3nM5BM/FvNRwEzPuNSWVeLkQZzB4xX", + "oA8YQSXjap+dZHx5ZbD8ft2XoM9sYoRQdq6d7bMkk/lEwwVM7mD9aqhzCVQvFlyloWzppVg5Rl8h1gnD", + "7xvDfqTcynGooBLdSzKZXNg+uxBLsBNZXKjOgI9/jHEL9zgx73GMt/pB9DcI9YyGlMNpdp94fYKpFyOx", + "hY2p5u2hIrkr9RMgBzHNL8SQ3yejyjJbDfv3Gsi1aP96Gaq9GMJfDdzvh+u2U6j+/pC9bY7Qf8b0dAq3", + "v3c3QhgUOYj7UlLMfZ6eMFKnMmETbsU3TwfBAwwYY66Nq9LtkH0vZ3NGEZxbZ497dY8z/67M2UBmkz5Y", + "9+eMY5TDQE8H/pWHiiecnrcOD4KWnbTuwGA/bhBRWma028X+oooTpNcOYmj1mqcR1u9yX2psk6uDtLXi", + "ZF5kSMHczaoFmZkVGd3I0IxO7IicsMjnRlqvn9rz9+bVXGciAt8vnTrLLwEZvMYJxvKDW/LeyZbVtlJY", + "lDid9k6LML/nZy++r5SMbpuN9Xm6uAqekHhabPzrx/E+LIczpQc6f1afHDkCU1R88Bv05rgz7cu4YdVR", + "afFPXna9lJxm12dLXbBFYR3OAqcQfILGsBDw+GRjPPxxs+9LJyRL8/pNvRuanVYFRNRzQQZPf5FGQx78", + "8FJcnmmdWS8RkbKnQYoMZVRH3lG1IUEB/QAHipgB5BeE9frwFIY1ZO/DOzyT1sWDrZyqEvvkP4csSFwK", + "swTDjNdH0UzAbp1kRcyDVaEjLyaHzBGqrAXrpwIdSNtpRIa1BX32rMDCC0X+YGmfScesXORZdP5Fk6Cv", + "CA3ZVSXicmp0jiDmcjYX1oVAd79tKDaNj1VeuGEqbQ7RTW914av7wuvSkGVxXiy4wlCwpDClnzzgFuZD", + "9aR1Gtny2GtmuWfVCbfkkxI9cQujgjddnZSBandX6CCK4jbSya97VnZC9Jug91nJKhv4acykcLrO4SpI", + "F874QiybcA9njOhXTR8Qbjkr3BHLQMK9EvBvmY6DZ951wvpiGDrrs/L502dBevDvsv0h+4nKdIz9jMb9", + "0l+iwiyB71jhQrnJI2SbaGUJPP4ZGEnJ8B6caWHh0yl5hIPAXIG35986MfC5j2/qflW+3e+zsa2gGOaH", + "CwIMmXgarn/kjhMBW05RCRqCjOPy/KGF4lo0Yb8qlmSCG2JNrvmUaTHjhVbSQUxkxGJMqFemZSBpYJ9s", + "966EAZx9Lox4hmVQMn1l677/qAJDJw5e3bL6bdpgE/bL65qNq1VTANWyqc3IhwDuCvKUupXwwHnHuF3B", + "vMJeJRTrtPFviJ1mQ90CnI5M4cZX37qEhXQUH6hetGKnfCHY2KPduIz8wcyDaslQ1xPb91meFbaueKkw", + "kfW3al3REK7VJleCNN8ZZVaFAzjiB8nwjyEZ1qhyN9J4rc0Vp1R0ehrPv8JnnaZZ+zCyWtKelQy6mHaj", + "gkVHjJiMv3FYoTIKYaQdwKAi4vBzYUQfBSdfh12FrpXxELSnZI+ihDh74LMdotVBVxavOg+EYu58cnf/", + "ndOEflVDSehWQTqQkKDhMwrmJJyrjEBoVkXugCpe0IziYhOha5ftTOnvz96c1NlwFxRZ67UbmkD3A1Qo", + "+e0LXO8G79EGJJPIPQERS3m7PGoGo9cx731Nwhiy7zmJ3li4ne2FSTq+tEwqjsXc92P00FbcujEl1q/Z", + "3fb42Pu/llkBEHbM6EvZRq+UDXwbt9EXFAVzN3E3wkh8xfAFhh8pp/1DKW49vlHAjrVa5ZztraQFDp/Q", + "driP7Jq2z6fVtk4DQFKHWTQbTgT7p5Zq/em0ZppZdKJiIt+KFBg8hXcmSnJ2iSSJC4jXAlluwjjNib03", + "pYcP51Rz/SzNQc3mwNXOqjm7fyfcqwlVu+HeSy8Ee3mu5S4AI2CwgCIGYXsxZO9VhRr9lQ6CczhzOBiP", + "tnSYF0Lkljmd8uUjyyZizi+lNkdMdsUG8kTzvKYPV4u8ANkNUXPc96b0pj53w8zZe3iOeaVJ3CpKCxc2", + "UcYJ4quIKAViz+hnnQtlyyRJU2msC6DqRD/ngI8lMJV61gYgotyZyWm0hEplHVeJ8J72CaoiAEyopcKj", + "bwGO4IUYHEbaGD5Ns3t6+G0TLdyQ0V8Z2GwsBNmMTD5I1pbC3qlwDNEWvgLUCRuvlV/5pfAaJE/SpWjR", + "wOvhJQ1+LRhVPhHMRvAYqh83r9z8kDUw7F444b2nh9/ud78tQnRheI+IVyF4cheJzSeLRKeEic8AGrzB", + "y0sM9TzeB9B6z0kKZ/A5vtbO0wdrNoZytURKxNFGBHrBkaqDw/xBaRnxHp8HIEgqwOwDn374IJUWMw+D", + "uuFZLHLhAcqQqsEHcoJ8xJ30tbQrJv2VmaCjQRVSo4XeOpFvCFku9xIaEjaUm1eGLeh8FPafkucYV/0C", + "/xTkXQpb3e/FTbCU8gbWHxrKYjGaZnxm6Xxgi7b7MIc1hyNscqt4AeZI1Ct2zZmyossonGuq1osgGf1K", + "bkmkKkLeUdmnTExdr99DEzBMFTO9ep8LcvUG+a/xnNCS2pK46cz7f2Abb52ujAqWV0ye1vNgGgeA6OHR", + "hVg2qbB1Slmn4GdYH7QNOlm8IxBqRU/aEgdZOrGpYjHCXraWUeDxKqW/wzTAyNLlQnjCyoX3wQnjrnv1", + "XK+v4j9ZotFcyctClbRjuaZIw0ZIy3VI/3UTSCvoet0D0C1IStb/m4XKhlDUFfWPv8VL1wJoF7J0bE88", + "3xZ/+sK7OjwvXQxu4GoWHCY87lZzEnHLcm7wbc2J1XtFJ0wluIqTZsaz+HNVQsmpbGNMd4Fh3ugGgM99", + "6g2bgGoOaOD75tzwhfC53V55ZYxW8XfqWcvCBhOKOl6fTLE5SgZJeQE8Y9vDd51hQdiM4bNu3V8aPlvt", + "vdCXolvvt/pSrPZG33ZgE9s6n0DDH8Sy0pdcP7Z1PMVW1W7CjcjYs7WrcC+wYbV3JsRW/cIpNPIoXImn", + "WY/mCp52axhWu4cr51vbb4I8QmKqbmXcmtrZ1lYeFvJzS8axUSD7TcuEewJi8OP2NIWdN1K5EdyJl9Kg", + "CWF5s8tz0Zg0LEoaaYDOoCHb0wnGMeAq+wwD/v709df7ddn4T19/jUJcJdXi4eBPP//6Vf/px39rrtjm", + "5g2R8ROrM+A25SSgIYyQ4NJXBjkY/vt2910YqXEzC+v04icxefvi5KWYYjS9VjtuJj3CK1NK3AiyTP7s", + "U03+/OuTr5p34EKq1b57YOD6/yVpvt/YA7ncVk5VWRXm5A/vfZvzpFmgdlpv5QYEEEzxoeDB2kZHl1oa", + "ya8wTNsPs+0g3oY17nAGhclGfhfxc7v0s5DK+/M/bjAGVxdTg7lt0rAtNqSK3XHysCv1WXc93QrOftyy", + "GhqkaRkvRSacOOFufjNmsoWOA/WmOMxdUi9NPFaGuNnsm1Rox2vllcoKOVETElbUJ7nIWlIwHsSmB/j0", + "GrLnWT7nqlgIIxOmDZsv87lQQ/bTXERdT79mul8fTVo/WrrKY/ngl+eDvx8Ovh38/D/+rZum7iU98Tpq", + "5urbNUdfgnahNjyfqV1Zz7yldDvm5RkZ7sR2kL41g9YA+PtfIFIBk80p0M7JKVrRU+FEgsFC+42DXsnU", + "zbePhs02zr9xa1elvPt51IJo0vKgjQ9Zetk2xnqDJ1HtrbeWPO4lNFlNuBXTe/mJwGM2aP+o/oPTDGQs", + "xiEPgY+BcFirOOaSO2w6k40JwXzNMwyzLKvXrM4tqB2Bco2gHYK5LGKOBbvQ2s3/Qjo89LGBPtGxAl61", + "sIYJt2il8AMi+8owl3QtQ97jw8NajryvGxd2m5c8LGGnh3wzIw7Jj9GDTU/ZP677bPlz9dmcc2lsPDs3", + "N7qYzb3yGCYxw5i+t/Cc8u8zxh3opa1jT1iupQ/qiDNdnXI1YDaG0z2p3sVP1lez8Uc6yxoOw7k2OMOT", + "m9oA9fHfiV9gw5MCq9IEbMYTvuJLWgiqWwXHzOmZVIJ7b/pcZ97Yh3wbR0NFnB3l6AczQ0wjchD5CIls", + "tKA0nnKmUNnekmas0ry2pK93pMtYdR3ntXaCxzSLdWrYSp9r66xrig7bVUVxSohbNK8cDUy0Xz6UGdlE", + "+wTZW5oee1yb6/a8lK2yQ1R1d1U6rwDepNp8RfqSMsTkzrJCr0StdEwGDW9NSgZ9UMkLDW0rsEmVg1+i", + "iQGjXeD3R/AiedRnj3wG5kekwXnkraiP2CU3Eq01pJ5Z5Jk4Yuc9fsWlQ3+94Uw7vfdo7lxujw4OBLUZ", + "JnrxaP+ZT2/LKs2xqOPe/rPzXnNqQprxdh1EuVuvfA9Mn/4FZlFtwKhb5VJtjX5aw6i7zacZJr2uzSFT", + "eEx17CNNcXJ7VMF0v/cx5v1ryslIYdI43zJCtrqwBnsLZhNsB+YD4DpCu/Mcj/2e45PuSH7GJ615IZuR", + "ypt9fswh7OltkTmZc3LCXPWs9y1tU3YyEivKNsA0CgRJ1k/wduFOVAWELpHJrynbCvwIENHy7k/Bj+Td", + "yQ/meiEOKCi5NOjZg/Pi8PCrBPrjX2Ll4fR88HfSzwxHg59/fdx/8vXXzVqaX2Q+QrvX2hT/LnPGTTIP", + "+em5VN6zr1A5h1o2ZQbXctZ7nj+wrw8hN/UzUlSH/CjgUz8V1g3/abXaryYdmkjFzXLrczlO1/t4NB19", + "RQo73EUlUkGEJrCvZSYgX8j6EUs7SqXZTBsoh6H/Y1T9NQtMC51ifaIGZASRdIGCtU9ZAO1qqZtSSM+L", + "vZvUa433JyyLNKET6XwKzj4776Xm6toM4P/nPXjYn/cG5mpgBvD/897+Lm433IpaljU4QPLmXN+JzhrU", + "8PZa6wch9KPJ0okGej714fX485AdsmllGlLYDpH1IUsCx/dpZbB+wIPKGfpNb0MnSqHQktTtdVmimBxh", + "ytj63dGPo7OeSLvj4U3PMg5100PdDUuaTSg+5xmUbqgoEV58ePX87FWv3/vpwzH+9+WrN6/wjw+v3j1/", + "+6pzvtxWwfsHKFW05jHcfL4vm+v1RP+90D3434jgX0XSA/nzUCL0Mr0Ojwm6eMYcv9ZKLzD2yoMJXjwl", + "dO/KQz5cY/JLBGcMbRZ42WkVzxplYZjKRECxjj2yhtKUyEzqXbzH7fsw7jMjZtyk6J6Mjsya5cUkk5h4", + "EYpNvEBntkH5pd8A9PR+f3rGDuLsD/xPIWtgTNEW/CGxFhemVbNCsPHKXKJe5Uoaweyc5wLLG8o0FhH2", + "nnU+9041FF/auMEhsREMD6rQRzbknA/eM+dqS8GlWEF6s2dyra56P+SWGCVzmKaaiVEQQzeHjlG3F6EX", + "yc6rQDGdxE4AT6HHJmDep2sHaKfUI4Ir4xg7h8fV+2IgWJe+2LDaF46va/eXsW2EQNFevkDpFgDUtlLc", + "uOyf6Vm33m/0LPStRJSRM8wWCMdle3QMaIKDpvmuUH4QyyYYZI0eWeFcJtLu4Mh0f0rdAmBwTBxBvHzH", + "Q34jL8XfpLhaOekSTOfzDpDWD90HyVVAbV3mW+rystJjFZpUMlak7ATsWElfbnEVVCy9sBO8D6HXFqA7", + "w1uHVc2+0AVUGZAbIIWipTLNtlW080UJj9NMrPYG7i/VrNs2eThvqE99kwJAE9RmXSB5bdk6jGCS7QaE", + "WgcooI6KydQ3Q4CQ51rOf9871YuRd+3CHeoE6KVeeI+zN9ilBpGyk3RkCQDtDXZY4QU1UJDopDsgaF0H", + "k+Rdeid5vZfmnWaveX3SZb6WDr3fxcYtMHbYxxJW0146PhnpXKhOoM745D22jSB8xPKoo5Rz4tuvSDvV", + "Ct87VU2v5Bbrhu9NZS76a+mOd80kfVe1Llcv+I/9XbpVtqVjxyYmtGvXKuvZrW8DF90NQMnOO/ZbxZ6u", + "3RoocoeuzWxxBwAlL9mh0wqt7tCzRhy7THOVz+7SN8l377N+QdzoQG8CoVmQ3r1zlJ9379ogK3cE0iJR", + "7dZ7XY7drf8HcTfdb8A+WoTnjr1rd1dXhGu697py95X37i7dKm+W7t1WXzsdezY+u3bse8OhW/UKN+hf", + "1XLs1r1R69IRRKNMcdNSU1TrGkxcqGpuUMsaLIM4bVDySkU2B8zBSImqh13zF0VDSoOXT5Rp1ifDMj1b", + "zRHM8zzzxpCNMXYrhhQ9i9ZdMPo3K5ZDwYwGk65ckLGunFG1OGZXi0yL00V16CYd81sO8tTncgtdcEhU", + "dGdOoQBOGNQap5V8BK2+ojs6iLaZMd5VLBg0hT4VsOSkyH178hSMLrkThqHDhvd8eIOucmBYJMti+Px4", + "2+G2GitXTrOT40MXA3N1hbSLIvVLbUR3PZ1a4RpdFE8gxMj6yrLYrL51JTlWjovKda74cvXZQnCLYcrV", + "lLbYmFxPMDOoucAP5LTDCzfXRjpytPLjB327PyICEIKdIXJUKixe3amuTbOBr9yQxmPThRUnPgiv6hlf", + "P5uu0YEh9ubmUYFtEDpHA64FYe2GhXfo5IpRSbd0b00lhZXXPJa+vm+nVpjzTk6tt/f09Abd0q1TYkC9", + "W9nFZhvvNvQsvWYDhjGnb4SmXSHthK43j+pIhXWjbSFalSwGwdlgW3BHv2dNsg0wpYHpDHNlS+IA/coq", + "mnbIaz9ezYyw9oTKLe3mUvfT3Ic//+0tu1CYqG+iC4dZuvx9DPkkcABGOQeG7J2mPvQZ2ops2vdJETBL", + "x1Rj+RRduGoRujXxbSozJ8zmlGpifR6SKi0amfiC+1xhlY+rTFpX82/2KzNiWlhhy/RrmHvgShdZSmUk", + "q5hgYzrPmSaqJ39yX/3hekm9/SIxs832+sZxpU3H+P6ic+BVfZf+KhTKX+9/iAXQ1zdZX2xlPscqBRFb", + "2ODR12FF+qJxLScQ/OYDdG5GuG0ROi/bI3Miv3/y9HD3OJ2XrfE5Q3Y8LYXZwgpbzTtblkilLuFyMwK5", + "gBdlvWfKN4f9rw77T77uPz78uXmKuLXehLXtvKYevwmxfYoQcHzCmzTWWwDBvJTcMfsPOjJQAq/mC8OI", + "lYwbR7+2j45NSx9BqvRZrj94NTnNhLIFFW/lKc8p4laJq1BlrXRBRpzAvZwLnk6LDAu4lN9kLejZGhj1", + "sjUgKqLNV08Ou4VHrXtk75ymAGTPtOrAHL3B14Op7LKdM1JGKOSFvuyt9/upwFvfIwpBTkccCaybU2HG", + "rRsVNvZam4/ykpHF1xymhoCprcwnZPvp7MwYXj03dJFHgXTU9A7GpKGoGcA2rKzuE+b6yEK5rn4t1ZNW", + "jbMsTNYejPfjhzdtoJFSKT2UzsX2Ek7+zYJIUTvHlQP6uRPavpEL6bqlS1p1pSYAttkNPrzq46GHZBmE", + "9mXvjoqk9Zk3ydg7R730K+voumE7X2S1rbqz1a55NO+2jncbVQm8iTGRu14ltRrm94QDBdYTIqDwy9AF", + "c7+eq5CDLctCRUxg+diTEBilJ/bIY80j/MnWuQYKW6ZQFuHYcxWkM46tfVKUJr94cov/piV7Qz3uYMfk", + "6FTOz4cWoWaQ6vc5XRbshumuVsnDrSD/klDOfCJ9Ol2A2JjihUh9a9ph4Lho5gvVBofsNRJgdS+lZXOe", + "Y6Y8eJ47yypnxFV6rugOh19CtXRcKqwxybQVKSVTxxOogJauAthn+K4mqzxXc54ypXGOFCbVmOfthozb", + "8clWDloCjvyzmWhW0s3cTEuyJT7Zt4oqBqpLt7QUlLyiN6nKoSDTHfapLTew8jwnhfTmEMgNSo+YN2Wx", + "TfsBifxzfINZ2ByvfemuDGkeP4TgAHS7XEx0hoPjQD4fKwzB7BxfbBPBeKVtpVzFZMmuU+20zs7VnhWC", + "/efjx7iW5QJuJp9qAmqV+jg/G8NWznsfMHbrvAeREWi6pj9fOJPRX88z/9Xrr897w3OKOSH2Jy2FJyc4", + "QZ5ZDbNM9GISHpU+7QzB+x8uBFzgJxztf5zxCYL90dK8iRcCO8kLlbgiatTqYEMlHg9rIVVha9AhqzoC", + "fs4y6QR4jZOyHl8CMFWeJALrCGBedsYzyamosYcwOO8xTPFvFqhyRT5XH2+ltsUWRFghTMSKZkrUibAW", + "7i6fpnFHYgzxpBsvXRrkzBfRR2Uvt5SRZKPK81UMGWzTdzZXiRTX0o2aI11PQp3Ma0mRjcOWqs3tqSUp", + "5m+0oRz9e2zhcdXn7MQQvjLDqC9Gz9m/Cu14PyboFMZogyVSeKiXC4pIYBN0h+UyF4HFe9V/arhULIWn", + "m1SiLYQ8FcaMJt88bY5HqZTLoqZsUkCx1GF7WGRXYHCRtQJrim/dnBaygrJ3FjXNYzEdu1TwLle6sFlD", + "7SpuZvUA/H801EYkSNzMioVYTXywlYFzOzJa18Pnm5dRqHotXpD/oCvLjbyUmZiJlmc8t/CWaQh2WgXJ", + "fQpkaA2gIIkKaGOCzmRtMTGqoJmSQwUCOxdZLDMB52AK1YhoyVWTVKbNBdBCaUjf49XYp30P0UeT0CBS", + "NS1guypaqMt29Go4znhmv35cPbBX6lIarRaU19tHxMNcMZ2vNtWtH/YaMH8tJn2nMPQ+jgE/UwqKnF+p", + "IXsHeXG0Yb8Io8ukymQ+9vwEEg8nIqPkFsCoclvDEqg/mz9jVKq0LPONQU5Yir8wl/KybkX69smTr776", + "05PDr76pS1UtGNYeDk/4tpVP3CoWnle5QsSouNFD5vm99I+UanR6LAkQdstHjCPbbyhG8Bu9Dx/uvLu9", + "89qwFVySbnarnWK9LmInKvqAVNhJHc+ovFftlumdvfrwtrcZbjUS1Df/4fjNm16/d/zurNfvff/jyfYA", + "UD/2BqL9gLr2m17v0BcULWf/NZhQjH3rNiQ+r96KskZcMUfSKlxTWbFQdltamX4PnuFbYEGTHfPTINQ+", + "TXTDjp0CO69uWKdCpQ2yFLjCrcg8VN5fjJxbbhdLnvvWQLZWFKkexNXvnZz91/7qTUemC5QMYlTbpSAR", + "oUV+aT40cDGVgKkrB+cL9FQWgZ4vq1mNdjjStZGg2c2HWWcHP6+d6w3ur+OKdyGZnDld+pvoobE4//vT", + "eFi1UiGVjfK/N+qUwGtSmAG3QPci9cVQUAvSIPVEy0VRyLSZEaORo9FUchac/krtWJi577aDX2ErqTnu", + "CrtrRbdKQa7CklTRzpXyYpQnDet7ZZ1cYKj7i5MfWYHOl7kwiVAO9H3lMhSm19py978Kd35Qnoa9AmMM", + "9KPt2iaTwXNt0ZYsopyxERZPnvlSxjT7mEfihmLHqV7EMvRX3FdJDEXhWqSCRhv1SYknrpbwwBv/erSV", + "ojnhvyt1GyNDyo0bK0U2ol4q1c2uxZfcceC1V0aSK9EKcVA+I4lFXdelUu54J9EnrY6y/bkf4f68dc23", + "kuBhOj77pAVw6yv0fo9taFymq8MGwU1y2DHpZ1yKEbxMVbKLdHf6KqRPYEbkRlihcEUrzwpt1srX3/Y0", + "o2NqiSxY+bjxtdzsdv6mPqW1nCJAWI1k1Yl5RVZPwCVoaqHjea+FqaBTapOSnv8LM4zZYhEd7MhYg1oQ", + "3A1fK/k5aHXR7uSdneGAZNrJVfa+2BqcShMkdJSjn4MxB5eSzAt1US8MA++WXng4fU5Gt9766Nc4zyBs", + "eH1IL25oJhfSx7higwQVFyItW1Dca9PCTihTChLn7fSKE50uvVUBQYZSnoSdyrPe1eQxDVKAr87Zlpmn", + "LAMbzUuod0wvpdVmeeQrSYPTYRjd1+Egnz+D5YFRKlspc1pzF8+WCJYSlNpKrdIhO0ZqQ2skOv7DgIWi", + "ARNMQo6kbtEXg3yTpGXhAiCLRqUektWUk4x8Ln3UdD3bBeXwcEZnlYho+tLXpo4hxj0s1BDyHsQkKmVa", + "hEY0AMpokCvreYQCKx5CD/JE7VgUE0+OSLJL4qWKrLz9Mm0tCEGhEcI0J14Do52ddxOoy9iE0KtNnN6q", + "KqaXwvrXNgZyVH6vi2/G7TrbLY5RWybbVMKgOs+mPS8DPj+I2e4VI9pcNL/H78uYlJnXAW5Iod7itPcT", + "fL0ToI5xGAQLnLB0PsjEFG5po8StIjN2gNno/B52oR82dtuR3cQvwcSD3lIxp44Yjddgva7Orn75meOj", + "683uEd9rI3/RCqu24FiML3QBog0F5FwK/71l6MLTZ0rMeO17OIdmCYtmsCWB/N9gxkmH8cFfo2H4Im8e", + "/DaxJ7GyT3d73Taq4M677Zflh+pD7U4UO4PsHBCyVpNpR64l01SoLfltEX7F08R32uoO79u1TBviYU+E", + "WUiMZLA3mz9asppVuPiTT9po2F9bSuZ2yw7aUCzpm6dP93erjaSvlDDNc8Wf0Ggb5vtjy3y7ZJKkpIZ5", + "ubfkFEX+N7647A1LtmzI7Fkt8rWbGH7CCyuq2aZRCra5SID202g629H2VvUnw+peTaa3al7vw8PNDmOr", + "qpDK4I0b4rhxr+1PEP1xl1V4Yp0wVNsA9GFzZm4gXHkptlsAIrV7eCz2zZYdwl5aY7FwB24ZtD01fCGa", + "g1Q+lLJtaARHPM2BYi+FMTIVNjyb/A7sV8/8yeE2c0Kjcj283dbU4vhUWgnd9hHWTgcHTVlJPq5x28tI", + "ciZU6ktW7Fmn874PPIcLFZ4vfV8xaJ/ejRDfBb0WmOYbCz2qUE86wrR3Vq2oopDfKRh9wa8DLR6rU6K9", + "dneIcuiqyTxEy24+2I1nueDXmH1Y/iKO1dvv2meAeR+sz5n89ruOyLRaPOZxS9gVrO55kUq9nS5f+Erd", + "HJpTAR6MHbyUqdBD9oFo0Fa1AyAicajWo3wvH3YJ+HJSZFY8998mF8JVvR32AAim1WVWOPCLcPNKxfV9", + "jy2+RnYt6l1amtEAq153LFR96nR+W9agTSIAzvadPF4sRCq5A90IEFYZz2h4IqZFxuy8cEBmPqnwAoPf", + "UBuNhdwTbUyBDqG4VMSRZrXeLbJMEMl/mtJjMFZ+J6XHyuzC6lJkOhc3iBwQviuLNkd0O6kWU2ArmZHX", + "pYGoy95YpLOenxoLoP6r1bg0WGilnVYyid7djCx15Ux5YrS1sT4+OnHpaYUohwz8l9HbD5LZD3DkwfFL", + "H6NYLERUSHulr78gpKVKTKR3W1NT7+CTAGsMyv6fN55hWxqalcTclKXiShoxyMSlyOhbSiZdOk97pyp/", + "cvF2Q24UEntrtbL6IXtuJtIZbkJ+bS95W+znk3WXqamBQaYEjMI7Qi7x7RnE+02pv3HGwgxgaEZow1Kd", + "oGuoSENsz9jrB//d59Q+WPnmJcKteNj32Xri8MbYlq5K5C9FFVue5n+cvn8XNbFNR5VJ67d4cy51PCKC", + "s3Z09RLUTYdCZwp7f1tl8AZzkHAB4fzNHI1eZKPDAtdgKIpAMFJK+twwIH2gcaT5knENAtSPSl6zmESJ", + "HjvAmlZqGpUb5SVF6MKuKrdHR5vYp1GFx7M/DV4AN/DhKJlXkHhaHpSYWastqpdn2SDJdHIRk/Z4pU5l", + "M2vw8Xw9SMrf4kIltHJG0oYc/l4U617aJInVPjvgbtxIXyMU6NWgDDAi6msK2V0UvtSbKs3p6CRZ1ifg", + "Mf8/W0gUWyYiwRc9vHTAbXwi5tKHvJICxRaLRXlxhu7E3usbSOoKeMIwIy0QdAI6R7YQ3JvA/I0JnrzC", + "m9cxHRmbckuGYB5iiqmBETx9hhUjBE+p6DxBU9qh5Q98aSZCKJZpi/LWFV9i5J/1lSTw6vAJM4zItXFM", + "umeMT0ID7ttAp5S7oKtEmq/kBFHalWGi3KJH93DjRd9cyO9m8osXUTJu3ZpoxV5qQfODVbvKSTWcza4z", + "XvMIB6A9WkcjB1gpq76zbv12hVFB8+yMvhC2sZhho89g8zndKOtRiDso5xGyPlWyH8F9co2O/BmHqhs1", + "Vm8KwfYCji1CvquDNJS13R8yuK3g9gl5Js6VjxkERg5jUaiyYjroPirj1XaK7eF3fzmEffFJmfaH56qa", + "gEZcIznCDuFdf6VNOrAYRIceDj4yJq5cKmf4AFrRgPZcAadQnOq9oIRDP+fAdyzJpjQ3umdhLhuOri3q", + "1tf8X7UsX+NmQfsgvM41Bjou8sIJ08Sp3TLXUK5EJWIzLp4IM0jmHCQ2YWAMzaT6J0lnmFLlGXBZxy8E", + "Sb4o7aBQiXsG3tNYp71EAnY4ZO/B4E8XkW3aAbZnZSaUy5a1fTpXZTPEjX3aqqjzOBw+bsT64My4esnD", + "hjaR+E9i8rxwc/W91hdb6bvdUhHAUED0XOuLiIVZRrgGwfZBmG9wtCK/5rTJkL2yltCyZTlvX5xQUXco", + "In8aZcyds1VW3uaJG8Hz/Od/UCj/z78++epja/JHRILtyR9Wivu3L+ZYXWrKOHq7qNPwYtGFS/RCjLzz", + "SeNzQsYxRy2+B52TXHSIUlxd542yUgpjtBkFxnGDFZHXU5Nw70xhqZTZTAxyo0EPFcpZhupRluoOOiM4", + "KppBlaSdUE5y0KBAqHKC6Qu816h3ri0aZD+s3QqlP2wx8XYkLydxprQa8MJp/MmxVCQZNyQnomkT08Lq", + "HGRHEAcLh6IEtfbvi/LlCjHn5OlRcf7Cfez1m2axPVqlvstxiZsP/eKGGSBxJ9v7NN3wwBLoBPr0xqO3", + "32OoHOndF/GlbIWREFwe3yrb4wsrNW9LxfR2Mwdc9SN8Qvxazff6+Mmfd8v3GuH0/b607zlswo5b3e2p", + "XoKvPNT9YN36vRWOoypjZWdanE+nwqBcDTYgQL0LkvcleOTzxFHqMSNm0jr/7AQ3vIkA/geUeAmV10Lu", + "IxtvJ1ZRjwRHXjQwYdXUtMOTujwM+LMXdR2bD+W5UtrhPHeNmIDeJWeaiDm/lBpzK6BFK1q9/vH2xQmD", + "KQUbLxHrz3uhmjTYmDNfmjo32ulEZ0OpD2rND54cPvl68Pjx4MnXB6RiOQCY9r/Dv/skIuJotDS2sraK", + "aq4c+EpMFjyZSyUywQ0EEQxn0s2LCYwOPyb5wX9PZeJSMR3AOLwECLLR2VxY4ZfLjWBF5NoUX07l+mIu", + "yMnSayOb9IAlg212q0u0oicdMPfvpWpplgoqjSgvRXsjmYoFXRTtbXQu1E/aZGl7E3hag6jZ3iJuiK/5", + "0dby40YUfW18xqZd7ciN0U5vwxMZ70ipEiM4qhqa7LtiMRGYshvhVT2RggZohWa3h6xtzJZGw0DOtJhq", + "amo41dmvqOs2c4K4dhpsM/1H7rc78bOF78umGmzTtiR3/LmJ5O6F1j8gtxVGpK3j7kTqJsLDAYfniuSu", + "U7IOYL668DDWhp4fMKfgUg1zbaTxOq/tdj1VGfRqyoJGmTNOdJuYsoYVId1gi5h6Q6iYWn67zO6z+1XX", + "V1/NZjy+0aOLDqzbWay97z72idK6R/OusrSPa7lJXtX5jdc5BmxEpAfswlh8cIouzQzkeAumOUTHSicy", + "KtRdqD+GimfhbFoU6fBzTDBWG6HFXW0mRl3TQa7MeBeGh2X1b8ndKX/dXXD0Lenaykxt5OlW4RKPrD+o", + "4LrGJ8/CsiNrKWUsYixN23ElVaqvbr0jYekE7g42Z4XGy2nGE6whYgWDAnFtpnrbOW10nfBxJzsnpSzH", + "25rIiwA3TtpIJ15kMp9obtKbvT43qyhrkaOhqHoYcPv7oVlb9xHvFIpL8dyi523qx2QYeX5y3Ov3LoWx", + "NJ3D4ePhYRAheS57R72vhofDr3xJcVzIgcejg8w/3eHLWVPQ3we0uHh/C9+Ylc5LaM+IDgghUfn45Mcz", + "tjaGtyRr5T2afNJg3wwNQWidMAtwqYELnWw3nl/5do8sK1HEe18loNXKRDojdsvG3go4JheGsv0YXwUg", + "OJfvo5V5YNo5HjJLU7bDQmGOdlSPh+kqAWZm47cnjkhyByANeeClmCTdhdpSYbvh7Ily8DyeHB72UG2H", + "Yno0jVLjg3/6+D4bBYAuZaz8UD4aHxGp+U4IK4rHSxHgH/u9rw8f39m0KNVvwzTOGnAhQVEtJO8OExsi", + "0YA5k5sl7esKZqwsod+7HkTT76B09SjdMeDSbFIAPvfae16C9IS9OtXg2uYRBn6S5HJjMJ2jpRTOVfbu", + "sdwy6frYX4YMFFMM4AguBGeRzC6E8EmlIq3FeXlrYUyB7idij0oshhn5QAgbDRM1isZKOSEhrNcSovEY", + "FgLpYm3IgRAWkWph1SMXFgN0d67OVcUTw3u/sDzjSgRDbA58yjq7UlchTORZvKCF8QyViiRkgvvKHu6K", + "EnHNjAALcxPBnTYTHLL873S6vC9a+65QaSYIyUve7gW+z0/wTZTm+VYNG1BT/fTwsG3guJKD73i4ST15", + "Q79vPw3PmAklgscyINBVcD+okYkG1NOGiX8VPOaATiU6VSgXl4xtMDl0lREG7R8pI7QSgUKAwr2jCfHJ", + "w0+z5kh8Mq3SXu3wQN1pHV/auAl9z46sIC+t6AUxQXxlRmBtPXyp/Aa5PnvnXUWueLmm1bvgtPUu6HIL", + "fOz3DkK5iYNpxmchICRpiAh5K8xMoGkTWxJSiWtpHdVAELbPijzlTrAVoA0FKy4lZ7bIoXCi1Sbtk3YF", + "7DCsUE5muKjY+qW4RLGbnffQeQ+277yHJQIzqQSqRiaosonZvekWgpmFyioNDBNrpoRRXuP6b84wVzSB", + "YTdXhI+wJNpDp9kCt3UPwr367B/nvcHgQmp7QQmPBwOfe3Ewy4vz3s/7N8/1SxNqlrQ7Me2V4DWcP503", + "KZ5Xb2KR1jyrb8Ncv+7SD+vyKp4F2quSyY+El3GKGS9UMveH4LkEzHlnosFKTFJsp5vCClM+qeNEBEw6", + "N9LGok5lGEjMCTHh8ech4F3/XG0lKLY7PZ2rXQnqhTAOBKiwC2zBFZ+RzeHCe0CrqeFkHCiMx3P26toJ", + "ZX3dZ/C57p8rrPA0MILMuQEirSPCD4iKqoMXL08OQpU6rfbxjTMBz0mRnit854S93Er7J+EYb07+3S2z", + "XQ5/yH4Ieeb9T+g/ca72fDZz73fzQusLKazfx/MexWxd8qzwrjuVcmH07RCEVcGChhoxWZQzGc60nmUi", + "IvYBqY9iwaXwPW2poGzusP7vuJUJOMa8vxTme+fyV8HLhfagccKovYHG9sd8ZngqbOzlNRFv+fWL6Dlu", + "T3wBeagc1O+d6LzILWQWvBLpa21+NJnFkGC/Nj+7YaIXvZ8/3hXnC7jyxTK/VbST4nY8sMjBRX4gAlET", + "M9S2ycEEm6JIqQ1baCNY7MZ+kTnjJpnLSz8hce0MT1DAWbBCpVDM4mCuF+KAmMtBOeTBeXF4+FUCRIJ/", + "QSVLjIs3S1aonNJ9ls0pngPslXiCshK4BSR4rkCD2vDEDXuIz7oMqUsaEOjQV9tfJ0aE555nVNMCeR9C", + "QbZJPIXRzvjJhAeJLmWqHBVdIdUUjKRA56Zi2XwqM4aBDufqVbk6r8BH1G7gMtbJLGsoIhZuDJhzuCLg", + "quGpVMLanUQrOulyThs5K4WWcuMOAL0GwTDYUdYOY9CQbwOsbgT+uCmFWNxIQu1gWQ/48pmpGUmoOqEa", + "PTVg++0pesBVOgj84fbU3W8gbdaVsvvnygoXia4cgchPqhs8PyLun6tP+PxYpZHnKv0QefAXTC39huuQ", + "tjjuJPoY8XT5WyClLdTD9iBqQuZ2v3pLxiV2Ji7vuH0wCc+EZiJ6FWpPKIbZuURKFW70NPp+M4q0sxQ0", + "DFa1TIA9JFS+8r/6iwimABJx6ceTLf31FVOpKyauk6yAZAwMJGi0BijtUwegOZxF3LUs4Yoc4lE9iXdP", + "SKtBdQC8sYRKXKGbZaxHF46GyVj7lFSktChfpAvdnCTiSWExdBoupWTOJRJVKijhIFyUZdAJ5s+l2sww", + "2oVYog0qbFdZwSznS4DiwxiZ0YVKB87InMHrQyWUpw/r08IsL2UKWjQC00TI3+Fbwp/O8+Q+Na/rI8UM", + "3TeUZxFkKHnyGxJbIyEwpJhGAqjidDshhnjUOh0mmUwuRoguVWqsn+wLaIQBLPd0oOUAtz3Ht4T4REWR", + "7j/rEZ5KDO2DMySyxD0Pc2wJa9n1EMnQfADXSfs5fhA8fVExSt+bVSIO4oX8RgtkaMP8kGSaXaW8W28/", + "LJoCoaLVt8E+f8P9RitV+4bX/Q7uiXianRtuSkDo0OAzODOny0367fDEn8jXIgSH3cWBYt619nOMqd/u", + "6QjXUst9YitipQR8s6+A1YZdSisnMpNuGZU+vxmU+F6mvniWvqpk0tsVDyBQc/0yXA33xepfKqUEiYGp", + "Twrn0JTovVOzZalG4DAv4yhOEh1hFEaHUp4hnO9MXmIFHzf38nUmuBXk505fS3RI8ELwP677bPlzNe9h", + "zqVpfF+9DMGn94S7Ef5tOQ8A+o1c2TgVqipe2HBMnPm8fDuhFHgnIpRRjrk7taqi1pqvEO7kSWh5jyRf", + "G2gL9aO1nLYiLuIutjn48CS1IYh040h3IiEBtW2Tct+GeO17IpQI/25kXL9NsLLPSyywrgqx+HmFmzmm", + "lix5lb2TI8X6vJDLdgurFnZlIhg7P6Xa1DGWICa+JJNTmYG1UhX4XDXV+vV1rnEdRsyFIv3BelHhPrNC", + "nCs3pwK764WBGXelRWom3XBqhEiFvXA6H2ozO7iGfzBy4+D68WP6I8+4VAcELBXT4ZyuDJ8JZ66VNraa", + "bcG7fYf1WlZYn9Yx8VuBCTyt10fSMem00XjoK1XfE72sFsK+KbnggSK2/JYkFlxdTeuGeHkXlFFJJ9XK", + "7M74hSizbd+XWLuWNPyjP8SNlxq6PR7klOS+HClmPpmgRavBqXrt7ionQL6Un/XEY4pJVh5Q8G++7Xnr", + "LGtng5QvnV36nOJUs+JAA3cIec7hO1cRRCvMui7S1jSmtYLtXlatJSwn9atUYCWAoZmTyYVle0o7n0zf", + "p1ctUSwGs2JeyEtuls+YK1DfucAEKNUSGZjqBNNnlksh279fK8Ns6zSN4HfSr5X4KB1iFzVFGtuLMFBe", + "LwfwQXCoj6McHyEnX2CmY381eE3PYGBELrhj79hgQLlSDhkZdOjVgH+LRvfx05C2/J7os5JI/6b81aPX", + "b0TZRpMpxRE6Hu4Yv1uJMqRka2GvPpHSPR3cap6mWyl7KDnQb+ZihLWRcudWx+RTvLVzxZhbOloSGfxD", + "PvLL0kdapTGXaz0pl1R4fYfUEVjFD/dieK5OjJ7KDJin0koscresOHPFr7xh1nt5RAOiJVt2NB9ap/MD", + "nBUlpj1XVC+sTBk8ZC+lzTO+xLzANGdoCdFc9JWfGmaWXmKeBExFda7GceQR2AFHGA8nZsu/5JhuYZSk", + "+RgzxDoHk8au4HQW7O6Yew8Y5IpfiU/iVpqbsKQjbErjnmizsi1D9iq6bAy8y0Z1CHA3enlyrirTmFK6", + "HEyglGF+Jpg4bGUwV/p4i+gDHQ4Moy3+VQizBBzgC+GEYdKeq5CiabJkOgN5mBLShYAGIxz38MoMwDRU", + "uMaG5ypi2jgeypil0ub+BuFsIqwbiOlUm5pjCzm91LGOtEPeGaXcXZ+8pYyJpsSf33FDBGR9SgSz8Ljq", + "NBuHx8aYMiYyrnD9ji11wVJ9jh7ZSkBGxeeOZYJbh9vpnwroCQfNMRPOJJ55TJe9mmLQOpFbrD4vFTyE", + "pCXr7lEFEcoz7uMeocbMEwpexB6LghsFnV1Md0u5/s6VM1zZ8KQ5YnLKOJo1Tek9CbNBnIFRucmkMBUu", + "yDD9t5hOReJCjuoFR5qnNxxlXEtE6QSFyXqeXF97W29udM5n3KGb4AlSk48lAMHDCsA0J9i4dNT4dx+z", + "duAXPkZbtk8jFjPPewwDU+1sJkD0PVe0s8S5Il+qM61G/8/AY16ERhgo6CnAYlB1i6NDlf4Dz/BopLG+", + "Bhv7iSL7QNQwl4IVCl6h3kl0jVoQfyOvApbubd0lWgzZuMqaPF+yxJiq3EAbJjI5k5Os2aOBoptgfxtZ", + "BRXJ8qImhsP3jnrII3ohWr/XwjsxpW+4x8sS4qVrYSyfGr8pl9SUdOnnW3nCrMTdw5GLUaC4Bgems9eD", + "P/sEwnWHXLbgOft//+f/EvO0YsGVk4ll3LKT52cvvmfrLuGNEdOh1aglPqAyA3JTZeNfz8l3/7x3VA0P", + "+PnjuOOE6FJpmo0nti7TWADHRgm/WWMBP/ub2MtFY7aH1bUOqLbWgXDJMCT4T/RiIlXIJ7hO1pRRkfge", + "/IxlEmKWW893opRQJpqv++KW1SQoGNG/83y9+oaqolUH1jbiB08gNDmE2WOKHPB+uRRVWgU68csoE2Nu", + "dKzbH1ajO+qoG3JkVLPoPx/8nZL0DUeDn3993H/y9dfNqfp+kfkILo5uqoR62Ejs6ym/KcZ8tfaVv6dG", + "/p5a303HzfAX68JFVuV2JFBY3N5xzSUQIyh8WnYaIJjP7ZD5Sya6D1N1IqO1Y0JRmFf0hved4R97kPo6", + "N+ElbEUG/feQh5L/OBt73/WDk5iHy473KeH+GPYtH1VjrVHqRCZKx+09rMJi0TlXqiQrUmFBtMAGV4bn", + "OYa4xfnUct62HVe/FyWrBjL+8CYai71wJVZEK7FFUgqCUp9lmJ8NiCrhRGuOPTl8+mcqfdwvSQ8OMMEI", + "FhIVkUf4A6BZTLLmRB6re7nh6VLmFw47iKbCsi+VujAyJ+eHFZyMWLEHkkssIuczSACpwr7tD7sUp/hN", + "GazrEjPxy2elsj9iQUyJWHv+3kUI7OZ+MMFMJmuv5rtxvlmV6VrjMGOL8HQiXh4DlVKWz7kVKw/05/Q+", + "xsdL+TZGlVg1xj3uf54Vdm3vd4jNrNzPMbisIYrJ37v3ZYxYv9o/Nc770UNO+fXj/NF7ZfgNqx/DZ8Pp", + "W4fsNC+nI/JM7UFiBHdiFO4UQqSiyc0RG8aab/fl61gfZSdkerypRB2t8zekyaOVUmQ9Syvb2vXkqAJb", + "h5N7iQ3v++RolBPu5rd2dYmHRktMb0edT7f3e6fda3DwvkMfGZw5JlS48ckGeXzDob4msfu3fZ4wyd/D", + "Ufo3TudT9LUSgUJHv8h8QyIpyobD2d+PT1h8tVReO+ERE8t5lSVJA3oN113b/Pgvpfm7zLeprmLl1giR", + "pGWn46sEhJiwqDadj3cCq2NJVeGztdjrzzsJCX5fb2UHh10Pa4xV8RD1qhv8JWKuP6wqG2I8IJpf8o0x", + "2rq0A0qHd/ye46bymF8ElxOUqQHW/kbMP1cbUJ/93bqU6elUGMusnCnM14pVJHzxnTCgl8XPVSqqX8Hf", + "3NBrFoIQSXkEWVnFJaZhEW4VChJas0tphe5gj74UwuuvJSKpLBf9oobsezmbC0OfbChxxOwCk/6XqhXI", + "tA+lQRi4hgqw8gzoJKw7Yv8bTptAsMd95tPDw8FC9c///dXh4eDrw0P29rsDuw8dvYq43vGrPpvwjKtE", + "pNTzAE+A7f3vx19X+tLB1bv+qe+/ZqHL14eDP9c6rU3zcR+/jT2eHA6exh4tJ1LBlhGCaVF8h79Kxbff", + "ql6/8htNGf+wrlUL3p1veuq9FeM8W9HR/UGY54pqcgcGiuqlkLPSM8468wBZ6RgadOUayCv8xgN4pk1d", + "KPgt3NK7SZ5xDxpQDn5jUhGy3vrh/lkQC/y6Kyvw+Q35+untgFiZtA7fC7YVs95I615ji5tdSF8mLpWr", + "bkCm8qGZUTqNLxCbYIFkp6BQ75tgD3jJtz40wYH9pDzj+/D7v4tHJsCpKHe+wJPEFaCBH+2Ct2MIRvA0", + "KhAa+QFEfnr1QTd2gNMJoinA/61wBJ044QZUf/PWMg1eMI2xtl8YOsH5spoJdAf0sYKuk1EujC93ZVs5", + "xKlAFntSaXpvgaArA92Wa1RAhbDNL/CoIcPnGrNglaM70FdKGDuX+Q44QJbpdhfR51RZpTRg+ywj2pTe", + "WHQxhfzQYqE9H6GQ5GFLupsgptyZV0+UjFpcJ1Jh3QjZ1lG7NCSsk8ob7TwX9Hntveg97PW3srZ+76Ze", + "Fl77WE51u5tFA4Sbpvd83KzWraS/+sLZZUOin6lHw90IJqh6N+a/4qhmIk/NShY76d36gnPCisJrBQPb", + "yIe0vXdGPLsSR8mBnI4rg5VE7xbdjVLuyCdpE8XcEPX/LvN63je/zN8NGfBqLrYVFL0BRXhl0xaS2FVV", + "3EY552o76WxXGdc0xOdqRUXcnqvN63zvjPxaPeTO5iJuWditcA118An7bGTd7MHVVof6XXcnLl8UyM8N", + "5ryHlcsBnQYDbDMo++0PdysPX2r77oGhPPd7+DtnKqvoemPGcrWaIG/lReK4ca/tT9jqnt4ilSF291K5", + "YcZ4XHZjLa0flYQisA2Vs0q6vfLb0clbcaW4OXRld522+DOhIy2mqtb3iQPVbCd5D/fz4NdwKB/pVDJB", + "Oa9WMVLnJUKuKFxQieK1Jl6HEk96kx5lu9rk6TqmhKMkZ/gv/ChhWwmv0YP6Rqqy1WM8oGjlVsXZKSqa", + "XttXl16p8slOc1UJBv7HNNtG7dc2G8spPsJxGY3pAU5fMQILt2/5avfR3L1+by54iqv+tfefg9PTVwOf", + "0G5w5sN/V6scpJJjQC0ABPBYopXAsb1VRrhfs5cG2+hqqyZT6McvEZFxo9d22WfICqy7M04buc2BDPPE", + "dVEAv6wIgXxNGfwJ/RGiYz8OvtCpYHs6cTxj1KfPsPDBN0+f7g+Zj8dA8fCbp0/bpglQei3T+sfh4E8/", + "//pV/2lTyMzmqLM7VE/fUDMTsxR+6Zc1qtjgfg7+sru44WV6Zg/KrW82jOqZJfJr4eUrKOOL12/C7cCs", + "PBGUacSbuFW/eRiqXN3sM1KrZ1ypVb6KCDG4XWK53SmjuTNpQ7a2DaTbfjPtMk5l7c2jlQ1GvnRr77Pd", + "im/0rON1CIj1m74Bm24XmDTFV5+evupKQj4D9oGYGWGtTzaw1fEPgyixRwiTXat76CuklkUtMPzbR8wM", + "2fPwJ1O+yNmcWzYRQlX7xCqjU5k5YUR6xLAqTFu10Xe0mlc4tRNayz26HzQNtyGLYG3HWtIBlpUh661v", + "XtHzTECYN8D+21sISqSE7s6uDyUtMwKQDLUSTmPMIrCpTIY8EfEjQBDZFPoINdUmESnThcPEATRWHxJH", + "UMXeymqgdg9FCkrLUpHJiTBUdkVpxyxs01wYcRQCNa+X0NBh+dxsGcbCMt2Y9IBgcV87lCU6XwZ/qap6", + "i6asKtNjCWa5Q6ipkVOfItlX8zyjNgVl0JOWkHFaWFFG6GMYJxXpNLpwgjnDp1OZMI7p5Ol3XMKQnemU", + "L+kbvxxII5LoxQKTHpxhqe4hXYK+rCXymmsHeRCMwWz1YwR2ismbxkwb/8V3y5xbC54i45Cb4yTjyysD", + "QddMXOcaVsEtG/sYtaESVx763q9+kz/uj49IBVuhNbiIxpWT4MpeCWOZpGwilNbE6URnPu2DVNYJsLNM", + "QbK94ib1ZWGdjkHZuL/HqVjk2ol4gJ7mmyqoUpKrWHA+8A3kJo4Vua+YLKgwcRVnoQ1PqYI5+V5gxkg6", + "aR7LMEamdFaWypK2LOGDtRCkY7Ywl1SaKGZK8KgW82FADQZ/zz1jPOAKHbyv8ujBAsBQKBccYg1381DI", + "k9gevXkjf43INhEs09Y1scCTopUF3r2OrJX7fbqwwI4M+FXtqvK49nlTdd2e3cPtnUc6P/DlGzqUFTET", + "6Qw3yyqXSHQqyMNsaoQNxSB8ChUMIMdCybZWazQQ0LkCDqsTns21dUffPnnyhGgJoc598VKLTPRRzmfi", + "UZ898nDhz1C6lFjBoysxWST5o3N1yY2ESHE7DF8Ogaqxfsze/qNIPpUpDa6Aw1PdfIZp6KziuZ1r4jPn", + "KgCS6lJfCAC1B80+iGmfqpz8zz77lTm5ELpwpyL5n+zj/iNGrS2VSeGJY0bMJGY8oarwWP3dp8aBJEmP", + "LLNLlcyNVrqwYT7PT46H4e/AGWLeJgByxbj/vYpwyGvPgcO4wr7QqejjxvZxVoknftq7iU6XPuUEnYAR", + "tsgim8LzKI9WWr+FIj1XPpVTQF/k0q8uBcRWQkYpU/hqM8oD0OYINHKCSrik7J1OxfCfNnA/uiCks0xf", + "qXA6YGcLlfyG7AXmn0HbU6hKHEBToqREK58dOVs+8+mAdCWDVWgNjQEHBaW6g8MDAdMfYp8lhts5ptny", + "xSFJJGeZ1nnIGBRhpVpYlEU4pj86V1QBJ85syJ5j+gQe4ON8YncqWC5duREY3mG0/7ZhJ/B6waPhE65S", + "rcp7MAzhrw4ADsLKZYifCRd6mNO5wrVSTef1xVI2FSwhh4eKm8nLbfcF6iIX8EtAXKDTCim3HoUuj3xK", + "q/ouwOMvZY/8i/ZREEt4dsWXlsrbWS8Enqt4nhzerRazSD4qkew8PIzPe4+G7LiecSw063vGAjg9IelL", + "M658ijTBHJ/4W5U2F4URgeDIr2lwJVWqrwJDxsQzVH0IhptqI2ZequMTSmFzrqIfVFkSH2BQngudC+XL", + "YIn4jgkJxPyM8tgnFEc6V1ZkAuVv/4O0rFDR1D0sGWeYW11cpAPVV54tBmjnCrZnyI6nfvwB7Qjq+yjg", + "KRE2SHUOxVFvM+lXOEY9ZRTsb61UISVECfx86GeKvNppPxfMFk1TDenaxDXc/9JlS8S0E45Us/S1pwCX", + "oDvgGTIxwFy8qgjLAgoQw6OCU9jGL0aJK2x5rki8xnLf7BVP5isAaNc4nfCxs1VYcJrWA4Pll8jAVnLg", + "VQkcVukvtXXsxIMCAFoBiZqlz9FGc8cQNRkKmsPwQ/Y+x8JzTLpzFdkUHZKv/R4xS0+JU/vDIVx6Brqb", + "6lzDQcAVrbRv1T9XHmtp0VoR3rg5gZaWJZm2Il3jJuUeeW6s0oj5j2BXfZQ+PSweQRVgv/PI/RKuYmFK", + "OB06fscntrxhS+zHXQ2SwzMWXSD9iy7mn+GuYfMRz55X66+zOb/E+2OhrWN/XkEN+6yR65SXRaIL5eDS", + "gZ04VxVpPSg2/T0SZJanh98Sglb5pn3mA6mRUdC1//LVm1dnr9i6qKeNPfgVpvlxyN7VZ+uz+Lj44AlF", + "kpMykTHxXXivwNX+jN5XgHDzwlmMR8TzXSKsCIe4lPTHQnjQ9BChkxWlhPmCNPErCtgmAbpschBfickS", + "Uq13V8rvWKt/dbKfKclJwzxAemvOXhMluTs18357d0lj4ioClb+RC+la8/GcBda+QjYlsU3EUhP+sVyY", + "QSDeDMDi7J886fAoq6HUB1FYUZoznj75dgcIDkWi7wq7vPuSd+XuYb7jU9woLySuP8Q6JgZuYiGtqt43", + "knRcDVwP70WfkRQarPDKmIxlsmQn70/PGniXWHduhfHWccbep/q2CUVtI7nBzVsu8O4iu2p6unLFNz1M", + "fx/UPVVW7BxYnbN66TyKT5Vwf0XFmMYbAdPEemlKeUWfpfqZKLFGvLjiNiQCGbLvYoLm1dFqQgRzWpPk", + "BlPHm3gizpVBwny2ImH4NyULghzJY3F87sXzoMBdQ1yv4CY3p4qu0l9vR7V3W5lTss+4v9d32RhW25eV", + "Mrj/KkTh71OU+s4VPW9ByNXKLywey7GX6JWG9eF78RFu38jxyaMgvlG+XppbY+YCSvmyhvSdfFzwP5uM", + "orsRGggsjUkJYFUNCFO3+MPYbSb/uC872VY7+Va9imLfl5/tpoHzdGU8hJXIddp9NE+oFWzZvZXIiSN8", + "JnmtNoM2Sa0sjGx8m1sgzZMn9zH516SD3Dx7zwujWjGUcPZZTBMq8IJGwLxwyNkwNbrSjgqXOCNXXyLD", + "Oy4THOxpFd1r1l2X7vHa5vxKbUXsU2x1r5iNQ3xe1PZTaMNt/PkzW1LWT5/f6vh/9X+gr+iFzLKtqPCD", + "zLJOd2gJeXdP0XvDMpj9b7Ly6vsfvshYXWA/cqZ4Rpn/g8vTzXGQkp9vxcIP1OyLxUOa/wMm3l2CANhP", + "kPTO/mswoQIQd4GOZIZsdbcMFwe1um9svOfbjxbRdPH5X77I7EThgWvDGd0GGVLZQVbCVl8sZ8Lpf2Y5", + "jKbQJod9t3TCBpfwL9YLvLwvmfUYcyvM1IVbdw5f4ez0WCFHCI71SArlZMYeH3qPQhurJWC2fHRc+ClW", + "9aJ6v/2qNd8yO+cGXdhsscCBjpgRvgGFMUtVCFYozENTeS+lmuo3+YqJ3MNA3ap0ZMcfstMCc9Dr6dQK", + "95dD7yYLScLRrQ3VwmImUVHVP1e+1i+2ZtqwN9y6AbpBD45fBk+43IhLqQtbcVgmuDA8kyoVuVApOmIM", + "z9Wra6ztTglC3FyUm0eLGbLnZImk3beMZ1Yz4b30oLVQDsOuxXUujYDqHWf/FXZCWsYvucywxJY3/DHu", + "HE/mzYV4A4WAw84mR/87YTX9dZdo3CPChHI/pTZhQbid6H5SPSzUs67u249W+E2qHxPsyQTLi7Voveh8", + "ayqvGH4ilfvm6dZo6B3WVfdsHzKop2sBhxKRCpUIckL3KGd1+eav0oHHLaIuN/f+4gBDXganlbhacsQv", + "l1vbnc8XUBBxD7p1DC0ILK5C95mcCqpq+BB7d2+xd5HWKneM9gdgXSqM2Tl2ArAZPZwPSmtLsyBEatcP", + "of295nSPo2yvO71K8b7j59Nvf6ZiG1ErHu5BjHeC3RApg7rJeqewtApe+Cyzrc+lkIa2ihobwzWPyxQA", + "MR9vOLbgGe90zCfdD0515ANfmRqao3wxNr2QzgWHnrKY5ypcaSPc9rKAeJ82B1zywS/PB38/HHw7+Pl/", + "/NuN8gLiWRws8qe3TgRYIrs/2RrHjb8OXksl7Vykg+dNoTVyIazjixzOIgYomApo6jxkfy244coJOoaJ", + "YB9ev/jqq6++HW6OxKtN5ZQMiDeaiTc+3nQiMJUnh0828QxpvfOWxDKl6M3eZ3kmuBXMmSX5LZC1s77d", + "H5Ca0IO1wV5dzGaUbRqqvKJDLIwQhPOJmGpD1oUlUU+5iCjvPG6Qdz5+wSmrqcC3l5YwqdGdMKtMWtfK", + "qMBdgQ5b3N4pI+bp23SbhdEoV/Ra8rs1ioYZkjE/zPLO3DRIVi8Xv+PGLri5aI/LoHXa6M/qa/kqwnWf", + "9Yir4N0ZwWJd4qlUWKmPcIKbC+G9/6T6J7kRy5Auywucb0+ewp2QzHnuhAl91v1x3nJzcd8CS22Me0yz", + "s8Mc2lQsb3GfIqH9YUSj52kaMZNwxQeGSjUIbL7Eyd1pAy+mLame7hsN64NsFJsfb7oC/SX7BVabwx1g", + "nNnECKGqPOY9eFNTbeiwzFwYdvzSu2r5SChhqByoj765CR7ofBMa6Pz+saAyxs3fTt5P4vNGFzqd1wXA", + "7geSZ9tDCP+DX3LvkoqBGCFSVrkYBuajUtiHVydvhozwCz3lsFT5XGT5Ebjpjcfjf1rUeGZD+HJv/xlr", + "+9/BAcPbeCHcXKe1Xue9JJPJxXmvqfvBATsFi6wrjOjHauv98NDxhWt9qd861LVgQRgBZ40BBFFN6acE", + "SyoOD79K/ttgwL579dfjd+yvr969+vD87NVL3An29tXZ9+9fsjfHp2dsMMDGAorSwI9HbBzHHvf9B0z1", + "Ez+JhXTHEGA4hk7flSVHndHZERtDVfg+G6eGS0UJrOAjSM6vtcEv4PNMO/2jyeBPiIwAAQv+piBNOZGZ", + "dMtTHzYJP+Dewh8ggp1BTHofo8SzY5UX+CE34EkglvC3TYzOELj3CTpFphKAYQQnn+DEfHTfGZ9gxyvp", + "krn/oMSV/wsd+vzfQtnCiA+CZ/4LOYW3MoXPh6W+rS76jeZpdQ+AApSrfONDiI/TDLf5n9i5iImq4dPc", + "ufyvwuGeU3jmERuvBqSO+/G7El0qX/I0fVFYpxerrQFC8y/kllr+Nq6i16t3L7sh17nyeDLweBKwFeXE", + "UtWOUfaUYS1bIkloFVMGjMnvC8P0pkb/ItS5agq5TTIp1IoOn9uwojGCDTCH/su+9yID7pngYs8Vhu7y", + "NO1j5gaiUNqOMPvh+hHs7Y9ZKm0CejyL0b+VyKHxX1+dsQPqcuD8TuN01iOC98c+2nRM/uu+F7WA3CMv", + "9GKhFQPEmYIVpMrLOD5UPY3tnfdC/WzPYIaJXhAXoYYVPN2DbxONzv1GCPYXRk0aCbPSOJPqgv0F+wyV", + "ToUdTqVK9+BP9hdCAwYfhkZngv3lL39h5z3oc95j8OuTb+hfaoNu2NTmrTa1ajzD4ZBmLqds778BhH0f", + "tqzEFcOLaI8go9ffFOTX6lKRj+xhv2fnKsweE76Gpa6xjL3z3oFb5AcYXpir2Xmvj+6/ffb4m8PDEnad", + "Pe79ClA/Vnj1mc4HVO1rIhWgmg/MXSq+8GFRcuHjQxc6LTIRE0B4k6AR3oLmFch0U3BKRgKxbLGa2iXP", + "Cl/tXM6UNuDIDlMLTzBKs1Gy973hcLg/7qO5T8MV5FEcbUYrjJ/aDtmJVAoK5GNVaPTj9cRVxgUMEm3E", + "mOU8ueAzms+5Wjet+S1gY1r/3n6giyTNgRJyoy8xlq5QlewwL8Ul0pxHzuhzb2CzFiJEEmf8F+m5icRQ", + "8DK2uZIqY8g+CCtcH7/znvL9GL/tg5r77P37t31/AJR0JFTuTmFeekkR1tZR4FAacn7ity9+PH75hDZz", + "JNMxWjG9ayudlBVGUtF7YHXSMqFS/xRfWfpqFH2ZVSbGfkL2G3jBXvJM+Me8KYBSEQP9g7waIL7mjg2Q", + "n58c22dM4gyAoCxX6URfb4y487z+A8hxv9Fwu8oUa2/+uqz5H6fv38UsCROdSk9RGO5F2ss/s7fyu6AC", + "pOPBvN70cjnzOGbEP9HgyOH9auc8EylLuQD+HcCj4Qd13/j9I+tBK3GVSSUGqQij+h4D+JqmQkXjlFYD", + "xMKCtDRPDw+HvU/pKFLb1G5Rg3s+bJBh4H8se++Jav9Wz9jHX93Gwf13EcJXfyRVIvVRWOsYbGETngmn", + "fxFGH6TSAuNuf56dGG/w9Rmu0GgPEDAiSTOA0ocHOzdphgc/Zd+fnZ3ExFUUOoSJOUIQE1AQpomQFkBe", + "gYb/Cmp/SscmIuGFFexHJS8Mnzr6dSXWGNpillO1jPTmGeDf3jaGKdEyT2HlZ/rvwuhel+AcbD9wegCr", + "ZH6v0js50RJdsmWAjPsqwq5Wtqiz7qN6tEJtPtkPwjpthGUKZLGM2dpiw5O2Mos+JcEqs2/Vp0u2GAr5", + "TjNBR059o/Hob2+Z0r7EK1NCpNZbjOYiS0FcuxCN95C6/ekJdU+HR4Bvf3axSadMif6Zy2Ivlmg1lbOC", + "tm3IQuOnh08xRUNsJ0N2AWrefPP/VbizOJ97vGLiIOD92ugofda8wJsqvdcTJLbA75YcMRQVWGGa3DiJ", + "rIoqhNGRtR4V6kP9CFLYSu4SZkXk9BW5hRIokCiaPgum9ioI8kzxeRUCrljhHLxSdkIOdkq9fD6ROHXA", + "+bArgPaevnwyTZZkghsbEu81I+a3xBjG1mkDTzEPYgyzIChYe7vMhIcpMDD3V2YET5dleQGC8Gx9PICV", + "iSk8uPx+NTr8wTnWEf7eZNQ4zAuc56f2/r0xxX2+anefyYDxI673lgyiKXvqqXBbOEKgkSeHj+v0ecWJ", + "QCtORSWtPouZYJ4cHkI/VAVZIOFMJIEadO4GUh2tZpIk4gPoVT6yx8uENjgOKRpCfl0rXIidxle05xGB", + "LQSJab+VHTyLKbFkvFO9uLCJJ/0meUjhPh8H+c1zjLs0r998Qla4L9GSejsxpSZcVkqVND8LjpVXbSjv", + "sx+dPcopkOdxn81CSpZqprCViVaZ2WGZnopbiGgUKRPqUmQ6F+UjwQ9rGU+DD+GTw6cNv4ekwmxP6TB8", + "8CvUpmz7yJYsSdqSKyHLenp4yEi/KlPuE9KhsqKZxieZtKWkQP7Z9xQpRGPhEJ8pUqhcpz+kxnB+PI6c", + "Zotq6XCiCTd4idTO28JSVCKGxBWaUmIgQJ4kIkf0Klx50ptx7RndjWEqw5vTeo3+/El0IIndyXFbMJHP", + "f4cW7rrTfzk2kbTPP4jGS7zgfJLJBRvL9Ij9asW/Pp6fK3DiP2K/hkMaAEbA9+fnagySAp0OU1hEj9Sj", + "Xqk8WGilnVYyQfVysGTwxGhrVxitV5NDvuqm4CC1LMODyjAnIE6kQ5g2BXMElREte8heYtJTmBQFRBNK", + "zHhuwzNpLNMxpas9CqkJYwAI/iYt1WrFrNiPGZ/7hD0hXmRgBQgUEky8tLPsShhgJaSqLyOiCkgxO2Qv", + "0D5pmZ1jljFnMJXlGjR0oRZOJA7nO2SvMR9qNcrLy1YrW0ZZweOw5WvOHxWZVfGxKCh5Ec76Gfpos/H/", + "pOCgv/AsG1Plwxo4naXCujKUIWA4JjIijfeVhP2e81yE/KAzoYQB+06dE46H7LU2UWL0uyf889TTLqXv", + "p5zGbA+aUzpgYSwrrC/KpZNiIRT0QgeB8X6/xs7HgMVjxDltFrHw7SKU9Rp7SenfcVovsTExtX5MXwrj", + "EvAmTk8RHvXl2W2O9B/q8UfSMlunpyF7jzY7w6xQKTtsOI9wvLm2kh4D3WgSMzjVCAtNhkRGAsjMeDO8", + "H4r7agdtsVZjwpsxXbxoyaeBhcXYM6uRIYFqdhBjsMrhMsEBJ2sZsQYEEk5oLq3TZklbf8t4rP66/gUQ", + "fxeEH7IPMCsiabAYW8Yde3z45Okz7BCRmVc4ARCeLcyUJ4IsNpTcFYl9ZgR3Iff+48oyV0IbaEeaY6ey", + "rClc6l6jzzrd+G86XEZfXKWb1RXAiVJZjMGpUI5FDtDpgr8SE164uTqYa31RKai2UlgRM/Jq1fcPZ8xc", + "jHZtusUDG2Qz4Sy5Usrcv9dD3Yyx4pdyxp02w8QIjOThmR2C7xKZ3Jt/p3R3wScF7lsUm5LBhViySsNo", + "0if1/VFNFTnTZal+2BCNpp0o42sjZ1LFIh0xb2+oM5p4m1BYpi/boZakXKhDLXOo48JX0kZXLOWPKD28", + "BMcYgOpVKidGXnIn2IVYWkZlPYQKcaJoNTpXZ4XxyZAh0hTdLi3eqGGGltjIzKtEoas/E5i5w6o4ZVs6", + "J69mwFzAZDfJBPxNR75ivorJ10sTg89BnfHZHRQQWVumQmch6/1RoFs5/zB1nQuFjA+QWaQhc/MypgQG", + "Qw/9hocvFXv8dQynqdckIfUKNA5pqFV/ZYsp5GcmHJMeJao4F12EMffXkNUXU6ZCPqxZnXw6wxKdfvzw", + "hu2Nf3j14d2rN6O3r84+vB89Pzkefff89NXoxw9vxvvkko6oJl19mOk0ZJ1Ha7dIbYs+6CcxeQ5c4Htg", + "AvfzSqwN8Ymfh+tj19nb9/6UnfhN1EeBI0R8CPMmfou4SBoDPZ3uwODBfY98Cwfo+7fVbhcoPjq3U2+q", + "KRJrW6BsjYqV45d9jJKwOU9En6RbYYgkYi2ShXAcLsrm7Lfk6EmOlOhbdZ/GvLXBNiVACgXM/B5UyqvY", + "4d1FWTVA7+Al0W/RjZWBK3gkKZvAkQC/rZwkpbwtPweOBcgWkiZpA7W6/KchlCcof0MYwaMmvGqhM7uU", + "vOIBMqyAWOkEDaEWGFangeELi2XW2KTiLeL77Fkh2Bid9Mf73iOXSjFiqkUBrwhOmVTIJUkscges3/Dl", + "udJTcHmXSlYesMBaPa7afh1J2V7plssV06E8q3diJETa92V1wmqmhaL3Mc2O9jxW4eJOe2fLIXvrR0V2", + "g1ZJF100K9caAFcUAIpylq16C+vCDfR0EDP2UotnDMsHxAcmrkpaXwkN3t+J8HVkzhUk0LUNQ4eqZGgK", + "kYo1uA/T/ay95pxpJXAoclkmlRO064ec/sAwgE0g5DTFzzUX0lPhzqm+3QhedVTlN2JwzB2SBHkklneg", + "FZbJuKl9udvPzlWwO2vjTS08TYOPdCjqQtABYISslQBlVfhYVhwqE9k03afPg7P7Kjfb5VL1DtPI+pI0", + "HxH5wKdqljOeYtCRyyIp9fo9fE5Dy7gbvaNexQEb3iNIOL2j3j9+PVeMXUiVHrFzGOi814dvEH+O2K+F", + "yUY+it0esX80OnQf/Pt57+eP2A229IghTIaHAVBBNhvBGnCifgDGKhwLWuFiQpmN2pKGsQvWqDpF2jti", + "v8JzCXpSaX/wjeZpKolQTwyciZPCejs/zY/+9fR6RMky2d4I4fbZr7hqYT/uR8/xPb8WnNCR99P+p93b", + "K5sEohlimz77lQrIHKdHnrnYfxz+PHQ6H9EPkKFpn2YD//n48znWt+0B59x+zBU2e6ujBgD3dda4km6H", + "DU1pZXd4ysyz6Q0w8krPX/3hxmb0AD+HU4mVf3FD/Jp+3oRMVdzxgOsYUj31j12TiDfxlM8UM7yj8FSK", + "G3QPruRQhilxqSwphpGHi6tsSW0rUtYXZgkFAexmIl2LzH7wq0w31jb4gAFCVGWrKtRNljVBfcieq8pN", + "Fp/OlcQV0Y+Bq0RklOykfsN9qMRmlYjQKfPYloxjlYwpiRtB0pSf4Z/Dwbc///rkq4/dEqc0mOoqeBgK", + "Hgw/a35SmALm0FvFkd1QhKKyNhnJL7F2IxUV4IkjA12tgqMMWXXI8qF1NjJiOmTvtBqA0twWE7AFpCLJ", + "OHS5JGsdxamFKoplLjNpfBFG0sLrvMi48woXTOUAd6hUsxHCJSM4ZeMcsvdU9QrgnitoR97TzAmzkCB/", + "Uxr5qhjsrXpeeUi1FcvnRpUS6FKAZHL6UpyrJ08P2Q/yuzj/UMSiWouWM2cKRTUeaehYDSzqw+RCYEIz", + "vwMlbZ0rTEVoySJkUUVbFsMrXKIXYlSoCwVaQJCLSdlHCiMbZeiVrPENAicdco0Q70mD8/bFCQ22IXYF", + "2Tu/YqsxLOjSUAlgeYxRJnlWWPYUD0JPS4s8PAHQ3ukDXGJkS+8T6438iqn7huCSoDqO3gCk2Cz5rEqZ", + "kIhZJUnQO7VCY2gF16as1riG+sMvI8Mp9Hp6b+ewoWZD2YhNxIyrPrplSCxo6B/wQHe+ALqvz6AnSJ3p", + "cIVNE64zHgNrRXpzVt1N9cZjzV6gh8pgtqqPmyz9Kxg13vBiwgK4SyYWEwGSk6/AqFzQc7u5tvi2Is36", + "e0VeF2gH9ETaDxZvH7640Eo6bdbKrUIAO44XKn6S+cCIIEycq6iIJz4dCv/A8P3Qjb4KE2ZhvtBV+MJA", + "CALdFNaKZ4DyAWXKSoG+qEeHDdGmhE1GKpxmZRPdXCyoEBNGgfkbRFi4oagYJ/qpeP2CL/WByiD+r0LE", + "i5LgxkuUIi5b7toVLVP/XKERrYwyhsvJV9WlbepT0SNoFpVQTevygaoplT+CSqTl/LQv4Rzq3a7WcG6J", + "q6irLzb6E7y6xu2paRf9cWyoViSo14h6NZcswmddp5pFd832OyuGmwpuf07h8qVnVnXu4eWkHQvnffz4", + "/x8AXVnhSTQGBAA=", } // GetSwagger returns the content of the embedded swagger specification file diff --git a/server/openapi.yaml b/server/openapi.yaml index b4315554..0b4cee76 100644 --- a/server/openapi.yaml +++ b/server/openapi.yaml @@ -1597,6 +1597,8 @@ paths: the API runs; when it shuts down, they are removed and their tabs closed. operationId: executePlaywrightCode x-telemetry-category: control + parameters: + - $ref: "#/components/parameters/IdempotencyKey" requestBody: required: true content: @@ -1618,6 +1620,10 @@ paths: application/json: schema: $ref: "#/components/schemas/PlaywrightExecutorLimitError" + "422": + $ref: "#/components/responses/IdempotencyKeyReusedError" + "429": + $ref: "#/components/responses/IdempotentCallsBusyError" "500": $ref: "#/components/responses/InternalError" /playwright/executors: @@ -1718,6 +1724,8 @@ paths: VM, equivalent in trust level to the process and Playwright execution APIs; it is not sandboxed. operationId: executeBrowserRepl x-telemetry-category: control + parameters: + - $ref: "#/components/parameters/IdempotencyKey" requestBody: description: JSON request bodies are limited to 8 MiB before strict decoding. The API rejects a marshaled daemon request over the daemon's 8 MiB newline-delimited request-line limit as a non-destructive 400. required: true @@ -1736,6 +1744,10 @@ paths: $ref: "#/components/responses/BadRequestError" "413": $ref: "#/components/responses/BadRequestError" + "422": + $ref: "#/components/responses/IdempotencyKeyReusedError" + "429": + $ref: "#/components/responses/IdempotentCallsBusyError" "500": $ref: "#/components/responses/InternalError" /browser/location: @@ -2110,6 +2122,23 @@ paths: "500": $ref: "#/components/responses/InternalError" components: + parameters: + IdempotencyKey: + name: Idempotency-Key + in: header + required: false + description: | + Makes retrying the call safe. A call with a key already used returns the first call's + response instead of running the code again, waiting for it if it is still running. A call + with a key keeps running for 10 seconds after its last caller disconnects, so a retry can + collect its response; after that it is cancelled like a call without a key. A response is + kept for 10 minutes once the call finishes, and only the most recent responses are kept. A call that did not run, + such as one rejected with 400, 409 or 429, does not use up its key. Keys are scoped to this + endpoint and are lost when the API process restarts. + schema: + type: string + minLength: 1 + maxLength: 255 schemas: ExtensionUploadMultipart: type: object @@ -8151,6 +8180,18 @@ components: application/json: schema: $ref: "#/components/schemas/Error" + IdempotentCallsBusyError: + description: Too many calls with a new Idempotency-Key are waiting or running. The call did not run; retry it. + content: + application/json: + schema: + $ref: "#/components/schemas/Error" + IdempotencyKeyReusedError: + description: The Idempotency-Key was already used for a request with different parameters + content: + application/json: + schema: + $ref: "#/components/schemas/Error" NotFoundError: description: Not Found content: