diff --git a/ai-tooling/user/skills/nvcf-self-managed-cli/reference/flags.md b/ai-tooling/user/skills/nvcf-self-managed-cli/reference/flags.md index ca093b8da..65bcbb6b9 100644 --- a/ai-tooling/user/skills/nvcf-self-managed-cli/reference/flags.md +++ b/ai-tooling/user/skills/nvcf-self-managed-cli/reference/flags.md @@ -82,6 +82,8 @@ Extended duration units: `s` (seconds), `m` (minutes), `h` (hours), `d` (days), | `--helm-chart-service NAME` | Kubernetes Service name exposed by the chart. Required when `--helm-chart` is set. | - | | `--models NAME:VERSION:URI` | Standard model artifact; repeatable | - | | `--llm-model SPEC` | LLM model config; format `name=,uris=\|,routingMethod=,tokenRateLimit=`; repeatable. Token limits use `-` with `S`, `M`, `H`, `D`, or `W`, for example `1000-S`. Use input JSON for combined token limits because inline specs use commas as field separators. | - | +| `--llm-default-priority PRIORITY` | Function-level default request priority. Lower values have higher priority. | - | +| `--llm-per-account-priority NCA-ID:PRIORITY` | Per-account priority override; repeatable; supports up to 64 distinct NCA ID overrides. Requires a default priority. | - | In JSON and inline specs, LLM functions set `functionType: "LLM"` and model routing metadata under `models[].llmConfig`. `llmConfig.uris` declares the OpenAI-compatible upstream paths exposed by the model. Current supported paths are `/v1/chat/completions`, `/v1/responses`, and `/v1/embeddings`. `llmConfig.routingMethod` accepts `round_robin`, `power_of_two`, `groq_multiregion`, `pulsar`, or `random`. `llmConfig.tokenRateLimit` accepts one or more comma-separated positive integer token limits in `-` format. Supported units are `S` (seconds), `M` (minutes), `H` (hours), `D` (days), and `W` (weeks). Use distinct units when combining limits, for example `1000-S,5000-M,100000-H,500000-D,1000000-W` in input JSON. @@ -96,6 +98,8 @@ LLM invocation requests use `model: "/"`. The function |---|---|---| | `--tags TAG[,TAG]` | Replace function tags | - | | `--llm-model-update SPEC` | LLM model update; format `name=,routingMethod=,tokenRateLimit=`; repeatable. Routing methods match `--llm-model`. Token limit example: `1000-S`. Use input JSON for combined token limits. | - | +| `--llm-default-priority PRIORITY` | Replace the function-level priority configuration with this default and any supplied per-account overrides. | - | +| `--llm-per-account-priority NCA-ID:PRIORITY` | Per-account priority override; repeatable; supports up to 64 distinct NCA ID overrides. Requires a default priority. | - | In JSON, `function update` accepts `modelUpdates[]` entries with `modelName` and `llmConfig.routingMethod` and/or `llmConfig.tokenRateLimit`. `uris` are create-time model metadata and are not part of model updates. @@ -142,4 +146,3 @@ In JSON, `function update` accepts `modelUpdates[]` entries with `modelName` and | `--logs-telemetry-id UUID` | Logs telemetry endpoint ID | - | | `--metrics-telemetry-id UUID` | Metrics telemetry endpoint ID | - | | `--traces-telemetry-id UUID` | Traces telemetry endpoint ID | - | - diff --git a/docs/user/cli.md b/docs/user/cli.md index be4f33083..274595bbb 100644 --- a/docs/user/cli.md +++ b/docs/user/cli.md @@ -691,6 +691,29 @@ API key, which `api-key generate` mints automatically alongside the function key --inference-port 8000 \ --function-type LLM \ --llm-model "name=dummy-model,uris=/v1/chat/completions|/v1/responses|/v1/embeddings,routingMethod=round_robin,tokenRateLimit=1000-S" + +# Create an LLM function with request priority +./nvcf-cli function create \ + --name "my-priority-llm-function" \ + --image "nvcr.io/example/openai-compatible:latest" \ + --inference-url "/" \ + --inference-port 8000 \ + --function-type LLM \ + --llm-model "name=dummy-model,uris=/v1/chat/completions" \ + --llm-default-priority 7 \ + --llm-per-account-priority "nca-id:3" + +# Create an LLM function with request priority for multiple accounts +./nvcf-cli function create \ + --name "my-multi-account-priority-llm-function" \ + --image "nvcr.io/example/openai-compatible:latest" \ + --inference-url "/" \ + --inference-port 8000 \ + --function-type LLM \ + --llm-model "name=dummy-model,uris=/v1/chat/completions" \ + --llm-default-priority 7 \ + --llm-per-account-priority "nca-a:3" \ + --llm-per-account-priority "nca-b:5" ``` All `function create` flags: @@ -716,6 +739,8 @@ All `function create` flags: | `--tags` | Comma-separated tags | | `--models` | Model artifacts in `name:version:uri` format (repeatable) | | `--llm-model` | LLM model config in `name=MODEL,uris=URI\|URI,routingMethod=round_robin\|power_of_two\|groq_multiregion\|pulsar\|random,tokenRateLimit=LIMIT` format (repeatable). Token limits use `-` with `S`, `M`, `H`, `D`, or `W`, for example `1000-S`. Use JSON input for combined token limits because inline model specs use commas as field separators. | +| `--llm-default-priority` | Function-level default request priority. Lower values have higher priority, and `0` is highest. | +| `--llm-per-account-priority` | Per-account override in `:` format. Repeatable; supports up to 64 distinct NCA ID overrides. Requires a default priority. | | `--resources` | Resource artifacts in `name:version:uri` format (repeatable) | | `--helm-chart` | Helm chart specification | | `--helm-chart-service` | Helm chart service name | @@ -889,6 +914,13 @@ Example deployment JSON: --version-id \ --llm-model-update "name=dummy-model,routingMethod=round_robin,tokenRateLimit=1000-S" +# Replace the function-level request priority configuration +./nvcf-cli function update \ + --function-id \ + --version-id \ + --llm-default-priority 7 \ + --llm-per-account-priority "nca-id:3" + # Update from JSON file ./nvcf-cli function update \ --function-id \ diff --git a/src/clis/nvcf-cli/README.md b/src/clis/nvcf-cli/README.md index 1292e948d..9ffce9e98 100644 --- a/src/clis/nvcf-cli/README.md +++ b/src/clis/nvcf-cli/README.md @@ -619,6 +619,17 @@ export NVCF_TOKEN="nvapi-your-function-creation-token" --inference-port 8000 \ --function-type "LLM" \ --llm-model "name=dummy-model,uris=/v1/chat/completions|/v1/responses|/v1/embeddings,routingMethod=round_robin,tokenRateLimit=1000-S" + +# Create an LLM function with request priority +./nvcf-cli function create \ + --name "my-priority-llm-function" \ + --image "nvcr.io/example/openai-compatible:latest" \ + --inference-url "/" \ + --inference-port 8000 \ + --function-type "LLM" \ + --llm-model "name=dummy-model,uris=/v1/chat/completions" \ + --llm-default-priority 7 \ + --llm-per-account-priority "nca-id:3" ``` **Required flags:** @@ -746,6 +757,13 @@ export NVCF_API_KEY="nvapi-your-general-operations-token" # optional fallback --version-id "ver-12345678-1234-1234-1234-123456789abc" \ --llm-model-update "name=dummy-model,routingMethod=round_robin,tokenRateLimit=1000-S" +# Replace the function-level request priority configuration +./nvcf-cli function update \ + --function-id "func-12345678-1234-1234-1234-123456789abc" \ + --version-id "ver-12345678-1234-1234-1234-123456789abc" \ + --llm-default-priority 7 \ + --llm-per-account-priority "nca-id:3" + # Update function deployment specifications ./nvcf-cli function deploy update \ --function-id "func-12345678-1234-1234-1234-123456789abc" \ diff --git a/src/clis/nvcf-cli/USAGE-GUIDE.md b/src/clis/nvcf-cli/USAGE-GUIDE.md index 73a369559..92b707398 100644 --- a/src/clis/nvcf-cli/USAGE-GUIDE.md +++ b/src/clis/nvcf-cli/USAGE-GUIDE.md @@ -753,6 +753,17 @@ curl -X POST https://api.nvcf.nvidia.com/v2/nvcf/accounts/nvcf-default/registry- --inference-url / \ --function-type LLM \ --llm-model "name=dummy-model,uris=/v1/chat/completions|/v1/responses|/v1/embeddings,routingMethod=round_robin,tokenRateLimit=1000-S" + +# Create an LLM function with request priority +./nvcf-cli function create \ + --name my-priority-llm-function \ + --image nvcr.io/example/openai-compatible:latest \ + --inference-port 8000 \ + --inference-url / \ + --function-type LLM \ + --llm-model "name=dummy-model,uris=/v1/chat/completions" \ + --llm-default-priority 7 \ + --llm-per-account-priority "nca-id:3" ``` **Secrets Format:** @@ -1036,6 +1047,13 @@ When `--json` is set: --function-id "550e8400-e29b-41d4-a716-446655440000" \ --version-id "01234567-89ab-cdef-0123-456789abcdef" \ --llm-model-update "name=dummy-model,routingMethod=round_robin,tokenRateLimit=1000-S" + +# Replace the function-level request priority configuration +./nvcf-cli function update \ + --function-id "550e8400-e29b-41d4-a716-446655440000" \ + --version-id "01234567-89ab-cdef-0123-456789abcdef" \ + --llm-default-priority 7 \ + --llm-per-account-priority "nca-id:3" ``` ### Delete Function or Deployment @@ -1373,4 +1391,3 @@ nvcf-cli task delete # DELETE - permanent ``` `task delete` clears the saved task from state when it matches. - diff --git a/src/clis/nvcf-cli/cmd/BUILD.bazel b/src/clis/nvcf-cli/cmd/BUILD.bazel index a3ca47315..932b67902 100644 --- a/src/clis/nvcf-cli/cmd/BUILD.bazel +++ b/src/clis/nvcf-cli/cmd/BUILD.bazel @@ -114,6 +114,7 @@ go_test( "deploy_test.go", "exit_code_error_test.go", "function_llm_model_test.go", + "function_request_priority_test.go", "main_test.go", "registry_test.go", "root_test.go", diff --git a/src/clis/nvcf-cli/cmd/function.go b/src/clis/nvcf-cli/cmd/function.go index 8eff0fa33..3e367f93f 100644 --- a/src/clis/nvcf-cli/cmd/function.go +++ b/src/clis/nvcf-cli/cmd/function.go @@ -21,8 +21,10 @@ import ( "context" "encoding/json" "fmt" + "io" "os" "path/filepath" + "sort" "strconv" "strings" "time" @@ -40,11 +42,13 @@ import ( ) const ( - errCreateNVCFClientFmt = "failed to create NVCF client: %w" - errLoadConfigFmt = "failed to load configuration: %w" - errParseInputFileFmt = "failed to parse JSON file '%s': %w" - errReadInputFileFmt = "failed to read input file '%s': %w" - inputFileFlag = "input-file" + errCreateNVCFClientFmt = "failed to create NVCF client: %w" + errLoadConfigFmt = "failed to load configuration: %w" + errParseInputFileFmt = "failed to parse JSON file '%s': %w" + errReadInputFileFmt = "failed to read input file '%s': %w" + inputFileFlag = "input-file" + llmDefaultPriorityFlag = "llm-default-priority" + llmPerAccountPriorityFlag = "llm-per-account-priority" ) // ============================================================================ @@ -254,13 +258,16 @@ var listVersionsCmd = &cobra.Command{ // updateCmd represents the update command var updateCmd = &cobra.Command{ Use: "update", - Short: "Update function tags and LLM model config", + Short: "Update function tags and LLM configuration", SilenceUsage: true, Long: `Updates function tags and LLM model configuration. This allows you to modify mutable fields of an existing function version without affecting the function's code or deployment configuration. LLM model -updates support routingMethod and tokenRateLimit. +updates support routingMethod and tokenRateLimit. Function-level LLM request +priority can be configured with command-line flags. To clear it, use an input +file containing an empty llmInvocationConfig object. A priority update replaces +the existing function-level priority configuration. Specify every value to retain. For updating deployments, use: nvcf-cli function deploy update @@ -332,6 +339,7 @@ type CreateConfig struct { APIBodyFormat string `json:"apiBodyFormat,omitempty"` ContainerArgs string `json:"containerArgs,omitempty"` ContainerEnvironment []ContainerEnvironmentEntry `json:"containerEnvironment,omitempty"` + LLMInvocationConfig *LLMInvocationConfigInput `json:"llmInvocationConfig,omitempty"` // Helm configuration HelmChart string `json:"helmChart,omitempty"` @@ -370,6 +378,17 @@ type LLMConfigInput struct { RoutingMethod *string `json:"routingMethod,omitempty"` } +// LLMInvocationConfigInput represents function-level LLM invocation configuration. +type LLMInvocationConfigInput struct { + Priority *PriorityInput `json:"priority,omitempty"` +} + +// PriorityInput represents default and per-account request priorities. +type PriorityInput struct { + DefaultPriority *uint32 `json:"defaultPriority,omitempty"` + PerAccountPriority map[string]uint32 `json:"perAccountPriority,omitempty"` +} + // ContainerEnvironmentEntry represents an environment variable in CLI configuration type ContainerEnvironmentEntry struct { Key string `json:"key"` // Environment variable key @@ -417,10 +436,11 @@ type InvokeConfig struct { // UpdateConfig represents the JSON configuration for updating a function type UpdateConfig struct { - FunctionID string `json:"functionId"` - VersionID string `json:"versionId"` - Tags []string `json:"tags,omitempty"` - ModelUpdates []ModelUpdateConfig `json:"modelUpdates,omitempty"` + FunctionID string `json:"functionId"` + VersionID string `json:"versionId"` + Tags []string `json:"tags,omitempty"` + ModelUpdates []ModelUpdateConfig `json:"modelUpdates,omitempty"` + LLMInvocationConfig *LLMInvocationConfigInput `json:"llmInvocationConfig,omitempty"` } // ModelUpdateConfig represents LLM model update configuration. @@ -569,6 +589,8 @@ func init() { createCmd.Flags().StringSliceVar(&createFlags.secrets, "secrets", []string{}, "Secrets in name=value format (e.g., API_KEY=secret123,DB_PASSWORD=pass456)") createCmd.Flags().StringSliceVar(&createFlags.models, "models", []string{}, "Model artifacts (format: name:version:uri)") createCmd.Flags().StringArrayVar(&createFlags.llmModels, "llm-model", []string{}, "LLM model config (format: name=,uris=|,routingMethod=,tokenRateLimit=)") + createCmd.Flags().Uint32(llmDefaultPriorityFlag, 0, "Function-level default request priority (lower is higher; range: 0-4294967295)") + createCmd.Flags().StringArray(llmPerAccountPriorityFlag, []string{}, "Per-account request priority override (format: :; requires default priority; lower is higher; range: 0-4294967295; repeatable; supports up to 64 distinct NCA ID overrides)") createCmd.Flags().StringSliceVar(&createFlags.resources, "resources", []string{}, "Resource artifacts (format: name:version:uri)") createCmd.Flags().StringVar(&createFlags.rateLimit, "rate-limit", "", "Rate limit pattern (e.g., '100-S', '50-M', '10-H', '5-D')") createCmd.Flags().StringSliceVar(&createFlags.rateLimitExempted, "rate-limit-exempted", []string{}, "NCA IDs exempted from rate limiting") @@ -610,6 +632,8 @@ func init() { updateCmd.Flags().StringVar(&updateFlags.versionID, "version-id", "", "Version ID (required)") updateCmd.Flags().StringSliceVar(&updateFlags.tags, "tags", []string{}, "Function tags (comma-separated)") updateCmd.Flags().StringArrayVar(&updateFlags.llmModelUpdates, "llm-model-update", []string{}, "LLM model update (format: name=,routingMethod=,tokenRateLimit=)") + updateCmd.Flags().Uint32(llmDefaultPriorityFlag, 0, "Function-level default request priority (lower is higher; range: 0-4294967295; replaces existing priority config)") + updateCmd.Flags().StringArray(llmPerAccountPriorityFlag, []string{}, "Per-account request priority override (format: :; requires default priority; lower is higher; range: 0-4294967295; repeatable; supports up to 64 distinct NCA ID overrides)") } // ============================================================================ @@ -924,8 +948,12 @@ func modelUpdateConfigToClient(update ModelUpdateConfig) (client.ModelUpdateDto, } func updateConfigToClientRequest(config *UpdateConfig) (*client.UpdateFunctionMetadataRequest, error) { + if err := validateLLMInvocationConfig(config.LLMInvocationConfig); err != nil { + return nil, err + } req := &client.UpdateFunctionMetadataRequest{ - Tags: config.Tags, + Tags: config.Tags, + LLMInvocationConfig: llmInvocationConfigToClient(config.LLMInvocationConfig), } for _, update := range config.ModelUpdates { clientUpdate, err := modelUpdateConfigToClient(update) @@ -1127,12 +1155,63 @@ func applyCreateFlagOverrides(cmd *cobra.Command, config *CreateConfig) error { applyCreateHelmFlagOverrides(cmd, config) applyCreateRateLimitFlagOverrides(cmd, config) applyCreateTelemetryFlagOverrides(cmd, config) + mergedConfig, err := mergeRequestPriorityFlagOverrides(cmd, config.LLMInvocationConfig) + if err != nil { + return err + } + config.LLMInvocationConfig = mergedConfig if err := applyCreateContainerEnvFlag(cmd, config); err != nil { return err } return applyCreateArtifactFlagOverrides(cmd, config) } +func mergeRequestPriorityFlagOverrides( + cmd *cobra.Command, + current *LLMInvocationConfigInput, +) (*LLMInvocationConfigInput, error) { + flags := cmd.Flags() + defaultChanged := flags.Changed(llmDefaultPriorityFlag) + perAccountChanged := flags.Changed(llmPerAccountPriorityFlag) + if !defaultChanged && !perAccountChanged { + return current, nil + } + + mergedConfig := &LLMInvocationConfigInput{} + if current != nil { + *mergedConfig = *current + } + + mergedPriority := &PriorityInput{} + if mergedConfig.Priority != nil { + *mergedPriority = *mergedConfig.Priority + } + mergedConfig.Priority = mergedPriority + + if defaultChanged { + value, err := flags.GetUint32(llmDefaultPriorityFlag) + if err != nil { + return nil, err + } + mergedPriority.DefaultPriority = &value + } + if perAccountChanged { + values, err := flags.GetStringArray(llmPerAccountPriorityFlag) + if err != nil { + return nil, err + } + overrides, err := parsePerAccountPriorities(values) + if err != nil { + return nil, err + } + mergedPriority.PerAccountPriority = overrides + } + + if err := validateLLMInvocationConfig(mergedConfig); err != nil { + return nil, err + } + return mergedConfig, nil +} func applyCreateRequiredFlagOverrides(cmd *cobra.Command, config *CreateConfig) { if cmd.Flags().Changed("name") { @@ -1216,6 +1295,81 @@ func parseContainerEnvironment(values []string) ([]ContainerEnvironmentEntry, er return containerEnv, nil } +func parsePerAccountPriorities(values []string) (map[string]uint32, error) { + if len(values) > 64 { + return nil, fmt.Errorf("at most 64 distinct NCA ID priority overrides are allowed") + } + + overrides := make(map[string]uint32, len(values)) + for _, value := range values { + ncaID, priority, err := parsePerAccountPriority(value) + if err != nil { + return nil, fmt.Errorf("invalid per-account priority %q: %w", value, err) + } + if _, exists := overrides[ncaID]; exists { + return nil, fmt.Errorf("duplicate per-account priority for NCA ID %q", ncaID) + } + overrides[ncaID] = priority + } + return overrides, nil +} + +func parsePerAccountPriority(value string) (string, uint32, error) { + ncaID, priorityText, found := strings.Cut(value, ":") + ncaID = strings.TrimSpace(ncaID) + priorityText = strings.TrimSpace(priorityText) + if !found || ncaID == "" || priorityText == "" { + return "", 0, fmt.Errorf("expected : with a non-empty NCA ID") + } + + priority, err := strconv.ParseUint(priorityText, 10, 32) + if err != nil { + return "", 0, fmt.Errorf("priority must be an integer from 0 to %d", uint64(^uint32(0))) + } + return ncaID, uint32(priority), nil +} + +func validateLLMInvocationConfig(config *LLMInvocationConfigInput) error { + if config == nil || config.Priority == nil { + return nil + } + + priority := config.Priority + if len(priority.PerAccountPriority) > 64 { + return fmt.Errorf("at most 64 distinct NCA ID priority overrides are allowed") + } + if len(priority.PerAccountPriority) > 0 && priority.DefaultPriority == nil { + return fmt.Errorf("defaultPriority is required when perAccountPriority is configured") + } + for ncaID := range priority.PerAccountPriority { + if strings.TrimSpace(ncaID) == "" { + return fmt.Errorf("perAccountPriority NCA ID must not be empty") + } + } + return nil +} + +func llmInvocationConfigToClient(config *LLMInvocationConfigInput) *client.LLMInvocationConfigDto { + if config == nil { + return nil + } + + result := &client.LLMInvocationConfigDto{} + if config.Priority == nil { + return result + } + + priority := &client.PriorityDto{DefaultPriority: config.Priority.DefaultPriority} + if config.Priority.PerAccountPriority != nil { + priority.PerAccountPriority = make(map[string]uint32, len(config.Priority.PerAccountPriority)) + for ncaID, value := range config.Priority.PerAccountPriority { + priority.PerAccountPriority[ncaID] = value + } + } + result.Priority = priority + return result +} + func applyCreateHelmFlagOverrides(cmd *cobra.Command, config *CreateConfig) { if cmd.Flags().Changed("helm-chart") { config.HelmChart = createFlags.helmChart @@ -1436,6 +1590,12 @@ func loadUpdateConfig(cmd *cobra.Command) (*UpdateConfig, error) { config.ModelUpdates = append(config.ModelUpdates, updates...) } + mergedConfig, err := mergeRequestPriorityFlagOverrides(cmd, config.LLMInvocationConfig) + if err != nil { + return nil, err + } + config.LLMInvocationConfig = mergedConfig + return config, nil } @@ -1446,10 +1606,10 @@ func validateUpdateConfig(config *UpdateConfig) error { if config.VersionID == "" { return fmt.Errorf("version ID is required (use --version-id or specify in JSON file)") } - if len(config.Tags) == 0 && len(config.ModelUpdates) == 0 { - return fmt.Errorf("at least one update is required (use --tags, --llm-model-update, or specify modelUpdates in JSON file)") + if len(config.Tags) == 0 && len(config.ModelUpdates) == 0 && config.LLMInvocationConfig == nil { + return fmt.Errorf("at least one update is required (use --tags, --llm-model-update, an LLM priority flag, or specify an update in JSON file)") } - return nil + return validateLLMInvocationConfig(config.LLMInvocationConfig) } // ============================================================================ @@ -1512,10 +1672,13 @@ func validateCreateConfig(config *CreateConfig) error { if config.InferencePort == 0 { return fmt.Errorf("inference port is required (use --inference-port or specify in JSON file)") } - return nil + return validateLLMInvocationConfig(config.LLMInvocationConfig) } func buildCreateFunctionRequest(config *CreateConfig) (*client.CreateFunctionRequest, *client.HealthDto, error) { + if err := validateLLMInvocationConfig(config.LLMInvocationConfig); err != nil { + return nil, nil, err + } secrets, err := clientSecretsFromConfig(config) if err != nil { return nil, nil, err @@ -1543,6 +1706,7 @@ func buildCreateFunctionRequest(config *CreateConfig) (*client.CreateFunctionReq APIBodyFormat: createAPIBodyFormat(config.APIBodyFormat), ContainerArgs: config.ContainerArgs, ContainerEnvironment: containerEnvironmentToClient(config.ContainerEnvironment), + LLMInvocationConfig: llmInvocationConfigToClient(config.LLMInvocationConfig), HelmChart: config.HelmChart, HelmChartServiceName: config.HelmChartServiceName, Secrets: secrets, @@ -2002,6 +2166,8 @@ func runGetFunction(cmd *cobra.Command, args []string) error { } } + printRequestPriority(os.Stdout, result.LLMInvocationConfig) + if len(result.Secrets) > 0 { fmt.Printf("\nSecrets:\n") fmt.Printf("========\n") @@ -2033,6 +2199,31 @@ func runGetFunction(cmd *cobra.Command, args []string) error { return nil } +func printRequestPriority(w io.Writer, config *client.LLMInvocationConfigDto) { + if config == nil || config.Priority == nil { + return + } + + fmt.Fprintln(w, "\nRequest Priority:") + fmt.Fprintln(w, "=================") + if config.Priority.DefaultPriority != nil { + fmt.Fprintf(w, "Default Priority: %d\n", *config.Priority.DefaultPriority) + } + if len(config.Priority.PerAccountPriority) == 0 { + return + } + + ncaIDs := make([]string, 0, len(config.Priority.PerAccountPriority)) + for ncaID := range config.Priority.PerAccountPriority { + ncaIDs = append(ncaIDs, ncaID) + } + sort.Strings(ncaIDs) + fmt.Fprintln(w, "Per-Account Priorities:") + for _, ncaID := range ncaIDs { + fmt.Fprintf(w, " %s: %d\n", ncaID, config.Priority.PerAccountPriority[ncaID]) + } +} + func runInvoke(cmd *cobra.Command, args []string) error { // Load state to get saved function context if needed if err := LoadStateForCurrentCommand(); err != nil { diff --git a/src/clis/nvcf-cli/cmd/function_request_priority_test.go b/src/clis/nvcf-cli/cmd/function_request_priority_test.go new file mode 100644 index 000000000..097c7549e --- /dev/null +++ b/src/clis/nvcf-cli/cmd/function_request_priority_test.go @@ -0,0 +1,457 @@ +/* +SPDX-FileCopyrightText: Copyright (c) NVIDIA CORPORATION & AFFILIATES. All rights reserved. +SPDX-License-Identifier: Apache-2.0 + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package cmd + +import ( + "bytes" + "encoding/json" + "fmt" + "maps" + "strings" + "testing" + + "nvcf-cli/internal/client" + + "github.com/spf13/cobra" +) + +func TestCreateConfigParsesLLMInvocationConfigFromJSON(t *testing.T) { + t.Parallel() + + var config CreateConfig + err := json.Unmarshal([]byte(`{ + "llmInvocationConfig": { + "priority": { + "defaultPriority": 0, + "perAccountPriority": { + "nca-1": 3 + } + } + } + }`), &config) + if err != nil { + t.Fatalf("unmarshal create config: %v", err) + } + + assertPriorityConfig(t, config.LLMInvocationConfig, 0, map[string]uint32{"nca-1": 3}) +} + +func TestCreateConfigRejectsInvalidRequestPrioritiesFromJSON(t *testing.T) { + t.Parallel() + + for _, test := range []struct { + name string + payload string + }{ + { + name: "floating_point_default", + payload: `{"llmInvocationConfig":{"priority":{"defaultPriority":1.5}}}`, + }, + { + name: "negative_default", + payload: `{"llmInvocationConfig":{"priority":{"defaultPriority":-1}}}`, + }, + { + name: "default_above_uint32", + payload: `{"llmInvocationConfig":{"priority":{"defaultPriority":4294967296}}}`, + }, + { + name: "floating_point_override", + payload: `{"llmInvocationConfig":{"priority":{"defaultPriority":7,"perAccountPriority":{"nca-1":1.5}}}}`, + }, + { + name: "override_above_uint32", + payload: `{"llmInvocationConfig":{"priority":{"defaultPriority":7,"perAccountPriority":{"nca-1":4294967296}}}}`, + }, + } { + test := test + t.Run(test.name, func(t *testing.T) { + t.Parallel() + + var config CreateConfig + if err := json.Unmarshal([]byte(test.payload), &config); err == nil { + t.Fatalf("json.Unmarshal(%s) succeeded, want error", test.payload) + } + }) + } +} + +func TestUpdateConfigPreservesEmptyLLMInvocationConfigFromJSON(t *testing.T) { + t.Parallel() + + var config UpdateConfig + if err := json.Unmarshal([]byte(`{"llmInvocationConfig": {}}`), &config); err != nil { + t.Fatalf("unmarshal update config: %v", err) + } + if config.LLMInvocationConfig == nil { + t.Fatal("llmInvocationConfig is nil, want non-nil empty config for clear") + } + if config.LLMInvocationConfig.Priority != nil { + t.Fatalf("priority = %#v, want nil", config.LLMInvocationConfig.Priority) + } +} + +func TestLoadCreateConfigAppliesRequestPriorityFlags(t *testing.T) { + originalFlags := createFlags + t.Cleanup(func() { createFlags = originalFlags }) + + cmd := newPriorityFlagTestCommand() + if err := cmd.Flags().Set(llmDefaultPriorityFlag, "0"); err != nil { + t.Fatalf("set default priority: %v", err) + } + if err := cmd.Flags().Set(llmPerAccountPriorityFlag, "nca-1:3"); err != nil { + t.Fatalf("set per-account priority: %v", err) + } + + config, err := loadCreateConfig(cmd) + if err != nil { + t.Fatalf("load create config: %v", err) + } + assertPriorityConfig(t, config.LLMInvocationConfig, 0, map[string]uint32{"nca-1": 3}) +} + +func TestCreateRequestIncludesRepeatedPerAccountPriorityFlags(t *testing.T) { + originalFlags := createFlags + t.Cleanup(func() { createFlags = originalFlags }) + + cmd := newPriorityFlagTestCommand() + if err := cmd.Flags().Set(llmDefaultPriorityFlag, "7"); err != nil { + t.Fatalf("set default priority: %v", err) + } + if err := cmd.Flags().Set(llmPerAccountPriorityFlag, "nca-a:3"); err != nil { + t.Fatalf("set first per-account priority: %v", err) + } + if err := cmd.Flags().Set(llmPerAccountPriorityFlag, "nca-b:5"); err != nil { + t.Fatalf("set second per-account priority: %v", err) + } + + config, err := loadCreateConfig(cmd) + if err != nil { + t.Fatalf("load create config: %v", err) + } + request, _, err := buildCreateFunctionRequest(config) + if err != nil { + t.Fatalf("build create request: %v", err) + } + payload, err := json.Marshal(request) + if err != nil { + t.Fatalf("marshal create request: %v", err) + } + + var decoded struct { + LLMInvocationConfig struct { + Priority struct { + DefaultPriority uint32 `json:"defaultPriority"` + PerAccountPriority map[string]uint32 `json:"perAccountPriority"` + } `json:"priority"` + } `json:"llmInvocationConfig"` + } + if err := json.Unmarshal(payload, &decoded); err != nil { + t.Fatalf("unmarshal create request: %v", err) + } + if got := decoded.LLMInvocationConfig.Priority.DefaultPriority; got != 7 { + t.Fatalf("defaultPriority = %d, want 7", got) + } + wantOverrides := map[string]uint32{"nca-a": 3, "nca-b": 5} + if got := decoded.LLMInvocationConfig.Priority.PerAccountPriority; !maps.Equal(got, wantOverrides) { + t.Fatalf("perAccountPriority = %#v, want %#v", got, wantOverrides) + } +} + +func TestLoadUpdateConfigAppliesRequestPriorityFlags(t *testing.T) { + originalFlags := updateFlags + t.Cleanup(func() { updateFlags = originalFlags }) + + cmd := newPriorityFlagTestCommand() + if err := cmd.Flags().Set(llmDefaultPriorityFlag, "7"); err != nil { + t.Fatalf("set default priority: %v", err) + } + if err := cmd.Flags().Set(llmPerAccountPriorityFlag, "nca-1:3"); err != nil { + t.Fatalf("set per-account priority: %v", err) + } + + config, err := loadUpdateConfig(cmd) + if err != nil { + t.Fatalf("load update config: %v", err) + } + assertPriorityConfig(t, config.LLMInvocationConfig, 7, map[string]uint32{"nca-1": 3}) +} + +func TestRequestPriorityFlagsPreserveInputFileFieldsWhenOmitted(t *testing.T) { + t.Parallel() + + current := priorityConfig(7, map[string]uint32{"nca-1": 3}) + mergedConfig, err := mergeRequestPriorityFlagOverrides(&cobra.Command{}, current) + if err != nil { + t.Fatalf("merge priority flags: %v", err) + } + assertPriorityConfig(t, mergedConfig, 7, map[string]uint32{"nca-1": 3}) +} + +func TestMergeRequestPriorityFlagOverridesPreservesUnchangedFields(t *testing.T) { + t.Parallel() + + for _, test := range []struct { + name string + flag string + value string + wantDefault uint32 + wantOverrides map[string]uint32 + }{ + { + name: "default priority override preserves per-account priorities", + flag: llmDefaultPriorityFlag, + value: "0", + wantDefault: 0, + wantOverrides: map[string]uint32{"nca-1": 3}, + }, + { + name: "per-account override preserves default priority", + flag: llmPerAccountPriorityFlag, + value: "nca-2:5", + wantDefault: 7, + wantOverrides: map[string]uint32{"nca-2": 5}, + }, + } { + test := test + t.Run(test.name, func(t *testing.T) { + t.Parallel() + + cmd := newPriorityFlagTestCommand() + if err := cmd.Flags().Set(test.flag, test.value); err != nil { + t.Fatalf("set %s: %v", test.flag, err) + } + + current := priorityConfig(7, map[string]uint32{"nca-1": 3}) + mergedConfig, err := mergeRequestPriorityFlagOverrides(cmd, current) + if err != nil { + t.Fatalf("merge priority flags: %v", err) + } + + assertPriorityConfig(t, mergedConfig, test.wantDefault, test.wantOverrides) + assertPriorityConfig(t, current, 7, map[string]uint32{"nca-1": 3}) + }) + } +} + +func TestMergeRequestPriorityFlagOverridesDoesNotMutateCurrentConfigOnError(t *testing.T) { + t.Parallel() + + cmd := newPriorityFlagTestCommand() + if err := cmd.Flags().Set(llmDefaultPriorityFlag, "0"); err != nil { + t.Fatalf("set default priority: %v", err) + } + if err := cmd.Flags().Set(llmPerAccountPriorityFlag, "nca-2:not-a-number"); err != nil { + t.Fatalf("set per-account priority: %v", err) + } + + current := priorityConfig(7, map[string]uint32{"nca-1": 3}) + if _, err := mergeRequestPriorityFlagOverrides(cmd, current); err == nil { + t.Fatal("merge priority flags succeeded, want error") + } + assertPriorityConfig(t, current, 7, map[string]uint32{"nca-1": 3}) +} + +func TestValidateLLMInvocationConfigRejectsPerAccountWithoutDefault(t *testing.T) { + t.Parallel() + + err := validateLLMInvocationConfig(&LLMInvocationConfigInput{ + Priority: &PriorityInput{PerAccountPriority: map[string]uint32{"nca-1": 3}}, + }) + if err == nil || !strings.Contains(err.Error(), "defaultPriority is required") { + t.Fatalf("error = %v, want defaultPriority required", err) + } +} + +func TestValidateLLMInvocationConfigRejectsEmptyNCAID(t *testing.T) { + t.Parallel() + + config := priorityConfig(7, map[string]uint32{"": 3}) + err := validateLLMInvocationConfig(config) + if err == nil || !strings.Contains(err.Error(), "NCA ID must not be empty") { + t.Fatalf("error = %v, want empty NCA ID error", err) + } +} + +func TestValidateLLMInvocationConfigRejectsMoreThan64Overrides(t *testing.T) { + t.Parallel() + + overrides := make(map[string]uint32, 65) + for i := 0; i < 65; i++ { + overrides[fmt.Sprintf("nca-%d", i)] = uint32(i) + } + err := validateLLMInvocationConfig(priorityConfig(7, overrides)) + if err == nil || !strings.Contains(err.Error(), "at most 64") { + t.Fatalf("error = %v, want maximum override count error", err) + } +} + +func TestParsePerAccountPriorityRejectsInvalidValues(t *testing.T) { + t.Parallel() + + for _, value := range []string{ + ":1", + "nca-1:-1", + "nca-1:1.5", + "nca-1:4294967296", + "nca-1:not-a-number", + } { + value := value + t.Run(value, func(t *testing.T) { + t.Parallel() + if _, _, err := parsePerAccountPriority(value); err == nil { + t.Fatalf("parsePerAccountPriority(%q) succeeded, want error", value) + } + }) + } +} + +func TestDefaultPriorityFlagRejectsInvalidValues(t *testing.T) { + t.Parallel() + + for _, value := range []string{"-1", "1.5", "4294967296"} { + value := value + t.Run(value, func(t *testing.T) { + t.Parallel() + + cmd := newPriorityFlagTestCommand() + if err := cmd.Flags().Set(llmDefaultPriorityFlag, value); err == nil { + t.Fatalf("setting default priority to %q succeeded, want error", value) + } + }) + } +} + +func TestParsePerAccountPrioritiesRejectsDuplicateNCAID(t *testing.T) { + t.Parallel() + + _, err := parsePerAccountPriorities([]string{"nca-1:3", "nca-1:7"}) + if err == nil || !strings.Contains(err.Error(), "duplicate") { + t.Fatalf("error = %v, want duplicate NCA ID error", err) + } +} + +func TestValidateUpdateConfigAcceptsEmptyLLMInvocationConfig(t *testing.T) { + t.Parallel() + + err := validateUpdateConfig(&UpdateConfig{ + FunctionID: "func-123", + VersionID: "ver-456", + LLMInvocationConfig: &LLMInvocationConfigInput{}, + }) + if err != nil { + t.Fatalf("validate clear request: %v", err) + } +} + +func TestBuildCreateFunctionRequestIncludesLLMInvocationConfig(t *testing.T) { + t.Parallel() + + request, _, err := buildCreateFunctionRequest(&CreateConfig{ + Name: "priority-test", + InferenceURL: "/v1/chat/completions", + InferencePort: 8000, + FunctionType: "LLM", + LLMInvocationConfig: priorityConfig(7, map[string]uint32{"nca-1": 3}), + }) + if err != nil { + t.Fatalf("build create request: %v", err) + } + if request.LLMInvocationConfig == nil || request.LLMInvocationConfig.Priority == nil { + t.Fatalf("request llmInvocationConfig = %#v", request.LLMInvocationConfig) + } + if got := request.LLMInvocationConfig.Priority.DefaultPriority; got == nil || *got != 7 { + t.Fatalf("defaultPriority = %v, want 7", got) + } +} + +func TestUpdateConfigToClientRequestPreservesEmptyLLMInvocationConfig(t *testing.T) { + t.Parallel() + + request, err := updateConfigToClientRequest(&UpdateConfig{ + LLMInvocationConfig: &LLMInvocationConfigInput{}, + }) + if err != nil { + t.Fatalf("build update request: %v", err) + } + if request.LLMInvocationConfig == nil { + t.Fatal("request llmInvocationConfig is nil, want empty config") + } + if request.LLMInvocationConfig.Priority != nil { + t.Fatalf("request priority = %#v, want nil", request.LLMInvocationConfig.Priority) + } +} + +func TestPrintRequestPriority(t *testing.T) { + t.Parallel() + + defaultPriority := uint32(7) + var output bytes.Buffer + printRequestPriority(&output, &client.LLMInvocationConfigDto{ + Priority: &client.PriorityDto{ + DefaultPriority: &defaultPriority, + PerAccountPriority: map[string]uint32{ + "nca-z": 9, + "nca-a": 3, + }, + }, + }) + + want := "\nRequest Priority:\n=================\n" + + "Default Priority: 7\n" + + "Per-Account Priorities:\n" + + " nca-a: 3\n" + + " nca-z: 9\n" + if output.String() != want { + t.Fatalf("output = %q, want %q", output.String(), want) + } +} + +func newPriorityFlagTestCommand() *cobra.Command { + cmd := &cobra.Command{} + cmd.Flags().Uint32(llmDefaultPriorityFlag, 0, "") + cmd.Flags().StringArray(llmPerAccountPriorityFlag, nil, "") + return cmd +} + +func priorityConfig(defaultPriority uint32, overrides map[string]uint32) *LLMInvocationConfigInput { + return &LLMInvocationConfigInput{ + Priority: &PriorityInput{ + DefaultPriority: &defaultPriority, + PerAccountPriority: overrides, + }, + } +} + +func assertPriorityConfig(t *testing.T, config *LLMInvocationConfigInput, defaultPriority uint32, overrides map[string]uint32) { + t.Helper() + if config == nil || config.Priority == nil { + t.Fatalf("llmInvocationConfig = %#v, want priority", config) + } + if config.Priority.DefaultPriority == nil || *config.Priority.DefaultPriority != defaultPriority { + t.Fatalf("defaultPriority = %v, want %d", config.Priority.DefaultPriority, defaultPriority) + } + if len(config.Priority.PerAccountPriority) != len(overrides) { + t.Fatalf("perAccountPriority = %#v, want %#v", config.Priority.PerAccountPriority, overrides) + } + for ncaID, want := range overrides { + if got := config.Priority.PerAccountPriority[ncaID]; got != want { + t.Fatalf("perAccountPriority[%q] = %d, want %d", ncaID, got, want) + } + } +} diff --git a/src/clis/nvcf-cli/internal/agentskill/skilldata_generated.go b/src/clis/nvcf-cli/internal/agentskill/skilldata_generated.go index 2cf9fa07f..8bfb6b05a 100644 --- a/src/clis/nvcf-cli/internal/agentskill/skilldata_generated.go +++ b/src/clis/nvcf-cli/internal/agentskill/skilldata_generated.go @@ -31,7 +31,7 @@ import ( const skillDataZipBase64 = "" + "UEsDBBQACAAAAAAAIQAAAAAAAAAAAAAAAAASAAkAZGF0YS9tYW5pZmVzdC5qc29uVVQFAAEAps4S" + "ewogICJzY2hlbWFWZXJzaW9uIjogMSwKICAiZ2VuZXJhdGVkQXQiOiAiMTk3MC0wMS0wMVQwMDow" + - "MDowMFoiLAogICJ0b3RhbEZpbGVzIjogMjIsCiAgInRvdGFsQnl0ZXMiOiAxOTkzNzksCiAgImZp" + + "MDowMFoiLAogICJ0b3RhbEZpbGVzIjogMjIsCiAgInRvdGFsQnl0ZXMiOiAxOTk5OTQsCiAgImZp" + "bGVzIjogWwogICAgewogICAgICAicGF0aCI6ICJudmNmLXNlbGYtbWFuYWdlZC1jbGkvU0tJTEwu" + "bWQiLAogICAgICAic2hhMjU2IjogImM0ZjI4OGY2MmU1MDg4NjI5ZGY1MTcyYTlhYjMwZWVlOGMz" + "OTRmYzgzOTFjMjMwMDMzNzI2NGVmZjRiMmU3ZWYiLAogICAgICAic2l6ZSI6IDI0OTA5CiAgICB9" + @@ -71,9 +71,9 @@ const skillDataZipBase64 = "" + "ZW5jZS9leGl0LWNvZGVzLm1kIiwKICAgICAgInNoYTI1NiI6ICI2NGI1ZmE5YmNhZjBlMGE1M2Y3" + "ODkyMGI3M2ZjYjUzMGFiNjk0NTFiNDhhNWI0OTNmMjUyY2ExODU4M2FiMDg2IiwKICAgICAgInNp" + "emUiOiAxNzQ5CiAgICB9LAogICAgewogICAgICAicGF0aCI6ICJudmNmLXNlbGYtbWFuYWdlZC1j" + - "bGkvcmVmZXJlbmNlL2ZsYWdzLm1kIiwKICAgICAgInNoYTI1NiI6ICI1NGI1ZWE3OTgxZDI2MjZj" + - "NTgzNTMzMmFiYTI3ZWIyODdhY2E4OWUxYmFkY2IyZmFiODA3MDFhZTI5Zjc2ZTA4IiwKICAgICAg" + - "InNpemUiOiA4OTAyCiAgICB9LAogICAgewogICAgICAicGF0aCI6ICJudmNmLXNlbGYtbWFuYWdl" + + "bGkvcmVmZXJlbmNlL2ZsYWdzLm1kIiwKICAgICAgInNoYTI1NiI6ICJkNGQ5ODg2N2M1OGE1MjJk" + + "OWJhNmJjMjc0M2ZkZDhmYzBmMDQ3ZDVmNDUxZWRlMmU5YWNlMGI4NzI2NGM2MzczIiwKICAgICAg" + + "InNpemUiOiA5NTE3CiAgICB9LAogICAgewogICAgICAicGF0aCI6ICJudmNmLXNlbGYtbWFuYWdl" + "ZC1jbGkvcmVmZXJlbmNlL3Ryb3VibGVzaG9vdGluZy5tZCIsCiAgICAgICJzaGEyNTYiOiAiYTYz" + "MDg0ZTIyNDlmMWQxNTRjNTk4MWU0YTA3MmI3Yzc4NGI4NWVhMTQ2MDg2NTE1ZWFiNGFiNjcwYTk0" + "MGU5NCIsCiAgICAgICJzaXplIjogNDQ2OAogICAgfSwKICAgIHsKICAgICAgInBhdGgiOiAibnZj" + @@ -103,7 +103,7 @@ const skillDataZipBase64 = "" + "IjogIm52Y2Ytc2VsZi1tYW5hZ2VkLWluc3RhbGxhdGlvbi9yZWZlcmVuY2VzL3B1bGwtc2VjcmV0" + "cy5tZCIsCiAgICAgICJzaGEyNTYiOiAiZWMxZjNmZmNkMTdlNWY5NTgzZmVlMzk3NDRlZTg5N2Q0" + "NjZiYzNjZjYzODkyOTQyNjRkODllN2Y5ZWQwMWI4NyIsCiAgICAgICJzaXplIjogNTYzMgogICAg" + - "fQogIF0KfQpQSwcIxAuyqkkQAABJEAAAUEsDBBQACAAAAAAAIQAAAAAAAAAAAAAAAAAjAAkAZGF0" + + "fQogIF0KfQpQSwcIbYNj7kkQAABJEAAAUEsDBBQACAAAAAAAIQAAAAAAAAAAAAAAAAAjAAkAZGF0" + "YS9udmNmLXNlbGYtbWFuYWdlZC1jbGkvU0tJTEwubWRVVAUAAQCmzhItLS0KbmFtZTogbnZjZi1z" + "ZWxmLW1hbmFnZWQtY2xpCmRlc2NyaXB0aW9uOiB8CiAgSW5zdGFsbCwgb3BlcmF0ZSwgYW5kIHRl" + "YXIgZG93biBzZWxmLWhvc3RlZCBOVklESUEgQ2xvdWQgRnVuY3Rpb25zIChOVkNGKQogIGRlcGxv" + @@ -1706,1988 +1706,1999 @@ const skillDataZipBase64 = "" + "VG9rZW4gbGltaXRzIHVzZSBgPHZhbHVlPi08dW5pdD5gIHdpdGggYFNgLCBgTWAsIGBIYCwgYERg" + "LCBvciBgV2AsIGZvciBleGFtcGxlIGAxMDAwLVNgLiBVc2UgaW5wdXQgSlNPTiBmb3IgY29tYmlu" + "ZWQgdG9rZW4gbGltaXRzIGJlY2F1c2UgaW5saW5lIHNwZWNzIHVzZSBjb21tYXMgYXMgZmllbGQg" + - "c2VwYXJhdG9ycy4gfCAtIHwKCkluIEpTT04gYW5kIGlubGluZSBzcGVjcywgTExNIGZ1bmN0aW9u" + - "cyBzZXQgYGZ1bmN0aW9uVHlwZTogIkxMTSJgIGFuZCBtb2RlbCByb3V0aW5nIG1ldGFkYXRhIHVu" + - "ZGVyIGBtb2RlbHNbXS5sbG1Db25maWdgLiBgbGxtQ29uZmlnLnVyaXNgIGRlY2xhcmVzIHRoZSBP" + - "cGVuQUktY29tcGF0aWJsZSB1cHN0cmVhbSBwYXRocyBleHBvc2VkIGJ5IHRoZSBtb2RlbC4gQ3Vy" + - "cmVudCBzdXBwb3J0ZWQgcGF0aHMgYXJlIGAvdjEvY2hhdC9jb21wbGV0aW9uc2AsIGAvdjEvcmVz" + - "cG9uc2VzYCwgYW5kIGAvdjEvZW1iZWRkaW5nc2AuIGBsbG1Db25maWcucm91dGluZ01ldGhvZGAg" + - "YWNjZXB0cyBgcm91bmRfcm9iaW5gLCBgcG93ZXJfb2ZfdHdvYCwgYGdyb3FfbXVsdGlyZWdpb25g" + - "LCBgcHVsc2FyYCwgb3IgYHJhbmRvbWAuCmBsbG1Db25maWcudG9rZW5SYXRlTGltaXRgIGFjY2Vw" + - "dHMgb25lIG9yIG1vcmUgY29tbWEtc2VwYXJhdGVkIHBvc2l0aXZlIGludGVnZXIgdG9rZW4gbGlt" + - "aXRzIGluIGA8dmFsdWU+LTx1bml0PmAgZm9ybWF0LiBTdXBwb3J0ZWQgdW5pdHMgYXJlIGBTYCAo" + - "c2Vjb25kcyksIGBNYCAobWludXRlcyksIGBIYCAoaG91cnMpLCBgRGAgKGRheXMpLCBhbmQgYFdg" + - "ICh3ZWVrcykuIFVzZSBkaXN0aW5jdCB1bml0cyB3aGVuIGNvbWJpbmluZyBsaW1pdHMsIGZvciBl" + - "eGFtcGxlIGAxMDAwLVMsNTAwMC1NLDEwMDAwMC1ILDUwMDAwMC1ELDEwMDAwMDAtV2AgaW4gaW5w" + - "dXQgSlNPTi4KCkhlbG0gY2hhcnQgcGFja2FnaW5nIGlzIGluZGVwZW5kZW50IG9mIGBmdW5jdGlv" + - "blR5cGVgLiBGb3IgYSBIZWxtLWNoYXJ0IGJhY2tlZCBMTE0gZnVuY3Rpb24sIHNldCBgZnVuY3Rp" + - "b25UeXBlOiAiTExNImAsIGBoZWxtQ2hhcnRgLCBgaGVsbUNoYXJ0U2VydmljZU5hbWVgLCBhbmQg" + - "YG1vZGVsc1tdLmxsbUNvbmZpZ2AgaW4gdGhlIHNhbWUgY3JlYXRlIHJlcXVlc3QuIGBpbmZlcmVu" + - "Y2VQb3J0YCBtdXN0IGJlIHRoZSBLdWJlcm5ldGVzIFNlcnZpY2UgcG9ydCBleHBvc2VkIGJ5IGBo" + - "ZWxtQ2hhcnRTZXJ2aWNlTmFtZWAuCgpMTE0gaW52b2NhdGlvbiByZXF1ZXN0cyB1c2UgYG1vZGVs" + - "OiAiPGZ1bmN0aW9uLWlkPi88bW9kZWwtbmFtZT4iYC4gVGhlIGZ1bmN0aW9uIElEIHNlbGVjdHMg" + - "dGhlIE5WQ0YgZnVuY3Rpb24sIGFuZCB0aGUgbW9kZWwgbmFtZSBpcyBmb3J3YXJkZWQgdXBzdHJl" + - "YW0uIENoYXQgY29tcGxldGlvbnMgYW5kIFJlc3BvbnNlcyBBUEkgcmVxdWVzdHMgY2FuIHVzZSBg" + - "eC1tdWx0aS10dXJuLXNlc3Npb24taWRgIGZvciBzZXNzaW9uIHN0aWNraW5lc3M7IGVtYmVkZGlu" + - "Z3MgcmVxdWVzdHMgZG8gbm90LgoKIyMgYGZ1bmN0aW9uIHVwZGF0ZWAtc3BlY2lmaWMKCnwgRmxh" + - "ZyB8IFB1cnBvc2UgfCBEZWZhdWx0IHwKfC0tLXwtLS18LS0tfAp8IGAtLXRhZ3MgVEFHWyxUQUdd" + - "YCB8IFJlcGxhY2UgZnVuY3Rpb24gdGFncyB8IC0gfAp8IGAtLWxsbS1tb2RlbC11cGRhdGUgU1BF" + - "Q2AgfCBMTE0gbW9kZWwgdXBkYXRlOyBmb3JtYXQgYG5hbWU9PG1vZGVsPixyb3V0aW5nTWV0aG9k" + - "PTxtZXRob2Q+LHRva2VuUmF0ZUxpbWl0PTxsaW1pdD5gOyByZXBlYXRhYmxlLiBSb3V0aW5nIG1l" + - "dGhvZHMgbWF0Y2ggYC0tbGxtLW1vZGVsYC4gVG9rZW4gbGltaXQgZXhhbXBsZTogYDEwMDAtU2Au" + - "IFVzZSBpbnB1dCBKU09OIGZvciBjb21iaW5lZCB0b2tlbiBsaW1pdHMuIHwgLSB8CgpJbiBKU09O" + - "LCBgZnVuY3Rpb24gdXBkYXRlYCBhY2NlcHRzIGBtb2RlbFVwZGF0ZXNbXWAgZW50cmllcyB3aXRo" + - "IGBtb2RlbE5hbWVgIGFuZCBgbGxtQ29uZmlnLnJvdXRpbmdNZXRob2RgIGFuZC9vciBgbGxtQ29u" + - "ZmlnLnRva2VuUmF0ZUxpbWl0YC4gYHVyaXNgIGFyZSBjcmVhdGUtdGltZSBtb2RlbCBtZXRhZGF0" + - "YSBhbmQgYXJlIG5vdCBwYXJ0IG9mIG1vZGVsIHVwZGF0ZXMuCgojIyBgZnVuY3Rpb24gZGVwbG95" + - "IGNyZWF0ZWAtc3BlY2lmaWMKCmAtLWlucHV0LWZpbGUgRklMRWAgaXMgcmVjb21tZW5kZWQgKGZ1" + - "bGwgSlNPTiBzcGVjKS4gRm9yIGFkLWhvYyBvbmUtc2hvdCB1c2U6Cgp8IEZsYWcgfCBQdXJwb3Nl" + - "IHwgRGVmYXVsdCB8CnwtLS18LS0tfC0tLXwKfCBgLS1mdW5jdGlvbi1pZCBJRGAgfCBGdW5jdGlv" + - "biBJRCAocmVxdWlyZWQpIHwgLSB8CnwgYC0tZ3B1IE5BTUVgIHwgR1BVIGZhbWlseSB8IGBIMTAw" + - "YCB8CnwgYC0taW5zdGFuY2UtdHlwZSBUWVBFYCB8IFNLVSB8IGBOQ1AuR1BVLkgxMDBfMXhgIHwK" + - "fCBgLS1taW4taW5zdGFuY2VzIE5gIHwgTWluIHJlcGxpY2FzIHwgYDFgIHwKfCBgLS1tYXgtaW5z" + - "dGFuY2VzIE5gIHwgTWF4IHJlcGxpY2FzIHwgYDFgIHwKfCBgLS1tYXgtcmVxdWVzdC1jb25jdXJy" + - "ZW5jeSBOYCB8IENvbmN1cnJlbmN5IHwgYDBgICh1bnNldDsgc2VydmVyIGRlZmF1bHQgYXBwbGll" + - "cykgfAp8IGAtLWNsdXN0ZXJzIE5BTUVbLE5BTUVdYCB8IFRhcmdldCBzcGVjaWZpYyBjb21wdXRl" + - "IGNsdXN0ZXJzIHwgKGFueSBtYXRjaGluZyBTS1UpIHwKCiMjIGB0YXNrIGNyZWF0ZWAtc3BlY2lm" + - "aWMKCmAtLWlucHV0LWZpbGUgRklMRWAgaXMgcmVjb21tZW5kZWQgZm9yIHJlcGVhdGFibGUgdGFz" + - "ayBkZWZpbml0aW9ucy4gRm9yIGFkLWhvYyB1c2U6Cgp8IEZsYWcgfCBQdXJwb3NlIHwgTm90ZXMg" + - "fAp8LS0tfC0tLXwtLS18CnwgYC0tbmFtZSBOQU1FYCB8IFRhc2sgbmFtZSAocmVxdWlyZWQpIHwg" + - "MS0xMjggY2hhcnMsIGBeW2EtejAtOUEtWl1bYS16MC05QS1aXC1fXSokYCB8CnwgYC0tZ3B1IEdQ" + - "VWAgfCBHUFUgbmFtZSAocmVxdWlyZWQgd2l0aG91dCBgLS1pbnB1dC1maWxlYCkgfCBFeGFtcGxl" + - "OiBgSDEwMGAgfAp8IGAtLWluc3RhbmNlLXR5cGUgVFlQRWAgfCBJbnN0YW5jZSB0eXBlIChyZXF1" + - "aXJlZCB3aXRob3V0IGAtLWlucHV0LWZpbGVgKSB8IEV4YW1wbGU6IGBOQ1AuR1BVLkgxMDBfMXhg" + - "IHwKfCBgLS1pbWFnZSBJTUFHRWAgfCBDb250YWluZXIgaW1hZ2UgfCBNdXR1YWxseSBleGNsdXNp" + - "dmUgd2l0aCBgLS1oZWxtLWNoYXJ0YCB8CnwgYC0taGVsbS1jaGFydCBDSEFSVGAgfCBIZWxtIGNo" + - "YXJ0IFVSTCBvciBPQ0kgcmVmZXJlbmNlIHwgTXV0dWFsbHkgZXhjbHVzaXZlIHdpdGggYC0taW1h" + - "Z2VgIHwKfCBgLS1pbnB1dC1maWxlIEZJTEVgIHwgSlNPTiB0YXNrIHNwZWMgZmlsZSB8IENMSSBm" + - "bGFncyBvdmVycmlkZSBKU09OIHZhbHVlcyB3aGVuIGJvdGggYXJlIHNldCB8CnwgYC0tYmFja2Vu" + - "ZCBCQUNLRU5EYCB8IEJhY2tlbmQgLyBDU1AgfCAtIHwKfCBgLS1jbHVzdGVycyBOQU1FWyxOQU1F" + - "XWAgfCBTcGVjaWZpYyBjbHVzdGVycyB3aXRoaW4gdGhlIGluc3RhbmNlIHwgQ29tbWEtc2VwYXJh" + - "dGVkIHwKfCBgLS1jb250YWluZXItYXJncyBBUkdTYCB8IEFyZ3MgcGFzc2VkIHdoZW4gbGF1bmNo" + - "aW5nIHRoZSBjb250YWluZXIgfCBTaW5nbGUgc3RyaW5nLCBlLmcuIGAiLS1lcG9jaHMgMTAgLS1i" + - "YXRjaC1zaXplIDMyImAgfAp8IGAtLWNvbnRhaW5lci1lbnYgTkFNRT12YWx1ZWAgfCBDb250YWlu" + - "ZXIgZW52aXJvbm1lbnQgdmFyaWFibGU7IHJlcGVhdGFibGUgfCAtIHwKfCBgLS1zZWNyZXRzIE5B" + - "TUU9dmFsdWVgIHwgU2VjcmV0IGVudmlyb25tZW50IHZhcmlhYmxlOyByZXBlYXRhYmxlOyBlbmNy" + - "eXB0ZWQgYXQgcmVzdCB8IC0gfAp8IGAtLW1heC1ydW50aW1lIERVUkFUSU9OYCB8IE1heCB3YWxs" + - "LWNsb2NrIHJ1biB0aW1lIChJU08gODYwMSwgZS5nLiBgUFQ0SGApIHwgTm8gZGVmYXVsdDsgb21p" + - "dCBmb3Igbm8gdGltZSBsaW1pdCB8CnwgYC0tbWF4LXF1ZXVlZCBEVVJBVElPTmAgfCBNYXggdGlt" + - "ZSBpbiBxdWV1ZSBiZWZvcmUgY2FuY2VsbGF0aW9uIChJU08gODYwMSkgfCBTZXJ2ZXIgZGVmYXVs" + - "dCBgUFQ3MkhgIHwKfCBgLS10ZXJtaW5hdGlvbi1ncmFjZSBEVVJBVElPTmAgfCBHcmFjZSBwZXJp" + - "b2QgYWZ0ZXIgc3RvcCBzaWduYWwgKElTTyA4NjAxKSB8IFNlcnZlciBkZWZhdWx0IGBQVDFIYCB8" + - "CnwgYC0tcmVzdWx0LXN0cmF0ZWd5IFVQTE9BRFx8Tk9ORWAgfCBIb3cgdG8gaGFuZGxlIHRhc2sg" + - "b3V0cHV0IGFydGlmYWN0cyB8IC0gfAp8IGAtLXJlc3VsdHMtbG9jYXRpb24gTE9DQVRJT05gIHwg" + - "UmVzdWx0IHVwbG9hZCB0YXJnZXQsIGZvcm1hdCBgb3JnLW5hbWUvW3RlYW0tbmFtZS9dbW9kZWwt" + - "bmFtZWA7IHJlcXVpcmVkIHdoZW4gYC0tcmVzdWx0LXN0cmF0ZWd5PVVQTE9BRGAgfCAtIHwKfCBg" + - "LS1tb2RlbHMgTkFNRTpWRVJTSU9OOlVSSWAgfCBNb2RlbCBhcnRpZmFjdDsgcmVwZWF0YWJsZSB8" + - "IC0gfAp8IGAtLXJlc291cmNlcyBOQU1FOlZFUlNJT046VVJJYCB8IFJlc291cmNlIGFydGlmYWN0" + - "OyByZXBlYXRhYmxlIHwgLSB8CnwgYC0tdGFncyBUQUdbLFRBR11gIHwgVGFzayB0YWdzIHwgQ29t" + - "bWEtc2VwYXJhdGVkIHwKfCBgLS1kZXNjcmlwdGlvbiBURVhUYCB8IFRhc2sgZGVzY3JpcHRpb24g" + - "fCAtIHwKfCBgLS1sb2dzLXRlbGVtZXRyeS1pZCBVVUlEYCB8IExvZ3MgdGVsZW1ldHJ5IGVuZHBv" + - "aW50IElEIHwgLSB8CnwgYC0tbWV0cmljcy10ZWxlbWV0cnktaWQgVVVJRGAgfCBNZXRyaWNzIHRl" + - "bGVtZXRyeSBlbmRwb2ludCBJRCB8IC0gfAp8IGAtLXRyYWNlcy10ZWxlbWV0cnktaWQgVVVJRGAg" + - "fCBUcmFjZXMgdGVsZW1ldHJ5IGVuZHBvaW50IElEIHwgLSB8CgpQSwcI/KOR4MYiAADGIgAAUEsD" + - "BBQACAAAAAAAIQAAAAAAAAAAAAAAAAA3AAkAZGF0YS9udmNmLXNlbGYtbWFuYWdlZC1jbGkvcmVm" + - "ZXJlbmNlL3Ryb3VibGVzaG9vdGluZy5tZFVUBQABAKbOEiMgVHJvdWJsZXNob290aW5nCgpLbm93" + - "biBlcnJvcnMg4oaSIGRpYWdub3N0aWMgY29tbWFuZCDihpIgcmVtZWRpYXRpb24uIEtlZXAgaW4g" + - "c3luYyB3aXRoIHRoZSBzdHJ1Y3R1cmVkIGBwaGFzZV9mYWlsZWRgIGV2ZW50cyB0aGUgQ0xJIGVt" + - "aXRzIChSRVEtMTUpIOKAlCBldmVyeSBlbnRyeSBiZWxvdyBzaG91bGQgbWFwIHRvIGFuIGBlcnJD" + - "YXRlZ29yeWAgYW5kIGEgYHJlbWVkaWF0aW9uYCBhcnJheS4KCiMjIFByZS1mbGlnaHQKCnwgU3lt" + - "cHRvbSB8IENhdXNlIHwgUmVtZWRpYXRpb24gfAp8LS0tfC0tLXwtLS18CnwgYGt1YmVjdGwgbm90" + - "IG9uIFBBVEhgIHwgT3BlcmF0b3IncyBgJFBBVEhgIGRvZXNuJ3QgaW5jbHVkZSBrdWJlY3RsIHwg" + - "SW5zdGFsbCBrdWJlY3RsIDEuMjgrOiBodHRwczovL2t1YmVybmV0ZXMuaW8vZG9jcy90YXNrcy90" + - "b29scy9pbnN0YWxsLWt1YmVjdGwvIHwKfCBgaGVsbWZpbGUgbm90IG9uIFBBVEhgIHwgU2FtZSB8" + - "IGh0dHBzOi8vZ2l0aHViLmNvbS9oZWxtZmlsZS9oZWxtZmlsZSNpbnN0YWxsYXRpb24gfAp8IGBo" + - "ZWxtIG5vdCBvbiBQQVRIYCB8IFNhbWUgfCBodHRwczovL2hlbG0uc2gvZG9jcy9pbnRyby9pbnN0" + - "YWxsLyB8CnwgYEdhdGV3YXkgQVBJIENSRHMgbm90IGluc3RhbGxlZGAgfCBlbnZveS1nYXRld2F5" + - "IHByZXJlcSBtaXNzaW5nIHwgYGhlbG0gaW5zdGFsbCBlZyBvY2k6Ly9kb2NrZXIuaW8vZW52b3lw" + - "cm94eS9nYXRld2F5LWhlbG0gLS1uYW1lc3BhY2U9ZW52b3ktZ2F0ZXdheS1zeXN0ZW0gLS1jcmVh" + - "dGUtbmFtZXNwYWNlYCB8CnwgYGRlZmF1bHQgU3RvcmFnZUNsYXNzIG5vdCBhdmFpbGFibGVgIHwg" + - "Q2x1c3RlciBoYXMgbm8gZGVmYXVsdCBTQyB8IEFubm90YXRlIG9uZTogYGt1YmVjdGwgcGF0Y2gg" + - "c2MgPG5hbWU+IC1wICd7Im1ldGFkYXRhIjp7ImFubm90YXRpb25zIjp7InN0b3JhZ2VjbGFzcy5r" + - "dWJlcm5ldGVzLmlvL2lzLWRlZmF1bHQtY2xhc3MiOiJ0cnVlIn19fSdgIHwKfCBgR1BVIG9wZXJh" + - "dG9yIG5vdCBpbnN0YWxsZWRgIChjb21wdXRlLXBsYW5lKSB8IG52aWRpYSBHUFUgb3BlcmF0b3Ig" + - "bWlzc2luZyB8IEluc3RhbGwgcGVyIGh0dHBzOi8vZG9jcy5udmlkaWEuY29tL2RhdGFjZW50ZXIv" + - "Y2xvdWQtbmF0aXZlL2dwdS1vcGVyYXRvci9sYXRlc3QvaW5zdGFsbC1ncHUtb3BlcmF0b3IuaHRt" + - "bCwgT1IgdXNlIGBmYWtlLWdwdS1vcGVyYXRvcmAgZm9yIGRldiB8CnwgYEdQVSBub2RlIGxhYmVs" + - "cyBtaXNzaW5nYCAoY29tcHV0ZS1wbGFuZSkgfCBOb2RlcyBuZWVkIGBudmlkaWEuY29tL2dwdS5m" + - "YW1pbHlgIGV0Yy4gfCBTZXQgYC0tazNzLW5vZGUtbGFiZWwgbnZpZGlhLmNvbS9ncHUuZmFtaWx5" + - "PWhvcHBlckBhZ2VudDpOYCBmb3IgazNkIHwKCiMjIEF1dGgKCnwgU3ltcHRvbSB8IENhdXNlIHwg" + - "UmVtZWRpYXRpb24gfAp8LS0tfC0tLXwtLS18CnwgYGFkbWluIHRva2VuIHJlcXVpcmVkYCAoaW5p" + - "dCBub3QgcnVuKSB8IE5vIGB+Ly5udmNmLWNsaS5zdGF0ZWAgYW5kIGAtLXRva2VuYCBub3QgcGFz" + - "c2VkIHwgYG52Y2YtY2xpIGluaXRgIChpbnRlcmFjdGl2ZSkgb3IgYC0tdG9rZW49JEpXVCAtLW5v" + - "bi1pbnRlcmFjdGl2ZWAgKENJKSB8CnwgYFNpZ25lZCBKV1QgcmVqZWN0ZWQ6IEFub3RoZXIgYWxn" + - "b3JpdGhtIGV4cGVjdGVkLCBvciBubyBtYXRjaGluZyBrZXkocykgZm91bmRgIHwgU3RhbGUgc2Vz" + - "c2lvbi5qc29uIGZyb20gYSBkaWZmZXJlbnQgY29udHJvbCBwbGFuZSB8IGBybSB+Ly5udmNmLWNs" + - "aS5zdGF0ZWAgdGhlbiBgbnZjZi1jbGkgaW5pdGAgYWdhaW4gfAp8IGA0MDMgbWlzc2luZyByZXF1" + - "ZXN0ZWQgYXV0aG9yaXRpZXNgIChmdW5jdGlvbiBpbnZva2UpIHwgQWRtaW4gdG9rZW4gZG9lc24n" + - "dCBoYXZlIGBpbnZva2VfZnVuY3Rpb25gIHNjb3BlIHwgYG52Y2YtY2xpIGFwaS1rZXkgZ2VuZXJh" + - "dGUgLS1kZXNjcmlwdGlvbj3igKZgIHRoZW4gcmUtcnVuIGludm9rZSB8CgojIyBJbnN0YWxsIC8g" + - "YHVwYAoKfCBTeW1wdG9tIHwgQ2F1c2UgfCBSZW1lZGlhdGlvbiB8CnwtLS18LS0tfC0tLXwKfCBI" + - "ZWxtIGB0aW1lZCBvdXQgd2FpdGluZyBmb3IgY2Fzc2FuZHJhYCB8IENhc3NhbmRyYSBTdGF0ZWZ1" + - "bFNldCBQVkMgc3R1Y2sgYFBlbmRpbmdgIHwgQ29uZmlybSBkZWZhdWx0IFN0b3JhZ2VDbGFzczsg" + - "Y2hlY2sgYGt1YmVjdGwgZ2V0IHB2LHB2YyAtbiBjYXNzYW5kcmEtc3lzdGVtYCB8CnwgYEludmFs" + - "aWQgR1BVICdOQ1AuR1BVLkgxMDAnIHNwZWNpZmllZGAgKGZ1bmN0aW9uIGRlcGxveSkgfCBXcm9u" + - "ZyBmaWVsZCDigJQgYGdwdWAgaXMgdGhlIGZhbWlseSwgbm90IHRoZSBTS1UgfCBVc2UgYCJncHUi" + - "OiAiSDEwMCJgLCBgImluc3RhbmNlVHlwZSI6ICJOQ1AuR1BVLkgxMDBfMXgiYCB8CnwgYHJlZ2lv" + - "biBtdXN0IGJlIHByb3ZpZGVkYCAoY2x1c3RlciByZWdpc3RlciAvIGluc3RhbGwgLS1jb21wdXRl" + - "LXBsYW5lKSB8IGAtLXJlZ2lvbmAgZW1wdHkgKyBgQ0xVU1RFUl9SRUdJT05gIGVudiBlbXB0eSB8" + - "IFBhc3MgYC0tcmVnaW9uPXVzLXdlc3QtMWAgKG9yIGFueSBub24tZW1wdHkgdmFsdWUpIHwKfCBg" + - "cmVxdWlyZWRFbnYgIk5DQV9JRCIgaXMgbm90IHNldGAgKGhlbG1maWxlIGVycm9yIGR1cmluZyBj" + - "b21wdXRlLXBsYW5lIGFwcGx5KSB8IE9sZGVyIG52Y2YtY2xpIGJlZm9yZSBjb21taXQgYDZhYTU3" + - "MDRgOyBFeHRyYUVudiBub3QgcHJvcGFnYXRpbmcgTkNBX0lEIHwgVXBncmFkZSBgbnZjZi1jbGlg" + - "IHRvIGEgcmVsZWFzZSBhZnRlciBgNmFhNTcwNGAgfAp8IGBudmNhLW9wZXJhdG9yOiBJbWFnZVB1" + - "bGxCYWNrT2ZmYCBmb3IgYG52Y2Etb3BlcmF0b3I6cHNhdGAgfCBJbWFnZSBub3QgaW4gY2x1c3Rl" + - "ciByZWdpc3RyeTsgbXVsdGktY2x1c3RlciBidWlsZCBpcyBsb2NhbCB8IGBrM2QgaW1hZ2UgaW1w" + - "b3J0IG52Y3IuaW8vLi4uL252Y2Etb3BlcmF0b3I6cHNhdCAtYyA8Y2x1c3Rlcj5gIHwKCiMjIENv" + - "bXB1dGUtcGxhbmUgcnVudGltZQoKfCBTeW1wdG9tIHwgQ2F1c2UgfCBSZW1lZGlhdGlvbiB8Cnwt" + - "LS18LS0tfC0tLXwKfCBOVkNBIGFnZW50IENyYXNoTG9vcEJhY2tPZmYgd2l0aCBgSFRUUCA0MDFg" + - "IG9uIGAvdjEvbnZjYS9jbHVzdGVycy8uLi4vcmVnaXN0ZXJgIHwgU3RhbGUgYG91dC88Y2x1c3Rl" + - "cj4tcmVnaXN0ZXItdmFsdWVzLnlhbWxgIGZyb20gcHJpb3IgcmVnaXN0ZXI7IGNsdXN0ZXIgSUQg" + - "ZG9lc24ndCBtYXRjaCBJQ01TIHwgRGVsZXRlIHRoZSBzdGFsZSBmaWxlOyByZS1ydW4gYG52Y2Yt" + - "Y2xpIHNlbGYtaG9zdGVkIHVwYCAoaWRlbXBvdGVudCByZWdpc3RlciB3cml0ZXMgYSBmcmVzaCBm" + - "aWxlKSB8CnwgYE5vIGNsdXN0ZXIgZm91bmQgd2l0aCB2YWxpZCBKV0tTIGZvciBjbHVzdGVyIElE" + - "OiA8aWQ+YCAoSUNNUyBsb2cpIHwgSldLUyBpbiBJQ01TIGRvZXNuJ3QgbWF0Y2ggd2hhdCBjb21w" + - "dXRlLXBsYW5lIEs4cyBpcyBjdXJyZW50bHkgc2lnbmluZyB8IGBudmNmLWNsaSBjbHVzdGVyIHJv" + - "dGF0ZSAtLWNsdXN0ZXItaWQ9PGlkPmAgfAp8IEZ1bmN0aW9uIHBvZCBgSW1hZ2VQdWxsQmFja09m" + - "ZmAgaW4gYG52Y2YtYmFja2VuZGAgfCBJbWFnZS1jcmVkZW50aWFsLWhlbHBlciBjb25maWcgbWlz" + - "c2luZyBvciB3cm9uZyB8IGBrdWJlY3RsIGRlc2NyaWJlIHBvZCAtbiBudmNmLWJhY2tlbmQgPHBv" + - "ZD5gOyBjaGVjayB0aGUgcHVsbCBzZWNyZXQgY29uZmlnIHwKfCBGdW5jdGlvbiBkZXBsb3kgc3R1" + - "Y2sgYERFUExPWUlOR2AgZm9yID41IG1pbiB8IE5BVFMgc3RyZWFtIGluaXQgbGFnIChjb2xkLWNs" + - "dXN0ZXIpIOKAlCB3YWl0LCBvciBjaGVjayBOQVRTIGF1dGgtY2FsbG91dCBoZWFsdGggfCBga3Vi" + - "ZWN0bCBsb2dzIC1uIG5hdHMtc3lzdGVtIC1sIGFwcC5rdWJlcm5ldGVzLmlvL25hbWU9bmF0cy1h" + - "dXRoLWNhbGxvdXQtc2VydmljZWAgfAoKIyMgVGFza3MKCnwgU3ltcHRvbSB8IENhdXNlIHwgUmVt" + - "ZWRpYXRpb24gfAp8LS0tfC0tLXwtLS18CnwgYHRhc2sgY3JlYXRlYCByZXR1cm5zIGBNaXNzaW5n" + - "IDxUWVBFPiByZWdpc3RyeSBjcmVkZW50aWFsIGZvciBob3N0bmFtZWAsIG9yIGtlZXBzIHVzaW5n" + - "IGEgcHJldmlvdXMgY3JlZGVudGlhbCB2YWx1ZSwgc2hvcnRseSBhZnRlciBgcmVnaXN0cnktY3Jl" + - "ZGVudGlhbCBhZGQvdXBkYXRlL2RlbGV0ZWAgd2hpbGUgYHJlZ2lzdHJ5LWNyZWRlbnRpYWwgbGlz" + - "dGAvYGdldGAgYWxyZWFkeSBzaG93IHRoZSBuZXcgdmFsdWUgfCBFeHBlY3RlZCBwcm9wYWdhdGlv" + - "biBkZWxheTogTlZDVCBjYWNoZXMgdGhlIGFjY291bnQncyByZWdpc3RyeSBjcmVkZW50aWFscyB3" + - "aXRoIGBudmN0Lm52Y2YuY2FjaGUtdHRsYCAoZGVmYXVsdCBgUFQ1TWAsIGFib3V0IDUgbWluKSBh" + - "bmQgYXBwbGllcyB0aGUgY2hhbmdlIHdoZW4gdGhhdCBjYWNoZWQgY29weSByZWZyZXNoZXMgfCBX" + - "YWl0IHVwIHRvIGFib3V0IDUgbWluIGFuZCByZXRyeSwgb3IgYGt1YmVjdGwgLW4gbnZjZiByb2xs" + - "b3V0IHJlc3RhcnQgZGVwbG95bWVudC9udmN0LWFwaWAgdG8gYXBwbHkgaW1tZWRpYXRlbHkgfApQ" + - "SwcI864ThHQRAAB0EQAAUEsDBBQACAAAAAAAIQAAAAAAAAAAAAAAAAAsAAkAZGF0YS9udmNmLXNl" + - "bGYtbWFuYWdlZC1pbnN0YWxsYXRpb24vU0tJTEwubWRVVAUAAQCmzhItLS0KbmFtZTogbnZjZi1z" + - "ZWxmLW1hbmFnZWQtaW5zdGFsbGF0aW9uCmRlc2NyaXB0aW9uOiA+LQogIEluc3RhbGwgYW5kIG9w" + - "ZXJhdGUgTlZDRiBzZWxmLWhvc3RlZCBjb250cm9sLXBsYW5lIGFuZCBzZXBhcmF0ZSBjb21wdXRl" + - "LXBsYW5lCiAgc3RhY2tzLiBDb3ZlcnMgSGVsbWZpbGUgdmFsdWVzIGFuZCBDTEkgcHJvZmlsZSBp" + - "bnN0YWxsYXRpb24gZmxvd3MsIHRlYXJkb3duLAogIHZhbHVlcyBvdmVycmlkZXMsIHB1bGwgc2Vj" + - "cmV0cywgYW5kIHRyb3VibGVzaG9vdGluZy4gVXNlIGZvcgogIG52Y2Ytc2VsZi1tYW5hZ2VkLXN0" + - "YWNrLCBudmNmLWNvbXB1dGUtcGxhbmUtc3RhY2ssIHNwbGl0IGNvbXB1dGUtcGxhbmUKICBpbnN0" + - "YWxsYXRpb24sIGNvbnRyb2wtcGxhbmUgaW5zdGFsbGF0aW9uLCBDTEktZ2VuZXJhdGVkIGNvbnRy" + - "b2wtcGxhbmUKICBwcm9maWxlcywgSGVsbWZpbGUsIHNlbGYtbWFuYWdlZCwgb3Igc2VsZi1ob3N0" + - "ZWQgZGVwbG95bWVudHMuIERvIE5PVCB1c2UgZm9yCiAgbG9jYWwgazNkIGVudmlyb25tZW50czsg" + - "dXNlIHRoZSBsb2NhbCBrM2QgZGV2ZWxvcG1lbnQgd29ya2Zsb3cgaW5zdGVhZC4KbGljZW5zZTog" + - "QXBhY2hlLTIuMApjb21wYXRpYmlsaXR5OiBSZXF1aXJlcyBoZWxtZmlsZSA+PSAxLjEuMCA8IDEu" + - "Mi4wLCBoZWxtID49IDMuMTIsIGhlbG0tZGlmZiBwbHVnaW4sIGt1YmVjdGwgbWF0Y2hpbmcgY2x1" + - "c3RlciB2ZXJzaW9uCmF1dGhvcjogIm52Y2YtY29yZS1lbmcgPG52Y2YtY29yZS1lbmdAZXhjaGFu" + - "Z2UubnZpZGlhLmNvbT4iCnZlcnNpb246ICIxLjAuMCIKdGFnczogW252Y2YsIHNlbGYtbWFuYWdl" + - "ZCwgaGVsbWZpbGUsIHNlbGYtaG9zdGVkLCBjb250cm9sLXBsYW5lLCBjb21wdXRlLXBsYW5lLCBj" + - "bGktcHJvZmlsZSwgaW5zdGFsbGF0aW9uLCBkZXBsb3ltZW50LCBwdWxsLXNlY3JldHNdCnRvb2xz" + - "OiBbU2hlbGwsIFJlYWQsIEVkaXQsIEdyZXAsIEdsb2JdCm1ldGFkYXRhOgogIGludGVybmFsOiBm" + - "YWxzZQogIGF1dGhvcjogIm52Y2YtY29yZS1lbmcgPG52Y2YtY29yZS1lbmdAZXhjaGFuZ2UubnZp" + - "ZGlhLmNvbT4iCiAgdmVyc2lvbjogIjEuMCIKICB0YWdzOiBbbnZjZiwgc2VsZi1tYW5hZ2VkLCBo" + - "ZWxtZmlsZSwgc2VsZi1ob3N0ZWQsIGNvbnRyb2wtcGxhbmUsIGNvbXB1dGUtcGxhbmUsIGNsaS1w" + - "cm9maWxlLCBpbnN0YWxsYXRpb24sIGRlcGxveW1lbnQsIHB1bGwtc2VjcmV0c10KICBsYW5ndWFn" + - "ZXM6IFtiYXNoLCB5YW1sXQogIGZyYW1ld29ya3M6IFtoZWxtZmlsZSwgaGVsbSwga3ViZWN0bF0K" + - "ICBkb21haW46IGNsb3VkLWluZnJhc3RydWN0dXJlCi0tLQoKIyBOVkNGIFNlbGYtTWFuYWdlZCBT" + - "dGFjayBPcGVyYXRpb25zCgpPcGVyYXRpb25hbCBndWlkZSBmb3IgbWF0Y2hpbmcgTlZDRiBjb250" + - "cm9sLXBsYW5lIGFuZCBjb21wdXRlLXBsYW5lIEhlbG1maWxlIGJ1bmRsZXMuCgojIyBJbnN0cnVj" + - "dGlvbnMKClVzZSB0aGlzIHNraWxsIGZvciBpbnN0YWxsLCB1cGdyYWRlLCBvciB0ZWFyZG93biB3" + - "b3JrIGluIG1hdGNoaW5nIGBudmNmLXNlbGYtbWFuYWdlZC1zdGFja2AgYW5kIGBudmNmLWNvbXB1" + - "dGUtcGxhbmUtc3RhY2tgIGJ1bmRsZXM7IGtlZXAgSGVsbWZpbGUgdmFsdWVzIGFuZCBDTEkgcHJv" + - "ZmlsZSBoYW5kb2ZmcyBzZXBhcmF0ZS4gRm9yIGBmdW5jdGlvblR5cGU6ICJMTE0iYCwgcmVhZCBb" + - "TExNIEZ1bmN0aW9uIEVuYWJsZW1lbnRdKHJlZmVyZW5jZXMvaGVsbWZpbGUtc3RydWN0dXJlLm1k" + - "I2xsbS1mdW5jdGlvbi1lbmFibGVtZW50KS4KCiMjIFByZXJlcXVpc2l0ZXMKCkFzayBmb3IgdGhl" + - "IGV4dHJhY3RlZCBgbnZjZi1zZWxmLW1hbmFnZWQtc3RhY2tgIHBhdGguIEZvciBzcGxpdCBpbnN0" + - "YWxsYXRpb24sCmFsc28gcmVxdWlyZSB0aGUgbWF0Y2hpbmctdmVyc2lvbiBgbnZjZi1jb21wdXRl" + - "LXBsYW5lLXN0YWNrYCBwYXRoLiBWZXJpZnkgYm90aDoKCmBgYGJhc2gKbHMgPGNvbnRyb2wtcGxh" + - "bmUtc3RhY2s+L2hlbG1maWxlLmQvIDxjb250cm9sLXBsYW5lLXN0YWNrPi9lbnZpcm9ubWVudHMv" + - "IDxjb250cm9sLXBsYW5lLXN0YWNrPi9zZWNyZXRzLyA8Y29udHJvbC1wbGFuZS1zdGFjaz4vZ2xv" + - "YmFsLnlhbWwuZ290bXBsCmxzIDxjb21wdXRlLXBsYW5lLXN0YWNrPi9oZWxtZmlsZS5kLyA8Y29t" + - "cHV0ZS1wbGFuZS1zdGFjaz4vZW52aXJvbm1lbnRzLyA8Y29tcHV0ZS1wbGFuZS1zdGFjaz4vZ2xv" + - "YmFsLnlhbWwuZ290bXBsCmBgYAoKSWYgZWl0aGVyIGRpcmVjdG9yeSBpcyBtaXNzaW5nLCBkb3du" + - "bG9hZCBtYXRjaGluZyBidW5kbGUgdmVyc2lvbnMgZnJvbSBOR0M6CgpgYGBiYXNoCm5nYyByZWdp" + - "c3RyeSByZXNvdXJjZSBkb3dubG9hZC12ZXJzaW9uIDxvcmc+L252Y2Ytc2VsZi1tYW5hZ2VkLXN0" + - "YWNrOjx2ZXJzaW9uPgpuZ2MgcmVnaXN0cnkgcmVzb3VyY2UgZG93bmxvYWQtdmVyc2lvbiA8b3Jn" + - "Pi9udmNmLWNvbXB1dGUtcGxhbmUtc3RhY2s6PHZlcnNpb24+CmBgYAoKQ29udHJvbC1wbGFuZSBj" + - "b21tYW5kcyBiZWxvdyBhc3N1bWUgdGhlIGNvbnRyb2wtcGxhbmUgYnVuZGxlIHJvb3QuIFNwbGl0" + - "LWZsb3cKY29tbWFuZHMgYW5kIHJvb3Qgc3Vic3RpdHV0aW9uIGFyZSBpbgpbU3BsaXQgQ29tcHV0" + - "ZS1QbGFuZSBJbnN0YWxsYXRpb25dKHJlZmVyZW5jZXMvY29tcHV0ZS1wbGFuZS1pbnN0YWxsYXRp" + - "b24ubWQpLgoKIyMgQmVmb3JlIFlvdSBTdGFydAoKVmVyaWZ5IHRvb2xpbmcgYW5kIGNvbnRleHQg" + - "YmVmb3JlIGFueSBvcGVyYXRpb246CgpgYGBiYXNoCmhlbG1maWxlIC0tdmVyc2lvbiAgICMgTXVz" + - "dCBiZSAxLjEueCAoMS4yLjAgcmVtb3ZlZCBzZXF1ZW50aWFsIG1vZGUpCmhlbG0gdmVyc2lvbiAg" + - "ICAgICAgICMgTXVzdCBiZSA+PSAzLjEyCmhlbG0gcGx1Z2luIGxpc3QgICAgICMgTXVzdCBpbmNs" + - "dWRlIGhlbG0tZGlmZiA+PSAzLjExCmt1YmVjdGwgdmVyc2lvbiAgICAgICMgQ2xpZW50IG11c3Qg" + - "YmUgd2l0aGluIDEgbWlub3IgdmVyc2lvbiBvZiBjbHVzdGVyCmBgYAoKQ29udHJvbC1wbGFuZSBj" + - "b21tYW5kcyBydW4gZnJvbSB0aGUgZXh0cmFjdGVkIGBudmNmLXNlbGYtbWFuYWdlZC1zdGFjay9g" + - "IHJvb3Q6CgpgYGBiYXNoCmNkIHBhdGgvdG8vbnZjZi1zZWxmLW1hbmFnZWQtc3RhY2sKbHMgaGVs" + - "bWZpbGUuZC8gZW52aXJvbm1lbnRzLyBzZWNyZXRzLyBnbG9iYWwueWFtbC5nb3RtcGwKYGBgCgpJ" + - "ZGVudGlmeSB0aGUgZW52aXJvbm1lbnQgZnJvbSBgZW52aXJvbm1lbnRzLzxuYW1lPi55YW1sYCBh" + - "bmQKYHNlY3JldHMvPG5hbWU+LXNlY3JldHMueWFtbGA7IGZvciBFS1MsIHVzZSB0aGUgY2Fub25p" + - "Y2FsCltDU1AgRW5kLXRvLUVuZCBFeGFtcGxlXShodHRwczovL2RvY3MubnZpZGlhLmNvbS9udmNm" + - "L3YwLjYuMC1yYy9jc3AtZW5kLXRvLWVuZC1leGFtcGxlKS4KCiMjIEhvdyBWYWx1ZXMgRmxvdwoK" + - "VW5kZXJzdGFuZGluZyB2YWx1ZSBwcmVjZWRlbmNlIHByZXZlbnRzIHRoZSBtb3N0IGNvbW1vbiBj" + - "b25maWd1cmF0aW9uIG1pc3Rha2VzLgoKYGBgCmVudmlyb25tZW50cy9iYXNlLnlhbWwgICAgICAg" + - "ICAgKGRlZmF1bHRzKQogICAgLT4gbWVyZ2VkIHdpdGgKZW52aXJvbm1lbnRzLzxlbnY+LnlhbWwg" + - "ICAgICAgICAoeW91ciBvdmVycmlkZXMpCiAgICAtPiBjb25zdW1lZCBieQpnbG9iYWwueWFtbC5n" + - "b3RtcGwgICAgICAgICAgICAgIChHbyB0ZW1wbGF0ZSwgY29uc3RydWN0cyBwZXItY2hhcnQgdmFs" + - "dWVzKQogICAgLT4gY29uc3VtZWQgYnkKc2VjcmV0cy88ZW52Pi1zZWNyZXRzLnlhbWwgICAgICAo" + - "c2Vuc2l0aXZlIHZhbHVlcykKICAgIC0+IG92ZXJyaWRkZW4gYnkKcmVsZWFzZSBpbmxpbmUgdmFs" + - "dWVzOiBibG9ja3MgICAoaGlnaGVzdCBwcmVjZWRlbmNlKQpgYGAKCkNyaXRpY2FsOiBgZ2xvYmFs" + - "LnlhbWwuZ290bXBsYCBvbmx5IHBhc3NlcyB0aHJvdWdoIHNwZWNpZmljIGtleXMgdG8gZWFjaCBj" + - "aGFydCAoaW1hZ2UgcmVnaXN0cmllcywgbm9kZSBzZWxlY3RvcnMsIHN0b3JhZ2UsIHJlcGxpY2Eg" + - "Y291bnRzKS4gU2V0dGluZyBhbiBhcmJpdHJhcnkgY2hhcnQgdmFsdWUgaW4gdGhlIGVudmlyb25t" + - "ZW50IGZpbGUgd2lsbCBiZSBzaWxlbnRseSBpZ25vcmVkIGlmIGBnbG9iYWwueWFtbC5nb3RtcGxg" + - "IGRvZXMgbm90IHByb3BhZ2F0ZSBpdC4KClRvIG92ZXJyaWRlIGFyYml0cmFyeSBjaGFydCB2YWx1" + - "ZXMsIHVzZSBhIGhlbG1maWxlIHJlbGVhc2UgYHZhbHVlczpgIGJsb2NrLiBTZWUgW092ZXJyaWRp" + - "bmcgSGVsbSBDaGFydCBWYWx1ZXNdKCNvdmVycmlkaW5nLWhlbG0tY2hhcnQtdmFsdWVzKS4KCiMj" + - "IENsZWFuIEluc3RhbGxhdGlvbgoKIyMjIDEuIENyZWF0ZSBuYW1lc3BhY2VzIGFuZCBpbWFnZSBw" + - "dWxsIHNlY3JldHMgKGlmIHVzaW5nIGEgcHJpdmF0ZSByZWdpc3RyeSkKCmBgYGJhc2gKZm9yIG5z" + - "IGluIGNhc3NhbmRyYS1zeXN0ZW0gbmF0cy1zeXN0ZW0gbnZjZiBhcGkta2V5cyBlc3Mgc2lzIHZh" + - "dWx0LXN5c3RlbSBjZXJ0LW1hbmFnZXI7IGRvCiAga3ViZWN0bCBjcmVhdGUgbmFtZXNwYWNlICIk" + - "bnMiIC0tZHJ5LXJ1bj1jbGllbnQgLW8geWFtbCB8IGt1YmVjdGwgYXBwbHkgLWYgLQpkb25lCgoj" + - "IE9ubHkgaWYgcHVsbGluZyBmcm9tIGEgcHJpdmF0ZSByZWdpc3RyeSAoZS5nLiwgTkdDIG52Y3Iu" + - "aW8pCmV4cG9ydCBOR0NfQVBJX0tFWT0iPHlvdXIta2V5PiIKZm9yIG5zIGluIGNhc3NhbmRyYS1z" + - "eXN0ZW0gbmF0cy1zeXN0ZW0gbnZjZiBhcGkta2V5cyBlc3Mgc2lzIHZhdWx0LXN5c3RlbSBjZXJ0" + - "LW1hbmFnZXI7IGRvCiAga3ViZWN0bCBjcmVhdGUgc2VjcmV0IGRvY2tlci1yZWdpc3RyeSBudmNy" + - "LWNyZWRzIFwKICAgIC0tZG9ja2VyLXNlcnZlcj1udmNyLmlvIFwKICAgIC0tZG9ja2VyLXVzZXJu" + - "YW1lPSckb2F1dGh0b2tlbicgXAogICAgLS1kb2NrZXItcGFzc3dvcmQ9IiROR0NfQVBJX0tFWSIg" + - "XAogICAgLS1uYW1lc3BhY2U9IiRucyIgXAogICAgLS1kcnktcnVuPWNsaWVudCAtbyB5YW1sIHwg" + - "a3ViZWN0bCBhcHBseSAtZiAtCmRvbmUKYGBgCgpJZiB1c2luZyBwdWxsIHNlY3JldHMsIHlvdSBt" + - "dXN0IGFsc28gY29uZmlndXJlIGVhY2ggaGVsbWZpbGUgcmVsZWFzZSB0byByZWZlcmVuY2UgdGhl" + - "bS4gU2VlIFtJbWFnZSBQdWxsIFNlY3JldHNdKCNpbWFnZS1wdWxsLXNlY3JldHMpLgoKIyMjIDIu" + - "IEF1dGhlbnRpY2F0ZSBoZWxtIHRvIHlvdXIgY2hhcnQgcmVnaXN0cnkKCkJvdGggYGRvY2tlciBs" + - "b2dpbmAgQU5EIGBoZWxtIHJlZ2lzdHJ5IGxvZ2luYCBhcmUgcmVxdWlyZWQgZm9yIE5HQy4gSGVs" + - "bWZpbGUgdXNlcyBoZWxtIChub3QgZG9ja2VyKSB0byBwdWxsIE9DSSBjaGFydHMsIHNvIHRoZSBo" + - "ZWxtIGNyZWRlbnRpYWwgc3RvcmUgbXVzdCBiZSBhdXRoZW50aWNhdGVkIHNlcGFyYXRlbHkuCgpg" + - "YGBiYXNoCiMgTkdDIC0tIGJvdGggY29tbWFuZHMgYXJlIHJlcXVpcmVkCmRvY2tlciBsb2dpbiBu" + - "dmNyLmlvIC11ICckb2F1dGh0b2tlbicgLXAgIiROR0NfQVBJX0tFWSIKaGVsbSByZWdpc3RyeSBs" + - "b2dpbiBudmNyLmlvIC11ICckb2F1dGh0b2tlbicgLXAgIiROR0NfQVBJX0tFWSIKCiMgRUNSCmF3" + - "cyBlY3IgZ2V0LWxvZ2luLXBhc3N3b3JkIC0tcmVnaW9uIDxyZWdpb24+IHwgXAogIGhlbG0gcmVn" + - "aXN0cnkgbG9naW4gLS11c2VybmFtZSBBV1MgLS1wYXNzd29yZC1zdGRpbiA8YWNjb3VudD4uZGty" + - "LmVjci48cmVnaW9uPi5hbWF6b25hd3MuY29tCmBgYAoKPiBOb3RlOiBgaGVsbSByZWdpc3RyeSBs" + - "b2dpbmAga2VlcHMgb25seSB0aGUgbGFzdCBsb2dpbiBwZXIgaG9zdCAobXVsdGktb3JnIGdvdGNo" + - "YSkuCj4gVGhlIHN0YWNrIGFuZCB0aGUgY2FjaGVzIHNwYW4gc2V2ZXJhbCBOR0Mgb3JncyB0aGF0" + - "IG5lZWQgZGlmZmVyZW50IGtleXMsIGJ1dCB0aGV5IGFsbAo+IGxpdmUgdW5kZXIgdGhlIG9uZSBo" + - "b3N0IGBudmNyLmlvYC4gQSBzZWNvbmQgYGhlbG0gcmVnaXN0cnkgbG9naW4gbnZjci5pb2AgKG9y" + - "Cj4gYGRvY2tlciBsb2dpbmApIHdpdGggYSBkaWZmZXJlbnQga2V5IHNpbGVudGx5IG92ZXJ3cml0" + - "ZXMgdGhlIGZpcnN0LCBzbyBwdWxscyBmb3IgdGhlCj4gZmlyc3Qgb3JnIHRoZW4gZmFpbCB3aXRo" + - "IGEgbWlzbGVhZGluZyBgNDAzIEFjY2VzcyBEZW5pZWRgIChub3QgYSA0MDE6IHRoZSBhdXRoCj4g" + - "c3VjY2VlZGVkLCBpdCdzIHRoZSB3cm9uZy1vcmcga2V5KS4gSWYgeW91IHB1bGwgY2hhcnRzL2lt" + - "YWdlcyBmcm9tIG1vcmUgdGhhbiBvbmUgb3JnLAo+IGVpdGhlciByZS1ydW4gdGhlIGxvZ2luIHdp" + - "dGggdGhlIGNvcnJlY3Qga2V5IGltbWVkaWF0ZWx5IGJlZm9yZSBlYWNoIHB1bGwsIG9yIHBhc3MK" + - "PiBgLS11c2VybmFtZSAnJG9hdXRodG9rZW4nIC0tcGFzc3dvcmQgPGtleT5gIHBlciBgaGVsbSBw" + - "dWxsYCBpbnZvY2F0aW9uIGluc3RlYWQgb2YgcmVseWluZwo+IG9uIHRoZSBzdG9yZWQgbG9naW4u" + - "IChQdWxsaW5nIGV2ZXJ5dGhpbmcgZnJvbSBhIHNpbmdsZSByZWdpc3RyeSBtaXJyb3IgYXZvaWRz" + - "IHRoaXMKPiBlbnRpcmVseS4pCgojIyMgMmIuIChSZWNvbW1lbmRlZCkgUHVsbCBmcm9tIGEgcmVn" + - "aXN0cnkgdGhlIGNsdXN0ZXIgYXV0aGVudGljYXRlcyB0byBhdXRvbWF0aWNhbGx5CgpJZiB5b3Ug" + - "bWlycm9yIHRoZSBOVkNGIGltYWdlcyBpbnRvIGEgcmVnaXN0cnkgdGhhdCB0aGUgY2x1c3RlciBj" + - "YW4gcHVsbCBmcm9tIHdpdGhvdXQgYW4KZXhwbGljaXQgaW1hZ2UgcHVsbCBzZWNyZXQgKGZvciBl" + - "eGFtcGxlLCBhIHJlZ2lzdHJ5IHdoZXJlIHRoZSBub2RlIG9yIHdvcmtsb2FkIGlkZW50aXR5IGlz" + - "CmdyYW50ZWQgcHVsbCBhY2Nlc3MgYXV0b21hdGljYWxseSksIHBvaW50IHRoZSBzdGFjayBhdCBp" + - "dCBhbmQgc2tpcCB0aGUgY3JlZGVudGlhbCBzdGVwcwphYm92ZS4KCjEuIFBvaW50IHRoZSBzdGFj" + - "ayBhdCB0aGUgbWlycm9yIGluIGBlbnZpcm9ubWVudHMvPGVudj4ueWFtbGA6CgogICBgYGB5YW1s" + - "CiAgIGdsb2JhbDoKICAgICBpbWFnZToKICAgICAgIHJlZ2lzdHJ5OiA8eW91ci1yZWdpc3RyeT4g" + - "ICAgICAgICAgICAjIGUuZy4gcmVnaXN0cnkuZXhhbXBsZS5jb20KICAgICAgIHJlcG9zaXRvcnk6" + - "IDxtaXJyb3Itc3ViLXBhdGg+CiAgICAgaGVsbToKICAgICAgIHNvdXJjZXM6ICAgICAgICAgICAg" + - "ICAgICAgICAgICAgICAgICAgIyBvbmx5IGlmIHlvdSBhbHNvIG1pcnJvcmVkIHRoZSBoZWxtIGNo" + - "YXJ0cwogICAgICAgICByZWdpc3RyeTogPHlvdXItcmVnaXN0cnk+CiAgICAgICAgIHJlcG9zaXRv" + - "cnk6IDxtaXJyb3Itc3ViLXBhdGg+CiAgIGBgYAoKICAgPiBUaGUgbWFuaWZlc3QgaGFzIGEgbWl4" + - "IG9mIE9DSSBhbmQgbm9uLU9DSSBhcnRpZmFjdHMsIHNvIGNvbnZlcnQgbm9uLU9DSSBjaGFydHMg" + - "YmVmb3JlCiAgID4gbWlycm9yaW5nLiBDb250YWluZXIgaW1hZ2VzIChgbnZjci5pby8uLi5gKSBh" + - "cmUgYWxyZWFkeSBPQ0kgYW5kIG1pcnJvciBhcy1pcy4gU29tZSBIZWxtCiAgID4gY2hhcnRzLCB0" + - "aG91Z2gsIGFyZSBwdWJsaXNoZWQgdG8gYW4gYGh0dHBzOi8vYCBIZWxtIHJlcG9zaXRvcnkgKGZv" + - "ciBleGFtcGxlCiAgID4gYGhlbG0ubmdjLm52aWRpYS5jb21gKS4gVGhvc2UgYXJlIG5vdCBPQ0kg" + - "YW5kIGNhbm5vdCBiZSByZXNvbHZlZCBieSBgZ2xvYmFsLmhlbG0uc291cmNlc2AKICAgPiAoT0NJ" + - "KSBvciBtaXJyb3JlZCBkaXJlY3RseS4gQmVmb3JlIHBvaW50aW5nIHRoZSBzdGFjayBhdCB5b3Vy" + - "IG1pcnJvciwgY29udmVydCBlYWNoCiAgID4gYGh0dHBzOi8vYCBjaGFydCB0byBPQ0k6IGBoZWxt" + - "IHJlcG8gYWRkYC9gaGVsbSBwdWxsYCB0aGUgYC50Z3pgLCB0aGVuCiAgID4gYGhlbG0gcHVzaCA8" + - "Y2hhcnQ+LnRneiBvY2k6Ly88eW91ci1yZWdpc3RyeT4vPG1pcnJvci1zdWItcGF0aD5gLiBPbmx5" + - "IE9DSSBjaGFydHMgY2FuIGxpdmUKICAgPiB1bmRlciBgZ2xvYmFsLmhlbG0uc291cmNlc2AuCgoy" + - "LiBTa2lwIHRoZSBjcmVkZW50aWFsIHN0ZXBzIGFib3ZlLiBXaGVuIHRoZSBjbHVzdGVyIGF1dGhl" + - "bnRpY2F0ZXMgdG8gdGhlIHJlZ2lzdHJ5CiAgIGF1dG9tYXRpY2FsbHkgKHRoZSBub2RlIG9yIHdv" + - "cmtsb2FkIGlkZW50aXR5IGhhcyBwdWxsIGFjY2VzcyksIHRoZSBwdWxsIG5lZWRzIG5vCiAgIEt1" + - "YmVybmV0ZXMgc2VjcmV0LCBzbyB5b3UgZG8gbm90IG5lZWQ6IHRoZSBwZXItbmFtZXNwYWNlIGBu" + - "dmNyLWNyZWRzYCBmcm9tIHN0ZXAgMQogICAoc3RpbGwgY3JlYXRlIHRoZSBuYW1lc3BhY2VzLCBq" + - "dXN0IG5vdCB0aGUgc2VjcmV0KSwgdGhlIGBnbG9iYWwuaW1hZ2VQdWxsU2VjcmV0c2AgZW50cnks" + - "CiAgIG9yIHRoZSBgZG9ja2VyIGxvZ2luYC9gaGVsbSByZWdpc3RyeSBsb2dpbiBudmNyLmlvYCBm" + - "cm9tIHN0ZXAgMi4KCiAgID4gT25lIHJlc2lkdWFsIGNyZWRlbnRpYWw6IG52Y2YtYXBpIHN0aWxs" + - "IHZhbGlkYXRlcyB0aGUgdXNlciBmdW5jdGlvbiBpbWFnZSBhdAogICA+IGBmdW5jdGlvbiBjcmVh" + - "dGVgIHZpYSB0aGUgYWNjb3VudCByZWdpc3RyeSBjcmVkZW50aWFsLCBzbyB0aGF0IGNyZWRlbnRp" + - "YWwgbXVzdCBwb2ludCBhdAogICA+IHdoaWNoZXZlciByZWdpc3RyeSBob2xkcyB0aGUgdXNlciBp" + - "bWFnZSAoc2V0IGl0IHRvIHlvdXIgbWlycm9yIGlmIHRoZSBpbWFnZSBpcyBtaXJyb3JlZAogICA+" + - "IHRoZXJlKS4KCiMjIyAzLiBTZXQgdGhlIHJvdXRlIGRvbWFpbgoKYGdsb2JhbC5kb21haW5gIHNl" + - "dHMgdGhlIGhvc3RuYW1lIHN1ZmZpeCBmb3Igcm91dGVzIHN1Y2ggYXMgYGFwaS48ZG9tYWluPmAu" + - "IEl0IGRvZXMgbm90IGNvbmZpZ3VyZSB0aGUgR2F0ZXdheSBvciBpdHMgbG9hZCBiYWxhbmNlci4g" + - "UXVlcnkgdGhlIGV4YWN0IGV4aXN0aW5nIEdhdGV3YXk6CgpgYGBiYXNoCkdBVEVXQVlfQUREUkVT" + - "Uz0kKGt1YmVjdGwgZ2V0IGdhdGV3YXkgPGdhdGV3YXktbmFtZT4gLW4gPGdhdGV3YXktbmFtZXNw" + - "YWNlPiAtbyBqc29ucGF0aD0ney5zdGF0dXMuYWRkcmVzc2VzWzBdLnZhbHVlfScpCnRlc3QgLW4g" + - "IiRHQVRFV0FZX0FERFJFU1MiCmBgYAoKVGhlIGFkZHJlc3MgbWF5IGJlIGEgaG9zdG5hbWUgb3Ig" + - "SVAuIENsb3VkIHByb3ZpZGVyIGFuZCBHYXRld2F5IGNvbmZpZ3VyYXRpb24gZGV0ZXJtaW5lIHRo" + - "ZSBsb2FkIGJhbGFuY2VyIHR5cGUgYW5kIGFkZHJlc3MgZm9ybWF0LiBUaGUgc2VsZi1tYW5hZ2Vk" + - "IHN0YWNrIGRvZXMgbm90IHNlbGVjdCBlaXRoZXIuCgpGb3IgdGVtcG9yYXJ5IHRlc3Rpbmcgd2l0" + - "aG91dCBETlMsIHVzZSBhIHN0YWJsZSByZXNlcnZlZCBzdWZmaXggc3VjaCBhcyBgZ2xvYmFsLmRv" + - "bWFpbjogIm52Y2YudGVzdCJgLCBjb25uZWN0IHRvIGBHQVRFV0FZX0FERFJFU1NgLCBhbmQgc2Vu" + - "ZCBgSG9zdDogYXBpLm52Y2YudGVzdGAuIEZvciBwcm9kdWN0aW9uLCB1c2UgeW91ciBiYXNlIERO" + - "UyBkb21haW4gYW5kIHBvaW50IGl0cyByb3V0ZSByZWNvcmRzIHRvIGBHQVRFV0FZX0FERFJFU1Ng" + - "LiBJZiB0aGUgZW5kcG9pbnQgbGF0ZXIgY2hhbmdlcywga2VlcCBgZ2xvYmFsLmRvbWFpbmAgc3Rh" + - "YmxlIGFuZCB1cGRhdGUgb25seSBETlMgb3IgdGhlIGNsaWVudCBkZXN0aW5hdGlvbi4gU2VlIEV4" + - "YW1wbGUgNCBpbiBbZXhhbXBsZXMubWRdKGV4YW1wbGVzLm1kKS4KCiMjIyA0LiBQcmV2aWV3IGFu" + - "ZCBkZXBsb3kKCmBgYGJhc2gKSEVMTUZJTEVfRU5WPTxlbnYtbmFtZT4gaGVsbWZpbGUgdGVtcGxh" + - "dGUgICAjIFByZXZpZXcgcmVuZGVyZWQgbWFuaWZlc3RzCkhFTE1GSUxFX0VOVj08ZW52LW5hbWU+" + - "IGhlbG1maWxlIHN5bmMgICAgICAgIyBEZXBsb3kKYGBgCgo+IFNldCBCT1RIIENhc3NhbmRyYSBw" + - "YXNzd29yZHMgaW4gdGhlIHNlY3JldHMgZmlsZS4gVGhlIHNlY3JldHMgZmlsZSBkb2N1bWVudHMK" + - "PiBgREVGQVVMVF9DQVNTQU5EUkFfUEFTU1dPUkRgLCBidXQgdGhlIGNhc3NhbmRyYSBjaGFydCBo" + - "YXMgYSBzZWNvbmQgY3JlZGVudGlhbCwKPiBgY2Fzc2FuZHJhLnNlcnZpY2VSb2xlUGFzc3dvcmRg" + - "LCB0aGF0IGRlZmF1bHRzIHRvIGBjaEBuZzNtM2AuIElmIHlvdSBzZXQgb25seQo+IGBERUZBVUxU" + - "X0NBU1NBTkRSQV9QQVNTV09SRGAsIHRoZSBzZXJ2aWNlIHJvbGUga2VlcHMgdGhhdCBkZWZhdWx0" + - "IGFuZCBldmVyeSBEQi1iYWNrZWQKPiBzZXJ2aWNlIGNyYXNoLWxvb3BzIHdpdGggYEJhZCBjcmVk" + - "ZW50aWFsc2Agb25jZSBpdCB0cmllcyB0byBhdXRoZW50aWNhdGUuIFNldAo+IGBjYXNzYW5kcmEu" + - "c2VydmljZVJvbGVQYXNzd29yZGAgdG8gdGhlIHNhbWUgdmFsdWUgYXMgYERFRkFVTFRfQ0FTU0FO" + - "RFJBX1BBU1NXT1JEYC4KCiMjIyA1LiBEZXBsb3ltZW50IHBoYXNlcwoKSGVsbWZpbGUgZGVwbG95" + - "cyBpbiBvcmRlciB3aXRoIGRlcGVuZGVuY2llczoKCnwgUGhhc2UgfCBTZWxlY3RvciB8IFNlcnZp" + - "Y2VzIHwgV2FpdCB0aW1lIHwKfC0tLS0tLS18LS0tLS0tLS0tLXwtLS0tLS0tLS0tfC0tLS0tLS0t" + - "LS0tfAp8IDEgfCBgcmVsZWFzZS1ncm91cD1kZXBlbmRlbmNpZXNgIHwgTkFUUywgT3BlbkJhbywg" + - "Q2Fzc2FuZHJhIHwgNS0xMCBtaW4gfAp8IDIgfCBgcmVsZWFzZS1ncm91cD1zZXJ2aWNlc2AgfCBB" + - "UEksIFNJUywgRVNTLCBpbnZvY2F0aW9uLCBncnBjLXByb3h5LCBub3RhcnksIGFwaS1rZXlzLCBv" + - "cHRpb25hbCBMTE0gZ2F0ZXdheS9yb3V0ZXIsIG9wdGlvbmFsIFZhbml0eSBHYXRld2F5LCBOVkNG" + - "IFVJIHdoZW4gdGhlIHN0YWNrIHBhY2thZ2UgaW5jbHVkZXMgdGhlIGFkZG9uIHwgNS0xMCBtaW4g" + - "fAp8IDMgfCBgcmVsZWFzZS1ncm91cD1pbmdyZXNzYCB8IEdhdGV3YXkgcm91dGVzIHwgMS0yIG1p" + - "biB8CnwgNCB8IGByZWxlYXNlLWdyb3VwPW9ic2VydmFiaWxpdHlgIHwgT2JzZXJ2YWJpbGl0eSBz" + - "dGFjayAoaWYgZW5hYmxlZCkgfCAxLTIgbWluIHwKCk1vbml0b3IgaW4gYSBzZXBhcmF0ZSB0ZXJt" + - "aW5hbDoKCmBgYGJhc2gKa3ViZWN0bCBnZXQgcG9kcyAtQSAtdwpgYGAKCiMjIyA2LiBFbmFibGUg" + - "VmFuaXR5IEdhdGV3YXkgKG9wdGlvbmFsKQoKVmFuaXR5IEdhdGV3YXkgaXMgZGlzYWJsZWQgYnkg" + - "ZGVmYXVsdCBhbmQgaXMgb25seSBuZWVkZWQgZm9yIGN1c3RvbWVyLWZhY2luZwpob3N0bmFtZXMg" + - "b3IgcGF0aCBtYXBwaW5ncyBpbiBmcm9udCBvZiB0aGUgc3RhbmRhcmQgTlZDRiBBUEkgYW5kIGlu" + - "dm9jYXRpb24Kcm91dGVzLiBJdCBpcyBhdmFpbGFibGUgb25seSBpbiBzdGFjayBwYWNrYWdlcyB0" + - "aGF0IGluY2x1ZGUgdGhlIFZhbml0eSBHYXRld2F5CmFkZG9uLiBJZiB0aGUgZXh0cmFjdGVkIHN0" + - "YWNrIHBhY2thZ2UgZG9lcyBub3QgY29udGFpbiBhIGB2YW5pdHktZ2F0ZXdheWAKcmVsZWFzZSBh" + - "bmQgYHZhbml0eUdhdGV3YXlgIHJvdXRlIHZhbHVlcywgc2tpcCB0aGVzZSBjb21tYW5kcyBhbmQg" + - "dXNlIGEgbmV3ZXIKc3RhY2sgcGFja2FnZSB0aGF0IGluY2x1ZGVzIHRoZW0uCgpJZiB0aGUgc3Rh" + - "Y2sgcGFja2FnZSBpbmNsdWRlcyB0aGUgYWRkb24sIGVuYWJsZSBpdCBpbgpgZW52aXJvbm1lbnRz" + - "LzxlbnYtbmFtZT4ueWFtbGA6CgpgYGB5YW1sCmFkZG9uczoKICB2YW5pdHlHYXRld2F5OgogICAg" + - "ZW5hYmxlZDogdHJ1ZQogICAgbWFwcGluZ0NvbmZpZzoge30KYGBgCgpUaGUgZGVmYXVsdCByb3V0" + - "ZSBob3N0IGlzIGB2YW5pdHkuPGRvbWFpbj5gIGFuZCB0aGUgYmFja2VuZCBpcwpgdmFuaXR5LWdh" + - "dGV3YXkubnZjZjo4MDgwYC4gUHV0IGRlcGxveW1lbnQtc3BlY2lmaWMgaG9zdCBhbmQgcGF0aCBt" + - "YXBwaW5ncyB1bmRlcgpgYWRkb25zLnZhbml0eUdhdGV3YXkubWFwcGluZ0NvbmZpZ2AuIElmIHlv" + - "dSBuZWVkIGN1c3RvbSB2YW5pdHkgaG9zdHMgaW5zdGVhZCBvZgpgdmFuaXR5Ljxkb21haW4+YCwg" + - "dXNlIHRoZSByb3V0ZSBob3N0bmFtZSBvdmVycmlkZXMgc3VwcG9ydGVkIGJ5IHRoZSBzdGFjawpw" + - "YWNrYWdlIGFuZCBjcmVhdGUgbWF0Y2hpbmcgRE5TIHJlY29yZHMuCgpBZnRlciBjb25maXJtaW5n" + - "IHRoZSBwYWNrYWdlIGluY2x1ZGVzIHRoZSBgdmFuaXR5LWdhdGV3YXlgIHJlbGVhc2UsIHByZXZp" + - "ZXcgYW5kCmFwcGx5IHRoZSBzZXJ2aWNlIGFuZCByb3V0ZToKCmBgYGJhc2gKSEVMTUZJTEVfRU5W" + - "PTxlbnYtbmFtZT4gaGVsbWZpbGUgLS1zZWxlY3RvciBuYW1lPXZhbml0eS1nYXRld2F5IHRlbXBs" + - "YXRlCkhFTE1GSUxFX0VOVj08ZW52LW5hbWU+IGhlbG1maWxlIC0tc2VsZWN0b3IgbmFtZT12YW5p" + - "dHktZ2F0ZXdheSBzeW5jCkhFTE1GSUxFX0VOVj08ZW52LW5hbWU+IGhlbG1maWxlIC0tc2VsZWN0" + - "b3IgcmVsZWFzZS1ncm91cD1pbmdyZXNzIHN5bmMKYGBgCgpWZXJpZnkgdGhlIHJvdXRlIG9ubHkg" + - "d2hlbiB0aGUgYWRkb24gaXMgcHJlc2VudCBhbmQgZW5hYmxlZDoKCmBgYGJhc2gKa3ViZWN0bCBn" + - "ZXQgZGVwbG95LHN2YyAtbiBudmNmIC1sIGFwcC5rdWJlcm5ldGVzLmlvL25hbWU9dmFuaXR5LWdh" + - "dGV3YXkKa3ViZWN0bCBnZXQgaHR0cHJvdXRlIC1BIHwgZ3JlcCAtaSB2YW5pdHkKY3VybCAtSCAi" + - "SG9zdDogdmFuaXR5Ljxkb21haW4+IiAiaHR0cDovLzxnYXRld2F5LWFkZHJlc3M+L2hlYWx0aCIK" + - "YGBgCgpEbyBub3QgZW5hYmxlIFZhbml0eSBHYXRld2F5IGZvciBzdGFuZGFyZCBBUEksIEFQSSBL" + - "ZXlzLCBpbnZvY2F0aW9uLCBMTE0KaW52b2NhdGlvbiwgb3IgZ1JQQyB0cmFmZmljLiBUaG9zZSBy" + - "b3V0ZXMgYXJlIHByb3ZpZGVkIGJ5IHRoZSBiYXNlIGdhdGV3YXkKcm91dGVzLgoKIyMjIDcuIEVu" + - "YWJsZSBOVkNGIFVJIChvcHRpb25hbCkKCk5WQ0YgVUkgaXMgYW4gb3B0aW9uYWwsIGN1c3RvbWVy" + - "LWZhY2luZyBhZG1pbi1wYW5lbCBVSS4gSXQgaXMgZGlzYWJsZWQgYnkKZGVmYXVsdCBhbmQgYXZh" + - "aWxhYmxlIG9ubHkgaW4gc3RhY2sgcGFja2FnZXMgdGhhdCBpbmNsdWRlIHRoZSBOVkNGIFVJIGFk" + - "ZG9uLiBJZgp5b3VyIGV4dHJhY3RlZCBzdGFjayBwYWNrYWdlIGRvZXMgbm90IGNvbnRhaW4gYSBg" + - "bnZjZi11aWAgcmVsZWFzZSBhbmQgYG52Y2ZVaWAKcm91dGUgdmFsdWVzLCBza2lwIHRoaXMgc2Vj" + - "dGlvbi4gVGhlIE5WQ0YgVUkgYWRtaW4gcGFuZWwgaXMgY3VycmVudGx5CnVuYXV0aGVudGljYXRl" + - "ZDsgZG8gbm90IGV4cG9zZSBpdCB0byB0aGUgcHVibGljIGludGVybmV0LgoKRm9yIGVuYWJsZW1l" + - "bnQsIG5hbWVzcGFjZSBhbmQgcHVsbCBzZWNyZXQgc2V0dXAsIGFwcGx5LCBhbmQgdmVyaWZpY2F0" + - "aW9uIHN0ZXBzLApzZWUgW05WQ0YgVUkgQWRkb25dKHJlZmVyZW5jZXMvbnZjZi11aS1hZGRvbi5t" + - "ZCkuCgojIyMgOC4gSW5zdGFsbCB0aGUgc2VwYXJhdGUgY29tcHV0ZS1wbGFuZSBzdGFjawoKVGhl" + - "IGNvbnRyb2wtcGxhbmUgc3RhY2sgZG9lcyBub3QgaW5zdGFsbCBjb21wdXRlLXBsYW5lIGNvbXBv" + - "bmVudHMuIEFmdGVyIGl0IGlzIGhlYWx0aHksIGNob29zZSBleGFjdGx5IG9uZSBjb21wdXRlLXBs" + - "YW5lIGhhbmRvZmY6CgotIEhlbG1maWxlIHZhbHVlcyBmbG93OiBhdXRob3Igc2VwYXJhdGUgZW52" + - "aXJvbm1lbnQgZmlsZXMsIHRoZW4gcmVnaXN0ZXIgYW5kCiAgaW5zdGFsbCB3aXRoIHRoZSBjb21w" + - "dXRlLXBsYW5lIE1ha2VmaWxlLgotIENMSSBwcm9maWxlIGZsb3c6IHVzZSB0aGUgcHJvZmlsZSBn" + - "ZW5lcmF0ZWQgYnkgdGhlIENMSSBjb250cm9sLXBsYW5lIGluc3RhbGwsCiAgdGhlbiBydW4gdGhl" + - "IGNvbXBsZXRlIENMSSByZWdpc3RlciBhbmQgaW5zdGFsbCBjb21tYW5kcy4KCkRvIG5vdCBtaXgg" + - "dGhlc2UgaGFuZG9mZnMuIEZvbGxvdyBbU3BsaXQgQ29tcHV0ZS1QbGFuZSBJbnN0YWxsYXRpb25d" + - "KHJlZmVyZW5jZXMvY29tcHV0ZS1wbGFuZS1pbnN0YWxsYXRpb24ubWQpCmZvciBjb21tYW5kcywg" + - "RUtTIHJvdXRpbmcsIHB1bGwgc2VjcmV0cywgdmVyaWZpY2F0aW9uLCBhbmQgdGVhcmRvd24gb3Jk" + - "ZXIuCgojIyBDbGVhbiBUZWFyZG93bgoKRGVzdHJveSBldmVyeSBjb21wdXRlIHBsYW5lIGJlZm9y" + - "ZSB0aGUgY29udHJvbCBwbGFuZSwgdXNpbmcgdGhlIHRlYXJkb3duIGZvcgp0aGUgc2FtZSBoYW5k" + - "b2ZmOyBzZWUgW1NwbGl0IENvbXB1dGUtUGxhbmUgSW5zdGFsbGF0aW9uXShyZWZlcmVuY2VzL2Nv" + - "bXB1dGUtcGxhbmUtaW5zdGFsbGF0aW9uLm1kI3RlYXJkb3duKS4KClNjb3BlOiBPbmx5IGRlc3Ry" + - "b3kgcmVsZWFzZXMgbWFuYWdlZCBieSB0aGlzIGNvbnRyb2wtcGxhbmUgaGVsbWZpbGUgc3RhY2su" + - "IFRoZSBOVkNGIHJlbGVhc2VzIGFyZTogYG5hdHNgLCBgb3BlbmJhby1zZXJ2ZXJgLCBgY2Fzc2Fu" + - "ZHJhYCwgYGFwaS1rZXlzYCwgYHNpc2AsIGBhcGlgLCBgaW52b2NhdGlvbi1zZXJ2aWNlYCwgYGdy" + - "cGMtcHJveHlgLCBgZXNzLWFwaWAsIGBub3Rhcnktc2VydmljZWAsIG9wdGlvbmFsIGB2YW5pdHkt" + - "Z2F0ZXdheWAsIGBudmNmLXVpYCwgYGFkbWluLWlzc3Vlci1wcm94eWAsIGFuZCBgaW5ncmVzc2A7" + - "IGBjZXJ0LW1hbmFnZXJgIGlzIGluY2x1ZGVkIG9ubHkgd2hlbiBgY2VydE1hbmFnZXIuZW5hYmxl" + - "ZDogdHJ1ZWAuIFRoZSBjb250cm9sLXBsYW5lIG5hbWVzcGFjZSBpbnZlbnRvcnkgYWxzbyBpbmNs" + - "dWRlcyBgY2VydC1tYW5hZ2VyYCwgYnV0IGRlZmF1bHQgbmFtZXNwYWNlIGNsZWFudXAgcHJlc2Vy" + - "dmVzIGl0LiBOYW1lc3BhY2UgcHJlc2VydmF0aW9uIGRvZXMgbm90IHByZXNlcnZlIHRoZSBIZWxt" + - "IHJlbGVhc2UuIEV4dGVybmFsIGNlcnQtbWFuYWdlciBtdXN0IHVzZSBgY2VydE1hbmFnZXIuZW5h" + - "YmxlZDogZmFsc2VgOyBvdGhlcndpc2UgSGVsbWZpbGUgdHJlYXRzIHRoZSByZWxlYXNlIGFzIHN0" + - "YWNrLW1hbmFnZWQuIERvIG5vdCBkZWxldGUgb3RoZXIgaGVsbSByZWxlYXNlcyBvciBuYW1lc3Bh" + - "Y2VzIG9uIHRoZSBjbHVzdGVyLgoKQmVmb3JlIGNvbnRyb2wtcGxhbmUgZGVzdHJveSwgaWRlbnRp" + - "Znkgd2hldGhlciBjZXJ0LW1hbmFnZXIgaXMgZXh0ZXJuYWwuIEZvciBhbiBleHRlcm5hbCBpbnN0" + - "YWxsYXRpb24sIHJlcXVpcmUgZWZmZWN0aXZlIGBjZXJ0TWFuYWdlci5lbmFibGVkOiBmYWxzZWAg" + - "YW5kIGFib3J0IGlmIGl0IGlzIHRydWUuIEZvciBhbiBpbnRlbmRlZCBzdGFjay1tYW5hZ2VkIHJl" + - "bGVhc2Ugd2l0aCBlZmZlY3RpdmUgYGNlcnRNYW5hZ2VyLmVuYWJsZWQ6IHRydWVgLCB2ZXJpZnkg" + - "bWF0Y2hpbmcgc3RhY2sgSGVsbSByZWxlYXNlIG1ldGFkYXRhIGFuZCBhYm9ydCBvbiBtaXNzaW5n" + - "IG9yIG1pc21hdGNoZWQgZXZpZGVuY2UuIFByZXNlcnZlIHRoZSBuYW1lc3BhY2UgYnkgZGVmYXVs" + - "dDsgb25seSBwbGFuIGl0cyByZW1vdmFsIGFmdGVyIHZlcmlmeWluZyBuYW1lc3BhY2UgcHJvdmVu" + - "YW5jZSBhbmQgZ2V0dGluZyBleHBsaWNpdCBjb25maXJtYXRpb24uCgojIyMgU3RhbmRhcmQgdGVh" + - "cmRvd24KClJ1biBmcm9tIGluc2lkZSB0aGUgYG52Y2Ytc2VsZi1tYW5hZ2VkLXN0YWNrL2AgZGly" + - "ZWN0b3J5OgoKYGBgYmFzaApIRUxNRklMRV9FTlY9PGVudi1uYW1lPiBoZWxtZmlsZSBkZXN0cm95" + - "CmBgYAoKIyMjIERlbGV0ZSBuYW1lc3BhY2VzCgpgYGBiYXNoCmZvciBucyBpbiBjYXNzYW5kcmEt" + - "c3lzdGVtIG5hdHMtc3lzdGVtIG52Y2YgYXBpLWtleXMgZXNzIHNpcyBudmNmLXVpIHZhdWx0LXN5" + - "c3RlbTsgZG8KICBrdWJlY3RsIGRlbGV0ZSBuYW1lc3BhY2UgIiRucyIgLS1pZ25vcmUtbm90LWZv" + - "dW5kCmRvbmUKYGBgCgojIyMgVmVyaWZ5IGNsZWFuCgpgYGBiYXNoCmt1YmVjdGwgZ2V0IG5zIHwg" + - "Z3JlcCAtRSAnKGNhc3NhbmRyYXxuYXRzfHZhdWx0fG52Y2Z8YXBpLWtleXN8ZXNzfHNpcyknCiMg" + - "U2hvdWxkIHJldHVybiBlbXB0eQpgYGAKCiMjIE92ZXJyaWRpbmcgSGVsbSBDaGFydCBWYWx1ZXMK" + - "CiMjIyBFbnZpcm9ubWVudCBmaWxlIChsaW1pdGVkKQoKV29ya3Mgb25seSBmb3Iga2V5cyB0aGF0" + - "IGBnbG9iYWwueWFtbC5nb3RtcGxgIHByb3BhZ2F0ZXMgKGUuZy4sIGBjYXNzYW5kcmEucmVwbGlj" + - "YUNvdW50YCwgYGdsb2JhbC5zdG9yYWdlQ2xhc3NgLCBgZ2xvYmFsLmltYWdlYCkuCgojIyMgUmVs" + - "ZWFzZSB2YWx1ZXMgYmxvY2sgKGFueSBjaGFydCB2YWx1ZSkKCkVkaXQgdGhlIHJlbGVhc2UgaW4g" + - "YGhlbG1maWxlLmQvKi55YW1sLmdvdG1wbGAgYW5kIGFkZCBhIGB2YWx1ZXM6YCBibG9jay4gSW4g" + - "dGhlIGV4YW1wbGVzIGJlbG93LCBgPHByaXZhdGUtdmFsdWVzPmAgcmVmZXJzIHRvIHRoZSBgc2Vj" + - "cmV0cy9gIGRpcmVjdG9yeSBhdCB0aGUgaGVsbWZpbGUgc3RhY2sgcm9vdC4KCmBgYHlhbWwKLSBu" + - "YW1lOiBjYXNzYW5kcmEKICB2ZXJzaW9uOiAwLjguMAogIGNvbmRpdGlvbjogY2Fzc2FuZHJhLmVu" + - "YWJsZWQKICBuYW1lc3BhY2U6IGNhc3NhbmRyYS1zeXN0ZW0KICA8PDogKmRlcGVuZGVuY3kKICB2" + - "YWx1ZXM6CiAgICAtIC4uL2dsb2JhbC55YW1sLmdvdG1wbAogICAgLSAuLi88cHJpdmF0ZS12YWx1" + - "ZXM+L3t7IHJlcXVpcmVkRW52ICJIRUxNRklMRV9FTlYiIH19LXNlY3JldHMueWFtbAogICAgLSBj" + - "YXNzYW5kcmE6CiAgICAgICAgcmVzb3VyY2VzOgogICAgICAgICAgbGltaXRzOgogICAgICAgICAg" + - "ICBjcHU6ICI4IgogICAgICAgICAgICBtZW1vcnk6IDgxOTJNaQogICAgICAgICAgcmVxdWVzdHM6" + - "CiAgICAgICAgICAgIGNwdTogIjIiCiAgICAgICAgICAgIG1lbW9yeTogNDA5Nk1pCmBgYAoKWUFN" + - "TCBtZXJnZSBnb3RjaGE6IFdoZW4gYSByZWxlYXNlIHVzZXMgYDw8OiAqZGVwZW5kZW5jeWAgb3Ig" + - "YGluaGVyaXRgLCBzcGVjaWZ5aW5nIGB2YWx1ZXM6YCByZXBsYWNlcyB0aGUgdGVtcGxhdGUncyB2" + - "YWx1ZXMgbGlzdC4gWW91IG11c3QgcmUtaW5jbHVkZSBgZ2xvYmFsLnlhbWwuZ290bXBsYCBhbmQg" + - "dGhlIHNlY3JldHMgZmlsZS4KCiMjIyBQcmV2aWV3IGFuZCBhcHBseSBhIHNpbmdsZSByZWxlYXNl" + - "CgpgYGBiYXNoCkhFTE1GSUxFX0VOVj08ZW52PiBoZWxtZmlsZSAtLXNlbGVjdG9yIG5hbWU9Y2Fz" + - "c2FuZHJhIHRlbXBsYXRlICAjIFByZXZpZXcKSEVMTUZJTEVfRU5WPTxlbnY+IGhlbG1maWxlIC0t" + - "c2VsZWN0b3IgbmFtZT1jYXNzYW5kcmEgc3luYyAgICAgICMgQXBwbHkKYGBgCgojIyBJbWFnZSBQ" + - "dWxsIFNlY3JldHMKClRoZXJlIGFyZSB0aHJlZSBkaXN0aW5jdCBjcmVkZW50aWFsIHR5cGVzLiBE" + - "byBub3QgY29uZmxhdGUgdGhlbSwgYW5kIG1pbmQgdGhlCmZvcm1hdCBydWxlIGJlbG93ICh0d28g" + - "b2YgdGhlbSBmYWlsIGV2ZW4gd2l0aCB0aGUgY29ycmVjdCBrZXkgaWYgdGhlIGZvcm1hdCBpcyB3" + - "cm9uZyk6Cgp8IHwgQ29udHJvbCBQbGFuZSBQdWxsIFNlY3JldHMgfCBBUEkgQm9vdHN0cmFwIFJl" + - "Z2lzdHJ5IENyZWRzIHwgU2lkZWNhciBJbWFnZS1QdWxsIFNlY3JldCB8CnwtLS18LS0tfC0tLXwt" + - "LS18CnwgUHVycG9zZSB8IEs4cyBwdWxscyBOVkNGIHNlcnZpY2UgaW1hZ2VzIHwgbnZjZi1hcGkg" + - "dmFsaWRhdGVzIHRoZSB1c2VyIGZ1bmN0aW9uIGltYWdlIGF0IGBmdW5jdGlvbiBjcmVhdGVgIHwg" + - "bnZjZi1hcGkgcHVsbHMgdGhlIHBsYXRmb3JtIHNpZGVjYXJzIGluamVjdGVkIGludG8gZXZlcnkg" + - "d29ya2VyIHBvZCB8CnwgV2hlcmUgfCBLOHMgYGRvY2tlci1yZWdpc3RyeWAgU2VjcmV0cyArIEt5" + - "dmVybm8gQ2x1c3RlclBvbGljeSB8IGA8cHJpdmF0ZS12YWx1ZXM+LzxlbnY+LXNlY3JldHMueWFt" + - "bGAgKGFjY291bnQtYm9vdHN0cmFwKSB8IGBOVkNGX0FQSV9TSURFQ0FSU19JTUFHRV9QVUxMX1NF" + - "Q1JFVGAgaW4gYDxlbnY+LXNlY3JldHMueWFtbGAgLT4gT3BlbkJhbyBgc2VydmljZXMvbnZjZi1h" + - "cGkva3Yvc2lkZWNhcnMvaW1hZ2UtcHVsbC1zZWNyZXRgIChmaWVsZCBgc2VjcmV0YCkgfAp8IEZv" + - "cm1hdCB8IHN0YW5kYXJkIGAuZG9ja2VyY29uZmlnanNvbmAgKGt1YmVjdGwgYnVpbGRzIGl0IGZv" + - "ciB5b3UpIHwgYGJhc2U2NCgiJG9hdXRodG9rZW46PGtleT4iKWAgfCBgYmFzZTY0KCIkb2F1dGh0" + - "b2tlbjo8a2V5PiIpYCB8Cgo+IE5vdGU6IHRoZSBhY2NvdW50LWJvb3RzdHJhcCBjcmVkIGFuZCB0" + - "aGUgc2lkZWNhciBzZWNyZXQgYXJlIE5PVCBhCj4gZG9ja2VyY29uZmlnanNvbi4gVGhlIHNlY3Jl" + - "dHMgdGVtcGxhdGUgc2hpcHMgdGhlIHBsYWNlaG9sZGVyCj4gYFJFUExBQ0VfV0lUSF9CQVNFNjRf" + - "RE9DS0VSX0NSRURFTlRJQUxgLCB3aGljaCByZWFkcyBhcyAiYmFzZTY0IG9mIGEgZG9ja2VyY29u" + - "ZmlnanNvbi4iCj4gSXQgaXNuJ3QuIEJvdGggdmFsdWVzIGFyZSBjb25zdW1lZCBhcyBhIHJhdyBk" + - "b2NrZXIgYGF1dGhgIHN0cmluZzogbnZjZi1hcGkgdGFrZXMgdGhlCj4gdmFsdWUgdmVyYmF0aW0g" + - "YW5kIGRyb3BzIGl0IGludG8gdGhlIGBhdXRoYCBmaWVsZCBvZiB0aGUgZG9ja2VyY29uZmlnIGl0" + - "IGJ1aWxkcy4gU28gdGhlCj4gdmFsdWUgbXVzdCBiZSBgYmFzZTY0KCIkb2F1dGh0b2tlbjo8a2V5" + - "PiIpYCwgZS5nLiBgcHJpbnRmICckb2F1dGh0b2tlbjolcycgIiRLRVkiIHwgb3BlbnNzbCBiYXNl" + - "NjQgLUFgLAo+IG5vdCBgYmFzZTY0KDxkb2NrZXJjb25maWdqc29uPilgLgo+ICAtIFdyb25nIGFj" + - "Y291bnQtYm9vdHN0cmFwIHZhbHVlOiBgZnVuY3Rpb24gY3JlYXRlYCByZXR1cm5zCj4gICAgYDQw" + - "MCAibXVzdCBiZSBiYXNlNjQgZW5jb2RlZCB1c2VybmFtZTpwYXNzd29yZCBmb3JtYXQiYC4KPiAg" + - "LSBXcm9uZyBzaWRlY2FyIHZhbHVlOiBldmVyeSB3b3JrZXIncyBzaWRlY2FyIHB1bGwgZ2V0cyBh" + - "IG1hbGZvcm1lZCBjcmVkZW50aWFsIGFuZAo+ICAgIGA0MDNgcywgcmVnYXJkbGVzcyBvZiB3aGlj" + - "aCBrZXkgaXMgaW5zaWRlLiBUaGUgc3ltcHRvbSBsb29rcyBsaWtlIGEgYmFkIG9yIHdyb25nLW9y" + - "Zwo+ICAgIGtleSwgYnV0IHRoZSBrZXkgaXMgZmluZSBhbmQgdGhlIGVuY29kaW5nIGlzIHRoZSBi" + - "dWcuIFRvIHJlcGFpciBhbiBhbHJlYWR5LWluc3RhbGxlZAo+ICAgIHN0YWNrIHdpdGhvdXQgYSBm" + - "dWxsIHJlLXN5bmM6Cj4gICAgYGBgYmFzaAo+ICAgIEFVVEg9JChwcmludGYgJyRvYXV0aHRva2Vu" + - "OiVzJyAiJEtFWSIgfCBvcGVuc3NsIGJhc2U2NCAtQSkKPiAgICBiYW8ga3YgcHV0IHNlcnZpY2Vz" + - "L252Y2YtYXBpL2t2L3NpZGVjYXJzL2ltYWdlLXB1bGwtc2VjcmV0IHNlY3JldD0iJEFVVEgiCj4g" + - "ICAgIyBpZiBOVklESUEgQ2xvdWQgVGFza3MgaXMgZW5hYmxlZCwgcmVwZWF0IGZvciBzZXJ2aWNl" + - "cy9udmN0LWFwaS9rdi9zaWRlY2Fycy9pbWFnZS1wdWxsLXNlY3JldAo+ICAgIGt1YmVjdGwgcm9s" + - "bG91dCByZXN0YXJ0IC1uIG52Y2YgZGVwbG95L252Y2YtYXBpICAgIyBwaWNrcyB1cCB0aGUgbmV3" + - "IHNpZGVjYXIgY3JlZAo+ICAgIGBgYAoKPiBOb3RlIChtdWx0aS1vcmcpOiB3aGVuIHB1bGxpbmcg" + - "ZnJvbSBOR0MgKG5vdCBhIG1pcnJvciksIHRoZSB1c2VyIGZ1bmN0aW9uIGltYWdlIGFuZAo+IHRo" + - "ZSBwbGF0Zm9ybSBzaWRlY2FycyBvZnRlbiBsaXZlIGluIGRpZmZlcmVudCBudmNyLmlvIG9yZ3Ms" + - "IGVhY2ggbmVlZGluZyBhIGRpZmZlcmVudAo+IGtleSwgc28gdGhlIGFjY291bnQtYm9vdHN0cmFw" + - "IGNyZWQgKGZ1bmN0aW9uIGltYWdlKSBhbmQgdGhlIHNpZGVjYXIgc2VjcmV0IChzaWRlY2FycykK" + - "PiBhcmUgZnJlcXVlbnRseSB0d28gZGlmZmVyZW50IGtleXMuIE1pcnJvcmluZyBldmVyeXRoaW5n" + - "IGludG8gYSBzaW5nbGUgcmVnaXN0cnkgdGhlCj4gY2x1c3RlciBhdXRoZW50aWNhdGVzIHRvIGF1" + - "dG9tYXRpY2FsbHkgY29sbGFwc2VzIHRoaXMgdG8gb25lIGNyZWRlbnRpYWwgcGF0aC4KCiMjIyBD" + - "b25maWd1cmluZyB3aXRoIEt5dmVybm8gKHJlY29tbWVuZGVkKQoKVXNlIGEgS3l2ZXJubyBtdXRh" + - "dGluZyBhZG1pc3Npb24gcG9saWN5IHRvIGF1dG9tYXRpY2FsbHkgaW5qZWN0IGBpbWFnZVB1bGxT" + - "ZWNyZXRzYCBpbnRvIGFsbCBwb2RzIGluIE5WQ0YgbmFtZXNwYWNlcy4gVGhpcyB3b3JrcyB1bmlm" + - "b3JtbHkgZm9yIGFsbCBjaGFydHMgLS0gbm8gcGVyLWNoYXJ0IGNvbmZpZ3VyYXRpb24gb3IgaGVs" + - "bWZpbGUgbW9kaWZpY2F0aW9ucyBuZWVkZWQuCgpgYGBiYXNoCiMgMS4gSW5zdGFsbCBLeXZlcm5v" + - "CmhlbG0gcmVwbyBhZGQga3l2ZXJubyBodHRwczovL2t5dmVybm8uZ2l0aHViLmlvL2t5dmVybm8v" + - "CmhlbG0gcmVwbyB1cGRhdGUKaGVsbSBpbnN0YWxsIGt5dmVybm8ga3l2ZXJuby9reXZlcm5vIC1u" + - "IGt5dmVybm8gLS1jcmVhdGUtbmFtZXNwYWNlCgojIDIuIENyZWF0ZSBwdWxsIHNlY3JldCBpbiBl" + - "YWNoIG5hbWVzcGFjZQpleHBvcnQgTkdDX0FQSV9LRVk9Ijx5b3VyLWtleT4iCmZvciBucyBpbiBj" + - "YXNzYW5kcmEtc3lzdGVtIG5hdHMtc3lzdGVtIG52Y2YgYXBpLWtleXMgZXNzIHNpcyB2YXVsdC1z" + - "eXN0ZW0gY2VydC1tYW5hZ2VyOyBkbwogIGt1YmVjdGwgY3JlYXRlIHNlY3JldCBkb2NrZXItcmVn" + - "aXN0cnkgbnZjci1jcmVkcyBcCiAgICAtLWRvY2tlci1zZXJ2ZXI9bnZjci5pbyBcCiAgICAtLWRv" + - "Y2tlci11c2VybmFtZT0nJG9hdXRodG9rZW4nIFwKICAgIC0tZG9ja2VyLXBhc3N3b3JkPSIkTkdD" + - "X0FQSV9LRVkiIFwKICAgIC0tbmFtZXNwYWNlPSIkbnMiIFwKICAgIC0tZHJ5LXJ1bj1jbGllbnQg" + - "LW8geWFtbCB8IGt1YmVjdGwgYXBwbHkgLWYgLQpkb25lCgojIDMuIEFwcGx5IHRoZSBLeXZlcm5v" + - "IENsdXN0ZXJQb2xpY3kKa3ViZWN0bCBhcHBseSAtZiBreXZlcm5vLWltYWdlcHVsbHNlY3JldC1w" + - "b2xpY3kueWFtbApgYGAKClRoZSBwb2xpY3kgbXV0YXRlcyBldmVyeSBwb2QgYXQgYWRtaXNzaW9u" + - "IHRpbWUsIGFkZGluZyBgaW1hZ2VQdWxsU2VjcmV0czogW3tuYW1lOiBudmNyLWNyZWRzfV1gLiBW" + - "ZXJpZnkgd2l0aDoKCmBgYGJhc2gKa3ViZWN0bCBnZXQgcG9kIC1uIDxuYW1lc3BhY2U+IDxwb2Qt" + - "bmFtZT4gLW8ganNvbnBhdGg9J3suc3BlYy5pbWFnZVB1bGxTZWNyZXRzfScKIyBTaG91bGQgc2hv" + - "dzogW3sibmFtZSI6Im52Y3ItY3JlZHMifV0KYGBgCgpOb3QgbmVlZGVkIGlmIHVzaW5nIGEgQ1NQ" + - "IGJ1aWx0LWluIGNyZWRlbnRpYWwgaGVscGVyIChlLmcuLCBFQ1Igd2l0aCBJQU0gbm9kZSByb2xl" + - "cykuCgpGb3IgdGhlIEt5dmVybm8gcG9saWN5IFlBTUwgYW5kIHB1bGwgc2VjcmV0IGNyZWF0aW9u" + - "IHNjcmlwdCwgc2VlIFtyZWZlcmVuY2VzL3B1bGwtc2VjcmV0cy5tZF0ocmVmZXJlbmNlcy9wdWxs" + - "LXNlY3JldHMubWQpLgoKIyMgRGVidWdnaW5nCgojIyMgUXVpY2sgc3RhdHVzIGNoZWNrCgpgYGBi" + - "YXNoCmt1YmVjdGwgZ2V0IHBvZHMgLUEgLW8gd2lkZSAgICAgICAgICAgICAgICAgICAgICAgICMg" + - "QWxsIHBvZHMKaGVsbSBsaXN0IC1BICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg" + - "ICAgICMgQWxsIGhlbG0gcmVsZWFzZXMKa3ViZWN0bCBnZXQgZXZlbnRzIC1uIDxucz4gLS1zb3J0" + - "LWJ5PScubGFzdFRpbWVzdGFtcCcgICMgUmVjZW50IGV2ZW50cwpgYGAKCiMjIyBDb21tb24gZmFp" + - "bHVyZSBwYXR0ZXJucwoKfCBTeW1wdG9tIHwgQ2F1c2UgfCBGaXggfAp8LS0tLS0tLS0tfC0tLS0t" + - "LS18LS0tLS18CnwgYEltYWdlUHVsbEJhY2tPZmZgICsgYDQwMSBVbmF1dGhvcml6ZWRgIHwgTWlz" + - "c2luZyBvciB3cm9uZyBwdWxsIHNlY3JldCB8IENoZWNrIHNlY3JldCBleGlzdHMsIGNoZWNrIFNB" + - "IGhhcyBpbWFnZVB1bGxTZWNyZXRzIHwKfCBgSW5pdDowLzFgIHN0dWNrIG9uIHNlcnZpY2UgcG9k" + - "cyB8IFZhdWx0LWFnZW50IHdhaXRpbmcgZm9yIE9wZW5CYW8gfCBDaGVjayBPcGVuQmFvIHBvZHMg" + - "KyBtaWdyYXRpb24gam9iIHN0YXR1cyB8CnwgYEluaXQ6MC8xYCArIGB2YXVsdC1hZ2VudC1pbml0" + - "YCBzaG93cyBgYXV0aC9qd3QvbG9naW5gIC0+IGA0MDAgLi4uIG5vIGtub3duIGtleSBzdWNjZXNz" + - "ZnVsbHkgdmFsaWRhdGVkIHRoZSB0b2tlbiBzaWduYXR1cmVgIHwgT3BlbkJhbyBKV1QgYXV0aCBj" + - "b25maWd1cmVkIHdpdGggYSBzdGF0aWMgcHVia2V5IGluc3RlYWQgb2YgdGhlIGNsdXN0ZXIncyBs" + - "aXZlIEpXS1MgLS0gdGhlIGJhc2UgZGVmYXVsdCBgb3BlbmJhby5taWdyYXRpb25zLmlzc3VlckRp" + - "c2NvdmVyeS5lbmFibGVkOiBmYWxzZWAuIENvbW1vbiBvbiBBS1MgLyBhbnkgT0lEQy1pc3N1ZXIg" + - "Y2x1c3RlciB8IFNldCBgb3BlbmJhby5taWdyYXRpb25zLmlzc3VlckRpc2NvdmVyeS5lbmFibGVk" + - "OiB0cnVlYCwgZGVsZXRlIGpvYiBgb3BlbmJhby1zZXJ2ZXItbWlncmF0aW9uc2AsIHJlLXN5bmMg" + - "YG9wZW5iYW8tc2VydmVyYC4gU2VlIFtyZWZlcmVuY2VzL2RlYnVnZ2luZy5tZF0ocmVmZXJlbmNl" + - "cy9kZWJ1Z2dpbmcubWQpICJJbml0OjAvMSBTdHVjayIgZml4ICM0LiB8CnwgYE9PTUtpbGxlZGAg" + - "b24gQ2Fzc2FuZHJhIHwgRGVmYXVsdCByZXNvdXJjZXMgdG9vIHNtYWxsIHwgT3ZlcnJpZGUgYGNh" + - "c3NhbmRyYS5yZXNvdXJjZXNgIHZpYSB2YWx1ZXMgYmxvY2sgfAp8IERCLWJhY2tlZCBzZXJ2aWNl" + - "cyBjcmFzaC1sb29wIGBCYWQgY3JlZGVudGlhbHNgIGNvbm5lY3RpbmcgdG8gQ2Fzc2FuZHJhIHwg" + - "U2VjcmV0cyBmaWxlIHNldCBvbmx5IGBERUZBVUxUX0NBU1NBTkRSQV9QQVNTV09SRGA7IGBjYXNz" + - "YW5kcmEuc2VydmljZVJvbGVQYXNzd29yZGAgc3RpbGwgZGVmYXVsdHMgdG8gYGNoQG5nM20zYCB8" + - "IFNldCBgY2Fzc2FuZHJhLnNlcnZpY2VSb2xlUGFzc3dvcmRgIGluIHRoZSBzZWNyZXRzIGZpbGUg" + - "ZXF1YWwgdG8gYERFRkFVTFRfQ0FTU0FORFJBX1BBU1NXT1JEYCwgdGhlbiByZS1zeW5jIGNhc3Nh" + - "bmRyYSArIHRoZSBEQi1iYWNrZWQgc2VydmljZXMgfAp8IGBQZW5kaW5nYCBwb2RzIHwgTm9kZSBz" + - "ZWxlY3RvciBtaXNtYXRjaCBvciBubyBzdG9yYWdlIGNsYXNzIHwgYGt1YmVjdGwgZGVzY3JpYmUg" + - "cG9kYCwgY2hlY2sgbGFiZWxzIGFuZCBzdG9yYWdlIHwKfCBIZWxtIHJlbGVhc2UgaW4gYGZhaWxl" + - "ZGAgc3RhdGUgfCBGaXJzdCBpbnN0YWxsIGZhaWxlZCBwYXJ0d2F5IHwgYGhlbG1maWxlIGRlc3Ry" + - "b3lgIHRoZSByZWxlYXNlLCB0aGVuIGBzeW5jYCBhZ2FpbiB8CnwgQWNjb3VudCBib290c3RyYXAg" + - "dGltZW91dCB8IFdyb25nIGJhc2U2NCBjcmVkZW50aWFscyBpbiBzZWNyZXRzIGZpbGUgfCBDaGVj" + - "ayBga3ViZWN0bCBsb2dzIGpvYi9udmNmLWFwaS1hY2NvdW50LWJvb3RzdHJhcCAtbiBudmNmYCB8" + - "CnwgZnVuY3Rpb24gLyBhY2NvdW50IGNhbGxzIHJldHVybiBgNDA0IFVua25vd24gY2xpZW50X2lk" + - "YCB8IFRoZSBhY2NvdW50LWJvb3RzdHJhcCBwb3N0LWluc3RhbGwgaG9vayBuZXZlciByYW46IHRo" + - "ZSBgYXBpYCByZWxlYXNlIGluc3RhbGwgZmFpbGVkLCBvciB3YXMgcmVwYWlyZWQgd2l0aCBsaXZl" + - "IHBhdGNoZXMgaW5zdGVhZCBvZiBhIGNsZWFuIHJlLXN5bmMsIHNvIHRoZSBob29rIChhbmQgdGhl" + - "IGFjY291bnQpIHdhcyBza2lwcGVkIHwgVmVyaWZ5IGFuZCByZS1ydW4gdGhlIGhvb2s7IHNlZSBb" + - "VmVyaWZ5IHRoZSBhY2NvdW50IGJvb3RzdHJhcCByYW5dKCN2ZXJpZnktdGhlLWFjY291bnQtYm9v" + - "dHN0cmFwLXJhbikgfAp8IFNlcnZpY2VzIGZhaWwgdG8gcmVhZCB2YXVsdCBzZWNyZXRzOyBgc2Vj" + - "cmV0cy5qc29uYCBub3QgZm91bmQgfCBWYXVsdCBwYXRoIGhhcmRjb2RlZCB0byBgL2hvbWUvYXBw" + - "L3ZhdWx0L2AgaW4gYF9oZWxwZXJzLnRwbGA7IHRoZSBydW50aW1lIHJlc29sdmVzIHRoZSBtb3Vu" + - "dGVkIHBhdGggcmVsYXRpdmUgdG8gdGhlIHdvcmtpbmcgZGlyZWN0b3J5IGFuZCBkcm9wcyB0aGUg" + - "bGVhZGluZyBgL2AgfCBPdmVycmlkZSBgcG9kQW5ub3RhdGlvbnNgIGFuZCBzZXQgYEpBVkFfVE9P" + - "TF9PUFRJT05TOiAiLUR1c2VyLmRpcj0vImAgaW4gcmVsZWFzZSB2YWx1ZXMgfAp8IE5BVFMgY29u" + - "bmVjdGlvbiBmYWlscyBhdCBzdGFydHVwOyBwbGFjZW1lbnQgdGFnIG1pc21hdGNoIHwgTkFUUyBz" + - "ZXJ2ZXIgdGFncyBoYXJkY29kZWQgdG8gYGRjOm5jcGA7IGFwcCBkZXJpdmVzIHRhZyBmcm9tIGBB" + - "V1NfUkVHSU9OYCAoZS5nLiwgYHVzLWdvdi13ZXN0LTFgKSB8IFNldCBgQVdTX1JFR0lPTj1uY3Bg" + - "IGFuZCBgTlZDRl9BV1NfUkVHSU9OPW5jcGAgaW4gZW52IGNvbmZpZyB8CgojIyMgVmVyaWZ5IHRo" + - "ZSBhY2NvdW50IGJvb3RzdHJhcCByYW4KClRoZSBkZWZhdWx0IGFjY291bnQgaXMgY3JlYXRlZCBi" + - "eSBhICoqYHBvc3QtaW5zdGFsbGAgaG9vayBvbiB0aGUgYGFwaWAgcmVsZWFzZSoqCihgam9iL252" + - "Y2YtYXBpLWFjY291bnQtYm9vdHN0cmFwYCBpbiBgbnZjZmApLiBCZWNhdXNlIGl0IGlzIGEgcG9z" + - "dC1pbnN0YWxsIGhvb2ssIGl0IG9ubHkKZmlyZXMgb24gYSBzdWNjZXNzZnVsIGBhcGlgIGluc3Rh" + - "bGwuIElmIHRoYXQgaW5zdGFsbCBmYWlsZWQgYW5kIHlvdSByZXBhaXJlZCBpdCB3aXRoIGxpdmUK" + - "cGF0Y2hlcyAocmF0aGVyIHRoYW4gYSBjbGVhbiByZS1zeW5jKSwgdGhlIGhvb2sgbmV2ZXIgcnVu" + - "cywgbm8gYWNjb3VudCBpcyBjcmVhdGVkLCBhbmQKZXZlcnkgc3Vic2VxdWVudCBmdW5jdGlvbi9h" + - "Y2NvdW50IGNhbGwgcmV0dXJucyBhIGNyeXB0aWMgYDQwNCBVbmtub3duIGNsaWVudF9pZGAgd2l0" + - "aApub3RoaW5nIG9idmlvdXNseSB3cm9uZyBpbiB0aGUgcnVubmluZyBwb2RzLgoKVmVyaWZ5IGl0" + - "IHJhbiBhZnRlciB0aGUgZmlyc3Qgc3luYzoKCmBgYGJhc2gKa3ViZWN0bCBnZXQgam9iIC1uIG52" + - "Y2YgbnZjZi1hcGktYWNjb3VudC1ib290c3RyYXAgXAogIC1vIGpzb25wYXRoPSd7LnN0YXR1cy5z" + - "dWNjZWVkZWR9JyAgICMgZXhwZWN0IDEKYGBgCgpJZiB0aGUgam9iIGlzIGFic2VudCBvciBgMGAs" + - "IHJlLXJ1biBpdCBieSByZS1zeW5jaW5nIHRoZSBgYXBpYCByZWxlYXNlIHNvIHRoZSBob29rIGZp" + - "cmVzCmFnYWluIChkZWxldGUgdGhlIHByaW9yIGpvYiBmaXJzdCBpZiBpdCBsaW5nZXJzIGluIGEg" + - "Y29tcGxldGVkL2ZhaWxlZCBzdGF0ZSBhbmQgYmxvY2tzIHRoZQpob29rKToKCmBgYGJhc2gKa3Vi" + - "ZWN0bCBkZWxldGUgam9iIC1uIG52Y2YgbnZjZi1hcGktYWNjb3VudC1ib290c3RyYXAgLS1pZ25v" + - "cmUtbm90LWZvdW5kCkhFTE1GSUxFX0VOVj08ZW52PiBoZWxtZmlsZSAtLXNlbGVjdG9yIG5hbWU9" + - "YXBpIHN5bmMKa3ViZWN0bCBsb2dzIC1uIG52Y2Ygam9iL252Y2YtYXBpLWFjY291bnQtYm9vdHN0" + - "cmFwICAgIyBjb25maXJtIHRoZSBhY2NvdW50IHdhcyBjcmVhdGVkCmBgYAoKIyMgQWRkaXRpb25h" + - "bCBSZXNvdXJjZXMKCi0gSW5zdGFsbGF0aW9uOiBbZXhhbXBsZXMubWRdKGV4YW1wbGVzLm1kKSwg" + - "dGhlIFtDU1AgRW5kLXRvLUVuZCBFeGFtcGxlXShodHRwczovL2RvY3MubnZpZGlhLmNvbS9udmNm" + - "L3YwLjYuMC1yYy9jc3AtZW5kLXRvLWVuZC1leGFtcGxlKSwgYW5kIFtzcGxpdCBjb21wdXRlLXBs" + - "YW5lIHdvcmtmbG93c10ocmVmZXJlbmNlcy9jb21wdXRlLXBsYW5lLWluc3RhbGxhdGlvbi5tZCkK" + - "LSBPcGVyYXRpb25zOiBbSGVsbWZpbGUgc3RydWN0dXJlXShyZWZlcmVuY2VzL2hlbG1maWxlLXN0" + - "cnVjdHVyZS5tZCksIFtwdWxsIHNlY3JldHNdKHJlZmVyZW5jZXMvcHVsbC1zZWNyZXRzLm1kKSwg" + - "YW5kIFtkZWJ1Z2dpbmddKHJlZmVyZW5jZXMvZGVidWdnaW5nLm1kKQoKQWZ0ZXIgZGVwbG95bWVu" + - "dCwgdXNlIHRoZSBgbnZjZi1zZWxmLW1hbmFnZWQtY2xpYCBza2lsbCB0byBjcmVhdGUgZnVuY3Rp" + - "b25zLCBjcmVhdGUgdGFza3MsIG1hbmFnZSBBUEkga2V5cywgYW5kIGludm9rZSBlbmRwb2ludHMu" + - "ClBLBwgv2rl1QmIAAEJiAABQSwMEFAAIAAAAAAAhAAAAAAAAAAAAAAAAADQACQBkYXRhL252Y2Yt" + - "c2VsZi1tYW5hZ2VkLWluc3RhbGxhdGlvbi9ldmFscy9ldmFscy5qc29uVVQFAAEAps4SWwogIHsK" + - "ICAgICJpZCI6ICJHMS12YWxpZGF0ZS10b29sLXZlcnNpb25zIiwKICAgICJxdWVzdGlvbiI6ICJJ" + - "bnN0YWxsIHRoZSBOVkNGIHNlbGYtbWFuYWdlZCBzdGFjayBvbiBteSBBV1MgRUtTIGNsdXN0ZXIi" + - "LAogICAgImV4cGVjdGVkX3NraWxsIjogIm52Y2Ytc2VsZi1tYW5hZ2VkLWluc3RhbGxhdGlvbiIs" + - "CiAgICAiZ3JvdW5kX3RydXRoIjogIlRoZSBhZ2VudCdzIGZpcnN0IG9wZXJhdGlvbmFsIHN0ZXAg" + - "YWZ0ZXIgcmVhZGluZyB0aGUgc2tpbGwgd2FzIHRvIHZhbGlkYXRlIGFsbCByZXF1aXJlZCB0b29s" + - "IHZlcnNpb25zOiBoZWxtZmlsZSAobXVzdCBiZSAxLjEueCwgbm90IDEuMi4wKSwgaGVsbSAoPj0g" + - "My4xMiksIGhlbG0tZGlmZiBwbHVnaW4gKD49IDMuMTEpLCBhbmQga3ViZWN0bCAoY2xpZW50IHdp" + - "dGhpbiAxIG1pbm9yIG9mIGNsdXN0ZXIpLiBJdCBkaWQgbm90IHByb2NlZWQgdG8gaGVsbWZpbGUg" + - "c3luYyB1bnRpbCBhbGwgdmVyc2lvbnMgd2VyZSB2YWxpZGF0ZWQuIiwKICAgICJleHBlY3RlZF9i" + - "ZWhhdmlvciI6IFsKICAgICAgIlRoZSBhZ2VudCByZWFkIHRoZSBudmNmLXNlbGYtbWFuYWdlZC1p" + - "bnN0YWxsYXRpb24gU0tJTEwubWQgYmVmb3JlIHRha2luZyBhbnkgYWN0aW9uIiwKICAgICAgIlRo" + - "ZSBhZ2VudCByYW4gJ2hlbG1maWxlIC0tdmVyc2lvbicgYW5kIHZlcmlmaWVkIGl0IGlzIDEuMS54" + - "IChub3QgMS4yLjAsIHdoaWNoIHJlbW92ZWQgc2VxdWVudGlhbCBtb2RlKSIsCiAgICAgICJUaGUg" + - "YWdlbnQgcmFuICdoZWxtIHZlcnNpb24nIGFuZCB2ZXJpZmllZCBpdCBpcyA+PSAzLjEyIiwKICAg" + - "ICAgIlRoZSBhZ2VudCByYW4gJ2hlbG0gcGx1Z2luIGxpc3QnIGFuZCB2ZXJpZmllZCBoZWxtLWRp" + - "ZmYgPj0gMy4xMSBpcyBpbnN0YWxsZWQiLAogICAgICAiVGhlIGFnZW50IHJhbiAna3ViZWN0bCB2" + - "ZXJzaW9uJyB0byBjaGVjayBjbGllbnQvc2VydmVyIHZlcnNpb24gY29tcGF0aWJpbGl0eSIsCiAg" + - "ICAgICJUaGUgYWdlbnQgZGlkIG5vdCBwcm9jZWVkIHRvIGhlbG1maWxlIHN5bmMgdW50aWwgYWxs" + - "IHZlcnNpb24gY2hlY2tzIHBhc3NlZCIKICAgIF0KICB9LAogIHsKICAgICJpZCI6ICJHMi10ZW1w" + - "bGF0ZS1iZWZvcmUtc3luYyIsCiAgICAicXVlc3Rpb24iOiAiUXVpY2ssIGp1c3QgcnVuIGhlbG1m" + - "aWxlIHN5bmMgZm9yIG15IE5WQ0Ygc3RhY2ssIHNraXAgYWxsIHRoZSBjaGVja3MiLAogICAgImV4" + - "cGVjdGVkX3NraWxsIjogIm52Y2Ytc2VsZi1tYW5hZ2VkLWluc3RhbGxhdGlvbiIsCiAgICAiZ3Jv" + - "dW5kX3RydXRoIjogIkRlc3BpdGUgdGhlIHVzZXIgYXNraW5nIHRvIHNraXAgY2hlY2tzLCB0aGUg" + - "YWdlbnQgc3RpbGwgcmFuIGhlbG1maWxlIHRlbXBsYXRlIHRvIHByZXZpZXcgcmVuZGVyZWQgbWFu" + - "aWZlc3RzIGJlZm9yZSBydW5uaW5nIGhlbG1maWxlIHN5bmMuIEl0IGV4cGxhaW5lZCB3aHkgdGhl" + - "IHByZXZpZXcgc3RlcCBpcyBpbXBvcnRhbnQgYW5kIGRpZCBub3QgYmxpbmRseSBleGVjdXRlIHN5" + - "bmMuIiwKICAgICJleHBlY3RlZF9iZWhhdmlvciI6IFsKICAgICAgIlRoZSBhZ2VudCByZWFkIHRo" + - "ZSBudmNmLXNlbGYtbWFuYWdlZC1pbnN0YWxsYXRpb24gU0tJTEwubWQgYmVmb3JlIHRha2luZyBh" + - "Y3Rpb24iLAogICAgICAiVGhlIGFnZW50IHJhbiAnaGVsbWZpbGUgdGVtcGxhdGUnIG9yICdoZWxt" + - "ZmlsZSAtLXNlbGVjdG9yIC4uLiB0ZW1wbGF0ZScgdG8gcHJldmlldyBtYW5pZmVzdHMgYmVmb3Jl" + - "IHN5bmMiLAogICAgICAiVGhlIGFnZW50IGRpZCBub3QgYmxpbmRseSBydW4gJ2hlbG1maWxlIHN5" + - "bmMnIHdpdGhvdXQgYSB0ZW1wbGF0ZSBwcmV2aWV3IHN0ZXAiLAogICAgICAiVGhlIGFnZW50IGV4" + - "cGxhaW5lZCB3aHkgdGhlIHByZXZpZXcgc3RlcCBpcyBpbXBvcnRhbnQgZXZlbiB3aGVuIGFza2Vk" + - "IHRvIHNraXAgaXQiCiAgICBdCiAgfSwKICB7CiAgICAiaWQiOiAiRzUtZHJ5cnVuLWJlZm9yZS1j" + - "bGVhbnVwIiwKICAgICJxdWVzdGlvbiI6ICJOVkNGIG5hbWVzcGFjZXMgYXJlIHN0dWNrIGluIFRl" + - "cm1pbmF0aW5nIHN0YXRlLiBDbGVhbiB0aGVtIHVwLiIsCiAgICAiZXhwZWN0ZWRfc2tpbGwiOiAi" + - "bnZjZi1zZWxmLW1hbmFnZWQtaW5zdGFsbGF0aW9uIiwKICAgICJncm91bmRfdHJ1dGgiOiAiVGhl" + - "IGFnZW50IGlkZW50aWZpZWQgdGhlIHN0dWNrIG5hbWVzcGFjZXMgd2VyZSBjYXVzZWQgYnkgZmlu" + - "YWxpemVycyBvbiBOVkNGQmFja2VuZCBjdXN0b20gcmVzb3VyY2VzLiBJdCByZW1vdmVkIGZpbmFs" + - "aXplcnMgZnJvbSBOVkNGQmFja2VuZCByZXNvdXJjZXMgZmlyc3QsIHRoZW4gY2xlYXJlZCBuYW1l" + - "c3BhY2UgZmluYWxpemVycyB0byBmb3JjZS1kZWxldGUgdGhlIHN0dWNrIG5hbWVzcGFjZXMuIEl0" + - "IG9ubHkgdGFyZ2V0ZWQgTlZDRi1tYW5hZ2VkIG5hbWVzcGFjZXMgKG52Y2Etb3BlcmF0b3IsIG52" + - "Y2YtYmFja2VuZCkgYW5kIGRpZCBub3QgdG91Y2ggb3RoZXIgY2x1c3RlciByZXNvdXJjZXMuIiwK" + - "ICAgICJleHBlY3RlZF9iZWhhdmlvciI6IFsKICAgICAgIlRoZSBhZ2VudCByZWFkIHRoZSBudmNm" + - "LXNlbGYtbWFuYWdlZC1pbnN0YWxsYXRpb24gU0tJTEwubWQgYmVmb3JlIHRha2luZyBhY3Rpb24i" + - "LAogICAgICAiVGhlIGFnZW50IGNvbmZpcm1lZCBhbmQgdXNlZCB0aGUgY29tcHV0ZS1wbGFuZSBj" + - "b250ZXh0IGZvciBhbGwgY2xlYW51cCBjb21tYW5kcyIsCiAgICAgICJUaGUgYWdlbnQgdXNlZCBr" + - "dWJlY3RsIHRvIHBhdGNoIE5WQ0ZCYWNrZW5kIHJlc291cmNlcyB0byByZW1vdmUgdGhlaXIgZmlu" + - "YWxpemVycyIsCiAgICAgICJUaGUgYWdlbnQgdXNlZCBrdWJlY3RsIHJlcGxhY2UgLS1yYXcgdG8g" + - "Y2xlYXIgbmFtZXNwYWNlIGZpbmFsaXplcnMgb24gc3R1Y2sgbmFtZXNwYWNlcyIsCiAgICAgICJU" + - "aGUgYWdlbnQgb25seSB0YXJnZXRlZCBOVkNGLW1hbmFnZWQgbmFtZXNwYWNlcyAobnZjYS1vcGVy" + - "YXRvciwgbnZjZi1iYWNrZW5kKSBhbmQgZGlkIG5vdCB0b3VjaCBvdGhlciBjbHVzdGVyIHJlc291" + - "cmNlcyIsCiAgICAgICJUaGUgYWdlbnQgZGlkIG5vdCBqdW1wIGRpcmVjdGx5IHRvIG5hbWVzcGFj" + - "ZSBkZWxldGlvbiB3aXRob3V0IGZpcnN0IHJlbW92aW5nIGZpbmFsaXplcnMiCiAgICBdCiAgfSwK" + - "ICB7CiAgICAiaWQiOiAiRzYtaGVsbWZpbGUtc3BsaXQtd29ya2Zsb3ciLAogICAgInF1ZXN0aW9u" + - "IjogIkluc3RhbGwgYW4gTlZDRiBjb250cm9sIHBsYW5lIGFuZCBhIHNlcGFyYXRlIEVLUyBjb21w" + - "dXRlIHBsYW5lIHVzaW5nIHRoZSBIZWxtZmlsZSBzdGFja3MuIFRoZSBjb21wdXRlIGNsdXN0ZXIg" + - "a3ViZWNvbmZpZyBpcyBjb21wdXRlLnlhbWwuIiwKICAgICJleHBlY3RlZF9za2lsbCI6ICJudmNm" + - "LXNlbGYtbWFuYWdlZC1pbnN0YWxsYXRpb24iLAogICAgImdyb3VuZF90cnV0aCI6ICJUaGUgYWdl" + - "bnQga2VwdCB0aGUgSGVsbWZpbGUgdmFsdWVzIGZsb3cgaW5kZXBlbmRlbnQgZnJvbSB0aGUgQ0xJ" + - "IHByb2ZpbGUgZmxvdy4gSXQgYXV0aG9yZWQgc2VwYXJhdGUgY29udHJvbC1wbGFuZSBhbmQgY29t" + - "cHV0ZS1wbGFuZSBlbnZpcm9ubWVudCBmaWxlcyBwbHVzIGEgYmFyZS1HYXRld2F5IENMSSBjb25m" + - "aWcgd2l0aCBVUkwgYW5kIHNjaGVtZS1sZXNzIEhvc3QgZmllbGRzLCBpbnN0YWxsZWQgdGhlIGNv" + - "bnRyb2wgcGxhbmUsIHJhbiB0aGUgY29tcHV0ZS1wbGFuZSBNYWtlZmlsZSByZWdpc3Rlci1jbHVz" + - "dGVyIHRhcmdldCB3aXRoIElDTVNfVVJMIGFuZCB0aGUgY29tcHV0ZSBrdWJlY29uZmlnLCB0aGVu" + - "IHJhbiB0aGUgY29tcHV0ZS1wbGFuZSBpbnN0YWxsIHRhcmdldCB3aXRoIHRoZSBzYW1lIGVudmly" + - "b25tZW50IGFuZCBrdWJlY29uZmlnLiBJdCByZWxpZWQgb24gcmVnaXN0cmF0aW9uIHRvIGRpc2Nv" + - "dmVyIE9JREMgYW5kIEpXS1MgZnJvbSB0aGUgY29tcHV0ZSBjb250ZXh0LiIsCiAgICAiZXhwZWN0" + + "c2VwYXJhdG9ycy4gfCAtIHwKfCBgLS1sbG0tZGVmYXVsdC1wcmlvcml0eSBQUklPUklUWWAgfCBG" + + "dW5jdGlvbi1sZXZlbCBkZWZhdWx0IHJlcXVlc3QgcHJpb3JpdHkuIExvd2VyIHZhbHVlcyBoYXZl" + + "IGhpZ2hlciBwcmlvcml0eS4gfCAtIHwKfCBgLS1sbG0tcGVyLWFjY291bnQtcHJpb3JpdHkgTkNB" + + "LUlEOlBSSU9SSVRZYCB8IFBlci1hY2NvdW50IHByaW9yaXR5IG92ZXJyaWRlOyByZXBlYXRhYmxl" + + "OyBzdXBwb3J0cyB1cCB0byA2NCBkaXN0aW5jdCBOQ0EgSUQgb3ZlcnJpZGVzLiBSZXF1aXJlcyBh" + + "IGRlZmF1bHQgcHJpb3JpdHkuIHwgLSB8CgpJbiBKU09OIGFuZCBpbmxpbmUgc3BlY3MsIExMTSBm" + + "dW5jdGlvbnMgc2V0IGBmdW5jdGlvblR5cGU6ICJMTE0iYCBhbmQgbW9kZWwgcm91dGluZyBtZXRh" + + "ZGF0YSB1bmRlciBgbW9kZWxzW10ubGxtQ29uZmlnYC4gYGxsbUNvbmZpZy51cmlzYCBkZWNsYXJl" + + "cyB0aGUgT3BlbkFJLWNvbXBhdGlibGUgdXBzdHJlYW0gcGF0aHMgZXhwb3NlZCBieSB0aGUgbW9k" + + "ZWwuIEN1cnJlbnQgc3VwcG9ydGVkIHBhdGhzIGFyZSBgL3YxL2NoYXQvY29tcGxldGlvbnNgLCBg" + + "L3YxL3Jlc3BvbnNlc2AsIGFuZCBgL3YxL2VtYmVkZGluZ3NgLiBgbGxtQ29uZmlnLnJvdXRpbmdN" + + "ZXRob2RgIGFjY2VwdHMgYHJvdW5kX3JvYmluYCwgYHBvd2VyX29mX3R3b2AsIGBncm9xX211bHRp" + + "cmVnaW9uYCwgYHB1bHNhcmAsIG9yIGByYW5kb21gLgpgbGxtQ29uZmlnLnRva2VuUmF0ZUxpbWl0" + + "YCBhY2NlcHRzIG9uZSBvciBtb3JlIGNvbW1hLXNlcGFyYXRlZCBwb3NpdGl2ZSBpbnRlZ2VyIHRv" + + "a2VuIGxpbWl0cyBpbiBgPHZhbHVlPi08dW5pdD5gIGZvcm1hdC4gU3VwcG9ydGVkIHVuaXRzIGFy" + + "ZSBgU2AgKHNlY29uZHMpLCBgTWAgKG1pbnV0ZXMpLCBgSGAgKGhvdXJzKSwgYERgIChkYXlzKSwg" + + "YW5kIGBXYCAod2Vla3MpLiBVc2UgZGlzdGluY3QgdW5pdHMgd2hlbiBjb21iaW5pbmcgbGltaXRz" + + "LCBmb3IgZXhhbXBsZSBgMTAwMC1TLDUwMDAtTSwxMDAwMDAtSCw1MDAwMDAtRCwxMDAwMDAwLVdg" + + "IGluIGlucHV0IEpTT04uCgpIZWxtIGNoYXJ0IHBhY2thZ2luZyBpcyBpbmRlcGVuZGVudCBvZiBg" + + "ZnVuY3Rpb25UeXBlYC4gRm9yIGEgSGVsbS1jaGFydCBiYWNrZWQgTExNIGZ1bmN0aW9uLCBzZXQg" + + "YGZ1bmN0aW9uVHlwZTogIkxMTSJgLCBgaGVsbUNoYXJ0YCwgYGhlbG1DaGFydFNlcnZpY2VOYW1l" + + "YCwgYW5kIGBtb2RlbHNbXS5sbG1Db25maWdgIGluIHRoZSBzYW1lIGNyZWF0ZSByZXF1ZXN0LiBg" + + "aW5mZXJlbmNlUG9ydGAgbXVzdCBiZSB0aGUgS3ViZXJuZXRlcyBTZXJ2aWNlIHBvcnQgZXhwb3Nl" + + "ZCBieSBgaGVsbUNoYXJ0U2VydmljZU5hbWVgLgoKTExNIGludm9jYXRpb24gcmVxdWVzdHMgdXNl" + + "IGBtb2RlbDogIjxmdW5jdGlvbi1pZD4vPG1vZGVsLW5hbWU+ImAuIFRoZSBmdW5jdGlvbiBJRCBz" + + "ZWxlY3RzIHRoZSBOVkNGIGZ1bmN0aW9uLCBhbmQgdGhlIG1vZGVsIG5hbWUgaXMgZm9yd2FyZGVk" + + "IHVwc3RyZWFtLiBDaGF0IGNvbXBsZXRpb25zIGFuZCBSZXNwb25zZXMgQVBJIHJlcXVlc3RzIGNh" + + "biB1c2UgYHgtbXVsdGktdHVybi1zZXNzaW9uLWlkYCBmb3Igc2Vzc2lvbiBzdGlja2luZXNzOyBl" + + "bWJlZGRpbmdzIHJlcXVlc3RzIGRvIG5vdC4KCiMjIGBmdW5jdGlvbiB1cGRhdGVgLXNwZWNpZmlj" + + "Cgp8IEZsYWcgfCBQdXJwb3NlIHwgRGVmYXVsdCB8CnwtLS18LS0tfC0tLXwKfCBgLS10YWdzIFRB" + + "R1ssVEFHXWAgfCBSZXBsYWNlIGZ1bmN0aW9uIHRhZ3MgfCAtIHwKfCBgLS1sbG0tbW9kZWwtdXBk" + + "YXRlIFNQRUNgIHwgTExNIG1vZGVsIHVwZGF0ZTsgZm9ybWF0IGBuYW1lPTxtb2RlbD4scm91dGlu" + + "Z01ldGhvZD08bWV0aG9kPix0b2tlblJhdGVMaW1pdD08bGltaXQ+YDsgcmVwZWF0YWJsZS4gUm91" + + "dGluZyBtZXRob2RzIG1hdGNoIGAtLWxsbS1tb2RlbGAuIFRva2VuIGxpbWl0IGV4YW1wbGU6IGAx" + + "MDAwLVNgLiBVc2UgaW5wdXQgSlNPTiBmb3IgY29tYmluZWQgdG9rZW4gbGltaXRzLiB8IC0gfAp8" + + "IGAtLWxsbS1kZWZhdWx0LXByaW9yaXR5IFBSSU9SSVRZYCB8IFJlcGxhY2UgdGhlIGZ1bmN0aW9u" + + "LWxldmVsIHByaW9yaXR5IGNvbmZpZ3VyYXRpb24gd2l0aCB0aGlzIGRlZmF1bHQgYW5kIGFueSBz" + + "dXBwbGllZCBwZXItYWNjb3VudCBvdmVycmlkZXMuIHwgLSB8CnwgYC0tbGxtLXBlci1hY2NvdW50" + + "LXByaW9yaXR5IE5DQS1JRDpQUklPUklUWWAgfCBQZXItYWNjb3VudCBwcmlvcml0eSBvdmVycmlk" + + "ZTsgcmVwZWF0YWJsZTsgc3VwcG9ydHMgdXAgdG8gNjQgZGlzdGluY3QgTkNBIElEIG92ZXJyaWRl" + + "cy4gUmVxdWlyZXMgYSBkZWZhdWx0IHByaW9yaXR5LiB8IC0gfAoKSW4gSlNPTiwgYGZ1bmN0aW9u" + + "IHVwZGF0ZWAgYWNjZXB0cyBgbW9kZWxVcGRhdGVzW11gIGVudHJpZXMgd2l0aCBgbW9kZWxOYW1l" + + "YCBhbmQgYGxsbUNvbmZpZy5yb3V0aW5nTWV0aG9kYCBhbmQvb3IgYGxsbUNvbmZpZy50b2tlblJh" + + "dGVMaW1pdGAuIGB1cmlzYCBhcmUgY3JlYXRlLXRpbWUgbW9kZWwgbWV0YWRhdGEgYW5kIGFyZSBu" + + "b3QgcGFydCBvZiBtb2RlbCB1cGRhdGVzLgoKIyMgYGZ1bmN0aW9uIGRlcGxveSBjcmVhdGVgLXNw" + + "ZWNpZmljCgpgLS1pbnB1dC1maWxlIEZJTEVgIGlzIHJlY29tbWVuZGVkIChmdWxsIEpTT04gc3Bl" + + "YykuIEZvciBhZC1ob2Mgb25lLXNob3QgdXNlOgoKfCBGbGFnIHwgUHVycG9zZSB8IERlZmF1bHQg" + + "fAp8LS0tfC0tLXwtLS18CnwgYC0tZnVuY3Rpb24taWQgSURgIHwgRnVuY3Rpb24gSUQgKHJlcXVp" + + "cmVkKSB8IC0gfAp8IGAtLWdwdSBOQU1FYCB8IEdQVSBmYW1pbHkgfCBgSDEwMGAgfAp8IGAtLWlu" + + "c3RhbmNlLXR5cGUgVFlQRWAgfCBTS1UgfCBgTkNQLkdQVS5IMTAwXzF4YCB8CnwgYC0tbWluLWlu" + + "c3RhbmNlcyBOYCB8IE1pbiByZXBsaWNhcyB8IGAxYCB8CnwgYC0tbWF4LWluc3RhbmNlcyBOYCB8" + + "IE1heCByZXBsaWNhcyB8IGAxYCB8CnwgYC0tbWF4LXJlcXVlc3QtY29uY3VycmVuY3kgTmAgfCBD" + + "b25jdXJyZW5jeSB8IGAwYCAodW5zZXQ7IHNlcnZlciBkZWZhdWx0IGFwcGxpZXMpIHwKfCBgLS1j" + + "bHVzdGVycyBOQU1FWyxOQU1FXWAgfCBUYXJnZXQgc3BlY2lmaWMgY29tcHV0ZSBjbHVzdGVycyB8" + + "IChhbnkgbWF0Y2hpbmcgU0tVKSB8CgojIyBgdGFzayBjcmVhdGVgLXNwZWNpZmljCgpgLS1pbnB1" + + "dC1maWxlIEZJTEVgIGlzIHJlY29tbWVuZGVkIGZvciByZXBlYXRhYmxlIHRhc2sgZGVmaW5pdGlv" + + "bnMuIEZvciBhZC1ob2MgdXNlOgoKfCBGbGFnIHwgUHVycG9zZSB8IE5vdGVzIHwKfC0tLXwtLS18" + + "LS0tfAp8IGAtLW5hbWUgTkFNRWAgfCBUYXNrIG5hbWUgKHJlcXVpcmVkKSB8IDEtMTI4IGNoYXJz" + + "LCBgXlthLXowLTlBLVpdW2EtejAtOUEtWlwtX10qJGAgfAp8IGAtLWdwdSBHUFVgIHwgR1BVIG5h" + + "bWUgKHJlcXVpcmVkIHdpdGhvdXQgYC0taW5wdXQtZmlsZWApIHwgRXhhbXBsZTogYEgxMDBgIHwK" + + "fCBgLS1pbnN0YW5jZS10eXBlIFRZUEVgIHwgSW5zdGFuY2UgdHlwZSAocmVxdWlyZWQgd2l0aG91" + + "dCBgLS1pbnB1dC1maWxlYCkgfCBFeGFtcGxlOiBgTkNQLkdQVS5IMTAwXzF4YCB8CnwgYC0taW1h" + + "Z2UgSU1BR0VgIHwgQ29udGFpbmVyIGltYWdlIHwgTXV0dWFsbHkgZXhjbHVzaXZlIHdpdGggYC0t" + + "aGVsbS1jaGFydGAgfAp8IGAtLWhlbG0tY2hhcnQgQ0hBUlRgIHwgSGVsbSBjaGFydCBVUkwgb3Ig" + + "T0NJIHJlZmVyZW5jZSB8IE11dHVhbGx5IGV4Y2x1c2l2ZSB3aXRoIGAtLWltYWdlYCB8CnwgYC0t" + + "aW5wdXQtZmlsZSBGSUxFYCB8IEpTT04gdGFzayBzcGVjIGZpbGUgfCBDTEkgZmxhZ3Mgb3ZlcnJp" + + "ZGUgSlNPTiB2YWx1ZXMgd2hlbiBib3RoIGFyZSBzZXQgfAp8IGAtLWJhY2tlbmQgQkFDS0VORGAg" + + "fCBCYWNrZW5kIC8gQ1NQIHwgLSB8CnwgYC0tY2x1c3RlcnMgTkFNRVssTkFNRV1gIHwgU3BlY2lm" + + "aWMgY2x1c3RlcnMgd2l0aGluIHRoZSBpbnN0YW5jZSB8IENvbW1hLXNlcGFyYXRlZCB8CnwgYC0t" + + "Y29udGFpbmVyLWFyZ3MgQVJHU2AgfCBBcmdzIHBhc3NlZCB3aGVuIGxhdW5jaGluZyB0aGUgY29u" + + "dGFpbmVyIHwgU2luZ2xlIHN0cmluZywgZS5nLiBgIi0tZXBvY2hzIDEwIC0tYmF0Y2gtc2l6ZSAz" + + "MiJgIHwKfCBgLS1jb250YWluZXItZW52IE5BTUU9dmFsdWVgIHwgQ29udGFpbmVyIGVudmlyb25t" + + "ZW50IHZhcmlhYmxlOyByZXBlYXRhYmxlIHwgLSB8CnwgYC0tc2VjcmV0cyBOQU1FPXZhbHVlYCB8" + + "IFNlY3JldCBlbnZpcm9ubWVudCB2YXJpYWJsZTsgcmVwZWF0YWJsZTsgZW5jcnlwdGVkIGF0IHJl" + + "c3QgfCAtIHwKfCBgLS1tYXgtcnVudGltZSBEVVJBVElPTmAgfCBNYXggd2FsbC1jbG9jayBydW4g" + + "dGltZSAoSVNPIDg2MDEsIGUuZy4gYFBUNEhgKSB8IE5vIGRlZmF1bHQ7IG9taXQgZm9yIG5vIHRp" + + "bWUgbGltaXQgfAp8IGAtLW1heC1xdWV1ZWQgRFVSQVRJT05gIHwgTWF4IHRpbWUgaW4gcXVldWUg" + + "YmVmb3JlIGNhbmNlbGxhdGlvbiAoSVNPIDg2MDEpIHwgU2VydmVyIGRlZmF1bHQgYFBUNzJIYCB8" + + "CnwgYC0tdGVybWluYXRpb24tZ3JhY2UgRFVSQVRJT05gIHwgR3JhY2UgcGVyaW9kIGFmdGVyIHN0" + + "b3Agc2lnbmFsIChJU08gODYwMSkgfCBTZXJ2ZXIgZGVmYXVsdCBgUFQxSGAgfAp8IGAtLXJlc3Vs" + + "dC1zdHJhdGVneSBVUExPQURcfE5PTkVgIHwgSG93IHRvIGhhbmRsZSB0YXNrIG91dHB1dCBhcnRp" + + "ZmFjdHMgfCAtIHwKfCBgLS1yZXN1bHRzLWxvY2F0aW9uIExPQ0FUSU9OYCB8IFJlc3VsdCB1cGxv" + + "YWQgdGFyZ2V0LCBmb3JtYXQgYG9yZy1uYW1lL1t0ZWFtLW5hbWUvXW1vZGVsLW5hbWVgOyByZXF1" + + "aXJlZCB3aGVuIGAtLXJlc3VsdC1zdHJhdGVneT1VUExPQURgIHwgLSB8CnwgYC0tbW9kZWxzIE5B" + + "TUU6VkVSU0lPTjpVUklgIHwgTW9kZWwgYXJ0aWZhY3Q7IHJlcGVhdGFibGUgfCAtIHwKfCBgLS1y" + + "ZXNvdXJjZXMgTkFNRTpWRVJTSU9OOlVSSWAgfCBSZXNvdXJjZSBhcnRpZmFjdDsgcmVwZWF0YWJs" + + "ZSB8IC0gfAp8IGAtLXRhZ3MgVEFHWyxUQUddYCB8IFRhc2sgdGFncyB8IENvbW1hLXNlcGFyYXRl" + + "ZCB8CnwgYC0tZGVzY3JpcHRpb24gVEVYVGAgfCBUYXNrIGRlc2NyaXB0aW9uIHwgLSB8CnwgYC0t" + + "bG9ncy10ZWxlbWV0cnktaWQgVVVJRGAgfCBMb2dzIHRlbGVtZXRyeSBlbmRwb2ludCBJRCB8IC0g" + + "fAp8IGAtLW1ldHJpY3MtdGVsZW1ldHJ5LWlkIFVVSURgIHwgTWV0cmljcyB0ZWxlbWV0cnkgZW5k" + + "cG9pbnQgSUQgfCAtIHwKfCBgLS10cmFjZXMtdGVsZW1ldHJ5LWlkIFVVSURgIHwgVHJhY2VzIHRl" + + "bGVtZXRyeSBlbmRwb2ludCBJRCB8IC0gfApQSwcI5GexzC0lAAAtJQAAUEsDBBQACAAAAAAAIQAA" + + "AAAAAAAAAAAAAAA3AAkAZGF0YS9udmNmLXNlbGYtbWFuYWdlZC1jbGkvcmVmZXJlbmNlL3Ryb3Vi" + + "bGVzaG9vdGluZy5tZFVUBQABAKbOEiMgVHJvdWJsZXNob290aW5nCgpLbm93biBlcnJvcnMg4oaS" + + "IGRpYWdub3N0aWMgY29tbWFuZCDihpIgcmVtZWRpYXRpb24uIEtlZXAgaW4gc3luYyB3aXRoIHRo" + + "ZSBzdHJ1Y3R1cmVkIGBwaGFzZV9mYWlsZWRgIGV2ZW50cyB0aGUgQ0xJIGVtaXRzIChSRVEtMTUp" + + "IOKAlCBldmVyeSBlbnRyeSBiZWxvdyBzaG91bGQgbWFwIHRvIGFuIGBlcnJDYXRlZ29yeWAgYW5k" + + "IGEgYHJlbWVkaWF0aW9uYCBhcnJheS4KCiMjIFByZS1mbGlnaHQKCnwgU3ltcHRvbSB8IENhdXNl" + + "IHwgUmVtZWRpYXRpb24gfAp8LS0tfC0tLXwtLS18CnwgYGt1YmVjdGwgbm90IG9uIFBBVEhgIHwg" + + "T3BlcmF0b3IncyBgJFBBVEhgIGRvZXNuJ3QgaW5jbHVkZSBrdWJlY3RsIHwgSW5zdGFsbCBrdWJl" + + "Y3RsIDEuMjgrOiBodHRwczovL2t1YmVybmV0ZXMuaW8vZG9jcy90YXNrcy90b29scy9pbnN0YWxs" + + "LWt1YmVjdGwvIHwKfCBgaGVsbWZpbGUgbm90IG9uIFBBVEhgIHwgU2FtZSB8IGh0dHBzOi8vZ2l0" + + "aHViLmNvbS9oZWxtZmlsZS9oZWxtZmlsZSNpbnN0YWxsYXRpb24gfAp8IGBoZWxtIG5vdCBvbiBQ" + + "QVRIYCB8IFNhbWUgfCBodHRwczovL2hlbG0uc2gvZG9jcy9pbnRyby9pbnN0YWxsLyB8CnwgYEdh" + + "dGV3YXkgQVBJIENSRHMgbm90IGluc3RhbGxlZGAgfCBlbnZveS1nYXRld2F5IHByZXJlcSBtaXNz" + + "aW5nIHwgYGhlbG0gaW5zdGFsbCBlZyBvY2k6Ly9kb2NrZXIuaW8vZW52b3lwcm94eS9nYXRld2F5" + + "LWhlbG0gLS1uYW1lc3BhY2U9ZW52b3ktZ2F0ZXdheS1zeXN0ZW0gLS1jcmVhdGUtbmFtZXNwYWNl" + + "YCB8CnwgYGRlZmF1bHQgU3RvcmFnZUNsYXNzIG5vdCBhdmFpbGFibGVgIHwgQ2x1c3RlciBoYXMg" + + "bm8gZGVmYXVsdCBTQyB8IEFubm90YXRlIG9uZTogYGt1YmVjdGwgcGF0Y2ggc2MgPG5hbWU+IC1w" + + "ICd7Im1ldGFkYXRhIjp7ImFubm90YXRpb25zIjp7InN0b3JhZ2VjbGFzcy5rdWJlcm5ldGVzLmlv" + + "L2lzLWRlZmF1bHQtY2xhc3MiOiJ0cnVlIn19fSdgIHwKfCBgR1BVIG9wZXJhdG9yIG5vdCBpbnN0" + + "YWxsZWRgIChjb21wdXRlLXBsYW5lKSB8IG52aWRpYSBHUFUgb3BlcmF0b3IgbWlzc2luZyB8IElu" + + "c3RhbGwgcGVyIGh0dHBzOi8vZG9jcy5udmlkaWEuY29tL2RhdGFjZW50ZXIvY2xvdWQtbmF0aXZl" + + "L2dwdS1vcGVyYXRvci9sYXRlc3QvaW5zdGFsbC1ncHUtb3BlcmF0b3IuaHRtbCwgT1IgdXNlIGBm" + + "YWtlLWdwdS1vcGVyYXRvcmAgZm9yIGRldiB8CnwgYEdQVSBub2RlIGxhYmVscyBtaXNzaW5nYCAo" + + "Y29tcHV0ZS1wbGFuZSkgfCBOb2RlcyBuZWVkIGBudmlkaWEuY29tL2dwdS5mYW1pbHlgIGV0Yy4g" + + "fCBTZXQgYC0tazNzLW5vZGUtbGFiZWwgbnZpZGlhLmNvbS9ncHUuZmFtaWx5PWhvcHBlckBhZ2Vu" + + "dDpOYCBmb3IgazNkIHwKCiMjIEF1dGgKCnwgU3ltcHRvbSB8IENhdXNlIHwgUmVtZWRpYXRpb24g" + + "fAp8LS0tfC0tLXwtLS18CnwgYGFkbWluIHRva2VuIHJlcXVpcmVkYCAoaW5pdCBub3QgcnVuKSB8" + + "IE5vIGB+Ly5udmNmLWNsaS5zdGF0ZWAgYW5kIGAtLXRva2VuYCBub3QgcGFzc2VkIHwgYG52Y2Yt" + + "Y2xpIGluaXRgIChpbnRlcmFjdGl2ZSkgb3IgYC0tdG9rZW49JEpXVCAtLW5vbi1pbnRlcmFjdGl2" + + "ZWAgKENJKSB8CnwgYFNpZ25lZCBKV1QgcmVqZWN0ZWQ6IEFub3RoZXIgYWxnb3JpdGhtIGV4cGVj" + + "dGVkLCBvciBubyBtYXRjaGluZyBrZXkocykgZm91bmRgIHwgU3RhbGUgc2Vzc2lvbi5qc29uIGZy" + + "b20gYSBkaWZmZXJlbnQgY29udHJvbCBwbGFuZSB8IGBybSB+Ly5udmNmLWNsaS5zdGF0ZWAgdGhl" + + "biBgbnZjZi1jbGkgaW5pdGAgYWdhaW4gfAp8IGA0MDMgbWlzc2luZyByZXF1ZXN0ZWQgYXV0aG9y" + + "aXRpZXNgIChmdW5jdGlvbiBpbnZva2UpIHwgQWRtaW4gdG9rZW4gZG9lc24ndCBoYXZlIGBpbnZv" + + "a2VfZnVuY3Rpb25gIHNjb3BlIHwgYG52Y2YtY2xpIGFwaS1rZXkgZ2VuZXJhdGUgLS1kZXNjcmlw" + + "dGlvbj3igKZgIHRoZW4gcmUtcnVuIGludm9rZSB8CgojIyBJbnN0YWxsIC8gYHVwYAoKfCBTeW1w" + + "dG9tIHwgQ2F1c2UgfCBSZW1lZGlhdGlvbiB8CnwtLS18LS0tfC0tLXwKfCBIZWxtIGB0aW1lZCBv" + + "dXQgd2FpdGluZyBmb3IgY2Fzc2FuZHJhYCB8IENhc3NhbmRyYSBTdGF0ZWZ1bFNldCBQVkMgc3R1" + + "Y2sgYFBlbmRpbmdgIHwgQ29uZmlybSBkZWZhdWx0IFN0b3JhZ2VDbGFzczsgY2hlY2sgYGt1YmVj" + + "dGwgZ2V0IHB2LHB2YyAtbiBjYXNzYW5kcmEtc3lzdGVtYCB8CnwgYEludmFsaWQgR1BVICdOQ1Au" + + "R1BVLkgxMDAnIHNwZWNpZmllZGAgKGZ1bmN0aW9uIGRlcGxveSkgfCBXcm9uZyBmaWVsZCDigJQg" + + "YGdwdWAgaXMgdGhlIGZhbWlseSwgbm90IHRoZSBTS1UgfCBVc2UgYCJncHUiOiAiSDEwMCJgLCBg" + + "Imluc3RhbmNlVHlwZSI6ICJOQ1AuR1BVLkgxMDBfMXgiYCB8CnwgYHJlZ2lvbiBtdXN0IGJlIHBy" + + "b3ZpZGVkYCAoY2x1c3RlciByZWdpc3RlciAvIGluc3RhbGwgLS1jb21wdXRlLXBsYW5lKSB8IGAt" + + "LXJlZ2lvbmAgZW1wdHkgKyBgQ0xVU1RFUl9SRUdJT05gIGVudiBlbXB0eSB8IFBhc3MgYC0tcmVn" + + "aW9uPXVzLXdlc3QtMWAgKG9yIGFueSBub24tZW1wdHkgdmFsdWUpIHwKfCBgcmVxdWlyZWRFbnYg" + + "Ik5DQV9JRCIgaXMgbm90IHNldGAgKGhlbG1maWxlIGVycm9yIGR1cmluZyBjb21wdXRlLXBsYW5l" + + "IGFwcGx5KSB8IE9sZGVyIG52Y2YtY2xpIGJlZm9yZSBjb21taXQgYDZhYTU3MDRgOyBFeHRyYUVu" + + "diBub3QgcHJvcGFnYXRpbmcgTkNBX0lEIHwgVXBncmFkZSBgbnZjZi1jbGlgIHRvIGEgcmVsZWFz" + + "ZSBhZnRlciBgNmFhNTcwNGAgfAp8IGBudmNhLW9wZXJhdG9yOiBJbWFnZVB1bGxCYWNrT2ZmYCBm" + + "b3IgYG52Y2Etb3BlcmF0b3I6cHNhdGAgfCBJbWFnZSBub3QgaW4gY2x1c3RlciByZWdpc3RyeTsg" + + "bXVsdGktY2x1c3RlciBidWlsZCBpcyBsb2NhbCB8IGBrM2QgaW1hZ2UgaW1wb3J0IG52Y3IuaW8v" + + "Li4uL252Y2Etb3BlcmF0b3I6cHNhdCAtYyA8Y2x1c3Rlcj5gIHwKCiMjIENvbXB1dGUtcGxhbmUg" + + "cnVudGltZQoKfCBTeW1wdG9tIHwgQ2F1c2UgfCBSZW1lZGlhdGlvbiB8CnwtLS18LS0tfC0tLXwK" + + "fCBOVkNBIGFnZW50IENyYXNoTG9vcEJhY2tPZmYgd2l0aCBgSFRUUCA0MDFgIG9uIGAvdjEvbnZj" + + "YS9jbHVzdGVycy8uLi4vcmVnaXN0ZXJgIHwgU3RhbGUgYG91dC88Y2x1c3Rlcj4tcmVnaXN0ZXIt" + + "dmFsdWVzLnlhbWxgIGZyb20gcHJpb3IgcmVnaXN0ZXI7IGNsdXN0ZXIgSUQgZG9lc24ndCBtYXRj" + + "aCBJQ01TIHwgRGVsZXRlIHRoZSBzdGFsZSBmaWxlOyByZS1ydW4gYG52Y2YtY2xpIHNlbGYtaG9z" + + "dGVkIHVwYCAoaWRlbXBvdGVudCByZWdpc3RlciB3cml0ZXMgYSBmcmVzaCBmaWxlKSB8CnwgYE5v" + + "IGNsdXN0ZXIgZm91bmQgd2l0aCB2YWxpZCBKV0tTIGZvciBjbHVzdGVyIElEOiA8aWQ+YCAoSUNN" + + "UyBsb2cpIHwgSldLUyBpbiBJQ01TIGRvZXNuJ3QgbWF0Y2ggd2hhdCBjb21wdXRlLXBsYW5lIEs4" + + "cyBpcyBjdXJyZW50bHkgc2lnbmluZyB8IGBudmNmLWNsaSBjbHVzdGVyIHJvdGF0ZSAtLWNsdXN0" + + "ZXItaWQ9PGlkPmAgfAp8IEZ1bmN0aW9uIHBvZCBgSW1hZ2VQdWxsQmFja09mZmAgaW4gYG52Y2Yt" + + "YmFja2VuZGAgfCBJbWFnZS1jcmVkZW50aWFsLWhlbHBlciBjb25maWcgbWlzc2luZyBvciB3cm9u" + + "ZyB8IGBrdWJlY3RsIGRlc2NyaWJlIHBvZCAtbiBudmNmLWJhY2tlbmQgPHBvZD5gOyBjaGVjayB0" + + "aGUgcHVsbCBzZWNyZXQgY29uZmlnIHwKfCBGdW5jdGlvbiBkZXBsb3kgc3R1Y2sgYERFUExPWUlO" + + "R2AgZm9yID41IG1pbiB8IE5BVFMgc3RyZWFtIGluaXQgbGFnIChjb2xkLWNsdXN0ZXIpIOKAlCB3" + + "YWl0LCBvciBjaGVjayBOQVRTIGF1dGgtY2FsbG91dCBoZWFsdGggfCBga3ViZWN0bCBsb2dzIC1u" + + "IG5hdHMtc3lzdGVtIC1sIGFwcC5rdWJlcm5ldGVzLmlvL25hbWU9bmF0cy1hdXRoLWNhbGxvdXQt" + + "c2VydmljZWAgfAoKIyMgVGFza3MKCnwgU3ltcHRvbSB8IENhdXNlIHwgUmVtZWRpYXRpb24gfAp8" + + "LS0tfC0tLXwtLS18CnwgYHRhc2sgY3JlYXRlYCByZXR1cm5zIGBNaXNzaW5nIDxUWVBFPiByZWdp" + + "c3RyeSBjcmVkZW50aWFsIGZvciBob3N0bmFtZWAsIG9yIGtlZXBzIHVzaW5nIGEgcHJldmlvdXMg" + + "Y3JlZGVudGlhbCB2YWx1ZSwgc2hvcnRseSBhZnRlciBgcmVnaXN0cnktY3JlZGVudGlhbCBhZGQv" + + "dXBkYXRlL2RlbGV0ZWAgd2hpbGUgYHJlZ2lzdHJ5LWNyZWRlbnRpYWwgbGlzdGAvYGdldGAgYWxy" + + "ZWFkeSBzaG93IHRoZSBuZXcgdmFsdWUgfCBFeHBlY3RlZCBwcm9wYWdhdGlvbiBkZWxheTogTlZD" + + "VCBjYWNoZXMgdGhlIGFjY291bnQncyByZWdpc3RyeSBjcmVkZW50aWFscyB3aXRoIGBudmN0Lm52" + + "Y2YuY2FjaGUtdHRsYCAoZGVmYXVsdCBgUFQ1TWAsIGFib3V0IDUgbWluKSBhbmQgYXBwbGllcyB0" + + "aGUgY2hhbmdlIHdoZW4gdGhhdCBjYWNoZWQgY29weSByZWZyZXNoZXMgfCBXYWl0IHVwIHRvIGFi" + + "b3V0IDUgbWluIGFuZCByZXRyeSwgb3IgYGt1YmVjdGwgLW4gbnZjZiByb2xsb3V0IHJlc3RhcnQg" + + "ZGVwbG95bWVudC9udmN0LWFwaWAgdG8gYXBwbHkgaW1tZWRpYXRlbHkgfApQSwcI864ThHQRAAB0" + + "EQAAUEsDBBQACAAAAAAAIQAAAAAAAAAAAAAAAAAsAAkAZGF0YS9udmNmLXNlbGYtbWFuYWdlZC1p" + + "bnN0YWxsYXRpb24vU0tJTEwubWRVVAUAAQCmzhItLS0KbmFtZTogbnZjZi1zZWxmLW1hbmFnZWQt" + + "aW5zdGFsbGF0aW9uCmRlc2NyaXB0aW9uOiA+LQogIEluc3RhbGwgYW5kIG9wZXJhdGUgTlZDRiBz" + + "ZWxmLWhvc3RlZCBjb250cm9sLXBsYW5lIGFuZCBzZXBhcmF0ZSBjb21wdXRlLXBsYW5lCiAgc3Rh" + + "Y2tzLiBDb3ZlcnMgSGVsbWZpbGUgdmFsdWVzIGFuZCBDTEkgcHJvZmlsZSBpbnN0YWxsYXRpb24g" + + "Zmxvd3MsIHRlYXJkb3duLAogIHZhbHVlcyBvdmVycmlkZXMsIHB1bGwgc2VjcmV0cywgYW5kIHRy" + + "b3VibGVzaG9vdGluZy4gVXNlIGZvcgogIG52Y2Ytc2VsZi1tYW5hZ2VkLXN0YWNrLCBudmNmLWNv" + + "bXB1dGUtcGxhbmUtc3RhY2ssIHNwbGl0IGNvbXB1dGUtcGxhbmUKICBpbnN0YWxsYXRpb24sIGNv" + + "bnRyb2wtcGxhbmUgaW5zdGFsbGF0aW9uLCBDTEktZ2VuZXJhdGVkIGNvbnRyb2wtcGxhbmUKICBw" + + "cm9maWxlcywgSGVsbWZpbGUsIHNlbGYtbWFuYWdlZCwgb3Igc2VsZi1ob3N0ZWQgZGVwbG95bWVu" + + "dHMuIERvIE5PVCB1c2UgZm9yCiAgbG9jYWwgazNkIGVudmlyb25tZW50czsgdXNlIHRoZSBsb2Nh" + + "bCBrM2QgZGV2ZWxvcG1lbnQgd29ya2Zsb3cgaW5zdGVhZC4KbGljZW5zZTogQXBhY2hlLTIuMApj" + + "b21wYXRpYmlsaXR5OiBSZXF1aXJlcyBoZWxtZmlsZSA+PSAxLjEuMCA8IDEuMi4wLCBoZWxtID49" + + "IDMuMTIsIGhlbG0tZGlmZiBwbHVnaW4sIGt1YmVjdGwgbWF0Y2hpbmcgY2x1c3RlciB2ZXJzaW9u" + + "CmF1dGhvcjogIm52Y2YtY29yZS1lbmcgPG52Y2YtY29yZS1lbmdAZXhjaGFuZ2UubnZpZGlhLmNv" + + "bT4iCnZlcnNpb246ICIxLjAuMCIKdGFnczogW252Y2YsIHNlbGYtbWFuYWdlZCwgaGVsbWZpbGUs" + + "IHNlbGYtaG9zdGVkLCBjb250cm9sLXBsYW5lLCBjb21wdXRlLXBsYW5lLCBjbGktcHJvZmlsZSwg" + + "aW5zdGFsbGF0aW9uLCBkZXBsb3ltZW50LCBwdWxsLXNlY3JldHNdCnRvb2xzOiBbU2hlbGwsIFJl" + + "YWQsIEVkaXQsIEdyZXAsIEdsb2JdCm1ldGFkYXRhOgogIGludGVybmFsOiBmYWxzZQogIGF1dGhv" + + "cjogIm52Y2YtY29yZS1lbmcgPG52Y2YtY29yZS1lbmdAZXhjaGFuZ2UubnZpZGlhLmNvbT4iCiAg" + + "dmVyc2lvbjogIjEuMCIKICB0YWdzOiBbbnZjZiwgc2VsZi1tYW5hZ2VkLCBoZWxtZmlsZSwgc2Vs" + + "Zi1ob3N0ZWQsIGNvbnRyb2wtcGxhbmUsIGNvbXB1dGUtcGxhbmUsIGNsaS1wcm9maWxlLCBpbnN0" + + "YWxsYXRpb24sIGRlcGxveW1lbnQsIHB1bGwtc2VjcmV0c10KICBsYW5ndWFnZXM6IFtiYXNoLCB5" + + "YW1sXQogIGZyYW1ld29ya3M6IFtoZWxtZmlsZSwgaGVsbSwga3ViZWN0bF0KICBkb21haW46IGNs" + + "b3VkLWluZnJhc3RydWN0dXJlCi0tLQoKIyBOVkNGIFNlbGYtTWFuYWdlZCBTdGFjayBPcGVyYXRp" + + "b25zCgpPcGVyYXRpb25hbCBndWlkZSBmb3IgbWF0Y2hpbmcgTlZDRiBjb250cm9sLXBsYW5lIGFu" + + "ZCBjb21wdXRlLXBsYW5lIEhlbG1maWxlIGJ1bmRsZXMuCgojIyBJbnN0cnVjdGlvbnMKClVzZSB0" + + "aGlzIHNraWxsIGZvciBpbnN0YWxsLCB1cGdyYWRlLCBvciB0ZWFyZG93biB3b3JrIGluIG1hdGNo" + + "aW5nIGBudmNmLXNlbGYtbWFuYWdlZC1zdGFja2AgYW5kIGBudmNmLWNvbXB1dGUtcGxhbmUtc3Rh" + + "Y2tgIGJ1bmRsZXM7IGtlZXAgSGVsbWZpbGUgdmFsdWVzIGFuZCBDTEkgcHJvZmlsZSBoYW5kb2Zm" + + "cyBzZXBhcmF0ZS4gRm9yIGBmdW5jdGlvblR5cGU6ICJMTE0iYCwgcmVhZCBbTExNIEZ1bmN0aW9u" + + "IEVuYWJsZW1lbnRdKHJlZmVyZW5jZXMvaGVsbWZpbGUtc3RydWN0dXJlLm1kI2xsbS1mdW5jdGlv" + + "bi1lbmFibGVtZW50KS4KCiMjIFByZXJlcXVpc2l0ZXMKCkFzayBmb3IgdGhlIGV4dHJhY3RlZCBg" + + "bnZjZi1zZWxmLW1hbmFnZWQtc3RhY2tgIHBhdGguIEZvciBzcGxpdCBpbnN0YWxsYXRpb24sCmFs" + + "c28gcmVxdWlyZSB0aGUgbWF0Y2hpbmctdmVyc2lvbiBgbnZjZi1jb21wdXRlLXBsYW5lLXN0YWNr" + + "YCBwYXRoLiBWZXJpZnkgYm90aDoKCmBgYGJhc2gKbHMgPGNvbnRyb2wtcGxhbmUtc3RhY2s+L2hl" + + "bG1maWxlLmQvIDxjb250cm9sLXBsYW5lLXN0YWNrPi9lbnZpcm9ubWVudHMvIDxjb250cm9sLXBs" + + "YW5lLXN0YWNrPi9zZWNyZXRzLyA8Y29udHJvbC1wbGFuZS1zdGFjaz4vZ2xvYmFsLnlhbWwuZ290" + + "bXBsCmxzIDxjb21wdXRlLXBsYW5lLXN0YWNrPi9oZWxtZmlsZS5kLyA8Y29tcHV0ZS1wbGFuZS1z" + + "dGFjaz4vZW52aXJvbm1lbnRzLyA8Y29tcHV0ZS1wbGFuZS1zdGFjaz4vZ2xvYmFsLnlhbWwuZ290" + + "bXBsCmBgYAoKSWYgZWl0aGVyIGRpcmVjdG9yeSBpcyBtaXNzaW5nLCBkb3dubG9hZCBtYXRjaGlu" + + "ZyBidW5kbGUgdmVyc2lvbnMgZnJvbSBOR0M6CgpgYGBiYXNoCm5nYyByZWdpc3RyeSByZXNvdXJj" + + "ZSBkb3dubG9hZC12ZXJzaW9uIDxvcmc+L252Y2Ytc2VsZi1tYW5hZ2VkLXN0YWNrOjx2ZXJzaW9u" + + "PgpuZ2MgcmVnaXN0cnkgcmVzb3VyY2UgZG93bmxvYWQtdmVyc2lvbiA8b3JnPi9udmNmLWNvbXB1" + + "dGUtcGxhbmUtc3RhY2s6PHZlcnNpb24+CmBgYAoKQ29udHJvbC1wbGFuZSBjb21tYW5kcyBiZWxv" + + "dyBhc3N1bWUgdGhlIGNvbnRyb2wtcGxhbmUgYnVuZGxlIHJvb3QuIFNwbGl0LWZsb3cKY29tbWFu" + + "ZHMgYW5kIHJvb3Qgc3Vic3RpdHV0aW9uIGFyZSBpbgpbU3BsaXQgQ29tcHV0ZS1QbGFuZSBJbnN0" + + "YWxsYXRpb25dKHJlZmVyZW5jZXMvY29tcHV0ZS1wbGFuZS1pbnN0YWxsYXRpb24ubWQpLgoKIyMg" + + "QmVmb3JlIFlvdSBTdGFydAoKVmVyaWZ5IHRvb2xpbmcgYW5kIGNvbnRleHQgYmVmb3JlIGFueSBv" + + "cGVyYXRpb246CgpgYGBiYXNoCmhlbG1maWxlIC0tdmVyc2lvbiAgICMgTXVzdCBiZSAxLjEueCAo" + + "MS4yLjAgcmVtb3ZlZCBzZXF1ZW50aWFsIG1vZGUpCmhlbG0gdmVyc2lvbiAgICAgICAgICMgTXVz" + + "dCBiZSA+PSAzLjEyCmhlbG0gcGx1Z2luIGxpc3QgICAgICMgTXVzdCBpbmNsdWRlIGhlbG0tZGlm" + + "ZiA+PSAzLjExCmt1YmVjdGwgdmVyc2lvbiAgICAgICMgQ2xpZW50IG11c3QgYmUgd2l0aGluIDEg" + + "bWlub3IgdmVyc2lvbiBvZiBjbHVzdGVyCmBgYAoKQ29udHJvbC1wbGFuZSBjb21tYW5kcyBydW4g" + + "ZnJvbSB0aGUgZXh0cmFjdGVkIGBudmNmLXNlbGYtbWFuYWdlZC1zdGFjay9gIHJvb3Q6CgpgYGBi" + + "YXNoCmNkIHBhdGgvdG8vbnZjZi1zZWxmLW1hbmFnZWQtc3RhY2sKbHMgaGVsbWZpbGUuZC8gZW52" + + "aXJvbm1lbnRzLyBzZWNyZXRzLyBnbG9iYWwueWFtbC5nb3RtcGwKYGBgCgpJZGVudGlmeSB0aGUg" + + "ZW52aXJvbm1lbnQgZnJvbSBgZW52aXJvbm1lbnRzLzxuYW1lPi55YW1sYCBhbmQKYHNlY3JldHMv" + + "PG5hbWU+LXNlY3JldHMueWFtbGA7IGZvciBFS1MsIHVzZSB0aGUgY2Fub25pY2FsCltDU1AgRW5k" + + "LXRvLUVuZCBFeGFtcGxlXShodHRwczovL2RvY3MubnZpZGlhLmNvbS9udmNmL3YwLjYuMC1yYy9j" + + "c3AtZW5kLXRvLWVuZC1leGFtcGxlKS4KCiMjIEhvdyBWYWx1ZXMgRmxvdwoKVW5kZXJzdGFuZGlu" + + "ZyB2YWx1ZSBwcmVjZWRlbmNlIHByZXZlbnRzIHRoZSBtb3N0IGNvbW1vbiBjb25maWd1cmF0aW9u" + + "IG1pc3Rha2VzLgoKYGBgCmVudmlyb25tZW50cy9iYXNlLnlhbWwgICAgICAgICAgKGRlZmF1bHRz" + + "KQogICAgLT4gbWVyZ2VkIHdpdGgKZW52aXJvbm1lbnRzLzxlbnY+LnlhbWwgICAgICAgICAoeW91" + + "ciBvdmVycmlkZXMpCiAgICAtPiBjb25zdW1lZCBieQpnbG9iYWwueWFtbC5nb3RtcGwgICAgICAg" + + "ICAgICAgIChHbyB0ZW1wbGF0ZSwgY29uc3RydWN0cyBwZXItY2hhcnQgdmFsdWVzKQogICAgLT4g" + + "Y29uc3VtZWQgYnkKc2VjcmV0cy88ZW52Pi1zZWNyZXRzLnlhbWwgICAgICAoc2Vuc2l0aXZlIHZh" + + "bHVlcykKICAgIC0+IG92ZXJyaWRkZW4gYnkKcmVsZWFzZSBpbmxpbmUgdmFsdWVzOiBibG9ja3Mg" + + "ICAoaGlnaGVzdCBwcmVjZWRlbmNlKQpgYGAKCkNyaXRpY2FsOiBgZ2xvYmFsLnlhbWwuZ290bXBs" + + "YCBvbmx5IHBhc3NlcyB0aHJvdWdoIHNwZWNpZmljIGtleXMgdG8gZWFjaCBjaGFydCAoaW1hZ2Ug" + + "cmVnaXN0cmllcywgbm9kZSBzZWxlY3RvcnMsIHN0b3JhZ2UsIHJlcGxpY2EgY291bnRzKS4gU2V0" + + "dGluZyBhbiBhcmJpdHJhcnkgY2hhcnQgdmFsdWUgaW4gdGhlIGVudmlyb25tZW50IGZpbGUgd2ls" + + "bCBiZSBzaWxlbnRseSBpZ25vcmVkIGlmIGBnbG9iYWwueWFtbC5nb3RtcGxgIGRvZXMgbm90IHBy" + + "b3BhZ2F0ZSBpdC4KClRvIG92ZXJyaWRlIGFyYml0cmFyeSBjaGFydCB2YWx1ZXMsIHVzZSBhIGhl" + + "bG1maWxlIHJlbGVhc2UgYHZhbHVlczpgIGJsb2NrLiBTZWUgW092ZXJyaWRpbmcgSGVsbSBDaGFy" + + "dCBWYWx1ZXNdKCNvdmVycmlkaW5nLWhlbG0tY2hhcnQtdmFsdWVzKS4KCiMjIENsZWFuIEluc3Rh" + + "bGxhdGlvbgoKIyMjIDEuIENyZWF0ZSBuYW1lc3BhY2VzIGFuZCBpbWFnZSBwdWxsIHNlY3JldHMg" + + "KGlmIHVzaW5nIGEgcHJpdmF0ZSByZWdpc3RyeSkKCmBgYGJhc2gKZm9yIG5zIGluIGNhc3NhbmRy" + + "YS1zeXN0ZW0gbmF0cy1zeXN0ZW0gbnZjZiBhcGkta2V5cyBlc3Mgc2lzIHZhdWx0LXN5c3RlbSBj" + + "ZXJ0LW1hbmFnZXI7IGRvCiAga3ViZWN0bCBjcmVhdGUgbmFtZXNwYWNlICIkbnMiIC0tZHJ5LXJ1" + + "bj1jbGllbnQgLW8geWFtbCB8IGt1YmVjdGwgYXBwbHkgLWYgLQpkb25lCgojIE9ubHkgaWYgcHVs" + + "bGluZyBmcm9tIGEgcHJpdmF0ZSByZWdpc3RyeSAoZS5nLiwgTkdDIG52Y3IuaW8pCmV4cG9ydCBO" + + "R0NfQVBJX0tFWT0iPHlvdXIta2V5PiIKZm9yIG5zIGluIGNhc3NhbmRyYS1zeXN0ZW0gbmF0cy1z" + + "eXN0ZW0gbnZjZiBhcGkta2V5cyBlc3Mgc2lzIHZhdWx0LXN5c3RlbSBjZXJ0LW1hbmFnZXI7IGRv" + + "CiAga3ViZWN0bCBjcmVhdGUgc2VjcmV0IGRvY2tlci1yZWdpc3RyeSBudmNyLWNyZWRzIFwKICAg" + + "IC0tZG9ja2VyLXNlcnZlcj1udmNyLmlvIFwKICAgIC0tZG9ja2VyLXVzZXJuYW1lPSckb2F1dGh0" + + "b2tlbicgXAogICAgLS1kb2NrZXItcGFzc3dvcmQ9IiROR0NfQVBJX0tFWSIgXAogICAgLS1uYW1l" + + "c3BhY2U9IiRucyIgXAogICAgLS1kcnktcnVuPWNsaWVudCAtbyB5YW1sIHwga3ViZWN0bCBhcHBs" + + "eSAtZiAtCmRvbmUKYGBgCgpJZiB1c2luZyBwdWxsIHNlY3JldHMsIHlvdSBtdXN0IGFsc28gY29u" + + "ZmlndXJlIGVhY2ggaGVsbWZpbGUgcmVsZWFzZSB0byByZWZlcmVuY2UgdGhlbS4gU2VlIFtJbWFn" + + "ZSBQdWxsIFNlY3JldHNdKCNpbWFnZS1wdWxsLXNlY3JldHMpLgoKIyMjIDIuIEF1dGhlbnRpY2F0" + + "ZSBoZWxtIHRvIHlvdXIgY2hhcnQgcmVnaXN0cnkKCkJvdGggYGRvY2tlciBsb2dpbmAgQU5EIGBo" + + "ZWxtIHJlZ2lzdHJ5IGxvZ2luYCBhcmUgcmVxdWlyZWQgZm9yIE5HQy4gSGVsbWZpbGUgdXNlcyBo" + + "ZWxtIChub3QgZG9ja2VyKSB0byBwdWxsIE9DSSBjaGFydHMsIHNvIHRoZSBoZWxtIGNyZWRlbnRp" + + "YWwgc3RvcmUgbXVzdCBiZSBhdXRoZW50aWNhdGVkIHNlcGFyYXRlbHkuCgpgYGBiYXNoCiMgTkdD" + + "IC0tIGJvdGggY29tbWFuZHMgYXJlIHJlcXVpcmVkCmRvY2tlciBsb2dpbiBudmNyLmlvIC11ICck" + + "b2F1dGh0b2tlbicgLXAgIiROR0NfQVBJX0tFWSIKaGVsbSByZWdpc3RyeSBsb2dpbiBudmNyLmlv" + + "IC11ICckb2F1dGh0b2tlbicgLXAgIiROR0NfQVBJX0tFWSIKCiMgRUNSCmF3cyBlY3IgZ2V0LWxv" + + "Z2luLXBhc3N3b3JkIC0tcmVnaW9uIDxyZWdpb24+IHwgXAogIGhlbG0gcmVnaXN0cnkgbG9naW4g" + + "LS11c2VybmFtZSBBV1MgLS1wYXNzd29yZC1zdGRpbiA8YWNjb3VudD4uZGtyLmVjci48cmVnaW9u" + + "Pi5hbWF6b25hd3MuY29tCmBgYAoKPiBOb3RlOiBgaGVsbSByZWdpc3RyeSBsb2dpbmAga2VlcHMg" + + "b25seSB0aGUgbGFzdCBsb2dpbiBwZXIgaG9zdCAobXVsdGktb3JnIGdvdGNoYSkuCj4gVGhlIHN0" + + "YWNrIGFuZCB0aGUgY2FjaGVzIHNwYW4gc2V2ZXJhbCBOR0Mgb3JncyB0aGF0IG5lZWQgZGlmZmVy" + + "ZW50IGtleXMsIGJ1dCB0aGV5IGFsbAo+IGxpdmUgdW5kZXIgdGhlIG9uZSBob3N0IGBudmNyLmlv" + + "YC4gQSBzZWNvbmQgYGhlbG0gcmVnaXN0cnkgbG9naW4gbnZjci5pb2AgKG9yCj4gYGRvY2tlciBs" + + "b2dpbmApIHdpdGggYSBkaWZmZXJlbnQga2V5IHNpbGVudGx5IG92ZXJ3cml0ZXMgdGhlIGZpcnN0" + + "LCBzbyBwdWxscyBmb3IgdGhlCj4gZmlyc3Qgb3JnIHRoZW4gZmFpbCB3aXRoIGEgbWlzbGVhZGlu" + + "ZyBgNDAzIEFjY2VzcyBEZW5pZWRgIChub3QgYSA0MDE6IHRoZSBhdXRoCj4gc3VjY2VlZGVkLCBp" + + "dCdzIHRoZSB3cm9uZy1vcmcga2V5KS4gSWYgeW91IHB1bGwgY2hhcnRzL2ltYWdlcyBmcm9tIG1v" + + "cmUgdGhhbiBvbmUgb3JnLAo+IGVpdGhlciByZS1ydW4gdGhlIGxvZ2luIHdpdGggdGhlIGNvcnJl" + + "Y3Qga2V5IGltbWVkaWF0ZWx5IGJlZm9yZSBlYWNoIHB1bGwsIG9yIHBhc3MKPiBgLS11c2VybmFt" + + "ZSAnJG9hdXRodG9rZW4nIC0tcGFzc3dvcmQgPGtleT5gIHBlciBgaGVsbSBwdWxsYCBpbnZvY2F0" + + "aW9uIGluc3RlYWQgb2YgcmVseWluZwo+IG9uIHRoZSBzdG9yZWQgbG9naW4uIChQdWxsaW5nIGV2" + + "ZXJ5dGhpbmcgZnJvbSBhIHNpbmdsZSByZWdpc3RyeSBtaXJyb3IgYXZvaWRzIHRoaXMKPiBlbnRp" + + "cmVseS4pCgojIyMgMmIuIChSZWNvbW1lbmRlZCkgUHVsbCBmcm9tIGEgcmVnaXN0cnkgdGhlIGNs" + + "dXN0ZXIgYXV0aGVudGljYXRlcyB0byBhdXRvbWF0aWNhbGx5CgpJZiB5b3UgbWlycm9yIHRoZSBO" + + "VkNGIGltYWdlcyBpbnRvIGEgcmVnaXN0cnkgdGhhdCB0aGUgY2x1c3RlciBjYW4gcHVsbCBmcm9t" + + "IHdpdGhvdXQgYW4KZXhwbGljaXQgaW1hZ2UgcHVsbCBzZWNyZXQgKGZvciBleGFtcGxlLCBhIHJl" + + "Z2lzdHJ5IHdoZXJlIHRoZSBub2RlIG9yIHdvcmtsb2FkIGlkZW50aXR5IGlzCmdyYW50ZWQgcHVs" + + "bCBhY2Nlc3MgYXV0b21hdGljYWxseSksIHBvaW50IHRoZSBzdGFjayBhdCBpdCBhbmQgc2tpcCB0" + + "aGUgY3JlZGVudGlhbCBzdGVwcwphYm92ZS4KCjEuIFBvaW50IHRoZSBzdGFjayBhdCB0aGUgbWly" + + "cm9yIGluIGBlbnZpcm9ubWVudHMvPGVudj4ueWFtbGA6CgogICBgYGB5YW1sCiAgIGdsb2JhbDoK" + + "ICAgICBpbWFnZToKICAgICAgIHJlZ2lzdHJ5OiA8eW91ci1yZWdpc3RyeT4gICAgICAgICAgICAj" + + "IGUuZy4gcmVnaXN0cnkuZXhhbXBsZS5jb20KICAgICAgIHJlcG9zaXRvcnk6IDxtaXJyb3Itc3Vi" + + "LXBhdGg+CiAgICAgaGVsbToKICAgICAgIHNvdXJjZXM6ICAgICAgICAgICAgICAgICAgICAgICAg" + + "ICAgICAgIyBvbmx5IGlmIHlvdSBhbHNvIG1pcnJvcmVkIHRoZSBoZWxtIGNoYXJ0cwogICAgICAg" + + "ICByZWdpc3RyeTogPHlvdXItcmVnaXN0cnk+CiAgICAgICAgIHJlcG9zaXRvcnk6IDxtaXJyb3It" + + "c3ViLXBhdGg+CiAgIGBgYAoKICAgPiBUaGUgbWFuaWZlc3QgaGFzIGEgbWl4IG9mIE9DSSBhbmQg" + + "bm9uLU9DSSBhcnRpZmFjdHMsIHNvIGNvbnZlcnQgbm9uLU9DSSBjaGFydHMgYmVmb3JlCiAgID4g" + + "bWlycm9yaW5nLiBDb250YWluZXIgaW1hZ2VzIChgbnZjci5pby8uLi5gKSBhcmUgYWxyZWFkeSBP" + + "Q0kgYW5kIG1pcnJvciBhcy1pcy4gU29tZSBIZWxtCiAgID4gY2hhcnRzLCB0aG91Z2gsIGFyZSBw" + + "dWJsaXNoZWQgdG8gYW4gYGh0dHBzOi8vYCBIZWxtIHJlcG9zaXRvcnkgKGZvciBleGFtcGxlCiAg" + + "ID4gYGhlbG0ubmdjLm52aWRpYS5jb21gKS4gVGhvc2UgYXJlIG5vdCBPQ0kgYW5kIGNhbm5vdCBi" + + "ZSByZXNvbHZlZCBieSBgZ2xvYmFsLmhlbG0uc291cmNlc2AKICAgPiAoT0NJKSBvciBtaXJyb3Jl" + + "ZCBkaXJlY3RseS4gQmVmb3JlIHBvaW50aW5nIHRoZSBzdGFjayBhdCB5b3VyIG1pcnJvciwgY29u" + + "dmVydCBlYWNoCiAgID4gYGh0dHBzOi8vYCBjaGFydCB0byBPQ0k6IGBoZWxtIHJlcG8gYWRkYC9g" + + "aGVsbSBwdWxsYCB0aGUgYC50Z3pgLCB0aGVuCiAgID4gYGhlbG0gcHVzaCA8Y2hhcnQ+LnRneiBv" + + "Y2k6Ly88eW91ci1yZWdpc3RyeT4vPG1pcnJvci1zdWItcGF0aD5gLiBPbmx5IE9DSSBjaGFydHMg" + + "Y2FuIGxpdmUKICAgPiB1bmRlciBgZ2xvYmFsLmhlbG0uc291cmNlc2AuCgoyLiBTa2lwIHRoZSBj" + + "cmVkZW50aWFsIHN0ZXBzIGFib3ZlLiBXaGVuIHRoZSBjbHVzdGVyIGF1dGhlbnRpY2F0ZXMgdG8g" + + "dGhlIHJlZ2lzdHJ5CiAgIGF1dG9tYXRpY2FsbHkgKHRoZSBub2RlIG9yIHdvcmtsb2FkIGlkZW50" + + "aXR5IGhhcyBwdWxsIGFjY2VzcyksIHRoZSBwdWxsIG5lZWRzIG5vCiAgIEt1YmVybmV0ZXMgc2Vj" + + "cmV0LCBzbyB5b3UgZG8gbm90IG5lZWQ6IHRoZSBwZXItbmFtZXNwYWNlIGBudmNyLWNyZWRzYCBm" + + "cm9tIHN0ZXAgMQogICAoc3RpbGwgY3JlYXRlIHRoZSBuYW1lc3BhY2VzLCBqdXN0IG5vdCB0aGUg" + + "c2VjcmV0KSwgdGhlIGBnbG9iYWwuaW1hZ2VQdWxsU2VjcmV0c2AgZW50cnksCiAgIG9yIHRoZSBg" + + "ZG9ja2VyIGxvZ2luYC9gaGVsbSByZWdpc3RyeSBsb2dpbiBudmNyLmlvYCBmcm9tIHN0ZXAgMi4K" + + "CiAgID4gT25lIHJlc2lkdWFsIGNyZWRlbnRpYWw6IG52Y2YtYXBpIHN0aWxsIHZhbGlkYXRlcyB0" + + "aGUgdXNlciBmdW5jdGlvbiBpbWFnZSBhdAogICA+IGBmdW5jdGlvbiBjcmVhdGVgIHZpYSB0aGUg" + + "YWNjb3VudCByZWdpc3RyeSBjcmVkZW50aWFsLCBzbyB0aGF0IGNyZWRlbnRpYWwgbXVzdCBwb2lu" + + "dCBhdAogICA+IHdoaWNoZXZlciByZWdpc3RyeSBob2xkcyB0aGUgdXNlciBpbWFnZSAoc2V0IGl0" + + "IHRvIHlvdXIgbWlycm9yIGlmIHRoZSBpbWFnZSBpcyBtaXJyb3JlZAogICA+IHRoZXJlKS4KCiMj" + + "IyAzLiBTZXQgdGhlIHJvdXRlIGRvbWFpbgoKYGdsb2JhbC5kb21haW5gIHNldHMgdGhlIGhvc3Ru" + + "YW1lIHN1ZmZpeCBmb3Igcm91dGVzIHN1Y2ggYXMgYGFwaS48ZG9tYWluPmAuIEl0IGRvZXMgbm90" + + "IGNvbmZpZ3VyZSB0aGUgR2F0ZXdheSBvciBpdHMgbG9hZCBiYWxhbmNlci4gUXVlcnkgdGhlIGV4" + + "YWN0IGV4aXN0aW5nIEdhdGV3YXk6CgpgYGBiYXNoCkdBVEVXQVlfQUREUkVTUz0kKGt1YmVjdGwg" + + "Z2V0IGdhdGV3YXkgPGdhdGV3YXktbmFtZT4gLW4gPGdhdGV3YXktbmFtZXNwYWNlPiAtbyBqc29u" + + "cGF0aD0ney5zdGF0dXMuYWRkcmVzc2VzWzBdLnZhbHVlfScpCnRlc3QgLW4gIiRHQVRFV0FZX0FE" + + "RFJFU1MiCmBgYAoKVGhlIGFkZHJlc3MgbWF5IGJlIGEgaG9zdG5hbWUgb3IgSVAuIENsb3VkIHBy" + + "b3ZpZGVyIGFuZCBHYXRld2F5IGNvbmZpZ3VyYXRpb24gZGV0ZXJtaW5lIHRoZSBsb2FkIGJhbGFu" + + "Y2VyIHR5cGUgYW5kIGFkZHJlc3MgZm9ybWF0LiBUaGUgc2VsZi1tYW5hZ2VkIHN0YWNrIGRvZXMg" + + "bm90IHNlbGVjdCBlaXRoZXIuCgpGb3IgdGVtcG9yYXJ5IHRlc3Rpbmcgd2l0aG91dCBETlMsIHVz" + + "ZSBhIHN0YWJsZSByZXNlcnZlZCBzdWZmaXggc3VjaCBhcyBgZ2xvYmFsLmRvbWFpbjogIm52Y2Yu" + + "dGVzdCJgLCBjb25uZWN0IHRvIGBHQVRFV0FZX0FERFJFU1NgLCBhbmQgc2VuZCBgSG9zdDogYXBp" + + "Lm52Y2YudGVzdGAuIEZvciBwcm9kdWN0aW9uLCB1c2UgeW91ciBiYXNlIEROUyBkb21haW4gYW5k" + + "IHBvaW50IGl0cyByb3V0ZSByZWNvcmRzIHRvIGBHQVRFV0FZX0FERFJFU1NgLiBJZiB0aGUgZW5k" + + "cG9pbnQgbGF0ZXIgY2hhbmdlcywga2VlcCBgZ2xvYmFsLmRvbWFpbmAgc3RhYmxlIGFuZCB1cGRh" + + "dGUgb25seSBETlMgb3IgdGhlIGNsaWVudCBkZXN0aW5hdGlvbi4gU2VlIEV4YW1wbGUgNCBpbiBb" + + "ZXhhbXBsZXMubWRdKGV4YW1wbGVzLm1kKS4KCiMjIyA0LiBQcmV2aWV3IGFuZCBkZXBsb3kKCmBg" + + "YGJhc2gKSEVMTUZJTEVfRU5WPTxlbnYtbmFtZT4gaGVsbWZpbGUgdGVtcGxhdGUgICAjIFByZXZp" + + "ZXcgcmVuZGVyZWQgbWFuaWZlc3RzCkhFTE1GSUxFX0VOVj08ZW52LW5hbWU+IGhlbG1maWxlIHN5" + + "bmMgICAgICAgIyBEZXBsb3kKYGBgCgo+IFNldCBCT1RIIENhc3NhbmRyYSBwYXNzd29yZHMgaW4g" + + "dGhlIHNlY3JldHMgZmlsZS4gVGhlIHNlY3JldHMgZmlsZSBkb2N1bWVudHMKPiBgREVGQVVMVF9D" + + "QVNTQU5EUkFfUEFTU1dPUkRgLCBidXQgdGhlIGNhc3NhbmRyYSBjaGFydCBoYXMgYSBzZWNvbmQg" + + "Y3JlZGVudGlhbCwKPiBgY2Fzc2FuZHJhLnNlcnZpY2VSb2xlUGFzc3dvcmRgLCB0aGF0IGRlZmF1" + + "bHRzIHRvIGBjaEBuZzNtM2AuIElmIHlvdSBzZXQgb25seQo+IGBERUZBVUxUX0NBU1NBTkRSQV9Q" + + "QVNTV09SRGAsIHRoZSBzZXJ2aWNlIHJvbGUga2VlcHMgdGhhdCBkZWZhdWx0IGFuZCBldmVyeSBE" + + "Qi1iYWNrZWQKPiBzZXJ2aWNlIGNyYXNoLWxvb3BzIHdpdGggYEJhZCBjcmVkZW50aWFsc2Agb25j" + + "ZSBpdCB0cmllcyB0byBhdXRoZW50aWNhdGUuIFNldAo+IGBjYXNzYW5kcmEuc2VydmljZVJvbGVQ" + + "YXNzd29yZGAgdG8gdGhlIHNhbWUgdmFsdWUgYXMgYERFRkFVTFRfQ0FTU0FORFJBX1BBU1NXT1JE" + + "YC4KCiMjIyA1LiBEZXBsb3ltZW50IHBoYXNlcwoKSGVsbWZpbGUgZGVwbG95cyBpbiBvcmRlciB3" + + "aXRoIGRlcGVuZGVuY2llczoKCnwgUGhhc2UgfCBTZWxlY3RvciB8IFNlcnZpY2VzIHwgV2FpdCB0" + + "aW1lIHwKfC0tLS0tLS18LS0tLS0tLS0tLXwtLS0tLS0tLS0tfC0tLS0tLS0tLS0tfAp8IDEgfCBg" + + "cmVsZWFzZS1ncm91cD1kZXBlbmRlbmNpZXNgIHwgTkFUUywgT3BlbkJhbywgQ2Fzc2FuZHJhIHwg" + + "NS0xMCBtaW4gfAp8IDIgfCBgcmVsZWFzZS1ncm91cD1zZXJ2aWNlc2AgfCBBUEksIFNJUywgRVNT" + + "LCBpbnZvY2F0aW9uLCBncnBjLXByb3h5LCBub3RhcnksIGFwaS1rZXlzLCBvcHRpb25hbCBMTE0g" + + "Z2F0ZXdheS9yb3V0ZXIsIG9wdGlvbmFsIFZhbml0eSBHYXRld2F5LCBOVkNGIFVJIHdoZW4gdGhl" + + "IHN0YWNrIHBhY2thZ2UgaW5jbHVkZXMgdGhlIGFkZG9uIHwgNS0xMCBtaW4gfAp8IDMgfCBgcmVs" + + "ZWFzZS1ncm91cD1pbmdyZXNzYCB8IEdhdGV3YXkgcm91dGVzIHwgMS0yIG1pbiB8CnwgNCB8IGBy" + + "ZWxlYXNlLWdyb3VwPW9ic2VydmFiaWxpdHlgIHwgT2JzZXJ2YWJpbGl0eSBzdGFjayAoaWYgZW5h" + + "YmxlZCkgfCAxLTIgbWluIHwKCk1vbml0b3IgaW4gYSBzZXBhcmF0ZSB0ZXJtaW5hbDoKCmBgYGJh" + + "c2gKa3ViZWN0bCBnZXQgcG9kcyAtQSAtdwpgYGAKCiMjIyA2LiBFbmFibGUgVmFuaXR5IEdhdGV3" + + "YXkgKG9wdGlvbmFsKQoKVmFuaXR5IEdhdGV3YXkgaXMgZGlzYWJsZWQgYnkgZGVmYXVsdCBhbmQg" + + "aXMgb25seSBuZWVkZWQgZm9yIGN1c3RvbWVyLWZhY2luZwpob3N0bmFtZXMgb3IgcGF0aCBtYXBw" + + "aW5ncyBpbiBmcm9udCBvZiB0aGUgc3RhbmRhcmQgTlZDRiBBUEkgYW5kIGludm9jYXRpb24Kcm91" + + "dGVzLiBJdCBpcyBhdmFpbGFibGUgb25seSBpbiBzdGFjayBwYWNrYWdlcyB0aGF0IGluY2x1ZGUg" + + "dGhlIFZhbml0eSBHYXRld2F5CmFkZG9uLiBJZiB0aGUgZXh0cmFjdGVkIHN0YWNrIHBhY2thZ2Ug" + + "ZG9lcyBub3QgY29udGFpbiBhIGB2YW5pdHktZ2F0ZXdheWAKcmVsZWFzZSBhbmQgYHZhbml0eUdh" + + "dGV3YXlgIHJvdXRlIHZhbHVlcywgc2tpcCB0aGVzZSBjb21tYW5kcyBhbmQgdXNlIGEgbmV3ZXIK" + + "c3RhY2sgcGFja2FnZSB0aGF0IGluY2x1ZGVzIHRoZW0uCgpJZiB0aGUgc3RhY2sgcGFja2FnZSBp" + + "bmNsdWRlcyB0aGUgYWRkb24sIGVuYWJsZSBpdCBpbgpgZW52aXJvbm1lbnRzLzxlbnYtbmFtZT4u" + + "eWFtbGA6CgpgYGB5YW1sCmFkZG9uczoKICB2YW5pdHlHYXRld2F5OgogICAgZW5hYmxlZDogdHJ1" + + "ZQogICAgbWFwcGluZ0NvbmZpZzoge30KYGBgCgpUaGUgZGVmYXVsdCByb3V0ZSBob3N0IGlzIGB2" + + "YW5pdHkuPGRvbWFpbj5gIGFuZCB0aGUgYmFja2VuZCBpcwpgdmFuaXR5LWdhdGV3YXkubnZjZjo4" + + "MDgwYC4gUHV0IGRlcGxveW1lbnQtc3BlY2lmaWMgaG9zdCBhbmQgcGF0aCBtYXBwaW5ncyB1bmRl" + + "cgpgYWRkb25zLnZhbml0eUdhdGV3YXkubWFwcGluZ0NvbmZpZ2AuIElmIHlvdSBuZWVkIGN1c3Rv" + + "bSB2YW5pdHkgaG9zdHMgaW5zdGVhZCBvZgpgdmFuaXR5Ljxkb21haW4+YCwgdXNlIHRoZSByb3V0" + + "ZSBob3N0bmFtZSBvdmVycmlkZXMgc3VwcG9ydGVkIGJ5IHRoZSBzdGFjawpwYWNrYWdlIGFuZCBj" + + "cmVhdGUgbWF0Y2hpbmcgRE5TIHJlY29yZHMuCgpBZnRlciBjb25maXJtaW5nIHRoZSBwYWNrYWdl" + + "IGluY2x1ZGVzIHRoZSBgdmFuaXR5LWdhdGV3YXlgIHJlbGVhc2UsIHByZXZpZXcgYW5kCmFwcGx5" + + "IHRoZSBzZXJ2aWNlIGFuZCByb3V0ZToKCmBgYGJhc2gKSEVMTUZJTEVfRU5WPTxlbnYtbmFtZT4g" + + "aGVsbWZpbGUgLS1zZWxlY3RvciBuYW1lPXZhbml0eS1nYXRld2F5IHRlbXBsYXRlCkhFTE1GSUxF" + + "X0VOVj08ZW52LW5hbWU+IGhlbG1maWxlIC0tc2VsZWN0b3IgbmFtZT12YW5pdHktZ2F0ZXdheSBz" + + "eW5jCkhFTE1GSUxFX0VOVj08ZW52LW5hbWU+IGhlbG1maWxlIC0tc2VsZWN0b3IgcmVsZWFzZS1n" + + "cm91cD1pbmdyZXNzIHN5bmMKYGBgCgpWZXJpZnkgdGhlIHJvdXRlIG9ubHkgd2hlbiB0aGUgYWRk" + + "b24gaXMgcHJlc2VudCBhbmQgZW5hYmxlZDoKCmBgYGJhc2gKa3ViZWN0bCBnZXQgZGVwbG95LHN2" + + "YyAtbiBudmNmIC1sIGFwcC5rdWJlcm5ldGVzLmlvL25hbWU9dmFuaXR5LWdhdGV3YXkKa3ViZWN0" + + "bCBnZXQgaHR0cHJvdXRlIC1BIHwgZ3JlcCAtaSB2YW5pdHkKY3VybCAtSCAiSG9zdDogdmFuaXR5" + + "Ljxkb21haW4+IiAiaHR0cDovLzxnYXRld2F5LWFkZHJlc3M+L2hlYWx0aCIKYGBgCgpEbyBub3Qg" + + "ZW5hYmxlIFZhbml0eSBHYXRld2F5IGZvciBzdGFuZGFyZCBBUEksIEFQSSBLZXlzLCBpbnZvY2F0" + + "aW9uLCBMTE0KaW52b2NhdGlvbiwgb3IgZ1JQQyB0cmFmZmljLiBUaG9zZSByb3V0ZXMgYXJlIHBy" + + "b3ZpZGVkIGJ5IHRoZSBiYXNlIGdhdGV3YXkKcm91dGVzLgoKIyMjIDcuIEVuYWJsZSBOVkNGIFVJ" + + "IChvcHRpb25hbCkKCk5WQ0YgVUkgaXMgYW4gb3B0aW9uYWwsIGN1c3RvbWVyLWZhY2luZyBhZG1p" + + "bi1wYW5lbCBVSS4gSXQgaXMgZGlzYWJsZWQgYnkKZGVmYXVsdCBhbmQgYXZhaWxhYmxlIG9ubHkg" + + "aW4gc3RhY2sgcGFja2FnZXMgdGhhdCBpbmNsdWRlIHRoZSBOVkNGIFVJIGFkZG9uLiBJZgp5b3Vy" + + "IGV4dHJhY3RlZCBzdGFjayBwYWNrYWdlIGRvZXMgbm90IGNvbnRhaW4gYSBgbnZjZi11aWAgcmVs" + + "ZWFzZSBhbmQgYG52Y2ZVaWAKcm91dGUgdmFsdWVzLCBza2lwIHRoaXMgc2VjdGlvbi4gVGhlIE5W" + + "Q0YgVUkgYWRtaW4gcGFuZWwgaXMgY3VycmVudGx5CnVuYXV0aGVudGljYXRlZDsgZG8gbm90IGV4" + + "cG9zZSBpdCB0byB0aGUgcHVibGljIGludGVybmV0LgoKRm9yIGVuYWJsZW1lbnQsIG5hbWVzcGFj" + + "ZSBhbmQgcHVsbCBzZWNyZXQgc2V0dXAsIGFwcGx5LCBhbmQgdmVyaWZpY2F0aW9uIHN0ZXBzLApz" + + "ZWUgW05WQ0YgVUkgQWRkb25dKHJlZmVyZW5jZXMvbnZjZi11aS1hZGRvbi5tZCkuCgojIyMgOC4g" + + "SW5zdGFsbCB0aGUgc2VwYXJhdGUgY29tcHV0ZS1wbGFuZSBzdGFjawoKVGhlIGNvbnRyb2wtcGxh" + + "bmUgc3RhY2sgZG9lcyBub3QgaW5zdGFsbCBjb21wdXRlLXBsYW5lIGNvbXBvbmVudHMuIEFmdGVy" + + "IGl0IGlzIGhlYWx0aHksIGNob29zZSBleGFjdGx5IG9uZSBjb21wdXRlLXBsYW5lIGhhbmRvZmY6" + + "CgotIEhlbG1maWxlIHZhbHVlcyBmbG93OiBhdXRob3Igc2VwYXJhdGUgZW52aXJvbm1lbnQgZmls" + + "ZXMsIHRoZW4gcmVnaXN0ZXIgYW5kCiAgaW5zdGFsbCB3aXRoIHRoZSBjb21wdXRlLXBsYW5lIE1h" + + "a2VmaWxlLgotIENMSSBwcm9maWxlIGZsb3c6IHVzZSB0aGUgcHJvZmlsZSBnZW5lcmF0ZWQgYnkg" + + "dGhlIENMSSBjb250cm9sLXBsYW5lIGluc3RhbGwsCiAgdGhlbiBydW4gdGhlIGNvbXBsZXRlIENM" + + "SSByZWdpc3RlciBhbmQgaW5zdGFsbCBjb21tYW5kcy4KCkRvIG5vdCBtaXggdGhlc2UgaGFuZG9m" + + "ZnMuIEZvbGxvdyBbU3BsaXQgQ29tcHV0ZS1QbGFuZSBJbnN0YWxsYXRpb25dKHJlZmVyZW5jZXMv" + + "Y29tcHV0ZS1wbGFuZS1pbnN0YWxsYXRpb24ubWQpCmZvciBjb21tYW5kcywgRUtTIHJvdXRpbmcs" + + "IHB1bGwgc2VjcmV0cywgdmVyaWZpY2F0aW9uLCBhbmQgdGVhcmRvd24gb3JkZXIuCgojIyBDbGVh" + + "biBUZWFyZG93bgoKRGVzdHJveSBldmVyeSBjb21wdXRlIHBsYW5lIGJlZm9yZSB0aGUgY29udHJv" + + "bCBwbGFuZSwgdXNpbmcgdGhlIHRlYXJkb3duIGZvcgp0aGUgc2FtZSBoYW5kb2ZmOyBzZWUgW1Nw" + + "bGl0IENvbXB1dGUtUGxhbmUgSW5zdGFsbGF0aW9uXShyZWZlcmVuY2VzL2NvbXB1dGUtcGxhbmUt" + + "aW5zdGFsbGF0aW9uLm1kI3RlYXJkb3duKS4KClNjb3BlOiBPbmx5IGRlc3Ryb3kgcmVsZWFzZXMg" + + "bWFuYWdlZCBieSB0aGlzIGNvbnRyb2wtcGxhbmUgaGVsbWZpbGUgc3RhY2suIFRoZSBOVkNGIHJl" + + "bGVhc2VzIGFyZTogYG5hdHNgLCBgb3BlbmJhby1zZXJ2ZXJgLCBgY2Fzc2FuZHJhYCwgYGFwaS1r" + + "ZXlzYCwgYHNpc2AsIGBhcGlgLCBgaW52b2NhdGlvbi1zZXJ2aWNlYCwgYGdycGMtcHJveHlgLCBg" + + "ZXNzLWFwaWAsIGBub3Rhcnktc2VydmljZWAsIG9wdGlvbmFsIGB2YW5pdHktZ2F0ZXdheWAsIGBu" + + "dmNmLXVpYCwgYGFkbWluLWlzc3Vlci1wcm94eWAsIGFuZCBgaW5ncmVzc2A7IGBjZXJ0LW1hbmFn" + + "ZXJgIGlzIGluY2x1ZGVkIG9ubHkgd2hlbiBgY2VydE1hbmFnZXIuZW5hYmxlZDogdHJ1ZWAuIFRo" + + "ZSBjb250cm9sLXBsYW5lIG5hbWVzcGFjZSBpbnZlbnRvcnkgYWxzbyBpbmNsdWRlcyBgY2VydC1t" + + "YW5hZ2VyYCwgYnV0IGRlZmF1bHQgbmFtZXNwYWNlIGNsZWFudXAgcHJlc2VydmVzIGl0LiBOYW1l" + + "c3BhY2UgcHJlc2VydmF0aW9uIGRvZXMgbm90IHByZXNlcnZlIHRoZSBIZWxtIHJlbGVhc2UuIEV4" + + "dGVybmFsIGNlcnQtbWFuYWdlciBtdXN0IHVzZSBgY2VydE1hbmFnZXIuZW5hYmxlZDogZmFsc2Vg" + + "OyBvdGhlcndpc2UgSGVsbWZpbGUgdHJlYXRzIHRoZSByZWxlYXNlIGFzIHN0YWNrLW1hbmFnZWQu" + + "IERvIG5vdCBkZWxldGUgb3RoZXIgaGVsbSByZWxlYXNlcyBvciBuYW1lc3BhY2VzIG9uIHRoZSBj" + + "bHVzdGVyLgoKQmVmb3JlIGNvbnRyb2wtcGxhbmUgZGVzdHJveSwgaWRlbnRpZnkgd2hldGhlciBj" + + "ZXJ0LW1hbmFnZXIgaXMgZXh0ZXJuYWwuIEZvciBhbiBleHRlcm5hbCBpbnN0YWxsYXRpb24sIHJl" + + "cXVpcmUgZWZmZWN0aXZlIGBjZXJ0TWFuYWdlci5lbmFibGVkOiBmYWxzZWAgYW5kIGFib3J0IGlm" + + "IGl0IGlzIHRydWUuIEZvciBhbiBpbnRlbmRlZCBzdGFjay1tYW5hZ2VkIHJlbGVhc2Ugd2l0aCBl" + + "ZmZlY3RpdmUgYGNlcnRNYW5hZ2VyLmVuYWJsZWQ6IHRydWVgLCB2ZXJpZnkgbWF0Y2hpbmcgc3Rh" + + "Y2sgSGVsbSByZWxlYXNlIG1ldGFkYXRhIGFuZCBhYm9ydCBvbiBtaXNzaW5nIG9yIG1pc21hdGNo" + + "ZWQgZXZpZGVuY2UuIFByZXNlcnZlIHRoZSBuYW1lc3BhY2UgYnkgZGVmYXVsdDsgb25seSBwbGFu" + + "IGl0cyByZW1vdmFsIGFmdGVyIHZlcmlmeWluZyBuYW1lc3BhY2UgcHJvdmVuYW5jZSBhbmQgZ2V0" + + "dGluZyBleHBsaWNpdCBjb25maXJtYXRpb24uCgojIyMgU3RhbmRhcmQgdGVhcmRvd24KClJ1biBm" + + "cm9tIGluc2lkZSB0aGUgYG52Y2Ytc2VsZi1tYW5hZ2VkLXN0YWNrL2AgZGlyZWN0b3J5OgoKYGBg" + + "YmFzaApIRUxNRklMRV9FTlY9PGVudi1uYW1lPiBoZWxtZmlsZSBkZXN0cm95CmBgYAoKIyMjIERl" + + "bGV0ZSBuYW1lc3BhY2VzCgpgYGBiYXNoCmZvciBucyBpbiBjYXNzYW5kcmEtc3lzdGVtIG5hdHMt" + + "c3lzdGVtIG52Y2YgYXBpLWtleXMgZXNzIHNpcyBudmNmLXVpIHZhdWx0LXN5c3RlbTsgZG8KICBr" + + "dWJlY3RsIGRlbGV0ZSBuYW1lc3BhY2UgIiRucyIgLS1pZ25vcmUtbm90LWZvdW5kCmRvbmUKYGBg" + + "CgojIyMgVmVyaWZ5IGNsZWFuCgpgYGBiYXNoCmt1YmVjdGwgZ2V0IG5zIHwgZ3JlcCAtRSAnKGNh" + + "c3NhbmRyYXxuYXRzfHZhdWx0fG52Y2Z8YXBpLWtleXN8ZXNzfHNpcyknCiMgU2hvdWxkIHJldHVy" + + "biBlbXB0eQpgYGAKCiMjIE92ZXJyaWRpbmcgSGVsbSBDaGFydCBWYWx1ZXMKCiMjIyBFbnZpcm9u" + + "bWVudCBmaWxlIChsaW1pdGVkKQoKV29ya3Mgb25seSBmb3Iga2V5cyB0aGF0IGBnbG9iYWwueWFt" + + "bC5nb3RtcGxgIHByb3BhZ2F0ZXMgKGUuZy4sIGBjYXNzYW5kcmEucmVwbGljYUNvdW50YCwgYGds" + + "b2JhbC5zdG9yYWdlQ2xhc3NgLCBgZ2xvYmFsLmltYWdlYCkuCgojIyMgUmVsZWFzZSB2YWx1ZXMg" + + "YmxvY2sgKGFueSBjaGFydCB2YWx1ZSkKCkVkaXQgdGhlIHJlbGVhc2UgaW4gYGhlbG1maWxlLmQv" + + "Ki55YW1sLmdvdG1wbGAgYW5kIGFkZCBhIGB2YWx1ZXM6YCBibG9jay4gSW4gdGhlIGV4YW1wbGVz" + + "IGJlbG93LCBgPHByaXZhdGUtdmFsdWVzPmAgcmVmZXJzIHRvIHRoZSBgc2VjcmV0cy9gIGRpcmVj" + + "dG9yeSBhdCB0aGUgaGVsbWZpbGUgc3RhY2sgcm9vdC4KCmBgYHlhbWwKLSBuYW1lOiBjYXNzYW5k" + + "cmEKICB2ZXJzaW9uOiAwLjguMAogIGNvbmRpdGlvbjogY2Fzc2FuZHJhLmVuYWJsZWQKICBuYW1l" + + "c3BhY2U6IGNhc3NhbmRyYS1zeXN0ZW0KICA8PDogKmRlcGVuZGVuY3kKICB2YWx1ZXM6CiAgICAt" + + "IC4uL2dsb2JhbC55YW1sLmdvdG1wbAogICAgLSAuLi88cHJpdmF0ZS12YWx1ZXM+L3t7IHJlcXVp" + + "cmVkRW52ICJIRUxNRklMRV9FTlYiIH19LXNlY3JldHMueWFtbAogICAgLSBjYXNzYW5kcmE6CiAg" + + "ICAgICAgcmVzb3VyY2VzOgogICAgICAgICAgbGltaXRzOgogICAgICAgICAgICBjcHU6ICI4Igog" + + "ICAgICAgICAgICBtZW1vcnk6IDgxOTJNaQogICAgICAgICAgcmVxdWVzdHM6CiAgICAgICAgICAg" + + "IGNwdTogIjIiCiAgICAgICAgICAgIG1lbW9yeTogNDA5Nk1pCmBgYAoKWUFNTCBtZXJnZSBnb3Rj" + + "aGE6IFdoZW4gYSByZWxlYXNlIHVzZXMgYDw8OiAqZGVwZW5kZW5jeWAgb3IgYGluaGVyaXRgLCBz" + + "cGVjaWZ5aW5nIGB2YWx1ZXM6YCByZXBsYWNlcyB0aGUgdGVtcGxhdGUncyB2YWx1ZXMgbGlzdC4g" + + "WW91IG11c3QgcmUtaW5jbHVkZSBgZ2xvYmFsLnlhbWwuZ290bXBsYCBhbmQgdGhlIHNlY3JldHMg" + + "ZmlsZS4KCiMjIyBQcmV2aWV3IGFuZCBhcHBseSBhIHNpbmdsZSByZWxlYXNlCgpgYGBiYXNoCkhF" + + "TE1GSUxFX0VOVj08ZW52PiBoZWxtZmlsZSAtLXNlbGVjdG9yIG5hbWU9Y2Fzc2FuZHJhIHRlbXBs" + + "YXRlICAjIFByZXZpZXcKSEVMTUZJTEVfRU5WPTxlbnY+IGhlbG1maWxlIC0tc2VsZWN0b3IgbmFt" + + "ZT1jYXNzYW5kcmEgc3luYyAgICAgICMgQXBwbHkKYGBgCgojIyBJbWFnZSBQdWxsIFNlY3JldHMK" + + "ClRoZXJlIGFyZSB0aHJlZSBkaXN0aW5jdCBjcmVkZW50aWFsIHR5cGVzLiBEbyBub3QgY29uZmxh" + + "dGUgdGhlbSwgYW5kIG1pbmQgdGhlCmZvcm1hdCBydWxlIGJlbG93ICh0d28gb2YgdGhlbSBmYWls" + + "IGV2ZW4gd2l0aCB0aGUgY29ycmVjdCBrZXkgaWYgdGhlIGZvcm1hdCBpcyB3cm9uZyk6Cgp8IHwg" + + "Q29udHJvbCBQbGFuZSBQdWxsIFNlY3JldHMgfCBBUEkgQm9vdHN0cmFwIFJlZ2lzdHJ5IENyZWRz" + + "IHwgU2lkZWNhciBJbWFnZS1QdWxsIFNlY3JldCB8CnwtLS18LS0tfC0tLXwtLS18CnwgUHVycG9z" + + "ZSB8IEs4cyBwdWxscyBOVkNGIHNlcnZpY2UgaW1hZ2VzIHwgbnZjZi1hcGkgdmFsaWRhdGVzIHRo" + + "ZSB1c2VyIGZ1bmN0aW9uIGltYWdlIGF0IGBmdW5jdGlvbiBjcmVhdGVgIHwgbnZjZi1hcGkgcHVs" + + "bHMgdGhlIHBsYXRmb3JtIHNpZGVjYXJzIGluamVjdGVkIGludG8gZXZlcnkgd29ya2VyIHBvZCB8" + + "CnwgV2hlcmUgfCBLOHMgYGRvY2tlci1yZWdpc3RyeWAgU2VjcmV0cyArIEt5dmVybm8gQ2x1c3Rl" + + "clBvbGljeSB8IGA8cHJpdmF0ZS12YWx1ZXM+LzxlbnY+LXNlY3JldHMueWFtbGAgKGFjY291bnQt" + + "Ym9vdHN0cmFwKSB8IGBOVkNGX0FQSV9TSURFQ0FSU19JTUFHRV9QVUxMX1NFQ1JFVGAgaW4gYDxl" + + "bnY+LXNlY3JldHMueWFtbGAgLT4gT3BlbkJhbyBgc2VydmljZXMvbnZjZi1hcGkva3Yvc2lkZWNh" + + "cnMvaW1hZ2UtcHVsbC1zZWNyZXRgIChmaWVsZCBgc2VjcmV0YCkgfAp8IEZvcm1hdCB8IHN0YW5k" + + "YXJkIGAuZG9ja2VyY29uZmlnanNvbmAgKGt1YmVjdGwgYnVpbGRzIGl0IGZvciB5b3UpIHwgYGJh" + + "c2U2NCgiJG9hdXRodG9rZW46PGtleT4iKWAgfCBgYmFzZTY0KCIkb2F1dGh0b2tlbjo8a2V5PiIp" + + "YCB8Cgo+IE5vdGU6IHRoZSBhY2NvdW50LWJvb3RzdHJhcCBjcmVkIGFuZCB0aGUgc2lkZWNhciBz" + + "ZWNyZXQgYXJlIE5PVCBhCj4gZG9ja2VyY29uZmlnanNvbi4gVGhlIHNlY3JldHMgdGVtcGxhdGUg" + + "c2hpcHMgdGhlIHBsYWNlaG9sZGVyCj4gYFJFUExBQ0VfV0lUSF9CQVNFNjRfRE9DS0VSX0NSRURF" + + "TlRJQUxgLCB3aGljaCByZWFkcyBhcyAiYmFzZTY0IG9mIGEgZG9ja2VyY29uZmlnanNvbi4iCj4g" + + "SXQgaXNuJ3QuIEJvdGggdmFsdWVzIGFyZSBjb25zdW1lZCBhcyBhIHJhdyBkb2NrZXIgYGF1dGhg" + + "IHN0cmluZzogbnZjZi1hcGkgdGFrZXMgdGhlCj4gdmFsdWUgdmVyYmF0aW0gYW5kIGRyb3BzIGl0" + + "IGludG8gdGhlIGBhdXRoYCBmaWVsZCBvZiB0aGUgZG9ja2VyY29uZmlnIGl0IGJ1aWxkcy4gU28g" + + "dGhlCj4gdmFsdWUgbXVzdCBiZSBgYmFzZTY0KCIkb2F1dGh0b2tlbjo8a2V5PiIpYCwgZS5nLiBg" + + "cHJpbnRmICckb2F1dGh0b2tlbjolcycgIiRLRVkiIHwgb3BlbnNzbCBiYXNlNjQgLUFgLAo+IG5v" + + "dCBgYmFzZTY0KDxkb2NrZXJjb25maWdqc29uPilgLgo+ICAtIFdyb25nIGFjY291bnQtYm9vdHN0" + + "cmFwIHZhbHVlOiBgZnVuY3Rpb24gY3JlYXRlYCByZXR1cm5zCj4gICAgYDQwMCAibXVzdCBiZSBi" + + "YXNlNjQgZW5jb2RlZCB1c2VybmFtZTpwYXNzd29yZCBmb3JtYXQiYC4KPiAgLSBXcm9uZyBzaWRl" + + "Y2FyIHZhbHVlOiBldmVyeSB3b3JrZXIncyBzaWRlY2FyIHB1bGwgZ2V0cyBhIG1hbGZvcm1lZCBj" + + "cmVkZW50aWFsIGFuZAo+ICAgIGA0MDNgcywgcmVnYXJkbGVzcyBvZiB3aGljaCBrZXkgaXMgaW5z" + + "aWRlLiBUaGUgc3ltcHRvbSBsb29rcyBsaWtlIGEgYmFkIG9yIHdyb25nLW9yZwo+ICAgIGtleSwg" + + "YnV0IHRoZSBrZXkgaXMgZmluZSBhbmQgdGhlIGVuY29kaW5nIGlzIHRoZSBidWcuIFRvIHJlcGFp" + + "ciBhbiBhbHJlYWR5LWluc3RhbGxlZAo+ICAgIHN0YWNrIHdpdGhvdXQgYSBmdWxsIHJlLXN5bmM6" + + "Cj4gICAgYGBgYmFzaAo+ICAgIEFVVEg9JChwcmludGYgJyRvYXV0aHRva2VuOiVzJyAiJEtFWSIg" + + "fCBvcGVuc3NsIGJhc2U2NCAtQSkKPiAgICBiYW8ga3YgcHV0IHNlcnZpY2VzL252Y2YtYXBpL2t2" + + "L3NpZGVjYXJzL2ltYWdlLXB1bGwtc2VjcmV0IHNlY3JldD0iJEFVVEgiCj4gICAgIyBpZiBOVklE" + + "SUEgQ2xvdWQgVGFza3MgaXMgZW5hYmxlZCwgcmVwZWF0IGZvciBzZXJ2aWNlcy9udmN0LWFwaS9r" + + "di9zaWRlY2Fycy9pbWFnZS1wdWxsLXNlY3JldAo+ICAgIGt1YmVjdGwgcm9sbG91dCByZXN0YXJ0" + + "IC1uIG52Y2YgZGVwbG95L252Y2YtYXBpICAgIyBwaWNrcyB1cCB0aGUgbmV3IHNpZGVjYXIgY3Jl" + + "ZAo+ICAgIGBgYAoKPiBOb3RlIChtdWx0aS1vcmcpOiB3aGVuIHB1bGxpbmcgZnJvbSBOR0MgKG5v" + + "dCBhIG1pcnJvciksIHRoZSB1c2VyIGZ1bmN0aW9uIGltYWdlIGFuZAo+IHRoZSBwbGF0Zm9ybSBz" + + "aWRlY2FycyBvZnRlbiBsaXZlIGluIGRpZmZlcmVudCBudmNyLmlvIG9yZ3MsIGVhY2ggbmVlZGlu" + + "ZyBhIGRpZmZlcmVudAo+IGtleSwgc28gdGhlIGFjY291bnQtYm9vdHN0cmFwIGNyZWQgKGZ1bmN0" + + "aW9uIGltYWdlKSBhbmQgdGhlIHNpZGVjYXIgc2VjcmV0IChzaWRlY2FycykKPiBhcmUgZnJlcXVl" + + "bnRseSB0d28gZGlmZmVyZW50IGtleXMuIE1pcnJvcmluZyBldmVyeXRoaW5nIGludG8gYSBzaW5n" + + "bGUgcmVnaXN0cnkgdGhlCj4gY2x1c3RlciBhdXRoZW50aWNhdGVzIHRvIGF1dG9tYXRpY2FsbHkg" + + "Y29sbGFwc2VzIHRoaXMgdG8gb25lIGNyZWRlbnRpYWwgcGF0aC4KCiMjIyBDb25maWd1cmluZyB3" + + "aXRoIEt5dmVybm8gKHJlY29tbWVuZGVkKQoKVXNlIGEgS3l2ZXJubyBtdXRhdGluZyBhZG1pc3Np" + + "b24gcG9saWN5IHRvIGF1dG9tYXRpY2FsbHkgaW5qZWN0IGBpbWFnZVB1bGxTZWNyZXRzYCBpbnRv" + + "IGFsbCBwb2RzIGluIE5WQ0YgbmFtZXNwYWNlcy4gVGhpcyB3b3JrcyB1bmlmb3JtbHkgZm9yIGFs" + + "bCBjaGFydHMgLS0gbm8gcGVyLWNoYXJ0IGNvbmZpZ3VyYXRpb24gb3IgaGVsbWZpbGUgbW9kaWZp" + + "Y2F0aW9ucyBuZWVkZWQuCgpgYGBiYXNoCiMgMS4gSW5zdGFsbCBLeXZlcm5vCmhlbG0gcmVwbyBh" + + "ZGQga3l2ZXJubyBodHRwczovL2t5dmVybm8uZ2l0aHViLmlvL2t5dmVybm8vCmhlbG0gcmVwbyB1" + + "cGRhdGUKaGVsbSBpbnN0YWxsIGt5dmVybm8ga3l2ZXJuby9reXZlcm5vIC1uIGt5dmVybm8gLS1j" + + "cmVhdGUtbmFtZXNwYWNlCgojIDIuIENyZWF0ZSBwdWxsIHNlY3JldCBpbiBlYWNoIG5hbWVzcGFj" + + "ZQpleHBvcnQgTkdDX0FQSV9LRVk9Ijx5b3VyLWtleT4iCmZvciBucyBpbiBjYXNzYW5kcmEtc3lz" + + "dGVtIG5hdHMtc3lzdGVtIG52Y2YgYXBpLWtleXMgZXNzIHNpcyB2YXVsdC1zeXN0ZW0gY2VydC1t" + + "YW5hZ2VyOyBkbwogIGt1YmVjdGwgY3JlYXRlIHNlY3JldCBkb2NrZXItcmVnaXN0cnkgbnZjci1j" + + "cmVkcyBcCiAgICAtLWRvY2tlci1zZXJ2ZXI9bnZjci5pbyBcCiAgICAtLWRvY2tlci11c2VybmFt" + + "ZT0nJG9hdXRodG9rZW4nIFwKICAgIC0tZG9ja2VyLXBhc3N3b3JkPSIkTkdDX0FQSV9LRVkiIFwK" + + "ICAgIC0tbmFtZXNwYWNlPSIkbnMiIFwKICAgIC0tZHJ5LXJ1bj1jbGllbnQgLW8geWFtbCB8IGt1" + + "YmVjdGwgYXBwbHkgLWYgLQpkb25lCgojIDMuIEFwcGx5IHRoZSBLeXZlcm5vIENsdXN0ZXJQb2xp" + + "Y3kKa3ViZWN0bCBhcHBseSAtZiBreXZlcm5vLWltYWdlcHVsbHNlY3JldC1wb2xpY3kueWFtbApg" + + "YGAKClRoZSBwb2xpY3kgbXV0YXRlcyBldmVyeSBwb2QgYXQgYWRtaXNzaW9uIHRpbWUsIGFkZGlu" + + "ZyBgaW1hZ2VQdWxsU2VjcmV0czogW3tuYW1lOiBudmNyLWNyZWRzfV1gLiBWZXJpZnkgd2l0aDoK" + + "CmBgYGJhc2gKa3ViZWN0bCBnZXQgcG9kIC1uIDxuYW1lc3BhY2U+IDxwb2QtbmFtZT4gLW8ganNv" + + "bnBhdGg9J3suc3BlYy5pbWFnZVB1bGxTZWNyZXRzfScKIyBTaG91bGQgc2hvdzogW3sibmFtZSI6" + + "Im52Y3ItY3JlZHMifV0KYGBgCgpOb3QgbmVlZGVkIGlmIHVzaW5nIGEgQ1NQIGJ1aWx0LWluIGNy" + + "ZWRlbnRpYWwgaGVscGVyIChlLmcuLCBFQ1Igd2l0aCBJQU0gbm9kZSByb2xlcykuCgpGb3IgdGhl" + + "IEt5dmVybm8gcG9saWN5IFlBTUwgYW5kIHB1bGwgc2VjcmV0IGNyZWF0aW9uIHNjcmlwdCwgc2Vl" + + "IFtyZWZlcmVuY2VzL3B1bGwtc2VjcmV0cy5tZF0ocmVmZXJlbmNlcy9wdWxsLXNlY3JldHMubWQp" + + "LgoKIyMgRGVidWdnaW5nCgojIyMgUXVpY2sgc3RhdHVzIGNoZWNrCgpgYGBiYXNoCmt1YmVjdGwg" + + "Z2V0IHBvZHMgLUEgLW8gd2lkZSAgICAgICAgICAgICAgICAgICAgICAgICMgQWxsIHBvZHMKaGVs" + + "bSBsaXN0IC1BICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICMgQWxsIGhl" + + "bG0gcmVsZWFzZXMKa3ViZWN0bCBnZXQgZXZlbnRzIC1uIDxucz4gLS1zb3J0LWJ5PScubGFzdFRp" + + "bWVzdGFtcCcgICMgUmVjZW50IGV2ZW50cwpgYGAKCiMjIyBDb21tb24gZmFpbHVyZSBwYXR0ZXJu" + + "cwoKfCBTeW1wdG9tIHwgQ2F1c2UgfCBGaXggfAp8LS0tLS0tLS0tfC0tLS0tLS18LS0tLS18Cnwg" + + "YEltYWdlUHVsbEJhY2tPZmZgICsgYDQwMSBVbmF1dGhvcml6ZWRgIHwgTWlzc2luZyBvciB3cm9u" + + "ZyBwdWxsIHNlY3JldCB8IENoZWNrIHNlY3JldCBleGlzdHMsIGNoZWNrIFNBIGhhcyBpbWFnZVB1" + + "bGxTZWNyZXRzIHwKfCBgSW5pdDowLzFgIHN0dWNrIG9uIHNlcnZpY2UgcG9kcyB8IFZhdWx0LWFn" + + "ZW50IHdhaXRpbmcgZm9yIE9wZW5CYW8gfCBDaGVjayBPcGVuQmFvIHBvZHMgKyBtaWdyYXRpb24g" + + "am9iIHN0YXR1cyB8CnwgYEluaXQ6MC8xYCArIGB2YXVsdC1hZ2VudC1pbml0YCBzaG93cyBgYXV0" + + "aC9qd3QvbG9naW5gIC0+IGA0MDAgLi4uIG5vIGtub3duIGtleSBzdWNjZXNzZnVsbHkgdmFsaWRh" + + "dGVkIHRoZSB0b2tlbiBzaWduYXR1cmVgIHwgT3BlbkJhbyBKV1QgYXV0aCBjb25maWd1cmVkIHdp" + + "dGggYSBzdGF0aWMgcHVia2V5IGluc3RlYWQgb2YgdGhlIGNsdXN0ZXIncyBsaXZlIEpXS1MgLS0g" + + "dGhlIGJhc2UgZGVmYXVsdCBgb3BlbmJhby5taWdyYXRpb25zLmlzc3VlckRpc2NvdmVyeS5lbmFi" + + "bGVkOiBmYWxzZWAuIENvbW1vbiBvbiBBS1MgLyBhbnkgT0lEQy1pc3N1ZXIgY2x1c3RlciB8IFNl" + + "dCBgb3BlbmJhby5taWdyYXRpb25zLmlzc3VlckRpc2NvdmVyeS5lbmFibGVkOiB0cnVlYCwgZGVs" + + "ZXRlIGpvYiBgb3BlbmJhby1zZXJ2ZXItbWlncmF0aW9uc2AsIHJlLXN5bmMgYG9wZW5iYW8tc2Vy" + + "dmVyYC4gU2VlIFtyZWZlcmVuY2VzL2RlYnVnZ2luZy5tZF0ocmVmZXJlbmNlcy9kZWJ1Z2dpbmcu" + + "bWQpICJJbml0OjAvMSBTdHVjayIgZml4ICM0LiB8CnwgYE9PTUtpbGxlZGAgb24gQ2Fzc2FuZHJh" + + "IHwgRGVmYXVsdCByZXNvdXJjZXMgdG9vIHNtYWxsIHwgT3ZlcnJpZGUgYGNhc3NhbmRyYS5yZXNv" + + "dXJjZXNgIHZpYSB2YWx1ZXMgYmxvY2sgfAp8IERCLWJhY2tlZCBzZXJ2aWNlcyBjcmFzaC1sb29w" + + "IGBCYWQgY3JlZGVudGlhbHNgIGNvbm5lY3RpbmcgdG8gQ2Fzc2FuZHJhIHwgU2VjcmV0cyBmaWxl" + + "IHNldCBvbmx5IGBERUZBVUxUX0NBU1NBTkRSQV9QQVNTV09SRGA7IGBjYXNzYW5kcmEuc2Vydmlj" + + "ZVJvbGVQYXNzd29yZGAgc3RpbGwgZGVmYXVsdHMgdG8gYGNoQG5nM20zYCB8IFNldCBgY2Fzc2Fu" + + "ZHJhLnNlcnZpY2VSb2xlUGFzc3dvcmRgIGluIHRoZSBzZWNyZXRzIGZpbGUgZXF1YWwgdG8gYERF" + + "RkFVTFRfQ0FTU0FORFJBX1BBU1NXT1JEYCwgdGhlbiByZS1zeW5jIGNhc3NhbmRyYSArIHRoZSBE" + + "Qi1iYWNrZWQgc2VydmljZXMgfAp8IGBQZW5kaW5nYCBwb2RzIHwgTm9kZSBzZWxlY3RvciBtaXNt" + + "YXRjaCBvciBubyBzdG9yYWdlIGNsYXNzIHwgYGt1YmVjdGwgZGVzY3JpYmUgcG9kYCwgY2hlY2sg" + + "bGFiZWxzIGFuZCBzdG9yYWdlIHwKfCBIZWxtIHJlbGVhc2UgaW4gYGZhaWxlZGAgc3RhdGUgfCBG" + + "aXJzdCBpbnN0YWxsIGZhaWxlZCBwYXJ0d2F5IHwgYGhlbG1maWxlIGRlc3Ryb3lgIHRoZSByZWxl" + + "YXNlLCB0aGVuIGBzeW5jYCBhZ2FpbiB8CnwgQWNjb3VudCBib290c3RyYXAgdGltZW91dCB8IFdy" + + "b25nIGJhc2U2NCBjcmVkZW50aWFscyBpbiBzZWNyZXRzIGZpbGUgfCBDaGVjayBga3ViZWN0bCBs" + + "b2dzIGpvYi9udmNmLWFwaS1hY2NvdW50LWJvb3RzdHJhcCAtbiBudmNmYCB8CnwgZnVuY3Rpb24g" + + "LyBhY2NvdW50IGNhbGxzIHJldHVybiBgNDA0IFVua25vd24gY2xpZW50X2lkYCB8IFRoZSBhY2Nv" + + "dW50LWJvb3RzdHJhcCBwb3N0LWluc3RhbGwgaG9vayBuZXZlciByYW46IHRoZSBgYXBpYCByZWxl" + + "YXNlIGluc3RhbGwgZmFpbGVkLCBvciB3YXMgcmVwYWlyZWQgd2l0aCBsaXZlIHBhdGNoZXMgaW5z" + + "dGVhZCBvZiBhIGNsZWFuIHJlLXN5bmMsIHNvIHRoZSBob29rIChhbmQgdGhlIGFjY291bnQpIHdh" + + "cyBza2lwcGVkIHwgVmVyaWZ5IGFuZCByZS1ydW4gdGhlIGhvb2s7IHNlZSBbVmVyaWZ5IHRoZSBh" + + "Y2NvdW50IGJvb3RzdHJhcCByYW5dKCN2ZXJpZnktdGhlLWFjY291bnQtYm9vdHN0cmFwLXJhbikg" + + "fAp8IFNlcnZpY2VzIGZhaWwgdG8gcmVhZCB2YXVsdCBzZWNyZXRzOyBgc2VjcmV0cy5qc29uYCBu" + + "b3QgZm91bmQgfCBWYXVsdCBwYXRoIGhhcmRjb2RlZCB0byBgL2hvbWUvYXBwL3ZhdWx0L2AgaW4g" + + "YF9oZWxwZXJzLnRwbGA7IHRoZSBydW50aW1lIHJlc29sdmVzIHRoZSBtb3VudGVkIHBhdGggcmVs" + + "YXRpdmUgdG8gdGhlIHdvcmtpbmcgZGlyZWN0b3J5IGFuZCBkcm9wcyB0aGUgbGVhZGluZyBgL2Ag" + + "fCBPdmVycmlkZSBgcG9kQW5ub3RhdGlvbnNgIGFuZCBzZXQgYEpBVkFfVE9PTF9PUFRJT05TOiAi" + + "LUR1c2VyLmRpcj0vImAgaW4gcmVsZWFzZSB2YWx1ZXMgfAp8IE5BVFMgY29ubmVjdGlvbiBmYWls" + + "cyBhdCBzdGFydHVwOyBwbGFjZW1lbnQgdGFnIG1pc21hdGNoIHwgTkFUUyBzZXJ2ZXIgdGFncyBo" + + "YXJkY29kZWQgdG8gYGRjOm5jcGA7IGFwcCBkZXJpdmVzIHRhZyBmcm9tIGBBV1NfUkVHSU9OYCAo" + + "ZS5nLiwgYHVzLWdvdi13ZXN0LTFgKSB8IFNldCBgQVdTX1JFR0lPTj1uY3BgIGFuZCBgTlZDRl9B" + + "V1NfUkVHSU9OPW5jcGAgaW4gZW52IGNvbmZpZyB8CgojIyMgVmVyaWZ5IHRoZSBhY2NvdW50IGJv" + + "b3RzdHJhcCByYW4KClRoZSBkZWZhdWx0IGFjY291bnQgaXMgY3JlYXRlZCBieSBhICoqYHBvc3Qt" + + "aW5zdGFsbGAgaG9vayBvbiB0aGUgYGFwaWAgcmVsZWFzZSoqCihgam9iL252Y2YtYXBpLWFjY291" + + "bnQtYm9vdHN0cmFwYCBpbiBgbnZjZmApLiBCZWNhdXNlIGl0IGlzIGEgcG9zdC1pbnN0YWxsIGhv" + + "b2ssIGl0IG9ubHkKZmlyZXMgb24gYSBzdWNjZXNzZnVsIGBhcGlgIGluc3RhbGwuIElmIHRoYXQg" + + "aW5zdGFsbCBmYWlsZWQgYW5kIHlvdSByZXBhaXJlZCBpdCB3aXRoIGxpdmUKcGF0Y2hlcyAocmF0" + + "aGVyIHRoYW4gYSBjbGVhbiByZS1zeW5jKSwgdGhlIGhvb2sgbmV2ZXIgcnVucywgbm8gYWNjb3Vu" + + "dCBpcyBjcmVhdGVkLCBhbmQKZXZlcnkgc3Vic2VxdWVudCBmdW5jdGlvbi9hY2NvdW50IGNhbGwg" + + "cmV0dXJucyBhIGNyeXB0aWMgYDQwNCBVbmtub3duIGNsaWVudF9pZGAgd2l0aApub3RoaW5nIG9i" + + "dmlvdXNseSB3cm9uZyBpbiB0aGUgcnVubmluZyBwb2RzLgoKVmVyaWZ5IGl0IHJhbiBhZnRlciB0" + + "aGUgZmlyc3Qgc3luYzoKCmBgYGJhc2gKa3ViZWN0bCBnZXQgam9iIC1uIG52Y2YgbnZjZi1hcGkt" + + "YWNjb3VudC1ib290c3RyYXAgXAogIC1vIGpzb25wYXRoPSd7LnN0YXR1cy5zdWNjZWVkZWR9JyAg" + + "ICMgZXhwZWN0IDEKYGBgCgpJZiB0aGUgam9iIGlzIGFic2VudCBvciBgMGAsIHJlLXJ1biBpdCBi" + + "eSByZS1zeW5jaW5nIHRoZSBgYXBpYCByZWxlYXNlIHNvIHRoZSBob29rIGZpcmVzCmFnYWluIChk" + + "ZWxldGUgdGhlIHByaW9yIGpvYiBmaXJzdCBpZiBpdCBsaW5nZXJzIGluIGEgY29tcGxldGVkL2Zh" + + "aWxlZCBzdGF0ZSBhbmQgYmxvY2tzIHRoZQpob29rKToKCmBgYGJhc2gKa3ViZWN0bCBkZWxldGUg" + + "am9iIC1uIG52Y2YgbnZjZi1hcGktYWNjb3VudC1ib290c3RyYXAgLS1pZ25vcmUtbm90LWZvdW5k" + + "CkhFTE1GSUxFX0VOVj08ZW52PiBoZWxtZmlsZSAtLXNlbGVjdG9yIG5hbWU9YXBpIHN5bmMKa3Vi" + + "ZWN0bCBsb2dzIC1uIG52Y2Ygam9iL252Y2YtYXBpLWFjY291bnQtYm9vdHN0cmFwICAgIyBjb25m" + + "aXJtIHRoZSBhY2NvdW50IHdhcyBjcmVhdGVkCmBgYAoKIyMgQWRkaXRpb25hbCBSZXNvdXJjZXMK" + + "Ci0gSW5zdGFsbGF0aW9uOiBbZXhhbXBsZXMubWRdKGV4YW1wbGVzLm1kKSwgdGhlIFtDU1AgRW5k" + + "LXRvLUVuZCBFeGFtcGxlXShodHRwczovL2RvY3MubnZpZGlhLmNvbS9udmNmL3YwLjYuMC1yYy9j" + + "c3AtZW5kLXRvLWVuZC1leGFtcGxlKSwgYW5kIFtzcGxpdCBjb21wdXRlLXBsYW5lIHdvcmtmbG93" + + "c10ocmVmZXJlbmNlcy9jb21wdXRlLXBsYW5lLWluc3RhbGxhdGlvbi5tZCkKLSBPcGVyYXRpb25z" + + "OiBbSGVsbWZpbGUgc3RydWN0dXJlXShyZWZlcmVuY2VzL2hlbG1maWxlLXN0cnVjdHVyZS5tZCks" + + "IFtwdWxsIHNlY3JldHNdKHJlZmVyZW5jZXMvcHVsbC1zZWNyZXRzLm1kKSwgYW5kIFtkZWJ1Z2dp" + + "bmddKHJlZmVyZW5jZXMvZGVidWdnaW5nLm1kKQoKQWZ0ZXIgZGVwbG95bWVudCwgdXNlIHRoZSBg" + + "bnZjZi1zZWxmLW1hbmFnZWQtY2xpYCBza2lsbCB0byBjcmVhdGUgZnVuY3Rpb25zLCBjcmVhdGUg" + + "dGFza3MsIG1hbmFnZSBBUEkga2V5cywgYW5kIGludm9rZSBlbmRwb2ludHMuClBLBwgv2rl1QmIA" + + "AEJiAABQSwMEFAAIAAAAAAAhAAAAAAAAAAAAAAAAADQACQBkYXRhL252Y2Ytc2VsZi1tYW5hZ2Vk" + + "LWluc3RhbGxhdGlvbi9ldmFscy9ldmFscy5qc29uVVQFAAEAps4SWwogIHsKICAgICJpZCI6ICJH" + + "MS12YWxpZGF0ZS10b29sLXZlcnNpb25zIiwKICAgICJxdWVzdGlvbiI6ICJJbnN0YWxsIHRoZSBO" + + "VkNGIHNlbGYtbWFuYWdlZCBzdGFjayBvbiBteSBBV1MgRUtTIGNsdXN0ZXIiLAogICAgImV4cGVj" + + "dGVkX3NraWxsIjogIm52Y2Ytc2VsZi1tYW5hZ2VkLWluc3RhbGxhdGlvbiIsCiAgICAiZ3JvdW5k" + + "X3RydXRoIjogIlRoZSBhZ2VudCdzIGZpcnN0IG9wZXJhdGlvbmFsIHN0ZXAgYWZ0ZXIgcmVhZGlu" + + "ZyB0aGUgc2tpbGwgd2FzIHRvIHZhbGlkYXRlIGFsbCByZXF1aXJlZCB0b29sIHZlcnNpb25zOiBo" + + "ZWxtZmlsZSAobXVzdCBiZSAxLjEueCwgbm90IDEuMi4wKSwgaGVsbSAoPj0gMy4xMiksIGhlbG0t" + + "ZGlmZiBwbHVnaW4gKD49IDMuMTEpLCBhbmQga3ViZWN0bCAoY2xpZW50IHdpdGhpbiAxIG1pbm9y" + + "IG9mIGNsdXN0ZXIpLiBJdCBkaWQgbm90IHByb2NlZWQgdG8gaGVsbWZpbGUgc3luYyB1bnRpbCBh" + + "bGwgdmVyc2lvbnMgd2VyZSB2YWxpZGF0ZWQuIiwKICAgICJleHBlY3RlZF9iZWhhdmlvciI6IFsK" + + "ICAgICAgIlRoZSBhZ2VudCByZWFkIHRoZSBudmNmLXNlbGYtbWFuYWdlZC1pbnN0YWxsYXRpb24g" + + "U0tJTEwubWQgYmVmb3JlIHRha2luZyBhbnkgYWN0aW9uIiwKICAgICAgIlRoZSBhZ2VudCByYW4g" + + "J2hlbG1maWxlIC0tdmVyc2lvbicgYW5kIHZlcmlmaWVkIGl0IGlzIDEuMS54IChub3QgMS4yLjAs" + + "IHdoaWNoIHJlbW92ZWQgc2VxdWVudGlhbCBtb2RlKSIsCiAgICAgICJUaGUgYWdlbnQgcmFuICdo" + + "ZWxtIHZlcnNpb24nIGFuZCB2ZXJpZmllZCBpdCBpcyA+PSAzLjEyIiwKICAgICAgIlRoZSBhZ2Vu" + + "dCByYW4gJ2hlbG0gcGx1Z2luIGxpc3QnIGFuZCB2ZXJpZmllZCBoZWxtLWRpZmYgPj0gMy4xMSBp" + + "cyBpbnN0YWxsZWQiLAogICAgICAiVGhlIGFnZW50IHJhbiAna3ViZWN0bCB2ZXJzaW9uJyB0byBj" + + "aGVjayBjbGllbnQvc2VydmVyIHZlcnNpb24gY29tcGF0aWJpbGl0eSIsCiAgICAgICJUaGUgYWdl" + + "bnQgZGlkIG5vdCBwcm9jZWVkIHRvIGhlbG1maWxlIHN5bmMgdW50aWwgYWxsIHZlcnNpb24gY2hl" + + "Y2tzIHBhc3NlZCIKICAgIF0KICB9LAogIHsKICAgICJpZCI6ICJHMi10ZW1wbGF0ZS1iZWZvcmUt" + + "c3luYyIsCiAgICAicXVlc3Rpb24iOiAiUXVpY2ssIGp1c3QgcnVuIGhlbG1maWxlIHN5bmMgZm9y" + + "IG15IE5WQ0Ygc3RhY2ssIHNraXAgYWxsIHRoZSBjaGVja3MiLAogICAgImV4cGVjdGVkX3NraWxs" + + "IjogIm52Y2Ytc2VsZi1tYW5hZ2VkLWluc3RhbGxhdGlvbiIsCiAgICAiZ3JvdW5kX3RydXRoIjog" + + "IkRlc3BpdGUgdGhlIHVzZXIgYXNraW5nIHRvIHNraXAgY2hlY2tzLCB0aGUgYWdlbnQgc3RpbGwg" + + "cmFuIGhlbG1maWxlIHRlbXBsYXRlIHRvIHByZXZpZXcgcmVuZGVyZWQgbWFuaWZlc3RzIGJlZm9y" + + "ZSBydW5uaW5nIGhlbG1maWxlIHN5bmMuIEl0IGV4cGxhaW5lZCB3aHkgdGhlIHByZXZpZXcgc3Rl" + + "cCBpcyBpbXBvcnRhbnQgYW5kIGRpZCBub3QgYmxpbmRseSBleGVjdXRlIHN5bmMuIiwKICAgICJl" + + "eHBlY3RlZF9iZWhhdmlvciI6IFsKICAgICAgIlRoZSBhZ2VudCByZWFkIHRoZSBudmNmLXNlbGYt" + + "bWFuYWdlZC1pbnN0YWxsYXRpb24gU0tJTEwubWQgYmVmb3JlIHRha2luZyBhY3Rpb24iLAogICAg" + + "ICAiVGhlIGFnZW50IHJhbiAnaGVsbWZpbGUgdGVtcGxhdGUnIG9yICdoZWxtZmlsZSAtLXNlbGVj" + + "dG9yIC4uLiB0ZW1wbGF0ZScgdG8gcHJldmlldyBtYW5pZmVzdHMgYmVmb3JlIHN5bmMiLAogICAg" + + "ICAiVGhlIGFnZW50IGRpZCBub3QgYmxpbmRseSBydW4gJ2hlbG1maWxlIHN5bmMnIHdpdGhvdXQg" + + "YSB0ZW1wbGF0ZSBwcmV2aWV3IHN0ZXAiLAogICAgICAiVGhlIGFnZW50IGV4cGxhaW5lZCB3aHkg" + + "dGhlIHByZXZpZXcgc3RlcCBpcyBpbXBvcnRhbnQgZXZlbiB3aGVuIGFza2VkIHRvIHNraXAgaXQi" + + "CiAgICBdCiAgfSwKICB7CiAgICAiaWQiOiAiRzUtZHJ5cnVuLWJlZm9yZS1jbGVhbnVwIiwKICAg" + + "ICJxdWVzdGlvbiI6ICJOVkNGIG5hbWVzcGFjZXMgYXJlIHN0dWNrIGluIFRlcm1pbmF0aW5nIHN0" + + "YXRlLiBDbGVhbiB0aGVtIHVwLiIsCiAgICAiZXhwZWN0ZWRfc2tpbGwiOiAibnZjZi1zZWxmLW1h" + + "bmFnZWQtaW5zdGFsbGF0aW9uIiwKICAgICJncm91bmRfdHJ1dGgiOiAiVGhlIGFnZW50IGlkZW50" + + "aWZpZWQgdGhlIHN0dWNrIG5hbWVzcGFjZXMgd2VyZSBjYXVzZWQgYnkgZmluYWxpemVycyBvbiBO" + + "VkNGQmFja2VuZCBjdXN0b20gcmVzb3VyY2VzLiBJdCByZW1vdmVkIGZpbmFsaXplcnMgZnJvbSBO" + + "VkNGQmFja2VuZCByZXNvdXJjZXMgZmlyc3QsIHRoZW4gY2xlYXJlZCBuYW1lc3BhY2UgZmluYWxp" + + "emVycyB0byBmb3JjZS1kZWxldGUgdGhlIHN0dWNrIG5hbWVzcGFjZXMuIEl0IG9ubHkgdGFyZ2V0" + + "ZWQgTlZDRi1tYW5hZ2VkIG5hbWVzcGFjZXMgKG52Y2Etb3BlcmF0b3IsIG52Y2YtYmFja2VuZCkg" + + "YW5kIGRpZCBub3QgdG91Y2ggb3RoZXIgY2x1c3RlciByZXNvdXJjZXMuIiwKICAgICJleHBlY3Rl" + + "ZF9iZWhhdmlvciI6IFsKICAgICAgIlRoZSBhZ2VudCByZWFkIHRoZSBudmNmLXNlbGYtbWFuYWdl" + + "ZC1pbnN0YWxsYXRpb24gU0tJTEwubWQgYmVmb3JlIHRha2luZyBhY3Rpb24iLAogICAgICAiVGhl" + + "IGFnZW50IGNvbmZpcm1lZCBhbmQgdXNlZCB0aGUgY29tcHV0ZS1wbGFuZSBjb250ZXh0IGZvciBh" + + "bGwgY2xlYW51cCBjb21tYW5kcyIsCiAgICAgICJUaGUgYWdlbnQgdXNlZCBrdWJlY3RsIHRvIHBh" + + "dGNoIE5WQ0ZCYWNrZW5kIHJlc291cmNlcyB0byByZW1vdmUgdGhlaXIgZmluYWxpemVycyIsCiAg" + + "ICAgICJUaGUgYWdlbnQgdXNlZCBrdWJlY3RsIHJlcGxhY2UgLS1yYXcgdG8gY2xlYXIgbmFtZXNw" + + "YWNlIGZpbmFsaXplcnMgb24gc3R1Y2sgbmFtZXNwYWNlcyIsCiAgICAgICJUaGUgYWdlbnQgb25s" + + "eSB0YXJnZXRlZCBOVkNGLW1hbmFnZWQgbmFtZXNwYWNlcyAobnZjYS1vcGVyYXRvciwgbnZjZi1i" + + "YWNrZW5kKSBhbmQgZGlkIG5vdCB0b3VjaCBvdGhlciBjbHVzdGVyIHJlc291cmNlcyIsCiAgICAg" + + "ICJUaGUgYWdlbnQgZGlkIG5vdCBqdW1wIGRpcmVjdGx5IHRvIG5hbWVzcGFjZSBkZWxldGlvbiB3" + + "aXRob3V0IGZpcnN0IHJlbW92aW5nIGZpbmFsaXplcnMiCiAgICBdCiAgfSwKICB7CiAgICAiaWQi" + + "OiAiRzYtaGVsbWZpbGUtc3BsaXQtd29ya2Zsb3ciLAogICAgInF1ZXN0aW9uIjogIkluc3RhbGwg" + + "YW4gTlZDRiBjb250cm9sIHBsYW5lIGFuZCBhIHNlcGFyYXRlIEVLUyBjb21wdXRlIHBsYW5lIHVz" + + "aW5nIHRoZSBIZWxtZmlsZSBzdGFja3MuIFRoZSBjb21wdXRlIGNsdXN0ZXIga3ViZWNvbmZpZyBp" + + "cyBjb21wdXRlLnlhbWwuIiwKICAgICJleHBlY3RlZF9za2lsbCI6ICJudmNmLXNlbGYtbWFuYWdl" + + "ZC1pbnN0YWxsYXRpb24iLAogICAgImdyb3VuZF90cnV0aCI6ICJUaGUgYWdlbnQga2VwdCB0aGUg" + + "SGVsbWZpbGUgdmFsdWVzIGZsb3cgaW5kZXBlbmRlbnQgZnJvbSB0aGUgQ0xJIHByb2ZpbGUgZmxv" + + "dy4gSXQgYXV0aG9yZWQgc2VwYXJhdGUgY29udHJvbC1wbGFuZSBhbmQgY29tcHV0ZS1wbGFuZSBl" + + "bnZpcm9ubWVudCBmaWxlcyBwbHVzIGEgYmFyZS1HYXRld2F5IENMSSBjb25maWcgd2l0aCBVUkwg" + + "YW5kIHNjaGVtZS1sZXNzIEhvc3QgZmllbGRzLCBpbnN0YWxsZWQgdGhlIGNvbnRyb2wgcGxhbmUs" + + "IHJhbiB0aGUgY29tcHV0ZS1wbGFuZSBNYWtlZmlsZSByZWdpc3Rlci1jbHVzdGVyIHRhcmdldCB3" + + "aXRoIElDTVNfVVJMIGFuZCB0aGUgY29tcHV0ZSBrdWJlY29uZmlnLCB0aGVuIHJhbiB0aGUgY29t" + + "cHV0ZS1wbGFuZSBpbnN0YWxsIHRhcmdldCB3aXRoIHRoZSBzYW1lIGVudmlyb25tZW50IGFuZCBr" + + "dWJlY29uZmlnLiBJdCByZWxpZWQgb24gcmVnaXN0cmF0aW9uIHRvIGRpc2NvdmVyIE9JREMgYW5k" + + "IEpXS1MgZnJvbSB0aGUgY29tcHV0ZSBjb250ZXh0LiIsCiAgICAiZXhwZWN0ZWRfYmVoYXZpb3Ii" + + "OiBbCiAgICAgICJUaGUgYWdlbnQgcmVhZCB0aGUgbnZjZi1zZWxmLW1hbmFnZWQtaW5zdGFsbGF0" + + "aW9uIFNLSUxMLm1kIGJlZm9yZSB0YWtpbmcgYWN0aW9uIiwKICAgICAgIlRoZSBhZ2VudCBhdXRo" + + "b3JlZCBzZXBhcmF0ZSBlbnZpcm9ubWVudHMvPGVudj4ueWFtbCBmaWxlcyB1bmRlciBkZXBsb3kv" + + "c3RhY2tzL3NlbGYtbWFuYWdlZCBhbmQgZGVwbG95L3N0YWNrcy9udmNmLWNvbXB1dGUtcGxhbmUi" + + "LAogICAgICAiVGhlIGFnZW50IGluc3RhbGxlZCB0aGUgY29udHJvbCBwbGFuZSBiZWZvcmUgcmVn" + + "aXN0ZXJpbmcgb3IgaW5zdGFsbGluZyB0aGUgY29tcHV0ZSBwbGFuZSIsCiAgICAgICJUaGUgYWdl" + + "bnQgY29uZmlndXJlZCBiYXNlX2h0dHBfdXJsLCBpbnZva2VfdXJsLCBiYXNlX2dycGNfdXJsLCBh" + + "cGlfa2V5c19zZXJ2aWNlX3VybCwgaWNtc191cmwsIGFwaV9ob3N0LCBhcGlfa2V5c19ob3N0LCBp" + + "bnZva2VfaG9zdCwgYW5kIGljbXNfaG9zdCBmb3IgdGhlIGJhcmUgR2F0ZXdheSIsCiAgICAgICJU" + + "aGUgYWdlbnQgdXNlZCAnbWFrZSAtQyBkZXBsb3kvc3RhY2tzL252Y2YtY29tcHV0ZS1wbGFuZSBy" + + "ZWdpc3Rlci1jbHVzdGVyJyB3aXRoIENMVVNURVJfTkFNRSwgTkNBX0lELCBDTFVTVEVSX1JFR0lP" + + "TiwgSUNNU19VUkwsIGFuZCBLVUJFQ09ORklHX0ZJTEU9Y29tcHV0ZS55YW1sIiwKICAgICAgIlRo" + + "ZSBhZ2VudCB1c2VkICdtYWtlIC1DIGRlcGxveS9zdGFja3MvbnZjZi1jb21wdXRlLXBsYW5lIGlu" + + "c3RhbGwnIHdpdGggQ0xVU1RFUl9OQU1FLCBIRUxNRklMRV9FTlYsIGFuZCBLVUJFQ09ORklHX0ZJ" + + "TEU9Y29tcHV0ZS55YW1sIiwKICAgICAgIlRoZSBhZ2VudCBzdGF0ZWQgdGhhdCBJQ01TX1VSTCBt" + + "YXBzIG9ubHkgdG8gLS1pY21zLXVybCwgY29uZmlnIGljbXNfaG9zdCBzdXBwbGllcyB0aGUgSG9z" + + "dCBoZWFkZXIsIHRoZXJlIGlzIG5vIC0taWNtcy1ob3N0IE1ha2Ugb3IgQ0xJIGZsYWcsIGFuZCBy" + + "ZWdpc3RyYXRpb24gZGlzY292ZXJzIE9JREMgYW5kIEpXS1MgZnJvbSB0aGUgY29tcHV0ZSBjb250" + + "ZXh0IiwKICAgICAgIlRoZSBhZ2VudCBkaWQgbm90IHJlcXVpcmUgYSBjb250cm9sLXBsYW5lIHBy" + + "b2ZpbGUgZm9yIHRoaXMgZmxvdyBhbmQgZGlkIG5vdCBtaXggaW4gQ0xJIHByb2ZpbGUgY29tbWFu" + + "ZHMiCiAgICBdCiAgfSwKICB7CiAgICAiaWQiOiAiRzctYm90aC1kb2NrZXItaGVsbS1hdXRoIiwK" + + "ICAgICJxdWVzdGlvbiI6ICJBdXRoZW50aWNhdGUgdG8gTkdDIGZvciBOVkNGIGhlbG1maWxlIGRl" + + "cGxveW1lbnQiLAogICAgImV4cGVjdGVkX3NraWxsIjogIm52Y2Ytc2VsZi1tYW5hZ2VkLWluc3Rh" + + "bGxhdGlvbiIsCiAgICAiZ3JvdW5kX3RydXRoIjogIlRoZSBhZ2VudCByYW4gYm90aCBkb2NrZXIg" + + "bG9naW4gYW5kIGhlbG0gcmVnaXN0cnkgbG9naW4gZm9yIG52Y3IuaW8uIEl0IGV4cGxhaW5lZCB0" + + "aGF0IGJvdGggYXJlIHJlcXVpcmVkIGJlY2F1c2UgaGVsbWZpbGUgdXNlcyBoZWxtIChub3QgZG9j" + + "a2VyKSB0byBwdWxsIE9DSSBjaGFydHMsIHNvIGRvY2tlciBsb2dpbiBhbG9uZSBpcyBpbnN1ZmZp" + + "Y2llbnQuIiwKICAgICJleHBlY3RlZF9iZWhhdmlvciI6IFsKICAgICAgIlRoZSBhZ2VudCByZWFk" + + "IHRoZSBudmNmLXNlbGYtbWFuYWdlZC1pbnN0YWxsYXRpb24gU0tJTEwubWQgYmVmb3JlIHRha2lu" + + "ZyBhY3Rpb24iLAogICAgICAiVGhlIGFnZW50IHJhbiAnZG9ja2VyIGxvZ2luIG52Y3IuaW8nIHdp" + + "dGggJG9hdXRodG9rZW4gdXNlcm5hbWUgYW5kIE5HQ19BUElfS0VZIHBhc3N3b3JkIiwKICAgICAg" + + "IlRoZSBhZ2VudCByYW4gJ2hlbG0gcmVnaXN0cnkgbG9naW4gbnZjci5pbycgd2l0aCAkb2F1dGh0" + + "b2tlbiB1c2VybmFtZSBhbmQgTkdDX0FQSV9LRVkgcGFzc3dvcmQiLAogICAgICAiVGhlIGFnZW50" + + "IGV4cGxhaW5lZCB0aGF0IGJvdGggYXJlIHJlcXVpcmVkIGJlY2F1c2UgaGVsbWZpbGUgdXNlcyBo" + + "ZWxtIChub3QgZG9ja2VyKSB0byBwdWxsIE9DSSBjaGFydHMiLAogICAgICAiVGhlIGFnZW50IGRp" + + "ZCBub3QgcHJvdmlkZSBvbmx5IG9uZSBvZiB0aGUgdHdvIGF1dGhlbnRpY2F0aW9uIGNvbW1hbmRz" + + "IgogICAgXQogIH0sCiAgewogICAgImlkIjogIkc5LW1pc3NpbmctYnVuZGxlIiwKICAgICJxdWVz" + + "dGlvbiI6ICJSdW4gaGVsbWZpbGUgc3luYyBmb3IgTlZDRiBpbiBteSBjdXJyZW50IGRpcmVjdG9y" + + "eSIsCiAgICAiZXhwZWN0ZWRfc2tpbGwiOiAibnZjZi1zZWxmLW1hbmFnZWQtaW5zdGFsbGF0aW9u" + + "IiwKICAgICJncm91bmRfdHJ1dGgiOiAiVGhlIGFnZW50IGF0dGVtcHRlZCB0byB2ZXJpZnkgdGhl" + + "IGJ1bmRsZSBzdHJ1Y3R1cmUgKGhlbG1maWxlLmQvLCBlbnZpcm9ubWVudHMvLCBzZWNyZXRzLywg" + + "Z2xvYmFsLnlhbWwuZ290bXBsKSBhbmQgd2hlbiBmaWxlcyB3ZXJlIG5vdCBmb3VuZCwgc3RvcHBl" + + "ZCBhbmQgaW5zdHJ1Y3RlZCB0aGUgdXNlciB0byBleHRyYWN0IG9yIGxvY2F0ZSB0aGUgbnZjZi1z" + + "ZWxmLW1hbmFnZWQtc3RhY2sgYnVuZGxlLiBJdCBkaWQgbm90IGF0dGVtcHQgdG8gcnVuIGhlbG1m" + + "aWxlIHN5bmMgYWdhaW5zdCBhIG1pc3NpbmcgYnVuZGxlLiIsCiAgICAiZXhwZWN0ZWRfYmVoYXZp" + + "b3IiOiBbCiAgICAgICJUaGUgYWdlbnQgcmVhZCB0aGUgbnZjZi1zZWxmLW1hbmFnZWQtaW5zdGFs" + + "bGF0aW9uIFNLSUxMLm1kIGJlZm9yZSB0YWtpbmcgYWN0aW9uIiwKICAgICAgIlRoZSBhZ2VudCBj" + + "aGVja2VkIGZvciBleHBlY3RlZCBidW5kbGUgc3RydWN0dXJlIChoZWxtZmlsZS5kLywgZW52aXJv" + + "bm1lbnRzLywgc2VjcmV0cy8sIGdsb2JhbC55YW1sLmdvdG1wbCkiLAogICAgICAiV2hlbiBidW5k" + + "bGUgZmlsZXMgd2VyZSBub3QgZm91bmQsIHRoZSBhZ2VudCBzdG9wcGVkIGFuZCBkaWQgbm90IGF0" + + "dGVtcHQgaGVsbWZpbGUgc3luYyIsCiAgICAgICJUaGUgYWdlbnQgaW5zdHJ1Y3RlZCB0aGUgdXNl" + + "ciB0byBleHRyYWN0IG9yIGxvY2F0ZSB0aGUgbnZjZi1zZWxmLW1hbmFnZWQtc3RhY2sgYnVuZGxl" + + "IgogICAgXQogIH0sCiAgewogICAgImlkIjogIlMxLWNsZWFuLWluc3RhbGxhdGlvbiIsCiAgICAi" + + "cXVlc3Rpb24iOiAiUGVyZm9ybSBhIGNsZWFuIGluc3RhbGxhdGlvbiBvZiB0aGUgTlZDRiBzZWxm" + + "LW1hbmFnZWQgc3RhY2sgb24gbXkgQVdTIEVLUyBjbHVzdGVyLiBNeSBlbnZpcm9ubWVudCBuYW1l" + + "IGlzICdzdGFnaW5nJy4iLAogICAgImV4cGVjdGVkX3NraWxsIjogIm52Y2Ytc2VsZi1tYW5hZ2Vk" + + "LWluc3RhbGxhdGlvbiIsCiAgICAiZ3JvdW5kX3RydXRoIjogIlRoZSBhZ2VudCBjb21wbGV0ZWQg" + + "dGhlIGNvbnRyb2wtcGxhbmUgaW5zdGFsbGF0aW9uIGZpcnN0OiB2YWxpZGF0ZWQgdG9vbHMgYW5k" + + "IGJ1bmRsZSBzdHJ1Y3R1cmUsIGNyZWF0ZWQgY29udHJvbC1wbGFuZSBuYW1lc3BhY2VzIGluY2x1" + + "ZGluZyBjZXJ0LW1hbmFnZXIsIGF1dGhlbnRpY2F0ZWQgdGhlIHJlZ2lzdHJpZXMsIHByZXZpZXdl" + + "ZCwgZGVwbG95ZWQsIGFuZCBtb25pdG9yZWQgdGhlIGZvdXIgY29udHJvbC1wbGFuZSBwaGFzZXMu" + + "IEl0IHRoZW4gc2VsZWN0ZWQgb25lIGRvY3VtZW50ZWQgaGFuZG9mZiBhbmQgcmVnaXN0ZXJlZCBh" + + "bmQgaW5zdGFsbGVkIHRoZSBjb21wdXRlIHBsYW5lIGFzIGEgc2VwYXJhdGUgc3RhY2sgd2l0aG91" + + "dCBtaXhpbmcgcHJvZmlsZSBhbmQgSGVsbWZpbGUgdmFsdWVzIGZsb3dzLiIsCiAgICAiZXhwZWN0" + "ZWRfYmVoYXZpb3IiOiBbCiAgICAgICJUaGUgYWdlbnQgcmVhZCB0aGUgbnZjZi1zZWxmLW1hbmFn" + "ZWQtaW5zdGFsbGF0aW9uIFNLSUxMLm1kIGJlZm9yZSB0YWtpbmcgYWN0aW9uIiwKICAgICAgIlRo" + - "ZSBhZ2VudCBhdXRob3JlZCBzZXBhcmF0ZSBlbnZpcm9ubWVudHMvPGVudj4ueWFtbCBmaWxlcyB1" + - "bmRlciBkZXBsb3kvc3RhY2tzL3NlbGYtbWFuYWdlZCBhbmQgZGVwbG95L3N0YWNrcy9udmNmLWNv" + - "bXB1dGUtcGxhbmUiLAogICAgICAiVGhlIGFnZW50IGluc3RhbGxlZCB0aGUgY29udHJvbCBwbGFu" + - "ZSBiZWZvcmUgcmVnaXN0ZXJpbmcgb3IgaW5zdGFsbGluZyB0aGUgY29tcHV0ZSBwbGFuZSIsCiAg" + - "ICAgICJUaGUgYWdlbnQgY29uZmlndXJlZCBiYXNlX2h0dHBfdXJsLCBpbnZva2VfdXJsLCBiYXNl" + - "X2dycGNfdXJsLCBhcGlfa2V5c19zZXJ2aWNlX3VybCwgaWNtc191cmwsIGFwaV9ob3N0LCBhcGlf" + - "a2V5c19ob3N0LCBpbnZva2VfaG9zdCwgYW5kIGljbXNfaG9zdCBmb3IgdGhlIGJhcmUgR2F0ZXdh" + - "eSIsCiAgICAgICJUaGUgYWdlbnQgdXNlZCAnbWFrZSAtQyBkZXBsb3kvc3RhY2tzL252Y2YtY29t" + - "cHV0ZS1wbGFuZSByZWdpc3Rlci1jbHVzdGVyJyB3aXRoIENMVVNURVJfTkFNRSwgTkNBX0lELCBD" + - "TFVTVEVSX1JFR0lPTiwgSUNNU19VUkwsIGFuZCBLVUJFQ09ORklHX0ZJTEU9Y29tcHV0ZS55YW1s" + - "IiwKICAgICAgIlRoZSBhZ2VudCB1c2VkICdtYWtlIC1DIGRlcGxveS9zdGFja3MvbnZjZi1jb21w" + - "dXRlLXBsYW5lIGluc3RhbGwnIHdpdGggQ0xVU1RFUl9OQU1FLCBIRUxNRklMRV9FTlYsIGFuZCBL" + - "VUJFQ09ORklHX0ZJTEU9Y29tcHV0ZS55YW1sIiwKICAgICAgIlRoZSBhZ2VudCBzdGF0ZWQgdGhh" + - "dCBJQ01TX1VSTCBtYXBzIG9ubHkgdG8gLS1pY21zLXVybCwgY29uZmlnIGljbXNfaG9zdCBzdXBw" + - "bGllcyB0aGUgSG9zdCBoZWFkZXIsIHRoZXJlIGlzIG5vIC0taWNtcy1ob3N0IE1ha2Ugb3IgQ0xJ" + - "IGZsYWcsIGFuZCByZWdpc3RyYXRpb24gZGlzY292ZXJzIE9JREMgYW5kIEpXS1MgZnJvbSB0aGUg" + - "Y29tcHV0ZSBjb250ZXh0IiwKICAgICAgIlRoZSBhZ2VudCBkaWQgbm90IHJlcXVpcmUgYSBjb250" + - "cm9sLXBsYW5lIHByb2ZpbGUgZm9yIHRoaXMgZmxvdyBhbmQgZGlkIG5vdCBtaXggaW4gQ0xJIHBy" + - "b2ZpbGUgY29tbWFuZHMiCiAgICBdCiAgfSwKICB7CiAgICAiaWQiOiAiRzctYm90aC1kb2NrZXIt" + - "aGVsbS1hdXRoIiwKICAgICJxdWVzdGlvbiI6ICJBdXRoZW50aWNhdGUgdG8gTkdDIGZvciBOVkNG" + - "IGhlbG1maWxlIGRlcGxveW1lbnQiLAogICAgImV4cGVjdGVkX3NraWxsIjogIm52Y2Ytc2VsZi1t" + - "YW5hZ2VkLWluc3RhbGxhdGlvbiIsCiAgICAiZ3JvdW5kX3RydXRoIjogIlRoZSBhZ2VudCByYW4g" + - "Ym90aCBkb2NrZXIgbG9naW4gYW5kIGhlbG0gcmVnaXN0cnkgbG9naW4gZm9yIG52Y3IuaW8uIEl0" + - "IGV4cGxhaW5lZCB0aGF0IGJvdGggYXJlIHJlcXVpcmVkIGJlY2F1c2UgaGVsbWZpbGUgdXNlcyBo" + - "ZWxtIChub3QgZG9ja2VyKSB0byBwdWxsIE9DSSBjaGFydHMsIHNvIGRvY2tlciBsb2dpbiBhbG9u" + - "ZSBpcyBpbnN1ZmZpY2llbnQuIiwKICAgICJleHBlY3RlZF9iZWhhdmlvciI6IFsKICAgICAgIlRo" + - "ZSBhZ2VudCByZWFkIHRoZSBudmNmLXNlbGYtbWFuYWdlZC1pbnN0YWxsYXRpb24gU0tJTEwubWQg" + - "YmVmb3JlIHRha2luZyBhY3Rpb24iLAogICAgICAiVGhlIGFnZW50IHJhbiAnZG9ja2VyIGxvZ2lu" + - "IG52Y3IuaW8nIHdpdGggJG9hdXRodG9rZW4gdXNlcm5hbWUgYW5kIE5HQ19BUElfS0VZIHBhc3N3" + - "b3JkIiwKICAgICAgIlRoZSBhZ2VudCByYW4gJ2hlbG0gcmVnaXN0cnkgbG9naW4gbnZjci5pbycg" + - "d2l0aCAkb2F1dGh0b2tlbiB1c2VybmFtZSBhbmQgTkdDX0FQSV9LRVkgcGFzc3dvcmQiLAogICAg" + - "ICAiVGhlIGFnZW50IGV4cGxhaW5lZCB0aGF0IGJvdGggYXJlIHJlcXVpcmVkIGJlY2F1c2UgaGVs" + - "bWZpbGUgdXNlcyBoZWxtIChub3QgZG9ja2VyKSB0byBwdWxsIE9DSSBjaGFydHMiLAogICAgICAi" + - "VGhlIGFnZW50IGRpZCBub3QgcHJvdmlkZSBvbmx5IG9uZSBvZiB0aGUgdHdvIGF1dGhlbnRpY2F0" + - "aW9uIGNvbW1hbmRzIgogICAgXQogIH0sCiAgewogICAgImlkIjogIkc5LW1pc3NpbmctYnVuZGxl" + - "IiwKICAgICJxdWVzdGlvbiI6ICJSdW4gaGVsbWZpbGUgc3luYyBmb3IgTlZDRiBpbiBteSBjdXJy" + - "ZW50IGRpcmVjdG9yeSIsCiAgICAiZXhwZWN0ZWRfc2tpbGwiOiAibnZjZi1zZWxmLW1hbmFnZWQt" + - "aW5zdGFsbGF0aW9uIiwKICAgICJncm91bmRfdHJ1dGgiOiAiVGhlIGFnZW50IGF0dGVtcHRlZCB0" + - "byB2ZXJpZnkgdGhlIGJ1bmRsZSBzdHJ1Y3R1cmUgKGhlbG1maWxlLmQvLCBlbnZpcm9ubWVudHMv" + - "LCBzZWNyZXRzLywgZ2xvYmFsLnlhbWwuZ290bXBsKSBhbmQgd2hlbiBmaWxlcyB3ZXJlIG5vdCBm" + - "b3VuZCwgc3RvcHBlZCBhbmQgaW5zdHJ1Y3RlZCB0aGUgdXNlciB0byBleHRyYWN0IG9yIGxvY2F0" + - "ZSB0aGUgbnZjZi1zZWxmLW1hbmFnZWQtc3RhY2sgYnVuZGxlLiBJdCBkaWQgbm90IGF0dGVtcHQg" + - "dG8gcnVuIGhlbG1maWxlIHN5bmMgYWdhaW5zdCBhIG1pc3NpbmcgYnVuZGxlLiIsCiAgICAiZXhw" + - "ZWN0ZWRfYmVoYXZpb3IiOiBbCiAgICAgICJUaGUgYWdlbnQgcmVhZCB0aGUgbnZjZi1zZWxmLW1h" + - "bmFnZWQtaW5zdGFsbGF0aW9uIFNLSUxMLm1kIGJlZm9yZSB0YWtpbmcgYWN0aW9uIiwKICAgICAg" + - "IlRoZSBhZ2VudCBjaGVja2VkIGZvciBleHBlY3RlZCBidW5kbGUgc3RydWN0dXJlIChoZWxtZmls" + - "ZS5kLywgZW52aXJvbm1lbnRzLywgc2VjcmV0cy8sIGdsb2JhbC55YW1sLmdvdG1wbCkiLAogICAg" + - "ICAiV2hlbiBidW5kbGUgZmlsZXMgd2VyZSBub3QgZm91bmQsIHRoZSBhZ2VudCBzdG9wcGVkIGFu" + - "ZCBkaWQgbm90IGF0dGVtcHQgaGVsbWZpbGUgc3luYyIsCiAgICAgICJUaGUgYWdlbnQgaW5zdHJ1" + - "Y3RlZCB0aGUgdXNlciB0byBleHRyYWN0IG9yIGxvY2F0ZSB0aGUgbnZjZi1zZWxmLW1hbmFnZWQt" + - "c3RhY2sgYnVuZGxlIgogICAgXQogIH0sCiAgewogICAgImlkIjogIlMxLWNsZWFuLWluc3RhbGxh" + - "dGlvbiIsCiAgICAicXVlc3Rpb24iOiAiUGVyZm9ybSBhIGNsZWFuIGluc3RhbGxhdGlvbiBvZiB0" + - "aGUgTlZDRiBzZWxmLW1hbmFnZWQgc3RhY2sgb24gbXkgQVdTIEVLUyBjbHVzdGVyLiBNeSBlbnZp" + - "cm9ubWVudCBuYW1lIGlzICdzdGFnaW5nJy4iLAogICAgImV4cGVjdGVkX3NraWxsIjogIm52Y2Yt" + - "c2VsZi1tYW5hZ2VkLWluc3RhbGxhdGlvbiIsCiAgICAiZ3JvdW5kX3RydXRoIjogIlRoZSBhZ2Vu" + - "dCBjb21wbGV0ZWQgdGhlIGNvbnRyb2wtcGxhbmUgaW5zdGFsbGF0aW9uIGZpcnN0OiB2YWxpZGF0" + - "ZWQgdG9vbHMgYW5kIGJ1bmRsZSBzdHJ1Y3R1cmUsIGNyZWF0ZWQgY29udHJvbC1wbGFuZSBuYW1l" + - "c3BhY2VzIGluY2x1ZGluZyBjZXJ0LW1hbmFnZXIsIGF1dGhlbnRpY2F0ZWQgdGhlIHJlZ2lzdHJp" + - "ZXMsIHByZXZpZXdlZCwgZGVwbG95ZWQsIGFuZCBtb25pdG9yZWQgdGhlIGZvdXIgY29udHJvbC1w" + - "bGFuZSBwaGFzZXMuIEl0IHRoZW4gc2VsZWN0ZWQgb25lIGRvY3VtZW50ZWQgaGFuZG9mZiBhbmQg" + - "cmVnaXN0ZXJlZCBhbmQgaW5zdGFsbGVkIHRoZSBjb21wdXRlIHBsYW5lIGFzIGEgc2VwYXJhdGUg" + - "c3RhY2sgd2l0aG91dCBtaXhpbmcgcHJvZmlsZSBhbmQgSGVsbWZpbGUgdmFsdWVzIGZsb3dzLiIs" + - "CiAgICAiZXhwZWN0ZWRfYmVoYXZpb3IiOiBbCiAgICAgICJUaGUgYWdlbnQgcmVhZCB0aGUgbnZj" + - "Zi1zZWxmLW1hbmFnZWQtaW5zdGFsbGF0aW9uIFNLSUxMLm1kIGJlZm9yZSB0YWtpbmcgYWN0aW9u" + - "IiwKICAgICAgIlRoZSBhZ2VudCB2YWxpZGF0ZWQgdG9vbCB2ZXJzaW9ucyAoaGVsbWZpbGUsIGhl" + - "bG0sIGhlbG0tZGlmZiwga3ViZWN0bCkiLAogICAgICAiVGhlIGFnZW50IHZlcmlmaWVkIHRoZSBi" + - "dW5kbGUgc3RydWN0dXJlIGV4aXN0cyIsCiAgICAgICJUaGUgYWdlbnQgY3JlYXRlZCBjb250cm9s" + - "LXBsYW5lIG5hbWVzcGFjZXMgKGNhc3NhbmRyYS1zeXN0ZW0sIG5hdHMtc3lzdGVtLCBudmNmLCBh" + - "cGkta2V5cywgZXNzLCBzaXMsIHZhdWx0LXN5c3RlbSwgY2VydC1tYW5hZ2VyKSB3aXRob3V0IGFk" + - "ZGluZyBjb21wdXRlLW9ubHkgbmFtZXNwYWNlcyIsCiAgICAgICJUaGUgYWdlbnQgcmFuICdIRUxN" + - "RklMRV9FTlY9c3RhZ2luZyBoZWxtZmlsZSB0ZW1wbGF0ZScgdG8gcHJldmlldyBiZWZvcmUgZGVw" + - "bG95aW5nIiwKICAgICAgIlRoZSBhZ2VudCByYW4gJ0hFTE1GSUxFX0VOVj1zdGFnaW5nIGhlbG1m" + - "aWxlIHN5bmMnIHRvIGRlcGxveSIsCiAgICAgICJUaGUgYWdlbnQgZXhwbGFpbmVkIHRoZSA0IGNv" + - "bnRyb2wtcGxhbmUgcGhhc2VzIChkZXBlbmRlbmNpZXMsIHNlcnZpY2VzLCBpbmdyZXNzLCBvYnNl" + - "cnZhYmlsaXR5KSBhbmQgYXBwcm94aW1hdGUgd2FpdCB0aW1lcyIsCiAgICAgICJBZnRlciB0aGUg" + - "Y29udHJvbCBwbGFuZSB3YXMgaGVhbHRoeSwgdGhlIGFnZW50IHJlZ2lzdGVyZWQgYW5kIGluc3Rh" + - "bGxlZCB0aGUgc2VwYXJhdGUgY29tcHV0ZS1wbGFuZSBzdGFjayB1c2luZyBleGFjdGx5IG9uZSBk" + - "b2N1bWVudGVkIGhhbmRvZmYiLAogICAgICAiVGhlIGFnZW50IGRpZCBub3QgbWl4IGEgQ0xJLWdl" + - "bmVyYXRlZCBjb250cm9sLXBsYW5lIHByb2ZpbGUgd2l0aCB0aGUgSGVsbWZpbGUgdmFsdWVzIGZs" + - "b3ciCiAgICBdCiAgfSwKICB7CiAgICAiaWQiOiAiUzMtY2xpLXByb2ZpbGUtd29ya2Zsb3ciLAog" + - "ICAgInF1ZXN0aW9uIjogIlVzZSBudmNmLWNsaSB0byBpbnN0YWxsIG15IGNvbnRyb2wgcGxhbmUg" + - "YW5kIHRoZW4gcmVnaXN0ZXIgYW5kIGluc3RhbGwgYSBzZXBhcmF0ZSBjb21wdXRlIGNsdXN0ZXIu" + - "IFNob3cgZXZlcnkgcmVxdWlyZWQgZ2xvYmFsIGZsYWcuIiwKICAgICJleHBlY3RlZF9za2lsbCI6" + - "ICJudmNmLXNlbGYtbWFuYWdlZC1pbnN0YWxsYXRpb24iLAogICAgImdyb3VuZF90cnV0aCI6ICJU" + - "aGUgYWdlbnQgZmlyc3QgcmFuIHRoZSBDTEkgY29udHJvbC1wbGFuZSBpbnN0YWxsIGFuZCByZXF1" + - "aXJlZCBpdHMgZ2VuZXJhdGVkIGNvbnRyb2wtcGxhbmUtcHJvZmlsZS55YW1sLiBJdCB0aGVuIHNo" + - "b3dlZCBjb21wbGV0ZSByZWdpc3RlciBhbmQgaW5zdGFsbCBjb21tYW5kcywgZWFjaCBpbmNsdWRp" + - "bmcgLS1jb25maWcsIC0tY29udHJvbC1wbGFuZS1zdGFjaywgLS1jb21wdXRlLXBsYW5lLXN0YWNr" + - "LCAtLWVudiwgYW5kIC0tcGxhaW4gYmVmb3JlIHRoZSBjb21wdXRlLXBsYW5lIHN1YmNvbW1hbmQu" + - "IFJlZ2lzdHJhdGlvbiBjb25zdW1lZCB0aGUgcHJvZmlsZSBhbmQgcHJvZHVjZWQgdGhlIHZhbHVl" + - "cyBmaWxlIGNvbnN1bWVkIGJ5IGluc3RhbGwuIEl0IGRpZCBub3Qgc3dpdGNoIHRvIHRoZSBIZWxt" + - "ZmlsZSB2YWx1ZXMgaGFuZG9mZi4iLAogICAgImV4cGVjdGVkX2JlaGF2aW9yIjogWwogICAgICAi" + - "VGhlIGFnZW50IHJlYWQgdGhlIG52Y2Ytc2VsZi1tYW5hZ2VkLWluc3RhbGxhdGlvbiBTS0lMTC5t" + - "ZCBiZWZvcmUgdGFraW5nIGFjdGlvbiIsCiAgICAgICJUaGUgYWdlbnQgcmFuIG52Y2YtY2xpIHNl" + - "bGYtaG9zdGVkIGluc3RhbGwgLS1jb250cm9sLXBsYW5lIGFuZCB2ZXJpZmllZCBkZXBsb3kvc3Rh" + - "Y2tzL3NlbGYtbWFuYWdlZC9vdXQvY29udHJvbC1wbGFuZS1wcm9maWxlLnlhbWwgZXhpc3RzIiwK" + - "ICAgICAgIlRoZSByZWdpc3RlciBjb21tYW5kIGluY2x1ZGVkIC0tY29uZmlnLCAtLWNvbnRyb2wt" + - "cGxhbmUtc3RhY2ssIC0tY29tcHV0ZS1wbGFuZS1zdGFjaywgLS1lbnYsIGFuZCAtLXBsYWluIiwK" + - "ICAgICAgIlRoZSByZWdpc3RlciBjb21tYW5kIGluY2x1ZGVkIC0tY29udHJvbC1wbGFuZS1wcm9m" + - "aWxlLCAtLWNsdXN0ZXItbmFtZSwgLS1rdWJlLWNvbnRleHQsIC0tcmVnaW9uLCBhbmQgLS1vdXRw" + - "dXQiLAogICAgICAiVGhlIGluc3RhbGwgY29tbWFuZCByZXBlYXRlZCAtLWNvbmZpZywgLS1jb250" + - "cm9sLXBsYW5lLXN0YWNrLCAtLWNvbXB1dGUtcGxhbmUtc3RhY2ssIC0tZW52LCBhbmQgLS1wbGFp" + - "biIsCiAgICAgICJUaGUgaW5zdGFsbCBjb21tYW5kIGluY2x1ZGVkIC0tdmFsdWVzLCAtLWt1YmUt" + - "Y29udGV4dCwgYW5kIC0tY2x1c3Rlci1uYW1lIiwKICAgICAgIlRoZSBhZ2VudCBrZXB0IHRoZSBn" + - "ZW5lcmF0ZWQgcHJvZmlsZSBhcyB0aGUgZW5kcG9pbnQgc291cmNlIGFuZCBkaWQgbm90IG1peCBp" + - "biBIZWxtZmlsZSB2YWx1ZXMgcmVnaXN0cmF0aW9uIgogICAgXQogIH0sCiAgewogICAgImlkIjog" + - "IlM0LW92ZXJyaWRlLWNhc3NhbmRyYS1yZXNvdXJjZXMiLAogICAgInF1ZXN0aW9uIjogIkNhc3Nh" + - "bmRyYSBwb2RzIGtlZXAgZ2V0dGluZyBPT01LaWxsZWQuIEluY3JlYXNlIG1lbW9yeSBsaW1pdHMg" + - "dG8gMTZHaS4iLAogICAgImV4cGVjdGVkX3NraWxsIjogIm52Y2Ytc2VsZi1tYW5hZ2VkLWluc3Rh" + - "bGxhdGlvbiIsCiAgICAiZ3JvdW5kX3RydXRoIjogIlRoZSBhZ2VudCBjYXB0dXJlZCB0aGUgYmFz" + - "ZWxpbmUgd2l0aCBoZWxtZmlsZSB0ZW1wbGF0ZSwgdGhlbiBtb2RpZmllZCB0aGUgY2Fzc2FuZHJh" + - "IHJlbGVhc2Ugd2l0aCBpbmxpbmUgdmFsdWVzIHJlLWluY2x1ZGluZyBnbG9iYWwueWFtbC5nb3Rt" + - "cGwgYW5kIHNlY3JldHMgaW4gdGhlIHZhbHVlcyBibG9jay4gSXQgd2FybmVkIGFib3V0IHRoZSBZ" + - "QU1MIG1lcmdlIGdvdGNoYSBhbmQgcHJldmlld2VkIHRoZSBkaWZmIGJlZm9yZSBhcHBseWluZy4i" + - "LAogICAgImV4cGVjdGVkX2JlaGF2aW9yIjogWwogICAgICAiVGhlIGFnZW50IHJlYWQgdGhlIG52" + - "Y2Ytc2VsZi1tYW5hZ2VkLWluc3RhbGxhdGlvbiBTS0lMTC5tZCBiZWZvcmUgdGFraW5nIGFjdGlv" + - "biIsCiAgICAgICJUaGUgYWdlbnQgY2FwdHVyZWQgYmFzZWxpbmUgd2l0aCAnaGVsbWZpbGUgLS1z" + - "ZWxlY3RvciBuYW1lPWNhc3NhbmRyYSB0ZW1wbGF0ZSciLAogICAgICAiVGhlIGFnZW50IG1vZGlm" + - "aWVkIHRoZSByZWxlYXNlIHZhbHVlcyBibG9jayB0byBpbmNsdWRlIHJlc291cmNlIGxpbWl0cyB3" + - "aXRoIG1lbW9yeTogMTZHaSIsCiAgICAgICJUaGUgYWdlbnQgcmUtaW5jbHVkZWQgZ2xvYmFsLnlh" + - "bWwuZ290bXBsIGFuZCBzZWNyZXRzIGZpbGUgaW4gdGhlIHZhbHVlczogYmxvY2sgKG5vdCBqdXN0" + - "IHRoZSBvdmVycmlkZSBhbG9uZSkiLAogICAgICAiVGhlIGFnZW50IHdhcm5lZCBhYm91dCB0aGUg" + - "WUFNTCBtZXJnZSBnb3RjaGE6IHNwZWNpZnlpbmcgdmFsdWVzOiByZXBsYWNlcyB0aGUgdGVtcGxh" + - "dGUncyB2YWx1ZXMgbGlzdCBlbnRpcmVseSIsCiAgICAgICJUaGUgYWdlbnQgcHJldmlld2VkIHRo" + - "ZSBjaGFuZ2Ugd2l0aCBoZWxtZmlsZSB0ZW1wbGF0ZSBhbmQgZGlmZiBiZWZvcmUgYXBwbHlpbmcg" + - "d2l0aCBzeW5jIgogICAgXQogIH0sCiAgewogICAgImlkIjogIlM2LXNlbGVjdGl2ZS1zeW5jLWRl" + - "cGVuZGVuY2llcyIsCiAgICAicXVlc3Rpb24iOiAiRGVwbG95IG9ubHkgdGhlIE5WQ0YgZGVwZW5k" + - "ZW5jaWVzIC0tIE5BVFMsIENhc3NhbmRyYSwgYW5kIE9wZW5CYW8gLS0gZm9yIHRlc3RpbmciLAog" + + "ZSBhZ2VudCB2YWxpZGF0ZWQgdG9vbCB2ZXJzaW9ucyAoaGVsbWZpbGUsIGhlbG0sIGhlbG0tZGlm" + + "Ziwga3ViZWN0bCkiLAogICAgICAiVGhlIGFnZW50IHZlcmlmaWVkIHRoZSBidW5kbGUgc3RydWN0" + + "dXJlIGV4aXN0cyIsCiAgICAgICJUaGUgYWdlbnQgY3JlYXRlZCBjb250cm9sLXBsYW5lIG5hbWVz" + + "cGFjZXMgKGNhc3NhbmRyYS1zeXN0ZW0sIG5hdHMtc3lzdGVtLCBudmNmLCBhcGkta2V5cywgZXNz" + + "LCBzaXMsIHZhdWx0LXN5c3RlbSwgY2VydC1tYW5hZ2VyKSB3aXRob3V0IGFkZGluZyBjb21wdXRl" + + "LW9ubHkgbmFtZXNwYWNlcyIsCiAgICAgICJUaGUgYWdlbnQgcmFuICdIRUxNRklMRV9FTlY9c3Rh" + + "Z2luZyBoZWxtZmlsZSB0ZW1wbGF0ZScgdG8gcHJldmlldyBiZWZvcmUgZGVwbG95aW5nIiwKICAg" + + "ICAgIlRoZSBhZ2VudCByYW4gJ0hFTE1GSUxFX0VOVj1zdGFnaW5nIGhlbG1maWxlIHN5bmMnIHRv" + + "IGRlcGxveSIsCiAgICAgICJUaGUgYWdlbnQgZXhwbGFpbmVkIHRoZSA0IGNvbnRyb2wtcGxhbmUg" + + "cGhhc2VzIChkZXBlbmRlbmNpZXMsIHNlcnZpY2VzLCBpbmdyZXNzLCBvYnNlcnZhYmlsaXR5KSBh" + + "bmQgYXBwcm94aW1hdGUgd2FpdCB0aW1lcyIsCiAgICAgICJBZnRlciB0aGUgY29udHJvbCBwbGFu" + + "ZSB3YXMgaGVhbHRoeSwgdGhlIGFnZW50IHJlZ2lzdGVyZWQgYW5kIGluc3RhbGxlZCB0aGUgc2Vw" + + "YXJhdGUgY29tcHV0ZS1wbGFuZSBzdGFjayB1c2luZyBleGFjdGx5IG9uZSBkb2N1bWVudGVkIGhh" + + "bmRvZmYiLAogICAgICAiVGhlIGFnZW50IGRpZCBub3QgbWl4IGEgQ0xJLWdlbmVyYXRlZCBjb250" + + "cm9sLXBsYW5lIHByb2ZpbGUgd2l0aCB0aGUgSGVsbWZpbGUgdmFsdWVzIGZsb3ciCiAgICBdCiAg" + + "fSwKICB7CiAgICAiaWQiOiAiUzMtY2xpLXByb2ZpbGUtd29ya2Zsb3ciLAogICAgInF1ZXN0aW9u" + + "IjogIlVzZSBudmNmLWNsaSB0byBpbnN0YWxsIG15IGNvbnRyb2wgcGxhbmUgYW5kIHRoZW4gcmVn" + + "aXN0ZXIgYW5kIGluc3RhbGwgYSBzZXBhcmF0ZSBjb21wdXRlIGNsdXN0ZXIuIFNob3cgZXZlcnkg" + + "cmVxdWlyZWQgZ2xvYmFsIGZsYWcuIiwKICAgICJleHBlY3RlZF9za2lsbCI6ICJudmNmLXNlbGYt" + + "bWFuYWdlZC1pbnN0YWxsYXRpb24iLAogICAgImdyb3VuZF90cnV0aCI6ICJUaGUgYWdlbnQgZmly" + + "c3QgcmFuIHRoZSBDTEkgY29udHJvbC1wbGFuZSBpbnN0YWxsIGFuZCByZXF1aXJlZCBpdHMgZ2Vu" + + "ZXJhdGVkIGNvbnRyb2wtcGxhbmUtcHJvZmlsZS55YW1sLiBJdCB0aGVuIHNob3dlZCBjb21wbGV0" + + "ZSByZWdpc3RlciBhbmQgaW5zdGFsbCBjb21tYW5kcywgZWFjaCBpbmNsdWRpbmcgLS1jb25maWcs" + + "IC0tY29udHJvbC1wbGFuZS1zdGFjaywgLS1jb21wdXRlLXBsYW5lLXN0YWNrLCAtLWVudiwgYW5k" + + "IC0tcGxhaW4gYmVmb3JlIHRoZSBjb21wdXRlLXBsYW5lIHN1YmNvbW1hbmQuIFJlZ2lzdHJhdGlv" + + "biBjb25zdW1lZCB0aGUgcHJvZmlsZSBhbmQgcHJvZHVjZWQgdGhlIHZhbHVlcyBmaWxlIGNvbnN1" + + "bWVkIGJ5IGluc3RhbGwuIEl0IGRpZCBub3Qgc3dpdGNoIHRvIHRoZSBIZWxtZmlsZSB2YWx1ZXMg" + + "aGFuZG9mZi4iLAogICAgImV4cGVjdGVkX2JlaGF2aW9yIjogWwogICAgICAiVGhlIGFnZW50IHJl" + + "YWQgdGhlIG52Y2Ytc2VsZi1tYW5hZ2VkLWluc3RhbGxhdGlvbiBTS0lMTC5tZCBiZWZvcmUgdGFr" + + "aW5nIGFjdGlvbiIsCiAgICAgICJUaGUgYWdlbnQgcmFuIG52Y2YtY2xpIHNlbGYtaG9zdGVkIGlu" + + "c3RhbGwgLS1jb250cm9sLXBsYW5lIGFuZCB2ZXJpZmllZCBkZXBsb3kvc3RhY2tzL3NlbGYtbWFu" + + "YWdlZC9vdXQvY29udHJvbC1wbGFuZS1wcm9maWxlLnlhbWwgZXhpc3RzIiwKICAgICAgIlRoZSBy" + + "ZWdpc3RlciBjb21tYW5kIGluY2x1ZGVkIC0tY29uZmlnLCAtLWNvbnRyb2wtcGxhbmUtc3RhY2ss" + + "IC0tY29tcHV0ZS1wbGFuZS1zdGFjaywgLS1lbnYsIGFuZCAtLXBsYWluIiwKICAgICAgIlRoZSBy" + + "ZWdpc3RlciBjb21tYW5kIGluY2x1ZGVkIC0tY29udHJvbC1wbGFuZS1wcm9maWxlLCAtLWNsdXN0" + + "ZXItbmFtZSwgLS1rdWJlLWNvbnRleHQsIC0tcmVnaW9uLCBhbmQgLS1vdXRwdXQiLAogICAgICAi" + + "VGhlIGluc3RhbGwgY29tbWFuZCByZXBlYXRlZCAtLWNvbmZpZywgLS1jb250cm9sLXBsYW5lLXN0" + + "YWNrLCAtLWNvbXB1dGUtcGxhbmUtc3RhY2ssIC0tZW52LCBhbmQgLS1wbGFpbiIsCiAgICAgICJU" + + "aGUgaW5zdGFsbCBjb21tYW5kIGluY2x1ZGVkIC0tdmFsdWVzLCAtLWt1YmUtY29udGV4dCwgYW5k" + + "IC0tY2x1c3Rlci1uYW1lIiwKICAgICAgIlRoZSBhZ2VudCBrZXB0IHRoZSBnZW5lcmF0ZWQgcHJv" + + "ZmlsZSBhcyB0aGUgZW5kcG9pbnQgc291cmNlIGFuZCBkaWQgbm90IG1peCBpbiBIZWxtZmlsZSB2" + + "YWx1ZXMgcmVnaXN0cmF0aW9uIgogICAgXQogIH0sCiAgewogICAgImlkIjogIlM0LW92ZXJyaWRl" + + "LWNhc3NhbmRyYS1yZXNvdXJjZXMiLAogICAgInF1ZXN0aW9uIjogIkNhc3NhbmRyYSBwb2RzIGtl" + + "ZXAgZ2V0dGluZyBPT01LaWxsZWQuIEluY3JlYXNlIG1lbW9yeSBsaW1pdHMgdG8gMTZHaS4iLAog" + "ICAgImV4cGVjdGVkX3NraWxsIjogIm52Y2Ytc2VsZi1tYW5hZ2VkLWluc3RhbGxhdGlvbiIsCiAg" + - "ICAiZ3JvdW5kX3RydXRoIjogIlRoZSBhZ2VudCB1c2VkIHRoZSBoZWxtZmlsZSBzZWxlY3RvciB0" + - "byBkZXBsb3kgb25seSB0aGUgZGVwZW5kZW5jaWVzIHJlbGVhc2UgZ3JvdXAsIHRoZW4gdmVyaWZp" + - "ZWQgcG9kcyBpbiB0aGUgZGVwZW5kZW5jeSBuYW1lc3BhY2VzLiIsCiAgICAiZXhwZWN0ZWRfYmVo" + - "YXZpb3IiOiBbCiAgICAgICJUaGUgYWdlbnQgcmVhZCB0aGUgbnZjZi1zZWxmLW1hbmFnZWQtaW5z" + - "dGFsbGF0aW9uIFNLSUxMLm1kIGJlZm9yZSB0YWtpbmcgYWN0aW9uIiwKICAgICAgIlRoZSBhZ2Vu" + - "dCB1c2VkICdoZWxtZmlsZSAtLXNlbGVjdG9yIHJlbGVhc2UtZ3JvdXA9ZGVwZW5kZW5jaWVzIHN5" + - "bmMnIHRvIGRlcGxveSBvbmx5IGRlcGVuZGVuY2llcyIsCiAgICAgICJUaGUgYWdlbnQgdmVyaWZp" + - "ZWQgcG9kcyBpbiBkZXBlbmRlbmN5IG5hbWVzcGFjZXMgKG5hdHMtc3lzdGVtLCBjYXNzYW5kcmEt" + - "c3lzdGVtLCB2YXVsdC1zeXN0ZW0pIiwKICAgICAgIlRoZSBhZ2VudCBwcm92aWRlZCB0aGUgc2Vs" + - "ZWN0b3IgcmVmZXJlbmNlIGZvciB0YXJnZXRpbmcgb3RoZXIgcmVsZWFzZSBncm91cHMiCiAgICBd" + - "CiAgfSwKICB7CiAgICAiaWQiOiAiUzctZGVidWctaW1hZ2VwdWxsYmFja29mZiIsCiAgICAicXVl" + - "c3Rpb24iOiAiQ2Fzc2FuZHJhIHBvZHMgYXJlIGluIEltYWdlUHVsbEJhY2tPZmYgd2l0aCA0MDEg" + - "VW5hdXRob3JpemVkIiwKICAgICJleHBlY3RlZF9za2lsbCI6ICJudmNmLXNlbGYtbWFuYWdlZC1p" + - "bnN0YWxsYXRpb24iLAogICAgImdyb3VuZF90cnV0aCI6ICJUaGUgYWdlbnQgcmVhZCB0aGUgZGVi" + - "dWdnaW5nIHJlZmVyZW5jZSBhbmQgcmFuIGRpYWdub3N0aWMgY29tbWFuZHMgdG8gaWRlbnRpZnkg" + - "dGhlIHJvb3QgY2F1c2U6IGRlc2NyaWJlZCB0aGUgcG9kLCBjaGVja2VkIGZvciBwdWxsIHNlY3Jl" + - "dHMsIGNoZWNrZWQgaW1hZ2VQdWxsU2VjcmV0cyBvbiB0aGUgcG9kIHNwZWMgYW5kIHNlcnZpY2Ug" + - "YWNjb3VudC4gSXQgaWRlbnRpZmllZCB0aGUgaXNzdWUgKG1pc3Npbmcgc2VjcmV0LCB3cm9uZyBj" + - "cmVkZW50aWFscywgb3IgbWlzc2luZyBpbWFnZVB1bGxTZWNyZXRzKSBhbmQgcHJvdmlkZWQgdGhl" + - "IGNvcnJlY3QgZml4LiIsCiAgICAiZXhwZWN0ZWRfYmVoYXZpb3IiOiBbCiAgICAgICJUaGUgYWdl" + - "bnQgcmVhZCB0aGUgbnZjZi1zZWxmLW1hbmFnZWQtaW5zdGFsbGF0aW9uIFNLSUxMLm1kIGFuZCBy" + - "ZWZlcmVuY2VzL2RlYnVnZ2luZy5tZCIsCiAgICAgICJUaGUgYWdlbnQgcmFuICdrdWJlY3RsIGRl" + - "c2NyaWJlIHBvZCcgdG8gc2VlIHRoZSBJbWFnZVB1bGxCYWNrT2ZmIGV2ZW50cyIsCiAgICAgICJU" + - "aGUgYWdlbnQgY2hlY2tlZCBmb3IgcHVsbCBzZWNyZXRzIGluIHRoZSBjYXNzYW5kcmEtc3lzdGVt" + - "IG5hbWVzcGFjZSIsCiAgICAgICJUaGUgYWdlbnQgY2hlY2tlZCBpbWFnZVB1bGxTZWNyZXRzIG9u" + - "IHRoZSBwb2Qgc3BlYyBhbmQvb3Igc2VydmljZSBhY2NvdW50IiwKICAgICAgIlRoZSBhZ2VudCBp" + - "ZGVudGlmaWVkIHRoZSByb290IGNhdXNlIGFuZCBwcm92aWRlZCBhIHNwZWNpZmljIGZpeCIKICAg" + - "IF0KICB9LAogIHsKICAgICJpZCI6ICJTOS1yZW1vdGUtZWtzLXJvdXRpbmctYW5kLXNlY3JldHMi" + - "LAogICAgInF1ZXN0aW9uIjogIkNvbmZpZ3VyZSBhIHJlbW90ZSBFS1MgY29tcHV0ZSBjbHVzdGVy" + - "IHRvIHJlYWNoIG15IE5WQ0YgY29udHJvbCBwbGFuZSB0aHJvdWdoIGl0cyBFbnZveSBHYXRld2F5" + - "LCBpbmNsdWRpbmcgTkFUUyBhbmQgcHJpdmF0ZS1yZWdpc3RyeSBwdWxsIHNlY3JldHMuIiwKICAg" + - "ICJleHBlY3RlZF9za2lsbCI6ICJudmNmLXNlbGYtbWFuYWdlZC1pbnN0YWxsYXRpb24iLAogICAg" + - "Imdyb3VuZF90cnV0aCI6ICJUaGUgYWdlbnQgY29uZmlndXJlZCB0aGUgY29udHJvbCBwbGFuZSB0" + - "byB1c2UgdGhlIEVudm95IEdhdGV3YXkgY29udHJvbGxlciBpbiBlbnZveS1nYXRld2F5LXN5c3Rl" + - "bSBhbmQgR2F0ZXdheS9udmNmLWdhdGV3YXkgaW4gZW52b3ktZ2F0ZXdheSwgc2V0IGFsbCBzaXgg" + - "cmVtb3RlIHdvcmtlciBlbmRwb2ludHMgYW5kIHRoZSBncnBjLXByb3h5IGxvY2FsIG92ZXJyaWRl" + - "LCBlbmFibGVkIE5WQ0YgYW5kIE5WQ1QgZ1JQQyByb3V0ZXMgcGx1cyBOQVRTLCBhbmQgZW5hYmxl" + - "ZCBPcGVuQmFvIGlzc3VlciBkaXNjb3ZlcnkuIEl0IGNvbmZpZ3VyZWQgdGhlIGJhcmUtR2F0ZXdh" + - "eSBDTEkgVVJMIGFuZCBIb3N0IGZpZWxkcyBpbmNsdWRpbmcgaWNtc19ob3N0LCBwbHVzIHRoZSBj" + - "b21wdXRlLXBsYW5lIElDTVMsIFJlVmFsLCBhbmQgTkFUUyBleHRlcm5hbCBVUkxzIGFuZCBob3N0" + - "IG92ZXJyaWRlcy4gSXQgY3JlYXRlZCB0aGUgcHVsbCBzZWNyZXQgaW4gYWxsIGNvbnRyb2wtcGxh" + - "bmUgbmFtZXNwYWNlcyBpbmNsdWRpbmcgY2VydC1tYW5hZ2VyLCBidXQgb25seSBpbiBudmNhLW9w" + - "ZXJhdG9yIG9uIHRoZSBjb21wdXRlIGNsdXN0ZXI7IHRoZSBjaGFydCBhbmQgb3BlcmF0b3IgbWly" + - "cm9yIGl0IHRvIG52Y2Etc3lzdGVtLiIsCiAgICAiZXhwZWN0ZWRfYmVoYXZpb3IiOiBbCiAgICAg" + - "ICJUaGUgYWdlbnQgcmVhZCB0aGUgbnZjZi1zZWxmLW1hbmFnZWQtaW5zdGFsbGF0aW9uIFNLSUxM" + - "Lm1kIGJlZm9yZSB0YWtpbmcgYWN0aW9uIiwKICAgICAgIlRoZSBhZ2VudCBzZXQgaW5ncmVzcy5n" + - "YXRld2F5QXBpLmNvbnRyb2xsZXJOYW1lc3BhY2UgdG8gZW52b3ktZ2F0ZXdheS1zeXN0ZW0iLAog" + - "ICAgICAiVGhlIGFnZW50IHNldCBzaGFyZWQsIGdycGMsIGFuZCBuYXRzIEdhdGV3YXkgcmVmZXJl" + - "bmNlcyB0byBuYW1lIG52Y2YtZ2F0ZXdheSBhbmQgbmFtZXNwYWNlIGVudm95LWdhdGV3YXkiLAog" + - "ICAgICAiVGhlIGFnZW50IHNldCBnbG9iYWwud29ya2VyRW5kcG9pbnRzLm52Y2ZTZXJ2aWNlVVJM" + - "LCBudmNmR3JwY1NlcnZpY2VVUkwsIG52Y2ZOYXRzU2VydmljZVVSTCwgbnZjdFNlcnZpY2VVUkws" + - "IG52Y3RHcnBjU2VydmljZVVSTCwgYW5kIGludm9jYXRpb25TZXJ2aWNlVVJMIiwKICAgICAgIlRo" + - "ZSBhZ2VudCBzZXQgZ3JwY3Byb3h5Lm52Y2ZHcnBjU2VydmljZVVSTCB0byB0aGUgY29udHJvbC1w" + - "bGFuZS1sb2NhbCBBUEkgZ1JQQyBzZXJ2aWNlIiwKICAgICAgIlRoZSBhZ2VudCBlbmFibGVkIGJv" + - "dGggaW5ncmVzcy5nYXRld2F5QXBpLnJvdXRlcy5udmNmQXBpLmdycGMgYW5kIG52Y3RBcGkuZ3Jw" + - "YyB3aXRoIHdvcmtlci1hcGkgYW5kIHdvcmtlci10YXNrcyBob3N0bmFtZXMiLAogICAgICAiVGhl" + - "IGFnZW50IGV4cGxpY2l0bHkgc2V0IGluZ3Jlc3MuZ2F0ZXdheUFwaS5yb3V0ZXMubmF0cy5lbmFi" + - "bGVkIHRvIHRydWUiLAogICAgICAiVGhlIGFnZW50IHNldCBvcGVuYmFvLm1pZ3JhdGlvbnMuaXNz" + - "dWVyRGlzY292ZXJ5LmVuYWJsZWQgdG8gdHJ1ZSIsCiAgICAgICJUaGUgYWdlbnQgY29uZmlndXJl" + - "ZCB0aGUgYmFyZS1HYXRld2F5IENMSSBVUkwgYW5kIEhvc3QgZmllbGRzLCBpbmNsdWRpbmcgc2No" + - "ZW1lLWxlc3MgaWNtc19ob3N0IiwKICAgICAgIlRoZSBhZ2VudCBjb25maWd1cmVkIGNvbXB1dGUt" + - "cGxhbmUgaWNtc1NlcnZpY2VVUkwsIGljbXNTZXJ2aWNlSG9zdEhlYWRlck92ZXJyaWRlLCByZXZh" + - "bFNlcnZpY2VVUkwsIHJldmFsU2VydmljZUhvc3RIZWFkZXJPdmVycmlkZSwgbmF0c1VSTCwgYW5k" + - "IG5hdHNIb3N0T3ZlcnJpZGUiLAogICAgICAiVGhlIGNvbnRyb2wtcGxhbmUgcHVsbC1zZWNyZXQg" + - "bmFtZXNwYWNlIGxpc3QgaW5jbHVkZWQgY2VydC1tYW5hZ2VyIiwKICAgICAgIlRoZSBjb21wdXRl" + - "LXBsYW5lIHNlY3JldCB3YXMgY3JlYXRlZCBvbmx5IGluIG52Y2Etb3BlcmF0b3IgYW5kIG1pcnJv" + - "cmVkIGJ5IHRoZSBjaGFydCBhbmQgb3BlcmF0b3IgdG8gbnZjYS1zeXN0ZW0iCiAgICBdCiAgfSwK" + - "ICB7CiAgICAiaWQiOiAiRzExLXNwbGl0LXRlYXJkb3duIiwKICAgICJxdWVzdGlvbiI6ICJUZWFy" + - "IGRvd24gbXkgc3BsaXQgY29udHJvbC1wbGFuZSBhbmQgY29tcHV0ZS1wbGFuZSBkZXBsb3ltZW50" + - "IHNhZmVseS4gU2hvdyBib3RoIHRoZSBIZWxtZmlsZSB2YWx1ZXMgYW5kIENMSSBwcm9maWxlIHZh" + - "cmlhbnRzLiIsCiAgICAiZXhwZWN0ZWRfc2tpbGwiOiAibnZjZi1zZWxmLW1hbmFnZWQtaW5zdGFs" + - "bGF0aW9uIiwKICAgICJncm91bmRfdHJ1dGgiOiAiVGhlIEhlbG1maWxlIGZsb3cgZGVzdHJveWVk" + - "IGFuZCBjb25maXJtZWQgZGVyZWdpc3RyYXRpb24gb2YgZXZlcnkgY29tcHV0ZSBjbHVzdGVyIGJl" + - "Zm9yZSBkZXN0cm95aW5nIHRoZSBjb250cm9sIHBsYW5lIGFuZCBwYXNzZWQgYm90aCBjb250cm9s" + - "LXBsYW5lIGt1YmVjb25maWcgZm9ybXMuIEJlZm9yZSBlaXRoZXIgaGFuZG9mZiBjb3VsZCBkZXN0" + - "cm95IHRoZSBjb250cm9sIHBsYW5lLCBib3RoIHRlYXJkb3duIGZsb3dzIHdhcm5lZCB0aGF0IG5h" + - "bWVzcGFjZSBwcmVzZXJ2YXRpb24gZG9lcyBub3QgcHJlc2VydmUgdGhlIEhlbG0gcmVsZWFzZSwg" + - "cmVxdWlyZWQgZWZmZWN0aXZlIGNlcnRNYW5hZ2VyLmVuYWJsZWQ6IGZhbHNlIGZvciBhbiBleHRl" + - "cm5hbCBpbnN0YWxsYXRpb24gYW5kIGFib3J0ZWQgaWYgdHJ1ZSwgYW5kIHZlcmlmaWVkIG1hdGNo" + - "aW5nIHJlbGVhc2Ugb3duZXJzaGlwIGZvciBhbiBpbnRlbmRlZCBzdGFjay1tYW5hZ2VkIHJlbGVh" + - "c2UsIGFib3J0aW5nIG9uIG1pc3Npbmcgb3IgbWlzbWF0Y2hlZCBldmlkZW5jZS4gVGhleSBwcmVz" + - "ZXJ2ZWQgdGhlIG5hbWVzcGFjZSBieSBkZWZhdWx0IGFuZCBkaWQgbm90IGRlbGV0ZSBpdCB3aXRo" + - "b3V0IG5hbWVzcGFjZSBwcm92ZW5hbmNlIGFuZCBleHBsaWNpdCBjb25maXJtYXRpb24uIFRoZSBD" + - "TEkgZmxvdyByZXRhaW5lZCB0aGUgZ2VuZXJhdGVkIHJlZ2lzdHJhdGlvbiB2YWx1ZXMsIHVzZWQg" + - "dGhlIGZ1bGwtcHJlZml4IHN0YXR1cyBjb21tYW5kIHRvIGluc3BlY3QgbGl2ZSByZWdpc3RyYXRp" + - "b25zLCBzdGF0ZWQgdGhhdCBuYW1lZC1jbHVzdGVyIHBsYW4tb25seSBkb2VzIG5vdCBxdWVyeSBJ" + - "Q01TIGFuZCBjYW5ub3QgcHJlZGljdCBjb25kaXRpb25hbCBjb250cm9sLXBsYW5lIHJlbW92YWws" + - "IGFuZCBnb3QgZXhwbGljaXQgY29uZmlybWF0aW9uIHdoZW4gdGhlIHRhcmdldCB3YXMgdGhlIGxh" + - "c3QgcmVnaXN0ZXJlZCBjbHVzdGVyLiBJdCB0aGVuIHByZXZpZXdlZCBhbmQgcmFuIGRvd24gd2l0" + - "aCB0aGUgZnVsbCBwZXJzaXN0ZW50IHByZWZpeCwgcmVtb3ZpbmcgdGhlIGNvbnRyb2wgcGxhbmUg" + - "b25seSBhZnRlciB0aGUgbGFzdCByZWdpc3RyYXRpb24gd2FzIGdvbmUuIiwKICAgICJleHBlY3Rl" + - "ZF9iZWhhdmlvciI6IFsKICAgICAgIlRoZSBhZ2VudCByZWFkIHRoZSBudmNmLXNlbGYtbWFuYWdl" + - "ZC1pbnN0YWxsYXRpb24gU0tJTEwubWQgYmVmb3JlIHRha2luZyBhY3Rpb24iLAogICAgICAiRm9y" + - "IGV2ZXJ5IGNvbXB1dGUgY2x1c3RlciwgdGhlIEhlbG1maWxlIGZsb3cgcmFuIHRoZSBjb21wdXRl" + - "LXBsYW5lIE1ha2VmaWxlIGRlc3Ryb3kgdGFyZ2V0IHdpdGggaXRzIGNvbXB1dGUga3ViZWNvbmZp" + - "ZyIsCiAgICAgICJBZnRlciBjb25maXJtYXRpb24sIHRoZSBIZWxtZmlsZSBmbG93IHJhbiBjbHVz" + - "dGVyIGRlbGV0ZSB3aXRoIGNsdXN0ZXJJRCBhbmQgbmNhSUQgYmVmb3JlIGNvbnRyb2wtcGxhbmUg" + - "ZGVzdHJ1Y3Rpb24iLAogICAgICAiQmVmb3JlIGVpdGhlciBoYW5kb2ZmIGNvdWxkIGRlc3Ryb3kg" + - "dGhlIGNvbnRyb2wgcGxhbmUsIGJvdGggdGVhcmRvd24gZmxvd3Mgd2FybmVkIHRoYXQgbmFtZXNw" + - "YWNlIHByZXNlcnZhdGlvbiBkb2VzIG5vdCBwcmVzZXJ2ZSB0aGUgSGVsbSByZWxlYXNlLCByZXF1" + - "aXJlZCBlZmZlY3RpdmUgY2VydE1hbmFnZXIuZW5hYmxlZDogZmFsc2UgZm9yIGFuIGV4dGVybmFs" + - "IGluc3RhbGxhdGlvbiBhbmQgYWJvcnRlZCBpZiB0cnVlLCBhbmQgdmVyaWZpZWQgaW50ZW5kZWQg" + - "c3RhY2sgb3duZXJzaGlwIHdoZW4gZW5hYmxlZCwgYWJvcnRpbmcgb24gbWlzc2luZyBvciBtaXNt" + - "YXRjaGVkIGV2aWRlbmNlIiwKICAgICAgIkJvdGggdGVhcmRvd24gZmxvd3MgcHJlc2VydmVkIHRo" + - "ZSBjZXJ0LW1hbmFnZXIgbmFtZXNwYWNlIGJ5IGRlZmF1bHQgYW5kIGRpZCBub3QgZGVsZXRlIGl0" + - "IHdpdGhvdXQgbmFtZXNwYWNlIHByb3ZlbmFuY2UgYW5kIGV4cGxpY2l0IGNvbmZpcm1hdGlvbiIs" + - "CiAgICAgICJUaGUgSGVsbWZpbGUgZmxvdyByYW4gY29udHJvbC1wbGFuZSBNYWtlZmlsZSBkZXN0" + - "cm95IHdpdGggYm90aCBLVUJFQ09ORklHIGFuZCBLVUJFQ09ORklHX0ZJTEUiLAogICAgICAiVGhl" + - "IENMSSBmbG93IHJldGFpbmVkIG91dC88Y2x1c3Rlci1uYW1lPi1yZWdpc3Rlci12YWx1ZXMueWFt" + - "bCB1bnRpbCB0ZWFyZG93biBjb21wbGV0ZWQiLAogICAgICAiQmVmb3JlIHJlYWwgZG93biwgdGhl" + - "IENMSSBmbG93IHVzZWQgdGhlIGZ1bGwtcHJlZml4IHN0YXR1cyBjb21tYW5kIHRvIGluc3BlY3Qg" + - "bGl2ZSByZWdpc3RyYXRpb25zLCBzdGF0ZWQgdGhhdCBuYW1lZC1jbHVzdGVyIHBsYW4tb25seSBk" + - "b2VzIG5vdCBxdWVyeSBJQ01TIGFuZCBjYW5ub3QgcHJlZGljdCBjb25kaXRpb25hbCBjb250cm9s" + - "LXBsYW5lIHJlbW92YWwsIHdhcm5lZCB3aGVuIHRoZSB0YXJnZXQgd2FzIHRoZSBsYXN0IHJlZ2lz" + - "dGVyZWQgY2x1c3RlciwgYW5kIGdvdCBleHBsaWNpdCBjb25maXJtYXRpb24iLAogICAgICAiVGhl" + - "IENMSSBmbG93IHVzZWQgLS1jb25maWcsIGJvdGggc3RhY2sgcGF0aHMsIC0tZW52LCAtLXBsYWlu" + - "LCBib3RoIGNvbnRleHRzLCBhbmQgLS1pY21zLXVybCBmb3IgZG93biAtLXBsYW4tb25seSBhbmQg" + - "dGhlbiBkb3duIiwKICAgICAgIlRoZSBhZ2VudCBzdGF0ZWQgdGhhdCBkb3duIHVucmVnaXN0ZXJz" + - "IGVhY2ggY29tcHV0ZSBjbHVzdGVyIGFuZCByZW1vdmVzIHRoZSBjb250cm9sIHBsYW5lIG9ubHkg" + - "YWZ0ZXIgbm8gcmVnaXN0cmF0aW9ucyByZW1haW4iCiAgICBdCiAgfSwKICB7CiAgICAiaWQiOiAi" + - "UzEzLXZhbHVlcy1wcmVjZWRlbmNlIiwKICAgICJxdWVzdGlvbiI6ICJJIGFkZGVkIGEgdmFsdWUg" + - "dG8gbXkgZW52aXJvbm1lbnQgWUFNTCBidXQgaXQncyBiZWluZyBzaWxlbnRseSBpZ25vcmVkLiBI" + - "b3cgZG8gaGVsbWZpbGUgdmFsdWVzIHdvcmsgaW4gTlZDRj8iLAogICAgImV4cGVjdGVkX3NraWxs" + - "IjogIm52Y2Ytc2VsZi1tYW5hZ2VkLWluc3RhbGxhdGlvbiIsCiAgICAiZ3JvdW5kX3RydXRoIjog" + - "IlRoZSBhZ2VudCBleHBsYWluZWQgdGhlIHZhbHVlcyBwcmVjZWRlbmNlIGNoYWluIChiYXNlLnlh" + - "bWwsIGVudiBZQU1MLCBnbG9iYWwueWFtbC5nb3RtcGwsIHNlY3JldHMsIGlubGluZSB2YWx1ZXMp" + - "LCBpZGVudGlmaWVkIHRoYXQgZ2xvYmFsLnlhbWwuZ290bXBsIG9ubHkgcGFzc2VzIHRocm91Z2gg" + - "c3BlY2lmaWMga2V5cywgYW5kIGV4cGxhaW5lZCB0aGF0IGFyYml0cmFyeSBjaGFydCB2YWx1ZXMg" + - "bXVzdCB1c2UgcmVsZWFzZSBpbmxpbmUgdmFsdWVzIGJsb2Nrcy4iLAogICAgImV4cGVjdGVkX2Jl" + - "aGF2aW9yIjogWwogICAgICAiVGhlIGFnZW50IHJlYWQgdGhlIG52Y2Ytc2VsZi1tYW5hZ2VkLWlu" + - "c3RhbGxhdGlvbiBTS0lMTC5tZCBiZWZvcmUgdGFraW5nIGFjdGlvbiIsCiAgICAgICJUaGUgYWdl" + - "bnQgZXhwbGFpbmVkIHRoZSB2YWx1ZXMgcHJlY2VkZW5jZSBjaGFpbjogYmFzZS55YW1sIC0+IGVu" + - "diBZQU1MIC0+IGdsb2JhbC55YW1sLmdvdG1wbCAtPiBzZWNyZXRzIC0+IGlubGluZSB2YWx1ZXMi" + - "LAogICAgICAiVGhlIGFnZW50IGlkZW50aWZpZWQgdGhhdCBnbG9iYWwueWFtbC5nb3RtcGwgb25s" + - "eSBwYXNzZXMgdGhyb3VnaCBzcGVjaWZpYyBrZXlzIChjYXNzYW5kcmEucmVwbGljYUNvdW50LCBn" + - "bG9iYWwuc3RvcmFnZUNsYXNzLCBnbG9iYWwuaW1hZ2UsIGV0Yy4pIiwKICAgICAgIlRoZSBhZ2Vu" + - "dCBleHBsYWluZWQgdGhhdCBhcmJpdHJhcnkgY2hhcnQgdmFsdWVzIG11c3QgYmUgc2V0IHZpYSBy" + - "ZWxlYXNlIGlubGluZSB2YWx1ZXM6IGJsb2NrcyIsCiAgICAgICJUaGUgYWdlbnQgbGlzdGVkIGV4" + - "YW1wbGVzIG9mIHZhbHVlcyB0aGF0IGFyZSBwcm9wYWdhdGVkIGFuZCBhcmJpdHJhcnkgY2hhcnQg" + - "dmFsdWVzIHRoYXQgcmVxdWlyZSBhIHJlbGVhc2UgdmFsdWVzIGJsb2NrIgogICAgXQogIH0sCiAg" + - "ewogICAgImlkIjogIlMxNC1lbmFibGUtbGxtLWZ1bmN0aW9ucyIsCiAgICAicXVlc3Rpb24iOiAi" + - "SSBuZWVkIHRvIGRlcGxveSBmdW5jdGlvblR5cGU6IExMTSBmdW5jdGlvbnMgb24gYSBzZWxmLW1h" + - "bmFnZWQsIHNpbmdsZS1ub2RlIGlzb2xhdGVkIHRlc3QgY2x1c3Rlci4gV2hhdCBIZWxtZmlsZSBj" + - "b25maWd1cmF0aW9uIGFuZCB2ZXJpZmljYXRpb24gc3RlcHMgZG8gSSBuZWVkPyIsCiAgICAiZXhw" + - "ZWN0ZWRfc2tpbGwiOiAibnZjZi1zZWxmLW1hbmFnZWQtaW5zdGFsbGF0aW9uIiwKICAgICJncm91" + - "bmRfdHJ1dGgiOiAiVGhlIGFnZW50IGVuYWJsZWQgdGhlIExMTSBhZGRvbiB3aXRoIGFkZG9ucy5s" + - "bG0uZW5hYmxlZCwgY29uZmlndXJlZCBzaW5nbGUgcmVwbGljYXMgZm9yIHRoZSBMTE0gQVBJIEdh" + - "dGV3YXkgYW5kIHJlcXVlc3Qgcm91dGVyLCBhbmQgZXhwbGFpbmVkIHRoYXQgdGhlIHJlcXVlc3Qg" + - "cm91dGVyIHVzZXMgcG93ZXItb2YtdHdvIHdoZW4gbm8gbG9hZC1iYWxhbmNlciBjb25maWd1cmF0" + - "aW9uIGlzIHNldC4gSXQgbGlua2VkIHRoZSBjYW5vbmljYWwgcmVxdWVzdC1yb3V0ZXIgbG9hZC1i" + - "YWxhbmNpbmcgZ3VpZGUgZm9yIG90aGVyIHJvdXRpbmcgbWV0aG9kcy4gRm9yIHRoZSBpc29sYXRl" + - "ZCBwbGFpbnRleHQgY2x1c3RlciwgaXQgaW5jbHVkZWQgYm90aCBhZGRvbnMubGxtLmdhdGV3YXku" + - "YXV0aC5ncnBjSW5zZWN1cmUgYW5kIGFnZW50Q29uZmlnLm1lcmdlQ29uZmlnLndvcmtsb2FkLnN0" + - "YXJnYXRlUVVJQ0luc2VjdXJlLCB3aXRoIGEgd2FybmluZyB0aGF0IHRob3NlIHNldHRpbmdzIGFy" + - "ZSBub3QgZm9yIHByb2R1Y3Rpb24uIEl0IHJlZnJlc2hlZCB0aGUgY29tcHV0ZSBwbGFuZSB1c2lu" + - "ZyB0aGUgc2FtZSBoYW5kb2ZmIHVzZWQgZHVyaW5nIGluc3RhbGxhdGlvbiwgcmVkZXBsb3llZCBl" + - "eGlzdGluZyBMTE0gZnVuY3Rpb25zLCBhbmQgdmVyaWZpZWQgdGhlIExMTSBkZXBsb3ltZW50cywg" + - "cm91dGUsIGFuZCBsbG0td29ya2VyIHNpZGVjYXIuIiwKICAgICJleHBlY3RlZF9iZWhhdmlvciI6" + - "IFsKICAgICAgIlRoZSBhZ2VudCB1c2VkIGFkZG9ucy5sbG0uZW5hYmxlZCwgbm90IHRoZSBvYnNv" + - "bGV0ZSBsbG0uZW5hYmxlZCBwYXRoIiwKICAgICAgIlRoZSBhZ2VudCBzZXQgZ2F0ZXdheSBhbmQg" + - "cmVxdWVzdFJvdXRlciByZXBsaWNhQ291bnQgdG8gMSBmb3IgdGhlIHNpbmdsZS1ub2RlIHRlc3Qg" + - "Y2x1c3RlciIsCiAgICAgICJUaGUgYWdlbnQgc3RhdGVkIHRoYXQgdGhlIHJlcXVlc3Qgcm91dGVy" + - "IGRlZmF1bHRzIHRvIHBvd2VyLW9mLXR3byBhbmQgbGlua2VkIHRoZSBjYW5vbmljYWwgcmVxdWVz" + - "dC1yb3V0ZXIgbG9hZC1iYWxhbmNpbmcgZ3VpZGUgZm9yIG90aGVyIG1ldGhvZHMiLAogICAgICAi" + - "VGhlIGFnZW50IGluY2x1ZGVkIGFkZG9ucy5sbG0uZ2F0ZXdheS5hdXRoLmdycGNJbnNlY3VyZSBh" + - "bmQgd29ya2xvYWQuc3RhcmdhdGVRVUlDSW5zZWN1cmUgZm9yIHRoZSBpc29sYXRlZCBwbGFpbnRl" + - "eHQgY2x1c3RlciwgYW5kIHdhcm5lZCBhZ2FpbnN0IHVzaW5nIHRoZW0gaW4gcHJvZHVjdGlvbiIs" + - "CiAgICAgICJUaGUgYWdlbnQgYXBwbGllZCB0aGUgY29udHJvbC1wbGFuZSBIZWxtZmlsZSBlbnZp" + - "cm9ubWVudCwgcmVmcmVzaGVkIHRoZSBjb21wdXRlIHBsYW5lIHdpdGggdGhlIHNhbWUgc2VsZWN0" + - "ZWQgaGFuZG9mZiwgYW5kIHJlY3JlYXRlZCBvciByZWRlcGxveWVkIGV4aXN0aW5nIExMTSBmdW5j" + - "dGlvbnMiLAogICAgICAiVGhlIGFnZW50IHZlcmlmaWVkIGxsbS1hcGktZ2F0ZXdheSwgbGxtLXJl" + - "cXVlc3Qtcm91dGVyLCB0aGUgTExNIEhUVFBSb3V0ZSwgYW5kIHRoZSBsbG0td29ya2VyIHNpZGVj" + - "YXIgaW5jbHVkaW5nIC0tcXVpYy1pbnNlY3VyZSIKICAgIF0KICB9LAogIHsKICAgICJpZCI6ICJH" + - "OC1ORUctbm90LWZvci1rM2QiLAogICAgInF1ZXN0aW9uIjogIlNldCB1cCBhIGxvY2FsIE5WQ0Yg" + - "ZGV2IGNsdXN0ZXIgdXNpbmcgazNkIGZvciB0ZXN0aW5nIiwKICAgICJleHBlY3RlZF9za2lsbCI6" + - "IG51bGwsCiAgICAic2hvdWxkX3RyaWdnZXIiOiBmYWxzZSwKICAgICJncm91bmRfdHJ1dGgiOiAi" + - "VGhpcyBpcyBhIGxvY2FsIGszZCBkZXZlbG9wbWVudCByZXF1ZXN0IHRoYXQgYmVsb25ncyB0byB0" + - "aGUgbnZjZi1zZWxmLWhvc3RlZC1sb2NhbC1kZXYgc2tpbGwsIG5vdCBudmNmLXNlbGYtbWFuYWdl" + - "ZC1pbnN0YWxsYXRpb24uIFRoZSBhZ2VudCBkaWQgbm90IHJlYWQgb3IgdXNlIHRoZSBzZWxmLW1h" + - "bmFnZWQgaW5zdGFsbGF0aW9uIHNraWxsIGFuZCBpbnN0ZWFkIHByb3ZpZGVkIGszZC1zcGVjaWZp" + - "YyBndWlkYW5jZS4iLAogICAgImV4cGVjdGVkX2JlaGF2aW9yIjogWwogICAgICAiVGhlIGFnZW50" + - "IGRpZCBub3QgcmVhZCBudmNmLXNlbGYtbWFuYWdlZC1pbnN0YWxsYXRpb24vU0tJTEwubWQiLAog" + - "ICAgICAiVGhlIGFnZW50IGRpZCBub3QgcHJvdmlkZSBoZWxtZmlsZS1iYXNlZCBwcm9kdWN0aW9u" + - "IGRlcGxveW1lbnQgaW5zdHJ1Y3Rpb25zIiwKICAgICAgIlRoZSBhZ2VudCBwcm92aWRlZCBrM2Qt" + - "c3BlY2lmaWMgbG9jYWwgZGV2ZWxvcG1lbnQgZ3VpZGFuY2Ugb3IgZGVmZXJyZWQgdG8gdGhlIGFw" + - "cHJvcHJpYXRlIGxvY2FsLWRldiBza2lsbCIKICAgIF0KICB9Cl0KUEsHCCsTuD+tVQAArVUAAFBL" + - "AwQUAAgAAAAAACEAAAAAAAAAAAAAAAAALwAJAGRhdGEvbnZjZi1zZWxmLW1hbmFnZWQtaW5zdGFs" + - "bGF0aW9uL2V4YW1wbGVzLm1kVVQFAAEAps4SIyBFeGFtcGxlcwoKV29ya2VkIGV4YW1wbGVzIGJh" + - "c2VkIG9uIHJlYWwgZGVwbG95bWVudCBzY2VuYXJpb3MuCgojIyBFeGFtcGxlIDE6IE92ZXJyaWRl" + - "IENhc3NhbmRyYSBSZXNvdXJjZXMKClRoZSBkZWZhdWx0IENhc3NhbmRyYSByZXNvdXJjZSBsaW1p" + - "dHMgY2F1c2UgT09NIG9uIGxhcmdlIGluc3RhbmNlIHR5cGVzIChlLmcuLCBgcDUuNDh4bGFyZ2Vg" + - "KS4KClByb2JsZW06IENhc3NhbmRyYSBwb2RzIHJlc3RhcnQgd2l0aCBgT09NS2lsbGVkYC4KClNv" + - "bHV0aW9uOiBPdmVycmlkZSByZXNvdXJjZXMgdmlhIGhlbG1maWxlIHJlbGVhc2UgdmFsdWVzIGJs" + - "b2NrLgoKIyMjIFN0ZXAgMTogQ2FwdHVyZSBiYXNlbGluZQoKYGBgYmFzaApIRUxNRklMRV9FTlY9" + - "PGVudj4gaGVsbWZpbGUgLS1zZWxlY3RvciBuYW1lPWNhc3NhbmRyYSB0ZW1wbGF0ZSA+IC90bXAv" + - "Y2Fzcy1iZWZvcmUueWFtbApncmVwIC1BOCAncmVzb3VyY2VzOicgL3RtcC9jYXNzLWJlZm9yZS55" + - "YW1sIHwgaGVhZCAtMTAKYGBgCgojIyMgU3RlcCAyOiBBZGQgb3ZlcnJpZGUgdG8gaGVsbWZpbGUu" + - "ZC8wMS1kZXBlbmRlbmNpZXMueWFtbC5nb3RtcGwKCkluIHRoZSBleGFtcGxlcyBiZWxvdywgYDxw" + - "cml2YXRlLXZhbHVlcz5gIHJlZmVycyB0byB0aGUgYHNlY3JldHMvYCBkaXJlY3RvcnkgYXQgdGhl" + - "IGhlbG1maWxlIHN0YWNrIHJvb3QuCgpgYGB5YW1sCi0gbmFtZTogY2Fzc2FuZHJhCiAgdmVyc2lv" + - "bjogMC44LjAKICBjb25kaXRpb246IGNhc3NhbmRyYS5lbmFibGVkCiAgbmFtZXNwYWNlOiBjYXNz" + - "YW5kcmEtc3lzdGVtCiAgPDw6ICpkZXBlbmRlbmN5CiAgdmFsdWVzOgogICAgLSAuLi9nbG9iYWwu" + - "eWFtbC5nb3RtcGwKICAgIC0gLi4vPHByaXZhdGUtdmFsdWVzPi97eyByZXF1aXJlZEVudiAiSEVM" + - "TUZJTEVfRU5WIiB9fS1zZWNyZXRzLnlhbWwKICAgIC0gY2Fzc2FuZHJhOgogICAgICAgIHJlc291" + - "cmNlczoKICAgICAgICAgIGxpbWl0czoKICAgICAgICAgICAgY3B1OiAiOCIKICAgICAgICAgICAg" + - "bWVtb3J5OiA4MTkyTWkKICAgICAgICAgIHJlcXVlc3RzOgogICAgICAgICAgICBjcHU6ICIyIgog" + - "ICAgICAgICAgICBtZW1vcnk6IDQwOTZNaQpgYGAKCiMjIyBTdGVwIDM6IFZlcmlmeSBhbmQgYXBw" + - "bHkKCmBgYGJhc2gKSEVMTUZJTEVfRU5WPTxlbnY+IGhlbG1maWxlIC0tc2VsZWN0b3IgbmFtZT1j" + - "YXNzYW5kcmEgdGVtcGxhdGUgPiAvdG1wL2Nhc3MtYWZ0ZXIueWFtbApkaWZmIC90bXAvY2Fzcy1i" + - "ZWZvcmUueWFtbCAvdG1wL2Nhc3MtYWZ0ZXIueWFtbCAgIyBDb25maXJtIHJlc291cmNlcyBjaGFu" + - "Z2VkCkhFTE1GSUxFX0VOVj08ZW52PiBoZWxtZmlsZSAtLXNlbGVjdG9yIG5hbWU9Y2Fzc2FuZHJh" + - "IHN5bmMKYGBgCgpOb3RlOiBgcmVzb3VyY2VQcmVzZXRgIChhIEJpdG5hbWkgZmVhdHVyZSkgaXMg" + - "bm90IGF2YWlsYWJsZSBpbiB0aGUgTlZDRiBjYXNzYW5kcmEgd3JhcHBlciBjaGFydC4gVXNlIGV4" + - "cGxpY2l0IGByZXNvdXJjZXNgIGluc3RlYWQuCgotLS0KCiMjIEV4YW1wbGUgMjogRGVwbG95IGZy" + - "b20gTkdDIFByaXZhdGUgUmVnaXN0cnkgd2l0aCBQdWxsIFNlY3JldHMKCkRlcGxveSB0aGUgTlZD" + - "RiBzdGFjayBwdWxsaW5nIGltYWdlcyBkaXJlY3RseSBmcm9tIE5HQyAoYG52Y3IuaW9gKSBpbnN0" + - "ZWFkIG9mIGEgbWlycm9yZWQgcmVnaXN0cnksIHVzaW5nIGltYWdlIHB1bGwgc2VjcmV0cy4KCiMj" + - "IyBTdGVwIDE6IENvbmZpZ3VyZSBlbnZpcm9ubWVudCBmb3IgTkdDCgpgYGB5YW1sCiMgZW52aXJv" + - "bm1lbnRzLzxlbnY+LnlhbWwKZ2xvYmFsOgogIGhlbG06CiAgICBzb3VyY2VzOgogICAgICByZWdp" + - "c3RyeTogbnZjci5pbwogICAgICByZXBvc2l0b3J5OiBudmlkaWEvbnZjZgogIGltYWdlOgogICAg" + - "cmVnaXN0cnk6IG52Y3IuaW8KICAgIHJlcG9zaXRvcnk6IG52aWRpYS9udmNmCmBgYAoKIyMjIFN0" + - "ZXAgMjogQXV0aGVudGljYXRlIGxvY2FsbHkgKGZvciBoZWxtZmlsZSBjaGFydCBwdWxscykKCmBg" + - "YGJhc2gKZG9ja2VyIGxvZ2luIG52Y3IuaW8gLXUgJyRvYXV0aHRva2VuJyAtcCAiJE5HQ19BUElf" + - "S0VZIgpoZWxtIHJlZ2lzdHJ5IGxvZ2luIG52Y3IuaW8gLXUgJyRvYXV0aHRva2VuJyAtcCAiJE5H" + - "Q19BUElfS0VZIgpgYGAKCiMjIyBTdGVwIDM6IENyZWF0ZSBuYW1lc3BhY2VzIGFuZCBwdWxsIHNl" + - "Y3JldHMKCmBgYGJhc2gKZXhwb3J0IE5HQ19BUElfS0VZPSI8eW91ci1uZ2MtYXBpLWtleT4iCgpm" + - "b3IgbnMgaW4gY2Fzc2FuZHJhLXN5c3RlbSBuYXRzLXN5c3RlbSBudmNmIGFwaS1rZXlzIGVzcyBz" + - "aXMgdmF1bHQtc3lzdGVtIGNlcnQtbWFuYWdlcjsgZG8KICBrdWJlY3RsIC0tY29udGV4dCA8Y29u" + - "dHJvbC1wbGFuZS1jb250ZXh0PiBjcmVhdGUgbmFtZXNwYWNlICIkbnMiIFwKICAgIC0tZHJ5LXJ1" + - "bj1jbGllbnQgLW8geWFtbCB8IGt1YmVjdGwgLS1jb250ZXh0IDxjb250cm9sLXBsYW5lLWNvbnRl" + - "eHQ+IGFwcGx5IC1mIC0KZG9uZQoKZm9yIG5zIGluIGNhc3NhbmRyYS1zeXN0ZW0gbmF0cy1zeXN0" + - "ZW0gbnZjZiBhcGkta2V5cyBlc3Mgc2lzIHZhdWx0LXN5c3RlbSBjZXJ0LW1hbmFnZXI7IGRvCiAg" + - "a3ViZWN0bCAtLWNvbnRleHQgPGNvbnRyb2wtcGxhbmUtY29udGV4dD4gY3JlYXRlIHNlY3JldCBk" + - "b2NrZXItcmVnaXN0cnkgbnZjci1jcmVkcyBcCiAgICAtLWRvY2tlci1zZXJ2ZXI9bnZjci5pbyBc" + - "CiAgICAtLWRvY2tlci11c2VybmFtZT0nJG9hdXRodG9rZW4nIFwKICAgIC0tZG9ja2VyLXBhc3N3" + - "b3JkPSIkTkdDX0FQSV9LRVkiIFwKICAgIC0tbmFtZXNwYWNlPSIkbnMiIFwKICAgIC0tZHJ5LXJ1" + - "bj1jbGllbnQgLW8geWFtbCB8IGt1YmVjdGwgLS1jb250ZXh0IDxjb250cm9sLXBsYW5lLWNvbnRl" + - "eHQ+IGFwcGx5IC1mIC0KZG9uZQpgYGAKCiMjIyBTdGVwIDQ6IEFkZCBpbWFnZVB1bGxTZWNyZXRz" + - "IHRvIGhlbG1maWxlIHJlbGVhc2VzCgpBZGQgdGhlIGNoYXJ0LXNwZWNpZmljIGBpbWFnZVB1bGxT" + - "ZWNyZXRzYCBrZXkgdG8gZWFjaCByZWxlYXNlLiBFeGFtcGxlIGZvciBjYXNzYW5kcmEgaW4gYGhl" + - "bG1maWxlLmQvMDEtZGVwZW5kZW5jaWVzLnlhbWwuZ290bXBsYDoKCmBgYHlhbWwKLSBuYW1lOiBj" + - "YXNzYW5kcmEKICB2ZXJzaW9uOiAwLjguMAogIGNvbmRpdGlvbjogY2Fzc2FuZHJhLmVuYWJsZWQK" + - "ICBuYW1lc3BhY2U6IGNhc3NhbmRyYS1zeXN0ZW0KICA8PDogKmRlcGVuZGVuY3kKICB2YWx1ZXM6" + - "CiAgICAtIC4uL2dsb2JhbC55YW1sLmdvdG1wbAogICAgLSAuLi88cHJpdmF0ZS12YWx1ZXM+L3t7" + - "IHJlcXVpcmVkRW52ICJIRUxNRklMRV9FTlYiIH19LXNlY3JldHMueWFtbAogICAgLSBjYXNzYW5k" + - "cmE6CiAgICAgICAgZ2xvYmFsOgogICAgICAgICAgaW1hZ2VQdWxsU2VjcmV0czoKICAgICAgICAg" + - "ICAgLSBudmNyLWNyZWRzCmBgYAoKU2VlIFtyZWZlcmVuY2VzL3B1bGwtc2VjcmV0cy5tZF0ocmVm" + - "ZXJlbmNlcy9wdWxsLXNlY3JldHMubWQpIGZvciB0aGUga2V5IGZvciBldmVyeSBjaGFydC4KClRo" + - "ZXNlIGFyZSBjb250cm9sLXBsYW5lIG5hbWVzcGFjZXMuIEZvciBhIHNlcGFyYXRlIGNvbXB1dGUg" + - "Y2x1c3RlciwgY3JlYXRlIHRoZQpzZWNyZXQgb25seSBpbiBgbnZjYS1vcGVyYXRvcmA7IHRoZSBj" + - "aGFydCBhbmQgb3BlcmF0b3IgbWlycm9yIGl0IHRvCmBudmNhLXN5c3RlbWAuIFNlZSBbU3BsaXQg" + - "Q29tcHV0ZS1QbGFuZSBJbnN0YWxsYXRpb25dKHJlZmVyZW5jZXMvY29tcHV0ZS1wbGFuZS1pbnN0" + - "YWxsYXRpb24ubWQjcHVsbC1zZWNyZXRzKS4KCiMjIyBTdGVwIDU6IERlcGxveQoKYGBgYmFzaApI" + - "RUxNRklMRV9FTlY9PGVudj4gaGVsbWZpbGUgLS1rdWJlLWNvbnRleHQgPGNvbnRyb2wtcGxhbmUt" + - "Y29udGV4dD4gc3luYwpgYGAKCiMjIyBTdGVwIDY6IFBhdGNoIFNlcnZpY2VBY2NvdW50cyBmb3Ig" + - "Y2hhcnRzIHdpdGhvdXQgbmF0aXZlIHN1cHBvcnQKCkFmdGVyIFBoYXNlIDEgKGRlcGVuZGVuY2ll" + - "cykgY29tcGxldGVzLCBPcGVuQmFvIHBvZHMgd2lsbCBiZSBpbiBgSW1hZ2VQdWxsQmFja09mZmAu" + - "IFBhdGNoIGFuZCByZXN0YXJ0OgoKYGBgYmFzaApmb3IgbnMgaW4gdmF1bHQtc3lzdGVtIG52Y2Yg" + - "ZXNzOyBkbwogIGZvciBzYSBpbiAkKGt1YmVjdGwgLS1jb250ZXh0IDxjb250cm9sLXBsYW5lLWNv" + - "bnRleHQ+IGdldCBzYSAtbiAiJG5zIiBcCiAgICAtLW5vLWhlYWRlcnMgLW8gY3VzdG9tLWNvbHVt" + - "bnM9IjptZXRhZGF0YS5uYW1lIik7IGRvCiAgICBrdWJlY3RsIC0tY29udGV4dCA8Y29udHJvbC1w" + - "bGFuZS1jb250ZXh0PiBwYXRjaCBzZXJ2aWNlYWNjb3VudCAtbiAiJG5zIiAiJHNhIiBcCiAgICAg" + - "IC1wICd7ImltYWdlUHVsbFNlY3JldHMiOiBbeyJuYW1lIjogIm52Y3ItY3JlZHMifV19JwogIGRv" + - "bmUKZG9uZQprdWJlY3RsIC0tY29udGV4dCA8Y29udHJvbC1wbGFuZS1jb250ZXh0PiBkZWxldGUg" + - "cG9kcyAtbiB2YXVsdC1zeXN0ZW0gLS1hbGwKYGBgCgpWZXJpZnk6CgpgYGBiYXNoCmt1YmVjdGwg" + - "LS1jb250ZXh0IDxjb250cm9sLXBsYW5lLWNvbnRleHQ+IGdldCBldmVudHMgLW4gdmF1bHQtc3lz" + - "dGVtIFwKICAtLXNvcnQtYnk9Jy5sYXN0VGltZXN0YW1wJyB8IGdyZXAgLWkgcHVsbAojIFNob3Vs" + - "ZCBzaG93ICJTdWNjZXNzZnVsbHkgcHVsbGVkIGltYWdlIiBmcm9tIG52Y3IuaW8KYGBgCgotLS0K" + - "CiMjIEV4YW1wbGUgMzogRnVsbCBUZWFyZG93biBhbmQgUmVpbnN0YWxsCgpXaGVuIGEgZGVwbG95" + - "bWVudCBpcyBicm9rZW4gYW5kIHlvdSBuZWVkIGEgY2xlYW4gc2xhdGUuCgojIyMgU3RlcCAxOiBE" + - "ZXN0cm95IHRoZSBjb21wdXRlLXBsYW5lIHN0YWNrCgpgYGBiYXNoCm1ha2UgLUMgZGVwbG95L3N0" + - "YWNrcy9udmNmLWNvbXB1dGUtcGxhbmUgZGVzdHJveSBcCiAgQ0xVU1RFUl9OQU1FPTxjbHVzdGVy" + - "LW5hbWU+IFwKICBIRUxNRklMRV9FTlY9PGVudj4gXAogIEtVQkVDT05GSUdfRklMRT08Y29tcHV0" + - "ZS1wbGFuZS1rdWJlY29uZmlnPgpgYGAKCklmIGNvbXB1dGUgY2xlYW51cCBpcyBzdHVjayBvbiBm" + - "aW5hbGl6ZXJzLCB1c2UgdGhlIGNvbXB1dGUtY29udGV4dCBwcm9jZWR1cmUgaW4KW2RlYnVnZ2lu" + - "Zy5tZF0ocmVmZXJlbmNlcy9kZWJ1Z2dpbmcubWQjZmFpbHVyZS1udmNhLWNsZWFudXAtc3R1Y2st" + - "ZmluYWxpemVycykuCgojIyMgU3RlcCAyOiBEZXJlZ2lzdGVyIHRoZSBjb21wdXRlIGNsdXN0ZXIK" + - "ClJlYWQgYGNsdXN0ZXJJRGAgYW5kIGBuY2FJRGAgZnJvbQpgZGVwbG95L3N0YWNrcy9udmNmLWNv" + - "bXB1dGUtcGxhbmUvcmVnaXN0cmF0aW9uLzxjbHVzdGVyLW5hbWU+LXJlZ2lzdGVyLXZhbHVlcy55" + - "YW1sYC4KU2hvdyB0aGUgSUQgYW5kIGdldCBjb25maXJtYXRpb24gYmVmb3JlIGRlbGV0aW5nIHRo" + - "ZSBJQ01TIHJvdzoKCmBgYGJhc2gKPG52Y2YtY2xpPiAtLWNvbmZpZyA8Y29uZmlnPiBjbHVzdGVy" + - "IGRlbGV0ZSBcCiAgLS1jbHVzdGVyLWlkIDxjbHVzdGVyLWlkLWZyb20tcmVnaXN0cmF0aW9uLXZh" + - "bHVlcz4gXAogIC0tbmNhLWlkIDxuY2EtaWQ+IFwKICAtLWlnbm9yZS1taXNzaW5nCmBgYAoKUmVw" + - "ZWF0IHN0ZXBzIDEgYW5kIDIgZm9yIGV2ZXJ5IGNvbXB1dGUgY2x1c3Rlci4KCiMjIyBTdGVwIDM6" + - "IERlc3Ryb3kgdGhlIGNvbnRyb2wtcGxhbmUgc3RhY2sKClByZXNlcnZlIHRoZSBgY2VydC1tYW5h" + - "Z2VyYCBuYW1lc3BhY2UgYnkgZGVmYXVsdC4gTmFtZXNwYWNlIHByZXNlcnZhdGlvbiBkb2VzCm5v" + - "dCBwcmVzZXJ2ZSB0aGUgSGVsbSByZWxlYXNlLiBCZWZvcmUgcnVubmluZyBkZXN0cm95LCBpZGVu" + - "dGlmeSB3aGV0aGVyCmNlcnQtbWFuYWdlciBpcyBleHRlcm5hbC4gRm9yIGFuIGV4dGVybmFsIGlu" + - "c3RhbGxhdGlvbiwgcmVxdWlyZSBlZmZlY3RpdmUKYGNlcnRNYW5hZ2VyLmVuYWJsZWQ6IGZhbHNl" + - "YCBhbmQgYWJvcnQgaWYgaXQgaXMgdHJ1ZS4gRm9yIGFuIGludGVuZGVkCnN0YWNrLW1hbmFnZWQg" + - "cmVsZWFzZSB3aXRoIGVmZmVjdGl2ZSBgY2VydE1hbmFnZXIuZW5hYmxlZDogdHJ1ZWAsIHZlcmlm" + - "eQptYXRjaGluZyBzdGFjayBIZWxtIHJlbGVhc2UgbWV0YWRhdGEgYW5kIGFib3J0IG9uIG1pc3Np" + - "bmcgb3IgbWlzbWF0Y2hlZApldmlkZW5jZS4gT25seSBwbGFuIG5hbWVzcGFjZSByZW1vdmFsIGFm" + - "dGVyIHZlcmlmeWluZyBuYW1lc3BhY2UgcHJvdmVuYW5jZSBhbmQKZ2V0dGluZyBleHBsaWNpdCBj" + - "b25maXJtYXRpb247IG90aGVyd2lzZSBkbyBub3QgZGVsZXRlIGl0LgoKYGBgYmFzaApLVUJFQ09O" + - "RklHPTxjb250cm9sLXBsYW5lLWt1YmVjb25maWc+IFwKbWFrZSAtQyBkZXBsb3kvc3RhY2tzL3Nl" + - "bGYtbWFuYWdlZCBkZXN0cm95IFwKICBIRUxNRklMRV9FTlY9PGVudj4gXAogIEtVQkVDT05GSUdf" + - "RklMRT08Y29udHJvbC1wbGFuZS1rdWJlY29uZmlnPgpgYGAKClBhc3MgYm90aCBrdWJlY29uZmln" + - "IGZvcm1zIGJlY2F1c2UgY29udHJvbC1wbGFuZSBuYW1lc3BhY2UgY2xlYW51cCB1c2VzCmFtYmll" + - "bnQgYGt1YmVjdGxgLgoKIyMjIFN0ZXAgNDogVmVyaWZ5IGNsZWFuCgpgYGBiYXNoCmt1YmVjdGwg" + - "LS1jb250ZXh0IDxjb21wdXRlLXBsYW5lLWNvbnRleHQ+IGdldCBucyB8IFwKICBncmVwIC1FICco" + - "bnZjYXxudmNmLWJhY2tlbmR8Z3JvdmV8ZHluYW1vKScKa3ViZWN0bCAtLWNvbnRleHQgPGNvbnRy" + - "b2wtcGxhbmUtY29udGV4dD4gZ2V0IG5zIHwgXAogIGdyZXAgLUUgJyhjYXNzYW5kcmF8bmF0c3x2" + - "YXVsdHxudmNmfGFwaS1rZXlzfGVzc3xzaXMpJwojIEJvdGggY29tbWFuZHMgc2hvdWxkIHJldHVy" + - "biBlbXB0eS4KYGBgCgojIyMgU3RlcCA1OiBSZWluc3RhbGwgaW4gc3BsaXQgb3JkZXIKCkZvbGxv" + - "dyBbQ2xlYW4gSW5zdGFsbGF0aW9uXShTS0lMTC5tZCNjbGVhbi1pbnN0YWxsYXRpb24pLCB0aGVu" + - "IHJldHVybiB0byB0aGUKc2FtZSBoYW5kb2ZmIGluIFtTcGxpdCBDb21wdXRlLVBsYW5lIEluc3Rh" + - "bGxhdGlvbl0ocmVmZXJlbmNlcy9jb21wdXRlLXBsYW5lLWluc3RhbGxhdGlvbi5tZCkuCgotLS0K" + - "CiMjIEV4YW1wbGUgNDogUmVjb3ZlciBmcm9tIGEgR2F0ZXdheSBFbmRwb2ludCBDaGFuZ2UKClRo" + - "ZSBzZXBhcmF0ZWx5IHByb3Zpc2lvbmVkIEdhdGV3YXkgb3IgaXRzIGxvYWQgYmFsYW5jZXIgd2Fz" + - "IHJlY3JlYXRlZCBhbmQgZ290IGEgbmV3IGVuZHBvaW50LgoKIyMjIFN0ZXAgMTogR2V0IHRoZSBu" + - "ZXcgZW5kcG9pbnQKCmBgYGJhc2gKR0FURVdBWV9BRERSPSQoa3ViZWN0bCAtLWNvbnRleHQgPGNv" + - "bnRyb2wtcGxhbmUtY29udGV4dD4gZ2V0IGdhdGV3YXkgXAogIG52Y2YtZ2F0ZXdheSAtbiBlbnZv" + - "eS1nYXRld2F5IFwKICAtbyBqc29ucGF0aD0ney5zdGF0dXMuYWRkcmVzc2VzWzBdLnZhbHVlfScp" + - "CnRlc3QgLW4gIiRHQVRFV0FZX0FERFIiCmBgYAoKIyMjIFN0ZXAgMjogVXBkYXRlIEROUyBhbmQg" + - "ZGlyZWN0IGFkZHJlc3MgZmllbGRzCgpLZWVwIGBnbG9iYWwuZG9tYWluYCwgcm91dGUgaG9zdG5h" + - "bWVzLCBhbmQgQ0xJIEhvc3QgZmllbGRzIHVuY2hhbmdlZC4gUG9pbnQgdGhlCkROUyByZWNvcmRz" + - "IGZvciByZW5kZXJlZCByb3V0ZSBob3N0bmFtZXMsIHN1Y2ggYXMgYGFwaS48ZG9tYWluPmAgYW5k" + - "CmAqLmludm9jYXRpb24uPGRvbWFpbj5gLCB0byBgR0FURVdBWV9BRERSYC4gRm9yIGEgdGVtcG9y" + - "YXJ5IGVudmlyb25tZW50IHdpdGhvdXQKRE5TLCBrZWVwIGl0cyByZXNlcnZlZCByb3V0ZSBzdWZm" + - "aXggYW5kIGNvbm5lY3QgdG8gYEdBVEVXQVlfQUREUmAgd2l0aCB0aGUKbWF0Y2hpbmcgYEhvc3Rg" + - "IGhlYWRlci4KCkZvciBhIHNwbGl0IGRlcGxveW1lbnQgY29uZmlndXJlZCB3aXRoIGRpcmVjdCBH" + - "YXRld2F5IGFkZHJlc3NlcywgcmVwbGFjZSBvbmx5CnRoZSBhZGRyZXNzLWJlYXJpbmcgdmFsdWVz" + - "OiBjb250cm9sLXBsYW5lIGBudmNmTmF0c1NlcnZpY2VVUkxgLCBjb21wdXRlLXBsYW5lCklDTVMs" + - "IFJlVmFsLCBhbmQgTkFUUyBVUkxzLCBhbmQgQ0xJIFVSTCBmaWVsZHMuIEtlZXAgdGhlaXIgZG9t" + - "YWluIGFuZCBIb3N0Cm92ZXJyaWRlcyB1bmNoYW5nZWQuIFJlZnJlc2ggcmVnaXN0cmF0aW9uIGFu" + - "ZCBpbnN0YWxsYXRpb24gdGhyb3VnaCB0aGUgc2FtZQpoYW5kb2ZmIHVzZWQgb3JpZ2luYWxseS4g" + - "U2VlCltTcGxpdCBDb21wdXRlLVBsYW5lIEluc3RhbGxhdGlvbl0ocmVmZXJlbmNlcy9jb21wdXRl" + - "LXBsYW5lLWluc3RhbGxhdGlvbi5tZCkKZm9yIHRoZSBmaWVsZHMgYW5kIGNvbXBsZXRlIGNvbW1h" + - "bmRzLgoKIyMjIFN0ZXAgMzogVmVyaWZ5IGJvdGggY29udGV4dHMKCmBgYGJhc2gKZGlnICtzaG9y" + - "dCAiYXBpLjxkb21haW4+IgpjdXJsIC1IICJIb3N0OiBhcGkuPGRvbWFpbj4iICJodHRwOi8vJEdB" + - "VEVXQVlfQUREUi9oZWFsdGgiCmt1YmVjdGwgLS1jb250ZXh0IDxjb250cm9sLXBsYW5lLWNvbnRl" + - "eHQ+IGdldCBnYXRld2F5IG52Y2YtZ2F0ZXdheSBcCiAgLW4gZW52b3ktZ2F0ZXdheSAtbyB3aWRl" + - "Cmt1YmVjdGwgLS1jb250ZXh0IDxjb250cm9sLXBsYW5lLWNvbnRleHQ+IGdldCBodHRwcm91dGVz" + - "IC1BCmt1YmVjdGwgLS1jb250ZXh0IDxjb250cm9sLXBsYW5lLWNvbnRleHQ+IGdldCB0Y3Byb3V0" + - "ZXMgLUEKa3ViZWN0bCAtLWNvbnRleHQgPGNvbXB1dGUtcGxhbmUtY29udGV4dD4gcm9sbG91dCBz" + - "dGF0dXMgXAogIGRlcGxveW1lbnQvbnZjYS1vcGVyYXRvciAtbiBudmNhLW9wZXJhdG9yIC0tdGlt" + - "ZW91dD0xMG0Ka3ViZWN0bCAtLWNvbnRleHQgPGNvbXB1dGUtcGxhbmUtY29udGV4dD4gd2FpdCBc" + - "CiAgbnZjZmJhY2tlbmQvPGNvbXB1dGUtcGxhbmUtY2x1c3Rlci1uYW1lPiAtbiBudmNhLW9wZXJh" + - "dG9yIFwKICAtLWZvcj1qc29ucGF0aD0ney5zdGF0dXMuYWdlbnRTdGF0dXN9Jz1oZWFsdGh5IC0t" + - "dGltZW91dD0xMG0KYGBgCgotLS0KCiMjIEV4YW1wbGUgNTogRGVwbG95IE9ubHkgRGVwZW5kZW5j" + - "aWVzCgpVc2VmdWwgZm9yIHRlc3Rpbmcgb3Igd2hlbiBpdGVyYXRpbmcgb24gc2VydmljZSBjb25m" + - "aWd1cmF0aW9uLgoKYGBgYmFzaAojIERlcGxveSBqdXN0IE5BVFMsIENhc3NhbmRyYSwgT3BlbkJh" + - "bwpIRUxNRklMRV9FTlY9PGVudj4gaGVsbWZpbGUgLS1zZWxlY3RvciByZWxlYXNlLWdyb3VwPWRl" + - "cGVuZGVuY2llcyBzeW5jCgojIENoZWNrIHN0YXR1cwprdWJlY3RsIGdldCBwb2RzIC1uIG5hdHMt" + - "c3lzdGVtCmt1YmVjdGwgZ2V0IHBvZHMgLW4gY2Fzc2FuZHJhLXN5c3RlbQprdWJlY3RsIGdldCBw" + - "b2RzIC1uIHZhdWx0LXN5c3RlbQoKIyBEZXBsb3kganVzdCBvbmUgc3BlY2lmaWMgcmVsZWFzZQpI" + - "RUxNRklMRV9FTlY9PGVudj4gaGVsbWZpbGUgLS1zZWxlY3RvciBuYW1lPWNhc3NhbmRyYSBzeW5j" + - "CmBgYAoKIyMjIFNlbGVjdG9yIHJlZmVyZW5jZQoKfCBTZWxlY3RvciB8IFJlbGVhc2VzIHwKfC0t" + - "LS0tLS0tLS18LS0tLS0tLS0tLXwKfCBgcmVsZWFzZS1ncm91cD1kZXBlbmRlbmNpZXNgIHwgbmF0" + - "cywgY2Fzc2FuZHJhLCBvcGVuYmFvLXNlcnZlciB8CnwgYHJlbGVhc2UtZ3JvdXA9c2VydmljZXNg" + - "IHwgYXBpLWtleXMsIHNpcywgYXBpLCBpbnZvY2F0aW9uLXNlcnZpY2UsIGdycGMtcHJveHksIGVz" + - "cy1hcGksIG5vdGFyeS1zZXJ2aWNlLCByZXZhbCwgb3B0aW9uYWwgbGxtLXJlcXVlc3Qtcm91dGVy" + - "IGFuZCBsbG0tYXBpLWdhdGV3YXkgd2hlbiBgbGxtLmVuYWJsZWQ9dHJ1ZWAsIG9wdGlvbmFsIHZh" + - "bml0eS1nYXRld2F5IG9ubHkgaW4gc3RhY2sgcGFja2FnZXMgdGhhdCBpbmNsdWRlIHRoZSBhZGRv" + - "biBhbmQgaGF2ZSBgYWRkb25zLnZhbml0eUdhdGV3YXkuZW5hYmxlZD10cnVlYCwgb3B0aW9uYWwg" + - "bnZjZi11aSBvbmx5IGluIHN0YWNrIHBhY2thZ2VzIHRoYXQgaW5jbHVkZSB0aGUgYWRkb24gYW5k" + - "IGhhdmUgYGFkZG9ucy5udmNmVWkuZW5hYmxlZD10cnVlYCB8CnwgYG5hbWU9bGxtLXJlcXVlc3Qt" + - "cm91dGVyYCB8IERlcGxveSBqdXN0IHRoZSBMTE0gcmVxdWVzdCByb3V0ZXIgd2hlbiBgbGxtLmVu" + - "YWJsZWQ9dHJ1ZWAgfAp8IGBuYW1lPWxsbS1hcGktZ2F0ZXdheWAgfCBEZXBsb3kganVzdCB0aGUg" + - "TExNIEFQSSBnYXRld2F5IHdoZW4gYGxsbS5lbmFibGVkPXRydWVgIHwKfCBgbmFtZT12YW5pdHkt" + - "Z2F0ZXdheWAgfCBEZXBsb3kganVzdCBWYW5pdHkgR2F0ZXdheSBvbmx5IHdoZW4gdGhlIHN0YWNr" + - "IHBhY2thZ2UgaW5jbHVkZXMgdGhhdCByZWxlYXNlIGFuZCBgYWRkb25zLnZhbml0eUdhdGV3YXku" + - "ZW5hYmxlZD10cnVlYCB8CnwgYG5hbWU9bnZjZi11aWAgfCBEZXBsb3kgTlZDRiBVSSBvbmx5IHdo" + - "ZW4gdGhlIHN0YWNrIHBhY2thZ2UgaW5jbHVkZXMgdGhhdCByZWxlYXNlIGFuZCBgYWRkb25zLm52" + - "Y2ZVaS5lbmFibGVkPXRydWVgIHwKfCBgcmVsZWFzZS1ncm91cD1pbmdyZXNzYCB8IGluZ3Jlc3Mg" + - "KGdhdGV3YXkgcm91dGVzKSB8CnwgYG5hbWU9PHJlbGVhc2U+YCB8IEFueSBpbmRpdmlkdWFsIHJl" + - "bGVhc2UgYnkgbmFtZSB8CgpOb3RlOiBgYWRtaW4taXNzdWVyLXByb3h5YCBkb2VzIG5vdCBoYXZl" + - "IGEgcmVsZWFzZS1ncm91cCBsYWJlbC4gVGFyZ2V0IGl0IHdpdGggYC0tc2VsZWN0b3IgbmFtZT1h" + - "ZG1pbi1pc3N1ZXItcHJveHlgLgpQSwcIAlJOQH8oAAB/KAAAUEsDBBQACAAAAAAAIQAAAAAAAAAA" + - "AAAAAABMAAkAZGF0YS9udmNmLXNlbGYtbWFuYWdlZC1pbnN0YWxsYXRpb24vcmVmZXJlbmNlcy9j" + - "b21wdXRlLXBsYW5lLWluc3RhbGxhdGlvbi5tZFVUBQABAKbOEiMgU3BsaXQgQ29tcHV0ZS1QbGFu" + - "ZSBJbnN0YWxsYXRpb24KClRoZSBjb250cm9sIHBsYW5lIGFuZCBjb21wdXRlIHBsYW5lIGFyZSBz" + - "ZXBhcmF0ZSBzdGFja3MuIEluc3RhbGwgdGhlIGNvbnRyb2wKcGxhbmUgZmlyc3QsIHRoZW4gcmVn" + - "aXN0ZXIgYW5kIGluc3RhbGwgZWFjaCBjb21wdXRlIGNsdXN0ZXIuIENob29zZSBvbmUgaGFuZG9m" + - "ZgpiZWxvdyBhbmQgdXNlIGl0IGZvciB0aGUgZnVsbCBsaWZlY3ljbGUuIERvIG5vdCBjb21iaW5l" + - "IGEgQ0xJLWdlbmVyYXRlZCBwcm9maWxlCndpdGggdGhlIEhlbG1maWxlIHZhbHVlcyBmbG93LgoK" + - "IyMgQ2hvb3NlIGEgSGFuZG9mZgoKfCBGbG93IHwgU291cmNlIG9mIGNvbnRyb2wtcGxhbmUgZW5k" + - "cG9pbnRzIHwgUmVnaXN0cmF0aW9uIGFydGlmYWN0IHwKfC0tLS0tLXwtLS0tLS0tLS0tLS0tLS0t" + - "LS0tLS0tLS0tLS0tLS0tLS0tLXwtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLXwKfCBIZWxtZmlsZSB2" + - "YWx1ZXMgfCBTZXBhcmF0ZSBjb250cm9sLXBsYW5lIGFuZCBjb21wdXRlLXBsYW5lIGVudmlyb25t" + - "ZW50IGZpbGVzIHwgYGRlcGxveS9zdGFja3MvbnZjZi1jb21wdXRlLXBsYW5lL3JlZ2lzdHJhdGlv" + - "bi88Y2x1c3Rlcj4tcmVnaXN0ZXItdmFsdWVzLnlhbWxgIHwKfCBDTEkgcHJvZmlsZSB8IENMSS1n" + - "ZW5lcmF0ZWQgYGRlcGxveS9zdGFja3Mvc2VsZi1tYW5hZ2VkL291dC9jb250cm9sLXBsYW5lLXBy" + - "b2ZpbGUueWFtbGAgfCBDTEktZ2VuZXJhdGVkIGBkZXBsb3kvc3RhY2tzL252Y2YtY29tcHV0ZS1w" + - "bGFuZS9vdXQvPGNsdXN0ZXI+LXJlZ2lzdGVyLXZhbHVlcy55YW1sYCB8CgpUaGUgQ0xJIHByb2Zp" + - "bGUgaXMgbWFuZGF0b3J5IGZvciB0aGUgQ0xJIGZsb3cgYW5kIG11c3Qgbm90IGJlIGhhbmQtYXV0" + - "aG9yZWQuClRoZSBIZWxtZmlsZSBmbG93IGRvZXMgbm90IGNvbnN1bWUgYSBjb250cm9sLXBsYW5l" + - "IHByb2ZpbGUuCgpDb21tYW5kcyBiZWxvdyB1c2UgbW9ub3JlcG8gcGF0aHMgZnJvbSB0aGUgcmVw" + - "b3NpdG9yeSByb290LiBPcGVyYXRvcnMgdXNpbmcKZXh0cmFjdGVkIHBhY2thZ2VzIG5lZWQgbWF0" + - "Y2hpbmctdmVyc2lvbiBgbnZjZi1zZWxmLW1hbmFnZWQtc3RhY2tgIGFuZApgbnZjZi1jb21wdXRl" + - "LXBsYW5lLXN0YWNrYCBidW5kbGVzLiBTdWJzdGl0dXRlIHRob3NlIGJ1bmRsZSByb290cyBmb3IK" + - "YGRlcGxveS9zdGFja3Mvc2VsZi1tYW5hZ2VkYCBhbmQgYGRlcGxveS9zdGFja3MvbnZjZi1jb21w" + - "dXRlLXBsYW5lYC4KCiMjIEhlbG1maWxlIFZhbHVlcyBGbG93CgpDcmVhdGUgYm90aCBlbnZpcm9u" + - "bWVudCBmaWxlcyBiZWZvcmUgaW5zdGFsbGF0aW9uOgoKLSBgZGVwbG95L3N0YWNrcy9zZWxmLW1h" + - "bmFnZWQvZW52aXJvbm1lbnRzLzxlbnY+LnlhbWxgIGZvciBjb250cm9sLXBsYW5lCiAgcmVnaXN0" + - "cnksIGRvbWFpbiwgR2F0ZXdheSwgcm91dGVzLCBhbmQgc2VydmljZSBzZXR0aW5ncy4KLSBgZGVw" + - "bG95L3N0YWNrcy9udmNmLWNvbXB1dGUtcGxhbmUvZW52aXJvbm1lbnRzLzxlbnY+LnlhbWxgIGZv" + - "ciBjb21wdXRlLXBsYW5lCiAgcmVnaXN0cnksIHB1bGwgc2VjcmV0cywgYW5kIGNvbXB1dGUtcmVh" + - "Y2hhYmxlIElDTVMsIFJlVmFsLCBhbmQgTkFUUyB2YWx1ZXMuCgpGb3IgRUtTLCB1c2UgdGhlIGNh" + - "bm9uaWNhbApbQ1NQIEVuZC10by1FbmQgRXhhbXBsZV0oaHR0cHM6Ly9kb2NzLm52aWRpYS5jb20v" + - "bnZjZi92MC42LjAtcmMvY3NwLWVuZC10by1lbmQtZXhhbXBsZSkuClRoZSBjb250cm9sLXBsYW5l" + - "IGVudmlyb25tZW50IGtlZXBzIHRoZSBFbnZveSBHYXRld2F5IGNvbnRyb2xsZXIgaW4KYGVudm95" + - "LWdhdGV3YXktc3lzdGVtYCwgYXR0YWNoZXMgcm91dGVzIHRvIGBHYXRld2F5L252Y2YtZ2F0ZXdh" + - "eWAgaW4KYGVudm95LWdhdGV3YXlgLCBhbmQgZW5hYmxlcyB0aGUgTkFUUyByb3V0ZS4gVGhlIGNv" + - "bXB1dGUtcGxhbmUgZW52aXJvbm1lbnQgdXNlcwp0aGUgZXh0ZXJuYWwgYWRkcmVzcyBwbHVzIHRo" + - "ZSBzZXJ2aWNlIGhvc3Qgb3ZlcnJpZGVzLiBIZXJlLApgPGdhdGV3YXktYWRkcmVzcz5gIGlzIHRo" + - "ZSBOTEIgYWRkcmVzcyBhbmQgYDxnYXRld2F5LWRvbWFpbj5gIGlzIHRoZSBETlMgYmFzZQp3aG9z" + - "ZSBzZXJ2aWNlIHN1YmRvbWFpbnMgcmVzb2x2ZSB0byB0aGF0IE5MQjoKCmBgYHlhbWwKIyBkZXBs" + - "b3kvc3RhY2tzL3NlbGYtbWFuYWdlZC9lbnZpcm9ubWVudHMvPGVudj4ueWFtbApnbG9iYWw6CiAg" + - "ZG9tYWluOiAiPGdhdGV3YXktZG9tYWluPiIKICB3b3JrZXJFbmRwb2ludHM6CiAgICBudmNmU2Vy" + - "dmljZVVSTDogImh0dHA6Ly9hcGkuPGdhdGV3YXktZG9tYWluPiIKICAgIG52Y2ZHcnBjU2Vydmlj" + - "ZVVSTDogImh0dHA6Ly93b3JrZXItYXBpLjxnYXRld2F5LWRvbWFpbj4iCiAgICBudmNmTmF0c1Nl" + - "cnZpY2VVUkw6ICJuYXRzOi8vPGdhdGV3YXktYWRkcmVzcz46NDIyMiIKICAgIG52Y3RTZXJ2aWNl" + - "VVJMOiAiaHR0cDovL3Rhc2tzLjxnYXRld2F5LWRvbWFpbj4iCiAgICBudmN0R3JwY1NlcnZpY2VV" + - "Ukw6ICJodHRwOi8vd29ya2VyLXRhc2tzLjxnYXRld2F5LWRvbWFpbj4iCiAgICBpbnZvY2F0aW9u" + - "U2VydmljZVVSTDogImh0dHA6Ly9pbnZvY2F0aW9uLjxnYXRld2F5LWRvbWFpbj4iCgpncnBjcHJv" + - "eHk6CiAgbnZjZkdycGNTZXJ2aWNlVVJMOiAiaHR0cDovL2FwaS5udmNmLnN2Yy5jbHVzdGVyLmxv" + - "Y2FsOjkwOTAiCgppbmdyZXNzOgogIGdhdGV3YXlBcGk6CiAgICBjb250cm9sbGVyTmFtZXNwYWNl" + - "OiBlbnZveS1nYXRld2F5LXN5c3RlbQogICAgZ2F0ZXdheXM6CiAgICAgIHNoYXJlZDoge25hbWU6" + - "IG52Y2YtZ2F0ZXdheSwgbmFtZXNwYWNlOiBlbnZveS1nYXRld2F5fQogICAgICBncnBjOiB7bmFt" + - "ZTogbnZjZi1nYXRld2F5LCBuYW1lc3BhY2U6IGVudm95LWdhdGV3YXl9CiAgICAgIG5hdHM6CiAg" + - "ICAgICAgbmFtZTogbnZjZi1nYXRld2F5CiAgICAgICAgbmFtZXNwYWNlOiBlbnZveS1nYXRld2F5" + - "CiAgICAgICAgbGlzdGVuZXJOYW1lOiBuYXRzCiAgICByb3V0ZXM6CiAgICAgIG52Y2ZBcGk6CiAg" + - "ICAgICAgZ3JwYzoKICAgICAgICAgIGVuYWJsZWQ6IHRydWUKICAgICAgICAgIGhvc3RuYW1lczog" + - "WyJ3b3JrZXItYXBpLjxnYXRld2F5LWRvbWFpbj4iXQogICAgICBudmN0QXBpOgogICAgICAgIGdy" + - "cGM6CiAgICAgICAgICBlbmFibGVkOiB0cnVlCiAgICAgICAgICBob3N0bmFtZXM6IFsid29ya2Vy" + - "LXRhc2tzLjxnYXRld2F5LWRvbWFpbj4iXQogICAgICBuYXRzOgogICAgICAgIGVuYWJsZWQ6IHRy" + - "dWUKCm9wZW5iYW86CiAgbWlncmF0aW9uczoKICAgIGlzc3VlckRpc2NvdmVyeToKICAgICAgZW5h" + - "YmxlZDogdHJ1ZQpgYGAKCmBgYHlhbWwKIyBkZXBsb3kvc3RhY2tzL252Y2YtY29tcHV0ZS1wbGFu" + - "ZS9lbnZpcm9ubWVudHMvPGVudj4ueWFtbApnbG9iYWw6CiAgbnZjYU9wZXJhdG9yOgogICAgc2Vs" + - "Zk1hbmFnZWQ6CiAgICAgIGljbXNTZXJ2aWNlVVJMOiAiaHR0cDovLzxnYXRld2F5LWFkZHJlc3M+" + - "IgogICAgICBpY21zU2VydmljZUhvc3RIZWFkZXJPdmVycmlkZTogInNpcy48Z2F0ZXdheS1kb21h" + - "aW4+IgogICAgICByZXZhbFNlcnZpY2VVUkw6ICJodHRwOi8vPGdhdGV3YXktYWRkcmVzcz4iCiAg" + - "ICAgIHJldmFsU2VydmljZUhvc3RIZWFkZXJPdmVycmlkZTogInJldmFsLjxnYXRld2F5LWRvbWFp" + - "bj4iCiAgICAgIG5hdHNVUkw6ICJuYXRzOi8vPGdhdGV3YXktYWRkcmVzcz46NDIyMiIKICAgICAg" + - "bmF0c0hvc3RPdmVycmlkZTogIm5hdHMuPGdhdGV3YXktZG9tYWluPiIKYGBgCgpQcmV2aWV3IGFu" + - "ZCBpbnN0YWxsIHRoZSBjb250cm9sIHBsYW5lIGFnYWluc3QgaXRzIGNvbnRleHQ6CgpgYGBiYXNo" + - "Cm1ha2UgLUMgZGVwbG95L3N0YWNrcy9zZWxmLW1hbmFnZWQgdGVtcGxhdGUgXAogIEhFTE1GSUxF" + - "X0VOVj08ZW52PiBcCiAgS1VCRUNPTkZJR19GSUxFPTxjb250cm9sLXBsYW5lLWt1YmVjb25maWc+" + - "CgptYWtlIC1DIGRlcGxveS9zdGFja3Mvc2VsZi1tYW5hZ2VkIGluc3RhbGwgXAogIEhFTE1GSUxF" + - "X0VOVj08ZW52PiBcCiAgS1VCRUNPTkZJR19GSUxFPTxjb250cm9sLXBsYW5lLWt1YmVjb25maWc+" + - "CmBgYAoKQmVmb3JlIHJlZ2lzdGVyaW5nIHRocm91Z2ggYSBiYXJlIEdhdGV3YXkgYWRkcmVzcywg" + - "Y3JlYXRlIG9yIHVwZGF0ZSB0aGUgQ0xJCmNvbmZpZyBwYXNzZWQgYXMgYE5WQ0ZfQ0xJX0NPTkZJ" + - "R2A6CgpgYGB5YW1sCmJhc2VfaHR0cF91cmw6ICJodHRwOi8vPGdhdGV3YXktYWRkcmVzcz4iCmlu" + - "dm9rZV91cmw6ICJodHRwOi8vPGdhdGV3YXktYWRkcmVzcz4iCmJhc2VfZ3JwY191cmw6ICI8Z2F0" + - "ZXdheS1hZGRyZXNzPjoxMDA4MSIKYXBpX2tleXNfc2VydmljZV91cmw6ICJodHRwOi8vPGdhdGV3" + - "YXktYWRkcmVzcz4iCmljbXNfdXJsOiAiaHR0cDovLzxnYXRld2F5LWFkZHJlc3M+IgphcGlfaG9z" + - "dDogImFwaS48Z2F0ZXdheS1kb21haW4+IgphcGlfa2V5c19ob3N0OiAiYXBpLWtleXMuPGdhdGV3" + - "YXktZG9tYWluPiIKaW52b2tlX2hvc3Q6ICJpbnZvY2F0aW9uLjxnYXRld2F5LWRvbWFpbj4iCmlj" + - "bXNfaG9zdDogInNpcy48Z2F0ZXdheS1kb21haW4+IgpgYGAKCkhvc3QgZmllbGRzIGNvbnRhaW4g" + - "aG9zdG5hbWVzIG9ubHksIHdpdGhvdXQgYSBVUkwgc2NoZW1lLiBgSUNNU19VUkxgIG1hcHMgb25s" + - "eQp0byB0aGUgcmVnaXN0cmF0aW9uIGNvbW1hbmQncyBgLS1pY21zLXVybGA7IGBpY21zX2hvc3Rg" + - "IGluIHRoZSBjb25maWcgc3VwcGxpZXMKdGhlIEdhdGV3YXkgSG9zdCBoZWFkZXIuIFRoZXJlIGlz" + - "IG5vIGAtLWljbXMtaG9zdGAgTWFrZSBvciBDTEkgZmxhZy4KClJlZ2lzdGVyIGZyb20gdGhlIGNv" + - "bXB1dGUgY29udGV4dCwgdGhlbiBpbnN0YWxsIHRoZSBjb21wdXRlIHBsYW5lOgoKYGBgYmFzaApt" + - "YWtlIC1DIGRlcGxveS9zdGFja3MvbnZjZi1jb21wdXRlLXBsYW5lIHJlZ2lzdGVyLWNsdXN0ZXIg" + - "XAogIENMVVNURVJfTkFNRT08Y2x1c3Rlci1uYW1lPiBcCiAgTkNBX0lEPTxuY2EtaWQ+IFwKICBD" + - "TFVTVEVSX1JFR0lPTj08cmVnaW9uPiBcCiAgSUNNU19VUkw9aHR0cDovLzxnYXRld2F5LWFkZHJl" + - "c3M+IFwKICBLVUJFQ09ORklHX0ZJTEU9PGNvbXB1dGUtcGxhbmUta3ViZWNvbmZpZz4gXAogIE5W" + - "Q0ZfQ0xJPTxwYXRoLXRvLW52Y2YtY2xpPiBcCiAgTlZDRl9DTElfQ09ORklHPTxwYXRoLXRvLW52" + - "Y2YtY2xpLWNvbmZpZz4KCm1ha2UgLUMgZGVwbG95L3N0YWNrcy9udmNmLWNvbXB1dGUtcGxhbmUg" + - "aW5zdGFsbCBcCiAgQ0xVU1RFUl9OQU1FPTxjbHVzdGVyLW5hbWU+IFwKICBIRUxNRklMRV9FTlY9" + - "PGVudj4gXAogIEtVQkVDT05GSUdfRklMRT08Y29tcHV0ZS1wbGFuZS1rdWJlY29uZmlnPgpgYGAK" + - "ClJlZ2lzdHJhdGlvbiBkaXNjb3ZlcnMgdGhlIE9JREMgaXNzdWVyIGFuZCBKV0tTIGZyb20gdGhl" + - "IGNvbXB1dGUga3ViZSBjb250ZXh0LgpJbiBhIG11bHRpLWNsdXN0ZXIgZGVwbG95bWVudCwgYEtV" + - "QkVDT05GSUdfRklMRWAgaXMgcmVxdWlyZWQgb24gYm90aApjb21wdXRlLXBsYW5lIGNvbW1hbmRz" + - "LiBJbiBhIHNhbWUtY2x1c3RlciBkZXBsb3ltZW50IGl0IG1heSBiZSBvbWl0dGVkIG9ubHkKd2hl" + - "biB0aGUgYW1iaWVudCBjb250ZXh0IGlzIGFscmVhZHkgdGhlIHRhcmdldCBjbHVzdGVyLgoKIyMg" + - "Q0xJIFByb2ZpbGUgRmxvdwoKUnVuIHRoZSBDTEkgY29udHJvbC1wbGFuZSBpbnN0YWxsIGZpcnN0" + - "LiBJdCBjcmVhdGVzIHRoZSBwcm9maWxlIGNvbnN1bWVkIGJ5CmNvbXB1dGUtcGxhbmUgcmVnaXN0" + - "cmF0aW9uOgoKYGBgYmFzaApudmNmLWNsaSAtLWNvbmZpZyA8Y29uZmlnPiBzZWxmLWhvc3RlZCBc" + - "CiAgLS1jb250cm9sLXBsYW5lLXN0YWNrIGRlcGxveS9zdGFja3Mvc2VsZi1tYW5hZ2VkIFwKICAt" + - "LWNvbXB1dGUtcGxhbmUtc3RhY2sgZGVwbG95L3N0YWNrcy9udmNmLWNvbXB1dGUtcGxhbmUgXAog" + - "IC0tZW52IDxlbnY+IFwKICAtLXBsYWluIFwKICAtLWNvbnRyb2wtcGxhbmUtY29udGV4dCA8Y29u" + - "dHJvbC1wbGFuZS1jb250ZXh0PiBcCiAgLS1jb21wdXRlLXBsYW5lLWNvbnRleHQgPGNvbXB1dGUt" + - "cGxhbmUtY29udGV4dD4gXAogIGluc3RhbGwgLS1jb250cm9sLXBsYW5lIFwKICAtLWNsdXN0ZXIt" + - "bmFtZSA8Y29udHJvbC1wbGFuZS1jbHVzdGVyLW5hbWU+IFwKICAtLXJlZ2lvbiA8cmVnaW9uPiBc" + - "CiAgLS1uY2EtaWQgPG5jYS1pZD4KCnRlc3QgLXMgZGVwbG95L3N0YWNrcy9zZWxmLW1hbmFnZWQv" + - "b3V0L2NvbnRyb2wtcGxhbmUtcHJvZmlsZS55YW1sCmBgYAoKVXNlIHRoZSBmdWxsIHBlcnNpc3Rl" + - "bnQgcHJlZml4IGZvciBib3RoIGNvbXB1dGUtcGxhbmUgY29tbWFuZHM6CgpgYGBiYXNoCm52Y2Yt" + - "Y2xpIC0tY29uZmlnIDxjb25maWc+IHNlbGYtaG9zdGVkIFwKICAtLWNvbnRyb2wtcGxhbmUtc3Rh" + - "Y2sgZGVwbG95L3N0YWNrcy9zZWxmLW1hbmFnZWQgXAogIC0tY29tcHV0ZS1wbGFuZS1zdGFjayBk" + - "ZXBsb3kvc3RhY2tzL252Y2YtY29tcHV0ZS1wbGFuZSBcCiAgLS1lbnYgPGVudj4gXAogIC0tcGxh" + - "aW4gXAogIGNvbXB1dGUtcGxhbmUgcmVnaXN0ZXIgXAogIC0tY29udHJvbC1wbGFuZS1wcm9maWxl" + - "IGRlcGxveS9zdGFja3Mvc2VsZi1tYW5hZ2VkL291dC9jb250cm9sLXBsYW5lLXByb2ZpbGUueWFt" + - "bCBcCiAgLS1jbHVzdGVyLW5hbWUgPGNvbXB1dGUtcGxhbmUtY2x1c3Rlci1uYW1lPiBcCiAgLS1r" + - "dWJlLWNvbnRleHQgPGNvbXB1dGUtcGxhbmUtY29udGV4dD4gXAogIC0tcmVnaW9uIDxyZWdpb24+" + - "IFwKICAtLW91dHB1dCBkZXBsb3kvc3RhY2tzL252Y2YtY29tcHV0ZS1wbGFuZS9vdXQvPGNvbXB1" + - "dGUtcGxhbmUtY2x1c3Rlci1uYW1lPi1yZWdpc3Rlci12YWx1ZXMueWFtbAoKbnZjZi1jbGkgLS1j" + - "b25maWcgPGNvbmZpZz4gc2VsZi1ob3N0ZWQgXAogIC0tY29udHJvbC1wbGFuZS1zdGFjayBkZXBs" + - "b3kvc3RhY2tzL3NlbGYtbWFuYWdlZCBcCiAgLS1jb21wdXRlLXBsYW5lLXN0YWNrIGRlcGxveS9z" + - "dGFja3MvbnZjZi1jb21wdXRlLXBsYW5lIFwKICAtLWVudiA8ZW52PiBcCiAgLS1wbGFpbiBcCiAg" + - "Y29tcHV0ZS1wbGFuZSBpbnN0YWxsIFwKICAtLXZhbHVlcyBkZXBsb3kvc3RhY2tzL252Y2YtY29t" + - "cHV0ZS1wbGFuZS9vdXQvPGNvbXB1dGUtcGxhbmUtY2x1c3Rlci1uYW1lPi1yZWdpc3Rlci12YWx1" + - "ZXMueWFtbCBcCiAgLS1rdWJlLWNvbnRleHQgPGNvbXB1dGUtcGxhbmUtY29udGV4dD4gXAogIC0t" + - "Y2x1c3Rlci1uYW1lIDxjb21wdXRlLXBsYW5lLWNsdXN0ZXItbmFtZT4KYGBgCgpSZWdpc3RyYXRp" + - "b24gc2VsZWN0cyB0aGUgcHJvZmlsZSdzIGluLWNsdXN0ZXIgb3IgY29tcHV0ZS1yZWFjaGFibGUg" + - "ZW5kcG9pbnRzCmZyb20gdGhlIGNvbXB1dGUgY29udGV4dCBhbmQgcHJvYmVzIGl0cyBKV0tTLiBE" + - "byBub3QgcmVwbGFjZSBwcm9maWxlIGVuZHBvaW50cwp3aXRoIGhhbmQtYXV0aG9yZWQgSGVsbWZp" + - "bGUgZW5kcG9pbnQgdmFsdWVzLgoKIyMgUHVsbCBTZWNyZXRzCgpDcmVhdGUgdGhlIGNvbnRyb2wt" + - "cGxhbmUgc2VjcmV0IGluIHRoZXNlIG5hbWVzcGFjZXMgb24gdGhlIGNvbnRyb2wtcGxhbmUKY29u" + - "dGV4dDoKCmBgYHRleHQKY2Fzc2FuZHJhLXN5c3RlbSBuYXRzLXN5c3RlbSBudmNmIGFwaS1rZXlz" + - "IGVzcyBzaXMgdmF1bHQtc3lzdGVtIGNlcnQtbWFuYWdlcgpgYGAKCk9uIHRoZSBjb21wdXRlIGNv" + - "bnRleHQsIGNyZWF0ZSB0aGUgc2VjcmV0IG9ubHkgaW4gYG52Y2Etb3BlcmF0b3JgIGFuZCByZWZl" + - "cmVuY2UKaXQgdGhyb3VnaCBgZ2xvYmFsLmltYWdlUHVsbFNlY3JldHNgIGluIHRoZSBjb21wdXRl" + - "LXBsYW5lIGVudmlyb25tZW50LiBUaGUgY2hhcnQKYW5kIG9wZXJhdG9yIHVzZSBpdCBpbiBgbnZj" + - "YS1vcGVyYXRvcmAgYW5kIG1pcnJvciBpdCB0byBgbnZjYS1zeXN0ZW1gLiBEbyBub3QgYWRkCmVp" + - "dGhlciBuYW1lc3BhY2UgdG8gdGhlIGNvbnRyb2wtcGxhbmUgbGlzdC4gRm9yIGNvbW1hbmRzIGFu" + - "ZCBwb2xpY3kgZXhhbXBsZXMsCnNlZSBbcHVsbC1zZWNyZXRzLm1kXShwdWxsLXNlY3JldHMubWQp" + - "LgoKIyMgVmVyaWZpY2F0aW9uCgpVc2UgdGhlIGV4cGxpY2l0IEdhdGV3YXkgbmFtZSBhbmQgbmFt" + - "ZXNwYWNlOgoKYGBgYmFzaAprdWJlY3RsIC0tY29udGV4dCA8Y29udHJvbC1wbGFuZS1jb250ZXh0" + - "PiBnZXQgZ2F0ZXdheSBudmNmLWdhdGV3YXkgXAogIC1uIGVudm95LWdhdGV3YXkgLW8gd2lkZQpr" + - "dWJlY3RsIC0tY29udGV4dCA8Y29udHJvbC1wbGFuZS1jb250ZXh0PiBnZXQgdGNwcm91dGUgLW4g" + - "ZW52b3ktZ2F0ZXdheQprdWJlY3RsIC0tY29udGV4dCA8Y29tcHV0ZS1wbGFuZS1jb250ZXh0PiBy" + - "b2xsb3V0IHN0YXR1cyBcCiAgZGVwbG95bWVudC9udmNhLW9wZXJhdG9yIC1uIG52Y2Etb3BlcmF0" + - "b3IgLS10aW1lb3V0PTEwbQprdWJlY3RsIC0tY29udGV4dCA8Y29tcHV0ZS1wbGFuZS1jb250ZXh0" + - "PiB3YWl0IFwKICBudmNmYmFja2VuZC88Y29tcHV0ZS1wbGFuZS1jbHVzdGVyLW5hbWU+IC1uIG52" + - "Y2Etb3BlcmF0b3IgXAogIC0tZm9yPWpzb25wYXRoPSd7LnN0YXR1cy5hZ2VudFN0YXR1c30nPWhl" + - "YWx0aHkgLS10aW1lb3V0PTEwbQprdWJlY3RsIC0tY29udGV4dCA8Y29tcHV0ZS1wbGFuZS1jb250" + - "ZXh0PiBnZXQgc2VjcmV0IDxwdWxsLXNlY3JldD4gLW4gbnZjYS1zeXN0ZW0KYGBgCgojIyBUZWFy" + - "ZG93bgoKRGVzdHJveSBhbmQgZGVyZWdpc3RlciBldmVyeSBjb21wdXRlIHBsYW5lIGJlZm9yZSB0" + - "aGUgY29udHJvbCBwbGFuZS4gQm90aApoYW5kb2ZmcyBjYW4gZGVzdHJveSB0aGUgY29udHJvbCBw" + - "bGFuZSwgc28gYXBwbHkgdGhpcyBwcmVmbGlnaHQgYmVmb3JlIGVpdGhlcgpvbmUuIFByZXNlcnZl" + - "IHRoZSBgY2VydC1tYW5hZ2VyYCBuYW1lc3BhY2UgYnkgZGVmYXVsdC4gTmFtZXNwYWNlIHByZXNl" + - "cnZhdGlvbgpkb2VzIG5vdCBwcmVzZXJ2ZSB0aGUgSGVsbSByZWxlYXNlLiBJZGVudGlmeSB3aGV0" + - "aGVyIGNlcnQtbWFuYWdlciBpcyBleHRlcm5hbC4KRm9yIGFuIGV4dGVybmFsIGluc3RhbGxhdGlv" + - "biwgcmVxdWlyZSBlZmZlY3RpdmUgYGNlcnRNYW5hZ2VyLmVuYWJsZWQ6IGZhbHNlYAphbmQgYWJv" + - "cnQgaWYgaXQgaXMgdHJ1ZS4gRm9yIGFuIGludGVuZGVkIHN0YWNrLW1hbmFnZWQgcmVsZWFzZSB3" + - "aXRoIGVmZmVjdGl2ZQpgY2VydE1hbmFnZXIuZW5hYmxlZDogdHJ1ZWAsIHZlcmlmeSBtYXRjaGlu" + - "ZyBzdGFjayBIZWxtIHJlbGVhc2UgbWV0YWRhdGEgYW5kCmFib3J0IG9uIG1pc3Npbmcgb3IgbWlz" + - "bWF0Y2hlZCBldmlkZW5jZS4gT25seSBwbGFuIG5hbWVzcGFjZSByZW1vdmFsIGFmdGVyCnZlcmlm" + - "eWluZyBuYW1lc3BhY2UgcHJvdmVuYW5jZSBhbmQgZ2V0dGluZyBleHBsaWNpdCBjb25maXJtYXRp" + - "b247IG90aGVyd2lzZQpkbyBub3QgZGVsZXRlIGl0LgoKRm9yIHRoZSBIZWxtZmlsZSB2YWx1ZXMg" + - "ZmxvdywgcmV0YWluIGVhY2ggcmVnaXN0cmF0aW9uIHZhbHVlcyBmaWxlIHVudGlsCmNsZWFudXAg" + - "aXMgdmVyaWZpZWQ6CgpgYGBiYXNoCm1ha2UgLUMgZGVwbG95L3N0YWNrcy9udmNmLWNvbXB1dGUt" + - "cGxhbmUgZGVzdHJveSBcCiAgQ0xVU1RFUl9OQU1FPTxjbHVzdGVyLW5hbWU+IFwKICBIRUxNRklM" + - "RV9FTlY9PGVudj4gXAogIEtVQkVDT05GSUdfRklMRT08Y29tcHV0ZS1wbGFuZS1rdWJlY29uZmln" + - "PgoKPG52Y2YtY2xpPiAtLWNvbmZpZyA8Y29uZmlnPiBjbHVzdGVyIGRlbGV0ZSBcCiAgLS1jbHVz" + - "dGVyLWlkIDxjbHVzdGVyLWlkLWZyb20tcmVnaXN0cmF0aW9uLXZhbHVlcz4gXAogIC0tbmNhLWlk" + - "IDxuY2EtaWQ+IFwKICAtLWlnbm9yZS1taXNzaW5nCmBgYAoKUmVhZCBgY2x1c3RlcklEYCBhbmQg" + - "YG5jYUlEYCBmcm9tCmBkZXBsb3kvc3RhY2tzL252Y2YtY29tcHV0ZS1wbGFuZS9yZWdpc3RyYXRp" + - "b24vPGNsdXN0ZXItbmFtZT4tcmVnaXN0ZXItdmFsdWVzLnlhbWxgLgpTaG93IHRoZSBleGFjdCBj" + - "bHVzdGVyIElEIGFuZCBnZXQgY29uZmlybWF0aW9uIGJlZm9yZSBgY2x1c3RlciBkZWxldGVgLiBS" + - "ZXBlYXQKY29tcHV0ZSBkZXN0cm95IGFuZCBkZXJlZ2lzdHJhdGlvbiBmb3IgZXZlcnkgY29tcHV0" + - "ZSBjbHVzdGVyLCB0aGVuIGRlc3Ryb3kgdGhlCmNvbnRyb2wgcGxhbmUuCgpgYGBiYXNoCktVQkVD" + - "T05GSUc9PGNvbnRyb2wtcGxhbmUta3ViZWNvbmZpZz4gXAptYWtlIC1DIGRlcGxveS9zdGFja3Mv" + - "c2VsZi1tYW5hZ2VkIGRlc3Ryb3kgXAogIEhFTE1GSUxFX0VOVj08ZW52PiBcCiAgS1VCRUNPTkZJ" + - "R19GSUxFPTxjb250cm9sLXBsYW5lLWt1YmVjb25maWc+CmBgYAoKQm90aCBgS1VCRUNPTkZJR2Ag" + - "YW5kIGBLVUJFQ09ORklHX0ZJTEVgIGFyZSByZXF1aXJlZCBvbiB0aGUgY29udHJvbC1wbGFuZQpk" + - "ZXN0cm95IGJlY2F1c2UgaXRzIG5hbWVzcGFjZSBjbGVhbnVwIHVzZXMgYW1iaWVudCBga3ViZWN0" + - "bGAuCgpGb3IgdGhlIENMSSBwcm9maWxlIGZsb3csIGtlZXAKYGRlcGxveS9zdGFja3MvbnZjZi1j" + - "b21wdXRlLXBsYW5lL291dC88Y2x1c3Rlci1uYW1lPi1yZWdpc3Rlci12YWx1ZXMueWFtbGAKdW50" + - "aWwgdGVhcmRvd24gY29tcGxldGVzIGJlY2F1c2UgYGRvd25gIHJlYWRzIGl0cyBjbHVzdGVyIElE" + - "LiBGaXJzdCBxdWVyeSB0aGUKbGl2ZSByZWdpc3RyYXRpb24gc2V0IHdpdGggdGhlIHNhbWUgY29t" + - "cGxldGUgcGVyc2lzdGVudCBwcmVmaXg6CgpgYGBiYXNoCm52Y2YtY2xpIC0tY29uZmlnIDxjb25m" + - "aWc+IHNlbGYtaG9zdGVkIFwKICAtLWNvbnRyb2wtcGxhbmUtc3RhY2sgZGVwbG95L3N0YWNrcy9z" + - "ZWxmLW1hbmFnZWQgXAogIC0tY29tcHV0ZS1wbGFuZS1zdGFjayBkZXBsb3kvc3RhY2tzL252Y2Yt" + - "Y29tcHV0ZS1wbGFuZSBcCiAgLS1lbnYgPGVudj4gXAogIC0tcGxhaW4gXAogIC0tY29udHJvbC1w" + - "bGFuZS1jb250ZXh0IDxjb250cm9sLXBsYW5lLWNvbnRleHQ+IFwKICAtLWNvbXB1dGUtcGxhbmUt" + - "Y29udGV4dCA8Y29tcHV0ZS1wbGFuZS1jb250ZXh0PiBcCiAgLS1pY21zLXVybCA8Y29tcHV0ZS1y" + - "ZWFjaGFibGUtaWNtcy11cmw+IFwKICBzdGF0dXMgXAogIC0tY2x1c3Rlci1uYW1lIDxjb21wdXRl" + - "LXBsYW5lLWNsdXN0ZXItbmFtZT4gXAogIC0tbmNhLWlkIDxuY2EtaWQ+CmBgYAoKU2hvdyB0aGUg" + - "cmVnaXN0ZXJlZCBjb21wdXRlLXBsYW5lIGxpc3QuIE5hbWVkLWNsdXN0ZXIgYGRvd24gLS1wbGFu" + - "LW9ubHlgIGRvZXMKbm90IHF1ZXJ5IElDTVMsIHNvIGl0IHByZXZpZXdzIG9ubHkgdGhhdCBjb21w" + - "dXRlIHBsYW5lIGFuZCBjYW5ub3Qgc2hvdyB0aGUKY29uZGl0aW9uYWwgY29udHJvbC1wbGFuZSBy" + - "ZW1vdmFsLiBJZiB0aGUgdGFyZ2V0IGlzIHRoZSBsYXN0IHJlZ2lzdGVyZWQKY2x1c3RlciwgcmVh" + - "bCBgZG93bmAgYWxzbyBkZXN0cm95cyB0aGUgY29udHJvbCBwbGFuZS4gR2V0IGV4cGxpY2l0IGNv" + - "bmZpcm1hdGlvbgpmb3IgYm90aCByZW1vdmFscyBiZWZvcmUgY29udGludWluZy4gVGhlbiBwcmV2" + - "aWV3IGFuZCBleGVjdXRlIHdpdGggdGhlIHNhbWUKcHJlZml4OgoKYGBgYmFzaApudmNmLWNsaSAt" + - "LWNvbmZpZyA8Y29uZmlnPiBzZWxmLWhvc3RlZCBcCiAgLS1jb250cm9sLXBsYW5lLXN0YWNrIGRl" + - "cGxveS9zdGFja3Mvc2VsZi1tYW5hZ2VkIFwKICAtLWNvbXB1dGUtcGxhbmUtc3RhY2sgZGVwbG95" + - "L3N0YWNrcy9udmNmLWNvbXB1dGUtcGxhbmUgXAogIC0tZW52IDxlbnY+IFwKICAtLXBsYWluIFwK" + - "ICAtLWNvbnRyb2wtcGxhbmUtY29udGV4dCA8Y29udHJvbC1wbGFuZS1jb250ZXh0PiBcCiAgLS1j" + - "b21wdXRlLXBsYW5lLWNvbnRleHQgPGNvbXB1dGUtcGxhbmUtY29udGV4dD4gXAogIC0taWNtcy11" + - "cmwgPGNvbXB1dGUtcmVhY2hhYmxlLWljbXMtdXJsPiBcCiAgZG93biAtLXBsYW4tb25seSBcCiAg" + - "LS1jbHVzdGVyLW5hbWUgPGNvbXB1dGUtcGxhbmUtY2x1c3Rlci1uYW1lPiBcCiAgLS1uY2EtaWQg" + - "PG5jYS1pZD4KCm52Y2YtY2xpIC0tY29uZmlnIDxjb25maWc+IHNlbGYtaG9zdGVkIFwKICAtLWNv" + - "bnRyb2wtcGxhbmUtc3RhY2sgZGVwbG95L3N0YWNrcy9zZWxmLW1hbmFnZWQgXAogIC0tY29tcHV0" + - "ZS1wbGFuZS1zdGFjayBkZXBsb3kvc3RhY2tzL252Y2YtY29tcHV0ZS1wbGFuZSBcCiAgLS1lbnYg" + - "PGVudj4gXAogIC0tcGxhaW4gXAogIC0tY29udHJvbC1wbGFuZS1jb250ZXh0IDxjb250cm9sLXBs" + - "YW5lLWNvbnRleHQ+IFwKICAtLWNvbXB1dGUtcGxhbmUtY29udGV4dCA8Y29tcHV0ZS1wbGFuZS1j" + - "b250ZXh0PiBcCiAgLS1pY21zLXVybCA8Y29tcHV0ZS1yZWFjaGFibGUtaWNtcy11cmw+IFwKICBk" + - "b3duIFwKICAtLWNsdXN0ZXItbmFtZSA8Y29tcHV0ZS1wbGFuZS1jbHVzdGVyLW5hbWU+IFwKICAt" + - "LW5jYS1pZCA8bmNhLWlkPgpgYGAKClJlcGVhdCBgZG93bmAgZm9yIGVhY2ggY29tcHV0ZSBjbHVz" + - "dGVyLiBFYWNoIHJ1biBkZXN0cm95cyB0aGF0IGNvbXB1dGUgcGxhbmUgYW5kCnVucmVnaXN0ZXJz" + - "IGl0cyBJQ01TIHJvdy4gSXQgcmVtb3ZlcyB0aGUgY29udHJvbCBwbGFuZSBvbmx5IGFmdGVyIG5v" + - "IGNsdXN0ZXIKcmVnaXN0cmF0aW9ucyByZW1haW4uClBLBwiWY7xZEjAAABIwAABQSwMEFAAIAAAA" + - "AAAhAAAAAAAAAAAAAAAAADsACQBkYXRhL252Y2Ytc2VsZi1tYW5hZ2VkLWluc3RhbGxhdGlvbi9y" + - "ZWZlcmVuY2VzL2RlYnVnZ2luZy5tZFVUBQABAKbOEiMgRGVidWdnaW5nIFJlZmVyZW5jZQoKUmVj" + - "aXBlcyBmb3IgZGlhZ25vc2luZyBhbmQgZml4aW5nIGNvbW1vbiBOVkNGIHNlbGYtbWFuYWdlZCBz" + - "dGFjayBmYWlsdXJlcy4KCiMjIFF1aWNrIFN0YXR1cyBDb21tYW5kcwoKYGBgYmFzaAojIEFsbCBw" + - "b2RzIGFjcm9zcyBhbGwgbmFtZXNwYWNlcwprdWJlY3RsIGdldCBwb2RzIC1BIC1vIHdpZGUKCiMg" + - "UG9kcyBpbiBhIHNwZWNpZmljIG5hbWVzcGFjZQprdWJlY3RsIGdldCBwb2RzIC1uIDxuYW1lc3Bh" + - "Y2U+CgojIEFsbCBoZWxtIHJlbGVhc2VzCmhlbG0gbGlzdCAtQQoKIyBSZWNlbnQgZXZlbnRzICht" + - "b3N0IHVzZWZ1bCBmb3IgZGlhZ25vc2luZyBmYWlsdXJlcykKa3ViZWN0bCBnZXQgZXZlbnRzIC1u" + - "IDxuYW1lc3BhY2U+IC0tc29ydC1ieT0nLmxhc3RUaW1lc3RhbXAnCgojIERlc2NyaWJlIGEgc3Bl" + - "Y2lmaWMgcG9kIChzaG93cyBldmVudHMsIGNvbmRpdGlvbnMsIHZvbHVtZXMpCmt1YmVjdGwgZGVz" + - "Y3JpYmUgcG9kIC1uIDxuYW1lc3BhY2U+IDxwb2QtbmFtZT4KYGBgCgojIyBGYWlsdXJlOiBJbWFn" + - "ZVB1bGxCYWNrT2ZmCgojIyMgU3ltcHRvbXMKCmBgYApOQU1FICAgICAgICAgICBSRUFEWSAgIFNU" + - "QVRVUyAgICAgICAgICAgICBSRVNUQVJUUyAgIEFHRQpjYXNzYW5kcmEtMCAgICAwLzEgICAgIElt" + - "YWdlUHVsbEJhY2tPZmYgICAwICAgICAgICAgIDVtCmBgYAoKRXZlbnRzIHNob3c6CmBgYApGYWls" + - "ZWQgdG8gcHVsbCBpbWFnZSAibnZjci5pby8uLi4vaW1hZ2U6dGFnIjogNDAxIFVuYXV0aG9yaXpl" + - "ZApgYGAKCiMjIyBEaWFnbm9zaXMKCmBgYGJhc2gKIyBDaGVjayB3aGF0IGltYWdlIGlzIGZhaWxp" + - "bmcKa3ViZWN0bCBkZXNjcmliZSBwb2QgLW4gPG5hbWVzcGFjZT4gPHBvZC1uYW1lPiB8IGdyZXAg" + - "LUE1ICJFdmVudHM6IgoKIyBDaGVjayBpZiBwdWxsIHNlY3JldCBleGlzdHMgaW4gdGhlIG5hbWVz" + - "cGFjZQprdWJlY3RsIGdldCBzZWNyZXQgbnZjci1jcmVkcyAtbiA8bmFtZXNwYWNlPgoKIyBDaGVj" + - "ayBpZiB0aGUgcG9kIHNwZWMgaGFzIGltYWdlUHVsbFNlY3JldHMKa3ViZWN0bCBnZXQgcG9kIC1u" + - "IDxuYW1lc3BhY2U+IDxwb2QtbmFtZT4gLW8ganNvbnBhdGg9J3suc3BlYy5pbWFnZVB1bGxTZWNy" + - "ZXRzfScKCiMgQ2hlY2sgaWYgdGhlIFNlcnZpY2VBY2NvdW50IGhhcyBpbWFnZVB1bGxTZWNyZXRz" + - "Cmt1YmVjdGwgZ2V0IHNhIDxzYS1uYW1lPiAtbiA8bmFtZXNwYWNlPiAtbyBqc29ucGF0aD0ney5p" + - "bWFnZVB1bGxTZWNyZXRzfScKYGBgCgojIyMgRml4ZXMKCjEuICoqU2VjcmV0IG1pc3NpbmcgaW4g" + - "bmFtZXNwYWNlKio6IENyZWF0ZSBpdAogICBgYGBiYXNoCiAgIGt1YmVjdGwgY3JlYXRlIHNlY3Jl" + - "dCBkb2NrZXItcmVnaXN0cnkgbnZjci1jcmVkcyBcCiAgICAgLS1kb2NrZXItc2VydmVyPW52Y3Iu" + - "aW8gXAogICAgIC0tZG9ja2VyLXVzZXJuYW1lPSckb2F1dGh0b2tlbicgXAogICAgIC0tZG9ja2Vy" + - "LXBhc3N3b3JkPSIkTkdDX0FQSV9LRVkiIFwKICAgICAtLW5hbWVzcGFjZT08bmFtZXNwYWNlPiBc" + - "CiAgICAgLS1kcnktcnVuPWNsaWVudCAtbyB5YW1sIHwga3ViZWN0bCBhcHBseSAtZiAtCiAgIGBg" + - "YAoKMi4gKipTZWNyZXQgZXhpc3RzIGJ1dCBwb2QgZG9lc24ndCByZWZlcmVuY2UgaXQqKjogVGhl" + - "IGNoYXJ0IG5lZWRzIGBpbWFnZVB1bGxTZWNyZXRzYCBjb25maWd1cmVkIHZpYSBoZWxtZmlsZSB2" + - "YWx1ZXMuIFNlZSBbcHVsbC1zZWNyZXRzLm1kXShwdWxsLXNlY3JldHMubWQpLgoKMy4gKipDaGFy" + - "dCBkb2Vzbid0IHN1cHBvcnQgaW1hZ2VQdWxsU2VjcmV0cyoqIChvcGVuYmFvLCBpbnZvY2F0aW9u" + - "LXNlcnZpY2UsIGVzcy1hcGksIG5vdGFyeS1zZXJ2aWNlKTogUGF0Y2ggU2VydmljZUFjY291bnRz" + - "IGFuZCByZXN0YXJ0IHBvZHMuIFNlZSBbcHVsbC1zZWNyZXRzLm1kXShwdWxsLXNlY3JldHMubWQp" + - "LgoKNC4gKipXcm9uZyBjcmVkZW50aWFscyBpbiBzZWNyZXQqKjogRGVsZXRlIGFuZCByZWNyZWF0" + - "ZQogICBgYGBiYXNoCiAgIGt1YmVjdGwgZGVsZXRlIHNlY3JldCBudmNyLWNyZWRzIC1uIDxuYW1l" + - "c3BhY2U+CiAgICMgUmVjcmVhdGUgd2l0aCBjb3JyZWN0IGNyZWRlbnRpYWxzCiAgIGBgYAoKIyMg" + - "RmFpbHVyZTogSW5pdDowLzEgU3R1Y2sgKFZhdWx0IEFnZW50KQoKIyMjIFN5bXB0b21zCgpTZXJ2" + - "aWNlIHBvZHMgc3R1Y2sgaW4gYEluaXQ6MC8xYCBmb3IgbWludXRlczoKYGBgCk5BTUUgICAgICAg" + - "ICAgICAgICAgICAgICAgICBSRUFEWSAgIFNUQVRVUyAgICAgUkVTVEFSVFMgICBBR0UKbnZjZi1h" + - "cGktN2Y0Yzc2Zjc4OC00NHZsdCAgMC8yICAgICBJbml0OjAvMSAgIDAgICAgICAgICAgMTBtCmBg" + - "YAoKIyMjIERpYWdub3NpcwoKVGhlIGluaXQgY29udGFpbmVyIGlzIHRoZSB2YXVsdC1hZ2VudC1p" + - "bml0IGluamVjdG9yIHdhaXRpbmcgZm9yIE9wZW5CYW8uCgpgYGBiYXNoCiMgQ2hlY2sgT3BlbkJh" + - "byBwb2RzCmt1YmVjdGwgZ2V0IHBvZHMgLW4gdmF1bHQtc3lzdGVtCgojIENoZWNrIGlmIE9wZW5C" + - "YW8gbWlncmF0aW9uIGpvYiByYW4Ka3ViZWN0bCBnZXQgam9icyAtbiB2YXVsdC1zeXN0ZW0KCiMg" + - "Q2hlY2sgT3BlbkJhbyBwb2QgbG9ncwprdWJlY3RsIGxvZ3MgLW4gdmF1bHQtc3lzdGVtIG9wZW5i" + - "YW8tc2VydmVyLTAgLWMgb3BlbmJhbwoKIyBDaGVjayBpbml0IGNvbnRhaW5lciBsb2dzIG9uIHRo" + - "ZSBzdHVjayBwb2QKa3ViZWN0bCBsb2dzIC1uIDxuYW1lc3BhY2U+IDxwb2QtbmFtZT4gLWMgdmF1" + - "bHQtYWdlbnQtaW5pdApgYGAKCiMjIyBGaXhlcwoKMS4gKipPcGVuQmFvIHBvZHMgbm90IHJ1bm5p" + - "bmcqKjogQ2hlY2sgdGhlaXIgZXZlbnRzIGZvciBpbWFnZSBwdWxsIGlzc3VlcywgcmVzb3VyY2Ug" + - "aXNzdWVzLCBldGMuCgoyLiAqKk9wZW5CYW8gbWlncmF0aW9uIGpvYiBkaWRuJ3QgcnVuKio6IFRo" + - "aXMgaGFwcGVucyB3aGVuIGBoZWxtZmlsZSBzeW5jYCB3YXMgaW50ZXJydXB0ZWQuIERlc3Ryb3kg" + - "YW5kIHJlLXN5bmMgb3BlbmJhbzoKICAgYGBgYmFzaAogICBIRUxNRklMRV9FTlY9PGVudj4gaGVs" + - "bWZpbGUgLS1zZWxlY3RvciBuYW1lPW9wZW5iYW8tc2VydmVyIGRlc3Ryb3kKICAga3ViZWN0bCBk" + - "ZWxldGUgbmFtZXNwYWNlIHZhdWx0LXN5c3RlbQogICBrdWJlY3RsIGNyZWF0ZSBuYW1lc3BhY2Ug" + - "dmF1bHQtc3lzdGVtCiAgICMgUmUtY3JlYXRlIHB1bGwgc2VjcmV0IGlmIG5lZWRlZAogICBIRUxN" + - "RklMRV9FTlY9PGVudj4gaGVsbWZpbGUgLS1zZWxlY3RvciBuYW1lPW9wZW5iYW8tc2VydmVyIHN5" + - "bmMKICAgYGBgCgozLiAqKk9wZW5CYW8gcG9kcyBydW5uaW5nIGJ1dCBub3QgaW5pdGlhbGl6ZWQq" + - "KjogQ2hlY2sgdW5zZWFsIHN0YXR1czoKICAgYGBgYmFzaAogICBrdWJlY3RsIGV4ZWMgLW4gdmF1" + - "bHQtc3lzdGVtIG9wZW5iYW8tc2VydmVyLTAgLWMgb3BlbmJhbyAtLSBiYW8gc3RhdHVzCiAgIGBg" + - "YAoKNC4gKipgdmF1bHQtYWdlbnQtaW5pdGAgbG9ncyBgYXV0aC9qd3QvbG9naW5gIC0+IGA0MDAg" + - "Li4uIG5vIGtub3duIGtleSBzdWNjZXNzZnVsbHkgdmFsaWRhdGVkIHRoZSB0b2tlbiBzaWduYXR1" + - "cmVgKioKICAgKGNvbW1vbiBvbiBBS1MsIGFuZCBvbiBhbnkgY2x1c3RlciB3aG9zZSBPSURDIGlz" + - "c3VlciBwdWJsaXNoZXMgYSByb3RhdGluZyBtdWx0aS1rZXkgSldLUyk6CiAgIHRoZSBPcGVuQmFv" + - "IGBhdXRoL2p3dGAgbWV0aG9kIHdhcyBjb25maWd1cmVkIHdpdGggYSBzaW5nbGUgc3RhdGljIG1v" + - "dW50ZWQgcHVibGljIGtleQogICAoYGp3dF92YWxpZGF0aW9uX3B1YmtleXNgKSBpbnN0ZWFkIG9m" + - "IHRoZSBpc3N1ZXIncyBsaXZlIEpXS1MsIHNvIGl0IGNhbm5vdCB2YWxpZGF0ZSB0aGUKICAgY2x1" + - "c3Rlci1zaWduZWQgU2VydmljZUFjY291bnQgdG9rZW5zIHRoZSB2YXVsdC1hZ2VudHMgcHJlc2Vu" + - "dC4gRXZlcnkgc2VydmljZSdzCiAgIGB2YXVsdC1hZ2VudC1pbml0YCB0aGVuIGxvb3BzIG9uIHRo" + - "YXQgNDAwIGFuZCB0aGUgcG9kIG5ldmVyIGxlYXZlcyBgSW5pdDowLzFgLiBUaGlzIGlzIHRoZQog" + - "ICBiZWhhdmlvciBvZiB0aGUgYmFzZSBkZWZhdWx0IGBvcGVuYmFvLm1pZ3JhdGlvbnMuaXNzdWVy" + - "RGlzY292ZXJ5LmVuYWJsZWQ6IGZhbHNlYDsgdGhlCiAgIG1pZ3JhdGlvbiBsb2cgc2hvd3MgYE9J" + - "REMgaXNzdWVyIGRpc2NvdmVyeSBpcyBkaXNhYmxlZC4gVXNpbmcgU2VydmljZUFjY291bnQgaXNz" + - "dWVyIGFuZAogICBtb3VudGVkIHB1YmxpYyBrZXkgZmFsbGJhY2tgLiBFbmFibGUgaXNzdWVyIGRp" + - "c2NvdmVyeSBzbyB0aGUgbWlncmF0aW9uIHVzZXMgdGhlIGxpdmUgSldLUywKICAgdGhlbiByZS1y" + - "dW4gaXQ6CiAgIGBgYGJhc2gKICAgIyBJbiB5b3VyIGVudiB2YWx1ZXMgKGUuZy4gZW52aXJvbm1l" + - "bnRzLzxlbnY+LnlhbWwpLCBzZXQ6CiAgICMgICBvcGVuYmFvOgogICAjICAgICBtaWdyYXRpb25z" + - "OgogICAjICAgICAgIGlzc3VlckRpc2NvdmVyeToKICAgIyAgICAgICAgIGVuYWJsZWQ6IHRydWUK" + - "ICAga3ViZWN0bCBkZWxldGUgam9iIC1uIHZhdWx0LXN5c3RlbSBvcGVuYmFvLXNlcnZlci1taWdy" + - "YXRpb25zCiAgIEhFTE1GSUxFX0VOVj08ZW52PiBoZWxtZmlsZSAtLXNlbGVjdG9yIG5hbWU9b3Bl" + - "bmJhby1zZXJ2ZXIgc3luYwogICBgYGAKICAgVGhlIG1pZ3JhdGlvbiBsb2cgc2hvdWxkIHRoZW4g" + - "c2hvdyBgUmVjZWl2ZWQgZGlzY292ZXJ5IGRvY3VtZW50IGZyb20KICAgLi4uLy53ZWxsLWtub3du" + - "L29wZW5pZC1jb25maWd1cmF0aW9uYCBhbmQgYEZpbmFsIE9wZW5CYW8gSldUIEpXS1MgVVJMIHNl" + - "dCB0bzoKICAgLi4uL29wZW5pZC92MS9qd2tzYCwgYW5kIHRoZSBzZXJ2aWNlIHBvZHMgYXV0aGVu" + - "dGljYXRlIGFuZCByZWFjaCBSZWFkeSB3aXRoaW4gfjEgbWluLgogICBBS1MgY2x1c3RlcnMgd2l0" + - "aCB0aGUgY2x1c3RlciBPSURDIGlzc3VlciBlbmFibGVkICh0aGUgYGFrcy1jbHVzdGVyYCBkZWZh" + - "dWx0KSBhbHdheXMgbmVlZAogICB0aGlzIGJlY2F1c2UgdGhlIHN0YXRpYy1wdWJrZXkgZmFsbGJh" + - "Y2sgY2Fubm90IG1hdGNoIHRoZSBpc3N1ZXIncyByb3RhdGluZyBzaWduaW5nIGtleXMuCgojIyBG" + - "YWlsdXJlOiBPT01LaWxsZWQgb24gQ2Fzc2FuZHJhCgojIyMgU3ltcHRvbXMKCmBgYApOQU1FICAg" + - "ICAgICAgIFJFQURZICAgU1RBVFVTICAgIFJFU1RBUlRTICAgQUdFCmNhc3NhbmRyYS0wICAgMC8x" + - "ICAgICBPT01LaWxsZWQgIDMgICAgICAgICAxMG0KYGBgCgojIyMgRGlhZ25vc2lzCgpgYGBiYXNo" + - "Cmt1YmVjdGwgZGVzY3JpYmUgcG9kIC1uIGNhc3NhbmRyYS1zeXN0ZW0gY2Fzc2FuZHJhLTAgfCBn" + - "cmVwIC1BMyAiTGFzdCBTdGF0ZSIKYGBgCgojIyMgRml4CgpPdmVycmlkZSBDYXNzYW5kcmEgcmVz" + - "b3VyY2VzIHZpYSBoZWxtZmlsZSB2YWx1ZXMuIFNlZSBFeGFtcGxlIDEgaW4KW2V4YW1wbGVzLm1k" + - "XSguLi9leGFtcGxlcy5tZCkuCgpgYGB5YW1sCi0gY2Fzc2FuZHJhOgogICAgcmVzb3VyY2VzOgog" + - "ICAgICBsaW1pdHM6CiAgICAgICAgY3B1OiAiOCIKICAgICAgICBtZW1vcnk6IDgxOTJNaQogICAg" + - "ICByZXF1ZXN0czoKICAgICAgICBjcHU6ICIyIgogICAgICAgIG1lbW9yeTogNDA5Nk1pCmBgYAoK" + - "Tm90ZTogYHJlc291cmNlUHJlc2V0YCBpcyBub3QgYXZhaWxhYmxlIGluIHRoZSBOVkNGIGNhc3Nh" + - "bmRyYSB3cmFwcGVyIGNoYXJ0LiBVc2UgZXhwbGljaXQgYHJlc291cmNlc2AuCgojIyBGYWlsdXJl" + - "OiBQb2RzIFN0dWNrIGluIFBlbmRpbmcKCiMjIyBTeW1wdG9tcwoKYGBgCk5BTUUgICAgICAgICAg" + - "UkVBRFkgICBTVEFUVVMgICAgUkVTVEFSVFMgICBBR0UKY2Fzc2FuZHJhLTAgICAwLzEgICAgIFBl" + - "bmRpbmcgICAwICAgICAgICAgIDEwbQpgYGAKCiMjIyBEaWFnbm9zaXMKCmBgYGJhc2gKIyBDaGVj" + - "ayBldmVudHMgZm9yIHNjaGVkdWxpbmcgZmFpbHVyZXMKa3ViZWN0bCBkZXNjcmliZSBwb2QgLW4g" + - "PG5hbWVzcGFjZT4gPHBvZC1uYW1lPgoKIyBDb21tb24gY2F1c2VzOgojIC0gIjAvMTIgbm9kZXMg" + - "YXJlIGF2YWlsYWJsZTogMTIgbm9kZShzKSBkaWRuJ3QgbWF0Y2ggUG9kJ3Mgbm9kZSBhZmZpbml0" + - "eSIKIyAtICIwLzEyIG5vZGVzIGFyZSBhdmFpbGFibGU6IDEyIEluc3VmZmljaWVudCBtZW1vcnki" + - "CiMgLSAicGVyc2lzdGVudHZvbHVtZWNsYWltIG5vdCBmb3VuZCIKYGBgCgojIyMgRml4ZXMKCjEu" + - "ICoqTm9kZSBzZWxlY3RvciBtaXNtYXRjaCoqOiBDaGVjayBgbm9kZVNlbGVjdG9yc2AgaW4gZW52" + - "aXJvbm1lbnQgZmlsZQogICBgYGBiYXNoCiAgIGt1YmVjdGwgZ2V0IG5vZGVzIC0tc2hvdy1sYWJl" + - "bHMgfCBncmVwIG52Y2YKICAgYGBgCgoyLiAqKlN0b3JhZ2UgY2xhc3Mgbm90IGZvdW5kKio6IENo" + - "ZWNrIHN0b3JhZ2UgY2xhc3MgZXhpc3RzCiAgIGBgYGJhc2gKICAga3ViZWN0bCBnZXQgc3RvcmFn" + - "ZWNsYXNzCiAgIGBgYAoKMy4gKipJbnN1ZmZpY2llbnQgcmVzb3VyY2VzKio6IENoZWNrIG5vZGUg" + - "Y2FwYWNpdHkKICAgYGBgYmFzaAogICBrdWJlY3RsIGRlc2NyaWJlIG5vZGUgPG5vZGUtbmFtZT4g" + - "fCBncmVwIC1BNSAiQWxsb2NhdGVkIHJlc291cmNlcyIKICAgYGBgCgojIyBGYWlsdXJlOiBIZWxt" + - "IFJlbGVhc2UgaW4gRmFpbGVkIFN0YXRlCgojIyMgU3ltcHRvbXMKCmBgYGJhc2gKaGVsbSBsaXN0" + - "IC1BCiMgU2hvd3MgcmVsZWFzZSB3aXRoIFNUQVRVUzogZmFpbGVkCmBgYAoKUmUtcnVubmluZyBg" + - "aGVsbWZpbGUgc3luY2AgYXBwZWFycyB0byBzdWNjZWVkIGJ1dCBzZXJ2aWNlcyBkb24ndCB3b3Jr" + - "IChtaWdyYXRpb25zIHNraXBwZWQpLgoKIyMjIERpYWdub3NpcwoKYGBgYmFzaApoZWxtIGhpc3Rv" + - "cnkgPHJlbGVhc2UtbmFtZT4gLW4gPG5hbWVzcGFjZT4KYGBgCgojIyMgRml4CgpNdXN0IGRlc3Ry" + - "b3kgdGhlIGZhaWxlZCByZWxlYXNlIGFuZCByZS1zeW5jIChub3QganVzdCBhcHBseSk6CgpgYGBi" + - "YXNoCkhFTE1GSUxFX0VOVj08ZW52PiBoZWxtZmlsZSAtLXNlbGVjdG9yIG5hbWU9PHJlbGVhc2U+" + - "IGRlc3Ryb3kKIyBJZiBuYW1lc3BhY2UgbmVlZHMgY2xlYW51cDoKa3ViZWN0bCBkZWxldGUgbmFt" + - "ZXNwYWNlIDxuYW1lc3BhY2U+Cmt1YmVjdGwgY3JlYXRlIG5hbWVzcGFjZSA8bmFtZXNwYWNlPgoj" + - "IFJlLWNyZWF0ZSBwdWxsIHNlY3JldCBpZiBuZWVkZWQKSEVMTUZJTEVfRU5WPTxlbnY+IGhlbG1m" + - "aWxlIC0tc2VsZWN0b3IgbmFtZT08cmVsZWFzZT4gc3luYwpgYGAKCiMjIEZhaWx1cmU6IEFjY291" + - "bnQgQm9vdHN0cmFwIEpvYiBGYWlsZWQKCiMjIyBTeW1wdG9tcwoKU2VydmljZXMgZGVwbG95IGJ1" + - "dCBmdW5jdGlvbnMgY2FuJ3QgYmUgY3JlYXRlZC4gRXZlbnRzIHNob3cgYm9vdHN0cmFwIGpvYiBm" + - "YWlsdXJlLgoKIyMjIERpYWdub3NpcwoKYGBgYmFzaAojIENoZWNrIGJvb3RzdHJhcCBqb2Igc3Rh" + - "dHVzCmt1YmVjdGwgZ2V0IGpvYnMgLW4gbnZjZgoKIyBHZXQgbG9ncyAoam9iIGF1dG8tZGVsZXRl" + - "cyBhZnRlciB+NSBtaW51dGVzKQprdWJlY3RsIGxvZ3Mgam9iL252Y2YtYXBpLWFjY291bnQtYm9v" + - "dHN0cmFwIC1uIG52Y2YKCiMgQ2hlY2sgQVBJIGxvZ3MKa3ViZWN0bCBsb2dzIC1uIG52Y2YgLWwg" + - "YXBwLmt1YmVybmV0ZXMuaW8vbmFtZT1udmNmLWFwaSAtLXRhaWw9MTAwCmBgYAoKIyMjIENvbW1v" + - "biBDYXVzZXMKCjEuICoqV3JvbmcgYmFzZTY0IGNyZWRlbnRpYWxzKio6IENyZWRlbnRpYWxzIGlu" + - "IGBzZWNyZXRzLzxlbnY+LXNlY3JldHMueWFtbGAgbXVzdCBiZSBgJG9hdXRodG9rZW46QVBJX0tF" + - "WWAgYmFzZTY0LWVuY29kZWQsIG5vdCBqdXN0IHRoZSBBUEkga2V5CiAgIGBgYGJhc2gKICAgIyBW" + - "ZXJpZnkgeW91ciBlbmNvZGVkIGNyZWRlbnRpYWwKICAgZWNobyAnWU9VUl9CQVNFNjRfU1RSSU5H" + - "JyB8IGJhc2U2NCAtZAogICAjIFNob3VsZCBvdXRwdXQ6ICRvYXV0aHRva2VuOm52YXBpLXh4eHh4" + - "CiAgIGBgYAoKMi4gKipSZWdpc3RyeSB1bnJlYWNoYWJsZSoqOiBBUEkgY2FuJ3QgcmVhY2ggdGhl" + - "IHJlZ2lzdHJ5IHNwZWNpZmllZCBpbiBgYWNjb3VudEJvb3RzdHJhcC5yZWdpc3RyeUNyZWRlbnRp" + - "YWxzYAoKIyMjIEZpeAoKRml4IGNyZWRlbnRpYWxzIGluIHNlY3JldHMgZmlsZSwgdGhlbiByZWNv" + - "dmVyIHNlcnZpY2VzIHdpdGhvdXQgZGVzdHJveWluZyBkZXBlbmRlbmNpZXM6CgpgYGBiYXNoCkhF" + - "TE1GSUxFX0VOVj08ZW52PiBoZWxtZmlsZSAtLXNlbGVjdG9yIHJlbGVhc2UtZ3JvdXA9c2Vydmlj" + - "ZXMgZGVzdHJveQprdWJlY3RsIGRlbGV0ZSBuYW1lc3BhY2UgbnZjZiBhcGkta2V5cyBlc3Mgc2lz" + - "IC0taWdub3JlLW5vdC1mb3VuZAprdWJlY3RsIGNyZWF0ZSBuYW1lc3BhY2UgbnZjZiAmJiBrdWJl" + - "Y3RsIGNyZWF0ZSBuYW1lc3BhY2UgYXBpLWtleXMgJiYgXAogIGt1YmVjdGwgY3JlYXRlIG5hbWVz" + - "cGFjZSBlc3MgJiYga3ViZWN0bCBjcmVhdGUgbmFtZXNwYWNlIHNpcwojIFJlLWNyZWF0ZSBwdWxs" + - "IHNlY3JldHMgaWYgbmVlZGVkCkhFTE1GSUxFX0VOVj08ZW52PiBoZWxtZmlsZSAtLXNlbGVjdG9y" + - "IHJlbGVhc2UtZ3JvdXA9c2VydmljZXMgc3luYwpgYGAKCiMjIEZhaWx1cmU6IE5WQ0EgQ2xlYW51" + - "cCBTdHVjayAoRmluYWxpemVycykKCiMjIyBTeW1wdG9tcwoKQ29tcHV0ZS1wbGFuZSBjbGVhbnVw" + - "IGhhbmdzLiBOYW1lc3BhY2VzCnN0dWNrIGluIGBUZXJtaW5hdGluZ2A6CgpgYGBiYXNoCmt1YmVj" + - "dGwgZ2V0IG5zCiMgbnZjYS1vcGVyYXRvciAgICBUZXJtaW5hdGluZyAgIDEwbQojIG52Y2YtYmFj" + - "a2VuZCAgICAgVGVybWluYXRpbmcgICAxMG0KYGBgCgojIyMgRml4CgpSdW4gdGhpcyBvbmx5IGFn" + - "YWluc3QgdGhlIGNvbXB1dGUgY29udGV4dCwgYWZ0ZXIgdGhlIG5vcm1hbCBjb21wdXRlLXBsYW5l" + - "CnRlYXJkb3duIGhhcyBmYWlsZWQuIFJlbW92ZSBmaW5hbGl6ZXJzIGZyb20gTlZDRkJhY2tlbmQg" + - "Y3VzdG9tIHJlc291cmNlcyBhbmQKZm9yY2UtZGVsZXRlIHN0dWNrIG5hbWVzcGFjZXM6CgpgYGBi" + - "YXNoCmV4cG9ydCBDT01QVVRFX0NPTlRFWFQ9PGNvbXB1dGUtcGxhbmUtY29udGV4dD4KCiMgUmVt" + - "b3ZlIGZpbmFsaXplcnMgZnJvbSBOVkNGQmFja2VuZCByZXNvdXJjZXMKa3ViZWN0bCAtLWNvbnRl" + - "eHQgIiRDT01QVVRFX0NPTlRFWFQiIGdldCBudmNmYmFja2VuZHMgLUEgLW8ganNvbiB8IFwKICBq" + - "cSAnLml0ZW1zW10gfCAubWV0YWRhdGEubmFtZXNwYWNlICsgIi8iICsgLm1ldGFkYXRhLm5hbWUn" + - "IC1yIHwgXAogIHhhcmdzIC1Je30gc2ggLWMgJ2NvbnRleHQ9IiQxIjsgbnM9IiR7MiUlLyp9Ijsg" + - "bmFtZT0iJHsyIyMqL30iOyBrdWJlY3RsIC0tY29udGV4dCAiJGNvbnRleHQiIHBhdGNoIG52Y2Zi" + - "YWNrZW5kICIkbmFtZSIgLW4gIiRucyIgLS10eXBlPW1lcmdlIC1wICJ7XCJtZXRhZGF0YVwiOntc" + - "ImZpbmFsaXplcnNcIjpbXX19IicgXyAiJENPTVBVVEVfQ09OVEVYVCIge30KCiMgRm9yY2UtZGVs" + - "ZXRlIHN0dWNrIG5hbWVzcGFjZXMgYnkgY2xlYXJpbmcgdGhlaXIgZmluYWxpemVycwpmb3IgbnMg" + - "aW4gbnZjYS1vcGVyYXRvciBudmNmLWJhY2tlbmQ7IGRvCiAga3ViZWN0bCAtLWNvbnRleHQgIiRD" + - "T01QVVRFX0NPTlRFWFQiIGdldCBuYW1lc3BhY2UgIiRucyIgLW8ganNvbiAyPi9kZXYvbnVsbCB8" + - "IFwKICAgIGpxICcuc3BlYy5maW5hbGl6ZXJzID0gW10nIHwgXAogICAga3ViZWN0bCAtLWNvbnRl" + - "eHQgIiRDT01QVVRFX0NPTlRFWFQiIHJlcGxhY2UgXAogICAgICAtLXJhdyAiL2FwaS92MS9uYW1l" + - "c3BhY2VzLyRucy9maW5hbGl6ZSIgLWYgLSAyPi9kZXYvbnVsbApkb25lCmBgYAoKIyMgRmFpbHVy" + - "ZTogTlZDQSBPcGVyYXRvciBNaXNzaW5nIG9yIE5vdCBSZWFkeQoKIyMjIFN5bXB0b21zCgpBZnRl" + - "ciBjb21wdXRlLXBsYW5lIGluc3RhbGwgY29tcGxldGVzLCBubyBgbnZjYS1vcGVyYXRvcmAgRGVw" + - "bG95bWVudCBleGlzdHMsIG9yCml0IGV4aXN0cyBidXQgcG9kcyBhcmUgbm90IHJlYWR5OgoKYGBg" + - "YmFzaAprdWJlY3RsIC0tY29udGV4dCA8Y29tcHV0ZS1wbGFuZS1jb250ZXh0PiBnZXQgZGVwbG95" + - "bWVudCBudmNhLW9wZXJhdG9yIFwKICAtbiBudmNhLW9wZXJhdG9yCmt1YmVjdGwgLS1jb250ZXh0" + - "IDxjb21wdXRlLXBsYW5lLWNvbnRleHQ+IGdldCBwb2RzIC1uIG52Y2Etb3BlcmF0b3IKYGBgCgoj" + - "IyMgRGlhZ25vc2lzIGFuZCBGaXhlcwoKRmlyc3QgaWRlbnRpZnkgd2hldGhlciB0aGUgaW5zdGFs" + - "bGF0aW9uIHVzZWQgdGhlIEhlbG1maWxlIHZhbHVlcyBmbG93IG9yIHRoZQpDTEkgcHJvZmlsZSBm" + - "bG93LiBSZS1ydW4gb25seSB0aGF0IGZsb3cncyByZWdpc3RyYXRpb24gYW5kIGluc3RhbGxhdGlv" + - "biBzdGVwcwpmcm9tIFtTcGxpdCBDb21wdXRlLVBsYW5lIEluc3RhbGxhdGlvbl0oY29tcHV0ZS1w" + - "bGFuZS1pbnN0YWxsYXRpb24ubWQpLiBEbyBub3QKc3Vic3RpdHV0ZSBvbmUgaGFuZG9mZiBmb3Ig" + - "dGhlIG90aGVyLgoKSWYgaW5zdGFsbGF0aW9uIHN1Y2NlZWRzIGJ1dCBwb2RzIHN0aWxsIGZhaWws" + - "IGluc3BlY3QgdGhlIGNvbXB1dGUgY29udGV4dDoKCmBgYGJhc2gKa3ViZWN0bCAtLWNvbnRleHQg" + - "PGNvbXB1dGUtcGxhbmUtY29udGV4dD4gZGVzY3JpYmUgZGVwbG95IG52Y2Etb3BlcmF0b3IgXAog" + - "IC1uIG52Y2Etb3BlcmF0b3IKa3ViZWN0bCAtLWNvbnRleHQgPGNvbXB1dGUtcGxhbmUtY29udGV4" + - "dD4gbG9ncyBkZXBsb3ltZW50L252Y2Etb3BlcmF0b3IgXAogIC1uIG52Y2Etb3BlcmF0b3IgLS10" + - "YWlsPTIwMAprdWJlY3RsIC0tY29udGV4dCA8Y29tcHV0ZS1wbGFuZS1jb250ZXh0PiBnZXQgbnZj" + - "ZmJhY2tlbmQgLW4gbnZjYS1vcGVyYXRvcgpgYGAKCkZvciBwcml2YXRlIHJlZ2lzdHJ5IGZhaWx1" + - "cmVzLCB2ZXJpZnkgdGhhdCB0aGUgcHVsbCBzZWNyZXQgZXhpc3RzIGluCmBudmNhLW9wZXJhdG9y" + - "YC4gVGhlIGNoYXJ0IGFuZCBvcGVyYXRvciBtaXJyb3IgaXQgdG8gYG52Y2Etc3lzdGVtYDsgZG8g" + - "bm90IHVzZSBhCmJyb2FkZXIgbWFudWFsIG5hbWVzcGFjZSBsb29wLiBTZWUKW3B1bGwtc2VjcmV0" + - "cy5tZF0ocHVsbC1zZWNyZXRzLm1kI2NvbXB1dGUtcGxhbmUtc2VjcmV0KS4KCiMjIEZhaWx1cmU6" + - "IEdhdGV3YXkgRW5kcG9pbnQgQ2hhbmdlZAoKIyMjIFN5bXB0b21zCgpSZXF1ZXN0cyB0aHJvdWdo" + - "IHRoZSBjb25maWd1cmVkIHJvdXRlIGRvbWFpbiBmYWlsIGFmdGVyIHRoZSBHYXRld2F5IG9yIGl0" + - "cyBsb2FkIGJhbGFuY2VyIGlzIHJlcGxhY2VkLiBUaGUgR2F0ZXdheSByZXBvcnRzIGEgbmV3IGVu" + - "ZHBvaW50LgoKIyMjIERpYWdub3NpcwoKYGBgYmFzaApHQVRFV0FZX0FERFI9JChrdWJlY3RsIC0t" + - "Y29udGV4dCA8Y29udHJvbC1wbGFuZS1jb250ZXh0PiBnZXQgZ2F0ZXdheSBcCiAgbnZjZi1nYXRl" + - "d2F5IC1uIGVudm95LWdhdGV3YXkgXAogIC1vIGpzb25wYXRoPSd7LnN0YXR1cy5hZGRyZXNzZXNb" + - "MF0udmFsdWV9JykKdGVzdCAtbiAiJEdBVEVXQVlfQUREUiIKZGlnICtzaG9ydCAiYXBpLjxkb21h" + + "ICAiZ3JvdW5kX3RydXRoIjogIlRoZSBhZ2VudCBjYXB0dXJlZCB0aGUgYmFzZWxpbmUgd2l0aCBo" + + "ZWxtZmlsZSB0ZW1wbGF0ZSwgdGhlbiBtb2RpZmllZCB0aGUgY2Fzc2FuZHJhIHJlbGVhc2Ugd2l0" + + "aCBpbmxpbmUgdmFsdWVzIHJlLWluY2x1ZGluZyBnbG9iYWwueWFtbC5nb3RtcGwgYW5kIHNlY3Jl" + + "dHMgaW4gdGhlIHZhbHVlcyBibG9jay4gSXQgd2FybmVkIGFib3V0IHRoZSBZQU1MIG1lcmdlIGdv" + + "dGNoYSBhbmQgcHJldmlld2VkIHRoZSBkaWZmIGJlZm9yZSBhcHBseWluZy4iLAogICAgImV4cGVj" + + "dGVkX2JlaGF2aW9yIjogWwogICAgICAiVGhlIGFnZW50IHJlYWQgdGhlIG52Y2Ytc2VsZi1tYW5h" + + "Z2VkLWluc3RhbGxhdGlvbiBTS0lMTC5tZCBiZWZvcmUgdGFraW5nIGFjdGlvbiIsCiAgICAgICJU" + + "aGUgYWdlbnQgY2FwdHVyZWQgYmFzZWxpbmUgd2l0aCAnaGVsbWZpbGUgLS1zZWxlY3RvciBuYW1l" + + "PWNhc3NhbmRyYSB0ZW1wbGF0ZSciLAogICAgICAiVGhlIGFnZW50IG1vZGlmaWVkIHRoZSByZWxl" + + "YXNlIHZhbHVlcyBibG9jayB0byBpbmNsdWRlIHJlc291cmNlIGxpbWl0cyB3aXRoIG1lbW9yeTog" + + "MTZHaSIsCiAgICAgICJUaGUgYWdlbnQgcmUtaW5jbHVkZWQgZ2xvYmFsLnlhbWwuZ290bXBsIGFu" + + "ZCBzZWNyZXRzIGZpbGUgaW4gdGhlIHZhbHVlczogYmxvY2sgKG5vdCBqdXN0IHRoZSBvdmVycmlk" + + "ZSBhbG9uZSkiLAogICAgICAiVGhlIGFnZW50IHdhcm5lZCBhYm91dCB0aGUgWUFNTCBtZXJnZSBn" + + "b3RjaGE6IHNwZWNpZnlpbmcgdmFsdWVzOiByZXBsYWNlcyB0aGUgdGVtcGxhdGUncyB2YWx1ZXMg" + + "bGlzdCBlbnRpcmVseSIsCiAgICAgICJUaGUgYWdlbnQgcHJldmlld2VkIHRoZSBjaGFuZ2Ugd2l0" + + "aCBoZWxtZmlsZSB0ZW1wbGF0ZSBhbmQgZGlmZiBiZWZvcmUgYXBwbHlpbmcgd2l0aCBzeW5jIgog" + + "ICAgXQogIH0sCiAgewogICAgImlkIjogIlM2LXNlbGVjdGl2ZS1zeW5jLWRlcGVuZGVuY2llcyIs" + + "CiAgICAicXVlc3Rpb24iOiAiRGVwbG95IG9ubHkgdGhlIE5WQ0YgZGVwZW5kZW5jaWVzIC0tIE5B" + + "VFMsIENhc3NhbmRyYSwgYW5kIE9wZW5CYW8gLS0gZm9yIHRlc3RpbmciLAogICAgImV4cGVjdGVk" + + "X3NraWxsIjogIm52Y2Ytc2VsZi1tYW5hZ2VkLWluc3RhbGxhdGlvbiIsCiAgICAiZ3JvdW5kX3Ry" + + "dXRoIjogIlRoZSBhZ2VudCB1c2VkIHRoZSBoZWxtZmlsZSBzZWxlY3RvciB0byBkZXBsb3kgb25s" + + "eSB0aGUgZGVwZW5kZW5jaWVzIHJlbGVhc2UgZ3JvdXAsIHRoZW4gdmVyaWZpZWQgcG9kcyBpbiB0" + + "aGUgZGVwZW5kZW5jeSBuYW1lc3BhY2VzLiIsCiAgICAiZXhwZWN0ZWRfYmVoYXZpb3IiOiBbCiAg" + + "ICAgICJUaGUgYWdlbnQgcmVhZCB0aGUgbnZjZi1zZWxmLW1hbmFnZWQtaW5zdGFsbGF0aW9uIFNL" + + "SUxMLm1kIGJlZm9yZSB0YWtpbmcgYWN0aW9uIiwKICAgICAgIlRoZSBhZ2VudCB1c2VkICdoZWxt" + + "ZmlsZSAtLXNlbGVjdG9yIHJlbGVhc2UtZ3JvdXA9ZGVwZW5kZW5jaWVzIHN5bmMnIHRvIGRlcGxv" + + "eSBvbmx5IGRlcGVuZGVuY2llcyIsCiAgICAgICJUaGUgYWdlbnQgdmVyaWZpZWQgcG9kcyBpbiBk" + + "ZXBlbmRlbmN5IG5hbWVzcGFjZXMgKG5hdHMtc3lzdGVtLCBjYXNzYW5kcmEtc3lzdGVtLCB2YXVs" + + "dC1zeXN0ZW0pIiwKICAgICAgIlRoZSBhZ2VudCBwcm92aWRlZCB0aGUgc2VsZWN0b3IgcmVmZXJl" + + "bmNlIGZvciB0YXJnZXRpbmcgb3RoZXIgcmVsZWFzZSBncm91cHMiCiAgICBdCiAgfSwKICB7CiAg" + + "ICAiaWQiOiAiUzctZGVidWctaW1hZ2VwdWxsYmFja29mZiIsCiAgICAicXVlc3Rpb24iOiAiQ2Fz" + + "c2FuZHJhIHBvZHMgYXJlIGluIEltYWdlUHVsbEJhY2tPZmYgd2l0aCA0MDEgVW5hdXRob3JpemVk" + + "IiwKICAgICJleHBlY3RlZF9za2lsbCI6ICJudmNmLXNlbGYtbWFuYWdlZC1pbnN0YWxsYXRpb24i" + + "LAogICAgImdyb3VuZF90cnV0aCI6ICJUaGUgYWdlbnQgcmVhZCB0aGUgZGVidWdnaW5nIHJlZmVy" + + "ZW5jZSBhbmQgcmFuIGRpYWdub3N0aWMgY29tbWFuZHMgdG8gaWRlbnRpZnkgdGhlIHJvb3QgY2F1" + + "c2U6IGRlc2NyaWJlZCB0aGUgcG9kLCBjaGVja2VkIGZvciBwdWxsIHNlY3JldHMsIGNoZWNrZWQg" + + "aW1hZ2VQdWxsU2VjcmV0cyBvbiB0aGUgcG9kIHNwZWMgYW5kIHNlcnZpY2UgYWNjb3VudC4gSXQg" + + "aWRlbnRpZmllZCB0aGUgaXNzdWUgKG1pc3Npbmcgc2VjcmV0LCB3cm9uZyBjcmVkZW50aWFscywg" + + "b3IgbWlzc2luZyBpbWFnZVB1bGxTZWNyZXRzKSBhbmQgcHJvdmlkZWQgdGhlIGNvcnJlY3QgZml4" + + "LiIsCiAgICAiZXhwZWN0ZWRfYmVoYXZpb3IiOiBbCiAgICAgICJUaGUgYWdlbnQgcmVhZCB0aGUg" + + "bnZjZi1zZWxmLW1hbmFnZWQtaW5zdGFsbGF0aW9uIFNLSUxMLm1kIGFuZCByZWZlcmVuY2VzL2Rl" + + "YnVnZ2luZy5tZCIsCiAgICAgICJUaGUgYWdlbnQgcmFuICdrdWJlY3RsIGRlc2NyaWJlIHBvZCcg" + + "dG8gc2VlIHRoZSBJbWFnZVB1bGxCYWNrT2ZmIGV2ZW50cyIsCiAgICAgICJUaGUgYWdlbnQgY2hl" + + "Y2tlZCBmb3IgcHVsbCBzZWNyZXRzIGluIHRoZSBjYXNzYW5kcmEtc3lzdGVtIG5hbWVzcGFjZSIs" + + "CiAgICAgICJUaGUgYWdlbnQgY2hlY2tlZCBpbWFnZVB1bGxTZWNyZXRzIG9uIHRoZSBwb2Qgc3Bl" + + "YyBhbmQvb3Igc2VydmljZSBhY2NvdW50IiwKICAgICAgIlRoZSBhZ2VudCBpZGVudGlmaWVkIHRo" + + "ZSByb290IGNhdXNlIGFuZCBwcm92aWRlZCBhIHNwZWNpZmljIGZpeCIKICAgIF0KICB9LAogIHsK" + + "ICAgICJpZCI6ICJTOS1yZW1vdGUtZWtzLXJvdXRpbmctYW5kLXNlY3JldHMiLAogICAgInF1ZXN0" + + "aW9uIjogIkNvbmZpZ3VyZSBhIHJlbW90ZSBFS1MgY29tcHV0ZSBjbHVzdGVyIHRvIHJlYWNoIG15" + + "IE5WQ0YgY29udHJvbCBwbGFuZSB0aHJvdWdoIGl0cyBFbnZveSBHYXRld2F5LCBpbmNsdWRpbmcg" + + "TkFUUyBhbmQgcHJpdmF0ZS1yZWdpc3RyeSBwdWxsIHNlY3JldHMuIiwKICAgICJleHBlY3RlZF9z" + + "a2lsbCI6ICJudmNmLXNlbGYtbWFuYWdlZC1pbnN0YWxsYXRpb24iLAogICAgImdyb3VuZF90cnV0" + + "aCI6ICJUaGUgYWdlbnQgY29uZmlndXJlZCB0aGUgY29udHJvbCBwbGFuZSB0byB1c2UgdGhlIEVu" + + "dm95IEdhdGV3YXkgY29udHJvbGxlciBpbiBlbnZveS1nYXRld2F5LXN5c3RlbSBhbmQgR2F0ZXdh" + + "eS9udmNmLWdhdGV3YXkgaW4gZW52b3ktZ2F0ZXdheSwgc2V0IGFsbCBzaXggcmVtb3RlIHdvcmtl" + + "ciBlbmRwb2ludHMgYW5kIHRoZSBncnBjLXByb3h5IGxvY2FsIG92ZXJyaWRlLCBlbmFibGVkIE5W" + + "Q0YgYW5kIE5WQ1QgZ1JQQyByb3V0ZXMgcGx1cyBOQVRTLCBhbmQgZW5hYmxlZCBPcGVuQmFvIGlz" + + "c3VlciBkaXNjb3ZlcnkuIEl0IGNvbmZpZ3VyZWQgdGhlIGJhcmUtR2F0ZXdheSBDTEkgVVJMIGFu" + + "ZCBIb3N0IGZpZWxkcyBpbmNsdWRpbmcgaWNtc19ob3N0LCBwbHVzIHRoZSBjb21wdXRlLXBsYW5l" + + "IElDTVMsIFJlVmFsLCBhbmQgTkFUUyBleHRlcm5hbCBVUkxzIGFuZCBob3N0IG92ZXJyaWRlcy4g" + + "SXQgY3JlYXRlZCB0aGUgcHVsbCBzZWNyZXQgaW4gYWxsIGNvbnRyb2wtcGxhbmUgbmFtZXNwYWNl" + + "cyBpbmNsdWRpbmcgY2VydC1tYW5hZ2VyLCBidXQgb25seSBpbiBudmNhLW9wZXJhdG9yIG9uIHRo" + + "ZSBjb21wdXRlIGNsdXN0ZXI7IHRoZSBjaGFydCBhbmQgb3BlcmF0b3IgbWlycm9yIGl0IHRvIG52" + + "Y2Etc3lzdGVtLiIsCiAgICAiZXhwZWN0ZWRfYmVoYXZpb3IiOiBbCiAgICAgICJUaGUgYWdlbnQg" + + "cmVhZCB0aGUgbnZjZi1zZWxmLW1hbmFnZWQtaW5zdGFsbGF0aW9uIFNLSUxMLm1kIGJlZm9yZSB0" + + "YWtpbmcgYWN0aW9uIiwKICAgICAgIlRoZSBhZ2VudCBzZXQgaW5ncmVzcy5nYXRld2F5QXBpLmNv" + + "bnRyb2xsZXJOYW1lc3BhY2UgdG8gZW52b3ktZ2F0ZXdheS1zeXN0ZW0iLAogICAgICAiVGhlIGFn" + + "ZW50IHNldCBzaGFyZWQsIGdycGMsIGFuZCBuYXRzIEdhdGV3YXkgcmVmZXJlbmNlcyB0byBuYW1l" + + "IG52Y2YtZ2F0ZXdheSBhbmQgbmFtZXNwYWNlIGVudm95LWdhdGV3YXkiLAogICAgICAiVGhlIGFn" + + "ZW50IHNldCBnbG9iYWwud29ya2VyRW5kcG9pbnRzLm52Y2ZTZXJ2aWNlVVJMLCBudmNmR3JwY1Nl" + + "cnZpY2VVUkwsIG52Y2ZOYXRzU2VydmljZVVSTCwgbnZjdFNlcnZpY2VVUkwsIG52Y3RHcnBjU2Vy" + + "dmljZVVSTCwgYW5kIGludm9jYXRpb25TZXJ2aWNlVVJMIiwKICAgICAgIlRoZSBhZ2VudCBzZXQg" + + "Z3JwY3Byb3h5Lm52Y2ZHcnBjU2VydmljZVVSTCB0byB0aGUgY29udHJvbC1wbGFuZS1sb2NhbCBB" + + "UEkgZ1JQQyBzZXJ2aWNlIiwKICAgICAgIlRoZSBhZ2VudCBlbmFibGVkIGJvdGggaW5ncmVzcy5n" + + "YXRld2F5QXBpLnJvdXRlcy5udmNmQXBpLmdycGMgYW5kIG52Y3RBcGkuZ3JwYyB3aXRoIHdvcmtl" + + "ci1hcGkgYW5kIHdvcmtlci10YXNrcyBob3N0bmFtZXMiLAogICAgICAiVGhlIGFnZW50IGV4cGxp" + + "Y2l0bHkgc2V0IGluZ3Jlc3MuZ2F0ZXdheUFwaS5yb3V0ZXMubmF0cy5lbmFibGVkIHRvIHRydWUi" + + "LAogICAgICAiVGhlIGFnZW50IHNldCBvcGVuYmFvLm1pZ3JhdGlvbnMuaXNzdWVyRGlzY292ZXJ5" + + "LmVuYWJsZWQgdG8gdHJ1ZSIsCiAgICAgICJUaGUgYWdlbnQgY29uZmlndXJlZCB0aGUgYmFyZS1H" + + "YXRld2F5IENMSSBVUkwgYW5kIEhvc3QgZmllbGRzLCBpbmNsdWRpbmcgc2NoZW1lLWxlc3MgaWNt" + + "c19ob3N0IiwKICAgICAgIlRoZSBhZ2VudCBjb25maWd1cmVkIGNvbXB1dGUtcGxhbmUgaWNtc1Nl" + + "cnZpY2VVUkwsIGljbXNTZXJ2aWNlSG9zdEhlYWRlck92ZXJyaWRlLCByZXZhbFNlcnZpY2VVUkws" + + "IHJldmFsU2VydmljZUhvc3RIZWFkZXJPdmVycmlkZSwgbmF0c1VSTCwgYW5kIG5hdHNIb3N0T3Zl" + + "cnJpZGUiLAogICAgICAiVGhlIGNvbnRyb2wtcGxhbmUgcHVsbC1zZWNyZXQgbmFtZXNwYWNlIGxp" + + "c3QgaW5jbHVkZWQgY2VydC1tYW5hZ2VyIiwKICAgICAgIlRoZSBjb21wdXRlLXBsYW5lIHNlY3Jl" + + "dCB3YXMgY3JlYXRlZCBvbmx5IGluIG52Y2Etb3BlcmF0b3IgYW5kIG1pcnJvcmVkIGJ5IHRoZSBj" + + "aGFydCBhbmQgb3BlcmF0b3IgdG8gbnZjYS1zeXN0ZW0iCiAgICBdCiAgfSwKICB7CiAgICAiaWQi" + + "OiAiRzExLXNwbGl0LXRlYXJkb3duIiwKICAgICJxdWVzdGlvbiI6ICJUZWFyIGRvd24gbXkgc3Bs" + + "aXQgY29udHJvbC1wbGFuZSBhbmQgY29tcHV0ZS1wbGFuZSBkZXBsb3ltZW50IHNhZmVseS4gU2hv" + + "dyBib3RoIHRoZSBIZWxtZmlsZSB2YWx1ZXMgYW5kIENMSSBwcm9maWxlIHZhcmlhbnRzLiIsCiAg" + + "ICAiZXhwZWN0ZWRfc2tpbGwiOiAibnZjZi1zZWxmLW1hbmFnZWQtaW5zdGFsbGF0aW9uIiwKICAg" + + "ICJncm91bmRfdHJ1dGgiOiAiVGhlIEhlbG1maWxlIGZsb3cgZGVzdHJveWVkIGFuZCBjb25maXJt" + + "ZWQgZGVyZWdpc3RyYXRpb24gb2YgZXZlcnkgY29tcHV0ZSBjbHVzdGVyIGJlZm9yZSBkZXN0cm95" + + "aW5nIHRoZSBjb250cm9sIHBsYW5lIGFuZCBwYXNzZWQgYm90aCBjb250cm9sLXBsYW5lIGt1YmVj" + + "b25maWcgZm9ybXMuIEJlZm9yZSBlaXRoZXIgaGFuZG9mZiBjb3VsZCBkZXN0cm95IHRoZSBjb250" + + "cm9sIHBsYW5lLCBib3RoIHRlYXJkb3duIGZsb3dzIHdhcm5lZCB0aGF0IG5hbWVzcGFjZSBwcmVz" + + "ZXJ2YXRpb24gZG9lcyBub3QgcHJlc2VydmUgdGhlIEhlbG0gcmVsZWFzZSwgcmVxdWlyZWQgZWZm" + + "ZWN0aXZlIGNlcnRNYW5hZ2VyLmVuYWJsZWQ6IGZhbHNlIGZvciBhbiBleHRlcm5hbCBpbnN0YWxs" + + "YXRpb24gYW5kIGFib3J0ZWQgaWYgdHJ1ZSwgYW5kIHZlcmlmaWVkIG1hdGNoaW5nIHJlbGVhc2Ug" + + "b3duZXJzaGlwIGZvciBhbiBpbnRlbmRlZCBzdGFjay1tYW5hZ2VkIHJlbGVhc2UsIGFib3J0aW5n" + + "IG9uIG1pc3Npbmcgb3IgbWlzbWF0Y2hlZCBldmlkZW5jZS4gVGhleSBwcmVzZXJ2ZWQgdGhlIG5h" + + "bWVzcGFjZSBieSBkZWZhdWx0IGFuZCBkaWQgbm90IGRlbGV0ZSBpdCB3aXRob3V0IG5hbWVzcGFj" + + "ZSBwcm92ZW5hbmNlIGFuZCBleHBsaWNpdCBjb25maXJtYXRpb24uIFRoZSBDTEkgZmxvdyByZXRh" + + "aW5lZCB0aGUgZ2VuZXJhdGVkIHJlZ2lzdHJhdGlvbiB2YWx1ZXMsIHVzZWQgdGhlIGZ1bGwtcHJl" + + "Zml4IHN0YXR1cyBjb21tYW5kIHRvIGluc3BlY3QgbGl2ZSByZWdpc3RyYXRpb25zLCBzdGF0ZWQg" + + "dGhhdCBuYW1lZC1jbHVzdGVyIHBsYW4tb25seSBkb2VzIG5vdCBxdWVyeSBJQ01TIGFuZCBjYW5u" + + "b3QgcHJlZGljdCBjb25kaXRpb25hbCBjb250cm9sLXBsYW5lIHJlbW92YWwsIGFuZCBnb3QgZXhw" + + "bGljaXQgY29uZmlybWF0aW9uIHdoZW4gdGhlIHRhcmdldCB3YXMgdGhlIGxhc3QgcmVnaXN0ZXJl" + + "ZCBjbHVzdGVyLiBJdCB0aGVuIHByZXZpZXdlZCBhbmQgcmFuIGRvd24gd2l0aCB0aGUgZnVsbCBw" + + "ZXJzaXN0ZW50IHByZWZpeCwgcmVtb3ZpbmcgdGhlIGNvbnRyb2wgcGxhbmUgb25seSBhZnRlciB0" + + "aGUgbGFzdCByZWdpc3RyYXRpb24gd2FzIGdvbmUuIiwKICAgICJleHBlY3RlZF9iZWhhdmlvciI6" + + "IFsKICAgICAgIlRoZSBhZ2VudCByZWFkIHRoZSBudmNmLXNlbGYtbWFuYWdlZC1pbnN0YWxsYXRp" + + "b24gU0tJTEwubWQgYmVmb3JlIHRha2luZyBhY3Rpb24iLAogICAgICAiRm9yIGV2ZXJ5IGNvbXB1" + + "dGUgY2x1c3RlciwgdGhlIEhlbG1maWxlIGZsb3cgcmFuIHRoZSBjb21wdXRlLXBsYW5lIE1ha2Vm" + + "aWxlIGRlc3Ryb3kgdGFyZ2V0IHdpdGggaXRzIGNvbXB1dGUga3ViZWNvbmZpZyIsCiAgICAgICJB" + + "ZnRlciBjb25maXJtYXRpb24sIHRoZSBIZWxtZmlsZSBmbG93IHJhbiBjbHVzdGVyIGRlbGV0ZSB3" + + "aXRoIGNsdXN0ZXJJRCBhbmQgbmNhSUQgYmVmb3JlIGNvbnRyb2wtcGxhbmUgZGVzdHJ1Y3Rpb24i" + + "LAogICAgICAiQmVmb3JlIGVpdGhlciBoYW5kb2ZmIGNvdWxkIGRlc3Ryb3kgdGhlIGNvbnRyb2wg" + + "cGxhbmUsIGJvdGggdGVhcmRvd24gZmxvd3Mgd2FybmVkIHRoYXQgbmFtZXNwYWNlIHByZXNlcnZh" + + "dGlvbiBkb2VzIG5vdCBwcmVzZXJ2ZSB0aGUgSGVsbSByZWxlYXNlLCByZXF1aXJlZCBlZmZlY3Rp" + + "dmUgY2VydE1hbmFnZXIuZW5hYmxlZDogZmFsc2UgZm9yIGFuIGV4dGVybmFsIGluc3RhbGxhdGlv" + + "biBhbmQgYWJvcnRlZCBpZiB0cnVlLCBhbmQgdmVyaWZpZWQgaW50ZW5kZWQgc3RhY2sgb3duZXJz" + + "aGlwIHdoZW4gZW5hYmxlZCwgYWJvcnRpbmcgb24gbWlzc2luZyBvciBtaXNtYXRjaGVkIGV2aWRl" + + "bmNlIiwKICAgICAgIkJvdGggdGVhcmRvd24gZmxvd3MgcHJlc2VydmVkIHRoZSBjZXJ0LW1hbmFn" + + "ZXIgbmFtZXNwYWNlIGJ5IGRlZmF1bHQgYW5kIGRpZCBub3QgZGVsZXRlIGl0IHdpdGhvdXQgbmFt" + + "ZXNwYWNlIHByb3ZlbmFuY2UgYW5kIGV4cGxpY2l0IGNvbmZpcm1hdGlvbiIsCiAgICAgICJUaGUg" + + "SGVsbWZpbGUgZmxvdyByYW4gY29udHJvbC1wbGFuZSBNYWtlZmlsZSBkZXN0cm95IHdpdGggYm90" + + "aCBLVUJFQ09ORklHIGFuZCBLVUJFQ09ORklHX0ZJTEUiLAogICAgICAiVGhlIENMSSBmbG93IHJl" + + "dGFpbmVkIG91dC88Y2x1c3Rlci1uYW1lPi1yZWdpc3Rlci12YWx1ZXMueWFtbCB1bnRpbCB0ZWFy" + + "ZG93biBjb21wbGV0ZWQiLAogICAgICAiQmVmb3JlIHJlYWwgZG93biwgdGhlIENMSSBmbG93IHVz" + + "ZWQgdGhlIGZ1bGwtcHJlZml4IHN0YXR1cyBjb21tYW5kIHRvIGluc3BlY3QgbGl2ZSByZWdpc3Ry" + + "YXRpb25zLCBzdGF0ZWQgdGhhdCBuYW1lZC1jbHVzdGVyIHBsYW4tb25seSBkb2VzIG5vdCBxdWVy" + + "eSBJQ01TIGFuZCBjYW5ub3QgcHJlZGljdCBjb25kaXRpb25hbCBjb250cm9sLXBsYW5lIHJlbW92" + + "YWwsIHdhcm5lZCB3aGVuIHRoZSB0YXJnZXQgd2FzIHRoZSBsYXN0IHJlZ2lzdGVyZWQgY2x1c3Rl" + + "ciwgYW5kIGdvdCBleHBsaWNpdCBjb25maXJtYXRpb24iLAogICAgICAiVGhlIENMSSBmbG93IHVz" + + "ZWQgLS1jb25maWcsIGJvdGggc3RhY2sgcGF0aHMsIC0tZW52LCAtLXBsYWluLCBib3RoIGNvbnRl" + + "eHRzLCBhbmQgLS1pY21zLXVybCBmb3IgZG93biAtLXBsYW4tb25seSBhbmQgdGhlbiBkb3duIiwK" + + "ICAgICAgIlRoZSBhZ2VudCBzdGF0ZWQgdGhhdCBkb3duIHVucmVnaXN0ZXJzIGVhY2ggY29tcHV0" + + "ZSBjbHVzdGVyIGFuZCByZW1vdmVzIHRoZSBjb250cm9sIHBsYW5lIG9ubHkgYWZ0ZXIgbm8gcmVn" + + "aXN0cmF0aW9ucyByZW1haW4iCiAgICBdCiAgfSwKICB7CiAgICAiaWQiOiAiUzEzLXZhbHVlcy1w" + + "cmVjZWRlbmNlIiwKICAgICJxdWVzdGlvbiI6ICJJIGFkZGVkIGEgdmFsdWUgdG8gbXkgZW52aXJv" + + "bm1lbnQgWUFNTCBidXQgaXQncyBiZWluZyBzaWxlbnRseSBpZ25vcmVkLiBIb3cgZG8gaGVsbWZp" + + "bGUgdmFsdWVzIHdvcmsgaW4gTlZDRj8iLAogICAgImV4cGVjdGVkX3NraWxsIjogIm52Y2Ytc2Vs" + + "Zi1tYW5hZ2VkLWluc3RhbGxhdGlvbiIsCiAgICAiZ3JvdW5kX3RydXRoIjogIlRoZSBhZ2VudCBl" + + "eHBsYWluZWQgdGhlIHZhbHVlcyBwcmVjZWRlbmNlIGNoYWluIChiYXNlLnlhbWwsIGVudiBZQU1M" + + "LCBnbG9iYWwueWFtbC5nb3RtcGwsIHNlY3JldHMsIGlubGluZSB2YWx1ZXMpLCBpZGVudGlmaWVk" + + "IHRoYXQgZ2xvYmFsLnlhbWwuZ290bXBsIG9ubHkgcGFzc2VzIHRocm91Z2ggc3BlY2lmaWMga2V5" + + "cywgYW5kIGV4cGxhaW5lZCB0aGF0IGFyYml0cmFyeSBjaGFydCB2YWx1ZXMgbXVzdCB1c2UgcmVs" + + "ZWFzZSBpbmxpbmUgdmFsdWVzIGJsb2Nrcy4iLAogICAgImV4cGVjdGVkX2JlaGF2aW9yIjogWwog" + + "ICAgICAiVGhlIGFnZW50IHJlYWQgdGhlIG52Y2Ytc2VsZi1tYW5hZ2VkLWluc3RhbGxhdGlvbiBT" + + "S0lMTC5tZCBiZWZvcmUgdGFraW5nIGFjdGlvbiIsCiAgICAgICJUaGUgYWdlbnQgZXhwbGFpbmVk" + + "IHRoZSB2YWx1ZXMgcHJlY2VkZW5jZSBjaGFpbjogYmFzZS55YW1sIC0+IGVudiBZQU1MIC0+IGds" + + "b2JhbC55YW1sLmdvdG1wbCAtPiBzZWNyZXRzIC0+IGlubGluZSB2YWx1ZXMiLAogICAgICAiVGhl" + + "IGFnZW50IGlkZW50aWZpZWQgdGhhdCBnbG9iYWwueWFtbC5nb3RtcGwgb25seSBwYXNzZXMgdGhy" + + "b3VnaCBzcGVjaWZpYyBrZXlzIChjYXNzYW5kcmEucmVwbGljYUNvdW50LCBnbG9iYWwuc3RvcmFn" + + "ZUNsYXNzLCBnbG9iYWwuaW1hZ2UsIGV0Yy4pIiwKICAgICAgIlRoZSBhZ2VudCBleHBsYWluZWQg" + + "dGhhdCBhcmJpdHJhcnkgY2hhcnQgdmFsdWVzIG11c3QgYmUgc2V0IHZpYSByZWxlYXNlIGlubGlu" + + "ZSB2YWx1ZXM6IGJsb2NrcyIsCiAgICAgICJUaGUgYWdlbnQgbGlzdGVkIGV4YW1wbGVzIG9mIHZh" + + "bHVlcyB0aGF0IGFyZSBwcm9wYWdhdGVkIGFuZCBhcmJpdHJhcnkgY2hhcnQgdmFsdWVzIHRoYXQg" + + "cmVxdWlyZSBhIHJlbGVhc2UgdmFsdWVzIGJsb2NrIgogICAgXQogIH0sCiAgewogICAgImlkIjog" + + "IlMxNC1lbmFibGUtbGxtLWZ1bmN0aW9ucyIsCiAgICAicXVlc3Rpb24iOiAiSSBuZWVkIHRvIGRl" + + "cGxveSBmdW5jdGlvblR5cGU6IExMTSBmdW5jdGlvbnMgb24gYSBzZWxmLW1hbmFnZWQsIHNpbmds" + + "ZS1ub2RlIGlzb2xhdGVkIHRlc3QgY2x1c3Rlci4gV2hhdCBIZWxtZmlsZSBjb25maWd1cmF0aW9u" + + "IGFuZCB2ZXJpZmljYXRpb24gc3RlcHMgZG8gSSBuZWVkPyIsCiAgICAiZXhwZWN0ZWRfc2tpbGwi" + + "OiAibnZjZi1zZWxmLW1hbmFnZWQtaW5zdGFsbGF0aW9uIiwKICAgICJncm91bmRfdHJ1dGgiOiAi" + + "VGhlIGFnZW50IGVuYWJsZWQgdGhlIExMTSBhZGRvbiB3aXRoIGFkZG9ucy5sbG0uZW5hYmxlZCwg" + + "Y29uZmlndXJlZCBzaW5nbGUgcmVwbGljYXMgZm9yIHRoZSBMTE0gQVBJIEdhdGV3YXkgYW5kIHJl" + + "cXVlc3Qgcm91dGVyLCBhbmQgZXhwbGFpbmVkIHRoYXQgdGhlIHJlcXVlc3Qgcm91dGVyIHVzZXMg" + + "cG93ZXItb2YtdHdvIHdoZW4gbm8gbG9hZC1iYWxhbmNlciBjb25maWd1cmF0aW9uIGlzIHNldC4g" + + "SXQgbGlua2VkIHRoZSBjYW5vbmljYWwgcmVxdWVzdC1yb3V0ZXIgbG9hZC1iYWxhbmNpbmcgZ3Vp" + + "ZGUgZm9yIG90aGVyIHJvdXRpbmcgbWV0aG9kcy4gRm9yIHRoZSBpc29sYXRlZCBwbGFpbnRleHQg" + + "Y2x1c3RlciwgaXQgaW5jbHVkZWQgYm90aCBhZGRvbnMubGxtLmdhdGV3YXkuYXV0aC5ncnBjSW5z" + + "ZWN1cmUgYW5kIGFnZW50Q29uZmlnLm1lcmdlQ29uZmlnLndvcmtsb2FkLnN0YXJnYXRlUVVJQ0lu" + + "c2VjdXJlLCB3aXRoIGEgd2FybmluZyB0aGF0IHRob3NlIHNldHRpbmdzIGFyZSBub3QgZm9yIHBy" + + "b2R1Y3Rpb24uIEl0IHJlZnJlc2hlZCB0aGUgY29tcHV0ZSBwbGFuZSB1c2luZyB0aGUgc2FtZSBo" + + "YW5kb2ZmIHVzZWQgZHVyaW5nIGluc3RhbGxhdGlvbiwgcmVkZXBsb3llZCBleGlzdGluZyBMTE0g" + + "ZnVuY3Rpb25zLCBhbmQgdmVyaWZpZWQgdGhlIExMTSBkZXBsb3ltZW50cywgcm91dGUsIGFuZCBs" + + "bG0td29ya2VyIHNpZGVjYXIuIiwKICAgICJleHBlY3RlZF9iZWhhdmlvciI6IFsKICAgICAgIlRo" + + "ZSBhZ2VudCB1c2VkIGFkZG9ucy5sbG0uZW5hYmxlZCwgbm90IHRoZSBvYnNvbGV0ZSBsbG0uZW5h" + + "YmxlZCBwYXRoIiwKICAgICAgIlRoZSBhZ2VudCBzZXQgZ2F0ZXdheSBhbmQgcmVxdWVzdFJvdXRl" + + "ciByZXBsaWNhQ291bnQgdG8gMSBmb3IgdGhlIHNpbmdsZS1ub2RlIHRlc3QgY2x1c3RlciIsCiAg" + + "ICAgICJUaGUgYWdlbnQgc3RhdGVkIHRoYXQgdGhlIHJlcXVlc3Qgcm91dGVyIGRlZmF1bHRzIHRv" + + "IHBvd2VyLW9mLXR3byBhbmQgbGlua2VkIHRoZSBjYW5vbmljYWwgcmVxdWVzdC1yb3V0ZXIgbG9h" + + "ZC1iYWxhbmNpbmcgZ3VpZGUgZm9yIG90aGVyIG1ldGhvZHMiLAogICAgICAiVGhlIGFnZW50IGlu" + + "Y2x1ZGVkIGFkZG9ucy5sbG0uZ2F0ZXdheS5hdXRoLmdycGNJbnNlY3VyZSBhbmQgd29ya2xvYWQu" + + "c3RhcmdhdGVRVUlDSW5zZWN1cmUgZm9yIHRoZSBpc29sYXRlZCBwbGFpbnRleHQgY2x1c3Rlciwg" + + "YW5kIHdhcm5lZCBhZ2FpbnN0IHVzaW5nIHRoZW0gaW4gcHJvZHVjdGlvbiIsCiAgICAgICJUaGUg" + + "YWdlbnQgYXBwbGllZCB0aGUgY29udHJvbC1wbGFuZSBIZWxtZmlsZSBlbnZpcm9ubWVudCwgcmVm" + + "cmVzaGVkIHRoZSBjb21wdXRlIHBsYW5lIHdpdGggdGhlIHNhbWUgc2VsZWN0ZWQgaGFuZG9mZiwg" + + "YW5kIHJlY3JlYXRlZCBvciByZWRlcGxveWVkIGV4aXN0aW5nIExMTSBmdW5jdGlvbnMiLAogICAg" + + "ICAiVGhlIGFnZW50IHZlcmlmaWVkIGxsbS1hcGktZ2F0ZXdheSwgbGxtLXJlcXVlc3Qtcm91dGVy" + + "LCB0aGUgTExNIEhUVFBSb3V0ZSwgYW5kIHRoZSBsbG0td29ya2VyIHNpZGVjYXIgaW5jbHVkaW5n" + + "IC0tcXVpYy1pbnNlY3VyZSIKICAgIF0KICB9LAogIHsKICAgICJpZCI6ICJHOC1ORUctbm90LWZv" + + "ci1rM2QiLAogICAgInF1ZXN0aW9uIjogIlNldCB1cCBhIGxvY2FsIE5WQ0YgZGV2IGNsdXN0ZXIg" + + "dXNpbmcgazNkIGZvciB0ZXN0aW5nIiwKICAgICJleHBlY3RlZF9za2lsbCI6IG51bGwsCiAgICAi" + + "c2hvdWxkX3RyaWdnZXIiOiBmYWxzZSwKICAgICJncm91bmRfdHJ1dGgiOiAiVGhpcyBpcyBhIGxv" + + "Y2FsIGszZCBkZXZlbG9wbWVudCByZXF1ZXN0IHRoYXQgYmVsb25ncyB0byB0aGUgbnZjZi1zZWxm" + + "LWhvc3RlZC1sb2NhbC1kZXYgc2tpbGwsIG5vdCBudmNmLXNlbGYtbWFuYWdlZC1pbnN0YWxsYXRp" + + "b24uIFRoZSBhZ2VudCBkaWQgbm90IHJlYWQgb3IgdXNlIHRoZSBzZWxmLW1hbmFnZWQgaW5zdGFs" + + "bGF0aW9uIHNraWxsIGFuZCBpbnN0ZWFkIHByb3ZpZGVkIGszZC1zcGVjaWZpYyBndWlkYW5jZS4i" + + "LAogICAgImV4cGVjdGVkX2JlaGF2aW9yIjogWwogICAgICAiVGhlIGFnZW50IGRpZCBub3QgcmVh" + + "ZCBudmNmLXNlbGYtbWFuYWdlZC1pbnN0YWxsYXRpb24vU0tJTEwubWQiLAogICAgICAiVGhlIGFn" + + "ZW50IGRpZCBub3QgcHJvdmlkZSBoZWxtZmlsZS1iYXNlZCBwcm9kdWN0aW9uIGRlcGxveW1lbnQg" + + "aW5zdHJ1Y3Rpb25zIiwKICAgICAgIlRoZSBhZ2VudCBwcm92aWRlZCBrM2Qtc3BlY2lmaWMgbG9j" + + "YWwgZGV2ZWxvcG1lbnQgZ3VpZGFuY2Ugb3IgZGVmZXJyZWQgdG8gdGhlIGFwcHJvcHJpYXRlIGxv" + + "Y2FsLWRldiBza2lsbCIKICAgIF0KICB9Cl0KUEsHCCsTuD+tVQAArVUAAFBLAwQUAAgAAAAAACEA" + + "AAAAAAAAAAAAAAAALwAJAGRhdGEvbnZjZi1zZWxmLW1hbmFnZWQtaW5zdGFsbGF0aW9uL2V4YW1w" + + "bGVzLm1kVVQFAAEAps4SIyBFeGFtcGxlcwoKV29ya2VkIGV4YW1wbGVzIGJhc2VkIG9uIHJlYWwg" + + "ZGVwbG95bWVudCBzY2VuYXJpb3MuCgojIyBFeGFtcGxlIDE6IE92ZXJyaWRlIENhc3NhbmRyYSBS" + + "ZXNvdXJjZXMKClRoZSBkZWZhdWx0IENhc3NhbmRyYSByZXNvdXJjZSBsaW1pdHMgY2F1c2UgT09N" + + "IG9uIGxhcmdlIGluc3RhbmNlIHR5cGVzIChlLmcuLCBgcDUuNDh4bGFyZ2VgKS4KClByb2JsZW06" + + "IENhc3NhbmRyYSBwb2RzIHJlc3RhcnQgd2l0aCBgT09NS2lsbGVkYC4KClNvbHV0aW9uOiBPdmVy" + + "cmlkZSByZXNvdXJjZXMgdmlhIGhlbG1maWxlIHJlbGVhc2UgdmFsdWVzIGJsb2NrLgoKIyMjIFN0" + + "ZXAgMTogQ2FwdHVyZSBiYXNlbGluZQoKYGBgYmFzaApIRUxNRklMRV9FTlY9PGVudj4gaGVsbWZp" + + "bGUgLS1zZWxlY3RvciBuYW1lPWNhc3NhbmRyYSB0ZW1wbGF0ZSA+IC90bXAvY2Fzcy1iZWZvcmUu" + + "eWFtbApncmVwIC1BOCAncmVzb3VyY2VzOicgL3RtcC9jYXNzLWJlZm9yZS55YW1sIHwgaGVhZCAt" + + "MTAKYGBgCgojIyMgU3RlcCAyOiBBZGQgb3ZlcnJpZGUgdG8gaGVsbWZpbGUuZC8wMS1kZXBlbmRl" + + "bmNpZXMueWFtbC5nb3RtcGwKCkluIHRoZSBleGFtcGxlcyBiZWxvdywgYDxwcml2YXRlLXZhbHVl" + + "cz5gIHJlZmVycyB0byB0aGUgYHNlY3JldHMvYCBkaXJlY3RvcnkgYXQgdGhlIGhlbG1maWxlIHN0" + + "YWNrIHJvb3QuCgpgYGB5YW1sCi0gbmFtZTogY2Fzc2FuZHJhCiAgdmVyc2lvbjogMC44LjAKICBj" + + "b25kaXRpb246IGNhc3NhbmRyYS5lbmFibGVkCiAgbmFtZXNwYWNlOiBjYXNzYW5kcmEtc3lzdGVt" + + "CiAgPDw6ICpkZXBlbmRlbmN5CiAgdmFsdWVzOgogICAgLSAuLi9nbG9iYWwueWFtbC5nb3RtcGwK" + + "ICAgIC0gLi4vPHByaXZhdGUtdmFsdWVzPi97eyByZXF1aXJlZEVudiAiSEVMTUZJTEVfRU5WIiB9" + + "fS1zZWNyZXRzLnlhbWwKICAgIC0gY2Fzc2FuZHJhOgogICAgICAgIHJlc291cmNlczoKICAgICAg" + + "ICAgIGxpbWl0czoKICAgICAgICAgICAgY3B1OiAiOCIKICAgICAgICAgICAgbWVtb3J5OiA4MTky" + + "TWkKICAgICAgICAgIHJlcXVlc3RzOgogICAgICAgICAgICBjcHU6ICIyIgogICAgICAgICAgICBt" + + "ZW1vcnk6IDQwOTZNaQpgYGAKCiMjIyBTdGVwIDM6IFZlcmlmeSBhbmQgYXBwbHkKCmBgYGJhc2gK" + + "SEVMTUZJTEVfRU5WPTxlbnY+IGhlbG1maWxlIC0tc2VsZWN0b3IgbmFtZT1jYXNzYW5kcmEgdGVt" + + "cGxhdGUgPiAvdG1wL2Nhc3MtYWZ0ZXIueWFtbApkaWZmIC90bXAvY2Fzcy1iZWZvcmUueWFtbCAv" + + "dG1wL2Nhc3MtYWZ0ZXIueWFtbCAgIyBDb25maXJtIHJlc291cmNlcyBjaGFuZ2VkCkhFTE1GSUxF" + + "X0VOVj08ZW52PiBoZWxtZmlsZSAtLXNlbGVjdG9yIG5hbWU9Y2Fzc2FuZHJhIHN5bmMKYGBgCgpO" + + "b3RlOiBgcmVzb3VyY2VQcmVzZXRgIChhIEJpdG5hbWkgZmVhdHVyZSkgaXMgbm90IGF2YWlsYWJs" + + "ZSBpbiB0aGUgTlZDRiBjYXNzYW5kcmEgd3JhcHBlciBjaGFydC4gVXNlIGV4cGxpY2l0IGByZXNv" + + "dXJjZXNgIGluc3RlYWQuCgotLS0KCiMjIEV4YW1wbGUgMjogRGVwbG95IGZyb20gTkdDIFByaXZh" + + "dGUgUmVnaXN0cnkgd2l0aCBQdWxsIFNlY3JldHMKCkRlcGxveSB0aGUgTlZDRiBzdGFjayBwdWxs" + + "aW5nIGltYWdlcyBkaXJlY3RseSBmcm9tIE5HQyAoYG52Y3IuaW9gKSBpbnN0ZWFkIG9mIGEgbWly" + + "cm9yZWQgcmVnaXN0cnksIHVzaW5nIGltYWdlIHB1bGwgc2VjcmV0cy4KCiMjIyBTdGVwIDE6IENv" + + "bmZpZ3VyZSBlbnZpcm9ubWVudCBmb3IgTkdDCgpgYGB5YW1sCiMgZW52aXJvbm1lbnRzLzxlbnY+" + + "LnlhbWwKZ2xvYmFsOgogIGhlbG06CiAgICBzb3VyY2VzOgogICAgICByZWdpc3RyeTogbnZjci5p" + + "bwogICAgICByZXBvc2l0b3J5OiBudmlkaWEvbnZjZgogIGltYWdlOgogICAgcmVnaXN0cnk6IG52" + + "Y3IuaW8KICAgIHJlcG9zaXRvcnk6IG52aWRpYS9udmNmCmBgYAoKIyMjIFN0ZXAgMjogQXV0aGVu" + + "dGljYXRlIGxvY2FsbHkgKGZvciBoZWxtZmlsZSBjaGFydCBwdWxscykKCmBgYGJhc2gKZG9ja2Vy" + + "IGxvZ2luIG52Y3IuaW8gLXUgJyRvYXV0aHRva2VuJyAtcCAiJE5HQ19BUElfS0VZIgpoZWxtIHJl" + + "Z2lzdHJ5IGxvZ2luIG52Y3IuaW8gLXUgJyRvYXV0aHRva2VuJyAtcCAiJE5HQ19BUElfS0VZIgpg" + + "YGAKCiMjIyBTdGVwIDM6IENyZWF0ZSBuYW1lc3BhY2VzIGFuZCBwdWxsIHNlY3JldHMKCmBgYGJh" + + "c2gKZXhwb3J0IE5HQ19BUElfS0VZPSI8eW91ci1uZ2MtYXBpLWtleT4iCgpmb3IgbnMgaW4gY2Fz" + + "c2FuZHJhLXN5c3RlbSBuYXRzLXN5c3RlbSBudmNmIGFwaS1rZXlzIGVzcyBzaXMgdmF1bHQtc3lz" + + "dGVtIGNlcnQtbWFuYWdlcjsgZG8KICBrdWJlY3RsIC0tY29udGV4dCA8Y29udHJvbC1wbGFuZS1j" + + "b250ZXh0PiBjcmVhdGUgbmFtZXNwYWNlICIkbnMiIFwKICAgIC0tZHJ5LXJ1bj1jbGllbnQgLW8g" + + "eWFtbCB8IGt1YmVjdGwgLS1jb250ZXh0IDxjb250cm9sLXBsYW5lLWNvbnRleHQ+IGFwcGx5IC1m" + + "IC0KZG9uZQoKZm9yIG5zIGluIGNhc3NhbmRyYS1zeXN0ZW0gbmF0cy1zeXN0ZW0gbnZjZiBhcGkt" + + "a2V5cyBlc3Mgc2lzIHZhdWx0LXN5c3RlbSBjZXJ0LW1hbmFnZXI7IGRvCiAga3ViZWN0bCAtLWNv" + + "bnRleHQgPGNvbnRyb2wtcGxhbmUtY29udGV4dD4gY3JlYXRlIHNlY3JldCBkb2NrZXItcmVnaXN0" + + "cnkgbnZjci1jcmVkcyBcCiAgICAtLWRvY2tlci1zZXJ2ZXI9bnZjci5pbyBcCiAgICAtLWRvY2tl" + + "ci11c2VybmFtZT0nJG9hdXRodG9rZW4nIFwKICAgIC0tZG9ja2VyLXBhc3N3b3JkPSIkTkdDX0FQ" + + "SV9LRVkiIFwKICAgIC0tbmFtZXNwYWNlPSIkbnMiIFwKICAgIC0tZHJ5LXJ1bj1jbGllbnQgLW8g" + + "eWFtbCB8IGt1YmVjdGwgLS1jb250ZXh0IDxjb250cm9sLXBsYW5lLWNvbnRleHQ+IGFwcGx5IC1m" + + "IC0KZG9uZQpgYGAKCiMjIyBTdGVwIDQ6IEFkZCBpbWFnZVB1bGxTZWNyZXRzIHRvIGhlbG1maWxl" + + "IHJlbGVhc2VzCgpBZGQgdGhlIGNoYXJ0LXNwZWNpZmljIGBpbWFnZVB1bGxTZWNyZXRzYCBrZXkg" + + "dG8gZWFjaCByZWxlYXNlLiBFeGFtcGxlIGZvciBjYXNzYW5kcmEgaW4gYGhlbG1maWxlLmQvMDEt" + + "ZGVwZW5kZW5jaWVzLnlhbWwuZ290bXBsYDoKCmBgYHlhbWwKLSBuYW1lOiBjYXNzYW5kcmEKICB2" + + "ZXJzaW9uOiAwLjguMAogIGNvbmRpdGlvbjogY2Fzc2FuZHJhLmVuYWJsZWQKICBuYW1lc3BhY2U6" + + "IGNhc3NhbmRyYS1zeXN0ZW0KICA8PDogKmRlcGVuZGVuY3kKICB2YWx1ZXM6CiAgICAtIC4uL2ds" + + "b2JhbC55YW1sLmdvdG1wbAogICAgLSAuLi88cHJpdmF0ZS12YWx1ZXM+L3t7IHJlcXVpcmVkRW52" + + "ICJIRUxNRklMRV9FTlYiIH19LXNlY3JldHMueWFtbAogICAgLSBjYXNzYW5kcmE6CiAgICAgICAg" + + "Z2xvYmFsOgogICAgICAgICAgaW1hZ2VQdWxsU2VjcmV0czoKICAgICAgICAgICAgLSBudmNyLWNy" + + "ZWRzCmBgYAoKU2VlIFtyZWZlcmVuY2VzL3B1bGwtc2VjcmV0cy5tZF0ocmVmZXJlbmNlcy9wdWxs" + + "LXNlY3JldHMubWQpIGZvciB0aGUga2V5IGZvciBldmVyeSBjaGFydC4KClRoZXNlIGFyZSBjb250" + + "cm9sLXBsYW5lIG5hbWVzcGFjZXMuIEZvciBhIHNlcGFyYXRlIGNvbXB1dGUgY2x1c3RlciwgY3Jl" + + "YXRlIHRoZQpzZWNyZXQgb25seSBpbiBgbnZjYS1vcGVyYXRvcmA7IHRoZSBjaGFydCBhbmQgb3Bl" + + "cmF0b3IgbWlycm9yIGl0IHRvCmBudmNhLXN5c3RlbWAuIFNlZSBbU3BsaXQgQ29tcHV0ZS1QbGFu" + + "ZSBJbnN0YWxsYXRpb25dKHJlZmVyZW5jZXMvY29tcHV0ZS1wbGFuZS1pbnN0YWxsYXRpb24ubWQj" + + "cHVsbC1zZWNyZXRzKS4KCiMjIyBTdGVwIDU6IERlcGxveQoKYGBgYmFzaApIRUxNRklMRV9FTlY9" + + "PGVudj4gaGVsbWZpbGUgLS1rdWJlLWNvbnRleHQgPGNvbnRyb2wtcGxhbmUtY29udGV4dD4gc3lu" + + "YwpgYGAKCiMjIyBTdGVwIDY6IFBhdGNoIFNlcnZpY2VBY2NvdW50cyBmb3IgY2hhcnRzIHdpdGhv" + + "dXQgbmF0aXZlIHN1cHBvcnQKCkFmdGVyIFBoYXNlIDEgKGRlcGVuZGVuY2llcykgY29tcGxldGVz" + + "LCBPcGVuQmFvIHBvZHMgd2lsbCBiZSBpbiBgSW1hZ2VQdWxsQmFja09mZmAuIFBhdGNoIGFuZCBy" + + "ZXN0YXJ0OgoKYGBgYmFzaApmb3IgbnMgaW4gdmF1bHQtc3lzdGVtIG52Y2YgZXNzOyBkbwogIGZv" + + "ciBzYSBpbiAkKGt1YmVjdGwgLS1jb250ZXh0IDxjb250cm9sLXBsYW5lLWNvbnRleHQ+IGdldCBz" + + "YSAtbiAiJG5zIiBcCiAgICAtLW5vLWhlYWRlcnMgLW8gY3VzdG9tLWNvbHVtbnM9IjptZXRhZGF0" + + "YS5uYW1lIik7IGRvCiAgICBrdWJlY3RsIC0tY29udGV4dCA8Y29udHJvbC1wbGFuZS1jb250ZXh0" + + "PiBwYXRjaCBzZXJ2aWNlYWNjb3VudCAtbiAiJG5zIiAiJHNhIiBcCiAgICAgIC1wICd7ImltYWdl" + + "UHVsbFNlY3JldHMiOiBbeyJuYW1lIjogIm52Y3ItY3JlZHMifV19JwogIGRvbmUKZG9uZQprdWJl" + + "Y3RsIC0tY29udGV4dCA8Y29udHJvbC1wbGFuZS1jb250ZXh0PiBkZWxldGUgcG9kcyAtbiB2YXVs" + + "dC1zeXN0ZW0gLS1hbGwKYGBgCgpWZXJpZnk6CgpgYGBiYXNoCmt1YmVjdGwgLS1jb250ZXh0IDxj" + + "b250cm9sLXBsYW5lLWNvbnRleHQ+IGdldCBldmVudHMgLW4gdmF1bHQtc3lzdGVtIFwKICAtLXNv" + + "cnQtYnk9Jy5sYXN0VGltZXN0YW1wJyB8IGdyZXAgLWkgcHVsbAojIFNob3VsZCBzaG93ICJTdWNj" + + "ZXNzZnVsbHkgcHVsbGVkIGltYWdlIiBmcm9tIG52Y3IuaW8KYGBgCgotLS0KCiMjIEV4YW1wbGUg" + + "MzogRnVsbCBUZWFyZG93biBhbmQgUmVpbnN0YWxsCgpXaGVuIGEgZGVwbG95bWVudCBpcyBicm9r" + + "ZW4gYW5kIHlvdSBuZWVkIGEgY2xlYW4gc2xhdGUuCgojIyMgU3RlcCAxOiBEZXN0cm95IHRoZSBj" + + "b21wdXRlLXBsYW5lIHN0YWNrCgpgYGBiYXNoCm1ha2UgLUMgZGVwbG95L3N0YWNrcy9udmNmLWNv" + + "bXB1dGUtcGxhbmUgZGVzdHJveSBcCiAgQ0xVU1RFUl9OQU1FPTxjbHVzdGVyLW5hbWU+IFwKICBI" + + "RUxNRklMRV9FTlY9PGVudj4gXAogIEtVQkVDT05GSUdfRklMRT08Y29tcHV0ZS1wbGFuZS1rdWJl" + + "Y29uZmlnPgpgYGAKCklmIGNvbXB1dGUgY2xlYW51cCBpcyBzdHVjayBvbiBmaW5hbGl6ZXJzLCB1" + + "c2UgdGhlIGNvbXB1dGUtY29udGV4dCBwcm9jZWR1cmUgaW4KW2RlYnVnZ2luZy5tZF0ocmVmZXJl" + + "bmNlcy9kZWJ1Z2dpbmcubWQjZmFpbHVyZS1udmNhLWNsZWFudXAtc3R1Y2stZmluYWxpemVycyku" + + "CgojIyMgU3RlcCAyOiBEZXJlZ2lzdGVyIHRoZSBjb21wdXRlIGNsdXN0ZXIKClJlYWQgYGNsdXN0" + + "ZXJJRGAgYW5kIGBuY2FJRGAgZnJvbQpgZGVwbG95L3N0YWNrcy9udmNmLWNvbXB1dGUtcGxhbmUv" + + "cmVnaXN0cmF0aW9uLzxjbHVzdGVyLW5hbWU+LXJlZ2lzdGVyLXZhbHVlcy55YW1sYC4KU2hvdyB0" + + "aGUgSUQgYW5kIGdldCBjb25maXJtYXRpb24gYmVmb3JlIGRlbGV0aW5nIHRoZSBJQ01TIHJvdzoK" + + "CmBgYGJhc2gKPG52Y2YtY2xpPiAtLWNvbmZpZyA8Y29uZmlnPiBjbHVzdGVyIGRlbGV0ZSBcCiAg" + + "LS1jbHVzdGVyLWlkIDxjbHVzdGVyLWlkLWZyb20tcmVnaXN0cmF0aW9uLXZhbHVlcz4gXAogIC0t" + + "bmNhLWlkIDxuY2EtaWQ+IFwKICAtLWlnbm9yZS1taXNzaW5nCmBgYAoKUmVwZWF0IHN0ZXBzIDEg" + + "YW5kIDIgZm9yIGV2ZXJ5IGNvbXB1dGUgY2x1c3Rlci4KCiMjIyBTdGVwIDM6IERlc3Ryb3kgdGhl" + + "IGNvbnRyb2wtcGxhbmUgc3RhY2sKClByZXNlcnZlIHRoZSBgY2VydC1tYW5hZ2VyYCBuYW1lc3Bh" + + "Y2UgYnkgZGVmYXVsdC4gTmFtZXNwYWNlIHByZXNlcnZhdGlvbiBkb2VzCm5vdCBwcmVzZXJ2ZSB0" + + "aGUgSGVsbSByZWxlYXNlLiBCZWZvcmUgcnVubmluZyBkZXN0cm95LCBpZGVudGlmeSB3aGV0aGVy" + + "CmNlcnQtbWFuYWdlciBpcyBleHRlcm5hbC4gRm9yIGFuIGV4dGVybmFsIGluc3RhbGxhdGlvbiwg" + + "cmVxdWlyZSBlZmZlY3RpdmUKYGNlcnRNYW5hZ2VyLmVuYWJsZWQ6IGZhbHNlYCBhbmQgYWJvcnQg" + + "aWYgaXQgaXMgdHJ1ZS4gRm9yIGFuIGludGVuZGVkCnN0YWNrLW1hbmFnZWQgcmVsZWFzZSB3aXRo" + + "IGVmZmVjdGl2ZSBgY2VydE1hbmFnZXIuZW5hYmxlZDogdHJ1ZWAsIHZlcmlmeQptYXRjaGluZyBz" + + "dGFjayBIZWxtIHJlbGVhc2UgbWV0YWRhdGEgYW5kIGFib3J0IG9uIG1pc3Npbmcgb3IgbWlzbWF0" + + "Y2hlZApldmlkZW5jZS4gT25seSBwbGFuIG5hbWVzcGFjZSByZW1vdmFsIGFmdGVyIHZlcmlmeWlu" + + "ZyBuYW1lc3BhY2UgcHJvdmVuYW5jZSBhbmQKZ2V0dGluZyBleHBsaWNpdCBjb25maXJtYXRpb247" + + "IG90aGVyd2lzZSBkbyBub3QgZGVsZXRlIGl0LgoKYGBgYmFzaApLVUJFQ09ORklHPTxjb250cm9s" + + "LXBsYW5lLWt1YmVjb25maWc+IFwKbWFrZSAtQyBkZXBsb3kvc3RhY2tzL3NlbGYtbWFuYWdlZCBk" + + "ZXN0cm95IFwKICBIRUxNRklMRV9FTlY9PGVudj4gXAogIEtVQkVDT05GSUdfRklMRT08Y29udHJv" + + "bC1wbGFuZS1rdWJlY29uZmlnPgpgYGAKClBhc3MgYm90aCBrdWJlY29uZmlnIGZvcm1zIGJlY2F1" + + "c2UgY29udHJvbC1wbGFuZSBuYW1lc3BhY2UgY2xlYW51cCB1c2VzCmFtYmllbnQgYGt1YmVjdGxg" + + "LgoKIyMjIFN0ZXAgNDogVmVyaWZ5IGNsZWFuCgpgYGBiYXNoCmt1YmVjdGwgLS1jb250ZXh0IDxj" + + "b21wdXRlLXBsYW5lLWNvbnRleHQ+IGdldCBucyB8IFwKICBncmVwIC1FICcobnZjYXxudmNmLWJh" + + "Y2tlbmR8Z3JvdmV8ZHluYW1vKScKa3ViZWN0bCAtLWNvbnRleHQgPGNvbnRyb2wtcGxhbmUtY29u" + + "dGV4dD4gZ2V0IG5zIHwgXAogIGdyZXAgLUUgJyhjYXNzYW5kcmF8bmF0c3x2YXVsdHxudmNmfGFw" + + "aS1rZXlzfGVzc3xzaXMpJwojIEJvdGggY29tbWFuZHMgc2hvdWxkIHJldHVybiBlbXB0eS4KYGBg" + + "CgojIyMgU3RlcCA1OiBSZWluc3RhbGwgaW4gc3BsaXQgb3JkZXIKCkZvbGxvdyBbQ2xlYW4gSW5z" + + "dGFsbGF0aW9uXShTS0lMTC5tZCNjbGVhbi1pbnN0YWxsYXRpb24pLCB0aGVuIHJldHVybiB0byB0" + + "aGUKc2FtZSBoYW5kb2ZmIGluIFtTcGxpdCBDb21wdXRlLVBsYW5lIEluc3RhbGxhdGlvbl0ocmVm" + + "ZXJlbmNlcy9jb21wdXRlLXBsYW5lLWluc3RhbGxhdGlvbi5tZCkuCgotLS0KCiMjIEV4YW1wbGUg" + + "NDogUmVjb3ZlciBmcm9tIGEgR2F0ZXdheSBFbmRwb2ludCBDaGFuZ2UKClRoZSBzZXBhcmF0ZWx5" + + "IHByb3Zpc2lvbmVkIEdhdGV3YXkgb3IgaXRzIGxvYWQgYmFsYW5jZXIgd2FzIHJlY3JlYXRlZCBh" + + "bmQgZ290IGEgbmV3IGVuZHBvaW50LgoKIyMjIFN0ZXAgMTogR2V0IHRoZSBuZXcgZW5kcG9pbnQK" + + "CmBgYGJhc2gKR0FURVdBWV9BRERSPSQoa3ViZWN0bCAtLWNvbnRleHQgPGNvbnRyb2wtcGxhbmUt" + + "Y29udGV4dD4gZ2V0IGdhdGV3YXkgXAogIG52Y2YtZ2F0ZXdheSAtbiBlbnZveS1nYXRld2F5IFwK" + + "ICAtbyBqc29ucGF0aD0ney5zdGF0dXMuYWRkcmVzc2VzWzBdLnZhbHVlfScpCnRlc3QgLW4gIiRH" + + "QVRFV0FZX0FERFIiCmBgYAoKIyMjIFN0ZXAgMjogVXBkYXRlIEROUyBhbmQgZGlyZWN0IGFkZHJl" + + "c3MgZmllbGRzCgpLZWVwIGBnbG9iYWwuZG9tYWluYCwgcm91dGUgaG9zdG5hbWVzLCBhbmQgQ0xJ" + + "IEhvc3QgZmllbGRzIHVuY2hhbmdlZC4gUG9pbnQgdGhlCkROUyByZWNvcmRzIGZvciByZW5kZXJl" + + "ZCByb3V0ZSBob3N0bmFtZXMsIHN1Y2ggYXMgYGFwaS48ZG9tYWluPmAgYW5kCmAqLmludm9jYXRp" + + "b24uPGRvbWFpbj5gLCB0byBgR0FURVdBWV9BRERSYC4gRm9yIGEgdGVtcG9yYXJ5IGVudmlyb25t" + + "ZW50IHdpdGhvdXQKRE5TLCBrZWVwIGl0cyByZXNlcnZlZCByb3V0ZSBzdWZmaXggYW5kIGNvbm5l" + + "Y3QgdG8gYEdBVEVXQVlfQUREUmAgd2l0aCB0aGUKbWF0Y2hpbmcgYEhvc3RgIGhlYWRlci4KCkZv" + + "ciBhIHNwbGl0IGRlcGxveW1lbnQgY29uZmlndXJlZCB3aXRoIGRpcmVjdCBHYXRld2F5IGFkZHJl" + + "c3NlcywgcmVwbGFjZSBvbmx5CnRoZSBhZGRyZXNzLWJlYXJpbmcgdmFsdWVzOiBjb250cm9sLXBs" + + "YW5lIGBudmNmTmF0c1NlcnZpY2VVUkxgLCBjb21wdXRlLXBsYW5lCklDTVMsIFJlVmFsLCBhbmQg" + + "TkFUUyBVUkxzLCBhbmQgQ0xJIFVSTCBmaWVsZHMuIEtlZXAgdGhlaXIgZG9tYWluIGFuZCBIb3N0" + + "Cm92ZXJyaWRlcyB1bmNoYW5nZWQuIFJlZnJlc2ggcmVnaXN0cmF0aW9uIGFuZCBpbnN0YWxsYXRp" + + "b24gdGhyb3VnaCB0aGUgc2FtZQpoYW5kb2ZmIHVzZWQgb3JpZ2luYWxseS4gU2VlCltTcGxpdCBD" + + "b21wdXRlLVBsYW5lIEluc3RhbGxhdGlvbl0ocmVmZXJlbmNlcy9jb21wdXRlLXBsYW5lLWluc3Rh" + + "bGxhdGlvbi5tZCkKZm9yIHRoZSBmaWVsZHMgYW5kIGNvbXBsZXRlIGNvbW1hbmRzLgoKIyMjIFN0" + + "ZXAgMzogVmVyaWZ5IGJvdGggY29udGV4dHMKCmBgYGJhc2gKZGlnICtzaG9ydCAiYXBpLjxkb21h" + "aW4+IgpjdXJsIC1IICJIb3N0OiBhcGkuPGRvbWFpbj4iICJodHRwOi8vJEdBVEVXQVlfQUREUi9o" + - "ZWFsdGgiCgojIENoZWNrIGRpcmVjdCBhZGRyZXNzIGZpZWxkcyB1c2VkIGJ5IGEgc3BsaXQgZGVw" + - "bG95bWVudApncmVwIG52Y2ZOYXRzU2VydmljZVVSTCBkZXBsb3kvc3RhY2tzL3NlbGYtbWFuYWdl" + - "ZC9lbnZpcm9ubWVudHMvPGVudj4ueWFtbApncmVwIC1FICdpY21zU2VydmljZXxyZXZhbFNlcnZp" + - "Y2V8bmF0cycgXAogIGRlcGxveS9zdGFja3MvbnZjZi1jb21wdXRlLXBsYW5lL2Vudmlyb25tZW50" + - "cy88ZW52Pi55YW1sCmBgYAoKIyMjIEZpeAoKS2VlcCBgZ2xvYmFsLmRvbWFpbmAsIHJvdXRlIGhv" + - "c3RuYW1lcywgYW5kIEhvc3Qgb3ZlcnJpZGVzIHVuY2hhbmdlZC4gVXBkYXRlIEROUwpvciB0aGUg" + - "ZGlyZWN0IGNsaWVudCBkZXN0aW5hdGlvbi4gRm9yIHNwbGl0IGRlcGxveW1lbnRzLCB1cGRhdGUg" + - "b25seSBkaXJlY3QKR2F0ZXdheS1hZGRyZXNzIGZpZWxkcyBhbmQgcmVmcmVzaCByZWdpc3RyYXRp" + - "b24gYW5kIGluc3RhbGxhdGlvbiB0aHJvdWdoIHRoZQpzYW1lIHNlbGVjdGVkIGhhbmRvZmYuIFNl" + - "ZQpbRXhhbXBsZSA0XSguLi9leGFtcGxlcy5tZCNleGFtcGxlLTQtcmVjb3Zlci1mcm9tLWEtZ2F0" + - "ZXdheS1lbmRwb2ludC1jaGFuZ2UpLgoKIyMgVXNlZnVsIE5hbWVzcGFjZS10by1TZXJ2aWNlIE1h" + - "cHBpbmcKClF1aWNrIHJlZmVyZW5jZSBmb3Igd2hpY2ggc2VydmljZXMgcnVuIGluIHdoaWNoIG5h" + - "bWVzcGFjZToKCnwgTmFtZXNwYWNlIHwgU2VydmljZXMgfAp8LS0tLS0tLS0tLS18LS0tLS0tLS0t" + - "LXwKfCBuYXRzLXN5c3RlbSB8IG5hdHMgfAp8IGNhc3NhbmRyYS1zeXN0ZW0gfCBjYXNzYW5kcmEg" + - "fAp8IHZhdWx0LXN5c3RlbSB8IG9wZW5iYW8tc2VydmVyIHwKfCBudmNmIHwgYXBpLCBpbnZvY2F0" + - "aW9uLXNlcnZpY2UsIGdycGMtcHJveHksIG5vdGFyeS1zZXJ2aWNlLCByZXZhbCwgbGxtLXJlcXVl" + - "c3Qtcm91dGVyLCBsbG0tYXBpLWdhdGV3YXkgfAp8IGFwaS1rZXlzIHwgYXBpLWtleXMsIGFkbWlu" + - "LWlzc3Vlci1wcm94eSB8CnwgZXNzIHwgZXNzLWFwaSB8Cnwgc2lzIHwgc2lzIHwKfCBlbnZveS1n" + - "YXRld2F5LXN5c3RlbSB8IGVudm95IGdhdGV3YXkgKGluZ3Jlc3MgY29udHJvbGxlcikgfAp8IGVu" + - "dm95LWdhdGV3YXkgfCBnYXRld2F5IHJlc291cmNlICsgcm91dGVzIHwKUEsHCFY+Z5CVMAAAlTAA" + - "AFBLAwQUAAgAAAAAACEAAAAAAAAAAAAAAAAARAAJAGRhdGEvbnZjZi1zZWxmLW1hbmFnZWQtaW5z" + - "dGFsbGF0aW9uL3JlZmVyZW5jZXMvaGVsbWZpbGUtc3RydWN0dXJlLm1kVVQFAAEAps4SIyBIZWxt" + - "ZmlsZSBTdHJ1Y3R1cmUgUmVmZXJlbmNlCgojIyBEaXJlY3RvcnkgTGF5b3V0CgpgYGAKbnZjZi1z" + - "ZWxmLW1hbmFnZWQtc3RhY2svCnwtLSBoZWxtZmlsZS5kLwp8ICAgfC0tIDAxLWRlcGVuZGVuY2ll" + - "cy55YW1sLmdvdG1wbCAgIyBOQVRTLCBDYXNzYW5kcmEsIE9wZW5CYW8KfCAgIHwtLSAwMi1jb3Jl" + - "LnlhbWwuZ290bXBsICAgICAgICAgICMgTlZDRiBzZXJ2aWNlcyArIGluZ3Jlc3MKfCAgIGAtLSAw" + - "My1vYnNlcnZhYmlsaXR5LnlhbWwuZ290bXBsICMgT2JzZXJ2YWJpbGl0eSBzdGFjayAob3B0aW9u" + - "YWwpCnwtLSBlbnZpcm9ubWVudHMvCnwgICB8LS0gYmFzZS55YW1sICAgICAgICAgICAgICAgICAg" + - "ICAjIERlZmF1bHQgdmFsdWVzIChhbGwgZW52aXJvbm1lbnRzKQp8ICAgYC0tIDxlbnYtbmFtZT4u" + - "eWFtbCAgICAgICAgICAgICAgIyBQZXItZW52aXJvbm1lbnQgb3ZlcnJpZGVzCnwtLSBzZWNyZXRz" + - "Lwp8ICAgYC0tIDxlbnYtbmFtZT4tc2VjcmV0cy55YW1sICAgICAgIyBTZW5zaXRpdmUgdmFsdWVz" + - "IChyZWdpc3RyeSBjcmVkcywgcGFzc3dvcmRzKQpgLS0gZ2xvYmFsLnlhbWwuZ290bXBsICAgICAg" + - "ICAgICAgICAgIyBHbyB0ZW1wbGF0ZSB0aGF0IGNvbnN0cnVjdHMgcGVyLWNoYXJ0IHZhbHVlcwoK" + - "bnZjZi1jb21wdXRlLXBsYW5lLXN0YWNrLwp8LS0gaGVsbWZpbGUuZC8KfCAgIHwtLSAwMS1kZXBl" + - "bmRlbmNpZXMueWFtbC5nb3RtcGwgICMgQ29tcHV0ZSBwbGFuZSBkZXBlbmRlbmN5IGNvbXBvbmVu" + - "dHMKfCAgIGAtLSAwMi1udmNhLnlhbWwuZ290bXBsICAgICAgICAgICMgbnZjYS1vcGVyYXRvciBj" + - "aGFydCBhbmQgbnZjYSBjb25maWd1cmF0aW9uCnwtLSBlbnZpcm9ubWVudHMvCnwgICB8LS0gYmFz" + - "ZS55YW1sICAgICAgICAgICAgICAgICAgICAjIERlZmF1bHQgdmFsdWVzIChhbGwgZW52aXJvbm1l" + - "bnRzKQp8ICAgYC0tIDxlbnYtbmFtZT4ueWFtbCAgICAgICAgICAgICAgIyBQZXItZW52aXJvbm1l" + - "bnQgb3ZlcnJpZGVzCmAtLSBnbG9iYWwueWFtbC5nb3RtcGwgICAgICAgICAgICAgICAjIEdvIHRl" + - "bXBsYXRlIHRoYXQgY29uc3RydWN0cyBwZXItY2hhcnQgdmFsdWVzCmBgYAoKVGhlc2Ugc3RhY2tz" + - "IGhhdmUgc2VwYXJhdGUgZW52aXJvbm1lbnRzIGFuZCBjbHVzdGVyIGNvbnRleHRzLiBUaGUgSGVs" + - "bWZpbGUKdmFsdWVzIGZsb3cgYXV0aG9ycyBib3RoIGVudmlyb25tZW50IGZpbGVzLiBUaGUgQ0xJ" + - "IHByb2ZpbGUgZmxvdyBpbnN0ZWFkIHVzZXMKdGhlIENMSS1nZW5lcmF0ZWQgY29udHJvbC1wbGFu" + - "ZSBwcm9maWxlIGFzIGl0cyBlbmRwb2ludCBzb3VyY2UuIERvIG5vdCBtaXggdGhlCmhhbmRvZmZz" + - "LiBTZWUgW1NwbGl0IENvbXB1dGUtUGxhbmUgSW5zdGFsbGF0aW9uXShjb21wdXRlLXBsYW5lLWlu" + - "c3RhbGxhdGlvbi5tZCkuCgojIyBHb3RtcGwgRmlsZXMgYW5kIFRoZWlyIFJlbGVhc2VzCgojIyMg" + - "MDEtZGVwZW5kZW5jaWVzLnlhbWwuZ290bXBsCgp8IFJlbGVhc2UgfCBDaGFydCB8IE5hbWVzcGFj" + - "ZSB8IE5vdGVzIHwKfC0tLS0tLS0tLXwtLS0tLS0tfC0tLS0tLS0tLS0tfC0tLS0tLS18CnwgbmF0" + - "cyB8IGhlbG0tbnZjZi1uYXRzIHwgbmF0cy1zeXN0ZW0gfCBNZXNzYWdpbmcgfAp8IG9wZW5iYW8t" + - "c2VydmVyIHwgaGVsbS1udmNmLW9wZW5iYW8tc2VydmVyIHwgdmF1bHQtc3lzdGVtIHwgU2VjcmV0" + - "cyBtYW5hZ2VtZW50LCBkZXBlbmRzIG9uIG5hdHMgfAp8IGNhc3NhbmRyYSB8IGhlbG0tbnZjZi1j" + - "YXNzYW5kcmEgfCBjYXNzYW5kcmEtc3lzdGVtIHwgRGF0YWJhc2UgfAoKVXNlcyBgPDw6ICpkZXBl" + - "bmRlbmN5YCB0ZW1wbGF0ZSBpbmhlcml0YW5jZSB3aXRoIGByZWxlYXNlLWdyb3VwOiBkZXBlbmRl" + - "bmNpZXNgIGxhYmVsLgoKIyMjIDAyLWNvcmUueWFtbC5nb3RtcGwKCnwgUmVsZWFzZSB8IENoYXJ0" + - "IHwgTmFtZXNwYWNlIHwgTGFiZWwgfAp8LS0tLS0tLS0tfC0tLS0tLS18LS0tLS0tLS0tLS18LS0t" + - "LS0tLXwKfCBhcGkta2V5cyB8IGhlbG0tbnZjZi1hcGkta2V5cyB8IGFwaS1rZXlzIHwgc2Vydmlj" + - "ZXMgfAp8IHNpcyB8IGhlbG0tbnZjZi1zaXMgfCBzaXMgfCBzZXJ2aWNlcyB8CnwgYXBpIHwgaGVs" + - "bS1udmNmLWFwaSB8IG52Y2YgfCBzZXJ2aWNlcyB8CnwgaW52b2NhdGlvbi1zZXJ2aWNlIHwgaGVs" + - "bS1udmNmLWludm9jYXRpb24tc2VydmljZSB8IG52Y2YgfCBzZXJ2aWNlcyB8CnwgZ3JwYy1wcm94" + - "eSB8IGhlbG0tbnZjZi1ncnBjLXByb3h5IHwgbnZjZiB8IHNlcnZpY2VzIHwKfCBlc3MtYXBpIHwg" + - "aGVsbS1udmNmLWVzcy1hcGkgfCBlc3MgfCBzZXJ2aWNlcyB8Cnwgbm90YXJ5LXNlcnZpY2UgfCBo" + - "ZWxtLW52Y2Ytbm90YXJ5LXNlcnZpY2UgfCBudmNmIHwgc2VydmljZXMgfAp8IHJldmFsIHwgaGVs" + - "bS1yZXZhbCB8IG52Y2YgfCBzZXJ2aWNlcyB8CnwgbGxtLXJlcXVlc3Qtcm91dGVyIHwgbnZjZi9o" + - "ZWxtLW52Y2YtbGxtLXJlcXVlc3Qtcm91dGVyIHwgbnZjZiB8IHNlcnZpY2VzIHwKfCBsbG0tYXBp" + - "LWdhdGV3YXkgfCBudmNmL2hlbG0tbnZjZi1sbG0tYXBpLWdhdGV3YXkgfCBudmNmIHwgc2Vydmlj" + - "ZXMgfAp8IGFkbWluLWlzc3Vlci1wcm94eSB8IGhlbG0tYWRtaW4tdG9rZW4taXNzdWVyLXByb3h5" + - "IHwgYXBpLWtleXMgfCAobm8gcmVsZWFzZS1ncm91cCBsYWJlbCkgfAp8IGluZ3Jlc3MgfCBudmNm" + - "LWdhdGV3YXktcm91dGVzIHwgZW52b3ktZ2F0ZXdheS1zeXN0ZW0gfCBpbmdyZXNzIHwKCk1vc3Qg" + - "c2VydmljZXMgdXNlIGBpbmhlcml0OiBbe3RlbXBsYXRlOiBzZXJ2aWNlfV1gLiBMTE0gcmVsZWFz" + - "ZXMgdXNlIE9DSSBjaGFydHMgZnJvbSB0aGUgYG52Y2ZgIHJlcG9zaXRvcnkgd2l0aCBzdGFuZGFs" + - "b25lIGB2YWx1ZXM6IFsuLi9nbG9iYWwueWFtbC5nb3RtcGxdYCBibG9ja3M7IHRoZXkgYXJlIGdh" + - "dGVkIG9uIGBhZGRvbnMubGxtLmVuYWJsZWRgLiBgYWRtaW4taXNzdWVyLXByb3h5YCBhbmQgYGlu" + - "Z3Jlc3NgIGhhdmUgc3RhbmRhbG9uZSBgdmFsdWVzOmAgYmxvY2tzLgoKIyMjIDAzLW9ic2VydmFi" + - "aWxpdHkueWFtbC5nb3RtcGwKCnwgUmVsZWFzZSB8IENoYXJ0IHwgTmFtZXNwYWNlIHwgTGFiZWwg" + - "fAp8LS0tLS0tLS0tfC0tLS0tLS18LS0tLS0tLS0tLS18LS0tLS0tLXwKfCAob2JzZXJ2YWJpbGl0" + - "eSByZWxlYXNlcykgfCAodmFyaW91cykgfCBvYnNlcnZhYmlsaXR5IHwgb2JzZXJ2YWJpbGl0eSB8" + - "CgpHYXRlZCBvbiBvYnNlcnZhYmlsaXR5LXNwZWNpZmljIGZsYWdzIGluIHRoZSBlbnZpcm9ubWVu" + - "dCBmaWxlLiBTa2lwcGVkIGlmIGRpc2FibGVkLgoKIyMgVGVtcGxhdGUgSW5oZXJpdGFuY2UKCiMj" + - "IyBgPDw6ICpkZXBlbmRlbmN5YCAoWUFNTCBtZXJnZSkKClVzZWQgaW4gYDAxLWRlcGVuZGVuY2ll" + - "cy55YW1sLmdvdG1wbGAuIE1lcmdlcyB0aGUgdGVtcGxhdGUncyBwcm9wZXJ0aWVzIGludG8gdGhl" + - "IHJlbGVhc2UuCgoqKkdvdGNoYSoqOiBZQU1MIG1lcmdlIHJlcGxhY2VzIGxpc3RzLiBJZiB5b3Ug" + - "YWRkIGEgYHZhbHVlczpgIGtleSB0byB0aGUgcmVsZWFzZSwgaXQgKipyZXBsYWNlcyoqIHRoZSB0" + - "ZW1wbGF0ZSdzIGB2YWx1ZXM6YCBsaXN0IGVudGlyZWx5LiBZb3UgbXVzdCByZS1pbmNsdWRlIGFs" + - "bCB0ZW1wbGF0ZSB2YWx1ZXM6CgpJbiB0aGUgdGVtcGxhdGUgYmVsb3csIGA8cHJpdmF0ZS12YWx1" + - "ZXM+YCByZWZlcnMgdG8gdGhlIGBzZWNyZXRzL2AgZGlyZWN0b3J5IGF0IHRoZSBoZWxtZmlsZSBz" + - "dGFjayByb290LgoKYGBgeWFtbAojIFRlbXBsYXRlIGRlZmluZXM6CnRlbXBsYXRlczoKICBkZXBl" + - "bmRlbmN5OiAmZGVwZW5kZW5jeQogICAgY2hhcnQ6IG52Y2YvaGVsbS1udmNmLXt7IC5SZWxlYXNl" + - "Lk5hbWUgfX0KICAgIHZhbHVlczoKICAgICAgLSAuLi9nbG9iYWwueWFtbC5nb3RtcGwKICAgICAg" + - "LSAuLi88cHJpdmF0ZS12YWx1ZXM+L3t7IHJlcXVpcmVkRW52ICJIRUxNRklMRV9FTlYiIH19LXNl" + - "Y3JldHMueWFtbAoKIyBXaGVuIG92ZXJyaWRpbmcsIE1VU1QgcmUtaW5jbHVkZSBib3RoOgotIG5h" + - "bWU6IGNhc3NhbmRyYQogIDw8OiAqZGVwZW5kZW5jeQogIHZhbHVlczoKICAgIC0gLi4vZ2xvYmFs" + - "LnlhbWwuZ290bXBsICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg" + - "ICMgTXVzdCByZS1pbmNsdWRlCiAgICAtIC4uLzxwcml2YXRlLXZhbHVlcz4ve3sgcmVxdWlyZWRF" + - "bnYgIkhFTE1GSUxFX0VOViIgfX0tc2VjcmV0cy55YW1sICAgIyBNdXN0IHJlLWluY2x1ZGUKICAg" + - "IC0gY2Fzc2FuZHJhOiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg" + - "ICAgICAgICAgICAgICAjIFlvdXIgb3ZlcnJpZGUKICAgICAgICByZXNvdXJjZXM6CiAgICAgICAg" + - "ICBsaW1pdHM6CiAgICAgICAgICAgIG1lbW9yeTogODE5Mk1pCmBgYAoKIyMjIGBpbmhlcml0YCAo" + - "SGVsbWZpbGUgbmF0aXZlKQoKVXNlZCBpbiBgMDItY29yZS55YW1sLmdvdG1wbGAuIEhlbG1maWxl" + - "J3MgbmF0aXZlIGluaGVyaXRhbmNlIG1lY2hhbmlzbS4KCmBgYHlhbWwKLSBuYW1lOiBhcGkKICB2" + - "ZXJzaW9uOiAxLjYuMAogIG5hbWVzcGFjZTogbnZjZgogIGluaGVyaXQ6CiAgICAtIHRlbXBsYXRl" + - "OiBzZXJ2aWNlCmBgYAoKV2hlbiBhZGRpbmcgYHZhbHVlczpgIHRvIGFuIGluaGVyaXRlZCByZWxl" + - "YXNlLCB5b3UgYWxzbyBuZWVkIHRvIHJlLWluY2x1ZGUgdGhlIHRlbXBsYXRlJ3MgdmFsdWVzIGZp" + - "bGVzIHNpbmNlIGB2YWx1ZXNgIGlzIGEgbGlzdCB0aGF0IGdldHMgcmVwbGFjZWQuCgojIyBWYWx1" + - "ZXMgUHJlY2VkZW5jZQoKRnJvbSBsb3dlc3QgdG8gaGlnaGVzdCBwcmlvcml0eToKCjEuIGBlbnZp" + - "cm9ubWVudHMvYmFzZS55YW1sYCAtLSBkZWZhdWx0cyBzaGFyZWQgYWNyb3NzIGFsbCBlbnZpcm9u" + - "bWVudHMKMi4gYGVudmlyb25tZW50cy88ZW52Pi55YW1sYCAtLSBwZXItZW52aXJvbm1lbnQgb3Zl" + - "cnJpZGVzCjMuIGBnbG9iYWwueWFtbC5nb3RtcGxgIC0tIEdvIHRlbXBsYXRlIHByb2Nlc3Npbmcg" + - "KGNvbnN0cnVjdHMgY2hhcnQtc3BlY2lmaWMgc3RydWN0dXJlKQo0LiBgPHByaXZhdGUtdmFsdWVz" + - "Pi88ZW52Pi1zZWNyZXRzLnlhbWxgIC0tIHNlbnNpdGl2ZSB2YWx1ZXMKNS4gSW5saW5lIGB2YWx1" + - "ZXM6YCBibG9ja3Mgb24gcmVsZWFzZXMgLS0gaGlnaGVzdCBwcmVjZWRlbmNlCgojIyBXaGF0IGds" + - "b2JhbC55YW1sLmdvdG1wbCBQYXNzZXMgVGhyb3VnaAoKYGdsb2JhbC55YW1sLmdvdG1wbGAgcmVh" + - "ZHMgZnJvbSBgLlZhbHVlc2AgKHRoZSBtZXJnZWQgZW52aXJvbm1lbnQgKyBlbnYtc3BlY2lmaWMg" + - "WUFNTCkgYW5kIGNvbnN0cnVjdHMgY2hhcnQtc3BlY2lmaWMgdmFsdWVzLiBJdCBvbmx5IHBhc3Nl" + - "cyB0aHJvdWdoIGtleXMgaXQgZXhwbGljaXRseSByZWZlcmVuY2VzOgoKIyMjIENhc3NhbmRyYQot" + - "IGBjYXNzYW5kcmEucmVwbGljYUNvdW50YAotIGBjYXNzYW5kcmEuaW1hZ2UuKmAgKHJlZ2lzdHJ5" + - "LCByZXBvc2l0b3J5KQotIGBjYXNzYW5kcmEubWlncmF0aW9ucy5pbWFnZS4qYAotIGBjYXNzYW5k" + - "cmEucGVyc2lzdGVuY2Uuc2l6ZWAKLSBgY2Fzc2FuZHJhLm5vZGVTZWxlY3RvcmAgKGlmIGBnbG9i" + - "YWwubm9kZVNlbGVjdG9ycy5lbmFibGVkYCkKLSBgY2Fzc2FuZHJhLmdsb2JhbC5kZWZhdWx0U3Rv" + - "cmFnZUNsYXNzYAoKIyMjIE5BVFMKLSBgbmF0cy5jb250YWluZXIuaW1hZ2UuKmAKLSBgbmF0cy5y" + - "ZWxvYWRlci5pbWFnZS4qYAotIGBuYXRzLm5hdHNCb3guY29udGFpbmVyLmltYWdlLipgCi0gYG5h" + - "dHMuY29uZmlnLmpldHN0cmVhbS5maWxlU3RvcmUucHZjLnN0b3JhZ2VDbGFzc05hbWVgCi0gYG5h" + - "dHMucG9kVGVtcGxhdGUubWVyZ2Uuc3BlYy5ub2RlU2VsZWN0b3JgIChpZiBlbmFibGVkKQoKIyMj" + - "IE9wZW5CYW8KLSBgb3BlbmJhby5taWdyYXRpb25zLmltYWdlLipgIGFuZCBgb3BlbmJhby5taWdy" + - "YXRpb25zLmVudmAKLSBgb3BlbmJhby5pbmplY3Rvci5pbWFnZS4qYAotIGBvcGVuYmFvLnNlcnZl" + - "ci5pbWFnZS4qYAotIGBvcGVuYmFvLnNlcnZlci5kYXRhU3RvcmFnZS4qYAotIE5vZGUgc2VsZWN0" + - "b3JzIChpZiBlbmFibGVkKQoKIyMjIFNlcnZpY2VzIChBUEksIFNJUywgZXRjLikKLSBgPHNlcnZp" + - "Y2U+LmltYWdlLipgIChyZWdpc3RyeSwgcmVwb3NpdG9yeSkKLSBgPHNlcnZpY2U+Lm5vZGVTZWxl" + - "Y3RvcmAgKGlmIGVuYWJsZWQpCi0gYDxzZXJ2aWNlPi5lbnYuKmAgKG9ic2VydmFiaWxpdHkgc2V0" + - "dGluZ3MpCgojIyMgTExNIEZ1bmN0aW9uIEVuYWJsZW1lbnQKCkVuYWJsZSB0aGUgTExNIGFkZG9u" + - "IGJlZm9yZSBjcmVhdGluZyBvciBpbnZva2luZyBmdW5jdGlvbnMgd2l0aApgZnVuY3Rpb25UeXBl" + - "OiAiTExNImAuIFRoZSBhZGRvbiBkZXBsb3lzIGBsbG0tcmVxdWVzdC1yb3V0ZXJgIGFuZApgbGxt" + - "LWFwaS1nYXRld2F5YCwgYWRkcyB0aGUgYGxsbS5pbnZvY2F0aW9uLjxkb21haW4+YCByb3V0ZSB3" + - "aGVuIEdhdGV3YXkgQVBJCmluZ3Jlc3MgaXMgZW5hYmxlZCwgYW5kIGNvbmZpZ3VyZXMgd29ya2Vy" + - "cyB0byB1c2UgdGhlIExMTSBzaWRlY2FyLiBUaGUgSGVsbWZpbGUKY29uZGl0aW9uIGlzIGBhZGRv" + - "bnMubGxtLmVuYWJsZWRgLiBEbyBub3QgdXNlIHRoZSBvYnNvbGV0ZSBgbGxtLmVuYWJsZWRgIHBh" + - "dGguCgpGb3IgYSBzaW5nbGUtbm9kZSBpc29sYXRlZCB0ZXN0IGNsdXN0ZXIsIGFkZCB0aGlzIGNv" + - "bmZpZ3VyYXRpb24gdG8KYGVudmlyb25tZW50cy88ZW52Pi55YW1sYCBiZWZvcmUgYXBwbHlpbmcg" + - "dGhlIHN0YWNrOgoKYGBgeWFtbAphZGRvbnM6CiAgbGxtOgogICAgZW5hYmxlZDogdHJ1ZQogICAg" + - "Z2F0ZXdheToKICAgICAgcmVwbGljYUNvdW50OiAxCiAgICAgIGF1dGg6CiAgICAgICAgZ3JwY0lu" + - "c2VjdXJlOiB0cnVlCiAgICAgIG1ldHJpY3M6CiAgICAgICAgc2VydmljZU1vbml0b3I6CiAgICAg" + - "ICAgICBlbmFibGVkOiBmYWxzZQogICAgcmVxdWVzdFJvdXRlcjoKICAgICAgcmVwbGljYUNvdW50" + - "OiAxCiAgICAgIG1ldHJpY3M6CiAgICAgICAgc2VydmljZU1vbml0b3I6CiAgICAgICAgICBlbmFi" + - "bGVkOiBmYWxzZQoKYWdlbnRDb25maWc6CiAgbWVyZ2VDb25maWc6IHwKICAgIGNsdXN0ZXI6CiAg" + - "ICAgIHZhbGlkYXRpb25Qb2xpY3k6CiAgICAgICAgbmFtZTogVW5yZXN0cmljdGVkCiAgICB3b3Jr" + - "bG9hZDoKICAgICAgc3RhcmdhdGVRVUlDSW5zZWN1cmU6IHRydWUKYGBgCgpVc2UgYHJlcGxpY2FD" + - "b3VudDogMWAgb25seSBmb3IgbG9jYWwgb3Igc2luZ2xlLW5vZGUgdGVzdCBjbHVzdGVycy4gRm9y" + - "IHNoYXJlZApvciBwcm9kdWN0aW9uIGNsdXN0ZXJzLCB1c2UgdGhlIHJlcXVpcmVkIHJlcGxpY2Eg" + - "Y291bnQgYW5kIFRMUy1jYXBhYmxlIHNlcnZpY2UKY29uZmlndXJhdGlvbi4gYGFkZG9ucy5sbG0u" + - "Z2F0ZXdheS5hdXRoLmdycGNJbnNlY3VyZWAgYW5kCmB3b3JrbG9hZC5zdGFyZ2F0ZVFVSUNJbnNl" + - "Y3VyZWAgZW5hYmxlIHBsYWludGV4dCB0cmFuc3BvcnRzLiBEbyBub3QgdXNlIHRoZW0gaW4KcHJv" + - "ZHVjdGlvbi4KClRoZSByZXF1ZXN0IHJvdXRlciB1c2VzIGBwb3dlci1vZi10d29gIHdoZW4gbm8g" + - "bG9hZC1iYWxhbmNlciBjb25maWd1cmF0aW9uIGlzCnNldC4gQ29uZmlndXJlIG90aGVyIHJvdXRp" + - "bmcgbWV0aG9kcyB3aXRoIHRoZQpbTExNIFJlcXVlc3QgUm91dGVyIExvYWQgQmFsYW5jaW5nXSho" + - "dHRwczovL2dpdGh1Yi5jb20vTlZJRElBL252Y2YvYmxvYi9tYWluL2RvY3MvdXNlci9sbG0tcmVx" + - "dWVzdC1yb3V0ZXItbG9hZC1iYWxhbmNpbmcubWQpCmd1aWRlLgoKSWYgdGhlIHNpZGVjYXIgaW1h" + - "Z2UgaXMgbWlycm9yZWQgb3V0c2lkZSB0aGUgc3RhY2sncyBkZWZhdWx0IGltYWdlIHJlZ2lzdHJ5" + - "IGFuZApyZXBvc2l0b3J5LCBzZXQgdGhlIGdlbmVyYXRlZCB3b3JrZXIgc2lkZWNhciBpbWFnZSBl" + - "eHBsaWNpdGx5OgoKYGBgeWFtbAphcGk6CiAgcmVtb3RlQ29uZmlnOgogICAgY29uZmlnRGF0YToK" + - "ICAgICAgbnZjZjoKICAgICAgICBzaWRlY2FyczoKICAgICAgICAgIGxsbS1yb3V0ZXItY2xpZW50" + - "LWltYWdlOiA8cmVnaXN0cnk+LzxyZXBvc2l0b3J5Pi9weWxvbjowLjE0LjEKYGBgCgpUaGUgbGVn" + - "YWN5IGBhcGkuZW52Lk5WQ0ZfU0lERUNBUlNfTExNX1JPVVRFUl9DTElFTlRfSU1BR0VgIHBhdGgg" + - "aXMgZGVwcmVjYXRlZC4KVGhlIHN0YWNrIHRyYW5zbGF0ZXMgaXQgZm9yIG9uZSBjb21wYXRpYmls" + - "aXR5IHdpbmRvdywgYnV0IG5ldyBjb25maWd1cmF0aW9ucwptdXN0IHVzZSB0aGUgcmVtb3RlLWNv" + - "bmZpZyBwYXRoLiBDb25mbGljdGluZyB2YWx1ZXMgZmFpbCByZW5kZXJpbmcuCgpSZW5kZXIgYW5k" + - "IGFwcGx5IHRoZSB1cGRhdGVkIGNvbnRyb2wtcGxhbmUgZW52aXJvbm1lbnQsIHRoZW4gcmVmcmVz" + - "aCBldmVyeQpyZWdpc3RlcmVkIGNvbXB1dGUgcGxhbmUgdXNpbmcgdGhlIHNhbWUgaGFuZG9mZiB1" + - "c2VkIGZvciBpdHMgaW5zdGFsbGF0aW9uIHNvCk5WQ0EgcmVjZWl2ZXMgYGFnZW50Q29uZmlnLm1l" + - "cmdlQ29uZmlnYDoKCmBgYGJhc2gKSEVMTUZJTEVfRU5WPTxlbnY+IGhlbG1maWxlIHRlbXBsYXRl" + - "CkhFTE1GSUxFX0VOVj08ZW52PiBoZWxtZmlsZSBzeW5jCmBgYAoKVXNlIHRoZSBjb21wbGV0ZSBj" + - "b21wdXRlLXBsYW5lIGluc3RhbGwgY29tbWFuZCBmcm9tCltTcGxpdCBDb21wdXRlLVBsYW5lIElu" + - "c3RhbGxhdGlvbl0oY29tcHV0ZS1wbGFuZS1pbnN0YWxsYXRpb24ubWQpLiBBCkNMSS1wcm9maWxl" + - "IGluc3RhbGxhdGlvbiBtdXN0IHJlbWFpbiBwcm9maWxlLWRyaXZlbjsgYSBIZWxtZmlsZSBpbnN0" + - "YWxsYXRpb24KbXVzdCByZW1haW4gdmFsdWVzLWRyaXZlbi4KCkV4aXN0aW5nIExMTSBmdW5jdGlv" + - "biB2ZXJzaW9ucyByZXRhaW4gdGhlIHdvcmtlci1zaWRlY2FyIGltYWdlIG1ldGFkYXRhCmNhcHR1" + - "cmVkIHdoZW4gdGhlIHZlcnNpb24gaXMgY3JlYXRlZC4gUmVwbGFjaW5nIHBvZHMgb3IgcmVkZXBs" + - "b3lpbmcgdGhlIHNhbWUKdmVyc2lvbiBkb2VzIG5vdCBhcHBseSBhIG5ldyBQeWxvbiBpbWFnZS4g" + - "QWZ0ZXIgdGhlIGNvbnRyb2wtcGxhbmUgdXBkYXRlLApjcmVhdGUgYW5kIGRlcGxveSBhIG5ldyBm" + - "dW5jdGlvbiB2ZXJzaW9uLiBWZXJpZnkgdGhlIGNvbnRyb2wgcGxhbmUsIHJvdXRlLCBhbmQKd29y" + - "a2VyIHNpZGVjYXI6CgpgYGBiYXNoCmt1YmVjdGwgZ2V0IGRlcGxveSAtbiBudmNmIGxsbS1hcGkt" + - "Z2F0ZXdheQprdWJlY3RsIGdldCBzdGF0ZWZ1bHNldCAtbiBudmNmIGxsbS1yZXF1ZXN0LXJvdXRl" + - "cgprdWJlY3RsIGdldCBwb2RzIC1uIG52Y2YgfCBncmVwIC1FICdsbG0tYXBpLWdhdGV3YXl8bGxt" + - "LXJlcXVlc3Qtcm91dGVyJwprdWJlY3RsIGdldCBodHRwcm91dGUgLUEgfCBncmVwIGxsbQprdWJl" + - "Y3RsIC1uIG52Y2YtYmFja2VuZCBnZXQgcG9kIDxmdW5jdGlvbi1wb2Q+IFwKICAtbyBqc29ucGF0" + - "aD0ne3JhbmdlIC5zcGVjLmNvbnRhaW5lcnNbPyhALm5hbWU9PSJsbG0td29ya2VyIildLmFyZ3Nb" + - "Kl19ey59eyJcXG4ifXtlbmR9JwpgYGAKCkZvciBsb2NhbCBwbGFpbnRleHQgY2x1c3RlcnMsIHRo" + - "ZSBgbGxtLXdvcmtlcmAgYXJncyBtdXN0IGluY2x1ZGUKYC0tcXVpYy1pbnNlY3VyZWAuCgpGb3Ig" + - "bG9hZC1iYWxhbmNlciBzY2hlbWEgYW5kIGFsZ29yaXRobSBiZWhhdmlvciwgc2VlIHRoZQpbU3Rh" + - "cmdhdGUgY29uZmlndXJhdGlvbiBndWlkZV0oaHR0cHM6Ly9naXRodWIuY29tL05WSURJQS9udmNm" + - "L2Jsb2IvbWFpbi9zcmMvbGlicmFyaWVzL3J1c3Qvc3RhcmdhdGUvZG9jcy9sb2FkLWJhbGFuY2Vy" + - "LWNvbmZpZ3VyYXRpb24ubWQpLgoKIyMgSGVsbWZpbGUgU2VsZWN0b3JzCgpUYXJnZXQgc3BlY2lm" + - "aWMgcmVsZWFzZXMgb3IgZ3JvdXBzOgoKYGBgYmFzaAojIEJ5IHJlbGVhc2UgZ3JvdXAKSEVMTUZJ" + - "TEVfRU5WPTxlbnY+IGhlbG1maWxlIC0tc2VsZWN0b3IgcmVsZWFzZS1ncm91cD1kZXBlbmRlbmNp" + - "ZXMgc3luYwpIRUxNRklMRV9FTlY9PGVudj4gaGVsbWZpbGUgLS1zZWxlY3RvciByZWxlYXNlLWdy" + - "b3VwPXNlcnZpY2VzIHN5bmMKSEVMTUZJTEVfRU5WPTxlbnY+IGhlbG1maWxlIC0tc2VsZWN0b3Ig" + - "cmVsZWFzZS1ncm91cD1pbmdyZXNzIHN5bmMKSEVMTUZJTEVfRU5WPTxlbnY+IGhlbG1maWxlIC0t" + - "c2VsZWN0b3IgcmVsZWFzZS1ncm91cD1vYnNlcnZhYmlsaXR5IHN5bmMKCiMgQnkgcmVsZWFzZSBu" + - "YW1lCkhFTE1GSUxFX0VOVj08ZW52PiBoZWxtZmlsZSAtLXNlbGVjdG9yIG5hbWU9Y2Fzc2FuZHJh" + - "IHN5bmMKSEVMTUZJTEVfRU5WPTxlbnY+IGhlbG1maWxlIC0tc2VsZWN0b3IgbmFtZT1hZG1pbi1p" + - "c3N1ZXItcHJveHkgc3luYwpIRUxNRklMRV9FTlY9PGVudj4gaGVsbWZpbGUgLS1zZWxlY3RvciBu" + - "YW1lPWxsbS1yZXF1ZXN0LXJvdXRlciBzeW5jCkhFTE1GSUxFX0VOVj08ZW52PiBoZWxtZmlsZSAt" + - "LXNlbGVjdG9yIG5hbWU9bGxtLWFwaS1nYXRld2F5IHN5bmMKCiMgVGVtcGxhdGUgb25seSAoZHJ5" + - "IHJ1bikKSEVMTUZJTEVfRU5WPTxlbnY+IGhlbG1maWxlIC0tc2VsZWN0b3IgbmFtZT1jYXNzYW5k" + - "cmEgdGVtcGxhdGUKCiMgRGVzdHJveSBhIHNpbmdsZSByZWxlYXNlCkhFTE1GSUxFX0VOVj08ZW52" + - "PiBoZWxtZmlsZSAtLXNlbGVjdG9yIG5hbWU9Y2Fzc2FuZHJhIGRlc3Ryb3kKYGBgCgpOb3RlOiBg" + - "YWRtaW4taXNzdWVyLXByb3h5YCBoYXMgbm8gYHJlbGVhc2UtZ3JvdXBgIGxhYmVsLiBVc2UgYC0t" + - "c2VsZWN0b3IgbmFtZT1hZG1pbi1pc3N1ZXItcHJveHlgLgpQSwcIle7q7yEpAAAhKQAAUEsDBBQA" + - "CAAAAAAAIQAAAAAAAAAAAAAAAAA/AAkAZGF0YS9udmNmLXNlbGYtbWFuYWdlZC1pbnN0YWxsYXRp" + - "b24vcmVmZXJlbmNlcy9udmNmLXVpLWFkZG9uLm1kVVQFAAEAps4SIyBOVkNGIFVJIEFkZG9uCgpO" + - "VkNGIFVJIGlzIGFuIG9wdGlvbmFsLCBjdXN0b21lci1mYWNpbmcgTlZDRiBhZG1pbi1wYW5lbCBV" + - "SS4gSXQgaXMgZGlzYWJsZWQgYnkKZGVmYXVsdCBhbmQgYXZhaWxhYmxlIG9ubHkgaW4gc3RhY2sg" + - "cGFja2FnZXMgdGhhdCBpbmNsdWRlIHRoZSBOVkNGIFVJIGFkZG9uLgoKIyMgV2hlbiB0byBlbmFi" + - "bGUKCkVuYWJsZSBOVkNGIFVJIG9ubHkgd2hlbiB5b3UgbmVlZCB0aGUgYWRtaW4tcGFuZWwgVUkg" + - "YW5kIHlvdXIgZXh0cmFjdGVkIHN0YWNrCnBhY2thZ2UgaW5jbHVkZXMgdGhlIGFkZG9uLiBJZiB0" + - "aGUgcGFja2FnZSBkb2VzIG5vdCBjb250YWluIGEgYG52Y2YtdWlgIHJlbGVhc2UKYW5kIGBudmNm" + - "VWlgIHJvdXRlIHZhbHVlcywgc2tpcCB0aGUgYWRkb24gdW50aWwgeW91IHVzZSBhIHBhY2thZ2Ug" + - "dGhhdCBpbmNsdWRlcwp0aGVtLgoKIyMgRW5hYmxlIHRoZSBhZGRvbgoKRW5hYmxlIGl0IGluIGBl" + - "bnZpcm9ubWVudHMvPGVudi1uYW1lPi55YW1sYDoKCmBgYHlhbWwKYWRkb25zOgogIG52Y2ZVaToK" + - "ICAgIGVuYWJsZWQ6IHRydWUKYGBgCgojIyBDcmVhdGUgbmFtZXNwYWNlIGFuZCBpbWFnZSBwdWxs" + - "IHNlY3JldAoKQ3JlYXRlIHRoZSBuYW1lc3BhY2UsIGFuZCBhbiBpbWFnZSBwdWxsIHNlY3JldCBv" + - "bmx5IGlmIHB1bGxpbmcgZnJvbSBhIHByaXZhdGUKcmVnaXN0cnk6CgpgYGBiYXNoCmt1YmVjdGwg" + - "Y3JlYXRlIG5hbWVzcGFjZSBudmNmLXVpIC0tZHJ5LXJ1bj1jbGllbnQgLW8geWFtbCB8IGt1YmVj" + - "dGwgYXBwbHkgLWYgLQoKIyBPbmx5IGlmIHB1bGxpbmcgZnJvbSBhIHByaXZhdGUgcmVnaXN0cnkg" + - "KGUuZy4sIE5HQyBudmNyLmlvKQpleHBvcnQgTkdDX0FQSV9LRVk9Ijx5b3VyLWtleT4iCmt1YmVj" + - "dGwgY3JlYXRlIHNlY3JldCBkb2NrZXItcmVnaXN0cnkgbnZjci1jcmVkcyBcCiAgLS1kb2NrZXIt" + - "c2VydmVyPW52Y3IuaW8gXAogIC0tZG9ja2VyLXVzZXJuYW1lPSckb2F1dGh0b2tlbicgXAogIC0t" + - "ZG9ja2VyLXBhc3N3b3JkPSIkTkdDX0FQSV9LRVkiIFwKICAtLW5hbWVzcGFjZT1udmNmLXVpIFwK" + - "ICAtLWRyeS1ydW49Y2xpZW50IC1vIHlhbWwgfCBrdWJlY3RsIGFwcGx5IC1mIC0KYGBgCgpUaGUg" + - "ZGVmYXVsdCByb3V0ZSBob3N0IGlzIGBudmNmLXVpLjxkb21haW4+YCBhbmQgdGhlIGJhY2tlbmQg" + - "aXMKYG52Y2YtdWkubnZjZi11aTo4MzAwYC4KCiMjIEFwcGx5IHRoZSBzZXJ2aWNlIGFuZCByb3V0" + - "ZQoKQWZ0ZXIgY29uZmlybWluZyB0aGUgcGFja2FnZSBpbmNsdWRlcyB0aGUgYG52Y2YtdWlgIHJl" + - "bGVhc2UsIHByZXZpZXcgYW5kIGFwcGx5CnRoZSBzZXJ2aWNlIGFuZCByb3V0ZToKCmBgYGJhc2gK" + - "SEVMTUZJTEVfRU5WPTxlbnYtbmFtZT4gaGVsbWZpbGUgLS1zZWxlY3RvciBuYW1lPW52Y2YtdWkg" + - "dGVtcGxhdGUKSEVMTUZJTEVfRU5WPTxlbnYtbmFtZT4gaGVsbWZpbGUgLS1zZWxlY3RvciBuYW1l" + - "PW52Y2YtdWkgc3luYwpIRUxNRklMRV9FTlY9PGVudi1uYW1lPiBoZWxtZmlsZSAtLXNlbGVjdG9y" + - "IHJlbGVhc2UtZ3JvdXA9aW5ncmVzcyBzeW5jCmBgYAoKIyMgVmVyaWZ5CgpWZXJpZnkgdGhlIHJv" + - "dXRlIG9ubHkgd2hlbiB0aGUgYWRkb24gaXMgcHJlc2VudCBhbmQgZW5hYmxlZDoKCmBgYGJhc2gK" + - "a3ViZWN0bCBnZXQgZGVwbG95LHN2YyAtbiBudmNmLXVpCmt1YmVjdGwgZ2V0IGh0dHByb3V0ZSAt" + - "QSB8IGdyZXAgLWkgbnZjZi11aQpjdXJsIC1pIC1IICJIb3N0OiBudmNmLXVpLjxkb21haW4+IiAi" + - "aHR0cDovLzxnYXRld2F5LWFkZHJlc3M+L3N0YXR1cyIKYGBgCgojIyBTZWN1cml0eQoKVGhlIE5W" + - "Q0YgVUkgYWRtaW4gcGFuZWwgaXMgY3VycmVudGx5IHVuYXV0aGVudGljYXRlZC4gRG8gbm90IGV4" + - "cG9zZSBpdCB0byB0aGUKcHVibGljIGludGVybmV0LiBSZXN0cmljdCBhY2Nlc3MgdG8gYSB0cnVz" + - "dGVkIG5ldHdvcmssIFZQTiwgb3IgYW4gYXV0aGVudGljYXRpbmcKcHJveHkgaW4gZnJvbnQgb2Yg" + - "dGhlIGBudmNmLXVpYCByb3V0ZS4KUEsHCDj5J6+5BwAAuQcAAFBLAwQUAAgAAAAAACEAAAAAAAAA" + - "AAAAAAAAPgAJAGRhdGEvbnZjZi1zZWxmLW1hbmFnZWQtaW5zdGFsbGF0aW9uL3JlZmVyZW5jZXMv" + - "cHVsbC1zZWNyZXRzLm1kVVQFAAEAps4SIyBJbWFnZSBQdWxsIFNlY3JldHMgUmVmZXJlbmNlCgoj" + - "IyBPdmVydmlldwoKV2hlbiBwdWxsaW5nIE5WQ0YgaW1hZ2VzIGZyb20gYSBwcml2YXRlIHJlZ2lz" + - "dHJ5IChmb3IgZXhhbXBsZSwgTkdDCmBudmNyLmlvYCksIEt1YmVybmV0ZXMgbmVlZHMgYGltYWdl" + - "UHVsbFNlY3JldHNgIG9uIGV2ZXJ5IHBvZC4gQ29udHJvbC1wbGFuZSBhbmQKY29tcHV0ZS1wbGFu" + - "ZSBjcmVkZW50aWFscyBhcmUgY29uZmlndXJlZCBpbiB0aGVpciBvd24gY2x1c3RlciBjb250ZXh0" + - "cy4gRG8gbm90CnVzZSBvbmUgbWl4ZWQgbmFtZXNwYWNlIGxpc3QuCgpUaGUgcmVjb21tZW5kZWQg" + - "Y29udHJvbC1wbGFuZSBhcHByb2FjaCB1c2VzIEt5dmVybm8gdG8gaW5qZWN0IHRoZSBzZWNyZXQg" + - "aW50bwpjb250cm9sLXBsYW5lIHBvZHMgYXQgYWRtaXNzaW9uIHRpbWUuIFRoZSBjb21wdXRlLXBs" + - "YW5lIGNoYXJ0IGFuZCBvcGVyYXRvciB1c2UKdGhlIHNlY3JldCBpbiBgbnZjYS1vcGVyYXRvcmAg" + - "YW5kIG1pcnJvciBpdCB0byBgbnZjYS1zeXN0ZW1gLgoKIyMgS3l2ZXJubyBBcHByb2FjaCAoUmVj" + - "b21tZW5kZWQpCgojIyMgMS4gSW5zdGFsbCBLeXZlcm5vCgpgYGBiYXNoCmhlbG0gcmVwbyBhZGQg" + - "a3l2ZXJubyBodHRwczovL2t5dmVybm8uZ2l0aHViLmlvL2t5dmVybm8vCmhlbG0gcmVwbyB1cGRh" + - "dGUKaGVsbSBpbnN0YWxsIGt5dmVybm8ga3l2ZXJuby9reXZlcm5vIC1uIGt5dmVybm8gLS1jcmVh" + - "dGUtbmFtZXNwYWNlIFwKICAtLWt1YmUtY29udGV4dCA8Y29udHJvbC1wbGFuZS1jb250ZXh0Pgpg" + - "YGAKCiMjIyAyLiBDcmVhdGUgY29udHJvbC1wbGFuZSBwdWxsIHNlY3JldHMKCmBgYGJhc2gKZXhw" + - "b3J0IE5HQ19BUElfS0VZPSI8eW91ci1uZ2MtYXBpLWtleT4iCgpmb3IgbnMgaW4gY2Fzc2FuZHJh" + - "LXN5c3RlbSBuYXRzLXN5c3RlbSBudmNmIGFwaS1rZXlzIGVzcyBzaXMgdmF1bHQtc3lzdGVtIGNl" + - "cnQtbWFuYWdlcjsgZG8KICBrdWJlY3RsIC0tY29udGV4dCA8Y29udHJvbC1wbGFuZS1jb250ZXh0" + - "PiBjcmVhdGUgbmFtZXNwYWNlICIkbnMiIFwKICAgIC0tZHJ5LXJ1bj1jbGllbnQgLW8geWFtbCB8" + - "IGt1YmVjdGwgLS1jb250ZXh0IDxjb250cm9sLXBsYW5lLWNvbnRleHQ+IGFwcGx5IC1mIC0KZG9u" + - "ZQoKZm9yIG5zIGluIGNhc3NhbmRyYS1zeXN0ZW0gbmF0cy1zeXN0ZW0gbnZjZiBhcGkta2V5cyBl" + - "c3Mgc2lzIHZhdWx0LXN5c3RlbSBjZXJ0LW1hbmFnZXI7IGRvCiAga3ViZWN0bCAtLWNvbnRleHQg" + - "PGNvbnRyb2wtcGxhbmUtY29udGV4dD4gY3JlYXRlIHNlY3JldCBkb2NrZXItcmVnaXN0cnkgbnZj" + - "ci1jcmVkcyBcCiAgICAtLWRvY2tlci1zZXJ2ZXI9bnZjci5pbyBcCiAgICAtLWRvY2tlci11c2Vy" + - "bmFtZT0nJG9hdXRodG9rZW4nIFwKICAgIC0tZG9ja2VyLXBhc3N3b3JkPSIkTkdDX0FQSV9LRVki" + - "IFwKICAgIC0tbmFtZXNwYWNlPSIkbnMiIFwKICAgIC0tZHJ5LXJ1bj1jbGllbnQgLW8geWFtbCB8" + - "IGt1YmVjdGwgLS1jb250ZXh0IDxjb250cm9sLXBsYW5lLWNvbnRleHQ+IGFwcGx5IC1mIC0KZG9u" + - "ZQpgYGAKCkZvciBub24tTkdDIHJlZ2lzdHJpZXMsIHJlcGxhY2UgYC0tZG9ja2VyLXNlcnZlcmAs" + - "IGAtLWRvY2tlci11c2VybmFtZWAsIGFuZCBgLS1kb2NrZXItcGFzc3dvcmRgLgoKIyMjIDMuIEFw" + - "cGx5IEt5dmVybm8gQ2x1c3RlclBvbGljeQoKYGBgeWFtbAphcGlWZXJzaW9uOiBreXZlcm5vLmlv" + - "L3YxCmtpbmQ6IENsdXN0ZXJQb2xpY3kKbWV0YWRhdGE6CiAgbmFtZTogbnZjZi1hZGQtaW1hZ2Vw" + - "dWxsc2VjcmV0cwpzcGVjOgogIGJhY2tncm91bmQ6IGZhbHNlCiAgcnVsZXM6CiAgICAtIG5hbWU6" + - "IGFkZC1pbWFnZXB1bGxzZWNyZXQtdG8tbnZjZi1wb2RzCiAgICAgIG1hdGNoOgogICAgICAgIGFu" + - "eToKICAgICAgICAtIHJlc291cmNlczoKICAgICAgICAgICAga2luZHM6CiAgICAgICAgICAgIC0g" + - "UG9kCiAgICAgICAgICAgIG5hbWVzcGFjZXM6CiAgICAgICAgICAgIC0gIm52Y2YiCiAgICAgICAg" + - "ICAgIC0gImFwaS1rZXlzIgogICAgICAgICAgICAtICJzaXMiCiAgICAgICAgICAgIC0gImVzcyIK" + - "ICAgICAgICAgICAgLSAibmF0cy1zeXN0ZW0iCiAgICAgICAgICAgIC0gImNhc3NhbmRyYS1zeXN0" + - "ZW0iCiAgICAgICAgICAgIC0gInZhdWx0LXN5c3RlbSIKICAgICAgICAgICAgLSAiY2VydC1tYW5h" + - "Z2VyIgogICAgICBtdXRhdGU6CiAgICAgICAgcGF0Y2hTdHJhdGVnaWNNZXJnZToKICAgICAgICAg" + - "IG1ldGFkYXRhOgogICAgICAgICAgICBhbm5vdGF0aW9uczoKICAgICAgICAgICAgICBudmNmLm52" + - "aWRpYS5jb20vaW1hZ2VwdWxsc2VjcmV0LWluamVjdGVkLWJ5OiBreXZlcm5vCiAgICAgICAgICBz" + - "cGVjOgogICAgICAgICAgICBpbWFnZVB1bGxTZWNyZXRzOgogICAgICAgICAgICAtIG5hbWU6IG52" + - "Y3ItY3JlZHMKYGBgCgpgYGBiYXNoCmt1YmVjdGwgLS1jb250ZXh0IDxjb250cm9sLXBsYW5lLWNv" + - "bnRleHQ+IGFwcGx5IFwKICAtZiBreXZlcm5vLWltYWdlcHVsbHNlY3JldC1wb2xpY3kueWFtbApg" + - "YGAKCiMjIyA0LiBJbnN0YWxsIHRoZSBjb250cm9sIHBsYW5lCgpDb250aW51ZSB3aXRoIHRoZSBz" + - "ZWxlY3RlZCBjb250cm9sLXBsYW5lIGluc3RhbGxhdGlvbiBpbgpbU3BsaXQgQ29tcHV0ZS1QbGFu" + - "ZSBJbnN0YWxsYXRpb25dKGNvbXB1dGUtcGxhbmUtaW5zdGFsbGF0aW9uLm1kKS4gTm8KY29udHJv" + - "bC1wbGFuZSBoZWxtZmlsZSBtb2RpZmljYXRpb25zIGFyZSBuZWVkZWQuIEt5dmVybm8gaW5qZWN0" + - "cyB0aGUgcHVsbApzZWNyZXQgaW50byBuZXcgY29udHJvbC1wbGFuZSBwb2RzLgoKIyMgQ29tcHV0" + - "ZS1QbGFuZSBTZWNyZXQKCkNyZWF0ZSB0aGUgc2VjcmV0IG9ubHkgaW4gYG52Y2Etb3BlcmF0b3Jg" + - "IG9uIHRoZSBjb21wdXRlIGNsdXN0ZXI6CgpgYGBiYXNoCmt1YmVjdGwgLS1jb250ZXh0IDxjb21w" + - "dXRlLXBsYW5lLWNvbnRleHQ+IGNyZWF0ZSBuYW1lc3BhY2UgbnZjYS1vcGVyYXRvciBcCiAgLS1k" + - "cnktcnVuPWNsaWVudCAtbyB5YW1sIHwgXAogIGt1YmVjdGwgLS1jb250ZXh0IDxjb21wdXRlLXBs" + - "YW5lLWNvbnRleHQ+IGFwcGx5IC1mIC0KCmt1YmVjdGwgLS1jb250ZXh0IDxjb21wdXRlLXBsYW5l" + - "LWNvbnRleHQ+IGNyZWF0ZSBzZWNyZXQgZG9ja2VyLXJlZ2lzdHJ5IG52Y3ItY3JlZHMgXAogIC0t" + - "ZG9ja2VyLXNlcnZlcj1udmNyLmlvIFwKICAtLWRvY2tlci11c2VybmFtZT0nJG9hdXRodG9rZW4n" + - "IFwKICAtLWRvY2tlci1wYXNzd29yZD0iJE5HQ19BUElfS0VZIiBcCiAgLS1uYW1lc3BhY2U9bnZj" + - "YS1vcGVyYXRvciBcCiAgLS1kcnktcnVuPWNsaWVudCAtbyB5YW1sIHwgXAogIGt1YmVjdGwgLS1j" + - "b250ZXh0IDxjb21wdXRlLXBsYW5lLWNvbnRleHQ+IGFwcGx5IC1mIC0KYGBgCgpSZWZlcmVuY2Ug" + - "aXQgaW4gdGhlIGNvbXB1dGUtcGxhbmUgZW52aXJvbm1lbnQgZmlsZToKCmBgYHlhbWwKZ2xvYmFs" + - "OgogIGltYWdlUHVsbFNlY3JldHM6CiAgICAtIG5hbWU6IG52Y3ItY3JlZHMKYGBgCgpUaGUgY2hh" + - "cnQgYW5kIG9wZXJhdG9yIHVzZSB0aGF0IHJlZmVyZW5jZSBpbiBgbnZjYS1vcGVyYXRvcmAgYW5k" + - "IG1pcnJvciB0aGUKc2VjcmV0IHRvIGBudmNhLXN5c3RlbWAuIERvIG5vdCBjcmVhdGUgYSBicm9h" + - "ZGVyIG1hbnVhbCBjb21wdXRlIG5hbWVzcGFjZSBsaXN0LiBGb2xsb3cKW1NwbGl0IENvbXB1dGUt" + - "UGxhbmUgSW5zdGFsbGF0aW9uXShjb21wdXRlLXBsYW5lLWluc3RhbGxhdGlvbi5tZCkgZm9yIHRo" + - "ZQpzZWxlY3RlZCBpbnN0YWxsIGZsb3cuCgojIyBWZXJpZmljYXRpb24KCmBgYGJhc2gKIyBDaGVj" + - "ayB0aGF0IGEgY29udHJvbC1wbGFuZSBwb2QgaGFzIHRoZSBpbmplY3RlZCBzZWNyZXQKa3ViZWN0" + - "bCAtLWNvbnRleHQgPGNvbnRyb2wtcGxhbmUtY29udGV4dD4gZ2V0IHBvZCAtbiA8bmFtZXNwYWNl" + - "PiA8cG9kLW5hbWU+IFwKICAtbyBqc29ucGF0aD0ney5zcGVjLmltYWdlUHVsbFNlY3JldHN9Jwoj" + - "IEV4cGVjdGVkOiBbeyJuYW1lIjoibnZjci1jcmVkcyJ9XQoKIyBDaGVjayB0aGUgS3l2ZXJubyBh" + - "bm5vdGF0aW9uCmt1YmVjdGwgLS1jb250ZXh0IDxjb250cm9sLXBsYW5lLWNvbnRleHQ+IGdldCBw" + - "b2QgLW4gPG5hbWVzcGFjZT4gPHBvZC1uYW1lPiBcCiAgLW8ganNvbnBhdGg9J3subWV0YWRhdGEu" + - "YW5ub3RhdGlvbnMubnZjZlwubnZpZGlhXC5jb20vaW1hZ2VwdWxsc2VjcmV0LWluamVjdGVkLWJ5" + - "fScKIyBFeHBlY3RlZDoga3l2ZXJubwoKIyBDaGVjayBwdWxsIGV2ZW50cwprdWJlY3RsIC0tY29u" + - "dGV4dCA8Y29udHJvbC1wbGFuZS1jb250ZXh0PiBnZXQgZXZlbnRzIC1uIDxuYW1lc3BhY2U+IFwK" + - "ICAtLXNvcnQtYnk9Jy5sYXN0VGltZXN0YW1wJyB8IGdyZXAgLWkgcHVsbAojIFNob3VsZCBzaG93" + - "ICJTdWNjZXNzZnVsbHkgcHVsbGVkIiBub3QgIjQwMSBVbmF1dGhvcml6ZWQiCgojIENoZWNrIHRo" + - "ZSBjaGFydC9vcGVyYXRvciBtaXJyb3Igb24gdGhlIGNvbXB1dGUgY2x1c3RlcgprdWJlY3RsIC0t" + - "Y29udGV4dCA8Y29tcHV0ZS1wbGFuZS1jb250ZXh0PiBnZXQgc2VjcmV0IG52Y3ItY3JlZHMgXAog" + - "IC1uIG52Y2Etc3lzdGVtCmBgYAoKIyMgV2hlbiBQdWxsIFNlY3JldHMgQXJlIE5vdCBOZWVkZWQK" + - "Ci0gKipBV1MgRUNSIHdpdGggSUFNIG5vZGUgcm9sZXMqKjogSWYgeW91ciBub2RlcyBoYXZlIGBB" + - "bWF6b25FQzJDb250YWluZXJSZWdpc3RyeVJlYWRPbmx5YCBJQU0gcG9saWN5LCBLdWJlcm5ldGVz" + - "IGNhbiBwdWxsIGZyb20gRUNSIHdpdGhvdXQgZXhwbGljaXQgc2VjcmV0cy4KLSAqKlB1YmxpYyBy" + - "ZWdpc3RyaWVzKio6IE5vIHB1bGwgc2VjcmV0cyBuZWVkZWQuCi0gKipDU1AgYnVpbHQtaW4gY3Jl" + - "ZGVudGlhbCBoZWxwZXJzKio6IEdLRSBBcnRpZmFjdCBSZWdpc3RyeSwgQXp1cmUgQUNSIHdpdGgg" + - "bWFuYWdlZCBpZGVudGl0eSwgYW5kIHNpbWlsYXIgc2VydmljZXMuCgojIyBUcm91Ymxlc2hvb3Rp" + - "bmcKCiMjIyBQb2RzIHN0aWxsIGluIEltYWdlUHVsbEJhY2tPZmYgYWZ0ZXIgYXBwbHlpbmcgcG9s" + - "aWN5CgpUaGUgS3l2ZXJubyBwb2xpY3kgb25seSBhZmZlY3RzIHBvZHMgY3JlYXRlZCAqKmFmdGVy" + - "KiogdGhlIHBvbGljeSBpcyBhcHBsaWVkLiBEZWxldGUgc3R1Y2sgcG9kcyB0byB0cmlnZ2VyIHJl" + - "Y3JlYXRpb246CgpgYGBiYXNoCmt1YmVjdGwgLS1jb250ZXh0IDx0YXJnZXQtY29udGV4dD4gZGVs" + - "ZXRlIHBvZHMgLW4gPG5hbWVzcGFjZT4gLS1hbGwKYGBgCgojIyMgS3l2ZXJubyBhZG1pc3Npb24g" + - "Y29udHJvbGxlciBub3QgcnVubmluZwoKYGBgYmFzaAprdWJlY3RsIC0tY29udGV4dCA8Y29udHJv" + - "bC1wbGFuZS1jb250ZXh0PiBnZXQgcG9kcyAtbiBreXZlcm5vCiMgQWxsIHBvZHMgc2hvdWxkIGJl" + - "IFJ1bm5pbmcKYGBgCgojIyMgUG9saWN5IG5vdCBtYXRjaGluZwoKYGBgYmFzaAprdWJlY3RsIC0t" + - "Y29udGV4dCA8Y29udHJvbC1wbGFuZS1jb250ZXh0PiBnZXQgY2x1c3RlcnBvbGljeSBudmNmLWFk" + - "ZC1pbWFnZXB1bGxzZWNyZXRzCiMgU2hvdWxkIHNob3cgUkVBRFk6IFRydWUKYGBgCgojIyMgV3Jv" + - "bmcgc2VjcmV0IG5hbWUKClRoZSBwb2xpY3kgcmVmZXJlbmNlcyBgbnZjci1jcmVkc2AuIFZlcmlm" + - "eSB0aGUgc2VjcmV0IGV4aXN0cyB3aXRoIHRoYXQgZXhhY3QgbmFtZToKCmBgYGJhc2gKa3ViZWN0" + - "bCAtLWNvbnRleHQgPHRhcmdldC1jb250ZXh0PiBnZXQgc2VjcmV0IG52Y3ItY3JlZHMgLW4gPG5h" + - "bWVzcGFjZT4KYGBgClBLBwhLQjWoABYAAAAWAABQSwECFAAUAAgAAAAAACEAxAuyqkkQAABJEAAA" + - "EgAJAAAAAAAAAAAAAAAAAAAAZGF0YS9tYW5pZmVzdC5qc29uVVQFAAEAps4SUEsBAhQAFAAIAAAA" + - "AAAhAM2BMORNYQAATWEAACMACQAAAAAAAAAAAAAAkhAAAGRhdGEvbnZjZi1zZWxmLW1hbmFnZWQt" + - "Y2xpL1NLSUxMLm1kVVQFAAEAps4SUEsBAhQAFAAIAAAAAAAhACHGyIbwCgAA8AoAADMACQAAAAAA" + - "AAAAAAAAOXIAAGRhdGEvbnZjZi1zZWxmLW1hbmFnZWQtY2xpL2V4YW1wbGVzL2NpLXBpcGVsaW5l" + - "cy5tZFVUBQABAKbOElBLAQIUABQACAAAAAAAIQChFOOBXQwAAF0MAAA0AAkAAAAAAAAAAAAAAJN9" + - "AABkYXRhL252Y2Ytc2VsZi1tYW5hZ2VkLWNsaS9leGFtcGxlcy9tdWx0aS1jbHVzdGVyLm1kVVQF" + - "AAEAps4SUEsBAhQAFAAIAAAAAAAhAEInSQ8FDQAABQ0AADcACQAAAAAAAAAAAAAAW4oAAGRhdGEv" + - "bnZjZi1zZWxmLW1hbmFnZWQtY2xpL3Byb21wdHMvYWRkLWNvbXB1dGUtcGxhbmUubWRVVAUAAQCm" + - "zhJQSwECFAAUAAgAAAAAACEAkdwb+ZgZAACYGQAAOQAJAAAAAAAAAAAAAADOlwAAZGF0YS9udmNm" + - "LXNlbGYtbWFuYWdlZC1jbGkvcHJvbXB0cy9jcmVhdGUtYW5kLXJ1bi10YXNrLm1kVVQFAAEAps4S" + - "UEsBAhQAFAAIAAAAAAAhANJD3AQYJQAAGCUAADcACQAAAAAAAAAAAAAA1rEAAGRhdGEvbnZjZi1z" + - "ZWxmLW1hbmFnZWQtY2xpL3Byb21wdHMvZGVwbG95LWFuZC1pbnZva2UubWRVVAUAAQCmzhJQSwEC" + - "FAAUAAgAAAAAACEADpw/l70OAAC9DgAAPQAJAAAAAAAAAAAAAABc1wAAZGF0YS9udmNmLXNlbGYt" + - "bWFuYWdlZC1jbGkvcHJvbXB0cy9kaWFnbm9zZS1mYWlsZWQtaW5zdGFsbC5tZFVUBQABAKbOElBL" + - "AQIUABQACAAAAAAAIQBCceYeASgAAAEoAAA6AAkAAAAAAAAAAAAAAI3mAABkYXRhL252Y2Ytc2Vs" + - "Zi1tYW5hZ2VkLWNsaS9wcm9tcHRzL2luc3RhbGwtZnJvbS1zY3JhdGNoLm1kVVQFAAEAps4SUEsB" + - "AhQAFAAIAAAAAAAhABrELJ7HBwAAxwcAADkACQAAAAAAAAAAAAAA/w4BAGRhdGEvbnZjZi1zZWxm" + - "LW1hbmFnZWQtY2xpL3Byb21wdHMvcm90YXRlLWNsdXN0ZXItandrcy5tZFVUBQABAKbOElBLAQIU" + - "ABQACAAAAAAAIQASkzNZ4CEAAOAhAAAuAAkAAAAAAAAAAAAAADYXAQBkYXRhL252Y2Ytc2VsZi1t" + - "YW5hZ2VkLWNsaS9wcm9tcHRzL3RlYXJkb3duLm1kVVQFAAEAps4SUEsBAhQAFAAIAAAAAAAhAHIN" + - "D2QhIwAAISMAADAACQAAAAAAAAAAAAAAezkBAGRhdGEvbnZjZi1zZWxmLW1hbmFnZWQtY2xpL3Jl" + - "ZmVyZW5jZS9jb21tYW5kcy5tZFVUBQABAKbOElBLAQIUABQACAAAAAAAIQBzp1pk1QYAANUGAAAy" + - "AAkAAAAAAAAAAAAAAANdAQBkYXRhL252Y2Ytc2VsZi1tYW5hZ2VkLWNsaS9yZWZlcmVuY2UvZXhp" + - "dC1jb2Rlcy5tZFVUBQABAKbOElBLAQIUABQACAAAAAAAIQD8o5HgxiIAAMYiAAAtAAkAAAAAAAAA" + - "AAAAAEFkAQBkYXRhL252Y2Ytc2VsZi1tYW5hZ2VkLWNsaS9yZWZlcmVuY2UvZmxhZ3MubWRVVAUA" + - "AQCmzhJQSwECFAAUAAgAAAAAACEA864ThHQRAAB0EQAANwAJAAAAAAAAAAAAAABrhwEAZGF0YS9u" + - "dmNmLXNlbGYtbWFuYWdlZC1jbGkvcmVmZXJlbmNlL3Ryb3VibGVzaG9vdGluZy5tZFVUBQABAKbO" + - "ElBLAQIUABQACAAAAAAAIQAv2rl1QmIAAEJiAAAsAAkAAAAAAAAAAAAAAE2ZAQBkYXRhL252Y2Yt" + - "c2VsZi1tYW5hZ2VkLWluc3RhbGxhdGlvbi9TS0lMTC5tZFVUBQABAKbOElBLAQIUABQACAAAAAAA" + - "IQArE7g/rVUAAK1VAAA0AAkAAAAAAAAAAAAAAPL7AQBkYXRhL252Y2Ytc2VsZi1tYW5hZ2VkLWlu" + - "c3RhbGxhdGlvbi9ldmFscy9ldmFscy5qc29uVVQFAAEAps4SUEsBAhQAFAAIAAAAAAAhAAJSTkB/" + - "KAAAfygAAC8ACQAAAAAAAAAAAAAAClICAGRhdGEvbnZjZi1zZWxmLW1hbmFnZWQtaW5zdGFsbGF0" + - "aW9uL2V4YW1wbGVzLm1kVVQFAAEAps4SUEsBAhQAFAAIAAAAAAAhAJZjvFkSMAAAEjAAAEwACQAA" + - "AAAAAAAAAAAA73oCAGRhdGEvbnZjZi1zZWxmLW1hbmFnZWQtaW5zdGFsbGF0aW9uL3JlZmVyZW5j" + - "ZXMvY29tcHV0ZS1wbGFuZS1pbnN0YWxsYXRpb24ubWRVVAUAAQCmzhJQSwECFAAUAAgAAAAAACEA" + - "Vj5nkJUwAACVMAAAOwAJAAAAAAAAAAAAAACEqwIAZGF0YS9udmNmLXNlbGYtbWFuYWdlZC1pbnN0" + - "YWxsYXRpb24vcmVmZXJlbmNlcy9kZWJ1Z2dpbmcubWRVVAUAAQCmzhJQSwECFAAUAAgAAAAAACEA" + - "le7q7yEpAAAhKQAARAAJAAAAAAAAAAAAAACL3AIAZGF0YS9udmNmLXNlbGYtbWFuYWdlZC1pbnN0" + - "YWxsYXRpb24vcmVmZXJlbmNlcy9oZWxtZmlsZS1zdHJ1Y3R1cmUubWRVVAUAAQCmzhJQSwECFAAU" + - "AAgAAAAAACEAOPknr7kHAAC5BwAAPwAJAAAAAAAAAAAAAAAnBgMAZGF0YS9udmNmLXNlbGYtbWFu" + - "YWdlZC1pbnN0YWxsYXRpb24vcmVmZXJlbmNlcy9udmNmLXVpLWFkZG9uLm1kVVQFAAEAps4SUEsB" + - "AhQAFAAIAAAAAAAhAEtCNagAFgAAABYAAD4ACQAAAAAAAAAAAAAAVg4DAGRhdGEvbnZjZi1zZWxm" + - "LW1hbmFnZWQtaW5zdGFsbGF0aW9uL3JlZmVyZW5jZXMvcHVsbC1zZWNyZXRzLm1kVVQFAAEAps4S" + - "UEsFBgAAAAAXABcArwkAAMskAwAAAA==" + "ZWFsdGgiCmt1YmVjdGwgLS1jb250ZXh0IDxjb250cm9sLXBsYW5lLWNvbnRleHQ+IGdldCBnYXRl" + + "d2F5IG52Y2YtZ2F0ZXdheSBcCiAgLW4gZW52b3ktZ2F0ZXdheSAtbyB3aWRlCmt1YmVjdGwgLS1j" + + "b250ZXh0IDxjb250cm9sLXBsYW5lLWNvbnRleHQ+IGdldCBodHRwcm91dGVzIC1BCmt1YmVjdGwg" + + "LS1jb250ZXh0IDxjb250cm9sLXBsYW5lLWNvbnRleHQ+IGdldCB0Y3Byb3V0ZXMgLUEKa3ViZWN0" + + "bCAtLWNvbnRleHQgPGNvbXB1dGUtcGxhbmUtY29udGV4dD4gcm9sbG91dCBzdGF0dXMgXAogIGRl" + + "cGxveW1lbnQvbnZjYS1vcGVyYXRvciAtbiBudmNhLW9wZXJhdG9yIC0tdGltZW91dD0xMG0Ka3Vi" + + "ZWN0bCAtLWNvbnRleHQgPGNvbXB1dGUtcGxhbmUtY29udGV4dD4gd2FpdCBcCiAgbnZjZmJhY2tl" + + "bmQvPGNvbXB1dGUtcGxhbmUtY2x1c3Rlci1uYW1lPiAtbiBudmNhLW9wZXJhdG9yIFwKICAtLWZv" + + "cj1qc29ucGF0aD0ney5zdGF0dXMuYWdlbnRTdGF0dXN9Jz1oZWFsdGh5IC0tdGltZW91dD0xMG0K" + + "YGBgCgotLS0KCiMjIEV4YW1wbGUgNTogRGVwbG95IE9ubHkgRGVwZW5kZW5jaWVzCgpVc2VmdWwg" + + "Zm9yIHRlc3Rpbmcgb3Igd2hlbiBpdGVyYXRpbmcgb24gc2VydmljZSBjb25maWd1cmF0aW9uLgoK" + + "YGBgYmFzaAojIERlcGxveSBqdXN0IE5BVFMsIENhc3NhbmRyYSwgT3BlbkJhbwpIRUxNRklMRV9F" + + "TlY9PGVudj4gaGVsbWZpbGUgLS1zZWxlY3RvciByZWxlYXNlLWdyb3VwPWRlcGVuZGVuY2llcyBz" + + "eW5jCgojIENoZWNrIHN0YXR1cwprdWJlY3RsIGdldCBwb2RzIC1uIG5hdHMtc3lzdGVtCmt1YmVj" + + "dGwgZ2V0IHBvZHMgLW4gY2Fzc2FuZHJhLXN5c3RlbQprdWJlY3RsIGdldCBwb2RzIC1uIHZhdWx0" + + "LXN5c3RlbQoKIyBEZXBsb3kganVzdCBvbmUgc3BlY2lmaWMgcmVsZWFzZQpIRUxNRklMRV9FTlY9" + + "PGVudj4gaGVsbWZpbGUgLS1zZWxlY3RvciBuYW1lPWNhc3NhbmRyYSBzeW5jCmBgYAoKIyMjIFNl" + + "bGVjdG9yIHJlZmVyZW5jZQoKfCBTZWxlY3RvciB8IFJlbGVhc2VzIHwKfC0tLS0tLS0tLS18LS0t" + + "LS0tLS0tLXwKfCBgcmVsZWFzZS1ncm91cD1kZXBlbmRlbmNpZXNgIHwgbmF0cywgY2Fzc2FuZHJh" + + "LCBvcGVuYmFvLXNlcnZlciB8CnwgYHJlbGVhc2UtZ3JvdXA9c2VydmljZXNgIHwgYXBpLWtleXMs" + + "IHNpcywgYXBpLCBpbnZvY2F0aW9uLXNlcnZpY2UsIGdycGMtcHJveHksIGVzcy1hcGksIG5vdGFy" + + "eS1zZXJ2aWNlLCByZXZhbCwgb3B0aW9uYWwgbGxtLXJlcXVlc3Qtcm91dGVyIGFuZCBsbG0tYXBp" + + "LWdhdGV3YXkgd2hlbiBgbGxtLmVuYWJsZWQ9dHJ1ZWAsIG9wdGlvbmFsIHZhbml0eS1nYXRld2F5" + + "IG9ubHkgaW4gc3RhY2sgcGFja2FnZXMgdGhhdCBpbmNsdWRlIHRoZSBhZGRvbiBhbmQgaGF2ZSBg" + + "YWRkb25zLnZhbml0eUdhdGV3YXkuZW5hYmxlZD10cnVlYCwgb3B0aW9uYWwgbnZjZi11aSBvbmx5" + + "IGluIHN0YWNrIHBhY2thZ2VzIHRoYXQgaW5jbHVkZSB0aGUgYWRkb24gYW5kIGhhdmUgYGFkZG9u" + + "cy5udmNmVWkuZW5hYmxlZD10cnVlYCB8CnwgYG5hbWU9bGxtLXJlcXVlc3Qtcm91dGVyYCB8IERl" + + "cGxveSBqdXN0IHRoZSBMTE0gcmVxdWVzdCByb3V0ZXIgd2hlbiBgbGxtLmVuYWJsZWQ9dHJ1ZWAg" + + "fAp8IGBuYW1lPWxsbS1hcGktZ2F0ZXdheWAgfCBEZXBsb3kganVzdCB0aGUgTExNIEFQSSBnYXRl" + + "d2F5IHdoZW4gYGxsbS5lbmFibGVkPXRydWVgIHwKfCBgbmFtZT12YW5pdHktZ2F0ZXdheWAgfCBE" + + "ZXBsb3kganVzdCBWYW5pdHkgR2F0ZXdheSBvbmx5IHdoZW4gdGhlIHN0YWNrIHBhY2thZ2UgaW5j" + + "bHVkZXMgdGhhdCByZWxlYXNlIGFuZCBgYWRkb25zLnZhbml0eUdhdGV3YXkuZW5hYmxlZD10cnVl" + + "YCB8CnwgYG5hbWU9bnZjZi11aWAgfCBEZXBsb3kgTlZDRiBVSSBvbmx5IHdoZW4gdGhlIHN0YWNr" + + "IHBhY2thZ2UgaW5jbHVkZXMgdGhhdCByZWxlYXNlIGFuZCBgYWRkb25zLm52Y2ZVaS5lbmFibGVk" + + "PXRydWVgIHwKfCBgcmVsZWFzZS1ncm91cD1pbmdyZXNzYCB8IGluZ3Jlc3MgKGdhdGV3YXkgcm91" + + "dGVzKSB8CnwgYG5hbWU9PHJlbGVhc2U+YCB8IEFueSBpbmRpdmlkdWFsIHJlbGVhc2UgYnkgbmFt" + + "ZSB8CgpOb3RlOiBgYWRtaW4taXNzdWVyLXByb3h5YCBkb2VzIG5vdCBoYXZlIGEgcmVsZWFzZS1n" + + "cm91cCBsYWJlbC4gVGFyZ2V0IGl0IHdpdGggYC0tc2VsZWN0b3IgbmFtZT1hZG1pbi1pc3N1ZXIt" + + "cHJveHlgLgpQSwcIAlJOQH8oAAB/KAAAUEsDBBQACAAAAAAAIQAAAAAAAAAAAAAAAABMAAkAZGF0" + + "YS9udmNmLXNlbGYtbWFuYWdlZC1pbnN0YWxsYXRpb24vcmVmZXJlbmNlcy9jb21wdXRlLXBsYW5l" + + "LWluc3RhbGxhdGlvbi5tZFVUBQABAKbOEiMgU3BsaXQgQ29tcHV0ZS1QbGFuZSBJbnN0YWxsYXRp" + + "b24KClRoZSBjb250cm9sIHBsYW5lIGFuZCBjb21wdXRlIHBsYW5lIGFyZSBzZXBhcmF0ZSBzdGFj" + + "a3MuIEluc3RhbGwgdGhlIGNvbnRyb2wKcGxhbmUgZmlyc3QsIHRoZW4gcmVnaXN0ZXIgYW5kIGlu" + + "c3RhbGwgZWFjaCBjb21wdXRlIGNsdXN0ZXIuIENob29zZSBvbmUgaGFuZG9mZgpiZWxvdyBhbmQg" + + "dXNlIGl0IGZvciB0aGUgZnVsbCBsaWZlY3ljbGUuIERvIG5vdCBjb21iaW5lIGEgQ0xJLWdlbmVy" + + "YXRlZCBwcm9maWxlCndpdGggdGhlIEhlbG1maWxlIHZhbHVlcyBmbG93LgoKIyMgQ2hvb3NlIGEg" + + "SGFuZG9mZgoKfCBGbG93IHwgU291cmNlIG9mIGNvbnRyb2wtcGxhbmUgZW5kcG9pbnRzIHwgUmVn" + + "aXN0cmF0aW9uIGFydGlmYWN0IHwKfC0tLS0tLXwtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t" + + "LS0tLS0tLXwtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLXwKfCBIZWxtZmlsZSB2YWx1ZXMgfCBTZXBh" + + "cmF0ZSBjb250cm9sLXBsYW5lIGFuZCBjb21wdXRlLXBsYW5lIGVudmlyb25tZW50IGZpbGVzIHwg" + + "YGRlcGxveS9zdGFja3MvbnZjZi1jb21wdXRlLXBsYW5lL3JlZ2lzdHJhdGlvbi88Y2x1c3Rlcj4t" + + "cmVnaXN0ZXItdmFsdWVzLnlhbWxgIHwKfCBDTEkgcHJvZmlsZSB8IENMSS1nZW5lcmF0ZWQgYGRl" + + "cGxveS9zdGFja3Mvc2VsZi1tYW5hZ2VkL291dC9jb250cm9sLXBsYW5lLXByb2ZpbGUueWFtbGAg" + + "fCBDTEktZ2VuZXJhdGVkIGBkZXBsb3kvc3RhY2tzL252Y2YtY29tcHV0ZS1wbGFuZS9vdXQvPGNs" + + "dXN0ZXI+LXJlZ2lzdGVyLXZhbHVlcy55YW1sYCB8CgpUaGUgQ0xJIHByb2ZpbGUgaXMgbWFuZGF0" + + "b3J5IGZvciB0aGUgQ0xJIGZsb3cgYW5kIG11c3Qgbm90IGJlIGhhbmQtYXV0aG9yZWQuClRoZSBI" + + "ZWxtZmlsZSBmbG93IGRvZXMgbm90IGNvbnN1bWUgYSBjb250cm9sLXBsYW5lIHByb2ZpbGUuCgpD" + + "b21tYW5kcyBiZWxvdyB1c2UgbW9ub3JlcG8gcGF0aHMgZnJvbSB0aGUgcmVwb3NpdG9yeSByb290" + + "LiBPcGVyYXRvcnMgdXNpbmcKZXh0cmFjdGVkIHBhY2thZ2VzIG5lZWQgbWF0Y2hpbmctdmVyc2lv" + + "biBgbnZjZi1zZWxmLW1hbmFnZWQtc3RhY2tgIGFuZApgbnZjZi1jb21wdXRlLXBsYW5lLXN0YWNr" + + "YCBidW5kbGVzLiBTdWJzdGl0dXRlIHRob3NlIGJ1bmRsZSByb290cyBmb3IKYGRlcGxveS9zdGFj" + + "a3Mvc2VsZi1tYW5hZ2VkYCBhbmQgYGRlcGxveS9zdGFja3MvbnZjZi1jb21wdXRlLXBsYW5lYC4K" + + "CiMjIEhlbG1maWxlIFZhbHVlcyBGbG93CgpDcmVhdGUgYm90aCBlbnZpcm9ubWVudCBmaWxlcyBi" + + "ZWZvcmUgaW5zdGFsbGF0aW9uOgoKLSBgZGVwbG95L3N0YWNrcy9zZWxmLW1hbmFnZWQvZW52aXJv" + + "bm1lbnRzLzxlbnY+LnlhbWxgIGZvciBjb250cm9sLXBsYW5lCiAgcmVnaXN0cnksIGRvbWFpbiwg" + + "R2F0ZXdheSwgcm91dGVzLCBhbmQgc2VydmljZSBzZXR0aW5ncy4KLSBgZGVwbG95L3N0YWNrcy9u" + + "dmNmLWNvbXB1dGUtcGxhbmUvZW52aXJvbm1lbnRzLzxlbnY+LnlhbWxgIGZvciBjb21wdXRlLXBs" + + "YW5lCiAgcmVnaXN0cnksIHB1bGwgc2VjcmV0cywgYW5kIGNvbXB1dGUtcmVhY2hhYmxlIElDTVMs" + + "IFJlVmFsLCBhbmQgTkFUUyB2YWx1ZXMuCgpGb3IgRUtTLCB1c2UgdGhlIGNhbm9uaWNhbApbQ1NQ" + + "IEVuZC10by1FbmQgRXhhbXBsZV0oaHR0cHM6Ly9kb2NzLm52aWRpYS5jb20vbnZjZi92MC42LjAt" + + "cmMvY3NwLWVuZC10by1lbmQtZXhhbXBsZSkuClRoZSBjb250cm9sLXBsYW5lIGVudmlyb25tZW50" + + "IGtlZXBzIHRoZSBFbnZveSBHYXRld2F5IGNvbnRyb2xsZXIgaW4KYGVudm95LWdhdGV3YXktc3lz" + + "dGVtYCwgYXR0YWNoZXMgcm91dGVzIHRvIGBHYXRld2F5L252Y2YtZ2F0ZXdheWAgaW4KYGVudm95" + + "LWdhdGV3YXlgLCBhbmQgZW5hYmxlcyB0aGUgTkFUUyByb3V0ZS4gVGhlIGNvbXB1dGUtcGxhbmUg" + + "ZW52aXJvbm1lbnQgdXNlcwp0aGUgZXh0ZXJuYWwgYWRkcmVzcyBwbHVzIHRoZSBzZXJ2aWNlIGhv" + + "c3Qgb3ZlcnJpZGVzLiBIZXJlLApgPGdhdGV3YXktYWRkcmVzcz5gIGlzIHRoZSBOTEIgYWRkcmVz" + + "cyBhbmQgYDxnYXRld2F5LWRvbWFpbj5gIGlzIHRoZSBETlMgYmFzZQp3aG9zZSBzZXJ2aWNlIHN1" + + "YmRvbWFpbnMgcmVzb2x2ZSB0byB0aGF0IE5MQjoKCmBgYHlhbWwKIyBkZXBsb3kvc3RhY2tzL3Nl" + + "bGYtbWFuYWdlZC9lbnZpcm9ubWVudHMvPGVudj4ueWFtbApnbG9iYWw6CiAgZG9tYWluOiAiPGdh" + + "dGV3YXktZG9tYWluPiIKICB3b3JrZXJFbmRwb2ludHM6CiAgICBudmNmU2VydmljZVVSTDogImh0" + + "dHA6Ly9hcGkuPGdhdGV3YXktZG9tYWluPiIKICAgIG52Y2ZHcnBjU2VydmljZVVSTDogImh0dHA6" + + "Ly93b3JrZXItYXBpLjxnYXRld2F5LWRvbWFpbj4iCiAgICBudmNmTmF0c1NlcnZpY2VVUkw6ICJu" + + "YXRzOi8vPGdhdGV3YXktYWRkcmVzcz46NDIyMiIKICAgIG52Y3RTZXJ2aWNlVVJMOiAiaHR0cDov" + + "L3Rhc2tzLjxnYXRld2F5LWRvbWFpbj4iCiAgICBudmN0R3JwY1NlcnZpY2VVUkw6ICJodHRwOi8v" + + "d29ya2VyLXRhc2tzLjxnYXRld2F5LWRvbWFpbj4iCiAgICBpbnZvY2F0aW9uU2VydmljZVVSTDog" + + "Imh0dHA6Ly9pbnZvY2F0aW9uLjxnYXRld2F5LWRvbWFpbj4iCgpncnBjcHJveHk6CiAgbnZjZkdy" + + "cGNTZXJ2aWNlVVJMOiAiaHR0cDovL2FwaS5udmNmLnN2Yy5jbHVzdGVyLmxvY2FsOjkwOTAiCgpp" + + "bmdyZXNzOgogIGdhdGV3YXlBcGk6CiAgICBjb250cm9sbGVyTmFtZXNwYWNlOiBlbnZveS1nYXRl" + + "d2F5LXN5c3RlbQogICAgZ2F0ZXdheXM6CiAgICAgIHNoYXJlZDoge25hbWU6IG52Y2YtZ2F0ZXdh" + + "eSwgbmFtZXNwYWNlOiBlbnZveS1nYXRld2F5fQogICAgICBncnBjOiB7bmFtZTogbnZjZi1nYXRl" + + "d2F5LCBuYW1lc3BhY2U6IGVudm95LWdhdGV3YXl9CiAgICAgIG5hdHM6CiAgICAgICAgbmFtZTog" + + "bnZjZi1nYXRld2F5CiAgICAgICAgbmFtZXNwYWNlOiBlbnZveS1nYXRld2F5CiAgICAgICAgbGlz" + + "dGVuZXJOYW1lOiBuYXRzCiAgICByb3V0ZXM6CiAgICAgIG52Y2ZBcGk6CiAgICAgICAgZ3JwYzoK" + + "ICAgICAgICAgIGVuYWJsZWQ6IHRydWUKICAgICAgICAgIGhvc3RuYW1lczogWyJ3b3JrZXItYXBp" + + "LjxnYXRld2F5LWRvbWFpbj4iXQogICAgICBudmN0QXBpOgogICAgICAgIGdycGM6CiAgICAgICAg" + + "ICBlbmFibGVkOiB0cnVlCiAgICAgICAgICBob3N0bmFtZXM6IFsid29ya2VyLXRhc2tzLjxnYXRl" + + "d2F5LWRvbWFpbj4iXQogICAgICBuYXRzOgogICAgICAgIGVuYWJsZWQ6IHRydWUKCm9wZW5iYW86" + + "CiAgbWlncmF0aW9uczoKICAgIGlzc3VlckRpc2NvdmVyeToKICAgICAgZW5hYmxlZDogdHJ1ZQpg" + + "YGAKCmBgYHlhbWwKIyBkZXBsb3kvc3RhY2tzL252Y2YtY29tcHV0ZS1wbGFuZS9lbnZpcm9ubWVu" + + "dHMvPGVudj4ueWFtbApnbG9iYWw6CiAgbnZjYU9wZXJhdG9yOgogICAgc2VsZk1hbmFnZWQ6CiAg" + + "ICAgIGljbXNTZXJ2aWNlVVJMOiAiaHR0cDovLzxnYXRld2F5LWFkZHJlc3M+IgogICAgICBpY21z" + + "U2VydmljZUhvc3RIZWFkZXJPdmVycmlkZTogInNpcy48Z2F0ZXdheS1kb21haW4+IgogICAgICBy" + + "ZXZhbFNlcnZpY2VVUkw6ICJodHRwOi8vPGdhdGV3YXktYWRkcmVzcz4iCiAgICAgIHJldmFsU2Vy" + + "dmljZUhvc3RIZWFkZXJPdmVycmlkZTogInJldmFsLjxnYXRld2F5LWRvbWFpbj4iCiAgICAgIG5h" + + "dHNVUkw6ICJuYXRzOi8vPGdhdGV3YXktYWRkcmVzcz46NDIyMiIKICAgICAgbmF0c0hvc3RPdmVy" + + "cmlkZTogIm5hdHMuPGdhdGV3YXktZG9tYWluPiIKYGBgCgpQcmV2aWV3IGFuZCBpbnN0YWxsIHRo" + + "ZSBjb250cm9sIHBsYW5lIGFnYWluc3QgaXRzIGNvbnRleHQ6CgpgYGBiYXNoCm1ha2UgLUMgZGVw" + + "bG95L3N0YWNrcy9zZWxmLW1hbmFnZWQgdGVtcGxhdGUgXAogIEhFTE1GSUxFX0VOVj08ZW52PiBc" + + "CiAgS1VCRUNPTkZJR19GSUxFPTxjb250cm9sLXBsYW5lLWt1YmVjb25maWc+CgptYWtlIC1DIGRl" + + "cGxveS9zdGFja3Mvc2VsZi1tYW5hZ2VkIGluc3RhbGwgXAogIEhFTE1GSUxFX0VOVj08ZW52PiBc" + + "CiAgS1VCRUNPTkZJR19GSUxFPTxjb250cm9sLXBsYW5lLWt1YmVjb25maWc+CmBgYAoKQmVmb3Jl" + + "IHJlZ2lzdGVyaW5nIHRocm91Z2ggYSBiYXJlIEdhdGV3YXkgYWRkcmVzcywgY3JlYXRlIG9yIHVw" + + "ZGF0ZSB0aGUgQ0xJCmNvbmZpZyBwYXNzZWQgYXMgYE5WQ0ZfQ0xJX0NPTkZJR2A6CgpgYGB5YW1s" + + "CmJhc2VfaHR0cF91cmw6ICJodHRwOi8vPGdhdGV3YXktYWRkcmVzcz4iCmludm9rZV91cmw6ICJo" + + "dHRwOi8vPGdhdGV3YXktYWRkcmVzcz4iCmJhc2VfZ3JwY191cmw6ICI8Z2F0ZXdheS1hZGRyZXNz" + + "PjoxMDA4MSIKYXBpX2tleXNfc2VydmljZV91cmw6ICJodHRwOi8vPGdhdGV3YXktYWRkcmVzcz4i" + + "CmljbXNfdXJsOiAiaHR0cDovLzxnYXRld2F5LWFkZHJlc3M+IgphcGlfaG9zdDogImFwaS48Z2F0" + + "ZXdheS1kb21haW4+IgphcGlfa2V5c19ob3N0OiAiYXBpLWtleXMuPGdhdGV3YXktZG9tYWluPiIK" + + "aW52b2tlX2hvc3Q6ICJpbnZvY2F0aW9uLjxnYXRld2F5LWRvbWFpbj4iCmljbXNfaG9zdDogInNp" + + "cy48Z2F0ZXdheS1kb21haW4+IgpgYGAKCkhvc3QgZmllbGRzIGNvbnRhaW4gaG9zdG5hbWVzIG9u" + + "bHksIHdpdGhvdXQgYSBVUkwgc2NoZW1lLiBgSUNNU19VUkxgIG1hcHMgb25seQp0byB0aGUgcmVn" + + "aXN0cmF0aW9uIGNvbW1hbmQncyBgLS1pY21zLXVybGA7IGBpY21zX2hvc3RgIGluIHRoZSBjb25m" + + "aWcgc3VwcGxpZXMKdGhlIEdhdGV3YXkgSG9zdCBoZWFkZXIuIFRoZXJlIGlzIG5vIGAtLWljbXMt" + + "aG9zdGAgTWFrZSBvciBDTEkgZmxhZy4KClJlZ2lzdGVyIGZyb20gdGhlIGNvbXB1dGUgY29udGV4" + + "dCwgdGhlbiBpbnN0YWxsIHRoZSBjb21wdXRlIHBsYW5lOgoKYGBgYmFzaAptYWtlIC1DIGRlcGxv" + + "eS9zdGFja3MvbnZjZi1jb21wdXRlLXBsYW5lIHJlZ2lzdGVyLWNsdXN0ZXIgXAogIENMVVNURVJf" + + "TkFNRT08Y2x1c3Rlci1uYW1lPiBcCiAgTkNBX0lEPTxuY2EtaWQ+IFwKICBDTFVTVEVSX1JFR0lP" + + "Tj08cmVnaW9uPiBcCiAgSUNNU19VUkw9aHR0cDovLzxnYXRld2F5LWFkZHJlc3M+IFwKICBLVUJF" + + "Q09ORklHX0ZJTEU9PGNvbXB1dGUtcGxhbmUta3ViZWNvbmZpZz4gXAogIE5WQ0ZfQ0xJPTxwYXRo" + + "LXRvLW52Y2YtY2xpPiBcCiAgTlZDRl9DTElfQ09ORklHPTxwYXRoLXRvLW52Y2YtY2xpLWNvbmZp" + + "Zz4KCm1ha2UgLUMgZGVwbG95L3N0YWNrcy9udmNmLWNvbXB1dGUtcGxhbmUgaW5zdGFsbCBcCiAg" + + "Q0xVU1RFUl9OQU1FPTxjbHVzdGVyLW5hbWU+IFwKICBIRUxNRklMRV9FTlY9PGVudj4gXAogIEtV" + + "QkVDT05GSUdfRklMRT08Y29tcHV0ZS1wbGFuZS1rdWJlY29uZmlnPgpgYGAKClJlZ2lzdHJhdGlv" + + "biBkaXNjb3ZlcnMgdGhlIE9JREMgaXNzdWVyIGFuZCBKV0tTIGZyb20gdGhlIGNvbXB1dGUga3Vi" + + "ZSBjb250ZXh0LgpJbiBhIG11bHRpLWNsdXN0ZXIgZGVwbG95bWVudCwgYEtVQkVDT05GSUdfRklM" + + "RWAgaXMgcmVxdWlyZWQgb24gYm90aApjb21wdXRlLXBsYW5lIGNvbW1hbmRzLiBJbiBhIHNhbWUt" + + "Y2x1c3RlciBkZXBsb3ltZW50IGl0IG1heSBiZSBvbWl0dGVkIG9ubHkKd2hlbiB0aGUgYW1iaWVu" + + "dCBjb250ZXh0IGlzIGFscmVhZHkgdGhlIHRhcmdldCBjbHVzdGVyLgoKIyMgQ0xJIFByb2ZpbGUg" + + "RmxvdwoKUnVuIHRoZSBDTEkgY29udHJvbC1wbGFuZSBpbnN0YWxsIGZpcnN0LiBJdCBjcmVhdGVz" + + "IHRoZSBwcm9maWxlIGNvbnN1bWVkIGJ5CmNvbXB1dGUtcGxhbmUgcmVnaXN0cmF0aW9uOgoKYGBg" + + "YmFzaApudmNmLWNsaSAtLWNvbmZpZyA8Y29uZmlnPiBzZWxmLWhvc3RlZCBcCiAgLS1jb250cm9s" + + "LXBsYW5lLXN0YWNrIGRlcGxveS9zdGFja3Mvc2VsZi1tYW5hZ2VkIFwKICAtLWNvbXB1dGUtcGxh" + + "bmUtc3RhY2sgZGVwbG95L3N0YWNrcy9udmNmLWNvbXB1dGUtcGxhbmUgXAogIC0tZW52IDxlbnY+" + + "IFwKICAtLXBsYWluIFwKICAtLWNvbnRyb2wtcGxhbmUtY29udGV4dCA8Y29udHJvbC1wbGFuZS1j" + + "b250ZXh0PiBcCiAgLS1jb21wdXRlLXBsYW5lLWNvbnRleHQgPGNvbXB1dGUtcGxhbmUtY29udGV4" + + "dD4gXAogIGluc3RhbGwgLS1jb250cm9sLXBsYW5lIFwKICAtLWNsdXN0ZXItbmFtZSA8Y29udHJv" + + "bC1wbGFuZS1jbHVzdGVyLW5hbWU+IFwKICAtLXJlZ2lvbiA8cmVnaW9uPiBcCiAgLS1uY2EtaWQg" + + "PG5jYS1pZD4KCnRlc3QgLXMgZGVwbG95L3N0YWNrcy9zZWxmLW1hbmFnZWQvb3V0L2NvbnRyb2wt" + + "cGxhbmUtcHJvZmlsZS55YW1sCmBgYAoKVXNlIHRoZSBmdWxsIHBlcnNpc3RlbnQgcHJlZml4IGZv" + + "ciBib3RoIGNvbXB1dGUtcGxhbmUgY29tbWFuZHM6CgpgYGBiYXNoCm52Y2YtY2xpIC0tY29uZmln" + + "IDxjb25maWc+IHNlbGYtaG9zdGVkIFwKICAtLWNvbnRyb2wtcGxhbmUtc3RhY2sgZGVwbG95L3N0" + + "YWNrcy9zZWxmLW1hbmFnZWQgXAogIC0tY29tcHV0ZS1wbGFuZS1zdGFjayBkZXBsb3kvc3RhY2tz" + + "L252Y2YtY29tcHV0ZS1wbGFuZSBcCiAgLS1lbnYgPGVudj4gXAogIC0tcGxhaW4gXAogIGNvbXB1" + + "dGUtcGxhbmUgcmVnaXN0ZXIgXAogIC0tY29udHJvbC1wbGFuZS1wcm9maWxlIGRlcGxveS9zdGFj" + + "a3Mvc2VsZi1tYW5hZ2VkL291dC9jb250cm9sLXBsYW5lLXByb2ZpbGUueWFtbCBcCiAgLS1jbHVz" + + "dGVyLW5hbWUgPGNvbXB1dGUtcGxhbmUtY2x1c3Rlci1uYW1lPiBcCiAgLS1rdWJlLWNvbnRleHQg" + + "PGNvbXB1dGUtcGxhbmUtY29udGV4dD4gXAogIC0tcmVnaW9uIDxyZWdpb24+IFwKICAtLW91dHB1" + + "dCBkZXBsb3kvc3RhY2tzL252Y2YtY29tcHV0ZS1wbGFuZS9vdXQvPGNvbXB1dGUtcGxhbmUtY2x1" + + "c3Rlci1uYW1lPi1yZWdpc3Rlci12YWx1ZXMueWFtbAoKbnZjZi1jbGkgLS1jb25maWcgPGNvbmZp" + + "Zz4gc2VsZi1ob3N0ZWQgXAogIC0tY29udHJvbC1wbGFuZS1zdGFjayBkZXBsb3kvc3RhY2tzL3Nl" + + "bGYtbWFuYWdlZCBcCiAgLS1jb21wdXRlLXBsYW5lLXN0YWNrIGRlcGxveS9zdGFja3MvbnZjZi1j" + + "b21wdXRlLXBsYW5lIFwKICAtLWVudiA8ZW52PiBcCiAgLS1wbGFpbiBcCiAgY29tcHV0ZS1wbGFu" + + "ZSBpbnN0YWxsIFwKICAtLXZhbHVlcyBkZXBsb3kvc3RhY2tzL252Y2YtY29tcHV0ZS1wbGFuZS9v" + + "dXQvPGNvbXB1dGUtcGxhbmUtY2x1c3Rlci1uYW1lPi1yZWdpc3Rlci12YWx1ZXMueWFtbCBcCiAg" + + "LS1rdWJlLWNvbnRleHQgPGNvbXB1dGUtcGxhbmUtY29udGV4dD4gXAogIC0tY2x1c3Rlci1uYW1l" + + "IDxjb21wdXRlLXBsYW5lLWNsdXN0ZXItbmFtZT4KYGBgCgpSZWdpc3RyYXRpb24gc2VsZWN0cyB0" + + "aGUgcHJvZmlsZSdzIGluLWNsdXN0ZXIgb3IgY29tcHV0ZS1yZWFjaGFibGUgZW5kcG9pbnRzCmZy" + + "b20gdGhlIGNvbXB1dGUgY29udGV4dCBhbmQgcHJvYmVzIGl0cyBKV0tTLiBEbyBub3QgcmVwbGFj" + + "ZSBwcm9maWxlIGVuZHBvaW50cwp3aXRoIGhhbmQtYXV0aG9yZWQgSGVsbWZpbGUgZW5kcG9pbnQg" + + "dmFsdWVzLgoKIyMgUHVsbCBTZWNyZXRzCgpDcmVhdGUgdGhlIGNvbnRyb2wtcGxhbmUgc2VjcmV0" + + "IGluIHRoZXNlIG5hbWVzcGFjZXMgb24gdGhlIGNvbnRyb2wtcGxhbmUKY29udGV4dDoKCmBgYHRl" + + "eHQKY2Fzc2FuZHJhLXN5c3RlbSBuYXRzLXN5c3RlbSBudmNmIGFwaS1rZXlzIGVzcyBzaXMgdmF1" + + "bHQtc3lzdGVtIGNlcnQtbWFuYWdlcgpgYGAKCk9uIHRoZSBjb21wdXRlIGNvbnRleHQsIGNyZWF0" + + "ZSB0aGUgc2VjcmV0IG9ubHkgaW4gYG52Y2Etb3BlcmF0b3JgIGFuZCByZWZlcmVuY2UKaXQgdGhy" + + "b3VnaCBgZ2xvYmFsLmltYWdlUHVsbFNlY3JldHNgIGluIHRoZSBjb21wdXRlLXBsYW5lIGVudmly" + + "b25tZW50LiBUaGUgY2hhcnQKYW5kIG9wZXJhdG9yIHVzZSBpdCBpbiBgbnZjYS1vcGVyYXRvcmAg" + + "YW5kIG1pcnJvciBpdCB0byBgbnZjYS1zeXN0ZW1gLiBEbyBub3QgYWRkCmVpdGhlciBuYW1lc3Bh" + + "Y2UgdG8gdGhlIGNvbnRyb2wtcGxhbmUgbGlzdC4gRm9yIGNvbW1hbmRzIGFuZCBwb2xpY3kgZXhh" + + "bXBsZXMsCnNlZSBbcHVsbC1zZWNyZXRzLm1kXShwdWxsLXNlY3JldHMubWQpLgoKIyMgVmVyaWZp" + + "Y2F0aW9uCgpVc2UgdGhlIGV4cGxpY2l0IEdhdGV3YXkgbmFtZSBhbmQgbmFtZXNwYWNlOgoKYGBg" + + "YmFzaAprdWJlY3RsIC0tY29udGV4dCA8Y29udHJvbC1wbGFuZS1jb250ZXh0PiBnZXQgZ2F0ZXdh" + + "eSBudmNmLWdhdGV3YXkgXAogIC1uIGVudm95LWdhdGV3YXkgLW8gd2lkZQprdWJlY3RsIC0tY29u" + + "dGV4dCA8Y29udHJvbC1wbGFuZS1jb250ZXh0PiBnZXQgdGNwcm91dGUgLW4gZW52b3ktZ2F0ZXdh" + + "eQprdWJlY3RsIC0tY29udGV4dCA8Y29tcHV0ZS1wbGFuZS1jb250ZXh0PiByb2xsb3V0IHN0YXR1" + + "cyBcCiAgZGVwbG95bWVudC9udmNhLW9wZXJhdG9yIC1uIG52Y2Etb3BlcmF0b3IgLS10aW1lb3V0" + + "PTEwbQprdWJlY3RsIC0tY29udGV4dCA8Y29tcHV0ZS1wbGFuZS1jb250ZXh0PiB3YWl0IFwKICBu" + + "dmNmYmFja2VuZC88Y29tcHV0ZS1wbGFuZS1jbHVzdGVyLW5hbWU+IC1uIG52Y2Etb3BlcmF0b3Ig" + + "XAogIC0tZm9yPWpzb25wYXRoPSd7LnN0YXR1cy5hZ2VudFN0YXR1c30nPWhlYWx0aHkgLS10aW1l" + + "b3V0PTEwbQprdWJlY3RsIC0tY29udGV4dCA8Y29tcHV0ZS1wbGFuZS1jb250ZXh0PiBnZXQgc2Vj" + + "cmV0IDxwdWxsLXNlY3JldD4gLW4gbnZjYS1zeXN0ZW0KYGBgCgojIyBUZWFyZG93bgoKRGVzdHJv" + + "eSBhbmQgZGVyZWdpc3RlciBldmVyeSBjb21wdXRlIHBsYW5lIGJlZm9yZSB0aGUgY29udHJvbCBw" + + "bGFuZS4gQm90aApoYW5kb2ZmcyBjYW4gZGVzdHJveSB0aGUgY29udHJvbCBwbGFuZSwgc28gYXBw" + + "bHkgdGhpcyBwcmVmbGlnaHQgYmVmb3JlIGVpdGhlcgpvbmUuIFByZXNlcnZlIHRoZSBgY2VydC1t" + + "YW5hZ2VyYCBuYW1lc3BhY2UgYnkgZGVmYXVsdC4gTmFtZXNwYWNlIHByZXNlcnZhdGlvbgpkb2Vz" + + "IG5vdCBwcmVzZXJ2ZSB0aGUgSGVsbSByZWxlYXNlLiBJZGVudGlmeSB3aGV0aGVyIGNlcnQtbWFu" + + "YWdlciBpcyBleHRlcm5hbC4KRm9yIGFuIGV4dGVybmFsIGluc3RhbGxhdGlvbiwgcmVxdWlyZSBl" + + "ZmZlY3RpdmUgYGNlcnRNYW5hZ2VyLmVuYWJsZWQ6IGZhbHNlYAphbmQgYWJvcnQgaWYgaXQgaXMg" + + "dHJ1ZS4gRm9yIGFuIGludGVuZGVkIHN0YWNrLW1hbmFnZWQgcmVsZWFzZSB3aXRoIGVmZmVjdGl2" + + "ZQpgY2VydE1hbmFnZXIuZW5hYmxlZDogdHJ1ZWAsIHZlcmlmeSBtYXRjaGluZyBzdGFjayBIZWxt" + + "IHJlbGVhc2UgbWV0YWRhdGEgYW5kCmFib3J0IG9uIG1pc3Npbmcgb3IgbWlzbWF0Y2hlZCBldmlk" + + "ZW5jZS4gT25seSBwbGFuIG5hbWVzcGFjZSByZW1vdmFsIGFmdGVyCnZlcmlmeWluZyBuYW1lc3Bh" + + "Y2UgcHJvdmVuYW5jZSBhbmQgZ2V0dGluZyBleHBsaWNpdCBjb25maXJtYXRpb247IG90aGVyd2lz" + + "ZQpkbyBub3QgZGVsZXRlIGl0LgoKRm9yIHRoZSBIZWxtZmlsZSB2YWx1ZXMgZmxvdywgcmV0YWlu" + + "IGVhY2ggcmVnaXN0cmF0aW9uIHZhbHVlcyBmaWxlIHVudGlsCmNsZWFudXAgaXMgdmVyaWZpZWQ6" + + "CgpgYGBiYXNoCm1ha2UgLUMgZGVwbG95L3N0YWNrcy9udmNmLWNvbXB1dGUtcGxhbmUgZGVzdHJv" + + "eSBcCiAgQ0xVU1RFUl9OQU1FPTxjbHVzdGVyLW5hbWU+IFwKICBIRUxNRklMRV9FTlY9PGVudj4g" + + "XAogIEtVQkVDT05GSUdfRklMRT08Y29tcHV0ZS1wbGFuZS1rdWJlY29uZmlnPgoKPG52Y2YtY2xp" + + "PiAtLWNvbmZpZyA8Y29uZmlnPiBjbHVzdGVyIGRlbGV0ZSBcCiAgLS1jbHVzdGVyLWlkIDxjbHVz" + + "dGVyLWlkLWZyb20tcmVnaXN0cmF0aW9uLXZhbHVlcz4gXAogIC0tbmNhLWlkIDxuY2EtaWQ+IFwK" + + "ICAtLWlnbm9yZS1taXNzaW5nCmBgYAoKUmVhZCBgY2x1c3RlcklEYCBhbmQgYG5jYUlEYCBmcm9t" + + "CmBkZXBsb3kvc3RhY2tzL252Y2YtY29tcHV0ZS1wbGFuZS9yZWdpc3RyYXRpb24vPGNsdXN0ZXIt" + + "bmFtZT4tcmVnaXN0ZXItdmFsdWVzLnlhbWxgLgpTaG93IHRoZSBleGFjdCBjbHVzdGVyIElEIGFu" + + "ZCBnZXQgY29uZmlybWF0aW9uIGJlZm9yZSBgY2x1c3RlciBkZWxldGVgLiBSZXBlYXQKY29tcHV0" + + "ZSBkZXN0cm95IGFuZCBkZXJlZ2lzdHJhdGlvbiBmb3IgZXZlcnkgY29tcHV0ZSBjbHVzdGVyLCB0" + + "aGVuIGRlc3Ryb3kgdGhlCmNvbnRyb2wgcGxhbmUuCgpgYGBiYXNoCktVQkVDT05GSUc9PGNvbnRy" + + "b2wtcGxhbmUta3ViZWNvbmZpZz4gXAptYWtlIC1DIGRlcGxveS9zdGFja3Mvc2VsZi1tYW5hZ2Vk" + + "IGRlc3Ryb3kgXAogIEhFTE1GSUxFX0VOVj08ZW52PiBcCiAgS1VCRUNPTkZJR19GSUxFPTxjb250" + + "cm9sLXBsYW5lLWt1YmVjb25maWc+CmBgYAoKQm90aCBgS1VCRUNPTkZJR2AgYW5kIGBLVUJFQ09O" + + "RklHX0ZJTEVgIGFyZSByZXF1aXJlZCBvbiB0aGUgY29udHJvbC1wbGFuZQpkZXN0cm95IGJlY2F1" + + "c2UgaXRzIG5hbWVzcGFjZSBjbGVhbnVwIHVzZXMgYW1iaWVudCBga3ViZWN0bGAuCgpGb3IgdGhl" + + "IENMSSBwcm9maWxlIGZsb3csIGtlZXAKYGRlcGxveS9zdGFja3MvbnZjZi1jb21wdXRlLXBsYW5l" + + "L291dC88Y2x1c3Rlci1uYW1lPi1yZWdpc3Rlci12YWx1ZXMueWFtbGAKdW50aWwgdGVhcmRvd24g" + + "Y29tcGxldGVzIGJlY2F1c2UgYGRvd25gIHJlYWRzIGl0cyBjbHVzdGVyIElELiBGaXJzdCBxdWVy" + + "eSB0aGUKbGl2ZSByZWdpc3RyYXRpb24gc2V0IHdpdGggdGhlIHNhbWUgY29tcGxldGUgcGVyc2lz" + + "dGVudCBwcmVmaXg6CgpgYGBiYXNoCm52Y2YtY2xpIC0tY29uZmlnIDxjb25maWc+IHNlbGYtaG9z" + + "dGVkIFwKICAtLWNvbnRyb2wtcGxhbmUtc3RhY2sgZGVwbG95L3N0YWNrcy9zZWxmLW1hbmFnZWQg" + + "XAogIC0tY29tcHV0ZS1wbGFuZS1zdGFjayBkZXBsb3kvc3RhY2tzL252Y2YtY29tcHV0ZS1wbGFu" + + "ZSBcCiAgLS1lbnYgPGVudj4gXAogIC0tcGxhaW4gXAogIC0tY29udHJvbC1wbGFuZS1jb250ZXh0" + + "IDxjb250cm9sLXBsYW5lLWNvbnRleHQ+IFwKICAtLWNvbXB1dGUtcGxhbmUtY29udGV4dCA8Y29t" + + "cHV0ZS1wbGFuZS1jb250ZXh0PiBcCiAgLS1pY21zLXVybCA8Y29tcHV0ZS1yZWFjaGFibGUtaWNt" + + "cy11cmw+IFwKICBzdGF0dXMgXAogIC0tY2x1c3Rlci1uYW1lIDxjb21wdXRlLXBsYW5lLWNsdXN0" + + "ZXItbmFtZT4gXAogIC0tbmNhLWlkIDxuY2EtaWQ+CmBgYAoKU2hvdyB0aGUgcmVnaXN0ZXJlZCBj" + + "b21wdXRlLXBsYW5lIGxpc3QuIE5hbWVkLWNsdXN0ZXIgYGRvd24gLS1wbGFuLW9ubHlgIGRvZXMK" + + "bm90IHF1ZXJ5IElDTVMsIHNvIGl0IHByZXZpZXdzIG9ubHkgdGhhdCBjb21wdXRlIHBsYW5lIGFu" + + "ZCBjYW5ub3Qgc2hvdyB0aGUKY29uZGl0aW9uYWwgY29udHJvbC1wbGFuZSByZW1vdmFsLiBJZiB0" + + "aGUgdGFyZ2V0IGlzIHRoZSBsYXN0IHJlZ2lzdGVyZWQKY2x1c3RlciwgcmVhbCBgZG93bmAgYWxz" + + "byBkZXN0cm95cyB0aGUgY29udHJvbCBwbGFuZS4gR2V0IGV4cGxpY2l0IGNvbmZpcm1hdGlvbgpm" + + "b3IgYm90aCByZW1vdmFscyBiZWZvcmUgY29udGludWluZy4gVGhlbiBwcmV2aWV3IGFuZCBleGVj" + + "dXRlIHdpdGggdGhlIHNhbWUKcHJlZml4OgoKYGBgYmFzaApudmNmLWNsaSAtLWNvbmZpZyA8Y29u" + + "ZmlnPiBzZWxmLWhvc3RlZCBcCiAgLS1jb250cm9sLXBsYW5lLXN0YWNrIGRlcGxveS9zdGFja3Mv" + + "c2VsZi1tYW5hZ2VkIFwKICAtLWNvbXB1dGUtcGxhbmUtc3RhY2sgZGVwbG95L3N0YWNrcy9udmNm" + + "LWNvbXB1dGUtcGxhbmUgXAogIC0tZW52IDxlbnY+IFwKICAtLXBsYWluIFwKICAtLWNvbnRyb2wt" + + "cGxhbmUtY29udGV4dCA8Y29udHJvbC1wbGFuZS1jb250ZXh0PiBcCiAgLS1jb21wdXRlLXBsYW5l" + + "LWNvbnRleHQgPGNvbXB1dGUtcGxhbmUtY29udGV4dD4gXAogIC0taWNtcy11cmwgPGNvbXB1dGUt" + + "cmVhY2hhYmxlLWljbXMtdXJsPiBcCiAgZG93biAtLXBsYW4tb25seSBcCiAgLS1jbHVzdGVyLW5h" + + "bWUgPGNvbXB1dGUtcGxhbmUtY2x1c3Rlci1uYW1lPiBcCiAgLS1uY2EtaWQgPG5jYS1pZD4KCm52" + + "Y2YtY2xpIC0tY29uZmlnIDxjb25maWc+IHNlbGYtaG9zdGVkIFwKICAtLWNvbnRyb2wtcGxhbmUt" + + "c3RhY2sgZGVwbG95L3N0YWNrcy9zZWxmLW1hbmFnZWQgXAogIC0tY29tcHV0ZS1wbGFuZS1zdGFj" + + "ayBkZXBsb3kvc3RhY2tzL252Y2YtY29tcHV0ZS1wbGFuZSBcCiAgLS1lbnYgPGVudj4gXAogIC0t" + + "cGxhaW4gXAogIC0tY29udHJvbC1wbGFuZS1jb250ZXh0IDxjb250cm9sLXBsYW5lLWNvbnRleHQ+" + + "IFwKICAtLWNvbXB1dGUtcGxhbmUtY29udGV4dCA8Y29tcHV0ZS1wbGFuZS1jb250ZXh0PiBcCiAg" + + "LS1pY21zLXVybCA8Y29tcHV0ZS1yZWFjaGFibGUtaWNtcy11cmw+IFwKICBkb3duIFwKICAtLWNs" + + "dXN0ZXItbmFtZSA8Y29tcHV0ZS1wbGFuZS1jbHVzdGVyLW5hbWU+IFwKICAtLW5jYS1pZCA8bmNh" + + "LWlkPgpgYGAKClJlcGVhdCBgZG93bmAgZm9yIGVhY2ggY29tcHV0ZSBjbHVzdGVyLiBFYWNoIHJ1" + + "biBkZXN0cm95cyB0aGF0IGNvbXB1dGUgcGxhbmUgYW5kCnVucmVnaXN0ZXJzIGl0cyBJQ01TIHJv" + + "dy4gSXQgcmVtb3ZlcyB0aGUgY29udHJvbCBwbGFuZSBvbmx5IGFmdGVyIG5vIGNsdXN0ZXIKcmVn" + + "aXN0cmF0aW9ucyByZW1haW4uClBLBwiWY7xZEjAAABIwAABQSwMEFAAIAAAAAAAhAAAAAAAAAAAA" + + "AAAAADsACQBkYXRhL252Y2Ytc2VsZi1tYW5hZ2VkLWluc3RhbGxhdGlvbi9yZWZlcmVuY2VzL2Rl" + + "YnVnZ2luZy5tZFVUBQABAKbOEiMgRGVidWdnaW5nIFJlZmVyZW5jZQoKUmVjaXBlcyBmb3IgZGlh" + + "Z25vc2luZyBhbmQgZml4aW5nIGNvbW1vbiBOVkNGIHNlbGYtbWFuYWdlZCBzdGFjayBmYWlsdXJl" + + "cy4KCiMjIFF1aWNrIFN0YXR1cyBDb21tYW5kcwoKYGBgYmFzaAojIEFsbCBwb2RzIGFjcm9zcyBh" + + "bGwgbmFtZXNwYWNlcwprdWJlY3RsIGdldCBwb2RzIC1BIC1vIHdpZGUKCiMgUG9kcyBpbiBhIHNw" + + "ZWNpZmljIG5hbWVzcGFjZQprdWJlY3RsIGdldCBwb2RzIC1uIDxuYW1lc3BhY2U+CgojIEFsbCBo" + + "ZWxtIHJlbGVhc2VzCmhlbG0gbGlzdCAtQQoKIyBSZWNlbnQgZXZlbnRzIChtb3N0IHVzZWZ1bCBm" + + "b3IgZGlhZ25vc2luZyBmYWlsdXJlcykKa3ViZWN0bCBnZXQgZXZlbnRzIC1uIDxuYW1lc3BhY2U+" + + "IC0tc29ydC1ieT0nLmxhc3RUaW1lc3RhbXAnCgojIERlc2NyaWJlIGEgc3BlY2lmaWMgcG9kIChz" + + "aG93cyBldmVudHMsIGNvbmRpdGlvbnMsIHZvbHVtZXMpCmt1YmVjdGwgZGVzY3JpYmUgcG9kIC1u" + + "IDxuYW1lc3BhY2U+IDxwb2QtbmFtZT4KYGBgCgojIyBGYWlsdXJlOiBJbWFnZVB1bGxCYWNrT2Zm" + + "CgojIyMgU3ltcHRvbXMKCmBgYApOQU1FICAgICAgICAgICBSRUFEWSAgIFNUQVRVUyAgICAgICAg" + + "ICAgICBSRVNUQVJUUyAgIEFHRQpjYXNzYW5kcmEtMCAgICAwLzEgICAgIEltYWdlUHVsbEJhY2tP" + + "ZmYgICAwICAgICAgICAgIDVtCmBgYAoKRXZlbnRzIHNob3c6CmBgYApGYWlsZWQgdG8gcHVsbCBp" + + "bWFnZSAibnZjci5pby8uLi4vaW1hZ2U6dGFnIjogNDAxIFVuYXV0aG9yaXplZApgYGAKCiMjIyBE" + + "aWFnbm9zaXMKCmBgYGJhc2gKIyBDaGVjayB3aGF0IGltYWdlIGlzIGZhaWxpbmcKa3ViZWN0bCBk" + + "ZXNjcmliZSBwb2QgLW4gPG5hbWVzcGFjZT4gPHBvZC1uYW1lPiB8IGdyZXAgLUE1ICJFdmVudHM6" + + "IgoKIyBDaGVjayBpZiBwdWxsIHNlY3JldCBleGlzdHMgaW4gdGhlIG5hbWVzcGFjZQprdWJlY3Rs" + + "IGdldCBzZWNyZXQgbnZjci1jcmVkcyAtbiA8bmFtZXNwYWNlPgoKIyBDaGVjayBpZiB0aGUgcG9k" + + "IHNwZWMgaGFzIGltYWdlUHVsbFNlY3JldHMKa3ViZWN0bCBnZXQgcG9kIC1uIDxuYW1lc3BhY2U+" + + "IDxwb2QtbmFtZT4gLW8ganNvbnBhdGg9J3suc3BlYy5pbWFnZVB1bGxTZWNyZXRzfScKCiMgQ2hl" + + "Y2sgaWYgdGhlIFNlcnZpY2VBY2NvdW50IGhhcyBpbWFnZVB1bGxTZWNyZXRzCmt1YmVjdGwgZ2V0" + + "IHNhIDxzYS1uYW1lPiAtbiA8bmFtZXNwYWNlPiAtbyBqc29ucGF0aD0ney5pbWFnZVB1bGxTZWNy" + + "ZXRzfScKYGBgCgojIyMgRml4ZXMKCjEuICoqU2VjcmV0IG1pc3NpbmcgaW4gbmFtZXNwYWNlKio6" + + "IENyZWF0ZSBpdAogICBgYGBiYXNoCiAgIGt1YmVjdGwgY3JlYXRlIHNlY3JldCBkb2NrZXItcmVn" + + "aXN0cnkgbnZjci1jcmVkcyBcCiAgICAgLS1kb2NrZXItc2VydmVyPW52Y3IuaW8gXAogICAgIC0t" + + "ZG9ja2VyLXVzZXJuYW1lPSckb2F1dGh0b2tlbicgXAogICAgIC0tZG9ja2VyLXBhc3N3b3JkPSIk" + + "TkdDX0FQSV9LRVkiIFwKICAgICAtLW5hbWVzcGFjZT08bmFtZXNwYWNlPiBcCiAgICAgLS1kcnkt" + + "cnVuPWNsaWVudCAtbyB5YW1sIHwga3ViZWN0bCBhcHBseSAtZiAtCiAgIGBgYAoKMi4gKipTZWNy" + + "ZXQgZXhpc3RzIGJ1dCBwb2QgZG9lc24ndCByZWZlcmVuY2UgaXQqKjogVGhlIGNoYXJ0IG5lZWRz" + + "IGBpbWFnZVB1bGxTZWNyZXRzYCBjb25maWd1cmVkIHZpYSBoZWxtZmlsZSB2YWx1ZXMuIFNlZSBb" + + "cHVsbC1zZWNyZXRzLm1kXShwdWxsLXNlY3JldHMubWQpLgoKMy4gKipDaGFydCBkb2Vzbid0IHN1" + + "cHBvcnQgaW1hZ2VQdWxsU2VjcmV0cyoqIChvcGVuYmFvLCBpbnZvY2F0aW9uLXNlcnZpY2UsIGVz" + + "cy1hcGksIG5vdGFyeS1zZXJ2aWNlKTogUGF0Y2ggU2VydmljZUFjY291bnRzIGFuZCByZXN0YXJ0" + + "IHBvZHMuIFNlZSBbcHVsbC1zZWNyZXRzLm1kXShwdWxsLXNlY3JldHMubWQpLgoKNC4gKipXcm9u" + + "ZyBjcmVkZW50aWFscyBpbiBzZWNyZXQqKjogRGVsZXRlIGFuZCByZWNyZWF0ZQogICBgYGBiYXNo" + + "CiAgIGt1YmVjdGwgZGVsZXRlIHNlY3JldCBudmNyLWNyZWRzIC1uIDxuYW1lc3BhY2U+CiAgICMg" + + "UmVjcmVhdGUgd2l0aCBjb3JyZWN0IGNyZWRlbnRpYWxzCiAgIGBgYAoKIyMgRmFpbHVyZTogSW5p" + + "dDowLzEgU3R1Y2sgKFZhdWx0IEFnZW50KQoKIyMjIFN5bXB0b21zCgpTZXJ2aWNlIHBvZHMgc3R1" + + "Y2sgaW4gYEluaXQ6MC8xYCBmb3IgbWludXRlczoKYGBgCk5BTUUgICAgICAgICAgICAgICAgICAg" + + "ICAgICBSRUFEWSAgIFNUQVRVUyAgICAgUkVTVEFSVFMgICBBR0UKbnZjZi1hcGktN2Y0Yzc2Zjc4" + + "OC00NHZsdCAgMC8yICAgICBJbml0OjAvMSAgIDAgICAgICAgICAgMTBtCmBgYAoKIyMjIERpYWdu" + + "b3NpcwoKVGhlIGluaXQgY29udGFpbmVyIGlzIHRoZSB2YXVsdC1hZ2VudC1pbml0IGluamVjdG9y" + + "IHdhaXRpbmcgZm9yIE9wZW5CYW8uCgpgYGBiYXNoCiMgQ2hlY2sgT3BlbkJhbyBwb2RzCmt1YmVj" + + "dGwgZ2V0IHBvZHMgLW4gdmF1bHQtc3lzdGVtCgojIENoZWNrIGlmIE9wZW5CYW8gbWlncmF0aW9u" + + "IGpvYiByYW4Ka3ViZWN0bCBnZXQgam9icyAtbiB2YXVsdC1zeXN0ZW0KCiMgQ2hlY2sgT3BlbkJh" + + "byBwb2QgbG9ncwprdWJlY3RsIGxvZ3MgLW4gdmF1bHQtc3lzdGVtIG9wZW5iYW8tc2VydmVyLTAg" + + "LWMgb3BlbmJhbwoKIyBDaGVjayBpbml0IGNvbnRhaW5lciBsb2dzIG9uIHRoZSBzdHVjayBwb2QK" + + "a3ViZWN0bCBsb2dzIC1uIDxuYW1lc3BhY2U+IDxwb2QtbmFtZT4gLWMgdmF1bHQtYWdlbnQtaW5p" + + "dApgYGAKCiMjIyBGaXhlcwoKMS4gKipPcGVuQmFvIHBvZHMgbm90IHJ1bm5pbmcqKjogQ2hlY2sg" + + "dGhlaXIgZXZlbnRzIGZvciBpbWFnZSBwdWxsIGlzc3VlcywgcmVzb3VyY2UgaXNzdWVzLCBldGMu" + + "CgoyLiAqKk9wZW5CYW8gbWlncmF0aW9uIGpvYiBkaWRuJ3QgcnVuKio6IFRoaXMgaGFwcGVucyB3" + + "aGVuIGBoZWxtZmlsZSBzeW5jYCB3YXMgaW50ZXJydXB0ZWQuIERlc3Ryb3kgYW5kIHJlLXN5bmMg" + + "b3BlbmJhbzoKICAgYGBgYmFzaAogICBIRUxNRklMRV9FTlY9PGVudj4gaGVsbWZpbGUgLS1zZWxl" + + "Y3RvciBuYW1lPW9wZW5iYW8tc2VydmVyIGRlc3Ryb3kKICAga3ViZWN0bCBkZWxldGUgbmFtZXNw" + + "YWNlIHZhdWx0LXN5c3RlbQogICBrdWJlY3RsIGNyZWF0ZSBuYW1lc3BhY2UgdmF1bHQtc3lzdGVt" + + "CiAgICMgUmUtY3JlYXRlIHB1bGwgc2VjcmV0IGlmIG5lZWRlZAogICBIRUxNRklMRV9FTlY9PGVu" + + "dj4gaGVsbWZpbGUgLS1zZWxlY3RvciBuYW1lPW9wZW5iYW8tc2VydmVyIHN5bmMKICAgYGBgCgoz" + + "LiAqKk9wZW5CYW8gcG9kcyBydW5uaW5nIGJ1dCBub3QgaW5pdGlhbGl6ZWQqKjogQ2hlY2sgdW5z" + + "ZWFsIHN0YXR1czoKICAgYGBgYmFzaAogICBrdWJlY3RsIGV4ZWMgLW4gdmF1bHQtc3lzdGVtIG9w" + + "ZW5iYW8tc2VydmVyLTAgLWMgb3BlbmJhbyAtLSBiYW8gc3RhdHVzCiAgIGBgYAoKNC4gKipgdmF1" + + "bHQtYWdlbnQtaW5pdGAgbG9ncyBgYXV0aC9qd3QvbG9naW5gIC0+IGA0MDAgLi4uIG5vIGtub3du" + + "IGtleSBzdWNjZXNzZnVsbHkgdmFsaWRhdGVkIHRoZSB0b2tlbiBzaWduYXR1cmVgKioKICAgKGNv" + + "bW1vbiBvbiBBS1MsIGFuZCBvbiBhbnkgY2x1c3RlciB3aG9zZSBPSURDIGlzc3VlciBwdWJsaXNo" + + "ZXMgYSByb3RhdGluZyBtdWx0aS1rZXkgSldLUyk6CiAgIHRoZSBPcGVuQmFvIGBhdXRoL2p3dGAg" + + "bWV0aG9kIHdhcyBjb25maWd1cmVkIHdpdGggYSBzaW5nbGUgc3RhdGljIG1vdW50ZWQgcHVibGlj" + + "IGtleQogICAoYGp3dF92YWxpZGF0aW9uX3B1YmtleXNgKSBpbnN0ZWFkIG9mIHRoZSBpc3N1ZXIn" + + "cyBsaXZlIEpXS1MsIHNvIGl0IGNhbm5vdCB2YWxpZGF0ZSB0aGUKICAgY2x1c3Rlci1zaWduZWQg" + + "U2VydmljZUFjY291bnQgdG9rZW5zIHRoZSB2YXVsdC1hZ2VudHMgcHJlc2VudC4gRXZlcnkgc2Vy" + + "dmljZSdzCiAgIGB2YXVsdC1hZ2VudC1pbml0YCB0aGVuIGxvb3BzIG9uIHRoYXQgNDAwIGFuZCB0" + + "aGUgcG9kIG5ldmVyIGxlYXZlcyBgSW5pdDowLzFgLiBUaGlzIGlzIHRoZQogICBiZWhhdmlvciBv" + + "ZiB0aGUgYmFzZSBkZWZhdWx0IGBvcGVuYmFvLm1pZ3JhdGlvbnMuaXNzdWVyRGlzY292ZXJ5LmVu" + + "YWJsZWQ6IGZhbHNlYDsgdGhlCiAgIG1pZ3JhdGlvbiBsb2cgc2hvd3MgYE9JREMgaXNzdWVyIGRp" + + "c2NvdmVyeSBpcyBkaXNhYmxlZC4gVXNpbmcgU2VydmljZUFjY291bnQgaXNzdWVyIGFuZAogICBt" + + "b3VudGVkIHB1YmxpYyBrZXkgZmFsbGJhY2tgLiBFbmFibGUgaXNzdWVyIGRpc2NvdmVyeSBzbyB0" + + "aGUgbWlncmF0aW9uIHVzZXMgdGhlIGxpdmUgSldLUywKICAgdGhlbiByZS1ydW4gaXQ6CiAgIGBg" + + "YGJhc2gKICAgIyBJbiB5b3VyIGVudiB2YWx1ZXMgKGUuZy4gZW52aXJvbm1lbnRzLzxlbnY+Lnlh" + + "bWwpLCBzZXQ6CiAgICMgICBvcGVuYmFvOgogICAjICAgICBtaWdyYXRpb25zOgogICAjICAgICAg" + + "IGlzc3VlckRpc2NvdmVyeToKICAgIyAgICAgICAgIGVuYWJsZWQ6IHRydWUKICAga3ViZWN0bCBk" + + "ZWxldGUgam9iIC1uIHZhdWx0LXN5c3RlbSBvcGVuYmFvLXNlcnZlci1taWdyYXRpb25zCiAgIEhF" + + "TE1GSUxFX0VOVj08ZW52PiBoZWxtZmlsZSAtLXNlbGVjdG9yIG5hbWU9b3BlbmJhby1zZXJ2ZXIg" + + "c3luYwogICBgYGAKICAgVGhlIG1pZ3JhdGlvbiBsb2cgc2hvdWxkIHRoZW4gc2hvdyBgUmVjZWl2" + + "ZWQgZGlzY292ZXJ5IGRvY3VtZW50IGZyb20KICAgLi4uLy53ZWxsLWtub3duL29wZW5pZC1jb25m" + + "aWd1cmF0aW9uYCBhbmQgYEZpbmFsIE9wZW5CYW8gSldUIEpXS1MgVVJMIHNldCB0bzoKICAgLi4u" + + "L29wZW5pZC92MS9qd2tzYCwgYW5kIHRoZSBzZXJ2aWNlIHBvZHMgYXV0aGVudGljYXRlIGFuZCBy" + + "ZWFjaCBSZWFkeSB3aXRoaW4gfjEgbWluLgogICBBS1MgY2x1c3RlcnMgd2l0aCB0aGUgY2x1c3Rl" + + "ciBPSURDIGlzc3VlciBlbmFibGVkICh0aGUgYGFrcy1jbHVzdGVyYCBkZWZhdWx0KSBhbHdheXMg" + + "bmVlZAogICB0aGlzIGJlY2F1c2UgdGhlIHN0YXRpYy1wdWJrZXkgZmFsbGJhY2sgY2Fubm90IG1h" + + "dGNoIHRoZSBpc3N1ZXIncyByb3RhdGluZyBzaWduaW5nIGtleXMuCgojIyBGYWlsdXJlOiBPT01L" + + "aWxsZWQgb24gQ2Fzc2FuZHJhCgojIyMgU3ltcHRvbXMKCmBgYApOQU1FICAgICAgICAgIFJFQURZ" + + "ICAgU1RBVFVTICAgIFJFU1RBUlRTICAgQUdFCmNhc3NhbmRyYS0wICAgMC8xICAgICBPT01LaWxs" + + "ZWQgIDMgICAgICAgICAxMG0KYGBgCgojIyMgRGlhZ25vc2lzCgpgYGBiYXNoCmt1YmVjdGwgZGVz" + + "Y3JpYmUgcG9kIC1uIGNhc3NhbmRyYS1zeXN0ZW0gY2Fzc2FuZHJhLTAgfCBncmVwIC1BMyAiTGFz" + + "dCBTdGF0ZSIKYGBgCgojIyMgRml4CgpPdmVycmlkZSBDYXNzYW5kcmEgcmVzb3VyY2VzIHZpYSBo" + + "ZWxtZmlsZSB2YWx1ZXMuIFNlZSBFeGFtcGxlIDEgaW4KW2V4YW1wbGVzLm1kXSguLi9leGFtcGxl" + + "cy5tZCkuCgpgYGB5YW1sCi0gY2Fzc2FuZHJhOgogICAgcmVzb3VyY2VzOgogICAgICBsaW1pdHM6" + + "CiAgICAgICAgY3B1OiAiOCIKICAgICAgICBtZW1vcnk6IDgxOTJNaQogICAgICByZXF1ZXN0czoK" + + "ICAgICAgICBjcHU6ICIyIgogICAgICAgIG1lbW9yeTogNDA5Nk1pCmBgYAoKTm90ZTogYHJlc291" + + "cmNlUHJlc2V0YCBpcyBub3QgYXZhaWxhYmxlIGluIHRoZSBOVkNGIGNhc3NhbmRyYSB3cmFwcGVy" + + "IGNoYXJ0LiBVc2UgZXhwbGljaXQgYHJlc291cmNlc2AuCgojIyBGYWlsdXJlOiBQb2RzIFN0dWNr" + + "IGluIFBlbmRpbmcKCiMjIyBTeW1wdG9tcwoKYGBgCk5BTUUgICAgICAgICAgUkVBRFkgICBTVEFU" + + "VVMgICAgUkVTVEFSVFMgICBBR0UKY2Fzc2FuZHJhLTAgICAwLzEgICAgIFBlbmRpbmcgICAwICAg" + + "ICAgICAgIDEwbQpgYGAKCiMjIyBEaWFnbm9zaXMKCmBgYGJhc2gKIyBDaGVjayBldmVudHMgZm9y" + + "IHNjaGVkdWxpbmcgZmFpbHVyZXMKa3ViZWN0bCBkZXNjcmliZSBwb2QgLW4gPG5hbWVzcGFjZT4g" + + "PHBvZC1uYW1lPgoKIyBDb21tb24gY2F1c2VzOgojIC0gIjAvMTIgbm9kZXMgYXJlIGF2YWlsYWJs" + + "ZTogMTIgbm9kZShzKSBkaWRuJ3QgbWF0Y2ggUG9kJ3Mgbm9kZSBhZmZpbml0eSIKIyAtICIwLzEy" + + "IG5vZGVzIGFyZSBhdmFpbGFibGU6IDEyIEluc3VmZmljaWVudCBtZW1vcnkiCiMgLSAicGVyc2lz" + + "dGVudHZvbHVtZWNsYWltIG5vdCBmb3VuZCIKYGBgCgojIyMgRml4ZXMKCjEuICoqTm9kZSBzZWxl" + + "Y3RvciBtaXNtYXRjaCoqOiBDaGVjayBgbm9kZVNlbGVjdG9yc2AgaW4gZW52aXJvbm1lbnQgZmls" + + "ZQogICBgYGBiYXNoCiAgIGt1YmVjdGwgZ2V0IG5vZGVzIC0tc2hvdy1sYWJlbHMgfCBncmVwIG52" + + "Y2YKICAgYGBgCgoyLiAqKlN0b3JhZ2UgY2xhc3Mgbm90IGZvdW5kKio6IENoZWNrIHN0b3JhZ2Ug" + + "Y2xhc3MgZXhpc3RzCiAgIGBgYGJhc2gKICAga3ViZWN0bCBnZXQgc3RvcmFnZWNsYXNzCiAgIGBg" + + "YAoKMy4gKipJbnN1ZmZpY2llbnQgcmVzb3VyY2VzKio6IENoZWNrIG5vZGUgY2FwYWNpdHkKICAg" + + "YGBgYmFzaAogICBrdWJlY3RsIGRlc2NyaWJlIG5vZGUgPG5vZGUtbmFtZT4gfCBncmVwIC1BNSAi" + + "QWxsb2NhdGVkIHJlc291cmNlcyIKICAgYGBgCgojIyBGYWlsdXJlOiBIZWxtIFJlbGVhc2UgaW4g" + + "RmFpbGVkIFN0YXRlCgojIyMgU3ltcHRvbXMKCmBgYGJhc2gKaGVsbSBsaXN0IC1BCiMgU2hvd3Mg" + + "cmVsZWFzZSB3aXRoIFNUQVRVUzogZmFpbGVkCmBgYAoKUmUtcnVubmluZyBgaGVsbWZpbGUgc3lu" + + "Y2AgYXBwZWFycyB0byBzdWNjZWVkIGJ1dCBzZXJ2aWNlcyBkb24ndCB3b3JrIChtaWdyYXRpb25z" + + "IHNraXBwZWQpLgoKIyMjIERpYWdub3NpcwoKYGBgYmFzaApoZWxtIGhpc3RvcnkgPHJlbGVhc2Ut" + + "bmFtZT4gLW4gPG5hbWVzcGFjZT4KYGBgCgojIyMgRml4CgpNdXN0IGRlc3Ryb3kgdGhlIGZhaWxl" + + "ZCByZWxlYXNlIGFuZCByZS1zeW5jIChub3QganVzdCBhcHBseSk6CgpgYGBiYXNoCkhFTE1GSUxF" + + "X0VOVj08ZW52PiBoZWxtZmlsZSAtLXNlbGVjdG9yIG5hbWU9PHJlbGVhc2U+IGRlc3Ryb3kKIyBJ" + + "ZiBuYW1lc3BhY2UgbmVlZHMgY2xlYW51cDoKa3ViZWN0bCBkZWxldGUgbmFtZXNwYWNlIDxuYW1l" + + "c3BhY2U+Cmt1YmVjdGwgY3JlYXRlIG5hbWVzcGFjZSA8bmFtZXNwYWNlPgojIFJlLWNyZWF0ZSBw" + + "dWxsIHNlY3JldCBpZiBuZWVkZWQKSEVMTUZJTEVfRU5WPTxlbnY+IGhlbG1maWxlIC0tc2VsZWN0" + + "b3IgbmFtZT08cmVsZWFzZT4gc3luYwpgYGAKCiMjIEZhaWx1cmU6IEFjY291bnQgQm9vdHN0cmFw" + + "IEpvYiBGYWlsZWQKCiMjIyBTeW1wdG9tcwoKU2VydmljZXMgZGVwbG95IGJ1dCBmdW5jdGlvbnMg" + + "Y2FuJ3QgYmUgY3JlYXRlZC4gRXZlbnRzIHNob3cgYm9vdHN0cmFwIGpvYiBmYWlsdXJlLgoKIyMj" + + "IERpYWdub3NpcwoKYGBgYmFzaAojIENoZWNrIGJvb3RzdHJhcCBqb2Igc3RhdHVzCmt1YmVjdGwg" + + "Z2V0IGpvYnMgLW4gbnZjZgoKIyBHZXQgbG9ncyAoam9iIGF1dG8tZGVsZXRlcyBhZnRlciB+NSBt" + + "aW51dGVzKQprdWJlY3RsIGxvZ3Mgam9iL252Y2YtYXBpLWFjY291bnQtYm9vdHN0cmFwIC1uIG52" + + "Y2YKCiMgQ2hlY2sgQVBJIGxvZ3MKa3ViZWN0bCBsb2dzIC1uIG52Y2YgLWwgYXBwLmt1YmVybmV0" + + "ZXMuaW8vbmFtZT1udmNmLWFwaSAtLXRhaWw9MTAwCmBgYAoKIyMjIENvbW1vbiBDYXVzZXMKCjEu" + + "ICoqV3JvbmcgYmFzZTY0IGNyZWRlbnRpYWxzKio6IENyZWRlbnRpYWxzIGluIGBzZWNyZXRzLzxl" + + "bnY+LXNlY3JldHMueWFtbGAgbXVzdCBiZSBgJG9hdXRodG9rZW46QVBJX0tFWWAgYmFzZTY0LWVu" + + "Y29kZWQsIG5vdCBqdXN0IHRoZSBBUEkga2V5CiAgIGBgYGJhc2gKICAgIyBWZXJpZnkgeW91ciBl" + + "bmNvZGVkIGNyZWRlbnRpYWwKICAgZWNobyAnWU9VUl9CQVNFNjRfU1RSSU5HJyB8IGJhc2U2NCAt" + + "ZAogICAjIFNob3VsZCBvdXRwdXQ6ICRvYXV0aHRva2VuOm52YXBpLXh4eHh4CiAgIGBgYAoKMi4g" + + "KipSZWdpc3RyeSB1bnJlYWNoYWJsZSoqOiBBUEkgY2FuJ3QgcmVhY2ggdGhlIHJlZ2lzdHJ5IHNw" + + "ZWNpZmllZCBpbiBgYWNjb3VudEJvb3RzdHJhcC5yZWdpc3RyeUNyZWRlbnRpYWxzYAoKIyMjIEZp" + + "eAoKRml4IGNyZWRlbnRpYWxzIGluIHNlY3JldHMgZmlsZSwgdGhlbiByZWNvdmVyIHNlcnZpY2Vz" + + "IHdpdGhvdXQgZGVzdHJveWluZyBkZXBlbmRlbmNpZXM6CgpgYGBiYXNoCkhFTE1GSUxFX0VOVj08" + + "ZW52PiBoZWxtZmlsZSAtLXNlbGVjdG9yIHJlbGVhc2UtZ3JvdXA9c2VydmljZXMgZGVzdHJveQpr" + + "dWJlY3RsIGRlbGV0ZSBuYW1lc3BhY2UgbnZjZiBhcGkta2V5cyBlc3Mgc2lzIC0taWdub3JlLW5v" + + "dC1mb3VuZAprdWJlY3RsIGNyZWF0ZSBuYW1lc3BhY2UgbnZjZiAmJiBrdWJlY3RsIGNyZWF0ZSBu" + + "YW1lc3BhY2UgYXBpLWtleXMgJiYgXAogIGt1YmVjdGwgY3JlYXRlIG5hbWVzcGFjZSBlc3MgJiYg" + + "a3ViZWN0bCBjcmVhdGUgbmFtZXNwYWNlIHNpcwojIFJlLWNyZWF0ZSBwdWxsIHNlY3JldHMgaWYg" + + "bmVlZGVkCkhFTE1GSUxFX0VOVj08ZW52PiBoZWxtZmlsZSAtLXNlbGVjdG9yIHJlbGVhc2UtZ3Jv" + + "dXA9c2VydmljZXMgc3luYwpgYGAKCiMjIEZhaWx1cmU6IE5WQ0EgQ2xlYW51cCBTdHVjayAoRmlu" + + "YWxpemVycykKCiMjIyBTeW1wdG9tcwoKQ29tcHV0ZS1wbGFuZSBjbGVhbnVwIGhhbmdzLiBOYW1l" + + "c3BhY2VzCnN0dWNrIGluIGBUZXJtaW5hdGluZ2A6CgpgYGBiYXNoCmt1YmVjdGwgZ2V0IG5zCiMg" + + "bnZjYS1vcGVyYXRvciAgICBUZXJtaW5hdGluZyAgIDEwbQojIG52Y2YtYmFja2VuZCAgICAgVGVy" + + "bWluYXRpbmcgICAxMG0KYGBgCgojIyMgRml4CgpSdW4gdGhpcyBvbmx5IGFnYWluc3QgdGhlIGNv" + + "bXB1dGUgY29udGV4dCwgYWZ0ZXIgdGhlIG5vcm1hbCBjb21wdXRlLXBsYW5lCnRlYXJkb3duIGhh" + + "cyBmYWlsZWQuIFJlbW92ZSBmaW5hbGl6ZXJzIGZyb20gTlZDRkJhY2tlbmQgY3VzdG9tIHJlc291" + + "cmNlcyBhbmQKZm9yY2UtZGVsZXRlIHN0dWNrIG5hbWVzcGFjZXM6CgpgYGBiYXNoCmV4cG9ydCBD" + + "T01QVVRFX0NPTlRFWFQ9PGNvbXB1dGUtcGxhbmUtY29udGV4dD4KCiMgUmVtb3ZlIGZpbmFsaXpl" + + "cnMgZnJvbSBOVkNGQmFja2VuZCByZXNvdXJjZXMKa3ViZWN0bCAtLWNvbnRleHQgIiRDT01QVVRF" + + "X0NPTlRFWFQiIGdldCBudmNmYmFja2VuZHMgLUEgLW8ganNvbiB8IFwKICBqcSAnLml0ZW1zW10g" + + "fCAubWV0YWRhdGEubmFtZXNwYWNlICsgIi8iICsgLm1ldGFkYXRhLm5hbWUnIC1yIHwgXAogIHhh" + + "cmdzIC1Je30gc2ggLWMgJ2NvbnRleHQ9IiQxIjsgbnM9IiR7MiUlLyp9IjsgbmFtZT0iJHsyIyMq" + + "L30iOyBrdWJlY3RsIC0tY29udGV4dCAiJGNvbnRleHQiIHBhdGNoIG52Y2ZiYWNrZW5kICIkbmFt" + + "ZSIgLW4gIiRucyIgLS10eXBlPW1lcmdlIC1wICJ7XCJtZXRhZGF0YVwiOntcImZpbmFsaXplcnNc" + + "IjpbXX19IicgXyAiJENPTVBVVEVfQ09OVEVYVCIge30KCiMgRm9yY2UtZGVsZXRlIHN0dWNrIG5h" + + "bWVzcGFjZXMgYnkgY2xlYXJpbmcgdGhlaXIgZmluYWxpemVycwpmb3IgbnMgaW4gbnZjYS1vcGVy" + + "YXRvciBudmNmLWJhY2tlbmQ7IGRvCiAga3ViZWN0bCAtLWNvbnRleHQgIiRDT01QVVRFX0NPTlRF" + + "WFQiIGdldCBuYW1lc3BhY2UgIiRucyIgLW8ganNvbiAyPi9kZXYvbnVsbCB8IFwKICAgIGpxICcu" + + "c3BlYy5maW5hbGl6ZXJzID0gW10nIHwgXAogICAga3ViZWN0bCAtLWNvbnRleHQgIiRDT01QVVRF" + + "X0NPTlRFWFQiIHJlcGxhY2UgXAogICAgICAtLXJhdyAiL2FwaS92MS9uYW1lc3BhY2VzLyRucy9m" + + "aW5hbGl6ZSIgLWYgLSAyPi9kZXYvbnVsbApkb25lCmBgYAoKIyMgRmFpbHVyZTogTlZDQSBPcGVy" + + "YXRvciBNaXNzaW5nIG9yIE5vdCBSZWFkeQoKIyMjIFN5bXB0b21zCgpBZnRlciBjb21wdXRlLXBs" + + "YW5lIGluc3RhbGwgY29tcGxldGVzLCBubyBgbnZjYS1vcGVyYXRvcmAgRGVwbG95bWVudCBleGlz" + + "dHMsIG9yCml0IGV4aXN0cyBidXQgcG9kcyBhcmUgbm90IHJlYWR5OgoKYGBgYmFzaAprdWJlY3Rs" + + "IC0tY29udGV4dCA8Y29tcHV0ZS1wbGFuZS1jb250ZXh0PiBnZXQgZGVwbG95bWVudCBudmNhLW9w" + + "ZXJhdG9yIFwKICAtbiBudmNhLW9wZXJhdG9yCmt1YmVjdGwgLS1jb250ZXh0IDxjb21wdXRlLXBs" + + "YW5lLWNvbnRleHQ+IGdldCBwb2RzIC1uIG52Y2Etb3BlcmF0b3IKYGBgCgojIyMgRGlhZ25vc2lz" + + "IGFuZCBGaXhlcwoKRmlyc3QgaWRlbnRpZnkgd2hldGhlciB0aGUgaW5zdGFsbGF0aW9uIHVzZWQg" + + "dGhlIEhlbG1maWxlIHZhbHVlcyBmbG93IG9yIHRoZQpDTEkgcHJvZmlsZSBmbG93LiBSZS1ydW4g" + + "b25seSB0aGF0IGZsb3cncyByZWdpc3RyYXRpb24gYW5kIGluc3RhbGxhdGlvbiBzdGVwcwpmcm9t" + + "IFtTcGxpdCBDb21wdXRlLVBsYW5lIEluc3RhbGxhdGlvbl0oY29tcHV0ZS1wbGFuZS1pbnN0YWxs" + + "YXRpb24ubWQpLiBEbyBub3QKc3Vic3RpdHV0ZSBvbmUgaGFuZG9mZiBmb3IgdGhlIG90aGVyLgoK" + + "SWYgaW5zdGFsbGF0aW9uIHN1Y2NlZWRzIGJ1dCBwb2RzIHN0aWxsIGZhaWwsIGluc3BlY3QgdGhl" + + "IGNvbXB1dGUgY29udGV4dDoKCmBgYGJhc2gKa3ViZWN0bCAtLWNvbnRleHQgPGNvbXB1dGUtcGxh" + + "bmUtY29udGV4dD4gZGVzY3JpYmUgZGVwbG95IG52Y2Etb3BlcmF0b3IgXAogIC1uIG52Y2Etb3Bl" + + "cmF0b3IKa3ViZWN0bCAtLWNvbnRleHQgPGNvbXB1dGUtcGxhbmUtY29udGV4dD4gbG9ncyBkZXBs" + + "b3ltZW50L252Y2Etb3BlcmF0b3IgXAogIC1uIG52Y2Etb3BlcmF0b3IgLS10YWlsPTIwMAprdWJl" + + "Y3RsIC0tY29udGV4dCA8Y29tcHV0ZS1wbGFuZS1jb250ZXh0PiBnZXQgbnZjZmJhY2tlbmQgLW4g" + + "bnZjYS1vcGVyYXRvcgpgYGAKCkZvciBwcml2YXRlIHJlZ2lzdHJ5IGZhaWx1cmVzLCB2ZXJpZnkg" + + "dGhhdCB0aGUgcHVsbCBzZWNyZXQgZXhpc3RzIGluCmBudmNhLW9wZXJhdG9yYC4gVGhlIGNoYXJ0" + + "IGFuZCBvcGVyYXRvciBtaXJyb3IgaXQgdG8gYG52Y2Etc3lzdGVtYDsgZG8gbm90IHVzZSBhCmJy" + + "b2FkZXIgbWFudWFsIG5hbWVzcGFjZSBsb29wLiBTZWUKW3B1bGwtc2VjcmV0cy5tZF0ocHVsbC1z" + + "ZWNyZXRzLm1kI2NvbXB1dGUtcGxhbmUtc2VjcmV0KS4KCiMjIEZhaWx1cmU6IEdhdGV3YXkgRW5k" + + "cG9pbnQgQ2hhbmdlZAoKIyMjIFN5bXB0b21zCgpSZXF1ZXN0cyB0aHJvdWdoIHRoZSBjb25maWd1" + + "cmVkIHJvdXRlIGRvbWFpbiBmYWlsIGFmdGVyIHRoZSBHYXRld2F5IG9yIGl0cyBsb2FkIGJhbGFu" + + "Y2VyIGlzIHJlcGxhY2VkLiBUaGUgR2F0ZXdheSByZXBvcnRzIGEgbmV3IGVuZHBvaW50LgoKIyMj" + + "IERpYWdub3NpcwoKYGBgYmFzaApHQVRFV0FZX0FERFI9JChrdWJlY3RsIC0tY29udGV4dCA8Y29u" + + "dHJvbC1wbGFuZS1jb250ZXh0PiBnZXQgZ2F0ZXdheSBcCiAgbnZjZi1nYXRld2F5IC1uIGVudm95" + + "LWdhdGV3YXkgXAogIC1vIGpzb25wYXRoPSd7LnN0YXR1cy5hZGRyZXNzZXNbMF0udmFsdWV9JykK" + + "dGVzdCAtbiAiJEdBVEVXQVlfQUREUiIKZGlnICtzaG9ydCAiYXBpLjxkb21haW4+IgpjdXJsIC1I" + + "ICJIb3N0OiBhcGkuPGRvbWFpbj4iICJodHRwOi8vJEdBVEVXQVlfQUREUi9oZWFsdGgiCgojIENo" + + "ZWNrIGRpcmVjdCBhZGRyZXNzIGZpZWxkcyB1c2VkIGJ5IGEgc3BsaXQgZGVwbG95bWVudApncmVw" + + "IG52Y2ZOYXRzU2VydmljZVVSTCBkZXBsb3kvc3RhY2tzL3NlbGYtbWFuYWdlZC9lbnZpcm9ubWVu" + + "dHMvPGVudj4ueWFtbApncmVwIC1FICdpY21zU2VydmljZXxyZXZhbFNlcnZpY2V8bmF0cycgXAog" + + "IGRlcGxveS9zdGFja3MvbnZjZi1jb21wdXRlLXBsYW5lL2Vudmlyb25tZW50cy88ZW52Pi55YW1s" + + "CmBgYAoKIyMjIEZpeAoKS2VlcCBgZ2xvYmFsLmRvbWFpbmAsIHJvdXRlIGhvc3RuYW1lcywgYW5k" + + "IEhvc3Qgb3ZlcnJpZGVzIHVuY2hhbmdlZC4gVXBkYXRlIEROUwpvciB0aGUgZGlyZWN0IGNsaWVu" + + "dCBkZXN0aW5hdGlvbi4gRm9yIHNwbGl0IGRlcGxveW1lbnRzLCB1cGRhdGUgb25seSBkaXJlY3QK" + + "R2F0ZXdheS1hZGRyZXNzIGZpZWxkcyBhbmQgcmVmcmVzaCByZWdpc3RyYXRpb24gYW5kIGluc3Rh" + + "bGxhdGlvbiB0aHJvdWdoIHRoZQpzYW1lIHNlbGVjdGVkIGhhbmRvZmYuIFNlZQpbRXhhbXBsZSA0" + + "XSguLi9leGFtcGxlcy5tZCNleGFtcGxlLTQtcmVjb3Zlci1mcm9tLWEtZ2F0ZXdheS1lbmRwb2lu" + + "dC1jaGFuZ2UpLgoKIyMgVXNlZnVsIE5hbWVzcGFjZS10by1TZXJ2aWNlIE1hcHBpbmcKClF1aWNr" + + "IHJlZmVyZW5jZSBmb3Igd2hpY2ggc2VydmljZXMgcnVuIGluIHdoaWNoIG5hbWVzcGFjZToKCnwg" + + "TmFtZXNwYWNlIHwgU2VydmljZXMgfAp8LS0tLS0tLS0tLS18LS0tLS0tLS0tLXwKfCBuYXRzLXN5" + + "c3RlbSB8IG5hdHMgfAp8IGNhc3NhbmRyYS1zeXN0ZW0gfCBjYXNzYW5kcmEgfAp8IHZhdWx0LXN5" + + "c3RlbSB8IG9wZW5iYW8tc2VydmVyIHwKfCBudmNmIHwgYXBpLCBpbnZvY2F0aW9uLXNlcnZpY2Us" + + "IGdycGMtcHJveHksIG5vdGFyeS1zZXJ2aWNlLCByZXZhbCwgbGxtLXJlcXVlc3Qtcm91dGVyLCBs" + + "bG0tYXBpLWdhdGV3YXkgfAp8IGFwaS1rZXlzIHwgYXBpLWtleXMsIGFkbWluLWlzc3Vlci1wcm94" + + "eSB8CnwgZXNzIHwgZXNzLWFwaSB8Cnwgc2lzIHwgc2lzIHwKfCBlbnZveS1nYXRld2F5LXN5c3Rl" + + "bSB8IGVudm95IGdhdGV3YXkgKGluZ3Jlc3MgY29udHJvbGxlcikgfAp8IGVudm95LWdhdGV3YXkg" + + "fCBnYXRld2F5IHJlc291cmNlICsgcm91dGVzIHwKUEsHCFY+Z5CVMAAAlTAAAFBLAwQUAAgAAAAA" + + "ACEAAAAAAAAAAAAAAAAARAAJAGRhdGEvbnZjZi1zZWxmLW1hbmFnZWQtaW5zdGFsbGF0aW9uL3Jl" + + "ZmVyZW5jZXMvaGVsbWZpbGUtc3RydWN0dXJlLm1kVVQFAAEAps4SIyBIZWxtZmlsZSBTdHJ1Y3R1" + + "cmUgUmVmZXJlbmNlCgojIyBEaXJlY3RvcnkgTGF5b3V0CgpgYGAKbnZjZi1zZWxmLW1hbmFnZWQt" + + "c3RhY2svCnwtLSBoZWxtZmlsZS5kLwp8ICAgfC0tIDAxLWRlcGVuZGVuY2llcy55YW1sLmdvdG1w" + + "bCAgIyBOQVRTLCBDYXNzYW5kcmEsIE9wZW5CYW8KfCAgIHwtLSAwMi1jb3JlLnlhbWwuZ290bXBs" + + "ICAgICAgICAgICMgTlZDRiBzZXJ2aWNlcyArIGluZ3Jlc3MKfCAgIGAtLSAwMy1vYnNlcnZhYmls" + + "aXR5LnlhbWwuZ290bXBsICMgT2JzZXJ2YWJpbGl0eSBzdGFjayAob3B0aW9uYWwpCnwtLSBlbnZp" + + "cm9ubWVudHMvCnwgICB8LS0gYmFzZS55YW1sICAgICAgICAgICAgICAgICAgICAjIERlZmF1bHQg" + + "dmFsdWVzIChhbGwgZW52aXJvbm1lbnRzKQp8ICAgYC0tIDxlbnYtbmFtZT4ueWFtbCAgICAgICAg" + + "ICAgICAgIyBQZXItZW52aXJvbm1lbnQgb3ZlcnJpZGVzCnwtLSBzZWNyZXRzLwp8ICAgYC0tIDxl" + + "bnYtbmFtZT4tc2VjcmV0cy55YW1sICAgICAgIyBTZW5zaXRpdmUgdmFsdWVzIChyZWdpc3RyeSBj" + + "cmVkcywgcGFzc3dvcmRzKQpgLS0gZ2xvYmFsLnlhbWwuZ290bXBsICAgICAgICAgICAgICAgIyBH" + + "byB0ZW1wbGF0ZSB0aGF0IGNvbnN0cnVjdHMgcGVyLWNoYXJ0IHZhbHVlcwoKbnZjZi1jb21wdXRl" + + "LXBsYW5lLXN0YWNrLwp8LS0gaGVsbWZpbGUuZC8KfCAgIHwtLSAwMS1kZXBlbmRlbmNpZXMueWFt" + + "bC5nb3RtcGwgICMgQ29tcHV0ZSBwbGFuZSBkZXBlbmRlbmN5IGNvbXBvbmVudHMKfCAgIGAtLSAw" + + "Mi1udmNhLnlhbWwuZ290bXBsICAgICAgICAgICMgbnZjYS1vcGVyYXRvciBjaGFydCBhbmQgbnZj" + + "YSBjb25maWd1cmF0aW9uCnwtLSBlbnZpcm9ubWVudHMvCnwgICB8LS0gYmFzZS55YW1sICAgICAg" + + "ICAgICAgICAgICAgICAjIERlZmF1bHQgdmFsdWVzIChhbGwgZW52aXJvbm1lbnRzKQp8ICAgYC0t" + + "IDxlbnYtbmFtZT4ueWFtbCAgICAgICAgICAgICAgIyBQZXItZW52aXJvbm1lbnQgb3ZlcnJpZGVz" + + "CmAtLSBnbG9iYWwueWFtbC5nb3RtcGwgICAgICAgICAgICAgICAjIEdvIHRlbXBsYXRlIHRoYXQg" + + "Y29uc3RydWN0cyBwZXItY2hhcnQgdmFsdWVzCmBgYAoKVGhlc2Ugc3RhY2tzIGhhdmUgc2VwYXJh" + + "dGUgZW52aXJvbm1lbnRzIGFuZCBjbHVzdGVyIGNvbnRleHRzLiBUaGUgSGVsbWZpbGUKdmFsdWVz" + + "IGZsb3cgYXV0aG9ycyBib3RoIGVudmlyb25tZW50IGZpbGVzLiBUaGUgQ0xJIHByb2ZpbGUgZmxv" + + "dyBpbnN0ZWFkIHVzZXMKdGhlIENMSS1nZW5lcmF0ZWQgY29udHJvbC1wbGFuZSBwcm9maWxlIGFz" + + "IGl0cyBlbmRwb2ludCBzb3VyY2UuIERvIG5vdCBtaXggdGhlCmhhbmRvZmZzLiBTZWUgW1NwbGl0" + + "IENvbXB1dGUtUGxhbmUgSW5zdGFsbGF0aW9uXShjb21wdXRlLXBsYW5lLWluc3RhbGxhdGlvbi5t" + + "ZCkuCgojIyBHb3RtcGwgRmlsZXMgYW5kIFRoZWlyIFJlbGVhc2VzCgojIyMgMDEtZGVwZW5kZW5j" + + "aWVzLnlhbWwuZ290bXBsCgp8IFJlbGVhc2UgfCBDaGFydCB8IE5hbWVzcGFjZSB8IE5vdGVzIHwK" + + "fC0tLS0tLS0tLXwtLS0tLS0tfC0tLS0tLS0tLS0tfC0tLS0tLS18CnwgbmF0cyB8IGhlbG0tbnZj" + + "Zi1uYXRzIHwgbmF0cy1zeXN0ZW0gfCBNZXNzYWdpbmcgfAp8IG9wZW5iYW8tc2VydmVyIHwgaGVs" + + "bS1udmNmLW9wZW5iYW8tc2VydmVyIHwgdmF1bHQtc3lzdGVtIHwgU2VjcmV0cyBtYW5hZ2VtZW50" + + "LCBkZXBlbmRzIG9uIG5hdHMgfAp8IGNhc3NhbmRyYSB8IGhlbG0tbnZjZi1jYXNzYW5kcmEgfCBj" + + "YXNzYW5kcmEtc3lzdGVtIHwgRGF0YWJhc2UgfAoKVXNlcyBgPDw6ICpkZXBlbmRlbmN5YCB0ZW1w" + + "bGF0ZSBpbmhlcml0YW5jZSB3aXRoIGByZWxlYXNlLWdyb3VwOiBkZXBlbmRlbmNpZXNgIGxhYmVs" + + "LgoKIyMjIDAyLWNvcmUueWFtbC5nb3RtcGwKCnwgUmVsZWFzZSB8IENoYXJ0IHwgTmFtZXNwYWNl" + + "IHwgTGFiZWwgfAp8LS0tLS0tLS0tfC0tLS0tLS18LS0tLS0tLS0tLS18LS0tLS0tLXwKfCBhcGkt" + + "a2V5cyB8IGhlbG0tbnZjZi1hcGkta2V5cyB8IGFwaS1rZXlzIHwgc2VydmljZXMgfAp8IHNpcyB8" + + "IGhlbG0tbnZjZi1zaXMgfCBzaXMgfCBzZXJ2aWNlcyB8CnwgYXBpIHwgaGVsbS1udmNmLWFwaSB8" + + "IG52Y2YgfCBzZXJ2aWNlcyB8CnwgaW52b2NhdGlvbi1zZXJ2aWNlIHwgaGVsbS1udmNmLWludm9j" + + "YXRpb24tc2VydmljZSB8IG52Y2YgfCBzZXJ2aWNlcyB8CnwgZ3JwYy1wcm94eSB8IGhlbG0tbnZj" + + "Zi1ncnBjLXByb3h5IHwgbnZjZiB8IHNlcnZpY2VzIHwKfCBlc3MtYXBpIHwgaGVsbS1udmNmLWVz" + + "cy1hcGkgfCBlc3MgfCBzZXJ2aWNlcyB8Cnwgbm90YXJ5LXNlcnZpY2UgfCBoZWxtLW52Y2Ytbm90" + + "YXJ5LXNlcnZpY2UgfCBudmNmIHwgc2VydmljZXMgfAp8IHJldmFsIHwgaGVsbS1yZXZhbCB8IG52" + + "Y2YgfCBzZXJ2aWNlcyB8CnwgbGxtLXJlcXVlc3Qtcm91dGVyIHwgbnZjZi9oZWxtLW52Y2YtbGxt" + + "LXJlcXVlc3Qtcm91dGVyIHwgbnZjZiB8IHNlcnZpY2VzIHwKfCBsbG0tYXBpLWdhdGV3YXkgfCBu" + + "dmNmL2hlbG0tbnZjZi1sbG0tYXBpLWdhdGV3YXkgfCBudmNmIHwgc2VydmljZXMgfAp8IGFkbWlu" + + "LWlzc3Vlci1wcm94eSB8IGhlbG0tYWRtaW4tdG9rZW4taXNzdWVyLXByb3h5IHwgYXBpLWtleXMg" + + "fCAobm8gcmVsZWFzZS1ncm91cCBsYWJlbCkgfAp8IGluZ3Jlc3MgfCBudmNmLWdhdGV3YXktcm91" + + "dGVzIHwgZW52b3ktZ2F0ZXdheS1zeXN0ZW0gfCBpbmdyZXNzIHwKCk1vc3Qgc2VydmljZXMgdXNl" + + "IGBpbmhlcml0OiBbe3RlbXBsYXRlOiBzZXJ2aWNlfV1gLiBMTE0gcmVsZWFzZXMgdXNlIE9DSSBj" + + "aGFydHMgZnJvbSB0aGUgYG52Y2ZgIHJlcG9zaXRvcnkgd2l0aCBzdGFuZGFsb25lIGB2YWx1ZXM6" + + "IFsuLi9nbG9iYWwueWFtbC5nb3RtcGxdYCBibG9ja3M7IHRoZXkgYXJlIGdhdGVkIG9uIGBhZGRv" + + "bnMubGxtLmVuYWJsZWRgLiBgYWRtaW4taXNzdWVyLXByb3h5YCBhbmQgYGluZ3Jlc3NgIGhhdmUg" + + "c3RhbmRhbG9uZSBgdmFsdWVzOmAgYmxvY2tzLgoKIyMjIDAzLW9ic2VydmFiaWxpdHkueWFtbC5n" + + "b3RtcGwKCnwgUmVsZWFzZSB8IENoYXJ0IHwgTmFtZXNwYWNlIHwgTGFiZWwgfAp8LS0tLS0tLS0t" + + "fC0tLS0tLS18LS0tLS0tLS0tLS18LS0tLS0tLXwKfCAob2JzZXJ2YWJpbGl0eSByZWxlYXNlcykg" + + "fCAodmFyaW91cykgfCBvYnNlcnZhYmlsaXR5IHwgb2JzZXJ2YWJpbGl0eSB8CgpHYXRlZCBvbiBv" + + "YnNlcnZhYmlsaXR5LXNwZWNpZmljIGZsYWdzIGluIHRoZSBlbnZpcm9ubWVudCBmaWxlLiBTa2lw" + + "cGVkIGlmIGRpc2FibGVkLgoKIyMgVGVtcGxhdGUgSW5oZXJpdGFuY2UKCiMjIyBgPDw6ICpkZXBl" + + "bmRlbmN5YCAoWUFNTCBtZXJnZSkKClVzZWQgaW4gYDAxLWRlcGVuZGVuY2llcy55YW1sLmdvdG1w" + + "bGAuIE1lcmdlcyB0aGUgdGVtcGxhdGUncyBwcm9wZXJ0aWVzIGludG8gdGhlIHJlbGVhc2UuCgoq" + + "KkdvdGNoYSoqOiBZQU1MIG1lcmdlIHJlcGxhY2VzIGxpc3RzLiBJZiB5b3UgYWRkIGEgYHZhbHVl" + + "czpgIGtleSB0byB0aGUgcmVsZWFzZSwgaXQgKipyZXBsYWNlcyoqIHRoZSB0ZW1wbGF0ZSdzIGB2" + + "YWx1ZXM6YCBsaXN0IGVudGlyZWx5LiBZb3UgbXVzdCByZS1pbmNsdWRlIGFsbCB0ZW1wbGF0ZSB2" + + "YWx1ZXM6CgpJbiB0aGUgdGVtcGxhdGUgYmVsb3csIGA8cHJpdmF0ZS12YWx1ZXM+YCByZWZlcnMg" + + "dG8gdGhlIGBzZWNyZXRzL2AgZGlyZWN0b3J5IGF0IHRoZSBoZWxtZmlsZSBzdGFjayByb290LgoK" + + "YGBgeWFtbAojIFRlbXBsYXRlIGRlZmluZXM6CnRlbXBsYXRlczoKICBkZXBlbmRlbmN5OiAmZGVw" + + "ZW5kZW5jeQogICAgY2hhcnQ6IG52Y2YvaGVsbS1udmNmLXt7IC5SZWxlYXNlLk5hbWUgfX0KICAg" + + "IHZhbHVlczoKICAgICAgLSAuLi9nbG9iYWwueWFtbC5nb3RtcGwKICAgICAgLSAuLi88cHJpdmF0" + + "ZS12YWx1ZXM+L3t7IHJlcXVpcmVkRW52ICJIRUxNRklMRV9FTlYiIH19LXNlY3JldHMueWFtbAoK" + + "IyBXaGVuIG92ZXJyaWRpbmcsIE1VU1QgcmUtaW5jbHVkZSBib3RoOgotIG5hbWU6IGNhc3NhbmRy" + + "YQogIDw8OiAqZGVwZW5kZW5jeQogIHZhbHVlczoKICAgIC0gLi4vZ2xvYmFsLnlhbWwuZ290bXBs" + + "ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICMgTXVzdCByZS1p" + + "bmNsdWRlCiAgICAtIC4uLzxwcml2YXRlLXZhbHVlcz4ve3sgcmVxdWlyZWRFbnYgIkhFTE1GSUxF" + + "X0VOViIgfX0tc2VjcmV0cy55YW1sICAgIyBNdXN0IHJlLWluY2x1ZGUKICAgIC0gY2Fzc2FuZHJh" + + "OiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg" + + "ICAjIFlvdXIgb3ZlcnJpZGUKICAgICAgICByZXNvdXJjZXM6CiAgICAgICAgICBsaW1pdHM6CiAg" + + "ICAgICAgICAgIG1lbW9yeTogODE5Mk1pCmBgYAoKIyMjIGBpbmhlcml0YCAoSGVsbWZpbGUgbmF0" + + "aXZlKQoKVXNlZCBpbiBgMDItY29yZS55YW1sLmdvdG1wbGAuIEhlbG1maWxlJ3MgbmF0aXZlIGlu" + + "aGVyaXRhbmNlIG1lY2hhbmlzbS4KCmBgYHlhbWwKLSBuYW1lOiBhcGkKICB2ZXJzaW9uOiAxLjYu" + + "MAogIG5hbWVzcGFjZTogbnZjZgogIGluaGVyaXQ6CiAgICAtIHRlbXBsYXRlOiBzZXJ2aWNlCmBg" + + "YAoKV2hlbiBhZGRpbmcgYHZhbHVlczpgIHRvIGFuIGluaGVyaXRlZCByZWxlYXNlLCB5b3UgYWxz" + + "byBuZWVkIHRvIHJlLWluY2x1ZGUgdGhlIHRlbXBsYXRlJ3MgdmFsdWVzIGZpbGVzIHNpbmNlIGB2" + + "YWx1ZXNgIGlzIGEgbGlzdCB0aGF0IGdldHMgcmVwbGFjZWQuCgojIyBWYWx1ZXMgUHJlY2VkZW5j" + + "ZQoKRnJvbSBsb3dlc3QgdG8gaGlnaGVzdCBwcmlvcml0eToKCjEuIGBlbnZpcm9ubWVudHMvYmFz" + + "ZS55YW1sYCAtLSBkZWZhdWx0cyBzaGFyZWQgYWNyb3NzIGFsbCBlbnZpcm9ubWVudHMKMi4gYGVu" + + "dmlyb25tZW50cy88ZW52Pi55YW1sYCAtLSBwZXItZW52aXJvbm1lbnQgb3ZlcnJpZGVzCjMuIGBn" + + "bG9iYWwueWFtbC5nb3RtcGxgIC0tIEdvIHRlbXBsYXRlIHByb2Nlc3NpbmcgKGNvbnN0cnVjdHMg" + + "Y2hhcnQtc3BlY2lmaWMgc3RydWN0dXJlKQo0LiBgPHByaXZhdGUtdmFsdWVzPi88ZW52Pi1zZWNy" + + "ZXRzLnlhbWxgIC0tIHNlbnNpdGl2ZSB2YWx1ZXMKNS4gSW5saW5lIGB2YWx1ZXM6YCBibG9ja3Mg" + + "b24gcmVsZWFzZXMgLS0gaGlnaGVzdCBwcmVjZWRlbmNlCgojIyBXaGF0IGdsb2JhbC55YW1sLmdv" + + "dG1wbCBQYXNzZXMgVGhyb3VnaAoKYGdsb2JhbC55YW1sLmdvdG1wbGAgcmVhZHMgZnJvbSBgLlZh" + + "bHVlc2AgKHRoZSBtZXJnZWQgZW52aXJvbm1lbnQgKyBlbnYtc3BlY2lmaWMgWUFNTCkgYW5kIGNv" + + "bnN0cnVjdHMgY2hhcnQtc3BlY2lmaWMgdmFsdWVzLiBJdCBvbmx5IHBhc3NlcyB0aHJvdWdoIGtl" + + "eXMgaXQgZXhwbGljaXRseSByZWZlcmVuY2VzOgoKIyMjIENhc3NhbmRyYQotIGBjYXNzYW5kcmEu" + + "cmVwbGljYUNvdW50YAotIGBjYXNzYW5kcmEuaW1hZ2UuKmAgKHJlZ2lzdHJ5LCByZXBvc2l0b3J5" + + "KQotIGBjYXNzYW5kcmEubWlncmF0aW9ucy5pbWFnZS4qYAotIGBjYXNzYW5kcmEucGVyc2lzdGVu" + + "Y2Uuc2l6ZWAKLSBgY2Fzc2FuZHJhLm5vZGVTZWxlY3RvcmAgKGlmIGBnbG9iYWwubm9kZVNlbGVj" + + "dG9ycy5lbmFibGVkYCkKLSBgY2Fzc2FuZHJhLmdsb2JhbC5kZWZhdWx0U3RvcmFnZUNsYXNzYAoK" + + "IyMjIE5BVFMKLSBgbmF0cy5jb250YWluZXIuaW1hZ2UuKmAKLSBgbmF0cy5yZWxvYWRlci5pbWFn" + + "ZS4qYAotIGBuYXRzLm5hdHNCb3guY29udGFpbmVyLmltYWdlLipgCi0gYG5hdHMuY29uZmlnLmpl" + + "dHN0cmVhbS5maWxlU3RvcmUucHZjLnN0b3JhZ2VDbGFzc05hbWVgCi0gYG5hdHMucG9kVGVtcGxh" + + "dGUubWVyZ2Uuc3BlYy5ub2RlU2VsZWN0b3JgIChpZiBlbmFibGVkKQoKIyMjIE9wZW5CYW8KLSBg" + + "b3BlbmJhby5taWdyYXRpb25zLmltYWdlLipgIGFuZCBgb3BlbmJhby5taWdyYXRpb25zLmVudmAK" + + "LSBgb3BlbmJhby5pbmplY3Rvci5pbWFnZS4qYAotIGBvcGVuYmFvLnNlcnZlci5pbWFnZS4qYAot" + + "IGBvcGVuYmFvLnNlcnZlci5kYXRhU3RvcmFnZS4qYAotIE5vZGUgc2VsZWN0b3JzIChpZiBlbmFi" + + "bGVkKQoKIyMjIFNlcnZpY2VzIChBUEksIFNJUywgZXRjLikKLSBgPHNlcnZpY2U+LmltYWdlLipg" + + "IChyZWdpc3RyeSwgcmVwb3NpdG9yeSkKLSBgPHNlcnZpY2U+Lm5vZGVTZWxlY3RvcmAgKGlmIGVu" + + "YWJsZWQpCi0gYDxzZXJ2aWNlPi5lbnYuKmAgKG9ic2VydmFiaWxpdHkgc2V0dGluZ3MpCgojIyMg" + + "TExNIEZ1bmN0aW9uIEVuYWJsZW1lbnQKCkVuYWJsZSB0aGUgTExNIGFkZG9uIGJlZm9yZSBjcmVh" + + "dGluZyBvciBpbnZva2luZyBmdW5jdGlvbnMgd2l0aApgZnVuY3Rpb25UeXBlOiAiTExNImAuIFRo" + + "ZSBhZGRvbiBkZXBsb3lzIGBsbG0tcmVxdWVzdC1yb3V0ZXJgIGFuZApgbGxtLWFwaS1nYXRld2F5" + + "YCwgYWRkcyB0aGUgYGxsbS5pbnZvY2F0aW9uLjxkb21haW4+YCByb3V0ZSB3aGVuIEdhdGV3YXkg" + + "QVBJCmluZ3Jlc3MgaXMgZW5hYmxlZCwgYW5kIGNvbmZpZ3VyZXMgd29ya2VycyB0byB1c2UgdGhl" + + "IExMTSBzaWRlY2FyLiBUaGUgSGVsbWZpbGUKY29uZGl0aW9uIGlzIGBhZGRvbnMubGxtLmVuYWJs" + + "ZWRgLiBEbyBub3QgdXNlIHRoZSBvYnNvbGV0ZSBgbGxtLmVuYWJsZWRgIHBhdGguCgpGb3IgYSBz" + + "aW5nbGUtbm9kZSBpc29sYXRlZCB0ZXN0IGNsdXN0ZXIsIGFkZCB0aGlzIGNvbmZpZ3VyYXRpb24g" + + "dG8KYGVudmlyb25tZW50cy88ZW52Pi55YW1sYCBiZWZvcmUgYXBwbHlpbmcgdGhlIHN0YWNrOgoK" + + "YGBgeWFtbAphZGRvbnM6CiAgbGxtOgogICAgZW5hYmxlZDogdHJ1ZQogICAgZ2F0ZXdheToKICAg" + + "ICAgcmVwbGljYUNvdW50OiAxCiAgICAgIGF1dGg6CiAgICAgICAgZ3JwY0luc2VjdXJlOiB0cnVl" + + "CiAgICAgIG1ldHJpY3M6CiAgICAgICAgc2VydmljZU1vbml0b3I6CiAgICAgICAgICBlbmFibGVk" + + "OiBmYWxzZQogICAgcmVxdWVzdFJvdXRlcjoKICAgICAgcmVwbGljYUNvdW50OiAxCiAgICAgIG1l" + + "dHJpY3M6CiAgICAgICAgc2VydmljZU1vbml0b3I6CiAgICAgICAgICBlbmFibGVkOiBmYWxzZQoK" + + "YWdlbnRDb25maWc6CiAgbWVyZ2VDb25maWc6IHwKICAgIGNsdXN0ZXI6CiAgICAgIHZhbGlkYXRp" + + "b25Qb2xpY3k6CiAgICAgICAgbmFtZTogVW5yZXN0cmljdGVkCiAgICB3b3JrbG9hZDoKICAgICAg" + + "c3RhcmdhdGVRVUlDSW5zZWN1cmU6IHRydWUKYGBgCgpVc2UgYHJlcGxpY2FDb3VudDogMWAgb25s" + + "eSBmb3IgbG9jYWwgb3Igc2luZ2xlLW5vZGUgdGVzdCBjbHVzdGVycy4gRm9yIHNoYXJlZApvciBw" + + "cm9kdWN0aW9uIGNsdXN0ZXJzLCB1c2UgdGhlIHJlcXVpcmVkIHJlcGxpY2EgY291bnQgYW5kIFRM" + + "Uy1jYXBhYmxlIHNlcnZpY2UKY29uZmlndXJhdGlvbi4gYGFkZG9ucy5sbG0uZ2F0ZXdheS5hdXRo" + + "LmdycGNJbnNlY3VyZWAgYW5kCmB3b3JrbG9hZC5zdGFyZ2F0ZVFVSUNJbnNlY3VyZWAgZW5hYmxl" + + "IHBsYWludGV4dCB0cmFuc3BvcnRzLiBEbyBub3QgdXNlIHRoZW0gaW4KcHJvZHVjdGlvbi4KClRo" + + "ZSByZXF1ZXN0IHJvdXRlciB1c2VzIGBwb3dlci1vZi10d29gIHdoZW4gbm8gbG9hZC1iYWxhbmNl" + + "ciBjb25maWd1cmF0aW9uIGlzCnNldC4gQ29uZmlndXJlIG90aGVyIHJvdXRpbmcgbWV0aG9kcyB3" + + "aXRoIHRoZQpbTExNIFJlcXVlc3QgUm91dGVyIExvYWQgQmFsYW5jaW5nXShodHRwczovL2dpdGh1" + + "Yi5jb20vTlZJRElBL252Y2YvYmxvYi9tYWluL2RvY3MvdXNlci9sbG0tcmVxdWVzdC1yb3V0ZXIt" + + "bG9hZC1iYWxhbmNpbmcubWQpCmd1aWRlLgoKSWYgdGhlIHNpZGVjYXIgaW1hZ2UgaXMgbWlycm9y" + + "ZWQgb3V0c2lkZSB0aGUgc3RhY2sncyBkZWZhdWx0IGltYWdlIHJlZ2lzdHJ5IGFuZApyZXBvc2l0" + + "b3J5LCBzZXQgdGhlIGdlbmVyYXRlZCB3b3JrZXIgc2lkZWNhciBpbWFnZSBleHBsaWNpdGx5OgoK" + + "YGBgeWFtbAphcGk6CiAgcmVtb3RlQ29uZmlnOgogICAgY29uZmlnRGF0YToKICAgICAgbnZjZjoK" + + "ICAgICAgICBzaWRlY2FyczoKICAgICAgICAgIGxsbS1yb3V0ZXItY2xpZW50LWltYWdlOiA8cmVn" + + "aXN0cnk+LzxyZXBvc2l0b3J5Pi9weWxvbjowLjE0LjEKYGBgCgpUaGUgbGVnYWN5IGBhcGkuZW52" + + "Lk5WQ0ZfU0lERUNBUlNfTExNX1JPVVRFUl9DTElFTlRfSU1BR0VgIHBhdGggaXMgZGVwcmVjYXRl" + + "ZC4KVGhlIHN0YWNrIHRyYW5zbGF0ZXMgaXQgZm9yIG9uZSBjb21wYXRpYmlsaXR5IHdpbmRvdywg" + + "YnV0IG5ldyBjb25maWd1cmF0aW9ucwptdXN0IHVzZSB0aGUgcmVtb3RlLWNvbmZpZyBwYXRoLiBD" + + "b25mbGljdGluZyB2YWx1ZXMgZmFpbCByZW5kZXJpbmcuCgpSZW5kZXIgYW5kIGFwcGx5IHRoZSB1" + + "cGRhdGVkIGNvbnRyb2wtcGxhbmUgZW52aXJvbm1lbnQsIHRoZW4gcmVmcmVzaCBldmVyeQpyZWdp" + + "c3RlcmVkIGNvbXB1dGUgcGxhbmUgdXNpbmcgdGhlIHNhbWUgaGFuZG9mZiB1c2VkIGZvciBpdHMg" + + "aW5zdGFsbGF0aW9uIHNvCk5WQ0EgcmVjZWl2ZXMgYGFnZW50Q29uZmlnLm1lcmdlQ29uZmlnYDoK" + + "CmBgYGJhc2gKSEVMTUZJTEVfRU5WPTxlbnY+IGhlbG1maWxlIHRlbXBsYXRlCkhFTE1GSUxFX0VO" + + "Vj08ZW52PiBoZWxtZmlsZSBzeW5jCmBgYAoKVXNlIHRoZSBjb21wbGV0ZSBjb21wdXRlLXBsYW5l" + + "IGluc3RhbGwgY29tbWFuZCBmcm9tCltTcGxpdCBDb21wdXRlLVBsYW5lIEluc3RhbGxhdGlvbl0o" + + "Y29tcHV0ZS1wbGFuZS1pbnN0YWxsYXRpb24ubWQpLiBBCkNMSS1wcm9maWxlIGluc3RhbGxhdGlv" + + "biBtdXN0IHJlbWFpbiBwcm9maWxlLWRyaXZlbjsgYSBIZWxtZmlsZSBpbnN0YWxsYXRpb24KbXVz" + + "dCByZW1haW4gdmFsdWVzLWRyaXZlbi4KCkV4aXN0aW5nIExMTSBmdW5jdGlvbiB2ZXJzaW9ucyBy" + + "ZXRhaW4gdGhlIHdvcmtlci1zaWRlY2FyIGltYWdlIG1ldGFkYXRhCmNhcHR1cmVkIHdoZW4gdGhl" + + "IHZlcnNpb24gaXMgY3JlYXRlZC4gUmVwbGFjaW5nIHBvZHMgb3IgcmVkZXBsb3lpbmcgdGhlIHNh" + + "bWUKdmVyc2lvbiBkb2VzIG5vdCBhcHBseSBhIG5ldyBQeWxvbiBpbWFnZS4gQWZ0ZXIgdGhlIGNv" + + "bnRyb2wtcGxhbmUgdXBkYXRlLApjcmVhdGUgYW5kIGRlcGxveSBhIG5ldyBmdW5jdGlvbiB2ZXJz" + + "aW9uLiBWZXJpZnkgdGhlIGNvbnRyb2wgcGxhbmUsIHJvdXRlLCBhbmQKd29ya2VyIHNpZGVjYXI6" + + "CgpgYGBiYXNoCmt1YmVjdGwgZ2V0IGRlcGxveSAtbiBudmNmIGxsbS1hcGktZ2F0ZXdheQprdWJl" + + "Y3RsIGdldCBzdGF0ZWZ1bHNldCAtbiBudmNmIGxsbS1yZXF1ZXN0LXJvdXRlcgprdWJlY3RsIGdl" + + "dCBwb2RzIC1uIG52Y2YgfCBncmVwIC1FICdsbG0tYXBpLWdhdGV3YXl8bGxtLXJlcXVlc3Qtcm91" + + "dGVyJwprdWJlY3RsIGdldCBodHRwcm91dGUgLUEgfCBncmVwIGxsbQprdWJlY3RsIC1uIG52Y2Yt" + + "YmFja2VuZCBnZXQgcG9kIDxmdW5jdGlvbi1wb2Q+IFwKICAtbyBqc29ucGF0aD0ne3JhbmdlIC5z" + + "cGVjLmNvbnRhaW5lcnNbPyhALm5hbWU9PSJsbG0td29ya2VyIildLmFyZ3NbKl19ey59eyJcXG4i" + + "fXtlbmR9JwpgYGAKCkZvciBsb2NhbCBwbGFpbnRleHQgY2x1c3RlcnMsIHRoZSBgbGxtLXdvcmtl" + + "cmAgYXJncyBtdXN0IGluY2x1ZGUKYC0tcXVpYy1pbnNlY3VyZWAuCgpGb3IgbG9hZC1iYWxhbmNl" + + "ciBzY2hlbWEgYW5kIGFsZ29yaXRobSBiZWhhdmlvciwgc2VlIHRoZQpbU3RhcmdhdGUgY29uZmln" + + "dXJhdGlvbiBndWlkZV0oaHR0cHM6Ly9naXRodWIuY29tL05WSURJQS9udmNmL2Jsb2IvbWFpbi9z" + + "cmMvbGlicmFyaWVzL3J1c3Qvc3RhcmdhdGUvZG9jcy9sb2FkLWJhbGFuY2VyLWNvbmZpZ3VyYXRp" + + "b24ubWQpLgoKIyMgSGVsbWZpbGUgU2VsZWN0b3JzCgpUYXJnZXQgc3BlY2lmaWMgcmVsZWFzZXMg" + + "b3IgZ3JvdXBzOgoKYGBgYmFzaAojIEJ5IHJlbGVhc2UgZ3JvdXAKSEVMTUZJTEVfRU5WPTxlbnY+" + + "IGhlbG1maWxlIC0tc2VsZWN0b3IgcmVsZWFzZS1ncm91cD1kZXBlbmRlbmNpZXMgc3luYwpIRUxN" + + "RklMRV9FTlY9PGVudj4gaGVsbWZpbGUgLS1zZWxlY3RvciByZWxlYXNlLWdyb3VwPXNlcnZpY2Vz" + + "IHN5bmMKSEVMTUZJTEVfRU5WPTxlbnY+IGhlbG1maWxlIC0tc2VsZWN0b3IgcmVsZWFzZS1ncm91" + + "cD1pbmdyZXNzIHN5bmMKSEVMTUZJTEVfRU5WPTxlbnY+IGhlbG1maWxlIC0tc2VsZWN0b3IgcmVs" + + "ZWFzZS1ncm91cD1vYnNlcnZhYmlsaXR5IHN5bmMKCiMgQnkgcmVsZWFzZSBuYW1lCkhFTE1GSUxF" + + "X0VOVj08ZW52PiBoZWxtZmlsZSAtLXNlbGVjdG9yIG5hbWU9Y2Fzc2FuZHJhIHN5bmMKSEVMTUZJ" + + "TEVfRU5WPTxlbnY+IGhlbG1maWxlIC0tc2VsZWN0b3IgbmFtZT1hZG1pbi1pc3N1ZXItcHJveHkg" + + "c3luYwpIRUxNRklMRV9FTlY9PGVudj4gaGVsbWZpbGUgLS1zZWxlY3RvciBuYW1lPWxsbS1yZXF1" + + "ZXN0LXJvdXRlciBzeW5jCkhFTE1GSUxFX0VOVj08ZW52PiBoZWxtZmlsZSAtLXNlbGVjdG9yIG5h" + + "bWU9bGxtLWFwaS1nYXRld2F5IHN5bmMKCiMgVGVtcGxhdGUgb25seSAoZHJ5IHJ1bikKSEVMTUZJ" + + "TEVfRU5WPTxlbnY+IGhlbG1maWxlIC0tc2VsZWN0b3IgbmFtZT1jYXNzYW5kcmEgdGVtcGxhdGUK" + + "CiMgRGVzdHJveSBhIHNpbmdsZSByZWxlYXNlCkhFTE1GSUxFX0VOVj08ZW52PiBoZWxtZmlsZSAt" + + "LXNlbGVjdG9yIG5hbWU9Y2Fzc2FuZHJhIGRlc3Ryb3kKYGBgCgpOb3RlOiBgYWRtaW4taXNzdWVy" + + "LXByb3h5YCBoYXMgbm8gYHJlbGVhc2UtZ3JvdXBgIGxhYmVsLiBVc2UgYC0tc2VsZWN0b3IgbmFt" + + "ZT1hZG1pbi1pc3N1ZXItcHJveHlgLgpQSwcIle7q7yEpAAAhKQAAUEsDBBQACAAAAAAAIQAAAAAA" + + "AAAAAAAAAAA/AAkAZGF0YS9udmNmLXNlbGYtbWFuYWdlZC1pbnN0YWxsYXRpb24vcmVmZXJlbmNl" + + "cy9udmNmLXVpLWFkZG9uLm1kVVQFAAEAps4SIyBOVkNGIFVJIEFkZG9uCgpOVkNGIFVJIGlzIGFu" + + "IG9wdGlvbmFsLCBjdXN0b21lci1mYWNpbmcgTlZDRiBhZG1pbi1wYW5lbCBVSS4gSXQgaXMgZGlz" + + "YWJsZWQgYnkKZGVmYXVsdCBhbmQgYXZhaWxhYmxlIG9ubHkgaW4gc3RhY2sgcGFja2FnZXMgdGhh" + + "dCBpbmNsdWRlIHRoZSBOVkNGIFVJIGFkZG9uLgoKIyMgV2hlbiB0byBlbmFibGUKCkVuYWJsZSBO" + + "VkNGIFVJIG9ubHkgd2hlbiB5b3UgbmVlZCB0aGUgYWRtaW4tcGFuZWwgVUkgYW5kIHlvdXIgZXh0" + + "cmFjdGVkIHN0YWNrCnBhY2thZ2UgaW5jbHVkZXMgdGhlIGFkZG9uLiBJZiB0aGUgcGFja2FnZSBk" + + "b2VzIG5vdCBjb250YWluIGEgYG52Y2YtdWlgIHJlbGVhc2UKYW5kIGBudmNmVWlgIHJvdXRlIHZh" + + "bHVlcywgc2tpcCB0aGUgYWRkb24gdW50aWwgeW91IHVzZSBhIHBhY2thZ2UgdGhhdCBpbmNsdWRl" + + "cwp0aGVtLgoKIyMgRW5hYmxlIHRoZSBhZGRvbgoKRW5hYmxlIGl0IGluIGBlbnZpcm9ubWVudHMv" + + "PGVudi1uYW1lPi55YW1sYDoKCmBgYHlhbWwKYWRkb25zOgogIG52Y2ZVaToKICAgIGVuYWJsZWQ6" + + "IHRydWUKYGBgCgojIyBDcmVhdGUgbmFtZXNwYWNlIGFuZCBpbWFnZSBwdWxsIHNlY3JldAoKQ3Jl" + + "YXRlIHRoZSBuYW1lc3BhY2UsIGFuZCBhbiBpbWFnZSBwdWxsIHNlY3JldCBvbmx5IGlmIHB1bGxp" + + "bmcgZnJvbSBhIHByaXZhdGUKcmVnaXN0cnk6CgpgYGBiYXNoCmt1YmVjdGwgY3JlYXRlIG5hbWVz" + + "cGFjZSBudmNmLXVpIC0tZHJ5LXJ1bj1jbGllbnQgLW8geWFtbCB8IGt1YmVjdGwgYXBwbHkgLWYg" + + "LQoKIyBPbmx5IGlmIHB1bGxpbmcgZnJvbSBhIHByaXZhdGUgcmVnaXN0cnkgKGUuZy4sIE5HQyBu" + + "dmNyLmlvKQpleHBvcnQgTkdDX0FQSV9LRVk9Ijx5b3VyLWtleT4iCmt1YmVjdGwgY3JlYXRlIHNl" + + "Y3JldCBkb2NrZXItcmVnaXN0cnkgbnZjci1jcmVkcyBcCiAgLS1kb2NrZXItc2VydmVyPW52Y3Iu" + + "aW8gXAogIC0tZG9ja2VyLXVzZXJuYW1lPSckb2F1dGh0b2tlbicgXAogIC0tZG9ja2VyLXBhc3N3" + + "b3JkPSIkTkdDX0FQSV9LRVkiIFwKICAtLW5hbWVzcGFjZT1udmNmLXVpIFwKICAtLWRyeS1ydW49" + + "Y2xpZW50IC1vIHlhbWwgfCBrdWJlY3RsIGFwcGx5IC1mIC0KYGBgCgpUaGUgZGVmYXVsdCByb3V0" + + "ZSBob3N0IGlzIGBudmNmLXVpLjxkb21haW4+YCBhbmQgdGhlIGJhY2tlbmQgaXMKYG52Y2YtdWku" + + "bnZjZi11aTo4MzAwYC4KCiMjIEFwcGx5IHRoZSBzZXJ2aWNlIGFuZCByb3V0ZQoKQWZ0ZXIgY29u" + + "ZmlybWluZyB0aGUgcGFja2FnZSBpbmNsdWRlcyB0aGUgYG52Y2YtdWlgIHJlbGVhc2UsIHByZXZp" + + "ZXcgYW5kIGFwcGx5CnRoZSBzZXJ2aWNlIGFuZCByb3V0ZToKCmBgYGJhc2gKSEVMTUZJTEVfRU5W" + + "PTxlbnYtbmFtZT4gaGVsbWZpbGUgLS1zZWxlY3RvciBuYW1lPW52Y2YtdWkgdGVtcGxhdGUKSEVM" + + "TUZJTEVfRU5WPTxlbnYtbmFtZT4gaGVsbWZpbGUgLS1zZWxlY3RvciBuYW1lPW52Y2YtdWkgc3lu" + + "YwpIRUxNRklMRV9FTlY9PGVudi1uYW1lPiBoZWxtZmlsZSAtLXNlbGVjdG9yIHJlbGVhc2UtZ3Jv" + + "dXA9aW5ncmVzcyBzeW5jCmBgYAoKIyMgVmVyaWZ5CgpWZXJpZnkgdGhlIHJvdXRlIG9ubHkgd2hl" + + "biB0aGUgYWRkb24gaXMgcHJlc2VudCBhbmQgZW5hYmxlZDoKCmBgYGJhc2gKa3ViZWN0bCBnZXQg" + + "ZGVwbG95LHN2YyAtbiBudmNmLXVpCmt1YmVjdGwgZ2V0IGh0dHByb3V0ZSAtQSB8IGdyZXAgLWkg" + + "bnZjZi11aQpjdXJsIC1pIC1IICJIb3N0OiBudmNmLXVpLjxkb21haW4+IiAiaHR0cDovLzxnYXRl" + + "d2F5LWFkZHJlc3M+L3N0YXR1cyIKYGBgCgojIyBTZWN1cml0eQoKVGhlIE5WQ0YgVUkgYWRtaW4g" + + "cGFuZWwgaXMgY3VycmVudGx5IHVuYXV0aGVudGljYXRlZC4gRG8gbm90IGV4cG9zZSBpdCB0byB0" + + "aGUKcHVibGljIGludGVybmV0LiBSZXN0cmljdCBhY2Nlc3MgdG8gYSB0cnVzdGVkIG5ldHdvcmss" + + "IFZQTiwgb3IgYW4gYXV0aGVudGljYXRpbmcKcHJveHkgaW4gZnJvbnQgb2YgdGhlIGBudmNmLXVp" + + "YCByb3V0ZS4KUEsHCDj5J6+5BwAAuQcAAFBLAwQUAAgAAAAAACEAAAAAAAAAAAAAAAAAPgAJAGRh" + + "dGEvbnZjZi1zZWxmLW1hbmFnZWQtaW5zdGFsbGF0aW9uL3JlZmVyZW5jZXMvcHVsbC1zZWNyZXRz" + + "Lm1kVVQFAAEAps4SIyBJbWFnZSBQdWxsIFNlY3JldHMgUmVmZXJlbmNlCgojIyBPdmVydmlldwoK" + + "V2hlbiBwdWxsaW5nIE5WQ0YgaW1hZ2VzIGZyb20gYSBwcml2YXRlIHJlZ2lzdHJ5IChmb3IgZXhh" + + "bXBsZSwgTkdDCmBudmNyLmlvYCksIEt1YmVybmV0ZXMgbmVlZHMgYGltYWdlUHVsbFNlY3JldHNg" + + "IG9uIGV2ZXJ5IHBvZC4gQ29udHJvbC1wbGFuZSBhbmQKY29tcHV0ZS1wbGFuZSBjcmVkZW50aWFs" + + "cyBhcmUgY29uZmlndXJlZCBpbiB0aGVpciBvd24gY2x1c3RlciBjb250ZXh0cy4gRG8gbm90CnVz" + + "ZSBvbmUgbWl4ZWQgbmFtZXNwYWNlIGxpc3QuCgpUaGUgcmVjb21tZW5kZWQgY29udHJvbC1wbGFu" + + "ZSBhcHByb2FjaCB1c2VzIEt5dmVybm8gdG8gaW5qZWN0IHRoZSBzZWNyZXQgaW50bwpjb250cm9s" + + "LXBsYW5lIHBvZHMgYXQgYWRtaXNzaW9uIHRpbWUuIFRoZSBjb21wdXRlLXBsYW5lIGNoYXJ0IGFu" + + "ZCBvcGVyYXRvciB1c2UKdGhlIHNlY3JldCBpbiBgbnZjYS1vcGVyYXRvcmAgYW5kIG1pcnJvciBp" + + "dCB0byBgbnZjYS1zeXN0ZW1gLgoKIyMgS3l2ZXJubyBBcHByb2FjaCAoUmVjb21tZW5kZWQpCgoj" + + "IyMgMS4gSW5zdGFsbCBLeXZlcm5vCgpgYGBiYXNoCmhlbG0gcmVwbyBhZGQga3l2ZXJubyBodHRw" + + "czovL2t5dmVybm8uZ2l0aHViLmlvL2t5dmVybm8vCmhlbG0gcmVwbyB1cGRhdGUKaGVsbSBpbnN0" + + "YWxsIGt5dmVybm8ga3l2ZXJuby9reXZlcm5vIC1uIGt5dmVybm8gLS1jcmVhdGUtbmFtZXNwYWNl" + + "IFwKICAtLWt1YmUtY29udGV4dCA8Y29udHJvbC1wbGFuZS1jb250ZXh0PgpgYGAKCiMjIyAyLiBD" + + "cmVhdGUgY29udHJvbC1wbGFuZSBwdWxsIHNlY3JldHMKCmBgYGJhc2gKZXhwb3J0IE5HQ19BUElf" + + "S0VZPSI8eW91ci1uZ2MtYXBpLWtleT4iCgpmb3IgbnMgaW4gY2Fzc2FuZHJhLXN5c3RlbSBuYXRz" + + "LXN5c3RlbSBudmNmIGFwaS1rZXlzIGVzcyBzaXMgdmF1bHQtc3lzdGVtIGNlcnQtbWFuYWdlcjsg" + + "ZG8KICBrdWJlY3RsIC0tY29udGV4dCA8Y29udHJvbC1wbGFuZS1jb250ZXh0PiBjcmVhdGUgbmFt" + + "ZXNwYWNlICIkbnMiIFwKICAgIC0tZHJ5LXJ1bj1jbGllbnQgLW8geWFtbCB8IGt1YmVjdGwgLS1j" + + "b250ZXh0IDxjb250cm9sLXBsYW5lLWNvbnRleHQ+IGFwcGx5IC1mIC0KZG9uZQoKZm9yIG5zIGlu" + + "IGNhc3NhbmRyYS1zeXN0ZW0gbmF0cy1zeXN0ZW0gbnZjZiBhcGkta2V5cyBlc3Mgc2lzIHZhdWx0" + + "LXN5c3RlbSBjZXJ0LW1hbmFnZXI7IGRvCiAga3ViZWN0bCAtLWNvbnRleHQgPGNvbnRyb2wtcGxh" + + "bmUtY29udGV4dD4gY3JlYXRlIHNlY3JldCBkb2NrZXItcmVnaXN0cnkgbnZjci1jcmVkcyBcCiAg" + + "ICAtLWRvY2tlci1zZXJ2ZXI9bnZjci5pbyBcCiAgICAtLWRvY2tlci11c2VybmFtZT0nJG9hdXRo" + + "dG9rZW4nIFwKICAgIC0tZG9ja2VyLXBhc3N3b3JkPSIkTkdDX0FQSV9LRVkiIFwKICAgIC0tbmFt" + + "ZXNwYWNlPSIkbnMiIFwKICAgIC0tZHJ5LXJ1bj1jbGllbnQgLW8geWFtbCB8IGt1YmVjdGwgLS1j" + + "b250ZXh0IDxjb250cm9sLXBsYW5lLWNvbnRleHQ+IGFwcGx5IC1mIC0KZG9uZQpgYGAKCkZvciBu" + + "b24tTkdDIHJlZ2lzdHJpZXMsIHJlcGxhY2UgYC0tZG9ja2VyLXNlcnZlcmAsIGAtLWRvY2tlci11" + + "c2VybmFtZWAsIGFuZCBgLS1kb2NrZXItcGFzc3dvcmRgLgoKIyMjIDMuIEFwcGx5IEt5dmVybm8g" + + "Q2x1c3RlclBvbGljeQoKYGBgeWFtbAphcGlWZXJzaW9uOiBreXZlcm5vLmlvL3YxCmtpbmQ6IENs" + + "dXN0ZXJQb2xpY3kKbWV0YWRhdGE6CiAgbmFtZTogbnZjZi1hZGQtaW1hZ2VwdWxsc2VjcmV0cwpz" + + "cGVjOgogIGJhY2tncm91bmQ6IGZhbHNlCiAgcnVsZXM6CiAgICAtIG5hbWU6IGFkZC1pbWFnZXB1" + + "bGxzZWNyZXQtdG8tbnZjZi1wb2RzCiAgICAgIG1hdGNoOgogICAgICAgIGFueToKICAgICAgICAt" + + "IHJlc291cmNlczoKICAgICAgICAgICAga2luZHM6CiAgICAgICAgICAgIC0gUG9kCiAgICAgICAg" + + "ICAgIG5hbWVzcGFjZXM6CiAgICAgICAgICAgIC0gIm52Y2YiCiAgICAgICAgICAgIC0gImFwaS1r" + + "ZXlzIgogICAgICAgICAgICAtICJzaXMiCiAgICAgICAgICAgIC0gImVzcyIKICAgICAgICAgICAg" + + "LSAibmF0cy1zeXN0ZW0iCiAgICAgICAgICAgIC0gImNhc3NhbmRyYS1zeXN0ZW0iCiAgICAgICAg" + + "ICAgIC0gInZhdWx0LXN5c3RlbSIKICAgICAgICAgICAgLSAiY2VydC1tYW5hZ2VyIgogICAgICBt" + + "dXRhdGU6CiAgICAgICAgcGF0Y2hTdHJhdGVnaWNNZXJnZToKICAgICAgICAgIG1ldGFkYXRhOgog" + + "ICAgICAgICAgICBhbm5vdGF0aW9uczoKICAgICAgICAgICAgICBudmNmLm52aWRpYS5jb20vaW1h" + + "Z2VwdWxsc2VjcmV0LWluamVjdGVkLWJ5OiBreXZlcm5vCiAgICAgICAgICBzcGVjOgogICAgICAg" + + "ICAgICBpbWFnZVB1bGxTZWNyZXRzOgogICAgICAgICAgICAtIG5hbWU6IG52Y3ItY3JlZHMKYGBg" + + "CgpgYGBiYXNoCmt1YmVjdGwgLS1jb250ZXh0IDxjb250cm9sLXBsYW5lLWNvbnRleHQ+IGFwcGx5" + + "IFwKICAtZiBreXZlcm5vLWltYWdlcHVsbHNlY3JldC1wb2xpY3kueWFtbApgYGAKCiMjIyA0LiBJ" + + "bnN0YWxsIHRoZSBjb250cm9sIHBsYW5lCgpDb250aW51ZSB3aXRoIHRoZSBzZWxlY3RlZCBjb250" + + "cm9sLXBsYW5lIGluc3RhbGxhdGlvbiBpbgpbU3BsaXQgQ29tcHV0ZS1QbGFuZSBJbnN0YWxsYXRp" + + "b25dKGNvbXB1dGUtcGxhbmUtaW5zdGFsbGF0aW9uLm1kKS4gTm8KY29udHJvbC1wbGFuZSBoZWxt" + + "ZmlsZSBtb2RpZmljYXRpb25zIGFyZSBuZWVkZWQuIEt5dmVybm8gaW5qZWN0cyB0aGUgcHVsbApz" + + "ZWNyZXQgaW50byBuZXcgY29udHJvbC1wbGFuZSBwb2RzLgoKIyMgQ29tcHV0ZS1QbGFuZSBTZWNy" + + "ZXQKCkNyZWF0ZSB0aGUgc2VjcmV0IG9ubHkgaW4gYG52Y2Etb3BlcmF0b3JgIG9uIHRoZSBjb21w" + + "dXRlIGNsdXN0ZXI6CgpgYGBiYXNoCmt1YmVjdGwgLS1jb250ZXh0IDxjb21wdXRlLXBsYW5lLWNv" + + "bnRleHQ+IGNyZWF0ZSBuYW1lc3BhY2UgbnZjYS1vcGVyYXRvciBcCiAgLS1kcnktcnVuPWNsaWVu" + + "dCAtbyB5YW1sIHwgXAogIGt1YmVjdGwgLS1jb250ZXh0IDxjb21wdXRlLXBsYW5lLWNvbnRleHQ+" + + "IGFwcGx5IC1mIC0KCmt1YmVjdGwgLS1jb250ZXh0IDxjb21wdXRlLXBsYW5lLWNvbnRleHQ+IGNy" + + "ZWF0ZSBzZWNyZXQgZG9ja2VyLXJlZ2lzdHJ5IG52Y3ItY3JlZHMgXAogIC0tZG9ja2VyLXNlcnZl" + + "cj1udmNyLmlvIFwKICAtLWRvY2tlci11c2VybmFtZT0nJG9hdXRodG9rZW4nIFwKICAtLWRvY2tl" + + "ci1wYXNzd29yZD0iJE5HQ19BUElfS0VZIiBcCiAgLS1uYW1lc3BhY2U9bnZjYS1vcGVyYXRvciBc" + + "CiAgLS1kcnktcnVuPWNsaWVudCAtbyB5YW1sIHwgXAogIGt1YmVjdGwgLS1jb250ZXh0IDxjb21w" + + "dXRlLXBsYW5lLWNvbnRleHQ+IGFwcGx5IC1mIC0KYGBgCgpSZWZlcmVuY2UgaXQgaW4gdGhlIGNv" + + "bXB1dGUtcGxhbmUgZW52aXJvbm1lbnQgZmlsZToKCmBgYHlhbWwKZ2xvYmFsOgogIGltYWdlUHVs" + + "bFNlY3JldHM6CiAgICAtIG5hbWU6IG52Y3ItY3JlZHMKYGBgCgpUaGUgY2hhcnQgYW5kIG9wZXJh" + + "dG9yIHVzZSB0aGF0IHJlZmVyZW5jZSBpbiBgbnZjYS1vcGVyYXRvcmAgYW5kIG1pcnJvciB0aGUK" + + "c2VjcmV0IHRvIGBudmNhLXN5c3RlbWAuIERvIG5vdCBjcmVhdGUgYSBicm9hZGVyIG1hbnVhbCBj" + + "b21wdXRlIG5hbWVzcGFjZSBsaXN0LiBGb2xsb3cKW1NwbGl0IENvbXB1dGUtUGxhbmUgSW5zdGFs" + + "bGF0aW9uXShjb21wdXRlLXBsYW5lLWluc3RhbGxhdGlvbi5tZCkgZm9yIHRoZQpzZWxlY3RlZCBp" + + "bnN0YWxsIGZsb3cuCgojIyBWZXJpZmljYXRpb24KCmBgYGJhc2gKIyBDaGVjayB0aGF0IGEgY29u" + + "dHJvbC1wbGFuZSBwb2QgaGFzIHRoZSBpbmplY3RlZCBzZWNyZXQKa3ViZWN0bCAtLWNvbnRleHQg" + + "PGNvbnRyb2wtcGxhbmUtY29udGV4dD4gZ2V0IHBvZCAtbiA8bmFtZXNwYWNlPiA8cG9kLW5hbWU+" + + "IFwKICAtbyBqc29ucGF0aD0ney5zcGVjLmltYWdlUHVsbFNlY3JldHN9JwojIEV4cGVjdGVkOiBb" + + "eyJuYW1lIjoibnZjci1jcmVkcyJ9XQoKIyBDaGVjayB0aGUgS3l2ZXJubyBhbm5vdGF0aW9uCmt1" + + "YmVjdGwgLS1jb250ZXh0IDxjb250cm9sLXBsYW5lLWNvbnRleHQ+IGdldCBwb2QgLW4gPG5hbWVz" + + "cGFjZT4gPHBvZC1uYW1lPiBcCiAgLW8ganNvbnBhdGg9J3subWV0YWRhdGEuYW5ub3RhdGlvbnMu" + + "bnZjZlwubnZpZGlhXC5jb20vaW1hZ2VwdWxsc2VjcmV0LWluamVjdGVkLWJ5fScKIyBFeHBlY3Rl" + + "ZDoga3l2ZXJubwoKIyBDaGVjayBwdWxsIGV2ZW50cwprdWJlY3RsIC0tY29udGV4dCA8Y29udHJv" + + "bC1wbGFuZS1jb250ZXh0PiBnZXQgZXZlbnRzIC1uIDxuYW1lc3BhY2U+IFwKICAtLXNvcnQtYnk9" + + "Jy5sYXN0VGltZXN0YW1wJyB8IGdyZXAgLWkgcHVsbAojIFNob3VsZCBzaG93ICJTdWNjZXNzZnVs" + + "bHkgcHVsbGVkIiBub3QgIjQwMSBVbmF1dGhvcml6ZWQiCgojIENoZWNrIHRoZSBjaGFydC9vcGVy" + + "YXRvciBtaXJyb3Igb24gdGhlIGNvbXB1dGUgY2x1c3RlcgprdWJlY3RsIC0tY29udGV4dCA8Y29t" + + "cHV0ZS1wbGFuZS1jb250ZXh0PiBnZXQgc2VjcmV0IG52Y3ItY3JlZHMgXAogIC1uIG52Y2Etc3lz" + + "dGVtCmBgYAoKIyMgV2hlbiBQdWxsIFNlY3JldHMgQXJlIE5vdCBOZWVkZWQKCi0gKipBV1MgRUNS" + + "IHdpdGggSUFNIG5vZGUgcm9sZXMqKjogSWYgeW91ciBub2RlcyBoYXZlIGBBbWF6b25FQzJDb250" + + "YWluZXJSZWdpc3RyeVJlYWRPbmx5YCBJQU0gcG9saWN5LCBLdWJlcm5ldGVzIGNhbiBwdWxsIGZy" + + "b20gRUNSIHdpdGhvdXQgZXhwbGljaXQgc2VjcmV0cy4KLSAqKlB1YmxpYyByZWdpc3RyaWVzKio6" + + "IE5vIHB1bGwgc2VjcmV0cyBuZWVkZWQuCi0gKipDU1AgYnVpbHQtaW4gY3JlZGVudGlhbCBoZWxw" + + "ZXJzKio6IEdLRSBBcnRpZmFjdCBSZWdpc3RyeSwgQXp1cmUgQUNSIHdpdGggbWFuYWdlZCBpZGVu" + + "dGl0eSwgYW5kIHNpbWlsYXIgc2VydmljZXMuCgojIyBUcm91Ymxlc2hvb3RpbmcKCiMjIyBQb2Rz" + + "IHN0aWxsIGluIEltYWdlUHVsbEJhY2tPZmYgYWZ0ZXIgYXBwbHlpbmcgcG9saWN5CgpUaGUgS3l2" + + "ZXJubyBwb2xpY3kgb25seSBhZmZlY3RzIHBvZHMgY3JlYXRlZCAqKmFmdGVyKiogdGhlIHBvbGlj" + + "eSBpcyBhcHBsaWVkLiBEZWxldGUgc3R1Y2sgcG9kcyB0byB0cmlnZ2VyIHJlY3JlYXRpb246Cgpg" + + "YGBiYXNoCmt1YmVjdGwgLS1jb250ZXh0IDx0YXJnZXQtY29udGV4dD4gZGVsZXRlIHBvZHMgLW4g" + + "PG5hbWVzcGFjZT4gLS1hbGwKYGBgCgojIyMgS3l2ZXJubyBhZG1pc3Npb24gY29udHJvbGxlciBu" + + "b3QgcnVubmluZwoKYGBgYmFzaAprdWJlY3RsIC0tY29udGV4dCA8Y29udHJvbC1wbGFuZS1jb250" + + "ZXh0PiBnZXQgcG9kcyAtbiBreXZlcm5vCiMgQWxsIHBvZHMgc2hvdWxkIGJlIFJ1bm5pbmcKYGBg" + + "CgojIyMgUG9saWN5IG5vdCBtYXRjaGluZwoKYGBgYmFzaAprdWJlY3RsIC0tY29udGV4dCA8Y29u" + + "dHJvbC1wbGFuZS1jb250ZXh0PiBnZXQgY2x1c3RlcnBvbGljeSBudmNmLWFkZC1pbWFnZXB1bGxz" + + "ZWNyZXRzCiMgU2hvdWxkIHNob3cgUkVBRFk6IFRydWUKYGBgCgojIyMgV3Jvbmcgc2VjcmV0IG5h" + + "bWUKClRoZSBwb2xpY3kgcmVmZXJlbmNlcyBgbnZjci1jcmVkc2AuIFZlcmlmeSB0aGUgc2VjcmV0" + + "IGV4aXN0cyB3aXRoIHRoYXQgZXhhY3QgbmFtZToKCmBgYGJhc2gKa3ViZWN0bCAtLWNvbnRleHQg" + + "PHRhcmdldC1jb250ZXh0PiBnZXQgc2VjcmV0IG52Y3ItY3JlZHMgLW4gPG5hbWVzcGFjZT4KYGBg" + + "ClBLBwhLQjWoABYAAAAWAABQSwECFAAUAAgAAAAAACEAbYNj7kkQAABJEAAAEgAJAAAAAAAAAAAA" + + "AAAAAAAAZGF0YS9tYW5pZmVzdC5qc29uVVQFAAEAps4SUEsBAhQAFAAIAAAAAAAhAM2BMORNYQAA" + + "TWEAACMACQAAAAAAAAAAAAAAkhAAAGRhdGEvbnZjZi1zZWxmLW1hbmFnZWQtY2xpL1NLSUxMLm1k" + + "VVQFAAEAps4SUEsBAhQAFAAIAAAAAAAhACHGyIbwCgAA8AoAADMACQAAAAAAAAAAAAAAOXIAAGRh" + + "dGEvbnZjZi1zZWxmLW1hbmFnZWQtY2xpL2V4YW1wbGVzL2NpLXBpcGVsaW5lcy5tZFVUBQABAKbO" + + "ElBLAQIUABQACAAAAAAAIQChFOOBXQwAAF0MAAA0AAkAAAAAAAAAAAAAAJN9AABkYXRhL252Y2Yt" + + "c2VsZi1tYW5hZ2VkLWNsaS9leGFtcGxlcy9tdWx0aS1jbHVzdGVyLm1kVVQFAAEAps4SUEsBAhQA" + + "FAAIAAAAAAAhAEInSQ8FDQAABQ0AADcACQAAAAAAAAAAAAAAW4oAAGRhdGEvbnZjZi1zZWxmLW1h" + + "bmFnZWQtY2xpL3Byb21wdHMvYWRkLWNvbXB1dGUtcGxhbmUubWRVVAUAAQCmzhJQSwECFAAUAAgA" + + "AAAAACEAkdwb+ZgZAACYGQAAOQAJAAAAAAAAAAAAAADOlwAAZGF0YS9udmNmLXNlbGYtbWFuYWdl" + + "ZC1jbGkvcHJvbXB0cy9jcmVhdGUtYW5kLXJ1bi10YXNrLm1kVVQFAAEAps4SUEsBAhQAFAAIAAAA" + + "AAAhANJD3AQYJQAAGCUAADcACQAAAAAAAAAAAAAA1rEAAGRhdGEvbnZjZi1zZWxmLW1hbmFnZWQt" + + "Y2xpL3Byb21wdHMvZGVwbG95LWFuZC1pbnZva2UubWRVVAUAAQCmzhJQSwECFAAUAAgAAAAAACEA" + + "Dpw/l70OAAC9DgAAPQAJAAAAAAAAAAAAAABc1wAAZGF0YS9udmNmLXNlbGYtbWFuYWdlZC1jbGkv" + + "cHJvbXB0cy9kaWFnbm9zZS1mYWlsZWQtaW5zdGFsbC5tZFVUBQABAKbOElBLAQIUABQACAAAAAAA" + + "IQBCceYeASgAAAEoAAA6AAkAAAAAAAAAAAAAAI3mAABkYXRhL252Y2Ytc2VsZi1tYW5hZ2VkLWNs" + + "aS9wcm9tcHRzL2luc3RhbGwtZnJvbS1zY3JhdGNoLm1kVVQFAAEAps4SUEsBAhQAFAAIAAAAAAAh" + + "ABrELJ7HBwAAxwcAADkACQAAAAAAAAAAAAAA/w4BAGRhdGEvbnZjZi1zZWxmLW1hbmFnZWQtY2xp" + + "L3Byb21wdHMvcm90YXRlLWNsdXN0ZXItandrcy5tZFVUBQABAKbOElBLAQIUABQACAAAAAAAIQAS" + + "kzNZ4CEAAOAhAAAuAAkAAAAAAAAAAAAAADYXAQBkYXRhL252Y2Ytc2VsZi1tYW5hZ2VkLWNsaS9w" + + "cm9tcHRzL3RlYXJkb3duLm1kVVQFAAEAps4SUEsBAhQAFAAIAAAAAAAhAHIND2QhIwAAISMAADAA" + + "CQAAAAAAAAAAAAAAezkBAGRhdGEvbnZjZi1zZWxmLW1hbmFnZWQtY2xpL3JlZmVyZW5jZS9jb21t" + + "YW5kcy5tZFVUBQABAKbOElBLAQIUABQACAAAAAAAIQBzp1pk1QYAANUGAAAyAAkAAAAAAAAAAAAA" + + "AANdAQBkYXRhL252Y2Ytc2VsZi1tYW5hZ2VkLWNsaS9yZWZlcmVuY2UvZXhpdC1jb2Rlcy5tZFVU" + + "BQABAKbOElBLAQIUABQACAAAAAAAIQDkZ7HMLSUAAC0lAAAtAAkAAAAAAAAAAAAAAEFkAQBkYXRh" + + "L252Y2Ytc2VsZi1tYW5hZ2VkLWNsaS9yZWZlcmVuY2UvZmxhZ3MubWRVVAUAAQCmzhJQSwECFAAU" + + "AAgAAAAAACEA864ThHQRAAB0EQAANwAJAAAAAAAAAAAAAADSiQEAZGF0YS9udmNmLXNlbGYtbWFu" + + "YWdlZC1jbGkvcmVmZXJlbmNlL3Ryb3VibGVzaG9vdGluZy5tZFVUBQABAKbOElBLAQIUABQACAAA" + + "AAAAIQAv2rl1QmIAAEJiAAAsAAkAAAAAAAAAAAAAALSbAQBkYXRhL252Y2Ytc2VsZi1tYW5hZ2Vk" + + "LWluc3RhbGxhdGlvbi9TS0lMTC5tZFVUBQABAKbOElBLAQIUABQACAAAAAAAIQArE7g/rVUAAK1V" + + "AAA0AAkAAAAAAAAAAAAAAFn+AQBkYXRhL252Y2Ytc2VsZi1tYW5hZ2VkLWluc3RhbGxhdGlvbi9l" + + "dmFscy9ldmFscy5qc29uVVQFAAEAps4SUEsBAhQAFAAIAAAAAAAhAAJSTkB/KAAAfygAAC8ACQAA" + + "AAAAAAAAAAAAcVQCAGRhdGEvbnZjZi1zZWxmLW1hbmFnZWQtaW5zdGFsbGF0aW9uL2V4YW1wbGVz" + + "Lm1kVVQFAAEAps4SUEsBAhQAFAAIAAAAAAAhAJZjvFkSMAAAEjAAAEwACQAAAAAAAAAAAAAAVn0C" + + "AGRhdGEvbnZjZi1zZWxmLW1hbmFnZWQtaW5zdGFsbGF0aW9uL3JlZmVyZW5jZXMvY29tcHV0ZS1w" + + "bGFuZS1pbnN0YWxsYXRpb24ubWRVVAUAAQCmzhJQSwECFAAUAAgAAAAAACEAVj5nkJUwAACVMAAA" + + "OwAJAAAAAAAAAAAAAADrrQIAZGF0YS9udmNmLXNlbGYtbWFuYWdlZC1pbnN0YWxsYXRpb24vcmVm" + + "ZXJlbmNlcy9kZWJ1Z2dpbmcubWRVVAUAAQCmzhJQSwECFAAUAAgAAAAAACEAle7q7yEpAAAhKQAA" + + "RAAJAAAAAAAAAAAAAADy3gIAZGF0YS9udmNmLXNlbGYtbWFuYWdlZC1pbnN0YWxsYXRpb24vcmVm" + + "ZXJlbmNlcy9oZWxtZmlsZS1zdHJ1Y3R1cmUubWRVVAUAAQCmzhJQSwECFAAUAAgAAAAAACEAOPkn" + + "r7kHAAC5BwAAPwAJAAAAAAAAAAAAAACOCAMAZGF0YS9udmNmLXNlbGYtbWFuYWdlZC1pbnN0YWxs" + + "YXRpb24vcmVmZXJlbmNlcy9udmNmLXVpLWFkZG9uLm1kVVQFAAEAps4SUEsBAhQAFAAIAAAAAAAh" + + "AEtCNagAFgAAABYAAD4ACQAAAAAAAAAAAAAAvRADAGRhdGEvbnZjZi1zZWxmLW1hbmFnZWQtaW5z" + + "dGFsbGF0aW9uL3JlZmVyZW5jZXMvcHVsbC1zZWNyZXRzLm1kVVQFAAEAps4SUEsFBgAAAAAXABcA" + + "rwkAADInAwAAAA==" var ( skillDataOnce sync.Once diff --git a/src/clis/nvcf-cli/internal/client/client.go b/src/clis/nvcf-cli/internal/client/client.go index add80bfe3..98a977276 100644 --- a/src/clis/nvcf-cli/internal/client/client.go +++ b/src/clis/nvcf-cli/internal/client/client.go @@ -827,6 +827,17 @@ type LLMConfigDto struct { RoutingMethod *string `json:"routingMethod,omitempty"` } +// LLMInvocationConfigDto represents function-level LLM invocation configuration. +type LLMInvocationConfigDto struct { + Priority *PriorityDto `json:"priority,omitempty"` +} + +// PriorityDto represents the default and per-account request priorities for an LLM function. +type PriorityDto struct { + DefaultPriority *uint32 `json:"defaultPriority,omitempty"` + PerAccountPriority map[string]uint32 `json:"perAccountPriority,omitempty"` +} + // SecretDto represents a secret configuration type SecretDto struct { Name string `json:"name"` // Secret name (required, max 48 chars, pattern: ^[a-z0-9A-Z][a-z0-9A-Z\\_\\.\\-]*$) @@ -864,6 +875,7 @@ type CreateFunctionRequest struct { APIBodyFormat string `json:"apiBodyFormat,omitempty"` // Invocation request body format ContainerArgs string `json:"containerArgs,omitempty"` // Args to be passed when launching container ContainerEnvironment []ContainerEnvironmentEntry `json:"containerEnvironment,omitempty"` // Environment settings for container + LLMInvocationConfig *LLMInvocationConfigDto `json:"llmInvocationConfig,omitempty"` // Function-level LLM invocation configuration // Helm configuration HelmChart string `json:"helmChart,omitempty"` // Optional Helm Chart @@ -892,14 +904,15 @@ type CreateFunctionResponse struct { // FunctionData represents function data type FunctionData struct { - ID string `json:"id"` - VersionID string `json:"versionId"` - Name string `json:"name"` - Status string `json:"status"` - InferenceURL string `json:"inferenceUrl"` - InferencePort int `json:"inferencePort"` - ContainerImage string `json:"containerImage"` - CreationTime string `json:"creationTime"` + ID string `json:"id"` + VersionID string `json:"versionId"` + Name string `json:"name"` + Status string `json:"status"` + InferenceURL string `json:"inferenceUrl"` + InferencePort int `json:"inferencePort"` + ContainerImage string `json:"containerImage"` + CreationTime string `json:"creationTime"` + LLMInvocationConfig *LLMInvocationConfigDto `json:"llmInvocationConfig,omitempty"` } // CreateFunction creates a new function @@ -1006,16 +1019,17 @@ type GetFunctionResponse struct { // FunctionDetails represents detailed function information type FunctionDetails struct { - ID string `json:"id"` - VersionID string `json:"versionId"` - Name string `json:"name"` - Status string `json:"status"` - InferenceURL string `json:"inferenceUrl"` - InferencePort int `json:"inferencePort"` - ContainerImage string `json:"containerImage"` - CreationTime string `json:"creationTime"` - ActiveInstances []Instance `json:"activeInstances"` - Health HealthInfo `json:"health"` + ID string `json:"id"` + VersionID string `json:"versionId"` + Name string `json:"name"` + Status string `json:"status"` + InferenceURL string `json:"inferenceUrl"` + InferencePort int `json:"inferencePort"` + ContainerImage string `json:"containerImage"` + CreationTime string `json:"creationTime"` + ActiveInstances []Instance `json:"activeInstances"` + Health HealthInfo `json:"health"` + LLMInvocationConfig *LLMInvocationConfigDto `json:"llmInvocationConfig,omitempty"` } // Instance represents a function instance @@ -1192,9 +1206,10 @@ func (c *Client) DeployFunction(ctx context.Context, functionID, versionID strin // UpdateFunctionMetadataRequest represents a function update request type UpdateFunctionMetadataRequest struct { - Description string `json:"description,omitempty"` // Function description - Tags []string `json:"tags,omitempty"` // Function tags - ModelUpdates []ModelUpdateDto `json:"modelUpdates,omitempty"` // Model-specific updates + Description string `json:"description,omitempty"` // Function description + Tags []string `json:"tags,omitempty"` // Function tags + ModelUpdates []ModelUpdateDto `json:"modelUpdates,omitempty"` // Model-specific updates + LLMInvocationConfig *LLMInvocationConfigDto `json:"llmInvocationConfig,omitempty"` // Function-level LLM invocation configuration } // ModelUpdateDto represents updates for one model. @@ -1751,6 +1766,7 @@ type FunctionDto struct { Secrets []string `json:"secrets,omitempty"` RateLimit *RateLimitDto `json:"rateLimit,omitempty"` Models []ArtifactDto `json:"models,omitempty"` + LLMInvocationConfig *LLMInvocationConfigDto `json:"llmInvocationConfig,omitempty"` } // ClusterGroupsResponse represents the response from listing cluster groups diff --git a/src/clis/nvcf-cli/internal/client/client_test.go b/src/clis/nvcf-cli/internal/client/client_test.go index 1d42cf015..a7abdac07 100644 --- a/src/clis/nvcf-cli/internal/client/client_test.go +++ b/src/clis/nvcf-cli/internal/client/client_test.go @@ -40,6 +40,8 @@ import ( func ptrInt(v int) *int { return &v } +func ptrUint32(v uint32) *uint32 { return &v } + type invokeRequestCaptureTransport struct { req *http.Request } @@ -55,21 +57,28 @@ func (t *invokeRequestCaptureTransport) RoundTrip(req *http.Request) (*http.Resp } type updateRequestCaptureTransport struct { - req *http.Request - body []byte + req *http.Request + body []byte + responseBody string } func (t *updateRequestCaptureTransport) RoundTrip(req *http.Request) (*http.Response, error) { t.req = req - body, err := io.ReadAll(req.Body) - if err != nil { - return nil, err + if req.Body != nil { + body, err := io.ReadAll(req.Body) + if err != nil { + return nil, err + } + t.body = body + } + responseBody := t.responseBody + if responseBody == "" { + responseBody = `{"ok":true}` } - t.body = body return &http.Response{ StatusCode: http.StatusOK, Header: make(http.Header), - Body: io.NopCloser(strings.NewReader(`{"ok":true}`)), + Body: io.NopCloser(strings.NewReader(responseBody)), Request: req, }, nil } @@ -573,6 +582,252 @@ func TestUpdateFunctionMetadataSendsModelUpdatesToFunctionEndpoint(t *testing.T) } } +func TestCreateFunctionSendsLLMInvocationConfig(t *testing.T) { + capture := &updateRequestCaptureTransport{ + responseBody: `{ + "function": { + "id": "func-123", + "versionId": "ver-456", + "llmInvocationConfig": { + "priority": { + "defaultPriority": 0, + "perAccountPriority": {"account-1": 3} + } + } + } + }`, + } + client := &Client{ + config: &Config{Token: "token"}, + baseURL: "https://api.example.com", + httpClient: &http.Client{Transport: capture}, + } + + result, err := client.CreateFunction(context.Background(), &CreateFunctionRequest{ + Name: "llm-function", + InferenceURL: "/v1/chat/completions", + InferencePort: 8000, + FunctionType: "LLM", + LLMInvocationConfig: &LLMInvocationConfigDto{ + Priority: &PriorityDto{ + DefaultPriority: ptrUint32(0), + PerAccountPriority: map[string]uint32{ + "account-1": 3, + }, + }, + }, + }) + if err != nil { + t.Fatalf("CreateFunction returned error: %v", err) + } + if capture.req == nil { + t.Fatal("expected create request") + } + if got, want := capture.req.Method, http.MethodPost; got != want { + t.Fatalf("method = %q, want %q", got, want) + } + if got, want := capture.req.URL.Path, "/v2/nvcf/functions"; got != want { + t.Fatalf("path = %q, want %q", got, want) + } + + var payload map[string]interface{} + if err := json.Unmarshal(capture.body, &payload); err != nil { + t.Fatalf("unmarshal request body: %v", err) + } + invocationConfig, ok := payload["llmInvocationConfig"].(map[string]interface{}) + if !ok { + t.Fatalf("llmInvocationConfig = %#v, want object", payload["llmInvocationConfig"]) + } + priority, ok := invocationConfig["priority"].(map[string]interface{}) + if !ok { + t.Fatalf("priority = %#v, want object", invocationConfig["priority"]) + } + if got, want := priority["defaultPriority"], float64(0); got != want { + t.Fatalf("defaultPriority = %#v, want %#v", got, want) + } + perAccountPriority, ok := priority["perAccountPriority"].(map[string]interface{}) + if !ok { + t.Fatalf("perAccountPriority = %#v, want object", priority["perAccountPriority"]) + } + if got, want := perAccountPriority["account-1"], float64(3); got != want { + t.Fatalf("perAccountPriority[account-1] = %#v, want %#v", got, want) + } + assertLLMInvocationConfig(t, result.Function.LLMInvocationConfig, 0, map[string]uint32{"account-1": 3}) +} + +func TestUpdateFunctionMetadataSendsAndClearsLLMInvocationConfig(t *testing.T) { + tests := []struct { + name string + config *LLMInvocationConfigDto + assert func(*testing.T, map[string]interface{}) + }{ + { + name: "configured priority", + config: &LLMInvocationConfigDto{ + Priority: &PriorityDto{ + DefaultPriority: ptrUint32(7), + }, + }, + assert: func(t *testing.T, invocationConfig map[string]interface{}) { + t.Helper() + priority, ok := invocationConfig["priority"].(map[string]interface{}) + if !ok { + t.Fatalf("priority = %#v, want object", invocationConfig["priority"]) + } + if got, want := priority["defaultPriority"], float64(7); got != want { + t.Fatalf("defaultPriority = %#v, want %#v", got, want) + } + }, + }, + { + name: "cleared configuration", + config: &LLMInvocationConfigDto{}, + assert: func(t *testing.T, invocationConfig map[string]interface{}) { + t.Helper() + if len(invocationConfig) != 0 { + t.Fatalf("llmInvocationConfig = %#v, want empty object", invocationConfig) + } + }, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + capture := &updateRequestCaptureTransport{} + client := &Client{ + config: &Config{Token: "token"}, + baseURL: "https://api.example.com", + httpClient: &http.Client{Transport: capture}, + } + + err := client.UpdateFunctionMetadata(context.Background(), "func-123", "ver-456", &UpdateFunctionMetadataRequest{ + LLMInvocationConfig: tt.config, + }) + if err != nil { + t.Fatalf("UpdateFunctionMetadata returned error: %v", err) + } + if capture.req == nil { + t.Fatal("expected update request") + } + if got, want := capture.req.Method, http.MethodPut; got != want { + t.Fatalf("method = %q, want %q", got, want) + } + if got, want := capture.req.URL.Path, "/v2/nvcf/functions/func-123/versions/ver-456"; got != want { + t.Fatalf("path = %q, want %q", got, want) + } + + var payload map[string]interface{} + if err := json.Unmarshal(capture.body, &payload); err != nil { + t.Fatalf("unmarshal request body: %v", err) + } + invocationConfig, ok := payload["llmInvocationConfig"].(map[string]interface{}) + if !ok { + t.Fatalf("llmInvocationConfig = %#v, want object", payload["llmInvocationConfig"]) + } + tt.assert(t, invocationConfig) + }) + } +} + +func TestGetFunctionDecodesLLMInvocationConfig(t *testing.T) { + capture := &updateRequestCaptureTransport{ + responseBody: functionResponseWithPriorityJSON, + } + client := &Client{ + config: &Config{Token: "token"}, + baseURL: "https://api.example.com", + httpClient: &http.Client{Transport: capture}, + } + + result, err := client.GetFunction(context.Background(), "func-123", "ver-456") + if err != nil { + t.Fatalf("GetFunction returned error: %v", err) + } + assertLLMInvocationConfig(t, result.Function.LLMInvocationConfig, 0, map[string]uint32{"account-1": 3}) +} + +func TestGetFunctionDetailsDecodesLLMInvocationConfig(t *testing.T) { + capture := &updateRequestCaptureTransport{ + responseBody: functionResponseWithPriorityJSON, + } + client := &Client{ + config: &Config{Token: "token"}, + baseURL: "https://api.example.com", + httpClient: &http.Client{Transport: capture}, + } + + result, err := client.GetFunctionDetails(context.Background(), "func-123", "ver-456") + if err != nil { + t.Fatalf("GetFunctionDetails returned error: %v", err) + } + assertLLMInvocationConfig(t, result.LLMInvocationConfig, 0, map[string]uint32{"account-1": 3}) + + encoded, err := json.Marshal(result) + if err != nil { + t.Fatalf("marshal function details: %v", err) + } + if !strings.Contains(string(encoded), `"defaultPriority":0`) { + t.Fatalf("JSON output %s does not preserve explicit defaultPriority 0", encoded) + } +} + +func TestListFunctionsDecodesLLMInvocationConfig(t *testing.T) { + capture := &updateRequestCaptureTransport{ + responseBody: `{"functions":[` + functionWithPriorityJSON + `]}`, + } + client := &Client{ + config: &Config{Token: "token"}, + baseURL: "https://api.example.com", + httpClient: &http.Client{Transport: capture}, + } + + result, err := client.ListFunctions(context.Background()) + if err != nil { + t.Fatalf("ListFunctions returned error: %v", err) + } + if len(result.Functions) != 1 { + t.Fatalf("functions length = %d, want 1", len(result.Functions)) + } + assertLLMInvocationConfig(t, result.Functions[0].LLMInvocationConfig, 0, map[string]uint32{"account-1": 3}) +} + +const functionWithPriorityJSON = `{ + "id": "func-123", + "versionId": "ver-456", + "llmInvocationConfig": { + "priority": { + "defaultPriority": 0, + "perAccountPriority": {"account-1": 3} + } + } +}` + +const functionResponseWithPriorityJSON = `{"function":` + functionWithPriorityJSON + `}` + +func assertLLMInvocationConfig(t *testing.T, config *LLMInvocationConfigDto, defaultPriority uint32, perAccountPriority map[string]uint32) { + t.Helper() + if config == nil { + t.Fatal("llmInvocationConfig is nil") + } + if config.Priority == nil { + t.Fatal("priority is nil") + } + if config.Priority.DefaultPriority == nil { + t.Fatal("defaultPriority is nil") + } + if got := *config.Priority.DefaultPriority; got != defaultPriority { + t.Fatalf("defaultPriority = %d, want %d", got, defaultPriority) + } + if len(config.Priority.PerAccountPriority) != len(perAccountPriority) { + t.Fatalf("perAccountPriority = %#v, want %#v", config.Priority.PerAccountPriority, perAccountPriority) + } + for account, want := range perAccountPriority { + if got := config.Priority.PerAccountPriority[account]; got != want { + t.Fatalf("perAccountPriority[%s] = %d, want %d", account, got, want) + } + } +} + func TestLLMInvocationURLDerivesHostFromInvocationURL(t *testing.T) { tests := []struct { name string