From 8c47e0eb7ccc6c4ca74d3e4225ffe5003a45f7f1 Mon Sep 17 00:00:00 2001 From: sjmiller609 <7516283+sjmiller609@users.noreply.github.com> Date: Fri, 8 May 2026 17:19:23 +0000 Subject: [PATCH] api: expose share_memory fork mode + fork_count/mem_locked on Instance ForkInstanceRequest gains share_memory: when true, the source instance is auto-promoted (idempotently) into a fan-out parent and the fork attaches to its mem-file via the existing template path instead of copying. While any share_memory fork is alive, the source is mem-locked: start/restore/ delete return 409 (ErrInvalidState) until the forks are deleted. Instance gains read-only fork_count and mem_locked fields so clients can introspect lock state on the existing GetInstance response without needing a separate templates resource. The internal templates registry stays in place but is not exposed in OpenAPI. templateGuard now returns ErrInvalidState rather than ErrNotSupported so the lock surfaces as a transient 409, not a 501 capability gap. --- cmd/api/api/instances.go | 3 + lib/instances/fork.go | 16 + lib/instances/query.go | 1 + lib/instances/share_memory_test.go | 169 +++++++++ lib/instances/templates.go | 73 +++- lib/instances/types.go | 19 + lib/oapi/oapi.go | 556 +++++++++++++++-------------- openapi.yaml | 25 +- 8 files changed, 591 insertions(+), 271 deletions(-) create mode 100644 lib/instances/share_memory_test.go diff --git a/cmd/api/api/instances.go b/cmd/api/api/instances.go index 61c38ff8..335da92f 100644 --- a/cmd/api/api/instances.go +++ b/cmd/api/api/instances.go @@ -638,6 +638,7 @@ func (s *ApiService) ForkInstance(ctx context.Context, request oapi.ForkInstance Name: request.Body.Name, FromRunning: request.Body.FromRunning != nil && *request.Body.FromRunning, TargetState: targetState, + ShareMemory: request.Body.ShareMemory != nil && *request.Body.ShareMemory, }) if err != nil { switch { @@ -1062,6 +1063,8 @@ func instanceToOAPI(inst instances.Instance) oapi.Instance { ExitCode: inst.ExitCode, HasSnapshot: lo.ToPtr(inst.HasSnapshot), Hypervisor: &hvType, + ForkCount: lo.ToPtr(inst.ForkCount), + MemLocked: lo.ToPtr(inst.MemLocked), } if b, err := json.Marshal(networkPayload); err == nil { diff --git a/lib/instances/fork.go b/lib/instances/fork.go index 9446960f..ac28e371 100644 --- a/lib/instances/fork.go +++ b/lib/instances/fork.go @@ -37,6 +37,14 @@ func (m *manager) forkInstance(ctx context.Context, id string, req ForkInstanceR return nil, "", err } + if req.ShareMemory { + shared, err := m.ensureShareMemoryTemplate(ctx, id) + if err != nil { + return nil, "", err + } + req.TemplateID = shared.ID + id = "" + } resolvedID, tpl, err := m.resolveForkFromTemplateRequest(ctx, id, req) if err != nil { return nil, "", err @@ -406,6 +414,14 @@ func validateForkRequest(req ForkInstanceRequest) error { if req.TargetState != "" && req.TargetState != StateStopped && req.TargetState != StateStandby && req.TargetState != StateRunning { return fmt.Errorf("%w: invalid fork target state %q (must be one of %s, %s, %s)", ErrInvalidRequest, req.TargetState, StateStopped, StateStandby, StateRunning) } + if req.ShareMemory { + if req.TemplateID != "" { + return fmt.Errorf("%w: share_memory cannot be combined with template_id", ErrInvalidRequest) + } + if req.FromRunning { + return fmt.Errorf("%w: share_memory requires the source to already be in Standby; from_running=true would re-restore the source after locking", ErrInvalidRequest) + } + } return nil } diff --git a/lib/instances/query.go b/lib/instances/query.go index 699fa35f..c2043068 100644 --- a/lib/instances/query.go +++ b/lib/instances/query.go @@ -356,6 +356,7 @@ func (m *manager) toInstanceWithStateDerivation(ctx context.Context, meta *metad BootMarkersHydrated: result.BootMarkersHydrated, } refreshHypervisorPID(&inst.StoredMetadata, result.State) + hydrateForkLockState(ctx, m.templateRegistry, &inst) // If VM is stopped and exit info isn't persisted yet, populate in-memory // from the serial console log. This is read-only -- no metadata writes. diff --git a/lib/instances/share_memory_test.go b/lib/instances/share_memory_test.go new file mode 100644 index 00000000..56b03271 --- /dev/null +++ b/lib/instances/share_memory_test.go @@ -0,0 +1,169 @@ +package instances + +import ( + "context" + "os" + "path/filepath" + "testing" + "time" + + "github.com/kernel/hypeman/lib/hypervisor" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" +) + +func TestValidateForkRequest_ShareMemoryConflicts(t *testing.T) { + t.Parallel() + + t.Run("share_memory with template_id is rejected", func(t *testing.T) { + err := validateForkRequest(ForkInstanceRequest{ + Name: "fork-bad-combo", + ShareMemory: true, + TemplateID: "tpl-123", + }) + require.Error(t, err) + assert.ErrorIs(t, err, ErrInvalidRequest) + }) + + t.Run("share_memory with from_running is rejected", func(t *testing.T) { + err := validateForkRequest(ForkInstanceRequest{ + Name: "fork-bad-combo", + ShareMemory: true, + FromRunning: true, + }) + require.Error(t, err) + assert.ErrorIs(t, err, ErrInvalidRequest) + }) + + t.Run("share_memory alone is allowed", func(t *testing.T) { + err := validateForkRequest(ForkInstanceRequest{ + Name: "fork-ok", + ShareMemory: true, + }) + require.NoError(t, err) + }) +} + +// stagedStandbySource creates a metadata + fake snapshot directory for an +// instance so toInstance reports State=Standby without involving any real +// hypervisor. Returns the source instance ID. +func stagedStandbySource(t *testing.T, mgr *manager, name string) string { + t.Helper() + id := name + require.NoError(t, mgr.ensureDirectories(id)) + + dataDir := mgr.paths.InstanceDir(id) + snapDir := filepath.Join(dataDir, "snapshots", "snapshot-latest") + require.NoError(t, os.MkdirAll(snapDir, 0o755)) + require.NoError(t, os.WriteFile(filepath.Join(snapDir, "memory"), []byte("fake-mem"), 0o644)) + require.NoError(t, os.WriteFile(filepath.Join(snapDir, "config.json"), []byte("{}"), 0o644)) + + now := time.Now() + meta := &metadata{StoredMetadata: StoredMetadata{ + Id: id, + Name: id, + Image: "docker.io/library/alpine:latest", + CreatedAt: now, + HypervisorType: hypervisor.TypeFirecracker, + HypervisorVersion: "test", + // Intentionally no SocketPath so deriveState falls through to the + // snapshot check and reports Standby. + DataDir: dataDir, + VsockCID: 44, + VsockSocket: mgr.paths.InstanceVsockSocket(id), + }} + require.NoError(t, mgr.saveMetadata(meta)) + return id +} + +func TestEnsureShareMemoryTemplate_AutoPromoteAndReuse(t *testing.T) { + t.Parallel() + mgr, _ := setupTestManager(t) + ctx := context.Background() + + sourceID := stagedStandbySource(t, mgr, "share-mem-source") + + tpl1, err := mgr.ensureShareMemoryTemplate(ctx, sourceID) + require.NoError(t, err) + require.NotNil(t, tpl1) + assert.Equal(t, sourceID, tpl1.SourceInstanceID) + assert.Equal(t, shareMemoryTemplateName(sourceID), tpl1.Name) + + // Source is now flagged as a template parent. + meta, err := mgr.loadMetadata(sourceID) + require.NoError(t, err) + assert.True(t, meta.StoredMetadata.IsTemplate) + assert.Equal(t, tpl1.ID, meta.StoredMetadata.TemplateID) + + // Second call returns the same registry entry — no duplicate promotion. + tpl2, err := mgr.ensureShareMemoryTemplate(ctx, sourceID) + require.NoError(t, err) + assert.Equal(t, tpl1.ID, tpl2.ID) +} + +func TestEnsureShareMemoryTemplate_RejectsNonStandby(t *testing.T) { + t.Parallel() + mgr, _ := setupTestManager(t) + ctx := context.Background() + + // Same staged source layout but no snapshot dir → state derives as Stopped. + id := "share-mem-stopped-source" + require.NoError(t, mgr.ensureDirectories(id)) + now := time.Now() + require.NoError(t, mgr.saveMetadata(&metadata{StoredMetadata: StoredMetadata{ + Id: id, + Name: id, + Image: "docker.io/library/alpine:latest", + CreatedAt: now, + HypervisorType: hypervisor.TypeFirecracker, + HypervisorVersion: "test", + DataDir: mgr.paths.InstanceDir(id), + VsockCID: 45, + VsockSocket: mgr.paths.InstanceVsockSocket(id), + }})) + + _, err := mgr.ensureShareMemoryTemplate(ctx, id) + require.Error(t, err) + assert.ErrorIs(t, err, ErrInvalidState) +} + +func TestTemplateGuard_ReturnsInvalidStateNotUnsupported(t *testing.T) { + t.Parallel() + mgr, _ := setupTestManager(t) + + // Locked: a template parent should return ErrInvalidState (409), not + // ErrNotSupported (501) — the lock is transient (resolves once forks + // are deleted), not a hypervisor capability gap. + stored := &StoredMetadata{Id: "src", IsTemplate: true, TemplateID: "tpl-xyz"} + err := mgr.templateGuard(stored, "start") + require.Error(t, err) + assert.ErrorIs(t, err, ErrInvalidState) + assert.NotErrorIs(t, err, ErrNotSupported) + + // Not a template: no error. + stored.IsTemplate = false + require.NoError(t, mgr.templateGuard(stored, "start")) +} + +func TestHydrateForkLockState(t *testing.T) { + t.Parallel() + mgr, _ := setupTestManager(t) + ctx := context.Background() + + sourceID := stagedStandbySource(t, mgr, "share-mem-hydrate-source") + tpl, err := mgr.ensureShareMemoryTemplate(ctx, sourceID) + require.NoError(t, err) + + // Zero forks initially. + inst, err := mgr.GetInstance(ctx, sourceID) + require.NoError(t, err) + assert.Equal(t, 0, inst.ForkCount) + assert.False(t, inst.MemLocked) + + // Bump refcount and re-read: ForkCount/MemLocked should reflect it. + require.NoError(t, mgr.bumpTemplateForkRefcount(ctx, tpl)) + inst, err = mgr.GetInstance(ctx, sourceID) + require.NoError(t, err) + assert.Equal(t, 1, inst.ForkCount) + assert.True(t, inst.MemLocked) +} diff --git a/lib/instances/templates.go b/lib/instances/templates.go index f6607a99..fd4f8541 100644 --- a/lib/instances/templates.go +++ b/lib/instances/templates.go @@ -165,13 +165,16 @@ func (m *manager) touchTemplateUsage(ctx context.Context, templateID string) { // templateGuard returns an error when the instance is a template parent. // Templates must not be Started or Restored — the snapshot is shared with -// live forks and resuming it would corrupt them. PR 3 hardens this further -// when forks rely on the template's mem-file directly. +// live forks and resuming it would corrupt them. +// +// Returns ErrInvalidState (409) so callers see this as a transient +// state-conflict (resolves once forks are deleted), not as a hypervisor +// capability gap (501). func (m *manager) templateGuard(stored *StoredMetadata, op string) error { if stored == nil || !stored.IsTemplate { return nil } - return fmt.Errorf("%w: cannot %s template instance %s (template_id=%s); fork from it instead", ErrNotSupported, op, stored.Id, stored.TemplateID) + return fmt.Errorf("%w: cannot %s instance %s while it is mem-locked by live forks; delete the forks (or wait for them to exit) first", ErrInvalidState, op, stored.Id) } // validateForkResolvedFromTemplate confirms a fork-from-template request @@ -324,3 +327,67 @@ func (m *manager) dropTemplateForkRefcount(ctx context.Context, templateID strin "template_id", templateID, "error", err) } } + +// ensureShareMemoryTemplate resolves (or creates) the template entry that +// backs ShareMemory=true forks against the given source instance. If the +// source is already a template parent, the existing entry is returned. +// Otherwise the source is auto-promoted with a deterministic, internal +// name derived from its instance ID — the public API never exposes the +// templates resource, so the name is purely a registry detail. +// +// The source must be in Standby; this is checked here so callers see a +// clear error before the fork machinery starts allocating fork state. +func (m *manager) ensureShareMemoryTemplate(ctx context.Context, instanceID string) (*templates.Template, error) { + if instanceID == "" { + return nil, fmt.Errorf("%w: share_memory requires a source instance id", ErrInvalidRequest) + } + if m.templateRegistry == nil { + return nil, fmt.Errorf("%w: template registry not configured", ErrNotSupported) + } + meta, err := m.loadMetadata(instanceID) + if err != nil { + return nil, err + } + stored := &meta.StoredMetadata + if stored.IsTemplate && stored.TemplateID != "" { + tpl, err := m.templateRegistry.Get(ctx, stored.TemplateID) + if err != nil { + return nil, fmt.Errorf("load existing share-memory template: %w", err) + } + return tpl, nil + } + inst := m.toInstance(ctx, meta) + if inst.State != StateStandby { + return nil, fmt.Errorf("%w: share_memory requires the source to be in Standby (got %s)", ErrInvalidState, inst.State) + } + return m.promoteToTemplate(ctx, instanceID, PromoteToTemplateRequest{ + Name: shareMemoryTemplateName(instanceID), + }) +} + +// shareMemoryTemplateName computes the registry name used for auto-promoted +// share-memory templates. Encoded as a function so tests can assert that +// repeated ShareMemory forks against the same source resolve the same +// registry entry. +func shareMemoryTemplateName(instanceID string) string { + return "share-mem-" + instanceID +} + +// hydrateForkLockState fills in ForkCount/MemLocked on inst by looking up +// the instance's template entry. Non-fatal: any registry lookup error +// leaves the fields at their zero value so callers see "not locked" rather +// than a hard failure. +func hydrateForkLockState(ctx context.Context, registry templates.Registry, inst *Instance) { + if inst == nil || registry == nil { + return + } + if !inst.IsTemplate || inst.TemplateID == "" { + return + } + tpl, err := registry.Get(ctx, inst.TemplateID) + if err != nil || tpl == nil { + return + } + inst.ForkCount = tpl.ForkCount + inst.MemLocked = tpl.ForkCount > 0 +} diff --git a/lib/instances/types.go b/lib/instances/types.go index bc9ee2cc..4d9854ae 100644 --- a/lib/instances/types.go +++ b/lib/instances/types.go @@ -173,6 +173,15 @@ type Instance struct { StateError *string // Error message if state couldn't be determined (non-nil when State=Unknown) HasSnapshot bool // Derived from filesystem check BootMarkersHydrated bool // True when missing boot markers were hydrated from logs in this read + + // ForkCount is the number of live forks created against this instance + // with ShareMemory=true. Derived from the templates registry when the + // instance is a fan-out parent; zero otherwise. + ForkCount int + // MemLocked is true iff ForkCount > 0. While true, start/restore/delete + // of this instance fails with ErrInvalidState because the snapshot + // mem-file is being served to live forks. + MemLocked bool } // GetHypervisorType returns the hypervisor type as a string. @@ -264,6 +273,16 @@ type ForkInstanceRequest struct { // template's mem-file instead of being copied per-fork, so many forks // fan out from the same warm guest memory. TemplateID string + + // ShareMemory opts the fork into mem-file sharing with the source + // instance: instead of copying the snapshot mem-file, the fork's + // hypervisor reads pages from the source's mem-file (via uffd or + // hardlink, depending on hypervisor). Requires the source to be in + // Standby. The first such fork against a source auto-promotes that + // source so subsequent ShareMemory forks reuse the same registry entry; + // while any are alive, the source is mem-locked (start/restore/delete + // return ErrInvalidState). + ShareMemory bool } // SnapshotKind determines how snapshot data is captured and restored. diff --git a/lib/oapi/oapi.go b/lib/oapi/oapi.go index 093dd8f5..fe95f3a5 100644 --- a/lib/oapi/oapi.go +++ b/lib/oapi/oapi.go @@ -683,6 +683,14 @@ type ForkInstanceRequest struct { // Name Name for the forked instance (lowercase letters, digits, and dashes only; cannot start or end with a dash) Name string `json:"name"` + // ShareMemory Share the source instance's snapshot mem-file with the fork instead of copying it. + // Requires the source to be in Standby state. While at least one fork created with + // share_memory=true is alive, the source is mem-locked: start/restore/delete on the + // source return 409 until all such forks are deleted (see Instance.fork_count and + // Instance.mem_locked). Forks created with share_memory=false are unaffected and may + // be created against the same locked source. + ShareMemory *bool `json:"share_memory,omitempty"` + // TargetState Target state for the forked instance after fork completes TargetState *ForkTargetState `json:"target_state,omitempty"` } @@ -875,6 +883,10 @@ type Instance struct { // ExitMessage Human-readable description of exit (e.g., "command not found", "killed by signal 9 (SIGKILL) - OOM") ExitMessage *string `json:"exit_message,omitempty"` + // ForkCount Number of live forks that share this instance's snapshot mem-file via share_memory=true. + // Zero for instances that have never been used as a fan-out parent. Read-only. + ForkCount *int `json:"fork_count,omitempty"` + // Gpu GPU information attached to the instance Gpu *InstanceGPU `json:"gpu,omitempty"` @@ -893,6 +905,10 @@ type Instance struct { // Image OCI image reference Image string `json:"image"` + // MemLocked True iff fork_count > 0 — i.e. at least one share_memory fork is alive against this + // instance. While true, start/restore/delete on this instance return 409. Read-only. + MemLocked *bool `json:"mem_locked,omitempty"` + // Name Human-readable name Name string `json:"name"` @@ -15654,273 +15670,279 @@ func (sh *strictHandler) GetVolume(w http.ResponseWriter, r *http.Request, id st // Base64 encoded, gzipped, json marshaled Swagger object var swaggerSpec = []string{ - "H4sIAAAAAAAC/+y9+3YbubE3+ipYfbJXpISkqKttZc3aRyPZHu2xbB3Lds7O0B8FdoMkRt1AD4CmRHv5", - "3zxAHjFP8i0UgL4RTbZkXazYe2clMrsbl0KhUFWo+tXnIORJyhlhSgb7nwMZTkmC4c8DpXA4/cDjLCFv", - "yR8ZkUr/nAqeEqEogZcSnjE1TLGa6n9FRIaCpopyFuwHp1hN0eWUCIJm0AqSU57FERoRBN+RKOgE5Aon", - "aUyC/WAjYWojwgoHnUDNU/2TVIKySfClEwiCI87iuelmjLNYBftjHEvSqXV7optGWCL9SRe+ydsbcR4T", - "zIIv0OIfGRUkCvZ/K0/jY/4yH/1OQqU7P8gUP1OYRaP5KY9pOF+c7CvKsivoDeFM8QQrGiJpvkEpfIRG", - "WJIIcYZwqOiMIMpGPGMRend4ikLOGAl1Y3LA+EgSMSMRGgueIDUlaMqlgneUwOEFUngUk96ABZ3aehCm", - "n0SrqfT3KVFTIjyDpRLZVtCYC6SmVCLK9NOQ9MoLpkRGFinbCWgUk6GiCeGZWiTUL/wSxZxNYFquXZRk", - "UqEpnhH0iQiO/shwTMdzyibNRBqRMRcE/TJPSYIZSmMcEomoQpQp7mZjaFTw2G7iYy46YVyQYUSkogzr", - "9ocpF2ZHVEf/Bv7AMSq9C0OD95GaYuW4nHGFLghJqxPFl/iiSsbftrY6z/r9/sdOQBVJzLbCVzTJkmB/", - "b3d3e7cTJJSZf2/mo6dMkQkRevj2FywEnpemI3kmQjIMaSSWzSSMKWEKHR4fvb3hBILNfg/+f+Np0Ak2", - "n231Nveewr8394LytBYIXx35l+Vb70xhlclFGWR209AyyrDEJIuzfp0lIyIQH6MwE4IwFc8RbCkStWC6", - "yrT7vqUIORvTSSbcFvRtuQo5p1gizIzQ6NbkRdFYq30XaiEW8Us2FCTBlGkaLwzirXuE9A5FdhPpIYWc", - "KcHjWAsFpUiSKul2UUeLcYZwmsY0BNFT2VQ7SV8GnYBlcawf1kZYrDaJ6YTCC61IQ2Vpkdy3SHFEmCIi", - "3+FtSFMRi00dF+T2rkYhF9tLQUlZ6J8uq9M80RJekNBMNz8BKhQZkZAnBOmmqyuw1d/a6/Z3uv29d5tP", - "9vs7+/3dfwSdYMxFglWwH0RYka5e8DbLtFx+HxZU0i8i+2JxVHlo16vJ4HbsEmOp8l0Nm5yq+RB7xvSO", - "JkQqnKR6Y+sxlIjZtK1dg/V1cJRfSuDNryIwI1dqaCnknY+PP8hVSkJ9xHC3PfMTW7fXQXSMMMplgGZX", - "IxiXTuTZV01EECz1gLXeoU+n34KMySzVZyGJhmmMlW5XKynABsOESqk/zX+IqDQbsxM4Jh8yroYiY8y8", - "yIi65OKi/KZtZUjToBNMsRzOJmkWdJadA1Wmhi5IjFMJ7dkVF0MiBBeB0TXnwzEXbpH0IVaQcElTCxSS", - "+ZnloVDQCSoEyOWjm4sbd76q3sFBL8BLwqjpRq+GySwOvNzW4nDzoS2XlEYsG63ULTOyH8uqBIgonjAu", - "FQ1lK7kJp7Fe3oRHHtF5lDeHaESYomNKhFVUCRIZg2PNNYJ0I4gylMnaPsh16SGZaeNnONsZqjBdJErN", - "UigvXumwL46Y0jGXL3++U1YwaXXuXktkhinsySMyo+ZoqSpDdmmGkaAzIjziOz9RjSg076E1vde1CGGc", - "kfUKpdiMRhS3EQcRjGlIPdxzeniMzGN0fITWpuSq2snWk9HToLlJhhMPL/ySJZh19YbQw3Ltw7vltl/t", - "eHV+niTZcCJ4li62fPzm5OQ9goeIgcpYbvHplk/1S0M6xFEkiJT++buH5bH1+/3+Pt7a7/d7fd8oZ4RF", - "XDSS1Dz2k3SzH5ElTbYiqW1/gaSvPxwfHR+gQy5SLsAIWrlxyuQpz6vMNtVV8fH/zxmNo0WuH+mfiRjm", - "h4iPYMdOjTo+cnqC/Q59OEFrWoZEZJRNJpRN1tvwe8g1OfRR5zvEYajIvqPNROW0lBuft6EgeEV3+o1W", - "nS1utcys5DCRTa27V7RETWgcU0lCziJZ7oMytbfTPJnShjEn1EJXz/XPKCFS4glBa+BSAfPDCFOt2Iwx", - "jUm03k6ZbZrM73xUOkIq7A1s0cWjcHNr2ys7Ejwhw4hOrE+sfkTp3zWL6XYUgrf9E4HDvN08oEtBxov9", - "vQDRDZ0IMiaCaB7/yu5SwWeEYWu9/An6Df6fjcJZuGE9hRtAzNPi9S+d4I+MZGSYcknNCBckl32i2QhI", - "jeAL/5jh0bK1LnGUVFgs3x/wxi3sxEKvW0kb67bQqg2erPzknX6nLjtBNOa6REkKNIrI51qp8WgHnCn7", - "oOa+5BMUU2YsDq3ambUAvWqekp9iDiLxluiQk39x8+tx30B4mR8aWtPPOrkCHvNJmZpTgoUakQoxG44w", - "21Axukbyn1a2T+2swpIMl0uQU8oYicBfbDe2eVOrsV4zA3bRBVXDGRHSu+dgWL9ShewbjU3FPLwY05gM", - "p1hOrYMtiqhxFp5WZuLR1iqOeAz2uGsQtAiwX89+Odja3UO2Aw8NredSv7A4k9LXunnzLlJYjHAce3mj", - "md2uf0YvcoifAwpnZdPZk3OgY0wj6QK7mtZOzuTU/AWyW48Kzj4tBjR7xfrvj55JH4KQMFZC4+2NXwfM", - "PcOTmGuazlHG6B9ZRcHuoeMxOIj1QUEjEnUQhgfgd9D234QwIrScKjxDJSUYrZHepNdBA60XdrUW3MVb", - "3X6/2x8EVTU23uka8z7FShGhB/h/fsPdTwfdf/S7zz4Wfw573Y9//ZOPAdpq5k4rtPNcc3u/g9xgy+p6", - "faCrVPkbS//y8H0Sxyz1sZYT113pw+NFxcHMNeLhBRE9yjdiOhJYzDfYhLKr/RgrIlV15svfvVVawDyW", - "EIFNNJmuSYaa0QNsvBbzSyJCLYFjohlPdrQQpkp2ENZ2MwgvpE/Jv6EQM70XjHLBBSIsQpdUTRGG96rU", - "SuZdnNIuNUMNOkGCr14RNlHTYH9ve4HPNZOv2T+6H//iflr/by+riywmHiZ/yzNF2QTB4/K1nhtDfkWz", - "bEUcdbMY1LyEsmPz2ebiHdTXrbCbyLKVNsZc41JrIZS7yFYMZPF+Vxtbicd0eDMjQtDIHcuHJ0doLaYX", - "xO4XJDKGBlm/vx3CC/Ansb+EPEkwi8xv6z30JqFKH4dZccqbK9va7RoJpxwUlTjm17lOA00RDBwcLz3H", - "l5HGS+3DvN3FU/8XLlU3wQxPCJij9kU0EvyC6IGaOwFKJLogc63lzNFEN9qdUQk3PITN0Awbr0NvwN5N", - "uSTmFfdIgm+fzghKeHhhrn6nHCz5GY4zIjvocqpVDvAJEhzbn5G5GBuwqR6kDHlKIm2EmNdgauicsNk5", - "SnAK2xwLAnscJVgRQXFMP5krfLhlIBHVJ9yAEdgYKMV6z4chFxHcsHFEcDgtUeHPEp0bheUcmj+nTLP1", - "udmYtcvqz8Gb9+9+fvP+9dHwzenz1wfHw1+f/6/+2XwU7P/2OTChGrmm8jPBggj0p88w3y9GvY2ICPaD", - "g0xNuaCfjLfmSyfQNJCav3BKezwlDNNeyJOgE/yl/M+PXz46hcy4sWd6G3gG9sWrDJmz1COSjpw3UCLr", - "YXJ3G5pkWkS9PH2/oU/nFEuppoJnk2l1Y1jV4FpbIqLyYkj5cJT6xkTlBTreeIO04oJiqjdorqhs9vsn", - "P2/IQaD/sev+sd5DR2bXwvC1DOLC6k9yqtknj/o4PH2PcBzz0PpQxk0XvK4rn4AnTIl5yqnPiKsJp+LV", - "RRnV7RZPryGKNkaUbUi9DN3wenQHvrmxKfGczajgLNHm3AwLqs9pWd0rr98cPR8+f/0h2NcHQZSF1it5", - "+ubtu2A/2O73+4GPQTUHrZCBL0/fm1tPs21UGmeToaSfPKrEQT4/lJCEC2NC22/Q2rSqaZh9i2BxBsH2", - "y58Nc22+BL5yi2LviPJWTMO1a72XP/u4ZTpPiZhR6fOz/ZI/cyu/GO5T4W1zS5YzLXBxr2S/hDHPom6p", - "y04wpoKEEF6h//UHSbQiP/tUvZbyfOd3f7VSYFdopjhOKSNLVNNvREW85OIi5jjqbt6yhmgvVD2hMeZB", - "dX3zmzXHEgsRZyPMoksaqekw4pdMD9kjV+0TlL+cC9crPRMc//uf//pwUthZmy9HqZW0m1u7Xylpa7JV", - "N+31oeQTyVL/NN6n/kl8OPn3P//lZvKwkzCKyI2UOrv+z00L9aAZG0to3KENN8P56Z0HrChuDWr4HDne", - "W3kN7BPUfEZEjOclwWvHFGz2QfrVRiUoREki+50WoxdIf7xCDOvW3CH/sm7kb/X9gtYzKM+Yftaywp4L", - "bUaSD2Rz68T+ubU4pIYRXdB0CFrzEE9yn++ykNCzC5paVRy+MMsYx0YQRBko7yPOVW/ATISKXjtYYHJF", - "QpB5UmGFDk6PJbqkcQweIhAqi0eLVuxLoU3wulT6v0XGOmiUKa2tc0WQtZugkwzGAi+PCMoYdvfhNd3Z", - "TnAxvADIckEEI/HQ6MayJWXMR8h+1EgcmOoYSxuiJlSWVul19OvJGVo7mjOc0BD9alo94VEWE3RmogvW", - "q9TrDFgqIExBd6L3M7X98jHimerycVcJQtwQE2gs97HZy9rZy9P39rpfrvcG7C3RhCUssoG+7sSxQaAR", - "Z3/WO5ZE1WbL/deI3hTSIRlO5ZSrYZoHTy+TTmf29cIUb+9M6ASzMM2qS7rVaQwCnVGhMhxrWVtRJ70X", - "/CaI3WM2mBj5svli5V4RNKuqN7NtPS6mZYho94bLehwnRlNq7TgpmfILLhRnZ35uN9gV7R8zN5CljqPC", - "1PyKvs5MIwvBO+bnjpvZDah0nNOk5m66HfIcyJJp3ir43MRgGY1QorVzbc1bPtb2+3kHnf+l8oPe+860", - "0PrFJTLUAHnC9E/l9utOiZXugmuFe5cXB8ubr8eBbIx0QrNNpARm0sSoTXFKeugXEOJIkSTVkoxNEJUo", - "D+1CjF/+DXGj1LhPB0wPTZo4EUuO3Gkk6YRRNlnXar4+mHAUGc/SOFOZ0O/NqCyoWWUd571ZiGo1oyNG", - "HkOGBGVhnEUEnTsPz3lVL1z0/yyahNYhtGDhGJKAZQPGntpIMqW71xNOsAqnmk48UyZwzE69GtRX8zKt", - "ulC1Y8mv2m6w/me5uKgnwsw8Jo6enL3kAbdgyT/Z5Aa0iorfRXlB5rDkzh2JFxySZU+k318oiOTxjNhj", - "t+zLHEGqDzeKU+HGNA5J64PU27+e5OLzzq1aCk2v1uSvmgqeFB+pum6yBcdY7d/FhDsppCdn+utow1gS", - "ID6YHvsI1LHzjrGVCHggENPMEqOIChKqheYpmwwYxJCc2196trVzvcm1jnIriVOQhwBKe3lpUWllndoH", - "zeip8YQqRaJOVTe4ICSVqyel1WvruPZ41wW5FNQJMhdU3FI9I2zMRUgSayR8neH4vNSY14y7XhOLIR2G", - "vqUxu/wMyE4hkYkfMusBbtZK2kY9ezGqWW0mhKDa5TmO43O0Zl9aR4L8DpH4dq0YZwWzvzs8dSyQX3t/", - "OOlojtRS4HyqVDrU/yWHehef1xuz37odXmSWPe2DfbWzs21X1TrdzIBrzVb9a96wiOalcep3482a5gs9", - "Shtn0kaVPyw+KTypF5RFbRv4Vb/b6J3LFSNnady1gy4VpJulE4EhxPY23XM3vjcFajZL8BV5vL4wySJD", - "MJOKJ+V4+7VaiAetBoNUiTXjcTfCCoMrs6W/1Qx3MfA4mZumjC3W5IkZTkaeuCH6CVIBJnSCR3NVvT/Y", - "9Gbzfe0lthuLb1maAviNBUmioeLLQ5jpGLl320QsmnwDxYezMeXL0zts/Esl/84cR9au1U1005BadwLo", - "OOHURJgaIoDS+OGkfHfXG7AuHL/76CjvIG82bxKDbokjc3OyxkVpECaRA43m6wijDyc99C4f7Z8l0gbL", - "jLiMhimWaEQIQxm4nuE07JqzuDyATMKhqeqfW9+JSX5YhytKbp/18pxj8NLkGdQQKjWitfmYzElYKHsn", - "jFnZC9bKa7Us8PstmVCpRC3sG629fXG4vb39rO6/3Nrt9je7m7vvNvv7ff2ff7SPEL/9/A5fWwdV2WKD", - "z8rS5/D98dGWdZZW+1GfdvCzp1dXWD3bo5fy2adkJCa/b+N7yQDxi7KjImoOrWWSiK4Tk5qrfLFypZC0", - "hli4G4e43VHEWhGAu+xdQ4l3+s27SG3xBU3bkN3rJ5/UBebKsOvS5BYt+XkKdmexS0oanI1uDKk3jvOI", - "youfBcEXkLK3eG4neELk0Jxn/niGTJogG3JlvRuCczWW5t606vXc3Hmy83R7b+dpv+/J6FhkeB7SYahP", - "oFYDeHN4jGI8JwLBN2gNLrwiNIr5qMrou9t7T5/0n21utR2HueJpR4fc8HJfoTVLkb86nBL3pDKora0n", - "e9vb2/29va2dVqOy/uJWg3K+5YpK8mT7yc7m062dVlTwKfTPXYZNXYH3ZVYemOx+/a+uTElIxzREkKOD", - "9AdoLYEjjOS3VdU9OcKRyz/1nx0K01gujZgwndk3jaMtyWJF05iYZ7AgrXzRMPMjaMmLkMFYnu97vZZs", - "XtLKCAE3l/wVVMkvq5DuxCQ0l5QnSuJo3+zQlXIOVrMY2McmPrBzaMkNr7Tp1I3JjMRlJjBHl8msFQTl", - "fGIWrTIrymY4ptGQsjTzskQjKV9kAnRR0yjCI54pc81oE7SLTiDqGWyPsRbX7ezcF1xcrIwf1Sdxnoe+", - "0it0AI70sXXVwCmOkf3apSiUlL78OtBcmtrnEr01XxgPUfFzmlVRbTrQk/UkMSSIVBwkqXUY2mbaapd+", - "vQWcpS78w/RXyM57in3pjk24wO1a2GJCAH9BrdRYNKe8g/fP4PXW4ej6w5WOlBZ0Z+TyPogO8fpdzbZd", - "yXB6NxRfFoyW+xqKl+AUFjQiPQS7C6JiXH5gbaedKZ6mJMr9P70Bs/Hc+U/S3KDoDw0d1JRQgbigE1rt", - "uOpgu8uotuuwouOmG7Nj+cNFDRUeQvhG86bHY2WwFi5cyhQp5y/ZRQg6wVmOTGElUZU0b3N0jwWKFKGW", - "C0N8efr+urFpqeBj6sMbglgI+9RaZi5q69VO/6y7+f+ZCEzNb6CiUWbiJxIe1YAk7PvtTp6Xp+9Pm8aU", - "Qzug8ugW5pRHvCwDt3IUsZdK9lbSWjCO/fXBkndS6N7PfLrsWOCEjLLxmIhh4nGuvdDPkXnBhDZRhk5+", - "ruqzWm9uazWfVhYHzOYxDm1mfjvqexxytWl0StT86F+ut8Qcw035fHqphH3HpvT10OscTAO9PH0vURGl", - "5PHUVZe3MV7+dDqXNMSxadGk51JWdrABc7bWkE+LD60r0qMn+zFY3EZAa7NJmsE2PHvbPX7zYSOJyKxT", - "GRNEFk15TPS410vSYuay+org/oqQmDV5OgxjyLYbqESrfAe3JlJpv3qoo7jC8VDG3Bes8U4/RPAQrX14", - "YbKu9Ag6KK0spf69RIUKf+95d4yWSE3dnkGHdZdpZYN7bccqGqZxr5SmV+nUt1V+ITg2IKBVfl4EQOIX", - "1YXmF6tBd0wjvn6PXWB4zajxJW8dnhwZhSHkTGHKiEAJUdhCjpZCXEAdCjpBV59RESYJhNqN/7Y8uqXB", - "BV/Oxmp04h4u4HbciQO3Id/8rQlBiFCCGR0TqWy+eaVnOcVbu3v7BhUjIuOd3b1er3fdHJXnRVJKq6XY", - "MCH8pXSVnpx+3TrcQSpKm7l8Dk4P3v0S7AcbmRQbMQ9xvCFHlO2X/p3/s3gAf5h/jijzprC0AlKh4wUA", - "leqVpj6zzO/7JcxLh+/XCtfOb89AZAPkzXnzjRWeaPvEcNzXJhbfGHqkwL9SJciRckBoC/gR+mm5J9Qp", - "RvCO7TNjisYFMsuiD/RG2DpyKfzAAvRASlgOOBDH5q+Qs5neFT70gYoAd8++6v7ARrkMI+rh5L9ba88E", - "SUBW1er9FmzgNF3Ntn5FMZd/bVFXbG605yR6cKl/kzu2au9vJv/zx/8vT5/8vvnHqw8f/nf28n+OXtP/", - "/RCfvvmqDKrlafEPmtt+a+nscLFUyWlvy0onWIUehWrKpWqgsH2CFDfxmj10CIbf/oB10SuqiMDxPhoE", - "tRDhQYDWyBUOlfkKcYZ0UzbTYV1/fGrcP/rjz862/FJvI7IpDcIuSJ7JJLNRxBNM2fqADZhtC7mJSLjT", - "139FKMSpygTRq6d12HiORgJgva15XnTeQZ9xmn5ZHzCwcMmVEnoGKRYqx/FwPQBT2FGZmAH7OolcYrix", - "kAcsP5fyvHDjo+nlThDwzdcjLv1E8ZovXFRTcZ72fRn0EPWlFzKmUhEIzM45W7NRHo6GnvYrouJp/2l/", - "pYKf89AS9oOdsIj375iyxV4yDAxdG8ENEWotfOlaNpk9gn559+5Uk0H/7xlyDRW0yJfYGHkmBlAaH6GK", - "ZSn6bz3woo3C6rackHGSwWdxi6yh5yY89N2rM6SISFzA/lqoyTmmoZ4fXP9TKTPNihSjg8OT5+u9FgUL", - "gLb5+Jes47t8hvXkDus0a/IF5hyv6dtBx0cQnmt3aKHAQVjNCy5QbARMsa/30XtJqrGusFTmVt+sZDwv", - "PG/mBBgE667FtC4p9tHbXG/E+VAqRRKqzrxiX0Kz9uLFxPwstN5ZgB8Xzi6yog0ifLDKg8T1idssCpZv", - "fw/FYc/buO6ST/N6e7vsDNWd+VmjWPvbRk25fXVn+7pG7nURHqpJmKUE3hzkoT06w12gHCwafFdUDRtv", - "8ZF+bO/snVnz4QRNsWR/VvCwZtxsbj9phdepe217/12++eZjM6R8W7qMzvze1uS2XtA4NuEQkk4YjtEz", - "tHZ2/PLX41ev1lEXvXlzUl+KZV/41qcF2IPbGy9P30O6DJZDd4XUHDWJi8hjckWlkosJr61uYpeDS/xS", - "AYDwZhCv3yIqhLu+XpjGfeA9PGRc4LeHNbEUHeJrIR6stnxHCA+NwtWHjlCVs+bn28VquJPhrCwvUlYq", - "XND2jcEROgH1BKweSC0CSYSOTwuQxcKr5ZqvzcnW6tns93ub/TY+vgSHS/o+OThs33l/y3gy9vFoP4z2", - "yfgrfIyWsY32h+NLPJdo4PTzQWAMgpIlUNq2VodvdX+7iEFxM8iJukKxClTiOiAS7dAhvjYlfxnU8lkV", - "ZLm1kvcVlUhahVC4o90GT9ivhtdxnxMU8iyOtCI10lvXGHYksvanJKrAr4bd/p5dMH7JqlM3XlQtAP7I", - "iJijDycnFZ+7IGMLz9ti4hB00bAOPL3WMmyt0LVXjuaGQA33Ac5QF7ul4+7WoRjKTj8XxGk4tIXzr1A/", - "vRfvlJml0XyyZE41t01EZsMs82lV+pFL3Xj//viowhwY720+7T991n062tzr7kT9zS7e3N7rbu3i/ng7", - "fLLdAJDfPvDm5rE01d3cnCoFhAcXqMmEi/b1fsuDYUaZQnmgnN7Ih1o9RSU92CQGgVfimFEFIJCUTXQz", - "4CSwarLJ8DQ4lZRRBZACAGhDmZ4yeGN0Izb8aR+9hHfhEU4gYckNQhtHVUcEjubGEasFg+s6hX8tH/LZ", - "NINyP/CNnGYKQXkoPW1NBmuuLG/CyJh99JrDN8JFqTJet3vM6+ATWHy9biOt2bgkF78KnVmBuY9e5EIy", - "F7NWrK5JYv80stuGVkPY+HoleM+ueKC5pVi5UlxaJzAUDTqBIxTEry1GstlxeZM0yqzou6EgOAYRWkQK", - "ZYrGFiUBZkKhQBJMBMPiNu1kiwhGoqFRAZruG034iVUT8o+coPhwgtYgH/KvyBqV+l/r+d1keVfubD3b", - "ebb3ZOvZXqush2KAqwX8IQRHLQ5upbQP02zoao80TP3w9L0pcRhyJrPEeAns3EtBpqngodZWKUNFMZOi", - "82e9Z+Vkj4hnprCTHZLNDPtSKl+2tPJMwwXbHzSe0fGY/fEpvNj6XdBk82pPbo28xl1RJ82rCR+XXa0L", - "ZiMZdQ2Koz8eHxhKyMaUlbdEwgzQGVEI+KeLcAiHdB7TZFnOJbZYinsZa2d7e/vpk92tVnxlR1faOEOw", - "XxdHeWJHUNpi8CZae3t2hjZKDGfadIGeADDBrALn32fIAjr3q5VAe5v9bR+XNOhLBdfYtmdJI8k/WCXI", - "TsoSHUKzcgVpYZd7qb293X+ys/t0t902dnX3xNVyCeNAPQx5LA5KeeXXwD3/7uAU6dbFGIdVC2Vza3tn", - "d+/J02uNSl1rVIDhY7A3rjGwp0/2dne2tzbb5V75XPA2q7CyYauyy7PpPEzhWQ0PKRZFb6fptPApnobB", - "3pIwxjQ5CF34TO30MRgbQ2FeKxahzcFgnQQLB1eLb1uZaLXCQUY14AKVKi72VrtDb+bdbBbT5jxYLcYX", - "degYM00umyRgoBxvQLtUkBnlmbyFhrgioWamccy5uNa3TfFIb4nMYmVckFSiDyd/BiGimQtJRdJqrL1l", - "vyWpFDec3LU2cIUn/FzdRKxWq9Fm6ZdNuNOwTTvL4mgr278xYynSoipjq+++D3EcZgBehvP11LOC3AOe", - "Kbipn5sokTjmnKFwitmEABi8gUpkE4TRlMdRL/BflcTRcOy9wsgrzPOifrkbhP7M1d9fe8mLknaGlWr4", - "vLuJkSoWuanXopZ8URO3IcNJ0xMrXoIBMJ9UrPmYTyRYgQriX3p19JkUCxPWgpnBqZslxnispm5t6dPe", - "M8Sa9PYdoebo5GNr0VodQ/GckjgUXMqiMPeHk+owlwUw5vXsV99nVwfbgnVlypkk/jLxtiZ8K4eP70D0", - "RIZ9zZEIPAwBoMtqQFscwwSzDJC+SoxMrlIqDHu0uxyfcqmGeTrKNQcr1RBQnDJBipw1d15OIQFgbkQc", - "vOM9F51ouwm58vLGN/h6gav8TTUNsFmmeinqp1Yn50EfGy8m5CzNASqSiuoZJNdJGStgf6iEVmkpWwmt", - "Ma4qYqkEXbPe5qLKb6PqfppKyr7a6Z+1zeZanrx1itX0mI25BxvyGg5/GxLvYhdSIqD8OGcoIoySyBmP", - "ueff+rYgyD6WBEUZsZQzCqnAluDYbG/AgGTOKUbZpCbr6x22ccObMSwHeYJ+7YttrhylPzT7nciAViZI", - "QCJcBGm3inigcuj3FC82LMgki7FA9YzFJUOW8ySm7KJN63KejHhMQ6Q/qF/njHkc88uhfiR/grmst5qd", - "/mBYxBjWrmfM4GyEqVmQWr/FFH7Ss1yvxbeD62XDfL+hv291g+uNG3pBY2KT+t4zelVi9CoKys5Wvyn1", - "oaHRStLDYkLodSW3ZVnfjne5mgd51QRPOL6JAKrdSlQdkZX5+mYLIWbLEj0WXTFozV0KO5SZKl1LaC+t", - "PCHtotzq4Q9uNBuShNXed57uPtlrCbfzVb7OJVWVv8KzOUuWeDQbVuqkjdvs6e7TZ8+2d3afbV3LQeUi", - "ZRrWpylaprw+teIoNafZbh/+71qDMrEy/iE1xMtUB1QpdHLjAX1ZsnWLNOuGa49GnO+4vJLunqXqAW3n", - "Y1yiLR1UVK5SLa81Mh4TMCqHhm7dYjC18PxWYwhxikOq5h6HCb40kO/5K7V04TbetOpgPSS1bVvEBy25", - "ZDYqAjrXXOfoL8a1XuOFp61Ru2Q2anLjv6n3apz4hQ+ofEXU4oamKCyw6C7I53OJZSWqQ/8dAmZzUaut", - "Hj9k3mhfldrxel6YuoiM9KW8+4tQl5e/tpwlt29FSa5TfNkR2rwFr2VDe05kX5nK1VG5NflgD8CbfTUc", - "lfH0lgIWVsD3ilP3+v22qzK3+J05wa7fXykE9Dof1qHFgB/tGCzJi7Y7FZZo4CbFxWpE6TsACDIxBTeC", - "CLLhCPeCEmR/vhNkoIXlOCPKvXumLfosXgIIzRQRM+xxTLkmkHul6kc1kriDrIsPbSbrtVKFO1O/rmZT", - "eFuGj2ktcJgKMqZXS7jFvGCO62r4uLQUiKqg4RKtJfgK7TxB4RQLWRs7o5OpiudVJ+uOJ3vi64o4E6VV", - "5/bw6sVqug8XbzTscpZb923Zs1Kugx/2nUTDZYnuh/lrzmec4jnolo2G4JPtnX5/e6t/o0z320KjL7XT", - "FBFa+s46cypXj+UW8vjPRcjCS0FNUTNHJqkEwck+RFOlOCQoJmPIA8uhYlfa9AtdLx+8vSS1gf85/7uF", - "cpVLrZ/FijjGGSgerh0LEuCmEbhb2mquR/n54rCXJIvlYiZcyBqrx6/udfvb3f7eu83t/d29/c3Nu0iN", - "z4nUFMLz5NPm5ZN4C4934qfzJ39sTp9MtpJtb7rAHRQ+qNURrNVBsHNIiahjUdYxXCWJKSNdmYe9rQ5A", - "XiILzE3Syv1/Pe+DmcFSZeGsOsmyzoBVQZx6Sbb7SGyyo1/qQqkP//ho+bBvFEdWH4ifwepDAX5qNxiA", - "atn8WlyQjLU8d96XXmx98iyNbVx19viCvmFre1e5geI+fq4IxsoOW3ZiL55qHhNuwgVV02T58ZC/lqMM", - "wGX4J6miaiJNDx1PGCDPln/O7z7KxaH1x0EniD/tVPeM/b19SpXNqs8Z0C51WQ1ocTcAwMbLqQCvFKaF", - "MOEJWBAgxE+b3c1ncEMff9r5qd991kN/L0UKdAy1yuTbdG9Xfu23oWEuKEHvNDfnm8+udY3u6LmMg361", - "51LTQWzz7S2PF7Cf7qxwYdOVBS4eL6xxLavozgoN2dNsWNaSIhLjua9YQ4znaETGgG5dsw/LTIZGZEKZ", - "7CBy5YQOlgijsink6rr35SBAXKBBsJsMgh46sCgVYK0WqM6V5gHPt8QnNLE1piyib3NYylbSLn+ibjxc", - "D7rIfeVRz3p+/ezZu/7mtaGLrndM9r4iqvqrzN12Jm6MpWqyLV5hqXKbFInMWhgdKPPDatX+LbS6TYeA", - "8FbAG9hHsublcJjyslD8nCekgyZcoSIRYqWmB8MXGfPyQ3X8RalmgMhoZIitFQzRbkx5MiNdJr6Oj1Aq", - "eJSFRRRwDIPOwpBIOc6g8nSvrVa/+p71Lh0aEF4/5gKtdmg0eTBWp9qSq+b1fk2uVKlLzbDNS73ZX73U", - "d+IF6QRZGq2WYealdhLsWmgkK+JKPT6ZKtlrmmBpMh9bSPS3ZQouGrlQtAqFWiXKUldFUfPUIidJT+1E", - "fDX04iQckZjoY2qxEWTKmtrQFyoLKbpapG7uPfW7DfHVMISkzIWB/EpIqm2VhEtbZjTBbO4dWB1JHK31", - "XRVNiaD5rkEzs9SqDu7JSk2scanag7LXvNom662MgZ+jlNwuIrv9cmW9jLvwwz2kkvbGXi7IKmM4tIYc", - "38X1b8J6TRHtuHZe7+zKdjrZO2sZNwEI1UN7y27mg+4/jFsZDXv7Gz/99f/tfvzLn/yleCp2sySiG5Ex", - "3HdekHnX1BjWNnqvCl8L4EZambYFbBTBCTiNwgtinFQJviqPd7efC435a5wsTAEuihPK8n+vnNBf/9R8", - "zVoi43uQkytZ9qvBru4CSVhxdxytJURMHFy/iw6E6u3abrggc4lKcIVWpXGM+meZf1KuE3xu1MAeVLce", - "UUB9lQOmrVochiTV1oSFbaMwFsFB+tSrZVvYRBfNr+USBqxYm11VQ0X77K1JvR8wctk1PURdzXs7u3vA", - "R5SVKbm5sMS+RTcJ+k0FNTWVPV6jV1RC9okLsi69jNZIkqq5AwV2YbDr1wMMOMgb9N583zJaWv/ZbYDD", - "vl+KBvsdlnMt4zm4Aa1EclhY/0YIRn8c3VEdmMnsSVuirgokVLMOpeo2h9klWp0ZQrToYkicfmYiUS38", - "6SSr48BvJExtWLBlX/ZLBBWol8YeF7vMgRt04aPVIbVLFerSzEojaV6bE6c31quCNxPoVJPmckoEKS0E", - "fFAgxl6TZDYutEVOlYFETYno1msYmjIbgkKgaW7yOxLkscOLftDlgEYn+CrvAXzoWC7cNME8Cmi/zZc/", - "Q+mct66WHR27JmAYNa3ej05U5aI21fgXF6PMVYvzNu97N56VVUukX9PeqjFn0UeFNX38+HdM1QsuwA5o", - "zmC6c5AjsDEiIiCFuw5h1Ar/hyYkGvJMLd//tqaATV+KnCpfwC07mwcDE9sS1ytkgcuxKcbw0ac3SBJm", - "gqq5NpKtSjoiWBBxkJkND4SEjuDnomNAL/7yBbyFY0/A4kvCiKAhOjg9hv2YYAaqMvpwgmI6JuE8jIkF", - "n12AWwEl783hsbUzHcAf2A1UAeu5qtMHp8dQxFYYWyvo97Z6fdjMKWE4pcF+sN3bhJK+muFgihtQ7AD+", - "tLkIub1yHFk96Gfziv5K4IQoImSw/5snpl8RYYonSNA68aRkN6SYCms4pDFkGhhWofpbQLtyR+m+OY87", - "huCt3WRSzW3cJUnf2GX9qDnB7BqY4la/b0xSpuzBi4viphu/2/zMot9W+hyQxwP9tKDXO53SkvxLJ9jp", - "b15rPCvrkfq6fc9wpqZc0E8Ehrl7TSLcqNNjZoLBkYEVseEu5X0GLFTeYb991OslsyTBYu7IVdAq5bJJ", - "GSbadmfk0lbu+J2PesheAgDarZzyLNbSBJlId2fuKyx6k08Ii3BKZ2TA7DltastiAcZ8gvT5bMyW6tYw", - "XZvVz3MQf+bRvEbdvLkN3VzXuX4LAtdRNSUZAjjYsKksT+H0pYxBeU9JLARpXp9iMaYG6jHLkHsLUROG", - "mSrK+5pCzBdkbv3K3gZbofhogQfLQqDufw5Pv7XuT18BsFR/5tdR/gxZ8lbVCQaXMWGcRYXO5SKqsRjh", - "OPbCPExiPsKxrVd9QTwq6kt4wxKljCvrlBvGI2IwQtO5mnJm/s5GGVOZ+Xsk+KUkQqtAFmzc0toWa7Ws", - "ewmwYAkAfptSJrrPDTPEjc8XZP6lN2AHUeLK1EjzCY4lt4W8DVoSlciF4Bre9aPZNkR3HGZS8cSyFCvX", - "HTXD5JlKM2VvtiVRFiEdXoeytHJKogFTHH0WZEKlEvMvG5+LHr+A7UJwpPmk9IqZ0sZnGn1pGrUcYj37", - "Ibzqsf4IEGAQ6NNlEOi/JwJr2yWTU3BlSHBfTMpLupan3mu9cL1O4RAzlPLUwBYAU5n65JU2oNoEjmOk", - "YCu5b7W2CSvZMB+bieQrnWjTkEzeSG0bQRHF0mbq7zz17ydJQkF8Do7/OXvzGsFRpdfAvFa4jczVMtOn", - "KIoy0OSh996APcfhFBm9CaDpBgGNBkFuXUTrMNZM2jjpbhdU3J/00H4y3XRo9FOvp5sy2vM++u2zaWVf", - "76U0GSp+Qdgg+NJBpQcTqqbZKH/20U/QpmyOs4ogQGtG9q+7WkGAKlEcg+bcwCxC3MraeI4wKiRQ2Y8y", - "ogyLpYWOPKS3FNSmPJ7IMjE+D8CDOgj2B86HOgg6g4CwGfxmHa2D4IufAlaJbsZBM7WenK6dM9Fev7++", - "Os3S0tejQlde1Nvvy4L2tXVriodVuhYVDzM5B+KoV9BU7TLq1j1oPj/jyNWB+KHirVDxrOeipLzB9+Vz", - "wLBvTIyBW9PAtD0bOw1sqXVi2AJQTMHicEnRxuCgToMrmLdsftTN+UWzYqdpl4UwxNjx38498B/0W1S+", - "h36f3Ve/OAZI0rwO9ONiR1gsx4gdv0X8kqhvgeP69yVKLX7qQ/LvY+Gfl8TqfQXRatJsg8zcfZMf+gFS", - "PqRtxbysbdUzGFP3jDCFnsOvPfu/zuIBIOPzmE/O95EhYcwnKKbM3saVbov0oWhpCR+ZrI/8O5sE4nC3", - "1sz5+e9//gsGRdnk3//8l9amzV+w3TcMGArg9J5PCRZqRLA630e/EpJ2cUxnxE0GkDTJjIg52u6DmpkK", - "eOSpLSoHbMDeEpUJVrq1NBBY0jYIpgeD+VCWEWmzZvSLdGzxOYyD2WPCu71sSHmvO7qzGGJsZlCagD4V", - "HQ9AwjU1YMXW/gr83jMz54r/rO4rX/CYrpYvilwpw71dM8BrChggsW/fwQM7abR2dvZ8vYfAxjBcARgs", - "oDEXzVjlufdDJq2WSUaiVAUKUNnIplJZ+Ub/75F9p50D2Lb4PXmAm+rkN7uAjcuDCBI5ev2wFdq4g/10", - "c65hn3/2yOVKNjtobz7fchcumqiVIXx76+x4b5Hm5kmJZA9hAqM1F5PuSjyeHh67UkDrD8b093Jq6Jna", - "Ahr50YG4KSx5b2bZIWfjmIYKdd1YoIZDQnJTrcogj0UcvLWjRtjNq452WD7fNirgPY0nXY7jUxx5d396", - "1Dq9zjFSIDIWvPbjJFnFOkdUhlx/W+KWbohTW5/SqC/5Pi1z0SqHlAlxz4+cpeqSFc/HR25D3p9rynad", - "sfrZcA9C8agmEB9QENZq7pUwTB8TN7/PV9HhQizxXH1brNm/Py3ovr1YPjZ/TG6sqEY2LQUNknPjAfqS", - "qF/MG3e40LYHz8TPiHC72kFOw6zzaZlPUTgl4YWZEFxIL7d9j80r7Uxf0973ZPkCea6jsViS/1BRWhi7", - "Ba2WGbjHto7g3dm30MO1zNvbu+e1DOYhMgSbjJzH2pTow3LOwvXv6qr3Xk4zQ+xHeZidZnHsbjxmRCiU", - "l+sunwEbnyEsabVu73bb0uPg/dtXXcJCDnFoeQyVX4myT25ZwzcLZqbyg03a2IQmOZm686xJw/mK9Tfh", - "gigvB/9fWy9sQfj/2nphSsL/1/aBKQq/fmfM0r8v0XzfGvcjZj6tcNMq0UA0MSgNu0pDzd9qqaS6978r", - "PdVM+lqaak7XH8pqG2W1TK6l+qpdijvVWE0fD3QlkzObj9rwyMUnfmea6v16+SxHOrhmKqvXHrYeDxfg", - "54VHlKFMkkcYQElzjisfGy3d1cWGXHp8ONY9PuoAITuadICdZBNE7sl57cZx78qt7ff+PdcHyYhOMp7J", - "cu5JglU4JdImK8WkKoAfm9pdHM+Nivc3zKX9+zw67l2v/sH3d6Tx1xfUCG9zA7VK53dvtdX57fta5zcp", - "1DZ3zQI8dRz433pDUKFLom7LxpVc88VgR9+4fLYIeq8NlcJcQGBB7A/Yf2v74zdFcPLxJ5ckk/X7W3vw", - "O2Gzjz+5PBl24liFMCWoxWo9eH0E134TyD4HONciJa8+DlP/AVjPAdj8xxlIxc1newvJceEPC6mVhVQi", - "13ILya7F3ZpIVRCse7eRHL/5CG5BTH5YSfdhJclsPKYhJUwV5dEWgsRsdcVHmFvG7P1QKbijctC2tpLy", - "TblCAS3A+e89sOe4QCO8b+PI1QF4nDHyPLXA2tYcKQ7DZnvkW+OH/v0K5/u3Qx4zixmFf5F0qdYpfVU3", - "AekxyRQEJRYIIRD1iYTR2vMWe6godimzNOVCSYMWCQqwwZOfagXYhyxZBYv0oUMCBjAlsjNgUC9APza5", - "/BsXZG6wIClnOexjPlOL/+jLvapicT7oNrp9HcsPNNpKx7rnbWyhox9Ox3ow0XEvmtZxBZF/Ld8YYFCO", - "SL6TeZ7cRz9RNll/VBGoRljlcyvhGXlUrQ2ot2fRdTdkXte36aAtAezaapT/gSfu4iR9WrvDoi0REEUU", - "TxiXioYucbeOWf7jhG59Qi+nrJebx7aaqt+gf8HFRdsjzlPd6xGcdOUZfoO+BD08QAN7eJcCGNvmNNBM", - "c++n4ELJtodMwaD1czGMs0gfhO5AdKrkWPBkaH80eLV6V1g0UHBRhLbVhxY2uvd7cBi95grRJI2J1uJJ", - "hLqGm/RqWtXfgb5TWSpweD1hqLdNOSHGgNFJVyDIiki4XHMLtgb37IvL5ZWaMZ+sBsHIO3eIDx4UjAEz", - "oPTEIdifo1zIQgktEpNQocspDaeAiAFltaCuKoBV4DQ9zyGw1vfRS9ipZSQw6HxNEqENoZAzyWNigC5m", - "SXK+v4jY+uHkBD4yYBgGm/V8HzmU1vyAkPqtMsJFXnnotcXtWNOcJHgcmxU911ZjaX7rFvuigCgbMB8O", - "BiOXtkE6RuclSIzzBkwMJ1Bf8cmDaVudZmBJMxfFkQDCGd4kLAqaLmJo7EfD2Ox7q7K0ROYww7hjYI6F", - "wbzikxzUssLKOE3bsq8dJnDxLEmW8DBaK5VIlSrimfqrVBERAj623N3E3GgNh+YfCl9oRrXlffIis8B+", - "3utGgzLnJZUWqqVaNuZfsyQJOoEdTwmd7hra+wqEk3qDi9diemVKMCY/9O7rAJRUhX0JoaR2ctgi/M0q", - "91vzwnfvn7WEir4HL0v1PqsYBWVFGSYBddRdLaxHhXQAC7mgi5nyRL494mbZlaUSnu2utxaKf34DRuuq", - "W6+8kmNeZvK+r78WR/CYk2DkwmzGXNTT41fdi33zjHR7S7Iw1TYc8oM3r++ea8WYabakoicUJJXg54Mq", - "l4DrHE45lyW2H5EpnlEuLAK79brmnAkuC2M92ui5c82q59Z/e27V833ra0K4/Mj20YPPbcyd/wv3qPji", - "RcnaziV+x6nUgAIpEUYjQckYpTiTRGtLWUKQqTBigbwJDqeuZndvwN5NCbJVKksOhLyoMZXofDM576BR", - "plCMxQSsHfPQRNIJEvIkISwylWcHbErwjGpTTaAYK8LCeVcSqEQ8I0UBE2262xtKU/A6r3XaQa5ELjgY", - "zksFcM9RKggwkTGXWaXa7ICJjP3NIFfqZs/dQM8RkQqPYiqnea2IEEeEhV5YyLNvW4zdvhP3jKjFGrEP", - "cmd5I1n6kJeYZV9mXqX7m7jffGSBWly4+pYtxPwSpVc2m4bVyMezoi7uf+CWNnN1c3ygm5mcxMt28bdx", - "JVMpjP/jWkbZLRllpjtSLR7/3d61FNWcM1a5brE+2ZteuOSVEHIyX0vmbXx2fx7fwEf2jUjCTqNh34S5", - "XUz6WxC5lqo3krkP5By0vqSSV+wBRbAd1MOpT1yUpNw3IYbNhsulcVnmKIHBpuLshzCuC2MbHnBTYew8", - "rgsX4CXxTFk3jXGTXC5qx/sFsHUI/IdGv9ZmVxKEDy74ihuBexN2x7l4MwIvxfOY4+/9XibkQpiETluO", - "+PEAipV8gaULpjXwuHVyCdFx2SQfTk7Wm6SEUEtlhFCPWEJUy5qGiada45sZEYJGrnTk4cmRjV6lEomM", - "9dCbhEI9xwtCUigUQ3kmEWTm9vT8XGrrYhG8Sg5rJyBMiXnKKVMrR1G8ejeD+XKj0nn3LCctpOJ3f3kM", - "XvjHJ6RAdmh1xU5guRWpsGoMxnPBaZSZepda28IjnunWtWRxhXYncLaNaUzkXCqSmMi8cRbDJgLQXVuT", - "yX5nMko7iCqJ9H7oQAZeSkRCpaScyQGz5d9TInTf+nMo/lsEGXmd9wrnUvPUiL5vI4BND8bEbGHVRDWA", - "FoA6oMF+sIHTdAPKRfuDpOzwvmJILyAiDcl5MuIxDVFM2YVEazG9MEYHmkkU6z/Wl4a0DeG72644dfOd", - "pSl9zMbcW5TD8GzOzN9HElJVrLlLxEcn1l6S8mZx8gcW2i/W5Eq5JgiOu4omJE9+R5miMf1kRJ1uhEpF", - "Q5NXU6ReQhFmm305YCdECf0OFgSFPI5JqJxzZSMVPNwYZP3+dphSQCnZJjA4EHjNjxPo8fD0PbxnCkV3", - "Bkz/Axp+d3BqbmLH2PoISgNlRF1ycYGON96sCPI9AzL9B0fJmQkuzYH0LviP67vrZzY37iHZsEV5uswA", - "4ul3H8ZpNbgf3oLH6S0AaIl8NmsTgUNQiuU0UxG/ZH7PwIzHWaL/Yf44XgVQonA4/QCvfjParhnOym7c", - "BB/FprRziogpGvQgFxSGYI81vlQTzk0BlJhK5J73FDhQ3yN3375TvkzHb/Bq0lLUFeT6ZvbWfZ98dgwO", - "d6tMj8eyzQ2nuZkovtz7dIlps/fp55iHFxJlTNG4Amqg7TbAAdU/FriN9uIP1ATIjnSlxBG5SqkABJsa", - "PAIiesYSYaSISCjD8QbM2TQCCJTOi4VnnEKSchhTSBOjEUEpj2NA2bmcEob0bMBR5Roo3dNKWwGi/E75", - "ilFxNCIhT4hD5Vz3mW5/x1S94KIKsfmtyMV3Jfrr+eip6nmuQBVt7vGrUEZP8BWENUeZvSZ2I1p7yYsf", - "jSuog2BtBsF2Xw6CDhoEW8kg0CtwiMGFihXaRQllmSKyh46MfwvSUPf6SJKQs0g6cFDnwdvuy6akVMOW", - "DRmOe/Ddfao9lquAlG9tJz7xoN9D+ntIsEFr5Q1n92TUgU0XIZ4pCOB2+8q+FREF7pH1e7+BLe2RH7Z9", - "G0n+d7t9KzIKVlmLy9LSG8mew0eu9Lq5pIoplwXqJApxikOq5h2E45iHhfcgk/ntQDcfykgQfKFtqN6A", - "vc2BK20iBDo8fd9xTjMUUXlhWrB+sR56MyNCZqN8cAikgfHgwWKQaMAURyGOwyzWfEvGYxJCDkNME6pk", - "g18tH8pdlkEsOvEsvHuYw9Y8LmeSnydg9Qq2kDWO2zBLvSFIGGOalJ1KdeKA6gtXuuD2HelGuT6Gx7G9", - "3goFlxLZprokphM6iu1ljeyhd1rlwAkZsDTGjBGBMmnijvTQu6kgUmYmMUY3AHVmDUd1UAF0kgqurJs4", - "5lxI49nVHP7hBElF0iVs9ta0fAJzviOYYNO47emBDIbaGJqPJfsK0gtiOMUQXPORPqYfINjHDOih4YQf", - "y8Z/J+hkQoTeFdgIWXM1ara1I6fZ9JVMj0aM/LP8rXYY+XmrpWjuUqTzUqCKoXtxCAr0dW5gPZ1f0EYs", - "E/voetkXv+qPWvZdjfL3D8I++spZfi+lx85KwdVtkfULDn9sIPelkVe2aiVBYTUcQeuMhLvMEGiNO/Bg", - "cAOPGWUAV9IOmuAEvj1G6N9vdtx9w2w/bt6qoARUCus0pEqthu/8JjjwbnA7Hzg79Aa4nd9UvhLgLj5c", - "3ug3lalU8QO64iHfPTLnXSUoGXhOgLFoSlAyUs8GEiw1lD7Yd9qZSbbF70mDt3fP19DfHdl/WP0tTIYS", - "sfwuO5Mb7XBbSJKqubtc5OPaBaCknyAZwwf8kMcQ3B3ewg2u12+PPRyfNl6u/6indW/390XR4eOjx19E", - "q7znKgfLhj51uliEUzojzU736g62JEoF6aY8hcuVyBDM0sOdZQqL3uQTss1brCr7L0QdxDGJUEQFCVU8", - "R5QpDhLB9PFniQTXlgA852Luc6aXd+4LwZMDO5sV56HdU9YZVtz5JvNuhBXuzpy0WeJC+4qbdne3rQUe", - "ogy9/BmtkSslDOIuGmvLB9FxTlJyFRISSeDJ9fKAN/sNnk36iQwnozajXIKd/MZiU6Mwk4onbu2Pj9Aa", - "FFuYEKbXQqv6Y9BkU8FnNDKFSAuiznhsqLrZQNDr+l21UpFXynDGhRncg+gwbQ6kySeaVsWCCV0I9oMR", - "ZRgGtxKluLqnTEKV7g9TSGso9o7jnODHEWYtvzVn7GhO1EaOI6Li3EDjrf845h7zMVcOTHVnWuW0a1cq", - "sl2sassQ0rsAzM3jmO/Xbf3h2wmvpPJRRlZa1/ksN0ib3ObfFgv27+98uG93+YdHHI7/kjjju+QqhwZ0", - "iz6GecVDHKOIzEjMU6giad4NOkEm4mA/mCqV7m9sxPq9KZdq/2n/aT/48vHL/w0AAP//ZNbJHlB0AQA=", + "H4sIAAAAAAAC/+y9/XIbOZIH+CqIutkYaYakqA/LtjY69tSS7da21dZZtud2mj4KrAJJjKqAagBFiXY4", + "4v7aB5i4J5wnuUACqC+iyKKsD2vs3YkZmVWFj0QikZnI/OXnIORJyhlhSgYHnwMZTkmC4c9DpXA4/cDj", + "LCFvyR8ZkUr/nAqeEqEogZcSnjE1TLGa6n9FRIaCpopyFhwEZ1hN0dWUCIJm0AqSU57FERoRBN+RKOgE", + "5BonaUyCg2ArYWorwgoHnUDNU/2TVIKySfClEwiCI87iuelmjLNYBQdjHEvSqXV7qptGWCL9SRe+ydsb", + "cR4TzIIv0OIfGRUkCg5+L0/jY/4yH/2DhEp3fpgpfq4wi0bzMx7TcL442deUZdfQG8KZ4glWNETSfINS", + "+AiNsCQR4gzhUNEZQZSNeMYi9O7oDIWcMRLqxuSA8ZEkYkYiNBY8QWpK0JRLBe8ogcNLpPAoJr0BCzq1", + "9SBMP4lWU+lvU6KmRHgGSyWyraAxF0hNqUSU6ach6ZUXTImMLFK2E9AoJkNFE8IztUioX/gVijmbwLRc", + "uyjJpEJTPCPoExEc/ZHhmI7nlE2aiTQiYy4I+mWekgQzlMY4JBJRhShT3M3G0KjgsSeJj7nohHFBhhGR", + "ijKs2x+mXJgdUR39G/gDx6j0LgwN3kdqipXjcsYVuiQkrU4UX+HLKhl/39npPO/3+x87AVUkMdsKX9Mk", + "S4KD/SdPdp90goQy8+/tfPSUKTIhQg/f/oKFwPPSdCTPREiGIY3EspmEMSVMoaOT47c3nECw3e/B/289", + "CzrB9vOd3vb+M/j39n5QntYC4asj/7J8650rrDK5KIPMbhpaRhmWmGRx1r9lyYgIxMcozIQgTMVzBFuK", + "RC2YrjLtvm8pQs7GdJIJtwV9W65CzimWCDMjNLo1eVE01mrfhVqIRfyKDQVJMGWaxguDeOseIb1Dkd1E", + "ekghZ0rwONZCQSmSpEq6XdTRYpwhnKYxDUH0VDbVXtKXQSdgWRzrh7URFqtNYjqh8EIr0lBZWiT3LVIc", + "EaaIyHd4G9JUxGJTxwW5vatRyMX2UlBSFvqny+o0T7SEFyQ0081PgApFRiTkCUG66eoK7PR39rv9vW5/", + "/93204P+3kH/yd+DTjDmIsEqOAgirEhXL3ibZVouv48KKukXkX2xOKo8tOvVZHA7domxVPmuhk1O1XyI", + "PWN6RxMiFU5SvbH1GErEbNrWrsH6OjjKLyXw9lcRmJFrNbQU8s7Hxx/kOiWhPmK42575ia3b6yA6Rhjl", + "MkCzqxGMSyfy/KsmIgiWesBa79Cn0+9BxmSW6rOQRMM0xkq3q5UUYINhQqXUn+Y/RFSajdkJHJMPGVdD", + "kTFmXmREXXFxWX7TtjKkadAJplgOZ5M0CzrLzoEqU0MXJMaphPbsioshEYKLwOia8+GYC7dI+hArSLik", + "qQUKyfzM8lAo6AQVAuTy0c3FjTtfVe/goBfgJWHUdKNXw2QWB15ua3G4+dCWS0ojlo1W6pYZ2Y9lVQJE", + "FE8Yl4qGspXchNNYL2/CI4/oPM6bQzQiTNExJcIqqgSJjMGx5hpBuhFEGcpkbR/kuvSQzLTxM5ztDVWY", + "LhKlZimUF6902BdHTOmYy5c/3ykrmLQ6d68lMsMU9uQxmVFztFSVIbs0w0jQGREe8Z2fqEYUmvfQht7r", + "WoQwzshmhVJsRiOK24iDCMY0pB7uOTs6QeYxOjlGG1NyXe1k5+noWdDcJMOJhxd+yRLMunpD6GG59uHd", + "ctuv97w6P0+SbDgRPEsXWz55c3r6HsFDxEBlLLf4bMen+qUhHeIoEkRK//zdw/LY+v1+/wDvHPT7vb5v", + "lDPCIi4aSWoe+0m63Y/IkiZbkdS2v0DS3z6cHJ8coiMuUi7ACFq5ccrkKc+rzDbVVfHx/88ZjaNFrh/p", + "n4kY5oeIj2AnTo06OXZ6gv0OfThFG1qGRGSUTSaUTTbb8HvINTn0Uec7xGGoyL6jzUTltJQbn7ehIHhF", + "d/qNVp0tbrXMrOQwkU2tu1e0RE1oHFNJQs4iWe6DMrW/1zyZ0oYxJ9RCVy/0zyghUuIJQRvgUgHzwwhT", + "rdiMMY1JtNlOmW2azD/4qHSEVNgb2KKLR+H2zq5XdiR4QoYRnVifWP2I0r9rFtPtKARv+ycCh3m7eUCX", + "gowX+3sJohs6EWRMBNE8/pXdpYLPCMPWevkT9Bv8H1uFs3DLegq3gJhnxetfOsEfGcnIMOWSmhEuSC77", + "RLMRkBrBF/4xw6Nla13iKKmwWL4/4I1b2ImFXreSNtZtoVUbPFn5yTv9Tl12gmjMdYmSFGgUkS+0UuPR", + "DjhT9kHNfcknKKbMWBxatTNrAXrVPCU/xRxE4i3RISf/4ubX476B8DI/NLSmn3VyBTzmkzI1pwQLNSIV", + "YjYcYbahYnSN5D+rbJ/aWYUlGS6XIGeUMRKBv9hubPOmVmO9ZgbsokuqhjMipHfPwbB+pQrZNxqbinl4", + "OaYxGU6xnFoHWxRR4yw8q8zEo61VHPEY7HHXIGgRYL+e/3K482Qf2Q48NLSeS/3C4kxKX+vmzbtIYTHC", + "cezljWZ2W/+MXuQQPwcUzsqmsyfnQMeYRtIFdjWtnZzJqfkLZLceFZx9Wgxo9or13x89kz4CIWGshMbb", + "G78OmHuGJzHXNJ2jjNE/soqC3UMnY3AQ64OCRiTqIAwPwO+g7b8JYURoOVV4hkpKMNogvUmvgwZaL+xq", + "LbiLd7r9frc/CKpqbLzXNeZ9ipUiQg/w//kddz8ddv/e7z7/WPw57HU//vVPPgZoq5k7rdDOc8Pt/Q5y", + "gy2r6/WBrlLlbyz9y8P3SRyz1CdaTqy70kcni4qDmWvEw0siepRvxXQksJhvsQll1wcxVkSq6syXv3ur", + "tIB5LCECm2gyrUmGmtEDbLwR8ysiQi2BY6IZT3a0EKZKdhDWdjMIL6RPyf9EIWZ6LxjlggtEWISuqJoi", + "DO9VqZXMuzilXWqGGnSCBF+/JmyipsHB/u4Cn2sm37B/dD/+xf20+V9eVhdZTDxM/pZnirIJgsflaz03", + "hvyKZtmKOOpmMah5CWUn5rPtxTuor1thN5FlK22Mucal1kIod5GtGMji/a42thKP6fBmRoSgkTuWj06P", + "0UZML4ndL0hkDA2yfn83hBfgT2J/CXmSYBaZ3zZ76E1ClT4Os+KUN1e2tds1Ek45KCpxzNe5TgNNEQwc", + "HC89x5eRxkvto7zdxVP/Fy5VN8EMTwiYo/ZFNBL8kuiBmjsBSiS6JHOt5czRRDfanVEJNzyEzdAMG69D", + "b8DeTbkk5hX3SIJvn84ISnh4aa5+pxws+RmOMyI76GqqVQ7wCRIc25+RuRgbsKkepAx5SiJthJjXYGro", + "grDZBUpwCtscCwJ7HCVYEUFxTD+ZK3y4ZSAR1SfcgBHYGCjFes+HIRcR3LBxRHA4LVHhzxJdGIXlApq/", + "oEyz9YXZmLXL6s/Bm/fvfn7z/rfj4ZuzF78dngx/ffE/+mfzUXDw++fAhGrkmsrPBAsi0J8+w3y/GPU2", + "IiI4CA4zNeWCfjLemi+dQNNAav7CKe3xlDBMeyFPgk7wl/I/P3756BQy48ae6W3gGdgXrzJkzlKPSDp2", + "3kCJrIfJ3W1okmkR9ers/ZY+nVMspZoKnk2m1Y1hVYO1tkRE5eWQ8uEo9Y2Jykt0svUGacUFxVRv0FxR", + "2e73T3/ekoNA/+OJ+8dmDx2bXQvD1zKIC6s/yalmnzzq4+jsPcJxzEPrQxk3XfC6rnwCnjAl5imnPiOu", + "JpyKVxdlVLdbPF1DFG2NKNuSehm64Xp0B765sSnxgs2o4CzR5twMC6rPaVndK7+9OX4xfPHbh+BAHwRR", + "Flqv5Nmbt++Cg2C33+8HPgbVHLRCBr46e29uPc22UWmcTYaSfvKoEof5/FBCEi6MCW2/QRvTqqZh9i2C", + "xRkEu69+Nsy1/Qr4yi2KvSPKWzEN1671Xv3s45bpPCViRqXPz/ZL/syt/GK4T4W3zS1ZzrTAxb2S/RLG", + "PIu6pS47wZgKEkJ4hf7XHyTRivzsU/VayvOd3/3VSoFdoZniOKWMLFFNvxEV8YqLy5jjqLt9yxqivVD1", + "hMaYB9X1zW/WHEssRJyNMIuuaKSmw4hfMT1kj1y1T1D+ci5cr/VMcPyv//3nh9PCztp+NUqtpN3eefKV", + "krYmW3XTXh9KPpEs9U/jfeqfxIfTf/3vP91MHnYSRhG5kVJn1/+FaaEeNGNjCY07tOFmOD+984AVxa1B", + "DZ8jx3srr4F9gprPiIjxvCR47ZiC7T5Iv9qoBIUoSWS/02L0EumPV4hh3Zo75F/Vjfydvl/QegblGdPP", + "WlbYc6HNSPKBbO+c2j93FofUMKJLmg5Bax7iSe7zXRYSen5JU6uKwxdmGePYCIIoA+V9xLnqDZiJUNFr", + "BwtMrkkIMk8qrNDh2YlEVzSOwUMEQmXxaNGKfSm0CV6XSv+3yFgHjTKltXWuCLJ2E3SSwVjg5RFBGcPu", + "PrymO9sJLoYXAFkuiWAkHhrdWLakjPkI2Y8aiQNTHWNpQ9SEytIqvY5/PT1HG8dzhhMaol9Nq6c8ymKC", + "zk10wWaVep0BSwWEKehO9H6mtl8+RjxTXT7uKkGIG2ICjeU+NntZO3t19t5e98vN3oC9JZqwhEU20Ned", + "ODYINOLsz3rHkqjabLn/GtGbQjokw6mccjVM8+DpZdLp3L5emOLtnQmdYBamWXVJdzqNQaAzKlSGYy1r", + "K+qk94LfBLF7zAYTI182X6zcK4JmVfVmtq3HxbQMEe3ecFmP48RoSq0dJyVTfsGF4uzMz+0Gu6L9E+YG", + "stRxVJiaX9HXuWlkIXjH/NxxM7sBlU5ymtTcTbdDnkNZMs1bBZ+bGCyjEUq0caGtecvH2n6/6KCLv1R+", + "0HvfmRZav7hChhogT5j+qdx+3Smx0l2wVrh3eXGwvPl6HMrGSCc020ZKYCZNjNoUp6SHfgEhjhRJUi3J", + "2ARRifLQLsT41X8ibpQa9+mA6aFJEydiyZE7jSSdMMomm1rN1wcTjiLjWRpnKhP6vRmVBTWrrOO8NwtR", + "rWZ0xMhjyJCgLIyziKAL5+G5qOqFi/6fRZPQOoQWLBxDErBswNhTW0mmdPd6wglW4VTTiWfKBI7ZqVeD", + "+mpeplUXqnYs+VXbDdb/PBcX9USYmcfE0ZOzlzzgFiz5J5vcgFZR8bsoL8kclty5I/GCQ7LsifT7CwWR", + "PJ4Re+yWfZkjSPXhRnEq3JjGIWl9kHr715NcfN65VUuh6dWa/FVTwZPiI1XXTbbgGKv9u5hwJ4X05Ex/", + "HW0YSwLEB9PjAIE6dtExthIBDwRimlliFFFBQrXQPGWTAYMYkgv7S8+2dqE3udZRbiVxCvIQQGkvLy0q", + "raxT+6AZPTWeUKVI1KnqBpeEpHL1pLR6bR3XHu+6IFeCOkHmgopbqmeEjbkISWKNhK8zHF+UGvOaces1", + "sRjSYehbGrPLz4DsFBKZ+CGzHuBmraRt1LMXo5rVZkIIql1e4Di+QBv2pU0kyD8gEt+uFeOsYPZ3R2eO", + "BfJr7w+nHc2RWgpcTJVKh/q/5FDv4ot6Y/Zbt8OLzLJnfbCv9vZ27apap5sZcK3Zqn/NGxbRvDRO/W68", + "WdN8oUdp40zaqPJHxSeFJ/WSsqhtA7/qdxu9c7li5CyNu3bQpYJ0s3QiMITY3qZ77sb3pkDNZgm+Io/X", + "FyZZZAhmUvGkHG+/UQvxoNVgkCqxZjzuRlhhcGW29Lea4S4GHidz05SxxZo8McPJyBM3RD9BKsCETvBo", + "rqr3B9vebL6vvcR2Y/EtS1MAv7EgSTRUfHkIMx0j926biEWTb6D4cDamfHl6h41/qeTfmePI2rW6iW4a", + "UutOAB0nnJoIU0MEUBo/nJbv7noD1oXj9wAd5x3kzeZNYtAtcWRuTja4KA3CJHKg0XwTYfThtIfe5aP9", + "s0TaYJkRl9EwxRKNCGEoA9cznIZdcxaXB5BJODRV/XPrOzHJD5twRcnts16ecwxemjyDGkKlRrQ2H5M5", + "CQtl74QxK3vBWnmtlgV+vyUTKpWohX2jjbcvj3Z3d5/X/Zc7T7r97e72k3fb/YO+/s/f20eI335+h6+t", + "w6psscFnZelz9P7keMc6S6v9qE97+Pmz62usnu/TK/n8UzISk3/s4nvJAPGLsuMiag5tZJKIrhOTmqt8", + "sXKlkLSGWLgbh7jdUcRaEYC77F1DiXf6zbtIbfEFTduQ3fWTT+oCc2XYdWlyi5b8PAW7s9glJQ3ORjeG", + "1BvHeUzl5c+C4EtI2Vs8txM8IXJozjN/PEMmTZANubbeDcG5Gktzb1r1em7vPd17tru/96zf92R0LDI8", + "D+kw1CdQqwG8OTpBMZ4TgeAbtAEXXhEaxXxUZfQnu/vPnvafb++0HYe54mlHh9zwcl+hDUuRvzqcEvek", + "Mqidnaf7u7u7/f39nb1Wo7L+4laDcr7likrydPfp3vaznb1WVPAp9C9chk1dgfdlVh6a7H79r65MSUjH", + "NESQo4P0B2gjgSOM5LdV1T05wpHLP/WfHQrTWC6NmDCd2TeNoy3JYkXTmJhnsCCtfNEw82NoyYuQwVie", + "77teSzYvaWWEgJtL/gqq5JdVSHdqEppLyhMlcXRgduhKOQerWQzsYxMf2Dm05IbX2nTqxmRG4jITmKPL", + "ZNYKgnI+MYtWmRVlMxzTaEhZmnlZopGULzMBuqhpFOERz5S5ZrQJ2kUnEPUMtsdYi+t2du5LLi5Xxo/q", + "kzjPQ1/pFToER/rYumrgFMfIfu1SFEpKX34daC5N7XOJ3povjIeo+DnNqqg2HejJepIYEkQqDpLUOgxt", + "M221S7/eAs5SF/5h+itk5z3FvnTHJlzgNi1sOHWG5ha+xdUvBGWUl8OS4M+y8DYkJOlCigvMytELXiU4", + "ArQZnhoECgU3r7B7ZblZxdEIzFMbhww36aSH/gZ+I6xQTLBUiDPbttVGoMcBK8/pJ+ArKhGO6YzUWUkP", + "NebhJYkOzIJsWe7ZikhMFLF+5QGznwiiMsHQXv85ypjSuzGOkcxMiOalhABZ82WENiQhyG2snn5u0AaM", + "6zJ/kJBkaIaw2UMvoZXybFBlMsZ5qnvJGB6PSahf0xyW4PmAjUj+KZ5gTW8zXc26pgs79bZbQWExIQDO", + "oVaqs3ro7+D9c3i9da6C/nCll63FpmTk6j52JCRzdLVM62qOv3WHF1B8WaRi7ogqXgIVTdCI9BCIXgiZ", + "csmjNTF8rniaak6wJO8NWL7J7E/SXK/BznJ7mArEBZ3QasdV7+tdhjyuw4qOm27MjuUPF80XeGgkUuOJ", + "gMfKAHFcunw6Uk5us4sQdILzHLbEHlNV0rzNoV8WKFLE4S4M8dXZ+3UDF1PBtcxebAsCZexTa7a7kL7X", + "e/3z7vb/ZcJzNb+B/k6ZCa5JeFRDGbHvt1NLXp29P2saU477gcqjW5hTHg61DPnMUcTeONor64oIhku5", + "opPCMHvuM3TGAidklI3HRAwTj+f1pX6OzAsm7o0ydPpz1djRRlVbl8pZZXHApzLGoYVtaEd9j7e2No1O", + "iZof/cv1lpjTpSnZUy+VsO/YfM8e+i1HWkGvzt5LVISwedy41eVtTKY4m84lDXFsWjS525SVva/AnK3N", + "p7PiQ+un9hhRfoAetxHQxmySZrANz992T9582EoiMutUxgRhZ1MeEz3uzZK0mLmUzyLzoyIkZk1uMMMY", + "su0GKtEq38GtiVTarx7qKK5wPJQx90XyvNMPETxEGx9empQ8PYIOSitLqX8vUaHC3/veHaMlUlO359Bh", + "3Z9e2eBex0IVKtX43krTq3Tq2yq/EBwbhNgqPy+iY/HL6kLzy9WITKYRX78nLmugZvH6MvuOTo+NwhBy", + "pjBlRKCEKGzxaEvxT6AOBZ2gq8+oCJME4jDH/7k89Knhfqacqtfo4T9aAHW5E+9+AxjBWxOfojVuRsdE", + "KgtGUOlZTvHOk/0DA5kSkfHek/1er7duAtOLImOp1VJsmfyOUi5TT06/bh3uIE+pzVw+B2eH734JDoKt", + "TIqtmIc43pIjyg5K/87/WTyAP8w/R5R585taoezQ8QK6TvW+W59Z5veDEiCqA39sBXrot2cg7AWSKr3J", + "6ApPtH1iOO5rs85vjEtTgKOpEh5NOVq4BTYN/bTcTe4UI3jH9mlM7hy2Z9FBfiPgJbkUm2IBlyIlLEej", + "iGPzV8jZTO8KHzRFRYC7Z191uWRDoIYR9XDy36y1ZyJoIOVu9X4LtnCarmZbv6KYy7+2kDw2cd5zEj24", + "1L/JBWy19zeT//7j/5ZnT/+x/cfrDx/+Z/bqv49/o//zIT5781XpdcsxEx4U+ODWsA7g1rECeNCWlU6x", + "Cj0K1ZRL1UBh+wQpboJ5e+gIDL+DAeui11QRgeMDNAhq8eODAG2Qaxwq8xXiDOmmbBrMpv74zLh/9Mef", + "nW35pd5GZPNdhF2QPM1NZqOIJ5iyzQEbMNsWchOREPCh/4pQiFOVCaJXT+uw8RyNBGC+W/O86LyDPuM0", + "/bI5YGDhkmsl9AxSLFQO8uJ6AKawozIBJfZ1EjnUAGMhD1h+LuWgAcZH08udIHBxUw/H9RPFa75wUc3T", + "etb3wStASKBeyJhKRSBqP+dszUZ5rCJ61q+Iimf9Z/2VCn7OQ0vYD3bCYjEIx5Qt9pJhYOjaCG4IX2xx", + "0aJlk9kj6Jd37840GfT/niPXUEGLfImNkWcCRKXxEapYlkJDN4NmZ3DLCRknGXwWt0gpe2Fih9+9PkeK", + "iMRlc2yEmpxjGur5QWwIlTLTrEgxOjw6fbHZa1HNAmibj3/JOr7LZ1jP/LFOsyZfYM7xmr4ddHIMsdt2", + "hxYKHMRcveQCxUbAFPv6AL2XpBoIDUtlQj7MSsbzwvNmToBBsOlaTOuS4gC9zfVGnA+lUkGj6swr9iU0", + "a2/lTEDYQuudBWx64ewiK9og/AurPINAn7jNomD59vdQHPa8Dfov+TTX29tlZ6juzM8axdrfNqTO7as7", + "u+sauevCf1QzdEvZ3TkCSHvojruAwFg0+K6pGjaGeCD92AZ0OLPmwymaYsn+rOBhzbjZ3n3aCsxV99o2", + "OKIcFsHHZkj5tnTpvvmlvkl8vqRxbGJlJJ0wHKPnaOP85NWvJ69fb6IuevPmtL4Uy77wrU9xYbnMex7T", + "GbF3n7ZYirkgLuU2e6+GtQBfuKbtDdjfieBwZNXc8lAMh5EZETaMVetLWCKMxph1eQbqDGGqh966Okc1", + "aeMNaW4Bd+IEwKuz95AwhuXQTac5bhgXUybXVCq5mPLd6gJ2ObzKLxUIFG8O/eYt4qK4AI6FadwH4slD", + "RsbeG9pKEQvgOfggjmE8RqVIAguo1kf/+n//P0R7pFcNjShvMBuDYeMgSvEBVA5YgXBjAixMan5zQERp", + "/UshEc17b81Ymxb2bwUQ5mtRXawNdEegLo1Hpg8QpXp6mp9vF57lToazsqJQWVV0eRo3xkPpBNQTo34o", + "9cFGInRyVuCqFr5K13xtTrY813a/39vut/HcJjhc0vfp4VH7zvs7xj91gEcHYXRAxl/hObaMbXR6HF/h", + "uUQDZ3UNAmPmley7kpyyllmrW/lF2JmboczU1cRVODLr4Ma0A4T5WhSOZejq51Vc9daq+1cUH2oVGON0", + "GRsSY78arnMpQlDIszjS6vFIb11jrpPIehUkUQVkPez29+yS8StWnbrxjWsB8EdGxBx9OD2t3KQIMraI", + "3C0mDqE0DevA07WWYWeFBbVyNDfEZrkPPJa62C0dd7eOvlJ25bq4bcOhLVy6hb7tDaegzCyN5pMlc6o5", + "4yIyG2aZT43Uj1y21vv3J8cV5sB4f/tZ/9nz7rPR9n53L+pvd/H27n535wnuj3fDp7sNNTHah1PdPEKq", + "upubsyOB8ODYNsmv0YHeb3mI0yhTKA9/1Bv5SOvjqKT4m1xA8DWdMKoA95WyiW4GXD/WLjBJ3QaaljKq", + "AEUEMKwo01MGH5tuxAa1HaBX8C48wgnkKLpBaJO36l7C0dy417VgcF2n8K/lQz6fZlDhC76R00whqAin", + "p63JYO2z5U0YGXOAfuPwjXCB6YzXDT3zOnh6Fl+vG4UbNtrMhaxDZ1ZgHqCXuZDMxawVqxBaXJLdNpsC", + "MkU2KyGZdsUDzS3FypWiDTuBoWjQCRyhICpxMT7Rjsubl1VmRd+9E8ExiNAi/itTNLbAKDATCjXRYCIY", + "FrdpJ1sQQBJZw6bpFtkEFVk1If/ICYoPp2gDUqD/iqwVrf+1md84l3fl3s7zvef7T3ee77dKdCoGuFrA", + "H0HI2+LgVkr7MM2GrtxQw9SPzt6bqqYhZzJLjO/Hzr0UOpwKHmptlTJU1C8qOn/ee17O74p4Zmq52SHZ", + "ZNAvpYqFS4tNNVyb/kHjGR2P2R+fwsudfwiabF/vy52R17grSiN6NeGTsgN9wWwko64Bbm0wvzVDCdmY", + "pfaWSJgBOicKAf90EQ7hkM4j1SzLuVw2S3EvY+3t7u4+e/pkpxVf2dGVNs4Q7NfFUZ7aEZS2GLyJNt6e", + "n6OtEsOZNl34LmDKMKvA+fdZ7nKoFv/tbfd3fVzSoC8VXGPbniWNJP9glSA7KUt0CLjLFaSFXe6l9u5u", + "/+nek2dP2m1jV2pTXC+XMA7Hx5DHQh+VV34DLl3eHZ4h3boY47BqoWzv7O492X/6bK1RqbVGBbBdBm5n", + "jYE9e7r/ZG93Z7tduqXvYsUmElc2bFV2eTadhyk8q+EhxaLo7TSdFj7F0zDYWxLGmCaHoQuKqp0+BlZn", + "KMxrxSK0ORisk2Dh4GrxbSsTrVYrzKgGXKBSkdXeav/vzdy5zWLanAerxfiiDh1jpsllUz8MeusNaJcK", + "MqM8k7fQEFeQcjUcx5yLtb5tijJ7S2QWK+OCpBJ9OP0zCBHNXEgqklYzKCz7LUmQueHk1trAFZ7wc3UT", + "sVqtRpulXzbhTsM27SyLjq5s/8Y8tEiLqoytjmg4wnGYAV4hztdTzwoySnimIP5ibmJ/4phzhsIpZhMC", + "9R8MOiqbIIymPI56gf9uKI6GY++dDb9CMTfwKpeEpBbKzwxCf2ZrYaONV7yoYmlYqQbJ/SQxUsWCtdVL", + "lwdLy2A35K1pemLFS8gf5pOKNR/ziQQrUEFUU68OOJViYYKVMDPQlLPEGI/VhLwdfdp7hliT3r4j1Byd", + "fGwtWqtjKJ5TEoeCS1nU4v9wWh3msrDUhDKaaDm7OkqhOtgWrCtTzqQvYMFWVm6LYOs7ED3xfl9zJAIP", + "Q1jvsrLvFro0wSwDcL8SI5PrlArDHu1CHqZcqmGeZLTmYKUaAnBbJkiRiejOyymkdcyNiIN3vOeiE203", + "IVde0fwGXy9wlb+ppgE2y1QvRf3U6uQ86GPjxTSrpZldRapYPS9onUTAAumLSmiVlnLQ0AbjqiKWSmhV", + "m20uqvw2qu6nqYr0673+edscveUpeWdYTU/YmHvgYNdw+NtEBxeRkhKRUIAuRBFhFLLW31Q8/9a3BakT", + "sSQoyoilnFFIBbYEx2Z7A+wrc04xyiY1WV/vsI0b3oxhOa4b9GtfbHPlKP0B9/Ze3t6KS4SL0PtWV+BU", + "Dv2e4sWGBZlkMRaonoe6ZMhynsSUXbZpXc6TEY9piPQH9eucMY9jfjXUj6RBIdhsNTv9wbCIHK1dz5jB", + "2bhhsyC1fospQITQZi1rAVwvW+b7Lf19qxtcbzTYSxoTm6r5ntHrEqNXgY/2dvpNCS0NjVZSWRbTfNeV", + "3JZlfTveZeAe5oVSPEkWJuSpditRdURW5uubLQQOLkvfWXTFoA13KeyApap0LQE8tfKEtItdrIc/uNFs", + "SRJWe9979uTpfkuEra/ydS4ppP4Vns1ZssSj2bBSp23cZs+ePHv+fHfvyfOdtRxULlKmYX2aomXK61Or", + "h1Rzmj3pw/+tNSgTK+MfUkO8THVAldpGNx7QlyVbt0ieb7j2aIT2j8sr6e5Zqh7Qdj7GJdrSYUXlKpXv", + "2yCARkNnZGjo1i0GU0u6aDWGEKc4pGrucZjgK1PlIX+llgTexptWHayHpLZti+OhJZfMRkWY7obrHP3F", + "uNZrvPCsNVCfzEZNbvw39V6NE7/wAZWviFrc0BS1RBbdBfl8rrCsRHXov0OAaS/KM9bjh8wb7QvRO17P", + "a9EXoaA+IAN/3fny8teWs+T2rSjJdYovO0Kbt+BaNrTnRPZVpl0dhlyTD/YAvNlXw1EZQnMpRmkFb7M4", + "ddfvt11hycXvCmSy9forhYCu82EdTRD40Y7Bkrxou1NhiQZuUlysBpG/A9gnE1NwI+AnG45wL9hP9uc7", + "wXtaWI5zoty759qiz+IlGPBMETHDHseUawK5V6p+VCOJO8i6+NB2slmrTro39etqNjG7ZfiY1gKHqSBj", + "er2EW8wL5riuxstLS4GoWidAoo0EX6O9pyicYiFrY2d0MlXxvOpk3fPkxHxd3XaitOrcvqJCsZruw8Ub", + "Dbuc5dZ9W/a8lNzhr/RAouEy+IKj/DXnM07xHHTLRkPw6e5ev7+7078RfsFtFaAotdMUEVr6zjpzKleP", + "5Rby+M9FlNIrQU0dQ0cmqQTByQFEU6U4JCgmY8juy9GhV9r0C10vH7y9JLWB/zn/u4VyKRPWz2JFHOMM", + "FA/XjoV+cNMI3C1tNbml/Hxx2EtSAHMxEy7kAtbjV/e7/d1uf//d9u7Bk/2D7e27ADzIidQUwvP00/bV", + "03gHj/fiZ/Onf2xPn052kl1vusAd1DqplQ6tlT6xc0iJqAOX1mGbJYkpI12Zh72tDkBeIgvMTdLK/b+e", + "98HMYKmycF6dZFlnwKogTr0K431kctnRL3Wh1Id/crx82DeKI6sPxM9g9aEAP7UbDADwbH8t2kvGWp47", + "70svtj55lsY2rjp7fEHfsLW9q9xAcR8/VwRjZYctO7EXTzWPCTfhgqppsvx4yF/LsSPgMvyTVFE1kaaH", + "TiYMwKbLP+d3H+V68PrjoBPEn/aqe8b+3j6lymIllHNq9VKX1YAWdwOAZb6cCvBKYVoIE56ABQFC/LTd", + "3X4ON/Txp72f+t3nPfS3UqRAx1CrTL5t93bl134bGuaCEvROc3O+/Xyta3RHz2Uc9Ks9l5oOYouiYHm8", + "AHN1Z4ULm64scPF4YY1rWUV3VlvMnmbDspYUkRjPffVZYjxHIzIGQPuafVhmMjQiE8pkB5FrJ3QgH7ts", + "CtnK3bt9OQgQF2gQPEkGQQ8dWuwRsFYLIPdK84DSXOITmtiychanuTksZSdplz9RNx7WA6RyX3nUs55f", + "P3v+rr+9NiDVesdk7yuiqr/K3G1n4sZYqibb4jWWKrdJkcishdGByl5s3vNVU7DpEBDeCigSB0jWvByu", + "jIQsFD/nCemgCVeoSIRYqenB8EXGvPxQHX9RnR2ATxoZYmcFQ7QbU57MSJeJr5NjlAoeZWERBRzDoLMw", + "JFKOMyg232ur1a++Z71LhwaE14+5QKsdGk0ejNWptuS6eb1/I9eq1KVm2Oal3u6vXuo78YJ0giyNVssw", + "81I7CbYWxsyKuFKPT6ZK9pomWJrMxxYS/W2ZgotGLtSpQ6FWibLUFU7VPLXISdJTLhVfD73AEMcGKcHT", + "CDKVjG3oC5WFFF0tUrf3n/ndhvi6CablV0JSbask3CI9oASzuXdgdXx4tNF3hXMlgua7BqPOUqs6uKcr", + "NbHGpWoPtV/zapust3JlgxyW5XZx9u2XK0vk3IUf7iGVtDf2ckFWGcOhNeSANq5/E9Zr6ubHtfN674ls", + "p5O9s5ZxEyxUPbS37GY+7P7duJXRsHew9dNf/8/ux7/8yV99q2I3SyK6ERnDfeclmXdNWXFto/eqoMQA", + "WaWVaVuzShGcgNMovCTGSZXg6/J4n/RzoTH/DScLU4CL4oSy/N8rJ/TXPzVfs5bI+B7k5EqW/WoIs7vA", + "h1bcHUcbCRETV4TBRQdu9gYMAg4vyVyiEgilVWlKsFPuk3Jp8AtbAQcK2o8oYPnKAdNWLQ5DkmprwoLx", + "URiL4CB96gXyLRimi+bXcgkDArDNrqoh4Hz2lqE/CBi56poeoq7mvb0n+8BHlJUpub2wxL5FNwn6TTV0", + "NZU9XqPXVEL2iQuyLr2MNkiSqrmDenZhsJvrAQYc5g16b75vGQOv//w2IH/fL8X4/Q4rOJfxHNyAViI5", + "LKx/I7CmP47uuA7MZPakrUpZBRKqWYdSdZvD7BKtzgwhWnQxJA5wtSAS1YLaTrI6uv9WwtSWhdD2Zb9E", + "UHR+aexxscscuAHAZrUIqV2qUJdmVhpJ89qcOr2xptkuIdCZJs3VlAhSWgj4oMABXpNkNi60RU6VAbpN", + "iejWy5aa4imCQqBpbvI7EuSxw4t+0OWARqf4Ou8BfOhYLtw0wTwKwMbtVz9DQaS3rnwlHbsmDMhhVav3", + "oxNVuWgZTRxXLS5GmasW523e9248K6uWSL+mvVVjzqKPCmv6+PFvmKqXXIAd0JzBdOcgR2BjRERACncd", + "wqgV/g9NSDTkmVq+/22lCJu+FDlVvgDRdjYPBia2Ve1XyAKXY1OM4aNPb5AkzARVc20kW5V0RLAg4jAz", + "Gx4ICR3Bz0XHgEn95Qt4C8eegMVXhBFBQ3R4dgL7McEMVGX04RTFdEzCeRgTCym8ALcCSt6boxNrZzqA", + "P7AbqALWc4XmD89OoG61MLZW0O/t9PqwmVPCcEqDg2C3tw1VvDXDwRS3oIQF/GlzEXJ75SSyetDP5hX9", + "lcAJUUTI4OB3T0y/IsKUxJCgdeJJyW5IMRXWcEhjyDQwrEL1t4B25Y7SA3MedwzBW7vJpJrbuEuSvrHL", + "+lFzgtk1MMWdft+YpEzZgxcX9Yy3/mHzM4t+W+lzQB4P9NOCXu90SkvyL51gr7+91nhWliD2dfue4UxN", + "uaCfCAzzyZpEuFGnJ8wEgyMDK2LDXcr7DFiovMN+/6jXS2ZJgsXckaugVcplkzJMtO3OyJWtx/IPPuoh", + "ewkAGMZyyrNYSxNkIt2dua+w6E0+ISzCKZ2RAbPntCknjQUY8wnS57MxW6pbw3RtVj/PQfyZR/MadfPm", + "tnRzXef6LQhcR9WUZAjgYMOmYkuF05cyBhV9JbGYq3nVkcWYGijBLkPurT1PGGaqqOhtaq9fkrn1K3sb", + "bIXiowUeLAsRAK7h/CQ7m/70FUCH9Wd+HefPkCVvVZ1gcBkTxllU6FwuohqLEY5jL8zDJOYjHNsS9ZfE", + "o6K+gjcsUcpAuk65YTwiBiM0naspZ+bvbJQxlZm/R4JfSSK0CmQh5C2tbX1my7pXAAuWAIy7KVCj+9wy", + "Q9z6fEnmX3oDdhglrviQNJ/gWHJbu9+gJVGJXAiu4V0/fG9DdMdRJhVPLEuxcjVZM0yeqTRT9mZbEmVx", + "7+F1qEQtpyQaMMXRZ0EmVCox/7L1uejxS7nqcekVM6WtzzT60jRqOcR69kN41WP9ESDAINCnyyDQf08E", + "1rZLJqfgypDgvpiUl3QjT73XeuFmncIhZijlqYEtAKaaYs1ylTYAjhvHMVKwldy3WtuElWyYj81E8hXE", + "tGlIJm+kto2gNGZpM/X3nvn3kyShID4Hx3+fv/kNwVGl18C8VriNzNUy06coijLQ5KH33oC9wOEUGb0J", + "oOkGAY0GQW5dRJsw1kzaOOluF1Tcn/TQfjLddGj0U6+nmzLa8wH6/bNp5UDvpTQZKn5J2CD40kGlBxOq", + "ptkof/bRT9CmbI7ziiBAG0b2b7oKUIAqURyD5tzALELcytp4jjAqJFDZjzKiDIul5as8pLcU1KY8nsgy", + "MT4PwIM6CA4Gzoc6CDqDgLAZ/GYdrYPgi58CVoluxkEzFbycrp0z0X6/v7k6zdLS16NCV17U2+/Lgva1", + "c2uKh1W6FhUPM7m83jez5dkio27dg+bzM45cdY8fKt4KFc96LkrKG3xfPgcM+8bEGLg1DUzbs7HTwJZa", + "J4YtAMUULA6XFG0MDuo0uIJ5y+ZH3ZxfNCv2mnZZCEOMHf/t3QP/Qb95XQzT7/P76hfHAEmaV/d+XOwI", + "i+UYseO3iF8R9S1wXP++RKnFT31I/n0s/POKWL2vIFpNmm2Rmbtv8kM/QMqHtK2Yl7Wteg5j6p4TptAL", + "+LVn/9dZPABkfBHzycUBMiSM+QTFlNnbuNJtkT4ULS3hI5P1kX9nk0Ac7taGOT//9b//hEFRNvnX//5T", + "a9PmL9juWwYMBXB6L6YECzUiWF0coF8JSbumtIadDCBpkhkRc7TbBzUzFfDIUzFWDtiAvYVCGqVbSwOB", + "JW2DYHowmA9lGZE2a0a/SMcWn8NV0Vkw4d1eNqS81x3dWQwxNjMoTUCfio4HIOGaGrBia38Ffu+ZmXPF", + "f1b3lS94TFfLF0WuleHerhngmgIGSOzbd/DAThptnJ+/2OwhsDEMVwAGC2jMRTNWee79kEmrZZKRKFWB", + "AlQ2ssmkki33/x7bd9o5gG2L35MH2MJyreECNi4PIkjk6PXDVmjjDvbTzbmGff7ZY5cr2eygvfl8y124", + "aKJWhvDtrbPjvUWamyclkj2ECYw2XEy6K9x5dnTiSgFtPhjT38upoWdqC2jkRwfiplzovZllR5yNYxoq", + "1HVjgRoOCclNtSqDPBZx8NaOGmE3rzraYfl826qA9zSedDmOT3Hk3f3pUet0nWOkQGQseO3HSbKKdY6p", + "DLn+tsQt3RCntuqoUV/yfVrmolUOKRPinh85S9UlK55Pjt2GvD/XlO06Y/Wz4R6E4nFNID6gIKzV3Cth", + "mD4mbn6fr6LDhVjiufq2WLN/f1rQfXuxfGz+mNxYUY1sWgoaJOfGA/QVUb+YN+5woW0PnomfE+F2tYOc", + "hlnn0zKfonBKwkszIbiQXm77nphX2pm+pr3vyfIF8qyjsViS/1BRWhi7Ba2WGbgnto7g3dm30MNa5u3t", + "3fNaBvMQGYJNRs5jbUr0YTln4eZ3ddV7L6eZIfajPMzOsjh2Nx4zIhTK65OXz4CtzxCWtFq3d7tt6XHw", + "/u3rLmEhhzi0PIbKr0TZJ7es4ZsFM1P5wSZtbEKTnEzdedak4XzF+ptwQZTXv/+PnZe2Av5/7Lw0NfD/", + "Y/fQVMHfvDNm6d+XaL5vjfsRM59WuGmVaCCaGJSGXaWh5m+1VFLd+9+VnmomvZammtP1h7LaRlktk2up", + "vmqX4k41VtPHA13J5MzmozY8cvGJ35mmer9ePsuRDq6Zyuq1h63HwwX4eeERZSiT5BEGUNKc48rHRkt3", + "dbEhlx4fjnVPjjtAyI4mHWAn2QSRe3Jeu3Hcu3Jr+71/z/VhMqKTjGeynHuSYBVOibTJSjGpCuDHpnYX", + "x3Oj4v0Nc2n/Po+Oe9erf/D9HWn89QU1wtvcQK3S+d1bbXV++77W+U0Ktc1dswBPHQf+t9kQVOiSqNuy", + "cSXXfDHY0Tcuny2C3mtDpTAXEFgQBwP2X9r++F0RnHz8ySXJZP3+zj78Ttjs408uT4adOlYhTAlqsVoP", + "fzuGa78JZJ8DnGuRklcfh6n/AKznAGz+7Qyk4uazvYXkuPCHhdTKQiqRa7mFZNfibk2kKgjWvdtIjt98", + "BLcgJj+spPuwkmQ2HtOQEqaK8mgLQWK2uuIjzC1j9n6oFNxROWhbW0n5plyhgBbg/Pce2HNSoBHet3Hk", + "6gA8zhh5nlpgbWuOFIdhsz3yrfFD/36F8/3bIY+ZxYzCv0i6VOuUvqqbgPSYZAqCEguEEIj6RMJo7XmL", + "PVQUu5RZmnKhpEGLBAXY4MlPtQLsQ5asgkX60CEBA5gS2RkwqBegH5tc/q1LMjdYkJSzHPYxn6nFf/Tl", + "XlWxOB90G92+juUHGm2lY93zNrbQ0Q+nYz2Y6LgXTeukgsi/kW8MMChHJN/JPE/uo58om2w+qghUI6zy", + "uZXwjDyq1hbU27Poulsyr+vbdNCWAHZtNcp/wxN3cZI+rd1h0ZYIiCKKJ4xLRUOXuFvHLP9xQrc+oZdT", + "1svNY1tN1W/Qv+Tisu0R56nu9QhOuvIMv0Ffgh4eoIE9vEsBjG1zGmimufdTcKFk20OmYND6uRjGWaQP", + "QncgOlVyLHgytD8avFq9KywaKLgoQtvqQwsb3fs9OIx+4wrRJI2J1uJJhLqGm/RqWtXfgb5TWSpwuJ4w", + "1NumnBBjwOikKxBkRSRcrrkF24B79sXl8krNmE9Wg2DknTvEBw8KxoAZUHriEOwvUC5koYQWiUmo0NWU", + "hlNAxICyWlBXFcAqcJpe5BBYmwfoFezUMhIYdL4hidCGUMiZ5DExQBezJLk4WERs/XB6Ch8ZMAyDzXpx", + "gBxKa35ASP1WGeEirzz0m8Xt2NCcJHgcmxW90FZjaX6bFvuigCgbMB8OBiNXtkE6RhclSIyLBkwMJ1Bf", + "88mDaVudZmBJMxfFkQDCGd4kLAqaLmJo7EfD2O57q7K0ROYww7hjYI6FwbzmkxzUssLKOE3bsq8dJnDx", + "LEmW8DDaKJVIlSrimfqrVBERAj623N3E3GgDh+YfCl9qRrXlffIis8B+3utGgzLnJZUWqqVaNuZfsyQJ", + "OoEdTwmdbg3tfQXCSb3BxWsxvTIlGJMfevc6ACVVYV9CKKmdHLYIf7PK/da88N37Zy2hou/By1K9zypG", + "QVlRhklAHXVXC+tRIR3AQi7oYqY8kW+PuFl2ZamEZ7vrrYXin9+A0brq1iuv5JiXmbzv66/FETzmJBi5", + "MJsxF/X0+FX3Yt88I93ekixMtQ2H/ODN9d1zrRgzzZZU9ISCpBL8fFDlEnCdwynnssT2IzLFM8qFRWC3", + "XtecM8FlYaxHGz13oVn1wvpvL6x6fmB9TQiXH9k+evC5jbnzf+EeFV+8LFnbucTvOJUaUCAlwmgkKBmj", + "FGeSaG0pSwgyFUYskDfB4dTV7O4N2LspQbZKZcmBkBc1phJdbCcXHTTKFIqxmIC1Yx6aSDpBQp4khEWm", + "8uyATQmeUW2qCRRjRVg470oClYhnpChgok13e0NpCl7ntU47yJXIBQfDRakA7gVKBQEmMuYyq1SbHTCR", + "sf80yJW62Qs30AtEpMKjmMppXisixBFhoRcW8vzbFmO378Q9J2qxRuyD3FneSJY+5CVm2ZeZV+n+Ju43", + "H1mgFheuvmULMb9E6ZXNpmE18vG8qIv7b7ilzVzdHB/oZiYn8bJd/G1cyVQK4/+4llF2S0aZ6Y5Ui8d/", + "t3ctRTXnjFWuW6xP9qYXLnklhJzMa8m8rc/uz5Mb+Mi+EUnYaTTsmzC3i0l/CyLXUvVGMveBnIPWl1Ty", + "ij2gCLaDejj1iYuSlPsmxLDZcLk0LsscJTDYVJz9EMZ1YWzDA24qjJ3HdeECvCSeKeumMW6Sy0XteL8A", + "tg6Bf9Po19rsSoLwwQVfcSNwb8LuJBdvRuCleB5z/L3fy4RcCJPQacsRPx5AsZIvsHTBtAEet04uITou", + "m+TD6elmk5QQaqmMEOoRS4hqWdMw8VRrfDMjQtDIlY48Oj220atUIpGxHnqTUKjneElICoViKM8kgszc", + "np6fS21dLIJXyWHtBIQpMU85ZWrlKIpX72YwX25UOu+e5aSFVPzuL4/BC//4hBTIDq2u2AkstyIVVo3B", + "eC44jTJT71JrW3jEM926liyu0O4EzrYxjYmcS0USE5k3zmLYRAC6a2sy2e9MRmkHUSWR3g8dyMBLiUio", + "lJQzOWC2/HtKhO5bfw7Ff4sgI6/zXuFcap4Z0fdtBLDpwZiYLayaqAbQAlAHNDgItnCabkG5aH+QlB3e", + "VwzpJUSkITlPRjymIYopu5RoI6aXxuhAM4li/cfm0pC2IXx32xWnbr6zNKVP2Jh7i3IYns2Z+ftIQqqK", + "NXeJ+OjE2itS3ixO/sBC+8WaXCnXBMFxV9GE5MnvKFM0pp+MqNONUKloaPJqitRLKMJssy8H7JQood/B", + "gqCQxzEJlXOubKWCh1uDrN/fDVMKKCW7BAYHAq/5cQI9Hp29h/dMoejOgOl/QMPvDs/MTewYWx9BaaCM", + "qCsuLtHJ1psVQb7nQKZ/4yg5M8GlOZDeBf9xfbd+ZnPjHpINW5Snywwgnn73YZxWg/vhLXic3gKAlshn", + "szEROASlWE4zFfEr5vcMzHicJfof5o+TVQAlCofTD/DqN6PtmuGs7MZN8FFsSjuniJiiQQ9yQWEI9ljj", + "SzXh3BRAialE7nlPgUP1PXL37Tvly3T8Bq8mLUVdQa5vZm/d98lnx+Bwt8r0eCzb3HCam4niy71PV5g2", + "e59+jnl4KVHGFI0roAbabgMcUP1jgdtoL/5ATYDsSFdKHJHrlApAsKnBIyCiZywRRoqIhDIcb8GcTSOA", + "QOm8WHjGKSQphzGFNDEaEZTyOAaUnaspYUjPBhxVroHSPa20FSDK75SvGBVHIxLyhDhUzk2f6fY3TNVL", + "LqoQm9+KXHxXor+ej56qnucKVNHmHr8KZfQUX0NYc5TZa2I3oo1XvPjRuII6CNZmEOz25SDooEGwkwwC", + "vQJHGFyoWKEnKKEsU0T20LHxb0Ea6n4fSRJyFkkHDuo8eLt92ZSUatiyIcNxH767T7XHchWQ8q3txCce", + "9HtIfw8JNmijvOHsnow6sOkixDMFAdxuX9m3IqLAPbJ57zewpT3yw7ZvI8n/ZrdvRUbBKmtxWVp6I9lz", + "+MiVXjeXVDHlskCdRCFOcUjVvINwHPOw8B5kMr8d6OZDGQmCL7UN1RuwtzlwpU2EQEdn7zvOaYYiKi9N", + "C9Yv1kNvZkTIbJQPDoE0MB48WAwSDZjiKMRxmMWab8l4TELIYYhpQpVs8KvlQ7nLMohFJ56Fdw9z2JrH", + "5Uzy8wSsXsEWssZxW2aptwQJY0yTslOpThxQfeFKF9y+I90o18fwOLbXW6HgUiLbVJfEdEJHsb2skT30", + "TqscOCEDlsaYMSJQJk3ckR56NxVEyswkxugGoM6s4agOKoBOUsGVdRPHnAtpPLuawz+cIqlIuoTN3pqW", + "T2HOdwQTbBq3PT2QwVAbQ/OxZF9BekEMpxiCaz7Sx/QDBPuYAT00nPBj2fjvBJ1MiNC7Ahsha65GzbZ2", + "5DSbvpLp0YiRf56/1Q4jP2+1FM1dinReClQxdC8OQYFe5wbW0/klbcQysY/Wy774VX/Usu9qlL9/EPbR", + "V87yeyk9dl4Krm6LrF9w+GMDuS+NvLJVKwkKq+EIWmck3GWGQGvcgQeDG3jMKAO4knbQBCfw7TFC/36z", + "4+4bZvtx81YFJaBSWKchVWo1fOc3wYF3g9v5wNmhN8Dt/KbylQB38eHyRr+pTKWKH9AVD/nukTnvKkHJ", + "wHMCjEVTgpKRejaQYKmh9MG+085Msi1+Txq8vXteQ393ZP9h9bcwGUrE8rvsTG60w20hSarm7nKRj2sX", + "gJJ+gmQMH/BDHkNwd3gLN7hevz32cHzaeLn+o57Wvd3fF0WHT44ffxGt8p6rHCxb+tTpYhFO6Yw0O92r", + "O9iSKBWkm/IULlciQzBLD3eWKSx6k0/INm+xquy/EHUQxyRCERUkVPEcUaY4SATTx58lElxbAvCci7nP", + "mV7euS8FTw7tbFach3ZPWWdYceebzLsRVrg7c9JmiQvtK27a3d22FniIMvTqZ7RBrpUwiLtorC0fRMc5", + "Scl1SEgkgSc3ywPe7jd4NuknMpyM2oxyCXbyG4tNjcJMKp64tT85RhtQbGFCmF4LreqPQZNNBZ/RyBQi", + "LYg647Gh6nYDQdf1u2qlIq+U4YwLM7gH0WHaHEiTTzStigUTuhAcBCPKMAxuJUpxdU+ZhCrdH6aQ1lDs", + "Hcc5wY8jzFp+G87Y0ZyojRxHRMW5gcbb/HHMPeZjrhyY6s60ymnXrlRku1jVliGkdwGYm8cx36/b+sO3", + "E15J5aOMrLSu81lukDa5zb8tFuzf3/lw3+7yD484HP8VccZ3yVUODegWfQzzmoc4RhGZkZinUEXSvBt0", + "gkzEwUEwVSo92NqK9XtTLtXBs/6zfvDl45f/PwAA//92jJRrQ3gBAA==", } // GetSwagger returns the content of the embedded swagger specification file diff --git a/openapi.yaml b/openapi.yaml index e6446965..454ec151 100644 --- a/openapi.yaml +++ b/openapi.yaml @@ -478,6 +478,17 @@ components: Optional final state for the forked instance. Default is the source instance state at fork time. For example, forking from Running defaults the fork result to Running. + share_memory: + type: boolean + description: | + Share the source instance's snapshot mem-file with the fork instead of copying it. + Requires the source to be in Standby state. While at least one fork created with + share_memory=true is alive, the source is mem-locked: start/restore/delete on the + source return 409 until all such forks are deleted (see Instance.fork_count and + Instance.mem_locked). Forks created with share_memory=false are unaffected and may + be created against the same locked source. + default: false + example: false ForkTargetState: type: string @@ -878,7 +889,19 @@ components: $ref: "#/components/schemas/SnapshotPolicy" auto_standby: $ref: "#/components/schemas/AutoStandbyPolicy" - + fork_count: + type: integer + description: | + Number of live forks that share this instance's snapshot mem-file via share_memory=true. + Zero for instances that have never been used as a fan-out parent. Read-only. + example: 0 + mem_locked: + type: boolean + description: | + True iff fork_count > 0 — i.e. at least one share_memory fork is alive against this + instance. While true, start/restore/delete on this instance return 409. Read-only. + example: false + PathInfo: type: object required: [exists]