diff --git a/cmd/api/api/build_registry_credentials_test.go b/cmd/api/api/build_registry_credentials_test.go new file mode 100644 index 000000000..8ed4eafbf --- /dev/null +++ b/cmd/api/api/build_registry_credentials_test.go @@ -0,0 +1,71 @@ +package api + +import ( + "bytes" + "context" + "encoding/json" + "mime/multipart" + "strings" + "testing" + "time" + + "github.com/kernel/hypeman/lib/builds" + "github.com/kernel/hypeman/lib/builds/registryauth" + "github.com/kernel/hypeman/lib/oapi" + "github.com/stretchr/testify/require" +) + +type registryCredentialBuildManager struct { + builds.Manager + request builds.CreateBuildRequest +} + +func (m *registryCredentialBuildManager) CreateBuild(_ context.Context, req builds.CreateBuildRequest, _ []byte) (*builds.Build, error) { + m.request = req + if _, err := registryauth.Normalize(req.RegistryCredentials, "local.example:4973", time.Now()); err != nil { + return nil, err + } + return &builds.Build{ID: "test-build", Status: builds.StatusQueued}, nil +} + +func TestCreateBuildRegistryCredentials(t *testing.T) { + for _, tc := range []struct { + name, data string + valid bool + }{ + {"valid", `{"registry.example":{"username":"AWS","password":"synthetic-token"}}`, true}, + {"omitted", "", true}, + {"malformed", `{"password":"synthetic-token"`, false}, + {"bad-host", `{"https://registry.example":{"username":"AWS","password":"synthetic-token"}}`, false}, + {"local-registry", `{"local.example:4973":{"username":"AWS","password":"synthetic-token"}}`, false}, + {"expired", `{"registry.example":{"username":"AWS","password":"synthetic-token","expires_at":"2000-01-01T00:00:00Z"}}`, false}, + {"oversized", strings.Repeat("x", registryauth.MaxBytes+1), false}, + } { + t.Run(tc.name, func(t *testing.T) { + manager := ®istryCredentialBuildManager{} + svc := &ApiService{BuildManager: manager} + var body bytes.Buffer + writer := multipart.NewWriter(&body) + require.NoError(t, writer.WriteField("source", "source")) + if tc.data != "" { + require.NoError(t, writer.WriteField("registry_credentials", tc.data)) + } + require.NoError(t, writer.Close()) + response, err := svc.CreateBuild(context.Background(), oapi.CreateBuildRequestObject{Body: multipart.NewReader(&body, writer.Boundary())}) + require.NoError(t, err) + if tc.valid { + _, ok := response.(oapi.CreateBuild202JSONResponse) + require.True(t, ok) + if tc.data != "" { + require.Equal(t, "synthetic-token", manager.request.RegistryCredentials["registry.example"].Password) + } + } else { + _, ok := response.(oapi.CreateBuild400JSONResponse) + require.True(t, ok) + } + encoded, err := json.Marshal(response) + require.NoError(t, err) + require.NotContains(t, string(encoded), "synthetic-token") + }) + } +} diff --git a/cmd/api/api/builds.go b/cmd/api/api/builds.go index ae8e74c27..0830d98bc 100644 --- a/cmd/api/api/builds.go +++ b/cmd/api/api/builds.go @@ -11,6 +11,7 @@ import ( "github.com/kernel/hypeman/lib/builders" "github.com/kernel/hypeman/lib/builds" + "github.com/kernel/hypeman/lib/builds/registryauth" "github.com/kernel/hypeman/lib/images" "github.com/kernel/hypeman/lib/logger" "github.com/kernel/hypeman/lib/oapi" @@ -55,6 +56,7 @@ func (s *ApiService) CreateBuild(ctx context.Context, request oapi.CreateBuildRe var isAdminBuild bool var secrets []builds.SecretRef var resourceTags map[string]string + var registryCredentials map[string]registryauth.Credential for { part, err := request.Body.NextPart() @@ -69,6 +71,11 @@ func (s *ApiService) CreateBuild(ctx context.Context, request oapi.CreateBuildRe } switch part.FormName() { + case "registry_credentials": + data, err := io.ReadAll(io.LimitReader(part, registryauth.MaxBytes+1)) + if err != nil || len(data) > registryauth.MaxBytes || json.Unmarshal(data, ®istryCredentials) != nil { + return oapi.CreateBuild400JSONResponse{Code: "invalid_request", Message: registryauth.ErrInvalid.Error()}, nil + } case "source": sourceData, err = io.ReadAll(part) if err != nil { @@ -230,15 +237,16 @@ func (s *ApiService) CreateBuild(ctx context.Context, request oapi.CreateBuildRe // Build domain request domainReq := builds.CreateBuildRequest{ - BaseImageDigest: baseImageDigest, - BuilderID: builderID, - CacheScope: cacheScope, - Dockerfile: dockerfile, - Secrets: secrets, - IsAdminBuild: isAdminBuild, - GlobalCacheKey: globalCacheKey, - ImageName: imageName, - Tags: resourceTags, + BaseImageDigest: baseImageDigest, + RegistryCredentials: registryCredentials, + BuilderID: builderID, + CacheScope: cacheScope, + Dockerfile: dockerfile, + Secrets: secrets, + IsAdminBuild: isAdminBuild, + GlobalCacheKey: globalCacheKey, + ImageName: imageName, + Tags: resourceTags, } // Apply build policy if any field was provided @@ -259,6 +267,8 @@ func (s *ApiService) CreateBuild(ctx context.Context, request oapi.CreateBuildRe build, err := s.BuildManager.CreateBuild(ctx, domainReq, sourceData) if err != nil { switch { + case errors.Is(err, registryauth.ErrInvalid): + return oapi.CreateBuild400JSONResponse{Code: "invalid_request", Message: registryauth.ErrInvalid.Error()}, nil case errors.Is(err, tags.ErrInvalidTags): return oapi.CreateBuild400JSONResponse{ Code: "invalid_request", diff --git a/integration/builder_cache_test.go b/integration/builder_cache_test.go index d01b49696..62ee77215 100644 --- a/integration/builder_cache_test.go +++ b/integration/builder_cache_test.go @@ -171,7 +171,7 @@ func builderIntegrationDockerContext(t *testing.T, repoRoot string) string { for _, path := range []string{"go.mod", "go.sum", "lib/guest/guest.pb.go", "lib/guest/guest_grpc.pb.go"} { copyBuilderIntegrationFile(t, repoRoot, contextDir, path) } - for _, dir := range []string{"lib/builds/builder_agent", "lib/system/guest_agent"} { + for _, dir := range []string{"lib/builds/builder_agent", "lib/builds/registryauth", "lib/system/guest_agent"} { err := filepath.WalkDir(filepath.Join(repoRoot, dir), func(path string, entry os.DirEntry, err error) error { if err != nil { return err diff --git a/lib/builds/README.md b/lib/builds/README.md index 796da60eb..372cd8707 100644 --- a/lib/builds/README.md +++ b/lib/builds/README.md @@ -230,6 +230,50 @@ Builder VMs authenticate to the registry using short-lived JWT tokens: 3. **Token TTL**: Matches build timeout (minimum 30 minutes) 4. **Authentication**: Builder agent sends token via Basic auth (`token:` format) +### Borrowed upstream credentials + +`POST /builds` accepts an optional `registry_credentials` multipart string: +a JSON object keyed by exact registry host, with `username`, `password`, and +optional RFC3339 `expires_at`. This supports private `FROM` images without +installing a shared upstream credential on the host. + +```json +{"registry.example":{"username":"AWS","password":"","expires_at":"2030-01-01T12:00:00Z"}} +``` + +Submit the JSON from a protected file rather than exposing the token in process arguments: + +```sh +curl -H "Authorization: Bearer $HYPEMAN_TOKEN" \ + -F "source=@source.tar.gz" \ + -F "registry_credentials=<$REGISTRY_CREDENTIALS_FILE" \ + "$HYPEMAN_URL/builds" +``` + +- Use pull-only credentials limited to the needed repositories. The registry/IAM + policy grants permissions; this field does not narrow the token itself. +- The API accepts at most 16 registry hosts and 64 KiB of JSON. Schemes, paths, + duplicate normalized hosts, local-output-registry overrides, CR/LF in + credentials, and expired credentials are rejected. Only username/password + authentication is supported for builds; do not pass `registry_token`. +- Hypeman keeps these credentials in memory, not metadata or the config disk. + They are sent only to that build's VM over vsock. The guest adds them beside + local-registry auth in its existing mode-0600 Docker config files, outside + the source context and persistent BuildKit cache, and deletes them afterward. +- Credentialed builds skip host base-image prefetching and the guest's Docker Hub + mirror, preventing private bases from entering the shared host mirror. +- Borrowing is bounded to **30 minutes from submission**, including queue time, + or the earliest caller expiry. Active builds are bounded by the same deadline. + Completion/cancellation/expiry releases host references. This does not revoke + the token at the upstream registry. +- There is no refresh or durable replay. After a restart, credentialed builds fail + and their old builder VM is deleted; resubmit with fresh credentials. +- Rebuild and deploy the generic builder image before enabling callers. + Older builders are rejected rather than accepting a credentialed build silently. + CLI/SDK caller wiring is a separate change; no new CLI flags exist yet. + +Omitting the field (or sending `{}`) preserves existing behavior. + ## Build Status Flow ``` diff --git a/lib/builds/builder_agent/main.go b/lib/builds/builder_agent/main.go index 6138144a9..31630b901 100644 --- a/lib/builds/builder_agent/main.go +++ b/lib/builds/builder_agent/main.go @@ -13,7 +13,6 @@ import ( "bytes" "context" "crypto/sha256" - "encoding/base64" "encoding/hex" "encoding/json" "fmt" @@ -27,6 +26,7 @@ import ( "sync" "time" + "github.com/kernel/hypeman/lib/builds/registryauth" "github.com/mdlayher/vsock" ) @@ -37,6 +37,8 @@ const ( // BuildConfig matches the BuildConfig type from lib/builds/types.go type BuildConfig struct { + RegistryCredentialsRequired bool `json:"registry_credentials_required,omitempty"` + JobID string `json:"job_id"` BaseImageDigest string `json:"base_image_digest,omitempty"` RegistryURL string `json:"registry_url"` @@ -88,6 +90,8 @@ type BuildProvenance struct { // VsockMessage is the envelope for vsock communication type VsockMessage struct { + RegistryCredentials map[string]registryauth.Credential `json:"registry_credentials,omitempty"` + Type string `json:"type"` Result *BuildResult `json:"result,omitempty"` Log string `json:"log,omitempty"` @@ -107,6 +111,8 @@ var ( secretsReady = make(chan struct{}) secretsOnce sync.Once + buildRegistryCredentials map[string]registryauth.Credential + // Encoder lock protects concurrent access to json.Encoder // (the goroutine sending build_result and the main loop handling get_status) encoderLock sync.Mutex @@ -120,6 +126,8 @@ var ( // It also writes to a buffer to include all logs in the final result. type streamingLogWriter struct { buffer *bytes.Buffer + pending []byte + redact func(string) string mu sync.Mutex closed bool closedMu sync.RWMutex @@ -133,9 +141,23 @@ func newStreamingLogWriter() *streamingLogWriter { func (w *streamingLogWriter) Write(p []byte) (n int, err error) { w.mu.Lock() - w.buffer.Write(p) - w.mu.Unlock() + defer w.mu.Unlock() + n = len(p) + if w.redact != nil { + w.pending = append(w.pending, p...) + end := bytes.LastIndexByte(w.pending, '\n') + if end < 0 { + return n, nil + } + p = []byte(w.redact(string(w.pending[:end+1]))) + w.pending = append(w.pending[:0], w.pending[end+1:]...) + } + w.emit(p) + return n, nil +} +func (w *streamingLogWriter) emit(p []byte) { + w.buffer.Write(p) // Hold RLock through the send to prevent markClosed()+close(logChan) // from racing between the check and the channel send. w.closedMu.RLock() @@ -151,11 +173,15 @@ func (w *streamingLogWriter) Write(p []byte) (n int, err error) { // Also write to stdout for local debugging os.Stdout.Write(p) - - return len(p), nil } func (w *streamingLogWriter) markClosed() { + w.mu.Lock() + defer w.mu.Unlock() + if len(w.pending) > 0 { + w.emit([]byte(w.redact(string(w.pending)))) + w.pending = nil + } w.closedMu.Lock() w.closed = true w.closedMu.Unlock() @@ -164,9 +190,27 @@ func (w *streamingLogWriter) markClosed() { func (w *streamingLogWriter) String() string { w.mu.Lock() defer w.mu.Unlock() + if w.redact != nil { + return w.buffer.String() + w.redact(string(w.pending)) + } return w.buffer.String() } +func (w *streamingLogWriter) setRedactor(redact func(string) string) { + w.mu.Lock() + defer w.mu.Unlock() + w.redact = redact +} + +func (w *streamingLogWriter) redactText(value string) string { + w.mu.Lock() + defer w.mu.Unlock() + if w.redact != nil { + return w.redact(value) + } + return value +} + func main() { log.Println("=== Builder Agent Starting ===") @@ -266,11 +310,12 @@ func handleHostConnection(conn net.Conn) { case "host_ready": // Host is ready to handle requests // Request secrets if we have any configured - if err := handleSecretsRequest(encoder, decoder); err != nil { - log.Printf("Failed to fetch secrets: %v", err) + credentials, err := handleSecretsRequest(encoder, decoder) + if err != nil { + log.Printf("Failed to fetch build credentials or secrets: %s", registryauth.Redactor(credentials)(err.Error())) } - // Signal that secrets are ready (even if failed, build can proceed) secretsOnce.Do(func() { + buildRegistryCredentials = credentials close(secretsReady) }) @@ -349,7 +394,8 @@ func handleHostConnection(conn net.Conn) { } // handleSecretsRequest requests secrets from the host and writes them to /run/secrets/ -func handleSecretsRequest(encoder *json.Encoder, decoder *json.Decoder) error { +func handleSecretsRequest(encoder *json.Encoder, decoder *json.Decoder) (map[string]registryauth.Credential, error) { + var credentials map[string]registryauth.Credential // Wait for config to be loaded var config *BuildConfig for i := 0; i < 30; i++ { @@ -364,12 +410,19 @@ func handleSecretsRequest(encoder *json.Encoder, decoder *json.Decoder) error { if config == nil { log.Printf("Config not loaded yet, skipping secrets") - return nil + return credentials, nil } + if config.RegistryCredentialsRequired { + var err error + credentials, err = fetchRegistryCredentials(encoder, decoder, config.RegistryURL) + if err != nil { + return nil, err + } + } if len(config.Secrets) == 0 { log.Printf("No secrets configured") - return nil + return credentials, nil } // Extract secret IDs @@ -389,34 +442,34 @@ func handleSecretsRequest(encoder *json.Encoder, decoder *json.Decoder) error { err := encoder.Encode(req) encoderLock.Unlock() if err != nil { - return fmt.Errorf("send get_secrets: %w", err) + return credentials, fmt.Errorf("send get_secrets: %w", err) } // Wait for secrets_response var resp VsockMessage if err := decoder.Decode(&resp); err != nil { - return fmt.Errorf("receive secrets_response: %w", err) + return credentials, fmt.Errorf("receive secrets_response: %w", err) } if resp.Type != "secrets_response" { - return fmt.Errorf("unexpected response type: %s", resp.Type) + return credentials, fmt.Errorf("unexpected response type: %s", resp.Type) } // Write secrets to /run/secrets/ if err := os.MkdirAll("/run/secrets", 0700); err != nil { - return fmt.Errorf("create secrets dir: %w", err) + return credentials, fmt.Errorf("create secrets dir: %w", err) } for id, value := range resp.Secrets { secretPath := fmt.Sprintf("/run/secrets/%s", id) if err := os.WriteFile(secretPath, []byte(value), 0600); err != nil { - return fmt.Errorf("write secret %s: %w", id, err) + return credentials, fmt.Errorf("write secret %s: %w", id, err) } log.Printf("Wrote secret: %s", id) } log.Printf("Received %d secrets", len(resp.Secrets)) - return nil + return credentials, nil } // runBuildProcess runs the actual build and stores the result @@ -454,17 +507,6 @@ func runBuildProcess() { buildConfig = config buildConfigLock.Unlock() - // Setup registry authentication before running the build - if err := setupRegistryAuth(config); err != nil { - setResult(BuildResult{ - Success: false, - Error: fmt.Sprintf("setup registry auth: %v", err), - Logs: logWriter.String(), - DurationMS: time.Since(start).Milliseconds(), - }) - return - } - // Setup timeout context ctx := context.Background() if config.TimeoutSeconds > 0 { @@ -473,13 +515,17 @@ func runBuildProcess() { defer cancel() } - // Wait for secrets if any are configured - if len(config.Secrets) > 0 { + // Borrowed registry credentials must arrive before BuildKit can start. + if len(config.Secrets) > 0 || config.RegistryCredentialsRequired { log.Printf("Waiting for secrets from host...") select { case <-secretsReady: log.Printf("Secrets ready, proceeding with build") case <-time.After(30 * time.Second): + if config.RegistryCredentialsRequired { + setResult(BuildResult{Error: "timed out waiting for registry credentials", Logs: logWriter.String()}) + return + } log.Printf("Warning: Timeout waiting for secrets, proceeding anyway") // Signal secrets ready to avoid blocking other goroutines secretsOnce.Do(func() { @@ -496,6 +542,28 @@ func runBuildProcess() { } } + var credentials map[string]registryauth.Credential + if config.RegistryCredentialsRequired { + if len(buildRegistryCredentials) == 0 { + setResult(BuildResult{Error: "registry credentials unavailable", Logs: logWriter.String()}) + return + } + credentials = buildRegistryCredentials + for _, credential := range credentials { + if credential.ExpiresAt != nil { + var cancel context.CancelFunc + ctx, cancel = context.WithDeadline(ctx, *credential.ExpiresAt) + defer cancel() + } + } + logWriter.setRedactor(registryauth.Redactor(credentials)) + defer cleanupRegistryAuth("/home/builder/.docker", "/root/.docker") + } + if err := setupRegistryAuth(config, credentials); err != nil { + setResult(BuildResult{Error: "setup registry auth: " + logWriter.redactText(err.Error()), Logs: logWriter.String()}) + return + } + // Ensure Dockerfile exists (either in source or provided via config) dockerfilePath := filepath.Join(config.SourcePath, "Dockerfile") if _, err := os.Stat(dockerfilePath); os.IsNotExist(err) { @@ -536,7 +604,7 @@ func runBuildProcess() { if err != nil { setResult(BuildResult{ Success: false, - Error: err.Error(), + Error: logWriter.redactText(err.Error()), Logs: logWriter.String(), Provenance: provenance, DurationMS: duration, @@ -579,7 +647,7 @@ func loadConfig() (*BuildConfig, error) { // setupRegistryAuth creates a Docker config.json with the registry token for authentication, // and a buildkitd.toml for TLS configuration. // BuildKit uses these files to authenticate and configure TLS when pushing images. -func setupRegistryAuth(config *BuildConfig) error { +func setupRegistryAuth(config *BuildConfig, credentials map[string]registryauth.Credential) error { // Parse registry host (strip any scheme prefix for backwards compatibility) registryHost := config.RegistryURL if strings.HasPrefix(registryHost, "https://") { @@ -591,60 +659,32 @@ func setupRegistryAuth(config *BuildConfig) error { token := config.RegistryToken if token == "" { + if config.RegistryCredentialsRequired { + return fmt.Errorf("local registry token is missing") + } log.Println("No registry token provided, skipping auth setup") return nil } - // Docker config format expects base64-encoded "username:password" or just the token - // For bearer tokens, we use the token directly as the "auth" value - // Format: base64(token + ":") - empty password - authValue := base64.StdEncoding.EncodeToString([]byte(token + ":")) - - // Create the Docker config structure - // Note: Docker config uses host without scheme (e.g., "10.102.0.1:8443") - // We use both auth (Basic) and identitytoken (JWT) to support different BuildKit versions dockerConfig := map[string]interface{}{ - "auths": map[string]interface{}{ - registryHost: map[string]string{ - "auth": authValue, // Basic auth: base64(jwt:) - "identitytoken": token, // JWT directly for OAuth2-style auth - }, - }, + "auths": registryAuthEntries(registryHost, token, credentials), "credsStore": "", "credHelpers": map[string]string{}, } - configData, err := json.MarshalIndent(dockerConfig, "", " ") if err != nil { return fmt.Errorf("marshal docker config: %w", err) } - - // Ensure ~/.docker directory exists - dockerDir := "/home/builder/.docker" - if err := os.MkdirAll(dockerDir, 0700); err != nil { - return fmt.Errorf("create docker config dir: %w", err) - } - - // Write config.json - configPath := filepath.Join(dockerDir, "config.json") - if err := os.WriteFile(configPath, configData, 0600); err != nil { + if err := writeRegistryConfig("/home/builder/.docker", configData); err != nil { return fmt.Errorf("write docker config: %w", err) } - - log.Printf("Docker config created for registry %s (auth length: %d)", registryHost, len(authValue)) - - // Also write to /root/.docker for rootless buildkit that may run as root - rootDockerDir := "/root/.docker" - if err := os.MkdirAll(rootDockerDir, 0700); err == nil { - rootConfigPath := filepath.Join(rootDockerDir, "config.json") - if err := os.WriteFile(rootConfigPath, configData, 0600); err != nil { - log.Printf("Warning: failed to write root docker config: %v", err) - } else { - log.Printf("Registry auth configured at %s", rootConfigPath) + if err := writeRegistryConfig("/root/.docker", configData); err != nil { + if config.RegistryCredentialsRequired { + return fmt.Errorf("write root docker config: %w", err) } + log.Printf("Warning: failed to write root docker config: %v", err) } - - log.Printf("Registry auth configured at %s", configPath) + log.Printf("Registry auth configured for %s", registryHost) // Setup buildkitd.toml for TLS configuration if err := setupBuildkitdConfig(config); err != nil { @@ -737,9 +777,11 @@ func setupBuildkitdConfig(config *BuildConfig) error { // BuildKit will try the mirror first for FROM pulls. Since base images // are pre-cached server-side via mirrorBaseImagesForBuild(), the mirror // will have them and serve them directly without pulling from Docker Hub. - tomlContent.WriteString("\n") - tomlContent.WriteString("[registry.\"docker.io\"]\n") - tomlContent.WriteString(fmt.Sprintf(" mirrors = [\"%s\"]\n", registryHost)) + if !config.RegistryCredentialsRequired { + tomlContent.WriteString("\n") + tomlContent.WriteString("[registry.\"docker.io\"]\n") + tomlContent.WriteString(fmt.Sprintf(" mirrors = [\"%s\"]\n", registryHost)) + } tomlContent.WriteString(gcConfig) diff --git a/lib/builds/builder_agent/registry_auth.go b/lib/builds/builder_agent/registry_auth.go new file mode 100644 index 000000000..1a3c99f11 --- /dev/null +++ b/lib/builds/builder_agent/registry_auth.go @@ -0,0 +1,65 @@ +package main + +import ( + "encoding/base64" + "encoding/json" + "fmt" + "log" + "os" + "path/filepath" + "time" + + "github.com/kernel/hypeman/lib/builds/registryauth" +) + +func fetchRegistryCredentials(encoder *json.Encoder, decoder *json.Decoder, localRegistry string) (map[string]registryauth.Credential, error) { + encoderLock.Lock() + err := encoder.Encode(VsockMessage{Type: "get_registry_credentials"}) + encoderLock.Unlock() + if err != nil { + return nil, fmt.Errorf("request registry credentials") + } + var response VsockMessage + if err := decoder.Decode(&response); err != nil || response.Type != "registry_credentials" || len(response.RegistryCredentials) == 0 { + return nil, fmt.Errorf("receive registry credentials") + } + return registryauth.Normalize(response.RegistryCredentials, localRegistry, time.Now()) +} + +func registryAuthEntries(host, token string, credentials map[string]registryauth.Credential) map[string]map[string]string { + auths := map[string]map[string]string{ + host: {"auth": base64.StdEncoding.EncodeToString([]byte(token + ":")), "identitytoken": token}, + } + for host, credential := range credentials { + auths[registryauth.DockerKey(host)] = map[string]string{"auth": credential.Auth()} + } + return auths +} + +func writeRegistryConfig(directory string, data []byte) error { + if err := os.MkdirAll(directory, 0700); err != nil { + return err + } + if err := os.Chmod(directory, 0700); err != nil { + return err + } + file, err := os.OpenFile(filepath.Join(directory, "config.json"), os.O_CREATE|os.O_WRONLY|os.O_TRUNC, 0600) + if err != nil { + return err + } + defer file.Close() + if err := file.Chmod(0600); err != nil { + return err + } + _, err = file.Write(data) + return err +} + +func cleanupRegistryAuth(directories ...string) { + for _, directory := range directories { + path := filepath.Join(directory, "config.json") + if err := os.Remove(path); err != nil && !os.IsNotExist(err) { + log.Printf("Failed to clean up registry auth file: %s", path) + } + } +} diff --git a/lib/builds/builder_agent/registry_auth_integration_test.go b/lib/builds/builder_agent/registry_auth_integration_test.go new file mode 100644 index 000000000..a1fbda1a7 --- /dev/null +++ b/lib/builds/builder_agent/registry_auth_integration_test.go @@ -0,0 +1,74 @@ +package main + +import ( + "context" + "encoding/json" + "net/http" + "net/http/httptest" + "os" + "os/exec" + "path/filepath" + "runtime" + "strconv" + "strings" + "testing" + "time" + + "github.com/google/go-containerregistry/pkg/authn" + "github.com/google/go-containerregistry/pkg/name" + "github.com/google/go-containerregistry/pkg/registry" + v1 "github.com/google/go-containerregistry/pkg/v1" + "github.com/google/go-containerregistry/pkg/v1/empty" + "github.com/google/go-containerregistry/pkg/v1/mutate" + "github.com/google/go-containerregistry/pkg/v1/remote" + "github.com/kernel/hypeman/lib/builds/registryauth" + "github.com/stretchr/testify/require" +) + +func TestBuildKitUsesBorrowedRegistryConfig(t *testing.T) { + if os.Getenv("HYPEMAN_BUILD_AUTH_DOCKER_TEST") != "1" { + t.Skip("set HYPEMAN_BUILD_AUTH_DOCKER_TEST=1 with Docker available") + } + credential := registryauth.Credential{Username: "AWS", Password: "synthetic-registry-password"} + handler := registry.New() + server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + user, password, _ := r.BasicAuth() + if user != credential.Username || password != credential.Password { + w.Header().Set("WWW-Authenticate", `Basic realm="private"`) + w.WriteHeader(http.StatusUnauthorized) + return + } + handler.ServeHTTP(w, r) + })) + defer server.Close() + host := strings.TrimPrefix(server.URL, "http://") + ref, err := name.ParseReference(host + "/private/base:latest") + require.NoError(t, err) + img, err := mutate.ConfigFile(empty.Image, &v1.ConfigFile{Architecture: runtime.GOARCH, OS: "linux"}) + require.NoError(t, err) + require.NoError(t, remote.Write(ref, img, remote.WithAuth(authn.FromConfig(authn.AuthConfig{Username: credential.Username, Password: credential.Password})))) + contextDir, authDir := t.TempDir(), t.TempDir() + require.NoError(t, os.WriteFile(filepath.Join(contextDir, "Dockerfile"), []byte("FROM "+ref.Name()+"\n"), 0600)) + ctx, cancel := context.WithTimeout(context.Background(), time.Minute) + defer cancel() + tag := "hypeman-registry-auth-test:" + strconv.FormatInt(time.Now().UnixNano(), 10) + build := func() ([]byte, error) { + cmd := exec.CommandContext(ctx, "docker", "build", "--progress=plain", "--no-cache", "--pull", "-t", tag, contextDir) + cmd.Env = append(os.Environ(), "DOCKER_CONFIG="+authDir) + return cmd.CombinedOutput() + } + _, err = build() + require.Error(t, err, "private base must reject unauthenticated builds") + config, err := json.Marshal(map[string]any{"auths": registryAuthEntries("local.example:4973", "local-token", map[string]registryauth.Credential{host: credential})}) + require.NoError(t, err) + require.NoError(t, writeRegistryConfig(authDir, config)) + defer exec.Command("docker", "image", "rm", "-f", tag).Run() + output, err := build() + require.NoError(t, err, "%s", output) + require.NotContains(t, string(output), credential.Password) + require.NotContains(t, string(output), credential.Auth()) + inspect, err := exec.CommandContext(ctx, "docker", "image", "inspect", tag).Output() + require.NoError(t, err) + require.NotContains(t, string(inspect), credential.Password) + require.NotContains(t, string(inspect), credential.Auth()) +} diff --git a/lib/builds/builder_agent/registry_auth_test.go b/lib/builds/builder_agent/registry_auth_test.go new file mode 100644 index 000000000..0b9a04edb --- /dev/null +++ b/lib/builds/builder_agent/registry_auth_test.go @@ -0,0 +1,145 @@ +package main + +import ( + "encoding/base64" + "encoding/json" + "io" + "net" + "os" + "path/filepath" + "strconv" + "strings" + "testing" + + "github.com/kernel/hypeman/lib/builds/registryauth" + "github.com/stretchr/testify/require" +) + +func TestRegistryCredentialHandoffAndConfig(t *testing.T) { + host, guest := net.Pipe() + defer host.Close() + defer guest.Close() + credentials := map[string]registryauth.Credential{"registry.example": {Username: "AWS", Password: "synthetic-token"}} + done := make(chan error, 1) + go func() { + var request VsockMessage + if err := json.NewDecoder(host).Decode(&request); err != nil { + done <- err + return + } + if request.Type != "get_registry_credentials" { + done <- registryauth.ErrInvalid + return + } + done <- json.NewEncoder(host).Encode(VsockMessage{Type: "registry_credentials", RegistryCredentials: credentials}) + }() + got, err := fetchRegistryCredentials(json.NewEncoder(guest), json.NewDecoder(guest), "local.example:4973") + require.NoError(t, err) + require.NoError(t, <-done) + auths := registryAuthEntries("local.example:4973", "local-token", got) + require.Equal(t, "local-token", auths["local.example:4973"]["identitytoken"]) + require.Equal(t, base64.StdEncoding.EncodeToString([]byte("AWS:synthetic-token")), auths["registry.example"]["auth"]) + require.Len(t, auths, 2) + data, err := json.Marshal(map[string]any{"auths": auths}) + require.NoError(t, err) + directory := filepath.Join(t.TempDir(), ".docker") + require.NoError(t, writeRegistryConfig(directory, data)) + info, err := os.Stat(filepath.Join(directory, "config.json")) + require.NoError(t, err) + require.Equal(t, os.FileMode(0600), info.Mode().Perm()) + info, err = os.Stat(directory) + require.NoError(t, err) + require.Equal(t, os.FileMode(0700), info.Mode().Perm()) + // Rewriting config must not retain a previous build's external credentials. + data, err = json.Marshal(map[string]any{"auths": registryAuthEntries("local.example:4973", "next-local-token", nil)}) + require.NoError(t, err) + require.NoError(t, writeRegistryConfig(directory, data)) + written, err := os.ReadFile(filepath.Join(directory, "config.json")) + require.NoError(t, err) + require.NotContains(t, string(written), got["registry.example"].Auth()) + cleanupRegistryAuth(directory) + require.NoFileExists(t, filepath.Join(directory, "config.json")) +} + +func TestRegistryCredentialsSurviveSecretsHandshakeError(t *testing.T) { + buildConfigLock.Lock() + previous := buildConfig + buildConfig = &BuildConfig{RegistryCredentialsRequired: true, RegistryURL: "local.example:4973", Secrets: []SecretRef{{ID: "missing"}}} + buildConfigLock.Unlock() + defer func() { + buildConfigLock.Lock() + buildConfig = previous + buildConfigLock.Unlock() + }() + host, guest := net.Pipe() + defer host.Close() + defer guest.Close() + done := make(chan error, 1) + go func() { + defer host.Close() + decoder, encoder := json.NewDecoder(host), json.NewEncoder(host) + var request VsockMessage + if err := decoder.Decode(&request); err != nil { + done <- err + return + } + if request.Type != "get_registry_credentials" { + done <- registryauth.ErrInvalid + return + } + if err := encoder.Encode(VsockMessage{Type: "registry_credentials", RegistryCredentials: map[string]registryauth.Credential{ + "registry.example": {Username: "AWS", Password: "synthetic-token"}, + }}); err != nil { + done <- err + return + } + if err := decoder.Decode(&request); err != nil { + done <- err + return + } + if request.Type != "get_secrets" { + done <- registryauth.ErrInvalid + return + } + done <- nil + }() + credentials, err := handleSecretsRequest(json.NewEncoder(guest), json.NewDecoder(guest)) + require.ErrorContains(t, err, "receive secrets_response") + require.Equal(t, "synthetic-token", credentials["registry.example"].Password) + require.NoError(t, <-done) +} + +func TestRegistryCredentialLogRedactionAcrossWrites(t *testing.T) { + oldStdout := os.Stdout + read, write, err := os.Pipe() + require.NoError(t, err) + os.Stdout = write + defer func() { os.Stdout = oldStdout; read.Close(); write.Close() }() + oldChan := logChan + logChan = make(chan string, 100) + defer func() { logChan = oldChan }() + credential := registryauth.Credential{Username: "AWS", Password: `synthetic-"secret"/+=<&>`} + writer := newStreamingLogWriter() + writer.setRedactor(registryauth.Redactor(map[string]registryauth.Credential{"registry.example": credential})) + quoted, err := json.Marshal(credential.Password) + require.NoError(t, err) + input := "pull " + credential.Password + "\nconfig " + credential.Auth() + "\nquoted " + string(quoted) + "\nplain-quoted " + strconv.Quote(credential.Password) + for _, b := range []byte(input) { + _, err = writer.Write([]byte{b}) + require.NoError(t, err) + } + writer.markClosed() + require.NoError(t, write.Close()) + stdout, err := io.ReadAll(read) + require.NoError(t, err) + streamed := "" + for len(logChan) > 0 { + streamed += <-logChan + } + for _, output := range []string{string(stdout), streamed, writer.String(), writer.redactText(input)} { + require.NotContains(t, output, credential.Password) + require.NotContains(t, output, credential.Auth()) + require.NotContains(t, output, string(quoted)) + require.Equal(t, 4, strings.Count(output, "[REDACTED]")) + } +} diff --git a/lib/builds/images/generic/Dockerfile b/lib/builds/images/generic/Dockerfile index 937efb68e..3ea20e1f2 100644 --- a/lib/builds/images/generic/Dockerfile +++ b/lib/builds/images/generic/Dockerfile @@ -16,6 +16,7 @@ RUN go mod download # Copy the builder_agent and guest_agent sources COPY lib/builds/builder_agent/ ./lib/builds/builder_agent/ +COPY lib/builds/registryauth/ ./lib/builds/registryauth/ COPY lib/system/guest_agent/ ./lib/system/guest_agent/ # Only copy proto files for guest-agent (not client.go which has host-side deps) COPY lib/guest/guest.pb.go lib/guest/guest_grpc.pb.go ./lib/guest/ diff --git a/lib/builds/manager.go b/lib/builds/manager.go index 3e429bfe0..924f1578a 100644 --- a/lib/builds/manager.go +++ b/lib/builds/manager.go @@ -19,6 +19,7 @@ import ( "github.com/google/go-containerregistry/pkg/v1/tarball" "github.com/kernel/hypeman/lib/builders" + "github.com/kernel/hypeman/lib/builds/registryauth" "github.com/kernel/hypeman/lib/images" "github.com/kernel/hypeman/lib/instances" "github.com/kernel/hypeman/lib/ocicache" @@ -143,6 +144,9 @@ func stripRegistryScheme(registryURL string) string { } type manager struct { + credentialsMu sync.Mutex + registryCredentials map[string]*borrowedBuildCredentials + config Config paths *paths.Paths queue *BuildQueue @@ -451,6 +455,12 @@ func (m *manager) CreateBuild(ctx context.Context, req CreateBuildRequest, sourc return nil, err } req.Tags = tags.Clone(req.Tags) + credentials, err := registryauth.Normalize(req.RegistryCredentials, m.config.RegistryURL, time.Now()) + if err != nil { + return nil, err + } + req.RequiresRegistryCredentials = len(credentials) > 0 + req.RegistryCredentials = nil // Apply defaults to build policy policy := req.BuildPolicy @@ -585,7 +595,9 @@ func (m *manager) CreateBuild(ctx context.Context, req CreateBuildRequest, sourc // Write build config for the builder agent buildConfig := &BuildConfig{ - JobID: id, + JobID: id, + RegistryCredentialsRequired: req.RequiresRegistryCredentials, + BaseImageDigest: req.BaseImageDigest, RegistryURL: m.config.RegistryURL, RegistryToken: registryToken, @@ -610,6 +622,10 @@ func (m *manager) CreateBuild(ctx context.Context, req CreateBuildRequest, sourc return nil, fmt.Errorf("write build config: %w", err) } + if req.RequiresRegistryCredentials { + m.holdRegistryCredentials(id, credentials) + } + // Enqueue the build. Builds sharing a builder are serialized by builder // ID so a waiting same-builder build stays pending instead of holding a // global concurrency slot while blocked on the builder's disk. @@ -740,6 +756,7 @@ func (m *manager) gcFinishedBuilds() { // runBuild executes a build in a builder VM func (m *manager) runBuild(ctx context.Context, id string, req CreateBuildRequest, policy *BuildPolicy) { start := time.Now() + defer m.releaseRegistryCredentials(id) m.logger.Info("starting build", "id", id) // Update status to building @@ -749,15 +766,33 @@ func (m *manager) runBuild(ctx context.Context, id string, req CreateBuildReques buildCtx, cancel := context.WithTimeout(ctx, time.Duration(policy.TimeoutSeconds)*time.Second) defer cancel() - // Mirror base images to the local registry before launching the VM. - // BuildKit is configured with our registry as a mirror for docker.io, - // so pre-cached images will be served locally without pulling from Docker Hub. - if err := m.mirrorBaseImagesForBuild(buildCtx, id, req); err != nil { - m.logger.Warn("failed to mirror base images", "id", id, "error", err) + redact := func(value string) string { return value } + var err error + if req.RequiresRegistryCredentials { + var credentials map[string]registryauth.Credential + var expires time.Time + credentials, expires, err = m.borrowRegistryCredentials(id) + if err == nil { + redact = registryauth.Redactor(credentials) + var deadlineCancel context.CancelFunc + buildCtx, deadlineCancel = context.WithDeadline(buildCtx, expires) + defer deadlineCancel() + } + } else if mirrorErr := m.mirrorBaseImagesForBuild(buildCtx, id, req); mirrorErr != nil { + m.logger.Warn("failed to mirror base images", "id", id, "error", mirrorErr) + } + // Private bases stay inside this build rather than entering the shared mirror. + var result *BuildResult + if err == nil { + result, err = m.executeBuild(buildCtx, id, req, policy) + } + if err != nil { + err = errors.New(redact(err.Error())) + } + if result != nil { + result.Logs = redact(result.Logs) + result.Error = redact(result.Error) } - - // Run the build in a builder VM - result, err := m.executeBuild(buildCtx, id, req, policy) // executeBuild's defers release the builder acquisition when it returns, // so same-builder builds may start while this build waits for image @@ -1002,7 +1037,7 @@ func (m *manager) executeBuild(ctx context.Context, id string, req CreateBuildRe // Wait for build result via vsock // The builder agent will send the result when complete - result, err := m.waitForResult(ctx, id, inst) + result, err := m.waitForResult(ctx, id, inst, req.RequiresRegistryCredentials) if err != nil { return nil, fmt.Errorf("wait for result: %w", err) } @@ -1011,7 +1046,7 @@ func (m *manager) executeBuild(ctx context.Context, id string, req CreateBuildRe } // waitForResult waits for the build result from the builder agent via vsock -func (m *manager) waitForResult(ctx context.Context, buildID string, inst *instances.Instance) (*BuildResult, error) { +func (m *manager) waitForResult(ctx context.Context, buildID string, inst *instances.Instance, requiresRegistryCredentials bool) (*BuildResult, error) { // Wait a bit for the VM to start and the builder agent to listen on vsock time.Sleep(3 * time.Second) @@ -1073,6 +1108,15 @@ func (m *manager) waitForResult(ctx context.Context, buildID string, inst *insta } m.logger.Debug("host_ready sent, waiting for agent messages", "instance", inst.Id) + credentialsDelivered := false + redact := func(value string) string { return value } + if requiresRegistryCredentials { + credentials, _, err := m.borrowRegistryCredentials(buildID) + if err != nil { + return nil, err + } + redact = registryauth.Redactor(credentials) + } // Handle messages from agent until we get the build result for { // Use a goroutine for decoding so we can respect context cancellation. @@ -1101,9 +1145,27 @@ func (m *manager) waitForResult(ctx context.Context, buildID string, inst *insta } } + failedResult := dr.response.Type == "build_result" && dr.response.Result != nil && !dr.response.Result.Success + if requiresRegistryCredentials && !credentialsDelivered && dr.response.Type != "get_registry_credentials" && dr.response.Type != "log" && !failedResult { + return nil, fmt.Errorf("builder does not support borrowed registry credentials; update the builder image") + } + dr.response.Log = redact(dr.response.Log) + if dr.response.Result != nil { + dr.response.Result.Logs = redact(dr.response.Result.Logs) + dr.response.Result.Error = redact(dr.response.Result.Error) + } // Handle message based on type - m.logger.Debug("received message from agent", "type", dr.response.Type, "instance", inst.Id) + m.logger.Debug("received message from agent", "type", redact(dr.response.Type), "instance", inst.Id) switch dr.response.Type { + case "get_registry_credentials": + credentials, _, err := m.borrowRegistryCredentials(buildID) + if err != nil { + return nil, err + } + if err := encoder.Encode(VsockMessage{Type: "registry_credentials", RegistryCredentials: credentials}); err != nil { + return nil, fmt.Errorf("send registry credentials: %w", err) + } + credentialsDelivered = true case "get_secrets": // Agent is requesting secrets m.logger.Debug("agent requesting secrets", "instance", inst.Id, "secret_ids", dr.response.SecretIDs) @@ -1137,7 +1199,7 @@ func (m *manager) waitForResult(ctx context.Context, buildID string, inst *insta return dr.response.Result, nil default: - m.logger.Warn("unexpected message type from agent", "type", dr.response.Type) + m.logger.Warn("unexpected message type from agent", "type", redact(dr.response.Type)) } } } @@ -1179,6 +1241,7 @@ func (m *manager) updateStatus(id string, status string, err error) error { // updateBuildComplete updates the build with final results func (m *manager) updateBuildComplete(id string, status string, digest *string, errMsg *string, provenance *BuildProvenance, durationMS *int64) { + m.releaseRegistryCredentials(id) meta, readErr := readMetadata(m.paths, id) if readErr != nil { m.logger.Error("read metadata for completion", "id", id, "error", readErr) @@ -1328,6 +1391,7 @@ func (m *manager) CancelBuild(ctx context.Context, id string) error { if !cancelled { return ErrBuildInProgress // Was already picked up } + m.releaseRegistryCredentials(id) return nil case StatusBuilding, StatusPushing: @@ -1336,7 +1400,11 @@ func (m *manager) CancelBuild(ctx context.Context, id string) error { if meta.BuilderInstance != nil { m.instanceManager.DeleteInstance(ctx, *meta.BuilderInstance) } - return m.updateStatus(id, StatusCancelled, nil) + err := m.updateStatus(id, StatusCancelled, nil) + if err == nil { + m.releaseRegistryCredentials(id) + } + return err case StatusReady, StatusFailed, StatusCancelled: return fmt.Errorf("build already completed with status: %s", meta.Status) @@ -1536,6 +1604,19 @@ func (m *manager) RecoverPendingBuilds() { for _, meta := range pending { meta := meta // Shadow loop variable for closure capture m.logger.Info("recovering build", "id", meta.ID, "status", meta.Status) + if meta.Request != nil && meta.Request.RequiresRegistryCredentials { + if _, _, err := m.borrowRegistryCredentials(meta.ID); err == nil { + continue // Already queued in this process with live credentials. + } + if meta.BuilderInstance != nil { + if err := m.instanceManager.DeleteInstance(context.Background(), *meta.BuilderInstance); err != nil { + m.logger.Error("delete interrupted credentialed builder", "id", meta.ID, "error", err) + } + } + errMsg := errRegistryCredentialsUnavailable.Error() + m.updateBuildComplete(meta.ID, StatusFailed, nil, &errMsg, nil, nil) + continue + } // Re-enqueue the build if meta.Request != nil { diff --git a/lib/builds/registry_credentials.go b/lib/builds/registry_credentials.go new file mode 100644 index 000000000..51f316620 --- /dev/null +++ b/lib/builds/registry_credentials.go @@ -0,0 +1,61 @@ +package builds + +import ( + "errors" + "maps" + "time" + + "github.com/kernel/hypeman/lib/builds/registryauth" + "github.com/kernel/hypeman/lib/images" +) + +var errRegistryCredentialsUnavailable = errors.New("build registry credentials expired or unavailable; submit a new build with fresh credentials") + +type borrowedBuildCredentials struct { + credentials map[string]registryauth.Credential + expiresAt time.Time + timer *time.Timer +} + +func (m *manager) holdRegistryCredentials(id string, credentials map[string]registryauth.Credential) { + expires := time.Now().Add(images.DefaultBorrowedCredentialsTimeout) + for _, c := range credentials { + if c.ExpiresAt != nil && c.ExpiresAt.Before(expires) { + expires = *c.ExpiresAt + } + } + m.credentialsMu.Lock() + defer m.credentialsMu.Unlock() + if m.registryCredentials == nil { + m.registryCredentials = make(map[string]*borrowedBuildCredentials) + } + entry := &borrowedBuildCredentials{credentials: credentials, expiresAt: expires} + m.registryCredentials[id] = entry + entry.timer = time.AfterFunc(time.Until(expires), func() { m.releaseRegistryCredentials(id) }) +} + +func (m *manager) borrowRegistryCredentials(id string) (map[string]registryauth.Credential, time.Time, error) { + m.credentialsMu.Lock() + defer m.credentialsMu.Unlock() + entry := m.registryCredentials[id] + if entry == nil || !time.Now().Before(entry.expiresAt) { + return nil, time.Time{}, errRegistryCredentialsUnavailable + } + credentials := maps.Clone(entry.credentials) + for host, credential := range credentials { + expires := entry.expiresAt + credential.ExpiresAt = &expires + credentials[host] = credential + } + return credentials, entry.expiresAt, nil +} + +func (m *manager) releaseRegistryCredentials(id string) { + m.credentialsMu.Lock() + defer m.credentialsMu.Unlock() + if entry := m.registryCredentials[id]; entry != nil { + entry.timer.Stop() + entry.credentials = nil + delete(m.registryCredentials, id) + } +} diff --git a/lib/builds/registry_credentials_test.go b/lib/builds/registry_credentials_test.go new file mode 100644 index 000000000..e54ee119c --- /dev/null +++ b/lib/builds/registry_credentials_test.go @@ -0,0 +1,176 @@ +package builds + +import ( + "context" + "encoding/json" + "net" + "os" + "strings" + "testing" + "time" + + "github.com/kernel/hypeman/lib/builds/registryauth" + "github.com/kernel/hypeman/lib/hypervisor" + "github.com/kernel/hypeman/lib/instances" + "github.com/stretchr/testify/require" +) + +func TestBuildRegistryCredentialsLifetime(t *testing.T) { + for _, outcome := range []string{"cancel", "complete", "expire", "restart"} { + t.Run(outcome, func(t *testing.T) { + mgr, instanceMgr, _, dir := setupTestManager(t) + defer os.RemoveAll(dir) + mgr.queue = NewBuildQueue(1) + mgr.queue.active["occupied"] = true + const secret = "synthetic-build-secret" + credentials := map[string]registryauth.Credential{"registry.example": {Username: "AWS", Password: secret}} + build, err := mgr.CreateBuild(context.Background(), CreateBuildRequest{ + Dockerfile: "FROM registry.example/base:1", RegistryCredentials: credentials, + }, []byte("source")) + require.NoError(t, err) + t.Cleanup(func() { mgr.releaseRegistryCredentials(build.ID) }) + credentials["registry.example"] = registryauth.Credential{} + borrowed, deadline, err := mgr.borrowRegistryCredentials(build.ID) + require.NoError(t, err) + require.Equal(t, secret, borrowed["registry.example"].Password) + require.WithinDuration(t, time.Now().Add(30*time.Minute), deadline, time.Second) + for _, path := range []string{mgr.paths.BuildMetadata(build.ID), mgr.paths.BuildConfig(build.ID)} { + data, err := os.ReadFile(path) + require.NoError(t, err) + require.NotContains(t, string(data), secret) + require.NotContains(t, string(data), borrowed["registry.example"].Auth()) + } + config, err := readBuildConfig(mgr.paths, build.ID) + require.NoError(t, err) + require.True(t, config.RegistryCredentialsRequired) + mgr.RecoverPendingBuilds() + fresh, err := mgr.GetBuild(context.Background(), build.ID) + require.NoError(t, err) + require.Equal(t, StatusQueued, fresh.Status) + switch outcome { + case "cancel": + require.NoError(t, mgr.CancelBuild(context.Background(), build.ID)) + case "complete": + mgr.updateBuildComplete(build.ID, StatusReady, nil, nil, nil, nil) + case "expire": + mgr.credentialsMu.Lock() + mgr.registryCredentials[build.ID].expiresAt = time.Now().Add(-time.Second) + mgr.credentialsMu.Unlock() + meta, err := readMetadata(mgr.paths, build.ID) + require.NoError(t, err) + mgr.instanceManager = nil // Must fail before any VM can launch. + mgr.runBuild(context.Background(), build.ID, *meta.Request, &BuildPolicy{TimeoutSeconds: 5}) + meta, err = readMetadata(mgr.paths, build.ID) + require.NoError(t, err) + require.Equal(t, StatusFailed, meta.Status) + case "restart": + mgr.releaseRegistryCredentials(build.ID) + meta, err := readMetadata(mgr.paths, build.ID) + require.NoError(t, err) + instanceID := "old-builder" + meta.BuilderInstance = &instanceID + require.NoError(t, writeMetadata(mgr.paths, meta)) + mgr.queue = NewBuildQueue(1) + mgr.RecoverPendingBuilds() + meta, err = readMetadata(mgr.paths, build.ID) + require.NoError(t, err) + require.Equal(t, StatusFailed, meta.Status) + require.Equal(t, 1, instanceMgr.deleteCallCount) + require.Zero(t, mgr.queue.QueueLength()) + } + _, _, err = mgr.borrowRegistryCredentials(build.ID) + require.ErrorIs(t, err, errRegistryCredentialsUnavailable) + }) + } +} + +func TestRegistryCredentialExpiryReleasesMemory(t *testing.T) { + mgr, _, _, dir := setupTestManager(t) + defer os.RemoveAll(dir) + expires := time.Now().Add(50 * time.Millisecond) + mgr.holdRegistryCredentials("expired", map[string]registryauth.Credential{ + "registry.example": {Username: "AWS", Password: "synthetic-token", ExpiresAt: &expires}, + }) + defer mgr.releaseRegistryCredentials("expired") + require.Eventually(t, func() bool { + mgr.credentialsMu.Lock() + defer mgr.credentialsMu.Unlock() + return mgr.registryCredentials["expired"] == nil + }, time.Second, 5*time.Millisecond) +} + +type credentialTestDialer struct{ net.Conn } + +func (d credentialTestDialer) DialVsock(context.Context, int) (net.Conn, error) { return d.Conn, nil } +func (d credentialTestDialer) Key() string { return "registry-auth-test" } + +func TestRegistryCredentialsVsock(t *testing.T) { + for _, scenario := range []string{"handoff", "old-builder", "startup-failure"} { + t.Run(scenario, func(t *testing.T) { + supported := scenario == "handoff" + mgr, instanceMgr, _, dir := setupTestManager(t) + defer os.RemoveAll(dir) + credentials := map[string]registryauth.Credential{"registry.example": {Username: "AWS", Password: `synthetic-"secret"`}} + mgr.holdRegistryCredentials("build", credentials) + defer mgr.releaseRegistryCredentials("build") + require.NoError(t, os.MkdirAll(mgr.paths.BuildDir("build"), 0755)) + host, guest := net.Pipe() + defer guest.Close() + instanceMgr.vsockDialerFunc = func(context.Context, string) (hypervisor.VsockDialer, error) { return credentialTestDialer{host}, nil } + done := make(chan error, 1) + go func() { + decoder, encoder := json.NewDecoder(guest), json.NewEncoder(guest) + var message VsockMessage + if err := decoder.Decode(&message); err != nil { + done <- err + return + } + if supported { + if err := encoder.Encode(VsockMessage{Type: "get_registry_credentials"}); err != nil { + done <- err + return + } + if err := decoder.Decode(&message); err != nil { + done <- err + return + } + if message.RegistryCredentials["registry.example"].Password != credentials["registry.example"].Password { + done <- registryauth.ErrInvalid + return + } + if err := encoder.Encode(VsockMessage{Type: "log", Log: credentials["registry.example"].Auth()}); err != nil { + done <- err + return + } + } + if !supported { + if err := encoder.Encode(VsockMessage{Type: "log", Log: credentials["registry.example"].Auth()}); err != nil { + done <- err + return + } + } + result := &BuildResult{Success: true, Logs: credentials["registry.example"].Password} + if scenario == "startup-failure" { + result.Success = false + result.Error = "load config: missing build.json" + } + done <- encoder.Encode(VsockMessage{Type: "build_result", Result: result}) + }() + result, err := mgr.waitForResult(context.Background(), "build", &instances.Instance{StoredMetadata: instances.StoredMetadata{Id: "vm"}}, true) + require.NoError(t, <-done) + if scenario == "old-builder" { + require.ErrorContains(t, err, "update the builder image") + return + } + require.NoError(t, err) + require.Equal(t, "[REDACTED]", result.Logs) + if scenario == "startup-failure" { + require.False(t, result.Success) + require.Equal(t, "load config: missing build.json", result.Error) + } + data, err := os.ReadFile(mgr.paths.BuildLog("build")) + require.NoError(t, err) + require.False(t, strings.Contains(string(data), credentials["registry.example"].Auth())) + }) + } +} diff --git a/lib/builds/registryauth/credentials.go b/lib/builds/registryauth/credentials.go new file mode 100644 index 000000000..576207ac7 --- /dev/null +++ b/lib/builds/registryauth/credentials.go @@ -0,0 +1,106 @@ +// Package registryauth describes credentials borrowed by a single build. +package registryauth + +import ( + "encoding/base64" + "encoding/json" + "errors" + "net/url" + "sort" + "strings" + "time" + + "github.com/google/go-containerregistry/pkg/name" +) + +const MaxBytes = 64 * 1024 + +var ErrInvalid = errors.New("invalid registry_credentials: use registry hosts and nonempty username/password pairs with a future expires_at") + +type Credential struct { + Username string `json:"username"` + Password string `json:"password"` + ExpiresAt *time.Time `json:"expires_at,omitempty"` +} + +// String prevents accidental formatting of a credential from disclosing its value. +func (Credential) String() string { return "[registry credential]" } + +// Normalize validates hosts, rejects local-registry overrides, and copies caller-owned values. +func Normalize(credentials map[string]Credential, localRegistry string, now time.Time) (map[string]Credential, error) { + if len(credentials) == 0 { + return make(map[string]Credential), nil + } + if len(credentials) > 16 { + return nil, ErrInvalid + } + localRegistry = strings.TrimPrefix(strings.TrimPrefix(localRegistry, "https://"), "http://") + local, err := name.NewRegistry(strings.ToLower(localRegistry)) + if err != nil { + return nil, ErrInvalid + } + out := make(map[string]Credential, len(credentials)) + size := 0 + for host, credential := range credentials { + size += len(host) + len(credential.Username) + len(credential.Password) + u, err := url.Parse("https://" + host) + if err != nil || u.Host != host || u.Hostname() == "" || u.User != nil || u.Path != "" || u.RawQuery != "" || u.Fragment != "" || strings.ContainsAny(host, " \t\r\n") { + return nil, ErrInvalid + } + registry, err := name.NewRegistry(strings.ToLower(host)) + if err != nil || registry.Name() == local.Name() || size > MaxBytes || credential.Username == "" || credential.Password == "" || strings.ContainsAny(credential.Username+credential.Password, "\r\n") { + return nil, ErrInvalid + } + if credential.ExpiresAt != nil { + expires := *credential.ExpiresAt + if !expires.After(now) { + return nil, ErrInvalid + } + credential.ExpiresAt = &expires + } + if _, exists := out[registry.Name()]; exists { + return nil, ErrInvalid + } + out[registry.Name()] = credential + } + return out, nil +} + +func DockerKey(host string) string { + if host == name.DefaultRegistry { + return "https://index.docker.io/v1/" + } + return host +} + +func (c Credential) Auth() string { + return base64.StdEncoding.EncodeToString([]byte(c.Username + ":" + c.Password)) +} + +// Redactor covers raw, JSON-escaped, URL-encoded, and Docker-config representations. +func Redactor(credentials map[string]Credential) func(string) string { + values := make(map[string]bool) + for _, c := range credentials { + quoted, _ := json.Marshal(c.Password) + var plain strings.Builder + encoder := json.NewEncoder(&plain) + encoder.SetEscapeHTML(false) + _ = encoder.Encode(c.Password) + plainQuoted := strings.TrimSuffix(plain.String(), "\n") + for _, value := range []string{c.Password, c.Auth(), base64.StdEncoding.EncodeToString([]byte(c.Password)), string(quoted[1 : len(quoted)-1]), plainQuoted[1 : len(plainQuoted)-1], url.QueryEscape(c.Password), url.PathEscape(c.Password)} { + if value != "" { + values[value] = true + } + } + } + keys := make([]string, 0, len(values)) + for key := range values { + keys = append(keys, key) + } + sort.Slice(keys, func(i, j int) bool { return len(keys[i]) > len(keys[j]) }) + pairs := make([]string, 0, len(keys)*2) + for _, key := range keys { + pairs = append(pairs, key, "[REDACTED]") + } + return strings.NewReplacer(pairs...).Replace +} diff --git a/lib/builds/registryauth/credentials_test.go b/lib/builds/registryauth/credentials_test.go new file mode 100644 index 000000000..04b951c07 --- /dev/null +++ b/lib/builds/registryauth/credentials_test.go @@ -0,0 +1,42 @@ +package registryauth + +import ( + "encoding/base64" + "encoding/json" + "strconv" + "strings" + "testing" + "time" + + "github.com/stretchr/testify/require" +) + +func TestNormalizeAndRedact(t *testing.T) { + expires := time.Now().Add(time.Hour) + password := `synthetic-"secret"/+=<&>` + input := map[string]Credential{"REGISTRY.EXAMPLE": {Username: "AWS", Password: password, ExpiresAt: &expires}} + got, err := Normalize(input, "http://local.example:4973", time.Now()) + require.NoError(t, err) + require.Equal(t, password, got["registry.example"].Password) + input["REGISTRY.EXAMPLE"] = Credential{} + expires = time.Time{} + require.True(t, got["registry.example"].ExpiresAt.After(time.Now())) + redact := Redactor(got) + quoted, err := json.Marshal(password) + require.NoError(t, err) + for _, value := range []string{password, string(quoted), strconv.Quote(password), base64.StdEncoding.EncodeToString([]byte("AWS:" + password))} { + require.NotContains(t, redact("before "+value+" after"), value) + require.Contains(t, redact(value), "[REDACTED]") + } + for _, host := range []string{"https://registry.example", "registry.example/path", "registry.example?x=y", "user:pass@registry.example", "local.example:4973", "registry.example\n"} { + _, err := Normalize(map[string]Credential{host: {Username: "AWS", Password: password}}, "local.example:4973", time.Now()) + require.ErrorIs(t, err, ErrInvalid) + require.NotContains(t, err.Error(), password) + } + for _, credential := range []Credential{{Username: "AWS"}, {Password: password}, {Username: "AWS", Password: "line\nbreak"}, {Username: "AWS", Password: password, ExpiresAt: &expires}, {Username: "AWS", Password: strings.Repeat("x", MaxBytes+1)}} { + _, err := Normalize(map[string]Credential{"registry.example": credential}, "local.example:4973", time.Now()) + require.ErrorIs(t, err, ErrInvalid) + } + _, err = Normalize(map[string]Credential{"docker.io": {Username: "u", Password: "p"}, "index.docker.io": {Username: "u", Password: "p"}}, "local.example:4973", time.Now()) + require.ErrorIs(t, err, ErrInvalid) +} diff --git a/lib/builds/types.go b/lib/builds/types.go index 4ad6008e9..f79edff71 100644 --- a/lib/builds/types.go +++ b/lib/builds/types.go @@ -6,6 +6,7 @@ import ( "fmt" "time" + "github.com/kernel/hypeman/lib/builds/registryauth" "github.com/kernel/hypeman/lib/tags" ) @@ -39,6 +40,11 @@ type Build struct { // CreateBuildRequest represents a request to create a new build type CreateBuildRequest struct { + // RegistryCredentials are borrowed for this build and never serialized to disk. + RegistryCredentials map[string]registryauth.Credential `json:"-"` + // RequiresRegistryCredentials makes interrupted builds fail closed on recovery. + RequiresRegistryCredentials bool `json:"requires_registry_credentials,omitempty"` + // Dockerfile content. Required if not included in the source tarball. // The Dockerfile specifies the runtime (e.g., FROM node:20-alpine). Dockerfile string `json:"dockerfile,omitempty"` @@ -133,6 +139,8 @@ type BuildProvenance struct { // BuildConfig is the configuration passed to the builder VM via config disk // This is read by the builder agent inside the guest type BuildConfig struct { + RegistryCredentialsRequired bool `json:"registry_credentials_required,omitempty"` + // JobID is the build job identifier JobID string `json:"job_id"` diff --git a/lib/builds/vsock_handler.go b/lib/builds/vsock_handler.go index f5aebfcd9..c0815ab0c 100644 --- a/lib/builds/vsock_handler.go +++ b/lib/builds/vsock_handler.go @@ -2,6 +2,8 @@ package builds import ( "context" + + "github.com/kernel/hypeman/lib/builds/registryauth" ) const ( @@ -14,6 +16,8 @@ const ( // VsockMessage is the envelope for vsock communication with builder agents type VsockMessage struct { + RegistryCredentials map[string]registryauth.Credential `json:"registry_credentials,omitempty"` + Type string `json:"type"` Result *BuildResult `json:"result,omitempty"` Log string `json:"log,omitempty"` diff --git a/lib/oapi/oapi.go b/lib/oapi/oapi.go index d4d82dfd7..9c04386dd 100644 --- a/lib/oapi/oapi.go +++ b/lib/oapi/oapi.go @@ -2015,6 +2015,20 @@ type CreateBuildMultipartBody struct { // MemoryMb Memory limit for builder VM in MB (default 2048) MemoryMb *int `json:"memory_mb,omitempty"` + // RegistryCredentials JSON object mapping exact registry hosts (no scheme or path) to + // objects with required username/password strings and optional RFC3339 + // expires_at. At most 16 registries; credentials + // cannot override Hypeman's local output registry. No CR/LF in values. + // Held in host memory for at most 30 minutes from submission, or the + // earliest expires_at, including queue time. Passed to the ephemeral + // builder's Docker auth config over vsock, never saved in host build + // metadata/config, and removed at build completion/cancellation. + // Requires an updated builder image. No automatic refresh or restart + // recovery: resubmit interrupted/expired builds with fresh credentials. + // Credentialed builds pull directly in BuildKit rather than populating + // the shared base-image mirror. Omit or use {} for existing behavior. + RegistryCredentials *string `json:"registry_credentials,omitempty"` + // Secrets JSON array of secret references to inject during build. // Each object has "id" (required) for use with --mount=type=secret,id=... // Example: [{"id": "npm_token"}, {"id": "github_token"}] @@ -19384,400 +19398,406 @@ func (sh *strictHandler) GetVolume(w http.ResponseWriter, r *http.Request, id st // Base64 encoded, gzipped, json marshaled Swagger object var swaggerSpec = []string{ - "H4sIAAAAAAAC/+z9+3IbN7Y3DN8Kit9+KtIekqIOPimVej7Hdhw9iWJty/Y8e4f+KLAbJDHqBjoAmjaT", - "ctX311zA1HuFcyVvrQWgT0STLdmS7MQ1VROZjTMWFhbW4bf+6EUyzaRgwuje8R89HS1YSvHPx8bQaPFG", - "JnnKXrLfcqYN/JwpmTFlOMNCqcyFmWTULOBfMdOR4pnhUvSOe2fULMi7BVOMLLEVohcyT2IyZQTrsbjX", - "77H3NM0S1jvu7aXC7MXU0F6/Z1YZ/KSN4mLe+9DvKUZjKZKV7WZG88T0jmc00azf6PYUmiZUE6gywDpF", - "e1MpE0ZF7wO2+FvOFYt7x79Wp/G2KCyn/2CRgc4f50aeGyri6epMJjxarU/2Zy7y99gbobmRKTU8ItrW", - "IRlWIlOqWUykIDQyfMkIF1OZi5i8enJGIikEi6AxPRZyqplaspjMlEyJWTCykNpgGaNodEkMnSZsOBa9", - "fmM/mIAv8fZV+vuCmQVTgcFyTVwrZCYVMQuuCRfwNWLD6oYZlbP1le33eJywieEpk7lZX6gf5TuSSDHH", - "afl2SZprQxZ0ycjvTEnyW04TPltxMW9fpCmbScXIj6uMpVSQLKER04QbwoWRfjZ2jUoau5eGiIvPhVRs", - "EjNtuKDQ/iSTyuj10b/AP2hCKmVxaFiemAU1nsqFNOSSsaw+UfqOXtaX8deDg/6j0Wj0tt/jhqX2WNH3", - "PM3T3vH9e/cO7/V7KRf23/vF6LkwbM5U70PxC1WKrirT0TJXEZtEPFabZhIlnAlDnpw8fXnNCfT2R0P8", - "397DXr+3/+hguH//If57/36vOq21ha+P/MPmo3duqMn1Og+yp2niCGVSIZL1Wf+Sp1OmiJyRKFeKCZOs", - "CB4pFncgutq0R6GtiKSY8XmuWLzetz9yteVcUE2osExj0OAXZWOdzl0ETCyW78REsZRyAWu8NoiX/hOB", - "E0rcIYIhRVIYJZMEmIIxLM2M9qeoD2xcEJplCY+Q9dQO1VE60r1+T+RJQqdrIyx3myV8zrFAp6XhurJJ", - "vi4xkjBhmCpOeJelqbHFto7L5Q7uRskXO3W5kEk8yYXhyXqvr+Fnt6bVnrgmC5bERM5mfcJnhBJoBX62", - "NF5f9oPRwf3B6Ggwuv9q/8Hx6NHx6N7/9Pq9mVQpNb3jXkwNG8Aud9kbZNqaiyi8O6JJIilcSIpFdneK", - "C6u2gVMWyZQRaHrjyI8+fuSt182TclOhIHEFy5s1sNXDxpXRjboTqk3BhHC/uFlNaGBMr3jKtKFpBnwI", - "xlBZzDYu5Bts7oNf+Y0LvP9RCyzYezNxKxScT4g+2PuMRXAjSs9NCgED2nPkXbCsW6FxxaiWwopJcJn+", - "2suFzjO4ulk8yRJqoN1ev2fJYJJyraFq8UPMteUj/Z4n8omQZqJyIWxBwcw7qS6rJV0rE571+r0F1ZPl", - "PMt7/U3XVp2osQuW0Exje27H1YQpJVXPisaryUwqv0m9t9Ul3NDU2grp4ooNrFCv36stQMHO/Vz8uItd", - "DQ6u33N/TZR9VWBzdjLrA6+2tT7cYmibGbu9RawQ7beZuMq6zgFiTudCasMj3YnNo/AA25vKOMA6nxbN", - "ER4zYfiMM+XkakYU3A8pI74RAo0QLkiuG+egEP0nbMmE0ZPl0cRE2fqiNB421c2ryCbljVi5lYvtL07K", - "FiKtzz34cFpSjmfyKVvyiK3Lbm5rJrHiS6YC7LsQACwrtOXIDpx1YCFCCrZbWymx5DGnXdhBjGOa8AD1", - "nD05IfYzOXlKdhbsfb2TgwfTh732JgVNA7TwY55SMYADAcPy7WPZats/H4Va5jJN88lcyTxbb/nkxenp", - "a4IfiUAJt9riw4OQpJpFfELjWDGtw/P3H6tjG41Go2N6cDwaDUehUS6ZiKVqXVL7Obyk+6OYbWiy05K6", - "9teW9Jc3J09PHpMnUmVS4Ztt68GpLk91XlWyqe9KiP6/z3kSr1P9FH5mLevElObaMGHI97YYUcw+5ci7", - "hdSMRDRaMDK1jxZ8nmN7XUi+6NjfXqERPOU6k8jnyZvTUprDpyF7z6Lc1Pr9lsRcGy4iJ1RVJtdhRKB+", - "ShjcvyHJAleAuDJcCmK86HRtISBSjG7pDkp06mz9/OeWvCapbmvdFyFckJQnCdcskiLW1T64MPeP2idT", - "OcX22lzr6hn8TFKmNZ0zsoNqKXxuWA5PuCYzyhMW73aTsNsm8w85rdxrtTOHZDCg02j/4DDI0FI6Z5OY", - "z51esUmD8DvIx9COITxtnQhKGN3mgV0qNlvv7we8T7ATxWZMMRF9dHeZkksmqHtS/Qf22/v/7JUK1z2n", - "bd3DxTwri3/o937LWc4mmdTcjnCNTbgvQEa41ARrhMeMn+LdThSlDVWbzweW+AQnsRQ2t66NU/2AvEXn", - "W6u8gjJNho7sqBBwKlyglW8/A0krILJIYZgIrM7Pck4SLuwziAnj9gKFvVXGvkvkfLf3ydahWP71ww/j", - "vgbzsj+0tAbf+sWrIJHz6mouGFVmymqL2XKvuobK0bUu/1nt+DQuUKrZZDMHOeNCsBh17u5g25IgWwff", - "PniKLrmZLOEGDp05HNZP3BBXorWpREaXM56wyYLqhR0xjWNuFa5ntZkERMiaMYOiksA3iKINPqrPf3x8", - "cO8+cR0E1tBpf6HA+kwqtaF5W5YYqqY0SYK00U5uV7+j1ykkTAGlwrft7iko0BOm5XQ9t5vu8Z7rhf0L", - "eTeMCu++Xr8XAXkl8Pca4fZ77wfQ6mBJFa46NF8Z1n/5niq/fV92Wvn1rOi/8uNLN5TKTz/4UVV+e1IO", - "0K8KU+vnwT3TcNJhqVJyYQZc4BaAAO40T1O7ecUry2kyiBQVCY+pLux8k2D1ZE2kIjsvf3hyeHj4aLe7", - "cMX15UTz39lkPt0oN7tBO0EZqhGoRrggcz6n05VhekieUCGkAWNktKBizmJCZwZqubHWHuD3RtuMMK1C", - "ElNtIpL5/Yg+evj+PTWP7vN3+tHv6VTN/3FIe23axVy3rC9q4KjbTShKFBWBTbzeRZ3S9/Dyt1QSMn6e", - "WnMVKQq5PdDNIQxJ+aCf8few5obs11Y6uLjh119hwhJSDHLBf8txt7OErtbfgIbRdIAUEVpeyzfsAdLb", - "j4+G82Pr+Jm+o9zAySlspm7KfSKTGO6dGVfa9Lpbw64kGDD1qUSk2ikLS0zrFNFcwNZLvRhn61lJ+IxF", - "qyhh68zds+9M5U7dGjO4c/DPQoHYlY0zFeDE/sezoovaz0/L/mq/P7Odf+j3ntCMTnnCPWeu82lnk584", - "xd+2Xao29tRWfelqfuj3ZoyaXLHAWp6jfwCxeuJBwpYsIa40EO8xeXx2QnSuZmgyR2q1ZUFtLzXTY6HY", - "nKo4YRpJ/d2CR4tCXQmqB02oKN0CyOPkHV1pkimmmTDHYzEuNOR63OuTsX18ub8tldi/rWuILyTmimn3", - "D9A1jHt9aCuRcz3uDcmPUpsBPJedLHVMxk4fo8c9smP/JBnV2iyUzOeLsUipoHOWMmH6BJ00UA0MnClZ", - "7RIqYjLuKamZMXTA0jxB3g+NPc6yhI3FOU94JAVJafTi3NV9x82CvLSVKpcnzhgu6z7JnOpZ05SNBbVq", - "UNjJFcmUnDKS0FxEC6YJEzOpIrY7JGdMDfwS+70lVDHYDKvEJbmAI8JouRn617eECaOcp0N35gIzuQr9", - "wdIXj2h9lZontsaHwjpylcq/uCrAqtyMg28UtSq16RV6tjdioer311HNEtAfC1xR3FUOpd4JUtuyWULn", - "SCqVQ2SJUY9FJNMUH3quF6LZkimaFDsEd5xEfQLcDe5GGosokXk8WKwyppZcS9WHG4JF6Iyg+uQ3luZ9", - "7BT+GqQ8UnKZEinGIgEy3qNpfP9od0gek4RrIA4/f26J25EYcgLUB3AY7bhHvU5+3LMT45rAxT8kz4RR", - "3NIc0ZbgpvYmbRBX182rMKu1uw335yqNndsaaxYO+7Mj6P4ai63QTUmABRlXuGjoztrAgNdlcL+um41R", - "bnzFbkVUuJ2qUecx4YbQLGNUacLFWJTUJGKkUlcpUwyXQ3Pjti5lhuyk1CB7Aa3tWCCH+EaT2u7vDgnK", - "jdY/rORIUIUolqzsgNhY+DG/40mCikOSowcDcjh70FAzVvGgwMNERcH7ktLa5Yxfzi5am0DtiNi+/+vZ", - "6WuiV9qwlEy5oGq1S7guea0lzXXDXFhkdLuHL3cU1eqzjiV6PUFdIkVdgGye160mBCeClnSxjcJ+lCEX", - "S6qiRciNThvy5Ow1gc/csAiIuDZeqtL7QVOS1C3NQa8UhVi73rXmkOlsnbOEI4Uj3jbZk+IeCYtIhTl+", - "3doFNSt2XJawCHiV9aex7zdGnHGZyBRZumDrs9lrXSLfuN7WuyY7Uu/BhHcrNwucaZWLIXkhCIoRpCZF", - "jAUW5SJK8phpUuHnpFTfevmi5gZVkP1Y/Pv///9YWSImS04LaYO84cqAD8nv9hU7UzRlwPTqV1q0YNHl", - "WDTFEAKtakmov1SKZea6eqEoPl8YIuS74Vic2DEVA97RcmbeUcXyDJ6ZZDBwox44OWvXOnFhQ9w0XDR/", - "bexNZXGu6EtYM+cVG9pfp7BtpPpLKbbUaXVODXtHAw/i50B6gyXX6LKGNOHKkpOzIcHPaEqIFvYrcFGQ", - "YsmOpQou5mOBX5xIvEucRGvJzJkmh+RFyk1B/EIW14u76cYCHAynjAm0IiZL64BckuqKNTcAvDn3wcA7", - "3A8djTmMfWLkZJ4H9a7+rou5YpEhb04HRg7enBKj6GzGI6CjjCk3anvBNAcd5OfgY5C0rLSv6F0okiE8", - "MhSP5yDkwHI50d/+Zi+njCkY16vHZ3DB4ep/S8Y9QY2tU3L6AVhyeMxi8svjV3C1Ri/Od92quaepbbgH", - "105ICd7v6XwqmGkbv/2KPrjhrUBX2m3M1y7R2hZtI++Pk2jg4rcNfLNBJik5GEgnIMQWJDgkP9fkV1uh", - "cFwBEXRdoi9a8If4W1KM9jsUaEjKqNCEOlm/MiLC9Vh46aMmcICkTdyKQlWVC8ul7H04qHBfFEusPIIS", - "WeGkv4T/Hyy1jC6di4d9ZRacVtAUT3d16dYkK246CTlbVQCVB0tgSX3vNcET3gha0EwvpMFXtf/HnmLa", - "SMV24XHu/KXge0ZzzcjfSMpSqVZj4cv37TlLqLE+DEXdGTCmHtmJEilYVY9gHQjoWGgjs4zFzjDxLZm5", - "w00LJ0KpCl21LTQWrgu9ZyUATYpZ4AaUFphkVW5yZSa7qGrA2RTTgjnnqR32QposyecDN88e2Un4krlp", - "wwT578y2AVYUKcXA+UNC0VJ3gp+IoWrOjFM9a2wfaWbcG4sdPLcE/w2GlTQXPMLbHMvNs3xQVXH0yM7z", - "s9d7pc/SWFQ+YxVQ6g24HCQ85cDeduAHcrL3gii4ofFnLuZ29FjYTqeYJJZ3UxySNzTJ3TlFaof1HQsv", - "/eNIB0blZjHLk2Oy/N0JYfX9KHaykIr2D/tO05SghqlVknlzSjRdMk+QWAue1NrAMaLxkinDtdPGXpId", - "R04DZ+dCutNEMBYTIcei2hYcZCRTGGJT5CdWEaNJY5HGohTbGp7k/mrzJsNCFeEFn+4am80vmhYbw8e/", - "Wq7wRD4vHvWNiyTj7VZV0EXiQaFRuUyV9ysjLzImoFQsozxlwhAuZtIXrXuRjYYHbZ5pLd2fV6+Vonu9", - "kMqQOTdEMRDjpHDcbNwbxFwZOP46n834e3xF5qgFsjINtqT7wKHGvVxcCvlOjHv1YT64Tw9m8fRw6274", - "YfdraxjcB2R6TivdGq+32Yb2ZKPBDERNYiS8nasvf0fhn8BcVoYkwaWnBnBWEs7iCm33rbfunAkGnCu2", - "PqCGeAmtxeQzCIqyN25VupIlpmVHreds64ZumcM8kVO88PxESqfTITmpr12fUPyAAnN9lYtoiYpjKNlh", - "w/kQbpcs4gPwDB3Qg8FoNBg1qT05GliX94wawxQM8P/3Kx38/njwP6PBo7fln5Ph4O3f/iP4IO/orert", - "2m6eO/4s9YkfbNWFtTnQbe6t17asVYfffnhRtdC605FieAxosnUM4HHwpFK8ndafnKx7vdmViiXooYdc", - "7iV8qqha7Yk5F++PQZzTpr5um8tuUrAEgmOsYOQLEKqJ07D8urekilNh3toxknFVOQDyG8FbA+79pzgi", - "Mhj4dhz78p73NQPAkPwiDaHOIg1PumMstN7vXNE0pajtXNKEx3g4nJlN85hZ5azAb2RppSTFTK4EORqN", - "/JdJZVAgN0jtpzLuOcWpihbEKYQUQVWIjZCJWAZdGhnTRphSZSnWTxocs7/tFX/t+D+Hb/+2+7//45OS", - "OhLaBhq36owr8rOGnzcUIjuJfMdURDUjCYPZ6j6J+ZwbbYW3GF2jUKH2LYmss4d1XZSKMOFV1FiuTs7p", - "akAzPnCaF2vu/pmJuVn0ju8fBhd3x/0xePuf/qeWhVV5EnqvvZQ5al7xczXw2o+hk/HFr26eoNEl5eLE", - "VttfFyc/bof9RDbttH3UtW413DFFVNCWgaxH4IPHURoSIpZMKTiKlq89OX0KT5hL5hgavBrJOB+NDiMs", - "gH8y9wsIcfCUwd926xKPbS4k7PzaY9FCohtkksirKCn7Tabe5iW40UYWWu2S+6/7FKIR3ZrF0dndFSRT", - "JS+ZQpMMLDFnmlyylVUXzGsKTSaWZEmVNw2+wrAELOI/oTWI4fMYHrEYnA+xrEw5tujebDYMitGk5JYp", - "BXMXvit1JDMGDNUVw6mRCyaWFySlmX3WK2aV5ik1THF4LpaKxZTFHHj0WDA8GCSjcOajSCpQscLeog62", - "XIVvNLmwz8QLbP6CCyDrC3swG6rSP3ovXr/6/sXrX55OXpw9++XxyeSnZ/8NP9tKveNf/+hZMI3C8ep7", - "RhVT5D/+wPl+sM6z6NMHoe4Lqdxr15vo0V+FZnwoMyYoH0Yy7fV7/1n959sPb727p43cW/aOgwP7EBQz", - "ne4z4IPvA6A0kar0PKWIC4IsyqsdKuqGhirfSn5XOhL4ROFyMs10MDalqbco5dD90ej0+z3nPXLP/2N3", - "SJzpFocPPEgqJx7rBZBPgcuB9rQkkZGL0Ji1heD7rkIMHm2tmeTCbGVOZdF1HjUYlF+vwIr2plzsadiG", - "QXS1dUe6ubaj8jOx5EoKfJ6juDRNmK6flV9ePH02efbLm94xXARxjnGEvX7v7MXLV73j3uFoNOqFCJS9", - "z7hiOuj4+HiqZZIbRrBQ6WM6JKe5RudOxzxmOepBUT7TJM1BsZSsCHsfJbkGPoXSgDFJKP744eBg/9X+", - "w+PR6Hg0+p/ODqtA+luY9/Oz1zZCHc87o4lZTNA0t63ij1j2CRb90Pe6SXzaB1ap2FOvrYTT6+qQnUVd", - "urKTI0iQ497h8+/tgdp/Pu5VCNGFAhet2IYbq/f8+9C6VLRR65Je8c1GuInYU/06GI3V1+faqYmqlvCB", - "oAixAyVjqmIylVTF39Z9abAmKPK/0QS1FTRxdiIremMdK0tKpvGt7H18SmWr7jeWADU/qVUlUkEYWkqX", - "HFjOIE259PXqbMkpU2o61GHFwBTQ41XchXr9HszM/cdPsNfvLX+vx1RvVwc615hOb8Utj0CaZFywDa/A", - "z0TYB51yImk82P/Esn7F360BQ2M/1Le7eJx6Al9Dd5pSEb/jsVlMICIehhy4Id0XUhQursn3MBOa/Puf", - "/3pzWipE9p9PM3dn7h/c+8g7s3FLQtPBWJtiInkWnsbrLDyJN6f//ue//EzudhJWpLyWeO72/5ltoQlQ", - "43C7rDd+i921kMPK+FzZYkvfgmEQunLlkqmErirXiRtTb3+EPL0xKsWtudHVq6iQN18u0JoX16rXC7D5", - "GWeJ9dGyrrf4vtDeQmRth3hagCd9o30EEiNTKY0dAawNo2vYKOFb6eNUUkN3c0RSGMoFU268xY1hrxT7", - "YknvHw3Js/cZUxwEJpqQmKp3XFinF1/TvbkJFQAIlHDBBjx1Fly7JHaSyJOhYTC0eYcjbR2O1rX2qKyO", - "ibsfbWWpGgqxm9QsKYaMeZIVSHqbjs9LW7p89AdIMkCR31NdWGa70GFBhvsHp+7PA0uQVeIrDpc9a1wV", - "xGe7+hbEUHg6G+xUW1i7KSPQE6PakCPynH9PuIBQ/oSRU/49oe524oK8+R+7D8jrdCdZSl/yzPp5TOi8", - "CEvdhPx3fskz957HGt7LwN5BcQ4t4xkajoVF9gG2gbQDHvnedmsgiEBbxwW4bfE+W5fRQDtQ3mi2uDXT", - "qlz0yTQ38OSXhhGnfHEQAzAWLDxlJC+dSBsPcDfBdccIXJZLpgRLJvaBrTuujK1EXKXWxcGpzqh2SGTK", - "5Fl9vZ7+dHpOdp6uBE15RH6yrZ7KOAdvQMsTduur1x+LTCG8C3QCZ4G7fuWMyNwM5GxgFGN+iCk2Vthh", - "HMjF8vnZaweTosFJ6SWDhWUidg6vXtgpPF7FN8aawmvNVvtvLHobFI4373c82eeueHm0u2sk+z1jkhC4", - "XWLZGgQR2TgKMFwV1OdD+/pwAp/LEovBcoMhea2BG4zA7UUq9FogU2kW1dclXku6+gIqITTLYvD+DD8x", - "y9ds43wfLYJ26yjL66R70G/FNFxahwkQZ3RXzrWEwhXGhYBLAc510JFRBcFmXJDP+o5ZeNmqXskOsNwz", - "auqAHF1V4bZlBIPd6h3qNNq4JN012hUd65pu2ysA/+gYNLG5/RPhB7JRo1/qAD+ir3PbSHOJXNt9P7Nr", - "rNJJsSYNO8CnWZ7HuqIz7YTbamUeK89osnMBalZHx6BYveiTi/+s/QD81MtT8Fx4R+xqII8W8FO1fb3m", - "2bxFj3tt72aqr78fj3Ur6hZZ7hOjqNDWz35BMzYkP+LFSAxLQVqEm4pXXQuFfPctkfaN4quOBQxN130t", - "vTZf87kA1zN0mgeGE8dW5e80dt7/Rofgjr0ebk1it6NzoEXIy5y3PbnwqveLOv9dV8yv662cpn5NYYG/", - "W0UFqnLMXpob6N6+XpxNWubGgpi5qTcEvLr6f5tjkBtLoYq8xv6fF+yiiSG9DGgsYHJyVtprKoajNvuM", - "E/7CtqNLtsIt93YiumYpqpqIwoYc59LuRJlKVdQd2quE64p9yVqKnHEInY/rRzRoNtm2FbBenZe//vIP", - "xuEM/GRLinGPeY9P6rkQTM72h0pHzXDxUZNwbMO6LvpW9cFQv0gEEEviffObzaNbMjoxXrhfhq61iyJI", - "8FNgjpfRH9WtJZWd9aI0NuNFMcPifl02AHRqvX1S1j110WL2VOyd4p6ReYDLjiKvi5pJ3cPr4/RAzyqN", - "bXAI69rEepSsXd/KmB09WWBnH0Ri9wPtXzXE4ybwf9x4hlvkmHqXFzRJLsiOK7RLFPsHosK6vQIPu2L7", - "AeXWkUDhbvbmtD8WlgtcLIzJJvB/egKn+KLZmKvrT3gJyv5whKLr0dFhPWbDDrjRbF1dHkTDad8a8Lu6", - "If+tFqW8R7/Hz8UNBIg3ZMfQORwdB3sE98TuxyrsudAsyhXbftYfo3jkoHdwTAnlYvDjq1dnRLE51xhq", - "HAxqsK7xLRhtTllQuqv56RpZ19oeHB7du//g4aNhfKmGLFLDXA/gITPYH9KU/i4FfadB7NpLVzTLjpf7", - "W/m83YJifO0s379s20lBpsCSvUNyl1fyk7JKaTC85CLu2sBPUHa706t/xN+02SVTbJBnc0Vj9omNLtf2", - "a8LVbN/VLZlQNjs059qAIqKEAN7Z7MdcX6ylTAYxNfQqbsx2uOsey+nKNmWf5KH2Wt3Dz5s+4TXcnmA+", - "hI91MvNjCW1LG6awVSSweGJkIHzXyw4nT2HNfdlO4KkIgWzkZDnjcluQPwytHrqL1b16A5oYZBF3mjpv", - "1eCF1t8q696cVn1rhmMxQCnsmDwtOiiaLZqk+MSgsbXy70hVix9GQ8AUoE/Im9MheVWM9hvtjQJ2TKSI", - "HM3RoIhC0cCKZNUB5Bhow02zulNLWjzmXXQhku7bsMjaggrQQoGG+rIpb8zHxnXjRrm7pAo901EhvAmd", - "7KW9jzYhlNU8Qu4NRvuD/Xuv9kdX9Qi5AcjpUFuP67zF+f5Xuc+T1ydPD5zac/faoGSfHJQ6zMqelkEL", - "ZCfXrBKQK1UwVKESEdASinDtCIMbChgo4Tc3lbUr8QpK3gTadggPDIv0r4GH3WSYW0FXK5NbV+isMlQ/", - "lKekIsjbHc0iHoy8BpfB7xWjl5hFYP3eRhyKib3Pwv6GCBYyXSE4Fiq5lJRmpkmBIVMqv/ePHhw9PLx/", - "9HA0CuA5rxO8jPgELbKdBgAuOAldFdCGO+jGEJNpIqd1Qr93eP/hg9Gj/YOu47CG+27rULy/fS2y41bk", - "bz7Tm/9SG9TBwYP7h4eHo/v3D446jco21m1QrmxdJHlw+OBo/+HBUadVCL3rnnl87aYAH0r28NjmR4J/", - "DXTGIj7jEUFcOgIVEDlgAWZ8b4Wun8kpjX1KjPDdYShP9EbvPtuZK2n1rWmeGJ4lzH7DDelkksCZP8WW", - "gjnGhChSkFytJYdKvtXvy8+lKILiTMym+XzuIP+KpTt10fyl8MRZEh+T4sm2kc/hbpYDe9tGB24OHanh", - "Z/muAN+rEIG9uixShWKkoBO7abVZ+XAhLrI8SBKtS/lDriwIBzZK6FTmxlrwXc6YshOLZyPQop2LuJu6", - "4wepLrfGd8BNXKTG6agw8IH+MwQCaIT4V4W+wtJu/RHcd01e2hpWUVj+nOX1vIB97MkpFIVHJ4gLvbFr", - "pqt0GZZbUGfunfpsfyXvvCWPxsHMOoF92he2mjNMCWW2SixAKdZ/6hyLdw4Xg4pbFSkd1l2wd7ex6Bjw", - "OACyHYAK5WZWfJPjdKFrKAsR6cINAJ8TZh5X4KUaJ+3cI264JR+OhYu3Kn5yTgFQ0a6DdSSQis95veO6", - "nvUWXZevQpmeuK5NndWKbT6DujADhniABZyeWU9g671Yxbt1e9Lr986L3FmOMdWXxv8YWJEywGAdeujs", - "9VUdkDMlZzyEB4ReR+6re6h519yfj0bng/3/st6dQH4osXFhPZXAjjBs5D/C8t0uoudnr8/axlQknyLV", - "0a3NaQPKUelZU0bFFIvjYs259i1XEvVSQQy9ZKBhwhNXK2bhu1g8JE+srw3KNXyGGm3ji1l4FWBAtu8l", - "O65B5YBPmGBFo9aUGudAVVWcNygGooD2Vk/EiHt+9rqO1/AoJH4j4Mo0h4FN0oA+8Af4TmyBAjDi9Pu6", - "CH5wFGo6zLjPagSEL/0ZjcA7oDOFBHSIjWlsQ2R8fvb6pUu41IZVDeRUJGWyMNVD8kuRkgyWV5d4VMOA", - "crFBgtb1HApMdCJDDiw/KMYIfitToQLdoNHbohsXjgY0RnQrKXxCRvD9d1iDv+VUUWG4YDF584P+loyc", - "lf3ND8TGHzmexXXV77L+uHwQ2tLWOMKzxUqDbs8ui02KwkVVsYlcoPPL5Kys6FTAgfdJOB2f5zhkB5Iw", - "4gKevxycvHizl8Zs2a+NCT5aL93nZ693K2x56cEsirJ1brxs0zD5rSqyQ07KjJTNg4A42k712aQO2JsR", - "mbKIeqfu5uZFRQLnKbproKIMzNyGCaKo01NTUWsEWRc43udJMnQ80w+ZoGZ6hqy7gv1qbzfH1BTLKD6+", - "CsnrvcFOGdF5FDEWNzxemqOu0NsxyUVKlV7QpDm54wJgIVpQRSPDFPnm/Te9cAYmZKVd74YKdRaXU2ey", - "rFxFAXqsnLu2I/7mh/rxtNKBDat2OnUuuEGYOMQG3ykGadHMh+SUrpzqJcNr1tFLuWN0NrNgqcU9oljC", - "qMbM6Zq8+WG7L6eRhiZtc3gFHx2f2oEJwSmCYfZJVmMD8HsVpaza7f3glVHOJ2CZwg6bZo4hORFhtmcd", - "hhBn0EKGac3nAp6D2vkMwX3qV3Jt7+p3Z1CT1MRl7NUXrjadfuACCFFM6LaycaDrL6P1TK7yss6m5OX2", - "7KG2kfZ+n/hQ1YYpzD0//bnFiFbvvERsVccxrEJVs4wqaliysu+Rgjrr2SDYuh8KRAtcIVb2GRT/YDMA", - "5YpNzEIxDT5jNQXFYX89i7TGqIQlc4nz7Jwq5jojSUrVJZ4y//wmubArUI+LPdwGjrUwJrvCpMCpwurk", - "DFNLmjQjtvSaX85TBlFaU2beMSb8VKgmtOoV34x41y3JyyCWhyku62vYOwz0e24jJchc0YgRW8vnoC/Y", - "Ghy9rkvZO2wZFlw4Wrfs7/6m/XVVZ3nSbY9Dw9rftsMmusoGv3py5pNwFUnO/TIfrK8yJJKwR87V2LK1", - "B3pzOjjflbAo2msy+5RhfjgXa1aNYvdeiZj/TmDEXiVyvMIcdDXW2fWDp8AuVd+e87ed3oTN4x5yv4FI", - "o1CyePzgovTmCDaIsQkqx5cXj62kZO/kyv3sIqlA0uICcJnrft9RrpJevzeYuVkd7+0Bv08Qb/XocP/h", - "3mbn741e/87JcRLzTVohV8o5y3kIAAtWiZOuk8QezbIOenOsue1+QPa0tgk2QTzcbZVHlg9xAXtNw3nx", - "PY2MT2mJivSaowStHltERa8LMtBgarNUwWv3UfV8joKeK+CGWif/vTXah5lZT2SgEaukbKyjJfLfg9Kp", - "VKG8hVIZF648Zf7RXtyH3hHY43/XTOqjh9VZ3r937/DeNj6EzKZxzN25C0zVlq4DMrDKcrvz6xqA/+i6", - "zOG+bCYrXJctNPXqSYCkNi+ozJi40nreOzo8uNp6dp3IiXfmbPClEJ4VAFihTFRGFqfM0JgaWmcyqIEG", - "LoOJsShLMXBw9u1m1tLi9VQFqLpuVr9P5TPTkuDzpcezT6ngM3wk2ZLVnvWCHty7f2zTEMdsdnTv/nA4", - "vCpsz7PiW7et2LOutRUEn6FefNw+3AA6T5e5/NE7e/zqR2BkuVb20trTUy6OK/8u/ll+wD/sP6dchFF9", - "umSu5rO1jNW17c1yB5vO4mOYiXDBWF5S6uDV12JCwpgChBILYmTWfKtvDgyzoHFez3lyBVDMDaH8IK6A", - "Rr51ba6dhFoUulBTST5d1St0SEQNrp+bPD+8xhnLuD6tpqPI0b3uD3OtLOt6YyLatTyFGRNF6tkksX9F", - "UiAqeSgPbe2K9N86pDHEa8TlKyy6rP5Y9F758Ul1IJXffRrEyk8uIe3bKzqybRRI/74uh27nQl4c3XKY", - "w+r/4lbomvzbgWgGIzju+C68jrNnvfcX8//z2//VZw/+sf/bz2/e/Pfy+f95+gv/7zfJ2YuPAmjajJ96", - "pyConwz3FD0ca+CnXUnpFCwz6/QEz7+WFXZfrMbBRAtMV0ym7BhcsH/mhimb/LIRsgz5Ghi+lLAWkQKz", - "FDo0i12ofGb9EKDyH14M/tBsI3awFcptSAGUpPNpLFPKxe5YjIVri/iJaHwXwF8xiWhmM1hyAYpZcOxW", - "mG7UGYbLzvvkD5plH3YhJQo1hL23qQAyihkbZ4VtQni3Djcq67zuirMCb9nGEY9FcVsXAKLWO2BYZhvh", - "LGlG+rUsyub3m3s5PRyFoFYxCg02EjNq4ROkoGwgoyI8jjwc7a6/57a8MQoa2kB+zn3GhilDmHGAFFtC", - "m5+ymEfIV3x0ry1ZCay2lOaUeJmS71e4Ny9tyGlMaG4WTBjnGNknkZSXnPVxS/sEjLPor4U1rRfOQmaD", - "6WqwkFkBw1LYwq0fS/2R/X8HbqKDN0zxmespiKYBJBIQOvHIuJlhmVK7sDaxVzYZkdBolHfFbVYrbRMZ", - "2QAMkyvhc+0wzLiLYEMF9bGQTP4tiRKOWie9QBveAtFCDTQTAvzsjYpANzqNYjZr/rvuiHRw7z6+YP2/", - "Dw86x5nbpdtEZXkSeNOmnvV14NiWTeIArHgw8YrwLa6DcANaTkxQT2Ek/vec+IbKE1cwEmvps5Gv2qVu", - "SXQl5nU3GJzojoEDFZrQ3HSd3foprMU6dmjB+hRhtaQDnNEznAd59fM5MUylHvViJ4LdwVNisWsGXOvc", - "ZRF8/OT02e6wF0SJq5m0cKs2xkLWBx1ASLHnoNV1qtTR0JT1yclTjHF310r5FsOgpB+kIom9FcvL6Bjh", - "fOrqHmrzj548dQJosiodlazYMu7t+haz5vV2TF76bgkthlJEK5e05ZssLxNs1rmt2oiptdYbwe1oH3PP", - "P3cfY3wUJme1vBiRblvvr+46R7fi8LGpIbvyhVSp2K7/quz9p8aE//Qy+uHVZHRnhZ5kC6pD1L2oWjWx", - "0Nq+Vw3ZdXav2j39av1ONA+erb/7FFWVa8gwuOdq1UMgyPcG+/uv9o+urr67Kpx3HamvgvFZIHp3h+K+", - "CUjrAEA1N5PWkBACn10AiNeLvDmF6EpAXoOPDe3I/uGDLkoJ7LVrMEXlI4jUOKSCS3nkvSIIwAIgXvIk", - "sQKM5nNBE/KI7JyfPP/p5Oefd8mAvHhx2tyKTTWC+3MNZG+8BXAdrXNUAHytBuRBiojfV69+hi9RwjBo", - "ysrhl9fH+96qWuyA/+0H9/zsNdRYUD3x7tbtEca0jNJn77k2eh13sVPUwsfgjduqpWKsyyRtG86pcito", - "+Y81VO0giufuDaCN+5CTteW8AyDuuwzt/fxAwDfCdn8s9rbTM9wQ9HbrlRaCrW7gmNxru92uD6J9I8Op", - "wUCF2FZVwvG4C9dGre73eCDm/LHz4yMnZ2WautIY4ZtvzOnRwXD//kPMtLw/6sLYUxpt6Pv08ZPunY8O", - "7C1zTKfHUXyMD/br2qwcYdsnCE3eQWTu2D8Sxz17YVZet5Vja8t0i7lYBwe/HhZ4U4xrgeVGcdY7LulJ", - "ujFRUoeg4ibUYZo70NiUJwnXLJIi1nUZeUE10ZnFSrYJgwoJfixwgH1S5G1HKYXQKFJ5qXp00rWT9/PM", - "0T0mLc6k0MxlLfmJrTRJORpBi+7R9VGTInYtHosd5eMci4BGzFccww8YNdQn7inUR69hTIwEFcZCL3ID", - "TGwXAlAEpDdWTitLphwtRrtE5/ZJi+PF1VgBw9Q8ZmosoFgAjfmP4nlyfB+QEfq94iUHyV1GoxA13ajx", - "c+hg17EFDIGhwqXTQ293lQuSi5gp8lJqZgwlzJJD00XuiobTj8Q499W7iVeueilXhQ/mNkj0TsLUR2M8", - "41Bb3ufoHXqNx/m964vonSIFvfzqYgRdrclVPBhcSAa8+KZw21mFHIudGlIzF+tRxN68tomD61N3rsdG", - "glFdrcib09Oa24OL0Og2ceQSLfsgsyttw8EWHcnW0VzFvFxBxN6Ogv3xyNRNSaUiIX5yHOqqhdFDF1gK", - "rSm2ag/nTfo1eFUGY6C4sPsERLNhgo3c0RbopXSMrLaqV3rmUFmdKO1jKhwifQHaUhr19UrvTXO9l0V8", - "z37Xe4io8xARdY6CkAcxW07yPPQ0gk+uH/L6NcDe4C+ICG0DZGrdU3p//+Ho4aPBw+n+/cFRPNof0P3D", - "+4ODe3Q0O4weHO4fHG4IKuoQA3v9sNbgizngx1x4rU+893zIqbktdqEhmzh/7HdcxPJd7foLOshWe3fO", - "t9u6X3et7zyEYEhQQrWx6osWTnaKlzyLoG0s5+OsizxxYUXn/Vej/Y/V/uDgWu6IVyoX1qyKBUoTQloZ", - "cHWz6uO8HsvHAfnAl22rVe28+6KNju89Or73sYvmgze2jbFJTre4uW0eYR45vREd4oOEK3okr6DsOZnI", - "avVt8VWv38tF9W8UBhq+1MXnTkFcbQe2H2Yjm66VFsiDk9p7BT1VLHJmfAySin+PYM6XAlgDRKAnoAsj", - "FV2cBRJEO9xJ5e0CzaBZzKnobOCyDcbAyEiuXTwfF8CI0f4IjTh8hGPyHMviJ5raZ50bhE3cXTW90Xhl", - "/WXgfPmu7SNr85DP3fsK68Bji8C/cNqwDE5lu7kJK50dk18k1ilee0I2db+2OD6z1os3ypIdB7Lv8W6w", - "MydqHpMfCvGyEFCdQLqjmftz4hhWCTO1WwP7cDsOjoSVnasAV/R7dkV7/Z5fKPgzAHXxuqT6tfNXJcWQ", - "IxmjCZ7lMkw/Nzxx4Po4E64Nj7QLHoHNbRN7XGwmiyf28dTmk2pDX20ZUlTyUtWbU7KD+Kl/I06xDf/a", - "LfxXa3fdwaOjR/cfHDy63wklrRzgdtH4CSITrA9uq5wcZfnE6Ubapg5J9HDNI6tVKHxfwNpVknmmJLAe", - "mLlvsNr5o+GjKjhcLHPgw8WQHJKkxaLGDQviHxa8qMUP8jeeLPlsJn77Pbo8+Ifi6f77+/pgut8Cem07", - "CqvdTqrOBWs6ajYd2NSeYfwuJCilWyHuXjKNMyDnzBCknwGhET5vinhqR3K5rq14kLCODg8PHz64d9CJ", - "rtzoKgdngkq4wKXsRlCWJFiS7Lw8Pyd7FYKzbXokmCwAc9A4Z8QlaB/VBdLh/ugwRCUtF3dJNa7tZdq6", - "5G/c89FNyi06Bm8XT8u1Ux5c7cPD0YOjew/vdTvGTj08Ue83cxhXzvbn02dUd34HpclXj88ItK5mNIJc", - "9o+tPnjUmlEx14z88viVhXYSkmRMDcob0bdUD3N1vmZXmp+50vwwiYxN/rBlijVPlQf3IXprvxvqY8h9", - "xeGZ1o5+nQsGjm+AvAL7GliKdSbeb7t3QoKZJdWXLEooTx9HPlijcY/ZJA8TZYuVm9DlinFv+bUrsEPd", - "TmqyQvllQ32wDpGK5KJILTTcbtz9JDbadv5vL5rt90MowEfA6jl4Mpuu8RpLmSm25DLXn6AhaWz07SyR", - "Ul2pbtvT5yXTYMHzoFhvTr/RxNEa0YZl9deYo8YNIG7XnNyVznONRMJE3rZYnXajy9ZvmnC/5dT2N0Fz", - "1LhBK3RiDJwrF9vdSJ/QJMoxmRYt9hNmhRcFggtkWbKyUQJJIqUg0YIKNLcol7pPzAklgMIwDPrUwpfJ", - "LOifId+RRFrQd0j24/JM2UFANRCGQLO0U83maEmpkf75XmqZjMskVKfGe2k4U20YnakIqof1pEZW8Mht", - "lZpONZFzjc9Lg/EPw2YajIwqG9ZAhc2btkztqzTguh0YYoOZh25U/AgH0z6VnfCCIet2JWmkpK4Ai705", - "1cOu0XNFPPR219D6YDuQrjWNBq4yvOJ05/SKofsxEBn0MTck0jBGH25wuvRqzpSKHDNPVQjZqfSHnR0r", - "Qa89KQCzrjhYbSaYTgZUgYUNrIjfLzRLvkzwXvSs7TrL5TyYr1V7jarCTbUNsJ2nBlc0vFr9ggZDZLyO", - "ULcRFK+ECmzCYl0FrLLMP8I1tsorGIRkB6NnKmypgiW528XdJvz4hX7W3r0uEzFYPLpiNG6GZDyjZnEi", - "ZnKdE1zFBut12s7vNWPKwyTGTHAW+1dpYYx1SjOuXR66OGdu5bDbGpAeOktQfDk5bRsEC9V5fbPDLopm", - "O4bN2WawX1eww05yHQ7NfaVyXCskICCeMki3kzsp15OwYWy9YcXmeUIVQgd2HLJepQkXl11a16t0KhMe", - "EajQtLDPJISQTeCT/g7nsttpdlBh0paa7NwOzkUY2g1p9FtO4TuY5W4jvhl1Onu2/h7U7+SHFvQ5/4En", - "zKFcvhb8fYXQ6+kYjg5GbXH3LY3WIu7XYV6vyrkdyQZPfK4DUYobpRyfVI3FLkcGlsbkcHjUOtxKHoTZ", - "GxOvZxuqh6B8HMjJE8uvGxAnZMowgshPba25Lmyxy1SCqWUg294/5LSuWu3qQBxIWLgjSrANxWbBSAHc", - "0Y2qbVtibU0qu3sVNAtkqzBRrHRFkIhtqR1LT602fvJyLcvhgrkl436ONuNhhww+3pOkAEJwvXZHRGjm", - "owx4PiPejTYrzOyM6bRWlSSrkKZMKUSgBwlHCj8bBHCRyq61R9CCuO4VUSylXIwFF4W6FWHZGBFsyVQl", - "3lYqeGTNIdjj75UnHvzO0sysXDIIVMN/owkY4/wYx6I6SGgc1OhD8lhYzaLKM1NLF8ti9+oDQvFJ8hUz", - "CvOncrMgM8X0ojr3UM5ckPHeSRW3JiNbEV8EpkHRWkuMvGSiysqKZoJPQ9vQxNZa9we0Ca/xq3t/kloO", - "atLMMb25v1wzFRYSiykVRTo5wVSOSuVxggcSBuByi7q/LIsv8FQ6oKeUzf+Xb7L86axovP5bo1gFIcVj", - "hj+2atugCjbK8vXVadjktjq9YEDdJlycdasE2fHO2D5Bk95tSZTU6Z7sFtPXDDvwo9nTLKr3fvTw3oP7", - "HTNVfZTZz+KAfWoj3zLdYNxr2anTLhakh/cePnp0eHTv0cGVLCw+QqVlf9qiVKr7AzAiBg5r8u9//uvN", - "aZ1aDu6hN/foSoPKs/Yhvc46DOjN6b//+S8/qmsPKMRo1uH+WzwAWv19kupOepeDujGwm5Fsw/v+cU1J", - "QAs2Q3YYgnqD+45dt0E5mAagSDcpmGY04mYVYOT0nU9w4Yo0ULs7tN4YbEjktW07fFXgXDqfFiXAh8UV", - "+E9rZW7QwsPOCe90Pm2zaL9o9orlSGm1qHpLdHBWsBQRVnAX83lHdc01PGbW7tAvYtXW43Zsic34vc2g", - "ChgKQvLW2opCWQsa8qSrVN3+xnZW7JY1tU5zxd9uOIftR/BKWt/AjRxQ+kZZ3rWhUm6HC/B6tSbTairK", - "jbk+a3kry1v36v12iENeT3pS3GBX768SenmVig1as/ToxuCWvGy7XyOJFmqqRNUEFGgyYYNKGgQsTXRu", - "LYJw5h1gfSAWNLqUs1kdNfdeO8o6Aghh2JjvhRoDL5M+aP2dzqIJ0W3Rgsa9e3rcI1JBSGY67jXMVsFA", - "zJS+n7gO6igxo02w52UgfWOQ2s9gmsjo0mZZxOT9QzIiKaNCk1zg4W9Y1fZHm61D/V5W2Ru/jvi4W1tK", - "t5lkyhZ0yTEzi7OpzGsunew9NxpdT7GdYxJLixtVSzHtZgjFbJjkcTlpvHSoWLmGoUEoJ4X3jS3LooJv", - "homtxe9Myb6DPQCO/eLFad86MKATox1YzVPST9SOoNfvlV00EjWUv4c9kcFYgeNuAv+n6+tYjW5Hy6pi", - "mhntkMBLcmgQAYQvCdPMCJB2e8jVA9TWr6RcoNugc/+ABfW9WwIhMYvwROr1s1gn9GsQdyMCwa10KATh", - "METCeCg2ZPJ56QzCzQFYZUMlO7xtp+ohbq2EE21k1quf6gl7HzEWN6FDw0W6et27mkGv+5+pQxsqEre7", - "0ug5vT674c2FiuFY21a7Gh0gpBjAqSu21B5Oi1znUW/qhFZd/So4xiQE1Boq0GH8gr3fvNa/sPcGkdbj", - "PGHx+toWR9KyKncZbVvxa8dIth1oqdjW9Jw3kLbSeq5fK3GlrcruInelK3Uj+SrXduecGV/23JFR6w7V", - "U8bUTFquCeKL1H1sLCn1ibvgyX662yDBo0VYK+LgfTtGe4K+BYzvM/5+A/HYAvZhXAdIKQ+SpwZikUp3", - "UvqeHD3AJGK6MXbB5wuTrOoOOEcBVKaPSuqqmGHCKwq77Hy5m77iureb285q6yHh+LwCMrSWHMWJpJNN", - "CNxPimJeO5/RFWpxWo2EDw6PRqPDg9G1ILj9sK6wXE/KKi4Far2dtuC8Sj3CqhYzy4GqLRTh2ut5tW3i", - "u3I1iTaK0fQYQ3gyGjGSsBnC7RWhsdsti82uNw/eCVQuHregf79Rbt+8Db6efKfoSswr/7KqD5xrHc2o", - "+n2LQbSFzURr4HyB6L3Dwej+q/3D43v3j/f3bwI2u1iktriRB7/vv3uQHNDZUfJw9eC3/cWD+UF6GHyH", - "XXIRd6XVn6Bsq5dNeUnWUZFqLI3suDlkTDUTpte1RoDmnHDBBrqItdoe8LiBF1j7+9bzfzU9v53BRtnh", - "vD7JqghBDdFByrobJC83mY22i+ZsTp5unsW1YpmaAwnTW3MoUKrjYDDXxX7vIzEectHxGnpdKdj5ItoY", - "X7ftKgpZ2PGkB3e5ZcVD5N2AeKjMetMFvn7JBXSnc6m4WaSbb4uiWAFIjn7Tv2sT15GjhuRkLqRi9Z8L", - "N7nqIwoq9/q95Pej+plxv3fHEHNYxgUBuq2uSgUd3MgStmTJ5lXAIuXDQ1lPdqoYLsR3+4P9R+iHkPx+", - "9N1o8KjucdC3q1Vdvn1fuvbrqMsaVpMJ+iRU+4+u5HHt13MTBf3EQ6nwynvZoRw7Gi9z0/urw4fu1ja4", - "/Ly2xw1MoFYB9GMlPXe5TapCUwwa2RDKfUVRqxuvxyqRkSmbc6G76G0PR4Xi9h4obsljBzVuE8LLop9q", - "80ArVTrhacpiTg2OSpkNEQwHHXVxzbfE1bKc+FoBaW0YFtcebQdb2BZwte2aHH5EZO9HvX67vXg34YCg", - "Xs0/URGNDAv2CZ+BDrrevk97bR8dGBiJ/mrHHvKtJFnHA3QpB3o9SZ/MpSFlMH5HfVsu2vWCxfghR2e+", - "EX3DEsTBJ4FWKaDI+Cb2dfKUZErGeVTGjyY46BI7ROVi2FXI3zq0G9VvYIg3KDm26zfaFBrd9JNt+93Q", - "TQLBtm/1/mj7Vt+IUqTfy7N4Ow+zhbpxsCthwG8JQQyoaOrL3pAEK5N524Gjv6yu4Pqb1+qSIxCJ8swb", - "WICm1ikpYG5BE0PIr/cpS5hhoUaITOIySoLrkotuZ6n79x8u2kycaJFaH8hPjGWEGoukhP2lYM0LDcwn", - "MC3ukp2Rxw3X1uA1sImP3GrVB/dgqyTWulVVFW5bMgbL5Rs6b4u8cllRf/vZ1ESzdSwVz/BrQtrL9mQC", - "rqZ3e2vVH9+EWu4uhbQXzvTQAID18MQFzrrvv/QFBrGuTrxHIfN8kCyMzLau9EwWDkSbonXPACTWwyTI", - "2ayM0tWX1vDrTeZGluBEQ0yV4m3qY2FLOBIEQCUAreQ6oioGEQKWwc3Tb0hJo7RqinlMcNwxiiigiaRV", - "7Al471hnbkwIP8uTPtGScHh1CCHRtzpHvFuX47kp57jz4NI+lnPj4HAuPa6TqzYWvhdw15tTLqytJ5Dq", - "Zm2LXtE5JkbcYupqPc2hJKJoh6LEUJfJDLOpwj8JpozVHp3Hy3BY3W+nyywJa2Wn0ikHqXUW2O7m1Z7V", - "5xWdbwRgbkYsVy0kjwf/Yy0iZDI83vvub//fwdv/DFpGGjoezdQgZjN0irtkq4FNuQX6pGEdfhjzffS0", - "oXPH1hhNUd+J0P7u4qiO996ouOBWv9B0bQroTVjJl7W/dUJ/+492X7zKMr7GO33rof/odDg3kTbYSC86", - "7aRMzX3cgw963B2OBcZRXrKVJpUsfNNVjal+o4sqlWgJcmHJfcjE8oJMOaY11WNBFWJqswxevi6xE8ex", - "KIlsSjGaVNtx2QD9eXHGc88C35yuYVe/eP3q+xevf3k6eXH27JfHJ5Ofnv1377gn2LuB7SEeAO0d3bvv", - "MvJXV3I/mBXm6slNhuTUhZQ4t5RZjsoXRKcDMzZECSYrwt5HSa7BswWX3pjk+mlM1gPLr58W5CNxr41J", - "Qh40Dp8dMNdhzFb0cZcV154YOchsqVfEcUHWpUtLOOMe3vpGemEvmEQGtiK82uXG1hf9/qLbdW8RgQOH", - "HaOz4bAFFN0/c43YKt5PqVKY7GCUk8+3bL9YT+ErIBQ/LhoMesl+4rRao0efIvXt6425bpcyGcBTvCU/", - "SNDyYdciGOWBTdnomV6bgWw+Dbw3nRlizuc0YBML2b4+SYpaP6Ct0X1r+9+aqy8cc/O0mTzFHku7VI1k", - "Hw2FljaD9pCcFF5gLXDTiKdt46x5xQ+01vxeKsyeSyUdwnaJJUL4b4qsL0+ZxwQdYKXtAeMbdQCVmVVG", - "0r43pzIPbcumBQLIBOCRilU2Aiuw+JpL5mLIOiAGIb3VAeRcZXw6oGuEJjuFltIvQREZv2662Zx05JS+", - "L3qAEvDga9rKcR5l0rP9599jgoiXbpeAfbomcBgNRUQ4HUKdijatiaeq9c2oUtX6vG354MFzvGoD92s7", - "Ww3iLPuokWaIHv9OuflBKlRdtOPz3HhWBbz8Y6YQ+bCZM6FTwgGesngic7P5/EMxkB7tlV8kAy6TSfs3", - "MkUijmqh5228wCPIlGNYX2lYDhblipsV6PXcy2SKIbs+gzMuJHaEP5cdY9bcDx/QwDELBDc9Z4IpHmFO", - "YosGKfDFBCqDMjWlzVK6hlKMItCLJydONeaBrlHVwQ2SnvcRfnx2Av4STFn1UG80PByO8DBnTNCM9457", - "h8P94aiHr6oFTnFvmnPQF+I/3Iu6ULKcxE4S+t4XgpqKpsxgjV8DqBXoI+uK4xOEziuPyIxy5V6RWSLj", - "gmA41MYkG/5CPba3ct8ue2f9PobEY6QWy164zX2LgjKeHZzmwWjk4PyNu34xzswGt+z9w3k6l/12kurc", - "EgVyTqw987xsWSz9h37vaLR/pTFtGgqe3VDHrwV1AecMX+f3RqOb7/RE2BBSBwjgXPeqJw4JqXrWfn0L", - "e6bzNKVq5ResulqZ1G2CMQPVoytr33FGkwhYBWbGAswhZr+D1ppaL3uVC0wo7isChdZPgW3bb3IBqPW9", - "jFefbAlrfXgdxYc6O4Pj8mGNnj8d7RRkvL6R7pPHlbdUewsE9D0tsuHf2Uk5Gj26+U5BPZ/wCAKKPQE7", - "33mu0T0tQZR8j5MlFfktl4aSIvTkCzrSTmadFuTWL6+ivT94/MEe74SFTDZnTKVU2EAeW2bLoV87ztZ8", - "Vh7njbeaJ/yTpz13U3nAKHtRoSBXP6LVa6spDK5fR0e947Y+7fTiOyT8o1s44W6yRULkuzxymIYWzCBf", - "0nFy5uBpKYQEZbnnzHwuND+6zSvLpc74C56iL4WAn7NCwit3a+1S2MtULuwDOCgBviyDa129b+rC36vy", - "S8WjC+0a0DQmcTHWB4DGqyHxa2of/aD01TaLglpaj8D6+TqD4X0uJ+zgNk4YzriwFH29pr5eU5tOuaUW", - "PwU8mJVT3kEHcSUNxF9P/3Bl7cNX3UN33UMnzYNg72xpgOwcEuc9HcmYEb2AlLToY4P4W95PylA1nP9O", - "qIoWfMkQgBFTE+aJ4RlV6AWVErASWBt6q2Jio1qiaG4Pmht4n9lygZuYK5pN0AVm0oaVWnrLciFAWUu1", - "95opoS/Xkujbsx9UsBcNllcjebeQmhXYk8JUbnMMxdf2dYzNDsfilQMlhgVEx3/PazRLEFp5g/5HCkLH", - "wlX41rMQ77SoaVpyLqoQ35JbFNWaW1M5VRzpREcyhAv1igkqzEBnLOIzcBDFaV2ylfM9DjbYKdsYDNiP", - "E1L3eF+6g90wtiC6LoWBpJ8W34ijpLr9Rkjj8rCXRi4Pd0UVpKcIJpGZJ3JKk4ldn0sWsAk+xxJuUUqD", - "S2lNEjJm4x78la3MQgr7dz7Nhcnt31Ml32mmwOY0Fhg05NYavBUKAdF62/E0k8pYPwfsc88Oce+PS7b6", - "AG51ccqFraFtFZpoCWYKqGekx3ex3KuFHuxpCtvBn+TayLSK0uvpzg5T5ibLjYt+0sz0Qwi1Y2Ek+cPj", - "kH7Y+6Ps8QMaixmNgU4qReyUULZuG7WeUJj9BIsGzO0MF2Dcg4vUunnMFRUGx1QCqZJ5dUt3ikwemCe4", - "ucIRFSSTmc2CgkS1oEBytTYQV4QmCTF4lHxdENxxJ1vm42Ai02krRqQF9WscIy7I6feVwzQ6ehg+T5pF", - "ioU8Sv7P+YtfCN7KsAe2WOmuhWvEBQgM4EWD6V0cT3sGSFbWUIUpNMc9Ho97hTk33sWx5tq5ywwGaFP8", - "Dob2ne2mz+PvhkNoyporj8mvf9hWjuEsZanFrB33PvRJ5cOcm0U+Lb69DS9oG9TeeY0RkB17ze0iJ6Ec", - "UZEqN769IkF1J90tAE6jpORAVceVKRdUrTYFvQaW3q2gnFlPxspi/DFGz8Vx73jsfRfHvf64x8QSf3MO", - "juPeh/AKOKtle75GvM8K42ZBRPdHo93tqO1ufQM2yw6GgU/8Bmx9FRXJZmEHHWTwX8s+8Kd+f35fvNjQ", - "TbyE0bIPf698v2u5Hnq/hc3/BcQeYB0pQ4+SQTVtHtwU6HKPVxvmhbiWZaTylKg+kQO2kcZ7gIqIJf49", - "sF0DdftWDaCiiCXJbZ+cuzo3hd2uSHfxRRnqcLPK873RrnDHFDe6rduuZk+4G/r94hT7AbW+U+qzpffB", - "Dif7QSAn98YntjBoTs5xTINzyP//DH8duv/6RykCk14kcn5xbHUKkLeCJFy4QIWKBzXILW4tsZLFcirq", - "2X8WmRZ3rIjz73/+CwfFxfzf//yXS5Dw73/+C4/7nsUoxJTvFwtGlZkyai6OCURMDmgC/u1uMpiUGeKy", - "VuRw5IwR+AmGJFhUeHvLHEBNx+IlM7kSlYAOm/RQuwadDQPmw0XOtMPCgoJ85jIyWafLgELJn2W7lLd6", - "ovsBTFGcQWUCcCt6GkBARm7z3rsnci+sy7Vzrmlzm/6ja16E2/mLYe+Npd6BHeAVGQwucejc4Qc3abJz", - "fv5sd0jwGWipArNu4aOmbMa9b4ZfedJ2nmQ5Sp2h4Cpb3hTRjE55wr0utCVlkD2CKY0WgO1VOD4XgP2+", - "iWM/UuAx4APqPDT7WHQsXpzvoe7XsMjkivUdJ1AOprfMKShdAA72gPyLG3RbG7iyYzFjFNogJ08tE6gg", - "2RdBtUXDAtFw0PmWm1r6wr4PSXXw33DwQJJNsBL2P6eGvaOrPqlIvjbFUEINvNR1HwqPhY2BdGswQLwf", - "UhnmEPmZHdLAuxi7YDLFZqC1xYm4LPzY904lILZfRqf67myksh0WkU4ch/nN8YkqraISW3px7ndjF0Nh", - "o4QjNURUjMUcPZQ8ArYUtV0tIt0WVMWDSMIlUEVEA9fohMXzNh77pNJW7wYlmVo/geP0Y5NcvzThYrE+", - "ATjEFuVxs0nxqSvTzaboWvwrGRXtAl3FqmhVy8zyG7u6Xy2MHSyM4XXz1saQye+phzG9OVdk28UdeSJ7", - "2ltfc/ulsmR3oWokOx4fCs01UpGzJyeExrFiWu/+uRWRMFNLpaX8B/cjsOK78IlxY5HK7oXXt9QJ5Eth", - "By/dqAn182omqa7eb3u1DFatN12RzKq88m7+9mh0epVrpBR6S1r7epNs9QLmOoKYyiq1DFA0SlghvhTn", - "tEpF27TK1r+4uHI2iku2FDhvuAN5e/pl13UumnfDLTDFpw2GeIeMsB4DXk09/yVR8+tiF928NqmfPy/S", - "HN2eFHTbqugQmX9Jz8W4sWzABS0CS+sF+pwZi7tyk+9010Ng4qDndqfaDnRlZ11My1YlFkAGJ4SamM1v", - "3xNbpNvT17b3V3r54vJcRWJxS/5VROnw2C3XatMD98TlUb+5920NYu6W/WkcgQUWGT443TTiNUFqUqpX", - "Itr96lLzySkaF7vyiFV+3iwuNNn4vXxn3ZZcBznxy6T9XBfvWi7ILAGEYWsEiPkMnQhNNQk+jvLgFkZZ", - "JJtX1DDnO/klBiSf5Ym1bkRSLJmqQEhWr9S9P9CbdvtTyTOvjbfr65c/D5iIZFwYT9plUvflEz+YLP3X", - "goxv/9R9gYG23IsHbQLjR+y/9XInBabo/zr4waGK/q+DH2iSccH+1+HjhBqmze6NEcvotm66237AfMHE", - "B+8XXl+0Nda0Z+i8GiBbp0yPq3sVyqzh4XpldxHh88mo79MLeU0Q4U4S3q3RPbykbhtK5cSntLBbKpWH", - "1WpgJf+5hb7zGkHfur6u1j3XOAIU7L5A/BapPBwsdXja3BO3401irpjW25QRRamO+ghf/i+lkrCTvpJS", - "oljXr3qJLnqJ6nJtVE3YgjernLB93JH1vSC20Grjp684YLdg0HEUWcEBq1m4SySwhdQGP30eoBB/pkgc", - "XhyF6n3W0WRacoqN95o/UydP+7jDfdjTk6dlMPgtGVD9OG5dI+D6vX1p7HE65fNc5roaZ55SEy2YdhgM", - "CavfDF+arqKUG1q1FZ8xlY5u8067dWXEV7q/ITVJc0Mt87ZeENseI75U18eIKw+PEYtP7XAqXMKvvk8G", - "udsSneIRqruScQ3I+0O/y7hCjyTIzqFJ+Y4h+LQ5Hov/DQ+jXw2j6dvvfEB8Phod3MffmVi+/c7HxItT", - "TypMGMVd7t7HvzxF15M5Rhdget8SfqM5DpLm2ljS80li/nQvt9L7pvvTzVPh16dbp6dbZbk2P91swRt+", - "u9UTTd36483TW2jB7be/6PPtL25Trj0tdT6b8Ygzgem6UCup15yo7RPzqzn5evpRmw6RKlPxwKxJIp2f", - "kQXX2iKhF2m6P6mLY781a4ck1BiWZqbIKelyQupFbiDXpU/igRP0+eB4OZ/Q9e6bmvhGwpG7tWQjmwJ3", - "gy/dItfobT91XcdfaOiszFzafPe4LEWb9tfl3RLvzb4pO1y1t/+q/JJJzD7f1pcugxdCICmdtT+luY0z", - "LmqWeJZD8urVzz6mmGLyXJfi0MgiCa+zY41FNa/hkDwrE0baAr4FeD6w2GEQQH2fKTBmNE64YBiEwXQo", - "/LeejfROj8Wnl4DDqVZv2/be5VjaDb1DCfjOWMGtyJqFs4FxluLiaFaysBanxcubeGq+KH7lGFCA8YRk", - "vT2aGzlwKAV7C2kxNcOwwmcJjRBVGIpZwEsHDGMRbqtNIdqLkknClAUyzXLjxS3AFHaD48LIIpu6k8wu", - "oPkJ5vS+6FsfSCibaAKZ/C3UzVjUOnMyH4I3IDAJjlCxzI64kXcYBs1B1QilEGeh2iWhyTu60mPh4B5s", - "9VRiVHRkMX+TZEh+lIi0Y/NvVxivTX77jR6LCx4nbOKAci4I10QvpDJMsJikcsl0vV9GVcKZwkk8obBy", - "mqR0hVCaFlXYro/MmIWrrMHxSPg3FTHHNKrQczHl47Gg5GA0IimjQjtwDU1neOG4NlwO9eqAviWUHI0e", - "uVqNfUO4d7/8O3CalGJLGdEpZMwFKrbpyXdxA1OX1timiceM7lxpu1+FftPlq6xtLNc+S2/cJ7ko4UNQ", - "11+xrsF2mVwJnKczTzKuimvQISZNWURhPYWs94MgujKKchW6IGGrK/m1/4yCY2V657hUYXCOBFUGEcQA", - "SER+XOCZlniUdr9toaqSqP4aF03wkEhFKKnQdanRYFGOrHEHQWcvymSxwid/v9j91p8dOL6OEfjjL+Zf", - "0v2ERCRns9oB3H412QO8KShunYT/quf0iWN6NRYXczoXUhseeWboMb2rj+avD8JOD8LNKxuk5plUl+2e", - "0D9Iddn1BeY9Nr+sh1h1hp+hIQKGh046d2+PQG24fawA0dz6I61JX8UpRaGLG134KpNEijlTVa38rZsN", - "qq+6HYu0CZepssbuAhcNHiET96NNNF7xN0cTQ+Ra/cs6qyGxwWaXPmvTlX16lEhyV+OVcKqqgA/2Lait", - "/0Hfi0NIV37DdlB6X9+uIFMFoNGtSK1F5x6WNADVOhavtU3ucGFNTxek4MEg0NqELeTdgkcLaAd/w/Yt", - "qivNsosCSn/3mDzHg1zZNtv5jk3TArSmZcIsGusyTS+O11Ntvzk9xUpYZmGTal8cE59eu7g/NJSqwrDC", - "LBKqDfnFgcvuFI9x3NEL0GFW5rfrAFrLVAdjEQJrBaxT2yCfkYsKbutFC6ig57c/y7n+bExFZYIaOxcj", - "iXs6Im0yEffanDx4Ejb87I9GobwJHeFj7TBuGD12bTA/y3mRHKdGyjTLupKvGyZS8TJNN9Aw2Sk5CNEm", - "lrn5mzYxUworO+puI26yQyP7D0MvgVAd8qg/2Ltj0bJUdobhpQKm2uv3mMjT3vGv7l/LNO31e248UO+d", - "ydJKtosrCPlb4HibDX7oh3aogrn7FxbP7+xKdImUiqMSS2a9I1HicS8ogHLF84Jbeh3o3/oNVcH+bVx3", - "TgfQ/ox4aQv85U2cXtF4a+K7e9E0xKcgfdzZKUYxq6EL/5wk+cp463ozIQtUZRzZo9sYGUIvkyiRmtXs", - "ZF8OcKPTFzZE73Z9m1/jAQwvzn0Kvi6OQOeu6rmv+RmoMLa53PgxEz/dW/e9WR/BlwxCoddmA+yvgfa3", - "zSnnsyekT7cla1PtQiFfafPqytpOhAnPrXUW4SrENiUrzY1MqeERpgOMFlLqCtkX0Pw2cafTwReUiRoq", - "qyxwgRgXQKoXTpt/4UTMY6d5JLT6yfUxxOoufCNcw38qa/xQUa4UHL/vX1CYmUZDyjTF2YxkNNcM5Mwc", - "NGKrKGE+/yMDu3pEM5MrhqltGUm54GmeVnMuwI4tKeJDXeynF30yzQ1JQMumio/eZymSacpEbOWksVgw", - "uuRMwaIk1DARrQaaYUr8JSOQ9iGRNEZNTRZTNJhhIKViQIGYwCJlhsbUUBR0LuDET2ws2EWRJd9qRwR7", - "X1ID2I5z8a3NpgPNXviBXhCG6SK4XhTZlCMaMxEF0yicf95s7NOr9M+ZaU70jhysrsVL79Ljqqq69sP5", - "PJyxvljIjw5sfoPQq9sf1fUgGk9Gf84jbefq53hHdrpiiTed4s/DQFcQ3WdjpLt7K5xUJM5td5VTiWT+", - "V9UjFgylhggBAbp2G69rXyuysxbLfCWet/eH//PkGtrFz4QT9lsf9m15AMtJfw4s163qtXjuHalVnS6p", - "qpO7OxbsBnV34pNUFS73pShba8h7Bd+uciejKL6+pPjKtpts2/mNXJdte93smmdEhZFzMUBX2zAHd2rc", - "VlbtVAd/0qCexuwqLPPOWWRpubh1GE3PGjO6AlXJX8HXeoP9KJJKWRQRatiXBf1d0RpWoyxQN1cmGO37", - "oNc3p6e7bVxCmY08QpkvmENUIpugWhqvK3BfLJlSPPbwpk9On5Y2WZWLIXmRckOMJJeMZWVgEAZnAmpn", - "gafSGHYTOKXfY8KoVSa5MFtHURa9mcGUP0gHK/MZipIul8RXc3hnczhq9r88doZchtBiAptfpoaarTmu", - "uZhJlVq5jE5lDq0DD4Jlgv20zhYznjC90oal1rkToCDguGFeIpd73tWzu9xH12Y4OTbqMGMq5VpzKfRY", - "uJCbjCnoG6pD+xU/taBBwNCCv55ZJvl5+EDCYKzbHzVtq4bIV5jTunfc26NZthdTQ1v87NzwPmJIP6BT", - "I9GrdAoBlOAVeanJTsIv7fOELDVJ4I/djV6RE6z3qTPrX/9kwUqfiJkM5i21NFsQ818qOM6xNW+Y/CzY", - "2h29Mz/ai/A5qx5czwtnspXF6q08VjGaDDAvv8diIrnhCf/dsl1ohGvDIxtFRot9fHNaMPjhWJwyo3hk", - "7b0R+J8jSAW+dPcyJaM9wPE7jDKOgH6HDAeHzLf9c4o9Pjl7jeVSlkq16o8FFa7hV4/PrKV5RiPWHKhg", - "BizJ5GTvxRaf9XNcpj+x/6Sd4EZAiuCGfzVPXh02pvUM6ZYjKrNNzzaZ/Wn1OjL7HJU6Tnb9qlH5MjUq", - "QFblbHYKZDgP54YvwZlUEYtJJt8xNZCzWVilspRJnsI/7B8n29DyDI0Wb7DoZyP82+Fs7cZP8Itw/Hdz", - "iplNM30nNiC7YF+qCy8snJ8CylE158jgRfTY/BWp+9PfetV1/Aytv25FfQr3z+Zs3fZ16MbgcVuq6/Gl", - "HHNLaX4mRm5Wxr2jvF0Z930io0vtAH6qWlSiGEXUfvixRFl3FlOUHTDemDhgLAu/xnR/LBr6WIsjpQkl", - "hqmUC5rs4ZxtI4gX75V6dCk5hv1HGLYz0KBtz2SSICg8girCbKDEzDdQMXBrl+SyWqZqmzUSkKNkyjyG", - "/m7o9fh3ys0PUtUB8T8Xvviqsv4INEk5mh+25ABo7/GjcgKc0vfoOR7nzr7uR7TzXJY/Ws1Yn+DejHuH", - "Iz3u9cm4d5COe7ADTyhqlKkh90jKRW4AXPOpVfdhYPf9EdEskiLWHsrfKzQPR7pl5o4sW2KG72O92xR7", - "HFXhUr50nYTYA5QjUB9jmMhO9cC5Mxn38dDFRObGWj/cuXKlYmZQQ7N766bryhn5ql7owsn/7o5vjUfh", - "LgO7rGy95exZrhesXev3s83blZsprEOR51svyD/kVPch8MEaBwC0b43vQe0z28FtpK+Arq6SusLN/Wve", - "ig55K8q1CkOAWn9TuJI9dVgcUPY+k8rA7w46wdEQviQQjwSzcb54cjIWEbAiC1ipWCqROzmUfXsLP/77", - "OXn25GWfPMWc0+THfLo7JC8g2Adb1c5kNRZWErPMK6KA7W5nEIeuZzt2pJ6b9J2HDq4kxR98OmMTnoyA", - "ocnvlfeZ7/cWjMYokfzR+1nazgJY1i9/hgME++dqFtve2yh8gBlBrQaPZ4ap9WZPXdiYKJBY3CXtgQ2d", - "4IYdY4fa4/mVfVrZwAKuHB70AvgrH76mErn5XOW3YzTEfl12SQgo/FLTFONBLJhjiAVWr+siGUdb0LTj", - "ZRsfGNjlydNP8qi4UUP5Jt5Vy1jwZz1dONMv1taV1fYJiLhI4rPV2OxjpRcWZNtWIxHNaMTNqk9okrg7", - "yt0EhYPOoBB/p4rRS1DmDwEIzfXs45vBXNz3tmISc31pW3Dm4CEBDz2dT4vBETxo1nCNaw5RwkaSiCZR", - "nlDDCJvNWIShyZgVSLeYk4uh9G7w7JSdBJFpKk7++ReXOTFME7h7JVk0KW7PbvWeYlFCedoOae8ENfS/", - "RG+HKTQqBbhPJJbiaKSk1sQ1NWAJn3PI7IHOGpDMA9RcNGVjkSVUCKZIrm2QAAx9kCmmda6YbwDuLkdR", - "fVLCVWZKGucdkUip9Fh4Cn9zSrRh2QYye2lbPsU535Bsaxt3Pd2RkroxhnZViCtCYEMspdgFBzoC1dAd", - "eObbAd21lPilHPxXis/B/TZTkloma12j7LH2y2kPfS2AuzWL6nlRqlsW1aLVSpBmJYBxI9zgpERwj3tX", - "c4IMdH7JWxEp3aerBVX/BJU69l0P3g0Pwn36yFmGEsL+GXOvnldiJrsqsEoK/9LUSZWR145qLe54O8pY", - "50Djmwz87QwndmcoYl8yeBitRRO3PXg/P0IY3S7oxW2n7vuyaasG/lV7m7YgIGzP0fBZUODNJGe4Y9CX", - "ayRn+KxgCIB27hAOJnhQ7wpWoGZ7luprfoUbRROwSRYQna4NTcByPee8uvGh9MaV6fZMci3+lSR4u0BX", - "kd/9sn999Xd4MlQWa5sJGgiepZlZuUreVlk6nWn+Oxu2GIILv9WbMwVfw6Xz05GHp9NWh847BFC7Q0PO", - "nfiMuoSUXIObX5n4z8eWf2GQi9UzV7tY9uDWGVAVLfiStSvd6yfYLVGm2CCTGRpXYrtgbj38XWaoGs5/", - "J655B0Hr/oUZTTGXAotJzBWLDHiLCCORI9g+vtFESWncd6lW7V4i9oj8oGT62M1my33ozpRThpV+hulq", - "EFNDB0vPbTao0D7Cu9P7UwLDI1yQ59+THfbeKJs3hczg5QMB735J2fuIsVgjTe5WB7w/Cg8RGp7Mp11G", - "uSEDzgv8gyYkyrWRqd/7k6dkBzPqzZmAvQBRf4aSbKbkkscsro0RnPftqu63LOhV9a4gVBTpEP3jwg7u", - "TmSYLhfS/Hee1dlC4RIz5YLi4LbmmKmfKYtpAP1RLrwDjtsjP4qvV5h7+e34xw5QImZ3dYtopLSI17tf", - "r7kv+ZqrBkP5O61223n3nM3K627xUR3Dlm4iD0YRO3e7aus3n09ID9dfZDSPU50viwdpm9r88yLB0e3d", - "D7etLn/zBYeAgrJ82Vg224BahgnmZ/TpjtmSJTJLMcs+lu31e7lKese9hTHZ8d4e+n4vpDbHR48eHPY+", - "vP3w/w4AGcPD5HgAAgA=", + "H4sIAAAAAAAC/+z9+3IbN7Y3DN8Kit9+KtIekqIOlm2lUs+n2I6jJ1asbdmeZ+8wHwV2gyRG3UAHQMtm", + "Uq76/poLmHqvcK7krbUA9IlosiVbkp24pmois3HGwsLCOvzWH71IppkUTBjdO/qjp6MFSyn+eWwMjRZv", + "ZZKn7BX7LWfawM+ZkhlThjMslMpcmElGzQL+FTMdKZ4ZLkXvqHdGzYK8WzDFyBW2QvRC5klMpoxgPRb3", + "+j32nqZZwnpHvZ1UmJ2YGtrr98wyg5+0UVzMex/6PcVoLEWytN3MaJ6Y3tGMJpr1G92eQtOEagJVBlin", + "aG8qZcKo6H3AFn/LuWJx7+iX6jR+LQrL6T9YZKDz49zIc0NFPF2eyYRHy9XJvuAif4+9EZobmVLDI6Jt", + "HZJhJTKlmsVECkIjw68Y4WIqcxGT10/OSCSFYBE0psdCTjVTVywmMyVTYhaMLKQ2WMYoGl0SQ6cJG45F", + "r9/YDybgS7x5lf6+YGbBVGCwXBPXCplJRcyCa8IFfI3YsLphRuVsdWX7PR4nbGJ4ymRuVhfqR/mOJFLM", + "cVq+XZLm2pAFvWLkd6Yk+S2nCZ8tuZi3L9KUzaRi5MdlxlIqSJbQiGnCDeHCSD8bu0YljT1IQ8TF50Iq", + "NomZNlxQaH+SSWX06uhf4h80IZWyODQsT8yCGk/lQhpyyVhWnyh9Ry/ry/jL3l7/8Wg0+rXf44al9ljR", + "9zzN097R4YMH+w/6vZQL++/dYvRcGDZnqveh+IUqRZeV6WiZq4hNIh6rdTOJEs6EIU9Onr664QR6u6Mh", + "/m/nUa/f2328N9w9fIT/3j3sVae1svD1kX9Yf/TODTW5XuVB9jRNHKFMKkSyOuuf83TKFJEzEuVKMWGS", + "JcEjxeIORFeb9ii0FZEUMz7PFYtX+/ZHrracC6oJFZZpDBr8omys07mLgInF8p2YKJZSLmCNVwbxyn8i", + "cEKJO0QwpEgKo2SSAFMwhqWZ0f4U9YGNC0KzLOERsp7aoTpIR7rX74k8Seh0ZYTlbrOEzzkW6LQ0XFc2", + "ydclRhImDFPFCe+yNDW22NZxudzB3Sj5YqcuFzKJJ7kwPFnt9Q387Na02hPXZMGSmMjZrE/4jFACrcDP", + "lsbry7432jscjA4Go8PXuw+PRo+PRg/+p9fvzaRKqekd9WJq2AB2ucveINPWXETh3RFNEknhQlIssrtT", + "XFi1DZyySKaMQNNrR37w8SNvvW6elJsKBYkrWN6sga0eNq6MbtSdUG0KJoT7xc1yQgNjes1Tpg1NM+BD", + "MIbKYrZxId9gcx/8yq9d4N2PWmDB3puJW6HgfEL0wd5nLIIbUXpuUggY0J4j74Jl3QmNK0a1FFZMgsv0", + "l14udJ7B1c3iSZZQA+32+j1LBpOUaw1Vix9iri0f6fc8kU+ENBOVC2ELCmbeSXVZLelamfCs1+8tqJ5c", + "zbO81193bdWJGrtgCc00tud2XE2YUlL1rGi8nMyk8pvU+7W6hGuaWlkhXVyxgRXq9Xu1BSjYuZ+LH3ex", + "q8HB9Xvur4myrwpszk5mdeDVtlaHWwxtPWO3t4gVov02E1dZ1zlAzOlcSG14pDuxeRQeYHtTGQdY59Oi", + "OcJjJgyfcaacXM2IgvshZcQ3QqARwgXJdeMcFKL/hF0xYfTk6mBiomx1URoPm+rmVWST8kas3MrF9hcn", + "ZQOR1ucefDhdUY5n8im74hFbld3c1kxixa+YCrDvQgCwrNCWI1tw1oGFCCnYdm2lxBWPOe3CDmIc04QH", + "qOfsyQmxn8nJU7K1YO/rnew9nD7qtTcpaBqghR/zlIoBHAgYlm8fy1bbfnEQapnLNM0ncyXzbLXlk5en", + "p28IfiQCJdxqi4/2QpJqFvEJjWPFtA7P33+sjm00Go2O6N7RaDQchUZ5xUQsVeuS2s/hJd0dxWxNk52W", + "1LW/sqQ/vz15enJMnkiVSYVvto0Hp7o81XlVyaa+KyH6/z7nSbxK9VP4mbWsE1Oaa8OEId/bYkQx+5Qj", + "7xZSMxLRaMHI1D5a8HmO7XUh+aJjf3uFRvCU60winydvT0tpDp+G7D2LclPr91sSc224iJxQVZlchxGB", + "+ilhcP+GJAtcAeLKcCmI8aLTjYWASDG6oTso0amz1fOfW/KapLqtdV+EcEFSniRcs0iKWFf74MIcHrRP", + "pnKK7bW50tUz+JmkTGs6Z2QL1VL43LAcnnBNZpQnLN7uJmG3TeYfclq512pnDslgQKfR7t5+kKGldM4m", + "MZ87vWKTBuF3kI+hHUN42joRlDC6zQO7VGy22t8PeJ9gJ4rNmGIi+ujuMiWvmKDuSfUf2G/v/7NTKlx3", + "nLZ1BxfzrCz+od/7LWc5m2RSczvCFTbhvgAZ4VITrBEeM36KtztRlDZUrT8fWOITnMRS2Ny4Nk71A/IW", + "nW+s8hrKNBk6sqNCwKlwgVa+/QwkrYDIIoVhIrA6L+ScJFzYZxATxu0FCnvLjH2XyPl275OtQ7H8q4cf", + "xn0D5mV/aGkNvvWLV0Ei59XVXDCqzJTVFrPlXnUNlaNrXf6z2vFpXKBUs8l6DnLGhWAx6tzdwbYlQbYO", + "vn3wFF1yM7mCGzh05nBYP3FDXInWphIZXc54wiYLqhd2xDSOuVW4ntVmEhAha8YMikoC3yCKNvioPv/x", + "eO/BIXEdBNbQaX+hwOpMKrWheVuWGKqmNEmCtNFObte/o1cpJEwBpcK37e4pKNATpuV0Pbeb7vGe64X9", + "C3k3jArvvl6/FwF5JfD3CuH2e+8H0OrgiipcdWi+Mqz/8j1Vfvu+7LTy61nRf+XHV24olZ9+8KOq/Pak", + "HKBfFaZWz4N7puGkw1Kl5MIMuMAtAAHcaZ6mdvOKV5bTZBApKhIeU13Y+TrB6smKSEW2Xv3wZH9///F2", + "d+GK68uJ5r+zyXy6Vm52g3aCMlQjUI1wQeZ8TqdLw/SQPKFCSAPGyGhBxZzFhM4M1HJjrT3AH4w2GWFa", + "hSSm2kQk8/sBffzo/XtqHh/yd/rx7+lUzf+xT3tt2sVct6wvauCo200oShQVgU282UWd0vfw8rdUEjJ+", + "nlpzFSkKuT3QzSEMSfmgn/H3sOaG7NZWOri44ddfYcISUgxywX/LcbezhC5X34CG0XSAFBFaXss37AHS", + "m4+PhvNj6/iZvqPcwMkpbKZuyn0ikxjunRlX2vS6W8OuJRgw9alEpNopC0tMqxTRXMDWS70YZ+tZSfiM", + "RcsoYavM3bPvTOVO3RozuHPwz0KB2JWNMxXgxP7Hs6KL2s9Py/5qvz+znX/o957QjE55wj1nrvNpZ5Of", + "OMXfpl2qNvbUVn3lan7o92aMmlyxwFqeo38AsXriQcKuWEJcaSDeI3J8dkJ0rmZoMkdqtWVBbS8102Oh", + "2JyqOGEaSf3dgkeLQl0JqgdNqCjdAshx8o4uNckU00yYo7EYFxpyPe71ydg+vtzflkrs39Y1xBcSc8W0", + "+wfoGsa9PrSVyLke94bkR6nNAJ7LTpY6ImOnj9HjHtmyf5KMam0WSubzxVikVNA5S5kwfYJOGqgGBs6U", + "LLcJFTEZ95TUzBg6YGmeIO+Hxo6zLGFjcc4THklBUhq9PHd133GzIK9spcrliTOGy7pPMqd61jRlY0Gt", + "GhR2ckkyJaeMJDQX0YJpwsRMqohtD8kZUwO/xH5vCVUMNsMqcUku4IgwWm6G/uVXwoRRztOhO3OBmVyH", + "/mDpi0e0vk7NE1vjQ2EduU7ln10VYFVuxsE3ilqW2vQKPdsbsVD1++uoZgnojwWuKO4qh1LvBKlt2Syh", + "cySVyiGyxKjHIpJpig891wvR7IopmhQ7BHecRH0C3A3uRhqLKJF5PFgsM6auuJaqDzcEi9AZQfXJbyzN", + "+9gp/DVIeaTkVUqkGIsEyHiHpvHhwfaQHJOEayAOP39uiduRGHIC1AdwGO24R71OftyzE+OawMU/JM+E", + "UdzSHNGW4Kb2Jm0QV9fNqzCrlbsN9+c6jZ3bGisWDvuzI+j+Cout0E1JgAUZV7ho6M5aw4BXZXC/ruuN", + "UW58xW5FVLidqlHnEeGG0CxjVGnCxViU1CRipFJXKVMMl0Nz47YuZYZspdQgewGt7Vggh/hGk9rubw8J", + "yo3WP6zkSFCFKJYs7YDYWPgxv+NJgopDkqMHA3I4e9BQM1bxoMDDREXB+5LS2uWMX84uWptA7YjYvv/r", + "2ekbopfasJRMuaBquU24LnmtJc1Vw1xYZHS7hy93FNXqs44lej1BXSJFXYBsnteNJgQngpZ0sYnCfpQh", + "F0uqokXIjU4b8uTsDYHP3LAIiLg2XqrSw6ApSeqW5qBXikKsXe9ac8h0Ns5ZwpHCEW+a7Elxj4RFpMIc", + "v2rtgpoVOy5LWAS8yvrT2PcbI864TGSKLF2w1dnstC6Rb1xv6l2TLal3YMLblZsFzrTKxZC8FATFCFKT", + "IsYCi3IRJXnMNKnwc1Kqb718UXODKsh+LP79//9/rCwRkytOC2mDvOXKgA/J7/YVO1M0ZcD06ldatGDR", + "5Vg0xRACrWpJqL9UimXmunqhKD5fGCLku+FYnNgxFQPe0nJm3lHF8gyemWQwcKMeODlr2zpxYUPcNFw0", + "f2nsTWVxrulLWDPnFRvaX6WwTaT6cym21Gl1Tg17RwMP4udAeoMrrtFlDWnClSUnZ0OCn9GUEC3sV+Ci", + "IMWSLUsVXMzHAr84kXibOInWkpkzTQ7Jy5SbgviFLK4Xd9ONBTgYThkTaEVMrqwDckmqS9bcAPDm3AUD", + "73A3dDTmMPaJkZN5HtS7+rsu5opFhrw9HRg5eHtKjKKzGY+AjjKm3KjtBdMcdJCfg49B0rLSvqJ3oUiG", + "8MhQPJ6DkAPL5UR/+5u9nDKmYFyvj8/ggsPV/5aMe4IaW6fk9AOw5PCYxeTn49dwtUYvz7fdqrmnqW24", + "B9dOSAne7+l8KphpG7/9ij644a1AV9pNzNcu0coWbSLvj5No4OK3DXyzRiYpORhIJyDEFiQ4JC9q8qut", + "UDiugAi6KtEXLfhD/C0pRvsdCjQkZVRoQp2sXxkR4XosvPRREzhA0iZuRaGqyoXlUvY+HFS4L4olVh5B", + "iaxw0r+C/x9caRldOhcP+8osOK2gKZ7u6tKtSFbcdBJyNqoAKg+WwJL63muCJ7wRtKCZXkiDr2r/jx3F", + "tJGKbcPj3PlLwfeM5pqRv5GUpVItx8KX79tzllBjfRiKujNgTD2yFSVSsKoewToQ0LHQRmYZi51h4lsy", + "c4ebFk6EUhW6altoLFwXesdKAJoUs8ANKC0wybLc5MpMtlHVgLMppgVzzlM77IU0WZLPB26ePbKV8Cvm", + "pg0T5L8z2wZYUaQUA+cPCUVL3Ql+IoaqOTNO9ayxfaSZcW8stvDcEvw3GFbSXPAIb3MsN8/yQVXF0SNb", + "z8/e7JQ+S2NR+YxVQKk34HKQ8JQDe9uCH8jJzkui4IbGn7mY29FjYTudYpJY3k1xSN7SJHfnFKkd1ncs", + "vPSPIx0YlZvFLE+OyNXvTgir70exk4VUtLvfd5qmBDVMrZLM21Oi6RXzBIm14EmtDRwjGl8xZbh22thL", + "suXIaeDsXEh3mgjGYiLkWFTbgoOMZApDbIr8xCpiNGks0liUYlvDk9xfbd5kWKgivODTXWOz/kXTYmP4", + "+FfLNZ7I58WjvnGRZLzdqgq6SDwoNCqXqfJ+ZeRlxgSUimWUp0wYwsVM+qJ1L7LRcK/NM62l+/PqtVJ0", + "rxdSGTLnhigGYpwUjpuNe4OYKwPHX+ezGX+Pr8gctUBWpsGWdB841LiXi0sh34lxrz7Mh4d0bxZP9zfu", + "hh92v7aGwX1Apue00q3xeuttaE/WGsxA1CRGwtu5+vJ3FP4JzGVlSBJcemoAZyXhLK7Qdt96686ZYMC5", + "YusDaoiX0FpMPoOgKHvrVqVrWWJadtR6zrZu6IY5zBM5xQvPT6R0Oh2Sk/ra9QnFDygw11e5iJaoOIaS", + "LTacD+F2ySI+AM/QAd0bjEaDUZPak4OBdXnPqDFMwQD/f7/Qwe/Hg/8ZDR7/Wv45GQ5+/dt/BB/kHb1V", + "vV3bzXPLn6U+8YOturA2B7rJvfXGlrXq8NsPL6oWWnc6UgyPAU02jgE8Dp5UirfT+pOTVa83u1KxBD30", + "kMudhE8VVcsdMefi/RGIc9rU12192XUKlkBwjBWMfAFCNXEall92rqjiVJhf7RjJuKocAPmN4K0B9/5T", + "HBEZDHw7jn15z/uaAWBIfpaGUGeRhifdERZa7XeuaJpS1HZe0YTHeDicmU3zmFnlrMBv5MpKSYqZXAly", + "MBr5L5PKoEBukNpPZdxzilMVLYhTCCmCqhAbIROxDLo0MqaNMKXKUqyeNDhmf9sp/tryfw5//dv2//6P", + "T0rqSGhraNyqM67Jzxp+3lCIbCXyHVMR1YwkDGar+yTmc260Fd5idI1Chdq3JLLOHtZ1USrChFdRY7k6", + "OafLAc34wGlerLn7BRNzs+gdHe4HF3fL/TH49T/9Ty0Lq/Ik9F57JXPUvOLnauC1H0Mn44tf3TxBo0vK", + "xYmttrsqTn7cDvuJrNtp+6hr3Wq4Y4qooA0DWY3AB4+jNCREXDGl4Chavvbk9Ck8YS6ZY2jwaiTjfDTa", + "j7AA/sncLyDEwVMGf9uuSzy2uZCw80uPRQuJbpBJIq+jpOw3mXqbl+BaG1lotUvuv+pTiEZ0axZHZ3dX", + "kEyVvGQKTTKwxJxpcsmWVl0wryk0mbgiV1R50+BrDEvAIv4TWoMYPo/hEYvB+RDLypRji+7NZsOgGE1K", + "bplSMHfhu1JHMmPAUF0xnBq5YOLqgqQ0s896xazSPKWGKQ7PxVKxmLKYA48eC4YHg2QUznwUSQUqVthb", + "1MGWq/CNJhf2mXiBzV9wAWR9YQ9mQ1X6R+/lm9ffv3zz89PJy7NnPx+fTH569t/ws63UO/rlj54F0ygc", + "r75nVDFF/uMPnO8H6zyLPn0Q6r6Qyr12vYke/VVoxocyY4LyYSTTXr/3n9V//vrhV+/uaSP3rnpHwYF9", + "CIqZTvcZ8MH3AVCaSFV6nlLEBUEW5dUOFXVDQ5VvJb9rHQl8onA5mWY6GJvS1FuUcujuaHT6/Y7zHnng", + "/7E9JM50i8MHHiSVE4/1AsinwOVAe1qSyMhFaMzaQvB9VyEGj7bWTHJhNjKnsugqjxoMyq/XYEU7Uy52", + "NGzDILreuiPd3NhR+Zm44koKfJ6juDRNmK6flZ9fPn02efbz294RXARxjnGEvX7v7OWr172j3v5oNOqF", + "CJS9z7hiOuj4eDzVMskNI1io9DEdktNco3OnYx6zHPWgKJ9pkuagWEqWhL2PklwDn0JpwJgkFH/8aLC3", + "+3r30dFodDQa/U9nh1Ug/Q3M+/nZGxuhjued0cQsJmia21TxRyz7BIt+6HvdJD7tA6tU7KnXVsLpdXXI", + "1qIuXdnJESTIcW//+ff2QO0+H/cqhOhCgYtWbMON1Xv+fWhdKtqoVUmv+GYj3ETsqX4VjMbq63Pt1ERV", + "S/hAUITYgZIxVTGZSqrib+u+NFgTFPnfaILaCpo4O5EVvbGOlSUl0/hW9j4+pbJV9xtLgJqf1KoSqSAM", + "LaVXHFjOIE259PXqbMkpU2o61GHFwBTQ41XchXr9HszM/cdPsNfvXf1ej6nerA50rjGd3oobHoE0ybhg", + "a16Bn4mwDzrlRNJ4sPuJZf2Kv1sDhsZ+qG938Tj1BL6C7jSlIn7HY7OYQEQ8DDlwQ7ovpChcXJPvYSY0", + "+fc///X2tFSI7D6fZu7O3N178JF3ZuOWhKaDsTbFRPIsPI03WXgSb0///c9/+Znc7ySsSHkj8dzt/zPb", + "QhOgxuF2WW/8FrtrIYeV8bmyxZa+AcMgdOXKK6YSuqxcJ25Mvd0R8vTGqBS35kZXr6JCXn+5QGteXKte", + "L8DmZ5wl1kfLut7i+0J7C5G1HeJpAZ70jfYRSIxMpTR2BLA2jK5go4RvpY9TSQ3dzRFJYSgXTLnxFjeG", + "vVLsiyU9PBiSZ+8zpjgITDQhMVXvuLBOL76me3MTKgAQKOGCDXjqLLh2SewkkSdDw2Bo8w5H2jocrWrt", + "UVkdE3c/2spSNRRit6lZUgwZ8yQrkPTWHZ9XtnT56A+QZIAiv6e6sMx2ocOCDHf3Tt2fe5Ygq8RXHC57", + "1rgqiM929S2IofB0NtiptrB2U0agJ0a1IQfkOf+ecAGh/Akjp/x7Qt3txAV5+z92H5DX6U6ylL7kmfXz", + "mNB5EZa6Dvnv/JJn7j2PNbyXgb2D4hxaxjM0HAuL7ANsA2kHPPK97dZAEIG2jgtw2+J9tiqjgXagvNFs", + "cWumVbnok2lu4MkvDSNO+eIgBmAsWHjKSF46kTYe4G6Cq44RuCyXTAmWTOwDW3dcGVuJuEqti4NTnVHt", + "kMiUybP6ej396fScbD1dCpryiPxkWz2VcQ7egJYnbNdXrz8WmUJ4F+gEzgJ3/coZkbkZyNnAKMb8EFNs", + "rLDDOJCLq+dnbxxMigYnpVcMFpaJ2Dm8emGn8HgV3xhrCq81W+2/sehtUDjevN/xZJ+74uXR7q6R7PeM", + "SULgdollaxBEZOMowHBVUJ8P7evDCXwuSywGyw2G5I0GbjACtxep0GuBTKVZVF+XeC3p6guohNAsi8H7", + "M/zELF+zjfN9sAjaraMsr5PuXr8V0/DKOkyAOKO7cq4rKFxhXAi4FOBcex0ZVRBsxgX5rO6YhZet6pXs", + "AMs9o6YOyNFVFW5bRjDYjd6hTqONS9Jdo13Rsa7otr0C8I+OQRPr2z8RfiBrNfqlDvAj+jq3jTSXyLXd", + "9zO7wSqdFGvSsAN8muU51hWdaSfcVivzWHlGk60LULM6OgbF6kWfXPxn7Qfgp16egufCO2JXA3m0gJ+q", + "7esVz+YNetwbezdTffP9ONatqFvkapcYRYW2fvYLmrEh+REvRmJYCtIi3FS86loo5LtvibRvFF91LGBo", + "uu5r6bX5ms8FuJ6h0zwwnDi2Kn+nsfP+NzoEd+z1cCsSux2dAy1CXua87cmFV71f1PnvqmJ+VW/lNPUr", + "Cgv83SoqUJVjdtLcQPf29eJs0jI3FsTMTb0h4NXV/5scg9xYClXkDfb/vGAXTQzpq4DGAiYnZ6W9pmI4", + "arPPOOEvbDu6ZEvccm8noiuWoqqJKGzIcS7tTpSpVEXdob1KuK7Yl6ylyBmH0Pm4fkSDZpNNWwHr1Xn5", + "6y//YBzOwE+2pBj3mPf4pJ4LweRsf6h01AwXHzUJRzas66JvVR8M9YtEALEk3je/2Ty6JaMT44X7Zeha", + "uyiCBD8F5ngZ/VHdWlLZWS9KYzNeFDMs7tdlA0Cn1psnZd1TFy1mT8XeKe4ZmQe47CjyuqiZ1D28Pk4P", + "9KzS2BqHsK5NrEbJ2vWtjNnRkwV29kEkdj/Q/lVDPG4C/8eNZ7hFjql3eUGT5IJsuULbRLF/ICqs2yvw", + "sCu2H1BuHQkU7mZvT/tjYbnAxcKYbAL/pydwii+ajbm6/oSXoOyPRii6Hhzs12M27IAbzdbV5UE0nPat", + "Ab+rW/LfalHKe/R7/FzcQIB4Q7YMncPRcbBHcE9sf6zCngvNolyxzWf9GMUjB72DY0ooF4MfX78+I4rN", + "ucZQ42BQg3WNb8Foc8qC0l3NT9fIutZ2b//gweHDR4+H8aUaskgNcz2Ah8xgd0hT+rsU9J0GsWsnXdIs", + "O7ra3cjn7RYU42tn+f5l204KMgWW7B2Su7ySn5RVSoPhJRdx1wZ+grKbnV79I/62zS6ZYoM8mysas09s", + "dLmxXxOuZvuubsiEst6hOdcGFBElBPDWej/m+mJdyWQQU0Ov48Zsh7vqsZwubVP2SR5qr9U9/LzpE17D", + "7QnmQ/hYJzM/ltC2tGEKW0UCiydGBsJ3vexw8hTW3JftBJ6KEMhGTq5mXG4K8oeh1UN3sbpXb0ATgyzi", + "TlPnrRq80PpbZd3b06pvzXAsBiiFHZGnRQdFs0WTFJ8YNLZW/i2pavHDaAiYAvQJeXs6JK+L0X6jvVHA", + "jokUkaM5GhRRKBpYkaw6gBwDbbhpVndqSYvHvI0uRNJ9GxZZW1ABWijQUF825Y352Lhu3Ch3l1ShZzoq", + "hNehk72y99E6hLKaR8iDwWh3sPvg9e7ouh4htwA5HWrruM5bnO9/lfs8eXPydM+pPbdvDEr2yUGpw6zs", + "aRm0QLZyzSoBuVIFQxUqEQEtoQg3jjC4pYCBEn5zXVm7Eq+h5G2gbYfwwLBI/wZ42E2GuRF0tTK5VYXO", + "MkP1Q3lKKoK83dEs4sHIa3AZ/F4xeolZBFbvbcShmNj7LOxviGAh0yWCY6GSS0lpZpoUGDKl8nv34OHB", + "o/3Dg0ejUQDPeZXgZcQnaJHtNABwwUnosoA23EI3hphMEzmtE/qD/cNHD0ePd/e6jsMa7rutQ/H+9rXI", + "lluRv/lMb/5LbVB7ew8P9/f3R4eHewedRmUb6zYoV7Yukjzcf3iw+2jvoNMqhN51zzy+dlOADyV7OLb5", + "keBfA52xiM94RBCXjkAFRA5YgBnfW6HrZ3JKY58SI3x3GMoTvda7z3bmSlp9a5onhmcJs99wQzqZJHDm", + "T7GlYI4xIYoUJNdryaGSb/T78nMpiqA4E7NpPp87yL9i6U5dNH8pPHGWxEekeLKt5XO4m+XAfm2jAzeH", + "jtTwQr4rwPcqRGCvLotUoRgp6MRuWm1WPlyIiywPkkTrUv6QKwvCgY0SOpW5sRZ8lzOm7MTi2Qi0aOci", + "7qbu+EGqy43xHXATF6lxOioMfKD/DIEAGiH+VaGvsLRbfwT3XZNXtoZVFJY/Z3k9L2Afe3IKReHRCeJC", + "b+ya6SpdhuUW1Jl7pz7bX8k778ijcTCzTmCf9oWt5gxTQpmNEgtQivWfOsfincPFoOJGRUqHdRfs3V0s", + "OgY8DoBsB6BCuZ0VX+c4XegaykJEunADwOeEmccVeKnGSTv3iBtuyYdj4eKtip+cUwBUtOtgHQmk4nNe", + "77iuZ71D1+XrUKYnrhtTZ7Vim8+gLsyAIR5gAadn1hPYei9W8W7dnvT6vfMid5ZjTPWl8T8GVqQMMFiF", + "Hjp7c10H5EzJGQ/hAaHXkfvqHmreNffFweh8sPtf1rsTyA8lNi6spxLYEYaN/EdYvttF9PzszVnbmIrk", + "U6Q6upU5rUE5Kj1ryqiYYnFcrDnXvuVKol4qiKGXDDRMeOJqxSx8F4uH5In1tUG5hs9Qo218MQuvAgzI", + "9n3FjmpQOeATJljRqDWlxjlQVRXnDYqBKKC91RMx4p6fvanjNTwOid8IuDLNYWCTNKAP/AG+E1ugAIw4", + "/b4ugu8dhJoOM+6zGgHhS39GI/AO6EwhAR1iYxqbEBmfn7155RIutWFVAzkVSZksTPWQ/FykJIPl1SUe", + "1TCgXGyQoHU9hwITnciQA8sPijGC38pUqEA3aPS26MaFowGNEd1KCp+QEXz/HdbgbzlVVBguWEze/qC/", + "JSNnZX/7A7HxR45ncV31u6w/Lh+GtrQ1jvBssdSg27PLYpOicFFVbCIX6PwyOSsrOhVw4H0STsfnOQ7Z", + "giSMuIDnrwYnL9/upDG76tfGBB+tl+7zszfbFbZ85cEsirJ1bnzVpmHyW1Vkh5yUGSmbBwFxtJ3qs0kd", + "sDcjMmUR9U7dzc2LigTOU3TXQEUZmLkNE0RRp6emotYIsi5wvM+TZOh4ph8yQc30DFl3BfvV3m6OqSmW", + "UXx8FZLXe4OdMqLzKGIsbni8NEddobcjkouUKr2gSXNyRwXAQrSgikaGKfLN+2964QxMyEq73g0V6iwu", + "p85kWbmKAvRYOXdtR/ztD/XjaaUDG1btdOpccIMwcYgNvlUM0qKZD8kpXTrVS4bXrKOXcsfobGbBUot7", + "RLGEUY2Z0zV5+8NmX04jDU3a5vAaPjo+tQUTglMEw+yTrMYG4PcqSlm128PglVHOJ2CZwg6bZo4hORFh", + "tmcdhhBn0EKGac3nAp6D2vkMwX3qV3Jl7+p3Z1CT1MRl7NUXrjadfuACCFFM6LaycaCrL6PVTK7yss6m", + "5OXm7KG2kfZ+n/hQ1YYpzD0//bnFiFbvvERsVccxrEJVs4wqaliytO+Rgjrr2SDYqh8KRAtcI1b2GRT/", + "YDMA5YpNzEIxDT5jNQXFfn81i7TGqIQr5hLn2TlVzHVGkpSqSzxl/vlNcmFXoB4Xu78JHGthTHaNSYFT", + "hdXJGaauaNKM2NIrfjlPGURpTZl5x5jwU6Ga0KpXfDPiXbckL4NYHqa4rK9hbz/Q77mNlCBzRSNGbC2f", + "g75ga3D0ui5lb79lWHDhaN2yv7vr9tdVneVJtz0ODWt30w6b6Dob/PrJmU/CVSQ598u8t7rKkEjCHjlX", + "Y8PW7un16eB8V8KiaK/I7FOG+eFcrFk1it17JWL+O4ERe5XI8Qpz0NVYZ9cPngK7VH17zn/t9CZsHveQ", + "+w1EGoWSxeMHF6U3R7BBjE1QOb68eGwlJXsnV+5nF0kFkhYXgMtc9/uOcpX0+r3BzM3qaGcH+H2CeKsH", + "+7uPdtY7f6/1+ndOjpOYr9MKuVLOWc5DAFiwSpx0nSR2aJZ10JtjzU33A7KnlU2wCeLhbqs8snyIC9hr", + "Gs6L72lkfEpLVKTXHCVo9dgiKnpdkIEGU5ulCl67j6vncxT0XAE31Dr576zQPszMeiIDjVglZWMdLZH/", + "HpROpQrlLZTKuHDlKfOP9uI+9I7AHv+7ZlIfParO8vDBg/0Hm/gQMpvGMXfnLjBVW7oOyMAqy+3Or2sA", + "/qPrMof7sp6scF020NTrJwGSWr+gMmPiWuv54GB/73rr2XUiJ96Zs8GXQnhWAGCFMlEZWZwyQ2NqaJ3J", + "oAYauAwmxqIsxcDB2bfrWUuL11MVoOqmWf0+lc9MS4LPVx7PPqWCz/CRZEtWe9YLuvfg8MimIY7Z7ODB", + "4XA4vC5sz7PiW7et2LGutRUEn6FefNw+3AI6T5e5/NE7O379IzCyXCt7ae3oKRdHlX8X/yw/4B/2n1Mu", + "wqg+XTJX89lKxura9ma5g01n8RHMRLhgLC8pdfDqazEhYUwBQokFMTJrvtW3B4ZZ0Div5zy5BijmmlB+", + "EFdAI9+6NjdOQi0KXaipJJ+u6hU6JKIG1891nh9e44xlXJ9W01Hk6F71h7lRlnW9NhHtSp7CjIki9WyS", + "2L8iKRCVPJSHtnZF+m8d0hjiNeLyFRZdVn8seq/8+KQ6kMrvPg1i5SeXkPbXazqyrRVI/74qh27mQl4c", + "3XCYw+r/4lbomvzbgWgGIzju+S68ibNnvfeX8//z2//VZw//sfvbi7dv//vq+f95+jP/77fJ2cuPAmha", + "j596ryConwz3FD0ca+CnXUnpFCwzq/QEz7+WFXZfrMbBRAtMV0ym7AhcsF9ww5RNftkIWYZ8DQxfSliL", + "SIFZCh2axTZUPrN+CFD5Dy8Gf2i2ETvYCuU2pABK0vk0linlYnssxsK1RfxENL4L4K+YRDSzGSy5AMUs", + "OHYrTDfqDMNl533yB82yD9uQEoUawt7bVAAZxYyNs8I2IbxbhxuVdV53xVmBt2zjiMeiuK0LAFHrHTAs", + "s41wljQj/VoWZf37zb2cHo1CUKsYhQYbiRm18AlSUDaQUREeRx6NtlffcxveGAUNrSE/5z5jw5QhzDhA", + "ii2hzU9ZzCPkKz6615asBFZbSnNKvEzJ90vcm1c25DQmNDcLJoxzjOyTSMpLzvq4pX0Cxln018Ka1gtn", + "IbPBdDlYyKyAYSls4daPpf7I/r8DN9HBW6b4zPUURNMAEgkInXhk3MywTKldWJnYa5uMSGg0yrviNquV", + "tomMbACGyZXwuXYYZtxFsKGC+lhIJv+WRAlHrZNeoA1vgWihBpoJAX72RkWgG51GMZs1/113RNp7cIgv", + "WP/v/b3OceZ26dZRWZ4E3rSpZ30dOLZlkzgAKx5MvCJ8g+sg3ICWExPUUxiJ/z0nvqHyxBWMxFr6bOSr", + "dqlbEl2Jed0OBie6Y+BAhSY0N11nt3oKa7GOHVqwPkVYLekAZ/QM50FevzgnhqnUo15sRbA7eEosds2A", + "a527LILHT06fbQ97QZS4mkkLt2ptLGR90AGEFHsOWl2nSh0NTVmfnDzFGHd3rZRvMQxK+kEqkthbsbyM", + "jhDOp67uoTb/6MlTJ4Amy9JRyYot4962bzFrXm9H5JXvltBiKEW0cklbvsnyMsFmnduqjZhaab0R3I72", + "Mff8c/cxxkdhclbLixHptvX+6q5zdCsOH5sasmtfSJWK7fqvyt5/akz4Ty+j719PRndW6Em2oDpE3Yuq", + "VRMLrex71ZBdZ/eq3dOv1u9E8+DZ+rtPUVW5hgyDe65WPQSC/GCwu/t69+D66rvrwnnXkfoqGJ8Fond3", + "KO7bgLQOAFRzM2kNCSHw2QWAeL3I21OIrgTkNfjY0I7s7j/sopTAXrsGU1Q+gkiNQyq4lEfeK4IALADi", + "JU8SK8BoPhc0IY/J1vnJ859OXrzYJgPy8uVpcyvW1Qjuzw2QvfEWwHW0zlEB8LUakAcpIn5fv34BX6KE", + "YdCUlcMvb473vVG12AH/2w/u+dkbqLGgeuLdrdsjjGkZpc/ec230Ku5ip6iFj8Ebt1VLxViXSdo2nFPl", + "RtDyH2uo2kEUz+1bQBv3IScry3kPQNz3Gdr7+YGAr4Xt/ljsbadnuCXo7dYrLQRb3cAxedB2u90cRPtW", + "hlODgQqxraqE43EXboxa3e/xQMz5sfPjIydnZZq60hjhm2/M6fHecPfwEWZa3h11Yewpjdb0fXr8pHvn", + "oz17yxzR6VEUH+GD/aY2K0fY9glCk3cQmTv2j8Rxz16Ylddt5djaMt1iLlbBwW+GBd4U41pguVGc9Y5L", + "epKuTZTUIai4CXWY5g40NuVJwjWLpIh1XUZeUE10ZrGSbcKgQoIfCxxgnxR521FKITSKVF6qHp107eT9", + "PHN0j0mLMyk0c1lLfmJLTVKORtCie3R91KSIXYvHYkv5OMcioBHzFcfwA0YN9Yl7CvXRaxgTI0GFsdCL", + "3AAT24YAFAHpjZXTypIpR4vRNtG5fdLieHE1lsAwNY+ZGgsoFkBj/qN4nhwdAjJCv1e85CC5y2gUoqZb", + "NX4OHew6toAhMFS4dHro7a5yQXIRM0VeSc2MoYRZcmi6yF3TcPqRGOe+ejfxylUv5arwwdwEid5JmPpo", + "jGccasv7HL1Db/A4f3BzEb1TpKCXX12MoKs1uY4HgwvJgBffFG47q5BjsVNDauZiPYrYmzc2cXB96s71", + "2EgwqqsleXt6WnN7cBEa3SaOXKJlH2R2rW3Y26Aj2Tia65iXK4jYm1GwPx6ZuimpVCTET45DXbUweugC", + "S6E1xVbt4bxOvwavymAMFBd2n4Bo1kywkTvaAr2UjpHVVvVSzxwqqxOlfUyFQ6QvQFtKo75e6p1prney", + "iO/Y73oHEXUeIaLOQRDyIGZXkzwPPY3gk+uHvHkDsDf4CyJC2wCZWveUHu4+Gj16PHg03T0cHMSj3QHd", + "3T8c7D2go9l+9HB/d29/TVBRhxjYm4e1Bl/MAT/mwmt94r3nQ07NbbELDdnE+WO/4yKW72rXX9BBttq7", + "c77d1P2qa33nIQRDghKqjVVftHCyU7zkWQRtYzkfZ13kiQsrOg9fj3Y/VvuDg2u5I16rXFizKhYoTQhp", + "ZcDVzaqP82YsHwfkA182rVa18+6LNjp68Pjowccumg/e2DTGJjnd4ea2eYR55PRGdIgPEq7okbyCsudk", + "IqvVt8WXvX4vF9W/URho+FIXnzsFcbUd2H6Yjay7VlogD05q7xX0VLHImfERSCr+PYI5XwpgDRCBnoAu", + "jFR0cRZIEO1wJ5W3CzSDZjGnorOByzYYAyMjuXbxfFwAI0b7IzTi8BGOyHMsi59oap91bhA2cXfV9Ebj", + "pfWXgfPlu7aPrPVDPnfvK6wDjy0C/8JpwzI4le36Jqx0dkR+llineO0J2dT92uL4zFot3ihLthzIvse7", + "wc6cqHlEfijEy0JAdQLplmbuz4ljWCXM1HYN7MPtODgSVnauAlzR79kV7fV7fqHgzwDUxZuS6lfOX5UU", + "Q45kjCZ4lssw/dzwxIHr40y4NjzSLngENrdN7HGxmSye2MdTm0+qDX21ZUhRyUtVb0/JFuKn/o04xTb8", + "a7vwX63ddXuPDx4fPtx7fNgJJa0c4GbR+AkiE6wObqOcHGX5xOlG2qYOSfRwzSOrVSh8X8DaVZJ5piSw", + "Hpi5b7Da+ePh4yo4XCxz4MPFkBySpMWixg0L4h8WvKjFD/I3nlzx2Uz89nt0ufcPxdPd94d6b7rbAnpt", + "Owqr3U6qzgUrOmo2HdjUnmH8LiQopVsh7l4xjTMg58wQpJ8BoRE+b4p4akdyua6teJCwDvb39x89fLDX", + "ia7c6CoHZ4JKuMCl7EZQliRYkmy9Oj8nOxWCs216JJgsAHPQOGfEJWgf1QXS4e5oP0QlLRd3STWu7au0", + "dcnfuuejm5RbdAzeLp6WK6c8uNr7+6OHBw8ePeh2jJ16eKLer+cwrpztz6fPqO78FkqTr4/PCLSuZjSC", + "XPbHVh88as2omGtGfj5+baGdhCQZU4PyRvQt1cNcna/ZteZnrjU/TCJjkz9smGLNU+XhIURv7XZDfQy5", + "rzg809rRr3PBwPENkFdgXwNLscrE+233Tkgws6T6ikUJ5elx5IM1GveYTfIwUbZYuQldrhj3ll+5AjvU", + "7aQmK5RfNtQH6xCpSC6K1ELDzcbdT2Kjbef/9qLZfD+EAnwErJ6DJ7PpGm+wlJliV1zm+hM0JI2Nvp0l", + "Uqpr1W17+rxiGix4HhTr7ek3mjhaI9qwrP4ac9S4BsTthpO71nmukUiYyNsWq9NudNn6dRPut5za/jpo", + "jho3aIVOjIFz5WKzG+kTmkQ5JtOixX7CrPCiQHCBLEuWNkogSaQUJFpQgeYW5VL3iTmhBFAYhkGfWvgy", + "mQX9M+Q7kkgL+g7JflyeKTsIqAbCEGiWtqrZHC0pNdI/P0gtk3GZhOrU+CANZ6oNozMVQfWwntTICh65", + "rVLTqSZyrvF5aTD+YdhMg5FRZcMaqLB5065S+yoNuG4Hhthg5qEbFT/CwbRPZSe8YMi6XUkaKakrwGJv", + "T/Wwa/RcEQ+92TW0PtgOpGtNo4GrDK843Tm9Yuh+DEQGfcwNiTSM0YdrnC69mjOlIsfMUxVCdir9YWfH", + "StBrTwrArGsOVpsJppMBVWBhAyvi9wvNki8TvBc9a7vJcjkP5hvVXqGqcFNtA2znqcEVDa9Wv6DBEBmv", + "ItStBcUroQKbsFjXAass849wja3yCgYh2cLomQpbqmBJbndxtwk/fqGflXevy0QMFo+uGI3rIRnPqFmc", + "iJlc5QTXscF6nbbze82Y8jCJMROcxf5VWhhjndKMa5eHLs6ZWznstgakh84SFF9OTtsGwUJ1Xt/ssIui", + "2Y5hfbYZ7NcV7LCTXIdDc1+rHNcKCQiIpwzS7eROyvUkbBhbbVixeZ5QhdCBHYesl2nCxWWX1vUyncqE", + "RwQqNC3sMwkhZBP4pL/DuWx3mh1UmLSlJju3g3MRhnZDGv2WU/gOZrndiG9Gnc6Orb8D9Tv5oQV9zn/g", + "CXMol28Ef18h9Ho6hoO9UVvcfUujtYj7VZjX63JuR7LBE5/rQJTiWinHJ1VjscuRgaUxORwetQ63kgdh", + "9sbEm9mG6iEoHwdy8sTy6wbECZkyjCDyU1tprgtb7DKVYGoZyLb3Dzmtq1a7OhAHEhZuiRJsQ7FZMFIA", + "d3StatuWWFmTyu5eB80C2SpMFCtdEyRiU2rH0lOrjZ+8WslyuGBuybifo8142CGDj/ckKYAQXK/dERGa", + "+SgDns+Id6PNEjM7YzqtZSXJKqQpUwoR6EHCkcLPBgFcpLJr7RG0IK57SRRLKRdjwUWhbkVYNkYEu2Kq", + "Em8rFTyy5hDs8ffKEw9+Z2lmli4ZBKrhv9EEjHF+jGNRHSQ0Dmr0ITkWVrOo8szU0sWy2L36gFB8knzF", + "jML8qdwsyEwxvajOPZQzF2S8d1LFrcnIlsQXgWlQtNYSIy+ZqLKyopng09A2NLG1Vv0BbcJr/Oren6SW", + "g5o0c0yv7y/XTIWFxGJKRZFOTjCVo1J5nOCBhAG43KLuL8viCzyVDugpZfP/5ZssfzorGq//1ihWQUjx", + "mOHHVm0bVMFGWb66Og2b3EanFwyoW4eLs2qVIFveGdsnaNLbLYmSOt2T3WL6mmEHfjQ7mkX13g8ePXh4", + "2DFT1UeZ/SwO2Kc28l2la4x7LTt12sWC9OjBo8eP9w8ePN67loXFR6i07E9blEp1fwBGxMBhTf79z3+9", + "Pa1Ty94D9OYeXWtQedY+pDdZhwG9Pf33P//lR3XjAYUYzSrcf4sHQKu/T1LdSe9yUDcGdjOSrXnfH9eU", + "BLRgM2SLIag3uO/YdRuUg2kAinSTgmlGI26WAUZO3/kEF65IA7W7Q+uNwYZEXtu2w1cFzqXzaVECfFhc", + "gf+0VuYGLTzqnPBO59M2i/bLZq9YjpRWi6q3RAdnBUsRYQV3MZ93VNdcw2Nm7Q79IlZtNW7HlliP39sM", + "qoChICRvra0olLWgIU+6StXtb2xnxW5ZU+s0V/zXNeew/QheS+sbuJEDSt8oy7s2VMrtcAHerNZkWk1F", + "uTbXZy1vZXnrXr/fDnHIq0lPihvs+v1VQi+vU7FBa5Ye3Rjckpdt92sk0UJNlaiagAJNJmxQSYOApYnO", + "rUUQzrwDrA/EgkaXcjaro+Y+aEdZRwAhDBvzvVBj4GXSB62/01k0IbotWtC490CPe0QqCMlMx72G2SoY", + "iJnS9xPXQR0lZrQO9rwMpG8MUvsZTBMZXdosi5i8f0hGJGVUaJILPPwNq9ruaL11qN/LKnvj1xEfdytL", + "6TaTTNmCXnHMzOJsKvOaSyd7z41G11Ns54jE0uJG1VJMuxlCMRsmeVROGi8dKpauYWgQyknhfWPLsqjg", + "m2Fia/E7U7LvYA+AY798edq3DgzoxGgHVvOU9BO1I+j1e2UXjUQN5e9hT2QwVuC4m8D/6eo6VqPb0bKq", + "mGZGOyTwkhwaRADhS8I0MwKk3R5y9QC11SspF+g26Nw/YEF975ZASMwiPJF69SzWCf0GxN2IQHArHQpB", + "2A+RMB6KNZl8XjmDcHMAVtlQyQ5v26l6iFsr4UQbmfXqp3rC3keMxU3o0HCRrl73rmbQ6/4FdWhDReJ2", + "Vxo9p1dnN7y9UDEca9tqV6MDhBQDOHXFltrDaZHrPOpNndCqq18Fx5iEgFpDBTqMX7D369f6Z/beINJ6", + "nCcsXl3b4khaVuUuo00rfuMYybYDLRXbmJ7zFtJWWs/1GyWutFXZfeSudKVuJV/lyu6cM+PLnjsyat2h", + "esqYmknLNUF8kbqPjSWlPnEXPNlNtxskeLAIa0UcvG/HaE/Qt4DxfcbfryEeW8A+jOsAKeVB8tRALFLp", + "Vkrfk4OHmERMN8Yu+HxhkmXdAecggMr0UUldFTNMeEVhl50vd9NXXPV2c9tZbT0kHJ9XQIZWkqM4kXSy", + "DoH7SVHMa+czukQtTquR8OH+wWi0vze6EQS3H9Y1lutJWcWlQK230xacV6lHWNViZjlQtYUiXHs1r7ZN", + "fFeuJtFGMZoeYQhPRiNGEjZDuL0iNHazZbHZ9frBO4HKxeMW9O83yu2bt8HXk+8UXYl55V9W9YFzraMZ", + "Vb9vMIi2sJloBZwvEL23Pxgdvt7dP3pweLS7exuw2cUitcWNPPx9993DZI/ODpJHy4e/7S4ezvfS/eA7", + "7JKLuCut/gRlW71sykuyjopUY2lky80hY6qZML2uNQI054QLNtBFrNXmgMc1vMDa3zee/+vp+e0M1soO", + "5/VJVkUIaogOUtb9IHm5yay1XTRnc/J0/SxuFMvUHEiY3ppDgVIdB4O5LnZ7H4nxkIuO19CbSsHOF9Ha", + "+LpNV1HIwo4nPbjLLSseIu8GxENl1usu8NVLLqA7nUvFzSJdf1sUxQpAcvSb/l2buI4cNSQncyEVq/9c", + "uMlVH1FQudfvJb8f1M+M+707hpjDMi4I0G11VSro4EaWsCuWrF8FLFI+PJT1ZKeK4UJ8tzvYfYx+CMnv", + "B9+NBo/rHgd9u1rV5dv1pWu/jrqsYTWZoE9Ctfv4Wh7Xfj3XUdBPPJQKr7yXHcqxo/EyN72/Onzobm2D", + "y88re9zABGoVQD9W0nOX26QqNMWgkQ2h3FcUtbrxeqwSGZmyORe6i952f1Qobh+A4pYcO6hxmxBeFv1U", + "mwdaqdIJT1MWc2pwVMqsiWDY66iLa74lrpflxNcKSGvDsLj2eDPYwqaAq03X5PAjIns/6vXb7cW7DgcE", + "9Wr+iYpoZFiwT/gMdND19n3aa/vowMBI9Fc78pBvJck6HqBLOdDrSfpkLg0pg/E76tty0a4XLMYPOTrz", + "tegbliD2Pgm0SgFFxtexr5OnJFMyzqMyfjTBQZfYISoXw65C/sah3ap+A0O8QcmxWb/RptDopp9s2++G", + "bhIItn2rd0ebt/pWlCL9Xp7Fm3mYLdSNg10LA35DCGJARVNf9oYkWJnMrx04+qvqCq6+ea0uOQKRKM+8", + "gQVoapWSAuYWNDGE/HqfsoQZFmqEyCQuoyS4LrnoZpa6e/ho0WbiRIvU6kB+Yiwj1FgkJewvBWteaGA+", + "gWlxl2yNPG64tgavgU185FarPriHGyWx1q2qqnDbkjFYLt/QeVvklcuK+tvPpiaarWKpeIZfE9JetScT", + "cDW921ur/vg21HL3KaS9dKaHBgCshycucNZ9/6UvMIh1deI9CJnng2RhZLZxpWeycCBaF617BiCxHiZB", + "zmZllK6+tIZfbzI3sgQnGmKqFG9THwtbwpEgACoBaCXXEVUxiBCwDG6efkNKGqVVU8wxwXHHKKKAJpJW", + "sSfgvWOduTEh/CxP+kRLwuHVIYRE3+oc8W5djuemnOPOg0v7WM6Ng8O59LhOrtpY+F7AXW9OubC2nkCq", + "m5Utek3nmBhxg6mr9TSHkoiiHYoSQ10mM8ymCv8kmDJWe3QeL8Nhdb+dLrMkrJWdSqccpNZZYLObV3tW", + "n9d0vhaAuRmxXLWQHA/+x1pEyGR4tPPd3/6/g1//M2gZaeh4NFODmM3QKe6SLQc25Rbok4Z1+GHM99HT", + "hs4dW2M0RX0nQvu7i6M63gej4oJb/kzTlSmgN2ElX9buxgn97T/affEqy/gG7/SNh/6j0+HcRtpgI73o", + "tJUyNfdxDz7ocXs4FhhHecmWmlSy8E2XNab6jS6qVKIlyIUl9yETVxdkyjGtqR4LqhBTm2Xw8nWJnTiO", + "RUlkU4rRpNqOywboz4sznnsW+PZ0Bbv65ZvX37988/PTycuzZz8fn0x+evbfvaOeYO8Gtod4ALR38ODQ", + "ZeSvruRuMCvM9ZObDMmpCylxbimzHJUvwMVAkskhSjBZEvY+SnINni249MYkN09jshpYfvO0IB+Je21M", + "EvKgcfjsgLkOY7aij7usuPbEyEFmS70ijguyKl1awhn38NY30gt7wSQysBXh1S43tr7oh4tu171FBA4c", + "dozOhsMWUHS/4BqxVbyfUqUw2cIoJ59v2Qd5b18Pofi4aDDoJfuJ02qNHn+K1Ldv1ua6vZLJAJ7iLflB", + "gpYPuxbBKA9sykbP9NoMZPNp4L3pzBBzPqcBm1jI9vVJUtT6AW2M7lvZ/9ZcfeGYm6fN5Cn2WNqlaiT7", + "aCi0tBm0h+Sk8AJrgZtGPG0bZ80rfqC15ndSYXZcKukQtkssEcJ/XWR9eco8JugAK20OGF+rA6jMrDKS", + "9r05lXloW9YtEEAmAI9UrLIRWIHFN1wyF0PWATEI6a0OIOcq49MBXSM02Sq0lH4Jisj4VdPN+qQjp/R9", + "0QOUgAdf01aO8yiTnu0+/x4TRLxyuwTs0zWBw2goIsLpEOpUtG5NPFWtbkaVqlbnbcsHD57jVWu4X9vZ", + "ahBn2UeNNEP0+HfKzQ9SoeqiHZ/n1rMq4OUfM4XIh82cCZ0SDvCUxROZm/XnH4qB9Giv/CIZcJlM2r+R", + "KRJxVAs9b+MFHkGmHMPqSsNysChX3CxBr+deJlMM2fUZnHEhsSP8uewYs+Z++IAGjlkguOk5E0zxCHMS", + "WzRIgS8mUBmUqSltltIVlGIUgV4+OXGqMQ90jaoObpD0vI/w8dkJ+EswZdVDvdFwfzjCw5wxQTPeO+rt", + "D3eHox6+qhY4xZ1pzkFfiP9wL+pCyXISO0noe18IaiqaMoM1fgmgVqCPrCuOTxA6rzwiM8qVe0VmiYwL", + "guFQG5Ns+Av1yN7KfbvsnfX7GBKPkVose+k291cUlPHs4DT3RiMH52/c9YtxZja4ZecfztO57LeTVOeW", + "KJBzYuWZ52XLYuk/9HsHo91rjWndUPDshjp+I6gLOGf4On8wGt1+pyfChpA6QADnulc9cUhI1bP2y6+w", + "ZzpPU6qWfsGqq5VJ3SYYM1A9urL2HWc0iYBVYGYswBxi9jtoran1sle5wITiviJQaP0U2Lb9JheAWt/L", + "ePnJlrDWh9dRfKizMzguH1bo+dPRTkHGqxvpPnlceUu1d0BA39MiG/69nZSD0ePb7xTU8wmPIKDYE7Dz", + "neca3dMSRMn3OFlSkd9yaSgpQk++oCPtZNZpQW798ira+YPHH+zxTljIZHPGVEqFDeSxZTYc+pXjbM1n", + "5XFee6t5wj952nM3lQeMshcVCnL1I1q9tprC4Op1dNA7auvTTi++R8I/uIMT7iZbJES+zyOHaWjBDPIl", + "HSdnDp6WQkhQlnvOzOdC86O7vLJc6oy/4Cn6Ugj4OSskvHK3Vi6FnUzlwj6AgxLgqzK41tX7pi78vS6/", + "VDy60K4BTWMSF2N9AGi8HBK/pvbRD0pfbbMoqCvrEVg/X2cwvM/lhO3dxQnDGReWoq/X1Ndrat0pt9Ti", + "p4AHs3LKO+ggrqWB+OvpH66tffiqe+iue+ikeRDsnS0NkJ1D4rynIxkzoheQkhZ9bBB/y/tJGaqG898J", + "VdGCXzEEYMTUhHlieEYVekGlBKwE1obeqphYq5YomtuB5gbeZ7Zc4CbmimYTdIGZtGGllt6yXAhQ1lLt", + "vWZK6MuVJPr27AcV7EWD5dVI3i2kZgX2pDCV2xxD8bV9HWOzw7F47UCJYQHR8d/zGs0ShFZeo/+RgtCx", + "cBW+9SzEOy1qmpaciyrEt+QWRbXm1lROFUc60ZEM4UK9ZoIKM9AZi/iMR25al2zpfI+DDXbKNgYD9uOE", + "1D3el25vO4wtiK5LYSDpp8U34iipbr8R0rg87KWRy8NdUQXpKYJJZOaJnNJkYtfnkgVsgs+xhFuU0uBS", + "WpOEjNm4B39lS7OQwv6dT3Nhcvv3VMl3mimwOY0FBg25tQZvhUJAtN52PM2kMtbPAfvcsUPc+eOSLT+A", + "W12ccmFraFuFJlqCmQLqGenxXSz3aqEHe5rCdvAnuTYyraL0erqzw5S5yXLjop80M/0QQu1YGEn+8Dik", + "H3b+KHv8gMZiRmOgk0oROyWUrdtGrScUZj/BogFzO8MFGPfgIrVuHnNFhcExlUCqZF7d0q0ikwfmCW6u", + "cEQFyWRms6AgUS0okFytDcQVoUlCDB4lXxcEd9zJlvk4mMh02ooRaUH9GseIC3L6feUwjQ4ebbdkWnAw", + "sNE6AN//c/7yZ2KNTySlWQamH/aeRqZE87V5lLeEJNbwhLC91Cy2iZFjYetafysffhIXgK87BZitnbhN", + "iCI9f3XeImNRca0hx86He/fQj4Ez/W0VWHcsnJuoBwzx6DTfaOdMacm0mMMQEmQ+ebXz4gdYP+shNhyL", + "H1mC7AJmWETF2yBiHMH+iKRc5HCh4pHU+dQBqiPEE3rMMqoSbgGj/BT6jhfBWiJqrXPxguwQZe5FlsFi", + "KpoUrP4bTSyjA7+khcP+wzmSKy2jy77zmdX0ipXjxspj4eNPdmy1Pi60YqmEstQVqyTK3YmoiFiSeEbx", + "ytvkqXCOVXEp4sPxxTWsgtJYvOMStGksFItgtEtEyoK1MlUw5Z3CmOrZVwto8pMq6LIrjHjRNi1BsoS5", + "49X8Eze1ZAzurHIxH4vKcQWBYGB5VMqVwssXBicVECr544NzbHZOiR5rrOEp2PtjXByqoft13Dv6Y1wg", + "II97R+Pe8d/Px73+uIBMxh8xmWFkGPB3qpYDBF/GH9m49+FDC9RyxSH18MGD/cNVeGP0qHiJjgjOIKNZ", + "pJhpO+kojAPrtcVKL00bdSiQD8S5wmVwoswzALBzLGJBNRn3eDzuFV4c8TaZuYXEHR0M0JXgOxjqd7ab", + "Po+/Gw6hKbtqR+SXP2wrR3CFZqmFqh73PvRJ5cOcm0U+Lb79GuajbQib57X7n2xZ6XYbBQjKEQytIuhb", + "ybjKnMBXnJSCR3WLplxQtVwX697OZOXMOjBXFuOPMTosI6E4l2WkICau8Dfn1zzufQivgHNWaE/Timel", + "8Gko7o7D0Wh7c7IGt74BV4UO9sBPrPppVYYUOaZhBx1S+F/LLPinVjt9Xyhq8Nov0fOsvs/b3O77OQ+9", + "38Hm/ywNvBQSljJ0JBtUs2XC3YiRNijRYjqYGxlEKxqEqmYsYBJtqAFQrPBqgM2K57s3ZhIn+dz1ybmv", + "c1OY64ssN1+UfR43qzzfa82J90xxo7u67WpmxPuh3y/Onhew5jlbHrvyoRfhHF+I3+ZUe8QWBoXpOY5p", + "cM6EIc/w16H7r9dFIR7xRSLnF0f2vQLpakjChYtPqgROgNzi1hIrWQi3op79Z5FgdcuKOP/+579wUFzM", + "//3Pf7m8KP/+57/wuO9YaNJtbG7BqDJTRs3FEYFA6QFNIKzFTQZzscPTckn2R84GiZ9gSIJFRZCHzI0e", + "C3gsmlyJShyXzXWqXYPOdAnz4SJn2kHgQUE+c4nYrK91QI/sz7Jdyjs90f0AlDDOoDIBuBU9DSAOKxfc", + "8ELl0AubcOyca0acptv4ivPwZv5i2HtjqXdgB3hNBoNLHDp3+MFNmmydnz/bHhJ8BlqqwGR7+Kgpm3Hv", + "m+FXnrSZJ1mOUmcouMqWN0U0o1OecG8CackUZo9gSqMFQPoV8Q5Fng7fxJEfKfAYcP12jtl9LDoWL893", + "0ORjWGRyxfqOEyiHzl2mEpUu7g57QP7FDXqrDlzZsZgxCm2Qk6eWCVQSWBSx9EXDAkGwUHvDTS1rad9H", + "ojvUfzh4IMkmWAn7n1PD3tFln1QkX5tZLKEGXuoaVWBjYUOf3RoMEOaLVIY5RH5mhzTwkQUuhlSxGRhr", + "cCI2UaPte6sSB98vg9J9dxagwA6LSCeOw/zm+ESV1j6BLb0897uxjRHwUcKRGiIqxmKOjoke+F6K2q4W", + "Aa4LquJBJFHbWAFChIiIhMXzNh77pNJW7xYlmVo/geP0Y5NcvzThYrE6ATjEFtx1vSfBU1emmyuBa/Gv", + "5EtgF+g6zgRWQcssv7Gr+9WxoINjQXjdvJNByNL/1KMX314Egu3ingIQPO2trrn9Ulmy+1A1ki0PC4dW", + "WqnI2ZMTQuNYMa23/9yKSJippdJS/oP7EVjxfbjCubFIZffC61vqBPKlsINXbtSE+nk1c9NX77edWuK6", + "1puuyGFXXnm3f3s0Or3ONVIKvSWtfb1JNjr/c40G4Cq1DFA0SlghvhTntEpFm7TKNqyguHLWiku2FPhs", + "uQN5d/pl13UumnfDHTDFpw2GeI+MsA79QKgoECK+JGp+U+yim9c69fPnRZqju5OC7loVHSLzL+m5GDeW", + "DbigBV5qvUCfM2Phlm7zne56CEwc9NzuVNuBLu2si2nZqsTiRuGEUBOz/u17Yot0e/ra9v5KL19cnutI", + "LG7Jv4ooHR675Vqte+DaLbjN920NWfKO/WkcgQUWGT443TT69UFGYqqXItr+6lLzySkaF7vyiFV+3iwu", + "NNn4vXxn3ZVcdyy8Rh18L7ku3rVckFkCwOLWCBDzGToRmqobJ45y7w5G+cq7KStqmHOZ/hJxCM7yxFo3", + "IimumKogx1av1J0/0Il+81PJM6+1t+ubVy8GTEQyLown7TKp+/KJH0yW/mvYAnd/6r7A+HruxYM2gfEj", + "9t8Gt5ACSvh/7f3gwIT/194PNMm4YP9r/zihhmmzfWvEMrqrm+6uHzBfMPHB+4XXF22FNe0YOq/Gxdcp", + "08NpX4cyazDYXtldBPZ9Mur79EJeEzu8k4R3Z3QPL6m7RlA68Zls7JZK5dH0GhDpf26h77xG0Heur6t1", + "zzWOAAW7LxC2SSqPAk1d5Bf3xO14k5grpvUmZURRqqM+wpf/S6kk7KSvpZQo1vWrXqKLXqK6XGtVE7bg", + "7SonbB/3ZH0viC202vjpK/zfHRh0HEVW4P9qFu4SAHAhtcFPnwcWzJ8pEocXR6F6n3U0mZacYu295s/U", + "ydM+7jDGN588LTEg7siA6sdx5xoB1+/dS2PH6ZTPc5nrKrxESk20YNpBrySsfjN8abqKUm5o1VZ8xlQ6", + "uss77c6VEV/p/pbUJM0NtczbekFseoz4Ul0fI648PEYsLL2Dp3F5/vo+B+x2S3SKB6bvSsY1/P4P/S7j", + "Cj2SICmPJuU7huDT5mgs/jc8jH4xjKa/fucD4vPRaO8Qf2fi6tfvfEy8OPWkwoRR3KXsPv75KbqezDG6", + "ALN6l6g7zXGQNNfGkp5HfPjTvdxK75vuTzdPhV+fbp2ebpXlWv90swVv+e1Wzy935483T2+hBbff/qLP", + "t7+4Tbn2tNT5bMYjzgRm6UOtpF5xorZPzK/m5JvpR20WVKpMxQOzJol0fkYWXGuDhF5k5/+kLo791mQ9", + "klBjWJqZIpWsSwWrF7mBFLc+dw9O0KeB5OV8Qte7b2riGwlH7tZyDK0L3A2+dIsUw3f91HUdf6Ghs9IG", + "y8f+cVmKNu2vy/sl3tt9U3a4au/+Vfklk5h9vq0uXQYvhEAuSmt/SnMbZ1zULGFsh+T16xc+pphizmyX", + "2dTIIve2s2ONRTWd6ZA8K/PE2gK+BXg+sNhhEEB9nyA0ZjROuGAYhMF0KPy3noT4Xo/Fp5eAwxmW79r2", + "3uVY2g29Rwn43ljBnciahbOBcZbi4mhWki8Xp8XLm3hqvih+5RhQgPGEZL0dmhs5cCgFOwtpoXTDaOJn", + "CY0QTByKWZxbBwxjga2rTSHai5JJwpQFS81y48UtgBJ3g+PCSOKrOMnsApqfYCr/C4tbahG6NKFi6dD8", + "xqLWmZP5ELwBgUlwhIpldsSNdOMwaA6qRiiFOAvVLglN3tGlHgsH92CrIwCsYpGF+k6SIflRItKOTbtf", + "Ybw25/U3eiwueJywiQPKuSBcE72QyjDBYgJArLrer4WOVTiJJxRWTpOULhFK04KJ2/WRGbNwlTU4Hgn/", + "piLmmD0Zei6mfDQWlOyNRiRlVGgHrqHpDC8c1wbBQdQG9C2h5GD02NVq7BtmefDLvwWnSSl2JSM6hUTZ", + "QMUwRG62cQNTl81cMW2kgu2bcaXtfhX6TZemtraxXPvk3HGf5KKED0Fdf8W6BttlciVwns48ybgqrkGH", + "mDRlEYX1FLLeD2JnyyjKVeiChK2upNX/MwqOlemd41KFwTkSVBlEEAMgEflxgWda4lHa/raFqkqi+mtc", + "NMFDIhWhpELXpUaDRTmyxi0Enb0oc0SLiSt/sf2tPztwfB0j8MdfzL+k+wmJSM5mtQO4+WqyB3hdUNwq", + "Cf9Vz+kTx/RqLC7mdC6kNjzyzNBD+VcfzV8fhJ0ehOtXNkjNM6ku2z2hf5DqsusLzHtsflkPseoMP0ND", + "BAwPnXTu3x6B2nD7WAGiufNHWpO+ilOKQhc3uvBVJokUc6aqWvk7NxtUX3VbZaYFZY3dBS4aPEIm7kcE", + "m9yu+JujiSFyrf5lndWQ2GCzS5+16dI+PUokuevxSjhVVcAHlzjD+h/0vTiEdOU3bMslgmhuV5CpAtDo", + "RqTWonMPSxqAah2LN9rmdLmwpqcLUvBgEGhtnibybsGjBbSDv2H7FtWVZtlFAaW/fUSe40GubJvtfMtm", + "ZwJa0zJhFo31Kk0vjlYz7L89PcVKWGZhM5pcHPncJqS4PzSUqsKwwiwSqg352YHLbhWPcdzRC9BhVua3", + "7QBay1QHYxECawWsU9sgn5GLCm7rRQuooOe3L+RcfzamojIvlZ2LkcQ9HZE2mYh7bU4ePAkbfnZHo1De", + "hI7wsXYYt4weuzKYF3Je5MSqkTLNsq7k64aJVHyVpmtomGyVHIRoE8vc/E2bmCmFlR11txE32aKR/Yeh", + "l0CoDnnUH+ztsWhZKjvD8FIBU+31e0zkae/oF/evqzTt9XtuPFDvncnSSraLawj5G+B4mw1+6Id2qIK5", + "+xcWz+/tSnT504qjEktmvSNR4nEvKIByxfOCW3oT6N/6DVXB/m1cd04H0P6MeGUL/OVNnF7ReGfiu3vR", + "NMSnIH3c2yn2WcqquvDPSZKvjLeuNxOyQFXGkT2+i5Eh9DKJEqlZzU725QA3On1hQ/Ru17f5NR7A8OLc", + "Z97s4gh07qqe+5qfgQpjk8uNHzPx071z35vVEXzJIBR6ZTbA/hpof5uccj57Qvp0W7Iy1S4U8pU2r6+s", + "7USY8NxaZRGuQmwzMRfpLjEdYLSQUlfIvoDmt/l6nQ6+oEzUUFllgQvEuABSvXDa/AsnYh45zSOh1U+u", + "jyFWd+Eb4Rr+U1njh4pypeD4ff+Cwsw0GlKmKc5mJKO5ZiBn5qARW0YJ8/kfGdjVI5qZXDHMaM1IygVP", + "87SacwF27IoiPtTFbnrRJ9PckAS0bKr46H2WIpmmTMRWThqLBaNXnClYlIQaJqLlQDOhObpGQdqHRNIY", + "NTVZjEk9bSZtxYACMYGFT3qKgs4FnPiJjQW7IJliSERWOyLY+5IawHaci29tNh1o9sIP9IIwTBfB9aJI", + "oh7RmIkomEbh/PNmY59epX/OTHOi9+RgdSNeep8eV1XVtR/O5+GM9cVCfnRg82uEXt3+qK4H0Xgy+nMe", + "aTtXP8d7stMVS7zuFH8eBrqC6D4bI939W+GkInFuu6ucSiTzv6oesWAoNUQICNC123hT+1qRnbVY5mvx", + "vJ0//J8nN9AufiacsN/6sG/LA1hO+nNguW5Vb8Rz70mt6nRJVZ3c/bFgN6j7E5+kqnC5L0XZWkPeK/h2", + "lTsZRfH1JcVXtt1k285v5KZs2+tmVzwjKoyciwG62oY5uFPjtrJqpzr4kwb1NGZXYZn3ziJLy8Wdw2h6", + "1pjRJahK/gq+1mvsR5FUyqKIUMO+LOjvitawGmWBurkywWjfB72+PT3dbuMSyqzlEcp8wRyiEtkE1dJ4", + "VYH78oopxWMPb/rk9Glpk1W5GJKXKTfESHLJWFYGBmFwJqB2FngqjWE3gVP6PSaMWmaSC7NxFGXR2xlM", + "+YN0sDKfoSjpckl8NYd3NoejZv/LY2fIZQgtJrD+ZWqo2ZjjmouZVKmVy+hU5tA68CBYJthP62wx4wnT", + "S21Yap07AQoCjhvmJXK55109u8t9dG2Gk2OjDjOmUq41l0KPhQu5yZiCvqE6tF/xUwsaBAwt+OuZZZKf", + "hw8kDMa6/VHTtmqIfIU5rXtHvR2aZTsxNbTFz84N7yOG9AM6NRK9TKcQQAlekZeabCX80j5PyJUmCfyx", + "vdYrcoL1PnVm/ZufLFjpEzGTwbyllmYLYv5LBcc5tuYNk58FW7und+ZHexE+Z9WD63nhTLayWL2RxypG", + "kwHm5fdYTCQ3POG/W7YLjXBteGSjyGixj29PCwY/HItTZhSPrL03Av9zBKnAl+5OpmS0Azh++1HGEdBv", + "n+HgkPm2f06xxydnb7BcylKplv2xoMI1/Pr4zFqaZzRizYEKZsCSTE52Xm7wWT/HZfoT+0/aCa4FpAhu", + "+Ffz5PVhY1rPkG45ojJb92yT2Z9WryOzz1Gp42TXrxqVL1OjAmRVzmarQIbzcG74EpxJFbGYZPIdUwM5", + "m4VVKlcyyVP4h/3jZBNanqHR4i0W/WyEfzucjd34CX4Rjv9uTjGzaabvxQZkF+xLdeGFhfNTQDmq5hwZ", + "vIiOzV+Ruj/9rVddx8/Q+utW1Kdw/2zO1l1fh24MHreluh5fyjG3lOZnYuR6Zdw7ytuVcd8nMrrUDuCn", + "qkUlilFE7YcfS5R1ZzFF2QHjjYkDxrLwa0z3x6Khj7U4UppQYphKuaDJDs7ZNoJ48V6pR68kx7D/CMN2", + "Bhq07ZlMEgSFR1BFmA2UmPkGKgZu7ZJcVstUbbNGAnKUTJnH0N8OvR7/Trn5Qao6IP7nwhdfV9YfgSYp", + "R/PDhhwA7T1+VE6AU/oePcfj3NnX/Yi2nsvyR6sZ6xPcm3Fvf6THvT4Z9/bScQ924AlFjTI15AFJucgN", + "gGs+teo+DOw+HBHNIili7aH8vUJzf6RbZu7IsiVm+BDr3aXY46gKl/KV6yTEHqAcgfoYw0S2qgfOncm4", + "j4cuJjI31vrhzpUrFTODGprtOzddV87IV/VCF07+d3d8azwKdxnYZWXrLWfPcr1g7Vq/FzZvV26msA5F", + "nm+9IP+QU92HwAdrHADQvhW+B7XPbAd3kb4CurpO6go39695KzrkrSjXKgwBav1N4Ur21GFxQNn7TCoD", + "vzvoBEdD+JJAPBLMxvnyyclYRMCKLGClYqlE7uRQ9u0tfPz3c/Lsyas+eYo5p8mP+XR7SF5CsA+2qp3J", + "aiysJGaZV0QB293OIA5dz3bsSD236TsPHVxLit/7dMYmPBkBQ5PfK+8z3+8tGI1RIvmj90LazgJY1q9e", + "wAGC/XM1i23vrRU+wIygloPjmWFqtdlTFzYmCiQWd0l7YEMnuGHH2KH2eH5ln1Y2sIAr+3u9AP7Kh6+p", + "RG4/V/ndGA2xX5ddEgIKv9Q0xXgQC+YYYoHV67pIxtEWNO142doHBnZ58vSTPCpu1VC+jnfVMhb8WU8X", + "zvSLtXVltX0CIi6S+Gw0NvtY6YUF2bbVSEQzGnGz7BOaJO6OcjdB4aAzKMTfqWL0EpT5QwBCcz37+GYw", + "F/e9rZjEXF/aFpw5eEjAQ0/n02JwBA+aNVzjmkOUsJEkokmUJ9QwwmYzFmFoMmYF0i3m5GIovVs8O2Un", + "QWSaipN//sVlTgzTBO5eSRZNituxW72jWJRQnrZD2jtBDf0v0dthCo1KAe4TiaU4GimpNXFNDVjC5xwy", + "e6CzBiTzADUXTdlYZAkVgimSaxskAEMfZIppnSvmG4C7y1FUn5RwlZmSxnlHJFIqPRaewt+eEm1YtobM", + "XtmWT3HOtyTb2sZdT/ekpG6MoV0V4ooQ2BBLKXbBgY5ANXQPnvl2QPctJX4pB/+14nNwv82UpJbJWtco", + "e6z9ctpDXwvgbs2iel6U6pZFtWi1EqRZCWBcCzc4KRHc4971nCADnV/yVkRK9+l6QdU/QaWOfdeDd8OD", + "cJ8+cpahhLB/xtyr55WYya4KrJLCvzR1UmXktaNaizvejDLWOdD4NgN/O8OJ3RuK2JcMHkZr0cRtD97P", + "jxBGdwt6cdep+75s2qqBf9Xepi0ICJtzNHwWFHg7yRnuGfTlBskZPisYAqCde4SDCR7U+4IVqNmepfqa", + "X+FW0QRskgVEp2tDE7Bczzmvrn0ovXVluj2TXIt/JQneLtB15He/7F9f/R2eDJXF2mSCBoJnaWaWrpK3", + "VZZOZ5r/zoYthuDCb/X2TME3cOn8dOTh6bTVofMeAdTu0ZBzLz6jLiEl1+DmVyb+87HlXxjkYvXM1S6W", + "Hbh1BlRFC37F2pXu9RPslihTbJDJDI0rsV0wtx7+LjNUDee/E9e8g6B1/8KMpphLgcUk5opFBrxFhJHI", + "EWwf32iipDTuu1TLdi8Re0R+UDI9drPZcB+6M+WUYaWfYbocxNTQwZXnNmtUaB/h3en9KYHhES7I8+/J", + "FntvlM2bQmbw8oGAd7+k7H3EWKyRJrerA94dhYcIDU/m0y6jXJMB5yX+QRMS5drI1O/9yVOyhRn15kzA", + "XoCoP0NJNlPyiscsro0RnPftqu62LOh19a4gVBTpEP3jwg7uXmSYLhfS/Hee1dlC4RIz5YLi4DbmmKmf", + "KYtpAP1RLrwDjtsjP4qvV5h7+W35xw5QImZ3dYtopLSI19tfr7kv+ZqrBkP5O61223n3nPXK627xUR3D", + "lm4jD0YRO3e3auu3n09ID5jkv8BoHqc6vyoepG1q88+LBEd3dz/ctbr87RccAgrK8qvGstkG1FWYYF6g", + "T3fMrlgisxSz7GPZXr+Xq6R31FsYkx3t7KDv90Jqc3Tw+OF+78OvH/7fAQBqC0NXbwQCAA==", } // GetSwagger returns the content of the embedded swagger specification file diff --git a/openapi.yaml b/openapi.yaml index 6747e73e0..0040558c9 100644 --- a/openapi.yaml +++ b/openapi.yaml @@ -4702,6 +4702,25 @@ paths: dockerfile: type: string description: Dockerfile content. Required if not included in the source tarball. + registry_credentials: + type: string + format: password + maxLength: 65536 + writeOnly: true + description: | + JSON object mapping exact registry hosts (no scheme or path) to + objects with required username/password strings and optional RFC3339 + expires_at. At most 16 registries; credentials + cannot override Hypeman's local output registry. No CR/LF in values. + Held in host memory for at most 30 minutes from submission, or the + earliest expires_at, including queue time. Passed to the ephemeral + builder's Docker auth config over vsock, never saved in host build + metadata/config, and removed at build completion/cancellation. + Requires an updated builder image. No automatic refresh or restart + recovery: resubmit interrupted/expired builds with fresh credentials. + Credentialed builds pull directly in BuildKit rather than populating + the shared base-image mirror. Omit or use {} for existing behavior. + example: '{"registry.example":{"username":"AWS","password":""}}' base_image_digest: type: string description: Optional pinned base image digest