From 75b689007ceb6154798ba5403e82302be7d358e9 Mon Sep 17 00:00:00 2001 From: sevenc Date: Fri, 28 Aug 2026 16:40:01 +0800 Subject: [PATCH 01/10] feat(nvcf-cli): support LLM request priority Add create, update, clear, and inspect support for function-level LLM request priority. Preserve explicit priority zero and document replacement semantics. Relates to #183 --- .../nvcf-self-managed-cli/reference/flags.md | 25 +- docs/user/cli.md | 39 +- src/clis/nvcf-cli/README.md | 34 +- src/clis/nvcf-cli/USAGE-GUIDE.md | 38 +- src/clis/nvcf-cli/cmd/BUILD.bazel | 1 + src/clis/nvcf-cli/cmd/function.go | 235 +- .../nvcf-cli/cmd/function_llm_model_test.go | 3 + .../cmd/function_request_priority_test.go | 390 + .../agentskill/skilldata_generated.go | 7228 +++++++++-------- src/clis/nvcf-cli/internal/client/client.go | 58 +- .../nvcf-cli/internal/client/client_test.go | 269 +- 11 files changed, 4669 insertions(+), 3651 deletions(-) create mode 100644 src/clis/nvcf-cli/cmd/function_request_priority_test.go 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..e17113f25 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,10 +82,29 @@ 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, maximum 64. 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. +Function-level request priority uses this JSON shape: + +```json +{ + "llmInvocationConfig": { + "priority": { + "defaultPriority": 7, + "perAccountPriority": { + "nca-id": 3 + } + } + } +} +``` + +Priority values range from `0` through `4294967295`. Lower values have higher priority, and `0` is highest. An explicit `0` is distinct from an omitted priority. `defaultPriority` is required when `perAccountPriority` has entries. + Helm chart packaging is independent of `functionType`. For a Helm-chart backed LLM function, set `functionType: "LLM"`, `helmChart`, `helmChartServiceName`, and `models[].llmConfig` in the same create request. `inferencePort` must be the Kubernetes Service port exposed by `helmChartServiceName`. LLM invocation requests use `model: "/"`. The function ID selects the NVCF function, and the model name is forwarded upstream. Chat completions and Responses API requests can use `x-multi-turn-session-id` for session stickiness; embeddings requests do not. @@ -96,9 +115,14 @@ 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, maximum 64. Requires a default priority. | - | +| `--clear-llm-priority` | Clear the function-level request priority configuration. | `false` | 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. +When `llmInvocationConfig` is present in an update, it replaces the complete function-level priority configuration. Specify every default and per-account value to retain. Omitting the field preserves the current configuration. Use `--clear-llm-priority` or `"llmInvocationConfig": {}` to clear it. + ## `function deploy create`-specific `--input-file FILE` is recommended (full JSON spec). For ad-hoc one-shot use: @@ -142,4 +166,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..6409301fe 100644 --- a/docs/user/cli.md +++ b/docs/user/cli.md @@ -690,7 +690,9 @@ API key, which `api-key generate` mints automatically alongside the function key --inference-url "/" \ --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" + --llm-model "name=dummy-model,uris=/v1/chat/completions|/v1/responses|/v1/embeddings,routingMethod=round_robin,tokenRateLimit=1000-S" \ + --llm-default-priority 7 \ + --llm-per-account-priority "nca-id:3" ``` All `function create` flags: @@ -716,6 +718,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, maximum 64). 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 | @@ -750,6 +754,14 @@ LLM functions use `functionType: "LLM"` and define model routing metadata under "inferenceUrl": "/", "inferencePort": 8000, "functionType": "LLM", + "llmInvocationConfig": { + "priority": { + "defaultPriority": 7, + "perAccountPriority": { + "nca-id": 3 + } + } + }, "models": [ { "name": "dummy-model", @@ -767,6 +779,8 @@ For LLM models, `llmConfig.routingMethod` accepts `round_robin`, `power_of_two`, Supported LLM paths are `/v1/chat/completions`, `/v1/responses`, and `/v1/embeddings`. `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 `1000-S` for a single limit, or `1000-S,5000-M,100000-H,500000-D,1000000-W` for a combined limit with distinct units. Use JSON input for combined limits because inline CLI model specs use commas as field separators. +Request priorities are unsigned 32-bit integers from `0` through `4294967295`. Lower values have higher priority, and an explicit `0` is distinct from an omitted priority. If `perAccountPriority` has entries, `defaultPriority` is required. + #### Deploy Function The `function deploy` command group manages deployments with the following subcommands: @@ -889,6 +903,19 @@ 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" + +# Clear the function-level request priority configuration +./nvcf-cli function update \ + --function-id \ + --version-id \ + --clear-llm-priority + # Update from JSON file ./nvcf-cli function update \ --function-id \ @@ -914,6 +941,16 @@ LLM model updates can also be provided in the input file: } ``` +`llmInvocationConfig` is a full replacement when it is present in an update. Specify every default and per-account value to retain. Omitting the field preserves the current configuration. Use `--clear-llm-priority` or an empty `llmInvocationConfig` object to clear it: + +```json +{ + "functionId": "", + "versionId": "", + "llmInvocationConfig": {} +} +``` + #### Invoke Function ```bash diff --git a/src/clis/nvcf-cli/README.md b/src/clis/nvcf-cli/README.md index 1292e948d..c36cb3905 100644 --- a/src/clis/nvcf-cli/README.md +++ b/src/clis/nvcf-cli/README.md @@ -618,7 +618,9 @@ export NVCF_TOKEN="nvapi-your-function-creation-token" --inference-url "/" \ --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" + --llm-model "name=dummy-model,uris=/v1/chat/completions|/v1/responses|/v1/embeddings,routingMethod=round_robin,tokenRateLimit=1000-S" \ + --llm-default-priority 7 \ + --llm-per-account-priority "nca-id:3" ``` **Required flags:** @@ -637,6 +639,14 @@ export NVCF_TOKEN="nvapi-your-function-creation-token" "functionType": "LLM", "description": "Example LLM function from JSON config", "tags": ["example", "demo"], + "llmInvocationConfig": { + "priority": { + "defaultPriority": 7, + "perAccountPriority": { + "nca-id": 3 + } + } + }, "health": { "protocol": "HTTP", "uri": "/health", @@ -674,6 +684,8 @@ request. Use `1000-S` for a single inline CLI limit. Use JSON input for combined limits, such as `1000-S,5000-M,100000-H,500000-D,1000000-W`, because inline model specs use commas as field separators. Supported LLM paths are `/v1/chat/completions`, `/v1/responses`, and `/v1/embeddings`. +Request priorities are unsigned 32-bit integers from `0` through `4294967295`. Lower values have higher priority, and `0` is the highest priority. An explicit `0` is distinct from an omitted priority. `--llm-per-account-priority` is repeatable and requires `--llm-default-priority` or a `defaultPriority` value in the input file. + #### **Deploy a Function** *Uses `NVCF_TOKEN` (with `NVCF_API_KEY` fallback)* Deploy a function with GPU specifications: @@ -746,6 +758,19 @@ 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" + +# Clear 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" \ + --clear-llm-priority + # Update function deployment specifications ./nvcf-cli function deploy update \ --function-id "func-12345678-1234-1234-1234-123456789abc" \ @@ -765,6 +790,11 @@ export NVCF_API_KEY="nvapi-your-general-operations-token" # optional fallback "functionId": "func-12345678-1234-1234-1234-123456789abc", "versionId": "ver-12345678-1234-1234-1234-123456789abc", "tags": ["production", "ml-model", "updated"], + "llmInvocationConfig": { + "priority": { + "defaultPriority": 0 + } + }, "modelUpdates": [ { "modelName": "dummy-model", @@ -777,6 +807,8 @@ export NVCF_API_KEY="nvapi-your-general-operations-token" # optional fallback } ``` +An update that includes `llmInvocationConfig` replaces the complete function-level priority configuration. Specify every default and per-account value to retain. Omitting the field preserves the current configuration. Use `--clear-llm-priority` or set `"llmInvocationConfig": {}` in the update file to clear it. + **Update Deployment JSON format (`update-deployment.json`):** ```json { diff --git a/src/clis/nvcf-cli/USAGE-GUIDE.md b/src/clis/nvcf-cli/USAGE-GUIDE.md index 73a369559..7cc91270e 100644 --- a/src/clis/nvcf-cli/USAGE-GUIDE.md +++ b/src/clis/nvcf-cli/USAGE-GUIDE.md @@ -752,7 +752,9 @@ curl -X POST https://api.nvcf.nvidia.com/v2/nvcf/accounts/nvcf-default/registry- --inference-port 8000 \ --inference-url / \ --function-type LLM \ - --llm-model "name=dummy-model,uris=/v1/chat/completions|/v1/responses|/v1/embeddings,routingMethod=round_robin,tokenRateLimit=1000-S" + --llm-model "name=dummy-model,uris=/v1/chat/completions|/v1/responses|/v1/embeddings,routingMethod=round_robin,tokenRateLimit=1000-S" \ + --llm-default-priority 7 \ + --llm-per-account-priority "nca-id:3" ``` **Secrets Format:** @@ -799,6 +801,14 @@ curl -X POST https://api.nvcf.nvidia.com/v2/nvcf/accounts/nvcf-default/registry- "inferenceUrl": "/", "inferencePort": 8000, "functionType": "LLM", + "llmInvocationConfig": { + "priority": { + "defaultPriority": 7, + "perAccountPriority": { + "nca-id": 3 + } + } + }, "models": [ { "name": "dummy-model", @@ -817,6 +827,8 @@ For LLM models, `llmConfig.routingMethod` accepts the API/auth spellings CLI validates these values before sending the create request. Supported LLM paths are `/v1/chat/completions`, `/v1/responses`, and `/v1/embeddings`. +Request priorities are unsigned 32-bit integers from `0` through `4294967295`. Lower values have higher priority, and `0` is the highest priority. An explicit `0` is distinct from an omitted priority. Per-account overrides require a default priority. + ### 5. List Functions #### CLI Usage @@ -1036,6 +1048,29 @@ 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" + +# Clear the function-level request priority configuration +./nvcf-cli function update \ + --function-id "550e8400-e29b-41d4-a716-446655440000" \ + --version-id "01234567-89ab-cdef-0123-456789abcdef" \ + --clear-llm-priority +``` + +When an update includes `llmInvocationConfig`, it replaces the complete function-level priority configuration. Specify every default and per-account value to retain. Omitting the field preserves the current configuration. An empty object clears it: + +```json +{ + "functionId": "550e8400-e29b-41d4-a716-446655440000", + "versionId": "01234567-89ab-cdef-0123-456789abcdef", + "llmInvocationConfig": {} +} ``` ### Delete Function or Deployment @@ -1373,4 +1408,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..fb5b734d7 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" @@ -254,13 +256,15 @@ 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 or cleared. A priority update replaces the existing +function-level priority configuration, so specify every value to retain. For updating deployments, use: nvcf-cli function deploy update @@ -332,6 +336,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 +375,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 +433,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. @@ -478,6 +495,10 @@ var createFlags struct { llmModels []string resources []string + // Function-level LLM invocation configuration + llmDefaultPriority uint32 + llmPerAccountPriorities []string + // Rate limiting rateLimit string rateLimitExempted []string @@ -517,11 +538,14 @@ var invokeFlags struct { } var updateFlags struct { - inputFile string - functionID string - versionID string - tags []string - llmModelUpdates []string + inputFile string + functionID string + versionID string + tags []string + llmModelUpdates []string + llmDefaultPriority uint32 + llmPerAccountPriorities []string + clearLLMPriority bool } // ============================================================================ @@ -569,6 +593,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().Uint32Var(&createFlags.llmDefaultPriority, "llm-default-priority", 0, "Function-level default request priority (lower is higher; range: 0-4294967295)") + createCmd.Flags().StringArrayVar(&createFlags.llmPerAccountPriorities, "llm-per-account-priority", []string{}, "Per-account request priority override (format: :; requires default priority; lower is higher; range: 0-4294967295; repeatable, max 64)") 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 +636,9 @@ 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().Uint32Var(&updateFlags.llmDefaultPriority, "llm-default-priority", 0, "Function-level default request priority (lower is higher; range: 0-4294967295; replaces existing priority config)") + updateCmd.Flags().StringArrayVar(&updateFlags.llmPerAccountPriorities, "llm-per-account-priority", []string{}, "Per-account request priority override (format: :; requires default priority; lower is higher; range: 0-4294967295; repeatable, max 64)") + updateCmd.Flags().BoolVar(&updateFlags.clearLLMPriority, "clear-llm-priority", false, "Clear the function-level request priority configuration") } // ============================================================================ @@ -924,8 +953,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,6 +1160,9 @@ func applyCreateFlagOverrides(cmd *cobra.Command, config *CreateConfig) error { applyCreateHelmFlagOverrides(cmd, config) applyCreateRateLimitFlagOverrides(cmd, config) applyCreateTelemetryFlagOverrides(cmd, config) + if err := applyCreateRequestPriorityFlagOverrides(cmd, config); err != nil { + return err + } if err := applyCreateContainerEnvFlag(cmd, config); err != nil { return err @@ -1134,6 +1170,49 @@ func applyCreateFlagOverrides(cmd *cobra.Command, config *CreateConfig) error { return applyCreateArtifactFlagOverrides(cmd, config) } +func applyCreateRequestPriorityFlagOverrides(cmd *cobra.Command, config *CreateConfig) error { + return applyRequestPriorityFlagOverrides( + cmd.Flags().Changed("llm-default-priority"), + createFlags.llmDefaultPriority, + cmd.Flags().Changed("llm-per-account-priority"), + createFlags.llmPerAccountPriorities, + &config.LLMInvocationConfig, + ) +} + +func applyRequestPriorityFlagOverrides( + defaultChanged bool, + defaultPriority uint32, + perAccountChanged bool, + perAccountValues []string, + target **LLMInvocationConfigInput, +) error { + if !defaultChanged && !perAccountChanged { + return nil + } + + config := *target + if config == nil { + config = &LLMInvocationConfigInput{} + } + if config.Priority == nil { + config.Priority = &PriorityInput{} + } + if defaultChanged { + value := defaultPriority + config.Priority.DefaultPriority = &value + } + if perAccountChanged { + overrides, err := parsePerAccountPriorities(perAccountValues) + if err != nil { + return err + } + config.Priority.PerAccountPriority = overrides + } + *target = config + return validateLLMInvocationConfig(config) +} + func applyCreateRequiredFlagOverrides(cmd *cobra.Command, config *CreateConfig) { if cmd.Flags().Changed("name") { config.Name = createFlags.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 per-account 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 per-account 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,24 @@ func loadUpdateConfig(cmd *cobra.Command) (*UpdateConfig, error) { config.ModelUpdates = append(config.ModelUpdates, updates...) } + priorityFlagsChanged := cmd.Flags().Changed("llm-default-priority") || cmd.Flags().Changed("llm-per-account-priority") + if cmd.Flags().Changed("clear-llm-priority") && updateFlags.clearLLMPriority { + if priorityFlagsChanged { + return nil, fmt.Errorf("--clear-llm-priority cannot be used with --llm-default-priority or --llm-per-account-priority") + } + config.LLMInvocationConfig = &LLMInvocationConfigInput{} + } else if priorityFlagsChanged { + if err := applyRequestPriorityFlagOverrides( + cmd.Flags().Changed("llm-default-priority"), + updateFlags.llmDefaultPriority, + cmd.Flags().Changed("llm-per-account-priority"), + updateFlags.llmPerAccountPriorities, + &config.LLMInvocationConfig, + ); err != nil { + return nil, err + } + } + return config, nil } @@ -1446,10 +1618,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 +1684,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 +1718,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 +2178,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 +2211,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_llm_model_test.go b/src/clis/nvcf-cli/cmd/function_llm_model_test.go index 15dfbd633..85db0e048 100644 --- a/src/clis/nvcf-cli/cmd/function_llm_model_test.go +++ b/src/clis/nvcf-cli/cmd/function_llm_model_test.go @@ -303,6 +303,9 @@ func TestLoadCreateConfigAppendsLLMModelFlag(t *testing.T) { llmModels []string resources []string + llmDefaultPriority uint32 + llmPerAccountPriorities []string + rateLimit string rateLimitExempted []string rateLimitSync bool 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..d7eaa1260 --- /dev/null +++ b/src/clis/nvcf-cli/cmd/function_request_priority_test.go @@ -0,0 +1,390 @@ +/* +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" + "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("llm-default-priority", "0"); err != nil { + t.Fatalf("set default priority: %v", err) + } + if err := cmd.Flags().Set("llm-per-account-priority", "nca-1:3"); err != nil { + t.Fatalf("set per-account priority: %v", err) + } + createFlags.llmDefaultPriority = 0 + createFlags.llmPerAccountPriorities = []string{"nca-1:3"} + + 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 TestLoadUpdateConfigAppliesRequestPriorityFlags(t *testing.T) { + originalFlags := updateFlags + t.Cleanup(func() { updateFlags = originalFlags }) + + cmd := newPriorityFlagTestCommand() + if err := cmd.Flags().Set("llm-default-priority", "7"); err != nil { + t.Fatalf("set default priority: %v", err) + } + if err := cmd.Flags().Set("llm-per-account-priority", "nca-1:3"); err != nil { + t.Fatalf("set per-account priority: %v", err) + } + updateFlags.llmDefaultPriority = 7 + updateFlags.llmPerAccountPriorities = []string{"nca-1:3"} + + 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 TestLoadUpdateConfigClearsRequestPriority(t *testing.T) { + originalFlags := updateFlags + t.Cleanup(func() { updateFlags = originalFlags }) + + cmd := newPriorityFlagTestCommand() + if err := cmd.Flags().Set("clear-llm-priority", "true"); err != nil { + t.Fatalf("set clear priority: %v", err) + } + updateFlags.clearLLMPriority = true + + config, err := loadUpdateConfig(cmd) + if err != nil { + t.Fatalf("load update config: %v", err) + } + if config.LLMInvocationConfig == nil { + t.Fatal("llmInvocationConfig is nil, want empty config") + } + if config.LLMInvocationConfig.Priority != nil { + t.Fatalf("priority = %#v, want nil", config.LLMInvocationConfig.Priority) + } +} + +func TestLoadUpdateConfigRejectsClearWithPriorityFlags(t *testing.T) { + originalFlags := updateFlags + t.Cleanup(func() { updateFlags = originalFlags }) + + cmd := newPriorityFlagTestCommand() + if err := cmd.Flags().Set("clear-llm-priority", "true"); err != nil { + t.Fatalf("set clear priority: %v", err) + } + if err := cmd.Flags().Set("llm-default-priority", "7"); err != nil { + t.Fatalf("set default priority: %v", err) + } + updateFlags.clearLLMPriority = true + updateFlags.llmDefaultPriority = 7 + + _, err := loadUpdateConfig(cmd) + if err == nil || !strings.Contains(err.Error(), "cannot be used with") { + t.Fatalf("error = %v, want mutually exclusive flags error", err) + } +} + +func TestRequestPriorityFlagsPreserveInputFileFieldsWhenOmitted(t *testing.T) { + t.Parallel() + + config := &CreateConfig{LLMInvocationConfig: priorityConfig(7, map[string]uint32{"nca-1": 3})} + if err := applyCreateRequestPriorityFlagOverrides(&cobra.Command{}, config); err != nil { + t.Fatalf("apply priority flags: %v", err) + } + assertPriorityConfig(t, config.LLMInvocationConfig, 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("llm-default-priority", 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("llm-default-priority", 0, "") + cmd.Flags().StringArray("llm-per-account-priority", nil, "") + cmd.Flags().Bool("clear-llm-priority", false, "") + 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 d1ddd58e2..9ca62649c 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" + - "MDowMFoiLAogICJ0b3RhbEZpbGVzIjogMjIsCiAgInRvdGFsQnl0ZXMiOiAxOTg5NzcsCiAgImZp" + + "MDowMFoiLAogICJ0b3RhbEZpbGVzIjogMjIsCiAgInRvdGFsQnl0ZXMiOiAyMDAzNjYsCiAgImZp" + "bGVzIjogWwogICAgewogICAgICAicGF0aCI6ICJudmNmLXNlbGYtbWFuYWdlZC1jbGkvU0tJTEwu" + "bWQiLAogICAgICAic2hhMjU2IjogImM0ZjI4OGY2MmU1MDg4NjI5ZGY1MTcyYTlhYjMwZWVlOGMz" + "OTRmYzgzOTFjMjMwMDMzNzI2NGVmZjRiMmU3ZWYiLAogICAgICAic2l6ZSI6IDI0OTA5CiAgICB9" + @@ -71,3616 +71,3640 @@ const skillDataZipBase64 = "" + "ZW5jZS9leGl0LWNvZGVzLm1kIiwKICAgICAgInNoYTI1NiI6ICI2NGI1ZmE5YmNhZjBlMGE1M2Y3" + "ODkyMGI3M2ZjYjUzMGFiNjk0NTFiNDhhNWI0OTNmMjUyY2ExODU4M2FiMDg2IiwKICAgICAgInNp" + "emUiOiAxNzQ5CiAgICB9LAogICAgewogICAgICAicGF0aCI6ICJudmNmLXNlbGYtbWFuYWdlZC1j" + - "bGkvcmVmZXJlbmNlL2ZsYWdzLm1kIiwKICAgICAgInNoYTI1NiI6ICI1NGI1ZWE3OTgxZDI2MjZj" + - "NTgzNTMzMmFiYTI3ZWIyODdhY2E4OWUxYmFkY2IyZmFiODA3MDFhZTI5Zjc2ZTA4IiwKICAgICAg" + - "InNpemUiOiA4OTAyCiAgICB9LAogICAgewogICAgICAicGF0aCI6ICJudmNmLXNlbGYtbWFuYWdl" + - "ZC1jbGkvcmVmZXJlbmNlL3Ryb3VibGVzaG9vdGluZy5tZCIsCiAgICAgICJzaGEyNTYiOiAiYTYz" + - "MDg0ZTIyNDlmMWQxNTRjNTk4MWU0YTA3MmI3Yzc4NGI4NWVhMTQ2MDg2NTE1ZWFiNGFiNjcwYTk0" + - "MGU5NCIsCiAgICAgICJzaXplIjogNDQ2OAogICAgfSwKICAgIHsKICAgICAgInBhdGgiOiAibnZj" + - "Zi1zZWxmLW1hbmFnZWQtaW5zdGFsbGF0aW9uL1NLSUxMLm1kIiwKICAgICAgInNoYTI1NiI6ICJj" + - "MzNmZDgzMDVlYzNmZDAyMGViNGM5ODJjM2FmZTc2YTdjMWQ0M2MzZTA1NGM4ZmJkMzhjNGJiMWI3" + - "MDdjNzVhIiwKICAgICAgInNpemUiOiAyNTE1NAogICAgfSwKICAgIHsKICAgICAgInBhdGgiOiAi" + - "bnZjZi1zZWxmLW1hbmFnZWQtaW5zdGFsbGF0aW9uL2V2YWxzL2V2YWxzLmpzb24iLAogICAgICAi" + - "c2hhMjU2IjogImM1YjQ1MzM3ZTQ5YjNhYjhhZTI4MzQ1ZDMxNjRhN2Y1NzkxOWU2NDQ4OTg3MDJk" + - "MGNhYWQ0OGFlZTI4YjFmM2EiLAogICAgICAic2l6ZSI6IDIxOTMzCiAgICB9LAogICAgewogICAg" + - "ICAicGF0aCI6ICJudmNmLXNlbGYtbWFuYWdlZC1pbnN0YWxsYXRpb24vZXhhbXBsZXMubWQiLAog" + - "ICAgICAic2hhMjU2IjogIjlhMzllNWNjYWJkNDA4MTljNzFmMmIwZjJkNzUyMzE2YjcyMzE1NjU0" + - "ZDgwZDNkMDE3Njk4Y2UxZmIzZTViMTEiLAogICAgICAic2l6ZSI6IDEwMzY3CiAgICB9LAogICAg" + - "ewogICAgICAicGF0aCI6ICJudmNmLXNlbGYtbWFuYWdlZC1pbnN0YWxsYXRpb24vcmVmZXJlbmNl" + - "cy9jb21wdXRlLXBsYW5lLWluc3RhbGxhdGlvbi5tZCIsCiAgICAgICJzaGEyNTYiOiAiNWRlZTU4" + - "YWUyYzY3YTYyOTQ2ZTNjNTkzMDJhZmFjYzQwYmRlNzFmOGRjMmYyNWNkNzc5OWNjNDViNDc0ZmEx" + - "OSIsCiAgICAgICJzaXplIjogMTIzMDYKICAgIH0sCiAgICB7CiAgICAgICJwYXRoIjogIm52Y2Yt" + - "c2VsZi1tYW5hZ2VkLWluc3RhbGxhdGlvbi9yZWZlcmVuY2VzL2RlYnVnZ2luZy5tZCIsCiAgICAg" + - "ICJzaGEyNTYiOiAiYTUyODE1OGJjMGJmZmZlZWY2ZTAxZGUzODRjYWY1NjVlNjQ0NWI0OGFiZDNj" + - "ZWU0MDA0ODcxZjUyM2Y1M2I5NyIsCiAgICAgICJzaXplIjogMTI0MzcKICAgIH0sCiAgICB7CiAg" + - "ICAgICJwYXRoIjogIm52Y2Ytc2VsZi1tYW5hZ2VkLWluc3RhbGxhdGlvbi9yZWZlcmVuY2VzL2hl" + - "bG1maWxlLXN0cnVjdHVyZS5tZCIsCiAgICAgICJzaGEyNTYiOiAiMWQ1Mjc3NmY5ZDdkOGRmNThk" + - "ZWZlMzA0NmQ2M2VjOGY1MmZkMzAxYzIxNWJmMGUxYWI2YmI5MTkxNjIwNzNkZSIsCiAgICAgICJz" + - "aXplIjogMTAxMjcKICAgIH0sCiAgICB7CiAgICAgICJwYXRoIjogIm52Y2Ytc2VsZi1tYW5hZ2Vk" + - "LWluc3RhbGxhdGlvbi9yZWZlcmVuY2VzL252Y2YtdWktYWRkb24ubWQiLAogICAgICAic2hhMjU2" + - "IjogIjUwNTI0ZTZlMTk3MTE4M2JkYzlhZDBhYzM4YTgwN2RmNzJjYzA4NTFiNzlmNTE4ZmUxMWE0" + - "OGU0NTk3Yzg1MGUiLAogICAgICAic2l6ZSI6IDE5NzcKICAgIH0sCiAgICB7CiAgICAgICJwYXRo" + - "IjogIm52Y2Ytc2VsZi1tYW5hZ2VkLWluc3RhbGxhdGlvbi9yZWZlcmVuY2VzL3B1bGwtc2VjcmV0" + - "cy5tZCIsCiAgICAgICJzaGEyNTYiOiAiZWMxZjNmZmNkMTdlNWY5NTgzZmVlMzk3NDRlZTg5N2Q0" + - "NjZiYzNjZjYzODkyOTQyNjRkODllN2Y5ZWQwMWI4NyIsCiAgICAgICJzaXplIjogNTYzMgogICAg" + - "fQogIF0KfQpQSwcI0GJVtkkQAABJEAAAUEsDBBQACAAAAAAAIQAAAAAAAAAAAAAAAAAjAAkAZGF0" + - "YS9udmNmLXNlbGYtbWFuYWdlZC1jbGkvU0tJTEwubWRVVAUAAQCmzhItLS0KbmFtZTogbnZjZi1z" + - "ZWxmLW1hbmFnZWQtY2xpCmRlc2NyaXB0aW9uOiB8CiAgSW5zdGFsbCwgb3BlcmF0ZSwgYW5kIHRl" + - "YXIgZG93biBzZWxmLWhvc3RlZCBOVklESUEgQ2xvdWQgRnVuY3Rpb25zIChOVkNGKQogIGRlcGxv" + - "eW1lbnRzIHdpdGggbnZjZi1jbGkuIFVzZSBmb3IgY29udHJvbC1wbGFuZSBvciBjb21wdXRlLXBs" + - "YW5lIGluc3RhbGwsCiAgc3RhdHVzIGNoZWNrcywgY2x1c3RlciByZWdpc3RyYXRpb24sIGZ1bmN0" + - "aW9uIGRlcGxveS9pbnZva2UsIHRhc2sKICBjcmVhdGUvbGlzdC9jYW5jZWwvZGVsZXRlLCBBUEkg" + - "a2V5cywgYWRtaW4gdG9rZW5zLCBKV0tTIHJvdGF0aW9uLAogIGZhaWxlZC1pbnN0YWxsIGRpYWdu" + - "b3NpcywgYW5kIHVuaW5zdGFsbCBvciBkb3duIHdvcmtmbG93cy4gVHJpZ2dlciBrZXl3b3JkczoK" + - "ICBudmNmLCBudmNmLWNsaSwgc2VsZi1ob3N0ZWQgbnZjZiwgc2VsZi1tYW5hZ2VkIG52Y2YsIE5W" + - "Q0ZCYWNrZW5kLCBOVkNBLCBOQ1AsCiAgSUNNUywgaGVsbWZpbGUsIGNvbnRyb2wgcGxhbmUsIGNv" + - "bXB1dGUgcGxhbmUsIExMTSBmdW5jdGlvbiwKICBPcGVuQUktY29tcGF0aWJsZSBpbnZvY2F0aW9u" + - "LCBSZXNwb25zZXMgQVBJLCBlbWJlZGRpbmdzLCBiYXRjaCB0YXNrLCB0YXNrCiAgbW9uaXRvciwg" + - "Y2x1c3RlciByb3RhdGUsIGNsdXN0ZXIgZGVsZXRlLCBoZWxtIHRhc2ssIGhlbG0tYmFzZWQgdGFz" + - "aywKICB0YXNrIHNlY3JldHMsIHVwZGF0ZSB0YXNrIHNlY3JldHMsIHJldHJpZXZlIHRhc2sgcmVz" + - "dWx0cywgYnVsayBmZXRjaCB0YXNrcywKICB0YXNrIHJlc3VsdHMsIE5WQ1QsIE5WQ1QgdGFzaywg" + - "TlZDVCBiYXRjaCBqb2IuCmFsbG93ZWQtdG9vbHM6IEJhc2gsIFJlYWQsIEFza1VzZXJRdWVzdGlv" + - "bgphcmd1bWVudC1oaW50OiAiW2luc3RhbGx8c3RhdHVzfGNoZWNrfGRlcGxveS1mdW5jdGlvbnxy" + - "ZWdpc3Rlci1jbHVzdGVyfHRlYXJkb3duXSBbYXJnc10iCi0tLQo8IS0tClRva2VuIEJ1ZGdldDoK" + - "LSBMZXZlbCAxIChZQU1MKTogfjEyMCB0b2tlbnMKLSBMZXZlbCAyICh0aGlzIGZpbGUpOiB+MTkw" + - "MCB0b2tlbnMgKHRhcmdldCA8MjAwMCkKLSBMZXZlbCAzIChwcm9tcHRzLywgcmVmZXJlbmNlLywg" + - "ZXhhbXBsZXMvKTogbG9hZGVkIG9uIGRlbWFuZAotLT4KCiMgTlZDRiBTZWxmLUhvc3RlZCBDTEkK" + - "CmBudmNmLWNsaWAgZHJpdmVzIGV2ZXJ5IHN0ZXAgb2YgYnJpbmdpbmcgdXAgc2VsZi1ob3N0ZWQg" + - "TlZJRElBIENsb3VkIEZ1bmN0aW9uczogY2x1c3RlciByZWdpc3RyYXRpb24sIGNvbnRyb2wtcGxh" + - "bmUgaW5zdGFsbCwgY29tcHV0ZS1wbGFuZSBpbnN0YWxsLCBmdW5jdGlvbiBkZXBsb3kvaW52b2tl" + - "LCBhbmQgbGlmZWN5Y2xlIG1hbmFnZW1lbnQuIFVzZSB0aGlzIHNraWxsIGFueSB0aW1lIHRoZSB1" + - "c2VyIHdhbnRzIHRvIG9wZXJhdGUgc2VsZi1ob3N0ZWQgTlZDRi4KCiMjIFdoZW4gdG8gdXNlCgot" + - "ICJpbnN0YWxsIHNlbGYtaG9zdGVkIE5WQ0YiIC8gImJyaW5nIHVwIGFuIE5WQ0YgY2x1c3RlciIK" + - "LSAicmVnaXN0ZXIgYSAoY29tcHV0ZXxHUFUpIGNsdXN0ZXIgd2l0aCBOVkNGIgotICJkZXBsb3kg" + - "YSAoY29udGFpbmVyfEdQVSkgZnVuY3Rpb24iIC8gImludm9rZSBhbiBOVkNGIGZ1bmN0aW9uIgot" + - "ICJjaGVjayBOVkNGIGNsdXN0ZXIgaGVhbHRoIiAvICJpcyBteSBOVkNGIGluc3RhbGwgT0s/Igot" + - "ICJyb3RhdGUgTlZDRiBjbHVzdGVyIEpXS1MiIC8gInRoZSBOVkNBIGFnZW50IHN0b3BwZWQgYXV0" + - "aGVudGljYXRpbmciCi0gInRlYXIgZG93biBOVkNGIiAvICJyZW1vdmUgdGhlIGNvbXB1dGUgcGxh" + - "bmUiIC8gInVuaW5zdGFsbCBOVkNGIiAvICJkZXJlZ2lzdGVyIHRoaXMgY2x1c3RlciIKLSAicHJl" + - "dmlldyB3aGF0IGBkb3duYCB3b3VsZCBkbyIgLyAiZHJ5LXJ1biB1bmluc3RhbGwiCi0gQW55IHRh" + - "c2sgb3BlcmF0aW9uOiBjcmVhdGUgLyBydW4gLyBzdWJtaXQgLyBtb25pdG9yIC8gY2FuY2VsIC8g" + - "ZGVsZXRlIC8gbGlzdCB0YXNrcywgaGVsbSB0YXNrLCB1cGRhdGUgdGFzayBzZWNyZXRzLCByZXRy" + - "aWV2ZSB0YXNrIHJlc3VsdHMsIGJ1bGsgZmV0Y2ggdGFzayBkZXRhaWxzLgotIEFueSByZWZlcmVu" + - "Y2UgdG8gYE5WQ1RgLCBgTlZDVCB0YXNrYCwgb3IgYE5WQ1QgYmF0Y2ggam9iYCAobGlzdCAvIHJ1" + - "biAvIGNhbmNlbCAvIGRlbGV0ZSAvIHJlc3VsdHMpLgotIEFueSByZWZlcmVuY2UgdG8gYE5WQ0ZC" + - "YWNrZW5kYCwgYE5WQ0FgLCBJQ01TLCBoZWxtIHJlbGVhc2VzIGxpa2UgYGhlbG0tbnZjZi0qYCwg" + - "b3IgYGljbXMuPGRvbWFpbj5gIC8gYGFwaS48ZG9tYWluPmAgVVJMcy4KCiMjIFF1aWNrIHN0YXJ0" + - "CgpGb3IgcmVtb3RlIG9uZS1jbGljayBpbnN0YWxscywgcHJlcGFyZSBHYXRld2F5IEFQSSBpbmdy" + - "ZXNzIGFuZCBDTEkgZW5kcG9pbnQKY29uZmlndXJhdGlvbiBiZWZvcmUgcnVubmluZyBgc2VsZi1o" + - "b3N0ZWQgdXBgLiBUaGUgY29tbWFuZCBhcHBsaWVzIHRoZSBjb250cm9sCnBsYW5lIGFuZCB0aGVu" + - "IGltbWVkaWF0ZWx5IGNhbGxzIEFQSSwgQVBJIEtleXMsIGludm9jYXRpb24sIGFuZCBnUlBDIGVu" + - "ZHBvaW50cy4KSWYgdGhlIEdhdGV3YXkgaXMgbm90IHByb2dyYW1tZWQgb3IgdGhlIENMSSBob3N0" + - "IGhlYWRlcnMgZG8gbm90IG1hdGNoIHRoZQpIVFRQUm91dGVzIHJlbmRlcmVkIGJ5IHRoZSBzdGFj" + - "ayBlbnZpcm9ubWVudCwgcG9zdC1pbnN0YWxsIGhlYWx0aCBhbmQgY2x1c3RlcgpyZWdpc3RyYXRp" + - "b24gd2lsbCBmYWlsLgoKYGBgc2gKIyBTaW5nbGUtY2x1c3RlciAoY29udHJvbCArIGNvbXB1dGUg" + - "b24gdGhlIGN1cnJlbnQga3ViZWNvbmZpZyBjb250ZXh0KToKbnZjZi1jbGkgc2VsZi1ob3N0ZWQg" + - "dXAgLS1jbHVzdGVyLW5hbWU9bmNwLWxvY2FsCgojIFNwbGl0LWNsdXN0ZXIgKGNvbnRyb2wgcGxh" + - "bmUgb24gY29udGV4dCBBLCBjb21wdXRlIHBsYW5lIG9uIGNvbnRleHQgQik6CktVQkVDT05GSUc9" + - "Y3AueWFtbDpncHUxLnlhbWwgbnZjZi1jbGkgc2VsZi1ob3N0ZWQgdXAgXAogIC0tY2x1c3Rlci1u" + - "YW1lPW5jcC1sb2NhbCBcCiAgLS1jb250cm9sLXBsYW5lLWNvbnRleHQ9YWRtaW5AY3AgXAogIC0t" + - "Y29tcHV0ZS1wbGFuZS1jb250ZXh0PWFkbWluQGdwdTEgXAogIC0taWNtcy11cmw9aHR0cHM6Ly9p" + - "Y21zLm52Y2YuZXhhbXBsZS5jb20KCiMgQWRkIGEgbmV3IGNvbXB1dGUgcGxhbmUgdG8gYW4gZXhp" + - "c3RpbmcgY29udHJvbCBwbGFuZSAobm8ga3ViZWN0bCBhY2Nlc3MgdG8gQ1AgbmVlZGVkOwojIHJl" + - "YWNoZXMgdGhlIGNvbnRyb2wgcGxhbmUgdmlhIHRoZSBwdWJsaWMgSUNNUyBIVFRQUm91dGUpOgpu" + - "dmNmLWNsaSBzZWxmLWhvc3RlZCBhZGQtY29tcHV0ZS1wbGFuZSBcCiAgLS1jbHVzdGVyLW5hbWU9" + - "bmNwLWxvY2FsLTIgXAogIC0tY29tcHV0ZS1wbGFuZS1jb250ZXh0PWFkbWluQGdwdTIgXAogIC0t" + - "aWNtcy11cmw9aHR0cHM6Ly9pY21zLm52Y2YuZXhhbXBsZS5jb20gXAogIC0tdG9rZW49JEFETUlO" + - "X0pXVAoKIyBUZWFyIGRvd24gKGFsd2F5cyBwbGFuLW9ubHkgZmlyc3QpOgpudmNmLWNsaSBzZWxm" + - "LWhvc3RlZCBkb3duIC0tcGxhbi1vbmx5IC0tY2x1c3Rlci1uYW1lPW5jcC1sb2NhbCAtLWpzb24g" + - "fCBqcQpudmNmLWNsaSBzZWxmLWhvc3RlZCBkb3duIC0tY2x1c3Rlci1uYW1lPW5jcC1sb2NhbAoK" + - "IyBQZXItcGxhbmUgdW5pbnN0YWxsIChHaXRPcHM7IG1pcnJvcnMgYGluc3RhbGxgKToKbnZjZi1j" + - "bGkgc2VsZi1ob3N0ZWQgdW5pbnN0YWxsIC0tbm8tYXBwbHkgLS1jb21wdXRlLXBsYW5lIC0tY2x1" + - "c3Rlci1uYW1lPW5jcC1sb2NhbCB8IGt1YmVjdGwgZGVsZXRlIC1mIC0KYGBgCgo+ICoqYHVwYCB2" + - "cyBgYWRkLWNvbXB1dGUtcGxhbmVgLioqIGB1cGAgYWx3YXlzIGluc3RhbGxzIGJvdGggcGxhbmVz" + - "IOKAlCB1c2UgaXQgZm9yIHRoZSAqZmlyc3QqIGluc3RhbGwuIGBhZGQtY29tcHV0ZS1wbGFuZWAg" + - "aXMgdGhlIHJpZ2h0IHN1YmNvbW1hbmQgYW55IHRpbWUgdGhlIGNvbnRyb2wgcGxhbmUgaXMgYWxy" + - "ZWFkeSBydW5uaW5nIGFuZCB5b3Ugd2FudCB0byBhdHRhY2ggYW4gTnRoIGNvbXB1dGUgY2x1c3Rl" + - "ci4KCj4gKipgZG93bmAgYWx3YXlzIHdpdGggYC0tcGxhbi1vbmx5YCBmaXJzdC4qKiBTaG93IHRo" + - "ZSB1c2VyIHRoZSBgd2lsbFVuaW5zdGFsbC5jb21tYW5kc1tdYCBhcnJheSBiZWZvcmUgcnVubmlu" + - "ZyBmb3IgcmVhbC4KCiMjIEF1dGhlbnRpY2F0aW9uCgpgbnZjZi1jbGlgIHVzZXMgdHdvIGNyZWRl" + - "bnRpYWxzLiBFYWNoIGlzIHJlc29sdmVkIGluZGVwZW5kZW50bHkgaW4gdGhpcyBvcmRlcjoKCnwg" + - "UHJlY2VkZW5jZSB8IFNvdXJjZSB8CnwtLS18LS0tfAp8IDEgKGhpZ2hlc3QpIHwgRW52aXJvbm1l" + - "bnQgdmFyaWFibGUgKGBOVkNGX1RPS0VOYCwgYE5WQ0ZfQVBJX0tFWWApIHwKfCAyIHwgQ29uZmln" + - "IGZpbGUgKGB+Ly5udmNmLWNsaS55YW1sYCwga2V5cyBgdG9rZW5gIGFuZCBgYXBpX2tleWApIHwK" + - "fCAzIHwgU3RhdGUgZmlsZSAoYH4vLm52Y2YtY2xpLnN0YXRlYCksIHNraXBwZWQgd2hlbiB0aGUg" + - "c3RvcmVkIHRva2VuIGlzIGV4cGlyZWQgfAoKfCBFbnYgdmFyIHwgVG9rZW4gdHlwZSB8IFVzZWQg" + - "YnkgfAp8LS0tfC0tLXwtLS18CnwgYE5WQ0ZfVE9LRU5gIHwgQWRtaW4gSldUIHwgYGZ1bmN0aW9u" + - "IGNyZWF0ZWAgLyBgZGVwbG95YCAvIGB1cGRhdGVgIC8gYGRlbGV0ZWAsIGNsdXN0ZXIgbWFuYWdl" + - "bWVudCAoYGNsdXN0ZXIgcmVnaXN0ZXJgL2BsaXN0LXJlZ2lzdGVyZWRgL2Byb3RhdGVgL2BkZWxl" + - "dGVgLCBgc2VsZi1ob3N0ZWRgIG9wcykuIFJlcXVpcmVkIGZvciBhZG1pbiBjb21tYW5kczsgcHJl" + - "ZmVycmVkIGZvciB0aGUgcmVzdC4gfAp8IGBOVkNGX0FQSV9LRVlgIHwgYG52YXBpLS4uLmAgQVBJ" + - "IGtleSB8IGBmdW5jdGlvbiBpbnZva2VgIC8gYGxpc3RgIC8gYGdldGAsIHF1ZXVlIGRldGFpbHMu" + - "IEZhbGxzIGJhY2sgdG8gYE5WQ0ZfVE9LRU5gIHdoZW4gdW5zZXQuIHwKClRva2VuIGdlbmVyYXRp" + - "b24gZmxvdzoKCjEuIFBvaW50IHRoZSBDTEkgYXQgeW91ciBzZWxmLWhvc3RlZCBlbmRwb2ludHMu" + - "IERlZmF1bHRzIHRhcmdldCBwcm9kdWN0aW9uIE5WQ0Y7IG92ZXJyaWRlIHdpdGggZW52IHZhcnMg" + - "b3IgYSB5YW1sIGZpbGUgKGAtLWNvbmZpZyA8cGF0aD5gLCBgLi8ubnZjZi1jbGkueWFtbGAsIG9y" + - "IGB+Ly5udmNmLWNsaS55YW1sYDsgYSBmdWxsIHRlbXBsYXRlIHNoaXBzIGF0IGBzcmMvY2xpcy9u" + - "dmNmLWNsaS8ubnZjZi1jbGkueWFtbC50ZW1wbGF0ZWApLgoKICAgYE5WQ0ZfQkFTRV9IVFRQX1VS" + - "TGAgLyBgQVBJX0tFWVNfU0VSVklDRV9VUkxgIC8gYE5WQ0ZfQkFTRV9HUlBDX1VSTGAgdGVsbCB0" + - "aGUgQ0xJICp3aGVyZSB0byBzZW5kIHJlcXVlc3RzKi4gYEFQSV9IT1NUYCAvIGBBUElfS0VZU19I" + - "T1NUYCAvIGBJTlZPS0VfSE9TVGAgc2V0IHRoZSBgSG9zdDpgIGhlYWRlciBvbiB0aG9zZSByZXF1" + - "ZXN0cyDigJQgbmVlZGVkIHdoZW4gZXZlcnkgTlZDRiBzZXJ2aWNlIHNpdHMgYmVoaW5kIGEgc2lu" + - "Z2xlIGdhdGV3YXkgdGhhdCByb3V0ZXMgYnkgaG9zdG5hbWUgKEVudm95IEdhdGV3YXkgSFRUUFJv" + - "dXRlIG9uIGBhcGkuPEVMQj5gLCBgYXBpLWtleXMuPEVMQj5gLCBgaW52b2NhdGlvbi48RUxCPmAs" + - "IGBsbG0uPEVMQj5gKS4gU2tpcCB0aGUgdGhyZWUgSG9zdCB2YXJzIHdoZW4gdGhlIGJhc2UgVVJM" + - "IGFscmVhZHkgcmVzb2x2ZXMgdG8gdGhlIHJpZ2h0IHNlcnZpY2UuCgogICBFbnYtdmFyIGZvcm06" + - "CiAgIGBgYHNoCiAgIGV4cG9ydCBOVkNGX0JBU0VfSFRUUF9VUkw9aHR0cHM6Ly9ndy5leGFtcGxl" + - "LmNvbQogICBleHBvcnQgQVBJX0tFWVNfU0VSVklDRV9VUkw9aHR0cHM6Ly9ndy5leGFtcGxlLmNv" + - "bQogICBleHBvcnQgTlZDRl9CQVNFX0dSUENfVVJMPWd3LmV4YW1wbGUuY29tOjQ0MwoKICAgIyBP" + - "bmx5IHdoZW4gdGhlIGdhdGV3YXkgcm91dGVzIGJ5IEhvc3QgaGVhZGVyOgogICBleHBvcnQgQVBJ" + - "X0tFWVNfSE9TVD1hcGkta2V5cy5ndy5leGFtcGxlLmNvbQogICBleHBvcnQgQVBJX0hPU1Q9YXBp" + - "Lmd3LmV4YW1wbGUuY29tCiAgIGV4cG9ydCBJTlZPS0VfSE9TVD1pbnZvY2F0aW9uLmd3LmV4YW1w" + - "bGUuY29tCiAgIGBgYAoKICAgWWFtbCBmb3JtIChgfi8ubnZjZi1jbGkueWFtbGApOgogICBgYGB5" + - "YW1sCiAgIGJhc2VfaHR0cF91cmw6IGh0dHBzOi8vZ3cuZXhhbXBsZS5jb20KICAgYXBpX2tleXNf" + - "c2VydmljZV91cmw6IGh0dHBzOi8vZ3cuZXhhbXBsZS5jb20KICAgYmFzZV9ncnBjX3VybDogZ3cu" + - "ZXhhbXBsZS5jb206NDQzCgogICAjIE9ubHkgd2hlbiB0aGUgZ2F0ZXdheSByb3V0ZXMgYnkgSG9z" + - "dCBoZWFkZXI6CiAgIGFwaV9rZXlzX2hvc3Q6IGFwaS1rZXlzLmd3LmV4YW1wbGUuY29tCiAgIGFw" + - "aV9ob3N0OiBhcGkuZ3cuZXhhbXBsZS5jb20KICAgaW52b2tlX2hvc3Q6IGludm9jYXRpb24uZ3cu" + - "ZXhhbXBsZS5jb20KICAgYGBgCgoyLiBgbnZjZi1jbGkgaW5pdGAgY2FsbHMgdGhlIEFQSSBLZXlz" + - "IHNlcnZpY2UgdmlhIHRob3NlIGVuZHBvaW50cyBhbmQgd3JpdGVzIHRoZSBhZG1pbiB0b2tlbiB0" + - "byBgfi8ubnZjZi1jbGkuc3RhdGVgLiBVc2UgYG52Y2YtY2xpIHJlZnJlc2hgIHRvIHJvdGF0ZSBh" + - "IHN0b3JlZCB0b2tlbi4KMy4gQWZ0ZXIgYGluaXRgLCBgbnZjZi1jbGkgYXBpLWtleSBnZW5lcmF0" + - "ZWAgbWludHMgZnVuY3Rpb24gKyB0YXNrIEFQSSBrZXlzIChhbHNvIHN0b3JlZCBpbiBzdGF0ZSku" + - "CgpBZnRlciBgaW5pdGAsIHRoZSBjcmVkZW50aWFscyBsaXZlIGluIGB+Ly5udmNmLWNsaS5zdGF0" + - "ZWAsIHNvIGxhdGVyIGNvbW1hbmRzIHdvcmsgd2l0aG91dCBleHBvcnRpbmcgYE5WQ0ZfVE9LRU5g" + - "IG9yIGBOVkNGX0FQSV9LRVlgLiBFeHBvcnQgdGhlIGVudiB2YXIgb25seSB0byBvdmVycmlkZSB0" + - "aGUgc3RvcmVkIHZhbHVlIChmb3IgZXhhbXBsZSBhIHNob3J0ZXItbGl2ZWQgdG9rZW4gZnJvbSBD" + - "SSkuCgojIyBDb3JlIHN1YmNvbW1hbmRzCgp8IFN1YmNvbW1hbmQgfCBXaGF0IGl0IGRvZXMgfCBX" + - "aGVuIHRvIHVzZSB8CnwtLS18LS0tfC0tLXwKfCBgbnZjZi1jbGkgc2VsZi1ob3N0ZWQgY2hlY2sg" + - "LS1wcmUgWy0tbG9jYWwtb25seSBcfCAtLWNvbnRyb2wtcGxhbmUtY29udGV4dD1YIFx8IC0tY29t" + - "cHV0ZS1wbGFuZS1jb250ZXh0PVldYCB8IFByZS1mbGlnaHQ6IGxvY2FsLWhvc3QgdG9vbHMgKyBj" + - "bHVzdGVyLXNpZGUgcHJlcmVxdWlzaXRlcyB8IEFsd2F5cyBydW4gZmlyc3Qgb24gYSBuZXcgZW52" + - "aXJvbm1lbnQgfAp8IGBudmNmLWNsaSBzZWxmLWhvc3RlZCBpbnN0YWxsIC0tY29udHJvbC1wbGFu" + - "ZSBcfCBrdWJlY3RsIGFwcGx5IC1mIC1gIHwgUmVuZGVyICsgYXBwbHkgdGhlIGNvbnRyb2wgcGxh" + - "bmUgfCBXaGVuIHlvdSB3YW50IG1hbnVhbCBjb250cm9sIG92ZXIgYXBwbHkgKEdpdE9wcy1mcmll" + - "bmRseSkgfAp8IGBudmNmLWNsaSBzZWxmLWhvc3RlZCBpbnN0YWxsIC0tY29tcHV0ZS1wbGFuZSAt" + - "LWNsdXN0ZXItbmFtZT1YIFx8IGt1YmVjdGwgYXBwbHkgLWYgLWAgfCBSZWdpc3RlciBjbHVzdGVy" + - "ICsgcmVuZGVyIGNvbXB1dGUgcGxhbmUgfCBTYW1lIOKAlCBtYW51YWwgYXBwbHkgcGF0aCB8Cnwg" + - "YG52Y2YtY2xpIHNlbGYtaG9zdGVkIHVwIC0tY2x1c3Rlci1uYW1lPVhgIHwgT25lLXNob3QgZmly" + - "c3QgaW5zdGFsbDogcHJlLWZsaWdodCDihpIgY29udHJvbCBwbGFuZSDihpIgcmVnaXN0ZXIg4oaS" + - "IGNvbXB1dGUgcGxhbmUgfCBTdGFuZGFyZCBpbnN0YWxsIHBhdGggKGJvdGggcGxhbmVzIGZyb20g" + - "c2NyYXRjaCkgfAp8IGBudmNmLWNsaSBzZWxmLWhvc3RlZCB1cCAtLXBsYW4tb25seSAtLWNsdXN0" + - "ZXItbmFtZT1YYCB8IERyeS1ydW46IGVtaXQgcGhhc2UtYnktcGhhc2UgcGxhbiArIEVUQSB3aXRo" + - "b3V0IGNoYW5naW5nIHN0YXRlIHwgQWdlbnQgLyBDSSBwcmV2aWV3IGJlZm9yZSBjb21taXQgfAp8" + - "IGBudmNmLWNsaSBzZWxmLWhvc3RlZCBhZGQtY29tcHV0ZS1wbGFuZSAtLWNsdXN0ZXItbmFtZT1Y" + - "IC0tY29tcHV0ZS1wbGFuZS1jb250ZXh0PVkgLS1pY21zLXVybD3igKYgLS10b2tlbj0kSldUYCB8" + - "IEFkZCBhIG5ldyBjb21wdXRlIHBsYW5lIHRvIGFuICpleGlzdGluZyogY29udHJvbCBwbGFuZSAo" + - "bm8gQ1AgaW5zdGFsbCkgfCBBZGRpbmcgdGhlIDJuZCwgM3JkLCDigKYgR1BVIGNsdXN0ZXIgYWZ0" + - "ZXIgdGhlIGluaXRpYWwgYHVwYCB8CnwgYG52Y2YtY2xpIHNlbGYtaG9zdGVkIHVuaW5zdGFsbCAt" + - "LWNvbnRyb2wtcGxhbmVgIHwgUGVyLXBsYW5lIHByaW1pdGl2ZTogYGhlbG1maWxlIGRlc3Ryb3lg" + - "IG9uIHRoZSBjb250cm9sIHBsYW5lIChyZWZ1c2VzIGlmIGNvbXB1dGUgcGxhbmVzIHN0aWxsIHJl" + - "Z2lzdGVyZWQpIHwgRmluYWwgdGVhcmRvd24gYWZ0ZXIgYWxsIGNvbXB1dGUgcGxhbmVzIGFyZSBn" + - "b25lLCBvciBzY3JpcHRlZCBwaXBlbGluZXMgfAp8IGBudmNmLWNsaSBzZWxmLWhvc3RlZCB1bmlu" + - "c3RhbGwgLS1jb21wdXRlLXBsYW5lIC0tY2x1c3Rlci1uYW1lPVhgIHwgUGVyLXBsYW5lIHByaW1p" + - "dGl2ZTogYGhlbG1maWxlIGRlc3Ryb3lgIG9uIGEgY29tcHV0ZSBwbGFuZSAobm8gSUNNUyB1bnJl" + - "Z2lzdGVyLCBubyBkcmFpbikgfCBKdXN0IHJlbW92ZSB0aGUgaGVsbSByZWxlYXNlcyB3aXRob3V0" + - "IHRoZSBJQ01TLXNpZGUgY2xlYW51cCB8CnwgYG52Y2YtY2xpIHNlbGYtaG9zdGVkIHVuaW5zdGFs" + - "bCAtLW5vLWFwcGx5IDxwbGFuZT5gIHwgUmVuZGVyIGRlbGV0ZSBZQU1MIHZpYSBgaGVsbSBnZXQg" + - "bWFuaWZlc3RgIHwgR2l0T3BzOyBgXHwga3ViZWN0bCBkZWxldGUgLWYgLWAgb3IgY29tbWl0ICsg" + - "QXJnbyBhcHBsaWVzIHwKfCBgbnZjZi1jbGkgc2VsZi1ob3N0ZWQgZG93biAtLWNsdXN0ZXItbmFt" + - "ZT1YYCB8IE9yY2hlc3RyYXRvcjogZHJhaW4g4oaSIHVuaW5zdGFsbCAtLWNvbXB1dGUtcGxhbmUg" + - "4oaSIGNsdXN0ZXIgZGVsZXRlIGluIElDTVMgfCBTdGFuZGFyZCAicmVtb3ZlIG9uZSBHUFUgY2x1" + - "c3RlciIgcGF0aCB8CnwgYG52Y2YtY2xpIHNlbGYtaG9zdGVkIGRvd24gLS1hbGwgLS1jb25maXJt" + - "YCB8IE9yY2hlc3RyYXRvcjogdGVhciBkb3duIGV2ZXJ5IHJlZ2lzdGVyZWQgY29tcHV0ZSBwbGFu" + - "ZSArIGNvbnRyb2wgcGxhbmUgfCBGdWxsIHVuaW5zdGFsbCB8CnwgYG52Y2YtY2xpIHNlbGYtaG9z" + - "dGVkIGRvd24gLS1wbGFuLW9ubHkgLS1jbHVzdGVyLW5hbWU9WGAgfCBEcnktcnVuIHByZXZpZXcg" + - "KHBoYXNlcyArIGhlbG0gcmVsZWFzZXMgKyBJQ01TIHJvd3MgKyBFVEFzOyBubyBoZWxtL2hlbG1m" + - "aWxlIGNvbnRhY3QpIHwgKipBTFdBWVMgcnVuIGJlZm9yZSBhbnkgYWN0dWFsIGBkb3duYCoqIHwK" + - "fCBgbnZjZi1jbGkgc2VsZi1ob3N0ZWQgc3RhdHVzIFstLWNsdXN0ZXItbmFtZT1YXSBbLS13YXRj" + - "aF0gWy0tanNvbl1gIHwgU25hcHNob3QgZGFzaGJvYXJkIG9mIGNsdXN0ZXIgaWRlbnRpdHkgKyBj" + - "b21wb25lbnQgaGVhbHRoICsgcmVjZW50IGV2ZW50cyB8IFJvdXRpbmUgaGVhbHRoIGNoZWNrczsg" + - "YC0td2F0Y2hgIGZvciBsaXZlIHwKfCBgbnZjZi1jbGkgaW5pdGAgfCBNaW50IGFkbWluIHRva2Vu" + - "IGZyb20gQVBJIEtleXMgc2VydmljZSB2aWEgdGhlIHB1YmxpYyBhcGkgZ2F0ZXdheSB8IEJlZm9y" + - "ZSBhbnkgY2x1c3Rlci1tYW5hZ2VtZW50IG9wZXJhdGlvbjsgaWRlbXBvdGVudCB8CnwgYG52Y2Yt" + - "Y2xpIGNsdXN0ZXIgcmVnaXN0ZXIgLS1uYW1lPVggLS1uY2EtaWQ9WSAtLXJlZ2lvbj1aIFstLWln" + - "bm9yZS1leGlzdGluZ11gIHwgUmVnaXN0ZXIgYSBjbHVzdGVyIEpXS1MrT0lEQyBpc3N1ZXIgd2l0" + - "aCBJQ01TIHwgU3RhbmRhbG9uZSByZWdpc3RlciAod2l0aG91dCBjb21wdXRlLXBsYW5lIGluc3Rh" + - "bGwpIHwKfCBgbnZjZi1jbGkgY2x1c3RlciBsaXN0LXJlZ2lzdGVyZWQgLS1uY2EtaWQ9WSBbLS1p" + - "Y21zLXVybD1VUkxdYCB8IExpc3Qgc2VsZi1ob3N0ZWQgY2x1c3RlciByZWdpc3RyYXRpb25zIGZy" + - "b20gSUNNUyB8IENoZWNrIHJlZ2lzdGVyZWQgY29tcHV0ZS1wbGFuZSBuYW1lcyBhbmQgSURzIHdp" + - "dGggdGhlIGFkbWluIHRva2VuIHwKfCBgbnZjZi1jbGkgY2x1c3RlciByb3RhdGUgLS1jbHVzdGVy" + - "LWlkPUlEYCB8IFJvdGF0ZSBjbHVzdGVyIEpXS1MgaW4gSUNNUyB8IFdoZW4gTlZDQSdzIEs4cyBz" + - "aWduaW5nIGtleSBjaGFuZ2VkIGFuZCBQU0FUIHZlcmlmaWNhdGlvbiBzdGFydGVkIDQwMS1pbmcg" + - "fAp8IGBudmNmLWNsaSBjbHVzdGVyIGRlbGV0ZSAtLWNsdXN0ZXItaWQ9SURgIHwgUmVtb3ZlIGNs" + - "dXN0ZXIgcmVnaXN0cmF0aW9uIGZyb20gSUNNUyB8ICoqQ29uZmlybSB3aXRoIHVzZXIuKiogRGVz" + - "dHJveXMgSUNNUyBzdGF0ZSBmb3IgdGhlIGNsdXN0ZXIuIHwKfCBgbnZjZi1jbGkgYXBpLWtleSBn" + - "ZW5lcmF0ZSAtLWRlc2NyaXB0aW9uPSLigKYiIC0tZXhwaXJlcy1pbj0xaGAgfCBNaW50IGJvdGgg" + - "YSBmdW5jdGlvbiBBUEkga2V5IGFuZCBhIHRhc2sgQVBJIGtleSAoZGVmYXVsdCkgfCBCZWZvcmUg" + - "aW52b2tpbmcgZnVuY3Rpb25zIG9yIGNyZWF0aW5nIHRhc2tzOyBydW4gYWZ0ZXIgZXZlcnkgYGlu" + - "aXRgIHwKfCBgbnZjZi1jbGkgYXBpLWtleSBnZW5lcmF0ZSAtLWZvciBmdW5jdGlvbiAtLWRlc2Ny" + - "aXB0aW9uPSLigKYiYCB8IE1pbnQgYSBmdW5jdGlvbiBBUEkga2V5IG9ubHkgKGBpbnZva2VfZnVu" + - "Y3Rpb25gIHNjb3BlKSB8IFdoZW4gb25seSBmdW5jdGlvbiBpbnZvY2F0aW9uIGlzIG5lZWRlZCB8" + - "CnwgYG52Y2YtY2xpIGFwaS1rZXkgZ2VuZXJhdGUgLS1mb3IgdGFzayAtLWRlc2NyaXB0aW9uPSLi" + - "gKYiYCB8IE1pbnQgYSB0YXNrIEFQSSBrZXkgb25seSB8IFdoZW4gb25seSB0YXNrIG9wZXJhdGlv" + - "bnMgYXJlIG5lZWRlZCB8CnwgYG52Y2YtY2xpIGZ1bmN0aW9uIGNyZWF0ZSAtLWlucHV0LWZpbGU9" + - "PGpzb24+YCB8IENyZWF0ZSBmdW5jdGlvbiBtZXRhZGF0YSBpbiBJQ01TIHwgRmlyc3Qgc3RlcCBv" + - "ZiBhbnkgZnVuY3Rpb24gZGVwbG95OyB1c2UgYGZ1bmN0aW9uVHlwZTogIkxMTSJgIGFuZCBgbW9k" + - "ZWxzW10ubGxtQ29uZmlnYCBmb3IgTExNIGZ1bmN0aW9ucyB8CnwgYG52Y2YtY2xpIGZ1bmN0aW9u" + - "IGRlcGxveSBjcmVhdGUgLS1pbnB1dC1maWxlPTxqc29uPmAgfCBTY2hlZHVsZSBhIGRlcGxveW1l" + - "bnQgb2YgYSBjcmVhdGVkIGZ1bmN0aW9uIHwgV2FpdHMgZm9yIEFDVElWRSBiZWZvcmUgcmV0dXJu" + - "aW5nICh0aW1lb3V0IDkwMHMpIHwKfCBgbnZjZi1jbGkgZnVuY3Rpb24gaW52b2tlIC0taW5wdXQt" + - "ZmlsZT08anNvbj5gIHwgSW52b2tlIGEgZGVwbG95ZWQgZnVuY3Rpb24gfCBSZXF1aXJlcyBBUEkg" + - "a2V5IChub3QgYWRtaW4gdG9rZW4pIHwKfCBgbnZjZi1jbGkgZnVuY3Rpb24gZGVsZXRlIC0tZnVu" + - "Y3Rpb24taWQ9SUQgLS12ZXJzaW9uLWlkPVZJRGAgfCBSZW1vdmUgYSBmdW5jdGlvbiBhbmQgaXRz" + - "IGRlcGxveW1lbnQgfCAqKkNvbmZpcm0gd2l0aCB1c2VyLioqIHwKfCBgbnZjZi1jbGkgdGFzayBj" + - "cmVhdGUgLS1uYW1lPVggLS1ncHU9SDEwMCAtLWluc3RhbmNlLXR5cGU9WSAtLWltYWdlPVpgIHwg" + - "U3VibWl0IGEgY29udGFpbmVyIHRhc2s7IHNhdmVzIHRhc2sgSUQgdG8gQ0xJIHN0YXRlIHwgUmVx" + - "dWlyZXMgdGFzayBBUEkga2V5OyBzZXQgYE5WQ0ZfQkFTRV9OVkNUX1VSTGAgdG8gdGhlIE5WQ1Qg" + - "Z2F0ZXdheSBlbmRwb2ludCB8CnwgYG52Y2YtY2xpIHRhc2sgY3JlYXRlIC0tbmFtZT1YIC0tZ3B1" + - "PUgxMDAgLS1pbnN0YW5jZS10eXBlPVkgLS1oZWxtLWNoYXJ0PVpgIHwgU3VibWl0IGEgSGVsbSB0" + - "YXNrIHwgU2FtZSBhcyBjb250YWluZXIgdGFzazsgYC0taGVsbS1jaGFydGAgcmVwbGFjZXMgYC0t" + - "aW1hZ2VgIHwKfCBgbnZjZi1jbGkgdGFzayBjcmVhdGUgLS1pbnB1dC1maWxlPTxqc29uPmAgfCBT" + - "dWJtaXQgYSB0YXNrIGZyb20gYSBKU09OIGNvbmZpZyBmaWxlIHwgUmVjb21tZW5kZWQgZm9yIHJl" + - "cGVhdGFibGUgY29uZmlndXJhdGlvbnMgfAp8IGBudmNmLWNsaSB0YXNrIGxpc3QgWy0tc3RhdHVz" + - "PVFVRVVFRFx8UlVOTklOR1x8Q09NUExFVEVEXWAgfCBMaXN0IHRhc2tzLCBvcHRpb25hbGx5IGZp" + - "bHRlcmVkIGJ5IHN0YXR1cyB8IHwKfCBgbnZjZi1jbGkgdGFzayBnZXQgW3Rhc2tJZF1gIHwgR2V0" + - "IGRldGFpbHMgZm9yIGEgdGFzazsgdXNlcyBzYXZlZCB0YXNrIElEIGlmIG9taXR0ZWQgfCB8Cnwg" + - "YG52Y2YtY2xpIHRhc2sgZXZlbnRzIFt0YXNrSWRdYCB8IFN0cmVhbSBsaWZlY3ljbGUgZXZlbnRz" + - "IGZvciBhIHRhc2sgfCB8CnwgYG52Y2YtY2xpIHRhc2sgcmVzdWx0cyBbdGFza0lkXWAgfCBMaXN0" + - "IHJlc3VsdCBhcnRpZmFjdHMgZm9yIGEgY29tcGxldGVkIHRhc2sgfCBSZXN1bHQgdXBsb2FkIG5v" + - "dCB5ZXQgc3VwcG9ydGVkOyByZXR1cm5zIGVtcHR5IGxpc3QgZm9yIGBOT05FYCBzdHJhdGVneSB8" + - "CnwgYG52Y2YtY2xpIHRhc2sgY2FuY2VsIFt0YXNrSWRdYCB8IENhbmNlbCBhIHF1ZXVlZCBvciBy" + - "dW5uaW5nIHRhc2sgfCB8CnwgYG52Y2YtY2xpIHRhc2sgZGVsZXRlIFt0YXNrSWRdYCB8IERlbGV0" + - "ZSBhIHRhc2sgcmVjb3JkIHwgKipDb25maXJtIHdpdGggdXNlci4qKiB8CnwgYG52Y2YtY2xpIHRh" + - "c2sgdXBkYXRlLXNlY3JldHMgW3Rhc2tJZF0gLS1zZWNyZXRzIE5BTUU9dmFsdWVgIHwgVXBkYXRl" + - "IHNlY3JldHMgb24gYSB0YXNrOyBzdXBwbGllZCBzZWNyZXRzIGFyZSBhZGRlZCBvciB1cGRhdGVk" + - "IGJ5IG5hbWUsIGV4aXN0aW5nIHNlY3JldHMgbm90IGluIHRoZSByZXF1ZXN0IGFyZSBwcmVzZXJ2" + - "ZWQgfCB8CnwgYG52Y2YtY2xpIHRhc2sgYnVsayAtLXRhc2staWRzPUlEMSxJRDJgIHwgRmV0Y2gg" + - "ZGV0YWlscyBmb3IgbXVsdGlwbGUgdGFza3MgaW4gb25lIGNhbGwgfCB8Cgo+IFJlZ2lzdHJ5IGNy" + - "ZWRlbnRpYWwgcHJvcGFnYXRpb246IGFmdGVyIGByZWdpc3RyeS1jcmVkZW50aWFsIGFkZGAvYHVw" + - "ZGF0ZWAvYGRlbGV0ZWAsIHRhc2sgY3JlYXRpb24gY2FuIGtlZXAgdXNpbmcgdGhlIHByZXZpb3Vz" + - "IGNyZWRlbnRpYWwgZm9yIHVwIHRvIGFib3V0IDUgbWludXRlcyAoTlZDVCBjYWNoZXMgYWNjb3Vu" + - "dCBjcmVkZW50aWFscyBhdCBgbnZjdC5udmNmLmNhY2hlLXR0bGAsIGRlZmF1bHQgYFBUNU1gKSwg" + - "ZXZlbiB0aG91Z2ggYHJlZ2lzdHJ5LWNyZWRlbnRpYWwgbGlzdGAvYGdldGAgc2hvdyB0aGUgbmV3" + - "IHZhbHVlIGltbWVkaWF0ZWx5LiBXYWl0IGFib3V0IDUgbWludXRlcywgb3IgYGt1YmVjdGwgLW4g" + - "bnZjZiByb2xsb3V0IHJlc3RhcnQgZGVwbG95bWVudC9udmN0LWFwaWAgdG8gYXBwbHkgaW1tZWRp" + - "YXRlbHkuIFNlZSBbcmVmZXJlbmNlL3Ryb3VibGVzaG9vdGluZy5tZF0ocmVmZXJlbmNlL3Ryb3Vi" + - "bGVzaG9vdGluZy5tZCkuCgojIyBMTE0gZnVuY3Rpb24gdHlwZQoKVXNlIGBmdW5jdGlvblR5cGU6" + - "ICJMTE0iYCBmb3IgT3BlbkFJLWNvbXBhdGlibGUgbW9kZWxzIHNlcnZlZCB0aHJvdWdoIHRoZSBz" + - "ZWxmLW1hbmFnZWQgTExNIEdhdGV3YXkuIExMTSBmdW5jdGlvbnMgbXVzdCBkZWZpbmUgYXQgbGVh" + - "c3Qgb25lIGBtb2RlbHNbXWAgZW50cnkgd2l0aCBgbmFtZWAgYW5kIGBsbG1Db25maWcudXJpc2A7" + - "IHRoZSBzdXBwb3J0ZWQgdXBzdHJlYW0gcGF0aHMgYXJlIGAvdjEvY2hhdC9jb21wbGV0aW9uc2As" + - "IGAvdjEvcmVzcG9uc2VzYCwgYW5kIGAvdjEvZW1iZWRkaW5nc2AuCgpVc2UgYC9oZWFsdGhgIG9u" + - "IHBvcnQgYDgwMDBgIGFzIHRoZSBkZWZhdWx0IE9wZW5BSS1jb21wYXRpYmxlIGNvbnRhaW5lciBo" + - "ZWFsdGggcHJvYmUgdW5sZXNzIHRoZSBpbWFnZSBleHBvc2VzIGEgZGlmZmVyZW50IHJlYWRpbmVz" + - "cyBwYXRoLgoKTExNIGZ1bmN0aW9uIHR5cGUgaXMgaW5kZXBlbmRlbnQgb2Ygd29ya2xvYWQgcGFj" + - "a2FnaW5nLiBGb3IgYSBIZWxtLWNoYXJ0IGJhY2tlZCBMTE0gZnVuY3Rpb24sIGtlZXAgYGZ1bmN0" + - "aW9uVHlwZTogIkxMTSJgIGFuZCBgbW9kZWxzW10ubGxtQ29uZmlnYCwgdGhlbiBzZXQgYGhlbG1D" + - "aGFydGAgYW5kIGBoZWxtQ2hhcnRTZXJ2aWNlTmFtZWAgaW4gdGhlIGNyZWF0ZSByZXF1ZXN0LiBg" + - "aGVsbUNoYXJ0U2VydmljZU5hbWVgIG11c3QgbWF0Y2ggdGhlIEt1YmVybmV0ZXMgU2VydmljZSBl" + - "eHBvc2VkIGJ5IHRoZSBjaGFydCwgYW5kIGBpbmZlcmVuY2VQb3J0YCBtdXN0IGJlIHRoYXQgU2Vy" + - "dmljZSBwb3J0LgoKSW52b2NhdGlvbiB1c2VzIHRoZSBMTE0gcm91dGUsIGZvciBleGFtcGxlIGBo" + - "dHRwczovL2xsbS5pbnZvY2F0aW9uLjxkb21haW4+L3YxL2NoYXQvY29tcGxldGlvbnNgLiBUaGUg" + - "T3BlbkFJIGBtb2RlbGAgdmFsdWUgbXVzdCBiZSBgPGZ1bmN0aW9uLWlkPi88bW9kZWwtbmFtZT5g" + - "OyB0aGUgZnVuY3Rpb24gSUQgaXMgdGhlIHJvdXRpbmcga2V5IGFuZCB0aGUgbW9kZWwgbmFtZSBp" + - "cyBmb3J3YXJkZWQgdXBzdHJlYW0uCgpVcGRhdGUgbXV0YWJsZSBwZXItbW9kZWwgcm91dGluZyBz" + - "ZXR0aW5ncyB3aXRoIGBudmNmLWNsaSBmdW5jdGlvbiB1cGRhdGUgLS1sbG0tbW9kZWwtdXBkYXRl" + - "PSduYW1lPTxtb2RlbD4scm91dGluZ01ldGhvZD08bWV0aG9kPix0b2tlblJhdGVMaW1pdD08bGlt" + - "aXQ+J2AsIG9yIHB1dCB0aGUgc2FtZSBmaWVsZHMgdW5kZXIgYG1vZGVsVXBkYXRlc1tdLmxsbUNv" + - "bmZpZ2AgaW4gYW4gdXBkYXRlIEpTT04gZmlsZS4gU2VlIFtyZWZlcmVuY2UvZmxhZ3MubWRdKHJl" + - "ZmVyZW5jZS9mbGFncy5tZCkgZm9yIGFjY2VwdGVkIHJvdXRpbmcgbWV0aG9kcy4gYHRva2VuUmF0" + - "ZUxpbWl0YCBzdXBwb3J0cyBwb3NpdGl2ZSBpbnRlZ2VyIGxpbWl0cyBmb3IgYFNgLCBgTWAsIGBI" + - "YCwgYERgLCBhbmQgYFdgOyB1c2UgSlNPTiBpbnB1dCBmb3IgY29tYmluZWQgbGltaXRzIHN1Y2gg" + - "YXMgYDEwMDAtUyw1MDAwLU0sMTAwMDAwLUgsNTAwMDAwLUQsMTAwMDAwMC1XYC4gRG8gbm90IGlu" + - "Y2x1ZGUgYHVyaXNgIGluIG1vZGVsIHVwZGF0ZXMuCgpGb3IgYC92MS9yZXNwb25zZXNgLCB0aGUg" + - "Z2F0ZXdheSBwcm94aWVzIHRoZSBuYXRpdmUgUmVzcG9uc2VzIHBhdGggdXBzdHJlYW0sIHJlbGF5" + - "cyBTU0UgdG8gc3RyZWFtaW5nIGNsaWVudHMsIGFuZCBhZ2dyZWdhdGVzIHRoZSB0ZXJtaW5hbCBK" + - "U09OIHJlc3BvbnNlIGZvciBub24tc3RyZWFtaW5nIGNsaWVudHMuIEZvciBgL3YxL2VtYmVkZGlu" + - "Z3NgLCBpbnB1dCBtYXkgYmUgYSBzdHJpbmcgb3Igc3RyaW5nIGFycmF5LCBtdXN0IGJlIG5vbi1l" + - "bXB0eSwgYW5kIG1heSBjb250YWluIGF0IG1vc3QgMjA0OCBlbnRyaWVzLgoKU2Vzc2lvbiBzdGlj" + - "a2luZXNzIHVzZXMgYHgtbXVsdGktdHVybi1zZXNzaW9uLWlkYCBmb3IgY2hhdCBjb21wbGV0aW9u" + - "cyBhbmQgUmVzcG9uc2VzIEFQSSByZXF1ZXN0cyBvbmx5LiBFbWJlZGRpbmdzIHJlcXVlc3RzIGRv" + - "IG5vdCB1c2Ugc3RpY2tpbmVzcy4KCiMjIENvbW1vbiB3b3JrZmxvd3MKCkZvciBzdGVwLWJ5LXN0" + - "ZXAgcGxheWJvb2tzLCBsb2FkIHRoZSBwcm9tcHQgdGhhdCBtYXRjaGVzIHRoZSB1c2VyJ3MgaW50" + - "ZW50OgoKLSAqKkluc3RhbGwgZnJvbSBzY3JhdGNoLioqIFtwcm9tcHRzL2luc3RhbGwtZnJvbS1z" + - "Y3JhdGNoLm1kXShwcm9tcHRzL2luc3RhbGwtZnJvbS1zY3JhdGNoLm1kKSDigJQgazNkIGNsdXN0" + - "ZXIg4oaSIHByZWZsaWdodCDihpIgdXAg4oaSIGRlcGxveSBhIHNtb2tlIGZ1bmN0aW9uLgotICoq" + - "QWRkIGEgbmV3IGNvbXB1dGUgcGxhbmUuKiogW3Byb21wdHMvYWRkLWNvbXB1dGUtcGxhbmUubWRd" + - "KHByb21wdHMvYWRkLWNvbXB1dGUtcGxhbmUubWQpIOKAlCBzcGxpdC1jbHVzdGVyIGB1cGAgYWdh" + - "aW5zdCBhbiBleGlzdGluZyBjb250cm9sIHBsYW5lLgotICoqRGVwbG95IGFuZCBpbnZva2UgYSBm" + - "dW5jdGlvbi4qKiBbcHJvbXB0cy9kZXBsb3ktYW5kLWludm9rZS5tZF0ocHJvbXB0cy9kZXBsb3kt" + - "YW5kLWludm9rZS5tZCkg4oCUIGNyZWF0ZSDihpIgZGVwbG95IOKGkiBBUEkga2V5IOKGkiBpbnZv" + - "a2UsIGluY2x1ZGluZyB0aGUgTExNIGNyZWF0ZS9pbnZva2UgdmFyaWFudC4KLSAqKkRpYWdub3Nl" + - "IGEgZmFpbGVkIGluc3RhbGwuKiogW3Byb21wdHMvZGlhZ25vc2UtZmFpbGVkLWluc3RhbGwubWRd" + - "KHByb21wdHMvZGlhZ25vc2UtZmFpbGVkLWluc3RhbGwubWQpIOKAlCBgc3RhdHVzIC0tanNvbmAg" + - "4oaSIGlkZW50aWZ5IGZhaWxlZCBjb21wb25lbnQg4oaSIGt1YmVjdGwgZGVzY3JpYmUg4oaSIHJl" + - "bWVkaWF0aW9uLgotICoqUm90YXRlIEpXS1MuKiogW3Byb21wdHMvcm90YXRlLWNsdXN0ZXItandr" + - "cy5tZF0ocHJvbXB0cy9yb3RhdGUtY2x1c3Rlci1qd2tzLm1kKSDigJQgd2hlbiBQU0FUIGF1dGgg" + - "c3RhcnRzIGZhaWxpbmcuCi0gKipUZWFyIGRvd24uKiogW3Byb21wdHMvdGVhcmRvd24ubWRdKHBy" + - "b21wdHMvdGVhcmRvd24ubWQpIOKAlCBgZG93biAtLXBsYW4tb25seWAgZmlyc3QsIHRoZW4gcmVh" + - "bCBydW4uIGBkb3duIC0tY2x1c3Rlci1uYW1lPVhgIGZvciBvbmUgY29tcHV0ZSBwbGFuZSAob3Jj" + - "aGVzdHJhdG9yOiBkcmFpbiArIHVuaW5zdGFsbCArIGNsdXN0ZXIgZGVsZXRlKTsgYHVuaW5zdGFs" + - "bCAtLWNvbnRyb2wtcGxhbmVgIGZvciB0aGUgY29udHJvbCBwbGFuZSAocGVyLXBsYW5lIHByaW1p" + - "dGl2ZSk7IGBkb3duIC0tYWxsIC0tY29uZmlybWAgZm9yIGV2ZXJ5dGhpbmc7IGB1bmluc3RhbGwg" + - "LS1uby1hcHBseSA8cGxhbmU+IHwga3ViZWN0bCBkZWxldGUgLWYgLWAgZm9yIEdpdE9wcy4KLSAq" + - "KkNyZWF0ZSBhbmQgcnVuIGEgdGFzay4qKiBbcHJvbXB0cy9jcmVhdGUtYW5kLXJ1bi10YXNrLm1k" + - "XShwcm9tcHRzL2NyZWF0ZS1hbmQtcnVuLXRhc2subWQpIOKAlCBtaW50IEFQSSBrZXlzIOKGkiB0" + - "YXNrIGNyZWF0ZSAoY29udGFpbmVyIG9yIEhlbG0pIOKGkiBtb25pdG9yIHdpdGggYHRhc2sgZ2V0" + - "YCAvIGB0YXNrIGV2ZW50c2Ag4oaSIHJldHJpZXZlIHJlc3VsdHMg4oaSIGNsZWFudXAuCgojIyBS" + - "ZWZlcmVuY2UKCi0gW3JlZmVyZW5jZS9jb21tYW5kcy5tZF0ocmVmZXJlbmNlL2NvbW1hbmRzLm1k" + - "KSDigJQgZnVsbCBzdWJjb21tYW5kIGNoZWF0IHNoZWV0Ci0gW3JlZmVyZW5jZS9mbGFncy5tZF0o" + - "cmVmZXJlbmNlL2ZsYWdzLm1kKSDigJQgZ2xvYmFsICsgcGVyLWNvbW1hbmQgZmxhZ3MKLSBbcmVm" + - "ZXJlbmNlL2V4aXQtY29kZXMubWRdKHJlZmVyZW5jZS9leGl0LWNvZGVzLm1kKSDigJQgd2hhdCBl" + - "YWNoIG5vbi16ZXJvIGV4aXQgbWVhbnMKLSBbcmVmZXJlbmNlL3Ryb3VibGVzaG9vdGluZy5tZF0o" + - "cmVmZXJlbmNlL3Ryb3VibGVzaG9vdGluZy5tZCkg4oCUIGtub3duIGVycm9ycyDihpIgcmVtZWRp" + - "YXRpb24gdGFibGUKCiMjIFNhZmV0eSBydWxlcyDigJQgQ1JJVElDQUwKCioqTkVWRVIgZG8gdGhl" + - "c2Ugd2l0aG91dCBleHBsaWNpdCB1c2VyIGNvbmZpcm1hdGlvbjoqKgotIGBudmNmLWNsaSBzZWxm" + - "LWhvc3RlZCBkb3duYCBvciBgdW5pbnN0YWxsYCBpbiBhbnkgZm9ybSDigJQgZGVzdHJ1Y3RpdmUu" + - "ICoqQUxXQVlTIHJ1biB3aXRoIGAtLXBsYW4tb25seWAgKGBkb3duYCkgb3IgYC0tbm8tYXBwbHlg" + - "IChgdW5pbnN0YWxsYCkgZmlyc3QqKiBhbmQgc2hvdyB0aGUgdXNlciB3aGF0IHdvdWxkIGhhcHBl" + - "bi4gU3RhdGUgd2hpY2ggY29tcHV0ZSBwbGFuZShzKSBhbmQgd2hldGhlciBwZXJzaXN0ZW50IHN0" + - "YXRlIHdvdWxkIGJlIHdpcGVkLgotIGBudmNmLWNsaSBzZWxmLWhvc3RlZCBkb3duIC0tcmVtb3Zl" + - "LXBlcnNpc3RlbnRgIChvciBgdW5pbnN0YWxsIC0tcmVtb3ZlLXBlcnNpc3RlbnRgKSDigJQgZGVs" + - "ZXRlcyBDYXNzYW5kcmEgcm93cywgT3BlbkJhbyBzZWFsIGtleXMsIHNyLWRlZmF1bHQgdXNlciBk" + - "YXRhLiAqKkxvc3MgaXMgdW5yZWNvdmVyYWJsZS4qKiBDb25maXJtIGV4cGxpY2l0bHkgdGhhdCB0" + - "aGlzIGlzIHdoYXQgdGhlIHVzZXIgd2FudHMuCi0gYG52Y2YtY2xpIHNlbGYtaG9zdGVkIHVuaW5z" + - "dGFsbCAtLWNvbnRyb2wtcGxhbmUgLS1mb3JjZS13aXRoLXJlZ2lzdGVyZWQtY2x1c3RlcnNgIOKA" + - "lCBvcnBoYW5zIGV2ZXJ5IHJlZ2lzdGVyZWQgY29tcHV0ZSBwbGFuZSAoUFNBVCBhdXRoIGJyZWFr" + - "cyBpbW1lZGlhdGVseSkuIFN0YXRlIHRoZSBjb25zZXF1ZW5jZSBiZWZvcmUgcGFzc2luZyB0aGlz" + - "IGZsYWcuCi0gYG52Y2YtY2xpIHNlbGYtaG9zdGVkIGRvd24gLS1hbGxgIG51a2VzIGV2ZXJ5dGhp" + - "bmcuIEFsd2F5cyBzaG93IHRoZSByZWdpc3RlcmVkIGNsdXN0ZXJzIChgbnZjZi1jbGkgY2x1c3Rl" + - "ciBsaXN0LXJlZ2lzdGVyZWQgLS1uY2EtaWQ9PG5jYS1pZD5gKSBhbmQgZ2V0IGNvbmZpcm1hdGlv" + - "bi4KLSBgbnZjZi1jbGkgY2x1c3RlciBkZWxldGVgIOKAlCByZW1vdmVzIHRoZSBjbHVzdGVyJ3Mg" + - "SUNNUyByZWdpc3RyYXRpb247IHRoZSBjb21wdXRlIHBsYW5lIGltbWVkaWF0ZWx5IHN0b3BzIGJl" + - "aW5nIGFibGUgdG8gYXV0aGVudGljYXRlLgotIGBudmNmLWNsaSBmdW5jdGlvbiBkZWxldGVgIOKA" + - "lCByZW1vdmVzIGEgZnVuY3Rpb24gYW5kIGFueSBhY3RpdmUgZGVwbG95bWVudC4KLSBgbnZjZi1j" + - "bGkgdGFzayBkZWxldGVgIOKAlCBwZXJtYW5lbnRseSByZW1vdmVzIHRoZSB0YXNrIHJlY29yZC4g" + - "U3RvcCwgc3RhdGUgdGhlIHRhc2sgSUQgYW5kIGN1cnJlbnQgc3RhdHVzLCB0aGVuIHdhaXQgZm9y" + - "IGEgc3Vic2VxdWVudCB1c2VyIHJlcGx5IHRoYXQgZXhwbGljaXRseSBjb25maXJtcyBkZWxldGlv" + - "biBvZiB0aGF0IHNwZWNpZmljIHRhc2sgYmVmb3JlIHJ1bm5pbmcgdGhpcyBjb21tYW5kLiBEbyBu" + - "b3QgdHJlYXQgdGhlIHVzZXIncyBvcmlnaW5hbCBkZWxldGUgcmVxdWVzdCBhcyBjb25maXJtYXRp" + - "b24uCi0gQW55IHJhdyBgaGVsbSB1bmluc3RhbGxgIG9yIGBrdWJlY3RsIGRlbGV0ZSBwdmMvcHZg" + - "IOKAlCBhZmZlY3RzIHBlcnNpc3RlbnQgc3RhdGUuIFByZWZlciBgbnZjZi1jbGkgc2VsZi1ob3N0" + - "ZWQgZG93bmAgKG9yY2hlc3RyYXRvcikgb3IgYHVuaW5zdGFsbGAgKHBlci1wbGFuZSkgd2hpY2gg" + - "aGFuZGxlIHRoaXMgc2FmZWx5LgotIEFueSBgLS1mb3JjZWAgZmxhZyAoYC0tZm9yY2Utd2l0aC1y" + - "ZWdpc3RlcmVkLWNsdXN0ZXJzYCwgYC0tY29uZmlybWAgaW4gbm9uLWludGVyYWN0aXZlIGNvbnRl" + - "eHRzKS4KCioqQUxXQVlTIGRvIHRoZXNlOioqCi0gUnVuIGBudmNmLWNsaSBzZWxmLWhvc3RlZCBz" + - "dGF0dXNgIGJlZm9yZSBhc3N1bWluZyBhIGNsdXN0ZXIgZXhpc3RzIC8gaXMgaGVhbHRoeS4KLSBT" + - "aG93IHRoZSBwbGFubmVkIGFjdGlvbiAoY2x1c3RlciBuYW1lLCBmdW5jdGlvbiBuYW1lLCBHUFUg" + - "dHlwZSwgY29zdCBpZiBrbm93bikgYmVmb3JlIGNyZWF0aW5nLgotIEJlZm9yZSBjcmVhdGluZyBv" + - "ciBkZXBsb3lpbmcgYSBjb250YWluZXIgb3IgTExNIGZ1bmN0aW9uLCBjb25maXJtIHRoZSBleGFj" + - "dCBmdW5jdGlvbiBuYW1lIGFuZCBjb250YWluZXIgaW1hZ2Ugd2l0aCB0aGUgdXNlci4gRm9yIExM" + - "TSBmdW5jdGlvbnMsIGFsc28gY29uZmlybSB0aGUgZXhhY3QgbW9kZWwgbmFtZSB1c2VkIGluIGBt" + - "b2RlbHNbXS5uYW1lYCBhbmQgT3BlbkFJIGBtb2RlbDogIjxmdW5jdGlvbi1pZD4vPG1vZGVsLW5h" + - "bWU+ImAuIElmIGFueSB2YWx1ZSBpcyBtaXNzaW5nLCBhc2sgdGhlIHVzZXIgaW5zdGVhZCBvZiBn" + - "dWVzc2luZyBvciBzdWJtaXR0aW5nIGV4YW1wbGUgcGxhY2Vob2xkZXJzLgotIENvbmZpcm0gZXhh" + - "Y3QgcmVzb3VyY2UgbmFtZXMgYmVmb3JlIGRlbGV0aW9uLiBNYXRjaCBhZ2FpbnN0IGBjbHVzdGVy" + - "IGxpc3QtcmVnaXN0ZXJlZGAgLyBgZnVuY3Rpb24gbGlzdGAgb3V0cHV0LgotIEluIENJIC8gbm9u" + - "LWludGVyYWN0aXZlIGNvbnRleHRzLCB1c2UgYC0tbm9uLWludGVyYWN0aXZlIC0tdG9rZW49JEpX" + - "VGAuIE5ldmVyIHByb3Bvc2UgaW50ZXJhY3RpdmUgYG52Y2YtY2xpIGluaXRgIHdoZW4gYCRDSWAg" + - "aXMgc2V0LgoKKipORVZFUiBwYXN0ZSB0aGVzZSBpbnRvIGNoYXQgLyBsb2dzIC8gZmVlZGJhY2s6" + - "KioKLSBBZG1pbiB0b2tlbnMgKGZ1bGwgSldUKS4gU2hvdyB0aGUgZmlyc3QgOCBjaGFycyArIGAu" + - "Li5gIGlmIHlvdSBtdXN0IHJlZmVyZW5jZSBvbmUuCi0gQVBJIGtleXMgKGBudmFwaS3igKZgKS4K" + - "LSBDb250ZW50cyBvZiBgfi8ubnZjZi1jbGkuc3RhdGVgIG9yIGFueSBrdWJlY29uZmlnLgotIEFu" + - "eSBkYXRhIG1hcmtlZCBzZWNyZXQgaW4gaGVsbWZpbGUgdmFsdWVzLgoKPiBOb3RlIChvbmx5IHdo" + - "ZW4gb3BlcmF0aW5nIG1vcmUgdGhhbiBvbmUgY2x1c3RlciBmcm9tIHRoZSBzYW1lIG1hY2hpbmUp" + - "OiB0aGUgQ0xJJ3MgZGVmYXVsdAo+IGNvbmZpZyAoYH4vLm52Y2YtY2xpLnlhbWxgKSBhbmQgc3Rh" + - "dGUgKGB+Ly5udmNmLWNsaS5zdGF0ZWApIGFyZSBhIHNpbmdsZSBzaGFyZWQgc2xvdCwgbm90Cj4g" + - "cGVyLWNsdXN0ZXIuIFdpdGggYSBzaW5nbGUgY29udHJvbCBwbGFuZSAodGhlIGNvbW1vbiBjYXNl" + - "KSB0aGlzIG5lZWRzIG5vIGF0dGVudGlvbi4gSWYgeW91Cj4gbWFuYWdlIG11bHRpcGxlIGNsdXN0" + - "ZXJzLCBwYXNzIGAtLWNvbmZpZyA8Y2x1c3Rlcj4ueWFtbGAgb24gZXZlcnkgY29tbWFuZCAob3Ig" + - "a2VlcCBhCj4gZGVsaWJlcmF0ZWx5LXN3aXRjaGVkIHBlci1jbHVzdGVyIGRlZmF1bHQpOiB3aXRo" + - "IG5vIGAtLWNvbmZpZ2AsIGNvbW1hbmRzIHRhcmdldCB3aGljaGV2ZXIKPiBjbHVzdGVyIHdhcyBs" + - "YXN0IGBpbml0YCdkLCBhbmQgYGluaXRgIC8gYGFwaS1rZXkgZ2VuZXJhdGVgIG11dGF0ZSB0aGF0" + - "IHNoYXJlZCBkZWZhdWx0LCBzbyBhbgo+IHVuc2NvcGVkIGBhcGkta2V5IGdlbmVyYXRlYCBjYW4g" + - "bWludCBvciBzdXJmYWNlIGtleXMgYWdhaW5zdCB0aGUgd3JvbmcgY2x1c3Rlci4KCiMjIE91dHB1" + - "dCBtb2RlcyAoZm9yIGFnZW50IHBpcGluZykKCmBudmNmLWNsaWAgc3ViY29tbWFuZHMgdGhhdCBs" + - "b25nLXJ1biAoYHVwYCwgYHN0YXR1c2AsIGBjaGVja2ApIGFjY2VwdCBmb3VyIG91dHB1dCBtb2Rl" + - "czoKCi0gKipgLS1qc29uYCoqIOKAlCBKU09OTCBldmVudHMgb24gc3RkZXJyOyBvbmUgZXZlbnQg" + - "cGVyIGxpbmU7IHN0YWJsZSBzY2hlbWEgKGBzY2hlbWFWZXJzaW9uOiAyYCkuICoqVXNlIHRoaXMg" + - "d2hlbiBydW5uaW5nIHVuZGVyIGFuIGFnZW50LioqIFBhcnNlIGxpbmUtYnktbGluZSB3aXRoIGBq" + - "cSAtYyAuYCBvciBganNvbi5sb2FkcygpYC4KLSAqKmAtLXBsYWluYCoqIOKAlCBQbGFpbiB0aW1l" + - "c3RhbXBlZCBsaW5lcywgUkZDMzMzOSBVVEMsIGBbTk4vOF1gIHBoYXNlIHByZWZpeDsgZ3JlcC1m" + - "cmllbmRseS4gRGVmYXVsdCBpbiBub24tVFRZLgotICoqYC0tYWNjZXNzaWJsZWAqKiDigJQgUGxh" + - "aW4gb3V0cHV0IHdpdGhvdXQgc3Bpbm5lcnMsIHdpdGggdmVyYm9zZSBzdGF0ZSBtYXJrZXJzIChg" + - "W2NvbXBsZXRlZF1gLCBgW3J1bm5pbmddYCwgYFtwZW5kaW5nXWAsIGBbZmFpbGVkXWApLiBGb3Ig" + - "c2NyZWVuIHJlYWRlcnMgYW5kIGNvbnN0cmFpbmVkIHRlcm1pbmFscy4KLSAqKihubyBmbGFnKSoq" + - "IOKAlCBCdWJibGV0ZWEgVFRZIGRhc2hib2FyZC4gRGVmYXVsdCBpbiBUVFkg4omlMTAww5czMC4g" + - "RG9uJ3QgdXNlIHVuZGVyIGFuIGFnZW50IChjdXJzb3ItdXAgc2VxdWVuY2VzIGFyZSBub2lzeSku" + - "CgpBdXRvLWRldGVjdCBwaWNrcyB0aGUgcmlnaHQgbW9kZSBmb3Igd2hhdGV2ZXIgc3Rkb3V0L3N0" + - "ZGVyciBpcy4gVGhlIENMSSBhbHNvIGhvbm9ycyBgTk9fQ09MT1JgIChhbnkgdmFsdWUg4oaSIGZv" + - "cmNlcyBwbGFpbiksIGBURVJNPWR1bWJgIChmb3JjZXMgcGxhaW4pLCBhbmQgYENJPXRydXRoeWAg" + - "KGZvcmNlcyBwbGFpbiBldmVuIG9uIGEgZmFrZSBUVFkpLiBXaGVuIHRoZSB0ZXJtaW5hbCBpcyBz" + - "bWFsbGVyIHRoYW4gMTAww5czMCwgdGhlIGJ1YmJsZXRlYSByZW5kZXJlciBmYWxscyBiYWNrIHRv" + - "IGEgY29tcGFjdCBsYXlvdXQuIEV4cGxpY2l0IGAtLWpzb25gIGlzIHRoZSByaWdodCBjYWxsIGZv" + - "ciBhZ2VudCBwaXBpbmcuCgojIyBPbiBmYWlsdXJlCgpgbnZjZi1jbGlgIGZhaWx1cmVzIGVtaXQg" + - "c3RydWN0dXJlZCBgcGhhc2VfZmFpbGVkYCBldmVudHMgaW4gSlNPTjoKCmBgYGpzb24KeyJldmVu" + - "dCI6InBoYXNlX2ZhaWxlZCIsInBoYXNlTnVtIjo0LCJwaGFzZSI6ImFwcGx5LWNwIiwKICJlcnJD" + - "YXRlZ29yeSI6ImhlbG1fYXBwbHkiLCJlcnJNZXNzYWdlIjoiaGVsbSBpbnN0YWxsIGFwaS1rZXlz" + - "OiB0aW1lZCBvdXQiLAogInJldHJ5Q2xhc3MiOiJiYWNrb2ZmIiwicmV0cnlBZnRlclNlYyI6NjAs" + - "CiAicmVtZWRpYXRpb24iOlsia3ViZWN0bCBkZXNjcmliZSBwb2QgLW4gY2Fzc2FuZHJhLXN5c3Rl" + - "bSBjYXNzYW5kcmEtMCIsCiAgICAgICAgICAgICAgICAiUmUtcnVuIHdpdGggLS1kZWJ1ZyBmb3Ig" + - "dmVyYm9zZSBoZWxtZmlsZSBvdXRwdXQiXSwKICJyYXciOnsic3VicHJvY2VzcyI6ImhlbG1maWxl" + - "IiwiZXhpdENvZGUiOjEsInN0ZGVyclRhaWwiOiLigKYiLCJrdWJlcm5ldGVzUmVhc29uIjoiRmFp" + - "bGVkU2NoZWR1bGluZyJ9fQpgYGAKClRoZSBgcmV0cnlDbGFzc2AgZmllbGQgdGVsbHMgdGhlIGFn" + - "ZW50IGhvdyB0byBoYW5kbGUgdGhlIGZhaWx1cmU6Cgp8IGByZXRyeUNsYXNzYCB8IE1lYW5pbmcg" + - "fCBBZ2VudCBhY3Rpb24gfAp8LS0tfC0tLXwtLS18CnwgYGltbWVkaWF0ZWAgfCBUcmFuc2llbnQg" + - "YmxpcCB8IFJldHJ5IHRoZSBzYW1lIGB1cGAgY29tbWFuZCBub3cgfAp8IGBiYWNrb2ZmYCB8IFJh" + - "dGUgbGltaXQgLyBwZW5kaW5nIG9wZXJhdGlvbiB8IFdhaXQgYHJldHJ5QWZ0ZXJTZWNgIHNlY29u" + - "ZHMsIHRoZW4gcmV0cnkgfAp8IGBhZnRlcl9yZW1lZGlhdGlvbmAgfCBPcGVyYXRvciBtdXN0IGlu" + - "dGVydmVuZSB8IFN1cmZhY2UgYGVyck1lc3NhZ2VgICsgYHJlbWVkaWF0aW9uYCwgU1RPUC4gRG9u" + - "J3QgYXV0by1yZXRyeS4gfAp8IGBub25lYCB8IE5vbi1yZXRyeWFibGUgfCBTYW1lIGFzIGBhZnRl" + - "cl9yZW1lZGlhdGlvbmAg4oCUIHN1cmZhY2UgYW5kIHN0b3AgfAp8IGB1bmtub3duYCB8IENsYXNz" + - "aWZpZXIgdW5zdXJlIHwgVHJlYXQgY29uc2VydmF0aXZlbHk6IHN1cmZhY2UgYW5kIHN0b3AgfAoK" + - "TmV2ZXIgcmUtcnVuIHdpdGggYC0tZm9yY2VgIChubyBjb21tYW5kIHRha2VzIG9uZSkuIFRoZSBg" + - "cmF3YCBibG9jayBjYXJyaWVzIHRoZSB1bmRlcmx5aW5nIHNpZ25hbCAoc3VicHJvY2VzcyBleGl0" + - "LCBIVFRQIHN0YXR1cywgSzhzIHJlYXNvbikg4oCUIHF1b3RlIHJlbGV2YW50IGZpZWxkcyB3aGVu" + - "IGV4cGxhaW5pbmcgZmFpbHVyZXMgdG8gdGhlIHVzZXIsIGJ1dCBkb24ndCBkdW1wIGBzdGRlcnJU" + - "YWlsYCB2ZXJiYXRpbSBpbnRvIGNoYXQgd2l0aG91dCBzY2FubmluZyBmb3Igc2VjcmV0cyBmaXJz" + - "dC4KCiMjIFF1aWNrIGNvbW1hbmQgcmVmZXJlbmNlCgpgYGBzaApudmNmLWNsaSBzZWxmLWhvc3Rl" + - "ZCBjaGVjayAtLXByZSAgICAgICAgICAgICAgIyBwcmUtZmxpZ2h0Cm52Y2YtY2xpIHNlbGYtaG9z" + - "dGVkIHVwIC0tY2x1c3Rlci1uYW1lPU5BTUUgICAjIG9uZS1zaG90IGluc3RhbGwKbnZjZi1jbGkg" + - "c2VsZi1ob3N0ZWQgc3RhdHVzICAgICAgICAgICAgICAgICAgICMgc25hcHNob3QKbnZjZi1jbGkg" + - "c2VsZi1ob3N0ZWQgc3RhdHVzIC0td2F0Y2ggICAgICAgICAgICMgbGl2ZQpudmNmLWNsaSBpbml0" + - "ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIyBtaW50IGFkbWluIHRva2VuIChjbGVh" + - "cnMgYWxsIHNhdmVkIEFQSSBrZXlzKQpudmNmLWNsaSBjbHVzdGVyIHJlZ2lzdGVyIOKApiAgICAg" + - "ICAgICAgICAgICAgICAjIHJlZ2lzdGVyIGNsdXN0ZXIKbnZjZi1jbGkgY2x1c3RlciBsaXN0LXJl" + - "Z2lzdGVyZWQgLS1uY2EtaWQ9PG5jYS1pZD4gIyBsaXN0IHNlbGYtaG9zdGVkIHJlZ2lzdHJhdGlv" + - "bnMKbnZjZi1jbGkgYXBpLWtleSBnZW5lcmF0ZSAtLWRlc2NyaXB0aW9uPeKApiAgICAgIyBtaW50" + - "IGJvdGggZnVuY3Rpb24gYW5kIHRhc2sgQVBJIGtleXMgKHJ1biBhZnRlciBldmVyeSBpbml0KQpu" + - "dmNmLWNsaSBhcGkta2V5IGdlbmVyYXRlIC0tZm9yIGZ1bmN0aW9uIOKApiAgICAjIGZ1bmN0aW9u" + - "IGtleSBvbmx5Cm52Y2YtY2xpIGFwaS1rZXkgZ2VuZXJhdGUgLS1mb3IgdGFzayDigKYgICAgICAg" + - "ICMgdGFzayBrZXkgb25seQpudmNmLWNsaSBmdW5jdGlvbiBjcmVhdGUgLS1pbnB1dC1maWxlPeKA" + - "piAgICAgICAjIGNyZWF0ZSBmdW5jdGlvbgpudmNmLWNsaSBmdW5jdGlvbiBjcmVhdGUgLS1mdW5j" + - "dGlvbi10eXBlPUxMTSAtLWxsbS1tb2RlbD08c3BlYz4gICMgY3JlYXRlIExMTSBmdW5jdGlvbiBt" + - "ZXRhZGF0YQpudmNmLWNsaSBmdW5jdGlvbiBjcmVhdGUgLS1uYW1lPWxsbS1oZWxtIC0taW5mZXJl" + - "bmNlLXVybD0vIC0taW5mZXJlbmNlLXBvcnQ9ODAwMCBcCiAgLS1mdW5jdGlvbi10eXBlPUxMTSAt" + - "LWhlbG0tY2hhcnQ9PGNoYXJ0PiAtLWhlbG0tY2hhcnQtc2VydmljZT08c2VydmljZT4gLS1sbG0t" + - "bW9kZWw9PHNwZWM+Cm52Y2YtY2xpIGZ1bmN0aW9uIHVwZGF0ZSAtLWxsbS1tb2RlbC11cGRhdGU9" + - "PHNwZWM+ICAjIHVwZGF0ZSBMTE0gcm91dGluZy90b2tlbiBsaW1pdHMKbnZjZi1jbGkgZnVuY3Rp" + - "b24gZGVwbG95IGNyZWF0ZSAtLWlucHV0LWZpbGU94oCmCm52Y2YtY2xpIGZ1bmN0aW9uIGludm9r" + - "ZSAtLWlucHV0LWZpbGU94oCmCgojIFRhc2sgY29tbWFuZHMg4oCUIHJlcXVpcmVzIE5WQ0ZfQkFT" + - "RV9OVkNUX1VSTD1odHRwOi8vPG52Y3QtZ2F0ZXdheT4KbnZjZi1jbGkgdGFzayBjcmVhdGUgLS1u" + - "YW1lPVggLS1ncHU9SDEwMCAtLWluc3RhbmNlLXR5cGU9WSAtLWltYWdlPVoKbnZjZi1jbGkgdGFz" + - "ayBjcmVhdGUgLS1pbnB1dC1maWxlPXRhc2suanNvbiAgICMgZnJvbSBKU09OIGNvbmZpZwpudmNm" + - "LWNsaSB0YXNrIGxpc3QgICAgICAgICAgICAgICAgICAgICAgICAgICAgIyBsaXN0IGFsbCB0YXNr" + - "cwpudmNmLWNsaSB0YXNrIGxpc3QgLS1zdGF0dXM9UlVOTklORyAgICAgICAgICAgIyBmaWx0ZXIg" + - "Ynkgc3RhdHVzCm52Y2YtY2xpIHRhc2sgZ2V0IFt0YXNrSWRdICAgICAgICAgICAgICAgICAgICAj" + - "IHRhc2sgZGV0YWlscwpudmNmLWNsaSB0YXNrIGV2ZW50cyBbdGFza0lkXSAgICAgICAgICAgICAg" + - "ICAgIyBsaWZlY3ljbGUgZXZlbnRzCm52Y2YtY2xpIHRhc2sgcmVzdWx0cyBbdGFza0lkXSAgICAg" + - "ICAgICAgICAgICAjIHJlc3VsdCBhcnRpZmFjdHMKbnZjZi1jbGkgdGFzayBjYW5jZWwgW3Rhc2tJ" + - "ZF0KbnZjZi1jbGkgdGFzayBkZWxldGUgW3Rhc2tJZF0KYGBgCgojIyBGZWVkYmFjawoKSWYgdGhl" + - "IHVzZXIgaGl0cyBhIGJ1ZyBvciBsaW1pdGF0aW9uLCBmaWxlIGFuIGlzc3VlIHRocm91Z2ggdGhl" + - "IHByb2plY3QgdHJhY2tlci4gRG9uJ3QgaW5jbHVkZSBzZWNyZXRzLgpQSwcIzYEw5E1hAABNYQAA" + - "UEsDBBQACAAAAAAAIQAAAAAAAAAAAAAAAAAzAAkAZGF0YS9udmNmLXNlbGYtbWFuYWdlZC1jbGkv" + - "ZXhhbXBsZXMvY2ktcGlwZWxpbmVzLm1kVVQFAAEAps4SIyBDSSBwaXBlbGluZSBwYXR0ZXJucwoK" + - "SG93IHRvIGRyaXZlIGBudmNmLWNsaWAgZnJvbSBDSSAoR2l0TGFiIENJLCBHaXRIdWIgQWN0aW9u" + - "cywgSmVua2lucywgQXJnb0NEKS4gUGF0dGVybnMgdGhhdCBzdXJmYWNlIGZyZXF1ZW50bHkuCgoj" + - "IyBCYXNpYyBpbnN0YWxsIHBpcGVsaW5lCgpgYGB5YW1sCiMgR2l0TGFiIENJIGV4YW1wbGUKZGVw" + - "bG95X252Y2Y6CiAgc3RhZ2U6IGRlcGxveQogIGltYWdlOiBudmNyLmlvLzA2NTExNTUyMTU4NjQ5" + - "NzkvbmNwLWRldi9udmNmLWNsaToxLjQuMAogIHZhcmlhYmxlczoKICAgIEtVQkVDT05GSUc6ICRL" + - "VUJFQ09ORklHX0ZJTEUKICBzY3JpcHQ6CiAgICAtIG52Y2YtY2xpIHNlbGYtaG9zdGVkIGNoZWNr" + - "IC0tcHJlIC0tanNvbiB8IGpxIC1lICcuZXZlbnQgIT0gInBoYXNlX2ZhaWxlZCInIHx8IGV4aXQg" + - "MgogICAgLSBudmNmLWNsaSBzZWxmLWhvc3RlZCB1cCAtLWNsdXN0ZXItbmFtZT0kQ0xVU1RFUl9O" + - "QU1FIC0tdG9rZW49JE5WQ0ZfQURNSU5fSldUIC0tbm9uLWludGVyYWN0aXZlIC0tanNvbgogICAg" + - "LSBudmNmLWNsaSBzZWxmLWhvc3RlZCBzdGF0dXMgLS1qc29uIHwganEgLWUgJy52ZXJkaWN0ID09" + - "ICJoZWFsdGh5IicKYGBgCgpOb3RlczoKLSBgLS1ub24taW50ZXJhY3RpdmUgLS10b2tlbj0kSldU" + - "YCBpcyByZXF1aXJlZCBpbiBDSTsgbmV2ZXIgdXNlIGludGVyYWN0aXZlIGBpbml0YC4KLSBBbHdh" + - "eXMgYC0tanNvbmAgZm9yIG1hY2hpbmUtcGFyc2luZy4KLSBGaW5hbCBzdGF0dXMgY2hlY2sgZ2F0" + - "ZXMgZG93bnN0cmVhbSBzdGFnZXMgb24gYHZlcmRpY3QgPT0gImhlYWx0aHkiYC4KCiMjIEdpdE9w" + - "cyAoQXJnbyAvIEZsdXgpIHBhdHRlcm4KCkNJIGRvZXNuJ3QgYGt1YmVjdGwgYXBwbHlgIOKAlCBp" + - "bnN0ZWFkLCByZW5kZXIgbWFuaWZlc3RzLCBjb21taXQgdGhlbSwgbGV0IHRoZSBjb250cm9sbGVy" + - "IGFwcGx5LgoKYGBgeWFtbApyZW5kZXI6CiAgc2NyaXB0OgogICAgLSBudmNmLWNsaSBzZWxmLWhv" + - "c3RlZCBpbnN0YWxsIC0tY29udHJvbC1wbGFuZSAtLW5vLWFwcGx5ID4gcmVuZGVyZWQvY29udHJv" + - "bC1wbGFuZS55YW1sCiAgICAtIG52Y2YtY2xpIHNlbGYtaG9zdGVkIGluc3RhbGwgLS1jb21wdXRl" + - "LXBsYW5lIC0tY2x1c3Rlci1uYW1lPSROQU1FIC0tbm8tYXBwbHkgPiByZW5kZXJlZC9jb21wdXRl" + - "LXBsYW5lLnlhbWwKICAgIC0gZ2l0IGFkZCByZW5kZXJlZC8gJiYgZ2l0IGNvbW1pdCAtbSAiZGVw" + - "bG95IE5WQ0YgJFRBRyIgJiYgZ2l0IHB1c2gKYGBgCgpUaGVuIEFyZ29DRCBvciBGbHV4IHdhdGNo" + - "ZXMgYHJlbmRlcmVkL2AgYW5kIGFwcGxpZXMuIFRoZSBDTEkgbmV2ZXIgdG91Y2hlcyB0aGUgY2x1" + - "c3RlciBkaXJlY3RseS4KCkZvciB0aGUgcmVnaXN0ZXIgc3RlcCAod2hpY2ggbXV0YXRlcyBJQ01T" + - "LCBub3QganVzdCBLOHMpOgoKYGBgeWFtbApyZWdpc3RlcjoKICBzY3JpcHQ6CiAgICAtIG52Y2Yt" + - "Y2xpIGNsdXN0ZXIgcmVnaXN0ZXIgLS1uYW1lPSROQU1FIC0tbmNhLWlkPSROQ0EgLS1yZWdpb249" + - "JFJFR0lPTiAtLWlnbm9yZS1leGlzdGluZwpgYGAKCmAtLWlnbm9yZS1leGlzdGluZ2AgaXMgdGhl" + - "IEdpdE9wcy1mcmllbmRseSBpZGVtcG90ZW50IGNvbnRyYWN0LgoKIyMgTXVsdGktY2x1c3RlciBw" + - "aXBlbGluZQoKV2hlbiB0aGUgcGlwZWxpbmUgbWFuYWdlcyBtYW55IGNvbXB1dGUgY2x1c3RlcnMg" + - "YWdhaW5zdCBvbmUgY29udHJvbCBwbGFuZToKCmBgYHlhbWwKZGVwbG95X2NvbXB1dGVfcGxhbmVz" + - "OgogIHBhcmFsbGVsOgogICAgbWF0cml4OgogICAgICAtIENMVVNURVI6IG5jcC1lYXN0LTEKICAg" + - "ICAgICBDT05URVhUOiBhZG1pbkBncHUtZWFzdC0xCiAgICAgIC0gQ0xVU1RFUjogbmNwLXdlc3Qt" + - "MQogICAgICAgIENPTlRFWFQ6IGFkbWluQGdwdS13ZXN0LTEKICAgICAgLSBDTFVTVEVSOiBuY3At" + - "ZXUtMQogICAgICAgIENPTlRFWFQ6IGFkbWluQGdwdS1ldS0xCiAgc2NyaXB0OgogICAgLSBudmNm" + - "LWNsaSBzZWxmLWhvc3RlZCB1cAogICAgICAgIC0tY2x1c3Rlci1uYW1lPSRDTFVTVEVSCiAgICAg" + - "ICAgLS1jb21wdXRlLXBsYW5lLWNvbnRleHQ9JENPTlRFWFQKICAgICAgICAtLWljbXMtdXJsPSRJ" + - "Q01TX1BVQkxJQ19VUkwKICAgICAgICAtLXRva2VuPSROVkNGX0FETUlOX0pXVAogICAgICAgIC0t" + - "bm9uLWludGVyYWN0aXZlCiAgICAgICAgLS1qc29uCmBgYAoKRWFjaCBwYXJhbGxlbCBqb2IgcmVn" + - "aXN0ZXJzICsgaW5zdGFsbHMgb25lIGNvbXB1dGUgcGxhbmUgYWdhaW5zdCB0aGUgc2hhcmVkIGNv" + - "bnRyb2wgcGxhbmUuIEZhaWx1cmVzIGFyZSBpc29sYXRlZC4KCiMjIFBsYW4tb25seSBwcmV2aWV3" + - "IGluIFBScwoKYGBgeWFtbApwcmV2aWV3OgogIHJ1bGVzOgogICAgLSBpZjogJENJX1BJUEVMSU5F" + - "X1NPVVJDRSA9PSAibWVyZ2VfcmVxdWVzdF9ldmVudCIKICBzY3JpcHQ6CiAgICAtIHwKICAgICAg" + - "bnZjZi1jbGkgc2VsZi1ob3N0ZWQgdXAgXAogICAgICAgIC0tY2x1c3Rlci1uYW1lPSRDTFVTVEVS" + - "X05BTUUgXAogICAgICAgIC0tcGxhbi1vbmx5IFwKICAgICAgICAtLWpzb24gfCB0ZWUgcGxhbi5q" + - "c29ubAogICAgLSBqcSAtcyAnLlswXScgcGxhbi5qc29ubCA+IHBsYW4uanNvbgogICAgLSAnZ2l0" + - "bGFiLW1yLWNvbW1lbnQgIiMjIE5WQ0YgZGVwbG95IHBsYW5cblxuXGBcYFxganNvblxuJChjYXQg" + - "cGxhbi5qc29uKVxuXGBcYFxgIicKYGBgCgpgLS1wbGFuLW9ubHlgIGV4aXRzIDAgd2l0aG91dCBj" + - "aGFuZ2luZyBjbHVzdGVyIHN0YXRlOyB0aGUgSlNPTkwgb3V0cHV0IGxpc3RzIGVhY2ggcGhhc2Ug" + - "KyBFVEEuIFJlbmRlcnMgbmljZWx5IGFzIGFuIE1SIGNvbW1lbnQuClBLBwghxsiG8AoAAPAKAABQ" + - "SwMEFAAIAAAAAAAhAAAAAAAAAAAAAAAAADQACQBkYXRhL252Y2Ytc2VsZi1tYW5hZ2VkLWNsaS9l" + - "eGFtcGxlcy9tdWx0aS1jbHVzdGVyLm1kVVQFAAEAps4SIyBNdWx0aS1jbHVzdGVyIHBhdHRlcm5z" + - "CgpFeGFtcGxlcyBvZiBzcGxpdC1jbHVzdGVyICsgbWFueS1jb21wdXRlLXBsYW5lIG9wZXJhdGlv" + - "bi4KCiMjIE9uZSBjb250cm9sIHBsYW5lICsgTiBjb21wdXRlIHBsYW5lcwoKVGhlIGNhbm9uaWNh" + - "bCBtdWx0aS1jbHVzdGVyIHRvcG9sb2d5LiBFYWNoIGNvbXB1dGUgcGxhbmUgaXMgcmVnaXN0ZXJl" + - "ZCBzZXBhcmF0ZWx5OgoKYGBgc2gKIyAxLiBCcmluZyB1cCB0aGUgY29udHJvbCBwbGFuZSAob25l" + - "LXRpbWUsIG9uIHRoZSBjb250cm9sLXBsYW5lIGNsdXN0ZXIpOgpLVUJFQ09ORklHPWNwLnlhbWwg" + - "bnZjZi1jbGkgc2VsZi1ob3N0ZWQgaW5zdGFsbCAtLWNvbnRyb2wtcGxhbmUgfCBrdWJlY3RsIGFw" + - "cGx5IC1mIC0KbnZjZi1jbGkgc2VsZi1ob3N0ZWQgY2hlY2sgLS1jb250cm9sLXBsYW5lIC0td2Fp" + - "dCA1bQoKIyAyLiBSZWdpc3RlciArIGluc3RhbGwgZWFjaCBjb21wdXRlIHBsYW5lOgpmb3IgQ1RY" + - "IGluIGFkbWluQGdwdS1lYXN0LTEgYWRtaW5AZ3B1LXdlc3QtMSBhZG1pbkBncHUtZXUtMTsgZG8K" + - "ICBOQU1FPSQoZWNobyAiJENUWCIgfCBjdXQgLWRAIC1mMikKICBudmNmLWNsaSBzZWxmLWhvc3Rl" + - "ZCB1cCBcCiAgICAtLWNsdXN0ZXItbmFtZT0kTkFNRSBcCiAgICAtLWNvbXB1dGUtcGxhbmUtY29u" + - "dGV4dD0kQ1RYIFwKICAgIC0taWNtcy11cmw9aHR0cHM6Ly9pY21zLm52Y2YuZXhhbXBsZS5jb20g" + - "XAogICAgLS10b2tlbj0kTlZDRl9BRE1JTl9KV1QgXAogICAgLS1ub24taW50ZXJhY3RpdmUgXAog" + - "ICAgLS1qc29uCmRvbmUKCiMgMy4gVmVyaWZ5IGFsbCBjb21wdXRlIHBsYW5lcyByZWdpc3RlcmVk" + - "OgpudmNmLWNsaSBjbHVzdGVyIGxpc3QtcmVnaXN0ZXJlZCAtLW5jYS1pZD0kTkNBX0lEIC0taWNt" + - "cy11cmw9JElDTVMgLS1qc29uIFwKICB8IGpxICcuY2x1c3RlcnNbXSB8IHtuYW1lOiAuY2x1c3Rl" + - "ck5hbWUsIHN0YXR1cywgbnZjYVZlcnNpb259JwpgYGAKCiMjIENvbXB1dGUtcGxhbmUtb25seSBv" + - "cGVyYXRvciBzY2VuYXJpbwoKVGhlIG9wZXJhdG9yIGhhcyBrdWJlY3RsIGFjY2VzcyB0byBPTkUg" + - "Y29tcHV0ZSBwbGFuZSBvbmx5IOKAlCB0aGUgY29udHJvbCBwbGFuZSBpcyBvcGVyYXRlZCBieSBz" + - "b21lb25lIGVsc2UgKGUuZy4gWW90dGEgcnVucyB0aGUgY29udHJvbCBwbGFuZSBmb3IgYSBjdXN0" + - "b21lcikuCgpgYGBzaAojIE1pbnQgYSB0b2tlbiB2aWEgdGhlIHB1YmxpYyBhcGkgZ2F0ZXdheSAo" + - "dGhlIGNvbnRyb2wgcGxhbmUncyBBUEkgS2V5cwojIHNlcnZpY2UgaXMgcmVhY2hhYmxlIHZpYSBh" + - "cGkubnZjZi5leGFtcGxlLmNvbSDigJQgbm8ga3ViZWN0bCBhY2Nlc3MgbmVlZGVkKToKbnZjZi1j" + - "bGkgaW5pdCAtLWFwaS11cmw9aHR0cHM6Ly9hcGkubnZjZi5leGFtcGxlLmNvbQoKIyBSdW4gcHJl" + - "LWZsaWdodCBzY29wZWQgdG8gdGhlIGNvbXB1dGUgcGxhbmUgb25seToKbnZjZi1jbGkgc2VsZi1o" + - "b3N0ZWQgY2hlY2sgLS1wcmUgXAogIC0tY29tcHV0ZS1wbGFuZS1jb250ZXh0PWFkbWluQGdwdTEg" + - "XAogIC0taWNtcy11cmw9aHR0cHM6Ly9pY21zLm52Y2YuZXhhbXBsZS5jb20gXAogIC0tanNvbgoK" + - "IyBCcmluZyB1cCBqdXN0IHRoZSBjb21wdXRlIHBsYW5lOgpudmNmLWNsaSBzZWxmLWhvc3RlZCB1" + - "cCBcCiAgLS1jbHVzdGVyLW5hbWU9bXktY29tcHV0ZS0xIFwKICAtLWNvbXB1dGUtcGxhbmUtY29u" + - "dGV4dD1hZG1pbkBncHUxIFwKICAtLWljbXMtdXJsPWh0dHBzOi8vaWNtcy5udmNmLmV4YW1wbGUu" + - "Y29tIFwKICAtLXRva2VuPSRBRE1JTl9KV1QgXAogIC0tbm9uLWludGVyYWN0aXZlCgojIFN0YXR1" + - "cyAoY29tcHV0ZS1vbmx5IOKAlCBvcGVyYXRvciBjYW4ndCBzZWUgY29udHJvbC1wbGFuZSBjb21w" + - "b25lbnQgaGVhbHRoKToKbnZjZi1jbGkgc2VsZi1ob3N0ZWQgc3RhdHVzIFwKICAtLWNvbXB1dGUt" + - "cGxhbmUtY29udGV4dD1hZG1pbkBncHUxIFwKICAtLWljbXMtdXJsPWh0dHBzOi8vaWNtcy5udmNm" + - "LmV4YW1wbGUuY29tCmBgYAoKIyMgRnVuY3Rpb25zIHRhcmdldGluZyBzcGVjaWZpYyBjb21wdXRl" + - "IHBsYW5lcwoKV2hlbiB5b3UgaGF2ZSBtdWx0aXBsZSBjb21wdXRlIHBsYW5lcyBhbmQgd2FudCBh" + - "IGZ1bmN0aW9uIHRvIGRlcGxveSB0byBvbmU6CgpgYGBqc29uCnsKICAiZnVuY3Rpb25JZCI6ICI8" + - "Zm5faWQ+IiwKICAidmVyc2lvbklkIjogIjx2ZXJfaWQ+IiwKICAiZGVwbG95bWVudFNwZWNpZmlj" + - "YXRpb25zIjogW3sKICAgICJncHUiOiAiSDEwMCIsCiAgICAiaW5zdGFuY2VUeXBlIjogIk5DUC5H" + - "UFUuSDEwMF8xeCIsCiAgICAibWluSW5zdGFuY2VzIjogMSwKICAgICJtYXhJbnN0YW5jZXMiOiAx" + - "LAogICAgImNsdXN0ZXJzIjogWyJncHUtZWFzdC0xIl0KICB9XQp9CmBgYAoKVGhlIGBjbHVzdGVy" + - "c2AgYXJyYXkgKHVzaW5nIGNsdXN0ZXIgbmFtZXMsIG5vdCBJRHMpIGxpbWl0cyBzY2hlZHVsaW5n" + - "IHRvIHRob3NlIGNvbXB1dGUgcGxhbmVzLiBPbWl0IHRvIGxldCBJQ01TIGNob29zZSBhbnkgY29t" + - "cHV0ZSBwbGFuZSB3aXRoIGEgbWF0Y2hpbmcgU0tVLgoKIyMgU3RhdHVzIGZhbi1vdXQgYWNyb3Nz" + - "IGNvbXB1dGUgcGxhbmVzCgpgYGBzaAojIExpc3QgYWxsIHJlZ2lzdGVyZWQgY29tcHV0ZSBwbGFu" + - "ZXM6Cm52Y2YtY2xpIGNsdXN0ZXIgbGlzdC1yZWdpc3RlcmVkIC0tbmNhLWlkPSROQ0FfSUQgLS1p" + - "Y21zLXVybD0kSUNNUyAtLWpzb24gXAogIHwganEgLXIgJy5jbHVzdGVyc1tdLmNsdXN0ZXJOYW1l" + - "JyA+IGNsdXN0ZXJzLnR4dAoKIyBTdGF0dXMgc25hcHNob3QgcGVyIGNvbXB1dGUgcGxhbmUgKGFz" + - "c3VtaW5nIGVhY2ggY29udGV4dCBuYW1lIG1hdGNoZXMpOgp3aGlsZSByZWFkIE5BTUU7IGRvCiAg" + - "ZWNobyAiPT09ICROQU1FID09PSIKICBudmNmLWNsaSBzZWxmLWhvc3RlZCBzdGF0dXMgXAogICAg" + - "LS1jbHVzdGVyLW5hbWU9JE5BTUUgXAogICAgLS1jb21wdXRlLXBsYW5lLWNvbnRleHQ9YWRtaW5A" + - "JE5BTUUgXAogICAgLS1qc29uIHwganEgLWMgJ3tjbHVzdGVyOi5jbHVzdGVyLCB2ZXJkaWN0Oi52" + - "ZXJkaWN0LCByZWNvbmNpbGU6LnJlY29uY2lsZUFnZVNlY30nCmRvbmUgPCBjbHVzdGVycy50eHQK" + - "YGBgCgpBIGZ1dHVyZSBNKzExIG1pbGVzdG9uZSB3aWxsIGFkZCBuYXRpdmUgZmFuLW91dCAoYHN0" + - "YXR1cyAtLWFsbC1jb21wdXRlLXBsYW5lc2ApIHNvIHRoaXMgZG9lc24ndCBuZWVkIGEgc2hlbGwg" + - "bG9vcC4KUEsHCKEU44FdDAAAXQwAAFBLAwQUAAgAAAAAACEAAAAAAAAAAAAAAAAANwAJAGRhdGEv" + - "bnZjZi1zZWxmLW1hbmFnZWQtY2xpL3Byb21wdHMvYWRkLWNvbXB1dGUtcGxhbmUubWRVVAUAAQCm" + - "zhIjIEFkZCBhIGNvbXB1dGUgcGxhbmUgdG8gYW4gZXhpc3RpbmcgY29udHJvbCBwbGFuZQoKVXNl" + - "ciBoYXMgYSB3b3JraW5nIE5WQ0YgY29udHJvbCBwbGFuZSAocnVubmluZyBzb21ld2hlcmUpIGFu" + - "ZCB3YW50cyB0byByZWdpc3RlciBhIG5ldyBHUFUgY2x1c3RlciBhZ2FpbnN0IGl0LiBUaGlzIGlz" + - "IHRoZSBtdWx0aS1jbHVzdGVyIHNjYWxpbmcgcGF0aDogb25lIGNvbnRyb2wgcGxhbmUg4oaSIE4g" + - "Y29tcHV0ZSBwbGFuZXMuCgojIyBQcmVyZXF1aXNpdGVzIHRoZSB1c2VyIG11c3QgaGF2ZQoKLSAq" + - "Kmt1YmVjdGwgY29udGV4dCBmb3IgdGhlIG5ldyBjb21wdXRlIHBsYW5lKiogaW4gdGhlaXIgYEtV" + - "QkVDT05GSUdgLgotICoqUHVibGljIElDTVMgVVJMKiogb2YgdGhlIGV4aXN0aW5nIGNvbnRyb2wg" + - "cGxhbmUgKGUuZy4gYGh0dHBzOi8vaWNtcy5udmNmLmV4YW1wbGUuY29tYCkuCi0gKipBZG1pbiBK" + - "V1QqKiBmb3IgdGhlIGNvbnRyb2wgcGxhbmUncyBhY2NvdW50LCBPUiBhYmlsaXR5IHRvIG1pbnQg" + - "b25lIHZpYSBgbnZjZi1jbGkgaW5pdGAgYWdhaW5zdCB0aGUgY29udHJvbCBwbGFuZSdzIHB1Ymxp" + - "YyBhcGkgZW5kcG9pbnQuIChBZG1pbiB0b2tlbnMgY29tZSBmcm9tIHRoZSBBUEkgS2V5cyBzZXJ2" + - "aWNlIHZpYSB0aGUgcHVibGljIGFwaSBnYXRld2F5IOKAlCBrdWJlY3RsIGFjY2VzcyB0byB0aGUg" + - "Y29udHJvbCBwbGFuZSBpcyBOT1QgcmVxdWlyZWQgdG8gb2J0YWluIG9uZS4pCi0gQSB1bmlxdWUg" + - "YC0tY2x1c3Rlci1uYW1lYCB0aGF0IGRvZXNuJ3QgY29sbGlkZSB3aXRoIGFscmVhZHktcmVnaXN0" + - "ZXJlZCBjbHVzdGVycy4gVXNlIGBudmNmLWNsaSBjbHVzdGVyIGxpc3QtcmVnaXN0ZXJlZCAtLW5j" + - "YS1pZD0kTkNBX0lEIC0taWNtcy11cmw9JElDTVNgIHRvIGNoZWNrLgoKIyMgU3RlcHMKCjEuICoq" + - "QXNrIGZvciBpbnB1dHM6KioKICAgLSBgLS1jbHVzdGVyLW5hbWU9PHVuaXF1ZT5gIOKAlCBtdXN0" + - "IGJlIHVuaXF1ZSB3aXRoaW4gdGhlIGNvbnRyb2wgcGxhbmUncyBOQ0Egc2NvcGUKICAgLSBgLS1j" + - "b21wdXRlLXBsYW5lLWNvbnRleHQ9PGNvbnRleHQ+YCDigJQgdGhlIG5ldyBHUFUgY2x1c3Rlcidz" + - "IGt1YmVjdGwgY29udGV4dAogICAtIGAtLWljbXMtdXJsPTxodHRwczovL2ljbXMubnZjZi5leGFt" + - "cGxlLmNvbT5gIOKAlCBjb250cm9sIHBsYW5lJ3MgcHVibGljIElDTVMgVVJMCiAgIC0gR1BVIHR5" + - "cGU/IChkZWZhdWx0IGBIMTAwYCwgYnV0IGFzaykKCjIuICoqUHJlLWZsaWdodCBqdXN0IHRoZSBj" + - "b21wdXRlIHBsYW5lOioqCgogICBgYGBzaAogICBudmNmLWNsaSBzZWxmLWhvc3RlZCBjaGVjayAt" + - "LXByZSBcCiAgICAgLS1jb21wdXRlLXBsYW5lLWNvbnRleHQ9JENUWCBcCiAgICAgLS1pY21zLXVy" + - "bD0kSUNNUyBcCiAgICAgLS1qc29uIHwganEgLWMgLgogICBgYGAKCiAgIFRoaXMgdmFsaWRhdGVz" + - "IHRoZSBHUFUgb3BlcmF0b3IgaXMgaW5zdGFsbGVkLCBHUFUgbm9kZSBsYWJlbHMgYXJlIHByZXNl" + - "bnQsIGFuZCBJQ01TIGlzIHJlYWNoYWJsZSB2aWEgSFRUUC4gQWRkcmVzcyBhbnkgZmFpbHVyZXMg" + - "YmVmb3JlIHByb2NlZWRpbmcuCgozLiAqKlJ1biBgYWRkLWNvbXB1dGUtcGxhbmVgOioqCgogICBg" + - "YGBzaAogICBudmNmLWNsaSBzZWxmLWhvc3RlZCBhZGQtY29tcHV0ZS1wbGFuZSBcCiAgICAgLS1j" + - "bHVzdGVyLW5hbWU9JE5BTUUgXAogICAgIC0tY29tcHV0ZS1wbGFuZS1jb250ZXh0PSRDVFggXAog" + - "ICAgIC0taWNtcy11cmw9JElDTVMgXAogICAgIC0tdG9rZW49JEpXVCBcCiAgICAgLS1ub24taW50" + - "ZXJhY3RpdmUgXAogICAgIC0tanNvbgogICBgYGAKCiAgIFRoaXMgaXMgYSBzZXBhcmF0ZSBzdWJj" + - "b21tYW5kIGZyb20gYHVwYC4gSXQgcnVucyBvbmx5IHRoZSBjb21wdXRlLXBsYW5lLXJlbGV2YW50" + - "IHBoYXNlczogMSAoY29tcHV0ZS1wbGFuZSBwcmVmbGlnaHQpLCA1IChyZWdpc3RlciksIDYgKGNv" + - "bXB1dGUtcGxhbmUgYXBwbHkpLCA4IChmaW5hbCBoZWFsdGggb24gdGhlIG5ldyBjb21wdXRlIHBs" + - "YW5lKS4gSXQgZG9lcyBOT1QgdG91Y2ggdGhlIGNvbnRyb2wgcGxhbmUgYW5kIGRvZXMgTk9UIGFj" + - "Y2VwdCBgLS1jb250cm9sLXBsYW5lLWNvbnRleHRgIOKAlCB0aGUgY29udHJvbCBwbGFuZSBpcyBy" + - "ZWFjaGVkIG92ZXIgSFRUUFMgYXQgYC0taWNtcy11cmxgLiBgLS10b2tlbmAgaXMgcmVxdWlyZWQg" + - "YmVjYXVzZSB0aGVyZSdzIG5vIGt1YmVjdGwgcGF0aCB0byBtaW50IG9uZSBmcm9tLgoKNC4gKipW" + - "ZXJpZnkuKiogYG52Y2YtY2xpIHNlbGYtaG9zdGVkIHN0YXR1cyAtLWNsdXN0ZXItbmFtZT0kTkFN" + - "RSAtLWpzb24gfCBqcWAg4oCUIGV4cGVjdCBgdmVyZGljdDogImhlYWx0aHkiYC4gVGhlIFJlZ2lz" + - "dGVyZWQgQ29tcHV0ZSBQbGFuZXMgcGFuZWwgZnJvbSBJQ01TIHNob3VsZCBub3cgbGlzdCB0aGUg" + - "bmV3IGNsdXN0ZXIuCgo1LiAqKlNtb2tlLioqIFtkZXBsb3ktYW5kLWludm9rZS5tZF0oZGVwbG95" + - "LWFuZC1pbnZva2UubWQpIOKAlCBkZXBsb3kgYSBzbWFsbCBmdW5jdGlvbiB0byB0aGUgbmV3IGNv" + - "bXB1dGUgcGxhbmUgdG8gY29uZmlybSBzY2hlZHVsaW5nIHdvcmtzLgoKIyMgV2hhdCBpZiBhIGNs" + - "dXN0ZXIgd2l0aCB0aGUgc2FtZSBuYW1lIGFscmVhZHkgZXhpc3RzPwoKYGFkZC1jb21wdXRlLXBs" + - "YW5lYCdzIHJlZ2lzdGVyIHBoYXNlIHVzZXMgYC0taWdub3JlLWV4aXN0aW5nYCBzZW1hbnRpY3Mg" + - "4oCUIGl0J2xsIG1hdGNoIHRoZSBleGlzdGluZyBJQ01TIHJvdyBhbmQgcmV1c2UgaXRzIGNsdXN0" + - "ZXJJZC4gVHdvIHNjZW5hcmlvczoKCi0gKipSZS1yZWdpc3RlcmluZyB0aGUgc2FtZSBjbHVzdGVy" + - "KiogKHJlLXJ1bm5pbmcgb24gdGhlIHNhbWUgY29tcHV0ZSBwbGFuZSB0aGF0IHdhcyBwcmV2aW91" + - "c2x5IHJlZ2lzdGVyZWQpOiBleHBlY3RlZCwgbm8tb3Agc2VtYW50aWNzLgotICoqRGlmZmVyZW50" + - "IHBoeXNpY2FsIGNsdXN0ZXIgYnV0IHNhbWUgbmFtZSoqOiB0aGUgc2Vjb25kIGF0dGVtcHQgd2ls" + - "bCByZXVzZSB0aGUgSUNNUyByb3csIGJ1dCB0aGUgbmV3IGNvbXB1dGUgcGxhbmUncyBKV0tTIHdp" + - "bGwgYmUgc2lsZW50bHkgKnJlcGxhY2VkKiDigJQgdGhlIG9sZCBjb21wdXRlIHBsYW5lJ3MgTlZD" + - "QSBhZ2VudCB3aWxsIHN0YXJ0IGZhaWxpbmcgUFNBVCBhdXRoLiAqKkNvbmZpcm0gd2l0aCB0aGUg" + - "dXNlcioqIHRoYXQgdGhleSBtZWFudCB0byBvdmVyd3JpdGUuCgpXaGVuIGluIGRvdWJ0LCBydW4g" + - "YG52Y2YtY2xpIGNsdXN0ZXIgbGlzdC1yZWdpc3RlcmVkIC0tbmNhLWlkPSROQ0FfSUQgLS1pY21z" + - "LXVybD0kSUNNU2AgZmlyc3QgYW5kIGFzayB0aGUgdXNlciBiZWZvcmUgcHJvY2VlZGluZyB3aXRo" + - "IGEgbmFtZSB0aGF0IGFscmVhZHkgZXhpc3RzLgpQSwcIQidJDwUNAAAFDQAAUEsDBBQACAAAAAAA" + - "IQAAAAAAAAAAAAAAAAA5AAkAZGF0YS9udmNmLXNlbGYtbWFuYWdlZC1jbGkvcHJvbXB0cy9jcmVh" + - "dGUtYW5kLXJ1bi10YXNrLm1kVVQFAAEAps4SIyBDcmVhdGUgYW5kIHJ1biBhIHRhc2sKClN0YW5k" + - "YXJkIGZsb3c6IG1pbnQgQVBJIGtleXMgLT4gdGFzayBDUkVBVEUgLT4gbW9uaXRvciAtPiByZXRy" + - "aWV2ZSByZXN1bHRzIC0+IGNsZWFudXAuCgojIyAxLiBNaW50IEFQSSBrZXlzCgpUaGUgYWRtaW4g" + - "dG9rZW4gZnJvbSBgaW5pdGAgZG9lcyBub3QgY2FycnkgdGFzayBpbnZvY2F0aW9uIHNjb3BlLiBH" + - "ZW5lcmF0ZSBBUEkga2V5czoKCmBgYHNoCm52Y2YtY2xpIGFwaS1rZXkgZ2VuZXJhdGUgLS1kZXNj" + - "cmlwdGlvbj0idGFzayBzbW9rZSB0ZXN0IiAtLWV4cGlyZXMtaW49OGgKIyAtPiBmdW5jdGlvbiBr" + - "ZXk6IG52YXBpLS4uLgojIC0+IHRhc2sga2V5OiBudmFwaS0uLi4KYGBgCgpCb3RoIGtleXMgYXJl" + - "IHNhdmVkIHRvIENMSSBzdGF0ZS4gVG8gbWludCBvbmx5IHRoZSB0YXNrIGtleToKCmBgYHNoCm52" + - "Y2YtY2xpIGFwaS1rZXkgZ2VuZXJhdGUgLS1mb3IgdGFzayAtLWRlc2NyaXB0aW9uPSJ0YXNrIHNt" + - "b2tlIHRlc3QiIC0tZXhwaXJlcy1pbj04aApgYGAKClRvIHZhbGlkYXRlIGVhY2gga2V5IGltbWVk" + - "aWF0ZWx5IGFmdGVyIG1pbnRpbmc6CgpgYGBzaApudmNmLWNsaSBhcGkta2V5IGdlbmVyYXRlIC0t" + - "ZGVzY3JpcHRpb249InRhc2sgc21va2UgdGVzdCIgLS1leHBpcmVzLWluPThoIC0tdmFsaWRhdGUK" + - "IyAtPiBmdW5jdGlvbiBBUEkga2V5IHZhbGlkYXRpb24gcGFzc2VkIQojIC0+IHRhc2sgQVBJIGtl" + - "eSB2YWxpZGF0aW9uIHBhc3NlZCEKYGBgCgpOZXZlciBlY2hvIHRoZSBrZXkgdmFsdWUgKG52YXBp" + - "LS4uLikgaW50byBjaGF0IG9yIGxvZ3MuIFJlcG9ydCBvbmx5IHRoYXQgdGhlIGtleSB3YXMgbWlu" + - "dGVkLCBpdHMgZGVzY3JpcHRpb24sIGFuZCBpdHMgZXhwaXJ5IOKAlCBuZXZlciB0aGUgdmFsdWUg" + - "aXRzZWxmLgoKIyMjIEZyZXNoIHNlc3Npb24gcHJlLWZsaWdodAoKQmVmb3JlIHJ1bm5pbmcgYW55" + - "IGB0YXNrYCBjb21tYW5kIGluIGEgZnJlc2ggYWdlbnQgc2Vzc2lvbiwgdmVyaWZ5IGNyZWRlbnRp" + - "YWxzOgoKMS4gQ2hlY2sgd2hldGhlciBgTlZDRl9BUElfS0VZYCBpcyBzZXQ6CiAgIGBgYHNoCiAg" + - "IHByaW50ZW52IE5WQ0ZfQVBJX0tFWSA+IC9kZXYvbnVsbCAyPiYxICYmIGVjaG8gc2V0IHx8IGVj" + - "aG8gdW5zZXQKICAgYGBgCjIuIElmIHVuc2V0LCByZWFkIHRoZSBzdG9yZWQga2V5IGV4cGlyeSB3" + - "aXRob3V0IHByaW50aW5nIHRoZSB2YWx1ZToKICAgYGBgc2gKICAgcHl0aG9uMyAtYyAiaW1wb3J0" + - "IGpzb24scGF0aGxpYjsgcz1qc29uLmxvYWRzKHBhdGhsaWIuUGF0aCgnfi8ubnZjZi1jbGkuc3Rh" + - "dGUnKS5leHBhbmR1c2VyKCkucmVhZF90ZXh0KCkpOyBwcmludChzLmdldCgnbnZjdEFwaUtleUV4" + - "cGlyYXRpb24nLCdtaXNzaW5nJykpIgogICBgYGAKMy4gSWYgdGhlIGV4cGlyeSBpcyBpbiB0aGUg" + - "cGFzdCBvciBtaXNzaW5nLCByZWdlbmVyYXRlOgogICBgYGBzaAogICBudmNmLWNsaSByZWZyZXNo" + - "CiAgIG52Y2YtY2xpIGFwaS1rZXkgZ2VuZXJhdGUgLS1mb3IgdGFzayAtLWRlc2NyaXB0aW9uPSJ0" + - "YXNrLWtleSIgLS1leHBpcmVzLWluPTI0aCAtLXZhbGlkYXRlCiAgIGBgYAo0LiBJbmplY3QgdGhl" + - "IHN0b3JlZCBrZXkgaW50byB0aGUgc3VicHJvY2VzcyBlbnYgd2l0aG91dCBsb2dnaW5nIHRoZSB2" + - "YWx1ZS4gVXNlIGEgc2hlbGwgc3Vic2hlbGwgb3IgZW52IHByZWZpeCDigJQgbmV2ZXIgcHJpbnQg" + - "dGhlIGtleSBpbnRvIGNoYXQuCgpFcnJvciBjbGFzc2lmaWNhdGlvbjoKLSAibWlzc2luZyBhdXRo" + - "ZW50aWNhdGlvbiBjcmVkZW50aWFscyIgb3IgZXhpdCAyOiBrZXkgbm90IGluamVjdGVkOyByZXBl" + - "YXQgcHJlLWZsaWdodC4KLSBIVFRQIDQwMzoga2V5IGV4cGlyZWQgb3Igd3JvbmcgYXVkaWVuY2U7" + - "IHJlZ2VuZXJhdGUuCi0gRW1wdHkgdGFzayBsaXN0OiB2YWxpZDsgbm8gdGFza3MgZXhpc3QgeWV0" + - "LgoKIyMgMi4gVGFzayBDUkVBVEU6IGNvbnRhaW5lcgoKRGVmaW5lIHRoZSB0YXNrIGluIGEgSlNP" + - "TiBmaWxlLiBNaW5pbXVtIHZpYWJsZSBjb250YWluZXIgdGFzazoKCmBgYGpzb24KewogICJuYW1l" + - "IjogInNtb2tlLWNvbnRhaW5lci10YXNrIiwKICAiZ3B1U3BlY2lmaWNhdGlvbiI6IHsKICAgICJn" + - "cHUiOiAiSDEwMCIsCiAgICAiaW5zdGFuY2VUeXBlIjogIk5DUC5HUFUuSDEwMF8xeCIsCiAgICAi" + - "YmFja2VuZCI6ICJuY3AtbG9jYWwiCiAgfSwKICAiY29udGFpbmVySW1hZ2UiOiAibnZjci5pby9u" + - "dmlkaWEvbmVtbzpsYXRlc3QiLAogICJjb250YWluZXJBcmdzIjogInB5dGhvbiAtYyBcInByaW50" + - "KCdoZWxsbyBmcm9tIHRhc2snKVwiIiwKICAicmVzdWx0SGFuZGxpbmdTdHJhdGVneSI6ICJOT05F" + - "Igp9CmBgYAoKYGBgc2gKbnZjZi1jbGkgdGFzayBjcmVhdGUgLS1pbnB1dC1maWxlPXRhc2stY29u" + - "dGFpbmVyLmpzb24KIyAtPiBUYXNrIElEOiA8dGFza19pZD4KYGBgCgpDYXB0dXJlIHRoZSB0YXNr" + - "IElEIGZyb20gdGhlIG91dHB1dC4gU3RhdGUgcGVyc2lzdGVuY2UgY2FuIGZhaWwgc2lsZW50bHks" + - "IHNvIHBhc3MKYDx0YXNrSWQ+YCBleHBsaWNpdGx5IG9uIHN1YnNlcXVlbnQgY29tbWFuZHMgcmF0" + - "aGVyIHRoYW4gcmVseWluZyBvbiBzYXZlZCBzdGF0ZS4KCkVxdWl2YWxlbnQgQ0xJIGZsYWdzIGZv" + - "cm0gZm9yIHF1aWNrIGFkLWhvYyBydW5zOgoKYGBgc2gKbnZjZi1jbGkgdGFzayBjcmVhdGUgXAog" + - "IC0tbmFtZT1zbW9rZS1jb250YWluZXItdGFzayBcCiAgLS1ncHU9SDEwMCBcCiAgLS1pbnN0YW5j" + - "ZS10eXBlPU5DUC5HUFUuSDEwMF8xeCBcCiAgLS1iYWNrZW5kPW5jcC1sb2NhbCBcCiAgLS1pbWFn" + - "ZT1udmNyLmlvL252aWRpYS9uZW1vOmxhdGVzdCBcCiAgLS1jb250YWluZXItYXJncz0icHl0aG9u" + - "IC1jICdwcmludChoZWxsbyBmcm9tIHRhc2spJyIgXAogIC0tcmVzdWx0LXN0cmF0ZWd5PU5PTkUK" + - "YGBgCgpUbyB0YXJnZXQgYSBzcGVjaWZpYyBjb21wdXRlIGNsdXN0ZXI6CgpgYGBzaApudmNmLWNs" + - "aSB0YXNrIGNyZWF0ZSAtLWlucHV0LWZpbGU9dGFzay1jb250YWluZXIuanNvbiAtLWNsdXN0ZXJz" + - "PW15LWNsdXN0ZXIKYGBgCgpUbyBpbmplY3QgZW52aXJvbm1lbnQgdmFyaWFibGVzIG9yIHNlY3Jl" + - "dHMsIGVpdGhlciBwYXNzIGZsYWdzOgoKYGBgc2gKbnZjZi1jbGkgdGFzayBjcmVhdGUgLS1pbnB1" + - "dC1maWxlPXRhc2stY29udGFpbmVyLmpzb24gXAogIC0tY29udGFpbmVyLWVudiBNWV9FTlY9dmFs" + - "dWUgXAogIC0tc2VjcmV0cyBNWV9TRUNSRVQ9czNjcjN0CmBgYAoKb3Igc2V0IHRoZW0gaW4gdGhl" + - "IEpTT04gZmlsZToKCmBgYGpzb24KewogICJjb250YWluZXJFbnZpcm9ubWVudCI6IFsKICAgIHsi" + - "a2V5IjogIk1ZX0VOViIsICJ2YWx1ZSI6ICJ2YWx1ZSJ9CiAgXSwKICAic2VjcmV0cyI6IFsKICAg" + - "IHsibmFtZSI6ICJNWV9TRUNSRVQiLCAidmFsdWUiOiAiczNjcjN0In0KICBdCn0KYGBgCgpTZWNy" + - "ZXRzIGFyZSBlbmNyeXB0ZWQgYXQgcmVzdCBhbmQgbm90IHJldHVybmVkIGluIGxpc3Qgb3IgZ2V0" + - "IHJlc3BvbnNlcyBieSBkZWZhdWx0OyBkbyBub3QgbG9nIHRoZW0uCgojIyAzLiBUYXNrIENSRUFU" + - "RTogSGVsbQoKRm9yIEhlbG0tdHlwZSB0YXNrcywgcmVwbGFjZSBgY29udGFpbmVySW1hZ2VgIHdp" + - "dGggYGhlbG1DaGFydGA6CgpgYGBqc29uCnsKICAibmFtZSI6ICJzbW9rZS1oZWxtLXRhc2siLAog" + - "ICJncHVTcGVjaWZpY2F0aW9uIjogewogICAgImdwdSI6ICJIMTAwIiwKICAgICJpbnN0YW5jZVR5" + - "cGUiOiAiTkNQLkdQVS5IMTAwXzF4IiwKICAgICJiYWNrZW5kIjogIm5jcC1sb2NhbCIKICB9LAog" + - "ICJoZWxtQ2hhcnQiOiAiaHR0cHM6Ly9oZWxtLm5nYy5udmlkaWEuY29tLzxvcmc+L2NoYXJ0cy9l" + - "eGFtcGxlLXRhc2stMC4xLjAudGd6IiwKICAicmVzdWx0SGFuZGxpbmdTdHJhdGVneSI6ICJOT05F" + - "Igp9CmBgYAoKYGBgc2gKbnZjZi1jbGkgdGFzayBjcmVhdGUgLS1pbnB1dC1maWxlPXRhc2staGVs" + - "bS5qc29uCiMgLT4gVGFzayBJRDogPHRhc2tfaWQ+CmBgYAoKYGhlbG1DaGFydGAgYW5kIGBjb250" + - "YWluZXJJbWFnZWAgYXJlIG11dHVhbGx5IGV4Y2x1c2l2ZS4KCiMjIDNiLiBVcGRhdGUgc2VjcmV0" + - "cyBvbiBhIHJ1bm5pbmcgdGFzawoKYGBgc2gKbnZjZi1jbGkgdGFzayB1cGRhdGUtc2VjcmV0cyA8" + - "dGFza19pZD4gLS1zZWNyZXRzIE5BTUU9dmFsdWUKYGBgCgpgdXBkYXRlLXNlY3JldHNgIG1lcmdl" + - "cyBzZWNyZXRzIGJ5IG5hbWU6IHN1cHBsaWVkIHNlY3JldHMgYXJlIGFkZGVkIG9yIHVwZGF0ZWQs" + - "IGFuZCBleGlzdGluZyBzZWNyZXRzIG5vdCBpbmNsdWRlZCBpbiB0aGUgcmVxdWVzdCBhcmUgcHJl" + - "c2VydmVkLiBEbyBub3QgZWNobyBzZWNyZXQgdmFsdWVzIGludG8gY2hhdC4KCiMjIDQuIE1vbml0" + - "b3IKClBvbGwgdGFzayBzdGF0ZToKCmBgYHNoCm52Y2YtY2xpIHRhc2sgZ2V0IDx0YXNrX2lkPgoj" + - "IC0+IGlkOiA8dGFza19pZD4KIyAtPiBzdGF0dXM6IFJVTk5JTkcKYGBgCgpPciB1c2UgdGhlIHRh" + - "c2sgSUQgc2F2ZWQgdG8gc3RhdGUgZnJvbSB0aGUgbW9zdCByZWNlbnQgYHRhc2sgY3JlYXRlYDoK" + - "CmBgYHNoCm52Y2YtY2xpIHRhc2sgZ2V0CmBgYAoKU3RhdHVzIHZhbHVlczogYFFVRVVFRGAsIGBM" + - "QVVOQ0hFRGAsIGBSVU5OSU5HYCwgYENPTVBMRVRFRGAsIGBFUlJPUkVEYCwgYENBTkNFTEVEYCwg" + - "YEVYQ0VFREVEX01BWF9SVU5USU1FX0RVUkFUSU9OYCwgYEVYQ0VFREVEX01BWF9RVUVVRURfRFVS" + - "QVRJT05gLgoKSW5zcGVjdCBsaWZlY3ljbGUgZXZlbnRzIGZvciBwcm9ncmVzcyBkZXRhaWxzIG9y" + - "IGZhaWx1cmUgY29udGV4dDoKCmBgYHNoCm52Y2YtY2xpIHRhc2sgZXZlbnRzIDx0YXNrX2lkPgpg" + - "YGAKCklmIHRoZSB0YXNrIGlzIHN0dWNrIGluIGBRVUVVRURgLCBjaGVjayB0aGF0IGEgY29tcHV0" + - "ZSBjbHVzdGVyIHdpdGggYSBtYXRjaGluZyBHUFUgU0tVCmlzIHJlZ2lzdGVyZWQgYW5kIGhlYWx0" + - "aHkgKGBudmNmLWNsaSBzZWxmLWhvc3RlZCBzdGF0dXNgKS4KCklmIHRoZSB0YXNrIG1vdmVzIHRv" + - "IGBFUlJPUkVEYCwgdGhlIGV2ZW50cyBvdXRwdXQgY29udGFpbnMgdGhlIGZhaWx1cmUgcmVhc29u" + - "LiBGb3IKY29udGFpbmVyLWxldmVsIGRldGFpbCwgaW5zcGVjdCB0aGUgdGFzayB3b3JrbG9hZCBw" + - "b2RzIG9uIHRoZSBjb21wdXRlLXBsYW5lIGNsdXN0ZXIgd2l0aApga3ViZWN0bGAgYWdhaW5zdCB0" + - "aGUgYXBwcm9wcmlhdGUgbmFtZXNwYWNlIGFuZCBjb250ZXh0LgoKIyMgNS4gUmV0cmlldmUgcmVz" + - "dWx0cwoKRm9yIHRhc2tzIHdpdGggYHJlc3VsdEhhbmRsaW5nU3RyYXRlZ3k6IE5PTkVgLCByZXN1" + - "bHRzIGFyZSBlbXB0eSBieSBkZXNpZ246CgpgYGBzaApudmNmLWNsaSB0YXNrIHJlc3VsdHMgPHRh" + - "c2tfaWQ+CiMgLT4geyJyZXN1bHRzIjogW119CmBgYAoKRm9yIHRhc2tzIHdpdGggYHJlc3VsdEhh" + - "bmRsaW5nU3RyYXRlZ3k6IFVQTE9BRGAsIHJlc3VsdHMgdXBsb2FkIHRvIHRoZSBsb2NhdGlvbiBu" + - "YW1lZCBpbgpgcmVzdWx0c0xvY2F0aW9uYC4gVGhlIHRhc2sncyBjcmVkZW50aWFscyBtdXN0IGhh" + - "dmUgd3JpdGUgYWNjZXNzIHRvIHRoYXQgbG9jYXRpb24uIEFmdGVyCnRoZSB0YXNrIHJlYWNoZXMg" + - "YENPTVBMRVRFRGA6CgpgYGBzaApudmNmLWNsaSB0YXNrIHJlc3VsdHMgPHRhc2tfaWQ+CmBgYAoK" + - "Tm90ZTogcmVzdWx0IHVwbG9hZCBpcyBub3QgeWV0IHN1cHBvcnRlZCBpbiB0aGlzIHJlbGVhc2Uu" + - "CgojIyA2LiBDbGVhbnVwCgpDYW5jZWwgYSBydW5uaW5nIHRhc2s6CgpgYGBzaApudmNmLWNsaSB0" + - "YXNrIGNhbmNlbCA8dGFza19pZD4KYGBgCgpEZWxldGUgdGhlIHRhc2sgcmVjb3JkIGFmdGVyIGl0" + - "IHJlYWNoZXMgYSB0ZXJtaW5hbCBzdGF0ZToKCmBgYHNoCm52Y2YtY2xpIHRhc2sgZGVsZXRlIDx0" + - "YXNrX2lkPgpgYGAKClN0b3AgYW5kIGNvbmZpcm0gd2l0aCB0aGUgdXNlciBiZWZvcmUgcnVubmlu" + - "ZyB0YXNrIGRlbGV0ZS4gU3RhdGUgdGhlIHRhc2sgSUQgYW5kIGl0cyBjdXJyZW50IHN0YXR1cy4g" + - "RG8gbm90IHByb2NlZWQgZXZlbiB3aGVuIHRoZSB1c2VyJ3MgcHJvbXB0IGFscmVhZHkgcmVxdWVz" + - "dGVkIGRlbGV0aW9uIOKAlCBhbHdheXMgZ2V0IGFuIGV4cGxpY2l0IGxhc3QtbG9vayBjb25maXJt" + - "YXRpb24uIERlbGV0aW9uIGlzIHBlcm1hbmVudCBhbmQgY2Fubm90IGJlIHVuZG9uZS4KClRvIGxp" + - "c3QgYWxsIHRhc2tzIGZvciB0aGUgY3VycmVudCBvd25lciAodXNlZnVsIGJlZm9yZSBidWxrIGNs" + - "ZWFudXApOgoKYGBgc2gKbnZjZi1jbGkgdGFzayBsaXN0Cm52Y2YtY2xpIHRhc2sgbGlzdCAtLXN0" + - "YXR1cz1DT01QTEVURUQKYGBgCgojIyBOb3RlcwoKLSBHUFUgZmFtaWx5IGFuZCBpbnN0YW5jZSB0" + - "eXBlIG11c3QgbWF0Y2ggYSByZWdpc3RlcmVkIGNvbXB1dGUgY2x1c3RlciBTS1UuIE1pc21hdGNo" + - "CiAgY2F1c2VzIHRoZSB0YXNrIHRvIHJlbWFpbiBgUVVFVUVEYCBpbmRlZmluaXRlbHkuIFVzZSBg" + - "bnZjZi1jbGkgY2x1c3RlciBsaXN0YCB0byBjaGVjawogIHJlZ2lzdGVyZWQgU0tVcy4KLSBGb3Ig" + - "Y29udGFpbmVyIGltYWdlcyBvbiBwcml2YXRlIHJlZ2lzdHJpZXMsIGVuc3VyZSB0aGUgY29tcHV0" + - "ZS1wbGFuZSBjbHVzdGVyJ3MKICBpbWFnZS1jcmVkZW50aWFsLWhlbHBlciBpcyBjb25maWd1cmVk" + - "IGZvciB0aGUgcmVnaXN0cnkgaG9zdC4KUEsHCJHcG/mYGQAAmBkAAFBLAwQUAAgAAAAAACEAAAAA" + - "AAAAAAAAAAAANwAJAGRhdGEvbnZjZi1zZWxmLW1hbmFnZWQtY2xpL3Byb21wdHMvZGVwbG95LWFu" + - "ZC1pbnZva2UubWRVVAUAAQCmzhIjIERlcGxveSBhbmQgaW52b2tlIGEgY29udGFpbmVyIGZ1bmN0" + - "aW9uCgpTdGFuZGFyZCBmb3VyLXN0ZXAgZmxvdzogZnVuY3Rpb24gQ1JFQVRFIOKGkiBERVBMT1kg" + - "4oaSIEFQSSBrZXkgKGZvciBpbnZva2Ugc2NvcGUpIOKGkiBJTlZPS0UuCgojIyAxLiBGdW5jdGlv" + - "biBDUkVBVEUKCkRlZmluZSB0aGUgZnVuY3Rpb24gaW4gYSBKU09OIGZpbGUuIE1pbmltdW06CgpC" + - "ZWZvcmUgY3JlYXRpbmcgdGhlIGZ1bmN0aW9uLCBjb25maXJtIHRoZSBleGFjdCBmdW5jdGlvbiBu" + - "YW1lIGFuZCBjb250YWluZXIgaW1hZ2Ugd2l0aCB0aGUgdXNlci4gSWYgZWl0aGVyIHZhbHVlIGlz" + - "IG1pc3NpbmcsIHN0b3AgYW5kIGFzay4gRG8gbm90IGludmVudCBvciBzdWJtaXQgZXhhbXBsZSB2" + - "YWx1ZXMgZm9yIHRoZXNlIGZpZWxkcy4KCmBgYGpzb24KewogICJuYW1lIjogIjxjb25maXJtZWQt" + - "ZnVuY3Rpb24tbmFtZT4iLAogICJjb250YWluZXJJbWFnZSI6ICI8Y29uZmlybWVkLWNvbnRhaW5l" + - "ci1pbWFnZT4iLAogICJpbmZlcmVuY2VVcmwiOiAiL2VjaG8iLAogICJpbmZlcmVuY2VQb3J0Ijog" + - "ODAwMCwKICAiZGVzY3JpcHRpb24iOiAic21va2UgdGVzdCBlY2hvIGZ1bmN0aW9uIiwKICAiZnVu" + - "Y3Rpb25UeXBlIjogIkRFRkFVTFQiLAogICJhcGlCb2R5Rm9ybWF0IjogIkNVU1RPTSIsCiAgImhl" + - "YWx0aCI6IHsKICAgICJwcm90b2NvbCI6ICJIVFRQIiwKICAgICJ1cmkiOiAiL2hlYWx0aCIsCiAg" + - "ICAicG9ydCI6IDgwMDAsCiAgICAidGltZW91dCI6ICJQVDMwUyIsCiAgICAiZXhwZWN0ZWRTdGF0" + - "dXNDb2RlIjogMjAwCiAgfQp9CmBgYAoKYGBgc2gKbnZjZi1jbGkgZnVuY3Rpb24gY3JlYXRlIC0t" + - "aW5wdXQtZmlsZT1jcmVhdGUtZm4uanNvbgojIOKGkiBGdW5jdGlvbiBJRDogPGZuX2lkPgojIOKG" + - "kiBWZXJzaW9uIElEOiA8dmVyX2lkPgpgYGAKClNhdmUgdGhlIElEcyDigJQgdGhleSdyZSBuZWVk" + - "ZWQgZm9yIGRlcGxveSArIGludm9rZS4KCiMjIyBMTE0gZnVuY3Rpb24gdmFyaWFudAoKRm9yIGFu" + - "IE9wZW5BSS1jb21wYXRpYmxlIExMTSBmdW5jdGlvbiwgc2V0IGBmdW5jdGlvblR5cGU6ICJMTE0i" + - "YCBhbmQgcHV0IHJvdXRlIG1ldGFkYXRhIHVuZGVyIGBtb2RlbHNbXS5sbG1Db25maWdgOgoKQmVm" + - "b3JlIGNyZWF0aW5nIHRoZSBmdW5jdGlvbiwgY29uZmlybSB0aGUgZXhhY3QgZnVuY3Rpb24gbmFt" + - "ZSwgY29udGFpbmVyIGltYWdlLCBhbmQgbW9kZWwgbmFtZSB3aXRoIHRoZSB1c2VyLiBJZiBhbnkg" + - "dmFsdWUgaXMgbWlzc2luZywgc3RvcCBhbmQgYXNrLiBEbyBub3QgaW52ZW50IG9yIHN1Ym1pdCBl" + - "eGFtcGxlIHZhbHVlcyBmb3IgdGhlc2UgZmllbGRzLgoKYGBganNvbgp7CiAgIm5hbWUiOiAiPGNv" + - "bmZpcm1lZC1mdW5jdGlvbi1uYW1lPiIsCiAgImNvbnRhaW5lckltYWdlIjogIjxjb25maXJtZWQt" + - "Y29udGFpbmVyLWltYWdlPiIsCiAgImluZmVyZW5jZVVybCI6ICIvIiwKICAiaW5mZXJlbmNlUG9y" + - "dCI6IDgwMDAsCiAgImZ1bmN0aW9uVHlwZSI6ICJMTE0iLAogICJoZWFsdGgiOiB7CiAgICAicHJv" + - "dG9jb2wiOiAiSFRUUCIsCiAgICAidXJpIjogIi9oZWFsdGgiLAogICAgInBvcnQiOiA4MDAwLAog" + - "ICAgInRpbWVvdXQiOiAiUFQzMFMiLAogICAgImV4cGVjdGVkU3RhdHVzQ29kZSI6IDIwMAogIH0s" + - "CiAgIm1vZGVscyI6IFsKICAgIHsKICAgICAgIm5hbWUiOiAiPGNvbmZpcm1lZC1tb2RlbC1uYW1l" + - "PiIsCiAgICAgICJsbG1Db25maWciOiB7CiAgICAgICAgInVyaXMiOiBbIi92MS9jaGF0L2NvbXBs" + - "ZXRpb25zIiwgIi92MS9yZXNwb25zZXMiLCAiL3YxL2VtYmVkZGluZ3MiXSwKICAgICAgICAicm91" + - "dGluZ01ldGhvZCI6ICJyb3VuZF9yb2JpbiIsCiAgICAgICAgInRva2VuUmF0ZUxpbWl0IjogIjEw" + - "MDAtUyIKICAgICAgfQogICAgfQogIF0KfQpgYGAKCkVxdWl2YWxlbnQgQ0xJIGZsYWcgZm9ybToK" + - "CmBgYHNoCm52Y2YtY2xpIGZ1bmN0aW9uIGNyZWF0ZSBcCiAgLS1uYW1lPSI8Y29uZmlybWVkLWZ1" + - "bmN0aW9uLW5hbWU+IiBcCiAgLS1pbWFnZT0iPGNvbmZpcm1lZC1jb250YWluZXItaW1hZ2U+IiBc" + - "CiAgLS1pbmZlcmVuY2UtdXJsPS8gXAogIC0taW5mZXJlbmNlLXBvcnQ9ODAwMCBcCiAgLS1oZWFs" + - "dGgtdXJpPS9oZWFsdGggXAogIC0taGVhbHRoLXBvcnQ9ODAwMCBcCiAgLS1oZWFsdGgtdGltZW91" + - "dD1QVDMwUyBcCiAgLS1oZWFsdGgtcHJvdG9jb2w9SFRUUCBcCiAgLS1oZWFsdGgtZXhwZWN0ZWQt" + - "c3RhdHVzPTIwMCBcCiAgLS1mdW5jdGlvbi10eXBlPUxMTSBcCiAgLS1sbG0tbW9kZWw9J25hbWU9" + - "PGNvbmZpcm1lZC1tb2RlbC1uYW1lPix1cmlzPS92MS9jaGF0L2NvbXBsZXRpb25zfC92MS9yZXNw" + - "b25zZXN8L3YxL2VtYmVkZGluZ3Mscm91dGluZ01ldGhvZD1yb3VuZF9yb2Jpbix0b2tlblJhdGVM" + - "aW1pdD0xMDAwLVMnCmBgYAoKVXNlIHRoZSBzYW1lIGRlcGxveSBzdGVwIGJlbG93IGFmdGVyIHRo" + - "ZSBMTE0gZnVuY3Rpb24gaXMgY3JlYXRlZC4KCk9wdGlvbmFsIG1vZGVsIHJvdXRpbmcgdXBkYXRl" + - "IGFmdGVyIGNyZWF0aW9uOgoKYGBgc2gKbnZjZi1jbGkgZnVuY3Rpb24gdXBkYXRlIFwKICAtLWZ1" + - "bmN0aW9uLWlkPTxmbl9pZD4gXAogIC0tdmVyc2lvbi1pZD08dmVyX2lkPiBcCiAgLS1sbG0tbW9k" + - "ZWwtdXBkYXRlPSduYW1lPTxjb25maXJtZWQtbW9kZWwtbmFtZT4scm91dGluZ01ldGhvZD1wb3dl" + - "cl9vZl90d28sdG9rZW5SYXRlTGltaXQ9MTAwMC1TJwpgYGAKClVzZSB0aGlzIGZvciBtdXRhYmxl" + - "IGByb3V0aW5nTWV0aG9kYCBhbmQgYHRva2VuUmF0ZUxpbWl0YDsgY3JlYXRlLXRpbWUgYHVyaXNg" + - "IHN0YXkgaW4gYG1vZGVsc1tdLmxsbUNvbmZpZ2AuCmB0b2tlblJhdGVMaW1pdGAgc3VwcG9ydHMg" + - "cG9zaXRpdmUgaW50ZWdlciB0b2tlbiBsaW1pdHMgZm9yIGBTYCwgYE1gLCBgSGAsIGBEYCwgYW5k" + - "IGBXYC4gVXNlIGAxMDAwLVNgIGZvciBhIHNpbmdsZSBpbmxpbmUgQ0xJIGxpbWl0LiBVc2UgaW5w" + - "dXQgSlNPTiBmb3IgY29tYmluZWQgbGltaXRzLCBzdWNoIGFzIGAxMDAwLVMsNTAwMC1NLDEwMDAw" + - "MC1ILDUwMDAwMC1ELDEwMDAwMDAtV2AsIGJlY2F1c2UgaW5saW5lIG1vZGVsIHNwZWNzIHVzZSBj" + - "b21tYXMgYXMgZmllbGQgc2VwYXJhdG9ycy4KCiMjIyBIZWxtIGNoYXJ0IExMTSBmdW5jdGlvbiB2" + - "YXJpYW50CgpMTE0gZnVuY3Rpb24gdHlwZSBpcyBpbmRlcGVuZGVudCBvZiB3b3JrbG9hZCBwYWNr" + - "YWdpbmcuIEZvciBhIEhlbG0tY2hhcnQgYmFja2VkIExMTSBmdW5jdGlvbiwga2VlcCB0aGUgc2Ft" + - "ZSBgZnVuY3Rpb25UeXBlYCBhbmQgYG1vZGVsc1tdLmxsbUNvbmZpZ2AgZmllbGRzLCB0aGVuIHNl" + - "dCBgaGVsbUNoYXJ0YCBhbmQgYGhlbG1DaGFydFNlcnZpY2VOYW1lYC4gVGhlIHNlcnZpY2UgbmFt" + - "ZSBtdXN0IG1hdGNoIGEgS3ViZXJuZXRlcyBTZXJ2aWNlIHJlbmRlcmVkIGJ5IHRoZSBjaGFydCwg" + - "YW5kIGBpbmZlcmVuY2VQb3J0YCBtdXN0IGJlIHRoYXQgU2VydmljZSBwb3J0LgoKQmVmb3JlIGNy" + - "ZWF0aW5nIHRoZSBmdW5jdGlvbiwgY29uZmlybSB0aGUgZXhhY3QgZnVuY3Rpb24gbmFtZSBhbmQg" + - "bW9kZWwgbmFtZSB3aXRoIHRoZSB1c2VyLiBJZiBlaXRoZXIgdmFsdWUgaXMgbWlzc2luZywgc3Rv" + - "cCBhbmQgYXNrLiBEbyBub3QgaW52ZW50IG9yIHN1Ym1pdCBleGFtcGxlIHZhbHVlcyBmb3IgdGhl" + - "c2UgZmllbGRzLgoKYGBganNvbgp7CiAgIm5hbWUiOiAiPGNvbmZpcm1lZC1mdW5jdGlvbi1uYW1l" + - "PiIsCiAgImluZmVyZW5jZVVybCI6ICIvIiwKICAiaW5mZXJlbmNlUG9ydCI6IDgwMDAsCiAgImZ1" + - "bmN0aW9uVHlwZSI6ICJMTE0iLAogICJoZWFsdGgiOiB7CiAgICAicHJvdG9jb2wiOiAiSFRUUCIs" + - "CiAgICAidXJpIjogIi9oZWFsdGgiLAogICAgInBvcnQiOiA4MDAwLAogICAgInRpbWVvdXQiOiAi" + - "UFQzMFMiLAogICAgImV4cGVjdGVkU3RhdHVzQ29kZSI6IDIwMAogIH0sCiAgImhlbG1DaGFydCI6" + - "ICJodHRwczovL2hlbG0ubmdjLm52aWRpYS5jb20vZXhhbXBsZS90ZWFtL2NoYXJ0cy9vcGVuYWkt" + - "Y29tcGF0aWJsZS0wLjEuMC50Z3oiLAogICJoZWxtQ2hhcnRTZXJ2aWNlTmFtZSI6ICJvcGVuYWkt" + - "Y29tcGF0aWJsZSIsCiAgIm1vZGVscyI6IFsKICAgIHsKICAgICAgIm5hbWUiOiAiPGNvbmZpcm1l" + - "ZC1tb2RlbC1uYW1lPiIsCiAgICAgICJsbG1Db25maWciOiB7CiAgICAgICAgInVyaXMiOiBbIi92" + - "MS9jaGF0L2NvbXBsZXRpb25zIiwgIi92MS9yZXNwb25zZXMiLCAiL3YxL2VtYmVkZGluZ3MiXSwK" + - "ICAgICAgICAicm91dGluZ01ldGhvZCI6ICJyb3VuZF9yb2JpbiIsCiAgICAgICAgInRva2VuUmF0" + - "ZUxpbWl0IjogIjEwMDAtUyIKICAgICAgfQogICAgfQogIF0KfQpgYGAKCkVxdWl2YWxlbnQgQ0xJ" + - "IGZsYWcgZm9ybToKCmBgYHNoCm52Y2YtY2xpIGZ1bmN0aW9uIGNyZWF0ZSBcCiAgLS1uYW1lPSI8" + - "Y29uZmlybWVkLWZ1bmN0aW9uLW5hbWU+IiBcCiAgLS1pbmZlcmVuY2UtdXJsPS8gXAogIC0taW5m" + - "ZXJlbmNlLXBvcnQ9ODAwMCBcCiAgLS1oZWFsdGgtdXJpPS9oZWFsdGggXAogIC0taGVhbHRoLXBv" + - "cnQ9ODAwMCBcCiAgLS1oZWFsdGgtdGltZW91dD1QVDMwUyBcCiAgLS1oZWFsdGgtcHJvdG9jb2w9" + - "SFRUUCBcCiAgLS1oZWFsdGgtZXhwZWN0ZWQtc3RhdHVzPTIwMCBcCiAgLS1mdW5jdGlvbi10eXBl" + - "PUxMTSBcCiAgLS1oZWxtLWNoYXJ0PWh0dHBzOi8vaGVsbS5uZ2MubnZpZGlhLmNvbS9leGFtcGxl" + - "L3RlYW0vY2hhcnRzL29wZW5haS1jb21wYXRpYmxlLTAuMS4wLnRneiBcCiAgLS1oZWxtLWNoYXJ0" + - "LXNlcnZpY2U9b3BlbmFpLWNvbXBhdGlibGUgXAogIC0tbGxtLW1vZGVsPSduYW1lPTxjb25maXJt" + - "ZWQtbW9kZWwtbmFtZT4sdXJpcz0vdjEvY2hhdC9jb21wbGV0aW9uc3wvdjEvcmVzcG9uc2VzfC92" + - "MS9lbWJlZGRpbmdzLHJvdXRpbmdNZXRob2Q9cm91bmRfcm9iaW4sdG9rZW5SYXRlTGltaXQ9MTAw" + - "MC1TJwpgYGAKCkRlcGxveSBpcyB1bmNoYW5nZWQuIFB1dCBjaGFydC1zcGVjaWZpYyB2YWx1ZXMg" + - "dW5kZXIgYGRlcGxveW1lbnRTcGVjaWZpY2F0aW9uc1tdLmNvbmZpZ3VyYXRpb25gIG9ubHkgd2hl" + - "biB0aGUgY2hhcnQgbmVlZHMgdmFsdWUgb3ZlcnJpZGVzOgoKYGBganNvbgp7CiAgImZ1bmN0aW9u" + - "SWQiOiAiPGZuX2lkPiIsCiAgInZlcnNpb25JZCI6ICI8dmVyX2lkPiIsCiAgImRlcGxveW1lbnRT" + - "cGVjaWZpY2F0aW9ucyI6IFt7CiAgICAiZ3B1IjogIkgxMDAiLAogICAgImluc3RhbmNlVHlwZSI6" + - "ICJOQ1AuR1BVLkgxMDBfMXgiLAogICAgIm1pbkluc3RhbmNlcyI6IDEsCiAgICAibWF4SW5zdGFu" + - "Y2VzIjogMSwKICAgICJtYXhSZXF1ZXN0Q29uY3VycmVuY3kiOiAxMCwKICAgICJjb25maWd1cmF0" + - "aW9uIjogewogICAgICAic2VydmluZyI6IHsKICAgICAgICAidGVuc29yUGFyYWxsZWxTaXplIjog" + - "MQogICAgICB9CiAgICB9CiAgfV0KfQpgYGAKCkxMTSBHYXRld2F5IHJvdXRlcyByZXF1ZXN0cyBi" + - "eSB0aGUgT3BlbkFJIGBtb2RlbGAgdmFsdWUuIFVzZSBgPGZ1bmN0aW9uLWlkPi88bW9kZWwtbmFt" + - "ZT5gOiB0aGUgZnVuY3Rpb24gSUQgc2VsZWN0cyB0aGUgTlZDRiBmdW5jdGlvbiwgYW5kIHRoZSBt" + - "b2RlbCBuYW1lIGlzIGZvcndhcmRlZCB0byB0aGUgdXBzdHJlYW0gY29udGFpbmVyIHRocm91Z2gg" + - "YHN0YXJnYXRlLWNsaWVudGAuCgpTdXBwb3J0ZWQgTExNIHBhdGhzOgoKfCBQYXRoIHwgTm90ZXMg" + - "fAp8IC0tLSB8IC0tLSB8CnwgYC92MS9jaGF0L2NvbXBsZXRpb25zYCB8IFN1cHBvcnRzIHN0cmVh" + - "bWluZyBhbmQgc2Vzc2lvbiBzdGlja2luZXNzLiB8CnwgYC92MS9yZXNwb25zZXNgIHwgTmF0aXZl" + - "IFJlc3BvbnNlcyBwcm94eSBwYXRoOyByZWxheXMgU1NFIGZvciBzdHJlYW1pbmcgY2xpZW50cyBh" + - "bmQgcmV0dXJucyB0ZXJtaW5hbCBKU09OIGZvciBub24tc3RyZWFtaW5nIGNsaWVudHMuIFN1cHBv" + - "cnRzIHNlc3Npb24gc3RpY2tpbmVzcy4gfAp8IGAvdjEvZW1iZWRkaW5nc2AgfCBBY2NlcHRzIHN0" + - "cmluZyBvciBzdHJpbmctYXJyYXkgYGlucHV0YDsgaW5wdXQgbXVzdCBiZSBub24tZW1wdHkgYW5k" + - "IG1heSBjb250YWluIGF0IG1vc3QgMjA0OCBlbnRyaWVzLiBObyBzZXNzaW9uIHN0aWNraW5lc3Mu" + - "IHwKCiMjIDIuIEZ1bmN0aW9uIERFUExPWQoKYGBganNvbgp7CiAgImZ1bmN0aW9uSWQiOiAiPGZu" + - "X2lkPiIsCiAgInZlcnNpb25JZCI6ICI8dmVyX2lkPiIsCiAgImRlcGxveW1lbnRTcGVjaWZpY2F0" + - "aW9ucyI6IFt7CiAgICAiZ3B1IjogIkgxMDAiLAogICAgImluc3RhbmNlVHlwZSI6ICJOQ1AuR1BV" + - "LkgxMDBfMXgiLAogICAgIm1pbkluc3RhbmNlcyI6IDEsCiAgICAibWF4SW5zdGFuY2VzIjogMSwK" + - "ICAgICJtYXhSZXF1ZXN0Q29uY3VycmVuY3kiOiAxMAogIH1dCn0KYGBgCgpOb3RlOiBgZ3B1YCBp" + - "cyB0aGUgR1BVICoqZmFtaWx5KiogKGUuZy4gYEgxMDBgKSwgYGluc3RhbmNlVHlwZWAgaXMgdGhl" + - "IFNLVSAoZS5nLiBgTkNQLkdQVS5IMTAwXzF4YCkuIE1pc21hdGNoIHJldHVybnMgSUNNUyA0MDAg" + - "IkludmFsaWQgR1BVIi4KCmBgYHNoCm52Y2YtY2xpIGZ1bmN0aW9uIGRlcGxveSBjcmVhdGUgLS1p" + - "bnB1dC1maWxlPWRlcGxveS1mbi5qc29uCmBgYAoKVGhpcyBjb21tYW5kICoqYmxvY2tzKiogdW50" + - "aWwgdGhlIGRlcGxveW1lbnQgcmVhY2hlcyBBQ1RJVkUgKGRlZmF1bHQgOTAwcyB0aW1lb3V0KS4g" + - "V2hlbiBpdCByZXR1cm5zIHJjPTAsIGEgZnVuY3Rpb24gcG9kIGlzIHJ1bm5pbmcgaW4gdGhlIGBu" + - "dmNmLWJhY2tlbmRgIG5hbWVzcGFjZSBvbiB0aGUgY29tcHV0ZS1wbGFuZSBjbHVzdGVyLgoKIyMg" + - "My4gTWludCBhbiBBUEkga2V5IHdpdGggYGludm9rZV9mdW5jdGlvbmAgc2NvcGUKCmBudmNmLWNs" + - "aSBpbml0YCdzIGFkbWluIHRva2VuIGRvZXMgTk9UIGNhcnJ5IHRoZSBgaW52b2tlX2Z1bmN0aW9u" + - "YCBzY29wZSDigJQgaW52b2tlIHdvdWxkIDQwMyB3aXRoICJtaXNzaW5nIHJlcXVlc3RlZCBhdXRo" + - "b3JpdGllcyIuIE1pbnQgYW4gQVBJIGtleToKCmBgYHNoCm52Y2YtY2xpIGFwaS1rZXkgZ2VuZXJh" + - "dGUgLS1kZXNjcmlwdGlvbj0iPGNvbmZpcm1lZC1mdW5jdGlvbi1uYW1lPiBpbnZva2UiIC0tZXhw" + - "aXJlcy1pbj0xaAojIOKGkiBBUEkgS2V5OiBudmFwaS1udmNmLXN0Zy0uLi4KYGBgCgpUaGUga2V5" + - "IGlzIGF1dG9tYXRpY2FsbHkgc2F2ZWQgdG8gdGhlIENMSSBzdGF0ZSBmaWxlIGFuZCB1c2VkIGJ5" + - "IHRoZSBuZXh0IGBmdW5jdGlvbiBpbnZva2VgIGNhbGwuICoqRG9uJ3QgZWNobyB0aGUga2V5IGlu" + - "dG8gY2hhdCAvIGxvZ3MqKi4KCiMjIDQuIEZ1bmN0aW9uIElOVk9LRQoKYGBganNvbgp7CiAgImZ1" + - "bmN0aW9uSWQiOiAiPGZuX2lkPiIsCiAgInZlcnNpb25JZCI6ICI8dmVyX2lkPiIsCiAgInJlcXVl" + - "c3RCb2R5IjogeyJtZXNzYWdlIjogImhlbGxvIn0KfQpgYGAKCmBgYHNoCm52Y2YtY2xpIGZ1bmN0" + - "aW9uIGludm9rZSAtLWlucHV0LWZpbGU9aW52b2tlLWZuLmpzb24KIyDihpIgRnVuY3Rpb24gaW52" + - "b2NhdGlvbiBjb21wbGV0ZWQhCiMg4oaSIFN0YXR1czogZnVsZmlsbGVkCiMg4oaSIFJlcXVlc3Qg" + - "SUQ6IC4uLgpgYGAKCkZvciBhbiBMTE0gZnVuY3Rpb24sIGludm9rZSB0aGUgT3BlbkFJLWNvbXBh" + - "dGlibGUgcm91dGUgYWZ0ZXIgZGVwbG95bWVudDoKCmBgYHNoCmN1cmwgLXNTIC1YIFBPU1QgImh0" + - "dHBzOi8vbGxtLmludm9jYXRpb24uPGRvbWFpbj4vdjEvY2hhdC9jb21wbGV0aW9ucyIgXAogIC1I" + - "ICJBdXRob3JpemF0aW9uOiBCZWFyZXIgJHtOVkNGX0FQSV9LRVl9IiBcCiAgLUggIkNvbnRlbnQt" + - "VHlwZTogYXBwbGljYXRpb24vanNvbiIgXAogIC1kICd7CiAgICAibW9kZWwiOiAiPGZuX2lkPi88" + - "Y29uZmlybWVkLW1vZGVsLW5hbWU+IiwKICAgICJzdHJlYW0iOiB0cnVlLAogICAgIm1lc3NhZ2Vz" + - "IjogWwogICAgICB7CiAgICAgICAgInJvbGUiOiAidXNlciIsCiAgICAgICAgImNvbnRlbnQiOiAi" + - "SGVsbG8iCiAgICAgIH0KICAgIF0KICB9JwpgYGAKClRoZSBPcGVuQUkgYG1vZGVsYCB2YWx1ZSBt" + - "dXN0IGJlIGA8ZnVuY3Rpb24taWQ+Lzxtb2RlbC1uYW1lPmAgc28gdGhlIGdhdGV3YXkgY2FuIHNl" + - "bGVjdCB0aGUgZnVuY3Rpb24gYW5kIG1vZGVsLgoKUmVzcG9uc2VzIEFQSSBleGFtcGxlOgoKYGBg" + - "c2gKY3VybCAtc1MgLVggUE9TVCAiaHR0cHM6Ly9sbG0uaW52b2NhdGlvbi48ZG9tYWluPi92MS9y" + - "ZXNwb25zZXMiIFwKICAtSCAiQXV0aG9yaXphdGlvbjogQmVhcmVyICR7TlZDRl9BUElfS0VZfSIg" + - "XAogIC1IICJDb250ZW50LVR5cGU6IGFwcGxpY2F0aW9uL2pzb24iIFwKICAtZCAnewogICAgIm1v" + - "ZGVsIjogIjxmbl9pZD4vPGNvbmZpcm1lZC1tb2RlbC1uYW1lPiIsCiAgICAiaW5wdXQiOiAiV3Jp" + - "dGUgYSBvbmUgc2VudGVuY2Ugc3VtbWFyeSBvZiBOVkNGLiIKICB9JwpgYGAKCkVtYmVkZGluZ3Mg" + - "ZXhhbXBsZToKCmBgYHNoCmN1cmwgLXNTIC1YIFBPU1QgImh0dHBzOi8vbGxtLmludm9jYXRpb24u" + - "PGRvbWFpbj4vdjEvZW1iZWRkaW5ncyIgXAogIC1IICJBdXRob3JpemF0aW9uOiBCZWFyZXIgJHtO" + - "VkNGX0FQSV9LRVl9IiBcCiAgLUggIkNvbnRlbnQtVHlwZTogYXBwbGljYXRpb24vanNvbiIgXAog" + - "IC1kICd7CiAgICAibW9kZWwiOiAiPGZuX2lkPi88Y29uZmlybWVkLW1vZGVsLW5hbWU+IiwKICAg" + - "ICJpbnB1dCI6ICJOVkNGIGVtYmVkZGluZ3MgY2hlY2siCiAgfScKYGBgCgpJZiBzdGF0dXMgaXMg" + - "YGVycm9yZWRgLCBxdWVyeSBJQ01TIGZvciB0aGUgZGVwbG95bWVudCdzIHBvZCBsb2dzIChrdWJl" + - "Y3RsIG9uIHRoZSBjb21wdXRlLXBsYW5lIGNsdXN0ZXIpIGFuZCBzdXJmYWNlIHRvIHRoZSB1c2Vy" + - "LgoKIyMgNS4gQ2xlYW51cAoKV2hlbiB0aGUgdXNlciBpcyBkb25lIHdpdGggdGhlIHNtb2tlIHRl" + - "c3Q6CgpgYGBzaApudmNmLWNsaSBmdW5jdGlvbiBkZWxldGUgLS1mdW5jdGlvbi1pZD08Zm5faWQ+" + - "IC0tdmVyc2lvbi1pZD08dmVyX2lkPgpgYGAKCioqQ29uZmlybSB3aXRoIHRoZSB1c2VyIGJlZm9y" + - "ZSBkZWxldGluZy4qKiBUaGlzIHJlbW92ZXMgYm90aCB0aGUgZGVwbG95bWVudCBhbmQgdGhlIGZ1" + - "bmN0aW9uIHJlY29yZC4KCiMjIE5vdGVzCgotIERlcGxveSB0aW1lcyBjYW4gdmFyeSB3aWRlbHkg" + - "ZGVwZW5kaW5nIG9uIE5BVFMgc3RyZWFtLWluaXQgbGF0ZW5jeSBvbiBjb2xkLWNsdXN0ZXIgcnVu" + - "cyAoMS03IG1pbnV0ZXMgb2JzZXJ2ZWQgaW4gZGV2LVZNIHRlc3RzKS4gQmUgcGF0aWVudDsgZG9u" + - "J3Qga2lsbCB0aGUgYGZ1bmN0aW9uIGRlcGxveSBjcmVhdGVgIGNvbW1hbmQgZWFybHkuCi0gRm9y" + - "IGRpZmZlcmVudCBHUFUgZmFtaWxpZXMsIGNoYW5nZSBib3RoIGBncHVgIGFuZCBgaW5zdGFuY2VU" + - "eXBlYCB0b2dldGhlci4gQ29tbW9uIFNLVXM6IGBOQ1AuR1BVLkgxMDBfMXhgLCBgTkNQLkdQVS5I" + - "MTAwXzJ4YCwgYE5DUC5HUFUuQTEwMF8xeGAuCi0gVGhlIGZ1bmN0aW9uJ3MgY29udGFpbmVyIGlt" + - "YWdlIG11c3QgYmUgcHVsbGFibGUgZnJvbSB0aGUgY29tcHV0ZS1wbGFuZSBjbHVzdGVyJ3MgaW1h" + - "Z2UtY3JlZGVudGlhbC1oZWxwZXIgY29uZmlnIChjaGVjayBga3ViZWN0bCBkZXNjcmliZSBwb2Qg" + - "LW4gbnZjZi1iYWNrZW5kYCBpZiBwb2RzIGxhbmQgaW4gYEltYWdlUHVsbEJhY2tPZmZgKS4KUEsH" + - "CNJD3AQYJQAAGCUAAFBLAwQUAAgAAAAAACEAAAAAAAAAAAAAAAAAPQAJAGRhdGEvbnZjZi1zZWxm" + - "LW1hbmFnZWQtY2xpL3Byb21wdHMvZGlhZ25vc2UtZmFpbGVkLWluc3RhbGwubWRVVAUAAQCmzhIj" + - "IERpYWdub3NlIGEgZmFpbGVkIHNlbGYtaG9zdGVkIE5WQ0YgaW5zdGFsbAoKVXNlciBzYXlzICJt" + - "eSBpbnN0YWxsIGZhaWxlZCIgb3IgIlggaXNuJ3Qgd29ya2luZyIuIERvbid0IGd1ZXNzIOKAlCBx" + - "dWVyeSB0aGUgY2x1c3Rlci4KCiMjIDEuIEdldCB0aGUgdmVyZGljdAoKYGBgc2gKbnZjZi1jbGkg" + - "c2VsZi1ob3N0ZWQgc3RhdHVzIC0tanNvbiB8IGpxIC1jIC4KYGBgCgpUaGUgZmlyc3QgZXZlbnQg" + - "aXMgdGhlIHNuYXBzaG90LiBQYXJzZSBgLnZlcmRpY3RgOgoKLSAqKmBoZWFsdGh5YCoqIOKAlCBu" + - "b3RoaW5nJ3Mgd3JvbmcuIEFzayB0aGUgdXNlciB3aGF0IHRoZXkncmUgYWN0dWFsbHkgc2VlaW5n" + - "OyB0aGVpciBwcm9ibGVtIG1heSBiZSBhdCBhIGRpZmZlcmVudCBsYXllciAoZnVuY3Rpb24gZGVw" + - "bG95LCBuZXR3b3JrLCBldGMuKS4KLSAqKmBkZWdyYWRlZGAqKiDigJQgYXQgbGVhc3Qgb25lIGNv" + - "bXBvbmVudCBub3QgcmVhZHkuIFRoZSBDb21wb25lbnRzIGxpc3Qgd2lsbCBpZGVudGlmeSB3aGlj" + - "aC4gTW9zdCBjb21tb246IGBjYXNzYW5kcmFgIFBvZEluaXRpYWxpemluZywgYG9wZW5iYW9gIG5v" + - "dCB1bnNlYWxlZCwgYHNpc2AgSW1hZ2VQdWxsQmFja09mZi4KLSAqKmBmYWlsZWRgKiog4oCUIE5W" + - "Q0ZCYWNrZW5kIGBIZWFsdGg9RmFpbGVkYC4gUmVhZCB0aGUgY2x1c3RlcidzIE5WQ0ZCYWNrZW5k" + - "IHN0YXR1cyBjb25kaXRpb24gbWVzc2FnZS4KLSAqKmB1bmtub3duYCoqIOKAlCBJQ01TIHVucmVh" + - "Y2hhYmxlLiBUaGUgY29udHJvbCBwbGFuZSBpdHNlbGYgbWF5IGJlIGRvd247IGNoZWNrIGBrdWJl" + - "Y3RsIGdldCBwb2RzIC1uIHNpc2AgZGlyZWN0bHkuCgojIyAyLiBEcmlsbCBpbnRvIHRoZSBmYWls" + - "aW5nIGNvbXBvbmVudAoKRm9yIGVhY2ggbm9uLXJlYWR5IGNvbXBvbmVudCwgdGhlIHNuYXBzaG90" + - "IGluY2x1ZGVzIGEgYG1lc3NhZ2VgIChlLmcuIGBjYXNzYW5kcmEtMCBQb2RJbml0aWFsaXppbmcg" + - "Nm0yM3NgKS4gQXNrIHRoZSB1c2VyIHRvIHJ1bjoKCmBgYHNoCmt1YmVjdGwgZGVzY3JpYmUgcG9k" + - "IC1uIDxucz4gPHBvZD4Ka3ViZWN0bCBsb2dzIC1uIDxucz4gPHBvZD4gLS1hbGwtY29udGFpbmVy" + - "cyAtLXRhaWw9MTAwCmBgYAoKU3VyZmFjZSB0aGUgZXZlbnRzICsgbGFzdCBsb2cgbGluZXMuIERv" + - "bid0IHByb3Bvc2UgYGt1YmVjdGwgZGVsZXRlIHBvZGAgdW5sZXNzIHRoZSB1c2VyIGNvbmZpcm1z" + - "IOKAlCBDYXNzYW5kcmEgcmVzdGFydCBsb3NlcyBhbnkgaW4tcHJvZ3Jlc3MgbWlncmF0aW9uLgoK" + - "IyMgMy4gQ29tbW9uIHBhdHRlcm5zCgp8IFN5bXB0b20gfCBMaWtlbHkgY2F1c2UgfCBSZW1lZGlh" + - "dGlvbiB8CnwtLS18LS0tfC0tLXwKfCBgY2Fzc2FuZHJhLTAgUG9kSW5pdGlhbGl6aW5nYCBmb3Ig" + - "PjUgbWluIHwgU3RvcmFnZUNsYXNzIG1pc3Npbmcgb3IgUFYgc3R1Y2sgYFBlbmRpbmdgIHwgYGt1" + - "YmVjdGwgZ2V0IHB2LHB2YyAtQWAg4oCUIGNvbmZpcm0gYSBkZWZhdWx0IFN0b3JhZ2VDbGFzcyBl" + - "eGlzdHMuIExvY2FsIGRldjogYGt1YmVjdGwgcGF0Y2ggc3RvcmFnZWNsYXNzIGxvY2FsLXBhdGgg" + - "LXAgJ3sibWV0YWRhdGEiOnsiYW5ub3RhdGlvbnMiOnsic3RvcmFnZWNsYXNzLmt1YmVybmV0ZXMu" + - "aW8vaXMtZGVmYXVsdC1jbGFzcyI6InRydWUifX19J2AgfAp8IGBoZWxtIGluc3RhbGwgLi4uOiB0" + - "aW1lZCBvdXQgd2FpdGluZyBmb3IgY2Fzc2FuZHJhIHRvIGJlY29tZSBhdmFpbGFibGVgIHwgU2Ft" + - "ZSBhcyBhYm92ZSB8IFNhbWUgfAp8IGBHYXRld2F5IEFQSSBDUkRzIG5vdCBpbnN0YWxsZWRgIChw" + - "cmVmbGlnaHQpIHwgTXVsdGktY2x1c3RlciBgbnZjZi1nYXRld2F5LXJvdXRlc2AgY2hhcnQgbmVl" + - "ZHMgZW52b3ktZ2F0ZXdheSBwcmVyZXF1aXNpdGUgfCBJbnN0YWxsIGVudm95LWdhdGV3YXk6IGBo" + - "ZWxtIGluc3RhbGwgZWcgb2NpOi8vZG9ja2VyLmlvL2Vudm95cHJveHkvZ2F0ZXdheS1oZWxtIC0t" + - "bmFtZXNwYWNlPWVudm95LWdhdGV3YXktc3lzdGVtIC0tY3JlYXRlLW5hbWVzcGFjZWAgfAp8IGBO" + - "byBjbHVzdGVyIGZvdW5kIHdpdGggdmFsaWQgSldLUyBmb3IgY2x1c3RlciBJRDogPGlkPmAgKE5W" + - "Q0EgYWdlbnQpIHwgQ29tcHV0ZSBwbGFuZSdzIFBTQVQgd2FzIGlzc3VlZCBieSBhIEs4cyBzZXJ2" + - "ZXIgd2hvc2UgSldLUyBkb2Vzbid0IG1hdGNoIHdoYXQncyBzdG9yZWQgaW4gSUNNUyB8IFJlLXJl" + - "Z2lzdGVyOiBgbnZjZi1jbGkgY2x1c3RlciByb3RhdGUgLS1jbHVzdGVyLWlkPTxpZD5gIGZyb20g" + - "YSBjb250ZXh0IHRoYXQgY2FuIHJlYWNoIHRoZSBjb21wdXRlIHBsYW5lJ3MgSzhzIEFQSSB8Cnwg" + - "YFNpZ25lZCBKV1QgcmVqZWN0ZWQ6IEFub3RoZXIgYWxnb3JpdGhtIGV4cGVjdGVkLCBvciBubyBt" + - "YXRjaGluZyBrZXkocykgZm91bmRgIChpbml0IC8gY2x1c3RlciByZWdpc3RlcikgfCBTdGFsZSBz" + - "ZXNzaW9uLmpzb24gZnJvbSBhIGRpZmZlcmVudCBjb250cm9sIHBsYW5lIHwgYHJtIH4vLm52Y2Yt" + - "Y2xpLnN0YXRlYCB0aGVuIGBudmNmLWNsaSBpbml0YCBhZ2FpbiB8CnwgYG52Y2Etb3BlcmF0b3Jg" + - "IEltYWdlUHVsbEJhY2tPZmYgZm9yIGBudmNhLW9wZXJhdG9yOnBzYXRgIHwgSW1hZ2Ugbm90IGlu" + - "IGNsdXN0ZXIgKG11bHRpLWNsdXN0ZXIgdG9wb2xvZ3kgYnVpbGRzIGl0IGxvY2FsbHkpIHwgYGsz" + - "ZCBpbWFnZSBpbXBvcnQgbnZjci5pby8uLi4vbnZjYS1vcGVyYXRvcjpwc2F0IC1jIDxjbHVzdGVy" + - "PmAgKG9yIHdoYXRldmVyIHlvdXIgaW1hZ2UgcHVzaCBwYXRoIGlzKSB8CnwgYHJlcXVpcmVkRW52" + - "ICJOQ0FfSUQiIGlzIG5vdCBzZXRgIChoZWxtZmlsZSBlcnJvcikgfCBPbGRlciBudmNmLWNsaTsg" + - "dGhlIGVudiBwcm9wYWdhdGlvbiBmaXggbGFuZGVkIGluIE0rNSBmb2xsb3ctdXBzIHwgVXBncmFk" + - "ZSBgbnZjZi1jbGlgIHRvIGEgdmVyc2lvbiBhZnRlciBgNmFhNTcwNGAgfAoKIyMgNC4gV2hlbiB0" + - "aGUgdXNlciB3YW50cyB0byBzdGFydCBvdmVyCgpJZiB0aGV5IGNvbmZpcm0gYSB0ZWFyZG93bjoK" + - "LSBTaW5nbGUtY2x1c3RlcjogYGNkIG52Y2Ytc2VsZi1tYW5hZ2VkLXN0YWNrICYmIG1ha2UgZGVz" + - "dHJveWAgKG9yIGBoZWxtIHVuaW5zdGFsbGAgcGVyIHJlbGVhc2UgaW4gcmV2ZXJzZSBvcmRlciku" + - "Ci0gTXVsdGktY2x1c3RlcjogYGhlbG0gdW5pbnN0YWxsIG52Y2Etb3BlcmF0b3IgLW4gbnZjYS1v" + - "cGVyYXRvcmAgb24gdGhlIGNvbXB1dGUgcGxhbmUgRklSU1Q7IHRoZW4gY29udHJvbCBwbGFuZTsg" + - "dGhlbiBgbnZjZi1jbGkgY2x1c3RlciBkZWxldGUgLS1jbHVzdGVyLWlkPTxpZD5gIHRvIHJlbW92" + - "ZSB0aGUgSUNNUyByb3cuCgpBbHdheXMgY29uZmlybSBiZWZvcmUgYW55IHRlYXJkb3duIOKAlCBD" + - "YXNzYW5kcmEgU3RhdGVmdWxTZXQgUFZDIGRlbGV0aW9uIGlzIGRlc3RydWN0aXZlIGFuZCBsb3Nl" + - "cyBjbHVzdGVyX29pZGMgcm93cy4KCiMjIFdoYXQgbm90IHRvIGRvCgotICoqRG9uJ3QgcHJvcG9z" + - "ZSBgLS1kZWJ1Z2AgYXMgYSBmaXguKiogSXQncyBkaWFnbm9zdGljIG9ubHkuCi0gKipEb24ndCBw" + - "cm9wb3NlIGBoZWxtIHVuaW5zdGFsbGAqKiB1bmxlc3MgdGhlIHVzZXIgZXhwbGljaXRseSBhc2tl" + - "ZCB0byBzdGFydCBvdmVyLgotICoqRG9uJ3QgcHJvcG9zZSBga3ViZWN0bCBkZWxldGUgcHZjYCoq" + - "IGV2ZXIgd2l0aG91dCBjb25maXJtYXRpb24g4oCUIGl0IGRlbGV0ZXMgdGhlIHVuZGVybHlpbmcg" + - "UFYuCi0gKipEb24ndCByZS1ydW4gYHVwYCB3aXRoIGRpZmZlcmVudCBpbnB1dHMqKiB0byAic2Vl" + - "IHdoYXQgaGFwcGVucyIuIERpYWdub3NlIHdpdGggYHN0YXR1c2AgLyBga3ViZWN0bCBkZXNjcmli" + - "ZWAgZmlyc3QuClBLBwgOnD+XvQ4AAL0OAABQSwMEFAAIAAAAAAAhAAAAAAAAAAAAAAAAADoACQBk" + - "YXRhL252Y2Ytc2VsZi1tYW5hZ2VkLWNsaS9wcm9tcHRzL2luc3RhbGwtZnJvbS1zY3JhdGNoLm1k" + - "VVQFAAEAps4SIyBJbnN0YWxsIHNlbGYtaG9zdGVkIE5WQ0YgZnJvbSBzY3JhdGNoCgpVc2VyIHdh" + - "bnRzIHRvIGJyaW5nIHVwIHNlbGYtaG9zdGVkIE5WQ0Ygb24gYSBmcmVzaCBLdWJlcm5ldGVzIGNs" + - "dXN0ZXIgKG9yIGszZCBmb3IgbG9jYWwgZGV2KS4gVGhpcyBpcyB0aGUgbW9zdCBjb21tb24gZW50" + - "cnlwb2ludC4KCiMjIFN0ZXBzCgoxLiBDb25maXJtIHRoZSB0b3BvbG9neS4gQXNrIHRoZSB1c2Vy" + - "OgogICAtICJTaW5nbGUtY2x1c3RlciAoY29udHJvbCBwbGFuZSBhbmQgY29tcHV0ZSBwbGFuZSBv" + - "biBvbmUgY2x1c3Rlciwgc2ltcGxlcikgb3Igc3BsaXQgKGNvbnRyb2wgcGxhbmUgb24gY2x1c3Rl" + - "ciBBLCBjb21wdXRlIHBsYW5lIG9uIGNsdXN0ZXIgQiwgcHJvZHVjdGlvbi1zaGFwZWQpPyIKICAg" + - "LSAiV2hhdCdzIHRoZSBjbHVzdGVyIG5hbWUgKHRoZSBgLS1jbHVzdGVyLW5hbWVgIGZsYWcsIGJl" + - "Y29tZXMgdGhlIElDTVMgcm93IGlkZW50aWZpZXIpPyBFeGFtcGxlczogYG5jcC1sb2NhbGAgZm9y" + - "IGxvY2FsIGRldiwgYHByb2QtdXMtZWFzdC0xYCBmb3IgcHJvZHVjdGlvbi4iCiAgIC0gRm9yIHNw" + - "bGl0OiAiQ29udHJvbC1wbGFuZSBrdWJlY29uZmlnIGNvbnRleHQgbmFtZT8gQ29tcHV0ZS1wbGFu" + - "ZSBjb250ZXh0PyBQdWJsaWMgSUNNUyBVUkw/IgoKMi4gUHJlcGFyZSByZW1vdGUgR2F0ZXdheSBh" + - "bmQgQ0xJIGNvbmZpZyBpZiB0aGlzIGlzIG5vdCBsb2NhbCBrM2QuIE9uZS1jbGljawogICBhcHBs" + - "aWVzIHRoZSBjb250cm9sIHBsYW5lLCB0aGVuIGltbWVkaWF0ZWx5IGNhbGxzIEFQSSwgQVBJIEtl" + - "eXMsIGludm9jYXRpb24sCiAgIGFuZCBnUlBDIGVuZHBvaW50cy4gRm9yIHJlbW90ZSBjbHVzdGVy" + - "cywgdGhlIEdhdGV3YXkgbXVzdCBiZSBwcm9ncmFtbWVkIGFuZAogICB0aGUgQ0xJIGNvbmZpZyBt" + - "dXN0IHBvaW50IGF0IHRoZSBHYXRld2F5IGxvYWQgYmFsYW5jZXIgYmVmb3JlIGB1cGAgcnVucy4K" + - "CiAgIElmIEdhdGV3YXkgQVBJIGluZ3Jlc3MgaXMgbm90IGFscmVhZHkgcHJlc2VudCwgY3JlYXRl" + - "IGl0IGZpcnN0LiBUaGVzZSBhcmUgdGhlCiAgIHNoYXJlZCBHYXRld2F5IHNldHVwIHN0ZXBzIHVz" + - "ZWQgYnkgb25lLWNsaWNrLCBIZWxtZmlsZSwgYW5kIHN0YW5kYWxvbmUgY2hhcnQKICAgaW5zdGFs" + - "bCBwYXRoczoKCiAgIGBgYHNoCiAgIGt1YmVjdGwgYXBwbHkgLWYgaHR0cHM6Ly9naXRodWIuY29t" + - "L2t1YmVybmV0ZXMtc2lncy9nYXRld2F5LWFwaS9yZWxlYXNlcy9kb3dubG9hZC92MS4yLjAvZXhw" + - "ZXJpbWVudGFsLWluc3RhbGwueWFtbAoKICAgZm9yIG5hbWVzcGFjZSBpbiBlbnZveS1nYXRld2F5" + - "LXN5c3RlbSBlbnZveS1nYXRld2F5IGFwaS1rZXlzIGVzcyBzaXMgbnZjZjsgZG8KICAgICBrdWJl" + - "Y3RsIGNyZWF0ZSBuYW1lc3BhY2UgIiRuYW1lc3BhY2UiIC0tZHJ5LXJ1bj1jbGllbnQgLW8geWFt" + - "bCB8IGt1YmVjdGwgYXBwbHkgLWYgLQogICBkb25lCgogICBmb3IgbmFtZXNwYWNlIGluIGVudm95" + - "LWdhdGV3YXkgYXBpLWtleXMgZXNzIHNpcyBudmNmOyBkbwogICAgIGt1YmVjdGwgbGFiZWwgbmFt" + - "ZXNwYWNlICIkbmFtZXNwYWNlIiBudmNmL3BsYXRmb3JtPXRydWUgLS1vdmVyd3JpdGUKICAgZG9u" + - "ZQoKICAgaGVsbSB1cGdyYWRlIC0taW5zdGFsbCBlZyBvY2k6Ly9kb2NrZXIuaW8vZW52b3lwcm94" + - "eS9nYXRld2F5LWhlbG0gXAogICAgIC0tdmVyc2lvbiB2MS4xLjMgXAogICAgIC1uIGVudm95LWdh" + - "dGV3YXktc3lzdGVtCiAgIGBgYAoKICAgQmVmb3JlIGFwcGx5aW5nIHRoZSBgRW52b3lQcm94eWAs" + - "IGRldGVybWluZSB3aGljaCBTZXJ2aWNlIGNvbnRyb2xsZXIgb3ducwogICBsb2FkIGJhbGFuY2Vy" + - "cyBvbiBFS1MuIERvIG5vdCBhcHBseSB0aGUgbWFuaWZlc3QgdW50aWwgeW91IGhhdmUgc2VsZWN0" + - "ZWQgdGhlCiAgIG1hdGNoaW5nIGBlbnZveVNlcnZpY2VgIGNvbmZpZ3VyYXRpb24uIFVzZSB0aGUg" + - "RUtTIEFQSSBhbmQgdGhlIGluLWNsdXN0ZXIKICAgY29udHJvbGxlciBEZXBsb3ltZW50IGluc3Rl" + - "YWQgb2YgZ3Vlc3NpbmcgZnJvbSB0aGUgY2x1c3RlciBhZ2Ugb3IgZXhpc3RpbmcKICAgU2Vydmlj" + - "ZXM6CgogICBgYGBzaAogICBleHBvcnQgRUtTX0NMVVNURVJfTkFNRT0iPGNsdXN0ZXItbmFtZT4i" + - "CgogICBhd3MgZWtzIGRlc2NyaWJlLWNsdXN0ZXIgLS1uYW1lICIkRUtTX0NMVVNURVJfTkFNRSIg" + - "XAogICAgIC0tcXVlcnkgJ2NsdXN0ZXIua3ViZXJuZXRlc05ldHdvcmtDb25maWcuZWxhc3RpY0xv" + - "YWRCYWxhbmNpbmcuZW5hYmxlZCcgXAogICAgIC0tb3V0cHV0IHRleHQKICAga3ViZWN0bCAtbiBr" + - "dWJlLXN5c3RlbSBnZXQgZGVwbG95bWVudCBhd3MtbG9hZC1iYWxhbmNlci1jb250cm9sbGVyCiAg" + - "IGBgYAoKICAgQW4gRUtTIEFQSSByZXN1bHQgb2YgYFRydWVgIHNlbGVjdHMKICAgW0VLUyBBdXRv" + - "IE1vZGVdKGh0dHBzOi8vZG9jcy5hd3MuYW1hem9uLmNvbS9la3MvbGF0ZXN0L3VzZXJndWlkZS9h" + - "dXRvLWNvbmZpZ3VyZS1ubGIuaHRtbCkuCiAgIE90aGVyd2lzZSwgYSBzdWNjZXNzZnVsIERlcGxv" + - "eW1lbnQgbG9va3VwIHNlbGVjdHMgdGhlIEFXUyBMb2FkIEJhbGFuY2VyCiAgIENvbnRyb2xsZXIu" + - "IElmIG5laXRoZXIgaXMgcHJlc2VudCwgY29uZmlybSB0aGF0IHRoZSBjbHVzdGVyIGludGVudGlv" + - "bmFsbHkKICAgdXNlcyB0aGUgbGVnYWN5IEFXUyBjbG91ZCBwcm92aWRlciBTZXJ2aWNlIGNvbnRy" + - "b2xsZXIsIG9yIGluc3RhbGwgdGhlIEFXUwogICBMb2FkIEJhbGFuY2VyIENvbnRyb2xsZXIsIGJl" + - "Zm9yZSBhcHBseWluZyB0aGUgZXhhbXBsZS4KCiAgIFRoZSBhcHBsaWVkIG1hbmlmZXN0IGJlbG93" + - "IGlzIGZvciB0aGUgQVdTIExvYWQgQmFsYW5jZXIgQ29udHJvbGxlci4gRm9yIEVLUwogICBBdXRv" + - "IE1vZGUsIHJlcGxhY2UgaXRzIGBlbnZveVNlcnZpY2VgIG1hcCBiZWZvcmUgYXBwbHlpbmcgaXQg" + - "d2l0aDoKCiAgIGBgYHlhbWwKICAgZW52b3lTZXJ2aWNlOgogICAgIGxvYWRCYWxhbmNlckNsYXNz" + - "OiBla3MuYW1hem9uYXdzLmNvbS9ubGIKICAgICBhbm5vdGF0aW9uczoKICAgICAgIHNlcnZpY2Uu" + - "YmV0YS5rdWJlcm5ldGVzLmlvL2F3cy1sb2FkLWJhbGFuY2VyLXNjaGVtZTogImludGVybmV0LWZh" + - "Y2luZyIKICAgYGBgCgogICBGb3IgdGhlIGxlZ2FjeSBBV1MgY2xvdWQgcHJvdmlkZXIgU2Vydmlj" + - "ZSBjb250cm9sbGVyLCByZXBsYWNlIHRoZSBtYXAgd2l0aDoKCiAgIGBgYHlhbWwKICAgZW52b3lT" + - "ZXJ2aWNlOgogICAgIGFubm90YXRpb25zOgogICAgICAgc2VydmljZS5iZXRhLmt1YmVybmV0ZXMu" + - "aW8vYXdzLWxvYWQtYmFsYW5jZXItdHlwZTogIm5sYiIKICAgYGBgCgogICBUaGUgbGVnYWN5IGNv" + - "bnRyb2xsZXIgY3JlYXRlcyBhbiBpbnRlcm5ldC1mYWNpbmcgbG9hZCBiYWxhbmNlciBieSBkZWZh" + - "dWx0LgogICBEbyBub3QgY29tYmluZSB0aGUgbGVnYWN5IGBubGJgIHNlbGVjdG9yIHdpdGggdGhl" + - "IEFXUyBMb2FkIEJhbGFuY2VyCiAgIENvbnRyb2xsZXIgdGFyZ2V0IHR5cGUgYW5kIHNjaGVtZSBh" + - "bm5vdGF0aW9ucy4gSXQgc3VwcG9ydHMgYW4gTkxCIFNlcnZpY2UKICAgd2hvc2UgcG9ydHMgdXNl" + - "IG9ubHkgVENQIG9yIG9ubHkgVURQLCBidXQgcmVqZWN0cyBvbmUgU2VydmljZSB0aGF0IGNvbWJp" + - "bmVzCiAgIFRDUCBhbmQgVURQIHBvcnRzLiBVc2UgdGhlIEFXUyBMb2FkIEJhbGFuY2VyIENvbnRy" + - "b2xsZXIgd2hlbiB0aGUgZ2VuZXJhdGVkCiAgIEVudm95IFNlcnZpY2UgY29tYmluZXMgcHJvdG9j" + - "b2xzLiBPbiBub24tQVdTIGNsdXN0ZXJzLCByZXBsYWNlIHRoZSBtYXAgd2l0aAogICB0aGUgcHJv" + - "dmlkZXIncyBTZXJ2aWNlIGNvbmZpZ3VyYXRpb24gYmVmb3JlIGFwcGx5aW5nIGl0LgoKICAgYGBg" + - "c2gKICAgIyBOb24tRUtTLUF1dG8tTW9kZSBleGFtcGxlOiB1c2UgQVdTIExCQyB3aXRoIGluc3Rh" + - "bmNlIHRhcmdldHMuCiAgIGt1YmVjdGwgYXBwbHkgLWYgLSA8PEVPRgogICBhcGlWZXJzaW9uOiBn" + - "YXRld2F5LmVudm95cHJveHkuaW8vdjFhbHBoYTEKICAga2luZDogRW52b3lQcm94eQogICBtZXRh" + - "ZGF0YToKICAgICBuYW1lOiBlZwogICAgIG5hbWVzcGFjZTogZW52b3ktZ2F0ZXdheS1zeXN0ZW0K" + - "ICAgc3BlYzoKICAgICBwcm92aWRlcjoKICAgICAgIHR5cGU6IEt1YmVybmV0ZXMKICAgICAgIGt1" + - "YmVybmV0ZXM6CiAgICAgICAgIGVudm95U2VydmljZToKICAgICAgICAgICBhbm5vdGF0aW9uczoK" + - "ICAgICAgICAgICAgIHNlcnZpY2UuYmV0YS5rdWJlcm5ldGVzLmlvL2F3cy1sb2FkLWJhbGFuY2Vy" + - "LXR5cGU6ICJleHRlcm5hbCIKICAgICAgICAgICAgIHNlcnZpY2UuYmV0YS5rdWJlcm5ldGVzLmlv" + - "L2F3cy1sb2FkLWJhbGFuY2VyLW5sYi10YXJnZXQtdHlwZTogImluc3RhbmNlIgogICAgICAgICAg" + - "ICAgc2VydmljZS5iZXRhLmt1YmVybmV0ZXMuaW8vYXdzLWxvYWQtYmFsYW5jZXItc2NoZW1lOiAi" + - "aW50ZXJuZXQtZmFjaW5nIgogICAtLS0KICAgYXBpVmVyc2lvbjogZ2F0ZXdheS5uZXR3b3JraW5n" + - "Lms4cy5pby92MQogICBraW5kOiBHYXRld2F5Q2xhc3MKICAgbWV0YWRhdGE6CiAgICAgbmFtZTog" + - "ZWcKICAgc3BlYzoKICAgICBjb250cm9sbGVyTmFtZTogZ2F0ZXdheS5lbnZveXByb3h5LmlvL2dh" + - "dGV3YXljbGFzcy1jb250cm9sbGVyCiAgICAgcGFyYW1ldGVyc1JlZjoKICAgICAgIGdyb3VwOiBn" + - "YXRld2F5LmVudm95cHJveHkuaW8KICAgICAgIGtpbmQ6IEVudm95UHJveHkKICAgICAgIG5hbWU6" + - "IGVnCiAgICAgICBuYW1lc3BhY2U6IGVudm95LWdhdGV3YXktc3lzdGVtCiAgIEVPRgoKICAga3Vi" + - "ZWN0bCBhcHBseSAtZiAtIDw8RU9GCiAgIGFwaVZlcnNpb246IGdhdGV3YXkubmV0d29ya2luZy5r" + - "OHMuaW8vdjEKICAga2luZDogR2F0ZXdheQogICBtZXRhZGF0YToKICAgICBuYW1lOiBudmNmLWdh" + - "dGV3YXkKICAgICBuYW1lc3BhY2U6IGVudm95LWdhdGV3YXkKICAgc3BlYzoKICAgICBnYXRld2F5" + - "Q2xhc3NOYW1lOiBlZwogICAgIGxpc3RlbmVyczoKICAgICAtIG5hbWU6IGh0dHAKICAgICAgIHBy" + - "b3RvY29sOiBIVFRQCiAgICAgICBwb3J0OiA4MAogICAgICAgYWxsb3dlZFJvdXRlczoKICAgICAg" + - "ICAgbmFtZXNwYWNlczoKICAgICAgICAgICBmcm9tOiBTZWxlY3RvcgogICAgICAgICAgIHNlbGVj" + - "dG9yOgogICAgICAgICAgICAgbWF0Y2hMYWJlbHM6CiAgICAgICAgICAgICAgIG52Y2YvcGxhdGZv" + - "cm06ICJ0cnVlIgogICAgIC0gbmFtZTogdGNwCiAgICAgICBwcm90b2NvbDogVENQCiAgICAgICBw" + - "b3J0OiAxMDA4MQogICAgICAgYWxsb3dlZFJvdXRlczoKICAgICAgICAgbmFtZXNwYWNlczoKICAg" + - "ICAgICAgICBmcm9tOiBTZWxlY3RvcgogICAgICAgICAgIHNlbGVjdG9yOgogICAgICAgICAgICAg" + - "bWF0Y2hMYWJlbHM6CiAgICAgICAgICAgICAgIG52Y2YvcGxhdGZvcm06ICJ0cnVlIgogICBFT0YK" + - "ICAgYGBgCgogICBTZXJ2aWNlIGFubm90YXRpb25zIG11c3QgYmUgdW5kZXIKICAgYEVudm95UHJv" + - "eHkuc3BlYy5wcm92aWRlci5rdWJlcm5ldGVzLmVudm95U2VydmljZS5hbm5vdGF0aW9uc2AuIEVu" + - "dm95IEdhdGV3YXkKICAgY29waWVzIHRoZW0gdG8gdGhlIGdlbmVyYXRlZCBFbnZveSBTZXJ2aWNl" + - "LiBEbyBub3QgcHV0IFNlcnZpY2UgYW5ub3RhdGlvbnMKICAgb24gdGhlIGBHYXRld2F5YCByZXNv" + - "dXJjZS4KCiAgIENhcHR1cmUgdGhlIEdhdGV3YXkgdmFsdWVzIGFuZCB3cml0ZSB0aGUgQ0xJIGNv" + - "bmZpZzoKCiAgIGBgYHNoCiAgIGV4cG9ydCBDTFVTVEVSX05BTUU9Im52Y2YtcmVtb3RlIgogICBl" + - "eHBvcnQgTkNBX0lEPSJudmNmLWRlZmF1bHQiCiAgIGV4cG9ydCBSRUdJT049InVzLXdlc3QtMSIK" + - "ICAgZXhwb3J0IEhUVFBfR0FURVdBWV9OQU1FU1BBQ0U9ImVudm95LWdhdGV3YXkiCiAgIGV4cG9y" + - "dCBIVFRQX0dBVEVXQVlfTkFNRT0ibnZjZi1nYXRld2F5IgogICBleHBvcnQgR1JQQ19HQVRFV0FZ" + - "X05BTUVTUEFDRT0iZW52b3ktZ2F0ZXdheSIKICAgZXhwb3J0IEdSUENfR0FURVdBWV9OQU1FPSJu" + - "dmNmLWdhdGV3YXkiCgogICBrdWJlY3RsIC1uICIkSFRUUF9HQVRFV0FZX05BTUVTUEFDRSIgd2Fp" + - "dCAiZ2F0ZXdheS8kSFRUUF9HQVRFV0FZX05BTUUiIFwKICAgICAtLWZvcj1jb25kaXRpb249UHJv" + - "Z3JhbW1lZD1UcnVlIC0tdGltZW91dD0xMG0KICAga3ViZWN0bCAtbiAiJEdSUENfR0FURVdBWV9O" + - "QU1FU1BBQ0UiIHdhaXQgImdhdGV3YXkvJEdSUENfR0FURVdBWV9OQU1FIiBcCiAgICAgLS1mb3I9" + - "Y29uZGl0aW9uPVByb2dyYW1tZWQ9VHJ1ZSAtLXRpbWVvdXQ9MTBtCgogICBleHBvcnQgR0FURVdB" + - "WV9BRERSPSIkKGt1YmVjdGwgLW4gIiRIVFRQX0dBVEVXQVlfTkFNRVNQQUNFIiBnZXQgImdhdGV3" + - "YXkvJEhUVFBfR0FURVdBWV9OQU1FIiBcCiAgICAgLW8ganNvbnBhdGg9J3suc3RhdHVzLmFkZHJl" + - "c3Nlc1swXS52YWx1ZX0nKSIKICAgZXhwb3J0IEdSUENfR0FURVdBWV9BRERSPSIkKGt1YmVjdGwg" + - "LW4gIiRHUlBDX0dBVEVXQVlfTkFNRVNQQUNFIiBnZXQgImdhdGV3YXkvJEdSUENfR0FURVdBWV9O" + - "QU1FIiBcCiAgICAgLW8ganNvbnBhdGg9J3suc3RhdHVzLmFkZHJlc3Nlc1swXS52YWx1ZX0nKSIK" + - "ICAgdGVzdCAtbiAiJEdBVEVXQVlfQUREUiIgfHwgZXhpdCAxCiAgIHRlc3QgLW4gIiRHUlBDX0dB" + - "VEVXQVlfQUREUiIgfHwgZXhpdCAxCiAgIGV4cG9ydCBTVEFDS19ET01BSU49IiRHQVRFV0FZX0FE" + - "RFIiCiAgIGBgYAoKICAgU2V0IGBTVEFDS19ET01BSU5gIHRvIHRoZSBob3N0bmFtZSBzdWZmaXgg" + - "dXNlZCBieSB0aGUgaW5zdGFsbGVkIEhUVFBSb3V0ZXMuCiAgIEZvciByZW1vdGUgdGVzdCBmbG93" + - "cyB3aXRob3V0IHByb2R1Y3Rpb24gRE5TLCB1c2UgdGhlIEdhdGV3YXkgbG9hZCBiYWxhbmNlcgog" + - "ICBhZGRyZXNzLgoKICAgYGBgc2gKICAgY2F0ID4gLm52Y2YtY2xpLnlhbWwgPDxFT0YKICAgYmFz" + - "ZV9odHRwX3VybDogImh0dHA6Ly8ke0dBVEVXQVlfQUREUn0iCiAgIGludm9rZV91cmw6ICJodHRw" + - "Oi8vJHtHQVRFV0FZX0FERFJ9IgogICBiYXNlX2dycGNfdXJsOiAiJHtHUlBDX0dBVEVXQVlfQURE" + - "Un06MTAwODEiCiAgIGFwaV9rZXlzX3NlcnZpY2VfdXJsOiAiaHR0cDovLyR7R0FURVdBWV9BRERS" + - "fSIKCiAgIGFwaV9rZXlzX2hvc3Q6ICJhcGkta2V5cy4ke1NUQUNLX0RPTUFJTn0iCiAgIGFwaV9o" + - "b3N0OiAiYXBpLiR7U1RBQ0tfRE9NQUlOfSIKICAgaW52b2tlX2hvc3Q6ICJpbnZvY2F0aW9uLiR7" + - "U1RBQ0tfRE9NQUlOfSIKCiAgIGFwaV9rZXlzX3NlcnZpY2VfaWQ6ICJudmlkaWEtY2xvdWQtZnVu" + - "Y3Rpb25zLW5jcC1zZXJ2aWNlLWlkLWFrZXRtIgogICBhcGlfa2V5c19pc3N1ZXJfc2VydmljZTog" + - "Im52Y2YtYXBpIgogICBhcGlfa2V5c19vd25lcl9pZDogInN2Y0BudmNmLWFwaS5sb2NhbCIKCiAg" + - "IGNsaWVudF9pZDogIiR7TkNBX0lEfSIKICAgRU9GCiAgIGBgYAoKMy4gUnVuIHByZS1mbGlnaHQu" + - "IENob29zZSB0aGUgZmxhdm9yIG1hdGNoaW5nIHRoZSB0b3BvbG9neToKCiAgIGBgYHNoCiAgICMg" + - "U2luZ2xlLWNsdXN0ZXIKICAgbnZjZi1jbGkgc2VsZi1ob3N0ZWQgY2hlY2sgLS1wcmUgLS1qc29u" + - "IHwganEgLWMgLgoKICAgIyBTcGxpdAogICBudmNmLWNsaSBzZWxmLWhvc3RlZCBjaGVjayAtLXBy" + - "ZSBcCiAgICAgLS1jb250cm9sLXBsYW5lLWNvbnRleHQ9YWRtaW5AY3AgXAogICAgIC0tY29tcHV0" + - "ZS1wbGFuZS1jb250ZXh0PWFkbWluQGdwdTEgXAogICAgIC0tanNvbiB8IGpxIC1jIC4KCiAgICMg" + - "Q29tcHV0ZS1vbmx5IChvcGVyYXRvciB3aXRoIGt1YmVjdGwgb24gY29tcHV0ZSBwbGFuZSBvbmx5" + - "KQogICBudmNmLWNsaSBzZWxmLWhvc3RlZCBjaGVjayAtLXByZSBcCiAgICAgLS1jb21wdXRlLXBs" + - "YW5lLWNvbnRleHQ9YWRtaW5AZ3B1MSBcCiAgICAgLS1pY21zLXVybD1odHRwczovL2ljbXMubnZj" + - "Zi5leGFtcGxlLmNvbSBcCiAgICAgLS1qc29uIHwganEgLWMgLgogICBgYGAKCiAgIFBhcnNlIHRo" + - "ZSBKU09OTCBzdHJlYW0uIElmIGFueSBjaGVjayBmYWlscyAoYCJwYXNzZWQiOmZhbHNlYCkgd2l0" + - "aCBgc2V2ZXJpdHk6IGVycm9yYCwgc3VyZmFjZSBgbWVzc2FnZWAgKyBgaGludFVSTGAgdG8gdGhl" + - "IHVzZXIgYW5kIHN0b3AuIERvbid0IHByb2NlZWQgdG8gaW5zdGFsbCB3aXRoIGJyb2tlbiBwcmVy" + - "ZXFzLgoKNC4gTWludCBhbiBhZG1pbiB0b2tlbiBpZiBuZWVkZWQuIGBudmNmLWNsaSBpbml0YCBp" + - "cyBpZGVtcG90ZW50LiBDYWxsIGl0IGlmIHRoZQogICB1c2VyIGRvZXMgbm90IGhhdmUgYSBzZXNz" + - "aW9uIHlldC4gSW5pdCB0YWxrcyB0byBBUEkgS2V5cyB0aHJvdWdoIHRoZSBwdWJsaWMKICAgQVBJ" + - "IGdhdGV3YXksIHNvIGl0IGFsc28gd29ya3MgaW4gY29tcHV0ZS1vbmx5IG1vZGUuCgo1LiBSdW4g" + - "YHVwYC4gVXNlIGAtLWpzb25gIGZvciB0aGUgSlNPTkwgZXZlbnQgc3RyZWFtOgoKICAgYGBgc2gK" + - "ICAgbnZjZi1jbGkgc2VsZi1ob3N0ZWQgdXAgXAogICAgIC0tY2x1c3Rlci1uYW1lPSIke0NMVVNU" + - "RVJfTkFNRX0iIFwKICAgICAtLW5jYS1pZD0iJHtOQ0FfSUR9IiBcCiAgICAgLS1yZWdpb249IiR7" + - "UkVHSU9OfSIgXAogICAgIC0tanNvbgogICBgYGAKCiAgIEZvciBzcGxpdC1jbHVzdGVyIGluc3Rh" + - "bGxzLCBhZGQgYm90aCBjb250ZXh0IGZsYWdzOgoKICAgYGBgc2gKICAgZXhwb3J0IENPTlRST0xf" + - "UExBTkVfQ09OVEVYVD0iYWRtaW5AY29udHJvbC1wbGFuZSIKICAgZXhwb3J0IENPTVBVVEVfUExB" + - "TkVfQ09OVEVYVD0iYWRtaW5AZ3B1LWNsdXN0ZXIiCgogICBudmNmLWNsaSBzZWxmLWhvc3RlZCB1" + - "cCBcCiAgICAgLS1jb250cm9sLXBsYW5lLWNvbnRleHQ9IiR7Q09OVFJPTF9QTEFORV9DT05URVhU" + - "fSIgXAogICAgIC0tY29tcHV0ZS1wbGFuZS1jb250ZXh0PSIke0NPTVBVVEVfUExBTkVfQ09OVEVY" + - "VH0iIFwKICAgICAtLWNsdXN0ZXItbmFtZT0iJHtDTFVTVEVSX05BTUV9IiBcCiAgICAgLS1uY2Et" + - "aWQ9IiR7TkNBX0lEfSIgXAogICAgIC0tcmVnaW9uPSIke1JFR0lPTn0iIFwKICAgICAtLWpzb24K" + - "ICAgYGBgCgogICBQYXJzZSBldmVudHM6CiAgIC0gYHBoYXNlX3N0YXJ0ZWRgIC8gYHBoYXNlX2Nv" + - "bXBsZXRlZGA6IGxvZyBwcm9ncmVzcwogICAtIGBwaGFzZV9wcm9ncmVzc2A6IHNob3cgcHJvZ3Jl" + - "c3MgZm9yIHRoZSBsb25nIGFwcGx5IHBoYXNlcyAocmVzb3VyY2UgY291bnRzKQogICAtIGB3YWl0" + - "aW5nYDogc3VyZmFjZSB0byB0aGUgdXNlciBpZiBpdCBwZXJzaXN0cyBmb3IgbW9yZSB0aGFuIDIg" + - "bWludXRlcwogICAtIGBwaGFzZV9mYWlsZWRgOiBzdG9wIGFuZCBzdXJmYWNlIGBlcnJNZXNzYWdl" + - "YCBwbHVzIGVhY2ggYHJlbWVkaWF0aW9uYCBsaW5lLgogICAgIERlY2lkZSBiYXNlZCBvbiBgcmV0" + - "cnlDbGFzc2A6IGBpbW1lZGlhdGVgIC0+IG1heSByZS1ydW4gbm93IHdpdGggdXNlcgogICAgIGFw" + - "cHJvdmFsOyBgYmFja29mZmAgLT4gd2FpdCBgcmV0cnlBZnRlclNlY2AgYW5kIHRoZW4gcmUtcnVu" + - "IHdpdGggdXNlcgogICAgIGFwcHJvdmFsOyBgYWZ0ZXJfcmVtZWRpYXRpb25gLCBgbm9uZWAsIG9y" + - "IGB1bmtub3duYCAtPiB0aGUgb3BlcmF0b3IgbXVzdAogICAgIGFjdCBmaXJzdCwgc28gZG8gbm90" + - "IGF1dG8tcmV0cnkuCiAgIC0gYGZpbmFsYDogZG9uZS4gUHJpbnQgY2x1c3RlcklkIGFuZCBOVkNG" + - "QmFja2VuZCBoZWFsdGguCgo2LiBWZXJpZnkgd2l0aCBzdGF0dXMuIFJ1biBgbnZjZi1jbGkgc2Vs" + - "Zi1ob3N0ZWQgc3RhdHVzIC0tanNvbiB8IGpxYCBhbmQgZXhwZWN0CiAgIGB2ZXJkaWN0OiAiaGVh" + - "bHRoeSJgLiBPdGhlcndpc2UsIHVzZQogICBbZGlhZ25vc2UtZmFpbGVkLWluc3RhbGwubWRdKGRp" + - "YWdub3NlLWZhaWxlZC1pbnN0YWxsLm1kKS4KCjcuIE9wdGlvbmFsbHkgc21va2UgdGVzdCBhIGZ1" + - "bmN0aW9uLiBVc2UKICAgW2RlcGxveS1hbmQtaW52b2tlLm1kXShkZXBsb3ktYW5kLWludm9rZS5t" + - "ZCkgZm9yIHRoZSBjcmVhdGUgLT4gZGVwbG95IC0+CiAgIGludm9rZSBmbG93LgoKIyMgTm90ZXMK" + - "Ci0gU2luZ2xlLWNsdXN0ZXIgYHVwYCBhZ2FpbnN0IGEgZnJlc2ggY2x1c3RlciB0YWtlcyBhYm91" + - "dCAxMC0xMyBtaW51dGVzLAogIGRlcGVuZGluZyBvbiBjaGFydCBwdWxsIHNwZWVkIGFuZCBOQVRT" + - "IHN0cmVhbS1pbml0IGxhdGVuY3kuCi0gYHVwYCBpcyBpZGVtcG90ZW50LiBJdCBpcyBzYWZlIHRv" + - "IHJlLXJ1biBhZnRlciBmaXhpbmcgYSBwcmVyZXF1aXNpdGUuCi0gTmV2ZXIgcHJvcG9zZSBgLS1m" + - "b3JjZWAgKG5vIGNvbW1hbmQgdGFrZXMgb25lIGFueXdheSkuCi0gSWYgdGhlIHVzZXIgaGFzIENJ" + - "IC8gYCRDSWAgc2V0LCBhbHdheXMgdXNlIGAtLW5vbi1pbnRlcmFjdGl2ZSAtLXRva2VuPSRKV1Rg" + - "OyBuZXZlciBwcm9wb3NlIGBudmNmLWNsaSBpbml0YCBpbnRlcmFjdGl2ZWx5LgpQSwcIQnHmHgEo" + - "AAABKAAAUEsDBBQACAAAAAAAIQAAAAAAAAAAAAAAAAA5AAkAZGF0YS9udmNmLXNlbGYtbWFuYWdl" + - "ZC1jbGkvcHJvbXB0cy9yb3RhdGUtY2x1c3Rlci1qd2tzLm1kVVQFAAEAps4SIyBSb3RhdGUgYSBj" + - "bHVzdGVyJ3MgSldLUwoKVXNlciBzYXlzIE5WQ0Egc3RvcHBlZCBhdXRoZW50aWNhdGluZywgb3Ig" + - "UFNBVCBhdXRoIGlzIDQwMS1pbmcgYWdhaW5zdCBJQ01TLiBUaGUgSzhzIEFQSSBzZXJ2ZXIncyBK" + - "V1Qgc2lnbmluZyBrZXlzIG1heSBoYXZlIHJvdGF0ZWQgYW5kIHRoZSBKV0tTIHN0b3JlZCBpbiBJ" + - "Q01TIGlzIG5vdyBzdGFsZS4KCiMjIFdoZW4gdG8gcm90YXRlCgotIGBrdWJlY3RsIGxvZ3MgLW4g" + - "bnZjYS1zeXN0ZW0gLWwgYXBwLmt1YmVybmV0ZXMuaW8vbmFtZT1udmNhYCBzaG93cyBgSFRUUCA0" + - "MDFgIG9uIGAvdjEvbnZjYS9jbHVzdGVycy88aWQ+L3JlZ2lzdGVyYCByZXBlYXRlZGx5Ci0gSUNN" + - "UyBsb2dzIHNob3cgYE5vIGNsdXN0ZXIgZm91bmQgd2l0aCB2YWxpZCBKV0tTIGZvciBjbHVzdGVy" + - "IElEOiA8aWQ+YCAoY2F1c2VkIGJ5IGlzc3VlciBtaXNtYXRjaCwgbm90IEpXS1MsIGJ1dCByb3Rh" + - "dGUgZml4ZXMgYm90aCkKLSBBZnRlciBhIGNvbnRyb2wtcGxhbmUgSzhzIHVwZ3JhZGUgb3IgY29t" + - "cHV0ZS1wbGFuZSBLOHMgdXBncmFkZQoKIyMgU3RlcHMKCjEuIENvbmZpcm0gdGhlIGNsdXN0ZXIg" + - "SUQuIFJ1biBgbnZjZi1jbGkgY2x1c3RlciBsaXN0LXJlZ2lzdGVyZWQgLS1uY2EtaWQ9JE5DQV9J" + - "RCAtLWljbXMtdXJsPSRJQ01TYC4gSWRlbnRpZnkgdGhlIHJvdyBtYXRjaGluZyB0aGUgdXNlcidz" + - "IGNvbXB1dGUgcGxhbmUuCgoyLiAqKlJvdGF0ZS4qKiBGcm9tIGEgY29udGV4dCB0aGF0IGNhbiBy" + - "ZWFjaCB0aGUgY29tcHV0ZSBwbGFuZSdzIEs4cyBBUEkgKGJlY2F1c2Ugcm90YXRpb24gcmUtZmV0" + - "Y2hlcyB0aGUgSzhzIEFQSSdzIGAvb3BlbmlkL3YxL2p3a3NgKToKCiAgIGBgYHNoCiAgIG52Y2Yt" + - "Y2xpIGNsdXN0ZXIgcm90YXRlIC0tY2x1c3Rlci1pZD08aWQ+IC0tY29tcHV0ZS1wbGFuZS1jb250" + - "ZXh0PTxjdHg+CiAgIGBgYAoKICAgVGhpcyByZS1mZXRjaGVzIEpXS1MgZnJvbSB0aGUgY29tcHV0" + - "ZSBwbGFuZSdzIEs4cyBBUEkgYW5kIFBVVHMgaXQgdG8gSUNNUy4gVGhlIGNsdXN0ZXIgSUQgc3Rh" + - "eXMgdGhlIHNhbWUuCgozLiAqKlZlcmlmeS4qKiBgbnZjZi1jbGkgY2x1c3RlciBnZXQgLS1jbHVz" + - "dGVyLWlkPTxpZD5gIOKAlCBjb25maXJtIGB1cGRhdGVkQXRgIGFkdmFuY2VkLiBUaGVuIGBrdWJl" + - "Y3RsIGxvZ3MgLW4gbnZjYS1zeXN0ZW0gLWwgYXBwLmt1YmVybmV0ZXMuaW8vbmFtZT1udmNhIC0t" + - "dGFpbD0yMGAg4oCUIHJlZ2lzdGVyIGF0dGVtcHRzIHNob3VsZCBzdWNjZWVkICgyMDAsIG5vdCA0" + - "MDEpLgoKIyMgV2hhdCBub3QgdG8gZG8KCi0gKipEb24ndCBgY2x1c3RlciBkZWxldGVgLioqIFJv" + - "dGF0aW9uIHByZXNlcnZlcyB0aGUgY2x1c3RlciBJRCArIGdyb3VwIElEOyBkZWxldGUgY3JlYXRl" + - "cyBhIG5ldyByb3cgYW5kIHlvdSBoYXZlIHRvIHJlZGVwbG95IHRoZSBjb21wdXRlIHBsYW5lIHdp" + - "dGggbmV3IElEcy4KLSAqKkRvbid0IG1hbnVhbGx5IGVkaXQgYG91dC88Y2x1c3Rlcj4tcmVnaXN0" + - "ZXItdmFsdWVzLnlhbWxgLioqIFJvdGF0ZSB1cGRhdGVzIElDTVMgb25seTsgdGhlIGhlbG0gdmFs" + - "dWVzIGZpbGUgYWxyZWFkeSBoYXMgdGhlIHJpZ2h0IGNsdXN0ZXIgSUQuCgojIyBJZiByb3RhdGlv" + - "biBkb2Vzbid0IGZpeCBpdAoKVGhlIGF1dGggZmFpbHVyZSBtYXkgYmUgYXQgYSBkaWZmZXJlbnQg" + - "bGF5ZXIg4oCUIGNoZWNrOgotIE5BVFMgYXV0aC1jYWxsb3V0IGhlYWx0aCAoYGt1YmVjdGwgbG9n" + - "cyAtbiBuYXRzLXN5c3RlbSAtbCBhcHA9bmF0cy1hdXRoLWNhbGxvdXQtc2VydmljZWApCi0gQ2x1" + - "c3RlciByb3cgZXhpc3RzIGluIGBjbHVzdGVyX29pZGNfYnlfY2x1c3Rlcl9pZGAgQ2Fzc2FuZHJh" + - "IHRhYmxlCi0gYGhlbG0tcmV2YWwtc2VydmljZWAgY29uZmlnbWFwIGhhcyBgYXV0aHoub2lkYy5l" + - "bmFibGVkPXRydWVgCgpSb3V0ZSB0byBbZGlhZ25vc2UtZmFpbGVkLWluc3RhbGwubWRdKGRpYWdu" + - "b3NlLWZhaWxlZC1pbnN0YWxsLm1kKSBmb3IgdGhvc2UgY2hlY2tzLgpQSwcIGsQsnscHAADHBwAA" + - "UEsDBBQACAAAAAAAIQAAAAAAAAAAAAAAAAAuAAkAZGF0YS9udmNmLXNlbGYtbWFuYWdlZC1jbGkv" + - "cHJvbXB0cy90ZWFyZG93bi5tZFVUBQABAKbOEiMgVGVhciBkb3duIGEgc2VsZi1ob3N0ZWQgTlZD" + - "RiBkZXBsb3ltZW50CgoqKlNBRkVUWToqKiBUZWFyZG93biBkZXN0cm95cyBwZXJzaXN0ZW50IHN0" + - "YXRlIChDYXNzYW5kcmEgcm93cywgT3BlbkJhbyBzZWFsIGtleXMsIHJlZ2lzdGVyZWQgY2x1c3Rl" + - "cnMpLiBBbHdheXMgY29uZmlybSB3aXRoIHRoZSB1c2VyIGJlZm9yZSBhbnkgc3RlcC4KCiMjIFRM" + - "O0RSIOKAlCBgZG93bmAgZm9yIG9uZS1zaG90LCBgdW5pbnN0YWxsYCBmb3IgcGVyLXBsYW5lCgpU" + - "aGUgQ0xJIHByb3ZpZGVzIGEgdHdvLXRpZXIgdGVhcmRvd24gc3VyZmFjZSBzeW1tZXRyaWMgd2l0" + - "aCB0aGUgaW5zdGFsbCBzaWRlIChSRVEtMjIsIE0rMTEpOgoKfCBUaWVyIHwgVXAgc2lkZSAoZXhp" + - "c3RpbmcpIHwgRG93biBzaWRlIHwKfC0tLXwtLS18LS0tfAp8IFBlci1wbGFuZSBwcmltaXRpdmUg" + - "KHJlbmRlcnMgWUFNTDsgR2l0T3BzLWZyaWVuZGx5KSB8IGBpbnN0YWxsIC0tY29udHJvbC1wbGFu" + - "ZWAgLyBgaW5zdGFsbCAtLWNvbXB1dGUtcGxhbmVgIHwgYHVuaW5zdGFsbCAtLWNvbnRyb2wtcGxh" + - "bmVgIC8gYHVuaW5zdGFsbCAtLWNvbXB1dGUtcGxhbmVgIHwKfCBPcmNoZXN0cmF0b3IgKG9uZS1z" + - "aG90LCBtdWx0aS1wbGFuZSArIElDTVMpIHwgYHVwIC0tY2x1c3Rlci1uYW1lPVhgIHwgYGRvd24g" + - "LS1jbHVzdGVyLW5hbWU9WGAgLyBgZG93biAtLWFsbGAgfAoKVXNlIGBkb3duYCBmb3Igbm9ybWFs" + - "IHRlYXJkb3duLiBVc2UgYHVuaW5zdGFsbGAgZm9yIEdpdE9wcyAoY29tbWl0IFlBTUw7IEFyZ28v" + - "Rmx1eCBhcHBsaWVzKSBvciBzY3JpcHRlZCBwaXBlbGluZXMuIEFsd2F5cyBzdGFydCB3aXRoIGEg" + - "ZHJ5LXJ1bi4KCiMjIERyeS1ydW4gc2hhcGVzCgp8IE1vZGUgfCBMaXZlcyBvbiB8IEludm9rZXMg" + - "aGVsbS9oZWxtZmlsZT8gfCBPdXRwdXQgfAp8LS0tfC0tLXwtLS18LS0tfAp8IGAtLXBsYW4tb25s" + - "eWAgfCBgdXBgIC8gYGRvd25gIChvcmNoZXN0cmF0b3JzKSB8ICoqTm8uKiogV2Fsa3MgcmVzb2x2" + - "ZWQgc3RhY2sgZW50cnlwb2ludCBmaWxlcywgZW1pdHMgcGhhc2UgcGxhbiArIEVUQXMgKyBoZWxt" + - "IHVuaW5zdGFsbCBjb21tYW5kIHN0cmluZ3MuIHwgRXZlbnQgc3RyZWFtIHwKfCBgLS1uby1hcHBs" + - "eWAgfCBgaW5zdGFsbGAgLyBgdW5pbnN0YWxsYCAocHJpbWl0aXZlcykgfCAqKlllcy4qKiBgaGVs" + - "bWZpbGUgdGVtcGxhdGVgIGZvciBpbnN0YWxsOyBgaGVsbSBnZXQgbWFuaWZlc3RgIGZvciB1bmlu" + - "c3RhbGwuIHwgWUFNTCBvbiBzdGRvdXQgfAoKU286Ci0gYGRvd24gLS1wbGFuLW9ubHkgLS1jbHVz" + - "dGVyLW5hbWU9WGAg4oCUIHNob3cgbWUgdGhlIG9yY2hlc3RyYXRvciBwaGFzZXMgd2l0aG91dCBp" + - "bnZva2luZyBhbnl0aGluZy4KLSBgdW5pbnN0YWxsIC0tbm8tYXBwbHkgLS1jb21wdXRlLXBsYW5l" + - "IC0tY2x1c3Rlci1uYW1lPVhgIOKAlCBnaXZlIG1lIHRoZSBZQU1MIEknZCBga3ViZWN0bCBkZWxl" + - "dGUgLWYgLWAuCgpgYGBzaAojIFN0ZXAgMTogQUxXQVlTIHByZXZpZXcgZmlyc3QuCm52Y2YtY2xp" + - "IHNlbGYtaG9zdGVkIGRvd24gLS1wbGFuLW9ubHkgLS1jbHVzdGVyLW5hbWU9bmNwLWxvY2FsIC0t" + - "anNvbiB8IGpxCgojIFN0ZXAgMjogUmVhbCBydW4uCm52Y2YtY2xpIHNlbGYtaG9zdGVkIGRvd24g" + - "LS1jbHVzdGVyLW5hbWU9bmNwLWxvY2FsCmBgYAoKIyMgV2hlbiB0byB1c2Ugd2hpY2ggZm9ybQoK" + - "fCBVc2VyIGludGVudCB8IENvbW1hbmQgfAp8LS0tfC0tLXwKfCAiUmVtb3ZlIHRoaXMgb25lIEdQ" + - "VSBjbHVzdGVyIiB8IGBudmNmLWNsaSBzZWxmLWhvc3RlZCBkb3duIC0tY2x1c3Rlci1uYW1lPVhg" + - "IHwKfCAiVGVhciBkb3duIGV2ZXJ5dGhpbmciIHwgYG52Y2YtY2xpIHNlbGYtaG9zdGVkIGRvd24g" + - "LS1hbGwgLS1jb25maXJtYCB8CnwgIlNob3cgbWUgdGhlIHN0ZXBzIHdpdGhvdXQgaW52b2tpbmcg" + - "YW55dGhpbmciIHwgYG52Y2YtY2xpIHNlbGYtaG9zdGVkIGRvd24gLS1wbGFuLW9ubHkgLS1jbHVz" + - "dGVyLW5hbWU9WGAgfAp8ICJHaXZlIG1lIFlBTUwgdG8gY29tbWl0ICsgQXJnbyBkZWxldGVzIGxh" + - "dGVyIiB8IGBudmNmLWNsaSBzZWxmLWhvc3RlZCB1bmluc3RhbGwgLS1uby1hcHBseSAtLWNvbXB1" + - "dGUtcGxhbmUgLS1jbHVzdGVyLW5hbWU9WCA+IGRlbGV0ZS55YW1sYCB8CnwgIkp1c3QgcmVtb3Zl" + - "IHRoZSBoZWxtIHJlbGVhc2VzIG9uIGEgY29tcHV0ZSBwbGFuZSAobm8gSUNNUyB1bnJlZ2lzdGVy" + - "LCBubyBkcmFpbikiIHwgYG52Y2YtY2xpIHNlbGYtaG9zdGVkIHVuaW5zdGFsbCAtLWNvbXB1dGUt" + - "cGxhbmUgLS1jbHVzdGVyLW5hbWU9WGAgfAp8ICJKdXN0IHJlbW92ZSB0aGUgY29udHJvbC1wbGFu" + - "ZSBoZWxtIHJlbGVhc2VzIiB8IGBudmNmLWNsaSBzZWxmLWhvc3RlZCB1bmluc3RhbGwgLS1jb250" + - "cm9sLXBsYW5lYCB8CgojIyBTdGVwcyBmb3IgYGRvd24gLS1jbHVzdGVyLW5hbWU9WGAgKHRoZSBz" + - "dGFuZGFyZCBwYXRoKQoKIyMjIDEuIENvbmZpcm0gc2NvcGUgd2l0aCB0aGUgdXNlcgoKQXNrOgot" + - "ICJUZWFyaW5nIGRvd24gZXZlcnl0aGluZyAoY29tcHV0ZSBwbGFuZXMgKyBjb250cm9sIHBsYW5l" + - "ICsgSUNNUyByb3dzKSBvciBqdXN0IG9uZSBjb21wdXRlIHBsYW5lPyIKLSAiQXJlIHRoZXJlIEFD" + - "VElWRSBmdW5jdGlvbiBkZXBsb3ltZW50cyBvbiB0aGlzIGNsdXN0ZXI/IGBudmNmLWNsaSBmdW5j" + - "dGlvbiBkZXBsb3kgbGlzdGAgdG8gY2hlY2suIiAoSW1wb3J0YW50IOKAlCBgZG93bmAgd2lsbCBy" + - "ZWZ1c2Ugd2l0aG91dCBgLS1kcmFpbi1hY3RpdmU9dHJ1ZXxwcm9tcHRgIGlmIGFueSBhcmUgQUNU" + - "SVZFLikKLSAiU2hvdWxkIHdlIHdpcGUgcGVyc2lzdGVudCBzdGF0ZSAoQ2Fzc2FuZHJhIGRhdGEs" + - "IE9wZW5CYW8gc2VhbCBrZXlzLCBzci1kZWZhdWx0IHVzZXIgZGF0YSk/IERlZmF1bHQgaXMgdG8g" + - "KipwcmVzZXJ2ZSoqIHRoZW0uIGAtLXJlbW92ZS1wZXJzaXN0ZW50YCBvcHRzIGluIHRvIGRlbGV0" + - "aW9uLiAqKkxvc3MgaXMgdW5yZWNvdmVyYWJsZS4qKiIKCiMjIyAyLiBSdW4gcGxhbi1vbmx5IGZp" + - "cnN0CgpgYGBzaApudmNmLWNsaSBzZWxmLWhvc3RlZCBkb3duIC0tcGxhbi1vbmx5IC0tY2x1c3Rl" + - "ci1uYW1lPSROQU1FIC0tanNvbiB8IGpxCmBgYAoKVGhpcyBlbWl0cyBhIGBwbGFubmVkYCBldmVu" + - "dCBsaXN0aW5nIGVhY2ggcGhhc2UsIHRoZSBoZWxtIHJlbGVhc2VzIHRoYXQgd291bGQgYmUgdW5p" + - "bnN0YWxsZWQsIHRoZSBJQ01TIHJvd3MgdGhhdCB3b3VsZCBiZSByZW1vdmVkLCBhbmQgRVRBcy4g" + - "Q29weSB0aGUgYHdpbGxVbmluc3RhbGwuY29tbWFuZHNbXWAgYXJyYXkgdG8gdGhlIHVzZXIg4oCU" + - "IHRob3NlIGFyZSB0aGUgbGl0ZXJhbCBgaGVsbSB1bmluc3RhbGwg4oCmYCBpbnZvY2F0aW9ucyB0" + - "aGUgb3JjaGVzdHJhdG9yIHdpbGwgcnVuLgoKIyMjIDMuIEV4ZWN1dGUgdGhlIGRvd24KCmBgYHNo" + - "Cm52Y2YtY2xpIHNlbGYtaG9zdGVkIGRvd24gLS1jbHVzdGVyLW5hbWU9JE5BTUUgLS1qc29uCmBg" + - "YAoKUGhhc2VzICgxLTcsIG1pcnJvcnMgwqc2LjcuMSk6CgoxLiBQcmVmbGlnaHQg4oCUIGt1YmVj" + - "dGwgYWNjZXNzICsgSUNNUyByZWFjaGFibGUKMi4gUmVzb2x2ZSBzdGFjayBidW5kbGUKMy4gRHJh" + - "aW4gYWN0aXZlIGRlcGxveW1lbnRzIOKAlCBydW5zIGBmdW5jdGlvbiBkZXBsb3kgcmVtb3ZlYCBm" + - "b3IgZWFjaCBBQ1RJVkUgZGVwbG95bWVudCwgcG9sbHMgdW50aWwgU1RPUFBFRC4gU3ViamVjdCB0" + - "byBgLS1kcmFpbi1hY3RpdmU9dHJ1ZXxmYWxzZXxwcm9tcHRgIChkZWZhdWx0IGlzIGBwcm9tcHRg" + - "IGluIFRUWSkuCjQuIFVuaW5zdGFsbCBjb21wdXRlIHBsYW5lIOKAlCBkZWxlZ2F0ZXMgdG8gYHVu" + - "aW5zdGFsbCAtLWNvbXB1dGUtcGxhbmVgOyBgaGVsbSB1bmluc3RhbGwgPHJlbGVhc2U+YCBwZXIg" + - "cmVsZWFzZSBpbiByZXZlcnNlLURBRyBvcmRlcgo1LiBSZW1vdmUgcGVyc2lzdGVudCAoc2tpcHBl" + - "ZCB1bmxlc3MgYC0tcmVtb3ZlLXBlcnNpc3RlbnRgKQo2LiBVbnJlZ2lzdGVyIGNsdXN0ZXIgZnJv" + - "bSBJQ01TCjcuIEZpbmFsIHZlcmlmeQoKIyMjIDQuIFRlYXIgZG93biB0aGUgY29udHJvbCBwbGFu" + - "ZSAoaWYgYXBwbGljYWJsZSkKCmBgYHNoCm52Y2YtY2xpIHNlbGYtaG9zdGVkIHVuaW5zdGFsbCAt" + - "LWNvbnRyb2wtcGxhbmUKYGBgCgpPciB2aWEgdGhlIG9yY2hlc3RyYXRvcidzIGAtLWFsbGAgbW9k" + - "ZSBpZiBldmVyeSBjb21wdXRlIHBsYW5lIGlzIGFsc28gZ29pbmcgYXdheSAoc2VlIHN0ZXAgNSku" + - "CgpgdW5pbnN0YWxsIC0tY29udHJvbC1wbGFuZWAgcmVmdXNlcyBpZiBhbnkgY29tcHV0ZSBwbGFu" + - "ZSBpcyBzdGlsbCByZWdpc3RlcmVkIGluIElDTVMuIFVzZSBgLS1mb3JjZS13aXRoLXJlZ2lzdGVy" + - "ZWQtY2x1c3RlcnNgIHRvIG92ZXJyaWRlICoqb25seSoqIGlmIHRoZSB1c2VyIGV4cGxpY2l0bHkg" + - "d2FudHMgdG8gb3JwaGFuIGNvbXB1dGUgcGxhbmVzIChQU0FUIGF1dGggYnJlYWtzIGZvciB0aG9z" + - "ZSBjbHVzdGVycyDigJQgdGhleSB3aWxsIHN0YXJ0IGZhaWxpbmcgZXZlcnkgaGVhbHRoIGNoZWNr" + - "KS4gQWx3YXlzIHN0YXRlIHRoZSBjb25zZXF1ZW5jZSBiZWZvcmUgcGFzc2luZyB0aGUgZmxhZy4K" + - "CiMjIyA1LiBPciwgbnVrZSBldmVyeXRoaW5nCgpgYGBzaApudmNmLWNsaSBzZWxmLWhvc3RlZCBk" + - "b3duIC0tYWxsIC0tY29uZmlybQpgYGAKClRoaXMgaXRlcmF0ZXMgZXZlcnkgcmVnaXN0ZXJlZCBj" + - "b21wdXRlIHBsYW5lIGluIElDTVMsIHJ1bnMgdGhlIHBlci1jbHVzdGVyIGRvd24gZm9yIGVhY2gg" + - "aW4gcGFyYWxsZWwgKGJvdW5kZWQgYnkgYC0tYWxsLWNvbmN1cnJlbmN5YCwgZGVmYXVsdCA0KSwg" + - "dGhlbiBydW5zIGB1bmluc3RhbGwgLS1jb250cm9sLXBsYW5lYC4gSW50ZXJhY3RpdmUgbW9kZSBw" + - "cm9tcHRzIHRoZSBvcGVyYXRvciB3aXRoIHRoZSBjbHVzdGVyIGxpc3QgYmVmb3JlIHByb2NlZWRp" + - "bmc7IGAtLWNvbmZpcm1gIHNraXBzIHRoZSBwcm9tcHQgZm9yIG5vbi1pbnRlcmFjdGl2ZSB1c2Uu" + - "CgojIyBHaXRPcHMgcGF0aCAoaWYgdXNlciBoYXMgQXJnbyAvIEZsdXgpCgpgYGBzaAojIFJlbmRl" + - "ciBkZWxldGUgWUFNTCBmb3IgdGhlIGNvbXB1dGUgcGxhbmU6Cm52Y2YtY2xpIHNlbGYtaG9zdGVk" + - "IHVuaW5zdGFsbCAtLW5vLWFwcGx5IC0tY29tcHV0ZS1wbGFuZSAtLWNsdXN0ZXItbmFtZT0kTkFN" + - "RSA+IGRlbGV0ZS55YW1sCgojIE9wZXJhdG9yIGNvbW1pdHMgZGVsZXRlLnlhbWwgdG8gdGhlaXIg" + - "R2l0T3BzIHJlcG8uIEFyZ28vRmx1eCBhcHBsaWVzIHRoZSBkZWxldGlvbiBvbiBuZXh0IHN5bmMu" + - "CmdpdCBhZGQgZGVsZXRlLnlhbWw7IGdpdCBjb21taXQgLW0gInJlbW92ZSBjb21wdXRlIHBsYW5l" + - "ICROQU1FIjsgZ2l0IHB1c2gKCiMgQWZ0ZXIgQXJnbyBzeW5jIHJlbW92ZXMgdGhlIEs4cyByZXNv" + - "dXJjZXMsIHNlcGFyYXRlbHkgcmVtb3ZlIHRoZSBJQ01TIHJvdzoKbnZjZi1jbGkgY2x1c3RlciBk" + - "ZWxldGUgLS1jbHVzdGVyLWlkPSRDTFVTVEVSX0lECmBgYAoKTm90ZTogYC0tbm8tYXBwbHlgIGRv" + - "ZXMgTk9UIGluY2x1ZGUgdGhlIElDTVMgYGNsdXN0ZXIgZGVsZXRlYCAoaGVsbSBkb2Vzbid0IG1h" + - "bmFnZSB0aGF0KS4gT3BlcmF0b3JzIGZvbGxvd2luZyBHaXRPcHMgbXVzdCBydW4gYG52Y2YtY2xp" + - "IGNsdXN0ZXIgZGVsZXRlYCBzZXBhcmF0ZWx5LCBvciB1c2UgYGRvd25gIHRvIG9yY2hlc3RyYXRl" + - "IGJvdGguCgojIyBGYWlsdXJlIHJlY292ZXJ5CgpJZiBgZG93bmAgcGFydGlhbC1mYWlscyBtaWQt" + - "d2F5LCAqKnJlLXJ1biB0aGUgc2FtZSBjb21tYW5kKiouIFRoZSBvcmNoZXN0cmF0b3IgaXMgaWRl" + - "bXBvdGVudDogYGhlbG0gdW5pbnN0YWxsYCBza2lwcyByZWxlYXNlcyB0aGF0IGFyZSBhbHJlYWR5" + - "IGdvbmUsIGFuZCBgY2x1c3RlciBkZWxldGUgLS1pZ25vcmUtbWlzc2luZ2Agc2tpcHMgSUNNUyBy" + - "b3dzIHRoYXQgYXJlIGFscmVhZHkgZ29uZS4gUGhhc2UgNCArIDYgZW1pdCBgcGhhc2U6IHNraXBw" + - "ZWQgKGFscmVhZHkgY2xlYW4pYCBvbiB0aGUgc2Vjb25kIHJ1bi4KCklmIGEgYHBoYXNlX2ZhaWxl" + - "ZGAgZXZlbnQgc3VyZmFjZXM6Ci0gYGVyckNhdGVnb3J5OiAiaGVsbV9wZW5kaW5nX3VwZ3JhZGUi" + - "LCByZXRyeUNsYXNzOiAiYWZ0ZXJfcmVtZWRpYXRpb24iYCDihpIgcnVuIGBoZWxtIHJvbGxiYWNr" + - "IDxyZWxlYXNlPiAwIC0ta3ViZS1jb250ZXh0PeKApmAgKHRoZSBtZXNzYWdlIGluY2x1ZGVzIHRo" + - "ZSBleGFjdCByZWxlYXNlIG5hbWUpIHRoZW4gcmUtcnVuIGBkb3duYC4gRG8gTk9UIGF1dG8tcm9s" + - "bGJhY2sgd2l0aG91dCB1c2VyIGNvbmZpcm1hdGlvbi4KLSBgZXJyQ2F0ZWdvcnk6ICJjb21wdXRl" + - "X3BsYW5lIiwgcmV0cnlDbGFzczogImFmdGVyX3JlbWVkaWF0aW9uImAgd2l0aCBtZXNzYWdlIGFi" + - "b3V0IEFDVElWRSBkZXBsb3ltZW50cyDihpIgdXNlciBwYXNzZWQgYC0tZHJhaW4tYWN0aXZlPWZh" + - "bHNlYCBidXQgZGVwbG95bWVudHMgZXhpc3QuIFJlLXJ1biB3aXRoIGAtLWRyYWluLWFjdGl2ZT10" + - "cnVlYCBvciBgLS1kcmFpbi1hY3RpdmU9cHJvbXB0YCBhbmQgY29uZmlybSB3aXRoIHRoZSB1c2Vy" + - "LgotIE90aGVyIGNhdGVnb3JpZXMg4oaSIHN1cmZhY2UgYGVyck1lc3NhZ2VgICsgZWFjaCBgcmVt" + - "ZWRpYXRpb25gIHN0cmluZyB2ZXJiYXRpbS4gU1RPUC4gRG8gbm90IHByb3Bvc2UgcmV0cnkgd2l0" + - "aG91dCB1c2VyIGlucHV0LgoKIyMgQWx3YXlzIGNvbmZpcm0KCkZvciBldmVyeSBgbnZjZi1jbGkg" + - "c2VsZi1ob3N0ZWQgZG93bmAgb3IgYHVuaW5zdGFsbGAgaW52b2NhdGlvbiwgZXNwZWNpYWxseSB3" + - "aXRoIGRlc3RydWN0aXZlIGZsYWdzOgotIFN0YXRlIHRoZSBleGFjdCBgLS1jbHVzdGVyLW5hbWVg" + - "IChvciBgLS1hbGxgKS4KLSBTdGF0ZSB3aGF0J3MgbG9zdCAoZS5nLiAiYWxsIGZ1bmN0aW9uIGRl" + - "cGxveW1lbnRzIHNjaGVkdWxlZCBvbiBgbmNwLWxvY2FsYCB3aWxsIHN0b3A7IGNvbXB1dGUgcGxh" + - "bmUgd2lsbCBkZXJlZ2lzdGVyIGZyb20gSUNNUyIpLgotIElmIGAtLXJlbW92ZS1wZXJzaXN0ZW50" + - "YCBpcyBiZWluZyBjb25zaWRlcmVkLCBzdGF0ZSB0aGF0IENhc3NhbmRyYSByb3dzICsgT3BlbkJh" + - "byBzZWFsIGtleXMgd2lsbCBiZSBkZWxldGVkIGFuZCB0aGF0IHRoaXMgaXMgdW5yZWNvdmVyYWJs" + - "ZS4KLSBXYWl0IGZvciBleHBsaWNpdCB1c2VyIGNvbmZpcm1hdGlvbi4KLSBOZXZlciBwcm9wb3Nl" + - "IGAtLWZvcmNlLXdpdGgtcmVnaXN0ZXJlZC1jbHVzdGVyc2Agd2l0aG91dCBleHBsYWluaW5nIHRo" + - "YXQgY29tcHV0ZSBwbGFuZXMgd2lsbCBiZSBvcnBoYW5lZC4KLSBOZXZlciBwcm9wb3NlIGAtLXJl" + - "bW92ZS1wZXJzaXN0ZW50YCB3aXRob3V0IGV4cGxhaW5pbmcgdGhlIGxvc3MuCgojIyBNYW51YWwg" + - "ZmFsbGJhY2sgKGlmIGBudmNmLWNsaSBzZWxmLWhvc3RlZCB7dW5pbnN0YWxsLGRvd259YCBpcyB1" + - "bmF2YWlsYWJsZSkKCklmIHRoZSB1c2VyIGlzIG9uIGEgQ0xJIHZlcnNpb24gb2xkZXIgdGhhbiBN" + - "KzExLCBmYWxsIGJhY2sgdG86CgpgYGBzaAojIFBlciBjb21wdXRlIHBsYW5lIChvbiBpdHMga3Vi" + - "ZWN0bCBjb250ZXh0KToKaGVsbSB1bmluc3RhbGwgbnZjYS1hZ2VudCAtbiBudmNhLXN5c3RlbQpo" + - "ZWxtIHVuaW5zdGFsbCBudmNhLW9wZXJhdG9yIC1uIG52Y2Etb3BlcmF0b3IKaGVsbSB1bmluc3Rh" + - "bGwgaW1hZ2UtY3JlZGVudGlhbC1oZWxwZXIgLW4gbnZjYS1zeXN0ZW0KaGVsbSB1bmluc3RhbGwg" + - "c2hhcmVkc3RvcmFnZSAtbiBudmNhLXN5c3RlbQoKIyBEcmFpbiB0aGUgSUNNUyByb3c6Cm52Y2Yt" + - "Y2xpIGNsdXN0ZXIgZGVsZXRlIC0tY2x1c3Rlci1pZD08aWQ+CgojIENvbnRyb2wgcGxhbmUgdGVh" + - "cmRvd24gKG9uIGl0cyBrdWJlY3RsIGNvbnRleHQpOgpjZCBudmNmLXNlbGYtbWFuYWdlZC1zdGFj" + - "awptYWtlIGRlc3Ryb3kgICAjIGludm9rZXMgaGVsbWZpbGUgZGVzdHJveSBhY3Jvc3MgYWxsIHJl" + - "bGVhc2VzCgojIElmIHVzaW5nIHNwbGl0IHN0YWNrIGJ1bmRsZXMsIHRlYXJkb3duIGNvbXB1dGUg" + - "cGxhbmUgcmVsZWFzZXMgdG9vOgpjZCAuLi9udmNmLWNvbXB1dGUtcGxhbmUtc3RhY2sKbWFrZSBk" + - "ZXN0cm95CmBgYAoKVGhpcyBpcyB0aGUgbWFudWFsIHBhdGg7IHByZWZlciB0aGUgbmV3IHN1YmNv" + - "bW1hbmRzIHdoZW5ldmVyIHRoZXkncmUgaW5zdGFsbGVkLgoKIyMgV2hhdCBga3ViZWN0bCBkZWxl" + - "dGUgcHZjYCBkb2VzCgpJZiB0aGUgdXNlciBhc2tzICJ3aHkgaXMgbXkgbmV3IGluc3RhbGwgc2Vl" + - "aW5nIHRoZSBvbGQgZGF0YT8iIOKAlCB0aGUgU3RhdGVmdWxTZXQgUFZDcyAoQ2Fzc2FuZHJhLCBP" + - "cGVuQmFvKSBhcmUgTk9UIGRlbGV0ZWQgYnkgYGhlbG0gdW5pbnN0YWxsYCAoYW5kIHNvIGFyZSBO" + - "T1QgZGVsZXRlZCBieSBgbnZjZi1jbGkgc2VsZi1ob3N0ZWQgZG93bmAgZWl0aGVyLCBieSBkZWZh" + - "dWx0KS4gVGhleSBwZXJzaXN0IGludGVudGlvbmFsbHkgc28gYSByZS1gdXBgIGNhbiByZXN1bWUg" + - "YWdhaW5zdCBleGlzdGluZyBkYXRhLiBUbyB3aXBlIGNvbXBsZXRlbHkgb24gdGhlIG5leHQgYGRv" + - "d25gOgoKYGBgc2gKbnZjZi1jbGkgc2VsZi1ob3N0ZWQgZG93biAtLWNsdXN0ZXItbmFtZT1uY3At" + - "bG9jYWwgLS1yZW1vdmUtcGVyc2lzdGVudApgYGAKCk9yLCBwb3N0LWRvd24sIG1hbnVhbGx5OgoK" + - "YGBgc2gKa3ViZWN0bCBkZWxldGUgcHZjIC1uIGNhc3NhbmRyYS1zeXN0ZW0gLS1hbGwKa3ViZWN0" + - "bCBkZWxldGUgcHZjIC1uIHZhdWx0LXN5c3RlbSAtLWFsbApgYGAKCioqQ29uZmlybSB3aXRoIHVz" + - "ZXIuKiogVGhpcyBpcyB0aGUgZGVzdHJ1Y3RpdmUgc3RlcC4KUEsHCBKTM1ngIQAA4CEAAFBLAwQU" + - "AAgAAAAAACEAAAAAAAAAAAAAAAAAMAAJAGRhdGEvbnZjZi1zZWxmLW1hbmFnZWQtY2xpL3JlZmVy" + - "ZW5jZS9jb21tYW5kcy5tZFVUBQABAKbOEiMgYG52Y2YtY2xpYCBjb21tYW5kIHJlZmVyZW5jZQoK" + - "RnVsbCBzdWJjb21tYW5kIGxpc3QuIEFsd2F5cyBwYWlyIHdpdGggW2ZsYWdzLm1kXShmbGFncy5t" + - "ZCkgZm9yIGdsb2JhbCBmbGFncyBhbmQgW2V4aXQtY29kZXMubWRdKGV4aXQtY29kZXMubWQpIGZv" + - "ciByZXR1cm4gY29kZXMuCgojIyBTZWxmLWhvc3RlZCBsaWZlY3ljbGUKCnwgQ29tbWFuZCB8IFB1" + - "cnBvc2UgfCBPdXRwdXQgfCBOb3RlcyB8CnwtLS18LS0tfC0tLXwtLS18CnwgYHNlbGYtaG9zdGVk" + - "IGNoZWNrIC0tcHJlIFtmbGFnc11gIHwgUHJlLWZsaWdodCB2YWxpZGF0aW9uIChubyBhZG1pbiBj" + - "cmVkcykgfCBzdHJlYW1pbmcgZXZlbnRzIHwgUGVyLXJvbGUgd2l0aCBgLS1jb250cm9sLXBsYW5l" + - "LWNvbnRleHRgIC8gYC0tY29tcHV0ZS1wbGFuZS1jb250ZXh0YDsgYC0tbG9jYWwtb25seWAgc2tp" + - "cHMga3ViZWN0bCB8CnwgYHNlbGYtaG9zdGVkIGNoZWNrIC0tY29udHJvbC1wbGFuZSBbLS13YWl0" + - "IERVUl1gIHwgRXZlcnkgQ1AgcmVsZWFzZSBoZWFsdGh5IHwgc3RyZWFtaW5nIGV2ZW50cyB8IFBv" + - "bGxzIHVudGlsIHBhc3Mgb3IgYC0td2FpdGAgZWxhcHNlcyB8CnwgYHNlbGYtaG9zdGVkIGNoZWNr" + - "IC0tY29tcHV0ZS1wbGFuZSAtLWNsdXN0ZXItbmFtZT1YIFstLXdhaXQgRFVSXWAgfCBQZXItY2x1" + - "c3RlciB3b3JrZXIgc3RhdGUgfCBzdHJlYW1pbmcgZXZlbnRzIHwgTlZDQSArIG9wZXJhdG9yICsg" + - "SldLUy1maW5nZXJwcmludCBtYXRjaCB8CnwgYHNlbGYtaG9zdGVkIGNoZWNrIC0tYWxsIFstLXdh" + - "aXQgRFVSXWAgfCBGYW4tb3V0IG92ZXIgYWxsIG9mIHRoZSBhYm92ZSB8IHN0cmVhbWluZyBldmVu" + - "dHMgfCB8CnwgYHNlbGYtaG9zdGVkIGluc3RhbGwgLS1jb250cm9sLXBsYW5lYCB8IFJlbmRlciBj" + - "b250cm9sLXBsYW5lIG1hbmlmZXN0cyB8IFlBTUwgb24gc3Rkb3V0IHwgUGlwZSB0byBga3ViZWN0" + - "bCBhcHBseSAtZiAtYCB8CnwgYHNlbGYtaG9zdGVkIGluc3RhbGwgLS1jb21wdXRlLXBsYW5lIC0t" + - "Y2x1c3Rlci1uYW1lPVhgIHwgUmVnaXN0ZXIgY2x1c3RlciArIHJlbmRlciBjb21wdXRlIG1hbmlm" + - "ZXN0cyB8IFlBTUwgb24gc3Rkb3V0IHwgT25lIGludm9jYXRpb24gcGVyIEdQVSBjbHVzdGVyIHwK" + - "fCBgc2VsZi1ob3N0ZWQgdXAgLS1jbHVzdGVyLW5hbWU9WGAgfCBPbmUtc2hvdCBmaXJzdCBpbnN0" + - "YWxsIChib3RoIHBsYW5lcykgfCAoZW1wdHkpIHN0ZG91dCwgcHJvZ3Jlc3Mgb24gc3RkZXJyIHwg" + - "QWx3YXlzIGluc3RhbGxzIGJvdGggcGxhbmVzOyBmb3IgY29tcHV0ZS1vbmx5IHVzZSBgYWRkLWNv" + - "bXB1dGUtcGxhbmVgIHwKfCBgc2VsZi1ob3N0ZWQgdXAgLS1wbGFuLW9ubHkgLS1jbHVzdGVyLW5h" + - "bWU9WGAgfCBEcnktcnVuIHByZXZpZXcgfCBKU09OTCBvbiBzdGRlcnIgfCBBZ2VudC1mcmllbmRs" + - "eSwgbm8gY2x1c3RlciBjaGFuZ2VzIHwKfCBgc2VsZi1ob3N0ZWQgYWRkLWNvbXB1dGUtcGxhbmUg" + - "LS1jbHVzdGVyLW5hbWU9WCAtLWNvbXB1dGUtcGxhbmUtY29udGV4dD1ZIC0taWNtcy11cmw9VVJM" + - "IC0tdG9rZW49JEpXVGAgfCBBZGQgYSBjb21wdXRlIHBsYW5lIHRvIGFuIGV4aXN0aW5nIGNvbnRy" + - "b2wgcGxhbmUgfCBwcm9ncmVzcyBvbiBzdGRlcnIgfCBGb3IgMm5kLCAzcmQsIOKApiBHUFUgY2x1" + - "c3RlciBhZnRlciB0aGUgZmlyc3QgaW5zdGFsbC4gQ1Agbm90IHRvdWNoZWQuIHwKfCBgc2VsZi1o" + - "b3N0ZWQgc3RhdHVzIFstLWNsdXN0ZXItbmFtZT1YXSBbLS13YXRjaF1gIHwgU25hcHNob3QgY2x1" + - "c3RlciBoZWFsdGggfCBUVFkvcGxhaW4vSlNPTkwgfCBgLS13YXRjaGAgZm9yIGxpdmUgcmUtcmVu" + - "ZGVyIHwKfCBgc2VsZi1ob3N0ZWQgdW5pbnN0YWxsIC0tY29tcHV0ZS1wbGFuZSAtLWNsdXN0ZXIt" + - "bmFtZT1YYCB8IFBlci1wbGFuZSBwcmltaXRpdmU6IGBoZWxtZmlsZSBkZXN0cm95YCBvbiBvbmUg" + - "Y29tcHV0ZSBwbGFuZSAobm8gSUNNUyB1bnJlZ2lzdGVyLCBubyBkcmFpbikgfCBwcm9ncmVzcyB8" + - "IEp1c3QgdGhlIGhlbG0gcmVsZWFzZXMgb24gdGhhdCBjb21wdXRlIHBsYW5lIHwKfCBgc2VsZi1o" + - "b3N0ZWQgdW5pbnN0YWxsIC0tY29udHJvbC1wbGFuZSBbLS1mb3JjZS13aXRoLXJlZ2lzdGVyZWQt" + - "Y2x1c3RlcnNdYCB8IFBlci1wbGFuZSBwcmltaXRpdmU6IGBoZWxtZmlsZSBkZXN0cm95YCBvbiB0" + - "aGUgY29udHJvbCBwbGFuZSB8IHByb2dyZXNzIHwgUmVmdXNlcyBpZiBjb21wdXRlIHBsYW5lcyBz" + - "dGlsbCByZWdpc3RlcmVkIHVubGVzcyBgLS1mb3JjZS13aXRoLXJlZ2lzdGVyZWQtY2x1c3RlcnNg" + - "IHwKfCBgc2VsZi1ob3N0ZWQgdW5pbnN0YWxsIC0tbm8tYXBwbHkgPHBsYW5lPmAgfCBSZW5kZXIg" + - "ZGVsZXRlIFlBTUwgdmlhIGBoZWxtIGdldCBtYW5pZmVzdGAgcGVyIHJlbGVhc2UgfCBZQU1MIG9u" + - "IHN0ZG91dCB8IEdpdE9wczsgcGlwZSB0byBga3ViZWN0bCBkZWxldGUgLWYgLWAgb3IgY29tbWl0" + - "ICsgQXJnbyBhcHBsaWVzLiBNaXJyb3JzIGBpbnN0YWxsIC0tbm8tYXBwbHlgIHwKfCBgc2VsZi1o" + - "b3N0ZWQgZG93biAtLWNsdXN0ZXItbmFtZT1YIFstLWRyYWluLWFjdGl2ZV0gWy0tcmVtb3ZlLXBl" + - "cnNpc3RlbnRdYCB8IE9yY2hlc3RyYXRvcjogZHJhaW4g4oaSIHVuaW5zdGFsbCAtLWNvbXB1dGUt" + - "cGxhbmUg4oaSIGNsdXN0ZXIgZGVsZXRlIGluIElDTVMgfCBwcm9ncmVzcyB8IFN5bW1ldHJpYyBj" + - "b21wYW5pb24gdG8gYHVwIC0tY2x1c3Rlci1uYW1lPVhgIHwKfCBgc2VsZi1ob3N0ZWQgZG93biAt" + - "LWFsbCBbLS1jb25maXJtXWAgfCBPcmNoZXN0cmF0b3I6IHRlYXIgZG93biBldmVyeSByZWdpc3Rl" + - "cmVkIGNvbXB1dGUgcGxhbmUgKyBjb250cm9sIHBsYW5lIHwgcHJvZ3Jlc3MgfCBCb3VuZGVkIHBh" + - "cmFsbGVsaXNtIHZpYSBgLS1hbGwtY29uY3VycmVuY3lgIChkZWZhdWx0IDQpOyBgLS1jb25maXJt" + - "YCByZXF1aXJlZCBpbiBub24taW50ZXJhY3RpdmUgfAp8IGBzZWxmLWhvc3RlZCBkb3duIC0tcGxh" + - "bi1vbmx5IC4uLmAgfCBPcmNoZXN0cmF0b3IgZHJ5LXJ1bjogcGhhc2VzICsgaGVsbSByZWxlYXNl" + - "cyArIElDTVMgcm93cyArIEVUQXMgKG5vIGhlbG0vaGVsbWZpbGUgY29udGFjdCkgfCBKU09OTCB8" + - "ICoqQWx3YXlzIHJ1biBiZWZvcmUgYW55IGFjdHVhbCBgZG93bmAqKiB8CgojIyBDbHVzdGVyIG1h" + - "bmFnZW1lbnQKCnwgQ29tbWFuZCB8IFB1cnBvc2UgfCBOb3RlcyB8CnwtLS18LS0tfC0tLXwKfCBg" + - "Y2x1c3RlciByZWdpc3RlciAtLW5hbWU9WCAtLW5jYS1pZD1ZIFstLXJlZ2lvbj1aXSBbLS1pZ25v" + - "cmUtZXhpc3RpbmddYCB8IFJlZ2lzdGVyIGEgSldLUytPSURDIHdpdGggSUNNUyB8IFVzZWQgYnkg" + - "YHVwYCBQaGFzZSA1IGludGVybmFsbHk7IHN0YW5kYWxvbmUgZm9yIG1hbnVhbCByZWdpc3RyYXRp" + - "b24gfAp8IGBjbHVzdGVyIGxpc3QtcmVnaXN0ZXJlZCAtLW5jYS1pZD1ZIFstLWljbXMtdXJsPVVS" + - "TF1gIHwgTGlzdCBzZWxmLWhvc3RlZCBjbHVzdGVyIHJlZ2lzdHJhdGlvbnMgZnJvbSBJQ01TIHwg" + - "VXNlcyB0aGUgYWRtaW4gdG9rZW47IGAtLWpzb25gIGZvciBtYWNoaW5lLXJlYWRhYmxlIG91dHB1" + - "dCB8CnwgYGNsdXN0ZXIgcm90YXRlIC0tY2x1c3Rlci1pZD1JRGAgfCBSZS1mZXRjaCBKV0tTIGZy" + - "b20gSzhzIGFuZCBQVVQgdG8gSUNNUyB8IEFmdGVyIEs4cyBBUEkgc2VydmVyIHNpZ25pbmcga2V5" + - "IHJvdGF0aW9uIHwKfCBgY2x1c3RlciBkZWxldGUgLS1jbHVzdGVyLWlkPUlEYCB8IFJlbW92ZSBJ" + - "Q01TIHJvdyB8ICoqREVTVFJVQ1RJVkU6IGNvbmZpcm0gd2l0aCB1c2VyKiogfAoKIyMgRnVuY3Rp" + - "b25zCgp8IENvbW1hbmQgfCBQdXJwb3NlIHwgTm90ZXMgfAp8LS0tfC0tLXwtLS18CnwgYGZ1bmN0" + - "aW9uIGNyZWF0ZSAtLWlucHV0LWZpbGU9RklMRWAgfCBDcmVhdGUgZnVuY3Rpb24gbWV0YWRhdGEg" + - "fCBSZXR1cm5zIEZ1bmN0aW9uIElEICsgVmVyc2lvbiBJRDsgTExNIGZ1bmN0aW9ucyB1c2UgYGZ1" + - "bmN0aW9uVHlwZTogIkxMTSJgIGFuZCBgbW9kZWxzW10ubGxtQ29uZmlnLnVyaXNgIGZvciBgL3Yx" + - "L2NoYXQvY29tcGxldGlvbnNgLCBgL3YxL3Jlc3BvbnNlc2AsIGFuZCBgL3YxL2VtYmVkZGluZ3Ng" + - "IHwKfCBgZnVuY3Rpb24gbGlzdGAgLyBgZnVuY3Rpb24gbGlzdC1pZHNgIHwgTGlzdCBmdW5jdGlv" + - "bnMgLyBJRHMgb25seSB8IHwKfCBgZnVuY3Rpb24gZ2V0IC0tZnVuY3Rpb24taWQ9SUQgLS12ZXJz" + - "aW9uLWlkPVZJRGAgfCBGdW5jdGlvbiBtZXRhZGF0YSB8IHwKfCBgZnVuY3Rpb24gdXBkYXRlIC0t" + - "ZnVuY3Rpb24taWQ9SUQgLS12ZXJzaW9uLWlkPVZJRCAtLXRhZ3M9VEFHWyxUQUddYCB8IFVwZGF0" + - "ZSBmdW5jdGlvbiB0YWdzIHwgfAp8IGBmdW5jdGlvbiB1cGRhdGUgLS1mdW5jdGlvbi1pZD1JRCAt" + - "LXZlcnNpb24taWQ9VklEIC0tbGxtLW1vZGVsLXVwZGF0ZT1TUEVDYCB8IFVwZGF0ZSBMTE0gbW9k" + - "ZWwgcm91dGluZyBjb25maWcgfCBgU1BFQ2AgdXNlcyBgbmFtZT08bW9kZWw+LHJvdXRpbmdNZXRo" + - "b2Q9PG1ldGhvZD4sdG9rZW5SYXRlTGltaXQ9PGxpbWl0PmA7IGFjY2VwdGVkIG1ldGhvZHMgYXJl" + - "IGxpc3RlZCBpbiBbZmxhZ3MubWRdKGZsYWdzLm1kKSB8CnwgYGZ1bmN0aW9uIGRlcGxveSBjcmVh" + - "dGUgLS1pbnB1dC1maWxlPUZJTEVgIHwgU2NoZWR1bGUgYSBkZXBsb3ltZW50IHwgQmxvY2tzIHVu" + - "dGlsIEFDVElWRSAoZGVmYXVsdCA5MDBzKSB8CnwgYGZ1bmN0aW9uIGRlcGxveSBnZXQgLS1mdW5j" + - "dGlvbi1pZD1JRCAtLXZlcnNpb24taWQ9VklEIFstLWpzb25dYCB8IERlcGxveW1lbnQgc3RhdHVz" + - "IHwgYGZ1bmN0aW9uU3RhdHVzOiBBQ1RJVkVcfERFUExPWUlOR1x8RVJST1JcfEZBSUxFRGAgfAp8" + - "IGBmdW5jdGlvbiBkZXBsb3kgdXBkYXRlIC0taW5wdXQtZmlsZT1GSUxFYCB8IE1vZGlmeSBhIGRl" + - "cGxveW1lbnQgaW4gcGxhY2UgfCB8CnwgYGZ1bmN0aW9uIGRlcGxveSByZW1vdmUgLS1mdW5jdGlv" + - "bi1pZD1JRCAtLXZlcnNpb24taWQ9VklEYCB8IFN0b3AgYSBkZXBsb3ltZW50LCBrZWVwIGZ1bmN0" + - "aW9uIHJlY29yZCB8IHwKfCBgZnVuY3Rpb24gaW52b2tlIC0taW5wdXQtZmlsZT1GSUxFYCB8IENh" + - "bGwgYSByZWd1bGFyIGZ1bmN0aW9uIHwgUmVxdWlyZXMgQVBJIGtleSAobm90IGFkbWluIHRva2Vu" + - "KTsgTExNIGZ1bmN0aW9ucyBhcmUgaW52b2tlZCB0aHJvdWdoIGBsbG0uaW52b2NhdGlvbi48ZG9t" + - "YWluPmAgd2l0aCBgbW9kZWw6ICI8ZnVuY3Rpb24taWQ+Lzxtb2RlbC1uYW1lPiJgIHwKfCBgZnVu" + - "Y3Rpb24gZGVsZXRlIC0tZnVuY3Rpb24taWQ9SUQgLS12ZXJzaW9uLWlkPVZJRGAgfCBSZW1vdmUg" + - "ZnVuY3Rpb24gKyBkZXBsb3ltZW50IHwgKipERVNUUlVDVElWRTogY29uZmlybSB3aXRoIHVzZXIq" + - "KiB8CgojIyBUYXNrcwoKVGFzayBjb21tYW5kcyByZXF1aXJlIGBOVkNGX0FQSV9LRVlgIHNldCB0" + - "byBhIHRhc2stc2NvcGVkIGtleSBhbmQgYE5WQ0ZfQkFTRV9OVkNUX1VSTGAgc2V0IHRvIHRoZSBO" + - "VkNUIGdhdGV3YXkgZW5kcG9pbnQuIEluIGEgZnJlc2ggc2Vzc2lvbiwgcmVhZCBgbnZjdEFwaUtl" + - "eWAgZnJvbSBgfi8ubnZjZi1jbGkuc3RhdGVgIGFuZCBpbmplY3QgaXQgYXMgYE5WQ0ZfQVBJX0tF" + - "WWAgd2l0aG91dCBsb2dnaW5nIHRoZSB2YWx1ZTsgY2hlY2sgYG52Y3RBcGlLZXlFeHBpcmF0aW9u" + - "YCBmaXJzdCBhbmQgcmVnZW5lcmF0ZSB3aXRoIGBhcGkta2V5IGdlbmVyYXRlIC0tZm9yIHRhc2sg" + - "LS12YWxpZGF0ZWAgaWYgZXhwaXJlZC4gUnVuIGBhcGkta2V5IGdlbmVyYXRlIC0tZm9yIHRhc2tg" + - "IGFmdGVyIGBpbml0YCB0byBtaW50IGEgbmV3IGtleS4KCnwgQ29tbWFuZCB8IFB1cnBvc2UgfCBO" + - "b3RlcyB8CnwtLS18LS0tfC0tLXwKfCBgdGFzayBjcmVhdGUgLS1uYW1lPVggLS1ncHU9R1BVIC0t" + - "aW5zdGFuY2UtdHlwZT1UWVBFIC0taW1hZ2U9SU1HYCB8IFN1Ym1pdCBhIGNvbnRhaW5lciB0YXNr" + - "IHwgU2F2ZXMgdGFzayBJRCB0byBDTEkgc3RhdGU7IHVzZSBgLS1pbnB1dC1maWxlYCBmb3IgcmVw" + - "ZWF0YWJsZSBjb25maWdzIHwKfCBgdGFzayBjcmVhdGUgLS1uYW1lPVggLS1ncHU9R1BVIC0taW5z" + - "dGFuY2UtdHlwZT1UWVBFIC0taGVsbS1jaGFydD1DSEFSVGAgfCBTdWJtaXQgYSBIZWxtIHRhc2sg" + - "fCBgLS1oZWxtLWNoYXJ0YCByZXBsYWNlcyBgLS1pbWFnZWAgfAp8IGB0YXNrIGNyZWF0ZSAtLWlu" + - "cHV0LWZpbGU9RklMRWAgfCBTdWJtaXQgYSB0YXNrIGZyb20gYSBKU09OIGNvbmZpZyBmaWxlIHwg" + - "UmVjb21tZW5kZWQgZm9yIHJlcGVhdGFibGUgY29uZmlndXJhdGlvbnMgfAp8IGB0YXNrIGxpc3Qg" + - "Wy0tc3RhdHVzPVNUQVRVU10gWy0tbGltaXQ9Tl1gIHwgTGlzdCB0YXNrcywgb3B0aW9uYWxseSBm" + - "aWx0ZXJlZCBieSBzdGF0dXMgfCBTdGF0dXNlczogYFFVRVVFRGAsIGBMQVVOQ0hFRGAsIGBSVU5O" + - "SU5HYCwgYENPTVBMRVRFRGAsIGBFUlJPUkVEYCwgYENBTkNFTEVEYCwgYEVYQ0VFREVEX01BWF9S" + - "VU5USU1FX0RVUkFUSU9OYCwgYEVYQ0VFREVEX01BWF9RVUVVRURfRFVSQVRJT05gIHwKfCBgdGFz" + - "ayBnZXQgW3Rhc2tJZF1gIHwgR2V0IHRhc2sgZGV0YWlscyB8IFVzZXMgc2F2ZWQgdGFzayBJRCBm" + - "cm9tIHN0YXRlIGlmIG9taXR0ZWQgfAp8IGB0YXNrIGV2ZW50cyBbdGFza0lkXSBbLS1saW1pdD1O" + - "XWAgfCBMaXN0IGxpZmVjeWNsZSBldmVudHMgZm9yIGEgdGFzayB8IHwKfCBgdGFzayByZXN1bHRz" + - "IFt0YXNrSWRdYCB8IExpc3QgcmVzdWx0IGFydGlmYWN0cyBmb3IgYSBjb21wbGV0ZWQgdGFzayB8" + - "IFJldHVybnMgZW1wdHkgbGlzdCB3aGVuIGByZXN1bHRIYW5kbGluZ1N0cmF0ZWd5YCBpcyBgTk9O" + - "RWA7IHJlc3VsdCB1cGxvYWQgbm90IHlldCBzdXBwb3J0ZWQgfAp8IGB0YXNrIGNhbmNlbCBbdGFz" + - "a0lkXWAgfCBDYW5jZWwgYSBydW5uaW5nIHRhc2sgfCBOby1vcCBpZiBhbHJlYWR5IGluIHRlcm1p" + - "bmFsIHN0YXRlIHwKfCBgdGFzayBkZWxldGUgW3Rhc2tJZF1gIHwgRGVsZXRlIGEgdGFzayByZWNv" + - "cmQgfCAqKlN0b3AsIHN0YXRlIHRhc2sgSUQgKyBjdXJyZW50IHN0YXR1cywgYW5kIHdhaXQgZm9y" + - "IGEgc3Vic2VxdWVudCB1c2VyIHJlcGx5IGV4cGxpY2l0bHkgY29uZmlybWluZyBkZWxldGlvbiBv" + - "ZiB0aGF0IHNwZWNpZmljIHRhc2suIERvIG5vdCB0cmVhdCB0aGUgb3JpZ2luYWwgZGVsZXRlIHJl" + - "cXVlc3QgYXMgY29uZmlybWF0aW9uLioqIHwKfCBgdGFzayB1cGRhdGUtc2VjcmV0cyBbdGFza0lk" + - "XSAtLXNlY3JldHMgTkFNRT12YWx1ZWAgfCBVcGRhdGUgc2VjcmV0cyBvbiBhIHRhc2s7IHN1cHBs" + - "aWVkIHNlY3JldHMgYXJlIGFkZGVkIG9yIHVwZGF0ZWQgYnkgbmFtZSwgZXhpc3Rpbmcgc2VjcmV0" + - "cyBub3QgaW4gdGhlIHJlcXVlc3QgYXJlIHByZXNlcnZlZCB8IFZhbHVlcyBhcmUgZW5jcnlwdGVk" + - "IGF0IHJlc3QgfAp8IGB0YXNrIGJ1bGsgLS10YXNrLWlkcz1JRDFbLElEMizigKZdYCB8IEZldGNo" + - "IGRldGFpbHMgZm9yIG11bHRpcGxlIHRhc2tzIGluIG9uZSByZXF1ZXN0IHwgfAoKIyMgQXV0aAoK" + - "fCBDb21tYW5kIHwgUHVycG9zZSB8IE5vdGVzIHwKfC0tLXwtLS18LS0tfAp8IGBpbml0YCB8IE1p" + - "bnQgYWRtaW4gdG9rZW4gZnJvbSBBUEkgS2V5cyB2aWEgcHVibGljIGFwaSBnYXRld2F5IHwgSWRl" + - "bXBvdGVudDsgd3JpdGVzIGB+Ly5udmNmLWNsaS5zdGF0ZWA7IGNsZWFycyBzYXZlZCBmdW5jdGlv" + - "biBzdGF0ZSBhbmQgYWxsIEFQSSBrZXlzIChmdW5jdGlvbiBhbmQgdGFzaykgfAp8IGBzdGF0dXNg" + - "IHwgU2hvdyBDTEkgc3RhdGUgKHRva2VuLCBsYXN0IGVuZHBvaW50cywgZnVuY3Rpb24gY29udGV4" + - "dCkgfCBEaXN0aW5jdCBmcm9tIGBzZWxmLWhvc3RlZCBzdGF0dXNgIHwKfCBgYXBpLWtleSBnZW5l" + - "cmF0ZSBbLS1mb3IgZnVuY3Rpb25cfHRhc2tdIFstLWRlc2NyaXB0aW9uPeKApl0gWy0tZXhwaXJl" + - "cy1pbj3igKZdYCB8IE1pbnQgQVBJIGtleXMgfCBEZWZhdWx0IChubyBgLS1mb3JgKTogZ2VuZXJh" + - "dGVzIGJvdGggYSBmdW5jdGlvbiBrZXkgYW5kIGEgdGFzayBrZXk7IGAtLWZvciBmdW5jdGlvbmAg" + - "b3IgYC0tZm9yIHRhc2tgIGdlbmVyYXRlcyBvbmUgb25seTsgYC0tc2NvcGVzYCByZXF1aXJlcyBg" + - "LS1mb3JgIHwKfCBgYXBpLWtleSBnZW5lcmF0ZSAtLXZhbGlkYXRlYCB8IE1pbnQgYW5kIGltbWVk" + - "aWF0ZWx5IHZhbGlkYXRlIGVhY2ggZ2VuZXJhdGVkIGtleSB8IFZhbGlkYXRlcyBlYWNoIGtleSBh" + - "Z2FpbnN0IGl0cyBjb3JyZWN0IGF1ZGllbmNlIChOVkNGIGZvciBmdW5jdGlvbiBrZXlzLCBOVkNU" + - "IGZvciB0YXNrIGtleXMpIHwKfCBgYXBpLWtleSBsaXN0YCB8IExpc3QgQVBJIGtleXMgZm9yIGN1" + - "cnJlbnQgb3duZXIgfCBMaXN0cyBOVkNGLXNjb3BlZCBrZXlzIG9ubHkgfAp8IGBhcGkta2V5IGRl" + - "bGV0ZSBLRVktSURgIC8gYGFwaS1rZXkgcmV2b2tlIEtFWS1JRGAgfCBSZW1vdmUgYW4gQVBJIGtl" + - "eSB8ICoqQ29uZmlybSB3aXRoIHVzZXIqKiB8CnwgYGFwaS1rZXkgc2hvd2AgfCBTaG93IGN1cnJl" + - "bnRseSBzYXZlZCBBUEkga2V5IGZyb20gc3RhdGUgfCB8CgojIyBBZ2VudCBza2lsbAoKfCBDb21t" + - "YW5kIHwgUHVycG9zZSB8IE5vdGVzIHwKfC0tLXwtLS18LS0tfAp8IGBhZ2VudC1za2lsbCBpbnN0" + - "YWxsIFstLXRhcmdldD1ESVJdYCB8IEluc3RhbGwgYWxsIGJ1bmRsZWQgcHVibGljIHVzZXIgc2tp" + - "bGxzIGludG8gYH4vLmNsYXVkZS9za2lsbHMvYCBhbmQgYH4vLmFnZW50cy9za2lsbHMvYCB8IERl" + - "ZmF1bHQ6IGJvdGggYmFzZSBza2lsbHMgZGlyZWN0b3JpZXMgfAp8IGBhZ2VudC1za2lsbCB1bmlu" + - "c3RhbGwgWy0tdGFyZ2V0PURJUl1gIHwgUmVtb3ZlIG9ubHkgYnVuZGxlZCBwdWJsaWMgdXNlciBz" + - "a2lsbHMgZnJvbSB0aGUgdGFyZ2V0IGJhc2Ugc2tpbGxzIGRpcmVjdG9yaWVzIHwgSWRlbXBvdGVu" + - "dDsgdW5yZWxhdGVkIHNraWxscyByZW1haW4gfAp8IGBhZ2VudC1za2lsbCBzaG93IFstLWZpbGU9" + - "UkVMXWAgfCBQcmludCBidW5kbGVkIGBudmNmLXNlbGYtbWFuYWdlZC1jbGkvU0tJTEwubWRgIG9y" + - "IGFub3RoZXIgZW1iZWRkZWQgZmlsZSB8IEZvciBkZWJ1Z2dpbmcgfAp8IGBhZ2VudC1za2lsbCB2" + - "ZXJzaW9uYCB8IFByaW50IGJ1aWxkIFNIQSBhbmQgZW1iZWRkZWQgcHVibGljIHVzZXIgc2tpbGwg" + - "c3VtbWFyeSB8IHwKUEsHCHIND2QhIwAAISMAAFBLAwQUAAgAAAAAACEAAAAAAAAAAAAAAAAAMgAJ" + - "AGRhdGEvbnZjZi1zZWxmLW1hbmFnZWQtY2xpL3JlZmVyZW5jZS9leGl0LWNvZGVzLm1kVVQFAAEA" + - "ps4SIyBgbnZjZi1jbGlgIGV4aXQgY29kZXMKClN0YWJsZSBhY3Jvc3Mgc3ViY29tbWFuZHMuIFVz" + - "ZSB0aGVzZSB0byBkcml2ZSBhZ2VudCByZXRyeSAvIHN1cmZhY2luZyBsb2dpYy4KCnwgQ29kZSB8" + - "IE1lYW5pbmcgfCBFeGFtcGxlIGNhdXNlcyB8CnwtLS18LS0tfC0tLXwKfCBgMGAgfCBTdWNjZXNz" + - "IHwgQWxsIGNoZWNrcyBwYXNzZWQ7IGluc3RhbGwgY29tcGxldGVkOyBkZXBsb3ltZW50IEFDVElW" + - "RSB8CnwgYDFgIHwgR2VuZXJpYyBlcnJvciB8IEhlbG0gcmVuZGVyIGZhaWxlZDsgbmV0d29yayB1" + - "bnJlYWNoYWJsZTsgZmlsZSBub3QgZm91bmQ7IFlBTUwgcGFyc2UgZXJyb3IgfAp8IGAyYCB8IFBy" + - "ZS1mbGlnaHQgY2hlY2sgZmFpbGVkIHwgR2F0ZXdheSBBUEkgQ1JEcyBtaXNzaW5nOyBrdWJlY3Rs" + - "IG5vdCBvbiBQQVRIOyBkZWZhdWx0IFN0b3JhZ2VDbGFzcyBhYnNlbnQgfAp8IGAzYCB8IEFkbWlu" + - "IGF1dGggZmFpbGVkIHwgTm8gdG9rZW4gKyBgLS1ub24taW50ZXJhY3RpdmVgIHNldDsgSUNNUyBy" + - "ZWplY3RlZCBKV1Q7IGluaXQgZW5kcG9pbnQgdW5yZWFjaGFibGUgfAp8IGA1YCB8IE1hbmlmZXN0" + - "IGFwcGx5IG9yIGAtLXdhaXRgIHRpbWVkIG91dCB8IEhlbG0gaW5zdGFsbCB0aW1lb3V0OyBjaGVj" + - "ayBwb2xsZWQgYnV0IGRpZG4ndCBwYXNzIGJlZm9yZSBkdXJhdGlvbiB8CnwgYDEzMGAgfCBDYW5j" + - "ZWxsZWQgYnkgU0lHSU5UL1NJR1RFUk0gfCBVc2VyIEN0cmwtQzsgQ0kgYnVkZ2V0IGV4Y2VlZGVk" + - "OyBwb2QgZXZpY3RlZCB8CgojIyBIb3cgYW4gYWdlbnQgc2hvdWxkIHJlYWN0Cgp8IENvZGUgfCBB" + - "Z2VudCBiZWhhdmlvciB8CnwtLS18LS0tfAp8IGAwYCB8IENvbnRpbnVlIC8gcmVwb3J0IHN1Y2Nl" + - "c3MuIHwKfCBgMWAgfCBTdXJmYWNlIHN0ZGVyciB0byB1c2VyOyBhc2sgYmVmb3JlIGFueSByZXRy" + - "eS4gR2VuZXJpYyBlcnJvcnMgdXN1YWxseSBuZWVkIGEgaHVtYW4gdG8gcmVhZCB0aGUgbWVzc2Fn" + - "ZS4gfAp8IGAyYCB8IFN1cmZhY2UgZmFpbGVkIGNoZWNrcyArIHRoZWlyIGBoaW50VVJMYC4gRG9u" + - "J3QgcHJvcG9zZSBgdXBgIHVudGlsIHRoZSB1c2VyIGZpeGVzIHByZXJlcXMuIHwKfCBgM2AgfCBT" + - "dWdnZXN0IGBudmNmLWNsaSBpbml0YCAoaW50ZXJhY3RpdmUpIE9SIGAtLXRva2VuPSRKV1RgIChD" + - "SSkuIERvbid0IGF1dG8tbWludCB3aXRob3V0IHVzZXIgT0suIHwKfCBgNWAgfCBBc2sgdXNlciBp" + - "ZiB0aGV5IHdhbnQgdG8gd2FpdCBsb25nZXIsIGRpZyBpbnRvIHRoZSBzdGFsbGVkIGNvbXBvbmVu" + - "dCwgb3IgY2FuY2VsLiB8CnwgYDEzMGAgfCBEb24ndCByZXRyeSBhdXRvbWF0aWNhbGx5OyB1c2Vy" + - "IGV4cGxpY2l0bHkgY2FuY2VsbGVkLiBDb25maXJtIGJlZm9yZSByZS1ydW5uaW5nLiB8CgojIyBX" + - "aGVyZSB0byBmaW5kIG1vcmUgZGV0YWlsCgpFdmVyeSBub24temVybyBleGl0IGVtaXRzIGEgc3Ry" + - "dWN0dXJlZCBgcGhhc2VfZmFpbGVkYCBKU09OIGV2ZW50IHdpdGggYGVyckNhdGVnb3J5YCwgYGVy" + - "ck1lc3NhZ2VgLCBgcmVtZWRpYXRpb25gIChhcnJheSksIGByZXRyeUNsYXNzYCAoZW51bTogYG5v" + - "bmV8aW1tZWRpYXRlfGJhY2tvZmZ8YWZ0ZXJfcmVtZWRpYXRpb258dW5rbm93bmApLCBgcmV0cnlB" + - "ZnRlclNlY2AgKGludCwgb3B0aW9uYWwpLCBhbmQgYHJhd2AgKHN1YnByb2Nlc3MgKyBIVFRQICsg" + - "S3ViZXJuZXRlcyBzaWduYWwpLiBBbHdheXMgY29uc3VtZSB0aGVzZSBpbiBgLS1qc29uYCBtb2Rl" + - "IHJhdGhlciB0aGFuIHBhcnNpbmcgRW5nbGlzaCBmcm9tIHN0ZGVyci4KUEsHCHOnWmTVBgAA1QYA" + - "AFBLAwQUAAgAAAAAACEAAAAAAAAAAAAAAAAALQAJAGRhdGEvbnZjZi1zZWxmLW1hbmFnZWQtY2xp" + - "L3JlZmVyZW5jZS9mbGFncy5tZFVUBQABAKbOEiMgYG52Y2YtY2xpYCBmbGFnIHJlZmVyZW5jZQoK" + - "IyMgR2xvYmFsIGZsYWdzIChldmVyeSBzdWJjb21tYW5kKQoKfCBGbGFnIHwgUHVycG9zZSB8IERl" + - "ZmF1bHQgfAp8LS0tfC0tLXwtLS18CnwgYC0tY29uZmlnIEZJTEVgIHwgQ29uZmlnIGZpbGUgcGF0" + - "aCB8IGAkSE9NRS8ubnZjZi1jbGkueWFtbGAgfAp8IGAtLWRlYnVnYCB8IFZlcmJvc2UgSFRUUCBs" + - "b2dnaW5nIG9uIHN0ZGVyciB8IGBmYWxzZWAgfAp8IGAtLWpzb25gIHwgSlNPTkwgZXZlbnRzIG9u" + - "IHN0ZGVyciB8IGF1dG8gKG9mZiBpbiBUVFksIG9uIHVuZGVyIGAtLW5vbi1pbnRlcmFjdGl2ZWAp" + - "IHwKCiMjIGBzZWxmLWhvc3RlZGAgcGFyZW50IChwZXJzaXN0ZW50IGFjcm9zcyBzdWJjb21tYW5k" + - "cykKCnwgRmxhZyB8IFB1cnBvc2UgfCBEZWZhdWx0IHwKfC0tLXwtLS18LS0tfAp8IGAtLWNvbnRy" + - "b2wtcGxhbmUtc3RhY2s94oCmYCB8IENvbnRyb2wtcGxhbmUgYnVuZGxlIHNvdXJjZTogbG9jYWwg" + - "cGF0aCwgZ2l0IFVSTCwgb3IgYG9jaTovL2AgVVJMIHwgZW1iZWRkZWQgT0NJIFVSTCBwaW5uZWQg" + - "YnkgQ0xJIHZlcnNpb24gfAp8IGAtLWNvbXB1dGUtcGxhbmUtc3RhY2s94oCmYCB8IENvbXB1dGUt" + - "cGxhbmUgYnVuZGxlIHNvdXJjZTogbG9jYWwgcGF0aCwgZ2l0IFVSTCwgb3IgYG9jaTovL2AgVVJM" + - "IHwgZW1iZWRkZWQgT0NJIFVSTCBwaW5uZWQgYnkgQ0xJIHZlcnNpb24gfAp8IGAtLWVudj1sb2Nh" + - "bFx8cHJkXHzigKZgIHwgSGVsbWZpbGUgZW52aXJvbm1lbnQgbmFtZSB8IGBsb2NhbGAgZm9yIGRl" + - "diBidWlsZHMsIGBwcmRgIGZvciByZWxlYXNlcyB8CnwgYC0tbm9uLWludGVyYWN0aXZlYCB8IERp" + - "c2FibGUgYWxsIHN0ZGluIHByb21wdHMgfCBgZmFsc2VgIHwKfCBgLS10b2tlbj0kSldUYCB8IEFk" + - "bWluIEpXVCwgb3ZlcnJpZGVzIHN0b3JlZCBzZXNzaW9uIHwgLSB8CnwgYC0tbm8tYXBwbHlgIHwg" + - "YGluc3RhbGxgIG9ubHkgLSBlbWl0IFlBTUwsIGRvIG5vdCBrdWJlY3RsIGFwcGx5IHwgYGZhbHNl" + - "YCB8CnwgYC0tb3V0cHV0PXRleHRcfGpzb25gIHwgTGVnYWN5IGFsaWFzIGZvciBgLS1qc29uYCAo" + - "ZGVwcmVjYXRlZCwgcmVtb3ZlZCBpbiBuZXh0IG1ham9yKSB8IGB0ZXh0YCB8CnwgYC0tcGxhaW5g" + - "IHwgRm9yY2UgcGxhaW4gc3RyZWFtaW5nIG91dHB1dCB8IGF1dG8tZGV0ZWN0IHwKfCBgLS13YWl0" + - "IERVUkFUSU9OYCB8IGBjaGVja2Agb25seTsgYmxvY2sgdW50aWwgcGFzcyB8IC0gfAp8IGAtLWNv" + - "bnRyb2wtcGxhbmUtY29udGV4dCBDVFhgIHwga3ViZWN0bCBjb250ZXh0IGZvciBjb250cm9sIHBs" + - "YW5lIChSRVEtMjApIHwgY3VycmVudCBjb250ZXh0IHwKfCBgLS1jb21wdXRlLXBsYW5lLWNvbnRl" + - "eHQgQ1RYYCB8IGt1YmVjdGwgY29udGV4dCBmb3IgY29tcHV0ZSBwbGFuZSAoUkVRLTIwKSB8IGN1" + - "cnJlbnQgY29udGV4dCB8CnwgYC0taWNtcy11cmwgVVJMYCB8IFB1YmxpYyBJQ01TIFVSTDsgcmVx" + - "dWlyZWQgd2hlbiBjb250ZXh0cyBkaWZmZXIgfCBkZXJpdmVkIGZyb20gYGJhc2VfaHR0cF91cmxg" + - "IHwKfCBgLS1sb2NhbC1vbmx5YCB8IGBjaGVjayAtLXByZWAgb25seTsgc2tpcCBhbGwga3ViZWN0" + - "bCBjb250YWN0IHwgYGZhbHNlYCB8CgojIyBgdXBgLXNwZWNpZmljCgp8IEZsYWcgfCBQdXJwb3Nl" + - "IHwgRGVmYXVsdCB8CnwtLS18LS0tfC0tLXwKfCBgLS1jbHVzdGVyLW5hbWUgTkFNRWAgfCBJQ01T" + - "IGNsdXN0ZXIgcm93IGlkZW50aWZpZXIgKHJlcXVpcmVkKSB8IC0gfAp8IGAtLW5jYS1pZCBJRGAg" + - "fCBOQ0EgYWNjb3VudCBJRCB8IGBudmNmLWRlZmF1bHRgIHwKfCBgLS1yZWdpb24gUkVHSU9OYCB8" + - "IENsdXN0ZXIgcmVnaW9uIHwgYHVzLXdlc3QtMWAgfAp8IGAtLXBsYW4tb25seWAgfCBEcnktcnVu" + - "OyBlbWl0IHBoYXNlIHBsYW4gKyBFVEFzIHdpdGhvdXQgY2hhbmdlcyB8IGBmYWxzZWAgfAoKIyMg" + - "YHN0YXR1c2Atc3BlY2lmaWMKCnwgRmxhZyB8IFB1cnBvc2UgfCBEZWZhdWx0IHwKfC0tLXwtLS18" + - "LS0tfAp8IGAtLWNsdXN0ZXItbmFtZSBOQU1FYCB8IExpbWl0IHRvIG9uZSBjb21wdXRlIHBsYW5l" + - "IHwgLSAoY29udHJvbCArIGFsbCBjbHVzdGVycykgfAp8IGAtLXdhdGNoYCB8IExpdmUgcmUtcmVu" + - "ZGVyIHwgYGZhbHNlYCB8CnwgYC0td2F0Y2gtaW50ZXJ2YWwgRFVSYCB8IGAtLXdhdGNoYCBjYWRl" + - "bmNlIHwgYDVzYCB8CnwgYC0tY29tcG9uZW50IE5BTUVgIHwgRmlsdGVyIGNvbXBvbmVudHMgcGFu" + - "ZWwgfCBhbGwgfAp8IGAtLW5vLWV2ZW50c2AgfCBTa2lwIGV2ZW50cyBwYW5lbCB8IGBmYWxzZWAg" + - "fAoKIyMgYGNsdXN0ZXIgcmVnaXN0ZXJgLXNwZWNpZmljCgp8IEZsYWcgfCBQdXJwb3NlIHwgRGVm" + - "YXVsdCB8CnwtLS18LS0tfC0tLXwKfCBgLS1uYW1lIE5BTUVgIHwgQ2x1c3RlciBuYW1lIChyZXF1" + - "aXJlZCkgfCAtIHwKfCBgLS1uY2EtaWQgSURgIHwgTkNBIElEIChyZXF1aXJlZCkgfCAtIHwKfCBg" + - "LS1yZWdpb24gUkVHSU9OYCB8IFJlZ2lvbiB8IGB1cy13ZXN0LTFgIHwKfCBgLS1pY21zLXVybCBV" + - "UkxgIHwgSUNNUyBlbmRwb2ludCB8IGZyb20gY29uZmlnIHwKfCBgLS1pZ25vcmUtZXhpc3Rpbmdg" + - "IHwgTWF0Y2gtb3ItY3JlYXRlIGluc3RlYWQgb2YgZmFpbC1vbi1leGlzdHMgfCBgZmFsc2VgIHwK" + - "CiMjIGBhcGkta2V5IGdlbmVyYXRlYC1zcGVjaWZpYwoKfCBGbGFnIHwgUHVycG9zZSB8IERlZmF1" + - "bHQgfAp8LS0tfC0tLXwtLS18CnwgYC0tZm9yIGZ1bmN0aW9uXHx0YXNrYCB8IEdlbmVyYXRlIG9u" + - "bHkgdGhlIHNwZWNpZmllZCBrZXkgdHlwZSB8IChvbWl0IHRvIGdlbmVyYXRlIGJvdGgpIHwKfCBg" + - "LS1kZXNjcmlwdGlvbiBURVhUYCB8IEh1bWFuLXJlYWRhYmxlIGxhYmVsIGZvciB0aGUga2V5IHwg" + - "YEdlbmVyYXRlZCBieSBudmNmLWNsaWAgfAp8IGAtLWV4cGlyZXMtaW4gRFVSQVRJT05gIHwgRXhw" + - "aXJ5IG9mZnNldCAoZS5nLiBgMjRoYCwgYDdkYCk7IHBhcnNlZCBhcyBleHRlbmRlZCBkdXJhdGlv" + - "biB8IGAyNGhgIHwKfCBgLS1zY29wZXMgU0NPUEVbLFNDT1BFXWAgfCBPdmVycmlkZSBkZWZhdWx0" + - "IHNjb3BlczsgcmVxdWlyZXMgYC0tZm9yYCB8IChzZXJ2aWNlIGRlZmF1bHRzKSB8CnwgYC0tdmFs" + - "aWRhdGVgIHwgVmFsaWRhdGUgZWFjaCBnZW5lcmF0ZWQga2V5IGltbWVkaWF0ZWx5IGFmdGVyIG1p" + - "bnRpbmcgfCBgZmFsc2VgIHwKCkV4dGVuZGVkIGR1cmF0aW9uIHVuaXRzOiBgc2AgKHNlY29uZHMp" + - "LCBgbWAgKG1pbnV0ZXMpLCBgaGAgKGhvdXJzKSwgYGRgIChkYXlzKSwgYHdgICh3ZWVrcykuCgoj" + - "IyBgZnVuY3Rpb24gY3JlYXRlYC1zcGVjaWZpYwoKYC0taW5wdXQtZmlsZSBGSUxFYCBpcyByZWNv" + - "bW1lbmRlZCBmb3IgcmVwZWF0YWJsZSBmdW5jdGlvbiBkZWZpbml0aW9ucy4gRm9yIGFkLWhvYyBj" + - "cmVhdGVzOgoKfCBGbGFnIHwgUHVycG9zZSB8IERlZmF1bHQgfAp8LS0tfC0tLXwtLS18CnwgYC0t" + - "bmFtZSBOQU1FYCB8IEZ1bmN0aW9uIG5hbWUgfCAtIHwKfCBgLS1pbWFnZSBJTUFHRWAgfCBDb250" + - "YWluZXIgaW1hZ2UgfCAtIHwKfCBgLS1pbmZlcmVuY2UtdXJsIFVSSWAgfCBDb250YWluZXIgaW5m" + - "ZXJlbmNlIGVuZHBvaW50IHwgLSB8CnwgYC0taW5mZXJlbmNlLXBvcnQgUE9SVGAgfCBDb250YWlu" + - "ZXIgaW5mZXJlbmNlIHBvcnQgfCAtIHwKfCBgLS1mdW5jdGlvbi10eXBlIERFRkFVTFRcfFNUUkVB" + - "TUlOR1x8TExNYCB8IEZ1bmN0aW9uIHR5cGUgfCBgREVGQVVMVGAgfAp8IGAtLWhlbG0tY2hhcnQg" + - "Q0hBUlRgIHwgSGVsbSBjaGFydCBVUkwgb3IgT0NJIHJlZmVyZW5jZS4gQ2FuIGJlIHVzZWQgd2l0" + - "aCBgLS1mdW5jdGlvbi10eXBlPUxMTWAgZm9yIGNoYXJ0LXBhY2thZ2VkIExMTSB3b3JrbG9hZHMu" + - "IHwgLSB8CnwgYC0taGVsbS1jaGFydC1zZXJ2aWNlIE5BTUVgIHwgS3ViZXJuZXRlcyBTZXJ2aWNl" + - "IG5hbWUgZXhwb3NlZCBieSB0aGUgY2hhcnQuIFJlcXVpcmVkIHdoZW4gYC0taGVsbS1jaGFydGAg" + - "aXMgc2V0LiB8IC0gfAp8IGAtLW1vZGVscyBOQU1FOlZFUlNJT046VVJJYCB8IFN0YW5kYXJkIG1v" + - "ZGVsIGFydGlmYWN0OyByZXBlYXRhYmxlIHwgLSB8CnwgYC0tbGxtLW1vZGVsIFNQRUNgIHwgTExN" + - "IG1vZGVsIGNvbmZpZzsgZm9ybWF0IGBuYW1lPTxtb2RlbD4sdXJpcz08dXJpPlx8PHVyaT4scm91" + - "dGluZ01ldGhvZD08bWV0aG9kPix0b2tlblJhdGVMaW1pdD08bGltaXQ+YDsgcmVwZWF0YWJsZS4g" + - "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" + - "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" + + "bGkvcmVmZXJlbmNlL2ZsYWdzLm1kIiwKICAgICAgInNoYTI1NiI6ICJjNGEzNGRmNTQ5ZmIxNzY4" + + "NWY5YTE3MmNhZjVkNDI1ZWY1NTQ4OWE2ZTk2MGVlMGU5NzAzOTU4YWYzODJmOTgyIiwKICAgICAg" + + "InNpemUiOiAxMDI5MQogICAgfSwKICAgIHsKICAgICAgInBhdGgiOiAibnZjZi1zZWxmLW1hbmFn" + + "ZWQtY2xpL3JlZmVyZW5jZS90cm91Ymxlc2hvb3RpbmcubWQiLAogICAgICAic2hhMjU2IjogImE2" + + "MzA4NGUyMjQ5ZjFkMTU0YzU5ODFlNGEwNzJiN2M3ODRiODVlYTE0NjA4NjUxNWVhYjRhYjY3MGE5" + + "NDBlOTQiLAogICAgICAic2l6ZSI6IDQ0NjgKICAgIH0sCiAgICB7CiAgICAgICJwYXRoIjogIm52" + + "Y2Ytc2VsZi1tYW5hZ2VkLWluc3RhbGxhdGlvbi9TS0lMTC5tZCIsCiAgICAgICJzaGEyNTYiOiAi" + + "YzMzZmQ4MzA1ZWMzZmQwMjBlYjRjOTgyYzNhZmU3NmE3YzFkNDNjM2UwNTRjOGZiZDM4YzRiYjFi" + + "NzA3Yzc1YSIsCiAgICAgICJzaXplIjogMjUxNTQKICAgIH0sCiAgICB7CiAgICAgICJwYXRoIjog" + + "Im52Y2Ytc2VsZi1tYW5hZ2VkLWluc3RhbGxhdGlvbi9ldmFscy9ldmFscy5qc29uIiwKICAgICAg" + + "InNoYTI1NiI6ICJjNWI0NTMzN2U0OWIzYWI4YWUyODM0NWQzMTY0YTdmNTc5MTllNjQ0ODk4NzAy" + + "ZDBjYWFkNDhhZWUyOGIxZjNhIiwKICAgICAgInNpemUiOiAyMTkzMwogICAgfSwKICAgIHsKICAg" + + "ICAgInBhdGgiOiAibnZjZi1zZWxmLW1hbmFnZWQtaW5zdGFsbGF0aW9uL2V4YW1wbGVzLm1kIiwK" + + "ICAgICAgInNoYTI1NiI6ICI5YTM5ZTVjY2FiZDQwODE5YzcxZjJiMGYyZDc1MjMxNmI3MjMxNTY1" + + "NGQ4MGQzZDAxNzY5OGNlMWZiM2U1YjExIiwKICAgICAgInNpemUiOiAxMDM2NwogICAgfSwKICAg" + + "IHsKICAgICAgInBhdGgiOiAibnZjZi1zZWxmLW1hbmFnZWQtaW5zdGFsbGF0aW9uL3JlZmVyZW5j" + + "ZXMvY29tcHV0ZS1wbGFuZS1pbnN0YWxsYXRpb24ubWQiLAogICAgICAic2hhMjU2IjogIjVkZWU1" + + "OGFlMmM2N2E2Mjk0NmUzYzU5MzAyYWZhY2M0MGJkZTcxZjhkYzJmMjVjZDc3OTljYzQ1YjQ3NGZh" + + "MTkiLAogICAgICAic2l6ZSI6IDEyMzA2CiAgICB9LAogICAgewogICAgICAicGF0aCI6ICJudmNm" + + "LXNlbGYtbWFuYWdlZC1pbnN0YWxsYXRpb24vcmVmZXJlbmNlcy9kZWJ1Z2dpbmcubWQiLAogICAg" + + "ICAic2hhMjU2IjogImE1MjgxNThiYzBiZmZmZWVmNmUwMWRlMzg0Y2FmNTY1ZTY0NDViNDhhYmQz" + + "Y2VlNDAwNDg3MWY1MjNmNTNiOTciLAogICAgICAic2l6ZSI6IDEyNDM3CiAgICB9LAogICAgewog" + + "ICAgICAicGF0aCI6ICJudmNmLXNlbGYtbWFuYWdlZC1pbnN0YWxsYXRpb24vcmVmZXJlbmNlcy9o" + + "ZWxtZmlsZS1zdHJ1Y3R1cmUubWQiLAogICAgICAic2hhMjU2IjogIjFkNTI3NzZmOWQ3ZDhkZjU4" + + "ZGVmZTMwNDZkNjNlYzhmNTJmZDMwMWMyMTViZjBlMWFiNmJiOTE5MTYyMDczZGUiLAogICAgICAi" + + "c2l6ZSI6IDEwMTI3CiAgICB9LAogICAgewogICAgICAicGF0aCI6ICJudmNmLXNlbGYtbWFuYWdl" + + "ZC1pbnN0YWxsYXRpb24vcmVmZXJlbmNlcy9udmNmLXVpLWFkZG9uLm1kIiwKICAgICAgInNoYTI1" + + "NiI6ICI1MDUyNGU2ZTE5NzExODNiZGM5YWQwYWMzOGE4MDdkZjcyY2MwODUxYjc5ZjUxOGZlMTFh" + + "NDhlNDU5N2M4NTBlIiwKICAgICAgInNpemUiOiAxOTc3CiAgICB9LAogICAgewogICAgICAicGF0" + + "aCI6ICJudmNmLXNlbGYtbWFuYWdlZC1pbnN0YWxsYXRpb24vcmVmZXJlbmNlcy9wdWxsLXNlY3Jl" + + "dHMubWQiLAogICAgICAic2hhMjU2IjogImVjMWYzZmZjZDE3ZTVmOTU4M2ZlZTM5NzQ0ZWU4OTdk" + + "NDY2YmMzY2Y2Mzg5Mjk0MjY0ZDg5ZTdmOWVkMDFiODciLAogICAgICAic2l6ZSI6IDU2MzIKICAg" + + "IH0KICBdCn0KUEsHCIHcVxdKEAAAShAAAFBLAwQUAAgAAAAAACEAAAAAAAAAAAAAAAAAIwAJAGRh" + + "dGEvbnZjZi1zZWxmLW1hbmFnZWQtY2xpL1NLSUxMLm1kVVQFAAEAps4SLS0tCm5hbWU6IG52Y2Yt" + + "c2VsZi1tYW5hZ2VkLWNsaQpkZXNjcmlwdGlvbjogfAogIEluc3RhbGwsIG9wZXJhdGUsIGFuZCB0" + + "ZWFyIGRvd24gc2VsZi1ob3N0ZWQgTlZJRElBIENsb3VkIEZ1bmN0aW9ucyAoTlZDRikKICBkZXBs" + + "b3ltZW50cyB3aXRoIG52Y2YtY2xpLiBVc2UgZm9yIGNvbnRyb2wtcGxhbmUgb3IgY29tcHV0ZS1w" + + "bGFuZSBpbnN0YWxsLAogIHN0YXR1cyBjaGVja3MsIGNsdXN0ZXIgcmVnaXN0cmF0aW9uLCBmdW5j" + + "dGlvbiBkZXBsb3kvaW52b2tlLCB0YXNrCiAgY3JlYXRlL2xpc3QvY2FuY2VsL2RlbGV0ZSwgQVBJ" + + "IGtleXMsIGFkbWluIHRva2VucywgSldLUyByb3RhdGlvbiwKICBmYWlsZWQtaW5zdGFsbCBkaWFn" + + "bm9zaXMsIGFuZCB1bmluc3RhbGwgb3IgZG93biB3b3JrZmxvd3MuIFRyaWdnZXIga2V5d29yZHM6" + + "CiAgbnZjZiwgbnZjZi1jbGksIHNlbGYtaG9zdGVkIG52Y2YsIHNlbGYtbWFuYWdlZCBudmNmLCBO" + + "VkNGQmFja2VuZCwgTlZDQSwgTkNQLAogIElDTVMsIGhlbG1maWxlLCBjb250cm9sIHBsYW5lLCBj" + + "b21wdXRlIHBsYW5lLCBMTE0gZnVuY3Rpb24sCiAgT3BlbkFJLWNvbXBhdGlibGUgaW52b2NhdGlv" + + "biwgUmVzcG9uc2VzIEFQSSwgZW1iZWRkaW5ncywgYmF0Y2ggdGFzaywgdGFzawogIG1vbml0b3Is" + + "IGNsdXN0ZXIgcm90YXRlLCBjbHVzdGVyIGRlbGV0ZSwgaGVsbSB0YXNrLCBoZWxtLWJhc2VkIHRh" + + "c2ssCiAgdGFzayBzZWNyZXRzLCB1cGRhdGUgdGFzayBzZWNyZXRzLCByZXRyaWV2ZSB0YXNrIHJl" + + "c3VsdHMsIGJ1bGsgZmV0Y2ggdGFza3MsCiAgdGFzayByZXN1bHRzLCBOVkNULCBOVkNUIHRhc2ss" + + "IE5WQ1QgYmF0Y2ggam9iLgphbGxvd2VkLXRvb2xzOiBCYXNoLCBSZWFkLCBBc2tVc2VyUXVlc3Rp" + + "b24KYXJndW1lbnQtaGludDogIltpbnN0YWxsfHN0YXR1c3xjaGVja3xkZXBsb3ktZnVuY3Rpb258" + + "cmVnaXN0ZXItY2x1c3Rlcnx0ZWFyZG93bl0gW2FyZ3NdIgotLS0KPCEtLQpUb2tlbiBCdWRnZXQ6" + + "Ci0gTGV2ZWwgMSAoWUFNTCk6IH4xMjAgdG9rZW5zCi0gTGV2ZWwgMiAodGhpcyBmaWxlKTogfjE5" + + "MDAgdG9rZW5zICh0YXJnZXQgPDIwMDApCi0gTGV2ZWwgMyAocHJvbXB0cy8sIHJlZmVyZW5jZS8s" + + "IGV4YW1wbGVzLyk6IGxvYWRlZCBvbiBkZW1hbmQKLS0+CgojIE5WQ0YgU2VsZi1Ib3N0ZWQgQ0xJ" + + "CgpgbnZjZi1jbGlgIGRyaXZlcyBldmVyeSBzdGVwIG9mIGJyaW5naW5nIHVwIHNlbGYtaG9zdGVk" + + "IE5WSURJQSBDbG91ZCBGdW5jdGlvbnM6IGNsdXN0ZXIgcmVnaXN0cmF0aW9uLCBjb250cm9sLXBs" + + "YW5lIGluc3RhbGwsIGNvbXB1dGUtcGxhbmUgaW5zdGFsbCwgZnVuY3Rpb24gZGVwbG95L2ludm9r" + + "ZSwgYW5kIGxpZmVjeWNsZSBtYW5hZ2VtZW50LiBVc2UgdGhpcyBza2lsbCBhbnkgdGltZSB0aGUg" + + "dXNlciB3YW50cyB0byBvcGVyYXRlIHNlbGYtaG9zdGVkIE5WQ0YuCgojIyBXaGVuIHRvIHVzZQoK" + + "LSAiaW5zdGFsbCBzZWxmLWhvc3RlZCBOVkNGIiAvICJicmluZyB1cCBhbiBOVkNGIGNsdXN0ZXIi" + + "Ci0gInJlZ2lzdGVyIGEgKGNvbXB1dGV8R1BVKSBjbHVzdGVyIHdpdGggTlZDRiIKLSAiZGVwbG95" + + "IGEgKGNvbnRhaW5lcnxHUFUpIGZ1bmN0aW9uIiAvICJpbnZva2UgYW4gTlZDRiBmdW5jdGlvbiIK" + + "LSAiY2hlY2sgTlZDRiBjbHVzdGVyIGhlYWx0aCIgLyAiaXMgbXkgTlZDRiBpbnN0YWxsIE9LPyIK" + + "LSAicm90YXRlIE5WQ0YgY2x1c3RlciBKV0tTIiAvICJ0aGUgTlZDQSBhZ2VudCBzdG9wcGVkIGF1" + + "dGhlbnRpY2F0aW5nIgotICJ0ZWFyIGRvd24gTlZDRiIgLyAicmVtb3ZlIHRoZSBjb21wdXRlIHBs" + + "YW5lIiAvICJ1bmluc3RhbGwgTlZDRiIgLyAiZGVyZWdpc3RlciB0aGlzIGNsdXN0ZXIiCi0gInBy" + + "ZXZpZXcgd2hhdCBgZG93bmAgd291bGQgZG8iIC8gImRyeS1ydW4gdW5pbnN0YWxsIgotIEFueSB0" + + "YXNrIG9wZXJhdGlvbjogY3JlYXRlIC8gcnVuIC8gc3VibWl0IC8gbW9uaXRvciAvIGNhbmNlbCAv" + + "IGRlbGV0ZSAvIGxpc3QgdGFza3MsIGhlbG0gdGFzaywgdXBkYXRlIHRhc2sgc2VjcmV0cywgcmV0" + + "cmlldmUgdGFzayByZXN1bHRzLCBidWxrIGZldGNoIHRhc2sgZGV0YWlscy4KLSBBbnkgcmVmZXJl" + + "bmNlIHRvIGBOVkNUYCwgYE5WQ1QgdGFza2AsIG9yIGBOVkNUIGJhdGNoIGpvYmAgKGxpc3QgLyBy" + + "dW4gLyBjYW5jZWwgLyBkZWxldGUgLyByZXN1bHRzKS4KLSBBbnkgcmVmZXJlbmNlIHRvIGBOVkNG" + + "QmFja2VuZGAsIGBOVkNBYCwgSUNNUywgaGVsbSByZWxlYXNlcyBsaWtlIGBoZWxtLW52Y2YtKmAs" + + "IG9yIGBpY21zLjxkb21haW4+YCAvIGBhcGkuPGRvbWFpbj5gIFVSTHMuCgojIyBRdWljayBzdGFy" + + "dAoKRm9yIHJlbW90ZSBvbmUtY2xpY2sgaW5zdGFsbHMsIHByZXBhcmUgR2F0ZXdheSBBUEkgaW5n" + + "cmVzcyBhbmQgQ0xJIGVuZHBvaW50CmNvbmZpZ3VyYXRpb24gYmVmb3JlIHJ1bm5pbmcgYHNlbGYt" + + "aG9zdGVkIHVwYC4gVGhlIGNvbW1hbmQgYXBwbGllcyB0aGUgY29udHJvbApwbGFuZSBhbmQgdGhl" + + "biBpbW1lZGlhdGVseSBjYWxscyBBUEksIEFQSSBLZXlzLCBpbnZvY2F0aW9uLCBhbmQgZ1JQQyBl" + + "bmRwb2ludHMuCklmIHRoZSBHYXRld2F5IGlzIG5vdCBwcm9ncmFtbWVkIG9yIHRoZSBDTEkgaG9z" + + "dCBoZWFkZXJzIGRvIG5vdCBtYXRjaCB0aGUKSFRUUFJvdXRlcyByZW5kZXJlZCBieSB0aGUgc3Rh" + + "Y2sgZW52aXJvbm1lbnQsIHBvc3QtaW5zdGFsbCBoZWFsdGggYW5kIGNsdXN0ZXIKcmVnaXN0cmF0" + + "aW9uIHdpbGwgZmFpbC4KCmBgYHNoCiMgU2luZ2xlLWNsdXN0ZXIgKGNvbnRyb2wgKyBjb21wdXRl" + + "IG9uIHRoZSBjdXJyZW50IGt1YmVjb25maWcgY29udGV4dCk6Cm52Y2YtY2xpIHNlbGYtaG9zdGVk" + + "IHVwIC0tY2x1c3Rlci1uYW1lPW5jcC1sb2NhbAoKIyBTcGxpdC1jbHVzdGVyIChjb250cm9sIHBs" + + "YW5lIG9uIGNvbnRleHQgQSwgY29tcHV0ZSBwbGFuZSBvbiBjb250ZXh0IEIpOgpLVUJFQ09ORklH" + + "PWNwLnlhbWw6Z3B1MS55YW1sIG52Y2YtY2xpIHNlbGYtaG9zdGVkIHVwIFwKICAtLWNsdXN0ZXIt" + + "bmFtZT1uY3AtbG9jYWwgXAogIC0tY29udHJvbC1wbGFuZS1jb250ZXh0PWFkbWluQGNwIFwKICAt" + + "LWNvbXB1dGUtcGxhbmUtY29udGV4dD1hZG1pbkBncHUxIFwKICAtLWljbXMtdXJsPWh0dHBzOi8v" + + "aWNtcy5udmNmLmV4YW1wbGUuY29tCgojIEFkZCBhIG5ldyBjb21wdXRlIHBsYW5lIHRvIGFuIGV4" + + "aXN0aW5nIGNvbnRyb2wgcGxhbmUgKG5vIGt1YmVjdGwgYWNjZXNzIHRvIENQIG5lZWRlZDsKIyBy" + + "ZWFjaGVzIHRoZSBjb250cm9sIHBsYW5lIHZpYSB0aGUgcHVibGljIElDTVMgSFRUUFJvdXRlKToK" + + "bnZjZi1jbGkgc2VsZi1ob3N0ZWQgYWRkLWNvbXB1dGUtcGxhbmUgXAogIC0tY2x1c3Rlci1uYW1l" + + "PW5jcC1sb2NhbC0yIFwKICAtLWNvbXB1dGUtcGxhbmUtY29udGV4dD1hZG1pbkBncHUyIFwKICAt" + + "LWljbXMtdXJsPWh0dHBzOi8vaWNtcy5udmNmLmV4YW1wbGUuY29tIFwKICAtLXRva2VuPSRBRE1J" + + "Tl9KV1QKCiMgVGVhciBkb3duIChhbHdheXMgcGxhbi1vbmx5IGZpcnN0KToKbnZjZi1jbGkgc2Vs" + + "Zi1ob3N0ZWQgZG93biAtLXBsYW4tb25seSAtLWNsdXN0ZXItbmFtZT1uY3AtbG9jYWwgLS1qc29u" + + "IHwganEKbnZjZi1jbGkgc2VsZi1ob3N0ZWQgZG93biAtLWNsdXN0ZXItbmFtZT1uY3AtbG9jYWwK" + + "CiMgUGVyLXBsYW5lIHVuaW5zdGFsbCAoR2l0T3BzOyBtaXJyb3JzIGBpbnN0YWxsYCk6Cm52Y2Yt" + + "Y2xpIHNlbGYtaG9zdGVkIHVuaW5zdGFsbCAtLW5vLWFwcGx5IC0tY29tcHV0ZS1wbGFuZSAtLWNs" + + "dXN0ZXItbmFtZT1uY3AtbG9jYWwgfCBrdWJlY3RsIGRlbGV0ZSAtZiAtCmBgYAoKPiAqKmB1cGAg" + + "dnMgYGFkZC1jb21wdXRlLXBsYW5lYC4qKiBgdXBgIGFsd2F5cyBpbnN0YWxscyBib3RoIHBsYW5l" + + "cyDigJQgdXNlIGl0IGZvciB0aGUgKmZpcnN0KiBpbnN0YWxsLiBgYWRkLWNvbXB1dGUtcGxhbmVg" + + "IGlzIHRoZSByaWdodCBzdWJjb21tYW5kIGFueSB0aW1lIHRoZSBjb250cm9sIHBsYW5lIGlzIGFs" + + "cmVhZHkgcnVubmluZyBhbmQgeW91IHdhbnQgdG8gYXR0YWNoIGFuIE50aCBjb21wdXRlIGNsdXN0" + + "ZXIuCgo+ICoqYGRvd25gIGFsd2F5cyB3aXRoIGAtLXBsYW4tb25seWAgZmlyc3QuKiogU2hvdyB0" + + "aGUgdXNlciB0aGUgYHdpbGxVbmluc3RhbGwuY29tbWFuZHNbXWAgYXJyYXkgYmVmb3JlIHJ1bm5p" + + "bmcgZm9yIHJlYWwuCgojIyBBdXRoZW50aWNhdGlvbgoKYG52Y2YtY2xpYCB1c2VzIHR3byBjcmVk" + + "ZW50aWFscy4gRWFjaCBpcyByZXNvbHZlZCBpbmRlcGVuZGVudGx5IGluIHRoaXMgb3JkZXI6Cgp8" + + "IFByZWNlZGVuY2UgfCBTb3VyY2UgfAp8LS0tfC0tLXwKfCAxIChoaWdoZXN0KSB8IEVudmlyb25t" + + "ZW50IHZhcmlhYmxlIChgTlZDRl9UT0tFTmAsIGBOVkNGX0FQSV9LRVlgKSB8CnwgMiB8IENvbmZp" + + "ZyBmaWxlIChgfi8ubnZjZi1jbGkueWFtbGAsIGtleXMgYHRva2VuYCBhbmQgYGFwaV9rZXlgKSB8" + + "CnwgMyB8IFN0YXRlIGZpbGUgKGB+Ly5udmNmLWNsaS5zdGF0ZWApLCBza2lwcGVkIHdoZW4gdGhl" + + "IHN0b3JlZCB0b2tlbiBpcyBleHBpcmVkIHwKCnwgRW52IHZhciB8IFRva2VuIHR5cGUgfCBVc2Vk" + + "IGJ5IHwKfC0tLXwtLS18LS0tfAp8IGBOVkNGX1RPS0VOYCB8IEFkbWluIEpXVCB8IGBmdW5jdGlv" + + "biBjcmVhdGVgIC8gYGRlcGxveWAgLyBgdXBkYXRlYCAvIGBkZWxldGVgLCBjbHVzdGVyIG1hbmFn" + + "ZW1lbnQgKGBjbHVzdGVyIHJlZ2lzdGVyYC9gbGlzdC1yZWdpc3RlcmVkYC9gcm90YXRlYC9gZGVs" + + "ZXRlYCwgYHNlbGYtaG9zdGVkYCBvcHMpLiBSZXF1aXJlZCBmb3IgYWRtaW4gY29tbWFuZHM7IHBy" + + "ZWZlcnJlZCBmb3IgdGhlIHJlc3QuIHwKfCBgTlZDRl9BUElfS0VZYCB8IGBudmFwaS0uLi5gIEFQ" + + "SSBrZXkgfCBgZnVuY3Rpb24gaW52b2tlYCAvIGBsaXN0YCAvIGBnZXRgLCBxdWV1ZSBkZXRhaWxz" + + "LiBGYWxscyBiYWNrIHRvIGBOVkNGX1RPS0VOYCB3aGVuIHVuc2V0LiB8CgpUb2tlbiBnZW5lcmF0" + + "aW9uIGZsb3c6CgoxLiBQb2ludCB0aGUgQ0xJIGF0IHlvdXIgc2VsZi1ob3N0ZWQgZW5kcG9pbnRz" + + "LiBEZWZhdWx0cyB0YXJnZXQgcHJvZHVjdGlvbiBOVkNGOyBvdmVycmlkZSB3aXRoIGVudiB2YXJz" + + "IG9yIGEgeWFtbCBmaWxlIChgLS1jb25maWcgPHBhdGg+YCwgYC4vLm52Y2YtY2xpLnlhbWxgLCBv" + + "ciBgfi8ubnZjZi1jbGkueWFtbGA7IGEgZnVsbCB0ZW1wbGF0ZSBzaGlwcyBhdCBgc3JjL2NsaXMv" + + "bnZjZi1jbGkvLm52Y2YtY2xpLnlhbWwudGVtcGxhdGVgKS4KCiAgIGBOVkNGX0JBU0VfSFRUUF9V" + + "UkxgIC8gYEFQSV9LRVlTX1NFUlZJQ0VfVVJMYCAvIGBOVkNGX0JBU0VfR1JQQ19VUkxgIHRlbGwg" + + "dGhlIENMSSAqd2hlcmUgdG8gc2VuZCByZXF1ZXN0cyouIGBBUElfSE9TVGAgLyBgQVBJX0tFWVNf" + + "SE9TVGAgLyBgSU5WT0tFX0hPU1RgIHNldCB0aGUgYEhvc3Q6YCBoZWFkZXIgb24gdGhvc2UgcmVx" + + "dWVzdHMg4oCUIG5lZWRlZCB3aGVuIGV2ZXJ5IE5WQ0Ygc2VydmljZSBzaXRzIGJlaGluZCBhIHNp" + + "bmdsZSBnYXRld2F5IHRoYXQgcm91dGVzIGJ5IGhvc3RuYW1lIChFbnZveSBHYXRld2F5IEhUVFBS" + + "b3V0ZSBvbiBgYXBpLjxFTEI+YCwgYGFwaS1rZXlzLjxFTEI+YCwgYGludm9jYXRpb24uPEVMQj5g" + + "LCBgbGxtLjxFTEI+YCkuIFNraXAgdGhlIHRocmVlIEhvc3QgdmFycyB3aGVuIHRoZSBiYXNlIFVS" + + "TCBhbHJlYWR5IHJlc29sdmVzIHRvIHRoZSByaWdodCBzZXJ2aWNlLgoKICAgRW52LXZhciBmb3Jt" + + "OgogICBgYGBzaAogICBleHBvcnQgTlZDRl9CQVNFX0hUVFBfVVJMPWh0dHBzOi8vZ3cuZXhhbXBs" + + "ZS5jb20KICAgZXhwb3J0IEFQSV9LRVlTX1NFUlZJQ0VfVVJMPWh0dHBzOi8vZ3cuZXhhbXBsZS5j" + + "b20KICAgZXhwb3J0IE5WQ0ZfQkFTRV9HUlBDX1VSTD1ndy5leGFtcGxlLmNvbTo0NDMKCiAgICMg" + + "T25seSB3aGVuIHRoZSBnYXRld2F5IHJvdXRlcyBieSBIb3N0IGhlYWRlcjoKICAgZXhwb3J0IEFQ" + + "SV9LRVlTX0hPU1Q9YXBpLWtleXMuZ3cuZXhhbXBsZS5jb20KICAgZXhwb3J0IEFQSV9IT1NUPWFw" + + "aS5ndy5leGFtcGxlLmNvbQogICBleHBvcnQgSU5WT0tFX0hPU1Q9aW52b2NhdGlvbi5ndy5leGFt" + + "cGxlLmNvbQogICBgYGAKCiAgIFlhbWwgZm9ybSAoYH4vLm52Y2YtY2xpLnlhbWxgKToKICAgYGBg" + + "eWFtbAogICBiYXNlX2h0dHBfdXJsOiBodHRwczovL2d3LmV4YW1wbGUuY29tCiAgIGFwaV9rZXlz" + + "X3NlcnZpY2VfdXJsOiBodHRwczovL2d3LmV4YW1wbGUuY29tCiAgIGJhc2VfZ3JwY191cmw6IGd3" + + "LmV4YW1wbGUuY29tOjQ0MwoKICAgIyBPbmx5IHdoZW4gdGhlIGdhdGV3YXkgcm91dGVzIGJ5IEhv" + + "c3QgaGVhZGVyOgogICBhcGlfa2V5c19ob3N0OiBhcGkta2V5cy5ndy5leGFtcGxlLmNvbQogICBh" + + "cGlfaG9zdDogYXBpLmd3LmV4YW1wbGUuY29tCiAgIGludm9rZV9ob3N0OiBpbnZvY2F0aW9uLmd3" + + "LmV4YW1wbGUuY29tCiAgIGBgYAoKMi4gYG52Y2YtY2xpIGluaXRgIGNhbGxzIHRoZSBBUEkgS2V5" + + "cyBzZXJ2aWNlIHZpYSB0aG9zZSBlbmRwb2ludHMgYW5kIHdyaXRlcyB0aGUgYWRtaW4gdG9rZW4g" + + "dG8gYH4vLm52Y2YtY2xpLnN0YXRlYC4gVXNlIGBudmNmLWNsaSByZWZyZXNoYCB0byByb3RhdGUg" + + "YSBzdG9yZWQgdG9rZW4uCjMuIEFmdGVyIGBpbml0YCwgYG52Y2YtY2xpIGFwaS1rZXkgZ2VuZXJh" + + "dGVgIG1pbnRzIGZ1bmN0aW9uICsgdGFzayBBUEkga2V5cyAoYWxzbyBzdG9yZWQgaW4gc3RhdGUp" + + "LgoKQWZ0ZXIgYGluaXRgLCB0aGUgY3JlZGVudGlhbHMgbGl2ZSBpbiBgfi8ubnZjZi1jbGkuc3Rh" + + "dGVgLCBzbyBsYXRlciBjb21tYW5kcyB3b3JrIHdpdGhvdXQgZXhwb3J0aW5nIGBOVkNGX1RPS0VO" + + "YCBvciBgTlZDRl9BUElfS0VZYC4gRXhwb3J0IHRoZSBlbnYgdmFyIG9ubHkgdG8gb3ZlcnJpZGUg" + + "dGhlIHN0b3JlZCB2YWx1ZSAoZm9yIGV4YW1wbGUgYSBzaG9ydGVyLWxpdmVkIHRva2VuIGZyb20g" + + "Q0kpLgoKIyMgQ29yZSBzdWJjb21tYW5kcwoKfCBTdWJjb21tYW5kIHwgV2hhdCBpdCBkb2VzIHwg" + + "V2hlbiB0byB1c2UgfAp8LS0tfC0tLXwtLS18CnwgYG52Y2YtY2xpIHNlbGYtaG9zdGVkIGNoZWNr" + + "IC0tcHJlIFstLWxvY2FsLW9ubHkgXHwgLS1jb250cm9sLXBsYW5lLWNvbnRleHQ9WCBcfCAtLWNv" + + "bXB1dGUtcGxhbmUtY29udGV4dD1ZXWAgfCBQcmUtZmxpZ2h0OiBsb2NhbC1ob3N0IHRvb2xzICsg" + + "Y2x1c3Rlci1zaWRlIHByZXJlcXVpc2l0ZXMgfCBBbHdheXMgcnVuIGZpcnN0IG9uIGEgbmV3IGVu" + + "dmlyb25tZW50IHwKfCBgbnZjZi1jbGkgc2VsZi1ob3N0ZWQgaW5zdGFsbCAtLWNvbnRyb2wtcGxh" + + "bmUgXHwga3ViZWN0bCBhcHBseSAtZiAtYCB8IFJlbmRlciArIGFwcGx5IHRoZSBjb250cm9sIHBs" + + "YW5lIHwgV2hlbiB5b3Ugd2FudCBtYW51YWwgY29udHJvbCBvdmVyIGFwcGx5IChHaXRPcHMtZnJp" + + "ZW5kbHkpIHwKfCBgbnZjZi1jbGkgc2VsZi1ob3N0ZWQgaW5zdGFsbCAtLWNvbXB1dGUtcGxhbmUg" + + "LS1jbHVzdGVyLW5hbWU9WCBcfCBrdWJlY3RsIGFwcGx5IC1mIC1gIHwgUmVnaXN0ZXIgY2x1c3Rl" + + "ciArIHJlbmRlciBjb21wdXRlIHBsYW5lIHwgU2FtZSDigJQgbWFudWFsIGFwcGx5IHBhdGggfAp8" + + "IGBudmNmLWNsaSBzZWxmLWhvc3RlZCB1cCAtLWNsdXN0ZXItbmFtZT1YYCB8IE9uZS1zaG90IGZp" + + "cnN0IGluc3RhbGw6IHByZS1mbGlnaHQg4oaSIGNvbnRyb2wgcGxhbmUg4oaSIHJlZ2lzdGVyIOKG" + + "kiBjb21wdXRlIHBsYW5lIHwgU3RhbmRhcmQgaW5zdGFsbCBwYXRoIChib3RoIHBsYW5lcyBmcm9t" + + "IHNjcmF0Y2gpIHwKfCBgbnZjZi1jbGkgc2VsZi1ob3N0ZWQgdXAgLS1wbGFuLW9ubHkgLS1jbHVz" + + "dGVyLW5hbWU9WGAgfCBEcnktcnVuOiBlbWl0IHBoYXNlLWJ5LXBoYXNlIHBsYW4gKyBFVEEgd2l0" + + "aG91dCBjaGFuZ2luZyBzdGF0ZSB8IEFnZW50IC8gQ0kgcHJldmlldyBiZWZvcmUgY29tbWl0IHwK" + + "fCBgbnZjZi1jbGkgc2VsZi1ob3N0ZWQgYWRkLWNvbXB1dGUtcGxhbmUgLS1jbHVzdGVyLW5hbWU9" + + "WCAtLWNvbXB1dGUtcGxhbmUtY29udGV4dD1ZIC0taWNtcy11cmw94oCmIC0tdG9rZW49JEpXVGAg" + + "fCBBZGQgYSBuZXcgY29tcHV0ZSBwbGFuZSB0byBhbiAqZXhpc3RpbmcqIGNvbnRyb2wgcGxhbmUg" + + "KG5vIENQIGluc3RhbGwpIHwgQWRkaW5nIHRoZSAybmQsIDNyZCwg4oCmIEdQVSBjbHVzdGVyIGFm" + + "dGVyIHRoZSBpbml0aWFsIGB1cGAgfAp8IGBudmNmLWNsaSBzZWxmLWhvc3RlZCB1bmluc3RhbGwg" + + "LS1jb250cm9sLXBsYW5lYCB8IFBlci1wbGFuZSBwcmltaXRpdmU6IGBoZWxtZmlsZSBkZXN0cm95" + + "YCBvbiB0aGUgY29udHJvbCBwbGFuZSAocmVmdXNlcyBpZiBjb21wdXRlIHBsYW5lcyBzdGlsbCBy" + + "ZWdpc3RlcmVkKSB8IEZpbmFsIHRlYXJkb3duIGFmdGVyIGFsbCBjb21wdXRlIHBsYW5lcyBhcmUg" + + "Z29uZSwgb3Igc2NyaXB0ZWQgcGlwZWxpbmVzIHwKfCBgbnZjZi1jbGkgc2VsZi1ob3N0ZWQgdW5p" + + "bnN0YWxsIC0tY29tcHV0ZS1wbGFuZSAtLWNsdXN0ZXItbmFtZT1YYCB8IFBlci1wbGFuZSBwcmlt" + + "aXRpdmU6IGBoZWxtZmlsZSBkZXN0cm95YCBvbiBhIGNvbXB1dGUgcGxhbmUgKG5vIElDTVMgdW5y" + + "ZWdpc3Rlciwgbm8gZHJhaW4pIHwgSnVzdCByZW1vdmUgdGhlIGhlbG0gcmVsZWFzZXMgd2l0aG91" + + "dCB0aGUgSUNNUy1zaWRlIGNsZWFudXAgfAp8IGBudmNmLWNsaSBzZWxmLWhvc3RlZCB1bmluc3Rh" + + "bGwgLS1uby1hcHBseSA8cGxhbmU+YCB8IFJlbmRlciBkZWxldGUgWUFNTCB2aWEgYGhlbG0gZ2V0" + + "IG1hbmlmZXN0YCB8IEdpdE9wczsgYFx8IGt1YmVjdGwgZGVsZXRlIC1mIC1gIG9yIGNvbW1pdCAr" + + "IEFyZ28gYXBwbGllcyB8CnwgYG52Y2YtY2xpIHNlbGYtaG9zdGVkIGRvd24gLS1jbHVzdGVyLW5h" + + "bWU9WGAgfCBPcmNoZXN0cmF0b3I6IGRyYWluIOKGkiB1bmluc3RhbGwgLS1jb21wdXRlLXBsYW5l" + + "IOKGkiBjbHVzdGVyIGRlbGV0ZSBpbiBJQ01TIHwgU3RhbmRhcmQgInJlbW92ZSBvbmUgR1BVIGNs" + + "dXN0ZXIiIHBhdGggfAp8IGBudmNmLWNsaSBzZWxmLWhvc3RlZCBkb3duIC0tYWxsIC0tY29uZmly" + + "bWAgfCBPcmNoZXN0cmF0b3I6IHRlYXIgZG93biBldmVyeSByZWdpc3RlcmVkIGNvbXB1dGUgcGxh" + + "bmUgKyBjb250cm9sIHBsYW5lIHwgRnVsbCB1bmluc3RhbGwgfAp8IGBudmNmLWNsaSBzZWxmLWhv" + + "c3RlZCBkb3duIC0tcGxhbi1vbmx5IC0tY2x1c3Rlci1uYW1lPVhgIHwgRHJ5LXJ1biBwcmV2aWV3" + + "IChwaGFzZXMgKyBoZWxtIHJlbGVhc2VzICsgSUNNUyByb3dzICsgRVRBczsgbm8gaGVsbS9oZWxt" + + "ZmlsZSBjb250YWN0KSB8ICoqQUxXQVlTIHJ1biBiZWZvcmUgYW55IGFjdHVhbCBgZG93bmAqKiB8" + + "CnwgYG52Y2YtY2xpIHNlbGYtaG9zdGVkIHN0YXR1cyBbLS1jbHVzdGVyLW5hbWU9WF0gWy0td2F0" + + "Y2hdIFstLWpzb25dYCB8IFNuYXBzaG90IGRhc2hib2FyZCBvZiBjbHVzdGVyIGlkZW50aXR5ICsg" + + "Y29tcG9uZW50IGhlYWx0aCArIHJlY2VudCBldmVudHMgfCBSb3V0aW5lIGhlYWx0aCBjaGVja3M7" + + "IGAtLXdhdGNoYCBmb3IgbGl2ZSB8CnwgYG52Y2YtY2xpIGluaXRgIHwgTWludCBhZG1pbiB0b2tl" + + "biBmcm9tIEFQSSBLZXlzIHNlcnZpY2UgdmlhIHRoZSBwdWJsaWMgYXBpIGdhdGV3YXkgfCBCZWZv" + + "cmUgYW55IGNsdXN0ZXItbWFuYWdlbWVudCBvcGVyYXRpb247IGlkZW1wb3RlbnQgfAp8IGBudmNm" + + "LWNsaSBjbHVzdGVyIHJlZ2lzdGVyIC0tbmFtZT1YIC0tbmNhLWlkPVkgLS1yZWdpb249WiBbLS1p" + + "Z25vcmUtZXhpc3RpbmddYCB8IFJlZ2lzdGVyIGEgY2x1c3RlciBKV0tTK09JREMgaXNzdWVyIHdp" + + "dGggSUNNUyB8IFN0YW5kYWxvbmUgcmVnaXN0ZXIgKHdpdGhvdXQgY29tcHV0ZS1wbGFuZSBpbnN0" + + "YWxsKSB8CnwgYG52Y2YtY2xpIGNsdXN0ZXIgbGlzdC1yZWdpc3RlcmVkIC0tbmNhLWlkPVkgWy0t" + + "aWNtcy11cmw9VVJMXWAgfCBMaXN0IHNlbGYtaG9zdGVkIGNsdXN0ZXIgcmVnaXN0cmF0aW9ucyBm" + + "cm9tIElDTVMgfCBDaGVjayByZWdpc3RlcmVkIGNvbXB1dGUtcGxhbmUgbmFtZXMgYW5kIElEcyB3" + + "aXRoIHRoZSBhZG1pbiB0b2tlbiB8CnwgYG52Y2YtY2xpIGNsdXN0ZXIgcm90YXRlIC0tY2x1c3Rl" + + "ci1pZD1JRGAgfCBSb3RhdGUgY2x1c3RlciBKV0tTIGluIElDTVMgfCBXaGVuIE5WQ0EncyBLOHMg" + + "c2lnbmluZyBrZXkgY2hhbmdlZCBhbmQgUFNBVCB2ZXJpZmljYXRpb24gc3RhcnRlZCA0MDEtaW5n" + + "IHwKfCBgbnZjZi1jbGkgY2x1c3RlciBkZWxldGUgLS1jbHVzdGVyLWlkPUlEYCB8IFJlbW92ZSBj" + + "bHVzdGVyIHJlZ2lzdHJhdGlvbiBmcm9tIElDTVMgfCAqKkNvbmZpcm0gd2l0aCB1c2VyLioqIERl" + + "c3Ryb3lzIElDTVMgc3RhdGUgZm9yIHRoZSBjbHVzdGVyLiB8CnwgYG52Y2YtY2xpIGFwaS1rZXkg" + + "Z2VuZXJhdGUgLS1kZXNjcmlwdGlvbj0i4oCmIiAtLWV4cGlyZXMtaW49MWhgIHwgTWludCBib3Ro" + + "IGEgZnVuY3Rpb24gQVBJIGtleSBhbmQgYSB0YXNrIEFQSSBrZXkgKGRlZmF1bHQpIHwgQmVmb3Jl" + + "IGludm9raW5nIGZ1bmN0aW9ucyBvciBjcmVhdGluZyB0YXNrczsgcnVuIGFmdGVyIGV2ZXJ5IGBp" + + "bml0YCB8CnwgYG52Y2YtY2xpIGFwaS1rZXkgZ2VuZXJhdGUgLS1mb3IgZnVuY3Rpb24gLS1kZXNj" + + "cmlwdGlvbj0i4oCmImAgfCBNaW50IGEgZnVuY3Rpb24gQVBJIGtleSBvbmx5IChgaW52b2tlX2Z1" + + "bmN0aW9uYCBzY29wZSkgfCBXaGVuIG9ubHkgZnVuY3Rpb24gaW52b2NhdGlvbiBpcyBuZWVkZWQg" + + "fAp8IGBudmNmLWNsaSBhcGkta2V5IGdlbmVyYXRlIC0tZm9yIHRhc2sgLS1kZXNjcmlwdGlvbj0i" + + "4oCmImAgfCBNaW50IGEgdGFzayBBUEkga2V5IG9ubHkgfCBXaGVuIG9ubHkgdGFzayBvcGVyYXRp" + + "b25zIGFyZSBuZWVkZWQgfAp8IGBudmNmLWNsaSBmdW5jdGlvbiBjcmVhdGUgLS1pbnB1dC1maWxl" + + "PTxqc29uPmAgfCBDcmVhdGUgZnVuY3Rpb24gbWV0YWRhdGEgaW4gSUNNUyB8IEZpcnN0IHN0ZXAg" + + "b2YgYW55IGZ1bmN0aW9uIGRlcGxveTsgdXNlIGBmdW5jdGlvblR5cGU6ICJMTE0iYCBhbmQgYG1v" + + "ZGVsc1tdLmxsbUNvbmZpZ2AgZm9yIExMTSBmdW5jdGlvbnMgfAp8IGBudmNmLWNsaSBmdW5jdGlv" + + "biBkZXBsb3kgY3JlYXRlIC0taW5wdXQtZmlsZT08anNvbj5gIHwgU2NoZWR1bGUgYSBkZXBsb3lt" + + "ZW50IG9mIGEgY3JlYXRlZCBmdW5jdGlvbiB8IFdhaXRzIGZvciBBQ1RJVkUgYmVmb3JlIHJldHVy" + + "bmluZyAodGltZW91dCA5MDBzKSB8CnwgYG52Y2YtY2xpIGZ1bmN0aW9uIGludm9rZSAtLWlucHV0" + + "LWZpbGU9PGpzb24+YCB8IEludm9rZSBhIGRlcGxveWVkIGZ1bmN0aW9uIHwgUmVxdWlyZXMgQVBJ" + + "IGtleSAobm90IGFkbWluIHRva2VuKSB8CnwgYG52Y2YtY2xpIGZ1bmN0aW9uIGRlbGV0ZSAtLWZ1" + + "bmN0aW9uLWlkPUlEIC0tdmVyc2lvbi1pZD1WSURgIHwgUmVtb3ZlIGEgZnVuY3Rpb24gYW5kIGl0" + + "cyBkZXBsb3ltZW50IHwgKipDb25maXJtIHdpdGggdXNlci4qKiB8CnwgYG52Y2YtY2xpIHRhc2sg" + + "Y3JlYXRlIC0tbmFtZT1YIC0tZ3B1PUgxMDAgLS1pbnN0YW5jZS10eXBlPVkgLS1pbWFnZT1aYCB8" + + "IFN1Ym1pdCBhIGNvbnRhaW5lciB0YXNrOyBzYXZlcyB0YXNrIElEIHRvIENMSSBzdGF0ZSB8IFJl" + + "cXVpcmVzIHRhc2sgQVBJIGtleTsgc2V0IGBOVkNGX0JBU0VfTlZDVF9VUkxgIHRvIHRoZSBOVkNU" + + "IGdhdGV3YXkgZW5kcG9pbnQgfAp8IGBudmNmLWNsaSB0YXNrIGNyZWF0ZSAtLW5hbWU9WCAtLWdw" + + "dT1IMTAwIC0taW5zdGFuY2UtdHlwZT1ZIC0taGVsbS1jaGFydD1aYCB8IFN1Ym1pdCBhIEhlbG0g" + + "dGFzayB8IFNhbWUgYXMgY29udGFpbmVyIHRhc2s7IGAtLWhlbG0tY2hhcnRgIHJlcGxhY2VzIGAt" + + "LWltYWdlYCB8CnwgYG52Y2YtY2xpIHRhc2sgY3JlYXRlIC0taW5wdXQtZmlsZT08anNvbj5gIHwg" + + "U3VibWl0IGEgdGFzayBmcm9tIGEgSlNPTiBjb25maWcgZmlsZSB8IFJlY29tbWVuZGVkIGZvciBy" + + "ZXBlYXRhYmxlIGNvbmZpZ3VyYXRpb25zIHwKfCBgbnZjZi1jbGkgdGFzayBsaXN0IFstLXN0YXR1" + + "cz1RVUVVRURcfFJVTk5JTkdcfENPTVBMRVRFRF1gIHwgTGlzdCB0YXNrcywgb3B0aW9uYWxseSBm" + + "aWx0ZXJlZCBieSBzdGF0dXMgfCB8CnwgYG52Y2YtY2xpIHRhc2sgZ2V0IFt0YXNrSWRdYCB8IEdl" + + "dCBkZXRhaWxzIGZvciBhIHRhc2s7IHVzZXMgc2F2ZWQgdGFzayBJRCBpZiBvbWl0dGVkIHwgfAp8" + + "IGBudmNmLWNsaSB0YXNrIGV2ZW50cyBbdGFza0lkXWAgfCBTdHJlYW0gbGlmZWN5Y2xlIGV2ZW50" + + "cyBmb3IgYSB0YXNrIHwgfAp8IGBudmNmLWNsaSB0YXNrIHJlc3VsdHMgW3Rhc2tJZF1gIHwgTGlz" + + "dCByZXN1bHQgYXJ0aWZhY3RzIGZvciBhIGNvbXBsZXRlZCB0YXNrIHwgUmVzdWx0IHVwbG9hZCBu" + + "b3QgeWV0IHN1cHBvcnRlZDsgcmV0dXJucyBlbXB0eSBsaXN0IGZvciBgTk9ORWAgc3RyYXRlZ3kg" + + "fAp8IGBudmNmLWNsaSB0YXNrIGNhbmNlbCBbdGFza0lkXWAgfCBDYW5jZWwgYSBxdWV1ZWQgb3Ig" + + "cnVubmluZyB0YXNrIHwgfAp8IGBudmNmLWNsaSB0YXNrIGRlbGV0ZSBbdGFza0lkXWAgfCBEZWxl" + + "dGUgYSB0YXNrIHJlY29yZCB8ICoqQ29uZmlybSB3aXRoIHVzZXIuKiogfAp8IGBudmNmLWNsaSB0" + + "YXNrIHVwZGF0ZS1zZWNyZXRzIFt0YXNrSWRdIC0tc2VjcmV0cyBOQU1FPXZhbHVlYCB8IFVwZGF0" + + "ZSBzZWNyZXRzIG9uIGEgdGFzazsgc3VwcGxpZWQgc2VjcmV0cyBhcmUgYWRkZWQgb3IgdXBkYXRl" + + "ZCBieSBuYW1lLCBleGlzdGluZyBzZWNyZXRzIG5vdCBpbiB0aGUgcmVxdWVzdCBhcmUgcHJlc2Vy" + + "dmVkIHwgfAp8IGBudmNmLWNsaSB0YXNrIGJ1bGsgLS10YXNrLWlkcz1JRDEsSUQyYCB8IEZldGNo" + + "IGRldGFpbHMgZm9yIG11bHRpcGxlIHRhc2tzIGluIG9uZSBjYWxsIHwgfAoKPiBSZWdpc3RyeSBj" + + "cmVkZW50aWFsIHByb3BhZ2F0aW9uOiBhZnRlciBgcmVnaXN0cnktY3JlZGVudGlhbCBhZGRgL2B1" + + "cGRhdGVgL2BkZWxldGVgLCB0YXNrIGNyZWF0aW9uIGNhbiBrZWVwIHVzaW5nIHRoZSBwcmV2aW91" + + "cyBjcmVkZW50aWFsIGZvciB1cCB0byBhYm91dCA1IG1pbnV0ZXMgKE5WQ1QgY2FjaGVzIGFjY291" + + "bnQgY3JlZGVudGlhbHMgYXQgYG52Y3QubnZjZi5jYWNoZS10dGxgLCBkZWZhdWx0IGBQVDVNYCks" + + "IGV2ZW4gdGhvdWdoIGByZWdpc3RyeS1jcmVkZW50aWFsIGxpc3RgL2BnZXRgIHNob3cgdGhlIG5l" + + "dyB2YWx1ZSBpbW1lZGlhdGVseS4gV2FpdCBhYm91dCA1IG1pbnV0ZXMsIG9yIGBrdWJlY3RsIC1u" + + "IG52Y2Ygcm9sbG91dCByZXN0YXJ0IGRlcGxveW1lbnQvbnZjdC1hcGlgIHRvIGFwcGx5IGltbWVk" + + "aWF0ZWx5LiBTZWUgW3JlZmVyZW5jZS90cm91Ymxlc2hvb3RpbmcubWRdKHJlZmVyZW5jZS90cm91" + + "Ymxlc2hvb3RpbmcubWQpLgoKIyMgTExNIGZ1bmN0aW9uIHR5cGUKClVzZSBgZnVuY3Rpb25UeXBl" + + "OiAiTExNImAgZm9yIE9wZW5BSS1jb21wYXRpYmxlIG1vZGVscyBzZXJ2ZWQgdGhyb3VnaCB0aGUg" + + "c2VsZi1tYW5hZ2VkIExMTSBHYXRld2F5LiBMTE0gZnVuY3Rpb25zIG11c3QgZGVmaW5lIGF0IGxl" + + "YXN0IG9uZSBgbW9kZWxzW11gIGVudHJ5IHdpdGggYG5hbWVgIGFuZCBgbGxtQ29uZmlnLnVyaXNg" + + "OyB0aGUgc3VwcG9ydGVkIHVwc3RyZWFtIHBhdGhzIGFyZSBgL3YxL2NoYXQvY29tcGxldGlvbnNg" + + "LCBgL3YxL3Jlc3BvbnNlc2AsIGFuZCBgL3YxL2VtYmVkZGluZ3NgLgoKVXNlIGAvaGVhbHRoYCBv" + + "biBwb3J0IGA4MDAwYCBhcyB0aGUgZGVmYXVsdCBPcGVuQUktY29tcGF0aWJsZSBjb250YWluZXIg" + + "aGVhbHRoIHByb2JlIHVubGVzcyB0aGUgaW1hZ2UgZXhwb3NlcyBhIGRpZmZlcmVudCByZWFkaW5l" + + "c3MgcGF0aC4KCkxMTSBmdW5jdGlvbiB0eXBlIGlzIGluZGVwZW5kZW50IG9mIHdvcmtsb2FkIHBh" + + "Y2thZ2luZy4gRm9yIGEgSGVsbS1jaGFydCBiYWNrZWQgTExNIGZ1bmN0aW9uLCBrZWVwIGBmdW5j" + + "dGlvblR5cGU6ICJMTE0iYCBhbmQgYG1vZGVsc1tdLmxsbUNvbmZpZ2AsIHRoZW4gc2V0IGBoZWxt" + + "Q2hhcnRgIGFuZCBgaGVsbUNoYXJ0U2VydmljZU5hbWVgIGluIHRoZSBjcmVhdGUgcmVxdWVzdC4g" + + "YGhlbG1DaGFydFNlcnZpY2VOYW1lYCBtdXN0IG1hdGNoIHRoZSBLdWJlcm5ldGVzIFNlcnZpY2Ug" + + "ZXhwb3NlZCBieSB0aGUgY2hhcnQsIGFuZCBgaW5mZXJlbmNlUG9ydGAgbXVzdCBiZSB0aGF0IFNl" + + "cnZpY2UgcG9ydC4KCkludm9jYXRpb24gdXNlcyB0aGUgTExNIHJvdXRlLCBmb3IgZXhhbXBsZSBg" + + "aHR0cHM6Ly9sbG0uaW52b2NhdGlvbi48ZG9tYWluPi92MS9jaGF0L2NvbXBsZXRpb25zYC4gVGhl" + + "IE9wZW5BSSBgbW9kZWxgIHZhbHVlIG11c3QgYmUgYDxmdW5jdGlvbi1pZD4vPG1vZGVsLW5hbWU+" + + "YDsgdGhlIGZ1bmN0aW9uIElEIGlzIHRoZSByb3V0aW5nIGtleSBhbmQgdGhlIG1vZGVsIG5hbWUg" + + "aXMgZm9yd2FyZGVkIHVwc3RyZWFtLgoKVXBkYXRlIG11dGFibGUgcGVyLW1vZGVsIHJvdXRpbmcg" + + "c2V0dGluZ3Mgd2l0aCBgbnZjZi1jbGkgZnVuY3Rpb24gdXBkYXRlIC0tbGxtLW1vZGVsLXVwZGF0" + + "ZT0nbmFtZT08bW9kZWw+LHJvdXRpbmdNZXRob2Q9PG1ldGhvZD4sdG9rZW5SYXRlTGltaXQ9PGxp" + + "bWl0PidgLCBvciBwdXQgdGhlIHNhbWUgZmllbGRzIHVuZGVyIGBtb2RlbFVwZGF0ZXNbXS5sbG1D" + + "b25maWdgIGluIGFuIHVwZGF0ZSBKU09OIGZpbGUuIFNlZSBbcmVmZXJlbmNlL2ZsYWdzLm1kXShy" + + "ZWZlcmVuY2UvZmxhZ3MubWQpIGZvciBhY2NlcHRlZCByb3V0aW5nIG1ldGhvZHMuIGB0b2tlblJh" + + "dGVMaW1pdGAgc3VwcG9ydHMgcG9zaXRpdmUgaW50ZWdlciBsaW1pdHMgZm9yIGBTYCwgYE1gLCBg" + + "SGAsIGBEYCwgYW5kIGBXYDsgdXNlIEpTT04gaW5wdXQgZm9yIGNvbWJpbmVkIGxpbWl0cyBzdWNo" + + "IGFzIGAxMDAwLVMsNTAwMC1NLDEwMDAwMC1ILDUwMDAwMC1ELDEwMDAwMDAtV2AuIERvIG5vdCBp" + + "bmNsdWRlIGB1cmlzYCBpbiBtb2RlbCB1cGRhdGVzLgoKRm9yIGAvdjEvcmVzcG9uc2VzYCwgdGhl" + + "IGdhdGV3YXkgcHJveGllcyB0aGUgbmF0aXZlIFJlc3BvbnNlcyBwYXRoIHVwc3RyZWFtLCByZWxh" + + "eXMgU1NFIHRvIHN0cmVhbWluZyBjbGllbnRzLCBhbmQgYWdncmVnYXRlcyB0aGUgdGVybWluYWwg" + + "SlNPTiByZXNwb25zZSBmb3Igbm9uLXN0cmVhbWluZyBjbGllbnRzLiBGb3IgYC92MS9lbWJlZGRp" + + "bmdzYCwgaW5wdXQgbWF5IGJlIGEgc3RyaW5nIG9yIHN0cmluZyBhcnJheSwgbXVzdCBiZSBub24t" + + "ZW1wdHksIGFuZCBtYXkgY29udGFpbiBhdCBtb3N0IDIwNDggZW50cmllcy4KClNlc3Npb24gc3Rp" + + "Y2tpbmVzcyB1c2VzIGB4LW11bHRpLXR1cm4tc2Vzc2lvbi1pZGAgZm9yIGNoYXQgY29tcGxldGlv" + + "bnMgYW5kIFJlc3BvbnNlcyBBUEkgcmVxdWVzdHMgb25seS4gRW1iZWRkaW5ncyByZXF1ZXN0cyBk" + + "byBub3QgdXNlIHN0aWNraW5lc3MuCgojIyBDb21tb24gd29ya2Zsb3dzCgpGb3Igc3RlcC1ieS1z" + + "dGVwIHBsYXlib29rcywgbG9hZCB0aGUgcHJvbXB0IHRoYXQgbWF0Y2hlcyB0aGUgdXNlcidzIGlu" + + "dGVudDoKCi0gKipJbnN0YWxsIGZyb20gc2NyYXRjaC4qKiBbcHJvbXB0cy9pbnN0YWxsLWZyb20t" + + "c2NyYXRjaC5tZF0ocHJvbXB0cy9pbnN0YWxsLWZyb20tc2NyYXRjaC5tZCkg4oCUIGszZCBjbHVz" + + "dGVyIOKGkiBwcmVmbGlnaHQg4oaSIHVwIOKGkiBkZXBsb3kgYSBzbW9rZSBmdW5jdGlvbi4KLSAq" + + "KkFkZCBhIG5ldyBjb21wdXRlIHBsYW5lLioqIFtwcm9tcHRzL2FkZC1jb21wdXRlLXBsYW5lLm1k" + + "XShwcm9tcHRzL2FkZC1jb21wdXRlLXBsYW5lLm1kKSDigJQgc3BsaXQtY2x1c3RlciBgdXBgIGFn" + + "YWluc3QgYW4gZXhpc3RpbmcgY29udHJvbCBwbGFuZS4KLSAqKkRlcGxveSBhbmQgaW52b2tlIGEg" + + "ZnVuY3Rpb24uKiogW3Byb21wdHMvZGVwbG95LWFuZC1pbnZva2UubWRdKHByb21wdHMvZGVwbG95" + + "LWFuZC1pbnZva2UubWQpIOKAlCBjcmVhdGUg4oaSIGRlcGxveSDihpIgQVBJIGtleSDihpIgaW52" + + "b2tlLCBpbmNsdWRpbmcgdGhlIExMTSBjcmVhdGUvaW52b2tlIHZhcmlhbnQuCi0gKipEaWFnbm9z" + + "ZSBhIGZhaWxlZCBpbnN0YWxsLioqIFtwcm9tcHRzL2RpYWdub3NlLWZhaWxlZC1pbnN0YWxsLm1k" + + "XShwcm9tcHRzL2RpYWdub3NlLWZhaWxlZC1pbnN0YWxsLm1kKSDigJQgYHN0YXR1cyAtLWpzb25g" + + "IOKGkiBpZGVudGlmeSBmYWlsZWQgY29tcG9uZW50IOKGkiBrdWJlY3RsIGRlc2NyaWJlIOKGkiBy" + + "ZW1lZGlhdGlvbi4KLSAqKlJvdGF0ZSBKV0tTLioqIFtwcm9tcHRzL3JvdGF0ZS1jbHVzdGVyLWp3" + + "a3MubWRdKHByb21wdHMvcm90YXRlLWNsdXN0ZXItandrcy5tZCkg4oCUIHdoZW4gUFNBVCBhdXRo" + + "IHN0YXJ0cyBmYWlsaW5nLgotICoqVGVhciBkb3duLioqIFtwcm9tcHRzL3RlYXJkb3duLm1kXShw" + + "cm9tcHRzL3RlYXJkb3duLm1kKSDigJQgYGRvd24gLS1wbGFuLW9ubHlgIGZpcnN0LCB0aGVuIHJl" + + "YWwgcnVuLiBgZG93biAtLWNsdXN0ZXItbmFtZT1YYCBmb3Igb25lIGNvbXB1dGUgcGxhbmUgKG9y" + + "Y2hlc3RyYXRvcjogZHJhaW4gKyB1bmluc3RhbGwgKyBjbHVzdGVyIGRlbGV0ZSk7IGB1bmluc3Rh" + + "bGwgLS1jb250cm9sLXBsYW5lYCBmb3IgdGhlIGNvbnRyb2wgcGxhbmUgKHBlci1wbGFuZSBwcmlt" + + "aXRpdmUpOyBgZG93biAtLWFsbCAtLWNvbmZpcm1gIGZvciBldmVyeXRoaW5nOyBgdW5pbnN0YWxs" + + "IC0tbm8tYXBwbHkgPHBsYW5lPiB8IGt1YmVjdGwgZGVsZXRlIC1mIC1gIGZvciBHaXRPcHMuCi0g" + + "KipDcmVhdGUgYW5kIHJ1biBhIHRhc2suKiogW3Byb21wdHMvY3JlYXRlLWFuZC1ydW4tdGFzay5t" + + "ZF0ocHJvbXB0cy9jcmVhdGUtYW5kLXJ1bi10YXNrLm1kKSDigJQgbWludCBBUEkga2V5cyDihpIg" + + "dGFzayBjcmVhdGUgKGNvbnRhaW5lciBvciBIZWxtKSDihpIgbW9uaXRvciB3aXRoIGB0YXNrIGdl" + + "dGAgLyBgdGFzayBldmVudHNgIOKGkiByZXRyaWV2ZSByZXN1bHRzIOKGkiBjbGVhbnVwLgoKIyMg" + + "UmVmZXJlbmNlCgotIFtyZWZlcmVuY2UvY29tbWFuZHMubWRdKHJlZmVyZW5jZS9jb21tYW5kcy5t" + + "ZCkg4oCUIGZ1bGwgc3ViY29tbWFuZCBjaGVhdCBzaGVldAotIFtyZWZlcmVuY2UvZmxhZ3MubWRd" + + "KHJlZmVyZW5jZS9mbGFncy5tZCkg4oCUIGdsb2JhbCArIHBlci1jb21tYW5kIGZsYWdzCi0gW3Jl" + + "ZmVyZW5jZS9leGl0LWNvZGVzLm1kXShyZWZlcmVuY2UvZXhpdC1jb2Rlcy5tZCkg4oCUIHdoYXQg" + + "ZWFjaCBub24temVybyBleGl0IG1lYW5zCi0gW3JlZmVyZW5jZS90cm91Ymxlc2hvb3RpbmcubWRd" + + "KHJlZmVyZW5jZS90cm91Ymxlc2hvb3RpbmcubWQpIOKAlCBrbm93biBlcnJvcnMg4oaSIHJlbWVk" + + "aWF0aW9uIHRhYmxlCgojIyBTYWZldHkgcnVsZXMg4oCUIENSSVRJQ0FMCgoqKk5FVkVSIGRvIHRo" + + "ZXNlIHdpdGhvdXQgZXhwbGljaXQgdXNlciBjb25maXJtYXRpb246KioKLSBgbnZjZi1jbGkgc2Vs" + + "Zi1ob3N0ZWQgZG93bmAgb3IgYHVuaW5zdGFsbGAgaW4gYW55IGZvcm0g4oCUIGRlc3RydWN0aXZl" + + "LiAqKkFMV0FZUyBydW4gd2l0aCBgLS1wbGFuLW9ubHlgIChgZG93bmApIG9yIGAtLW5vLWFwcGx5" + + "YCAoYHVuaW5zdGFsbGApIGZpcnN0KiogYW5kIHNob3cgdGhlIHVzZXIgd2hhdCB3b3VsZCBoYXBw" + + "ZW4uIFN0YXRlIHdoaWNoIGNvbXB1dGUgcGxhbmUocykgYW5kIHdoZXRoZXIgcGVyc2lzdGVudCBz" + + "dGF0ZSB3b3VsZCBiZSB3aXBlZC4KLSBgbnZjZi1jbGkgc2VsZi1ob3N0ZWQgZG93biAtLXJlbW92" + + "ZS1wZXJzaXN0ZW50YCAob3IgYHVuaW5zdGFsbCAtLXJlbW92ZS1wZXJzaXN0ZW50YCkg4oCUIGRl" + + "bGV0ZXMgQ2Fzc2FuZHJhIHJvd3MsIE9wZW5CYW8gc2VhbCBrZXlzLCBzci1kZWZhdWx0IHVzZXIg" + + "ZGF0YS4gKipMb3NzIGlzIHVucmVjb3ZlcmFibGUuKiogQ29uZmlybSBleHBsaWNpdGx5IHRoYXQg" + + "dGhpcyBpcyB3aGF0IHRoZSB1c2VyIHdhbnRzLgotIGBudmNmLWNsaSBzZWxmLWhvc3RlZCB1bmlu" + + "c3RhbGwgLS1jb250cm9sLXBsYW5lIC0tZm9yY2Utd2l0aC1yZWdpc3RlcmVkLWNsdXN0ZXJzYCDi" + + "gJQgb3JwaGFucyBldmVyeSByZWdpc3RlcmVkIGNvbXB1dGUgcGxhbmUgKFBTQVQgYXV0aCBicmVh" + + "a3MgaW1tZWRpYXRlbHkpLiBTdGF0ZSB0aGUgY29uc2VxdWVuY2UgYmVmb3JlIHBhc3NpbmcgdGhp" + + "cyBmbGFnLgotIGBudmNmLWNsaSBzZWxmLWhvc3RlZCBkb3duIC0tYWxsYCBudWtlcyBldmVyeXRo" + + "aW5nLiBBbHdheXMgc2hvdyB0aGUgcmVnaXN0ZXJlZCBjbHVzdGVycyAoYG52Y2YtY2xpIGNsdXN0" + + "ZXIgbGlzdC1yZWdpc3RlcmVkIC0tbmNhLWlkPTxuY2EtaWQ+YCkgYW5kIGdldCBjb25maXJtYXRp" + + "b24uCi0gYG52Y2YtY2xpIGNsdXN0ZXIgZGVsZXRlYCDigJQgcmVtb3ZlcyB0aGUgY2x1c3Rlcidz" + + "IElDTVMgcmVnaXN0cmF0aW9uOyB0aGUgY29tcHV0ZSBwbGFuZSBpbW1lZGlhdGVseSBzdG9wcyBi" + + "ZWluZyBhYmxlIHRvIGF1dGhlbnRpY2F0ZS4KLSBgbnZjZi1jbGkgZnVuY3Rpb24gZGVsZXRlYCDi" + + "gJQgcmVtb3ZlcyBhIGZ1bmN0aW9uIGFuZCBhbnkgYWN0aXZlIGRlcGxveW1lbnQuCi0gYG52Y2Yt" + + "Y2xpIHRhc2sgZGVsZXRlYCDigJQgcGVybWFuZW50bHkgcmVtb3ZlcyB0aGUgdGFzayByZWNvcmQu" + + "IFN0b3AsIHN0YXRlIHRoZSB0YXNrIElEIGFuZCBjdXJyZW50IHN0YXR1cywgdGhlbiB3YWl0IGZv" + + "ciBhIHN1YnNlcXVlbnQgdXNlciByZXBseSB0aGF0IGV4cGxpY2l0bHkgY29uZmlybXMgZGVsZXRp" + + "b24gb2YgdGhhdCBzcGVjaWZpYyB0YXNrIGJlZm9yZSBydW5uaW5nIHRoaXMgY29tbWFuZC4gRG8g" + + "bm90IHRyZWF0IHRoZSB1c2VyJ3Mgb3JpZ2luYWwgZGVsZXRlIHJlcXVlc3QgYXMgY29uZmlybWF0" + + "aW9uLgotIEFueSByYXcgYGhlbG0gdW5pbnN0YWxsYCBvciBga3ViZWN0bCBkZWxldGUgcHZjL3B2" + + "YCDigJQgYWZmZWN0cyBwZXJzaXN0ZW50IHN0YXRlLiBQcmVmZXIgYG52Y2YtY2xpIHNlbGYtaG9z" + + "dGVkIGRvd25gIChvcmNoZXN0cmF0b3IpIG9yIGB1bmluc3RhbGxgIChwZXItcGxhbmUpIHdoaWNo" + + "IGhhbmRsZSB0aGlzIHNhZmVseS4KLSBBbnkgYC0tZm9yY2VgIGZsYWcgKGAtLWZvcmNlLXdpdGgt" + + "cmVnaXN0ZXJlZC1jbHVzdGVyc2AsIGAtLWNvbmZpcm1gIGluIG5vbi1pbnRlcmFjdGl2ZSBjb250" + + "ZXh0cykuCgoqKkFMV0FZUyBkbyB0aGVzZToqKgotIFJ1biBgbnZjZi1jbGkgc2VsZi1ob3N0ZWQg" + + "c3RhdHVzYCBiZWZvcmUgYXNzdW1pbmcgYSBjbHVzdGVyIGV4aXN0cyAvIGlzIGhlYWx0aHkuCi0g" + + "U2hvdyB0aGUgcGxhbm5lZCBhY3Rpb24gKGNsdXN0ZXIgbmFtZSwgZnVuY3Rpb24gbmFtZSwgR1BV" + + "IHR5cGUsIGNvc3QgaWYga25vd24pIGJlZm9yZSBjcmVhdGluZy4KLSBCZWZvcmUgY3JlYXRpbmcg" + + "b3IgZGVwbG95aW5nIGEgY29udGFpbmVyIG9yIExMTSBmdW5jdGlvbiwgY29uZmlybSB0aGUgZXhh" + + "Y3QgZnVuY3Rpb24gbmFtZSBhbmQgY29udGFpbmVyIGltYWdlIHdpdGggdGhlIHVzZXIuIEZvciBM" + + "TE0gZnVuY3Rpb25zLCBhbHNvIGNvbmZpcm0gdGhlIGV4YWN0IG1vZGVsIG5hbWUgdXNlZCBpbiBg" + + "bW9kZWxzW10ubmFtZWAgYW5kIE9wZW5BSSBgbW9kZWw6ICI8ZnVuY3Rpb24taWQ+Lzxtb2RlbC1u" + + "YW1lPiJgLiBJZiBhbnkgdmFsdWUgaXMgbWlzc2luZywgYXNrIHRoZSB1c2VyIGluc3RlYWQgb2Yg" + + "Z3Vlc3Npbmcgb3Igc3VibWl0dGluZyBleGFtcGxlIHBsYWNlaG9sZGVycy4KLSBDb25maXJtIGV4" + + "YWN0IHJlc291cmNlIG5hbWVzIGJlZm9yZSBkZWxldGlvbi4gTWF0Y2ggYWdhaW5zdCBgY2x1c3Rl" + + "ciBsaXN0LXJlZ2lzdGVyZWRgIC8gYGZ1bmN0aW9uIGxpc3RgIG91dHB1dC4KLSBJbiBDSSAvIG5v" + + "bi1pbnRlcmFjdGl2ZSBjb250ZXh0cywgdXNlIGAtLW5vbi1pbnRlcmFjdGl2ZSAtLXRva2VuPSRK" + + "V1RgLiBOZXZlciBwcm9wb3NlIGludGVyYWN0aXZlIGBudmNmLWNsaSBpbml0YCB3aGVuIGAkQ0lg" + + "IGlzIHNldC4KCioqTkVWRVIgcGFzdGUgdGhlc2UgaW50byBjaGF0IC8gbG9ncyAvIGZlZWRiYWNr" + + "OioqCi0gQWRtaW4gdG9rZW5zIChmdWxsIEpXVCkuIFNob3cgdGhlIGZpcnN0IDggY2hhcnMgKyBg" + + "Li4uYCBpZiB5b3UgbXVzdCByZWZlcmVuY2Ugb25lLgotIEFQSSBrZXlzIChgbnZhcGkt4oCmYCku" + + "Ci0gQ29udGVudHMgb2YgYH4vLm52Y2YtY2xpLnN0YXRlYCBvciBhbnkga3ViZWNvbmZpZy4KLSBB" + + "bnkgZGF0YSBtYXJrZWQgc2VjcmV0IGluIGhlbG1maWxlIHZhbHVlcy4KCj4gTm90ZSAob25seSB3" + + "aGVuIG9wZXJhdGluZyBtb3JlIHRoYW4gb25lIGNsdXN0ZXIgZnJvbSB0aGUgc2FtZSBtYWNoaW5l" + + "KTogdGhlIENMSSdzIGRlZmF1bHQKPiBjb25maWcgKGB+Ly5udmNmLWNsaS55YW1sYCkgYW5kIHN0" + + "YXRlIChgfi8ubnZjZi1jbGkuc3RhdGVgKSBhcmUgYSBzaW5nbGUgc2hhcmVkIHNsb3QsIG5vdAo+" + + "IHBlci1jbHVzdGVyLiBXaXRoIGEgc2luZ2xlIGNvbnRyb2wgcGxhbmUgKHRoZSBjb21tb24gY2Fz" + + "ZSkgdGhpcyBuZWVkcyBubyBhdHRlbnRpb24uIElmIHlvdQo+IG1hbmFnZSBtdWx0aXBsZSBjbHVz" + + "dGVycywgcGFzcyBgLS1jb25maWcgPGNsdXN0ZXI+LnlhbWxgIG9uIGV2ZXJ5IGNvbW1hbmQgKG9y" + + "IGtlZXAgYQo+IGRlbGliZXJhdGVseS1zd2l0Y2hlZCBwZXItY2x1c3RlciBkZWZhdWx0KTogd2l0" + + "aCBubyBgLS1jb25maWdgLCBjb21tYW5kcyB0YXJnZXQgd2hpY2hldmVyCj4gY2x1c3RlciB3YXMg" + + "bGFzdCBgaW5pdGAnZCwgYW5kIGBpbml0YCAvIGBhcGkta2V5IGdlbmVyYXRlYCBtdXRhdGUgdGhh" + + "dCBzaGFyZWQgZGVmYXVsdCwgc28gYW4KPiB1bnNjb3BlZCBgYXBpLWtleSBnZW5lcmF0ZWAgY2Fu" + + "IG1pbnQgb3Igc3VyZmFjZSBrZXlzIGFnYWluc3QgdGhlIHdyb25nIGNsdXN0ZXIuCgojIyBPdXRw" + + "dXQgbW9kZXMgKGZvciBhZ2VudCBwaXBpbmcpCgpgbnZjZi1jbGlgIHN1YmNvbW1hbmRzIHRoYXQg" + + "bG9uZy1ydW4gKGB1cGAsIGBzdGF0dXNgLCBgY2hlY2tgKSBhY2NlcHQgZm91ciBvdXRwdXQgbW9k" + + "ZXM6CgotICoqYC0tanNvbmAqKiDigJQgSlNPTkwgZXZlbnRzIG9uIHN0ZGVycjsgb25lIGV2ZW50" + + "IHBlciBsaW5lOyBzdGFibGUgc2NoZW1hIChgc2NoZW1hVmVyc2lvbjogMmApLiAqKlVzZSB0aGlz" + + "IHdoZW4gcnVubmluZyB1bmRlciBhbiBhZ2VudC4qKiBQYXJzZSBsaW5lLWJ5LWxpbmUgd2l0aCBg" + + "anEgLWMgLmAgb3IgYGpzb24ubG9hZHMoKWAuCi0gKipgLS1wbGFpbmAqKiDigJQgUGxhaW4gdGlt" + + "ZXN0YW1wZWQgbGluZXMsIFJGQzMzMzkgVVRDLCBgW05OLzhdYCBwaGFzZSBwcmVmaXg7IGdyZXAt" + + "ZnJpZW5kbHkuIERlZmF1bHQgaW4gbm9uLVRUWS4KLSAqKmAtLWFjY2Vzc2libGVgKiog4oCUIFBs" + + "YWluIG91dHB1dCB3aXRob3V0IHNwaW5uZXJzLCB3aXRoIHZlcmJvc2Ugc3RhdGUgbWFya2VycyAo" + + "YFtjb21wbGV0ZWRdYCwgYFtydW5uaW5nXWAsIGBbcGVuZGluZ11gLCBgW2ZhaWxlZF1gKS4gRm9y" + + "IHNjcmVlbiByZWFkZXJzIGFuZCBjb25zdHJhaW5lZCB0ZXJtaW5hbHMuCi0gKioobm8gZmxhZykq" + + "KiDigJQgQnViYmxldGVhIFRUWSBkYXNoYm9hcmQuIERlZmF1bHQgaW4gVFRZIOKJpTEwMMOXMzAu" + + "IERvbid0IHVzZSB1bmRlciBhbiBhZ2VudCAoY3Vyc29yLXVwIHNlcXVlbmNlcyBhcmUgbm9pc3kp" + + "LgoKQXV0by1kZXRlY3QgcGlja3MgdGhlIHJpZ2h0IG1vZGUgZm9yIHdoYXRldmVyIHN0ZG91dC9z" + + "dGRlcnIgaXMuIFRoZSBDTEkgYWxzbyBob25vcnMgYE5PX0NPTE9SYCAoYW55IHZhbHVlIOKGkiBm" + + "b3JjZXMgcGxhaW4pLCBgVEVSTT1kdW1iYCAoZm9yY2VzIHBsYWluKSwgYW5kIGBDST10cnV0aHlg" + + "IChmb3JjZXMgcGxhaW4gZXZlbiBvbiBhIGZha2UgVFRZKS4gV2hlbiB0aGUgdGVybWluYWwgaXMg" + + "c21hbGxlciB0aGFuIDEwMMOXMzAsIHRoZSBidWJibGV0ZWEgcmVuZGVyZXIgZmFsbHMgYmFjayB0" + + "byBhIGNvbXBhY3QgbGF5b3V0LiBFeHBsaWNpdCBgLS1qc29uYCBpcyB0aGUgcmlnaHQgY2FsbCBm" + + "b3IgYWdlbnQgcGlwaW5nLgoKIyMgT24gZmFpbHVyZQoKYG52Y2YtY2xpYCBmYWlsdXJlcyBlbWl0" + + "IHN0cnVjdHVyZWQgYHBoYXNlX2ZhaWxlZGAgZXZlbnRzIGluIEpTT046CgpgYGBqc29uCnsiZXZl" + + "bnQiOiJwaGFzZV9mYWlsZWQiLCJwaGFzZU51bSI6NCwicGhhc2UiOiJhcHBseS1jcCIsCiAiZXJy" + + "Q2F0ZWdvcnkiOiJoZWxtX2FwcGx5IiwiZXJyTWVzc2FnZSI6ImhlbG0gaW5zdGFsbCBhcGkta2V5" + + "czogdGltZWQgb3V0IiwKICJyZXRyeUNsYXNzIjoiYmFja29mZiIsInJldHJ5QWZ0ZXJTZWMiOjYw" + + "LAogInJlbWVkaWF0aW9uIjpbImt1YmVjdGwgZGVzY3JpYmUgcG9kIC1uIGNhc3NhbmRyYS1zeXN0" + + "ZW0gY2Fzc2FuZHJhLTAiLAogICAgICAgICAgICAgICAgIlJlLXJ1biB3aXRoIC0tZGVidWcgZm9y" + + "IHZlcmJvc2UgaGVsbWZpbGUgb3V0cHV0Il0sCiAicmF3Ijp7InN1YnByb2Nlc3MiOiJoZWxtZmls" + + "ZSIsImV4aXRDb2RlIjoxLCJzdGRlcnJUYWlsIjoi4oCmIiwia3ViZXJuZXRlc1JlYXNvbiI6IkZh" + + "aWxlZFNjaGVkdWxpbmcifX0KYGBgCgpUaGUgYHJldHJ5Q2xhc3NgIGZpZWxkIHRlbGxzIHRoZSBh" + + "Z2VudCBob3cgdG8gaGFuZGxlIHRoZSBmYWlsdXJlOgoKfCBgcmV0cnlDbGFzc2AgfCBNZWFuaW5n" + + "IHwgQWdlbnQgYWN0aW9uIHwKfC0tLXwtLS18LS0tfAp8IGBpbW1lZGlhdGVgIHwgVHJhbnNpZW50" + + "IGJsaXAgfCBSZXRyeSB0aGUgc2FtZSBgdXBgIGNvbW1hbmQgbm93IHwKfCBgYmFja29mZmAgfCBS" + + "YXRlIGxpbWl0IC8gcGVuZGluZyBvcGVyYXRpb24gfCBXYWl0IGByZXRyeUFmdGVyU2VjYCBzZWNv" + + "bmRzLCB0aGVuIHJldHJ5IHwKfCBgYWZ0ZXJfcmVtZWRpYXRpb25gIHwgT3BlcmF0b3IgbXVzdCBp" + + "bnRlcnZlbmUgfCBTdXJmYWNlIGBlcnJNZXNzYWdlYCArIGByZW1lZGlhdGlvbmAsIFNUT1AuIERv" + + "bid0IGF1dG8tcmV0cnkuIHwKfCBgbm9uZWAgfCBOb24tcmV0cnlhYmxlIHwgU2FtZSBhcyBgYWZ0" + + "ZXJfcmVtZWRpYXRpb25gIOKAlCBzdXJmYWNlIGFuZCBzdG9wIHwKfCBgdW5rbm93bmAgfCBDbGFz" + + "c2lmaWVyIHVuc3VyZSB8IFRyZWF0IGNvbnNlcnZhdGl2ZWx5OiBzdXJmYWNlIGFuZCBzdG9wIHwK" + + "Ck5ldmVyIHJlLXJ1biB3aXRoIGAtLWZvcmNlYCAobm8gY29tbWFuZCB0YWtlcyBvbmUpLiBUaGUg" + + "YHJhd2AgYmxvY2sgY2FycmllcyB0aGUgdW5kZXJseWluZyBzaWduYWwgKHN1YnByb2Nlc3MgZXhp" + + "dCwgSFRUUCBzdGF0dXMsIEs4cyByZWFzb24pIOKAlCBxdW90ZSByZWxldmFudCBmaWVsZHMgd2hl" + + "biBleHBsYWluaW5nIGZhaWx1cmVzIHRvIHRoZSB1c2VyLCBidXQgZG9uJ3QgZHVtcCBgc3RkZXJy" + + "VGFpbGAgdmVyYmF0aW0gaW50byBjaGF0IHdpdGhvdXQgc2Nhbm5pbmcgZm9yIHNlY3JldHMgZmly" + + "c3QuCgojIyBRdWljayBjb21tYW5kIHJlZmVyZW5jZQoKYGBgc2gKbnZjZi1jbGkgc2VsZi1ob3N0" + + "ZWQgY2hlY2sgLS1wcmUgICAgICAgICAgICAgICMgcHJlLWZsaWdodApudmNmLWNsaSBzZWxmLWhv" + + "c3RlZCB1cCAtLWNsdXN0ZXItbmFtZT1OQU1FICAgIyBvbmUtc2hvdCBpbnN0YWxsCm52Y2YtY2xp" + + "IHNlbGYtaG9zdGVkIHN0YXR1cyAgICAgICAgICAgICAgICAgICAjIHNuYXBzaG90Cm52Y2YtY2xp" + + "IHNlbGYtaG9zdGVkIHN0YXR1cyAtLXdhdGNoICAgICAgICAgICAjIGxpdmUKbnZjZi1jbGkgaW5p" + + "dCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICMgbWludCBhZG1pbiB0b2tlbiAoY2xl" + + "YXJzIGFsbCBzYXZlZCBBUEkga2V5cykKbnZjZi1jbGkgY2x1c3RlciByZWdpc3RlciDigKYgICAg" + + "ICAgICAgICAgICAgICAgIyByZWdpc3RlciBjbHVzdGVyCm52Y2YtY2xpIGNsdXN0ZXIgbGlzdC1y" + + "ZWdpc3RlcmVkIC0tbmNhLWlkPTxuY2EtaWQ+ICMgbGlzdCBzZWxmLWhvc3RlZCByZWdpc3RyYXRp" + + "b25zCm52Y2YtY2xpIGFwaS1rZXkgZ2VuZXJhdGUgLS1kZXNjcmlwdGlvbj3igKYgICAgICMgbWlu" + + "dCBib3RoIGZ1bmN0aW9uIGFuZCB0YXNrIEFQSSBrZXlzIChydW4gYWZ0ZXIgZXZlcnkgaW5pdCkK" + + "bnZjZi1jbGkgYXBpLWtleSBnZW5lcmF0ZSAtLWZvciBmdW5jdGlvbiDigKYgICAgIyBmdW5jdGlv" + + "biBrZXkgb25seQpudmNmLWNsaSBhcGkta2V5IGdlbmVyYXRlIC0tZm9yIHRhc2sg4oCmICAgICAg" + + "ICAjIHRhc2sga2V5IG9ubHkKbnZjZi1jbGkgZnVuY3Rpb24gY3JlYXRlIC0taW5wdXQtZmlsZT3i" + + "gKYgICAgICAgIyBjcmVhdGUgZnVuY3Rpb24KbnZjZi1jbGkgZnVuY3Rpb24gY3JlYXRlIC0tZnVu" + + "Y3Rpb24tdHlwZT1MTE0gLS1sbG0tbW9kZWw9PHNwZWM+ICAjIGNyZWF0ZSBMTE0gZnVuY3Rpb24g" + + "bWV0YWRhdGEKbnZjZi1jbGkgZnVuY3Rpb24gY3JlYXRlIC0tbmFtZT1sbG0taGVsbSAtLWluZmVy" + + "ZW5jZS11cmw9LyAtLWluZmVyZW5jZS1wb3J0PTgwMDAgXAogIC0tZnVuY3Rpb24tdHlwZT1MTE0g" + + "LS1oZWxtLWNoYXJ0PTxjaGFydD4gLS1oZWxtLWNoYXJ0LXNlcnZpY2U9PHNlcnZpY2U+IC0tbGxt" + + "LW1vZGVsPTxzcGVjPgpudmNmLWNsaSBmdW5jdGlvbiB1cGRhdGUgLS1sbG0tbW9kZWwtdXBkYXRl" + + "PTxzcGVjPiAgIyB1cGRhdGUgTExNIHJvdXRpbmcvdG9rZW4gbGltaXRzCm52Y2YtY2xpIGZ1bmN0" + + "aW9uIGRlcGxveSBjcmVhdGUgLS1pbnB1dC1maWxlPeKApgpudmNmLWNsaSBmdW5jdGlvbiBpbnZv" + + "a2UgLS1pbnB1dC1maWxlPeKApgoKIyBUYXNrIGNvbW1hbmRzIOKAlCByZXF1aXJlcyBOVkNGX0JB" + + "U0VfTlZDVF9VUkw9aHR0cDovLzxudmN0LWdhdGV3YXk+Cm52Y2YtY2xpIHRhc2sgY3JlYXRlIC0t" + + "bmFtZT1YIC0tZ3B1PUgxMDAgLS1pbnN0YW5jZS10eXBlPVkgLS1pbWFnZT1aCm52Y2YtY2xpIHRh" + + "c2sgY3JlYXRlIC0taW5wdXQtZmlsZT10YXNrLmpzb24gICAjIGZyb20gSlNPTiBjb25maWcKbnZj" + + "Zi1jbGkgdGFzayBsaXN0ICAgICAgICAgICAgICAgICAgICAgICAgICAgICMgbGlzdCBhbGwgdGFz" + + "a3MKbnZjZi1jbGkgdGFzayBsaXN0IC0tc3RhdHVzPVJVTk5JTkcgICAgICAgICAgICMgZmlsdGVy" + + "IGJ5IHN0YXR1cwpudmNmLWNsaSB0YXNrIGdldCBbdGFza0lkXSAgICAgICAgICAgICAgICAgICAg" + + "IyB0YXNrIGRldGFpbHMKbnZjZi1jbGkgdGFzayBldmVudHMgW3Rhc2tJZF0gICAgICAgICAgICAg" + + "ICAgICMgbGlmZWN5Y2xlIGV2ZW50cwpudmNmLWNsaSB0YXNrIHJlc3VsdHMgW3Rhc2tJZF0gICAg" + + "ICAgICAgICAgICAgIyByZXN1bHQgYXJ0aWZhY3RzCm52Y2YtY2xpIHRhc2sgY2FuY2VsIFt0YXNr" + + "SWRdCm52Y2YtY2xpIHRhc2sgZGVsZXRlIFt0YXNrSWRdCmBgYAoKIyMgRmVlZGJhY2sKCklmIHRo" + + "ZSB1c2VyIGhpdHMgYSBidWcgb3IgbGltaXRhdGlvbiwgZmlsZSBhbiBpc3N1ZSB0aHJvdWdoIHRo" + + "ZSBwcm9qZWN0IHRyYWNrZXIuIERvbid0IGluY2x1ZGUgc2VjcmV0cy4KUEsHCM2BMORNYQAATWEA" + + "AFBLAwQUAAgAAAAAACEAAAAAAAAAAAAAAAAAMwAJAGRhdGEvbnZjZi1zZWxmLW1hbmFnZWQtY2xp" + + "L2V4YW1wbGVzL2NpLXBpcGVsaW5lcy5tZFVUBQABAKbOEiMgQ0kgcGlwZWxpbmUgcGF0dGVybnMK" + + "CkhvdyB0byBkcml2ZSBgbnZjZi1jbGlgIGZyb20gQ0kgKEdpdExhYiBDSSwgR2l0SHViIEFjdGlv" + + "bnMsIEplbmtpbnMsIEFyZ29DRCkuIFBhdHRlcm5zIHRoYXQgc3VyZmFjZSBmcmVxdWVudGx5LgoK" + + "IyMgQmFzaWMgaW5zdGFsbCBwaXBlbGluZQoKYGBgeWFtbAojIEdpdExhYiBDSSBleGFtcGxlCmRl" + + "cGxveV9udmNmOgogIHN0YWdlOiBkZXBsb3kKICBpbWFnZTogbnZjci5pby8wNjUxMTU1MjE1ODY0" + + "OTc5L25jcC1kZXYvbnZjZi1jbGk6MS40LjAKICB2YXJpYWJsZXM6CiAgICBLVUJFQ09ORklHOiAk" + + "S1VCRUNPTkZJR19GSUxFCiAgc2NyaXB0OgogICAgLSBudmNmLWNsaSBzZWxmLWhvc3RlZCBjaGVj" + + "ayAtLXByZSAtLWpzb24gfCBqcSAtZSAnLmV2ZW50ICE9ICJwaGFzZV9mYWlsZWQiJyB8fCBleGl0" + + "IDIKICAgIC0gbnZjZi1jbGkgc2VsZi1ob3N0ZWQgdXAgLS1jbHVzdGVyLW5hbWU9JENMVVNURVJf" + + "TkFNRSAtLXRva2VuPSROVkNGX0FETUlOX0pXVCAtLW5vbi1pbnRlcmFjdGl2ZSAtLWpzb24KICAg" + + "IC0gbnZjZi1jbGkgc2VsZi1ob3N0ZWQgc3RhdHVzIC0tanNvbiB8IGpxIC1lICcudmVyZGljdCA9" + + "PSAiaGVhbHRoeSInCmBgYAoKTm90ZXM6Ci0gYC0tbm9uLWludGVyYWN0aXZlIC0tdG9rZW49JEpX" + + "VGAgaXMgcmVxdWlyZWQgaW4gQ0k7IG5ldmVyIHVzZSBpbnRlcmFjdGl2ZSBgaW5pdGAuCi0gQWx3" + + "YXlzIGAtLWpzb25gIGZvciBtYWNoaW5lLXBhcnNpbmcuCi0gRmluYWwgc3RhdHVzIGNoZWNrIGdh" + + "dGVzIGRvd25zdHJlYW0gc3RhZ2VzIG9uIGB2ZXJkaWN0ID09ICJoZWFsdGh5ImAuCgojIyBHaXRP" + + "cHMgKEFyZ28gLyBGbHV4KSBwYXR0ZXJuCgpDSSBkb2Vzbid0IGBrdWJlY3RsIGFwcGx5YCDigJQg" + + "aW5zdGVhZCwgcmVuZGVyIG1hbmlmZXN0cywgY29tbWl0IHRoZW0sIGxldCB0aGUgY29udHJvbGxl" + + "ciBhcHBseS4KCmBgYHlhbWwKcmVuZGVyOgogIHNjcmlwdDoKICAgIC0gbnZjZi1jbGkgc2VsZi1o" + + "b3N0ZWQgaW5zdGFsbCAtLWNvbnRyb2wtcGxhbmUgLS1uby1hcHBseSA+IHJlbmRlcmVkL2NvbnRy" + + "b2wtcGxhbmUueWFtbAogICAgLSBudmNmLWNsaSBzZWxmLWhvc3RlZCBpbnN0YWxsIC0tY29tcHV0" + + "ZS1wbGFuZSAtLWNsdXN0ZXItbmFtZT0kTkFNRSAtLW5vLWFwcGx5ID4gcmVuZGVyZWQvY29tcHV0" + + "ZS1wbGFuZS55YW1sCiAgICAtIGdpdCBhZGQgcmVuZGVyZWQvICYmIGdpdCBjb21taXQgLW0gImRl" + + "cGxveSBOVkNGICRUQUciICYmIGdpdCBwdXNoCmBgYAoKVGhlbiBBcmdvQ0Qgb3IgRmx1eCB3YXRj" + + "aGVzIGByZW5kZXJlZC9gIGFuZCBhcHBsaWVzLiBUaGUgQ0xJIG5ldmVyIHRvdWNoZXMgdGhlIGNs" + + "dXN0ZXIgZGlyZWN0bHkuCgpGb3IgdGhlIHJlZ2lzdGVyIHN0ZXAgKHdoaWNoIG11dGF0ZXMgSUNN" + + "Uywgbm90IGp1c3QgSzhzKToKCmBgYHlhbWwKcmVnaXN0ZXI6CiAgc2NyaXB0OgogICAgLSBudmNm" + + "LWNsaSBjbHVzdGVyIHJlZ2lzdGVyIC0tbmFtZT0kTkFNRSAtLW5jYS1pZD0kTkNBIC0tcmVnaW9u" + + "PSRSRUdJT04gLS1pZ25vcmUtZXhpc3RpbmcKYGBgCgpgLS1pZ25vcmUtZXhpc3RpbmdgIGlzIHRo" + + "ZSBHaXRPcHMtZnJpZW5kbHkgaWRlbXBvdGVudCBjb250cmFjdC4KCiMjIE11bHRpLWNsdXN0ZXIg" + + "cGlwZWxpbmUKCldoZW4gdGhlIHBpcGVsaW5lIG1hbmFnZXMgbWFueSBjb21wdXRlIGNsdXN0ZXJz" + + "IGFnYWluc3Qgb25lIGNvbnRyb2wgcGxhbmU6CgpgYGB5YW1sCmRlcGxveV9jb21wdXRlX3BsYW5l" + + "czoKICBwYXJhbGxlbDoKICAgIG1hdHJpeDoKICAgICAgLSBDTFVTVEVSOiBuY3AtZWFzdC0xCiAg" + + "ICAgICAgQ09OVEVYVDogYWRtaW5AZ3B1LWVhc3QtMQogICAgICAtIENMVVNURVI6IG5jcC13ZXN0" + + "LTEKICAgICAgICBDT05URVhUOiBhZG1pbkBncHUtd2VzdC0xCiAgICAgIC0gQ0xVU1RFUjogbmNw" + + "LWV1LTEKICAgICAgICBDT05URVhUOiBhZG1pbkBncHUtZXUtMQogIHNjcmlwdDoKICAgIC0gbnZj" + + "Zi1jbGkgc2VsZi1ob3N0ZWQgdXAKICAgICAgICAtLWNsdXN0ZXItbmFtZT0kQ0xVU1RFUgogICAg" + + "ICAgIC0tY29tcHV0ZS1wbGFuZS1jb250ZXh0PSRDT05URVhUCiAgICAgICAgLS1pY21zLXVybD0k" + + "SUNNU19QVUJMSUNfVVJMCiAgICAgICAgLS10b2tlbj0kTlZDRl9BRE1JTl9KV1QKICAgICAgICAt" + + "LW5vbi1pbnRlcmFjdGl2ZQogICAgICAgIC0tanNvbgpgYGAKCkVhY2ggcGFyYWxsZWwgam9iIHJl" + + "Z2lzdGVycyArIGluc3RhbGxzIG9uZSBjb21wdXRlIHBsYW5lIGFnYWluc3QgdGhlIHNoYXJlZCBj" + + "b250cm9sIHBsYW5lLiBGYWlsdXJlcyBhcmUgaXNvbGF0ZWQuCgojIyBQbGFuLW9ubHkgcHJldmll" + + "dyBpbiBQUnMKCmBgYHlhbWwKcHJldmlldzoKICBydWxlczoKICAgIC0gaWY6ICRDSV9QSVBFTElO" + + "RV9TT1VSQ0UgPT0gIm1lcmdlX3JlcXVlc3RfZXZlbnQiCiAgc2NyaXB0OgogICAgLSB8CiAgICAg" + + "IG52Y2YtY2xpIHNlbGYtaG9zdGVkIHVwIFwKICAgICAgICAtLWNsdXN0ZXItbmFtZT0kQ0xVU1RF" + + "Ul9OQU1FIFwKICAgICAgICAtLXBsYW4tb25seSBcCiAgICAgICAgLS1qc29uIHwgdGVlIHBsYW4u" + + "anNvbmwKICAgIC0ganEgLXMgJy5bMF0nIHBsYW4uanNvbmwgPiBwbGFuLmpzb24KICAgIC0gJ2dp" + + "dGxhYi1tci1jb21tZW50ICIjIyBOVkNGIGRlcGxveSBwbGFuXG5cblxgXGBcYGpzb25cbiQoY2F0" + + "IHBsYW4uanNvbilcblxgXGBcYCInCmBgYAoKYC0tcGxhbi1vbmx5YCBleGl0cyAwIHdpdGhvdXQg" + + "Y2hhbmdpbmcgY2x1c3RlciBzdGF0ZTsgdGhlIEpTT05MIG91dHB1dCBsaXN0cyBlYWNoIHBoYXNl" + + "ICsgRVRBLiBSZW5kZXJzIG5pY2VseSBhcyBhbiBNUiBjb21tZW50LgpQSwcIIcbIhvAKAADwCgAA" + + "UEsDBBQACAAAAAAAIQAAAAAAAAAAAAAAAAA0AAkAZGF0YS9udmNmLXNlbGYtbWFuYWdlZC1jbGkv" + + "ZXhhbXBsZXMvbXVsdGktY2x1c3Rlci5tZFVUBQABAKbOEiMgTXVsdGktY2x1c3RlciBwYXR0ZXJu" + + "cwoKRXhhbXBsZXMgb2Ygc3BsaXQtY2x1c3RlciArIG1hbnktY29tcHV0ZS1wbGFuZSBvcGVyYXRp" + + "b24uCgojIyBPbmUgY29udHJvbCBwbGFuZSArIE4gY29tcHV0ZSBwbGFuZXMKClRoZSBjYW5vbmlj" + + "YWwgbXVsdGktY2x1c3RlciB0b3BvbG9neS4gRWFjaCBjb21wdXRlIHBsYW5lIGlzIHJlZ2lzdGVy" + + "ZWQgc2VwYXJhdGVseToKCmBgYHNoCiMgMS4gQnJpbmcgdXAgdGhlIGNvbnRyb2wgcGxhbmUgKG9u" + + "ZS10aW1lLCBvbiB0aGUgY29udHJvbC1wbGFuZSBjbHVzdGVyKToKS1VCRUNPTkZJRz1jcC55YW1s" + + "IG52Y2YtY2xpIHNlbGYtaG9zdGVkIGluc3RhbGwgLS1jb250cm9sLXBsYW5lIHwga3ViZWN0bCBh" + + "cHBseSAtZiAtCm52Y2YtY2xpIHNlbGYtaG9zdGVkIGNoZWNrIC0tY29udHJvbC1wbGFuZSAtLXdh" + + "aXQgNW0KCiMgMi4gUmVnaXN0ZXIgKyBpbnN0YWxsIGVhY2ggY29tcHV0ZSBwbGFuZToKZm9yIENU" + + "WCBpbiBhZG1pbkBncHUtZWFzdC0xIGFkbWluQGdwdS13ZXN0LTEgYWRtaW5AZ3B1LWV1LTE7IGRv" + + "CiAgTkFNRT0kKGVjaG8gIiRDVFgiIHwgY3V0IC1kQCAtZjIpCiAgbnZjZi1jbGkgc2VsZi1ob3N0" + + "ZWQgdXAgXAogICAgLS1jbHVzdGVyLW5hbWU9JE5BTUUgXAogICAgLS1jb21wdXRlLXBsYW5lLWNv" + + "bnRleHQ9JENUWCBcCiAgICAtLWljbXMtdXJsPWh0dHBzOi8vaWNtcy5udmNmLmV4YW1wbGUuY29t" + + "IFwKICAgIC0tdG9rZW49JE5WQ0ZfQURNSU5fSldUIFwKICAgIC0tbm9uLWludGVyYWN0aXZlIFwK" + + "ICAgIC0tanNvbgpkb25lCgojIDMuIFZlcmlmeSBhbGwgY29tcHV0ZSBwbGFuZXMgcmVnaXN0ZXJl" + + "ZDoKbnZjZi1jbGkgY2x1c3RlciBsaXN0LXJlZ2lzdGVyZWQgLS1uY2EtaWQ9JE5DQV9JRCAtLWlj" + + "bXMtdXJsPSRJQ01TIC0tanNvbiBcCiAgfCBqcSAnLmNsdXN0ZXJzW10gfCB7bmFtZTogLmNsdXN0" + + "ZXJOYW1lLCBzdGF0dXMsIG52Y2FWZXJzaW9ufScKYGBgCgojIyBDb21wdXRlLXBsYW5lLW9ubHkg" + + "b3BlcmF0b3Igc2NlbmFyaW8KClRoZSBvcGVyYXRvciBoYXMga3ViZWN0bCBhY2Nlc3MgdG8gT05F" + + "IGNvbXB1dGUgcGxhbmUgb25seSDigJQgdGhlIGNvbnRyb2wgcGxhbmUgaXMgb3BlcmF0ZWQgYnkg" + + "c29tZW9uZSBlbHNlIChlLmcuIFlvdHRhIHJ1bnMgdGhlIGNvbnRyb2wgcGxhbmUgZm9yIGEgY3Vz" + + "dG9tZXIpLgoKYGBgc2gKIyBNaW50IGEgdG9rZW4gdmlhIHRoZSBwdWJsaWMgYXBpIGdhdGV3YXkg" + + "KHRoZSBjb250cm9sIHBsYW5lJ3MgQVBJIEtleXMKIyBzZXJ2aWNlIGlzIHJlYWNoYWJsZSB2aWEg" + + "YXBpLm52Y2YuZXhhbXBsZS5jb20g4oCUIG5vIGt1YmVjdGwgYWNjZXNzIG5lZWRlZCk6Cm52Y2Yt" + + "Y2xpIGluaXQgLS1hcGktdXJsPWh0dHBzOi8vYXBpLm52Y2YuZXhhbXBsZS5jb20KCiMgUnVuIHBy" + + "ZS1mbGlnaHQgc2NvcGVkIHRvIHRoZSBjb21wdXRlIHBsYW5lIG9ubHk6Cm52Y2YtY2xpIHNlbGYt" + + "aG9zdGVkIGNoZWNrIC0tcHJlIFwKICAtLWNvbXB1dGUtcGxhbmUtY29udGV4dD1hZG1pbkBncHUx" + + "IFwKICAtLWljbXMtdXJsPWh0dHBzOi8vaWNtcy5udmNmLmV4YW1wbGUuY29tIFwKICAtLWpzb24K" + + "CiMgQnJpbmcgdXAganVzdCB0aGUgY29tcHV0ZSBwbGFuZToKbnZjZi1jbGkgc2VsZi1ob3N0ZWQg" + + "dXAgXAogIC0tY2x1c3Rlci1uYW1lPW15LWNvbXB1dGUtMSBcCiAgLS1jb21wdXRlLXBsYW5lLWNv" + + "bnRleHQ9YWRtaW5AZ3B1MSBcCiAgLS1pY21zLXVybD1odHRwczovL2ljbXMubnZjZi5leGFtcGxl" + + "LmNvbSBcCiAgLS10b2tlbj0kQURNSU5fSldUIFwKICAtLW5vbi1pbnRlcmFjdGl2ZQoKIyBTdGF0" + + "dXMgKGNvbXB1dGUtb25seSDigJQgb3BlcmF0b3IgY2FuJ3Qgc2VlIGNvbnRyb2wtcGxhbmUgY29t" + + "cG9uZW50IGhlYWx0aCk6Cm52Y2YtY2xpIHNlbGYtaG9zdGVkIHN0YXR1cyBcCiAgLS1jb21wdXRl" + + "LXBsYW5lLWNvbnRleHQ9YWRtaW5AZ3B1MSBcCiAgLS1pY21zLXVybD1odHRwczovL2ljbXMubnZj" + + "Zi5leGFtcGxlLmNvbQpgYGAKCiMjIEZ1bmN0aW9ucyB0YXJnZXRpbmcgc3BlY2lmaWMgY29tcHV0" + + "ZSBwbGFuZXMKCldoZW4geW91IGhhdmUgbXVsdGlwbGUgY29tcHV0ZSBwbGFuZXMgYW5kIHdhbnQg" + + "YSBmdW5jdGlvbiB0byBkZXBsb3kgdG8gb25lOgoKYGBganNvbgp7CiAgImZ1bmN0aW9uSWQiOiAi" + + "PGZuX2lkPiIsCiAgInZlcnNpb25JZCI6ICI8dmVyX2lkPiIsCiAgImRlcGxveW1lbnRTcGVjaWZp" + + "Y2F0aW9ucyI6IFt7CiAgICAiZ3B1IjogIkgxMDAiLAogICAgImluc3RhbmNlVHlwZSI6ICJOQ1Au" + + "R1BVLkgxMDBfMXgiLAogICAgIm1pbkluc3RhbmNlcyI6IDEsCiAgICAibWF4SW5zdGFuY2VzIjog" + + "MSwKICAgICJjbHVzdGVycyI6IFsiZ3B1LWVhc3QtMSJdCiAgfV0KfQpgYGAKClRoZSBgY2x1c3Rl" + + "cnNgIGFycmF5ICh1c2luZyBjbHVzdGVyIG5hbWVzLCBub3QgSURzKSBsaW1pdHMgc2NoZWR1bGlu" + + "ZyB0byB0aG9zZSBjb21wdXRlIHBsYW5lcy4gT21pdCB0byBsZXQgSUNNUyBjaG9vc2UgYW55IGNv" + + "bXB1dGUgcGxhbmUgd2l0aCBhIG1hdGNoaW5nIFNLVS4KCiMjIFN0YXR1cyBmYW4tb3V0IGFjcm9z" + + "cyBjb21wdXRlIHBsYW5lcwoKYGBgc2gKIyBMaXN0IGFsbCByZWdpc3RlcmVkIGNvbXB1dGUgcGxh" + + "bmVzOgpudmNmLWNsaSBjbHVzdGVyIGxpc3QtcmVnaXN0ZXJlZCAtLW5jYS1pZD0kTkNBX0lEIC0t" + + "aWNtcy11cmw9JElDTVMgLS1qc29uIFwKICB8IGpxIC1yICcuY2x1c3RlcnNbXS5jbHVzdGVyTmFt" + + "ZScgPiBjbHVzdGVycy50eHQKCiMgU3RhdHVzIHNuYXBzaG90IHBlciBjb21wdXRlIHBsYW5lIChh" + + "c3N1bWluZyBlYWNoIGNvbnRleHQgbmFtZSBtYXRjaGVzKToKd2hpbGUgcmVhZCBOQU1FOyBkbwog" + + "IGVjaG8gIj09PSAkTkFNRSA9PT0iCiAgbnZjZi1jbGkgc2VsZi1ob3N0ZWQgc3RhdHVzIFwKICAg" + + "IC0tY2x1c3Rlci1uYW1lPSROQU1FIFwKICAgIC0tY29tcHV0ZS1wbGFuZS1jb250ZXh0PWFkbWlu" + + "QCROQU1FIFwKICAgIC0tanNvbiB8IGpxIC1jICd7Y2x1c3RlcjouY2x1c3RlciwgdmVyZGljdDou" + + "dmVyZGljdCwgcmVjb25jaWxlOi5yZWNvbmNpbGVBZ2VTZWN9Jwpkb25lIDwgY2x1c3RlcnMudHh0" + + "CmBgYAoKQSBmdXR1cmUgTSsxMSBtaWxlc3RvbmUgd2lsbCBhZGQgbmF0aXZlIGZhbi1vdXQgKGBz" + + "dGF0dXMgLS1hbGwtY29tcHV0ZS1wbGFuZXNgKSBzbyB0aGlzIGRvZXNuJ3QgbmVlZCBhIHNoZWxs" + + "IGxvb3AuClBLBwihFOOBXQwAAF0MAABQSwMEFAAIAAAAAAAhAAAAAAAAAAAAAAAAADcACQBkYXRh" + + "L252Y2Ytc2VsZi1tYW5hZ2VkLWNsaS9wcm9tcHRzL2FkZC1jb21wdXRlLXBsYW5lLm1kVVQFAAEA" + + "ps4SIyBBZGQgYSBjb21wdXRlIHBsYW5lIHRvIGFuIGV4aXN0aW5nIGNvbnRyb2wgcGxhbmUKClVz" + + "ZXIgaGFzIGEgd29ya2luZyBOVkNGIGNvbnRyb2wgcGxhbmUgKHJ1bm5pbmcgc29tZXdoZXJlKSBh" + + "bmQgd2FudHMgdG8gcmVnaXN0ZXIgYSBuZXcgR1BVIGNsdXN0ZXIgYWdhaW5zdCBpdC4gVGhpcyBp" + + "cyB0aGUgbXVsdGktY2x1c3RlciBzY2FsaW5nIHBhdGg6IG9uZSBjb250cm9sIHBsYW5lIOKGkiBO" + + "IGNvbXB1dGUgcGxhbmVzLgoKIyMgUHJlcmVxdWlzaXRlcyB0aGUgdXNlciBtdXN0IGhhdmUKCi0g" + + "KiprdWJlY3RsIGNvbnRleHQgZm9yIHRoZSBuZXcgY29tcHV0ZSBwbGFuZSoqIGluIHRoZWlyIGBL" + + "VUJFQ09ORklHYC4KLSAqKlB1YmxpYyBJQ01TIFVSTCoqIG9mIHRoZSBleGlzdGluZyBjb250cm9s" + + "IHBsYW5lIChlLmcuIGBodHRwczovL2ljbXMubnZjZi5leGFtcGxlLmNvbWApLgotICoqQWRtaW4g" + + "SldUKiogZm9yIHRoZSBjb250cm9sIHBsYW5lJ3MgYWNjb3VudCwgT1IgYWJpbGl0eSB0byBtaW50" + + "IG9uZSB2aWEgYG52Y2YtY2xpIGluaXRgIGFnYWluc3QgdGhlIGNvbnRyb2wgcGxhbmUncyBwdWJs" + + "aWMgYXBpIGVuZHBvaW50LiAoQWRtaW4gdG9rZW5zIGNvbWUgZnJvbSB0aGUgQVBJIEtleXMgc2Vy" + + "dmljZSB2aWEgdGhlIHB1YmxpYyBhcGkgZ2F0ZXdheSDigJQga3ViZWN0bCBhY2Nlc3MgdG8gdGhl" + + "IGNvbnRyb2wgcGxhbmUgaXMgTk9UIHJlcXVpcmVkIHRvIG9idGFpbiBvbmUuKQotIEEgdW5pcXVl" + + "IGAtLWNsdXN0ZXItbmFtZWAgdGhhdCBkb2Vzbid0IGNvbGxpZGUgd2l0aCBhbHJlYWR5LXJlZ2lz" + + "dGVyZWQgY2x1c3RlcnMuIFVzZSBgbnZjZi1jbGkgY2x1c3RlciBsaXN0LXJlZ2lzdGVyZWQgLS1u" + + "Y2EtaWQ9JE5DQV9JRCAtLWljbXMtdXJsPSRJQ01TYCB0byBjaGVjay4KCiMjIFN0ZXBzCgoxLiAq" + + "KkFzayBmb3IgaW5wdXRzOioqCiAgIC0gYC0tY2x1c3Rlci1uYW1lPTx1bmlxdWU+YCDigJQgbXVz" + + "dCBiZSB1bmlxdWUgd2l0aGluIHRoZSBjb250cm9sIHBsYW5lJ3MgTkNBIHNjb3BlCiAgIC0gYC0t" + + "Y29tcHV0ZS1wbGFuZS1jb250ZXh0PTxjb250ZXh0PmAg4oCUIHRoZSBuZXcgR1BVIGNsdXN0ZXIn" + + "cyBrdWJlY3RsIGNvbnRleHQKICAgLSBgLS1pY21zLXVybD08aHR0cHM6Ly9pY21zLm52Y2YuZXhh" + + "bXBsZS5jb20+YCDigJQgY29udHJvbCBwbGFuZSdzIHB1YmxpYyBJQ01TIFVSTAogICAtIEdQVSB0" + + "eXBlPyAoZGVmYXVsdCBgSDEwMGAsIGJ1dCBhc2spCgoyLiAqKlByZS1mbGlnaHQganVzdCB0aGUg" + + "Y29tcHV0ZSBwbGFuZToqKgoKICAgYGBgc2gKICAgbnZjZi1jbGkgc2VsZi1ob3N0ZWQgY2hlY2sg" + + "LS1wcmUgXAogICAgIC0tY29tcHV0ZS1wbGFuZS1jb250ZXh0PSRDVFggXAogICAgIC0taWNtcy11" + + "cmw9JElDTVMgXAogICAgIC0tanNvbiB8IGpxIC1jIC4KICAgYGBgCgogICBUaGlzIHZhbGlkYXRl" + + "cyB0aGUgR1BVIG9wZXJhdG9yIGlzIGluc3RhbGxlZCwgR1BVIG5vZGUgbGFiZWxzIGFyZSBwcmVz" + + "ZW50LCBhbmQgSUNNUyBpcyByZWFjaGFibGUgdmlhIEhUVFAuIEFkZHJlc3MgYW55IGZhaWx1cmVz" + + "IGJlZm9yZSBwcm9jZWVkaW5nLgoKMy4gKipSdW4gYGFkZC1jb21wdXRlLXBsYW5lYDoqKgoKICAg" + + "YGBgc2gKICAgbnZjZi1jbGkgc2VsZi1ob3N0ZWQgYWRkLWNvbXB1dGUtcGxhbmUgXAogICAgIC0t" + + "Y2x1c3Rlci1uYW1lPSROQU1FIFwKICAgICAtLWNvbXB1dGUtcGxhbmUtY29udGV4dD0kQ1RYIFwK" + + "ICAgICAtLWljbXMtdXJsPSRJQ01TIFwKICAgICAtLXRva2VuPSRKV1QgXAogICAgIC0tbm9uLWlu" + + "dGVyYWN0aXZlIFwKICAgICAtLWpzb24KICAgYGBgCgogICBUaGlzIGlzIGEgc2VwYXJhdGUgc3Vi" + + "Y29tbWFuZCBmcm9tIGB1cGAuIEl0IHJ1bnMgb25seSB0aGUgY29tcHV0ZS1wbGFuZS1yZWxldmFu" + + "dCBwaGFzZXM6IDEgKGNvbXB1dGUtcGxhbmUgcHJlZmxpZ2h0KSwgNSAocmVnaXN0ZXIpLCA2IChj" + + "b21wdXRlLXBsYW5lIGFwcGx5KSwgOCAoZmluYWwgaGVhbHRoIG9uIHRoZSBuZXcgY29tcHV0ZSBw" + + "bGFuZSkuIEl0IGRvZXMgTk9UIHRvdWNoIHRoZSBjb250cm9sIHBsYW5lIGFuZCBkb2VzIE5PVCBh" + + "Y2NlcHQgYC0tY29udHJvbC1wbGFuZS1jb250ZXh0YCDigJQgdGhlIGNvbnRyb2wgcGxhbmUgaXMg" + + "cmVhY2hlZCBvdmVyIEhUVFBTIGF0IGAtLWljbXMtdXJsYC4gYC0tdG9rZW5gIGlzIHJlcXVpcmVk" + + "IGJlY2F1c2UgdGhlcmUncyBubyBrdWJlY3RsIHBhdGggdG8gbWludCBvbmUgZnJvbS4KCjQuICoq" + + "VmVyaWZ5LioqIGBudmNmLWNsaSBzZWxmLWhvc3RlZCBzdGF0dXMgLS1jbHVzdGVyLW5hbWU9JE5B" + + "TUUgLS1qc29uIHwganFgIOKAlCBleHBlY3QgYHZlcmRpY3Q6ICJoZWFsdGh5ImAuIFRoZSBSZWdp" + + "c3RlcmVkIENvbXB1dGUgUGxhbmVzIHBhbmVsIGZyb20gSUNNUyBzaG91bGQgbm93IGxpc3QgdGhl" + + "IG5ldyBjbHVzdGVyLgoKNS4gKipTbW9rZS4qKiBbZGVwbG95LWFuZC1pbnZva2UubWRdKGRlcGxv" + + "eS1hbmQtaW52b2tlLm1kKSDigJQgZGVwbG95IGEgc21hbGwgZnVuY3Rpb24gdG8gdGhlIG5ldyBj" + + "b21wdXRlIHBsYW5lIHRvIGNvbmZpcm0gc2NoZWR1bGluZyB3b3Jrcy4KCiMjIFdoYXQgaWYgYSBj" + + "bHVzdGVyIHdpdGggdGhlIHNhbWUgbmFtZSBhbHJlYWR5IGV4aXN0cz8KCmBhZGQtY29tcHV0ZS1w" + + "bGFuZWAncyByZWdpc3RlciBwaGFzZSB1c2VzIGAtLWlnbm9yZS1leGlzdGluZ2Agc2VtYW50aWNz" + + "IOKAlCBpdCdsbCBtYXRjaCB0aGUgZXhpc3RpbmcgSUNNUyByb3cgYW5kIHJldXNlIGl0cyBjbHVz" + + "dGVySWQuIFR3byBzY2VuYXJpb3M6CgotICoqUmUtcmVnaXN0ZXJpbmcgdGhlIHNhbWUgY2x1c3Rl" + + "cioqIChyZS1ydW5uaW5nIG9uIHRoZSBzYW1lIGNvbXB1dGUgcGxhbmUgdGhhdCB3YXMgcHJldmlv" + + "dXNseSByZWdpc3RlcmVkKTogZXhwZWN0ZWQsIG5vLW9wIHNlbWFudGljcy4KLSAqKkRpZmZlcmVu" + + "dCBwaHlzaWNhbCBjbHVzdGVyIGJ1dCBzYW1lIG5hbWUqKjogdGhlIHNlY29uZCBhdHRlbXB0IHdp" + + "bGwgcmV1c2UgdGhlIElDTVMgcm93LCBidXQgdGhlIG5ldyBjb21wdXRlIHBsYW5lJ3MgSldLUyB3" + + "aWxsIGJlIHNpbGVudGx5ICpyZXBsYWNlZCog4oCUIHRoZSBvbGQgY29tcHV0ZSBwbGFuZSdzIE5W" + + "Q0EgYWdlbnQgd2lsbCBzdGFydCBmYWlsaW5nIFBTQVQgYXV0aC4gKipDb25maXJtIHdpdGggdGhl" + + "IHVzZXIqKiB0aGF0IHRoZXkgbWVhbnQgdG8gb3ZlcndyaXRlLgoKV2hlbiBpbiBkb3VidCwgcnVu" + + "IGBudmNmLWNsaSBjbHVzdGVyIGxpc3QtcmVnaXN0ZXJlZCAtLW5jYS1pZD0kTkNBX0lEIC0taWNt" + + "cy11cmw9JElDTVNgIGZpcnN0IGFuZCBhc2sgdGhlIHVzZXIgYmVmb3JlIHByb2NlZWRpbmcgd2l0" + + "aCBhIG5hbWUgdGhhdCBhbHJlYWR5IGV4aXN0cy4KUEsHCEInSQ8FDQAABQ0AAFBLAwQUAAgAAAAA" + + "ACEAAAAAAAAAAAAAAAAAOQAJAGRhdGEvbnZjZi1zZWxmLW1hbmFnZWQtY2xpL3Byb21wdHMvY3Jl" + + "YXRlLWFuZC1ydW4tdGFzay5tZFVUBQABAKbOEiMgQ3JlYXRlIGFuZCBydW4gYSB0YXNrCgpTdGFu" + + "ZGFyZCBmbG93OiBtaW50IEFQSSBrZXlzIC0+IHRhc2sgQ1JFQVRFIC0+IG1vbml0b3IgLT4gcmV0" + + "cmlldmUgcmVzdWx0cyAtPiBjbGVhbnVwLgoKIyMgMS4gTWludCBBUEkga2V5cwoKVGhlIGFkbWlu" + + "IHRva2VuIGZyb20gYGluaXRgIGRvZXMgbm90IGNhcnJ5IHRhc2sgaW52b2NhdGlvbiBzY29wZS4g" + + "R2VuZXJhdGUgQVBJIGtleXM6CgpgYGBzaApudmNmLWNsaSBhcGkta2V5IGdlbmVyYXRlIC0tZGVz" + + "Y3JpcHRpb249InRhc2sgc21va2UgdGVzdCIgLS1leHBpcmVzLWluPThoCiMgLT4gZnVuY3Rpb24g" + + "a2V5OiBudmFwaS0uLi4KIyAtPiB0YXNrIGtleTogbnZhcGktLi4uCmBgYAoKQm90aCBrZXlzIGFy" + + "ZSBzYXZlZCB0byBDTEkgc3RhdGUuIFRvIG1pbnQgb25seSB0aGUgdGFzayBrZXk6CgpgYGBzaApu" + + "dmNmLWNsaSBhcGkta2V5IGdlbmVyYXRlIC0tZm9yIHRhc2sgLS1kZXNjcmlwdGlvbj0idGFzayBz" + + "bW9rZSB0ZXN0IiAtLWV4cGlyZXMtaW49OGgKYGBgCgpUbyB2YWxpZGF0ZSBlYWNoIGtleSBpbW1l" + + "ZGlhdGVseSBhZnRlciBtaW50aW5nOgoKYGBgc2gKbnZjZi1jbGkgYXBpLWtleSBnZW5lcmF0ZSAt" + + "LWRlc2NyaXB0aW9uPSJ0YXNrIHNtb2tlIHRlc3QiIC0tZXhwaXJlcy1pbj04aCAtLXZhbGlkYXRl" + + "CiMgLT4gZnVuY3Rpb24gQVBJIGtleSB2YWxpZGF0aW9uIHBhc3NlZCEKIyAtPiB0YXNrIEFQSSBr" + + "ZXkgdmFsaWRhdGlvbiBwYXNzZWQhCmBgYAoKTmV2ZXIgZWNobyB0aGUga2V5IHZhbHVlIChudmFw" + + "aS0uLi4pIGludG8gY2hhdCBvciBsb2dzLiBSZXBvcnQgb25seSB0aGF0IHRoZSBrZXkgd2FzIG1p" + + "bnRlZCwgaXRzIGRlc2NyaXB0aW9uLCBhbmQgaXRzIGV4cGlyeSDigJQgbmV2ZXIgdGhlIHZhbHVl" + + "IGl0c2VsZi4KCiMjIyBGcmVzaCBzZXNzaW9uIHByZS1mbGlnaHQKCkJlZm9yZSBydW5uaW5nIGFu" + + "eSBgdGFza2AgY29tbWFuZCBpbiBhIGZyZXNoIGFnZW50IHNlc3Npb24sIHZlcmlmeSBjcmVkZW50" + + "aWFsczoKCjEuIENoZWNrIHdoZXRoZXIgYE5WQ0ZfQVBJX0tFWWAgaXMgc2V0OgogICBgYGBzaAog" + + "ICBwcmludGVudiBOVkNGX0FQSV9LRVkgPiAvZGV2L251bGwgMj4mMSAmJiBlY2hvIHNldCB8fCBl" + + "Y2hvIHVuc2V0CiAgIGBgYAoyLiBJZiB1bnNldCwgcmVhZCB0aGUgc3RvcmVkIGtleSBleHBpcnkg" + + "d2l0aG91dCBwcmludGluZyB0aGUgdmFsdWU6CiAgIGBgYHNoCiAgIHB5dGhvbjMgLWMgImltcG9y" + + "dCBqc29uLHBhdGhsaWI7IHM9anNvbi5sb2FkcyhwYXRobGliLlBhdGgoJ34vLm52Y2YtY2xpLnN0" + + "YXRlJykuZXhwYW5kdXNlcigpLnJlYWRfdGV4dCgpKTsgcHJpbnQocy5nZXQoJ252Y3RBcGlLZXlF" + + "eHBpcmF0aW9uJywnbWlzc2luZycpKSIKICAgYGBgCjMuIElmIHRoZSBleHBpcnkgaXMgaW4gdGhl" + + "IHBhc3Qgb3IgbWlzc2luZywgcmVnZW5lcmF0ZToKICAgYGBgc2gKICAgbnZjZi1jbGkgcmVmcmVz" + + "aAogICBudmNmLWNsaSBhcGkta2V5IGdlbmVyYXRlIC0tZm9yIHRhc2sgLS1kZXNjcmlwdGlvbj0i" + + "dGFzay1rZXkiIC0tZXhwaXJlcy1pbj0yNGggLS12YWxpZGF0ZQogICBgYGAKNC4gSW5qZWN0IHRo" + + "ZSBzdG9yZWQga2V5IGludG8gdGhlIHN1YnByb2Nlc3MgZW52IHdpdGhvdXQgbG9nZ2luZyB0aGUg" + + "dmFsdWUuIFVzZSBhIHNoZWxsIHN1YnNoZWxsIG9yIGVudiBwcmVmaXgg4oCUIG5ldmVyIHByaW50" + + "IHRoZSBrZXkgaW50byBjaGF0LgoKRXJyb3IgY2xhc3NpZmljYXRpb246Ci0gIm1pc3NpbmcgYXV0" + + "aGVudGljYXRpb24gY3JlZGVudGlhbHMiIG9yIGV4aXQgMjoga2V5IG5vdCBpbmplY3RlZDsgcmVw" + + "ZWF0IHByZS1mbGlnaHQuCi0gSFRUUCA0MDM6IGtleSBleHBpcmVkIG9yIHdyb25nIGF1ZGllbmNl" + + "OyByZWdlbmVyYXRlLgotIEVtcHR5IHRhc2sgbGlzdDogdmFsaWQ7IG5vIHRhc2tzIGV4aXN0IHll" + + "dC4KCiMjIDIuIFRhc2sgQ1JFQVRFOiBjb250YWluZXIKCkRlZmluZSB0aGUgdGFzayBpbiBhIEpT" + + "T04gZmlsZS4gTWluaW11bSB2aWFibGUgY29udGFpbmVyIHRhc2s6CgpgYGBqc29uCnsKICAibmFt" + + "ZSI6ICJzbW9rZS1jb250YWluZXItdGFzayIsCiAgImdwdVNwZWNpZmljYXRpb24iOiB7CiAgICAi" + + "Z3B1IjogIkgxMDAiLAogICAgImluc3RhbmNlVHlwZSI6ICJOQ1AuR1BVLkgxMDBfMXgiLAogICAg" + + "ImJhY2tlbmQiOiAibmNwLWxvY2FsIgogIH0sCiAgImNvbnRhaW5lckltYWdlIjogIm52Y3IuaW8v" + + "bnZpZGlhL25lbW86bGF0ZXN0IiwKICAiY29udGFpbmVyQXJncyI6ICJweXRob24gLWMgXCJwcmlu" + + "dCgnaGVsbG8gZnJvbSB0YXNrJylcIiIsCiAgInJlc3VsdEhhbmRsaW5nU3RyYXRlZ3kiOiAiTk9O" + + "RSIKfQpgYGAKCmBgYHNoCm52Y2YtY2xpIHRhc2sgY3JlYXRlIC0taW5wdXQtZmlsZT10YXNrLWNv" + + "bnRhaW5lci5qc29uCiMgLT4gVGFzayBJRDogPHRhc2tfaWQ+CmBgYAoKQ2FwdHVyZSB0aGUgdGFz" + + "ayBJRCBmcm9tIHRoZSBvdXRwdXQuIFN0YXRlIHBlcnNpc3RlbmNlIGNhbiBmYWlsIHNpbGVudGx5" + + "LCBzbyBwYXNzCmA8dGFza0lkPmAgZXhwbGljaXRseSBvbiBzdWJzZXF1ZW50IGNvbW1hbmRzIHJh" + + "dGhlciB0aGFuIHJlbHlpbmcgb24gc2F2ZWQgc3RhdGUuCgpFcXVpdmFsZW50IENMSSBmbGFncyBm" + + "b3JtIGZvciBxdWljayBhZC1ob2MgcnVuczoKCmBgYHNoCm52Y2YtY2xpIHRhc2sgY3JlYXRlIFwK" + + "ICAtLW5hbWU9c21va2UtY29udGFpbmVyLXRhc2sgXAogIC0tZ3B1PUgxMDAgXAogIC0taW5zdGFu" + + "Y2UtdHlwZT1OQ1AuR1BVLkgxMDBfMXggXAogIC0tYmFja2VuZD1uY3AtbG9jYWwgXAogIC0taW1h" + + "Z2U9bnZjci5pby9udmlkaWEvbmVtbzpsYXRlc3QgXAogIC0tY29udGFpbmVyLWFyZ3M9InB5dGhv" + + "biAtYyAncHJpbnQoaGVsbG8gZnJvbSB0YXNrKSciIFwKICAtLXJlc3VsdC1zdHJhdGVneT1OT05F" + + "CmBgYAoKVG8gdGFyZ2V0IGEgc3BlY2lmaWMgY29tcHV0ZSBjbHVzdGVyOgoKYGBgc2gKbnZjZi1j" + + "bGkgdGFzayBjcmVhdGUgLS1pbnB1dC1maWxlPXRhc2stY29udGFpbmVyLmpzb24gLS1jbHVzdGVy" + + "cz1teS1jbHVzdGVyCmBgYAoKVG8gaW5qZWN0IGVudmlyb25tZW50IHZhcmlhYmxlcyBvciBzZWNy" + + "ZXRzLCBlaXRoZXIgcGFzcyBmbGFnczoKCmBgYHNoCm52Y2YtY2xpIHRhc2sgY3JlYXRlIC0taW5w" + + "dXQtZmlsZT10YXNrLWNvbnRhaW5lci5qc29uIFwKICAtLWNvbnRhaW5lci1lbnYgTVlfRU5WPXZh" + + "bHVlIFwKICAtLXNlY3JldHMgTVlfU0VDUkVUPXMzY3IzdApgYGAKCm9yIHNldCB0aGVtIGluIHRo" + + "ZSBKU09OIGZpbGU6CgpgYGBqc29uCnsKICAiY29udGFpbmVyRW52aXJvbm1lbnQiOiBbCiAgICB7" + + "ImtleSI6ICJNWV9FTlYiLCAidmFsdWUiOiAidmFsdWUifQogIF0sCiAgInNlY3JldHMiOiBbCiAg" + + "ICB7Im5hbWUiOiAiTVlfU0VDUkVUIiwgInZhbHVlIjogInMzY3IzdCJ9CiAgXQp9CmBgYAoKU2Vj" + + "cmV0cyBhcmUgZW5jcnlwdGVkIGF0IHJlc3QgYW5kIG5vdCByZXR1cm5lZCBpbiBsaXN0IG9yIGdl" + + "dCByZXNwb25zZXMgYnkgZGVmYXVsdDsgZG8gbm90IGxvZyB0aGVtLgoKIyMgMy4gVGFzayBDUkVB" + + "VEU6IEhlbG0KCkZvciBIZWxtLXR5cGUgdGFza3MsIHJlcGxhY2UgYGNvbnRhaW5lckltYWdlYCB3" + + "aXRoIGBoZWxtQ2hhcnRgOgoKYGBganNvbgp7CiAgIm5hbWUiOiAic21va2UtaGVsbS10YXNrIiwK" + + "ICAiZ3B1U3BlY2lmaWNhdGlvbiI6IHsKICAgICJncHUiOiAiSDEwMCIsCiAgICAiaW5zdGFuY2VU" + + "eXBlIjogIk5DUC5HUFUuSDEwMF8xeCIsCiAgICAiYmFja2VuZCI6ICJuY3AtbG9jYWwiCiAgfSwK" + + "ICAiaGVsbUNoYXJ0IjogImh0dHBzOi8vaGVsbS5uZ2MubnZpZGlhLmNvbS88b3JnPi9jaGFydHMv" + + "ZXhhbXBsZS10YXNrLTAuMS4wLnRneiIsCiAgInJlc3VsdEhhbmRsaW5nU3RyYXRlZ3kiOiAiTk9O" + + "RSIKfQpgYGAKCmBgYHNoCm52Y2YtY2xpIHRhc2sgY3JlYXRlIC0taW5wdXQtZmlsZT10YXNrLWhl" + + "bG0uanNvbgojIC0+IFRhc2sgSUQ6IDx0YXNrX2lkPgpgYGAKCmBoZWxtQ2hhcnRgIGFuZCBgY29u" + + "dGFpbmVySW1hZ2VgIGFyZSBtdXR1YWxseSBleGNsdXNpdmUuCgojIyAzYi4gVXBkYXRlIHNlY3Jl" + + "dHMgb24gYSBydW5uaW5nIHRhc2sKCmBgYHNoCm52Y2YtY2xpIHRhc2sgdXBkYXRlLXNlY3JldHMg" + + "PHRhc2tfaWQ+IC0tc2VjcmV0cyBOQU1FPXZhbHVlCmBgYAoKYHVwZGF0ZS1zZWNyZXRzYCBtZXJn" + + "ZXMgc2VjcmV0cyBieSBuYW1lOiBzdXBwbGllZCBzZWNyZXRzIGFyZSBhZGRlZCBvciB1cGRhdGVk" + + "LCBhbmQgZXhpc3Rpbmcgc2VjcmV0cyBub3QgaW5jbHVkZWQgaW4gdGhlIHJlcXVlc3QgYXJlIHBy" + + "ZXNlcnZlZC4gRG8gbm90IGVjaG8gc2VjcmV0IHZhbHVlcyBpbnRvIGNoYXQuCgojIyA0LiBNb25p" + + "dG9yCgpQb2xsIHRhc2sgc3RhdGU6CgpgYGBzaApudmNmLWNsaSB0YXNrIGdldCA8dGFza19pZD4K" + + "IyAtPiBpZDogPHRhc2tfaWQ+CiMgLT4gc3RhdHVzOiBSVU5OSU5HCmBgYAoKT3IgdXNlIHRoZSB0" + + "YXNrIElEIHNhdmVkIHRvIHN0YXRlIGZyb20gdGhlIG1vc3QgcmVjZW50IGB0YXNrIGNyZWF0ZWA6" + + "CgpgYGBzaApudmNmLWNsaSB0YXNrIGdldApgYGAKClN0YXR1cyB2YWx1ZXM6IGBRVUVVRURgLCBg" + + "TEFVTkNIRURgLCBgUlVOTklOR2AsIGBDT01QTEVURURgLCBgRVJST1JFRGAsIGBDQU5DRUxFRGAs" + + "IGBFWENFRURFRF9NQVhfUlVOVElNRV9EVVJBVElPTmAsIGBFWENFRURFRF9NQVhfUVVFVUVEX0RV" + + "UkFUSU9OYC4KCkluc3BlY3QgbGlmZWN5Y2xlIGV2ZW50cyBmb3IgcHJvZ3Jlc3MgZGV0YWlscyBv" + + "ciBmYWlsdXJlIGNvbnRleHQ6CgpgYGBzaApudmNmLWNsaSB0YXNrIGV2ZW50cyA8dGFza19pZD4K" + + "YGBgCgpJZiB0aGUgdGFzayBpcyBzdHVjayBpbiBgUVVFVUVEYCwgY2hlY2sgdGhhdCBhIGNvbXB1" + + "dGUgY2x1c3RlciB3aXRoIGEgbWF0Y2hpbmcgR1BVIFNLVQppcyByZWdpc3RlcmVkIGFuZCBoZWFs" + + "dGh5IChgbnZjZi1jbGkgc2VsZi1ob3N0ZWQgc3RhdHVzYCkuCgpJZiB0aGUgdGFzayBtb3ZlcyB0" + + "byBgRVJST1JFRGAsIHRoZSBldmVudHMgb3V0cHV0IGNvbnRhaW5zIHRoZSBmYWlsdXJlIHJlYXNv" + + "bi4gRm9yCmNvbnRhaW5lci1sZXZlbCBkZXRhaWwsIGluc3BlY3QgdGhlIHRhc2sgd29ya2xvYWQg" + + "cG9kcyBvbiB0aGUgY29tcHV0ZS1wbGFuZSBjbHVzdGVyIHdpdGgKYGt1YmVjdGxgIGFnYWluc3Qg" + + "dGhlIGFwcHJvcHJpYXRlIG5hbWVzcGFjZSBhbmQgY29udGV4dC4KCiMjIDUuIFJldHJpZXZlIHJl" + + "c3VsdHMKCkZvciB0YXNrcyB3aXRoIGByZXN1bHRIYW5kbGluZ1N0cmF0ZWd5OiBOT05FYCwgcmVz" + + "dWx0cyBhcmUgZW1wdHkgYnkgZGVzaWduOgoKYGBgc2gKbnZjZi1jbGkgdGFzayByZXN1bHRzIDx0" + + "YXNrX2lkPgojIC0+IHsicmVzdWx0cyI6IFtdfQpgYGAKCkZvciB0YXNrcyB3aXRoIGByZXN1bHRI" + + "YW5kbGluZ1N0cmF0ZWd5OiBVUExPQURgLCByZXN1bHRzIHVwbG9hZCB0byB0aGUgbG9jYXRpb24g" + + "bmFtZWQgaW4KYHJlc3VsdHNMb2NhdGlvbmAuIFRoZSB0YXNrJ3MgY3JlZGVudGlhbHMgbXVzdCBo" + + "YXZlIHdyaXRlIGFjY2VzcyB0byB0aGF0IGxvY2F0aW9uLiBBZnRlcgp0aGUgdGFzayByZWFjaGVz" + + "IGBDT01QTEVURURgOgoKYGBgc2gKbnZjZi1jbGkgdGFzayByZXN1bHRzIDx0YXNrX2lkPgpgYGAK" + + "Ck5vdGU6IHJlc3VsdCB1cGxvYWQgaXMgbm90IHlldCBzdXBwb3J0ZWQgaW4gdGhpcyByZWxlYXNl" + + "LgoKIyMgNi4gQ2xlYW51cAoKQ2FuY2VsIGEgcnVubmluZyB0YXNrOgoKYGBgc2gKbnZjZi1jbGkg" + + "dGFzayBjYW5jZWwgPHRhc2tfaWQ+CmBgYAoKRGVsZXRlIHRoZSB0YXNrIHJlY29yZCBhZnRlciBp" + + "dCByZWFjaGVzIGEgdGVybWluYWwgc3RhdGU6CgpgYGBzaApudmNmLWNsaSB0YXNrIGRlbGV0ZSA8" + + "dGFza19pZD4KYGBgCgpTdG9wIGFuZCBjb25maXJtIHdpdGggdGhlIHVzZXIgYmVmb3JlIHJ1bm5p" + + "bmcgdGFzayBkZWxldGUuIFN0YXRlIHRoZSB0YXNrIElEIGFuZCBpdHMgY3VycmVudCBzdGF0dXMu" + + "IERvIG5vdCBwcm9jZWVkIGV2ZW4gd2hlbiB0aGUgdXNlcidzIHByb21wdCBhbHJlYWR5IHJlcXVl" + + "c3RlZCBkZWxldGlvbiDigJQgYWx3YXlzIGdldCBhbiBleHBsaWNpdCBsYXN0LWxvb2sgY29uZmly" + + "bWF0aW9uLiBEZWxldGlvbiBpcyBwZXJtYW5lbnQgYW5kIGNhbm5vdCBiZSB1bmRvbmUuCgpUbyBs" + + "aXN0IGFsbCB0YXNrcyBmb3IgdGhlIGN1cnJlbnQgb3duZXIgKHVzZWZ1bCBiZWZvcmUgYnVsayBj" + + "bGVhbnVwKToKCmBgYHNoCm52Y2YtY2xpIHRhc2sgbGlzdApudmNmLWNsaSB0YXNrIGxpc3QgLS1z" + + "dGF0dXM9Q09NUExFVEVECmBgYAoKIyMgTm90ZXMKCi0gR1BVIGZhbWlseSBhbmQgaW5zdGFuY2Ug" + + "dHlwZSBtdXN0IG1hdGNoIGEgcmVnaXN0ZXJlZCBjb21wdXRlIGNsdXN0ZXIgU0tVLiBNaXNtYXRj" + + "aAogIGNhdXNlcyB0aGUgdGFzayB0byByZW1haW4gYFFVRVVFRGAgaW5kZWZpbml0ZWx5LiBVc2Ug" + + "YG52Y2YtY2xpIGNsdXN0ZXIgbGlzdGAgdG8gY2hlY2sKICByZWdpc3RlcmVkIFNLVXMuCi0gRm9y" + + "IGNvbnRhaW5lciBpbWFnZXMgb24gcHJpdmF0ZSByZWdpc3RyaWVzLCBlbnN1cmUgdGhlIGNvbXB1" + + "dGUtcGxhbmUgY2x1c3RlcidzCiAgaW1hZ2UtY3JlZGVudGlhbC1oZWxwZXIgaXMgY29uZmlndXJl" + + "ZCBmb3IgdGhlIHJlZ2lzdHJ5IGhvc3QuClBLBwiR3Bv5mBkAAJgZAABQSwMEFAAIAAAAAAAhAAAA" + + "AAAAAAAAAAAAADcACQBkYXRhL252Y2Ytc2VsZi1tYW5hZ2VkLWNsaS9wcm9tcHRzL2RlcGxveS1h" + + "bmQtaW52b2tlLm1kVVQFAAEAps4SIyBEZXBsb3kgYW5kIGludm9rZSBhIGNvbnRhaW5lciBmdW5j" + + "dGlvbgoKU3RhbmRhcmQgZm91ci1zdGVwIGZsb3c6IGZ1bmN0aW9uIENSRUFURSDihpIgREVQTE9Z" + + "IOKGkiBBUEkga2V5IChmb3IgaW52b2tlIHNjb3BlKSDihpIgSU5WT0tFLgoKIyMgMS4gRnVuY3Rp" + + "b24gQ1JFQVRFCgpEZWZpbmUgdGhlIGZ1bmN0aW9uIGluIGEgSlNPTiBmaWxlLiBNaW5pbXVtOgoK" + + "QmVmb3JlIGNyZWF0aW5nIHRoZSBmdW5jdGlvbiwgY29uZmlybSB0aGUgZXhhY3QgZnVuY3Rpb24g" + + "bmFtZSBhbmQgY29udGFpbmVyIGltYWdlIHdpdGggdGhlIHVzZXIuIElmIGVpdGhlciB2YWx1ZSBp" + + "cyBtaXNzaW5nLCBzdG9wIGFuZCBhc2suIERvIG5vdCBpbnZlbnQgb3Igc3VibWl0IGV4YW1wbGUg" + + "dmFsdWVzIGZvciB0aGVzZSBmaWVsZHMuCgpgYGBqc29uCnsKICAibmFtZSI6ICI8Y29uZmlybWVk" + + "LWZ1bmN0aW9uLW5hbWU+IiwKICAiY29udGFpbmVySW1hZ2UiOiAiPGNvbmZpcm1lZC1jb250YWlu" + + "ZXItaW1hZ2U+IiwKICAiaW5mZXJlbmNlVXJsIjogIi9lY2hvIiwKICAiaW5mZXJlbmNlUG9ydCI6" + + "IDgwMDAsCiAgImRlc2NyaXB0aW9uIjogInNtb2tlIHRlc3QgZWNobyBmdW5jdGlvbiIsCiAgImZ1" + + "bmN0aW9uVHlwZSI6ICJERUZBVUxUIiwKICAiYXBpQm9keUZvcm1hdCI6ICJDVVNUT00iLAogICJo" + + "ZWFsdGgiOiB7CiAgICAicHJvdG9jb2wiOiAiSFRUUCIsCiAgICAidXJpIjogIi9oZWFsdGgiLAog" + + "ICAgInBvcnQiOiA4MDAwLAogICAgInRpbWVvdXQiOiAiUFQzMFMiLAogICAgImV4cGVjdGVkU3Rh" + + "dHVzQ29kZSI6IDIwMAogIH0KfQpgYGAKCmBgYHNoCm52Y2YtY2xpIGZ1bmN0aW9uIGNyZWF0ZSAt" + + "LWlucHV0LWZpbGU9Y3JlYXRlLWZuLmpzb24KIyDihpIgRnVuY3Rpb24gSUQ6IDxmbl9pZD4KIyDi" + + "hpIgVmVyc2lvbiBJRDogPHZlcl9pZD4KYGBgCgpTYXZlIHRoZSBJRHMg4oCUIHRoZXkncmUgbmVl" + + "ZGVkIGZvciBkZXBsb3kgKyBpbnZva2UuCgojIyMgTExNIGZ1bmN0aW9uIHZhcmlhbnQKCkZvciBh" + + "biBPcGVuQUktY29tcGF0aWJsZSBMTE0gZnVuY3Rpb24sIHNldCBgZnVuY3Rpb25UeXBlOiAiTExN" + + "ImAgYW5kIHB1dCByb3V0ZSBtZXRhZGF0YSB1bmRlciBgbW9kZWxzW10ubGxtQ29uZmlnYDoKCkJl" + + "Zm9yZSBjcmVhdGluZyB0aGUgZnVuY3Rpb24sIGNvbmZpcm0gdGhlIGV4YWN0IGZ1bmN0aW9uIG5h" + + "bWUsIGNvbnRhaW5lciBpbWFnZSwgYW5kIG1vZGVsIG5hbWUgd2l0aCB0aGUgdXNlci4gSWYgYW55" + + "IHZhbHVlIGlzIG1pc3NpbmcsIHN0b3AgYW5kIGFzay4gRG8gbm90IGludmVudCBvciBzdWJtaXQg" + + "ZXhhbXBsZSB2YWx1ZXMgZm9yIHRoZXNlIGZpZWxkcy4KCmBgYGpzb24KewogICJuYW1lIjogIjxj" + + "b25maXJtZWQtZnVuY3Rpb24tbmFtZT4iLAogICJjb250YWluZXJJbWFnZSI6ICI8Y29uZmlybWVk" + + "LWNvbnRhaW5lci1pbWFnZT4iLAogICJpbmZlcmVuY2VVcmwiOiAiLyIsCiAgImluZmVyZW5jZVBv" + + "cnQiOiA4MDAwLAogICJmdW5jdGlvblR5cGUiOiAiTExNIiwKICAiaGVhbHRoIjogewogICAgInBy" + + "b3RvY29sIjogIkhUVFAiLAogICAgInVyaSI6ICIvaGVhbHRoIiwKICAgICJwb3J0IjogODAwMCwK" + + "ICAgICJ0aW1lb3V0IjogIlBUMzBTIiwKICAgICJleHBlY3RlZFN0YXR1c0NvZGUiOiAyMDAKICB9" + + "LAogICJtb2RlbHMiOiBbCiAgICB7CiAgICAgICJuYW1lIjogIjxjb25maXJtZWQtbW9kZWwtbmFt" + + "ZT4iLAogICAgICAibGxtQ29uZmlnIjogewogICAgICAgICJ1cmlzIjogWyIvdjEvY2hhdC9jb21w" + + "bGV0aW9ucyIsICIvdjEvcmVzcG9uc2VzIiwgIi92MS9lbWJlZGRpbmdzIl0sCiAgICAgICAgInJv" + + "dXRpbmdNZXRob2QiOiAicm91bmRfcm9iaW4iLAogICAgICAgICJ0b2tlblJhdGVMaW1pdCI6ICIx" + + "MDAwLVMiCiAgICAgIH0KICAgIH0KICBdCn0KYGBgCgpFcXVpdmFsZW50IENMSSBmbGFnIGZvcm06" + + "CgpgYGBzaApudmNmLWNsaSBmdW5jdGlvbiBjcmVhdGUgXAogIC0tbmFtZT0iPGNvbmZpcm1lZC1m" + + "dW5jdGlvbi1uYW1lPiIgXAogIC0taW1hZ2U9Ijxjb25maXJtZWQtY29udGFpbmVyLWltYWdlPiIg" + + "XAogIC0taW5mZXJlbmNlLXVybD0vIFwKICAtLWluZmVyZW5jZS1wb3J0PTgwMDAgXAogIC0taGVh" + + "bHRoLXVyaT0vaGVhbHRoIFwKICAtLWhlYWx0aC1wb3J0PTgwMDAgXAogIC0taGVhbHRoLXRpbWVv" + + "dXQ9UFQzMFMgXAogIC0taGVhbHRoLXByb3RvY29sPUhUVFAgXAogIC0taGVhbHRoLWV4cGVjdGVk" + + "LXN0YXR1cz0yMDAgXAogIC0tZnVuY3Rpb24tdHlwZT1MTE0gXAogIC0tbGxtLW1vZGVsPSduYW1l" + + "PTxjb25maXJtZWQtbW9kZWwtbmFtZT4sdXJpcz0vdjEvY2hhdC9jb21wbGV0aW9uc3wvdjEvcmVz" + + "cG9uc2VzfC92MS9lbWJlZGRpbmdzLHJvdXRpbmdNZXRob2Q9cm91bmRfcm9iaW4sdG9rZW5SYXRl" + + "TGltaXQ9MTAwMC1TJwpgYGAKClVzZSB0aGUgc2FtZSBkZXBsb3kgc3RlcCBiZWxvdyBhZnRlciB0" + + "aGUgTExNIGZ1bmN0aW9uIGlzIGNyZWF0ZWQuCgpPcHRpb25hbCBtb2RlbCByb3V0aW5nIHVwZGF0" + + "ZSBhZnRlciBjcmVhdGlvbjoKCmBgYHNoCm52Y2YtY2xpIGZ1bmN0aW9uIHVwZGF0ZSBcCiAgLS1m" + + "dW5jdGlvbi1pZD08Zm5faWQ+IFwKICAtLXZlcnNpb24taWQ9PHZlcl9pZD4gXAogIC0tbGxtLW1v" + + "ZGVsLXVwZGF0ZT0nbmFtZT08Y29uZmlybWVkLW1vZGVsLW5hbWU+LHJvdXRpbmdNZXRob2Q9cG93" + + "ZXJfb2ZfdHdvLHRva2VuUmF0ZUxpbWl0PTEwMDAtUycKYGBgCgpVc2UgdGhpcyBmb3IgbXV0YWJs" + + "ZSBgcm91dGluZ01ldGhvZGAgYW5kIGB0b2tlblJhdGVMaW1pdGA7IGNyZWF0ZS10aW1lIGB1cmlz" + + "YCBzdGF5IGluIGBtb2RlbHNbXS5sbG1Db25maWdgLgpgdG9rZW5SYXRlTGltaXRgIHN1cHBvcnRz" + + "IHBvc2l0aXZlIGludGVnZXIgdG9rZW4gbGltaXRzIGZvciBgU2AsIGBNYCwgYEhgLCBgRGAsIGFu" + + "ZCBgV2AuIFVzZSBgMTAwMC1TYCBmb3IgYSBzaW5nbGUgaW5saW5lIENMSSBsaW1pdC4gVXNlIGlu" + + "cHV0IEpTT04gZm9yIGNvbWJpbmVkIGxpbWl0cywgc3VjaCBhcyBgMTAwMC1TLDUwMDAtTSwxMDAw" + + "MDAtSCw1MDAwMDAtRCwxMDAwMDAwLVdgLCBiZWNhdXNlIGlubGluZSBtb2RlbCBzcGVjcyB1c2Ug" + + "Y29tbWFzIGFzIGZpZWxkIHNlcGFyYXRvcnMuCgojIyMgSGVsbSBjaGFydCBMTE0gZnVuY3Rpb24g" + + "dmFyaWFudAoKTExNIGZ1bmN0aW9uIHR5cGUgaXMgaW5kZXBlbmRlbnQgb2Ygd29ya2xvYWQgcGFj" + + "a2FnaW5nLiBGb3IgYSBIZWxtLWNoYXJ0IGJhY2tlZCBMTE0gZnVuY3Rpb24sIGtlZXAgdGhlIHNh" + + "bWUgYGZ1bmN0aW9uVHlwZWAgYW5kIGBtb2RlbHNbXS5sbG1Db25maWdgIGZpZWxkcywgdGhlbiBz" + + "ZXQgYGhlbG1DaGFydGAgYW5kIGBoZWxtQ2hhcnRTZXJ2aWNlTmFtZWAuIFRoZSBzZXJ2aWNlIG5h" + + "bWUgbXVzdCBtYXRjaCBhIEt1YmVybmV0ZXMgU2VydmljZSByZW5kZXJlZCBieSB0aGUgY2hhcnQs" + + "IGFuZCBgaW5mZXJlbmNlUG9ydGAgbXVzdCBiZSB0aGF0IFNlcnZpY2UgcG9ydC4KCkJlZm9yZSBj" + + "cmVhdGluZyB0aGUgZnVuY3Rpb24sIGNvbmZpcm0gdGhlIGV4YWN0IGZ1bmN0aW9uIG5hbWUgYW5k" + + "IG1vZGVsIG5hbWUgd2l0aCB0aGUgdXNlci4gSWYgZWl0aGVyIHZhbHVlIGlzIG1pc3NpbmcsIHN0" + + "b3AgYW5kIGFzay4gRG8gbm90IGludmVudCBvciBzdWJtaXQgZXhhbXBsZSB2YWx1ZXMgZm9yIHRo" + + "ZXNlIGZpZWxkcy4KCmBgYGpzb24KewogICJuYW1lIjogIjxjb25maXJtZWQtZnVuY3Rpb24tbmFt" + + "ZT4iLAogICJpbmZlcmVuY2VVcmwiOiAiLyIsCiAgImluZmVyZW5jZVBvcnQiOiA4MDAwLAogICJm" + + "dW5jdGlvblR5cGUiOiAiTExNIiwKICAiaGVhbHRoIjogewogICAgInByb3RvY29sIjogIkhUVFAi" + + "LAogICAgInVyaSI6ICIvaGVhbHRoIiwKICAgICJwb3J0IjogODAwMCwKICAgICJ0aW1lb3V0Ijog" + + "IlBUMzBTIiwKICAgICJleHBlY3RlZFN0YXR1c0NvZGUiOiAyMDAKICB9LAogICJoZWxtQ2hhcnQi" + + "OiAiaHR0cHM6Ly9oZWxtLm5nYy5udmlkaWEuY29tL2V4YW1wbGUvdGVhbS9jaGFydHMvb3BlbmFp" + + "LWNvbXBhdGlibGUtMC4xLjAudGd6IiwKICAiaGVsbUNoYXJ0U2VydmljZU5hbWUiOiAib3BlbmFp" + + "LWNvbXBhdGlibGUiLAogICJtb2RlbHMiOiBbCiAgICB7CiAgICAgICJuYW1lIjogIjxjb25maXJt" + + "ZWQtbW9kZWwtbmFtZT4iLAogICAgICAibGxtQ29uZmlnIjogewogICAgICAgICJ1cmlzIjogWyIv" + + "djEvY2hhdC9jb21wbGV0aW9ucyIsICIvdjEvcmVzcG9uc2VzIiwgIi92MS9lbWJlZGRpbmdzIl0s" + + "CiAgICAgICAgInJvdXRpbmdNZXRob2QiOiAicm91bmRfcm9iaW4iLAogICAgICAgICJ0b2tlblJh" + + "dGVMaW1pdCI6ICIxMDAwLVMiCiAgICAgIH0KICAgIH0KICBdCn0KYGBgCgpFcXVpdmFsZW50IENM" + + "SSBmbGFnIGZvcm06CgpgYGBzaApudmNmLWNsaSBmdW5jdGlvbiBjcmVhdGUgXAogIC0tbmFtZT0i" + + "PGNvbmZpcm1lZC1mdW5jdGlvbi1uYW1lPiIgXAogIC0taW5mZXJlbmNlLXVybD0vIFwKICAtLWlu" + + "ZmVyZW5jZS1wb3J0PTgwMDAgXAogIC0taGVhbHRoLXVyaT0vaGVhbHRoIFwKICAtLWhlYWx0aC1w" + + "b3J0PTgwMDAgXAogIC0taGVhbHRoLXRpbWVvdXQ9UFQzMFMgXAogIC0taGVhbHRoLXByb3RvY29s" + + "PUhUVFAgXAogIC0taGVhbHRoLWV4cGVjdGVkLXN0YXR1cz0yMDAgXAogIC0tZnVuY3Rpb24tdHlw" + + "ZT1MTE0gXAogIC0taGVsbS1jaGFydD1odHRwczovL2hlbG0ubmdjLm52aWRpYS5jb20vZXhhbXBs" + + "ZS90ZWFtL2NoYXJ0cy9vcGVuYWktY29tcGF0aWJsZS0wLjEuMC50Z3ogXAogIC0taGVsbS1jaGFy" + + "dC1zZXJ2aWNlPW9wZW5haS1jb21wYXRpYmxlIFwKICAtLWxsbS1tb2RlbD0nbmFtZT08Y29uZmly" + + "bWVkLW1vZGVsLW5hbWU+LHVyaXM9L3YxL2NoYXQvY29tcGxldGlvbnN8L3YxL3Jlc3BvbnNlc3wv" + + "djEvZW1iZWRkaW5ncyxyb3V0aW5nTWV0aG9kPXJvdW5kX3JvYmluLHRva2VuUmF0ZUxpbWl0PTEw" + + "MDAtUycKYGBgCgpEZXBsb3kgaXMgdW5jaGFuZ2VkLiBQdXQgY2hhcnQtc3BlY2lmaWMgdmFsdWVz" + + "IHVuZGVyIGBkZXBsb3ltZW50U3BlY2lmaWNhdGlvbnNbXS5jb25maWd1cmF0aW9uYCBvbmx5IHdo" + + "ZW4gdGhlIGNoYXJ0IG5lZWRzIHZhbHVlIG92ZXJyaWRlczoKCmBgYGpzb24KewogICJmdW5jdGlv" + + "bklkIjogIjxmbl9pZD4iLAogICJ2ZXJzaW9uSWQiOiAiPHZlcl9pZD4iLAogICJkZXBsb3ltZW50" + + "U3BlY2lmaWNhdGlvbnMiOiBbewogICAgImdwdSI6ICJIMTAwIiwKICAgICJpbnN0YW5jZVR5cGUi" + + "OiAiTkNQLkdQVS5IMTAwXzF4IiwKICAgICJtaW5JbnN0YW5jZXMiOiAxLAogICAgIm1heEluc3Rh" + + "bmNlcyI6IDEsCiAgICAibWF4UmVxdWVzdENvbmN1cnJlbmN5IjogMTAsCiAgICAiY29uZmlndXJh" + + "dGlvbiI6IHsKICAgICAgInNlcnZpbmciOiB7CiAgICAgICAgInRlbnNvclBhcmFsbGVsU2l6ZSI6" + + "IDEKICAgICAgfQogICAgfQogIH1dCn0KYGBgCgpMTE0gR2F0ZXdheSByb3V0ZXMgcmVxdWVzdHMg" + + "YnkgdGhlIE9wZW5BSSBgbW9kZWxgIHZhbHVlLiBVc2UgYDxmdW5jdGlvbi1pZD4vPG1vZGVsLW5h" + + "bWU+YDogdGhlIGZ1bmN0aW9uIElEIHNlbGVjdHMgdGhlIE5WQ0YgZnVuY3Rpb24sIGFuZCB0aGUg" + + "bW9kZWwgbmFtZSBpcyBmb3J3YXJkZWQgdG8gdGhlIHVwc3RyZWFtIGNvbnRhaW5lciB0aHJvdWdo" + + "IGBzdGFyZ2F0ZS1jbGllbnRgLgoKU3VwcG9ydGVkIExMTSBwYXRoczoKCnwgUGF0aCB8IE5vdGVz" + + "IHwKfCAtLS0gfCAtLS0gfAp8IGAvdjEvY2hhdC9jb21wbGV0aW9uc2AgfCBTdXBwb3J0cyBzdHJl" + + "YW1pbmcgYW5kIHNlc3Npb24gc3RpY2tpbmVzcy4gfAp8IGAvdjEvcmVzcG9uc2VzYCB8IE5hdGl2" + + "ZSBSZXNwb25zZXMgcHJveHkgcGF0aDsgcmVsYXlzIFNTRSBmb3Igc3RyZWFtaW5nIGNsaWVudHMg" + + "YW5kIHJldHVybnMgdGVybWluYWwgSlNPTiBmb3Igbm9uLXN0cmVhbWluZyBjbGllbnRzLiBTdXBw" + + "b3J0cyBzZXNzaW9uIHN0aWNraW5lc3MuIHwKfCBgL3YxL2VtYmVkZGluZ3NgIHwgQWNjZXB0cyBz" + + "dHJpbmcgb3Igc3RyaW5nLWFycmF5IGBpbnB1dGA7IGlucHV0IG11c3QgYmUgbm9uLWVtcHR5IGFu" + + "ZCBtYXkgY29udGFpbiBhdCBtb3N0IDIwNDggZW50cmllcy4gTm8gc2Vzc2lvbiBzdGlja2luZXNz" + + "LiB8CgojIyAyLiBGdW5jdGlvbiBERVBMT1kKCmBgYGpzb24KewogICJmdW5jdGlvbklkIjogIjxm" + + "bl9pZD4iLAogICJ2ZXJzaW9uSWQiOiAiPHZlcl9pZD4iLAogICJkZXBsb3ltZW50U3BlY2lmaWNh" + + "dGlvbnMiOiBbewogICAgImdwdSI6ICJIMTAwIiwKICAgICJpbnN0YW5jZVR5cGUiOiAiTkNQLkdQ" + + "VS5IMTAwXzF4IiwKICAgICJtaW5JbnN0YW5jZXMiOiAxLAogICAgIm1heEluc3RhbmNlcyI6IDEs" + + "CiAgICAibWF4UmVxdWVzdENvbmN1cnJlbmN5IjogMTAKICB9XQp9CmBgYAoKTm90ZTogYGdwdWAg" + + "aXMgdGhlIEdQVSAqKmZhbWlseSoqIChlLmcuIGBIMTAwYCksIGBpbnN0YW5jZVR5cGVgIGlzIHRo" + + "ZSBTS1UgKGUuZy4gYE5DUC5HUFUuSDEwMF8xeGApLiBNaXNtYXRjaCByZXR1cm5zIElDTVMgNDAw" + + "ICJJbnZhbGlkIEdQVSIuCgpgYGBzaApudmNmLWNsaSBmdW5jdGlvbiBkZXBsb3kgY3JlYXRlIC0t" + + "aW5wdXQtZmlsZT1kZXBsb3ktZm4uanNvbgpgYGAKClRoaXMgY29tbWFuZCAqKmJsb2NrcyoqIHVu" + + "dGlsIHRoZSBkZXBsb3ltZW50IHJlYWNoZXMgQUNUSVZFIChkZWZhdWx0IDkwMHMgdGltZW91dCku" + + "IFdoZW4gaXQgcmV0dXJucyByYz0wLCBhIGZ1bmN0aW9uIHBvZCBpcyBydW5uaW5nIGluIHRoZSBg" + + "bnZjZi1iYWNrZW5kYCBuYW1lc3BhY2Ugb24gdGhlIGNvbXB1dGUtcGxhbmUgY2x1c3Rlci4KCiMj" + + "IDMuIE1pbnQgYW4gQVBJIGtleSB3aXRoIGBpbnZva2VfZnVuY3Rpb25gIHNjb3BlCgpgbnZjZi1j" + + "bGkgaW5pdGAncyBhZG1pbiB0b2tlbiBkb2VzIE5PVCBjYXJyeSB0aGUgYGludm9rZV9mdW5jdGlv" + + "bmAgc2NvcGUg4oCUIGludm9rZSB3b3VsZCA0MDMgd2l0aCAibWlzc2luZyByZXF1ZXN0ZWQgYXV0" + + "aG9yaXRpZXMiLiBNaW50IGFuIEFQSSBrZXk6CgpgYGBzaApudmNmLWNsaSBhcGkta2V5IGdlbmVy" + + "YXRlIC0tZGVzY3JpcHRpb249Ijxjb25maXJtZWQtZnVuY3Rpb24tbmFtZT4gaW52b2tlIiAtLWV4" + + "cGlyZXMtaW49MWgKIyDihpIgQVBJIEtleTogbnZhcGktbnZjZi1zdGctLi4uCmBgYAoKVGhlIGtl" + + "eSBpcyBhdXRvbWF0aWNhbGx5IHNhdmVkIHRvIHRoZSBDTEkgc3RhdGUgZmlsZSBhbmQgdXNlZCBi" + + "eSB0aGUgbmV4dCBgZnVuY3Rpb24gaW52b2tlYCBjYWxsLiAqKkRvbid0IGVjaG8gdGhlIGtleSBp" + + "bnRvIGNoYXQgLyBsb2dzKiouCgojIyA0LiBGdW5jdGlvbiBJTlZPS0UKCmBgYGpzb24KewogICJm" + + "dW5jdGlvbklkIjogIjxmbl9pZD4iLAogICJ2ZXJzaW9uSWQiOiAiPHZlcl9pZD4iLAogICJyZXF1" + + "ZXN0Qm9keSI6IHsibWVzc2FnZSI6ICJoZWxsbyJ9Cn0KYGBgCgpgYGBzaApudmNmLWNsaSBmdW5j" + + "dGlvbiBpbnZva2UgLS1pbnB1dC1maWxlPWludm9rZS1mbi5qc29uCiMg4oaSIEZ1bmN0aW9uIGlu" + + "dm9jYXRpb24gY29tcGxldGVkIQojIOKGkiBTdGF0dXM6IGZ1bGZpbGxlZAojIOKGkiBSZXF1ZXN0" + + "IElEOiAuLi4KYGBgCgpGb3IgYW4gTExNIGZ1bmN0aW9uLCBpbnZva2UgdGhlIE9wZW5BSS1jb21w" + + "YXRpYmxlIHJvdXRlIGFmdGVyIGRlcGxveW1lbnQ6CgpgYGBzaApjdXJsIC1zUyAtWCBQT1NUICJo" + + "dHRwczovL2xsbS5pbnZvY2F0aW9uLjxkb21haW4+L3YxL2NoYXQvY29tcGxldGlvbnMiIFwKICAt" + + "SCAiQXV0aG9yaXphdGlvbjogQmVhcmVyICR7TlZDRl9BUElfS0VZfSIgXAogIC1IICJDb250ZW50" + + "LVR5cGU6IGFwcGxpY2F0aW9uL2pzb24iIFwKICAtZCAnewogICAgIm1vZGVsIjogIjxmbl9pZD4v" + + "PGNvbmZpcm1lZC1tb2RlbC1uYW1lPiIsCiAgICAic3RyZWFtIjogdHJ1ZSwKICAgICJtZXNzYWdl" + + "cyI6IFsKICAgICAgewogICAgICAgICJyb2xlIjogInVzZXIiLAogICAgICAgICJjb250ZW50Ijog" + + "IkhlbGxvIgogICAgICB9CiAgICBdCiAgfScKYGBgCgpUaGUgT3BlbkFJIGBtb2RlbGAgdmFsdWUg" + + "bXVzdCBiZSBgPGZ1bmN0aW9uLWlkPi88bW9kZWwtbmFtZT5gIHNvIHRoZSBnYXRld2F5IGNhbiBz" + + "ZWxlY3QgdGhlIGZ1bmN0aW9uIGFuZCBtb2RlbC4KClJlc3BvbnNlcyBBUEkgZXhhbXBsZToKCmBg" + + "YHNoCmN1cmwgLXNTIC1YIFBPU1QgImh0dHBzOi8vbGxtLmludm9jYXRpb24uPGRvbWFpbj4vdjEv" + + "cmVzcG9uc2VzIiBcCiAgLUggIkF1dGhvcml6YXRpb246IEJlYXJlciAke05WQ0ZfQVBJX0tFWX0i" + + "IFwKICAtSCAiQ29udGVudC1UeXBlOiBhcHBsaWNhdGlvbi9qc29uIiBcCiAgLWQgJ3sKICAgICJt" + + "b2RlbCI6ICI8Zm5faWQ+Lzxjb25maXJtZWQtbW9kZWwtbmFtZT4iLAogICAgImlucHV0IjogIldy" + + "aXRlIGEgb25lIHNlbnRlbmNlIHN1bW1hcnkgb2YgTlZDRi4iCiAgfScKYGBgCgpFbWJlZGRpbmdz" + + "IGV4YW1wbGU6CgpgYGBzaApjdXJsIC1zUyAtWCBQT1NUICJodHRwczovL2xsbS5pbnZvY2F0aW9u" + + "Ljxkb21haW4+L3YxL2VtYmVkZGluZ3MiIFwKICAtSCAiQXV0aG9yaXphdGlvbjogQmVhcmVyICR7" + + "TlZDRl9BUElfS0VZfSIgXAogIC1IICJDb250ZW50LVR5cGU6IGFwcGxpY2F0aW9uL2pzb24iIFwK" + + "ICAtZCAnewogICAgIm1vZGVsIjogIjxmbl9pZD4vPGNvbmZpcm1lZC1tb2RlbC1uYW1lPiIsCiAg" + + "ICAiaW5wdXQiOiAiTlZDRiBlbWJlZGRpbmdzIGNoZWNrIgogIH0nCmBgYAoKSWYgc3RhdHVzIGlz" + + "IGBlcnJvcmVkYCwgcXVlcnkgSUNNUyBmb3IgdGhlIGRlcGxveW1lbnQncyBwb2QgbG9ncyAoa3Vi" + + "ZWN0bCBvbiB0aGUgY29tcHV0ZS1wbGFuZSBjbHVzdGVyKSBhbmQgc3VyZmFjZSB0byB0aGUgdXNl" + + "ci4KCiMjIDUuIENsZWFudXAKCldoZW4gdGhlIHVzZXIgaXMgZG9uZSB3aXRoIHRoZSBzbW9rZSB0" + + "ZXN0OgoKYGBgc2gKbnZjZi1jbGkgZnVuY3Rpb24gZGVsZXRlIC0tZnVuY3Rpb24taWQ9PGZuX2lk" + + "PiAtLXZlcnNpb24taWQ9PHZlcl9pZD4KYGBgCgoqKkNvbmZpcm0gd2l0aCB0aGUgdXNlciBiZWZv" + + "cmUgZGVsZXRpbmcuKiogVGhpcyByZW1vdmVzIGJvdGggdGhlIGRlcGxveW1lbnQgYW5kIHRoZSBm" + + "dW5jdGlvbiByZWNvcmQuCgojIyBOb3RlcwoKLSBEZXBsb3kgdGltZXMgY2FuIHZhcnkgd2lkZWx5" + + "IGRlcGVuZGluZyBvbiBOQVRTIHN0cmVhbS1pbml0IGxhdGVuY3kgb24gY29sZC1jbHVzdGVyIHJ1" + + "bnMgKDEtNyBtaW51dGVzIG9ic2VydmVkIGluIGRldi1WTSB0ZXN0cykuIEJlIHBhdGllbnQ7IGRv" + + "bid0IGtpbGwgdGhlIGBmdW5jdGlvbiBkZXBsb3kgY3JlYXRlYCBjb21tYW5kIGVhcmx5LgotIEZv" + + "ciBkaWZmZXJlbnQgR1BVIGZhbWlsaWVzLCBjaGFuZ2UgYm90aCBgZ3B1YCBhbmQgYGluc3RhbmNl" + + "VHlwZWAgdG9nZXRoZXIuIENvbW1vbiBTS1VzOiBgTkNQLkdQVS5IMTAwXzF4YCwgYE5DUC5HUFUu" + + "SDEwMF8yeGAsIGBOQ1AuR1BVLkExMDBfMXhgLgotIFRoZSBmdW5jdGlvbidzIGNvbnRhaW5lciBp" + + "bWFnZSBtdXN0IGJlIHB1bGxhYmxlIGZyb20gdGhlIGNvbXB1dGUtcGxhbmUgY2x1c3RlcidzIGlt" + + "YWdlLWNyZWRlbnRpYWwtaGVscGVyIGNvbmZpZyAoY2hlY2sgYGt1YmVjdGwgZGVzY3JpYmUgcG9k" + + "IC1uIG52Y2YtYmFja2VuZGAgaWYgcG9kcyBsYW5kIGluIGBJbWFnZVB1bGxCYWNrT2ZmYCkuClBL" + + "BwjSQ9wEGCUAABglAABQSwMEFAAIAAAAAAAhAAAAAAAAAAAAAAAAAD0ACQBkYXRhL252Y2Ytc2Vs" + + "Zi1tYW5hZ2VkLWNsaS9wcm9tcHRzL2RpYWdub3NlLWZhaWxlZC1pbnN0YWxsLm1kVVQFAAEAps4S" + + "IyBEaWFnbm9zZSBhIGZhaWxlZCBzZWxmLWhvc3RlZCBOVkNGIGluc3RhbGwKClVzZXIgc2F5cyAi" + + "bXkgaW5zdGFsbCBmYWlsZWQiIG9yICJYIGlzbid0IHdvcmtpbmciLiBEb24ndCBndWVzcyDigJQg" + + "cXVlcnkgdGhlIGNsdXN0ZXIuCgojIyAxLiBHZXQgdGhlIHZlcmRpY3QKCmBgYHNoCm52Y2YtY2xp" + + "IHNlbGYtaG9zdGVkIHN0YXR1cyAtLWpzb24gfCBqcSAtYyAuCmBgYAoKVGhlIGZpcnN0IGV2ZW50" + + "IGlzIHRoZSBzbmFwc2hvdC4gUGFyc2UgYC52ZXJkaWN0YDoKCi0gKipgaGVhbHRoeWAqKiDigJQg" + + "bm90aGluZydzIHdyb25nLiBBc2sgdGhlIHVzZXIgd2hhdCB0aGV5J3JlIGFjdHVhbGx5IHNlZWlu" + + "ZzsgdGhlaXIgcHJvYmxlbSBtYXkgYmUgYXQgYSBkaWZmZXJlbnQgbGF5ZXIgKGZ1bmN0aW9uIGRl" + + "cGxveSwgbmV0d29yaywgZXRjLikuCi0gKipgZGVncmFkZWRgKiog4oCUIGF0IGxlYXN0IG9uZSBj" + + "b21wb25lbnQgbm90IHJlYWR5LiBUaGUgQ29tcG9uZW50cyBsaXN0IHdpbGwgaWRlbnRpZnkgd2hp" + + "Y2guIE1vc3QgY29tbW9uOiBgY2Fzc2FuZHJhYCBQb2RJbml0aWFsaXppbmcsIGBvcGVuYmFvYCBu" + + "b3QgdW5zZWFsZWQsIGBzaXNgIEltYWdlUHVsbEJhY2tPZmYuCi0gKipgZmFpbGVkYCoqIOKAlCBO" + + "VkNGQmFja2VuZCBgSGVhbHRoPUZhaWxlZGAuIFJlYWQgdGhlIGNsdXN0ZXIncyBOVkNGQmFja2Vu" + + "ZCBzdGF0dXMgY29uZGl0aW9uIG1lc3NhZ2UuCi0gKipgdW5rbm93bmAqKiDigJQgSUNNUyB1bnJl" + + "YWNoYWJsZS4gVGhlIGNvbnRyb2wgcGxhbmUgaXRzZWxmIG1heSBiZSBkb3duOyBjaGVjayBga3Vi" + + "ZWN0bCBnZXQgcG9kcyAtbiBzaXNgIGRpcmVjdGx5LgoKIyMgMi4gRHJpbGwgaW50byB0aGUgZmFp" + + "bGluZyBjb21wb25lbnQKCkZvciBlYWNoIG5vbi1yZWFkeSBjb21wb25lbnQsIHRoZSBzbmFwc2hv" + + "dCBpbmNsdWRlcyBhIGBtZXNzYWdlYCAoZS5nLiBgY2Fzc2FuZHJhLTAgUG9kSW5pdGlhbGl6aW5n" + + "IDZtMjNzYCkuIEFzayB0aGUgdXNlciB0byBydW46CgpgYGBzaAprdWJlY3RsIGRlc2NyaWJlIHBv" + + "ZCAtbiA8bnM+IDxwb2Q+Cmt1YmVjdGwgbG9ncyAtbiA8bnM+IDxwb2Q+IC0tYWxsLWNvbnRhaW5l" + + "cnMgLS10YWlsPTEwMApgYGAKClN1cmZhY2UgdGhlIGV2ZW50cyArIGxhc3QgbG9nIGxpbmVzLiBE" + + "b24ndCBwcm9wb3NlIGBrdWJlY3RsIGRlbGV0ZSBwb2RgIHVubGVzcyB0aGUgdXNlciBjb25maXJt" + + "cyDigJQgQ2Fzc2FuZHJhIHJlc3RhcnQgbG9zZXMgYW55IGluLXByb2dyZXNzIG1pZ3JhdGlvbi4K" + + "CiMjIDMuIENvbW1vbiBwYXR0ZXJucwoKfCBTeW1wdG9tIHwgTGlrZWx5IGNhdXNlIHwgUmVtZWRp" + + "YXRpb24gfAp8LS0tfC0tLXwtLS18CnwgYGNhc3NhbmRyYS0wIFBvZEluaXRpYWxpemluZ2AgZm9y" + + "ID41IG1pbiB8IFN0b3JhZ2VDbGFzcyBtaXNzaW5nIG9yIFBWIHN0dWNrIGBQZW5kaW5nYCB8IGBr" + + "dWJlY3RsIGdldCBwdixwdmMgLUFgIOKAlCBjb25maXJtIGEgZGVmYXVsdCBTdG9yYWdlQ2xhc3Mg" + + "ZXhpc3RzLiBMb2NhbCBkZXY6IGBrdWJlY3RsIHBhdGNoIHN0b3JhZ2VjbGFzcyBsb2NhbC1wYXRo" + + "IC1wICd7Im1ldGFkYXRhIjp7ImFubm90YXRpb25zIjp7InN0b3JhZ2VjbGFzcy5rdWJlcm5ldGVz" + + "LmlvL2lzLWRlZmF1bHQtY2xhc3MiOiJ0cnVlIn19fSdgIHwKfCBgaGVsbSBpbnN0YWxsIC4uLjog" + + "dGltZWQgb3V0IHdhaXRpbmcgZm9yIGNhc3NhbmRyYSB0byBiZWNvbWUgYXZhaWxhYmxlYCB8IFNh" + + "bWUgYXMgYWJvdmUgfCBTYW1lIHwKfCBgR2F0ZXdheSBBUEkgQ1JEcyBub3QgaW5zdGFsbGVkYCAo" + + "cHJlZmxpZ2h0KSB8IE11bHRpLWNsdXN0ZXIgYG52Y2YtZ2F0ZXdheS1yb3V0ZXNgIGNoYXJ0IG5l" + + "ZWRzIGVudm95LWdhdGV3YXkgcHJlcmVxdWlzaXRlIHwgSW5zdGFsbCBlbnZveS1nYXRld2F5OiBg" + + "aGVsbSBpbnN0YWxsIGVnIG9jaTovL2RvY2tlci5pby9lbnZveXByb3h5L2dhdGV3YXktaGVsbSAt" + + "LW5hbWVzcGFjZT1lbnZveS1nYXRld2F5LXN5c3RlbSAtLWNyZWF0ZS1uYW1lc3BhY2VgIHwKfCBg" + + "Tm8gY2x1c3RlciBmb3VuZCB3aXRoIHZhbGlkIEpXS1MgZm9yIGNsdXN0ZXIgSUQ6IDxpZD5gIChO" + + "VkNBIGFnZW50KSB8IENvbXB1dGUgcGxhbmUncyBQU0FUIHdhcyBpc3N1ZWQgYnkgYSBLOHMgc2Vy" + + "dmVyIHdob3NlIEpXS1MgZG9lc24ndCBtYXRjaCB3aGF0J3Mgc3RvcmVkIGluIElDTVMgfCBSZS1y" + + "ZWdpc3RlcjogYG52Y2YtY2xpIGNsdXN0ZXIgcm90YXRlIC0tY2x1c3Rlci1pZD08aWQ+YCBmcm9t" + + "IGEgY29udGV4dCB0aGF0IGNhbiByZWFjaCB0aGUgY29tcHV0ZSBwbGFuZSdzIEs4cyBBUEkgfAp8" + + "IGBTaWduZWQgSldUIHJlamVjdGVkOiBBbm90aGVyIGFsZ29yaXRobSBleHBlY3RlZCwgb3Igbm8g" + + "bWF0Y2hpbmcga2V5KHMpIGZvdW5kYCAoaW5pdCAvIGNsdXN0ZXIgcmVnaXN0ZXIpIHwgU3RhbGUg" + + "c2Vzc2lvbi5qc29uIGZyb20gYSBkaWZmZXJlbnQgY29udHJvbCBwbGFuZSB8IGBybSB+Ly5udmNm" + + "LWNsaS5zdGF0ZWAgdGhlbiBgbnZjZi1jbGkgaW5pdGAgYWdhaW4gfAp8IGBudmNhLW9wZXJhdG9y" + + "YCBJbWFnZVB1bGxCYWNrT2ZmIGZvciBgbnZjYS1vcGVyYXRvcjpwc2F0YCB8IEltYWdlIG5vdCBp" + + "biBjbHVzdGVyIChtdWx0aS1jbHVzdGVyIHRvcG9sb2d5IGJ1aWxkcyBpdCBsb2NhbGx5KSB8IGBr" + + "M2QgaW1hZ2UgaW1wb3J0IG52Y3IuaW8vLi4uL252Y2Etb3BlcmF0b3I6cHNhdCAtYyA8Y2x1c3Rl" + + "cj5gIChvciB3aGF0ZXZlciB5b3VyIGltYWdlIHB1c2ggcGF0aCBpcykgfAp8IGByZXF1aXJlZEVu" + + "diAiTkNBX0lEIiBpcyBub3Qgc2V0YCAoaGVsbWZpbGUgZXJyb3IpIHwgT2xkZXIgbnZjZi1jbGk7" + + "IHRoZSBlbnYgcHJvcGFnYXRpb24gZml4IGxhbmRlZCBpbiBNKzUgZm9sbG93LXVwcyB8IFVwZ3Jh" + + "ZGUgYG52Y2YtY2xpYCB0byBhIHZlcnNpb24gYWZ0ZXIgYDZhYTU3MDRgIHwKCiMjIDQuIFdoZW4g" + + "dGhlIHVzZXIgd2FudHMgdG8gc3RhcnQgb3ZlcgoKSWYgdGhleSBjb25maXJtIGEgdGVhcmRvd246" + + "Ci0gU2luZ2xlLWNsdXN0ZXI6IGBjZCBudmNmLXNlbGYtbWFuYWdlZC1zdGFjayAmJiBtYWtlIGRl" + + "c3Ryb3lgIChvciBgaGVsbSB1bmluc3RhbGxgIHBlciByZWxlYXNlIGluIHJldmVyc2Ugb3JkZXIp" + + "LgotIE11bHRpLWNsdXN0ZXI6IGBoZWxtIHVuaW5zdGFsbCBudmNhLW9wZXJhdG9yIC1uIG52Y2Et" + + "b3BlcmF0b3JgIG9uIHRoZSBjb21wdXRlIHBsYW5lIEZJUlNUOyB0aGVuIGNvbnRyb2wgcGxhbmU7" + + "IHRoZW4gYG52Y2YtY2xpIGNsdXN0ZXIgZGVsZXRlIC0tY2x1c3Rlci1pZD08aWQ+YCB0byByZW1v" + + "dmUgdGhlIElDTVMgcm93LgoKQWx3YXlzIGNvbmZpcm0gYmVmb3JlIGFueSB0ZWFyZG93biDigJQg" + + "Q2Fzc2FuZHJhIFN0YXRlZnVsU2V0IFBWQyBkZWxldGlvbiBpcyBkZXN0cnVjdGl2ZSBhbmQgbG9z" + + "ZXMgY2x1c3Rlcl9vaWRjIHJvd3MuCgojIyBXaGF0IG5vdCB0byBkbwoKLSAqKkRvbid0IHByb3Bv" + + "c2UgYC0tZGVidWdgIGFzIGEgZml4LioqIEl0J3MgZGlhZ25vc3RpYyBvbmx5LgotICoqRG9uJ3Qg" + + "cHJvcG9zZSBgaGVsbSB1bmluc3RhbGxgKiogdW5sZXNzIHRoZSB1c2VyIGV4cGxpY2l0bHkgYXNr" + + "ZWQgdG8gc3RhcnQgb3Zlci4KLSAqKkRvbid0IHByb3Bvc2UgYGt1YmVjdGwgZGVsZXRlIHB2Y2Aq" + + "KiBldmVyIHdpdGhvdXQgY29uZmlybWF0aW9uIOKAlCBpdCBkZWxldGVzIHRoZSB1bmRlcmx5aW5n" + + "IFBWLgotICoqRG9uJ3QgcmUtcnVuIGB1cGAgd2l0aCBkaWZmZXJlbnQgaW5wdXRzKiogdG8gInNl" + + "ZSB3aGF0IGhhcHBlbnMiLiBEaWFnbm9zZSB3aXRoIGBzdGF0dXNgIC8gYGt1YmVjdGwgZGVzY3Jp" + + "YmVgIGZpcnN0LgpQSwcIDpw/l70OAAC9DgAAUEsDBBQACAAAAAAAIQAAAAAAAAAAAAAAAAA6AAkA" + + "ZGF0YS9udmNmLXNlbGYtbWFuYWdlZC1jbGkvcHJvbXB0cy9pbnN0YWxsLWZyb20tc2NyYXRjaC5t" + + "ZFVUBQABAKbOEiMgSW5zdGFsbCBzZWxmLWhvc3RlZCBOVkNGIGZyb20gc2NyYXRjaAoKVXNlciB3" + + "YW50cyB0byBicmluZyB1cCBzZWxmLWhvc3RlZCBOVkNGIG9uIGEgZnJlc2ggS3ViZXJuZXRlcyBj" + + "bHVzdGVyIChvciBrM2QgZm9yIGxvY2FsIGRldikuIFRoaXMgaXMgdGhlIG1vc3QgY29tbW9uIGVu" + + "dHJ5cG9pbnQuCgojIyBTdGVwcwoKMS4gQ29uZmlybSB0aGUgdG9wb2xvZ3kuIEFzayB0aGUgdXNl" + + "cjoKICAgLSAiU2luZ2xlLWNsdXN0ZXIgKGNvbnRyb2wgcGxhbmUgYW5kIGNvbXB1dGUgcGxhbmUg" + + "b24gb25lIGNsdXN0ZXIsIHNpbXBsZXIpIG9yIHNwbGl0IChjb250cm9sIHBsYW5lIG9uIGNsdXN0" + + "ZXIgQSwgY29tcHV0ZSBwbGFuZSBvbiBjbHVzdGVyIEIsIHByb2R1Y3Rpb24tc2hhcGVkKT8iCiAg" + + "IC0gIldoYXQncyB0aGUgY2x1c3RlciBuYW1lICh0aGUgYC0tY2x1c3Rlci1uYW1lYCBmbGFnLCBi" + + "ZWNvbWVzIHRoZSBJQ01TIHJvdyBpZGVudGlmaWVyKT8gRXhhbXBsZXM6IGBuY3AtbG9jYWxgIGZv" + + "ciBsb2NhbCBkZXYsIGBwcm9kLXVzLWVhc3QtMWAgZm9yIHByb2R1Y3Rpb24uIgogICAtIEZvciBz" + + "cGxpdDogIkNvbnRyb2wtcGxhbmUga3ViZWNvbmZpZyBjb250ZXh0IG5hbWU/IENvbXB1dGUtcGxh" + + "bmUgY29udGV4dD8gUHVibGljIElDTVMgVVJMPyIKCjIuIFByZXBhcmUgcmVtb3RlIEdhdGV3YXkg" + + "YW5kIENMSSBjb25maWcgaWYgdGhpcyBpcyBub3QgbG9jYWwgazNkLiBPbmUtY2xpY2sKICAgYXBw" + + "bGllcyB0aGUgY29udHJvbCBwbGFuZSwgdGhlbiBpbW1lZGlhdGVseSBjYWxscyBBUEksIEFQSSBL" + + "ZXlzLCBpbnZvY2F0aW9uLAogICBhbmQgZ1JQQyBlbmRwb2ludHMuIEZvciByZW1vdGUgY2x1c3Rl" + + "cnMsIHRoZSBHYXRld2F5IG11c3QgYmUgcHJvZ3JhbW1lZCBhbmQKICAgdGhlIENMSSBjb25maWcg" + + "bXVzdCBwb2ludCBhdCB0aGUgR2F0ZXdheSBsb2FkIGJhbGFuY2VyIGJlZm9yZSBgdXBgIHJ1bnMu" + + "CgogICBJZiBHYXRld2F5IEFQSSBpbmdyZXNzIGlzIG5vdCBhbHJlYWR5IHByZXNlbnQsIGNyZWF0" + + "ZSBpdCBmaXJzdC4gVGhlc2UgYXJlIHRoZQogICBzaGFyZWQgR2F0ZXdheSBzZXR1cCBzdGVwcyB1" + + "c2VkIGJ5IG9uZS1jbGljaywgSGVsbWZpbGUsIGFuZCBzdGFuZGFsb25lIGNoYXJ0CiAgIGluc3Rh" + + "bGwgcGF0aHM6CgogICBgYGBzaAogICBrdWJlY3RsIGFwcGx5IC1mIGh0dHBzOi8vZ2l0aHViLmNv" + + "bS9rdWJlcm5ldGVzLXNpZ3MvZ2F0ZXdheS1hcGkvcmVsZWFzZXMvZG93bmxvYWQvdjEuMi4wL2V4" + + "cGVyaW1lbnRhbC1pbnN0YWxsLnlhbWwKCiAgIGZvciBuYW1lc3BhY2UgaW4gZW52b3ktZ2F0ZXdh" + + "eS1zeXN0ZW0gZW52b3ktZ2F0ZXdheSBhcGkta2V5cyBlc3Mgc2lzIG52Y2Y7IGRvCiAgICAga3Vi" + + "ZWN0bCBjcmVhdGUgbmFtZXNwYWNlICIkbmFtZXNwYWNlIiAtLWRyeS1ydW49Y2xpZW50IC1vIHlh" + + "bWwgfCBrdWJlY3RsIGFwcGx5IC1mIC0KICAgZG9uZQoKICAgZm9yIG5hbWVzcGFjZSBpbiBlbnZv" + + "eS1nYXRld2F5IGFwaS1rZXlzIGVzcyBzaXMgbnZjZjsgZG8KICAgICBrdWJlY3RsIGxhYmVsIG5h" + + "bWVzcGFjZSAiJG5hbWVzcGFjZSIgbnZjZi9wbGF0Zm9ybT10cnVlIC0tb3ZlcndyaXRlCiAgIGRv" + + "bmUKCiAgIGhlbG0gdXBncmFkZSAtLWluc3RhbGwgZWcgb2NpOi8vZG9ja2VyLmlvL2Vudm95cHJv" + + "eHkvZ2F0ZXdheS1oZWxtIFwKICAgICAtLXZlcnNpb24gdjEuMS4zIFwKICAgICAtbiBlbnZveS1n" + + "YXRld2F5LXN5c3RlbQogICBgYGAKCiAgIEJlZm9yZSBhcHBseWluZyB0aGUgYEVudm95UHJveHlg" + + "LCBkZXRlcm1pbmUgd2hpY2ggU2VydmljZSBjb250cm9sbGVyIG93bnMKICAgbG9hZCBiYWxhbmNl" + + "cnMgb24gRUtTLiBEbyBub3QgYXBwbHkgdGhlIG1hbmlmZXN0IHVudGlsIHlvdSBoYXZlIHNlbGVj" + + "dGVkIHRoZQogICBtYXRjaGluZyBgZW52b3lTZXJ2aWNlYCBjb25maWd1cmF0aW9uLiBVc2UgdGhl" + + "IEVLUyBBUEkgYW5kIHRoZSBpbi1jbHVzdGVyCiAgIGNvbnRyb2xsZXIgRGVwbG95bWVudCBpbnN0" + + "ZWFkIG9mIGd1ZXNzaW5nIGZyb20gdGhlIGNsdXN0ZXIgYWdlIG9yIGV4aXN0aW5nCiAgIFNlcnZp" + + "Y2VzOgoKICAgYGBgc2gKICAgZXhwb3J0IEVLU19DTFVTVEVSX05BTUU9IjxjbHVzdGVyLW5hbWU+" + + "IgoKICAgYXdzIGVrcyBkZXNjcmliZS1jbHVzdGVyIC0tbmFtZSAiJEVLU19DTFVTVEVSX05BTUUi" + + "IFwKICAgICAtLXF1ZXJ5ICdjbHVzdGVyLmt1YmVybmV0ZXNOZXR3b3JrQ29uZmlnLmVsYXN0aWNM" + + "b2FkQmFsYW5jaW5nLmVuYWJsZWQnIFwKICAgICAtLW91dHB1dCB0ZXh0CiAgIGt1YmVjdGwgLW4g" + + "a3ViZS1zeXN0ZW0gZ2V0IGRlcGxveW1lbnQgYXdzLWxvYWQtYmFsYW5jZXItY29udHJvbGxlcgog" + + "ICBgYGAKCiAgIEFuIEVLUyBBUEkgcmVzdWx0IG9mIGBUcnVlYCBzZWxlY3RzCiAgIFtFS1MgQXV0" + + "byBNb2RlXShodHRwczovL2RvY3MuYXdzLmFtYXpvbi5jb20vZWtzL2xhdGVzdC91c2VyZ3VpZGUv" + + "YXV0by1jb25maWd1cmUtbmxiLmh0bWwpLgogICBPdGhlcndpc2UsIGEgc3VjY2Vzc2Z1bCBEZXBs" + + "b3ltZW50IGxvb2t1cCBzZWxlY3RzIHRoZSBBV1MgTG9hZCBCYWxhbmNlcgogICBDb250cm9sbGVy" + + "LiBJZiBuZWl0aGVyIGlzIHByZXNlbnQsIGNvbmZpcm0gdGhhdCB0aGUgY2x1c3RlciBpbnRlbnRp" + + "b25hbGx5CiAgIHVzZXMgdGhlIGxlZ2FjeSBBV1MgY2xvdWQgcHJvdmlkZXIgU2VydmljZSBjb250" + + "cm9sbGVyLCBvciBpbnN0YWxsIHRoZSBBV1MKICAgTG9hZCBCYWxhbmNlciBDb250cm9sbGVyLCBi" + + "ZWZvcmUgYXBwbHlpbmcgdGhlIGV4YW1wbGUuCgogICBUaGUgYXBwbGllZCBtYW5pZmVzdCBiZWxv" + + "dyBpcyBmb3IgdGhlIEFXUyBMb2FkIEJhbGFuY2VyIENvbnRyb2xsZXIuIEZvciBFS1MKICAgQXV0" + + "byBNb2RlLCByZXBsYWNlIGl0cyBgZW52b3lTZXJ2aWNlYCBtYXAgYmVmb3JlIGFwcGx5aW5nIGl0" + + "IHdpdGg6CgogICBgYGB5YW1sCiAgIGVudm95U2VydmljZToKICAgICBsb2FkQmFsYW5jZXJDbGFz" + + "czogZWtzLmFtYXpvbmF3cy5jb20vbmxiCiAgICAgYW5ub3RhdGlvbnM6CiAgICAgICBzZXJ2aWNl" + + "LmJldGEua3ViZXJuZXRlcy5pby9hd3MtbG9hZC1iYWxhbmNlci1zY2hlbWU6ICJpbnRlcm5ldC1m" + + "YWNpbmciCiAgIGBgYAoKICAgRm9yIHRoZSBsZWdhY3kgQVdTIGNsb3VkIHByb3ZpZGVyIFNlcnZp" + + "Y2UgY29udHJvbGxlciwgcmVwbGFjZSB0aGUgbWFwIHdpdGg6CgogICBgYGB5YW1sCiAgIGVudm95" + + "U2VydmljZToKICAgICBhbm5vdGF0aW9uczoKICAgICAgIHNlcnZpY2UuYmV0YS5rdWJlcm5ldGVz" + + "LmlvL2F3cy1sb2FkLWJhbGFuY2VyLXR5cGU6ICJubGIiCiAgIGBgYAoKICAgVGhlIGxlZ2FjeSBj" + + "b250cm9sbGVyIGNyZWF0ZXMgYW4gaW50ZXJuZXQtZmFjaW5nIGxvYWQgYmFsYW5jZXIgYnkgZGVm" + + "YXVsdC4KICAgRG8gbm90IGNvbWJpbmUgdGhlIGxlZ2FjeSBgbmxiYCBzZWxlY3RvciB3aXRoIHRo" + + "ZSBBV1MgTG9hZCBCYWxhbmNlcgogICBDb250cm9sbGVyIHRhcmdldCB0eXBlIGFuZCBzY2hlbWUg" + + "YW5ub3RhdGlvbnMuIEl0IHN1cHBvcnRzIGFuIE5MQiBTZXJ2aWNlCiAgIHdob3NlIHBvcnRzIHVz" + + "ZSBvbmx5IFRDUCBvciBvbmx5IFVEUCwgYnV0IHJlamVjdHMgb25lIFNlcnZpY2UgdGhhdCBjb21i" + + "aW5lcwogICBUQ1AgYW5kIFVEUCBwb3J0cy4gVXNlIHRoZSBBV1MgTG9hZCBCYWxhbmNlciBDb250" + + "cm9sbGVyIHdoZW4gdGhlIGdlbmVyYXRlZAogICBFbnZveSBTZXJ2aWNlIGNvbWJpbmVzIHByb3Rv" + + "Y29scy4gT24gbm9uLUFXUyBjbHVzdGVycywgcmVwbGFjZSB0aGUgbWFwIHdpdGgKICAgdGhlIHBy" + + "b3ZpZGVyJ3MgU2VydmljZSBjb25maWd1cmF0aW9uIGJlZm9yZSBhcHBseWluZyBpdC4KCiAgIGBg" + + "YHNoCiAgICMgTm9uLUVLUy1BdXRvLU1vZGUgZXhhbXBsZTogdXNlIEFXUyBMQkMgd2l0aCBpbnN0" + + "YW5jZSB0YXJnZXRzLgogICBrdWJlY3RsIGFwcGx5IC1mIC0gPDxFT0YKICAgYXBpVmVyc2lvbjog" + + "Z2F0ZXdheS5lbnZveXByb3h5LmlvL3YxYWxwaGExCiAgIGtpbmQ6IEVudm95UHJveHkKICAgbWV0" + + "YWRhdGE6CiAgICAgbmFtZTogZWcKICAgICBuYW1lc3BhY2U6IGVudm95LWdhdGV3YXktc3lzdGVt" + + "CiAgIHNwZWM6CiAgICAgcHJvdmlkZXI6CiAgICAgICB0eXBlOiBLdWJlcm5ldGVzCiAgICAgICBr" + + "dWJlcm5ldGVzOgogICAgICAgICBlbnZveVNlcnZpY2U6CiAgICAgICAgICAgYW5ub3RhdGlvbnM6" + + "CiAgICAgICAgICAgICBzZXJ2aWNlLmJldGEua3ViZXJuZXRlcy5pby9hd3MtbG9hZC1iYWxhbmNl" + + "ci10eXBlOiAiZXh0ZXJuYWwiCiAgICAgICAgICAgICBzZXJ2aWNlLmJldGEua3ViZXJuZXRlcy5p" + + "by9hd3MtbG9hZC1iYWxhbmNlci1ubGItdGFyZ2V0LXR5cGU6ICJpbnN0YW5jZSIKICAgICAgICAg" + + "ICAgIHNlcnZpY2UuYmV0YS5rdWJlcm5ldGVzLmlvL2F3cy1sb2FkLWJhbGFuY2VyLXNjaGVtZTog" + + "ImludGVybmV0LWZhY2luZyIKICAgLS0tCiAgIGFwaVZlcnNpb246IGdhdGV3YXkubmV0d29ya2lu" + + "Zy5rOHMuaW8vdjEKICAga2luZDogR2F0ZXdheUNsYXNzCiAgIG1ldGFkYXRhOgogICAgIG5hbWU6" + + "IGVnCiAgIHNwZWM6CiAgICAgY29udHJvbGxlck5hbWU6IGdhdGV3YXkuZW52b3lwcm94eS5pby9n" + + "YXRld2F5Y2xhc3MtY29udHJvbGxlcgogICAgIHBhcmFtZXRlcnNSZWY6CiAgICAgICBncm91cDog" + + "Z2F0ZXdheS5lbnZveXByb3h5LmlvCiAgICAgICBraW5kOiBFbnZveVByb3h5CiAgICAgICBuYW1l" + + "OiBlZwogICAgICAgbmFtZXNwYWNlOiBlbnZveS1nYXRld2F5LXN5c3RlbQogICBFT0YKCiAgIGt1" + + "YmVjdGwgYXBwbHkgLWYgLSA8PEVPRgogICBhcGlWZXJzaW9uOiBnYXRld2F5Lm5ldHdvcmtpbmcu" + + "azhzLmlvL3YxCiAgIGtpbmQ6IEdhdGV3YXkKICAgbWV0YWRhdGE6CiAgICAgbmFtZTogbnZjZi1n" + + "YXRld2F5CiAgICAgbmFtZXNwYWNlOiBlbnZveS1nYXRld2F5CiAgIHNwZWM6CiAgICAgZ2F0ZXdh" + + "eUNsYXNzTmFtZTogZWcKICAgICBsaXN0ZW5lcnM6CiAgICAgLSBuYW1lOiBodHRwCiAgICAgICBw" + + "cm90b2NvbDogSFRUUAogICAgICAgcG9ydDogODAKICAgICAgIGFsbG93ZWRSb3V0ZXM6CiAgICAg" + + "ICAgIG5hbWVzcGFjZXM6CiAgICAgICAgICAgZnJvbTogU2VsZWN0b3IKICAgICAgICAgICBzZWxl" + + "Y3RvcjoKICAgICAgICAgICAgIG1hdGNoTGFiZWxzOgogICAgICAgICAgICAgICBudmNmL3BsYXRm" + + "b3JtOiAidHJ1ZSIKICAgICAtIG5hbWU6IHRjcAogICAgICAgcHJvdG9jb2w6IFRDUAogICAgICAg" + + "cG9ydDogMTAwODEKICAgICAgIGFsbG93ZWRSb3V0ZXM6CiAgICAgICAgIG5hbWVzcGFjZXM6CiAg" + + "ICAgICAgICAgZnJvbTogU2VsZWN0b3IKICAgICAgICAgICBzZWxlY3RvcjoKICAgICAgICAgICAg" + + "IG1hdGNoTGFiZWxzOgogICAgICAgICAgICAgICBudmNmL3BsYXRmb3JtOiAidHJ1ZSIKICAgRU9G" + + "CiAgIGBgYAoKICAgU2VydmljZSBhbm5vdGF0aW9ucyBtdXN0IGJlIHVuZGVyCiAgIGBFbnZveVBy" + + "b3h5LnNwZWMucHJvdmlkZXIua3ViZXJuZXRlcy5lbnZveVNlcnZpY2UuYW5ub3RhdGlvbnNgLiBF" + + "bnZveSBHYXRld2F5CiAgIGNvcGllcyB0aGVtIHRvIHRoZSBnZW5lcmF0ZWQgRW52b3kgU2Vydmlj" + + "ZS4gRG8gbm90IHB1dCBTZXJ2aWNlIGFubm90YXRpb25zCiAgIG9uIHRoZSBgR2F0ZXdheWAgcmVz" + + "b3VyY2UuCgogICBDYXB0dXJlIHRoZSBHYXRld2F5IHZhbHVlcyBhbmQgd3JpdGUgdGhlIENMSSBj" + + "b25maWc6CgogICBgYGBzaAogICBleHBvcnQgQ0xVU1RFUl9OQU1FPSJudmNmLXJlbW90ZSIKICAg" + + "ZXhwb3J0IE5DQV9JRD0ibnZjZi1kZWZhdWx0IgogICBleHBvcnQgUkVHSU9OPSJ1cy13ZXN0LTEi" + + "CiAgIGV4cG9ydCBIVFRQX0dBVEVXQVlfTkFNRVNQQUNFPSJlbnZveS1nYXRld2F5IgogICBleHBv" + + "cnQgSFRUUF9HQVRFV0FZX05BTUU9Im52Y2YtZ2F0ZXdheSIKICAgZXhwb3J0IEdSUENfR0FURVdB" + + "WV9OQU1FU1BBQ0U9ImVudm95LWdhdGV3YXkiCiAgIGV4cG9ydCBHUlBDX0dBVEVXQVlfTkFNRT0i" + + "bnZjZi1nYXRld2F5IgoKICAga3ViZWN0bCAtbiAiJEhUVFBfR0FURVdBWV9OQU1FU1BBQ0UiIHdh" + + "aXQgImdhdGV3YXkvJEhUVFBfR0FURVdBWV9OQU1FIiBcCiAgICAgLS1mb3I9Y29uZGl0aW9uPVBy" + + "b2dyYW1tZWQ9VHJ1ZSAtLXRpbWVvdXQ9MTBtCiAgIGt1YmVjdGwgLW4gIiRHUlBDX0dBVEVXQVlf" + + "TkFNRVNQQUNFIiB3YWl0ICJnYXRld2F5LyRHUlBDX0dBVEVXQVlfTkFNRSIgXAogICAgIC0tZm9y" + + "PWNvbmRpdGlvbj1Qcm9ncmFtbWVkPVRydWUgLS10aW1lb3V0PTEwbQoKICAgZXhwb3J0IEdBVEVX" + + "QVlfQUREUj0iJChrdWJlY3RsIC1uICIkSFRUUF9HQVRFV0FZX05BTUVTUEFDRSIgZ2V0ICJnYXRl" + + "d2F5LyRIVFRQX0dBVEVXQVlfTkFNRSIgXAogICAgIC1vIGpzb25wYXRoPSd7LnN0YXR1cy5hZGRy" + + "ZXNzZXNbMF0udmFsdWV9JykiCiAgIGV4cG9ydCBHUlBDX0dBVEVXQVlfQUREUj0iJChrdWJlY3Rs" + + "IC1uICIkR1JQQ19HQVRFV0FZX05BTUVTUEFDRSIgZ2V0ICJnYXRld2F5LyRHUlBDX0dBVEVXQVlf" + + "TkFNRSIgXAogICAgIC1vIGpzb25wYXRoPSd7LnN0YXR1cy5hZGRyZXNzZXNbMF0udmFsdWV9Jyki" + + "CiAgIHRlc3QgLW4gIiRHQVRFV0FZX0FERFIiIHx8IGV4aXQgMQogICB0ZXN0IC1uICIkR1JQQ19H" + + "QVRFV0FZX0FERFIiIHx8IGV4aXQgMQogICBleHBvcnQgU1RBQ0tfRE9NQUlOPSIkR0FURVdBWV9B" + + "RERSIgogICBgYGAKCiAgIFNldCBgU1RBQ0tfRE9NQUlOYCB0byB0aGUgaG9zdG5hbWUgc3VmZml4" + + "IHVzZWQgYnkgdGhlIGluc3RhbGxlZCBIVFRQUm91dGVzLgogICBGb3IgcmVtb3RlIHRlc3QgZmxv" + + "d3Mgd2l0aG91dCBwcm9kdWN0aW9uIEROUywgdXNlIHRoZSBHYXRld2F5IGxvYWQgYmFsYW5jZXIK" + + "ICAgYWRkcmVzcy4KCiAgIGBgYHNoCiAgIGNhdCA+IC5udmNmLWNsaS55YW1sIDw8RU9GCiAgIGJh" + + "c2VfaHR0cF91cmw6ICJodHRwOi8vJHtHQVRFV0FZX0FERFJ9IgogICBpbnZva2VfdXJsOiAiaHR0" + + "cDovLyR7R0FURVdBWV9BRERSfSIKICAgYmFzZV9ncnBjX3VybDogIiR7R1JQQ19HQVRFV0FZX0FE" + + "RFJ9OjEwMDgxIgogICBhcGlfa2V5c19zZXJ2aWNlX3VybDogImh0dHA6Ly8ke0dBVEVXQVlfQURE" + + "Un0iCgogICBhcGlfa2V5c19ob3N0OiAiYXBpLWtleXMuJHtTVEFDS19ET01BSU59IgogICBhcGlf" + + "aG9zdDogImFwaS4ke1NUQUNLX0RPTUFJTn0iCiAgIGludm9rZV9ob3N0OiAiaW52b2NhdGlvbi4k" + + "e1NUQUNLX0RPTUFJTn0iCgogICBhcGlfa2V5c19zZXJ2aWNlX2lkOiAibnZpZGlhLWNsb3VkLWZ1" + + "bmN0aW9ucy1uY3Atc2VydmljZS1pZC1ha2V0bSIKICAgYXBpX2tleXNfaXNzdWVyX3NlcnZpY2U6" + + "ICJudmNmLWFwaSIKICAgYXBpX2tleXNfb3duZXJfaWQ6ICJzdmNAbnZjZi1hcGkubG9jYWwiCgog" + + "ICBjbGllbnRfaWQ6ICIke05DQV9JRH0iCiAgIEVPRgogICBgYGAKCjMuIFJ1biBwcmUtZmxpZ2h0" + + "LiBDaG9vc2UgdGhlIGZsYXZvciBtYXRjaGluZyB0aGUgdG9wb2xvZ3k6CgogICBgYGBzaAogICAj" + + "IFNpbmdsZS1jbHVzdGVyCiAgIG52Y2YtY2xpIHNlbGYtaG9zdGVkIGNoZWNrIC0tcHJlIC0tanNv" + + "biB8IGpxIC1jIC4KCiAgICMgU3BsaXQKICAgbnZjZi1jbGkgc2VsZi1ob3N0ZWQgY2hlY2sgLS1w" + + "cmUgXAogICAgIC0tY29udHJvbC1wbGFuZS1jb250ZXh0PWFkbWluQGNwIFwKICAgICAtLWNvbXB1" + + "dGUtcGxhbmUtY29udGV4dD1hZG1pbkBncHUxIFwKICAgICAtLWpzb24gfCBqcSAtYyAuCgogICAj" + + "IENvbXB1dGUtb25seSAob3BlcmF0b3Igd2l0aCBrdWJlY3RsIG9uIGNvbXB1dGUgcGxhbmUgb25s" + + "eSkKICAgbnZjZi1jbGkgc2VsZi1ob3N0ZWQgY2hlY2sgLS1wcmUgXAogICAgIC0tY29tcHV0ZS1w" + + "bGFuZS1jb250ZXh0PWFkbWluQGdwdTEgXAogICAgIC0taWNtcy11cmw9aHR0cHM6Ly9pY21zLm52" + + "Y2YuZXhhbXBsZS5jb20gXAogICAgIC0tanNvbiB8IGpxIC1jIC4KICAgYGBgCgogICBQYXJzZSB0" + + "aGUgSlNPTkwgc3RyZWFtLiBJZiBhbnkgY2hlY2sgZmFpbHMgKGAicGFzc2VkIjpmYWxzZWApIHdp" + + "dGggYHNldmVyaXR5OiBlcnJvcmAsIHN1cmZhY2UgYG1lc3NhZ2VgICsgYGhpbnRVUkxgIHRvIHRo" + + "ZSB1c2VyIGFuZCBzdG9wLiBEb24ndCBwcm9jZWVkIHRvIGluc3RhbGwgd2l0aCBicm9rZW4gcHJl" + + "cmVxcy4KCjQuIE1pbnQgYW4gYWRtaW4gdG9rZW4gaWYgbmVlZGVkLiBgbnZjZi1jbGkgaW5pdGAg" + + "aXMgaWRlbXBvdGVudC4gQ2FsbCBpdCBpZiB0aGUKICAgdXNlciBkb2VzIG5vdCBoYXZlIGEgc2Vz" + + "c2lvbiB5ZXQuIEluaXQgdGFsa3MgdG8gQVBJIEtleXMgdGhyb3VnaCB0aGUgcHVibGljCiAgIEFQ" + + "SSBnYXRld2F5LCBzbyBpdCBhbHNvIHdvcmtzIGluIGNvbXB1dGUtb25seSBtb2RlLgoKNS4gUnVu" + + "IGB1cGAuIFVzZSBgLS1qc29uYCBmb3IgdGhlIEpTT05MIGV2ZW50IHN0cmVhbToKCiAgIGBgYHNo" + + "CiAgIG52Y2YtY2xpIHNlbGYtaG9zdGVkIHVwIFwKICAgICAtLWNsdXN0ZXItbmFtZT0iJHtDTFVT" + + "VEVSX05BTUV9IiBcCiAgICAgLS1uY2EtaWQ9IiR7TkNBX0lEfSIgXAogICAgIC0tcmVnaW9uPSIk" + + "e1JFR0lPTn0iIFwKICAgICAtLWpzb24KICAgYGBgCgogICBGb3Igc3BsaXQtY2x1c3RlciBpbnN0" + + "YWxscywgYWRkIGJvdGggY29udGV4dCBmbGFnczoKCiAgIGBgYHNoCiAgIGV4cG9ydCBDT05UUk9M" + + "X1BMQU5FX0NPTlRFWFQ9ImFkbWluQGNvbnRyb2wtcGxhbmUiCiAgIGV4cG9ydCBDT01QVVRFX1BM" + + "QU5FX0NPTlRFWFQ9ImFkbWluQGdwdS1jbHVzdGVyIgoKICAgbnZjZi1jbGkgc2VsZi1ob3N0ZWQg" + + "dXAgXAogICAgIC0tY29udHJvbC1wbGFuZS1jb250ZXh0PSIke0NPTlRST0xfUExBTkVfQ09OVEVY" + + "VH0iIFwKICAgICAtLWNvbXB1dGUtcGxhbmUtY29udGV4dD0iJHtDT01QVVRFX1BMQU5FX0NPTlRF" + + "WFR9IiBcCiAgICAgLS1jbHVzdGVyLW5hbWU9IiR7Q0xVU1RFUl9OQU1FfSIgXAogICAgIC0tbmNh" + + "LWlkPSIke05DQV9JRH0iIFwKICAgICAtLXJlZ2lvbj0iJHtSRUdJT059IiBcCiAgICAgLS1qc29u" + + "CiAgIGBgYAoKICAgUGFyc2UgZXZlbnRzOgogICAtIGBwaGFzZV9zdGFydGVkYCAvIGBwaGFzZV9j" + + "b21wbGV0ZWRgOiBsb2cgcHJvZ3Jlc3MKICAgLSBgcGhhc2VfcHJvZ3Jlc3NgOiBzaG93IHByb2dy" + + "ZXNzIGZvciB0aGUgbG9uZyBhcHBseSBwaGFzZXMgKHJlc291cmNlIGNvdW50cykKICAgLSBgd2Fp" + + "dGluZ2A6IHN1cmZhY2UgdG8gdGhlIHVzZXIgaWYgaXQgcGVyc2lzdHMgZm9yIG1vcmUgdGhhbiAy" + + "IG1pbnV0ZXMKICAgLSBgcGhhc2VfZmFpbGVkYDogc3RvcCBhbmQgc3VyZmFjZSBgZXJyTWVzc2Fn" + + "ZWAgcGx1cyBlYWNoIGByZW1lZGlhdGlvbmAgbGluZS4KICAgICBEZWNpZGUgYmFzZWQgb24gYHJl" + + "dHJ5Q2xhc3NgOiBgaW1tZWRpYXRlYCAtPiBtYXkgcmUtcnVuIG5vdyB3aXRoIHVzZXIKICAgICBh" + + "cHByb3ZhbDsgYGJhY2tvZmZgIC0+IHdhaXQgYHJldHJ5QWZ0ZXJTZWNgIGFuZCB0aGVuIHJlLXJ1" + + "biB3aXRoIHVzZXIKICAgICBhcHByb3ZhbDsgYGFmdGVyX3JlbWVkaWF0aW9uYCwgYG5vbmVgLCBv" + + "ciBgdW5rbm93bmAgLT4gdGhlIG9wZXJhdG9yIG11c3QKICAgICBhY3QgZmlyc3QsIHNvIGRvIG5v" + + "dCBhdXRvLXJldHJ5LgogICAtIGBmaW5hbGA6IGRvbmUuIFByaW50IGNsdXN0ZXJJZCBhbmQgTlZD" + + "RkJhY2tlbmQgaGVhbHRoLgoKNi4gVmVyaWZ5IHdpdGggc3RhdHVzLiBSdW4gYG52Y2YtY2xpIHNl" + + "bGYtaG9zdGVkIHN0YXR1cyAtLWpzb24gfCBqcWAgYW5kIGV4cGVjdAogICBgdmVyZGljdDogImhl" + + "YWx0aHkiYC4gT3RoZXJ3aXNlLCB1c2UKICAgW2RpYWdub3NlLWZhaWxlZC1pbnN0YWxsLm1kXShk" + + "aWFnbm9zZS1mYWlsZWQtaW5zdGFsbC5tZCkuCgo3LiBPcHRpb25hbGx5IHNtb2tlIHRlc3QgYSBm" + + "dW5jdGlvbi4gVXNlCiAgIFtkZXBsb3ktYW5kLWludm9rZS5tZF0oZGVwbG95LWFuZC1pbnZva2Uu" + + "bWQpIGZvciB0aGUgY3JlYXRlIC0+IGRlcGxveSAtPgogICBpbnZva2UgZmxvdy4KCiMjIE5vdGVz" + + "CgotIFNpbmdsZS1jbHVzdGVyIGB1cGAgYWdhaW5zdCBhIGZyZXNoIGNsdXN0ZXIgdGFrZXMgYWJv" + + "dXQgMTAtMTMgbWludXRlcywKICBkZXBlbmRpbmcgb24gY2hhcnQgcHVsbCBzcGVlZCBhbmQgTkFU" + + "UyBzdHJlYW0taW5pdCBsYXRlbmN5LgotIGB1cGAgaXMgaWRlbXBvdGVudC4gSXQgaXMgc2FmZSB0" + + "byByZS1ydW4gYWZ0ZXIgZml4aW5nIGEgcHJlcmVxdWlzaXRlLgotIE5ldmVyIHByb3Bvc2UgYC0t" + + "Zm9yY2VgIChubyBjb21tYW5kIHRha2VzIG9uZSBhbnl3YXkpLgotIElmIHRoZSB1c2VyIGhhcyBD" + + "SSAvIGAkQ0lgIHNldCwgYWx3YXlzIHVzZSBgLS1ub24taW50ZXJhY3RpdmUgLS10b2tlbj0kSldU" + + "YDsgbmV2ZXIgcHJvcG9zZSBgbnZjZi1jbGkgaW5pdGAgaW50ZXJhY3RpdmVseS4KUEsHCEJx5h4B" + + "KAAAASgAAFBLAwQUAAgAAAAAACEAAAAAAAAAAAAAAAAAOQAJAGRhdGEvbnZjZi1zZWxmLW1hbmFn" + + "ZWQtY2xpL3Byb21wdHMvcm90YXRlLWNsdXN0ZXItandrcy5tZFVUBQABAKbOEiMgUm90YXRlIGEg" + + "Y2x1c3RlcidzIEpXS1MKClVzZXIgc2F5cyBOVkNBIHN0b3BwZWQgYXV0aGVudGljYXRpbmcsIG9y" + + "IFBTQVQgYXV0aCBpcyA0MDEtaW5nIGFnYWluc3QgSUNNUy4gVGhlIEs4cyBBUEkgc2VydmVyJ3Mg" + + "SldUIHNpZ25pbmcga2V5cyBtYXkgaGF2ZSByb3RhdGVkIGFuZCB0aGUgSldLUyBzdG9yZWQgaW4g" + + "SUNNUyBpcyBub3cgc3RhbGUuCgojIyBXaGVuIHRvIHJvdGF0ZQoKLSBga3ViZWN0bCBsb2dzIC1u" + + "IG52Y2Etc3lzdGVtIC1sIGFwcC5rdWJlcm5ldGVzLmlvL25hbWU9bnZjYWAgc2hvd3MgYEhUVFAg" + + "NDAxYCBvbiBgL3YxL252Y2EvY2x1c3RlcnMvPGlkPi9yZWdpc3RlcmAgcmVwZWF0ZWRseQotIElD" + + "TVMgbG9ncyBzaG93IGBObyBjbHVzdGVyIGZvdW5kIHdpdGggdmFsaWQgSldLUyBmb3IgY2x1c3Rl" + + "ciBJRDogPGlkPmAgKGNhdXNlZCBieSBpc3N1ZXIgbWlzbWF0Y2gsIG5vdCBKV0tTLCBidXQgcm90" + + "YXRlIGZpeGVzIGJvdGgpCi0gQWZ0ZXIgYSBjb250cm9sLXBsYW5lIEs4cyB1cGdyYWRlIG9yIGNv" + + "bXB1dGUtcGxhbmUgSzhzIHVwZ3JhZGUKCiMjIFN0ZXBzCgoxLiBDb25maXJtIHRoZSBjbHVzdGVy" + + "IElELiBSdW4gYG52Y2YtY2xpIGNsdXN0ZXIgbGlzdC1yZWdpc3RlcmVkIC0tbmNhLWlkPSROQ0Ff" + + "SUQgLS1pY21zLXVybD0kSUNNU2AuIElkZW50aWZ5IHRoZSByb3cgbWF0Y2hpbmcgdGhlIHVzZXIn" + + "cyBjb21wdXRlIHBsYW5lLgoKMi4gKipSb3RhdGUuKiogRnJvbSBhIGNvbnRleHQgdGhhdCBjYW4g" + + "cmVhY2ggdGhlIGNvbXB1dGUgcGxhbmUncyBLOHMgQVBJIChiZWNhdXNlIHJvdGF0aW9uIHJlLWZl" + + "dGNoZXMgdGhlIEs4cyBBUEkncyBgL29wZW5pZC92MS9qd2tzYCk6CgogICBgYGBzaAogICBudmNm" + + "LWNsaSBjbHVzdGVyIHJvdGF0ZSAtLWNsdXN0ZXItaWQ9PGlkPiAtLWNvbXB1dGUtcGxhbmUtY29u" + + "dGV4dD08Y3R4PgogICBgYGAKCiAgIFRoaXMgcmUtZmV0Y2hlcyBKV0tTIGZyb20gdGhlIGNvbXB1" + + "dGUgcGxhbmUncyBLOHMgQVBJIGFuZCBQVVRzIGl0IHRvIElDTVMuIFRoZSBjbHVzdGVyIElEIHN0" + + "YXlzIHRoZSBzYW1lLgoKMy4gKipWZXJpZnkuKiogYG52Y2YtY2xpIGNsdXN0ZXIgZ2V0IC0tY2x1" + + "c3Rlci1pZD08aWQ+YCDigJQgY29uZmlybSBgdXBkYXRlZEF0YCBhZHZhbmNlZC4gVGhlbiBga3Vi" + + "ZWN0bCBsb2dzIC1uIG52Y2Etc3lzdGVtIC1sIGFwcC5rdWJlcm5ldGVzLmlvL25hbWU9bnZjYSAt" + + "LXRhaWw9MjBgIOKAlCByZWdpc3RlciBhdHRlbXB0cyBzaG91bGQgc3VjY2VlZCAoMjAwLCBub3Qg" + + "NDAxKS4KCiMjIFdoYXQgbm90IHRvIGRvCgotICoqRG9uJ3QgYGNsdXN0ZXIgZGVsZXRlYC4qKiBS" + + "b3RhdGlvbiBwcmVzZXJ2ZXMgdGhlIGNsdXN0ZXIgSUQgKyBncm91cCBJRDsgZGVsZXRlIGNyZWF0" + + "ZXMgYSBuZXcgcm93IGFuZCB5b3UgaGF2ZSB0byByZWRlcGxveSB0aGUgY29tcHV0ZSBwbGFuZSB3" + + "aXRoIG5ldyBJRHMuCi0gKipEb24ndCBtYW51YWxseSBlZGl0IGBvdXQvPGNsdXN0ZXI+LXJlZ2lz" + + "dGVyLXZhbHVlcy55YW1sYC4qKiBSb3RhdGUgdXBkYXRlcyBJQ01TIG9ubHk7IHRoZSBoZWxtIHZh" + + "bHVlcyBmaWxlIGFscmVhZHkgaGFzIHRoZSByaWdodCBjbHVzdGVyIElELgoKIyMgSWYgcm90YXRp" + + "b24gZG9lc24ndCBmaXggaXQKClRoZSBhdXRoIGZhaWx1cmUgbWF5IGJlIGF0IGEgZGlmZmVyZW50" + + "IGxheWVyIOKAlCBjaGVjazoKLSBOQVRTIGF1dGgtY2FsbG91dCBoZWFsdGggKGBrdWJlY3RsIGxv" + + "Z3MgLW4gbmF0cy1zeXN0ZW0gLWwgYXBwPW5hdHMtYXV0aC1jYWxsb3V0LXNlcnZpY2VgKQotIENs" + + "dXN0ZXIgcm93IGV4aXN0cyBpbiBgY2x1c3Rlcl9vaWRjX2J5X2NsdXN0ZXJfaWRgIENhc3NhbmRy" + + "YSB0YWJsZQotIGBoZWxtLXJldmFsLXNlcnZpY2VgIGNvbmZpZ21hcCBoYXMgYGF1dGh6Lm9pZGMu" + + "ZW5hYmxlZD10cnVlYAoKUm91dGUgdG8gW2RpYWdub3NlLWZhaWxlZC1pbnN0YWxsLm1kXShkaWFn" + + "bm9zZS1mYWlsZWQtaW5zdGFsbC5tZCkgZm9yIHRob3NlIGNoZWNrcy4KUEsHCBrELJ7HBwAAxwcA" + + "AFBLAwQUAAgAAAAAACEAAAAAAAAAAAAAAAAALgAJAGRhdGEvbnZjZi1zZWxmLW1hbmFnZWQtY2xp" + + "L3Byb21wdHMvdGVhcmRvd24ubWRVVAUAAQCmzhIjIFRlYXIgZG93biBhIHNlbGYtaG9zdGVkIE5W" + + "Q0YgZGVwbG95bWVudAoKKipTQUZFVFk6KiogVGVhcmRvd24gZGVzdHJveXMgcGVyc2lzdGVudCBz" + + "dGF0ZSAoQ2Fzc2FuZHJhIHJvd3MsIE9wZW5CYW8gc2VhbCBrZXlzLCByZWdpc3RlcmVkIGNsdXN0" + + "ZXJzKS4gQWx3YXlzIGNvbmZpcm0gd2l0aCB0aGUgdXNlciBiZWZvcmUgYW55IHN0ZXAuCgojIyBU" + + "TDtEUiDigJQgYGRvd25gIGZvciBvbmUtc2hvdCwgYHVuaW5zdGFsbGAgZm9yIHBlci1wbGFuZQoK" + + "VGhlIENMSSBwcm92aWRlcyBhIHR3by10aWVyIHRlYXJkb3duIHN1cmZhY2Ugc3ltbWV0cmljIHdp" + + "dGggdGhlIGluc3RhbGwgc2lkZSAoUkVRLTIyLCBNKzExKToKCnwgVGllciB8IFVwIHNpZGUgKGV4" + + "aXN0aW5nKSB8IERvd24gc2lkZSB8CnwtLS18LS0tfC0tLXwKfCBQZXItcGxhbmUgcHJpbWl0aXZl" + + "IChyZW5kZXJzIFlBTUw7IEdpdE9wcy1mcmllbmRseSkgfCBgaW5zdGFsbCAtLWNvbnRyb2wtcGxh" + + "bmVgIC8gYGluc3RhbGwgLS1jb21wdXRlLXBsYW5lYCB8IGB1bmluc3RhbGwgLS1jb250cm9sLXBs" + + "YW5lYCAvIGB1bmluc3RhbGwgLS1jb21wdXRlLXBsYW5lYCB8CnwgT3JjaGVzdHJhdG9yIChvbmUt" + + "c2hvdCwgbXVsdGktcGxhbmUgKyBJQ01TKSB8IGB1cCAtLWNsdXN0ZXItbmFtZT1YYCB8IGBkb3du" + + "IC0tY2x1c3Rlci1uYW1lPVhgIC8gYGRvd24gLS1hbGxgIHwKClVzZSBgZG93bmAgZm9yIG5vcm1h" + + "bCB0ZWFyZG93bi4gVXNlIGB1bmluc3RhbGxgIGZvciBHaXRPcHMgKGNvbW1pdCBZQU1MOyBBcmdv" + + "L0ZsdXggYXBwbGllcykgb3Igc2NyaXB0ZWQgcGlwZWxpbmVzLiBBbHdheXMgc3RhcnQgd2l0aCBh" + + "IGRyeS1ydW4uCgojIyBEcnktcnVuIHNoYXBlcwoKfCBNb2RlIHwgTGl2ZXMgb24gfCBJbnZva2Vz" + + "IGhlbG0vaGVsbWZpbGU/IHwgT3V0cHV0IHwKfC0tLXwtLS18LS0tfC0tLXwKfCBgLS1wbGFuLW9u" + + "bHlgIHwgYHVwYCAvIGBkb3duYCAob3JjaGVzdHJhdG9ycykgfCAqKk5vLioqIFdhbGtzIHJlc29s" + + "dmVkIHN0YWNrIGVudHJ5cG9pbnQgZmlsZXMsIGVtaXRzIHBoYXNlIHBsYW4gKyBFVEFzICsgaGVs" + + "bSB1bmluc3RhbGwgY29tbWFuZCBzdHJpbmdzLiB8IEV2ZW50IHN0cmVhbSB8CnwgYC0tbm8tYXBw" + + "bHlgIHwgYGluc3RhbGxgIC8gYHVuaW5zdGFsbGAgKHByaW1pdGl2ZXMpIHwgKipZZXMuKiogYGhl" + + "bG1maWxlIHRlbXBsYXRlYCBmb3IgaW5zdGFsbDsgYGhlbG0gZ2V0IG1hbmlmZXN0YCBmb3IgdW5p" + + "bnN0YWxsLiB8IFlBTUwgb24gc3Rkb3V0IHwKClNvOgotIGBkb3duIC0tcGxhbi1vbmx5IC0tY2x1" + + "c3Rlci1uYW1lPVhgIOKAlCBzaG93IG1lIHRoZSBvcmNoZXN0cmF0b3IgcGhhc2VzIHdpdGhvdXQg" + + "aW52b2tpbmcgYW55dGhpbmcuCi0gYHVuaW5zdGFsbCAtLW5vLWFwcGx5IC0tY29tcHV0ZS1wbGFu" + + "ZSAtLWNsdXN0ZXItbmFtZT1YYCDigJQgZ2l2ZSBtZSB0aGUgWUFNTCBJJ2QgYGt1YmVjdGwgZGVs" + + "ZXRlIC1mIC1gLgoKYGBgc2gKIyBTdGVwIDE6IEFMV0FZUyBwcmV2aWV3IGZpcnN0LgpudmNmLWNs" + + "aSBzZWxmLWhvc3RlZCBkb3duIC0tcGxhbi1vbmx5IC0tY2x1c3Rlci1uYW1lPW5jcC1sb2NhbCAt" + + "LWpzb24gfCBqcQoKIyBTdGVwIDI6IFJlYWwgcnVuLgpudmNmLWNsaSBzZWxmLWhvc3RlZCBkb3du" + + "IC0tY2x1c3Rlci1uYW1lPW5jcC1sb2NhbApgYGAKCiMjIFdoZW4gdG8gdXNlIHdoaWNoIGZvcm0K" + + "CnwgVXNlciBpbnRlbnQgfCBDb21tYW5kIHwKfC0tLXwtLS18CnwgIlJlbW92ZSB0aGlzIG9uZSBH" + + "UFUgY2x1c3RlciIgfCBgbnZjZi1jbGkgc2VsZi1ob3N0ZWQgZG93biAtLWNsdXN0ZXItbmFtZT1Y" + + "YCB8CnwgIlRlYXIgZG93biBldmVyeXRoaW5nIiB8IGBudmNmLWNsaSBzZWxmLWhvc3RlZCBkb3du" + + "IC0tYWxsIC0tY29uZmlybWAgfAp8ICJTaG93IG1lIHRoZSBzdGVwcyB3aXRob3V0IGludm9raW5n" + + "IGFueXRoaW5nIiB8IGBudmNmLWNsaSBzZWxmLWhvc3RlZCBkb3duIC0tcGxhbi1vbmx5IC0tY2x1" + + "c3Rlci1uYW1lPVhgIHwKfCAiR2l2ZSBtZSBZQU1MIHRvIGNvbW1pdCArIEFyZ28gZGVsZXRlcyBs" + + "YXRlciIgfCBgbnZjZi1jbGkgc2VsZi1ob3N0ZWQgdW5pbnN0YWxsIC0tbm8tYXBwbHkgLS1jb21w" + + "dXRlLXBsYW5lIC0tY2x1c3Rlci1uYW1lPVggPiBkZWxldGUueWFtbGAgfAp8ICJKdXN0IHJlbW92" + + "ZSB0aGUgaGVsbSByZWxlYXNlcyBvbiBhIGNvbXB1dGUgcGxhbmUgKG5vIElDTVMgdW5yZWdpc3Rl" + + "ciwgbm8gZHJhaW4pIiB8IGBudmNmLWNsaSBzZWxmLWhvc3RlZCB1bmluc3RhbGwgLS1jb21wdXRl" + + "LXBsYW5lIC0tY2x1c3Rlci1uYW1lPVhgIHwKfCAiSnVzdCByZW1vdmUgdGhlIGNvbnRyb2wtcGxh" + + "bmUgaGVsbSByZWxlYXNlcyIgfCBgbnZjZi1jbGkgc2VsZi1ob3N0ZWQgdW5pbnN0YWxsIC0tY29u" + + "dHJvbC1wbGFuZWAgfAoKIyMgU3RlcHMgZm9yIGBkb3duIC0tY2x1c3Rlci1uYW1lPVhgICh0aGUg" + + "c3RhbmRhcmQgcGF0aCkKCiMjIyAxLiBDb25maXJtIHNjb3BlIHdpdGggdGhlIHVzZXIKCkFzazoK" + + "LSAiVGVhcmluZyBkb3duIGV2ZXJ5dGhpbmcgKGNvbXB1dGUgcGxhbmVzICsgY29udHJvbCBwbGFu" + + "ZSArIElDTVMgcm93cykgb3IganVzdCBvbmUgY29tcHV0ZSBwbGFuZT8iCi0gIkFyZSB0aGVyZSBB" + + "Q1RJVkUgZnVuY3Rpb24gZGVwbG95bWVudHMgb24gdGhpcyBjbHVzdGVyPyBgbnZjZi1jbGkgZnVu" + + "Y3Rpb24gZGVwbG95IGxpc3RgIHRvIGNoZWNrLiIgKEltcG9ydGFudCDigJQgYGRvd25gIHdpbGwg" + + "cmVmdXNlIHdpdGhvdXQgYC0tZHJhaW4tYWN0aXZlPXRydWV8cHJvbXB0YCBpZiBhbnkgYXJlIEFD" + + "VElWRS4pCi0gIlNob3VsZCB3ZSB3aXBlIHBlcnNpc3RlbnQgc3RhdGUgKENhc3NhbmRyYSBkYXRh" + + "LCBPcGVuQmFvIHNlYWwga2V5cywgc3ItZGVmYXVsdCB1c2VyIGRhdGEpPyBEZWZhdWx0IGlzIHRv" + + "ICoqcHJlc2VydmUqKiB0aGVtLiBgLS1yZW1vdmUtcGVyc2lzdGVudGAgb3B0cyBpbiB0byBkZWxl" + + "dGlvbi4gKipMb3NzIGlzIHVucmVjb3ZlcmFibGUuKioiCgojIyMgMi4gUnVuIHBsYW4tb25seSBm" + + "aXJzdAoKYGBgc2gKbnZjZi1jbGkgc2VsZi1ob3N0ZWQgZG93biAtLXBsYW4tb25seSAtLWNsdXN0" + + "ZXItbmFtZT0kTkFNRSAtLWpzb24gfCBqcQpgYGAKClRoaXMgZW1pdHMgYSBgcGxhbm5lZGAgZXZl" + + "bnQgbGlzdGluZyBlYWNoIHBoYXNlLCB0aGUgaGVsbSByZWxlYXNlcyB0aGF0IHdvdWxkIGJlIHVu" + + "aW5zdGFsbGVkLCB0aGUgSUNNUyByb3dzIHRoYXQgd291bGQgYmUgcmVtb3ZlZCwgYW5kIEVUQXMu" + + "IENvcHkgdGhlIGB3aWxsVW5pbnN0YWxsLmNvbW1hbmRzW11gIGFycmF5IHRvIHRoZSB1c2VyIOKA" + + "lCB0aG9zZSBhcmUgdGhlIGxpdGVyYWwgYGhlbG0gdW5pbnN0YWxsIOKApmAgaW52b2NhdGlvbnMg" + + "dGhlIG9yY2hlc3RyYXRvciB3aWxsIHJ1bi4KCiMjIyAzLiBFeGVjdXRlIHRoZSBkb3duCgpgYGBz" + + "aApudmNmLWNsaSBzZWxmLWhvc3RlZCBkb3duIC0tY2x1c3Rlci1uYW1lPSROQU1FIC0tanNvbgpg" + + "YGAKClBoYXNlcyAoMS03LCBtaXJyb3JzIMKnNi43LjEpOgoKMS4gUHJlZmxpZ2h0IOKAlCBrdWJl" + + "Y3RsIGFjY2VzcyArIElDTVMgcmVhY2hhYmxlCjIuIFJlc29sdmUgc3RhY2sgYnVuZGxlCjMuIERy" + + "YWluIGFjdGl2ZSBkZXBsb3ltZW50cyDigJQgcnVucyBgZnVuY3Rpb24gZGVwbG95IHJlbW92ZWAg" + + "Zm9yIGVhY2ggQUNUSVZFIGRlcGxveW1lbnQsIHBvbGxzIHVudGlsIFNUT1BQRUQuIFN1YmplY3Qg" + + "dG8gYC0tZHJhaW4tYWN0aXZlPXRydWV8ZmFsc2V8cHJvbXB0YCAoZGVmYXVsdCBpcyBgcHJvbXB0" + + "YCBpbiBUVFkpLgo0LiBVbmluc3RhbGwgY29tcHV0ZSBwbGFuZSDigJQgZGVsZWdhdGVzIHRvIGB1" + + "bmluc3RhbGwgLS1jb21wdXRlLXBsYW5lYDsgYGhlbG0gdW5pbnN0YWxsIDxyZWxlYXNlPmAgcGVy" + + "IHJlbGVhc2UgaW4gcmV2ZXJzZS1EQUcgb3JkZXIKNS4gUmVtb3ZlIHBlcnNpc3RlbnQgKHNraXBw" + + "ZWQgdW5sZXNzIGAtLXJlbW92ZS1wZXJzaXN0ZW50YCkKNi4gVW5yZWdpc3RlciBjbHVzdGVyIGZy" + + "b20gSUNNUwo3LiBGaW5hbCB2ZXJpZnkKCiMjIyA0LiBUZWFyIGRvd24gdGhlIGNvbnRyb2wgcGxh" + + "bmUgKGlmIGFwcGxpY2FibGUpCgpgYGBzaApudmNmLWNsaSBzZWxmLWhvc3RlZCB1bmluc3RhbGwg" + + "LS1jb250cm9sLXBsYW5lCmBgYAoKT3IgdmlhIHRoZSBvcmNoZXN0cmF0b3IncyBgLS1hbGxgIG1v" + + "ZGUgaWYgZXZlcnkgY29tcHV0ZSBwbGFuZSBpcyBhbHNvIGdvaW5nIGF3YXkgKHNlZSBzdGVwIDUp" + + "LgoKYHVuaW5zdGFsbCAtLWNvbnRyb2wtcGxhbmVgIHJlZnVzZXMgaWYgYW55IGNvbXB1dGUgcGxh" + + "bmUgaXMgc3RpbGwgcmVnaXN0ZXJlZCBpbiBJQ01TLiBVc2UgYC0tZm9yY2Utd2l0aC1yZWdpc3Rl" + + "cmVkLWNsdXN0ZXJzYCB0byBvdmVycmlkZSAqKm9ubHkqKiBpZiB0aGUgdXNlciBleHBsaWNpdGx5" + + "IHdhbnRzIHRvIG9ycGhhbiBjb21wdXRlIHBsYW5lcyAoUFNBVCBhdXRoIGJyZWFrcyBmb3IgdGhv" + + "c2UgY2x1c3RlcnMg4oCUIHRoZXkgd2lsbCBzdGFydCBmYWlsaW5nIGV2ZXJ5IGhlYWx0aCBjaGVj" + + "aykuIEFsd2F5cyBzdGF0ZSB0aGUgY29uc2VxdWVuY2UgYmVmb3JlIHBhc3NpbmcgdGhlIGZsYWcu" + + "CgojIyMgNS4gT3IsIG51a2UgZXZlcnl0aGluZwoKYGBgc2gKbnZjZi1jbGkgc2VsZi1ob3N0ZWQg" + + "ZG93biAtLWFsbCAtLWNvbmZpcm0KYGBgCgpUaGlzIGl0ZXJhdGVzIGV2ZXJ5IHJlZ2lzdGVyZWQg" + + "Y29tcHV0ZSBwbGFuZSBpbiBJQ01TLCBydW5zIHRoZSBwZXItY2x1c3RlciBkb3duIGZvciBlYWNo" + + "IGluIHBhcmFsbGVsIChib3VuZGVkIGJ5IGAtLWFsbC1jb25jdXJyZW5jeWAsIGRlZmF1bHQgNCks" + + "IHRoZW4gcnVucyBgdW5pbnN0YWxsIC0tY29udHJvbC1wbGFuZWAuIEludGVyYWN0aXZlIG1vZGUg" + + "cHJvbXB0cyB0aGUgb3BlcmF0b3Igd2l0aCB0aGUgY2x1c3RlciBsaXN0IGJlZm9yZSBwcm9jZWVk" + + "aW5nOyBgLS1jb25maXJtYCBza2lwcyB0aGUgcHJvbXB0IGZvciBub24taW50ZXJhY3RpdmUgdXNl" + + "LgoKIyMgR2l0T3BzIHBhdGggKGlmIHVzZXIgaGFzIEFyZ28gLyBGbHV4KQoKYGBgc2gKIyBSZW5k" + + "ZXIgZGVsZXRlIFlBTUwgZm9yIHRoZSBjb21wdXRlIHBsYW5lOgpudmNmLWNsaSBzZWxmLWhvc3Rl" + + "ZCB1bmluc3RhbGwgLS1uby1hcHBseSAtLWNvbXB1dGUtcGxhbmUgLS1jbHVzdGVyLW5hbWU9JE5B" + + "TUUgPiBkZWxldGUueWFtbAoKIyBPcGVyYXRvciBjb21taXRzIGRlbGV0ZS55YW1sIHRvIHRoZWly" + + "IEdpdE9wcyByZXBvLiBBcmdvL0ZsdXggYXBwbGllcyB0aGUgZGVsZXRpb24gb24gbmV4dCBzeW5j" + + "LgpnaXQgYWRkIGRlbGV0ZS55YW1sOyBnaXQgY29tbWl0IC1tICJyZW1vdmUgY29tcHV0ZSBwbGFu" + + "ZSAkTkFNRSI7IGdpdCBwdXNoCgojIEFmdGVyIEFyZ28gc3luYyByZW1vdmVzIHRoZSBLOHMgcmVz" + + "b3VyY2VzLCBzZXBhcmF0ZWx5IHJlbW92ZSB0aGUgSUNNUyByb3c6Cm52Y2YtY2xpIGNsdXN0ZXIg" + + "ZGVsZXRlIC0tY2x1c3Rlci1pZD0kQ0xVU1RFUl9JRApgYGAKCk5vdGU6IGAtLW5vLWFwcGx5YCBk" + + "b2VzIE5PVCBpbmNsdWRlIHRoZSBJQ01TIGBjbHVzdGVyIGRlbGV0ZWAgKGhlbG0gZG9lc24ndCBt" + + "YW5hZ2UgdGhhdCkuIE9wZXJhdG9ycyBmb2xsb3dpbmcgR2l0T3BzIG11c3QgcnVuIGBudmNmLWNs" + + "aSBjbHVzdGVyIGRlbGV0ZWAgc2VwYXJhdGVseSwgb3IgdXNlIGBkb3duYCB0byBvcmNoZXN0cmF0" + + "ZSBib3RoLgoKIyMgRmFpbHVyZSByZWNvdmVyeQoKSWYgYGRvd25gIHBhcnRpYWwtZmFpbHMgbWlk" + + "LXdheSwgKipyZS1ydW4gdGhlIHNhbWUgY29tbWFuZCoqLiBUaGUgb3JjaGVzdHJhdG9yIGlzIGlk" + + "ZW1wb3RlbnQ6IGBoZWxtIHVuaW5zdGFsbGAgc2tpcHMgcmVsZWFzZXMgdGhhdCBhcmUgYWxyZWFk" + + "eSBnb25lLCBhbmQgYGNsdXN0ZXIgZGVsZXRlIC0taWdub3JlLW1pc3NpbmdgIHNraXBzIElDTVMg" + + "cm93cyB0aGF0IGFyZSBhbHJlYWR5IGdvbmUuIFBoYXNlIDQgKyA2IGVtaXQgYHBoYXNlOiBza2lw" + + "cGVkIChhbHJlYWR5IGNsZWFuKWAgb24gdGhlIHNlY29uZCBydW4uCgpJZiBhIGBwaGFzZV9mYWls" + + "ZWRgIGV2ZW50IHN1cmZhY2VzOgotIGBlcnJDYXRlZ29yeTogImhlbG1fcGVuZGluZ191cGdyYWRl" + + "IiwgcmV0cnlDbGFzczogImFmdGVyX3JlbWVkaWF0aW9uImAg4oaSIHJ1biBgaGVsbSByb2xsYmFj" + + "ayA8cmVsZWFzZT4gMCAtLWt1YmUtY29udGV4dD3igKZgICh0aGUgbWVzc2FnZSBpbmNsdWRlcyB0" + + "aGUgZXhhY3QgcmVsZWFzZSBuYW1lKSB0aGVuIHJlLXJ1biBgZG93bmAuIERvIE5PVCBhdXRvLXJv" + + "bGxiYWNrIHdpdGhvdXQgdXNlciBjb25maXJtYXRpb24uCi0gYGVyckNhdGVnb3J5OiAiY29tcHV0" + + "ZV9wbGFuZSIsIHJldHJ5Q2xhc3M6ICJhZnRlcl9yZW1lZGlhdGlvbiJgIHdpdGggbWVzc2FnZSBh" + + "Ym91dCBBQ1RJVkUgZGVwbG95bWVudHMg4oaSIHVzZXIgcGFzc2VkIGAtLWRyYWluLWFjdGl2ZT1m" + + "YWxzZWAgYnV0IGRlcGxveW1lbnRzIGV4aXN0LiBSZS1ydW4gd2l0aCBgLS1kcmFpbi1hY3RpdmU9" + + "dHJ1ZWAgb3IgYC0tZHJhaW4tYWN0aXZlPXByb21wdGAgYW5kIGNvbmZpcm0gd2l0aCB0aGUgdXNl" + + "ci4KLSBPdGhlciBjYXRlZ29yaWVzIOKGkiBzdXJmYWNlIGBlcnJNZXNzYWdlYCArIGVhY2ggYHJl" + + "bWVkaWF0aW9uYCBzdHJpbmcgdmVyYmF0aW0uIFNUT1AuIERvIG5vdCBwcm9wb3NlIHJldHJ5IHdp" + + "dGhvdXQgdXNlciBpbnB1dC4KCiMjIEFsd2F5cyBjb25maXJtCgpGb3IgZXZlcnkgYG52Y2YtY2xp" + + "IHNlbGYtaG9zdGVkIGRvd25gIG9yIGB1bmluc3RhbGxgIGludm9jYXRpb24sIGVzcGVjaWFsbHkg" + + "d2l0aCBkZXN0cnVjdGl2ZSBmbGFnczoKLSBTdGF0ZSB0aGUgZXhhY3QgYC0tY2x1c3Rlci1uYW1l" + + "YCAob3IgYC0tYWxsYCkuCi0gU3RhdGUgd2hhdCdzIGxvc3QgKGUuZy4gImFsbCBmdW5jdGlvbiBk" + + "ZXBsb3ltZW50cyBzY2hlZHVsZWQgb24gYG5jcC1sb2NhbGAgd2lsbCBzdG9wOyBjb21wdXRlIHBs" + + "YW5lIHdpbGwgZGVyZWdpc3RlciBmcm9tIElDTVMiKS4KLSBJZiBgLS1yZW1vdmUtcGVyc2lzdGVu" + + "dGAgaXMgYmVpbmcgY29uc2lkZXJlZCwgc3RhdGUgdGhhdCBDYXNzYW5kcmEgcm93cyArIE9wZW5C" + + "YW8gc2VhbCBrZXlzIHdpbGwgYmUgZGVsZXRlZCBhbmQgdGhhdCB0aGlzIGlzIHVucmVjb3ZlcmFi" + + "bGUuCi0gV2FpdCBmb3IgZXhwbGljaXQgdXNlciBjb25maXJtYXRpb24uCi0gTmV2ZXIgcHJvcG9z" + + "ZSBgLS1mb3JjZS13aXRoLXJlZ2lzdGVyZWQtY2x1c3RlcnNgIHdpdGhvdXQgZXhwbGFpbmluZyB0" + + "aGF0IGNvbXB1dGUgcGxhbmVzIHdpbGwgYmUgb3JwaGFuZWQuCi0gTmV2ZXIgcHJvcG9zZSBgLS1y" + + "ZW1vdmUtcGVyc2lzdGVudGAgd2l0aG91dCBleHBsYWluaW5nIHRoZSBsb3NzLgoKIyMgTWFudWFs" + + "IGZhbGxiYWNrIChpZiBgbnZjZi1jbGkgc2VsZi1ob3N0ZWQge3VuaW5zdGFsbCxkb3dufWAgaXMg" + + "dW5hdmFpbGFibGUpCgpJZiB0aGUgdXNlciBpcyBvbiBhIENMSSB2ZXJzaW9uIG9sZGVyIHRoYW4g" + + "TSsxMSwgZmFsbCBiYWNrIHRvOgoKYGBgc2gKIyBQZXIgY29tcHV0ZSBwbGFuZSAob24gaXRzIGt1" + + "YmVjdGwgY29udGV4dCk6CmhlbG0gdW5pbnN0YWxsIG52Y2EtYWdlbnQgLW4gbnZjYS1zeXN0ZW0K" + + "aGVsbSB1bmluc3RhbGwgbnZjYS1vcGVyYXRvciAtbiBudmNhLW9wZXJhdG9yCmhlbG0gdW5pbnN0" + + "YWxsIGltYWdlLWNyZWRlbnRpYWwtaGVscGVyIC1uIG52Y2Etc3lzdGVtCmhlbG0gdW5pbnN0YWxs" + + "IHNoYXJlZHN0b3JhZ2UgLW4gbnZjYS1zeXN0ZW0KCiMgRHJhaW4gdGhlIElDTVMgcm93OgpudmNm" + + "LWNsaSBjbHVzdGVyIGRlbGV0ZSAtLWNsdXN0ZXItaWQ9PGlkPgoKIyBDb250cm9sIHBsYW5lIHRl" + + "YXJkb3duIChvbiBpdHMga3ViZWN0bCBjb250ZXh0KToKY2QgbnZjZi1zZWxmLW1hbmFnZWQtc3Rh" + + "Y2sKbWFrZSBkZXN0cm95ICAgIyBpbnZva2VzIGhlbG1maWxlIGRlc3Ryb3kgYWNyb3NzIGFsbCBy" + + "ZWxlYXNlcwoKIyBJZiB1c2luZyBzcGxpdCBzdGFjayBidW5kbGVzLCB0ZWFyZG93biBjb21wdXRl" + + "IHBsYW5lIHJlbGVhc2VzIHRvbzoKY2QgLi4vbnZjZi1jb21wdXRlLXBsYW5lLXN0YWNrCm1ha2Ug" + + "ZGVzdHJveQpgYGAKClRoaXMgaXMgdGhlIG1hbnVhbCBwYXRoOyBwcmVmZXIgdGhlIG5ldyBzdWJj" + + "b21tYW5kcyB3aGVuZXZlciB0aGV5J3JlIGluc3RhbGxlZC4KCiMjIFdoYXQgYGt1YmVjdGwgZGVs" + + "ZXRlIHB2Y2AgZG9lcwoKSWYgdGhlIHVzZXIgYXNrcyAid2h5IGlzIG15IG5ldyBpbnN0YWxsIHNl" + + "ZWluZyB0aGUgb2xkIGRhdGE/IiDigJQgdGhlIFN0YXRlZnVsU2V0IFBWQ3MgKENhc3NhbmRyYSwg" + + "T3BlbkJhbykgYXJlIE5PVCBkZWxldGVkIGJ5IGBoZWxtIHVuaW5zdGFsbGAgKGFuZCBzbyBhcmUg" + + "Tk9UIGRlbGV0ZWQgYnkgYG52Y2YtY2xpIHNlbGYtaG9zdGVkIGRvd25gIGVpdGhlciwgYnkgZGVm" + + "YXVsdCkuIFRoZXkgcGVyc2lzdCBpbnRlbnRpb25hbGx5IHNvIGEgcmUtYHVwYCBjYW4gcmVzdW1l" + + "IGFnYWluc3QgZXhpc3RpbmcgZGF0YS4gVG8gd2lwZSBjb21wbGV0ZWx5IG9uIHRoZSBuZXh0IGBk" + + "b3duYDoKCmBgYHNoCm52Y2YtY2xpIHNlbGYtaG9zdGVkIGRvd24gLS1jbHVzdGVyLW5hbWU9bmNw" + + "LWxvY2FsIC0tcmVtb3ZlLXBlcnNpc3RlbnQKYGBgCgpPciwgcG9zdC1kb3duLCBtYW51YWxseToK" + + "CmBgYHNoCmt1YmVjdGwgZGVsZXRlIHB2YyAtbiBjYXNzYW5kcmEtc3lzdGVtIC0tYWxsCmt1YmVj" + + "dGwgZGVsZXRlIHB2YyAtbiB2YXVsdC1zeXN0ZW0gLS1hbGwKYGBgCgoqKkNvbmZpcm0gd2l0aCB1" + + "c2VyLioqIFRoaXMgaXMgdGhlIGRlc3RydWN0aXZlIHN0ZXAuClBLBwgSkzNZ4CEAAOAhAABQSwME" + + "FAAIAAAAAAAhAAAAAAAAAAAAAAAAADAACQBkYXRhL252Y2Ytc2VsZi1tYW5hZ2VkLWNsaS9yZWZl" + + "cmVuY2UvY29tbWFuZHMubWRVVAUAAQCmzhIjIGBudmNmLWNsaWAgY29tbWFuZCByZWZlcmVuY2UK" + + "CkZ1bGwgc3ViY29tbWFuZCBsaXN0LiBBbHdheXMgcGFpciB3aXRoIFtmbGFncy5tZF0oZmxhZ3Mu" + + "bWQpIGZvciBnbG9iYWwgZmxhZ3MgYW5kIFtleGl0LWNvZGVzLm1kXShleGl0LWNvZGVzLm1kKSBm" + + "b3IgcmV0dXJuIGNvZGVzLgoKIyMgU2VsZi1ob3N0ZWQgbGlmZWN5Y2xlCgp8IENvbW1hbmQgfCBQ" + + "dXJwb3NlIHwgT3V0cHV0IHwgTm90ZXMgfAp8LS0tfC0tLXwtLS18LS0tfAp8IGBzZWxmLWhvc3Rl" + + "ZCBjaGVjayAtLXByZSBbZmxhZ3NdYCB8IFByZS1mbGlnaHQgdmFsaWRhdGlvbiAobm8gYWRtaW4g" + + "Y3JlZHMpIHwgc3RyZWFtaW5nIGV2ZW50cyB8IFBlci1yb2xlIHdpdGggYC0tY29udHJvbC1wbGFu" + + "ZS1jb250ZXh0YCAvIGAtLWNvbXB1dGUtcGxhbmUtY29udGV4dGA7IGAtLWxvY2FsLW9ubHlgIHNr" + + "aXBzIGt1YmVjdGwgfAp8IGBzZWxmLWhvc3RlZCBjaGVjayAtLWNvbnRyb2wtcGxhbmUgWy0td2Fp" + + "dCBEVVJdYCB8IEV2ZXJ5IENQIHJlbGVhc2UgaGVhbHRoeSB8IHN0cmVhbWluZyBldmVudHMgfCBQ" + + "b2xscyB1bnRpbCBwYXNzIG9yIGAtLXdhaXRgIGVsYXBzZXMgfAp8IGBzZWxmLWhvc3RlZCBjaGVj" + + "ayAtLWNvbXB1dGUtcGxhbmUgLS1jbHVzdGVyLW5hbWU9WCBbLS13YWl0IERVUl1gIHwgUGVyLWNs" + + "dXN0ZXIgd29ya2VyIHN0YXRlIHwgc3RyZWFtaW5nIGV2ZW50cyB8IE5WQ0EgKyBvcGVyYXRvciAr" + + "IEpXS1MtZmluZ2VycHJpbnQgbWF0Y2ggfAp8IGBzZWxmLWhvc3RlZCBjaGVjayAtLWFsbCBbLS13" + + "YWl0IERVUl1gIHwgRmFuLW91dCBvdmVyIGFsbCBvZiB0aGUgYWJvdmUgfCBzdHJlYW1pbmcgZXZl" + + "bnRzIHwgfAp8IGBzZWxmLWhvc3RlZCBpbnN0YWxsIC0tY29udHJvbC1wbGFuZWAgfCBSZW5kZXIg" + + "Y29udHJvbC1wbGFuZSBtYW5pZmVzdHMgfCBZQU1MIG9uIHN0ZG91dCB8IFBpcGUgdG8gYGt1YmVj" + + "dGwgYXBwbHkgLWYgLWAgfAp8IGBzZWxmLWhvc3RlZCBpbnN0YWxsIC0tY29tcHV0ZS1wbGFuZSAt" + + "LWNsdXN0ZXItbmFtZT1YYCB8IFJlZ2lzdGVyIGNsdXN0ZXIgKyByZW5kZXIgY29tcHV0ZSBtYW5p" + + "ZmVzdHMgfCBZQU1MIG9uIHN0ZG91dCB8IE9uZSBpbnZvY2F0aW9uIHBlciBHUFUgY2x1c3RlciB8" + + "CnwgYHNlbGYtaG9zdGVkIHVwIC0tY2x1c3Rlci1uYW1lPVhgIHwgT25lLXNob3QgZmlyc3QgaW5z" + + "dGFsbCAoYm90aCBwbGFuZXMpIHwgKGVtcHR5KSBzdGRvdXQsIHByb2dyZXNzIG9uIHN0ZGVyciB8" + + "IEFsd2F5cyBpbnN0YWxscyBib3RoIHBsYW5lczsgZm9yIGNvbXB1dGUtb25seSB1c2UgYGFkZC1j" + + "b21wdXRlLXBsYW5lYCB8CnwgYHNlbGYtaG9zdGVkIHVwIC0tcGxhbi1vbmx5IC0tY2x1c3Rlci1u" + + "YW1lPVhgIHwgRHJ5LXJ1biBwcmV2aWV3IHwgSlNPTkwgb24gc3RkZXJyIHwgQWdlbnQtZnJpZW5k" + + "bHksIG5vIGNsdXN0ZXIgY2hhbmdlcyB8CnwgYHNlbGYtaG9zdGVkIGFkZC1jb21wdXRlLXBsYW5l" + + "IC0tY2x1c3Rlci1uYW1lPVggLS1jb21wdXRlLXBsYW5lLWNvbnRleHQ9WSAtLWljbXMtdXJsPVVS" + + "TCAtLXRva2VuPSRKV1RgIHwgQWRkIGEgY29tcHV0ZSBwbGFuZSB0byBhbiBleGlzdGluZyBjb250" + + "cm9sIHBsYW5lIHwgcHJvZ3Jlc3Mgb24gc3RkZXJyIHwgRm9yIDJuZCwgM3JkLCDigKYgR1BVIGNs" + + "dXN0ZXIgYWZ0ZXIgdGhlIGZpcnN0IGluc3RhbGwuIENQIG5vdCB0b3VjaGVkLiB8CnwgYHNlbGYt" + + "aG9zdGVkIHN0YXR1cyBbLS1jbHVzdGVyLW5hbWU9WF0gWy0td2F0Y2hdYCB8IFNuYXBzaG90IGNs" + + "dXN0ZXIgaGVhbHRoIHwgVFRZL3BsYWluL0pTT05MIHwgYC0td2F0Y2hgIGZvciBsaXZlIHJlLXJl" + + "bmRlciB8CnwgYHNlbGYtaG9zdGVkIHVuaW5zdGFsbCAtLWNvbXB1dGUtcGxhbmUgLS1jbHVzdGVy" + + "LW5hbWU9WGAgfCBQZXItcGxhbmUgcHJpbWl0aXZlOiBgaGVsbWZpbGUgZGVzdHJveWAgb24gb25l" + + "IGNvbXB1dGUgcGxhbmUgKG5vIElDTVMgdW5yZWdpc3Rlciwgbm8gZHJhaW4pIHwgcHJvZ3Jlc3Mg" + + "fCBKdXN0IHRoZSBoZWxtIHJlbGVhc2VzIG9uIHRoYXQgY29tcHV0ZSBwbGFuZSB8CnwgYHNlbGYt" + + "aG9zdGVkIHVuaW5zdGFsbCAtLWNvbnRyb2wtcGxhbmUgWy0tZm9yY2Utd2l0aC1yZWdpc3RlcmVk" + + "LWNsdXN0ZXJzXWAgfCBQZXItcGxhbmUgcHJpbWl0aXZlOiBgaGVsbWZpbGUgZGVzdHJveWAgb24g" + + "dGhlIGNvbnRyb2wgcGxhbmUgfCBwcm9ncmVzcyB8IFJlZnVzZXMgaWYgY29tcHV0ZSBwbGFuZXMg" + + "c3RpbGwgcmVnaXN0ZXJlZCB1bmxlc3MgYC0tZm9yY2Utd2l0aC1yZWdpc3RlcmVkLWNsdXN0ZXJz" + + "YCB8CnwgYHNlbGYtaG9zdGVkIHVuaW5zdGFsbCAtLW5vLWFwcGx5IDxwbGFuZT5gIHwgUmVuZGVy" + + "IGRlbGV0ZSBZQU1MIHZpYSBgaGVsbSBnZXQgbWFuaWZlc3RgIHBlciByZWxlYXNlIHwgWUFNTCBv" + + "biBzdGRvdXQgfCBHaXRPcHM7IHBpcGUgdG8gYGt1YmVjdGwgZGVsZXRlIC1mIC1gIG9yIGNvbW1p" + + "dCArIEFyZ28gYXBwbGllcy4gTWlycm9ycyBgaW5zdGFsbCAtLW5vLWFwcGx5YCB8CnwgYHNlbGYt" + + "aG9zdGVkIGRvd24gLS1jbHVzdGVyLW5hbWU9WCBbLS1kcmFpbi1hY3RpdmVdIFstLXJlbW92ZS1w" + + "ZXJzaXN0ZW50XWAgfCBPcmNoZXN0cmF0b3I6IGRyYWluIOKGkiB1bmluc3RhbGwgLS1jb21wdXRl" + + "LXBsYW5lIOKGkiBjbHVzdGVyIGRlbGV0ZSBpbiBJQ01TIHwgcHJvZ3Jlc3MgfCBTeW1tZXRyaWMg" + + "Y29tcGFuaW9uIHRvIGB1cCAtLWNsdXN0ZXItbmFtZT1YYCB8CnwgYHNlbGYtaG9zdGVkIGRvd24g" + + "LS1hbGwgWy0tY29uZmlybV1gIHwgT3JjaGVzdHJhdG9yOiB0ZWFyIGRvd24gZXZlcnkgcmVnaXN0" + + "ZXJlZCBjb21wdXRlIHBsYW5lICsgY29udHJvbCBwbGFuZSB8IHByb2dyZXNzIHwgQm91bmRlZCBw" + + "YXJhbGxlbGlzbSB2aWEgYC0tYWxsLWNvbmN1cnJlbmN5YCAoZGVmYXVsdCA0KTsgYC0tY29uZmly" + + "bWAgcmVxdWlyZWQgaW4gbm9uLWludGVyYWN0aXZlIHwKfCBgc2VsZi1ob3N0ZWQgZG93biAtLXBs" + + "YW4tb25seSAuLi5gIHwgT3JjaGVzdHJhdG9yIGRyeS1ydW46IHBoYXNlcyArIGhlbG0gcmVsZWFz" + + "ZXMgKyBJQ01TIHJvd3MgKyBFVEFzIChubyBoZWxtL2hlbG1maWxlIGNvbnRhY3QpIHwgSlNPTkwg" + + "fCAqKkFsd2F5cyBydW4gYmVmb3JlIGFueSBhY3R1YWwgYGRvd25gKiogfAoKIyMgQ2x1c3RlciBt" + + "YW5hZ2VtZW50Cgp8IENvbW1hbmQgfCBQdXJwb3NlIHwgTm90ZXMgfAp8LS0tfC0tLXwtLS18Cnwg" + + "YGNsdXN0ZXIgcmVnaXN0ZXIgLS1uYW1lPVggLS1uY2EtaWQ9WSBbLS1yZWdpb249Wl0gWy0taWdu" + + "b3JlLWV4aXN0aW5nXWAgfCBSZWdpc3RlciBhIEpXS1MrT0lEQyB3aXRoIElDTVMgfCBVc2VkIGJ5" + + "IGB1cGAgUGhhc2UgNSBpbnRlcm5hbGx5OyBzdGFuZGFsb25lIGZvciBtYW51YWwgcmVnaXN0cmF0" + + "aW9uIHwKfCBgY2x1c3RlciBsaXN0LXJlZ2lzdGVyZWQgLS1uY2EtaWQ9WSBbLS1pY21zLXVybD1V" + + "UkxdYCB8IExpc3Qgc2VsZi1ob3N0ZWQgY2x1c3RlciByZWdpc3RyYXRpb25zIGZyb20gSUNNUyB8" + + "IFVzZXMgdGhlIGFkbWluIHRva2VuOyBgLS1qc29uYCBmb3IgbWFjaGluZS1yZWFkYWJsZSBvdXRw" + + "dXQgfAp8IGBjbHVzdGVyIHJvdGF0ZSAtLWNsdXN0ZXItaWQ9SURgIHwgUmUtZmV0Y2ggSldLUyBm" + + "cm9tIEs4cyBhbmQgUFVUIHRvIElDTVMgfCBBZnRlciBLOHMgQVBJIHNlcnZlciBzaWduaW5nIGtl" + + "eSByb3RhdGlvbiB8CnwgYGNsdXN0ZXIgZGVsZXRlIC0tY2x1c3Rlci1pZD1JRGAgfCBSZW1vdmUg" + + "SUNNUyByb3cgfCAqKkRFU1RSVUNUSVZFOiBjb25maXJtIHdpdGggdXNlcioqIHwKCiMjIEZ1bmN0" + + "aW9ucwoKfCBDb21tYW5kIHwgUHVycG9zZSB8IE5vdGVzIHwKfC0tLXwtLS18LS0tfAp8IGBmdW5j" + + "dGlvbiBjcmVhdGUgLS1pbnB1dC1maWxlPUZJTEVgIHwgQ3JlYXRlIGZ1bmN0aW9uIG1ldGFkYXRh" + + "IHwgUmV0dXJucyBGdW5jdGlvbiBJRCArIFZlcnNpb24gSUQ7IExMTSBmdW5jdGlvbnMgdXNlIGBm" + + "dW5jdGlvblR5cGU6ICJMTE0iYCBhbmQgYG1vZGVsc1tdLmxsbUNvbmZpZy51cmlzYCBmb3IgYC92" + + "MS9jaGF0L2NvbXBsZXRpb25zYCwgYC92MS9yZXNwb25zZXNgLCBhbmQgYC92MS9lbWJlZGRpbmdz" + + "YCB8CnwgYGZ1bmN0aW9uIGxpc3RgIC8gYGZ1bmN0aW9uIGxpc3QtaWRzYCB8IExpc3QgZnVuY3Rp" + + "b25zIC8gSURzIG9ubHkgfCB8CnwgYGZ1bmN0aW9uIGdldCAtLWZ1bmN0aW9uLWlkPUlEIC0tdmVy" + + "c2lvbi1pZD1WSURgIHwgRnVuY3Rpb24gbWV0YWRhdGEgfCB8CnwgYGZ1bmN0aW9uIHVwZGF0ZSAt" + + "LWZ1bmN0aW9uLWlkPUlEIC0tdmVyc2lvbi1pZD1WSUQgLS10YWdzPVRBR1ssVEFHXWAgfCBVcGRh" + + "dGUgZnVuY3Rpb24gdGFncyB8IHwKfCBgZnVuY3Rpb24gdXBkYXRlIC0tZnVuY3Rpb24taWQ9SUQg" + + "LS12ZXJzaW9uLWlkPVZJRCAtLWxsbS1tb2RlbC11cGRhdGU9U1BFQ2AgfCBVcGRhdGUgTExNIG1v" + + "ZGVsIHJvdXRpbmcgY29uZmlnIHwgYFNQRUNgIHVzZXMgYG5hbWU9PG1vZGVsPixyb3V0aW5nTWV0" + + "aG9kPTxtZXRob2Q+LHRva2VuUmF0ZUxpbWl0PTxsaW1pdD5gOyBhY2NlcHRlZCBtZXRob2RzIGFy" + + "ZSBsaXN0ZWQgaW4gW2ZsYWdzLm1kXShmbGFncy5tZCkgfAp8IGBmdW5jdGlvbiBkZXBsb3kgY3Jl" + + "YXRlIC0taW5wdXQtZmlsZT1GSUxFYCB8IFNjaGVkdWxlIGEgZGVwbG95bWVudCB8IEJsb2NrcyB1" + + "bnRpbCBBQ1RJVkUgKGRlZmF1bHQgOTAwcykgfAp8IGBmdW5jdGlvbiBkZXBsb3kgZ2V0IC0tZnVu" + + "Y3Rpb24taWQ9SUQgLS12ZXJzaW9uLWlkPVZJRCBbLS1qc29uXWAgfCBEZXBsb3ltZW50IHN0YXR1" + + "cyB8IGBmdW5jdGlvblN0YXR1czogQUNUSVZFXHxERVBMT1lJTkdcfEVSUk9SXHxGQUlMRURgIHwK" + + "fCBgZnVuY3Rpb24gZGVwbG95IHVwZGF0ZSAtLWlucHV0LWZpbGU9RklMRWAgfCBNb2RpZnkgYSBk" + + "ZXBsb3ltZW50IGluIHBsYWNlIHwgfAp8IGBmdW5jdGlvbiBkZXBsb3kgcmVtb3ZlIC0tZnVuY3Rp" + + "b24taWQ9SUQgLS12ZXJzaW9uLWlkPVZJRGAgfCBTdG9wIGEgZGVwbG95bWVudCwga2VlcCBmdW5j" + + "dGlvbiByZWNvcmQgfCB8CnwgYGZ1bmN0aW9uIGludm9rZSAtLWlucHV0LWZpbGU9RklMRWAgfCBD" + + "YWxsIGEgcmVndWxhciBmdW5jdGlvbiB8IFJlcXVpcmVzIEFQSSBrZXkgKG5vdCBhZG1pbiB0b2tl" + + "bik7IExMTSBmdW5jdGlvbnMgYXJlIGludm9rZWQgdGhyb3VnaCBgbGxtLmludm9jYXRpb24uPGRv" + + "bWFpbj5gIHdpdGggYG1vZGVsOiAiPGZ1bmN0aW9uLWlkPi88bW9kZWwtbmFtZT4iYCB8CnwgYGZ1" + + "bmN0aW9uIGRlbGV0ZSAtLWZ1bmN0aW9uLWlkPUlEIC0tdmVyc2lvbi1pZD1WSURgIHwgUmVtb3Zl" + + "IGZ1bmN0aW9uICsgZGVwbG95bWVudCB8ICoqREVTVFJVQ1RJVkU6IGNvbmZpcm0gd2l0aCB1c2Vy" + + "KiogfAoKIyMgVGFza3MKClRhc2sgY29tbWFuZHMgcmVxdWlyZSBgTlZDRl9BUElfS0VZYCBzZXQg" + + "dG8gYSB0YXNrLXNjb3BlZCBrZXkgYW5kIGBOVkNGX0JBU0VfTlZDVF9VUkxgIHNldCB0byB0aGUg" + + "TlZDVCBnYXRld2F5IGVuZHBvaW50LiBJbiBhIGZyZXNoIHNlc3Npb24sIHJlYWQgYG52Y3RBcGlL" + + "ZXlgIGZyb20gYH4vLm52Y2YtY2xpLnN0YXRlYCBhbmQgaW5qZWN0IGl0IGFzIGBOVkNGX0FQSV9L" + + "RVlgIHdpdGhvdXQgbG9nZ2luZyB0aGUgdmFsdWU7IGNoZWNrIGBudmN0QXBpS2V5RXhwaXJhdGlv" + + "bmAgZmlyc3QgYW5kIHJlZ2VuZXJhdGUgd2l0aCBgYXBpLWtleSBnZW5lcmF0ZSAtLWZvciB0YXNr" + + "IC0tdmFsaWRhdGVgIGlmIGV4cGlyZWQuIFJ1biBgYXBpLWtleSBnZW5lcmF0ZSAtLWZvciB0YXNr" + + "YCBhZnRlciBgaW5pdGAgdG8gbWludCBhIG5ldyBrZXkuCgp8IENvbW1hbmQgfCBQdXJwb3NlIHwg" + + "Tm90ZXMgfAp8LS0tfC0tLXwtLS18CnwgYHRhc2sgY3JlYXRlIC0tbmFtZT1YIC0tZ3B1PUdQVSAt" + + "LWluc3RhbmNlLXR5cGU9VFlQRSAtLWltYWdlPUlNR2AgfCBTdWJtaXQgYSBjb250YWluZXIgdGFz" + + "ayB8IFNhdmVzIHRhc2sgSUQgdG8gQ0xJIHN0YXRlOyB1c2UgYC0taW5wdXQtZmlsZWAgZm9yIHJl" + + "cGVhdGFibGUgY29uZmlncyB8CnwgYHRhc2sgY3JlYXRlIC0tbmFtZT1YIC0tZ3B1PUdQVSAtLWlu" + + "c3RhbmNlLXR5cGU9VFlQRSAtLWhlbG0tY2hhcnQ9Q0hBUlRgIHwgU3VibWl0IGEgSGVsbSB0YXNr" + + "IHwgYC0taGVsbS1jaGFydGAgcmVwbGFjZXMgYC0taW1hZ2VgIHwKfCBgdGFzayBjcmVhdGUgLS1p" + + "bnB1dC1maWxlPUZJTEVgIHwgU3VibWl0IGEgdGFzayBmcm9tIGEgSlNPTiBjb25maWcgZmlsZSB8" + + "IFJlY29tbWVuZGVkIGZvciByZXBlYXRhYmxlIGNvbmZpZ3VyYXRpb25zIHwKfCBgdGFzayBsaXN0" + + "IFstLXN0YXR1cz1TVEFUVVNdIFstLWxpbWl0PU5dYCB8IExpc3QgdGFza3MsIG9wdGlvbmFsbHkg" + + "ZmlsdGVyZWQgYnkgc3RhdHVzIHwgU3RhdHVzZXM6IGBRVUVVRURgLCBgTEFVTkNIRURgLCBgUlVO" + + "TklOR2AsIGBDT01QTEVURURgLCBgRVJST1JFRGAsIGBDQU5DRUxFRGAsIGBFWENFRURFRF9NQVhf" + + "UlVOVElNRV9EVVJBVElPTmAsIGBFWENFRURFRF9NQVhfUVVFVUVEX0RVUkFUSU9OYCB8CnwgYHRh" + + "c2sgZ2V0IFt0YXNrSWRdYCB8IEdldCB0YXNrIGRldGFpbHMgfCBVc2VzIHNhdmVkIHRhc2sgSUQg" + + "ZnJvbSBzdGF0ZSBpZiBvbWl0dGVkIHwKfCBgdGFzayBldmVudHMgW3Rhc2tJZF0gWy0tbGltaXQ9" + + "Tl1gIHwgTGlzdCBsaWZlY3ljbGUgZXZlbnRzIGZvciBhIHRhc2sgfCB8CnwgYHRhc2sgcmVzdWx0" + + "cyBbdGFza0lkXWAgfCBMaXN0IHJlc3VsdCBhcnRpZmFjdHMgZm9yIGEgY29tcGxldGVkIHRhc2sg" + + "fCBSZXR1cm5zIGVtcHR5IGxpc3Qgd2hlbiBgcmVzdWx0SGFuZGxpbmdTdHJhdGVneWAgaXMgYE5P" + + "TkVgOyByZXN1bHQgdXBsb2FkIG5vdCB5ZXQgc3VwcG9ydGVkIHwKfCBgdGFzayBjYW5jZWwgW3Rh" + + "c2tJZF1gIHwgQ2FuY2VsIGEgcnVubmluZyB0YXNrIHwgTm8tb3AgaWYgYWxyZWFkeSBpbiB0ZXJt" + + "aW5hbCBzdGF0ZSB8CnwgYHRhc2sgZGVsZXRlIFt0YXNrSWRdYCB8IERlbGV0ZSBhIHRhc2sgcmVj" + + "b3JkIHwgKipTdG9wLCBzdGF0ZSB0YXNrIElEICsgY3VycmVudCBzdGF0dXMsIGFuZCB3YWl0IGZv" + + "ciBhIHN1YnNlcXVlbnQgdXNlciByZXBseSBleHBsaWNpdGx5IGNvbmZpcm1pbmcgZGVsZXRpb24g" + + "b2YgdGhhdCBzcGVjaWZpYyB0YXNrLiBEbyBub3QgdHJlYXQgdGhlIG9yaWdpbmFsIGRlbGV0ZSBy" + + "ZXF1ZXN0IGFzIGNvbmZpcm1hdGlvbi4qKiB8CnwgYHRhc2sgdXBkYXRlLXNlY3JldHMgW3Rhc2tJ" + + "ZF0gLS1zZWNyZXRzIE5BTUU9dmFsdWVgIHwgVXBkYXRlIHNlY3JldHMgb24gYSB0YXNrOyBzdXBw" + + "bGllZCBzZWNyZXRzIGFyZSBhZGRlZCBvciB1cGRhdGVkIGJ5IG5hbWUsIGV4aXN0aW5nIHNlY3Jl" + + "dHMgbm90IGluIHRoZSByZXF1ZXN0IGFyZSBwcmVzZXJ2ZWQgfCBWYWx1ZXMgYXJlIGVuY3J5cHRl" + + "ZCBhdCByZXN0IHwKfCBgdGFzayBidWxrIC0tdGFzay1pZHM9SUQxWyxJRDIs4oCmXWAgfCBGZXRj" + + "aCBkZXRhaWxzIGZvciBtdWx0aXBsZSB0YXNrcyBpbiBvbmUgcmVxdWVzdCB8IHwKCiMjIEF1dGgK" + + "CnwgQ29tbWFuZCB8IFB1cnBvc2UgfCBOb3RlcyB8CnwtLS18LS0tfC0tLXwKfCBgaW5pdGAgfCBN" + + "aW50IGFkbWluIHRva2VuIGZyb20gQVBJIEtleXMgdmlhIHB1YmxpYyBhcGkgZ2F0ZXdheSB8IElk" + + "ZW1wb3RlbnQ7IHdyaXRlcyBgfi8ubnZjZi1jbGkuc3RhdGVgOyBjbGVhcnMgc2F2ZWQgZnVuY3Rp" + + "b24gc3RhdGUgYW5kIGFsbCBBUEkga2V5cyAoZnVuY3Rpb24gYW5kIHRhc2spIHwKfCBgc3RhdHVz" + + "YCB8IFNob3cgQ0xJIHN0YXRlICh0b2tlbiwgbGFzdCBlbmRwb2ludHMsIGZ1bmN0aW9uIGNvbnRl" + + "eHQpIHwgRGlzdGluY3QgZnJvbSBgc2VsZi1ob3N0ZWQgc3RhdHVzYCB8CnwgYGFwaS1rZXkgZ2Vu" + + "ZXJhdGUgWy0tZm9yIGZ1bmN0aW9uXHx0YXNrXSBbLS1kZXNjcmlwdGlvbj3igKZdIFstLWV4cGly" + + "ZXMtaW494oCmXWAgfCBNaW50IEFQSSBrZXlzIHwgRGVmYXVsdCAobm8gYC0tZm9yYCk6IGdlbmVy" + + "YXRlcyBib3RoIGEgZnVuY3Rpb24ga2V5IGFuZCBhIHRhc2sga2V5OyBgLS1mb3IgZnVuY3Rpb25g" + + "IG9yIGAtLWZvciB0YXNrYCBnZW5lcmF0ZXMgb25lIG9ubHk7IGAtLXNjb3Blc2AgcmVxdWlyZXMg" + + "YC0tZm9yYCB8CnwgYGFwaS1rZXkgZ2VuZXJhdGUgLS12YWxpZGF0ZWAgfCBNaW50IGFuZCBpbW1l" + + "ZGlhdGVseSB2YWxpZGF0ZSBlYWNoIGdlbmVyYXRlZCBrZXkgfCBWYWxpZGF0ZXMgZWFjaCBrZXkg" + + "YWdhaW5zdCBpdHMgY29ycmVjdCBhdWRpZW5jZSAoTlZDRiBmb3IgZnVuY3Rpb24ga2V5cywgTlZD" + + "VCBmb3IgdGFzayBrZXlzKSB8CnwgYGFwaS1rZXkgbGlzdGAgfCBMaXN0IEFQSSBrZXlzIGZvciBj" + + "dXJyZW50IG93bmVyIHwgTGlzdHMgTlZDRi1zY29wZWQga2V5cyBvbmx5IHwKfCBgYXBpLWtleSBk" + + "ZWxldGUgS0VZLUlEYCAvIGBhcGkta2V5IHJldm9rZSBLRVktSURgIHwgUmVtb3ZlIGFuIEFQSSBr" + + "ZXkgfCAqKkNvbmZpcm0gd2l0aCB1c2VyKiogfAp8IGBhcGkta2V5IHNob3dgIHwgU2hvdyBjdXJy" + + "ZW50bHkgc2F2ZWQgQVBJIGtleSBmcm9tIHN0YXRlIHwgfAoKIyMgQWdlbnQgc2tpbGwKCnwgQ29t" + + "bWFuZCB8IFB1cnBvc2UgfCBOb3RlcyB8CnwtLS18LS0tfC0tLXwKfCBgYWdlbnQtc2tpbGwgaW5z" + + "dGFsbCBbLS10YXJnZXQ9RElSXWAgfCBJbnN0YWxsIGFsbCBidW5kbGVkIHB1YmxpYyB1c2VyIHNr" + + "aWxscyBpbnRvIGB+Ly5jbGF1ZGUvc2tpbGxzL2AgYW5kIGB+Ly5hZ2VudHMvc2tpbGxzL2AgfCBE" + + "ZWZhdWx0OiBib3RoIGJhc2Ugc2tpbGxzIGRpcmVjdG9yaWVzIHwKfCBgYWdlbnQtc2tpbGwgdW5p" + + "bnN0YWxsIFstLXRhcmdldD1ESVJdYCB8IFJlbW92ZSBvbmx5IGJ1bmRsZWQgcHVibGljIHVzZXIg" + + "c2tpbGxzIGZyb20gdGhlIHRhcmdldCBiYXNlIHNraWxscyBkaXJlY3RvcmllcyB8IElkZW1wb3Rl" + + "bnQ7IHVucmVsYXRlZCBza2lsbHMgcmVtYWluIHwKfCBgYWdlbnQtc2tpbGwgc2hvdyBbLS1maWxl" + + "PVJFTF1gIHwgUHJpbnQgYnVuZGxlZCBgbnZjZi1zZWxmLW1hbmFnZWQtY2xpL1NLSUxMLm1kYCBv" + + "ciBhbm90aGVyIGVtYmVkZGVkIGZpbGUgfCBGb3IgZGVidWdnaW5nIHwKfCBgYWdlbnQtc2tpbGwg" + + "dmVyc2lvbmAgfCBQcmludCBidWlsZCBTSEEgYW5kIGVtYmVkZGVkIHB1YmxpYyB1c2VyIHNraWxs" + + "IHN1bW1hcnkgfCB8ClBLBwhyDQ9kISMAACEjAABQSwMEFAAIAAAAAAAhAAAAAAAAAAAAAAAAADIA" + + "CQBkYXRhL252Y2Ytc2VsZi1tYW5hZ2VkLWNsaS9yZWZlcmVuY2UvZXhpdC1jb2Rlcy5tZFVUBQAB" + + "AKbOEiMgYG52Y2YtY2xpYCBleGl0IGNvZGVzCgpTdGFibGUgYWNyb3NzIHN1YmNvbW1hbmRzLiBV" + + "c2UgdGhlc2UgdG8gZHJpdmUgYWdlbnQgcmV0cnkgLyBzdXJmYWNpbmcgbG9naWMuCgp8IENvZGUg" + + "fCBNZWFuaW5nIHwgRXhhbXBsZSBjYXVzZXMgfAp8LS0tfC0tLXwtLS18CnwgYDBgIHwgU3VjY2Vz" + + "cyB8IEFsbCBjaGVja3MgcGFzc2VkOyBpbnN0YWxsIGNvbXBsZXRlZDsgZGVwbG95bWVudCBBQ1RJ" + + "VkUgfAp8IGAxYCB8IEdlbmVyaWMgZXJyb3IgfCBIZWxtIHJlbmRlciBmYWlsZWQ7IG5ldHdvcmsg" + + "dW5yZWFjaGFibGU7IGZpbGUgbm90IGZvdW5kOyBZQU1MIHBhcnNlIGVycm9yIHwKfCBgMmAgfCBQ" + + "cmUtZmxpZ2h0IGNoZWNrIGZhaWxlZCB8IEdhdGV3YXkgQVBJIENSRHMgbWlzc2luZzsga3ViZWN0" + + "bCBub3Qgb24gUEFUSDsgZGVmYXVsdCBTdG9yYWdlQ2xhc3MgYWJzZW50IHwKfCBgM2AgfCBBZG1p" + + "biBhdXRoIGZhaWxlZCB8IE5vIHRva2VuICsgYC0tbm9uLWludGVyYWN0aXZlYCBzZXQ7IElDTVMg" + + "cmVqZWN0ZWQgSldUOyBpbml0IGVuZHBvaW50IHVucmVhY2hhYmxlIHwKfCBgNWAgfCBNYW5pZmVz" + + "dCBhcHBseSBvciBgLS13YWl0YCB0aW1lZCBvdXQgfCBIZWxtIGluc3RhbGwgdGltZW91dDsgY2hl" + + "Y2sgcG9sbGVkIGJ1dCBkaWRuJ3QgcGFzcyBiZWZvcmUgZHVyYXRpb24gfAp8IGAxMzBgIHwgQ2Fu" + + "Y2VsbGVkIGJ5IFNJR0lOVC9TSUdURVJNIHwgVXNlciBDdHJsLUM7IENJIGJ1ZGdldCBleGNlZWRl" + + "ZDsgcG9kIGV2aWN0ZWQgfAoKIyMgSG93IGFuIGFnZW50IHNob3VsZCByZWFjdAoKfCBDb2RlIHwg" + + "QWdlbnQgYmVoYXZpb3IgfAp8LS0tfC0tLXwKfCBgMGAgfCBDb250aW51ZSAvIHJlcG9ydCBzdWNj" + + "ZXNzLiB8CnwgYDFgIHwgU3VyZmFjZSBzdGRlcnIgdG8gdXNlcjsgYXNrIGJlZm9yZSBhbnkgcmV0" + + "cnkuIEdlbmVyaWMgZXJyb3JzIHVzdWFsbHkgbmVlZCBhIGh1bWFuIHRvIHJlYWQgdGhlIG1lc3Nh" + + "Z2UuIHwKfCBgMmAgfCBTdXJmYWNlIGZhaWxlZCBjaGVja3MgKyB0aGVpciBgaGludFVSTGAuIERv" + + "bid0IHByb3Bvc2UgYHVwYCB1bnRpbCB0aGUgdXNlciBmaXhlcyBwcmVyZXFzLiB8CnwgYDNgIHwg" + + "U3VnZ2VzdCBgbnZjZi1jbGkgaW5pdGAgKGludGVyYWN0aXZlKSBPUiBgLS10b2tlbj0kSldUYCAo" + + "Q0kpLiBEb24ndCBhdXRvLW1pbnQgd2l0aG91dCB1c2VyIE9LLiB8CnwgYDVgIHwgQXNrIHVzZXIg" + + "aWYgdGhleSB3YW50IHRvIHdhaXQgbG9uZ2VyLCBkaWcgaW50byB0aGUgc3RhbGxlZCBjb21wb25l" + + "bnQsIG9yIGNhbmNlbC4gfAp8IGAxMzBgIHwgRG9uJ3QgcmV0cnkgYXV0b21hdGljYWxseTsgdXNl" + + "ciBleHBsaWNpdGx5IGNhbmNlbGxlZC4gQ29uZmlybSBiZWZvcmUgcmUtcnVubmluZy4gfAoKIyMg" + + "V2hlcmUgdG8gZmluZCBtb3JlIGRldGFpbAoKRXZlcnkgbm9uLXplcm8gZXhpdCBlbWl0cyBhIHN0" + + "cnVjdHVyZWQgYHBoYXNlX2ZhaWxlZGAgSlNPTiBldmVudCB3aXRoIGBlcnJDYXRlZ29yeWAsIGBl" + + "cnJNZXNzYWdlYCwgYHJlbWVkaWF0aW9uYCAoYXJyYXkpLCBgcmV0cnlDbGFzc2AgKGVudW06IGBu" + + "b25lfGltbWVkaWF0ZXxiYWNrb2ZmfGFmdGVyX3JlbWVkaWF0aW9ufHVua25vd25gKSwgYHJldHJ5" + + "QWZ0ZXJTZWNgIChpbnQsIG9wdGlvbmFsKSwgYW5kIGByYXdgIChzdWJwcm9jZXNzICsgSFRUUCAr" + + "IEt1YmVybmV0ZXMgc2lnbmFsKS4gQWx3YXlzIGNvbnN1bWUgdGhlc2UgaW4gYC0tanNvbmAgbW9k" + + "ZSByYXRoZXIgdGhhbiBwYXJzaW5nIEVuZ2xpc2ggZnJvbSBzdGRlcnIuClBLBwhzp1pk1QYAANUG" + + "AABQSwMEFAAIAAAAAAAhAAAAAAAAAAAAAAAAAC0ACQBkYXRhL252Y2Ytc2VsZi1tYW5hZ2VkLWNs" + + "aS9yZWZlcmVuY2UvZmxhZ3MubWRVVAUAAQCmzhIjIGBudmNmLWNsaWAgZmxhZyByZWZlcmVuY2UK" + + "CiMjIEdsb2JhbCBmbGFncyAoZXZlcnkgc3ViY29tbWFuZCkKCnwgRmxhZyB8IFB1cnBvc2UgfCBE" + + "ZWZhdWx0IHwKfC0tLXwtLS18LS0tfAp8IGAtLWNvbmZpZyBGSUxFYCB8IENvbmZpZyBmaWxlIHBh" + + "dGggfCBgJEhPTUUvLm52Y2YtY2xpLnlhbWxgIHwKfCBgLS1kZWJ1Z2AgfCBWZXJib3NlIEhUVFAg" + + "bG9nZ2luZyBvbiBzdGRlcnIgfCBgZmFsc2VgIHwKfCBgLS1qc29uYCB8IEpTT05MIGV2ZW50cyBv" + + "biBzdGRlcnIgfCBhdXRvIChvZmYgaW4gVFRZLCBvbiB1bmRlciBgLS1ub24taW50ZXJhY3RpdmVg" + + "KSB8CgojIyBgc2VsZi1ob3N0ZWRgIHBhcmVudCAocGVyc2lzdGVudCBhY3Jvc3Mgc3ViY29tbWFu" + + "ZHMpCgp8IEZsYWcgfCBQdXJwb3NlIHwgRGVmYXVsdCB8CnwtLS18LS0tfC0tLXwKfCBgLS1jb250" + + "cm9sLXBsYW5lLXN0YWNrPeKApmAgfCBDb250cm9sLXBsYW5lIGJ1bmRsZSBzb3VyY2U6IGxvY2Fs" + + "IHBhdGgsIGdpdCBVUkwsIG9yIGBvY2k6Ly9gIFVSTCB8IGVtYmVkZGVkIE9DSSBVUkwgcGlubmVk" + + "IGJ5IENMSSB2ZXJzaW9uIHwKfCBgLS1jb21wdXRlLXBsYW5lLXN0YWNrPeKApmAgfCBDb21wdXRl" + + "LXBsYW5lIGJ1bmRsZSBzb3VyY2U6IGxvY2FsIHBhdGgsIGdpdCBVUkwsIG9yIGBvY2k6Ly9gIFVS" + + "TCB8IGVtYmVkZGVkIE9DSSBVUkwgcGlubmVkIGJ5IENMSSB2ZXJzaW9uIHwKfCBgLS1lbnY9bG9j" + + "YWxcfHByZFx84oCmYCB8IEhlbG1maWxlIGVudmlyb25tZW50IG5hbWUgfCBgbG9jYWxgIGZvciBk" + + "ZXYgYnVpbGRzLCBgcHJkYCBmb3IgcmVsZWFzZXMgfAp8IGAtLW5vbi1pbnRlcmFjdGl2ZWAgfCBE" + + "aXNhYmxlIGFsbCBzdGRpbiBwcm9tcHRzIHwgYGZhbHNlYCB8CnwgYC0tdG9rZW49JEpXVGAgfCBB" + + "ZG1pbiBKV1QsIG92ZXJyaWRlcyBzdG9yZWQgc2Vzc2lvbiB8IC0gfAp8IGAtLW5vLWFwcGx5YCB8" + + "IGBpbnN0YWxsYCBvbmx5IC0gZW1pdCBZQU1MLCBkbyBub3Qga3ViZWN0bCBhcHBseSB8IGBmYWxz" + + "ZWAgfAp8IGAtLW91dHB1dD10ZXh0XHxqc29uYCB8IExlZ2FjeSBhbGlhcyBmb3IgYC0tanNvbmAg" + + "KGRlcHJlY2F0ZWQsIHJlbW92ZWQgaW4gbmV4dCBtYWpvcikgfCBgdGV4dGAgfAp8IGAtLXBsYWlu" + + "YCB8IEZvcmNlIHBsYWluIHN0cmVhbWluZyBvdXRwdXQgfCBhdXRvLWRldGVjdCB8CnwgYC0td2Fp" + + "dCBEVVJBVElPTmAgfCBgY2hlY2tgIG9ubHk7IGJsb2NrIHVudGlsIHBhc3MgfCAtIHwKfCBgLS1j" + + "b250cm9sLXBsYW5lLWNvbnRleHQgQ1RYYCB8IGt1YmVjdGwgY29udGV4dCBmb3IgY29udHJvbCBw" + + "bGFuZSAoUkVRLTIwKSB8IGN1cnJlbnQgY29udGV4dCB8CnwgYC0tY29tcHV0ZS1wbGFuZS1jb250" + + "ZXh0IENUWGAgfCBrdWJlY3RsIGNvbnRleHQgZm9yIGNvbXB1dGUgcGxhbmUgKFJFUS0yMCkgfCBj" + + "dXJyZW50IGNvbnRleHQgfAp8IGAtLWljbXMtdXJsIFVSTGAgfCBQdWJsaWMgSUNNUyBVUkw7IHJl" + + "cXVpcmVkIHdoZW4gY29udGV4dHMgZGlmZmVyIHwgZGVyaXZlZCBmcm9tIGBiYXNlX2h0dHBfdXJs" + + "YCB8CnwgYC0tbG9jYWwtb25seWAgfCBgY2hlY2sgLS1wcmVgIG9ubHk7IHNraXAgYWxsIGt1YmVj" + + "dGwgY29udGFjdCB8IGBmYWxzZWAgfAoKIyMgYHVwYC1zcGVjaWZpYwoKfCBGbGFnIHwgUHVycG9z" + + "ZSB8IERlZmF1bHQgfAp8LS0tfC0tLXwtLS18CnwgYC0tY2x1c3Rlci1uYW1lIE5BTUVgIHwgSUNN" + + "UyBjbHVzdGVyIHJvdyBpZGVudGlmaWVyIChyZXF1aXJlZCkgfCAtIHwKfCBgLS1uY2EtaWQgSURg" + + "IHwgTkNBIGFjY291bnQgSUQgfCBgbnZjZi1kZWZhdWx0YCB8CnwgYC0tcmVnaW9uIFJFR0lPTmAg" + + "fCBDbHVzdGVyIHJlZ2lvbiB8IGB1cy13ZXN0LTFgIHwKfCBgLS1wbGFuLW9ubHlgIHwgRHJ5LXJ1" + + "bjsgZW1pdCBwaGFzZSBwbGFuICsgRVRBcyB3aXRob3V0IGNoYW5nZXMgfCBgZmFsc2VgIHwKCiMj" + + "IGBzdGF0dXNgLXNwZWNpZmljCgp8IEZsYWcgfCBQdXJwb3NlIHwgRGVmYXVsdCB8CnwtLS18LS0t" + + "fC0tLXwKfCBgLS1jbHVzdGVyLW5hbWUgTkFNRWAgfCBMaW1pdCB0byBvbmUgY29tcHV0ZSBwbGFu" + + "ZSB8IC0gKGNvbnRyb2wgKyBhbGwgY2x1c3RlcnMpIHwKfCBgLS13YXRjaGAgfCBMaXZlIHJlLXJl" + + "bmRlciB8IGBmYWxzZWAgfAp8IGAtLXdhdGNoLWludGVydmFsIERVUmAgfCBgLS13YXRjaGAgY2Fk" + + "ZW5jZSB8IGA1c2AgfAp8IGAtLWNvbXBvbmVudCBOQU1FYCB8IEZpbHRlciBjb21wb25lbnRzIHBh" + + "bmVsIHwgYWxsIHwKfCBgLS1uby1ldmVudHNgIHwgU2tpcCBldmVudHMgcGFuZWwgfCBgZmFsc2Vg" + + "IHwKCiMjIGBjbHVzdGVyIHJlZ2lzdGVyYC1zcGVjaWZpYwoKfCBGbGFnIHwgUHVycG9zZSB8IERl" + + "ZmF1bHQgfAp8LS0tfC0tLXwtLS18CnwgYC0tbmFtZSBOQU1FYCB8IENsdXN0ZXIgbmFtZSAocmVx" + + "dWlyZWQpIHwgLSB8CnwgYC0tbmNhLWlkIElEYCB8IE5DQSBJRCAocmVxdWlyZWQpIHwgLSB8Cnwg" + + "YC0tcmVnaW9uIFJFR0lPTmAgfCBSZWdpb24gfCBgdXMtd2VzdC0xYCB8CnwgYC0taWNtcy11cmwg" + + "VVJMYCB8IElDTVMgZW5kcG9pbnQgfCBmcm9tIGNvbmZpZyB8CnwgYC0taWdub3JlLWV4aXN0aW5n" + + "YCB8IE1hdGNoLW9yLWNyZWF0ZSBpbnN0ZWFkIG9mIGZhaWwtb24tZXhpc3RzIHwgYGZhbHNlYCB8" + + "CgojIyBgYXBpLWtleSBnZW5lcmF0ZWAtc3BlY2lmaWMKCnwgRmxhZyB8IFB1cnBvc2UgfCBEZWZh" + + "dWx0IHwKfC0tLXwtLS18LS0tfAp8IGAtLWZvciBmdW5jdGlvblx8dGFza2AgfCBHZW5lcmF0ZSBv" + + "bmx5IHRoZSBzcGVjaWZpZWQga2V5IHR5cGUgfCAob21pdCB0byBnZW5lcmF0ZSBib3RoKSB8Cnwg" + + "YC0tZGVzY3JpcHRpb24gVEVYVGAgfCBIdW1hbi1yZWFkYWJsZSBsYWJlbCBmb3IgdGhlIGtleSB8" + + "IGBHZW5lcmF0ZWQgYnkgbnZjZi1jbGlgIHwKfCBgLS1leHBpcmVzLWluIERVUkFUSU9OYCB8IEV4" + + "cGlyeSBvZmZzZXQgKGUuZy4gYDI0aGAsIGA3ZGApOyBwYXJzZWQgYXMgZXh0ZW5kZWQgZHVyYXRp" + + "b24gfCBgMjRoYCB8CnwgYC0tc2NvcGVzIFNDT1BFWyxTQ09QRV1gIHwgT3ZlcnJpZGUgZGVmYXVs" + + "dCBzY29wZXM7IHJlcXVpcmVzIGAtLWZvcmAgfCAoc2VydmljZSBkZWZhdWx0cykgfAp8IGAtLXZh" + + "bGlkYXRlYCB8IFZhbGlkYXRlIGVhY2ggZ2VuZXJhdGVkIGtleSBpbW1lZGlhdGVseSBhZnRlciBt" + + "aW50aW5nIHwgYGZhbHNlYCB8CgpFeHRlbmRlZCBkdXJhdGlvbiB1bml0czogYHNgIChzZWNvbmRz" + + "KSwgYG1gIChtaW51dGVzKSwgYGhgIChob3VycyksIGBkYCAoZGF5cyksIGB3YCAod2Vla3MpLgoK" + + "IyMgYGZ1bmN0aW9uIGNyZWF0ZWAtc3BlY2lmaWMKCmAtLWlucHV0LWZpbGUgRklMRWAgaXMgcmVj" + + "b21tZW5kZWQgZm9yIHJlcGVhdGFibGUgZnVuY3Rpb24gZGVmaW5pdGlvbnMuIEZvciBhZC1ob2Mg" + + "Y3JlYXRlczoKCnwgRmxhZyB8IFB1cnBvc2UgfCBEZWZhdWx0IHwKfC0tLXwtLS18LS0tfAp8IGAt" + + "LW5hbWUgTkFNRWAgfCBGdW5jdGlvbiBuYW1lIHwgLSB8CnwgYC0taW1hZ2UgSU1BR0VgIHwgQ29u" + + "dGFpbmVyIGltYWdlIHwgLSB8CnwgYC0taW5mZXJlbmNlLXVybCBVUklgIHwgQ29udGFpbmVyIGlu" + + "ZmVyZW5jZSBlbmRwb2ludCB8IC0gfAp8IGAtLWluZmVyZW5jZS1wb3J0IFBPUlRgIHwgQ29udGFp" + + "bmVyIGluZmVyZW5jZSBwb3J0IHwgLSB8CnwgYC0tZnVuY3Rpb24tdHlwZSBERUZBVUxUXHxTVFJF" + + "QU1JTkdcfExMTWAgfCBGdW5jdGlvbiB0eXBlIHwgYERFRkFVTFRgIHwKfCBgLS1oZWxtLWNoYXJ0" + + "IENIQVJUYCB8IEhlbG0gY2hhcnQgVVJMIG9yIE9DSSByZWZlcmVuY2UuIENhbiBiZSB1c2VkIHdp" + + "dGggYC0tZnVuY3Rpb24tdHlwZT1MTE1gIGZvciBjaGFydC1wYWNrYWdlZCBMTE0gd29ya2xvYWRz" + + "LiB8IC0gfAp8IGAtLWhlbG0tY2hhcnQtc2VydmljZSBOQU1FYCB8IEt1YmVybmV0ZXMgU2Vydmlj" + + "ZSBuYW1lIGV4cG9zZWQgYnkgdGhlIGNoYXJ0LiBSZXF1aXJlZCB3aGVuIGAtLWhlbG0tY2hhcnRg" + + "IGlzIHNldC4gfCAtIHwKfCBgLS1tb2RlbHMgTkFNRTpWRVJTSU9OOlVSSWAgfCBTdGFuZGFyZCBt" + + "b2RlbCBhcnRpZmFjdDsgcmVwZWF0YWJsZSB8IC0gfAp8IGAtLWxsbS1tb2RlbCBTUEVDYCB8IExM" + + "TSBtb2RlbCBjb25maWc7IGZvcm1hdCBgbmFtZT08bW9kZWw+LHVyaXM9PHVyaT5cfDx1cmk+LHJv" + + "dXRpbmdNZXRob2Q9PG1ldGhvZD4sdG9rZW5SYXRlTGltaXQ9PGxpbWl0PmA7IHJlcGVhdGFibGUu" + + "IFRva2VuIGxpbWl0cyB1c2UgYDx2YWx1ZT4tPHVuaXQ+YCB3aXRoIGBTYCwgYE1gLCBgSGAsIGBE" + + "YCwgb3IgYFdgLCBmb3IgZXhhbXBsZSBgMTAwMC1TYC4gVXNlIGlucHV0IEpTT04gZm9yIGNvbWJp" + + "bmVkIHRva2VuIGxpbWl0cyBiZWNhdXNlIGlubGluZSBzcGVjcyB1c2UgY29tbWFzIGFzIGZpZWxk" + + "IHNlcGFyYXRvcnMuIHwgLSB8CnwgYC0tbGxtLWRlZmF1bHQtcHJpb3JpdHkgUFJJT1JJVFlgIHwg" + + "RnVuY3Rpb24tbGV2ZWwgZGVmYXVsdCByZXF1ZXN0IHByaW9yaXR5LiBMb3dlciB2YWx1ZXMgaGF2" + + "ZSBoaWdoZXIgcHJpb3JpdHkuIHwgLSB8CnwgYC0tbGxtLXBlci1hY2NvdW50LXByaW9yaXR5IE5D" + + "QS1JRDpQUklPUklUWWAgfCBQZXItYWNjb3VudCBwcmlvcml0eSBvdmVycmlkZTsgcmVwZWF0YWJs" + + "ZSwgbWF4aW11bSA2NC4gUmVxdWlyZXMgYSBkZWZhdWx0IHByaW9yaXR5LiB8IC0gfAoKSW4gSlNP" + + "TiBhbmQgaW5saW5lIHNwZWNzLCBMTE0gZnVuY3Rpb25zIHNldCBgZnVuY3Rpb25UeXBlOiAiTExN" + + "ImAgYW5kIG1vZGVsIHJvdXRpbmcgbWV0YWRhdGEgdW5kZXIgYG1vZGVsc1tdLmxsbUNvbmZpZ2Au" + + "IGBsbG1Db25maWcudXJpc2AgZGVjbGFyZXMgdGhlIE9wZW5BSS1jb21wYXRpYmxlIHVwc3RyZWFt" + + "IHBhdGhzIGV4cG9zZWQgYnkgdGhlIG1vZGVsLiBDdXJyZW50IHN1cHBvcnRlZCBwYXRocyBhcmUg" + + "YC92MS9jaGF0L2NvbXBsZXRpb25zYCwgYC92MS9yZXNwb25zZXNgLCBhbmQgYC92MS9lbWJlZGRp" + + "bmdzYC4gYGxsbUNvbmZpZy5yb3V0aW5nTWV0aG9kYCBhY2NlcHRzIGByb3VuZF9yb2JpbmAsIGBw" + + "b3dlcl9vZl90d29gLCBgZ3JvcV9tdWx0aXJlZ2lvbmAsIGBwdWxzYXJgLCBvciBgcmFuZG9tYC4K" + + "YGxsbUNvbmZpZy50b2tlblJhdGVMaW1pdGAgYWNjZXB0cyBvbmUgb3IgbW9yZSBjb21tYS1zZXBh" + + "cmF0ZWQgcG9zaXRpdmUgaW50ZWdlciB0b2tlbiBsaW1pdHMgaW4gYDx2YWx1ZT4tPHVuaXQ+YCBm" + + "b3JtYXQuIFN1cHBvcnRlZCB1bml0cyBhcmUgYFNgIChzZWNvbmRzKSwgYE1gIChtaW51dGVzKSwg" + + "YEhgIChob3VycyksIGBEYCAoZGF5cyksIGFuZCBgV2AgKHdlZWtzKS4gVXNlIGRpc3RpbmN0IHVu" + + "aXRzIHdoZW4gY29tYmluaW5nIGxpbWl0cywgZm9yIGV4YW1wbGUgYDEwMDAtUyw1MDAwLU0sMTAw" + + "MDAwLUgsNTAwMDAwLUQsMTAwMDAwMC1XYCBpbiBpbnB1dCBKU09OLgoKRnVuY3Rpb24tbGV2ZWwg" + + "cmVxdWVzdCBwcmlvcml0eSB1c2VzIHRoaXMgSlNPTiBzaGFwZToKCmBgYGpzb24KewogICJsbG1J" + + "bnZvY2F0aW9uQ29uZmlnIjogewogICAgInByaW9yaXR5IjogewogICAgICAiZGVmYXVsdFByaW9y" + + "aXR5IjogNywKICAgICAgInBlckFjY291bnRQcmlvcml0eSI6IHsKICAgICAgICAibmNhLWlkIjog" + + "MwogICAgICB9CiAgICB9CiAgfQp9CmBgYAoKUHJpb3JpdHkgdmFsdWVzIHJhbmdlIGZyb20gYDBg" + + "IHRocm91Z2ggYDQyOTQ5NjcyOTVgLiBMb3dlciB2YWx1ZXMgaGF2ZSBoaWdoZXIgcHJpb3JpdHks" + + "IGFuZCBgMGAgaXMgaGlnaGVzdC4gQW4gZXhwbGljaXQgYDBgIGlzIGRpc3RpbmN0IGZyb20gYW4g" + + "b21pdHRlZCBwcmlvcml0eS4gYGRlZmF1bHRQcmlvcml0eWAgaXMgcmVxdWlyZWQgd2hlbiBgcGVy" + + "QWNjb3VudFByaW9yaXR5YCBoYXMgZW50cmllcy4KCkhlbG0gY2hhcnQgcGFja2FnaW5nIGlzIGlu" + + "ZGVwZW5kZW50IG9mIGBmdW5jdGlvblR5cGVgLiBGb3IgYSBIZWxtLWNoYXJ0IGJhY2tlZCBMTE0g" + + "ZnVuY3Rpb24sIHNldCBgZnVuY3Rpb25UeXBlOiAiTExNImAsIGBoZWxtQ2hhcnRgLCBgaGVsbUNo" + + "YXJ0U2VydmljZU5hbWVgLCBhbmQgYG1vZGVsc1tdLmxsbUNvbmZpZ2AgaW4gdGhlIHNhbWUgY3Jl" + + "YXRlIHJlcXVlc3QuIGBpbmZlcmVuY2VQb3J0YCBtdXN0IGJlIHRoZSBLdWJlcm5ldGVzIFNlcnZp" + + "Y2UgcG9ydCBleHBvc2VkIGJ5IGBoZWxtQ2hhcnRTZXJ2aWNlTmFtZWAuCgpMTE0gaW52b2NhdGlv" + + "biByZXF1ZXN0cyB1c2UgYG1vZGVsOiAiPGZ1bmN0aW9uLWlkPi88bW9kZWwtbmFtZT4iYC4gVGhl" + + "IGZ1bmN0aW9uIElEIHNlbGVjdHMgdGhlIE5WQ0YgZnVuY3Rpb24sIGFuZCB0aGUgbW9kZWwgbmFt" + + "ZSBpcyBmb3J3YXJkZWQgdXBzdHJlYW0uIENoYXQgY29tcGxldGlvbnMgYW5kIFJlc3BvbnNlcyBB" + + "UEkgcmVxdWVzdHMgY2FuIHVzZSBgeC1tdWx0aS10dXJuLXNlc3Npb24taWRgIGZvciBzZXNzaW9u" + + "IHN0aWNraW5lc3M7IGVtYmVkZGluZ3MgcmVxdWVzdHMgZG8gbm90LgoKIyMgYGZ1bmN0aW9uIHVw" + + "ZGF0ZWAtc3BlY2lmaWMKCnwgRmxhZyB8IFB1cnBvc2UgfCBEZWZhdWx0IHwKfC0tLXwtLS18LS0t" + + "fAp8IGAtLXRhZ3MgVEFHWyxUQUddYCB8IFJlcGxhY2UgZnVuY3Rpb24gdGFncyB8IC0gfAp8IGAt" + + "LWxsbS1tb2RlbC11cGRhdGUgU1BFQ2AgfCBMTE0gbW9kZWwgdXBkYXRlOyBmb3JtYXQgYG5hbWU9" + + "PG1vZGVsPixyb3V0aW5nTWV0aG9kPTxtZXRob2Q+LHRva2VuUmF0ZUxpbWl0PTxsaW1pdD5gOyBy" + + "ZXBlYXRhYmxlLiBSb3V0aW5nIG1ldGhvZHMgbWF0Y2ggYC0tbGxtLW1vZGVsYC4gVG9rZW4gbGlt" + + "aXQgZXhhbXBsZTogYDEwMDAtU2AuIFVzZSBpbnB1dCBKU09OIGZvciBjb21iaW5lZCB0b2tlbiBs" + + "aW1pdHMuIHwgLSB8CnwgYC0tbGxtLWRlZmF1bHQtcHJpb3JpdHkgUFJJT1JJVFlgIHwgUmVwbGFj" + + "ZSB0aGUgZnVuY3Rpb24tbGV2ZWwgcHJpb3JpdHkgY29uZmlndXJhdGlvbiB3aXRoIHRoaXMgZGVm" + + "YXVsdCBhbmQgYW55IHN1cHBsaWVkIHBlci1hY2NvdW50IG92ZXJyaWRlcy4gfCAtIHwKfCBgLS1s" + + "bG0tcGVyLWFjY291bnQtcHJpb3JpdHkgTkNBLUlEOlBSSU9SSVRZYCB8IFBlci1hY2NvdW50IHBy" + + "aW9yaXR5IG92ZXJyaWRlOyByZXBlYXRhYmxlLCBtYXhpbXVtIDY0LiBSZXF1aXJlcyBhIGRlZmF1" + + "bHQgcHJpb3JpdHkuIHwgLSB8CnwgYC0tY2xlYXItbGxtLXByaW9yaXR5YCB8IENsZWFyIHRoZSBm" + + "dW5jdGlvbi1sZXZlbCByZXF1ZXN0IHByaW9yaXR5IGNvbmZpZ3VyYXRpb24uIHwgYGZhbHNlYCB8" + + "CgpJbiBKU09OLCBgZnVuY3Rpb24gdXBkYXRlYCBhY2NlcHRzIGBtb2RlbFVwZGF0ZXNbXWAgZW50" + + "cmllcyB3aXRoIGBtb2RlbE5hbWVgIGFuZCBgbGxtQ29uZmlnLnJvdXRpbmdNZXRob2RgIGFuZC9v" + + "ciBgbGxtQ29uZmlnLnRva2VuUmF0ZUxpbWl0YC4gYHVyaXNgIGFyZSBjcmVhdGUtdGltZSBtb2Rl" + + "bCBtZXRhZGF0YSBhbmQgYXJlIG5vdCBwYXJ0IG9mIG1vZGVsIHVwZGF0ZXMuCgpXaGVuIGBsbG1J" + + "bnZvY2F0aW9uQ29uZmlnYCBpcyBwcmVzZW50IGluIGFuIHVwZGF0ZSwgaXQgcmVwbGFjZXMgdGhl" + + "IGNvbXBsZXRlIGZ1bmN0aW9uLWxldmVsIHByaW9yaXR5IGNvbmZpZ3VyYXRpb24uIFNwZWNpZnkg" + + "ZXZlcnkgZGVmYXVsdCBhbmQgcGVyLWFjY291bnQgdmFsdWUgdG8gcmV0YWluLiBPbWl0dGluZyB0" + + "aGUgZmllbGQgcHJlc2VydmVzIHRoZSBjdXJyZW50IGNvbmZpZ3VyYXRpb24uIFVzZSBgLS1jbGVh" + + "ci1sbG0tcHJpb3JpdHlgIG9yIGAibGxtSW52b2NhdGlvbkNvbmZpZyI6IHt9YCB0byBjbGVhciBp" + + "dC4KCiMjIGBmdW5jdGlvbiBkZXBsb3kgY3JlYXRlYC1zcGVjaWZpYwoKYC0taW5wdXQtZmlsZSBG" + + "SUxFYCBpcyByZWNvbW1lbmRlZCAoZnVsbCBKU09OIHNwZWMpLiBGb3IgYWQtaG9jIG9uZS1zaG90" + + "IHVzZToKCnwgRmxhZyB8IFB1cnBvc2UgfCBEZWZhdWx0IHwKfC0tLXwtLS18LS0tfAp8IGAtLWZ1" + + "bmN0aW9uLWlkIElEYCB8IEZ1bmN0aW9uIElEIChyZXF1aXJlZCkgfCAtIHwKfCBgLS1ncHUgTkFN" + + "RWAgfCBHUFUgZmFtaWx5IHwgYEgxMDBgIHwKfCBgLS1pbnN0YW5jZS10eXBlIFRZUEVgIHwgU0tV" + + "IHwgYE5DUC5HUFUuSDEwMF8xeGAgfAp8IGAtLW1pbi1pbnN0YW5jZXMgTmAgfCBNaW4gcmVwbGlj" + + "YXMgfCBgMWAgfAp8IGAtLW1heC1pbnN0YW5jZXMgTmAgfCBNYXggcmVwbGljYXMgfCBgMWAgfAp8" + + "IGAtLW1heC1yZXF1ZXN0LWNvbmN1cnJlbmN5IE5gIHwgQ29uY3VycmVuY3kgfCBgMGAgKHVuc2V0" + + "OyBzZXJ2ZXIgZGVmYXVsdCBhcHBsaWVzKSB8CnwgYC0tY2x1c3RlcnMgTkFNRVssTkFNRV1gIHwg" + + "VGFyZ2V0IHNwZWNpZmljIGNvbXB1dGUgY2x1c3RlcnMgfCAoYW55IG1hdGNoaW5nIFNLVSkgfAoK" + + "IyMgYHRhc2sgY3JlYXRlYC1zcGVjaWZpYwoKYC0taW5wdXQtZmlsZSBGSUxFYCBpcyByZWNvbW1l" + + "bmRlZCBmb3IgcmVwZWF0YWJsZSB0YXNrIGRlZmluaXRpb25zLiBGb3IgYWQtaG9jIHVzZToKCnwg" + + "RmxhZyB8IFB1cnBvc2UgfCBOb3RlcyB8CnwtLS18LS0tfC0tLXwKfCBgLS1uYW1lIE5BTUVgIHwg" + + "VGFzayBuYW1lIChyZXF1aXJlZCkgfCAxLTEyOCBjaGFycywgYF5bYS16MC05QS1aXVthLXowLTlB" + + "LVpcLV9dKiRgIHwKfCBgLS1ncHUgR1BVYCB8IEdQVSBuYW1lIChyZXF1aXJlZCB3aXRob3V0IGAt" + + "LWlucHV0LWZpbGVgKSB8IEV4YW1wbGU6IGBIMTAwYCB8CnwgYC0taW5zdGFuY2UtdHlwZSBUWVBF" + + "YCB8IEluc3RhbmNlIHR5cGUgKHJlcXVpcmVkIHdpdGhvdXQgYC0taW5wdXQtZmlsZWApIHwgRXhh" + + "bXBsZTogYE5DUC5HUFUuSDEwMF8xeGAgfAp8IGAtLWltYWdlIElNQUdFYCB8IENvbnRhaW5lciBp" + + "bWFnZSB8IE11dHVhbGx5IGV4Y2x1c2l2ZSB3aXRoIGAtLWhlbG0tY2hhcnRgIHwKfCBgLS1oZWxt" + + "LWNoYXJ0IENIQVJUYCB8IEhlbG0gY2hhcnQgVVJMIG9yIE9DSSByZWZlcmVuY2UgfCBNdXR1YWxs" + + "eSBleGNsdXNpdmUgd2l0aCBgLS1pbWFnZWAgfAp8IGAtLWlucHV0LWZpbGUgRklMRWAgfCBKU09O" + + "IHRhc2sgc3BlYyBmaWxlIHwgQ0xJIGZsYWdzIG92ZXJyaWRlIEpTT04gdmFsdWVzIHdoZW4gYm90" + + "aCBhcmUgc2V0IHwKfCBgLS1iYWNrZW5kIEJBQ0tFTkRgIHwgQmFja2VuZCAvIENTUCB8IC0gfAp8" + + "IGAtLWNsdXN0ZXJzIE5BTUVbLE5BTUVdYCB8IFNwZWNpZmljIGNsdXN0ZXJzIHdpdGhpbiB0aGUg" + + "aW5zdGFuY2UgfCBDb21tYS1zZXBhcmF0ZWQgfAp8IGAtLWNvbnRhaW5lci1hcmdzIEFSR1NgIHwg" + + "QXJncyBwYXNzZWQgd2hlbiBsYXVuY2hpbmcgdGhlIGNvbnRhaW5lciB8IFNpbmdsZSBzdHJpbmcs" + + "IGUuZy4gYCItLWVwb2NocyAxMCAtLWJhdGNoLXNpemUgMzIiYCB8CnwgYC0tY29udGFpbmVyLWVu" + + "diBOQU1FPXZhbHVlYCB8IENvbnRhaW5lciBlbnZpcm9ubWVudCB2YXJpYWJsZTsgcmVwZWF0YWJs" + + "ZSB8IC0gfAp8IGAtLXNlY3JldHMgTkFNRT12YWx1ZWAgfCBTZWNyZXQgZW52aXJvbm1lbnQgdmFy" + + "aWFibGU7IHJlcGVhdGFibGU7IGVuY3J5cHRlZCBhdCByZXN0IHwgLSB8CnwgYC0tbWF4LXJ1bnRp" + + "bWUgRFVSQVRJT05gIHwgTWF4IHdhbGwtY2xvY2sgcnVuIHRpbWUgKElTTyA4NjAxLCBlLmcuIGBQ" + + "VDRIYCkgfCBObyBkZWZhdWx0OyBvbWl0IGZvciBubyB0aW1lIGxpbWl0IHwKfCBgLS1tYXgtcXVl" + + "dWVkIERVUkFUSU9OYCB8IE1heCB0aW1lIGluIHF1ZXVlIGJlZm9yZSBjYW5jZWxsYXRpb24gKElT" + + "TyA4NjAxKSB8IFNlcnZlciBkZWZhdWx0IGBQVDcySGAgfAp8IGAtLXRlcm1pbmF0aW9uLWdyYWNl" + + "IERVUkFUSU9OYCB8IEdyYWNlIHBlcmlvZCBhZnRlciBzdG9wIHNpZ25hbCAoSVNPIDg2MDEpIHwg" + + "U2VydmVyIGRlZmF1bHQgYFBUMUhgIHwKfCBgLS1yZXN1bHQtc3RyYXRlZ3kgVVBMT0FEXHxOT05F" + + "YCB8IEhvdyB0byBoYW5kbGUgdGFzayBvdXRwdXQgYXJ0aWZhY3RzIHwgLSB8CnwgYC0tcmVzdWx0" + + "cy1sb2NhdGlvbiBMT0NBVElPTmAgfCBSZXN1bHQgdXBsb2FkIHRhcmdldCwgZm9ybWF0IGBvcmct" + + "bmFtZS9bdGVhbS1uYW1lL11tb2RlbC1uYW1lYDsgcmVxdWlyZWQgd2hlbiBgLS1yZXN1bHQtc3Ry" + + "YXRlZ3k9VVBMT0FEYCB8IC0gfAp8IGAtLW1vZGVscyBOQU1FOlZFUlNJT046VVJJYCB8IE1vZGVs" + + "IGFydGlmYWN0OyByZXBlYXRhYmxlIHwgLSB8CnwgYC0tcmVzb3VyY2VzIE5BTUU6VkVSU0lPTjpV" + + "UklgIHwgUmVzb3VyY2UgYXJ0aWZhY3Q7IHJlcGVhdGFibGUgfCAtIHwKfCBgLS10YWdzIFRBR1ss" + + "VEFHXWAgfCBUYXNrIHRhZ3MgfCBDb21tYS1zZXBhcmF0ZWQgfAp8IGAtLWRlc2NyaXB0aW9uIFRF" + + "WFRgIHwgVGFzayBkZXNjcmlwdGlvbiB8IC0gfAp8IGAtLWxvZ3MtdGVsZW1ldHJ5LWlkIFVVSURg" + + "IHwgTG9ncyB0ZWxlbWV0cnkgZW5kcG9pbnQgSUQgfCAtIHwKfCBgLS1tZXRyaWNzLXRlbGVtZXRy" + + "eS1pZCBVVUlEYCB8IE1ldHJpY3MgdGVsZW1ldHJ5IGVuZHBvaW50IElEIHwgLSB8CnwgYC0tdHJh" + + "Y2VzLXRlbGVtZXRyeS1pZCBVVUlEYCB8IFRyYWNlcyB0ZWxlbWV0cnkgZW5kcG9pbnQgSUQgfCAt" + + "IHwKUEsHCKjPH6gzKAAAMygAAFBLAwQUAAgAAAAAACEAAAAAAAAAAAAAAAAANwAJAGRhdGEvbnZj" + + "Zi1zZWxmLW1hbmFnZWQtY2xpL3JlZmVyZW5jZS90cm91Ymxlc2hvb3RpbmcubWRVVAUAAQCmzhIj" + + "IFRyb3VibGVzaG9vdGluZwoKS25vd24gZXJyb3JzIOKGkiBkaWFnbm9zdGljIGNvbW1hbmQg4oaS" + + "IHJlbWVkaWF0aW9uLiBLZWVwIGluIHN5bmMgd2l0aCB0aGUgc3RydWN0dXJlZCBgcGhhc2VfZmFp" + + "bGVkYCBldmVudHMgdGhlIENMSSBlbWl0cyAoUkVRLTE1KSDigJQgZXZlcnkgZW50cnkgYmVsb3cg" + + "c2hvdWxkIG1hcCB0byBhbiBgZXJyQ2F0ZWdvcnlgIGFuZCBhIGByZW1lZGlhdGlvbmAgYXJyYXku" + + "CgojIyBQcmUtZmxpZ2h0Cgp8IFN5bXB0b20gfCBDYXVzZSB8IFJlbWVkaWF0aW9uIHwKfC0tLXwt" + + "LS18LS0tfAp8IGBrdWJlY3RsIG5vdCBvbiBQQVRIYCB8IE9wZXJhdG9yJ3MgYCRQQVRIYCBkb2Vz" + + "bid0IGluY2x1ZGUga3ViZWN0bCB8IEluc3RhbGwga3ViZWN0bCAxLjI4KzogaHR0cHM6Ly9rdWJl" + + "cm5ldGVzLmlvL2RvY3MvdGFza3MvdG9vbHMvaW5zdGFsbC1rdWJlY3RsLyB8CnwgYGhlbG1maWxl" + + "IG5vdCBvbiBQQVRIYCB8IFNhbWUgfCBodHRwczovL2dpdGh1Yi5jb20vaGVsbWZpbGUvaGVsbWZp" + + "bGUjaW5zdGFsbGF0aW9uIHwKfCBgaGVsbSBub3Qgb24gUEFUSGAgfCBTYW1lIHwgaHR0cHM6Ly9o" + + "ZWxtLnNoL2RvY3MvaW50cm8vaW5zdGFsbC8gfAp8IGBHYXRld2F5IEFQSSBDUkRzIG5vdCBpbnN0" + + "YWxsZWRgIHwgZW52b3ktZ2F0ZXdheSBwcmVyZXEgbWlzc2luZyB8IGBoZWxtIGluc3RhbGwgZWcg" + + "b2NpOi8vZG9ja2VyLmlvL2Vudm95cHJveHkvZ2F0ZXdheS1oZWxtIC0tbmFtZXNwYWNlPWVudm95" + + "LWdhdGV3YXktc3lzdGVtIC0tY3JlYXRlLW5hbWVzcGFjZWAgfAp8IGBkZWZhdWx0IFN0b3JhZ2VD" + + "bGFzcyBub3QgYXZhaWxhYmxlYCB8IENsdXN0ZXIgaGFzIG5vIGRlZmF1bHQgU0MgfCBBbm5vdGF0" + + "ZSBvbmU6IGBrdWJlY3RsIHBhdGNoIHNjIDxuYW1lPiAtcCAneyJtZXRhZGF0YSI6eyJhbm5vdGF0" + + "aW9ucyI6eyJzdG9yYWdlY2xhc3Mua3ViZXJuZXRlcy5pby9pcy1kZWZhdWx0LWNsYXNzIjoidHJ1" + + "ZSJ9fX0nYCB8CnwgYEdQVSBvcGVyYXRvciBub3QgaW5zdGFsbGVkYCAoY29tcHV0ZS1wbGFuZSkg" + + "fCBudmlkaWEgR1BVIG9wZXJhdG9yIG1pc3NpbmcgfCBJbnN0YWxsIHBlciBodHRwczovL2RvY3Mu" + + "bnZpZGlhLmNvbS9kYXRhY2VudGVyL2Nsb3VkLW5hdGl2ZS9ncHUtb3BlcmF0b3IvbGF0ZXN0L2lu" + + "c3RhbGwtZ3B1LW9wZXJhdG9yLmh0bWwsIE9SIHVzZSBgZmFrZS1ncHUtb3BlcmF0b3JgIGZvciBk" + + "ZXYgfAp8IGBHUFUgbm9kZSBsYWJlbHMgbWlzc2luZ2AgKGNvbXB1dGUtcGxhbmUpIHwgTm9kZXMg" + + "bmVlZCBgbnZpZGlhLmNvbS9ncHUuZmFtaWx5YCBldGMuIHwgU2V0IGAtLWszcy1ub2RlLWxhYmVs" + + "IG52aWRpYS5jb20vZ3B1LmZhbWlseT1ob3BwZXJAYWdlbnQ6TmAgZm9yIGszZCB8CgojIyBBdXRo" + + "Cgp8IFN5bXB0b20gfCBDYXVzZSB8IFJlbWVkaWF0aW9uIHwKfC0tLXwtLS18LS0tfAp8IGBhZG1p" + + "biB0b2tlbiByZXF1aXJlZGAgKGluaXQgbm90IHJ1bikgfCBObyBgfi8ubnZjZi1jbGkuc3RhdGVg" + + "IGFuZCBgLS10b2tlbmAgbm90IHBhc3NlZCB8IGBudmNmLWNsaSBpbml0YCAoaW50ZXJhY3RpdmUp" + + "IG9yIGAtLXRva2VuPSRKV1QgLS1ub24taW50ZXJhY3RpdmVgIChDSSkgfAp8IGBTaWduZWQgSldU" + + "IHJlamVjdGVkOiBBbm90aGVyIGFsZ29yaXRobSBleHBlY3RlZCwgb3Igbm8gbWF0Y2hpbmcga2V5" + + "KHMpIGZvdW5kYCB8IFN0YWxlIHNlc3Npb24uanNvbiBmcm9tIGEgZGlmZmVyZW50IGNvbnRyb2wg" + + "cGxhbmUgfCBgcm0gfi8ubnZjZi1jbGkuc3RhdGVgIHRoZW4gYG52Y2YtY2xpIGluaXRgIGFnYWlu" + + "IHwKfCBgNDAzIG1pc3NpbmcgcmVxdWVzdGVkIGF1dGhvcml0aWVzYCAoZnVuY3Rpb24gaW52b2tl" + + "KSB8IEFkbWluIHRva2VuIGRvZXNuJ3QgaGF2ZSBgaW52b2tlX2Z1bmN0aW9uYCBzY29wZSB8IGBu" + + "dmNmLWNsaSBhcGkta2V5IGdlbmVyYXRlIC0tZGVzY3JpcHRpb2494oCmYCB0aGVuIHJlLXJ1biBp" + + "bnZva2UgfAoKIyMgSW5zdGFsbCAvIGB1cGAKCnwgU3ltcHRvbSB8IENhdXNlIHwgUmVtZWRpYXRp" + + "b24gfAp8LS0tfC0tLXwtLS18CnwgSGVsbSBgdGltZWQgb3V0IHdhaXRpbmcgZm9yIGNhc3NhbmRy" + + "YWAgfCBDYXNzYW5kcmEgU3RhdGVmdWxTZXQgUFZDIHN0dWNrIGBQZW5kaW5nYCB8IENvbmZpcm0g" + + "ZGVmYXVsdCBTdG9yYWdlQ2xhc3M7IGNoZWNrIGBrdWJlY3RsIGdldCBwdixwdmMgLW4gY2Fzc2Fu" + + "ZHJhLXN5c3RlbWAgfAp8IGBJbnZhbGlkIEdQVSAnTkNQLkdQVS5IMTAwJyBzcGVjaWZpZWRgIChm" + + "dW5jdGlvbiBkZXBsb3kpIHwgV3JvbmcgZmllbGQg4oCUIGBncHVgIGlzIHRoZSBmYW1pbHksIG5v" + + "dCB0aGUgU0tVIHwgVXNlIGAiZ3B1IjogIkgxMDAiYCwgYCJpbnN0YW5jZVR5cGUiOiAiTkNQLkdQ" + + "VS5IMTAwXzF4ImAgfAp8IGByZWdpb24gbXVzdCBiZSBwcm92aWRlZGAgKGNsdXN0ZXIgcmVnaXN0" + + "ZXIgLyBpbnN0YWxsIC0tY29tcHV0ZS1wbGFuZSkgfCBgLS1yZWdpb25gIGVtcHR5ICsgYENMVVNU" + + "RVJfUkVHSU9OYCBlbnYgZW1wdHkgfCBQYXNzIGAtLXJlZ2lvbj11cy13ZXN0LTFgIChvciBhbnkg" + + "bm9uLWVtcHR5IHZhbHVlKSB8CnwgYHJlcXVpcmVkRW52ICJOQ0FfSUQiIGlzIG5vdCBzZXRgICho" + + "ZWxtZmlsZSBlcnJvciBkdXJpbmcgY29tcHV0ZS1wbGFuZSBhcHBseSkgfCBPbGRlciBudmNmLWNs" + + "aSBiZWZvcmUgY29tbWl0IGA2YWE1NzA0YDsgRXh0cmFFbnYgbm90IHByb3BhZ2F0aW5nIE5DQV9J" + + "RCB8IFVwZ3JhZGUgYG52Y2YtY2xpYCB0byBhIHJlbGVhc2UgYWZ0ZXIgYDZhYTU3MDRgIHwKfCBg" + + "bnZjYS1vcGVyYXRvcjogSW1hZ2VQdWxsQmFja09mZmAgZm9yIGBudmNhLW9wZXJhdG9yOnBzYXRg" + + "IHwgSW1hZ2Ugbm90IGluIGNsdXN0ZXIgcmVnaXN0cnk7IG11bHRpLWNsdXN0ZXIgYnVpbGQgaXMg" + + "bG9jYWwgfCBgazNkIGltYWdlIGltcG9ydCBudmNyLmlvLy4uLi9udmNhLW9wZXJhdG9yOnBzYXQg" + + "LWMgPGNsdXN0ZXI+YCB8CgojIyBDb21wdXRlLXBsYW5lIHJ1bnRpbWUKCnwgU3ltcHRvbSB8IENh" + + "dXNlIHwgUmVtZWRpYXRpb24gfAp8LS0tfC0tLXwtLS18CnwgTlZDQSBhZ2VudCBDcmFzaExvb3BC" + + "YWNrT2ZmIHdpdGggYEhUVFAgNDAxYCBvbiBgL3YxL252Y2EvY2x1c3RlcnMvLi4uL3JlZ2lzdGVy" + + "YCB8IFN0YWxlIGBvdXQvPGNsdXN0ZXI+LXJlZ2lzdGVyLXZhbHVlcy55YW1sYCBmcm9tIHByaW9y" + + "IHJlZ2lzdGVyOyBjbHVzdGVyIElEIGRvZXNuJ3QgbWF0Y2ggSUNNUyB8IERlbGV0ZSB0aGUgc3Rh" + + "bGUgZmlsZTsgcmUtcnVuIGBudmNmLWNsaSBzZWxmLWhvc3RlZCB1cGAgKGlkZW1wb3RlbnQgcmVn" + + "aXN0ZXIgd3JpdGVzIGEgZnJlc2ggZmlsZSkgfAp8IGBObyBjbHVzdGVyIGZvdW5kIHdpdGggdmFs" + + "aWQgSldLUyBmb3IgY2x1c3RlciBJRDogPGlkPmAgKElDTVMgbG9nKSB8IEpXS1MgaW4gSUNNUyBk" + + "b2Vzbid0IG1hdGNoIHdoYXQgY29tcHV0ZS1wbGFuZSBLOHMgaXMgY3VycmVudGx5IHNpZ25pbmcg" + + "fCBgbnZjZi1jbGkgY2x1c3RlciByb3RhdGUgLS1jbHVzdGVyLWlkPTxpZD5gIHwKfCBGdW5jdGlv" + + "biBwb2QgYEltYWdlUHVsbEJhY2tPZmZgIGluIGBudmNmLWJhY2tlbmRgIHwgSW1hZ2UtY3JlZGVu" + + "dGlhbC1oZWxwZXIgY29uZmlnIG1pc3Npbmcgb3Igd3JvbmcgfCBga3ViZWN0bCBkZXNjcmliZSBw" + + "b2QgLW4gbnZjZi1iYWNrZW5kIDxwb2Q+YDsgY2hlY2sgdGhlIHB1bGwgc2VjcmV0IGNvbmZpZyB8" + + "CnwgRnVuY3Rpb24gZGVwbG95IHN0dWNrIGBERVBMT1lJTkdgIGZvciA+NSBtaW4gfCBOQVRTIHN0" + + "cmVhbSBpbml0IGxhZyAoY29sZC1jbHVzdGVyKSDigJQgd2FpdCwgb3IgY2hlY2sgTkFUUyBhdXRo" + + "LWNhbGxvdXQgaGVhbHRoIHwgYGt1YmVjdGwgbG9ncyAtbiBuYXRzLXN5c3RlbSAtbCBhcHAua3Vi" + + "ZXJuZXRlcy5pby9uYW1lPW5hdHMtYXV0aC1jYWxsb3V0LXNlcnZpY2VgIHwKCiMjIFRhc2tzCgp8" + + "IFN5bXB0b20gfCBDYXVzZSB8IFJlbWVkaWF0aW9uIHwKfC0tLXwtLS18LS0tfAp8IGB0YXNrIGNy" + + "ZWF0ZWAgcmV0dXJucyBgTWlzc2luZyA8VFlQRT4gcmVnaXN0cnkgY3JlZGVudGlhbCBmb3IgaG9z" + + "dG5hbWVgLCBvciBrZWVwcyB1c2luZyBhIHByZXZpb3VzIGNyZWRlbnRpYWwgdmFsdWUsIHNob3J0" + + "bHkgYWZ0ZXIgYHJlZ2lzdHJ5LWNyZWRlbnRpYWwgYWRkL3VwZGF0ZS9kZWxldGVgIHdoaWxlIGBy" + + "ZWdpc3RyeS1jcmVkZW50aWFsIGxpc3RgL2BnZXRgIGFscmVhZHkgc2hvdyB0aGUgbmV3IHZhbHVl" + + "IHwgRXhwZWN0ZWQgcHJvcGFnYXRpb24gZGVsYXk6IE5WQ1QgY2FjaGVzIHRoZSBhY2NvdW50J3Mg" + + "cmVnaXN0cnkgY3JlZGVudGlhbHMgd2l0aCBgbnZjdC5udmNmLmNhY2hlLXR0bGAgKGRlZmF1bHQg" + + "YFBUNU1gLCBhYm91dCA1IG1pbikgYW5kIGFwcGxpZXMgdGhlIGNoYW5nZSB3aGVuIHRoYXQgY2Fj" + + "aGVkIGNvcHkgcmVmcmVzaGVzIHwgV2FpdCB1cCB0byBhYm91dCA1IG1pbiBhbmQgcmV0cnksIG9y" + + "IGBrdWJlY3RsIC1uIG52Y2Ygcm9sbG91dCByZXN0YXJ0IGRlcGxveW1lbnQvbnZjdC1hcGlgIHRv" + + "IGFwcGx5IGltbWVkaWF0ZWx5IHwKUEsHCPOuE4R0EQAAdBEAAFBLAwQUAAgAAAAAACEAAAAAAAAA" + + "AAAAAAAALAAJAGRhdGEvbnZjZi1zZWxmLW1hbmFnZWQtaW5zdGFsbGF0aW9uL1NLSUxMLm1kVVQF" + + "AAEAps4SLS0tCm5hbWU6IG52Y2Ytc2VsZi1tYW5hZ2VkLWluc3RhbGxhdGlvbgpkZXNjcmlwdGlv" + + "bjogPi0KICBJbnN0YWxsIGFuZCBvcGVyYXRlIE5WQ0Ygc2VsZi1ob3N0ZWQgY29udHJvbC1wbGFu" + + "ZSBhbmQgc2VwYXJhdGUgY29tcHV0ZS1wbGFuZQogIHN0YWNrcy4gQ292ZXJzIEhlbG1maWxlIHZh" + + "bHVlcyBhbmQgQ0xJIHByb2ZpbGUgaW5zdGFsbGF0aW9uIGZsb3dzLCB0ZWFyZG93biwKICB2YWx1" + + "ZXMgb3ZlcnJpZGVzLCBwdWxsIHNlY3JldHMsIGFuZCB0cm91Ymxlc2hvb3RpbmcuIFVzZSBmb3IK" + + "ICBudmNmLXNlbGYtbWFuYWdlZC1zdGFjaywgbnZjZi1jb21wdXRlLXBsYW5lLXN0YWNrLCBzcGxp" + + "dCBjb21wdXRlLXBsYW5lCiAgaW5zdGFsbGF0aW9uLCBjb250cm9sLXBsYW5lIGluc3RhbGxhdGlv" + + "biwgQ0xJLWdlbmVyYXRlZCBjb250cm9sLXBsYW5lCiAgcHJvZmlsZXMsIEhlbG1maWxlLCBzZWxm" + + "LW1hbmFnZWQsIG9yIHNlbGYtaG9zdGVkIGRlcGxveW1lbnRzLiBEbyBOT1QgdXNlIGZvcgogIGxv" + + "Y2FsIGszZCBlbnZpcm9ubWVudHM7IHVzZSB0aGUgbG9jYWwgazNkIGRldmVsb3BtZW50IHdvcmtm" + + "bG93IGluc3RlYWQuCmxpY2Vuc2U6IEFwYWNoZS0yLjAKY29tcGF0aWJpbGl0eTogUmVxdWlyZXMg" + + "aGVsbWZpbGUgPj0gMS4xLjAgPCAxLjIuMCwgaGVsbSA+PSAzLjEyLCBoZWxtLWRpZmYgcGx1Z2lu" + + "LCBrdWJlY3RsIG1hdGNoaW5nIGNsdXN0ZXIgdmVyc2lvbgphdXRob3I6ICJudmNmLWNvcmUtZW5n" + + "IDxudmNmLWNvcmUtZW5nQGV4Y2hhbmdlLm52aWRpYS5jb20+Igp2ZXJzaW9uOiAiMS4wLjAiCnRh" + + "Z3M6IFtudmNmLCBzZWxmLW1hbmFnZWQsIGhlbG1maWxlLCBzZWxmLWhvc3RlZCwgY29udHJvbC1w" + + "bGFuZSwgY29tcHV0ZS1wbGFuZSwgY2xpLXByb2ZpbGUsIGluc3RhbGxhdGlvbiwgZGVwbG95bWVu" + + "dCwgcHVsbC1zZWNyZXRzXQp0b29sczogW1NoZWxsLCBSZWFkLCBFZGl0LCBHcmVwLCBHbG9iXQpt" + + "ZXRhZGF0YToKICBpbnRlcm5hbDogZmFsc2UKICBhdXRob3I6ICJudmNmLWNvcmUtZW5nIDxudmNm" + + "LWNvcmUtZW5nQGV4Y2hhbmdlLm52aWRpYS5jb20+IgogIHZlcnNpb246ICIxLjAiCiAgdGFnczog" + + "W252Y2YsIHNlbGYtbWFuYWdlZCwgaGVsbWZpbGUsIHNlbGYtaG9zdGVkLCBjb250cm9sLXBsYW5l" + + "LCBjb21wdXRlLXBsYW5lLCBjbGktcHJvZmlsZSwgaW5zdGFsbGF0aW9uLCBkZXBsb3ltZW50LCBw" + + "dWxsLXNlY3JldHNdCiAgbGFuZ3VhZ2VzOiBbYmFzaCwgeWFtbF0KICBmcmFtZXdvcmtzOiBbaGVs" + + "bWZpbGUsIGhlbG0sIGt1YmVjdGxdCiAgZG9tYWluOiBjbG91ZC1pbmZyYXN0cnVjdHVyZQotLS0K" + + "CiMgTlZDRiBTZWxmLU1hbmFnZWQgU3RhY2sgT3BlcmF0aW9ucwoKT3BlcmF0aW9uYWwgZ3VpZGUg" + + "Zm9yIG1hdGNoaW5nIE5WQ0YgY29udHJvbC1wbGFuZSBhbmQgY29tcHV0ZS1wbGFuZSBIZWxtZmls" + + "ZSBidW5kbGVzLgoKIyMgSW5zdHJ1Y3Rpb25zCgpVc2UgdGhpcyBza2lsbCBmb3IgaW5zdGFsbCwg" + + "dXBncmFkZSwgb3IgdGVhcmRvd24gd29yayBpbiBtYXRjaGluZyBgbnZjZi1zZWxmLW1hbmFnZWQt" + + "c3RhY2tgIGFuZCBgbnZjZi1jb21wdXRlLXBsYW5lLXN0YWNrYCBidW5kbGVzOyBrZWVwIEhlbG1m" + + "aWxlIHZhbHVlcyBhbmQgQ0xJIHByb2ZpbGUgaGFuZG9mZnMgc2VwYXJhdGUuIEZvciBgZnVuY3Rp" + + "b25UeXBlOiAiTExNImAsIHJlYWQgW0xMTSBGdW5jdGlvbiBFbmFibGVtZW50XShyZWZlcmVuY2Vz" + + "L2hlbG1maWxlLXN0cnVjdHVyZS5tZCNsbG0tZnVuY3Rpb24tZW5hYmxlbWVudCkuCgojIyBQcmVy" + + "ZXF1aXNpdGVzCgpBc2sgZm9yIHRoZSBleHRyYWN0ZWQgYG52Y2Ytc2VsZi1tYW5hZ2VkLXN0YWNr" + + "YCBwYXRoLiBGb3Igc3BsaXQgaW5zdGFsbGF0aW9uLAphbHNvIHJlcXVpcmUgdGhlIG1hdGNoaW5n" + + "LXZlcnNpb24gYG52Y2YtY29tcHV0ZS1wbGFuZS1zdGFja2AgcGF0aC4gVmVyaWZ5IGJvdGg6Cgpg" + + "YGBiYXNoCmxzIDxjb250cm9sLXBsYW5lLXN0YWNrPi9oZWxtZmlsZS5kLyA8Y29udHJvbC1wbGFu" + + "ZS1zdGFjaz4vZW52aXJvbm1lbnRzLyA8Y29udHJvbC1wbGFuZS1zdGFjaz4vc2VjcmV0cy8gPGNv" + + "bnRyb2wtcGxhbmUtc3RhY2s+L2dsb2JhbC55YW1sLmdvdG1wbApscyA8Y29tcHV0ZS1wbGFuZS1z" + + "dGFjaz4vaGVsbWZpbGUuZC8gPGNvbXB1dGUtcGxhbmUtc3RhY2s+L2Vudmlyb25tZW50cy8gPGNv" + + "bXB1dGUtcGxhbmUtc3RhY2s+L2dsb2JhbC55YW1sLmdvdG1wbApgYGAKCklmIGVpdGhlciBkaXJl" + + "Y3RvcnkgaXMgbWlzc2luZywgZG93bmxvYWQgbWF0Y2hpbmcgYnVuZGxlIHZlcnNpb25zIGZyb20g" + + "TkdDOgoKYGBgYmFzaApuZ2MgcmVnaXN0cnkgcmVzb3VyY2UgZG93bmxvYWQtdmVyc2lvbiA8b3Jn" + + "Pi9udmNmLXNlbGYtbWFuYWdlZC1zdGFjazo8dmVyc2lvbj4KbmdjIHJlZ2lzdHJ5IHJlc291cmNl" + + "IGRvd25sb2FkLXZlcnNpb24gPG9yZz4vbnZjZi1jb21wdXRlLXBsYW5lLXN0YWNrOjx2ZXJzaW9u" + + "PgpgYGAKCkNvbnRyb2wtcGxhbmUgY29tbWFuZHMgYmVsb3cgYXNzdW1lIHRoZSBjb250cm9sLXBs" + + "YW5lIGJ1bmRsZSByb290LiBTcGxpdC1mbG93CmNvbW1hbmRzIGFuZCByb290IHN1YnN0aXR1dGlv" + + "biBhcmUgaW4KW1NwbGl0IENvbXB1dGUtUGxhbmUgSW5zdGFsbGF0aW9uXShyZWZlcmVuY2VzL2Nv" + + "bXB1dGUtcGxhbmUtaW5zdGFsbGF0aW9uLm1kKS4KCiMjIEJlZm9yZSBZb3UgU3RhcnQKClZlcmlm" + + "eSB0b29saW5nIGFuZCBjb250ZXh0IGJlZm9yZSBhbnkgb3BlcmF0aW9uOgoKYGBgYmFzaApoZWxt" + + "ZmlsZSAtLXZlcnNpb24gICAjIE11c3QgYmUgMS4xLnggKDEuMi4wIHJlbW92ZWQgc2VxdWVudGlh" + + "bCBtb2RlKQpoZWxtIHZlcnNpb24gICAgICAgICAjIE11c3QgYmUgPj0gMy4xMgpoZWxtIHBsdWdp" + + "biBsaXN0ICAgICAjIE11c3QgaW5jbHVkZSBoZWxtLWRpZmYgPj0gMy4xMQprdWJlY3RsIHZlcnNp" + + "b24gICAgICAjIENsaWVudCBtdXN0IGJlIHdpdGhpbiAxIG1pbm9yIHZlcnNpb24gb2YgY2x1c3Rl" + + "cgpgYGAKCkNvbnRyb2wtcGxhbmUgY29tbWFuZHMgcnVuIGZyb20gdGhlIGV4dHJhY3RlZCBgbnZj" + + "Zi1zZWxmLW1hbmFnZWQtc3RhY2svYCByb290OgoKYGBgYmFzaApjZCBwYXRoL3RvL252Y2Ytc2Vs" + + "Zi1tYW5hZ2VkLXN0YWNrCmxzIGhlbG1maWxlLmQvIGVudmlyb25tZW50cy8gc2VjcmV0cy8gZ2xv" + + "YmFsLnlhbWwuZ290bXBsCmBgYAoKSWRlbnRpZnkgdGhlIGVudmlyb25tZW50IGZyb20gYGVudmly" + + "b25tZW50cy88bmFtZT4ueWFtbGAgYW5kCmBzZWNyZXRzLzxuYW1lPi1zZWNyZXRzLnlhbWxgOyBm" + + "b3IgRUtTLCB1c2UgdGhlIGNhbm9uaWNhbApbQ1NQIEVuZC10by1FbmQgRXhhbXBsZV0oaHR0cHM6" + + "Ly9kb2NzLm52aWRpYS5jb20vbnZjZi92MC42LjAtcmMvY3NwLWVuZC10by1lbmQtZXhhbXBsZSku" + + "CgojIyBIb3cgVmFsdWVzIEZsb3cKClVuZGVyc3RhbmRpbmcgdmFsdWUgcHJlY2VkZW5jZSBwcmV2" + + "ZW50cyB0aGUgbW9zdCBjb21tb24gY29uZmlndXJhdGlvbiBtaXN0YWtlcy4KCmBgYAplbnZpcm9u" + + "bWVudHMvYmFzZS55YW1sICAgICAgICAgIChkZWZhdWx0cykKICAgIC0+IG1lcmdlZCB3aXRoCmVu" + + "dmlyb25tZW50cy88ZW52Pi55YW1sICAgICAgICAgKHlvdXIgb3ZlcnJpZGVzKQogICAgLT4gY29u" + + "c3VtZWQgYnkKZ2xvYmFsLnlhbWwuZ290bXBsICAgICAgICAgICAgICAoR28gdGVtcGxhdGUsIGNv" + + "bnN0cnVjdHMgcGVyLWNoYXJ0IHZhbHVlcykKICAgIC0+IGNvbnN1bWVkIGJ5CnNlY3JldHMvPGVu" + + "dj4tc2VjcmV0cy55YW1sICAgICAgKHNlbnNpdGl2ZSB2YWx1ZXMpCiAgICAtPiBvdmVycmlkZGVu" + + "IGJ5CnJlbGVhc2UgaW5saW5lIHZhbHVlczogYmxvY2tzICAgKGhpZ2hlc3QgcHJlY2VkZW5jZSkK" + + "YGBgCgpDcml0aWNhbDogYGdsb2JhbC55YW1sLmdvdG1wbGAgb25seSBwYXNzZXMgdGhyb3VnaCBz" + + "cGVjaWZpYyBrZXlzIHRvIGVhY2ggY2hhcnQgKGltYWdlIHJlZ2lzdHJpZXMsIG5vZGUgc2VsZWN0" + + "b3JzLCBzdG9yYWdlLCByZXBsaWNhIGNvdW50cykuIFNldHRpbmcgYW4gYXJiaXRyYXJ5IGNoYXJ0" + + "IHZhbHVlIGluIHRoZSBlbnZpcm9ubWVudCBmaWxlIHdpbGwgYmUgc2lsZW50bHkgaWdub3JlZCBp" + + "ZiBgZ2xvYmFsLnlhbWwuZ290bXBsYCBkb2VzIG5vdCBwcm9wYWdhdGUgaXQuCgpUbyBvdmVycmlk" + + "ZSBhcmJpdHJhcnkgY2hhcnQgdmFsdWVzLCB1c2UgYSBoZWxtZmlsZSByZWxlYXNlIGB2YWx1ZXM6" + + "YCBibG9jay4gU2VlIFtPdmVycmlkaW5nIEhlbG0gQ2hhcnQgVmFsdWVzXSgjb3ZlcnJpZGluZy1o" + + "ZWxtLWNoYXJ0LXZhbHVlcykuCgojIyBDbGVhbiBJbnN0YWxsYXRpb24KCiMjIyAxLiBDcmVhdGUg" + + "bmFtZXNwYWNlcyBhbmQgaW1hZ2UgcHVsbCBzZWNyZXRzIChpZiB1c2luZyBhIHByaXZhdGUgcmVn" + + "aXN0cnkpCgpgYGBiYXNoCmZvciBucyBpbiBjYXNzYW5kcmEtc3lzdGVtIG5hdHMtc3lzdGVtIG52" + + "Y2YgYXBpLWtleXMgZXNzIHNpcyB2YXVsdC1zeXN0ZW0gY2VydC1tYW5hZ2VyOyBkbwogIGt1YmVj" + + "dGwgY3JlYXRlIG5hbWVzcGFjZSAiJG5zIiAtLWRyeS1ydW49Y2xpZW50IC1vIHlhbWwgfCBrdWJl" + + "Y3RsIGFwcGx5IC1mIC0KZG9uZQoKIyBPbmx5IGlmIHB1bGxpbmcgZnJvbSBhIHByaXZhdGUgcmVn" + + "aXN0cnkgKGUuZy4sIE5HQyBudmNyLmlvKQpleHBvcnQgTkdDX0FQSV9LRVk9Ijx5b3VyLWtleT4i" + + "CmZvciBucyBpbiBjYXNzYW5kcmEtc3lzdGVtIG5hdHMtc3lzdGVtIG52Y2YgYXBpLWtleXMgZXNz" + + "IHNpcyB2YXVsdC1zeXN0ZW0gY2VydC1tYW5hZ2VyOyBkbwogIGt1YmVjdGwgY3JlYXRlIHNlY3Jl" + + "dCBkb2NrZXItcmVnaXN0cnkgbnZjci1jcmVkcyBcCiAgICAtLWRvY2tlci1zZXJ2ZXI9bnZjci5p" + + "byBcCiAgICAtLWRvY2tlci11c2VybmFtZT0nJG9hdXRodG9rZW4nIFwKICAgIC0tZG9ja2VyLXBh" + + "c3N3b3JkPSIkTkdDX0FQSV9LRVkiIFwKICAgIC0tbmFtZXNwYWNlPSIkbnMiIFwKICAgIC0tZHJ5" + + "LXJ1bj1jbGllbnQgLW8geWFtbCB8IGt1YmVjdGwgYXBwbHkgLWYgLQpkb25lCmBgYAoKSWYgdXNp" + + "bmcgcHVsbCBzZWNyZXRzLCB5b3UgbXVzdCBhbHNvIGNvbmZpZ3VyZSBlYWNoIGhlbG1maWxlIHJl" + + "bGVhc2UgdG8gcmVmZXJlbmNlIHRoZW0uIFNlZSBbSW1hZ2UgUHVsbCBTZWNyZXRzXSgjaW1hZ2Ut" + + "cHVsbC1zZWNyZXRzKS4KCiMjIyAyLiBBdXRoZW50aWNhdGUgaGVsbSB0byB5b3VyIGNoYXJ0IHJl" + + "Z2lzdHJ5CgpCb3RoIGBkb2NrZXIgbG9naW5gIEFORCBgaGVsbSByZWdpc3RyeSBsb2dpbmAgYXJl" + + "IHJlcXVpcmVkIGZvciBOR0MuIEhlbG1maWxlIHVzZXMgaGVsbSAobm90IGRvY2tlcikgdG8gcHVs" + + "bCBPQ0kgY2hhcnRzLCBzbyB0aGUgaGVsbSBjcmVkZW50aWFsIHN0b3JlIG11c3QgYmUgYXV0aGVu" + + "dGljYXRlZCBzZXBhcmF0ZWx5LgoKYGBgYmFzaAojIE5HQyAtLSBib3RoIGNvbW1hbmRzIGFyZSBy" + + "ZXF1aXJlZApkb2NrZXIgbG9naW4gbnZjci5pbyAtdSAnJG9hdXRodG9rZW4nIC1wICIkTkdDX0FQ" + + "SV9LRVkiCmhlbG0gcmVnaXN0cnkgbG9naW4gbnZjci5pbyAtdSAnJG9hdXRodG9rZW4nIC1wICIk" + + "TkdDX0FQSV9LRVkiCgojIEVDUgphd3MgZWNyIGdldC1sb2dpbi1wYXNzd29yZCAtLXJlZ2lvbiA8" + + "cmVnaW9uPiB8IFwKICBoZWxtIHJlZ2lzdHJ5IGxvZ2luIC0tdXNlcm5hbWUgQVdTIC0tcGFzc3dv" + + "cmQtc3RkaW4gPGFjY291bnQ+LmRrci5lY3IuPHJlZ2lvbj4uYW1hem9uYXdzLmNvbQpgYGAKCj4g" + + "Tm90ZTogYGhlbG0gcmVnaXN0cnkgbG9naW5gIGtlZXBzIG9ubHkgdGhlIGxhc3QgbG9naW4gcGVy" + + "IGhvc3QgKG11bHRpLW9yZyBnb3RjaGEpLgo+IFRoZSBzdGFjayBhbmQgdGhlIGNhY2hlcyBzcGFu" + + "IHNldmVyYWwgTkdDIG9yZ3MgdGhhdCBuZWVkIGRpZmZlcmVudCBrZXlzLCBidXQgdGhleSBhbGwK" + + "PiBsaXZlIHVuZGVyIHRoZSBvbmUgaG9zdCBgbnZjci5pb2AuIEEgc2Vjb25kIGBoZWxtIHJlZ2lz" + + "dHJ5IGxvZ2luIG52Y3IuaW9gIChvcgo+IGBkb2NrZXIgbG9naW5gKSB3aXRoIGEgZGlmZmVyZW50" + + "IGtleSBzaWxlbnRseSBvdmVyd3JpdGVzIHRoZSBmaXJzdCwgc28gcHVsbHMgZm9yIHRoZQo+IGZp" + + "cnN0IG9yZyB0aGVuIGZhaWwgd2l0aCBhIG1pc2xlYWRpbmcgYDQwMyBBY2Nlc3MgRGVuaWVkYCAo" + + "bm90IGEgNDAxOiB0aGUgYXV0aAo+IHN1Y2NlZWRlZCwgaXQncyB0aGUgd3Jvbmctb3JnIGtleSku" + + "IElmIHlvdSBwdWxsIGNoYXJ0cy9pbWFnZXMgZnJvbSBtb3JlIHRoYW4gb25lIG9yZywKPiBlaXRo" + + "ZXIgcmUtcnVuIHRoZSBsb2dpbiB3aXRoIHRoZSBjb3JyZWN0IGtleSBpbW1lZGlhdGVseSBiZWZv" + + "cmUgZWFjaCBwdWxsLCBvciBwYXNzCj4gYC0tdXNlcm5hbWUgJyRvYXV0aHRva2VuJyAtLXBhc3N3" + + "b3JkIDxrZXk+YCBwZXIgYGhlbG0gcHVsbGAgaW52b2NhdGlvbiBpbnN0ZWFkIG9mIHJlbHlpbmcK" + + "PiBvbiB0aGUgc3RvcmVkIGxvZ2luLiAoUHVsbGluZyBldmVyeXRoaW5nIGZyb20gYSBzaW5nbGUg" + + "cmVnaXN0cnkgbWlycm9yIGF2b2lkcyB0aGlzCj4gZW50aXJlbHkuKQoKIyMjIDJiLiAoUmVjb21t" + + "ZW5kZWQpIFB1bGwgZnJvbSBhIHJlZ2lzdHJ5IHRoZSBjbHVzdGVyIGF1dGhlbnRpY2F0ZXMgdG8g" + + "YXV0b21hdGljYWxseQoKSWYgeW91IG1pcnJvciB0aGUgTlZDRiBpbWFnZXMgaW50byBhIHJlZ2lz" + + "dHJ5IHRoYXQgdGhlIGNsdXN0ZXIgY2FuIHB1bGwgZnJvbSB3aXRob3V0IGFuCmV4cGxpY2l0IGlt" + + "YWdlIHB1bGwgc2VjcmV0IChmb3IgZXhhbXBsZSwgYSByZWdpc3RyeSB3aGVyZSB0aGUgbm9kZSBv" + + "ciB3b3JrbG9hZCBpZGVudGl0eSBpcwpncmFudGVkIHB1bGwgYWNjZXNzIGF1dG9tYXRpY2FsbHkp" + + "LCBwb2ludCB0aGUgc3RhY2sgYXQgaXQgYW5kIHNraXAgdGhlIGNyZWRlbnRpYWwgc3RlcHMKYWJv" + + "dmUuCgoxLiBQb2ludCB0aGUgc3RhY2sgYXQgdGhlIG1pcnJvciBpbiBgZW52aXJvbm1lbnRzLzxl" + + "bnY+LnlhbWxgOgoKICAgYGBgeWFtbAogICBnbG9iYWw6CiAgICAgaW1hZ2U6CiAgICAgICByZWdp" + + "c3RyeTogPHlvdXItcmVnaXN0cnk+ICAgICAgICAgICAgIyBlLmcuIHJlZ2lzdHJ5LmV4YW1wbGUu" + + "Y29tCiAgICAgICByZXBvc2l0b3J5OiA8bWlycm9yLXN1Yi1wYXRoPgogICAgIGhlbG06CiAgICAg" + + "ICBzb3VyY2VzOiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICMgb25seSBpZiB5b3UgYWxz" + + "byBtaXJyb3JlZCB0aGUgaGVsbSBjaGFydHMKICAgICAgICAgcmVnaXN0cnk6IDx5b3VyLXJlZ2lz" + + "dHJ5PgogICAgICAgICByZXBvc2l0b3J5OiA8bWlycm9yLXN1Yi1wYXRoPgogICBgYGAKCiAgID4g" + + "VGhlIG1hbmlmZXN0IGhhcyBhIG1peCBvZiBPQ0kgYW5kIG5vbi1PQ0kgYXJ0aWZhY3RzLCBzbyBj" + + "b252ZXJ0IG5vbi1PQ0kgY2hhcnRzIGJlZm9yZQogICA+IG1pcnJvcmluZy4gQ29udGFpbmVyIGlt" + + "YWdlcyAoYG52Y3IuaW8vLi4uYCkgYXJlIGFscmVhZHkgT0NJIGFuZCBtaXJyb3IgYXMtaXMuIFNv" + + "bWUgSGVsbQogICA+IGNoYXJ0cywgdGhvdWdoLCBhcmUgcHVibGlzaGVkIHRvIGFuIGBodHRwczov" + + "L2AgSGVsbSByZXBvc2l0b3J5IChmb3IgZXhhbXBsZQogICA+IGBoZWxtLm5nYy5udmlkaWEuY29t" + + "YCkuIFRob3NlIGFyZSBub3QgT0NJIGFuZCBjYW5ub3QgYmUgcmVzb2x2ZWQgYnkgYGdsb2JhbC5o" + + "ZWxtLnNvdXJjZXNgCiAgID4gKE9DSSkgb3IgbWlycm9yZWQgZGlyZWN0bHkuIEJlZm9yZSBwb2lu" + + "dGluZyB0aGUgc3RhY2sgYXQgeW91ciBtaXJyb3IsIGNvbnZlcnQgZWFjaAogICA+IGBodHRwczov" + + "L2AgY2hhcnQgdG8gT0NJOiBgaGVsbSByZXBvIGFkZGAvYGhlbG0gcHVsbGAgdGhlIGAudGd6YCwg" + + "dGhlbgogICA+IGBoZWxtIHB1c2ggPGNoYXJ0Pi50Z3ogb2NpOi8vPHlvdXItcmVnaXN0cnk+Lzxt" + + "aXJyb3Itc3ViLXBhdGg+YC4gT25seSBPQ0kgY2hhcnRzIGNhbiBsaXZlCiAgID4gdW5kZXIgYGds" + + "b2JhbC5oZWxtLnNvdXJjZXNgLgoKMi4gU2tpcCB0aGUgY3JlZGVudGlhbCBzdGVwcyBhYm92ZS4g" + + "V2hlbiB0aGUgY2x1c3RlciBhdXRoZW50aWNhdGVzIHRvIHRoZSByZWdpc3RyeQogICBhdXRvbWF0" + + "aWNhbGx5ICh0aGUgbm9kZSBvciB3b3JrbG9hZCBpZGVudGl0eSBoYXMgcHVsbCBhY2Nlc3MpLCB0" + + "aGUgcHVsbCBuZWVkcyBubwogICBLdWJlcm5ldGVzIHNlY3JldCwgc28geW91IGRvIG5vdCBuZWVk" + + "OiB0aGUgcGVyLW5hbWVzcGFjZSBgbnZjci1jcmVkc2AgZnJvbSBzdGVwIDEKICAgKHN0aWxsIGNy" + + "ZWF0ZSB0aGUgbmFtZXNwYWNlcywganVzdCBub3QgdGhlIHNlY3JldCksIHRoZSBgZ2xvYmFsLmlt" + + "YWdlUHVsbFNlY3JldHNgIGVudHJ5LAogICBvciB0aGUgYGRvY2tlciBsb2dpbmAvYGhlbG0gcmVn" + + "aXN0cnkgbG9naW4gbnZjci5pb2AgZnJvbSBzdGVwIDIuCgogICA+IE9uZSByZXNpZHVhbCBjcmVk" + + "ZW50aWFsOiBudmNmLWFwaSBzdGlsbCB2YWxpZGF0ZXMgdGhlIHVzZXIgZnVuY3Rpb24gaW1hZ2Ug" + + "YXQKICAgPiBgZnVuY3Rpb24gY3JlYXRlYCB2aWEgdGhlIGFjY291bnQgcmVnaXN0cnkgY3JlZGVu" + + "dGlhbCwgc28gdGhhdCBjcmVkZW50aWFsIG11c3QgcG9pbnQgYXQKICAgPiB3aGljaGV2ZXIgcmVn" + + "aXN0cnkgaG9sZHMgdGhlIHVzZXIgaW1hZ2UgKHNldCBpdCB0byB5b3VyIG1pcnJvciBpZiB0aGUg" + + "aW1hZ2UgaXMgbWlycm9yZWQKICAgPiB0aGVyZSkuCgojIyMgMy4gU2V0IHRoZSByb3V0ZSBkb21h" + + "aW4KCmBnbG9iYWwuZG9tYWluYCBzZXRzIHRoZSBob3N0bmFtZSBzdWZmaXggZm9yIHJvdXRlcyBz" + + "dWNoIGFzIGBhcGkuPGRvbWFpbj5gLiBJdCBkb2VzIG5vdCBjb25maWd1cmUgdGhlIEdhdGV3YXkg" + + "b3IgaXRzIGxvYWQgYmFsYW5jZXIuIFF1ZXJ5IHRoZSBleGFjdCBleGlzdGluZyBHYXRld2F5OgoK" + + "YGBgYmFzaApHQVRFV0FZX0FERFJFU1M9JChrdWJlY3RsIGdldCBnYXRld2F5IDxnYXRld2F5LW5h" + + "bWU+IC1uIDxnYXRld2F5LW5hbWVzcGFjZT4gLW8ganNvbnBhdGg9J3suc3RhdHVzLmFkZHJlc3Nl" + + "c1swXS52YWx1ZX0nKQp0ZXN0IC1uICIkR0FURVdBWV9BRERSRVNTIgpgYGAKClRoZSBhZGRyZXNz" + + "IG1heSBiZSBhIGhvc3RuYW1lIG9yIElQLiBDbG91ZCBwcm92aWRlciBhbmQgR2F0ZXdheSBjb25m" + + "aWd1cmF0aW9uIGRldGVybWluZSB0aGUgbG9hZCBiYWxhbmNlciB0eXBlIGFuZCBhZGRyZXNzIGZv" + + "cm1hdC4gVGhlIHNlbGYtbWFuYWdlZCBzdGFjayBkb2VzIG5vdCBzZWxlY3QgZWl0aGVyLgoKRm9y" + + "IHRlbXBvcmFyeSB0ZXN0aW5nIHdpdGhvdXQgRE5TLCB1c2UgYSBzdGFibGUgcmVzZXJ2ZWQgc3Vm" + + "Zml4IHN1Y2ggYXMgYGdsb2JhbC5kb21haW46ICJudmNmLnRlc3QiYCwgY29ubmVjdCB0byBgR0FU" + + "RVdBWV9BRERSRVNTYCwgYW5kIHNlbmQgYEhvc3Q6IGFwaS5udmNmLnRlc3RgLiBGb3IgcHJvZHVj" + + "dGlvbiwgdXNlIHlvdXIgYmFzZSBETlMgZG9tYWluIGFuZCBwb2ludCBpdHMgcm91dGUgcmVjb3Jk" + + "cyB0byBgR0FURVdBWV9BRERSRVNTYC4gSWYgdGhlIGVuZHBvaW50IGxhdGVyIGNoYW5nZXMsIGtl" + + "ZXAgYGdsb2JhbC5kb21haW5gIHN0YWJsZSBhbmQgdXBkYXRlIG9ubHkgRE5TIG9yIHRoZSBjbGll" + + "bnQgZGVzdGluYXRpb24uIFNlZSBFeGFtcGxlIDQgaW4gW2V4YW1wbGVzLm1kXShleGFtcGxlcy5t" + + "ZCkuCgojIyMgNC4gUHJldmlldyBhbmQgZGVwbG95CgpgYGBiYXNoCkhFTE1GSUxFX0VOVj08ZW52" + + "LW5hbWU+IGhlbG1maWxlIHRlbXBsYXRlICAgIyBQcmV2aWV3IHJlbmRlcmVkIG1hbmlmZXN0cwpI" + + "RUxNRklMRV9FTlY9PGVudi1uYW1lPiBoZWxtZmlsZSBzeW5jICAgICAgICMgRGVwbG95CmBgYAoK" + + "PiBTZXQgQk9USCBDYXNzYW5kcmEgcGFzc3dvcmRzIGluIHRoZSBzZWNyZXRzIGZpbGUuIFRoZSBz" + + "ZWNyZXRzIGZpbGUgZG9jdW1lbnRzCj4gYERFRkFVTFRfQ0FTU0FORFJBX1BBU1NXT1JEYCwgYnV0" + + "IHRoZSBjYXNzYW5kcmEgY2hhcnQgaGFzIGEgc2Vjb25kIGNyZWRlbnRpYWwsCj4gYGNhc3NhbmRy" + + "YS5zZXJ2aWNlUm9sZVBhc3N3b3JkYCwgdGhhdCBkZWZhdWx0cyB0byBgY2hAbmczbTNgLiBJZiB5" + + "b3Ugc2V0IG9ubHkKPiBgREVGQVVMVF9DQVNTQU5EUkFfUEFTU1dPUkRgLCB0aGUgc2VydmljZSBy" + + "b2xlIGtlZXBzIHRoYXQgZGVmYXVsdCBhbmQgZXZlcnkgREItYmFja2VkCj4gc2VydmljZSBjcmFz" + + "aC1sb29wcyB3aXRoIGBCYWQgY3JlZGVudGlhbHNgIG9uY2UgaXQgdHJpZXMgdG8gYXV0aGVudGlj" + + "YXRlLiBTZXQKPiBgY2Fzc2FuZHJhLnNlcnZpY2VSb2xlUGFzc3dvcmRgIHRvIHRoZSBzYW1lIHZh" + + "bHVlIGFzIGBERUZBVUxUX0NBU1NBTkRSQV9QQVNTV09SRGAuCgojIyMgNS4gRGVwbG95bWVudCBw" + + "aGFzZXMKCkhlbG1maWxlIGRlcGxveXMgaW4gb3JkZXIgd2l0aCBkZXBlbmRlbmNpZXM6Cgp8IFBo" + + "YXNlIHwgU2VsZWN0b3IgfCBTZXJ2aWNlcyB8IFdhaXQgdGltZSB8CnwtLS0tLS0tfC0tLS0tLS0t" + + "LS18LS0tLS0tLS0tLXwtLS0tLS0tLS0tLXwKfCAxIHwgYHJlbGVhc2UtZ3JvdXA9ZGVwZW5kZW5j" + + "aWVzYCB8IE5BVFMsIE9wZW5CYW8sIENhc3NhbmRyYSB8IDUtMTAgbWluIHwKfCAyIHwgYHJlbGVh" + + "c2UtZ3JvdXA9c2VydmljZXNgIHwgQVBJLCBTSVMsIEVTUywgaW52b2NhdGlvbiwgZ3JwYy1wcm94" + + "eSwgbm90YXJ5LCBhcGkta2V5cywgb3B0aW9uYWwgTExNIGdhdGV3YXkvcm91dGVyLCBvcHRpb25h" + + "bCBWYW5pdHkgR2F0ZXdheSwgTlZDRiBVSSB3aGVuIHRoZSBzdGFjayBwYWNrYWdlIGluY2x1ZGVz" + + "IHRoZSBhZGRvbiB8IDUtMTAgbWluIHwKfCAzIHwgYHJlbGVhc2UtZ3JvdXA9aW5ncmVzc2AgfCBH" + + "YXRld2F5IHJvdXRlcyB8IDEtMiBtaW4gfAp8IDQgfCBgcmVsZWFzZS1ncm91cD1vYnNlcnZhYmls" + + "aXR5YCB8IE9ic2VydmFiaWxpdHkgc3RhY2sgKGlmIGVuYWJsZWQpIHwgMS0yIG1pbiB8CgpNb25p" + + "dG9yIGluIGEgc2VwYXJhdGUgdGVybWluYWw6CgpgYGBiYXNoCmt1YmVjdGwgZ2V0IHBvZHMgLUEg" + + "LXcKYGBgCgojIyMgNi4gRW5hYmxlIFZhbml0eSBHYXRld2F5IChvcHRpb25hbCkKClZhbml0eSBH" + + "YXRld2F5IGlzIGRpc2FibGVkIGJ5IGRlZmF1bHQgYW5kIGlzIG9ubHkgbmVlZGVkIGZvciBjdXN0" + + "b21lci1mYWNpbmcKaG9zdG5hbWVzIG9yIHBhdGggbWFwcGluZ3MgaW4gZnJvbnQgb2YgdGhlIHN0" + + "YW5kYXJkIE5WQ0YgQVBJIGFuZCBpbnZvY2F0aW9uCnJvdXRlcy4gSXQgaXMgYXZhaWxhYmxlIG9u" + + "bHkgaW4gc3RhY2sgcGFja2FnZXMgdGhhdCBpbmNsdWRlIHRoZSBWYW5pdHkgR2F0ZXdheQphZGRv" + + "bi4gSWYgdGhlIGV4dHJhY3RlZCBzdGFjayBwYWNrYWdlIGRvZXMgbm90IGNvbnRhaW4gYSBgdmFu" + + "aXR5LWdhdGV3YXlgCnJlbGVhc2UgYW5kIGB2YW5pdHlHYXRld2F5YCByb3V0ZSB2YWx1ZXMsIHNr" + + "aXAgdGhlc2UgY29tbWFuZHMgYW5kIHVzZSBhIG5ld2VyCnN0YWNrIHBhY2thZ2UgdGhhdCBpbmNs" + + "dWRlcyB0aGVtLgoKSWYgdGhlIHN0YWNrIHBhY2thZ2UgaW5jbHVkZXMgdGhlIGFkZG9uLCBlbmFi" + + "bGUgaXQgaW4KYGVudmlyb25tZW50cy88ZW52LW5hbWU+LnlhbWxgOgoKYGBgeWFtbAphZGRvbnM6" + + "CiAgdmFuaXR5R2F0ZXdheToKICAgIGVuYWJsZWQ6IHRydWUKICAgIG1hcHBpbmdDb25maWc6IHt9" + + "CmBgYAoKVGhlIGRlZmF1bHQgcm91dGUgaG9zdCBpcyBgdmFuaXR5Ljxkb21haW4+YCBhbmQgdGhl" + + "IGJhY2tlbmQgaXMKYHZhbml0eS1nYXRld2F5Lm52Y2Y6ODA4MGAuIFB1dCBkZXBsb3ltZW50LXNw" + + "ZWNpZmljIGhvc3QgYW5kIHBhdGggbWFwcGluZ3MgdW5kZXIKYGFkZG9ucy52YW5pdHlHYXRld2F5" + + "Lm1hcHBpbmdDb25maWdgLiBJZiB5b3UgbmVlZCBjdXN0b20gdmFuaXR5IGhvc3RzIGluc3RlYWQg" + + "b2YKYHZhbml0eS48ZG9tYWluPmAsIHVzZSB0aGUgcm91dGUgaG9zdG5hbWUgb3ZlcnJpZGVzIHN1" + + "cHBvcnRlZCBieSB0aGUgc3RhY2sKcGFja2FnZSBhbmQgY3JlYXRlIG1hdGNoaW5nIEROUyByZWNv" + + "cmRzLgoKQWZ0ZXIgY29uZmlybWluZyB0aGUgcGFja2FnZSBpbmNsdWRlcyB0aGUgYHZhbml0eS1n" + + "YXRld2F5YCByZWxlYXNlLCBwcmV2aWV3IGFuZAphcHBseSB0aGUgc2VydmljZSBhbmQgcm91dGU6" + + "CgpgYGBiYXNoCkhFTE1GSUxFX0VOVj08ZW52LW5hbWU+IGhlbG1maWxlIC0tc2VsZWN0b3IgbmFt" + + "ZT12YW5pdHktZ2F0ZXdheSB0ZW1wbGF0ZQpIRUxNRklMRV9FTlY9PGVudi1uYW1lPiBoZWxtZmls" + + "ZSAtLXNlbGVjdG9yIG5hbWU9dmFuaXR5LWdhdGV3YXkgc3luYwpIRUxNRklMRV9FTlY9PGVudi1u" + + "YW1lPiBoZWxtZmlsZSAtLXNlbGVjdG9yIHJlbGVhc2UtZ3JvdXA9aW5ncmVzcyBzeW5jCmBgYAoK" + + "VmVyaWZ5IHRoZSByb3V0ZSBvbmx5IHdoZW4gdGhlIGFkZG9uIGlzIHByZXNlbnQgYW5kIGVuYWJs" + + "ZWQ6CgpgYGBiYXNoCmt1YmVjdGwgZ2V0IGRlcGxveSxzdmMgLW4gbnZjZiAtbCBhcHAua3ViZXJu" + + "ZXRlcy5pby9uYW1lPXZhbml0eS1nYXRld2F5Cmt1YmVjdGwgZ2V0IGh0dHByb3V0ZSAtQSB8IGdy" + + "ZXAgLWkgdmFuaXR5CmN1cmwgLUggIkhvc3Q6IHZhbml0eS48ZG9tYWluPiIgImh0dHA6Ly88Z2F0" + + "ZXdheS1hZGRyZXNzPi9oZWFsdGgiCmBgYAoKRG8gbm90IGVuYWJsZSBWYW5pdHkgR2F0ZXdheSBm" + + "b3Igc3RhbmRhcmQgQVBJLCBBUEkgS2V5cywgaW52b2NhdGlvbiwgTExNCmludm9jYXRpb24sIG9y" + + "IGdSUEMgdHJhZmZpYy4gVGhvc2Ugcm91dGVzIGFyZSBwcm92aWRlZCBieSB0aGUgYmFzZSBnYXRl" + + "d2F5CnJvdXRlcy4KCiMjIyA3LiBFbmFibGUgTlZDRiBVSSAob3B0aW9uYWwpCgpOVkNGIFVJIGlz" + + "IGFuIG9wdGlvbmFsLCBjdXN0b21lci1mYWNpbmcgYWRtaW4tcGFuZWwgVUkuIEl0IGlzIGRpc2Fi" + + "bGVkIGJ5CmRlZmF1bHQgYW5kIGF2YWlsYWJsZSBvbmx5IGluIHN0YWNrIHBhY2thZ2VzIHRoYXQg" + + "aW5jbHVkZSB0aGUgTlZDRiBVSSBhZGRvbi4gSWYKeW91ciBleHRyYWN0ZWQgc3RhY2sgcGFja2Fn" + + "ZSBkb2VzIG5vdCBjb250YWluIGEgYG52Y2YtdWlgIHJlbGVhc2UgYW5kIGBudmNmVWlgCnJvdXRl" + + "IHZhbHVlcywgc2tpcCB0aGlzIHNlY3Rpb24uIFRoZSBOVkNGIFVJIGFkbWluIHBhbmVsIGlzIGN1" + + "cnJlbnRseQp1bmF1dGhlbnRpY2F0ZWQ7IGRvIG5vdCBleHBvc2UgaXQgdG8gdGhlIHB1YmxpYyBp" + + "bnRlcm5ldC4KCkZvciBlbmFibGVtZW50LCBuYW1lc3BhY2UgYW5kIHB1bGwgc2VjcmV0IHNldHVw" + + "LCBhcHBseSwgYW5kIHZlcmlmaWNhdGlvbiBzdGVwcywKc2VlIFtOVkNGIFVJIEFkZG9uXShyZWZl" + + "cmVuY2VzL252Y2YtdWktYWRkb24ubWQpLgoKIyMjIDguIEluc3RhbGwgdGhlIHNlcGFyYXRlIGNv" + + "bXB1dGUtcGxhbmUgc3RhY2sKClRoZSBjb250cm9sLXBsYW5lIHN0YWNrIGRvZXMgbm90IGluc3Rh" + + "bGwgY29tcHV0ZS1wbGFuZSBjb21wb25lbnRzLiBBZnRlciBpdCBpcyBoZWFsdGh5LCBjaG9vc2Ug" + + "ZXhhY3RseSBvbmUgY29tcHV0ZS1wbGFuZSBoYW5kb2ZmOgoKLSBIZWxtZmlsZSB2YWx1ZXMgZmxv" + + "dzogYXV0aG9yIHNlcGFyYXRlIGVudmlyb25tZW50IGZpbGVzLCB0aGVuIHJlZ2lzdGVyIGFuZAog" + + "IGluc3RhbGwgd2l0aCB0aGUgY29tcHV0ZS1wbGFuZSBNYWtlZmlsZS4KLSBDTEkgcHJvZmlsZSBm" + + "bG93OiB1c2UgdGhlIHByb2ZpbGUgZ2VuZXJhdGVkIGJ5IHRoZSBDTEkgY29udHJvbC1wbGFuZSBp" + + "bnN0YWxsLAogIHRoZW4gcnVuIHRoZSBjb21wbGV0ZSBDTEkgcmVnaXN0ZXIgYW5kIGluc3RhbGwg" + + "Y29tbWFuZHMuCgpEbyBub3QgbWl4IHRoZXNlIGhhbmRvZmZzLiBGb2xsb3cgW1NwbGl0IENvbXB1" + + "dGUtUGxhbmUgSW5zdGFsbGF0aW9uXShyZWZlcmVuY2VzL2NvbXB1dGUtcGxhbmUtaW5zdGFsbGF0" + + "aW9uLm1kKQpmb3IgY29tbWFuZHMsIEVLUyByb3V0aW5nLCBwdWxsIHNlY3JldHMsIHZlcmlmaWNh" + + "dGlvbiwgYW5kIHRlYXJkb3duIG9yZGVyLgoKIyMgQ2xlYW4gVGVhcmRvd24KCkRlc3Ryb3kgZXZl" + + "cnkgY29tcHV0ZSBwbGFuZSBiZWZvcmUgdGhlIGNvbnRyb2wgcGxhbmUsIHVzaW5nIHRoZSB0ZWFy" + + "ZG93biBmb3IKdGhlIHNhbWUgaGFuZG9mZjsgc2VlIFtTcGxpdCBDb21wdXRlLVBsYW5lIEluc3Rh" + + "bGxhdGlvbl0ocmVmZXJlbmNlcy9jb21wdXRlLXBsYW5lLWluc3RhbGxhdGlvbi5tZCN0ZWFyZG93" + + "bikuCgpTY29wZTogT25seSBkZXN0cm95IHJlbGVhc2VzIG1hbmFnZWQgYnkgdGhpcyBjb250cm9s" + + "LXBsYW5lIGhlbG1maWxlIHN0YWNrLiBUaGUgTlZDRiByZWxlYXNlcyBhcmU6IGBuYXRzYCwgYG9w" + + "ZW5iYW8tc2VydmVyYCwgYGNhc3NhbmRyYWAsIGBhcGkta2V5c2AsIGBzaXNgLCBgYXBpYCwgYGlu" + + "dm9jYXRpb24tc2VydmljZWAsIGBncnBjLXByb3h5YCwgYGVzcy1hcGlgLCBgbm90YXJ5LXNlcnZp" + + "Y2VgLCBvcHRpb25hbCBgdmFuaXR5LWdhdGV3YXlgLCBgbnZjZi11aWAsIGBhZG1pbi1pc3N1ZXIt" + + "cHJveHlgLCBhbmQgYGluZ3Jlc3NgOyBgY2VydC1tYW5hZ2VyYCBpcyBpbmNsdWRlZCBvbmx5IHdo" + + "ZW4gYGNlcnRNYW5hZ2VyLmVuYWJsZWQ6IHRydWVgLiBUaGUgY29udHJvbC1wbGFuZSBuYW1lc3Bh" + + "Y2UgaW52ZW50b3J5IGFsc28gaW5jbHVkZXMgYGNlcnQtbWFuYWdlcmAsIGJ1dCBkZWZhdWx0IG5h" + + "bWVzcGFjZSBjbGVhbnVwIHByZXNlcnZlcyBpdC4gTmFtZXNwYWNlIHByZXNlcnZhdGlvbiBkb2Vz" + + "IG5vdCBwcmVzZXJ2ZSB0aGUgSGVsbSByZWxlYXNlLiBFeHRlcm5hbCBjZXJ0LW1hbmFnZXIgbXVz" + + "dCB1c2UgYGNlcnRNYW5hZ2VyLmVuYWJsZWQ6IGZhbHNlYDsgb3RoZXJ3aXNlIEhlbG1maWxlIHRy" + + "ZWF0cyB0aGUgcmVsZWFzZSBhcyBzdGFjay1tYW5hZ2VkLiBEbyBub3QgZGVsZXRlIG90aGVyIGhl" + + "bG0gcmVsZWFzZXMgb3IgbmFtZXNwYWNlcyBvbiB0aGUgY2x1c3Rlci4KCkJlZm9yZSBjb250cm9s" + + "LXBsYW5lIGRlc3Ryb3ksIGlkZW50aWZ5IHdoZXRoZXIgY2VydC1tYW5hZ2VyIGlzIGV4dGVybmFs" + + "LiBGb3IgYW4gZXh0ZXJuYWwgaW5zdGFsbGF0aW9uLCByZXF1aXJlIGVmZmVjdGl2ZSBgY2VydE1h" + + "bmFnZXIuZW5hYmxlZDogZmFsc2VgIGFuZCBhYm9ydCBpZiBpdCBpcyB0cnVlLiBGb3IgYW4gaW50" + + "ZW5kZWQgc3RhY2stbWFuYWdlZCByZWxlYXNlIHdpdGggZWZmZWN0aXZlIGBjZXJ0TWFuYWdlci5l" + + "bmFibGVkOiB0cnVlYCwgdmVyaWZ5IG1hdGNoaW5nIHN0YWNrIEhlbG0gcmVsZWFzZSBtZXRhZGF0" + + "YSBhbmQgYWJvcnQgb24gbWlzc2luZyBvciBtaXNtYXRjaGVkIGV2aWRlbmNlLiBQcmVzZXJ2ZSB0" + + "aGUgbmFtZXNwYWNlIGJ5IGRlZmF1bHQ7IG9ubHkgcGxhbiBpdHMgcmVtb3ZhbCBhZnRlciB2ZXJp" + + "ZnlpbmcgbmFtZXNwYWNlIHByb3ZlbmFuY2UgYW5kIGdldHRpbmcgZXhwbGljaXQgY29uZmlybWF0" + + "aW9uLgoKIyMjIFN0YW5kYXJkIHRlYXJkb3duCgpSdW4gZnJvbSBpbnNpZGUgdGhlIGBudmNmLXNl" + + "bGYtbWFuYWdlZC1zdGFjay9gIGRpcmVjdG9yeToKCmBgYGJhc2gKSEVMTUZJTEVfRU5WPTxlbnYt" + + "bmFtZT4gaGVsbWZpbGUgZGVzdHJveQpgYGAKCiMjIyBEZWxldGUgbmFtZXNwYWNlcwoKYGBgYmFz" + + "aApmb3IgbnMgaW4gY2Fzc2FuZHJhLXN5c3RlbSBuYXRzLXN5c3RlbSBudmNmIGFwaS1rZXlzIGVz" + + "cyBzaXMgbnZjZi11aSB2YXVsdC1zeXN0ZW07IGRvCiAga3ViZWN0bCBkZWxldGUgbmFtZXNwYWNl" + + "ICIkbnMiIC0taWdub3JlLW5vdC1mb3VuZApkb25lCmBgYAoKIyMjIFZlcmlmeSBjbGVhbgoKYGBg" + + "YmFzaAprdWJlY3RsIGdldCBucyB8IGdyZXAgLUUgJyhjYXNzYW5kcmF8bmF0c3x2YXVsdHxudmNm" + + "fGFwaS1rZXlzfGVzc3xzaXMpJwojIFNob3VsZCByZXR1cm4gZW1wdHkKYGBgCgojIyBPdmVycmlk" + + "aW5nIEhlbG0gQ2hhcnQgVmFsdWVzCgojIyMgRW52aXJvbm1lbnQgZmlsZSAobGltaXRlZCkKCldv" + + "cmtzIG9ubHkgZm9yIGtleXMgdGhhdCBgZ2xvYmFsLnlhbWwuZ290bXBsYCBwcm9wYWdhdGVzIChl" + + "LmcuLCBgY2Fzc2FuZHJhLnJlcGxpY2FDb3VudGAsIGBnbG9iYWwuc3RvcmFnZUNsYXNzYCwgYGds" + + "b2JhbC5pbWFnZWApLgoKIyMjIFJlbGVhc2UgdmFsdWVzIGJsb2NrIChhbnkgY2hhcnQgdmFsdWUp" + + "CgpFZGl0IHRoZSByZWxlYXNlIGluIGBoZWxtZmlsZS5kLyoueWFtbC5nb3RtcGxgIGFuZCBhZGQg" + + "YSBgdmFsdWVzOmAgYmxvY2suIEluIHRoZSBleGFtcGxlcyBiZWxvdywgYDxwcml2YXRlLXZhbHVl" + + "cz5gIHJlZmVycyB0byB0aGUgYHNlY3JldHMvYCBkaXJlY3RvcnkgYXQgdGhlIGhlbG1maWxlIHN0" + + "YWNrIHJvb3QuCgpgYGB5YW1sCi0gbmFtZTogY2Fzc2FuZHJhCiAgdmVyc2lvbjogMC44LjAKICBj" + + "b25kaXRpb246IGNhc3NhbmRyYS5lbmFibGVkCiAgbmFtZXNwYWNlOiBjYXNzYW5kcmEtc3lzdGVt" + + "CiAgPDw6ICpkZXBlbmRlbmN5CiAgdmFsdWVzOgogICAgLSAuLi9nbG9iYWwueWFtbC5nb3RtcGwK" + + "ICAgIC0gLi4vPHByaXZhdGUtdmFsdWVzPi97eyByZXF1aXJlZEVudiAiSEVMTUZJTEVfRU5WIiB9" + + "fS1zZWNyZXRzLnlhbWwKICAgIC0gY2Fzc2FuZHJhOgogICAgICAgIHJlc291cmNlczoKICAgICAg" + + "ICAgIGxpbWl0czoKICAgICAgICAgICAgY3B1OiAiOCIKICAgICAgICAgICAgbWVtb3J5OiA4MTky" + + "TWkKICAgICAgICAgIHJlcXVlc3RzOgogICAgICAgICAgICBjcHU6ICIyIgogICAgICAgICAgICBt" + + "ZW1vcnk6IDQwOTZNaQpgYGAKCllBTUwgbWVyZ2UgZ290Y2hhOiBXaGVuIGEgcmVsZWFzZSB1c2Vz" + + "IGA8PDogKmRlcGVuZGVuY3lgIG9yIGBpbmhlcml0YCwgc3BlY2lmeWluZyBgdmFsdWVzOmAgcmVw" + + "bGFjZXMgdGhlIHRlbXBsYXRlJ3MgdmFsdWVzIGxpc3QuIFlvdSBtdXN0IHJlLWluY2x1ZGUgYGds" + + "b2JhbC55YW1sLmdvdG1wbGAgYW5kIHRoZSBzZWNyZXRzIGZpbGUuCgojIyMgUHJldmlldyBhbmQg" + + "YXBwbHkgYSBzaW5nbGUgcmVsZWFzZQoKYGBgYmFzaApIRUxNRklMRV9FTlY9PGVudj4gaGVsbWZp" + + "bGUgLS1zZWxlY3RvciBuYW1lPWNhc3NhbmRyYSB0ZW1wbGF0ZSAgIyBQcmV2aWV3CkhFTE1GSUxF" + + "X0VOVj08ZW52PiBoZWxtZmlsZSAtLXNlbGVjdG9yIG5hbWU9Y2Fzc2FuZHJhIHN5bmMgICAgICAj" + + "IEFwcGx5CmBgYAoKIyMgSW1hZ2UgUHVsbCBTZWNyZXRzCgpUaGVyZSBhcmUgdGhyZWUgZGlzdGlu" + + "Y3QgY3JlZGVudGlhbCB0eXBlcy4gRG8gbm90IGNvbmZsYXRlIHRoZW0sIGFuZCBtaW5kIHRoZQpm" + + "b3JtYXQgcnVsZSBiZWxvdyAodHdvIG9mIHRoZW0gZmFpbCBldmVuIHdpdGggdGhlIGNvcnJlY3Qg" + + "a2V5IGlmIHRoZSBmb3JtYXQgaXMgd3JvbmcpOgoKfCB8IENvbnRyb2wgUGxhbmUgUHVsbCBTZWNy" + + "ZXRzIHwgQVBJIEJvb3RzdHJhcCBSZWdpc3RyeSBDcmVkcyB8IFNpZGVjYXIgSW1hZ2UtUHVsbCBT" + + "ZWNyZXQgfAp8LS0tfC0tLXwtLS18LS0tfAp8IFB1cnBvc2UgfCBLOHMgcHVsbHMgTlZDRiBzZXJ2" + + "aWNlIGltYWdlcyB8IG52Y2YtYXBpIHZhbGlkYXRlcyB0aGUgdXNlciBmdW5jdGlvbiBpbWFnZSBh" + + "dCBgZnVuY3Rpb24gY3JlYXRlYCB8IG52Y2YtYXBpIHB1bGxzIHRoZSBwbGF0Zm9ybSBzaWRlY2Fy" + + "cyBpbmplY3RlZCBpbnRvIGV2ZXJ5IHdvcmtlciBwb2QgfAp8IFdoZXJlIHwgSzhzIGBkb2NrZXIt" + + "cmVnaXN0cnlgIFNlY3JldHMgKyBLeXZlcm5vIENsdXN0ZXJQb2xpY3kgfCBgPHByaXZhdGUtdmFs" + + "dWVzPi88ZW52Pi1zZWNyZXRzLnlhbWxgIChhY2NvdW50LWJvb3RzdHJhcCkgfCBgTlZDRl9BUElf" + + "U0lERUNBUlNfSU1BR0VfUFVMTF9TRUNSRVRgIGluIGA8ZW52Pi1zZWNyZXRzLnlhbWxgIC0+IE9w" + + "ZW5CYW8gYHNlcnZpY2VzL252Y2YtYXBpL2t2L3NpZGVjYXJzL2ltYWdlLXB1bGwtc2VjcmV0YCAo" + + "ZmllbGQgYHNlY3JldGApIHwKfCBGb3JtYXQgfCBzdGFuZGFyZCBgLmRvY2tlcmNvbmZpZ2pzb25g" + + "IChrdWJlY3RsIGJ1aWxkcyBpdCBmb3IgeW91KSB8IGBiYXNlNjQoIiRvYXV0aHRva2VuOjxrZXk+" + + "IilgIHwgYGJhc2U2NCgiJG9hdXRodG9rZW46PGtleT4iKWAgfAoKPiBOb3RlOiB0aGUgYWNjb3Vu" + + "dC1ib290c3RyYXAgY3JlZCBhbmQgdGhlIHNpZGVjYXIgc2VjcmV0IGFyZSBOT1QgYQo+IGRvY2tl" + + "cmNvbmZpZ2pzb24uIFRoZSBzZWNyZXRzIHRlbXBsYXRlIHNoaXBzIHRoZSBwbGFjZWhvbGRlcgo+" + + "IGBSRVBMQUNFX1dJVEhfQkFTRTY0X0RPQ0tFUl9DUkVERU5USUFMYCwgd2hpY2ggcmVhZHMgYXMg" + + "ImJhc2U2NCBvZiBhIGRvY2tlcmNvbmZpZ2pzb24uIgo+IEl0IGlzbid0LiBCb3RoIHZhbHVlcyBh" + + "cmUgY29uc3VtZWQgYXMgYSByYXcgZG9ja2VyIGBhdXRoYCBzdHJpbmc6IG52Y2YtYXBpIHRha2Vz" + + "IHRoZQo+IHZhbHVlIHZlcmJhdGltIGFuZCBkcm9wcyBpdCBpbnRvIHRoZSBgYXV0aGAgZmllbGQg" + + "b2YgdGhlIGRvY2tlcmNvbmZpZyBpdCBidWlsZHMuIFNvIHRoZQo+IHZhbHVlIG11c3QgYmUgYGJh" + + "c2U2NCgiJG9hdXRodG9rZW46PGtleT4iKWAsIGUuZy4gYHByaW50ZiAnJG9hdXRodG9rZW46JXMn" + + "ICIkS0VZIiB8IG9wZW5zc2wgYmFzZTY0IC1BYCwKPiBub3QgYGJhc2U2NCg8ZG9ja2VyY29uZmln" + + "anNvbj4pYC4KPiAgLSBXcm9uZyBhY2NvdW50LWJvb3RzdHJhcCB2YWx1ZTogYGZ1bmN0aW9uIGNy" + + "ZWF0ZWAgcmV0dXJucwo+ICAgIGA0MDAgIm11c3QgYmUgYmFzZTY0IGVuY29kZWQgdXNlcm5hbWU6" + + "cGFzc3dvcmQgZm9ybWF0ImAuCj4gIC0gV3Jvbmcgc2lkZWNhciB2YWx1ZTogZXZlcnkgd29ya2Vy" + + "J3Mgc2lkZWNhciBwdWxsIGdldHMgYSBtYWxmb3JtZWQgY3JlZGVudGlhbCBhbmQKPiAgICBgNDAz" + + "YHMsIHJlZ2FyZGxlc3Mgb2Ygd2hpY2gga2V5IGlzIGluc2lkZS4gVGhlIHN5bXB0b20gbG9va3Mg" + + "bGlrZSBhIGJhZCBvciB3cm9uZy1vcmcKPiAgICBrZXksIGJ1dCB0aGUga2V5IGlzIGZpbmUgYW5k" + + "IHRoZSBlbmNvZGluZyBpcyB0aGUgYnVnLiBUbyByZXBhaXIgYW4gYWxyZWFkeS1pbnN0YWxsZWQK" + + "PiAgICBzdGFjayB3aXRob3V0IGEgZnVsbCByZS1zeW5jOgo+ICAgIGBgYGJhc2gKPiAgICBBVVRI" + + "PSQocHJpbnRmICckb2F1dGh0b2tlbjolcycgIiRLRVkiIHwgb3BlbnNzbCBiYXNlNjQgLUEpCj4g" + + "ICAgYmFvIGt2IHB1dCBzZXJ2aWNlcy9udmNmLWFwaS9rdi9zaWRlY2Fycy9pbWFnZS1wdWxsLXNl" + + "Y3JldCBzZWNyZXQ9IiRBVVRIIgo+ICAgICMgaWYgTlZJRElBIENsb3VkIFRhc2tzIGlzIGVuYWJs" + + "ZWQsIHJlcGVhdCBmb3Igc2VydmljZXMvbnZjdC1hcGkva3Yvc2lkZWNhcnMvaW1hZ2UtcHVsbC1z" + + "ZWNyZXQKPiAgICBrdWJlY3RsIHJvbGxvdXQgcmVzdGFydCAtbiBudmNmIGRlcGxveS9udmNmLWFw" + + "aSAgICMgcGlja3MgdXAgdGhlIG5ldyBzaWRlY2FyIGNyZWQKPiAgICBgYGAKCj4gTm90ZSAobXVs" + + "dGktb3JnKTogd2hlbiBwdWxsaW5nIGZyb20gTkdDIChub3QgYSBtaXJyb3IpLCB0aGUgdXNlciBm" + + "dW5jdGlvbiBpbWFnZSBhbmQKPiB0aGUgcGxhdGZvcm0gc2lkZWNhcnMgb2Z0ZW4gbGl2ZSBpbiBk" + + "aWZmZXJlbnQgbnZjci5pbyBvcmdzLCBlYWNoIG5lZWRpbmcgYSBkaWZmZXJlbnQKPiBrZXksIHNv" + + "IHRoZSBhY2NvdW50LWJvb3RzdHJhcCBjcmVkIChmdW5jdGlvbiBpbWFnZSkgYW5kIHRoZSBzaWRl" + + "Y2FyIHNlY3JldCAoc2lkZWNhcnMpCj4gYXJlIGZyZXF1ZW50bHkgdHdvIGRpZmZlcmVudCBrZXlz" + + "LiBNaXJyb3JpbmcgZXZlcnl0aGluZyBpbnRvIGEgc2luZ2xlIHJlZ2lzdHJ5IHRoZQo+IGNsdXN0" + + "ZXIgYXV0aGVudGljYXRlcyB0byBhdXRvbWF0aWNhbGx5IGNvbGxhcHNlcyB0aGlzIHRvIG9uZSBj" + + "cmVkZW50aWFsIHBhdGguCgojIyMgQ29uZmlndXJpbmcgd2l0aCBLeXZlcm5vIChyZWNvbW1lbmRl" + + "ZCkKClVzZSBhIEt5dmVybm8gbXV0YXRpbmcgYWRtaXNzaW9uIHBvbGljeSB0byBhdXRvbWF0aWNh" + + "bGx5IGluamVjdCBgaW1hZ2VQdWxsU2VjcmV0c2AgaW50byBhbGwgcG9kcyBpbiBOVkNGIG5hbWVz" + + "cGFjZXMuIFRoaXMgd29ya3MgdW5pZm9ybWx5IGZvciBhbGwgY2hhcnRzIC0tIG5vIHBlci1jaGFy" + + "dCBjb25maWd1cmF0aW9uIG9yIGhlbG1maWxlIG1vZGlmaWNhdGlvbnMgbmVlZGVkLgoKYGBgYmFz" + + "aAojIDEuIEluc3RhbGwgS3l2ZXJubwpoZWxtIHJlcG8gYWRkIGt5dmVybm8gaHR0cHM6Ly9reXZl" + + "cm5vLmdpdGh1Yi5pby9reXZlcm5vLwpoZWxtIHJlcG8gdXBkYXRlCmhlbG0gaW5zdGFsbCBreXZl" + + "cm5vIGt5dmVybm8va3l2ZXJubyAtbiBreXZlcm5vIC0tY3JlYXRlLW5hbWVzcGFjZQoKIyAyLiBD" + + "cmVhdGUgcHVsbCBzZWNyZXQgaW4gZWFjaCBuYW1lc3BhY2UKZXhwb3J0IE5HQ19BUElfS0VZPSI8" + + "eW91ci1rZXk+Igpmb3IgbnMgaW4gY2Fzc2FuZHJhLXN5c3RlbSBuYXRzLXN5c3RlbSBudmNmIGFw" + + "aS1rZXlzIGVzcyBzaXMgdmF1bHQtc3lzdGVtIGNlcnQtbWFuYWdlcjsgZG8KICBrdWJlY3RsIGNy" + + "ZWF0ZSBzZWNyZXQgZG9ja2VyLXJlZ2lzdHJ5IG52Y3ItY3JlZHMgXAogICAgLS1kb2NrZXItc2Vy" + + "dmVyPW52Y3IuaW8gXAogICAgLS1kb2NrZXItdXNlcm5hbWU9JyRvYXV0aHRva2VuJyBcCiAgICAt" + + "LWRvY2tlci1wYXNzd29yZD0iJE5HQ19BUElfS0VZIiBcCiAgICAtLW5hbWVzcGFjZT0iJG5zIiBc" + + "CiAgICAtLWRyeS1ydW49Y2xpZW50IC1vIHlhbWwgfCBrdWJlY3RsIGFwcGx5IC1mIC0KZG9uZQoK" + + "IyAzLiBBcHBseSB0aGUgS3l2ZXJubyBDbHVzdGVyUG9saWN5Cmt1YmVjdGwgYXBwbHkgLWYga3l2" + + "ZXJuby1pbWFnZXB1bGxzZWNyZXQtcG9saWN5LnlhbWwKYGBgCgpUaGUgcG9saWN5IG11dGF0ZXMg" + + "ZXZlcnkgcG9kIGF0IGFkbWlzc2lvbiB0aW1lLCBhZGRpbmcgYGltYWdlUHVsbFNlY3JldHM6IFt7" + + "bmFtZTogbnZjci1jcmVkc31dYC4gVmVyaWZ5IHdpdGg6CgpgYGBiYXNoCmt1YmVjdGwgZ2V0IHBv" + + "ZCAtbiA8bmFtZXNwYWNlPiA8cG9kLW5hbWU+IC1vIGpzb25wYXRoPSd7LnNwZWMuaW1hZ2VQdWxs" + + "U2VjcmV0c30nCiMgU2hvdWxkIHNob3c6IFt7Im5hbWUiOiJudmNyLWNyZWRzIn1dCmBgYAoKTm90" + + "IG5lZWRlZCBpZiB1c2luZyBhIENTUCBidWlsdC1pbiBjcmVkZW50aWFsIGhlbHBlciAoZS5nLiwg" + + "RUNSIHdpdGggSUFNIG5vZGUgcm9sZXMpLgoKRm9yIHRoZSBLeXZlcm5vIHBvbGljeSBZQU1MIGFu" + + "ZCBwdWxsIHNlY3JldCBjcmVhdGlvbiBzY3JpcHQsIHNlZSBbcmVmZXJlbmNlcy9wdWxsLXNlY3Jl" + + "dHMubWRdKHJlZmVyZW5jZXMvcHVsbC1zZWNyZXRzLm1kKS4KCiMjIERlYnVnZ2luZwoKIyMjIFF1" + + "aWNrIHN0YXR1cyBjaGVjawoKYGBgYmFzaAprdWJlY3RsIGdldCBwb2RzIC1BIC1vIHdpZGUgICAg" + + "ICAgICAgICAgICAgICAgICAgICAjIEFsbCBwb2RzCmhlbG0gbGlzdCAtQSAgICAgICAgICAgICAg" + + "ICAgICAgICAgICAgICAgICAgICAgICAgICAjIEFsbCBoZWxtIHJlbGVhc2VzCmt1YmVjdGwgZ2V0" + + "IGV2ZW50cyAtbiA8bnM+IC0tc29ydC1ieT0nLmxhc3RUaW1lc3RhbXAnICAjIFJlY2VudCBldmVu" + + "dHMKYGBgCgojIyMgQ29tbW9uIGZhaWx1cmUgcGF0dGVybnMKCnwgU3ltcHRvbSB8IENhdXNlIHwg" + + "Rml4IHwKfC0tLS0tLS0tLXwtLS0tLS0tfC0tLS0tfAp8IGBJbWFnZVB1bGxCYWNrT2ZmYCArIGA0" + + "MDEgVW5hdXRob3JpemVkYCB8IE1pc3Npbmcgb3Igd3JvbmcgcHVsbCBzZWNyZXQgfCBDaGVjayBz" + + "ZWNyZXQgZXhpc3RzLCBjaGVjayBTQSBoYXMgaW1hZ2VQdWxsU2VjcmV0cyB8CnwgYEluaXQ6MC8x" + + "YCBzdHVjayBvbiBzZXJ2aWNlIHBvZHMgfCBWYXVsdC1hZ2VudCB3YWl0aW5nIGZvciBPcGVuQmFv" + + "IHwgQ2hlY2sgT3BlbkJhbyBwb2RzICsgbWlncmF0aW9uIGpvYiBzdGF0dXMgfAp8IGBJbml0OjAv" + + "MWAgKyBgdmF1bHQtYWdlbnQtaW5pdGAgc2hvd3MgYGF1dGgvand0L2xvZ2luYCAtPiBgNDAwIC4u" + + "LiBubyBrbm93biBrZXkgc3VjY2Vzc2Z1bGx5IHZhbGlkYXRlZCB0aGUgdG9rZW4gc2lnbmF0dXJl" + + "YCB8IE9wZW5CYW8gSldUIGF1dGggY29uZmlndXJlZCB3aXRoIGEgc3RhdGljIHB1YmtleSBpbnN0" + + "ZWFkIG9mIHRoZSBjbHVzdGVyJ3MgbGl2ZSBKV0tTIC0tIHRoZSBiYXNlIGRlZmF1bHQgYG9wZW5i" + + "YW8ubWlncmF0aW9ucy5pc3N1ZXJEaXNjb3ZlcnkuZW5hYmxlZDogZmFsc2VgLiBDb21tb24gb24g" + + "QUtTIC8gYW55IE9JREMtaXNzdWVyIGNsdXN0ZXIgfCBTZXQgYG9wZW5iYW8ubWlncmF0aW9ucy5p" + + "c3N1ZXJEaXNjb3ZlcnkuZW5hYmxlZDogdHJ1ZWAsIGRlbGV0ZSBqb2IgYG9wZW5iYW8tc2VydmVy" + + "LW1pZ3JhdGlvbnNgLCByZS1zeW5jIGBvcGVuYmFvLXNlcnZlcmAuIFNlZSBbcmVmZXJlbmNlcy9k" + + "ZWJ1Z2dpbmcubWRdKHJlZmVyZW5jZXMvZGVidWdnaW5nLm1kKSAiSW5pdDowLzEgU3R1Y2siIGZp" + + "eCAjNC4gfAp8IGBPT01LaWxsZWRgIG9uIENhc3NhbmRyYSB8IERlZmF1bHQgcmVzb3VyY2VzIHRv" + + "byBzbWFsbCB8IE92ZXJyaWRlIGBjYXNzYW5kcmEucmVzb3VyY2VzYCB2aWEgdmFsdWVzIGJsb2Nr" + + "IHwKfCBEQi1iYWNrZWQgc2VydmljZXMgY3Jhc2gtbG9vcCBgQmFkIGNyZWRlbnRpYWxzYCBjb25u" + + "ZWN0aW5nIHRvIENhc3NhbmRyYSB8IFNlY3JldHMgZmlsZSBzZXQgb25seSBgREVGQVVMVF9DQVNT" + + "QU5EUkFfUEFTU1dPUkRgOyBgY2Fzc2FuZHJhLnNlcnZpY2VSb2xlUGFzc3dvcmRgIHN0aWxsIGRl" + + "ZmF1bHRzIHRvIGBjaEBuZzNtM2AgfCBTZXQgYGNhc3NhbmRyYS5zZXJ2aWNlUm9sZVBhc3N3b3Jk" + + "YCBpbiB0aGUgc2VjcmV0cyBmaWxlIGVxdWFsIHRvIGBERUZBVUxUX0NBU1NBTkRSQV9QQVNTV09S" + + "RGAsIHRoZW4gcmUtc3luYyBjYXNzYW5kcmEgKyB0aGUgREItYmFja2VkIHNlcnZpY2VzIHwKfCBg" + + "UGVuZGluZ2AgcG9kcyB8IE5vZGUgc2VsZWN0b3IgbWlzbWF0Y2ggb3Igbm8gc3RvcmFnZSBjbGFz" + + "cyB8IGBrdWJlY3RsIGRlc2NyaWJlIHBvZGAsIGNoZWNrIGxhYmVscyBhbmQgc3RvcmFnZSB8Cnwg" + + "SGVsbSByZWxlYXNlIGluIGBmYWlsZWRgIHN0YXRlIHwgRmlyc3QgaW5zdGFsbCBmYWlsZWQgcGFy" + + "dHdheSB8IGBoZWxtZmlsZSBkZXN0cm95YCB0aGUgcmVsZWFzZSwgdGhlbiBgc3luY2AgYWdhaW4g" + + "fAp8IEFjY291bnQgYm9vdHN0cmFwIHRpbWVvdXQgfCBXcm9uZyBiYXNlNjQgY3JlZGVudGlhbHMg" + + "aW4gc2VjcmV0cyBmaWxlIHwgQ2hlY2sgYGt1YmVjdGwgbG9ncyBqb2IvbnZjZi1hcGktYWNjb3Vu" + + "dC1ib290c3RyYXAgLW4gbnZjZmAgfAp8IGZ1bmN0aW9uIC8gYWNjb3VudCBjYWxscyByZXR1cm4g" + + "YDQwNCBVbmtub3duIGNsaWVudF9pZGAgfCBUaGUgYWNjb3VudC1ib290c3RyYXAgcG9zdC1pbnN0" + + "YWxsIGhvb2sgbmV2ZXIgcmFuOiB0aGUgYGFwaWAgcmVsZWFzZSBpbnN0YWxsIGZhaWxlZCwgb3Ig" + + "d2FzIHJlcGFpcmVkIHdpdGggbGl2ZSBwYXRjaGVzIGluc3RlYWQgb2YgYSBjbGVhbiByZS1zeW5j" + + "LCBzbyB0aGUgaG9vayAoYW5kIHRoZSBhY2NvdW50KSB3YXMgc2tpcHBlZCB8IFZlcmlmeSBhbmQg" + + "cmUtcnVuIHRoZSBob29rOyBzZWUgW1ZlcmlmeSB0aGUgYWNjb3VudCBib290c3RyYXAgcmFuXSgj" + + "dmVyaWZ5LXRoZS1hY2NvdW50LWJvb3RzdHJhcC1yYW4pIHwKfCBTZXJ2aWNlcyBmYWlsIHRvIHJl" + + "YWQgdmF1bHQgc2VjcmV0czsgYHNlY3JldHMuanNvbmAgbm90IGZvdW5kIHwgVmF1bHQgcGF0aCBo" + + "YXJkY29kZWQgdG8gYC9ob21lL2FwcC92YXVsdC9gIGluIGBfaGVscGVycy50cGxgOyB0aGUgcnVu" + + "dGltZSByZXNvbHZlcyB0aGUgbW91bnRlZCBwYXRoIHJlbGF0aXZlIHRvIHRoZSB3b3JraW5nIGRp" + + "cmVjdG9yeSBhbmQgZHJvcHMgdGhlIGxlYWRpbmcgYC9gIHwgT3ZlcnJpZGUgYHBvZEFubm90YXRp" + + "b25zYCBhbmQgc2V0IGBKQVZBX1RPT0xfT1BUSU9OUzogIi1EdXNlci5kaXI9LyJgIGluIHJlbGVh" + + "c2UgdmFsdWVzIHwKfCBOQVRTIGNvbm5lY3Rpb24gZmFpbHMgYXQgc3RhcnR1cDsgcGxhY2VtZW50" + + "IHRhZyBtaXNtYXRjaCB8IE5BVFMgc2VydmVyIHRhZ3MgaGFyZGNvZGVkIHRvIGBkYzpuY3BgOyBh" + + "cHAgZGVyaXZlcyB0YWcgZnJvbSBgQVdTX1JFR0lPTmAgKGUuZy4sIGB1cy1nb3Ytd2VzdC0xYCkg" + + "fCBTZXQgYEFXU19SRUdJT049bmNwYCBhbmQgYE5WQ0ZfQVdTX1JFR0lPTj1uY3BgIGluIGVudiBj" + + "b25maWcgfAoKIyMjIFZlcmlmeSB0aGUgYWNjb3VudCBib290c3RyYXAgcmFuCgpUaGUgZGVmYXVs" + + "dCBhY2NvdW50IGlzIGNyZWF0ZWQgYnkgYSAqKmBwb3N0LWluc3RhbGxgIGhvb2sgb24gdGhlIGBh" + + "cGlgIHJlbGVhc2UqKgooYGpvYi9udmNmLWFwaS1hY2NvdW50LWJvb3RzdHJhcGAgaW4gYG52Y2Zg" + + "KS4gQmVjYXVzZSBpdCBpcyBhIHBvc3QtaW5zdGFsbCBob29rLCBpdCBvbmx5CmZpcmVzIG9uIGEg" + + "c3VjY2Vzc2Z1bCBgYXBpYCBpbnN0YWxsLiBJZiB0aGF0IGluc3RhbGwgZmFpbGVkIGFuZCB5b3Ug" + + "cmVwYWlyZWQgaXQgd2l0aCBsaXZlCnBhdGNoZXMgKHJhdGhlciB0aGFuIGEgY2xlYW4gcmUtc3lu" + + "YyksIHRoZSBob29rIG5ldmVyIHJ1bnMsIG5vIGFjY291bnQgaXMgY3JlYXRlZCwgYW5kCmV2ZXJ5" + + "IHN1YnNlcXVlbnQgZnVuY3Rpb24vYWNjb3VudCBjYWxsIHJldHVybnMgYSBjcnlwdGljIGA0MDQg" + + "VW5rbm93biBjbGllbnRfaWRgIHdpdGgKbm90aGluZyBvYnZpb3VzbHkgd3JvbmcgaW4gdGhlIHJ1" + + "bm5pbmcgcG9kcy4KClZlcmlmeSBpdCByYW4gYWZ0ZXIgdGhlIGZpcnN0IHN5bmM6CgpgYGBiYXNo" + + "Cmt1YmVjdGwgZ2V0IGpvYiAtbiBudmNmIG52Y2YtYXBpLWFjY291bnQtYm9vdHN0cmFwIFwKICAt" + + "byBqc29ucGF0aD0ney5zdGF0dXMuc3VjY2VlZGVkfScgICAjIGV4cGVjdCAxCmBgYAoKSWYgdGhl" + + "IGpvYiBpcyBhYnNlbnQgb3IgYDBgLCByZS1ydW4gaXQgYnkgcmUtc3luY2luZyB0aGUgYGFwaWAg" + + "cmVsZWFzZSBzbyB0aGUgaG9vayBmaXJlcwphZ2FpbiAoZGVsZXRlIHRoZSBwcmlvciBqb2IgZmly" + + "c3QgaWYgaXQgbGluZ2VycyBpbiBhIGNvbXBsZXRlZC9mYWlsZWQgc3RhdGUgYW5kIGJsb2NrcyB0" + + "aGUKaG9vayk6CgpgYGBiYXNoCmt1YmVjdGwgZGVsZXRlIGpvYiAtbiBudmNmIG52Y2YtYXBpLWFj" + + "Y291bnQtYm9vdHN0cmFwIC0taWdub3JlLW5vdC1mb3VuZApIRUxNRklMRV9FTlY9PGVudj4gaGVs" + + "bWZpbGUgLS1zZWxlY3RvciBuYW1lPWFwaSBzeW5jCmt1YmVjdGwgbG9ncyAtbiBudmNmIGpvYi9u" + + "dmNmLWFwaS1hY2NvdW50LWJvb3RzdHJhcCAgICMgY29uZmlybSB0aGUgYWNjb3VudCB3YXMgY3Jl" + + "YXRlZApgYGAKCiMjIEFkZGl0aW9uYWwgUmVzb3VyY2VzCgotIEluc3RhbGxhdGlvbjogW2V4YW1w" + + "bGVzLm1kXShleGFtcGxlcy5tZCksIHRoZSBbQ1NQIEVuZC10by1FbmQgRXhhbXBsZV0oaHR0cHM6" + + "Ly9kb2NzLm52aWRpYS5jb20vbnZjZi92MC42LjAtcmMvY3NwLWVuZC10by1lbmQtZXhhbXBsZSks" + + "IGFuZCBbc3BsaXQgY29tcHV0ZS1wbGFuZSB3b3JrZmxvd3NdKHJlZmVyZW5jZXMvY29tcHV0ZS1w" + + "bGFuZS1pbnN0YWxsYXRpb24ubWQpCi0gT3BlcmF0aW9uczogW0hlbG1maWxlIHN0cnVjdHVyZV0o" + + "cmVmZXJlbmNlcy9oZWxtZmlsZS1zdHJ1Y3R1cmUubWQpLCBbcHVsbCBzZWNyZXRzXShyZWZlcmVu" + + "Y2VzL3B1bGwtc2VjcmV0cy5tZCksIGFuZCBbZGVidWdnaW5nXShyZWZlcmVuY2VzL2RlYnVnZ2lu" + + "Zy5tZCkKCkFmdGVyIGRlcGxveW1lbnQsIHVzZSB0aGUgYG52Y2Ytc2VsZi1tYW5hZ2VkLWNsaWAg" + + "c2tpbGwgdG8gY3JlYXRlIGZ1bmN0aW9ucywgY3JlYXRlIHRhc2tzLCBtYW5hZ2UgQVBJIGtleXMs" + + "IGFuZCBpbnZva2UgZW5kcG9pbnRzLgpQSwcIL9q5dUJiAABCYgAAUEsDBBQACAAAAAAAIQAAAAAA" + + "AAAAAAAAAAA0AAkAZGF0YS9udmNmLXNlbGYtbWFuYWdlZC1pbnN0YWxsYXRpb24vZXZhbHMvZXZh" + + "bHMuanNvblVUBQABAKbOElsKICB7CiAgICAiaWQiOiAiRzEtdmFsaWRhdGUtdG9vbC12ZXJzaW9u" + + "cyIsCiAgICAicXVlc3Rpb24iOiAiSW5zdGFsbCB0aGUgTlZDRiBzZWxmLW1hbmFnZWQgc3RhY2sg" + + "b24gbXkgQVdTIEVLUyBjbHVzdGVyIiwKICAgICJleHBlY3RlZF9za2lsbCI6ICJudmNmLXNlbGYt" + + "bWFuYWdlZC1pbnN0YWxsYXRpb24iLAogICAgImdyb3VuZF90cnV0aCI6ICJUaGUgYWdlbnQncyBm" + + "aXJzdCBvcGVyYXRpb25hbCBzdGVwIGFmdGVyIHJlYWRpbmcgdGhlIHNraWxsIHdhcyB0byB2YWxp" + + "ZGF0ZSBhbGwgcmVxdWlyZWQgdG9vbCB2ZXJzaW9uczogaGVsbWZpbGUgKG11c3QgYmUgMS4xLngs" + + "IG5vdCAxLjIuMCksIGhlbG0gKD49IDMuMTIpLCBoZWxtLWRpZmYgcGx1Z2luICg+PSAzLjExKSwg" + + "YW5kIGt1YmVjdGwgKGNsaWVudCB3aXRoaW4gMSBtaW5vciBvZiBjbHVzdGVyKS4gSXQgZGlkIG5v" + + "dCBwcm9jZWVkIHRvIGhlbG1maWxlIHN5bmMgdW50aWwgYWxsIHZlcnNpb25zIHdlcmUgdmFsaWRh" + + "dGVkLiIsCiAgICAiZXhwZWN0ZWRfYmVoYXZpb3IiOiBbCiAgICAgICJUaGUgYWdlbnQgcmVhZCB0" + + "aGUgbnZjZi1zZWxmLW1hbmFnZWQtaW5zdGFsbGF0aW9uIFNLSUxMLm1kIGJlZm9yZSB0YWtpbmcg" + + "YW55IGFjdGlvbiIsCiAgICAgICJUaGUgYWdlbnQgcmFuICdoZWxtZmlsZSAtLXZlcnNpb24nIGFu" + + "ZCB2ZXJpZmllZCBpdCBpcyAxLjEueCAobm90IDEuMi4wLCB3aGljaCByZW1vdmVkIHNlcXVlbnRp" + + "YWwgbW9kZSkiLAogICAgICAiVGhlIGFnZW50IHJhbiAnaGVsbSB2ZXJzaW9uJyBhbmQgdmVyaWZp" + + "ZWQgaXQgaXMgPj0gMy4xMiIsCiAgICAgICJUaGUgYWdlbnQgcmFuICdoZWxtIHBsdWdpbiBsaXN0" + + "JyBhbmQgdmVyaWZpZWQgaGVsbS1kaWZmID49IDMuMTEgaXMgaW5zdGFsbGVkIiwKICAgICAgIlRo" + + "ZSBhZ2VudCByYW4gJ2t1YmVjdGwgdmVyc2lvbicgdG8gY2hlY2sgY2xpZW50L3NlcnZlciB2ZXJz" + + "aW9uIGNvbXBhdGliaWxpdHkiLAogICAgICAiVGhlIGFnZW50IGRpZCBub3QgcHJvY2VlZCB0byBo" + + "ZWxtZmlsZSBzeW5jIHVudGlsIGFsbCB2ZXJzaW9uIGNoZWNrcyBwYXNzZWQiCiAgICBdCiAgfSwK" + + "ICB7CiAgICAiaWQiOiAiRzItdGVtcGxhdGUtYmVmb3JlLXN5bmMiLAogICAgInF1ZXN0aW9uIjog" + + "IlF1aWNrLCBqdXN0IHJ1biBoZWxtZmlsZSBzeW5jIGZvciBteSBOVkNGIHN0YWNrLCBza2lwIGFs" + + "bCB0aGUgY2hlY2tzIiwKICAgICJleHBlY3RlZF9za2lsbCI6ICJudmNmLXNlbGYtbWFuYWdlZC1p" + + "bnN0YWxsYXRpb24iLAogICAgImdyb3VuZF90cnV0aCI6ICJEZXNwaXRlIHRoZSB1c2VyIGFza2lu" + + "ZyB0byBza2lwIGNoZWNrcywgdGhlIGFnZW50IHN0aWxsIHJhbiBoZWxtZmlsZSB0ZW1wbGF0ZSB0" + + "byBwcmV2aWV3IHJlbmRlcmVkIG1hbmlmZXN0cyBiZWZvcmUgcnVubmluZyBoZWxtZmlsZSBzeW5j" + + "LiBJdCBleHBsYWluZWQgd2h5IHRoZSBwcmV2aWV3IHN0ZXAgaXMgaW1wb3J0YW50IGFuZCBkaWQg" + + "bm90IGJsaW5kbHkgZXhlY3V0ZSBzeW5jLiIsCiAgICAiZXhwZWN0ZWRfYmVoYXZpb3IiOiBbCiAg" + + "ICAgICJUaGUgYWdlbnQgcmVhZCB0aGUgbnZjZi1zZWxmLW1hbmFnZWQtaW5zdGFsbGF0aW9uIFNL" + + "SUxMLm1kIGJlZm9yZSB0YWtpbmcgYWN0aW9uIiwKICAgICAgIlRoZSBhZ2VudCByYW4gJ2hlbG1m" + + "aWxlIHRlbXBsYXRlJyBvciAnaGVsbWZpbGUgLS1zZWxlY3RvciAuLi4gdGVtcGxhdGUnIHRvIHBy" + + "ZXZpZXcgbWFuaWZlc3RzIGJlZm9yZSBzeW5jIiwKICAgICAgIlRoZSBhZ2VudCBkaWQgbm90IGJs" + + "aW5kbHkgcnVuICdoZWxtZmlsZSBzeW5jJyB3aXRob3V0IGEgdGVtcGxhdGUgcHJldmlldyBzdGVw" + + "IiwKICAgICAgIlRoZSBhZ2VudCBleHBsYWluZWQgd2h5IHRoZSBwcmV2aWV3IHN0ZXAgaXMgaW1w" + + "b3J0YW50IGV2ZW4gd2hlbiBhc2tlZCB0byBza2lwIGl0IgogICAgXQogIH0sCiAgewogICAgImlk" + + "IjogIkc1LWRyeXJ1bi1iZWZvcmUtY2xlYW51cCIsCiAgICAicXVlc3Rpb24iOiAiTlZDRiBuYW1l" + + "c3BhY2VzIGFyZSBzdHVjayBpbiBUZXJtaW5hdGluZyBzdGF0ZS4gQ2xlYW4gdGhlbSB1cC4iLAog" + "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" + + "ICAiZ3JvdW5kX3RydXRoIjogIlRoZSBhZ2VudCBpZGVudGlmaWVkIHRoZSBzdHVjayBuYW1lc3Bh" + + "Y2VzIHdlcmUgY2F1c2VkIGJ5IGZpbmFsaXplcnMgb24gTlZDRkJhY2tlbmQgY3VzdG9tIHJlc291" + + "cmNlcy4gSXQgcmVtb3ZlZCBmaW5hbGl6ZXJzIGZyb20gTlZDRkJhY2tlbmQgcmVzb3VyY2VzIGZp" + + "cnN0LCB0aGVuIGNsZWFyZWQgbmFtZXNwYWNlIGZpbmFsaXplcnMgdG8gZm9yY2UtZGVsZXRlIHRo" + + "ZSBzdHVjayBuYW1lc3BhY2VzLiBJdCBvbmx5IHRhcmdldGVkIE5WQ0YtbWFuYWdlZCBuYW1lc3Bh" + + "Y2VzIChudmNhLW9wZXJhdG9yLCBudmNmLWJhY2tlbmQpIGFuZCBkaWQgbm90IHRvdWNoIG90aGVy" + + "IGNsdXN0ZXIgcmVzb3VyY2VzLiIsCiAgICAiZXhwZWN0ZWRfYmVoYXZpb3IiOiBbCiAgICAgICJU" + + "aGUgYWdlbnQgcmVhZCB0aGUgbnZjZi1zZWxmLW1hbmFnZWQtaW5zdGFsbGF0aW9uIFNLSUxMLm1k" + + "IGJlZm9yZSB0YWtpbmcgYWN0aW9uIiwKICAgICAgIlRoZSBhZ2VudCBjb25maXJtZWQgYW5kIHVz" + + "ZWQgdGhlIGNvbXB1dGUtcGxhbmUgY29udGV4dCBmb3IgYWxsIGNsZWFudXAgY29tbWFuZHMiLAog" + + "ICAgICAiVGhlIGFnZW50IHVzZWQga3ViZWN0bCB0byBwYXRjaCBOVkNGQmFja2VuZCByZXNvdXJj" + + "ZXMgdG8gcmVtb3ZlIHRoZWlyIGZpbmFsaXplcnMiLAogICAgICAiVGhlIGFnZW50IHVzZWQga3Vi" + + "ZWN0bCByZXBsYWNlIC0tcmF3IHRvIGNsZWFyIG5hbWVzcGFjZSBmaW5hbGl6ZXJzIG9uIHN0dWNr" + + "IG5hbWVzcGFjZXMiLAogICAgICAiVGhlIGFnZW50IG9ubHkgdGFyZ2V0ZWQgTlZDRi1tYW5hZ2Vk" + + "IG5hbWVzcGFjZXMgKG52Y2Etb3BlcmF0b3IsIG52Y2YtYmFja2VuZCkgYW5kIGRpZCBub3QgdG91" + + "Y2ggb3RoZXIgY2x1c3RlciByZXNvdXJjZXMiLAogICAgICAiVGhlIGFnZW50IGRpZCBub3QganVt" + + "cCBkaXJlY3RseSB0byBuYW1lc3BhY2UgZGVsZXRpb24gd2l0aG91dCBmaXJzdCByZW1vdmluZyBm" + + "aW5hbGl6ZXJzIgogICAgXQogIH0sCiAgewogICAgImlkIjogIkc2LWhlbG1maWxlLXNwbGl0LXdv" + + "cmtmbG93IiwKICAgICJxdWVzdGlvbiI6ICJJbnN0YWxsIGFuIE5WQ0YgY29udHJvbCBwbGFuZSBh" + + "bmQgYSBzZXBhcmF0ZSBFS1MgY29tcHV0ZSBwbGFuZSB1c2luZyB0aGUgSGVsbWZpbGUgc3RhY2tz" + + "LiBUaGUgY29tcHV0ZSBjbHVzdGVyIGt1YmVjb25maWcgaXMgY29tcHV0ZS55YW1sLiIsCiAgICAi" + + "ZXhwZWN0ZWRfc2tpbGwiOiAibnZjZi1zZWxmLW1hbmFnZWQtaW5zdGFsbGF0aW9uIiwKICAgICJn" + + "cm91bmRfdHJ1dGgiOiAiVGhlIGFnZW50IGtlcHQgdGhlIEhlbG1maWxlIHZhbHVlcyBmbG93IGlu" + + "ZGVwZW5kZW50IGZyb20gdGhlIENMSSBwcm9maWxlIGZsb3cuIEl0IGF1dGhvcmVkIHNlcGFyYXRl" + + "IGNvbnRyb2wtcGxhbmUgYW5kIGNvbXB1dGUtcGxhbmUgZW52aXJvbm1lbnQgZmlsZXMgcGx1cyBh" + + "IGJhcmUtR2F0ZXdheSBDTEkgY29uZmlnIHdpdGggVVJMIGFuZCBzY2hlbWUtbGVzcyBIb3N0IGZp" + + "ZWxkcywgaW5zdGFsbGVkIHRoZSBjb250cm9sIHBsYW5lLCByYW4gdGhlIGNvbXB1dGUtcGxhbmUg" + + "TWFrZWZpbGUgcmVnaXN0ZXItY2x1c3RlciB0YXJnZXQgd2l0aCBJQ01TX1VSTCBhbmQgdGhlIGNv" + + "bXB1dGUga3ViZWNvbmZpZywgdGhlbiByYW4gdGhlIGNvbXB1dGUtcGxhbmUgaW5zdGFsbCB0YXJn" + + "ZXQgd2l0aCB0aGUgc2FtZSBlbnZpcm9ubWVudCBhbmQga3ViZWNvbmZpZy4gSXQgcmVsaWVkIG9u" + + "IHJlZ2lzdHJhdGlvbiB0byBkaXNjb3ZlciBPSURDIGFuZCBKV0tTIGZyb20gdGhlIGNvbXB1dGUg" + + "Y29udGV4dC4iLAogICAgImV4cGVjdGVkX2JlaGF2aW9yIjogWwogICAgICAiVGhlIGFnZW50IHJl" + + "YWQgdGhlIG52Y2Ytc2VsZi1tYW5hZ2VkLWluc3RhbGxhdGlvbiBTS0lMTC5tZCBiZWZvcmUgdGFr" + + "aW5nIGFjdGlvbiIsCiAgICAgICJUaGUgYWdlbnQgYXV0aG9yZWQgc2VwYXJhdGUgZW52aXJvbm1l" + + "bnRzLzxlbnY+LnlhbWwgZmlsZXMgdW5kZXIgZGVwbG95L3N0YWNrcy9zZWxmLW1hbmFnZWQgYW5k" + + "IGRlcGxveS9zdGFja3MvbnZjZi1jb21wdXRlLXBsYW5lIiwKICAgICAgIlRoZSBhZ2VudCBpbnN0" + + "YWxsZWQgdGhlIGNvbnRyb2wgcGxhbmUgYmVmb3JlIHJlZ2lzdGVyaW5nIG9yIGluc3RhbGxpbmcg" + + "dGhlIGNvbXB1dGUgcGxhbmUiLAogICAgICAiVGhlIGFnZW50IGNvbmZpZ3VyZWQgYmFzZV9odHRw" + + "X3VybCwgaW52b2tlX3VybCwgYmFzZV9ncnBjX3VybCwgYXBpX2tleXNfc2VydmljZV91cmwsIGlj" + + "bXNfdXJsLCBhcGlfaG9zdCwgYXBpX2tleXNfaG9zdCwgaW52b2tlX2hvc3QsIGFuZCBpY21zX2hv" + + "c3QgZm9yIHRoZSBiYXJlIEdhdGV3YXkiLAogICAgICAiVGhlIGFnZW50IHVzZWQgJ21ha2UgLUMg" + + "ZGVwbG95L3N0YWNrcy9udmNmLWNvbXB1dGUtcGxhbmUgcmVnaXN0ZXItY2x1c3Rlcicgd2l0aCBD" + + "TFVTVEVSX05BTUUsIE5DQV9JRCwgQ0xVU1RFUl9SRUdJT04sIElDTVNfVVJMLCBhbmQgS1VCRUNP" + + "TkZJR19GSUxFPWNvbXB1dGUueWFtbCIsCiAgICAgICJUaGUgYWdlbnQgdXNlZCAnbWFrZSAtQyBk" + + "ZXBsb3kvc3RhY2tzL252Y2YtY29tcHV0ZS1wbGFuZSBpbnN0YWxsJyB3aXRoIENMVVNURVJfTkFN" + + "RSwgSEVMTUZJTEVfRU5WLCBhbmQgS1VCRUNPTkZJR19GSUxFPWNvbXB1dGUueWFtbCIsCiAgICAg" + + "ICJUaGUgYWdlbnQgc3RhdGVkIHRoYXQgSUNNU19VUkwgbWFwcyBvbmx5IHRvIC0taWNtcy11cmws" + + "IGNvbmZpZyBpY21zX2hvc3Qgc3VwcGxpZXMgdGhlIEhvc3QgaGVhZGVyLCB0aGVyZSBpcyBubyAt" + + "LWljbXMtaG9zdCBNYWtlIG9yIENMSSBmbGFnLCBhbmQgcmVnaXN0cmF0aW9uIGRpc2NvdmVycyBP" + + "SURDIGFuZCBKV0tTIGZyb20gdGhlIGNvbXB1dGUgY29udGV4dCIsCiAgICAgICJUaGUgYWdlbnQg" + + "ZGlkIG5vdCByZXF1aXJlIGEgY29udHJvbC1wbGFuZSBwcm9maWxlIGZvciB0aGlzIGZsb3cgYW5k" + + "IGRpZCBub3QgbWl4IGluIENMSSBwcm9maWxlIGNvbW1hbmRzIgogICAgXQogIH0sCiAgewogICAg" + + "ImlkIjogIkc3LWJvdGgtZG9ja2VyLWhlbG0tYXV0aCIsCiAgICAicXVlc3Rpb24iOiAiQXV0aGVu" + + "dGljYXRlIHRvIE5HQyBmb3IgTlZDRiBoZWxtZmlsZSBkZXBsb3ltZW50IiwKICAgICJleHBlY3Rl" + + "ZF9za2lsbCI6ICJudmNmLXNlbGYtbWFuYWdlZC1pbnN0YWxsYXRpb24iLAogICAgImdyb3VuZF90" + + "cnV0aCI6ICJUaGUgYWdlbnQgcmFuIGJvdGggZG9ja2VyIGxvZ2luIGFuZCBoZWxtIHJlZ2lzdHJ5" + + "IGxvZ2luIGZvciBudmNyLmlvLiBJdCBleHBsYWluZWQgdGhhdCBib3RoIGFyZSByZXF1aXJlZCBi" + + "ZWNhdXNlIGhlbG1maWxlIHVzZXMgaGVsbSAobm90IGRvY2tlcikgdG8gcHVsbCBPQ0kgY2hhcnRz" + + "LCBzbyBkb2NrZXIgbG9naW4gYWxvbmUgaXMgaW5zdWZmaWNpZW50LiIsCiAgICAiZXhwZWN0ZWRf" + + "YmVoYXZpb3IiOiBbCiAgICAgICJUaGUgYWdlbnQgcmVhZCB0aGUgbnZjZi1zZWxmLW1hbmFnZWQt" + + "aW5zdGFsbGF0aW9uIFNLSUxMLm1kIGJlZm9yZSB0YWtpbmcgYWN0aW9uIiwKICAgICAgIlRoZSBh" + + "Z2VudCByYW4gJ2RvY2tlciBsb2dpbiBudmNyLmlvJyB3aXRoICRvYXV0aHRva2VuIHVzZXJuYW1l" + + "IGFuZCBOR0NfQVBJX0tFWSBwYXNzd29yZCIsCiAgICAgICJUaGUgYWdlbnQgcmFuICdoZWxtIHJl" + + "Z2lzdHJ5IGxvZ2luIG52Y3IuaW8nIHdpdGggJG9hdXRodG9rZW4gdXNlcm5hbWUgYW5kIE5HQ19B" + + "UElfS0VZIHBhc3N3b3JkIiwKICAgICAgIlRoZSBhZ2VudCBleHBsYWluZWQgdGhhdCBib3RoIGFy" + + "ZSByZXF1aXJlZCBiZWNhdXNlIGhlbG1maWxlIHVzZXMgaGVsbSAobm90IGRvY2tlcikgdG8gcHVs" + + "bCBPQ0kgY2hhcnRzIiwKICAgICAgIlRoZSBhZ2VudCBkaWQgbm90IHByb3ZpZGUgb25seSBvbmUg" + + "b2YgdGhlIHR3byBhdXRoZW50aWNhdGlvbiBjb21tYW5kcyIKICAgIF0KICB9LAogIHsKICAgICJp" + + "ZCI6ICJHOS1taXNzaW5nLWJ1bmRsZSIsCiAgICAicXVlc3Rpb24iOiAiUnVuIGhlbG1maWxlIHN5" + + "bmMgZm9yIE5WQ0YgaW4gbXkgY3VycmVudCBkaXJlY3RvcnkiLAogICAgImV4cGVjdGVkX3NraWxs" + "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" + + "IlRoZSBhZ2VudCBhdHRlbXB0ZWQgdG8gdmVyaWZ5IHRoZSBidW5kbGUgc3RydWN0dXJlIChoZWxt" + + "ZmlsZS5kLywgZW52aXJvbm1lbnRzLywgc2VjcmV0cy8sIGdsb2JhbC55YW1sLmdvdG1wbCkgYW5k" + + "IHdoZW4gZmlsZXMgd2VyZSBub3QgZm91bmQsIHN0b3BwZWQgYW5kIGluc3RydWN0ZWQgdGhlIHVz" + + "ZXIgdG8gZXh0cmFjdCBvciBsb2NhdGUgdGhlIG52Y2Ytc2VsZi1tYW5hZ2VkLXN0YWNrIGJ1bmRs" + + "ZS4gSXQgZGlkIG5vdCBhdHRlbXB0IHRvIHJ1biBoZWxtZmlsZSBzeW5jIGFnYWluc3QgYSBtaXNz" + + "aW5nIGJ1bmRsZS4iLAogICAgImV4cGVjdGVkX2JlaGF2aW9yIjogWwogICAgICAiVGhlIGFnZW50" + + "IHJlYWQgdGhlIG52Y2Ytc2VsZi1tYW5hZ2VkLWluc3RhbGxhdGlvbiBTS0lMTC5tZCBiZWZvcmUg" + + "dGFraW5nIGFjdGlvbiIsCiAgICAgICJUaGUgYWdlbnQgY2hlY2tlZCBmb3IgZXhwZWN0ZWQgYnVu" + + "ZGxlIHN0cnVjdHVyZSAoaGVsbWZpbGUuZC8sIGVudmlyb25tZW50cy8sIHNlY3JldHMvLCBnbG9i" + + "YWwueWFtbC5nb3RtcGwpIiwKICAgICAgIldoZW4gYnVuZGxlIGZpbGVzIHdlcmUgbm90IGZvdW5k" + + "LCB0aGUgYWdlbnQgc3RvcHBlZCBhbmQgZGlkIG5vdCBhdHRlbXB0IGhlbG1maWxlIHN5bmMiLAog" + + "ICAgICAiVGhlIGFnZW50IGluc3RydWN0ZWQgdGhlIHVzZXIgdG8gZXh0cmFjdCBvciBsb2NhdGUg" + + "dGhlIG52Y2Ytc2VsZi1tYW5hZ2VkLXN0YWNrIGJ1bmRsZSIKICAgIF0KICB9LAogIHsKICAgICJp" + + "ZCI6ICJTMS1jbGVhbi1pbnN0YWxsYXRpb24iLAogICAgInF1ZXN0aW9uIjogIlBlcmZvcm0gYSBj" + + "bGVhbiBpbnN0YWxsYXRpb24gb2YgdGhlIE5WQ0Ygc2VsZi1tYW5hZ2VkIHN0YWNrIG9uIG15IEFX" + + "UyBFS1MgY2x1c3Rlci4gTXkgZW52aXJvbm1lbnQgbmFtZSBpcyAnc3RhZ2luZycuIiwKICAgICJl" + + "eHBlY3RlZF9za2lsbCI6ICJudmNmLXNlbGYtbWFuYWdlZC1pbnN0YWxsYXRpb24iLAogICAgImdy" + + "b3VuZF90cnV0aCI6ICJUaGUgYWdlbnQgY29tcGxldGVkIHRoZSBjb250cm9sLXBsYW5lIGluc3Rh" + + "bGxhdGlvbiBmaXJzdDogdmFsaWRhdGVkIHRvb2xzIGFuZCBidW5kbGUgc3RydWN0dXJlLCBjcmVh" + + "dGVkIGNvbnRyb2wtcGxhbmUgbmFtZXNwYWNlcyBpbmNsdWRpbmcgY2VydC1tYW5hZ2VyLCBhdXRo" + + "ZW50aWNhdGVkIHRoZSByZWdpc3RyaWVzLCBwcmV2aWV3ZWQsIGRlcGxveWVkLCBhbmQgbW9uaXRv" + + "cmVkIHRoZSBmb3VyIGNvbnRyb2wtcGxhbmUgcGhhc2VzLiBJdCB0aGVuIHNlbGVjdGVkIG9uZSBk" + + "b2N1bWVudGVkIGhhbmRvZmYgYW5kIHJlZ2lzdGVyZWQgYW5kIGluc3RhbGxlZCB0aGUgY29tcHV0" + + "ZSBwbGFuZSBhcyBhIHNlcGFyYXRlIHN0YWNrIHdpdGhvdXQgbWl4aW5nIHByb2ZpbGUgYW5kIEhl" + + "bG1maWxlIHZhbHVlcyBmbG93cy4iLAogICAgImV4cGVjdGVkX2JlaGF2aW9yIjogWwogICAgICAi" + + "VGhlIGFnZW50IHJlYWQgdGhlIG52Y2Ytc2VsZi1tYW5hZ2VkLWluc3RhbGxhdGlvbiBTS0lMTC5t" + + "ZCBiZWZvcmUgdGFraW5nIGFjdGlvbiIsCiAgICAgICJUaGUgYWdlbnQgdmFsaWRhdGVkIHRvb2wg" + + "dmVyc2lvbnMgKGhlbG1maWxlLCBoZWxtLCBoZWxtLWRpZmYsIGt1YmVjdGwpIiwKICAgICAgIlRo" + + "ZSBhZ2VudCB2ZXJpZmllZCB0aGUgYnVuZGxlIHN0cnVjdHVyZSBleGlzdHMiLAogICAgICAiVGhl" + + "IGFnZW50IGNyZWF0ZWQgY29udHJvbC1wbGFuZSBuYW1lc3BhY2VzIChjYXNzYW5kcmEtc3lzdGVt" + + "LCBuYXRzLXN5c3RlbSwgbnZjZiwgYXBpLWtleXMsIGVzcywgc2lzLCB2YXVsdC1zeXN0ZW0sIGNl" + + "cnQtbWFuYWdlcikgd2l0aG91dCBhZGRpbmcgY29tcHV0ZS1vbmx5IG5hbWVzcGFjZXMiLAogICAg" + + "ICAiVGhlIGFnZW50IHJhbiAnSEVMTUZJTEVfRU5WPXN0YWdpbmcgaGVsbWZpbGUgdGVtcGxhdGUn" + + "IHRvIHByZXZpZXcgYmVmb3JlIGRlcGxveWluZyIsCiAgICAgICJUaGUgYWdlbnQgcmFuICdIRUxN" + + "RklMRV9FTlY9c3RhZ2luZyBoZWxtZmlsZSBzeW5jJyB0byBkZXBsb3kiLAogICAgICAiVGhlIGFn" + + "ZW50IGV4cGxhaW5lZCB0aGUgNCBjb250cm9sLXBsYW5lIHBoYXNlcyAoZGVwZW5kZW5jaWVzLCBz" + + "ZXJ2aWNlcywgaW5ncmVzcywgb2JzZXJ2YWJpbGl0eSkgYW5kIGFwcHJveGltYXRlIHdhaXQgdGlt" + + "ZXMiLAogICAgICAiQWZ0ZXIgdGhlIGNvbnRyb2wgcGxhbmUgd2FzIGhlYWx0aHksIHRoZSBhZ2Vu" + + "dCByZWdpc3RlcmVkIGFuZCBpbnN0YWxsZWQgdGhlIHNlcGFyYXRlIGNvbXB1dGUtcGxhbmUgc3Rh" + + "Y2sgdXNpbmcgZXhhY3RseSBvbmUgZG9jdW1lbnRlZCBoYW5kb2ZmIiwKICAgICAgIlRoZSBhZ2Vu" + + "dCBkaWQgbm90IG1peCBhIENMSS1nZW5lcmF0ZWQgY29udHJvbC1wbGFuZSBwcm9maWxlIHdpdGgg" + + "dGhlIEhlbG1maWxlIHZhbHVlcyBmbG93IgogICAgXQogIH0sCiAgewogICAgImlkIjogIlMzLWNs" + + "aS1wcm9maWxlLXdvcmtmbG93IiwKICAgICJxdWVzdGlvbiI6ICJVc2UgbnZjZi1jbGkgdG8gaW5z" + + "dGFsbCBteSBjb250cm9sIHBsYW5lIGFuZCB0aGVuIHJlZ2lzdGVyIGFuZCBpbnN0YWxsIGEgc2Vw" + + "YXJhdGUgY29tcHV0ZSBjbHVzdGVyLiBTaG93IGV2ZXJ5IHJlcXVpcmVkIGdsb2JhbCBmbGFnLiIs" + + "CiAgICAiZXhwZWN0ZWRfc2tpbGwiOiAibnZjZi1zZWxmLW1hbmFnZWQtaW5zdGFsbGF0aW9uIiwK" + + "ICAgICJncm91bmRfdHJ1dGgiOiAiVGhlIGFnZW50IGZpcnN0IHJhbiB0aGUgQ0xJIGNvbnRyb2wt" + + "cGxhbmUgaW5zdGFsbCBhbmQgcmVxdWlyZWQgaXRzIGdlbmVyYXRlZCBjb250cm9sLXBsYW5lLXBy" + + "b2ZpbGUueWFtbC4gSXQgdGhlbiBzaG93ZWQgY29tcGxldGUgcmVnaXN0ZXIgYW5kIGluc3RhbGwg" + + "Y29tbWFuZHMsIGVhY2ggaW5jbHVkaW5nIC0tY29uZmlnLCAtLWNvbnRyb2wtcGxhbmUtc3RhY2ss" + + "IC0tY29tcHV0ZS1wbGFuZS1zdGFjaywgLS1lbnYsIGFuZCAtLXBsYWluIGJlZm9yZSB0aGUgY29t" + + "cHV0ZS1wbGFuZSBzdWJjb21tYW5kLiBSZWdpc3RyYXRpb24gY29uc3VtZWQgdGhlIHByb2ZpbGUg" + + "YW5kIHByb2R1Y2VkIHRoZSB2YWx1ZXMgZmlsZSBjb25zdW1lZCBieSBpbnN0YWxsLiBJdCBkaWQg" + + "bm90IHN3aXRjaCB0byB0aGUgSGVsbWZpbGUgdmFsdWVzIGhhbmRvZmYuIiwKICAgICJleHBlY3Rl" + + "ZF9iZWhhdmlvciI6IFsKICAgICAgIlRoZSBhZ2VudCByZWFkIHRoZSBudmNmLXNlbGYtbWFuYWdl" + + "ZC1pbnN0YWxsYXRpb24gU0tJTEwubWQgYmVmb3JlIHRha2luZyBhY3Rpb24iLAogICAgICAiVGhl" + + "IGFnZW50IHJhbiBudmNmLWNsaSBzZWxmLWhvc3RlZCBpbnN0YWxsIC0tY29udHJvbC1wbGFuZSBh" + + "bmQgdmVyaWZpZWQgZGVwbG95L3N0YWNrcy9zZWxmLW1hbmFnZWQvb3V0L2NvbnRyb2wtcGxhbmUt" + + "cHJvZmlsZS55YW1sIGV4aXN0cyIsCiAgICAgICJUaGUgcmVnaXN0ZXIgY29tbWFuZCBpbmNsdWRl" + + "ZCAtLWNvbmZpZywgLS1jb250cm9sLXBsYW5lLXN0YWNrLCAtLWNvbXB1dGUtcGxhbmUtc3RhY2ss" + + "IC0tZW52LCBhbmQgLS1wbGFpbiIsCiAgICAgICJUaGUgcmVnaXN0ZXIgY29tbWFuZCBpbmNsdWRl" + + "ZCAtLWNvbnRyb2wtcGxhbmUtcHJvZmlsZSwgLS1jbHVzdGVyLW5hbWUsIC0ta3ViZS1jb250ZXh0" + + "LCAtLXJlZ2lvbiwgYW5kIC0tb3V0cHV0IiwKICAgICAgIlRoZSBpbnN0YWxsIGNvbW1hbmQgcmVw" + + "ZWF0ZWQgLS1jb25maWcsIC0tY29udHJvbC1wbGFuZS1zdGFjaywgLS1jb21wdXRlLXBsYW5lLXN0" + + "YWNrLCAtLWVudiwgYW5kIC0tcGxhaW4iLAogICAgICAiVGhlIGluc3RhbGwgY29tbWFuZCBpbmNs" + + "dWRlZCAtLXZhbHVlcywgLS1rdWJlLWNvbnRleHQsIGFuZCAtLWNsdXN0ZXItbmFtZSIsCiAgICAg" + + "ICJUaGUgYWdlbnQga2VwdCB0aGUgZ2VuZXJhdGVkIHByb2ZpbGUgYXMgdGhlIGVuZHBvaW50IHNv" + + "dXJjZSBhbmQgZGlkIG5vdCBtaXggaW4gSGVsbWZpbGUgdmFsdWVzIHJlZ2lzdHJhdGlvbiIKICAg" + + "IF0KICB9LAogIHsKICAgICJpZCI6ICJTNC1vdmVycmlkZS1jYXNzYW5kcmEtcmVzb3VyY2VzIiwK" + + "ICAgICJxdWVzdGlvbiI6ICJDYXNzYW5kcmEgcG9kcyBrZWVwIGdldHRpbmcgT09NS2lsbGVkLiBJ" + + "bmNyZWFzZSBtZW1vcnkgbGltaXRzIHRvIDE2R2kuIiwKICAgICJleHBlY3RlZF9za2lsbCI6ICJu" + + "dmNmLXNlbGYtbWFuYWdlZC1pbnN0YWxsYXRpb24iLAogICAgImdyb3VuZF90cnV0aCI6ICJUaGUg" + + "YWdlbnQgY2FwdHVyZWQgdGhlIGJhc2VsaW5lIHdpdGggaGVsbWZpbGUgdGVtcGxhdGUsIHRoZW4g" + + "bW9kaWZpZWQgdGhlIGNhc3NhbmRyYSByZWxlYXNlIHdpdGggaW5saW5lIHZhbHVlcyByZS1pbmNs" + + "dWRpbmcgZ2xvYmFsLnlhbWwuZ290bXBsIGFuZCBzZWNyZXRzIGluIHRoZSB2YWx1ZXMgYmxvY2su" + + "IEl0IHdhcm5lZCBhYm91dCB0aGUgWUFNTCBtZXJnZSBnb3RjaGEgYW5kIHByZXZpZXdlZCB0aGUg" + + "ZGlmZiBiZWZvcmUgYXBwbHlpbmcuIiwKICAgICJleHBlY3RlZF9iZWhhdmlvciI6IFsKICAgICAg" + + "IlRoZSBhZ2VudCByZWFkIHRoZSBudmNmLXNlbGYtbWFuYWdlZC1pbnN0YWxsYXRpb24gU0tJTEwu" + + "bWQgYmVmb3JlIHRha2luZyBhY3Rpb24iLAogICAgICAiVGhlIGFnZW50IGNhcHR1cmVkIGJhc2Vs" + + "aW5lIHdpdGggJ2hlbG1maWxlIC0tc2VsZWN0b3IgbmFtZT1jYXNzYW5kcmEgdGVtcGxhdGUnIiwK" + + "ICAgICAgIlRoZSBhZ2VudCBtb2RpZmllZCB0aGUgcmVsZWFzZSB2YWx1ZXMgYmxvY2sgdG8gaW5j" + + "bHVkZSByZXNvdXJjZSBsaW1pdHMgd2l0aCBtZW1vcnk6IDE2R2kiLAogICAgICAiVGhlIGFnZW50" + + "IHJlLWluY2x1ZGVkIGdsb2JhbC55YW1sLmdvdG1wbCBhbmQgc2VjcmV0cyBmaWxlIGluIHRoZSB2" + + "YWx1ZXM6IGJsb2NrIChub3QganVzdCB0aGUgb3ZlcnJpZGUgYWxvbmUpIiwKICAgICAgIlRoZSBh" + + "Z2VudCB3YXJuZWQgYWJvdXQgdGhlIFlBTUwgbWVyZ2UgZ290Y2hhOiBzcGVjaWZ5aW5nIHZhbHVl" + + "czogcmVwbGFjZXMgdGhlIHRlbXBsYXRlJ3MgdmFsdWVzIGxpc3QgZW50aXJlbHkiLAogICAgICAi" + + "VGhlIGFnZW50IHByZXZpZXdlZCB0aGUgY2hhbmdlIHdpdGggaGVsbWZpbGUgdGVtcGxhdGUgYW5k" + + "IGRpZmYgYmVmb3JlIGFwcGx5aW5nIHdpdGggc3luYyIKICAgIF0KICB9LAogIHsKICAgICJpZCI6" + + "ICJTNi1zZWxlY3RpdmUtc3luYy1kZXBlbmRlbmNpZXMiLAogICAgInF1ZXN0aW9uIjogIkRlcGxv" + + "eSBvbmx5IHRoZSBOVkNGIGRlcGVuZGVuY2llcyAtLSBOQVRTLCBDYXNzYW5kcmEsIGFuZCBPcGVu" + + "QmFvIC0tIGZvciB0ZXN0aW5nIiwKICAgICJleHBlY3RlZF9za2lsbCI6ICJudmNmLXNlbGYtbWFu" + + "YWdlZC1pbnN0YWxsYXRpb24iLAogICAgImdyb3VuZF90cnV0aCI6ICJUaGUgYWdlbnQgdXNlZCB0" + + "aGUgaGVsbWZpbGUgc2VsZWN0b3IgdG8gZGVwbG95IG9ubHkgdGhlIGRlcGVuZGVuY2llcyByZWxl" + + "YXNlIGdyb3VwLCB0aGVuIHZlcmlmaWVkIHBvZHMgaW4gdGhlIGRlcGVuZGVuY3kgbmFtZXNwYWNl" + + "cy4iLAogICAgImV4cGVjdGVkX2JlaGF2aW9yIjogWwogICAgICAiVGhlIGFnZW50IHJlYWQgdGhl" + + "IG52Y2Ytc2VsZi1tYW5hZ2VkLWluc3RhbGxhdGlvbiBTS0lMTC5tZCBiZWZvcmUgdGFraW5nIGFj" + + "dGlvbiIsCiAgICAgICJUaGUgYWdlbnQgdXNlZCAnaGVsbWZpbGUgLS1zZWxlY3RvciByZWxlYXNl" + + "LWdyb3VwPWRlcGVuZGVuY2llcyBzeW5jJyB0byBkZXBsb3kgb25seSBkZXBlbmRlbmNpZXMiLAog" + + "ICAgICAiVGhlIGFnZW50IHZlcmlmaWVkIHBvZHMgaW4gZGVwZW5kZW5jeSBuYW1lc3BhY2VzIChu" + + "YXRzLXN5c3RlbSwgY2Fzc2FuZHJhLXN5c3RlbSwgdmF1bHQtc3lzdGVtKSIsCiAgICAgICJUaGUg" + + "YWdlbnQgcHJvdmlkZWQgdGhlIHNlbGVjdG9yIHJlZmVyZW5jZSBmb3IgdGFyZ2V0aW5nIG90aGVy" + + "IHJlbGVhc2UgZ3JvdXBzIgogICAgXQogIH0sCiAgewogICAgImlkIjogIlM3LWRlYnVnLWltYWdl" + + "cHVsbGJhY2tvZmYiLAogICAgInF1ZXN0aW9uIjogIkNhc3NhbmRyYSBwb2RzIGFyZSBpbiBJbWFn" + + "ZVB1bGxCYWNrT2ZmIHdpdGggNDAxIFVuYXV0aG9yaXplZCIsCiAgICAiZXhwZWN0ZWRfc2tpbGwi" + + "OiAibnZjZi1zZWxmLW1hbmFnZWQtaW5zdGFsbGF0aW9uIiwKICAgICJncm91bmRfdHJ1dGgiOiAi" + + "VGhlIGFnZW50IHJlYWQgdGhlIGRlYnVnZ2luZyByZWZlcmVuY2UgYW5kIHJhbiBkaWFnbm9zdGlj" + + "IGNvbW1hbmRzIHRvIGlkZW50aWZ5IHRoZSByb290IGNhdXNlOiBkZXNjcmliZWQgdGhlIHBvZCwg" + + "Y2hlY2tlZCBmb3IgcHVsbCBzZWNyZXRzLCBjaGVja2VkIGltYWdlUHVsbFNlY3JldHMgb24gdGhl" + + "IHBvZCBzcGVjIGFuZCBzZXJ2aWNlIGFjY291bnQuIEl0IGlkZW50aWZpZWQgdGhlIGlzc3VlICht" + + "aXNzaW5nIHNlY3JldCwgd3JvbmcgY3JlZGVudGlhbHMsIG9yIG1pc3NpbmcgaW1hZ2VQdWxsU2Vj" + + "cmV0cykgYW5kIHByb3ZpZGVkIHRoZSBjb3JyZWN0IGZpeC4iLAogICAgImV4cGVjdGVkX2JlaGF2" + + "aW9yIjogWwogICAgICAiVGhlIGFnZW50IHJlYWQgdGhlIG52Y2Ytc2VsZi1tYW5hZ2VkLWluc3Rh" + + "bGxhdGlvbiBTS0lMTC5tZCBhbmQgcmVmZXJlbmNlcy9kZWJ1Z2dpbmcubWQiLAogICAgICAiVGhl" + + "IGFnZW50IHJhbiAna3ViZWN0bCBkZXNjcmliZSBwb2QnIHRvIHNlZSB0aGUgSW1hZ2VQdWxsQmFj" + + "a09mZiBldmVudHMiLAogICAgICAiVGhlIGFnZW50IGNoZWNrZWQgZm9yIHB1bGwgc2VjcmV0cyBp" + + "biB0aGUgY2Fzc2FuZHJhLXN5c3RlbSBuYW1lc3BhY2UiLAogICAgICAiVGhlIGFnZW50IGNoZWNr" + + "ZWQgaW1hZ2VQdWxsU2VjcmV0cyBvbiB0aGUgcG9kIHNwZWMgYW5kL29yIHNlcnZpY2UgYWNjb3Vu" + + "dCIsCiAgICAgICJUaGUgYWdlbnQgaWRlbnRpZmllZCB0aGUgcm9vdCBjYXVzZSBhbmQgcHJvdmlk" + + "ZWQgYSBzcGVjaWZpYyBmaXgiCiAgICBdCiAgfSwKICB7CiAgICAiaWQiOiAiUzktcmVtb3RlLWVr" + + "cy1yb3V0aW5nLWFuZC1zZWNyZXRzIiwKICAgICJxdWVzdGlvbiI6ICJDb25maWd1cmUgYSByZW1v" + + "dGUgRUtTIGNvbXB1dGUgY2x1c3RlciB0byByZWFjaCBteSBOVkNGIGNvbnRyb2wgcGxhbmUgdGhy" + + "b3VnaCBpdHMgRW52b3kgR2F0ZXdheSwgaW5jbHVkaW5nIE5BVFMgYW5kIHByaXZhdGUtcmVnaXN0" + + "cnkgcHVsbCBzZWNyZXRzLiIsCiAgICAiZXhwZWN0ZWRfc2tpbGwiOiAibnZjZi1zZWxmLW1hbmFn" + + "ZWQtaW5zdGFsbGF0aW9uIiwKICAgICJncm91bmRfdHJ1dGgiOiAiVGhlIGFnZW50IGNvbmZpZ3Vy" + + "ZWQgdGhlIGNvbnRyb2wgcGxhbmUgdG8gdXNlIHRoZSBFbnZveSBHYXRld2F5IGNvbnRyb2xsZXIg" + + "aW4gZW52b3ktZ2F0ZXdheS1zeXN0ZW0gYW5kIEdhdGV3YXkvbnZjZi1nYXRld2F5IGluIGVudm95" + + "LWdhdGV3YXksIHNldCBhbGwgc2l4IHJlbW90ZSB3b3JrZXIgZW5kcG9pbnRzIGFuZCB0aGUgZ3Jw" + + "Yy1wcm94eSBsb2NhbCBvdmVycmlkZSwgZW5hYmxlZCBOVkNGIGFuZCBOVkNUIGdSUEMgcm91dGVz" + + "IHBsdXMgTkFUUywgYW5kIGVuYWJsZWQgT3BlbkJhbyBpc3N1ZXIgZGlzY292ZXJ5LiBJdCBjb25m" + + "aWd1cmVkIHRoZSBiYXJlLUdhdGV3YXkgQ0xJIFVSTCBhbmQgSG9zdCBmaWVsZHMgaW5jbHVkaW5n" + + "IGljbXNfaG9zdCwgcGx1cyB0aGUgY29tcHV0ZS1wbGFuZSBJQ01TLCBSZVZhbCwgYW5kIE5BVFMg" + + "ZXh0ZXJuYWwgVVJMcyBhbmQgaG9zdCBvdmVycmlkZXMuIEl0IGNyZWF0ZWQgdGhlIHB1bGwgc2Vj" + + "cmV0IGluIGFsbCBjb250cm9sLXBsYW5lIG5hbWVzcGFjZXMgaW5jbHVkaW5nIGNlcnQtbWFuYWdl" + + "ciwgYnV0IG9ubHkgaW4gbnZjYS1vcGVyYXRvciBvbiB0aGUgY29tcHV0ZSBjbHVzdGVyOyB0aGUg" + + "Y2hhcnQgYW5kIG9wZXJhdG9yIG1pcnJvciBpdCB0byBudmNhLXN5c3RlbS4iLAogICAgImV4cGVj" + + "dGVkX2JlaGF2aW9yIjogWwogICAgICAiVGhlIGFnZW50IHJlYWQgdGhlIG52Y2Ytc2VsZi1tYW5h" + + "Z2VkLWluc3RhbGxhdGlvbiBTS0lMTC5tZCBiZWZvcmUgdGFraW5nIGFjdGlvbiIsCiAgICAgICJU" + + "aGUgYWdlbnQgc2V0IGluZ3Jlc3MuZ2F0ZXdheUFwaS5jb250cm9sbGVyTmFtZXNwYWNlIHRvIGVu" + + "dm95LWdhdGV3YXktc3lzdGVtIiwKICAgICAgIlRoZSBhZ2VudCBzZXQgc2hhcmVkLCBncnBjLCBh" + + "bmQgbmF0cyBHYXRld2F5IHJlZmVyZW5jZXMgdG8gbmFtZSBudmNmLWdhdGV3YXkgYW5kIG5hbWVz" + + "cGFjZSBlbnZveS1nYXRld2F5IiwKICAgICAgIlRoZSBhZ2VudCBzZXQgZ2xvYmFsLndvcmtlckVu" + + "ZHBvaW50cy5udmNmU2VydmljZVVSTCwgbnZjZkdycGNTZXJ2aWNlVVJMLCBudmNmTmF0c1NlcnZp" + + "Y2VVUkwsIG52Y3RTZXJ2aWNlVVJMLCBudmN0R3JwY1NlcnZpY2VVUkwsIGFuZCBpbnZvY2F0aW9u" + + "U2VydmljZVVSTCIsCiAgICAgICJUaGUgYWdlbnQgc2V0IGdycGNwcm94eS5udmNmR3JwY1NlcnZp" + + "Y2VVUkwgdG8gdGhlIGNvbnRyb2wtcGxhbmUtbG9jYWwgQVBJIGdSUEMgc2VydmljZSIsCiAgICAg" + + "ICJUaGUgYWdlbnQgZW5hYmxlZCBib3RoIGluZ3Jlc3MuZ2F0ZXdheUFwaS5yb3V0ZXMubnZjZkFw" + + "aS5ncnBjIGFuZCBudmN0QXBpLmdycGMgd2l0aCB3b3JrZXItYXBpIGFuZCB3b3JrZXItdGFza3Mg" + + "aG9zdG5hbWVzIiwKICAgICAgIlRoZSBhZ2VudCBleHBsaWNpdGx5IHNldCBpbmdyZXNzLmdhdGV3" + + "YXlBcGkucm91dGVzLm5hdHMuZW5hYmxlZCB0byB0cnVlIiwKICAgICAgIlRoZSBhZ2VudCBzZXQg" + + "b3BlbmJhby5taWdyYXRpb25zLmlzc3VlckRpc2NvdmVyeS5lbmFibGVkIHRvIHRydWUiLAogICAg" + + "ICAiVGhlIGFnZW50IGNvbmZpZ3VyZWQgdGhlIGJhcmUtR2F0ZXdheSBDTEkgVVJMIGFuZCBIb3N0" + + "IGZpZWxkcywgaW5jbHVkaW5nIHNjaGVtZS1sZXNzIGljbXNfaG9zdCIsCiAgICAgICJUaGUgYWdl" + + "bnQgY29uZmlndXJlZCBjb21wdXRlLXBsYW5lIGljbXNTZXJ2aWNlVVJMLCBpY21zU2VydmljZUhv" + + "c3RIZWFkZXJPdmVycmlkZSwgcmV2YWxTZXJ2aWNlVVJMLCByZXZhbFNlcnZpY2VIb3N0SGVhZGVy" + + "T3ZlcnJpZGUsIG5hdHNVUkwsIGFuZCBuYXRzSG9zdE92ZXJyaWRlIiwKICAgICAgIlRoZSBjb250" + + "cm9sLXBsYW5lIHB1bGwtc2VjcmV0IG5hbWVzcGFjZSBsaXN0IGluY2x1ZGVkIGNlcnQtbWFuYWdl" + + "ciIsCiAgICAgICJUaGUgY29tcHV0ZS1wbGFuZSBzZWNyZXQgd2FzIGNyZWF0ZWQgb25seSBpbiBu" + + "dmNhLW9wZXJhdG9yIGFuZCBtaXJyb3JlZCBieSB0aGUgY2hhcnQgYW5kIG9wZXJhdG9yIHRvIG52" + + "Y2Etc3lzdGVtIgogICAgXQogIH0sCiAgewogICAgImlkIjogIkcxMS1zcGxpdC10ZWFyZG93biIs" + + "CiAgICAicXVlc3Rpb24iOiAiVGVhciBkb3duIG15IHNwbGl0IGNvbnRyb2wtcGxhbmUgYW5kIGNv" + + "bXB1dGUtcGxhbmUgZGVwbG95bWVudCBzYWZlbHkuIFNob3cgYm90aCB0aGUgSGVsbWZpbGUgdmFs" + + "dWVzIGFuZCBDTEkgcHJvZmlsZSB2YXJpYW50cy4iLAogICAgImV4cGVjdGVkX3NraWxsIjogIm52" + + "Y2Ytc2VsZi1tYW5hZ2VkLWluc3RhbGxhdGlvbiIsCiAgICAiZ3JvdW5kX3RydXRoIjogIlRoZSBI" + + "ZWxtZmlsZSBmbG93IGRlc3Ryb3llZCBhbmQgY29uZmlybWVkIGRlcmVnaXN0cmF0aW9uIG9mIGV2" + + "ZXJ5IGNvbXB1dGUgY2x1c3RlciBiZWZvcmUgZGVzdHJveWluZyB0aGUgY29udHJvbCBwbGFuZSBh" + + "bmQgcGFzc2VkIGJvdGggY29udHJvbC1wbGFuZSBrdWJlY29uZmlnIGZvcm1zLiBCZWZvcmUgZWl0" + + "aGVyIGhhbmRvZmYgY291bGQgZGVzdHJveSB0aGUgY29udHJvbCBwbGFuZSwgYm90aCB0ZWFyZG93" + + "biBmbG93cyB3YXJuZWQgdGhhdCBuYW1lc3BhY2UgcHJlc2VydmF0aW9uIGRvZXMgbm90IHByZXNl" + + "cnZlIHRoZSBIZWxtIHJlbGVhc2UsIHJlcXVpcmVkIGVmZmVjdGl2ZSBjZXJ0TWFuYWdlci5lbmFi" + + "bGVkOiBmYWxzZSBmb3IgYW4gZXh0ZXJuYWwgaW5zdGFsbGF0aW9uIGFuZCBhYm9ydGVkIGlmIHRy" + + "dWUsIGFuZCB2ZXJpZmllZCBtYXRjaGluZyByZWxlYXNlIG93bmVyc2hpcCBmb3IgYW4gaW50ZW5k" + + "ZWQgc3RhY2stbWFuYWdlZCByZWxlYXNlLCBhYm9ydGluZyBvbiBtaXNzaW5nIG9yIG1pc21hdGNo" + + "ZWQgZXZpZGVuY2UuIFRoZXkgcHJlc2VydmVkIHRoZSBuYW1lc3BhY2UgYnkgZGVmYXVsdCBhbmQg" + + "ZGlkIG5vdCBkZWxldGUgaXQgd2l0aG91dCBuYW1lc3BhY2UgcHJvdmVuYW5jZSBhbmQgZXhwbGlj" + + "aXQgY29uZmlybWF0aW9uLiBUaGUgQ0xJIGZsb3cgcmV0YWluZWQgdGhlIGdlbmVyYXRlZCByZWdp" + + "c3RyYXRpb24gdmFsdWVzLCB1c2VkIHRoZSBmdWxsLXByZWZpeCBzdGF0dXMgY29tbWFuZCB0byBp" + + "bnNwZWN0IGxpdmUgcmVnaXN0cmF0aW9ucywgc3RhdGVkIHRoYXQgbmFtZWQtY2x1c3RlciBwbGFu" + + "LW9ubHkgZG9lcyBub3QgcXVlcnkgSUNNUyBhbmQgY2Fubm90IHByZWRpY3QgY29uZGl0aW9uYWwg" + + "Y29udHJvbC1wbGFuZSByZW1vdmFsLCBhbmQgZ290IGV4cGxpY2l0IGNvbmZpcm1hdGlvbiB3aGVu" + + "IHRoZSB0YXJnZXQgd2FzIHRoZSBsYXN0IHJlZ2lzdGVyZWQgY2x1c3Rlci4gSXQgdGhlbiBwcmV2" + + "aWV3ZWQgYW5kIHJhbiBkb3duIHdpdGggdGhlIGZ1bGwgcGVyc2lzdGVudCBwcmVmaXgsIHJlbW92" + + "aW5nIHRoZSBjb250cm9sIHBsYW5lIG9ubHkgYWZ0ZXIgdGhlIGxhc3QgcmVnaXN0cmF0aW9uIHdh" + + "cyBnb25lLiIsCiAgICAiZXhwZWN0ZWRfYmVoYXZpb3IiOiBbCiAgICAgICJUaGUgYWdlbnQgcmVh" + + "ZCB0aGUgbnZjZi1zZWxmLW1hbmFnZWQtaW5zdGFsbGF0aW9uIFNLSUxMLm1kIGJlZm9yZSB0YWtp" + + "bmcgYWN0aW9uIiwKICAgICAgIkZvciBldmVyeSBjb21wdXRlIGNsdXN0ZXIsIHRoZSBIZWxtZmls" + + "ZSBmbG93IHJhbiB0aGUgY29tcHV0ZS1wbGFuZSBNYWtlZmlsZSBkZXN0cm95IHRhcmdldCB3aXRo" + + "IGl0cyBjb21wdXRlIGt1YmVjb25maWciLAogICAgICAiQWZ0ZXIgY29uZmlybWF0aW9uLCB0aGUg" + + "SGVsbWZpbGUgZmxvdyByYW4gY2x1c3RlciBkZWxldGUgd2l0aCBjbHVzdGVySUQgYW5kIG5jYUlE" + + "IGJlZm9yZSBjb250cm9sLXBsYW5lIGRlc3RydWN0aW9uIiwKICAgICAgIkJlZm9yZSBlaXRoZXIg" + + "aGFuZG9mZiBjb3VsZCBkZXN0cm95IHRoZSBjb250cm9sIHBsYW5lLCBib3RoIHRlYXJkb3duIGZs" + + "b3dzIHdhcm5lZCB0aGF0IG5hbWVzcGFjZSBwcmVzZXJ2YXRpb24gZG9lcyBub3QgcHJlc2VydmUg" + + "dGhlIEhlbG0gcmVsZWFzZSwgcmVxdWlyZWQgZWZmZWN0aXZlIGNlcnRNYW5hZ2VyLmVuYWJsZWQ6" + + "IGZhbHNlIGZvciBhbiBleHRlcm5hbCBpbnN0YWxsYXRpb24gYW5kIGFib3J0ZWQgaWYgdHJ1ZSwg" + + "YW5kIHZlcmlmaWVkIGludGVuZGVkIHN0YWNrIG93bmVyc2hpcCB3aGVuIGVuYWJsZWQsIGFib3J0" + + "aW5nIG9uIG1pc3Npbmcgb3IgbWlzbWF0Y2hlZCBldmlkZW5jZSIsCiAgICAgICJCb3RoIHRlYXJk" + + "b3duIGZsb3dzIHByZXNlcnZlZCB0aGUgY2VydC1tYW5hZ2VyIG5hbWVzcGFjZSBieSBkZWZhdWx0" + + "IGFuZCBkaWQgbm90IGRlbGV0ZSBpdCB3aXRob3V0IG5hbWVzcGFjZSBwcm92ZW5hbmNlIGFuZCBl" + + "eHBsaWNpdCBjb25maXJtYXRpb24iLAogICAgICAiVGhlIEhlbG1maWxlIGZsb3cgcmFuIGNvbnRy" + + "b2wtcGxhbmUgTWFrZWZpbGUgZGVzdHJveSB3aXRoIGJvdGggS1VCRUNPTkZJRyBhbmQgS1VCRUNP" + + "TkZJR19GSUxFIiwKICAgICAgIlRoZSBDTEkgZmxvdyByZXRhaW5lZCBvdXQvPGNsdXN0ZXItbmFt" + + "ZT4tcmVnaXN0ZXItdmFsdWVzLnlhbWwgdW50aWwgdGVhcmRvd24gY29tcGxldGVkIiwKICAgICAg" + + "IkJlZm9yZSByZWFsIGRvd24sIHRoZSBDTEkgZmxvdyB1c2VkIHRoZSBmdWxsLXByZWZpeCBzdGF0" + + "dXMgY29tbWFuZCB0byBpbnNwZWN0IGxpdmUgcmVnaXN0cmF0aW9ucywgc3RhdGVkIHRoYXQgbmFt" + + "ZWQtY2x1c3RlciBwbGFuLW9ubHkgZG9lcyBub3QgcXVlcnkgSUNNUyBhbmQgY2Fubm90IHByZWRp" + + "Y3QgY29uZGl0aW9uYWwgY29udHJvbC1wbGFuZSByZW1vdmFsLCB3YXJuZWQgd2hlbiB0aGUgdGFy" + + "Z2V0IHdhcyB0aGUgbGFzdCByZWdpc3RlcmVkIGNsdXN0ZXIsIGFuZCBnb3QgZXhwbGljaXQgY29u" + + "ZmlybWF0aW9uIiwKICAgICAgIlRoZSBDTEkgZmxvdyB1c2VkIC0tY29uZmlnLCBib3RoIHN0YWNr" + + "IHBhdGhzLCAtLWVudiwgLS1wbGFpbiwgYm90aCBjb250ZXh0cywgYW5kIC0taWNtcy11cmwgZm9y" + + "IGRvd24gLS1wbGFuLW9ubHkgYW5kIHRoZW4gZG93biIsCiAgICAgICJUaGUgYWdlbnQgc3RhdGVk" + + "IHRoYXQgZG93biB1bnJlZ2lzdGVycyBlYWNoIGNvbXB1dGUgY2x1c3RlciBhbmQgcmVtb3ZlcyB0" + + "aGUgY29udHJvbCBwbGFuZSBvbmx5IGFmdGVyIG5vIHJlZ2lzdHJhdGlvbnMgcmVtYWluIgogICAg" + + "XQogIH0sCiAgewogICAgImlkIjogIlMxMy12YWx1ZXMtcHJlY2VkZW5jZSIsCiAgICAicXVlc3Rp" + + "b24iOiAiSSBhZGRlZCBhIHZhbHVlIHRvIG15IGVudmlyb25tZW50IFlBTUwgYnV0IGl0J3MgYmVp" + + "bmcgc2lsZW50bHkgaWdub3JlZC4gSG93IGRvIGhlbG1maWxlIHZhbHVlcyB3b3JrIGluIE5WQ0Y/" + + "IiwKICAgICJleHBlY3RlZF9za2lsbCI6ICJudmNmLXNlbGYtbWFuYWdlZC1pbnN0YWxsYXRpb24i" + + "LAogICAgImdyb3VuZF90cnV0aCI6ICJUaGUgYWdlbnQgZXhwbGFpbmVkIHRoZSB2YWx1ZXMgcHJl" + + "Y2VkZW5jZSBjaGFpbiAoYmFzZS55YW1sLCBlbnYgWUFNTCwgZ2xvYmFsLnlhbWwuZ290bXBsLCBz" + + "ZWNyZXRzLCBpbmxpbmUgdmFsdWVzKSwgaWRlbnRpZmllZCB0aGF0IGdsb2JhbC55YW1sLmdvdG1w" + + "bCBvbmx5IHBhc3NlcyB0aHJvdWdoIHNwZWNpZmljIGtleXMsIGFuZCBleHBsYWluZWQgdGhhdCBh" + + "cmJpdHJhcnkgY2hhcnQgdmFsdWVzIG11c3QgdXNlIHJlbGVhc2UgaW5saW5lIHZhbHVlcyBibG9j" + + "a3MuIiwKICAgICJleHBlY3RlZF9iZWhhdmlvciI6IFsKICAgICAgIlRoZSBhZ2VudCByZWFkIHRo" + + "ZSBudmNmLXNlbGYtbWFuYWdlZC1pbnN0YWxsYXRpb24gU0tJTEwubWQgYmVmb3JlIHRha2luZyBh" + + "Y3Rpb24iLAogICAgICAiVGhlIGFnZW50IGV4cGxhaW5lZCB0aGUgdmFsdWVzIHByZWNlZGVuY2Ug" + + "Y2hhaW46IGJhc2UueWFtbCAtPiBlbnYgWUFNTCAtPiBnbG9iYWwueWFtbC5nb3RtcGwgLT4gc2Vj" + + "cmV0cyAtPiBpbmxpbmUgdmFsdWVzIiwKICAgICAgIlRoZSBhZ2VudCBpZGVudGlmaWVkIHRoYXQg" + + "Z2xvYmFsLnlhbWwuZ290bXBsIG9ubHkgcGFzc2VzIHRocm91Z2ggc3BlY2lmaWMga2V5cyAoY2Fz" + + "c2FuZHJhLnJlcGxpY2FDb3VudCwgZ2xvYmFsLnN0b3JhZ2VDbGFzcywgZ2xvYmFsLmltYWdlLCBl" + + "dGMuKSIsCiAgICAgICJUaGUgYWdlbnQgZXhwbGFpbmVkIHRoYXQgYXJiaXRyYXJ5IGNoYXJ0IHZh" + + "bHVlcyBtdXN0IGJlIHNldCB2aWEgcmVsZWFzZSBpbmxpbmUgdmFsdWVzOiBibG9ja3MiLAogICAg" + + "ICAiVGhlIGFnZW50IGxpc3RlZCBleGFtcGxlcyBvZiB2YWx1ZXMgdGhhdCBhcmUgcHJvcGFnYXRl" + + "ZCBhbmQgYXJiaXRyYXJ5IGNoYXJ0IHZhbHVlcyB0aGF0IHJlcXVpcmUgYSByZWxlYXNlIHZhbHVl" + + "cyBibG9jayIKICAgIF0KICB9LAogIHsKICAgICJpZCI6ICJTMTQtZW5hYmxlLWxsbS1mdW5jdGlv" + + "bnMiLAogICAgInF1ZXN0aW9uIjogIkkgbmVlZCB0byBkZXBsb3kgZnVuY3Rpb25UeXBlOiBMTE0g" + + "ZnVuY3Rpb25zIG9uIGEgc2VsZi1tYW5hZ2VkLCBzaW5nbGUtbm9kZSBpc29sYXRlZCB0ZXN0IGNs" + + "dXN0ZXIuIFdoYXQgSGVsbWZpbGUgY29uZmlndXJhdGlvbiBhbmQgdmVyaWZpY2F0aW9uIHN0ZXBz" + + "IGRvIEkgbmVlZD8iLAogICAgImV4cGVjdGVkX3NraWxsIjogIm52Y2Ytc2VsZi1tYW5hZ2VkLWlu" + + "c3RhbGxhdGlvbiIsCiAgICAiZ3JvdW5kX3RydXRoIjogIlRoZSBhZ2VudCBlbmFibGVkIHRoZSBM" + + "TE0gYWRkb24gd2l0aCBhZGRvbnMubGxtLmVuYWJsZWQsIGNvbmZpZ3VyZWQgc2luZ2xlIHJlcGxp" + + "Y2FzIGZvciB0aGUgTExNIEFQSSBHYXRld2F5IGFuZCByZXF1ZXN0IHJvdXRlciwgYW5kIGV4cGxh" + + "aW5lZCB0aGF0IHRoZSByZXF1ZXN0IHJvdXRlciB1c2VzIHBvd2VyLW9mLXR3byB3aGVuIG5vIGxv" + + "YWQtYmFsYW5jZXIgY29uZmlndXJhdGlvbiBpcyBzZXQuIEl0IGxpbmtlZCB0aGUgY2Fub25pY2Fs" + + "IHJlcXVlc3Qtcm91dGVyIGxvYWQtYmFsYW5jaW5nIGd1aWRlIGZvciBvdGhlciByb3V0aW5nIG1l" + + "dGhvZHMuIEZvciB0aGUgaXNvbGF0ZWQgcGxhaW50ZXh0IGNsdXN0ZXIsIGl0IGluY2x1ZGVkIGJv" + + "dGggYWRkb25zLmxsbS5nYXRld2F5LmF1dGguZ3JwY0luc2VjdXJlIGFuZCBhZ2VudENvbmZpZy5t" + + "ZXJnZUNvbmZpZy53b3JrbG9hZC5zdGFyZ2F0ZVFVSUNJbnNlY3VyZSwgd2l0aCBhIHdhcm5pbmcg" + + "dGhhdCB0aG9zZSBzZXR0aW5ncyBhcmUgbm90IGZvciBwcm9kdWN0aW9uLiBJdCByZWZyZXNoZWQg" + + "dGhlIGNvbXB1dGUgcGxhbmUgdXNpbmcgdGhlIHNhbWUgaGFuZG9mZiB1c2VkIGR1cmluZyBpbnN0" + + "YWxsYXRpb24sIHJlZGVwbG95ZWQgZXhpc3RpbmcgTExNIGZ1bmN0aW9ucywgYW5kIHZlcmlmaWVk" + + "IHRoZSBMTE0gZGVwbG95bWVudHMsIHJvdXRlLCBhbmQgbGxtLXdvcmtlciBzaWRlY2FyLiIsCiAg" + + "ICAiZXhwZWN0ZWRfYmVoYXZpb3IiOiBbCiAgICAgICJUaGUgYWdlbnQgdXNlZCBhZGRvbnMubGxt" + + "LmVuYWJsZWQsIG5vdCB0aGUgb2Jzb2xldGUgbGxtLmVuYWJsZWQgcGF0aCIsCiAgICAgICJUaGUg" + + "YWdlbnQgc2V0IGdhdGV3YXkgYW5kIHJlcXVlc3RSb3V0ZXIgcmVwbGljYUNvdW50IHRvIDEgZm9y" + + "IHRoZSBzaW5nbGUtbm9kZSB0ZXN0IGNsdXN0ZXIiLAogICAgICAiVGhlIGFnZW50IHN0YXRlZCB0" + + "aGF0IHRoZSByZXF1ZXN0IHJvdXRlciBkZWZhdWx0cyB0byBwb3dlci1vZi10d28gYW5kIGxpbmtl" + + "ZCB0aGUgY2Fub25pY2FsIHJlcXVlc3Qtcm91dGVyIGxvYWQtYmFsYW5jaW5nIGd1aWRlIGZvciBv" + + "dGhlciBtZXRob2RzIiwKICAgICAgIlRoZSBhZ2VudCBpbmNsdWRlZCBhZGRvbnMubGxtLmdhdGV3" + + "YXkuYXV0aC5ncnBjSW5zZWN1cmUgYW5kIHdvcmtsb2FkLnN0YXJnYXRlUVVJQ0luc2VjdXJlIGZv" + + "ciB0aGUgaXNvbGF0ZWQgcGxhaW50ZXh0IGNsdXN0ZXIsIGFuZCB3YXJuZWQgYWdhaW5zdCB1c2lu" + + "ZyB0aGVtIGluIHByb2R1Y3Rpb24iLAogICAgICAiVGhlIGFnZW50IGFwcGxpZWQgdGhlIGNvbnRy" + + "b2wtcGxhbmUgSGVsbWZpbGUgZW52aXJvbm1lbnQsIHJlZnJlc2hlZCB0aGUgY29tcHV0ZSBwbGFu" + + "ZSB3aXRoIHRoZSBzYW1lIHNlbGVjdGVkIGhhbmRvZmYsIGFuZCByZWNyZWF0ZWQgb3IgcmVkZXBs" + + "b3llZCBleGlzdGluZyBMTE0gZnVuY3Rpb25zIiwKICAgICAgIlRoZSBhZ2VudCB2ZXJpZmllZCBs" + + "bG0tYXBpLWdhdGV3YXksIGxsbS1yZXF1ZXN0LXJvdXRlciwgdGhlIExMTSBIVFRQUm91dGUsIGFu" + + "ZCB0aGUgbGxtLXdvcmtlciBzaWRlY2FyIGluY2x1ZGluZyAtLXF1aWMtaW5zZWN1cmUiCiAgICBd" + + "CiAgfSwKICB7CiAgICAiaWQiOiAiRzgtTkVHLW5vdC1mb3ItazNkIiwKICAgICJxdWVzdGlvbiI6" + + "ICJTZXQgdXAgYSBsb2NhbCBOVkNGIGRldiBjbHVzdGVyIHVzaW5nIGszZCBmb3IgdGVzdGluZyIs" + + "CiAgICAiZXhwZWN0ZWRfc2tpbGwiOiBudWxsLAogICAgInNob3VsZF90cmlnZ2VyIjogZmFsc2Us" + + "CiAgICAiZ3JvdW5kX3RydXRoIjogIlRoaXMgaXMgYSBsb2NhbCBrM2QgZGV2ZWxvcG1lbnQgcmVx" + + "dWVzdCB0aGF0IGJlbG9uZ3MgdG8gdGhlIG52Y2Ytc2VsZi1ob3N0ZWQtbG9jYWwtZGV2IHNraWxs" + + "LCBub3QgbnZjZi1zZWxmLW1hbmFnZWQtaW5zdGFsbGF0aW9uLiBUaGUgYWdlbnQgZGlkIG5vdCBy" + + "ZWFkIG9yIHVzZSB0aGUgc2VsZi1tYW5hZ2VkIGluc3RhbGxhdGlvbiBza2lsbCBhbmQgaW5zdGVh" + + "ZCBwcm92aWRlZCBrM2Qtc3BlY2lmaWMgZ3VpZGFuY2UuIiwKICAgICJleHBlY3RlZF9iZWhhdmlv" + + "ciI6IFsKICAgICAgIlRoZSBhZ2VudCBkaWQgbm90IHJlYWQgbnZjZi1zZWxmLW1hbmFnZWQtaW5z" + + "dGFsbGF0aW9uL1NLSUxMLm1kIiwKICAgICAgIlRoZSBhZ2VudCBkaWQgbm90IHByb3ZpZGUgaGVs" + + "bWZpbGUtYmFzZWQgcHJvZHVjdGlvbiBkZXBsb3ltZW50IGluc3RydWN0aW9ucyIsCiAgICAgICJU" + + "aGUgYWdlbnQgcHJvdmlkZWQgazNkLXNwZWNpZmljIGxvY2FsIGRldmVsb3BtZW50IGd1aWRhbmNl" + + "IG9yIGRlZmVycmVkIHRvIHRoZSBhcHByb3ByaWF0ZSBsb2NhbC1kZXYgc2tpbGwiCiAgICBdCiAg" + + "fQpdClBLBwgrE7g/rVUAAK1VAABQSwMEFAAIAAAAAAAhAAAAAAAAAAAAAAAAAC8ACQBkYXRhL252" + + "Y2Ytc2VsZi1tYW5hZ2VkLWluc3RhbGxhdGlvbi9leGFtcGxlcy5tZFVUBQABAKbOEiMgRXhhbXBs" + + "ZXMKCldvcmtlZCBleGFtcGxlcyBiYXNlZCBvbiByZWFsIGRlcGxveW1lbnQgc2NlbmFyaW9zLgoK" + + "IyMgRXhhbXBsZSAxOiBPdmVycmlkZSBDYXNzYW5kcmEgUmVzb3VyY2VzCgpUaGUgZGVmYXVsdCBD" + + "YXNzYW5kcmEgcmVzb3VyY2UgbGltaXRzIGNhdXNlIE9PTSBvbiBsYXJnZSBpbnN0YW5jZSB0eXBl" + + "cyAoZS5nLiwgYHA1LjQ4eGxhcmdlYCkuCgpQcm9ibGVtOiBDYXNzYW5kcmEgcG9kcyByZXN0YXJ0" + + "IHdpdGggYE9PTUtpbGxlZGAuCgpTb2x1dGlvbjogT3ZlcnJpZGUgcmVzb3VyY2VzIHZpYSBoZWxt" + + "ZmlsZSByZWxlYXNlIHZhbHVlcyBibG9jay4KCiMjIyBTdGVwIDE6IENhcHR1cmUgYmFzZWxpbmUK" + + "CmBgYGJhc2gKSEVMTUZJTEVfRU5WPTxlbnY+IGhlbG1maWxlIC0tc2VsZWN0b3IgbmFtZT1jYXNz" + + "YW5kcmEgdGVtcGxhdGUgPiAvdG1wL2Nhc3MtYmVmb3JlLnlhbWwKZ3JlcCAtQTggJ3Jlc291cmNl" + + "czonIC90bXAvY2Fzcy1iZWZvcmUueWFtbCB8IGhlYWQgLTEwCmBgYAoKIyMjIFN0ZXAgMjogQWRk" + + "IG92ZXJyaWRlIHRvIGhlbG1maWxlLmQvMDEtZGVwZW5kZW5jaWVzLnlhbWwuZ290bXBsCgpJbiB0" + + "aGUgZXhhbXBsZXMgYmVsb3csIGA8cHJpdmF0ZS12YWx1ZXM+YCByZWZlcnMgdG8gdGhlIGBzZWNy" + + "ZXRzL2AgZGlyZWN0b3J5IGF0IHRoZSBoZWxtZmlsZSBzdGFjayByb290LgoKYGBgeWFtbAotIG5h" + + "bWU6IGNhc3NhbmRyYQogIHZlcnNpb246IDAuOC4wCiAgY29uZGl0aW9uOiBjYXNzYW5kcmEuZW5h" + + "YmxlZAogIG5hbWVzcGFjZTogY2Fzc2FuZHJhLXN5c3RlbQogIDw8OiAqZGVwZW5kZW5jeQogIHZh" + + "bHVlczoKICAgIC0gLi4vZ2xvYmFsLnlhbWwuZ290bXBsCiAgICAtIC4uLzxwcml2YXRlLXZhbHVl" + + "cz4ve3sgcmVxdWlyZWRFbnYgIkhFTE1GSUxFX0VOViIgfX0tc2VjcmV0cy55YW1sCiAgICAtIGNh" + + "c3NhbmRyYToKICAgICAgICByZXNvdXJjZXM6CiAgICAgICAgICBsaW1pdHM6CiAgICAgICAgICAg" + + "IGNwdTogIjgiCiAgICAgICAgICAgIG1lbW9yeTogODE5Mk1pCiAgICAgICAgICByZXF1ZXN0czoK" + + "ICAgICAgICAgICAgY3B1OiAiMiIKICAgICAgICAgICAgbWVtb3J5OiA0MDk2TWkKYGBgCgojIyMg" + + "U3RlcCAzOiBWZXJpZnkgYW5kIGFwcGx5CgpgYGBiYXNoCkhFTE1GSUxFX0VOVj08ZW52PiBoZWxt" + + "ZmlsZSAtLXNlbGVjdG9yIG5hbWU9Y2Fzc2FuZHJhIHRlbXBsYXRlID4gL3RtcC9jYXNzLWFmdGVy" + + "LnlhbWwKZGlmZiAvdG1wL2Nhc3MtYmVmb3JlLnlhbWwgL3RtcC9jYXNzLWFmdGVyLnlhbWwgICMg" + + "Q29uZmlybSByZXNvdXJjZXMgY2hhbmdlZApIRUxNRklMRV9FTlY9PGVudj4gaGVsbWZpbGUgLS1z" + + "ZWxlY3RvciBuYW1lPWNhc3NhbmRyYSBzeW5jCmBgYAoKTm90ZTogYHJlc291cmNlUHJlc2V0YCAo" + + "YSBCaXRuYW1pIGZlYXR1cmUpIGlzIG5vdCBhdmFpbGFibGUgaW4gdGhlIE5WQ0YgY2Fzc2FuZHJh" + + "IHdyYXBwZXIgY2hhcnQuIFVzZSBleHBsaWNpdCBgcmVzb3VyY2VzYCBpbnN0ZWFkLgoKLS0tCgoj" + + "IyBFeGFtcGxlIDI6IERlcGxveSBmcm9tIE5HQyBQcml2YXRlIFJlZ2lzdHJ5IHdpdGggUHVsbCBT" + + "ZWNyZXRzCgpEZXBsb3kgdGhlIE5WQ0Ygc3RhY2sgcHVsbGluZyBpbWFnZXMgZGlyZWN0bHkgZnJv" + + "bSBOR0MgKGBudmNyLmlvYCkgaW5zdGVhZCBvZiBhIG1pcnJvcmVkIHJlZ2lzdHJ5LCB1c2luZyBp" + + "bWFnZSBwdWxsIHNlY3JldHMuCgojIyMgU3RlcCAxOiBDb25maWd1cmUgZW52aXJvbm1lbnQgZm9y" + + "IE5HQwoKYGBgeWFtbAojIGVudmlyb25tZW50cy88ZW52Pi55YW1sCmdsb2JhbDoKICBoZWxtOgog" + + "ICAgc291cmNlczoKICAgICAgcmVnaXN0cnk6IG52Y3IuaW8KICAgICAgcmVwb3NpdG9yeTogbnZp" + + "ZGlhL252Y2YKICBpbWFnZToKICAgIHJlZ2lzdHJ5OiBudmNyLmlvCiAgICByZXBvc2l0b3J5OiBu" + + "dmlkaWEvbnZjZgpgYGAKCiMjIyBTdGVwIDI6IEF1dGhlbnRpY2F0ZSBsb2NhbGx5IChmb3IgaGVs" + + "bWZpbGUgY2hhcnQgcHVsbHMpCgpgYGBiYXNoCmRvY2tlciBsb2dpbiBudmNyLmlvIC11ICckb2F1" + + "dGh0b2tlbicgLXAgIiROR0NfQVBJX0tFWSIKaGVsbSByZWdpc3RyeSBsb2dpbiBudmNyLmlvIC11" + + "ICckb2F1dGh0b2tlbicgLXAgIiROR0NfQVBJX0tFWSIKYGBgCgojIyMgU3RlcCAzOiBDcmVhdGUg" + + "bmFtZXNwYWNlcyBhbmQgcHVsbCBzZWNyZXRzCgpgYGBiYXNoCmV4cG9ydCBOR0NfQVBJX0tFWT0i" + + "PHlvdXItbmdjLWFwaS1rZXk+IgoKZm9yIG5zIGluIGNhc3NhbmRyYS1zeXN0ZW0gbmF0cy1zeXN0" + "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" + + "a3ViZWN0bCAtLWNvbnRleHQgPGNvbnRyb2wtcGxhbmUtY29udGV4dD4gY3JlYXRlIG5hbWVzcGFj" + + "ZSAiJG5zIiBcCiAgICAtLWRyeS1ydW49Y2xpZW50IC1vIHlhbWwgfCBrdWJlY3RsIC0tY29udGV4" + + "dCA8Y29udHJvbC1wbGFuZS1jb250ZXh0PiBhcHBseSAtZiAtCmRvbmUKCmZvciBucyBpbiBjYXNz" + + "YW5kcmEtc3lzdGVtIG5hdHMtc3lzdGVtIG52Y2YgYXBpLWtleXMgZXNzIHNpcyB2YXVsdC1zeXN0" + + "ZW0gY2VydC1tYW5hZ2VyOyBkbwogIGt1YmVjdGwgLS1jb250ZXh0IDxjb250cm9sLXBsYW5lLWNv" + + "bnRleHQ+IGNyZWF0ZSBzZWNyZXQgZG9ja2VyLXJlZ2lzdHJ5IG52Y3ItY3JlZHMgXAogICAgLS1k" + + "b2NrZXItc2VydmVyPW52Y3IuaW8gXAogICAgLS1kb2NrZXItdXNlcm5hbWU9JyRvYXV0aHRva2Vu" + + "JyBcCiAgICAtLWRvY2tlci1wYXNzd29yZD0iJE5HQ19BUElfS0VZIiBcCiAgICAtLW5hbWVzcGFj" + + "ZT0iJG5zIiBcCiAgICAtLWRyeS1ydW49Y2xpZW50IC1vIHlhbWwgfCBrdWJlY3RsIC0tY29udGV4" + + "dCA8Y29udHJvbC1wbGFuZS1jb250ZXh0PiBhcHBseSAtZiAtCmRvbmUKYGBgCgojIyMgU3RlcCA0" + + "OiBBZGQgaW1hZ2VQdWxsU2VjcmV0cyB0byBoZWxtZmlsZSByZWxlYXNlcwoKQWRkIHRoZSBjaGFy" + + "dC1zcGVjaWZpYyBgaW1hZ2VQdWxsU2VjcmV0c2Aga2V5IHRvIGVhY2ggcmVsZWFzZS4gRXhhbXBs" + + "ZSBmb3IgY2Fzc2FuZHJhIGluIGBoZWxtZmlsZS5kLzAxLWRlcGVuZGVuY2llcy55YW1sLmdvdG1w" + + "bGA6CgpgYGB5YW1sCi0gbmFtZTogY2Fzc2FuZHJhCiAgdmVyc2lvbjogMC44LjAKICBjb25kaXRp" + + "b246IGNhc3NhbmRyYS5lbmFibGVkCiAgbmFtZXNwYWNlOiBjYXNzYW5kcmEtc3lzdGVtCiAgPDw6" + + "ICpkZXBlbmRlbmN5CiAgdmFsdWVzOgogICAgLSAuLi9nbG9iYWwueWFtbC5nb3RtcGwKICAgIC0g" + + "Li4vPHByaXZhdGUtdmFsdWVzPi97eyByZXF1aXJlZEVudiAiSEVMTUZJTEVfRU5WIiB9fS1zZWNy" + + "ZXRzLnlhbWwKICAgIC0gY2Fzc2FuZHJhOgogICAgICAgIGdsb2JhbDoKICAgICAgICAgIGltYWdl" + + "UHVsbFNlY3JldHM6CiAgICAgICAgICAgIC0gbnZjci1jcmVkcwpgYGAKClNlZSBbcmVmZXJlbmNl" + + "cy9wdWxsLXNlY3JldHMubWRdKHJlZmVyZW5jZXMvcHVsbC1zZWNyZXRzLm1kKSBmb3IgdGhlIGtl" + + "eSBmb3IgZXZlcnkgY2hhcnQuCgpUaGVzZSBhcmUgY29udHJvbC1wbGFuZSBuYW1lc3BhY2VzLiBG" + + "b3IgYSBzZXBhcmF0ZSBjb21wdXRlIGNsdXN0ZXIsIGNyZWF0ZSB0aGUKc2VjcmV0IG9ubHkgaW4g" + + "YG52Y2Etb3BlcmF0b3JgOyB0aGUgY2hhcnQgYW5kIG9wZXJhdG9yIG1pcnJvciBpdCB0bwpgbnZj" + + "YS1zeXN0ZW1gLiBTZWUgW1NwbGl0IENvbXB1dGUtUGxhbmUgSW5zdGFsbGF0aW9uXShyZWZlcmVu" + + "Y2VzL2NvbXB1dGUtcGxhbmUtaW5zdGFsbGF0aW9uLm1kI3B1bGwtc2VjcmV0cykuCgojIyMgU3Rl" + + "cCA1OiBEZXBsb3kKCmBgYGJhc2gKSEVMTUZJTEVfRU5WPTxlbnY+IGhlbG1maWxlIC0ta3ViZS1j" + + "b250ZXh0IDxjb250cm9sLXBsYW5lLWNvbnRleHQ+IHN5bmMKYGBgCgojIyMgU3RlcCA2OiBQYXRj" + + "aCBTZXJ2aWNlQWNjb3VudHMgZm9yIGNoYXJ0cyB3aXRob3V0IG5hdGl2ZSBzdXBwb3J0CgpBZnRl" + + "ciBQaGFzZSAxIChkZXBlbmRlbmNpZXMpIGNvbXBsZXRlcywgT3BlbkJhbyBwb2RzIHdpbGwgYmUg" + + "aW4gYEltYWdlUHVsbEJhY2tPZmZgLiBQYXRjaCBhbmQgcmVzdGFydDoKCmBgYGJhc2gKZm9yIG5z" + + "IGluIHZhdWx0LXN5c3RlbSBudmNmIGVzczsgZG8KICBmb3Igc2EgaW4gJChrdWJlY3RsIC0tY29u" + + "dGV4dCA8Y29udHJvbC1wbGFuZS1jb250ZXh0PiBnZXQgc2EgLW4gIiRucyIgXAogICAgLS1uby1o" + + "ZWFkZXJzIC1vIGN1c3RvbS1jb2x1bW5zPSI6bWV0YWRhdGEubmFtZSIpOyBkbwogICAga3ViZWN0" + + "bCAtLWNvbnRleHQgPGNvbnRyb2wtcGxhbmUtY29udGV4dD4gcGF0Y2ggc2VydmljZWFjY291bnQg" + + "LW4gIiRucyIgIiRzYSIgXAogICAgICAtcCAneyJpbWFnZVB1bGxTZWNyZXRzIjogW3sibmFtZSI6" + + "ICJudmNyLWNyZWRzIn1dfScKICBkb25lCmRvbmUKa3ViZWN0bCAtLWNvbnRleHQgPGNvbnRyb2wt" + + "cGxhbmUtY29udGV4dD4gZGVsZXRlIHBvZHMgLW4gdmF1bHQtc3lzdGVtIC0tYWxsCmBgYAoKVmVy" + + "aWZ5OgoKYGBgYmFzaAprdWJlY3RsIC0tY29udGV4dCA8Y29udHJvbC1wbGFuZS1jb250ZXh0PiBn" + + "ZXQgZXZlbnRzIC1uIHZhdWx0LXN5c3RlbSBcCiAgLS1zb3J0LWJ5PScubGFzdFRpbWVzdGFtcCcg" + + "fCBncmVwIC1pIHB1bGwKIyBTaG91bGQgc2hvdyAiU3VjY2Vzc2Z1bGx5IHB1bGxlZCBpbWFnZSIg" + + "ZnJvbSBudmNyLmlvCmBgYAoKLS0tCgojIyBFeGFtcGxlIDM6IEZ1bGwgVGVhcmRvd24gYW5kIFJl" + + "aW5zdGFsbAoKV2hlbiBhIGRlcGxveW1lbnQgaXMgYnJva2VuIGFuZCB5b3UgbmVlZCBhIGNsZWFu" + + "IHNsYXRlLgoKIyMjIFN0ZXAgMTogRGVzdHJveSB0aGUgY29tcHV0ZS1wbGFuZSBzdGFjawoKYGBg" + + "YmFzaAptYWtlIC1DIGRlcGxveS9zdGFja3MvbnZjZi1jb21wdXRlLXBsYW5lIGRlc3Ryb3kgXAog" + + "IENMVVNURVJfTkFNRT08Y2x1c3Rlci1uYW1lPiBcCiAgSEVMTUZJTEVfRU5WPTxlbnY+IFwKICBL" + + "VUJFQ09ORklHX0ZJTEU9PGNvbXB1dGUtcGxhbmUta3ViZWNvbmZpZz4KYGBgCgpJZiBjb21wdXRl" + + "IGNsZWFudXAgaXMgc3R1Y2sgb24gZmluYWxpemVycywgdXNlIHRoZSBjb21wdXRlLWNvbnRleHQg" + + "cHJvY2VkdXJlIGluCltkZWJ1Z2dpbmcubWRdKHJlZmVyZW5jZXMvZGVidWdnaW5nLm1kI2ZhaWx1" + + "cmUtbnZjYS1jbGVhbnVwLXN0dWNrLWZpbmFsaXplcnMpLgoKIyMjIFN0ZXAgMjogRGVyZWdpc3Rl" + + "ciB0aGUgY29tcHV0ZSBjbHVzdGVyCgpSZWFkIGBjbHVzdGVySURgIGFuZCBgbmNhSURgIGZyb20K" + + "YGRlcGxveS9zdGFja3MvbnZjZi1jb21wdXRlLXBsYW5lL3JlZ2lzdHJhdGlvbi88Y2x1c3Rlci1u" + + "YW1lPi1yZWdpc3Rlci12YWx1ZXMueWFtbGAuClNob3cgdGhlIElEIGFuZCBnZXQgY29uZmlybWF0" + + "aW9uIGJlZm9yZSBkZWxldGluZyB0aGUgSUNNUyByb3c6CgpgYGBiYXNoCjxudmNmLWNsaT4gLS1j" + + "b25maWcgPGNvbmZpZz4gY2x1c3RlciBkZWxldGUgXAogIC0tY2x1c3Rlci1pZCA8Y2x1c3Rlci1p" + + "ZC1mcm9tLXJlZ2lzdHJhdGlvbi12YWx1ZXM+IFwKICAtLW5jYS1pZCA8bmNhLWlkPiBcCiAgLS1p" + + "Z25vcmUtbWlzc2luZwpgYGAKClJlcGVhdCBzdGVwcyAxIGFuZCAyIGZvciBldmVyeSBjb21wdXRl" + + "IGNsdXN0ZXIuCgojIyMgU3RlcCAzOiBEZXN0cm95IHRoZSBjb250cm9sLXBsYW5lIHN0YWNrCgpQ" + + "cmVzZXJ2ZSB0aGUgYGNlcnQtbWFuYWdlcmAgbmFtZXNwYWNlIGJ5IGRlZmF1bHQuIE5hbWVzcGFj" + + "ZSBwcmVzZXJ2YXRpb24gZG9lcwpub3QgcHJlc2VydmUgdGhlIEhlbG0gcmVsZWFzZS4gQmVmb3Jl" + + "IHJ1bm5pbmcgZGVzdHJveSwgaWRlbnRpZnkgd2hldGhlcgpjZXJ0LW1hbmFnZXIgaXMgZXh0ZXJu" + + "YWwuIEZvciBhbiBleHRlcm5hbCBpbnN0YWxsYXRpb24sIHJlcXVpcmUgZWZmZWN0aXZlCmBjZXJ0" + + "TWFuYWdlci5lbmFibGVkOiBmYWxzZWAgYW5kIGFib3J0IGlmIGl0IGlzIHRydWUuIEZvciBhbiBp" + + "bnRlbmRlZApzdGFjay1tYW5hZ2VkIHJlbGVhc2Ugd2l0aCBlZmZlY3RpdmUgYGNlcnRNYW5hZ2Vy" + + "LmVuYWJsZWQ6IHRydWVgLCB2ZXJpZnkKbWF0Y2hpbmcgc3RhY2sgSGVsbSByZWxlYXNlIG1ldGFk" + + "YXRhIGFuZCBhYm9ydCBvbiBtaXNzaW5nIG9yIG1pc21hdGNoZWQKZXZpZGVuY2UuIE9ubHkgcGxh" + + "biBuYW1lc3BhY2UgcmVtb3ZhbCBhZnRlciB2ZXJpZnlpbmcgbmFtZXNwYWNlIHByb3ZlbmFuY2Ug" + + "YW5kCmdldHRpbmcgZXhwbGljaXQgY29uZmlybWF0aW9uOyBvdGhlcndpc2UgZG8gbm90IGRlbGV0" + + "ZSBpdC4KCmBgYGJhc2gKS1VCRUNPTkZJRz08Y29udHJvbC1wbGFuZS1rdWJlY29uZmlnPiBcCm1h" + + "a2UgLUMgZGVwbG95L3N0YWNrcy9zZWxmLW1hbmFnZWQgZGVzdHJveSBcCiAgSEVMTUZJTEVfRU5W" + + "PTxlbnY+IFwKICBLVUJFQ09ORklHX0ZJTEU9PGNvbnRyb2wtcGxhbmUta3ViZWNvbmZpZz4KYGBg" + + "CgpQYXNzIGJvdGgga3ViZWNvbmZpZyBmb3JtcyBiZWNhdXNlIGNvbnRyb2wtcGxhbmUgbmFtZXNw" + + "YWNlIGNsZWFudXAgdXNlcwphbWJpZW50IGBrdWJlY3RsYC4KCiMjIyBTdGVwIDQ6IFZlcmlmeSBj" + + "bGVhbgoKYGBgYmFzaAprdWJlY3RsIC0tY29udGV4dCA8Y29tcHV0ZS1wbGFuZS1jb250ZXh0PiBn" + + "ZXQgbnMgfCBcCiAgZ3JlcCAtRSAnKG52Y2F8bnZjZi1iYWNrZW5kfGdyb3ZlfGR5bmFtbyknCmt1" + + "YmVjdGwgLS1jb250ZXh0IDxjb250cm9sLXBsYW5lLWNvbnRleHQ+IGdldCBucyB8IFwKICBncmVw" + + "IC1FICcoY2Fzc2FuZHJhfG5hdHN8dmF1bHR8bnZjZnxhcGkta2V5c3xlc3N8c2lzKScKIyBCb3Ro" + + "IGNvbW1hbmRzIHNob3VsZCByZXR1cm4gZW1wdHkuCmBgYAoKIyMjIFN0ZXAgNTogUmVpbnN0YWxs" + + "IGluIHNwbGl0IG9yZGVyCgpGb2xsb3cgW0NsZWFuIEluc3RhbGxhdGlvbl0oU0tJTEwubWQjY2xl" + + "YW4taW5zdGFsbGF0aW9uKSwgdGhlbiByZXR1cm4gdG8gdGhlCnNhbWUgaGFuZG9mZiBpbiBbU3Bs" + + "aXQgQ29tcHV0ZS1QbGFuZSBJbnN0YWxsYXRpb25dKHJlZmVyZW5jZXMvY29tcHV0ZS1wbGFuZS1p" + + "bnN0YWxsYXRpb24ubWQpLgoKLS0tCgojIyBFeGFtcGxlIDQ6IFJlY292ZXIgZnJvbSBhIEdhdGV3" + + "YXkgRW5kcG9pbnQgQ2hhbmdlCgpUaGUgc2VwYXJhdGVseSBwcm92aXNpb25lZCBHYXRld2F5IG9y" + + "IGl0cyBsb2FkIGJhbGFuY2VyIHdhcyByZWNyZWF0ZWQgYW5kIGdvdCBhIG5ldyBlbmRwb2ludC4K" + + "CiMjIyBTdGVwIDE6IEdldCB0aGUgbmV3IGVuZHBvaW50CgpgYGBiYXNoCkdBVEVXQVlfQUREUj0k" + + "KGt1YmVjdGwgLS1jb250ZXh0IDxjb250cm9sLXBsYW5lLWNvbnRleHQ+IGdldCBnYXRld2F5IFwK" + + "ICBudmNmLWdhdGV3YXkgLW4gZW52b3ktZ2F0ZXdheSBcCiAgLW8ganNvbnBhdGg9J3suc3RhdHVz" + + "LmFkZHJlc3Nlc1swXS52YWx1ZX0nKQp0ZXN0IC1uICIkR0FURVdBWV9BRERSIgpgYGAKCiMjIyBT" + + "dGVwIDI6IFVwZGF0ZSBETlMgYW5kIGRpcmVjdCBhZGRyZXNzIGZpZWxkcwoKS2VlcCBgZ2xvYmFs" + + "LmRvbWFpbmAsIHJvdXRlIGhvc3RuYW1lcywgYW5kIENMSSBIb3N0IGZpZWxkcyB1bmNoYW5nZWQu" + + "IFBvaW50IHRoZQpETlMgcmVjb3JkcyBmb3IgcmVuZGVyZWQgcm91dGUgaG9zdG5hbWVzLCBzdWNo" + + "IGFzIGBhcGkuPGRvbWFpbj5gIGFuZApgKi5pbnZvY2F0aW9uLjxkb21haW4+YCwgdG8gYEdBVEVX" + + "QVlfQUREUmAuIEZvciBhIHRlbXBvcmFyeSBlbnZpcm9ubWVudCB3aXRob3V0CkROUywga2VlcCBp" + + "dHMgcmVzZXJ2ZWQgcm91dGUgc3VmZml4IGFuZCBjb25uZWN0IHRvIGBHQVRFV0FZX0FERFJgIHdp" + + "dGggdGhlCm1hdGNoaW5nIGBIb3N0YCBoZWFkZXIuCgpGb3IgYSBzcGxpdCBkZXBsb3ltZW50IGNv" + + "bmZpZ3VyZWQgd2l0aCBkaXJlY3QgR2F0ZXdheSBhZGRyZXNzZXMsIHJlcGxhY2Ugb25seQp0aGUg" + + "YWRkcmVzcy1iZWFyaW5nIHZhbHVlczogY29udHJvbC1wbGFuZSBgbnZjZk5hdHNTZXJ2aWNlVVJM" + + "YCwgY29tcHV0ZS1wbGFuZQpJQ01TLCBSZVZhbCwgYW5kIE5BVFMgVVJMcywgYW5kIENMSSBVUkwg" + + "ZmllbGRzLiBLZWVwIHRoZWlyIGRvbWFpbiBhbmQgSG9zdApvdmVycmlkZXMgdW5jaGFuZ2VkLiBS" + + "ZWZyZXNoIHJlZ2lzdHJhdGlvbiBhbmQgaW5zdGFsbGF0aW9uIHRocm91Z2ggdGhlIHNhbWUKaGFu" + + "ZG9mZiB1c2VkIG9yaWdpbmFsbHkuIFNlZQpbU3BsaXQgQ29tcHV0ZS1QbGFuZSBJbnN0YWxsYXRp" + + "b25dKHJlZmVyZW5jZXMvY29tcHV0ZS1wbGFuZS1pbnN0YWxsYXRpb24ubWQpCmZvciB0aGUgZmll" + + "bGRzIGFuZCBjb21wbGV0ZSBjb21tYW5kcy4KCiMjIyBTdGVwIDM6IFZlcmlmeSBib3RoIGNvbnRl" + + "eHRzCgpgYGBiYXNoCmRpZyArc2hvcnQgImFwaS48ZG9tYWluPiIKY3VybCAtSCAiSG9zdDogYXBp" + + "Ljxkb21haW4+IiAiaHR0cDovLyRHQVRFV0FZX0FERFIvaGVhbHRoIgprdWJlY3RsIC0tY29udGV4" + + "dCA8Y29udHJvbC1wbGFuZS1jb250ZXh0PiBnZXQgZ2F0ZXdheSBudmNmLWdhdGV3YXkgXAogIC1u" + + "IGVudm95LWdhdGV3YXkgLW8gd2lkZQprdWJlY3RsIC0tY29udGV4dCA8Y29udHJvbC1wbGFuZS1j" + + "b250ZXh0PiBnZXQgaHR0cHJvdXRlcyAtQQprdWJlY3RsIC0tY29udGV4dCA8Y29udHJvbC1wbGFu" + + "ZS1jb250ZXh0PiBnZXQgdGNwcm91dGVzIC1BCmt1YmVjdGwgLS1jb250ZXh0IDxjb21wdXRlLXBs" + + "YW5lLWNvbnRleHQ+IHJvbGxvdXQgc3RhdHVzIFwKICBkZXBsb3ltZW50L252Y2Etb3BlcmF0b3Ig" + + "LW4gbnZjYS1vcGVyYXRvciAtLXRpbWVvdXQ9MTBtCmt1YmVjdGwgLS1jb250ZXh0IDxjb21wdXRl" + + "LXBsYW5lLWNvbnRleHQ+IHdhaXQgXAogIG52Y2ZiYWNrZW5kLzxjb21wdXRlLXBsYW5lLWNsdXN0" + + "ZXItbmFtZT4gLW4gbnZjYS1vcGVyYXRvciBcCiAgLS1mb3I9anNvbnBhdGg9J3suc3RhdHVzLmFn" + + "ZW50U3RhdHVzfSc9aGVhbHRoeSAtLXRpbWVvdXQ9MTBtCmBgYAoKLS0tCgojIyBFeGFtcGxlIDU6" + + "IERlcGxveSBPbmx5IERlcGVuZGVuY2llcwoKVXNlZnVsIGZvciB0ZXN0aW5nIG9yIHdoZW4gaXRl" + + "cmF0aW5nIG9uIHNlcnZpY2UgY29uZmlndXJhdGlvbi4KCmBgYGJhc2gKIyBEZXBsb3kganVzdCBO" + + "QVRTLCBDYXNzYW5kcmEsIE9wZW5CYW8KSEVMTUZJTEVfRU5WPTxlbnY+IGhlbG1maWxlIC0tc2Vs" + + "ZWN0b3IgcmVsZWFzZS1ncm91cD1kZXBlbmRlbmNpZXMgc3luYwoKIyBDaGVjayBzdGF0dXMKa3Vi" + + "ZWN0bCBnZXQgcG9kcyAtbiBuYXRzLXN5c3RlbQprdWJlY3RsIGdldCBwb2RzIC1uIGNhc3NhbmRy" + + "YS1zeXN0ZW0Ka3ViZWN0bCBnZXQgcG9kcyAtbiB2YXVsdC1zeXN0ZW0KCiMgRGVwbG95IGp1c3Qg" + + "b25lIHNwZWNpZmljIHJlbGVhc2UKSEVMTUZJTEVfRU5WPTxlbnY+IGhlbG1maWxlIC0tc2VsZWN0" + + "b3IgbmFtZT1jYXNzYW5kcmEgc3luYwpgYGAKCiMjIyBTZWxlY3RvciByZWZlcmVuY2UKCnwgU2Vs" + + "ZWN0b3IgfCBSZWxlYXNlcyB8CnwtLS0tLS0tLS0tfC0tLS0tLS0tLS18CnwgYHJlbGVhc2UtZ3Jv" + + "dXA9ZGVwZW5kZW5jaWVzYCB8IG5hdHMsIGNhc3NhbmRyYSwgb3BlbmJhby1zZXJ2ZXIgfAp8IGBy" + + "ZWxlYXNlLWdyb3VwPXNlcnZpY2VzYCB8IGFwaS1rZXlzLCBzaXMsIGFwaSwgaW52b2NhdGlvbi1z" + + "ZXJ2aWNlLCBncnBjLXByb3h5LCBlc3MtYXBpLCBub3Rhcnktc2VydmljZSwgcmV2YWwsIG9wdGlv" + + "bmFsIGxsbS1yZXF1ZXN0LXJvdXRlciBhbmQgbGxtLWFwaS1nYXRld2F5IHdoZW4gYGxsbS5lbmFi" + + "bGVkPXRydWVgLCBvcHRpb25hbCB2YW5pdHktZ2F0ZXdheSBvbmx5IGluIHN0YWNrIHBhY2thZ2Vz" + + "IHRoYXQgaW5jbHVkZSB0aGUgYWRkb24gYW5kIGhhdmUgYGFkZG9ucy52YW5pdHlHYXRld2F5LmVu" + + "YWJsZWQ9dHJ1ZWAsIG9wdGlvbmFsIG52Y2YtdWkgb25seSBpbiBzdGFjayBwYWNrYWdlcyB0aGF0" + + "IGluY2x1ZGUgdGhlIGFkZG9uIGFuZCBoYXZlIGBhZGRvbnMubnZjZlVpLmVuYWJsZWQ9dHJ1ZWAg" + + "fAp8IGBuYW1lPWxsbS1yZXF1ZXN0LXJvdXRlcmAgfCBEZXBsb3kganVzdCB0aGUgTExNIHJlcXVl" + + "c3Qgcm91dGVyIHdoZW4gYGxsbS5lbmFibGVkPXRydWVgIHwKfCBgbmFtZT1sbG0tYXBpLWdhdGV3" + + "YXlgIHwgRGVwbG95IGp1c3QgdGhlIExMTSBBUEkgZ2F0ZXdheSB3aGVuIGBsbG0uZW5hYmxlZD10" + + "cnVlYCB8CnwgYG5hbWU9dmFuaXR5LWdhdGV3YXlgIHwgRGVwbG95IGp1c3QgVmFuaXR5IEdhdGV3" + + "YXkgb25seSB3aGVuIHRoZSBzdGFjayBwYWNrYWdlIGluY2x1ZGVzIHRoYXQgcmVsZWFzZSBhbmQg" + + "YGFkZG9ucy52YW5pdHlHYXRld2F5LmVuYWJsZWQ9dHJ1ZWAgfAp8IGBuYW1lPW52Y2YtdWlgIHwg" + + "RGVwbG95IE5WQ0YgVUkgb25seSB3aGVuIHRoZSBzdGFjayBwYWNrYWdlIGluY2x1ZGVzIHRoYXQg" + + "cmVsZWFzZSBhbmQgYGFkZG9ucy5udmNmVWkuZW5hYmxlZD10cnVlYCB8CnwgYHJlbGVhc2UtZ3Jv" + + "dXA9aW5ncmVzc2AgfCBpbmdyZXNzIChnYXRld2F5IHJvdXRlcykgfAp8IGBuYW1lPTxyZWxlYXNl" + + "PmAgfCBBbnkgaW5kaXZpZHVhbCByZWxlYXNlIGJ5IG5hbWUgfAoKTm90ZTogYGFkbWluLWlzc3Vl" + + "ci1wcm94eWAgZG9lcyBub3QgaGF2ZSBhIHJlbGVhc2UtZ3JvdXAgbGFiZWwuIFRhcmdldCBpdCB3" + + "aXRoIGAtLXNlbGVjdG9yIG5hbWU9YWRtaW4taXNzdWVyLXByb3h5YC4KUEsHCAJSTkB/KAAAfygA" + + "AFBLAwQUAAgAAAAAACEAAAAAAAAAAAAAAAAATAAJAGRhdGEvbnZjZi1zZWxmLW1hbmFnZWQtaW5z" + + "dGFsbGF0aW9uL3JlZmVyZW5jZXMvY29tcHV0ZS1wbGFuZS1pbnN0YWxsYXRpb24ubWRVVAUAAQCm" + + "zhIjIFNwbGl0IENvbXB1dGUtUGxhbmUgSW5zdGFsbGF0aW9uCgpUaGUgY29udHJvbCBwbGFuZSBh" + + "bmQgY29tcHV0ZSBwbGFuZSBhcmUgc2VwYXJhdGUgc3RhY2tzLiBJbnN0YWxsIHRoZSBjb250cm9s" + + "CnBsYW5lIGZpcnN0LCB0aGVuIHJlZ2lzdGVyIGFuZCBpbnN0YWxsIGVhY2ggY29tcHV0ZSBjbHVz" + + "dGVyLiBDaG9vc2Ugb25lIGhhbmRvZmYKYmVsb3cgYW5kIHVzZSBpdCBmb3IgdGhlIGZ1bGwgbGlm" + + "ZWN5Y2xlLiBEbyBub3QgY29tYmluZSBhIENMSS1nZW5lcmF0ZWQgcHJvZmlsZQp3aXRoIHRoZSBI" + + "ZWxtZmlsZSB2YWx1ZXMgZmxvdy4KCiMjIENob29zZSBhIEhhbmRvZmYKCnwgRmxvdyB8IFNvdXJj" + + "ZSBvZiBjb250cm9sLXBsYW5lIGVuZHBvaW50cyB8IFJlZ2lzdHJhdGlvbiBhcnRpZmFjdCB8Cnwt" + + "LS0tLS18LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS18LS0tLS0tLS0tLS0tLS0t" + + "LS0tLS0tLS18CnwgSGVsbWZpbGUgdmFsdWVzIHwgU2VwYXJhdGUgY29udHJvbC1wbGFuZSBhbmQg" + + "Y29tcHV0ZS1wbGFuZSBlbnZpcm9ubWVudCBmaWxlcyB8IGBkZXBsb3kvc3RhY2tzL252Y2YtY29t" + + "cHV0ZS1wbGFuZS9yZWdpc3RyYXRpb24vPGNsdXN0ZXI+LXJlZ2lzdGVyLXZhbHVlcy55YW1sYCB8" + + "CnwgQ0xJIHByb2ZpbGUgfCBDTEktZ2VuZXJhdGVkIGBkZXBsb3kvc3RhY2tzL3NlbGYtbWFuYWdl" + + "ZC9vdXQvY29udHJvbC1wbGFuZS1wcm9maWxlLnlhbWxgIHwgQ0xJLWdlbmVyYXRlZCBgZGVwbG95" + + "L3N0YWNrcy9udmNmLWNvbXB1dGUtcGxhbmUvb3V0LzxjbHVzdGVyPi1yZWdpc3Rlci12YWx1ZXMu" + + "eWFtbGAgfAoKVGhlIENMSSBwcm9maWxlIGlzIG1hbmRhdG9yeSBmb3IgdGhlIENMSSBmbG93IGFu" + + "ZCBtdXN0IG5vdCBiZSBoYW5kLWF1dGhvcmVkLgpUaGUgSGVsbWZpbGUgZmxvdyBkb2VzIG5vdCBj" + + "b25zdW1lIGEgY29udHJvbC1wbGFuZSBwcm9maWxlLgoKQ29tbWFuZHMgYmVsb3cgdXNlIG1vbm9y" + + "ZXBvIHBhdGhzIGZyb20gdGhlIHJlcG9zaXRvcnkgcm9vdC4gT3BlcmF0b3JzIHVzaW5nCmV4dHJh" + + "Y3RlZCBwYWNrYWdlcyBuZWVkIG1hdGNoaW5nLXZlcnNpb24gYG52Y2Ytc2VsZi1tYW5hZ2VkLXN0" + + "YWNrYCBhbmQKYG52Y2YtY29tcHV0ZS1wbGFuZS1zdGFja2AgYnVuZGxlcy4gU3Vic3RpdHV0ZSB0" + + "aG9zZSBidW5kbGUgcm9vdHMgZm9yCmBkZXBsb3kvc3RhY2tzL3NlbGYtbWFuYWdlZGAgYW5kIGBk" + + "ZXBsb3kvc3RhY2tzL252Y2YtY29tcHV0ZS1wbGFuZWAuCgojIyBIZWxtZmlsZSBWYWx1ZXMgRmxv" + + "dwoKQ3JlYXRlIGJvdGggZW52aXJvbm1lbnQgZmlsZXMgYmVmb3JlIGluc3RhbGxhdGlvbjoKCi0g" + + "YGRlcGxveS9zdGFja3Mvc2VsZi1tYW5hZ2VkL2Vudmlyb25tZW50cy88ZW52Pi55YW1sYCBmb3Ig" + + "Y29udHJvbC1wbGFuZQogIHJlZ2lzdHJ5LCBkb21haW4sIEdhdGV3YXksIHJvdXRlcywgYW5kIHNl" + + "cnZpY2Ugc2V0dGluZ3MuCi0gYGRlcGxveS9zdGFja3MvbnZjZi1jb21wdXRlLXBsYW5lL2Vudmly" + + "b25tZW50cy88ZW52Pi55YW1sYCBmb3IgY29tcHV0ZS1wbGFuZQogIHJlZ2lzdHJ5LCBwdWxsIHNl" + + "Y3JldHMsIGFuZCBjb21wdXRlLXJlYWNoYWJsZSBJQ01TLCBSZVZhbCwgYW5kIE5BVFMgdmFsdWVz" + + "LgoKRm9yIEVLUywgdXNlIHRoZSBjYW5vbmljYWwKW0NTUCBFbmQtdG8tRW5kIEV4YW1wbGVdKGh0" + + "dHBzOi8vZG9jcy5udmlkaWEuY29tL252Y2YvdjAuNi4wLXJjL2NzcC1lbmQtdG8tZW5kLWV4YW1w" + + "bGUpLgpUaGUgY29udHJvbC1wbGFuZSBlbnZpcm9ubWVudCBrZWVwcyB0aGUgRW52b3kgR2F0ZXdh" + + "eSBjb250cm9sbGVyIGluCmBlbnZveS1nYXRld2F5LXN5c3RlbWAsIGF0dGFjaGVzIHJvdXRlcyB0" + + "byBgR2F0ZXdheS9udmNmLWdhdGV3YXlgIGluCmBlbnZveS1nYXRld2F5YCwgYW5kIGVuYWJsZXMg" + + "dGhlIE5BVFMgcm91dGUuIFRoZSBjb21wdXRlLXBsYW5lIGVudmlyb25tZW50IHVzZXMKdGhlIGV4" + + "dGVybmFsIGFkZHJlc3MgcGx1cyB0aGUgc2VydmljZSBob3N0IG92ZXJyaWRlcy4gSGVyZSwKYDxn" + + "YXRld2F5LWFkZHJlc3M+YCBpcyB0aGUgTkxCIGFkZHJlc3MgYW5kIGA8Z2F0ZXdheS1kb21haW4+" + + "YCBpcyB0aGUgRE5TIGJhc2UKd2hvc2Ugc2VydmljZSBzdWJkb21haW5zIHJlc29sdmUgdG8gdGhh" + + "dCBOTEI6CgpgYGB5YW1sCiMgZGVwbG95L3N0YWNrcy9zZWxmLW1hbmFnZWQvZW52aXJvbm1lbnRz" + + "LzxlbnY+LnlhbWwKZ2xvYmFsOgogIGRvbWFpbjogIjxnYXRld2F5LWRvbWFpbj4iCiAgd29ya2Vy" + + "RW5kcG9pbnRzOgogICAgbnZjZlNlcnZpY2VVUkw6ICJodHRwOi8vYXBpLjxnYXRld2F5LWRvbWFp" + + "bj4iCiAgICBudmNmR3JwY1NlcnZpY2VVUkw6ICJodHRwOi8vd29ya2VyLWFwaS48Z2F0ZXdheS1k" + + "b21haW4+IgogICAgbnZjZk5hdHNTZXJ2aWNlVVJMOiAibmF0czovLzxnYXRld2F5LWFkZHJlc3M+" + + "OjQyMjIiCiAgICBudmN0U2VydmljZVVSTDogImh0dHA6Ly90YXNrcy48Z2F0ZXdheS1kb21haW4+" + + "IgogICAgbnZjdEdycGNTZXJ2aWNlVVJMOiAiaHR0cDovL3dvcmtlci10YXNrcy48Z2F0ZXdheS1k" + + "b21haW4+IgogICAgaW52b2NhdGlvblNlcnZpY2VVUkw6ICJodHRwOi8vaW52b2NhdGlvbi48Z2F0" + + "ZXdheS1kb21haW4+IgoKZ3JwY3Byb3h5OgogIG52Y2ZHcnBjU2VydmljZVVSTDogImh0dHA6Ly9h" + + "cGkubnZjZi5zdmMuY2x1c3Rlci5sb2NhbDo5MDkwIgoKaW5ncmVzczoKICBnYXRld2F5QXBpOgog" + + "ICAgY29udHJvbGxlck5hbWVzcGFjZTogZW52b3ktZ2F0ZXdheS1zeXN0ZW0KICAgIGdhdGV3YXlz" + + "OgogICAgICBzaGFyZWQ6IHtuYW1lOiBudmNmLWdhdGV3YXksIG5hbWVzcGFjZTogZW52b3ktZ2F0" + + "ZXdheX0KICAgICAgZ3JwYzoge25hbWU6IG52Y2YtZ2F0ZXdheSwgbmFtZXNwYWNlOiBlbnZveS1n" + + "YXRld2F5fQogICAgICBuYXRzOgogICAgICAgIG5hbWU6IG52Y2YtZ2F0ZXdheQogICAgICAgIG5h" + + "bWVzcGFjZTogZW52b3ktZ2F0ZXdheQogICAgICAgIGxpc3RlbmVyTmFtZTogbmF0cwogICAgcm91" + + "dGVzOgogICAgICBudmNmQXBpOgogICAgICAgIGdycGM6CiAgICAgICAgICBlbmFibGVkOiB0cnVl" + + "CiAgICAgICAgICBob3N0bmFtZXM6IFsid29ya2VyLWFwaS48Z2F0ZXdheS1kb21haW4+Il0KICAg" + + "ICAgbnZjdEFwaToKICAgICAgICBncnBjOgogICAgICAgICAgZW5hYmxlZDogdHJ1ZQogICAgICAg" + + "ICAgaG9zdG5hbWVzOiBbIndvcmtlci10YXNrcy48Z2F0ZXdheS1kb21haW4+Il0KICAgICAgbmF0" + + "czoKICAgICAgICBlbmFibGVkOiB0cnVlCgpvcGVuYmFvOgogIG1pZ3JhdGlvbnM6CiAgICBpc3N1" + + "ZXJEaXNjb3Zlcnk6CiAgICAgIGVuYWJsZWQ6IHRydWUKYGBgCgpgYGB5YW1sCiMgZGVwbG95L3N0" + + "YWNrcy9udmNmLWNvbXB1dGUtcGxhbmUvZW52aXJvbm1lbnRzLzxlbnY+LnlhbWwKZ2xvYmFsOgog" + + "IG52Y2FPcGVyYXRvcjoKICAgIHNlbGZNYW5hZ2VkOgogICAgICBpY21zU2VydmljZVVSTDogImh0" + + "dHA6Ly88Z2F0ZXdheS1hZGRyZXNzPiIKICAgICAgaWNtc1NlcnZpY2VIb3N0SGVhZGVyT3ZlcnJp" + + "ZGU6ICJzaXMuPGdhdGV3YXktZG9tYWluPiIKICAgICAgcmV2YWxTZXJ2aWNlVVJMOiAiaHR0cDov" + + "LzxnYXRld2F5LWFkZHJlc3M+IgogICAgICByZXZhbFNlcnZpY2VIb3N0SGVhZGVyT3ZlcnJpZGU6" + + "ICJyZXZhbC48Z2F0ZXdheS1kb21haW4+IgogICAgICBuYXRzVVJMOiAibmF0czovLzxnYXRld2F5" + + "LWFkZHJlc3M+OjQyMjIiCiAgICAgIG5hdHNIb3N0T3ZlcnJpZGU6ICJuYXRzLjxnYXRld2F5LWRv" + + "bWFpbj4iCmBgYAoKUHJldmlldyBhbmQgaW5zdGFsbCB0aGUgY29udHJvbCBwbGFuZSBhZ2FpbnN0" + + "IGl0cyBjb250ZXh0OgoKYGBgYmFzaAptYWtlIC1DIGRlcGxveS9zdGFja3Mvc2VsZi1tYW5hZ2Vk" + + "IHRlbXBsYXRlIFwKICBIRUxNRklMRV9FTlY9PGVudj4gXAogIEtVQkVDT05GSUdfRklMRT08Y29u" + + "dHJvbC1wbGFuZS1rdWJlY29uZmlnPgoKbWFrZSAtQyBkZXBsb3kvc3RhY2tzL3NlbGYtbWFuYWdl" + + "ZCBpbnN0YWxsIFwKICBIRUxNRklMRV9FTlY9PGVudj4gXAogIEtVQkVDT05GSUdfRklMRT08Y29u" + + "dHJvbC1wbGFuZS1rdWJlY29uZmlnPgpgYGAKCkJlZm9yZSByZWdpc3RlcmluZyB0aHJvdWdoIGEg" + + "YmFyZSBHYXRld2F5IGFkZHJlc3MsIGNyZWF0ZSBvciB1cGRhdGUgdGhlIENMSQpjb25maWcgcGFz" + + "c2VkIGFzIGBOVkNGX0NMSV9DT05GSUdgOgoKYGBgeWFtbApiYXNlX2h0dHBfdXJsOiAiaHR0cDov" + + "LzxnYXRld2F5LWFkZHJlc3M+IgppbnZva2VfdXJsOiAiaHR0cDovLzxnYXRld2F5LWFkZHJlc3M+" + + "IgpiYXNlX2dycGNfdXJsOiAiPGdhdGV3YXktYWRkcmVzcz46MTAwODEiCmFwaV9rZXlzX3NlcnZp" + + "Y2VfdXJsOiAiaHR0cDovLzxnYXRld2F5LWFkZHJlc3M+IgppY21zX3VybDogImh0dHA6Ly88Z2F0" + + "ZXdheS1hZGRyZXNzPiIKYXBpX2hvc3Q6ICJhcGkuPGdhdGV3YXktZG9tYWluPiIKYXBpX2tleXNf" + + "aG9zdDogImFwaS1rZXlzLjxnYXRld2F5LWRvbWFpbj4iCmludm9rZV9ob3N0OiAiaW52b2NhdGlv" + + "bi48Z2F0ZXdheS1kb21haW4+IgppY21zX2hvc3Q6ICJzaXMuPGdhdGV3YXktZG9tYWluPiIKYGBg" + + "CgpIb3N0IGZpZWxkcyBjb250YWluIGhvc3RuYW1lcyBvbmx5LCB3aXRob3V0IGEgVVJMIHNjaGVt" + + "ZS4gYElDTVNfVVJMYCBtYXBzIG9ubHkKdG8gdGhlIHJlZ2lzdHJhdGlvbiBjb21tYW5kJ3MgYC0t" + + "aWNtcy11cmxgOyBgaWNtc19ob3N0YCBpbiB0aGUgY29uZmlnIHN1cHBsaWVzCnRoZSBHYXRld2F5" + + "IEhvc3QgaGVhZGVyLiBUaGVyZSBpcyBubyBgLS1pY21zLWhvc3RgIE1ha2Ugb3IgQ0xJIGZsYWcu" + + "CgpSZWdpc3RlciBmcm9tIHRoZSBjb21wdXRlIGNvbnRleHQsIHRoZW4gaW5zdGFsbCB0aGUgY29t" + + "cHV0ZSBwbGFuZToKCmBgYGJhc2gKbWFrZSAtQyBkZXBsb3kvc3RhY2tzL252Y2YtY29tcHV0ZS1w" + + "bGFuZSByZWdpc3Rlci1jbHVzdGVyIFwKICBDTFVTVEVSX05BTUU9PGNsdXN0ZXItbmFtZT4gXAog" + + "IE5DQV9JRD08bmNhLWlkPiBcCiAgQ0xVU1RFUl9SRUdJT049PHJlZ2lvbj4gXAogIElDTVNfVVJM" + + "PWh0dHA6Ly88Z2F0ZXdheS1hZGRyZXNzPiBcCiAgS1VCRUNPTkZJR19GSUxFPTxjb21wdXRlLXBs" + + "YW5lLWt1YmVjb25maWc+IFwKICBOVkNGX0NMST08cGF0aC10by1udmNmLWNsaT4gXAogIE5WQ0Zf" + + "Q0xJX0NPTkZJRz08cGF0aC10by1udmNmLWNsaS1jb25maWc+CgptYWtlIC1DIGRlcGxveS9zdGFj" + + "a3MvbnZjZi1jb21wdXRlLXBsYW5lIGluc3RhbGwgXAogIENMVVNURVJfTkFNRT08Y2x1c3Rlci1u" + + "YW1lPiBcCiAgSEVMTUZJTEVfRU5WPTxlbnY+IFwKICBLVUJFQ09ORklHX0ZJTEU9PGNvbXB1dGUt" + + "cGxhbmUta3ViZWNvbmZpZz4KYGBgCgpSZWdpc3RyYXRpb24gZGlzY292ZXJzIHRoZSBPSURDIGlz" + + "c3VlciBhbmQgSldLUyBmcm9tIHRoZSBjb21wdXRlIGt1YmUgY29udGV4dC4KSW4gYSBtdWx0aS1j" + + "bHVzdGVyIGRlcGxveW1lbnQsIGBLVUJFQ09ORklHX0ZJTEVgIGlzIHJlcXVpcmVkIG9uIGJvdGgK" + + "Y29tcHV0ZS1wbGFuZSBjb21tYW5kcy4gSW4gYSBzYW1lLWNsdXN0ZXIgZGVwbG95bWVudCBpdCBt" + + "YXkgYmUgb21pdHRlZCBvbmx5CndoZW4gdGhlIGFtYmllbnQgY29udGV4dCBpcyBhbHJlYWR5IHRo" + + "ZSB0YXJnZXQgY2x1c3Rlci4KCiMjIENMSSBQcm9maWxlIEZsb3cKClJ1biB0aGUgQ0xJIGNvbnRy" + + "b2wtcGxhbmUgaW5zdGFsbCBmaXJzdC4gSXQgY3JlYXRlcyB0aGUgcHJvZmlsZSBjb25zdW1lZCBi" + + "eQpjb21wdXRlLXBsYW5lIHJlZ2lzdHJhdGlvbjoKCmBgYGJhc2gKbnZjZi1jbGkgLS1jb25maWcg" + + "PGNvbmZpZz4gc2VsZi1ob3N0ZWQgXAogIC0tY29udHJvbC1wbGFuZS1zdGFjayBkZXBsb3kvc3Rh" + + "Y2tzL3NlbGYtbWFuYWdlZCBcCiAgLS1jb21wdXRlLXBsYW5lLXN0YWNrIGRlcGxveS9zdGFja3Mv" + + "bnZjZi1jb21wdXRlLXBsYW5lIFwKICAtLWVudiA8ZW52PiBcCiAgLS1wbGFpbiBcCiAgLS1jb250" + + "cm9sLXBsYW5lLWNvbnRleHQgPGNvbnRyb2wtcGxhbmUtY29udGV4dD4gXAogIC0tY29tcHV0ZS1w" + + "bGFuZS1jb250ZXh0IDxjb21wdXRlLXBsYW5lLWNvbnRleHQ+IFwKICBpbnN0YWxsIC0tY29udHJv" + + "bC1wbGFuZSBcCiAgLS1jbHVzdGVyLW5hbWUgPGNvbnRyb2wtcGxhbmUtY2x1c3Rlci1uYW1lPiBc" + + "CiAgLS1yZWdpb24gPHJlZ2lvbj4gXAogIC0tbmNhLWlkIDxuY2EtaWQ+Cgp0ZXN0IC1zIGRlcGxv" + + "eS9zdGFja3Mvc2VsZi1tYW5hZ2VkL291dC9jb250cm9sLXBsYW5lLXByb2ZpbGUueWFtbApgYGAK" + + "ClVzZSB0aGUgZnVsbCBwZXJzaXN0ZW50IHByZWZpeCBmb3IgYm90aCBjb21wdXRlLXBsYW5lIGNv" + + "bW1hbmRzOgoKYGBgYmFzaApudmNmLWNsaSAtLWNvbmZpZyA8Y29uZmlnPiBzZWxmLWhvc3RlZCBc" + "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" + + "IC0tZW52IDxlbnY+IFwKICAtLXBsYWluIFwKICBjb21wdXRlLXBsYW5lIHJlZ2lzdGVyIFwKICAt" + + "LWNvbnRyb2wtcGxhbmUtcHJvZmlsZSBkZXBsb3kvc3RhY2tzL3NlbGYtbWFuYWdlZC9vdXQvY29u" + + "dHJvbC1wbGFuZS1wcm9maWxlLnlhbWwgXAogIC0tY2x1c3Rlci1uYW1lIDxjb21wdXRlLXBsYW5l" + + "LWNsdXN0ZXItbmFtZT4gXAogIC0ta3ViZS1jb250ZXh0IDxjb21wdXRlLXBsYW5lLWNvbnRleHQ+" + + "IFwKICAtLXJlZ2lvbiA8cmVnaW9uPiBcCiAgLS1vdXRwdXQgZGVwbG95L3N0YWNrcy9udmNmLWNv" + + "bXB1dGUtcGxhbmUvb3V0Lzxjb21wdXRlLXBsYW5lLWNsdXN0ZXItbmFtZT4tcmVnaXN0ZXItdmFs" + + "dWVzLnlhbWwKCm52Y2YtY2xpIC0tY29uZmlnIDxjb25maWc+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" + - "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" + - "eHBsaWNpdGx5OgoKYGBgeWFtbAphcGk6CiAgZW52OgogICAgTlZDRl9TSURFQ0FSU19MTE1fUk9V" + - "VEVSX0NMSUVOVF9JTUFHRTogPHJlZ2lzdHJ5Pi88cmVwb3NpdG9yeT4vcHlsb246MC4yLjEKYGBg" + - "CgpSZW5kZXIgYW5kIGFwcGx5IHRoZSB1cGRhdGVkIGNvbnRyb2wtcGxhbmUgZW52aXJvbm1lbnQs" + - "IHRoZW4gcmVmcmVzaCBldmVyeQpyZWdpc3RlcmVkIGNvbXB1dGUgcGxhbmUgdXNpbmcgdGhlIHNh" + - "bWUgaGFuZG9mZiB1c2VkIGZvciBpdHMgaW5zdGFsbGF0aW9uIHNvCk5WQ0EgcmVjZWl2ZXMgYGFn" + - "ZW50Q29uZmlnLm1lcmdlQ29uZmlnYDoKCmBgYGJhc2gKSEVMTUZJTEVfRU5WPTxlbnY+IGhlbG1m" + - "aWxlIHRlbXBsYXRlCkhFTE1GSUxFX0VOVj08ZW52PiBoZWxtZmlsZSBzeW5jCmBgYAoKVXNlIHRo" + - "ZSBjb21wbGV0ZSBjb21wdXRlLXBsYW5lIGluc3RhbGwgY29tbWFuZCBmcm9tCltTcGxpdCBDb21w" + - "dXRlLVBsYW5lIEluc3RhbGxhdGlvbl0oY29tcHV0ZS1wbGFuZS1pbnN0YWxsYXRpb24ubWQpLiBB" + - "CkNMSS1wcm9maWxlIGluc3RhbGxhdGlvbiBtdXN0IHJlbWFpbiBwcm9maWxlLWRyaXZlbjsgYSBI" + - "ZWxtZmlsZSBpbnN0YWxsYXRpb24KbXVzdCByZW1haW4gdmFsdWVzLWRyaXZlbi4KCkV4aXN0aW5n" + - "IExMTSBmdW5jdGlvbiBwb2RzIGtlZXAgdGhlaXIgZXhpc3Rpbmcgc2lkZWNhciBhcmd1bWVudHMu" + - "IFJlY3JlYXRlIG9yCnJlZGVwbG95IHRob3NlIGZ1bmN0aW9ucyBhZnRlciB0aGUgY29tcHV0ZS1w" + - "bGFuZSByZWZyZXNoLiBWZXJpZnkgdGhlIGNvbnRyb2wKcGxhbmUsIHJvdXRlLCBhbmQgd29ya2Vy" + - "IHNpZGVjYXI6CgpgYGBiYXNoCmt1YmVjdGwgZ2V0IGRlcGxveSAtbiBudmNmIGxsbS1hcGktZ2F0" + - "ZXdheQprdWJlY3RsIGdldCBzdGF0ZWZ1bHNldCAtbiBudmNmIGxsbS1yZXF1ZXN0LXJvdXRlcgpr" + - "dWJlY3RsIGdldCBwb2RzIC1uIG52Y2YgfCBncmVwIC1FICdsbG0tYXBpLWdhdGV3YXl8bGxtLXJl" + - "cXVlc3Qtcm91dGVyJwprdWJlY3RsIGdldCBodHRwcm91dGUgLUEgfCBncmVwIGxsbQprdWJlY3Rs" + - "IC1uIG52Y2YtYmFja2VuZCBnZXQgcG9kIDxmdW5jdGlvbi1wb2Q+IFwKICAtbyBqc29ucGF0aD0n" + - "e3JhbmdlIC5zcGVjLmNvbnRhaW5lcnNbPyhALm5hbWU9PSJsbG0td29ya2VyIildLmFyZ3NbKl19" + - "ey59eyJcXG4ifXtlbmR9JwpgYGAKCkZvciBsb2NhbCBwbGFpbnRleHQgY2x1c3RlcnMsIHRoZSBg" + - "bGxtLXdvcmtlcmAgYXJncyBtdXN0IGluY2x1ZGUKYC0tcXVpYy1pbnNlY3VyZWAuCgpGb3IgbG9h" + - "ZC1iYWxhbmNlciBzY2hlbWEgYW5kIGFsZ29yaXRobSBiZWhhdmlvciwgc2VlIHRoZQpbU3Rhcmdh" + - "dGUgY29uZmlndXJhdGlvbiBndWlkZV0oaHR0cHM6Ly9naXRodWIuY29tL05WSURJQS9udmNmL2Js" + - "b2IvbWFpbi9zcmMvbGlicmFyaWVzL3J1c3Qvc3RhcmdhdGUvZG9jcy9sb2FkLWJhbGFuY2VyLWNv" + - "bmZpZ3VyYXRpb24ubWQpLgoKIyMgSGVsbWZpbGUgU2VsZWN0b3JzCgpUYXJnZXQgc3BlY2lmaWMg" + - "cmVsZWFzZXMgb3IgZ3JvdXBzOgoKYGBgYmFzaAojIEJ5IHJlbGVhc2UgZ3JvdXAKSEVMTUZJTEVf" + - "RU5WPTxlbnY+IGhlbG1maWxlIC0tc2VsZWN0b3IgcmVsZWFzZS1ncm91cD1kZXBlbmRlbmNpZXMg" + - "c3luYwpIRUxNRklMRV9FTlY9PGVudj4gaGVsbWZpbGUgLS1zZWxlY3RvciByZWxlYXNlLWdyb3Vw" + - "PXNlcnZpY2VzIHN5bmMKSEVMTUZJTEVfRU5WPTxlbnY+IGhlbG1maWxlIC0tc2VsZWN0b3IgcmVs" + - "ZWFzZS1ncm91cD1pbmdyZXNzIHN5bmMKSEVMTUZJTEVfRU5WPTxlbnY+IGhlbG1maWxlIC0tc2Vs" + - "ZWN0b3IgcmVsZWFzZS1ncm91cD1vYnNlcnZhYmlsaXR5IHN5bmMKCiMgQnkgcmVsZWFzZSBuYW1l" + - "CkhFTE1GSUxFX0VOVj08ZW52PiBoZWxtZmlsZSAtLXNlbGVjdG9yIG5hbWU9Y2Fzc2FuZHJhIHN5" + - "bmMKSEVMTUZJTEVfRU5WPTxlbnY+IGhlbG1maWxlIC0tc2VsZWN0b3IgbmFtZT1hZG1pbi1pc3N1" + - "ZXItcHJveHkgc3luYwpIRUxNRklMRV9FTlY9PGVudj4gaGVsbWZpbGUgLS1zZWxlY3RvciBuYW1l" + - "PWxsbS1yZXF1ZXN0LXJvdXRlciBzeW5jCkhFTE1GSUxFX0VOVj08ZW52PiBoZWxtZmlsZSAtLXNl" + - "bGVjdG9yIG5hbWU9bGxtLWFwaS1nYXRld2F5IHN5bmMKCiMgVGVtcGxhdGUgb25seSAoZHJ5IHJ1" + - "bikKSEVMTUZJTEVfRU5WPTxlbnY+IGhlbG1maWxlIC0tc2VsZWN0b3IgbmFtZT1jYXNzYW5kcmEg" + - "dGVtcGxhdGUKCiMgRGVzdHJveSBhIHNpbmdsZSByZWxlYXNlCkhFTE1GSUxFX0VOVj08ZW52PiBo" + - "ZWxtZmlsZSAtLXNlbGVjdG9yIG5hbWU9Y2Fzc2FuZHJhIGRlc3Ryb3kKYGBgCgpOb3RlOiBgYWRt" + - "aW4taXNzdWVyLXByb3h5YCBoYXMgbm8gYHJlbGVhc2UtZ3JvdXBgIGxhYmVsLiBVc2UgYC0tc2Vs" + - "ZWN0b3IgbmFtZT1hZG1pbi1pc3N1ZXItcHJveHlgLgpQSwcIwFYg548nAACPJwAAUEsDBBQACAAA" + - "AAAAIQAAAAAAAAAAAAAAAAA/AAkAZGF0YS9udmNmLXNlbGYtbWFuYWdlZC1pbnN0YWxsYXRpb24v" + - "cmVmZXJlbmNlcy9udmNmLXVpLWFkZG9uLm1kVVQFAAEAps4SIyBOVkNGIFVJIEFkZG9uCgpOVkNG" + - "IFVJIGlzIGFuIG9wdGlvbmFsLCBjdXN0b21lci1mYWNpbmcgTlZDRiBhZG1pbi1wYW5lbCBVSS4g" + - "SXQgaXMgZGlzYWJsZWQgYnkKZGVmYXVsdCBhbmQgYXZhaWxhYmxlIG9ubHkgaW4gc3RhY2sgcGFj" + - "a2FnZXMgdGhhdCBpbmNsdWRlIHRoZSBOVkNGIFVJIGFkZG9uLgoKIyMgV2hlbiB0byBlbmFibGUK" + - "CkVuYWJsZSBOVkNGIFVJIG9ubHkgd2hlbiB5b3UgbmVlZCB0aGUgYWRtaW4tcGFuZWwgVUkgYW5k" + - "IHlvdXIgZXh0cmFjdGVkIHN0YWNrCnBhY2thZ2UgaW5jbHVkZXMgdGhlIGFkZG9uLiBJZiB0aGUg" + - "cGFja2FnZSBkb2VzIG5vdCBjb250YWluIGEgYG52Y2YtdWlgIHJlbGVhc2UKYW5kIGBudmNmVWlg" + - "IHJvdXRlIHZhbHVlcywgc2tpcCB0aGUgYWRkb24gdW50aWwgeW91IHVzZSBhIHBhY2thZ2UgdGhh" + - "dCBpbmNsdWRlcwp0aGVtLgoKIyMgRW5hYmxlIHRoZSBhZGRvbgoKRW5hYmxlIGl0IGluIGBlbnZp" + - "cm9ubWVudHMvPGVudi1uYW1lPi55YW1sYDoKCmBgYHlhbWwKYWRkb25zOgogIG52Y2ZVaToKICAg" + - "IGVuYWJsZWQ6IHRydWUKYGBgCgojIyBDcmVhdGUgbmFtZXNwYWNlIGFuZCBpbWFnZSBwdWxsIHNl" + - "Y3JldAoKQ3JlYXRlIHRoZSBuYW1lc3BhY2UsIGFuZCBhbiBpbWFnZSBwdWxsIHNlY3JldCBvbmx5" + - "IGlmIHB1bGxpbmcgZnJvbSBhIHByaXZhdGUKcmVnaXN0cnk6CgpgYGBiYXNoCmt1YmVjdGwgY3Jl" + - "YXRlIG5hbWVzcGFjZSBudmNmLXVpIC0tZHJ5LXJ1bj1jbGllbnQgLW8geWFtbCB8IGt1YmVjdGwg" + - "YXBwbHkgLWYgLQoKIyBPbmx5IGlmIHB1bGxpbmcgZnJvbSBhIHByaXZhdGUgcmVnaXN0cnkgKGUu" + - "Zy4sIE5HQyBudmNyLmlvKQpleHBvcnQgTkdDX0FQSV9LRVk9Ijx5b3VyLWtleT4iCmt1YmVjdGwg" + - "Y3JlYXRlIHNlY3JldCBkb2NrZXItcmVnaXN0cnkgbnZjci1jcmVkcyBcCiAgLS1kb2NrZXItc2Vy" + - "dmVyPW52Y3IuaW8gXAogIC0tZG9ja2VyLXVzZXJuYW1lPSckb2F1dGh0b2tlbicgXAogIC0tZG9j" + - "a2VyLXBhc3N3b3JkPSIkTkdDX0FQSV9LRVkiIFwKICAtLW5hbWVzcGFjZT1udmNmLXVpIFwKICAt" + - "LWRyeS1ydW49Y2xpZW50IC1vIHlhbWwgfCBrdWJlY3RsIGFwcGx5IC1mIC0KYGBgCgpUaGUgZGVm" + - "YXVsdCByb3V0ZSBob3N0IGlzIGBudmNmLXVpLjxkb21haW4+YCBhbmQgdGhlIGJhY2tlbmQgaXMK" + - "YG52Y2YtdWkubnZjZi11aTo4MzAwYC4KCiMjIEFwcGx5IHRoZSBzZXJ2aWNlIGFuZCByb3V0ZQoK" + - "QWZ0ZXIgY29uZmlybWluZyB0aGUgcGFja2FnZSBpbmNsdWRlcyB0aGUgYG52Y2YtdWlgIHJlbGVh" + - "c2UsIHByZXZpZXcgYW5kIGFwcGx5CnRoZSBzZXJ2aWNlIGFuZCByb3V0ZToKCmBgYGJhc2gKSEVM" + - "TUZJTEVfRU5WPTxlbnYtbmFtZT4gaGVsbWZpbGUgLS1zZWxlY3RvciBuYW1lPW52Y2YtdWkgdGVt" + - "cGxhdGUKSEVMTUZJTEVfRU5WPTxlbnYtbmFtZT4gaGVsbWZpbGUgLS1zZWxlY3RvciBuYW1lPW52" + - "Y2YtdWkgc3luYwpIRUxNRklMRV9FTlY9PGVudi1uYW1lPiBoZWxtZmlsZSAtLXNlbGVjdG9yIHJl" + - "bGVhc2UtZ3JvdXA9aW5ncmVzcyBzeW5jCmBgYAoKIyMgVmVyaWZ5CgpWZXJpZnkgdGhlIHJvdXRl" + - "IG9ubHkgd2hlbiB0aGUgYWRkb24gaXMgcHJlc2VudCBhbmQgZW5hYmxlZDoKCmBgYGJhc2gKa3Vi" + - "ZWN0bCBnZXQgZGVwbG95LHN2YyAtbiBudmNmLXVpCmt1YmVjdGwgZ2V0IGh0dHByb3V0ZSAtQSB8" + - "IGdyZXAgLWkgbnZjZi11aQpjdXJsIC1pIC1IICJIb3N0OiBudmNmLXVpLjxkb21haW4+IiAiaHR0" + - "cDovLzxnYXRld2F5LWFkZHJlc3M+L3N0YXR1cyIKYGBgCgojIyBTZWN1cml0eQoKVGhlIE5WQ0Yg" + - "VUkgYWRtaW4gcGFuZWwgaXMgY3VycmVudGx5IHVuYXV0aGVudGljYXRlZC4gRG8gbm90IGV4cG9z" + - "ZSBpdCB0byB0aGUKcHVibGljIGludGVybmV0LiBSZXN0cmljdCBhY2Nlc3MgdG8gYSB0cnVzdGVk" + - "IG5ldHdvcmssIFZQTiwgb3IgYW4gYXV0aGVudGljYXRpbmcKcHJveHkgaW4gZnJvbnQgb2YgdGhl" + - "IGBudmNmLXVpYCByb3V0ZS4KUEsHCDj5J6+5BwAAuQcAAFBLAwQUAAgAAAAAACEAAAAAAAAAAAAA" + - "AAAAPgAJAGRhdGEvbnZjZi1zZWxmLW1hbmFnZWQtaW5zdGFsbGF0aW9uL3JlZmVyZW5jZXMvcHVs" + - "bC1zZWNyZXRzLm1kVVQFAAEAps4SIyBJbWFnZSBQdWxsIFNlY3JldHMgUmVmZXJlbmNlCgojIyBP" + - "dmVydmlldwoKV2hlbiBwdWxsaW5nIE5WQ0YgaW1hZ2VzIGZyb20gYSBwcml2YXRlIHJlZ2lzdHJ5" + - "IChmb3IgZXhhbXBsZSwgTkdDCmBudmNyLmlvYCksIEt1YmVybmV0ZXMgbmVlZHMgYGltYWdlUHVs" + - "bFNlY3JldHNgIG9uIGV2ZXJ5IHBvZC4gQ29udHJvbC1wbGFuZSBhbmQKY29tcHV0ZS1wbGFuZSBj" + - "cmVkZW50aWFscyBhcmUgY29uZmlndXJlZCBpbiB0aGVpciBvd24gY2x1c3RlciBjb250ZXh0cy4g" + - "RG8gbm90CnVzZSBvbmUgbWl4ZWQgbmFtZXNwYWNlIGxpc3QuCgpUaGUgcmVjb21tZW5kZWQgY29u" + - "dHJvbC1wbGFuZSBhcHByb2FjaCB1c2VzIEt5dmVybm8gdG8gaW5qZWN0IHRoZSBzZWNyZXQgaW50" + - "bwpjb250cm9sLXBsYW5lIHBvZHMgYXQgYWRtaXNzaW9uIHRpbWUuIFRoZSBjb21wdXRlLXBsYW5l" + - "IGNoYXJ0IGFuZCBvcGVyYXRvciB1c2UKdGhlIHNlY3JldCBpbiBgbnZjYS1vcGVyYXRvcmAgYW5k" + - "IG1pcnJvciBpdCB0byBgbnZjYS1zeXN0ZW1gLgoKIyMgS3l2ZXJubyBBcHByb2FjaCAoUmVjb21t" + - "ZW5kZWQpCgojIyMgMS4gSW5zdGFsbCBLeXZlcm5vCgpgYGBiYXNoCmhlbG0gcmVwbyBhZGQga3l2" + - "ZXJubyBodHRwczovL2t5dmVybm8uZ2l0aHViLmlvL2t5dmVybm8vCmhlbG0gcmVwbyB1cGRhdGUK" + - "aGVsbSBpbnN0YWxsIGt5dmVybm8ga3l2ZXJuby9reXZlcm5vIC1uIGt5dmVybm8gLS1jcmVhdGUt" + - "bmFtZXNwYWNlIFwKICAtLWt1YmUtY29udGV4dCA8Y29udHJvbC1wbGFuZS1jb250ZXh0PgpgYGAK" + - "CiMjIyAyLiBDcmVhdGUgY29udHJvbC1wbGFuZSBwdWxsIHNlY3JldHMKCmBgYGJhc2gKZXhwb3J0" + - "IE5HQ19BUElfS0VZPSI8eW91ci1uZ2MtYXBpLWtleT4iCgpmb3IgbnMgaW4gY2Fzc2FuZHJhLXN5" + - "c3RlbSBuYXRzLXN5c3RlbSBudmNmIGFwaS1rZXlzIGVzcyBzaXMgdmF1bHQtc3lzdGVtIGNlcnQt" + - "bWFuYWdlcjsgZG8KICBrdWJlY3RsIC0tY29udGV4dCA8Y29udHJvbC1wbGFuZS1jb250ZXh0PiBj" + - "cmVhdGUgbmFtZXNwYWNlICIkbnMiIFwKICAgIC0tZHJ5LXJ1bj1jbGllbnQgLW8geWFtbCB8IGt1" + - "YmVjdGwgLS1jb250ZXh0IDxjb250cm9sLXBsYW5lLWNvbnRleHQ+IGFwcGx5IC1mIC0KZG9uZQoK" + + "PGVudj4gXAogIC0tcGxhaW4gXAogIGNvbXB1dGUtcGxhbmUgaW5zdGFsbCBcCiAgLS12YWx1ZXMg" + + "ZGVwbG95L3N0YWNrcy9udmNmLWNvbXB1dGUtcGxhbmUvb3V0Lzxjb21wdXRlLXBsYW5lLWNsdXN0" + + "ZXItbmFtZT4tcmVnaXN0ZXItdmFsdWVzLnlhbWwgXAogIC0ta3ViZS1jb250ZXh0IDxjb21wdXRl" + + "LXBsYW5lLWNvbnRleHQ+IFwKICAtLWNsdXN0ZXItbmFtZSA8Y29tcHV0ZS1wbGFuZS1jbHVzdGVy" + + "LW5hbWU+CmBgYAoKUmVnaXN0cmF0aW9uIHNlbGVjdHMgdGhlIHByb2ZpbGUncyBpbi1jbHVzdGVy" + + "IG9yIGNvbXB1dGUtcmVhY2hhYmxlIGVuZHBvaW50cwpmcm9tIHRoZSBjb21wdXRlIGNvbnRleHQg" + + "YW5kIHByb2JlcyBpdHMgSldLUy4gRG8gbm90IHJlcGxhY2UgcHJvZmlsZSBlbmRwb2ludHMKd2l0" + + "aCBoYW5kLWF1dGhvcmVkIEhlbG1maWxlIGVuZHBvaW50IHZhbHVlcy4KCiMjIFB1bGwgU2VjcmV0" + + "cwoKQ3JlYXRlIHRoZSBjb250cm9sLXBsYW5lIHNlY3JldCBpbiB0aGVzZSBuYW1lc3BhY2VzIG9u" + + "IHRoZSBjb250cm9sLXBsYW5lCmNvbnRleHQ6CgpgYGB0ZXh0CmNhc3NhbmRyYS1zeXN0ZW0gbmF0" + + "cy1zeXN0ZW0gbnZjZiBhcGkta2V5cyBlc3Mgc2lzIHZhdWx0LXN5c3RlbSBjZXJ0LW1hbmFnZXIK" + + "YGBgCgpPbiB0aGUgY29tcHV0ZSBjb250ZXh0LCBjcmVhdGUgdGhlIHNlY3JldCBvbmx5IGluIGBu" + + "dmNhLW9wZXJhdG9yYCBhbmQgcmVmZXJlbmNlCml0IHRocm91Z2ggYGdsb2JhbC5pbWFnZVB1bGxT" + + "ZWNyZXRzYCBpbiB0aGUgY29tcHV0ZS1wbGFuZSBlbnZpcm9ubWVudC4gVGhlIGNoYXJ0CmFuZCBv" + + "cGVyYXRvciB1c2UgaXQgaW4gYG52Y2Etb3BlcmF0b3JgIGFuZCBtaXJyb3IgaXQgdG8gYG52Y2Et" + + "c3lzdGVtYC4gRG8gbm90IGFkZAplaXRoZXIgbmFtZXNwYWNlIHRvIHRoZSBjb250cm9sLXBsYW5l" + + "IGxpc3QuIEZvciBjb21tYW5kcyBhbmQgcG9saWN5IGV4YW1wbGVzLApzZWUgW3B1bGwtc2VjcmV0" + + "cy5tZF0ocHVsbC1zZWNyZXRzLm1kKS4KCiMjIFZlcmlmaWNhdGlvbgoKVXNlIHRoZSBleHBsaWNp" + + "dCBHYXRld2F5IG5hbWUgYW5kIG5hbWVzcGFjZToKCmBgYGJhc2gKa3ViZWN0bCAtLWNvbnRleHQg" + + "PGNvbnRyb2wtcGxhbmUtY29udGV4dD4gZ2V0IGdhdGV3YXkgbnZjZi1nYXRld2F5IFwKICAtbiBl" + + "bnZveS1nYXRld2F5IC1vIHdpZGUKa3ViZWN0bCAtLWNvbnRleHQgPGNvbnRyb2wtcGxhbmUtY29u" + + "dGV4dD4gZ2V0IHRjcHJvdXRlIC1uIGVudm95LWdhdGV3YXkKa3ViZWN0bCAtLWNvbnRleHQgPGNv" + + "bXB1dGUtcGxhbmUtY29udGV4dD4gcm9sbG91dCBzdGF0dXMgXAogIGRlcGxveW1lbnQvbnZjYS1v" + + "cGVyYXRvciAtbiBudmNhLW9wZXJhdG9yIC0tdGltZW91dD0xMG0Ka3ViZWN0bCAtLWNvbnRleHQg" + + "PGNvbXB1dGUtcGxhbmUtY29udGV4dD4gd2FpdCBcCiAgbnZjZmJhY2tlbmQvPGNvbXB1dGUtcGxh" + + "bmUtY2x1c3Rlci1uYW1lPiAtbiBudmNhLW9wZXJhdG9yIFwKICAtLWZvcj1qc29ucGF0aD0ney5z" + + "dGF0dXMuYWdlbnRTdGF0dXN9Jz1oZWFsdGh5IC0tdGltZW91dD0xMG0Ka3ViZWN0bCAtLWNvbnRl" + + "eHQgPGNvbXB1dGUtcGxhbmUtY29udGV4dD4gZ2V0IHNlY3JldCA8cHVsbC1zZWNyZXQ+IC1uIG52" + + "Y2Etc3lzdGVtCmBgYAoKIyMgVGVhcmRvd24KCkRlc3Ryb3kgYW5kIGRlcmVnaXN0ZXIgZXZlcnkg" + + "Y29tcHV0ZSBwbGFuZSBiZWZvcmUgdGhlIGNvbnRyb2wgcGxhbmUuIEJvdGgKaGFuZG9mZnMgY2Fu" + + "IGRlc3Ryb3kgdGhlIGNvbnRyb2wgcGxhbmUsIHNvIGFwcGx5IHRoaXMgcHJlZmxpZ2h0IGJlZm9y" + + "ZSBlaXRoZXIKb25lLiBQcmVzZXJ2ZSB0aGUgYGNlcnQtbWFuYWdlcmAgbmFtZXNwYWNlIGJ5IGRl" + + "ZmF1bHQuIE5hbWVzcGFjZSBwcmVzZXJ2YXRpb24KZG9lcyBub3QgcHJlc2VydmUgdGhlIEhlbG0g" + + "cmVsZWFzZS4gSWRlbnRpZnkgd2hldGhlciBjZXJ0LW1hbmFnZXIgaXMgZXh0ZXJuYWwuCkZvciBh" + + "biBleHRlcm5hbCBpbnN0YWxsYXRpb24sIHJlcXVpcmUgZWZmZWN0aXZlIGBjZXJ0TWFuYWdlci5l" + + "bmFibGVkOiBmYWxzZWAKYW5kIGFib3J0IGlmIGl0IGlzIHRydWUuIEZvciBhbiBpbnRlbmRlZCBz" + + "dGFjay1tYW5hZ2VkIHJlbGVhc2Ugd2l0aCBlZmZlY3RpdmUKYGNlcnRNYW5hZ2VyLmVuYWJsZWQ6" + + "IHRydWVgLCB2ZXJpZnkgbWF0Y2hpbmcgc3RhY2sgSGVsbSByZWxlYXNlIG1ldGFkYXRhIGFuZAph" + + "Ym9ydCBvbiBtaXNzaW5nIG9yIG1pc21hdGNoZWQgZXZpZGVuY2UuIE9ubHkgcGxhbiBuYW1lc3Bh" + + "Y2UgcmVtb3ZhbCBhZnRlcgp2ZXJpZnlpbmcgbmFtZXNwYWNlIHByb3ZlbmFuY2UgYW5kIGdldHRp" + + "bmcgZXhwbGljaXQgY29uZmlybWF0aW9uOyBvdGhlcndpc2UKZG8gbm90IGRlbGV0ZSBpdC4KCkZv" + + "ciB0aGUgSGVsbWZpbGUgdmFsdWVzIGZsb3csIHJldGFpbiBlYWNoIHJlZ2lzdHJhdGlvbiB2YWx1" + + "ZXMgZmlsZSB1bnRpbApjbGVhbnVwIGlzIHZlcmlmaWVkOgoKYGBgYmFzaAptYWtlIC1DIGRlcGxv" + + "eS9zdGFja3MvbnZjZi1jb21wdXRlLXBsYW5lIGRlc3Ryb3kgXAogIENMVVNURVJfTkFNRT08Y2x1" + + "c3Rlci1uYW1lPiBcCiAgSEVMTUZJTEVfRU5WPTxlbnY+IFwKICBLVUJFQ09ORklHX0ZJTEU9PGNv" + + "bXB1dGUtcGxhbmUta3ViZWNvbmZpZz4KCjxudmNmLWNsaT4gLS1jb25maWcgPGNvbmZpZz4gY2x1" + + "c3RlciBkZWxldGUgXAogIC0tY2x1c3Rlci1pZCA8Y2x1c3Rlci1pZC1mcm9tLXJlZ2lzdHJhdGlv" + + "bi12YWx1ZXM+IFwKICAtLW5jYS1pZCA8bmNhLWlkPiBcCiAgLS1pZ25vcmUtbWlzc2luZwpgYGAK" + + "ClJlYWQgYGNsdXN0ZXJJRGAgYW5kIGBuY2FJRGAgZnJvbQpgZGVwbG95L3N0YWNrcy9udmNmLWNv" + + "bXB1dGUtcGxhbmUvcmVnaXN0cmF0aW9uLzxjbHVzdGVyLW5hbWU+LXJlZ2lzdGVyLXZhbHVlcy55" + + "YW1sYC4KU2hvdyB0aGUgZXhhY3QgY2x1c3RlciBJRCBhbmQgZ2V0IGNvbmZpcm1hdGlvbiBiZWZv" + + "cmUgYGNsdXN0ZXIgZGVsZXRlYC4gUmVwZWF0CmNvbXB1dGUgZGVzdHJveSBhbmQgZGVyZWdpc3Ry" + + "YXRpb24gZm9yIGV2ZXJ5IGNvbXB1dGUgY2x1c3RlciwgdGhlbiBkZXN0cm95IHRoZQpjb250cm9s" + + "IHBsYW5lLgoKYGBgYmFzaApLVUJFQ09ORklHPTxjb250cm9sLXBsYW5lLWt1YmVjb25maWc+IFwK" + + "bWFrZSAtQyBkZXBsb3kvc3RhY2tzL3NlbGYtbWFuYWdlZCBkZXN0cm95IFwKICBIRUxNRklMRV9F" + + "TlY9PGVudj4gXAogIEtVQkVDT05GSUdfRklMRT08Y29udHJvbC1wbGFuZS1rdWJlY29uZmlnPgpg" + + "YGAKCkJvdGggYEtVQkVDT05GSUdgIGFuZCBgS1VCRUNPTkZJR19GSUxFYCBhcmUgcmVxdWlyZWQg" + + "b24gdGhlIGNvbnRyb2wtcGxhbmUKZGVzdHJveSBiZWNhdXNlIGl0cyBuYW1lc3BhY2UgY2xlYW51" + + "cCB1c2VzIGFtYmllbnQgYGt1YmVjdGxgLgoKRm9yIHRoZSBDTEkgcHJvZmlsZSBmbG93LCBrZWVw" + + "CmBkZXBsb3kvc3RhY2tzL252Y2YtY29tcHV0ZS1wbGFuZS9vdXQvPGNsdXN0ZXItbmFtZT4tcmVn" + + "aXN0ZXItdmFsdWVzLnlhbWxgCnVudGlsIHRlYXJkb3duIGNvbXBsZXRlcyBiZWNhdXNlIGBkb3du" + + "YCByZWFkcyBpdHMgY2x1c3RlciBJRC4gRmlyc3QgcXVlcnkgdGhlCmxpdmUgcmVnaXN0cmF0aW9u" + + "IHNldCB3aXRoIHRoZSBzYW1lIGNvbXBsZXRlIHBlcnNpc3RlbnQgcHJlZml4OgoKYGBgYmFzaApu" + + "dmNmLWNsaSAtLWNvbmZpZyA8Y29uZmlnPiBzZWxmLWhvc3RlZCBcCiAgLS1jb250cm9sLXBsYW5l" + + "LXN0YWNrIGRlcGxveS9zdGFja3Mvc2VsZi1tYW5hZ2VkIFwKICAtLWNvbXB1dGUtcGxhbmUtc3Rh" + + "Y2sgZGVwbG95L3N0YWNrcy9udmNmLWNvbXB1dGUtcGxhbmUgXAogIC0tZW52IDxlbnY+IFwKICAt" + + "LXBsYWluIFwKICAtLWNvbnRyb2wtcGxhbmUtY29udGV4dCA8Y29udHJvbC1wbGFuZS1jb250ZXh0" + + "PiBcCiAgLS1jb21wdXRlLXBsYW5lLWNvbnRleHQgPGNvbXB1dGUtcGxhbmUtY29udGV4dD4gXAog" + + "IC0taWNtcy11cmwgPGNvbXB1dGUtcmVhY2hhYmxlLWljbXMtdXJsPiBcCiAgc3RhdHVzIFwKICAt" + + "LWNsdXN0ZXItbmFtZSA8Y29tcHV0ZS1wbGFuZS1jbHVzdGVyLW5hbWU+IFwKICAtLW5jYS1pZCA8" + + "bmNhLWlkPgpgYGAKClNob3cgdGhlIHJlZ2lzdGVyZWQgY29tcHV0ZS1wbGFuZSBsaXN0LiBOYW1l" + + "ZC1jbHVzdGVyIGBkb3duIC0tcGxhbi1vbmx5YCBkb2VzCm5vdCBxdWVyeSBJQ01TLCBzbyBpdCBw" + + "cmV2aWV3cyBvbmx5IHRoYXQgY29tcHV0ZSBwbGFuZSBhbmQgY2Fubm90IHNob3cgdGhlCmNvbmRp" + + "dGlvbmFsIGNvbnRyb2wtcGxhbmUgcmVtb3ZhbC4gSWYgdGhlIHRhcmdldCBpcyB0aGUgbGFzdCBy" + + "ZWdpc3RlcmVkCmNsdXN0ZXIsIHJlYWwgYGRvd25gIGFsc28gZGVzdHJveXMgdGhlIGNvbnRyb2wg" + + "cGxhbmUuIEdldCBleHBsaWNpdCBjb25maXJtYXRpb24KZm9yIGJvdGggcmVtb3ZhbHMgYmVmb3Jl" + + "IGNvbnRpbnVpbmcuIFRoZW4gcHJldmlldyBhbmQgZXhlY3V0ZSB3aXRoIHRoZSBzYW1lCnByZWZp" + + "eDoKCmBgYGJhc2gKbnZjZi1jbGkgLS1jb25maWcgPGNvbmZpZz4gc2VsZi1ob3N0ZWQgXAogIC0t" + + "Y29udHJvbC1wbGFuZS1zdGFjayBkZXBsb3kvc3RhY2tzL3NlbGYtbWFuYWdlZCBcCiAgLS1jb21w" + + "dXRlLXBsYW5lLXN0YWNrIGRlcGxveS9zdGFja3MvbnZjZi1jb21wdXRlLXBsYW5lIFwKICAtLWVu" + + "diA8ZW52PiBcCiAgLS1wbGFpbiBcCiAgLS1jb250cm9sLXBsYW5lLWNvbnRleHQgPGNvbnRyb2wt" + + "cGxhbmUtY29udGV4dD4gXAogIC0tY29tcHV0ZS1wbGFuZS1jb250ZXh0IDxjb21wdXRlLXBsYW5l" + + "LWNvbnRleHQ+IFwKICAtLWljbXMtdXJsIDxjb21wdXRlLXJlYWNoYWJsZS1pY21zLXVybD4gXAog" + + "IGRvd24gLS1wbGFuLW9ubHkgXAogIC0tY2x1c3Rlci1uYW1lIDxjb21wdXRlLXBsYW5lLWNsdXN0" + + "ZXItbmFtZT4gXAogIC0tbmNhLWlkIDxuY2EtaWQ+CgpudmNmLWNsaSAtLWNvbmZpZyA8Y29uZmln" + + "PiBzZWxmLWhvc3RlZCBcCiAgLS1jb250cm9sLXBsYW5lLXN0YWNrIGRlcGxveS9zdGFja3Mvc2Vs" + + "Zi1tYW5hZ2VkIFwKICAtLWNvbXB1dGUtcGxhbmUtc3RhY2sgZGVwbG95L3N0YWNrcy9udmNmLWNv" + + "bXB1dGUtcGxhbmUgXAogIC0tZW52IDxlbnY+IFwKICAtLXBsYWluIFwKICAtLWNvbnRyb2wtcGxh" + + "bmUtY29udGV4dCA8Y29udHJvbC1wbGFuZS1jb250ZXh0PiBcCiAgLS1jb21wdXRlLXBsYW5lLWNv" + + "bnRleHQgPGNvbXB1dGUtcGxhbmUtY29udGV4dD4gXAogIC0taWNtcy11cmwgPGNvbXB1dGUtcmVh" + + "Y2hhYmxlLWljbXMtdXJsPiBcCiAgZG93biBcCiAgLS1jbHVzdGVyLW5hbWUgPGNvbXB1dGUtcGxh" + + "bmUtY2x1c3Rlci1uYW1lPiBcCiAgLS1uY2EtaWQgPG5jYS1pZD4KYGBgCgpSZXBlYXQgYGRvd25g" + + "IGZvciBlYWNoIGNvbXB1dGUgY2x1c3Rlci4gRWFjaCBydW4gZGVzdHJveXMgdGhhdCBjb21wdXRl" + + "IHBsYW5lIGFuZAp1bnJlZ2lzdGVycyBpdHMgSUNNUyByb3cuIEl0IHJlbW92ZXMgdGhlIGNvbnRy" + + "b2wgcGxhbmUgb25seSBhZnRlciBubyBjbHVzdGVyCnJlZ2lzdHJhdGlvbnMgcmVtYWluLgpQSwcI" + + "lmO8WRIwAAASMAAAUEsDBBQACAAAAAAAIQAAAAAAAAAAAAAAAAA7AAkAZGF0YS9udmNmLXNlbGYt" + + "bWFuYWdlZC1pbnN0YWxsYXRpb24vcmVmZXJlbmNlcy9kZWJ1Z2dpbmcubWRVVAUAAQCmzhIjIERl" + + "YnVnZ2luZyBSZWZlcmVuY2UKClJlY2lwZXMgZm9yIGRpYWdub3NpbmcgYW5kIGZpeGluZyBjb21t" + + "b24gTlZDRiBzZWxmLW1hbmFnZWQgc3RhY2sgZmFpbHVyZXMuCgojIyBRdWljayBTdGF0dXMgQ29t" + + "bWFuZHMKCmBgYGJhc2gKIyBBbGwgcG9kcyBhY3Jvc3MgYWxsIG5hbWVzcGFjZXMKa3ViZWN0bCBn" + + "ZXQgcG9kcyAtQSAtbyB3aWRlCgojIFBvZHMgaW4gYSBzcGVjaWZpYyBuYW1lc3BhY2UKa3ViZWN0" + + "bCBnZXQgcG9kcyAtbiA8bmFtZXNwYWNlPgoKIyBBbGwgaGVsbSByZWxlYXNlcwpoZWxtIGxpc3Qg" + + "LUEKCiMgUmVjZW50IGV2ZW50cyAobW9zdCB1c2VmdWwgZm9yIGRpYWdub3NpbmcgZmFpbHVyZXMp" + + "Cmt1YmVjdGwgZ2V0IGV2ZW50cyAtbiA8bmFtZXNwYWNlPiAtLXNvcnQtYnk9Jy5sYXN0VGltZXN0" + + "YW1wJwoKIyBEZXNjcmliZSBhIHNwZWNpZmljIHBvZCAoc2hvd3MgZXZlbnRzLCBjb25kaXRpb25z" + + "LCB2b2x1bWVzKQprdWJlY3RsIGRlc2NyaWJlIHBvZCAtbiA8bmFtZXNwYWNlPiA8cG9kLW5hbWU+" + + "CmBgYAoKIyMgRmFpbHVyZTogSW1hZ2VQdWxsQmFja09mZgoKIyMjIFN5bXB0b21zCgpgYGAKTkFN" + + "RSAgICAgICAgICAgUkVBRFkgICBTVEFUVVMgICAgICAgICAgICAgUkVTVEFSVFMgICBBR0UKY2Fz" + + "c2FuZHJhLTAgICAgMC8xICAgICBJbWFnZVB1bGxCYWNrT2ZmICAgMCAgICAgICAgICA1bQpgYGAK" + + "CkV2ZW50cyBzaG93OgpgYGAKRmFpbGVkIHRvIHB1bGwgaW1hZ2UgIm52Y3IuaW8vLi4uL2ltYWdl" + + "OnRhZyI6IDQwMSBVbmF1dGhvcml6ZWQKYGBgCgojIyMgRGlhZ25vc2lzCgpgYGBiYXNoCiMgQ2hl" + + "Y2sgd2hhdCBpbWFnZSBpcyBmYWlsaW5nCmt1YmVjdGwgZGVzY3JpYmUgcG9kIC1uIDxuYW1lc3Bh" + + "Y2U+IDxwb2QtbmFtZT4gfCBncmVwIC1BNSAiRXZlbnRzOiIKCiMgQ2hlY2sgaWYgcHVsbCBzZWNy" + + "ZXQgZXhpc3RzIGluIHRoZSBuYW1lc3BhY2UKa3ViZWN0bCBnZXQgc2VjcmV0IG52Y3ItY3JlZHMg" + + "LW4gPG5hbWVzcGFjZT4KCiMgQ2hlY2sgaWYgdGhlIHBvZCBzcGVjIGhhcyBpbWFnZVB1bGxTZWNy" + + "ZXRzCmt1YmVjdGwgZ2V0IHBvZCAtbiA8bmFtZXNwYWNlPiA8cG9kLW5hbWU+IC1vIGpzb25wYXRo" + + "PSd7LnNwZWMuaW1hZ2VQdWxsU2VjcmV0c30nCgojIENoZWNrIGlmIHRoZSBTZXJ2aWNlQWNjb3Vu" + + "dCBoYXMgaW1hZ2VQdWxsU2VjcmV0cwprdWJlY3RsIGdldCBzYSA8c2EtbmFtZT4gLW4gPG5hbWVz" + + "cGFjZT4gLW8ganNvbnBhdGg9J3suaW1hZ2VQdWxsU2VjcmV0c30nCmBgYAoKIyMjIEZpeGVzCgox" + + "LiAqKlNlY3JldCBtaXNzaW5nIGluIG5hbWVzcGFjZSoqOiBDcmVhdGUgaXQKICAgYGBgYmFzaAog" + + "ICBrdWJlY3RsIGNyZWF0ZSBzZWNyZXQgZG9ja2VyLXJlZ2lzdHJ5IG52Y3ItY3JlZHMgXAogICAg" + + "IC0tZG9ja2VyLXNlcnZlcj1udmNyLmlvIFwKICAgICAtLWRvY2tlci11c2VybmFtZT0nJG9hdXRo" + + "dG9rZW4nIFwKICAgICAtLWRvY2tlci1wYXNzd29yZD0iJE5HQ19BUElfS0VZIiBcCiAgICAgLS1u" + + "YW1lc3BhY2U9PG5hbWVzcGFjZT4gXAogICAgIC0tZHJ5LXJ1bj1jbGllbnQgLW8geWFtbCB8IGt1" + + "YmVjdGwgYXBwbHkgLWYgLQogICBgYGAKCjIuICoqU2VjcmV0IGV4aXN0cyBidXQgcG9kIGRvZXNu" + + "J3QgcmVmZXJlbmNlIGl0Kio6IFRoZSBjaGFydCBuZWVkcyBgaW1hZ2VQdWxsU2VjcmV0c2AgY29u" + + "ZmlndXJlZCB2aWEgaGVsbWZpbGUgdmFsdWVzLiBTZWUgW3B1bGwtc2VjcmV0cy5tZF0ocHVsbC1z" + + "ZWNyZXRzLm1kKS4KCjMuICoqQ2hhcnQgZG9lc24ndCBzdXBwb3J0IGltYWdlUHVsbFNlY3JldHMq" + + "KiAob3BlbmJhbywgaW52b2NhdGlvbi1zZXJ2aWNlLCBlc3MtYXBpLCBub3Rhcnktc2VydmljZSk6" + + "IFBhdGNoIFNlcnZpY2VBY2NvdW50cyBhbmQgcmVzdGFydCBwb2RzLiBTZWUgW3B1bGwtc2VjcmV0" + + "cy5tZF0ocHVsbC1zZWNyZXRzLm1kKS4KCjQuICoqV3JvbmcgY3JlZGVudGlhbHMgaW4gc2VjcmV0" + + "Kio6IERlbGV0ZSBhbmQgcmVjcmVhdGUKICAgYGBgYmFzaAogICBrdWJlY3RsIGRlbGV0ZSBzZWNy" + + "ZXQgbnZjci1jcmVkcyAtbiA8bmFtZXNwYWNlPgogICAjIFJlY3JlYXRlIHdpdGggY29ycmVjdCBj" + + "cmVkZW50aWFscwogICBgYGAKCiMjIEZhaWx1cmU6IEluaXQ6MC8xIFN0dWNrIChWYXVsdCBBZ2Vu" + + "dCkKCiMjIyBTeW1wdG9tcwoKU2VydmljZSBwb2RzIHN0dWNrIGluIGBJbml0OjAvMWAgZm9yIG1p" + + "bnV0ZXM6CmBgYApOQU1FICAgICAgICAgICAgICAgICAgICAgICAgUkVBRFkgICBTVEFUVVMgICAg" + + "IFJFU1RBUlRTICAgQUdFCm52Y2YtYXBpLTdmNGM3NmY3ODgtNDR2bHQgIDAvMiAgICAgSW5pdDow" + + "LzEgICAwICAgICAgICAgIDEwbQpgYGAKCiMjIyBEaWFnbm9zaXMKClRoZSBpbml0IGNvbnRhaW5l" + + "ciBpcyB0aGUgdmF1bHQtYWdlbnQtaW5pdCBpbmplY3RvciB3YWl0aW5nIGZvciBPcGVuQmFvLgoK" + + "YGBgYmFzaAojIENoZWNrIE9wZW5CYW8gcG9kcwprdWJlY3RsIGdldCBwb2RzIC1uIHZhdWx0LXN5" + + "c3RlbQoKIyBDaGVjayBpZiBPcGVuQmFvIG1pZ3JhdGlvbiBqb2IgcmFuCmt1YmVjdGwgZ2V0IGpv" + + "YnMgLW4gdmF1bHQtc3lzdGVtCgojIENoZWNrIE9wZW5CYW8gcG9kIGxvZ3MKa3ViZWN0bCBsb2dz" + + "IC1uIHZhdWx0LXN5c3RlbSBvcGVuYmFvLXNlcnZlci0wIC1jIG9wZW5iYW8KCiMgQ2hlY2sgaW5p" + + "dCBjb250YWluZXIgbG9ncyBvbiB0aGUgc3R1Y2sgcG9kCmt1YmVjdGwgbG9ncyAtbiA8bmFtZXNw" + + "YWNlPiA8cG9kLW5hbWU+IC1jIHZhdWx0LWFnZW50LWluaXQKYGBgCgojIyMgRml4ZXMKCjEuICoq" + + "T3BlbkJhbyBwb2RzIG5vdCBydW5uaW5nKio6IENoZWNrIHRoZWlyIGV2ZW50cyBmb3IgaW1hZ2Ug" + + "cHVsbCBpc3N1ZXMsIHJlc291cmNlIGlzc3VlcywgZXRjLgoKMi4gKipPcGVuQmFvIG1pZ3JhdGlv" + + "biBqb2IgZGlkbid0IHJ1bioqOiBUaGlzIGhhcHBlbnMgd2hlbiBgaGVsbWZpbGUgc3luY2Agd2Fz" + + "IGludGVycnVwdGVkLiBEZXN0cm95IGFuZCByZS1zeW5jIG9wZW5iYW86CiAgIGBgYGJhc2gKICAg" + + "SEVMTUZJTEVfRU5WPTxlbnY+IGhlbG1maWxlIC0tc2VsZWN0b3IgbmFtZT1vcGVuYmFvLXNlcnZl" + + "ciBkZXN0cm95CiAgIGt1YmVjdGwgZGVsZXRlIG5hbWVzcGFjZSB2YXVsdC1zeXN0ZW0KICAga3Vi" + + "ZWN0bCBjcmVhdGUgbmFtZXNwYWNlIHZhdWx0LXN5c3RlbQogICAjIFJlLWNyZWF0ZSBwdWxsIHNl" + + "Y3JldCBpZiBuZWVkZWQKICAgSEVMTUZJTEVfRU5WPTxlbnY+IGhlbG1maWxlIC0tc2VsZWN0b3Ig" + + "bmFtZT1vcGVuYmFvLXNlcnZlciBzeW5jCiAgIGBgYAoKMy4gKipPcGVuQmFvIHBvZHMgcnVubmlu" + + "ZyBidXQgbm90IGluaXRpYWxpemVkKio6IENoZWNrIHVuc2VhbCBzdGF0dXM6CiAgIGBgYGJhc2gK" + + "ICAga3ViZWN0bCBleGVjIC1uIHZhdWx0LXN5c3RlbSBvcGVuYmFvLXNlcnZlci0wIC1jIG9wZW5i" + + "YW8gLS0gYmFvIHN0YXR1cwogICBgYGAKCjQuICoqYHZhdWx0LWFnZW50LWluaXRgIGxvZ3MgYGF1" + + "dGgvand0L2xvZ2luYCAtPiBgNDAwIC4uLiBubyBrbm93biBrZXkgc3VjY2Vzc2Z1bGx5IHZhbGlk" + + "YXRlZCB0aGUgdG9rZW4gc2lnbmF0dXJlYCoqCiAgIChjb21tb24gb24gQUtTLCBhbmQgb24gYW55" + + "IGNsdXN0ZXIgd2hvc2UgT0lEQyBpc3N1ZXIgcHVibGlzaGVzIGEgcm90YXRpbmcgbXVsdGkta2V5" + + "IEpXS1MpOgogICB0aGUgT3BlbkJhbyBgYXV0aC9qd3RgIG1ldGhvZCB3YXMgY29uZmlndXJlZCB3" + + "aXRoIGEgc2luZ2xlIHN0YXRpYyBtb3VudGVkIHB1YmxpYyBrZXkKICAgKGBqd3RfdmFsaWRhdGlv" + + "bl9wdWJrZXlzYCkgaW5zdGVhZCBvZiB0aGUgaXNzdWVyJ3MgbGl2ZSBKV0tTLCBzbyBpdCBjYW5u" + + "b3QgdmFsaWRhdGUgdGhlCiAgIGNsdXN0ZXItc2lnbmVkIFNlcnZpY2VBY2NvdW50IHRva2VucyB0" + + "aGUgdmF1bHQtYWdlbnRzIHByZXNlbnQuIEV2ZXJ5IHNlcnZpY2UncwogICBgdmF1bHQtYWdlbnQt" + + "aW5pdGAgdGhlbiBsb29wcyBvbiB0aGF0IDQwMCBhbmQgdGhlIHBvZCBuZXZlciBsZWF2ZXMgYElu" + + "aXQ6MC8xYC4gVGhpcyBpcyB0aGUKICAgYmVoYXZpb3Igb2YgdGhlIGJhc2UgZGVmYXVsdCBgb3Bl" + + "bmJhby5taWdyYXRpb25zLmlzc3VlckRpc2NvdmVyeS5lbmFibGVkOiBmYWxzZWA7IHRoZQogICBt" + + "aWdyYXRpb24gbG9nIHNob3dzIGBPSURDIGlzc3VlciBkaXNjb3ZlcnkgaXMgZGlzYWJsZWQuIFVz" + + "aW5nIFNlcnZpY2VBY2NvdW50IGlzc3VlciBhbmQKICAgbW91bnRlZCBwdWJsaWMga2V5IGZhbGxi" + + "YWNrYC4gRW5hYmxlIGlzc3VlciBkaXNjb3Zlcnkgc28gdGhlIG1pZ3JhdGlvbiB1c2VzIHRoZSBs" + + "aXZlIEpXS1MsCiAgIHRoZW4gcmUtcnVuIGl0OgogICBgYGBiYXNoCiAgICMgSW4geW91ciBlbnYg" + + "dmFsdWVzIChlLmcuIGVudmlyb25tZW50cy88ZW52Pi55YW1sKSwgc2V0OgogICAjICAgb3BlbmJh" + + "bzoKICAgIyAgICAgbWlncmF0aW9uczoKICAgIyAgICAgICBpc3N1ZXJEaXNjb3Zlcnk6CiAgICMg" + + "ICAgICAgICBlbmFibGVkOiB0cnVlCiAgIGt1YmVjdGwgZGVsZXRlIGpvYiAtbiB2YXVsdC1zeXN0" + + "ZW0gb3BlbmJhby1zZXJ2ZXItbWlncmF0aW9ucwogICBIRUxNRklMRV9FTlY9PGVudj4gaGVsbWZp" + + "bGUgLS1zZWxlY3RvciBuYW1lPW9wZW5iYW8tc2VydmVyIHN5bmMKICAgYGBgCiAgIFRoZSBtaWdy" + + "YXRpb24gbG9nIHNob3VsZCB0aGVuIHNob3cgYFJlY2VpdmVkIGRpc2NvdmVyeSBkb2N1bWVudCBm" + + "cm9tCiAgIC4uLi8ud2VsbC1rbm93bi9vcGVuaWQtY29uZmlndXJhdGlvbmAgYW5kIGBGaW5hbCBP" + + "cGVuQmFvIEpXVCBKV0tTIFVSTCBzZXQgdG86CiAgIC4uLi9vcGVuaWQvdjEvandrc2AsIGFuZCB0" + + "aGUgc2VydmljZSBwb2RzIGF1dGhlbnRpY2F0ZSBhbmQgcmVhY2ggUmVhZHkgd2l0aGluIH4xIG1p" + + "bi4KICAgQUtTIGNsdXN0ZXJzIHdpdGggdGhlIGNsdXN0ZXIgT0lEQyBpc3N1ZXIgZW5hYmxlZCAo" + + "dGhlIGBha3MtY2x1c3RlcmAgZGVmYXVsdCkgYWx3YXlzIG5lZWQKICAgdGhpcyBiZWNhdXNlIHRo" + + "ZSBzdGF0aWMtcHVia2V5IGZhbGxiYWNrIGNhbm5vdCBtYXRjaCB0aGUgaXNzdWVyJ3Mgcm90YXRp" + + "bmcgc2lnbmluZyBrZXlzLgoKIyMgRmFpbHVyZTogT09NS2lsbGVkIG9uIENhc3NhbmRyYQoKIyMj" + + "IFN5bXB0b21zCgpgYGAKTkFNRSAgICAgICAgICBSRUFEWSAgIFNUQVRVUyAgICBSRVNUQVJUUyAg" + + "IEFHRQpjYXNzYW5kcmEtMCAgIDAvMSAgICAgT09NS2lsbGVkICAzICAgICAgICAgMTBtCmBgYAoK" + + "IyMjIERpYWdub3NpcwoKYGBgYmFzaAprdWJlY3RsIGRlc2NyaWJlIHBvZCAtbiBjYXNzYW5kcmEt" + + "c3lzdGVtIGNhc3NhbmRyYS0wIHwgZ3JlcCAtQTMgIkxhc3QgU3RhdGUiCmBgYAoKIyMjIEZpeAoK" + + "T3ZlcnJpZGUgQ2Fzc2FuZHJhIHJlc291cmNlcyB2aWEgaGVsbWZpbGUgdmFsdWVzLiBTZWUgRXhh" + + "bXBsZSAxIGluCltleGFtcGxlcy5tZF0oLi4vZXhhbXBsZXMubWQpLgoKYGBgeWFtbAotIGNhc3Nh" + + "bmRyYToKICAgIHJlc291cmNlczoKICAgICAgbGltaXRzOgogICAgICAgIGNwdTogIjgiCiAgICAg" + + "ICAgbWVtb3J5OiA4MTkyTWkKICAgICAgcmVxdWVzdHM6CiAgICAgICAgY3B1OiAiMiIKICAgICAg" + + "ICBtZW1vcnk6IDQwOTZNaQpgYGAKCk5vdGU6IGByZXNvdXJjZVByZXNldGAgaXMgbm90IGF2YWls" + + "YWJsZSBpbiB0aGUgTlZDRiBjYXNzYW5kcmEgd3JhcHBlciBjaGFydC4gVXNlIGV4cGxpY2l0IGBy" + + "ZXNvdXJjZXNgLgoKIyMgRmFpbHVyZTogUG9kcyBTdHVjayBpbiBQZW5kaW5nCgojIyMgU3ltcHRv" + + "bXMKCmBgYApOQU1FICAgICAgICAgIFJFQURZICAgU1RBVFVTICAgIFJFU1RBUlRTICAgQUdFCmNh" + + "c3NhbmRyYS0wICAgMC8xICAgICBQZW5kaW5nICAgMCAgICAgICAgICAxMG0KYGBgCgojIyMgRGlh" + + "Z25vc2lzCgpgYGBiYXNoCiMgQ2hlY2sgZXZlbnRzIGZvciBzY2hlZHVsaW5nIGZhaWx1cmVzCmt1" + + "YmVjdGwgZGVzY3JpYmUgcG9kIC1uIDxuYW1lc3BhY2U+IDxwb2QtbmFtZT4KCiMgQ29tbW9uIGNh" + + "dXNlczoKIyAtICIwLzEyIG5vZGVzIGFyZSBhdmFpbGFibGU6IDEyIG5vZGUocykgZGlkbid0IG1h" + + "dGNoIFBvZCdzIG5vZGUgYWZmaW5pdHkiCiMgLSAiMC8xMiBub2RlcyBhcmUgYXZhaWxhYmxlOiAx" + + "MiBJbnN1ZmZpY2llbnQgbWVtb3J5IgojIC0gInBlcnNpc3RlbnR2b2x1bWVjbGFpbSBub3QgZm91" + + "bmQiCmBgYAoKIyMjIEZpeGVzCgoxLiAqKk5vZGUgc2VsZWN0b3IgbWlzbWF0Y2gqKjogQ2hlY2sg" + + "YG5vZGVTZWxlY3RvcnNgIGluIGVudmlyb25tZW50IGZpbGUKICAgYGBgYmFzaAogICBrdWJlY3Rs" + + "IGdldCBub2RlcyAtLXNob3ctbGFiZWxzIHwgZ3JlcCBudmNmCiAgIGBgYAoKMi4gKipTdG9yYWdl" + + "IGNsYXNzIG5vdCBmb3VuZCoqOiBDaGVjayBzdG9yYWdlIGNsYXNzIGV4aXN0cwogICBgYGBiYXNo" + + "CiAgIGt1YmVjdGwgZ2V0IHN0b3JhZ2VjbGFzcwogICBgYGAKCjMuICoqSW5zdWZmaWNpZW50IHJl" + + "c291cmNlcyoqOiBDaGVjayBub2RlIGNhcGFjaXR5CiAgIGBgYGJhc2gKICAga3ViZWN0bCBkZXNj" + + "cmliZSBub2RlIDxub2RlLW5hbWU+IHwgZ3JlcCAtQTUgIkFsbG9jYXRlZCByZXNvdXJjZXMiCiAg" + + "IGBgYAoKIyMgRmFpbHVyZTogSGVsbSBSZWxlYXNlIGluIEZhaWxlZCBTdGF0ZQoKIyMjIFN5bXB0" + + "b21zCgpgYGBiYXNoCmhlbG0gbGlzdCAtQQojIFNob3dzIHJlbGVhc2Ugd2l0aCBTVEFUVVM6IGZh" + + "aWxlZApgYGAKClJlLXJ1bm5pbmcgYGhlbG1maWxlIHN5bmNgIGFwcGVhcnMgdG8gc3VjY2VlZCBi" + + "dXQgc2VydmljZXMgZG9uJ3Qgd29yayAobWlncmF0aW9ucyBza2lwcGVkKS4KCiMjIyBEaWFnbm9z" + + "aXMKCmBgYGJhc2gKaGVsbSBoaXN0b3J5IDxyZWxlYXNlLW5hbWU+IC1uIDxuYW1lc3BhY2U+CmBg" + + "YAoKIyMjIEZpeAoKTXVzdCBkZXN0cm95IHRoZSBmYWlsZWQgcmVsZWFzZSBhbmQgcmUtc3luYyAo" + + "bm90IGp1c3QgYXBwbHkpOgoKYGBgYmFzaApIRUxNRklMRV9FTlY9PGVudj4gaGVsbWZpbGUgLS1z" + + "ZWxlY3RvciBuYW1lPTxyZWxlYXNlPiBkZXN0cm95CiMgSWYgbmFtZXNwYWNlIG5lZWRzIGNsZWFu" + + "dXA6Cmt1YmVjdGwgZGVsZXRlIG5hbWVzcGFjZSA8bmFtZXNwYWNlPgprdWJlY3RsIGNyZWF0ZSBu" + + "YW1lc3BhY2UgPG5hbWVzcGFjZT4KIyBSZS1jcmVhdGUgcHVsbCBzZWNyZXQgaWYgbmVlZGVkCkhF" + + "TE1GSUxFX0VOVj08ZW52PiBoZWxtZmlsZSAtLXNlbGVjdG9yIG5hbWU9PHJlbGVhc2U+IHN5bmMK" + + "YGBgCgojIyBGYWlsdXJlOiBBY2NvdW50IEJvb3RzdHJhcCBKb2IgRmFpbGVkCgojIyMgU3ltcHRv" + + "bXMKClNlcnZpY2VzIGRlcGxveSBidXQgZnVuY3Rpb25zIGNhbid0IGJlIGNyZWF0ZWQuIEV2ZW50" + + "cyBzaG93IGJvb3RzdHJhcCBqb2IgZmFpbHVyZS4KCiMjIyBEaWFnbm9zaXMKCmBgYGJhc2gKIyBD" + + "aGVjayBib290c3RyYXAgam9iIHN0YXR1cwprdWJlY3RsIGdldCBqb2JzIC1uIG52Y2YKCiMgR2V0" + + "IGxvZ3MgKGpvYiBhdXRvLWRlbGV0ZXMgYWZ0ZXIgfjUgbWludXRlcykKa3ViZWN0bCBsb2dzIGpv" + + "Yi9udmNmLWFwaS1hY2NvdW50LWJvb3RzdHJhcCAtbiBudmNmCgojIENoZWNrIEFQSSBsb2dzCmt1" + + "YmVjdGwgbG9ncyAtbiBudmNmIC1sIGFwcC5rdWJlcm5ldGVzLmlvL25hbWU9bnZjZi1hcGkgLS10" + + "YWlsPTEwMApgYGAKCiMjIyBDb21tb24gQ2F1c2VzCgoxLiAqKldyb25nIGJhc2U2NCBjcmVkZW50" + + "aWFscyoqOiBDcmVkZW50aWFscyBpbiBgc2VjcmV0cy88ZW52Pi1zZWNyZXRzLnlhbWxgIG11c3Qg" + + "YmUgYCRvYXV0aHRva2VuOkFQSV9LRVlgIGJhc2U2NC1lbmNvZGVkLCBub3QganVzdCB0aGUgQVBJ" + + "IGtleQogICBgYGBiYXNoCiAgICMgVmVyaWZ5IHlvdXIgZW5jb2RlZCBjcmVkZW50aWFsCiAgIGVj" + + "aG8gJ1lPVVJfQkFTRTY0X1NUUklORycgfCBiYXNlNjQgLWQKICAgIyBTaG91bGQgb3V0cHV0OiAk" + + "b2F1dGh0b2tlbjpudmFwaS14eHh4eAogICBgYGAKCjIuICoqUmVnaXN0cnkgdW5yZWFjaGFibGUq" + + "KjogQVBJIGNhbid0IHJlYWNoIHRoZSByZWdpc3RyeSBzcGVjaWZpZWQgaW4gYGFjY291bnRCb290" + + "c3RyYXAucmVnaXN0cnlDcmVkZW50aWFsc2AKCiMjIyBGaXgKCkZpeCBjcmVkZW50aWFscyBpbiBz" + + "ZWNyZXRzIGZpbGUsIHRoZW4gcmVjb3ZlciBzZXJ2aWNlcyB3aXRob3V0IGRlc3Ryb3lpbmcgZGVw" + + "ZW5kZW5jaWVzOgoKYGBgYmFzaApIRUxNRklMRV9FTlY9PGVudj4gaGVsbWZpbGUgLS1zZWxlY3Rv" + + "ciByZWxlYXNlLWdyb3VwPXNlcnZpY2VzIGRlc3Ryb3kKa3ViZWN0bCBkZWxldGUgbmFtZXNwYWNl" + + "IG52Y2YgYXBpLWtleXMgZXNzIHNpcyAtLWlnbm9yZS1ub3QtZm91bmQKa3ViZWN0bCBjcmVhdGUg" + + "bmFtZXNwYWNlIG52Y2YgJiYga3ViZWN0bCBjcmVhdGUgbmFtZXNwYWNlIGFwaS1rZXlzICYmIFwK" + + "ICBrdWJlY3RsIGNyZWF0ZSBuYW1lc3BhY2UgZXNzICYmIGt1YmVjdGwgY3JlYXRlIG5hbWVzcGFj" + + "ZSBzaXMKIyBSZS1jcmVhdGUgcHVsbCBzZWNyZXRzIGlmIG5lZWRlZApIRUxNRklMRV9FTlY9PGVu" + + "dj4gaGVsbWZpbGUgLS1zZWxlY3RvciByZWxlYXNlLWdyb3VwPXNlcnZpY2VzIHN5bmMKYGBgCgoj" + + "IyBGYWlsdXJlOiBOVkNBIENsZWFudXAgU3R1Y2sgKEZpbmFsaXplcnMpCgojIyMgU3ltcHRvbXMK" + + "CkNvbXB1dGUtcGxhbmUgY2xlYW51cCBoYW5ncy4gTmFtZXNwYWNlcwpzdHVjayBpbiBgVGVybWlu" + + "YXRpbmdgOgoKYGBgYmFzaAprdWJlY3RsIGdldCBucwojIG52Y2Etb3BlcmF0b3IgICAgVGVybWlu" + + "YXRpbmcgICAxMG0KIyBudmNmLWJhY2tlbmQgICAgIFRlcm1pbmF0aW5nICAgMTBtCmBgYAoKIyMj" + + "IEZpeAoKUnVuIHRoaXMgb25seSBhZ2FpbnN0IHRoZSBjb21wdXRlIGNvbnRleHQsIGFmdGVyIHRo" + + "ZSBub3JtYWwgY29tcHV0ZS1wbGFuZQp0ZWFyZG93biBoYXMgZmFpbGVkLiBSZW1vdmUgZmluYWxp" + + "emVycyBmcm9tIE5WQ0ZCYWNrZW5kIGN1c3RvbSByZXNvdXJjZXMgYW5kCmZvcmNlLWRlbGV0ZSBz" + + "dHVjayBuYW1lc3BhY2VzOgoKYGBgYmFzaApleHBvcnQgQ09NUFVURV9DT05URVhUPTxjb21wdXRl" + + "LXBsYW5lLWNvbnRleHQ+CgojIFJlbW92ZSBmaW5hbGl6ZXJzIGZyb20gTlZDRkJhY2tlbmQgcmVz" + + "b3VyY2VzCmt1YmVjdGwgLS1jb250ZXh0ICIkQ09NUFVURV9DT05URVhUIiBnZXQgbnZjZmJhY2tl" + + "bmRzIC1BIC1vIGpzb24gfCBcCiAganEgJy5pdGVtc1tdIHwgLm1ldGFkYXRhLm5hbWVzcGFjZSAr" + + "ICIvIiArIC5tZXRhZGF0YS5uYW1lJyAtciB8IFwKICB4YXJncyAtSXt9IHNoIC1jICdjb250ZXh0" + + "PSIkMSI7IG5zPSIkezIlJS8qfSI7IG5hbWU9IiR7MiMjKi99Ijsga3ViZWN0bCAtLWNvbnRleHQg" + + "IiRjb250ZXh0IiBwYXRjaCBudmNmYmFja2VuZCAiJG5hbWUiIC1uICIkbnMiIC0tdHlwZT1tZXJn" + + "ZSAtcCAie1wibWV0YWRhdGFcIjp7XCJmaW5hbGl6ZXJzXCI6W119fSInIF8gIiRDT01QVVRFX0NP" + + "TlRFWFQiIHt9CgojIEZvcmNlLWRlbGV0ZSBzdHVjayBuYW1lc3BhY2VzIGJ5IGNsZWFyaW5nIHRo" + + "ZWlyIGZpbmFsaXplcnMKZm9yIG5zIGluIG52Y2Etb3BlcmF0b3IgbnZjZi1iYWNrZW5kOyBkbwog" + + "IGt1YmVjdGwgLS1jb250ZXh0ICIkQ09NUFVURV9DT05URVhUIiBnZXQgbmFtZXNwYWNlICIkbnMi" + + "IC1vIGpzb24gMj4vZGV2L251bGwgfCBcCiAgICBqcSAnLnNwZWMuZmluYWxpemVycyA9IFtdJyB8" + + "IFwKICAgIGt1YmVjdGwgLS1jb250ZXh0ICIkQ09NUFVURV9DT05URVhUIiByZXBsYWNlIFwKICAg" + + "ICAgLS1yYXcgIi9hcGkvdjEvbmFtZXNwYWNlcy8kbnMvZmluYWxpemUiIC1mIC0gMj4vZGV2L251" + + "bGwKZG9uZQpgYGAKCiMjIEZhaWx1cmU6IE5WQ0EgT3BlcmF0b3IgTWlzc2luZyBvciBOb3QgUmVh" + + "ZHkKCiMjIyBTeW1wdG9tcwoKQWZ0ZXIgY29tcHV0ZS1wbGFuZSBpbnN0YWxsIGNvbXBsZXRlcywg" + + "bm8gYG52Y2Etb3BlcmF0b3JgIERlcGxveW1lbnQgZXhpc3RzLCBvcgppdCBleGlzdHMgYnV0IHBv" + + "ZHMgYXJlIG5vdCByZWFkeToKCmBgYGJhc2gKa3ViZWN0bCAtLWNvbnRleHQgPGNvbXB1dGUtcGxh" + + "bmUtY29udGV4dD4gZ2V0IGRlcGxveW1lbnQgbnZjYS1vcGVyYXRvciBcCiAgLW4gbnZjYS1vcGVy" + + "YXRvcgprdWJlY3RsIC0tY29udGV4dCA8Y29tcHV0ZS1wbGFuZS1jb250ZXh0PiBnZXQgcG9kcyAt" + + "biBudmNhLW9wZXJhdG9yCmBgYAoKIyMjIERpYWdub3NpcyBhbmQgRml4ZXMKCkZpcnN0IGlkZW50" + + "aWZ5IHdoZXRoZXIgdGhlIGluc3RhbGxhdGlvbiB1c2VkIHRoZSBIZWxtZmlsZSB2YWx1ZXMgZmxv" + + "dyBvciB0aGUKQ0xJIHByb2ZpbGUgZmxvdy4gUmUtcnVuIG9ubHkgdGhhdCBmbG93J3MgcmVnaXN0" + + "cmF0aW9uIGFuZCBpbnN0YWxsYXRpb24gc3RlcHMKZnJvbSBbU3BsaXQgQ29tcHV0ZS1QbGFuZSBJ" + + "bnN0YWxsYXRpb25dKGNvbXB1dGUtcGxhbmUtaW5zdGFsbGF0aW9uLm1kKS4gRG8gbm90CnN1YnN0" + + "aXR1dGUgb25lIGhhbmRvZmYgZm9yIHRoZSBvdGhlci4KCklmIGluc3RhbGxhdGlvbiBzdWNjZWVk" + + "cyBidXQgcG9kcyBzdGlsbCBmYWlsLCBpbnNwZWN0IHRoZSBjb21wdXRlIGNvbnRleHQ6CgpgYGBi" + + "YXNoCmt1YmVjdGwgLS1jb250ZXh0IDxjb21wdXRlLXBsYW5lLWNvbnRleHQ+IGRlc2NyaWJlIGRl" + + "cGxveSBudmNhLW9wZXJhdG9yIFwKICAtbiBudmNhLW9wZXJhdG9yCmt1YmVjdGwgLS1jb250ZXh0" + + "IDxjb21wdXRlLXBsYW5lLWNvbnRleHQ+IGxvZ3MgZGVwbG95bWVudC9udmNhLW9wZXJhdG9yIFwK" + + "ICAtbiBudmNhLW9wZXJhdG9yIC0tdGFpbD0yMDAKa3ViZWN0bCAtLWNvbnRleHQgPGNvbXB1dGUt" + + "cGxhbmUtY29udGV4dD4gZ2V0IG52Y2ZiYWNrZW5kIC1uIG52Y2Etb3BlcmF0b3IKYGBgCgpGb3Ig" + + "cHJpdmF0ZSByZWdpc3RyeSBmYWlsdXJlcywgdmVyaWZ5IHRoYXQgdGhlIHB1bGwgc2VjcmV0IGV4" + + "aXN0cyBpbgpgbnZjYS1vcGVyYXRvcmAuIFRoZSBjaGFydCBhbmQgb3BlcmF0b3IgbWlycm9yIGl0" + + "IHRvIGBudmNhLXN5c3RlbWA7IGRvIG5vdCB1c2UgYQpicm9hZGVyIG1hbnVhbCBuYW1lc3BhY2Ug" + + "bG9vcC4gU2VlCltwdWxsLXNlY3JldHMubWRdKHB1bGwtc2VjcmV0cy5tZCNjb21wdXRlLXBsYW5l" + + "LXNlY3JldCkuCgojIyBGYWlsdXJlOiBHYXRld2F5IEVuZHBvaW50IENoYW5nZWQKCiMjIyBTeW1w" + + "dG9tcwoKUmVxdWVzdHMgdGhyb3VnaCB0aGUgY29uZmlndXJlZCByb3V0ZSBkb21haW4gZmFpbCBh" + + "ZnRlciB0aGUgR2F0ZXdheSBvciBpdHMgbG9hZCBiYWxhbmNlciBpcyByZXBsYWNlZC4gVGhlIEdh" + + "dGV3YXkgcmVwb3J0cyBhIG5ldyBlbmRwb2ludC4KCiMjIyBEaWFnbm9zaXMKCmBgYGJhc2gKR0FU" + + "RVdBWV9BRERSPSQoa3ViZWN0bCAtLWNvbnRleHQgPGNvbnRyb2wtcGxhbmUtY29udGV4dD4gZ2V0" + + "IGdhdGV3YXkgXAogIG52Y2YtZ2F0ZXdheSAtbiBlbnZveS1nYXRld2F5IFwKICAtbyBqc29ucGF0" + + "aD0ney5zdGF0dXMuYWRkcmVzc2VzWzBdLnZhbHVlfScpCnRlc3QgLW4gIiRHQVRFV0FZX0FERFIi" + + "CmRpZyArc2hvcnQgImFwaS48ZG9tYWluPiIKY3VybCAtSCAiSG9zdDogYXBpLjxkb21haW4+IiAi" + + "aHR0cDovLyRHQVRFV0FZX0FERFIvaGVhbHRoIgoKIyBDaGVjayBkaXJlY3QgYWRkcmVzcyBmaWVs" + + "ZHMgdXNlZCBieSBhIHNwbGl0IGRlcGxveW1lbnQKZ3JlcCBudmNmTmF0c1NlcnZpY2VVUkwgZGVw" + + "bG95L3N0YWNrcy9zZWxmLW1hbmFnZWQvZW52aXJvbm1lbnRzLzxlbnY+LnlhbWwKZ3JlcCAtRSAn" + + "aWNtc1NlcnZpY2V8cmV2YWxTZXJ2aWNlfG5hdHMnIFwKICBkZXBsb3kvc3RhY2tzL252Y2YtY29t" + + "cHV0ZS1wbGFuZS9lbnZpcm9ubWVudHMvPGVudj4ueWFtbApgYGAKCiMjIyBGaXgKCktlZXAgYGds" + + "b2JhbC5kb21haW5gLCByb3V0ZSBob3N0bmFtZXMsIGFuZCBIb3N0IG92ZXJyaWRlcyB1bmNoYW5n" + + "ZWQuIFVwZGF0ZSBETlMKb3IgdGhlIGRpcmVjdCBjbGllbnQgZGVzdGluYXRpb24uIEZvciBzcGxp" + + "dCBkZXBsb3ltZW50cywgdXBkYXRlIG9ubHkgZGlyZWN0CkdhdGV3YXktYWRkcmVzcyBmaWVsZHMg" + + "YW5kIHJlZnJlc2ggcmVnaXN0cmF0aW9uIGFuZCBpbnN0YWxsYXRpb24gdGhyb3VnaCB0aGUKc2Ft" + + "ZSBzZWxlY3RlZCBoYW5kb2ZmLiBTZWUKW0V4YW1wbGUgNF0oLi4vZXhhbXBsZXMubWQjZXhhbXBs" + + "ZS00LXJlY292ZXItZnJvbS1hLWdhdGV3YXktZW5kcG9pbnQtY2hhbmdlKS4KCiMjIFVzZWZ1bCBO" + + "YW1lc3BhY2UtdG8tU2VydmljZSBNYXBwaW5nCgpRdWljayByZWZlcmVuY2UgZm9yIHdoaWNoIHNl" + + "cnZpY2VzIHJ1biBpbiB3aGljaCBuYW1lc3BhY2U6Cgp8IE5hbWVzcGFjZSB8IFNlcnZpY2VzIHwK" + + "fC0tLS0tLS0tLS0tfC0tLS0tLS0tLS18CnwgbmF0cy1zeXN0ZW0gfCBuYXRzIHwKfCBjYXNzYW5k" + + "cmEtc3lzdGVtIHwgY2Fzc2FuZHJhIHwKfCB2YXVsdC1zeXN0ZW0gfCBvcGVuYmFvLXNlcnZlciB8" + + "CnwgbnZjZiB8IGFwaSwgaW52b2NhdGlvbi1zZXJ2aWNlLCBncnBjLXByb3h5LCBub3Rhcnktc2Vy" + + "dmljZSwgcmV2YWwsIGxsbS1yZXF1ZXN0LXJvdXRlciwgbGxtLWFwaS1nYXRld2F5IHwKfCBhcGkt" + + "a2V5cyB8IGFwaS1rZXlzLCBhZG1pbi1pc3N1ZXItcHJveHkgfAp8IGVzcyB8IGVzcy1hcGkgfAp8" + + "IHNpcyB8IHNpcyB8CnwgZW52b3ktZ2F0ZXdheS1zeXN0ZW0gfCBlbnZveSBnYXRld2F5IChpbmdy" + + "ZXNzIGNvbnRyb2xsZXIpIHwKfCBlbnZveS1nYXRld2F5IHwgZ2F0ZXdheSByZXNvdXJjZSArIHJv" + + "dXRlcyB8ClBLBwhWPmeQlTAAAJUwAABQSwMEFAAIAAAAAAAhAAAAAAAAAAAAAAAAAEQACQBkYXRh" + + "L252Y2Ytc2VsZi1tYW5hZ2VkLWluc3RhbGxhdGlvbi9yZWZlcmVuY2VzL2hlbG1maWxlLXN0cnVj" + + "dHVyZS5tZFVUBQABAKbOEiMgSGVsbWZpbGUgU3RydWN0dXJlIFJlZmVyZW5jZQoKIyMgRGlyZWN0" + + "b3J5IExheW91dAoKYGBgCm52Y2Ytc2VsZi1tYW5hZ2VkLXN0YWNrLwp8LS0gaGVsbWZpbGUuZC8K" + + "fCAgIHwtLSAwMS1kZXBlbmRlbmNpZXMueWFtbC5nb3RtcGwgICMgTkFUUywgQ2Fzc2FuZHJhLCBP" + + "cGVuQmFvCnwgICB8LS0gMDItY29yZS55YW1sLmdvdG1wbCAgICAgICAgICAjIE5WQ0Ygc2Vydmlj" + + "ZXMgKyBpbmdyZXNzCnwgICBgLS0gMDMtb2JzZXJ2YWJpbGl0eS55YW1sLmdvdG1wbCAjIE9ic2Vy" + + "dmFiaWxpdHkgc3RhY2sgKG9wdGlvbmFsKQp8LS0gZW52aXJvbm1lbnRzLwp8ICAgfC0tIGJhc2Uu" + + "eWFtbCAgICAgICAgICAgICAgICAgICAgIyBEZWZhdWx0IHZhbHVlcyAoYWxsIGVudmlyb25tZW50" + + "cykKfCAgIGAtLSA8ZW52LW5hbWU+LnlhbWwgICAgICAgICAgICAgICMgUGVyLWVudmlyb25tZW50" + + "IG92ZXJyaWRlcwp8LS0gc2VjcmV0cy8KfCAgIGAtLSA8ZW52LW5hbWU+LXNlY3JldHMueWFtbCAg" + + "ICAgICMgU2Vuc2l0aXZlIHZhbHVlcyAocmVnaXN0cnkgY3JlZHMsIHBhc3N3b3JkcykKYC0tIGds" + + "b2JhbC55YW1sLmdvdG1wbCAgICAgICAgICAgICAgICMgR28gdGVtcGxhdGUgdGhhdCBjb25zdHJ1" + + "Y3RzIHBlci1jaGFydCB2YWx1ZXMKCm52Y2YtY29tcHV0ZS1wbGFuZS1zdGFjay8KfC0tIGhlbG1m" + + "aWxlLmQvCnwgICB8LS0gMDEtZGVwZW5kZW5jaWVzLnlhbWwuZ290bXBsICAjIENvbXB1dGUgcGxh" + + "bmUgZGVwZW5kZW5jeSBjb21wb25lbnRzCnwgICBgLS0gMDItbnZjYS55YW1sLmdvdG1wbCAgICAg" + + "ICAgICAjIG52Y2Etb3BlcmF0b3IgY2hhcnQgYW5kIG52Y2EgY29uZmlndXJhdGlvbgp8LS0gZW52" + + "aXJvbm1lbnRzLwp8ICAgfC0tIGJhc2UueWFtbCAgICAgICAgICAgICAgICAgICAgIyBEZWZhdWx0" + + "IHZhbHVlcyAoYWxsIGVudmlyb25tZW50cykKfCAgIGAtLSA8ZW52LW5hbWU+LnlhbWwgICAgICAg" + + "ICAgICAgICMgUGVyLWVudmlyb25tZW50IG92ZXJyaWRlcwpgLS0gZ2xvYmFsLnlhbWwuZ290bXBs" + + "ICAgICAgICAgICAgICAgIyBHbyB0ZW1wbGF0ZSB0aGF0IGNvbnN0cnVjdHMgcGVyLWNoYXJ0IHZh" + + "bHVlcwpgYGAKClRoZXNlIHN0YWNrcyBoYXZlIHNlcGFyYXRlIGVudmlyb25tZW50cyBhbmQgY2x1" + + "c3RlciBjb250ZXh0cy4gVGhlIEhlbG1maWxlCnZhbHVlcyBmbG93IGF1dGhvcnMgYm90aCBlbnZp" + + "cm9ubWVudCBmaWxlcy4gVGhlIENMSSBwcm9maWxlIGZsb3cgaW5zdGVhZCB1c2VzCnRoZSBDTEkt" + + "Z2VuZXJhdGVkIGNvbnRyb2wtcGxhbmUgcHJvZmlsZSBhcyBpdHMgZW5kcG9pbnQgc291cmNlLiBE" + + "byBub3QgbWl4IHRoZQpoYW5kb2Zmcy4gU2VlIFtTcGxpdCBDb21wdXRlLVBsYW5lIEluc3RhbGxh" + + "dGlvbl0oY29tcHV0ZS1wbGFuZS1pbnN0YWxsYXRpb24ubWQpLgoKIyMgR290bXBsIEZpbGVzIGFu" + + "ZCBUaGVpciBSZWxlYXNlcwoKIyMjIDAxLWRlcGVuZGVuY2llcy55YW1sLmdvdG1wbAoKfCBSZWxl" + + "YXNlIHwgQ2hhcnQgfCBOYW1lc3BhY2UgfCBOb3RlcyB8CnwtLS0tLS0tLS18LS0tLS0tLXwtLS0t" + + "LS0tLS0tLXwtLS0tLS0tfAp8IG5hdHMgfCBoZWxtLW52Y2YtbmF0cyB8IG5hdHMtc3lzdGVtIHwg" + + "TWVzc2FnaW5nIHwKfCBvcGVuYmFvLXNlcnZlciB8IGhlbG0tbnZjZi1vcGVuYmFvLXNlcnZlciB8" + + "IHZhdWx0LXN5c3RlbSB8IFNlY3JldHMgbWFuYWdlbWVudCwgZGVwZW5kcyBvbiBuYXRzIHwKfCBj" + + "YXNzYW5kcmEgfCBoZWxtLW52Y2YtY2Fzc2FuZHJhIHwgY2Fzc2FuZHJhLXN5c3RlbSB8IERhdGFi" + + "YXNlIHwKClVzZXMgYDw8OiAqZGVwZW5kZW5jeWAgdGVtcGxhdGUgaW5oZXJpdGFuY2Ugd2l0aCBg" + + "cmVsZWFzZS1ncm91cDogZGVwZW5kZW5jaWVzYCBsYWJlbC4KCiMjIyAwMi1jb3JlLnlhbWwuZ290" + + "bXBsCgp8IFJlbGVhc2UgfCBDaGFydCB8IE5hbWVzcGFjZSB8IExhYmVsIHwKfC0tLS0tLS0tLXwt" + + "LS0tLS0tfC0tLS0tLS0tLS0tfC0tLS0tLS18CnwgYXBpLWtleXMgfCBoZWxtLW52Y2YtYXBpLWtl" + + "eXMgfCBhcGkta2V5cyB8IHNlcnZpY2VzIHwKfCBzaXMgfCBoZWxtLW52Y2Ytc2lzIHwgc2lzIHwg" + + "c2VydmljZXMgfAp8IGFwaSB8IGhlbG0tbnZjZi1hcGkgfCBudmNmIHwgc2VydmljZXMgfAp8IGlu" + + "dm9jYXRpb24tc2VydmljZSB8IGhlbG0tbnZjZi1pbnZvY2F0aW9uLXNlcnZpY2UgfCBudmNmIHwg" + + "c2VydmljZXMgfAp8IGdycGMtcHJveHkgfCBoZWxtLW52Y2YtZ3JwYy1wcm94eSB8IG52Y2YgfCBz" + + "ZXJ2aWNlcyB8CnwgZXNzLWFwaSB8IGhlbG0tbnZjZi1lc3MtYXBpIHwgZXNzIHwgc2VydmljZXMg" + + "fAp8IG5vdGFyeS1zZXJ2aWNlIHwgaGVsbS1udmNmLW5vdGFyeS1zZXJ2aWNlIHwgbnZjZiB8IHNl" + + "cnZpY2VzIHwKfCByZXZhbCB8IGhlbG0tcmV2YWwgfCBudmNmIHwgc2VydmljZXMgfAp8IGxsbS1y" + + "ZXF1ZXN0LXJvdXRlciB8IG52Y2YvaGVsbS1udmNmLWxsbS1yZXF1ZXN0LXJvdXRlciB8IG52Y2Yg" + + "fCBzZXJ2aWNlcyB8CnwgbGxtLWFwaS1nYXRld2F5IHwgbnZjZi9oZWxtLW52Y2YtbGxtLWFwaS1n" + + "YXRld2F5IHwgbnZjZiB8IHNlcnZpY2VzIHwKfCBhZG1pbi1pc3N1ZXItcHJveHkgfCBoZWxtLWFk" + + "bWluLXRva2VuLWlzc3Vlci1wcm94eSB8IGFwaS1rZXlzIHwgKG5vIHJlbGVhc2UtZ3JvdXAgbGFi" + + "ZWwpIHwKfCBpbmdyZXNzIHwgbnZjZi1nYXRld2F5LXJvdXRlcyB8IGVudm95LWdhdGV3YXktc3lz" + + "dGVtIHwgaW5ncmVzcyB8CgpNb3N0IHNlcnZpY2VzIHVzZSBgaW5oZXJpdDogW3t0ZW1wbGF0ZTog" + + "c2VydmljZX1dYC4gTExNIHJlbGVhc2VzIHVzZSBPQ0kgY2hhcnRzIGZyb20gdGhlIGBudmNmYCBy" + + "ZXBvc2l0b3J5IHdpdGggc3RhbmRhbG9uZSBgdmFsdWVzOiBbLi4vZ2xvYmFsLnlhbWwuZ290bXBs" + + "XWAgYmxvY2tzOyB0aGV5IGFyZSBnYXRlZCBvbiBgYWRkb25zLmxsbS5lbmFibGVkYC4gYGFkbWlu" + + "LWlzc3Vlci1wcm94eWAgYW5kIGBpbmdyZXNzYCBoYXZlIHN0YW5kYWxvbmUgYHZhbHVlczpgIGJs" + + "b2Nrcy4KCiMjIyAwMy1vYnNlcnZhYmlsaXR5LnlhbWwuZ290bXBsCgp8IFJlbGVhc2UgfCBDaGFy" + + "dCB8IE5hbWVzcGFjZSB8IExhYmVsIHwKfC0tLS0tLS0tLXwtLS0tLS0tfC0tLS0tLS0tLS0tfC0t" + + "LS0tLS18CnwgKG9ic2VydmFiaWxpdHkgcmVsZWFzZXMpIHwgKHZhcmlvdXMpIHwgb2JzZXJ2YWJp" + + "bGl0eSB8IG9ic2VydmFiaWxpdHkgfAoKR2F0ZWQgb24gb2JzZXJ2YWJpbGl0eS1zcGVjaWZpYyBm" + + "bGFncyBpbiB0aGUgZW52aXJvbm1lbnQgZmlsZS4gU2tpcHBlZCBpZiBkaXNhYmxlZC4KCiMjIFRl" + + "bXBsYXRlIEluaGVyaXRhbmNlCgojIyMgYDw8OiAqZGVwZW5kZW5jeWAgKFlBTUwgbWVyZ2UpCgpV" + + "c2VkIGluIGAwMS1kZXBlbmRlbmNpZXMueWFtbC5nb3RtcGxgLiBNZXJnZXMgdGhlIHRlbXBsYXRl" + + "J3MgcHJvcGVydGllcyBpbnRvIHRoZSByZWxlYXNlLgoKKipHb3RjaGEqKjogWUFNTCBtZXJnZSBy" + + "ZXBsYWNlcyBsaXN0cy4gSWYgeW91IGFkZCBhIGB2YWx1ZXM6YCBrZXkgdG8gdGhlIHJlbGVhc2Us" + + "IGl0ICoqcmVwbGFjZXMqKiB0aGUgdGVtcGxhdGUncyBgdmFsdWVzOmAgbGlzdCBlbnRpcmVseS4g" + + "WW91IG11c3QgcmUtaW5jbHVkZSBhbGwgdGVtcGxhdGUgdmFsdWVzOgoKSW4gdGhlIHRlbXBsYXRl" + + "IGJlbG93LCBgPHByaXZhdGUtdmFsdWVzPmAgcmVmZXJzIHRvIHRoZSBgc2VjcmV0cy9gIGRpcmVj" + + "dG9yeSBhdCB0aGUgaGVsbWZpbGUgc3RhY2sgcm9vdC4KCmBgYHlhbWwKIyBUZW1wbGF0ZSBkZWZp" + + "bmVzOgp0ZW1wbGF0ZXM6CiAgZGVwZW5kZW5jeTogJmRlcGVuZGVuY3kKICAgIGNoYXJ0OiBudmNm" + + "L2hlbG0tbnZjZi17eyAuUmVsZWFzZS5OYW1lIH19CiAgICB2YWx1ZXM6CiAgICAgIC0gLi4vZ2xv" + + "YmFsLnlhbWwuZ290bXBsCiAgICAgIC0gLi4vPHByaXZhdGUtdmFsdWVzPi97eyByZXF1aXJlZEVu" + + "diAiSEVMTUZJTEVfRU5WIiB9fS1zZWNyZXRzLnlhbWwKCiMgV2hlbiBvdmVycmlkaW5nLCBNVVNU" + + "IHJlLWluY2x1ZGUgYm90aDoKLSBuYW1lOiBjYXNzYW5kcmEKICA8PDogKmRlcGVuZGVuY3kKICB2" + + "YWx1ZXM6CiAgICAtIC4uL2dsb2JhbC55YW1sLmdvdG1wbCAgICAgICAgICAgICAgICAgICAgICAg" + + "ICAgICAgICAgICAgICAgICAgICAgICAjIE11c3QgcmUtaW5jbHVkZQogICAgLSAuLi88cHJpdmF0" + + "ZS12YWx1ZXM+L3t7IHJlcXVpcmVkRW52ICJIRUxNRklMRV9FTlYiIH19LXNlY3JldHMueWFtbCAg" + + "ICMgTXVzdCByZS1pbmNsdWRlCiAgICAtIGNhc3NhbmRyYTogICAgICAgICAgICAgICAgICAgICAg" + + "ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIyBZb3VyIG92ZXJyaWRlCiAgICAg" + + "ICAgcmVzb3VyY2VzOgogICAgICAgICAgbGltaXRzOgogICAgICAgICAgICBtZW1vcnk6IDgxOTJN" + + "aQpgYGAKCiMjIyBgaW5oZXJpdGAgKEhlbG1maWxlIG5hdGl2ZSkKClVzZWQgaW4gYDAyLWNvcmUu" + + "eWFtbC5nb3RtcGxgLiBIZWxtZmlsZSdzIG5hdGl2ZSBpbmhlcml0YW5jZSBtZWNoYW5pc20uCgpg" + + "YGB5YW1sCi0gbmFtZTogYXBpCiAgdmVyc2lvbjogMS42LjAKICBuYW1lc3BhY2U6IG52Y2YKICBp" + + "bmhlcml0OgogICAgLSB0ZW1wbGF0ZTogc2VydmljZQpgYGAKCldoZW4gYWRkaW5nIGB2YWx1ZXM6" + + "YCB0byBhbiBpbmhlcml0ZWQgcmVsZWFzZSwgeW91IGFsc28gbmVlZCB0byByZS1pbmNsdWRlIHRo" + + "ZSB0ZW1wbGF0ZSdzIHZhbHVlcyBmaWxlcyBzaW5jZSBgdmFsdWVzYCBpcyBhIGxpc3QgdGhhdCBn" + + "ZXRzIHJlcGxhY2VkLgoKIyMgVmFsdWVzIFByZWNlZGVuY2UKCkZyb20gbG93ZXN0IHRvIGhpZ2hl" + + "c3QgcHJpb3JpdHk6CgoxLiBgZW52aXJvbm1lbnRzL2Jhc2UueWFtbGAgLS0gZGVmYXVsdHMgc2hh" + + "cmVkIGFjcm9zcyBhbGwgZW52aXJvbm1lbnRzCjIuIGBlbnZpcm9ubWVudHMvPGVudj4ueWFtbGAg" + + "LS0gcGVyLWVudmlyb25tZW50IG92ZXJyaWRlcwozLiBgZ2xvYmFsLnlhbWwuZ290bXBsYCAtLSBH" + + "byB0ZW1wbGF0ZSBwcm9jZXNzaW5nIChjb25zdHJ1Y3RzIGNoYXJ0LXNwZWNpZmljIHN0cnVjdHVy" + + "ZSkKNC4gYDxwcml2YXRlLXZhbHVlcz4vPGVudj4tc2VjcmV0cy55YW1sYCAtLSBzZW5zaXRpdmUg" + + "dmFsdWVzCjUuIElubGluZSBgdmFsdWVzOmAgYmxvY2tzIG9uIHJlbGVhc2VzIC0tIGhpZ2hlc3Qg" + + "cHJlY2VkZW5jZQoKIyMgV2hhdCBnbG9iYWwueWFtbC5nb3RtcGwgUGFzc2VzIFRocm91Z2gKCmBn" + + "bG9iYWwueWFtbC5nb3RtcGxgIHJlYWRzIGZyb20gYC5WYWx1ZXNgICh0aGUgbWVyZ2VkIGVudmly" + + "b25tZW50ICsgZW52LXNwZWNpZmljIFlBTUwpIGFuZCBjb25zdHJ1Y3RzIGNoYXJ0LXNwZWNpZmlj" + + "IHZhbHVlcy4gSXQgb25seSBwYXNzZXMgdGhyb3VnaCBrZXlzIGl0IGV4cGxpY2l0bHkgcmVmZXJl" + + "bmNlczoKCiMjIyBDYXNzYW5kcmEKLSBgY2Fzc2FuZHJhLnJlcGxpY2FDb3VudGAKLSBgY2Fzc2Fu" + + "ZHJhLmltYWdlLipgIChyZWdpc3RyeSwgcmVwb3NpdG9yeSkKLSBgY2Fzc2FuZHJhLm1pZ3JhdGlv" + + "bnMuaW1hZ2UuKmAKLSBgY2Fzc2FuZHJhLnBlcnNpc3RlbmNlLnNpemVgCi0gYGNhc3NhbmRyYS5u" + + "b2RlU2VsZWN0b3JgIChpZiBgZ2xvYmFsLm5vZGVTZWxlY3RvcnMuZW5hYmxlZGApCi0gYGNhc3Nh" + + "bmRyYS5nbG9iYWwuZGVmYXVsdFN0b3JhZ2VDbGFzc2AKCiMjIyBOQVRTCi0gYG5hdHMuY29udGFp" + + "bmVyLmltYWdlLipgCi0gYG5hdHMucmVsb2FkZXIuaW1hZ2UuKmAKLSBgbmF0cy5uYXRzQm94LmNv" + + "bnRhaW5lci5pbWFnZS4qYAotIGBuYXRzLmNvbmZpZy5qZXRzdHJlYW0uZmlsZVN0b3JlLnB2Yy5z" + + "dG9yYWdlQ2xhc3NOYW1lYAotIGBuYXRzLnBvZFRlbXBsYXRlLm1lcmdlLnNwZWMubm9kZVNlbGVj" + + "dG9yYCAoaWYgZW5hYmxlZCkKCiMjIyBPcGVuQmFvCi0gYG9wZW5iYW8ubWlncmF0aW9ucy5pbWFn" + + "ZS4qYCBhbmQgYG9wZW5iYW8ubWlncmF0aW9ucy5lbnZgCi0gYG9wZW5iYW8uaW5qZWN0b3IuaW1h" + + "Z2UuKmAKLSBgb3BlbmJhby5zZXJ2ZXIuaW1hZ2UuKmAKLSBgb3BlbmJhby5zZXJ2ZXIuZGF0YVN0" + + "b3JhZ2UuKmAKLSBOb2RlIHNlbGVjdG9ycyAoaWYgZW5hYmxlZCkKCiMjIyBTZXJ2aWNlcyAoQVBJ" + + "LCBTSVMsIGV0Yy4pCi0gYDxzZXJ2aWNlPi5pbWFnZS4qYCAocmVnaXN0cnksIHJlcG9zaXRvcnkp" + + "Ci0gYDxzZXJ2aWNlPi5ub2RlU2VsZWN0b3JgIChpZiBlbmFibGVkKQotIGA8c2VydmljZT4uZW52" + + "LipgIChvYnNlcnZhYmlsaXR5IHNldHRpbmdzKQoKIyMjIExMTSBGdW5jdGlvbiBFbmFibGVtZW50" + + "CgpFbmFibGUgdGhlIExMTSBhZGRvbiBiZWZvcmUgY3JlYXRpbmcgb3IgaW52b2tpbmcgZnVuY3Rp" + + "b25zIHdpdGgKYGZ1bmN0aW9uVHlwZTogIkxMTSJgLiBUaGUgYWRkb24gZGVwbG95cyBgbGxtLXJl" + + "cXVlc3Qtcm91dGVyYCBhbmQKYGxsbS1hcGktZ2F0ZXdheWAsIGFkZHMgdGhlIGBsbG0uaW52b2Nh" + + "dGlvbi48ZG9tYWluPmAgcm91dGUgd2hlbiBHYXRld2F5IEFQSQppbmdyZXNzIGlzIGVuYWJsZWQs" + + "IGFuZCBjb25maWd1cmVzIHdvcmtlcnMgdG8gdXNlIHRoZSBMTE0gc2lkZWNhci4gVGhlIEhlbG1m" + + "aWxlCmNvbmRpdGlvbiBpcyBgYWRkb25zLmxsbS5lbmFibGVkYC4gRG8gbm90IHVzZSB0aGUgb2Jz" + + "b2xldGUgYGxsbS5lbmFibGVkYCBwYXRoLgoKRm9yIGEgc2luZ2xlLW5vZGUgaXNvbGF0ZWQgdGVz" + + "dCBjbHVzdGVyLCBhZGQgdGhpcyBjb25maWd1cmF0aW9uIHRvCmBlbnZpcm9ubWVudHMvPGVudj4u" + + "eWFtbGAgYmVmb3JlIGFwcGx5aW5nIHRoZSBzdGFjazoKCmBgYHlhbWwKYWRkb25zOgogIGxsbToK" + + "ICAgIGVuYWJsZWQ6IHRydWUKICAgIGdhdGV3YXk6CiAgICAgIHJlcGxpY2FDb3VudDogMQogICAg" + + "ICBhdXRoOgogICAgICAgIGdycGNJbnNlY3VyZTogdHJ1ZQogICAgICBtZXRyaWNzOgogICAgICAg" + + "IHNlcnZpY2VNb25pdG9yOgogICAgICAgICAgZW5hYmxlZDogZmFsc2UKICAgIHJlcXVlc3RSb3V0" + + "ZXI6CiAgICAgIHJlcGxpY2FDb3VudDogMQogICAgICBtZXRyaWNzOgogICAgICAgIHNlcnZpY2VN" + + "b25pdG9yOgogICAgICAgICAgZW5hYmxlZDogZmFsc2UKCmFnZW50Q29uZmlnOgogIG1lcmdlQ29u" + + "ZmlnOiB8CiAgICBjbHVzdGVyOgogICAgICB2YWxpZGF0aW9uUG9saWN5OgogICAgICAgIG5hbWU6" + + "IFVucmVzdHJpY3RlZAogICAgd29ya2xvYWQ6CiAgICAgIHN0YXJnYXRlUVVJQ0luc2VjdXJlOiB0" + + "cnVlCmBgYAoKVXNlIGByZXBsaWNhQ291bnQ6IDFgIG9ubHkgZm9yIGxvY2FsIG9yIHNpbmdsZS1u" + + "b2RlIHRlc3QgY2x1c3RlcnMuIEZvciBzaGFyZWQKb3IgcHJvZHVjdGlvbiBjbHVzdGVycywgdXNl" + + "IHRoZSByZXF1aXJlZCByZXBsaWNhIGNvdW50IGFuZCBUTFMtY2FwYWJsZSBzZXJ2aWNlCmNvbmZp" + + "Z3VyYXRpb24uIGBhZGRvbnMubGxtLmdhdGV3YXkuYXV0aC5ncnBjSW5zZWN1cmVgIGFuZApgd29y" + + "a2xvYWQuc3RhcmdhdGVRVUlDSW5zZWN1cmVgIGVuYWJsZSBwbGFpbnRleHQgdHJhbnNwb3J0cy4g" + + "RG8gbm90IHVzZSB0aGVtIGluCnByb2R1Y3Rpb24uCgpUaGUgcmVxdWVzdCByb3V0ZXIgdXNlcyBg" + + "cG93ZXItb2YtdHdvYCB3aGVuIG5vIGxvYWQtYmFsYW5jZXIgY29uZmlndXJhdGlvbiBpcwpzZXQu" + + "IENvbmZpZ3VyZSBvdGhlciByb3V0aW5nIG1ldGhvZHMgd2l0aCB0aGUKW0xMTSBSZXF1ZXN0IFJv" + + "dXRlciBMb2FkIEJhbGFuY2luZ10oaHR0cHM6Ly9naXRodWIuY29tL05WSURJQS9udmNmL2Jsb2Iv" + + "bWFpbi9kb2NzL3VzZXIvbGxtLXJlcXVlc3Qtcm91dGVyLWxvYWQtYmFsYW5jaW5nLm1kKQpndWlk" + + "ZS4KCklmIHRoZSBzaWRlY2FyIGltYWdlIGlzIG1pcnJvcmVkIG91dHNpZGUgdGhlIHN0YWNrJ3Mg" + + "ZGVmYXVsdCBpbWFnZSByZWdpc3RyeSBhbmQKcmVwb3NpdG9yeSwgc2V0IHRoZSBnZW5lcmF0ZWQg" + + "d29ya2VyIHNpZGVjYXIgaW1hZ2UgZXhwbGljaXRseToKCmBgYHlhbWwKYXBpOgogIGVudjoKICAg" + + "IE5WQ0ZfU0lERUNBUlNfTExNX1JPVVRFUl9DTElFTlRfSU1BR0U6IDxyZWdpc3RyeT4vPHJlcG9z" + + "aXRvcnk+L3B5bG9uOjAuMi4xCmBgYAoKUmVuZGVyIGFuZCBhcHBseSB0aGUgdXBkYXRlZCBjb250" + + "cm9sLXBsYW5lIGVudmlyb25tZW50LCB0aGVuIHJlZnJlc2ggZXZlcnkKcmVnaXN0ZXJlZCBjb21w" + + "dXRlIHBsYW5lIHVzaW5nIHRoZSBzYW1lIGhhbmRvZmYgdXNlZCBmb3IgaXRzIGluc3RhbGxhdGlv" + + "biBzbwpOVkNBIHJlY2VpdmVzIGBhZ2VudENvbmZpZy5tZXJnZUNvbmZpZ2A6CgpgYGBiYXNoCkhF" + + "TE1GSUxFX0VOVj08ZW52PiBoZWxtZmlsZSB0ZW1wbGF0ZQpIRUxNRklMRV9FTlY9PGVudj4gaGVs" + + "bWZpbGUgc3luYwpgYGAKClVzZSB0aGUgY29tcGxldGUgY29tcHV0ZS1wbGFuZSBpbnN0YWxsIGNv" + + "bW1hbmQgZnJvbQpbU3BsaXQgQ29tcHV0ZS1QbGFuZSBJbnN0YWxsYXRpb25dKGNvbXB1dGUtcGxh" + + "bmUtaW5zdGFsbGF0aW9uLm1kKS4gQQpDTEktcHJvZmlsZSBpbnN0YWxsYXRpb24gbXVzdCByZW1h" + + "aW4gcHJvZmlsZS1kcml2ZW47IGEgSGVsbWZpbGUgaW5zdGFsbGF0aW9uCm11c3QgcmVtYWluIHZh" + + "bHVlcy1kcml2ZW4uCgpFeGlzdGluZyBMTE0gZnVuY3Rpb24gcG9kcyBrZWVwIHRoZWlyIGV4aXN0" + + "aW5nIHNpZGVjYXIgYXJndW1lbnRzLiBSZWNyZWF0ZSBvcgpyZWRlcGxveSB0aG9zZSBmdW5jdGlv" + + "bnMgYWZ0ZXIgdGhlIGNvbXB1dGUtcGxhbmUgcmVmcmVzaC4gVmVyaWZ5IHRoZSBjb250cm9sCnBs" + + "YW5lLCByb3V0ZSwgYW5kIHdvcmtlciBzaWRlY2FyOgoKYGBgYmFzaAprdWJlY3RsIGdldCBkZXBs" + + "b3kgLW4gbnZjZiBsbG0tYXBpLWdhdGV3YXkKa3ViZWN0bCBnZXQgc3RhdGVmdWxzZXQgLW4gbnZj" + + "ZiBsbG0tcmVxdWVzdC1yb3V0ZXIKa3ViZWN0bCBnZXQgcG9kcyAtbiBudmNmIHwgZ3JlcCAtRSAn" + + "bGxtLWFwaS1nYXRld2F5fGxsbS1yZXF1ZXN0LXJvdXRlcicKa3ViZWN0bCBnZXQgaHR0cHJvdXRl" + + "IC1BIHwgZ3JlcCBsbG0Ka3ViZWN0bCAtbiBudmNmLWJhY2tlbmQgZ2V0IHBvZCA8ZnVuY3Rpb24t" + + "cG9kPiBcCiAgLW8ganNvbnBhdGg9J3tyYW5nZSAuc3BlYy5jb250YWluZXJzWz8oQC5uYW1lPT0i" + + "bGxtLXdvcmtlciIpXS5hcmdzWypdfXsufXsiXFxuIn17ZW5kfScKYGBgCgpGb3IgbG9jYWwgcGxh" + + "aW50ZXh0IGNsdXN0ZXJzLCB0aGUgYGxsbS13b3JrZXJgIGFyZ3MgbXVzdCBpbmNsdWRlCmAtLXF1" + + "aWMtaW5zZWN1cmVgLgoKRm9yIGxvYWQtYmFsYW5jZXIgc2NoZW1hIGFuZCBhbGdvcml0aG0gYmVo" + + "YXZpb3IsIHNlZSB0aGUKW1N0YXJnYXRlIGNvbmZpZ3VyYXRpb24gZ3VpZGVdKGh0dHBzOi8vZ2l0" + + "aHViLmNvbS9OVklESUEvbnZjZi9ibG9iL21haW4vc3JjL2xpYnJhcmllcy9ydXN0L3N0YXJnYXRl" + + "L2RvY3MvbG9hZC1iYWxhbmNlci1jb25maWd1cmF0aW9uLm1kKS4KCiMjIEhlbG1maWxlIFNlbGVj" + + "dG9ycwoKVGFyZ2V0IHNwZWNpZmljIHJlbGVhc2VzIG9yIGdyb3VwczoKCmBgYGJhc2gKIyBCeSBy" + + "ZWxlYXNlIGdyb3VwCkhFTE1GSUxFX0VOVj08ZW52PiBoZWxtZmlsZSAtLXNlbGVjdG9yIHJlbGVh" + + "c2UtZ3JvdXA9ZGVwZW5kZW5jaWVzIHN5bmMKSEVMTUZJTEVfRU5WPTxlbnY+IGhlbG1maWxlIC0t" + + "c2VsZWN0b3IgcmVsZWFzZS1ncm91cD1zZXJ2aWNlcyBzeW5jCkhFTE1GSUxFX0VOVj08ZW52PiBo" + + "ZWxtZmlsZSAtLXNlbGVjdG9yIHJlbGVhc2UtZ3JvdXA9aW5ncmVzcyBzeW5jCkhFTE1GSUxFX0VO" + + "Vj08ZW52PiBoZWxtZmlsZSAtLXNlbGVjdG9yIHJlbGVhc2UtZ3JvdXA9b2JzZXJ2YWJpbGl0eSBz" + + "eW5jCgojIEJ5IHJlbGVhc2UgbmFtZQpIRUxNRklMRV9FTlY9PGVudj4gaGVsbWZpbGUgLS1zZWxl" + + "Y3RvciBuYW1lPWNhc3NhbmRyYSBzeW5jCkhFTE1GSUxFX0VOVj08ZW52PiBoZWxtZmlsZSAtLXNl" + + "bGVjdG9yIG5hbWU9YWRtaW4taXNzdWVyLXByb3h5IHN5bmMKSEVMTUZJTEVfRU5WPTxlbnY+IGhl" + + "bG1maWxlIC0tc2VsZWN0b3IgbmFtZT1sbG0tcmVxdWVzdC1yb3V0ZXIgc3luYwpIRUxNRklMRV9F" + + "TlY9PGVudj4gaGVsbWZpbGUgLS1zZWxlY3RvciBuYW1lPWxsbS1hcGktZ2F0ZXdheSBzeW5jCgoj" + + "IFRlbXBsYXRlIG9ubHkgKGRyeSBydW4pCkhFTE1GSUxFX0VOVj08ZW52PiBoZWxtZmlsZSAtLXNl" + + "bGVjdG9yIG5hbWU9Y2Fzc2FuZHJhIHRlbXBsYXRlCgojIERlc3Ryb3kgYSBzaW5nbGUgcmVsZWFz" + + "ZQpIRUxNRklMRV9FTlY9PGVudj4gaGVsbWZpbGUgLS1zZWxlY3RvciBuYW1lPWNhc3NhbmRyYSBk" + + "ZXN0cm95CmBgYAoKTm90ZTogYGFkbWluLWlzc3Vlci1wcm94eWAgaGFzIG5vIGByZWxlYXNlLWdy" + + "b3VwYCBsYWJlbC4gVXNlIGAtLXNlbGVjdG9yIG5hbWU9YWRtaW4taXNzdWVyLXByb3h5YC4KUEsH" + + "CMBWIOePJwAAjycAAFBLAwQUAAgAAAAAACEAAAAAAAAAAAAAAAAAPwAJAGRhdGEvbnZjZi1zZWxm" + + "LW1hbmFnZWQtaW5zdGFsbGF0aW9uL3JlZmVyZW5jZXMvbnZjZi11aS1hZGRvbi5tZFVUBQABAKbO" + + "EiMgTlZDRiBVSSBBZGRvbgoKTlZDRiBVSSBpcyBhbiBvcHRpb25hbCwgY3VzdG9tZXItZmFjaW5n" + + "IE5WQ0YgYWRtaW4tcGFuZWwgVUkuIEl0IGlzIGRpc2FibGVkIGJ5CmRlZmF1bHQgYW5kIGF2YWls" + + "YWJsZSBvbmx5IGluIHN0YWNrIHBhY2thZ2VzIHRoYXQgaW5jbHVkZSB0aGUgTlZDRiBVSSBhZGRv" + + "bi4KCiMjIFdoZW4gdG8gZW5hYmxlCgpFbmFibGUgTlZDRiBVSSBvbmx5IHdoZW4geW91IG5lZWQg" + + "dGhlIGFkbWluLXBhbmVsIFVJIGFuZCB5b3VyIGV4dHJhY3RlZCBzdGFjawpwYWNrYWdlIGluY2x1" + + "ZGVzIHRoZSBhZGRvbi4gSWYgdGhlIHBhY2thZ2UgZG9lcyBub3QgY29udGFpbiBhIGBudmNmLXVp" + + "YCByZWxlYXNlCmFuZCBgbnZjZlVpYCByb3V0ZSB2YWx1ZXMsIHNraXAgdGhlIGFkZG9uIHVudGls" + + "IHlvdSB1c2UgYSBwYWNrYWdlIHRoYXQgaW5jbHVkZXMKdGhlbS4KCiMjIEVuYWJsZSB0aGUgYWRk" + + "b24KCkVuYWJsZSBpdCBpbiBgZW52aXJvbm1lbnRzLzxlbnYtbmFtZT4ueWFtbGA6CgpgYGB5YW1s" + + "CmFkZG9uczoKICBudmNmVWk6CiAgICBlbmFibGVkOiB0cnVlCmBgYAoKIyMgQ3JlYXRlIG5hbWVz" + + "cGFjZSBhbmQgaW1hZ2UgcHVsbCBzZWNyZXQKCkNyZWF0ZSB0aGUgbmFtZXNwYWNlLCBhbmQgYW4g" + + "aW1hZ2UgcHVsbCBzZWNyZXQgb25seSBpZiBwdWxsaW5nIGZyb20gYSBwcml2YXRlCnJlZ2lzdHJ5" + + "OgoKYGBgYmFzaAprdWJlY3RsIGNyZWF0ZSBuYW1lc3BhY2UgbnZjZi11aSAtLWRyeS1ydW49Y2xp" + + "ZW50IC1vIHlhbWwgfCBrdWJlY3RsIGFwcGx5IC1mIC0KCiMgT25seSBpZiBwdWxsaW5nIGZyb20g" + + "YSBwcml2YXRlIHJlZ2lzdHJ5IChlLmcuLCBOR0MgbnZjci5pbykKZXhwb3J0IE5HQ19BUElfS0VZ" + + "PSI8eW91ci1rZXk+IgprdWJlY3RsIGNyZWF0ZSBzZWNyZXQgZG9ja2VyLXJlZ2lzdHJ5IG52Y3It" + + "Y3JlZHMgXAogIC0tZG9ja2VyLXNlcnZlcj1udmNyLmlvIFwKICAtLWRvY2tlci11c2VybmFtZT0n" + + "JG9hdXRodG9rZW4nIFwKICAtLWRvY2tlci1wYXNzd29yZD0iJE5HQ19BUElfS0VZIiBcCiAgLS1u" + + "YW1lc3BhY2U9bnZjZi11aSBcCiAgLS1kcnktcnVuPWNsaWVudCAtbyB5YW1sIHwga3ViZWN0bCBh" + + "cHBseSAtZiAtCmBgYAoKVGhlIGRlZmF1bHQgcm91dGUgaG9zdCBpcyBgbnZjZi11aS48ZG9tYWlu" + + "PmAgYW5kIHRoZSBiYWNrZW5kIGlzCmBudmNmLXVpLm52Y2YtdWk6ODMwMGAuCgojIyBBcHBseSB0" + + "aGUgc2VydmljZSBhbmQgcm91dGUKCkFmdGVyIGNvbmZpcm1pbmcgdGhlIHBhY2thZ2UgaW5jbHVk" + + "ZXMgdGhlIGBudmNmLXVpYCByZWxlYXNlLCBwcmV2aWV3IGFuZCBhcHBseQp0aGUgc2VydmljZSBh" + + "bmQgcm91dGU6CgpgYGBiYXNoCkhFTE1GSUxFX0VOVj08ZW52LW5hbWU+IGhlbG1maWxlIC0tc2Vs" + + "ZWN0b3IgbmFtZT1udmNmLXVpIHRlbXBsYXRlCkhFTE1GSUxFX0VOVj08ZW52LW5hbWU+IGhlbG1m" + + "aWxlIC0tc2VsZWN0b3IgbmFtZT1udmNmLXVpIHN5bmMKSEVMTUZJTEVfRU5WPTxlbnYtbmFtZT4g" + + "aGVsbWZpbGUgLS1zZWxlY3RvciByZWxlYXNlLWdyb3VwPWluZ3Jlc3Mgc3luYwpgYGAKCiMjIFZl" + + "cmlmeQoKVmVyaWZ5IHRoZSByb3V0ZSBvbmx5IHdoZW4gdGhlIGFkZG9uIGlzIHByZXNlbnQgYW5k" + + "IGVuYWJsZWQ6CgpgYGBiYXNoCmt1YmVjdGwgZ2V0IGRlcGxveSxzdmMgLW4gbnZjZi11aQprdWJl" + + "Y3RsIGdldCBodHRwcm91dGUgLUEgfCBncmVwIC1pIG52Y2YtdWkKY3VybCAtaSAtSCAiSG9zdDog" + + "bnZjZi11aS48ZG9tYWluPiIgImh0dHA6Ly88Z2F0ZXdheS1hZGRyZXNzPi9zdGF0dXMiCmBgYAoK" + + "IyMgU2VjdXJpdHkKClRoZSBOVkNGIFVJIGFkbWluIHBhbmVsIGlzIGN1cnJlbnRseSB1bmF1dGhl" + + "bnRpY2F0ZWQuIERvIG5vdCBleHBvc2UgaXQgdG8gdGhlCnB1YmxpYyBpbnRlcm5ldC4gUmVzdHJp" + + "Y3QgYWNjZXNzIHRvIGEgdHJ1c3RlZCBuZXR3b3JrLCBWUE4sIG9yIGFuIGF1dGhlbnRpY2F0aW5n" + + "CnByb3h5IGluIGZyb250IG9mIHRoZSBgbnZjZi11aWAgcm91dGUuClBLBwg4+SevuQcAALkHAABQ" + + "SwMEFAAIAAAAAAAhAAAAAAAAAAAAAAAAAD4ACQBkYXRhL252Y2Ytc2VsZi1tYW5hZ2VkLWluc3Rh" + + "bGxhdGlvbi9yZWZlcmVuY2VzL3B1bGwtc2VjcmV0cy5tZFVUBQABAKbOEiMgSW1hZ2UgUHVsbCBT" + + "ZWNyZXRzIFJlZmVyZW5jZQoKIyMgT3ZlcnZpZXcKCldoZW4gcHVsbGluZyBOVkNGIGltYWdlcyBm" + + "cm9tIGEgcHJpdmF0ZSByZWdpc3RyeSAoZm9yIGV4YW1wbGUsIE5HQwpgbnZjci5pb2ApLCBLdWJl" + + "cm5ldGVzIG5lZWRzIGBpbWFnZVB1bGxTZWNyZXRzYCBvbiBldmVyeSBwb2QuIENvbnRyb2wtcGxh" + + "bmUgYW5kCmNvbXB1dGUtcGxhbmUgY3JlZGVudGlhbHMgYXJlIGNvbmZpZ3VyZWQgaW4gdGhlaXIg" + + "b3duIGNsdXN0ZXIgY29udGV4dHMuIERvIG5vdAp1c2Ugb25lIG1peGVkIG5hbWVzcGFjZSBsaXN0" + + "LgoKVGhlIHJlY29tbWVuZGVkIGNvbnRyb2wtcGxhbmUgYXBwcm9hY2ggdXNlcyBLeXZlcm5vIHRv" + + "IGluamVjdCB0aGUgc2VjcmV0IGludG8KY29udHJvbC1wbGFuZSBwb2RzIGF0IGFkbWlzc2lvbiB0" + + "aW1lLiBUaGUgY29tcHV0ZS1wbGFuZSBjaGFydCBhbmQgb3BlcmF0b3IgdXNlCnRoZSBzZWNyZXQg" + + "aW4gYG52Y2Etb3BlcmF0b3JgIGFuZCBtaXJyb3IgaXQgdG8gYG52Y2Etc3lzdGVtYC4KCiMjIEt5" + + "dmVybm8gQXBwcm9hY2ggKFJlY29tbWVuZGVkKQoKIyMjIDEuIEluc3RhbGwgS3l2ZXJubwoKYGBg" + + "YmFzaApoZWxtIHJlcG8gYWRkIGt5dmVybm8gaHR0cHM6Ly9reXZlcm5vLmdpdGh1Yi5pby9reXZl" + + "cm5vLwpoZWxtIHJlcG8gdXBkYXRlCmhlbG0gaW5zdGFsbCBreXZlcm5vIGt5dmVybm8va3l2ZXJu" + + "byAtbiBreXZlcm5vIC0tY3JlYXRlLW5hbWVzcGFjZSBcCiAgLS1rdWJlLWNvbnRleHQgPGNvbnRy" + + "b2wtcGxhbmUtY29udGV4dD4KYGBgCgojIyMgMi4gQ3JlYXRlIGNvbnRyb2wtcGxhbmUgcHVsbCBz" + + "ZWNyZXRzCgpgYGBiYXNoCmV4cG9ydCBOR0NfQVBJX0tFWT0iPHlvdXItbmdjLWFwaS1rZXk+IgoK" + "Zm9yIG5zIGluIGNhc3NhbmRyYS1zeXN0ZW0gbmF0cy1zeXN0ZW0gbnZjZiBhcGkta2V5cyBlc3Mg" + "c2lzIHZhdWx0LXN5c3RlbSBjZXJ0LW1hbmFnZXI7IGRvCiAga3ViZWN0bCAtLWNvbnRleHQgPGNv" + - "bnRyb2wtcGxhbmUtY29udGV4dD4gY3JlYXRlIHNlY3JldCBkb2NrZXItcmVnaXN0cnkgbnZjci1j" + - "cmVkcyBcCiAgICAtLWRvY2tlci1zZXJ2ZXI9bnZjci5pbyBcCiAgICAtLWRvY2tlci11c2VybmFt" + - "ZT0nJG9hdXRodG9rZW4nIFwKICAgIC0tZG9ja2VyLXBhc3N3b3JkPSIkTkdDX0FQSV9LRVkiIFwK" + - "ICAgIC0tbmFtZXNwYWNlPSIkbnMiIFwKICAgIC0tZHJ5LXJ1bj1jbGllbnQgLW8geWFtbCB8IGt1" + - "YmVjdGwgLS1jb250ZXh0IDxjb250cm9sLXBsYW5lLWNvbnRleHQ+IGFwcGx5IC1mIC0KZG9uZQpg" + - "YGAKCkZvciBub24tTkdDIHJlZ2lzdHJpZXMsIHJlcGxhY2UgYC0tZG9ja2VyLXNlcnZlcmAsIGAt" + - "LWRvY2tlci11c2VybmFtZWAsIGFuZCBgLS1kb2NrZXItcGFzc3dvcmRgLgoKIyMjIDMuIEFwcGx5" + - "IEt5dmVybm8gQ2x1c3RlclBvbGljeQoKYGBgeWFtbAphcGlWZXJzaW9uOiBreXZlcm5vLmlvL3Yx" + - "CmtpbmQ6IENsdXN0ZXJQb2xpY3kKbWV0YWRhdGE6CiAgbmFtZTogbnZjZi1hZGQtaW1hZ2VwdWxs" + - "c2VjcmV0cwpzcGVjOgogIGJhY2tncm91bmQ6IGZhbHNlCiAgcnVsZXM6CiAgICAtIG5hbWU6IGFk" + - "ZC1pbWFnZXB1bGxzZWNyZXQtdG8tbnZjZi1wb2RzCiAgICAgIG1hdGNoOgogICAgICAgIGFueToK" + - "ICAgICAgICAtIHJlc291cmNlczoKICAgICAgICAgICAga2luZHM6CiAgICAgICAgICAgIC0gUG9k" + - "CiAgICAgICAgICAgIG5hbWVzcGFjZXM6CiAgICAgICAgICAgIC0gIm52Y2YiCiAgICAgICAgICAg" + - "IC0gImFwaS1rZXlzIgogICAgICAgICAgICAtICJzaXMiCiAgICAgICAgICAgIC0gImVzcyIKICAg" + - "ICAgICAgICAgLSAibmF0cy1zeXN0ZW0iCiAgICAgICAgICAgIC0gImNhc3NhbmRyYS1zeXN0ZW0i" + - "CiAgICAgICAgICAgIC0gInZhdWx0LXN5c3RlbSIKICAgICAgICAgICAgLSAiY2VydC1tYW5hZ2Vy" + - "IgogICAgICBtdXRhdGU6CiAgICAgICAgcGF0Y2hTdHJhdGVnaWNNZXJnZToKICAgICAgICAgIG1l" + - "dGFkYXRhOgogICAgICAgICAgICBhbm5vdGF0aW9uczoKICAgICAgICAgICAgICBudmNmLm52aWRp" + - "YS5jb20vaW1hZ2VwdWxsc2VjcmV0LWluamVjdGVkLWJ5OiBreXZlcm5vCiAgICAgICAgICBzcGVj" + - "OgogICAgICAgICAgICBpbWFnZVB1bGxTZWNyZXRzOgogICAgICAgICAgICAtIG5hbWU6IG52Y3It" + - "Y3JlZHMKYGBgCgpgYGBiYXNoCmt1YmVjdGwgLS1jb250ZXh0IDxjb250cm9sLXBsYW5lLWNvbnRl" + - "eHQ+IGFwcGx5IFwKICAtZiBreXZlcm5vLWltYWdlcHVsbHNlY3JldC1wb2xpY3kueWFtbApgYGAK" + - "CiMjIyA0LiBJbnN0YWxsIHRoZSBjb250cm9sIHBsYW5lCgpDb250aW51ZSB3aXRoIHRoZSBzZWxl" + - "Y3RlZCBjb250cm9sLXBsYW5lIGluc3RhbGxhdGlvbiBpbgpbU3BsaXQgQ29tcHV0ZS1QbGFuZSBJ" + - "bnN0YWxsYXRpb25dKGNvbXB1dGUtcGxhbmUtaW5zdGFsbGF0aW9uLm1kKS4gTm8KY29udHJvbC1w" + - "bGFuZSBoZWxtZmlsZSBtb2RpZmljYXRpb25zIGFyZSBuZWVkZWQuIEt5dmVybm8gaW5qZWN0cyB0" + - "aGUgcHVsbApzZWNyZXQgaW50byBuZXcgY29udHJvbC1wbGFuZSBwb2RzLgoKIyMgQ29tcHV0ZS1Q" + - "bGFuZSBTZWNyZXQKCkNyZWF0ZSB0aGUgc2VjcmV0IG9ubHkgaW4gYG52Y2Etb3BlcmF0b3JgIG9u" + - "IHRoZSBjb21wdXRlIGNsdXN0ZXI6CgpgYGBiYXNoCmt1YmVjdGwgLS1jb250ZXh0IDxjb21wdXRl" + - "LXBsYW5lLWNvbnRleHQ+IGNyZWF0ZSBuYW1lc3BhY2UgbnZjYS1vcGVyYXRvciBcCiAgLS1kcnkt" + - "cnVuPWNsaWVudCAtbyB5YW1sIHwgXAogIGt1YmVjdGwgLS1jb250ZXh0IDxjb21wdXRlLXBsYW5l" + - "LWNvbnRleHQ+IGFwcGx5IC1mIC0KCmt1YmVjdGwgLS1jb250ZXh0IDxjb21wdXRlLXBsYW5lLWNv" + - "bnRleHQ+IGNyZWF0ZSBzZWNyZXQgZG9ja2VyLXJlZ2lzdHJ5IG52Y3ItY3JlZHMgXAogIC0tZG9j" + - "a2VyLXNlcnZlcj1udmNyLmlvIFwKICAtLWRvY2tlci11c2VybmFtZT0nJG9hdXRodG9rZW4nIFwK" + - "ICAtLWRvY2tlci1wYXNzd29yZD0iJE5HQ19BUElfS0VZIiBcCiAgLS1uYW1lc3BhY2U9bnZjYS1v" + - "cGVyYXRvciBcCiAgLS1kcnktcnVuPWNsaWVudCAtbyB5YW1sIHwgXAogIGt1YmVjdGwgLS1jb250" + - "ZXh0IDxjb21wdXRlLXBsYW5lLWNvbnRleHQ+IGFwcGx5IC1mIC0KYGBgCgpSZWZlcmVuY2UgaXQg" + - "aW4gdGhlIGNvbXB1dGUtcGxhbmUgZW52aXJvbm1lbnQgZmlsZToKCmBgYHlhbWwKZ2xvYmFsOgog" + - "IGltYWdlUHVsbFNlY3JldHM6CiAgICAtIG5hbWU6IG52Y3ItY3JlZHMKYGBgCgpUaGUgY2hhcnQg" + - "YW5kIG9wZXJhdG9yIHVzZSB0aGF0IHJlZmVyZW5jZSBpbiBgbnZjYS1vcGVyYXRvcmAgYW5kIG1p" + - "cnJvciB0aGUKc2VjcmV0IHRvIGBudmNhLXN5c3RlbWAuIERvIG5vdCBjcmVhdGUgYSBicm9hZGVy" + - "IG1hbnVhbCBjb21wdXRlIG5hbWVzcGFjZSBsaXN0LiBGb2xsb3cKW1NwbGl0IENvbXB1dGUtUGxh" + - "bmUgSW5zdGFsbGF0aW9uXShjb21wdXRlLXBsYW5lLWluc3RhbGxhdGlvbi5tZCkgZm9yIHRoZQpz" + - "ZWxlY3RlZCBpbnN0YWxsIGZsb3cuCgojIyBWZXJpZmljYXRpb24KCmBgYGJhc2gKIyBDaGVjayB0" + - "aGF0IGEgY29udHJvbC1wbGFuZSBwb2QgaGFzIHRoZSBpbmplY3RlZCBzZWNyZXQKa3ViZWN0bCAt" + - "LWNvbnRleHQgPGNvbnRyb2wtcGxhbmUtY29udGV4dD4gZ2V0IHBvZCAtbiA8bmFtZXNwYWNlPiA8" + - "cG9kLW5hbWU+IFwKICAtbyBqc29ucGF0aD0ney5zcGVjLmltYWdlUHVsbFNlY3JldHN9JwojIEV4" + - "cGVjdGVkOiBbeyJuYW1lIjoibnZjci1jcmVkcyJ9XQoKIyBDaGVjayB0aGUgS3l2ZXJubyBhbm5v" + - "dGF0aW9uCmt1YmVjdGwgLS1jb250ZXh0IDxjb250cm9sLXBsYW5lLWNvbnRleHQ+IGdldCBwb2Qg" + - "LW4gPG5hbWVzcGFjZT4gPHBvZC1uYW1lPiBcCiAgLW8ganNvbnBhdGg9J3subWV0YWRhdGEuYW5u" + - "b3RhdGlvbnMubnZjZlwubnZpZGlhXC5jb20vaW1hZ2VwdWxsc2VjcmV0LWluamVjdGVkLWJ5fScK" + - "IyBFeHBlY3RlZDoga3l2ZXJubwoKIyBDaGVjayBwdWxsIGV2ZW50cwprdWJlY3RsIC0tY29udGV4" + - "dCA8Y29udHJvbC1wbGFuZS1jb250ZXh0PiBnZXQgZXZlbnRzIC1uIDxuYW1lc3BhY2U+IFwKICAt" + - "LXNvcnQtYnk9Jy5sYXN0VGltZXN0YW1wJyB8IGdyZXAgLWkgcHVsbAojIFNob3VsZCBzaG93ICJT" + - "dWNjZXNzZnVsbHkgcHVsbGVkIiBub3QgIjQwMSBVbmF1dGhvcml6ZWQiCgojIENoZWNrIHRoZSBj" + - "aGFydC9vcGVyYXRvciBtaXJyb3Igb24gdGhlIGNvbXB1dGUgY2x1c3RlcgprdWJlY3RsIC0tY29u" + - "dGV4dCA8Y29tcHV0ZS1wbGFuZS1jb250ZXh0PiBnZXQgc2VjcmV0IG52Y3ItY3JlZHMgXAogIC1u" + - "IG52Y2Etc3lzdGVtCmBgYAoKIyMgV2hlbiBQdWxsIFNlY3JldHMgQXJlIE5vdCBOZWVkZWQKCi0g" + - "KipBV1MgRUNSIHdpdGggSUFNIG5vZGUgcm9sZXMqKjogSWYgeW91ciBub2RlcyBoYXZlIGBBbWF6" + - "b25FQzJDb250YWluZXJSZWdpc3RyeVJlYWRPbmx5YCBJQU0gcG9saWN5LCBLdWJlcm5ldGVzIGNh" + - "biBwdWxsIGZyb20gRUNSIHdpdGhvdXQgZXhwbGljaXQgc2VjcmV0cy4KLSAqKlB1YmxpYyByZWdp" + - "c3RyaWVzKio6IE5vIHB1bGwgc2VjcmV0cyBuZWVkZWQuCi0gKipDU1AgYnVpbHQtaW4gY3JlZGVu" + - "dGlhbCBoZWxwZXJzKio6IEdLRSBBcnRpZmFjdCBSZWdpc3RyeSwgQXp1cmUgQUNSIHdpdGggbWFu" + - "YWdlZCBpZGVudGl0eSwgYW5kIHNpbWlsYXIgc2VydmljZXMuCgojIyBUcm91Ymxlc2hvb3RpbmcK" + - "CiMjIyBQb2RzIHN0aWxsIGluIEltYWdlUHVsbEJhY2tPZmYgYWZ0ZXIgYXBwbHlpbmcgcG9saWN5" + - "CgpUaGUgS3l2ZXJubyBwb2xpY3kgb25seSBhZmZlY3RzIHBvZHMgY3JlYXRlZCAqKmFmdGVyKiog" + - "dGhlIHBvbGljeSBpcyBhcHBsaWVkLiBEZWxldGUgc3R1Y2sgcG9kcyB0byB0cmlnZ2VyIHJlY3Jl" + - "YXRpb246CgpgYGBiYXNoCmt1YmVjdGwgLS1jb250ZXh0IDx0YXJnZXQtY29udGV4dD4gZGVsZXRl" + - "IHBvZHMgLW4gPG5hbWVzcGFjZT4gLS1hbGwKYGBgCgojIyMgS3l2ZXJubyBhZG1pc3Npb24gY29u" + - "dHJvbGxlciBub3QgcnVubmluZwoKYGBgYmFzaAprdWJlY3RsIC0tY29udGV4dCA8Y29udHJvbC1w" + - "bGFuZS1jb250ZXh0PiBnZXQgcG9kcyAtbiBreXZlcm5vCiMgQWxsIHBvZHMgc2hvdWxkIGJlIFJ1" + - "bm5pbmcKYGBgCgojIyMgUG9saWN5IG5vdCBtYXRjaGluZwoKYGBgYmFzaAprdWJlY3RsIC0tY29u" + - "dGV4dCA8Y29udHJvbC1wbGFuZS1jb250ZXh0PiBnZXQgY2x1c3RlcnBvbGljeSBudmNmLWFkZC1p" + - "bWFnZXB1bGxzZWNyZXRzCiMgU2hvdWxkIHNob3cgUkVBRFk6IFRydWUKYGBgCgojIyMgV3Jvbmcg" + - "c2VjcmV0IG5hbWUKClRoZSBwb2xpY3kgcmVmZXJlbmNlcyBgbnZjci1jcmVkc2AuIFZlcmlmeSB0" + - "aGUgc2VjcmV0IGV4aXN0cyB3aXRoIHRoYXQgZXhhY3QgbmFtZToKCmBgYGJhc2gKa3ViZWN0bCAt" + - "LWNvbnRleHQgPHRhcmdldC1jb250ZXh0PiBnZXQgc2VjcmV0IG52Y3ItY3JlZHMgLW4gPG5hbWVz" + - "cGFjZT4KYGBgClBLBwhLQjWoABYAAAAWAABQSwECFAAUAAgAAAAAACEA0GJVtkkQAABJEAAAEgAJ" + - "AAAAAAAAAAAAAAAAAAAAZGF0YS9tYW5pZmVzdC5qc29uVVQFAAEAps4SUEsBAhQAFAAIAAAAAAAh" + - "AM2BMORNYQAATWEAACMACQAAAAAAAAAAAAAAkhAAAGRhdGEvbnZjZi1zZWxmLW1hbmFnZWQtY2xp" + - "L1NLSUxMLm1kVVQFAAEAps4SUEsBAhQAFAAIAAAAAAAhACHGyIbwCgAA8AoAADMACQAAAAAAAAAA" + - "AAAAOXIAAGRhdGEvbnZjZi1zZWxmLW1hbmFnZWQtY2xpL2V4YW1wbGVzL2NpLXBpcGVsaW5lcy5t" + - "ZFVUBQABAKbOElBLAQIUABQACAAAAAAAIQChFOOBXQwAAF0MAAA0AAkAAAAAAAAAAAAAAJN9AABk" + - "YXRhL252Y2Ytc2VsZi1tYW5hZ2VkLWNsaS9leGFtcGxlcy9tdWx0aS1jbHVzdGVyLm1kVVQFAAEA" + - "ps4SUEsBAhQAFAAIAAAAAAAhAEInSQ8FDQAABQ0AADcACQAAAAAAAAAAAAAAW4oAAGRhdGEvbnZj" + - "Zi1zZWxmLW1hbmFnZWQtY2xpL3Byb21wdHMvYWRkLWNvbXB1dGUtcGxhbmUubWRVVAUAAQCmzhJQ" + - "SwECFAAUAAgAAAAAACEAkdwb+ZgZAACYGQAAOQAJAAAAAAAAAAAAAADOlwAAZGF0YS9udmNmLXNl" + - "bGYtbWFuYWdlZC1jbGkvcHJvbXB0cy9jcmVhdGUtYW5kLXJ1bi10YXNrLm1kVVQFAAEAps4SUEsB" + - "AhQAFAAIAAAAAAAhANJD3AQYJQAAGCUAADcACQAAAAAAAAAAAAAA1rEAAGRhdGEvbnZjZi1zZWxm" + - "LW1hbmFnZWQtY2xpL3Byb21wdHMvZGVwbG95LWFuZC1pbnZva2UubWRVVAUAAQCmzhJQSwECFAAU" + - "AAgAAAAAACEADpw/l70OAAC9DgAAPQAJAAAAAAAAAAAAAABc1wAAZGF0YS9udmNmLXNlbGYtbWFu" + - "YWdlZC1jbGkvcHJvbXB0cy9kaWFnbm9zZS1mYWlsZWQtaW5zdGFsbC5tZFVUBQABAKbOElBLAQIU" + - "ABQACAAAAAAAIQBCceYeASgAAAEoAAA6AAkAAAAAAAAAAAAAAI3mAABkYXRhL252Y2Ytc2VsZi1t" + - "YW5hZ2VkLWNsaS9wcm9tcHRzL2luc3RhbGwtZnJvbS1zY3JhdGNoLm1kVVQFAAEAps4SUEsBAhQA" + - "FAAIAAAAAAAhABrELJ7HBwAAxwcAADkACQAAAAAAAAAAAAAA/w4BAGRhdGEvbnZjZi1zZWxmLW1h" + - "bmFnZWQtY2xpL3Byb21wdHMvcm90YXRlLWNsdXN0ZXItandrcy5tZFVUBQABAKbOElBLAQIUABQA" + - "CAAAAAAAIQASkzNZ4CEAAOAhAAAuAAkAAAAAAAAAAAAAADYXAQBkYXRhL252Y2Ytc2VsZi1tYW5h" + - "Z2VkLWNsaS9wcm9tcHRzL3RlYXJkb3duLm1kVVQFAAEAps4SUEsBAhQAFAAIAAAAAAAhAHIND2Qh" + - "IwAAISMAADAACQAAAAAAAAAAAAAAezkBAGRhdGEvbnZjZi1zZWxmLW1hbmFnZWQtY2xpL3JlZmVy" + - "ZW5jZS9jb21tYW5kcy5tZFVUBQABAKbOElBLAQIUABQACAAAAAAAIQBzp1pk1QYAANUGAAAyAAkA" + - "AAAAAAAAAAAAAANdAQBkYXRhL252Y2Ytc2VsZi1tYW5hZ2VkLWNsaS9yZWZlcmVuY2UvZXhpdC1j" + - "b2Rlcy5tZFVUBQABAKbOElBLAQIUABQACAAAAAAAIQD8o5HgxiIAAMYiAAAtAAkAAAAAAAAAAAAA" + - "AEFkAQBkYXRhL252Y2Ytc2VsZi1tYW5hZ2VkLWNsaS9yZWZlcmVuY2UvZmxhZ3MubWRVVAUAAQCm" + - "zhJQSwECFAAUAAgAAAAAACEA864ThHQRAAB0EQAANwAJAAAAAAAAAAAAAABrhwEAZGF0YS9udmNm" + - "LXNlbGYtbWFuYWdlZC1jbGkvcmVmZXJlbmNlL3Ryb3VibGVzaG9vdGluZy5tZFVUBQABAKbOElBL" + - "AQIUABQACAAAAAAAIQAv2rl1QmIAAEJiAAAsAAkAAAAAAAAAAAAAAE2ZAQBkYXRhL252Y2Ytc2Vs" + - "Zi1tYW5hZ2VkLWluc3RhbGxhdGlvbi9TS0lMTC5tZFVUBQABAKbOElBLAQIUABQACAAAAAAAIQAr" + - "E7g/rVUAAK1VAAA0AAkAAAAAAAAAAAAAAPL7AQBkYXRhL252Y2Ytc2VsZi1tYW5hZ2VkLWluc3Rh" + - "bGxhdGlvbi9ldmFscy9ldmFscy5qc29uVVQFAAEAps4SUEsBAhQAFAAIAAAAAAAhAAJSTkB/KAAA" + - "fygAAC8ACQAAAAAAAAAAAAAAClICAGRhdGEvbnZjZi1zZWxmLW1hbmFnZWQtaW5zdGFsbGF0aW9u" + - "L2V4YW1wbGVzLm1kVVQFAAEAps4SUEsBAhQAFAAIAAAAAAAhAJZjvFkSMAAAEjAAAEwACQAAAAAA" + - "AAAAAAAA73oCAGRhdGEvbnZjZi1zZWxmLW1hbmFnZWQtaW5zdGFsbGF0aW9uL3JlZmVyZW5jZXMv" + - "Y29tcHV0ZS1wbGFuZS1pbnN0YWxsYXRpb24ubWRVVAUAAQCmzhJQSwECFAAUAAgAAAAAACEAVj5n" + - "kJUwAACVMAAAOwAJAAAAAAAAAAAAAACEqwIAZGF0YS9udmNmLXNlbGYtbWFuYWdlZC1pbnN0YWxs" + - "YXRpb24vcmVmZXJlbmNlcy9kZWJ1Z2dpbmcubWRVVAUAAQCmzhJQSwECFAAUAAgAAAAAACEAwFYg" + - "548nAACPJwAARAAJAAAAAAAAAAAAAACL3AIAZGF0YS9udmNmLXNlbGYtbWFuYWdlZC1pbnN0YWxs" + - "YXRpb24vcmVmZXJlbmNlcy9oZWxtZmlsZS1zdHJ1Y3R1cmUubWRVVAUAAQCmzhJQSwECFAAUAAgA" + - "AAAAACEAOPknr7kHAAC5BwAAPwAJAAAAAAAAAAAAAACVBAMAZGF0YS9udmNmLXNlbGYtbWFuYWdl" + - "ZC1pbnN0YWxsYXRpb24vcmVmZXJlbmNlcy9udmNmLXVpLWFkZG9uLm1kVVQFAAEAps4SUEsBAhQA" + - "FAAIAAAAAAAhAEtCNagAFgAAABYAAD4ACQAAAAAAAAAAAAAAxAwDAGRhdGEvbnZjZi1zZWxmLW1h" + - "bmFnZWQtaW5zdGFsbGF0aW9uL3JlZmVyZW5jZXMvcHVsbC1zZWNyZXRzLm1kVVQFAAEAps4SUEsF" + - "BgAAAAAXABcArwkAADkjAwAAAA==" + "bnRyb2wtcGxhbmUtY29udGV4dD4gY3JlYXRlIG5hbWVzcGFjZSAiJG5zIiBcCiAgICAtLWRyeS1y" + + "dW49Y2xpZW50IC1vIHlhbWwgfCBrdWJlY3RsIC0tY29udGV4dCA8Y29udHJvbC1wbGFuZS1jb250" + + "ZXh0PiBhcHBseSAtZiAtCmRvbmUKCmZvciBucyBpbiBjYXNzYW5kcmEtc3lzdGVtIG5hdHMtc3lz" + + "dGVtIG52Y2YgYXBpLWtleXMgZXNzIHNpcyB2YXVsdC1zeXN0ZW0gY2VydC1tYW5hZ2VyOyBkbwog" + + "IGt1YmVjdGwgLS1jb250ZXh0IDxjb250cm9sLXBsYW5lLWNvbnRleHQ+IGNyZWF0ZSBzZWNyZXQg" + + "ZG9ja2VyLXJlZ2lzdHJ5IG52Y3ItY3JlZHMgXAogICAgLS1kb2NrZXItc2VydmVyPW52Y3IuaW8g" + + "XAogICAgLS1kb2NrZXItdXNlcm5hbWU9JyRvYXV0aHRva2VuJyBcCiAgICAtLWRvY2tlci1wYXNz" + + "d29yZD0iJE5HQ19BUElfS0VZIiBcCiAgICAtLW5hbWVzcGFjZT0iJG5zIiBcCiAgICAtLWRyeS1y" + + "dW49Y2xpZW50IC1vIHlhbWwgfCBrdWJlY3RsIC0tY29udGV4dCA8Y29udHJvbC1wbGFuZS1jb250" + + "ZXh0PiBhcHBseSAtZiAtCmRvbmUKYGBgCgpGb3Igbm9uLU5HQyByZWdpc3RyaWVzLCByZXBsYWNl" + + "IGAtLWRvY2tlci1zZXJ2ZXJgLCBgLS1kb2NrZXItdXNlcm5hbWVgLCBhbmQgYC0tZG9ja2VyLXBh" + + "c3N3b3JkYC4KCiMjIyAzLiBBcHBseSBLeXZlcm5vIENsdXN0ZXJQb2xpY3kKCmBgYHlhbWwKYXBp" + + "VmVyc2lvbjoga3l2ZXJuby5pby92MQpraW5kOiBDbHVzdGVyUG9saWN5Cm1ldGFkYXRhOgogIG5h" + + "bWU6IG52Y2YtYWRkLWltYWdlcHVsbHNlY3JldHMKc3BlYzoKICBiYWNrZ3JvdW5kOiBmYWxzZQog" + + "IHJ1bGVzOgogICAgLSBuYW1lOiBhZGQtaW1hZ2VwdWxsc2VjcmV0LXRvLW52Y2YtcG9kcwogICAg" + + "ICBtYXRjaDoKICAgICAgICBhbnk6CiAgICAgICAgLSByZXNvdXJjZXM6CiAgICAgICAgICAgIGtp" + + "bmRzOgogICAgICAgICAgICAtIFBvZAogICAgICAgICAgICBuYW1lc3BhY2VzOgogICAgICAgICAg" + + "ICAtICJudmNmIgogICAgICAgICAgICAtICJhcGkta2V5cyIKICAgICAgICAgICAgLSAic2lzIgog" + + "ICAgICAgICAgICAtICJlc3MiCiAgICAgICAgICAgIC0gIm5hdHMtc3lzdGVtIgogICAgICAgICAg" + + "ICAtICJjYXNzYW5kcmEtc3lzdGVtIgogICAgICAgICAgICAtICJ2YXVsdC1zeXN0ZW0iCiAgICAg" + + "ICAgICAgIC0gImNlcnQtbWFuYWdlciIKICAgICAgbXV0YXRlOgogICAgICAgIHBhdGNoU3RyYXRl" + + "Z2ljTWVyZ2U6CiAgICAgICAgICBtZXRhZGF0YToKICAgICAgICAgICAgYW5ub3RhdGlvbnM6CiAg" + + "ICAgICAgICAgICAgbnZjZi5udmlkaWEuY29tL2ltYWdlcHVsbHNlY3JldC1pbmplY3RlZC1ieTog" + + "a3l2ZXJubwogICAgICAgICAgc3BlYzoKICAgICAgICAgICAgaW1hZ2VQdWxsU2VjcmV0czoKICAg" + + "ICAgICAgICAgLSBuYW1lOiBudmNyLWNyZWRzCmBgYAoKYGBgYmFzaAprdWJlY3RsIC0tY29udGV4" + + "dCA8Y29udHJvbC1wbGFuZS1jb250ZXh0PiBhcHBseSBcCiAgLWYga3l2ZXJuby1pbWFnZXB1bGxz" + + "ZWNyZXQtcG9saWN5LnlhbWwKYGBgCgojIyMgNC4gSW5zdGFsbCB0aGUgY29udHJvbCBwbGFuZQoK" + + "Q29udGludWUgd2l0aCB0aGUgc2VsZWN0ZWQgY29udHJvbC1wbGFuZSBpbnN0YWxsYXRpb24gaW4K" + + "W1NwbGl0IENvbXB1dGUtUGxhbmUgSW5zdGFsbGF0aW9uXShjb21wdXRlLXBsYW5lLWluc3RhbGxh" + + "dGlvbi5tZCkuIE5vCmNvbnRyb2wtcGxhbmUgaGVsbWZpbGUgbW9kaWZpY2F0aW9ucyBhcmUgbmVl" + + "ZGVkLiBLeXZlcm5vIGluamVjdHMgdGhlIHB1bGwKc2VjcmV0IGludG8gbmV3IGNvbnRyb2wtcGxh" + + "bmUgcG9kcy4KCiMjIENvbXB1dGUtUGxhbmUgU2VjcmV0CgpDcmVhdGUgdGhlIHNlY3JldCBvbmx5" + + "IGluIGBudmNhLW9wZXJhdG9yYCBvbiB0aGUgY29tcHV0ZSBjbHVzdGVyOgoKYGBgYmFzaAprdWJl" + + "Y3RsIC0tY29udGV4dCA8Y29tcHV0ZS1wbGFuZS1jb250ZXh0PiBjcmVhdGUgbmFtZXNwYWNlIG52" + + "Y2Etb3BlcmF0b3IgXAogIC0tZHJ5LXJ1bj1jbGllbnQgLW8geWFtbCB8IFwKICBrdWJlY3RsIC0t" + + "Y29udGV4dCA8Y29tcHV0ZS1wbGFuZS1jb250ZXh0PiBhcHBseSAtZiAtCgprdWJlY3RsIC0tY29u" + + "dGV4dCA8Y29tcHV0ZS1wbGFuZS1jb250ZXh0PiBjcmVhdGUgc2VjcmV0IGRvY2tlci1yZWdpc3Ry" + + "eSBudmNyLWNyZWRzIFwKICAtLWRvY2tlci1zZXJ2ZXI9bnZjci5pbyBcCiAgLS1kb2NrZXItdXNl" + + "cm5hbWU9JyRvYXV0aHRva2VuJyBcCiAgLS1kb2NrZXItcGFzc3dvcmQ9IiROR0NfQVBJX0tFWSIg" + + "XAogIC0tbmFtZXNwYWNlPW52Y2Etb3BlcmF0b3IgXAogIC0tZHJ5LXJ1bj1jbGllbnQgLW8geWFt" + + "bCB8IFwKICBrdWJlY3RsIC0tY29udGV4dCA8Y29tcHV0ZS1wbGFuZS1jb250ZXh0PiBhcHBseSAt" + + "ZiAtCmBgYAoKUmVmZXJlbmNlIGl0IGluIHRoZSBjb21wdXRlLXBsYW5lIGVudmlyb25tZW50IGZp" + + "bGU6CgpgYGB5YW1sCmdsb2JhbDoKICBpbWFnZVB1bGxTZWNyZXRzOgogICAgLSBuYW1lOiBudmNy" + + "LWNyZWRzCmBgYAoKVGhlIGNoYXJ0IGFuZCBvcGVyYXRvciB1c2UgdGhhdCByZWZlcmVuY2UgaW4g" + + "YG52Y2Etb3BlcmF0b3JgIGFuZCBtaXJyb3IgdGhlCnNlY3JldCB0byBgbnZjYS1zeXN0ZW1gLiBE" + + "byBub3QgY3JlYXRlIGEgYnJvYWRlciBtYW51YWwgY29tcHV0ZSBuYW1lc3BhY2UgbGlzdC4gRm9s" + + "bG93CltTcGxpdCBDb21wdXRlLVBsYW5lIEluc3RhbGxhdGlvbl0oY29tcHV0ZS1wbGFuZS1pbnN0" + + "YWxsYXRpb24ubWQpIGZvciB0aGUKc2VsZWN0ZWQgaW5zdGFsbCBmbG93LgoKIyMgVmVyaWZpY2F0" + + "aW9uCgpgYGBiYXNoCiMgQ2hlY2sgdGhhdCBhIGNvbnRyb2wtcGxhbmUgcG9kIGhhcyB0aGUgaW5q" + + "ZWN0ZWQgc2VjcmV0Cmt1YmVjdGwgLS1jb250ZXh0IDxjb250cm9sLXBsYW5lLWNvbnRleHQ+IGdl" + + "dCBwb2QgLW4gPG5hbWVzcGFjZT4gPHBvZC1uYW1lPiBcCiAgLW8ganNvbnBhdGg9J3suc3BlYy5p" + + "bWFnZVB1bGxTZWNyZXRzfScKIyBFeHBlY3RlZDogW3sibmFtZSI6Im52Y3ItY3JlZHMifV0KCiMg" + + "Q2hlY2sgdGhlIEt5dmVybm8gYW5ub3RhdGlvbgprdWJlY3RsIC0tY29udGV4dCA8Y29udHJvbC1w" + + "bGFuZS1jb250ZXh0PiBnZXQgcG9kIC1uIDxuYW1lc3BhY2U+IDxwb2QtbmFtZT4gXAogIC1vIGpz" + + "b25wYXRoPSd7Lm1ldGFkYXRhLmFubm90YXRpb25zLm52Y2ZcLm52aWRpYVwuY29tL2ltYWdlcHVs" + + "bHNlY3JldC1pbmplY3RlZC1ieX0nCiMgRXhwZWN0ZWQ6IGt5dmVybm8KCiMgQ2hlY2sgcHVsbCBl" + + "dmVudHMKa3ViZWN0bCAtLWNvbnRleHQgPGNvbnRyb2wtcGxhbmUtY29udGV4dD4gZ2V0IGV2ZW50" + + "cyAtbiA8bmFtZXNwYWNlPiBcCiAgLS1zb3J0LWJ5PScubGFzdFRpbWVzdGFtcCcgfCBncmVwIC1p" + + "IHB1bGwKIyBTaG91bGQgc2hvdyAiU3VjY2Vzc2Z1bGx5IHB1bGxlZCIgbm90ICI0MDEgVW5hdXRo" + + "b3JpemVkIgoKIyBDaGVjayB0aGUgY2hhcnQvb3BlcmF0b3IgbWlycm9yIG9uIHRoZSBjb21wdXRl" + + "IGNsdXN0ZXIKa3ViZWN0bCAtLWNvbnRleHQgPGNvbXB1dGUtcGxhbmUtY29udGV4dD4gZ2V0IHNl" + + "Y3JldCBudmNyLWNyZWRzIFwKICAtbiBudmNhLXN5c3RlbQpgYGAKCiMjIFdoZW4gUHVsbCBTZWNy" + + "ZXRzIEFyZSBOb3QgTmVlZGVkCgotICoqQVdTIEVDUiB3aXRoIElBTSBub2RlIHJvbGVzKio6IElm" + + "IHlvdXIgbm9kZXMgaGF2ZSBgQW1hem9uRUMyQ29udGFpbmVyUmVnaXN0cnlSZWFkT25seWAgSUFN" + + "IHBvbGljeSwgS3ViZXJuZXRlcyBjYW4gcHVsbCBmcm9tIEVDUiB3aXRob3V0IGV4cGxpY2l0IHNl" + + "Y3JldHMuCi0gKipQdWJsaWMgcmVnaXN0cmllcyoqOiBObyBwdWxsIHNlY3JldHMgbmVlZGVkLgot" + + "ICoqQ1NQIGJ1aWx0LWluIGNyZWRlbnRpYWwgaGVscGVycyoqOiBHS0UgQXJ0aWZhY3QgUmVnaXN0" + + "cnksIEF6dXJlIEFDUiB3aXRoIG1hbmFnZWQgaWRlbnRpdHksIGFuZCBzaW1pbGFyIHNlcnZpY2Vz" + + "LgoKIyMgVHJvdWJsZXNob290aW5nCgojIyMgUG9kcyBzdGlsbCBpbiBJbWFnZVB1bGxCYWNrT2Zm" + + "IGFmdGVyIGFwcGx5aW5nIHBvbGljeQoKVGhlIEt5dmVybm8gcG9saWN5IG9ubHkgYWZmZWN0cyBw" + + "b2RzIGNyZWF0ZWQgKiphZnRlcioqIHRoZSBwb2xpY3kgaXMgYXBwbGllZC4gRGVsZXRlIHN0dWNr" + + "IHBvZHMgdG8gdHJpZ2dlciByZWNyZWF0aW9uOgoKYGBgYmFzaAprdWJlY3RsIC0tY29udGV4dCA8" + + "dGFyZ2V0LWNvbnRleHQ+IGRlbGV0ZSBwb2RzIC1uIDxuYW1lc3BhY2U+IC0tYWxsCmBgYAoKIyMj" + + "IEt5dmVybm8gYWRtaXNzaW9uIGNvbnRyb2xsZXIgbm90IHJ1bm5pbmcKCmBgYGJhc2gKa3ViZWN0" + + "bCAtLWNvbnRleHQgPGNvbnRyb2wtcGxhbmUtY29udGV4dD4gZ2V0IHBvZHMgLW4ga3l2ZXJubwoj" + + "IEFsbCBwb2RzIHNob3VsZCBiZSBSdW5uaW5nCmBgYAoKIyMjIFBvbGljeSBub3QgbWF0Y2hpbmcK" + + "CmBgYGJhc2gKa3ViZWN0bCAtLWNvbnRleHQgPGNvbnRyb2wtcGxhbmUtY29udGV4dD4gZ2V0IGNs" + + "dXN0ZXJwb2xpY3kgbnZjZi1hZGQtaW1hZ2VwdWxsc2VjcmV0cwojIFNob3VsZCBzaG93IFJFQURZ" + + "OiBUcnVlCmBgYAoKIyMjIFdyb25nIHNlY3JldCBuYW1lCgpUaGUgcG9saWN5IHJlZmVyZW5jZXMg" + + "YG52Y3ItY3JlZHNgLiBWZXJpZnkgdGhlIHNlY3JldCBleGlzdHMgd2l0aCB0aGF0IGV4YWN0IG5h" + + "bWU6CgpgYGBiYXNoCmt1YmVjdGwgLS1jb250ZXh0IDx0YXJnZXQtY29udGV4dD4gZ2V0IHNlY3Jl" + + "dCBudmNyLWNyZWRzIC1uIDxuYW1lc3BhY2U+CmBgYApQSwcIS0I1qAAWAAAAFgAAUEsBAhQAFAAI" + + "AAAAAAAhAIHcVxdKEAAAShAAABIACQAAAAAAAAAAAAAAAAAAAGRhdGEvbWFuaWZlc3QuanNvblVU" + + "BQABAKbOElBLAQIUABQACAAAAAAAIQDNgTDkTWEAAE1hAAAjAAkAAAAAAAAAAAAAAJMQAABkYXRh" + + "L252Y2Ytc2VsZi1tYW5hZ2VkLWNsaS9TS0lMTC5tZFVUBQABAKbOElBLAQIUABQACAAAAAAAIQAh" + + "xsiG8AoAAPAKAAAzAAkAAAAAAAAAAAAAADpyAABkYXRhL252Y2Ytc2VsZi1tYW5hZ2VkLWNsaS9l" + + "eGFtcGxlcy9jaS1waXBlbGluZXMubWRVVAUAAQCmzhJQSwECFAAUAAgAAAAAACEAoRTjgV0MAABd" + + "DAAANAAJAAAAAAAAAAAAAACUfQAAZGF0YS9udmNmLXNlbGYtbWFuYWdlZC1jbGkvZXhhbXBsZXMv" + + "bXVsdGktY2x1c3Rlci5tZFVUBQABAKbOElBLAQIUABQACAAAAAAAIQBCJ0kPBQ0AAAUNAAA3AAkA" + + "AAAAAAAAAAAAAFyKAABkYXRhL252Y2Ytc2VsZi1tYW5hZ2VkLWNsaS9wcm9tcHRzL2FkZC1jb21w" + + "dXRlLXBsYW5lLm1kVVQFAAEAps4SUEsBAhQAFAAIAAAAAAAhAJHcG/mYGQAAmBkAADkACQAAAAAA" + + "AAAAAAAAz5cAAGRhdGEvbnZjZi1zZWxmLW1hbmFnZWQtY2xpL3Byb21wdHMvY3JlYXRlLWFuZC1y" + + "dW4tdGFzay5tZFVUBQABAKbOElBLAQIUABQACAAAAAAAIQDSQ9wEGCUAABglAAA3AAkAAAAAAAAA" + + "AAAAANexAABkYXRhL252Y2Ytc2VsZi1tYW5hZ2VkLWNsaS9wcm9tcHRzL2RlcGxveS1hbmQtaW52" + + "b2tlLm1kVVQFAAEAps4SUEsBAhQAFAAIAAAAAAAhAA6cP5e9DgAAvQ4AAD0ACQAAAAAAAAAAAAAA" + + "XdcAAGRhdGEvbnZjZi1zZWxmLW1hbmFnZWQtY2xpL3Byb21wdHMvZGlhZ25vc2UtZmFpbGVkLWlu" + + "c3RhbGwubWRVVAUAAQCmzhJQSwECFAAUAAgAAAAAACEAQnHmHgEoAAABKAAAOgAJAAAAAAAAAAAA" + + "AACO5gAAZGF0YS9udmNmLXNlbGYtbWFuYWdlZC1jbGkvcHJvbXB0cy9pbnN0YWxsLWZyb20tc2Ny" + + "YXRjaC5tZFVUBQABAKbOElBLAQIUABQACAAAAAAAIQAaxCyexwcAAMcHAAA5AAkAAAAAAAAAAAAA" + + "AAAPAQBkYXRhL252Y2Ytc2VsZi1tYW5hZ2VkLWNsaS9wcm9tcHRzL3JvdGF0ZS1jbHVzdGVyLWp3" + + "a3MubWRVVAUAAQCmzhJQSwECFAAUAAgAAAAAACEAEpMzWeAhAADgIQAALgAJAAAAAAAAAAAAAAA3" + + "FwEAZGF0YS9udmNmLXNlbGYtbWFuYWdlZC1jbGkvcHJvbXB0cy90ZWFyZG93bi5tZFVUBQABAKbO" + + "ElBLAQIUABQACAAAAAAAIQByDQ9kISMAACEjAAAwAAkAAAAAAAAAAAAAAHw5AQBkYXRhL252Y2Yt" + + "c2VsZi1tYW5hZ2VkLWNsaS9yZWZlcmVuY2UvY29tbWFuZHMubWRVVAUAAQCmzhJQSwECFAAUAAgA" + + "AAAAACEAc6daZNUGAADVBgAAMgAJAAAAAAAAAAAAAAAEXQEAZGF0YS9udmNmLXNlbGYtbWFuYWdl" + + "ZC1jbGkvcmVmZXJlbmNlL2V4aXQtY29kZXMubWRVVAUAAQCmzhJQSwECFAAUAAgAAAAAACEAqM8f" + + "qDMoAAAzKAAALQAJAAAAAAAAAAAAAABCZAEAZGF0YS9udmNmLXNlbGYtbWFuYWdlZC1jbGkvcmVm" + + "ZXJlbmNlL2ZsYWdzLm1kVVQFAAEAps4SUEsBAhQAFAAIAAAAAAAhAPOuE4R0EQAAdBEAADcACQAA" + + "AAAAAAAAAAAA2YwBAGRhdGEvbnZjZi1zZWxmLW1hbmFnZWQtY2xpL3JlZmVyZW5jZS90cm91Ymxl" + + "c2hvb3RpbmcubWRVVAUAAQCmzhJQSwECFAAUAAgAAAAAACEAL9q5dUJiAABCYgAALAAJAAAAAAAA" + + "AAAAAAC7ngEAZGF0YS9udmNmLXNlbGYtbWFuYWdlZC1pbnN0YWxsYXRpb24vU0tJTEwubWRVVAUA" + + "AQCmzhJQSwECFAAUAAgAAAAAACEAKxO4P61VAACtVQAANAAJAAAAAAAAAAAAAABgAQIAZGF0YS9u" + + "dmNmLXNlbGYtbWFuYWdlZC1pbnN0YWxsYXRpb24vZXZhbHMvZXZhbHMuanNvblVUBQABAKbOElBL" + + "AQIUABQACAAAAAAAIQACUk5AfygAAH8oAAAvAAkAAAAAAAAAAAAAAHhXAgBkYXRhL252Y2Ytc2Vs" + + "Zi1tYW5hZ2VkLWluc3RhbGxhdGlvbi9leGFtcGxlcy5tZFVUBQABAKbOElBLAQIUABQACAAAAAAA" + + "IQCWY7xZEjAAABIwAABMAAkAAAAAAAAAAAAAAF2AAgBkYXRhL252Y2Ytc2VsZi1tYW5hZ2VkLWlu" + + "c3RhbGxhdGlvbi9yZWZlcmVuY2VzL2NvbXB1dGUtcGxhbmUtaW5zdGFsbGF0aW9uLm1kVVQFAAEA" + + "ps4SUEsBAhQAFAAIAAAAAAAhAFY+Z5CVMAAAlTAAADsACQAAAAAAAAAAAAAA8rACAGRhdGEvbnZj" + + "Zi1zZWxmLW1hbmFnZWQtaW5zdGFsbGF0aW9uL3JlZmVyZW5jZXMvZGVidWdnaW5nLm1kVVQFAAEA" + + "ps4SUEsBAhQAFAAIAAAAAAAhAMBWIOePJwAAjycAAEQACQAAAAAAAAAAAAAA+eECAGRhdGEvbnZj" + + "Zi1zZWxmLW1hbmFnZWQtaW5zdGFsbGF0aW9uL3JlZmVyZW5jZXMvaGVsbWZpbGUtc3RydWN0dXJl" + + "Lm1kVVQFAAEAps4SUEsBAhQAFAAIAAAAAAAhADj5J6+5BwAAuQcAAD8ACQAAAAAAAAAAAAAAAwoD" + + "AGRhdGEvbnZjZi1zZWxmLW1hbmFnZWQtaW5zdGFsbGF0aW9uL3JlZmVyZW5jZXMvbnZjZi11aS1h" + + "ZGRvbi5tZFVUBQABAKbOElBLAQIUABQACAAAAAAAIQBLQjWoABYAAAAWAAA+AAkAAAAAAAAAAAAA" + + "ADISAwBkYXRhL252Y2Ytc2VsZi1tYW5hZ2VkLWluc3RhbGxhdGlvbi9yZWZlcmVuY2VzL3B1bGwt" + + "c2VjcmV0cy5tZFVUBQABAKbOElBLBQYAAAAAFwAXAK8JAACnKAMAAAA=" 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 From 199c01464960368a6a6b3955758c0346821cd8c9 Mon Sep 17 00:00:00 2001 From: sevenc Date: Fri, 28 Aug 2026 16:53:32 +0800 Subject: [PATCH 02/10] test(nvcf-cli): cover repeated priority overrides --- .../cmd/function_request_priority_test.go | 51 +++++++++++++++++++ 1 file changed, 51 insertions(+) diff --git a/src/clis/nvcf-cli/cmd/function_request_priority_test.go b/src/clis/nvcf-cli/cmd/function_request_priority_test.go index d7eaa1260..426220974 100644 --- a/src/clis/nvcf-cli/cmd/function_request_priority_test.go +++ b/src/clis/nvcf-cli/cmd/function_request_priority_test.go @@ -21,6 +21,7 @@ import ( "bytes" "encoding/json" "fmt" + "maps" "strings" "testing" @@ -126,6 +127,56 @@ func TestLoadCreateConfigAppliesRequestPriorityFlags(t *testing.T) { assertPriorityConfig(t, config.LLMInvocationConfig, 0, map[string]uint32{"nca-1": 3}) } +func TestCreateRequestIncludesRepeatedPerAccountPriorityFlags(t *testing.T) { + originalFlags := createFlags + t.Cleanup(func() { createFlags = originalFlags }) + + cmd := &cobra.Command{} + cmd.Flags().Uint32Var(&createFlags.llmDefaultPriority, "llm-default-priority", 0, "") + cmd.Flags().StringArrayVar(&createFlags.llmPerAccountPriorities, "llm-per-account-priority", nil, "") + if err := cmd.Flags().Set("llm-default-priority", "7"); err != nil { + t.Fatalf("set default priority: %v", err) + } + if err := cmd.Flags().Set("llm-per-account-priority", "nca-a:3"); err != nil { + t.Fatalf("set first per-account priority: %v", err) + } + if err := cmd.Flags().Set("llm-per-account-priority", "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 }) From 659100e0b2116f85ca8060ed1f32e7a5e7ffcad4 Mon Sep 17 00:00:00 2001 From: sevenc Date: Fri, 28 Aug 2026 17:12:37 +0800 Subject: [PATCH 03/10] refactor(nvcf-cli): clear priority through input file --- .../nvcf-self-managed-cli/reference/flags.md | 3 +- docs/user/cli.md | 8 +- src/clis/nvcf-cli/README.md | 8 +- src/clis/nvcf-cli/USAGE-GUIDE.md | 12 +- src/clis/nvcf-cli/cmd/function.go | 14 +- .../cmd/function_request_priority_test.go | 43 - .../agentskill/skilldata_generated.go | 3906 ++++++++--------- 7 files changed, 1964 insertions(+), 2030 deletions(-) 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 e17113f25..0e861ba58 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 @@ -117,11 +117,10 @@ LLM invocation requests use `model: "/"`. The function | `--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, maximum 64. Requires a default priority. | - | -| `--clear-llm-priority` | Clear the function-level request priority configuration. | `false` | 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. -When `llmInvocationConfig` is present in an update, it replaces the complete function-level priority configuration. Specify every default and per-account value to retain. Omitting the field preserves the current configuration. Use `--clear-llm-priority` or `"llmInvocationConfig": {}` to clear it. +When `llmInvocationConfig` is present in an update, it replaces the complete function-level priority configuration. Specify every default and per-account value to retain. Omitting the field preserves the current configuration. Use `--input-file` with `"llmInvocationConfig": {}` to clear it. ## `function deploy create`-specific diff --git a/docs/user/cli.md b/docs/user/cli.md index 6409301fe..482067206 100644 --- a/docs/user/cli.md +++ b/docs/user/cli.md @@ -910,12 +910,6 @@ Example deployment JSON: --llm-default-priority 7 \ --llm-per-account-priority "nca-id:3" -# Clear the function-level request priority configuration -./nvcf-cli function update \ - --function-id \ - --version-id \ - --clear-llm-priority - # Update from JSON file ./nvcf-cli function update \ --function-id \ @@ -941,7 +935,7 @@ LLM model updates can also be provided in the input file: } ``` -`llmInvocationConfig` is a full replacement when it is present in an update. Specify every default and per-account value to retain. Omitting the field preserves the current configuration. Use `--clear-llm-priority` or an empty `llmInvocationConfig` object to clear it: +`llmInvocationConfig` is a full replacement when it is present in an update. Specify every default and per-account value to retain. Omitting the field preserves the current configuration. To clear it, use `--input-file` with an empty `llmInvocationConfig` object: ```json { diff --git a/src/clis/nvcf-cli/README.md b/src/clis/nvcf-cli/README.md index c36cb3905..2db2e93da 100644 --- a/src/clis/nvcf-cli/README.md +++ b/src/clis/nvcf-cli/README.md @@ -765,12 +765,6 @@ export NVCF_API_KEY="nvapi-your-general-operations-token" # optional fallback --llm-default-priority 7 \ --llm-per-account-priority "nca-id:3" -# Clear 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" \ - --clear-llm-priority - # Update function deployment specifications ./nvcf-cli function deploy update \ --function-id "func-12345678-1234-1234-1234-123456789abc" \ @@ -807,7 +801,7 @@ export NVCF_API_KEY="nvapi-your-general-operations-token" # optional fallback } ``` -An update that includes `llmInvocationConfig` replaces the complete function-level priority configuration. Specify every default and per-account value to retain. Omitting the field preserves the current configuration. Use `--clear-llm-priority` or set `"llmInvocationConfig": {}` in the update file to clear it. +An update that includes `llmInvocationConfig` replaces the complete function-level priority configuration. Specify every default and per-account value to retain. Omitting the field preserves the current configuration. To clear it, use `--input-file` with `"llmInvocationConfig": {}`. **Update Deployment JSON format (`update-deployment.json`):** ```json diff --git a/src/clis/nvcf-cli/USAGE-GUIDE.md b/src/clis/nvcf-cli/USAGE-GUIDE.md index 7cc91270e..bf4041180 100644 --- a/src/clis/nvcf-cli/USAGE-GUIDE.md +++ b/src/clis/nvcf-cli/USAGE-GUIDE.md @@ -1055,15 +1055,9 @@ When `--json` is set: --version-id "01234567-89ab-cdef-0123-456789abcdef" \ --llm-default-priority 7 \ --llm-per-account-priority "nca-id:3" - -# Clear the function-level request priority configuration -./nvcf-cli function update \ - --function-id "550e8400-e29b-41d4-a716-446655440000" \ - --version-id "01234567-89ab-cdef-0123-456789abcdef" \ - --clear-llm-priority ``` -When an update includes `llmInvocationConfig`, it replaces the complete function-level priority configuration. Specify every default and per-account value to retain. Omitting the field preserves the current configuration. An empty object clears it: +When an update includes `llmInvocationConfig`, it replaces the complete function-level priority configuration. Specify every default and per-account value to retain. Omitting the field preserves the current configuration. To clear it, save an update file such as `clear-priority.json` with an empty object: ```json { @@ -1073,6 +1067,10 @@ When an update includes `llmInvocationConfig`, it replaces the complete function } ``` +```bash +./nvcf-cli function update --input-file clear-priority.json +``` + ### Delete Function or Deployment The delete command offers flexible ways to specify which function to delete, with automatic fallback to the current function in state. diff --git a/src/clis/nvcf-cli/cmd/function.go b/src/clis/nvcf-cli/cmd/function.go index fb5b734d7..81b7c8eba 100644 --- a/src/clis/nvcf-cli/cmd/function.go +++ b/src/clis/nvcf-cli/cmd/function.go @@ -263,8 +263,9 @@ var updateCmd = &cobra.Command{ 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. Function-level LLM request -priority can be configured or cleared. A priority update replaces the existing -function-level priority configuration, so specify every value to retain. +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 @@ -545,7 +546,6 @@ var updateFlags struct { llmModelUpdates []string llmDefaultPriority uint32 llmPerAccountPriorities []string - clearLLMPriority bool } // ============================================================================ @@ -638,7 +638,6 @@ func init() { updateCmd.Flags().StringArrayVar(&updateFlags.llmModelUpdates, "llm-model-update", []string{}, "LLM model update (format: name=,routingMethod=,tokenRateLimit=)") updateCmd.Flags().Uint32Var(&updateFlags.llmDefaultPriority, "llm-default-priority", 0, "Function-level default request priority (lower is higher; range: 0-4294967295; replaces existing priority config)") updateCmd.Flags().StringArrayVar(&updateFlags.llmPerAccountPriorities, "llm-per-account-priority", []string{}, "Per-account request priority override (format: :; requires default priority; lower is higher; range: 0-4294967295; repeatable, max 64)") - updateCmd.Flags().BoolVar(&updateFlags.clearLLMPriority, "clear-llm-priority", false, "Clear the function-level request priority configuration") } // ============================================================================ @@ -1591,12 +1590,7 @@ func loadUpdateConfig(cmd *cobra.Command) (*UpdateConfig, error) { } priorityFlagsChanged := cmd.Flags().Changed("llm-default-priority") || cmd.Flags().Changed("llm-per-account-priority") - if cmd.Flags().Changed("clear-llm-priority") && updateFlags.clearLLMPriority { - if priorityFlagsChanged { - return nil, fmt.Errorf("--clear-llm-priority cannot be used with --llm-default-priority or --llm-per-account-priority") - } - config.LLMInvocationConfig = &LLMInvocationConfigInput{} - } else if priorityFlagsChanged { + if priorityFlagsChanged { if err := applyRequestPriorityFlagOverrides( cmd.Flags().Changed("llm-default-priority"), updateFlags.llmDefaultPriority, diff --git a/src/clis/nvcf-cli/cmd/function_request_priority_test.go b/src/clis/nvcf-cli/cmd/function_request_priority_test.go index 426220974..19317fa50 100644 --- a/src/clis/nvcf-cli/cmd/function_request_priority_test.go +++ b/src/clis/nvcf-cli/cmd/function_request_priority_test.go @@ -198,48 +198,6 @@ func TestLoadUpdateConfigAppliesRequestPriorityFlags(t *testing.T) { assertPriorityConfig(t, config.LLMInvocationConfig, 7, map[string]uint32{"nca-1": 3}) } -func TestLoadUpdateConfigClearsRequestPriority(t *testing.T) { - originalFlags := updateFlags - t.Cleanup(func() { updateFlags = originalFlags }) - - cmd := newPriorityFlagTestCommand() - if err := cmd.Flags().Set("clear-llm-priority", "true"); err != nil { - t.Fatalf("set clear priority: %v", err) - } - updateFlags.clearLLMPriority = true - - config, err := loadUpdateConfig(cmd) - if err != nil { - t.Fatalf("load update config: %v", err) - } - if config.LLMInvocationConfig == nil { - t.Fatal("llmInvocationConfig is nil, want empty config") - } - if config.LLMInvocationConfig.Priority != nil { - t.Fatalf("priority = %#v, want nil", config.LLMInvocationConfig.Priority) - } -} - -func TestLoadUpdateConfigRejectsClearWithPriorityFlags(t *testing.T) { - originalFlags := updateFlags - t.Cleanup(func() { updateFlags = originalFlags }) - - cmd := newPriorityFlagTestCommand() - if err := cmd.Flags().Set("clear-llm-priority", "true"); err != nil { - t.Fatalf("set clear priority: %v", err) - } - if err := cmd.Flags().Set("llm-default-priority", "7"); err != nil { - t.Fatalf("set default priority: %v", err) - } - updateFlags.clearLLMPriority = true - updateFlags.llmDefaultPriority = 7 - - _, err := loadUpdateConfig(cmd) - if err == nil || !strings.Contains(err.Error(), "cannot be used with") { - t.Fatalf("error = %v, want mutually exclusive flags error", err) - } -} - func TestRequestPriorityFlagsPreserveInputFileFieldsWhenOmitted(t *testing.T) { t.Parallel() @@ -409,7 +367,6 @@ func newPriorityFlagTestCommand() *cobra.Command { cmd := &cobra.Command{} cmd.Flags().Uint32("llm-default-priority", 0, "") cmd.Flags().StringArray("llm-per-account-priority", nil, "") - cmd.Flags().Bool("clear-llm-priority", false, "") return cmd } diff --git a/src/clis/nvcf-cli/internal/agentskill/skilldata_generated.go b/src/clis/nvcf-cli/internal/agentskill/skilldata_generated.go index 9ca62649c..a16c4441f 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" + - "MDowMFoiLAogICJ0b3RhbEZpbGVzIjogMjIsCiAgInRvdGFsQnl0ZXMiOiAyMDAzNjYsCiAgImZp" + + "MDowMFoiLAogICJ0b3RhbEZpbGVzIjogMjIsCiAgInRvdGFsQnl0ZXMiOiAyMDAyNjQsCiAgImZp" + "bGVzIjogWwogICAgewogICAgICAicGF0aCI6ICJudmNmLXNlbGYtbWFuYWdlZC1jbGkvU0tJTEwu" + "bWQiLAogICAgICAic2hhMjU2IjogImM0ZjI4OGY2MmU1MDg4NjI5ZGY1MTcyYTlhYjMwZWVlOGMz" + "OTRmYzgzOTFjMjMwMDMzNzI2NGVmZjRiMmU3ZWYiLAogICAgICAic2l6ZSI6IDI0OTA5CiAgICB9" + @@ -71,9 +71,9 @@ const skillDataZipBase64 = "" + "ZW5jZS9leGl0LWNvZGVzLm1kIiwKICAgICAgInNoYTI1NiI6ICI2NGI1ZmE5YmNhZjBlMGE1M2Y3" + "ODkyMGI3M2ZjYjUzMGFiNjk0NTFiNDhhNWI0OTNmMjUyY2ExODU4M2FiMDg2IiwKICAgICAgInNp" + "emUiOiAxNzQ5CiAgICB9LAogICAgewogICAgICAicGF0aCI6ICJudmNmLXNlbGYtbWFuYWdlZC1j" + - "bGkvcmVmZXJlbmNlL2ZsYWdzLm1kIiwKICAgICAgInNoYTI1NiI6ICJjNGEzNGRmNTQ5ZmIxNzY4" + - "NWY5YTE3MmNhZjVkNDI1ZWY1NTQ4OWE2ZTk2MGVlMGU5NzAzOTU4YWYzODJmOTgyIiwKICAgICAg" + - "InNpemUiOiAxMDI5MQogICAgfSwKICAgIHsKICAgICAgInBhdGgiOiAibnZjZi1zZWxmLW1hbmFn" + + "bGkvcmVmZXJlbmNlL2ZsYWdzLm1kIiwKICAgICAgInNoYTI1NiI6ICI1OTgwYjc2ZGYzODFhMjdh" + + "NmU2MjhkMmZkMWVkMTE5ZTdjMTM5YTFkYzE1OGE4MGQwODQ3Zjk3ZmFlMTc4YjE5IiwKICAgICAg" + + "InNpemUiOiAxMDE4OQogICAgfSwKICAgIHsKICAgICAgInBhdGgiOiAibnZjZi1zZWxmLW1hbmFn" + "ZWQtY2xpL3JlZmVyZW5jZS90cm91Ymxlc2hvb3RpbmcubWQiLAogICAgICAic2hhMjU2IjogImE2" + "MzA4NGUyMjQ5ZjFkMTU0YzU5ODFlNGEwNzJiN2M3ODRiODVlYTE0NjA4NjUxNWVhYjRhYjY3MGE5" + "NDBlOTQiLAogICAgICAic2l6ZSI6IDQ0NjgKICAgIH0sCiAgICB7CiAgICAgICJwYXRoIjogIm52" + @@ -103,7 +103,7 @@ const skillDataZipBase64 = "" + "aCI6ICJudmNmLXNlbGYtbWFuYWdlZC1pbnN0YWxsYXRpb24vcmVmZXJlbmNlcy9wdWxsLXNlY3Jl" + "dHMubWQiLAogICAgICAic2hhMjU2IjogImVjMWYzZmZjZDE3ZTVmOTU4M2ZlZTM5NzQ0ZWU4OTdk" + "NDY2YmMzY2Y2Mzg5Mjk0MjY0ZDg5ZTdmOWVkMDFiODciLAogICAgICAic2l6ZSI6IDU2MzIKICAg" + - "IH0KICBdCn0KUEsHCIHcVxdKEAAAShAAAFBLAwQUAAgAAAAAACEAAAAAAAAAAAAAAAAAIwAJAGRh" + + "IH0KICBdCn0KUEsHCPQ3BvZKEAAAShAAAFBLAwQUAAgAAAAAACEAAAAAAAAAAAAAAAAAIwAJAGRh" + "dGEvbnZjZi1zZWxmLW1hbmFnZWQtY2xpL1NLSUxMLm1kVVQFAAEAps4SLS0tCm5hbWU6IG52Y2Yt" + "c2VsZi1tYW5hZ2VkLWNsaQpkZXNjcmlwdGlvbjogfAogIEluc3RhbGwsIG9wZXJhdGUsIGFuZCB0" + "ZWFyIGRvd24gc2VsZi1ob3N0ZWQgTlZJRElBIENsb3VkIEZ1bmN0aW9ucyAoTlZDRikKICBkZXBs" + @@ -1753,1958 +1753,1956 @@ const skillDataZipBase64 = "" + "YXVsdCBhbmQgYW55IHN1cHBsaWVkIHBlci1hY2NvdW50IG92ZXJyaWRlcy4gfCAtIHwKfCBgLS1s" + "bG0tcGVyLWFjY291bnQtcHJpb3JpdHkgTkNBLUlEOlBSSU9SSVRZYCB8IFBlci1hY2NvdW50IHBy" + "aW9yaXR5IG92ZXJyaWRlOyByZXBlYXRhYmxlLCBtYXhpbXVtIDY0LiBSZXF1aXJlcyBhIGRlZmF1" + - "bHQgcHJpb3JpdHkuIHwgLSB8CnwgYC0tY2xlYXItbGxtLXByaW9yaXR5YCB8IENsZWFyIHRoZSBm" + - "dW5jdGlvbi1sZXZlbCByZXF1ZXN0IHByaW9yaXR5IGNvbmZpZ3VyYXRpb24uIHwgYGZhbHNlYCB8" + - "CgpJbiBKU09OLCBgZnVuY3Rpb24gdXBkYXRlYCBhY2NlcHRzIGBtb2RlbFVwZGF0ZXNbXWAgZW50" + - "cmllcyB3aXRoIGBtb2RlbE5hbWVgIGFuZCBgbGxtQ29uZmlnLnJvdXRpbmdNZXRob2RgIGFuZC9v" + - "ciBgbGxtQ29uZmlnLnRva2VuUmF0ZUxpbWl0YC4gYHVyaXNgIGFyZSBjcmVhdGUtdGltZSBtb2Rl" + - "bCBtZXRhZGF0YSBhbmQgYXJlIG5vdCBwYXJ0IG9mIG1vZGVsIHVwZGF0ZXMuCgpXaGVuIGBsbG1J" + - "bnZvY2F0aW9uQ29uZmlnYCBpcyBwcmVzZW50IGluIGFuIHVwZGF0ZSwgaXQgcmVwbGFjZXMgdGhl" + - "IGNvbXBsZXRlIGZ1bmN0aW9uLWxldmVsIHByaW9yaXR5IGNvbmZpZ3VyYXRpb24uIFNwZWNpZnkg" + - "ZXZlcnkgZGVmYXVsdCBhbmQgcGVyLWFjY291bnQgdmFsdWUgdG8gcmV0YWluLiBPbWl0dGluZyB0" + - "aGUgZmllbGQgcHJlc2VydmVzIHRoZSBjdXJyZW50IGNvbmZpZ3VyYXRpb24uIFVzZSBgLS1jbGVh" + - "ci1sbG0tcHJpb3JpdHlgIG9yIGAibGxtSW52b2NhdGlvbkNvbmZpZyI6IHt9YCB0byBjbGVhciBp" + - "dC4KCiMjIGBmdW5jdGlvbiBkZXBsb3kgY3JlYXRlYC1zcGVjaWZpYwoKYC0taW5wdXQtZmlsZSBG" + - "SUxFYCBpcyByZWNvbW1lbmRlZCAoZnVsbCBKU09OIHNwZWMpLiBGb3IgYWQtaG9jIG9uZS1zaG90" + - "IHVzZToKCnwgRmxhZyB8IFB1cnBvc2UgfCBEZWZhdWx0IHwKfC0tLXwtLS18LS0tfAp8IGAtLWZ1" + - "bmN0aW9uLWlkIElEYCB8IEZ1bmN0aW9uIElEIChyZXF1aXJlZCkgfCAtIHwKfCBgLS1ncHUgTkFN" + - "RWAgfCBHUFUgZmFtaWx5IHwgYEgxMDBgIHwKfCBgLS1pbnN0YW5jZS10eXBlIFRZUEVgIHwgU0tV" + - "IHwgYE5DUC5HUFUuSDEwMF8xeGAgfAp8IGAtLW1pbi1pbnN0YW5jZXMgTmAgfCBNaW4gcmVwbGlj" + - "YXMgfCBgMWAgfAp8IGAtLW1heC1pbnN0YW5jZXMgTmAgfCBNYXggcmVwbGljYXMgfCBgMWAgfAp8" + - "IGAtLW1heC1yZXF1ZXN0LWNvbmN1cnJlbmN5IE5gIHwgQ29uY3VycmVuY3kgfCBgMGAgKHVuc2V0" + - "OyBzZXJ2ZXIgZGVmYXVsdCBhcHBsaWVzKSB8CnwgYC0tY2x1c3RlcnMgTkFNRVssTkFNRV1gIHwg" + - "VGFyZ2V0IHNwZWNpZmljIGNvbXB1dGUgY2x1c3RlcnMgfCAoYW55IG1hdGNoaW5nIFNLVSkgfAoK" + - "IyMgYHRhc2sgY3JlYXRlYC1zcGVjaWZpYwoKYC0taW5wdXQtZmlsZSBGSUxFYCBpcyByZWNvbW1l" + - "bmRlZCBmb3IgcmVwZWF0YWJsZSB0YXNrIGRlZmluaXRpb25zLiBGb3IgYWQtaG9jIHVzZToKCnwg" + - "RmxhZyB8IFB1cnBvc2UgfCBOb3RlcyB8CnwtLS18LS0tfC0tLXwKfCBgLS1uYW1lIE5BTUVgIHwg" + - "VGFzayBuYW1lIChyZXF1aXJlZCkgfCAxLTEyOCBjaGFycywgYF5bYS16MC05QS1aXVthLXowLTlB" + - "LVpcLV9dKiRgIHwKfCBgLS1ncHUgR1BVYCB8IEdQVSBuYW1lIChyZXF1aXJlZCB3aXRob3V0IGAt" + - "LWlucHV0LWZpbGVgKSB8IEV4YW1wbGU6IGBIMTAwYCB8CnwgYC0taW5zdGFuY2UtdHlwZSBUWVBF" + - "YCB8IEluc3RhbmNlIHR5cGUgKHJlcXVpcmVkIHdpdGhvdXQgYC0taW5wdXQtZmlsZWApIHwgRXhh" + - "bXBsZTogYE5DUC5HUFUuSDEwMF8xeGAgfAp8IGAtLWltYWdlIElNQUdFYCB8IENvbnRhaW5lciBp" + - "bWFnZSB8IE11dHVhbGx5IGV4Y2x1c2l2ZSB3aXRoIGAtLWhlbG0tY2hhcnRgIHwKfCBgLS1oZWxt" + - "LWNoYXJ0IENIQVJUYCB8IEhlbG0gY2hhcnQgVVJMIG9yIE9DSSByZWZlcmVuY2UgfCBNdXR1YWxs" + - "eSBleGNsdXNpdmUgd2l0aCBgLS1pbWFnZWAgfAp8IGAtLWlucHV0LWZpbGUgRklMRWAgfCBKU09O" + - "IHRhc2sgc3BlYyBmaWxlIHwgQ0xJIGZsYWdzIG92ZXJyaWRlIEpTT04gdmFsdWVzIHdoZW4gYm90" + - "aCBhcmUgc2V0IHwKfCBgLS1iYWNrZW5kIEJBQ0tFTkRgIHwgQmFja2VuZCAvIENTUCB8IC0gfAp8" + - "IGAtLWNsdXN0ZXJzIE5BTUVbLE5BTUVdYCB8IFNwZWNpZmljIGNsdXN0ZXJzIHdpdGhpbiB0aGUg" + - "aW5zdGFuY2UgfCBDb21tYS1zZXBhcmF0ZWQgfAp8IGAtLWNvbnRhaW5lci1hcmdzIEFSR1NgIHwg" + - "QXJncyBwYXNzZWQgd2hlbiBsYXVuY2hpbmcgdGhlIGNvbnRhaW5lciB8IFNpbmdsZSBzdHJpbmcs" + - "IGUuZy4gYCItLWVwb2NocyAxMCAtLWJhdGNoLXNpemUgMzIiYCB8CnwgYC0tY29udGFpbmVyLWVu" + - "diBOQU1FPXZhbHVlYCB8IENvbnRhaW5lciBlbnZpcm9ubWVudCB2YXJpYWJsZTsgcmVwZWF0YWJs" + - "ZSB8IC0gfAp8IGAtLXNlY3JldHMgTkFNRT12YWx1ZWAgfCBTZWNyZXQgZW52aXJvbm1lbnQgdmFy" + - "aWFibGU7IHJlcGVhdGFibGU7IGVuY3J5cHRlZCBhdCByZXN0IHwgLSB8CnwgYC0tbWF4LXJ1bnRp" + - "bWUgRFVSQVRJT05gIHwgTWF4IHdhbGwtY2xvY2sgcnVuIHRpbWUgKElTTyA4NjAxLCBlLmcuIGBQ" + - "VDRIYCkgfCBObyBkZWZhdWx0OyBvbWl0IGZvciBubyB0aW1lIGxpbWl0IHwKfCBgLS1tYXgtcXVl" + - "dWVkIERVUkFUSU9OYCB8IE1heCB0aW1lIGluIHF1ZXVlIGJlZm9yZSBjYW5jZWxsYXRpb24gKElT" + - "TyA4NjAxKSB8IFNlcnZlciBkZWZhdWx0IGBQVDcySGAgfAp8IGAtLXRlcm1pbmF0aW9uLWdyYWNl" + - "IERVUkFUSU9OYCB8IEdyYWNlIHBlcmlvZCBhZnRlciBzdG9wIHNpZ25hbCAoSVNPIDg2MDEpIHwg" + - "U2VydmVyIGRlZmF1bHQgYFBUMUhgIHwKfCBgLS1yZXN1bHQtc3RyYXRlZ3kgVVBMT0FEXHxOT05F" + - "YCB8IEhvdyB0byBoYW5kbGUgdGFzayBvdXRwdXQgYXJ0aWZhY3RzIHwgLSB8CnwgYC0tcmVzdWx0" + - "cy1sb2NhdGlvbiBMT0NBVElPTmAgfCBSZXN1bHQgdXBsb2FkIHRhcmdldCwgZm9ybWF0IGBvcmct" + - "bmFtZS9bdGVhbS1uYW1lL11tb2RlbC1uYW1lYDsgcmVxdWlyZWQgd2hlbiBgLS1yZXN1bHQtc3Ry" + - "YXRlZ3k9VVBMT0FEYCB8IC0gfAp8IGAtLW1vZGVscyBOQU1FOlZFUlNJT046VVJJYCB8IE1vZGVs" + - "IGFydGlmYWN0OyByZXBlYXRhYmxlIHwgLSB8CnwgYC0tcmVzb3VyY2VzIE5BTUU6VkVSU0lPTjpV" + - "UklgIHwgUmVzb3VyY2UgYXJ0aWZhY3Q7IHJlcGVhdGFibGUgfCAtIHwKfCBgLS10YWdzIFRBR1ss" + - "VEFHXWAgfCBUYXNrIHRhZ3MgfCBDb21tYS1zZXBhcmF0ZWQgfAp8IGAtLWRlc2NyaXB0aW9uIFRF" + - "WFRgIHwgVGFzayBkZXNjcmlwdGlvbiB8IC0gfAp8IGAtLWxvZ3MtdGVsZW1ldHJ5LWlkIFVVSURg" + - "IHwgTG9ncyB0ZWxlbWV0cnkgZW5kcG9pbnQgSUQgfCAtIHwKfCBgLS1tZXRyaWNzLXRlbGVtZXRy" + - "eS1pZCBVVUlEYCB8IE1ldHJpY3MgdGVsZW1ldHJ5IGVuZHBvaW50IElEIHwgLSB8CnwgYC0tdHJh" + - "Y2VzLXRlbGVtZXRyeS1pZCBVVUlEYCB8IFRyYWNlcyB0ZWxlbWV0cnkgZW5kcG9pbnQgSUQgfCAt" + - "IHwKUEsHCKjPH6gzKAAAMygAAFBLAwQUAAgAAAAAACEAAAAAAAAAAAAAAAAANwAJAGRhdGEvbnZj" + - "Zi1zZWxmLW1hbmFnZWQtY2xpL3JlZmVyZW5jZS90cm91Ymxlc2hvb3RpbmcubWRVVAUAAQCmzhIj" + - "IFRyb3VibGVzaG9vdGluZwoKS25vd24gZXJyb3JzIOKGkiBkaWFnbm9zdGljIGNvbW1hbmQg4oaS" + - "IHJlbWVkaWF0aW9uLiBLZWVwIGluIHN5bmMgd2l0aCB0aGUgc3RydWN0dXJlZCBgcGhhc2VfZmFp" + - "bGVkYCBldmVudHMgdGhlIENMSSBlbWl0cyAoUkVRLTE1KSDigJQgZXZlcnkgZW50cnkgYmVsb3cg" + - "c2hvdWxkIG1hcCB0byBhbiBgZXJyQ2F0ZWdvcnlgIGFuZCBhIGByZW1lZGlhdGlvbmAgYXJyYXku" + - "CgojIyBQcmUtZmxpZ2h0Cgp8IFN5bXB0b20gfCBDYXVzZSB8IFJlbWVkaWF0aW9uIHwKfC0tLXwt" + - "LS18LS0tfAp8IGBrdWJlY3RsIG5vdCBvbiBQQVRIYCB8IE9wZXJhdG9yJ3MgYCRQQVRIYCBkb2Vz" + - "bid0IGluY2x1ZGUga3ViZWN0bCB8IEluc3RhbGwga3ViZWN0bCAxLjI4KzogaHR0cHM6Ly9rdWJl" + - "cm5ldGVzLmlvL2RvY3MvdGFza3MvdG9vbHMvaW5zdGFsbC1rdWJlY3RsLyB8CnwgYGhlbG1maWxl" + - "IG5vdCBvbiBQQVRIYCB8IFNhbWUgfCBodHRwczovL2dpdGh1Yi5jb20vaGVsbWZpbGUvaGVsbWZp" + - "bGUjaW5zdGFsbGF0aW9uIHwKfCBgaGVsbSBub3Qgb24gUEFUSGAgfCBTYW1lIHwgaHR0cHM6Ly9o" + - "ZWxtLnNoL2RvY3MvaW50cm8vaW5zdGFsbC8gfAp8IGBHYXRld2F5IEFQSSBDUkRzIG5vdCBpbnN0" + - "YWxsZWRgIHwgZW52b3ktZ2F0ZXdheSBwcmVyZXEgbWlzc2luZyB8IGBoZWxtIGluc3RhbGwgZWcg" + - "b2NpOi8vZG9ja2VyLmlvL2Vudm95cHJveHkvZ2F0ZXdheS1oZWxtIC0tbmFtZXNwYWNlPWVudm95" + - "LWdhdGV3YXktc3lzdGVtIC0tY3JlYXRlLW5hbWVzcGFjZWAgfAp8IGBkZWZhdWx0IFN0b3JhZ2VD" + - "bGFzcyBub3QgYXZhaWxhYmxlYCB8IENsdXN0ZXIgaGFzIG5vIGRlZmF1bHQgU0MgfCBBbm5vdGF0" + - "ZSBvbmU6IGBrdWJlY3RsIHBhdGNoIHNjIDxuYW1lPiAtcCAneyJtZXRhZGF0YSI6eyJhbm5vdGF0" + - "aW9ucyI6eyJzdG9yYWdlY2xhc3Mua3ViZXJuZXRlcy5pby9pcy1kZWZhdWx0LWNsYXNzIjoidHJ1" + - "ZSJ9fX0nYCB8CnwgYEdQVSBvcGVyYXRvciBub3QgaW5zdGFsbGVkYCAoY29tcHV0ZS1wbGFuZSkg" + - "fCBudmlkaWEgR1BVIG9wZXJhdG9yIG1pc3NpbmcgfCBJbnN0YWxsIHBlciBodHRwczovL2RvY3Mu" + - "bnZpZGlhLmNvbS9kYXRhY2VudGVyL2Nsb3VkLW5hdGl2ZS9ncHUtb3BlcmF0b3IvbGF0ZXN0L2lu" + - "c3RhbGwtZ3B1LW9wZXJhdG9yLmh0bWwsIE9SIHVzZSBgZmFrZS1ncHUtb3BlcmF0b3JgIGZvciBk" + - "ZXYgfAp8IGBHUFUgbm9kZSBsYWJlbHMgbWlzc2luZ2AgKGNvbXB1dGUtcGxhbmUpIHwgTm9kZXMg" + - "bmVlZCBgbnZpZGlhLmNvbS9ncHUuZmFtaWx5YCBldGMuIHwgU2V0IGAtLWszcy1ub2RlLWxhYmVs" + - "IG52aWRpYS5jb20vZ3B1LmZhbWlseT1ob3BwZXJAYWdlbnQ6TmAgZm9yIGszZCB8CgojIyBBdXRo" + - "Cgp8IFN5bXB0b20gfCBDYXVzZSB8IFJlbWVkaWF0aW9uIHwKfC0tLXwtLS18LS0tfAp8IGBhZG1p" + - "biB0b2tlbiByZXF1aXJlZGAgKGluaXQgbm90IHJ1bikgfCBObyBgfi8ubnZjZi1jbGkuc3RhdGVg" + - "IGFuZCBgLS10b2tlbmAgbm90IHBhc3NlZCB8IGBudmNmLWNsaSBpbml0YCAoaW50ZXJhY3RpdmUp" + - "IG9yIGAtLXRva2VuPSRKV1QgLS1ub24taW50ZXJhY3RpdmVgIChDSSkgfAp8IGBTaWduZWQgSldU" + - "IHJlamVjdGVkOiBBbm90aGVyIGFsZ29yaXRobSBleHBlY3RlZCwgb3Igbm8gbWF0Y2hpbmcga2V5" + - "KHMpIGZvdW5kYCB8IFN0YWxlIHNlc3Npb24uanNvbiBmcm9tIGEgZGlmZmVyZW50IGNvbnRyb2wg" + - "cGxhbmUgfCBgcm0gfi8ubnZjZi1jbGkuc3RhdGVgIHRoZW4gYG52Y2YtY2xpIGluaXRgIGFnYWlu" + - "IHwKfCBgNDAzIG1pc3NpbmcgcmVxdWVzdGVkIGF1dGhvcml0aWVzYCAoZnVuY3Rpb24gaW52b2tl" + - "KSB8IEFkbWluIHRva2VuIGRvZXNuJ3QgaGF2ZSBgaW52b2tlX2Z1bmN0aW9uYCBzY29wZSB8IGBu" + - "dmNmLWNsaSBhcGkta2V5IGdlbmVyYXRlIC0tZGVzY3JpcHRpb2494oCmYCB0aGVuIHJlLXJ1biBp" + - "bnZva2UgfAoKIyMgSW5zdGFsbCAvIGB1cGAKCnwgU3ltcHRvbSB8IENhdXNlIHwgUmVtZWRpYXRp" + - "b24gfAp8LS0tfC0tLXwtLS18CnwgSGVsbSBgdGltZWQgb3V0IHdhaXRpbmcgZm9yIGNhc3NhbmRy" + - "YWAgfCBDYXNzYW5kcmEgU3RhdGVmdWxTZXQgUFZDIHN0dWNrIGBQZW5kaW5nYCB8IENvbmZpcm0g" + - "ZGVmYXVsdCBTdG9yYWdlQ2xhc3M7IGNoZWNrIGBrdWJlY3RsIGdldCBwdixwdmMgLW4gY2Fzc2Fu" + - "ZHJhLXN5c3RlbWAgfAp8IGBJbnZhbGlkIEdQVSAnTkNQLkdQVS5IMTAwJyBzcGVjaWZpZWRgIChm" + - "dW5jdGlvbiBkZXBsb3kpIHwgV3JvbmcgZmllbGQg4oCUIGBncHVgIGlzIHRoZSBmYW1pbHksIG5v" + - "dCB0aGUgU0tVIHwgVXNlIGAiZ3B1IjogIkgxMDAiYCwgYCJpbnN0YW5jZVR5cGUiOiAiTkNQLkdQ" + - "VS5IMTAwXzF4ImAgfAp8IGByZWdpb24gbXVzdCBiZSBwcm92aWRlZGAgKGNsdXN0ZXIgcmVnaXN0" + - "ZXIgLyBpbnN0YWxsIC0tY29tcHV0ZS1wbGFuZSkgfCBgLS1yZWdpb25gIGVtcHR5ICsgYENMVVNU" + - "RVJfUkVHSU9OYCBlbnYgZW1wdHkgfCBQYXNzIGAtLXJlZ2lvbj11cy13ZXN0LTFgIChvciBhbnkg" + - "bm9uLWVtcHR5IHZhbHVlKSB8CnwgYHJlcXVpcmVkRW52ICJOQ0FfSUQiIGlzIG5vdCBzZXRgICho" + - "ZWxtZmlsZSBlcnJvciBkdXJpbmcgY29tcHV0ZS1wbGFuZSBhcHBseSkgfCBPbGRlciBudmNmLWNs" + - "aSBiZWZvcmUgY29tbWl0IGA2YWE1NzA0YDsgRXh0cmFFbnYgbm90IHByb3BhZ2F0aW5nIE5DQV9J" + - "RCB8IFVwZ3JhZGUgYG52Y2YtY2xpYCB0byBhIHJlbGVhc2UgYWZ0ZXIgYDZhYTU3MDRgIHwKfCBg" + - "bnZjYS1vcGVyYXRvcjogSW1hZ2VQdWxsQmFja09mZmAgZm9yIGBudmNhLW9wZXJhdG9yOnBzYXRg" + - "IHwgSW1hZ2Ugbm90IGluIGNsdXN0ZXIgcmVnaXN0cnk7IG11bHRpLWNsdXN0ZXIgYnVpbGQgaXMg" + - "bG9jYWwgfCBgazNkIGltYWdlIGltcG9ydCBudmNyLmlvLy4uLi9udmNhLW9wZXJhdG9yOnBzYXQg" + - "LWMgPGNsdXN0ZXI+YCB8CgojIyBDb21wdXRlLXBsYW5lIHJ1bnRpbWUKCnwgU3ltcHRvbSB8IENh" + - "dXNlIHwgUmVtZWRpYXRpb24gfAp8LS0tfC0tLXwtLS18CnwgTlZDQSBhZ2VudCBDcmFzaExvb3BC" + - "YWNrT2ZmIHdpdGggYEhUVFAgNDAxYCBvbiBgL3YxL252Y2EvY2x1c3RlcnMvLi4uL3JlZ2lzdGVy" + - "YCB8IFN0YWxlIGBvdXQvPGNsdXN0ZXI+LXJlZ2lzdGVyLXZhbHVlcy55YW1sYCBmcm9tIHByaW9y" + - "IHJlZ2lzdGVyOyBjbHVzdGVyIElEIGRvZXNuJ3QgbWF0Y2ggSUNNUyB8IERlbGV0ZSB0aGUgc3Rh" + - "bGUgZmlsZTsgcmUtcnVuIGBudmNmLWNsaSBzZWxmLWhvc3RlZCB1cGAgKGlkZW1wb3RlbnQgcmVn" + - "aXN0ZXIgd3JpdGVzIGEgZnJlc2ggZmlsZSkgfAp8IGBObyBjbHVzdGVyIGZvdW5kIHdpdGggdmFs" + - "aWQgSldLUyBmb3IgY2x1c3RlciBJRDogPGlkPmAgKElDTVMgbG9nKSB8IEpXS1MgaW4gSUNNUyBk" + - "b2Vzbid0IG1hdGNoIHdoYXQgY29tcHV0ZS1wbGFuZSBLOHMgaXMgY3VycmVudGx5IHNpZ25pbmcg" + - "fCBgbnZjZi1jbGkgY2x1c3RlciByb3RhdGUgLS1jbHVzdGVyLWlkPTxpZD5gIHwKfCBGdW5jdGlv" + - "biBwb2QgYEltYWdlUHVsbEJhY2tPZmZgIGluIGBudmNmLWJhY2tlbmRgIHwgSW1hZ2UtY3JlZGVu" + - "dGlhbC1oZWxwZXIgY29uZmlnIG1pc3Npbmcgb3Igd3JvbmcgfCBga3ViZWN0bCBkZXNjcmliZSBw" + - "b2QgLW4gbnZjZi1iYWNrZW5kIDxwb2Q+YDsgY2hlY2sgdGhlIHB1bGwgc2VjcmV0IGNvbmZpZyB8" + - "CnwgRnVuY3Rpb24gZGVwbG95IHN0dWNrIGBERVBMT1lJTkdgIGZvciA+NSBtaW4gfCBOQVRTIHN0" + - "cmVhbSBpbml0IGxhZyAoY29sZC1jbHVzdGVyKSDigJQgd2FpdCwgb3IgY2hlY2sgTkFUUyBhdXRo" + - "LWNhbGxvdXQgaGVhbHRoIHwgYGt1YmVjdGwgbG9ncyAtbiBuYXRzLXN5c3RlbSAtbCBhcHAua3Vi" + - "ZXJuZXRlcy5pby9uYW1lPW5hdHMtYXV0aC1jYWxsb3V0LXNlcnZpY2VgIHwKCiMjIFRhc2tzCgp8" + - "IFN5bXB0b20gfCBDYXVzZSB8IFJlbWVkaWF0aW9uIHwKfC0tLXwtLS18LS0tfAp8IGB0YXNrIGNy" + - "ZWF0ZWAgcmV0dXJucyBgTWlzc2luZyA8VFlQRT4gcmVnaXN0cnkgY3JlZGVudGlhbCBmb3IgaG9z" + - "dG5hbWVgLCBvciBrZWVwcyB1c2luZyBhIHByZXZpb3VzIGNyZWRlbnRpYWwgdmFsdWUsIHNob3J0" + - "bHkgYWZ0ZXIgYHJlZ2lzdHJ5LWNyZWRlbnRpYWwgYWRkL3VwZGF0ZS9kZWxldGVgIHdoaWxlIGBy" + - "ZWdpc3RyeS1jcmVkZW50aWFsIGxpc3RgL2BnZXRgIGFscmVhZHkgc2hvdyB0aGUgbmV3IHZhbHVl" + - "IHwgRXhwZWN0ZWQgcHJvcGFnYXRpb24gZGVsYXk6IE5WQ1QgY2FjaGVzIHRoZSBhY2NvdW50J3Mg" + - "cmVnaXN0cnkgY3JlZGVudGlhbHMgd2l0aCBgbnZjdC5udmNmLmNhY2hlLXR0bGAgKGRlZmF1bHQg" + - "YFBUNU1gLCBhYm91dCA1IG1pbikgYW5kIGFwcGxpZXMgdGhlIGNoYW5nZSB3aGVuIHRoYXQgY2Fj" + - "aGVkIGNvcHkgcmVmcmVzaGVzIHwgV2FpdCB1cCB0byBhYm91dCA1IG1pbiBhbmQgcmV0cnksIG9y" + - "IGBrdWJlY3RsIC1uIG52Y2Ygcm9sbG91dCByZXN0YXJ0IGRlcGxveW1lbnQvbnZjdC1hcGlgIHRv" + - "IGFwcGx5IGltbWVkaWF0ZWx5IHwKUEsHCPOuE4R0EQAAdBEAAFBLAwQUAAgAAAAAACEAAAAAAAAA" + - "AAAAAAAALAAJAGRhdGEvbnZjZi1zZWxmLW1hbmFnZWQtaW5zdGFsbGF0aW9uL1NLSUxMLm1kVVQF" + - "AAEAps4SLS0tCm5hbWU6IG52Y2Ytc2VsZi1tYW5hZ2VkLWluc3RhbGxhdGlvbgpkZXNjcmlwdGlv" + - "bjogPi0KICBJbnN0YWxsIGFuZCBvcGVyYXRlIE5WQ0Ygc2VsZi1ob3N0ZWQgY29udHJvbC1wbGFu" + - "ZSBhbmQgc2VwYXJhdGUgY29tcHV0ZS1wbGFuZQogIHN0YWNrcy4gQ292ZXJzIEhlbG1maWxlIHZh" + - "bHVlcyBhbmQgQ0xJIHByb2ZpbGUgaW5zdGFsbGF0aW9uIGZsb3dzLCB0ZWFyZG93biwKICB2YWx1" + - "ZXMgb3ZlcnJpZGVzLCBwdWxsIHNlY3JldHMsIGFuZCB0cm91Ymxlc2hvb3RpbmcuIFVzZSBmb3IK" + - "ICBudmNmLXNlbGYtbWFuYWdlZC1zdGFjaywgbnZjZi1jb21wdXRlLXBsYW5lLXN0YWNrLCBzcGxp" + - "dCBjb21wdXRlLXBsYW5lCiAgaW5zdGFsbGF0aW9uLCBjb250cm9sLXBsYW5lIGluc3RhbGxhdGlv" + - "biwgQ0xJLWdlbmVyYXRlZCBjb250cm9sLXBsYW5lCiAgcHJvZmlsZXMsIEhlbG1maWxlLCBzZWxm" + - "LW1hbmFnZWQsIG9yIHNlbGYtaG9zdGVkIGRlcGxveW1lbnRzLiBEbyBOT1QgdXNlIGZvcgogIGxv" + - "Y2FsIGszZCBlbnZpcm9ubWVudHM7IHVzZSB0aGUgbG9jYWwgazNkIGRldmVsb3BtZW50IHdvcmtm" + - "bG93IGluc3RlYWQuCmxpY2Vuc2U6IEFwYWNoZS0yLjAKY29tcGF0aWJpbGl0eTogUmVxdWlyZXMg" + - "aGVsbWZpbGUgPj0gMS4xLjAgPCAxLjIuMCwgaGVsbSA+PSAzLjEyLCBoZWxtLWRpZmYgcGx1Z2lu" + - "LCBrdWJlY3RsIG1hdGNoaW5nIGNsdXN0ZXIgdmVyc2lvbgphdXRob3I6ICJudmNmLWNvcmUtZW5n" + - "IDxudmNmLWNvcmUtZW5nQGV4Y2hhbmdlLm52aWRpYS5jb20+Igp2ZXJzaW9uOiAiMS4wLjAiCnRh" + - "Z3M6IFtudmNmLCBzZWxmLW1hbmFnZWQsIGhlbG1maWxlLCBzZWxmLWhvc3RlZCwgY29udHJvbC1w" + - "bGFuZSwgY29tcHV0ZS1wbGFuZSwgY2xpLXByb2ZpbGUsIGluc3RhbGxhdGlvbiwgZGVwbG95bWVu" + - "dCwgcHVsbC1zZWNyZXRzXQp0b29sczogW1NoZWxsLCBSZWFkLCBFZGl0LCBHcmVwLCBHbG9iXQpt" + - "ZXRhZGF0YToKICBpbnRlcm5hbDogZmFsc2UKICBhdXRob3I6ICJudmNmLWNvcmUtZW5nIDxudmNm" + - "LWNvcmUtZW5nQGV4Y2hhbmdlLm52aWRpYS5jb20+IgogIHZlcnNpb246ICIxLjAiCiAgdGFnczog" + - "W252Y2YsIHNlbGYtbWFuYWdlZCwgaGVsbWZpbGUsIHNlbGYtaG9zdGVkLCBjb250cm9sLXBsYW5l" + - "LCBjb21wdXRlLXBsYW5lLCBjbGktcHJvZmlsZSwgaW5zdGFsbGF0aW9uLCBkZXBsb3ltZW50LCBw" + - "dWxsLXNlY3JldHNdCiAgbGFuZ3VhZ2VzOiBbYmFzaCwgeWFtbF0KICBmcmFtZXdvcmtzOiBbaGVs" + - "bWZpbGUsIGhlbG0sIGt1YmVjdGxdCiAgZG9tYWluOiBjbG91ZC1pbmZyYXN0cnVjdHVyZQotLS0K" + - "CiMgTlZDRiBTZWxmLU1hbmFnZWQgU3RhY2sgT3BlcmF0aW9ucwoKT3BlcmF0aW9uYWwgZ3VpZGUg" + - "Zm9yIG1hdGNoaW5nIE5WQ0YgY29udHJvbC1wbGFuZSBhbmQgY29tcHV0ZS1wbGFuZSBIZWxtZmls" + - "ZSBidW5kbGVzLgoKIyMgSW5zdHJ1Y3Rpb25zCgpVc2UgdGhpcyBza2lsbCBmb3IgaW5zdGFsbCwg" + - "dXBncmFkZSwgb3IgdGVhcmRvd24gd29yayBpbiBtYXRjaGluZyBgbnZjZi1zZWxmLW1hbmFnZWQt" + - "c3RhY2tgIGFuZCBgbnZjZi1jb21wdXRlLXBsYW5lLXN0YWNrYCBidW5kbGVzOyBrZWVwIEhlbG1m" + - "aWxlIHZhbHVlcyBhbmQgQ0xJIHByb2ZpbGUgaGFuZG9mZnMgc2VwYXJhdGUuIEZvciBgZnVuY3Rp" + - "b25UeXBlOiAiTExNImAsIHJlYWQgW0xMTSBGdW5jdGlvbiBFbmFibGVtZW50XShyZWZlcmVuY2Vz" + - "L2hlbG1maWxlLXN0cnVjdHVyZS5tZCNsbG0tZnVuY3Rpb24tZW5hYmxlbWVudCkuCgojIyBQcmVy" + - "ZXF1aXNpdGVzCgpBc2sgZm9yIHRoZSBleHRyYWN0ZWQgYG52Y2Ytc2VsZi1tYW5hZ2VkLXN0YWNr" + - "YCBwYXRoLiBGb3Igc3BsaXQgaW5zdGFsbGF0aW9uLAphbHNvIHJlcXVpcmUgdGhlIG1hdGNoaW5n" + - "LXZlcnNpb24gYG52Y2YtY29tcHV0ZS1wbGFuZS1zdGFja2AgcGF0aC4gVmVyaWZ5IGJvdGg6Cgpg" + - "YGBiYXNoCmxzIDxjb250cm9sLXBsYW5lLXN0YWNrPi9oZWxtZmlsZS5kLyA8Y29udHJvbC1wbGFu" + - "ZS1zdGFjaz4vZW52aXJvbm1lbnRzLyA8Y29udHJvbC1wbGFuZS1zdGFjaz4vc2VjcmV0cy8gPGNv" + - "bnRyb2wtcGxhbmUtc3RhY2s+L2dsb2JhbC55YW1sLmdvdG1wbApscyA8Y29tcHV0ZS1wbGFuZS1z" + - "dGFjaz4vaGVsbWZpbGUuZC8gPGNvbXB1dGUtcGxhbmUtc3RhY2s+L2Vudmlyb25tZW50cy8gPGNv" + - "bXB1dGUtcGxhbmUtc3RhY2s+L2dsb2JhbC55YW1sLmdvdG1wbApgYGAKCklmIGVpdGhlciBkaXJl" + - "Y3RvcnkgaXMgbWlzc2luZywgZG93bmxvYWQgbWF0Y2hpbmcgYnVuZGxlIHZlcnNpb25zIGZyb20g" + - "TkdDOgoKYGBgYmFzaApuZ2MgcmVnaXN0cnkgcmVzb3VyY2UgZG93bmxvYWQtdmVyc2lvbiA8b3Jn" + - "Pi9udmNmLXNlbGYtbWFuYWdlZC1zdGFjazo8dmVyc2lvbj4KbmdjIHJlZ2lzdHJ5IHJlc291cmNl" + - "IGRvd25sb2FkLXZlcnNpb24gPG9yZz4vbnZjZi1jb21wdXRlLXBsYW5lLXN0YWNrOjx2ZXJzaW9u" + - "PgpgYGAKCkNvbnRyb2wtcGxhbmUgY29tbWFuZHMgYmVsb3cgYXNzdW1lIHRoZSBjb250cm9sLXBs" + - "YW5lIGJ1bmRsZSByb290LiBTcGxpdC1mbG93CmNvbW1hbmRzIGFuZCByb290IHN1YnN0aXR1dGlv" + - "biBhcmUgaW4KW1NwbGl0IENvbXB1dGUtUGxhbmUgSW5zdGFsbGF0aW9uXShyZWZlcmVuY2VzL2Nv" + - "bXB1dGUtcGxhbmUtaW5zdGFsbGF0aW9uLm1kKS4KCiMjIEJlZm9yZSBZb3UgU3RhcnQKClZlcmlm" + - "eSB0b29saW5nIGFuZCBjb250ZXh0IGJlZm9yZSBhbnkgb3BlcmF0aW9uOgoKYGBgYmFzaApoZWxt" + - "ZmlsZSAtLXZlcnNpb24gICAjIE11c3QgYmUgMS4xLnggKDEuMi4wIHJlbW92ZWQgc2VxdWVudGlh" + - "bCBtb2RlKQpoZWxtIHZlcnNpb24gICAgICAgICAjIE11c3QgYmUgPj0gMy4xMgpoZWxtIHBsdWdp" + - "biBsaXN0ICAgICAjIE11c3QgaW5jbHVkZSBoZWxtLWRpZmYgPj0gMy4xMQprdWJlY3RsIHZlcnNp" + - "b24gICAgICAjIENsaWVudCBtdXN0IGJlIHdpdGhpbiAxIG1pbm9yIHZlcnNpb24gb2YgY2x1c3Rl" + - "cgpgYGAKCkNvbnRyb2wtcGxhbmUgY29tbWFuZHMgcnVuIGZyb20gdGhlIGV4dHJhY3RlZCBgbnZj" + - "Zi1zZWxmLW1hbmFnZWQtc3RhY2svYCByb290OgoKYGBgYmFzaApjZCBwYXRoL3RvL252Y2Ytc2Vs" + - "Zi1tYW5hZ2VkLXN0YWNrCmxzIGhlbG1maWxlLmQvIGVudmlyb25tZW50cy8gc2VjcmV0cy8gZ2xv" + - "YmFsLnlhbWwuZ290bXBsCmBgYAoKSWRlbnRpZnkgdGhlIGVudmlyb25tZW50IGZyb20gYGVudmly" + - "b25tZW50cy88bmFtZT4ueWFtbGAgYW5kCmBzZWNyZXRzLzxuYW1lPi1zZWNyZXRzLnlhbWxgOyBm" + - "b3IgRUtTLCB1c2UgdGhlIGNhbm9uaWNhbApbQ1NQIEVuZC10by1FbmQgRXhhbXBsZV0oaHR0cHM6" + - "Ly9kb2NzLm52aWRpYS5jb20vbnZjZi92MC42LjAtcmMvY3NwLWVuZC10by1lbmQtZXhhbXBsZSku" + - "CgojIyBIb3cgVmFsdWVzIEZsb3cKClVuZGVyc3RhbmRpbmcgdmFsdWUgcHJlY2VkZW5jZSBwcmV2" + - "ZW50cyB0aGUgbW9zdCBjb21tb24gY29uZmlndXJhdGlvbiBtaXN0YWtlcy4KCmBgYAplbnZpcm9u" + - "bWVudHMvYmFzZS55YW1sICAgICAgICAgIChkZWZhdWx0cykKICAgIC0+IG1lcmdlZCB3aXRoCmVu" + - "dmlyb25tZW50cy88ZW52Pi55YW1sICAgICAgICAgKHlvdXIgb3ZlcnJpZGVzKQogICAgLT4gY29u" + - "c3VtZWQgYnkKZ2xvYmFsLnlhbWwuZ290bXBsICAgICAgICAgICAgICAoR28gdGVtcGxhdGUsIGNv" + - "bnN0cnVjdHMgcGVyLWNoYXJ0IHZhbHVlcykKICAgIC0+IGNvbnN1bWVkIGJ5CnNlY3JldHMvPGVu" + - "dj4tc2VjcmV0cy55YW1sICAgICAgKHNlbnNpdGl2ZSB2YWx1ZXMpCiAgICAtPiBvdmVycmlkZGVu" + - "IGJ5CnJlbGVhc2UgaW5saW5lIHZhbHVlczogYmxvY2tzICAgKGhpZ2hlc3QgcHJlY2VkZW5jZSkK" + - "YGBgCgpDcml0aWNhbDogYGdsb2JhbC55YW1sLmdvdG1wbGAgb25seSBwYXNzZXMgdGhyb3VnaCBz" + - "cGVjaWZpYyBrZXlzIHRvIGVhY2ggY2hhcnQgKGltYWdlIHJlZ2lzdHJpZXMsIG5vZGUgc2VsZWN0" + - "b3JzLCBzdG9yYWdlLCByZXBsaWNhIGNvdW50cykuIFNldHRpbmcgYW4gYXJiaXRyYXJ5IGNoYXJ0" + - "IHZhbHVlIGluIHRoZSBlbnZpcm9ubWVudCBmaWxlIHdpbGwgYmUgc2lsZW50bHkgaWdub3JlZCBp" + - "ZiBgZ2xvYmFsLnlhbWwuZ290bXBsYCBkb2VzIG5vdCBwcm9wYWdhdGUgaXQuCgpUbyBvdmVycmlk" + - "ZSBhcmJpdHJhcnkgY2hhcnQgdmFsdWVzLCB1c2UgYSBoZWxtZmlsZSByZWxlYXNlIGB2YWx1ZXM6" + - "YCBibG9jay4gU2VlIFtPdmVycmlkaW5nIEhlbG0gQ2hhcnQgVmFsdWVzXSgjb3ZlcnJpZGluZy1o" + - "ZWxtLWNoYXJ0LXZhbHVlcykuCgojIyBDbGVhbiBJbnN0YWxsYXRpb24KCiMjIyAxLiBDcmVhdGUg" + - "bmFtZXNwYWNlcyBhbmQgaW1hZ2UgcHVsbCBzZWNyZXRzIChpZiB1c2luZyBhIHByaXZhdGUgcmVn" + - "aXN0cnkpCgpgYGBiYXNoCmZvciBucyBpbiBjYXNzYW5kcmEtc3lzdGVtIG5hdHMtc3lzdGVtIG52" + - "Y2YgYXBpLWtleXMgZXNzIHNpcyB2YXVsdC1zeXN0ZW0gY2VydC1tYW5hZ2VyOyBkbwogIGt1YmVj" + - "dGwgY3JlYXRlIG5hbWVzcGFjZSAiJG5zIiAtLWRyeS1ydW49Y2xpZW50IC1vIHlhbWwgfCBrdWJl" + - "Y3RsIGFwcGx5IC1mIC0KZG9uZQoKIyBPbmx5IGlmIHB1bGxpbmcgZnJvbSBhIHByaXZhdGUgcmVn" + - "aXN0cnkgKGUuZy4sIE5HQyBudmNyLmlvKQpleHBvcnQgTkdDX0FQSV9LRVk9Ijx5b3VyLWtleT4i" + - "CmZvciBucyBpbiBjYXNzYW5kcmEtc3lzdGVtIG5hdHMtc3lzdGVtIG52Y2YgYXBpLWtleXMgZXNz" + - "IHNpcyB2YXVsdC1zeXN0ZW0gY2VydC1tYW5hZ2VyOyBkbwogIGt1YmVjdGwgY3JlYXRlIHNlY3Jl" + - "dCBkb2NrZXItcmVnaXN0cnkgbnZjci1jcmVkcyBcCiAgICAtLWRvY2tlci1zZXJ2ZXI9bnZjci5p" + - "byBcCiAgICAtLWRvY2tlci11c2VybmFtZT0nJG9hdXRodG9rZW4nIFwKICAgIC0tZG9ja2VyLXBh" + - "c3N3b3JkPSIkTkdDX0FQSV9LRVkiIFwKICAgIC0tbmFtZXNwYWNlPSIkbnMiIFwKICAgIC0tZHJ5" + - "LXJ1bj1jbGllbnQgLW8geWFtbCB8IGt1YmVjdGwgYXBwbHkgLWYgLQpkb25lCmBgYAoKSWYgdXNp" + - "bmcgcHVsbCBzZWNyZXRzLCB5b3UgbXVzdCBhbHNvIGNvbmZpZ3VyZSBlYWNoIGhlbG1maWxlIHJl" + - "bGVhc2UgdG8gcmVmZXJlbmNlIHRoZW0uIFNlZSBbSW1hZ2UgUHVsbCBTZWNyZXRzXSgjaW1hZ2Ut" + - "cHVsbC1zZWNyZXRzKS4KCiMjIyAyLiBBdXRoZW50aWNhdGUgaGVsbSB0byB5b3VyIGNoYXJ0IHJl" + - "Z2lzdHJ5CgpCb3RoIGBkb2NrZXIgbG9naW5gIEFORCBgaGVsbSByZWdpc3RyeSBsb2dpbmAgYXJl" + - "IHJlcXVpcmVkIGZvciBOR0MuIEhlbG1maWxlIHVzZXMgaGVsbSAobm90IGRvY2tlcikgdG8gcHVs" + - "bCBPQ0kgY2hhcnRzLCBzbyB0aGUgaGVsbSBjcmVkZW50aWFsIHN0b3JlIG11c3QgYmUgYXV0aGVu" + - "dGljYXRlZCBzZXBhcmF0ZWx5LgoKYGBgYmFzaAojIE5HQyAtLSBib3RoIGNvbW1hbmRzIGFyZSBy" + - "ZXF1aXJlZApkb2NrZXIgbG9naW4gbnZjci5pbyAtdSAnJG9hdXRodG9rZW4nIC1wICIkTkdDX0FQ" + - "SV9LRVkiCmhlbG0gcmVnaXN0cnkgbG9naW4gbnZjci5pbyAtdSAnJG9hdXRodG9rZW4nIC1wICIk" + - "TkdDX0FQSV9LRVkiCgojIEVDUgphd3MgZWNyIGdldC1sb2dpbi1wYXNzd29yZCAtLXJlZ2lvbiA8" + - "cmVnaW9uPiB8IFwKICBoZWxtIHJlZ2lzdHJ5IGxvZ2luIC0tdXNlcm5hbWUgQVdTIC0tcGFzc3dv" + - "cmQtc3RkaW4gPGFjY291bnQ+LmRrci5lY3IuPHJlZ2lvbj4uYW1hem9uYXdzLmNvbQpgYGAKCj4g" + - "Tm90ZTogYGhlbG0gcmVnaXN0cnkgbG9naW5gIGtlZXBzIG9ubHkgdGhlIGxhc3QgbG9naW4gcGVy" + - "IGhvc3QgKG11bHRpLW9yZyBnb3RjaGEpLgo+IFRoZSBzdGFjayBhbmQgdGhlIGNhY2hlcyBzcGFu" + - "IHNldmVyYWwgTkdDIG9yZ3MgdGhhdCBuZWVkIGRpZmZlcmVudCBrZXlzLCBidXQgdGhleSBhbGwK" + - "PiBsaXZlIHVuZGVyIHRoZSBvbmUgaG9zdCBgbnZjci5pb2AuIEEgc2Vjb25kIGBoZWxtIHJlZ2lz" + - "dHJ5IGxvZ2luIG52Y3IuaW9gIChvcgo+IGBkb2NrZXIgbG9naW5gKSB3aXRoIGEgZGlmZmVyZW50" + - "IGtleSBzaWxlbnRseSBvdmVyd3JpdGVzIHRoZSBmaXJzdCwgc28gcHVsbHMgZm9yIHRoZQo+IGZp" + - "cnN0IG9yZyB0aGVuIGZhaWwgd2l0aCBhIG1pc2xlYWRpbmcgYDQwMyBBY2Nlc3MgRGVuaWVkYCAo" + - "bm90IGEgNDAxOiB0aGUgYXV0aAo+IHN1Y2NlZWRlZCwgaXQncyB0aGUgd3Jvbmctb3JnIGtleSku" + - "IElmIHlvdSBwdWxsIGNoYXJ0cy9pbWFnZXMgZnJvbSBtb3JlIHRoYW4gb25lIG9yZywKPiBlaXRo" + - "ZXIgcmUtcnVuIHRoZSBsb2dpbiB3aXRoIHRoZSBjb3JyZWN0IGtleSBpbW1lZGlhdGVseSBiZWZv" + - "cmUgZWFjaCBwdWxsLCBvciBwYXNzCj4gYC0tdXNlcm5hbWUgJyRvYXV0aHRva2VuJyAtLXBhc3N3" + - "b3JkIDxrZXk+YCBwZXIgYGhlbG0gcHVsbGAgaW52b2NhdGlvbiBpbnN0ZWFkIG9mIHJlbHlpbmcK" + - "PiBvbiB0aGUgc3RvcmVkIGxvZ2luLiAoUHVsbGluZyBldmVyeXRoaW5nIGZyb20gYSBzaW5nbGUg" + - "cmVnaXN0cnkgbWlycm9yIGF2b2lkcyB0aGlzCj4gZW50aXJlbHkuKQoKIyMjIDJiLiAoUmVjb21t" + - "ZW5kZWQpIFB1bGwgZnJvbSBhIHJlZ2lzdHJ5IHRoZSBjbHVzdGVyIGF1dGhlbnRpY2F0ZXMgdG8g" + - "YXV0b21hdGljYWxseQoKSWYgeW91IG1pcnJvciB0aGUgTlZDRiBpbWFnZXMgaW50byBhIHJlZ2lz" + - "dHJ5IHRoYXQgdGhlIGNsdXN0ZXIgY2FuIHB1bGwgZnJvbSB3aXRob3V0IGFuCmV4cGxpY2l0IGlt" + - "YWdlIHB1bGwgc2VjcmV0IChmb3IgZXhhbXBsZSwgYSByZWdpc3RyeSB3aGVyZSB0aGUgbm9kZSBv" + - "ciB3b3JrbG9hZCBpZGVudGl0eSBpcwpncmFudGVkIHB1bGwgYWNjZXNzIGF1dG9tYXRpY2FsbHkp" + - "LCBwb2ludCB0aGUgc3RhY2sgYXQgaXQgYW5kIHNraXAgdGhlIGNyZWRlbnRpYWwgc3RlcHMKYWJv" + - "dmUuCgoxLiBQb2ludCB0aGUgc3RhY2sgYXQgdGhlIG1pcnJvciBpbiBgZW52aXJvbm1lbnRzLzxl" + - "bnY+LnlhbWxgOgoKICAgYGBgeWFtbAogICBnbG9iYWw6CiAgICAgaW1hZ2U6CiAgICAgICByZWdp" + - "c3RyeTogPHlvdXItcmVnaXN0cnk+ICAgICAgICAgICAgIyBlLmcuIHJlZ2lzdHJ5LmV4YW1wbGUu" + - "Y29tCiAgICAgICByZXBvc2l0b3J5OiA8bWlycm9yLXN1Yi1wYXRoPgogICAgIGhlbG06CiAgICAg" + - "ICBzb3VyY2VzOiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICMgb25seSBpZiB5b3UgYWxz" + - "byBtaXJyb3JlZCB0aGUgaGVsbSBjaGFydHMKICAgICAgICAgcmVnaXN0cnk6IDx5b3VyLXJlZ2lz" + - "dHJ5PgogICAgICAgICByZXBvc2l0b3J5OiA8bWlycm9yLXN1Yi1wYXRoPgogICBgYGAKCiAgID4g" + - "VGhlIG1hbmlmZXN0IGhhcyBhIG1peCBvZiBPQ0kgYW5kIG5vbi1PQ0kgYXJ0aWZhY3RzLCBzbyBj" + - "b252ZXJ0IG5vbi1PQ0kgY2hhcnRzIGJlZm9yZQogICA+IG1pcnJvcmluZy4gQ29udGFpbmVyIGlt" + - "YWdlcyAoYG52Y3IuaW8vLi4uYCkgYXJlIGFscmVhZHkgT0NJIGFuZCBtaXJyb3IgYXMtaXMuIFNv" + - "bWUgSGVsbQogICA+IGNoYXJ0cywgdGhvdWdoLCBhcmUgcHVibGlzaGVkIHRvIGFuIGBodHRwczov" + - "L2AgSGVsbSByZXBvc2l0b3J5IChmb3IgZXhhbXBsZQogICA+IGBoZWxtLm5nYy5udmlkaWEuY29t" + - "YCkuIFRob3NlIGFyZSBub3QgT0NJIGFuZCBjYW5ub3QgYmUgcmVzb2x2ZWQgYnkgYGdsb2JhbC5o" + - "ZWxtLnNvdXJjZXNgCiAgID4gKE9DSSkgb3IgbWlycm9yZWQgZGlyZWN0bHkuIEJlZm9yZSBwb2lu" + - "dGluZyB0aGUgc3RhY2sgYXQgeW91ciBtaXJyb3IsIGNvbnZlcnQgZWFjaAogICA+IGBodHRwczov" + - "L2AgY2hhcnQgdG8gT0NJOiBgaGVsbSByZXBvIGFkZGAvYGhlbG0gcHVsbGAgdGhlIGAudGd6YCwg" + - "dGhlbgogICA+IGBoZWxtIHB1c2ggPGNoYXJ0Pi50Z3ogb2NpOi8vPHlvdXItcmVnaXN0cnk+Lzxt" + - "aXJyb3Itc3ViLXBhdGg+YC4gT25seSBPQ0kgY2hhcnRzIGNhbiBsaXZlCiAgID4gdW5kZXIgYGds" + - "b2JhbC5oZWxtLnNvdXJjZXNgLgoKMi4gU2tpcCB0aGUgY3JlZGVudGlhbCBzdGVwcyBhYm92ZS4g" + - "V2hlbiB0aGUgY2x1c3RlciBhdXRoZW50aWNhdGVzIHRvIHRoZSByZWdpc3RyeQogICBhdXRvbWF0" + - "aWNhbGx5ICh0aGUgbm9kZSBvciB3b3JrbG9hZCBpZGVudGl0eSBoYXMgcHVsbCBhY2Nlc3MpLCB0" + - "aGUgcHVsbCBuZWVkcyBubwogICBLdWJlcm5ldGVzIHNlY3JldCwgc28geW91IGRvIG5vdCBuZWVk" + - "OiB0aGUgcGVyLW5hbWVzcGFjZSBgbnZjci1jcmVkc2AgZnJvbSBzdGVwIDEKICAgKHN0aWxsIGNy" + - "ZWF0ZSB0aGUgbmFtZXNwYWNlcywganVzdCBub3QgdGhlIHNlY3JldCksIHRoZSBgZ2xvYmFsLmlt" + - "YWdlUHVsbFNlY3JldHNgIGVudHJ5LAogICBvciB0aGUgYGRvY2tlciBsb2dpbmAvYGhlbG0gcmVn" + - "aXN0cnkgbG9naW4gbnZjci5pb2AgZnJvbSBzdGVwIDIuCgogICA+IE9uZSByZXNpZHVhbCBjcmVk" + - "ZW50aWFsOiBudmNmLWFwaSBzdGlsbCB2YWxpZGF0ZXMgdGhlIHVzZXIgZnVuY3Rpb24gaW1hZ2Ug" + - "YXQKICAgPiBgZnVuY3Rpb24gY3JlYXRlYCB2aWEgdGhlIGFjY291bnQgcmVnaXN0cnkgY3JlZGVu" + - "dGlhbCwgc28gdGhhdCBjcmVkZW50aWFsIG11c3QgcG9pbnQgYXQKICAgPiB3aGljaGV2ZXIgcmVn" + - "aXN0cnkgaG9sZHMgdGhlIHVzZXIgaW1hZ2UgKHNldCBpdCB0byB5b3VyIG1pcnJvciBpZiB0aGUg" + - "aW1hZ2UgaXMgbWlycm9yZWQKICAgPiB0aGVyZSkuCgojIyMgMy4gU2V0IHRoZSByb3V0ZSBkb21h" + - "aW4KCmBnbG9iYWwuZG9tYWluYCBzZXRzIHRoZSBob3N0bmFtZSBzdWZmaXggZm9yIHJvdXRlcyBz" + - "dWNoIGFzIGBhcGkuPGRvbWFpbj5gLiBJdCBkb2VzIG5vdCBjb25maWd1cmUgdGhlIEdhdGV3YXkg" + - "b3IgaXRzIGxvYWQgYmFsYW5jZXIuIFF1ZXJ5IHRoZSBleGFjdCBleGlzdGluZyBHYXRld2F5OgoK" + - "YGBgYmFzaApHQVRFV0FZX0FERFJFU1M9JChrdWJlY3RsIGdldCBnYXRld2F5IDxnYXRld2F5LW5h" + - "bWU+IC1uIDxnYXRld2F5LW5hbWVzcGFjZT4gLW8ganNvbnBhdGg9J3suc3RhdHVzLmFkZHJlc3Nl" + - "c1swXS52YWx1ZX0nKQp0ZXN0IC1uICIkR0FURVdBWV9BRERSRVNTIgpgYGAKClRoZSBhZGRyZXNz" + - "IG1heSBiZSBhIGhvc3RuYW1lIG9yIElQLiBDbG91ZCBwcm92aWRlciBhbmQgR2F0ZXdheSBjb25m" + - "aWd1cmF0aW9uIGRldGVybWluZSB0aGUgbG9hZCBiYWxhbmNlciB0eXBlIGFuZCBhZGRyZXNzIGZv" + - "cm1hdC4gVGhlIHNlbGYtbWFuYWdlZCBzdGFjayBkb2VzIG5vdCBzZWxlY3QgZWl0aGVyLgoKRm9y" + - "IHRlbXBvcmFyeSB0ZXN0aW5nIHdpdGhvdXQgRE5TLCB1c2UgYSBzdGFibGUgcmVzZXJ2ZWQgc3Vm" + - "Zml4IHN1Y2ggYXMgYGdsb2JhbC5kb21haW46ICJudmNmLnRlc3QiYCwgY29ubmVjdCB0byBgR0FU" + - "RVdBWV9BRERSRVNTYCwgYW5kIHNlbmQgYEhvc3Q6IGFwaS5udmNmLnRlc3RgLiBGb3IgcHJvZHVj" + - "dGlvbiwgdXNlIHlvdXIgYmFzZSBETlMgZG9tYWluIGFuZCBwb2ludCBpdHMgcm91dGUgcmVjb3Jk" + - "cyB0byBgR0FURVdBWV9BRERSRVNTYC4gSWYgdGhlIGVuZHBvaW50IGxhdGVyIGNoYW5nZXMsIGtl" + - "ZXAgYGdsb2JhbC5kb21haW5gIHN0YWJsZSBhbmQgdXBkYXRlIG9ubHkgRE5TIG9yIHRoZSBjbGll" + - "bnQgZGVzdGluYXRpb24uIFNlZSBFeGFtcGxlIDQgaW4gW2V4YW1wbGVzLm1kXShleGFtcGxlcy5t" + - "ZCkuCgojIyMgNC4gUHJldmlldyBhbmQgZGVwbG95CgpgYGBiYXNoCkhFTE1GSUxFX0VOVj08ZW52" + - "LW5hbWU+IGhlbG1maWxlIHRlbXBsYXRlICAgIyBQcmV2aWV3IHJlbmRlcmVkIG1hbmlmZXN0cwpI" + - "RUxNRklMRV9FTlY9PGVudi1uYW1lPiBoZWxtZmlsZSBzeW5jICAgICAgICMgRGVwbG95CmBgYAoK" + - "PiBTZXQgQk9USCBDYXNzYW5kcmEgcGFzc3dvcmRzIGluIHRoZSBzZWNyZXRzIGZpbGUuIFRoZSBz" + - "ZWNyZXRzIGZpbGUgZG9jdW1lbnRzCj4gYERFRkFVTFRfQ0FTU0FORFJBX1BBU1NXT1JEYCwgYnV0" + - "IHRoZSBjYXNzYW5kcmEgY2hhcnQgaGFzIGEgc2Vjb25kIGNyZWRlbnRpYWwsCj4gYGNhc3NhbmRy" + - "YS5zZXJ2aWNlUm9sZVBhc3N3b3JkYCwgdGhhdCBkZWZhdWx0cyB0byBgY2hAbmczbTNgLiBJZiB5" + - "b3Ugc2V0IG9ubHkKPiBgREVGQVVMVF9DQVNTQU5EUkFfUEFTU1dPUkRgLCB0aGUgc2VydmljZSBy" + - "b2xlIGtlZXBzIHRoYXQgZGVmYXVsdCBhbmQgZXZlcnkgREItYmFja2VkCj4gc2VydmljZSBjcmFz" + - "aC1sb29wcyB3aXRoIGBCYWQgY3JlZGVudGlhbHNgIG9uY2UgaXQgdHJpZXMgdG8gYXV0aGVudGlj" + - "YXRlLiBTZXQKPiBgY2Fzc2FuZHJhLnNlcnZpY2VSb2xlUGFzc3dvcmRgIHRvIHRoZSBzYW1lIHZh" + - "bHVlIGFzIGBERUZBVUxUX0NBU1NBTkRSQV9QQVNTV09SRGAuCgojIyMgNS4gRGVwbG95bWVudCBw" + - "aGFzZXMKCkhlbG1maWxlIGRlcGxveXMgaW4gb3JkZXIgd2l0aCBkZXBlbmRlbmNpZXM6Cgp8IFBo" + - "YXNlIHwgU2VsZWN0b3IgfCBTZXJ2aWNlcyB8IFdhaXQgdGltZSB8CnwtLS0tLS0tfC0tLS0tLS0t" + - "LS18LS0tLS0tLS0tLXwtLS0tLS0tLS0tLXwKfCAxIHwgYHJlbGVhc2UtZ3JvdXA9ZGVwZW5kZW5j" + - "aWVzYCB8IE5BVFMsIE9wZW5CYW8sIENhc3NhbmRyYSB8IDUtMTAgbWluIHwKfCAyIHwgYHJlbGVh" + - "c2UtZ3JvdXA9c2VydmljZXNgIHwgQVBJLCBTSVMsIEVTUywgaW52b2NhdGlvbiwgZ3JwYy1wcm94" + - "eSwgbm90YXJ5LCBhcGkta2V5cywgb3B0aW9uYWwgTExNIGdhdGV3YXkvcm91dGVyLCBvcHRpb25h" + - "bCBWYW5pdHkgR2F0ZXdheSwgTlZDRiBVSSB3aGVuIHRoZSBzdGFjayBwYWNrYWdlIGluY2x1ZGVz" + - "IHRoZSBhZGRvbiB8IDUtMTAgbWluIHwKfCAzIHwgYHJlbGVhc2UtZ3JvdXA9aW5ncmVzc2AgfCBH" + - "YXRld2F5IHJvdXRlcyB8IDEtMiBtaW4gfAp8IDQgfCBgcmVsZWFzZS1ncm91cD1vYnNlcnZhYmls" + - "aXR5YCB8IE9ic2VydmFiaWxpdHkgc3RhY2sgKGlmIGVuYWJsZWQpIHwgMS0yIG1pbiB8CgpNb25p" + - "dG9yIGluIGEgc2VwYXJhdGUgdGVybWluYWw6CgpgYGBiYXNoCmt1YmVjdGwgZ2V0IHBvZHMgLUEg" + - "LXcKYGBgCgojIyMgNi4gRW5hYmxlIFZhbml0eSBHYXRld2F5IChvcHRpb25hbCkKClZhbml0eSBH" + - "YXRld2F5IGlzIGRpc2FibGVkIGJ5IGRlZmF1bHQgYW5kIGlzIG9ubHkgbmVlZGVkIGZvciBjdXN0" + - "b21lci1mYWNpbmcKaG9zdG5hbWVzIG9yIHBhdGggbWFwcGluZ3MgaW4gZnJvbnQgb2YgdGhlIHN0" + - "YW5kYXJkIE5WQ0YgQVBJIGFuZCBpbnZvY2F0aW9uCnJvdXRlcy4gSXQgaXMgYXZhaWxhYmxlIG9u" + - "bHkgaW4gc3RhY2sgcGFja2FnZXMgdGhhdCBpbmNsdWRlIHRoZSBWYW5pdHkgR2F0ZXdheQphZGRv" + - "bi4gSWYgdGhlIGV4dHJhY3RlZCBzdGFjayBwYWNrYWdlIGRvZXMgbm90IGNvbnRhaW4gYSBgdmFu" + - "aXR5LWdhdGV3YXlgCnJlbGVhc2UgYW5kIGB2YW5pdHlHYXRld2F5YCByb3V0ZSB2YWx1ZXMsIHNr" + - "aXAgdGhlc2UgY29tbWFuZHMgYW5kIHVzZSBhIG5ld2VyCnN0YWNrIHBhY2thZ2UgdGhhdCBpbmNs" + - "dWRlcyB0aGVtLgoKSWYgdGhlIHN0YWNrIHBhY2thZ2UgaW5jbHVkZXMgdGhlIGFkZG9uLCBlbmFi" + - "bGUgaXQgaW4KYGVudmlyb25tZW50cy88ZW52LW5hbWU+LnlhbWxgOgoKYGBgeWFtbAphZGRvbnM6" + - "CiAgdmFuaXR5R2F0ZXdheToKICAgIGVuYWJsZWQ6IHRydWUKICAgIG1hcHBpbmdDb25maWc6IHt9" + - "CmBgYAoKVGhlIGRlZmF1bHQgcm91dGUgaG9zdCBpcyBgdmFuaXR5Ljxkb21haW4+YCBhbmQgdGhl" + - "IGJhY2tlbmQgaXMKYHZhbml0eS1nYXRld2F5Lm52Y2Y6ODA4MGAuIFB1dCBkZXBsb3ltZW50LXNw" + - "ZWNpZmljIGhvc3QgYW5kIHBhdGggbWFwcGluZ3MgdW5kZXIKYGFkZG9ucy52YW5pdHlHYXRld2F5" + - "Lm1hcHBpbmdDb25maWdgLiBJZiB5b3UgbmVlZCBjdXN0b20gdmFuaXR5IGhvc3RzIGluc3RlYWQg" + - "b2YKYHZhbml0eS48ZG9tYWluPmAsIHVzZSB0aGUgcm91dGUgaG9zdG5hbWUgb3ZlcnJpZGVzIHN1" + - "cHBvcnRlZCBieSB0aGUgc3RhY2sKcGFja2FnZSBhbmQgY3JlYXRlIG1hdGNoaW5nIEROUyByZWNv" + - "cmRzLgoKQWZ0ZXIgY29uZmlybWluZyB0aGUgcGFja2FnZSBpbmNsdWRlcyB0aGUgYHZhbml0eS1n" + - "YXRld2F5YCByZWxlYXNlLCBwcmV2aWV3IGFuZAphcHBseSB0aGUgc2VydmljZSBhbmQgcm91dGU6" + - "CgpgYGBiYXNoCkhFTE1GSUxFX0VOVj08ZW52LW5hbWU+IGhlbG1maWxlIC0tc2VsZWN0b3IgbmFt" + - "ZT12YW5pdHktZ2F0ZXdheSB0ZW1wbGF0ZQpIRUxNRklMRV9FTlY9PGVudi1uYW1lPiBoZWxtZmls" + - "ZSAtLXNlbGVjdG9yIG5hbWU9dmFuaXR5LWdhdGV3YXkgc3luYwpIRUxNRklMRV9FTlY9PGVudi1u" + - "YW1lPiBoZWxtZmlsZSAtLXNlbGVjdG9yIHJlbGVhc2UtZ3JvdXA9aW5ncmVzcyBzeW5jCmBgYAoK" + - "VmVyaWZ5IHRoZSByb3V0ZSBvbmx5IHdoZW4gdGhlIGFkZG9uIGlzIHByZXNlbnQgYW5kIGVuYWJs" + - "ZWQ6CgpgYGBiYXNoCmt1YmVjdGwgZ2V0IGRlcGxveSxzdmMgLW4gbnZjZiAtbCBhcHAua3ViZXJu" + - "ZXRlcy5pby9uYW1lPXZhbml0eS1nYXRld2F5Cmt1YmVjdGwgZ2V0IGh0dHByb3V0ZSAtQSB8IGdy" + - "ZXAgLWkgdmFuaXR5CmN1cmwgLUggIkhvc3Q6IHZhbml0eS48ZG9tYWluPiIgImh0dHA6Ly88Z2F0" + - "ZXdheS1hZGRyZXNzPi9oZWFsdGgiCmBgYAoKRG8gbm90IGVuYWJsZSBWYW5pdHkgR2F0ZXdheSBm" + - "b3Igc3RhbmRhcmQgQVBJLCBBUEkgS2V5cywgaW52b2NhdGlvbiwgTExNCmludm9jYXRpb24sIG9y" + - "IGdSUEMgdHJhZmZpYy4gVGhvc2Ugcm91dGVzIGFyZSBwcm92aWRlZCBieSB0aGUgYmFzZSBnYXRl" + - "d2F5CnJvdXRlcy4KCiMjIyA3LiBFbmFibGUgTlZDRiBVSSAob3B0aW9uYWwpCgpOVkNGIFVJIGlz" + - "IGFuIG9wdGlvbmFsLCBjdXN0b21lci1mYWNpbmcgYWRtaW4tcGFuZWwgVUkuIEl0IGlzIGRpc2Fi" + - "bGVkIGJ5CmRlZmF1bHQgYW5kIGF2YWlsYWJsZSBvbmx5IGluIHN0YWNrIHBhY2thZ2VzIHRoYXQg" + - "aW5jbHVkZSB0aGUgTlZDRiBVSSBhZGRvbi4gSWYKeW91ciBleHRyYWN0ZWQgc3RhY2sgcGFja2Fn" + - "ZSBkb2VzIG5vdCBjb250YWluIGEgYG52Y2YtdWlgIHJlbGVhc2UgYW5kIGBudmNmVWlgCnJvdXRl" + - "IHZhbHVlcywgc2tpcCB0aGlzIHNlY3Rpb24uIFRoZSBOVkNGIFVJIGFkbWluIHBhbmVsIGlzIGN1" + - "cnJlbnRseQp1bmF1dGhlbnRpY2F0ZWQ7IGRvIG5vdCBleHBvc2UgaXQgdG8gdGhlIHB1YmxpYyBp" + - "bnRlcm5ldC4KCkZvciBlbmFibGVtZW50LCBuYW1lc3BhY2UgYW5kIHB1bGwgc2VjcmV0IHNldHVw" + - "LCBhcHBseSwgYW5kIHZlcmlmaWNhdGlvbiBzdGVwcywKc2VlIFtOVkNGIFVJIEFkZG9uXShyZWZl" + - "cmVuY2VzL252Y2YtdWktYWRkb24ubWQpLgoKIyMjIDguIEluc3RhbGwgdGhlIHNlcGFyYXRlIGNv" + - "bXB1dGUtcGxhbmUgc3RhY2sKClRoZSBjb250cm9sLXBsYW5lIHN0YWNrIGRvZXMgbm90IGluc3Rh" + - "bGwgY29tcHV0ZS1wbGFuZSBjb21wb25lbnRzLiBBZnRlciBpdCBpcyBoZWFsdGh5LCBjaG9vc2Ug" + - "ZXhhY3RseSBvbmUgY29tcHV0ZS1wbGFuZSBoYW5kb2ZmOgoKLSBIZWxtZmlsZSB2YWx1ZXMgZmxv" + - "dzogYXV0aG9yIHNlcGFyYXRlIGVudmlyb25tZW50IGZpbGVzLCB0aGVuIHJlZ2lzdGVyIGFuZAog" + - "IGluc3RhbGwgd2l0aCB0aGUgY29tcHV0ZS1wbGFuZSBNYWtlZmlsZS4KLSBDTEkgcHJvZmlsZSBm" + - "bG93OiB1c2UgdGhlIHByb2ZpbGUgZ2VuZXJhdGVkIGJ5IHRoZSBDTEkgY29udHJvbC1wbGFuZSBp" + - "bnN0YWxsLAogIHRoZW4gcnVuIHRoZSBjb21wbGV0ZSBDTEkgcmVnaXN0ZXIgYW5kIGluc3RhbGwg" + - "Y29tbWFuZHMuCgpEbyBub3QgbWl4IHRoZXNlIGhhbmRvZmZzLiBGb2xsb3cgW1NwbGl0IENvbXB1" + - "dGUtUGxhbmUgSW5zdGFsbGF0aW9uXShyZWZlcmVuY2VzL2NvbXB1dGUtcGxhbmUtaW5zdGFsbGF0" + - "aW9uLm1kKQpmb3IgY29tbWFuZHMsIEVLUyByb3V0aW5nLCBwdWxsIHNlY3JldHMsIHZlcmlmaWNh" + - "dGlvbiwgYW5kIHRlYXJkb3duIG9yZGVyLgoKIyMgQ2xlYW4gVGVhcmRvd24KCkRlc3Ryb3kgZXZl" + - "cnkgY29tcHV0ZSBwbGFuZSBiZWZvcmUgdGhlIGNvbnRyb2wgcGxhbmUsIHVzaW5nIHRoZSB0ZWFy" + - "ZG93biBmb3IKdGhlIHNhbWUgaGFuZG9mZjsgc2VlIFtTcGxpdCBDb21wdXRlLVBsYW5lIEluc3Rh" + - "bGxhdGlvbl0ocmVmZXJlbmNlcy9jb21wdXRlLXBsYW5lLWluc3RhbGxhdGlvbi5tZCN0ZWFyZG93" + - "bikuCgpTY29wZTogT25seSBkZXN0cm95IHJlbGVhc2VzIG1hbmFnZWQgYnkgdGhpcyBjb250cm9s" + - "LXBsYW5lIGhlbG1maWxlIHN0YWNrLiBUaGUgTlZDRiByZWxlYXNlcyBhcmU6IGBuYXRzYCwgYG9w" + - "ZW5iYW8tc2VydmVyYCwgYGNhc3NhbmRyYWAsIGBhcGkta2V5c2AsIGBzaXNgLCBgYXBpYCwgYGlu" + - "dm9jYXRpb24tc2VydmljZWAsIGBncnBjLXByb3h5YCwgYGVzcy1hcGlgLCBgbm90YXJ5LXNlcnZp" + - "Y2VgLCBvcHRpb25hbCBgdmFuaXR5LWdhdGV3YXlgLCBgbnZjZi11aWAsIGBhZG1pbi1pc3N1ZXIt" + - "cHJveHlgLCBhbmQgYGluZ3Jlc3NgOyBgY2VydC1tYW5hZ2VyYCBpcyBpbmNsdWRlZCBvbmx5IHdo" + - "ZW4gYGNlcnRNYW5hZ2VyLmVuYWJsZWQ6IHRydWVgLiBUaGUgY29udHJvbC1wbGFuZSBuYW1lc3Bh" + - "Y2UgaW52ZW50b3J5IGFsc28gaW5jbHVkZXMgYGNlcnQtbWFuYWdlcmAsIGJ1dCBkZWZhdWx0IG5h" + - "bWVzcGFjZSBjbGVhbnVwIHByZXNlcnZlcyBpdC4gTmFtZXNwYWNlIHByZXNlcnZhdGlvbiBkb2Vz" + - "IG5vdCBwcmVzZXJ2ZSB0aGUgSGVsbSByZWxlYXNlLiBFeHRlcm5hbCBjZXJ0LW1hbmFnZXIgbXVz" + - "dCB1c2UgYGNlcnRNYW5hZ2VyLmVuYWJsZWQ6IGZhbHNlYDsgb3RoZXJ3aXNlIEhlbG1maWxlIHRy" + - "ZWF0cyB0aGUgcmVsZWFzZSBhcyBzdGFjay1tYW5hZ2VkLiBEbyBub3QgZGVsZXRlIG90aGVyIGhl" + - "bG0gcmVsZWFzZXMgb3IgbmFtZXNwYWNlcyBvbiB0aGUgY2x1c3Rlci4KCkJlZm9yZSBjb250cm9s" + - "LXBsYW5lIGRlc3Ryb3ksIGlkZW50aWZ5IHdoZXRoZXIgY2VydC1tYW5hZ2VyIGlzIGV4dGVybmFs" + - "LiBGb3IgYW4gZXh0ZXJuYWwgaW5zdGFsbGF0aW9uLCByZXF1aXJlIGVmZmVjdGl2ZSBgY2VydE1h" + - "bmFnZXIuZW5hYmxlZDogZmFsc2VgIGFuZCBhYm9ydCBpZiBpdCBpcyB0cnVlLiBGb3IgYW4gaW50" + - "ZW5kZWQgc3RhY2stbWFuYWdlZCByZWxlYXNlIHdpdGggZWZmZWN0aXZlIGBjZXJ0TWFuYWdlci5l" + - "bmFibGVkOiB0cnVlYCwgdmVyaWZ5IG1hdGNoaW5nIHN0YWNrIEhlbG0gcmVsZWFzZSBtZXRhZGF0" + - "YSBhbmQgYWJvcnQgb24gbWlzc2luZyBvciBtaXNtYXRjaGVkIGV2aWRlbmNlLiBQcmVzZXJ2ZSB0" + - "aGUgbmFtZXNwYWNlIGJ5IGRlZmF1bHQ7IG9ubHkgcGxhbiBpdHMgcmVtb3ZhbCBhZnRlciB2ZXJp" + - "ZnlpbmcgbmFtZXNwYWNlIHByb3ZlbmFuY2UgYW5kIGdldHRpbmcgZXhwbGljaXQgY29uZmlybWF0" + - "aW9uLgoKIyMjIFN0YW5kYXJkIHRlYXJkb3duCgpSdW4gZnJvbSBpbnNpZGUgdGhlIGBudmNmLXNl" + - "bGYtbWFuYWdlZC1zdGFjay9gIGRpcmVjdG9yeToKCmBgYGJhc2gKSEVMTUZJTEVfRU5WPTxlbnYt" + - "bmFtZT4gaGVsbWZpbGUgZGVzdHJveQpgYGAKCiMjIyBEZWxldGUgbmFtZXNwYWNlcwoKYGBgYmFz" + - "aApmb3IgbnMgaW4gY2Fzc2FuZHJhLXN5c3RlbSBuYXRzLXN5c3RlbSBudmNmIGFwaS1rZXlzIGVz" + - "cyBzaXMgbnZjZi11aSB2YXVsdC1zeXN0ZW07IGRvCiAga3ViZWN0bCBkZWxldGUgbmFtZXNwYWNl" + - "ICIkbnMiIC0taWdub3JlLW5vdC1mb3VuZApkb25lCmBgYAoKIyMjIFZlcmlmeSBjbGVhbgoKYGBg" + - "YmFzaAprdWJlY3RsIGdldCBucyB8IGdyZXAgLUUgJyhjYXNzYW5kcmF8bmF0c3x2YXVsdHxudmNm" + - "fGFwaS1rZXlzfGVzc3xzaXMpJwojIFNob3VsZCByZXR1cm4gZW1wdHkKYGBgCgojIyBPdmVycmlk" + - "aW5nIEhlbG0gQ2hhcnQgVmFsdWVzCgojIyMgRW52aXJvbm1lbnQgZmlsZSAobGltaXRlZCkKCldv" + - "cmtzIG9ubHkgZm9yIGtleXMgdGhhdCBgZ2xvYmFsLnlhbWwuZ290bXBsYCBwcm9wYWdhdGVzIChl" + - "LmcuLCBgY2Fzc2FuZHJhLnJlcGxpY2FDb3VudGAsIGBnbG9iYWwuc3RvcmFnZUNsYXNzYCwgYGds" + - "b2JhbC5pbWFnZWApLgoKIyMjIFJlbGVhc2UgdmFsdWVzIGJsb2NrIChhbnkgY2hhcnQgdmFsdWUp" + - "CgpFZGl0IHRoZSByZWxlYXNlIGluIGBoZWxtZmlsZS5kLyoueWFtbC5nb3RtcGxgIGFuZCBhZGQg" + - "YSBgdmFsdWVzOmAgYmxvY2suIEluIHRoZSBleGFtcGxlcyBiZWxvdywgYDxwcml2YXRlLXZhbHVl" + - "cz5gIHJlZmVycyB0byB0aGUgYHNlY3JldHMvYCBkaXJlY3RvcnkgYXQgdGhlIGhlbG1maWxlIHN0" + - "YWNrIHJvb3QuCgpgYGB5YW1sCi0gbmFtZTogY2Fzc2FuZHJhCiAgdmVyc2lvbjogMC44LjAKICBj" + - "b25kaXRpb246IGNhc3NhbmRyYS5lbmFibGVkCiAgbmFtZXNwYWNlOiBjYXNzYW5kcmEtc3lzdGVt" + - "CiAgPDw6ICpkZXBlbmRlbmN5CiAgdmFsdWVzOgogICAgLSAuLi9nbG9iYWwueWFtbC5nb3RtcGwK" + - "ICAgIC0gLi4vPHByaXZhdGUtdmFsdWVzPi97eyByZXF1aXJlZEVudiAiSEVMTUZJTEVfRU5WIiB9" + - "fS1zZWNyZXRzLnlhbWwKICAgIC0gY2Fzc2FuZHJhOgogICAgICAgIHJlc291cmNlczoKICAgICAg" + - "ICAgIGxpbWl0czoKICAgICAgICAgICAgY3B1OiAiOCIKICAgICAgICAgICAgbWVtb3J5OiA4MTky" + - "TWkKICAgICAgICAgIHJlcXVlc3RzOgogICAgICAgICAgICBjcHU6ICIyIgogICAgICAgICAgICBt" + - "ZW1vcnk6IDQwOTZNaQpgYGAKCllBTUwgbWVyZ2UgZ290Y2hhOiBXaGVuIGEgcmVsZWFzZSB1c2Vz" + - "IGA8PDogKmRlcGVuZGVuY3lgIG9yIGBpbmhlcml0YCwgc3BlY2lmeWluZyBgdmFsdWVzOmAgcmVw" + - "bGFjZXMgdGhlIHRlbXBsYXRlJ3MgdmFsdWVzIGxpc3QuIFlvdSBtdXN0IHJlLWluY2x1ZGUgYGds" + - "b2JhbC55YW1sLmdvdG1wbGAgYW5kIHRoZSBzZWNyZXRzIGZpbGUuCgojIyMgUHJldmlldyBhbmQg" + - "YXBwbHkgYSBzaW5nbGUgcmVsZWFzZQoKYGBgYmFzaApIRUxNRklMRV9FTlY9PGVudj4gaGVsbWZp" + - "bGUgLS1zZWxlY3RvciBuYW1lPWNhc3NhbmRyYSB0ZW1wbGF0ZSAgIyBQcmV2aWV3CkhFTE1GSUxF" + - "X0VOVj08ZW52PiBoZWxtZmlsZSAtLXNlbGVjdG9yIG5hbWU9Y2Fzc2FuZHJhIHN5bmMgICAgICAj" + - "IEFwcGx5CmBgYAoKIyMgSW1hZ2UgUHVsbCBTZWNyZXRzCgpUaGVyZSBhcmUgdGhyZWUgZGlzdGlu" + - "Y3QgY3JlZGVudGlhbCB0eXBlcy4gRG8gbm90IGNvbmZsYXRlIHRoZW0sIGFuZCBtaW5kIHRoZQpm" + - "b3JtYXQgcnVsZSBiZWxvdyAodHdvIG9mIHRoZW0gZmFpbCBldmVuIHdpdGggdGhlIGNvcnJlY3Qg" + - "a2V5IGlmIHRoZSBmb3JtYXQgaXMgd3JvbmcpOgoKfCB8IENvbnRyb2wgUGxhbmUgUHVsbCBTZWNy" + - "ZXRzIHwgQVBJIEJvb3RzdHJhcCBSZWdpc3RyeSBDcmVkcyB8IFNpZGVjYXIgSW1hZ2UtUHVsbCBT" + - "ZWNyZXQgfAp8LS0tfC0tLXwtLS18LS0tfAp8IFB1cnBvc2UgfCBLOHMgcHVsbHMgTlZDRiBzZXJ2" + - "aWNlIGltYWdlcyB8IG52Y2YtYXBpIHZhbGlkYXRlcyB0aGUgdXNlciBmdW5jdGlvbiBpbWFnZSBh" + - "dCBgZnVuY3Rpb24gY3JlYXRlYCB8IG52Y2YtYXBpIHB1bGxzIHRoZSBwbGF0Zm9ybSBzaWRlY2Fy" + - "cyBpbmplY3RlZCBpbnRvIGV2ZXJ5IHdvcmtlciBwb2QgfAp8IFdoZXJlIHwgSzhzIGBkb2NrZXIt" + - "cmVnaXN0cnlgIFNlY3JldHMgKyBLeXZlcm5vIENsdXN0ZXJQb2xpY3kgfCBgPHByaXZhdGUtdmFs" + - "dWVzPi88ZW52Pi1zZWNyZXRzLnlhbWxgIChhY2NvdW50LWJvb3RzdHJhcCkgfCBgTlZDRl9BUElf" + - "U0lERUNBUlNfSU1BR0VfUFVMTF9TRUNSRVRgIGluIGA8ZW52Pi1zZWNyZXRzLnlhbWxgIC0+IE9w" + - "ZW5CYW8gYHNlcnZpY2VzL252Y2YtYXBpL2t2L3NpZGVjYXJzL2ltYWdlLXB1bGwtc2VjcmV0YCAo" + - "ZmllbGQgYHNlY3JldGApIHwKfCBGb3JtYXQgfCBzdGFuZGFyZCBgLmRvY2tlcmNvbmZpZ2pzb25g" + - "IChrdWJlY3RsIGJ1aWxkcyBpdCBmb3IgeW91KSB8IGBiYXNlNjQoIiRvYXV0aHRva2VuOjxrZXk+" + - "IilgIHwgYGJhc2U2NCgiJG9hdXRodG9rZW46PGtleT4iKWAgfAoKPiBOb3RlOiB0aGUgYWNjb3Vu" + - "dC1ib290c3RyYXAgY3JlZCBhbmQgdGhlIHNpZGVjYXIgc2VjcmV0IGFyZSBOT1QgYQo+IGRvY2tl" + - "cmNvbmZpZ2pzb24uIFRoZSBzZWNyZXRzIHRlbXBsYXRlIHNoaXBzIHRoZSBwbGFjZWhvbGRlcgo+" + - "IGBSRVBMQUNFX1dJVEhfQkFTRTY0X0RPQ0tFUl9DUkVERU5USUFMYCwgd2hpY2ggcmVhZHMgYXMg" + - "ImJhc2U2NCBvZiBhIGRvY2tlcmNvbmZpZ2pzb24uIgo+IEl0IGlzbid0LiBCb3RoIHZhbHVlcyBh" + - "cmUgY29uc3VtZWQgYXMgYSByYXcgZG9ja2VyIGBhdXRoYCBzdHJpbmc6IG52Y2YtYXBpIHRha2Vz" + - "IHRoZQo+IHZhbHVlIHZlcmJhdGltIGFuZCBkcm9wcyBpdCBpbnRvIHRoZSBgYXV0aGAgZmllbGQg" + - "b2YgdGhlIGRvY2tlcmNvbmZpZyBpdCBidWlsZHMuIFNvIHRoZQo+IHZhbHVlIG11c3QgYmUgYGJh" + - "c2U2NCgiJG9hdXRodG9rZW46PGtleT4iKWAsIGUuZy4gYHByaW50ZiAnJG9hdXRodG9rZW46JXMn" + - "ICIkS0VZIiB8IG9wZW5zc2wgYmFzZTY0IC1BYCwKPiBub3QgYGJhc2U2NCg8ZG9ja2VyY29uZmln" + - "anNvbj4pYC4KPiAgLSBXcm9uZyBhY2NvdW50LWJvb3RzdHJhcCB2YWx1ZTogYGZ1bmN0aW9uIGNy" + - "ZWF0ZWAgcmV0dXJucwo+ICAgIGA0MDAgIm11c3QgYmUgYmFzZTY0IGVuY29kZWQgdXNlcm5hbWU6" + - "cGFzc3dvcmQgZm9ybWF0ImAuCj4gIC0gV3Jvbmcgc2lkZWNhciB2YWx1ZTogZXZlcnkgd29ya2Vy" + - "J3Mgc2lkZWNhciBwdWxsIGdldHMgYSBtYWxmb3JtZWQgY3JlZGVudGlhbCBhbmQKPiAgICBgNDAz" + - "YHMsIHJlZ2FyZGxlc3Mgb2Ygd2hpY2gga2V5IGlzIGluc2lkZS4gVGhlIHN5bXB0b20gbG9va3Mg" + - "bGlrZSBhIGJhZCBvciB3cm9uZy1vcmcKPiAgICBrZXksIGJ1dCB0aGUga2V5IGlzIGZpbmUgYW5k" + - "IHRoZSBlbmNvZGluZyBpcyB0aGUgYnVnLiBUbyByZXBhaXIgYW4gYWxyZWFkeS1pbnN0YWxsZWQK" + - "PiAgICBzdGFjayB3aXRob3V0IGEgZnVsbCByZS1zeW5jOgo+ICAgIGBgYGJhc2gKPiAgICBBVVRI" + - "PSQocHJpbnRmICckb2F1dGh0b2tlbjolcycgIiRLRVkiIHwgb3BlbnNzbCBiYXNlNjQgLUEpCj4g" + - "ICAgYmFvIGt2IHB1dCBzZXJ2aWNlcy9udmNmLWFwaS9rdi9zaWRlY2Fycy9pbWFnZS1wdWxsLXNl" + - "Y3JldCBzZWNyZXQ9IiRBVVRIIgo+ICAgICMgaWYgTlZJRElBIENsb3VkIFRhc2tzIGlzIGVuYWJs" + - "ZWQsIHJlcGVhdCBmb3Igc2VydmljZXMvbnZjdC1hcGkva3Yvc2lkZWNhcnMvaW1hZ2UtcHVsbC1z" + - "ZWNyZXQKPiAgICBrdWJlY3RsIHJvbGxvdXQgcmVzdGFydCAtbiBudmNmIGRlcGxveS9udmNmLWFw" + - "aSAgICMgcGlja3MgdXAgdGhlIG5ldyBzaWRlY2FyIGNyZWQKPiAgICBgYGAKCj4gTm90ZSAobXVs" + - "dGktb3JnKTogd2hlbiBwdWxsaW5nIGZyb20gTkdDIChub3QgYSBtaXJyb3IpLCB0aGUgdXNlciBm" + - "dW5jdGlvbiBpbWFnZSBhbmQKPiB0aGUgcGxhdGZvcm0gc2lkZWNhcnMgb2Z0ZW4gbGl2ZSBpbiBk" + - "aWZmZXJlbnQgbnZjci5pbyBvcmdzLCBlYWNoIG5lZWRpbmcgYSBkaWZmZXJlbnQKPiBrZXksIHNv" + - "IHRoZSBhY2NvdW50LWJvb3RzdHJhcCBjcmVkIChmdW5jdGlvbiBpbWFnZSkgYW5kIHRoZSBzaWRl" + - "Y2FyIHNlY3JldCAoc2lkZWNhcnMpCj4gYXJlIGZyZXF1ZW50bHkgdHdvIGRpZmZlcmVudCBrZXlz" + - "LiBNaXJyb3JpbmcgZXZlcnl0aGluZyBpbnRvIGEgc2luZ2xlIHJlZ2lzdHJ5IHRoZQo+IGNsdXN0" + - "ZXIgYXV0aGVudGljYXRlcyB0byBhdXRvbWF0aWNhbGx5IGNvbGxhcHNlcyB0aGlzIHRvIG9uZSBj" + - "cmVkZW50aWFsIHBhdGguCgojIyMgQ29uZmlndXJpbmcgd2l0aCBLeXZlcm5vIChyZWNvbW1lbmRl" + - "ZCkKClVzZSBhIEt5dmVybm8gbXV0YXRpbmcgYWRtaXNzaW9uIHBvbGljeSB0byBhdXRvbWF0aWNh" + - "bGx5IGluamVjdCBgaW1hZ2VQdWxsU2VjcmV0c2AgaW50byBhbGwgcG9kcyBpbiBOVkNGIG5hbWVz" + - "cGFjZXMuIFRoaXMgd29ya3MgdW5pZm9ybWx5IGZvciBhbGwgY2hhcnRzIC0tIG5vIHBlci1jaGFy" + - "dCBjb25maWd1cmF0aW9uIG9yIGhlbG1maWxlIG1vZGlmaWNhdGlvbnMgbmVlZGVkLgoKYGBgYmFz" + - "aAojIDEuIEluc3RhbGwgS3l2ZXJubwpoZWxtIHJlcG8gYWRkIGt5dmVybm8gaHR0cHM6Ly9reXZl" + - "cm5vLmdpdGh1Yi5pby9reXZlcm5vLwpoZWxtIHJlcG8gdXBkYXRlCmhlbG0gaW5zdGFsbCBreXZl" + - "cm5vIGt5dmVybm8va3l2ZXJubyAtbiBreXZlcm5vIC0tY3JlYXRlLW5hbWVzcGFjZQoKIyAyLiBD" + - "cmVhdGUgcHVsbCBzZWNyZXQgaW4gZWFjaCBuYW1lc3BhY2UKZXhwb3J0IE5HQ19BUElfS0VZPSI8" + - "eW91ci1rZXk+Igpmb3IgbnMgaW4gY2Fzc2FuZHJhLXN5c3RlbSBuYXRzLXN5c3RlbSBudmNmIGFw" + - "aS1rZXlzIGVzcyBzaXMgdmF1bHQtc3lzdGVtIGNlcnQtbWFuYWdlcjsgZG8KICBrdWJlY3RsIGNy" + + "bHQgcHJpb3JpdHkuIHwgLSB8CgpJbiBKU09OLCBgZnVuY3Rpb24gdXBkYXRlYCBhY2NlcHRzIGBt" + + "b2RlbFVwZGF0ZXNbXWAgZW50cmllcyB3aXRoIGBtb2RlbE5hbWVgIGFuZCBgbGxtQ29uZmlnLnJv" + + "dXRpbmdNZXRob2RgIGFuZC9vciBgbGxtQ29uZmlnLnRva2VuUmF0ZUxpbWl0YC4gYHVyaXNgIGFy" + + "ZSBjcmVhdGUtdGltZSBtb2RlbCBtZXRhZGF0YSBhbmQgYXJlIG5vdCBwYXJ0IG9mIG1vZGVsIHVw" + + "ZGF0ZXMuCgpXaGVuIGBsbG1JbnZvY2F0aW9uQ29uZmlnYCBpcyBwcmVzZW50IGluIGFuIHVwZGF0" + + "ZSwgaXQgcmVwbGFjZXMgdGhlIGNvbXBsZXRlIGZ1bmN0aW9uLWxldmVsIHByaW9yaXR5IGNvbmZp" + + "Z3VyYXRpb24uIFNwZWNpZnkgZXZlcnkgZGVmYXVsdCBhbmQgcGVyLWFjY291bnQgdmFsdWUgdG8g" + + "cmV0YWluLiBPbWl0dGluZyB0aGUgZmllbGQgcHJlc2VydmVzIHRoZSBjdXJyZW50IGNvbmZpZ3Vy" + + "YXRpb24uIFVzZSBgLS1pbnB1dC1maWxlYCB3aXRoIGAibGxtSW52b2NhdGlvbkNvbmZpZyI6IHt9" + + "YCB0byBjbGVhciBpdC4KCiMjIGBmdW5jdGlvbiBkZXBsb3kgY3JlYXRlYC1zcGVjaWZpYwoKYC0t" + + "aW5wdXQtZmlsZSBGSUxFYCBpcyByZWNvbW1lbmRlZCAoZnVsbCBKU09OIHNwZWMpLiBGb3IgYWQt" + + "aG9jIG9uZS1zaG90IHVzZToKCnwgRmxhZyB8IFB1cnBvc2UgfCBEZWZhdWx0IHwKfC0tLXwtLS18" + + "LS0tfAp8IGAtLWZ1bmN0aW9uLWlkIElEYCB8IEZ1bmN0aW9uIElEIChyZXF1aXJlZCkgfCAtIHwK" + + "fCBgLS1ncHUgTkFNRWAgfCBHUFUgZmFtaWx5IHwgYEgxMDBgIHwKfCBgLS1pbnN0YW5jZS10eXBl" + + "IFRZUEVgIHwgU0tVIHwgYE5DUC5HUFUuSDEwMF8xeGAgfAp8IGAtLW1pbi1pbnN0YW5jZXMgTmAg" + + "fCBNaW4gcmVwbGljYXMgfCBgMWAgfAp8IGAtLW1heC1pbnN0YW5jZXMgTmAgfCBNYXggcmVwbGlj" + + "YXMgfCBgMWAgfAp8IGAtLW1heC1yZXF1ZXN0LWNvbmN1cnJlbmN5IE5gIHwgQ29uY3VycmVuY3kg" + + "fCBgMGAgKHVuc2V0OyBzZXJ2ZXIgZGVmYXVsdCBhcHBsaWVzKSB8CnwgYC0tY2x1c3RlcnMgTkFN" + + "RVssTkFNRV1gIHwgVGFyZ2V0IHNwZWNpZmljIGNvbXB1dGUgY2x1c3RlcnMgfCAoYW55IG1hdGNo" + + "aW5nIFNLVSkgfAoKIyMgYHRhc2sgY3JlYXRlYC1zcGVjaWZpYwoKYC0taW5wdXQtZmlsZSBGSUxF" + + "YCBpcyByZWNvbW1lbmRlZCBmb3IgcmVwZWF0YWJsZSB0YXNrIGRlZmluaXRpb25zLiBGb3IgYWQt" + + "aG9jIHVzZToKCnwgRmxhZyB8IFB1cnBvc2UgfCBOb3RlcyB8CnwtLS18LS0tfC0tLXwKfCBgLS1u" + + "YW1lIE5BTUVgIHwgVGFzayBuYW1lIChyZXF1aXJlZCkgfCAxLTEyOCBjaGFycywgYF5bYS16MC05" + + "QS1aXVthLXowLTlBLVpcLV9dKiRgIHwKfCBgLS1ncHUgR1BVYCB8IEdQVSBuYW1lIChyZXF1aXJl" + + "ZCB3aXRob3V0IGAtLWlucHV0LWZpbGVgKSB8IEV4YW1wbGU6IGBIMTAwYCB8CnwgYC0taW5zdGFu" + + "Y2UtdHlwZSBUWVBFYCB8IEluc3RhbmNlIHR5cGUgKHJlcXVpcmVkIHdpdGhvdXQgYC0taW5wdXQt" + + "ZmlsZWApIHwgRXhhbXBsZTogYE5DUC5HUFUuSDEwMF8xeGAgfAp8IGAtLWltYWdlIElNQUdFYCB8" + + "IENvbnRhaW5lciBpbWFnZSB8IE11dHVhbGx5IGV4Y2x1c2l2ZSB3aXRoIGAtLWhlbG0tY2hhcnRg" + + "IHwKfCBgLS1oZWxtLWNoYXJ0IENIQVJUYCB8IEhlbG0gY2hhcnQgVVJMIG9yIE9DSSByZWZlcmVu" + + "Y2UgfCBNdXR1YWxseSBleGNsdXNpdmUgd2l0aCBgLS1pbWFnZWAgfAp8IGAtLWlucHV0LWZpbGUg" + + "RklMRWAgfCBKU09OIHRhc2sgc3BlYyBmaWxlIHwgQ0xJIGZsYWdzIG92ZXJyaWRlIEpTT04gdmFs" + + "dWVzIHdoZW4gYm90aCBhcmUgc2V0IHwKfCBgLS1iYWNrZW5kIEJBQ0tFTkRgIHwgQmFja2VuZCAv" + + "IENTUCB8IC0gfAp8IGAtLWNsdXN0ZXJzIE5BTUVbLE5BTUVdYCB8IFNwZWNpZmljIGNsdXN0ZXJz" + + "IHdpdGhpbiB0aGUgaW5zdGFuY2UgfCBDb21tYS1zZXBhcmF0ZWQgfAp8IGAtLWNvbnRhaW5lci1h" + + "cmdzIEFSR1NgIHwgQXJncyBwYXNzZWQgd2hlbiBsYXVuY2hpbmcgdGhlIGNvbnRhaW5lciB8IFNp" + + "bmdsZSBzdHJpbmcsIGUuZy4gYCItLWVwb2NocyAxMCAtLWJhdGNoLXNpemUgMzIiYCB8CnwgYC0t" + + "Y29udGFpbmVyLWVudiBOQU1FPXZhbHVlYCB8IENvbnRhaW5lciBlbnZpcm9ubWVudCB2YXJpYWJs" + + "ZTsgcmVwZWF0YWJsZSB8IC0gfAp8IGAtLXNlY3JldHMgTkFNRT12YWx1ZWAgfCBTZWNyZXQgZW52" + + "aXJvbm1lbnQgdmFyaWFibGU7IHJlcGVhdGFibGU7IGVuY3J5cHRlZCBhdCByZXN0IHwgLSB8Cnwg" + + "YC0tbWF4LXJ1bnRpbWUgRFVSQVRJT05gIHwgTWF4IHdhbGwtY2xvY2sgcnVuIHRpbWUgKElTTyA4" + + "NjAxLCBlLmcuIGBQVDRIYCkgfCBObyBkZWZhdWx0OyBvbWl0IGZvciBubyB0aW1lIGxpbWl0IHwK" + + "fCBgLS1tYXgtcXVldWVkIERVUkFUSU9OYCB8IE1heCB0aW1lIGluIHF1ZXVlIGJlZm9yZSBjYW5j" + + "ZWxsYXRpb24gKElTTyA4NjAxKSB8IFNlcnZlciBkZWZhdWx0IGBQVDcySGAgfAp8IGAtLXRlcm1p" + + "bmF0aW9uLWdyYWNlIERVUkFUSU9OYCB8IEdyYWNlIHBlcmlvZCBhZnRlciBzdG9wIHNpZ25hbCAo" + + "SVNPIDg2MDEpIHwgU2VydmVyIGRlZmF1bHQgYFBUMUhgIHwKfCBgLS1yZXN1bHQtc3RyYXRlZ3kg" + + "VVBMT0FEXHxOT05FYCB8IEhvdyB0byBoYW5kbGUgdGFzayBvdXRwdXQgYXJ0aWZhY3RzIHwgLSB8" + + "CnwgYC0tcmVzdWx0cy1sb2NhdGlvbiBMT0NBVElPTmAgfCBSZXN1bHQgdXBsb2FkIHRhcmdldCwg" + + "Zm9ybWF0IGBvcmctbmFtZS9bdGVhbS1uYW1lL11tb2RlbC1uYW1lYDsgcmVxdWlyZWQgd2hlbiBg" + + "LS1yZXN1bHQtc3RyYXRlZ3k9VVBMT0FEYCB8IC0gfAp8IGAtLW1vZGVscyBOQU1FOlZFUlNJT046" + + "VVJJYCB8IE1vZGVsIGFydGlmYWN0OyByZXBlYXRhYmxlIHwgLSB8CnwgYC0tcmVzb3VyY2VzIE5B" + + "TUU6VkVSU0lPTjpVUklgIHwgUmVzb3VyY2UgYXJ0aWZhY3Q7IHJlcGVhdGFibGUgfCAtIHwKfCBg" + + "LS10YWdzIFRBR1ssVEFHXWAgfCBUYXNrIHRhZ3MgfCBDb21tYS1zZXBhcmF0ZWQgfAp8IGAtLWRl" + + "c2NyaXB0aW9uIFRFWFRgIHwgVGFzayBkZXNjcmlwdGlvbiB8IC0gfAp8IGAtLWxvZ3MtdGVsZW1l" + + "dHJ5LWlkIFVVSURgIHwgTG9ncyB0ZWxlbWV0cnkgZW5kcG9pbnQgSUQgfCAtIHwKfCBgLS1tZXRy" + + "aWNzLXRlbGVtZXRyeS1pZCBVVUlEYCB8IE1ldHJpY3MgdGVsZW1ldHJ5IGVuZHBvaW50IElEIHwg" + + "LSB8CnwgYC0tdHJhY2VzLXRlbGVtZXRyeS1pZCBVVUlEYCB8IFRyYWNlcyB0ZWxlbWV0cnkgZW5k" + + "cG9pbnQgSUQgfCAtIHwKUEsHCFXo2d7NJwAAzScAAFBLAwQUAAgAAAAAACEAAAAAAAAAAAAAAAAA" + + "NwAJAGRhdGEvbnZjZi1zZWxmLW1hbmFnZWQtY2xpL3JlZmVyZW5jZS90cm91Ymxlc2hvb3Rpbmcu" + + "bWRVVAUAAQCmzhIjIFRyb3VibGVzaG9vdGluZwoKS25vd24gZXJyb3JzIOKGkiBkaWFnbm9zdGlj" + + "IGNvbW1hbmQg4oaSIHJlbWVkaWF0aW9uLiBLZWVwIGluIHN5bmMgd2l0aCB0aGUgc3RydWN0dXJl" + + "ZCBgcGhhc2VfZmFpbGVkYCBldmVudHMgdGhlIENMSSBlbWl0cyAoUkVRLTE1KSDigJQgZXZlcnkg" + + "ZW50cnkgYmVsb3cgc2hvdWxkIG1hcCB0byBhbiBgZXJyQ2F0ZWdvcnlgIGFuZCBhIGByZW1lZGlh" + + "dGlvbmAgYXJyYXkuCgojIyBQcmUtZmxpZ2h0Cgp8IFN5bXB0b20gfCBDYXVzZSB8IFJlbWVkaWF0" + + "aW9uIHwKfC0tLXwtLS18LS0tfAp8IGBrdWJlY3RsIG5vdCBvbiBQQVRIYCB8IE9wZXJhdG9yJ3Mg" + + "YCRQQVRIYCBkb2Vzbid0IGluY2x1ZGUga3ViZWN0bCB8IEluc3RhbGwga3ViZWN0bCAxLjI4Kzog" + + "aHR0cHM6Ly9rdWJlcm5ldGVzLmlvL2RvY3MvdGFza3MvdG9vbHMvaW5zdGFsbC1rdWJlY3RsLyB8" + + "CnwgYGhlbG1maWxlIG5vdCBvbiBQQVRIYCB8IFNhbWUgfCBodHRwczovL2dpdGh1Yi5jb20vaGVs" + + "bWZpbGUvaGVsbWZpbGUjaW5zdGFsbGF0aW9uIHwKfCBgaGVsbSBub3Qgb24gUEFUSGAgfCBTYW1l" + + "IHwgaHR0cHM6Ly9oZWxtLnNoL2RvY3MvaW50cm8vaW5zdGFsbC8gfAp8IGBHYXRld2F5IEFQSSBD" + + "UkRzIG5vdCBpbnN0YWxsZWRgIHwgZW52b3ktZ2F0ZXdheSBwcmVyZXEgbWlzc2luZyB8IGBoZWxt" + + "IGluc3RhbGwgZWcgb2NpOi8vZG9ja2VyLmlvL2Vudm95cHJveHkvZ2F0ZXdheS1oZWxtIC0tbmFt" + + "ZXNwYWNlPWVudm95LWdhdGV3YXktc3lzdGVtIC0tY3JlYXRlLW5hbWVzcGFjZWAgfAp8IGBkZWZh" + + "dWx0IFN0b3JhZ2VDbGFzcyBub3QgYXZhaWxhYmxlYCB8IENsdXN0ZXIgaGFzIG5vIGRlZmF1bHQg" + + "U0MgfCBBbm5vdGF0ZSBvbmU6IGBrdWJlY3RsIHBhdGNoIHNjIDxuYW1lPiAtcCAneyJtZXRhZGF0" + + "YSI6eyJhbm5vdGF0aW9ucyI6eyJzdG9yYWdlY2xhc3Mua3ViZXJuZXRlcy5pby9pcy1kZWZhdWx0" + + "LWNsYXNzIjoidHJ1ZSJ9fX0nYCB8CnwgYEdQVSBvcGVyYXRvciBub3QgaW5zdGFsbGVkYCAoY29t" + + "cHV0ZS1wbGFuZSkgfCBudmlkaWEgR1BVIG9wZXJhdG9yIG1pc3NpbmcgfCBJbnN0YWxsIHBlciBo" + + "dHRwczovL2RvY3MubnZpZGlhLmNvbS9kYXRhY2VudGVyL2Nsb3VkLW5hdGl2ZS9ncHUtb3BlcmF0" + + "b3IvbGF0ZXN0L2luc3RhbGwtZ3B1LW9wZXJhdG9yLmh0bWwsIE9SIHVzZSBgZmFrZS1ncHUtb3Bl" + + "cmF0b3JgIGZvciBkZXYgfAp8IGBHUFUgbm9kZSBsYWJlbHMgbWlzc2luZ2AgKGNvbXB1dGUtcGxh" + + "bmUpIHwgTm9kZXMgbmVlZCBgbnZpZGlhLmNvbS9ncHUuZmFtaWx5YCBldGMuIHwgU2V0IGAtLWsz" + + "cy1ub2RlLWxhYmVsIG52aWRpYS5jb20vZ3B1LmZhbWlseT1ob3BwZXJAYWdlbnQ6TmAgZm9yIGsz" + + "ZCB8CgojIyBBdXRoCgp8IFN5bXB0b20gfCBDYXVzZSB8IFJlbWVkaWF0aW9uIHwKfC0tLXwtLS18" + + "LS0tfAp8IGBhZG1pbiB0b2tlbiByZXF1aXJlZGAgKGluaXQgbm90IHJ1bikgfCBObyBgfi8ubnZj" + + "Zi1jbGkuc3RhdGVgIGFuZCBgLS10b2tlbmAgbm90IHBhc3NlZCB8IGBudmNmLWNsaSBpbml0YCAo" + + "aW50ZXJhY3RpdmUpIG9yIGAtLXRva2VuPSRKV1QgLS1ub24taW50ZXJhY3RpdmVgIChDSSkgfAp8" + + "IGBTaWduZWQgSldUIHJlamVjdGVkOiBBbm90aGVyIGFsZ29yaXRobSBleHBlY3RlZCwgb3Igbm8g" + + "bWF0Y2hpbmcga2V5KHMpIGZvdW5kYCB8IFN0YWxlIHNlc3Npb24uanNvbiBmcm9tIGEgZGlmZmVy" + + "ZW50IGNvbnRyb2wgcGxhbmUgfCBgcm0gfi8ubnZjZi1jbGkuc3RhdGVgIHRoZW4gYG52Y2YtY2xp" + + "IGluaXRgIGFnYWluIHwKfCBgNDAzIG1pc3NpbmcgcmVxdWVzdGVkIGF1dGhvcml0aWVzYCAoZnVu" + + "Y3Rpb24gaW52b2tlKSB8IEFkbWluIHRva2VuIGRvZXNuJ3QgaGF2ZSBgaW52b2tlX2Z1bmN0aW9u" + + "YCBzY29wZSB8IGBudmNmLWNsaSBhcGkta2V5IGdlbmVyYXRlIC0tZGVzY3JpcHRpb2494oCmYCB0" + + "aGVuIHJlLXJ1biBpbnZva2UgfAoKIyMgSW5zdGFsbCAvIGB1cGAKCnwgU3ltcHRvbSB8IENhdXNl" + + "IHwgUmVtZWRpYXRpb24gfAp8LS0tfC0tLXwtLS18CnwgSGVsbSBgdGltZWQgb3V0IHdhaXRpbmcg" + + "Zm9yIGNhc3NhbmRyYWAgfCBDYXNzYW5kcmEgU3RhdGVmdWxTZXQgUFZDIHN0dWNrIGBQZW5kaW5n" + + "YCB8IENvbmZpcm0gZGVmYXVsdCBTdG9yYWdlQ2xhc3M7IGNoZWNrIGBrdWJlY3RsIGdldCBwdixw" + + "dmMgLW4gY2Fzc2FuZHJhLXN5c3RlbWAgfAp8IGBJbnZhbGlkIEdQVSAnTkNQLkdQVS5IMTAwJyBz" + + "cGVjaWZpZWRgIChmdW5jdGlvbiBkZXBsb3kpIHwgV3JvbmcgZmllbGQg4oCUIGBncHVgIGlzIHRo" + + "ZSBmYW1pbHksIG5vdCB0aGUgU0tVIHwgVXNlIGAiZ3B1IjogIkgxMDAiYCwgYCJpbnN0YW5jZVR5" + + "cGUiOiAiTkNQLkdQVS5IMTAwXzF4ImAgfAp8IGByZWdpb24gbXVzdCBiZSBwcm92aWRlZGAgKGNs" + + "dXN0ZXIgcmVnaXN0ZXIgLyBpbnN0YWxsIC0tY29tcHV0ZS1wbGFuZSkgfCBgLS1yZWdpb25gIGVt" + + "cHR5ICsgYENMVVNURVJfUkVHSU9OYCBlbnYgZW1wdHkgfCBQYXNzIGAtLXJlZ2lvbj11cy13ZXN0" + + "LTFgIChvciBhbnkgbm9uLWVtcHR5IHZhbHVlKSB8CnwgYHJlcXVpcmVkRW52ICJOQ0FfSUQiIGlz" + + "IG5vdCBzZXRgIChoZWxtZmlsZSBlcnJvciBkdXJpbmcgY29tcHV0ZS1wbGFuZSBhcHBseSkgfCBP" + + "bGRlciBudmNmLWNsaSBiZWZvcmUgY29tbWl0IGA2YWE1NzA0YDsgRXh0cmFFbnYgbm90IHByb3Bh" + + "Z2F0aW5nIE5DQV9JRCB8IFVwZ3JhZGUgYG52Y2YtY2xpYCB0byBhIHJlbGVhc2UgYWZ0ZXIgYDZh" + + "YTU3MDRgIHwKfCBgbnZjYS1vcGVyYXRvcjogSW1hZ2VQdWxsQmFja09mZmAgZm9yIGBudmNhLW9w" + + "ZXJhdG9yOnBzYXRgIHwgSW1hZ2Ugbm90IGluIGNsdXN0ZXIgcmVnaXN0cnk7IG11bHRpLWNsdXN0" + + "ZXIgYnVpbGQgaXMgbG9jYWwgfCBgazNkIGltYWdlIGltcG9ydCBudmNyLmlvLy4uLi9udmNhLW9w" + + "ZXJhdG9yOnBzYXQgLWMgPGNsdXN0ZXI+YCB8CgojIyBDb21wdXRlLXBsYW5lIHJ1bnRpbWUKCnwg" + + "U3ltcHRvbSB8IENhdXNlIHwgUmVtZWRpYXRpb24gfAp8LS0tfC0tLXwtLS18CnwgTlZDQSBhZ2Vu" + + "dCBDcmFzaExvb3BCYWNrT2ZmIHdpdGggYEhUVFAgNDAxYCBvbiBgL3YxL252Y2EvY2x1c3RlcnMv" + + "Li4uL3JlZ2lzdGVyYCB8IFN0YWxlIGBvdXQvPGNsdXN0ZXI+LXJlZ2lzdGVyLXZhbHVlcy55YW1s" + + "YCBmcm9tIHByaW9yIHJlZ2lzdGVyOyBjbHVzdGVyIElEIGRvZXNuJ3QgbWF0Y2ggSUNNUyB8IERl" + + "bGV0ZSB0aGUgc3RhbGUgZmlsZTsgcmUtcnVuIGBudmNmLWNsaSBzZWxmLWhvc3RlZCB1cGAgKGlk" + + "ZW1wb3RlbnQgcmVnaXN0ZXIgd3JpdGVzIGEgZnJlc2ggZmlsZSkgfAp8IGBObyBjbHVzdGVyIGZv" + + "dW5kIHdpdGggdmFsaWQgSldLUyBmb3IgY2x1c3RlciBJRDogPGlkPmAgKElDTVMgbG9nKSB8IEpX" + + "S1MgaW4gSUNNUyBkb2Vzbid0IG1hdGNoIHdoYXQgY29tcHV0ZS1wbGFuZSBLOHMgaXMgY3VycmVu" + + "dGx5IHNpZ25pbmcgfCBgbnZjZi1jbGkgY2x1c3RlciByb3RhdGUgLS1jbHVzdGVyLWlkPTxpZD5g" + + "IHwKfCBGdW5jdGlvbiBwb2QgYEltYWdlUHVsbEJhY2tPZmZgIGluIGBudmNmLWJhY2tlbmRgIHwg" + + "SW1hZ2UtY3JlZGVudGlhbC1oZWxwZXIgY29uZmlnIG1pc3Npbmcgb3Igd3JvbmcgfCBga3ViZWN0" + + "bCBkZXNjcmliZSBwb2QgLW4gbnZjZi1iYWNrZW5kIDxwb2Q+YDsgY2hlY2sgdGhlIHB1bGwgc2Vj" + + "cmV0IGNvbmZpZyB8CnwgRnVuY3Rpb24gZGVwbG95IHN0dWNrIGBERVBMT1lJTkdgIGZvciA+NSBt" + + "aW4gfCBOQVRTIHN0cmVhbSBpbml0IGxhZyAoY29sZC1jbHVzdGVyKSDigJQgd2FpdCwgb3IgY2hl" + + "Y2sgTkFUUyBhdXRoLWNhbGxvdXQgaGVhbHRoIHwgYGt1YmVjdGwgbG9ncyAtbiBuYXRzLXN5c3Rl" + + "bSAtbCBhcHAua3ViZXJuZXRlcy5pby9uYW1lPW5hdHMtYXV0aC1jYWxsb3V0LXNlcnZpY2VgIHwK" + + "CiMjIFRhc2tzCgp8IFN5bXB0b20gfCBDYXVzZSB8IFJlbWVkaWF0aW9uIHwKfC0tLXwtLS18LS0t" + + "fAp8IGB0YXNrIGNyZWF0ZWAgcmV0dXJucyBgTWlzc2luZyA8VFlQRT4gcmVnaXN0cnkgY3JlZGVu" + + "dGlhbCBmb3IgaG9zdG5hbWVgLCBvciBrZWVwcyB1c2luZyBhIHByZXZpb3VzIGNyZWRlbnRpYWwg" + + "dmFsdWUsIHNob3J0bHkgYWZ0ZXIgYHJlZ2lzdHJ5LWNyZWRlbnRpYWwgYWRkL3VwZGF0ZS9kZWxl" + + "dGVgIHdoaWxlIGByZWdpc3RyeS1jcmVkZW50aWFsIGxpc3RgL2BnZXRgIGFscmVhZHkgc2hvdyB0" + + "aGUgbmV3IHZhbHVlIHwgRXhwZWN0ZWQgcHJvcGFnYXRpb24gZGVsYXk6IE5WQ1QgY2FjaGVzIHRo" + + "ZSBhY2NvdW50J3MgcmVnaXN0cnkgY3JlZGVudGlhbHMgd2l0aCBgbnZjdC5udmNmLmNhY2hlLXR0" + + "bGAgKGRlZmF1bHQgYFBUNU1gLCBhYm91dCA1IG1pbikgYW5kIGFwcGxpZXMgdGhlIGNoYW5nZSB3" + + "aGVuIHRoYXQgY2FjaGVkIGNvcHkgcmVmcmVzaGVzIHwgV2FpdCB1cCB0byBhYm91dCA1IG1pbiBh" + + "bmQgcmV0cnksIG9yIGBrdWJlY3RsIC1uIG52Y2Ygcm9sbG91dCByZXN0YXJ0IGRlcGxveW1lbnQv" + + "bnZjdC1hcGlgIHRvIGFwcGx5IGltbWVkaWF0ZWx5IHwKUEsHCPOuE4R0EQAAdBEAAFBLAwQUAAgA" + + "AAAAACEAAAAAAAAAAAAAAAAALAAJAGRhdGEvbnZjZi1zZWxmLW1hbmFnZWQtaW5zdGFsbGF0aW9u" + + "L1NLSUxMLm1kVVQFAAEAps4SLS0tCm5hbWU6IG52Y2Ytc2VsZi1tYW5hZ2VkLWluc3RhbGxhdGlv" + + "bgpkZXNjcmlwdGlvbjogPi0KICBJbnN0YWxsIGFuZCBvcGVyYXRlIE5WQ0Ygc2VsZi1ob3N0ZWQg" + + "Y29udHJvbC1wbGFuZSBhbmQgc2VwYXJhdGUgY29tcHV0ZS1wbGFuZQogIHN0YWNrcy4gQ292ZXJz" + + "IEhlbG1maWxlIHZhbHVlcyBhbmQgQ0xJIHByb2ZpbGUgaW5zdGFsbGF0aW9uIGZsb3dzLCB0ZWFy" + + "ZG93biwKICB2YWx1ZXMgb3ZlcnJpZGVzLCBwdWxsIHNlY3JldHMsIGFuZCB0cm91Ymxlc2hvb3Rp" + + "bmcuIFVzZSBmb3IKICBudmNmLXNlbGYtbWFuYWdlZC1zdGFjaywgbnZjZi1jb21wdXRlLXBsYW5l" + + "LXN0YWNrLCBzcGxpdCBjb21wdXRlLXBsYW5lCiAgaW5zdGFsbGF0aW9uLCBjb250cm9sLXBsYW5l" + + "IGluc3RhbGxhdGlvbiwgQ0xJLWdlbmVyYXRlZCBjb250cm9sLXBsYW5lCiAgcHJvZmlsZXMsIEhl" + + "bG1maWxlLCBzZWxmLW1hbmFnZWQsIG9yIHNlbGYtaG9zdGVkIGRlcGxveW1lbnRzLiBEbyBOT1Qg" + + "dXNlIGZvcgogIGxvY2FsIGszZCBlbnZpcm9ubWVudHM7IHVzZSB0aGUgbG9jYWwgazNkIGRldmVs" + + "b3BtZW50IHdvcmtmbG93IGluc3RlYWQuCmxpY2Vuc2U6IEFwYWNoZS0yLjAKY29tcGF0aWJpbGl0" + + "eTogUmVxdWlyZXMgaGVsbWZpbGUgPj0gMS4xLjAgPCAxLjIuMCwgaGVsbSA+PSAzLjEyLCBoZWxt" + + "LWRpZmYgcGx1Z2luLCBrdWJlY3RsIG1hdGNoaW5nIGNsdXN0ZXIgdmVyc2lvbgphdXRob3I6ICJu" + + "dmNmLWNvcmUtZW5nIDxudmNmLWNvcmUtZW5nQGV4Y2hhbmdlLm52aWRpYS5jb20+Igp2ZXJzaW9u" + + "OiAiMS4wLjAiCnRhZ3M6IFtudmNmLCBzZWxmLW1hbmFnZWQsIGhlbG1maWxlLCBzZWxmLWhvc3Rl" + + "ZCwgY29udHJvbC1wbGFuZSwgY29tcHV0ZS1wbGFuZSwgY2xpLXByb2ZpbGUsIGluc3RhbGxhdGlv" + + "biwgZGVwbG95bWVudCwgcHVsbC1zZWNyZXRzXQp0b29sczogW1NoZWxsLCBSZWFkLCBFZGl0LCBH" + + "cmVwLCBHbG9iXQptZXRhZGF0YToKICBpbnRlcm5hbDogZmFsc2UKICBhdXRob3I6ICJudmNmLWNv" + + "cmUtZW5nIDxudmNmLWNvcmUtZW5nQGV4Y2hhbmdlLm52aWRpYS5jb20+IgogIHZlcnNpb246ICIx" + + "LjAiCiAgdGFnczogW252Y2YsIHNlbGYtbWFuYWdlZCwgaGVsbWZpbGUsIHNlbGYtaG9zdGVkLCBj" + + "b250cm9sLXBsYW5lLCBjb21wdXRlLXBsYW5lLCBjbGktcHJvZmlsZSwgaW5zdGFsbGF0aW9uLCBk" + + "ZXBsb3ltZW50LCBwdWxsLXNlY3JldHNdCiAgbGFuZ3VhZ2VzOiBbYmFzaCwgeWFtbF0KICBmcmFt" + + "ZXdvcmtzOiBbaGVsbWZpbGUsIGhlbG0sIGt1YmVjdGxdCiAgZG9tYWluOiBjbG91ZC1pbmZyYXN0" + + "cnVjdHVyZQotLS0KCiMgTlZDRiBTZWxmLU1hbmFnZWQgU3RhY2sgT3BlcmF0aW9ucwoKT3BlcmF0" + + "aW9uYWwgZ3VpZGUgZm9yIG1hdGNoaW5nIE5WQ0YgY29udHJvbC1wbGFuZSBhbmQgY29tcHV0ZS1w" + + "bGFuZSBIZWxtZmlsZSBidW5kbGVzLgoKIyMgSW5zdHJ1Y3Rpb25zCgpVc2UgdGhpcyBza2lsbCBm" + + "b3IgaW5zdGFsbCwgdXBncmFkZSwgb3IgdGVhcmRvd24gd29yayBpbiBtYXRjaGluZyBgbnZjZi1z" + + "ZWxmLW1hbmFnZWQtc3RhY2tgIGFuZCBgbnZjZi1jb21wdXRlLXBsYW5lLXN0YWNrYCBidW5kbGVz" + + "OyBrZWVwIEhlbG1maWxlIHZhbHVlcyBhbmQgQ0xJIHByb2ZpbGUgaGFuZG9mZnMgc2VwYXJhdGUu" + + "IEZvciBgZnVuY3Rpb25UeXBlOiAiTExNImAsIHJlYWQgW0xMTSBGdW5jdGlvbiBFbmFibGVtZW50" + + "XShyZWZlcmVuY2VzL2hlbG1maWxlLXN0cnVjdHVyZS5tZCNsbG0tZnVuY3Rpb24tZW5hYmxlbWVu" + + "dCkuCgojIyBQcmVyZXF1aXNpdGVzCgpBc2sgZm9yIHRoZSBleHRyYWN0ZWQgYG52Y2Ytc2VsZi1t" + + "YW5hZ2VkLXN0YWNrYCBwYXRoLiBGb3Igc3BsaXQgaW5zdGFsbGF0aW9uLAphbHNvIHJlcXVpcmUg" + + "dGhlIG1hdGNoaW5nLXZlcnNpb24gYG52Y2YtY29tcHV0ZS1wbGFuZS1zdGFja2AgcGF0aC4gVmVy" + + "aWZ5IGJvdGg6CgpgYGBiYXNoCmxzIDxjb250cm9sLXBsYW5lLXN0YWNrPi9oZWxtZmlsZS5kLyA8" + + "Y29udHJvbC1wbGFuZS1zdGFjaz4vZW52aXJvbm1lbnRzLyA8Y29udHJvbC1wbGFuZS1zdGFjaz4v" + + "c2VjcmV0cy8gPGNvbnRyb2wtcGxhbmUtc3RhY2s+L2dsb2JhbC55YW1sLmdvdG1wbApscyA8Y29t" + + "cHV0ZS1wbGFuZS1zdGFjaz4vaGVsbWZpbGUuZC8gPGNvbXB1dGUtcGxhbmUtc3RhY2s+L2Vudmly" + + "b25tZW50cy8gPGNvbXB1dGUtcGxhbmUtc3RhY2s+L2dsb2JhbC55YW1sLmdvdG1wbApgYGAKCklm" + + "IGVpdGhlciBkaXJlY3RvcnkgaXMgbWlzc2luZywgZG93bmxvYWQgbWF0Y2hpbmcgYnVuZGxlIHZl" + + "cnNpb25zIGZyb20gTkdDOgoKYGBgYmFzaApuZ2MgcmVnaXN0cnkgcmVzb3VyY2UgZG93bmxvYWQt" + + "dmVyc2lvbiA8b3JnPi9udmNmLXNlbGYtbWFuYWdlZC1zdGFjazo8dmVyc2lvbj4KbmdjIHJlZ2lz" + + "dHJ5IHJlc291cmNlIGRvd25sb2FkLXZlcnNpb24gPG9yZz4vbnZjZi1jb21wdXRlLXBsYW5lLXN0" + + "YWNrOjx2ZXJzaW9uPgpgYGAKCkNvbnRyb2wtcGxhbmUgY29tbWFuZHMgYmVsb3cgYXNzdW1lIHRo" + + "ZSBjb250cm9sLXBsYW5lIGJ1bmRsZSByb290LiBTcGxpdC1mbG93CmNvbW1hbmRzIGFuZCByb290" + + "IHN1YnN0aXR1dGlvbiBhcmUgaW4KW1NwbGl0IENvbXB1dGUtUGxhbmUgSW5zdGFsbGF0aW9uXShy" + + "ZWZlcmVuY2VzL2NvbXB1dGUtcGxhbmUtaW5zdGFsbGF0aW9uLm1kKS4KCiMjIEJlZm9yZSBZb3Ug" + + "U3RhcnQKClZlcmlmeSB0b29saW5nIGFuZCBjb250ZXh0IGJlZm9yZSBhbnkgb3BlcmF0aW9uOgoK" + + "YGBgYmFzaApoZWxtZmlsZSAtLXZlcnNpb24gICAjIE11c3QgYmUgMS4xLnggKDEuMi4wIHJlbW92" + + "ZWQgc2VxdWVudGlhbCBtb2RlKQpoZWxtIHZlcnNpb24gICAgICAgICAjIE11c3QgYmUgPj0gMy4x" + + "MgpoZWxtIHBsdWdpbiBsaXN0ICAgICAjIE11c3QgaW5jbHVkZSBoZWxtLWRpZmYgPj0gMy4xMQpr" + + "dWJlY3RsIHZlcnNpb24gICAgICAjIENsaWVudCBtdXN0IGJlIHdpdGhpbiAxIG1pbm9yIHZlcnNp" + + "b24gb2YgY2x1c3RlcgpgYGAKCkNvbnRyb2wtcGxhbmUgY29tbWFuZHMgcnVuIGZyb20gdGhlIGV4" + + "dHJhY3RlZCBgbnZjZi1zZWxmLW1hbmFnZWQtc3RhY2svYCByb290OgoKYGBgYmFzaApjZCBwYXRo" + + "L3RvL252Y2Ytc2VsZi1tYW5hZ2VkLXN0YWNrCmxzIGhlbG1maWxlLmQvIGVudmlyb25tZW50cy8g" + + "c2VjcmV0cy8gZ2xvYmFsLnlhbWwuZ290bXBsCmBgYAoKSWRlbnRpZnkgdGhlIGVudmlyb25tZW50" + + "IGZyb20gYGVudmlyb25tZW50cy88bmFtZT4ueWFtbGAgYW5kCmBzZWNyZXRzLzxuYW1lPi1zZWNy" + + "ZXRzLnlhbWxgOyBmb3IgRUtTLCB1c2UgdGhlIGNhbm9uaWNhbApbQ1NQIEVuZC10by1FbmQgRXhh" + + "bXBsZV0oaHR0cHM6Ly9kb2NzLm52aWRpYS5jb20vbnZjZi92MC42LjAtcmMvY3NwLWVuZC10by1l" + + "bmQtZXhhbXBsZSkuCgojIyBIb3cgVmFsdWVzIEZsb3cKClVuZGVyc3RhbmRpbmcgdmFsdWUgcHJl" + + "Y2VkZW5jZSBwcmV2ZW50cyB0aGUgbW9zdCBjb21tb24gY29uZmlndXJhdGlvbiBtaXN0YWtlcy4K" + + "CmBgYAplbnZpcm9ubWVudHMvYmFzZS55YW1sICAgICAgICAgIChkZWZhdWx0cykKICAgIC0+IG1l" + + "cmdlZCB3aXRoCmVudmlyb25tZW50cy88ZW52Pi55YW1sICAgICAgICAgKHlvdXIgb3ZlcnJpZGVz" + + "KQogICAgLT4gY29uc3VtZWQgYnkKZ2xvYmFsLnlhbWwuZ290bXBsICAgICAgICAgICAgICAoR28g" + + "dGVtcGxhdGUsIGNvbnN0cnVjdHMgcGVyLWNoYXJ0IHZhbHVlcykKICAgIC0+IGNvbnN1bWVkIGJ5" + + "CnNlY3JldHMvPGVudj4tc2VjcmV0cy55YW1sICAgICAgKHNlbnNpdGl2ZSB2YWx1ZXMpCiAgICAt" + + "PiBvdmVycmlkZGVuIGJ5CnJlbGVhc2UgaW5saW5lIHZhbHVlczogYmxvY2tzICAgKGhpZ2hlc3Qg" + + "cHJlY2VkZW5jZSkKYGBgCgpDcml0aWNhbDogYGdsb2JhbC55YW1sLmdvdG1wbGAgb25seSBwYXNz" + + "ZXMgdGhyb3VnaCBzcGVjaWZpYyBrZXlzIHRvIGVhY2ggY2hhcnQgKGltYWdlIHJlZ2lzdHJpZXMs" + + "IG5vZGUgc2VsZWN0b3JzLCBzdG9yYWdlLCByZXBsaWNhIGNvdW50cykuIFNldHRpbmcgYW4gYXJi" + + "aXRyYXJ5IGNoYXJ0IHZhbHVlIGluIHRoZSBlbnZpcm9ubWVudCBmaWxlIHdpbGwgYmUgc2lsZW50" + + "bHkgaWdub3JlZCBpZiBgZ2xvYmFsLnlhbWwuZ290bXBsYCBkb2VzIG5vdCBwcm9wYWdhdGUgaXQu" + + "CgpUbyBvdmVycmlkZSBhcmJpdHJhcnkgY2hhcnQgdmFsdWVzLCB1c2UgYSBoZWxtZmlsZSByZWxl" + + "YXNlIGB2YWx1ZXM6YCBibG9jay4gU2VlIFtPdmVycmlkaW5nIEhlbG0gQ2hhcnQgVmFsdWVzXSgj" + + "b3ZlcnJpZGluZy1oZWxtLWNoYXJ0LXZhbHVlcykuCgojIyBDbGVhbiBJbnN0YWxsYXRpb24KCiMj" + + "IyAxLiBDcmVhdGUgbmFtZXNwYWNlcyBhbmQgaW1hZ2UgcHVsbCBzZWNyZXRzIChpZiB1c2luZyBh" + + "IHByaXZhdGUgcmVnaXN0cnkpCgpgYGBiYXNoCmZvciBucyBpbiBjYXNzYW5kcmEtc3lzdGVtIG5h" + + "dHMtc3lzdGVtIG52Y2YgYXBpLWtleXMgZXNzIHNpcyB2YXVsdC1zeXN0ZW0gY2VydC1tYW5hZ2Vy" + + "OyBkbwogIGt1YmVjdGwgY3JlYXRlIG5hbWVzcGFjZSAiJG5zIiAtLWRyeS1ydW49Y2xpZW50IC1v" + + "IHlhbWwgfCBrdWJlY3RsIGFwcGx5IC1mIC0KZG9uZQoKIyBPbmx5IGlmIHB1bGxpbmcgZnJvbSBh" + + "IHByaXZhdGUgcmVnaXN0cnkgKGUuZy4sIE5HQyBudmNyLmlvKQpleHBvcnQgTkdDX0FQSV9LRVk9" + + "Ijx5b3VyLWtleT4iCmZvciBucyBpbiBjYXNzYW5kcmEtc3lzdGVtIG5hdHMtc3lzdGVtIG52Y2Yg" + + "YXBpLWtleXMgZXNzIHNpcyB2YXVsdC1zeXN0ZW0gY2VydC1tYW5hZ2VyOyBkbwogIGt1YmVjdGwg" + + "Y3JlYXRlIHNlY3JldCBkb2NrZXItcmVnaXN0cnkgbnZjci1jcmVkcyBcCiAgICAtLWRvY2tlci1z" + + "ZXJ2ZXI9bnZjci5pbyBcCiAgICAtLWRvY2tlci11c2VybmFtZT0nJG9hdXRodG9rZW4nIFwKICAg" + + "IC0tZG9ja2VyLXBhc3N3b3JkPSIkTkdDX0FQSV9LRVkiIFwKICAgIC0tbmFtZXNwYWNlPSIkbnMi" + + "IFwKICAgIC0tZHJ5LXJ1bj1jbGllbnQgLW8geWFtbCB8IGt1YmVjdGwgYXBwbHkgLWYgLQpkb25l" + + "CmBgYAoKSWYgdXNpbmcgcHVsbCBzZWNyZXRzLCB5b3UgbXVzdCBhbHNvIGNvbmZpZ3VyZSBlYWNo" + + "IGhlbG1maWxlIHJlbGVhc2UgdG8gcmVmZXJlbmNlIHRoZW0uIFNlZSBbSW1hZ2UgUHVsbCBTZWNy" + + "ZXRzXSgjaW1hZ2UtcHVsbC1zZWNyZXRzKS4KCiMjIyAyLiBBdXRoZW50aWNhdGUgaGVsbSB0byB5" + + "b3VyIGNoYXJ0IHJlZ2lzdHJ5CgpCb3RoIGBkb2NrZXIgbG9naW5gIEFORCBgaGVsbSByZWdpc3Ry" + + "eSBsb2dpbmAgYXJlIHJlcXVpcmVkIGZvciBOR0MuIEhlbG1maWxlIHVzZXMgaGVsbSAobm90IGRv" + + "Y2tlcikgdG8gcHVsbCBPQ0kgY2hhcnRzLCBzbyB0aGUgaGVsbSBjcmVkZW50aWFsIHN0b3JlIG11" + + "c3QgYmUgYXV0aGVudGljYXRlZCBzZXBhcmF0ZWx5LgoKYGBgYmFzaAojIE5HQyAtLSBib3RoIGNv" + + "bW1hbmRzIGFyZSByZXF1aXJlZApkb2NrZXIgbG9naW4gbnZjci5pbyAtdSAnJG9hdXRodG9rZW4n" + + "IC1wICIkTkdDX0FQSV9LRVkiCmhlbG0gcmVnaXN0cnkgbG9naW4gbnZjci5pbyAtdSAnJG9hdXRo" + + "dG9rZW4nIC1wICIkTkdDX0FQSV9LRVkiCgojIEVDUgphd3MgZWNyIGdldC1sb2dpbi1wYXNzd29y" + + "ZCAtLXJlZ2lvbiA8cmVnaW9uPiB8IFwKICBoZWxtIHJlZ2lzdHJ5IGxvZ2luIC0tdXNlcm5hbWUg" + + "QVdTIC0tcGFzc3dvcmQtc3RkaW4gPGFjY291bnQ+LmRrci5lY3IuPHJlZ2lvbj4uYW1hem9uYXdz" + + "LmNvbQpgYGAKCj4gTm90ZTogYGhlbG0gcmVnaXN0cnkgbG9naW5gIGtlZXBzIG9ubHkgdGhlIGxh" + + "c3QgbG9naW4gcGVyIGhvc3QgKG11bHRpLW9yZyBnb3RjaGEpLgo+IFRoZSBzdGFjayBhbmQgdGhl" + + "IGNhY2hlcyBzcGFuIHNldmVyYWwgTkdDIG9yZ3MgdGhhdCBuZWVkIGRpZmZlcmVudCBrZXlzLCBi" + + "dXQgdGhleSBhbGwKPiBsaXZlIHVuZGVyIHRoZSBvbmUgaG9zdCBgbnZjci5pb2AuIEEgc2Vjb25k" + + "IGBoZWxtIHJlZ2lzdHJ5IGxvZ2luIG52Y3IuaW9gIChvcgo+IGBkb2NrZXIgbG9naW5gKSB3aXRo" + + "IGEgZGlmZmVyZW50IGtleSBzaWxlbnRseSBvdmVyd3JpdGVzIHRoZSBmaXJzdCwgc28gcHVsbHMg" + + "Zm9yIHRoZQo+IGZpcnN0IG9yZyB0aGVuIGZhaWwgd2l0aCBhIG1pc2xlYWRpbmcgYDQwMyBBY2Nl" + + "c3MgRGVuaWVkYCAobm90IGEgNDAxOiB0aGUgYXV0aAo+IHN1Y2NlZWRlZCwgaXQncyB0aGUgd3Jv" + + "bmctb3JnIGtleSkuIElmIHlvdSBwdWxsIGNoYXJ0cy9pbWFnZXMgZnJvbSBtb3JlIHRoYW4gb25l" + + "IG9yZywKPiBlaXRoZXIgcmUtcnVuIHRoZSBsb2dpbiB3aXRoIHRoZSBjb3JyZWN0IGtleSBpbW1l" + + "ZGlhdGVseSBiZWZvcmUgZWFjaCBwdWxsLCBvciBwYXNzCj4gYC0tdXNlcm5hbWUgJyRvYXV0aHRv" + + "a2VuJyAtLXBhc3N3b3JkIDxrZXk+YCBwZXIgYGhlbG0gcHVsbGAgaW52b2NhdGlvbiBpbnN0ZWFk" + + "IG9mIHJlbHlpbmcKPiBvbiB0aGUgc3RvcmVkIGxvZ2luLiAoUHVsbGluZyBldmVyeXRoaW5nIGZy" + + "b20gYSBzaW5nbGUgcmVnaXN0cnkgbWlycm9yIGF2b2lkcyB0aGlzCj4gZW50aXJlbHkuKQoKIyMj" + + "IDJiLiAoUmVjb21tZW5kZWQpIFB1bGwgZnJvbSBhIHJlZ2lzdHJ5IHRoZSBjbHVzdGVyIGF1dGhl" + + "bnRpY2F0ZXMgdG8gYXV0b21hdGljYWxseQoKSWYgeW91IG1pcnJvciB0aGUgTlZDRiBpbWFnZXMg" + + "aW50byBhIHJlZ2lzdHJ5IHRoYXQgdGhlIGNsdXN0ZXIgY2FuIHB1bGwgZnJvbSB3aXRob3V0IGFu" + + "CmV4cGxpY2l0IGltYWdlIHB1bGwgc2VjcmV0IChmb3IgZXhhbXBsZSwgYSByZWdpc3RyeSB3aGVy" + + "ZSB0aGUgbm9kZSBvciB3b3JrbG9hZCBpZGVudGl0eSBpcwpncmFudGVkIHB1bGwgYWNjZXNzIGF1" + + "dG9tYXRpY2FsbHkpLCBwb2ludCB0aGUgc3RhY2sgYXQgaXQgYW5kIHNraXAgdGhlIGNyZWRlbnRp" + + "YWwgc3RlcHMKYWJvdmUuCgoxLiBQb2ludCB0aGUgc3RhY2sgYXQgdGhlIG1pcnJvciBpbiBgZW52" + + "aXJvbm1lbnRzLzxlbnY+LnlhbWxgOgoKICAgYGBgeWFtbAogICBnbG9iYWw6CiAgICAgaW1hZ2U6" + + "CiAgICAgICByZWdpc3RyeTogPHlvdXItcmVnaXN0cnk+ICAgICAgICAgICAgIyBlLmcuIHJlZ2lz" + + "dHJ5LmV4YW1wbGUuY29tCiAgICAgICByZXBvc2l0b3J5OiA8bWlycm9yLXN1Yi1wYXRoPgogICAg" + + "IGhlbG06CiAgICAgICBzb3VyY2VzOiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICMgb25s" + + "eSBpZiB5b3UgYWxzbyBtaXJyb3JlZCB0aGUgaGVsbSBjaGFydHMKICAgICAgICAgcmVnaXN0cnk6" + + "IDx5b3VyLXJlZ2lzdHJ5PgogICAgICAgICByZXBvc2l0b3J5OiA8bWlycm9yLXN1Yi1wYXRoPgog" + + "ICBgYGAKCiAgID4gVGhlIG1hbmlmZXN0IGhhcyBhIG1peCBvZiBPQ0kgYW5kIG5vbi1PQ0kgYXJ0" + + "aWZhY3RzLCBzbyBjb252ZXJ0IG5vbi1PQ0kgY2hhcnRzIGJlZm9yZQogICA+IG1pcnJvcmluZy4g" + + "Q29udGFpbmVyIGltYWdlcyAoYG52Y3IuaW8vLi4uYCkgYXJlIGFscmVhZHkgT0NJIGFuZCBtaXJy" + + "b3IgYXMtaXMuIFNvbWUgSGVsbQogICA+IGNoYXJ0cywgdGhvdWdoLCBhcmUgcHVibGlzaGVkIHRv" + + "IGFuIGBodHRwczovL2AgSGVsbSByZXBvc2l0b3J5IChmb3IgZXhhbXBsZQogICA+IGBoZWxtLm5n" + + "Yy5udmlkaWEuY29tYCkuIFRob3NlIGFyZSBub3QgT0NJIGFuZCBjYW5ub3QgYmUgcmVzb2x2ZWQg" + + "YnkgYGdsb2JhbC5oZWxtLnNvdXJjZXNgCiAgID4gKE9DSSkgb3IgbWlycm9yZWQgZGlyZWN0bHku" + + "IEJlZm9yZSBwb2ludGluZyB0aGUgc3RhY2sgYXQgeW91ciBtaXJyb3IsIGNvbnZlcnQgZWFjaAog" + + "ICA+IGBodHRwczovL2AgY2hhcnQgdG8gT0NJOiBgaGVsbSByZXBvIGFkZGAvYGhlbG0gcHVsbGAg" + + "dGhlIGAudGd6YCwgdGhlbgogICA+IGBoZWxtIHB1c2ggPGNoYXJ0Pi50Z3ogb2NpOi8vPHlvdXIt" + + "cmVnaXN0cnk+LzxtaXJyb3Itc3ViLXBhdGg+YC4gT25seSBPQ0kgY2hhcnRzIGNhbiBsaXZlCiAg" + + "ID4gdW5kZXIgYGdsb2JhbC5oZWxtLnNvdXJjZXNgLgoKMi4gU2tpcCB0aGUgY3JlZGVudGlhbCBz" + + "dGVwcyBhYm92ZS4gV2hlbiB0aGUgY2x1c3RlciBhdXRoZW50aWNhdGVzIHRvIHRoZSByZWdpc3Ry" + + "eQogICBhdXRvbWF0aWNhbGx5ICh0aGUgbm9kZSBvciB3b3JrbG9hZCBpZGVudGl0eSBoYXMgcHVs" + + "bCBhY2Nlc3MpLCB0aGUgcHVsbCBuZWVkcyBubwogICBLdWJlcm5ldGVzIHNlY3JldCwgc28geW91" + + "IGRvIG5vdCBuZWVkOiB0aGUgcGVyLW5hbWVzcGFjZSBgbnZjci1jcmVkc2AgZnJvbSBzdGVwIDEK" + + "ICAgKHN0aWxsIGNyZWF0ZSB0aGUgbmFtZXNwYWNlcywganVzdCBub3QgdGhlIHNlY3JldCksIHRo" + + "ZSBgZ2xvYmFsLmltYWdlUHVsbFNlY3JldHNgIGVudHJ5LAogICBvciB0aGUgYGRvY2tlciBsb2dp" + + "bmAvYGhlbG0gcmVnaXN0cnkgbG9naW4gbnZjci5pb2AgZnJvbSBzdGVwIDIuCgogICA+IE9uZSBy" + + "ZXNpZHVhbCBjcmVkZW50aWFsOiBudmNmLWFwaSBzdGlsbCB2YWxpZGF0ZXMgdGhlIHVzZXIgZnVu" + + "Y3Rpb24gaW1hZ2UgYXQKICAgPiBgZnVuY3Rpb24gY3JlYXRlYCB2aWEgdGhlIGFjY291bnQgcmVn" + + "aXN0cnkgY3JlZGVudGlhbCwgc28gdGhhdCBjcmVkZW50aWFsIG11c3QgcG9pbnQgYXQKICAgPiB3" + + "aGljaGV2ZXIgcmVnaXN0cnkgaG9sZHMgdGhlIHVzZXIgaW1hZ2UgKHNldCBpdCB0byB5b3VyIG1p" + + "cnJvciBpZiB0aGUgaW1hZ2UgaXMgbWlycm9yZWQKICAgPiB0aGVyZSkuCgojIyMgMy4gU2V0IHRo" + + "ZSByb3V0ZSBkb21haW4KCmBnbG9iYWwuZG9tYWluYCBzZXRzIHRoZSBob3N0bmFtZSBzdWZmaXgg" + + "Zm9yIHJvdXRlcyBzdWNoIGFzIGBhcGkuPGRvbWFpbj5gLiBJdCBkb2VzIG5vdCBjb25maWd1cmUg" + + "dGhlIEdhdGV3YXkgb3IgaXRzIGxvYWQgYmFsYW5jZXIuIFF1ZXJ5IHRoZSBleGFjdCBleGlzdGlu" + + "ZyBHYXRld2F5OgoKYGBgYmFzaApHQVRFV0FZX0FERFJFU1M9JChrdWJlY3RsIGdldCBnYXRld2F5" + + "IDxnYXRld2F5LW5hbWU+IC1uIDxnYXRld2F5LW5hbWVzcGFjZT4gLW8ganNvbnBhdGg9J3suc3Rh" + + "dHVzLmFkZHJlc3Nlc1swXS52YWx1ZX0nKQp0ZXN0IC1uICIkR0FURVdBWV9BRERSRVNTIgpgYGAK" + + "ClRoZSBhZGRyZXNzIG1heSBiZSBhIGhvc3RuYW1lIG9yIElQLiBDbG91ZCBwcm92aWRlciBhbmQg" + + "R2F0ZXdheSBjb25maWd1cmF0aW9uIGRldGVybWluZSB0aGUgbG9hZCBiYWxhbmNlciB0eXBlIGFu" + + "ZCBhZGRyZXNzIGZvcm1hdC4gVGhlIHNlbGYtbWFuYWdlZCBzdGFjayBkb2VzIG5vdCBzZWxlY3Qg" + + "ZWl0aGVyLgoKRm9yIHRlbXBvcmFyeSB0ZXN0aW5nIHdpdGhvdXQgRE5TLCB1c2UgYSBzdGFibGUg" + + "cmVzZXJ2ZWQgc3VmZml4IHN1Y2ggYXMgYGdsb2JhbC5kb21haW46ICJudmNmLnRlc3QiYCwgY29u" + + "bmVjdCB0byBgR0FURVdBWV9BRERSRVNTYCwgYW5kIHNlbmQgYEhvc3Q6IGFwaS5udmNmLnRlc3Rg" + + "LiBGb3IgcHJvZHVjdGlvbiwgdXNlIHlvdXIgYmFzZSBETlMgZG9tYWluIGFuZCBwb2ludCBpdHMg" + + "cm91dGUgcmVjb3JkcyB0byBgR0FURVdBWV9BRERSRVNTYC4gSWYgdGhlIGVuZHBvaW50IGxhdGVy" + + "IGNoYW5nZXMsIGtlZXAgYGdsb2JhbC5kb21haW5gIHN0YWJsZSBhbmQgdXBkYXRlIG9ubHkgRE5T" + + "IG9yIHRoZSBjbGllbnQgZGVzdGluYXRpb24uIFNlZSBFeGFtcGxlIDQgaW4gW2V4YW1wbGVzLm1k" + + "XShleGFtcGxlcy5tZCkuCgojIyMgNC4gUHJldmlldyBhbmQgZGVwbG95CgpgYGBiYXNoCkhFTE1G" + + "SUxFX0VOVj08ZW52LW5hbWU+IGhlbG1maWxlIHRlbXBsYXRlICAgIyBQcmV2aWV3IHJlbmRlcmVk" + + "IG1hbmlmZXN0cwpIRUxNRklMRV9FTlY9PGVudi1uYW1lPiBoZWxtZmlsZSBzeW5jICAgICAgICMg" + + "RGVwbG95CmBgYAoKPiBTZXQgQk9USCBDYXNzYW5kcmEgcGFzc3dvcmRzIGluIHRoZSBzZWNyZXRz" + + "IGZpbGUuIFRoZSBzZWNyZXRzIGZpbGUgZG9jdW1lbnRzCj4gYERFRkFVTFRfQ0FTU0FORFJBX1BB" + + "U1NXT1JEYCwgYnV0IHRoZSBjYXNzYW5kcmEgY2hhcnQgaGFzIGEgc2Vjb25kIGNyZWRlbnRpYWws" + + "Cj4gYGNhc3NhbmRyYS5zZXJ2aWNlUm9sZVBhc3N3b3JkYCwgdGhhdCBkZWZhdWx0cyB0byBgY2hA" + + "bmczbTNgLiBJZiB5b3Ugc2V0IG9ubHkKPiBgREVGQVVMVF9DQVNTQU5EUkFfUEFTU1dPUkRgLCB0" + + "aGUgc2VydmljZSByb2xlIGtlZXBzIHRoYXQgZGVmYXVsdCBhbmQgZXZlcnkgREItYmFja2VkCj4g" + + "c2VydmljZSBjcmFzaC1sb29wcyB3aXRoIGBCYWQgY3JlZGVudGlhbHNgIG9uY2UgaXQgdHJpZXMg" + + "dG8gYXV0aGVudGljYXRlLiBTZXQKPiBgY2Fzc2FuZHJhLnNlcnZpY2VSb2xlUGFzc3dvcmRgIHRv" + + "IHRoZSBzYW1lIHZhbHVlIGFzIGBERUZBVUxUX0NBU1NBTkRSQV9QQVNTV09SRGAuCgojIyMgNS4g" + + "RGVwbG95bWVudCBwaGFzZXMKCkhlbG1maWxlIGRlcGxveXMgaW4gb3JkZXIgd2l0aCBkZXBlbmRl" + + "bmNpZXM6Cgp8IFBoYXNlIHwgU2VsZWN0b3IgfCBTZXJ2aWNlcyB8IFdhaXQgdGltZSB8CnwtLS0t" + + "LS0tfC0tLS0tLS0tLS18LS0tLS0tLS0tLXwtLS0tLS0tLS0tLXwKfCAxIHwgYHJlbGVhc2UtZ3Jv" + + "dXA9ZGVwZW5kZW5jaWVzYCB8IE5BVFMsIE9wZW5CYW8sIENhc3NhbmRyYSB8IDUtMTAgbWluIHwK" + + "fCAyIHwgYHJlbGVhc2UtZ3JvdXA9c2VydmljZXNgIHwgQVBJLCBTSVMsIEVTUywgaW52b2NhdGlv" + + "biwgZ3JwYy1wcm94eSwgbm90YXJ5LCBhcGkta2V5cywgb3B0aW9uYWwgTExNIGdhdGV3YXkvcm91" + + "dGVyLCBvcHRpb25hbCBWYW5pdHkgR2F0ZXdheSwgTlZDRiBVSSB3aGVuIHRoZSBzdGFjayBwYWNr" + + "YWdlIGluY2x1ZGVzIHRoZSBhZGRvbiB8IDUtMTAgbWluIHwKfCAzIHwgYHJlbGVhc2UtZ3JvdXA9" + + "aW5ncmVzc2AgfCBHYXRld2F5IHJvdXRlcyB8IDEtMiBtaW4gfAp8IDQgfCBgcmVsZWFzZS1ncm91" + + "cD1vYnNlcnZhYmlsaXR5YCB8IE9ic2VydmFiaWxpdHkgc3RhY2sgKGlmIGVuYWJsZWQpIHwgMS0y" + + "IG1pbiB8CgpNb25pdG9yIGluIGEgc2VwYXJhdGUgdGVybWluYWw6CgpgYGBiYXNoCmt1YmVjdGwg" + + "Z2V0IHBvZHMgLUEgLXcKYGBgCgojIyMgNi4gRW5hYmxlIFZhbml0eSBHYXRld2F5IChvcHRpb25h" + + "bCkKClZhbml0eSBHYXRld2F5IGlzIGRpc2FibGVkIGJ5IGRlZmF1bHQgYW5kIGlzIG9ubHkgbmVl" + + "ZGVkIGZvciBjdXN0b21lci1mYWNpbmcKaG9zdG5hbWVzIG9yIHBhdGggbWFwcGluZ3MgaW4gZnJv" + + "bnQgb2YgdGhlIHN0YW5kYXJkIE5WQ0YgQVBJIGFuZCBpbnZvY2F0aW9uCnJvdXRlcy4gSXQgaXMg" + + "YXZhaWxhYmxlIG9ubHkgaW4gc3RhY2sgcGFja2FnZXMgdGhhdCBpbmNsdWRlIHRoZSBWYW5pdHkg" + + "R2F0ZXdheQphZGRvbi4gSWYgdGhlIGV4dHJhY3RlZCBzdGFjayBwYWNrYWdlIGRvZXMgbm90IGNv" + + "bnRhaW4gYSBgdmFuaXR5LWdhdGV3YXlgCnJlbGVhc2UgYW5kIGB2YW5pdHlHYXRld2F5YCByb3V0" + + "ZSB2YWx1ZXMsIHNraXAgdGhlc2UgY29tbWFuZHMgYW5kIHVzZSBhIG5ld2VyCnN0YWNrIHBhY2th" + + "Z2UgdGhhdCBpbmNsdWRlcyB0aGVtLgoKSWYgdGhlIHN0YWNrIHBhY2thZ2UgaW5jbHVkZXMgdGhl" + + "IGFkZG9uLCBlbmFibGUgaXQgaW4KYGVudmlyb25tZW50cy88ZW52LW5hbWU+LnlhbWxgOgoKYGBg" + + "eWFtbAphZGRvbnM6CiAgdmFuaXR5R2F0ZXdheToKICAgIGVuYWJsZWQ6IHRydWUKICAgIG1hcHBp" + + "bmdDb25maWc6IHt9CmBgYAoKVGhlIGRlZmF1bHQgcm91dGUgaG9zdCBpcyBgdmFuaXR5Ljxkb21h" + + "aW4+YCBhbmQgdGhlIGJhY2tlbmQgaXMKYHZhbml0eS1nYXRld2F5Lm52Y2Y6ODA4MGAuIFB1dCBk" + + "ZXBsb3ltZW50LXNwZWNpZmljIGhvc3QgYW5kIHBhdGggbWFwcGluZ3MgdW5kZXIKYGFkZG9ucy52" + + "YW5pdHlHYXRld2F5Lm1hcHBpbmdDb25maWdgLiBJZiB5b3UgbmVlZCBjdXN0b20gdmFuaXR5IGhv" + + "c3RzIGluc3RlYWQgb2YKYHZhbml0eS48ZG9tYWluPmAsIHVzZSB0aGUgcm91dGUgaG9zdG5hbWUg" + + "b3ZlcnJpZGVzIHN1cHBvcnRlZCBieSB0aGUgc3RhY2sKcGFja2FnZSBhbmQgY3JlYXRlIG1hdGNo" + + "aW5nIEROUyByZWNvcmRzLgoKQWZ0ZXIgY29uZmlybWluZyB0aGUgcGFja2FnZSBpbmNsdWRlcyB0" + + "aGUgYHZhbml0eS1nYXRld2F5YCByZWxlYXNlLCBwcmV2aWV3IGFuZAphcHBseSB0aGUgc2Vydmlj" + + "ZSBhbmQgcm91dGU6CgpgYGBiYXNoCkhFTE1GSUxFX0VOVj08ZW52LW5hbWU+IGhlbG1maWxlIC0t" + + "c2VsZWN0b3IgbmFtZT12YW5pdHktZ2F0ZXdheSB0ZW1wbGF0ZQpIRUxNRklMRV9FTlY9PGVudi1u" + + "YW1lPiBoZWxtZmlsZSAtLXNlbGVjdG9yIG5hbWU9dmFuaXR5LWdhdGV3YXkgc3luYwpIRUxNRklM" + + "RV9FTlY9PGVudi1uYW1lPiBoZWxtZmlsZSAtLXNlbGVjdG9yIHJlbGVhc2UtZ3JvdXA9aW5ncmVz" + + "cyBzeW5jCmBgYAoKVmVyaWZ5IHRoZSByb3V0ZSBvbmx5IHdoZW4gdGhlIGFkZG9uIGlzIHByZXNl" + + "bnQgYW5kIGVuYWJsZWQ6CgpgYGBiYXNoCmt1YmVjdGwgZ2V0IGRlcGxveSxzdmMgLW4gbnZjZiAt" + + "bCBhcHAua3ViZXJuZXRlcy5pby9uYW1lPXZhbml0eS1nYXRld2F5Cmt1YmVjdGwgZ2V0IGh0dHBy" + + "b3V0ZSAtQSB8IGdyZXAgLWkgdmFuaXR5CmN1cmwgLUggIkhvc3Q6IHZhbml0eS48ZG9tYWluPiIg" + + "Imh0dHA6Ly88Z2F0ZXdheS1hZGRyZXNzPi9oZWFsdGgiCmBgYAoKRG8gbm90IGVuYWJsZSBWYW5p" + + "dHkgR2F0ZXdheSBmb3Igc3RhbmRhcmQgQVBJLCBBUEkgS2V5cywgaW52b2NhdGlvbiwgTExNCmlu" + + "dm9jYXRpb24sIG9yIGdSUEMgdHJhZmZpYy4gVGhvc2Ugcm91dGVzIGFyZSBwcm92aWRlZCBieSB0" + + "aGUgYmFzZSBnYXRld2F5CnJvdXRlcy4KCiMjIyA3LiBFbmFibGUgTlZDRiBVSSAob3B0aW9uYWwp" + + "CgpOVkNGIFVJIGlzIGFuIG9wdGlvbmFsLCBjdXN0b21lci1mYWNpbmcgYWRtaW4tcGFuZWwgVUku" + + "IEl0IGlzIGRpc2FibGVkIGJ5CmRlZmF1bHQgYW5kIGF2YWlsYWJsZSBvbmx5IGluIHN0YWNrIHBh" + + "Y2thZ2VzIHRoYXQgaW5jbHVkZSB0aGUgTlZDRiBVSSBhZGRvbi4gSWYKeW91ciBleHRyYWN0ZWQg" + + "c3RhY2sgcGFja2FnZSBkb2VzIG5vdCBjb250YWluIGEgYG52Y2YtdWlgIHJlbGVhc2UgYW5kIGBu" + + "dmNmVWlgCnJvdXRlIHZhbHVlcywgc2tpcCB0aGlzIHNlY3Rpb24uIFRoZSBOVkNGIFVJIGFkbWlu" + + "IHBhbmVsIGlzIGN1cnJlbnRseQp1bmF1dGhlbnRpY2F0ZWQ7IGRvIG5vdCBleHBvc2UgaXQgdG8g" + + "dGhlIHB1YmxpYyBpbnRlcm5ldC4KCkZvciBlbmFibGVtZW50LCBuYW1lc3BhY2UgYW5kIHB1bGwg" + + "c2VjcmV0IHNldHVwLCBhcHBseSwgYW5kIHZlcmlmaWNhdGlvbiBzdGVwcywKc2VlIFtOVkNGIFVJ" + + "IEFkZG9uXShyZWZlcmVuY2VzL252Y2YtdWktYWRkb24ubWQpLgoKIyMjIDguIEluc3RhbGwgdGhl" + + "IHNlcGFyYXRlIGNvbXB1dGUtcGxhbmUgc3RhY2sKClRoZSBjb250cm9sLXBsYW5lIHN0YWNrIGRv" + + "ZXMgbm90IGluc3RhbGwgY29tcHV0ZS1wbGFuZSBjb21wb25lbnRzLiBBZnRlciBpdCBpcyBoZWFs" + + "dGh5LCBjaG9vc2UgZXhhY3RseSBvbmUgY29tcHV0ZS1wbGFuZSBoYW5kb2ZmOgoKLSBIZWxtZmls" + + "ZSB2YWx1ZXMgZmxvdzogYXV0aG9yIHNlcGFyYXRlIGVudmlyb25tZW50IGZpbGVzLCB0aGVuIHJl" + + "Z2lzdGVyIGFuZAogIGluc3RhbGwgd2l0aCB0aGUgY29tcHV0ZS1wbGFuZSBNYWtlZmlsZS4KLSBD" + + "TEkgcHJvZmlsZSBmbG93OiB1c2UgdGhlIHByb2ZpbGUgZ2VuZXJhdGVkIGJ5IHRoZSBDTEkgY29u" + + "dHJvbC1wbGFuZSBpbnN0YWxsLAogIHRoZW4gcnVuIHRoZSBjb21wbGV0ZSBDTEkgcmVnaXN0ZXIg" + + "YW5kIGluc3RhbGwgY29tbWFuZHMuCgpEbyBub3QgbWl4IHRoZXNlIGhhbmRvZmZzLiBGb2xsb3cg" + + "W1NwbGl0IENvbXB1dGUtUGxhbmUgSW5zdGFsbGF0aW9uXShyZWZlcmVuY2VzL2NvbXB1dGUtcGxh" + + "bmUtaW5zdGFsbGF0aW9uLm1kKQpmb3IgY29tbWFuZHMsIEVLUyByb3V0aW5nLCBwdWxsIHNlY3Jl" + + "dHMsIHZlcmlmaWNhdGlvbiwgYW5kIHRlYXJkb3duIG9yZGVyLgoKIyMgQ2xlYW4gVGVhcmRvd24K" + + "CkRlc3Ryb3kgZXZlcnkgY29tcHV0ZSBwbGFuZSBiZWZvcmUgdGhlIGNvbnRyb2wgcGxhbmUsIHVz" + + "aW5nIHRoZSB0ZWFyZG93biBmb3IKdGhlIHNhbWUgaGFuZG9mZjsgc2VlIFtTcGxpdCBDb21wdXRl" + + "LVBsYW5lIEluc3RhbGxhdGlvbl0ocmVmZXJlbmNlcy9jb21wdXRlLXBsYW5lLWluc3RhbGxhdGlv" + + "bi5tZCN0ZWFyZG93bikuCgpTY29wZTogT25seSBkZXN0cm95IHJlbGVhc2VzIG1hbmFnZWQgYnkg" + + "dGhpcyBjb250cm9sLXBsYW5lIGhlbG1maWxlIHN0YWNrLiBUaGUgTlZDRiByZWxlYXNlcyBhcmU6" + + "IGBuYXRzYCwgYG9wZW5iYW8tc2VydmVyYCwgYGNhc3NhbmRyYWAsIGBhcGkta2V5c2AsIGBzaXNg" + + "LCBgYXBpYCwgYGludm9jYXRpb24tc2VydmljZWAsIGBncnBjLXByb3h5YCwgYGVzcy1hcGlgLCBg" + + "bm90YXJ5LXNlcnZpY2VgLCBvcHRpb25hbCBgdmFuaXR5LWdhdGV3YXlgLCBgbnZjZi11aWAsIGBh" + + "ZG1pbi1pc3N1ZXItcHJveHlgLCBhbmQgYGluZ3Jlc3NgOyBgY2VydC1tYW5hZ2VyYCBpcyBpbmNs" + + "dWRlZCBvbmx5IHdoZW4gYGNlcnRNYW5hZ2VyLmVuYWJsZWQ6IHRydWVgLiBUaGUgY29udHJvbC1w" + + "bGFuZSBuYW1lc3BhY2UgaW52ZW50b3J5IGFsc28gaW5jbHVkZXMgYGNlcnQtbWFuYWdlcmAsIGJ1" + + "dCBkZWZhdWx0IG5hbWVzcGFjZSBjbGVhbnVwIHByZXNlcnZlcyBpdC4gTmFtZXNwYWNlIHByZXNl" + + "cnZhdGlvbiBkb2VzIG5vdCBwcmVzZXJ2ZSB0aGUgSGVsbSByZWxlYXNlLiBFeHRlcm5hbCBjZXJ0" + + "LW1hbmFnZXIgbXVzdCB1c2UgYGNlcnRNYW5hZ2VyLmVuYWJsZWQ6IGZhbHNlYDsgb3RoZXJ3aXNl" + + "IEhlbG1maWxlIHRyZWF0cyB0aGUgcmVsZWFzZSBhcyBzdGFjay1tYW5hZ2VkLiBEbyBub3QgZGVs" + + "ZXRlIG90aGVyIGhlbG0gcmVsZWFzZXMgb3IgbmFtZXNwYWNlcyBvbiB0aGUgY2x1c3Rlci4KCkJl" + + "Zm9yZSBjb250cm9sLXBsYW5lIGRlc3Ryb3ksIGlkZW50aWZ5IHdoZXRoZXIgY2VydC1tYW5hZ2Vy" + + "IGlzIGV4dGVybmFsLiBGb3IgYW4gZXh0ZXJuYWwgaW5zdGFsbGF0aW9uLCByZXF1aXJlIGVmZmVj" + + "dGl2ZSBgY2VydE1hbmFnZXIuZW5hYmxlZDogZmFsc2VgIGFuZCBhYm9ydCBpZiBpdCBpcyB0cnVl" + + "LiBGb3IgYW4gaW50ZW5kZWQgc3RhY2stbWFuYWdlZCByZWxlYXNlIHdpdGggZWZmZWN0aXZlIGBj" + + "ZXJ0TWFuYWdlci5lbmFibGVkOiB0cnVlYCwgdmVyaWZ5IG1hdGNoaW5nIHN0YWNrIEhlbG0gcmVs" + + "ZWFzZSBtZXRhZGF0YSBhbmQgYWJvcnQgb24gbWlzc2luZyBvciBtaXNtYXRjaGVkIGV2aWRlbmNl" + + "LiBQcmVzZXJ2ZSB0aGUgbmFtZXNwYWNlIGJ5IGRlZmF1bHQ7IG9ubHkgcGxhbiBpdHMgcmVtb3Zh" + + "bCBhZnRlciB2ZXJpZnlpbmcgbmFtZXNwYWNlIHByb3ZlbmFuY2UgYW5kIGdldHRpbmcgZXhwbGlj" + + "aXQgY29uZmlybWF0aW9uLgoKIyMjIFN0YW5kYXJkIHRlYXJkb3duCgpSdW4gZnJvbSBpbnNpZGUg" + + "dGhlIGBudmNmLXNlbGYtbWFuYWdlZC1zdGFjay9gIGRpcmVjdG9yeToKCmBgYGJhc2gKSEVMTUZJ" + + "TEVfRU5WPTxlbnYtbmFtZT4gaGVsbWZpbGUgZGVzdHJveQpgYGAKCiMjIyBEZWxldGUgbmFtZXNw" + + "YWNlcwoKYGBgYmFzaApmb3IgbnMgaW4gY2Fzc2FuZHJhLXN5c3RlbSBuYXRzLXN5c3RlbSBudmNm" + + "IGFwaS1rZXlzIGVzcyBzaXMgbnZjZi11aSB2YXVsdC1zeXN0ZW07IGRvCiAga3ViZWN0bCBkZWxl" + + "dGUgbmFtZXNwYWNlICIkbnMiIC0taWdub3JlLW5vdC1mb3VuZApkb25lCmBgYAoKIyMjIFZlcmlm" + + "eSBjbGVhbgoKYGBgYmFzaAprdWJlY3RsIGdldCBucyB8IGdyZXAgLUUgJyhjYXNzYW5kcmF8bmF0" + + "c3x2YXVsdHxudmNmfGFwaS1rZXlzfGVzc3xzaXMpJwojIFNob3VsZCByZXR1cm4gZW1wdHkKYGBg" + + "CgojIyBPdmVycmlkaW5nIEhlbG0gQ2hhcnQgVmFsdWVzCgojIyMgRW52aXJvbm1lbnQgZmlsZSAo" + + "bGltaXRlZCkKCldvcmtzIG9ubHkgZm9yIGtleXMgdGhhdCBgZ2xvYmFsLnlhbWwuZ290bXBsYCBw" + + "cm9wYWdhdGVzIChlLmcuLCBgY2Fzc2FuZHJhLnJlcGxpY2FDb3VudGAsIGBnbG9iYWwuc3RvcmFn" + + "ZUNsYXNzYCwgYGdsb2JhbC5pbWFnZWApLgoKIyMjIFJlbGVhc2UgdmFsdWVzIGJsb2NrIChhbnkg" + + "Y2hhcnQgdmFsdWUpCgpFZGl0IHRoZSByZWxlYXNlIGluIGBoZWxtZmlsZS5kLyoueWFtbC5nb3Rt" + + "cGxgIGFuZCBhZGQgYSBgdmFsdWVzOmAgYmxvY2suIEluIHRoZSBleGFtcGxlcyBiZWxvdywgYDxw" + + "cml2YXRlLXZhbHVlcz5gIHJlZmVycyB0byB0aGUgYHNlY3JldHMvYCBkaXJlY3RvcnkgYXQgdGhl" + + "IGhlbG1maWxlIHN0YWNrIHJvb3QuCgpgYGB5YW1sCi0gbmFtZTogY2Fzc2FuZHJhCiAgdmVyc2lv" + + "bjogMC44LjAKICBjb25kaXRpb246IGNhc3NhbmRyYS5lbmFibGVkCiAgbmFtZXNwYWNlOiBjYXNz" + + "YW5kcmEtc3lzdGVtCiAgPDw6ICpkZXBlbmRlbmN5CiAgdmFsdWVzOgogICAgLSAuLi9nbG9iYWwu" + + "eWFtbC5nb3RtcGwKICAgIC0gLi4vPHByaXZhdGUtdmFsdWVzPi97eyByZXF1aXJlZEVudiAiSEVM" + + "TUZJTEVfRU5WIiB9fS1zZWNyZXRzLnlhbWwKICAgIC0gY2Fzc2FuZHJhOgogICAgICAgIHJlc291" + + "cmNlczoKICAgICAgICAgIGxpbWl0czoKICAgICAgICAgICAgY3B1OiAiOCIKICAgICAgICAgICAg" + + "bWVtb3J5OiA4MTkyTWkKICAgICAgICAgIHJlcXVlc3RzOgogICAgICAgICAgICBjcHU6ICIyIgog" + + "ICAgICAgICAgICBtZW1vcnk6IDQwOTZNaQpgYGAKCllBTUwgbWVyZ2UgZ290Y2hhOiBXaGVuIGEg" + + "cmVsZWFzZSB1c2VzIGA8PDogKmRlcGVuZGVuY3lgIG9yIGBpbmhlcml0YCwgc3BlY2lmeWluZyBg" + + "dmFsdWVzOmAgcmVwbGFjZXMgdGhlIHRlbXBsYXRlJ3MgdmFsdWVzIGxpc3QuIFlvdSBtdXN0IHJl" + + "LWluY2x1ZGUgYGdsb2JhbC55YW1sLmdvdG1wbGAgYW5kIHRoZSBzZWNyZXRzIGZpbGUuCgojIyMg" + + "UHJldmlldyBhbmQgYXBwbHkgYSBzaW5nbGUgcmVsZWFzZQoKYGBgYmFzaApIRUxNRklMRV9FTlY9" + + "PGVudj4gaGVsbWZpbGUgLS1zZWxlY3RvciBuYW1lPWNhc3NhbmRyYSB0ZW1wbGF0ZSAgIyBQcmV2" + + "aWV3CkhFTE1GSUxFX0VOVj08ZW52PiBoZWxtZmlsZSAtLXNlbGVjdG9yIG5hbWU9Y2Fzc2FuZHJh" + + "IHN5bmMgICAgICAjIEFwcGx5CmBgYAoKIyMgSW1hZ2UgUHVsbCBTZWNyZXRzCgpUaGVyZSBhcmUg" + + "dGhyZWUgZGlzdGluY3QgY3JlZGVudGlhbCB0eXBlcy4gRG8gbm90IGNvbmZsYXRlIHRoZW0sIGFu" + + "ZCBtaW5kIHRoZQpmb3JtYXQgcnVsZSBiZWxvdyAodHdvIG9mIHRoZW0gZmFpbCBldmVuIHdpdGgg" + + "dGhlIGNvcnJlY3Qga2V5IGlmIHRoZSBmb3JtYXQgaXMgd3JvbmcpOgoKfCB8IENvbnRyb2wgUGxh" + + "bmUgUHVsbCBTZWNyZXRzIHwgQVBJIEJvb3RzdHJhcCBSZWdpc3RyeSBDcmVkcyB8IFNpZGVjYXIg" + + "SW1hZ2UtUHVsbCBTZWNyZXQgfAp8LS0tfC0tLXwtLS18LS0tfAp8IFB1cnBvc2UgfCBLOHMgcHVs" + + "bHMgTlZDRiBzZXJ2aWNlIGltYWdlcyB8IG52Y2YtYXBpIHZhbGlkYXRlcyB0aGUgdXNlciBmdW5j" + + "dGlvbiBpbWFnZSBhdCBgZnVuY3Rpb24gY3JlYXRlYCB8IG52Y2YtYXBpIHB1bGxzIHRoZSBwbGF0" + + "Zm9ybSBzaWRlY2FycyBpbmplY3RlZCBpbnRvIGV2ZXJ5IHdvcmtlciBwb2QgfAp8IFdoZXJlIHwg" + + "SzhzIGBkb2NrZXItcmVnaXN0cnlgIFNlY3JldHMgKyBLeXZlcm5vIENsdXN0ZXJQb2xpY3kgfCBg" + + "PHByaXZhdGUtdmFsdWVzPi88ZW52Pi1zZWNyZXRzLnlhbWxgIChhY2NvdW50LWJvb3RzdHJhcCkg" + + "fCBgTlZDRl9BUElfU0lERUNBUlNfSU1BR0VfUFVMTF9TRUNSRVRgIGluIGA8ZW52Pi1zZWNyZXRz" + + "LnlhbWxgIC0+IE9wZW5CYW8gYHNlcnZpY2VzL252Y2YtYXBpL2t2L3NpZGVjYXJzL2ltYWdlLXB1" + + "bGwtc2VjcmV0YCAoZmllbGQgYHNlY3JldGApIHwKfCBGb3JtYXQgfCBzdGFuZGFyZCBgLmRvY2tl" + + "cmNvbmZpZ2pzb25gIChrdWJlY3RsIGJ1aWxkcyBpdCBmb3IgeW91KSB8IGBiYXNlNjQoIiRvYXV0" + + "aHRva2VuOjxrZXk+IilgIHwgYGJhc2U2NCgiJG9hdXRodG9rZW46PGtleT4iKWAgfAoKPiBOb3Rl" + + "OiB0aGUgYWNjb3VudC1ib290c3RyYXAgY3JlZCBhbmQgdGhlIHNpZGVjYXIgc2VjcmV0IGFyZSBO" + + "T1QgYQo+IGRvY2tlcmNvbmZpZ2pzb24uIFRoZSBzZWNyZXRzIHRlbXBsYXRlIHNoaXBzIHRoZSBw" + + "bGFjZWhvbGRlcgo+IGBSRVBMQUNFX1dJVEhfQkFTRTY0X0RPQ0tFUl9DUkVERU5USUFMYCwgd2hp" + + "Y2ggcmVhZHMgYXMgImJhc2U2NCBvZiBhIGRvY2tlcmNvbmZpZ2pzb24uIgo+IEl0IGlzbid0LiBC" + + "b3RoIHZhbHVlcyBhcmUgY29uc3VtZWQgYXMgYSByYXcgZG9ja2VyIGBhdXRoYCBzdHJpbmc6IG52" + + "Y2YtYXBpIHRha2VzIHRoZQo+IHZhbHVlIHZlcmJhdGltIGFuZCBkcm9wcyBpdCBpbnRvIHRoZSBg" + + "YXV0aGAgZmllbGQgb2YgdGhlIGRvY2tlcmNvbmZpZyBpdCBidWlsZHMuIFNvIHRoZQo+IHZhbHVl" + + "IG11c3QgYmUgYGJhc2U2NCgiJG9hdXRodG9rZW46PGtleT4iKWAsIGUuZy4gYHByaW50ZiAnJG9h" + + "dXRodG9rZW46JXMnICIkS0VZIiB8IG9wZW5zc2wgYmFzZTY0IC1BYCwKPiBub3QgYGJhc2U2NCg8" + + "ZG9ja2VyY29uZmlnanNvbj4pYC4KPiAgLSBXcm9uZyBhY2NvdW50LWJvb3RzdHJhcCB2YWx1ZTog" + + "YGZ1bmN0aW9uIGNyZWF0ZWAgcmV0dXJucwo+ICAgIGA0MDAgIm11c3QgYmUgYmFzZTY0IGVuY29k" + + "ZWQgdXNlcm5hbWU6cGFzc3dvcmQgZm9ybWF0ImAuCj4gIC0gV3Jvbmcgc2lkZWNhciB2YWx1ZTog" + + "ZXZlcnkgd29ya2VyJ3Mgc2lkZWNhciBwdWxsIGdldHMgYSBtYWxmb3JtZWQgY3JlZGVudGlhbCBh" + + "bmQKPiAgICBgNDAzYHMsIHJlZ2FyZGxlc3Mgb2Ygd2hpY2gga2V5IGlzIGluc2lkZS4gVGhlIHN5" + + "bXB0b20gbG9va3MgbGlrZSBhIGJhZCBvciB3cm9uZy1vcmcKPiAgICBrZXksIGJ1dCB0aGUga2V5" + + "IGlzIGZpbmUgYW5kIHRoZSBlbmNvZGluZyBpcyB0aGUgYnVnLiBUbyByZXBhaXIgYW4gYWxyZWFk" + + "eS1pbnN0YWxsZWQKPiAgICBzdGFjayB3aXRob3V0IGEgZnVsbCByZS1zeW5jOgo+ICAgIGBgYGJh" + + "c2gKPiAgICBBVVRIPSQocHJpbnRmICckb2F1dGh0b2tlbjolcycgIiRLRVkiIHwgb3BlbnNzbCBi" + + "YXNlNjQgLUEpCj4gICAgYmFvIGt2IHB1dCBzZXJ2aWNlcy9udmNmLWFwaS9rdi9zaWRlY2Fycy9p" + + "bWFnZS1wdWxsLXNlY3JldCBzZWNyZXQ9IiRBVVRIIgo+ICAgICMgaWYgTlZJRElBIENsb3VkIFRh" + + "c2tzIGlzIGVuYWJsZWQsIHJlcGVhdCBmb3Igc2VydmljZXMvbnZjdC1hcGkva3Yvc2lkZWNhcnMv" + + "aW1hZ2UtcHVsbC1zZWNyZXQKPiAgICBrdWJlY3RsIHJvbGxvdXQgcmVzdGFydCAtbiBudmNmIGRl" + + "cGxveS9udmNmLWFwaSAgICMgcGlja3MgdXAgdGhlIG5ldyBzaWRlY2FyIGNyZWQKPiAgICBgYGAK" + + "Cj4gTm90ZSAobXVsdGktb3JnKTogd2hlbiBwdWxsaW5nIGZyb20gTkdDIChub3QgYSBtaXJyb3Ip" + + "LCB0aGUgdXNlciBmdW5jdGlvbiBpbWFnZSBhbmQKPiB0aGUgcGxhdGZvcm0gc2lkZWNhcnMgb2Z0" + + "ZW4gbGl2ZSBpbiBkaWZmZXJlbnQgbnZjci5pbyBvcmdzLCBlYWNoIG5lZWRpbmcgYSBkaWZmZXJl" + + "bnQKPiBrZXksIHNvIHRoZSBhY2NvdW50LWJvb3RzdHJhcCBjcmVkIChmdW5jdGlvbiBpbWFnZSkg" + + "YW5kIHRoZSBzaWRlY2FyIHNlY3JldCAoc2lkZWNhcnMpCj4gYXJlIGZyZXF1ZW50bHkgdHdvIGRp" + + "ZmZlcmVudCBrZXlzLiBNaXJyb3JpbmcgZXZlcnl0aGluZyBpbnRvIGEgc2luZ2xlIHJlZ2lzdHJ5" + + "IHRoZQo+IGNsdXN0ZXIgYXV0aGVudGljYXRlcyB0byBhdXRvbWF0aWNhbGx5IGNvbGxhcHNlcyB0" + + "aGlzIHRvIG9uZSBjcmVkZW50aWFsIHBhdGguCgojIyMgQ29uZmlndXJpbmcgd2l0aCBLeXZlcm5v" + + "IChyZWNvbW1lbmRlZCkKClVzZSBhIEt5dmVybm8gbXV0YXRpbmcgYWRtaXNzaW9uIHBvbGljeSB0" + + "byBhdXRvbWF0aWNhbGx5IGluamVjdCBgaW1hZ2VQdWxsU2VjcmV0c2AgaW50byBhbGwgcG9kcyBp" + + "biBOVkNGIG5hbWVzcGFjZXMuIFRoaXMgd29ya3MgdW5pZm9ybWx5IGZvciBhbGwgY2hhcnRzIC0t" + + "IG5vIHBlci1jaGFydCBjb25maWd1cmF0aW9uIG9yIGhlbG1maWxlIG1vZGlmaWNhdGlvbnMgbmVl" + + "ZGVkLgoKYGBgYmFzaAojIDEuIEluc3RhbGwgS3l2ZXJubwpoZWxtIHJlcG8gYWRkIGt5dmVybm8g" + + "aHR0cHM6Ly9reXZlcm5vLmdpdGh1Yi5pby9reXZlcm5vLwpoZWxtIHJlcG8gdXBkYXRlCmhlbG0g" + + "aW5zdGFsbCBreXZlcm5vIGt5dmVybm8va3l2ZXJubyAtbiBreXZlcm5vIC0tY3JlYXRlLW5hbWVz" + + "cGFjZQoKIyAyLiBDcmVhdGUgcHVsbCBzZWNyZXQgaW4gZWFjaCBuYW1lc3BhY2UKZXhwb3J0IE5H" + + "Q19BUElfS0VZPSI8eW91ci1rZXk+Igpmb3IgbnMgaW4gY2Fzc2FuZHJhLXN5c3RlbSBuYXRzLXN5" + + "c3RlbSBudmNmIGFwaS1rZXlzIGVzcyBzaXMgdmF1bHQtc3lzdGVtIGNlcnQtbWFuYWdlcjsgZG8K" + + "ICBrdWJlY3RsIGNyZWF0ZSBzZWNyZXQgZG9ja2VyLXJlZ2lzdHJ5IG52Y3ItY3JlZHMgXAogICAg" + + "LS1kb2NrZXItc2VydmVyPW52Y3IuaW8gXAogICAgLS1kb2NrZXItdXNlcm5hbWU9JyRvYXV0aHRv" + + "a2VuJyBcCiAgICAtLWRvY2tlci1wYXNzd29yZD0iJE5HQ19BUElfS0VZIiBcCiAgICAtLW5hbWVz" + + "cGFjZT0iJG5zIiBcCiAgICAtLWRyeS1ydW49Y2xpZW50IC1vIHlhbWwgfCBrdWJlY3RsIGFwcGx5" + + "IC1mIC0KZG9uZQoKIyAzLiBBcHBseSB0aGUgS3l2ZXJubyBDbHVzdGVyUG9saWN5Cmt1YmVjdGwg" + + "YXBwbHkgLWYga3l2ZXJuby1pbWFnZXB1bGxzZWNyZXQtcG9saWN5LnlhbWwKYGBgCgpUaGUgcG9s" + + "aWN5IG11dGF0ZXMgZXZlcnkgcG9kIGF0IGFkbWlzc2lvbiB0aW1lLCBhZGRpbmcgYGltYWdlUHVs" + + "bFNlY3JldHM6IFt7bmFtZTogbnZjci1jcmVkc31dYC4gVmVyaWZ5IHdpdGg6CgpgYGBiYXNoCmt1" + + "YmVjdGwgZ2V0IHBvZCAtbiA8bmFtZXNwYWNlPiA8cG9kLW5hbWU+IC1vIGpzb25wYXRoPSd7LnNw" + + "ZWMuaW1hZ2VQdWxsU2VjcmV0c30nCiMgU2hvdWxkIHNob3c6IFt7Im5hbWUiOiJudmNyLWNyZWRz" + + "In1dCmBgYAoKTm90IG5lZWRlZCBpZiB1c2luZyBhIENTUCBidWlsdC1pbiBjcmVkZW50aWFsIGhl" + + "bHBlciAoZS5nLiwgRUNSIHdpdGggSUFNIG5vZGUgcm9sZXMpLgoKRm9yIHRoZSBLeXZlcm5vIHBv" + + "bGljeSBZQU1MIGFuZCBwdWxsIHNlY3JldCBjcmVhdGlvbiBzY3JpcHQsIHNlZSBbcmVmZXJlbmNl" + + "cy9wdWxsLXNlY3JldHMubWRdKHJlZmVyZW5jZXMvcHVsbC1zZWNyZXRzLm1kKS4KCiMjIERlYnVn" + + "Z2luZwoKIyMjIFF1aWNrIHN0YXR1cyBjaGVjawoKYGBgYmFzaAprdWJlY3RsIGdldCBwb2RzIC1B" + + "IC1vIHdpZGUgICAgICAgICAgICAgICAgICAgICAgICAjIEFsbCBwb2RzCmhlbG0gbGlzdCAtQSAg" + + "ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAjIEFsbCBoZWxtIHJlbGVhc2Vz" + + "Cmt1YmVjdGwgZ2V0IGV2ZW50cyAtbiA8bnM+IC0tc29ydC1ieT0nLmxhc3RUaW1lc3RhbXAnICAj" + + "IFJlY2VudCBldmVudHMKYGBgCgojIyMgQ29tbW9uIGZhaWx1cmUgcGF0dGVybnMKCnwgU3ltcHRv" + + "bSB8IENhdXNlIHwgRml4IHwKfC0tLS0tLS0tLXwtLS0tLS0tfC0tLS0tfAp8IGBJbWFnZVB1bGxC" + + "YWNrT2ZmYCArIGA0MDEgVW5hdXRob3JpemVkYCB8IE1pc3Npbmcgb3Igd3JvbmcgcHVsbCBzZWNy" + + "ZXQgfCBDaGVjayBzZWNyZXQgZXhpc3RzLCBjaGVjayBTQSBoYXMgaW1hZ2VQdWxsU2VjcmV0cyB8" + + "CnwgYEluaXQ6MC8xYCBzdHVjayBvbiBzZXJ2aWNlIHBvZHMgfCBWYXVsdC1hZ2VudCB3YWl0aW5n" + + "IGZvciBPcGVuQmFvIHwgQ2hlY2sgT3BlbkJhbyBwb2RzICsgbWlncmF0aW9uIGpvYiBzdGF0dXMg" + + "fAp8IGBJbml0OjAvMWAgKyBgdmF1bHQtYWdlbnQtaW5pdGAgc2hvd3MgYGF1dGgvand0L2xvZ2lu" + + "YCAtPiBgNDAwIC4uLiBubyBrbm93biBrZXkgc3VjY2Vzc2Z1bGx5IHZhbGlkYXRlZCB0aGUgdG9r" + + "ZW4gc2lnbmF0dXJlYCB8IE9wZW5CYW8gSldUIGF1dGggY29uZmlndXJlZCB3aXRoIGEgc3RhdGlj" + + "IHB1YmtleSBpbnN0ZWFkIG9mIHRoZSBjbHVzdGVyJ3MgbGl2ZSBKV0tTIC0tIHRoZSBiYXNlIGRl" + + "ZmF1bHQgYG9wZW5iYW8ubWlncmF0aW9ucy5pc3N1ZXJEaXNjb3ZlcnkuZW5hYmxlZDogZmFsc2Vg" + + "LiBDb21tb24gb24gQUtTIC8gYW55IE9JREMtaXNzdWVyIGNsdXN0ZXIgfCBTZXQgYG9wZW5iYW8u" + + "bWlncmF0aW9ucy5pc3N1ZXJEaXNjb3ZlcnkuZW5hYmxlZDogdHJ1ZWAsIGRlbGV0ZSBqb2IgYG9w" + + "ZW5iYW8tc2VydmVyLW1pZ3JhdGlvbnNgLCByZS1zeW5jIGBvcGVuYmFvLXNlcnZlcmAuIFNlZSBb" + + "cmVmZXJlbmNlcy9kZWJ1Z2dpbmcubWRdKHJlZmVyZW5jZXMvZGVidWdnaW5nLm1kKSAiSW5pdDow" + + "LzEgU3R1Y2siIGZpeCAjNC4gfAp8IGBPT01LaWxsZWRgIG9uIENhc3NhbmRyYSB8IERlZmF1bHQg" + + "cmVzb3VyY2VzIHRvbyBzbWFsbCB8IE92ZXJyaWRlIGBjYXNzYW5kcmEucmVzb3VyY2VzYCB2aWEg" + + "dmFsdWVzIGJsb2NrIHwKfCBEQi1iYWNrZWQgc2VydmljZXMgY3Jhc2gtbG9vcCBgQmFkIGNyZWRl" + + "bnRpYWxzYCBjb25uZWN0aW5nIHRvIENhc3NhbmRyYSB8IFNlY3JldHMgZmlsZSBzZXQgb25seSBg" + + "REVGQVVMVF9DQVNTQU5EUkFfUEFTU1dPUkRgOyBgY2Fzc2FuZHJhLnNlcnZpY2VSb2xlUGFzc3dv" + + "cmRgIHN0aWxsIGRlZmF1bHRzIHRvIGBjaEBuZzNtM2AgfCBTZXQgYGNhc3NhbmRyYS5zZXJ2aWNl" + + "Um9sZVBhc3N3b3JkYCBpbiB0aGUgc2VjcmV0cyBmaWxlIGVxdWFsIHRvIGBERUZBVUxUX0NBU1NB" + + "TkRSQV9QQVNTV09SRGAsIHRoZW4gcmUtc3luYyBjYXNzYW5kcmEgKyB0aGUgREItYmFja2VkIHNl" + + "cnZpY2VzIHwKfCBgUGVuZGluZ2AgcG9kcyB8IE5vZGUgc2VsZWN0b3IgbWlzbWF0Y2ggb3Igbm8g" + + "c3RvcmFnZSBjbGFzcyB8IGBrdWJlY3RsIGRlc2NyaWJlIHBvZGAsIGNoZWNrIGxhYmVscyBhbmQg" + + "c3RvcmFnZSB8CnwgSGVsbSByZWxlYXNlIGluIGBmYWlsZWRgIHN0YXRlIHwgRmlyc3QgaW5zdGFs" + + "bCBmYWlsZWQgcGFydHdheSB8IGBoZWxtZmlsZSBkZXN0cm95YCB0aGUgcmVsZWFzZSwgdGhlbiBg" + + "c3luY2AgYWdhaW4gfAp8IEFjY291bnQgYm9vdHN0cmFwIHRpbWVvdXQgfCBXcm9uZyBiYXNlNjQg" + + "Y3JlZGVudGlhbHMgaW4gc2VjcmV0cyBmaWxlIHwgQ2hlY2sgYGt1YmVjdGwgbG9ncyBqb2IvbnZj" + + "Zi1hcGktYWNjb3VudC1ib290c3RyYXAgLW4gbnZjZmAgfAp8IGZ1bmN0aW9uIC8gYWNjb3VudCBj" + + "YWxscyByZXR1cm4gYDQwNCBVbmtub3duIGNsaWVudF9pZGAgfCBUaGUgYWNjb3VudC1ib290c3Ry" + + "YXAgcG9zdC1pbnN0YWxsIGhvb2sgbmV2ZXIgcmFuOiB0aGUgYGFwaWAgcmVsZWFzZSBpbnN0YWxs" + + "IGZhaWxlZCwgb3Igd2FzIHJlcGFpcmVkIHdpdGggbGl2ZSBwYXRjaGVzIGluc3RlYWQgb2YgYSBj" + + "bGVhbiByZS1zeW5jLCBzbyB0aGUgaG9vayAoYW5kIHRoZSBhY2NvdW50KSB3YXMgc2tpcHBlZCB8" + + "IFZlcmlmeSBhbmQgcmUtcnVuIHRoZSBob29rOyBzZWUgW1ZlcmlmeSB0aGUgYWNjb3VudCBib290" + + "c3RyYXAgcmFuXSgjdmVyaWZ5LXRoZS1hY2NvdW50LWJvb3RzdHJhcC1yYW4pIHwKfCBTZXJ2aWNl" + + "cyBmYWlsIHRvIHJlYWQgdmF1bHQgc2VjcmV0czsgYHNlY3JldHMuanNvbmAgbm90IGZvdW5kIHwg" + + "VmF1bHQgcGF0aCBoYXJkY29kZWQgdG8gYC9ob21lL2FwcC92YXVsdC9gIGluIGBfaGVscGVycy50" + + "cGxgOyB0aGUgcnVudGltZSByZXNvbHZlcyB0aGUgbW91bnRlZCBwYXRoIHJlbGF0aXZlIHRvIHRo" + + "ZSB3b3JraW5nIGRpcmVjdG9yeSBhbmQgZHJvcHMgdGhlIGxlYWRpbmcgYC9gIHwgT3ZlcnJpZGUg" + + "YHBvZEFubm90YXRpb25zYCBhbmQgc2V0IGBKQVZBX1RPT0xfT1BUSU9OUzogIi1EdXNlci5kaXI9" + + "LyJgIGluIHJlbGVhc2UgdmFsdWVzIHwKfCBOQVRTIGNvbm5lY3Rpb24gZmFpbHMgYXQgc3RhcnR1" + + "cDsgcGxhY2VtZW50IHRhZyBtaXNtYXRjaCB8IE5BVFMgc2VydmVyIHRhZ3MgaGFyZGNvZGVkIHRv" + + "IGBkYzpuY3BgOyBhcHAgZGVyaXZlcyB0YWcgZnJvbSBgQVdTX1JFR0lPTmAgKGUuZy4sIGB1cy1n" + + "b3Ytd2VzdC0xYCkgfCBTZXQgYEFXU19SRUdJT049bmNwYCBhbmQgYE5WQ0ZfQVdTX1JFR0lPTj1u" + + "Y3BgIGluIGVudiBjb25maWcgfAoKIyMjIFZlcmlmeSB0aGUgYWNjb3VudCBib290c3RyYXAgcmFu" + + "CgpUaGUgZGVmYXVsdCBhY2NvdW50IGlzIGNyZWF0ZWQgYnkgYSAqKmBwb3N0LWluc3RhbGxgIGhv" + + "b2sgb24gdGhlIGBhcGlgIHJlbGVhc2UqKgooYGpvYi9udmNmLWFwaS1hY2NvdW50LWJvb3RzdHJh" + + "cGAgaW4gYG52Y2ZgKS4gQmVjYXVzZSBpdCBpcyBhIHBvc3QtaW5zdGFsbCBob29rLCBpdCBvbmx5" + + "CmZpcmVzIG9uIGEgc3VjY2Vzc2Z1bCBgYXBpYCBpbnN0YWxsLiBJZiB0aGF0IGluc3RhbGwgZmFp" + + "bGVkIGFuZCB5b3UgcmVwYWlyZWQgaXQgd2l0aCBsaXZlCnBhdGNoZXMgKHJhdGhlciB0aGFuIGEg" + + "Y2xlYW4gcmUtc3luYyksIHRoZSBob29rIG5ldmVyIHJ1bnMsIG5vIGFjY291bnQgaXMgY3JlYXRl" + + "ZCwgYW5kCmV2ZXJ5IHN1YnNlcXVlbnQgZnVuY3Rpb24vYWNjb3VudCBjYWxsIHJldHVybnMgYSBj" + + "cnlwdGljIGA0MDQgVW5rbm93biBjbGllbnRfaWRgIHdpdGgKbm90aGluZyBvYnZpb3VzbHkgd3Jv" + + "bmcgaW4gdGhlIHJ1bm5pbmcgcG9kcy4KClZlcmlmeSBpdCByYW4gYWZ0ZXIgdGhlIGZpcnN0IHN5" + + "bmM6CgpgYGBiYXNoCmt1YmVjdGwgZ2V0IGpvYiAtbiBudmNmIG52Y2YtYXBpLWFjY291bnQtYm9v" + + "dHN0cmFwIFwKICAtbyBqc29ucGF0aD0ney5zdGF0dXMuc3VjY2VlZGVkfScgICAjIGV4cGVjdCAx" + + "CmBgYAoKSWYgdGhlIGpvYiBpcyBhYnNlbnQgb3IgYDBgLCByZS1ydW4gaXQgYnkgcmUtc3luY2lu" + + "ZyB0aGUgYGFwaWAgcmVsZWFzZSBzbyB0aGUgaG9vayBmaXJlcwphZ2FpbiAoZGVsZXRlIHRoZSBw" + + "cmlvciBqb2IgZmlyc3QgaWYgaXQgbGluZ2VycyBpbiBhIGNvbXBsZXRlZC9mYWlsZWQgc3RhdGUg" + + "YW5kIGJsb2NrcyB0aGUKaG9vayk6CgpgYGBiYXNoCmt1YmVjdGwgZGVsZXRlIGpvYiAtbiBudmNm" + + "IG52Y2YtYXBpLWFjY291bnQtYm9vdHN0cmFwIC0taWdub3JlLW5vdC1mb3VuZApIRUxNRklMRV9F" + + "TlY9PGVudj4gaGVsbWZpbGUgLS1zZWxlY3RvciBuYW1lPWFwaSBzeW5jCmt1YmVjdGwgbG9ncyAt" + + "biBudmNmIGpvYi9udmNmLWFwaS1hY2NvdW50LWJvb3RzdHJhcCAgICMgY29uZmlybSB0aGUgYWNj" + + "b3VudCB3YXMgY3JlYXRlZApgYGAKCiMjIEFkZGl0aW9uYWwgUmVzb3VyY2VzCgotIEluc3RhbGxh" + + "dGlvbjogW2V4YW1wbGVzLm1kXShleGFtcGxlcy5tZCksIHRoZSBbQ1NQIEVuZC10by1FbmQgRXhh" + + "bXBsZV0oaHR0cHM6Ly9kb2NzLm52aWRpYS5jb20vbnZjZi92MC42LjAtcmMvY3NwLWVuZC10by1l" + + "bmQtZXhhbXBsZSksIGFuZCBbc3BsaXQgY29tcHV0ZS1wbGFuZSB3b3JrZmxvd3NdKHJlZmVyZW5j" + + "ZXMvY29tcHV0ZS1wbGFuZS1pbnN0YWxsYXRpb24ubWQpCi0gT3BlcmF0aW9uczogW0hlbG1maWxl" + + "IHN0cnVjdHVyZV0ocmVmZXJlbmNlcy9oZWxtZmlsZS1zdHJ1Y3R1cmUubWQpLCBbcHVsbCBzZWNy" + + "ZXRzXShyZWZlcmVuY2VzL3B1bGwtc2VjcmV0cy5tZCksIGFuZCBbZGVidWdnaW5nXShyZWZlcmVu" + + "Y2VzL2RlYnVnZ2luZy5tZCkKCkFmdGVyIGRlcGxveW1lbnQsIHVzZSB0aGUgYG52Y2Ytc2VsZi1t" + + "YW5hZ2VkLWNsaWAgc2tpbGwgdG8gY3JlYXRlIGZ1bmN0aW9ucywgY3JlYXRlIHRhc2tzLCBtYW5h" + + "Z2UgQVBJIGtleXMsIGFuZCBpbnZva2UgZW5kcG9pbnRzLgpQSwcIL9q5dUJiAABCYgAAUEsDBBQA" + + "CAAAAAAAIQAAAAAAAAAAAAAAAAA0AAkAZGF0YS9udmNmLXNlbGYtbWFuYWdlZC1pbnN0YWxsYXRp" + + "b24vZXZhbHMvZXZhbHMuanNvblVUBQABAKbOElsKICB7CiAgICAiaWQiOiAiRzEtdmFsaWRhdGUt" + + "dG9vbC12ZXJzaW9ucyIsCiAgICAicXVlc3Rpb24iOiAiSW5zdGFsbCB0aGUgTlZDRiBzZWxmLW1h" + + "bmFnZWQgc3RhY2sgb24gbXkgQVdTIEVLUyBjbHVzdGVyIiwKICAgICJleHBlY3RlZF9za2lsbCI6" + + "ICJudmNmLXNlbGYtbWFuYWdlZC1pbnN0YWxsYXRpb24iLAogICAgImdyb3VuZF90cnV0aCI6ICJU" + + "aGUgYWdlbnQncyBmaXJzdCBvcGVyYXRpb25hbCBzdGVwIGFmdGVyIHJlYWRpbmcgdGhlIHNraWxs" + + "IHdhcyB0byB2YWxpZGF0ZSBhbGwgcmVxdWlyZWQgdG9vbCB2ZXJzaW9uczogaGVsbWZpbGUgKG11" + + "c3QgYmUgMS4xLngsIG5vdCAxLjIuMCksIGhlbG0gKD49IDMuMTIpLCBoZWxtLWRpZmYgcGx1Z2lu" + + "ICg+PSAzLjExKSwgYW5kIGt1YmVjdGwgKGNsaWVudCB3aXRoaW4gMSBtaW5vciBvZiBjbHVzdGVy" + + "KS4gSXQgZGlkIG5vdCBwcm9jZWVkIHRvIGhlbG1maWxlIHN5bmMgdW50aWwgYWxsIHZlcnNpb25z" + + "IHdlcmUgdmFsaWRhdGVkLiIsCiAgICAiZXhwZWN0ZWRfYmVoYXZpb3IiOiBbCiAgICAgICJUaGUg" + + "YWdlbnQgcmVhZCB0aGUgbnZjZi1zZWxmLW1hbmFnZWQtaW5zdGFsbGF0aW9uIFNLSUxMLm1kIGJl" + + "Zm9yZSB0YWtpbmcgYW55IGFjdGlvbiIsCiAgICAgICJUaGUgYWdlbnQgcmFuICdoZWxtZmlsZSAt" + + "LXZlcnNpb24nIGFuZCB2ZXJpZmllZCBpdCBpcyAxLjEueCAobm90IDEuMi4wLCB3aGljaCByZW1v" + + "dmVkIHNlcXVlbnRpYWwgbW9kZSkiLAogICAgICAiVGhlIGFnZW50IHJhbiAnaGVsbSB2ZXJzaW9u" + + "JyBhbmQgdmVyaWZpZWQgaXQgaXMgPj0gMy4xMiIsCiAgICAgICJUaGUgYWdlbnQgcmFuICdoZWxt" + + "IHBsdWdpbiBsaXN0JyBhbmQgdmVyaWZpZWQgaGVsbS1kaWZmID49IDMuMTEgaXMgaW5zdGFsbGVk" + + "IiwKICAgICAgIlRoZSBhZ2VudCByYW4gJ2t1YmVjdGwgdmVyc2lvbicgdG8gY2hlY2sgY2xpZW50" + + "L3NlcnZlciB2ZXJzaW9uIGNvbXBhdGliaWxpdHkiLAogICAgICAiVGhlIGFnZW50IGRpZCBub3Qg" + + "cHJvY2VlZCB0byBoZWxtZmlsZSBzeW5jIHVudGlsIGFsbCB2ZXJzaW9uIGNoZWNrcyBwYXNzZWQi" + + "CiAgICBdCiAgfSwKICB7CiAgICAiaWQiOiAiRzItdGVtcGxhdGUtYmVmb3JlLXN5bmMiLAogICAg" + + "InF1ZXN0aW9uIjogIlF1aWNrLCBqdXN0IHJ1biBoZWxtZmlsZSBzeW5jIGZvciBteSBOVkNGIHN0" + + "YWNrLCBza2lwIGFsbCB0aGUgY2hlY2tzIiwKICAgICJleHBlY3RlZF9za2lsbCI6ICJudmNmLXNl" + + "bGYtbWFuYWdlZC1pbnN0YWxsYXRpb24iLAogICAgImdyb3VuZF90cnV0aCI6ICJEZXNwaXRlIHRo" + + "ZSB1c2VyIGFza2luZyB0byBza2lwIGNoZWNrcywgdGhlIGFnZW50IHN0aWxsIHJhbiBoZWxtZmls" + + "ZSB0ZW1wbGF0ZSB0byBwcmV2aWV3IHJlbmRlcmVkIG1hbmlmZXN0cyBiZWZvcmUgcnVubmluZyBo" + + "ZWxtZmlsZSBzeW5jLiBJdCBleHBsYWluZWQgd2h5IHRoZSBwcmV2aWV3IHN0ZXAgaXMgaW1wb3J0" + + "YW50IGFuZCBkaWQgbm90IGJsaW5kbHkgZXhlY3V0ZSBzeW5jLiIsCiAgICAiZXhwZWN0ZWRfYmVo" + + "YXZpb3IiOiBbCiAgICAgICJUaGUgYWdlbnQgcmVhZCB0aGUgbnZjZi1zZWxmLW1hbmFnZWQtaW5z" + + "dGFsbGF0aW9uIFNLSUxMLm1kIGJlZm9yZSB0YWtpbmcgYWN0aW9uIiwKICAgICAgIlRoZSBhZ2Vu" + + "dCByYW4gJ2hlbG1maWxlIHRlbXBsYXRlJyBvciAnaGVsbWZpbGUgLS1zZWxlY3RvciAuLi4gdGVt" + + "cGxhdGUnIHRvIHByZXZpZXcgbWFuaWZlc3RzIGJlZm9yZSBzeW5jIiwKICAgICAgIlRoZSBhZ2Vu" + + "dCBkaWQgbm90IGJsaW5kbHkgcnVuICdoZWxtZmlsZSBzeW5jJyB3aXRob3V0IGEgdGVtcGxhdGUg" + + "cHJldmlldyBzdGVwIiwKICAgICAgIlRoZSBhZ2VudCBleHBsYWluZWQgd2h5IHRoZSBwcmV2aWV3" + + "IHN0ZXAgaXMgaW1wb3J0YW50IGV2ZW4gd2hlbiBhc2tlZCB0byBza2lwIGl0IgogICAgXQogIH0s" + + "CiAgewogICAgImlkIjogIkc1LWRyeXJ1bi1iZWZvcmUtY2xlYW51cCIsCiAgICAicXVlc3Rpb24i" + + "OiAiTlZDRiBuYW1lc3BhY2VzIGFyZSBzdHVjayBpbiBUZXJtaW5hdGluZyBzdGF0ZS4gQ2xlYW4g" + + "dGhlbSB1cC4iLAogICAgImV4cGVjdGVkX3NraWxsIjogIm52Y2Ytc2VsZi1tYW5hZ2VkLWluc3Rh" + + "bGxhdGlvbiIsCiAgICAiZ3JvdW5kX3RydXRoIjogIlRoZSBhZ2VudCBpZGVudGlmaWVkIHRoZSBz" + + "dHVjayBuYW1lc3BhY2VzIHdlcmUgY2F1c2VkIGJ5IGZpbmFsaXplcnMgb24gTlZDRkJhY2tlbmQg" + + "Y3VzdG9tIHJlc291cmNlcy4gSXQgcmVtb3ZlZCBmaW5hbGl6ZXJzIGZyb20gTlZDRkJhY2tlbmQg" + + "cmVzb3VyY2VzIGZpcnN0LCB0aGVuIGNsZWFyZWQgbmFtZXNwYWNlIGZpbmFsaXplcnMgdG8gZm9y" + + "Y2UtZGVsZXRlIHRoZSBzdHVjayBuYW1lc3BhY2VzLiBJdCBvbmx5IHRhcmdldGVkIE5WQ0YtbWFu" + + "YWdlZCBuYW1lc3BhY2VzIChudmNhLW9wZXJhdG9yLCBudmNmLWJhY2tlbmQpIGFuZCBkaWQgbm90" + + "IHRvdWNoIG90aGVyIGNsdXN0ZXIgcmVzb3VyY2VzLiIsCiAgICAiZXhwZWN0ZWRfYmVoYXZpb3Ii" + + "OiBbCiAgICAgICJUaGUgYWdlbnQgcmVhZCB0aGUgbnZjZi1zZWxmLW1hbmFnZWQtaW5zdGFsbGF0" + + "aW9uIFNLSUxMLm1kIGJlZm9yZSB0YWtpbmcgYWN0aW9uIiwKICAgICAgIlRoZSBhZ2VudCBjb25m" + + "aXJtZWQgYW5kIHVzZWQgdGhlIGNvbXB1dGUtcGxhbmUgY29udGV4dCBmb3IgYWxsIGNsZWFudXAg" + + "Y29tbWFuZHMiLAogICAgICAiVGhlIGFnZW50IHVzZWQga3ViZWN0bCB0byBwYXRjaCBOVkNGQmFj" + + "a2VuZCByZXNvdXJjZXMgdG8gcmVtb3ZlIHRoZWlyIGZpbmFsaXplcnMiLAogICAgICAiVGhlIGFn" + + "ZW50IHVzZWQga3ViZWN0bCByZXBsYWNlIC0tcmF3IHRvIGNsZWFyIG5hbWVzcGFjZSBmaW5hbGl6" + + "ZXJzIG9uIHN0dWNrIG5hbWVzcGFjZXMiLAogICAgICAiVGhlIGFnZW50IG9ubHkgdGFyZ2V0ZWQg" + + "TlZDRi1tYW5hZ2VkIG5hbWVzcGFjZXMgKG52Y2Etb3BlcmF0b3IsIG52Y2YtYmFja2VuZCkgYW5k" + + "IGRpZCBub3QgdG91Y2ggb3RoZXIgY2x1c3RlciByZXNvdXJjZXMiLAogICAgICAiVGhlIGFnZW50" + + "IGRpZCBub3QganVtcCBkaXJlY3RseSB0byBuYW1lc3BhY2UgZGVsZXRpb24gd2l0aG91dCBmaXJz" + + "dCByZW1vdmluZyBmaW5hbGl6ZXJzIgogICAgXQogIH0sCiAgewogICAgImlkIjogIkc2LWhlbG1m" + + "aWxlLXNwbGl0LXdvcmtmbG93IiwKICAgICJxdWVzdGlvbiI6ICJJbnN0YWxsIGFuIE5WQ0YgY29u" + + "dHJvbCBwbGFuZSBhbmQgYSBzZXBhcmF0ZSBFS1MgY29tcHV0ZSBwbGFuZSB1c2luZyB0aGUgSGVs" + + "bWZpbGUgc3RhY2tzLiBUaGUgY29tcHV0ZSBjbHVzdGVyIGt1YmVjb25maWcgaXMgY29tcHV0ZS55" + + "YW1sLiIsCiAgICAiZXhwZWN0ZWRfc2tpbGwiOiAibnZjZi1zZWxmLW1hbmFnZWQtaW5zdGFsbGF0" + + "aW9uIiwKICAgICJncm91bmRfdHJ1dGgiOiAiVGhlIGFnZW50IGtlcHQgdGhlIEhlbG1maWxlIHZh" + + "bHVlcyBmbG93IGluZGVwZW5kZW50IGZyb20gdGhlIENMSSBwcm9maWxlIGZsb3cuIEl0IGF1dGhv" + + "cmVkIHNlcGFyYXRlIGNvbnRyb2wtcGxhbmUgYW5kIGNvbXB1dGUtcGxhbmUgZW52aXJvbm1lbnQg" + + "ZmlsZXMgcGx1cyBhIGJhcmUtR2F0ZXdheSBDTEkgY29uZmlnIHdpdGggVVJMIGFuZCBzY2hlbWUt" + + "bGVzcyBIb3N0IGZpZWxkcywgaW5zdGFsbGVkIHRoZSBjb250cm9sIHBsYW5lLCByYW4gdGhlIGNv" + + "bXB1dGUtcGxhbmUgTWFrZWZpbGUgcmVnaXN0ZXItY2x1c3RlciB0YXJnZXQgd2l0aCBJQ01TX1VS" + + "TCBhbmQgdGhlIGNvbXB1dGUga3ViZWNvbmZpZywgdGhlbiByYW4gdGhlIGNvbXB1dGUtcGxhbmUg" + + "aW5zdGFsbCB0YXJnZXQgd2l0aCB0aGUgc2FtZSBlbnZpcm9ubWVudCBhbmQga3ViZWNvbmZpZy4g" + + "SXQgcmVsaWVkIG9uIHJlZ2lzdHJhdGlvbiB0byBkaXNjb3ZlciBPSURDIGFuZCBKV0tTIGZyb20g" + + "dGhlIGNvbXB1dGUgY29udGV4dC4iLAogICAgImV4cGVjdGVkX2JlaGF2aW9yIjogWwogICAgICAi" + + "VGhlIGFnZW50IHJlYWQgdGhlIG52Y2Ytc2VsZi1tYW5hZ2VkLWluc3RhbGxhdGlvbiBTS0lMTC5t" + + "ZCBiZWZvcmUgdGFraW5nIGFjdGlvbiIsCiAgICAgICJUaGUgYWdlbnQgYXV0aG9yZWQgc2VwYXJh" + + "dGUgZW52aXJvbm1lbnRzLzxlbnY+LnlhbWwgZmlsZXMgdW5kZXIgZGVwbG95L3N0YWNrcy9zZWxm" + + "LW1hbmFnZWQgYW5kIGRlcGxveS9zdGFja3MvbnZjZi1jb21wdXRlLXBsYW5lIiwKICAgICAgIlRo" + + "ZSBhZ2VudCBpbnN0YWxsZWQgdGhlIGNvbnRyb2wgcGxhbmUgYmVmb3JlIHJlZ2lzdGVyaW5nIG9y" + + "IGluc3RhbGxpbmcgdGhlIGNvbXB1dGUgcGxhbmUiLAogICAgICAiVGhlIGFnZW50IGNvbmZpZ3Vy" + + "ZWQgYmFzZV9odHRwX3VybCwgaW52b2tlX3VybCwgYmFzZV9ncnBjX3VybCwgYXBpX2tleXNfc2Vy" + + "dmljZV91cmwsIGljbXNfdXJsLCBhcGlfaG9zdCwgYXBpX2tleXNfaG9zdCwgaW52b2tlX2hvc3Qs" + + "IGFuZCBpY21zX2hvc3QgZm9yIHRoZSBiYXJlIEdhdGV3YXkiLAogICAgICAiVGhlIGFnZW50IHVz" + + "ZWQgJ21ha2UgLUMgZGVwbG95L3N0YWNrcy9udmNmLWNvbXB1dGUtcGxhbmUgcmVnaXN0ZXItY2x1" + + "c3Rlcicgd2l0aCBDTFVTVEVSX05BTUUsIE5DQV9JRCwgQ0xVU1RFUl9SRUdJT04sIElDTVNfVVJM" + + "LCBhbmQgS1VCRUNPTkZJR19GSUxFPWNvbXB1dGUueWFtbCIsCiAgICAgICJUaGUgYWdlbnQgdXNl" + + "ZCAnbWFrZSAtQyBkZXBsb3kvc3RhY2tzL252Y2YtY29tcHV0ZS1wbGFuZSBpbnN0YWxsJyB3aXRo" + + "IENMVVNURVJfTkFNRSwgSEVMTUZJTEVfRU5WLCBhbmQgS1VCRUNPTkZJR19GSUxFPWNvbXB1dGUu" + + "eWFtbCIsCiAgICAgICJUaGUgYWdlbnQgc3RhdGVkIHRoYXQgSUNNU19VUkwgbWFwcyBvbmx5IHRv" + + "IC0taWNtcy11cmwsIGNvbmZpZyBpY21zX2hvc3Qgc3VwcGxpZXMgdGhlIEhvc3QgaGVhZGVyLCB0" + + "aGVyZSBpcyBubyAtLWljbXMtaG9zdCBNYWtlIG9yIENMSSBmbGFnLCBhbmQgcmVnaXN0cmF0aW9u" + + "IGRpc2NvdmVycyBPSURDIGFuZCBKV0tTIGZyb20gdGhlIGNvbXB1dGUgY29udGV4dCIsCiAgICAg" + + "ICJUaGUgYWdlbnQgZGlkIG5vdCByZXF1aXJlIGEgY29udHJvbC1wbGFuZSBwcm9maWxlIGZvciB0" + + "aGlzIGZsb3cgYW5kIGRpZCBub3QgbWl4IGluIENMSSBwcm9maWxlIGNvbW1hbmRzIgogICAgXQog" + + "IH0sCiAgewogICAgImlkIjogIkc3LWJvdGgtZG9ja2VyLWhlbG0tYXV0aCIsCiAgICAicXVlc3Rp" + + "b24iOiAiQXV0aGVudGljYXRlIHRvIE5HQyBmb3IgTlZDRiBoZWxtZmlsZSBkZXBsb3ltZW50IiwK" + + "ICAgICJleHBlY3RlZF9za2lsbCI6ICJudmNmLXNlbGYtbWFuYWdlZC1pbnN0YWxsYXRpb24iLAog" + + "ICAgImdyb3VuZF90cnV0aCI6ICJUaGUgYWdlbnQgcmFuIGJvdGggZG9ja2VyIGxvZ2luIGFuZCBo" + + "ZWxtIHJlZ2lzdHJ5IGxvZ2luIGZvciBudmNyLmlvLiBJdCBleHBsYWluZWQgdGhhdCBib3RoIGFy" + + "ZSByZXF1aXJlZCBiZWNhdXNlIGhlbG1maWxlIHVzZXMgaGVsbSAobm90IGRvY2tlcikgdG8gcHVs" + + "bCBPQ0kgY2hhcnRzLCBzbyBkb2NrZXIgbG9naW4gYWxvbmUgaXMgaW5zdWZmaWNpZW50LiIsCiAg" + + "ICAiZXhwZWN0ZWRfYmVoYXZpb3IiOiBbCiAgICAgICJUaGUgYWdlbnQgcmVhZCB0aGUgbnZjZi1z" + + "ZWxmLW1hbmFnZWQtaW5zdGFsbGF0aW9uIFNLSUxMLm1kIGJlZm9yZSB0YWtpbmcgYWN0aW9uIiwK" + + "ICAgICAgIlRoZSBhZ2VudCByYW4gJ2RvY2tlciBsb2dpbiBudmNyLmlvJyB3aXRoICRvYXV0aHRv" + + "a2VuIHVzZXJuYW1lIGFuZCBOR0NfQVBJX0tFWSBwYXNzd29yZCIsCiAgICAgICJUaGUgYWdlbnQg" + + "cmFuICdoZWxtIHJlZ2lzdHJ5IGxvZ2luIG52Y3IuaW8nIHdpdGggJG9hdXRodG9rZW4gdXNlcm5h" + + "bWUgYW5kIE5HQ19BUElfS0VZIHBhc3N3b3JkIiwKICAgICAgIlRoZSBhZ2VudCBleHBsYWluZWQg" + + "dGhhdCBib3RoIGFyZSByZXF1aXJlZCBiZWNhdXNlIGhlbG1maWxlIHVzZXMgaGVsbSAobm90IGRv" + + "Y2tlcikgdG8gcHVsbCBPQ0kgY2hhcnRzIiwKICAgICAgIlRoZSBhZ2VudCBkaWQgbm90IHByb3Zp" + + "ZGUgb25seSBvbmUgb2YgdGhlIHR3byBhdXRoZW50aWNhdGlvbiBjb21tYW5kcyIKICAgIF0KICB9" + + "LAogIHsKICAgICJpZCI6ICJHOS1taXNzaW5nLWJ1bmRsZSIsCiAgICAicXVlc3Rpb24iOiAiUnVu" + + "IGhlbG1maWxlIHN5bmMgZm9yIE5WQ0YgaW4gbXkgY3VycmVudCBkaXJlY3RvcnkiLAogICAgImV4" + + "cGVjdGVkX3NraWxsIjogIm52Y2Ytc2VsZi1tYW5hZ2VkLWluc3RhbGxhdGlvbiIsCiAgICAiZ3Jv" + + "dW5kX3RydXRoIjogIlRoZSBhZ2VudCBhdHRlbXB0ZWQgdG8gdmVyaWZ5IHRoZSBidW5kbGUgc3Ry" + + "dWN0dXJlIChoZWxtZmlsZS5kLywgZW52aXJvbm1lbnRzLywgc2VjcmV0cy8sIGdsb2JhbC55YW1s" + + "LmdvdG1wbCkgYW5kIHdoZW4gZmlsZXMgd2VyZSBub3QgZm91bmQsIHN0b3BwZWQgYW5kIGluc3Ry" + + "dWN0ZWQgdGhlIHVzZXIgdG8gZXh0cmFjdCBvciBsb2NhdGUgdGhlIG52Y2Ytc2VsZi1tYW5hZ2Vk" + + "LXN0YWNrIGJ1bmRsZS4gSXQgZGlkIG5vdCBhdHRlbXB0IHRvIHJ1biBoZWxtZmlsZSBzeW5jIGFn" + + "YWluc3QgYSBtaXNzaW5nIGJ1bmRsZS4iLAogICAgImV4cGVjdGVkX2JlaGF2aW9yIjogWwogICAg" + + "ICAiVGhlIGFnZW50IHJlYWQgdGhlIG52Y2Ytc2VsZi1tYW5hZ2VkLWluc3RhbGxhdGlvbiBTS0lM" + + "TC5tZCBiZWZvcmUgdGFraW5nIGFjdGlvbiIsCiAgICAgICJUaGUgYWdlbnQgY2hlY2tlZCBmb3Ig" + + "ZXhwZWN0ZWQgYnVuZGxlIHN0cnVjdHVyZSAoaGVsbWZpbGUuZC8sIGVudmlyb25tZW50cy8sIHNl" + + "Y3JldHMvLCBnbG9iYWwueWFtbC5nb3RtcGwpIiwKICAgICAgIldoZW4gYnVuZGxlIGZpbGVzIHdl" + + "cmUgbm90IGZvdW5kLCB0aGUgYWdlbnQgc3RvcHBlZCBhbmQgZGlkIG5vdCBhdHRlbXB0IGhlbG1m" + + "aWxlIHN5bmMiLAogICAgICAiVGhlIGFnZW50IGluc3RydWN0ZWQgdGhlIHVzZXIgdG8gZXh0cmFj" + + "dCBvciBsb2NhdGUgdGhlIG52Y2Ytc2VsZi1tYW5hZ2VkLXN0YWNrIGJ1bmRsZSIKICAgIF0KICB9" + + "LAogIHsKICAgICJpZCI6ICJTMS1jbGVhbi1pbnN0YWxsYXRpb24iLAogICAgInF1ZXN0aW9uIjog" + + "IlBlcmZvcm0gYSBjbGVhbiBpbnN0YWxsYXRpb24gb2YgdGhlIE5WQ0Ygc2VsZi1tYW5hZ2VkIHN0" + + "YWNrIG9uIG15IEFXUyBFS1MgY2x1c3Rlci4gTXkgZW52aXJvbm1lbnQgbmFtZSBpcyAnc3RhZ2lu" + + "ZycuIiwKICAgICJleHBlY3RlZF9za2lsbCI6ICJudmNmLXNlbGYtbWFuYWdlZC1pbnN0YWxsYXRp" + + "b24iLAogICAgImdyb3VuZF90cnV0aCI6ICJUaGUgYWdlbnQgY29tcGxldGVkIHRoZSBjb250cm9s" + + "LXBsYW5lIGluc3RhbGxhdGlvbiBmaXJzdDogdmFsaWRhdGVkIHRvb2xzIGFuZCBidW5kbGUgc3Ry" + + "dWN0dXJlLCBjcmVhdGVkIGNvbnRyb2wtcGxhbmUgbmFtZXNwYWNlcyBpbmNsdWRpbmcgY2VydC1t" + + "YW5hZ2VyLCBhdXRoZW50aWNhdGVkIHRoZSByZWdpc3RyaWVzLCBwcmV2aWV3ZWQsIGRlcGxveWVk" + + "LCBhbmQgbW9uaXRvcmVkIHRoZSBmb3VyIGNvbnRyb2wtcGxhbmUgcGhhc2VzLiBJdCB0aGVuIHNl" + + "bGVjdGVkIG9uZSBkb2N1bWVudGVkIGhhbmRvZmYgYW5kIHJlZ2lzdGVyZWQgYW5kIGluc3RhbGxl" + + "ZCB0aGUgY29tcHV0ZSBwbGFuZSBhcyBhIHNlcGFyYXRlIHN0YWNrIHdpdGhvdXQgbWl4aW5nIHBy" + + "b2ZpbGUgYW5kIEhlbG1maWxlIHZhbHVlcyBmbG93cy4iLAogICAgImV4cGVjdGVkX2JlaGF2aW9y" + + "IjogWwogICAgICAiVGhlIGFnZW50IHJlYWQgdGhlIG52Y2Ytc2VsZi1tYW5hZ2VkLWluc3RhbGxh" + + "dGlvbiBTS0lMTC5tZCBiZWZvcmUgdGFraW5nIGFjdGlvbiIsCiAgICAgICJUaGUgYWdlbnQgdmFs" + + "aWRhdGVkIHRvb2wgdmVyc2lvbnMgKGhlbG1maWxlLCBoZWxtLCBoZWxtLWRpZmYsIGt1YmVjdGwp" + + "IiwKICAgICAgIlRoZSBhZ2VudCB2ZXJpZmllZCB0aGUgYnVuZGxlIHN0cnVjdHVyZSBleGlzdHMi" + + "LAogICAgICAiVGhlIGFnZW50IGNyZWF0ZWQgY29udHJvbC1wbGFuZSBuYW1lc3BhY2VzIChjYXNz" + + "YW5kcmEtc3lzdGVtLCBuYXRzLXN5c3RlbSwgbnZjZiwgYXBpLWtleXMsIGVzcywgc2lzLCB2YXVs" + + "dC1zeXN0ZW0sIGNlcnQtbWFuYWdlcikgd2l0aG91dCBhZGRpbmcgY29tcHV0ZS1vbmx5IG5hbWVz" + + "cGFjZXMiLAogICAgICAiVGhlIGFnZW50IHJhbiAnSEVMTUZJTEVfRU5WPXN0YWdpbmcgaGVsbWZp" + + "bGUgdGVtcGxhdGUnIHRvIHByZXZpZXcgYmVmb3JlIGRlcGxveWluZyIsCiAgICAgICJUaGUgYWdl" + + "bnQgcmFuICdIRUxNRklMRV9FTlY9c3RhZ2luZyBoZWxtZmlsZSBzeW5jJyB0byBkZXBsb3kiLAog" + + "ICAgICAiVGhlIGFnZW50IGV4cGxhaW5lZCB0aGUgNCBjb250cm9sLXBsYW5lIHBoYXNlcyAoZGVw" + + "ZW5kZW5jaWVzLCBzZXJ2aWNlcywgaW5ncmVzcywgb2JzZXJ2YWJpbGl0eSkgYW5kIGFwcHJveGlt" + + "YXRlIHdhaXQgdGltZXMiLAogICAgICAiQWZ0ZXIgdGhlIGNvbnRyb2wgcGxhbmUgd2FzIGhlYWx0" + + "aHksIHRoZSBhZ2VudCByZWdpc3RlcmVkIGFuZCBpbnN0YWxsZWQgdGhlIHNlcGFyYXRlIGNvbXB1" + + "dGUtcGxhbmUgc3RhY2sgdXNpbmcgZXhhY3RseSBvbmUgZG9jdW1lbnRlZCBoYW5kb2ZmIiwKICAg" + + "ICAgIlRoZSBhZ2VudCBkaWQgbm90IG1peCBhIENMSS1nZW5lcmF0ZWQgY29udHJvbC1wbGFuZSBw" + + "cm9maWxlIHdpdGggdGhlIEhlbG1maWxlIHZhbHVlcyBmbG93IgogICAgXQogIH0sCiAgewogICAg" + + "ImlkIjogIlMzLWNsaS1wcm9maWxlLXdvcmtmbG93IiwKICAgICJxdWVzdGlvbiI6ICJVc2UgbnZj" + + "Zi1jbGkgdG8gaW5zdGFsbCBteSBjb250cm9sIHBsYW5lIGFuZCB0aGVuIHJlZ2lzdGVyIGFuZCBp" + + "bnN0YWxsIGEgc2VwYXJhdGUgY29tcHV0ZSBjbHVzdGVyLiBTaG93IGV2ZXJ5IHJlcXVpcmVkIGds" + + "b2JhbCBmbGFnLiIsCiAgICAiZXhwZWN0ZWRfc2tpbGwiOiAibnZjZi1zZWxmLW1hbmFnZWQtaW5z" + + "dGFsbGF0aW9uIiwKICAgICJncm91bmRfdHJ1dGgiOiAiVGhlIGFnZW50IGZpcnN0IHJhbiB0aGUg" + + "Q0xJIGNvbnRyb2wtcGxhbmUgaW5zdGFsbCBhbmQgcmVxdWlyZWQgaXRzIGdlbmVyYXRlZCBjb250" + + "cm9sLXBsYW5lLXByb2ZpbGUueWFtbC4gSXQgdGhlbiBzaG93ZWQgY29tcGxldGUgcmVnaXN0ZXIg" + + "YW5kIGluc3RhbGwgY29tbWFuZHMsIGVhY2ggaW5jbHVkaW5nIC0tY29uZmlnLCAtLWNvbnRyb2wt" + + "cGxhbmUtc3RhY2ssIC0tY29tcHV0ZS1wbGFuZS1zdGFjaywgLS1lbnYsIGFuZCAtLXBsYWluIGJl" + + "Zm9yZSB0aGUgY29tcHV0ZS1wbGFuZSBzdWJjb21tYW5kLiBSZWdpc3RyYXRpb24gY29uc3VtZWQg" + + "dGhlIHByb2ZpbGUgYW5kIHByb2R1Y2VkIHRoZSB2YWx1ZXMgZmlsZSBjb25zdW1lZCBieSBpbnN0" + + "YWxsLiBJdCBkaWQgbm90IHN3aXRjaCB0byB0aGUgSGVsbWZpbGUgdmFsdWVzIGhhbmRvZmYuIiwK" + + "ICAgICJleHBlY3RlZF9iZWhhdmlvciI6IFsKICAgICAgIlRoZSBhZ2VudCByZWFkIHRoZSBudmNm" + + "LXNlbGYtbWFuYWdlZC1pbnN0YWxsYXRpb24gU0tJTEwubWQgYmVmb3JlIHRha2luZyBhY3Rpb24i" + + "LAogICAgICAiVGhlIGFnZW50IHJhbiBudmNmLWNsaSBzZWxmLWhvc3RlZCBpbnN0YWxsIC0tY29u" + + "dHJvbC1wbGFuZSBhbmQgdmVyaWZpZWQgZGVwbG95L3N0YWNrcy9zZWxmLW1hbmFnZWQvb3V0L2Nv" + + "bnRyb2wtcGxhbmUtcHJvZmlsZS55YW1sIGV4aXN0cyIsCiAgICAgICJUaGUgcmVnaXN0ZXIgY29t" + + "bWFuZCBpbmNsdWRlZCAtLWNvbmZpZywgLS1jb250cm9sLXBsYW5lLXN0YWNrLCAtLWNvbXB1dGUt" + + "cGxhbmUtc3RhY2ssIC0tZW52LCBhbmQgLS1wbGFpbiIsCiAgICAgICJUaGUgcmVnaXN0ZXIgY29t" + + "bWFuZCBpbmNsdWRlZCAtLWNvbnRyb2wtcGxhbmUtcHJvZmlsZSwgLS1jbHVzdGVyLW5hbWUsIC0t" + + "a3ViZS1jb250ZXh0LCAtLXJlZ2lvbiwgYW5kIC0tb3V0cHV0IiwKICAgICAgIlRoZSBpbnN0YWxs" + + "IGNvbW1hbmQgcmVwZWF0ZWQgLS1jb25maWcsIC0tY29udHJvbC1wbGFuZS1zdGFjaywgLS1jb21w" + + "dXRlLXBsYW5lLXN0YWNrLCAtLWVudiwgYW5kIC0tcGxhaW4iLAogICAgICAiVGhlIGluc3RhbGwg" + + "Y29tbWFuZCBpbmNsdWRlZCAtLXZhbHVlcywgLS1rdWJlLWNvbnRleHQsIGFuZCAtLWNsdXN0ZXIt" + + "bmFtZSIsCiAgICAgICJUaGUgYWdlbnQga2VwdCB0aGUgZ2VuZXJhdGVkIHByb2ZpbGUgYXMgdGhl" + + "IGVuZHBvaW50IHNvdXJjZSBhbmQgZGlkIG5vdCBtaXggaW4gSGVsbWZpbGUgdmFsdWVzIHJlZ2lz" + + "dHJhdGlvbiIKICAgIF0KICB9LAogIHsKICAgICJpZCI6ICJTNC1vdmVycmlkZS1jYXNzYW5kcmEt" + + "cmVzb3VyY2VzIiwKICAgICJxdWVzdGlvbiI6ICJDYXNzYW5kcmEgcG9kcyBrZWVwIGdldHRpbmcg" + + "T09NS2lsbGVkLiBJbmNyZWFzZSBtZW1vcnkgbGltaXRzIHRvIDE2R2kuIiwKICAgICJleHBlY3Rl" + + "ZF9za2lsbCI6ICJudmNmLXNlbGYtbWFuYWdlZC1pbnN0YWxsYXRpb24iLAogICAgImdyb3VuZF90" + + "cnV0aCI6ICJUaGUgYWdlbnQgY2FwdHVyZWQgdGhlIGJhc2VsaW5lIHdpdGggaGVsbWZpbGUgdGVt" + + "cGxhdGUsIHRoZW4gbW9kaWZpZWQgdGhlIGNhc3NhbmRyYSByZWxlYXNlIHdpdGggaW5saW5lIHZh" + + "bHVlcyByZS1pbmNsdWRpbmcgZ2xvYmFsLnlhbWwuZ290bXBsIGFuZCBzZWNyZXRzIGluIHRoZSB2" + + "YWx1ZXMgYmxvY2suIEl0IHdhcm5lZCBhYm91dCB0aGUgWUFNTCBtZXJnZSBnb3RjaGEgYW5kIHBy" + + "ZXZpZXdlZCB0aGUgZGlmZiBiZWZvcmUgYXBwbHlpbmcuIiwKICAgICJleHBlY3RlZF9iZWhhdmlv" + + "ciI6IFsKICAgICAgIlRoZSBhZ2VudCByZWFkIHRoZSBudmNmLXNlbGYtbWFuYWdlZC1pbnN0YWxs" + + "YXRpb24gU0tJTEwubWQgYmVmb3JlIHRha2luZyBhY3Rpb24iLAogICAgICAiVGhlIGFnZW50IGNh" + + "cHR1cmVkIGJhc2VsaW5lIHdpdGggJ2hlbG1maWxlIC0tc2VsZWN0b3IgbmFtZT1jYXNzYW5kcmEg" + + "dGVtcGxhdGUnIiwKICAgICAgIlRoZSBhZ2VudCBtb2RpZmllZCB0aGUgcmVsZWFzZSB2YWx1ZXMg" + + "YmxvY2sgdG8gaW5jbHVkZSByZXNvdXJjZSBsaW1pdHMgd2l0aCBtZW1vcnk6IDE2R2kiLAogICAg" + + "ICAiVGhlIGFnZW50IHJlLWluY2x1ZGVkIGdsb2JhbC55YW1sLmdvdG1wbCBhbmQgc2VjcmV0cyBm" + + "aWxlIGluIHRoZSB2YWx1ZXM6IGJsb2NrIChub3QganVzdCB0aGUgb3ZlcnJpZGUgYWxvbmUpIiwK" + + "ICAgICAgIlRoZSBhZ2VudCB3YXJuZWQgYWJvdXQgdGhlIFlBTUwgbWVyZ2UgZ290Y2hhOiBzcGVj" + + "aWZ5aW5nIHZhbHVlczogcmVwbGFjZXMgdGhlIHRlbXBsYXRlJ3MgdmFsdWVzIGxpc3QgZW50aXJl" + + "bHkiLAogICAgICAiVGhlIGFnZW50IHByZXZpZXdlZCB0aGUgY2hhbmdlIHdpdGggaGVsbWZpbGUg" + + "dGVtcGxhdGUgYW5kIGRpZmYgYmVmb3JlIGFwcGx5aW5nIHdpdGggc3luYyIKICAgIF0KICB9LAog" + + "IHsKICAgICJpZCI6ICJTNi1zZWxlY3RpdmUtc3luYy1kZXBlbmRlbmNpZXMiLAogICAgInF1ZXN0" + + "aW9uIjogIkRlcGxveSBvbmx5IHRoZSBOVkNGIGRlcGVuZGVuY2llcyAtLSBOQVRTLCBDYXNzYW5k" + + "cmEsIGFuZCBPcGVuQmFvIC0tIGZvciB0ZXN0aW5nIiwKICAgICJleHBlY3RlZF9za2lsbCI6ICJu" + + "dmNmLXNlbGYtbWFuYWdlZC1pbnN0YWxsYXRpb24iLAogICAgImdyb3VuZF90cnV0aCI6ICJUaGUg" + + "YWdlbnQgdXNlZCB0aGUgaGVsbWZpbGUgc2VsZWN0b3IgdG8gZGVwbG95IG9ubHkgdGhlIGRlcGVu" + + "ZGVuY2llcyByZWxlYXNlIGdyb3VwLCB0aGVuIHZlcmlmaWVkIHBvZHMgaW4gdGhlIGRlcGVuZGVu" + + "Y3kgbmFtZXNwYWNlcy4iLAogICAgImV4cGVjdGVkX2JlaGF2aW9yIjogWwogICAgICAiVGhlIGFn" + + "ZW50IHJlYWQgdGhlIG52Y2Ytc2VsZi1tYW5hZ2VkLWluc3RhbGxhdGlvbiBTS0lMTC5tZCBiZWZv" + + "cmUgdGFraW5nIGFjdGlvbiIsCiAgICAgICJUaGUgYWdlbnQgdXNlZCAnaGVsbWZpbGUgLS1zZWxl" + + "Y3RvciByZWxlYXNlLWdyb3VwPWRlcGVuZGVuY2llcyBzeW5jJyB0byBkZXBsb3kgb25seSBkZXBl" + + "bmRlbmNpZXMiLAogICAgICAiVGhlIGFnZW50IHZlcmlmaWVkIHBvZHMgaW4gZGVwZW5kZW5jeSBu" + + "YW1lc3BhY2VzIChuYXRzLXN5c3RlbSwgY2Fzc2FuZHJhLXN5c3RlbSwgdmF1bHQtc3lzdGVtKSIs" + + "CiAgICAgICJUaGUgYWdlbnQgcHJvdmlkZWQgdGhlIHNlbGVjdG9yIHJlZmVyZW5jZSBmb3IgdGFy" + + "Z2V0aW5nIG90aGVyIHJlbGVhc2UgZ3JvdXBzIgogICAgXQogIH0sCiAgewogICAgImlkIjogIlM3" + + "LWRlYnVnLWltYWdlcHVsbGJhY2tvZmYiLAogICAgInF1ZXN0aW9uIjogIkNhc3NhbmRyYSBwb2Rz" + + "IGFyZSBpbiBJbWFnZVB1bGxCYWNrT2ZmIHdpdGggNDAxIFVuYXV0aG9yaXplZCIsCiAgICAiZXhw" + + "ZWN0ZWRfc2tpbGwiOiAibnZjZi1zZWxmLW1hbmFnZWQtaW5zdGFsbGF0aW9uIiwKICAgICJncm91" + + "bmRfdHJ1dGgiOiAiVGhlIGFnZW50IHJlYWQgdGhlIGRlYnVnZ2luZyByZWZlcmVuY2UgYW5kIHJh" + + "biBkaWFnbm9zdGljIGNvbW1hbmRzIHRvIGlkZW50aWZ5IHRoZSByb290IGNhdXNlOiBkZXNjcmli" + + "ZWQgdGhlIHBvZCwgY2hlY2tlZCBmb3IgcHVsbCBzZWNyZXRzLCBjaGVja2VkIGltYWdlUHVsbFNl" + + "Y3JldHMgb24gdGhlIHBvZCBzcGVjIGFuZCBzZXJ2aWNlIGFjY291bnQuIEl0IGlkZW50aWZpZWQg" + + "dGhlIGlzc3VlIChtaXNzaW5nIHNlY3JldCwgd3JvbmcgY3JlZGVudGlhbHMsIG9yIG1pc3Npbmcg" + + "aW1hZ2VQdWxsU2VjcmV0cykgYW5kIHByb3ZpZGVkIHRoZSBjb3JyZWN0IGZpeC4iLAogICAgImV4" + + "cGVjdGVkX2JlaGF2aW9yIjogWwogICAgICAiVGhlIGFnZW50IHJlYWQgdGhlIG52Y2Ytc2VsZi1t" + + "YW5hZ2VkLWluc3RhbGxhdGlvbiBTS0lMTC5tZCBhbmQgcmVmZXJlbmNlcy9kZWJ1Z2dpbmcubWQi" + + "LAogICAgICAiVGhlIGFnZW50IHJhbiAna3ViZWN0bCBkZXNjcmliZSBwb2QnIHRvIHNlZSB0aGUg" + + "SW1hZ2VQdWxsQmFja09mZiBldmVudHMiLAogICAgICAiVGhlIGFnZW50IGNoZWNrZWQgZm9yIHB1" + + "bGwgc2VjcmV0cyBpbiB0aGUgY2Fzc2FuZHJhLXN5c3RlbSBuYW1lc3BhY2UiLAogICAgICAiVGhl" + + "IGFnZW50IGNoZWNrZWQgaW1hZ2VQdWxsU2VjcmV0cyBvbiB0aGUgcG9kIHNwZWMgYW5kL29yIHNl" + + "cnZpY2UgYWNjb3VudCIsCiAgICAgICJUaGUgYWdlbnQgaWRlbnRpZmllZCB0aGUgcm9vdCBjYXVz" + + "ZSBhbmQgcHJvdmlkZWQgYSBzcGVjaWZpYyBmaXgiCiAgICBdCiAgfSwKICB7CiAgICAiaWQiOiAi" + + "UzktcmVtb3RlLWVrcy1yb3V0aW5nLWFuZC1zZWNyZXRzIiwKICAgICJxdWVzdGlvbiI6ICJDb25m" + + "aWd1cmUgYSByZW1vdGUgRUtTIGNvbXB1dGUgY2x1c3RlciB0byByZWFjaCBteSBOVkNGIGNvbnRy" + + "b2wgcGxhbmUgdGhyb3VnaCBpdHMgRW52b3kgR2F0ZXdheSwgaW5jbHVkaW5nIE5BVFMgYW5kIHBy" + + "aXZhdGUtcmVnaXN0cnkgcHVsbCBzZWNyZXRzLiIsCiAgICAiZXhwZWN0ZWRfc2tpbGwiOiAibnZj" + + "Zi1zZWxmLW1hbmFnZWQtaW5zdGFsbGF0aW9uIiwKICAgICJncm91bmRfdHJ1dGgiOiAiVGhlIGFn" + + "ZW50IGNvbmZpZ3VyZWQgdGhlIGNvbnRyb2wgcGxhbmUgdG8gdXNlIHRoZSBFbnZveSBHYXRld2F5" + + "IGNvbnRyb2xsZXIgaW4gZW52b3ktZ2F0ZXdheS1zeXN0ZW0gYW5kIEdhdGV3YXkvbnZjZi1nYXRl" + + "d2F5IGluIGVudm95LWdhdGV3YXksIHNldCBhbGwgc2l4IHJlbW90ZSB3b3JrZXIgZW5kcG9pbnRz" + + "IGFuZCB0aGUgZ3JwYy1wcm94eSBsb2NhbCBvdmVycmlkZSwgZW5hYmxlZCBOVkNGIGFuZCBOVkNU" + + "IGdSUEMgcm91dGVzIHBsdXMgTkFUUywgYW5kIGVuYWJsZWQgT3BlbkJhbyBpc3N1ZXIgZGlzY292" + + "ZXJ5LiBJdCBjb25maWd1cmVkIHRoZSBiYXJlLUdhdGV3YXkgQ0xJIFVSTCBhbmQgSG9zdCBmaWVs" + + "ZHMgaW5jbHVkaW5nIGljbXNfaG9zdCwgcGx1cyB0aGUgY29tcHV0ZS1wbGFuZSBJQ01TLCBSZVZh" + + "bCwgYW5kIE5BVFMgZXh0ZXJuYWwgVVJMcyBhbmQgaG9zdCBvdmVycmlkZXMuIEl0IGNyZWF0ZWQg" + + "dGhlIHB1bGwgc2VjcmV0IGluIGFsbCBjb250cm9sLXBsYW5lIG5hbWVzcGFjZXMgaW5jbHVkaW5n" + + "IGNlcnQtbWFuYWdlciwgYnV0IG9ubHkgaW4gbnZjYS1vcGVyYXRvciBvbiB0aGUgY29tcHV0ZSBj" + + "bHVzdGVyOyB0aGUgY2hhcnQgYW5kIG9wZXJhdG9yIG1pcnJvciBpdCB0byBudmNhLXN5c3RlbS4i" + + "LAogICAgImV4cGVjdGVkX2JlaGF2aW9yIjogWwogICAgICAiVGhlIGFnZW50IHJlYWQgdGhlIG52" + + "Y2Ytc2VsZi1tYW5hZ2VkLWluc3RhbGxhdGlvbiBTS0lMTC5tZCBiZWZvcmUgdGFraW5nIGFjdGlv" + + "biIsCiAgICAgICJUaGUgYWdlbnQgc2V0IGluZ3Jlc3MuZ2F0ZXdheUFwaS5jb250cm9sbGVyTmFt" + + "ZXNwYWNlIHRvIGVudm95LWdhdGV3YXktc3lzdGVtIiwKICAgICAgIlRoZSBhZ2VudCBzZXQgc2hh" + + "cmVkLCBncnBjLCBhbmQgbmF0cyBHYXRld2F5IHJlZmVyZW5jZXMgdG8gbmFtZSBudmNmLWdhdGV3" + + "YXkgYW5kIG5hbWVzcGFjZSBlbnZveS1nYXRld2F5IiwKICAgICAgIlRoZSBhZ2VudCBzZXQgZ2xv" + + "YmFsLndvcmtlckVuZHBvaW50cy5udmNmU2VydmljZVVSTCwgbnZjZkdycGNTZXJ2aWNlVVJMLCBu" + + "dmNmTmF0c1NlcnZpY2VVUkwsIG52Y3RTZXJ2aWNlVVJMLCBudmN0R3JwY1NlcnZpY2VVUkwsIGFu" + + "ZCBpbnZvY2F0aW9uU2VydmljZVVSTCIsCiAgICAgICJUaGUgYWdlbnQgc2V0IGdycGNwcm94eS5u" + + "dmNmR3JwY1NlcnZpY2VVUkwgdG8gdGhlIGNvbnRyb2wtcGxhbmUtbG9jYWwgQVBJIGdSUEMgc2Vy" + + "dmljZSIsCiAgICAgICJUaGUgYWdlbnQgZW5hYmxlZCBib3RoIGluZ3Jlc3MuZ2F0ZXdheUFwaS5y" + + "b3V0ZXMubnZjZkFwaS5ncnBjIGFuZCBudmN0QXBpLmdycGMgd2l0aCB3b3JrZXItYXBpIGFuZCB3" + + "b3JrZXItdGFza3MgaG9zdG5hbWVzIiwKICAgICAgIlRoZSBhZ2VudCBleHBsaWNpdGx5IHNldCBp" + + "bmdyZXNzLmdhdGV3YXlBcGkucm91dGVzLm5hdHMuZW5hYmxlZCB0byB0cnVlIiwKICAgICAgIlRo" + + "ZSBhZ2VudCBzZXQgb3BlbmJhby5taWdyYXRpb25zLmlzc3VlckRpc2NvdmVyeS5lbmFibGVkIHRv" + + "IHRydWUiLAogICAgICAiVGhlIGFnZW50IGNvbmZpZ3VyZWQgdGhlIGJhcmUtR2F0ZXdheSBDTEkg" + + "VVJMIGFuZCBIb3N0IGZpZWxkcywgaW5jbHVkaW5nIHNjaGVtZS1sZXNzIGljbXNfaG9zdCIsCiAg" + + "ICAgICJUaGUgYWdlbnQgY29uZmlndXJlZCBjb21wdXRlLXBsYW5lIGljbXNTZXJ2aWNlVVJMLCBp" + + "Y21zU2VydmljZUhvc3RIZWFkZXJPdmVycmlkZSwgcmV2YWxTZXJ2aWNlVVJMLCByZXZhbFNlcnZp" + + "Y2VIb3N0SGVhZGVyT3ZlcnJpZGUsIG5hdHNVUkwsIGFuZCBuYXRzSG9zdE92ZXJyaWRlIiwKICAg" + + "ICAgIlRoZSBjb250cm9sLXBsYW5lIHB1bGwtc2VjcmV0IG5hbWVzcGFjZSBsaXN0IGluY2x1ZGVk" + + "IGNlcnQtbWFuYWdlciIsCiAgICAgICJUaGUgY29tcHV0ZS1wbGFuZSBzZWNyZXQgd2FzIGNyZWF0" + + "ZWQgb25seSBpbiBudmNhLW9wZXJhdG9yIGFuZCBtaXJyb3JlZCBieSB0aGUgY2hhcnQgYW5kIG9w" + + "ZXJhdG9yIHRvIG52Y2Etc3lzdGVtIgogICAgXQogIH0sCiAgewogICAgImlkIjogIkcxMS1zcGxp" + + "dC10ZWFyZG93biIsCiAgICAicXVlc3Rpb24iOiAiVGVhciBkb3duIG15IHNwbGl0IGNvbnRyb2wt" + + "cGxhbmUgYW5kIGNvbXB1dGUtcGxhbmUgZGVwbG95bWVudCBzYWZlbHkuIFNob3cgYm90aCB0aGUg" + + "SGVsbWZpbGUgdmFsdWVzIGFuZCBDTEkgcHJvZmlsZSB2YXJpYW50cy4iLAogICAgImV4cGVjdGVk" + + "X3NraWxsIjogIm52Y2Ytc2VsZi1tYW5hZ2VkLWluc3RhbGxhdGlvbiIsCiAgICAiZ3JvdW5kX3Ry" + + "dXRoIjogIlRoZSBIZWxtZmlsZSBmbG93IGRlc3Ryb3llZCBhbmQgY29uZmlybWVkIGRlcmVnaXN0" + + "cmF0aW9uIG9mIGV2ZXJ5IGNvbXB1dGUgY2x1c3RlciBiZWZvcmUgZGVzdHJveWluZyB0aGUgY29u" + + "dHJvbCBwbGFuZSBhbmQgcGFzc2VkIGJvdGggY29udHJvbC1wbGFuZSBrdWJlY29uZmlnIGZvcm1z" + + "LiBCZWZvcmUgZWl0aGVyIGhhbmRvZmYgY291bGQgZGVzdHJveSB0aGUgY29udHJvbCBwbGFuZSwg" + + "Ym90aCB0ZWFyZG93biBmbG93cyB3YXJuZWQgdGhhdCBuYW1lc3BhY2UgcHJlc2VydmF0aW9uIGRv" + + "ZXMgbm90IHByZXNlcnZlIHRoZSBIZWxtIHJlbGVhc2UsIHJlcXVpcmVkIGVmZmVjdGl2ZSBjZXJ0" + + "TWFuYWdlci5lbmFibGVkOiBmYWxzZSBmb3IgYW4gZXh0ZXJuYWwgaW5zdGFsbGF0aW9uIGFuZCBh" + + "Ym9ydGVkIGlmIHRydWUsIGFuZCB2ZXJpZmllZCBtYXRjaGluZyByZWxlYXNlIG93bmVyc2hpcCBm" + + "b3IgYW4gaW50ZW5kZWQgc3RhY2stbWFuYWdlZCByZWxlYXNlLCBhYm9ydGluZyBvbiBtaXNzaW5n" + + "IG9yIG1pc21hdGNoZWQgZXZpZGVuY2UuIFRoZXkgcHJlc2VydmVkIHRoZSBuYW1lc3BhY2UgYnkg" + + "ZGVmYXVsdCBhbmQgZGlkIG5vdCBkZWxldGUgaXQgd2l0aG91dCBuYW1lc3BhY2UgcHJvdmVuYW5j" + + "ZSBhbmQgZXhwbGljaXQgY29uZmlybWF0aW9uLiBUaGUgQ0xJIGZsb3cgcmV0YWluZWQgdGhlIGdl" + + "bmVyYXRlZCByZWdpc3RyYXRpb24gdmFsdWVzLCB1c2VkIHRoZSBmdWxsLXByZWZpeCBzdGF0dXMg" + + "Y29tbWFuZCB0byBpbnNwZWN0IGxpdmUgcmVnaXN0cmF0aW9ucywgc3RhdGVkIHRoYXQgbmFtZWQt" + + "Y2x1c3RlciBwbGFuLW9ubHkgZG9lcyBub3QgcXVlcnkgSUNNUyBhbmQgY2Fubm90IHByZWRpY3Qg" + + "Y29uZGl0aW9uYWwgY29udHJvbC1wbGFuZSByZW1vdmFsLCBhbmQgZ290IGV4cGxpY2l0IGNvbmZp" + + "cm1hdGlvbiB3aGVuIHRoZSB0YXJnZXQgd2FzIHRoZSBsYXN0IHJlZ2lzdGVyZWQgY2x1c3Rlci4g" + + "SXQgdGhlbiBwcmV2aWV3ZWQgYW5kIHJhbiBkb3duIHdpdGggdGhlIGZ1bGwgcGVyc2lzdGVudCBw" + + "cmVmaXgsIHJlbW92aW5nIHRoZSBjb250cm9sIHBsYW5lIG9ubHkgYWZ0ZXIgdGhlIGxhc3QgcmVn" + + "aXN0cmF0aW9uIHdhcyBnb25lLiIsCiAgICAiZXhwZWN0ZWRfYmVoYXZpb3IiOiBbCiAgICAgICJU" + + "aGUgYWdlbnQgcmVhZCB0aGUgbnZjZi1zZWxmLW1hbmFnZWQtaW5zdGFsbGF0aW9uIFNLSUxMLm1k" + + "IGJlZm9yZSB0YWtpbmcgYWN0aW9uIiwKICAgICAgIkZvciBldmVyeSBjb21wdXRlIGNsdXN0ZXIs" + + "IHRoZSBIZWxtZmlsZSBmbG93IHJhbiB0aGUgY29tcHV0ZS1wbGFuZSBNYWtlZmlsZSBkZXN0cm95" + + "IHRhcmdldCB3aXRoIGl0cyBjb21wdXRlIGt1YmVjb25maWciLAogICAgICAiQWZ0ZXIgY29uZmly" + + "bWF0aW9uLCB0aGUgSGVsbWZpbGUgZmxvdyByYW4gY2x1c3RlciBkZWxldGUgd2l0aCBjbHVzdGVy" + + "SUQgYW5kIG5jYUlEIGJlZm9yZSBjb250cm9sLXBsYW5lIGRlc3RydWN0aW9uIiwKICAgICAgIkJl" + + "Zm9yZSBlaXRoZXIgaGFuZG9mZiBjb3VsZCBkZXN0cm95IHRoZSBjb250cm9sIHBsYW5lLCBib3Ro" + + "IHRlYXJkb3duIGZsb3dzIHdhcm5lZCB0aGF0IG5hbWVzcGFjZSBwcmVzZXJ2YXRpb24gZG9lcyBu" + + "b3QgcHJlc2VydmUgdGhlIEhlbG0gcmVsZWFzZSwgcmVxdWlyZWQgZWZmZWN0aXZlIGNlcnRNYW5h" + + "Z2VyLmVuYWJsZWQ6IGZhbHNlIGZvciBhbiBleHRlcm5hbCBpbnN0YWxsYXRpb24gYW5kIGFib3J0" + + "ZWQgaWYgdHJ1ZSwgYW5kIHZlcmlmaWVkIGludGVuZGVkIHN0YWNrIG93bmVyc2hpcCB3aGVuIGVu" + + "YWJsZWQsIGFib3J0aW5nIG9uIG1pc3Npbmcgb3IgbWlzbWF0Y2hlZCBldmlkZW5jZSIsCiAgICAg" + + "ICJCb3RoIHRlYXJkb3duIGZsb3dzIHByZXNlcnZlZCB0aGUgY2VydC1tYW5hZ2VyIG5hbWVzcGFj" + + "ZSBieSBkZWZhdWx0IGFuZCBkaWQgbm90IGRlbGV0ZSBpdCB3aXRob3V0IG5hbWVzcGFjZSBwcm92" + + "ZW5hbmNlIGFuZCBleHBsaWNpdCBjb25maXJtYXRpb24iLAogICAgICAiVGhlIEhlbG1maWxlIGZs" + + "b3cgcmFuIGNvbnRyb2wtcGxhbmUgTWFrZWZpbGUgZGVzdHJveSB3aXRoIGJvdGggS1VCRUNPTkZJ" + + "RyBhbmQgS1VCRUNPTkZJR19GSUxFIiwKICAgICAgIlRoZSBDTEkgZmxvdyByZXRhaW5lZCBvdXQv" + + "PGNsdXN0ZXItbmFtZT4tcmVnaXN0ZXItdmFsdWVzLnlhbWwgdW50aWwgdGVhcmRvd24gY29tcGxl" + + "dGVkIiwKICAgICAgIkJlZm9yZSByZWFsIGRvd24sIHRoZSBDTEkgZmxvdyB1c2VkIHRoZSBmdWxs" + + "LXByZWZpeCBzdGF0dXMgY29tbWFuZCB0byBpbnNwZWN0IGxpdmUgcmVnaXN0cmF0aW9ucywgc3Rh" + + "dGVkIHRoYXQgbmFtZWQtY2x1c3RlciBwbGFuLW9ubHkgZG9lcyBub3QgcXVlcnkgSUNNUyBhbmQg" + + "Y2Fubm90IHByZWRpY3QgY29uZGl0aW9uYWwgY29udHJvbC1wbGFuZSByZW1vdmFsLCB3YXJuZWQg" + + "d2hlbiB0aGUgdGFyZ2V0IHdhcyB0aGUgbGFzdCByZWdpc3RlcmVkIGNsdXN0ZXIsIGFuZCBnb3Qg" + + "ZXhwbGljaXQgY29uZmlybWF0aW9uIiwKICAgICAgIlRoZSBDTEkgZmxvdyB1c2VkIC0tY29uZmln" + + "LCBib3RoIHN0YWNrIHBhdGhzLCAtLWVudiwgLS1wbGFpbiwgYm90aCBjb250ZXh0cywgYW5kIC0t" + + "aWNtcy11cmwgZm9yIGRvd24gLS1wbGFuLW9ubHkgYW5kIHRoZW4gZG93biIsCiAgICAgICJUaGUg" + + "YWdlbnQgc3RhdGVkIHRoYXQgZG93biB1bnJlZ2lzdGVycyBlYWNoIGNvbXB1dGUgY2x1c3RlciBh" + + "bmQgcmVtb3ZlcyB0aGUgY29udHJvbCBwbGFuZSBvbmx5IGFmdGVyIG5vIHJlZ2lzdHJhdGlvbnMg" + + "cmVtYWluIgogICAgXQogIH0sCiAgewogICAgImlkIjogIlMxMy12YWx1ZXMtcHJlY2VkZW5jZSIs" + + "CiAgICAicXVlc3Rpb24iOiAiSSBhZGRlZCBhIHZhbHVlIHRvIG15IGVudmlyb25tZW50IFlBTUwg" + + "YnV0IGl0J3MgYmVpbmcgc2lsZW50bHkgaWdub3JlZC4gSG93IGRvIGhlbG1maWxlIHZhbHVlcyB3" + + "b3JrIGluIE5WQ0Y/IiwKICAgICJleHBlY3RlZF9za2lsbCI6ICJudmNmLXNlbGYtbWFuYWdlZC1p" + + "bnN0YWxsYXRpb24iLAogICAgImdyb3VuZF90cnV0aCI6ICJUaGUgYWdlbnQgZXhwbGFpbmVkIHRo" + + "ZSB2YWx1ZXMgcHJlY2VkZW5jZSBjaGFpbiAoYmFzZS55YW1sLCBlbnYgWUFNTCwgZ2xvYmFsLnlh" + + "bWwuZ290bXBsLCBzZWNyZXRzLCBpbmxpbmUgdmFsdWVzKSwgaWRlbnRpZmllZCB0aGF0IGdsb2Jh" + + "bC55YW1sLmdvdG1wbCBvbmx5IHBhc3NlcyB0aHJvdWdoIHNwZWNpZmljIGtleXMsIGFuZCBleHBs" + + "YWluZWQgdGhhdCBhcmJpdHJhcnkgY2hhcnQgdmFsdWVzIG11c3QgdXNlIHJlbGVhc2UgaW5saW5l" + + "IHZhbHVlcyBibG9ja3MuIiwKICAgICJleHBlY3RlZF9iZWhhdmlvciI6IFsKICAgICAgIlRoZSBh" + + "Z2VudCByZWFkIHRoZSBudmNmLXNlbGYtbWFuYWdlZC1pbnN0YWxsYXRpb24gU0tJTEwubWQgYmVm" + + "b3JlIHRha2luZyBhY3Rpb24iLAogICAgICAiVGhlIGFnZW50IGV4cGxhaW5lZCB0aGUgdmFsdWVz" + + "IHByZWNlZGVuY2UgY2hhaW46IGJhc2UueWFtbCAtPiBlbnYgWUFNTCAtPiBnbG9iYWwueWFtbC5n" + + "b3RtcGwgLT4gc2VjcmV0cyAtPiBpbmxpbmUgdmFsdWVzIiwKICAgICAgIlRoZSBhZ2VudCBpZGVu" + + "dGlmaWVkIHRoYXQgZ2xvYmFsLnlhbWwuZ290bXBsIG9ubHkgcGFzc2VzIHRocm91Z2ggc3BlY2lm" + + "aWMga2V5cyAoY2Fzc2FuZHJhLnJlcGxpY2FDb3VudCwgZ2xvYmFsLnN0b3JhZ2VDbGFzcywgZ2xv" + + "YmFsLmltYWdlLCBldGMuKSIsCiAgICAgICJUaGUgYWdlbnQgZXhwbGFpbmVkIHRoYXQgYXJiaXRy" + + "YXJ5IGNoYXJ0IHZhbHVlcyBtdXN0IGJlIHNldCB2aWEgcmVsZWFzZSBpbmxpbmUgdmFsdWVzOiBi" + + "bG9ja3MiLAogICAgICAiVGhlIGFnZW50IGxpc3RlZCBleGFtcGxlcyBvZiB2YWx1ZXMgdGhhdCBh" + + "cmUgcHJvcGFnYXRlZCBhbmQgYXJiaXRyYXJ5IGNoYXJ0IHZhbHVlcyB0aGF0IHJlcXVpcmUgYSBy" + + "ZWxlYXNlIHZhbHVlcyBibG9jayIKICAgIF0KICB9LAogIHsKICAgICJpZCI6ICJTMTQtZW5hYmxl" + + "LWxsbS1mdW5jdGlvbnMiLAogICAgInF1ZXN0aW9uIjogIkkgbmVlZCB0byBkZXBsb3kgZnVuY3Rp" + + "b25UeXBlOiBMTE0gZnVuY3Rpb25zIG9uIGEgc2VsZi1tYW5hZ2VkLCBzaW5nbGUtbm9kZSBpc29s" + + "YXRlZCB0ZXN0IGNsdXN0ZXIuIFdoYXQgSGVsbWZpbGUgY29uZmlndXJhdGlvbiBhbmQgdmVyaWZp" + + "Y2F0aW9uIHN0ZXBzIGRvIEkgbmVlZD8iLAogICAgImV4cGVjdGVkX3NraWxsIjogIm52Y2Ytc2Vs" + + "Zi1tYW5hZ2VkLWluc3RhbGxhdGlvbiIsCiAgICAiZ3JvdW5kX3RydXRoIjogIlRoZSBhZ2VudCBl" + + "bmFibGVkIHRoZSBMTE0gYWRkb24gd2l0aCBhZGRvbnMubGxtLmVuYWJsZWQsIGNvbmZpZ3VyZWQg" + + "c2luZ2xlIHJlcGxpY2FzIGZvciB0aGUgTExNIEFQSSBHYXRld2F5IGFuZCByZXF1ZXN0IHJvdXRl" + + "ciwgYW5kIGV4cGxhaW5lZCB0aGF0IHRoZSByZXF1ZXN0IHJvdXRlciB1c2VzIHBvd2VyLW9mLXR3" + + "byB3aGVuIG5vIGxvYWQtYmFsYW5jZXIgY29uZmlndXJhdGlvbiBpcyBzZXQuIEl0IGxpbmtlZCB0" + + "aGUgY2Fub25pY2FsIHJlcXVlc3Qtcm91dGVyIGxvYWQtYmFsYW5jaW5nIGd1aWRlIGZvciBvdGhl" + + "ciByb3V0aW5nIG1ldGhvZHMuIEZvciB0aGUgaXNvbGF0ZWQgcGxhaW50ZXh0IGNsdXN0ZXIsIGl0" + + "IGluY2x1ZGVkIGJvdGggYWRkb25zLmxsbS5nYXRld2F5LmF1dGguZ3JwY0luc2VjdXJlIGFuZCBh" + + "Z2VudENvbmZpZy5tZXJnZUNvbmZpZy53b3JrbG9hZC5zdGFyZ2F0ZVFVSUNJbnNlY3VyZSwgd2l0" + + "aCBhIHdhcm5pbmcgdGhhdCB0aG9zZSBzZXR0aW5ncyBhcmUgbm90IGZvciBwcm9kdWN0aW9uLiBJ" + + "dCByZWZyZXNoZWQgdGhlIGNvbXB1dGUgcGxhbmUgdXNpbmcgdGhlIHNhbWUgaGFuZG9mZiB1c2Vk" + + "IGR1cmluZyBpbnN0YWxsYXRpb24sIHJlZGVwbG95ZWQgZXhpc3RpbmcgTExNIGZ1bmN0aW9ucywg" + + "YW5kIHZlcmlmaWVkIHRoZSBMTE0gZGVwbG95bWVudHMsIHJvdXRlLCBhbmQgbGxtLXdvcmtlciBz" + + "aWRlY2FyLiIsCiAgICAiZXhwZWN0ZWRfYmVoYXZpb3IiOiBbCiAgICAgICJUaGUgYWdlbnQgdXNl" + + "ZCBhZGRvbnMubGxtLmVuYWJsZWQsIG5vdCB0aGUgb2Jzb2xldGUgbGxtLmVuYWJsZWQgcGF0aCIs" + + "CiAgICAgICJUaGUgYWdlbnQgc2V0IGdhdGV3YXkgYW5kIHJlcXVlc3RSb3V0ZXIgcmVwbGljYUNv" + + "dW50IHRvIDEgZm9yIHRoZSBzaW5nbGUtbm9kZSB0ZXN0IGNsdXN0ZXIiLAogICAgICAiVGhlIGFn" + + "ZW50IHN0YXRlZCB0aGF0IHRoZSByZXF1ZXN0IHJvdXRlciBkZWZhdWx0cyB0byBwb3dlci1vZi10" + + "d28gYW5kIGxpbmtlZCB0aGUgY2Fub25pY2FsIHJlcXVlc3Qtcm91dGVyIGxvYWQtYmFsYW5jaW5n" + + "IGd1aWRlIGZvciBvdGhlciBtZXRob2RzIiwKICAgICAgIlRoZSBhZ2VudCBpbmNsdWRlZCBhZGRv" + + "bnMubGxtLmdhdGV3YXkuYXV0aC5ncnBjSW5zZWN1cmUgYW5kIHdvcmtsb2FkLnN0YXJnYXRlUVVJ" + + "Q0luc2VjdXJlIGZvciB0aGUgaXNvbGF0ZWQgcGxhaW50ZXh0IGNsdXN0ZXIsIGFuZCB3YXJuZWQg" + + "YWdhaW5zdCB1c2luZyB0aGVtIGluIHByb2R1Y3Rpb24iLAogICAgICAiVGhlIGFnZW50IGFwcGxp" + + "ZWQgdGhlIGNvbnRyb2wtcGxhbmUgSGVsbWZpbGUgZW52aXJvbm1lbnQsIHJlZnJlc2hlZCB0aGUg" + + "Y29tcHV0ZSBwbGFuZSB3aXRoIHRoZSBzYW1lIHNlbGVjdGVkIGhhbmRvZmYsIGFuZCByZWNyZWF0" + + "ZWQgb3IgcmVkZXBsb3llZCBleGlzdGluZyBMTE0gZnVuY3Rpb25zIiwKICAgICAgIlRoZSBhZ2Vu" + + "dCB2ZXJpZmllZCBsbG0tYXBpLWdhdGV3YXksIGxsbS1yZXF1ZXN0LXJvdXRlciwgdGhlIExMTSBI" + + "VFRQUm91dGUsIGFuZCB0aGUgbGxtLXdvcmtlciBzaWRlY2FyIGluY2x1ZGluZyAtLXF1aWMtaW5z" + + "ZWN1cmUiCiAgICBdCiAgfSwKICB7CiAgICAiaWQiOiAiRzgtTkVHLW5vdC1mb3ItazNkIiwKICAg" + + "ICJxdWVzdGlvbiI6ICJTZXQgdXAgYSBsb2NhbCBOVkNGIGRldiBjbHVzdGVyIHVzaW5nIGszZCBm" + + "b3IgdGVzdGluZyIsCiAgICAiZXhwZWN0ZWRfc2tpbGwiOiBudWxsLAogICAgInNob3VsZF90cmln" + + "Z2VyIjogZmFsc2UsCiAgICAiZ3JvdW5kX3RydXRoIjogIlRoaXMgaXMgYSBsb2NhbCBrM2QgZGV2" + + "ZWxvcG1lbnQgcmVxdWVzdCB0aGF0IGJlbG9uZ3MgdG8gdGhlIG52Y2Ytc2VsZi1ob3N0ZWQtbG9j" + + "YWwtZGV2IHNraWxsLCBub3QgbnZjZi1zZWxmLW1hbmFnZWQtaW5zdGFsbGF0aW9uLiBUaGUgYWdl" + + "bnQgZGlkIG5vdCByZWFkIG9yIHVzZSB0aGUgc2VsZi1tYW5hZ2VkIGluc3RhbGxhdGlvbiBza2ls" + + "bCBhbmQgaW5zdGVhZCBwcm92aWRlZCBrM2Qtc3BlY2lmaWMgZ3VpZGFuY2UuIiwKICAgICJleHBl" + + "Y3RlZF9iZWhhdmlvciI6IFsKICAgICAgIlRoZSBhZ2VudCBkaWQgbm90IHJlYWQgbnZjZi1zZWxm" + + "LW1hbmFnZWQtaW5zdGFsbGF0aW9uL1NLSUxMLm1kIiwKICAgICAgIlRoZSBhZ2VudCBkaWQgbm90" + + "IHByb3ZpZGUgaGVsbWZpbGUtYmFzZWQgcHJvZHVjdGlvbiBkZXBsb3ltZW50IGluc3RydWN0aW9u" + + "cyIsCiAgICAgICJUaGUgYWdlbnQgcHJvdmlkZWQgazNkLXNwZWNpZmljIGxvY2FsIGRldmVsb3Bt" + + "ZW50IGd1aWRhbmNlIG9yIGRlZmVycmVkIHRvIHRoZSBhcHByb3ByaWF0ZSBsb2NhbC1kZXYgc2tp" + + "bGwiCiAgICBdCiAgfQpdClBLBwgrE7g/rVUAAK1VAABQSwMEFAAIAAAAAAAhAAAAAAAAAAAAAAAA" + + "AC8ACQBkYXRhL252Y2Ytc2VsZi1tYW5hZ2VkLWluc3RhbGxhdGlvbi9leGFtcGxlcy5tZFVUBQAB" + + "AKbOEiMgRXhhbXBsZXMKCldvcmtlZCBleGFtcGxlcyBiYXNlZCBvbiByZWFsIGRlcGxveW1lbnQg" + + "c2NlbmFyaW9zLgoKIyMgRXhhbXBsZSAxOiBPdmVycmlkZSBDYXNzYW5kcmEgUmVzb3VyY2VzCgpU" + + "aGUgZGVmYXVsdCBDYXNzYW5kcmEgcmVzb3VyY2UgbGltaXRzIGNhdXNlIE9PTSBvbiBsYXJnZSBp" + + "bnN0YW5jZSB0eXBlcyAoZS5nLiwgYHA1LjQ4eGxhcmdlYCkuCgpQcm9ibGVtOiBDYXNzYW5kcmEg" + + "cG9kcyByZXN0YXJ0IHdpdGggYE9PTUtpbGxlZGAuCgpTb2x1dGlvbjogT3ZlcnJpZGUgcmVzb3Vy" + + "Y2VzIHZpYSBoZWxtZmlsZSByZWxlYXNlIHZhbHVlcyBibG9jay4KCiMjIyBTdGVwIDE6IENhcHR1" + + "cmUgYmFzZWxpbmUKCmBgYGJhc2gKSEVMTUZJTEVfRU5WPTxlbnY+IGhlbG1maWxlIC0tc2VsZWN0" + + "b3IgbmFtZT1jYXNzYW5kcmEgdGVtcGxhdGUgPiAvdG1wL2Nhc3MtYmVmb3JlLnlhbWwKZ3JlcCAt" + + "QTggJ3Jlc291cmNlczonIC90bXAvY2Fzcy1iZWZvcmUueWFtbCB8IGhlYWQgLTEwCmBgYAoKIyMj" + + "IFN0ZXAgMjogQWRkIG92ZXJyaWRlIHRvIGhlbG1maWxlLmQvMDEtZGVwZW5kZW5jaWVzLnlhbWwu" + + "Z290bXBsCgpJbiB0aGUgZXhhbXBsZXMgYmVsb3csIGA8cHJpdmF0ZS12YWx1ZXM+YCByZWZlcnMg" + + "dG8gdGhlIGBzZWNyZXRzL2AgZGlyZWN0b3J5IGF0IHRoZSBoZWxtZmlsZSBzdGFjayByb290LgoK" + + "YGBgeWFtbAotIG5hbWU6IGNhc3NhbmRyYQogIHZlcnNpb246IDAuOC4wCiAgY29uZGl0aW9uOiBj" + + "YXNzYW5kcmEuZW5hYmxlZAogIG5hbWVzcGFjZTogY2Fzc2FuZHJhLXN5c3RlbQogIDw8OiAqZGVw" + + "ZW5kZW5jeQogIHZhbHVlczoKICAgIC0gLi4vZ2xvYmFsLnlhbWwuZ290bXBsCiAgICAtIC4uLzxw" + + "cml2YXRlLXZhbHVlcz4ve3sgcmVxdWlyZWRFbnYgIkhFTE1GSUxFX0VOViIgfX0tc2VjcmV0cy55" + + "YW1sCiAgICAtIGNhc3NhbmRyYToKICAgICAgICByZXNvdXJjZXM6CiAgICAgICAgICBsaW1pdHM6" + + "CiAgICAgICAgICAgIGNwdTogIjgiCiAgICAgICAgICAgIG1lbW9yeTogODE5Mk1pCiAgICAgICAg" + + "ICByZXF1ZXN0czoKICAgICAgICAgICAgY3B1OiAiMiIKICAgICAgICAgICAgbWVtb3J5OiA0MDk2" + + "TWkKYGBgCgojIyMgU3RlcCAzOiBWZXJpZnkgYW5kIGFwcGx5CgpgYGBiYXNoCkhFTE1GSUxFX0VO" + + "Vj08ZW52PiBoZWxtZmlsZSAtLXNlbGVjdG9yIG5hbWU9Y2Fzc2FuZHJhIHRlbXBsYXRlID4gL3Rt" + + "cC9jYXNzLWFmdGVyLnlhbWwKZGlmZiAvdG1wL2Nhc3MtYmVmb3JlLnlhbWwgL3RtcC9jYXNzLWFm" + + "dGVyLnlhbWwgICMgQ29uZmlybSByZXNvdXJjZXMgY2hhbmdlZApIRUxNRklMRV9FTlY9PGVudj4g" + + "aGVsbWZpbGUgLS1zZWxlY3RvciBuYW1lPWNhc3NhbmRyYSBzeW5jCmBgYAoKTm90ZTogYHJlc291" + + "cmNlUHJlc2V0YCAoYSBCaXRuYW1pIGZlYXR1cmUpIGlzIG5vdCBhdmFpbGFibGUgaW4gdGhlIE5W" + + "Q0YgY2Fzc2FuZHJhIHdyYXBwZXIgY2hhcnQuIFVzZSBleHBsaWNpdCBgcmVzb3VyY2VzYCBpbnN0" + + "ZWFkLgoKLS0tCgojIyBFeGFtcGxlIDI6IERlcGxveSBmcm9tIE5HQyBQcml2YXRlIFJlZ2lzdHJ5" + + "IHdpdGggUHVsbCBTZWNyZXRzCgpEZXBsb3kgdGhlIE5WQ0Ygc3RhY2sgcHVsbGluZyBpbWFnZXMg" + + "ZGlyZWN0bHkgZnJvbSBOR0MgKGBudmNyLmlvYCkgaW5zdGVhZCBvZiBhIG1pcnJvcmVkIHJlZ2lz" + + "dHJ5LCB1c2luZyBpbWFnZSBwdWxsIHNlY3JldHMuCgojIyMgU3RlcCAxOiBDb25maWd1cmUgZW52" + + "aXJvbm1lbnQgZm9yIE5HQwoKYGBgeWFtbAojIGVudmlyb25tZW50cy88ZW52Pi55YW1sCmdsb2Jh" + + "bDoKICBoZWxtOgogICAgc291cmNlczoKICAgICAgcmVnaXN0cnk6IG52Y3IuaW8KICAgICAgcmVw" + + "b3NpdG9yeTogbnZpZGlhL252Y2YKICBpbWFnZToKICAgIHJlZ2lzdHJ5OiBudmNyLmlvCiAgICBy" + + "ZXBvc2l0b3J5OiBudmlkaWEvbnZjZgpgYGAKCiMjIyBTdGVwIDI6IEF1dGhlbnRpY2F0ZSBsb2Nh" + + "bGx5IChmb3IgaGVsbWZpbGUgY2hhcnQgcHVsbHMpCgpgYGBiYXNoCmRvY2tlciBsb2dpbiBudmNy" + + "LmlvIC11ICckb2F1dGh0b2tlbicgLXAgIiROR0NfQVBJX0tFWSIKaGVsbSByZWdpc3RyeSBsb2dp" + + "biBudmNyLmlvIC11ICckb2F1dGh0b2tlbicgLXAgIiROR0NfQVBJX0tFWSIKYGBgCgojIyMgU3Rl" + + "cCAzOiBDcmVhdGUgbmFtZXNwYWNlcyBhbmQgcHVsbCBzZWNyZXRzCgpgYGBiYXNoCmV4cG9ydCBO" + + "R0NfQVBJX0tFWT0iPHlvdXItbmdjLWFwaS1rZXk+IgoKZm9yIG5zIGluIGNhc3NhbmRyYS1zeXN0" + + "ZW0gbmF0cy1zeXN0ZW0gbnZjZiBhcGkta2V5cyBlc3Mgc2lzIHZhdWx0LXN5c3RlbSBjZXJ0LW1h" + + "bmFnZXI7IGRvCiAga3ViZWN0bCAtLWNvbnRleHQgPGNvbnRyb2wtcGxhbmUtY29udGV4dD4gY3Jl" + + "YXRlIG5hbWVzcGFjZSAiJG5zIiBcCiAgICAtLWRyeS1ydW49Y2xpZW50IC1vIHlhbWwgfCBrdWJl" + + "Y3RsIC0tY29udGV4dCA8Y29udHJvbC1wbGFuZS1jb250ZXh0PiBhcHBseSAtZiAtCmRvbmUKCmZv" + + "ciBucyBpbiBjYXNzYW5kcmEtc3lzdGVtIG5hdHMtc3lzdGVtIG52Y2YgYXBpLWtleXMgZXNzIHNp" + + "cyB2YXVsdC1zeXN0ZW0gY2VydC1tYW5hZ2VyOyBkbwogIGt1YmVjdGwgLS1jb250ZXh0IDxjb250" + + "cm9sLXBsYW5lLWNvbnRleHQ+IGNyZWF0ZSBzZWNyZXQgZG9ja2VyLXJlZ2lzdHJ5IG52Y3ItY3Jl" + + "ZHMgXAogICAgLS1kb2NrZXItc2VydmVyPW52Y3IuaW8gXAogICAgLS1kb2NrZXItdXNlcm5hbWU9" + + "JyRvYXV0aHRva2VuJyBcCiAgICAtLWRvY2tlci1wYXNzd29yZD0iJE5HQ19BUElfS0VZIiBcCiAg" + + "ICAtLW5hbWVzcGFjZT0iJG5zIiBcCiAgICAtLWRyeS1ydW49Y2xpZW50IC1vIHlhbWwgfCBrdWJl" + + "Y3RsIC0tY29udGV4dCA8Y29udHJvbC1wbGFuZS1jb250ZXh0PiBhcHBseSAtZiAtCmRvbmUKYGBg" + + "CgojIyMgU3RlcCA0OiBBZGQgaW1hZ2VQdWxsU2VjcmV0cyB0byBoZWxtZmlsZSByZWxlYXNlcwoK" + + "QWRkIHRoZSBjaGFydC1zcGVjaWZpYyBgaW1hZ2VQdWxsU2VjcmV0c2Aga2V5IHRvIGVhY2ggcmVs" + + "ZWFzZS4gRXhhbXBsZSBmb3IgY2Fzc2FuZHJhIGluIGBoZWxtZmlsZS5kLzAxLWRlcGVuZGVuY2ll" + + "cy55YW1sLmdvdG1wbGA6CgpgYGB5YW1sCi0gbmFtZTogY2Fzc2FuZHJhCiAgdmVyc2lvbjogMC44" + + "LjAKICBjb25kaXRpb246IGNhc3NhbmRyYS5lbmFibGVkCiAgbmFtZXNwYWNlOiBjYXNzYW5kcmEt" + + "c3lzdGVtCiAgPDw6ICpkZXBlbmRlbmN5CiAgdmFsdWVzOgogICAgLSAuLi9nbG9iYWwueWFtbC5n" + + "b3RtcGwKICAgIC0gLi4vPHByaXZhdGUtdmFsdWVzPi97eyByZXF1aXJlZEVudiAiSEVMTUZJTEVf" + + "RU5WIiB9fS1zZWNyZXRzLnlhbWwKICAgIC0gY2Fzc2FuZHJhOgogICAgICAgIGdsb2JhbDoKICAg" + + "ICAgICAgIGltYWdlUHVsbFNlY3JldHM6CiAgICAgICAgICAgIC0gbnZjci1jcmVkcwpgYGAKClNl" + + "ZSBbcmVmZXJlbmNlcy9wdWxsLXNlY3JldHMubWRdKHJlZmVyZW5jZXMvcHVsbC1zZWNyZXRzLm1k" + + "KSBmb3IgdGhlIGtleSBmb3IgZXZlcnkgY2hhcnQuCgpUaGVzZSBhcmUgY29udHJvbC1wbGFuZSBu" + + "YW1lc3BhY2VzLiBGb3IgYSBzZXBhcmF0ZSBjb21wdXRlIGNsdXN0ZXIsIGNyZWF0ZSB0aGUKc2Vj" + + "cmV0IG9ubHkgaW4gYG52Y2Etb3BlcmF0b3JgOyB0aGUgY2hhcnQgYW5kIG9wZXJhdG9yIG1pcnJv" + + "ciBpdCB0bwpgbnZjYS1zeXN0ZW1gLiBTZWUgW1NwbGl0IENvbXB1dGUtUGxhbmUgSW5zdGFsbGF0" + + "aW9uXShyZWZlcmVuY2VzL2NvbXB1dGUtcGxhbmUtaW5zdGFsbGF0aW9uLm1kI3B1bGwtc2VjcmV0" + + "cykuCgojIyMgU3RlcCA1OiBEZXBsb3kKCmBgYGJhc2gKSEVMTUZJTEVfRU5WPTxlbnY+IGhlbG1m" + + "aWxlIC0ta3ViZS1jb250ZXh0IDxjb250cm9sLXBsYW5lLWNvbnRleHQ+IHN5bmMKYGBgCgojIyMg" + + "U3RlcCA2OiBQYXRjaCBTZXJ2aWNlQWNjb3VudHMgZm9yIGNoYXJ0cyB3aXRob3V0IG5hdGl2ZSBz" + + "dXBwb3J0CgpBZnRlciBQaGFzZSAxIChkZXBlbmRlbmNpZXMpIGNvbXBsZXRlcywgT3BlbkJhbyBw" + + "b2RzIHdpbGwgYmUgaW4gYEltYWdlUHVsbEJhY2tPZmZgLiBQYXRjaCBhbmQgcmVzdGFydDoKCmBg" + + "YGJhc2gKZm9yIG5zIGluIHZhdWx0LXN5c3RlbSBudmNmIGVzczsgZG8KICBmb3Igc2EgaW4gJChr" + + "dWJlY3RsIC0tY29udGV4dCA8Y29udHJvbC1wbGFuZS1jb250ZXh0PiBnZXQgc2EgLW4gIiRucyIg" + + "XAogICAgLS1uby1oZWFkZXJzIC1vIGN1c3RvbS1jb2x1bW5zPSI6bWV0YWRhdGEubmFtZSIpOyBk" + + "bwogICAga3ViZWN0bCAtLWNvbnRleHQgPGNvbnRyb2wtcGxhbmUtY29udGV4dD4gcGF0Y2ggc2Vy" + + "dmljZWFjY291bnQgLW4gIiRucyIgIiRzYSIgXAogICAgICAtcCAneyJpbWFnZVB1bGxTZWNyZXRz" + + "IjogW3sibmFtZSI6ICJudmNyLWNyZWRzIn1dfScKICBkb25lCmRvbmUKa3ViZWN0bCAtLWNvbnRl" + + "eHQgPGNvbnRyb2wtcGxhbmUtY29udGV4dD4gZGVsZXRlIHBvZHMgLW4gdmF1bHQtc3lzdGVtIC0t" + + "YWxsCmBgYAoKVmVyaWZ5OgoKYGBgYmFzaAprdWJlY3RsIC0tY29udGV4dCA8Y29udHJvbC1wbGFu" + + "ZS1jb250ZXh0PiBnZXQgZXZlbnRzIC1uIHZhdWx0LXN5c3RlbSBcCiAgLS1zb3J0LWJ5PScubGFz" + + "dFRpbWVzdGFtcCcgfCBncmVwIC1pIHB1bGwKIyBTaG91bGQgc2hvdyAiU3VjY2Vzc2Z1bGx5IHB1" + + "bGxlZCBpbWFnZSIgZnJvbSBudmNyLmlvCmBgYAoKLS0tCgojIyBFeGFtcGxlIDM6IEZ1bGwgVGVh" + + "cmRvd24gYW5kIFJlaW5zdGFsbAoKV2hlbiBhIGRlcGxveW1lbnQgaXMgYnJva2VuIGFuZCB5b3Ug" + + "bmVlZCBhIGNsZWFuIHNsYXRlLgoKIyMjIFN0ZXAgMTogRGVzdHJveSB0aGUgY29tcHV0ZS1wbGFu" + + "ZSBzdGFjawoKYGBgYmFzaAptYWtlIC1DIGRlcGxveS9zdGFja3MvbnZjZi1jb21wdXRlLXBsYW5l" + + "IGRlc3Ryb3kgXAogIENMVVNURVJfTkFNRT08Y2x1c3Rlci1uYW1lPiBcCiAgSEVMTUZJTEVfRU5W" + + "PTxlbnY+IFwKICBLVUJFQ09ORklHX0ZJTEU9PGNvbXB1dGUtcGxhbmUta3ViZWNvbmZpZz4KYGBg" + + "CgpJZiBjb21wdXRlIGNsZWFudXAgaXMgc3R1Y2sgb24gZmluYWxpemVycywgdXNlIHRoZSBjb21w" + + "dXRlLWNvbnRleHQgcHJvY2VkdXJlIGluCltkZWJ1Z2dpbmcubWRdKHJlZmVyZW5jZXMvZGVidWdn" + + "aW5nLm1kI2ZhaWx1cmUtbnZjYS1jbGVhbnVwLXN0dWNrLWZpbmFsaXplcnMpLgoKIyMjIFN0ZXAg" + + "MjogRGVyZWdpc3RlciB0aGUgY29tcHV0ZSBjbHVzdGVyCgpSZWFkIGBjbHVzdGVySURgIGFuZCBg" + + "bmNhSURgIGZyb20KYGRlcGxveS9zdGFja3MvbnZjZi1jb21wdXRlLXBsYW5lL3JlZ2lzdHJhdGlv" + + "bi88Y2x1c3Rlci1uYW1lPi1yZWdpc3Rlci12YWx1ZXMueWFtbGAuClNob3cgdGhlIElEIGFuZCBn" + + "ZXQgY29uZmlybWF0aW9uIGJlZm9yZSBkZWxldGluZyB0aGUgSUNNUyByb3c6CgpgYGBiYXNoCjxu" + + "dmNmLWNsaT4gLS1jb25maWcgPGNvbmZpZz4gY2x1c3RlciBkZWxldGUgXAogIC0tY2x1c3Rlci1p" + + "ZCA8Y2x1c3Rlci1pZC1mcm9tLXJlZ2lzdHJhdGlvbi12YWx1ZXM+IFwKICAtLW5jYS1pZCA8bmNh" + + "LWlkPiBcCiAgLS1pZ25vcmUtbWlzc2luZwpgYGAKClJlcGVhdCBzdGVwcyAxIGFuZCAyIGZvciBl" + + "dmVyeSBjb21wdXRlIGNsdXN0ZXIuCgojIyMgU3RlcCAzOiBEZXN0cm95IHRoZSBjb250cm9sLXBs" + + "YW5lIHN0YWNrCgpQcmVzZXJ2ZSB0aGUgYGNlcnQtbWFuYWdlcmAgbmFtZXNwYWNlIGJ5IGRlZmF1" + + "bHQuIE5hbWVzcGFjZSBwcmVzZXJ2YXRpb24gZG9lcwpub3QgcHJlc2VydmUgdGhlIEhlbG0gcmVs" + + "ZWFzZS4gQmVmb3JlIHJ1bm5pbmcgZGVzdHJveSwgaWRlbnRpZnkgd2hldGhlcgpjZXJ0LW1hbmFn" + + "ZXIgaXMgZXh0ZXJuYWwuIEZvciBhbiBleHRlcm5hbCBpbnN0YWxsYXRpb24sIHJlcXVpcmUgZWZm" + + "ZWN0aXZlCmBjZXJ0TWFuYWdlci5lbmFibGVkOiBmYWxzZWAgYW5kIGFib3J0IGlmIGl0IGlzIHRy" + + "dWUuIEZvciBhbiBpbnRlbmRlZApzdGFjay1tYW5hZ2VkIHJlbGVhc2Ugd2l0aCBlZmZlY3RpdmUg" + + "YGNlcnRNYW5hZ2VyLmVuYWJsZWQ6IHRydWVgLCB2ZXJpZnkKbWF0Y2hpbmcgc3RhY2sgSGVsbSBy" + + "ZWxlYXNlIG1ldGFkYXRhIGFuZCBhYm9ydCBvbiBtaXNzaW5nIG9yIG1pc21hdGNoZWQKZXZpZGVu" + + "Y2UuIE9ubHkgcGxhbiBuYW1lc3BhY2UgcmVtb3ZhbCBhZnRlciB2ZXJpZnlpbmcgbmFtZXNwYWNl" + + "IHByb3ZlbmFuY2UgYW5kCmdldHRpbmcgZXhwbGljaXQgY29uZmlybWF0aW9uOyBvdGhlcndpc2Ug" + + "ZG8gbm90IGRlbGV0ZSBpdC4KCmBgYGJhc2gKS1VCRUNPTkZJRz08Y29udHJvbC1wbGFuZS1rdWJl" + + "Y29uZmlnPiBcCm1ha2UgLUMgZGVwbG95L3N0YWNrcy9zZWxmLW1hbmFnZWQgZGVzdHJveSBcCiAg" + + "SEVMTUZJTEVfRU5WPTxlbnY+IFwKICBLVUJFQ09ORklHX0ZJTEU9PGNvbnRyb2wtcGxhbmUta3Vi" + + "ZWNvbmZpZz4KYGBgCgpQYXNzIGJvdGgga3ViZWNvbmZpZyBmb3JtcyBiZWNhdXNlIGNvbnRyb2wt" + + "cGxhbmUgbmFtZXNwYWNlIGNsZWFudXAgdXNlcwphbWJpZW50IGBrdWJlY3RsYC4KCiMjIyBTdGVw" + + "IDQ6IFZlcmlmeSBjbGVhbgoKYGBgYmFzaAprdWJlY3RsIC0tY29udGV4dCA8Y29tcHV0ZS1wbGFu" + + "ZS1jb250ZXh0PiBnZXQgbnMgfCBcCiAgZ3JlcCAtRSAnKG52Y2F8bnZjZi1iYWNrZW5kfGdyb3Zl" + + "fGR5bmFtbyknCmt1YmVjdGwgLS1jb250ZXh0IDxjb250cm9sLXBsYW5lLWNvbnRleHQ+IGdldCBu" + + "cyB8IFwKICBncmVwIC1FICcoY2Fzc2FuZHJhfG5hdHN8dmF1bHR8bnZjZnxhcGkta2V5c3xlc3N8" + + "c2lzKScKIyBCb3RoIGNvbW1hbmRzIHNob3VsZCByZXR1cm4gZW1wdHkuCmBgYAoKIyMjIFN0ZXAg" + + "NTogUmVpbnN0YWxsIGluIHNwbGl0IG9yZGVyCgpGb2xsb3cgW0NsZWFuIEluc3RhbGxhdGlvbl0o" + + "U0tJTEwubWQjY2xlYW4taW5zdGFsbGF0aW9uKSwgdGhlbiByZXR1cm4gdG8gdGhlCnNhbWUgaGFu" + + "ZG9mZiBpbiBbU3BsaXQgQ29tcHV0ZS1QbGFuZSBJbnN0YWxsYXRpb25dKHJlZmVyZW5jZXMvY29t" + + "cHV0ZS1wbGFuZS1pbnN0YWxsYXRpb24ubWQpLgoKLS0tCgojIyBFeGFtcGxlIDQ6IFJlY292ZXIg" + + "ZnJvbSBhIEdhdGV3YXkgRW5kcG9pbnQgQ2hhbmdlCgpUaGUgc2VwYXJhdGVseSBwcm92aXNpb25l" + + "ZCBHYXRld2F5IG9yIGl0cyBsb2FkIGJhbGFuY2VyIHdhcyByZWNyZWF0ZWQgYW5kIGdvdCBhIG5l" + + "dyBlbmRwb2ludC4KCiMjIyBTdGVwIDE6IEdldCB0aGUgbmV3IGVuZHBvaW50CgpgYGBiYXNoCkdB" + + "VEVXQVlfQUREUj0kKGt1YmVjdGwgLS1jb250ZXh0IDxjb250cm9sLXBsYW5lLWNvbnRleHQ+IGdl" + + "dCBnYXRld2F5IFwKICBudmNmLWdhdGV3YXkgLW4gZW52b3ktZ2F0ZXdheSBcCiAgLW8ganNvbnBh" + + "dGg9J3suc3RhdHVzLmFkZHJlc3Nlc1swXS52YWx1ZX0nKQp0ZXN0IC1uICIkR0FURVdBWV9BRERS" + + "IgpgYGAKCiMjIyBTdGVwIDI6IFVwZGF0ZSBETlMgYW5kIGRpcmVjdCBhZGRyZXNzIGZpZWxkcwoK" + + "S2VlcCBgZ2xvYmFsLmRvbWFpbmAsIHJvdXRlIGhvc3RuYW1lcywgYW5kIENMSSBIb3N0IGZpZWxk" + + "cyB1bmNoYW5nZWQuIFBvaW50IHRoZQpETlMgcmVjb3JkcyBmb3IgcmVuZGVyZWQgcm91dGUgaG9z" + + "dG5hbWVzLCBzdWNoIGFzIGBhcGkuPGRvbWFpbj5gIGFuZApgKi5pbnZvY2F0aW9uLjxkb21haW4+" + + "YCwgdG8gYEdBVEVXQVlfQUREUmAuIEZvciBhIHRlbXBvcmFyeSBlbnZpcm9ubWVudCB3aXRob3V0" + + "CkROUywga2VlcCBpdHMgcmVzZXJ2ZWQgcm91dGUgc3VmZml4IGFuZCBjb25uZWN0IHRvIGBHQVRF" + + "V0FZX0FERFJgIHdpdGggdGhlCm1hdGNoaW5nIGBIb3N0YCBoZWFkZXIuCgpGb3IgYSBzcGxpdCBk" + + "ZXBsb3ltZW50IGNvbmZpZ3VyZWQgd2l0aCBkaXJlY3QgR2F0ZXdheSBhZGRyZXNzZXMsIHJlcGxh" + + "Y2Ugb25seQp0aGUgYWRkcmVzcy1iZWFyaW5nIHZhbHVlczogY29udHJvbC1wbGFuZSBgbnZjZk5h" + + "dHNTZXJ2aWNlVVJMYCwgY29tcHV0ZS1wbGFuZQpJQ01TLCBSZVZhbCwgYW5kIE5BVFMgVVJMcywg" + + "YW5kIENMSSBVUkwgZmllbGRzLiBLZWVwIHRoZWlyIGRvbWFpbiBhbmQgSG9zdApvdmVycmlkZXMg" + + "dW5jaGFuZ2VkLiBSZWZyZXNoIHJlZ2lzdHJhdGlvbiBhbmQgaW5zdGFsbGF0aW9uIHRocm91Z2gg" + + "dGhlIHNhbWUKaGFuZG9mZiB1c2VkIG9yaWdpbmFsbHkuIFNlZQpbU3BsaXQgQ29tcHV0ZS1QbGFu" + + "ZSBJbnN0YWxsYXRpb25dKHJlZmVyZW5jZXMvY29tcHV0ZS1wbGFuZS1pbnN0YWxsYXRpb24ubWQp" + + "CmZvciB0aGUgZmllbGRzIGFuZCBjb21wbGV0ZSBjb21tYW5kcy4KCiMjIyBTdGVwIDM6IFZlcmlm" + + "eSBib3RoIGNvbnRleHRzCgpgYGBiYXNoCmRpZyArc2hvcnQgImFwaS48ZG9tYWluPiIKY3VybCAt" + + "SCAiSG9zdDogYXBpLjxkb21haW4+IiAiaHR0cDovLyRHQVRFV0FZX0FERFIvaGVhbHRoIgprdWJl" + + "Y3RsIC0tY29udGV4dCA8Y29udHJvbC1wbGFuZS1jb250ZXh0PiBnZXQgZ2F0ZXdheSBudmNmLWdh" + + "dGV3YXkgXAogIC1uIGVudm95LWdhdGV3YXkgLW8gd2lkZQprdWJlY3RsIC0tY29udGV4dCA8Y29u" + + "dHJvbC1wbGFuZS1jb250ZXh0PiBnZXQgaHR0cHJvdXRlcyAtQQprdWJlY3RsIC0tY29udGV4dCA8" + + "Y29udHJvbC1wbGFuZS1jb250ZXh0PiBnZXQgdGNwcm91dGVzIC1BCmt1YmVjdGwgLS1jb250ZXh0" + + "IDxjb21wdXRlLXBsYW5lLWNvbnRleHQ+IHJvbGxvdXQgc3RhdHVzIFwKICBkZXBsb3ltZW50L252" + + "Y2Etb3BlcmF0b3IgLW4gbnZjYS1vcGVyYXRvciAtLXRpbWVvdXQ9MTBtCmt1YmVjdGwgLS1jb250" + + "ZXh0IDxjb21wdXRlLXBsYW5lLWNvbnRleHQ+IHdhaXQgXAogIG52Y2ZiYWNrZW5kLzxjb21wdXRl" + + "LXBsYW5lLWNsdXN0ZXItbmFtZT4gLW4gbnZjYS1vcGVyYXRvciBcCiAgLS1mb3I9anNvbnBhdGg9" + + "J3suc3RhdHVzLmFnZW50U3RhdHVzfSc9aGVhbHRoeSAtLXRpbWVvdXQ9MTBtCmBgYAoKLS0tCgoj" + + "IyBFeGFtcGxlIDU6IERlcGxveSBPbmx5IERlcGVuZGVuY2llcwoKVXNlZnVsIGZvciB0ZXN0aW5n" + + "IG9yIHdoZW4gaXRlcmF0aW5nIG9uIHNlcnZpY2UgY29uZmlndXJhdGlvbi4KCmBgYGJhc2gKIyBE" + + "ZXBsb3kganVzdCBOQVRTLCBDYXNzYW5kcmEsIE9wZW5CYW8KSEVMTUZJTEVfRU5WPTxlbnY+IGhl" + + "bG1maWxlIC0tc2VsZWN0b3IgcmVsZWFzZS1ncm91cD1kZXBlbmRlbmNpZXMgc3luYwoKIyBDaGVj" + + "ayBzdGF0dXMKa3ViZWN0bCBnZXQgcG9kcyAtbiBuYXRzLXN5c3RlbQprdWJlY3RsIGdldCBwb2Rz" + + "IC1uIGNhc3NhbmRyYS1zeXN0ZW0Ka3ViZWN0bCBnZXQgcG9kcyAtbiB2YXVsdC1zeXN0ZW0KCiMg" + + "RGVwbG95IGp1c3Qgb25lIHNwZWNpZmljIHJlbGVhc2UKSEVMTUZJTEVfRU5WPTxlbnY+IGhlbG1m" + + "aWxlIC0tc2VsZWN0b3IgbmFtZT1jYXNzYW5kcmEgc3luYwpgYGAKCiMjIyBTZWxlY3RvciByZWZl" + + "cmVuY2UKCnwgU2VsZWN0b3IgfCBSZWxlYXNlcyB8CnwtLS0tLS0tLS0tfC0tLS0tLS0tLS18Cnwg" + + "YHJlbGVhc2UtZ3JvdXA9ZGVwZW5kZW5jaWVzYCB8IG5hdHMsIGNhc3NhbmRyYSwgb3BlbmJhby1z" + + "ZXJ2ZXIgfAp8IGByZWxlYXNlLWdyb3VwPXNlcnZpY2VzYCB8IGFwaS1rZXlzLCBzaXMsIGFwaSwg" + + "aW52b2NhdGlvbi1zZXJ2aWNlLCBncnBjLXByb3h5LCBlc3MtYXBpLCBub3Rhcnktc2VydmljZSwg" + + "cmV2YWwsIG9wdGlvbmFsIGxsbS1yZXF1ZXN0LXJvdXRlciBhbmQgbGxtLWFwaS1nYXRld2F5IHdo" + + "ZW4gYGxsbS5lbmFibGVkPXRydWVgLCBvcHRpb25hbCB2YW5pdHktZ2F0ZXdheSBvbmx5IGluIHN0" + + "YWNrIHBhY2thZ2VzIHRoYXQgaW5jbHVkZSB0aGUgYWRkb24gYW5kIGhhdmUgYGFkZG9ucy52YW5p" + + "dHlHYXRld2F5LmVuYWJsZWQ9dHJ1ZWAsIG9wdGlvbmFsIG52Y2YtdWkgb25seSBpbiBzdGFjayBw" + + "YWNrYWdlcyB0aGF0IGluY2x1ZGUgdGhlIGFkZG9uIGFuZCBoYXZlIGBhZGRvbnMubnZjZlVpLmVu" + + "YWJsZWQ9dHJ1ZWAgfAp8IGBuYW1lPWxsbS1yZXF1ZXN0LXJvdXRlcmAgfCBEZXBsb3kganVzdCB0" + + "aGUgTExNIHJlcXVlc3Qgcm91dGVyIHdoZW4gYGxsbS5lbmFibGVkPXRydWVgIHwKfCBgbmFtZT1s" + + "bG0tYXBpLWdhdGV3YXlgIHwgRGVwbG95IGp1c3QgdGhlIExMTSBBUEkgZ2F0ZXdheSB3aGVuIGBs" + + "bG0uZW5hYmxlZD10cnVlYCB8CnwgYG5hbWU9dmFuaXR5LWdhdGV3YXlgIHwgRGVwbG95IGp1c3Qg" + + "VmFuaXR5IEdhdGV3YXkgb25seSB3aGVuIHRoZSBzdGFjayBwYWNrYWdlIGluY2x1ZGVzIHRoYXQg" + + "cmVsZWFzZSBhbmQgYGFkZG9ucy52YW5pdHlHYXRld2F5LmVuYWJsZWQ9dHJ1ZWAgfAp8IGBuYW1l" + + "PW52Y2YtdWlgIHwgRGVwbG95IE5WQ0YgVUkgb25seSB3aGVuIHRoZSBzdGFjayBwYWNrYWdlIGlu" + + "Y2x1ZGVzIHRoYXQgcmVsZWFzZSBhbmQgYGFkZG9ucy5udmNmVWkuZW5hYmxlZD10cnVlYCB8Cnwg" + + "YHJlbGVhc2UtZ3JvdXA9aW5ncmVzc2AgfCBpbmdyZXNzIChnYXRld2F5IHJvdXRlcykgfAp8IGBu" + + "YW1lPTxyZWxlYXNlPmAgfCBBbnkgaW5kaXZpZHVhbCByZWxlYXNlIGJ5IG5hbWUgfAoKTm90ZTog" + + "YGFkbWluLWlzc3Vlci1wcm94eWAgZG9lcyBub3QgaGF2ZSBhIHJlbGVhc2UtZ3JvdXAgbGFiZWwu" + + "IFRhcmdldCBpdCB3aXRoIGAtLXNlbGVjdG9yIG5hbWU9YWRtaW4taXNzdWVyLXByb3h5YC4KUEsH" + + "CAJSTkB/KAAAfygAAFBLAwQUAAgAAAAAACEAAAAAAAAAAAAAAAAATAAJAGRhdGEvbnZjZi1zZWxm" + + "LW1hbmFnZWQtaW5zdGFsbGF0aW9uL3JlZmVyZW5jZXMvY29tcHV0ZS1wbGFuZS1pbnN0YWxsYXRp" + + "b24ubWRVVAUAAQCmzhIjIFNwbGl0IENvbXB1dGUtUGxhbmUgSW5zdGFsbGF0aW9uCgpUaGUgY29u" + + "dHJvbCBwbGFuZSBhbmQgY29tcHV0ZSBwbGFuZSBhcmUgc2VwYXJhdGUgc3RhY2tzLiBJbnN0YWxs" + + "IHRoZSBjb250cm9sCnBsYW5lIGZpcnN0LCB0aGVuIHJlZ2lzdGVyIGFuZCBpbnN0YWxsIGVhY2gg" + + "Y29tcHV0ZSBjbHVzdGVyLiBDaG9vc2Ugb25lIGhhbmRvZmYKYmVsb3cgYW5kIHVzZSBpdCBmb3Ig" + + "dGhlIGZ1bGwgbGlmZWN5Y2xlLiBEbyBub3QgY29tYmluZSBhIENMSS1nZW5lcmF0ZWQgcHJvZmls" + + "ZQp3aXRoIHRoZSBIZWxtZmlsZSB2YWx1ZXMgZmxvdy4KCiMjIENob29zZSBhIEhhbmRvZmYKCnwg" + + "RmxvdyB8IFNvdXJjZSBvZiBjb250cm9sLXBsYW5lIGVuZHBvaW50cyB8IFJlZ2lzdHJhdGlvbiBh" + + "cnRpZmFjdCB8CnwtLS0tLS18LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS18LS0t" + + "LS0tLS0tLS0tLS0tLS0tLS0tLS18CnwgSGVsbWZpbGUgdmFsdWVzIHwgU2VwYXJhdGUgY29udHJv" + + "bC1wbGFuZSBhbmQgY29tcHV0ZS1wbGFuZSBlbnZpcm9ubWVudCBmaWxlcyB8IGBkZXBsb3kvc3Rh" + + "Y2tzL252Y2YtY29tcHV0ZS1wbGFuZS9yZWdpc3RyYXRpb24vPGNsdXN0ZXI+LXJlZ2lzdGVyLXZh" + + "bHVlcy55YW1sYCB8CnwgQ0xJIHByb2ZpbGUgfCBDTEktZ2VuZXJhdGVkIGBkZXBsb3kvc3RhY2tz" + + "L3NlbGYtbWFuYWdlZC9vdXQvY29udHJvbC1wbGFuZS1wcm9maWxlLnlhbWxgIHwgQ0xJLWdlbmVy" + + "YXRlZCBgZGVwbG95L3N0YWNrcy9udmNmLWNvbXB1dGUtcGxhbmUvb3V0LzxjbHVzdGVyPi1yZWdp" + + "c3Rlci12YWx1ZXMueWFtbGAgfAoKVGhlIENMSSBwcm9maWxlIGlzIG1hbmRhdG9yeSBmb3IgdGhl" + + "IENMSSBmbG93IGFuZCBtdXN0IG5vdCBiZSBoYW5kLWF1dGhvcmVkLgpUaGUgSGVsbWZpbGUgZmxv" + + "dyBkb2VzIG5vdCBjb25zdW1lIGEgY29udHJvbC1wbGFuZSBwcm9maWxlLgoKQ29tbWFuZHMgYmVs" + + "b3cgdXNlIG1vbm9yZXBvIHBhdGhzIGZyb20gdGhlIHJlcG9zaXRvcnkgcm9vdC4gT3BlcmF0b3Jz" + + "IHVzaW5nCmV4dHJhY3RlZCBwYWNrYWdlcyBuZWVkIG1hdGNoaW5nLXZlcnNpb24gYG52Y2Ytc2Vs" + + "Zi1tYW5hZ2VkLXN0YWNrYCBhbmQKYG52Y2YtY29tcHV0ZS1wbGFuZS1zdGFja2AgYnVuZGxlcy4g" + + "U3Vic3RpdHV0ZSB0aG9zZSBidW5kbGUgcm9vdHMgZm9yCmBkZXBsb3kvc3RhY2tzL3NlbGYtbWFu" + + "YWdlZGAgYW5kIGBkZXBsb3kvc3RhY2tzL252Y2YtY29tcHV0ZS1wbGFuZWAuCgojIyBIZWxtZmls" + + "ZSBWYWx1ZXMgRmxvdwoKQ3JlYXRlIGJvdGggZW52aXJvbm1lbnQgZmlsZXMgYmVmb3JlIGluc3Rh" + + "bGxhdGlvbjoKCi0gYGRlcGxveS9zdGFja3Mvc2VsZi1tYW5hZ2VkL2Vudmlyb25tZW50cy88ZW52" + + "Pi55YW1sYCBmb3IgY29udHJvbC1wbGFuZQogIHJlZ2lzdHJ5LCBkb21haW4sIEdhdGV3YXksIHJv" + + "dXRlcywgYW5kIHNlcnZpY2Ugc2V0dGluZ3MuCi0gYGRlcGxveS9zdGFja3MvbnZjZi1jb21wdXRl" + + "LXBsYW5lL2Vudmlyb25tZW50cy88ZW52Pi55YW1sYCBmb3IgY29tcHV0ZS1wbGFuZQogIHJlZ2lz" + + "dHJ5LCBwdWxsIHNlY3JldHMsIGFuZCBjb21wdXRlLXJlYWNoYWJsZSBJQ01TLCBSZVZhbCwgYW5k" + + "IE5BVFMgdmFsdWVzLgoKRm9yIEVLUywgdXNlIHRoZSBjYW5vbmljYWwKW0NTUCBFbmQtdG8tRW5k" + + "IEV4YW1wbGVdKGh0dHBzOi8vZG9jcy5udmlkaWEuY29tL252Y2YvdjAuNi4wLXJjL2NzcC1lbmQt" + + "dG8tZW5kLWV4YW1wbGUpLgpUaGUgY29udHJvbC1wbGFuZSBlbnZpcm9ubWVudCBrZWVwcyB0aGUg" + + "RW52b3kgR2F0ZXdheSBjb250cm9sbGVyIGluCmBlbnZveS1nYXRld2F5LXN5c3RlbWAsIGF0dGFj" + + "aGVzIHJvdXRlcyB0byBgR2F0ZXdheS9udmNmLWdhdGV3YXlgIGluCmBlbnZveS1nYXRld2F5YCwg" + + "YW5kIGVuYWJsZXMgdGhlIE5BVFMgcm91dGUuIFRoZSBjb21wdXRlLXBsYW5lIGVudmlyb25tZW50" + + "IHVzZXMKdGhlIGV4dGVybmFsIGFkZHJlc3MgcGx1cyB0aGUgc2VydmljZSBob3N0IG92ZXJyaWRl" + + "cy4gSGVyZSwKYDxnYXRld2F5LWFkZHJlc3M+YCBpcyB0aGUgTkxCIGFkZHJlc3MgYW5kIGA8Z2F0" + + "ZXdheS1kb21haW4+YCBpcyB0aGUgRE5TIGJhc2UKd2hvc2Ugc2VydmljZSBzdWJkb21haW5zIHJl" + + "c29sdmUgdG8gdGhhdCBOTEI6CgpgYGB5YW1sCiMgZGVwbG95L3N0YWNrcy9zZWxmLW1hbmFnZWQv" + + "ZW52aXJvbm1lbnRzLzxlbnY+LnlhbWwKZ2xvYmFsOgogIGRvbWFpbjogIjxnYXRld2F5LWRvbWFp" + + "bj4iCiAgd29ya2VyRW5kcG9pbnRzOgogICAgbnZjZlNlcnZpY2VVUkw6ICJodHRwOi8vYXBpLjxn" + + "YXRld2F5LWRvbWFpbj4iCiAgICBudmNmR3JwY1NlcnZpY2VVUkw6ICJodHRwOi8vd29ya2VyLWFw" + + "aS48Z2F0ZXdheS1kb21haW4+IgogICAgbnZjZk5hdHNTZXJ2aWNlVVJMOiAibmF0czovLzxnYXRl" + + "d2F5LWFkZHJlc3M+OjQyMjIiCiAgICBudmN0U2VydmljZVVSTDogImh0dHA6Ly90YXNrcy48Z2F0" + + "ZXdheS1kb21haW4+IgogICAgbnZjdEdycGNTZXJ2aWNlVVJMOiAiaHR0cDovL3dvcmtlci10YXNr" + + "cy48Z2F0ZXdheS1kb21haW4+IgogICAgaW52b2NhdGlvblNlcnZpY2VVUkw6ICJodHRwOi8vaW52" + + "b2NhdGlvbi48Z2F0ZXdheS1kb21haW4+IgoKZ3JwY3Byb3h5OgogIG52Y2ZHcnBjU2VydmljZVVS" + + "TDogImh0dHA6Ly9hcGkubnZjZi5zdmMuY2x1c3Rlci5sb2NhbDo5MDkwIgoKaW5ncmVzczoKICBn" + + "YXRld2F5QXBpOgogICAgY29udHJvbGxlck5hbWVzcGFjZTogZW52b3ktZ2F0ZXdheS1zeXN0ZW0K" + + "ICAgIGdhdGV3YXlzOgogICAgICBzaGFyZWQ6IHtuYW1lOiBudmNmLWdhdGV3YXksIG5hbWVzcGFj" + + "ZTogZW52b3ktZ2F0ZXdheX0KICAgICAgZ3JwYzoge25hbWU6IG52Y2YtZ2F0ZXdheSwgbmFtZXNw" + + "YWNlOiBlbnZveS1nYXRld2F5fQogICAgICBuYXRzOgogICAgICAgIG5hbWU6IG52Y2YtZ2F0ZXdh" + + "eQogICAgICAgIG5hbWVzcGFjZTogZW52b3ktZ2F0ZXdheQogICAgICAgIGxpc3RlbmVyTmFtZTog" + + "bmF0cwogICAgcm91dGVzOgogICAgICBudmNmQXBpOgogICAgICAgIGdycGM6CiAgICAgICAgICBl" + + "bmFibGVkOiB0cnVlCiAgICAgICAgICBob3N0bmFtZXM6IFsid29ya2VyLWFwaS48Z2F0ZXdheS1k" + + "b21haW4+Il0KICAgICAgbnZjdEFwaToKICAgICAgICBncnBjOgogICAgICAgICAgZW5hYmxlZDog" + + "dHJ1ZQogICAgICAgICAgaG9zdG5hbWVzOiBbIndvcmtlci10YXNrcy48Z2F0ZXdheS1kb21haW4+" + + "Il0KICAgICAgbmF0czoKICAgICAgICBlbmFibGVkOiB0cnVlCgpvcGVuYmFvOgogIG1pZ3JhdGlv" + + "bnM6CiAgICBpc3N1ZXJEaXNjb3Zlcnk6CiAgICAgIGVuYWJsZWQ6IHRydWUKYGBgCgpgYGB5YW1s" + + "CiMgZGVwbG95L3N0YWNrcy9udmNmLWNvbXB1dGUtcGxhbmUvZW52aXJvbm1lbnRzLzxlbnY+Lnlh" + + "bWwKZ2xvYmFsOgogIG52Y2FPcGVyYXRvcjoKICAgIHNlbGZNYW5hZ2VkOgogICAgICBpY21zU2Vy" + + "dmljZVVSTDogImh0dHA6Ly88Z2F0ZXdheS1hZGRyZXNzPiIKICAgICAgaWNtc1NlcnZpY2VIb3N0" + + "SGVhZGVyT3ZlcnJpZGU6ICJzaXMuPGdhdGV3YXktZG9tYWluPiIKICAgICAgcmV2YWxTZXJ2aWNl" + + "VVJMOiAiaHR0cDovLzxnYXRld2F5LWFkZHJlc3M+IgogICAgICByZXZhbFNlcnZpY2VIb3N0SGVh" + + "ZGVyT3ZlcnJpZGU6ICJyZXZhbC48Z2F0ZXdheS1kb21haW4+IgogICAgICBuYXRzVVJMOiAibmF0" + + "czovLzxnYXRld2F5LWFkZHJlc3M+OjQyMjIiCiAgICAgIG5hdHNIb3N0T3ZlcnJpZGU6ICJuYXRz" + + "LjxnYXRld2F5LWRvbWFpbj4iCmBgYAoKUHJldmlldyBhbmQgaW5zdGFsbCB0aGUgY29udHJvbCBw" + + "bGFuZSBhZ2FpbnN0IGl0cyBjb250ZXh0OgoKYGBgYmFzaAptYWtlIC1DIGRlcGxveS9zdGFja3Mv" + + "c2VsZi1tYW5hZ2VkIHRlbXBsYXRlIFwKICBIRUxNRklMRV9FTlY9PGVudj4gXAogIEtVQkVDT05G" + + "SUdfRklMRT08Y29udHJvbC1wbGFuZS1rdWJlY29uZmlnPgoKbWFrZSAtQyBkZXBsb3kvc3RhY2tz" + + "L3NlbGYtbWFuYWdlZCBpbnN0YWxsIFwKICBIRUxNRklMRV9FTlY9PGVudj4gXAogIEtVQkVDT05G" + + "SUdfRklMRT08Y29udHJvbC1wbGFuZS1rdWJlY29uZmlnPgpgYGAKCkJlZm9yZSByZWdpc3Rlcmlu" + + "ZyB0aHJvdWdoIGEgYmFyZSBHYXRld2F5IGFkZHJlc3MsIGNyZWF0ZSBvciB1cGRhdGUgdGhlIENM" + + "SQpjb25maWcgcGFzc2VkIGFzIGBOVkNGX0NMSV9DT05GSUdgOgoKYGBgeWFtbApiYXNlX2h0dHBf" + + "dXJsOiAiaHR0cDovLzxnYXRld2F5LWFkZHJlc3M+IgppbnZva2VfdXJsOiAiaHR0cDovLzxnYXRl" + + "d2F5LWFkZHJlc3M+IgpiYXNlX2dycGNfdXJsOiAiPGdhdGV3YXktYWRkcmVzcz46MTAwODEiCmFw" + + "aV9rZXlzX3NlcnZpY2VfdXJsOiAiaHR0cDovLzxnYXRld2F5LWFkZHJlc3M+IgppY21zX3VybDog" + + "Imh0dHA6Ly88Z2F0ZXdheS1hZGRyZXNzPiIKYXBpX2hvc3Q6ICJhcGkuPGdhdGV3YXktZG9tYWlu" + + "PiIKYXBpX2tleXNfaG9zdDogImFwaS1rZXlzLjxnYXRld2F5LWRvbWFpbj4iCmludm9rZV9ob3N0" + + "OiAiaW52b2NhdGlvbi48Z2F0ZXdheS1kb21haW4+IgppY21zX2hvc3Q6ICJzaXMuPGdhdGV3YXkt" + + "ZG9tYWluPiIKYGBgCgpIb3N0IGZpZWxkcyBjb250YWluIGhvc3RuYW1lcyBvbmx5LCB3aXRob3V0" + + "IGEgVVJMIHNjaGVtZS4gYElDTVNfVVJMYCBtYXBzIG9ubHkKdG8gdGhlIHJlZ2lzdHJhdGlvbiBj" + + "b21tYW5kJ3MgYC0taWNtcy11cmxgOyBgaWNtc19ob3N0YCBpbiB0aGUgY29uZmlnIHN1cHBsaWVz" + + "CnRoZSBHYXRld2F5IEhvc3QgaGVhZGVyLiBUaGVyZSBpcyBubyBgLS1pY21zLWhvc3RgIE1ha2Ug" + + "b3IgQ0xJIGZsYWcuCgpSZWdpc3RlciBmcm9tIHRoZSBjb21wdXRlIGNvbnRleHQsIHRoZW4gaW5z" + + "dGFsbCB0aGUgY29tcHV0ZSBwbGFuZToKCmBgYGJhc2gKbWFrZSAtQyBkZXBsb3kvc3RhY2tzL252" + + "Y2YtY29tcHV0ZS1wbGFuZSByZWdpc3Rlci1jbHVzdGVyIFwKICBDTFVTVEVSX05BTUU9PGNsdXN0" + + "ZXItbmFtZT4gXAogIE5DQV9JRD08bmNhLWlkPiBcCiAgQ0xVU1RFUl9SRUdJT049PHJlZ2lvbj4g" + + "XAogIElDTVNfVVJMPWh0dHA6Ly88Z2F0ZXdheS1hZGRyZXNzPiBcCiAgS1VCRUNPTkZJR19GSUxF" + + "PTxjb21wdXRlLXBsYW5lLWt1YmVjb25maWc+IFwKICBOVkNGX0NMST08cGF0aC10by1udmNmLWNs" + + "aT4gXAogIE5WQ0ZfQ0xJX0NPTkZJRz08cGF0aC10by1udmNmLWNsaS1jb25maWc+CgptYWtlIC1D" + + "IGRlcGxveS9zdGFja3MvbnZjZi1jb21wdXRlLXBsYW5lIGluc3RhbGwgXAogIENMVVNURVJfTkFN" + + "RT08Y2x1c3Rlci1uYW1lPiBcCiAgSEVMTUZJTEVfRU5WPTxlbnY+IFwKICBLVUJFQ09ORklHX0ZJ" + + "TEU9PGNvbXB1dGUtcGxhbmUta3ViZWNvbmZpZz4KYGBgCgpSZWdpc3RyYXRpb24gZGlzY292ZXJz" + + "IHRoZSBPSURDIGlzc3VlciBhbmQgSldLUyBmcm9tIHRoZSBjb21wdXRlIGt1YmUgY29udGV4dC4K" + + "SW4gYSBtdWx0aS1jbHVzdGVyIGRlcGxveW1lbnQsIGBLVUJFQ09ORklHX0ZJTEVgIGlzIHJlcXVp" + + "cmVkIG9uIGJvdGgKY29tcHV0ZS1wbGFuZSBjb21tYW5kcy4gSW4gYSBzYW1lLWNsdXN0ZXIgZGVw" + + "bG95bWVudCBpdCBtYXkgYmUgb21pdHRlZCBvbmx5CndoZW4gdGhlIGFtYmllbnQgY29udGV4dCBp" + + "cyBhbHJlYWR5IHRoZSB0YXJnZXQgY2x1c3Rlci4KCiMjIENMSSBQcm9maWxlIEZsb3cKClJ1biB0" + + "aGUgQ0xJIGNvbnRyb2wtcGxhbmUgaW5zdGFsbCBmaXJzdC4gSXQgY3JlYXRlcyB0aGUgcHJvZmls" + + "ZSBjb25zdW1lZCBieQpjb21wdXRlLXBsYW5lIHJlZ2lzdHJhdGlvbjoKCmBgYGJhc2gKbnZjZi1j" + + "bGkgLS1jb25maWcgPGNvbmZpZz4gc2VsZi1ob3N0ZWQgXAogIC0tY29udHJvbC1wbGFuZS1zdGFj" + + "ayBkZXBsb3kvc3RhY2tzL3NlbGYtbWFuYWdlZCBcCiAgLS1jb21wdXRlLXBsYW5lLXN0YWNrIGRl" + + "cGxveS9zdGFja3MvbnZjZi1jb21wdXRlLXBsYW5lIFwKICAtLWVudiA8ZW52PiBcCiAgLS1wbGFp" + + "biBcCiAgLS1jb250cm9sLXBsYW5lLWNvbnRleHQgPGNvbnRyb2wtcGxhbmUtY29udGV4dD4gXAog" + + "IC0tY29tcHV0ZS1wbGFuZS1jb250ZXh0IDxjb21wdXRlLXBsYW5lLWNvbnRleHQ+IFwKICBpbnN0" + + "YWxsIC0tY29udHJvbC1wbGFuZSBcCiAgLS1jbHVzdGVyLW5hbWUgPGNvbnRyb2wtcGxhbmUtY2x1" + + "c3Rlci1uYW1lPiBcCiAgLS1yZWdpb24gPHJlZ2lvbj4gXAogIC0tbmNhLWlkIDxuY2EtaWQ+Cgp0" + + "ZXN0IC1zIGRlcGxveS9zdGFja3Mvc2VsZi1tYW5hZ2VkL291dC9jb250cm9sLXBsYW5lLXByb2Zp" + + "bGUueWFtbApgYGAKClVzZSB0aGUgZnVsbCBwZXJzaXN0ZW50IHByZWZpeCBmb3IgYm90aCBjb21w" + + "dXRlLXBsYW5lIGNvbW1hbmRzOgoKYGBgYmFzaApudmNmLWNsaSAtLWNvbmZpZyA8Y29uZmlnPiBz" + + "ZWxmLWhvc3RlZCBcCiAgLS1jb250cm9sLXBsYW5lLXN0YWNrIGRlcGxveS9zdGFja3Mvc2VsZi1t" + + "YW5hZ2VkIFwKICAtLWNvbXB1dGUtcGxhbmUtc3RhY2sgZGVwbG95L3N0YWNrcy9udmNmLWNvbXB1" + + "dGUtcGxhbmUgXAogIC0tZW52IDxlbnY+IFwKICAtLXBsYWluIFwKICBjb21wdXRlLXBsYW5lIHJl" + + "Z2lzdGVyIFwKICAtLWNvbnRyb2wtcGxhbmUtcHJvZmlsZSBkZXBsb3kvc3RhY2tzL3NlbGYtbWFu" + + "YWdlZC9vdXQvY29udHJvbC1wbGFuZS1wcm9maWxlLnlhbWwgXAogIC0tY2x1c3Rlci1uYW1lIDxj" + + "b21wdXRlLXBsYW5lLWNsdXN0ZXItbmFtZT4gXAogIC0ta3ViZS1jb250ZXh0IDxjb21wdXRlLXBs" + + "YW5lLWNvbnRleHQ+IFwKICAtLXJlZ2lvbiA8cmVnaW9uPiBcCiAgLS1vdXRwdXQgZGVwbG95L3N0" + + "YWNrcy9udmNmLWNvbXB1dGUtcGxhbmUvb3V0Lzxjb21wdXRlLXBsYW5lLWNsdXN0ZXItbmFtZT4t" + + "cmVnaXN0ZXItdmFsdWVzLnlhbWwKCm52Y2YtY2xpIC0tY29uZmlnIDxjb25maWc+IHNlbGYtaG9z" + + "dGVkIFwKICAtLWNvbnRyb2wtcGxhbmUtc3RhY2sgZGVwbG95L3N0YWNrcy9zZWxmLW1hbmFnZWQg" + + "XAogIC0tY29tcHV0ZS1wbGFuZS1zdGFjayBkZXBsb3kvc3RhY2tzL252Y2YtY29tcHV0ZS1wbGFu" + + "ZSBcCiAgLS1lbnYgPGVudj4gXAogIC0tcGxhaW4gXAogIGNvbXB1dGUtcGxhbmUgaW5zdGFsbCBc" + + "CiAgLS12YWx1ZXMgZGVwbG95L3N0YWNrcy9udmNmLWNvbXB1dGUtcGxhbmUvb3V0Lzxjb21wdXRl" + + "LXBsYW5lLWNsdXN0ZXItbmFtZT4tcmVnaXN0ZXItdmFsdWVzLnlhbWwgXAogIC0ta3ViZS1jb250" + + "ZXh0IDxjb21wdXRlLXBsYW5lLWNvbnRleHQ+IFwKICAtLWNsdXN0ZXItbmFtZSA8Y29tcHV0ZS1w" + + "bGFuZS1jbHVzdGVyLW5hbWU+CmBgYAoKUmVnaXN0cmF0aW9uIHNlbGVjdHMgdGhlIHByb2ZpbGUn" + + "cyBpbi1jbHVzdGVyIG9yIGNvbXB1dGUtcmVhY2hhYmxlIGVuZHBvaW50cwpmcm9tIHRoZSBjb21w" + + "dXRlIGNvbnRleHQgYW5kIHByb2JlcyBpdHMgSldLUy4gRG8gbm90IHJlcGxhY2UgcHJvZmlsZSBl" + + "bmRwb2ludHMKd2l0aCBoYW5kLWF1dGhvcmVkIEhlbG1maWxlIGVuZHBvaW50IHZhbHVlcy4KCiMj" + + "IFB1bGwgU2VjcmV0cwoKQ3JlYXRlIHRoZSBjb250cm9sLXBsYW5lIHNlY3JldCBpbiB0aGVzZSBu" + + "YW1lc3BhY2VzIG9uIHRoZSBjb250cm9sLXBsYW5lCmNvbnRleHQ6CgpgYGB0ZXh0CmNhc3NhbmRy" + + "YS1zeXN0ZW0gbmF0cy1zeXN0ZW0gbnZjZiBhcGkta2V5cyBlc3Mgc2lzIHZhdWx0LXN5c3RlbSBj" + + "ZXJ0LW1hbmFnZXIKYGBgCgpPbiB0aGUgY29tcHV0ZSBjb250ZXh0LCBjcmVhdGUgdGhlIHNlY3Jl" + + "dCBvbmx5IGluIGBudmNhLW9wZXJhdG9yYCBhbmQgcmVmZXJlbmNlCml0IHRocm91Z2ggYGdsb2Jh" + + "bC5pbWFnZVB1bGxTZWNyZXRzYCBpbiB0aGUgY29tcHV0ZS1wbGFuZSBlbnZpcm9ubWVudC4gVGhl" + + "IGNoYXJ0CmFuZCBvcGVyYXRvciB1c2UgaXQgaW4gYG52Y2Etb3BlcmF0b3JgIGFuZCBtaXJyb3Ig" + + "aXQgdG8gYG52Y2Etc3lzdGVtYC4gRG8gbm90IGFkZAplaXRoZXIgbmFtZXNwYWNlIHRvIHRoZSBj" + + "b250cm9sLXBsYW5lIGxpc3QuIEZvciBjb21tYW5kcyBhbmQgcG9saWN5IGV4YW1wbGVzLApzZWUg" + + "W3B1bGwtc2VjcmV0cy5tZF0ocHVsbC1zZWNyZXRzLm1kKS4KCiMjIFZlcmlmaWNhdGlvbgoKVXNl" + + "IHRoZSBleHBsaWNpdCBHYXRld2F5IG5hbWUgYW5kIG5hbWVzcGFjZToKCmBgYGJhc2gKa3ViZWN0" + + "bCAtLWNvbnRleHQgPGNvbnRyb2wtcGxhbmUtY29udGV4dD4gZ2V0IGdhdGV3YXkgbnZjZi1nYXRl" + + "d2F5IFwKICAtbiBlbnZveS1nYXRld2F5IC1vIHdpZGUKa3ViZWN0bCAtLWNvbnRleHQgPGNvbnRy" + + "b2wtcGxhbmUtY29udGV4dD4gZ2V0IHRjcHJvdXRlIC1uIGVudm95LWdhdGV3YXkKa3ViZWN0bCAt" + + "LWNvbnRleHQgPGNvbXB1dGUtcGxhbmUtY29udGV4dD4gcm9sbG91dCBzdGF0dXMgXAogIGRlcGxv" + + "eW1lbnQvbnZjYS1vcGVyYXRvciAtbiBudmNhLW9wZXJhdG9yIC0tdGltZW91dD0xMG0Ka3ViZWN0" + + "bCAtLWNvbnRleHQgPGNvbXB1dGUtcGxhbmUtY29udGV4dD4gd2FpdCBcCiAgbnZjZmJhY2tlbmQv" + + "PGNvbXB1dGUtcGxhbmUtY2x1c3Rlci1uYW1lPiAtbiBudmNhLW9wZXJhdG9yIFwKICAtLWZvcj1q" + + "c29ucGF0aD0ney5zdGF0dXMuYWdlbnRTdGF0dXN9Jz1oZWFsdGh5IC0tdGltZW91dD0xMG0Ka3Vi" + + "ZWN0bCAtLWNvbnRleHQgPGNvbXB1dGUtcGxhbmUtY29udGV4dD4gZ2V0IHNlY3JldCA8cHVsbC1z" + + "ZWNyZXQ+IC1uIG52Y2Etc3lzdGVtCmBgYAoKIyMgVGVhcmRvd24KCkRlc3Ryb3kgYW5kIGRlcmVn" + + "aXN0ZXIgZXZlcnkgY29tcHV0ZSBwbGFuZSBiZWZvcmUgdGhlIGNvbnRyb2wgcGxhbmUuIEJvdGgK" + + "aGFuZG9mZnMgY2FuIGRlc3Ryb3kgdGhlIGNvbnRyb2wgcGxhbmUsIHNvIGFwcGx5IHRoaXMgcHJl" + + "ZmxpZ2h0IGJlZm9yZSBlaXRoZXIKb25lLiBQcmVzZXJ2ZSB0aGUgYGNlcnQtbWFuYWdlcmAgbmFt" + + "ZXNwYWNlIGJ5IGRlZmF1bHQuIE5hbWVzcGFjZSBwcmVzZXJ2YXRpb24KZG9lcyBub3QgcHJlc2Vy" + + "dmUgdGhlIEhlbG0gcmVsZWFzZS4gSWRlbnRpZnkgd2hldGhlciBjZXJ0LW1hbmFnZXIgaXMgZXh0" + + "ZXJuYWwuCkZvciBhbiBleHRlcm5hbCBpbnN0YWxsYXRpb24sIHJlcXVpcmUgZWZmZWN0aXZlIGBj" + + "ZXJ0TWFuYWdlci5lbmFibGVkOiBmYWxzZWAKYW5kIGFib3J0IGlmIGl0IGlzIHRydWUuIEZvciBh" + + "biBpbnRlbmRlZCBzdGFjay1tYW5hZ2VkIHJlbGVhc2Ugd2l0aCBlZmZlY3RpdmUKYGNlcnRNYW5h" + + "Z2VyLmVuYWJsZWQ6IHRydWVgLCB2ZXJpZnkgbWF0Y2hpbmcgc3RhY2sgSGVsbSByZWxlYXNlIG1l" + + "dGFkYXRhIGFuZAphYm9ydCBvbiBtaXNzaW5nIG9yIG1pc21hdGNoZWQgZXZpZGVuY2UuIE9ubHkg" + + "cGxhbiBuYW1lc3BhY2UgcmVtb3ZhbCBhZnRlcgp2ZXJpZnlpbmcgbmFtZXNwYWNlIHByb3ZlbmFu" + + "Y2UgYW5kIGdldHRpbmcgZXhwbGljaXQgY29uZmlybWF0aW9uOyBvdGhlcndpc2UKZG8gbm90IGRl" + + "bGV0ZSBpdC4KCkZvciB0aGUgSGVsbWZpbGUgdmFsdWVzIGZsb3csIHJldGFpbiBlYWNoIHJlZ2lz" + + "dHJhdGlvbiB2YWx1ZXMgZmlsZSB1bnRpbApjbGVhbnVwIGlzIHZlcmlmaWVkOgoKYGBgYmFzaApt" + + "YWtlIC1DIGRlcGxveS9zdGFja3MvbnZjZi1jb21wdXRlLXBsYW5lIGRlc3Ryb3kgXAogIENMVVNU" + + "RVJfTkFNRT08Y2x1c3Rlci1uYW1lPiBcCiAgSEVMTUZJTEVfRU5WPTxlbnY+IFwKICBLVUJFQ09O" + + "RklHX0ZJTEU9PGNvbXB1dGUtcGxhbmUta3ViZWNvbmZpZz4KCjxudmNmLWNsaT4gLS1jb25maWcg" + + "PGNvbmZpZz4gY2x1c3RlciBkZWxldGUgXAogIC0tY2x1c3Rlci1pZCA8Y2x1c3Rlci1pZC1mcm9t" + + "LXJlZ2lzdHJhdGlvbi12YWx1ZXM+IFwKICAtLW5jYS1pZCA8bmNhLWlkPiBcCiAgLS1pZ25vcmUt" + + "bWlzc2luZwpgYGAKClJlYWQgYGNsdXN0ZXJJRGAgYW5kIGBuY2FJRGAgZnJvbQpgZGVwbG95L3N0" + + "YWNrcy9udmNmLWNvbXB1dGUtcGxhbmUvcmVnaXN0cmF0aW9uLzxjbHVzdGVyLW5hbWU+LXJlZ2lz" + + "dGVyLXZhbHVlcy55YW1sYC4KU2hvdyB0aGUgZXhhY3QgY2x1c3RlciBJRCBhbmQgZ2V0IGNvbmZp" + + "cm1hdGlvbiBiZWZvcmUgYGNsdXN0ZXIgZGVsZXRlYC4gUmVwZWF0CmNvbXB1dGUgZGVzdHJveSBh" + + "bmQgZGVyZWdpc3RyYXRpb24gZm9yIGV2ZXJ5IGNvbXB1dGUgY2x1c3RlciwgdGhlbiBkZXN0cm95" + + "IHRoZQpjb250cm9sIHBsYW5lLgoKYGBgYmFzaApLVUJFQ09ORklHPTxjb250cm9sLXBsYW5lLWt1" + + "YmVjb25maWc+IFwKbWFrZSAtQyBkZXBsb3kvc3RhY2tzL3NlbGYtbWFuYWdlZCBkZXN0cm95IFwK" + + "ICBIRUxNRklMRV9FTlY9PGVudj4gXAogIEtVQkVDT05GSUdfRklMRT08Y29udHJvbC1wbGFuZS1r" + + "dWJlY29uZmlnPgpgYGAKCkJvdGggYEtVQkVDT05GSUdgIGFuZCBgS1VCRUNPTkZJR19GSUxFYCBh" + + "cmUgcmVxdWlyZWQgb24gdGhlIGNvbnRyb2wtcGxhbmUKZGVzdHJveSBiZWNhdXNlIGl0cyBuYW1l" + + "c3BhY2UgY2xlYW51cCB1c2VzIGFtYmllbnQgYGt1YmVjdGxgLgoKRm9yIHRoZSBDTEkgcHJvZmls" + + "ZSBmbG93LCBrZWVwCmBkZXBsb3kvc3RhY2tzL252Y2YtY29tcHV0ZS1wbGFuZS9vdXQvPGNsdXN0" + + "ZXItbmFtZT4tcmVnaXN0ZXItdmFsdWVzLnlhbWxgCnVudGlsIHRlYXJkb3duIGNvbXBsZXRlcyBi" + + "ZWNhdXNlIGBkb3duYCByZWFkcyBpdHMgY2x1c3RlciBJRC4gRmlyc3QgcXVlcnkgdGhlCmxpdmUg" + + "cmVnaXN0cmF0aW9uIHNldCB3aXRoIHRoZSBzYW1lIGNvbXBsZXRlIHBlcnNpc3RlbnQgcHJlZml4" + + "OgoKYGBgYmFzaApudmNmLWNsaSAtLWNvbmZpZyA8Y29uZmlnPiBzZWxmLWhvc3RlZCBcCiAgLS1j" + + "b250cm9sLXBsYW5lLXN0YWNrIGRlcGxveS9zdGFja3Mvc2VsZi1tYW5hZ2VkIFwKICAtLWNvbXB1" + + "dGUtcGxhbmUtc3RhY2sgZGVwbG95L3N0YWNrcy9udmNmLWNvbXB1dGUtcGxhbmUgXAogIC0tZW52" + + "IDxlbnY+IFwKICAtLXBsYWluIFwKICAtLWNvbnRyb2wtcGxhbmUtY29udGV4dCA8Y29udHJvbC1w" + + "bGFuZS1jb250ZXh0PiBcCiAgLS1jb21wdXRlLXBsYW5lLWNvbnRleHQgPGNvbXB1dGUtcGxhbmUt" + + "Y29udGV4dD4gXAogIC0taWNtcy11cmwgPGNvbXB1dGUtcmVhY2hhYmxlLWljbXMtdXJsPiBcCiAg" + + "c3RhdHVzIFwKICAtLWNsdXN0ZXItbmFtZSA8Y29tcHV0ZS1wbGFuZS1jbHVzdGVyLW5hbWU+IFwK" + + "ICAtLW5jYS1pZCA8bmNhLWlkPgpgYGAKClNob3cgdGhlIHJlZ2lzdGVyZWQgY29tcHV0ZS1wbGFu" + + "ZSBsaXN0LiBOYW1lZC1jbHVzdGVyIGBkb3duIC0tcGxhbi1vbmx5YCBkb2VzCm5vdCBxdWVyeSBJ" + + "Q01TLCBzbyBpdCBwcmV2aWV3cyBvbmx5IHRoYXQgY29tcHV0ZSBwbGFuZSBhbmQgY2Fubm90IHNo" + + "b3cgdGhlCmNvbmRpdGlvbmFsIGNvbnRyb2wtcGxhbmUgcmVtb3ZhbC4gSWYgdGhlIHRhcmdldCBp" + + "cyB0aGUgbGFzdCByZWdpc3RlcmVkCmNsdXN0ZXIsIHJlYWwgYGRvd25gIGFsc28gZGVzdHJveXMg" + + "dGhlIGNvbnRyb2wgcGxhbmUuIEdldCBleHBsaWNpdCBjb25maXJtYXRpb24KZm9yIGJvdGggcmVt" + + "b3ZhbHMgYmVmb3JlIGNvbnRpbnVpbmcuIFRoZW4gcHJldmlldyBhbmQgZXhlY3V0ZSB3aXRoIHRo" + + "ZSBzYW1lCnByZWZpeDoKCmBgYGJhc2gKbnZjZi1jbGkgLS1jb25maWcgPGNvbmZpZz4gc2VsZi1o" + + "b3N0ZWQgXAogIC0tY29udHJvbC1wbGFuZS1zdGFjayBkZXBsb3kvc3RhY2tzL3NlbGYtbWFuYWdl" + + "ZCBcCiAgLS1jb21wdXRlLXBsYW5lLXN0YWNrIGRlcGxveS9zdGFja3MvbnZjZi1jb21wdXRlLXBs" + + "YW5lIFwKICAtLWVudiA8ZW52PiBcCiAgLS1wbGFpbiBcCiAgLS1jb250cm9sLXBsYW5lLWNvbnRl" + + "eHQgPGNvbnRyb2wtcGxhbmUtY29udGV4dD4gXAogIC0tY29tcHV0ZS1wbGFuZS1jb250ZXh0IDxj" + + "b21wdXRlLXBsYW5lLWNvbnRleHQ+IFwKICAtLWljbXMtdXJsIDxjb21wdXRlLXJlYWNoYWJsZS1p" + + "Y21zLXVybD4gXAogIGRvd24gLS1wbGFuLW9ubHkgXAogIC0tY2x1c3Rlci1uYW1lIDxjb21wdXRl" + + "LXBsYW5lLWNsdXN0ZXItbmFtZT4gXAogIC0tbmNhLWlkIDxuY2EtaWQ+CgpudmNmLWNsaSAtLWNv" + + "bmZpZyA8Y29uZmlnPiBzZWxmLWhvc3RlZCBcCiAgLS1jb250cm9sLXBsYW5lLXN0YWNrIGRlcGxv" + + "eS9zdGFja3Mvc2VsZi1tYW5hZ2VkIFwKICAtLWNvbXB1dGUtcGxhbmUtc3RhY2sgZGVwbG95L3N0" + + "YWNrcy9udmNmLWNvbXB1dGUtcGxhbmUgXAogIC0tZW52IDxlbnY+IFwKICAtLXBsYWluIFwKICAt" + + "LWNvbnRyb2wtcGxhbmUtY29udGV4dCA8Y29udHJvbC1wbGFuZS1jb250ZXh0PiBcCiAgLS1jb21w" + + "dXRlLXBsYW5lLWNvbnRleHQgPGNvbXB1dGUtcGxhbmUtY29udGV4dD4gXAogIC0taWNtcy11cmwg" + + "PGNvbXB1dGUtcmVhY2hhYmxlLWljbXMtdXJsPiBcCiAgZG93biBcCiAgLS1jbHVzdGVyLW5hbWUg" + + "PGNvbXB1dGUtcGxhbmUtY2x1c3Rlci1uYW1lPiBcCiAgLS1uY2EtaWQgPG5jYS1pZD4KYGBgCgpS" + + "ZXBlYXQgYGRvd25gIGZvciBlYWNoIGNvbXB1dGUgY2x1c3Rlci4gRWFjaCBydW4gZGVzdHJveXMg" + + "dGhhdCBjb21wdXRlIHBsYW5lIGFuZAp1bnJlZ2lzdGVycyBpdHMgSUNNUyByb3cuIEl0IHJlbW92" + + "ZXMgdGhlIGNvbnRyb2wgcGxhbmUgb25seSBhZnRlciBubyBjbHVzdGVyCnJlZ2lzdHJhdGlvbnMg" + + "cmVtYWluLgpQSwcIlmO8WRIwAAASMAAAUEsDBBQACAAAAAAAIQAAAAAAAAAAAAAAAAA7AAkAZGF0" + + "YS9udmNmLXNlbGYtbWFuYWdlZC1pbnN0YWxsYXRpb24vcmVmZXJlbmNlcy9kZWJ1Z2dpbmcubWRV" + + "VAUAAQCmzhIjIERlYnVnZ2luZyBSZWZlcmVuY2UKClJlY2lwZXMgZm9yIGRpYWdub3NpbmcgYW5k" + + "IGZpeGluZyBjb21tb24gTlZDRiBzZWxmLW1hbmFnZWQgc3RhY2sgZmFpbHVyZXMuCgojIyBRdWlj" + + "ayBTdGF0dXMgQ29tbWFuZHMKCmBgYGJhc2gKIyBBbGwgcG9kcyBhY3Jvc3MgYWxsIG5hbWVzcGFj" + + "ZXMKa3ViZWN0bCBnZXQgcG9kcyAtQSAtbyB3aWRlCgojIFBvZHMgaW4gYSBzcGVjaWZpYyBuYW1l" + + "c3BhY2UKa3ViZWN0bCBnZXQgcG9kcyAtbiA8bmFtZXNwYWNlPgoKIyBBbGwgaGVsbSByZWxlYXNl" + + "cwpoZWxtIGxpc3QgLUEKCiMgUmVjZW50IGV2ZW50cyAobW9zdCB1c2VmdWwgZm9yIGRpYWdub3Np" + + "bmcgZmFpbHVyZXMpCmt1YmVjdGwgZ2V0IGV2ZW50cyAtbiA8bmFtZXNwYWNlPiAtLXNvcnQtYnk9" + + "Jy5sYXN0VGltZXN0YW1wJwoKIyBEZXNjcmliZSBhIHNwZWNpZmljIHBvZCAoc2hvd3MgZXZlbnRz" + + "LCBjb25kaXRpb25zLCB2b2x1bWVzKQprdWJlY3RsIGRlc2NyaWJlIHBvZCAtbiA8bmFtZXNwYWNl" + + "PiA8cG9kLW5hbWU+CmBgYAoKIyMgRmFpbHVyZTogSW1hZ2VQdWxsQmFja09mZgoKIyMjIFN5bXB0" + + "b21zCgpgYGAKTkFNRSAgICAgICAgICAgUkVBRFkgICBTVEFUVVMgICAgICAgICAgICAgUkVTVEFS" + + "VFMgICBBR0UKY2Fzc2FuZHJhLTAgICAgMC8xICAgICBJbWFnZVB1bGxCYWNrT2ZmICAgMCAgICAg" + + "ICAgICA1bQpgYGAKCkV2ZW50cyBzaG93OgpgYGAKRmFpbGVkIHRvIHB1bGwgaW1hZ2UgIm52Y3Iu" + + "aW8vLi4uL2ltYWdlOnRhZyI6IDQwMSBVbmF1dGhvcml6ZWQKYGBgCgojIyMgRGlhZ25vc2lzCgpg" + + "YGBiYXNoCiMgQ2hlY2sgd2hhdCBpbWFnZSBpcyBmYWlsaW5nCmt1YmVjdGwgZGVzY3JpYmUgcG9k" + + "IC1uIDxuYW1lc3BhY2U+IDxwb2QtbmFtZT4gfCBncmVwIC1BNSAiRXZlbnRzOiIKCiMgQ2hlY2sg" + + "aWYgcHVsbCBzZWNyZXQgZXhpc3RzIGluIHRoZSBuYW1lc3BhY2UKa3ViZWN0bCBnZXQgc2VjcmV0" + + "IG52Y3ItY3JlZHMgLW4gPG5hbWVzcGFjZT4KCiMgQ2hlY2sgaWYgdGhlIHBvZCBzcGVjIGhhcyBp" + + "bWFnZVB1bGxTZWNyZXRzCmt1YmVjdGwgZ2V0IHBvZCAtbiA8bmFtZXNwYWNlPiA8cG9kLW5hbWU+" + + "IC1vIGpzb25wYXRoPSd7LnNwZWMuaW1hZ2VQdWxsU2VjcmV0c30nCgojIENoZWNrIGlmIHRoZSBT" + + "ZXJ2aWNlQWNjb3VudCBoYXMgaW1hZ2VQdWxsU2VjcmV0cwprdWJlY3RsIGdldCBzYSA8c2EtbmFt" + + "ZT4gLW4gPG5hbWVzcGFjZT4gLW8ganNvbnBhdGg9J3suaW1hZ2VQdWxsU2VjcmV0c30nCmBgYAoK" + + "IyMjIEZpeGVzCgoxLiAqKlNlY3JldCBtaXNzaW5nIGluIG5hbWVzcGFjZSoqOiBDcmVhdGUgaXQK" + + "ICAgYGBgYmFzaAogICBrdWJlY3RsIGNyZWF0ZSBzZWNyZXQgZG9ja2VyLXJlZ2lzdHJ5IG52Y3It" + + "Y3JlZHMgXAogICAgIC0tZG9ja2VyLXNlcnZlcj1udmNyLmlvIFwKICAgICAtLWRvY2tlci11c2Vy" + + "bmFtZT0nJG9hdXRodG9rZW4nIFwKICAgICAtLWRvY2tlci1wYXNzd29yZD0iJE5HQ19BUElfS0VZ" + + "IiBcCiAgICAgLS1uYW1lc3BhY2U9PG5hbWVzcGFjZT4gXAogICAgIC0tZHJ5LXJ1bj1jbGllbnQg" + + "LW8geWFtbCB8IGt1YmVjdGwgYXBwbHkgLWYgLQogICBgYGAKCjIuICoqU2VjcmV0IGV4aXN0cyBi" + + "dXQgcG9kIGRvZXNuJ3QgcmVmZXJlbmNlIGl0Kio6IFRoZSBjaGFydCBuZWVkcyBgaW1hZ2VQdWxs" + + "U2VjcmV0c2AgY29uZmlndXJlZCB2aWEgaGVsbWZpbGUgdmFsdWVzLiBTZWUgW3B1bGwtc2VjcmV0" + + "cy5tZF0ocHVsbC1zZWNyZXRzLm1kKS4KCjMuICoqQ2hhcnQgZG9lc24ndCBzdXBwb3J0IGltYWdl" + + "UHVsbFNlY3JldHMqKiAob3BlbmJhbywgaW52b2NhdGlvbi1zZXJ2aWNlLCBlc3MtYXBpLCBub3Rh" + + "cnktc2VydmljZSk6IFBhdGNoIFNlcnZpY2VBY2NvdW50cyBhbmQgcmVzdGFydCBwb2RzLiBTZWUg" + + "W3B1bGwtc2VjcmV0cy5tZF0ocHVsbC1zZWNyZXRzLm1kKS4KCjQuICoqV3JvbmcgY3JlZGVudGlh" + + "bHMgaW4gc2VjcmV0Kio6IERlbGV0ZSBhbmQgcmVjcmVhdGUKICAgYGBgYmFzaAogICBrdWJlY3Rs" + + "IGRlbGV0ZSBzZWNyZXQgbnZjci1jcmVkcyAtbiA8bmFtZXNwYWNlPgogICAjIFJlY3JlYXRlIHdp" + + "dGggY29ycmVjdCBjcmVkZW50aWFscwogICBgYGAKCiMjIEZhaWx1cmU6IEluaXQ6MC8xIFN0dWNr" + + "IChWYXVsdCBBZ2VudCkKCiMjIyBTeW1wdG9tcwoKU2VydmljZSBwb2RzIHN0dWNrIGluIGBJbml0" + + "OjAvMWAgZm9yIG1pbnV0ZXM6CmBgYApOQU1FICAgICAgICAgICAgICAgICAgICAgICAgUkVBRFkg" + + "ICBTVEFUVVMgICAgIFJFU1RBUlRTICAgQUdFCm52Y2YtYXBpLTdmNGM3NmY3ODgtNDR2bHQgIDAv" + + "MiAgICAgSW5pdDowLzEgICAwICAgICAgICAgIDEwbQpgYGAKCiMjIyBEaWFnbm9zaXMKClRoZSBp" + + "bml0IGNvbnRhaW5lciBpcyB0aGUgdmF1bHQtYWdlbnQtaW5pdCBpbmplY3RvciB3YWl0aW5nIGZv" + + "ciBPcGVuQmFvLgoKYGBgYmFzaAojIENoZWNrIE9wZW5CYW8gcG9kcwprdWJlY3RsIGdldCBwb2Rz" + + "IC1uIHZhdWx0LXN5c3RlbQoKIyBDaGVjayBpZiBPcGVuQmFvIG1pZ3JhdGlvbiBqb2IgcmFuCmt1" + + "YmVjdGwgZ2V0IGpvYnMgLW4gdmF1bHQtc3lzdGVtCgojIENoZWNrIE9wZW5CYW8gcG9kIGxvZ3MK" + + "a3ViZWN0bCBsb2dzIC1uIHZhdWx0LXN5c3RlbSBvcGVuYmFvLXNlcnZlci0wIC1jIG9wZW5iYW8K" + + "CiMgQ2hlY2sgaW5pdCBjb250YWluZXIgbG9ncyBvbiB0aGUgc3R1Y2sgcG9kCmt1YmVjdGwgbG9n" + + "cyAtbiA8bmFtZXNwYWNlPiA8cG9kLW5hbWU+IC1jIHZhdWx0LWFnZW50LWluaXQKYGBgCgojIyMg" + + "Rml4ZXMKCjEuICoqT3BlbkJhbyBwb2RzIG5vdCBydW5uaW5nKio6IENoZWNrIHRoZWlyIGV2ZW50" + + "cyBmb3IgaW1hZ2UgcHVsbCBpc3N1ZXMsIHJlc291cmNlIGlzc3VlcywgZXRjLgoKMi4gKipPcGVu" + + "QmFvIG1pZ3JhdGlvbiBqb2IgZGlkbid0IHJ1bioqOiBUaGlzIGhhcHBlbnMgd2hlbiBgaGVsbWZp" + + "bGUgc3luY2Agd2FzIGludGVycnVwdGVkLiBEZXN0cm95IGFuZCByZS1zeW5jIG9wZW5iYW86CiAg" + + "IGBgYGJhc2gKICAgSEVMTUZJTEVfRU5WPTxlbnY+IGhlbG1maWxlIC0tc2VsZWN0b3IgbmFtZT1v" + + "cGVuYmFvLXNlcnZlciBkZXN0cm95CiAgIGt1YmVjdGwgZGVsZXRlIG5hbWVzcGFjZSB2YXVsdC1z" + + "eXN0ZW0KICAga3ViZWN0bCBjcmVhdGUgbmFtZXNwYWNlIHZhdWx0LXN5c3RlbQogICAjIFJlLWNy" + + "ZWF0ZSBwdWxsIHNlY3JldCBpZiBuZWVkZWQKICAgSEVMTUZJTEVfRU5WPTxlbnY+IGhlbG1maWxl" + + "IC0tc2VsZWN0b3IgbmFtZT1vcGVuYmFvLXNlcnZlciBzeW5jCiAgIGBgYAoKMy4gKipPcGVuQmFv" + + "IHBvZHMgcnVubmluZyBidXQgbm90IGluaXRpYWxpemVkKio6IENoZWNrIHVuc2VhbCBzdGF0dXM6" + + "CiAgIGBgYGJhc2gKICAga3ViZWN0bCBleGVjIC1uIHZhdWx0LXN5c3RlbSBvcGVuYmFvLXNlcnZl" + + "ci0wIC1jIG9wZW5iYW8gLS0gYmFvIHN0YXR1cwogICBgYGAKCjQuICoqYHZhdWx0LWFnZW50LWlu" + + "aXRgIGxvZ3MgYGF1dGgvand0L2xvZ2luYCAtPiBgNDAwIC4uLiBubyBrbm93biBrZXkgc3VjY2Vz" + + "c2Z1bGx5IHZhbGlkYXRlZCB0aGUgdG9rZW4gc2lnbmF0dXJlYCoqCiAgIChjb21tb24gb24gQUtT" + + "LCBhbmQgb24gYW55IGNsdXN0ZXIgd2hvc2UgT0lEQyBpc3N1ZXIgcHVibGlzaGVzIGEgcm90YXRp" + + "bmcgbXVsdGkta2V5IEpXS1MpOgogICB0aGUgT3BlbkJhbyBgYXV0aC9qd3RgIG1ldGhvZCB3YXMg" + + "Y29uZmlndXJlZCB3aXRoIGEgc2luZ2xlIHN0YXRpYyBtb3VudGVkIHB1YmxpYyBrZXkKICAgKGBq" + + "d3RfdmFsaWRhdGlvbl9wdWJrZXlzYCkgaW5zdGVhZCBvZiB0aGUgaXNzdWVyJ3MgbGl2ZSBKV0tT" + + "LCBzbyBpdCBjYW5ub3QgdmFsaWRhdGUgdGhlCiAgIGNsdXN0ZXItc2lnbmVkIFNlcnZpY2VBY2Nv" + + "dW50IHRva2VucyB0aGUgdmF1bHQtYWdlbnRzIHByZXNlbnQuIEV2ZXJ5IHNlcnZpY2UncwogICBg" + + "dmF1bHQtYWdlbnQtaW5pdGAgdGhlbiBsb29wcyBvbiB0aGF0IDQwMCBhbmQgdGhlIHBvZCBuZXZl" + + "ciBsZWF2ZXMgYEluaXQ6MC8xYC4gVGhpcyBpcyB0aGUKICAgYmVoYXZpb3Igb2YgdGhlIGJhc2Ug" + + "ZGVmYXVsdCBgb3BlbmJhby5taWdyYXRpb25zLmlzc3VlckRpc2NvdmVyeS5lbmFibGVkOiBmYWxz" + + "ZWA7IHRoZQogICBtaWdyYXRpb24gbG9nIHNob3dzIGBPSURDIGlzc3VlciBkaXNjb3ZlcnkgaXMg" + + "ZGlzYWJsZWQuIFVzaW5nIFNlcnZpY2VBY2NvdW50IGlzc3VlciBhbmQKICAgbW91bnRlZCBwdWJs" + + "aWMga2V5IGZhbGxiYWNrYC4gRW5hYmxlIGlzc3VlciBkaXNjb3Zlcnkgc28gdGhlIG1pZ3JhdGlv" + + "biB1c2VzIHRoZSBsaXZlIEpXS1MsCiAgIHRoZW4gcmUtcnVuIGl0OgogICBgYGBiYXNoCiAgICMg" + + "SW4geW91ciBlbnYgdmFsdWVzIChlLmcuIGVudmlyb25tZW50cy88ZW52Pi55YW1sKSwgc2V0Ogog" + + "ICAjICAgb3BlbmJhbzoKICAgIyAgICAgbWlncmF0aW9uczoKICAgIyAgICAgICBpc3N1ZXJEaXNj" + + "b3Zlcnk6CiAgICMgICAgICAgICBlbmFibGVkOiB0cnVlCiAgIGt1YmVjdGwgZGVsZXRlIGpvYiAt" + + "biB2YXVsdC1zeXN0ZW0gb3BlbmJhby1zZXJ2ZXItbWlncmF0aW9ucwogICBIRUxNRklMRV9FTlY9" + + "PGVudj4gaGVsbWZpbGUgLS1zZWxlY3RvciBuYW1lPW9wZW5iYW8tc2VydmVyIHN5bmMKICAgYGBg" + + "CiAgIFRoZSBtaWdyYXRpb24gbG9nIHNob3VsZCB0aGVuIHNob3cgYFJlY2VpdmVkIGRpc2NvdmVy" + + "eSBkb2N1bWVudCBmcm9tCiAgIC4uLi8ud2VsbC1rbm93bi9vcGVuaWQtY29uZmlndXJhdGlvbmAg" + + "YW5kIGBGaW5hbCBPcGVuQmFvIEpXVCBKV0tTIFVSTCBzZXQgdG86CiAgIC4uLi9vcGVuaWQvdjEv" + + "andrc2AsIGFuZCB0aGUgc2VydmljZSBwb2RzIGF1dGhlbnRpY2F0ZSBhbmQgcmVhY2ggUmVhZHkg" + + "d2l0aGluIH4xIG1pbi4KICAgQUtTIGNsdXN0ZXJzIHdpdGggdGhlIGNsdXN0ZXIgT0lEQyBpc3N1" + + "ZXIgZW5hYmxlZCAodGhlIGBha3MtY2x1c3RlcmAgZGVmYXVsdCkgYWx3YXlzIG5lZWQKICAgdGhp" + + "cyBiZWNhdXNlIHRoZSBzdGF0aWMtcHVia2V5IGZhbGxiYWNrIGNhbm5vdCBtYXRjaCB0aGUgaXNz" + + "dWVyJ3Mgcm90YXRpbmcgc2lnbmluZyBrZXlzLgoKIyMgRmFpbHVyZTogT09NS2lsbGVkIG9uIENh" + + "c3NhbmRyYQoKIyMjIFN5bXB0b21zCgpgYGAKTkFNRSAgICAgICAgICBSRUFEWSAgIFNUQVRVUyAg" + + "ICBSRVNUQVJUUyAgIEFHRQpjYXNzYW5kcmEtMCAgIDAvMSAgICAgT09NS2lsbGVkICAzICAgICAg" + + "ICAgMTBtCmBgYAoKIyMjIERpYWdub3NpcwoKYGBgYmFzaAprdWJlY3RsIGRlc2NyaWJlIHBvZCAt" + + "biBjYXNzYW5kcmEtc3lzdGVtIGNhc3NhbmRyYS0wIHwgZ3JlcCAtQTMgIkxhc3QgU3RhdGUiCmBg" + + "YAoKIyMjIEZpeAoKT3ZlcnJpZGUgQ2Fzc2FuZHJhIHJlc291cmNlcyB2aWEgaGVsbWZpbGUgdmFs" + + "dWVzLiBTZWUgRXhhbXBsZSAxIGluCltleGFtcGxlcy5tZF0oLi4vZXhhbXBsZXMubWQpLgoKYGBg" + + "eWFtbAotIGNhc3NhbmRyYToKICAgIHJlc291cmNlczoKICAgICAgbGltaXRzOgogICAgICAgIGNw" + + "dTogIjgiCiAgICAgICAgbWVtb3J5OiA4MTkyTWkKICAgICAgcmVxdWVzdHM6CiAgICAgICAgY3B1" + + "OiAiMiIKICAgICAgICBtZW1vcnk6IDQwOTZNaQpgYGAKCk5vdGU6IGByZXNvdXJjZVByZXNldGAg" + + "aXMgbm90IGF2YWlsYWJsZSBpbiB0aGUgTlZDRiBjYXNzYW5kcmEgd3JhcHBlciBjaGFydC4gVXNl" + + "IGV4cGxpY2l0IGByZXNvdXJjZXNgLgoKIyMgRmFpbHVyZTogUG9kcyBTdHVjayBpbiBQZW5kaW5n" + + "CgojIyMgU3ltcHRvbXMKCmBgYApOQU1FICAgICAgICAgIFJFQURZICAgU1RBVFVTICAgIFJFU1RB" + + "UlRTICAgQUdFCmNhc3NhbmRyYS0wICAgMC8xICAgICBQZW5kaW5nICAgMCAgICAgICAgICAxMG0K" + + "YGBgCgojIyMgRGlhZ25vc2lzCgpgYGBiYXNoCiMgQ2hlY2sgZXZlbnRzIGZvciBzY2hlZHVsaW5n" + + "IGZhaWx1cmVzCmt1YmVjdGwgZGVzY3JpYmUgcG9kIC1uIDxuYW1lc3BhY2U+IDxwb2QtbmFtZT4K" + + "CiMgQ29tbW9uIGNhdXNlczoKIyAtICIwLzEyIG5vZGVzIGFyZSBhdmFpbGFibGU6IDEyIG5vZGUo" + + "cykgZGlkbid0IG1hdGNoIFBvZCdzIG5vZGUgYWZmaW5pdHkiCiMgLSAiMC8xMiBub2RlcyBhcmUg" + + "YXZhaWxhYmxlOiAxMiBJbnN1ZmZpY2llbnQgbWVtb3J5IgojIC0gInBlcnNpc3RlbnR2b2x1bWVj" + + "bGFpbSBub3QgZm91bmQiCmBgYAoKIyMjIEZpeGVzCgoxLiAqKk5vZGUgc2VsZWN0b3IgbWlzbWF0" + + "Y2gqKjogQ2hlY2sgYG5vZGVTZWxlY3RvcnNgIGluIGVudmlyb25tZW50IGZpbGUKICAgYGBgYmFz" + + "aAogICBrdWJlY3RsIGdldCBub2RlcyAtLXNob3ctbGFiZWxzIHwgZ3JlcCBudmNmCiAgIGBgYAoK" + + "Mi4gKipTdG9yYWdlIGNsYXNzIG5vdCBmb3VuZCoqOiBDaGVjayBzdG9yYWdlIGNsYXNzIGV4aXN0" + + "cwogICBgYGBiYXNoCiAgIGt1YmVjdGwgZ2V0IHN0b3JhZ2VjbGFzcwogICBgYGAKCjMuICoqSW5z" + + "dWZmaWNpZW50IHJlc291cmNlcyoqOiBDaGVjayBub2RlIGNhcGFjaXR5CiAgIGBgYGJhc2gKICAg" + + "a3ViZWN0bCBkZXNjcmliZSBub2RlIDxub2RlLW5hbWU+IHwgZ3JlcCAtQTUgIkFsbG9jYXRlZCBy" + + "ZXNvdXJjZXMiCiAgIGBgYAoKIyMgRmFpbHVyZTogSGVsbSBSZWxlYXNlIGluIEZhaWxlZCBTdGF0" + + "ZQoKIyMjIFN5bXB0b21zCgpgYGBiYXNoCmhlbG0gbGlzdCAtQQojIFNob3dzIHJlbGVhc2Ugd2l0" + + "aCBTVEFUVVM6IGZhaWxlZApgYGAKClJlLXJ1bm5pbmcgYGhlbG1maWxlIHN5bmNgIGFwcGVhcnMg" + + "dG8gc3VjY2VlZCBidXQgc2VydmljZXMgZG9uJ3Qgd29yayAobWlncmF0aW9ucyBza2lwcGVkKS4K" + + "CiMjIyBEaWFnbm9zaXMKCmBgYGJhc2gKaGVsbSBoaXN0b3J5IDxyZWxlYXNlLW5hbWU+IC1uIDxu" + + "YW1lc3BhY2U+CmBgYAoKIyMjIEZpeAoKTXVzdCBkZXN0cm95IHRoZSBmYWlsZWQgcmVsZWFzZSBh" + + "bmQgcmUtc3luYyAobm90IGp1c3QgYXBwbHkpOgoKYGBgYmFzaApIRUxNRklMRV9FTlY9PGVudj4g" + + "aGVsbWZpbGUgLS1zZWxlY3RvciBuYW1lPTxyZWxlYXNlPiBkZXN0cm95CiMgSWYgbmFtZXNwYWNl" + + "IG5lZWRzIGNsZWFudXA6Cmt1YmVjdGwgZGVsZXRlIG5hbWVzcGFjZSA8bmFtZXNwYWNlPgprdWJl" + + "Y3RsIGNyZWF0ZSBuYW1lc3BhY2UgPG5hbWVzcGFjZT4KIyBSZS1jcmVhdGUgcHVsbCBzZWNyZXQg" + + "aWYgbmVlZGVkCkhFTE1GSUxFX0VOVj08ZW52PiBoZWxtZmlsZSAtLXNlbGVjdG9yIG5hbWU9PHJl" + + "bGVhc2U+IHN5bmMKYGBgCgojIyBGYWlsdXJlOiBBY2NvdW50IEJvb3RzdHJhcCBKb2IgRmFpbGVk" + + "CgojIyMgU3ltcHRvbXMKClNlcnZpY2VzIGRlcGxveSBidXQgZnVuY3Rpb25zIGNhbid0IGJlIGNy" + + "ZWF0ZWQuIEV2ZW50cyBzaG93IGJvb3RzdHJhcCBqb2IgZmFpbHVyZS4KCiMjIyBEaWFnbm9zaXMK" + + "CmBgYGJhc2gKIyBDaGVjayBib290c3RyYXAgam9iIHN0YXR1cwprdWJlY3RsIGdldCBqb2JzIC1u" + + "IG52Y2YKCiMgR2V0IGxvZ3MgKGpvYiBhdXRvLWRlbGV0ZXMgYWZ0ZXIgfjUgbWludXRlcykKa3Vi" + + "ZWN0bCBsb2dzIGpvYi9udmNmLWFwaS1hY2NvdW50LWJvb3RzdHJhcCAtbiBudmNmCgojIENoZWNr" + + "IEFQSSBsb2dzCmt1YmVjdGwgbG9ncyAtbiBudmNmIC1sIGFwcC5rdWJlcm5ldGVzLmlvL25hbWU9" + + "bnZjZi1hcGkgLS10YWlsPTEwMApgYGAKCiMjIyBDb21tb24gQ2F1c2VzCgoxLiAqKldyb25nIGJh" + + "c2U2NCBjcmVkZW50aWFscyoqOiBDcmVkZW50aWFscyBpbiBgc2VjcmV0cy88ZW52Pi1zZWNyZXRz" + + "LnlhbWxgIG11c3QgYmUgYCRvYXV0aHRva2VuOkFQSV9LRVlgIGJhc2U2NC1lbmNvZGVkLCBub3Qg" + + "anVzdCB0aGUgQVBJIGtleQogICBgYGBiYXNoCiAgICMgVmVyaWZ5IHlvdXIgZW5jb2RlZCBjcmVk" + + "ZW50aWFsCiAgIGVjaG8gJ1lPVVJfQkFTRTY0X1NUUklORycgfCBiYXNlNjQgLWQKICAgIyBTaG91" + + "bGQgb3V0cHV0OiAkb2F1dGh0b2tlbjpudmFwaS14eHh4eAogICBgYGAKCjIuICoqUmVnaXN0cnkg" + + "dW5yZWFjaGFibGUqKjogQVBJIGNhbid0IHJlYWNoIHRoZSByZWdpc3RyeSBzcGVjaWZpZWQgaW4g" + + "YGFjY291bnRCb290c3RyYXAucmVnaXN0cnlDcmVkZW50aWFsc2AKCiMjIyBGaXgKCkZpeCBjcmVk" + + "ZW50aWFscyBpbiBzZWNyZXRzIGZpbGUsIHRoZW4gcmVjb3ZlciBzZXJ2aWNlcyB3aXRob3V0IGRl" + + "c3Ryb3lpbmcgZGVwZW5kZW5jaWVzOgoKYGBgYmFzaApIRUxNRklMRV9FTlY9PGVudj4gaGVsbWZp" + + "bGUgLS1zZWxlY3RvciByZWxlYXNlLWdyb3VwPXNlcnZpY2VzIGRlc3Ryb3kKa3ViZWN0bCBkZWxl" + + "dGUgbmFtZXNwYWNlIG52Y2YgYXBpLWtleXMgZXNzIHNpcyAtLWlnbm9yZS1ub3QtZm91bmQKa3Vi" + + "ZWN0bCBjcmVhdGUgbmFtZXNwYWNlIG52Y2YgJiYga3ViZWN0bCBjcmVhdGUgbmFtZXNwYWNlIGFw" + + "aS1rZXlzICYmIFwKICBrdWJlY3RsIGNyZWF0ZSBuYW1lc3BhY2UgZXNzICYmIGt1YmVjdGwgY3Jl" + + "YXRlIG5hbWVzcGFjZSBzaXMKIyBSZS1jcmVhdGUgcHVsbCBzZWNyZXRzIGlmIG5lZWRlZApIRUxN" + + "RklMRV9FTlY9PGVudj4gaGVsbWZpbGUgLS1zZWxlY3RvciByZWxlYXNlLWdyb3VwPXNlcnZpY2Vz" + + "IHN5bmMKYGBgCgojIyBGYWlsdXJlOiBOVkNBIENsZWFudXAgU3R1Y2sgKEZpbmFsaXplcnMpCgoj" + + "IyMgU3ltcHRvbXMKCkNvbXB1dGUtcGxhbmUgY2xlYW51cCBoYW5ncy4gTmFtZXNwYWNlcwpzdHVj" + + "ayBpbiBgVGVybWluYXRpbmdgOgoKYGBgYmFzaAprdWJlY3RsIGdldCBucwojIG52Y2Etb3BlcmF0" + + "b3IgICAgVGVybWluYXRpbmcgICAxMG0KIyBudmNmLWJhY2tlbmQgICAgIFRlcm1pbmF0aW5nICAg" + + "MTBtCmBgYAoKIyMjIEZpeAoKUnVuIHRoaXMgb25seSBhZ2FpbnN0IHRoZSBjb21wdXRlIGNvbnRl" + + "eHQsIGFmdGVyIHRoZSBub3JtYWwgY29tcHV0ZS1wbGFuZQp0ZWFyZG93biBoYXMgZmFpbGVkLiBS" + + "ZW1vdmUgZmluYWxpemVycyBmcm9tIE5WQ0ZCYWNrZW5kIGN1c3RvbSByZXNvdXJjZXMgYW5kCmZv" + + "cmNlLWRlbGV0ZSBzdHVjayBuYW1lc3BhY2VzOgoKYGBgYmFzaApleHBvcnQgQ09NUFVURV9DT05U" + + "RVhUPTxjb21wdXRlLXBsYW5lLWNvbnRleHQ+CgojIFJlbW92ZSBmaW5hbGl6ZXJzIGZyb20gTlZD" + + "RkJhY2tlbmQgcmVzb3VyY2VzCmt1YmVjdGwgLS1jb250ZXh0ICIkQ09NUFVURV9DT05URVhUIiBn" + + "ZXQgbnZjZmJhY2tlbmRzIC1BIC1vIGpzb24gfCBcCiAganEgJy5pdGVtc1tdIHwgLm1ldGFkYXRh" + + "Lm5hbWVzcGFjZSArICIvIiArIC5tZXRhZGF0YS5uYW1lJyAtciB8IFwKICB4YXJncyAtSXt9IHNo" + + "IC1jICdjb250ZXh0PSIkMSI7IG5zPSIkezIlJS8qfSI7IG5hbWU9IiR7MiMjKi99Ijsga3ViZWN0" + + "bCAtLWNvbnRleHQgIiRjb250ZXh0IiBwYXRjaCBudmNmYmFja2VuZCAiJG5hbWUiIC1uICIkbnMi" + + "IC0tdHlwZT1tZXJnZSAtcCAie1wibWV0YWRhdGFcIjp7XCJmaW5hbGl6ZXJzXCI6W119fSInIF8g" + + "IiRDT01QVVRFX0NPTlRFWFQiIHt9CgojIEZvcmNlLWRlbGV0ZSBzdHVjayBuYW1lc3BhY2VzIGJ5" + + "IGNsZWFyaW5nIHRoZWlyIGZpbmFsaXplcnMKZm9yIG5zIGluIG52Y2Etb3BlcmF0b3IgbnZjZi1i" + + "YWNrZW5kOyBkbwogIGt1YmVjdGwgLS1jb250ZXh0ICIkQ09NUFVURV9DT05URVhUIiBnZXQgbmFt" + + "ZXNwYWNlICIkbnMiIC1vIGpzb24gMj4vZGV2L251bGwgfCBcCiAgICBqcSAnLnNwZWMuZmluYWxp" + + "emVycyA9IFtdJyB8IFwKICAgIGt1YmVjdGwgLS1jb250ZXh0ICIkQ09NUFVURV9DT05URVhUIiBy" + + "ZXBsYWNlIFwKICAgICAgLS1yYXcgIi9hcGkvdjEvbmFtZXNwYWNlcy8kbnMvZmluYWxpemUiIC1m" + + "IC0gMj4vZGV2L251bGwKZG9uZQpgYGAKCiMjIEZhaWx1cmU6IE5WQ0EgT3BlcmF0b3IgTWlzc2lu" + + "ZyBvciBOb3QgUmVhZHkKCiMjIyBTeW1wdG9tcwoKQWZ0ZXIgY29tcHV0ZS1wbGFuZSBpbnN0YWxs" + + "IGNvbXBsZXRlcywgbm8gYG52Y2Etb3BlcmF0b3JgIERlcGxveW1lbnQgZXhpc3RzLCBvcgppdCBl" + + "eGlzdHMgYnV0IHBvZHMgYXJlIG5vdCByZWFkeToKCmBgYGJhc2gKa3ViZWN0bCAtLWNvbnRleHQg" + + "PGNvbXB1dGUtcGxhbmUtY29udGV4dD4gZ2V0IGRlcGxveW1lbnQgbnZjYS1vcGVyYXRvciBcCiAg" + + "LW4gbnZjYS1vcGVyYXRvcgprdWJlY3RsIC0tY29udGV4dCA8Y29tcHV0ZS1wbGFuZS1jb250ZXh0" + + "PiBnZXQgcG9kcyAtbiBudmNhLW9wZXJhdG9yCmBgYAoKIyMjIERpYWdub3NpcyBhbmQgRml4ZXMK" + + "CkZpcnN0IGlkZW50aWZ5IHdoZXRoZXIgdGhlIGluc3RhbGxhdGlvbiB1c2VkIHRoZSBIZWxtZmls" + + "ZSB2YWx1ZXMgZmxvdyBvciB0aGUKQ0xJIHByb2ZpbGUgZmxvdy4gUmUtcnVuIG9ubHkgdGhhdCBm" + + "bG93J3MgcmVnaXN0cmF0aW9uIGFuZCBpbnN0YWxsYXRpb24gc3RlcHMKZnJvbSBbU3BsaXQgQ29t" + + "cHV0ZS1QbGFuZSBJbnN0YWxsYXRpb25dKGNvbXB1dGUtcGxhbmUtaW5zdGFsbGF0aW9uLm1kKS4g" + + "RG8gbm90CnN1YnN0aXR1dGUgb25lIGhhbmRvZmYgZm9yIHRoZSBvdGhlci4KCklmIGluc3RhbGxh" + + "dGlvbiBzdWNjZWVkcyBidXQgcG9kcyBzdGlsbCBmYWlsLCBpbnNwZWN0IHRoZSBjb21wdXRlIGNv" + + "bnRleHQ6CgpgYGBiYXNoCmt1YmVjdGwgLS1jb250ZXh0IDxjb21wdXRlLXBsYW5lLWNvbnRleHQ+" + + "IGRlc2NyaWJlIGRlcGxveSBudmNhLW9wZXJhdG9yIFwKICAtbiBudmNhLW9wZXJhdG9yCmt1YmVj" + + "dGwgLS1jb250ZXh0IDxjb21wdXRlLXBsYW5lLWNvbnRleHQ+IGxvZ3MgZGVwbG95bWVudC9udmNh" + + "LW9wZXJhdG9yIFwKICAtbiBudmNhLW9wZXJhdG9yIC0tdGFpbD0yMDAKa3ViZWN0bCAtLWNvbnRl" + + "eHQgPGNvbXB1dGUtcGxhbmUtY29udGV4dD4gZ2V0IG52Y2ZiYWNrZW5kIC1uIG52Y2Etb3BlcmF0" + + "b3IKYGBgCgpGb3IgcHJpdmF0ZSByZWdpc3RyeSBmYWlsdXJlcywgdmVyaWZ5IHRoYXQgdGhlIHB1" + + "bGwgc2VjcmV0IGV4aXN0cyBpbgpgbnZjYS1vcGVyYXRvcmAuIFRoZSBjaGFydCBhbmQgb3BlcmF0" + + "b3IgbWlycm9yIGl0IHRvIGBudmNhLXN5c3RlbWA7IGRvIG5vdCB1c2UgYQpicm9hZGVyIG1hbnVh" + + "bCBuYW1lc3BhY2UgbG9vcC4gU2VlCltwdWxsLXNlY3JldHMubWRdKHB1bGwtc2VjcmV0cy5tZCNj" + + "b21wdXRlLXBsYW5lLXNlY3JldCkuCgojIyBGYWlsdXJlOiBHYXRld2F5IEVuZHBvaW50IENoYW5n" + + "ZWQKCiMjIyBTeW1wdG9tcwoKUmVxdWVzdHMgdGhyb3VnaCB0aGUgY29uZmlndXJlZCByb3V0ZSBk" + + "b21haW4gZmFpbCBhZnRlciB0aGUgR2F0ZXdheSBvciBpdHMgbG9hZCBiYWxhbmNlciBpcyByZXBs" + + "YWNlZC4gVGhlIEdhdGV3YXkgcmVwb3J0cyBhIG5ldyBlbmRwb2ludC4KCiMjIyBEaWFnbm9zaXMK" + + "CmBgYGJhc2gKR0FURVdBWV9BRERSPSQoa3ViZWN0bCAtLWNvbnRleHQgPGNvbnRyb2wtcGxhbmUt" + + "Y29udGV4dD4gZ2V0IGdhdGV3YXkgXAogIG52Y2YtZ2F0ZXdheSAtbiBlbnZveS1nYXRld2F5IFwK" + + "ICAtbyBqc29ucGF0aD0ney5zdGF0dXMuYWRkcmVzc2VzWzBdLnZhbHVlfScpCnRlc3QgLW4gIiRH" + + "QVRFV0FZX0FERFIiCmRpZyArc2hvcnQgImFwaS48ZG9tYWluPiIKY3VybCAtSCAiSG9zdDogYXBp" + + "Ljxkb21haW4+IiAiaHR0cDovLyRHQVRFV0FZX0FERFIvaGVhbHRoIgoKIyBDaGVjayBkaXJlY3Qg" + + "YWRkcmVzcyBmaWVsZHMgdXNlZCBieSBhIHNwbGl0IGRlcGxveW1lbnQKZ3JlcCBudmNmTmF0c1Nl" + + "cnZpY2VVUkwgZGVwbG95L3N0YWNrcy9zZWxmLW1hbmFnZWQvZW52aXJvbm1lbnRzLzxlbnY+Lnlh" + + "bWwKZ3JlcCAtRSAnaWNtc1NlcnZpY2V8cmV2YWxTZXJ2aWNlfG5hdHMnIFwKICBkZXBsb3kvc3Rh" + + "Y2tzL252Y2YtY29tcHV0ZS1wbGFuZS9lbnZpcm9ubWVudHMvPGVudj4ueWFtbApgYGAKCiMjIyBG" + + "aXgKCktlZXAgYGdsb2JhbC5kb21haW5gLCByb3V0ZSBob3N0bmFtZXMsIGFuZCBIb3N0IG92ZXJy" + + "aWRlcyB1bmNoYW5nZWQuIFVwZGF0ZSBETlMKb3IgdGhlIGRpcmVjdCBjbGllbnQgZGVzdGluYXRp" + + "b24uIEZvciBzcGxpdCBkZXBsb3ltZW50cywgdXBkYXRlIG9ubHkgZGlyZWN0CkdhdGV3YXktYWRk" + + "cmVzcyBmaWVsZHMgYW5kIHJlZnJlc2ggcmVnaXN0cmF0aW9uIGFuZCBpbnN0YWxsYXRpb24gdGhy" + + "b3VnaCB0aGUKc2FtZSBzZWxlY3RlZCBoYW5kb2ZmLiBTZWUKW0V4YW1wbGUgNF0oLi4vZXhhbXBs" + + "ZXMubWQjZXhhbXBsZS00LXJlY292ZXItZnJvbS1hLWdhdGV3YXktZW5kcG9pbnQtY2hhbmdlKS4K" + + "CiMjIFVzZWZ1bCBOYW1lc3BhY2UtdG8tU2VydmljZSBNYXBwaW5nCgpRdWljayByZWZlcmVuY2Ug" + + "Zm9yIHdoaWNoIHNlcnZpY2VzIHJ1biBpbiB3aGljaCBuYW1lc3BhY2U6Cgp8IE5hbWVzcGFjZSB8" + + "IFNlcnZpY2VzIHwKfC0tLS0tLS0tLS0tfC0tLS0tLS0tLS18CnwgbmF0cy1zeXN0ZW0gfCBuYXRz" + + "IHwKfCBjYXNzYW5kcmEtc3lzdGVtIHwgY2Fzc2FuZHJhIHwKfCB2YXVsdC1zeXN0ZW0gfCBvcGVu" + + "YmFvLXNlcnZlciB8CnwgbnZjZiB8IGFwaSwgaW52b2NhdGlvbi1zZXJ2aWNlLCBncnBjLXByb3h5" + + "LCBub3Rhcnktc2VydmljZSwgcmV2YWwsIGxsbS1yZXF1ZXN0LXJvdXRlciwgbGxtLWFwaS1nYXRl" + + "d2F5IHwKfCBhcGkta2V5cyB8IGFwaS1rZXlzLCBhZG1pbi1pc3N1ZXItcHJveHkgfAp8IGVzcyB8" + + "IGVzcy1hcGkgfAp8IHNpcyB8IHNpcyB8CnwgZW52b3ktZ2F0ZXdheS1zeXN0ZW0gfCBlbnZveSBn" + + "YXRld2F5IChpbmdyZXNzIGNvbnRyb2xsZXIpIHwKfCBlbnZveS1nYXRld2F5IHwgZ2F0ZXdheSBy" + + "ZXNvdXJjZSArIHJvdXRlcyB8ClBLBwhWPmeQlTAAAJUwAABQSwMEFAAIAAAAAAAhAAAAAAAAAAAA" + + "AAAAAEQACQBkYXRhL252Y2Ytc2VsZi1tYW5hZ2VkLWluc3RhbGxhdGlvbi9yZWZlcmVuY2VzL2hl" + + "bG1maWxlLXN0cnVjdHVyZS5tZFVUBQABAKbOEiMgSGVsbWZpbGUgU3RydWN0dXJlIFJlZmVyZW5j" + + "ZQoKIyMgRGlyZWN0b3J5IExheW91dAoKYGBgCm52Y2Ytc2VsZi1tYW5hZ2VkLXN0YWNrLwp8LS0g" + + "aGVsbWZpbGUuZC8KfCAgIHwtLSAwMS1kZXBlbmRlbmNpZXMueWFtbC5nb3RtcGwgICMgTkFUUywg" + + "Q2Fzc2FuZHJhLCBPcGVuQmFvCnwgICB8LS0gMDItY29yZS55YW1sLmdvdG1wbCAgICAgICAgICAj" + + "IE5WQ0Ygc2VydmljZXMgKyBpbmdyZXNzCnwgICBgLS0gMDMtb2JzZXJ2YWJpbGl0eS55YW1sLmdv" + + "dG1wbCAjIE9ic2VydmFiaWxpdHkgc3RhY2sgKG9wdGlvbmFsKQp8LS0gZW52aXJvbm1lbnRzLwp8" + + "ICAgfC0tIGJhc2UueWFtbCAgICAgICAgICAgICAgICAgICAgIyBEZWZhdWx0IHZhbHVlcyAoYWxs" + + "IGVudmlyb25tZW50cykKfCAgIGAtLSA8ZW52LW5hbWU+LnlhbWwgICAgICAgICAgICAgICMgUGVy" + + "LWVudmlyb25tZW50IG92ZXJyaWRlcwp8LS0gc2VjcmV0cy8KfCAgIGAtLSA8ZW52LW5hbWU+LXNl" + + "Y3JldHMueWFtbCAgICAgICMgU2Vuc2l0aXZlIHZhbHVlcyAocmVnaXN0cnkgY3JlZHMsIHBhc3N3" + + "b3JkcykKYC0tIGdsb2JhbC55YW1sLmdvdG1wbCAgICAgICAgICAgICAgICMgR28gdGVtcGxhdGUg" + + "dGhhdCBjb25zdHJ1Y3RzIHBlci1jaGFydCB2YWx1ZXMKCm52Y2YtY29tcHV0ZS1wbGFuZS1zdGFj" + + "ay8KfC0tIGhlbG1maWxlLmQvCnwgICB8LS0gMDEtZGVwZW5kZW5jaWVzLnlhbWwuZ290bXBsICAj" + + "IENvbXB1dGUgcGxhbmUgZGVwZW5kZW5jeSBjb21wb25lbnRzCnwgICBgLS0gMDItbnZjYS55YW1s" + + "LmdvdG1wbCAgICAgICAgICAjIG52Y2Etb3BlcmF0b3IgY2hhcnQgYW5kIG52Y2EgY29uZmlndXJh" + + "dGlvbgp8LS0gZW52aXJvbm1lbnRzLwp8ICAgfC0tIGJhc2UueWFtbCAgICAgICAgICAgICAgICAg" + + "ICAgIyBEZWZhdWx0IHZhbHVlcyAoYWxsIGVudmlyb25tZW50cykKfCAgIGAtLSA8ZW52LW5hbWU+" + + "LnlhbWwgICAgICAgICAgICAgICMgUGVyLWVudmlyb25tZW50IG92ZXJyaWRlcwpgLS0gZ2xvYmFs" + + "LnlhbWwuZ290bXBsICAgICAgICAgICAgICAgIyBHbyB0ZW1wbGF0ZSB0aGF0IGNvbnN0cnVjdHMg" + + "cGVyLWNoYXJ0IHZhbHVlcwpgYGAKClRoZXNlIHN0YWNrcyBoYXZlIHNlcGFyYXRlIGVudmlyb25t" + + "ZW50cyBhbmQgY2x1c3RlciBjb250ZXh0cy4gVGhlIEhlbG1maWxlCnZhbHVlcyBmbG93IGF1dGhv" + + "cnMgYm90aCBlbnZpcm9ubWVudCBmaWxlcy4gVGhlIENMSSBwcm9maWxlIGZsb3cgaW5zdGVhZCB1" + + "c2VzCnRoZSBDTEktZ2VuZXJhdGVkIGNvbnRyb2wtcGxhbmUgcHJvZmlsZSBhcyBpdHMgZW5kcG9p" + + "bnQgc291cmNlLiBEbyBub3QgbWl4IHRoZQpoYW5kb2Zmcy4gU2VlIFtTcGxpdCBDb21wdXRlLVBs" + + "YW5lIEluc3RhbGxhdGlvbl0oY29tcHV0ZS1wbGFuZS1pbnN0YWxsYXRpb24ubWQpLgoKIyMgR290" + + "bXBsIEZpbGVzIGFuZCBUaGVpciBSZWxlYXNlcwoKIyMjIDAxLWRlcGVuZGVuY2llcy55YW1sLmdv" + + "dG1wbAoKfCBSZWxlYXNlIHwgQ2hhcnQgfCBOYW1lc3BhY2UgfCBOb3RlcyB8CnwtLS0tLS0tLS18" + + "LS0tLS0tLXwtLS0tLS0tLS0tLXwtLS0tLS0tfAp8IG5hdHMgfCBoZWxtLW52Y2YtbmF0cyB8IG5h" + + "dHMtc3lzdGVtIHwgTWVzc2FnaW5nIHwKfCBvcGVuYmFvLXNlcnZlciB8IGhlbG0tbnZjZi1vcGVu" + + "YmFvLXNlcnZlciB8IHZhdWx0LXN5c3RlbSB8IFNlY3JldHMgbWFuYWdlbWVudCwgZGVwZW5kcyBv" + + "biBuYXRzIHwKfCBjYXNzYW5kcmEgfCBoZWxtLW52Y2YtY2Fzc2FuZHJhIHwgY2Fzc2FuZHJhLXN5" + + "c3RlbSB8IERhdGFiYXNlIHwKClVzZXMgYDw8OiAqZGVwZW5kZW5jeWAgdGVtcGxhdGUgaW5oZXJp" + + "dGFuY2Ugd2l0aCBgcmVsZWFzZS1ncm91cDogZGVwZW5kZW5jaWVzYCBsYWJlbC4KCiMjIyAwMi1j" + + "b3JlLnlhbWwuZ290bXBsCgp8IFJlbGVhc2UgfCBDaGFydCB8IE5hbWVzcGFjZSB8IExhYmVsIHwK" + + "fC0tLS0tLS0tLXwtLS0tLS0tfC0tLS0tLS0tLS0tfC0tLS0tLS18CnwgYXBpLWtleXMgfCBoZWxt" + + "LW52Y2YtYXBpLWtleXMgfCBhcGkta2V5cyB8IHNlcnZpY2VzIHwKfCBzaXMgfCBoZWxtLW52Y2Yt" + + "c2lzIHwgc2lzIHwgc2VydmljZXMgfAp8IGFwaSB8IGhlbG0tbnZjZi1hcGkgfCBudmNmIHwgc2Vy" + + "dmljZXMgfAp8IGludm9jYXRpb24tc2VydmljZSB8IGhlbG0tbnZjZi1pbnZvY2F0aW9uLXNlcnZp" + + "Y2UgfCBudmNmIHwgc2VydmljZXMgfAp8IGdycGMtcHJveHkgfCBoZWxtLW52Y2YtZ3JwYy1wcm94" + + "eSB8IG52Y2YgfCBzZXJ2aWNlcyB8CnwgZXNzLWFwaSB8IGhlbG0tbnZjZi1lc3MtYXBpIHwgZXNz" + + "IHwgc2VydmljZXMgfAp8IG5vdGFyeS1zZXJ2aWNlIHwgaGVsbS1udmNmLW5vdGFyeS1zZXJ2aWNl" + + "IHwgbnZjZiB8IHNlcnZpY2VzIHwKfCByZXZhbCB8IGhlbG0tcmV2YWwgfCBudmNmIHwgc2Vydmlj" + + "ZXMgfAp8IGxsbS1yZXF1ZXN0LXJvdXRlciB8IG52Y2YvaGVsbS1udmNmLWxsbS1yZXF1ZXN0LXJv" + + "dXRlciB8IG52Y2YgfCBzZXJ2aWNlcyB8CnwgbGxtLWFwaS1nYXRld2F5IHwgbnZjZi9oZWxtLW52" + + "Y2YtbGxtLWFwaS1nYXRld2F5IHwgbnZjZiB8IHNlcnZpY2VzIHwKfCBhZG1pbi1pc3N1ZXItcHJv" + + "eHkgfCBoZWxtLWFkbWluLXRva2VuLWlzc3Vlci1wcm94eSB8IGFwaS1rZXlzIHwgKG5vIHJlbGVh" + + "c2UtZ3JvdXAgbGFiZWwpIHwKfCBpbmdyZXNzIHwgbnZjZi1nYXRld2F5LXJvdXRlcyB8IGVudm95" + + "LWdhdGV3YXktc3lzdGVtIHwgaW5ncmVzcyB8CgpNb3N0IHNlcnZpY2VzIHVzZSBgaW5oZXJpdDog" + + "W3t0ZW1wbGF0ZTogc2VydmljZX1dYC4gTExNIHJlbGVhc2VzIHVzZSBPQ0kgY2hhcnRzIGZyb20g" + + "dGhlIGBudmNmYCByZXBvc2l0b3J5IHdpdGggc3RhbmRhbG9uZSBgdmFsdWVzOiBbLi4vZ2xvYmFs" + + "LnlhbWwuZ290bXBsXWAgYmxvY2tzOyB0aGV5IGFyZSBnYXRlZCBvbiBgYWRkb25zLmxsbS5lbmFi" + + "bGVkYC4gYGFkbWluLWlzc3Vlci1wcm94eWAgYW5kIGBpbmdyZXNzYCBoYXZlIHN0YW5kYWxvbmUg" + + "YHZhbHVlczpgIGJsb2Nrcy4KCiMjIyAwMy1vYnNlcnZhYmlsaXR5LnlhbWwuZ290bXBsCgp8IFJl" + + "bGVhc2UgfCBDaGFydCB8IE5hbWVzcGFjZSB8IExhYmVsIHwKfC0tLS0tLS0tLXwtLS0tLS0tfC0t" + + "LS0tLS0tLS0tfC0tLS0tLS18CnwgKG9ic2VydmFiaWxpdHkgcmVsZWFzZXMpIHwgKHZhcmlvdXMp" + + "IHwgb2JzZXJ2YWJpbGl0eSB8IG9ic2VydmFiaWxpdHkgfAoKR2F0ZWQgb24gb2JzZXJ2YWJpbGl0" + + "eS1zcGVjaWZpYyBmbGFncyBpbiB0aGUgZW52aXJvbm1lbnQgZmlsZS4gU2tpcHBlZCBpZiBkaXNh" + + "YmxlZC4KCiMjIFRlbXBsYXRlIEluaGVyaXRhbmNlCgojIyMgYDw8OiAqZGVwZW5kZW5jeWAgKFlB" + + "TUwgbWVyZ2UpCgpVc2VkIGluIGAwMS1kZXBlbmRlbmNpZXMueWFtbC5nb3RtcGxgLiBNZXJnZXMg" + + "dGhlIHRlbXBsYXRlJ3MgcHJvcGVydGllcyBpbnRvIHRoZSByZWxlYXNlLgoKKipHb3RjaGEqKjog" + + "WUFNTCBtZXJnZSByZXBsYWNlcyBsaXN0cy4gSWYgeW91IGFkZCBhIGB2YWx1ZXM6YCBrZXkgdG8g" + + "dGhlIHJlbGVhc2UsIGl0ICoqcmVwbGFjZXMqKiB0aGUgdGVtcGxhdGUncyBgdmFsdWVzOmAgbGlz" + + "dCBlbnRpcmVseS4gWW91IG11c3QgcmUtaW5jbHVkZSBhbGwgdGVtcGxhdGUgdmFsdWVzOgoKSW4g" + + "dGhlIHRlbXBsYXRlIGJlbG93LCBgPHByaXZhdGUtdmFsdWVzPmAgcmVmZXJzIHRvIHRoZSBgc2Vj" + + "cmV0cy9gIGRpcmVjdG9yeSBhdCB0aGUgaGVsbWZpbGUgc3RhY2sgcm9vdC4KCmBgYHlhbWwKIyBU" + + "ZW1wbGF0ZSBkZWZpbmVzOgp0ZW1wbGF0ZXM6CiAgZGVwZW5kZW5jeTogJmRlcGVuZGVuY3kKICAg" + + "IGNoYXJ0OiBudmNmL2hlbG0tbnZjZi17eyAuUmVsZWFzZS5OYW1lIH19CiAgICB2YWx1ZXM6CiAg" + + "ICAgIC0gLi4vZ2xvYmFsLnlhbWwuZ290bXBsCiAgICAgIC0gLi4vPHByaXZhdGUtdmFsdWVzPi97" + + "eyByZXF1aXJlZEVudiAiSEVMTUZJTEVfRU5WIiB9fS1zZWNyZXRzLnlhbWwKCiMgV2hlbiBvdmVy" + + "cmlkaW5nLCBNVVNUIHJlLWluY2x1ZGUgYm90aDoKLSBuYW1lOiBjYXNzYW5kcmEKICA8PDogKmRl" + + "cGVuZGVuY3kKICB2YWx1ZXM6CiAgICAtIC4uL2dsb2JhbC55YW1sLmdvdG1wbCAgICAgICAgICAg" + + "ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAjIE11c3QgcmUtaW5jbHVkZQogICAg" + + "LSAuLi88cHJpdmF0ZS12YWx1ZXM+L3t7IHJlcXVpcmVkRW52ICJIRUxNRklMRV9FTlYiIH19LXNl" + + "Y3JldHMueWFtbCAgICMgTXVzdCByZS1pbmNsdWRlCiAgICAtIGNhc3NhbmRyYTogICAgICAgICAg" + + "ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIyBZb3VyIG92" + + "ZXJyaWRlCiAgICAgICAgcmVzb3VyY2VzOgogICAgICAgICAgbGltaXRzOgogICAgICAgICAgICBt" + + "ZW1vcnk6IDgxOTJNaQpgYGAKCiMjIyBgaW5oZXJpdGAgKEhlbG1maWxlIG5hdGl2ZSkKClVzZWQg" + + "aW4gYDAyLWNvcmUueWFtbC5nb3RtcGxgLiBIZWxtZmlsZSdzIG5hdGl2ZSBpbmhlcml0YW5jZSBt" + + "ZWNoYW5pc20uCgpgYGB5YW1sCi0gbmFtZTogYXBpCiAgdmVyc2lvbjogMS42LjAKICBuYW1lc3Bh" + + "Y2U6IG52Y2YKICBpbmhlcml0OgogICAgLSB0ZW1wbGF0ZTogc2VydmljZQpgYGAKCldoZW4gYWRk" + + "aW5nIGB2YWx1ZXM6YCB0byBhbiBpbmhlcml0ZWQgcmVsZWFzZSwgeW91IGFsc28gbmVlZCB0byBy" + + "ZS1pbmNsdWRlIHRoZSB0ZW1wbGF0ZSdzIHZhbHVlcyBmaWxlcyBzaW5jZSBgdmFsdWVzYCBpcyBh" + + "IGxpc3QgdGhhdCBnZXRzIHJlcGxhY2VkLgoKIyMgVmFsdWVzIFByZWNlZGVuY2UKCkZyb20gbG93" + + "ZXN0IHRvIGhpZ2hlc3QgcHJpb3JpdHk6CgoxLiBgZW52aXJvbm1lbnRzL2Jhc2UueWFtbGAgLS0g" + + "ZGVmYXVsdHMgc2hhcmVkIGFjcm9zcyBhbGwgZW52aXJvbm1lbnRzCjIuIGBlbnZpcm9ubWVudHMv" + + "PGVudj4ueWFtbGAgLS0gcGVyLWVudmlyb25tZW50IG92ZXJyaWRlcwozLiBgZ2xvYmFsLnlhbWwu" + + "Z290bXBsYCAtLSBHbyB0ZW1wbGF0ZSBwcm9jZXNzaW5nIChjb25zdHJ1Y3RzIGNoYXJ0LXNwZWNp" + + "ZmljIHN0cnVjdHVyZSkKNC4gYDxwcml2YXRlLXZhbHVlcz4vPGVudj4tc2VjcmV0cy55YW1sYCAt" + + "LSBzZW5zaXRpdmUgdmFsdWVzCjUuIElubGluZSBgdmFsdWVzOmAgYmxvY2tzIG9uIHJlbGVhc2Vz" + + "IC0tIGhpZ2hlc3QgcHJlY2VkZW5jZQoKIyMgV2hhdCBnbG9iYWwueWFtbC5nb3RtcGwgUGFzc2Vz" + + "IFRocm91Z2gKCmBnbG9iYWwueWFtbC5nb3RtcGxgIHJlYWRzIGZyb20gYC5WYWx1ZXNgICh0aGUg" + + "bWVyZ2VkIGVudmlyb25tZW50ICsgZW52LXNwZWNpZmljIFlBTUwpIGFuZCBjb25zdHJ1Y3RzIGNo" + + "YXJ0LXNwZWNpZmljIHZhbHVlcy4gSXQgb25seSBwYXNzZXMgdGhyb3VnaCBrZXlzIGl0IGV4cGxp" + + "Y2l0bHkgcmVmZXJlbmNlczoKCiMjIyBDYXNzYW5kcmEKLSBgY2Fzc2FuZHJhLnJlcGxpY2FDb3Vu" + + "dGAKLSBgY2Fzc2FuZHJhLmltYWdlLipgIChyZWdpc3RyeSwgcmVwb3NpdG9yeSkKLSBgY2Fzc2Fu" + + "ZHJhLm1pZ3JhdGlvbnMuaW1hZ2UuKmAKLSBgY2Fzc2FuZHJhLnBlcnNpc3RlbmNlLnNpemVgCi0g" + + "YGNhc3NhbmRyYS5ub2RlU2VsZWN0b3JgIChpZiBgZ2xvYmFsLm5vZGVTZWxlY3RvcnMuZW5hYmxl" + + "ZGApCi0gYGNhc3NhbmRyYS5nbG9iYWwuZGVmYXVsdFN0b3JhZ2VDbGFzc2AKCiMjIyBOQVRTCi0g" + + "YG5hdHMuY29udGFpbmVyLmltYWdlLipgCi0gYG5hdHMucmVsb2FkZXIuaW1hZ2UuKmAKLSBgbmF0" + + "cy5uYXRzQm94LmNvbnRhaW5lci5pbWFnZS4qYAotIGBuYXRzLmNvbmZpZy5qZXRzdHJlYW0uZmls" + + "ZVN0b3JlLnB2Yy5zdG9yYWdlQ2xhc3NOYW1lYAotIGBuYXRzLnBvZFRlbXBsYXRlLm1lcmdlLnNw" + + "ZWMubm9kZVNlbGVjdG9yYCAoaWYgZW5hYmxlZCkKCiMjIyBPcGVuQmFvCi0gYG9wZW5iYW8ubWln" + + "cmF0aW9ucy5pbWFnZS4qYCBhbmQgYG9wZW5iYW8ubWlncmF0aW9ucy5lbnZgCi0gYG9wZW5iYW8u" + + "aW5qZWN0b3IuaW1hZ2UuKmAKLSBgb3BlbmJhby5zZXJ2ZXIuaW1hZ2UuKmAKLSBgb3BlbmJhby5z" + + "ZXJ2ZXIuZGF0YVN0b3JhZ2UuKmAKLSBOb2RlIHNlbGVjdG9ycyAoaWYgZW5hYmxlZCkKCiMjIyBT" + + "ZXJ2aWNlcyAoQVBJLCBTSVMsIGV0Yy4pCi0gYDxzZXJ2aWNlPi5pbWFnZS4qYCAocmVnaXN0cnks" + + "IHJlcG9zaXRvcnkpCi0gYDxzZXJ2aWNlPi5ub2RlU2VsZWN0b3JgIChpZiBlbmFibGVkKQotIGA8" + + "c2VydmljZT4uZW52LipgIChvYnNlcnZhYmlsaXR5IHNldHRpbmdzKQoKIyMjIExMTSBGdW5jdGlv" + + "biBFbmFibGVtZW50CgpFbmFibGUgdGhlIExMTSBhZGRvbiBiZWZvcmUgY3JlYXRpbmcgb3IgaW52" + + "b2tpbmcgZnVuY3Rpb25zIHdpdGgKYGZ1bmN0aW9uVHlwZTogIkxMTSJgLiBUaGUgYWRkb24gZGVw" + + "bG95cyBgbGxtLXJlcXVlc3Qtcm91dGVyYCBhbmQKYGxsbS1hcGktZ2F0ZXdheWAsIGFkZHMgdGhl" + + "IGBsbG0uaW52b2NhdGlvbi48ZG9tYWluPmAgcm91dGUgd2hlbiBHYXRld2F5IEFQSQppbmdyZXNz" + + "IGlzIGVuYWJsZWQsIGFuZCBjb25maWd1cmVzIHdvcmtlcnMgdG8gdXNlIHRoZSBMTE0gc2lkZWNh" + + "ci4gVGhlIEhlbG1maWxlCmNvbmRpdGlvbiBpcyBgYWRkb25zLmxsbS5lbmFibGVkYC4gRG8gbm90" + + "IHVzZSB0aGUgb2Jzb2xldGUgYGxsbS5lbmFibGVkYCBwYXRoLgoKRm9yIGEgc2luZ2xlLW5vZGUg" + + "aXNvbGF0ZWQgdGVzdCBjbHVzdGVyLCBhZGQgdGhpcyBjb25maWd1cmF0aW9uIHRvCmBlbnZpcm9u" + + "bWVudHMvPGVudj4ueWFtbGAgYmVmb3JlIGFwcGx5aW5nIHRoZSBzdGFjazoKCmBgYHlhbWwKYWRk" + + "b25zOgogIGxsbToKICAgIGVuYWJsZWQ6IHRydWUKICAgIGdhdGV3YXk6CiAgICAgIHJlcGxpY2FD" + + "b3VudDogMQogICAgICBhdXRoOgogICAgICAgIGdycGNJbnNlY3VyZTogdHJ1ZQogICAgICBtZXRy" + + "aWNzOgogICAgICAgIHNlcnZpY2VNb25pdG9yOgogICAgICAgICAgZW5hYmxlZDogZmFsc2UKICAg" + + "IHJlcXVlc3RSb3V0ZXI6CiAgICAgIHJlcGxpY2FDb3VudDogMQogICAgICBtZXRyaWNzOgogICAg" + + "ICAgIHNlcnZpY2VNb25pdG9yOgogICAgICAgICAgZW5hYmxlZDogZmFsc2UKCmFnZW50Q29uZmln" + + "OgogIG1lcmdlQ29uZmlnOiB8CiAgICBjbHVzdGVyOgogICAgICB2YWxpZGF0aW9uUG9saWN5Ogog" + + "ICAgICAgIG5hbWU6IFVucmVzdHJpY3RlZAogICAgd29ya2xvYWQ6CiAgICAgIHN0YXJnYXRlUVVJ" + + "Q0luc2VjdXJlOiB0cnVlCmBgYAoKVXNlIGByZXBsaWNhQ291bnQ6IDFgIG9ubHkgZm9yIGxvY2Fs" + + "IG9yIHNpbmdsZS1ub2RlIHRlc3QgY2x1c3RlcnMuIEZvciBzaGFyZWQKb3IgcHJvZHVjdGlvbiBj" + + "bHVzdGVycywgdXNlIHRoZSByZXF1aXJlZCByZXBsaWNhIGNvdW50IGFuZCBUTFMtY2FwYWJsZSBz" + + "ZXJ2aWNlCmNvbmZpZ3VyYXRpb24uIGBhZGRvbnMubGxtLmdhdGV3YXkuYXV0aC5ncnBjSW5zZWN1" + + "cmVgIGFuZApgd29ya2xvYWQuc3RhcmdhdGVRVUlDSW5zZWN1cmVgIGVuYWJsZSBwbGFpbnRleHQg" + + "dHJhbnNwb3J0cy4gRG8gbm90IHVzZSB0aGVtIGluCnByb2R1Y3Rpb24uCgpUaGUgcmVxdWVzdCBy" + + "b3V0ZXIgdXNlcyBgcG93ZXItb2YtdHdvYCB3aGVuIG5vIGxvYWQtYmFsYW5jZXIgY29uZmlndXJh" + + "dGlvbiBpcwpzZXQuIENvbmZpZ3VyZSBvdGhlciByb3V0aW5nIG1ldGhvZHMgd2l0aCB0aGUKW0xM" + + "TSBSZXF1ZXN0IFJvdXRlciBMb2FkIEJhbGFuY2luZ10oaHR0cHM6Ly9naXRodWIuY29tL05WSURJ" + + "QS9udmNmL2Jsb2IvbWFpbi9kb2NzL3VzZXIvbGxtLXJlcXVlc3Qtcm91dGVyLWxvYWQtYmFsYW5j" + + "aW5nLm1kKQpndWlkZS4KCklmIHRoZSBzaWRlY2FyIGltYWdlIGlzIG1pcnJvcmVkIG91dHNpZGUg" + + "dGhlIHN0YWNrJ3MgZGVmYXVsdCBpbWFnZSByZWdpc3RyeSBhbmQKcmVwb3NpdG9yeSwgc2V0IHRo" + + "ZSBnZW5lcmF0ZWQgd29ya2VyIHNpZGVjYXIgaW1hZ2UgZXhwbGljaXRseToKCmBgYHlhbWwKYXBp" + + "OgogIGVudjoKICAgIE5WQ0ZfU0lERUNBUlNfTExNX1JPVVRFUl9DTElFTlRfSU1BR0U6IDxyZWdp" + + "c3RyeT4vPHJlcG9zaXRvcnk+L3B5bG9uOjAuMi4xCmBgYAoKUmVuZGVyIGFuZCBhcHBseSB0aGUg" + + "dXBkYXRlZCBjb250cm9sLXBsYW5lIGVudmlyb25tZW50LCB0aGVuIHJlZnJlc2ggZXZlcnkKcmVn" + + "aXN0ZXJlZCBjb21wdXRlIHBsYW5lIHVzaW5nIHRoZSBzYW1lIGhhbmRvZmYgdXNlZCBmb3IgaXRz" + + "IGluc3RhbGxhdGlvbiBzbwpOVkNBIHJlY2VpdmVzIGBhZ2VudENvbmZpZy5tZXJnZUNvbmZpZ2A6" + + "CgpgYGBiYXNoCkhFTE1GSUxFX0VOVj08ZW52PiBoZWxtZmlsZSB0ZW1wbGF0ZQpIRUxNRklMRV9F" + + "TlY9PGVudj4gaGVsbWZpbGUgc3luYwpgYGAKClVzZSB0aGUgY29tcGxldGUgY29tcHV0ZS1wbGFu" + + "ZSBpbnN0YWxsIGNvbW1hbmQgZnJvbQpbU3BsaXQgQ29tcHV0ZS1QbGFuZSBJbnN0YWxsYXRpb25d" + + "KGNvbXB1dGUtcGxhbmUtaW5zdGFsbGF0aW9uLm1kKS4gQQpDTEktcHJvZmlsZSBpbnN0YWxsYXRp" + + "b24gbXVzdCByZW1haW4gcHJvZmlsZS1kcml2ZW47IGEgSGVsbWZpbGUgaW5zdGFsbGF0aW9uCm11" + + "c3QgcmVtYWluIHZhbHVlcy1kcml2ZW4uCgpFeGlzdGluZyBMTE0gZnVuY3Rpb24gcG9kcyBrZWVw" + + "IHRoZWlyIGV4aXN0aW5nIHNpZGVjYXIgYXJndW1lbnRzLiBSZWNyZWF0ZSBvcgpyZWRlcGxveSB0" + + "aG9zZSBmdW5jdGlvbnMgYWZ0ZXIgdGhlIGNvbXB1dGUtcGxhbmUgcmVmcmVzaC4gVmVyaWZ5IHRo" + + "ZSBjb250cm9sCnBsYW5lLCByb3V0ZSwgYW5kIHdvcmtlciBzaWRlY2FyOgoKYGBgYmFzaAprdWJl" + + "Y3RsIGdldCBkZXBsb3kgLW4gbnZjZiBsbG0tYXBpLWdhdGV3YXkKa3ViZWN0bCBnZXQgc3RhdGVm" + + "dWxzZXQgLW4gbnZjZiBsbG0tcmVxdWVzdC1yb3V0ZXIKa3ViZWN0bCBnZXQgcG9kcyAtbiBudmNm" + + "IHwgZ3JlcCAtRSAnbGxtLWFwaS1nYXRld2F5fGxsbS1yZXF1ZXN0LXJvdXRlcicKa3ViZWN0bCBn" + + "ZXQgaHR0cHJvdXRlIC1BIHwgZ3JlcCBsbG0Ka3ViZWN0bCAtbiBudmNmLWJhY2tlbmQgZ2V0IHBv" + + "ZCA8ZnVuY3Rpb24tcG9kPiBcCiAgLW8ganNvbnBhdGg9J3tyYW5nZSAuc3BlYy5jb250YWluZXJz" + + "Wz8oQC5uYW1lPT0ibGxtLXdvcmtlciIpXS5hcmdzWypdfXsufXsiXFxuIn17ZW5kfScKYGBgCgpG" + + "b3IgbG9jYWwgcGxhaW50ZXh0IGNsdXN0ZXJzLCB0aGUgYGxsbS13b3JrZXJgIGFyZ3MgbXVzdCBp" + + "bmNsdWRlCmAtLXF1aWMtaW5zZWN1cmVgLgoKRm9yIGxvYWQtYmFsYW5jZXIgc2NoZW1hIGFuZCBh" + + "bGdvcml0aG0gYmVoYXZpb3IsIHNlZSB0aGUKW1N0YXJnYXRlIGNvbmZpZ3VyYXRpb24gZ3VpZGVd" + + "KGh0dHBzOi8vZ2l0aHViLmNvbS9OVklESUEvbnZjZi9ibG9iL21haW4vc3JjL2xpYnJhcmllcy9y" + + "dXN0L3N0YXJnYXRlL2RvY3MvbG9hZC1iYWxhbmNlci1jb25maWd1cmF0aW9uLm1kKS4KCiMjIEhl" + + "bG1maWxlIFNlbGVjdG9ycwoKVGFyZ2V0IHNwZWNpZmljIHJlbGVhc2VzIG9yIGdyb3VwczoKCmBg" + + "YGJhc2gKIyBCeSByZWxlYXNlIGdyb3VwCkhFTE1GSUxFX0VOVj08ZW52PiBoZWxtZmlsZSAtLXNl" + + "bGVjdG9yIHJlbGVhc2UtZ3JvdXA9ZGVwZW5kZW5jaWVzIHN5bmMKSEVMTUZJTEVfRU5WPTxlbnY+" + + "IGhlbG1maWxlIC0tc2VsZWN0b3IgcmVsZWFzZS1ncm91cD1zZXJ2aWNlcyBzeW5jCkhFTE1GSUxF" + + "X0VOVj08ZW52PiBoZWxtZmlsZSAtLXNlbGVjdG9yIHJlbGVhc2UtZ3JvdXA9aW5ncmVzcyBzeW5j" + + "CkhFTE1GSUxFX0VOVj08ZW52PiBoZWxtZmlsZSAtLXNlbGVjdG9yIHJlbGVhc2UtZ3JvdXA9b2Jz" + + "ZXJ2YWJpbGl0eSBzeW5jCgojIEJ5IHJlbGVhc2UgbmFtZQpIRUxNRklMRV9FTlY9PGVudj4gaGVs" + + "bWZpbGUgLS1zZWxlY3RvciBuYW1lPWNhc3NhbmRyYSBzeW5jCkhFTE1GSUxFX0VOVj08ZW52PiBo" + + "ZWxtZmlsZSAtLXNlbGVjdG9yIG5hbWU9YWRtaW4taXNzdWVyLXByb3h5IHN5bmMKSEVMTUZJTEVf" + + "RU5WPTxlbnY+IGhlbG1maWxlIC0tc2VsZWN0b3IgbmFtZT1sbG0tcmVxdWVzdC1yb3V0ZXIgc3lu" + + "YwpIRUxNRklMRV9FTlY9PGVudj4gaGVsbWZpbGUgLS1zZWxlY3RvciBuYW1lPWxsbS1hcGktZ2F0" + + "ZXdheSBzeW5jCgojIFRlbXBsYXRlIG9ubHkgKGRyeSBydW4pCkhFTE1GSUxFX0VOVj08ZW52PiBo" + + "ZWxtZmlsZSAtLXNlbGVjdG9yIG5hbWU9Y2Fzc2FuZHJhIHRlbXBsYXRlCgojIERlc3Ryb3kgYSBz" + + "aW5nbGUgcmVsZWFzZQpIRUxNRklMRV9FTlY9PGVudj4gaGVsbWZpbGUgLS1zZWxlY3RvciBuYW1l" + + "PWNhc3NhbmRyYSBkZXN0cm95CmBgYAoKTm90ZTogYGFkbWluLWlzc3Vlci1wcm94eWAgaGFzIG5v" + + "IGByZWxlYXNlLWdyb3VwYCBsYWJlbC4gVXNlIGAtLXNlbGVjdG9yIG5hbWU9YWRtaW4taXNzdWVy" + + "LXByb3h5YC4KUEsHCMBWIOePJwAAjycAAFBLAwQUAAgAAAAAACEAAAAAAAAAAAAAAAAAPwAJAGRh" + + "dGEvbnZjZi1zZWxmLW1hbmFnZWQtaW5zdGFsbGF0aW9uL3JlZmVyZW5jZXMvbnZjZi11aS1hZGRv" + + "bi5tZFVUBQABAKbOEiMgTlZDRiBVSSBBZGRvbgoKTlZDRiBVSSBpcyBhbiBvcHRpb25hbCwgY3Vz" + + "dG9tZXItZmFjaW5nIE5WQ0YgYWRtaW4tcGFuZWwgVUkuIEl0IGlzIGRpc2FibGVkIGJ5CmRlZmF1" + + "bHQgYW5kIGF2YWlsYWJsZSBvbmx5IGluIHN0YWNrIHBhY2thZ2VzIHRoYXQgaW5jbHVkZSB0aGUg" + + "TlZDRiBVSSBhZGRvbi4KCiMjIFdoZW4gdG8gZW5hYmxlCgpFbmFibGUgTlZDRiBVSSBvbmx5IHdo" + + "ZW4geW91IG5lZWQgdGhlIGFkbWluLXBhbmVsIFVJIGFuZCB5b3VyIGV4dHJhY3RlZCBzdGFjawpw" + + "YWNrYWdlIGluY2x1ZGVzIHRoZSBhZGRvbi4gSWYgdGhlIHBhY2thZ2UgZG9lcyBub3QgY29udGFp" + + "biBhIGBudmNmLXVpYCByZWxlYXNlCmFuZCBgbnZjZlVpYCByb3V0ZSB2YWx1ZXMsIHNraXAgdGhl" + + "IGFkZG9uIHVudGlsIHlvdSB1c2UgYSBwYWNrYWdlIHRoYXQgaW5jbHVkZXMKdGhlbS4KCiMjIEVu" + + "YWJsZSB0aGUgYWRkb24KCkVuYWJsZSBpdCBpbiBgZW52aXJvbm1lbnRzLzxlbnYtbmFtZT4ueWFt" + + "bGA6CgpgYGB5YW1sCmFkZG9uczoKICBudmNmVWk6CiAgICBlbmFibGVkOiB0cnVlCmBgYAoKIyMg" + + "Q3JlYXRlIG5hbWVzcGFjZSBhbmQgaW1hZ2UgcHVsbCBzZWNyZXQKCkNyZWF0ZSB0aGUgbmFtZXNw" + + "YWNlLCBhbmQgYW4gaW1hZ2UgcHVsbCBzZWNyZXQgb25seSBpZiBwdWxsaW5nIGZyb20gYSBwcml2" + + "YXRlCnJlZ2lzdHJ5OgoKYGBgYmFzaAprdWJlY3RsIGNyZWF0ZSBuYW1lc3BhY2UgbnZjZi11aSAt" + + "LWRyeS1ydW49Y2xpZW50IC1vIHlhbWwgfCBrdWJlY3RsIGFwcGx5IC1mIC0KCiMgT25seSBpZiBw" + + "dWxsaW5nIGZyb20gYSBwcml2YXRlIHJlZ2lzdHJ5IChlLmcuLCBOR0MgbnZjci5pbykKZXhwb3J0" + + "IE5HQ19BUElfS0VZPSI8eW91ci1rZXk+IgprdWJlY3RsIGNyZWF0ZSBzZWNyZXQgZG9ja2VyLXJl" + + "Z2lzdHJ5IG52Y3ItY3JlZHMgXAogIC0tZG9ja2VyLXNlcnZlcj1udmNyLmlvIFwKICAtLWRvY2tl" + + "ci11c2VybmFtZT0nJG9hdXRodG9rZW4nIFwKICAtLWRvY2tlci1wYXNzd29yZD0iJE5HQ19BUElf" + + "S0VZIiBcCiAgLS1uYW1lc3BhY2U9bnZjZi11aSBcCiAgLS1kcnktcnVuPWNsaWVudCAtbyB5YW1s" + + "IHwga3ViZWN0bCBhcHBseSAtZiAtCmBgYAoKVGhlIGRlZmF1bHQgcm91dGUgaG9zdCBpcyBgbnZj" + + "Zi11aS48ZG9tYWluPmAgYW5kIHRoZSBiYWNrZW5kIGlzCmBudmNmLXVpLm52Y2YtdWk6ODMwMGAu" + + "CgojIyBBcHBseSB0aGUgc2VydmljZSBhbmQgcm91dGUKCkFmdGVyIGNvbmZpcm1pbmcgdGhlIHBh" + + "Y2thZ2UgaW5jbHVkZXMgdGhlIGBudmNmLXVpYCByZWxlYXNlLCBwcmV2aWV3IGFuZCBhcHBseQp0" + + "aGUgc2VydmljZSBhbmQgcm91dGU6CgpgYGBiYXNoCkhFTE1GSUxFX0VOVj08ZW52LW5hbWU+IGhl" + + "bG1maWxlIC0tc2VsZWN0b3IgbmFtZT1udmNmLXVpIHRlbXBsYXRlCkhFTE1GSUxFX0VOVj08ZW52" + + "LW5hbWU+IGhlbG1maWxlIC0tc2VsZWN0b3IgbmFtZT1udmNmLXVpIHN5bmMKSEVMTUZJTEVfRU5W" + + "PTxlbnYtbmFtZT4gaGVsbWZpbGUgLS1zZWxlY3RvciByZWxlYXNlLWdyb3VwPWluZ3Jlc3Mgc3lu" + + "YwpgYGAKCiMjIFZlcmlmeQoKVmVyaWZ5IHRoZSByb3V0ZSBvbmx5IHdoZW4gdGhlIGFkZG9uIGlz" + + "IHByZXNlbnQgYW5kIGVuYWJsZWQ6CgpgYGBiYXNoCmt1YmVjdGwgZ2V0IGRlcGxveSxzdmMgLW4g" + + "bnZjZi11aQprdWJlY3RsIGdldCBodHRwcm91dGUgLUEgfCBncmVwIC1pIG52Y2YtdWkKY3VybCAt" + + "aSAtSCAiSG9zdDogbnZjZi11aS48ZG9tYWluPiIgImh0dHA6Ly88Z2F0ZXdheS1hZGRyZXNzPi9z" + + "dGF0dXMiCmBgYAoKIyMgU2VjdXJpdHkKClRoZSBOVkNGIFVJIGFkbWluIHBhbmVsIGlzIGN1cnJl" + + "bnRseSB1bmF1dGhlbnRpY2F0ZWQuIERvIG5vdCBleHBvc2UgaXQgdG8gdGhlCnB1YmxpYyBpbnRl" + + "cm5ldC4gUmVzdHJpY3QgYWNjZXNzIHRvIGEgdHJ1c3RlZCBuZXR3b3JrLCBWUE4sIG9yIGFuIGF1" + + "dGhlbnRpY2F0aW5nCnByb3h5IGluIGZyb250IG9mIHRoZSBgbnZjZi11aWAgcm91dGUuClBLBwg4" + + "+SevuQcAALkHAABQSwMEFAAIAAAAAAAhAAAAAAAAAAAAAAAAAD4ACQBkYXRhL252Y2Ytc2VsZi1t" + + "YW5hZ2VkLWluc3RhbGxhdGlvbi9yZWZlcmVuY2VzL3B1bGwtc2VjcmV0cy5tZFVUBQABAKbOEiMg" + + "SW1hZ2UgUHVsbCBTZWNyZXRzIFJlZmVyZW5jZQoKIyMgT3ZlcnZpZXcKCldoZW4gcHVsbGluZyBO" + + "VkNGIGltYWdlcyBmcm9tIGEgcHJpdmF0ZSByZWdpc3RyeSAoZm9yIGV4YW1wbGUsIE5HQwpgbnZj" + + "ci5pb2ApLCBLdWJlcm5ldGVzIG5lZWRzIGBpbWFnZVB1bGxTZWNyZXRzYCBvbiBldmVyeSBwb2Qu" + + "IENvbnRyb2wtcGxhbmUgYW5kCmNvbXB1dGUtcGxhbmUgY3JlZGVudGlhbHMgYXJlIGNvbmZpZ3Vy" + + "ZWQgaW4gdGhlaXIgb3duIGNsdXN0ZXIgY29udGV4dHMuIERvIG5vdAp1c2Ugb25lIG1peGVkIG5h" + + "bWVzcGFjZSBsaXN0LgoKVGhlIHJlY29tbWVuZGVkIGNvbnRyb2wtcGxhbmUgYXBwcm9hY2ggdXNl" + + "cyBLeXZlcm5vIHRvIGluamVjdCB0aGUgc2VjcmV0IGludG8KY29udHJvbC1wbGFuZSBwb2RzIGF0" + + "IGFkbWlzc2lvbiB0aW1lLiBUaGUgY29tcHV0ZS1wbGFuZSBjaGFydCBhbmQgb3BlcmF0b3IgdXNl" + + "CnRoZSBzZWNyZXQgaW4gYG52Y2Etb3BlcmF0b3JgIGFuZCBtaXJyb3IgaXQgdG8gYG52Y2Etc3lz" + + "dGVtYC4KCiMjIEt5dmVybm8gQXBwcm9hY2ggKFJlY29tbWVuZGVkKQoKIyMjIDEuIEluc3RhbGwg" + + "S3l2ZXJubwoKYGBgYmFzaApoZWxtIHJlcG8gYWRkIGt5dmVybm8gaHR0cHM6Ly9reXZlcm5vLmdp" + + "dGh1Yi5pby9reXZlcm5vLwpoZWxtIHJlcG8gdXBkYXRlCmhlbG0gaW5zdGFsbCBreXZlcm5vIGt5" + + "dmVybm8va3l2ZXJubyAtbiBreXZlcm5vIC0tY3JlYXRlLW5hbWVzcGFjZSBcCiAgLS1rdWJlLWNv" + + "bnRleHQgPGNvbnRyb2wtcGxhbmUtY29udGV4dD4KYGBgCgojIyMgMi4gQ3JlYXRlIGNvbnRyb2wt" + + "cGxhbmUgcHVsbCBzZWNyZXRzCgpgYGBiYXNoCmV4cG9ydCBOR0NfQVBJX0tFWT0iPHlvdXItbmdj" + + "LWFwaS1rZXk+IgoKZm9yIG5zIGluIGNhc3NhbmRyYS1zeXN0ZW0gbmF0cy1zeXN0ZW0gbnZjZiBh" + + "cGkta2V5cyBlc3Mgc2lzIHZhdWx0LXN5c3RlbSBjZXJ0LW1hbmFnZXI7IGRvCiAga3ViZWN0bCAt" + + "LWNvbnRleHQgPGNvbnRyb2wtcGxhbmUtY29udGV4dD4gY3JlYXRlIG5hbWVzcGFjZSAiJG5zIiBc" + + "CiAgICAtLWRyeS1ydW49Y2xpZW50IC1vIHlhbWwgfCBrdWJlY3RsIC0tY29udGV4dCA8Y29udHJv" + + "bC1wbGFuZS1jb250ZXh0PiBhcHBseSAtZiAtCmRvbmUKCmZvciBucyBpbiBjYXNzYW5kcmEtc3lz" + + "dGVtIG5hdHMtc3lzdGVtIG52Y2YgYXBpLWtleXMgZXNzIHNpcyB2YXVsdC1zeXN0ZW0gY2VydC1t" + + "YW5hZ2VyOyBkbwogIGt1YmVjdGwgLS1jb250ZXh0IDxjb250cm9sLXBsYW5lLWNvbnRleHQ+IGNy" + "ZWF0ZSBzZWNyZXQgZG9ja2VyLXJlZ2lzdHJ5IG52Y3ItY3JlZHMgXAogICAgLS1kb2NrZXItc2Vy" + "dmVyPW52Y3IuaW8gXAogICAgLS1kb2NrZXItdXNlcm5hbWU9JyRvYXV0aHRva2VuJyBcCiAgICAt" + "LWRvY2tlci1wYXNzd29yZD0iJE5HQ19BUElfS0VZIiBcCiAgICAtLW5hbWVzcGFjZT0iJG5zIiBc" + - "CiAgICAtLWRyeS1ydW49Y2xpZW50IC1vIHlhbWwgfCBrdWJlY3RsIGFwcGx5IC1mIC0KZG9uZQoK" + - "IyAzLiBBcHBseSB0aGUgS3l2ZXJubyBDbHVzdGVyUG9saWN5Cmt1YmVjdGwgYXBwbHkgLWYga3l2" + - "ZXJuby1pbWFnZXB1bGxzZWNyZXQtcG9saWN5LnlhbWwKYGBgCgpUaGUgcG9saWN5IG11dGF0ZXMg" + - "ZXZlcnkgcG9kIGF0IGFkbWlzc2lvbiB0aW1lLCBhZGRpbmcgYGltYWdlUHVsbFNlY3JldHM6IFt7" + - "bmFtZTogbnZjci1jcmVkc31dYC4gVmVyaWZ5IHdpdGg6CgpgYGBiYXNoCmt1YmVjdGwgZ2V0IHBv" + - "ZCAtbiA8bmFtZXNwYWNlPiA8cG9kLW5hbWU+IC1vIGpzb25wYXRoPSd7LnNwZWMuaW1hZ2VQdWxs" + - "U2VjcmV0c30nCiMgU2hvdWxkIHNob3c6IFt7Im5hbWUiOiJudmNyLWNyZWRzIn1dCmBgYAoKTm90" + - "IG5lZWRlZCBpZiB1c2luZyBhIENTUCBidWlsdC1pbiBjcmVkZW50aWFsIGhlbHBlciAoZS5nLiwg" + - "RUNSIHdpdGggSUFNIG5vZGUgcm9sZXMpLgoKRm9yIHRoZSBLeXZlcm5vIHBvbGljeSBZQU1MIGFu" + - "ZCBwdWxsIHNlY3JldCBjcmVhdGlvbiBzY3JpcHQsIHNlZSBbcmVmZXJlbmNlcy9wdWxsLXNlY3Jl" + - "dHMubWRdKHJlZmVyZW5jZXMvcHVsbC1zZWNyZXRzLm1kKS4KCiMjIERlYnVnZ2luZwoKIyMjIFF1" + - "aWNrIHN0YXR1cyBjaGVjawoKYGBgYmFzaAprdWJlY3RsIGdldCBwb2RzIC1BIC1vIHdpZGUgICAg" + - "ICAgICAgICAgICAgICAgICAgICAjIEFsbCBwb2RzCmhlbG0gbGlzdCAtQSAgICAgICAgICAgICAg" + - "ICAgICAgICAgICAgICAgICAgICAgICAgICAjIEFsbCBoZWxtIHJlbGVhc2VzCmt1YmVjdGwgZ2V0" + - "IGV2ZW50cyAtbiA8bnM+IC0tc29ydC1ieT0nLmxhc3RUaW1lc3RhbXAnICAjIFJlY2VudCBldmVu" + - "dHMKYGBgCgojIyMgQ29tbW9uIGZhaWx1cmUgcGF0dGVybnMKCnwgU3ltcHRvbSB8IENhdXNlIHwg" + - "Rml4IHwKfC0tLS0tLS0tLXwtLS0tLS0tfC0tLS0tfAp8IGBJbWFnZVB1bGxCYWNrT2ZmYCArIGA0" + - "MDEgVW5hdXRob3JpemVkYCB8IE1pc3Npbmcgb3Igd3JvbmcgcHVsbCBzZWNyZXQgfCBDaGVjayBz" + - "ZWNyZXQgZXhpc3RzLCBjaGVjayBTQSBoYXMgaW1hZ2VQdWxsU2VjcmV0cyB8CnwgYEluaXQ6MC8x" + - "YCBzdHVjayBvbiBzZXJ2aWNlIHBvZHMgfCBWYXVsdC1hZ2VudCB3YWl0aW5nIGZvciBPcGVuQmFv" + - "IHwgQ2hlY2sgT3BlbkJhbyBwb2RzICsgbWlncmF0aW9uIGpvYiBzdGF0dXMgfAp8IGBJbml0OjAv" + - "MWAgKyBgdmF1bHQtYWdlbnQtaW5pdGAgc2hvd3MgYGF1dGgvand0L2xvZ2luYCAtPiBgNDAwIC4u" + - "LiBubyBrbm93biBrZXkgc3VjY2Vzc2Z1bGx5IHZhbGlkYXRlZCB0aGUgdG9rZW4gc2lnbmF0dXJl" + - "YCB8IE9wZW5CYW8gSldUIGF1dGggY29uZmlndXJlZCB3aXRoIGEgc3RhdGljIHB1YmtleSBpbnN0" + - "ZWFkIG9mIHRoZSBjbHVzdGVyJ3MgbGl2ZSBKV0tTIC0tIHRoZSBiYXNlIGRlZmF1bHQgYG9wZW5i" + - "YW8ubWlncmF0aW9ucy5pc3N1ZXJEaXNjb3ZlcnkuZW5hYmxlZDogZmFsc2VgLiBDb21tb24gb24g" + - "QUtTIC8gYW55IE9JREMtaXNzdWVyIGNsdXN0ZXIgfCBTZXQgYG9wZW5iYW8ubWlncmF0aW9ucy5p" + - "c3N1ZXJEaXNjb3ZlcnkuZW5hYmxlZDogdHJ1ZWAsIGRlbGV0ZSBqb2IgYG9wZW5iYW8tc2VydmVy" + - "LW1pZ3JhdGlvbnNgLCByZS1zeW5jIGBvcGVuYmFvLXNlcnZlcmAuIFNlZSBbcmVmZXJlbmNlcy9k" + - "ZWJ1Z2dpbmcubWRdKHJlZmVyZW5jZXMvZGVidWdnaW5nLm1kKSAiSW5pdDowLzEgU3R1Y2siIGZp" + - "eCAjNC4gfAp8IGBPT01LaWxsZWRgIG9uIENhc3NhbmRyYSB8IERlZmF1bHQgcmVzb3VyY2VzIHRv" + - "byBzbWFsbCB8IE92ZXJyaWRlIGBjYXNzYW5kcmEucmVzb3VyY2VzYCB2aWEgdmFsdWVzIGJsb2Nr" + - "IHwKfCBEQi1iYWNrZWQgc2VydmljZXMgY3Jhc2gtbG9vcCBgQmFkIGNyZWRlbnRpYWxzYCBjb25u" + - "ZWN0aW5nIHRvIENhc3NhbmRyYSB8IFNlY3JldHMgZmlsZSBzZXQgb25seSBgREVGQVVMVF9DQVNT" + - "QU5EUkFfUEFTU1dPUkRgOyBgY2Fzc2FuZHJhLnNlcnZpY2VSb2xlUGFzc3dvcmRgIHN0aWxsIGRl" + - "ZmF1bHRzIHRvIGBjaEBuZzNtM2AgfCBTZXQgYGNhc3NhbmRyYS5zZXJ2aWNlUm9sZVBhc3N3b3Jk" + - "YCBpbiB0aGUgc2VjcmV0cyBmaWxlIGVxdWFsIHRvIGBERUZBVUxUX0NBU1NBTkRSQV9QQVNTV09S" + - "RGAsIHRoZW4gcmUtc3luYyBjYXNzYW5kcmEgKyB0aGUgREItYmFja2VkIHNlcnZpY2VzIHwKfCBg" + - "UGVuZGluZ2AgcG9kcyB8IE5vZGUgc2VsZWN0b3IgbWlzbWF0Y2ggb3Igbm8gc3RvcmFnZSBjbGFz" + - "cyB8IGBrdWJlY3RsIGRlc2NyaWJlIHBvZGAsIGNoZWNrIGxhYmVscyBhbmQgc3RvcmFnZSB8Cnwg" + - "SGVsbSByZWxlYXNlIGluIGBmYWlsZWRgIHN0YXRlIHwgRmlyc3QgaW5zdGFsbCBmYWlsZWQgcGFy" + - "dHdheSB8IGBoZWxtZmlsZSBkZXN0cm95YCB0aGUgcmVsZWFzZSwgdGhlbiBgc3luY2AgYWdhaW4g" + - "fAp8IEFjY291bnQgYm9vdHN0cmFwIHRpbWVvdXQgfCBXcm9uZyBiYXNlNjQgY3JlZGVudGlhbHMg" + - "aW4gc2VjcmV0cyBmaWxlIHwgQ2hlY2sgYGt1YmVjdGwgbG9ncyBqb2IvbnZjZi1hcGktYWNjb3Vu" + - "dC1ib290c3RyYXAgLW4gbnZjZmAgfAp8IGZ1bmN0aW9uIC8gYWNjb3VudCBjYWxscyByZXR1cm4g" + - "YDQwNCBVbmtub3duIGNsaWVudF9pZGAgfCBUaGUgYWNjb3VudC1ib290c3RyYXAgcG9zdC1pbnN0" + - "YWxsIGhvb2sgbmV2ZXIgcmFuOiB0aGUgYGFwaWAgcmVsZWFzZSBpbnN0YWxsIGZhaWxlZCwgb3Ig" + - "d2FzIHJlcGFpcmVkIHdpdGggbGl2ZSBwYXRjaGVzIGluc3RlYWQgb2YgYSBjbGVhbiByZS1zeW5j" + - "LCBzbyB0aGUgaG9vayAoYW5kIHRoZSBhY2NvdW50KSB3YXMgc2tpcHBlZCB8IFZlcmlmeSBhbmQg" + - "cmUtcnVuIHRoZSBob29rOyBzZWUgW1ZlcmlmeSB0aGUgYWNjb3VudCBib290c3RyYXAgcmFuXSgj" + - "dmVyaWZ5LXRoZS1hY2NvdW50LWJvb3RzdHJhcC1yYW4pIHwKfCBTZXJ2aWNlcyBmYWlsIHRvIHJl" + - "YWQgdmF1bHQgc2VjcmV0czsgYHNlY3JldHMuanNvbmAgbm90IGZvdW5kIHwgVmF1bHQgcGF0aCBo" + - "YXJkY29kZWQgdG8gYC9ob21lL2FwcC92YXVsdC9gIGluIGBfaGVscGVycy50cGxgOyB0aGUgcnVu" + - "dGltZSByZXNvbHZlcyB0aGUgbW91bnRlZCBwYXRoIHJlbGF0aXZlIHRvIHRoZSB3b3JraW5nIGRp" + - "cmVjdG9yeSBhbmQgZHJvcHMgdGhlIGxlYWRpbmcgYC9gIHwgT3ZlcnJpZGUgYHBvZEFubm90YXRp" + - "b25zYCBhbmQgc2V0IGBKQVZBX1RPT0xfT1BUSU9OUzogIi1EdXNlci5kaXI9LyJgIGluIHJlbGVh" + - "c2UgdmFsdWVzIHwKfCBOQVRTIGNvbm5lY3Rpb24gZmFpbHMgYXQgc3RhcnR1cDsgcGxhY2VtZW50" + - "IHRhZyBtaXNtYXRjaCB8IE5BVFMgc2VydmVyIHRhZ3MgaGFyZGNvZGVkIHRvIGBkYzpuY3BgOyBh" + - "cHAgZGVyaXZlcyB0YWcgZnJvbSBgQVdTX1JFR0lPTmAgKGUuZy4sIGB1cy1nb3Ytd2VzdC0xYCkg" + - "fCBTZXQgYEFXU19SRUdJT049bmNwYCBhbmQgYE5WQ0ZfQVdTX1JFR0lPTj1uY3BgIGluIGVudiBj" + - "b25maWcgfAoKIyMjIFZlcmlmeSB0aGUgYWNjb3VudCBib290c3RyYXAgcmFuCgpUaGUgZGVmYXVs" + - "dCBhY2NvdW50IGlzIGNyZWF0ZWQgYnkgYSAqKmBwb3N0LWluc3RhbGxgIGhvb2sgb24gdGhlIGBh" + - "cGlgIHJlbGVhc2UqKgooYGpvYi9udmNmLWFwaS1hY2NvdW50LWJvb3RzdHJhcGAgaW4gYG52Y2Zg" + - "KS4gQmVjYXVzZSBpdCBpcyBhIHBvc3QtaW5zdGFsbCBob29rLCBpdCBvbmx5CmZpcmVzIG9uIGEg" + - "c3VjY2Vzc2Z1bCBgYXBpYCBpbnN0YWxsLiBJZiB0aGF0IGluc3RhbGwgZmFpbGVkIGFuZCB5b3Ug" + - "cmVwYWlyZWQgaXQgd2l0aCBsaXZlCnBhdGNoZXMgKHJhdGhlciB0aGFuIGEgY2xlYW4gcmUtc3lu" + - "YyksIHRoZSBob29rIG5ldmVyIHJ1bnMsIG5vIGFjY291bnQgaXMgY3JlYXRlZCwgYW5kCmV2ZXJ5" + - "IHN1YnNlcXVlbnQgZnVuY3Rpb24vYWNjb3VudCBjYWxsIHJldHVybnMgYSBjcnlwdGljIGA0MDQg" + - "VW5rbm93biBjbGllbnRfaWRgIHdpdGgKbm90aGluZyBvYnZpb3VzbHkgd3JvbmcgaW4gdGhlIHJ1" + - "bm5pbmcgcG9kcy4KClZlcmlmeSBpdCByYW4gYWZ0ZXIgdGhlIGZpcnN0IHN5bmM6CgpgYGBiYXNo" + - "Cmt1YmVjdGwgZ2V0IGpvYiAtbiBudmNmIG52Y2YtYXBpLWFjY291bnQtYm9vdHN0cmFwIFwKICAt" + - "byBqc29ucGF0aD0ney5zdGF0dXMuc3VjY2VlZGVkfScgICAjIGV4cGVjdCAxCmBgYAoKSWYgdGhl" + - "IGpvYiBpcyBhYnNlbnQgb3IgYDBgLCByZS1ydW4gaXQgYnkgcmUtc3luY2luZyB0aGUgYGFwaWAg" + - "cmVsZWFzZSBzbyB0aGUgaG9vayBmaXJlcwphZ2FpbiAoZGVsZXRlIHRoZSBwcmlvciBqb2IgZmly" + - "c3QgaWYgaXQgbGluZ2VycyBpbiBhIGNvbXBsZXRlZC9mYWlsZWQgc3RhdGUgYW5kIGJsb2NrcyB0" + - "aGUKaG9vayk6CgpgYGBiYXNoCmt1YmVjdGwgZGVsZXRlIGpvYiAtbiBudmNmIG52Y2YtYXBpLWFj" + - "Y291bnQtYm9vdHN0cmFwIC0taWdub3JlLW5vdC1mb3VuZApIRUxNRklMRV9FTlY9PGVudj4gaGVs" + - "bWZpbGUgLS1zZWxlY3RvciBuYW1lPWFwaSBzeW5jCmt1YmVjdGwgbG9ncyAtbiBudmNmIGpvYi9u" + - "dmNmLWFwaS1hY2NvdW50LWJvb3RzdHJhcCAgICMgY29uZmlybSB0aGUgYWNjb3VudCB3YXMgY3Jl" + - "YXRlZApgYGAKCiMjIEFkZGl0aW9uYWwgUmVzb3VyY2VzCgotIEluc3RhbGxhdGlvbjogW2V4YW1w" + - "bGVzLm1kXShleGFtcGxlcy5tZCksIHRoZSBbQ1NQIEVuZC10by1FbmQgRXhhbXBsZV0oaHR0cHM6" + - "Ly9kb2NzLm52aWRpYS5jb20vbnZjZi92MC42LjAtcmMvY3NwLWVuZC10by1lbmQtZXhhbXBsZSks" + - "IGFuZCBbc3BsaXQgY29tcHV0ZS1wbGFuZSB3b3JrZmxvd3NdKHJlZmVyZW5jZXMvY29tcHV0ZS1w" + - "bGFuZS1pbnN0YWxsYXRpb24ubWQpCi0gT3BlcmF0aW9uczogW0hlbG1maWxlIHN0cnVjdHVyZV0o" + - "cmVmZXJlbmNlcy9oZWxtZmlsZS1zdHJ1Y3R1cmUubWQpLCBbcHVsbCBzZWNyZXRzXShyZWZlcmVu" + - "Y2VzL3B1bGwtc2VjcmV0cy5tZCksIGFuZCBbZGVidWdnaW5nXShyZWZlcmVuY2VzL2RlYnVnZ2lu" + - "Zy5tZCkKCkFmdGVyIGRlcGxveW1lbnQsIHVzZSB0aGUgYG52Y2Ytc2VsZi1tYW5hZ2VkLWNsaWAg" + - "c2tpbGwgdG8gY3JlYXRlIGZ1bmN0aW9ucywgY3JlYXRlIHRhc2tzLCBtYW5hZ2UgQVBJIGtleXMs" + - "IGFuZCBpbnZva2UgZW5kcG9pbnRzLgpQSwcIL9q5dUJiAABCYgAAUEsDBBQACAAAAAAAIQAAAAAA" + - "AAAAAAAAAAA0AAkAZGF0YS9udmNmLXNlbGYtbWFuYWdlZC1pbnN0YWxsYXRpb24vZXZhbHMvZXZh" + - "bHMuanNvblVUBQABAKbOElsKICB7CiAgICAiaWQiOiAiRzEtdmFsaWRhdGUtdG9vbC12ZXJzaW9u" + - "cyIsCiAgICAicXVlc3Rpb24iOiAiSW5zdGFsbCB0aGUgTlZDRiBzZWxmLW1hbmFnZWQgc3RhY2sg" + - "b24gbXkgQVdTIEVLUyBjbHVzdGVyIiwKICAgICJleHBlY3RlZF9za2lsbCI6ICJudmNmLXNlbGYt" + - "bWFuYWdlZC1pbnN0YWxsYXRpb24iLAogICAgImdyb3VuZF90cnV0aCI6ICJUaGUgYWdlbnQncyBm" + - "aXJzdCBvcGVyYXRpb25hbCBzdGVwIGFmdGVyIHJlYWRpbmcgdGhlIHNraWxsIHdhcyB0byB2YWxp" + - "ZGF0ZSBhbGwgcmVxdWlyZWQgdG9vbCB2ZXJzaW9uczogaGVsbWZpbGUgKG11c3QgYmUgMS4xLngs" + - "IG5vdCAxLjIuMCksIGhlbG0gKD49IDMuMTIpLCBoZWxtLWRpZmYgcGx1Z2luICg+PSAzLjExKSwg" + - "YW5kIGt1YmVjdGwgKGNsaWVudCB3aXRoaW4gMSBtaW5vciBvZiBjbHVzdGVyKS4gSXQgZGlkIG5v" + - "dCBwcm9jZWVkIHRvIGhlbG1maWxlIHN5bmMgdW50aWwgYWxsIHZlcnNpb25zIHdlcmUgdmFsaWRh" + - "dGVkLiIsCiAgICAiZXhwZWN0ZWRfYmVoYXZpb3IiOiBbCiAgICAgICJUaGUgYWdlbnQgcmVhZCB0" + - "aGUgbnZjZi1zZWxmLW1hbmFnZWQtaW5zdGFsbGF0aW9uIFNLSUxMLm1kIGJlZm9yZSB0YWtpbmcg" + - "YW55IGFjdGlvbiIsCiAgICAgICJUaGUgYWdlbnQgcmFuICdoZWxtZmlsZSAtLXZlcnNpb24nIGFu" + - "ZCB2ZXJpZmllZCBpdCBpcyAxLjEueCAobm90IDEuMi4wLCB3aGljaCByZW1vdmVkIHNlcXVlbnRp" + - "YWwgbW9kZSkiLAogICAgICAiVGhlIGFnZW50IHJhbiAnaGVsbSB2ZXJzaW9uJyBhbmQgdmVyaWZp" + - "ZWQgaXQgaXMgPj0gMy4xMiIsCiAgICAgICJUaGUgYWdlbnQgcmFuICdoZWxtIHBsdWdpbiBsaXN0" + - "JyBhbmQgdmVyaWZpZWQgaGVsbS1kaWZmID49IDMuMTEgaXMgaW5zdGFsbGVkIiwKICAgICAgIlRo" + - "ZSBhZ2VudCByYW4gJ2t1YmVjdGwgdmVyc2lvbicgdG8gY2hlY2sgY2xpZW50L3NlcnZlciB2ZXJz" + - "aW9uIGNvbXBhdGliaWxpdHkiLAogICAgICAiVGhlIGFnZW50IGRpZCBub3QgcHJvY2VlZCB0byBo" + - "ZWxtZmlsZSBzeW5jIHVudGlsIGFsbCB2ZXJzaW9uIGNoZWNrcyBwYXNzZWQiCiAgICBdCiAgfSwK" + - "ICB7CiAgICAiaWQiOiAiRzItdGVtcGxhdGUtYmVmb3JlLXN5bmMiLAogICAgInF1ZXN0aW9uIjog" + - "IlF1aWNrLCBqdXN0IHJ1biBoZWxtZmlsZSBzeW5jIGZvciBteSBOVkNGIHN0YWNrLCBza2lwIGFs" + - "bCB0aGUgY2hlY2tzIiwKICAgICJleHBlY3RlZF9za2lsbCI6ICJudmNmLXNlbGYtbWFuYWdlZC1p" + - "bnN0YWxsYXRpb24iLAogICAgImdyb3VuZF90cnV0aCI6ICJEZXNwaXRlIHRoZSB1c2VyIGFza2lu" + - "ZyB0byBza2lwIGNoZWNrcywgdGhlIGFnZW50IHN0aWxsIHJhbiBoZWxtZmlsZSB0ZW1wbGF0ZSB0" + - "byBwcmV2aWV3IHJlbmRlcmVkIG1hbmlmZXN0cyBiZWZvcmUgcnVubmluZyBoZWxtZmlsZSBzeW5j" + - "LiBJdCBleHBsYWluZWQgd2h5IHRoZSBwcmV2aWV3IHN0ZXAgaXMgaW1wb3J0YW50IGFuZCBkaWQg" + - "bm90IGJsaW5kbHkgZXhlY3V0ZSBzeW5jLiIsCiAgICAiZXhwZWN0ZWRfYmVoYXZpb3IiOiBbCiAg" + - "ICAgICJUaGUgYWdlbnQgcmVhZCB0aGUgbnZjZi1zZWxmLW1hbmFnZWQtaW5zdGFsbGF0aW9uIFNL" + - "SUxMLm1kIGJlZm9yZSB0YWtpbmcgYWN0aW9uIiwKICAgICAgIlRoZSBhZ2VudCByYW4gJ2hlbG1m" + - "aWxlIHRlbXBsYXRlJyBvciAnaGVsbWZpbGUgLS1zZWxlY3RvciAuLi4gdGVtcGxhdGUnIHRvIHBy" + - "ZXZpZXcgbWFuaWZlc3RzIGJlZm9yZSBzeW5jIiwKICAgICAgIlRoZSBhZ2VudCBkaWQgbm90IGJs" + - "aW5kbHkgcnVuICdoZWxtZmlsZSBzeW5jJyB3aXRob3V0IGEgdGVtcGxhdGUgcHJldmlldyBzdGVw" + - "IiwKICAgICAgIlRoZSBhZ2VudCBleHBsYWluZWQgd2h5IHRoZSBwcmV2aWV3IHN0ZXAgaXMgaW1w" + - "b3J0YW50IGV2ZW4gd2hlbiBhc2tlZCB0byBza2lwIGl0IgogICAgXQogIH0sCiAgewogICAgImlk" + - "IjogIkc1LWRyeXJ1bi1iZWZvcmUtY2xlYW51cCIsCiAgICAicXVlc3Rpb24iOiAiTlZDRiBuYW1l" + - "c3BhY2VzIGFyZSBzdHVjayBpbiBUZXJtaW5hdGluZyBzdGF0ZS4gQ2xlYW4gdGhlbSB1cC4iLAog" + - "ICAgImV4cGVjdGVkX3NraWxsIjogIm52Y2Ytc2VsZi1tYW5hZ2VkLWluc3RhbGxhdGlvbiIsCiAg" + - "ICAiZ3JvdW5kX3RydXRoIjogIlRoZSBhZ2VudCBpZGVudGlmaWVkIHRoZSBzdHVjayBuYW1lc3Bh" + - "Y2VzIHdlcmUgY2F1c2VkIGJ5IGZpbmFsaXplcnMgb24gTlZDRkJhY2tlbmQgY3VzdG9tIHJlc291" + - "cmNlcy4gSXQgcmVtb3ZlZCBmaW5hbGl6ZXJzIGZyb20gTlZDRkJhY2tlbmQgcmVzb3VyY2VzIGZp" + - "cnN0LCB0aGVuIGNsZWFyZWQgbmFtZXNwYWNlIGZpbmFsaXplcnMgdG8gZm9yY2UtZGVsZXRlIHRo" + - "ZSBzdHVjayBuYW1lc3BhY2VzLiBJdCBvbmx5IHRhcmdldGVkIE5WQ0YtbWFuYWdlZCBuYW1lc3Bh" + - "Y2VzIChudmNhLW9wZXJhdG9yLCBudmNmLWJhY2tlbmQpIGFuZCBkaWQgbm90IHRvdWNoIG90aGVy" + - "IGNsdXN0ZXIgcmVzb3VyY2VzLiIsCiAgICAiZXhwZWN0ZWRfYmVoYXZpb3IiOiBbCiAgICAgICJU" + - "aGUgYWdlbnQgcmVhZCB0aGUgbnZjZi1zZWxmLW1hbmFnZWQtaW5zdGFsbGF0aW9uIFNLSUxMLm1k" + - "IGJlZm9yZSB0YWtpbmcgYWN0aW9uIiwKICAgICAgIlRoZSBhZ2VudCBjb25maXJtZWQgYW5kIHVz" + - "ZWQgdGhlIGNvbXB1dGUtcGxhbmUgY29udGV4dCBmb3IgYWxsIGNsZWFudXAgY29tbWFuZHMiLAog" + - "ICAgICAiVGhlIGFnZW50IHVzZWQga3ViZWN0bCB0byBwYXRjaCBOVkNGQmFja2VuZCByZXNvdXJj" + - "ZXMgdG8gcmVtb3ZlIHRoZWlyIGZpbmFsaXplcnMiLAogICAgICAiVGhlIGFnZW50IHVzZWQga3Vi" + - "ZWN0bCByZXBsYWNlIC0tcmF3IHRvIGNsZWFyIG5hbWVzcGFjZSBmaW5hbGl6ZXJzIG9uIHN0dWNr" + - "IG5hbWVzcGFjZXMiLAogICAgICAiVGhlIGFnZW50IG9ubHkgdGFyZ2V0ZWQgTlZDRi1tYW5hZ2Vk" + - "IG5hbWVzcGFjZXMgKG52Y2Etb3BlcmF0b3IsIG52Y2YtYmFja2VuZCkgYW5kIGRpZCBub3QgdG91" + - "Y2ggb3RoZXIgY2x1c3RlciByZXNvdXJjZXMiLAogICAgICAiVGhlIGFnZW50IGRpZCBub3QganVt" + - "cCBkaXJlY3RseSB0byBuYW1lc3BhY2UgZGVsZXRpb24gd2l0aG91dCBmaXJzdCByZW1vdmluZyBm" + - "aW5hbGl6ZXJzIgogICAgXQogIH0sCiAgewogICAgImlkIjogIkc2LWhlbG1maWxlLXNwbGl0LXdv" + - "cmtmbG93IiwKICAgICJxdWVzdGlvbiI6ICJJbnN0YWxsIGFuIE5WQ0YgY29udHJvbCBwbGFuZSBh" + - "bmQgYSBzZXBhcmF0ZSBFS1MgY29tcHV0ZSBwbGFuZSB1c2luZyB0aGUgSGVsbWZpbGUgc3RhY2tz" + - "LiBUaGUgY29tcHV0ZSBjbHVzdGVyIGt1YmVjb25maWcgaXMgY29tcHV0ZS55YW1sLiIsCiAgICAi" + - "ZXhwZWN0ZWRfc2tpbGwiOiAibnZjZi1zZWxmLW1hbmFnZWQtaW5zdGFsbGF0aW9uIiwKICAgICJn" + - "cm91bmRfdHJ1dGgiOiAiVGhlIGFnZW50IGtlcHQgdGhlIEhlbG1maWxlIHZhbHVlcyBmbG93IGlu" + - "ZGVwZW5kZW50IGZyb20gdGhlIENMSSBwcm9maWxlIGZsb3cuIEl0IGF1dGhvcmVkIHNlcGFyYXRl" + - "IGNvbnRyb2wtcGxhbmUgYW5kIGNvbXB1dGUtcGxhbmUgZW52aXJvbm1lbnQgZmlsZXMgcGx1cyBh" + - "IGJhcmUtR2F0ZXdheSBDTEkgY29uZmlnIHdpdGggVVJMIGFuZCBzY2hlbWUtbGVzcyBIb3N0IGZp" + - "ZWxkcywgaW5zdGFsbGVkIHRoZSBjb250cm9sIHBsYW5lLCByYW4gdGhlIGNvbXB1dGUtcGxhbmUg" + - "TWFrZWZpbGUgcmVnaXN0ZXItY2x1c3RlciB0YXJnZXQgd2l0aCBJQ01TX1VSTCBhbmQgdGhlIGNv" + - "bXB1dGUga3ViZWNvbmZpZywgdGhlbiByYW4gdGhlIGNvbXB1dGUtcGxhbmUgaW5zdGFsbCB0YXJn" + - "ZXQgd2l0aCB0aGUgc2FtZSBlbnZpcm9ubWVudCBhbmQga3ViZWNvbmZpZy4gSXQgcmVsaWVkIG9u" + - "IHJlZ2lzdHJhdGlvbiB0byBkaXNjb3ZlciBPSURDIGFuZCBKV0tTIGZyb20gdGhlIGNvbXB1dGUg" + - "Y29udGV4dC4iLAogICAgImV4cGVjdGVkX2JlaGF2aW9yIjogWwogICAgICAiVGhlIGFnZW50IHJl" + - "YWQgdGhlIG52Y2Ytc2VsZi1tYW5hZ2VkLWluc3RhbGxhdGlvbiBTS0lMTC5tZCBiZWZvcmUgdGFr" + - "aW5nIGFjdGlvbiIsCiAgICAgICJUaGUgYWdlbnQgYXV0aG9yZWQgc2VwYXJhdGUgZW52aXJvbm1l" + - "bnRzLzxlbnY+LnlhbWwgZmlsZXMgdW5kZXIgZGVwbG95L3N0YWNrcy9zZWxmLW1hbmFnZWQgYW5k" + - "IGRlcGxveS9zdGFja3MvbnZjZi1jb21wdXRlLXBsYW5lIiwKICAgICAgIlRoZSBhZ2VudCBpbnN0" + - "YWxsZWQgdGhlIGNvbnRyb2wgcGxhbmUgYmVmb3JlIHJlZ2lzdGVyaW5nIG9yIGluc3RhbGxpbmcg" + - "dGhlIGNvbXB1dGUgcGxhbmUiLAogICAgICAiVGhlIGFnZW50IGNvbmZpZ3VyZWQgYmFzZV9odHRw" + - "X3VybCwgaW52b2tlX3VybCwgYmFzZV9ncnBjX3VybCwgYXBpX2tleXNfc2VydmljZV91cmwsIGlj" + - "bXNfdXJsLCBhcGlfaG9zdCwgYXBpX2tleXNfaG9zdCwgaW52b2tlX2hvc3QsIGFuZCBpY21zX2hv" + - "c3QgZm9yIHRoZSBiYXJlIEdhdGV3YXkiLAogICAgICAiVGhlIGFnZW50IHVzZWQgJ21ha2UgLUMg" + - "ZGVwbG95L3N0YWNrcy9udmNmLWNvbXB1dGUtcGxhbmUgcmVnaXN0ZXItY2x1c3Rlcicgd2l0aCBD" + - "TFVTVEVSX05BTUUsIE5DQV9JRCwgQ0xVU1RFUl9SRUdJT04sIElDTVNfVVJMLCBhbmQgS1VCRUNP" + - "TkZJR19GSUxFPWNvbXB1dGUueWFtbCIsCiAgICAgICJUaGUgYWdlbnQgdXNlZCAnbWFrZSAtQyBk" + - "ZXBsb3kvc3RhY2tzL252Y2YtY29tcHV0ZS1wbGFuZSBpbnN0YWxsJyB3aXRoIENMVVNURVJfTkFN" + - "RSwgSEVMTUZJTEVfRU5WLCBhbmQgS1VCRUNPTkZJR19GSUxFPWNvbXB1dGUueWFtbCIsCiAgICAg" + - "ICJUaGUgYWdlbnQgc3RhdGVkIHRoYXQgSUNNU19VUkwgbWFwcyBvbmx5IHRvIC0taWNtcy11cmws" + - "IGNvbmZpZyBpY21zX2hvc3Qgc3VwcGxpZXMgdGhlIEhvc3QgaGVhZGVyLCB0aGVyZSBpcyBubyAt" + - "LWljbXMtaG9zdCBNYWtlIG9yIENMSSBmbGFnLCBhbmQgcmVnaXN0cmF0aW9uIGRpc2NvdmVycyBP" + - "SURDIGFuZCBKV0tTIGZyb20gdGhlIGNvbXB1dGUgY29udGV4dCIsCiAgICAgICJUaGUgYWdlbnQg" + - "ZGlkIG5vdCByZXF1aXJlIGEgY29udHJvbC1wbGFuZSBwcm9maWxlIGZvciB0aGlzIGZsb3cgYW5k" + - "IGRpZCBub3QgbWl4IGluIENMSSBwcm9maWxlIGNvbW1hbmRzIgogICAgXQogIH0sCiAgewogICAg" + - "ImlkIjogIkc3LWJvdGgtZG9ja2VyLWhlbG0tYXV0aCIsCiAgICAicXVlc3Rpb24iOiAiQXV0aGVu" + - "dGljYXRlIHRvIE5HQyBmb3IgTlZDRiBoZWxtZmlsZSBkZXBsb3ltZW50IiwKICAgICJleHBlY3Rl" + - "ZF9za2lsbCI6ICJudmNmLXNlbGYtbWFuYWdlZC1pbnN0YWxsYXRpb24iLAogICAgImdyb3VuZF90" + - "cnV0aCI6ICJUaGUgYWdlbnQgcmFuIGJvdGggZG9ja2VyIGxvZ2luIGFuZCBoZWxtIHJlZ2lzdHJ5" + - "IGxvZ2luIGZvciBudmNyLmlvLiBJdCBleHBsYWluZWQgdGhhdCBib3RoIGFyZSByZXF1aXJlZCBi" + - "ZWNhdXNlIGhlbG1maWxlIHVzZXMgaGVsbSAobm90IGRvY2tlcikgdG8gcHVsbCBPQ0kgY2hhcnRz" + - "LCBzbyBkb2NrZXIgbG9naW4gYWxvbmUgaXMgaW5zdWZmaWNpZW50LiIsCiAgICAiZXhwZWN0ZWRf" + - "YmVoYXZpb3IiOiBbCiAgICAgICJUaGUgYWdlbnQgcmVhZCB0aGUgbnZjZi1zZWxmLW1hbmFnZWQt" + - "aW5zdGFsbGF0aW9uIFNLSUxMLm1kIGJlZm9yZSB0YWtpbmcgYWN0aW9uIiwKICAgICAgIlRoZSBh" + - "Z2VudCByYW4gJ2RvY2tlciBsb2dpbiBudmNyLmlvJyB3aXRoICRvYXV0aHRva2VuIHVzZXJuYW1l" + - "IGFuZCBOR0NfQVBJX0tFWSBwYXNzd29yZCIsCiAgICAgICJUaGUgYWdlbnQgcmFuICdoZWxtIHJl" + - "Z2lzdHJ5IGxvZ2luIG52Y3IuaW8nIHdpdGggJG9hdXRodG9rZW4gdXNlcm5hbWUgYW5kIE5HQ19B" + - "UElfS0VZIHBhc3N3b3JkIiwKICAgICAgIlRoZSBhZ2VudCBleHBsYWluZWQgdGhhdCBib3RoIGFy" + - "ZSByZXF1aXJlZCBiZWNhdXNlIGhlbG1maWxlIHVzZXMgaGVsbSAobm90IGRvY2tlcikgdG8gcHVs" + - "bCBPQ0kgY2hhcnRzIiwKICAgICAgIlRoZSBhZ2VudCBkaWQgbm90IHByb3ZpZGUgb25seSBvbmUg" + - "b2YgdGhlIHR3byBhdXRoZW50aWNhdGlvbiBjb21tYW5kcyIKICAgIF0KICB9LAogIHsKICAgICJp" + - "ZCI6ICJHOS1taXNzaW5nLWJ1bmRsZSIsCiAgICAicXVlc3Rpb24iOiAiUnVuIGhlbG1maWxlIHN5" + - "bmMgZm9yIE5WQ0YgaW4gbXkgY3VycmVudCBkaXJlY3RvcnkiLAogICAgImV4cGVjdGVkX3NraWxs" + - "IjogIm52Y2Ytc2VsZi1tYW5hZ2VkLWluc3RhbGxhdGlvbiIsCiAgICAiZ3JvdW5kX3RydXRoIjog" + - "IlRoZSBhZ2VudCBhdHRlbXB0ZWQgdG8gdmVyaWZ5IHRoZSBidW5kbGUgc3RydWN0dXJlIChoZWxt" + - "ZmlsZS5kLywgZW52aXJvbm1lbnRzLywgc2VjcmV0cy8sIGdsb2JhbC55YW1sLmdvdG1wbCkgYW5k" + - "IHdoZW4gZmlsZXMgd2VyZSBub3QgZm91bmQsIHN0b3BwZWQgYW5kIGluc3RydWN0ZWQgdGhlIHVz" + - "ZXIgdG8gZXh0cmFjdCBvciBsb2NhdGUgdGhlIG52Y2Ytc2VsZi1tYW5hZ2VkLXN0YWNrIGJ1bmRs" + - "ZS4gSXQgZGlkIG5vdCBhdHRlbXB0IHRvIHJ1biBoZWxtZmlsZSBzeW5jIGFnYWluc3QgYSBtaXNz" + - "aW5nIGJ1bmRsZS4iLAogICAgImV4cGVjdGVkX2JlaGF2aW9yIjogWwogICAgICAiVGhlIGFnZW50" + - "IHJlYWQgdGhlIG52Y2Ytc2VsZi1tYW5hZ2VkLWluc3RhbGxhdGlvbiBTS0lMTC5tZCBiZWZvcmUg" + - "dGFraW5nIGFjdGlvbiIsCiAgICAgICJUaGUgYWdlbnQgY2hlY2tlZCBmb3IgZXhwZWN0ZWQgYnVu" + - "ZGxlIHN0cnVjdHVyZSAoaGVsbWZpbGUuZC8sIGVudmlyb25tZW50cy8sIHNlY3JldHMvLCBnbG9i" + - "YWwueWFtbC5nb3RtcGwpIiwKICAgICAgIldoZW4gYnVuZGxlIGZpbGVzIHdlcmUgbm90IGZvdW5k" + - "LCB0aGUgYWdlbnQgc3RvcHBlZCBhbmQgZGlkIG5vdCBhdHRlbXB0IGhlbG1maWxlIHN5bmMiLAog" + - "ICAgICAiVGhlIGFnZW50IGluc3RydWN0ZWQgdGhlIHVzZXIgdG8gZXh0cmFjdCBvciBsb2NhdGUg" + - "dGhlIG52Y2Ytc2VsZi1tYW5hZ2VkLXN0YWNrIGJ1bmRsZSIKICAgIF0KICB9LAogIHsKICAgICJp" + - "ZCI6ICJTMS1jbGVhbi1pbnN0YWxsYXRpb24iLAogICAgInF1ZXN0aW9uIjogIlBlcmZvcm0gYSBj" + - "bGVhbiBpbnN0YWxsYXRpb24gb2YgdGhlIE5WQ0Ygc2VsZi1tYW5hZ2VkIHN0YWNrIG9uIG15IEFX" + - "UyBFS1MgY2x1c3Rlci4gTXkgZW52aXJvbm1lbnQgbmFtZSBpcyAnc3RhZ2luZycuIiwKICAgICJl" + - "eHBlY3RlZF9za2lsbCI6ICJudmNmLXNlbGYtbWFuYWdlZC1pbnN0YWxsYXRpb24iLAogICAgImdy" + - "b3VuZF90cnV0aCI6ICJUaGUgYWdlbnQgY29tcGxldGVkIHRoZSBjb250cm9sLXBsYW5lIGluc3Rh" + - "bGxhdGlvbiBmaXJzdDogdmFsaWRhdGVkIHRvb2xzIGFuZCBidW5kbGUgc3RydWN0dXJlLCBjcmVh" + - "dGVkIGNvbnRyb2wtcGxhbmUgbmFtZXNwYWNlcyBpbmNsdWRpbmcgY2VydC1tYW5hZ2VyLCBhdXRo" + - "ZW50aWNhdGVkIHRoZSByZWdpc3RyaWVzLCBwcmV2aWV3ZWQsIGRlcGxveWVkLCBhbmQgbW9uaXRv" + - "cmVkIHRoZSBmb3VyIGNvbnRyb2wtcGxhbmUgcGhhc2VzLiBJdCB0aGVuIHNlbGVjdGVkIG9uZSBk" + - "b2N1bWVudGVkIGhhbmRvZmYgYW5kIHJlZ2lzdGVyZWQgYW5kIGluc3RhbGxlZCB0aGUgY29tcHV0" + - "ZSBwbGFuZSBhcyBhIHNlcGFyYXRlIHN0YWNrIHdpdGhvdXQgbWl4aW5nIHByb2ZpbGUgYW5kIEhl" + - "bG1maWxlIHZhbHVlcyBmbG93cy4iLAogICAgImV4cGVjdGVkX2JlaGF2aW9yIjogWwogICAgICAi" + - "VGhlIGFnZW50IHJlYWQgdGhlIG52Y2Ytc2VsZi1tYW5hZ2VkLWluc3RhbGxhdGlvbiBTS0lMTC5t" + - "ZCBiZWZvcmUgdGFraW5nIGFjdGlvbiIsCiAgICAgICJUaGUgYWdlbnQgdmFsaWRhdGVkIHRvb2wg" + - "dmVyc2lvbnMgKGhlbG1maWxlLCBoZWxtLCBoZWxtLWRpZmYsIGt1YmVjdGwpIiwKICAgICAgIlRo" + - "ZSBhZ2VudCB2ZXJpZmllZCB0aGUgYnVuZGxlIHN0cnVjdHVyZSBleGlzdHMiLAogICAgICAiVGhl" + - "IGFnZW50IGNyZWF0ZWQgY29udHJvbC1wbGFuZSBuYW1lc3BhY2VzIChjYXNzYW5kcmEtc3lzdGVt" + - "LCBuYXRzLXN5c3RlbSwgbnZjZiwgYXBpLWtleXMsIGVzcywgc2lzLCB2YXVsdC1zeXN0ZW0sIGNl" + - "cnQtbWFuYWdlcikgd2l0aG91dCBhZGRpbmcgY29tcHV0ZS1vbmx5IG5hbWVzcGFjZXMiLAogICAg" + - "ICAiVGhlIGFnZW50IHJhbiAnSEVMTUZJTEVfRU5WPXN0YWdpbmcgaGVsbWZpbGUgdGVtcGxhdGUn" + - "IHRvIHByZXZpZXcgYmVmb3JlIGRlcGxveWluZyIsCiAgICAgICJUaGUgYWdlbnQgcmFuICdIRUxN" + - "RklMRV9FTlY9c3RhZ2luZyBoZWxtZmlsZSBzeW5jJyB0byBkZXBsb3kiLAogICAgICAiVGhlIGFn" + - "ZW50IGV4cGxhaW5lZCB0aGUgNCBjb250cm9sLXBsYW5lIHBoYXNlcyAoZGVwZW5kZW5jaWVzLCBz" + - "ZXJ2aWNlcywgaW5ncmVzcywgb2JzZXJ2YWJpbGl0eSkgYW5kIGFwcHJveGltYXRlIHdhaXQgdGlt" + - "ZXMiLAogICAgICAiQWZ0ZXIgdGhlIGNvbnRyb2wgcGxhbmUgd2FzIGhlYWx0aHksIHRoZSBhZ2Vu" + - "dCByZWdpc3RlcmVkIGFuZCBpbnN0YWxsZWQgdGhlIHNlcGFyYXRlIGNvbXB1dGUtcGxhbmUgc3Rh" + - "Y2sgdXNpbmcgZXhhY3RseSBvbmUgZG9jdW1lbnRlZCBoYW5kb2ZmIiwKICAgICAgIlRoZSBhZ2Vu" + - "dCBkaWQgbm90IG1peCBhIENMSS1nZW5lcmF0ZWQgY29udHJvbC1wbGFuZSBwcm9maWxlIHdpdGgg" + - "dGhlIEhlbG1maWxlIHZhbHVlcyBmbG93IgogICAgXQogIH0sCiAgewogICAgImlkIjogIlMzLWNs" + - "aS1wcm9maWxlLXdvcmtmbG93IiwKICAgICJxdWVzdGlvbiI6ICJVc2UgbnZjZi1jbGkgdG8gaW5z" + - "dGFsbCBteSBjb250cm9sIHBsYW5lIGFuZCB0aGVuIHJlZ2lzdGVyIGFuZCBpbnN0YWxsIGEgc2Vw" + - "YXJhdGUgY29tcHV0ZSBjbHVzdGVyLiBTaG93IGV2ZXJ5IHJlcXVpcmVkIGdsb2JhbCBmbGFnLiIs" + - "CiAgICAiZXhwZWN0ZWRfc2tpbGwiOiAibnZjZi1zZWxmLW1hbmFnZWQtaW5zdGFsbGF0aW9uIiwK" + - "ICAgICJncm91bmRfdHJ1dGgiOiAiVGhlIGFnZW50IGZpcnN0IHJhbiB0aGUgQ0xJIGNvbnRyb2wt" + - "cGxhbmUgaW5zdGFsbCBhbmQgcmVxdWlyZWQgaXRzIGdlbmVyYXRlZCBjb250cm9sLXBsYW5lLXBy" + - "b2ZpbGUueWFtbC4gSXQgdGhlbiBzaG93ZWQgY29tcGxldGUgcmVnaXN0ZXIgYW5kIGluc3RhbGwg" + - "Y29tbWFuZHMsIGVhY2ggaW5jbHVkaW5nIC0tY29uZmlnLCAtLWNvbnRyb2wtcGxhbmUtc3RhY2ss" + - "IC0tY29tcHV0ZS1wbGFuZS1zdGFjaywgLS1lbnYsIGFuZCAtLXBsYWluIGJlZm9yZSB0aGUgY29t" + - "cHV0ZS1wbGFuZSBzdWJjb21tYW5kLiBSZWdpc3RyYXRpb24gY29uc3VtZWQgdGhlIHByb2ZpbGUg" + - "YW5kIHByb2R1Y2VkIHRoZSB2YWx1ZXMgZmlsZSBjb25zdW1lZCBieSBpbnN0YWxsLiBJdCBkaWQg" + - "bm90IHN3aXRjaCB0byB0aGUgSGVsbWZpbGUgdmFsdWVzIGhhbmRvZmYuIiwKICAgICJleHBlY3Rl" + - "ZF9iZWhhdmlvciI6IFsKICAgICAgIlRoZSBhZ2VudCByZWFkIHRoZSBudmNmLXNlbGYtbWFuYWdl" + - "ZC1pbnN0YWxsYXRpb24gU0tJTEwubWQgYmVmb3JlIHRha2luZyBhY3Rpb24iLAogICAgICAiVGhl" + - "IGFnZW50IHJhbiBudmNmLWNsaSBzZWxmLWhvc3RlZCBpbnN0YWxsIC0tY29udHJvbC1wbGFuZSBh" + - "bmQgdmVyaWZpZWQgZGVwbG95L3N0YWNrcy9zZWxmLW1hbmFnZWQvb3V0L2NvbnRyb2wtcGxhbmUt" + - "cHJvZmlsZS55YW1sIGV4aXN0cyIsCiAgICAgICJUaGUgcmVnaXN0ZXIgY29tbWFuZCBpbmNsdWRl" + - "ZCAtLWNvbmZpZywgLS1jb250cm9sLXBsYW5lLXN0YWNrLCAtLWNvbXB1dGUtcGxhbmUtc3RhY2ss" + - "IC0tZW52LCBhbmQgLS1wbGFpbiIsCiAgICAgICJUaGUgcmVnaXN0ZXIgY29tbWFuZCBpbmNsdWRl" + - "ZCAtLWNvbnRyb2wtcGxhbmUtcHJvZmlsZSwgLS1jbHVzdGVyLW5hbWUsIC0ta3ViZS1jb250ZXh0" + - "LCAtLXJlZ2lvbiwgYW5kIC0tb3V0cHV0IiwKICAgICAgIlRoZSBpbnN0YWxsIGNvbW1hbmQgcmVw" + - "ZWF0ZWQgLS1jb25maWcsIC0tY29udHJvbC1wbGFuZS1zdGFjaywgLS1jb21wdXRlLXBsYW5lLXN0" + - "YWNrLCAtLWVudiwgYW5kIC0tcGxhaW4iLAogICAgICAiVGhlIGluc3RhbGwgY29tbWFuZCBpbmNs" + - "dWRlZCAtLXZhbHVlcywgLS1rdWJlLWNvbnRleHQsIGFuZCAtLWNsdXN0ZXItbmFtZSIsCiAgICAg" + - "ICJUaGUgYWdlbnQga2VwdCB0aGUgZ2VuZXJhdGVkIHByb2ZpbGUgYXMgdGhlIGVuZHBvaW50IHNv" + - "dXJjZSBhbmQgZGlkIG5vdCBtaXggaW4gSGVsbWZpbGUgdmFsdWVzIHJlZ2lzdHJhdGlvbiIKICAg" + - "IF0KICB9LAogIHsKICAgICJpZCI6ICJTNC1vdmVycmlkZS1jYXNzYW5kcmEtcmVzb3VyY2VzIiwK" + - "ICAgICJxdWVzdGlvbiI6ICJDYXNzYW5kcmEgcG9kcyBrZWVwIGdldHRpbmcgT09NS2lsbGVkLiBJ" + - "bmNyZWFzZSBtZW1vcnkgbGltaXRzIHRvIDE2R2kuIiwKICAgICJleHBlY3RlZF9za2lsbCI6ICJu" + - "dmNmLXNlbGYtbWFuYWdlZC1pbnN0YWxsYXRpb24iLAogICAgImdyb3VuZF90cnV0aCI6ICJUaGUg" + - "YWdlbnQgY2FwdHVyZWQgdGhlIGJhc2VsaW5lIHdpdGggaGVsbWZpbGUgdGVtcGxhdGUsIHRoZW4g" + - "bW9kaWZpZWQgdGhlIGNhc3NhbmRyYSByZWxlYXNlIHdpdGggaW5saW5lIHZhbHVlcyByZS1pbmNs" + - "dWRpbmcgZ2xvYmFsLnlhbWwuZ290bXBsIGFuZCBzZWNyZXRzIGluIHRoZSB2YWx1ZXMgYmxvY2su" + - "IEl0IHdhcm5lZCBhYm91dCB0aGUgWUFNTCBtZXJnZSBnb3RjaGEgYW5kIHByZXZpZXdlZCB0aGUg" + - "ZGlmZiBiZWZvcmUgYXBwbHlpbmcuIiwKICAgICJleHBlY3RlZF9iZWhhdmlvciI6IFsKICAgICAg" + - "IlRoZSBhZ2VudCByZWFkIHRoZSBudmNmLXNlbGYtbWFuYWdlZC1pbnN0YWxsYXRpb24gU0tJTEwu" + - "bWQgYmVmb3JlIHRha2luZyBhY3Rpb24iLAogICAgICAiVGhlIGFnZW50IGNhcHR1cmVkIGJhc2Vs" + - "aW5lIHdpdGggJ2hlbG1maWxlIC0tc2VsZWN0b3IgbmFtZT1jYXNzYW5kcmEgdGVtcGxhdGUnIiwK" + - "ICAgICAgIlRoZSBhZ2VudCBtb2RpZmllZCB0aGUgcmVsZWFzZSB2YWx1ZXMgYmxvY2sgdG8gaW5j" + - "bHVkZSByZXNvdXJjZSBsaW1pdHMgd2l0aCBtZW1vcnk6IDE2R2kiLAogICAgICAiVGhlIGFnZW50" + - "IHJlLWluY2x1ZGVkIGdsb2JhbC55YW1sLmdvdG1wbCBhbmQgc2VjcmV0cyBmaWxlIGluIHRoZSB2" + - "YWx1ZXM6IGJsb2NrIChub3QganVzdCB0aGUgb3ZlcnJpZGUgYWxvbmUpIiwKICAgICAgIlRoZSBh" + - "Z2VudCB3YXJuZWQgYWJvdXQgdGhlIFlBTUwgbWVyZ2UgZ290Y2hhOiBzcGVjaWZ5aW5nIHZhbHVl" + - "czogcmVwbGFjZXMgdGhlIHRlbXBsYXRlJ3MgdmFsdWVzIGxpc3QgZW50aXJlbHkiLAogICAgICAi" + - "VGhlIGFnZW50IHByZXZpZXdlZCB0aGUgY2hhbmdlIHdpdGggaGVsbWZpbGUgdGVtcGxhdGUgYW5k" + - "IGRpZmYgYmVmb3JlIGFwcGx5aW5nIHdpdGggc3luYyIKICAgIF0KICB9LAogIHsKICAgICJpZCI6" + - "ICJTNi1zZWxlY3RpdmUtc3luYy1kZXBlbmRlbmNpZXMiLAogICAgInF1ZXN0aW9uIjogIkRlcGxv" + - "eSBvbmx5IHRoZSBOVkNGIGRlcGVuZGVuY2llcyAtLSBOQVRTLCBDYXNzYW5kcmEsIGFuZCBPcGVu" + - "QmFvIC0tIGZvciB0ZXN0aW5nIiwKICAgICJleHBlY3RlZF9za2lsbCI6ICJudmNmLXNlbGYtbWFu" + - "YWdlZC1pbnN0YWxsYXRpb24iLAogICAgImdyb3VuZF90cnV0aCI6ICJUaGUgYWdlbnQgdXNlZCB0" + - "aGUgaGVsbWZpbGUgc2VsZWN0b3IgdG8gZGVwbG95IG9ubHkgdGhlIGRlcGVuZGVuY2llcyByZWxl" + - "YXNlIGdyb3VwLCB0aGVuIHZlcmlmaWVkIHBvZHMgaW4gdGhlIGRlcGVuZGVuY3kgbmFtZXNwYWNl" + - "cy4iLAogICAgImV4cGVjdGVkX2JlaGF2aW9yIjogWwogICAgICAiVGhlIGFnZW50IHJlYWQgdGhl" + - "IG52Y2Ytc2VsZi1tYW5hZ2VkLWluc3RhbGxhdGlvbiBTS0lMTC5tZCBiZWZvcmUgdGFraW5nIGFj" + - "dGlvbiIsCiAgICAgICJUaGUgYWdlbnQgdXNlZCAnaGVsbWZpbGUgLS1zZWxlY3RvciByZWxlYXNl" + - "LWdyb3VwPWRlcGVuZGVuY2llcyBzeW5jJyB0byBkZXBsb3kgb25seSBkZXBlbmRlbmNpZXMiLAog" + - "ICAgICAiVGhlIGFnZW50IHZlcmlmaWVkIHBvZHMgaW4gZGVwZW5kZW5jeSBuYW1lc3BhY2VzIChu" + - "YXRzLXN5c3RlbSwgY2Fzc2FuZHJhLXN5c3RlbSwgdmF1bHQtc3lzdGVtKSIsCiAgICAgICJUaGUg" + - "YWdlbnQgcHJvdmlkZWQgdGhlIHNlbGVjdG9yIHJlZmVyZW5jZSBmb3IgdGFyZ2V0aW5nIG90aGVy" + - "IHJlbGVhc2UgZ3JvdXBzIgogICAgXQogIH0sCiAgewogICAgImlkIjogIlM3LWRlYnVnLWltYWdl" + - "cHVsbGJhY2tvZmYiLAogICAgInF1ZXN0aW9uIjogIkNhc3NhbmRyYSBwb2RzIGFyZSBpbiBJbWFn" + - "ZVB1bGxCYWNrT2ZmIHdpdGggNDAxIFVuYXV0aG9yaXplZCIsCiAgICAiZXhwZWN0ZWRfc2tpbGwi" + - "OiAibnZjZi1zZWxmLW1hbmFnZWQtaW5zdGFsbGF0aW9uIiwKICAgICJncm91bmRfdHJ1dGgiOiAi" + - "VGhlIGFnZW50IHJlYWQgdGhlIGRlYnVnZ2luZyByZWZlcmVuY2UgYW5kIHJhbiBkaWFnbm9zdGlj" + - "IGNvbW1hbmRzIHRvIGlkZW50aWZ5IHRoZSByb290IGNhdXNlOiBkZXNjcmliZWQgdGhlIHBvZCwg" + - "Y2hlY2tlZCBmb3IgcHVsbCBzZWNyZXRzLCBjaGVja2VkIGltYWdlUHVsbFNlY3JldHMgb24gdGhl" + - "IHBvZCBzcGVjIGFuZCBzZXJ2aWNlIGFjY291bnQuIEl0IGlkZW50aWZpZWQgdGhlIGlzc3VlICht" + - "aXNzaW5nIHNlY3JldCwgd3JvbmcgY3JlZGVudGlhbHMsIG9yIG1pc3NpbmcgaW1hZ2VQdWxsU2Vj" + - "cmV0cykgYW5kIHByb3ZpZGVkIHRoZSBjb3JyZWN0IGZpeC4iLAogICAgImV4cGVjdGVkX2JlaGF2" + - "aW9yIjogWwogICAgICAiVGhlIGFnZW50IHJlYWQgdGhlIG52Y2Ytc2VsZi1tYW5hZ2VkLWluc3Rh" + - "bGxhdGlvbiBTS0lMTC5tZCBhbmQgcmVmZXJlbmNlcy9kZWJ1Z2dpbmcubWQiLAogICAgICAiVGhl" + - "IGFnZW50IHJhbiAna3ViZWN0bCBkZXNjcmliZSBwb2QnIHRvIHNlZSB0aGUgSW1hZ2VQdWxsQmFj" + - "a09mZiBldmVudHMiLAogICAgICAiVGhlIGFnZW50IGNoZWNrZWQgZm9yIHB1bGwgc2VjcmV0cyBp" + - "biB0aGUgY2Fzc2FuZHJhLXN5c3RlbSBuYW1lc3BhY2UiLAogICAgICAiVGhlIGFnZW50IGNoZWNr" + - "ZWQgaW1hZ2VQdWxsU2VjcmV0cyBvbiB0aGUgcG9kIHNwZWMgYW5kL29yIHNlcnZpY2UgYWNjb3Vu" + - "dCIsCiAgICAgICJUaGUgYWdlbnQgaWRlbnRpZmllZCB0aGUgcm9vdCBjYXVzZSBhbmQgcHJvdmlk" + - "ZWQgYSBzcGVjaWZpYyBmaXgiCiAgICBdCiAgfSwKICB7CiAgICAiaWQiOiAiUzktcmVtb3RlLWVr" + - "cy1yb3V0aW5nLWFuZC1zZWNyZXRzIiwKICAgICJxdWVzdGlvbiI6ICJDb25maWd1cmUgYSByZW1v" + - "dGUgRUtTIGNvbXB1dGUgY2x1c3RlciB0byByZWFjaCBteSBOVkNGIGNvbnRyb2wgcGxhbmUgdGhy" + - "b3VnaCBpdHMgRW52b3kgR2F0ZXdheSwgaW5jbHVkaW5nIE5BVFMgYW5kIHByaXZhdGUtcmVnaXN0" + - "cnkgcHVsbCBzZWNyZXRzLiIsCiAgICAiZXhwZWN0ZWRfc2tpbGwiOiAibnZjZi1zZWxmLW1hbmFn" + - "ZWQtaW5zdGFsbGF0aW9uIiwKICAgICJncm91bmRfdHJ1dGgiOiAiVGhlIGFnZW50IGNvbmZpZ3Vy" + - "ZWQgdGhlIGNvbnRyb2wgcGxhbmUgdG8gdXNlIHRoZSBFbnZveSBHYXRld2F5IGNvbnRyb2xsZXIg" + - "aW4gZW52b3ktZ2F0ZXdheS1zeXN0ZW0gYW5kIEdhdGV3YXkvbnZjZi1nYXRld2F5IGluIGVudm95" + - "LWdhdGV3YXksIHNldCBhbGwgc2l4IHJlbW90ZSB3b3JrZXIgZW5kcG9pbnRzIGFuZCB0aGUgZ3Jw" + - "Yy1wcm94eSBsb2NhbCBvdmVycmlkZSwgZW5hYmxlZCBOVkNGIGFuZCBOVkNUIGdSUEMgcm91dGVz" + - "IHBsdXMgTkFUUywgYW5kIGVuYWJsZWQgT3BlbkJhbyBpc3N1ZXIgZGlzY292ZXJ5LiBJdCBjb25m" + - "aWd1cmVkIHRoZSBiYXJlLUdhdGV3YXkgQ0xJIFVSTCBhbmQgSG9zdCBmaWVsZHMgaW5jbHVkaW5n" + - "IGljbXNfaG9zdCwgcGx1cyB0aGUgY29tcHV0ZS1wbGFuZSBJQ01TLCBSZVZhbCwgYW5kIE5BVFMg" + - "ZXh0ZXJuYWwgVVJMcyBhbmQgaG9zdCBvdmVycmlkZXMuIEl0IGNyZWF0ZWQgdGhlIHB1bGwgc2Vj" + - "cmV0IGluIGFsbCBjb250cm9sLXBsYW5lIG5hbWVzcGFjZXMgaW5jbHVkaW5nIGNlcnQtbWFuYWdl" + - "ciwgYnV0IG9ubHkgaW4gbnZjYS1vcGVyYXRvciBvbiB0aGUgY29tcHV0ZSBjbHVzdGVyOyB0aGUg" + - "Y2hhcnQgYW5kIG9wZXJhdG9yIG1pcnJvciBpdCB0byBudmNhLXN5c3RlbS4iLAogICAgImV4cGVj" + - "dGVkX2JlaGF2aW9yIjogWwogICAgICAiVGhlIGFnZW50IHJlYWQgdGhlIG52Y2Ytc2VsZi1tYW5h" + - "Z2VkLWluc3RhbGxhdGlvbiBTS0lMTC5tZCBiZWZvcmUgdGFraW5nIGFjdGlvbiIsCiAgICAgICJU" + - "aGUgYWdlbnQgc2V0IGluZ3Jlc3MuZ2F0ZXdheUFwaS5jb250cm9sbGVyTmFtZXNwYWNlIHRvIGVu" + - "dm95LWdhdGV3YXktc3lzdGVtIiwKICAgICAgIlRoZSBhZ2VudCBzZXQgc2hhcmVkLCBncnBjLCBh" + - "bmQgbmF0cyBHYXRld2F5IHJlZmVyZW5jZXMgdG8gbmFtZSBudmNmLWdhdGV3YXkgYW5kIG5hbWVz" + - "cGFjZSBlbnZveS1nYXRld2F5IiwKICAgICAgIlRoZSBhZ2VudCBzZXQgZ2xvYmFsLndvcmtlckVu" + - "ZHBvaW50cy5udmNmU2VydmljZVVSTCwgbnZjZkdycGNTZXJ2aWNlVVJMLCBudmNmTmF0c1NlcnZp" + - "Y2VVUkwsIG52Y3RTZXJ2aWNlVVJMLCBudmN0R3JwY1NlcnZpY2VVUkwsIGFuZCBpbnZvY2F0aW9u" + - "U2VydmljZVVSTCIsCiAgICAgICJUaGUgYWdlbnQgc2V0IGdycGNwcm94eS5udmNmR3JwY1NlcnZp" + - "Y2VVUkwgdG8gdGhlIGNvbnRyb2wtcGxhbmUtbG9jYWwgQVBJIGdSUEMgc2VydmljZSIsCiAgICAg" + - "ICJUaGUgYWdlbnQgZW5hYmxlZCBib3RoIGluZ3Jlc3MuZ2F0ZXdheUFwaS5yb3V0ZXMubnZjZkFw" + - "aS5ncnBjIGFuZCBudmN0QXBpLmdycGMgd2l0aCB3b3JrZXItYXBpIGFuZCB3b3JrZXItdGFza3Mg" + - "aG9zdG5hbWVzIiwKICAgICAgIlRoZSBhZ2VudCBleHBsaWNpdGx5IHNldCBpbmdyZXNzLmdhdGV3" + - "YXlBcGkucm91dGVzLm5hdHMuZW5hYmxlZCB0byB0cnVlIiwKICAgICAgIlRoZSBhZ2VudCBzZXQg" + - "b3BlbmJhby5taWdyYXRpb25zLmlzc3VlckRpc2NvdmVyeS5lbmFibGVkIHRvIHRydWUiLAogICAg" + - "ICAiVGhlIGFnZW50IGNvbmZpZ3VyZWQgdGhlIGJhcmUtR2F0ZXdheSBDTEkgVVJMIGFuZCBIb3N0" + - "IGZpZWxkcywgaW5jbHVkaW5nIHNjaGVtZS1sZXNzIGljbXNfaG9zdCIsCiAgICAgICJUaGUgYWdl" + - "bnQgY29uZmlndXJlZCBjb21wdXRlLXBsYW5lIGljbXNTZXJ2aWNlVVJMLCBpY21zU2VydmljZUhv" + - "c3RIZWFkZXJPdmVycmlkZSwgcmV2YWxTZXJ2aWNlVVJMLCByZXZhbFNlcnZpY2VIb3N0SGVhZGVy" + - "T3ZlcnJpZGUsIG5hdHNVUkwsIGFuZCBuYXRzSG9zdE92ZXJyaWRlIiwKICAgICAgIlRoZSBjb250" + - "cm9sLXBsYW5lIHB1bGwtc2VjcmV0IG5hbWVzcGFjZSBsaXN0IGluY2x1ZGVkIGNlcnQtbWFuYWdl" + - "ciIsCiAgICAgICJUaGUgY29tcHV0ZS1wbGFuZSBzZWNyZXQgd2FzIGNyZWF0ZWQgb25seSBpbiBu" + - "dmNhLW9wZXJhdG9yIGFuZCBtaXJyb3JlZCBieSB0aGUgY2hhcnQgYW5kIG9wZXJhdG9yIHRvIG52" + - "Y2Etc3lzdGVtIgogICAgXQogIH0sCiAgewogICAgImlkIjogIkcxMS1zcGxpdC10ZWFyZG93biIs" + - "CiAgICAicXVlc3Rpb24iOiAiVGVhciBkb3duIG15IHNwbGl0IGNvbnRyb2wtcGxhbmUgYW5kIGNv" + - "bXB1dGUtcGxhbmUgZGVwbG95bWVudCBzYWZlbHkuIFNob3cgYm90aCB0aGUgSGVsbWZpbGUgdmFs" + - "dWVzIGFuZCBDTEkgcHJvZmlsZSB2YXJpYW50cy4iLAogICAgImV4cGVjdGVkX3NraWxsIjogIm52" + - "Y2Ytc2VsZi1tYW5hZ2VkLWluc3RhbGxhdGlvbiIsCiAgICAiZ3JvdW5kX3RydXRoIjogIlRoZSBI" + - "ZWxtZmlsZSBmbG93IGRlc3Ryb3llZCBhbmQgY29uZmlybWVkIGRlcmVnaXN0cmF0aW9uIG9mIGV2" + - "ZXJ5IGNvbXB1dGUgY2x1c3RlciBiZWZvcmUgZGVzdHJveWluZyB0aGUgY29udHJvbCBwbGFuZSBh" + - "bmQgcGFzc2VkIGJvdGggY29udHJvbC1wbGFuZSBrdWJlY29uZmlnIGZvcm1zLiBCZWZvcmUgZWl0" + - "aGVyIGhhbmRvZmYgY291bGQgZGVzdHJveSB0aGUgY29udHJvbCBwbGFuZSwgYm90aCB0ZWFyZG93" + - "biBmbG93cyB3YXJuZWQgdGhhdCBuYW1lc3BhY2UgcHJlc2VydmF0aW9uIGRvZXMgbm90IHByZXNl" + - "cnZlIHRoZSBIZWxtIHJlbGVhc2UsIHJlcXVpcmVkIGVmZmVjdGl2ZSBjZXJ0TWFuYWdlci5lbmFi" + - "bGVkOiBmYWxzZSBmb3IgYW4gZXh0ZXJuYWwgaW5zdGFsbGF0aW9uIGFuZCBhYm9ydGVkIGlmIHRy" + - "dWUsIGFuZCB2ZXJpZmllZCBtYXRjaGluZyByZWxlYXNlIG93bmVyc2hpcCBmb3IgYW4gaW50ZW5k" + - "ZWQgc3RhY2stbWFuYWdlZCByZWxlYXNlLCBhYm9ydGluZyBvbiBtaXNzaW5nIG9yIG1pc21hdGNo" + - "ZWQgZXZpZGVuY2UuIFRoZXkgcHJlc2VydmVkIHRoZSBuYW1lc3BhY2UgYnkgZGVmYXVsdCBhbmQg" + - "ZGlkIG5vdCBkZWxldGUgaXQgd2l0aG91dCBuYW1lc3BhY2UgcHJvdmVuYW5jZSBhbmQgZXhwbGlj" + - "aXQgY29uZmlybWF0aW9uLiBUaGUgQ0xJIGZsb3cgcmV0YWluZWQgdGhlIGdlbmVyYXRlZCByZWdp" + - "c3RyYXRpb24gdmFsdWVzLCB1c2VkIHRoZSBmdWxsLXByZWZpeCBzdGF0dXMgY29tbWFuZCB0byBp" + - "bnNwZWN0IGxpdmUgcmVnaXN0cmF0aW9ucywgc3RhdGVkIHRoYXQgbmFtZWQtY2x1c3RlciBwbGFu" + - "LW9ubHkgZG9lcyBub3QgcXVlcnkgSUNNUyBhbmQgY2Fubm90IHByZWRpY3QgY29uZGl0aW9uYWwg" + - "Y29udHJvbC1wbGFuZSByZW1vdmFsLCBhbmQgZ290IGV4cGxpY2l0IGNvbmZpcm1hdGlvbiB3aGVu" + - "IHRoZSB0YXJnZXQgd2FzIHRoZSBsYXN0IHJlZ2lzdGVyZWQgY2x1c3Rlci4gSXQgdGhlbiBwcmV2" + - "aWV3ZWQgYW5kIHJhbiBkb3duIHdpdGggdGhlIGZ1bGwgcGVyc2lzdGVudCBwcmVmaXgsIHJlbW92" + - "aW5nIHRoZSBjb250cm9sIHBsYW5lIG9ubHkgYWZ0ZXIgdGhlIGxhc3QgcmVnaXN0cmF0aW9uIHdh" + - "cyBnb25lLiIsCiAgICAiZXhwZWN0ZWRfYmVoYXZpb3IiOiBbCiAgICAgICJUaGUgYWdlbnQgcmVh" + - "ZCB0aGUgbnZjZi1zZWxmLW1hbmFnZWQtaW5zdGFsbGF0aW9uIFNLSUxMLm1kIGJlZm9yZSB0YWtp" + - "bmcgYWN0aW9uIiwKICAgICAgIkZvciBldmVyeSBjb21wdXRlIGNsdXN0ZXIsIHRoZSBIZWxtZmls" + - "ZSBmbG93IHJhbiB0aGUgY29tcHV0ZS1wbGFuZSBNYWtlZmlsZSBkZXN0cm95IHRhcmdldCB3aXRo" + - "IGl0cyBjb21wdXRlIGt1YmVjb25maWciLAogICAgICAiQWZ0ZXIgY29uZmlybWF0aW9uLCB0aGUg" + - "SGVsbWZpbGUgZmxvdyByYW4gY2x1c3RlciBkZWxldGUgd2l0aCBjbHVzdGVySUQgYW5kIG5jYUlE" + - "IGJlZm9yZSBjb250cm9sLXBsYW5lIGRlc3RydWN0aW9uIiwKICAgICAgIkJlZm9yZSBlaXRoZXIg" + - "aGFuZG9mZiBjb3VsZCBkZXN0cm95IHRoZSBjb250cm9sIHBsYW5lLCBib3RoIHRlYXJkb3duIGZs" + - "b3dzIHdhcm5lZCB0aGF0IG5hbWVzcGFjZSBwcmVzZXJ2YXRpb24gZG9lcyBub3QgcHJlc2VydmUg" + - "dGhlIEhlbG0gcmVsZWFzZSwgcmVxdWlyZWQgZWZmZWN0aXZlIGNlcnRNYW5hZ2VyLmVuYWJsZWQ6" + - "IGZhbHNlIGZvciBhbiBleHRlcm5hbCBpbnN0YWxsYXRpb24gYW5kIGFib3J0ZWQgaWYgdHJ1ZSwg" + - "YW5kIHZlcmlmaWVkIGludGVuZGVkIHN0YWNrIG93bmVyc2hpcCB3aGVuIGVuYWJsZWQsIGFib3J0" + - "aW5nIG9uIG1pc3Npbmcgb3IgbWlzbWF0Y2hlZCBldmlkZW5jZSIsCiAgICAgICJCb3RoIHRlYXJk" + - "b3duIGZsb3dzIHByZXNlcnZlZCB0aGUgY2VydC1tYW5hZ2VyIG5hbWVzcGFjZSBieSBkZWZhdWx0" + - "IGFuZCBkaWQgbm90IGRlbGV0ZSBpdCB3aXRob3V0IG5hbWVzcGFjZSBwcm92ZW5hbmNlIGFuZCBl" + - "eHBsaWNpdCBjb25maXJtYXRpb24iLAogICAgICAiVGhlIEhlbG1maWxlIGZsb3cgcmFuIGNvbnRy" + - "b2wtcGxhbmUgTWFrZWZpbGUgZGVzdHJveSB3aXRoIGJvdGggS1VCRUNPTkZJRyBhbmQgS1VCRUNP" + - "TkZJR19GSUxFIiwKICAgICAgIlRoZSBDTEkgZmxvdyByZXRhaW5lZCBvdXQvPGNsdXN0ZXItbmFt" + - "ZT4tcmVnaXN0ZXItdmFsdWVzLnlhbWwgdW50aWwgdGVhcmRvd24gY29tcGxldGVkIiwKICAgICAg" + - "IkJlZm9yZSByZWFsIGRvd24sIHRoZSBDTEkgZmxvdyB1c2VkIHRoZSBmdWxsLXByZWZpeCBzdGF0" + - "dXMgY29tbWFuZCB0byBpbnNwZWN0IGxpdmUgcmVnaXN0cmF0aW9ucywgc3RhdGVkIHRoYXQgbmFt" + - "ZWQtY2x1c3RlciBwbGFuLW9ubHkgZG9lcyBub3QgcXVlcnkgSUNNUyBhbmQgY2Fubm90IHByZWRp" + - "Y3QgY29uZGl0aW9uYWwgY29udHJvbC1wbGFuZSByZW1vdmFsLCB3YXJuZWQgd2hlbiB0aGUgdGFy" + - "Z2V0IHdhcyB0aGUgbGFzdCByZWdpc3RlcmVkIGNsdXN0ZXIsIGFuZCBnb3QgZXhwbGljaXQgY29u" + - "ZmlybWF0aW9uIiwKICAgICAgIlRoZSBDTEkgZmxvdyB1c2VkIC0tY29uZmlnLCBib3RoIHN0YWNr" + - "IHBhdGhzLCAtLWVudiwgLS1wbGFpbiwgYm90aCBjb250ZXh0cywgYW5kIC0taWNtcy11cmwgZm9y" + - "IGRvd24gLS1wbGFuLW9ubHkgYW5kIHRoZW4gZG93biIsCiAgICAgICJUaGUgYWdlbnQgc3RhdGVk" + - "IHRoYXQgZG93biB1bnJlZ2lzdGVycyBlYWNoIGNvbXB1dGUgY2x1c3RlciBhbmQgcmVtb3ZlcyB0" + - "aGUgY29udHJvbCBwbGFuZSBvbmx5IGFmdGVyIG5vIHJlZ2lzdHJhdGlvbnMgcmVtYWluIgogICAg" + - "XQogIH0sCiAgewogICAgImlkIjogIlMxMy12YWx1ZXMtcHJlY2VkZW5jZSIsCiAgICAicXVlc3Rp" + - "b24iOiAiSSBhZGRlZCBhIHZhbHVlIHRvIG15IGVudmlyb25tZW50IFlBTUwgYnV0IGl0J3MgYmVp" + - "bmcgc2lsZW50bHkgaWdub3JlZC4gSG93IGRvIGhlbG1maWxlIHZhbHVlcyB3b3JrIGluIE5WQ0Y/" + - "IiwKICAgICJleHBlY3RlZF9za2lsbCI6ICJudmNmLXNlbGYtbWFuYWdlZC1pbnN0YWxsYXRpb24i" + - "LAogICAgImdyb3VuZF90cnV0aCI6ICJUaGUgYWdlbnQgZXhwbGFpbmVkIHRoZSB2YWx1ZXMgcHJl" + - "Y2VkZW5jZSBjaGFpbiAoYmFzZS55YW1sLCBlbnYgWUFNTCwgZ2xvYmFsLnlhbWwuZ290bXBsLCBz" + - "ZWNyZXRzLCBpbmxpbmUgdmFsdWVzKSwgaWRlbnRpZmllZCB0aGF0IGdsb2JhbC55YW1sLmdvdG1w" + - "bCBvbmx5IHBhc3NlcyB0aHJvdWdoIHNwZWNpZmljIGtleXMsIGFuZCBleHBsYWluZWQgdGhhdCBh" + - "cmJpdHJhcnkgY2hhcnQgdmFsdWVzIG11c3QgdXNlIHJlbGVhc2UgaW5saW5lIHZhbHVlcyBibG9j" + - "a3MuIiwKICAgICJleHBlY3RlZF9iZWhhdmlvciI6IFsKICAgICAgIlRoZSBhZ2VudCByZWFkIHRo" + - "ZSBudmNmLXNlbGYtbWFuYWdlZC1pbnN0YWxsYXRpb24gU0tJTEwubWQgYmVmb3JlIHRha2luZyBh" + - "Y3Rpb24iLAogICAgICAiVGhlIGFnZW50IGV4cGxhaW5lZCB0aGUgdmFsdWVzIHByZWNlZGVuY2Ug" + - "Y2hhaW46IGJhc2UueWFtbCAtPiBlbnYgWUFNTCAtPiBnbG9iYWwueWFtbC5nb3RtcGwgLT4gc2Vj" + - "cmV0cyAtPiBpbmxpbmUgdmFsdWVzIiwKICAgICAgIlRoZSBhZ2VudCBpZGVudGlmaWVkIHRoYXQg" + - "Z2xvYmFsLnlhbWwuZ290bXBsIG9ubHkgcGFzc2VzIHRocm91Z2ggc3BlY2lmaWMga2V5cyAoY2Fz" + - "c2FuZHJhLnJlcGxpY2FDb3VudCwgZ2xvYmFsLnN0b3JhZ2VDbGFzcywgZ2xvYmFsLmltYWdlLCBl" + - "dGMuKSIsCiAgICAgICJUaGUgYWdlbnQgZXhwbGFpbmVkIHRoYXQgYXJiaXRyYXJ5IGNoYXJ0IHZh" + - "bHVlcyBtdXN0IGJlIHNldCB2aWEgcmVsZWFzZSBpbmxpbmUgdmFsdWVzOiBibG9ja3MiLAogICAg" + - "ICAiVGhlIGFnZW50IGxpc3RlZCBleGFtcGxlcyBvZiB2YWx1ZXMgdGhhdCBhcmUgcHJvcGFnYXRl" + - "ZCBhbmQgYXJiaXRyYXJ5IGNoYXJ0IHZhbHVlcyB0aGF0IHJlcXVpcmUgYSByZWxlYXNlIHZhbHVl" + - "cyBibG9jayIKICAgIF0KICB9LAogIHsKICAgICJpZCI6ICJTMTQtZW5hYmxlLWxsbS1mdW5jdGlv" + - "bnMiLAogICAgInF1ZXN0aW9uIjogIkkgbmVlZCB0byBkZXBsb3kgZnVuY3Rpb25UeXBlOiBMTE0g" + - "ZnVuY3Rpb25zIG9uIGEgc2VsZi1tYW5hZ2VkLCBzaW5nbGUtbm9kZSBpc29sYXRlZCB0ZXN0IGNs" + - "dXN0ZXIuIFdoYXQgSGVsbWZpbGUgY29uZmlndXJhdGlvbiBhbmQgdmVyaWZpY2F0aW9uIHN0ZXBz" + - "IGRvIEkgbmVlZD8iLAogICAgImV4cGVjdGVkX3NraWxsIjogIm52Y2Ytc2VsZi1tYW5hZ2VkLWlu" + - "c3RhbGxhdGlvbiIsCiAgICAiZ3JvdW5kX3RydXRoIjogIlRoZSBhZ2VudCBlbmFibGVkIHRoZSBM" + - "TE0gYWRkb24gd2l0aCBhZGRvbnMubGxtLmVuYWJsZWQsIGNvbmZpZ3VyZWQgc2luZ2xlIHJlcGxp" + - "Y2FzIGZvciB0aGUgTExNIEFQSSBHYXRld2F5IGFuZCByZXF1ZXN0IHJvdXRlciwgYW5kIGV4cGxh" + - "aW5lZCB0aGF0IHRoZSByZXF1ZXN0IHJvdXRlciB1c2VzIHBvd2VyLW9mLXR3byB3aGVuIG5vIGxv" + - "YWQtYmFsYW5jZXIgY29uZmlndXJhdGlvbiBpcyBzZXQuIEl0IGxpbmtlZCB0aGUgY2Fub25pY2Fs" + - "IHJlcXVlc3Qtcm91dGVyIGxvYWQtYmFsYW5jaW5nIGd1aWRlIGZvciBvdGhlciByb3V0aW5nIG1l" + - "dGhvZHMuIEZvciB0aGUgaXNvbGF0ZWQgcGxhaW50ZXh0IGNsdXN0ZXIsIGl0IGluY2x1ZGVkIGJv" + - "dGggYWRkb25zLmxsbS5nYXRld2F5LmF1dGguZ3JwY0luc2VjdXJlIGFuZCBhZ2VudENvbmZpZy5t" + - "ZXJnZUNvbmZpZy53b3JrbG9hZC5zdGFyZ2F0ZVFVSUNJbnNlY3VyZSwgd2l0aCBhIHdhcm5pbmcg" + - "dGhhdCB0aG9zZSBzZXR0aW5ncyBhcmUgbm90IGZvciBwcm9kdWN0aW9uLiBJdCByZWZyZXNoZWQg" + - "dGhlIGNvbXB1dGUgcGxhbmUgdXNpbmcgdGhlIHNhbWUgaGFuZG9mZiB1c2VkIGR1cmluZyBpbnN0" + - "YWxsYXRpb24sIHJlZGVwbG95ZWQgZXhpc3RpbmcgTExNIGZ1bmN0aW9ucywgYW5kIHZlcmlmaWVk" + - "IHRoZSBMTE0gZGVwbG95bWVudHMsIHJvdXRlLCBhbmQgbGxtLXdvcmtlciBzaWRlY2FyLiIsCiAg" + - "ICAiZXhwZWN0ZWRfYmVoYXZpb3IiOiBbCiAgICAgICJUaGUgYWdlbnQgdXNlZCBhZGRvbnMubGxt" + - "LmVuYWJsZWQsIG5vdCB0aGUgb2Jzb2xldGUgbGxtLmVuYWJsZWQgcGF0aCIsCiAgICAgICJUaGUg" + - "YWdlbnQgc2V0IGdhdGV3YXkgYW5kIHJlcXVlc3RSb3V0ZXIgcmVwbGljYUNvdW50IHRvIDEgZm9y" + - "IHRoZSBzaW5nbGUtbm9kZSB0ZXN0IGNsdXN0ZXIiLAogICAgICAiVGhlIGFnZW50IHN0YXRlZCB0" + - "aGF0IHRoZSByZXF1ZXN0IHJvdXRlciBkZWZhdWx0cyB0byBwb3dlci1vZi10d28gYW5kIGxpbmtl" + - "ZCB0aGUgY2Fub25pY2FsIHJlcXVlc3Qtcm91dGVyIGxvYWQtYmFsYW5jaW5nIGd1aWRlIGZvciBv" + - "dGhlciBtZXRob2RzIiwKICAgICAgIlRoZSBhZ2VudCBpbmNsdWRlZCBhZGRvbnMubGxtLmdhdGV3" + - "YXkuYXV0aC5ncnBjSW5zZWN1cmUgYW5kIHdvcmtsb2FkLnN0YXJnYXRlUVVJQ0luc2VjdXJlIGZv" + - "ciB0aGUgaXNvbGF0ZWQgcGxhaW50ZXh0IGNsdXN0ZXIsIGFuZCB3YXJuZWQgYWdhaW5zdCB1c2lu" + - "ZyB0aGVtIGluIHByb2R1Y3Rpb24iLAogICAgICAiVGhlIGFnZW50IGFwcGxpZWQgdGhlIGNvbnRy" + - "b2wtcGxhbmUgSGVsbWZpbGUgZW52aXJvbm1lbnQsIHJlZnJlc2hlZCB0aGUgY29tcHV0ZSBwbGFu" + - "ZSB3aXRoIHRoZSBzYW1lIHNlbGVjdGVkIGhhbmRvZmYsIGFuZCByZWNyZWF0ZWQgb3IgcmVkZXBs" + - "b3llZCBleGlzdGluZyBMTE0gZnVuY3Rpb25zIiwKICAgICAgIlRoZSBhZ2VudCB2ZXJpZmllZCBs" + - "bG0tYXBpLWdhdGV3YXksIGxsbS1yZXF1ZXN0LXJvdXRlciwgdGhlIExMTSBIVFRQUm91dGUsIGFu" + - "ZCB0aGUgbGxtLXdvcmtlciBzaWRlY2FyIGluY2x1ZGluZyAtLXF1aWMtaW5zZWN1cmUiCiAgICBd" + - "CiAgfSwKICB7CiAgICAiaWQiOiAiRzgtTkVHLW5vdC1mb3ItazNkIiwKICAgICJxdWVzdGlvbiI6" + - "ICJTZXQgdXAgYSBsb2NhbCBOVkNGIGRldiBjbHVzdGVyIHVzaW5nIGszZCBmb3IgdGVzdGluZyIs" + - "CiAgICAiZXhwZWN0ZWRfc2tpbGwiOiBudWxsLAogICAgInNob3VsZF90cmlnZ2VyIjogZmFsc2Us" + - "CiAgICAiZ3JvdW5kX3RydXRoIjogIlRoaXMgaXMgYSBsb2NhbCBrM2QgZGV2ZWxvcG1lbnQgcmVx" + - "dWVzdCB0aGF0IGJlbG9uZ3MgdG8gdGhlIG52Y2Ytc2VsZi1ob3N0ZWQtbG9jYWwtZGV2IHNraWxs" + - "LCBub3QgbnZjZi1zZWxmLW1hbmFnZWQtaW5zdGFsbGF0aW9uLiBUaGUgYWdlbnQgZGlkIG5vdCBy" + - "ZWFkIG9yIHVzZSB0aGUgc2VsZi1tYW5hZ2VkIGluc3RhbGxhdGlvbiBza2lsbCBhbmQgaW5zdGVh" + - "ZCBwcm92aWRlZCBrM2Qtc3BlY2lmaWMgZ3VpZGFuY2UuIiwKICAgICJleHBlY3RlZF9iZWhhdmlv" + - "ciI6IFsKICAgICAgIlRoZSBhZ2VudCBkaWQgbm90IHJlYWQgbnZjZi1zZWxmLW1hbmFnZWQtaW5z" + - "dGFsbGF0aW9uL1NLSUxMLm1kIiwKICAgICAgIlRoZSBhZ2VudCBkaWQgbm90IHByb3ZpZGUgaGVs" + - "bWZpbGUtYmFzZWQgcHJvZHVjdGlvbiBkZXBsb3ltZW50IGluc3RydWN0aW9ucyIsCiAgICAgICJU" + - "aGUgYWdlbnQgcHJvdmlkZWQgazNkLXNwZWNpZmljIGxvY2FsIGRldmVsb3BtZW50IGd1aWRhbmNl" + - "IG9yIGRlZmVycmVkIHRvIHRoZSBhcHByb3ByaWF0ZSBsb2NhbC1kZXYgc2tpbGwiCiAgICBdCiAg" + - "fQpdClBLBwgrE7g/rVUAAK1VAABQSwMEFAAIAAAAAAAhAAAAAAAAAAAAAAAAAC8ACQBkYXRhL252" + - "Y2Ytc2VsZi1tYW5hZ2VkLWluc3RhbGxhdGlvbi9leGFtcGxlcy5tZFVUBQABAKbOEiMgRXhhbXBs" + - "ZXMKCldvcmtlZCBleGFtcGxlcyBiYXNlZCBvbiByZWFsIGRlcGxveW1lbnQgc2NlbmFyaW9zLgoK" + - "IyMgRXhhbXBsZSAxOiBPdmVycmlkZSBDYXNzYW5kcmEgUmVzb3VyY2VzCgpUaGUgZGVmYXVsdCBD" + - "YXNzYW5kcmEgcmVzb3VyY2UgbGltaXRzIGNhdXNlIE9PTSBvbiBsYXJnZSBpbnN0YW5jZSB0eXBl" + - "cyAoZS5nLiwgYHA1LjQ4eGxhcmdlYCkuCgpQcm9ibGVtOiBDYXNzYW5kcmEgcG9kcyByZXN0YXJ0" + - "IHdpdGggYE9PTUtpbGxlZGAuCgpTb2x1dGlvbjogT3ZlcnJpZGUgcmVzb3VyY2VzIHZpYSBoZWxt" + - "ZmlsZSByZWxlYXNlIHZhbHVlcyBibG9jay4KCiMjIyBTdGVwIDE6IENhcHR1cmUgYmFzZWxpbmUK" + - "CmBgYGJhc2gKSEVMTUZJTEVfRU5WPTxlbnY+IGhlbG1maWxlIC0tc2VsZWN0b3IgbmFtZT1jYXNz" + - "YW5kcmEgdGVtcGxhdGUgPiAvdG1wL2Nhc3MtYmVmb3JlLnlhbWwKZ3JlcCAtQTggJ3Jlc291cmNl" + - "czonIC90bXAvY2Fzcy1iZWZvcmUueWFtbCB8IGhlYWQgLTEwCmBgYAoKIyMjIFN0ZXAgMjogQWRk" + - "IG92ZXJyaWRlIHRvIGhlbG1maWxlLmQvMDEtZGVwZW5kZW5jaWVzLnlhbWwuZ290bXBsCgpJbiB0" + - "aGUgZXhhbXBsZXMgYmVsb3csIGA8cHJpdmF0ZS12YWx1ZXM+YCByZWZlcnMgdG8gdGhlIGBzZWNy" + - "ZXRzL2AgZGlyZWN0b3J5IGF0IHRoZSBoZWxtZmlsZSBzdGFjayByb290LgoKYGBgeWFtbAotIG5h" + - "bWU6IGNhc3NhbmRyYQogIHZlcnNpb246IDAuOC4wCiAgY29uZGl0aW9uOiBjYXNzYW5kcmEuZW5h" + - "YmxlZAogIG5hbWVzcGFjZTogY2Fzc2FuZHJhLXN5c3RlbQogIDw8OiAqZGVwZW5kZW5jeQogIHZh" + - "bHVlczoKICAgIC0gLi4vZ2xvYmFsLnlhbWwuZ290bXBsCiAgICAtIC4uLzxwcml2YXRlLXZhbHVl" + - "cz4ve3sgcmVxdWlyZWRFbnYgIkhFTE1GSUxFX0VOViIgfX0tc2VjcmV0cy55YW1sCiAgICAtIGNh" + - "c3NhbmRyYToKICAgICAgICByZXNvdXJjZXM6CiAgICAgICAgICBsaW1pdHM6CiAgICAgICAgICAg" + - "IGNwdTogIjgiCiAgICAgICAgICAgIG1lbW9yeTogODE5Mk1pCiAgICAgICAgICByZXF1ZXN0czoK" + - "ICAgICAgICAgICAgY3B1OiAiMiIKICAgICAgICAgICAgbWVtb3J5OiA0MDk2TWkKYGBgCgojIyMg" + - "U3RlcCAzOiBWZXJpZnkgYW5kIGFwcGx5CgpgYGBiYXNoCkhFTE1GSUxFX0VOVj08ZW52PiBoZWxt" + - "ZmlsZSAtLXNlbGVjdG9yIG5hbWU9Y2Fzc2FuZHJhIHRlbXBsYXRlID4gL3RtcC9jYXNzLWFmdGVy" + - "LnlhbWwKZGlmZiAvdG1wL2Nhc3MtYmVmb3JlLnlhbWwgL3RtcC9jYXNzLWFmdGVyLnlhbWwgICMg" + - "Q29uZmlybSByZXNvdXJjZXMgY2hhbmdlZApIRUxNRklMRV9FTlY9PGVudj4gaGVsbWZpbGUgLS1z" + - "ZWxlY3RvciBuYW1lPWNhc3NhbmRyYSBzeW5jCmBgYAoKTm90ZTogYHJlc291cmNlUHJlc2V0YCAo" + - "YSBCaXRuYW1pIGZlYXR1cmUpIGlzIG5vdCBhdmFpbGFibGUgaW4gdGhlIE5WQ0YgY2Fzc2FuZHJh" + - "IHdyYXBwZXIgY2hhcnQuIFVzZSBleHBsaWNpdCBgcmVzb3VyY2VzYCBpbnN0ZWFkLgoKLS0tCgoj" + - "IyBFeGFtcGxlIDI6IERlcGxveSBmcm9tIE5HQyBQcml2YXRlIFJlZ2lzdHJ5IHdpdGggUHVsbCBT" + - "ZWNyZXRzCgpEZXBsb3kgdGhlIE5WQ0Ygc3RhY2sgcHVsbGluZyBpbWFnZXMgZGlyZWN0bHkgZnJv" + - "bSBOR0MgKGBudmNyLmlvYCkgaW5zdGVhZCBvZiBhIG1pcnJvcmVkIHJlZ2lzdHJ5LCB1c2luZyBp" + - "bWFnZSBwdWxsIHNlY3JldHMuCgojIyMgU3RlcCAxOiBDb25maWd1cmUgZW52aXJvbm1lbnQgZm9y" + - "IE5HQwoKYGBgeWFtbAojIGVudmlyb25tZW50cy88ZW52Pi55YW1sCmdsb2JhbDoKICBoZWxtOgog" + - "ICAgc291cmNlczoKICAgICAgcmVnaXN0cnk6IG52Y3IuaW8KICAgICAgcmVwb3NpdG9yeTogbnZp" + - "ZGlhL252Y2YKICBpbWFnZToKICAgIHJlZ2lzdHJ5OiBudmNyLmlvCiAgICByZXBvc2l0b3J5OiBu" + - "dmlkaWEvbnZjZgpgYGAKCiMjIyBTdGVwIDI6IEF1dGhlbnRpY2F0ZSBsb2NhbGx5IChmb3IgaGVs" + - "bWZpbGUgY2hhcnQgcHVsbHMpCgpgYGBiYXNoCmRvY2tlciBsb2dpbiBudmNyLmlvIC11ICckb2F1" + - "dGh0b2tlbicgLXAgIiROR0NfQVBJX0tFWSIKaGVsbSByZWdpc3RyeSBsb2dpbiBudmNyLmlvIC11" + - "ICckb2F1dGh0b2tlbicgLXAgIiROR0NfQVBJX0tFWSIKYGBgCgojIyMgU3RlcCAzOiBDcmVhdGUg" + - "bmFtZXNwYWNlcyBhbmQgcHVsbCBzZWNyZXRzCgpgYGBiYXNoCmV4cG9ydCBOR0NfQVBJX0tFWT0i" + - "PHlvdXItbmdjLWFwaS1rZXk+IgoKZm9yIG5zIGluIGNhc3NhbmRyYS1zeXN0ZW0gbmF0cy1zeXN0" + - "ZW0gbnZjZiBhcGkta2V5cyBlc3Mgc2lzIHZhdWx0LXN5c3RlbSBjZXJ0LW1hbmFnZXI7IGRvCiAg" + - "a3ViZWN0bCAtLWNvbnRleHQgPGNvbnRyb2wtcGxhbmUtY29udGV4dD4gY3JlYXRlIG5hbWVzcGFj" + - "ZSAiJG5zIiBcCiAgICAtLWRyeS1ydW49Y2xpZW50IC1vIHlhbWwgfCBrdWJlY3RsIC0tY29udGV4" + - "dCA8Y29udHJvbC1wbGFuZS1jb250ZXh0PiBhcHBseSAtZiAtCmRvbmUKCmZvciBucyBpbiBjYXNz" + - "YW5kcmEtc3lzdGVtIG5hdHMtc3lzdGVtIG52Y2YgYXBpLWtleXMgZXNzIHNpcyB2YXVsdC1zeXN0" + - "ZW0gY2VydC1tYW5hZ2VyOyBkbwogIGt1YmVjdGwgLS1jb250ZXh0IDxjb250cm9sLXBsYW5lLWNv" + - "bnRleHQ+IGNyZWF0ZSBzZWNyZXQgZG9ja2VyLXJlZ2lzdHJ5IG52Y3ItY3JlZHMgXAogICAgLS1k" + - "b2NrZXItc2VydmVyPW52Y3IuaW8gXAogICAgLS1kb2NrZXItdXNlcm5hbWU9JyRvYXV0aHRva2Vu" + - "JyBcCiAgICAtLWRvY2tlci1wYXNzd29yZD0iJE5HQ19BUElfS0VZIiBcCiAgICAtLW5hbWVzcGFj" + - "ZT0iJG5zIiBcCiAgICAtLWRyeS1ydW49Y2xpZW50IC1vIHlhbWwgfCBrdWJlY3RsIC0tY29udGV4" + - "dCA8Y29udHJvbC1wbGFuZS1jb250ZXh0PiBhcHBseSAtZiAtCmRvbmUKYGBgCgojIyMgU3RlcCA0" + - "OiBBZGQgaW1hZ2VQdWxsU2VjcmV0cyB0byBoZWxtZmlsZSByZWxlYXNlcwoKQWRkIHRoZSBjaGFy" + - "dC1zcGVjaWZpYyBgaW1hZ2VQdWxsU2VjcmV0c2Aga2V5IHRvIGVhY2ggcmVsZWFzZS4gRXhhbXBs" + - "ZSBmb3IgY2Fzc2FuZHJhIGluIGBoZWxtZmlsZS5kLzAxLWRlcGVuZGVuY2llcy55YW1sLmdvdG1w" + - "bGA6CgpgYGB5YW1sCi0gbmFtZTogY2Fzc2FuZHJhCiAgdmVyc2lvbjogMC44LjAKICBjb25kaXRp" + - "b246IGNhc3NhbmRyYS5lbmFibGVkCiAgbmFtZXNwYWNlOiBjYXNzYW5kcmEtc3lzdGVtCiAgPDw6" + - "ICpkZXBlbmRlbmN5CiAgdmFsdWVzOgogICAgLSAuLi9nbG9iYWwueWFtbC5nb3RtcGwKICAgIC0g" + - "Li4vPHByaXZhdGUtdmFsdWVzPi97eyByZXF1aXJlZEVudiAiSEVMTUZJTEVfRU5WIiB9fS1zZWNy" + - "ZXRzLnlhbWwKICAgIC0gY2Fzc2FuZHJhOgogICAgICAgIGdsb2JhbDoKICAgICAgICAgIGltYWdl" + - "UHVsbFNlY3JldHM6CiAgICAgICAgICAgIC0gbnZjci1jcmVkcwpgYGAKClNlZSBbcmVmZXJlbmNl" + - "cy9wdWxsLXNlY3JldHMubWRdKHJlZmVyZW5jZXMvcHVsbC1zZWNyZXRzLm1kKSBmb3IgdGhlIGtl" + - "eSBmb3IgZXZlcnkgY2hhcnQuCgpUaGVzZSBhcmUgY29udHJvbC1wbGFuZSBuYW1lc3BhY2VzLiBG" + - "b3IgYSBzZXBhcmF0ZSBjb21wdXRlIGNsdXN0ZXIsIGNyZWF0ZSB0aGUKc2VjcmV0IG9ubHkgaW4g" + - "YG52Y2Etb3BlcmF0b3JgOyB0aGUgY2hhcnQgYW5kIG9wZXJhdG9yIG1pcnJvciBpdCB0bwpgbnZj" + - "YS1zeXN0ZW1gLiBTZWUgW1NwbGl0IENvbXB1dGUtUGxhbmUgSW5zdGFsbGF0aW9uXShyZWZlcmVu" + - "Y2VzL2NvbXB1dGUtcGxhbmUtaW5zdGFsbGF0aW9uLm1kI3B1bGwtc2VjcmV0cykuCgojIyMgU3Rl" + - "cCA1OiBEZXBsb3kKCmBgYGJhc2gKSEVMTUZJTEVfRU5WPTxlbnY+IGhlbG1maWxlIC0ta3ViZS1j" + - "b250ZXh0IDxjb250cm9sLXBsYW5lLWNvbnRleHQ+IHN5bmMKYGBgCgojIyMgU3RlcCA2OiBQYXRj" + - "aCBTZXJ2aWNlQWNjb3VudHMgZm9yIGNoYXJ0cyB3aXRob3V0IG5hdGl2ZSBzdXBwb3J0CgpBZnRl" + - "ciBQaGFzZSAxIChkZXBlbmRlbmNpZXMpIGNvbXBsZXRlcywgT3BlbkJhbyBwb2RzIHdpbGwgYmUg" + - "aW4gYEltYWdlUHVsbEJhY2tPZmZgLiBQYXRjaCBhbmQgcmVzdGFydDoKCmBgYGJhc2gKZm9yIG5z" + - "IGluIHZhdWx0LXN5c3RlbSBudmNmIGVzczsgZG8KICBmb3Igc2EgaW4gJChrdWJlY3RsIC0tY29u" + - "dGV4dCA8Y29udHJvbC1wbGFuZS1jb250ZXh0PiBnZXQgc2EgLW4gIiRucyIgXAogICAgLS1uby1o" + - "ZWFkZXJzIC1vIGN1c3RvbS1jb2x1bW5zPSI6bWV0YWRhdGEubmFtZSIpOyBkbwogICAga3ViZWN0" + - "bCAtLWNvbnRleHQgPGNvbnRyb2wtcGxhbmUtY29udGV4dD4gcGF0Y2ggc2VydmljZWFjY291bnQg" + - "LW4gIiRucyIgIiRzYSIgXAogICAgICAtcCAneyJpbWFnZVB1bGxTZWNyZXRzIjogW3sibmFtZSI6" + - "ICJudmNyLWNyZWRzIn1dfScKICBkb25lCmRvbmUKa3ViZWN0bCAtLWNvbnRleHQgPGNvbnRyb2wt" + - "cGxhbmUtY29udGV4dD4gZGVsZXRlIHBvZHMgLW4gdmF1bHQtc3lzdGVtIC0tYWxsCmBgYAoKVmVy" + - "aWZ5OgoKYGBgYmFzaAprdWJlY3RsIC0tY29udGV4dCA8Y29udHJvbC1wbGFuZS1jb250ZXh0PiBn" + - "ZXQgZXZlbnRzIC1uIHZhdWx0LXN5c3RlbSBcCiAgLS1zb3J0LWJ5PScubGFzdFRpbWVzdGFtcCcg" + - "fCBncmVwIC1pIHB1bGwKIyBTaG91bGQgc2hvdyAiU3VjY2Vzc2Z1bGx5IHB1bGxlZCBpbWFnZSIg" + - "ZnJvbSBudmNyLmlvCmBgYAoKLS0tCgojIyBFeGFtcGxlIDM6IEZ1bGwgVGVhcmRvd24gYW5kIFJl" + - "aW5zdGFsbAoKV2hlbiBhIGRlcGxveW1lbnQgaXMgYnJva2VuIGFuZCB5b3UgbmVlZCBhIGNsZWFu" + - "IHNsYXRlLgoKIyMjIFN0ZXAgMTogRGVzdHJveSB0aGUgY29tcHV0ZS1wbGFuZSBzdGFjawoKYGBg" + - "YmFzaAptYWtlIC1DIGRlcGxveS9zdGFja3MvbnZjZi1jb21wdXRlLXBsYW5lIGRlc3Ryb3kgXAog" + - "IENMVVNURVJfTkFNRT08Y2x1c3Rlci1uYW1lPiBcCiAgSEVMTUZJTEVfRU5WPTxlbnY+IFwKICBL" + - "VUJFQ09ORklHX0ZJTEU9PGNvbXB1dGUtcGxhbmUta3ViZWNvbmZpZz4KYGBgCgpJZiBjb21wdXRl" + - "IGNsZWFudXAgaXMgc3R1Y2sgb24gZmluYWxpemVycywgdXNlIHRoZSBjb21wdXRlLWNvbnRleHQg" + - "cHJvY2VkdXJlIGluCltkZWJ1Z2dpbmcubWRdKHJlZmVyZW5jZXMvZGVidWdnaW5nLm1kI2ZhaWx1" + - "cmUtbnZjYS1jbGVhbnVwLXN0dWNrLWZpbmFsaXplcnMpLgoKIyMjIFN0ZXAgMjogRGVyZWdpc3Rl" + - "ciB0aGUgY29tcHV0ZSBjbHVzdGVyCgpSZWFkIGBjbHVzdGVySURgIGFuZCBgbmNhSURgIGZyb20K" + - "YGRlcGxveS9zdGFja3MvbnZjZi1jb21wdXRlLXBsYW5lL3JlZ2lzdHJhdGlvbi88Y2x1c3Rlci1u" + - "YW1lPi1yZWdpc3Rlci12YWx1ZXMueWFtbGAuClNob3cgdGhlIElEIGFuZCBnZXQgY29uZmlybWF0" + - "aW9uIGJlZm9yZSBkZWxldGluZyB0aGUgSUNNUyByb3c6CgpgYGBiYXNoCjxudmNmLWNsaT4gLS1j" + - "b25maWcgPGNvbmZpZz4gY2x1c3RlciBkZWxldGUgXAogIC0tY2x1c3Rlci1pZCA8Y2x1c3Rlci1p" + - "ZC1mcm9tLXJlZ2lzdHJhdGlvbi12YWx1ZXM+IFwKICAtLW5jYS1pZCA8bmNhLWlkPiBcCiAgLS1p" + - "Z25vcmUtbWlzc2luZwpgYGAKClJlcGVhdCBzdGVwcyAxIGFuZCAyIGZvciBldmVyeSBjb21wdXRl" + - "IGNsdXN0ZXIuCgojIyMgU3RlcCAzOiBEZXN0cm95IHRoZSBjb250cm9sLXBsYW5lIHN0YWNrCgpQ" + - "cmVzZXJ2ZSB0aGUgYGNlcnQtbWFuYWdlcmAgbmFtZXNwYWNlIGJ5IGRlZmF1bHQuIE5hbWVzcGFj" + - "ZSBwcmVzZXJ2YXRpb24gZG9lcwpub3QgcHJlc2VydmUgdGhlIEhlbG0gcmVsZWFzZS4gQmVmb3Jl" + - "IHJ1bm5pbmcgZGVzdHJveSwgaWRlbnRpZnkgd2hldGhlcgpjZXJ0LW1hbmFnZXIgaXMgZXh0ZXJu" + - "YWwuIEZvciBhbiBleHRlcm5hbCBpbnN0YWxsYXRpb24sIHJlcXVpcmUgZWZmZWN0aXZlCmBjZXJ0" + - "TWFuYWdlci5lbmFibGVkOiBmYWxzZWAgYW5kIGFib3J0IGlmIGl0IGlzIHRydWUuIEZvciBhbiBp" + - "bnRlbmRlZApzdGFjay1tYW5hZ2VkIHJlbGVhc2Ugd2l0aCBlZmZlY3RpdmUgYGNlcnRNYW5hZ2Vy" + - "LmVuYWJsZWQ6IHRydWVgLCB2ZXJpZnkKbWF0Y2hpbmcgc3RhY2sgSGVsbSByZWxlYXNlIG1ldGFk" + - "YXRhIGFuZCBhYm9ydCBvbiBtaXNzaW5nIG9yIG1pc21hdGNoZWQKZXZpZGVuY2UuIE9ubHkgcGxh" + - "biBuYW1lc3BhY2UgcmVtb3ZhbCBhZnRlciB2ZXJpZnlpbmcgbmFtZXNwYWNlIHByb3ZlbmFuY2Ug" + - "YW5kCmdldHRpbmcgZXhwbGljaXQgY29uZmlybWF0aW9uOyBvdGhlcndpc2UgZG8gbm90IGRlbGV0" + - "ZSBpdC4KCmBgYGJhc2gKS1VCRUNPTkZJRz08Y29udHJvbC1wbGFuZS1rdWJlY29uZmlnPiBcCm1h" + - "a2UgLUMgZGVwbG95L3N0YWNrcy9zZWxmLW1hbmFnZWQgZGVzdHJveSBcCiAgSEVMTUZJTEVfRU5W" + - "PTxlbnY+IFwKICBLVUJFQ09ORklHX0ZJTEU9PGNvbnRyb2wtcGxhbmUta3ViZWNvbmZpZz4KYGBg" + - "CgpQYXNzIGJvdGgga3ViZWNvbmZpZyBmb3JtcyBiZWNhdXNlIGNvbnRyb2wtcGxhbmUgbmFtZXNw" + - "YWNlIGNsZWFudXAgdXNlcwphbWJpZW50IGBrdWJlY3RsYC4KCiMjIyBTdGVwIDQ6IFZlcmlmeSBj" + - "bGVhbgoKYGBgYmFzaAprdWJlY3RsIC0tY29udGV4dCA8Y29tcHV0ZS1wbGFuZS1jb250ZXh0PiBn" + - "ZXQgbnMgfCBcCiAgZ3JlcCAtRSAnKG52Y2F8bnZjZi1iYWNrZW5kfGdyb3ZlfGR5bmFtbyknCmt1" + - "YmVjdGwgLS1jb250ZXh0IDxjb250cm9sLXBsYW5lLWNvbnRleHQ+IGdldCBucyB8IFwKICBncmVw" + - "IC1FICcoY2Fzc2FuZHJhfG5hdHN8dmF1bHR8bnZjZnxhcGkta2V5c3xlc3N8c2lzKScKIyBCb3Ro" + - "IGNvbW1hbmRzIHNob3VsZCByZXR1cm4gZW1wdHkuCmBgYAoKIyMjIFN0ZXAgNTogUmVpbnN0YWxs" + - "IGluIHNwbGl0IG9yZGVyCgpGb2xsb3cgW0NsZWFuIEluc3RhbGxhdGlvbl0oU0tJTEwubWQjY2xl" + - "YW4taW5zdGFsbGF0aW9uKSwgdGhlbiByZXR1cm4gdG8gdGhlCnNhbWUgaGFuZG9mZiBpbiBbU3Bs" + - "aXQgQ29tcHV0ZS1QbGFuZSBJbnN0YWxsYXRpb25dKHJlZmVyZW5jZXMvY29tcHV0ZS1wbGFuZS1p" + - "bnN0YWxsYXRpb24ubWQpLgoKLS0tCgojIyBFeGFtcGxlIDQ6IFJlY292ZXIgZnJvbSBhIEdhdGV3" + - "YXkgRW5kcG9pbnQgQ2hhbmdlCgpUaGUgc2VwYXJhdGVseSBwcm92aXNpb25lZCBHYXRld2F5IG9y" + - "IGl0cyBsb2FkIGJhbGFuY2VyIHdhcyByZWNyZWF0ZWQgYW5kIGdvdCBhIG5ldyBlbmRwb2ludC4K" + - "CiMjIyBTdGVwIDE6IEdldCB0aGUgbmV3IGVuZHBvaW50CgpgYGBiYXNoCkdBVEVXQVlfQUREUj0k" + - "KGt1YmVjdGwgLS1jb250ZXh0IDxjb250cm9sLXBsYW5lLWNvbnRleHQ+IGdldCBnYXRld2F5IFwK" + - "ICBudmNmLWdhdGV3YXkgLW4gZW52b3ktZ2F0ZXdheSBcCiAgLW8ganNvbnBhdGg9J3suc3RhdHVz" + - "LmFkZHJlc3Nlc1swXS52YWx1ZX0nKQp0ZXN0IC1uICIkR0FURVdBWV9BRERSIgpgYGAKCiMjIyBT" + - "dGVwIDI6IFVwZGF0ZSBETlMgYW5kIGRpcmVjdCBhZGRyZXNzIGZpZWxkcwoKS2VlcCBgZ2xvYmFs" + - "LmRvbWFpbmAsIHJvdXRlIGhvc3RuYW1lcywgYW5kIENMSSBIb3N0IGZpZWxkcyB1bmNoYW5nZWQu" + - "IFBvaW50IHRoZQpETlMgcmVjb3JkcyBmb3IgcmVuZGVyZWQgcm91dGUgaG9zdG5hbWVzLCBzdWNo" + - "IGFzIGBhcGkuPGRvbWFpbj5gIGFuZApgKi5pbnZvY2F0aW9uLjxkb21haW4+YCwgdG8gYEdBVEVX" + - "QVlfQUREUmAuIEZvciBhIHRlbXBvcmFyeSBlbnZpcm9ubWVudCB3aXRob3V0CkROUywga2VlcCBp" + - "dHMgcmVzZXJ2ZWQgcm91dGUgc3VmZml4IGFuZCBjb25uZWN0IHRvIGBHQVRFV0FZX0FERFJgIHdp" + - "dGggdGhlCm1hdGNoaW5nIGBIb3N0YCBoZWFkZXIuCgpGb3IgYSBzcGxpdCBkZXBsb3ltZW50IGNv" + - "bmZpZ3VyZWQgd2l0aCBkaXJlY3QgR2F0ZXdheSBhZGRyZXNzZXMsIHJlcGxhY2Ugb25seQp0aGUg" + - "YWRkcmVzcy1iZWFyaW5nIHZhbHVlczogY29udHJvbC1wbGFuZSBgbnZjZk5hdHNTZXJ2aWNlVVJM" + - "YCwgY29tcHV0ZS1wbGFuZQpJQ01TLCBSZVZhbCwgYW5kIE5BVFMgVVJMcywgYW5kIENMSSBVUkwg" + - "ZmllbGRzLiBLZWVwIHRoZWlyIGRvbWFpbiBhbmQgSG9zdApvdmVycmlkZXMgdW5jaGFuZ2VkLiBS" + - "ZWZyZXNoIHJlZ2lzdHJhdGlvbiBhbmQgaW5zdGFsbGF0aW9uIHRocm91Z2ggdGhlIHNhbWUKaGFu" + - "ZG9mZiB1c2VkIG9yaWdpbmFsbHkuIFNlZQpbU3BsaXQgQ29tcHV0ZS1QbGFuZSBJbnN0YWxsYXRp" + - "b25dKHJlZmVyZW5jZXMvY29tcHV0ZS1wbGFuZS1pbnN0YWxsYXRpb24ubWQpCmZvciB0aGUgZmll" + - "bGRzIGFuZCBjb21wbGV0ZSBjb21tYW5kcy4KCiMjIyBTdGVwIDM6IFZlcmlmeSBib3RoIGNvbnRl" + - "eHRzCgpgYGBiYXNoCmRpZyArc2hvcnQgImFwaS48ZG9tYWluPiIKY3VybCAtSCAiSG9zdDogYXBp" + - "Ljxkb21haW4+IiAiaHR0cDovLyRHQVRFV0FZX0FERFIvaGVhbHRoIgprdWJlY3RsIC0tY29udGV4" + - "dCA8Y29udHJvbC1wbGFuZS1jb250ZXh0PiBnZXQgZ2F0ZXdheSBudmNmLWdhdGV3YXkgXAogIC1u" + - "IGVudm95LWdhdGV3YXkgLW8gd2lkZQprdWJlY3RsIC0tY29udGV4dCA8Y29udHJvbC1wbGFuZS1j" + - "b250ZXh0PiBnZXQgaHR0cHJvdXRlcyAtQQprdWJlY3RsIC0tY29udGV4dCA8Y29udHJvbC1wbGFu" + - "ZS1jb250ZXh0PiBnZXQgdGNwcm91dGVzIC1BCmt1YmVjdGwgLS1jb250ZXh0IDxjb21wdXRlLXBs" + - "YW5lLWNvbnRleHQ+IHJvbGxvdXQgc3RhdHVzIFwKICBkZXBsb3ltZW50L252Y2Etb3BlcmF0b3Ig" + - "LW4gbnZjYS1vcGVyYXRvciAtLXRpbWVvdXQ9MTBtCmt1YmVjdGwgLS1jb250ZXh0IDxjb21wdXRl" + - "LXBsYW5lLWNvbnRleHQ+IHdhaXQgXAogIG52Y2ZiYWNrZW5kLzxjb21wdXRlLXBsYW5lLWNsdXN0" + - "ZXItbmFtZT4gLW4gbnZjYS1vcGVyYXRvciBcCiAgLS1mb3I9anNvbnBhdGg9J3suc3RhdHVzLmFn" + - "ZW50U3RhdHVzfSc9aGVhbHRoeSAtLXRpbWVvdXQ9MTBtCmBgYAoKLS0tCgojIyBFeGFtcGxlIDU6" + - "IERlcGxveSBPbmx5IERlcGVuZGVuY2llcwoKVXNlZnVsIGZvciB0ZXN0aW5nIG9yIHdoZW4gaXRl" + - "cmF0aW5nIG9uIHNlcnZpY2UgY29uZmlndXJhdGlvbi4KCmBgYGJhc2gKIyBEZXBsb3kganVzdCBO" + - "QVRTLCBDYXNzYW5kcmEsIE9wZW5CYW8KSEVMTUZJTEVfRU5WPTxlbnY+IGhlbG1maWxlIC0tc2Vs" + - "ZWN0b3IgcmVsZWFzZS1ncm91cD1kZXBlbmRlbmNpZXMgc3luYwoKIyBDaGVjayBzdGF0dXMKa3Vi" + - "ZWN0bCBnZXQgcG9kcyAtbiBuYXRzLXN5c3RlbQprdWJlY3RsIGdldCBwb2RzIC1uIGNhc3NhbmRy" + - "YS1zeXN0ZW0Ka3ViZWN0bCBnZXQgcG9kcyAtbiB2YXVsdC1zeXN0ZW0KCiMgRGVwbG95IGp1c3Qg" + - "b25lIHNwZWNpZmljIHJlbGVhc2UKSEVMTUZJTEVfRU5WPTxlbnY+IGhlbG1maWxlIC0tc2VsZWN0" + - "b3IgbmFtZT1jYXNzYW5kcmEgc3luYwpgYGAKCiMjIyBTZWxlY3RvciByZWZlcmVuY2UKCnwgU2Vs" + - "ZWN0b3IgfCBSZWxlYXNlcyB8CnwtLS0tLS0tLS0tfC0tLS0tLS0tLS18CnwgYHJlbGVhc2UtZ3Jv" + - "dXA9ZGVwZW5kZW5jaWVzYCB8IG5hdHMsIGNhc3NhbmRyYSwgb3BlbmJhby1zZXJ2ZXIgfAp8IGBy" + - "ZWxlYXNlLWdyb3VwPXNlcnZpY2VzYCB8IGFwaS1rZXlzLCBzaXMsIGFwaSwgaW52b2NhdGlvbi1z" + - "ZXJ2aWNlLCBncnBjLXByb3h5LCBlc3MtYXBpLCBub3Rhcnktc2VydmljZSwgcmV2YWwsIG9wdGlv" + - "bmFsIGxsbS1yZXF1ZXN0LXJvdXRlciBhbmQgbGxtLWFwaS1nYXRld2F5IHdoZW4gYGxsbS5lbmFi" + - "bGVkPXRydWVgLCBvcHRpb25hbCB2YW5pdHktZ2F0ZXdheSBvbmx5IGluIHN0YWNrIHBhY2thZ2Vz" + - "IHRoYXQgaW5jbHVkZSB0aGUgYWRkb24gYW5kIGhhdmUgYGFkZG9ucy52YW5pdHlHYXRld2F5LmVu" + - "YWJsZWQ9dHJ1ZWAsIG9wdGlvbmFsIG52Y2YtdWkgb25seSBpbiBzdGFjayBwYWNrYWdlcyB0aGF0" + - "IGluY2x1ZGUgdGhlIGFkZG9uIGFuZCBoYXZlIGBhZGRvbnMubnZjZlVpLmVuYWJsZWQ9dHJ1ZWAg" + - "fAp8IGBuYW1lPWxsbS1yZXF1ZXN0LXJvdXRlcmAgfCBEZXBsb3kganVzdCB0aGUgTExNIHJlcXVl" + - "c3Qgcm91dGVyIHdoZW4gYGxsbS5lbmFibGVkPXRydWVgIHwKfCBgbmFtZT1sbG0tYXBpLWdhdGV3" + - "YXlgIHwgRGVwbG95IGp1c3QgdGhlIExMTSBBUEkgZ2F0ZXdheSB3aGVuIGBsbG0uZW5hYmxlZD10" + - "cnVlYCB8CnwgYG5hbWU9dmFuaXR5LWdhdGV3YXlgIHwgRGVwbG95IGp1c3QgVmFuaXR5IEdhdGV3" + - "YXkgb25seSB3aGVuIHRoZSBzdGFjayBwYWNrYWdlIGluY2x1ZGVzIHRoYXQgcmVsZWFzZSBhbmQg" + - "YGFkZG9ucy52YW5pdHlHYXRld2F5LmVuYWJsZWQ9dHJ1ZWAgfAp8IGBuYW1lPW52Y2YtdWlgIHwg" + - "RGVwbG95IE5WQ0YgVUkgb25seSB3aGVuIHRoZSBzdGFjayBwYWNrYWdlIGluY2x1ZGVzIHRoYXQg" + - "cmVsZWFzZSBhbmQgYGFkZG9ucy5udmNmVWkuZW5hYmxlZD10cnVlYCB8CnwgYHJlbGVhc2UtZ3Jv" + - "dXA9aW5ncmVzc2AgfCBpbmdyZXNzIChnYXRld2F5IHJvdXRlcykgfAp8IGBuYW1lPTxyZWxlYXNl" + - "PmAgfCBBbnkgaW5kaXZpZHVhbCByZWxlYXNlIGJ5IG5hbWUgfAoKTm90ZTogYGFkbWluLWlzc3Vl" + - "ci1wcm94eWAgZG9lcyBub3QgaGF2ZSBhIHJlbGVhc2UtZ3JvdXAgbGFiZWwuIFRhcmdldCBpdCB3" + - "aXRoIGAtLXNlbGVjdG9yIG5hbWU9YWRtaW4taXNzdWVyLXByb3h5YC4KUEsHCAJSTkB/KAAAfygA" + - "AFBLAwQUAAgAAAAAACEAAAAAAAAAAAAAAAAATAAJAGRhdGEvbnZjZi1zZWxmLW1hbmFnZWQtaW5z" + - "dGFsbGF0aW9uL3JlZmVyZW5jZXMvY29tcHV0ZS1wbGFuZS1pbnN0YWxsYXRpb24ubWRVVAUAAQCm" + - "zhIjIFNwbGl0IENvbXB1dGUtUGxhbmUgSW5zdGFsbGF0aW9uCgpUaGUgY29udHJvbCBwbGFuZSBh" + - "bmQgY29tcHV0ZSBwbGFuZSBhcmUgc2VwYXJhdGUgc3RhY2tzLiBJbnN0YWxsIHRoZSBjb250cm9s" + - "CnBsYW5lIGZpcnN0LCB0aGVuIHJlZ2lzdGVyIGFuZCBpbnN0YWxsIGVhY2ggY29tcHV0ZSBjbHVz" + - "dGVyLiBDaG9vc2Ugb25lIGhhbmRvZmYKYmVsb3cgYW5kIHVzZSBpdCBmb3IgdGhlIGZ1bGwgbGlm" + - "ZWN5Y2xlLiBEbyBub3QgY29tYmluZSBhIENMSS1nZW5lcmF0ZWQgcHJvZmlsZQp3aXRoIHRoZSBI" + - "ZWxtZmlsZSB2YWx1ZXMgZmxvdy4KCiMjIENob29zZSBhIEhhbmRvZmYKCnwgRmxvdyB8IFNvdXJj" + - "ZSBvZiBjb250cm9sLXBsYW5lIGVuZHBvaW50cyB8IFJlZ2lzdHJhdGlvbiBhcnRpZmFjdCB8Cnwt" + - "LS0tLS18LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS18LS0tLS0tLS0tLS0tLS0t" + - "LS0tLS0tLS18CnwgSGVsbWZpbGUgdmFsdWVzIHwgU2VwYXJhdGUgY29udHJvbC1wbGFuZSBhbmQg" + - "Y29tcHV0ZS1wbGFuZSBlbnZpcm9ubWVudCBmaWxlcyB8IGBkZXBsb3kvc3RhY2tzL252Y2YtY29t" + - "cHV0ZS1wbGFuZS9yZWdpc3RyYXRpb24vPGNsdXN0ZXI+LXJlZ2lzdGVyLXZhbHVlcy55YW1sYCB8" + - "CnwgQ0xJIHByb2ZpbGUgfCBDTEktZ2VuZXJhdGVkIGBkZXBsb3kvc3RhY2tzL3NlbGYtbWFuYWdl" + - "ZC9vdXQvY29udHJvbC1wbGFuZS1wcm9maWxlLnlhbWxgIHwgQ0xJLWdlbmVyYXRlZCBgZGVwbG95" + - "L3N0YWNrcy9udmNmLWNvbXB1dGUtcGxhbmUvb3V0LzxjbHVzdGVyPi1yZWdpc3Rlci12YWx1ZXMu" + - "eWFtbGAgfAoKVGhlIENMSSBwcm9maWxlIGlzIG1hbmRhdG9yeSBmb3IgdGhlIENMSSBmbG93IGFu" + - "ZCBtdXN0IG5vdCBiZSBoYW5kLWF1dGhvcmVkLgpUaGUgSGVsbWZpbGUgZmxvdyBkb2VzIG5vdCBj" + - "b25zdW1lIGEgY29udHJvbC1wbGFuZSBwcm9maWxlLgoKQ29tbWFuZHMgYmVsb3cgdXNlIG1vbm9y" + - "ZXBvIHBhdGhzIGZyb20gdGhlIHJlcG9zaXRvcnkgcm9vdC4gT3BlcmF0b3JzIHVzaW5nCmV4dHJh" + - "Y3RlZCBwYWNrYWdlcyBuZWVkIG1hdGNoaW5nLXZlcnNpb24gYG52Y2Ytc2VsZi1tYW5hZ2VkLXN0" + - "YWNrYCBhbmQKYG52Y2YtY29tcHV0ZS1wbGFuZS1zdGFja2AgYnVuZGxlcy4gU3Vic3RpdHV0ZSB0" + - "aG9zZSBidW5kbGUgcm9vdHMgZm9yCmBkZXBsb3kvc3RhY2tzL3NlbGYtbWFuYWdlZGAgYW5kIGBk" + - "ZXBsb3kvc3RhY2tzL252Y2YtY29tcHV0ZS1wbGFuZWAuCgojIyBIZWxtZmlsZSBWYWx1ZXMgRmxv" + - "dwoKQ3JlYXRlIGJvdGggZW52aXJvbm1lbnQgZmlsZXMgYmVmb3JlIGluc3RhbGxhdGlvbjoKCi0g" + - "YGRlcGxveS9zdGFja3Mvc2VsZi1tYW5hZ2VkL2Vudmlyb25tZW50cy88ZW52Pi55YW1sYCBmb3Ig" + - "Y29udHJvbC1wbGFuZQogIHJlZ2lzdHJ5LCBkb21haW4sIEdhdGV3YXksIHJvdXRlcywgYW5kIHNl" + - "cnZpY2Ugc2V0dGluZ3MuCi0gYGRlcGxveS9zdGFja3MvbnZjZi1jb21wdXRlLXBsYW5lL2Vudmly" + - "b25tZW50cy88ZW52Pi55YW1sYCBmb3IgY29tcHV0ZS1wbGFuZQogIHJlZ2lzdHJ5LCBwdWxsIHNl" + - "Y3JldHMsIGFuZCBjb21wdXRlLXJlYWNoYWJsZSBJQ01TLCBSZVZhbCwgYW5kIE5BVFMgdmFsdWVz" + - "LgoKRm9yIEVLUywgdXNlIHRoZSBjYW5vbmljYWwKW0NTUCBFbmQtdG8tRW5kIEV4YW1wbGVdKGh0" + - "dHBzOi8vZG9jcy5udmlkaWEuY29tL252Y2YvdjAuNi4wLXJjL2NzcC1lbmQtdG8tZW5kLWV4YW1w" + - "bGUpLgpUaGUgY29udHJvbC1wbGFuZSBlbnZpcm9ubWVudCBrZWVwcyB0aGUgRW52b3kgR2F0ZXdh" + - "eSBjb250cm9sbGVyIGluCmBlbnZveS1nYXRld2F5LXN5c3RlbWAsIGF0dGFjaGVzIHJvdXRlcyB0" + - "byBgR2F0ZXdheS9udmNmLWdhdGV3YXlgIGluCmBlbnZveS1nYXRld2F5YCwgYW5kIGVuYWJsZXMg" + - "dGhlIE5BVFMgcm91dGUuIFRoZSBjb21wdXRlLXBsYW5lIGVudmlyb25tZW50IHVzZXMKdGhlIGV4" + - "dGVybmFsIGFkZHJlc3MgcGx1cyB0aGUgc2VydmljZSBob3N0IG92ZXJyaWRlcy4gSGVyZSwKYDxn" + - "YXRld2F5LWFkZHJlc3M+YCBpcyB0aGUgTkxCIGFkZHJlc3MgYW5kIGA8Z2F0ZXdheS1kb21haW4+" + - "YCBpcyB0aGUgRE5TIGJhc2UKd2hvc2Ugc2VydmljZSBzdWJkb21haW5zIHJlc29sdmUgdG8gdGhh" + - "dCBOTEI6CgpgYGB5YW1sCiMgZGVwbG95L3N0YWNrcy9zZWxmLW1hbmFnZWQvZW52aXJvbm1lbnRz" + - "LzxlbnY+LnlhbWwKZ2xvYmFsOgogIGRvbWFpbjogIjxnYXRld2F5LWRvbWFpbj4iCiAgd29ya2Vy" + - "RW5kcG9pbnRzOgogICAgbnZjZlNlcnZpY2VVUkw6ICJodHRwOi8vYXBpLjxnYXRld2F5LWRvbWFp" + - "bj4iCiAgICBudmNmR3JwY1NlcnZpY2VVUkw6ICJodHRwOi8vd29ya2VyLWFwaS48Z2F0ZXdheS1k" + - "b21haW4+IgogICAgbnZjZk5hdHNTZXJ2aWNlVVJMOiAibmF0czovLzxnYXRld2F5LWFkZHJlc3M+" + - "OjQyMjIiCiAgICBudmN0U2VydmljZVVSTDogImh0dHA6Ly90YXNrcy48Z2F0ZXdheS1kb21haW4+" + - "IgogICAgbnZjdEdycGNTZXJ2aWNlVVJMOiAiaHR0cDovL3dvcmtlci10YXNrcy48Z2F0ZXdheS1k" + - "b21haW4+IgogICAgaW52b2NhdGlvblNlcnZpY2VVUkw6ICJodHRwOi8vaW52b2NhdGlvbi48Z2F0" + - "ZXdheS1kb21haW4+IgoKZ3JwY3Byb3h5OgogIG52Y2ZHcnBjU2VydmljZVVSTDogImh0dHA6Ly9h" + - "cGkubnZjZi5zdmMuY2x1c3Rlci5sb2NhbDo5MDkwIgoKaW5ncmVzczoKICBnYXRld2F5QXBpOgog" + - "ICAgY29udHJvbGxlck5hbWVzcGFjZTogZW52b3ktZ2F0ZXdheS1zeXN0ZW0KICAgIGdhdGV3YXlz" + - "OgogICAgICBzaGFyZWQ6IHtuYW1lOiBudmNmLWdhdGV3YXksIG5hbWVzcGFjZTogZW52b3ktZ2F0" + - "ZXdheX0KICAgICAgZ3JwYzoge25hbWU6IG52Y2YtZ2F0ZXdheSwgbmFtZXNwYWNlOiBlbnZveS1n" + - "YXRld2F5fQogICAgICBuYXRzOgogICAgICAgIG5hbWU6IG52Y2YtZ2F0ZXdheQogICAgICAgIG5h" + - "bWVzcGFjZTogZW52b3ktZ2F0ZXdheQogICAgICAgIGxpc3RlbmVyTmFtZTogbmF0cwogICAgcm91" + - "dGVzOgogICAgICBudmNmQXBpOgogICAgICAgIGdycGM6CiAgICAgICAgICBlbmFibGVkOiB0cnVl" + - "CiAgICAgICAgICBob3N0bmFtZXM6IFsid29ya2VyLWFwaS48Z2F0ZXdheS1kb21haW4+Il0KICAg" + - "ICAgbnZjdEFwaToKICAgICAgICBncnBjOgogICAgICAgICAgZW5hYmxlZDogdHJ1ZQogICAgICAg" + - "ICAgaG9zdG5hbWVzOiBbIndvcmtlci10YXNrcy48Z2F0ZXdheS1kb21haW4+Il0KICAgICAgbmF0" + - "czoKICAgICAgICBlbmFibGVkOiB0cnVlCgpvcGVuYmFvOgogIG1pZ3JhdGlvbnM6CiAgICBpc3N1" + - "ZXJEaXNjb3Zlcnk6CiAgICAgIGVuYWJsZWQ6IHRydWUKYGBgCgpgYGB5YW1sCiMgZGVwbG95L3N0" + - "YWNrcy9udmNmLWNvbXB1dGUtcGxhbmUvZW52aXJvbm1lbnRzLzxlbnY+LnlhbWwKZ2xvYmFsOgog" + - "IG52Y2FPcGVyYXRvcjoKICAgIHNlbGZNYW5hZ2VkOgogICAgICBpY21zU2VydmljZVVSTDogImh0" + - "dHA6Ly88Z2F0ZXdheS1hZGRyZXNzPiIKICAgICAgaWNtc1NlcnZpY2VIb3N0SGVhZGVyT3ZlcnJp" + - "ZGU6ICJzaXMuPGdhdGV3YXktZG9tYWluPiIKICAgICAgcmV2YWxTZXJ2aWNlVVJMOiAiaHR0cDov" + - "LzxnYXRld2F5LWFkZHJlc3M+IgogICAgICByZXZhbFNlcnZpY2VIb3N0SGVhZGVyT3ZlcnJpZGU6" + - "ICJyZXZhbC48Z2F0ZXdheS1kb21haW4+IgogICAgICBuYXRzVVJMOiAibmF0czovLzxnYXRld2F5" + - "LWFkZHJlc3M+OjQyMjIiCiAgICAgIG5hdHNIb3N0T3ZlcnJpZGU6ICJuYXRzLjxnYXRld2F5LWRv" + - "bWFpbj4iCmBgYAoKUHJldmlldyBhbmQgaW5zdGFsbCB0aGUgY29udHJvbCBwbGFuZSBhZ2FpbnN0" + - "IGl0cyBjb250ZXh0OgoKYGBgYmFzaAptYWtlIC1DIGRlcGxveS9zdGFja3Mvc2VsZi1tYW5hZ2Vk" + - "IHRlbXBsYXRlIFwKICBIRUxNRklMRV9FTlY9PGVudj4gXAogIEtVQkVDT05GSUdfRklMRT08Y29u" + - "dHJvbC1wbGFuZS1rdWJlY29uZmlnPgoKbWFrZSAtQyBkZXBsb3kvc3RhY2tzL3NlbGYtbWFuYWdl" + - "ZCBpbnN0YWxsIFwKICBIRUxNRklMRV9FTlY9PGVudj4gXAogIEtVQkVDT05GSUdfRklMRT08Y29u" + - "dHJvbC1wbGFuZS1rdWJlY29uZmlnPgpgYGAKCkJlZm9yZSByZWdpc3RlcmluZyB0aHJvdWdoIGEg" + - "YmFyZSBHYXRld2F5IGFkZHJlc3MsIGNyZWF0ZSBvciB1cGRhdGUgdGhlIENMSQpjb25maWcgcGFz" + - "c2VkIGFzIGBOVkNGX0NMSV9DT05GSUdgOgoKYGBgeWFtbApiYXNlX2h0dHBfdXJsOiAiaHR0cDov" + - "LzxnYXRld2F5LWFkZHJlc3M+IgppbnZva2VfdXJsOiAiaHR0cDovLzxnYXRld2F5LWFkZHJlc3M+" + - "IgpiYXNlX2dycGNfdXJsOiAiPGdhdGV3YXktYWRkcmVzcz46MTAwODEiCmFwaV9rZXlzX3NlcnZp" + - "Y2VfdXJsOiAiaHR0cDovLzxnYXRld2F5LWFkZHJlc3M+IgppY21zX3VybDogImh0dHA6Ly88Z2F0" + - "ZXdheS1hZGRyZXNzPiIKYXBpX2hvc3Q6ICJhcGkuPGdhdGV3YXktZG9tYWluPiIKYXBpX2tleXNf" + - "aG9zdDogImFwaS1rZXlzLjxnYXRld2F5LWRvbWFpbj4iCmludm9rZV9ob3N0OiAiaW52b2NhdGlv" + - "bi48Z2F0ZXdheS1kb21haW4+IgppY21zX2hvc3Q6ICJzaXMuPGdhdGV3YXktZG9tYWluPiIKYGBg" + - "CgpIb3N0IGZpZWxkcyBjb250YWluIGhvc3RuYW1lcyBvbmx5LCB3aXRob3V0IGEgVVJMIHNjaGVt" + - "ZS4gYElDTVNfVVJMYCBtYXBzIG9ubHkKdG8gdGhlIHJlZ2lzdHJhdGlvbiBjb21tYW5kJ3MgYC0t" + - "aWNtcy11cmxgOyBgaWNtc19ob3N0YCBpbiB0aGUgY29uZmlnIHN1cHBsaWVzCnRoZSBHYXRld2F5" + - "IEhvc3QgaGVhZGVyLiBUaGVyZSBpcyBubyBgLS1pY21zLWhvc3RgIE1ha2Ugb3IgQ0xJIGZsYWcu" + - "CgpSZWdpc3RlciBmcm9tIHRoZSBjb21wdXRlIGNvbnRleHQsIHRoZW4gaW5zdGFsbCB0aGUgY29t" + - "cHV0ZSBwbGFuZToKCmBgYGJhc2gKbWFrZSAtQyBkZXBsb3kvc3RhY2tzL252Y2YtY29tcHV0ZS1w" + - "bGFuZSByZWdpc3Rlci1jbHVzdGVyIFwKICBDTFVTVEVSX05BTUU9PGNsdXN0ZXItbmFtZT4gXAog" + - "IE5DQV9JRD08bmNhLWlkPiBcCiAgQ0xVU1RFUl9SRUdJT049PHJlZ2lvbj4gXAogIElDTVNfVVJM" + - "PWh0dHA6Ly88Z2F0ZXdheS1hZGRyZXNzPiBcCiAgS1VCRUNPTkZJR19GSUxFPTxjb21wdXRlLXBs" + - "YW5lLWt1YmVjb25maWc+IFwKICBOVkNGX0NMST08cGF0aC10by1udmNmLWNsaT4gXAogIE5WQ0Zf" + - "Q0xJX0NPTkZJRz08cGF0aC10by1udmNmLWNsaS1jb25maWc+CgptYWtlIC1DIGRlcGxveS9zdGFj" + - "a3MvbnZjZi1jb21wdXRlLXBsYW5lIGluc3RhbGwgXAogIENMVVNURVJfTkFNRT08Y2x1c3Rlci1u" + - "YW1lPiBcCiAgSEVMTUZJTEVfRU5WPTxlbnY+IFwKICBLVUJFQ09ORklHX0ZJTEU9PGNvbXB1dGUt" + - "cGxhbmUta3ViZWNvbmZpZz4KYGBgCgpSZWdpc3RyYXRpb24gZGlzY292ZXJzIHRoZSBPSURDIGlz" + - "c3VlciBhbmQgSldLUyBmcm9tIHRoZSBjb21wdXRlIGt1YmUgY29udGV4dC4KSW4gYSBtdWx0aS1j" + - "bHVzdGVyIGRlcGxveW1lbnQsIGBLVUJFQ09ORklHX0ZJTEVgIGlzIHJlcXVpcmVkIG9uIGJvdGgK" + - "Y29tcHV0ZS1wbGFuZSBjb21tYW5kcy4gSW4gYSBzYW1lLWNsdXN0ZXIgZGVwbG95bWVudCBpdCBt" + - "YXkgYmUgb21pdHRlZCBvbmx5CndoZW4gdGhlIGFtYmllbnQgY29udGV4dCBpcyBhbHJlYWR5IHRo" + - "ZSB0YXJnZXQgY2x1c3Rlci4KCiMjIENMSSBQcm9maWxlIEZsb3cKClJ1biB0aGUgQ0xJIGNvbnRy" + - "b2wtcGxhbmUgaW5zdGFsbCBmaXJzdC4gSXQgY3JlYXRlcyB0aGUgcHJvZmlsZSBjb25zdW1lZCBi" + - "eQpjb21wdXRlLXBsYW5lIHJlZ2lzdHJhdGlvbjoKCmBgYGJhc2gKbnZjZi1jbGkgLS1jb25maWcg" + - "PGNvbmZpZz4gc2VsZi1ob3N0ZWQgXAogIC0tY29udHJvbC1wbGFuZS1zdGFjayBkZXBsb3kvc3Rh" + - "Y2tzL3NlbGYtbWFuYWdlZCBcCiAgLS1jb21wdXRlLXBsYW5lLXN0YWNrIGRlcGxveS9zdGFja3Mv" + - "bnZjZi1jb21wdXRlLXBsYW5lIFwKICAtLWVudiA8ZW52PiBcCiAgLS1wbGFpbiBcCiAgLS1jb250" + - "cm9sLXBsYW5lLWNvbnRleHQgPGNvbnRyb2wtcGxhbmUtY29udGV4dD4gXAogIC0tY29tcHV0ZS1w" + - "bGFuZS1jb250ZXh0IDxjb21wdXRlLXBsYW5lLWNvbnRleHQ+IFwKICBpbnN0YWxsIC0tY29udHJv" + - "bC1wbGFuZSBcCiAgLS1jbHVzdGVyLW5hbWUgPGNvbnRyb2wtcGxhbmUtY2x1c3Rlci1uYW1lPiBc" + - "CiAgLS1yZWdpb24gPHJlZ2lvbj4gXAogIC0tbmNhLWlkIDxuY2EtaWQ+Cgp0ZXN0IC1zIGRlcGxv" + - "eS9zdGFja3Mvc2VsZi1tYW5hZ2VkL291dC9jb250cm9sLXBsYW5lLXByb2ZpbGUueWFtbApgYGAK" + - "ClVzZSB0aGUgZnVsbCBwZXJzaXN0ZW50IHByZWZpeCBmb3IgYm90aCBjb21wdXRlLXBsYW5lIGNv" + - "bW1hbmRzOgoKYGBgYmFzaApudmNmLWNsaSAtLWNvbmZpZyA8Y29uZmlnPiBzZWxmLWhvc3RlZCBc" + - "CiAgLS1jb250cm9sLXBsYW5lLXN0YWNrIGRlcGxveS9zdGFja3Mvc2VsZi1tYW5hZ2VkIFwKICAt" + - "LWNvbXB1dGUtcGxhbmUtc3RhY2sgZGVwbG95L3N0YWNrcy9udmNmLWNvbXB1dGUtcGxhbmUgXAog" + - "IC0tZW52IDxlbnY+IFwKICAtLXBsYWluIFwKICBjb21wdXRlLXBsYW5lIHJlZ2lzdGVyIFwKICAt" + - "LWNvbnRyb2wtcGxhbmUtcHJvZmlsZSBkZXBsb3kvc3RhY2tzL3NlbGYtbWFuYWdlZC9vdXQvY29u" + - "dHJvbC1wbGFuZS1wcm9maWxlLnlhbWwgXAogIC0tY2x1c3Rlci1uYW1lIDxjb21wdXRlLXBsYW5l" + - "LWNsdXN0ZXItbmFtZT4gXAogIC0ta3ViZS1jb250ZXh0IDxjb21wdXRlLXBsYW5lLWNvbnRleHQ+" + - "IFwKICAtLXJlZ2lvbiA8cmVnaW9uPiBcCiAgLS1vdXRwdXQgZGVwbG95L3N0YWNrcy9udmNmLWNv" + - "bXB1dGUtcGxhbmUvb3V0Lzxjb21wdXRlLXBsYW5lLWNsdXN0ZXItbmFtZT4tcmVnaXN0ZXItdmFs" + - "dWVzLnlhbWwKCm52Y2YtY2xpIC0tY29uZmlnIDxjb25maWc+IHNlbGYtaG9zdGVkIFwKICAtLWNv" + - "bnRyb2wtcGxhbmUtc3RhY2sgZGVwbG95L3N0YWNrcy9zZWxmLW1hbmFnZWQgXAogIC0tY29tcHV0" + - "ZS1wbGFuZS1zdGFjayBkZXBsb3kvc3RhY2tzL252Y2YtY29tcHV0ZS1wbGFuZSBcCiAgLS1lbnYg" + - "PGVudj4gXAogIC0tcGxhaW4gXAogIGNvbXB1dGUtcGxhbmUgaW5zdGFsbCBcCiAgLS12YWx1ZXMg" + - "ZGVwbG95L3N0YWNrcy9udmNmLWNvbXB1dGUtcGxhbmUvb3V0Lzxjb21wdXRlLXBsYW5lLWNsdXN0" + - "ZXItbmFtZT4tcmVnaXN0ZXItdmFsdWVzLnlhbWwgXAogIC0ta3ViZS1jb250ZXh0IDxjb21wdXRl" + - "LXBsYW5lLWNvbnRleHQ+IFwKICAtLWNsdXN0ZXItbmFtZSA8Y29tcHV0ZS1wbGFuZS1jbHVzdGVy" + - "LW5hbWU+CmBgYAoKUmVnaXN0cmF0aW9uIHNlbGVjdHMgdGhlIHByb2ZpbGUncyBpbi1jbHVzdGVy" + - "IG9yIGNvbXB1dGUtcmVhY2hhYmxlIGVuZHBvaW50cwpmcm9tIHRoZSBjb21wdXRlIGNvbnRleHQg" + - "YW5kIHByb2JlcyBpdHMgSldLUy4gRG8gbm90IHJlcGxhY2UgcHJvZmlsZSBlbmRwb2ludHMKd2l0" + - "aCBoYW5kLWF1dGhvcmVkIEhlbG1maWxlIGVuZHBvaW50IHZhbHVlcy4KCiMjIFB1bGwgU2VjcmV0" + - "cwoKQ3JlYXRlIHRoZSBjb250cm9sLXBsYW5lIHNlY3JldCBpbiB0aGVzZSBuYW1lc3BhY2VzIG9u" + - "IHRoZSBjb250cm9sLXBsYW5lCmNvbnRleHQ6CgpgYGB0ZXh0CmNhc3NhbmRyYS1zeXN0ZW0gbmF0" + - "cy1zeXN0ZW0gbnZjZiBhcGkta2V5cyBlc3Mgc2lzIHZhdWx0LXN5c3RlbSBjZXJ0LW1hbmFnZXIK" + - "YGBgCgpPbiB0aGUgY29tcHV0ZSBjb250ZXh0LCBjcmVhdGUgdGhlIHNlY3JldCBvbmx5IGluIGBu" + - "dmNhLW9wZXJhdG9yYCBhbmQgcmVmZXJlbmNlCml0IHRocm91Z2ggYGdsb2JhbC5pbWFnZVB1bGxT" + - "ZWNyZXRzYCBpbiB0aGUgY29tcHV0ZS1wbGFuZSBlbnZpcm9ubWVudC4gVGhlIGNoYXJ0CmFuZCBv" + - "cGVyYXRvciB1c2UgaXQgaW4gYG52Y2Etb3BlcmF0b3JgIGFuZCBtaXJyb3IgaXQgdG8gYG52Y2Et" + - "c3lzdGVtYC4gRG8gbm90IGFkZAplaXRoZXIgbmFtZXNwYWNlIHRvIHRoZSBjb250cm9sLXBsYW5l" + - "IGxpc3QuIEZvciBjb21tYW5kcyBhbmQgcG9saWN5IGV4YW1wbGVzLApzZWUgW3B1bGwtc2VjcmV0" + - "cy5tZF0ocHVsbC1zZWNyZXRzLm1kKS4KCiMjIFZlcmlmaWNhdGlvbgoKVXNlIHRoZSBleHBsaWNp" + - "dCBHYXRld2F5IG5hbWUgYW5kIG5hbWVzcGFjZToKCmBgYGJhc2gKa3ViZWN0bCAtLWNvbnRleHQg" + - "PGNvbnRyb2wtcGxhbmUtY29udGV4dD4gZ2V0IGdhdGV3YXkgbnZjZi1nYXRld2F5IFwKICAtbiBl" + - "bnZveS1nYXRld2F5IC1vIHdpZGUKa3ViZWN0bCAtLWNvbnRleHQgPGNvbnRyb2wtcGxhbmUtY29u" + - "dGV4dD4gZ2V0IHRjcHJvdXRlIC1uIGVudm95LWdhdGV3YXkKa3ViZWN0bCAtLWNvbnRleHQgPGNv" + - "bXB1dGUtcGxhbmUtY29udGV4dD4gcm9sbG91dCBzdGF0dXMgXAogIGRlcGxveW1lbnQvbnZjYS1v" + - "cGVyYXRvciAtbiBudmNhLW9wZXJhdG9yIC0tdGltZW91dD0xMG0Ka3ViZWN0bCAtLWNvbnRleHQg" + - "PGNvbXB1dGUtcGxhbmUtY29udGV4dD4gd2FpdCBcCiAgbnZjZmJhY2tlbmQvPGNvbXB1dGUtcGxh" + - "bmUtY2x1c3Rlci1uYW1lPiAtbiBudmNhLW9wZXJhdG9yIFwKICAtLWZvcj1qc29ucGF0aD0ney5z" + - "dGF0dXMuYWdlbnRTdGF0dXN9Jz1oZWFsdGh5IC0tdGltZW91dD0xMG0Ka3ViZWN0bCAtLWNvbnRl" + - "eHQgPGNvbXB1dGUtcGxhbmUtY29udGV4dD4gZ2V0IHNlY3JldCA8cHVsbC1zZWNyZXQ+IC1uIG52" + - "Y2Etc3lzdGVtCmBgYAoKIyMgVGVhcmRvd24KCkRlc3Ryb3kgYW5kIGRlcmVnaXN0ZXIgZXZlcnkg" + - "Y29tcHV0ZSBwbGFuZSBiZWZvcmUgdGhlIGNvbnRyb2wgcGxhbmUuIEJvdGgKaGFuZG9mZnMgY2Fu" + - "IGRlc3Ryb3kgdGhlIGNvbnRyb2wgcGxhbmUsIHNvIGFwcGx5IHRoaXMgcHJlZmxpZ2h0IGJlZm9y" + - "ZSBlaXRoZXIKb25lLiBQcmVzZXJ2ZSB0aGUgYGNlcnQtbWFuYWdlcmAgbmFtZXNwYWNlIGJ5IGRl" + - "ZmF1bHQuIE5hbWVzcGFjZSBwcmVzZXJ2YXRpb24KZG9lcyBub3QgcHJlc2VydmUgdGhlIEhlbG0g" + - "cmVsZWFzZS4gSWRlbnRpZnkgd2hldGhlciBjZXJ0LW1hbmFnZXIgaXMgZXh0ZXJuYWwuCkZvciBh" + - "biBleHRlcm5hbCBpbnN0YWxsYXRpb24sIHJlcXVpcmUgZWZmZWN0aXZlIGBjZXJ0TWFuYWdlci5l" + - "bmFibGVkOiBmYWxzZWAKYW5kIGFib3J0IGlmIGl0IGlzIHRydWUuIEZvciBhbiBpbnRlbmRlZCBz" + - "dGFjay1tYW5hZ2VkIHJlbGVhc2Ugd2l0aCBlZmZlY3RpdmUKYGNlcnRNYW5hZ2VyLmVuYWJsZWQ6" + - "IHRydWVgLCB2ZXJpZnkgbWF0Y2hpbmcgc3RhY2sgSGVsbSByZWxlYXNlIG1ldGFkYXRhIGFuZAph" + - "Ym9ydCBvbiBtaXNzaW5nIG9yIG1pc21hdGNoZWQgZXZpZGVuY2UuIE9ubHkgcGxhbiBuYW1lc3Bh" + - "Y2UgcmVtb3ZhbCBhZnRlcgp2ZXJpZnlpbmcgbmFtZXNwYWNlIHByb3ZlbmFuY2UgYW5kIGdldHRp" + - "bmcgZXhwbGljaXQgY29uZmlybWF0aW9uOyBvdGhlcndpc2UKZG8gbm90IGRlbGV0ZSBpdC4KCkZv" + - "ciB0aGUgSGVsbWZpbGUgdmFsdWVzIGZsb3csIHJldGFpbiBlYWNoIHJlZ2lzdHJhdGlvbiB2YWx1" + - "ZXMgZmlsZSB1bnRpbApjbGVhbnVwIGlzIHZlcmlmaWVkOgoKYGBgYmFzaAptYWtlIC1DIGRlcGxv" + - "eS9zdGFja3MvbnZjZi1jb21wdXRlLXBsYW5lIGRlc3Ryb3kgXAogIENMVVNURVJfTkFNRT08Y2x1" + - "c3Rlci1uYW1lPiBcCiAgSEVMTUZJTEVfRU5WPTxlbnY+IFwKICBLVUJFQ09ORklHX0ZJTEU9PGNv" + - "bXB1dGUtcGxhbmUta3ViZWNvbmZpZz4KCjxudmNmLWNsaT4gLS1jb25maWcgPGNvbmZpZz4gY2x1" + - "c3RlciBkZWxldGUgXAogIC0tY2x1c3Rlci1pZCA8Y2x1c3Rlci1pZC1mcm9tLXJlZ2lzdHJhdGlv" + - "bi12YWx1ZXM+IFwKICAtLW5jYS1pZCA8bmNhLWlkPiBcCiAgLS1pZ25vcmUtbWlzc2luZwpgYGAK" + - "ClJlYWQgYGNsdXN0ZXJJRGAgYW5kIGBuY2FJRGAgZnJvbQpgZGVwbG95L3N0YWNrcy9udmNmLWNv" + - "bXB1dGUtcGxhbmUvcmVnaXN0cmF0aW9uLzxjbHVzdGVyLW5hbWU+LXJlZ2lzdGVyLXZhbHVlcy55" + - "YW1sYC4KU2hvdyB0aGUgZXhhY3QgY2x1c3RlciBJRCBhbmQgZ2V0IGNvbmZpcm1hdGlvbiBiZWZv" + - "cmUgYGNsdXN0ZXIgZGVsZXRlYC4gUmVwZWF0CmNvbXB1dGUgZGVzdHJveSBhbmQgZGVyZWdpc3Ry" + - "YXRpb24gZm9yIGV2ZXJ5IGNvbXB1dGUgY2x1c3RlciwgdGhlbiBkZXN0cm95IHRoZQpjb250cm9s" + - "IHBsYW5lLgoKYGBgYmFzaApLVUJFQ09ORklHPTxjb250cm9sLXBsYW5lLWt1YmVjb25maWc+IFwK" + - "bWFrZSAtQyBkZXBsb3kvc3RhY2tzL3NlbGYtbWFuYWdlZCBkZXN0cm95IFwKICBIRUxNRklMRV9F" + - "TlY9PGVudj4gXAogIEtVQkVDT05GSUdfRklMRT08Y29udHJvbC1wbGFuZS1rdWJlY29uZmlnPgpg" + - "YGAKCkJvdGggYEtVQkVDT05GSUdgIGFuZCBgS1VCRUNPTkZJR19GSUxFYCBhcmUgcmVxdWlyZWQg" + - "b24gdGhlIGNvbnRyb2wtcGxhbmUKZGVzdHJveSBiZWNhdXNlIGl0cyBuYW1lc3BhY2UgY2xlYW51" + - "cCB1c2VzIGFtYmllbnQgYGt1YmVjdGxgLgoKRm9yIHRoZSBDTEkgcHJvZmlsZSBmbG93LCBrZWVw" + - "CmBkZXBsb3kvc3RhY2tzL252Y2YtY29tcHV0ZS1wbGFuZS9vdXQvPGNsdXN0ZXItbmFtZT4tcmVn" + - "aXN0ZXItdmFsdWVzLnlhbWxgCnVudGlsIHRlYXJkb3duIGNvbXBsZXRlcyBiZWNhdXNlIGBkb3du" + - "YCByZWFkcyBpdHMgY2x1c3RlciBJRC4gRmlyc3QgcXVlcnkgdGhlCmxpdmUgcmVnaXN0cmF0aW9u" + - "IHNldCB3aXRoIHRoZSBzYW1lIGNvbXBsZXRlIHBlcnNpc3RlbnQgcHJlZml4OgoKYGBgYmFzaApu" + - "dmNmLWNsaSAtLWNvbmZpZyA8Y29uZmlnPiBzZWxmLWhvc3RlZCBcCiAgLS1jb250cm9sLXBsYW5l" + - "LXN0YWNrIGRlcGxveS9zdGFja3Mvc2VsZi1tYW5hZ2VkIFwKICAtLWNvbXB1dGUtcGxhbmUtc3Rh" + - "Y2sgZGVwbG95L3N0YWNrcy9udmNmLWNvbXB1dGUtcGxhbmUgXAogIC0tZW52IDxlbnY+IFwKICAt" + - "LXBsYWluIFwKICAtLWNvbnRyb2wtcGxhbmUtY29udGV4dCA8Y29udHJvbC1wbGFuZS1jb250ZXh0" + - "PiBcCiAgLS1jb21wdXRlLXBsYW5lLWNvbnRleHQgPGNvbXB1dGUtcGxhbmUtY29udGV4dD4gXAog" + - "IC0taWNtcy11cmwgPGNvbXB1dGUtcmVhY2hhYmxlLWljbXMtdXJsPiBcCiAgc3RhdHVzIFwKICAt" + - "LWNsdXN0ZXItbmFtZSA8Y29tcHV0ZS1wbGFuZS1jbHVzdGVyLW5hbWU+IFwKICAtLW5jYS1pZCA8" + - "bmNhLWlkPgpgYGAKClNob3cgdGhlIHJlZ2lzdGVyZWQgY29tcHV0ZS1wbGFuZSBsaXN0LiBOYW1l" + - "ZC1jbHVzdGVyIGBkb3duIC0tcGxhbi1vbmx5YCBkb2VzCm5vdCBxdWVyeSBJQ01TLCBzbyBpdCBw" + - "cmV2aWV3cyBvbmx5IHRoYXQgY29tcHV0ZSBwbGFuZSBhbmQgY2Fubm90IHNob3cgdGhlCmNvbmRp" + - "dGlvbmFsIGNvbnRyb2wtcGxhbmUgcmVtb3ZhbC4gSWYgdGhlIHRhcmdldCBpcyB0aGUgbGFzdCBy" + - "ZWdpc3RlcmVkCmNsdXN0ZXIsIHJlYWwgYGRvd25gIGFsc28gZGVzdHJveXMgdGhlIGNvbnRyb2wg" + - "cGxhbmUuIEdldCBleHBsaWNpdCBjb25maXJtYXRpb24KZm9yIGJvdGggcmVtb3ZhbHMgYmVmb3Jl" + - "IGNvbnRpbnVpbmcuIFRoZW4gcHJldmlldyBhbmQgZXhlY3V0ZSB3aXRoIHRoZSBzYW1lCnByZWZp" + - "eDoKCmBgYGJhc2gKbnZjZi1jbGkgLS1jb25maWcgPGNvbmZpZz4gc2VsZi1ob3N0ZWQgXAogIC0t" + - "Y29udHJvbC1wbGFuZS1zdGFjayBkZXBsb3kvc3RhY2tzL3NlbGYtbWFuYWdlZCBcCiAgLS1jb21w" + - "dXRlLXBsYW5lLXN0YWNrIGRlcGxveS9zdGFja3MvbnZjZi1jb21wdXRlLXBsYW5lIFwKICAtLWVu" + - "diA8ZW52PiBcCiAgLS1wbGFpbiBcCiAgLS1jb250cm9sLXBsYW5lLWNvbnRleHQgPGNvbnRyb2wt" + - "cGxhbmUtY29udGV4dD4gXAogIC0tY29tcHV0ZS1wbGFuZS1jb250ZXh0IDxjb21wdXRlLXBsYW5l" + - "LWNvbnRleHQ+IFwKICAtLWljbXMtdXJsIDxjb21wdXRlLXJlYWNoYWJsZS1pY21zLXVybD4gXAog" + - "IGRvd24gLS1wbGFuLW9ubHkgXAogIC0tY2x1c3Rlci1uYW1lIDxjb21wdXRlLXBsYW5lLWNsdXN0" + - "ZXItbmFtZT4gXAogIC0tbmNhLWlkIDxuY2EtaWQ+CgpudmNmLWNsaSAtLWNvbmZpZyA8Y29uZmln" + - "PiBzZWxmLWhvc3RlZCBcCiAgLS1jb250cm9sLXBsYW5lLXN0YWNrIGRlcGxveS9zdGFja3Mvc2Vs" + - "Zi1tYW5hZ2VkIFwKICAtLWNvbXB1dGUtcGxhbmUtc3RhY2sgZGVwbG95L3N0YWNrcy9udmNmLWNv" + - "bXB1dGUtcGxhbmUgXAogIC0tZW52IDxlbnY+IFwKICAtLXBsYWluIFwKICAtLWNvbnRyb2wtcGxh" + - "bmUtY29udGV4dCA8Y29udHJvbC1wbGFuZS1jb250ZXh0PiBcCiAgLS1jb21wdXRlLXBsYW5lLWNv" + - "bnRleHQgPGNvbXB1dGUtcGxhbmUtY29udGV4dD4gXAogIC0taWNtcy11cmwgPGNvbXB1dGUtcmVh" + - "Y2hhYmxlLWljbXMtdXJsPiBcCiAgZG93biBcCiAgLS1jbHVzdGVyLW5hbWUgPGNvbXB1dGUtcGxh" + - "bmUtY2x1c3Rlci1uYW1lPiBcCiAgLS1uY2EtaWQgPG5jYS1pZD4KYGBgCgpSZXBlYXQgYGRvd25g" + - "IGZvciBlYWNoIGNvbXB1dGUgY2x1c3Rlci4gRWFjaCBydW4gZGVzdHJveXMgdGhhdCBjb21wdXRl" + - "IHBsYW5lIGFuZAp1bnJlZ2lzdGVycyBpdHMgSUNNUyByb3cuIEl0IHJlbW92ZXMgdGhlIGNvbnRy" + - "b2wgcGxhbmUgb25seSBhZnRlciBubyBjbHVzdGVyCnJlZ2lzdHJhdGlvbnMgcmVtYWluLgpQSwcI" + - "lmO8WRIwAAASMAAAUEsDBBQACAAAAAAAIQAAAAAAAAAAAAAAAAA7AAkAZGF0YS9udmNmLXNlbGYt" + - "bWFuYWdlZC1pbnN0YWxsYXRpb24vcmVmZXJlbmNlcy9kZWJ1Z2dpbmcubWRVVAUAAQCmzhIjIERl" + - "YnVnZ2luZyBSZWZlcmVuY2UKClJlY2lwZXMgZm9yIGRpYWdub3NpbmcgYW5kIGZpeGluZyBjb21t" + - "b24gTlZDRiBzZWxmLW1hbmFnZWQgc3RhY2sgZmFpbHVyZXMuCgojIyBRdWljayBTdGF0dXMgQ29t" + - "bWFuZHMKCmBgYGJhc2gKIyBBbGwgcG9kcyBhY3Jvc3MgYWxsIG5hbWVzcGFjZXMKa3ViZWN0bCBn" + - "ZXQgcG9kcyAtQSAtbyB3aWRlCgojIFBvZHMgaW4gYSBzcGVjaWZpYyBuYW1lc3BhY2UKa3ViZWN0" + - "bCBnZXQgcG9kcyAtbiA8bmFtZXNwYWNlPgoKIyBBbGwgaGVsbSByZWxlYXNlcwpoZWxtIGxpc3Qg" + - "LUEKCiMgUmVjZW50IGV2ZW50cyAobW9zdCB1c2VmdWwgZm9yIGRpYWdub3NpbmcgZmFpbHVyZXMp" + - "Cmt1YmVjdGwgZ2V0IGV2ZW50cyAtbiA8bmFtZXNwYWNlPiAtLXNvcnQtYnk9Jy5sYXN0VGltZXN0" + - "YW1wJwoKIyBEZXNjcmliZSBhIHNwZWNpZmljIHBvZCAoc2hvd3MgZXZlbnRzLCBjb25kaXRpb25z" + - "LCB2b2x1bWVzKQprdWJlY3RsIGRlc2NyaWJlIHBvZCAtbiA8bmFtZXNwYWNlPiA8cG9kLW5hbWU+" + - "CmBgYAoKIyMgRmFpbHVyZTogSW1hZ2VQdWxsQmFja09mZgoKIyMjIFN5bXB0b21zCgpgYGAKTkFN" + - "RSAgICAgICAgICAgUkVBRFkgICBTVEFUVVMgICAgICAgICAgICAgUkVTVEFSVFMgICBBR0UKY2Fz" + - "c2FuZHJhLTAgICAgMC8xICAgICBJbWFnZVB1bGxCYWNrT2ZmICAgMCAgICAgICAgICA1bQpgYGAK" + - "CkV2ZW50cyBzaG93OgpgYGAKRmFpbGVkIHRvIHB1bGwgaW1hZ2UgIm52Y3IuaW8vLi4uL2ltYWdl" + - "OnRhZyI6IDQwMSBVbmF1dGhvcml6ZWQKYGBgCgojIyMgRGlhZ25vc2lzCgpgYGBiYXNoCiMgQ2hl" + - "Y2sgd2hhdCBpbWFnZSBpcyBmYWlsaW5nCmt1YmVjdGwgZGVzY3JpYmUgcG9kIC1uIDxuYW1lc3Bh" + - "Y2U+IDxwb2QtbmFtZT4gfCBncmVwIC1BNSAiRXZlbnRzOiIKCiMgQ2hlY2sgaWYgcHVsbCBzZWNy" + - "ZXQgZXhpc3RzIGluIHRoZSBuYW1lc3BhY2UKa3ViZWN0bCBnZXQgc2VjcmV0IG52Y3ItY3JlZHMg" + - "LW4gPG5hbWVzcGFjZT4KCiMgQ2hlY2sgaWYgdGhlIHBvZCBzcGVjIGhhcyBpbWFnZVB1bGxTZWNy" + - "ZXRzCmt1YmVjdGwgZ2V0IHBvZCAtbiA8bmFtZXNwYWNlPiA8cG9kLW5hbWU+IC1vIGpzb25wYXRo" + - "PSd7LnNwZWMuaW1hZ2VQdWxsU2VjcmV0c30nCgojIENoZWNrIGlmIHRoZSBTZXJ2aWNlQWNjb3Vu" + - "dCBoYXMgaW1hZ2VQdWxsU2VjcmV0cwprdWJlY3RsIGdldCBzYSA8c2EtbmFtZT4gLW4gPG5hbWVz" + - "cGFjZT4gLW8ganNvbnBhdGg9J3suaW1hZ2VQdWxsU2VjcmV0c30nCmBgYAoKIyMjIEZpeGVzCgox" + - "LiAqKlNlY3JldCBtaXNzaW5nIGluIG5hbWVzcGFjZSoqOiBDcmVhdGUgaXQKICAgYGBgYmFzaAog" + - "ICBrdWJlY3RsIGNyZWF0ZSBzZWNyZXQgZG9ja2VyLXJlZ2lzdHJ5IG52Y3ItY3JlZHMgXAogICAg" + - "IC0tZG9ja2VyLXNlcnZlcj1udmNyLmlvIFwKICAgICAtLWRvY2tlci11c2VybmFtZT0nJG9hdXRo" + - "dG9rZW4nIFwKICAgICAtLWRvY2tlci1wYXNzd29yZD0iJE5HQ19BUElfS0VZIiBcCiAgICAgLS1u" + - "YW1lc3BhY2U9PG5hbWVzcGFjZT4gXAogICAgIC0tZHJ5LXJ1bj1jbGllbnQgLW8geWFtbCB8IGt1" + - "YmVjdGwgYXBwbHkgLWYgLQogICBgYGAKCjIuICoqU2VjcmV0IGV4aXN0cyBidXQgcG9kIGRvZXNu" + - "J3QgcmVmZXJlbmNlIGl0Kio6IFRoZSBjaGFydCBuZWVkcyBgaW1hZ2VQdWxsU2VjcmV0c2AgY29u" + - "ZmlndXJlZCB2aWEgaGVsbWZpbGUgdmFsdWVzLiBTZWUgW3B1bGwtc2VjcmV0cy5tZF0ocHVsbC1z" + - "ZWNyZXRzLm1kKS4KCjMuICoqQ2hhcnQgZG9lc24ndCBzdXBwb3J0IGltYWdlUHVsbFNlY3JldHMq" + - "KiAob3BlbmJhbywgaW52b2NhdGlvbi1zZXJ2aWNlLCBlc3MtYXBpLCBub3Rhcnktc2VydmljZSk6" + - "IFBhdGNoIFNlcnZpY2VBY2NvdW50cyBhbmQgcmVzdGFydCBwb2RzLiBTZWUgW3B1bGwtc2VjcmV0" + - "cy5tZF0ocHVsbC1zZWNyZXRzLm1kKS4KCjQuICoqV3JvbmcgY3JlZGVudGlhbHMgaW4gc2VjcmV0" + - "Kio6IERlbGV0ZSBhbmQgcmVjcmVhdGUKICAgYGBgYmFzaAogICBrdWJlY3RsIGRlbGV0ZSBzZWNy" + - "ZXQgbnZjci1jcmVkcyAtbiA8bmFtZXNwYWNlPgogICAjIFJlY3JlYXRlIHdpdGggY29ycmVjdCBj" + - "cmVkZW50aWFscwogICBgYGAKCiMjIEZhaWx1cmU6IEluaXQ6MC8xIFN0dWNrIChWYXVsdCBBZ2Vu" + - "dCkKCiMjIyBTeW1wdG9tcwoKU2VydmljZSBwb2RzIHN0dWNrIGluIGBJbml0OjAvMWAgZm9yIG1p" + - "bnV0ZXM6CmBgYApOQU1FICAgICAgICAgICAgICAgICAgICAgICAgUkVBRFkgICBTVEFUVVMgICAg" + - "IFJFU1RBUlRTICAgQUdFCm52Y2YtYXBpLTdmNGM3NmY3ODgtNDR2bHQgIDAvMiAgICAgSW5pdDow" + - "LzEgICAwICAgICAgICAgIDEwbQpgYGAKCiMjIyBEaWFnbm9zaXMKClRoZSBpbml0IGNvbnRhaW5l" + - "ciBpcyB0aGUgdmF1bHQtYWdlbnQtaW5pdCBpbmplY3RvciB3YWl0aW5nIGZvciBPcGVuQmFvLgoK" + - "YGBgYmFzaAojIENoZWNrIE9wZW5CYW8gcG9kcwprdWJlY3RsIGdldCBwb2RzIC1uIHZhdWx0LXN5" + - "c3RlbQoKIyBDaGVjayBpZiBPcGVuQmFvIG1pZ3JhdGlvbiBqb2IgcmFuCmt1YmVjdGwgZ2V0IGpv" + - "YnMgLW4gdmF1bHQtc3lzdGVtCgojIENoZWNrIE9wZW5CYW8gcG9kIGxvZ3MKa3ViZWN0bCBsb2dz" + - "IC1uIHZhdWx0LXN5c3RlbSBvcGVuYmFvLXNlcnZlci0wIC1jIG9wZW5iYW8KCiMgQ2hlY2sgaW5p" + - "dCBjb250YWluZXIgbG9ncyBvbiB0aGUgc3R1Y2sgcG9kCmt1YmVjdGwgbG9ncyAtbiA8bmFtZXNw" + - "YWNlPiA8cG9kLW5hbWU+IC1jIHZhdWx0LWFnZW50LWluaXQKYGBgCgojIyMgRml4ZXMKCjEuICoq" + - "T3BlbkJhbyBwb2RzIG5vdCBydW5uaW5nKio6IENoZWNrIHRoZWlyIGV2ZW50cyBmb3IgaW1hZ2Ug" + - "cHVsbCBpc3N1ZXMsIHJlc291cmNlIGlzc3VlcywgZXRjLgoKMi4gKipPcGVuQmFvIG1pZ3JhdGlv" + - "biBqb2IgZGlkbid0IHJ1bioqOiBUaGlzIGhhcHBlbnMgd2hlbiBgaGVsbWZpbGUgc3luY2Agd2Fz" + - "IGludGVycnVwdGVkLiBEZXN0cm95IGFuZCByZS1zeW5jIG9wZW5iYW86CiAgIGBgYGJhc2gKICAg" + - "SEVMTUZJTEVfRU5WPTxlbnY+IGhlbG1maWxlIC0tc2VsZWN0b3IgbmFtZT1vcGVuYmFvLXNlcnZl" + - "ciBkZXN0cm95CiAgIGt1YmVjdGwgZGVsZXRlIG5hbWVzcGFjZSB2YXVsdC1zeXN0ZW0KICAga3Vi" + - "ZWN0bCBjcmVhdGUgbmFtZXNwYWNlIHZhdWx0LXN5c3RlbQogICAjIFJlLWNyZWF0ZSBwdWxsIHNl" + - "Y3JldCBpZiBuZWVkZWQKICAgSEVMTUZJTEVfRU5WPTxlbnY+IGhlbG1maWxlIC0tc2VsZWN0b3Ig" + - "bmFtZT1vcGVuYmFvLXNlcnZlciBzeW5jCiAgIGBgYAoKMy4gKipPcGVuQmFvIHBvZHMgcnVubmlu" + - "ZyBidXQgbm90IGluaXRpYWxpemVkKio6IENoZWNrIHVuc2VhbCBzdGF0dXM6CiAgIGBgYGJhc2gK" + - "ICAga3ViZWN0bCBleGVjIC1uIHZhdWx0LXN5c3RlbSBvcGVuYmFvLXNlcnZlci0wIC1jIG9wZW5i" + - "YW8gLS0gYmFvIHN0YXR1cwogICBgYGAKCjQuICoqYHZhdWx0LWFnZW50LWluaXRgIGxvZ3MgYGF1" + - "dGgvand0L2xvZ2luYCAtPiBgNDAwIC4uLiBubyBrbm93biBrZXkgc3VjY2Vzc2Z1bGx5IHZhbGlk" + - "YXRlZCB0aGUgdG9rZW4gc2lnbmF0dXJlYCoqCiAgIChjb21tb24gb24gQUtTLCBhbmQgb24gYW55" + - "IGNsdXN0ZXIgd2hvc2UgT0lEQyBpc3N1ZXIgcHVibGlzaGVzIGEgcm90YXRpbmcgbXVsdGkta2V5" + - "IEpXS1MpOgogICB0aGUgT3BlbkJhbyBgYXV0aC9qd3RgIG1ldGhvZCB3YXMgY29uZmlndXJlZCB3" + - "aXRoIGEgc2luZ2xlIHN0YXRpYyBtb3VudGVkIHB1YmxpYyBrZXkKICAgKGBqd3RfdmFsaWRhdGlv" + - "bl9wdWJrZXlzYCkgaW5zdGVhZCBvZiB0aGUgaXNzdWVyJ3MgbGl2ZSBKV0tTLCBzbyBpdCBjYW5u" + - "b3QgdmFsaWRhdGUgdGhlCiAgIGNsdXN0ZXItc2lnbmVkIFNlcnZpY2VBY2NvdW50IHRva2VucyB0" + - "aGUgdmF1bHQtYWdlbnRzIHByZXNlbnQuIEV2ZXJ5IHNlcnZpY2UncwogICBgdmF1bHQtYWdlbnQt" + - "aW5pdGAgdGhlbiBsb29wcyBvbiB0aGF0IDQwMCBhbmQgdGhlIHBvZCBuZXZlciBsZWF2ZXMgYElu" + - "aXQ6MC8xYC4gVGhpcyBpcyB0aGUKICAgYmVoYXZpb3Igb2YgdGhlIGJhc2UgZGVmYXVsdCBgb3Bl" + - "bmJhby5taWdyYXRpb25zLmlzc3VlckRpc2NvdmVyeS5lbmFibGVkOiBmYWxzZWA7IHRoZQogICBt" + - "aWdyYXRpb24gbG9nIHNob3dzIGBPSURDIGlzc3VlciBkaXNjb3ZlcnkgaXMgZGlzYWJsZWQuIFVz" + - "aW5nIFNlcnZpY2VBY2NvdW50IGlzc3VlciBhbmQKICAgbW91bnRlZCBwdWJsaWMga2V5IGZhbGxi" + - "YWNrYC4gRW5hYmxlIGlzc3VlciBkaXNjb3Zlcnkgc28gdGhlIG1pZ3JhdGlvbiB1c2VzIHRoZSBs" + - "aXZlIEpXS1MsCiAgIHRoZW4gcmUtcnVuIGl0OgogICBgYGBiYXNoCiAgICMgSW4geW91ciBlbnYg" + - "dmFsdWVzIChlLmcuIGVudmlyb25tZW50cy88ZW52Pi55YW1sKSwgc2V0OgogICAjICAgb3BlbmJh" + - "bzoKICAgIyAgICAgbWlncmF0aW9uczoKICAgIyAgICAgICBpc3N1ZXJEaXNjb3Zlcnk6CiAgICMg" + - "ICAgICAgICBlbmFibGVkOiB0cnVlCiAgIGt1YmVjdGwgZGVsZXRlIGpvYiAtbiB2YXVsdC1zeXN0" + - "ZW0gb3BlbmJhby1zZXJ2ZXItbWlncmF0aW9ucwogICBIRUxNRklMRV9FTlY9PGVudj4gaGVsbWZp" + - "bGUgLS1zZWxlY3RvciBuYW1lPW9wZW5iYW8tc2VydmVyIHN5bmMKICAgYGBgCiAgIFRoZSBtaWdy" + - "YXRpb24gbG9nIHNob3VsZCB0aGVuIHNob3cgYFJlY2VpdmVkIGRpc2NvdmVyeSBkb2N1bWVudCBm" + - "cm9tCiAgIC4uLi8ud2VsbC1rbm93bi9vcGVuaWQtY29uZmlndXJhdGlvbmAgYW5kIGBGaW5hbCBP" + - "cGVuQmFvIEpXVCBKV0tTIFVSTCBzZXQgdG86CiAgIC4uLi9vcGVuaWQvdjEvandrc2AsIGFuZCB0" + - "aGUgc2VydmljZSBwb2RzIGF1dGhlbnRpY2F0ZSBhbmQgcmVhY2ggUmVhZHkgd2l0aGluIH4xIG1p" + - "bi4KICAgQUtTIGNsdXN0ZXJzIHdpdGggdGhlIGNsdXN0ZXIgT0lEQyBpc3N1ZXIgZW5hYmxlZCAo" + - "dGhlIGBha3MtY2x1c3RlcmAgZGVmYXVsdCkgYWx3YXlzIG5lZWQKICAgdGhpcyBiZWNhdXNlIHRo" + - "ZSBzdGF0aWMtcHVia2V5IGZhbGxiYWNrIGNhbm5vdCBtYXRjaCB0aGUgaXNzdWVyJ3Mgcm90YXRp" + - "bmcgc2lnbmluZyBrZXlzLgoKIyMgRmFpbHVyZTogT09NS2lsbGVkIG9uIENhc3NhbmRyYQoKIyMj" + - "IFN5bXB0b21zCgpgYGAKTkFNRSAgICAgICAgICBSRUFEWSAgIFNUQVRVUyAgICBSRVNUQVJUUyAg" + - "IEFHRQpjYXNzYW5kcmEtMCAgIDAvMSAgICAgT09NS2lsbGVkICAzICAgICAgICAgMTBtCmBgYAoK" + - "IyMjIERpYWdub3NpcwoKYGBgYmFzaAprdWJlY3RsIGRlc2NyaWJlIHBvZCAtbiBjYXNzYW5kcmEt" + - "c3lzdGVtIGNhc3NhbmRyYS0wIHwgZ3JlcCAtQTMgIkxhc3QgU3RhdGUiCmBgYAoKIyMjIEZpeAoK" + - "T3ZlcnJpZGUgQ2Fzc2FuZHJhIHJlc291cmNlcyB2aWEgaGVsbWZpbGUgdmFsdWVzLiBTZWUgRXhh" + - "bXBsZSAxIGluCltleGFtcGxlcy5tZF0oLi4vZXhhbXBsZXMubWQpLgoKYGBgeWFtbAotIGNhc3Nh" + - "bmRyYToKICAgIHJlc291cmNlczoKICAgICAgbGltaXRzOgogICAgICAgIGNwdTogIjgiCiAgICAg" + - "ICAgbWVtb3J5OiA4MTkyTWkKICAgICAgcmVxdWVzdHM6CiAgICAgICAgY3B1OiAiMiIKICAgICAg" + - "ICBtZW1vcnk6IDQwOTZNaQpgYGAKCk5vdGU6IGByZXNvdXJjZVByZXNldGAgaXMgbm90IGF2YWls" + - "YWJsZSBpbiB0aGUgTlZDRiBjYXNzYW5kcmEgd3JhcHBlciBjaGFydC4gVXNlIGV4cGxpY2l0IGBy" + - "ZXNvdXJjZXNgLgoKIyMgRmFpbHVyZTogUG9kcyBTdHVjayBpbiBQZW5kaW5nCgojIyMgU3ltcHRv" + - "bXMKCmBgYApOQU1FICAgICAgICAgIFJFQURZICAgU1RBVFVTICAgIFJFU1RBUlRTICAgQUdFCmNh" + - "c3NhbmRyYS0wICAgMC8xICAgICBQZW5kaW5nICAgMCAgICAgICAgICAxMG0KYGBgCgojIyMgRGlh" + - "Z25vc2lzCgpgYGBiYXNoCiMgQ2hlY2sgZXZlbnRzIGZvciBzY2hlZHVsaW5nIGZhaWx1cmVzCmt1" + - "YmVjdGwgZGVzY3JpYmUgcG9kIC1uIDxuYW1lc3BhY2U+IDxwb2QtbmFtZT4KCiMgQ29tbW9uIGNh" + - "dXNlczoKIyAtICIwLzEyIG5vZGVzIGFyZSBhdmFpbGFibGU6IDEyIG5vZGUocykgZGlkbid0IG1h" + - "dGNoIFBvZCdzIG5vZGUgYWZmaW5pdHkiCiMgLSAiMC8xMiBub2RlcyBhcmUgYXZhaWxhYmxlOiAx" + - "MiBJbnN1ZmZpY2llbnQgbWVtb3J5IgojIC0gInBlcnNpc3RlbnR2b2x1bWVjbGFpbSBub3QgZm91" + - "bmQiCmBgYAoKIyMjIEZpeGVzCgoxLiAqKk5vZGUgc2VsZWN0b3IgbWlzbWF0Y2gqKjogQ2hlY2sg" + - "YG5vZGVTZWxlY3RvcnNgIGluIGVudmlyb25tZW50IGZpbGUKICAgYGBgYmFzaAogICBrdWJlY3Rs" + - "IGdldCBub2RlcyAtLXNob3ctbGFiZWxzIHwgZ3JlcCBudmNmCiAgIGBgYAoKMi4gKipTdG9yYWdl" + - "IGNsYXNzIG5vdCBmb3VuZCoqOiBDaGVjayBzdG9yYWdlIGNsYXNzIGV4aXN0cwogICBgYGBiYXNo" + - "CiAgIGt1YmVjdGwgZ2V0IHN0b3JhZ2VjbGFzcwogICBgYGAKCjMuICoqSW5zdWZmaWNpZW50IHJl" + - "c291cmNlcyoqOiBDaGVjayBub2RlIGNhcGFjaXR5CiAgIGBgYGJhc2gKICAga3ViZWN0bCBkZXNj" + - "cmliZSBub2RlIDxub2RlLW5hbWU+IHwgZ3JlcCAtQTUgIkFsbG9jYXRlZCByZXNvdXJjZXMiCiAg" + - "IGBgYAoKIyMgRmFpbHVyZTogSGVsbSBSZWxlYXNlIGluIEZhaWxlZCBTdGF0ZQoKIyMjIFN5bXB0" + - "b21zCgpgYGBiYXNoCmhlbG0gbGlzdCAtQQojIFNob3dzIHJlbGVhc2Ugd2l0aCBTVEFUVVM6IGZh" + - "aWxlZApgYGAKClJlLXJ1bm5pbmcgYGhlbG1maWxlIHN5bmNgIGFwcGVhcnMgdG8gc3VjY2VlZCBi" + - "dXQgc2VydmljZXMgZG9uJ3Qgd29yayAobWlncmF0aW9ucyBza2lwcGVkKS4KCiMjIyBEaWFnbm9z" + - "aXMKCmBgYGJhc2gKaGVsbSBoaXN0b3J5IDxyZWxlYXNlLW5hbWU+IC1uIDxuYW1lc3BhY2U+CmBg" + - "YAoKIyMjIEZpeAoKTXVzdCBkZXN0cm95IHRoZSBmYWlsZWQgcmVsZWFzZSBhbmQgcmUtc3luYyAo" + - "bm90IGp1c3QgYXBwbHkpOgoKYGBgYmFzaApIRUxNRklMRV9FTlY9PGVudj4gaGVsbWZpbGUgLS1z" + - "ZWxlY3RvciBuYW1lPTxyZWxlYXNlPiBkZXN0cm95CiMgSWYgbmFtZXNwYWNlIG5lZWRzIGNsZWFu" + - "dXA6Cmt1YmVjdGwgZGVsZXRlIG5hbWVzcGFjZSA8bmFtZXNwYWNlPgprdWJlY3RsIGNyZWF0ZSBu" + - "YW1lc3BhY2UgPG5hbWVzcGFjZT4KIyBSZS1jcmVhdGUgcHVsbCBzZWNyZXQgaWYgbmVlZGVkCkhF" + - "TE1GSUxFX0VOVj08ZW52PiBoZWxtZmlsZSAtLXNlbGVjdG9yIG5hbWU9PHJlbGVhc2U+IHN5bmMK" + - "YGBgCgojIyBGYWlsdXJlOiBBY2NvdW50IEJvb3RzdHJhcCBKb2IgRmFpbGVkCgojIyMgU3ltcHRv" + - "bXMKClNlcnZpY2VzIGRlcGxveSBidXQgZnVuY3Rpb25zIGNhbid0IGJlIGNyZWF0ZWQuIEV2ZW50" + - "cyBzaG93IGJvb3RzdHJhcCBqb2IgZmFpbHVyZS4KCiMjIyBEaWFnbm9zaXMKCmBgYGJhc2gKIyBD" + - "aGVjayBib290c3RyYXAgam9iIHN0YXR1cwprdWJlY3RsIGdldCBqb2JzIC1uIG52Y2YKCiMgR2V0" + - "IGxvZ3MgKGpvYiBhdXRvLWRlbGV0ZXMgYWZ0ZXIgfjUgbWludXRlcykKa3ViZWN0bCBsb2dzIGpv" + - "Yi9udmNmLWFwaS1hY2NvdW50LWJvb3RzdHJhcCAtbiBudmNmCgojIENoZWNrIEFQSSBsb2dzCmt1" + - "YmVjdGwgbG9ncyAtbiBudmNmIC1sIGFwcC5rdWJlcm5ldGVzLmlvL25hbWU9bnZjZi1hcGkgLS10" + - "YWlsPTEwMApgYGAKCiMjIyBDb21tb24gQ2F1c2VzCgoxLiAqKldyb25nIGJhc2U2NCBjcmVkZW50" + - "aWFscyoqOiBDcmVkZW50aWFscyBpbiBgc2VjcmV0cy88ZW52Pi1zZWNyZXRzLnlhbWxgIG11c3Qg" + - "YmUgYCRvYXV0aHRva2VuOkFQSV9LRVlgIGJhc2U2NC1lbmNvZGVkLCBub3QganVzdCB0aGUgQVBJ" + - "IGtleQogICBgYGBiYXNoCiAgICMgVmVyaWZ5IHlvdXIgZW5jb2RlZCBjcmVkZW50aWFsCiAgIGVj" + - "aG8gJ1lPVVJfQkFTRTY0X1NUUklORycgfCBiYXNlNjQgLWQKICAgIyBTaG91bGQgb3V0cHV0OiAk" + - "b2F1dGh0b2tlbjpudmFwaS14eHh4eAogICBgYGAKCjIuICoqUmVnaXN0cnkgdW5yZWFjaGFibGUq" + - "KjogQVBJIGNhbid0IHJlYWNoIHRoZSByZWdpc3RyeSBzcGVjaWZpZWQgaW4gYGFjY291bnRCb290" + - "c3RyYXAucmVnaXN0cnlDcmVkZW50aWFsc2AKCiMjIyBGaXgKCkZpeCBjcmVkZW50aWFscyBpbiBz" + - "ZWNyZXRzIGZpbGUsIHRoZW4gcmVjb3ZlciBzZXJ2aWNlcyB3aXRob3V0IGRlc3Ryb3lpbmcgZGVw" + - "ZW5kZW5jaWVzOgoKYGBgYmFzaApIRUxNRklMRV9FTlY9PGVudj4gaGVsbWZpbGUgLS1zZWxlY3Rv" + - "ciByZWxlYXNlLWdyb3VwPXNlcnZpY2VzIGRlc3Ryb3kKa3ViZWN0bCBkZWxldGUgbmFtZXNwYWNl" + - "IG52Y2YgYXBpLWtleXMgZXNzIHNpcyAtLWlnbm9yZS1ub3QtZm91bmQKa3ViZWN0bCBjcmVhdGUg" + - "bmFtZXNwYWNlIG52Y2YgJiYga3ViZWN0bCBjcmVhdGUgbmFtZXNwYWNlIGFwaS1rZXlzICYmIFwK" + - "ICBrdWJlY3RsIGNyZWF0ZSBuYW1lc3BhY2UgZXNzICYmIGt1YmVjdGwgY3JlYXRlIG5hbWVzcGFj" + - "ZSBzaXMKIyBSZS1jcmVhdGUgcHVsbCBzZWNyZXRzIGlmIG5lZWRlZApIRUxNRklMRV9FTlY9PGVu" + - "dj4gaGVsbWZpbGUgLS1zZWxlY3RvciByZWxlYXNlLWdyb3VwPXNlcnZpY2VzIHN5bmMKYGBgCgoj" + - "IyBGYWlsdXJlOiBOVkNBIENsZWFudXAgU3R1Y2sgKEZpbmFsaXplcnMpCgojIyMgU3ltcHRvbXMK" + - "CkNvbXB1dGUtcGxhbmUgY2xlYW51cCBoYW5ncy4gTmFtZXNwYWNlcwpzdHVjayBpbiBgVGVybWlu" + - "YXRpbmdgOgoKYGBgYmFzaAprdWJlY3RsIGdldCBucwojIG52Y2Etb3BlcmF0b3IgICAgVGVybWlu" + - "YXRpbmcgICAxMG0KIyBudmNmLWJhY2tlbmQgICAgIFRlcm1pbmF0aW5nICAgMTBtCmBgYAoKIyMj" + - "IEZpeAoKUnVuIHRoaXMgb25seSBhZ2FpbnN0IHRoZSBjb21wdXRlIGNvbnRleHQsIGFmdGVyIHRo" + - "ZSBub3JtYWwgY29tcHV0ZS1wbGFuZQp0ZWFyZG93biBoYXMgZmFpbGVkLiBSZW1vdmUgZmluYWxp" + - "emVycyBmcm9tIE5WQ0ZCYWNrZW5kIGN1c3RvbSByZXNvdXJjZXMgYW5kCmZvcmNlLWRlbGV0ZSBz" + - "dHVjayBuYW1lc3BhY2VzOgoKYGBgYmFzaApleHBvcnQgQ09NUFVURV9DT05URVhUPTxjb21wdXRl" + - "LXBsYW5lLWNvbnRleHQ+CgojIFJlbW92ZSBmaW5hbGl6ZXJzIGZyb20gTlZDRkJhY2tlbmQgcmVz" + - "b3VyY2VzCmt1YmVjdGwgLS1jb250ZXh0ICIkQ09NUFVURV9DT05URVhUIiBnZXQgbnZjZmJhY2tl" + - "bmRzIC1BIC1vIGpzb24gfCBcCiAganEgJy5pdGVtc1tdIHwgLm1ldGFkYXRhLm5hbWVzcGFjZSAr" + - "ICIvIiArIC5tZXRhZGF0YS5uYW1lJyAtciB8IFwKICB4YXJncyAtSXt9IHNoIC1jICdjb250ZXh0" + - "PSIkMSI7IG5zPSIkezIlJS8qfSI7IG5hbWU9IiR7MiMjKi99Ijsga3ViZWN0bCAtLWNvbnRleHQg" + - "IiRjb250ZXh0IiBwYXRjaCBudmNmYmFja2VuZCAiJG5hbWUiIC1uICIkbnMiIC0tdHlwZT1tZXJn" + - "ZSAtcCAie1wibWV0YWRhdGFcIjp7XCJmaW5hbGl6ZXJzXCI6W119fSInIF8gIiRDT01QVVRFX0NP" + - "TlRFWFQiIHt9CgojIEZvcmNlLWRlbGV0ZSBzdHVjayBuYW1lc3BhY2VzIGJ5IGNsZWFyaW5nIHRo" + - "ZWlyIGZpbmFsaXplcnMKZm9yIG5zIGluIG52Y2Etb3BlcmF0b3IgbnZjZi1iYWNrZW5kOyBkbwog" + - "IGt1YmVjdGwgLS1jb250ZXh0ICIkQ09NUFVURV9DT05URVhUIiBnZXQgbmFtZXNwYWNlICIkbnMi" + - "IC1vIGpzb24gMj4vZGV2L251bGwgfCBcCiAgICBqcSAnLnNwZWMuZmluYWxpemVycyA9IFtdJyB8" + - "IFwKICAgIGt1YmVjdGwgLS1jb250ZXh0ICIkQ09NUFVURV9DT05URVhUIiByZXBsYWNlIFwKICAg" + - "ICAgLS1yYXcgIi9hcGkvdjEvbmFtZXNwYWNlcy8kbnMvZmluYWxpemUiIC1mIC0gMj4vZGV2L251" + - "bGwKZG9uZQpgYGAKCiMjIEZhaWx1cmU6IE5WQ0EgT3BlcmF0b3IgTWlzc2luZyBvciBOb3QgUmVh" + - "ZHkKCiMjIyBTeW1wdG9tcwoKQWZ0ZXIgY29tcHV0ZS1wbGFuZSBpbnN0YWxsIGNvbXBsZXRlcywg" + - "bm8gYG52Y2Etb3BlcmF0b3JgIERlcGxveW1lbnQgZXhpc3RzLCBvcgppdCBleGlzdHMgYnV0IHBv" + - "ZHMgYXJlIG5vdCByZWFkeToKCmBgYGJhc2gKa3ViZWN0bCAtLWNvbnRleHQgPGNvbXB1dGUtcGxh" + - "bmUtY29udGV4dD4gZ2V0IGRlcGxveW1lbnQgbnZjYS1vcGVyYXRvciBcCiAgLW4gbnZjYS1vcGVy" + - "YXRvcgprdWJlY3RsIC0tY29udGV4dCA8Y29tcHV0ZS1wbGFuZS1jb250ZXh0PiBnZXQgcG9kcyAt" + - "biBudmNhLW9wZXJhdG9yCmBgYAoKIyMjIERpYWdub3NpcyBhbmQgRml4ZXMKCkZpcnN0IGlkZW50" + - "aWZ5IHdoZXRoZXIgdGhlIGluc3RhbGxhdGlvbiB1c2VkIHRoZSBIZWxtZmlsZSB2YWx1ZXMgZmxv" + - "dyBvciB0aGUKQ0xJIHByb2ZpbGUgZmxvdy4gUmUtcnVuIG9ubHkgdGhhdCBmbG93J3MgcmVnaXN0" + - "cmF0aW9uIGFuZCBpbnN0YWxsYXRpb24gc3RlcHMKZnJvbSBbU3BsaXQgQ29tcHV0ZS1QbGFuZSBJ" + - "bnN0YWxsYXRpb25dKGNvbXB1dGUtcGxhbmUtaW5zdGFsbGF0aW9uLm1kKS4gRG8gbm90CnN1YnN0" + - "aXR1dGUgb25lIGhhbmRvZmYgZm9yIHRoZSBvdGhlci4KCklmIGluc3RhbGxhdGlvbiBzdWNjZWVk" + - "cyBidXQgcG9kcyBzdGlsbCBmYWlsLCBpbnNwZWN0IHRoZSBjb21wdXRlIGNvbnRleHQ6CgpgYGBi" + - "YXNoCmt1YmVjdGwgLS1jb250ZXh0IDxjb21wdXRlLXBsYW5lLWNvbnRleHQ+IGRlc2NyaWJlIGRl" + - "cGxveSBudmNhLW9wZXJhdG9yIFwKICAtbiBudmNhLW9wZXJhdG9yCmt1YmVjdGwgLS1jb250ZXh0" + - "IDxjb21wdXRlLXBsYW5lLWNvbnRleHQ+IGxvZ3MgZGVwbG95bWVudC9udmNhLW9wZXJhdG9yIFwK" + - "ICAtbiBudmNhLW9wZXJhdG9yIC0tdGFpbD0yMDAKa3ViZWN0bCAtLWNvbnRleHQgPGNvbXB1dGUt" + - "cGxhbmUtY29udGV4dD4gZ2V0IG52Y2ZiYWNrZW5kIC1uIG52Y2Etb3BlcmF0b3IKYGBgCgpGb3Ig" + - "cHJpdmF0ZSByZWdpc3RyeSBmYWlsdXJlcywgdmVyaWZ5IHRoYXQgdGhlIHB1bGwgc2VjcmV0IGV4" + - "aXN0cyBpbgpgbnZjYS1vcGVyYXRvcmAuIFRoZSBjaGFydCBhbmQgb3BlcmF0b3IgbWlycm9yIGl0" + - "IHRvIGBudmNhLXN5c3RlbWA7IGRvIG5vdCB1c2UgYQpicm9hZGVyIG1hbnVhbCBuYW1lc3BhY2Ug" + - "bG9vcC4gU2VlCltwdWxsLXNlY3JldHMubWRdKHB1bGwtc2VjcmV0cy5tZCNjb21wdXRlLXBsYW5l" + - "LXNlY3JldCkuCgojIyBGYWlsdXJlOiBHYXRld2F5IEVuZHBvaW50IENoYW5nZWQKCiMjIyBTeW1w" + - "dG9tcwoKUmVxdWVzdHMgdGhyb3VnaCB0aGUgY29uZmlndXJlZCByb3V0ZSBkb21haW4gZmFpbCBh" + - "ZnRlciB0aGUgR2F0ZXdheSBvciBpdHMgbG9hZCBiYWxhbmNlciBpcyByZXBsYWNlZC4gVGhlIEdh" + - "dGV3YXkgcmVwb3J0cyBhIG5ldyBlbmRwb2ludC4KCiMjIyBEaWFnbm9zaXMKCmBgYGJhc2gKR0FU" + - "RVdBWV9BRERSPSQoa3ViZWN0bCAtLWNvbnRleHQgPGNvbnRyb2wtcGxhbmUtY29udGV4dD4gZ2V0" + - "IGdhdGV3YXkgXAogIG52Y2YtZ2F0ZXdheSAtbiBlbnZveS1nYXRld2F5IFwKICAtbyBqc29ucGF0" + - "aD0ney5zdGF0dXMuYWRkcmVzc2VzWzBdLnZhbHVlfScpCnRlc3QgLW4gIiRHQVRFV0FZX0FERFIi" + - "CmRpZyArc2hvcnQgImFwaS48ZG9tYWluPiIKY3VybCAtSCAiSG9zdDogYXBpLjxkb21haW4+IiAi" + - "aHR0cDovLyRHQVRFV0FZX0FERFIvaGVhbHRoIgoKIyBDaGVjayBkaXJlY3QgYWRkcmVzcyBmaWVs" + - "ZHMgdXNlZCBieSBhIHNwbGl0IGRlcGxveW1lbnQKZ3JlcCBudmNmTmF0c1NlcnZpY2VVUkwgZGVw" + - "bG95L3N0YWNrcy9zZWxmLW1hbmFnZWQvZW52aXJvbm1lbnRzLzxlbnY+LnlhbWwKZ3JlcCAtRSAn" + - "aWNtc1NlcnZpY2V8cmV2YWxTZXJ2aWNlfG5hdHMnIFwKICBkZXBsb3kvc3RhY2tzL252Y2YtY29t" + - "cHV0ZS1wbGFuZS9lbnZpcm9ubWVudHMvPGVudj4ueWFtbApgYGAKCiMjIyBGaXgKCktlZXAgYGds" + - "b2JhbC5kb21haW5gLCByb3V0ZSBob3N0bmFtZXMsIGFuZCBIb3N0IG92ZXJyaWRlcyB1bmNoYW5n" + - "ZWQuIFVwZGF0ZSBETlMKb3IgdGhlIGRpcmVjdCBjbGllbnQgZGVzdGluYXRpb24uIEZvciBzcGxp" + - "dCBkZXBsb3ltZW50cywgdXBkYXRlIG9ubHkgZGlyZWN0CkdhdGV3YXktYWRkcmVzcyBmaWVsZHMg" + - "YW5kIHJlZnJlc2ggcmVnaXN0cmF0aW9uIGFuZCBpbnN0YWxsYXRpb24gdGhyb3VnaCB0aGUKc2Ft" + - "ZSBzZWxlY3RlZCBoYW5kb2ZmLiBTZWUKW0V4YW1wbGUgNF0oLi4vZXhhbXBsZXMubWQjZXhhbXBs" + - "ZS00LXJlY292ZXItZnJvbS1hLWdhdGV3YXktZW5kcG9pbnQtY2hhbmdlKS4KCiMjIFVzZWZ1bCBO" + - "YW1lc3BhY2UtdG8tU2VydmljZSBNYXBwaW5nCgpRdWljayByZWZlcmVuY2UgZm9yIHdoaWNoIHNl" + - "cnZpY2VzIHJ1biBpbiB3aGljaCBuYW1lc3BhY2U6Cgp8IE5hbWVzcGFjZSB8IFNlcnZpY2VzIHwK" + - "fC0tLS0tLS0tLS0tfC0tLS0tLS0tLS18CnwgbmF0cy1zeXN0ZW0gfCBuYXRzIHwKfCBjYXNzYW5k" + - "cmEtc3lzdGVtIHwgY2Fzc2FuZHJhIHwKfCB2YXVsdC1zeXN0ZW0gfCBvcGVuYmFvLXNlcnZlciB8" + - "CnwgbnZjZiB8IGFwaSwgaW52b2NhdGlvbi1zZXJ2aWNlLCBncnBjLXByb3h5LCBub3Rhcnktc2Vy" + - "dmljZSwgcmV2YWwsIGxsbS1yZXF1ZXN0LXJvdXRlciwgbGxtLWFwaS1nYXRld2F5IHwKfCBhcGkt" + - "a2V5cyB8IGFwaS1rZXlzLCBhZG1pbi1pc3N1ZXItcHJveHkgfAp8IGVzcyB8IGVzcy1hcGkgfAp8" + - "IHNpcyB8IHNpcyB8CnwgZW52b3ktZ2F0ZXdheS1zeXN0ZW0gfCBlbnZveSBnYXRld2F5IChpbmdy" + - "ZXNzIGNvbnRyb2xsZXIpIHwKfCBlbnZveS1nYXRld2F5IHwgZ2F0ZXdheSByZXNvdXJjZSArIHJv" + - "dXRlcyB8ClBLBwhWPmeQlTAAAJUwAABQSwMEFAAIAAAAAAAhAAAAAAAAAAAAAAAAAEQACQBkYXRh" + - "L252Y2Ytc2VsZi1tYW5hZ2VkLWluc3RhbGxhdGlvbi9yZWZlcmVuY2VzL2hlbG1maWxlLXN0cnVj" + - "dHVyZS5tZFVUBQABAKbOEiMgSGVsbWZpbGUgU3RydWN0dXJlIFJlZmVyZW5jZQoKIyMgRGlyZWN0" + - "b3J5IExheW91dAoKYGBgCm52Y2Ytc2VsZi1tYW5hZ2VkLXN0YWNrLwp8LS0gaGVsbWZpbGUuZC8K" + - "fCAgIHwtLSAwMS1kZXBlbmRlbmNpZXMueWFtbC5nb3RtcGwgICMgTkFUUywgQ2Fzc2FuZHJhLCBP" + - "cGVuQmFvCnwgICB8LS0gMDItY29yZS55YW1sLmdvdG1wbCAgICAgICAgICAjIE5WQ0Ygc2Vydmlj" + - "ZXMgKyBpbmdyZXNzCnwgICBgLS0gMDMtb2JzZXJ2YWJpbGl0eS55YW1sLmdvdG1wbCAjIE9ic2Vy" + - "dmFiaWxpdHkgc3RhY2sgKG9wdGlvbmFsKQp8LS0gZW52aXJvbm1lbnRzLwp8ICAgfC0tIGJhc2Uu" + - "eWFtbCAgICAgICAgICAgICAgICAgICAgIyBEZWZhdWx0IHZhbHVlcyAoYWxsIGVudmlyb25tZW50" + - "cykKfCAgIGAtLSA8ZW52LW5hbWU+LnlhbWwgICAgICAgICAgICAgICMgUGVyLWVudmlyb25tZW50" + - "IG92ZXJyaWRlcwp8LS0gc2VjcmV0cy8KfCAgIGAtLSA8ZW52LW5hbWU+LXNlY3JldHMueWFtbCAg" + - "ICAgICMgU2Vuc2l0aXZlIHZhbHVlcyAocmVnaXN0cnkgY3JlZHMsIHBhc3N3b3JkcykKYC0tIGds" + - "b2JhbC55YW1sLmdvdG1wbCAgICAgICAgICAgICAgICMgR28gdGVtcGxhdGUgdGhhdCBjb25zdHJ1" + - "Y3RzIHBlci1jaGFydCB2YWx1ZXMKCm52Y2YtY29tcHV0ZS1wbGFuZS1zdGFjay8KfC0tIGhlbG1m" + - "aWxlLmQvCnwgICB8LS0gMDEtZGVwZW5kZW5jaWVzLnlhbWwuZ290bXBsICAjIENvbXB1dGUgcGxh" + - "bmUgZGVwZW5kZW5jeSBjb21wb25lbnRzCnwgICBgLS0gMDItbnZjYS55YW1sLmdvdG1wbCAgICAg" + - "ICAgICAjIG52Y2Etb3BlcmF0b3IgY2hhcnQgYW5kIG52Y2EgY29uZmlndXJhdGlvbgp8LS0gZW52" + - "aXJvbm1lbnRzLwp8ICAgfC0tIGJhc2UueWFtbCAgICAgICAgICAgICAgICAgICAgIyBEZWZhdWx0" + - "IHZhbHVlcyAoYWxsIGVudmlyb25tZW50cykKfCAgIGAtLSA8ZW52LW5hbWU+LnlhbWwgICAgICAg" + - "ICAgICAgICMgUGVyLWVudmlyb25tZW50IG92ZXJyaWRlcwpgLS0gZ2xvYmFsLnlhbWwuZ290bXBs" + - "ICAgICAgICAgICAgICAgIyBHbyB0ZW1wbGF0ZSB0aGF0IGNvbnN0cnVjdHMgcGVyLWNoYXJ0IHZh" + - "bHVlcwpgYGAKClRoZXNlIHN0YWNrcyBoYXZlIHNlcGFyYXRlIGVudmlyb25tZW50cyBhbmQgY2x1" + - "c3RlciBjb250ZXh0cy4gVGhlIEhlbG1maWxlCnZhbHVlcyBmbG93IGF1dGhvcnMgYm90aCBlbnZp" + - "cm9ubWVudCBmaWxlcy4gVGhlIENMSSBwcm9maWxlIGZsb3cgaW5zdGVhZCB1c2VzCnRoZSBDTEkt" + - "Z2VuZXJhdGVkIGNvbnRyb2wtcGxhbmUgcHJvZmlsZSBhcyBpdHMgZW5kcG9pbnQgc291cmNlLiBE" + - "byBub3QgbWl4IHRoZQpoYW5kb2Zmcy4gU2VlIFtTcGxpdCBDb21wdXRlLVBsYW5lIEluc3RhbGxh" + - "dGlvbl0oY29tcHV0ZS1wbGFuZS1pbnN0YWxsYXRpb24ubWQpLgoKIyMgR290bXBsIEZpbGVzIGFu" + - "ZCBUaGVpciBSZWxlYXNlcwoKIyMjIDAxLWRlcGVuZGVuY2llcy55YW1sLmdvdG1wbAoKfCBSZWxl" + - "YXNlIHwgQ2hhcnQgfCBOYW1lc3BhY2UgfCBOb3RlcyB8CnwtLS0tLS0tLS18LS0tLS0tLXwtLS0t" + - "LS0tLS0tLXwtLS0tLS0tfAp8IG5hdHMgfCBoZWxtLW52Y2YtbmF0cyB8IG5hdHMtc3lzdGVtIHwg" + - "TWVzc2FnaW5nIHwKfCBvcGVuYmFvLXNlcnZlciB8IGhlbG0tbnZjZi1vcGVuYmFvLXNlcnZlciB8" + - "IHZhdWx0LXN5c3RlbSB8IFNlY3JldHMgbWFuYWdlbWVudCwgZGVwZW5kcyBvbiBuYXRzIHwKfCBj" + - "YXNzYW5kcmEgfCBoZWxtLW52Y2YtY2Fzc2FuZHJhIHwgY2Fzc2FuZHJhLXN5c3RlbSB8IERhdGFi" + - "YXNlIHwKClVzZXMgYDw8OiAqZGVwZW5kZW5jeWAgdGVtcGxhdGUgaW5oZXJpdGFuY2Ugd2l0aCBg" + - "cmVsZWFzZS1ncm91cDogZGVwZW5kZW5jaWVzYCBsYWJlbC4KCiMjIyAwMi1jb3JlLnlhbWwuZ290" + - "bXBsCgp8IFJlbGVhc2UgfCBDaGFydCB8IE5hbWVzcGFjZSB8IExhYmVsIHwKfC0tLS0tLS0tLXwt" + - "LS0tLS0tfC0tLS0tLS0tLS0tfC0tLS0tLS18CnwgYXBpLWtleXMgfCBoZWxtLW52Y2YtYXBpLWtl" + - "eXMgfCBhcGkta2V5cyB8IHNlcnZpY2VzIHwKfCBzaXMgfCBoZWxtLW52Y2Ytc2lzIHwgc2lzIHwg" + - "c2VydmljZXMgfAp8IGFwaSB8IGhlbG0tbnZjZi1hcGkgfCBudmNmIHwgc2VydmljZXMgfAp8IGlu" + - "dm9jYXRpb24tc2VydmljZSB8IGhlbG0tbnZjZi1pbnZvY2F0aW9uLXNlcnZpY2UgfCBudmNmIHwg" + - "c2VydmljZXMgfAp8IGdycGMtcHJveHkgfCBoZWxtLW52Y2YtZ3JwYy1wcm94eSB8IG52Y2YgfCBz" + - "ZXJ2aWNlcyB8CnwgZXNzLWFwaSB8IGhlbG0tbnZjZi1lc3MtYXBpIHwgZXNzIHwgc2VydmljZXMg" + - "fAp8IG5vdGFyeS1zZXJ2aWNlIHwgaGVsbS1udmNmLW5vdGFyeS1zZXJ2aWNlIHwgbnZjZiB8IHNl" + - "cnZpY2VzIHwKfCByZXZhbCB8IGhlbG0tcmV2YWwgfCBudmNmIHwgc2VydmljZXMgfAp8IGxsbS1y" + - "ZXF1ZXN0LXJvdXRlciB8IG52Y2YvaGVsbS1udmNmLWxsbS1yZXF1ZXN0LXJvdXRlciB8IG52Y2Yg" + - "fCBzZXJ2aWNlcyB8CnwgbGxtLWFwaS1nYXRld2F5IHwgbnZjZi9oZWxtLW52Y2YtbGxtLWFwaS1n" + - "YXRld2F5IHwgbnZjZiB8IHNlcnZpY2VzIHwKfCBhZG1pbi1pc3N1ZXItcHJveHkgfCBoZWxtLWFk" + - "bWluLXRva2VuLWlzc3Vlci1wcm94eSB8IGFwaS1rZXlzIHwgKG5vIHJlbGVhc2UtZ3JvdXAgbGFi" + - "ZWwpIHwKfCBpbmdyZXNzIHwgbnZjZi1nYXRld2F5LXJvdXRlcyB8IGVudm95LWdhdGV3YXktc3lz" + - "dGVtIHwgaW5ncmVzcyB8CgpNb3N0IHNlcnZpY2VzIHVzZSBgaW5oZXJpdDogW3t0ZW1wbGF0ZTog" + - "c2VydmljZX1dYC4gTExNIHJlbGVhc2VzIHVzZSBPQ0kgY2hhcnRzIGZyb20gdGhlIGBudmNmYCBy" + - "ZXBvc2l0b3J5IHdpdGggc3RhbmRhbG9uZSBgdmFsdWVzOiBbLi4vZ2xvYmFsLnlhbWwuZ290bXBs" + - "XWAgYmxvY2tzOyB0aGV5IGFyZSBnYXRlZCBvbiBgYWRkb25zLmxsbS5lbmFibGVkYC4gYGFkbWlu" + - "LWlzc3Vlci1wcm94eWAgYW5kIGBpbmdyZXNzYCBoYXZlIHN0YW5kYWxvbmUgYHZhbHVlczpgIGJs" + - "b2Nrcy4KCiMjIyAwMy1vYnNlcnZhYmlsaXR5LnlhbWwuZ290bXBsCgp8IFJlbGVhc2UgfCBDaGFy" + - "dCB8IE5hbWVzcGFjZSB8IExhYmVsIHwKfC0tLS0tLS0tLXwtLS0tLS0tfC0tLS0tLS0tLS0tfC0t" + - "LS0tLS18CnwgKG9ic2VydmFiaWxpdHkgcmVsZWFzZXMpIHwgKHZhcmlvdXMpIHwgb2JzZXJ2YWJp" + - "bGl0eSB8IG9ic2VydmFiaWxpdHkgfAoKR2F0ZWQgb24gb2JzZXJ2YWJpbGl0eS1zcGVjaWZpYyBm" + - "bGFncyBpbiB0aGUgZW52aXJvbm1lbnQgZmlsZS4gU2tpcHBlZCBpZiBkaXNhYmxlZC4KCiMjIFRl" + - "bXBsYXRlIEluaGVyaXRhbmNlCgojIyMgYDw8OiAqZGVwZW5kZW5jeWAgKFlBTUwgbWVyZ2UpCgpV" + - "c2VkIGluIGAwMS1kZXBlbmRlbmNpZXMueWFtbC5nb3RtcGxgLiBNZXJnZXMgdGhlIHRlbXBsYXRl" + - "J3MgcHJvcGVydGllcyBpbnRvIHRoZSByZWxlYXNlLgoKKipHb3RjaGEqKjogWUFNTCBtZXJnZSBy" + - "ZXBsYWNlcyBsaXN0cy4gSWYgeW91IGFkZCBhIGB2YWx1ZXM6YCBrZXkgdG8gdGhlIHJlbGVhc2Us" + - "IGl0ICoqcmVwbGFjZXMqKiB0aGUgdGVtcGxhdGUncyBgdmFsdWVzOmAgbGlzdCBlbnRpcmVseS4g" + - "WW91IG11c3QgcmUtaW5jbHVkZSBhbGwgdGVtcGxhdGUgdmFsdWVzOgoKSW4gdGhlIHRlbXBsYXRl" + - "IGJlbG93LCBgPHByaXZhdGUtdmFsdWVzPmAgcmVmZXJzIHRvIHRoZSBgc2VjcmV0cy9gIGRpcmVj" + - "dG9yeSBhdCB0aGUgaGVsbWZpbGUgc3RhY2sgcm9vdC4KCmBgYHlhbWwKIyBUZW1wbGF0ZSBkZWZp" + - "bmVzOgp0ZW1wbGF0ZXM6CiAgZGVwZW5kZW5jeTogJmRlcGVuZGVuY3kKICAgIGNoYXJ0OiBudmNm" + - "L2hlbG0tbnZjZi17eyAuUmVsZWFzZS5OYW1lIH19CiAgICB2YWx1ZXM6CiAgICAgIC0gLi4vZ2xv" + - "YmFsLnlhbWwuZ290bXBsCiAgICAgIC0gLi4vPHByaXZhdGUtdmFsdWVzPi97eyByZXF1aXJlZEVu" + - "diAiSEVMTUZJTEVfRU5WIiB9fS1zZWNyZXRzLnlhbWwKCiMgV2hlbiBvdmVycmlkaW5nLCBNVVNU" + - "IHJlLWluY2x1ZGUgYm90aDoKLSBuYW1lOiBjYXNzYW5kcmEKICA8PDogKmRlcGVuZGVuY3kKICB2" + - "YWx1ZXM6CiAgICAtIC4uL2dsb2JhbC55YW1sLmdvdG1wbCAgICAgICAgICAgICAgICAgICAgICAg" + - "ICAgICAgICAgICAgICAgICAgICAgICAjIE11c3QgcmUtaW5jbHVkZQogICAgLSAuLi88cHJpdmF0" + - "ZS12YWx1ZXM+L3t7IHJlcXVpcmVkRW52ICJIRUxNRklMRV9FTlYiIH19LXNlY3JldHMueWFtbCAg" + - "ICMgTXVzdCByZS1pbmNsdWRlCiAgICAtIGNhc3NhbmRyYTogICAgICAgICAgICAgICAgICAgICAg" + - "ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIyBZb3VyIG92ZXJyaWRlCiAgICAg" + - "ICAgcmVzb3VyY2VzOgogICAgICAgICAgbGltaXRzOgogICAgICAgICAgICBtZW1vcnk6IDgxOTJN" + - "aQpgYGAKCiMjIyBgaW5oZXJpdGAgKEhlbG1maWxlIG5hdGl2ZSkKClVzZWQgaW4gYDAyLWNvcmUu" + - "eWFtbC5nb3RtcGxgLiBIZWxtZmlsZSdzIG5hdGl2ZSBpbmhlcml0YW5jZSBtZWNoYW5pc20uCgpg" + - "YGB5YW1sCi0gbmFtZTogYXBpCiAgdmVyc2lvbjogMS42LjAKICBuYW1lc3BhY2U6IG52Y2YKICBp" + - "bmhlcml0OgogICAgLSB0ZW1wbGF0ZTogc2VydmljZQpgYGAKCldoZW4gYWRkaW5nIGB2YWx1ZXM6" + - "YCB0byBhbiBpbmhlcml0ZWQgcmVsZWFzZSwgeW91IGFsc28gbmVlZCB0byByZS1pbmNsdWRlIHRo" + - "ZSB0ZW1wbGF0ZSdzIHZhbHVlcyBmaWxlcyBzaW5jZSBgdmFsdWVzYCBpcyBhIGxpc3QgdGhhdCBn" + - "ZXRzIHJlcGxhY2VkLgoKIyMgVmFsdWVzIFByZWNlZGVuY2UKCkZyb20gbG93ZXN0IHRvIGhpZ2hl" + - "c3QgcHJpb3JpdHk6CgoxLiBgZW52aXJvbm1lbnRzL2Jhc2UueWFtbGAgLS0gZGVmYXVsdHMgc2hh" + - "cmVkIGFjcm9zcyBhbGwgZW52aXJvbm1lbnRzCjIuIGBlbnZpcm9ubWVudHMvPGVudj4ueWFtbGAg" + - "LS0gcGVyLWVudmlyb25tZW50IG92ZXJyaWRlcwozLiBgZ2xvYmFsLnlhbWwuZ290bXBsYCAtLSBH" + - "byB0ZW1wbGF0ZSBwcm9jZXNzaW5nIChjb25zdHJ1Y3RzIGNoYXJ0LXNwZWNpZmljIHN0cnVjdHVy" + - "ZSkKNC4gYDxwcml2YXRlLXZhbHVlcz4vPGVudj4tc2VjcmV0cy55YW1sYCAtLSBzZW5zaXRpdmUg" + - "dmFsdWVzCjUuIElubGluZSBgdmFsdWVzOmAgYmxvY2tzIG9uIHJlbGVhc2VzIC0tIGhpZ2hlc3Qg" + - "cHJlY2VkZW5jZQoKIyMgV2hhdCBnbG9iYWwueWFtbC5nb3RtcGwgUGFzc2VzIFRocm91Z2gKCmBn" + - "bG9iYWwueWFtbC5nb3RtcGxgIHJlYWRzIGZyb20gYC5WYWx1ZXNgICh0aGUgbWVyZ2VkIGVudmly" + - "b25tZW50ICsgZW52LXNwZWNpZmljIFlBTUwpIGFuZCBjb25zdHJ1Y3RzIGNoYXJ0LXNwZWNpZmlj" + - "IHZhbHVlcy4gSXQgb25seSBwYXNzZXMgdGhyb3VnaCBrZXlzIGl0IGV4cGxpY2l0bHkgcmVmZXJl" + - "bmNlczoKCiMjIyBDYXNzYW5kcmEKLSBgY2Fzc2FuZHJhLnJlcGxpY2FDb3VudGAKLSBgY2Fzc2Fu" + - "ZHJhLmltYWdlLipgIChyZWdpc3RyeSwgcmVwb3NpdG9yeSkKLSBgY2Fzc2FuZHJhLm1pZ3JhdGlv" + - "bnMuaW1hZ2UuKmAKLSBgY2Fzc2FuZHJhLnBlcnNpc3RlbmNlLnNpemVgCi0gYGNhc3NhbmRyYS5u" + - "b2RlU2VsZWN0b3JgIChpZiBgZ2xvYmFsLm5vZGVTZWxlY3RvcnMuZW5hYmxlZGApCi0gYGNhc3Nh" + - "bmRyYS5nbG9iYWwuZGVmYXVsdFN0b3JhZ2VDbGFzc2AKCiMjIyBOQVRTCi0gYG5hdHMuY29udGFp" + - "bmVyLmltYWdlLipgCi0gYG5hdHMucmVsb2FkZXIuaW1hZ2UuKmAKLSBgbmF0cy5uYXRzQm94LmNv" + - "bnRhaW5lci5pbWFnZS4qYAotIGBuYXRzLmNvbmZpZy5qZXRzdHJlYW0uZmlsZVN0b3JlLnB2Yy5z" + - "dG9yYWdlQ2xhc3NOYW1lYAotIGBuYXRzLnBvZFRlbXBsYXRlLm1lcmdlLnNwZWMubm9kZVNlbGVj" + - "dG9yYCAoaWYgZW5hYmxlZCkKCiMjIyBPcGVuQmFvCi0gYG9wZW5iYW8ubWlncmF0aW9ucy5pbWFn" + - "ZS4qYCBhbmQgYG9wZW5iYW8ubWlncmF0aW9ucy5lbnZgCi0gYG9wZW5iYW8uaW5qZWN0b3IuaW1h" + - "Z2UuKmAKLSBgb3BlbmJhby5zZXJ2ZXIuaW1hZ2UuKmAKLSBgb3BlbmJhby5zZXJ2ZXIuZGF0YVN0" + - "b3JhZ2UuKmAKLSBOb2RlIHNlbGVjdG9ycyAoaWYgZW5hYmxlZCkKCiMjIyBTZXJ2aWNlcyAoQVBJ" + - "LCBTSVMsIGV0Yy4pCi0gYDxzZXJ2aWNlPi5pbWFnZS4qYCAocmVnaXN0cnksIHJlcG9zaXRvcnkp" + - "Ci0gYDxzZXJ2aWNlPi5ub2RlU2VsZWN0b3JgIChpZiBlbmFibGVkKQotIGA8c2VydmljZT4uZW52" + - "LipgIChvYnNlcnZhYmlsaXR5IHNldHRpbmdzKQoKIyMjIExMTSBGdW5jdGlvbiBFbmFibGVtZW50" + - "CgpFbmFibGUgdGhlIExMTSBhZGRvbiBiZWZvcmUgY3JlYXRpbmcgb3IgaW52b2tpbmcgZnVuY3Rp" + - "b25zIHdpdGgKYGZ1bmN0aW9uVHlwZTogIkxMTSJgLiBUaGUgYWRkb24gZGVwbG95cyBgbGxtLXJl" + - "cXVlc3Qtcm91dGVyYCBhbmQKYGxsbS1hcGktZ2F0ZXdheWAsIGFkZHMgdGhlIGBsbG0uaW52b2Nh" + - "dGlvbi48ZG9tYWluPmAgcm91dGUgd2hlbiBHYXRld2F5IEFQSQppbmdyZXNzIGlzIGVuYWJsZWQs" + - "IGFuZCBjb25maWd1cmVzIHdvcmtlcnMgdG8gdXNlIHRoZSBMTE0gc2lkZWNhci4gVGhlIEhlbG1m" + - "aWxlCmNvbmRpdGlvbiBpcyBgYWRkb25zLmxsbS5lbmFibGVkYC4gRG8gbm90IHVzZSB0aGUgb2Jz" + - "b2xldGUgYGxsbS5lbmFibGVkYCBwYXRoLgoKRm9yIGEgc2luZ2xlLW5vZGUgaXNvbGF0ZWQgdGVz" + - "dCBjbHVzdGVyLCBhZGQgdGhpcyBjb25maWd1cmF0aW9uIHRvCmBlbnZpcm9ubWVudHMvPGVudj4u" + - "eWFtbGAgYmVmb3JlIGFwcGx5aW5nIHRoZSBzdGFjazoKCmBgYHlhbWwKYWRkb25zOgogIGxsbToK" + - "ICAgIGVuYWJsZWQ6IHRydWUKICAgIGdhdGV3YXk6CiAgICAgIHJlcGxpY2FDb3VudDogMQogICAg" + - "ICBhdXRoOgogICAgICAgIGdycGNJbnNlY3VyZTogdHJ1ZQogICAgICBtZXRyaWNzOgogICAgICAg" + - "IHNlcnZpY2VNb25pdG9yOgogICAgICAgICAgZW5hYmxlZDogZmFsc2UKICAgIHJlcXVlc3RSb3V0" + - "ZXI6CiAgICAgIHJlcGxpY2FDb3VudDogMQogICAgICBtZXRyaWNzOgogICAgICAgIHNlcnZpY2VN" + - "b25pdG9yOgogICAgICAgICAgZW5hYmxlZDogZmFsc2UKCmFnZW50Q29uZmlnOgogIG1lcmdlQ29u" + - "ZmlnOiB8CiAgICBjbHVzdGVyOgogICAgICB2YWxpZGF0aW9uUG9saWN5OgogICAgICAgIG5hbWU6" + - "IFVucmVzdHJpY3RlZAogICAgd29ya2xvYWQ6CiAgICAgIHN0YXJnYXRlUVVJQ0luc2VjdXJlOiB0" + - "cnVlCmBgYAoKVXNlIGByZXBsaWNhQ291bnQ6IDFgIG9ubHkgZm9yIGxvY2FsIG9yIHNpbmdsZS1u" + - "b2RlIHRlc3QgY2x1c3RlcnMuIEZvciBzaGFyZWQKb3IgcHJvZHVjdGlvbiBjbHVzdGVycywgdXNl" + - "IHRoZSByZXF1aXJlZCByZXBsaWNhIGNvdW50IGFuZCBUTFMtY2FwYWJsZSBzZXJ2aWNlCmNvbmZp" + - "Z3VyYXRpb24uIGBhZGRvbnMubGxtLmdhdGV3YXkuYXV0aC5ncnBjSW5zZWN1cmVgIGFuZApgd29y" + - "a2xvYWQuc3RhcmdhdGVRVUlDSW5zZWN1cmVgIGVuYWJsZSBwbGFpbnRleHQgdHJhbnNwb3J0cy4g" + - "RG8gbm90IHVzZSB0aGVtIGluCnByb2R1Y3Rpb24uCgpUaGUgcmVxdWVzdCByb3V0ZXIgdXNlcyBg" + - "cG93ZXItb2YtdHdvYCB3aGVuIG5vIGxvYWQtYmFsYW5jZXIgY29uZmlndXJhdGlvbiBpcwpzZXQu" + - "IENvbmZpZ3VyZSBvdGhlciByb3V0aW5nIG1ldGhvZHMgd2l0aCB0aGUKW0xMTSBSZXF1ZXN0IFJv" + - "dXRlciBMb2FkIEJhbGFuY2luZ10oaHR0cHM6Ly9naXRodWIuY29tL05WSURJQS9udmNmL2Jsb2Iv" + - "bWFpbi9kb2NzL3VzZXIvbGxtLXJlcXVlc3Qtcm91dGVyLWxvYWQtYmFsYW5jaW5nLm1kKQpndWlk" + - "ZS4KCklmIHRoZSBzaWRlY2FyIGltYWdlIGlzIG1pcnJvcmVkIG91dHNpZGUgdGhlIHN0YWNrJ3Mg" + - "ZGVmYXVsdCBpbWFnZSByZWdpc3RyeSBhbmQKcmVwb3NpdG9yeSwgc2V0IHRoZSBnZW5lcmF0ZWQg" + - "d29ya2VyIHNpZGVjYXIgaW1hZ2UgZXhwbGljaXRseToKCmBgYHlhbWwKYXBpOgogIGVudjoKICAg" + - "IE5WQ0ZfU0lERUNBUlNfTExNX1JPVVRFUl9DTElFTlRfSU1BR0U6IDxyZWdpc3RyeT4vPHJlcG9z" + - "aXRvcnk+L3B5bG9uOjAuMi4xCmBgYAoKUmVuZGVyIGFuZCBhcHBseSB0aGUgdXBkYXRlZCBjb250" + - "cm9sLXBsYW5lIGVudmlyb25tZW50LCB0aGVuIHJlZnJlc2ggZXZlcnkKcmVnaXN0ZXJlZCBjb21w" + - "dXRlIHBsYW5lIHVzaW5nIHRoZSBzYW1lIGhhbmRvZmYgdXNlZCBmb3IgaXRzIGluc3RhbGxhdGlv" + - "biBzbwpOVkNBIHJlY2VpdmVzIGBhZ2VudENvbmZpZy5tZXJnZUNvbmZpZ2A6CgpgYGBiYXNoCkhF" + - "TE1GSUxFX0VOVj08ZW52PiBoZWxtZmlsZSB0ZW1wbGF0ZQpIRUxNRklMRV9FTlY9PGVudj4gaGVs" + - "bWZpbGUgc3luYwpgYGAKClVzZSB0aGUgY29tcGxldGUgY29tcHV0ZS1wbGFuZSBpbnN0YWxsIGNv" + - "bW1hbmQgZnJvbQpbU3BsaXQgQ29tcHV0ZS1QbGFuZSBJbnN0YWxsYXRpb25dKGNvbXB1dGUtcGxh" + - "bmUtaW5zdGFsbGF0aW9uLm1kKS4gQQpDTEktcHJvZmlsZSBpbnN0YWxsYXRpb24gbXVzdCByZW1h" + - "aW4gcHJvZmlsZS1kcml2ZW47IGEgSGVsbWZpbGUgaW5zdGFsbGF0aW9uCm11c3QgcmVtYWluIHZh" + - "bHVlcy1kcml2ZW4uCgpFeGlzdGluZyBMTE0gZnVuY3Rpb24gcG9kcyBrZWVwIHRoZWlyIGV4aXN0" + - "aW5nIHNpZGVjYXIgYXJndW1lbnRzLiBSZWNyZWF0ZSBvcgpyZWRlcGxveSB0aG9zZSBmdW5jdGlv" + - "bnMgYWZ0ZXIgdGhlIGNvbXB1dGUtcGxhbmUgcmVmcmVzaC4gVmVyaWZ5IHRoZSBjb250cm9sCnBs" + - "YW5lLCByb3V0ZSwgYW5kIHdvcmtlciBzaWRlY2FyOgoKYGBgYmFzaAprdWJlY3RsIGdldCBkZXBs" + - "b3kgLW4gbnZjZiBsbG0tYXBpLWdhdGV3YXkKa3ViZWN0bCBnZXQgc3RhdGVmdWxzZXQgLW4gbnZj" + - "ZiBsbG0tcmVxdWVzdC1yb3V0ZXIKa3ViZWN0bCBnZXQgcG9kcyAtbiBudmNmIHwgZ3JlcCAtRSAn" + - "bGxtLWFwaS1nYXRld2F5fGxsbS1yZXF1ZXN0LXJvdXRlcicKa3ViZWN0bCBnZXQgaHR0cHJvdXRl" + - "IC1BIHwgZ3JlcCBsbG0Ka3ViZWN0bCAtbiBudmNmLWJhY2tlbmQgZ2V0IHBvZCA8ZnVuY3Rpb24t" + - "cG9kPiBcCiAgLW8ganNvbnBhdGg9J3tyYW5nZSAuc3BlYy5jb250YWluZXJzWz8oQC5uYW1lPT0i" + - "bGxtLXdvcmtlciIpXS5hcmdzWypdfXsufXsiXFxuIn17ZW5kfScKYGBgCgpGb3IgbG9jYWwgcGxh" + - "aW50ZXh0IGNsdXN0ZXJzLCB0aGUgYGxsbS13b3JrZXJgIGFyZ3MgbXVzdCBpbmNsdWRlCmAtLXF1" + - "aWMtaW5zZWN1cmVgLgoKRm9yIGxvYWQtYmFsYW5jZXIgc2NoZW1hIGFuZCBhbGdvcml0aG0gYmVo" + - "YXZpb3IsIHNlZSB0aGUKW1N0YXJnYXRlIGNvbmZpZ3VyYXRpb24gZ3VpZGVdKGh0dHBzOi8vZ2l0" + - "aHViLmNvbS9OVklESUEvbnZjZi9ibG9iL21haW4vc3JjL2xpYnJhcmllcy9ydXN0L3N0YXJnYXRl" + - "L2RvY3MvbG9hZC1iYWxhbmNlci1jb25maWd1cmF0aW9uLm1kKS4KCiMjIEhlbG1maWxlIFNlbGVj" + - "dG9ycwoKVGFyZ2V0IHNwZWNpZmljIHJlbGVhc2VzIG9yIGdyb3VwczoKCmBgYGJhc2gKIyBCeSBy" + - "ZWxlYXNlIGdyb3VwCkhFTE1GSUxFX0VOVj08ZW52PiBoZWxtZmlsZSAtLXNlbGVjdG9yIHJlbGVh" + - "c2UtZ3JvdXA9ZGVwZW5kZW5jaWVzIHN5bmMKSEVMTUZJTEVfRU5WPTxlbnY+IGhlbG1maWxlIC0t" + - "c2VsZWN0b3IgcmVsZWFzZS1ncm91cD1zZXJ2aWNlcyBzeW5jCkhFTE1GSUxFX0VOVj08ZW52PiBo" + - "ZWxtZmlsZSAtLXNlbGVjdG9yIHJlbGVhc2UtZ3JvdXA9aW5ncmVzcyBzeW5jCkhFTE1GSUxFX0VO" + - "Vj08ZW52PiBoZWxtZmlsZSAtLXNlbGVjdG9yIHJlbGVhc2UtZ3JvdXA9b2JzZXJ2YWJpbGl0eSBz" + - "eW5jCgojIEJ5IHJlbGVhc2UgbmFtZQpIRUxNRklMRV9FTlY9PGVudj4gaGVsbWZpbGUgLS1zZWxl" + - "Y3RvciBuYW1lPWNhc3NhbmRyYSBzeW5jCkhFTE1GSUxFX0VOVj08ZW52PiBoZWxtZmlsZSAtLXNl" + - "bGVjdG9yIG5hbWU9YWRtaW4taXNzdWVyLXByb3h5IHN5bmMKSEVMTUZJTEVfRU5WPTxlbnY+IGhl" + - "bG1maWxlIC0tc2VsZWN0b3IgbmFtZT1sbG0tcmVxdWVzdC1yb3V0ZXIgc3luYwpIRUxNRklMRV9F" + - "TlY9PGVudj4gaGVsbWZpbGUgLS1zZWxlY3RvciBuYW1lPWxsbS1hcGktZ2F0ZXdheSBzeW5jCgoj" + - "IFRlbXBsYXRlIG9ubHkgKGRyeSBydW4pCkhFTE1GSUxFX0VOVj08ZW52PiBoZWxtZmlsZSAtLXNl" + - "bGVjdG9yIG5hbWU9Y2Fzc2FuZHJhIHRlbXBsYXRlCgojIERlc3Ryb3kgYSBzaW5nbGUgcmVsZWFz" + - "ZQpIRUxNRklMRV9FTlY9PGVudj4gaGVsbWZpbGUgLS1zZWxlY3RvciBuYW1lPWNhc3NhbmRyYSBk" + - "ZXN0cm95CmBgYAoKTm90ZTogYGFkbWluLWlzc3Vlci1wcm94eWAgaGFzIG5vIGByZWxlYXNlLWdy" + - "b3VwYCBsYWJlbC4gVXNlIGAtLXNlbGVjdG9yIG5hbWU9YWRtaW4taXNzdWVyLXByb3h5YC4KUEsH" + - "CMBWIOePJwAAjycAAFBLAwQUAAgAAAAAACEAAAAAAAAAAAAAAAAAPwAJAGRhdGEvbnZjZi1zZWxm" + - "LW1hbmFnZWQtaW5zdGFsbGF0aW9uL3JlZmVyZW5jZXMvbnZjZi11aS1hZGRvbi5tZFVUBQABAKbO" + - "EiMgTlZDRiBVSSBBZGRvbgoKTlZDRiBVSSBpcyBhbiBvcHRpb25hbCwgY3VzdG9tZXItZmFjaW5n" + - "IE5WQ0YgYWRtaW4tcGFuZWwgVUkuIEl0IGlzIGRpc2FibGVkIGJ5CmRlZmF1bHQgYW5kIGF2YWls" + - "YWJsZSBvbmx5IGluIHN0YWNrIHBhY2thZ2VzIHRoYXQgaW5jbHVkZSB0aGUgTlZDRiBVSSBhZGRv" + - "bi4KCiMjIFdoZW4gdG8gZW5hYmxlCgpFbmFibGUgTlZDRiBVSSBvbmx5IHdoZW4geW91IG5lZWQg" + - "dGhlIGFkbWluLXBhbmVsIFVJIGFuZCB5b3VyIGV4dHJhY3RlZCBzdGFjawpwYWNrYWdlIGluY2x1" + - "ZGVzIHRoZSBhZGRvbi4gSWYgdGhlIHBhY2thZ2UgZG9lcyBub3QgY29udGFpbiBhIGBudmNmLXVp" + - "YCByZWxlYXNlCmFuZCBgbnZjZlVpYCByb3V0ZSB2YWx1ZXMsIHNraXAgdGhlIGFkZG9uIHVudGls" + - "IHlvdSB1c2UgYSBwYWNrYWdlIHRoYXQgaW5jbHVkZXMKdGhlbS4KCiMjIEVuYWJsZSB0aGUgYWRk" + - "b24KCkVuYWJsZSBpdCBpbiBgZW52aXJvbm1lbnRzLzxlbnYtbmFtZT4ueWFtbGA6CgpgYGB5YW1s" + - "CmFkZG9uczoKICBudmNmVWk6CiAgICBlbmFibGVkOiB0cnVlCmBgYAoKIyMgQ3JlYXRlIG5hbWVz" + - "cGFjZSBhbmQgaW1hZ2UgcHVsbCBzZWNyZXQKCkNyZWF0ZSB0aGUgbmFtZXNwYWNlLCBhbmQgYW4g" + - "aW1hZ2UgcHVsbCBzZWNyZXQgb25seSBpZiBwdWxsaW5nIGZyb20gYSBwcml2YXRlCnJlZ2lzdHJ5" + - "OgoKYGBgYmFzaAprdWJlY3RsIGNyZWF0ZSBuYW1lc3BhY2UgbnZjZi11aSAtLWRyeS1ydW49Y2xp" + - "ZW50IC1vIHlhbWwgfCBrdWJlY3RsIGFwcGx5IC1mIC0KCiMgT25seSBpZiBwdWxsaW5nIGZyb20g" + - "YSBwcml2YXRlIHJlZ2lzdHJ5IChlLmcuLCBOR0MgbnZjci5pbykKZXhwb3J0IE5HQ19BUElfS0VZ" + - "PSI8eW91ci1rZXk+IgprdWJlY3RsIGNyZWF0ZSBzZWNyZXQgZG9ja2VyLXJlZ2lzdHJ5IG52Y3It" + - "Y3JlZHMgXAogIC0tZG9ja2VyLXNlcnZlcj1udmNyLmlvIFwKICAtLWRvY2tlci11c2VybmFtZT0n" + - "JG9hdXRodG9rZW4nIFwKICAtLWRvY2tlci1wYXNzd29yZD0iJE5HQ19BUElfS0VZIiBcCiAgLS1u" + - "YW1lc3BhY2U9bnZjZi11aSBcCiAgLS1kcnktcnVuPWNsaWVudCAtbyB5YW1sIHwga3ViZWN0bCBh" + - "cHBseSAtZiAtCmBgYAoKVGhlIGRlZmF1bHQgcm91dGUgaG9zdCBpcyBgbnZjZi11aS48ZG9tYWlu" + - "PmAgYW5kIHRoZSBiYWNrZW5kIGlzCmBudmNmLXVpLm52Y2YtdWk6ODMwMGAuCgojIyBBcHBseSB0" + - "aGUgc2VydmljZSBhbmQgcm91dGUKCkFmdGVyIGNvbmZpcm1pbmcgdGhlIHBhY2thZ2UgaW5jbHVk" + - "ZXMgdGhlIGBudmNmLXVpYCByZWxlYXNlLCBwcmV2aWV3IGFuZCBhcHBseQp0aGUgc2VydmljZSBh" + - "bmQgcm91dGU6CgpgYGBiYXNoCkhFTE1GSUxFX0VOVj08ZW52LW5hbWU+IGhlbG1maWxlIC0tc2Vs" + - "ZWN0b3IgbmFtZT1udmNmLXVpIHRlbXBsYXRlCkhFTE1GSUxFX0VOVj08ZW52LW5hbWU+IGhlbG1m" + - "aWxlIC0tc2VsZWN0b3IgbmFtZT1udmNmLXVpIHN5bmMKSEVMTUZJTEVfRU5WPTxlbnYtbmFtZT4g" + - "aGVsbWZpbGUgLS1zZWxlY3RvciByZWxlYXNlLWdyb3VwPWluZ3Jlc3Mgc3luYwpgYGAKCiMjIFZl" + - "cmlmeQoKVmVyaWZ5IHRoZSByb3V0ZSBvbmx5IHdoZW4gdGhlIGFkZG9uIGlzIHByZXNlbnQgYW5k" + - "IGVuYWJsZWQ6CgpgYGBiYXNoCmt1YmVjdGwgZ2V0IGRlcGxveSxzdmMgLW4gbnZjZi11aQprdWJl" + - "Y3RsIGdldCBodHRwcm91dGUgLUEgfCBncmVwIC1pIG52Y2YtdWkKY3VybCAtaSAtSCAiSG9zdDog" + - "bnZjZi11aS48ZG9tYWluPiIgImh0dHA6Ly88Z2F0ZXdheS1hZGRyZXNzPi9zdGF0dXMiCmBgYAoK" + - "IyMgU2VjdXJpdHkKClRoZSBOVkNGIFVJIGFkbWluIHBhbmVsIGlzIGN1cnJlbnRseSB1bmF1dGhl" + - "bnRpY2F0ZWQuIERvIG5vdCBleHBvc2UgaXQgdG8gdGhlCnB1YmxpYyBpbnRlcm5ldC4gUmVzdHJp" + - "Y3QgYWNjZXNzIHRvIGEgdHJ1c3RlZCBuZXR3b3JrLCBWUE4sIG9yIGFuIGF1dGhlbnRpY2F0aW5n" + - "CnByb3h5IGluIGZyb250IG9mIHRoZSBgbnZjZi11aWAgcm91dGUuClBLBwg4+SevuQcAALkHAABQ" + - "SwMEFAAIAAAAAAAhAAAAAAAAAAAAAAAAAD4ACQBkYXRhL252Y2Ytc2VsZi1tYW5hZ2VkLWluc3Rh" + - "bGxhdGlvbi9yZWZlcmVuY2VzL3B1bGwtc2VjcmV0cy5tZFVUBQABAKbOEiMgSW1hZ2UgUHVsbCBT" + - "ZWNyZXRzIFJlZmVyZW5jZQoKIyMgT3ZlcnZpZXcKCldoZW4gcHVsbGluZyBOVkNGIGltYWdlcyBm" + - "cm9tIGEgcHJpdmF0ZSByZWdpc3RyeSAoZm9yIGV4YW1wbGUsIE5HQwpgbnZjci5pb2ApLCBLdWJl" + - "cm5ldGVzIG5lZWRzIGBpbWFnZVB1bGxTZWNyZXRzYCBvbiBldmVyeSBwb2QuIENvbnRyb2wtcGxh" + - "bmUgYW5kCmNvbXB1dGUtcGxhbmUgY3JlZGVudGlhbHMgYXJlIGNvbmZpZ3VyZWQgaW4gdGhlaXIg" + - "b3duIGNsdXN0ZXIgY29udGV4dHMuIERvIG5vdAp1c2Ugb25lIG1peGVkIG5hbWVzcGFjZSBsaXN0" + - "LgoKVGhlIHJlY29tbWVuZGVkIGNvbnRyb2wtcGxhbmUgYXBwcm9hY2ggdXNlcyBLeXZlcm5vIHRv" + - "IGluamVjdCB0aGUgc2VjcmV0IGludG8KY29udHJvbC1wbGFuZSBwb2RzIGF0IGFkbWlzc2lvbiB0" + - "aW1lLiBUaGUgY29tcHV0ZS1wbGFuZSBjaGFydCBhbmQgb3BlcmF0b3IgdXNlCnRoZSBzZWNyZXQg" + - "aW4gYG52Y2Etb3BlcmF0b3JgIGFuZCBtaXJyb3IgaXQgdG8gYG52Y2Etc3lzdGVtYC4KCiMjIEt5" + - "dmVybm8gQXBwcm9hY2ggKFJlY29tbWVuZGVkKQoKIyMjIDEuIEluc3RhbGwgS3l2ZXJubwoKYGBg" + - "YmFzaApoZWxtIHJlcG8gYWRkIGt5dmVybm8gaHR0cHM6Ly9reXZlcm5vLmdpdGh1Yi5pby9reXZl" + - "cm5vLwpoZWxtIHJlcG8gdXBkYXRlCmhlbG0gaW5zdGFsbCBreXZlcm5vIGt5dmVybm8va3l2ZXJu" + - "byAtbiBreXZlcm5vIC0tY3JlYXRlLW5hbWVzcGFjZSBcCiAgLS1rdWJlLWNvbnRleHQgPGNvbnRy" + - "b2wtcGxhbmUtY29udGV4dD4KYGBgCgojIyMgMi4gQ3JlYXRlIGNvbnRyb2wtcGxhbmUgcHVsbCBz" + - "ZWNyZXRzCgpgYGBiYXNoCmV4cG9ydCBOR0NfQVBJX0tFWT0iPHlvdXItbmdjLWFwaS1rZXk+IgoK" + - "Zm9yIG5zIGluIGNhc3NhbmRyYS1zeXN0ZW0gbmF0cy1zeXN0ZW0gbnZjZiBhcGkta2V5cyBlc3Mg" + - "c2lzIHZhdWx0LXN5c3RlbSBjZXJ0LW1hbmFnZXI7IGRvCiAga3ViZWN0bCAtLWNvbnRleHQgPGNv" + - "bnRyb2wtcGxhbmUtY29udGV4dD4gY3JlYXRlIG5hbWVzcGFjZSAiJG5zIiBcCiAgICAtLWRyeS1y" + - "dW49Y2xpZW50IC1vIHlhbWwgfCBrdWJlY3RsIC0tY29udGV4dCA8Y29udHJvbC1wbGFuZS1jb250" + - "ZXh0PiBhcHBseSAtZiAtCmRvbmUKCmZvciBucyBpbiBjYXNzYW5kcmEtc3lzdGVtIG5hdHMtc3lz" + - "dGVtIG52Y2YgYXBpLWtleXMgZXNzIHNpcyB2YXVsdC1zeXN0ZW0gY2VydC1tYW5hZ2VyOyBkbwog" + - "IGt1YmVjdGwgLS1jb250ZXh0IDxjb250cm9sLXBsYW5lLWNvbnRleHQ+IGNyZWF0ZSBzZWNyZXQg" + - "ZG9ja2VyLXJlZ2lzdHJ5IG52Y3ItY3JlZHMgXAogICAgLS1kb2NrZXItc2VydmVyPW52Y3IuaW8g" + - "XAogICAgLS1kb2NrZXItdXNlcm5hbWU9JyRvYXV0aHRva2VuJyBcCiAgICAtLWRvY2tlci1wYXNz" + - "d29yZD0iJE5HQ19BUElfS0VZIiBcCiAgICAtLW5hbWVzcGFjZT0iJG5zIiBcCiAgICAtLWRyeS1y" + - "dW49Y2xpZW50IC1vIHlhbWwgfCBrdWJlY3RsIC0tY29udGV4dCA8Y29udHJvbC1wbGFuZS1jb250" + - "ZXh0PiBhcHBseSAtZiAtCmRvbmUKYGBgCgpGb3Igbm9uLU5HQyByZWdpc3RyaWVzLCByZXBsYWNl" + - "IGAtLWRvY2tlci1zZXJ2ZXJgLCBgLS1kb2NrZXItdXNlcm5hbWVgLCBhbmQgYC0tZG9ja2VyLXBh" + - "c3N3b3JkYC4KCiMjIyAzLiBBcHBseSBLeXZlcm5vIENsdXN0ZXJQb2xpY3kKCmBgYHlhbWwKYXBp" + - "VmVyc2lvbjoga3l2ZXJuby5pby92MQpraW5kOiBDbHVzdGVyUG9saWN5Cm1ldGFkYXRhOgogIG5h" + - "bWU6IG52Y2YtYWRkLWltYWdlcHVsbHNlY3JldHMKc3BlYzoKICBiYWNrZ3JvdW5kOiBmYWxzZQog" + - "IHJ1bGVzOgogICAgLSBuYW1lOiBhZGQtaW1hZ2VwdWxsc2VjcmV0LXRvLW52Y2YtcG9kcwogICAg" + - "ICBtYXRjaDoKICAgICAgICBhbnk6CiAgICAgICAgLSByZXNvdXJjZXM6CiAgICAgICAgICAgIGtp" + - "bmRzOgogICAgICAgICAgICAtIFBvZAogICAgICAgICAgICBuYW1lc3BhY2VzOgogICAgICAgICAg" + - "ICAtICJudmNmIgogICAgICAgICAgICAtICJhcGkta2V5cyIKICAgICAgICAgICAgLSAic2lzIgog" + - "ICAgICAgICAgICAtICJlc3MiCiAgICAgICAgICAgIC0gIm5hdHMtc3lzdGVtIgogICAgICAgICAg" + - "ICAtICJjYXNzYW5kcmEtc3lzdGVtIgogICAgICAgICAgICAtICJ2YXVsdC1zeXN0ZW0iCiAgICAg" + - "ICAgICAgIC0gImNlcnQtbWFuYWdlciIKICAgICAgbXV0YXRlOgogICAgICAgIHBhdGNoU3RyYXRl" + - "Z2ljTWVyZ2U6CiAgICAgICAgICBtZXRhZGF0YToKICAgICAgICAgICAgYW5ub3RhdGlvbnM6CiAg" + - "ICAgICAgICAgICAgbnZjZi5udmlkaWEuY29tL2ltYWdlcHVsbHNlY3JldC1pbmplY3RlZC1ieTog" + - "a3l2ZXJubwogICAgICAgICAgc3BlYzoKICAgICAgICAgICAgaW1hZ2VQdWxsU2VjcmV0czoKICAg" + - "ICAgICAgICAgLSBuYW1lOiBudmNyLWNyZWRzCmBgYAoKYGBgYmFzaAprdWJlY3RsIC0tY29udGV4" + - "dCA8Y29udHJvbC1wbGFuZS1jb250ZXh0PiBhcHBseSBcCiAgLWYga3l2ZXJuby1pbWFnZXB1bGxz" + - "ZWNyZXQtcG9saWN5LnlhbWwKYGBgCgojIyMgNC4gSW5zdGFsbCB0aGUgY29udHJvbCBwbGFuZQoK" + - "Q29udGludWUgd2l0aCB0aGUgc2VsZWN0ZWQgY29udHJvbC1wbGFuZSBpbnN0YWxsYXRpb24gaW4K" + - "W1NwbGl0IENvbXB1dGUtUGxhbmUgSW5zdGFsbGF0aW9uXShjb21wdXRlLXBsYW5lLWluc3RhbGxh" + - "dGlvbi5tZCkuIE5vCmNvbnRyb2wtcGxhbmUgaGVsbWZpbGUgbW9kaWZpY2F0aW9ucyBhcmUgbmVl" + - "ZGVkLiBLeXZlcm5vIGluamVjdHMgdGhlIHB1bGwKc2VjcmV0IGludG8gbmV3IGNvbnRyb2wtcGxh" + - "bmUgcG9kcy4KCiMjIENvbXB1dGUtUGxhbmUgU2VjcmV0CgpDcmVhdGUgdGhlIHNlY3JldCBvbmx5" + - "IGluIGBudmNhLW9wZXJhdG9yYCBvbiB0aGUgY29tcHV0ZSBjbHVzdGVyOgoKYGBgYmFzaAprdWJl" + - "Y3RsIC0tY29udGV4dCA8Y29tcHV0ZS1wbGFuZS1jb250ZXh0PiBjcmVhdGUgbmFtZXNwYWNlIG52" + - "Y2Etb3BlcmF0b3IgXAogIC0tZHJ5LXJ1bj1jbGllbnQgLW8geWFtbCB8IFwKICBrdWJlY3RsIC0t" + - "Y29udGV4dCA8Y29tcHV0ZS1wbGFuZS1jb250ZXh0PiBhcHBseSAtZiAtCgprdWJlY3RsIC0tY29u" + - "dGV4dCA8Y29tcHV0ZS1wbGFuZS1jb250ZXh0PiBjcmVhdGUgc2VjcmV0IGRvY2tlci1yZWdpc3Ry" + - "eSBudmNyLWNyZWRzIFwKICAtLWRvY2tlci1zZXJ2ZXI9bnZjci5pbyBcCiAgLS1kb2NrZXItdXNl" + - "cm5hbWU9JyRvYXV0aHRva2VuJyBcCiAgLS1kb2NrZXItcGFzc3dvcmQ9IiROR0NfQVBJX0tFWSIg" + - "XAogIC0tbmFtZXNwYWNlPW52Y2Etb3BlcmF0b3IgXAogIC0tZHJ5LXJ1bj1jbGllbnQgLW8geWFt" + - "bCB8IFwKICBrdWJlY3RsIC0tY29udGV4dCA8Y29tcHV0ZS1wbGFuZS1jb250ZXh0PiBhcHBseSAt" + - "ZiAtCmBgYAoKUmVmZXJlbmNlIGl0IGluIHRoZSBjb21wdXRlLXBsYW5lIGVudmlyb25tZW50IGZp" + - "bGU6CgpgYGB5YW1sCmdsb2JhbDoKICBpbWFnZVB1bGxTZWNyZXRzOgogICAgLSBuYW1lOiBudmNy" + - "LWNyZWRzCmBgYAoKVGhlIGNoYXJ0IGFuZCBvcGVyYXRvciB1c2UgdGhhdCByZWZlcmVuY2UgaW4g" + - "YG52Y2Etb3BlcmF0b3JgIGFuZCBtaXJyb3IgdGhlCnNlY3JldCB0byBgbnZjYS1zeXN0ZW1gLiBE" + - "byBub3QgY3JlYXRlIGEgYnJvYWRlciBtYW51YWwgY29tcHV0ZSBuYW1lc3BhY2UgbGlzdC4gRm9s" + - "bG93CltTcGxpdCBDb21wdXRlLVBsYW5lIEluc3RhbGxhdGlvbl0oY29tcHV0ZS1wbGFuZS1pbnN0" + - "YWxsYXRpb24ubWQpIGZvciB0aGUKc2VsZWN0ZWQgaW5zdGFsbCBmbG93LgoKIyMgVmVyaWZpY2F0" + - "aW9uCgpgYGBiYXNoCiMgQ2hlY2sgdGhhdCBhIGNvbnRyb2wtcGxhbmUgcG9kIGhhcyB0aGUgaW5q" + - "ZWN0ZWQgc2VjcmV0Cmt1YmVjdGwgLS1jb250ZXh0IDxjb250cm9sLXBsYW5lLWNvbnRleHQ+IGdl" + - "dCBwb2QgLW4gPG5hbWVzcGFjZT4gPHBvZC1uYW1lPiBcCiAgLW8ganNvbnBhdGg9J3suc3BlYy5p" + - "bWFnZVB1bGxTZWNyZXRzfScKIyBFeHBlY3RlZDogW3sibmFtZSI6Im52Y3ItY3JlZHMifV0KCiMg" + - "Q2hlY2sgdGhlIEt5dmVybm8gYW5ub3RhdGlvbgprdWJlY3RsIC0tY29udGV4dCA8Y29udHJvbC1w" + - "bGFuZS1jb250ZXh0PiBnZXQgcG9kIC1uIDxuYW1lc3BhY2U+IDxwb2QtbmFtZT4gXAogIC1vIGpz" + - "b25wYXRoPSd7Lm1ldGFkYXRhLmFubm90YXRpb25zLm52Y2ZcLm52aWRpYVwuY29tL2ltYWdlcHVs" + - "bHNlY3JldC1pbmplY3RlZC1ieX0nCiMgRXhwZWN0ZWQ6IGt5dmVybm8KCiMgQ2hlY2sgcHVsbCBl" + - "dmVudHMKa3ViZWN0bCAtLWNvbnRleHQgPGNvbnRyb2wtcGxhbmUtY29udGV4dD4gZ2V0IGV2ZW50" + - "cyAtbiA8bmFtZXNwYWNlPiBcCiAgLS1zb3J0LWJ5PScubGFzdFRpbWVzdGFtcCcgfCBncmVwIC1p" + - "IHB1bGwKIyBTaG91bGQgc2hvdyAiU3VjY2Vzc2Z1bGx5IHB1bGxlZCIgbm90ICI0MDEgVW5hdXRo" + - "b3JpemVkIgoKIyBDaGVjayB0aGUgY2hhcnQvb3BlcmF0b3IgbWlycm9yIG9uIHRoZSBjb21wdXRl" + - "IGNsdXN0ZXIKa3ViZWN0bCAtLWNvbnRleHQgPGNvbXB1dGUtcGxhbmUtY29udGV4dD4gZ2V0IHNl" + - "Y3JldCBudmNyLWNyZWRzIFwKICAtbiBudmNhLXN5c3RlbQpgYGAKCiMjIFdoZW4gUHVsbCBTZWNy" + - "ZXRzIEFyZSBOb3QgTmVlZGVkCgotICoqQVdTIEVDUiB3aXRoIElBTSBub2RlIHJvbGVzKio6IElm" + - "IHlvdXIgbm9kZXMgaGF2ZSBgQW1hem9uRUMyQ29udGFpbmVyUmVnaXN0cnlSZWFkT25seWAgSUFN" + - "IHBvbGljeSwgS3ViZXJuZXRlcyBjYW4gcHVsbCBmcm9tIEVDUiB3aXRob3V0IGV4cGxpY2l0IHNl" + - "Y3JldHMuCi0gKipQdWJsaWMgcmVnaXN0cmllcyoqOiBObyBwdWxsIHNlY3JldHMgbmVlZGVkLgot" + - "ICoqQ1NQIGJ1aWx0LWluIGNyZWRlbnRpYWwgaGVscGVycyoqOiBHS0UgQXJ0aWZhY3QgUmVnaXN0" + - "cnksIEF6dXJlIEFDUiB3aXRoIG1hbmFnZWQgaWRlbnRpdHksIGFuZCBzaW1pbGFyIHNlcnZpY2Vz" + - "LgoKIyMgVHJvdWJsZXNob290aW5nCgojIyMgUG9kcyBzdGlsbCBpbiBJbWFnZVB1bGxCYWNrT2Zm" + - "IGFmdGVyIGFwcGx5aW5nIHBvbGljeQoKVGhlIEt5dmVybm8gcG9saWN5IG9ubHkgYWZmZWN0cyBw" + - "b2RzIGNyZWF0ZWQgKiphZnRlcioqIHRoZSBwb2xpY3kgaXMgYXBwbGllZC4gRGVsZXRlIHN0dWNr" + - "IHBvZHMgdG8gdHJpZ2dlciByZWNyZWF0aW9uOgoKYGBgYmFzaAprdWJlY3RsIC0tY29udGV4dCA8" + - "dGFyZ2V0LWNvbnRleHQ+IGRlbGV0ZSBwb2RzIC1uIDxuYW1lc3BhY2U+IC0tYWxsCmBgYAoKIyMj" + - "IEt5dmVybm8gYWRtaXNzaW9uIGNvbnRyb2xsZXIgbm90IHJ1bm5pbmcKCmBgYGJhc2gKa3ViZWN0" + - "bCAtLWNvbnRleHQgPGNvbnRyb2wtcGxhbmUtY29udGV4dD4gZ2V0IHBvZHMgLW4ga3l2ZXJubwoj" + - "IEFsbCBwb2RzIHNob3VsZCBiZSBSdW5uaW5nCmBgYAoKIyMjIFBvbGljeSBub3QgbWF0Y2hpbmcK" + - "CmBgYGJhc2gKa3ViZWN0bCAtLWNvbnRleHQgPGNvbnRyb2wtcGxhbmUtY29udGV4dD4gZ2V0IGNs" + - "dXN0ZXJwb2xpY3kgbnZjZi1hZGQtaW1hZ2VwdWxsc2VjcmV0cwojIFNob3VsZCBzaG93IFJFQURZ" + - "OiBUcnVlCmBgYAoKIyMjIFdyb25nIHNlY3JldCBuYW1lCgpUaGUgcG9saWN5IHJlZmVyZW5jZXMg" + - "YG52Y3ItY3JlZHNgLiBWZXJpZnkgdGhlIHNlY3JldCBleGlzdHMgd2l0aCB0aGF0IGV4YWN0IG5h" + - "bWU6CgpgYGBiYXNoCmt1YmVjdGwgLS1jb250ZXh0IDx0YXJnZXQtY29udGV4dD4gZ2V0IHNlY3Jl" + - "dCBudmNyLWNyZWRzIC1uIDxuYW1lc3BhY2U+CmBgYApQSwcIS0I1qAAWAAAAFgAAUEsBAhQAFAAI" + - "AAAAAAAhAIHcVxdKEAAAShAAABIACQAAAAAAAAAAAAAAAAAAAGRhdGEvbWFuaWZlc3QuanNvblVU" + - "BQABAKbOElBLAQIUABQACAAAAAAAIQDNgTDkTWEAAE1hAAAjAAkAAAAAAAAAAAAAAJMQAABkYXRh" + - "L252Y2Ytc2VsZi1tYW5hZ2VkLWNsaS9TS0lMTC5tZFVUBQABAKbOElBLAQIUABQACAAAAAAAIQAh" + - "xsiG8AoAAPAKAAAzAAkAAAAAAAAAAAAAADpyAABkYXRhL252Y2Ytc2VsZi1tYW5hZ2VkLWNsaS9l" + - "eGFtcGxlcy9jaS1waXBlbGluZXMubWRVVAUAAQCmzhJQSwECFAAUAAgAAAAAACEAoRTjgV0MAABd" + - "DAAANAAJAAAAAAAAAAAAAACUfQAAZGF0YS9udmNmLXNlbGYtbWFuYWdlZC1jbGkvZXhhbXBsZXMv" + - "bXVsdGktY2x1c3Rlci5tZFVUBQABAKbOElBLAQIUABQACAAAAAAAIQBCJ0kPBQ0AAAUNAAA3AAkA" + - "AAAAAAAAAAAAAFyKAABkYXRhL252Y2Ytc2VsZi1tYW5hZ2VkLWNsaS9wcm9tcHRzL2FkZC1jb21w" + - "dXRlLXBsYW5lLm1kVVQFAAEAps4SUEsBAhQAFAAIAAAAAAAhAJHcG/mYGQAAmBkAADkACQAAAAAA" + - "AAAAAAAAz5cAAGRhdGEvbnZjZi1zZWxmLW1hbmFnZWQtY2xpL3Byb21wdHMvY3JlYXRlLWFuZC1y" + - "dW4tdGFzay5tZFVUBQABAKbOElBLAQIUABQACAAAAAAAIQDSQ9wEGCUAABglAAA3AAkAAAAAAAAA" + - "AAAAANexAABkYXRhL252Y2Ytc2VsZi1tYW5hZ2VkLWNsaS9wcm9tcHRzL2RlcGxveS1hbmQtaW52" + - "b2tlLm1kVVQFAAEAps4SUEsBAhQAFAAIAAAAAAAhAA6cP5e9DgAAvQ4AAD0ACQAAAAAAAAAAAAAA" + - "XdcAAGRhdGEvbnZjZi1zZWxmLW1hbmFnZWQtY2xpL3Byb21wdHMvZGlhZ25vc2UtZmFpbGVkLWlu" + - "c3RhbGwubWRVVAUAAQCmzhJQSwECFAAUAAgAAAAAACEAQnHmHgEoAAABKAAAOgAJAAAAAAAAAAAA" + - "AACO5gAAZGF0YS9udmNmLXNlbGYtbWFuYWdlZC1jbGkvcHJvbXB0cy9pbnN0YWxsLWZyb20tc2Ny" + - "YXRjaC5tZFVUBQABAKbOElBLAQIUABQACAAAAAAAIQAaxCyexwcAAMcHAAA5AAkAAAAAAAAAAAAA" + - "AAAPAQBkYXRhL252Y2Ytc2VsZi1tYW5hZ2VkLWNsaS9wcm9tcHRzL3JvdGF0ZS1jbHVzdGVyLWp3" + - "a3MubWRVVAUAAQCmzhJQSwECFAAUAAgAAAAAACEAEpMzWeAhAADgIQAALgAJAAAAAAAAAAAAAAA3" + - "FwEAZGF0YS9udmNmLXNlbGYtbWFuYWdlZC1jbGkvcHJvbXB0cy90ZWFyZG93bi5tZFVUBQABAKbO" + - "ElBLAQIUABQACAAAAAAAIQByDQ9kISMAACEjAAAwAAkAAAAAAAAAAAAAAHw5AQBkYXRhL252Y2Yt" + - "c2VsZi1tYW5hZ2VkLWNsaS9yZWZlcmVuY2UvY29tbWFuZHMubWRVVAUAAQCmzhJQSwECFAAUAAgA" + - "AAAAACEAc6daZNUGAADVBgAAMgAJAAAAAAAAAAAAAAAEXQEAZGF0YS9udmNmLXNlbGYtbWFuYWdl" + - "ZC1jbGkvcmVmZXJlbmNlL2V4aXQtY29kZXMubWRVVAUAAQCmzhJQSwECFAAUAAgAAAAAACEAqM8f" + - "qDMoAAAzKAAALQAJAAAAAAAAAAAAAABCZAEAZGF0YS9udmNmLXNlbGYtbWFuYWdlZC1jbGkvcmVm" + - "ZXJlbmNlL2ZsYWdzLm1kVVQFAAEAps4SUEsBAhQAFAAIAAAAAAAhAPOuE4R0EQAAdBEAADcACQAA" + - "AAAAAAAAAAAA2YwBAGRhdGEvbnZjZi1zZWxmLW1hbmFnZWQtY2xpL3JlZmVyZW5jZS90cm91Ymxl" + - "c2hvb3RpbmcubWRVVAUAAQCmzhJQSwECFAAUAAgAAAAAACEAL9q5dUJiAABCYgAALAAJAAAAAAAA" + - "AAAAAAC7ngEAZGF0YS9udmNmLXNlbGYtbWFuYWdlZC1pbnN0YWxsYXRpb24vU0tJTEwubWRVVAUA" + - "AQCmzhJQSwECFAAUAAgAAAAAACEAKxO4P61VAACtVQAANAAJAAAAAAAAAAAAAABgAQIAZGF0YS9u" + - "dmNmLXNlbGYtbWFuYWdlZC1pbnN0YWxsYXRpb24vZXZhbHMvZXZhbHMuanNvblVUBQABAKbOElBL" + - "AQIUABQACAAAAAAAIQACUk5AfygAAH8oAAAvAAkAAAAAAAAAAAAAAHhXAgBkYXRhL252Y2Ytc2Vs" + - "Zi1tYW5hZ2VkLWluc3RhbGxhdGlvbi9leGFtcGxlcy5tZFVUBQABAKbOElBLAQIUABQACAAAAAAA" + - "IQCWY7xZEjAAABIwAABMAAkAAAAAAAAAAAAAAF2AAgBkYXRhL252Y2Ytc2VsZi1tYW5hZ2VkLWlu" + - "c3RhbGxhdGlvbi9yZWZlcmVuY2VzL2NvbXB1dGUtcGxhbmUtaW5zdGFsbGF0aW9uLm1kVVQFAAEA" + - "ps4SUEsBAhQAFAAIAAAAAAAhAFY+Z5CVMAAAlTAAADsACQAAAAAAAAAAAAAA8rACAGRhdGEvbnZj" + - "Zi1zZWxmLW1hbmFnZWQtaW5zdGFsbGF0aW9uL3JlZmVyZW5jZXMvZGVidWdnaW5nLm1kVVQFAAEA" + - "ps4SUEsBAhQAFAAIAAAAAAAhAMBWIOePJwAAjycAAEQACQAAAAAAAAAAAAAA+eECAGRhdGEvbnZj" + - "Zi1zZWxmLW1hbmFnZWQtaW5zdGFsbGF0aW9uL3JlZmVyZW5jZXMvaGVsbWZpbGUtc3RydWN0dXJl" + - "Lm1kVVQFAAEAps4SUEsBAhQAFAAIAAAAAAAhADj5J6+5BwAAuQcAAD8ACQAAAAAAAAAAAAAAAwoD" + - "AGRhdGEvbnZjZi1zZWxmLW1hbmFnZWQtaW5zdGFsbGF0aW9uL3JlZmVyZW5jZXMvbnZjZi11aS1h" + - "ZGRvbi5tZFVUBQABAKbOElBLAQIUABQACAAAAAAAIQBLQjWoABYAAAAWAAA+AAkAAAAAAAAAAAAA" + - "ADISAwBkYXRhL252Y2Ytc2VsZi1tYW5hZ2VkLWluc3RhbGxhdGlvbi9yZWZlcmVuY2VzL3B1bGwt" + - "c2VjcmV0cy5tZFVUBQABAKbOElBLBQYAAAAAFwAXAK8JAACnKAMAAAA=" + "CiAgICAtLWRyeS1ydW49Y2xpZW50IC1vIHlhbWwgfCBrdWJlY3RsIC0tY29udGV4dCA8Y29udHJv" + + "bC1wbGFuZS1jb250ZXh0PiBhcHBseSAtZiAtCmRvbmUKYGBgCgpGb3Igbm9uLU5HQyByZWdpc3Ry" + + "aWVzLCByZXBsYWNlIGAtLWRvY2tlci1zZXJ2ZXJgLCBgLS1kb2NrZXItdXNlcm5hbWVgLCBhbmQg" + + "YC0tZG9ja2VyLXBhc3N3b3JkYC4KCiMjIyAzLiBBcHBseSBLeXZlcm5vIENsdXN0ZXJQb2xpY3kK" + + "CmBgYHlhbWwKYXBpVmVyc2lvbjoga3l2ZXJuby5pby92MQpraW5kOiBDbHVzdGVyUG9saWN5Cm1l" + + "dGFkYXRhOgogIG5hbWU6IG52Y2YtYWRkLWltYWdlcHVsbHNlY3JldHMKc3BlYzoKICBiYWNrZ3Jv" + + "dW5kOiBmYWxzZQogIHJ1bGVzOgogICAgLSBuYW1lOiBhZGQtaW1hZ2VwdWxsc2VjcmV0LXRvLW52" + + "Y2YtcG9kcwogICAgICBtYXRjaDoKICAgICAgICBhbnk6CiAgICAgICAgLSByZXNvdXJjZXM6CiAg" + + "ICAgICAgICAgIGtpbmRzOgogICAgICAgICAgICAtIFBvZAogICAgICAgICAgICBuYW1lc3BhY2Vz" + + "OgogICAgICAgICAgICAtICJudmNmIgogICAgICAgICAgICAtICJhcGkta2V5cyIKICAgICAgICAg" + + "ICAgLSAic2lzIgogICAgICAgICAgICAtICJlc3MiCiAgICAgICAgICAgIC0gIm5hdHMtc3lzdGVt" + + "IgogICAgICAgICAgICAtICJjYXNzYW5kcmEtc3lzdGVtIgogICAgICAgICAgICAtICJ2YXVsdC1z" + + "eXN0ZW0iCiAgICAgICAgICAgIC0gImNlcnQtbWFuYWdlciIKICAgICAgbXV0YXRlOgogICAgICAg" + + "IHBhdGNoU3RyYXRlZ2ljTWVyZ2U6CiAgICAgICAgICBtZXRhZGF0YToKICAgICAgICAgICAgYW5u" + + "b3RhdGlvbnM6CiAgICAgICAgICAgICAgbnZjZi5udmlkaWEuY29tL2ltYWdlcHVsbHNlY3JldC1p" + + "bmplY3RlZC1ieToga3l2ZXJubwogICAgICAgICAgc3BlYzoKICAgICAgICAgICAgaW1hZ2VQdWxs" + + "U2VjcmV0czoKICAgICAgICAgICAgLSBuYW1lOiBudmNyLWNyZWRzCmBgYAoKYGBgYmFzaAprdWJl" + + "Y3RsIC0tY29udGV4dCA8Y29udHJvbC1wbGFuZS1jb250ZXh0PiBhcHBseSBcCiAgLWYga3l2ZXJu" + + "by1pbWFnZXB1bGxzZWNyZXQtcG9saWN5LnlhbWwKYGBgCgojIyMgNC4gSW5zdGFsbCB0aGUgY29u" + + "dHJvbCBwbGFuZQoKQ29udGludWUgd2l0aCB0aGUgc2VsZWN0ZWQgY29udHJvbC1wbGFuZSBpbnN0" + + "YWxsYXRpb24gaW4KW1NwbGl0IENvbXB1dGUtUGxhbmUgSW5zdGFsbGF0aW9uXShjb21wdXRlLXBs" + + "YW5lLWluc3RhbGxhdGlvbi5tZCkuIE5vCmNvbnRyb2wtcGxhbmUgaGVsbWZpbGUgbW9kaWZpY2F0" + + "aW9ucyBhcmUgbmVlZGVkLiBLeXZlcm5vIGluamVjdHMgdGhlIHB1bGwKc2VjcmV0IGludG8gbmV3" + + "IGNvbnRyb2wtcGxhbmUgcG9kcy4KCiMjIENvbXB1dGUtUGxhbmUgU2VjcmV0CgpDcmVhdGUgdGhl" + + "IHNlY3JldCBvbmx5IGluIGBudmNhLW9wZXJhdG9yYCBvbiB0aGUgY29tcHV0ZSBjbHVzdGVyOgoK" + + "YGBgYmFzaAprdWJlY3RsIC0tY29udGV4dCA8Y29tcHV0ZS1wbGFuZS1jb250ZXh0PiBjcmVhdGUg" + + "bmFtZXNwYWNlIG52Y2Etb3BlcmF0b3IgXAogIC0tZHJ5LXJ1bj1jbGllbnQgLW8geWFtbCB8IFwK" + + "ICBrdWJlY3RsIC0tY29udGV4dCA8Y29tcHV0ZS1wbGFuZS1jb250ZXh0PiBhcHBseSAtZiAtCgpr" + + "dWJlY3RsIC0tY29udGV4dCA8Y29tcHV0ZS1wbGFuZS1jb250ZXh0PiBjcmVhdGUgc2VjcmV0IGRv" + + "Y2tlci1yZWdpc3RyeSBudmNyLWNyZWRzIFwKICAtLWRvY2tlci1zZXJ2ZXI9bnZjci5pbyBcCiAg" + + "LS1kb2NrZXItdXNlcm5hbWU9JyRvYXV0aHRva2VuJyBcCiAgLS1kb2NrZXItcGFzc3dvcmQ9IiRO" + + "R0NfQVBJX0tFWSIgXAogIC0tbmFtZXNwYWNlPW52Y2Etb3BlcmF0b3IgXAogIC0tZHJ5LXJ1bj1j" + + "bGllbnQgLW8geWFtbCB8IFwKICBrdWJlY3RsIC0tY29udGV4dCA8Y29tcHV0ZS1wbGFuZS1jb250" + + "ZXh0PiBhcHBseSAtZiAtCmBgYAoKUmVmZXJlbmNlIGl0IGluIHRoZSBjb21wdXRlLXBsYW5lIGVu" + + "dmlyb25tZW50IGZpbGU6CgpgYGB5YW1sCmdsb2JhbDoKICBpbWFnZVB1bGxTZWNyZXRzOgogICAg" + + "LSBuYW1lOiBudmNyLWNyZWRzCmBgYAoKVGhlIGNoYXJ0IGFuZCBvcGVyYXRvciB1c2UgdGhhdCBy" + + "ZWZlcmVuY2UgaW4gYG52Y2Etb3BlcmF0b3JgIGFuZCBtaXJyb3IgdGhlCnNlY3JldCB0byBgbnZj" + + "YS1zeXN0ZW1gLiBEbyBub3QgY3JlYXRlIGEgYnJvYWRlciBtYW51YWwgY29tcHV0ZSBuYW1lc3Bh" + + "Y2UgbGlzdC4gRm9sbG93CltTcGxpdCBDb21wdXRlLVBsYW5lIEluc3RhbGxhdGlvbl0oY29tcHV0" + + "ZS1wbGFuZS1pbnN0YWxsYXRpb24ubWQpIGZvciB0aGUKc2VsZWN0ZWQgaW5zdGFsbCBmbG93LgoK" + + "IyMgVmVyaWZpY2F0aW9uCgpgYGBiYXNoCiMgQ2hlY2sgdGhhdCBhIGNvbnRyb2wtcGxhbmUgcG9k" + + "IGhhcyB0aGUgaW5qZWN0ZWQgc2VjcmV0Cmt1YmVjdGwgLS1jb250ZXh0IDxjb250cm9sLXBsYW5l" + + "LWNvbnRleHQ+IGdldCBwb2QgLW4gPG5hbWVzcGFjZT4gPHBvZC1uYW1lPiBcCiAgLW8ganNvbnBh" + + "dGg9J3suc3BlYy5pbWFnZVB1bGxTZWNyZXRzfScKIyBFeHBlY3RlZDogW3sibmFtZSI6Im52Y3It" + + "Y3JlZHMifV0KCiMgQ2hlY2sgdGhlIEt5dmVybm8gYW5ub3RhdGlvbgprdWJlY3RsIC0tY29udGV4" + + "dCA8Y29udHJvbC1wbGFuZS1jb250ZXh0PiBnZXQgcG9kIC1uIDxuYW1lc3BhY2U+IDxwb2QtbmFt" + + "ZT4gXAogIC1vIGpzb25wYXRoPSd7Lm1ldGFkYXRhLmFubm90YXRpb25zLm52Y2ZcLm52aWRpYVwu" + + "Y29tL2ltYWdlcHVsbHNlY3JldC1pbmplY3RlZC1ieX0nCiMgRXhwZWN0ZWQ6IGt5dmVybm8KCiMg" + + "Q2hlY2sgcHVsbCBldmVudHMKa3ViZWN0bCAtLWNvbnRleHQgPGNvbnRyb2wtcGxhbmUtY29udGV4" + + "dD4gZ2V0IGV2ZW50cyAtbiA8bmFtZXNwYWNlPiBcCiAgLS1zb3J0LWJ5PScubGFzdFRpbWVzdGFt" + + "cCcgfCBncmVwIC1pIHB1bGwKIyBTaG91bGQgc2hvdyAiU3VjY2Vzc2Z1bGx5IHB1bGxlZCIgbm90" + + "ICI0MDEgVW5hdXRob3JpemVkIgoKIyBDaGVjayB0aGUgY2hhcnQvb3BlcmF0b3IgbWlycm9yIG9u" + + "IHRoZSBjb21wdXRlIGNsdXN0ZXIKa3ViZWN0bCAtLWNvbnRleHQgPGNvbXB1dGUtcGxhbmUtY29u" + + "dGV4dD4gZ2V0IHNlY3JldCBudmNyLWNyZWRzIFwKICAtbiBudmNhLXN5c3RlbQpgYGAKCiMjIFdo" + + "ZW4gUHVsbCBTZWNyZXRzIEFyZSBOb3QgTmVlZGVkCgotICoqQVdTIEVDUiB3aXRoIElBTSBub2Rl" + + "IHJvbGVzKio6IElmIHlvdXIgbm9kZXMgaGF2ZSBgQW1hem9uRUMyQ29udGFpbmVyUmVnaXN0cnlS" + + "ZWFkT25seWAgSUFNIHBvbGljeSwgS3ViZXJuZXRlcyBjYW4gcHVsbCBmcm9tIEVDUiB3aXRob3V0" + + "IGV4cGxpY2l0IHNlY3JldHMuCi0gKipQdWJsaWMgcmVnaXN0cmllcyoqOiBObyBwdWxsIHNlY3Jl" + + "dHMgbmVlZGVkLgotICoqQ1NQIGJ1aWx0LWluIGNyZWRlbnRpYWwgaGVscGVycyoqOiBHS0UgQXJ0" + + "aWZhY3QgUmVnaXN0cnksIEF6dXJlIEFDUiB3aXRoIG1hbmFnZWQgaWRlbnRpdHksIGFuZCBzaW1p" + + "bGFyIHNlcnZpY2VzLgoKIyMgVHJvdWJsZXNob290aW5nCgojIyMgUG9kcyBzdGlsbCBpbiBJbWFn" + + "ZVB1bGxCYWNrT2ZmIGFmdGVyIGFwcGx5aW5nIHBvbGljeQoKVGhlIEt5dmVybm8gcG9saWN5IG9u" + + "bHkgYWZmZWN0cyBwb2RzIGNyZWF0ZWQgKiphZnRlcioqIHRoZSBwb2xpY3kgaXMgYXBwbGllZC4g" + + "RGVsZXRlIHN0dWNrIHBvZHMgdG8gdHJpZ2dlciByZWNyZWF0aW9uOgoKYGBgYmFzaAprdWJlY3Rs" + + "IC0tY29udGV4dCA8dGFyZ2V0LWNvbnRleHQ+IGRlbGV0ZSBwb2RzIC1uIDxuYW1lc3BhY2U+IC0t" + + "YWxsCmBgYAoKIyMjIEt5dmVybm8gYWRtaXNzaW9uIGNvbnRyb2xsZXIgbm90IHJ1bm5pbmcKCmBg" + + "YGJhc2gKa3ViZWN0bCAtLWNvbnRleHQgPGNvbnRyb2wtcGxhbmUtY29udGV4dD4gZ2V0IHBvZHMg" + + "LW4ga3l2ZXJubwojIEFsbCBwb2RzIHNob3VsZCBiZSBSdW5uaW5nCmBgYAoKIyMjIFBvbGljeSBu" + + "b3QgbWF0Y2hpbmcKCmBgYGJhc2gKa3ViZWN0bCAtLWNvbnRleHQgPGNvbnRyb2wtcGxhbmUtY29u" + + "dGV4dD4gZ2V0IGNsdXN0ZXJwb2xpY3kgbnZjZi1hZGQtaW1hZ2VwdWxsc2VjcmV0cwojIFNob3Vs" + + "ZCBzaG93IFJFQURZOiBUcnVlCmBgYAoKIyMjIFdyb25nIHNlY3JldCBuYW1lCgpUaGUgcG9saWN5" + + "IHJlZmVyZW5jZXMgYG52Y3ItY3JlZHNgLiBWZXJpZnkgdGhlIHNlY3JldCBleGlzdHMgd2l0aCB0" + + "aGF0IGV4YWN0IG5hbWU6CgpgYGBiYXNoCmt1YmVjdGwgLS1jb250ZXh0IDx0YXJnZXQtY29udGV4" + + "dD4gZ2V0IHNlY3JldCBudmNyLWNyZWRzIC1uIDxuYW1lc3BhY2U+CmBgYApQSwcIS0I1qAAWAAAA" + + "FgAAUEsBAhQAFAAIAAAAAAAhAPQ3BvZKEAAAShAAABIACQAAAAAAAAAAAAAAAAAAAGRhdGEvbWFu" + + "aWZlc3QuanNvblVUBQABAKbOElBLAQIUABQACAAAAAAAIQDNgTDkTWEAAE1hAAAjAAkAAAAAAAAA" + + "AAAAAJMQAABkYXRhL252Y2Ytc2VsZi1tYW5hZ2VkLWNsaS9TS0lMTC5tZFVUBQABAKbOElBLAQIU" + + "ABQACAAAAAAAIQAhxsiG8AoAAPAKAAAzAAkAAAAAAAAAAAAAADpyAABkYXRhL252Y2Ytc2VsZi1t" + + "YW5hZ2VkLWNsaS9leGFtcGxlcy9jaS1waXBlbGluZXMubWRVVAUAAQCmzhJQSwECFAAUAAgAAAAA" + + "ACEAoRTjgV0MAABdDAAANAAJAAAAAAAAAAAAAACUfQAAZGF0YS9udmNmLXNlbGYtbWFuYWdlZC1j" + + "bGkvZXhhbXBsZXMvbXVsdGktY2x1c3Rlci5tZFVUBQABAKbOElBLAQIUABQACAAAAAAAIQBCJ0kP" + + "BQ0AAAUNAAA3AAkAAAAAAAAAAAAAAFyKAABkYXRhL252Y2Ytc2VsZi1tYW5hZ2VkLWNsaS9wcm9t" + + "cHRzL2FkZC1jb21wdXRlLXBsYW5lLm1kVVQFAAEAps4SUEsBAhQAFAAIAAAAAAAhAJHcG/mYGQAA" + + "mBkAADkACQAAAAAAAAAAAAAAz5cAAGRhdGEvbnZjZi1zZWxmLW1hbmFnZWQtY2xpL3Byb21wdHMv" + + "Y3JlYXRlLWFuZC1ydW4tdGFzay5tZFVUBQABAKbOElBLAQIUABQACAAAAAAAIQDSQ9wEGCUAABgl" + + "AAA3AAkAAAAAAAAAAAAAANexAABkYXRhL252Y2Ytc2VsZi1tYW5hZ2VkLWNsaS9wcm9tcHRzL2Rl" + + "cGxveS1hbmQtaW52b2tlLm1kVVQFAAEAps4SUEsBAhQAFAAIAAAAAAAhAA6cP5e9DgAAvQ4AAD0A" + + "CQAAAAAAAAAAAAAAXdcAAGRhdGEvbnZjZi1zZWxmLW1hbmFnZWQtY2xpL3Byb21wdHMvZGlhZ25v" + + "c2UtZmFpbGVkLWluc3RhbGwubWRVVAUAAQCmzhJQSwECFAAUAAgAAAAAACEAQnHmHgEoAAABKAAA" + + "OgAJAAAAAAAAAAAAAACO5gAAZGF0YS9udmNmLXNlbGYtbWFuYWdlZC1jbGkvcHJvbXB0cy9pbnN0" + + "YWxsLWZyb20tc2NyYXRjaC5tZFVUBQABAKbOElBLAQIUABQACAAAAAAAIQAaxCyexwcAAMcHAAA5" + + "AAkAAAAAAAAAAAAAAAAPAQBkYXRhL252Y2Ytc2VsZi1tYW5hZ2VkLWNsaS9wcm9tcHRzL3JvdGF0" + + "ZS1jbHVzdGVyLWp3a3MubWRVVAUAAQCmzhJQSwECFAAUAAgAAAAAACEAEpMzWeAhAADgIQAALgAJ" + + "AAAAAAAAAAAAAAA3FwEAZGF0YS9udmNmLXNlbGYtbWFuYWdlZC1jbGkvcHJvbXB0cy90ZWFyZG93" + + "bi5tZFVUBQABAKbOElBLAQIUABQACAAAAAAAIQByDQ9kISMAACEjAAAwAAkAAAAAAAAAAAAAAHw5" + + "AQBkYXRhL252Y2Ytc2VsZi1tYW5hZ2VkLWNsaS9yZWZlcmVuY2UvY29tbWFuZHMubWRVVAUAAQCm" + + "zhJQSwECFAAUAAgAAAAAACEAc6daZNUGAADVBgAAMgAJAAAAAAAAAAAAAAAEXQEAZGF0YS9udmNm" + + "LXNlbGYtbWFuYWdlZC1jbGkvcmVmZXJlbmNlL2V4aXQtY29kZXMubWRVVAUAAQCmzhJQSwECFAAU" + + "AAgAAAAAACEAVejZ3s0nAADNJwAALQAJAAAAAAAAAAAAAABCZAEAZGF0YS9udmNmLXNlbGYtbWFu" + + "YWdlZC1jbGkvcmVmZXJlbmNlL2ZsYWdzLm1kVVQFAAEAps4SUEsBAhQAFAAIAAAAAAAhAPOuE4R0" + + "EQAAdBEAADcACQAAAAAAAAAAAAAAc4wBAGRhdGEvbnZjZi1zZWxmLW1hbmFnZWQtY2xpL3JlZmVy" + + "ZW5jZS90cm91Ymxlc2hvb3RpbmcubWRVVAUAAQCmzhJQSwECFAAUAAgAAAAAACEAL9q5dUJiAABC" + + "YgAALAAJAAAAAAAAAAAAAABVngEAZGF0YS9udmNmLXNlbGYtbWFuYWdlZC1pbnN0YWxsYXRpb24v" + + "U0tJTEwubWRVVAUAAQCmzhJQSwECFAAUAAgAAAAAACEAKxO4P61VAACtVQAANAAJAAAAAAAAAAAA" + + "AAD6AAIAZGF0YS9udmNmLXNlbGYtbWFuYWdlZC1pbnN0YWxsYXRpb24vZXZhbHMvZXZhbHMuanNv" + + "blVUBQABAKbOElBLAQIUABQACAAAAAAAIQACUk5AfygAAH8oAAAvAAkAAAAAAAAAAAAAABJXAgBk" + + "YXRhL252Y2Ytc2VsZi1tYW5hZ2VkLWluc3RhbGxhdGlvbi9leGFtcGxlcy5tZFVUBQABAKbOElBL" + + "AQIUABQACAAAAAAAIQCWY7xZEjAAABIwAABMAAkAAAAAAAAAAAAAAPd/AgBkYXRhL252Y2Ytc2Vs" + + "Zi1tYW5hZ2VkLWluc3RhbGxhdGlvbi9yZWZlcmVuY2VzL2NvbXB1dGUtcGxhbmUtaW5zdGFsbGF0" + + "aW9uLm1kVVQFAAEAps4SUEsBAhQAFAAIAAAAAAAhAFY+Z5CVMAAAlTAAADsACQAAAAAAAAAAAAAA" + + "jLACAGRhdGEvbnZjZi1zZWxmLW1hbmFnZWQtaW5zdGFsbGF0aW9uL3JlZmVyZW5jZXMvZGVidWdn" + + "aW5nLm1kVVQFAAEAps4SUEsBAhQAFAAIAAAAAAAhAMBWIOePJwAAjycAAEQACQAAAAAAAAAAAAAA" + + "k+ECAGRhdGEvbnZjZi1zZWxmLW1hbmFnZWQtaW5zdGFsbGF0aW9uL3JlZmVyZW5jZXMvaGVsbWZp" + + "bGUtc3RydWN0dXJlLm1kVVQFAAEAps4SUEsBAhQAFAAIAAAAAAAhADj5J6+5BwAAuQcAAD8ACQAA" + + "AAAAAAAAAAAAnQkDAGRhdGEvbnZjZi1zZWxmLW1hbmFnZWQtaW5zdGFsbGF0aW9uL3JlZmVyZW5j" + + "ZXMvbnZjZi11aS1hZGRvbi5tZFVUBQABAKbOElBLAQIUABQACAAAAAAAIQBLQjWoABYAAAAWAAA+" + + "AAkAAAAAAAAAAAAAAMwRAwBkYXRhL252Y2Ytc2VsZi1tYW5hZ2VkLWluc3RhbGxhdGlvbi9yZWZl" + + "cmVuY2VzL3B1bGwtc2VjcmV0cy5tZFVUBQABAKbOElBLBQYAAAAAFwAXAK8JAABBKAMAAAA=" var ( skillDataOnce sync.Once From 0be0418d0b187ad693cf8eb85ed9f0d93583fa4f Mon Sep 17 00:00:00 2001 From: sevenc Date: Fri, 28 Aug 2026 18:11:12 +0800 Subject: [PATCH 04/10] docs(nvcf-cli): separate request priority example --- src/clis/nvcf-cli/README.md | 11 ++++++++++- src/clis/nvcf-cli/USAGE-GUIDE.md | 11 ++++++++++- 2 files changed, 20 insertions(+), 2 deletions(-) diff --git a/src/clis/nvcf-cli/README.md b/src/clis/nvcf-cli/README.md index 2db2e93da..fee8b8bd0 100644 --- a/src/clis/nvcf-cli/README.md +++ b/src/clis/nvcf-cli/README.md @@ -618,7 +618,16 @@ export NVCF_TOKEN="nvapi-your-function-creation-token" --inference-url "/" \ --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" \ + --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" ``` diff --git a/src/clis/nvcf-cli/USAGE-GUIDE.md b/src/clis/nvcf-cli/USAGE-GUIDE.md index bf4041180..31cd7feea 100644 --- a/src/clis/nvcf-cli/USAGE-GUIDE.md +++ b/src/clis/nvcf-cli/USAGE-GUIDE.md @@ -752,7 +752,16 @@ curl -X POST https://api.nvcf.nvidia.com/v2/nvcf/accounts/nvcf-default/registry- --inference-port 8000 \ --inference-url / \ --function-type LLM \ - --llm-model "name=dummy-model,uris=/v1/chat/completions|/v1/responses|/v1/embeddings,routingMethod=round_robin,tokenRateLimit=1000-S" \ + --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" ``` From d7c3a466efe0a3bfb19ed2830d1c9c2b43a56905 Mon Sep 17 00:00:00 2001 From: sevenc Date: Fri, 28 Aug 2026 22:10:09 +0800 Subject: [PATCH 05/10] docs(nvcf-cli): simplify request priority guidance --- src/clis/nvcf-cli/README.md | 17 ----------------- src/clis/nvcf-cli/USAGE-GUIDE.md | 24 ------------------------ 2 files changed, 41 deletions(-) diff --git a/src/clis/nvcf-cli/README.md b/src/clis/nvcf-cli/README.md index fee8b8bd0..9ffce9e98 100644 --- a/src/clis/nvcf-cli/README.md +++ b/src/clis/nvcf-cli/README.md @@ -648,14 +648,6 @@ export NVCF_TOKEN="nvapi-your-function-creation-token" "functionType": "LLM", "description": "Example LLM function from JSON config", "tags": ["example", "demo"], - "llmInvocationConfig": { - "priority": { - "defaultPriority": 7, - "perAccountPriority": { - "nca-id": 3 - } - } - }, "health": { "protocol": "HTTP", "uri": "/health", @@ -693,8 +685,6 @@ request. Use `1000-S` for a single inline CLI limit. Use JSON input for combined limits, such as `1000-S,5000-M,100000-H,500000-D,1000000-W`, because inline model specs use commas as field separators. Supported LLM paths are `/v1/chat/completions`, `/v1/responses`, and `/v1/embeddings`. -Request priorities are unsigned 32-bit integers from `0` through `4294967295`. Lower values have higher priority, and `0` is the highest priority. An explicit `0` is distinct from an omitted priority. `--llm-per-account-priority` is repeatable and requires `--llm-default-priority` or a `defaultPriority` value in the input file. - #### **Deploy a Function** *Uses `NVCF_TOKEN` (with `NVCF_API_KEY` fallback)* Deploy a function with GPU specifications: @@ -793,11 +783,6 @@ export NVCF_API_KEY="nvapi-your-general-operations-token" # optional fallback "functionId": "func-12345678-1234-1234-1234-123456789abc", "versionId": "ver-12345678-1234-1234-1234-123456789abc", "tags": ["production", "ml-model", "updated"], - "llmInvocationConfig": { - "priority": { - "defaultPriority": 0 - } - }, "modelUpdates": [ { "modelName": "dummy-model", @@ -810,8 +795,6 @@ export NVCF_API_KEY="nvapi-your-general-operations-token" # optional fallback } ``` -An update that includes `llmInvocationConfig` replaces the complete function-level priority configuration. Specify every default and per-account value to retain. Omitting the field preserves the current configuration. To clear it, use `--input-file` with `"llmInvocationConfig": {}`. - **Update Deployment JSON format (`update-deployment.json`):** ```json { diff --git a/src/clis/nvcf-cli/USAGE-GUIDE.md b/src/clis/nvcf-cli/USAGE-GUIDE.md index 31cd7feea..92b707398 100644 --- a/src/clis/nvcf-cli/USAGE-GUIDE.md +++ b/src/clis/nvcf-cli/USAGE-GUIDE.md @@ -810,14 +810,6 @@ curl -X POST https://api.nvcf.nvidia.com/v2/nvcf/accounts/nvcf-default/registry- "inferenceUrl": "/", "inferencePort": 8000, "functionType": "LLM", - "llmInvocationConfig": { - "priority": { - "defaultPriority": 7, - "perAccountPriority": { - "nca-id": 3 - } - } - }, "models": [ { "name": "dummy-model", @@ -836,8 +828,6 @@ For LLM models, `llmConfig.routingMethod` accepts the API/auth spellings CLI validates these values before sending the create request. Supported LLM paths are `/v1/chat/completions`, `/v1/responses`, and `/v1/embeddings`. -Request priorities are unsigned 32-bit integers from `0` through `4294967295`. Lower values have higher priority, and `0` is the highest priority. An explicit `0` is distinct from an omitted priority. Per-account overrides require a default priority. - ### 5. List Functions #### CLI Usage @@ -1066,20 +1056,6 @@ When `--json` is set: --llm-per-account-priority "nca-id:3" ``` -When an update includes `llmInvocationConfig`, it replaces the complete function-level priority configuration. Specify every default and per-account value to retain. Omitting the field preserves the current configuration. To clear it, save an update file such as `clear-priority.json` with an empty object: - -```json -{ - "functionId": "550e8400-e29b-41d4-a716-446655440000", - "versionId": "01234567-89ab-cdef-0123-456789abcdef", - "llmInvocationConfig": {} -} -``` - -```bash -./nvcf-cli function update --input-file clear-priority.json -``` - ### Delete Function or Deployment The delete command offers flexible ways to specify which function to delete, with automatic fallback to the current function in state. From 58d103889547cf476d0ad7bcc991c46f390e350b Mon Sep 17 00:00:00 2001 From: sevenc Date: Fri, 28 Aug 2026 22:12:33 +0800 Subject: [PATCH 06/10] docs(nvcf-cli): trim request priority details --- .../nvcf-self-managed-cli/reference/flags.md | 19 ------------ docs/user/cli.md | 31 ++++++------------- 2 files changed, 10 insertions(+), 40 deletions(-) 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 0e861ba58..9338d366a 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 @@ -88,23 +88,6 @@ Extended duration units: `s` (seconds), `m` (minutes), `h` (hours), `d` (days), 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. -Function-level request priority uses this JSON shape: - -```json -{ - "llmInvocationConfig": { - "priority": { - "defaultPriority": 7, - "perAccountPriority": { - "nca-id": 3 - } - } - } -} -``` - -Priority values range from `0` through `4294967295`. Lower values have higher priority, and `0` is highest. An explicit `0` is distinct from an omitted priority. `defaultPriority` is required when `perAccountPriority` has entries. - Helm chart packaging is independent of `functionType`. For a Helm-chart backed LLM function, set `functionType: "LLM"`, `helmChart`, `helmChartServiceName`, and `models[].llmConfig` in the same create request. `inferencePort` must be the Kubernetes Service port exposed by `helmChartServiceName`. LLM invocation requests use `model: "/"`. The function ID selects the NVCF function, and the model name is forwarded upstream. Chat completions and Responses API requests can use `x-multi-turn-session-id` for session stickiness; embeddings requests do not. @@ -120,8 +103,6 @@ LLM invocation requests use `model: "/"`. The function 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. -When `llmInvocationConfig` is present in an update, it replaces the complete function-level priority configuration. Specify every default and per-account value to retain. Omitting the field preserves the current configuration. Use `--input-file` with `"llmInvocationConfig": {}` to clear it. - ## `function deploy create`-specific `--input-file FILE` is recommended (full JSON spec). For ad-hoc one-shot use: diff --git a/docs/user/cli.md b/docs/user/cli.md index 482067206..70a0f4103 100644 --- a/docs/user/cli.md +++ b/docs/user/cli.md @@ -690,7 +690,16 @@ API key, which `api-key generate` mints automatically alongside the function key --inference-url "/" \ --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" \ + --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" ``` @@ -754,14 +763,6 @@ LLM functions use `functionType: "LLM"` and define model routing metadata under "inferenceUrl": "/", "inferencePort": 8000, "functionType": "LLM", - "llmInvocationConfig": { - "priority": { - "defaultPriority": 7, - "perAccountPriority": { - "nca-id": 3 - } - } - }, "models": [ { "name": "dummy-model", @@ -779,8 +780,6 @@ For LLM models, `llmConfig.routingMethod` accepts `round_robin`, `power_of_two`, Supported LLM paths are `/v1/chat/completions`, `/v1/responses`, and `/v1/embeddings`. `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 `1000-S` for a single limit, or `1000-S,5000-M,100000-H,500000-D,1000000-W` for a combined limit with distinct units. Use JSON input for combined limits because inline CLI model specs use commas as field separators. -Request priorities are unsigned 32-bit integers from `0` through `4294967295`. Lower values have higher priority, and an explicit `0` is distinct from an omitted priority. If `perAccountPriority` has entries, `defaultPriority` is required. - #### Deploy Function The `function deploy` command group manages deployments with the following subcommands: @@ -935,16 +934,6 @@ LLM model updates can also be provided in the input file: } ``` -`llmInvocationConfig` is a full replacement when it is present in an update. Specify every default and per-account value to retain. Omitting the field preserves the current configuration. To clear it, use `--input-file` with an empty `llmInvocationConfig` object: - -```json -{ - "functionId": "", - "versionId": "", - "llmInvocationConfig": {} -} -``` - #### Invoke Function ```bash From d6f3c58a4238c3391146d36f446f047e7e265c10 Mon Sep 17 00:00:00 2001 From: sevenc Date: Fri, 28 Aug 2026 22:16:14 +0800 Subject: [PATCH 07/10] docs(nvcf-cli): clarify per-account priority limit --- .../user/skills/nvcf-self-managed-cli/reference/flags.md | 4 ++-- docs/user/cli.md | 2 +- src/clis/nvcf-cli/cmd/function.go | 8 ++++---- 3 files changed, 7 insertions(+), 7 deletions(-) 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 9338d366a..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 @@ -83,7 +83,7 @@ Extended duration units: `s` (seconds), `m` (minutes), `h` (hours), `d` (days), | `--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, maximum 64. Requires a default 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. @@ -99,7 +99,7 @@ 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, maximum 64. Requires a default 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, `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. diff --git a/docs/user/cli.md b/docs/user/cli.md index 70a0f4103..5dc14f3a0 100644 --- a/docs/user/cli.md +++ b/docs/user/cli.md @@ -728,7 +728,7 @@ All `function create` flags: | `--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, maximum 64). Requires a default priority. | +| `--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 | diff --git a/src/clis/nvcf-cli/cmd/function.go b/src/clis/nvcf-cli/cmd/function.go index 81b7c8eba..fb28cadb9 100644 --- a/src/clis/nvcf-cli/cmd/function.go +++ b/src/clis/nvcf-cli/cmd/function.go @@ -594,7 +594,7 @@ func init() { 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().Uint32Var(&createFlags.llmDefaultPriority, "llm-default-priority", 0, "Function-level default request priority (lower is higher; range: 0-4294967295)") - createCmd.Flags().StringArrayVar(&createFlags.llmPerAccountPriorities, "llm-per-account-priority", []string{}, "Per-account request priority override (format: :; requires default priority; lower is higher; range: 0-4294967295; repeatable, max 64)") + createCmd.Flags().StringArrayVar(&createFlags.llmPerAccountPriorities, "llm-per-account-priority", []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") @@ -637,7 +637,7 @@ func init() { 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().Uint32Var(&updateFlags.llmDefaultPriority, "llm-default-priority", 0, "Function-level default request priority (lower is higher; range: 0-4294967295; replaces existing priority config)") - updateCmd.Flags().StringArrayVar(&updateFlags.llmPerAccountPriorities, "llm-per-account-priority", []string{}, "Per-account request priority override (format: :; requires default priority; lower is higher; range: 0-4294967295; repeatable, max 64)") + updateCmd.Flags().StringArrayVar(&updateFlags.llmPerAccountPriorities, "llm-per-account-priority", []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)") } // ============================================================================ @@ -1296,7 +1296,7 @@ func parseContainerEnvironment(values []string) ([]ContainerEnvironmentEntry, er func parsePerAccountPriorities(values []string) (map[string]uint32, error) { if len(values) > 64 { - return nil, fmt.Errorf("at most 64 per-account priority overrides are allowed") + return nil, fmt.Errorf("at most 64 distinct NCA ID priority overrides are allowed") } overrides := make(map[string]uint32, len(values)) @@ -1335,7 +1335,7 @@ func validateLLMInvocationConfig(config *LLMInvocationConfigInput) error { priority := config.Priority if len(priority.PerAccountPriority) > 64 { - return fmt.Errorf("at most 64 per-account priority overrides are allowed") + 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") From eeda7685a82efb44f39812cce080fcbeced2ecda Mon Sep 17 00:00:00 2001 From: sevenc Date: Fri, 28 Aug 2026 22:43:42 +0800 Subject: [PATCH 08/10] refactor(nvcf-cli): simplify priority flag merging --- src/clis/nvcf-cli/cmd/function.go | 120 +++++++++--------- .../nvcf-cli/cmd/function_llm_model_test.go | 3 - .../cmd/function_request_priority_test.go | 101 ++++++++++++--- 3 files changed, 137 insertions(+), 87 deletions(-) diff --git a/src/clis/nvcf-cli/cmd/function.go b/src/clis/nvcf-cli/cmd/function.go index fb28cadb9..3e367f93f 100644 --- a/src/clis/nvcf-cli/cmd/function.go +++ b/src/clis/nvcf-cli/cmd/function.go @@ -42,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" ) // ============================================================================ @@ -496,10 +498,6 @@ var createFlags struct { llmModels []string resources []string - // Function-level LLM invocation configuration - llmDefaultPriority uint32 - llmPerAccountPriorities []string - // Rate limiting rateLimit string rateLimitExempted []string @@ -539,13 +537,11 @@ var invokeFlags struct { } var updateFlags struct { - inputFile string - functionID string - versionID string - tags []string - llmModelUpdates []string - llmDefaultPriority uint32 - llmPerAccountPriorities []string + inputFile string + functionID string + versionID string + tags []string + llmModelUpdates []string } // ============================================================================ @@ -593,8 +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().Uint32Var(&createFlags.llmDefaultPriority, "llm-default-priority", 0, "Function-level default request priority (lower is higher; range: 0-4294967295)") - createCmd.Flags().StringArrayVar(&createFlags.llmPerAccountPriorities, "llm-per-account-priority", []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().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") @@ -636,8 +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().Uint32Var(&updateFlags.llmDefaultPriority, "llm-default-priority", 0, "Function-level default request priority (lower is higher; range: 0-4294967295; replaces existing priority config)") - updateCmd.Flags().StringArrayVar(&updateFlags.llmPerAccountPriorities, "llm-per-account-priority", []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)") + 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)") } // ============================================================================ @@ -1159,57 +1155,62 @@ func applyCreateFlagOverrides(cmd *cobra.Command, config *CreateConfig) error { applyCreateHelmFlagOverrides(cmd, config) applyCreateRateLimitFlagOverrides(cmd, config) applyCreateTelemetryFlagOverrides(cmd, config) - if err := applyCreateRequestPriorityFlagOverrides(cmd, config); err != nil { + 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 applyCreateRequestPriorityFlagOverrides(cmd *cobra.Command, config *CreateConfig) error { - return applyRequestPriorityFlagOverrides( - cmd.Flags().Changed("llm-default-priority"), - createFlags.llmDefaultPriority, - cmd.Flags().Changed("llm-per-account-priority"), - createFlags.llmPerAccountPriorities, - &config.LLMInvocationConfig, - ) -} - -func applyRequestPriorityFlagOverrides( - defaultChanged bool, - defaultPriority uint32, - perAccountChanged bool, - perAccountValues []string, - target **LLMInvocationConfigInput, -) error { +func mergeRequestPriorityFlagOverrides( + cmd *cobra.Command, + current *LLMInvocationConfigInput, +) (*LLMInvocationConfigInput, error) { + flags := cmd.Flags() + defaultChanged := flags.Changed(llmDefaultPriorityFlag) + perAccountChanged := flags.Changed(llmPerAccountPriorityFlag) if !defaultChanged && !perAccountChanged { - return nil + return current, nil } - config := *target - if config == nil { - config = &LLMInvocationConfigInput{} + mergedConfig := &LLMInvocationConfigInput{} + if current != nil { + *mergedConfig = *current } - if config.Priority == nil { - config.Priority = &PriorityInput{} + + mergedPriority := &PriorityInput{} + if mergedConfig.Priority != nil { + *mergedPriority = *mergedConfig.Priority } + mergedConfig.Priority = mergedPriority + if defaultChanged { - value := defaultPriority - config.Priority.DefaultPriority = &value + value, err := flags.GetUint32(llmDefaultPriorityFlag) + if err != nil { + return nil, err + } + mergedPriority.DefaultPriority = &value } if perAccountChanged { - overrides, err := parsePerAccountPriorities(perAccountValues) + values, err := flags.GetStringArray(llmPerAccountPriorityFlag) if err != nil { - return err + return nil, err } - config.Priority.PerAccountPriority = overrides + overrides, err := parsePerAccountPriorities(values) + if err != nil { + return nil, err + } + mergedPriority.PerAccountPriority = overrides } - *target = config - return validateLLMInvocationConfig(config) + + if err := validateLLMInvocationConfig(mergedConfig); err != nil { + return nil, err + } + return mergedConfig, nil } func applyCreateRequiredFlagOverrides(cmd *cobra.Command, config *CreateConfig) { @@ -1589,18 +1590,11 @@ func loadUpdateConfig(cmd *cobra.Command) (*UpdateConfig, error) { config.ModelUpdates = append(config.ModelUpdates, updates...) } - priorityFlagsChanged := cmd.Flags().Changed("llm-default-priority") || cmd.Flags().Changed("llm-per-account-priority") - if priorityFlagsChanged { - if err := applyRequestPriorityFlagOverrides( - cmd.Flags().Changed("llm-default-priority"), - updateFlags.llmDefaultPriority, - cmd.Flags().Changed("llm-per-account-priority"), - updateFlags.llmPerAccountPriorities, - &config.LLMInvocationConfig, - ); err != nil { - return nil, err - } + mergedConfig, err := mergeRequestPriorityFlagOverrides(cmd, config.LLMInvocationConfig) + if err != nil { + return nil, err } + config.LLMInvocationConfig = mergedConfig return config, nil } diff --git a/src/clis/nvcf-cli/cmd/function_llm_model_test.go b/src/clis/nvcf-cli/cmd/function_llm_model_test.go index 85db0e048..15dfbd633 100644 --- a/src/clis/nvcf-cli/cmd/function_llm_model_test.go +++ b/src/clis/nvcf-cli/cmd/function_llm_model_test.go @@ -303,9 +303,6 @@ func TestLoadCreateConfigAppendsLLMModelFlag(t *testing.T) { llmModels []string resources []string - llmDefaultPriority uint32 - llmPerAccountPriorities []string - rateLimit string rateLimitExempted []string rateLimitSync bool diff --git a/src/clis/nvcf-cli/cmd/function_request_priority_test.go b/src/clis/nvcf-cli/cmd/function_request_priority_test.go index 19317fa50..097c7549e 100644 --- a/src/clis/nvcf-cli/cmd/function_request_priority_test.go +++ b/src/clis/nvcf-cli/cmd/function_request_priority_test.go @@ -111,14 +111,12 @@ func TestLoadCreateConfigAppliesRequestPriorityFlags(t *testing.T) { t.Cleanup(func() { createFlags = originalFlags }) cmd := newPriorityFlagTestCommand() - if err := cmd.Flags().Set("llm-default-priority", "0"); err != nil { + if err := cmd.Flags().Set(llmDefaultPriorityFlag, "0"); err != nil { t.Fatalf("set default priority: %v", err) } - if err := cmd.Flags().Set("llm-per-account-priority", "nca-1:3"); err != nil { + if err := cmd.Flags().Set(llmPerAccountPriorityFlag, "nca-1:3"); err != nil { t.Fatalf("set per-account priority: %v", err) } - createFlags.llmDefaultPriority = 0 - createFlags.llmPerAccountPriorities = []string{"nca-1:3"} config, err := loadCreateConfig(cmd) if err != nil { @@ -131,16 +129,14 @@ func TestCreateRequestIncludesRepeatedPerAccountPriorityFlags(t *testing.T) { originalFlags := createFlags t.Cleanup(func() { createFlags = originalFlags }) - cmd := &cobra.Command{} - cmd.Flags().Uint32Var(&createFlags.llmDefaultPriority, "llm-default-priority", 0, "") - cmd.Flags().StringArrayVar(&createFlags.llmPerAccountPriorities, "llm-per-account-priority", nil, "") - if err := cmd.Flags().Set("llm-default-priority", "7"); err != nil { + cmd := newPriorityFlagTestCommand() + if err := cmd.Flags().Set(llmDefaultPriorityFlag, "7"); err != nil { t.Fatalf("set default priority: %v", err) } - if err := cmd.Flags().Set("llm-per-account-priority", "nca-a:3"); err != nil { + 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("llm-per-account-priority", "nca-b:5"); err != nil { + if err := cmd.Flags().Set(llmPerAccountPriorityFlag, "nca-b:5"); err != nil { t.Fatalf("set second per-account priority: %v", err) } @@ -182,14 +178,12 @@ func TestLoadUpdateConfigAppliesRequestPriorityFlags(t *testing.T) { t.Cleanup(func() { updateFlags = originalFlags }) cmd := newPriorityFlagTestCommand() - if err := cmd.Flags().Set("llm-default-priority", "7"); err != nil { + if err := cmd.Flags().Set(llmDefaultPriorityFlag, "7"); err != nil { t.Fatalf("set default priority: %v", err) } - if err := cmd.Flags().Set("llm-per-account-priority", "nca-1:3"); err != nil { + if err := cmd.Flags().Set(llmPerAccountPriorityFlag, "nca-1:3"); err != nil { t.Fatalf("set per-account priority: %v", err) } - updateFlags.llmDefaultPriority = 7 - updateFlags.llmPerAccountPriorities = []string{"nca-1:3"} config, err := loadUpdateConfig(cmd) if err != nil { @@ -201,11 +195,76 @@ func TestLoadUpdateConfigAppliesRequestPriorityFlags(t *testing.T) { func TestRequestPriorityFlagsPreserveInputFileFieldsWhenOmitted(t *testing.T) { t.Parallel() - config := &CreateConfig{LLMInvocationConfig: priorityConfig(7, map[string]uint32{"nca-1": 3})} - if err := applyCreateRequestPriorityFlagOverrides(&cobra.Command{}, config); err != nil { - t.Fatalf("apply priority flags: %v", err) + 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, config.LLMInvocationConfig, 7, map[string]uint32{"nca-1": 3}) + 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) { @@ -271,7 +330,7 @@ func TestDefaultPriorityFlagRejectsInvalidValues(t *testing.T) { t.Parallel() cmd := newPriorityFlagTestCommand() - if err := cmd.Flags().Set("llm-default-priority", value); err == nil { + if err := cmd.Flags().Set(llmDefaultPriorityFlag, value); err == nil { t.Fatalf("setting default priority to %q succeeded, want error", value) } }) @@ -365,8 +424,8 @@ func TestPrintRequestPriority(t *testing.T) { func newPriorityFlagTestCommand() *cobra.Command { cmd := &cobra.Command{} - cmd.Flags().Uint32("llm-default-priority", 0, "") - cmd.Flags().StringArray("llm-per-account-priority", nil, "") + cmd.Flags().Uint32(llmDefaultPriorityFlag, 0, "") + cmd.Flags().StringArray(llmPerAccountPriorityFlag, nil, "") return cmd } From 1e936027cd798691a195dc68f1bed312c329bfea Mon Sep 17 00:00:00 2001 From: sevenc Date: Sat, 29 Aug 2026 08:34:57 +0800 Subject: [PATCH 09/10] docs(nvcf-cli): add multi-account priority example --- docs/user/cli.md | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/docs/user/cli.md b/docs/user/cli.md index 5dc14f3a0..e35be66e9 100644 --- a/docs/user/cli.md +++ b/docs/user/cli.md @@ -701,7 +701,8 @@ API key, which `api-key generate` mints automatically alongside the function key --function-type LLM \ --llm-model "name=dummy-model,uris=/v1/chat/completions" \ --llm-default-priority 7 \ - --llm-per-account-priority "nca-id:3" + --llm-per-account-priority "nca-a:3" \ + --llm-per-account-priority "nca-b:5" ``` All `function create` flags: From 82031196a5cf20f2ee211cb37824172b89532871 Mon Sep 17 00:00:00 2001 From: sevenc Date: Sat, 29 Aug 2026 08:38:22 +0800 Subject: [PATCH 10/10] docs(nvcf-cli): separate multi-account priority example --- docs/user/cli.md | 11 +++++++++++ 1 file changed, 11 insertions(+) diff --git a/docs/user/cli.md b/docs/user/cli.md index e35be66e9..274595bbb 100644 --- a/docs/user/cli.md +++ b/docs/user/cli.md @@ -701,6 +701,17 @@ API key, which `api-key generate` mints automatically alongside the function key --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" ```