From 85fe06652567ae2059b3a9a679627244c8c06602 Mon Sep 17 00:00:00 2001 From: Mike Camp Date: Tue, 25 Aug 2026 14:17:12 -0400 Subject: [PATCH 1/6] fix(self-managed): validate external LLM routing Move Envoy Gateway Service annotations to EnvoyProxy, document controller-specific NLB configuration and the existing backend-router Gateway API path, and define the certificate reload and remote-cluster trust contracts. Reject partial backend-router dial overrides and add rendered configuration and documentation example regressions. Tests: self-managed Helmfile render checks; gateway-routes and llm-request-router chart tests; short BDD suite; Fern validation. Signed-off-by: Mike Camp --- .../prompts/install-from-scratch.md | 97 +- deploy/stacks/self-managed/global.yaml.gotmpl | 10 +- .../tests/llm-router-split-cluster.sh | 56 +- docs/user/gateway-routing.md | 220 +- docs/user/helmfile-installation.md | 13 +- docs/user/llm-function-enablement.md | 200 +- .../agentskill/skilldata_generated.go | 5145 +++++++++-------- tests/bdd/gateway_examples_test.go | 230 + 8 files changed, 3298 insertions(+), 2673 deletions(-) create mode 100644 tests/bdd/gateway_examples_test.go diff --git a/ai-tooling/user/skills/nvcf-self-managed-cli/prompts/install-from-scratch.md b/ai-tooling/user/skills/nvcf-self-managed-cli/prompts/install-from-scratch.md index 05c152d76..2c3394492 100644 --- a/ai-tooling/user/skills/nvcf-self-managed-cli/prompts/install-from-scratch.md +++ b/ai-tooling/user/skills/nvcf-self-managed-cli/prompts/install-from-scratch.md @@ -4,12 +4,12 @@ User wants to bring up self-hosted NVCF on a fresh Kubernetes cluster (or k3d fo ## Steps -1. **Confirm the topology.** Ask the user: +1. Confirm the topology. Ask the user: - "Single-cluster (control plane and compute plane on one cluster, simpler) or split (control plane on cluster A, compute plane on cluster B, production-shaped)?" - "What's the cluster name (the `--cluster-name` flag, becomes the ICMS row identifier)? Examples: `ncp-local` for local dev, `prod-us-east-1` for production." - For split: "Control-plane kubeconfig context name? Compute-plane context? Public ICMS URL?" -2. **Prepare remote Gateway and CLI config if this is not local k3d.** One-click +2. Prepare remote Gateway and CLI config if this is not local k3d. One-click applies the control plane, then immediately calls API, API Keys, invocation, and gRPC endpoints. For remote clusters, the Gateway must be programmed and the CLI config must point at the Gateway load balancer before `up` runs. @@ -33,13 +33,34 @@ User wants to bring up self-hosted NVCF on a fresh Kubernetes cluster (or k3d fo --version v1.1.3 \ -n envoy-gateway-system + # Non-EKS-Auto-Mode example: use AWS LBC with instance targets. kubectl apply -f - <2 min) - - `phase_failed` — STOP. Surface `errMessage` + each `remediation` line. Decide based on `retryClass`: `immediate` → may re-run now with user OK; `backoff` → wait `retryAfterSec` then re-run with user OK; `after_remediation`/`none`/`unknown` → operator must act first, do NOT auto-retry. - - `final` — done. Print clusterId, NVCFBackend health. - -6. **Verify with status.** `nvcf-cli self-hosted status --json | jq` — expect `verdict: "healthy"`. If not, route to [diagnose-failed-install.md](diagnose-failed-install.md). - -7. **(Optional) Smoke a function.** Route to [deploy-and-invoke.md](deploy-and-invoke.md) for the create → deploy → invoke flow. + - `phase_started` / `phase_completed`: log progress + - `phase_progress`: show progress for the long apply phases (resource counts) + - `waiting`: surface to the user if it persists for more than 2 minutes + - `phase_failed`: stop and surface `errMessage` plus each `remediation` line. + Decide based on `retryClass`: `immediate` -> may re-run now with user + approval; `backoff` -> wait `retryAfterSec` and then re-run with user + approval; `after_remediation`, `none`, or `unknown` -> the operator must + act first, so do not auto-retry. + - `final`: done. Print clusterId and NVCFBackend health. + +6. Verify with status. Run `nvcf-cli self-hosted status --json | jq` and expect + `verdict: "healthy"`. Otherwise, use + [diagnose-failed-install.md](diagnose-failed-install.md). + +7. Optionally smoke test a function. Use + [deploy-and-invoke.md](deploy-and-invoke.md) for the create -> deploy -> + invoke flow. ## Notes -- Single-cluster `up` against a fresh cluster takes ~10–13 min depending on chart pull speed and NATS stream-init latency. -- `up` is idempotent — safe to re-run if the user wants to retry after fixing a prerequisite. +- Single-cluster `up` against a fresh cluster takes about 10-13 minutes, + depending on chart pull speed and NATS stream-init latency. +- `up` is idempotent. It is safe to re-run after fixing a prerequisite. - Never propose `--force` (no command takes one anyway). - If the user has CI / `$CI` set, always use `--non-interactive --token=$JWT`; never propose `nvcf-cli init` interactively. diff --git a/deploy/stacks/self-managed/global.yaml.gotmpl b/deploy/stacks/self-managed/global.yaml.gotmpl index 9c458dd87..22c180f3f 100644 --- a/deploy/stacks/self-managed/global.yaml.gotmpl +++ b/deploy/stacks/self-managed/global.yaml.gotmpl @@ -860,6 +860,12 @@ llmApiGateway: {{- toYaml . | nindent 4 }} {{- end }} +{{- $pylonGrpcDialAddress := dig "addons" "llm" "requestRouter" "backendRouter" "pylonGrpcDialAddress" "" .Values | default "" | toString | trim }} +{{- $pylonReverseTunnelDialAddress := dig "addons" "llm" "requestRouter" "backendRouter" "pylonReverseTunnelDialAddress" "" .Values | default "" | toString | trim }} +{{- if and $llmEnabled (ne (empty $pylonGrpcDialAddress) (empty $pylonReverseTunnelDialAddress)) }} +{{- fail "addons.llm.requestRouter.backendRouter.pylonGrpcDialAddress and addons.llm.requestRouter.backendRouter.pylonReverseTunnelDialAddress must either both be set or both be omitted" }} +{{- end }} + llmRequestRouter: enabled: {{ dig "addons" "llm" "enabled" false .Values }} fullnameOverride: llm-request-router @@ -892,10 +898,10 @@ llmRequestRouter: image: registry: {{ .Values.global.image.registry }} repository: {{ .Values.global.image.repository }}/stargate - {{- with dig "addons" "llm" "requestRouter" "backendRouter" "pylonGrpcDialAddress" "" .Values }} + {{- with $pylonGrpcDialAddress }} pylonGrpcDialAddress: {{ . | quote }} {{- end }} - {{- with dig "addons" "llm" "requestRouter" "backendRouter" "pylonReverseTunnelDialAddress" "" .Values }} + {{- with $pylonReverseTunnelDialAddress }} pylonReverseTunnelDialAddress: {{ . | quote }} {{- end }} {{- if .Values.global.imagePullSecrets }} diff --git a/deploy/stacks/self-managed/tests/llm-router-split-cluster.sh b/deploy/stacks/self-managed/tests/llm-router-split-cluster.sh index 606da19fd..e0b62cd94 100755 --- a/deploy/stacks/self-managed/tests/llm-router-split-cluster.sh +++ b/deploy/stacks/self-managed/tests/llm-router-split-cluster.sh @@ -22,7 +22,7 @@ printf '{}\n' >"$secrets_file" printf '%s\n' \ 'global:' \ ' workerEndpoints:' \ - ' llmRequestRouterAddress: llm-request-router.nvcf.svc.cluster.local:50071' \ + ' llmRequestRouterAddress: llm-grpc.example.com:50071' \ 'addons:' \ ' llm:' \ ' enabled: true' \ @@ -35,8 +35,8 @@ printf '%s\n' \ ' requestRouter:' \ " chartPath: $router_chart_path" \ ' backendRouter:' \ - ' pylonGrpcDialAddress: llm-request-router.nvcf.svc.cluster.local:50071' \ - ' pylonReverseTunnelDialAddress: llm-request-router.nvcf.svc.cluster.local:50072' \ + ' pylonGrpcDialAddress: llm-grpc.example.com:50071' \ + ' pylonReverseTunnelDialAddress: llm-quic.example.com:50072' \ 'ingress:' \ ' gatewayApi:' \ ' controllerNamespace: envoy-gateway-system' \ @@ -120,13 +120,13 @@ assert_value '.nvcfGatewayRoutes.gateways.llmQuic.listenerName' 'llm-quic' assert_file_value "$work_dir/api-values.yaml" \ '.api.remoteConfig.configData.nvcf.llm-request-router.worker-address' \ - 'llm-request-router.nvcf.svc.cluster.local:50071' + 'llm-grpc.example.com:50071' assert_file_value "$work_dir/router-values.yaml" \ '.llmRequestRouter.backendRouter.pylonGrpcDialAddress' \ - 'llm-request-router.nvcf.svc.cluster.local:50071' + 'llm-grpc.example.com:50071' assert_file_value "$work_dir/router-values.yaml" \ '.llmRequestRouter.backendRouter.pylonReverseTunnelDialAddress' \ - 'llm-request-router.nvcf.svc.cluster.local:50072' + 'llm-quic.example.com:50072' assert_file_value "$work_dir/router-values.yaml" \ '.llmRequestRouter.certificate.dnsNames[0]' \ 'llm-request-router.nvcf.svc.cluster.local' @@ -140,4 +140,48 @@ assert_file_value "$work_dir/router-values.yaml" \ '.llmRequestRouter.tls.quicInsecure' \ 'false' +assert_partial_backend_override_rejected() { + local missing_key="$1" + local case_name="$2" + local partial_environment_name="${environment_name}-${case_name}" + local partial_environment_file="$test_stack_dir/environments/$partial_environment_name.yaml" + local partial_error="$work_dir/$case_name-error.log" + + cp "$environment_file" "$partial_environment_file" + printf '{}\n' >"$test_stack_dir/secrets/$partial_environment_name-secrets.yaml" + yq -i "del(.addons.llm.requestRouter.backendRouter.${missing_key})" \ + "$partial_environment_file" + + if HELMFILE_ENV="$partial_environment_name" \ + HELMFILE_CACHE_HOME="$work_dir/helmfile-cache" \ + helmfile \ + --file "$test_stack_dir/helmfile.d/02-core.yaml.gotmpl" \ + --environment default \ + --selector name=llm-request-router \ + write-values \ + --output-file-template "$work_dir/$case_name-values.yaml" \ + >/dev/null 2>"$partial_error"; then + echo "llm-router-split-cluster: partial override without $missing_key was accepted" >&2 + return 1 + fi + + grep -Fq \ + 'addons.llm.requestRouter.backendRouter.pylonGrpcDialAddress and addons.llm.requestRouter.backendRouter.pylonReverseTunnelDialAddress must either both be set or both be omitted' \ + "$partial_error" || { + echo "llm-router-split-cluster: partial override without $missing_key returned an unexpected error" >&2 + sed -n '1,80p' "$partial_error" >&2 + return 1 + } +} + +partial_override_failures=0 +assert_partial_backend_override_rejected \ + 'pylonReverseTunnelDialAddress' 'missing-reverse-tunnel' || + partial_override_failures=$((partial_override_failures + 1)) +assert_partial_backend_override_rejected \ + 'pylonGrpcDialAddress' 'missing-grpc' || + partial_override_failures=$((partial_override_failures + 1)) +test "$partial_override_failures" -eq 0 || + fail "$partial_override_failures partial backend-router override case(s) were not rejected" + echo "llm-router-split-cluster: all checks passed" diff --git a/docs/user/gateway-routing.md b/docs/user/gateway-routing.md index 9aca656a9..a4cd1eba1 100644 --- a/docs/user/gateway-routing.md +++ b/docs/user/gateway-routing.md @@ -1,15 +1,17 @@ # Gateway Routing and DNS -This guide explains how NVCF self-hosted deployments route traffic through the Kubernetes Gateway API, and how to configure DNS and HTTPS for production environments. +This guide explains how NVCF self-hosted deployments route traffic through the +Kubernetes Gateway API, and how to configure DNS and HTTPS for production +environments. ## Overview The NVCF self-hosted deployment uses the [Kubernetes Gateway API](https://gateway-api.sigs.k8s.io/) for ingress traffic management. This provides: - Hostname-based routing for HTTP services (API Keys, NVCF API, Invocation) -- Port-based routing for gRPC services -- Single load balancer for all NVCF services -- Cross-namespace routing via ReferenceGrants +- Port-based routing for gRPC and optional LLM reverse QUIC traffic +- One or more load balancers, based on the Gateway and listener layout +- Cross-namespace routing through `ReferenceGrant` The Gateway API is a Kubernetes standard with multiple implementations. The examples on this page use Envoy Gateway, but you can use any Gateway @@ -71,6 +73,13 @@ Create an `EnvoyProxy` resource before you create the `GatewayClass`. The `envoyDeployment.replicas` setting controls the Envoy proxy data-plane pods that handle ingress traffic. It does not control Envoy Gateway controller pods. +Service annotations on a `Gateway` do not configure the Envoy data-plane +Service. Set them in `EnvoyProxy.spec.provider.kubernetes.envoyService` so +Envoy Gateway copies them to the generated Service. The example is for an EKS +cluster that does not use EKS Auto Mode. It uses the +[AWS Load Balancer Controller](https://kubernetes-sigs.github.io/aws-load-balancer-controller/latest/guide/service/nlb/) +with instance targets and an internet-facing Network Load Balancer (NLB). + Create the `GatewayClass` with a `parametersRef` that points to the `EnvoyProxy` resource: @@ -85,6 +94,11 @@ spec: provider: type: Kubernetes kubernetes: + envoyService: + annotations: + service.beta.kubernetes.io/aws-load-balancer-type: "external" + service.beta.kubernetes.io/aws-load-balancer-nlb-target-type: "instance" + service.beta.kubernetes.io/aws-load-balancer-scheme: "internet-facing" envoyDeployment: replicas: 2 --- @@ -102,19 +116,42 @@ spec: EOF ``` +For [EKS Auto Mode](https://docs.aws.amazon.com/eks/latest/userguide/auto-configure-nlb.html), +replace the AWS Load Balancer Controller annotation map with the Auto Mode +Service class and its documented internet-facing scheme annotation: + +```yaml +envoyService: + loadBalancerClass: eks.amazonaws.com/nlb + annotations: + service.beta.kubernetes.io/aws-load-balancer-scheme: "internet-facing" +``` + +For a cluster that does not use EKS Auto Mode and uses the legacy AWS cloud +provider Service controller instead of the AWS Load Balancer Controller, +replace the three annotations with: + +```yaml +envoyService: + annotations: + service.beta.kubernetes.io/aws-load-balancer-type: "nlb" +``` + +The legacy controller creates an internet-facing load balancer by default. Add +`service.beta.kubernetes.io/aws-load-balancer-internal: "true"` for an internal +NLB. Do not combine the legacy `nlb` controller selector with the AWS Load +Balancer Controller target type and scheme annotations. The legacy controller +supports an NLB Service whose ports use only TCP or only UDP, but rejects one +Service that combines TCP and UDP ports. Use the AWS Load Balancer Controller +when the generated Envoy Service combines protocols. For another cloud provider, +replace the annotations under `envoyService` with that provider's Service +annotations. + ### Create Gateway Create the Gateway resource with an HTTP listener on port 80, a TCP listener on port 10081 for gRPC, and a TCP listener on port 4222 for NATS. - -The `annotations` section is cloud-provider specific and controls how the -external load balancer is provisioned. Keep the AWS annotations for EKS. Replace -them with equivalent annotations for GKE, AKS, or on-prem load balancer -integrations. - - - ```bash kubectl apply -f - < +### LLM worker listeners + +LLM workers in another cluster or region need a TCP path for gRPC registration +and watches, plus a UDP path for the reverse QUIC tunnel. These paths are +separate from the `grpcWorker` callback route. + +The following example uses separate Gateways so the infrastructure can create +one TCP load balancer and one UDP load balancer. A provider that supports mixed +TCP and UDP listeners can use one Gateway for both listeners. In that case, +set `llmGrpc.name` and `llmQuic.name` to the same Gateway name. + +```bash +kubectl apply -f - < -TCPRoute is experimental. Some Gateway API implementations may have limited or no TCPRoute support. Verify your chosen implementation supports TCPRoute before deploying. If it doesn't, gRPC invocations and NVCA NATS connections won't work through the gateway. +`TCPRoute` and `UDPRoute` are experimental. Some Gateway API implementations +have limited support for them. Verify the controller's supported versions +before deploying. Remote LLM workers require both route kinds. @@ -299,7 +419,8 @@ To use a different Gateway API implementation instead of Envoy Gateway: 4. Create a `Gateway` with `http` (port 80), `tcp` (port 10081), and `nats` (port 4222) listeners. Add `worker-tcp` (port 10086) only when enabling - split or multi-cluster gRPC invocation. + split or multi-cluster gRPC invocation. Add `llm-grpc` (TCP port 50071) and + `llm-quic` (UDP port 50072) when remote LLM workers use the Gateway. 5. Update your install configuration to reference your Gateway: @@ -322,7 +443,8 @@ To use a different Gateway API implementation instead of Envoy Gateway: listenerName: nats # TCP listener name for NATS ``` -The `nvcf-gateway-routes` chart will create HTTPRoutes and TCPRoutes that attach to your specified Gateway. +The `nvcf-gateway-routes` chart creates the enabled routes and attaches them to +the configured Gateways and listeners. ### Not Using Gateway API @@ -330,7 +452,7 @@ While technically possible to bypass the Gateway API entirely, this is not recom - The `nvcf-gateway-routes` chart specifically creates Gateway API resources - You would need to manually create and maintain all routing configuration -- Traditional Kubernetes Ingress does not support TCPRoute (required for gRPC) +- Traditional Kubernetes Ingress does not provide `TCPRoute` or `UDPRoute` - Multiple LoadBalancer services would require multiple external IPs If you have a specific requirement that prevents using Gateway API, you would need to: @@ -340,6 +462,9 @@ If you have a specific requirement that prevents using Gateway API, you would ne 3. Configure hostname routing manually 4. Set up TCP load balancers for gRPC on port 10081, optional split or multi-cluster gRPC invocation on port 10086, and NATS on port 4222 +5. When serving remote LLM workers, route TCP port 50071 and UDP port 50072 to + `llm-request-router-backend-router` without bypassing its authority and SNI + selection ## Gateway Architecture @@ -358,6 +483,8 @@ These resources must be created manually before deploying the control plane: (port 4222) listeners - Optional `worker-tcp` (port 10086) listener for split or multi-cluster gRPC invocation +- Optional `llm-grpc` (TCP port 50071) and `llm-quic` (UDP port 50072) + listeners for remote LLM workers ### Resources created by nvcf-gateway-routes @@ -371,6 +498,8 @@ When you deploy the control plane via helmfile, the `nvcf-gateway-routes` chart - Optional `TCPRoute` for split or multi-cluster gRPC invocation when the `grpcWorker` route is enabled - Optional `TCPRoute` for NATS when the `nats` route is enabled +- Optional `TCPRoute` and `UDPRoute` for LLM worker traffic when the + `llmWorker` route is enabled - `ReferenceGrants` for cross-namespace routing permissions These routes attach to the Gateway you prepared in [Gateway quickstart](./gateway-routing.md#gateway-quickstart). @@ -388,6 +517,8 @@ These routes attach to the Gateway you prepared in [Gateway quickstart](./gatewa | gRPC | N/A (TCP routing, no hostname matching) | 10081 | gRPC function invocations | | gRPC worker callback | N/A (TCP routing, no hostname matching) | 10086 | HTTP/1 CONNECT callback from workers to grpc-proxy when the beta `grpcWorker` route is enabled | | NATS | N/A (TCP routing, no hostname matching) | 4222 | NVCA messaging when the NATS route is enabled | +| LLM worker gRPC | N/A (TCP routing, authority selects a request-router pod) | 50071 | Registration and request-router watches through `llm-request-router-backend-router` | +| LLM worker QUIC | N/A (UDP routing, SNI selects a request-router pod) | 50072 | Reverse inference tunnels through `llm-request-router-backend-router` | The `` is your Gateway's load balancer address (e.g., `a1b2c3d4.us-west-2.elb.amazonaws.com`) or your custom domain. The helmfile deployment automatically configures the HTTPRoute hostnames using this value from your environment configuration. @@ -460,13 +591,18 @@ By default, the route host is `nvcf-ui.` and the backend is ### How Routing Works -1. The Gateway's LoadBalancer service exposes ports 80 (HTTP), 10081 (gRPC), - and 4222 (NATS) externally. +1. The main Gateway's LoadBalancer Service exposes ports 80 (HTTP), 10081 + (gRPC), and 4222 (NATS) externally. 2. HTTP requests arrive at port 80. The Gateway inspects the `Host` header and matches it against HTTPRoute hostnames. 3. The matching HTTPRoute forwards the request to the appropriate backend service (e.g., `api-keys` service on port 8080). 4. gRPC requests arrive at port 10081. The TCPRoute forwards all traffic directly to the `grpc` service. No hostname matching is required. 5. NATS connections arrive at port 4222. When enabled, the NATS TCPRoute forwards traffic directly to the NATS service. +6. Remote LLM gRPC connections arrive at the configured `llmGrpc` listener. + The TCPRoute forwards them to the backend-router Service on port 50071. +7. Remote LLM reverse tunnels arrive at the configured `llmQuic` listener. + The UDPRoute forwards them to the same Service on port 50072. The TCP and + UDP listeners can use separate Gateways and load balancers. gRPC doesn't need Host headers because it uses a dedicated TCP listener on port 10081. The gateway routes all traffic on that port directly to the gRPC service without hostname matching. @@ -520,6 +656,34 @@ kubectl get svc -n envoy-gateway-system -l gateway.envoyproxy.io/owning-gateway- # Expected output includes: 80 10081 4222 ``` +### Verify LLM worker routes + +After applying the stack with `llmWorker.enabled: true`, verify both route +parents and the cross-namespace backend reference: + +```bash +export LLM_GRPC_GATEWAY_NAMESPACE=envoy-gateway +export LLM_QUIC_GATEWAY_NAMESPACE=envoy-gateway + +kubectl -n "$LLM_GRPC_GATEWAY_NAMESPACE" get tcproute llm-worker-grpc \ + -o jsonpath='{range .status.parents[*].conditions[*]}{.type}={.status}{" reason="}{.reason}{"\n"}{end}' +kubectl -n "$LLM_QUIC_GATEWAY_NAMESPACE" get udproute llm-worker-quic \ + -o jsonpath='{range .status.parents[*].conditions[*]}{.type}={.status}{" reason="}{.reason}{"\n"}{end}' +kubectl -n nvcf get referencegrant allow-llm-worker-routes -o yaml +kubectl -n nvcf get service llm-request-router-backend-router \ + -o jsonpath='{.spec.type}{"\t"}{range .spec.ports[*]}{.port}{"/"}{.protocol}{" "}{end}{"\n"}' +``` + +Each route parent must report `Accepted=True` and `ResolvedRefs=True`. The +Service type must remain `ClusterIP`, with TCP port `50071` and UDP port +`50072`. Also wait for each referenced Gateway to report `Programmed=True` and +confirm that its status contains an external address. + +Route status proves that the controller accepted the configuration. It does +not prove that firewall rules, cross-region routing, DNS, or UDP forwarding +work from a compute cluster. Test both external endpoints from every worker +network before deploying production LLM functions. + ### Test Connectivity ```bash diff --git a/docs/user/helmfile-installation.md b/docs/user/helmfile-installation.md index 0a37bb874..936a501d7 100644 --- a/docs/user/helmfile-installation.md +++ b/docs/user/helmfile-installation.md @@ -170,6 +170,11 @@ workers in a compute cluster to reach grpc-proxy in the control-plane cluster, complete [gRPC Invocation Enablement](./grpc-invocation-enablement.md) before you deploy or sync the control plane. +Remote LLM workers use separate gRPC and reverse QUIC paths. Complete +[LLM worker listeners](./gateway-routing.md#llm-worker-listeners) and +[Remote compute clusters and regions](./llm-function-enablement.md#remote-compute-clusters-and-regions) +before applying the control plane. + The Gateway address is embedded throughout your deployment. The `domain` value in your environment file, the Gateway API HTTPRoutes/TCPRoutes, and service @@ -334,10 +339,10 @@ ingress: When `addons.llm` is enabled, the stack defaults `global.workerEndpoints.llmRequestRouterAddress` to `llm-request-router.nvcf.svc.cluster.local:50071`. Colocated workers require no -additional configuration. For a split deployment, override this value with a -request-router host and port that worker pods can reach. See -[LLM Function Enablement](./llm-function-enablement.md) for the complete addon -configuration. +additional configuration. For a split deployment, this address alone is not +enough. Configure the paired backend-router gRPC and reverse QUIC dial +addresses, Gateway routes, DNS, and trust described in +[Remote compute clusters and regions](./llm-function-enablement.md#remote-compute-clusters-and-regions). #### `domain` and `ingress` Configuration diff --git a/docs/user/llm-function-enablement.md b/docs/user/llm-function-enablement.md index 28995c9ce..781931d03 100644 --- a/docs/user/llm-function-enablement.md +++ b/docs/user/llm-function-enablement.md @@ -39,10 +39,15 @@ cert-manager, or one you issue yourself and supply in a pre-created Secret. Each compute plane receives the public root CA certificate and uses the combined system and private trust bundle in the `llm-worker` sidecar. -The request-router address configured for the compute plane must use a DNS name -listed in the certificate SANs. For a single-cluster deployment, use -`llm-request-router.nvcf.svc.cluster.local:50071`. Use an address reachable from -each compute cluster when the control and compute planes use separate networks. +The external dial endpoints and the request-router TLS identity are separate. +For a single-cluster deployment, workers dial +`llm-request-router.nvcf.svc.cluster.local:50071`. For remote workers, the +backend router preserves the advertised request-router pod hostname as the QUIC +Server Name Indication (SNI) while it sends traffic through an external UDP +endpoint. The certificate must cover that advertised hostname. The default +wildcard SAN is `*.llm-request-router-headless.nvcf.svc.cluster.local`. +An external load-balancer hostname does not need to be a certificate SAN just +because workers use it as a dial endpoint. ### Managed OpenBao issuer @@ -74,9 +79,9 @@ addons: replicaCount: 2 ``` -The stable service name covers a single request-router replica. The wildcard -SAN covers the pod-specific headless service names advertised when the -request-router StatefulSet has multiple replicas. +The stable Service SAN covers the in-cluster Service name. The wildcard SAN +covers the pod-specific headless names advertised through the backend-router +path. To use a custom managed `ClusterIssuer`, set both the issuer identity and the management override: @@ -152,6 +157,70 @@ API then includes the address in LLM worker configuration. Do not configure the worker address under `api.env`. When the LLM addon is disabled, the stack does not pass a staged endpoint to the API chart. +### Remote compute clusters and regions + +One self-managed control plane can serve LLM workers in separate GPU clusters +or regions when every worker cluster has routable DNS and network paths to both +backend-router endpoints. + +| Path | Worker-facing values | Gateway route and backend | Terminating component | +| --- | --- | --- | --- | +| gRPC registration and watches | `global.workerEndpoints.llmRequestRouterAddress` for the initial connection, then `pylonGrpcDialAddress` | `llmGrpc` TCP listener and `TCPRoute` to `llm-request-router-backend-router:50071` | The backend router accepts gRPC, selects a request-router pod from the HTTP/2 authority, and proxies the stream. | +| Reverse inference tunnel | `pylonReverseTunnelDialAddress` | `llmQuic` UDP listener and `UDPRoute` to `llm-request-router-backend-router:50072` | The backend router terminates the worker-facing QUIC connection, selects a request-router pod from SNI, and forwards the tunnel. | + +Configure distinct TCP and UDP endpoints when the infrastructure uses separate +Gateways or load balancers: + +```yaml +global: + workerEndpoints: + llmRequestRouterAddress: llm-grpc.example.com:50071 + +addons: + llm: + enabled: true + requestRouter: + backendRouter: + pylonGrpcDialAddress: llm-grpc.example.com:50071 + pylonReverseTunnelDialAddress: llm-quic.example.com:50072 + +ingress: + gatewayApi: + routes: + llmWorker: + enabled: true + backend: + namespace: nvcf + gateways: + llmGrpc: + name: llm-grpc-gateway + namespace: envoy-gateway + listenerName: llm-grpc + llmQuic: + name: llm-quic-gateway + namespace: envoy-gateway + listenerName: llm-quic +``` + +Set both `pylonGrpcDialAddress` and `pylonReverseTunnelDialAddress`, or omit +both to use the in-cluster backend-router Service. Helmfile rendering rejects a +partial override. The gRPC worker address normally uses the same TCP endpoint +as `pylonGrpcDialAddress`. + +The dial hostnames select network paths. They do not replace the advertised +request-router pod hostname used for QUIC SNI. Keep the default wildcard SAN, +or issue a certificate that covers a customized advertised hostname. Every +compute cluster must trust the issuing CA as described in +[Compute-plane trust](#compute-plane-trust). Server certificate and key updates +follow [Certificate Renewal](#certificate-renewal). A CA or trust-bundle change +requires a worker rollout. + +The stack does not provision cross-region networking, firewall rules, load +balancers, DNS, or trust distribution. Supply those dependencies and register +the trust bundle in every compute cluster. A successful Helm render and +accepted Gateway routes do not prove remote TCP or UDP reachability. Test both +paths and an LLM invocation from each region before production use. + The request router uses `power-of-two` when no load-balancer configuration is set, and accepts any supported `routingMethod` from a function. When a load-balancer configuration is set, a function can only select an algorithm @@ -193,25 +262,30 @@ stack-managed issuance. Rendering fails if any of them is set in this mode, so a configuration that expects the stack to issue a certificate cannot be mistaken for one that expects you to. -The certificate must carry a SAN covering the router's advertised hostname and -the address workers connect to. At the default single-replica configuration -that is `llm-request-router.nvcf.svc.cluster.local`. At higher replica counts -the router advertises per-pod headless names, so use a leftmost wildcard such -as `*.llm-request-router-headless.nvcf.svc.cluster.local`. Include any external -name set in `global.workerEndpoints.llmRequestRouterAddress`. The stack cannot -read your Secret at render time, so it validates neither the SANs nor the -expiry. A certificate that does not cover the advertised hostname fails at -worker connection time, not at install time. +The certificate must carry a SAN covering the router's advertised hostname. +The stack enables backend routing and advertises per-pod headless names, so +include `*.llm-request-router-headless.nvcf.svc.cluster.local` along with the +stable `llm-request-router.nvcf.svc.cluster.local` name. An external TCP or UDP +dial hostname does not need to be a SAN unless the advertised identity is also +customized to use that hostname. The stack cannot read your Secret at render +time, so it validates neither the SANs nor the expiry. A certificate that does +not cover the advertised hostname fails at worker connection time, not at +install time. You own issuance, renewal, rotation, and recovery in this mode: -- Renewal and rotation: update the Secret, then restart the router with - `kubectl rollout restart statefulset/llm-request-router --namespace nvcf`. - The router reads the certificate at startup. +- Renewal and rotation: hot reload requires `helm-nvcf-llm-request-router` + 1.10.0 or later and Stargate 0.11.1 or later. With those versions, update the + Secret and follow the + [transport TLS rotation runbook](./runbooks/transport-tls-rotation.md). Older + chart releases and Stargate image overrides older than 0.11.1 require a + request-router restart after the Secret update. - Expiry: track it yourself. Nothing in the stack renews the certificate or alerts on an approaching expiry. -- Recovery: if the Secret is deleted or malformed, the router pods fail to - start. Restore the Secret and roll the StatefulSet. +- Recovery: a running router keeps its last-known-good identity after rejecting + a malformed replacement. A new pod cannot start from a missing or malformed + Secret. Restore a valid Secret and follow the rotation runbook to verify the + active identity. Compute-plane trust works exactly as described in [Compute-plane trust](#compute-plane-trust). Author the `transportTls` block @@ -276,8 +350,9 @@ controlPlane: requestRouterAddress: llm-router.example.com:443 ``` -Use the endpoint that compute-plane workers can resolve and reach. Its -hostname must match a SAN on the request-router certificate. +Use the gRPC endpoint that compute-plane workers can resolve and reach. This is +a dial endpoint. It does not replace the advertised request-router hostname +that the certificate covers. Registration renders this field as `agent.llm.requestRouterAddress` in the compute-plane values. That is operator configuration, not a runtime fallback @@ -289,25 +364,12 @@ from the `LLM_REQUEST_ROUTER_ADDRESS` variable in its launch environment, with the workload, translation rejects the launch instead of falling back to the registered address. -Add that hostname to `addons.llm.pki.dnsNames`. The list accepts any number of -additional names; the stack only requires that one entry covers the router's -advertised hostname. For the managed issuer, also extend `allowedDomains` with -the parent domain, because the OpenBao signing role allows subdomains and -wildcards but not bare domains. To issue for `llm-router.example.com`, use: - -```yaml -addons: - llm: - pki: - allowedDomains: nvcf.svc.cluster.local,example.com - dnsNames: - - llm-request-router.nvcf.svc.cluster.local - - "*.llm-request-router-headless.nvcf.svc.cluster.local" - - llm-router.example.com -``` - -`allowedDomains: llm-router.example.com` does not work for that name. The role -sets `allow_bare_domains=false`, so the entry must be the parent domain. +Keep the default stable and wildcard entries in `addons.llm.pki.dnsNames`. +Add another SAN only when the advertised request-router identity changes, not +when only a load-balancer dial endpoint changes. For the managed issuer, any +new advertised DNS suffix must also be covered by `allowedDomains`. The +OpenBao role allows subdomains and wildcards but not bare domains, so configure +the parent domain rather than the exact leaf name. The managed export reads the public root CA certificate from `services/all/pki/root` in the stack's OpenBao service and calculates the @@ -505,7 +567,9 @@ kubectl -n nvcf-backend get pod \ The worker args must contain `--stargate-address=llm-request-router.nvcf.svc.cluster.local:50071`, or the configured routable DNS name, and must not contain `--quic-insecure`. The -address hostname must match a certificate SAN. The environment must contain: +external address is the initial gRPC dial endpoint. The reverse tunnel verifies +the advertised request-router pod hostname instead. The environment must +contain: ```text STARGATE_TLS_CERT_PATH=/etc/ssl/certs/ca-certificates.crt @@ -515,26 +579,38 @@ Also verify the control-plane components: ```bash kubectl get deployment -n nvcf llm-api-gateway +kubectl get deployment -n nvcf llm-request-router-backend-router kubectl get statefulset -n nvcf llm-request-router +kubectl get service -n nvcf llm-request-router-backend-router kubectl get pods -n nvcf | grep -E 'llm-api-gateway|llm-request-router' kubectl get httproute -A | grep llm ``` +For remote workers, also verify the LLM `TCPRoute`, `UDPRoute`, and +`ReferenceGrant` as described in +[Gateway Routing and DNS](./gateway-routing.md#verify-llm-worker-routes). + ## Certificate Renewal cert-manager renews the request-router certificate and updates `Secret/stargate-quic-tls`. With `mode: existingSecret` there is no renewal -loop and you update the Secret yourself. Either way, the request router loads -its certificate when the pod starts. Restart the StatefulSet after renewal so -every replica uses the updated certificate: - -```bash -kubectl -n nvcf rollout restart statefulset/llm-request-router -kubectl -n nvcf rollout status statefulset/llm-request-router --timeout=5m -``` - -Run the certificate and worker checks again after the restart. Do not assume -that the request router hot reloads certificate changes. +loop and you update the Secret yourself. + +Hot reload requires `helm-nvcf-llm-request-router` 1.10.0 or later and Stargate +0.11.1 or later. The request router polls the mounted server certificate and +private key every 30 seconds. A valid replacement becomes active for new +handshakes without restarting the request router. Established connections +remain open. If a replacement is invalid, the router rejects it and keeps the +last-known-good identity. Older chart releases and Stargate image overrides +older than 0.11.1 require a request-router restart after the Secret update. + +This reload contract covers the server certificate and private key only. A +trust-bundle change, including a root CA rotation, requires a rolling restart of +the LLM worker pods. Renewing an intermediate under an already-trusted root does +not change the trust bundle and does not require a worker-pod restart. Follow +the [transport TLS rotation runbook](./runbooks/transport-tls-rotation.md) for +the atomic Secret update, reload checks, trust-bundle rollout order, and +recovery procedure. ## Upgrade and Rollback @@ -572,8 +648,9 @@ Use this order for a safe rollback: plane again, and recreate the LLM workers with the combined trust bundle. 3. Set `addons.llm.pki.issuerKind` and `issuerName` to the replacement, set `clusterIssuer.enabled: false`, and apply the control-plane stack. -4. Wait for `Certificate/stargate-quic-tls` to become ready, restart the - request-router StatefulSet, and verify the replacement TLS data path. +4. Wait for `Certificate/stargate-quic-tls` to become ready, confirm a + successful `server_identity` reload, and verify the replacement TLS data + path with a new connection. 5. Remove the old root from the compute-plane profile, register each compute plane again, and recreate the workers. 6. Confirm that no `Certificate` references the old issuer: @@ -677,11 +754,14 @@ For transport TLS failures, check: - Unknown issuer: inspect the `Certificate` Ready condition and verify `issuerRef.kind`, `issuerRef.name`, and the issuer namespace. A namespaced `Issuer` must be in `nvcf`. -- SAN mismatch: compare the hostname in `--stargate-address` with the SANs in - `Secret/stargate-quic-tls`. Do not replace the hostname with an IP address. +- SAN mismatch: compare the request router's + `--advertised-hostname-template` with the SANs in + `Secret/stargate-quic-tls`. The external `--stargate-address` is a dial + endpoint and does not replace the advertised QUIC identity. - Expired or not-yet-valid certificate: inspect the certificate dates and the - cluster clock. Renew the certificate and restart the request-router - StatefulSet. + cluster clock. Renew the certificate and use the + [transport TLS rotation runbook](./runbooks/transport-tls-rotation.md) to + verify that the replacement becomes active. - Missing trust bundle: verify `ConfigMap/nvcf-transport-trust-bundle`, compare its fingerprint with the compute-plane profile, and confirm `STARGATE_TLS_CERT_PATH` in the `llm-worker` container. diff --git a/src/clis/nvcf-cli/internal/agentskill/skilldata_generated.go b/src/clis/nvcf-cli/internal/agentskill/skilldata_generated.go index f26911390..48cb288e4 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" + - "MDowMFoiLAogICJ0b3RhbEZpbGVzIjogMjIsCiAgInRvdGFsQnl0ZXMiOiAxOTU5OTQsCiAgImZp" + + "MDowMFoiLAogICJ0b3RhbEZpbGVzIjogMjIsCiAgInRvdGFsQnl0ZXMiOiAxOTgwNjksCiAgImZp" + "bGVzIjogWwogICAgewogICAgICAicGF0aCI6ICJudmNmLXNlbGYtbWFuYWdlZC1jbGkvU0tJTEwu" + "bWQiLAogICAgICAic2hhMjU2IjogImM0ZjI4OGY2MmU1MDg4NjI5ZGY1MTcyYTlhYjMwZWVlOGMz" + "OTRmYzgzOTFjMjMwMDMzNzI2NGVmZjRiMmU3ZWYiLAogICAgICAic2l6ZSI6IDI0OTA5CiAgICB9" + @@ -56,8 +56,8 @@ const skillDataZipBase64 = "" + "NTU5NWY1ZjNmZTA2YTU5ZjQ2M2U0NGUyMGFkNjg2YjRlYzQ2Mjk2MjI1ODRjZTRmMDQ3NSIsCiAg" + "ICAgICJzaXplIjogMzc3MwogICAgfSwKICAgIHsKICAgICAgInBhdGgiOiAibnZjZi1zZWxmLW1h" + "bmFnZWQtY2xpL3Byb21wdHMvaW5zdGFsbC1mcm9tLXNjcmF0Y2gubWQiLAogICAgICAic2hhMjU2" + - "IjogIjhjNmRmY2RlOGI3ZjE3ZTI3YzAwNjExYjM4MDE3ZTRmMjJjM2MzMTc1OTY2NTE5YTMzZGY4" + - "MWQwOTgzMGVkNDYiLAogICAgICAic2l6ZSI6IDcyNTgKICAgIH0sCiAgICB7CiAgICAgICJwYXRo" + + "IjogImUwYWUxODMxNjgyZDUwNDA0N2NiYjVkMmRiYjRhMjhmNTEzODU0NTkyMTM5MTQzZGJkMjNm" + + "ZTk2MTNhOWFlOTMiLAogICAgICAic2l6ZSI6IDkzMzMKICAgIH0sCiAgICB7CiAgICAgICJwYXRo" + "IjogIm52Y2Ytc2VsZi1tYW5hZ2VkLWNsaS9wcm9tcHRzL3JvdGF0ZS1jbHVzdGVyLWp3a3MubWQi" + "LAogICAgICAic2hhMjU2IjogIjZmYWU1NTYyZGM1ZTk3YzI0YTkzNjA1YjY3NGEwYWZjN2VjNGEz" + "ZDBiZWMzY2ViZjlmNjRlOGJlNmYyNjc4YTUiLAogICAgICAic2l6ZSI6IDE5OTEKICAgIH0sCiAg" + @@ -103,7 +103,7 @@ const skillDataZipBase64 = "" + "OiAibnZjZi1zZWxmLW1hbmFnZWQtaW5zdGFsbGF0aW9uL3JlZmVyZW5jZXMvcHVsbC1zZWNyZXRz" + "Lm1kIiwKICAgICAgInNoYTI1NiI6ICJlYzFmM2ZmY2QxN2U1Zjk1ODNmZWUzOTc0NGVlODk3ZDQ2" + "NmJjM2NmNjM4OTI5NDI2NGQ4OWU3ZjllZDAxYjg3IiwKICAgICAgInNpemUiOiA1NjMyCiAgICB9" + - "CiAgXQp9ClBLBwg5k0fPSBAAAEgQAABQSwMEFAAIAAAAAAAhAAAAAAAAAAAAAAAAACMACQBkYXRh" + + "CiAgXQp9ClBLBwitcpafSBAAAEgQAABQSwMEFAAIAAAAAAAhAAAAAAAAAAAAAAAAACMACQBkYXRh" + "L252Y2Ytc2VsZi1tYW5hZ2VkLWNsaS9TS0lMTC5tZFVUBQABAKbOEi0tLQpuYW1lOiBudmNmLXNl" + "bGYtbWFuYWdlZC1jbGkKZGVzY3JpcHRpb246IHwKICBJbnN0YWxsLCBvcGVyYXRlLCBhbmQgdGVh" + "ciBkb3duIHNlbGYtaG9zdGVkIE5WSURJQSBDbG91ZCBGdW5jdGlvbnMgKE5WQ0YpCiAgZGVwbG95" + @@ -1069,1031 +1069,1630 @@ const skillDataZipBase64 = "" + "VAUAAQCmzhIjIEluc3RhbGwgc2VsZi1ob3N0ZWQgTlZDRiBmcm9tIHNjcmF0Y2gKClVzZXIgd2Fu" + "dHMgdG8gYnJpbmcgdXAgc2VsZi1ob3N0ZWQgTlZDRiBvbiBhIGZyZXNoIEt1YmVybmV0ZXMgY2x1" + "c3RlciAob3IgazNkIGZvciBsb2NhbCBkZXYpLiBUaGlzIGlzIHRoZSBtb3N0IGNvbW1vbiBlbnRy" + - "eXBvaW50LgoKIyMgU3RlcHMKCjEuICoqQ29uZmlybSB0aGUgdG9wb2xvZ3kuKiogQXNrIHRoZSB1" + - "c2VyOgogICAtICJTaW5nbGUtY2x1c3RlciAoY29udHJvbCBwbGFuZSBhbmQgY29tcHV0ZSBwbGFu" + - "ZSBvbiBvbmUgY2x1c3Rlciwgc2ltcGxlcikgb3Igc3BsaXQgKGNvbnRyb2wgcGxhbmUgb24gY2x1" + - "c3RlciBBLCBjb21wdXRlIHBsYW5lIG9uIGNsdXN0ZXIgQiwgcHJvZHVjdGlvbi1zaGFwZWQpPyIK" + - "ICAgLSAiV2hhdCdzIHRoZSBjbHVzdGVyIG5hbWUgKHRoZSBgLS1jbHVzdGVyLW5hbWVgIGZsYWcs" + - "IGJlY29tZXMgdGhlIElDTVMgcm93IGlkZW50aWZpZXIpPyBFeGFtcGxlczogYG5jcC1sb2NhbGAg" + - "Zm9yIGxvY2FsIGRldiwgYHByb2QtdXMtZWFzdC0xYCBmb3IgcHJvZHVjdGlvbi4iCiAgIC0gRm9y" + - "IHNwbGl0OiAiQ29udHJvbC1wbGFuZSBrdWJlY29uZmlnIGNvbnRleHQgbmFtZT8gQ29tcHV0ZS1w" + - "bGFuZSBjb250ZXh0PyBQdWJsaWMgSUNNUyBVUkw/IgoKMi4gKipQcmVwYXJlIHJlbW90ZSBHYXRl" + - "d2F5IGFuZCBDTEkgY29uZmlnIGlmIHRoaXMgaXMgbm90IGxvY2FsIGszZC4qKiBPbmUtY2xpY2sK" + - "ICAgYXBwbGllcyB0aGUgY29udHJvbCBwbGFuZSwgdGhlbiBpbW1lZGlhdGVseSBjYWxscyBBUEks" + - "IEFQSSBLZXlzLCBpbnZvY2F0aW9uLAogICBhbmQgZ1JQQyBlbmRwb2ludHMuIEZvciByZW1vdGUg" + - "Y2x1c3RlcnMsIHRoZSBHYXRld2F5IG11c3QgYmUgcHJvZ3JhbW1lZCBhbmQKICAgdGhlIENMSSBj" + - "b25maWcgbXVzdCBwb2ludCBhdCB0aGUgR2F0ZXdheSBsb2FkIGJhbGFuY2VyIGJlZm9yZSBgdXBg" + - "IHJ1bnMuCgogICBJZiBHYXRld2F5IEFQSSBpbmdyZXNzIGlzIG5vdCBhbHJlYWR5IHByZXNlbnQs" + - "IGNyZWF0ZSBpdCBmaXJzdC4gVGhlc2UgYXJlIHRoZQogICBzaGFyZWQgR2F0ZXdheSBzZXR1cCBz" + - "dGVwcyB1c2VkIGJ5IG9uZS1jbGljaywgSGVsbWZpbGUsIGFuZCBzdGFuZGFsb25lIGNoYXJ0CiAg" + - "IGluc3RhbGwgcGF0aHM6CgogICBgYGBzaAogICBrdWJlY3RsIGFwcGx5IC1mIGh0dHBzOi8vZ2l0" + - "aHViLmNvbS9rdWJlcm5ldGVzLXNpZ3MvZ2F0ZXdheS1hcGkvcmVsZWFzZXMvZG93bmxvYWQvdjEu" + - "Mi4wL2V4cGVyaW1lbnRhbC1pbnN0YWxsLnlhbWwKCiAgIGZvciBuYW1lc3BhY2UgaW4gZW52b3kt" + - "Z2F0ZXdheS1zeXN0ZW0gZW52b3ktZ2F0ZXdheSBhcGkta2V5cyBlc3Mgc2lzIG52Y2Y7IGRvCiAg" + - "ICAga3ViZWN0bCBjcmVhdGUgbmFtZXNwYWNlICIkbmFtZXNwYWNlIiAtLWRyeS1ydW49Y2xpZW50" + - "IC1vIHlhbWwgfCBrdWJlY3RsIGFwcGx5IC1mIC0KICAgZG9uZQoKICAgZm9yIG5hbWVzcGFjZSBp" + - "biBlbnZveS1nYXRld2F5IGFwaS1rZXlzIGVzcyBzaXMgbnZjZjsgZG8KICAgICBrdWJlY3RsIGxh" + - "YmVsIG5hbWVzcGFjZSAiJG5hbWVzcGFjZSIgbnZjZi9wbGF0Zm9ybT10cnVlIC0tb3ZlcndyaXRl" + - "CiAgIGRvbmUKCiAgIGhlbG0gdXBncmFkZSAtLWluc3RhbGwgZWcgb2NpOi8vZG9ja2VyLmlvL2Vu" + - "dm95cHJveHkvZ2F0ZXdheS1oZWxtIFwKICAgICAtLXZlcnNpb24gdjEuMS4zIFwKICAgICAtbiBl" + - "bnZveS1nYXRld2F5LXN5c3RlbQoKICAga3ViZWN0bCBhcHBseSAtZiAtIDw8RU9GCiAgIGFwaVZl" + - "cnNpb246IGdhdGV3YXkubmV0d29ya2luZy5rOHMuaW8vdjEKICAga2luZDogR2F0ZXdheUNsYXNz" + - "CiAgIG1ldGFkYXRhOgogICAgIG5hbWU6IGVnCiAgIHNwZWM6CiAgICAgY29udHJvbGxlck5hbWU6" + - "IGdhdGV3YXkuZW52b3lwcm94eS5pby9nYXRld2F5Y2xhc3MtY29udHJvbGxlcgogICBFT0YKCiAg" + - "IGt1YmVjdGwgYXBwbHkgLWYgLSA8PEVPRgogICBhcGlWZXJzaW9uOiBnYXRld2F5Lm5ldHdvcmtp" + - "bmcuazhzLmlvL3YxCiAgIGtpbmQ6IEdhdGV3YXkKICAgbWV0YWRhdGE6CiAgICAgbmFtZTogbnZj" + - "Zi1nYXRld2F5CiAgICAgbmFtZXNwYWNlOiBlbnZveS1nYXRld2F5CiAgICAgYW5ub3RhdGlvbnM6" + - "CiAgICAgICBzZXJ2aWNlLmJldGEua3ViZXJuZXRlcy5pby9hd3MtbG9hZC1iYWxhbmNlci10eXBl" + - "OiAibmxiIgogICAgICAgc2VydmljZS5iZXRhLmt1YmVybmV0ZXMuaW8vYXdzLWxvYWQtYmFsYW5j" + - "ZXItc2NoZW1lOiAiaW50ZXJuZXQtZmFjaW5nIgogICBzcGVjOgogICAgIGdhdGV3YXlDbGFzc05h" + - "bWU6IGVnCiAgICAgbGlzdGVuZXJzOgogICAgIC0gbmFtZTogaHR0cAogICAgICAgcHJvdG9jb2w6" + - "IEhUVFAKICAgICAgIHBvcnQ6IDgwCiAgICAgICBhbGxvd2VkUm91dGVzOgogICAgICAgICBuYW1l" + - "c3BhY2VzOgogICAgICAgICAgIGZyb206IFNlbGVjdG9yCiAgICAgICAgICAgc2VsZWN0b3I6CiAg" + - "ICAgICAgICAgICBtYXRjaExhYmVsczoKICAgICAgICAgICAgICAgbnZjZi9wbGF0Zm9ybTogInRy" + - "dWUiCiAgICAgLSBuYW1lOiB0Y3AKICAgICAgIHByb3RvY29sOiBUQ1AKICAgICAgIHBvcnQ6IDEw" + - "MDgxCiAgICAgICBhbGxvd2VkUm91dGVzOgogICAgICAgICBuYW1lc3BhY2VzOgogICAgICAgICAg" + - "IGZyb206IFNlbGVjdG9yCiAgICAgICAgICAgc2VsZWN0b3I6CiAgICAgICAgICAgICBtYXRjaExh" + - "YmVsczoKICAgICAgICAgICAgICAgbnZjZi9wbGF0Zm9ybTogInRydWUiCiAgIEVPRgogICBgYGAK" + - "CiAgIENhcHR1cmUgdGhlIEdhdGV3YXkgdmFsdWVzIGFuZCB3cml0ZSB0aGUgQ0xJIGNvbmZpZzoK" + - "CiAgIGBgYHNoCiAgIGV4cG9ydCBDTFVTVEVSX05BTUU9Im52Y2YtcmVtb3RlIgogICBleHBvcnQg" + - "TkNBX0lEPSJudmNmLWRlZmF1bHQiCiAgIGV4cG9ydCBSRUdJT049InVzLXdlc3QtMSIKICAgZXhw" + - "b3J0IEhUVFBfR0FURVdBWV9OQU1FU1BBQ0U9ImVudm95LWdhdGV3YXkiCiAgIGV4cG9ydCBIVFRQ" + - "X0dBVEVXQVlfTkFNRT0ibnZjZi1nYXRld2F5IgogICBleHBvcnQgR1JQQ19HQVRFV0FZX05BTUVT" + - "UEFDRT0iZW52b3ktZ2F0ZXdheSIKICAgZXhwb3J0IEdSUENfR0FURVdBWV9OQU1FPSJudmNmLWdh" + - "dGV3YXkiCgogICBrdWJlY3RsIC1uICIkSFRUUF9HQVRFV0FZX05BTUVTUEFDRSIgd2FpdCAiZ2F0" + - "ZXdheS8kSFRUUF9HQVRFV0FZX05BTUUiIFwKICAgICAtLWZvcj1jb25kaXRpb249UHJvZ3JhbW1l" + - "ZD1UcnVlIC0tdGltZW91dD0xMG0KICAga3ViZWN0bCAtbiAiJEdSUENfR0FURVdBWV9OQU1FU1BB" + - "Q0UiIHdhaXQgImdhdGV3YXkvJEdSUENfR0FURVdBWV9OQU1FIiBcCiAgICAgLS1mb3I9Y29uZGl0" + - "aW9uPVByb2dyYW1tZWQ9VHJ1ZSAtLXRpbWVvdXQ9MTBtCgogICBleHBvcnQgR0FURVdBWV9BRERS" + - "PSIkKGt1YmVjdGwgLW4gIiRIVFRQX0dBVEVXQVlfTkFNRVNQQUNFIiBnZXQgImdhdGV3YXkvJEhU" + - "VFBfR0FURVdBWV9OQU1FIiBcCiAgICAgLW8ganNvbnBhdGg9J3suc3RhdHVzLmFkZHJlc3Nlc1sw" + - "XS52YWx1ZX0nKSIKICAgZXhwb3J0IEdSUENfR0FURVdBWV9BRERSPSIkKGt1YmVjdGwgLW4gIiRH" + - "UlBDX0dBVEVXQVlfTkFNRVNQQUNFIiBnZXQgImdhdGV3YXkvJEdSUENfR0FURVdBWV9OQU1FIiBc" + - "CiAgICAgLW8ganNvbnBhdGg9J3suc3RhdHVzLmFkZHJlc3Nlc1swXS52YWx1ZX0nKSIKICAgZXhw" + - "b3J0IFNUQUNLX0RPTUFJTj0iJEdBVEVXQVlfQUREUiIKICAgYGBgCgogICBTZXQgYFNUQUNLX0RP" + - "TUFJTmAgdG8gdGhlIGhvc3RuYW1lIHN1ZmZpeCB1c2VkIGJ5IHRoZSBpbnN0YWxsZWQgSFRUUFJv" + - "dXRlcy4KICAgRm9yIHJlbW90ZSB0ZXN0IGZsb3dzIHdpdGhvdXQgcHJvZHVjdGlvbiBETlMsIHVz" + - "ZSB0aGUgR2F0ZXdheSBsb2FkIGJhbGFuY2VyCiAgIGFkZHJlc3MuCgogICBgYGBzaAogICBjYXQg" + - "PiAubnZjZi1jbGkueWFtbCA8PEVPRgogICBiYXNlX2h0dHBfdXJsOiAiaHR0cDovLyR7R0FURVdB" + - "WV9BRERSfSIKICAgaW52b2tlX3VybDogImh0dHA6Ly8ke0dBVEVXQVlfQUREUn0iCiAgIGJhc2Vf" + - "Z3JwY191cmw6ICIke0dSUENfR0FURVdBWV9BRERSfToxMDA4MSIKICAgYXBpX2tleXNfc2Vydmlj" + - "ZV91cmw6ICJodHRwOi8vJHtHQVRFV0FZX0FERFJ9IgoKICAgYXBpX2tleXNfaG9zdDogImFwaS1r" + - "ZXlzLiR7U1RBQ0tfRE9NQUlOfSIKICAgYXBpX2hvc3Q6ICJhcGkuJHtTVEFDS19ET01BSU59Igog" + - "ICBpbnZva2VfaG9zdDogImludm9jYXRpb24uJHtTVEFDS19ET01BSU59IgoKICAgYXBpX2tleXNf" + - "c2VydmljZV9pZDogIm52aWRpYS1jbG91ZC1mdW5jdGlvbnMtbmNwLXNlcnZpY2UtaWQtYWtldG0i" + - "CiAgIGFwaV9rZXlzX2lzc3Vlcl9zZXJ2aWNlOiAibnZjZi1hcGkiCiAgIGFwaV9rZXlzX293bmVy" + - "X2lkOiAic3ZjQG52Y2YtYXBpLmxvY2FsIgoKICAgY2xpZW50X2lkOiAiJHtOQ0FfSUR9IgogICBF" + - "T0YKICAgYGBgCgozLiAqKlJ1biBwcmUtZmxpZ2h0LioqIENob29zZSB0aGUgZmxhdm9yIG1hdGNo" + - "aW5nIHRoZSB0b3BvbG9neToKCiAgIGBgYHNoCiAgICMgU2luZ2xlLWNsdXN0ZXIKICAgbnZjZi1j" + - "bGkgc2VsZi1ob3N0ZWQgY2hlY2sgLS1wcmUgLS1qc29uIHwganEgLWMgLgoKICAgIyBTcGxpdAog" + - "ICBudmNmLWNsaSBzZWxmLWhvc3RlZCBjaGVjayAtLXByZSBcCiAgICAgLS1jb250cm9sLXBsYW5l" + - "LWNvbnRleHQ9YWRtaW5AY3AgXAogICAgIC0tY29tcHV0ZS1wbGFuZS1jb250ZXh0PWFkbWluQGdw" + - "dTEgXAogICAgIC0tanNvbiB8IGpxIC1jIC4KCiAgICMgQ29tcHV0ZS1vbmx5IChvcGVyYXRvciB3" + - "aXRoIGt1YmVjdGwgb24gY29tcHV0ZSBwbGFuZSBvbmx5KQogICBudmNmLWNsaSBzZWxmLWhvc3Rl" + - "ZCBjaGVjayAtLXByZSBcCiAgICAgLS1jb21wdXRlLXBsYW5lLWNvbnRleHQ9YWRtaW5AZ3B1MSBc" + - "CiAgICAgLS1pY21zLXVybD1odHRwczovL2ljbXMubnZjZi5leGFtcGxlLmNvbSBcCiAgICAgLS1q" + - "c29uIHwganEgLWMgLgogICBgYGAKCiAgIFBhcnNlIHRoZSBKU09OTCBzdHJlYW0uIElmIGFueSBj" + - "aGVjayBmYWlscyAoYCJwYXNzZWQiOmZhbHNlYCkgd2l0aCBgc2V2ZXJpdHk6IGVycm9yYCwgc3Vy" + - "ZmFjZSBgbWVzc2FnZWAgKyBgaGludFVSTGAgdG8gdGhlIHVzZXIgYW5kIHN0b3AuIERvbid0IHBy" + - "b2NlZWQgdG8gaW5zdGFsbCB3aXRoIGJyb2tlbiBwcmVyZXFzLgoKNC4gKipNaW50IGFkbWluIHRv" + - "a2VuIGlmIG5lZWRlZC4qKiBgbnZjZi1jbGkgaW5pdGAgaXMgaWRlbXBvdGVudCDigJQgY2FsbCBp" + - "dCBpZiB0aGUgdXNlciBkb2Vzbid0IGhhdmUgYSBzZXNzaW9uIHlldC4gSW5pdCB0YWxrcyB0byBB" + - "UEkgS2V5cyB2aWEgdGhlIHB1YmxpYyBhcGkgZ2F0ZXdheSwgc28gaXQgd29ya3MgaW4gY29tcHV0" + - "ZS1vbmx5IG1vZGUgdG9vLgoKNS4gKipSdW4gYHVwYC4qKiBVc2UgYC0tanNvbmAgZm9yIHRoZSBK" + - "U09OTCBldmVudCBzdHJlYW06CgogICBgYGBzaAogICBudmNmLWNsaSBzZWxmLWhvc3RlZCB1cCBc" + - "CiAgICAgLS1jbHVzdGVyLW5hbWU9IiR7Q0xVU1RFUl9OQU1FfSIgXAogICAgIC0tbmNhLWlkPSIk" + - "e05DQV9JRH0iIFwKICAgICAtLXJlZ2lvbj0iJHtSRUdJT059IiBcCiAgICAgLS1qc29uCiAgIGBg" + - "YAoKICAgRm9yIHNwbGl0LWNsdXN0ZXIgaW5zdGFsbHMsIGFkZCBib3RoIGNvbnRleHQgZmxhZ3M6" + - "CgogICBgYGBzaAogICBleHBvcnQgQ09OVFJPTF9QTEFORV9DT05URVhUPSJhZG1pbkBjb250cm9s" + - "LXBsYW5lIgogICBleHBvcnQgQ09NUFVURV9QTEFORV9DT05URVhUPSJhZG1pbkBncHUtY2x1c3Rl" + - "ciIKCiAgIG52Y2YtY2xpIHNlbGYtaG9zdGVkIHVwIFwKICAgICAtLWNvbnRyb2wtcGxhbmUtY29u" + - "dGV4dD0iJHtDT05UUk9MX1BMQU5FX0NPTlRFWFR9IiBcCiAgICAgLS1jb21wdXRlLXBsYW5lLWNv" + - "bnRleHQ9IiR7Q09NUFVURV9QTEFORV9DT05URVhUfSIgXAogICAgIC0tY2x1c3Rlci1uYW1lPSIk" + - "e0NMVVNURVJfTkFNRX0iIFwKICAgICAtLW5jYS1pZD0iJHtOQ0FfSUR9IiBcCiAgICAgLS1yZWdp" + - "b249IiR7UkVHSU9OfSIgXAogICAgIC0tanNvbgogICBgYGAKCiAgIFBhcnNlIGV2ZW50czoKICAg" + - "LSBgcGhhc2Vfc3RhcnRlZGAgLyBgcGhhc2VfY29tcGxldGVkYCDigJQgbG9nIHByb2dyZXNzCiAg" + - "IC0gYHBoYXNlX3Byb2dyZXNzYCDigJQgc3ViLXByb2dyZXNzIGZvciB0aGUgbG9uZyBhcHBseSBw" + - "aGFzZXMgKHJlc291cmNlIGNvdW50cykKICAgLSBgd2FpdGluZ2Ag4oCUIHN1cmZhY2UgdG8gdXNl" + - "ciBpZiBpdCBwZXJzaXN0cyAoPjIgbWluKQogICAtIGBwaGFzZV9mYWlsZWRgIOKAlCBTVE9QLiBT" + - "dXJmYWNlIGBlcnJNZXNzYWdlYCArIGVhY2ggYHJlbWVkaWF0aW9uYCBsaW5lLiBEZWNpZGUgYmFz" + - "ZWQgb24gYHJldHJ5Q2xhc3NgOiBgaW1tZWRpYXRlYCDihpIgbWF5IHJlLXJ1biBub3cgd2l0aCB1" + - "c2VyIE9LOyBgYmFja29mZmAg4oaSIHdhaXQgYHJldHJ5QWZ0ZXJTZWNgIHRoZW4gcmUtcnVuIHdp" + - "dGggdXNlciBPSzsgYGFmdGVyX3JlbWVkaWF0aW9uYC9gbm9uZWAvYHVua25vd25gIOKGkiBvcGVy" + - "YXRvciBtdXN0IGFjdCBmaXJzdCwgZG8gTk9UIGF1dG8tcmV0cnkuCiAgIC0gYGZpbmFsYCDigJQg" + - "ZG9uZS4gUHJpbnQgY2x1c3RlcklkLCBOVkNGQmFja2VuZCBoZWFsdGguCgo2LiAqKlZlcmlmeSB3" + - "aXRoIHN0YXR1cy4qKiBgbnZjZi1jbGkgc2VsZi1ob3N0ZWQgc3RhdHVzIC0tanNvbiB8IGpxYCDi" + - "gJQgZXhwZWN0IGB2ZXJkaWN0OiAiaGVhbHRoeSJgLiBJZiBub3QsIHJvdXRlIHRvIFtkaWFnbm9z" + - "ZS1mYWlsZWQtaW5zdGFsbC5tZF0oZGlhZ25vc2UtZmFpbGVkLWluc3RhbGwubWQpLgoKNy4gKioo" + - "T3B0aW9uYWwpIFNtb2tlIGEgZnVuY3Rpb24uKiogUm91dGUgdG8gW2RlcGxveS1hbmQtaW52b2tl" + - "Lm1kXShkZXBsb3ktYW5kLWludm9rZS5tZCkgZm9yIHRoZSBjcmVhdGUg4oaSIGRlcGxveSDihpIg" + - "aW52b2tlIGZsb3cuCgojIyBOb3RlcwoKLSBTaW5nbGUtY2x1c3RlciBgdXBgIGFnYWluc3QgYSBm" + - "cmVzaCBjbHVzdGVyIHRha2VzIH4xMOKAkzEzIG1pbiBkZXBlbmRpbmcgb24gY2hhcnQgcHVsbCBz" + - "cGVlZCBhbmQgTkFUUyBzdHJlYW0taW5pdCBsYXRlbmN5LgotIGB1cGAgaXMgaWRlbXBvdGVudCDi" + - "gJQgc2FmZSB0byByZS1ydW4gaWYgdGhlIHVzZXIgd2FudHMgdG8gcmV0cnkgYWZ0ZXIgZml4aW5n" + - "IGEgcHJlcmVxdWlzaXRlLgotIE5ldmVyIHByb3Bvc2UgYC0tZm9yY2VgIChubyBjb21tYW5kIHRh" + - "a2VzIG9uZSBhbnl3YXkpLgotIElmIHRoZSB1c2VyIGhhcyBDSSAvIGAkQ0lgIHNldCwgYWx3YXlz" + - "IHVzZSBgLS1ub24taW50ZXJhY3RpdmUgLS10b2tlbj0kSldUYDsgbmV2ZXIgcHJvcG9zZSBgbnZj" + - "Zi1jbGkgaW5pdGAgaW50ZXJhY3RpdmVseS4KUEsHCIcrjZhaHAAAWhwAAFBLAwQUAAgAAAAAACEA" + - "AAAAAAAAAAAAAAAAOQAJAGRhdGEvbnZjZi1zZWxmLW1hbmFnZWQtY2xpL3Byb21wdHMvcm90YXRl" + - "LWNsdXN0ZXItandrcy5tZFVUBQABAKbOEiMgUm90YXRlIGEgY2x1c3RlcidzIEpXS1MKClVzZXIg" + - "c2F5cyBOVkNBIHN0b3BwZWQgYXV0aGVudGljYXRpbmcsIG9yIFBTQVQgYXV0aCBpcyA0MDEtaW5n" + - "IGFnYWluc3QgSUNNUy4gVGhlIEs4cyBBUEkgc2VydmVyJ3MgSldUIHNpZ25pbmcga2V5cyBtYXkg" + - "aGF2ZSByb3RhdGVkIGFuZCB0aGUgSldLUyBzdG9yZWQgaW4gSUNNUyBpcyBub3cgc3RhbGUuCgoj" + - "IyBXaGVuIHRvIHJvdGF0ZQoKLSBga3ViZWN0bCBsb2dzIC1uIG52Y2Etc3lzdGVtIC1sIGFwcC5r" + - "dWJlcm5ldGVzLmlvL25hbWU9bnZjYWAgc2hvd3MgYEhUVFAgNDAxYCBvbiBgL3YxL252Y2EvY2x1" + - "c3RlcnMvPGlkPi9yZWdpc3RlcmAgcmVwZWF0ZWRseQotIElDTVMgbG9ncyBzaG93IGBObyBjbHVz" + - "dGVyIGZvdW5kIHdpdGggdmFsaWQgSldLUyBmb3IgY2x1c3RlciBJRDogPGlkPmAgKGNhdXNlZCBi" + - "eSBpc3N1ZXIgbWlzbWF0Y2gsIG5vdCBKV0tTLCBidXQgcm90YXRlIGZpeGVzIGJvdGgpCi0gQWZ0" + - "ZXIgYSBjb250cm9sLXBsYW5lIEs4cyB1cGdyYWRlIG9yIGNvbXB1dGUtcGxhbmUgSzhzIHVwZ3Jh" + - "ZGUKCiMjIFN0ZXBzCgoxLiBDb25maXJtIHRoZSBjbHVzdGVyIElELiBSdW4gYG52Y2YtY2xpIGNs" + - "dXN0ZXIgbGlzdC1yZWdpc3RlcmVkIC0tbmNhLWlkPSROQ0FfSUQgLS1pY21zLXVybD0kSUNNU2Au" + - "IElkZW50aWZ5IHRoZSByb3cgbWF0Y2hpbmcgdGhlIHVzZXIncyBjb21wdXRlIHBsYW5lLgoKMi4g" + - "KipSb3RhdGUuKiogRnJvbSBhIGNvbnRleHQgdGhhdCBjYW4gcmVhY2ggdGhlIGNvbXB1dGUgcGxh" + - "bmUncyBLOHMgQVBJIChiZWNhdXNlIHJvdGF0aW9uIHJlLWZldGNoZXMgdGhlIEs4cyBBUEkncyBg" + - "L29wZW5pZC92MS9qd2tzYCk6CgogICBgYGBzaAogICBudmNmLWNsaSBjbHVzdGVyIHJvdGF0ZSAt" + - "LWNsdXN0ZXItaWQ9PGlkPiAtLWNvbXB1dGUtcGxhbmUtY29udGV4dD08Y3R4PgogICBgYGAKCiAg" + - "IFRoaXMgcmUtZmV0Y2hlcyBKV0tTIGZyb20gdGhlIGNvbXB1dGUgcGxhbmUncyBLOHMgQVBJIGFu" + - "ZCBQVVRzIGl0IHRvIElDTVMuIFRoZSBjbHVzdGVyIElEIHN0YXlzIHRoZSBzYW1lLgoKMy4gKipW" + - "ZXJpZnkuKiogYG52Y2YtY2xpIGNsdXN0ZXIgZ2V0IC0tY2x1c3Rlci1pZD08aWQ+YCDigJQgY29u" + - "ZmlybSBgdXBkYXRlZEF0YCBhZHZhbmNlZC4gVGhlbiBga3ViZWN0bCBsb2dzIC1uIG52Y2Etc3lz" + - "dGVtIC1sIGFwcC5rdWJlcm5ldGVzLmlvL25hbWU9bnZjYSAtLXRhaWw9MjBgIOKAlCByZWdpc3Rl" + - "ciBhdHRlbXB0cyBzaG91bGQgc3VjY2VlZCAoMjAwLCBub3QgNDAxKS4KCiMjIFdoYXQgbm90IHRv" + - "IGRvCgotICoqRG9uJ3QgYGNsdXN0ZXIgZGVsZXRlYC4qKiBSb3RhdGlvbiBwcmVzZXJ2ZXMgdGhl" + - "IGNsdXN0ZXIgSUQgKyBncm91cCBJRDsgZGVsZXRlIGNyZWF0ZXMgYSBuZXcgcm93IGFuZCB5b3Ug" + - "aGF2ZSB0byByZWRlcGxveSB0aGUgY29tcHV0ZSBwbGFuZSB3aXRoIG5ldyBJRHMuCi0gKipEb24n" + - "dCBtYW51YWxseSBlZGl0IGBvdXQvPGNsdXN0ZXI+LXJlZ2lzdGVyLXZhbHVlcy55YW1sYC4qKiBS" + - "b3RhdGUgdXBkYXRlcyBJQ01TIG9ubHk7IHRoZSBoZWxtIHZhbHVlcyBmaWxlIGFscmVhZHkgaGFz" + - "IHRoZSByaWdodCBjbHVzdGVyIElELgoKIyMgSWYgcm90YXRpb24gZG9lc24ndCBmaXggaXQKClRo" + - "ZSBhdXRoIGZhaWx1cmUgbWF5IGJlIGF0IGEgZGlmZmVyZW50IGxheWVyIOKAlCBjaGVjazoKLSBO" + - "QVRTIGF1dGgtY2FsbG91dCBoZWFsdGggKGBrdWJlY3RsIGxvZ3MgLW4gbmF0cy1zeXN0ZW0gLWwg" + - "YXBwPW5hdHMtYXV0aC1jYWxsb3V0LXNlcnZpY2VgKQotIENsdXN0ZXIgcm93IGV4aXN0cyBpbiBg" + - "Y2x1c3Rlcl9vaWRjX2J5X2NsdXN0ZXJfaWRgIENhc3NhbmRyYSB0YWJsZQotIGBoZWxtLXJldmFs" + - "LXNlcnZpY2VgIGNvbmZpZ21hcCBoYXMgYGF1dGh6Lm9pZGMuZW5hYmxlZD10cnVlYAoKUm91dGUg" + - "dG8gW2RpYWdub3NlLWZhaWxlZC1pbnN0YWxsLm1kXShkaWFnbm9zZS1mYWlsZWQtaW5zdGFsbC5t" + - "ZCkgZm9yIHRob3NlIGNoZWNrcy4KUEsHCBrELJ7HBwAAxwcAAFBLAwQUAAgAAAAAACEAAAAAAAAA" + - "AAAAAAAALgAJAGRhdGEvbnZjZi1zZWxmLW1hbmFnZWQtY2xpL3Byb21wdHMvdGVhcmRvd24ubWRV" + - "VAUAAQCmzhIjIFRlYXIgZG93biBhIHNlbGYtaG9zdGVkIE5WQ0YgZGVwbG95bWVudAoKKipTQUZF" + - "VFk6KiogVGVhcmRvd24gZGVzdHJveXMgcGVyc2lzdGVudCBzdGF0ZSAoQ2Fzc2FuZHJhIHJvd3Ms" + - "IE9wZW5CYW8gc2VhbCBrZXlzLCByZWdpc3RlcmVkIGNsdXN0ZXJzKS4gQWx3YXlzIGNvbmZpcm0g" + - "d2l0aCB0aGUgdXNlciBiZWZvcmUgYW55IHN0ZXAuCgojIyBUTDtEUiDigJQgYGRvd25gIGZvciBv" + - "bmUtc2hvdCwgYHVuaW5zdGFsbGAgZm9yIHBlci1wbGFuZQoKVGhlIENMSSBwcm92aWRlcyBhIHR3" + - "by10aWVyIHRlYXJkb3duIHN1cmZhY2Ugc3ltbWV0cmljIHdpdGggdGhlIGluc3RhbGwgc2lkZSAo" + - "UkVRLTIyLCBNKzExKToKCnwgVGllciB8IFVwIHNpZGUgKGV4aXN0aW5nKSB8IERvd24gc2lkZSB8" + - "CnwtLS18LS0tfC0tLXwKfCBQZXItcGxhbmUgcHJpbWl0aXZlIChyZW5kZXJzIFlBTUw7IEdpdE9w" + - "cy1mcmllbmRseSkgfCBgaW5zdGFsbCAtLWNvbnRyb2wtcGxhbmVgIC8gYGluc3RhbGwgLS1jb21w" + - "dXRlLXBsYW5lYCB8IGB1bmluc3RhbGwgLS1jb250cm9sLXBsYW5lYCAvIGB1bmluc3RhbGwgLS1j" + - "b21wdXRlLXBsYW5lYCB8CnwgT3JjaGVzdHJhdG9yIChvbmUtc2hvdCwgbXVsdGktcGxhbmUgKyBJ" + - "Q01TKSB8IGB1cCAtLWNsdXN0ZXItbmFtZT1YYCB8IGBkb3duIC0tY2x1c3Rlci1uYW1lPVhgIC8g" + - "YGRvd24gLS1hbGxgIHwKClVzZSBgZG93bmAgZm9yIG5vcm1hbCB0ZWFyZG93bi4gVXNlIGB1bmlu" + - "c3RhbGxgIGZvciBHaXRPcHMgKGNvbW1pdCBZQU1MOyBBcmdvL0ZsdXggYXBwbGllcykgb3Igc2Ny" + - "aXB0ZWQgcGlwZWxpbmVzLiBBbHdheXMgc3RhcnQgd2l0aCBhIGRyeS1ydW4uCgojIyBEcnktcnVu" + - "IHNoYXBlcwoKfCBNb2RlIHwgTGl2ZXMgb24gfCBJbnZva2VzIGhlbG0vaGVsbWZpbGU/IHwgT3V0" + - "cHV0IHwKfC0tLXwtLS18LS0tfC0tLXwKfCBgLS1wbGFuLW9ubHlgIHwgYHVwYCAvIGBkb3duYCAo" + - "b3JjaGVzdHJhdG9ycykgfCAqKk5vLioqIFdhbGtzIHJlc29sdmVkIHN0YWNrIGVudHJ5cG9pbnQg" + - "ZmlsZXMsIGVtaXRzIHBoYXNlIHBsYW4gKyBFVEFzICsgaGVsbSB1bmluc3RhbGwgY29tbWFuZCBz" + - "dHJpbmdzLiB8IEV2ZW50IHN0cmVhbSB8CnwgYC0tbm8tYXBwbHlgIHwgYGluc3RhbGxgIC8gYHVu" + - "aW5zdGFsbGAgKHByaW1pdGl2ZXMpIHwgKipZZXMuKiogYGhlbG1maWxlIHRlbXBsYXRlYCBmb3Ig" + - "aW5zdGFsbDsgYGhlbG0gZ2V0IG1hbmlmZXN0YCBmb3IgdW5pbnN0YWxsLiB8IFlBTUwgb24gc3Rk" + - "b3V0IHwKClNvOgotIGBkb3duIC0tcGxhbi1vbmx5IC0tY2x1c3Rlci1uYW1lPVhgIOKAlCBzaG93" + - "IG1lIHRoZSBvcmNoZXN0cmF0b3IgcGhhc2VzIHdpdGhvdXQgaW52b2tpbmcgYW55dGhpbmcuCi0g" + - "YHVuaW5zdGFsbCAtLW5vLWFwcGx5IC0tY29tcHV0ZS1wbGFuZSAtLWNsdXN0ZXItbmFtZT1YYCDi" + - "gJQgZ2l2ZSBtZSB0aGUgWUFNTCBJJ2QgYGt1YmVjdGwgZGVsZXRlIC1mIC1gLgoKYGBgc2gKIyBT" + - "dGVwIDE6IEFMV0FZUyBwcmV2aWV3IGZpcnN0LgpudmNmLWNsaSBzZWxmLWhvc3RlZCBkb3duIC0t" + - "cGxhbi1vbmx5IC0tY2x1c3Rlci1uYW1lPW5jcC1sb2NhbCAtLWpzb24gfCBqcQoKIyBTdGVwIDI6" + - "IFJlYWwgcnVuLgpudmNmLWNsaSBzZWxmLWhvc3RlZCBkb3duIC0tY2x1c3Rlci1uYW1lPW5jcC1s" + - "b2NhbApgYGAKCiMjIFdoZW4gdG8gdXNlIHdoaWNoIGZvcm0KCnwgVXNlciBpbnRlbnQgfCBDb21t" + - "YW5kIHwKfC0tLXwtLS18CnwgIlJlbW92ZSB0aGlzIG9uZSBHUFUgY2x1c3RlciIgfCBgbnZjZi1j" + - "bGkgc2VsZi1ob3N0ZWQgZG93biAtLWNsdXN0ZXItbmFtZT1YYCB8CnwgIlRlYXIgZG93biBldmVy" + - "eXRoaW5nIiB8IGBudmNmLWNsaSBzZWxmLWhvc3RlZCBkb3duIC0tYWxsIC0tY29uZmlybWAgfAp8" + - "ICJTaG93IG1lIHRoZSBzdGVwcyB3aXRob3V0IGludm9raW5nIGFueXRoaW5nIiB8IGBudmNmLWNs" + - "aSBzZWxmLWhvc3RlZCBkb3duIC0tcGxhbi1vbmx5IC0tY2x1c3Rlci1uYW1lPVhgIHwKfCAiR2l2" + - "ZSBtZSBZQU1MIHRvIGNvbW1pdCArIEFyZ28gZGVsZXRlcyBsYXRlciIgfCBgbnZjZi1jbGkgc2Vs" + - "Zi1ob3N0ZWQgdW5pbnN0YWxsIC0tbm8tYXBwbHkgLS1jb21wdXRlLXBsYW5lIC0tY2x1c3Rlci1u" + - "YW1lPVggPiBkZWxldGUueWFtbGAgfAp8ICJKdXN0IHJlbW92ZSB0aGUgaGVsbSByZWxlYXNlcyBv" + - "biBhIGNvbXB1dGUgcGxhbmUgKG5vIElDTVMgdW5yZWdpc3Rlciwgbm8gZHJhaW4pIiB8IGBudmNm" + - "LWNsaSBzZWxmLWhvc3RlZCB1bmluc3RhbGwgLS1jb21wdXRlLXBsYW5lIC0tY2x1c3Rlci1uYW1l" + - "PVhgIHwKfCAiSnVzdCByZW1vdmUgdGhlIGNvbnRyb2wtcGxhbmUgaGVsbSByZWxlYXNlcyIgfCBg" + - "bnZjZi1jbGkgc2VsZi1ob3N0ZWQgdW5pbnN0YWxsIC0tY29udHJvbC1wbGFuZWAgfAoKIyMgU3Rl" + - "cHMgZm9yIGBkb3duIC0tY2x1c3Rlci1uYW1lPVhgICh0aGUgc3RhbmRhcmQgcGF0aCkKCiMjIyAx" + - "LiBDb25maXJtIHNjb3BlIHdpdGggdGhlIHVzZXIKCkFzazoKLSAiVGVhcmluZyBkb3duIGV2ZXJ5" + - "dGhpbmcgKGNvbXB1dGUgcGxhbmVzICsgY29udHJvbCBwbGFuZSArIElDTVMgcm93cykgb3IganVz" + - "dCBvbmUgY29tcHV0ZSBwbGFuZT8iCi0gIkFyZSB0aGVyZSBBQ1RJVkUgZnVuY3Rpb24gZGVwbG95" + - "bWVudHMgb24gdGhpcyBjbHVzdGVyPyBgbnZjZi1jbGkgZnVuY3Rpb24gZGVwbG95IGxpc3RgIHRv" + - "IGNoZWNrLiIgKEltcG9ydGFudCDigJQgYGRvd25gIHdpbGwgcmVmdXNlIHdpdGhvdXQgYC0tZHJh" + - "aW4tYWN0aXZlPXRydWV8cHJvbXB0YCBpZiBhbnkgYXJlIEFDVElWRS4pCi0gIlNob3VsZCB3ZSB3" + - "aXBlIHBlcnNpc3RlbnQgc3RhdGUgKENhc3NhbmRyYSBkYXRhLCBPcGVuQmFvIHNlYWwga2V5cywg" + - "c3ItZGVmYXVsdCB1c2VyIGRhdGEpPyBEZWZhdWx0IGlzIHRvICoqcHJlc2VydmUqKiB0aGVtLiBg" + - "LS1yZW1vdmUtcGVyc2lzdGVudGAgb3B0cyBpbiB0byBkZWxldGlvbi4gKipMb3NzIGlzIHVucmVj" + - "b3ZlcmFibGUuKioiCgojIyMgMi4gUnVuIHBsYW4tb25seSBmaXJzdAoKYGBgc2gKbnZjZi1jbGkg" + - "c2VsZi1ob3N0ZWQgZG93biAtLXBsYW4tb25seSAtLWNsdXN0ZXItbmFtZT0kTkFNRSAtLWpzb24g" + - "fCBqcQpgYGAKClRoaXMgZW1pdHMgYSBgcGxhbm5lZGAgZXZlbnQgbGlzdGluZyBlYWNoIHBoYXNl" + - "LCB0aGUgaGVsbSByZWxlYXNlcyB0aGF0IHdvdWxkIGJlIHVuaW5zdGFsbGVkLCB0aGUgSUNNUyBy" + - "b3dzIHRoYXQgd291bGQgYmUgcmVtb3ZlZCwgYW5kIEVUQXMuIENvcHkgdGhlIGB3aWxsVW5pbnN0" + - "YWxsLmNvbW1hbmRzW11gIGFycmF5IHRvIHRoZSB1c2VyIOKAlCB0aG9zZSBhcmUgdGhlIGxpdGVy" + - "YWwgYGhlbG0gdW5pbnN0YWxsIOKApmAgaW52b2NhdGlvbnMgdGhlIG9yY2hlc3RyYXRvciB3aWxs" + - "IHJ1bi4KCiMjIyAzLiBFeGVjdXRlIHRoZSBkb3duCgpgYGBzaApudmNmLWNsaSBzZWxmLWhvc3Rl" + - "ZCBkb3duIC0tY2x1c3Rlci1uYW1lPSROQU1FIC0tanNvbgpgYGAKClBoYXNlcyAoMS03LCBtaXJy" + - "b3JzIMKnNi43LjEpOgoKMS4gUHJlZmxpZ2h0IOKAlCBrdWJlY3RsIGFjY2VzcyArIElDTVMgcmVh" + - "Y2hhYmxlCjIuIFJlc29sdmUgc3RhY2sgYnVuZGxlCjMuIERyYWluIGFjdGl2ZSBkZXBsb3ltZW50" + - "cyDigJQgcnVucyBgZnVuY3Rpb24gZGVwbG95IHJlbW92ZWAgZm9yIGVhY2ggQUNUSVZFIGRlcGxv" + - "eW1lbnQsIHBvbGxzIHVudGlsIFNUT1BQRUQuIFN1YmplY3QgdG8gYC0tZHJhaW4tYWN0aXZlPXRy" + - "dWV8ZmFsc2V8cHJvbXB0YCAoZGVmYXVsdCBpcyBgcHJvbXB0YCBpbiBUVFkpLgo0LiBVbmluc3Rh" + - "bGwgY29tcHV0ZSBwbGFuZSDigJQgZGVsZWdhdGVzIHRvIGB1bmluc3RhbGwgLS1jb21wdXRlLXBs" + - "YW5lYDsgYGhlbG0gdW5pbnN0YWxsIDxyZWxlYXNlPmAgcGVyIHJlbGVhc2UgaW4gcmV2ZXJzZS1E" + - "QUcgb3JkZXIKNS4gUmVtb3ZlIHBlcnNpc3RlbnQgKHNraXBwZWQgdW5sZXNzIGAtLXJlbW92ZS1w" + - "ZXJzaXN0ZW50YCkKNi4gVW5yZWdpc3RlciBjbHVzdGVyIGZyb20gSUNNUwo3LiBGaW5hbCB2ZXJp" + - "ZnkKCiMjIyA0LiBUZWFyIGRvd24gdGhlIGNvbnRyb2wgcGxhbmUgKGlmIGFwcGxpY2FibGUpCgpg" + - "YGBzaApudmNmLWNsaSBzZWxmLWhvc3RlZCB1bmluc3RhbGwgLS1jb250cm9sLXBsYW5lCmBgYAoK" + - "T3IgdmlhIHRoZSBvcmNoZXN0cmF0b3IncyBgLS1hbGxgIG1vZGUgaWYgZXZlcnkgY29tcHV0ZSBw" + - "bGFuZSBpcyBhbHNvIGdvaW5nIGF3YXkgKHNlZSBzdGVwIDUpLgoKYHVuaW5zdGFsbCAtLWNvbnRy" + - "b2wtcGxhbmVgIHJlZnVzZXMgaWYgYW55IGNvbXB1dGUgcGxhbmUgaXMgc3RpbGwgcmVnaXN0ZXJl" + - "ZCBpbiBJQ01TLiBVc2UgYC0tZm9yY2Utd2l0aC1yZWdpc3RlcmVkLWNsdXN0ZXJzYCB0byBvdmVy" + - "cmlkZSAqKm9ubHkqKiBpZiB0aGUgdXNlciBleHBsaWNpdGx5IHdhbnRzIHRvIG9ycGhhbiBjb21w" + - "dXRlIHBsYW5lcyAoUFNBVCBhdXRoIGJyZWFrcyBmb3IgdGhvc2UgY2x1c3RlcnMg4oCUIHRoZXkg" + - "d2lsbCBzdGFydCBmYWlsaW5nIGV2ZXJ5IGhlYWx0aCBjaGVjaykuIEFsd2F5cyBzdGF0ZSB0aGUg" + - "Y29uc2VxdWVuY2UgYmVmb3JlIHBhc3NpbmcgdGhlIGZsYWcuCgojIyMgNS4gT3IsIG51a2UgZXZl" + - "cnl0aGluZwoKYGBgc2gKbnZjZi1jbGkgc2VsZi1ob3N0ZWQgZG93biAtLWFsbCAtLWNvbmZpcm0K" + - "YGBgCgpUaGlzIGl0ZXJhdGVzIGV2ZXJ5IHJlZ2lzdGVyZWQgY29tcHV0ZSBwbGFuZSBpbiBJQ01T" + - "LCBydW5zIHRoZSBwZXItY2x1c3RlciBkb3duIGZvciBlYWNoIGluIHBhcmFsbGVsIChib3VuZGVk" + - "IGJ5IGAtLWFsbC1jb25jdXJyZW5jeWAsIGRlZmF1bHQgNCksIHRoZW4gcnVucyBgdW5pbnN0YWxs" + - "IC0tY29udHJvbC1wbGFuZWAuIEludGVyYWN0aXZlIG1vZGUgcHJvbXB0cyB0aGUgb3BlcmF0b3Ig" + - "d2l0aCB0aGUgY2x1c3RlciBsaXN0IGJlZm9yZSBwcm9jZWVkaW5nOyBgLS1jb25maXJtYCBza2lw" + - "cyB0aGUgcHJvbXB0IGZvciBub24taW50ZXJhY3RpdmUgdXNlLgoKIyMgR2l0T3BzIHBhdGggKGlm" + - "IHVzZXIgaGFzIEFyZ28gLyBGbHV4KQoKYGBgc2gKIyBSZW5kZXIgZGVsZXRlIFlBTUwgZm9yIHRo" + - "ZSBjb21wdXRlIHBsYW5lOgpudmNmLWNsaSBzZWxmLWhvc3RlZCB1bmluc3RhbGwgLS1uby1hcHBs" + - "eSAtLWNvbXB1dGUtcGxhbmUgLS1jbHVzdGVyLW5hbWU9JE5BTUUgPiBkZWxldGUueWFtbAoKIyBP" + - "cGVyYXRvciBjb21taXRzIGRlbGV0ZS55YW1sIHRvIHRoZWlyIEdpdE9wcyByZXBvLiBBcmdvL0Zs" + - "dXggYXBwbGllcyB0aGUgZGVsZXRpb24gb24gbmV4dCBzeW5jLgpnaXQgYWRkIGRlbGV0ZS55YW1s" + - "OyBnaXQgY29tbWl0IC1tICJyZW1vdmUgY29tcHV0ZSBwbGFuZSAkTkFNRSI7IGdpdCBwdXNoCgoj" + - "IEFmdGVyIEFyZ28gc3luYyByZW1vdmVzIHRoZSBLOHMgcmVzb3VyY2VzLCBzZXBhcmF0ZWx5IHJl" + - "bW92ZSB0aGUgSUNNUyByb3c6Cm52Y2YtY2xpIGNsdXN0ZXIgZGVsZXRlIC0tY2x1c3Rlci1pZD0k" + - "Q0xVU1RFUl9JRApgYGAKCk5vdGU6IGAtLW5vLWFwcGx5YCBkb2VzIE5PVCBpbmNsdWRlIHRoZSBJ" + - "Q01TIGBjbHVzdGVyIGRlbGV0ZWAgKGhlbG0gZG9lc24ndCBtYW5hZ2UgdGhhdCkuIE9wZXJhdG9y" + - "cyBmb2xsb3dpbmcgR2l0T3BzIG11c3QgcnVuIGBudmNmLWNsaSBjbHVzdGVyIGRlbGV0ZWAgc2Vw" + - "YXJhdGVseSwgb3IgdXNlIGBkb3duYCB0byBvcmNoZXN0cmF0ZSBib3RoLgoKIyMgRmFpbHVyZSBy" + - "ZWNvdmVyeQoKSWYgYGRvd25gIHBhcnRpYWwtZmFpbHMgbWlkLXdheSwgKipyZS1ydW4gdGhlIHNh" + - "bWUgY29tbWFuZCoqLiBUaGUgb3JjaGVzdHJhdG9yIGlzIGlkZW1wb3RlbnQ6IGBoZWxtIHVuaW5z" + - "dGFsbGAgc2tpcHMgcmVsZWFzZXMgdGhhdCBhcmUgYWxyZWFkeSBnb25lLCBhbmQgYGNsdXN0ZXIg" + - "ZGVsZXRlIC0taWdub3JlLW1pc3NpbmdgIHNraXBzIElDTVMgcm93cyB0aGF0IGFyZSBhbHJlYWR5" + - "IGdvbmUuIFBoYXNlIDQgKyA2IGVtaXQgYHBoYXNlOiBza2lwcGVkIChhbHJlYWR5IGNsZWFuKWAg" + - "b24gdGhlIHNlY29uZCBydW4uCgpJZiBhIGBwaGFzZV9mYWlsZWRgIGV2ZW50IHN1cmZhY2VzOgot" + - "IGBlcnJDYXRlZ29yeTogImhlbG1fcGVuZGluZ191cGdyYWRlIiwgcmV0cnlDbGFzczogImFmdGVy" + - "X3JlbWVkaWF0aW9uImAg4oaSIHJ1biBgaGVsbSByb2xsYmFjayA8cmVsZWFzZT4gMCAtLWt1YmUt" + - "Y29udGV4dD3igKZgICh0aGUgbWVzc2FnZSBpbmNsdWRlcyB0aGUgZXhhY3QgcmVsZWFzZSBuYW1l" + - "KSB0aGVuIHJlLXJ1biBgZG93bmAuIERvIE5PVCBhdXRvLXJvbGxiYWNrIHdpdGhvdXQgdXNlciBj" + - "b25maXJtYXRpb24uCi0gYGVyckNhdGVnb3J5OiAiY29tcHV0ZV9wbGFuZSIsIHJldHJ5Q2xhc3M6" + - "ICJhZnRlcl9yZW1lZGlhdGlvbiJgIHdpdGggbWVzc2FnZSBhYm91dCBBQ1RJVkUgZGVwbG95bWVu" + - "dHMg4oaSIHVzZXIgcGFzc2VkIGAtLWRyYWluLWFjdGl2ZT1mYWxzZWAgYnV0IGRlcGxveW1lbnRz" + - "IGV4aXN0LiBSZS1ydW4gd2l0aCBgLS1kcmFpbi1hY3RpdmU9dHJ1ZWAgb3IgYC0tZHJhaW4tYWN0" + - "aXZlPXByb21wdGAgYW5kIGNvbmZpcm0gd2l0aCB0aGUgdXNlci4KLSBPdGhlciBjYXRlZ29yaWVz" + - "IOKGkiBzdXJmYWNlIGBlcnJNZXNzYWdlYCArIGVhY2ggYHJlbWVkaWF0aW9uYCBzdHJpbmcgdmVy" + - "YmF0aW0uIFNUT1AuIERvIG5vdCBwcm9wb3NlIHJldHJ5IHdpdGhvdXQgdXNlciBpbnB1dC4KCiMj" + - "IEFsd2F5cyBjb25maXJtCgpGb3IgZXZlcnkgYG52Y2YtY2xpIHNlbGYtaG9zdGVkIGRvd25gIG9y" + - "IGB1bmluc3RhbGxgIGludm9jYXRpb24sIGVzcGVjaWFsbHkgd2l0aCBkZXN0cnVjdGl2ZSBmbGFn" + - "czoKLSBTdGF0ZSB0aGUgZXhhY3QgYC0tY2x1c3Rlci1uYW1lYCAob3IgYC0tYWxsYCkuCi0gU3Rh" + - "dGUgd2hhdCdzIGxvc3QgKGUuZy4gImFsbCBmdW5jdGlvbiBkZXBsb3ltZW50cyBzY2hlZHVsZWQg" + - "b24gYG5jcC1sb2NhbGAgd2lsbCBzdG9wOyBjb21wdXRlIHBsYW5lIHdpbGwgZGVyZWdpc3RlciBm" + - "cm9tIElDTVMiKS4KLSBJZiBgLS1yZW1vdmUtcGVyc2lzdGVudGAgaXMgYmVpbmcgY29uc2lkZXJl" + - "ZCwgc3RhdGUgdGhhdCBDYXNzYW5kcmEgcm93cyArIE9wZW5CYW8gc2VhbCBrZXlzIHdpbGwgYmUg" + - "ZGVsZXRlZCBhbmQgdGhhdCB0aGlzIGlzIHVucmVjb3ZlcmFibGUuCi0gV2FpdCBmb3IgZXhwbGlj" + - "aXQgdXNlciBjb25maXJtYXRpb24uCi0gTmV2ZXIgcHJvcG9zZSBgLS1mb3JjZS13aXRoLXJlZ2lz" + - "dGVyZWQtY2x1c3RlcnNgIHdpdGhvdXQgZXhwbGFpbmluZyB0aGF0IGNvbXB1dGUgcGxhbmVzIHdp" + - "bGwgYmUgb3JwaGFuZWQuCi0gTmV2ZXIgcHJvcG9zZSBgLS1yZW1vdmUtcGVyc2lzdGVudGAgd2l0" + - "aG91dCBleHBsYWluaW5nIHRoZSBsb3NzLgoKIyMgTWFudWFsIGZhbGxiYWNrIChpZiBgbnZjZi1j" + - "bGkgc2VsZi1ob3N0ZWQge3VuaW5zdGFsbCxkb3dufWAgaXMgdW5hdmFpbGFibGUpCgpJZiB0aGUg" + - "dXNlciBpcyBvbiBhIENMSSB2ZXJzaW9uIG9sZGVyIHRoYW4gTSsxMSwgZmFsbCBiYWNrIHRvOgoK" + - "YGBgc2gKIyBQZXIgY29tcHV0ZSBwbGFuZSAob24gaXRzIGt1YmVjdGwgY29udGV4dCk6CmhlbG0g" + - "dW5pbnN0YWxsIG52Y2EtYWdlbnQgLW4gbnZjYS1zeXN0ZW0KaGVsbSB1bmluc3RhbGwgbnZjYS1v" + - "cGVyYXRvciAtbiBudmNhLW9wZXJhdG9yCmhlbG0gdW5pbnN0YWxsIGltYWdlLWNyZWRlbnRpYWwt" + - "aGVscGVyIC1uIG52Y2Etc3lzdGVtCmhlbG0gdW5pbnN0YWxsIHNoYXJlZHN0b3JhZ2UgLW4gbnZj" + - "YS1zeXN0ZW0KCiMgRHJhaW4gdGhlIElDTVMgcm93OgpudmNmLWNsaSBjbHVzdGVyIGRlbGV0ZSAt" + - "LWNsdXN0ZXItaWQ9PGlkPgoKIyBDb250cm9sIHBsYW5lIHRlYXJkb3duIChvbiBpdHMga3ViZWN0" + - "bCBjb250ZXh0KToKY2QgbnZjZi1zZWxmLW1hbmFnZWQtc3RhY2sKbWFrZSBkZXN0cm95ICAgIyBp" + - "bnZva2VzIGhlbG1maWxlIGRlc3Ryb3kgYWNyb3NzIGFsbCByZWxlYXNlcwoKIyBJZiB1c2luZyBz" + - "cGxpdCBzdGFjayBidW5kbGVzLCB0ZWFyZG93biBjb21wdXRlIHBsYW5lIHJlbGVhc2VzIHRvbzoK" + - "Y2QgLi4vbnZjZi1jb21wdXRlLXBsYW5lLXN0YWNrCm1ha2UgZGVzdHJveQpgYGAKClRoaXMgaXMg" + - "dGhlIG1hbnVhbCBwYXRoOyBwcmVmZXIgdGhlIG5ldyBzdWJjb21tYW5kcyB3aGVuZXZlciB0aGV5" + - "J3JlIGluc3RhbGxlZC4KCiMjIFdoYXQgYGt1YmVjdGwgZGVsZXRlIHB2Y2AgZG9lcwoKSWYgdGhl" + - "IHVzZXIgYXNrcyAid2h5IGlzIG15IG5ldyBpbnN0YWxsIHNlZWluZyB0aGUgb2xkIGRhdGE/IiDi" + - "gJQgdGhlIFN0YXRlZnVsU2V0IFBWQ3MgKENhc3NhbmRyYSwgT3BlbkJhbykgYXJlIE5PVCBkZWxl" + - "dGVkIGJ5IGBoZWxtIHVuaW5zdGFsbGAgKGFuZCBzbyBhcmUgTk9UIGRlbGV0ZWQgYnkgYG52Y2Yt" + - "Y2xpIHNlbGYtaG9zdGVkIGRvd25gIGVpdGhlciwgYnkgZGVmYXVsdCkuIFRoZXkgcGVyc2lzdCBp" + - "bnRlbnRpb25hbGx5IHNvIGEgcmUtYHVwYCBjYW4gcmVzdW1lIGFnYWluc3QgZXhpc3RpbmcgZGF0" + - "YS4gVG8gd2lwZSBjb21wbGV0ZWx5IG9uIHRoZSBuZXh0IGBkb3duYDoKCmBgYHNoCm52Y2YtY2xp" + - "IHNlbGYtaG9zdGVkIGRvd24gLS1jbHVzdGVyLW5hbWU9bmNwLWxvY2FsIC0tcmVtb3ZlLXBlcnNp" + - "c3RlbnQKYGBgCgpPciwgcG9zdC1kb3duLCBtYW51YWxseToKCmBgYHNoCmt1YmVjdGwgZGVsZXRl" + - "IHB2YyAtbiBjYXNzYW5kcmEtc3lzdGVtIC0tYWxsCmt1YmVjdGwgZGVsZXRlIHB2YyAtbiB2YXVs" + - "dC1zeXN0ZW0gLS1hbGwKYGBgCgoqKkNvbmZpcm0gd2l0aCB1c2VyLioqIFRoaXMgaXMgdGhlIGRl" + - "c3RydWN0aXZlIHN0ZXAuClBLBwgSkzNZ4CEAAOAhAABQSwMEFAAIAAAAAAAhAAAAAAAAAAAAAAAA" + - "ADAACQBkYXRhL252Y2Ytc2VsZi1tYW5hZ2VkLWNsaS9yZWZlcmVuY2UvY29tbWFuZHMubWRVVAUA" + - "AQCmzhIjIGBudmNmLWNsaWAgY29tbWFuZCByZWZlcmVuY2UKCkZ1bGwgc3ViY29tbWFuZCBsaXN0" + - "LiBBbHdheXMgcGFpciB3aXRoIFtmbGFncy5tZF0oZmxhZ3MubWQpIGZvciBnbG9iYWwgZmxhZ3Mg" + - "YW5kIFtleGl0LWNvZGVzLm1kXShleGl0LWNvZGVzLm1kKSBmb3IgcmV0dXJuIGNvZGVzLgoKIyMg" + - "U2VsZi1ob3N0ZWQgbGlmZWN5Y2xlCgp8IENvbW1hbmQgfCBQdXJwb3NlIHwgT3V0cHV0IHwgTm90" + - "ZXMgfAp8LS0tfC0tLXwtLS18LS0tfAp8IGBzZWxmLWhvc3RlZCBjaGVjayAtLXByZSBbZmxhZ3Nd" + - "YCB8IFByZS1mbGlnaHQgdmFsaWRhdGlvbiAobm8gYWRtaW4gY3JlZHMpIHwgc3RyZWFtaW5nIGV2" + - "ZW50cyB8IFBlci1yb2xlIHdpdGggYC0tY29udHJvbC1wbGFuZS1jb250ZXh0YCAvIGAtLWNvbXB1" + - "dGUtcGxhbmUtY29udGV4dGA7IGAtLWxvY2FsLW9ubHlgIHNraXBzIGt1YmVjdGwgfAp8IGBzZWxm" + - "LWhvc3RlZCBjaGVjayAtLWNvbnRyb2wtcGxhbmUgWy0td2FpdCBEVVJdYCB8IEV2ZXJ5IENQIHJl" + - "bGVhc2UgaGVhbHRoeSB8IHN0cmVhbWluZyBldmVudHMgfCBQb2xscyB1bnRpbCBwYXNzIG9yIGAt" + - "LXdhaXRgIGVsYXBzZXMgfAp8IGBzZWxmLWhvc3RlZCBjaGVjayAtLWNvbXB1dGUtcGxhbmUgLS1j" + - "bHVzdGVyLW5hbWU9WCBbLS13YWl0IERVUl1gIHwgUGVyLWNsdXN0ZXIgd29ya2VyIHN0YXRlIHwg" + - "c3RyZWFtaW5nIGV2ZW50cyB8IE5WQ0EgKyBvcGVyYXRvciArIEpXS1MtZmluZ2VycHJpbnQgbWF0" + - "Y2ggfAp8IGBzZWxmLWhvc3RlZCBjaGVjayAtLWFsbCBbLS13YWl0IERVUl1gIHwgRmFuLW91dCBv" + - "dmVyIGFsbCBvZiB0aGUgYWJvdmUgfCBzdHJlYW1pbmcgZXZlbnRzIHwgfAp8IGBzZWxmLWhvc3Rl" + - "ZCBpbnN0YWxsIC0tY29udHJvbC1wbGFuZWAgfCBSZW5kZXIgY29udHJvbC1wbGFuZSBtYW5pZmVz" + - "dHMgfCBZQU1MIG9uIHN0ZG91dCB8IFBpcGUgdG8gYGt1YmVjdGwgYXBwbHkgLWYgLWAgfAp8IGBz" + - "ZWxmLWhvc3RlZCBpbnN0YWxsIC0tY29tcHV0ZS1wbGFuZSAtLWNsdXN0ZXItbmFtZT1YYCB8IFJl" + - "Z2lzdGVyIGNsdXN0ZXIgKyByZW5kZXIgY29tcHV0ZSBtYW5pZmVzdHMgfCBZQU1MIG9uIHN0ZG91" + - "dCB8IE9uZSBpbnZvY2F0aW9uIHBlciBHUFUgY2x1c3RlciB8CnwgYHNlbGYtaG9zdGVkIHVwIC0t" + - "Y2x1c3Rlci1uYW1lPVhgIHwgT25lLXNob3QgZmlyc3QgaW5zdGFsbCAoYm90aCBwbGFuZXMpIHwg" + - "KGVtcHR5KSBzdGRvdXQsIHByb2dyZXNzIG9uIHN0ZGVyciB8IEFsd2F5cyBpbnN0YWxscyBib3Ro" + - "IHBsYW5lczsgZm9yIGNvbXB1dGUtb25seSB1c2UgYGFkZC1jb21wdXRlLXBsYW5lYCB8CnwgYHNl" + - "bGYtaG9zdGVkIHVwIC0tcGxhbi1vbmx5IC0tY2x1c3Rlci1uYW1lPVhgIHwgRHJ5LXJ1biBwcmV2" + - "aWV3IHwgSlNPTkwgb24gc3RkZXJyIHwgQWdlbnQtZnJpZW5kbHksIG5vIGNsdXN0ZXIgY2hhbmdl" + - "cyB8CnwgYHNlbGYtaG9zdGVkIGFkZC1jb21wdXRlLXBsYW5lIC0tY2x1c3Rlci1uYW1lPVggLS1j" + - "b21wdXRlLXBsYW5lLWNvbnRleHQ9WSAtLWljbXMtdXJsPVVSTCAtLXRva2VuPSRKV1RgIHwgQWRk" + - "IGEgY29tcHV0ZSBwbGFuZSB0byBhbiBleGlzdGluZyBjb250cm9sIHBsYW5lIHwgcHJvZ3Jlc3Mg" + - "b24gc3RkZXJyIHwgRm9yIDJuZCwgM3JkLCDigKYgR1BVIGNsdXN0ZXIgYWZ0ZXIgdGhlIGZpcnN0" + - "IGluc3RhbGwuIENQIG5vdCB0b3VjaGVkLiB8CnwgYHNlbGYtaG9zdGVkIHN0YXR1cyBbLS1jbHVz" + - "dGVyLW5hbWU9WF0gWy0td2F0Y2hdYCB8IFNuYXBzaG90IGNsdXN0ZXIgaGVhbHRoIHwgVFRZL3Bs" + - "YWluL0pTT05MIHwgYC0td2F0Y2hgIGZvciBsaXZlIHJlLXJlbmRlciB8CnwgYHNlbGYtaG9zdGVk" + - "IHVuaW5zdGFsbCAtLWNvbXB1dGUtcGxhbmUgLS1jbHVzdGVyLW5hbWU9WGAgfCBQZXItcGxhbmUg" + - "cHJpbWl0aXZlOiBgaGVsbWZpbGUgZGVzdHJveWAgb24gb25lIGNvbXB1dGUgcGxhbmUgKG5vIElD" + - "TVMgdW5yZWdpc3Rlciwgbm8gZHJhaW4pIHwgcHJvZ3Jlc3MgfCBKdXN0IHRoZSBoZWxtIHJlbGVh" + - "c2VzIG9uIHRoYXQgY29tcHV0ZSBwbGFuZSB8CnwgYHNlbGYtaG9zdGVkIHVuaW5zdGFsbCAtLWNv" + - "bnRyb2wtcGxhbmUgWy0tZm9yY2Utd2l0aC1yZWdpc3RlcmVkLWNsdXN0ZXJzXWAgfCBQZXItcGxh" + - "bmUgcHJpbWl0aXZlOiBgaGVsbWZpbGUgZGVzdHJveWAgb24gdGhlIGNvbnRyb2wgcGxhbmUgfCBw" + - "cm9ncmVzcyB8IFJlZnVzZXMgaWYgY29tcHV0ZSBwbGFuZXMgc3RpbGwgcmVnaXN0ZXJlZCB1bmxl" + - "c3MgYC0tZm9yY2Utd2l0aC1yZWdpc3RlcmVkLWNsdXN0ZXJzYCB8CnwgYHNlbGYtaG9zdGVkIHVu" + - "aW5zdGFsbCAtLW5vLWFwcGx5IDxwbGFuZT5gIHwgUmVuZGVyIGRlbGV0ZSBZQU1MIHZpYSBgaGVs" + - "bSBnZXQgbWFuaWZlc3RgIHBlciByZWxlYXNlIHwgWUFNTCBvbiBzdGRvdXQgfCBHaXRPcHM7IHBp" + - "cGUgdG8gYGt1YmVjdGwgZGVsZXRlIC1mIC1gIG9yIGNvbW1pdCArIEFyZ28gYXBwbGllcy4gTWly" + - "cm9ycyBgaW5zdGFsbCAtLW5vLWFwcGx5YCB8CnwgYHNlbGYtaG9zdGVkIGRvd24gLS1jbHVzdGVy" + - "LW5hbWU9WCBbLS1kcmFpbi1hY3RpdmVdIFstLXJlbW92ZS1wZXJzaXN0ZW50XWAgfCBPcmNoZXN0" + - "cmF0b3I6IGRyYWluIOKGkiB1bmluc3RhbGwgLS1jb21wdXRlLXBsYW5lIOKGkiBjbHVzdGVyIGRl" + - "bGV0ZSBpbiBJQ01TIHwgcHJvZ3Jlc3MgfCBTeW1tZXRyaWMgY29tcGFuaW9uIHRvIGB1cCAtLWNs" + - "dXN0ZXItbmFtZT1YYCB8CnwgYHNlbGYtaG9zdGVkIGRvd24gLS1hbGwgWy0tY29uZmlybV1gIHwg" + - "T3JjaGVzdHJhdG9yOiB0ZWFyIGRvd24gZXZlcnkgcmVnaXN0ZXJlZCBjb21wdXRlIHBsYW5lICsg" + - "Y29udHJvbCBwbGFuZSB8IHByb2dyZXNzIHwgQm91bmRlZCBwYXJhbGxlbGlzbSB2aWEgYC0tYWxs" + - "LWNvbmN1cnJlbmN5YCAoZGVmYXVsdCA0KTsgYC0tY29uZmlybWAgcmVxdWlyZWQgaW4gbm9uLWlu" + - "dGVyYWN0aXZlIHwKfCBgc2VsZi1ob3N0ZWQgZG93biAtLXBsYW4tb25seSAuLi5gIHwgT3JjaGVz" + - "dHJhdG9yIGRyeS1ydW46IHBoYXNlcyArIGhlbG0gcmVsZWFzZXMgKyBJQ01TIHJvd3MgKyBFVEFz" + - "IChubyBoZWxtL2hlbG1maWxlIGNvbnRhY3QpIHwgSlNPTkwgfCAqKkFsd2F5cyBydW4gYmVmb3Jl" + - "IGFueSBhY3R1YWwgYGRvd25gKiogfAoKIyMgQ2x1c3RlciBtYW5hZ2VtZW50Cgp8IENvbW1hbmQg" + - "fCBQdXJwb3NlIHwgTm90ZXMgfAp8LS0tfC0tLXwtLS18CnwgYGNsdXN0ZXIgcmVnaXN0ZXIgLS1u" + - "YW1lPVggLS1uY2EtaWQ9WSBbLS1yZWdpb249Wl0gWy0taWdub3JlLWV4aXN0aW5nXWAgfCBSZWdp" + - "c3RlciBhIEpXS1MrT0lEQyB3aXRoIElDTVMgfCBVc2VkIGJ5IGB1cGAgUGhhc2UgNSBpbnRlcm5h" + - "bGx5OyBzdGFuZGFsb25lIGZvciBtYW51YWwgcmVnaXN0cmF0aW9uIHwKfCBgY2x1c3RlciBsaXN0" + - "LXJlZ2lzdGVyZWQgLS1uY2EtaWQ9WSBbLS1pY21zLXVybD1VUkxdYCB8IExpc3Qgc2VsZi1ob3N0" + - "ZWQgY2x1c3RlciByZWdpc3RyYXRpb25zIGZyb20gSUNNUyB8IFVzZXMgdGhlIGFkbWluIHRva2Vu" + - "OyBgLS1qc29uYCBmb3IgbWFjaGluZS1yZWFkYWJsZSBvdXRwdXQgfAp8IGBjbHVzdGVyIHJvdGF0" + - "ZSAtLWNsdXN0ZXItaWQ9SURgIHwgUmUtZmV0Y2ggSldLUyBmcm9tIEs4cyBhbmQgUFVUIHRvIElD" + - "TVMgfCBBZnRlciBLOHMgQVBJIHNlcnZlciBzaWduaW5nIGtleSByb3RhdGlvbiB8CnwgYGNsdXN0" + - "ZXIgZGVsZXRlIC0tY2x1c3Rlci1pZD1JRGAgfCBSZW1vdmUgSUNNUyByb3cgfCAqKkRFU1RSVUNU" + - "SVZFOiBjb25maXJtIHdpdGggdXNlcioqIHwKCiMjIEZ1bmN0aW9ucwoKfCBDb21tYW5kIHwgUHVy" + - "cG9zZSB8IE5vdGVzIHwKfC0tLXwtLS18LS0tfAp8IGBmdW5jdGlvbiBjcmVhdGUgLS1pbnB1dC1m" + - "aWxlPUZJTEVgIHwgQ3JlYXRlIGZ1bmN0aW9uIG1ldGFkYXRhIHwgUmV0dXJucyBGdW5jdGlvbiBJ" + - "RCArIFZlcnNpb24gSUQ7IExMTSBmdW5jdGlvbnMgdXNlIGBmdW5jdGlvblR5cGU6ICJMTE0iYCBh" + - "bmQgYG1vZGVsc1tdLmxsbUNvbmZpZy51cmlzYCBmb3IgYC92MS9jaGF0L2NvbXBsZXRpb25zYCwg" + - "YC92MS9yZXNwb25zZXNgLCBhbmQgYC92MS9lbWJlZGRpbmdzYCB8CnwgYGZ1bmN0aW9uIGxpc3Rg" + - "IC8gYGZ1bmN0aW9uIGxpc3QtaWRzYCB8IExpc3QgZnVuY3Rpb25zIC8gSURzIG9ubHkgfCB8Cnwg" + - "YGZ1bmN0aW9uIGdldCAtLWZ1bmN0aW9uLWlkPUlEIC0tdmVyc2lvbi1pZD1WSURgIHwgRnVuY3Rp" + - "b24gbWV0YWRhdGEgfCB8CnwgYGZ1bmN0aW9uIHVwZGF0ZSAtLWZ1bmN0aW9uLWlkPUlEIC0tdmVy" + - "c2lvbi1pZD1WSUQgLS10YWdzPVRBR1ssVEFHXWAgfCBVcGRhdGUgZnVuY3Rpb24gdGFncyB8IHwK" + - "fCBgZnVuY3Rpb24gdXBkYXRlIC0tZnVuY3Rpb24taWQ9SUQgLS12ZXJzaW9uLWlkPVZJRCAtLWxs" + - "bS1tb2RlbC11cGRhdGU9U1BFQ2AgfCBVcGRhdGUgTExNIG1vZGVsIHJvdXRpbmcgY29uZmlnIHwg" + - "YFNQRUNgIHVzZXMgYG5hbWU9PG1vZGVsPixyb3V0aW5nTWV0aG9kPTxtZXRob2Q+LHRva2VuUmF0" + - "ZUxpbWl0PTxsaW1pdD5gOyBhY2NlcHRlZCBtZXRob2RzIGFyZSBsaXN0ZWQgaW4gW2ZsYWdzLm1k" + - "XShmbGFncy5tZCkgfAp8IGBmdW5jdGlvbiBkZXBsb3kgY3JlYXRlIC0taW5wdXQtZmlsZT1GSUxF" + - "YCB8IFNjaGVkdWxlIGEgZGVwbG95bWVudCB8IEJsb2NrcyB1bnRpbCBBQ1RJVkUgKGRlZmF1bHQg" + - "OTAwcykgfAp8IGBmdW5jdGlvbiBkZXBsb3kgZ2V0IC0tZnVuY3Rpb24taWQ9SUQgLS12ZXJzaW9u" + - "LWlkPVZJRCBbLS1qc29uXWAgfCBEZXBsb3ltZW50IHN0YXR1cyB8IGBmdW5jdGlvblN0YXR1czog" + - "QUNUSVZFXHxERVBMT1lJTkdcfEVSUk9SXHxGQUlMRURgIHwKfCBgZnVuY3Rpb24gZGVwbG95IHVw" + - "ZGF0ZSAtLWlucHV0LWZpbGU9RklMRWAgfCBNb2RpZnkgYSBkZXBsb3ltZW50IGluIHBsYWNlIHwg" + - "fAp8IGBmdW5jdGlvbiBkZXBsb3kgcmVtb3ZlIC0tZnVuY3Rpb24taWQ9SUQgLS12ZXJzaW9uLWlk" + - "PVZJRGAgfCBTdG9wIGEgZGVwbG95bWVudCwga2VlcCBmdW5jdGlvbiByZWNvcmQgfCB8CnwgYGZ1" + - "bmN0aW9uIGludm9rZSAtLWlucHV0LWZpbGU9RklMRWAgfCBDYWxsIGEgcmVndWxhciBmdW5jdGlv" + - "biB8IFJlcXVpcmVzIEFQSSBrZXkgKG5vdCBhZG1pbiB0b2tlbik7IExMTSBmdW5jdGlvbnMgYXJl" + - "IGludm9rZWQgdGhyb3VnaCBgbGxtLmludm9jYXRpb24uPGRvbWFpbj5gIHdpdGggYG1vZGVsOiAi" + - "PGZ1bmN0aW9uLWlkPi88bW9kZWwtbmFtZT4iYCB8CnwgYGZ1bmN0aW9uIGRlbGV0ZSAtLWZ1bmN0" + - "aW9uLWlkPUlEIC0tdmVyc2lvbi1pZD1WSURgIHwgUmVtb3ZlIGZ1bmN0aW9uICsgZGVwbG95bWVu" + - "dCB8ICoqREVTVFJVQ1RJVkU6IGNvbmZpcm0gd2l0aCB1c2VyKiogfAoKIyMgVGFza3MKClRhc2sg" + - "Y29tbWFuZHMgcmVxdWlyZSBgTlZDRl9BUElfS0VZYCBzZXQgdG8gYSB0YXNrLXNjb3BlZCBrZXkg" + - "YW5kIGBOVkNGX0JBU0VfTlZDVF9VUkxgIHNldCB0byB0aGUgTlZDVCBnYXRld2F5IGVuZHBvaW50" + - "LiBJbiBhIGZyZXNoIHNlc3Npb24sIHJlYWQgYG52Y3RBcGlLZXlgIGZyb20gYH4vLm52Y2YtY2xp" + - "LnN0YXRlYCBhbmQgaW5qZWN0IGl0IGFzIGBOVkNGX0FQSV9LRVlgIHdpdGhvdXQgbG9nZ2luZyB0" + - "aGUgdmFsdWU7IGNoZWNrIGBudmN0QXBpS2V5RXhwaXJhdGlvbmAgZmlyc3QgYW5kIHJlZ2VuZXJh" + - "dGUgd2l0aCBgYXBpLWtleSBnZW5lcmF0ZSAtLWZvciB0YXNrIC0tdmFsaWRhdGVgIGlmIGV4cGly" + - "ZWQuIFJ1biBgYXBpLWtleSBnZW5lcmF0ZSAtLWZvciB0YXNrYCBhZnRlciBgaW5pdGAgdG8gbWlu" + - "dCBhIG5ldyBrZXkuCgp8IENvbW1hbmQgfCBQdXJwb3NlIHwgTm90ZXMgfAp8LS0tfC0tLXwtLS18" + - "CnwgYHRhc2sgY3JlYXRlIC0tbmFtZT1YIC0tZ3B1PUdQVSAtLWluc3RhbmNlLXR5cGU9VFlQRSAt" + - "LWltYWdlPUlNR2AgfCBTdWJtaXQgYSBjb250YWluZXIgdGFzayB8IFNhdmVzIHRhc2sgSUQgdG8g" + - "Q0xJIHN0YXRlOyB1c2UgYC0taW5wdXQtZmlsZWAgZm9yIHJlcGVhdGFibGUgY29uZmlncyB8Cnwg" + - "YHRhc2sgY3JlYXRlIC0tbmFtZT1YIC0tZ3B1PUdQVSAtLWluc3RhbmNlLXR5cGU9VFlQRSAtLWhl" + - "bG0tY2hhcnQ9Q0hBUlRgIHwgU3VibWl0IGEgSGVsbSB0YXNrIHwgYC0taGVsbS1jaGFydGAgcmVw" + - "bGFjZXMgYC0taW1hZ2VgIHwKfCBgdGFzayBjcmVhdGUgLS1pbnB1dC1maWxlPUZJTEVgIHwgU3Vi" + - "bWl0IGEgdGFzayBmcm9tIGEgSlNPTiBjb25maWcgZmlsZSB8IFJlY29tbWVuZGVkIGZvciByZXBl" + - "YXRhYmxlIGNvbmZpZ3VyYXRpb25zIHwKfCBgdGFzayBsaXN0IFstLXN0YXR1cz1TVEFUVVNdIFst" + - "LWxpbWl0PU5dYCB8IExpc3QgdGFza3MsIG9wdGlvbmFsbHkgZmlsdGVyZWQgYnkgc3RhdHVzIHwg" + - "U3RhdHVzZXM6IGBRVUVVRURgLCBgTEFVTkNIRURgLCBgUlVOTklOR2AsIGBDT01QTEVURURgLCBg" + - "RVJST1JFRGAsIGBDQU5DRUxFRGAsIGBFWENFRURFRF9NQVhfUlVOVElNRV9EVVJBVElPTmAsIGBF" + - "WENFRURFRF9NQVhfUVVFVUVEX0RVUkFUSU9OYCB8CnwgYHRhc2sgZ2V0IFt0YXNrSWRdYCB8IEdl" + - "dCB0YXNrIGRldGFpbHMgfCBVc2VzIHNhdmVkIHRhc2sgSUQgZnJvbSBzdGF0ZSBpZiBvbWl0dGVk" + - "IHwKfCBgdGFzayBldmVudHMgW3Rhc2tJZF0gWy0tbGltaXQ9Tl1gIHwgTGlzdCBsaWZlY3ljbGUg" + - "ZXZlbnRzIGZvciBhIHRhc2sgfCB8CnwgYHRhc2sgcmVzdWx0cyBbdGFza0lkXWAgfCBMaXN0IHJl" + - "c3VsdCBhcnRpZmFjdHMgZm9yIGEgY29tcGxldGVkIHRhc2sgfCBSZXR1cm5zIGVtcHR5IGxpc3Qg" + - "d2hlbiBgcmVzdWx0SGFuZGxpbmdTdHJhdGVneWAgaXMgYE5PTkVgOyByZXN1bHQgdXBsb2FkIG5v" + - "dCB5ZXQgc3VwcG9ydGVkIHwKfCBgdGFzayBjYW5jZWwgW3Rhc2tJZF1gIHwgQ2FuY2VsIGEgcnVu" + - "bmluZyB0YXNrIHwgTm8tb3AgaWYgYWxyZWFkeSBpbiB0ZXJtaW5hbCBzdGF0ZSB8CnwgYHRhc2sg" + - "ZGVsZXRlIFt0YXNrSWRdYCB8IERlbGV0ZSBhIHRhc2sgcmVjb3JkIHwgKipTdG9wLCBzdGF0ZSB0" + - "YXNrIElEICsgY3VycmVudCBzdGF0dXMsIGFuZCB3YWl0IGZvciBhIHN1YnNlcXVlbnQgdXNlciBy" + - "ZXBseSBleHBsaWNpdGx5IGNvbmZpcm1pbmcgZGVsZXRpb24gb2YgdGhhdCBzcGVjaWZpYyB0YXNr" + - "LiBEbyBub3QgdHJlYXQgdGhlIG9yaWdpbmFsIGRlbGV0ZSByZXF1ZXN0IGFzIGNvbmZpcm1hdGlv" + - "bi4qKiB8CnwgYHRhc2sgdXBkYXRlLXNlY3JldHMgW3Rhc2tJZF0gLS1zZWNyZXRzIE5BTUU9dmFs" + - "dWVgIHwgVXBkYXRlIHNlY3JldHMgb24gYSB0YXNrOyBzdXBwbGllZCBzZWNyZXRzIGFyZSBhZGRl" + - "ZCBvciB1cGRhdGVkIGJ5IG5hbWUsIGV4aXN0aW5nIHNlY3JldHMgbm90IGluIHRoZSByZXF1ZXN0" + - "IGFyZSBwcmVzZXJ2ZWQgfCBWYWx1ZXMgYXJlIGVuY3J5cHRlZCBhdCByZXN0IHwKfCBgdGFzayBi" + - "dWxrIC0tdGFzay1pZHM9SUQxWyxJRDIs4oCmXWAgfCBGZXRjaCBkZXRhaWxzIGZvciBtdWx0aXBs" + - "ZSB0YXNrcyBpbiBvbmUgcmVxdWVzdCB8IHwKCiMjIEF1dGgKCnwgQ29tbWFuZCB8IFB1cnBvc2Ug" + - "fCBOb3RlcyB8CnwtLS18LS0tfC0tLXwKfCBgaW5pdGAgfCBNaW50IGFkbWluIHRva2VuIGZyb20g" + - "QVBJIEtleXMgdmlhIHB1YmxpYyBhcGkgZ2F0ZXdheSB8IElkZW1wb3RlbnQ7IHdyaXRlcyBgfi8u" + - "bnZjZi1jbGkuc3RhdGVgOyBjbGVhcnMgc2F2ZWQgZnVuY3Rpb24gc3RhdGUgYW5kIGFsbCBBUEkg" + - "a2V5cyAoZnVuY3Rpb24gYW5kIHRhc2spIHwKfCBgc3RhdHVzYCB8IFNob3cgQ0xJIHN0YXRlICh0" + - "b2tlbiwgbGFzdCBlbmRwb2ludHMsIGZ1bmN0aW9uIGNvbnRleHQpIHwgRGlzdGluY3QgZnJvbSBg" + - "c2VsZi1ob3N0ZWQgc3RhdHVzYCB8CnwgYGFwaS1rZXkgZ2VuZXJhdGUgWy0tZm9yIGZ1bmN0aW9u" + - "XHx0YXNrXSBbLS1kZXNjcmlwdGlvbj3igKZdIFstLWV4cGlyZXMtaW494oCmXWAgfCBNaW50IEFQ" + - "SSBrZXlzIHwgRGVmYXVsdCAobm8gYC0tZm9yYCk6IGdlbmVyYXRlcyBib3RoIGEgZnVuY3Rpb24g" + - "a2V5IGFuZCBhIHRhc2sga2V5OyBgLS1mb3IgZnVuY3Rpb25gIG9yIGAtLWZvciB0YXNrYCBnZW5l" + - "cmF0ZXMgb25lIG9ubHk7IGAtLXNjb3Blc2AgcmVxdWlyZXMgYC0tZm9yYCB8CnwgYGFwaS1rZXkg" + - "Z2VuZXJhdGUgLS12YWxpZGF0ZWAgfCBNaW50IGFuZCBpbW1lZGlhdGVseSB2YWxpZGF0ZSBlYWNo" + - "IGdlbmVyYXRlZCBrZXkgfCBWYWxpZGF0ZXMgZWFjaCBrZXkgYWdhaW5zdCBpdHMgY29ycmVjdCBh" + - "dWRpZW5jZSAoTlZDRiBmb3IgZnVuY3Rpb24ga2V5cywgTlZDVCBmb3IgdGFzayBrZXlzKSB8Cnwg" + - "YGFwaS1rZXkgbGlzdGAgfCBMaXN0IEFQSSBrZXlzIGZvciBjdXJyZW50IG93bmVyIHwgTGlzdHMg" + - "TlZDRi1zY29wZWQga2V5cyBvbmx5IHwKfCBgYXBpLWtleSBkZWxldGUgS0VZLUlEYCAvIGBhcGkt" + - "a2V5IHJldm9rZSBLRVktSURgIHwgUmVtb3ZlIGFuIEFQSSBrZXkgfCAqKkNvbmZpcm0gd2l0aCB1" + - "c2VyKiogfAp8IGBhcGkta2V5IHNob3dgIHwgU2hvdyBjdXJyZW50bHkgc2F2ZWQgQVBJIGtleSBm" + - "cm9tIHN0YXRlIHwgfAoKIyMgQWdlbnQgc2tpbGwKCnwgQ29tbWFuZCB8IFB1cnBvc2UgfCBOb3Rl" + - "cyB8CnwtLS18LS0tfC0tLXwKfCBgYWdlbnQtc2tpbGwgaW5zdGFsbCBbLS10YXJnZXQ9RElSXWAg" + - "fCBJbnN0YWxsIGFsbCBidW5kbGVkIHB1YmxpYyB1c2VyIHNraWxscyBpbnRvIGB+Ly5jbGF1ZGUv" + - "c2tpbGxzL2AgYW5kIGB+Ly5hZ2VudHMvc2tpbGxzL2AgfCBEZWZhdWx0OiBib3RoIGJhc2Ugc2tp" + - "bGxzIGRpcmVjdG9yaWVzIHwKfCBgYWdlbnQtc2tpbGwgdW5pbnN0YWxsIFstLXRhcmdldD1ESVJd" + - "YCB8IFJlbW92ZSBvbmx5IGJ1bmRsZWQgcHVibGljIHVzZXIgc2tpbGxzIGZyb20gdGhlIHRhcmdl" + - "dCBiYXNlIHNraWxscyBkaXJlY3RvcmllcyB8IElkZW1wb3RlbnQ7IHVucmVsYXRlZCBza2lsbHMg" + - "cmVtYWluIHwKfCBgYWdlbnQtc2tpbGwgc2hvdyBbLS1maWxlPVJFTF1gIHwgUHJpbnQgYnVuZGxl" + - "ZCBgbnZjZi1zZWxmLW1hbmFnZWQtY2xpL1NLSUxMLm1kYCBvciBhbm90aGVyIGVtYmVkZGVkIGZp" + - "bGUgfCBGb3IgZGVidWdnaW5nIHwKfCBgYWdlbnQtc2tpbGwgdmVyc2lvbmAgfCBQcmludCBidWls" + - "ZCBTSEEgYW5kIGVtYmVkZGVkIHB1YmxpYyB1c2VyIHNraWxsIHN1bW1hcnkgfCB8ClBLBwhyDQ9k" + - "ISMAACEjAABQSwMEFAAIAAAAAAAhAAAAAAAAAAAAAAAAADIACQBkYXRhL252Y2Ytc2VsZi1tYW5h" + - "Z2VkLWNsaS9yZWZlcmVuY2UvZXhpdC1jb2Rlcy5tZFVUBQABAKbOEiMgYG52Y2YtY2xpYCBleGl0" + - "IGNvZGVzCgpTdGFibGUgYWNyb3NzIHN1YmNvbW1hbmRzLiBVc2UgdGhlc2UgdG8gZHJpdmUgYWdl" + - "bnQgcmV0cnkgLyBzdXJmYWNpbmcgbG9naWMuCgp8IENvZGUgfCBNZWFuaW5nIHwgRXhhbXBsZSBj" + - "YXVzZXMgfAp8LS0tfC0tLXwtLS18CnwgYDBgIHwgU3VjY2VzcyB8IEFsbCBjaGVja3MgcGFzc2Vk" + - "OyBpbnN0YWxsIGNvbXBsZXRlZDsgZGVwbG95bWVudCBBQ1RJVkUgfAp8IGAxYCB8IEdlbmVyaWMg" + - "ZXJyb3IgfCBIZWxtIHJlbmRlciBmYWlsZWQ7IG5ldHdvcmsgdW5yZWFjaGFibGU7IGZpbGUgbm90" + - "IGZvdW5kOyBZQU1MIHBhcnNlIGVycm9yIHwKfCBgMmAgfCBQcmUtZmxpZ2h0IGNoZWNrIGZhaWxl" + - "ZCB8IEdhdGV3YXkgQVBJIENSRHMgbWlzc2luZzsga3ViZWN0bCBub3Qgb24gUEFUSDsgZGVmYXVs" + - "dCBTdG9yYWdlQ2xhc3MgYWJzZW50IHwKfCBgM2AgfCBBZG1pbiBhdXRoIGZhaWxlZCB8IE5vIHRv" + - "a2VuICsgYC0tbm9uLWludGVyYWN0aXZlYCBzZXQ7IElDTVMgcmVqZWN0ZWQgSldUOyBpbml0IGVu" + - "ZHBvaW50IHVucmVhY2hhYmxlIHwKfCBgNWAgfCBNYW5pZmVzdCBhcHBseSBvciBgLS13YWl0YCB0" + - "aW1lZCBvdXQgfCBIZWxtIGluc3RhbGwgdGltZW91dDsgY2hlY2sgcG9sbGVkIGJ1dCBkaWRuJ3Qg" + - "cGFzcyBiZWZvcmUgZHVyYXRpb24gfAp8IGAxMzBgIHwgQ2FuY2VsbGVkIGJ5IFNJR0lOVC9TSUdU" + - "RVJNIHwgVXNlciBDdHJsLUM7IENJIGJ1ZGdldCBleGNlZWRlZDsgcG9kIGV2aWN0ZWQgfAoKIyMg" + - "SG93IGFuIGFnZW50IHNob3VsZCByZWFjdAoKfCBDb2RlIHwgQWdlbnQgYmVoYXZpb3IgfAp8LS0t" + - "fC0tLXwKfCBgMGAgfCBDb250aW51ZSAvIHJlcG9ydCBzdWNjZXNzLiB8CnwgYDFgIHwgU3VyZmFj" + - "ZSBzdGRlcnIgdG8gdXNlcjsgYXNrIGJlZm9yZSBhbnkgcmV0cnkuIEdlbmVyaWMgZXJyb3JzIHVz" + - "dWFsbHkgbmVlZCBhIGh1bWFuIHRvIHJlYWQgdGhlIG1lc3NhZ2UuIHwKfCBgMmAgfCBTdXJmYWNl" + - "IGZhaWxlZCBjaGVja3MgKyB0aGVpciBgaGludFVSTGAuIERvbid0IHByb3Bvc2UgYHVwYCB1bnRp" + - "bCB0aGUgdXNlciBmaXhlcyBwcmVyZXFzLiB8CnwgYDNgIHwgU3VnZ2VzdCBgbnZjZi1jbGkgaW5p" + - "dGAgKGludGVyYWN0aXZlKSBPUiBgLS10b2tlbj0kSldUYCAoQ0kpLiBEb24ndCBhdXRvLW1pbnQg" + - "d2l0aG91dCB1c2VyIE9LLiB8CnwgYDVgIHwgQXNrIHVzZXIgaWYgdGhleSB3YW50IHRvIHdhaXQg" + - "bG9uZ2VyLCBkaWcgaW50byB0aGUgc3RhbGxlZCBjb21wb25lbnQsIG9yIGNhbmNlbC4gfAp8IGAx" + - "MzBgIHwgRG9uJ3QgcmV0cnkgYXV0b21hdGljYWxseTsgdXNlciBleHBsaWNpdGx5IGNhbmNlbGxl" + - "ZC4gQ29uZmlybSBiZWZvcmUgcmUtcnVubmluZy4gfAoKIyMgV2hlcmUgdG8gZmluZCBtb3JlIGRl" + - "dGFpbAoKRXZlcnkgbm9uLXplcm8gZXhpdCBlbWl0cyBhIHN0cnVjdHVyZWQgYHBoYXNlX2ZhaWxl" + - "ZGAgSlNPTiBldmVudCB3aXRoIGBlcnJDYXRlZ29yeWAsIGBlcnJNZXNzYWdlYCwgYHJlbWVkaWF0" + - "aW9uYCAoYXJyYXkpLCBgcmV0cnlDbGFzc2AgKGVudW06IGBub25lfGltbWVkaWF0ZXxiYWNrb2Zm" + - "fGFmdGVyX3JlbWVkaWF0aW9ufHVua25vd25gKSwgYHJldHJ5QWZ0ZXJTZWNgIChpbnQsIG9wdGlv" + - "bmFsKSwgYW5kIGByYXdgIChzdWJwcm9jZXNzICsgSFRUUCArIEt1YmVybmV0ZXMgc2lnbmFsKS4g" + - "QWx3YXlzIGNvbnN1bWUgdGhlc2UgaW4gYC0tanNvbmAgbW9kZSByYXRoZXIgdGhhbiBwYXJzaW5n" + - "IEVuZ2xpc2ggZnJvbSBzdGRlcnIuClBLBwhzp1pk1QYAANUGAABQSwMEFAAIAAAAAAAhAAAAAAAA" + - "AAAAAAAAAC0ACQBkYXRhL252Y2Ytc2VsZi1tYW5hZ2VkLWNsaS9yZWZlcmVuY2UvZmxhZ3MubWRV" + - "VAUAAQCmzhIjIGBudmNmLWNsaWAgZmxhZyByZWZlcmVuY2UKCiMjIEdsb2JhbCBmbGFncyAoZXZl" + - "cnkgc3ViY29tbWFuZCkKCnwgRmxhZyB8IFB1cnBvc2UgfCBEZWZhdWx0IHwKfC0tLXwtLS18LS0t" + - "fAp8IGAtLWNvbmZpZyBGSUxFYCB8IENvbmZpZyBmaWxlIHBhdGggfCBgJEhPTUUvLm52Y2YtY2xp" + - "LnlhbWxgIHwKfCBgLS1kZWJ1Z2AgfCBWZXJib3NlIEhUVFAgbG9nZ2luZyBvbiBzdGRlcnIgfCBg" + - "ZmFsc2VgIHwKfCBgLS1qc29uYCB8IEpTT05MIGV2ZW50cyBvbiBzdGRlcnIgfCBhdXRvIChvZmYg" + - "aW4gVFRZLCBvbiB1bmRlciBgLS1ub24taW50ZXJhY3RpdmVgKSB8CgojIyBgc2VsZi1ob3N0ZWRg" + - "IHBhcmVudCAocGVyc2lzdGVudCBhY3Jvc3Mgc3ViY29tbWFuZHMpCgp8IEZsYWcgfCBQdXJwb3Nl" + - "IHwgRGVmYXVsdCB8CnwtLS18LS0tfC0tLXwKfCBgLS1jb250cm9sLXBsYW5lLXN0YWNrPeKApmAg" + - "fCBDb250cm9sLXBsYW5lIGJ1bmRsZSBzb3VyY2U6IGxvY2FsIHBhdGgsIGdpdCBVUkwsIG9yIGBv" + - "Y2k6Ly9gIFVSTCB8IGVtYmVkZGVkIE9DSSBVUkwgcGlubmVkIGJ5IENMSSB2ZXJzaW9uIHwKfCBg" + - "LS1jb21wdXRlLXBsYW5lLXN0YWNrPeKApmAgfCBDb21wdXRlLXBsYW5lIGJ1bmRsZSBzb3VyY2U6" + - "IGxvY2FsIHBhdGgsIGdpdCBVUkwsIG9yIGBvY2k6Ly9gIFVSTCB8IGVtYmVkZGVkIE9DSSBVUkwg" + - "cGlubmVkIGJ5IENMSSB2ZXJzaW9uIHwKfCBgLS1lbnY9bG9jYWxcfHByZFx84oCmYCB8IEhlbG1m" + - "aWxlIGVudmlyb25tZW50IG5hbWUgfCBgbG9jYWxgIGZvciBkZXYgYnVpbGRzLCBgcHJkYCBmb3Ig" + - "cmVsZWFzZXMgfAp8IGAtLW5vbi1pbnRlcmFjdGl2ZWAgfCBEaXNhYmxlIGFsbCBzdGRpbiBwcm9t" + - "cHRzIHwgYGZhbHNlYCB8CnwgYC0tdG9rZW49JEpXVGAgfCBBZG1pbiBKV1QsIG92ZXJyaWRlcyBz" + - "dG9yZWQgc2Vzc2lvbiB8IC0gfAp8IGAtLW5vLWFwcGx5YCB8IGBpbnN0YWxsYCBvbmx5IC0gZW1p" + - "dCBZQU1MLCBkbyBub3Qga3ViZWN0bCBhcHBseSB8IGBmYWxzZWAgfAp8IGAtLW91dHB1dD10ZXh0" + - "XHxqc29uYCB8IExlZ2FjeSBhbGlhcyBmb3IgYC0tanNvbmAgKGRlcHJlY2F0ZWQsIHJlbW92ZWQg" + - "aW4gbmV4dCBtYWpvcikgfCBgdGV4dGAgfAp8IGAtLXBsYWluYCB8IEZvcmNlIHBsYWluIHN0cmVh" + - "bWluZyBvdXRwdXQgfCBhdXRvLWRldGVjdCB8CnwgYC0td2FpdCBEVVJBVElPTmAgfCBgY2hlY2tg" + - "IG9ubHk7IGJsb2NrIHVudGlsIHBhc3MgfCAtIHwKfCBgLS1jb250cm9sLXBsYW5lLWNvbnRleHQg" + - "Q1RYYCB8IGt1YmVjdGwgY29udGV4dCBmb3IgY29udHJvbCBwbGFuZSAoUkVRLTIwKSB8IGN1cnJl" + - "bnQgY29udGV4dCB8CnwgYC0tY29tcHV0ZS1wbGFuZS1jb250ZXh0IENUWGAgfCBrdWJlY3RsIGNv" + - "bnRleHQgZm9yIGNvbXB1dGUgcGxhbmUgKFJFUS0yMCkgfCBjdXJyZW50IGNvbnRleHQgfAp8IGAt" + - "LWljbXMtdXJsIFVSTGAgfCBQdWJsaWMgSUNNUyBVUkw7IHJlcXVpcmVkIHdoZW4gY29udGV4dHMg" + - "ZGlmZmVyIHwgZGVyaXZlZCBmcm9tIGBiYXNlX2h0dHBfdXJsYCB8CnwgYC0tbG9jYWwtb25seWAg" + - "fCBgY2hlY2sgLS1wcmVgIG9ubHk7IHNraXAgYWxsIGt1YmVjdGwgY29udGFjdCB8IGBmYWxzZWAg" + - "fAoKIyMgYHVwYC1zcGVjaWZpYwoKfCBGbGFnIHwgUHVycG9zZSB8IERlZmF1bHQgfAp8LS0tfC0t" + - "LXwtLS18CnwgYC0tY2x1c3Rlci1uYW1lIE5BTUVgIHwgSUNNUyBjbHVzdGVyIHJvdyBpZGVudGlm" + - "aWVyIChyZXF1aXJlZCkgfCAtIHwKfCBgLS1uY2EtaWQgSURgIHwgTkNBIGFjY291bnQgSUQgfCBg" + - "bnZjZi1kZWZhdWx0YCB8CnwgYC0tcmVnaW9uIFJFR0lPTmAgfCBDbHVzdGVyIHJlZ2lvbiB8IGB1" + - "cy13ZXN0LTFgIHwKfCBgLS1wbGFuLW9ubHlgIHwgRHJ5LXJ1bjsgZW1pdCBwaGFzZSBwbGFuICsg" + - "RVRBcyB3aXRob3V0IGNoYW5nZXMgfCBgZmFsc2VgIHwKCiMjIGBzdGF0dXNgLXNwZWNpZmljCgp8" + - "IEZsYWcgfCBQdXJwb3NlIHwgRGVmYXVsdCB8CnwtLS18LS0tfC0tLXwKfCBgLS1jbHVzdGVyLW5h" + - "bWUgTkFNRWAgfCBMaW1pdCB0byBvbmUgY29tcHV0ZSBwbGFuZSB8IC0gKGNvbnRyb2wgKyBhbGwg" + - "Y2x1c3RlcnMpIHwKfCBgLS13YXRjaGAgfCBMaXZlIHJlLXJlbmRlciB8IGBmYWxzZWAgfAp8IGAt" + - "LXdhdGNoLWludGVydmFsIERVUmAgfCBgLS13YXRjaGAgY2FkZW5jZSB8IGA1c2AgfAp8IGAtLWNv" + - "bXBvbmVudCBOQU1FYCB8IEZpbHRlciBjb21wb25lbnRzIHBhbmVsIHwgYWxsIHwKfCBgLS1uby1l" + - "dmVudHNgIHwgU2tpcCBldmVudHMgcGFuZWwgfCBgZmFsc2VgIHwKCiMjIGBjbHVzdGVyIHJlZ2lz" + - "dGVyYC1zcGVjaWZpYwoKfCBGbGFnIHwgUHVycG9zZSB8IERlZmF1bHQgfAp8LS0tfC0tLXwtLS18" + - "CnwgYC0tbmFtZSBOQU1FYCB8IENsdXN0ZXIgbmFtZSAocmVxdWlyZWQpIHwgLSB8CnwgYC0tbmNh" + - "LWlkIElEYCB8IE5DQSBJRCAocmVxdWlyZWQpIHwgLSB8CnwgYC0tcmVnaW9uIFJFR0lPTmAgfCBS" + - "ZWdpb24gfCBgdXMtd2VzdC0xYCB8CnwgYC0taWNtcy11cmwgVVJMYCB8IElDTVMgZW5kcG9pbnQg" + - "fCBmcm9tIGNvbmZpZyB8CnwgYC0taWdub3JlLWV4aXN0aW5nYCB8IE1hdGNoLW9yLWNyZWF0ZSBp" + - "bnN0ZWFkIG9mIGZhaWwtb24tZXhpc3RzIHwgYGZhbHNlYCB8CgojIyBgYXBpLWtleSBnZW5lcmF0" + - "ZWAtc3BlY2lmaWMKCnwgRmxhZyB8IFB1cnBvc2UgfCBEZWZhdWx0IHwKfC0tLXwtLS18LS0tfAp8" + - "IGAtLWZvciBmdW5jdGlvblx8dGFza2AgfCBHZW5lcmF0ZSBvbmx5IHRoZSBzcGVjaWZpZWQga2V5" + - "IHR5cGUgfCAob21pdCB0byBnZW5lcmF0ZSBib3RoKSB8CnwgYC0tZGVzY3JpcHRpb24gVEVYVGAg" + - "fCBIdW1hbi1yZWFkYWJsZSBsYWJlbCBmb3IgdGhlIGtleSB8IGBHZW5lcmF0ZWQgYnkgbnZjZi1j" + - "bGlgIHwKfCBgLS1leHBpcmVzLWluIERVUkFUSU9OYCB8IEV4cGlyeSBvZmZzZXQgKGUuZy4gYDI0" + - "aGAsIGA3ZGApOyBwYXJzZWQgYXMgZXh0ZW5kZWQgZHVyYXRpb24gfCBgMjRoYCB8CnwgYC0tc2Nv" + - "cGVzIFNDT1BFWyxTQ09QRV1gIHwgT3ZlcnJpZGUgZGVmYXVsdCBzY29wZXM7IHJlcXVpcmVzIGAt" + - "LWZvcmAgfCAoc2VydmljZSBkZWZhdWx0cykgfAp8IGAtLXZhbGlkYXRlYCB8IFZhbGlkYXRlIGVh" + - "Y2ggZ2VuZXJhdGVkIGtleSBpbW1lZGlhdGVseSBhZnRlciBtaW50aW5nIHwgYGZhbHNlYCB8CgpF" + - "eHRlbmRlZCBkdXJhdGlvbiB1bml0czogYHNgIChzZWNvbmRzKSwgYG1gIChtaW51dGVzKSwgYGhg" + - "IChob3VycyksIGBkYCAoZGF5cyksIGB3YCAod2Vla3MpLgoKIyMgYGZ1bmN0aW9uIGNyZWF0ZWAt" + - "c3BlY2lmaWMKCmAtLWlucHV0LWZpbGUgRklMRWAgaXMgcmVjb21tZW5kZWQgZm9yIHJlcGVhdGFi" + - "bGUgZnVuY3Rpb24gZGVmaW5pdGlvbnMuIEZvciBhZC1ob2MgY3JlYXRlczoKCnwgRmxhZyB8IFB1" + - "cnBvc2UgfCBEZWZhdWx0IHwKfC0tLXwtLS18LS0tfAp8IGAtLW5hbWUgTkFNRWAgfCBGdW5jdGlv" + - "biBuYW1lIHwgLSB8CnwgYC0taW1hZ2UgSU1BR0VgIHwgQ29udGFpbmVyIGltYWdlIHwgLSB8Cnwg" + - "YC0taW5mZXJlbmNlLXVybCBVUklgIHwgQ29udGFpbmVyIGluZmVyZW5jZSBlbmRwb2ludCB8IC0g" + - "fAp8IGAtLWluZmVyZW5jZS1wb3J0IFBPUlRgIHwgQ29udGFpbmVyIGluZmVyZW5jZSBwb3J0IHwg" + - "LSB8CnwgYC0tZnVuY3Rpb24tdHlwZSBERUZBVUxUXHxTVFJFQU1JTkdcfExMTWAgfCBGdW5jdGlv" + - "biB0eXBlIHwgYERFRkFVTFRgIHwKfCBgLS1oZWxtLWNoYXJ0IENIQVJUYCB8IEhlbG0gY2hhcnQg" + - "VVJMIG9yIE9DSSByZWZlcmVuY2UuIENhbiBiZSB1c2VkIHdpdGggYC0tZnVuY3Rpb24tdHlwZT1M" + - "TE1gIGZvciBjaGFydC1wYWNrYWdlZCBMTE0gd29ya2xvYWRzLiB8IC0gfAp8IGAtLWhlbG0tY2hh" + - "cnQtc2VydmljZSBOQU1FYCB8IEt1YmVybmV0ZXMgU2VydmljZSBuYW1lIGV4cG9zZWQgYnkgdGhl" + - "IGNoYXJ0LiBSZXF1aXJlZCB3aGVuIGAtLWhlbG0tY2hhcnRgIGlzIHNldC4gfCAtIHwKfCBgLS1t" + - "b2RlbHMgTkFNRTpWRVJTSU9OOlVSSWAgfCBTdGFuZGFyZCBtb2RlbCBhcnRpZmFjdDsgcmVwZWF0" + - "YWJsZSB8IC0gfAp8IGAtLWxsbS1tb2RlbCBTUEVDYCB8IExMTSBtb2RlbCBjb25maWc7IGZvcm1h" + - "dCBgbmFtZT08bW9kZWw+LHVyaXM9PHVyaT5cfDx1cmk+LHJvdXRpbmdNZXRob2Q9PG1ldGhvZD4s" + - "dG9rZW5SYXRlTGltaXQ9PGxpbWl0PmA7IHJlcGVhdGFibGUuIFRva2VuIGxpbWl0cyB1c2UgYDx2" + - "YWx1ZT4tPHVuaXQ+YCB3aXRoIGBTYCwgYE1gLCBgSGAsIGBEYCwgb3IgYFdgLCBmb3IgZXhhbXBs" + - "ZSBgMTAwMC1TYC4gVXNlIGlucHV0IEpTT04gZm9yIGNvbWJpbmVkIHRva2VuIGxpbWl0cyBiZWNh" + - "dXNlIGlubGluZSBzcGVjcyB1c2UgY29tbWFzIGFzIGZpZWxkIHNlcGFyYXRvcnMuIHwgLSB8CgpJ" + - "biBKU09OIGFuZCBpbmxpbmUgc3BlY3MsIExMTSBmdW5jdGlvbnMgc2V0IGBmdW5jdGlvblR5cGU6" + - "ICJMTE0iYCBhbmQgbW9kZWwgcm91dGluZyBtZXRhZGF0YSB1bmRlciBgbW9kZWxzW10ubGxtQ29u" + - "ZmlnYC4gYGxsbUNvbmZpZy51cmlzYCBkZWNsYXJlcyB0aGUgT3BlbkFJLWNvbXBhdGlibGUgdXBz" + - "dHJlYW0gcGF0aHMgZXhwb3NlZCBieSB0aGUgbW9kZWwuIEN1cnJlbnQgc3VwcG9ydGVkIHBhdGhz" + - "IGFyZSBgL3YxL2NoYXQvY29tcGxldGlvbnNgLCBgL3YxL3Jlc3BvbnNlc2AsIGFuZCBgL3YxL2Vt" + - "YmVkZGluZ3NgLiBgbGxtQ29uZmlnLnJvdXRpbmdNZXRob2RgIGFjY2VwdHMgYHJvdW5kX3JvYmlu" + - "YCwgYHBvd2VyX29mX3R3b2AsIGBncm9xX211bHRpcmVnaW9uYCwgYHB1bHNhcmAsIG9yIGByYW5k" + - "b21gLgpgbGxtQ29uZmlnLnRva2VuUmF0ZUxpbWl0YCBhY2NlcHRzIG9uZSBvciBtb3JlIGNvbW1h" + - "LXNlcGFyYXRlZCBwb3NpdGl2ZSBpbnRlZ2VyIHRva2VuIGxpbWl0cyBpbiBgPHZhbHVlPi08dW5p" + - "dD5gIGZvcm1hdC4gU3VwcG9ydGVkIHVuaXRzIGFyZSBgU2AgKHNlY29uZHMpLCBgTWAgKG1pbnV0" + - "ZXMpLCBgSGAgKGhvdXJzKSwgYERgIChkYXlzKSwgYW5kIGBXYCAod2Vla3MpLiBVc2UgZGlzdGlu" + - "Y3QgdW5pdHMgd2hlbiBjb21iaW5pbmcgbGltaXRzLCBmb3IgZXhhbXBsZSBgMTAwMC1TLDUwMDAt" + - "TSwxMDAwMDAtSCw1MDAwMDAtRCwxMDAwMDAwLVdgIGluIGlucHV0IEpTT04uCgpIZWxtIGNoYXJ0" + - "IHBhY2thZ2luZyBpcyBpbmRlcGVuZGVudCBvZiBgZnVuY3Rpb25UeXBlYC4gRm9yIGEgSGVsbS1j" + - "aGFydCBiYWNrZWQgTExNIGZ1bmN0aW9uLCBzZXQgYGZ1bmN0aW9uVHlwZTogIkxMTSJgLCBgaGVs" + - "bUNoYXJ0YCwgYGhlbG1DaGFydFNlcnZpY2VOYW1lYCwgYW5kIGBtb2RlbHNbXS5sbG1Db25maWdg" + - "IGluIHRoZSBzYW1lIGNyZWF0ZSByZXF1ZXN0LiBgaW5mZXJlbmNlUG9ydGAgbXVzdCBiZSB0aGUg" + - "S3ViZXJuZXRlcyBTZXJ2aWNlIHBvcnQgZXhwb3NlZCBieSBgaGVsbUNoYXJ0U2VydmljZU5hbWVg" + - "LgoKTExNIGludm9jYXRpb24gcmVxdWVzdHMgdXNlIGBtb2RlbDogIjxmdW5jdGlvbi1pZD4vPG1v" + - "ZGVsLW5hbWU+ImAuIFRoZSBmdW5jdGlvbiBJRCBzZWxlY3RzIHRoZSBOVkNGIGZ1bmN0aW9uLCBh" + - "bmQgdGhlIG1vZGVsIG5hbWUgaXMgZm9yd2FyZGVkIHVwc3RyZWFtLiBDaGF0IGNvbXBsZXRpb25z" + - "IGFuZCBSZXNwb25zZXMgQVBJIHJlcXVlc3RzIGNhbiB1c2UgYHgtbXVsdGktdHVybi1zZXNzaW9u" + - "LWlkYCBmb3Igc2Vzc2lvbiBzdGlja2luZXNzOyBlbWJlZGRpbmdzIHJlcXVlc3RzIGRvIG5vdC4K" + - "CiMjIGBmdW5jdGlvbiB1cGRhdGVgLXNwZWNpZmljCgp8IEZsYWcgfCBQdXJwb3NlIHwgRGVmYXVs" + - "dCB8CnwtLS18LS0tfC0tLXwKfCBgLS10YWdzIFRBR1ssVEFHXWAgfCBSZXBsYWNlIGZ1bmN0aW9u" + - "IHRhZ3MgfCAtIHwKfCBgLS1sbG0tbW9kZWwtdXBkYXRlIFNQRUNgIHwgTExNIG1vZGVsIHVwZGF0" + - "ZTsgZm9ybWF0IGBuYW1lPTxtb2RlbD4scm91dGluZ01ldGhvZD08bWV0aG9kPix0b2tlblJhdGVM" + - "aW1pdD08bGltaXQ+YDsgcmVwZWF0YWJsZS4gUm91dGluZyBtZXRob2RzIG1hdGNoIGAtLWxsbS1t" + - "b2RlbGAuIFRva2VuIGxpbWl0IGV4YW1wbGU6IGAxMDAwLVNgLiBVc2UgaW5wdXQgSlNPTiBmb3Ig" + - "Y29tYmluZWQgdG9rZW4gbGltaXRzLiB8IC0gfAoKSW4gSlNPTiwgYGZ1bmN0aW9uIHVwZGF0ZWAg" + - "YWNjZXB0cyBgbW9kZWxVcGRhdGVzW11gIGVudHJpZXMgd2l0aCBgbW9kZWxOYW1lYCBhbmQgYGxs" + - "bUNvbmZpZy5yb3V0aW5nTWV0aG9kYCBhbmQvb3IgYGxsbUNvbmZpZy50b2tlblJhdGVMaW1pdGAu" + - "IGB1cmlzYCBhcmUgY3JlYXRlLXRpbWUgbW9kZWwgbWV0YWRhdGEgYW5kIGFyZSBub3QgcGFydCBv" + - "ZiBtb2RlbCB1cGRhdGVzLgoKIyMgYGZ1bmN0aW9uIGRlcGxveSBjcmVhdGVgLXNwZWNpZmljCgpg" + - "LS1pbnB1dC1maWxlIEZJTEVgIGlzIHJlY29tbWVuZGVkIChmdWxsIEpTT04gc3BlYykuIEZvciBh" + - "ZC1ob2Mgb25lLXNob3QgdXNlOgoKfCBGbGFnIHwgUHVycG9zZSB8IERlZmF1bHQgfAp8LS0tfC0t" + - "LXwtLS18CnwgYC0tZnVuY3Rpb24taWQgSURgIHwgRnVuY3Rpb24gSUQgKHJlcXVpcmVkKSB8IC0g" + - "fAp8IGAtLWdwdSBOQU1FYCB8IEdQVSBmYW1pbHkgfCBgSDEwMGAgfAp8IGAtLWluc3RhbmNlLXR5" + - "cGUgVFlQRWAgfCBTS1UgfCBgTkNQLkdQVS5IMTAwXzF4YCB8CnwgYC0tbWluLWluc3RhbmNlcyBO" + - "YCB8IE1pbiByZXBsaWNhcyB8IGAxYCB8CnwgYC0tbWF4LWluc3RhbmNlcyBOYCB8IE1heCByZXBs" + - "aWNhcyB8IGAxYCB8CnwgYC0tbWF4LXJlcXVlc3QtY29uY3VycmVuY3kgTmAgfCBDb25jdXJyZW5j" + - "eSB8IGAwYCAodW5zZXQ7IHNlcnZlciBkZWZhdWx0IGFwcGxpZXMpIHwKfCBgLS1jbHVzdGVycyBO" + - "QU1FWyxOQU1FXWAgfCBUYXJnZXQgc3BlY2lmaWMgY29tcHV0ZSBjbHVzdGVycyB8IChhbnkgbWF0" + - "Y2hpbmcgU0tVKSB8CgojIyBgdGFzayBjcmVhdGVgLXNwZWNpZmljCgpgLS1pbnB1dC1maWxlIEZJ" + - "TEVgIGlzIHJlY29tbWVuZGVkIGZvciByZXBlYXRhYmxlIHRhc2sgZGVmaW5pdGlvbnMuIEZvciBh" + - "ZC1ob2MgdXNlOgoKfCBGbGFnIHwgUHVycG9zZSB8IE5vdGVzIHwKfC0tLXwtLS18LS0tfAp8IGAt" + - "LW5hbWUgTkFNRWAgfCBUYXNrIG5hbWUgKHJlcXVpcmVkKSB8IDEtMTI4IGNoYXJzLCBgXlthLXow" + - "LTlBLVpdW2EtejAtOUEtWlwtX10qJGAgfAp8IGAtLWdwdSBHUFVgIHwgR1BVIG5hbWUgKHJlcXVp" + - "cmVkIHdpdGhvdXQgYC0taW5wdXQtZmlsZWApIHwgRXhhbXBsZTogYEgxMDBgIHwKfCBgLS1pbnN0" + - "YW5jZS10eXBlIFRZUEVgIHwgSW5zdGFuY2UgdHlwZSAocmVxdWlyZWQgd2l0aG91dCBgLS1pbnB1" + - "dC1maWxlYCkgfCBFeGFtcGxlOiBgTkNQLkdQVS5IMTAwXzF4YCB8CnwgYC0taW1hZ2UgSU1BR0Vg" + - "IHwgQ29udGFpbmVyIGltYWdlIHwgTXV0dWFsbHkgZXhjbHVzaXZlIHdpdGggYC0taGVsbS1jaGFy" + - "dGAgfAp8IGAtLWhlbG0tY2hhcnQgQ0hBUlRgIHwgSGVsbSBjaGFydCBVUkwgb3IgT0NJIHJlZmVy" + - "ZW5jZSB8IE11dHVhbGx5IGV4Y2x1c2l2ZSB3aXRoIGAtLWltYWdlYCB8CnwgYC0taW5wdXQtZmls" + - "ZSBGSUxFYCB8IEpTT04gdGFzayBzcGVjIGZpbGUgfCBDTEkgZmxhZ3Mgb3ZlcnJpZGUgSlNPTiB2" + - "YWx1ZXMgd2hlbiBib3RoIGFyZSBzZXQgfAp8IGAtLWJhY2tlbmQgQkFDS0VORGAgfCBCYWNrZW5k" + - "IC8gQ1NQIHwgLSB8CnwgYC0tY2x1c3RlcnMgTkFNRVssTkFNRV1gIHwgU3BlY2lmaWMgY2x1c3Rl" + - "cnMgd2l0aGluIHRoZSBpbnN0YW5jZSB8IENvbW1hLXNlcGFyYXRlZCB8CnwgYC0tY29udGFpbmVy" + - "LWFyZ3MgQVJHU2AgfCBBcmdzIHBhc3NlZCB3aGVuIGxhdW5jaGluZyB0aGUgY29udGFpbmVyIHwg" + - "U2luZ2xlIHN0cmluZywgZS5nLiBgIi0tZXBvY2hzIDEwIC0tYmF0Y2gtc2l6ZSAzMiJgIHwKfCBg" + - "LS1jb250YWluZXItZW52IE5BTUU9dmFsdWVgIHwgQ29udGFpbmVyIGVudmlyb25tZW50IHZhcmlh" + - "YmxlOyByZXBlYXRhYmxlIHwgLSB8CnwgYC0tc2VjcmV0cyBOQU1FPXZhbHVlYCB8IFNlY3JldCBl" + - "bnZpcm9ubWVudCB2YXJpYWJsZTsgcmVwZWF0YWJsZTsgZW5jcnlwdGVkIGF0IHJlc3QgfCAtIHwK" + - "fCBgLS1tYXgtcnVudGltZSBEVVJBVElPTmAgfCBNYXggd2FsbC1jbG9jayBydW4gdGltZSAoSVNP" + - "IDg2MDEsIGUuZy4gYFBUNEhgKSB8IE5vIGRlZmF1bHQ7IG9taXQgZm9yIG5vIHRpbWUgbGltaXQg" + - "fAp8IGAtLW1heC1xdWV1ZWQgRFVSQVRJT05gIHwgTWF4IHRpbWUgaW4gcXVldWUgYmVmb3JlIGNh" + - "bmNlbGxhdGlvbiAoSVNPIDg2MDEpIHwgU2VydmVyIGRlZmF1bHQgYFBUNzJIYCB8CnwgYC0tdGVy" + - "bWluYXRpb24tZ3JhY2UgRFVSQVRJT05gIHwgR3JhY2UgcGVyaW9kIGFmdGVyIHN0b3Agc2lnbmFs" + - "IChJU08gODYwMSkgfCBTZXJ2ZXIgZGVmYXVsdCBgUFQxSGAgfAp8IGAtLXJlc3VsdC1zdHJhdGVn" + - "eSBVUExPQURcfE5PTkVgIHwgSG93IHRvIGhhbmRsZSB0YXNrIG91dHB1dCBhcnRpZmFjdHMgfCAt" + - "IHwKfCBgLS1yZXN1bHRzLWxvY2F0aW9uIExPQ0FUSU9OYCB8IFJlc3VsdCB1cGxvYWQgdGFyZ2V0" + - "LCBmb3JtYXQgYG9yZy1uYW1lL1t0ZWFtLW5hbWUvXW1vZGVsLW5hbWVgOyByZXF1aXJlZCB3aGVu" + - "IGAtLXJlc3VsdC1zdHJhdGVneT1VUExPQURgIHwgLSB8CnwgYC0tbW9kZWxzIE5BTUU6VkVSU0lP" + - "TjpVUklgIHwgTW9kZWwgYXJ0aWZhY3Q7IHJlcGVhdGFibGUgfCAtIHwKfCBgLS1yZXNvdXJjZXMg" + - "TkFNRTpWRVJTSU9OOlVSSWAgfCBSZXNvdXJjZSBhcnRpZmFjdDsgcmVwZWF0YWJsZSB8IC0gfAp8" + - "IGAtLXRhZ3MgVEFHWyxUQUddYCB8IFRhc2sgdGFncyB8IENvbW1hLXNlcGFyYXRlZCB8CnwgYC0t" + - "ZGVzY3JpcHRpb24gVEVYVGAgfCBUYXNrIGRlc2NyaXB0aW9uIHwgLSB8CnwgYC0tbG9ncy10ZWxl" + - "bWV0cnktaWQgVVVJRGAgfCBMb2dzIHRlbGVtZXRyeSBlbmRwb2ludCBJRCB8IC0gfAp8IGAtLW1l" + - "dHJpY3MtdGVsZW1ldHJ5LWlkIFVVSURgIHwgTWV0cmljcyB0ZWxlbWV0cnkgZW5kcG9pbnQgSUQg" + - "fCAtIHwKfCBgLS10cmFjZXMtdGVsZW1ldHJ5LWlkIFVVSURgIHwgVHJhY2VzIHRlbGVtZXRyeSBl" + - "bmRwb2ludCBJRCB8IC0gfAoKUEsHCPyjkeDGIgAAxiIAAFBLAwQUAAgAAAAAACEAAAAAAAAAAAAA" + - "AAAANwAJAGRhdGEvbnZjZi1zZWxmLW1hbmFnZWQtY2xpL3JlZmVyZW5jZS90cm91Ymxlc2hvb3Rp" + - "bmcubWRVVAUAAQCmzhIjIFRyb3VibGVzaG9vdGluZwoKS25vd24gZXJyb3JzIOKGkiBkaWFnbm9z" + - "dGljIGNvbW1hbmQg4oaSIHJlbWVkaWF0aW9uLiBLZWVwIGluIHN5bmMgd2l0aCB0aGUgc3RydWN0" + - "dXJlZCBgcGhhc2VfZmFpbGVkYCBldmVudHMgdGhlIENMSSBlbWl0cyAoUkVRLTE1KSDigJQgZXZl" + - "cnkgZW50cnkgYmVsb3cgc2hvdWxkIG1hcCB0byBhbiBgZXJyQ2F0ZWdvcnlgIGFuZCBhIGByZW1l" + - "ZGlhdGlvbmAgYXJyYXkuCgojIyBQcmUtZmxpZ2h0Cgp8IFN5bXB0b20gfCBDYXVzZSB8IFJlbWVk" + - "aWF0aW9uIHwKfC0tLXwtLS18LS0tfAp8IGBrdWJlY3RsIG5vdCBvbiBQQVRIYCB8IE9wZXJhdG9y" + - "J3MgYCRQQVRIYCBkb2Vzbid0IGluY2x1ZGUga3ViZWN0bCB8IEluc3RhbGwga3ViZWN0bCAxLjI4" + - "KzogaHR0cHM6Ly9rdWJlcm5ldGVzLmlvL2RvY3MvdGFza3MvdG9vbHMvaW5zdGFsbC1rdWJlY3Rs" + - "LyB8CnwgYGhlbG1maWxlIG5vdCBvbiBQQVRIYCB8IFNhbWUgfCBodHRwczovL2dpdGh1Yi5jb20v" + - "aGVsbWZpbGUvaGVsbWZpbGUjaW5zdGFsbGF0aW9uIHwKfCBgaGVsbSBub3Qgb24gUEFUSGAgfCBT" + - "YW1lIHwgaHR0cHM6Ly9oZWxtLnNoL2RvY3MvaW50cm8vaW5zdGFsbC8gfAp8IGBHYXRld2F5IEFQ" + - "SSBDUkRzIG5vdCBpbnN0YWxsZWRgIHwgZW52b3ktZ2F0ZXdheSBwcmVyZXEgbWlzc2luZyB8IGBo" + - "ZWxtIGluc3RhbGwgZWcgb2NpOi8vZG9ja2VyLmlvL2Vudm95cHJveHkvZ2F0ZXdheS1oZWxtIC0t" + - "bmFtZXNwYWNlPWVudm95LWdhdGV3YXktc3lzdGVtIC0tY3JlYXRlLW5hbWVzcGFjZWAgfAp8IGBk" + - "ZWZhdWx0IFN0b3JhZ2VDbGFzcyBub3QgYXZhaWxhYmxlYCB8IENsdXN0ZXIgaGFzIG5vIGRlZmF1" + - "bHQgU0MgfCBBbm5vdGF0ZSBvbmU6IGBrdWJlY3RsIHBhdGNoIHNjIDxuYW1lPiAtcCAneyJtZXRh" + - "ZGF0YSI6eyJhbm5vdGF0aW9ucyI6eyJzdG9yYWdlY2xhc3Mua3ViZXJuZXRlcy5pby9pcy1kZWZh" + - "dWx0LWNsYXNzIjoidHJ1ZSJ9fX0nYCB8CnwgYEdQVSBvcGVyYXRvciBub3QgaW5zdGFsbGVkYCAo" + - "Y29tcHV0ZS1wbGFuZSkgfCBudmlkaWEgR1BVIG9wZXJhdG9yIG1pc3NpbmcgfCBJbnN0YWxsIHBl" + - "ciBodHRwczovL2RvY3MubnZpZGlhLmNvbS9kYXRhY2VudGVyL2Nsb3VkLW5hdGl2ZS9ncHUtb3Bl" + - "cmF0b3IvbGF0ZXN0L2luc3RhbGwtZ3B1LW9wZXJhdG9yLmh0bWwsIE9SIHVzZSBgZmFrZS1ncHUt" + - "b3BlcmF0b3JgIGZvciBkZXYgfAp8IGBHUFUgbm9kZSBsYWJlbHMgbWlzc2luZ2AgKGNvbXB1dGUt" + - "cGxhbmUpIHwgTm9kZXMgbmVlZCBgbnZpZGlhLmNvbS9ncHUuZmFtaWx5YCBldGMuIHwgU2V0IGAt" + - "LWszcy1ub2RlLWxhYmVsIG52aWRpYS5jb20vZ3B1LmZhbWlseT1ob3BwZXJAYWdlbnQ6TmAgZm9y" + - "IGszZCB8CgojIyBBdXRoCgp8IFN5bXB0b20gfCBDYXVzZSB8IFJlbWVkaWF0aW9uIHwKfC0tLXwt" + - "LS18LS0tfAp8IGBhZG1pbiB0b2tlbiByZXF1aXJlZGAgKGluaXQgbm90IHJ1bikgfCBObyBgfi8u" + - "bnZjZi1jbGkuc3RhdGVgIGFuZCBgLS10b2tlbmAgbm90IHBhc3NlZCB8IGBudmNmLWNsaSBpbml0" + - "YCAoaW50ZXJhY3RpdmUpIG9yIGAtLXRva2VuPSRKV1QgLS1ub24taW50ZXJhY3RpdmVgIChDSSkg" + - "fAp8IGBTaWduZWQgSldUIHJlamVjdGVkOiBBbm90aGVyIGFsZ29yaXRobSBleHBlY3RlZCwgb3Ig" + - "bm8gbWF0Y2hpbmcga2V5KHMpIGZvdW5kYCB8IFN0YWxlIHNlc3Npb24uanNvbiBmcm9tIGEgZGlm" + - "ZmVyZW50IGNvbnRyb2wgcGxhbmUgfCBgcm0gfi8ubnZjZi1jbGkuc3RhdGVgIHRoZW4gYG52Y2Yt" + - "Y2xpIGluaXRgIGFnYWluIHwKfCBgNDAzIG1pc3NpbmcgcmVxdWVzdGVkIGF1dGhvcml0aWVzYCAo" + - "ZnVuY3Rpb24gaW52b2tlKSB8IEFkbWluIHRva2VuIGRvZXNuJ3QgaGF2ZSBgaW52b2tlX2Z1bmN0" + - "aW9uYCBzY29wZSB8IGBudmNmLWNsaSBhcGkta2V5IGdlbmVyYXRlIC0tZGVzY3JpcHRpb2494oCm" + - "YCB0aGVuIHJlLXJ1biBpbnZva2UgfAoKIyMgSW5zdGFsbCAvIGB1cGAKCnwgU3ltcHRvbSB8IENh" + - "dXNlIHwgUmVtZWRpYXRpb24gfAp8LS0tfC0tLXwtLS18CnwgSGVsbSBgdGltZWQgb3V0IHdhaXRp" + - "bmcgZm9yIGNhc3NhbmRyYWAgfCBDYXNzYW5kcmEgU3RhdGVmdWxTZXQgUFZDIHN0dWNrIGBQZW5k" + - "aW5nYCB8IENvbmZpcm0gZGVmYXVsdCBTdG9yYWdlQ2xhc3M7IGNoZWNrIGBrdWJlY3RsIGdldCBw" + - "dixwdmMgLW4gY2Fzc2FuZHJhLXN5c3RlbWAgfAp8IGBJbnZhbGlkIEdQVSAnTkNQLkdQVS5IMTAw" + - "JyBzcGVjaWZpZWRgIChmdW5jdGlvbiBkZXBsb3kpIHwgV3JvbmcgZmllbGQg4oCUIGBncHVgIGlz" + - "IHRoZSBmYW1pbHksIG5vdCB0aGUgU0tVIHwgVXNlIGAiZ3B1IjogIkgxMDAiYCwgYCJpbnN0YW5j" + - "ZVR5cGUiOiAiTkNQLkdQVS5IMTAwXzF4ImAgfAp8IGByZWdpb24gbXVzdCBiZSBwcm92aWRlZGAg" + - "KGNsdXN0ZXIgcmVnaXN0ZXIgLyBpbnN0YWxsIC0tY29tcHV0ZS1wbGFuZSkgfCBgLS1yZWdpb25g" + - "IGVtcHR5ICsgYENMVVNURVJfUkVHSU9OYCBlbnYgZW1wdHkgfCBQYXNzIGAtLXJlZ2lvbj11cy13" + - "ZXN0LTFgIChvciBhbnkgbm9uLWVtcHR5IHZhbHVlKSB8CnwgYHJlcXVpcmVkRW52ICJOQ0FfSUQi" + - "IGlzIG5vdCBzZXRgIChoZWxtZmlsZSBlcnJvciBkdXJpbmcgY29tcHV0ZS1wbGFuZSBhcHBseSkg" + - "fCBPbGRlciBudmNmLWNsaSBiZWZvcmUgY29tbWl0IGA2YWE1NzA0YDsgRXh0cmFFbnYgbm90IHBy" + - "b3BhZ2F0aW5nIE5DQV9JRCB8IFVwZ3JhZGUgYG52Y2YtY2xpYCB0byBhIHJlbGVhc2UgYWZ0ZXIg" + - "YDZhYTU3MDRgIHwKfCBgbnZjYS1vcGVyYXRvcjogSW1hZ2VQdWxsQmFja09mZmAgZm9yIGBudmNh" + - "LW9wZXJhdG9yOnBzYXRgIHwgSW1hZ2Ugbm90IGluIGNsdXN0ZXIgcmVnaXN0cnk7IG11bHRpLWNs" + - "dXN0ZXIgYnVpbGQgaXMgbG9jYWwgfCBgazNkIGltYWdlIGltcG9ydCBudmNyLmlvLy4uLi9udmNh" + - "LW9wZXJhdG9yOnBzYXQgLWMgPGNsdXN0ZXI+YCB8CgojIyBDb21wdXRlLXBsYW5lIHJ1bnRpbWUK" + - "CnwgU3ltcHRvbSB8IENhdXNlIHwgUmVtZWRpYXRpb24gfAp8LS0tfC0tLXwtLS18CnwgTlZDQSBh" + - "Z2VudCBDcmFzaExvb3BCYWNrT2ZmIHdpdGggYEhUVFAgNDAxYCBvbiBgL3YxL252Y2EvY2x1c3Rl" + - "cnMvLi4uL3JlZ2lzdGVyYCB8IFN0YWxlIGBvdXQvPGNsdXN0ZXI+LXJlZ2lzdGVyLXZhbHVlcy55" + - "YW1sYCBmcm9tIHByaW9yIHJlZ2lzdGVyOyBjbHVzdGVyIElEIGRvZXNuJ3QgbWF0Y2ggSUNNUyB8" + - "IERlbGV0ZSB0aGUgc3RhbGUgZmlsZTsgcmUtcnVuIGBudmNmLWNsaSBzZWxmLWhvc3RlZCB1cGAg" + - "KGlkZW1wb3RlbnQgcmVnaXN0ZXIgd3JpdGVzIGEgZnJlc2ggZmlsZSkgfAp8IGBObyBjbHVzdGVy" + - "IGZvdW5kIHdpdGggdmFsaWQgSldLUyBmb3IgY2x1c3RlciBJRDogPGlkPmAgKElDTVMgbG9nKSB8" + - "IEpXS1MgaW4gSUNNUyBkb2Vzbid0IG1hdGNoIHdoYXQgY29tcHV0ZS1wbGFuZSBLOHMgaXMgY3Vy" + - "cmVudGx5IHNpZ25pbmcgfCBgbnZjZi1jbGkgY2x1c3RlciByb3RhdGUgLS1jbHVzdGVyLWlkPTxp" + - "ZD5gIHwKfCBGdW5jdGlvbiBwb2QgYEltYWdlUHVsbEJhY2tPZmZgIGluIGBudmNmLWJhY2tlbmRg" + - "IHwgSW1hZ2UtY3JlZGVudGlhbC1oZWxwZXIgY29uZmlnIG1pc3Npbmcgb3Igd3JvbmcgfCBga3Vi" + - "ZWN0bCBkZXNjcmliZSBwb2QgLW4gbnZjZi1iYWNrZW5kIDxwb2Q+YDsgY2hlY2sgdGhlIHB1bGwg" + - "c2VjcmV0IGNvbmZpZyB8CnwgRnVuY3Rpb24gZGVwbG95IHN0dWNrIGBERVBMT1lJTkdgIGZvciA+" + - "NSBtaW4gfCBOQVRTIHN0cmVhbSBpbml0IGxhZyAoY29sZC1jbHVzdGVyKSDigJQgd2FpdCwgb3Ig" + - "Y2hlY2sgTkFUUyBhdXRoLWNhbGxvdXQgaGVhbHRoIHwgYGt1YmVjdGwgbG9ncyAtbiBuYXRzLXN5" + - "c3RlbSAtbCBhcHAua3ViZXJuZXRlcy5pby9uYW1lPW5hdHMtYXV0aC1jYWxsb3V0LXNlcnZpY2Vg" + - "IHwKCiMjIFRhc2tzCgp8IFN5bXB0b20gfCBDYXVzZSB8IFJlbWVkaWF0aW9uIHwKfC0tLXwtLS18" + - "LS0tfAp8IGB0YXNrIGNyZWF0ZWAgcmV0dXJucyBgTWlzc2luZyA8VFlQRT4gcmVnaXN0cnkgY3Jl" + - "ZGVudGlhbCBmb3IgaG9zdG5hbWVgLCBvciBrZWVwcyB1c2luZyBhIHByZXZpb3VzIGNyZWRlbnRp" + - "YWwgdmFsdWUsIHNob3J0bHkgYWZ0ZXIgYHJlZ2lzdHJ5LWNyZWRlbnRpYWwgYWRkL3VwZGF0ZS9k" + - "ZWxldGVgIHdoaWxlIGByZWdpc3RyeS1jcmVkZW50aWFsIGxpc3RgL2BnZXRgIGFscmVhZHkgc2hv" + - "dyB0aGUgbmV3IHZhbHVlIHwgRXhwZWN0ZWQgcHJvcGFnYXRpb24gZGVsYXk6IE5WQ1QgY2FjaGVz" + - "IHRoZSBhY2NvdW50J3MgcmVnaXN0cnkgY3JlZGVudGlhbHMgd2l0aCBgbnZjdC5udmNmLmNhY2hl" + - "LXR0bGAgKGRlZmF1bHQgYFBUNU1gLCBhYm91dCA1IG1pbikgYW5kIGFwcGxpZXMgdGhlIGNoYW5n" + - "ZSB3aGVuIHRoYXQgY2FjaGVkIGNvcHkgcmVmcmVzaGVzIHwgV2FpdCB1cCB0byBhYm91dCA1IG1p" + - "biBhbmQgcmV0cnksIG9yIGBrdWJlY3RsIC1uIG52Y2Ygcm9sbG91dCByZXN0YXJ0IGRlcGxveW1l" + - "bnQvbnZjdC1hcGlgIHRvIGFwcGx5IGltbWVkaWF0ZWx5IHwKUEsHCPOuE4R0EQAAdBEAAFBLAwQU" + - "AAgAAAAAACEAAAAAAAAAAAAAAAAALAAJAGRhdGEvbnZjZi1zZWxmLW1hbmFnZWQtaW5zdGFsbGF0" + - "aW9uL1NLSUxMLm1kVVQFAAEAps4SLS0tCm5hbWU6IG52Y2Ytc2VsZi1tYW5hZ2VkLWluc3RhbGxh" + - "dGlvbgpkZXNjcmlwdGlvbjogPi0KICBJbnN0YWxsIGFuZCBvcGVyYXRlIE5WQ0Ygc2VsZi1ob3N0" + - "ZWQgY29udHJvbC1wbGFuZSBhbmQgc2VwYXJhdGUgY29tcHV0ZS1wbGFuZQogIHN0YWNrcy4gQ292" + - "ZXJzIEhlbG1maWxlIHZhbHVlcyBhbmQgQ0xJIHByb2ZpbGUgaW5zdGFsbGF0aW9uIGZsb3dzLCB0" + - "ZWFyZG93biwKICB2YWx1ZXMgb3ZlcnJpZGVzLCBwdWxsIHNlY3JldHMsIGFuZCB0cm91Ymxlc2hv" + - "b3RpbmcuIFVzZSBmb3IKICBudmNmLXNlbGYtbWFuYWdlZC1zdGFjaywgbnZjZi1jb21wdXRlLXBs" + - "YW5lLXN0YWNrLCBzcGxpdCBjb21wdXRlLXBsYW5lCiAgaW5zdGFsbGF0aW9uLCBjb250cm9sLXBs" + - "YW5lIGluc3RhbGxhdGlvbiwgQ0xJLWdlbmVyYXRlZCBjb250cm9sLXBsYW5lCiAgcHJvZmlsZXMs" + - "IEhlbG1maWxlLCBzZWxmLW1hbmFnZWQsIG9yIHNlbGYtaG9zdGVkIGRlcGxveW1lbnRzLiBEbyBO" + - "T1QgdXNlIGZvcgogIGxvY2FsIGszZCBlbnZpcm9ubWVudHM7IHVzZSB0aGUgbG9jYWwgazNkIGRl" + - "dmVsb3BtZW50IHdvcmtmbG93IGluc3RlYWQuCmxpY2Vuc2U6IEFwYWNoZS0yLjAKY29tcGF0aWJp" + - "bGl0eTogUmVxdWlyZXMgaGVsbWZpbGUgPj0gMS4xLjAgPCAxLjIuMCwgaGVsbSA+PSAzLjEyLCBo" + - "ZWxtLWRpZmYgcGx1Z2luLCBrdWJlY3RsIG1hdGNoaW5nIGNsdXN0ZXIgdmVyc2lvbgphdXRob3I6" + - "ICJudmNmLWNvcmUtZW5nIDxudmNmLWNvcmUtZW5nQGV4Y2hhbmdlLm52aWRpYS5jb20+Igp2ZXJz" + - "aW9uOiAiMS4wLjAiCnRhZ3M6IFtudmNmLCBzZWxmLW1hbmFnZWQsIGhlbG1maWxlLCBzZWxmLWhv" + - "c3RlZCwgY29udHJvbC1wbGFuZSwgY29tcHV0ZS1wbGFuZSwgY2xpLXByb2ZpbGUsIGluc3RhbGxh" + - "dGlvbiwgZGVwbG95bWVudCwgcHVsbC1zZWNyZXRzXQp0b29sczogW1NoZWxsLCBSZWFkLCBFZGl0" + - "LCBHcmVwLCBHbG9iXQptZXRhZGF0YToKICBpbnRlcm5hbDogZmFsc2UKICBhdXRob3I6ICJudmNm" + - "LWNvcmUtZW5nIDxudmNmLWNvcmUtZW5nQGV4Y2hhbmdlLm52aWRpYS5jb20+IgogIHZlcnNpb246" + - "ICIxLjAiCiAgdGFnczogW252Y2YsIHNlbGYtbWFuYWdlZCwgaGVsbWZpbGUsIHNlbGYtaG9zdGVk" + - "LCBjb250cm9sLXBsYW5lLCBjb21wdXRlLXBsYW5lLCBjbGktcHJvZmlsZSwgaW5zdGFsbGF0aW9u" + - "LCBkZXBsb3ltZW50LCBwdWxsLXNlY3JldHNdCiAgbGFuZ3VhZ2VzOiBbYmFzaCwgeWFtbF0KICBm" + - "cmFtZXdvcmtzOiBbaGVsbWZpbGUsIGhlbG0sIGt1YmVjdGxdCiAgZG9tYWluOiBjbG91ZC1pbmZy" + - "YXN0cnVjdHVyZQotLS0KCiMgTlZDRiBTZWxmLU1hbmFnZWQgU3RhY2sgT3BlcmF0aW9ucwoKT3Bl" + - "cmF0aW9uYWwgZ3VpZGUgZm9yIG1hdGNoaW5nIE5WQ0YgY29udHJvbC1wbGFuZSBhbmQgY29tcHV0" + - "ZS1wbGFuZSBIZWxtZmlsZSBidW5kbGVzLgoKIyMgSW5zdHJ1Y3Rpb25zCgpVc2UgdGhpcyBza2ls" + - "bCBmb3IgaW5zdGFsbCwgdXBncmFkZSwgb3IgdGVhcmRvd24gd29yayBpbiBtYXRjaGluZyBgbnZj" + - "Zi1zZWxmLW1hbmFnZWQtc3RhY2tgIGFuZCBgbnZjZi1jb21wdXRlLXBsYW5lLXN0YWNrYCBidW5k" + - "bGVzOyBrZWVwIEhlbG1maWxlIHZhbHVlcyBhbmQgQ0xJIHByb2ZpbGUgaGFuZG9mZnMgc2VwYXJh" + - "dGUuIEZvciBgZnVuY3Rpb25UeXBlOiAiTExNImAsIHJlYWQgW0xMTSBGdW5jdGlvbiBFbmFibGVt" + - "ZW50XShyZWZlcmVuY2VzL2hlbG1maWxlLXN0cnVjdHVyZS5tZCNsbG0tZnVuY3Rpb24tZW5hYmxl" + - "bWVudCkuCgojIyBQcmVyZXF1aXNpdGVzCgpBc2sgZm9yIHRoZSBleHRyYWN0ZWQgYG52Y2Ytc2Vs" + - "Zi1tYW5hZ2VkLXN0YWNrYCBwYXRoLiBGb3Igc3BsaXQgaW5zdGFsbGF0aW9uLAphbHNvIHJlcXVp" + - "cmUgdGhlIG1hdGNoaW5nLXZlcnNpb24gYG52Y2YtY29tcHV0ZS1wbGFuZS1zdGFja2AgcGF0aC4g" + - "VmVyaWZ5IGJvdGg6CgpgYGBiYXNoCmxzIDxjb250cm9sLXBsYW5lLXN0YWNrPi9oZWxtZmlsZS5k" + - "LyA8Y29udHJvbC1wbGFuZS1zdGFjaz4vZW52aXJvbm1lbnRzLyA8Y29udHJvbC1wbGFuZS1zdGFj" + - "az4vc2VjcmV0cy8gPGNvbnRyb2wtcGxhbmUtc3RhY2s+L2dsb2JhbC55YW1sLmdvdG1wbApscyA8" + - "Y29tcHV0ZS1wbGFuZS1zdGFjaz4vaGVsbWZpbGUuZC8gPGNvbXB1dGUtcGxhbmUtc3RhY2s+L2Vu" + - "dmlyb25tZW50cy8gPGNvbXB1dGUtcGxhbmUtc3RhY2s+L2dsb2JhbC55YW1sLmdvdG1wbApgYGAK" + - "CklmIGVpdGhlciBkaXJlY3RvcnkgaXMgbWlzc2luZywgZG93bmxvYWQgbWF0Y2hpbmcgYnVuZGxl" + - "IHZlcnNpb25zIGZyb20gTkdDOgoKYGBgYmFzaApuZ2MgcmVnaXN0cnkgcmVzb3VyY2UgZG93bmxv" + - "YWQtdmVyc2lvbiA8b3JnPi9udmNmLXNlbGYtbWFuYWdlZC1zdGFjazo8dmVyc2lvbj4KbmdjIHJl" + - "Z2lzdHJ5IHJlc291cmNlIGRvd25sb2FkLXZlcnNpb24gPG9yZz4vbnZjZi1jb21wdXRlLXBsYW5l" + - "LXN0YWNrOjx2ZXJzaW9uPgpgYGAKCkNvbnRyb2wtcGxhbmUgY29tbWFuZHMgYmVsb3cgYXNzdW1l" + - "IHRoZSBjb250cm9sLXBsYW5lIGJ1bmRsZSByb290LiBTcGxpdC1mbG93CmNvbW1hbmRzIGFuZCBy" + - "b290IHN1YnN0aXR1dGlvbiBhcmUgaW4KW1NwbGl0IENvbXB1dGUtUGxhbmUgSW5zdGFsbGF0aW9u" + - "XShyZWZlcmVuY2VzL2NvbXB1dGUtcGxhbmUtaW5zdGFsbGF0aW9uLm1kKS4KCiMjIEJlZm9yZSBZ" + - "b3UgU3RhcnQKClZlcmlmeSB0b29saW5nIGFuZCBjb250ZXh0IGJlZm9yZSBhbnkgb3BlcmF0aW9u" + - "OgoKYGBgYmFzaApoZWxtZmlsZSAtLXZlcnNpb24gICAjIE11c3QgYmUgMS4xLnggKDEuMi4wIHJl" + - "bW92ZWQgc2VxdWVudGlhbCBtb2RlKQpoZWxtIHZlcnNpb24gICAgICAgICAjIE11c3QgYmUgPj0g" + - "My4xMgpoZWxtIHBsdWdpbiBsaXN0ICAgICAjIE11c3QgaW5jbHVkZSBoZWxtLWRpZmYgPj0gMy4x" + - "MQprdWJlY3RsIHZlcnNpb24gICAgICAjIENsaWVudCBtdXN0IGJlIHdpdGhpbiAxIG1pbm9yIHZl" + - "cnNpb24gb2YgY2x1c3RlcgpgYGAKCkNvbnRyb2wtcGxhbmUgY29tbWFuZHMgcnVuIGZyb20gdGhl" + - "IGV4dHJhY3RlZCBgbnZjZi1zZWxmLW1hbmFnZWQtc3RhY2svYCByb290OgoKYGBgYmFzaApjZCBw" + - "YXRoL3RvL252Y2Ytc2VsZi1tYW5hZ2VkLXN0YWNrCmxzIGhlbG1maWxlLmQvIGVudmlyb25tZW50" + - "cy8gc2VjcmV0cy8gZ2xvYmFsLnlhbWwuZ290bXBsCmBgYAoKSWRlbnRpZnkgdGhlIGVudmlyb25t" + - "ZW50IGZyb20gYGVudmlyb25tZW50cy88bmFtZT4ueWFtbGAgYW5kCmBzZWNyZXRzLzxuYW1lPi1z" + - "ZWNyZXRzLnlhbWxgOyBmb3IgRUtTLCB1c2UgdGhlIGNhbm9uaWNhbApbQ1NQIEVuZC10by1FbmQg" + - "RXhhbXBsZV0oaHR0cHM6Ly9kb2NzLm52aWRpYS5jb20vbnZjZi92MC42LjAtcmMvY3NwLWVuZC10" + - "by1lbmQtZXhhbXBsZSkuCgojIyBIb3cgVmFsdWVzIEZsb3cKClVuZGVyc3RhbmRpbmcgdmFsdWUg" + - "cHJlY2VkZW5jZSBwcmV2ZW50cyB0aGUgbW9zdCBjb21tb24gY29uZmlndXJhdGlvbiBtaXN0YWtl" + - "cy4KCmBgYAplbnZpcm9ubWVudHMvYmFzZS55YW1sICAgICAgICAgIChkZWZhdWx0cykKICAgIC0+" + - "IG1lcmdlZCB3aXRoCmVudmlyb25tZW50cy88ZW52Pi55YW1sICAgICAgICAgKHlvdXIgb3ZlcnJp" + - "ZGVzKQogICAgLT4gY29uc3VtZWQgYnkKZ2xvYmFsLnlhbWwuZ290bXBsICAgICAgICAgICAgICAo" + - "R28gdGVtcGxhdGUsIGNvbnN0cnVjdHMgcGVyLWNoYXJ0IHZhbHVlcykKICAgIC0+IGNvbnN1bWVk" + - "IGJ5CnNlY3JldHMvPGVudj4tc2VjcmV0cy55YW1sICAgICAgKHNlbnNpdGl2ZSB2YWx1ZXMpCiAg" + - "ICAtPiBvdmVycmlkZGVuIGJ5CnJlbGVhc2UgaW5saW5lIHZhbHVlczogYmxvY2tzICAgKGhpZ2hl" + - "c3QgcHJlY2VkZW5jZSkKYGBgCgpDcml0aWNhbDogYGdsb2JhbC55YW1sLmdvdG1wbGAgb25seSBw" + - "YXNzZXMgdGhyb3VnaCBzcGVjaWZpYyBrZXlzIHRvIGVhY2ggY2hhcnQgKGltYWdlIHJlZ2lzdHJp" + - "ZXMsIG5vZGUgc2VsZWN0b3JzLCBzdG9yYWdlLCByZXBsaWNhIGNvdW50cykuIFNldHRpbmcgYW4g" + - "YXJiaXRyYXJ5IGNoYXJ0IHZhbHVlIGluIHRoZSBlbnZpcm9ubWVudCBmaWxlIHdpbGwgYmUgc2ls" + - "ZW50bHkgaWdub3JlZCBpZiBgZ2xvYmFsLnlhbWwuZ290bXBsYCBkb2VzIG5vdCBwcm9wYWdhdGUg" + - "aXQuCgpUbyBvdmVycmlkZSBhcmJpdHJhcnkgY2hhcnQgdmFsdWVzLCB1c2UgYSBoZWxtZmlsZSBy" + - "ZWxlYXNlIGB2YWx1ZXM6YCBibG9jay4gU2VlIFtPdmVycmlkaW5nIEhlbG0gQ2hhcnQgVmFsdWVz" + - "XSgjb3ZlcnJpZGluZy1oZWxtLWNoYXJ0LXZhbHVlcykuCgojIyBDbGVhbiBJbnN0YWxsYXRpb24K" + - "CiMjIyAxLiBDcmVhdGUgbmFtZXNwYWNlcyBhbmQgaW1hZ2UgcHVsbCBzZWNyZXRzIChpZiB1c2lu" + - "ZyBhIHByaXZhdGUgcmVnaXN0cnkpCgpgYGBiYXNoCmZvciBucyBpbiBjYXNzYW5kcmEtc3lzdGVt" + - "IG5hdHMtc3lzdGVtIG52Y2YgYXBpLWtleXMgZXNzIHNpcyB2YXVsdC1zeXN0ZW0gY2VydC1tYW5h" + - "Z2VyOyBkbwogIGt1YmVjdGwgY3JlYXRlIG5hbWVzcGFjZSAiJG5zIiAtLWRyeS1ydW49Y2xpZW50" + - "IC1vIHlhbWwgfCBrdWJlY3RsIGFwcGx5IC1mIC0KZG9uZQoKIyBPbmx5IGlmIHB1bGxpbmcgZnJv" + - "bSBhIHByaXZhdGUgcmVnaXN0cnkgKGUuZy4sIE5HQyBudmNyLmlvKQpleHBvcnQgTkdDX0FQSV9L" + - "RVk9Ijx5b3VyLWtleT4iCmZvciBucyBpbiBjYXNzYW5kcmEtc3lzdGVtIG5hdHMtc3lzdGVtIG52" + - "Y2YgYXBpLWtleXMgZXNzIHNpcyB2YXVsdC1zeXN0ZW0gY2VydC1tYW5hZ2VyOyBkbwogIGt1YmVj" + - "dGwgY3JlYXRlIHNlY3JldCBkb2NrZXItcmVnaXN0cnkgbnZjci1jcmVkcyBcCiAgICAtLWRvY2tl" + - "ci1zZXJ2ZXI9bnZjci5pbyBcCiAgICAtLWRvY2tlci11c2VybmFtZT0nJG9hdXRodG9rZW4nIFwK" + - "ICAgIC0tZG9ja2VyLXBhc3N3b3JkPSIkTkdDX0FQSV9LRVkiIFwKICAgIC0tbmFtZXNwYWNlPSIk" + - "bnMiIFwKICAgIC0tZHJ5LXJ1bj1jbGllbnQgLW8geWFtbCB8IGt1YmVjdGwgYXBwbHkgLWYgLQpk" + - "b25lCmBgYAoKSWYgdXNpbmcgcHVsbCBzZWNyZXRzLCB5b3UgbXVzdCBhbHNvIGNvbmZpZ3VyZSBl" + - "YWNoIGhlbG1maWxlIHJlbGVhc2UgdG8gcmVmZXJlbmNlIHRoZW0uIFNlZSBbSW1hZ2UgUHVsbCBT" + - "ZWNyZXRzXSgjaW1hZ2UtcHVsbC1zZWNyZXRzKS4KCiMjIyAyLiBBdXRoZW50aWNhdGUgaGVsbSB0" + - "byB5b3VyIGNoYXJ0IHJlZ2lzdHJ5CgpCb3RoIGBkb2NrZXIgbG9naW5gIEFORCBgaGVsbSByZWdp" + - "c3RyeSBsb2dpbmAgYXJlIHJlcXVpcmVkIGZvciBOR0MuIEhlbG1maWxlIHVzZXMgaGVsbSAobm90" + - "IGRvY2tlcikgdG8gcHVsbCBPQ0kgY2hhcnRzLCBzbyB0aGUgaGVsbSBjcmVkZW50aWFsIHN0b3Jl" + - "IG11c3QgYmUgYXV0aGVudGljYXRlZCBzZXBhcmF0ZWx5LgoKYGBgYmFzaAojIE5HQyAtLSBib3Ro" + - "IGNvbW1hbmRzIGFyZSByZXF1aXJlZApkb2NrZXIgbG9naW4gbnZjci5pbyAtdSAnJG9hdXRodG9r" + - "ZW4nIC1wICIkTkdDX0FQSV9LRVkiCmhlbG0gcmVnaXN0cnkgbG9naW4gbnZjci5pbyAtdSAnJG9h" + - "dXRodG9rZW4nIC1wICIkTkdDX0FQSV9LRVkiCgojIEVDUgphd3MgZWNyIGdldC1sb2dpbi1wYXNz" + - "d29yZCAtLXJlZ2lvbiA8cmVnaW9uPiB8IFwKICBoZWxtIHJlZ2lzdHJ5IGxvZ2luIC0tdXNlcm5h" + - "bWUgQVdTIC0tcGFzc3dvcmQtc3RkaW4gPGFjY291bnQ+LmRrci5lY3IuPHJlZ2lvbj4uYW1hem9u" + - "YXdzLmNvbQpgYGAKCj4gTm90ZTogYGhlbG0gcmVnaXN0cnkgbG9naW5gIGtlZXBzIG9ubHkgdGhl" + - "IGxhc3QgbG9naW4gcGVyIGhvc3QgKG11bHRpLW9yZyBnb3RjaGEpLgo+IFRoZSBzdGFjayBhbmQg" + - "dGhlIGNhY2hlcyBzcGFuIHNldmVyYWwgTkdDIG9yZ3MgdGhhdCBuZWVkIGRpZmZlcmVudCBrZXlz" + - "LCBidXQgdGhleSBhbGwKPiBsaXZlIHVuZGVyIHRoZSBvbmUgaG9zdCBgbnZjci5pb2AuIEEgc2Vj" + - "b25kIGBoZWxtIHJlZ2lzdHJ5IGxvZ2luIG52Y3IuaW9gIChvcgo+IGBkb2NrZXIgbG9naW5gKSB3" + - "aXRoIGEgZGlmZmVyZW50IGtleSBzaWxlbnRseSBvdmVyd3JpdGVzIHRoZSBmaXJzdCwgc28gcHVs" + - "bHMgZm9yIHRoZQo+IGZpcnN0IG9yZyB0aGVuIGZhaWwgd2l0aCBhIG1pc2xlYWRpbmcgYDQwMyBB" + - "Y2Nlc3MgRGVuaWVkYCAobm90IGEgNDAxOiB0aGUgYXV0aAo+IHN1Y2NlZWRlZCwgaXQncyB0aGUg" + - "d3Jvbmctb3JnIGtleSkuIElmIHlvdSBwdWxsIGNoYXJ0cy9pbWFnZXMgZnJvbSBtb3JlIHRoYW4g" + - "b25lIG9yZywKPiBlaXRoZXIgcmUtcnVuIHRoZSBsb2dpbiB3aXRoIHRoZSBjb3JyZWN0IGtleSBp" + - "bW1lZGlhdGVseSBiZWZvcmUgZWFjaCBwdWxsLCBvciBwYXNzCj4gYC0tdXNlcm5hbWUgJyRvYXV0" + - "aHRva2VuJyAtLXBhc3N3b3JkIDxrZXk+YCBwZXIgYGhlbG0gcHVsbGAgaW52b2NhdGlvbiBpbnN0" + - "ZWFkIG9mIHJlbHlpbmcKPiBvbiB0aGUgc3RvcmVkIGxvZ2luLiAoUHVsbGluZyBldmVyeXRoaW5n" + - "IGZyb20gYSBzaW5nbGUgcmVnaXN0cnkgbWlycm9yIGF2b2lkcyB0aGlzCj4gZW50aXJlbHkuKQoK" + - "IyMjIDJiLiAoUmVjb21tZW5kZWQpIFB1bGwgZnJvbSBhIHJlZ2lzdHJ5IHRoZSBjbHVzdGVyIGF1" + - "dGhlbnRpY2F0ZXMgdG8gYXV0b21hdGljYWxseQoKSWYgeW91IG1pcnJvciB0aGUgTlZDRiBpbWFn" + - "ZXMgaW50byBhIHJlZ2lzdHJ5IHRoYXQgdGhlIGNsdXN0ZXIgY2FuIHB1bGwgZnJvbSB3aXRob3V0" + - "IGFuCmV4cGxpY2l0IGltYWdlIHB1bGwgc2VjcmV0IChmb3IgZXhhbXBsZSwgYSByZWdpc3RyeSB3" + - "aGVyZSB0aGUgbm9kZSBvciB3b3JrbG9hZCBpZGVudGl0eSBpcwpncmFudGVkIHB1bGwgYWNjZXNz" + - "IGF1dG9tYXRpY2FsbHkpLCBwb2ludCB0aGUgc3RhY2sgYXQgaXQgYW5kIHNraXAgdGhlIGNyZWRl" + - "bnRpYWwgc3RlcHMKYWJvdmUuCgoxLiBQb2ludCB0aGUgc3RhY2sgYXQgdGhlIG1pcnJvciBpbiBg" + - "ZW52aXJvbm1lbnRzLzxlbnY+LnlhbWxgOgoKICAgYGBgeWFtbAogICBnbG9iYWw6CiAgICAgaW1h" + - "Z2U6CiAgICAgICByZWdpc3RyeTogPHlvdXItcmVnaXN0cnk+ICAgICAgICAgICAgIyBlLmcuIHJl" + - "Z2lzdHJ5LmV4YW1wbGUuY29tCiAgICAgICByZXBvc2l0b3J5OiA8bWlycm9yLXN1Yi1wYXRoPgog" + - "ICAgIGhlbG06CiAgICAgICBzb3VyY2VzOiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICMg" + - "b25seSBpZiB5b3UgYWxzbyBtaXJyb3JlZCB0aGUgaGVsbSBjaGFydHMKICAgICAgICAgcmVnaXN0" + - "cnk6IDx5b3VyLXJlZ2lzdHJ5PgogICAgICAgICByZXBvc2l0b3J5OiA8bWlycm9yLXN1Yi1wYXRo" + - "PgogICBgYGAKCiAgID4gVGhlIG1hbmlmZXN0IGhhcyBhIG1peCBvZiBPQ0kgYW5kIG5vbi1PQ0kg" + - "YXJ0aWZhY3RzLCBzbyBjb252ZXJ0IG5vbi1PQ0kgY2hhcnRzIGJlZm9yZQogICA+IG1pcnJvcmlu" + - "Zy4gQ29udGFpbmVyIGltYWdlcyAoYG52Y3IuaW8vLi4uYCkgYXJlIGFscmVhZHkgT0NJIGFuZCBt" + - "aXJyb3IgYXMtaXMuIFNvbWUgSGVsbQogICA+IGNoYXJ0cywgdGhvdWdoLCBhcmUgcHVibGlzaGVk" + - "IHRvIGFuIGBodHRwczovL2AgSGVsbSByZXBvc2l0b3J5IChmb3IgZXhhbXBsZQogICA+IGBoZWxt" + - "Lm5nYy5udmlkaWEuY29tYCkuIFRob3NlIGFyZSBub3QgT0NJIGFuZCBjYW5ub3QgYmUgcmVzb2x2" + - "ZWQgYnkgYGdsb2JhbC5oZWxtLnNvdXJjZXNgCiAgID4gKE9DSSkgb3IgbWlycm9yZWQgZGlyZWN0" + - "bHkuIEJlZm9yZSBwb2ludGluZyB0aGUgc3RhY2sgYXQgeW91ciBtaXJyb3IsIGNvbnZlcnQgZWFj" + - "aAogICA+IGBodHRwczovL2AgY2hhcnQgdG8gT0NJOiBgaGVsbSByZXBvIGFkZGAvYGhlbG0gcHVs" + - "bGAgdGhlIGAudGd6YCwgdGhlbgogICA+IGBoZWxtIHB1c2ggPGNoYXJ0Pi50Z3ogb2NpOi8vPHlv" + - "dXItcmVnaXN0cnk+LzxtaXJyb3Itc3ViLXBhdGg+YC4gT25seSBPQ0kgY2hhcnRzIGNhbiBsaXZl" + - "CiAgID4gdW5kZXIgYGdsb2JhbC5oZWxtLnNvdXJjZXNgLgoKMi4gU2tpcCB0aGUgY3JlZGVudGlh" + - "bCBzdGVwcyBhYm92ZS4gV2hlbiB0aGUgY2x1c3RlciBhdXRoZW50aWNhdGVzIHRvIHRoZSByZWdp" + - "c3RyeQogICBhdXRvbWF0aWNhbGx5ICh0aGUgbm9kZSBvciB3b3JrbG9hZCBpZGVudGl0eSBoYXMg" + - "cHVsbCBhY2Nlc3MpLCB0aGUgcHVsbCBuZWVkcyBubwogICBLdWJlcm5ldGVzIHNlY3JldCwgc28g" + - "eW91IGRvIG5vdCBuZWVkOiB0aGUgcGVyLW5hbWVzcGFjZSBgbnZjci1jcmVkc2AgZnJvbSBzdGVw" + - "IDEKICAgKHN0aWxsIGNyZWF0ZSB0aGUgbmFtZXNwYWNlcywganVzdCBub3QgdGhlIHNlY3JldCks" + - "IHRoZSBgZ2xvYmFsLmltYWdlUHVsbFNlY3JldHNgIGVudHJ5LAogICBvciB0aGUgYGRvY2tlciBs" + - "b2dpbmAvYGhlbG0gcmVnaXN0cnkgbG9naW4gbnZjci5pb2AgZnJvbSBzdGVwIDIuCgogICA+IE9u" + - "ZSByZXNpZHVhbCBjcmVkZW50aWFsOiBudmNmLWFwaSBzdGlsbCB2YWxpZGF0ZXMgdGhlIHVzZXIg" + - "ZnVuY3Rpb24gaW1hZ2UgYXQKICAgPiBgZnVuY3Rpb24gY3JlYXRlYCB2aWEgdGhlIGFjY291bnQg" + - "cmVnaXN0cnkgY3JlZGVudGlhbCwgc28gdGhhdCBjcmVkZW50aWFsIG11c3QgcG9pbnQgYXQKICAg" + - "PiB3aGljaGV2ZXIgcmVnaXN0cnkgaG9sZHMgdGhlIHVzZXIgaW1hZ2UgKHNldCBpdCB0byB5b3Vy" + - "IG1pcnJvciBpZiB0aGUgaW1hZ2UgaXMgbWlycm9yZWQKICAgPiB0aGVyZSkuCgojIyMgMy4gU2V0" + - "IHRoZSByb3V0ZSBkb21haW4KCmBnbG9iYWwuZG9tYWluYCBzZXRzIHRoZSBob3N0bmFtZSBzdWZm" + - "aXggZm9yIHJvdXRlcyBzdWNoIGFzIGBhcGkuPGRvbWFpbj5gLiBJdCBkb2VzIG5vdCBjb25maWd1" + - "cmUgdGhlIEdhdGV3YXkgb3IgaXRzIGxvYWQgYmFsYW5jZXIuIFF1ZXJ5IHRoZSBleGFjdCBleGlz" + - "dGluZyBHYXRld2F5OgoKYGBgYmFzaApHQVRFV0FZX0FERFJFU1M9JChrdWJlY3RsIGdldCBnYXRl" + - "d2F5IDxnYXRld2F5LW5hbWU+IC1uIDxnYXRld2F5LW5hbWVzcGFjZT4gLW8ganNvbnBhdGg9J3su" + - "c3RhdHVzLmFkZHJlc3Nlc1swXS52YWx1ZX0nKQp0ZXN0IC1uICIkR0FURVdBWV9BRERSRVNTIgpg" + - "YGAKClRoZSBhZGRyZXNzIG1heSBiZSBhIGhvc3RuYW1lIG9yIElQLiBDbG91ZCBwcm92aWRlciBh" + - "bmQgR2F0ZXdheSBjb25maWd1cmF0aW9uIGRldGVybWluZSB0aGUgbG9hZCBiYWxhbmNlciB0eXBl" + - "IGFuZCBhZGRyZXNzIGZvcm1hdC4gVGhlIHNlbGYtbWFuYWdlZCBzdGFjayBkb2VzIG5vdCBzZWxl" + - "Y3QgZWl0aGVyLgoKRm9yIHRlbXBvcmFyeSB0ZXN0aW5nIHdpdGhvdXQgRE5TLCB1c2UgYSBzdGFi" + - "bGUgcmVzZXJ2ZWQgc3VmZml4IHN1Y2ggYXMgYGdsb2JhbC5kb21haW46ICJudmNmLnRlc3QiYCwg" + - "Y29ubmVjdCB0byBgR0FURVdBWV9BRERSRVNTYCwgYW5kIHNlbmQgYEhvc3Q6IGFwaS5udmNmLnRl" + - "c3RgLiBGb3IgcHJvZHVjdGlvbiwgdXNlIHlvdXIgYmFzZSBETlMgZG9tYWluIGFuZCBwb2ludCBp" + - "dHMgcm91dGUgcmVjb3JkcyB0byBgR0FURVdBWV9BRERSRVNTYC4gSWYgdGhlIGVuZHBvaW50IGxh" + - "dGVyIGNoYW5nZXMsIGtlZXAgYGdsb2JhbC5kb21haW5gIHN0YWJsZSBhbmQgdXBkYXRlIG9ubHkg" + - "RE5TIG9yIHRoZSBjbGllbnQgZGVzdGluYXRpb24uIFNlZSBFeGFtcGxlIDQgaW4gW2V4YW1wbGVz" + - "Lm1kXShleGFtcGxlcy5tZCkuCgojIyMgNC4gUHJldmlldyBhbmQgZGVwbG95CgpgYGBiYXNoCkhF" + - "TE1GSUxFX0VOVj08ZW52LW5hbWU+IGhlbG1maWxlIHRlbXBsYXRlICAgIyBQcmV2aWV3IHJlbmRl" + - "cmVkIG1hbmlmZXN0cwpIRUxNRklMRV9FTlY9PGVudi1uYW1lPiBoZWxtZmlsZSBzeW5jICAgICAg" + - "ICMgRGVwbG95CmBgYAoKPiBTZXQgQk9USCBDYXNzYW5kcmEgcGFzc3dvcmRzIGluIHRoZSBzZWNy" + - "ZXRzIGZpbGUuIFRoZSBzZWNyZXRzIGZpbGUgZG9jdW1lbnRzCj4gYERFRkFVTFRfQ0FTU0FORFJB" + - "X1BBU1NXT1JEYCwgYnV0IHRoZSBjYXNzYW5kcmEgY2hhcnQgaGFzIGEgc2Vjb25kIGNyZWRlbnRp" + - "YWwsCj4gYGNhc3NhbmRyYS5zZXJ2aWNlUm9sZVBhc3N3b3JkYCwgdGhhdCBkZWZhdWx0cyB0byBg" + - "Y2hAbmczbTNgLiBJZiB5b3Ugc2V0IG9ubHkKPiBgREVGQVVMVF9DQVNTQU5EUkFfUEFTU1dPUkRg" + - "LCB0aGUgc2VydmljZSByb2xlIGtlZXBzIHRoYXQgZGVmYXVsdCBhbmQgZXZlcnkgREItYmFja2Vk" + - "Cj4gc2VydmljZSBjcmFzaC1sb29wcyB3aXRoIGBCYWQgY3JlZGVudGlhbHNgIG9uY2UgaXQgdHJp" + - "ZXMgdG8gYXV0aGVudGljYXRlLiBTZXQKPiBgY2Fzc2FuZHJhLnNlcnZpY2VSb2xlUGFzc3dvcmRg" + - "IHRvIHRoZSBzYW1lIHZhbHVlIGFzIGBERUZBVUxUX0NBU1NBTkRSQV9QQVNTV09SRGAuCgojIyMg" + - "NS4gRGVwbG95bWVudCBwaGFzZXMKCkhlbG1maWxlIGRlcGxveXMgaW4gb3JkZXIgd2l0aCBkZXBl" + - "bmRlbmNpZXM6Cgp8IFBoYXNlIHwgU2VsZWN0b3IgfCBTZXJ2aWNlcyB8IFdhaXQgdGltZSB8Cnwt" + - "LS0tLS0tfC0tLS0tLS0tLS18LS0tLS0tLS0tLXwtLS0tLS0tLS0tLXwKfCAxIHwgYHJlbGVhc2Ut" + - "Z3JvdXA9ZGVwZW5kZW5jaWVzYCB8IE5BVFMsIE9wZW5CYW8sIENhc3NhbmRyYSB8IDUtMTAgbWlu" + - "IHwKfCAyIHwgYHJlbGVhc2UtZ3JvdXA9c2VydmljZXNgIHwgQVBJLCBTSVMsIEVTUywgaW52b2Nh" + - "dGlvbiwgZ3JwYy1wcm94eSwgbm90YXJ5LCBhcGkta2V5cywgb3B0aW9uYWwgTExNIGdhdGV3YXkv" + - "cm91dGVyLCBvcHRpb25hbCBWYW5pdHkgR2F0ZXdheSwgTlZDRiBVSSB3aGVuIHRoZSBzdGFjayBw" + - "YWNrYWdlIGluY2x1ZGVzIHRoZSBhZGRvbiB8IDUtMTAgbWluIHwKfCAzIHwgYHJlbGVhc2UtZ3Jv" + - "dXA9aW5ncmVzc2AgfCBHYXRld2F5IHJvdXRlcyB8IDEtMiBtaW4gfAp8IDQgfCBgcmVsZWFzZS1n" + - "cm91cD1vYnNlcnZhYmlsaXR5YCB8IE9ic2VydmFiaWxpdHkgc3RhY2sgKGlmIGVuYWJsZWQpIHwg" + - "MS0yIG1pbiB8CgpNb25pdG9yIGluIGEgc2VwYXJhdGUgdGVybWluYWw6CgpgYGBiYXNoCmt1YmVj" + - "dGwgZ2V0IHBvZHMgLUEgLXcKYGBgCgojIyMgNi4gRW5hYmxlIFZhbml0eSBHYXRld2F5IChvcHRp" + - "b25hbCkKClZhbml0eSBHYXRld2F5IGlzIGRpc2FibGVkIGJ5IGRlZmF1bHQgYW5kIGlzIG9ubHkg" + - "bmVlZGVkIGZvciBjdXN0b21lci1mYWNpbmcKaG9zdG5hbWVzIG9yIHBhdGggbWFwcGluZ3MgaW4g" + - "ZnJvbnQgb2YgdGhlIHN0YW5kYXJkIE5WQ0YgQVBJIGFuZCBpbnZvY2F0aW9uCnJvdXRlcy4gSXQg" + - "aXMgYXZhaWxhYmxlIG9ubHkgaW4gc3RhY2sgcGFja2FnZXMgdGhhdCBpbmNsdWRlIHRoZSBWYW5p" + - "dHkgR2F0ZXdheQphZGRvbi4gSWYgdGhlIGV4dHJhY3RlZCBzdGFjayBwYWNrYWdlIGRvZXMgbm90" + - "IGNvbnRhaW4gYSBgdmFuaXR5LWdhdGV3YXlgCnJlbGVhc2UgYW5kIGB2YW5pdHlHYXRld2F5YCBy" + - "b3V0ZSB2YWx1ZXMsIHNraXAgdGhlc2UgY29tbWFuZHMgYW5kIHVzZSBhIG5ld2VyCnN0YWNrIHBh" + - "Y2thZ2UgdGhhdCBpbmNsdWRlcyB0aGVtLgoKSWYgdGhlIHN0YWNrIHBhY2thZ2UgaW5jbHVkZXMg" + - "dGhlIGFkZG9uLCBlbmFibGUgaXQgaW4KYGVudmlyb25tZW50cy88ZW52LW5hbWU+LnlhbWxgOgoK" + - "YGBgeWFtbAphZGRvbnM6CiAgdmFuaXR5R2F0ZXdheToKICAgIGVuYWJsZWQ6IHRydWUKICAgIG1h" + - "cHBpbmdDb25maWc6IHt9CmBgYAoKVGhlIGRlZmF1bHQgcm91dGUgaG9zdCBpcyBgdmFuaXR5Ljxk" + - "b21haW4+YCBhbmQgdGhlIGJhY2tlbmQgaXMKYHZhbml0eS1nYXRld2F5Lm52Y2Y6ODA4MGAuIFB1" + - "dCBkZXBsb3ltZW50LXNwZWNpZmljIGhvc3QgYW5kIHBhdGggbWFwcGluZ3MgdW5kZXIKYGFkZG9u" + - "cy52YW5pdHlHYXRld2F5Lm1hcHBpbmdDb25maWdgLiBJZiB5b3UgbmVlZCBjdXN0b20gdmFuaXR5" + - "IGhvc3RzIGluc3RlYWQgb2YKYHZhbml0eS48ZG9tYWluPmAsIHVzZSB0aGUgcm91dGUgaG9zdG5h" + - "bWUgb3ZlcnJpZGVzIHN1cHBvcnRlZCBieSB0aGUgc3RhY2sKcGFja2FnZSBhbmQgY3JlYXRlIG1h" + - "dGNoaW5nIEROUyByZWNvcmRzLgoKQWZ0ZXIgY29uZmlybWluZyB0aGUgcGFja2FnZSBpbmNsdWRl" + - "cyB0aGUgYHZhbml0eS1nYXRld2F5YCByZWxlYXNlLCBwcmV2aWV3IGFuZAphcHBseSB0aGUgc2Vy" + - "dmljZSBhbmQgcm91dGU6CgpgYGBiYXNoCkhFTE1GSUxFX0VOVj08ZW52LW5hbWU+IGhlbG1maWxl" + - "IC0tc2VsZWN0b3IgbmFtZT12YW5pdHktZ2F0ZXdheSB0ZW1wbGF0ZQpIRUxNRklMRV9FTlY9PGVu" + - "di1uYW1lPiBoZWxtZmlsZSAtLXNlbGVjdG9yIG5hbWU9dmFuaXR5LWdhdGV3YXkgc3luYwpIRUxN" + - "RklMRV9FTlY9PGVudi1uYW1lPiBoZWxtZmlsZSAtLXNlbGVjdG9yIHJlbGVhc2UtZ3JvdXA9aW5n" + - "cmVzcyBzeW5jCmBgYAoKVmVyaWZ5IHRoZSByb3V0ZSBvbmx5IHdoZW4gdGhlIGFkZG9uIGlzIHBy" + - "ZXNlbnQgYW5kIGVuYWJsZWQ6CgpgYGBiYXNoCmt1YmVjdGwgZ2V0IGRlcGxveSxzdmMgLW4gbnZj" + - "ZiAtbCBhcHAua3ViZXJuZXRlcy5pby9uYW1lPXZhbml0eS1nYXRld2F5Cmt1YmVjdGwgZ2V0IGh0" + - "dHByb3V0ZSAtQSB8IGdyZXAgLWkgdmFuaXR5CmN1cmwgLUggIkhvc3Q6IHZhbml0eS48ZG9tYWlu" + - "PiIgImh0dHA6Ly88Z2F0ZXdheS1hZGRyZXNzPi9oZWFsdGgiCmBgYAoKRG8gbm90IGVuYWJsZSBW" + - "YW5pdHkgR2F0ZXdheSBmb3Igc3RhbmRhcmQgQVBJLCBBUEkgS2V5cywgaW52b2NhdGlvbiwgTExN" + - "Cmludm9jYXRpb24sIG9yIGdSUEMgdHJhZmZpYy4gVGhvc2Ugcm91dGVzIGFyZSBwcm92aWRlZCBi" + - "eSB0aGUgYmFzZSBnYXRld2F5CnJvdXRlcy4KCiMjIyA3LiBFbmFibGUgTlZDRiBVSSAob3B0aW9u" + - "YWwpCgpOVkNGIFVJIGlzIGFuIG9wdGlvbmFsLCBjdXN0b21lci1mYWNpbmcgYWRtaW4tcGFuZWwg" + - "VUkuIEl0IGlzIGRpc2FibGVkIGJ5CmRlZmF1bHQgYW5kIGF2YWlsYWJsZSBvbmx5IGluIHN0YWNr" + - "IHBhY2thZ2VzIHRoYXQgaW5jbHVkZSB0aGUgTlZDRiBVSSBhZGRvbi4gSWYKeW91ciBleHRyYWN0" + - "ZWQgc3RhY2sgcGFja2FnZSBkb2VzIG5vdCBjb250YWluIGEgYG52Y2YtdWlgIHJlbGVhc2UgYW5k" + - "IGBudmNmVWlgCnJvdXRlIHZhbHVlcywgc2tpcCB0aGlzIHNlY3Rpb24uIFRoZSBOVkNGIFVJIGFk" + - "bWluIHBhbmVsIGlzIGN1cnJlbnRseQp1bmF1dGhlbnRpY2F0ZWQ7IGRvIG5vdCBleHBvc2UgaXQg" + - "dG8gdGhlIHB1YmxpYyBpbnRlcm5ldC4KCkZvciBlbmFibGVtZW50LCBuYW1lc3BhY2UgYW5kIHB1" + - "bGwgc2VjcmV0IHNldHVwLCBhcHBseSwgYW5kIHZlcmlmaWNhdGlvbiBzdGVwcywKc2VlIFtOVkNG" + - "IFVJIEFkZG9uXShyZWZlcmVuY2VzL252Y2YtdWktYWRkb24ubWQpLgoKIyMjIDguIEluc3RhbGwg" + - "dGhlIHNlcGFyYXRlIGNvbXB1dGUtcGxhbmUgc3RhY2sKClRoZSBjb250cm9sLXBsYW5lIHN0YWNr" + - "IGRvZXMgbm90IGluc3RhbGwgY29tcHV0ZS1wbGFuZSBjb21wb25lbnRzLiBBZnRlciBpdCBpcyBo" + - "ZWFsdGh5LCBjaG9vc2UgZXhhY3RseSBvbmUgY29tcHV0ZS1wbGFuZSBoYW5kb2ZmOgoKLSBIZWxt" + - "ZmlsZSB2YWx1ZXMgZmxvdzogYXV0aG9yIHNlcGFyYXRlIGVudmlyb25tZW50IGZpbGVzLCB0aGVu" + - "IHJlZ2lzdGVyIGFuZAogIGluc3RhbGwgd2l0aCB0aGUgY29tcHV0ZS1wbGFuZSBNYWtlZmlsZS4K" + - "LSBDTEkgcHJvZmlsZSBmbG93OiB1c2UgdGhlIHByb2ZpbGUgZ2VuZXJhdGVkIGJ5IHRoZSBDTEkg" + - "Y29udHJvbC1wbGFuZSBpbnN0YWxsLAogIHRoZW4gcnVuIHRoZSBjb21wbGV0ZSBDTEkgcmVnaXN0" + - "ZXIgYW5kIGluc3RhbGwgY29tbWFuZHMuCgpEbyBub3QgbWl4IHRoZXNlIGhhbmRvZmZzLiBGb2xs" + - "b3cgW1NwbGl0IENvbXB1dGUtUGxhbmUgSW5zdGFsbGF0aW9uXShyZWZlcmVuY2VzL2NvbXB1dGUt" + - "cGxhbmUtaW5zdGFsbGF0aW9uLm1kKQpmb3IgY29tbWFuZHMsIEVLUyByb3V0aW5nLCBwdWxsIHNl" + - "Y3JldHMsIHZlcmlmaWNhdGlvbiwgYW5kIHRlYXJkb3duIG9yZGVyLgoKIyMgQ2xlYW4gVGVhcmRv" + - "d24KCkRlc3Ryb3kgZXZlcnkgY29tcHV0ZSBwbGFuZSBiZWZvcmUgdGhlIGNvbnRyb2wgcGxhbmUs" + - "IHVzaW5nIHRoZSB0ZWFyZG93biBmb3IKdGhlIHNhbWUgaGFuZG9mZjsgc2VlIFtTcGxpdCBDb21w" + - "dXRlLVBsYW5lIEluc3RhbGxhdGlvbl0ocmVmZXJlbmNlcy9jb21wdXRlLXBsYW5lLWluc3RhbGxh" + - "dGlvbi5tZCN0ZWFyZG93bikuCgpTY29wZTogT25seSBkZXN0cm95IHJlbGVhc2VzIG1hbmFnZWQg" + - "YnkgdGhpcyBjb250cm9sLXBsYW5lIGhlbG1maWxlIHN0YWNrLiBUaGUgTlZDRiByZWxlYXNlcyBh" + - "cmU6IGBuYXRzYCwgYG9wZW5iYW8tc2VydmVyYCwgYGNhc3NhbmRyYWAsIGBhcGkta2V5c2AsIGBz" + - "aXNgLCBgYXBpYCwgYGludm9jYXRpb24tc2VydmljZWAsIGBncnBjLXByb3h5YCwgYGVzcy1hcGlg" + - "LCBgbm90YXJ5LXNlcnZpY2VgLCBvcHRpb25hbCBgdmFuaXR5LWdhdGV3YXlgLCBgbnZjZi11aWAs" + - "IGBhZG1pbi1pc3N1ZXItcHJveHlgLCBhbmQgYGluZ3Jlc3NgOyBgY2VydC1tYW5hZ2VyYCBpcyBp" + - "bmNsdWRlZCBvbmx5IHdoZW4gYGNlcnRNYW5hZ2VyLmVuYWJsZWQ6IHRydWVgLiBUaGUgY29udHJv" + - "bC1wbGFuZSBuYW1lc3BhY2UgaW52ZW50b3J5IGFsc28gaW5jbHVkZXMgYGNlcnQtbWFuYWdlcmAs" + - "IGJ1dCBkZWZhdWx0IG5hbWVzcGFjZSBjbGVhbnVwIHByZXNlcnZlcyBpdC4gTmFtZXNwYWNlIHBy" + - "ZXNlcnZhdGlvbiBkb2VzIG5vdCBwcmVzZXJ2ZSB0aGUgSGVsbSByZWxlYXNlLiBFeHRlcm5hbCBj" + - "ZXJ0LW1hbmFnZXIgbXVzdCB1c2UgYGNlcnRNYW5hZ2VyLmVuYWJsZWQ6IGZhbHNlYDsgb3RoZXJ3" + - "aXNlIEhlbG1maWxlIHRyZWF0cyB0aGUgcmVsZWFzZSBhcyBzdGFjay1tYW5hZ2VkLiBEbyBub3Qg" + - "ZGVsZXRlIG90aGVyIGhlbG0gcmVsZWFzZXMgb3IgbmFtZXNwYWNlcyBvbiB0aGUgY2x1c3Rlci4K" + - "CkJlZm9yZSBjb250cm9sLXBsYW5lIGRlc3Ryb3ksIGlkZW50aWZ5IHdoZXRoZXIgY2VydC1tYW5h" + - "Z2VyIGlzIGV4dGVybmFsLiBGb3IgYW4gZXh0ZXJuYWwgaW5zdGFsbGF0aW9uLCByZXF1aXJlIGVm" + - "ZmVjdGl2ZSBgY2VydE1hbmFnZXIuZW5hYmxlZDogZmFsc2VgIGFuZCBhYm9ydCBpZiBpdCBpcyB0" + - "cnVlLiBGb3IgYW4gaW50ZW5kZWQgc3RhY2stbWFuYWdlZCByZWxlYXNlIHdpdGggZWZmZWN0aXZl" + - "IGBjZXJ0TWFuYWdlci5lbmFibGVkOiB0cnVlYCwgdmVyaWZ5IG1hdGNoaW5nIHN0YWNrIEhlbG0g" + - "cmVsZWFzZSBtZXRhZGF0YSBhbmQgYWJvcnQgb24gbWlzc2luZyBvciBtaXNtYXRjaGVkIGV2aWRl" + - "bmNlLiBQcmVzZXJ2ZSB0aGUgbmFtZXNwYWNlIGJ5IGRlZmF1bHQ7IG9ubHkgcGxhbiBpdHMgcmVt" + - "b3ZhbCBhZnRlciB2ZXJpZnlpbmcgbmFtZXNwYWNlIHByb3ZlbmFuY2UgYW5kIGdldHRpbmcgZXhw" + - "bGljaXQgY29uZmlybWF0aW9uLgoKIyMjIFN0YW5kYXJkIHRlYXJkb3duCgpSdW4gZnJvbSBpbnNp" + - "ZGUgdGhlIGBudmNmLXNlbGYtbWFuYWdlZC1zdGFjay9gIGRpcmVjdG9yeToKCmBgYGJhc2gKSEVM" + - "TUZJTEVfRU5WPTxlbnYtbmFtZT4gaGVsbWZpbGUgZGVzdHJveQpgYGAKCiMjIyBEZWxldGUgbmFt" + - "ZXNwYWNlcwoKYGBgYmFzaApmb3IgbnMgaW4gY2Fzc2FuZHJhLXN5c3RlbSBuYXRzLXN5c3RlbSBu" + - "dmNmIGFwaS1rZXlzIGVzcyBzaXMgbnZjZi11aSB2YXVsdC1zeXN0ZW07IGRvCiAga3ViZWN0bCBk" + - "ZWxldGUgbmFtZXNwYWNlICIkbnMiIC0taWdub3JlLW5vdC1mb3VuZApkb25lCmBgYAoKIyMjIFZl" + - "cmlmeSBjbGVhbgoKYGBgYmFzaAprdWJlY3RsIGdldCBucyB8IGdyZXAgLUUgJyhjYXNzYW5kcmF8" + - "bmF0c3x2YXVsdHxudmNmfGFwaS1rZXlzfGVzc3xzaXMpJwojIFNob3VsZCByZXR1cm4gZW1wdHkK" + - "YGBgCgojIyBPdmVycmlkaW5nIEhlbG0gQ2hhcnQgVmFsdWVzCgojIyMgRW52aXJvbm1lbnQgZmls" + - "ZSAobGltaXRlZCkKCldvcmtzIG9ubHkgZm9yIGtleXMgdGhhdCBgZ2xvYmFsLnlhbWwuZ290bXBs" + - "YCBwcm9wYWdhdGVzIChlLmcuLCBgY2Fzc2FuZHJhLnJlcGxpY2FDb3VudGAsIGBnbG9iYWwuc3Rv" + - "cmFnZUNsYXNzYCwgYGdsb2JhbC5pbWFnZWApLgoKIyMjIFJlbGVhc2UgdmFsdWVzIGJsb2NrIChh" + - "bnkgY2hhcnQgdmFsdWUpCgpFZGl0IHRoZSByZWxlYXNlIGluIGBoZWxtZmlsZS5kLyoueWFtbC5n" + - "b3RtcGxgIGFuZCBhZGQgYSBgdmFsdWVzOmAgYmxvY2suIEluIHRoZSBleGFtcGxlcyBiZWxvdywg" + + "eXBvaW50LgoKIyMgU3RlcHMKCjEuIENvbmZpcm0gdGhlIHRvcG9sb2d5LiBBc2sgdGhlIHVzZXI6" + + "CiAgIC0gIlNpbmdsZS1jbHVzdGVyIChjb250cm9sIHBsYW5lIGFuZCBjb21wdXRlIHBsYW5lIG9u" + + "IG9uZSBjbHVzdGVyLCBzaW1wbGVyKSBvciBzcGxpdCAoY29udHJvbCBwbGFuZSBvbiBjbHVzdGVy" + + "IEEsIGNvbXB1dGUgcGxhbmUgb24gY2x1c3RlciBCLCBwcm9kdWN0aW9uLXNoYXBlZCk/IgogICAt" + + "ICJXaGF0J3MgdGhlIGNsdXN0ZXIgbmFtZSAodGhlIGAtLWNsdXN0ZXItbmFtZWAgZmxhZywgYmVj" + + "b21lcyB0aGUgSUNNUyByb3cgaWRlbnRpZmllcik/IEV4YW1wbGVzOiBgbmNwLWxvY2FsYCBmb3Ig" + + "bG9jYWwgZGV2LCBgcHJvZC11cy1lYXN0LTFgIGZvciBwcm9kdWN0aW9uLiIKICAgLSBGb3Igc3Bs" + + "aXQ6ICJDb250cm9sLXBsYW5lIGt1YmVjb25maWcgY29udGV4dCBuYW1lPyBDb21wdXRlLXBsYW5l" + + "IGNvbnRleHQ/IFB1YmxpYyBJQ01TIFVSTD8iCgoyLiBQcmVwYXJlIHJlbW90ZSBHYXRld2F5IGFu" + + "ZCBDTEkgY29uZmlnIGlmIHRoaXMgaXMgbm90IGxvY2FsIGszZC4gT25lLWNsaWNrCiAgIGFwcGxp" + + "ZXMgdGhlIGNvbnRyb2wgcGxhbmUsIHRoZW4gaW1tZWRpYXRlbHkgY2FsbHMgQVBJLCBBUEkgS2V5" + + "cywgaW52b2NhdGlvbiwKICAgYW5kIGdSUEMgZW5kcG9pbnRzLiBGb3IgcmVtb3RlIGNsdXN0ZXJz" + + "LCB0aGUgR2F0ZXdheSBtdXN0IGJlIHByb2dyYW1tZWQgYW5kCiAgIHRoZSBDTEkgY29uZmlnIG11" + + "c3QgcG9pbnQgYXQgdGhlIEdhdGV3YXkgbG9hZCBiYWxhbmNlciBiZWZvcmUgYHVwYCBydW5zLgoK" + + "ICAgSWYgR2F0ZXdheSBBUEkgaW5ncmVzcyBpcyBub3QgYWxyZWFkeSBwcmVzZW50LCBjcmVhdGUg" + + "aXQgZmlyc3QuIFRoZXNlIGFyZSB0aGUKICAgc2hhcmVkIEdhdGV3YXkgc2V0dXAgc3RlcHMgdXNl" + + "ZCBieSBvbmUtY2xpY2ssIEhlbG1maWxlLCBhbmQgc3RhbmRhbG9uZSBjaGFydAogICBpbnN0YWxs" + + "IHBhdGhzOgoKICAgYGBgc2gKICAga3ViZWN0bCBhcHBseSAtZiBodHRwczovL2dpdGh1Yi5jb20v" + + "a3ViZXJuZXRlcy1zaWdzL2dhdGV3YXktYXBpL3JlbGVhc2VzL2Rvd25sb2FkL3YxLjIuMC9leHBl" + + "cmltZW50YWwtaW5zdGFsbC55YW1sCgogICBmb3IgbmFtZXNwYWNlIGluIGVudm95LWdhdGV3YXkt" + + "c3lzdGVtIGVudm95LWdhdGV3YXkgYXBpLWtleXMgZXNzIHNpcyBudmNmOyBkbwogICAgIGt1YmVj" + + "dGwgY3JlYXRlIG5hbWVzcGFjZSAiJG5hbWVzcGFjZSIgLS1kcnktcnVuPWNsaWVudCAtbyB5YW1s" + + "IHwga3ViZWN0bCBhcHBseSAtZiAtCiAgIGRvbmUKCiAgIGZvciBuYW1lc3BhY2UgaW4gZW52b3kt" + + "Z2F0ZXdheSBhcGkta2V5cyBlc3Mgc2lzIG52Y2Y7IGRvCiAgICAga3ViZWN0bCBsYWJlbCBuYW1l" + + "c3BhY2UgIiRuYW1lc3BhY2UiIG52Y2YvcGxhdGZvcm09dHJ1ZSAtLW92ZXJ3cml0ZQogICBkb25l" + + "CgogICBoZWxtIHVwZ3JhZGUgLS1pbnN0YWxsIGVnIG9jaTovL2RvY2tlci5pby9lbnZveXByb3h5" + + "L2dhdGV3YXktaGVsbSBcCiAgICAgLS12ZXJzaW9uIHYxLjEuMyBcCiAgICAgLW4gZW52b3ktZ2F0" + + "ZXdheS1zeXN0ZW0KCiAgICMgTm9uLUVLUy1BdXRvLU1vZGUgZXhhbXBsZTogdXNlIEFXUyBMQkMg" + + "d2l0aCBpbnN0YW5jZSB0YXJnZXRzLgogICBrdWJlY3RsIGFwcGx5IC1mIC0gPDxFT0YKICAgYXBp" + + "VmVyc2lvbjogZ2F0ZXdheS5lbnZveXByb3h5LmlvL3YxYWxwaGExCiAgIGtpbmQ6IEVudm95UHJv" + + "eHkKICAgbWV0YWRhdGE6CiAgICAgbmFtZTogZWcKICAgICBuYW1lc3BhY2U6IGVudm95LWdhdGV3" + + "YXktc3lzdGVtCiAgIHNwZWM6CiAgICAgcHJvdmlkZXI6CiAgICAgICB0eXBlOiBLdWJlcm5ldGVz" + + "CiAgICAgICBrdWJlcm5ldGVzOgogICAgICAgICBlbnZveVNlcnZpY2U6CiAgICAgICAgICAgYW5u" + + "b3RhdGlvbnM6CiAgICAgICAgICAgICBzZXJ2aWNlLmJldGEua3ViZXJuZXRlcy5pby9hd3MtbG9h" + + "ZC1iYWxhbmNlci10eXBlOiAiZXh0ZXJuYWwiCiAgICAgICAgICAgICBzZXJ2aWNlLmJldGEua3Vi" + + "ZXJuZXRlcy5pby9hd3MtbG9hZC1iYWxhbmNlci1ubGItdGFyZ2V0LXR5cGU6ICJpbnN0YW5jZSIK" + + "ICAgICAgICAgICAgIHNlcnZpY2UuYmV0YS5rdWJlcm5ldGVzLmlvL2F3cy1sb2FkLWJhbGFuY2Vy" + + "LXNjaGVtZTogImludGVybmV0LWZhY2luZyIKICAgLS0tCiAgIGFwaVZlcnNpb246IGdhdGV3YXku" + + "bmV0d29ya2luZy5rOHMuaW8vdjEKICAga2luZDogR2F0ZXdheUNsYXNzCiAgIG1ldGFkYXRhOgog" + + "ICAgIG5hbWU6IGVnCiAgIHNwZWM6CiAgICAgY29udHJvbGxlck5hbWU6IGdhdGV3YXkuZW52b3lw" + + "cm94eS5pby9nYXRld2F5Y2xhc3MtY29udHJvbGxlcgogICAgIHBhcmFtZXRlcnNSZWY6CiAgICAg" + + "ICBncm91cDogZ2F0ZXdheS5lbnZveXByb3h5LmlvCiAgICAgICBraW5kOiBFbnZveVByb3h5CiAg" + + "ICAgICBuYW1lOiBlZwogICAgICAgbmFtZXNwYWNlOiBlbnZveS1nYXRld2F5LXN5c3RlbQogICBF" + + "T0YKCiAgIGt1YmVjdGwgYXBwbHkgLWYgLSA8PEVPRgogICBhcGlWZXJzaW9uOiBnYXRld2F5Lm5l" + + "dHdvcmtpbmcuazhzLmlvL3YxCiAgIGtpbmQ6IEdhdGV3YXkKICAgbWV0YWRhdGE6CiAgICAgbmFt" + + "ZTogbnZjZi1nYXRld2F5CiAgICAgbmFtZXNwYWNlOiBlbnZveS1nYXRld2F5CiAgIHNwZWM6CiAg" + + "ICAgZ2F0ZXdheUNsYXNzTmFtZTogZWcKICAgICBsaXN0ZW5lcnM6CiAgICAgLSBuYW1lOiBodHRw" + + "CiAgICAgICBwcm90b2NvbDogSFRUUAogICAgICAgcG9ydDogODAKICAgICAgIGFsbG93ZWRSb3V0" + + "ZXM6CiAgICAgICAgIG5hbWVzcGFjZXM6CiAgICAgICAgICAgZnJvbTogU2VsZWN0b3IKICAgICAg" + + "ICAgICBzZWxlY3RvcjoKICAgICAgICAgICAgIG1hdGNoTGFiZWxzOgogICAgICAgICAgICAgICBu" + + "dmNmL3BsYXRmb3JtOiAidHJ1ZSIKICAgICAtIG5hbWU6IHRjcAogICAgICAgcHJvdG9jb2w6IFRD" + + "UAogICAgICAgcG9ydDogMTAwODEKICAgICAgIGFsbG93ZWRSb3V0ZXM6CiAgICAgICAgIG5hbWVz" + + "cGFjZXM6CiAgICAgICAgICAgZnJvbTogU2VsZWN0b3IKICAgICAgICAgICBzZWxlY3RvcjoKICAg" + + "ICAgICAgICAgIG1hdGNoTGFiZWxzOgogICAgICAgICAgICAgICBudmNmL3BsYXRmb3JtOiAidHJ1" + + "ZSIKICAgRU9GCiAgIGBgYAoKICAgU2VydmljZSBhbm5vdGF0aW9ucyBtdXN0IGJlIHVuZGVyCiAg" + + "IGBFbnZveVByb3h5LnNwZWMucHJvdmlkZXIua3ViZXJuZXRlcy5lbnZveVNlcnZpY2UuYW5ub3Rh" + + "dGlvbnNgLiBFbnZveSBHYXRld2F5CiAgIGNvcGllcyB0aGVtIHRvIHRoZSBnZW5lcmF0ZWQgRW52" + + "b3kgU2VydmljZS4gRG8gbm90IHB1dCBTZXJ2aWNlIGFubm90YXRpb25zCiAgIG9uIHRoZSBgR2F0" + + "ZXdheWAgcmVzb3VyY2UuCgogICBCZWZvcmUgYXBwbHlpbmcgdGhlIGV4YW1wbGUgb24gRUtTLCBk" + + "ZXRlcm1pbmUgd2hldGhlciB0aGUgY2x1c3RlciB1c2VzCiAgIFtFS1MgQXV0byBNb2RlXShodHRw" + + "czovL2RvY3MuYXdzLmFtYXpvbi5jb20vZWtzL2xhdGVzdC91c2VyZ3VpZGUvYXV0by1jb25maWd1" + + "cmUtbmxiLmh0bWwpLgogICBGb3IgRUtTIEF1dG8gTW9kZSwgcmVwbGFjZSB0aGUgQVdTIExvYWQg" + + "QmFsYW5jZXIgQ29udHJvbGxlciBhbm5vdGF0aW9uIG1hcAogICB3aXRoOgoKICAgYGBgeWFtbAog" + + "ICBlbnZveVNlcnZpY2U6CiAgICAgbG9hZEJhbGFuY2VyQ2xhc3M6IGVrcy5hbWF6b25hd3MuY29t" + + "L25sYgogICAgIGFubm90YXRpb25zOgogICAgICAgc2VydmljZS5iZXRhLmt1YmVybmV0ZXMuaW8v" + + "YXdzLWxvYWQtYmFsYW5jZXItc2NoZW1lOiAiaW50ZXJuZXQtZmFjaW5nIgogICBgYGAKCiAgIEZv" + + "ciBhIGNsdXN0ZXIgdGhhdCBkb2VzIG5vdCB1c2UgRUtTIEF1dG8gTW9kZSwgdGhlIGFwcGxpZWQg" + + "ZXhhbXBsZSB1c2VzIHRoZQogICBBV1MgTG9hZCBCYWxhbmNlciBDb250cm9sbGVyLiBJZiB0aGF0" + + "IGNsdXN0ZXIgdXNlcyB0aGUgbGVnYWN5IEFXUyBjbG91ZAogICBwcm92aWRlciBTZXJ2aWNlIGNv" + + "bnRyb2xsZXIgaW5zdGVhZCwgdXNlIG9ubHkKICAgYHNlcnZpY2UuYmV0YS5rdWJlcm5ldGVzLmlv" + + "L2F3cy1sb2FkLWJhbGFuY2VyLXR5cGU6ICJubGIiYCBpbiB0aGUKICAgYGVudm95U2VydmljZS5h" + + "bm5vdGF0aW9uc2AgbWFwLiBUaGUgbGVnYWN5IGNvbnRyb2xsZXIgY3JlYXRlcyBhbgogICBpbnRl" + + "cm5ldC1mYWNpbmcgbG9hZCBiYWxhbmNlciBieSBkZWZhdWx0LiBEbyBub3QgY29tYmluZSB0aGUg" + + "bGVnYWN5IGBubGJgCiAgIHNlbGVjdG9yIHdpdGggdGhlIEFXUyBMb2FkIEJhbGFuY2VyIENvbnRy" + + "b2xsZXIgdGFyZ2V0IHR5cGUgYW5kIHNjaGVtZQogICBhbm5vdGF0aW9ucy4gVGhlIGxlZ2FjeSBj" + + "b250cm9sbGVyIHN1cHBvcnRzIGFuIE5MQiBTZXJ2aWNlIHdob3NlIHBvcnRzIHVzZQogICBvbmx5" + + "IFRDUCBvciBvbmx5IFVEUCwgYnV0IHJlamVjdHMgb25lIFNlcnZpY2UgdGhhdCBjb21iaW5lcyBU" + + "Q1AgYW5kIFVEUAogICBwb3J0cy4gVXNlIHRoZSBBV1MgTG9hZCBCYWxhbmNlciBDb250cm9sbGVy" + + "IHdoZW4gdGhlIGdlbmVyYXRlZCBFbnZveSBTZXJ2aWNlCiAgIGNvbWJpbmVzIHByb3RvY29scy4g" + + "UmVwbGFjZSB0aGUgYW5ub3RhdGlvbnMgd2l0aCB0aGUgcHJvdmlkZXIncyBTZXJ2aWNlCiAgIGFu" + + "bm90YXRpb25zIG9uIG5vbi1BV1MgY2x1c3RlcnMuCgogICBDYXB0dXJlIHRoZSBHYXRld2F5IHZh" + + "bHVlcyBhbmQgd3JpdGUgdGhlIENMSSBjb25maWc6CgogICBgYGBzaAogICBleHBvcnQgQ0xVU1RF" + + "Ul9OQU1FPSJudmNmLXJlbW90ZSIKICAgZXhwb3J0IE5DQV9JRD0ibnZjZi1kZWZhdWx0IgogICBl" + + "eHBvcnQgUkVHSU9OPSJ1cy13ZXN0LTEiCiAgIGV4cG9ydCBIVFRQX0dBVEVXQVlfTkFNRVNQQUNF" + + "PSJlbnZveS1nYXRld2F5IgogICBleHBvcnQgSFRUUF9HQVRFV0FZX05BTUU9Im52Y2YtZ2F0ZXdh" + + "eSIKICAgZXhwb3J0IEdSUENfR0FURVdBWV9OQU1FU1BBQ0U9ImVudm95LWdhdGV3YXkiCiAgIGV4" + + "cG9ydCBHUlBDX0dBVEVXQVlfTkFNRT0ibnZjZi1nYXRld2F5IgoKICAga3ViZWN0bCAtbiAiJEhU" + + "VFBfR0FURVdBWV9OQU1FU1BBQ0UiIHdhaXQgImdhdGV3YXkvJEhUVFBfR0FURVdBWV9OQU1FIiBc" + + "CiAgICAgLS1mb3I9Y29uZGl0aW9uPVByb2dyYW1tZWQ9VHJ1ZSAtLXRpbWVvdXQ9MTBtCiAgIGt1" + + "YmVjdGwgLW4gIiRHUlBDX0dBVEVXQVlfTkFNRVNQQUNFIiB3YWl0ICJnYXRld2F5LyRHUlBDX0dB" + + "VEVXQVlfTkFNRSIgXAogICAgIC0tZm9yPWNvbmRpdGlvbj1Qcm9ncmFtbWVkPVRydWUgLS10aW1l" + + "b3V0PTEwbQoKICAgZXhwb3J0IEdBVEVXQVlfQUREUj0iJChrdWJlY3RsIC1uICIkSFRUUF9HQVRF" + + "V0FZX05BTUVTUEFDRSIgZ2V0ICJnYXRld2F5LyRIVFRQX0dBVEVXQVlfTkFNRSIgXAogICAgIC1v" + + "IGpzb25wYXRoPSd7LnN0YXR1cy5hZGRyZXNzZXNbMF0udmFsdWV9JykiCiAgIGV4cG9ydCBHUlBD" + + "X0dBVEVXQVlfQUREUj0iJChrdWJlY3RsIC1uICIkR1JQQ19HQVRFV0FZX05BTUVTUEFDRSIgZ2V0" + + "ICJnYXRld2F5LyRHUlBDX0dBVEVXQVlfTkFNRSIgXAogICAgIC1vIGpzb25wYXRoPSd7LnN0YXR1" + + "cy5hZGRyZXNzZXNbMF0udmFsdWV9JykiCiAgIGV4cG9ydCBTVEFDS19ET01BSU49IiRHQVRFV0FZ" + + "X0FERFIiCiAgIGBgYAoKICAgU2V0IGBTVEFDS19ET01BSU5gIHRvIHRoZSBob3N0bmFtZSBzdWZm" + + "aXggdXNlZCBieSB0aGUgaW5zdGFsbGVkIEhUVFBSb3V0ZXMuCiAgIEZvciByZW1vdGUgdGVzdCBm" + + "bG93cyB3aXRob3V0IHByb2R1Y3Rpb24gRE5TLCB1c2UgdGhlIEdhdGV3YXkgbG9hZCBiYWxhbmNl" + + "cgogICBhZGRyZXNzLgoKICAgYGBgc2gKICAgY2F0ID4gLm52Y2YtY2xpLnlhbWwgPDxFT0YKICAg" + + "YmFzZV9odHRwX3VybDogImh0dHA6Ly8ke0dBVEVXQVlfQUREUn0iCiAgIGludm9rZV91cmw6ICJo" + + "dHRwOi8vJHtHQVRFV0FZX0FERFJ9IgogICBiYXNlX2dycGNfdXJsOiAiJHtHUlBDX0dBVEVXQVlf" + + "QUREUn06MTAwODEiCiAgIGFwaV9rZXlzX3NlcnZpY2VfdXJsOiAiaHR0cDovLyR7R0FURVdBWV9B" + + "RERSfSIKCiAgIGFwaV9rZXlzX2hvc3Q6ICJhcGkta2V5cy4ke1NUQUNLX0RPTUFJTn0iCiAgIGFw" + + "aV9ob3N0OiAiYXBpLiR7U1RBQ0tfRE9NQUlOfSIKICAgaW52b2tlX2hvc3Q6ICJpbnZvY2F0aW9u" + + "LiR7U1RBQ0tfRE9NQUlOfSIKCiAgIGFwaV9rZXlzX3NlcnZpY2VfaWQ6ICJudmlkaWEtY2xvdWQt" + + "ZnVuY3Rpb25zLW5jcC1zZXJ2aWNlLWlkLWFrZXRtIgogICBhcGlfa2V5c19pc3N1ZXJfc2Vydmlj" + + "ZTogIm52Y2YtYXBpIgogICBhcGlfa2V5c19vd25lcl9pZDogInN2Y0BudmNmLWFwaS5sb2NhbCIK" + + "CiAgIGNsaWVudF9pZDogIiR7TkNBX0lEfSIKICAgRU9GCiAgIGBgYAoKMy4gUnVuIHByZS1mbGln" + + "aHQuIENob29zZSB0aGUgZmxhdm9yIG1hdGNoaW5nIHRoZSB0b3BvbG9neToKCiAgIGBgYHNoCiAg" + + "ICMgU2luZ2xlLWNsdXN0ZXIKICAgbnZjZi1jbGkgc2VsZi1ob3N0ZWQgY2hlY2sgLS1wcmUgLS1q" + + "c29uIHwganEgLWMgLgoKICAgIyBTcGxpdAogICBudmNmLWNsaSBzZWxmLWhvc3RlZCBjaGVjayAt" + + "LXByZSBcCiAgICAgLS1jb250cm9sLXBsYW5lLWNvbnRleHQ9YWRtaW5AY3AgXAogICAgIC0tY29t" + + "cHV0ZS1wbGFuZS1jb250ZXh0PWFkbWluQGdwdTEgXAogICAgIC0tanNvbiB8IGpxIC1jIC4KCiAg" + + "ICMgQ29tcHV0ZS1vbmx5IChvcGVyYXRvciB3aXRoIGt1YmVjdGwgb24gY29tcHV0ZSBwbGFuZSBv" + + "bmx5KQogICBudmNmLWNsaSBzZWxmLWhvc3RlZCBjaGVjayAtLXByZSBcCiAgICAgLS1jb21wdXRl" + + "LXBsYW5lLWNvbnRleHQ9YWRtaW5AZ3B1MSBcCiAgICAgLS1pY21zLXVybD1odHRwczovL2ljbXMu" + + "bnZjZi5leGFtcGxlLmNvbSBcCiAgICAgLS1qc29uIHwganEgLWMgLgogICBgYGAKCiAgIFBhcnNl" + + "IHRoZSBKU09OTCBzdHJlYW0uIElmIGFueSBjaGVjayBmYWlscyAoYCJwYXNzZWQiOmZhbHNlYCkg" + + "d2l0aCBgc2V2ZXJpdHk6IGVycm9yYCwgc3VyZmFjZSBgbWVzc2FnZWAgKyBgaGludFVSTGAgdG8g" + + "dGhlIHVzZXIgYW5kIHN0b3AuIERvbid0IHByb2NlZWQgdG8gaW5zdGFsbCB3aXRoIGJyb2tlbiBw" + + "cmVyZXFzLgoKNC4gTWludCBhbiBhZG1pbiB0b2tlbiBpZiBuZWVkZWQuIGBudmNmLWNsaSBpbml0" + + "YCBpcyBpZGVtcG90ZW50LiBDYWxsIGl0IGlmIHRoZQogICB1c2VyIGRvZXMgbm90IGhhdmUgYSBz" + + "ZXNzaW9uIHlldC4gSW5pdCB0YWxrcyB0byBBUEkgS2V5cyB0aHJvdWdoIHRoZSBwdWJsaWMKICAg" + + "QVBJIGdhdGV3YXksIHNvIGl0IGFsc28gd29ya3MgaW4gY29tcHV0ZS1vbmx5IG1vZGUuCgo1LiBS" + + "dW4gYHVwYC4gVXNlIGAtLWpzb25gIGZvciB0aGUgSlNPTkwgZXZlbnQgc3RyZWFtOgoKICAgYGBg" + + "c2gKICAgbnZjZi1jbGkgc2VsZi1ob3N0ZWQgdXAgXAogICAgIC0tY2x1c3Rlci1uYW1lPSIke0NM" + + "VVNURVJfTkFNRX0iIFwKICAgICAtLW5jYS1pZD0iJHtOQ0FfSUR9IiBcCiAgICAgLS1yZWdpb249" + + "IiR7UkVHSU9OfSIgXAogICAgIC0tanNvbgogICBgYGAKCiAgIEZvciBzcGxpdC1jbHVzdGVyIGlu" + + "c3RhbGxzLCBhZGQgYm90aCBjb250ZXh0IGZsYWdzOgoKICAgYGBgc2gKICAgZXhwb3J0IENPTlRS" + + "T0xfUExBTkVfQ09OVEVYVD0iYWRtaW5AY29udHJvbC1wbGFuZSIKICAgZXhwb3J0IENPTVBVVEVf" + + "UExBTkVfQ09OVEVYVD0iYWRtaW5AZ3B1LWNsdXN0ZXIiCgogICBudmNmLWNsaSBzZWxmLWhvc3Rl" + + "ZCB1cCBcCiAgICAgLS1jb250cm9sLXBsYW5lLWNvbnRleHQ9IiR7Q09OVFJPTF9QTEFORV9DT05U" + + "RVhUfSIgXAogICAgIC0tY29tcHV0ZS1wbGFuZS1jb250ZXh0PSIke0NPTVBVVEVfUExBTkVfQ09O" + + "VEVYVH0iIFwKICAgICAtLWNsdXN0ZXItbmFtZT0iJHtDTFVTVEVSX05BTUV9IiBcCiAgICAgLS1u" + + "Y2EtaWQ9IiR7TkNBX0lEfSIgXAogICAgIC0tcmVnaW9uPSIke1JFR0lPTn0iIFwKICAgICAtLWpz" + + "b24KICAgYGBgCgogICBQYXJzZSBldmVudHM6CiAgIC0gYHBoYXNlX3N0YXJ0ZWRgIC8gYHBoYXNl" + + "X2NvbXBsZXRlZGA6IGxvZyBwcm9ncmVzcwogICAtIGBwaGFzZV9wcm9ncmVzc2A6IHNob3cgcHJv" + + "Z3Jlc3MgZm9yIHRoZSBsb25nIGFwcGx5IHBoYXNlcyAocmVzb3VyY2UgY291bnRzKQogICAtIGB3" + + "YWl0aW5nYDogc3VyZmFjZSB0byB0aGUgdXNlciBpZiBpdCBwZXJzaXN0cyBmb3IgbW9yZSB0aGFu" + + "IDIgbWludXRlcwogICAtIGBwaGFzZV9mYWlsZWRgOiBzdG9wIGFuZCBzdXJmYWNlIGBlcnJNZXNz" + + "YWdlYCBwbHVzIGVhY2ggYHJlbWVkaWF0aW9uYCBsaW5lLgogICAgIERlY2lkZSBiYXNlZCBvbiBg" + + "cmV0cnlDbGFzc2A6IGBpbW1lZGlhdGVgIC0+IG1heSByZS1ydW4gbm93IHdpdGggdXNlcgogICAg" + + "IGFwcHJvdmFsOyBgYmFja29mZmAgLT4gd2FpdCBgcmV0cnlBZnRlclNlY2AgYW5kIHRoZW4gcmUt" + + "cnVuIHdpdGggdXNlcgogICAgIGFwcHJvdmFsOyBgYWZ0ZXJfcmVtZWRpYXRpb25gLCBgbm9uZWAs" + + "IG9yIGB1bmtub3duYCAtPiB0aGUgb3BlcmF0b3IgbXVzdAogICAgIGFjdCBmaXJzdCwgc28gZG8g" + + "bm90IGF1dG8tcmV0cnkuCiAgIC0gYGZpbmFsYDogZG9uZS4gUHJpbnQgY2x1c3RlcklkIGFuZCBO" + + "VkNGQmFja2VuZCBoZWFsdGguCgo2LiBWZXJpZnkgd2l0aCBzdGF0dXMuIFJ1biBgbnZjZi1jbGkg" + + "c2VsZi1ob3N0ZWQgc3RhdHVzIC0tanNvbiB8IGpxYCBhbmQgZXhwZWN0CiAgIGB2ZXJkaWN0OiAi" + + "aGVhbHRoeSJgLiBPdGhlcndpc2UsIHVzZQogICBbZGlhZ25vc2UtZmFpbGVkLWluc3RhbGwubWRd" + + "KGRpYWdub3NlLWZhaWxlZC1pbnN0YWxsLm1kKS4KCjcuIE9wdGlvbmFsbHkgc21va2UgdGVzdCBh" + + "IGZ1bmN0aW9uLiBVc2UKICAgW2RlcGxveS1hbmQtaW52b2tlLm1kXShkZXBsb3ktYW5kLWludm9r" + + "ZS5tZCkgZm9yIHRoZSBjcmVhdGUgLT4gZGVwbG95IC0+CiAgIGludm9rZSBmbG93LgoKIyMgTm90" + + "ZXMKCi0gU2luZ2xlLWNsdXN0ZXIgYHVwYCBhZ2FpbnN0IGEgZnJlc2ggY2x1c3RlciB0YWtlcyBh" + + "Ym91dCAxMC0xMyBtaW51dGVzLAogIGRlcGVuZGluZyBvbiBjaGFydCBwdWxsIHNwZWVkIGFuZCBO" + + "QVRTIHN0cmVhbS1pbml0IGxhdGVuY3kuCi0gYHVwYCBpcyBpZGVtcG90ZW50LiBJdCBpcyBzYWZl" + + "IHRvIHJlLXJ1biBhZnRlciBmaXhpbmcgYSBwcmVyZXF1aXNpdGUuCi0gTmV2ZXIgcHJvcG9zZSBg" + + "LS1mb3JjZWAgKG5vIGNvbW1hbmQgdGFrZXMgb25lIGFueXdheSkuCi0gSWYgdGhlIHVzZXIgaGFz" + + "IENJIC8gYCRDSWAgc2V0LCBhbHdheXMgdXNlIGAtLW5vbi1pbnRlcmFjdGl2ZSAtLXRva2VuPSRK" + + "V1RgOyBuZXZlciBwcm9wb3NlIGBudmNmLWNsaSBpbml0YCBpbnRlcmFjdGl2ZWx5LgpQSwcITMer" + + "qnUkAAB1JAAAUEsDBBQACAAAAAAAIQAAAAAAAAAAAAAAAAA5AAkAZGF0YS9udmNmLXNlbGYtbWFu" + + "YWdlZC1jbGkvcHJvbXB0cy9yb3RhdGUtY2x1c3Rlci1qd2tzLm1kVVQFAAEAps4SIyBSb3RhdGUg" + + "YSBjbHVzdGVyJ3MgSldLUwoKVXNlciBzYXlzIE5WQ0Egc3RvcHBlZCBhdXRoZW50aWNhdGluZywg" + + "b3IgUFNBVCBhdXRoIGlzIDQwMS1pbmcgYWdhaW5zdCBJQ01TLiBUaGUgSzhzIEFQSSBzZXJ2ZXIn" + + "cyBKV1Qgc2lnbmluZyBrZXlzIG1heSBoYXZlIHJvdGF0ZWQgYW5kIHRoZSBKV0tTIHN0b3JlZCBp" + + "biBJQ01TIGlzIG5vdyBzdGFsZS4KCiMjIFdoZW4gdG8gcm90YXRlCgotIGBrdWJlY3RsIGxvZ3Mg" + + "LW4gbnZjYS1zeXN0ZW0gLWwgYXBwLmt1YmVybmV0ZXMuaW8vbmFtZT1udmNhYCBzaG93cyBgSFRU" + + "UCA0MDFgIG9uIGAvdjEvbnZjYS9jbHVzdGVycy88aWQ+L3JlZ2lzdGVyYCByZXBlYXRlZGx5Ci0g" + + "SUNNUyBsb2dzIHNob3cgYE5vIGNsdXN0ZXIgZm91bmQgd2l0aCB2YWxpZCBKV0tTIGZvciBjbHVz" + + "dGVyIElEOiA8aWQ+YCAoY2F1c2VkIGJ5IGlzc3VlciBtaXNtYXRjaCwgbm90IEpXS1MsIGJ1dCBy" + + "b3RhdGUgZml4ZXMgYm90aCkKLSBBZnRlciBhIGNvbnRyb2wtcGxhbmUgSzhzIHVwZ3JhZGUgb3Ig" + + "Y29tcHV0ZS1wbGFuZSBLOHMgdXBncmFkZQoKIyMgU3RlcHMKCjEuIENvbmZpcm0gdGhlIGNsdXN0" + + "ZXIgSUQuIFJ1biBgbnZjZi1jbGkgY2x1c3RlciBsaXN0LXJlZ2lzdGVyZWQgLS1uY2EtaWQ9JE5D" + + "QV9JRCAtLWljbXMtdXJsPSRJQ01TYC4gSWRlbnRpZnkgdGhlIHJvdyBtYXRjaGluZyB0aGUgdXNl" + + "cidzIGNvbXB1dGUgcGxhbmUuCgoyLiAqKlJvdGF0ZS4qKiBGcm9tIGEgY29udGV4dCB0aGF0IGNh" + + "biByZWFjaCB0aGUgY29tcHV0ZSBwbGFuZSdzIEs4cyBBUEkgKGJlY2F1c2Ugcm90YXRpb24gcmUt" + + "ZmV0Y2hlcyB0aGUgSzhzIEFQSSdzIGAvb3BlbmlkL3YxL2p3a3NgKToKCiAgIGBgYHNoCiAgIG52" + + "Y2YtY2xpIGNsdXN0ZXIgcm90YXRlIC0tY2x1c3Rlci1pZD08aWQ+IC0tY29tcHV0ZS1wbGFuZS1j" + + "b250ZXh0PTxjdHg+CiAgIGBgYAoKICAgVGhpcyByZS1mZXRjaGVzIEpXS1MgZnJvbSB0aGUgY29t" + + "cHV0ZSBwbGFuZSdzIEs4cyBBUEkgYW5kIFBVVHMgaXQgdG8gSUNNUy4gVGhlIGNsdXN0ZXIgSUQg" + + "c3RheXMgdGhlIHNhbWUuCgozLiAqKlZlcmlmeS4qKiBgbnZjZi1jbGkgY2x1c3RlciBnZXQgLS1j" + + "bHVzdGVyLWlkPTxpZD5gIOKAlCBjb25maXJtIGB1cGRhdGVkQXRgIGFkdmFuY2VkLiBUaGVuIGBr" + + "dWJlY3RsIGxvZ3MgLW4gbnZjYS1zeXN0ZW0gLWwgYXBwLmt1YmVybmV0ZXMuaW8vbmFtZT1udmNh" + + "IC0tdGFpbD0yMGAg4oCUIHJlZ2lzdGVyIGF0dGVtcHRzIHNob3VsZCBzdWNjZWVkICgyMDAsIG5v" + + "dCA0MDEpLgoKIyMgV2hhdCBub3QgdG8gZG8KCi0gKipEb24ndCBgY2x1c3RlciBkZWxldGVgLioq" + + "IFJvdGF0aW9uIHByZXNlcnZlcyB0aGUgY2x1c3RlciBJRCArIGdyb3VwIElEOyBkZWxldGUgY3Jl" + + "YXRlcyBhIG5ldyByb3cgYW5kIHlvdSBoYXZlIHRvIHJlZGVwbG95IHRoZSBjb21wdXRlIHBsYW5l" + + "IHdpdGggbmV3IElEcy4KLSAqKkRvbid0IG1hbnVhbGx5IGVkaXQgYG91dC88Y2x1c3Rlcj4tcmVn" + + "aXN0ZXItdmFsdWVzLnlhbWxgLioqIFJvdGF0ZSB1cGRhdGVzIElDTVMgb25seTsgdGhlIGhlbG0g" + + "dmFsdWVzIGZpbGUgYWxyZWFkeSBoYXMgdGhlIHJpZ2h0IGNsdXN0ZXIgSUQuCgojIyBJZiByb3Rh" + + "dGlvbiBkb2Vzbid0IGZpeCBpdAoKVGhlIGF1dGggZmFpbHVyZSBtYXkgYmUgYXQgYSBkaWZmZXJl" + + "bnQgbGF5ZXIg4oCUIGNoZWNrOgotIE5BVFMgYXV0aC1jYWxsb3V0IGhlYWx0aCAoYGt1YmVjdGwg" + + "bG9ncyAtbiBuYXRzLXN5c3RlbSAtbCBhcHA9bmF0cy1hdXRoLWNhbGxvdXQtc2VydmljZWApCi0g" + + "Q2x1c3RlciByb3cgZXhpc3RzIGluIGBjbHVzdGVyX29pZGNfYnlfY2x1c3Rlcl9pZGAgQ2Fzc2Fu" + + "ZHJhIHRhYmxlCi0gYGhlbG0tcmV2YWwtc2VydmljZWAgY29uZmlnbWFwIGhhcyBgYXV0aHoub2lk" + + "Yy5lbmFibGVkPXRydWVgCgpSb3V0ZSB0byBbZGlhZ25vc2UtZmFpbGVkLWluc3RhbGwubWRdKGRp" + + "YWdub3NlLWZhaWxlZC1pbnN0YWxsLm1kKSBmb3IgdGhvc2UgY2hlY2tzLgpQSwcIGsQsnscHAADH" + + "BwAAUEsDBBQACAAAAAAAIQAAAAAAAAAAAAAAAAAuAAkAZGF0YS9udmNmLXNlbGYtbWFuYWdlZC1j" + + "bGkvcHJvbXB0cy90ZWFyZG93bi5tZFVUBQABAKbOEiMgVGVhciBkb3duIGEgc2VsZi1ob3N0ZWQg" + + "TlZDRiBkZXBsb3ltZW50CgoqKlNBRkVUWToqKiBUZWFyZG93biBkZXN0cm95cyBwZXJzaXN0ZW50" + + "IHN0YXRlIChDYXNzYW5kcmEgcm93cywgT3BlbkJhbyBzZWFsIGtleXMsIHJlZ2lzdGVyZWQgY2x1" + + "c3RlcnMpLiBBbHdheXMgY29uZmlybSB3aXRoIHRoZSB1c2VyIGJlZm9yZSBhbnkgc3RlcC4KCiMj" + + "IFRMO0RSIOKAlCBgZG93bmAgZm9yIG9uZS1zaG90LCBgdW5pbnN0YWxsYCBmb3IgcGVyLXBsYW5l" + + "CgpUaGUgQ0xJIHByb3ZpZGVzIGEgdHdvLXRpZXIgdGVhcmRvd24gc3VyZmFjZSBzeW1tZXRyaWMg" + + "d2l0aCB0aGUgaW5zdGFsbCBzaWRlIChSRVEtMjIsIE0rMTEpOgoKfCBUaWVyIHwgVXAgc2lkZSAo" + + "ZXhpc3RpbmcpIHwgRG93biBzaWRlIHwKfC0tLXwtLS18LS0tfAp8IFBlci1wbGFuZSBwcmltaXRp" + + "dmUgKHJlbmRlcnMgWUFNTDsgR2l0T3BzLWZyaWVuZGx5KSB8IGBpbnN0YWxsIC0tY29udHJvbC1w" + + "bGFuZWAgLyBgaW5zdGFsbCAtLWNvbXB1dGUtcGxhbmVgIHwgYHVuaW5zdGFsbCAtLWNvbnRyb2wt" + + "cGxhbmVgIC8gYHVuaW5zdGFsbCAtLWNvbXB1dGUtcGxhbmVgIHwKfCBPcmNoZXN0cmF0b3IgKG9u" + + "ZS1zaG90LCBtdWx0aS1wbGFuZSArIElDTVMpIHwgYHVwIC0tY2x1c3Rlci1uYW1lPVhgIHwgYGRv" + + "d24gLS1jbHVzdGVyLW5hbWU9WGAgLyBgZG93biAtLWFsbGAgfAoKVXNlIGBkb3duYCBmb3Igbm9y" + + "bWFsIHRlYXJkb3duLiBVc2UgYHVuaW5zdGFsbGAgZm9yIEdpdE9wcyAoY29tbWl0IFlBTUw7IEFy" + + "Z28vRmx1eCBhcHBsaWVzKSBvciBzY3JpcHRlZCBwaXBlbGluZXMuIEFsd2F5cyBzdGFydCB3aXRo" + + "IGEgZHJ5LXJ1bi4KCiMjIERyeS1ydW4gc2hhcGVzCgp8IE1vZGUgfCBMaXZlcyBvbiB8IEludm9r" + + "ZXMgaGVsbS9oZWxtZmlsZT8gfCBPdXRwdXQgfAp8LS0tfC0tLXwtLS18LS0tfAp8IGAtLXBsYW4t" + + "b25seWAgfCBgdXBgIC8gYGRvd25gIChvcmNoZXN0cmF0b3JzKSB8ICoqTm8uKiogV2Fsa3MgcmVz" + + "b2x2ZWQgc3RhY2sgZW50cnlwb2ludCBmaWxlcywgZW1pdHMgcGhhc2UgcGxhbiArIEVUQXMgKyBo" + + "ZWxtIHVuaW5zdGFsbCBjb21tYW5kIHN0cmluZ3MuIHwgRXZlbnQgc3RyZWFtIHwKfCBgLS1uby1h" + + "cHBseWAgfCBgaW5zdGFsbGAgLyBgdW5pbnN0YWxsYCAocHJpbWl0aXZlcykgfCAqKlllcy4qKiBg" + + "aGVsbWZpbGUgdGVtcGxhdGVgIGZvciBpbnN0YWxsOyBgaGVsbSBnZXQgbWFuaWZlc3RgIGZvciB1" + + "bmluc3RhbGwuIHwgWUFNTCBvbiBzdGRvdXQgfAoKU286Ci0gYGRvd24gLS1wbGFuLW9ubHkgLS1j" + + "bHVzdGVyLW5hbWU9WGAg4oCUIHNob3cgbWUgdGhlIG9yY2hlc3RyYXRvciBwaGFzZXMgd2l0aG91" + + "dCBpbnZva2luZyBhbnl0aGluZy4KLSBgdW5pbnN0YWxsIC0tbm8tYXBwbHkgLS1jb21wdXRlLXBs" + + "YW5lIC0tY2x1c3Rlci1uYW1lPVhgIOKAlCBnaXZlIG1lIHRoZSBZQU1MIEknZCBga3ViZWN0bCBk" + + "ZWxldGUgLWYgLWAuCgpgYGBzaAojIFN0ZXAgMTogQUxXQVlTIHByZXZpZXcgZmlyc3QuCm52Y2Yt" + + "Y2xpIHNlbGYtaG9zdGVkIGRvd24gLS1wbGFuLW9ubHkgLS1jbHVzdGVyLW5hbWU9bmNwLWxvY2Fs" + + "IC0tanNvbiB8IGpxCgojIFN0ZXAgMjogUmVhbCBydW4uCm52Y2YtY2xpIHNlbGYtaG9zdGVkIGRv" + + "d24gLS1jbHVzdGVyLW5hbWU9bmNwLWxvY2FsCmBgYAoKIyMgV2hlbiB0byB1c2Ugd2hpY2ggZm9y" + + "bQoKfCBVc2VyIGludGVudCB8IENvbW1hbmQgfAp8LS0tfC0tLXwKfCAiUmVtb3ZlIHRoaXMgb25l" + + "IEdQVSBjbHVzdGVyIiB8IGBudmNmLWNsaSBzZWxmLWhvc3RlZCBkb3duIC0tY2x1c3Rlci1uYW1l" + + "PVhgIHwKfCAiVGVhciBkb3duIGV2ZXJ5dGhpbmciIHwgYG52Y2YtY2xpIHNlbGYtaG9zdGVkIGRv" + + "d24gLS1hbGwgLS1jb25maXJtYCB8CnwgIlNob3cgbWUgdGhlIHN0ZXBzIHdpdGhvdXQgaW52b2tp" + + "bmcgYW55dGhpbmciIHwgYG52Y2YtY2xpIHNlbGYtaG9zdGVkIGRvd24gLS1wbGFuLW9ubHkgLS1j" + + "bHVzdGVyLW5hbWU9WGAgfAp8ICJHaXZlIG1lIFlBTUwgdG8gY29tbWl0ICsgQXJnbyBkZWxldGVz" + + "IGxhdGVyIiB8IGBudmNmLWNsaSBzZWxmLWhvc3RlZCB1bmluc3RhbGwgLS1uby1hcHBseSAtLWNv" + + "bXB1dGUtcGxhbmUgLS1jbHVzdGVyLW5hbWU9WCA+IGRlbGV0ZS55YW1sYCB8CnwgIkp1c3QgcmVt" + + "b3ZlIHRoZSBoZWxtIHJlbGVhc2VzIG9uIGEgY29tcHV0ZSBwbGFuZSAobm8gSUNNUyB1bnJlZ2lz" + + "dGVyLCBubyBkcmFpbikiIHwgYG52Y2YtY2xpIHNlbGYtaG9zdGVkIHVuaW5zdGFsbCAtLWNvbXB1" + + "dGUtcGxhbmUgLS1jbHVzdGVyLW5hbWU9WGAgfAp8ICJKdXN0IHJlbW92ZSB0aGUgY29udHJvbC1w" + + "bGFuZSBoZWxtIHJlbGVhc2VzIiB8IGBudmNmLWNsaSBzZWxmLWhvc3RlZCB1bmluc3RhbGwgLS1j" + + "b250cm9sLXBsYW5lYCB8CgojIyBTdGVwcyBmb3IgYGRvd24gLS1jbHVzdGVyLW5hbWU9WGAgKHRo" + + "ZSBzdGFuZGFyZCBwYXRoKQoKIyMjIDEuIENvbmZpcm0gc2NvcGUgd2l0aCB0aGUgdXNlcgoKQXNr" + + "OgotICJUZWFyaW5nIGRvd24gZXZlcnl0aGluZyAoY29tcHV0ZSBwbGFuZXMgKyBjb250cm9sIHBs" + + "YW5lICsgSUNNUyByb3dzKSBvciBqdXN0IG9uZSBjb21wdXRlIHBsYW5lPyIKLSAiQXJlIHRoZXJl" + + "IEFDVElWRSBmdW5jdGlvbiBkZXBsb3ltZW50cyBvbiB0aGlzIGNsdXN0ZXI/IGBudmNmLWNsaSBm" + + "dW5jdGlvbiBkZXBsb3kgbGlzdGAgdG8gY2hlY2suIiAoSW1wb3J0YW50IOKAlCBgZG93bmAgd2ls" + + "bCByZWZ1c2Ugd2l0aG91dCBgLS1kcmFpbi1hY3RpdmU9dHJ1ZXxwcm9tcHRgIGlmIGFueSBhcmUg" + + "QUNUSVZFLikKLSAiU2hvdWxkIHdlIHdpcGUgcGVyc2lzdGVudCBzdGF0ZSAoQ2Fzc2FuZHJhIGRh" + + "dGEsIE9wZW5CYW8gc2VhbCBrZXlzLCBzci1kZWZhdWx0IHVzZXIgZGF0YSk/IERlZmF1bHQgaXMg" + + "dG8gKipwcmVzZXJ2ZSoqIHRoZW0uIGAtLXJlbW92ZS1wZXJzaXN0ZW50YCBvcHRzIGluIHRvIGRl" + + "bGV0aW9uLiAqKkxvc3MgaXMgdW5yZWNvdmVyYWJsZS4qKiIKCiMjIyAyLiBSdW4gcGxhbi1vbmx5" + + "IGZpcnN0CgpgYGBzaApudmNmLWNsaSBzZWxmLWhvc3RlZCBkb3duIC0tcGxhbi1vbmx5IC0tY2x1" + + "c3Rlci1uYW1lPSROQU1FIC0tanNvbiB8IGpxCmBgYAoKVGhpcyBlbWl0cyBhIGBwbGFubmVkYCBl" + + "dmVudCBsaXN0aW5nIGVhY2ggcGhhc2UsIHRoZSBoZWxtIHJlbGVhc2VzIHRoYXQgd291bGQgYmUg" + + "dW5pbnN0YWxsZWQsIHRoZSBJQ01TIHJvd3MgdGhhdCB3b3VsZCBiZSByZW1vdmVkLCBhbmQgRVRB" + + "cy4gQ29weSB0aGUgYHdpbGxVbmluc3RhbGwuY29tbWFuZHNbXWAgYXJyYXkgdG8gdGhlIHVzZXIg" + + "4oCUIHRob3NlIGFyZSB0aGUgbGl0ZXJhbCBgaGVsbSB1bmluc3RhbGwg4oCmYCBpbnZvY2F0aW9u" + + "cyB0aGUgb3JjaGVzdHJhdG9yIHdpbGwgcnVuLgoKIyMjIDMuIEV4ZWN1dGUgdGhlIGRvd24KCmBg" + + "YHNoCm52Y2YtY2xpIHNlbGYtaG9zdGVkIGRvd24gLS1jbHVzdGVyLW5hbWU9JE5BTUUgLS1qc29u" + + "CmBgYAoKUGhhc2VzICgxLTcsIG1pcnJvcnMgwqc2LjcuMSk6CgoxLiBQcmVmbGlnaHQg4oCUIGt1" + + "YmVjdGwgYWNjZXNzICsgSUNNUyByZWFjaGFibGUKMi4gUmVzb2x2ZSBzdGFjayBidW5kbGUKMy4g" + + "RHJhaW4gYWN0aXZlIGRlcGxveW1lbnRzIOKAlCBydW5zIGBmdW5jdGlvbiBkZXBsb3kgcmVtb3Zl" + + "YCBmb3IgZWFjaCBBQ1RJVkUgZGVwbG95bWVudCwgcG9sbHMgdW50aWwgU1RPUFBFRC4gU3ViamVj" + + "dCB0byBgLS1kcmFpbi1hY3RpdmU9dHJ1ZXxmYWxzZXxwcm9tcHRgIChkZWZhdWx0IGlzIGBwcm9t" + + "cHRgIGluIFRUWSkuCjQuIFVuaW5zdGFsbCBjb21wdXRlIHBsYW5lIOKAlCBkZWxlZ2F0ZXMgdG8g" + + "YHVuaW5zdGFsbCAtLWNvbXB1dGUtcGxhbmVgOyBgaGVsbSB1bmluc3RhbGwgPHJlbGVhc2U+YCBw" + + "ZXIgcmVsZWFzZSBpbiByZXZlcnNlLURBRyBvcmRlcgo1LiBSZW1vdmUgcGVyc2lzdGVudCAoc2tp" + + "cHBlZCB1bmxlc3MgYC0tcmVtb3ZlLXBlcnNpc3RlbnRgKQo2LiBVbnJlZ2lzdGVyIGNsdXN0ZXIg" + + "ZnJvbSBJQ01TCjcuIEZpbmFsIHZlcmlmeQoKIyMjIDQuIFRlYXIgZG93biB0aGUgY29udHJvbCBw" + + "bGFuZSAoaWYgYXBwbGljYWJsZSkKCmBgYHNoCm52Y2YtY2xpIHNlbGYtaG9zdGVkIHVuaW5zdGFs" + + "bCAtLWNvbnRyb2wtcGxhbmUKYGBgCgpPciB2aWEgdGhlIG9yY2hlc3RyYXRvcidzIGAtLWFsbGAg" + + "bW9kZSBpZiBldmVyeSBjb21wdXRlIHBsYW5lIGlzIGFsc28gZ29pbmcgYXdheSAoc2VlIHN0ZXAg" + + "NSkuCgpgdW5pbnN0YWxsIC0tY29udHJvbC1wbGFuZWAgcmVmdXNlcyBpZiBhbnkgY29tcHV0ZSBw" + + "bGFuZSBpcyBzdGlsbCByZWdpc3RlcmVkIGluIElDTVMuIFVzZSBgLS1mb3JjZS13aXRoLXJlZ2lz" + + "dGVyZWQtY2x1c3RlcnNgIHRvIG92ZXJyaWRlICoqb25seSoqIGlmIHRoZSB1c2VyIGV4cGxpY2l0" + + "bHkgd2FudHMgdG8gb3JwaGFuIGNvbXB1dGUgcGxhbmVzIChQU0FUIGF1dGggYnJlYWtzIGZvciB0" + + "aG9zZSBjbHVzdGVycyDigJQgdGhleSB3aWxsIHN0YXJ0IGZhaWxpbmcgZXZlcnkgaGVhbHRoIGNo" + + "ZWNrKS4gQWx3YXlzIHN0YXRlIHRoZSBjb25zZXF1ZW5jZSBiZWZvcmUgcGFzc2luZyB0aGUgZmxh" + + "Zy4KCiMjIyA1LiBPciwgbnVrZSBldmVyeXRoaW5nCgpgYGBzaApudmNmLWNsaSBzZWxmLWhvc3Rl" + + "ZCBkb3duIC0tYWxsIC0tY29uZmlybQpgYGAKClRoaXMgaXRlcmF0ZXMgZXZlcnkgcmVnaXN0ZXJl" + + "ZCBjb21wdXRlIHBsYW5lIGluIElDTVMsIHJ1bnMgdGhlIHBlci1jbHVzdGVyIGRvd24gZm9yIGVh" + + "Y2ggaW4gcGFyYWxsZWwgKGJvdW5kZWQgYnkgYC0tYWxsLWNvbmN1cnJlbmN5YCwgZGVmYXVsdCA0" + + "KSwgdGhlbiBydW5zIGB1bmluc3RhbGwgLS1jb250cm9sLXBsYW5lYC4gSW50ZXJhY3RpdmUgbW9k" + + "ZSBwcm9tcHRzIHRoZSBvcGVyYXRvciB3aXRoIHRoZSBjbHVzdGVyIGxpc3QgYmVmb3JlIHByb2Nl" + + "ZWRpbmc7IGAtLWNvbmZpcm1gIHNraXBzIHRoZSBwcm9tcHQgZm9yIG5vbi1pbnRlcmFjdGl2ZSB1" + + "c2UuCgojIyBHaXRPcHMgcGF0aCAoaWYgdXNlciBoYXMgQXJnbyAvIEZsdXgpCgpgYGBzaAojIFJl" + + "bmRlciBkZWxldGUgWUFNTCBmb3IgdGhlIGNvbXB1dGUgcGxhbmU6Cm52Y2YtY2xpIHNlbGYtaG9z" + + "dGVkIHVuaW5zdGFsbCAtLW5vLWFwcGx5IC0tY29tcHV0ZS1wbGFuZSAtLWNsdXN0ZXItbmFtZT0k" + + "TkFNRSA+IGRlbGV0ZS55YW1sCgojIE9wZXJhdG9yIGNvbW1pdHMgZGVsZXRlLnlhbWwgdG8gdGhl" + + "aXIgR2l0T3BzIHJlcG8uIEFyZ28vRmx1eCBhcHBsaWVzIHRoZSBkZWxldGlvbiBvbiBuZXh0IHN5" + + "bmMuCmdpdCBhZGQgZGVsZXRlLnlhbWw7IGdpdCBjb21taXQgLW0gInJlbW92ZSBjb21wdXRlIHBs" + + "YW5lICROQU1FIjsgZ2l0IHB1c2gKCiMgQWZ0ZXIgQXJnbyBzeW5jIHJlbW92ZXMgdGhlIEs4cyBy" + + "ZXNvdXJjZXMsIHNlcGFyYXRlbHkgcmVtb3ZlIHRoZSBJQ01TIHJvdzoKbnZjZi1jbGkgY2x1c3Rl" + + "ciBkZWxldGUgLS1jbHVzdGVyLWlkPSRDTFVTVEVSX0lECmBgYAoKTm90ZTogYC0tbm8tYXBwbHlg" + + "IGRvZXMgTk9UIGluY2x1ZGUgdGhlIElDTVMgYGNsdXN0ZXIgZGVsZXRlYCAoaGVsbSBkb2Vzbid0" + + "IG1hbmFnZSB0aGF0KS4gT3BlcmF0b3JzIGZvbGxvd2luZyBHaXRPcHMgbXVzdCBydW4gYG52Y2Yt" + + "Y2xpIGNsdXN0ZXIgZGVsZXRlYCBzZXBhcmF0ZWx5LCBvciB1c2UgYGRvd25gIHRvIG9yY2hlc3Ry" + + "YXRlIGJvdGguCgojIyBGYWlsdXJlIHJlY292ZXJ5CgpJZiBgZG93bmAgcGFydGlhbC1mYWlscyBt" + + "aWQtd2F5LCAqKnJlLXJ1biB0aGUgc2FtZSBjb21tYW5kKiouIFRoZSBvcmNoZXN0cmF0b3IgaXMg" + + "aWRlbXBvdGVudDogYGhlbG0gdW5pbnN0YWxsYCBza2lwcyByZWxlYXNlcyB0aGF0IGFyZSBhbHJl" + + "YWR5IGdvbmUsIGFuZCBgY2x1c3RlciBkZWxldGUgLS1pZ25vcmUtbWlzc2luZ2Agc2tpcHMgSUNN" + + "UyByb3dzIHRoYXQgYXJlIGFscmVhZHkgZ29uZS4gUGhhc2UgNCArIDYgZW1pdCBgcGhhc2U6IHNr" + + "aXBwZWQgKGFscmVhZHkgY2xlYW4pYCBvbiB0aGUgc2Vjb25kIHJ1bi4KCklmIGEgYHBoYXNlX2Zh" + + "aWxlZGAgZXZlbnQgc3VyZmFjZXM6Ci0gYGVyckNhdGVnb3J5OiAiaGVsbV9wZW5kaW5nX3VwZ3Jh" + + "ZGUiLCByZXRyeUNsYXNzOiAiYWZ0ZXJfcmVtZWRpYXRpb24iYCDihpIgcnVuIGBoZWxtIHJvbGxi" + + "YWNrIDxyZWxlYXNlPiAwIC0ta3ViZS1jb250ZXh0PeKApmAgKHRoZSBtZXNzYWdlIGluY2x1ZGVz" + + "IHRoZSBleGFjdCByZWxlYXNlIG5hbWUpIHRoZW4gcmUtcnVuIGBkb3duYC4gRG8gTk9UIGF1dG8t" + + "cm9sbGJhY2sgd2l0aG91dCB1c2VyIGNvbmZpcm1hdGlvbi4KLSBgZXJyQ2F0ZWdvcnk6ICJjb21w" + + "dXRlX3BsYW5lIiwgcmV0cnlDbGFzczogImFmdGVyX3JlbWVkaWF0aW9uImAgd2l0aCBtZXNzYWdl" + + "IGFib3V0IEFDVElWRSBkZXBsb3ltZW50cyDihpIgdXNlciBwYXNzZWQgYC0tZHJhaW4tYWN0aXZl" + + "PWZhbHNlYCBidXQgZGVwbG95bWVudHMgZXhpc3QuIFJlLXJ1biB3aXRoIGAtLWRyYWluLWFjdGl2" + + "ZT10cnVlYCBvciBgLS1kcmFpbi1hY3RpdmU9cHJvbXB0YCBhbmQgY29uZmlybSB3aXRoIHRoZSB1" + + "c2VyLgotIE90aGVyIGNhdGVnb3JpZXMg4oaSIHN1cmZhY2UgYGVyck1lc3NhZ2VgICsgZWFjaCBg" + + "cmVtZWRpYXRpb25gIHN0cmluZyB2ZXJiYXRpbS4gU1RPUC4gRG8gbm90IHByb3Bvc2UgcmV0cnkg" + + "d2l0aG91dCB1c2VyIGlucHV0LgoKIyMgQWx3YXlzIGNvbmZpcm0KCkZvciBldmVyeSBgbnZjZi1j" + + "bGkgc2VsZi1ob3N0ZWQgZG93bmAgb3IgYHVuaW5zdGFsbGAgaW52b2NhdGlvbiwgZXNwZWNpYWxs" + + "eSB3aXRoIGRlc3RydWN0aXZlIGZsYWdzOgotIFN0YXRlIHRoZSBleGFjdCBgLS1jbHVzdGVyLW5h" + + "bWVgIChvciBgLS1hbGxgKS4KLSBTdGF0ZSB3aGF0J3MgbG9zdCAoZS5nLiAiYWxsIGZ1bmN0aW9u" + + "IGRlcGxveW1lbnRzIHNjaGVkdWxlZCBvbiBgbmNwLWxvY2FsYCB3aWxsIHN0b3A7IGNvbXB1dGUg" + + "cGxhbmUgd2lsbCBkZXJlZ2lzdGVyIGZyb20gSUNNUyIpLgotIElmIGAtLXJlbW92ZS1wZXJzaXN0" + + "ZW50YCBpcyBiZWluZyBjb25zaWRlcmVkLCBzdGF0ZSB0aGF0IENhc3NhbmRyYSByb3dzICsgT3Bl" + + "bkJhbyBzZWFsIGtleXMgd2lsbCBiZSBkZWxldGVkIGFuZCB0aGF0IHRoaXMgaXMgdW5yZWNvdmVy" + + "YWJsZS4KLSBXYWl0IGZvciBleHBsaWNpdCB1c2VyIGNvbmZpcm1hdGlvbi4KLSBOZXZlciBwcm9w" + + "b3NlIGAtLWZvcmNlLXdpdGgtcmVnaXN0ZXJlZC1jbHVzdGVyc2Agd2l0aG91dCBleHBsYWluaW5n" + + "IHRoYXQgY29tcHV0ZSBwbGFuZXMgd2lsbCBiZSBvcnBoYW5lZC4KLSBOZXZlciBwcm9wb3NlIGAt" + + "LXJlbW92ZS1wZXJzaXN0ZW50YCB3aXRob3V0IGV4cGxhaW5pbmcgdGhlIGxvc3MuCgojIyBNYW51" + + "YWwgZmFsbGJhY2sgKGlmIGBudmNmLWNsaSBzZWxmLWhvc3RlZCB7dW5pbnN0YWxsLGRvd259YCBp" + + "cyB1bmF2YWlsYWJsZSkKCklmIHRoZSB1c2VyIGlzIG9uIGEgQ0xJIHZlcnNpb24gb2xkZXIgdGhh" + + "biBNKzExLCBmYWxsIGJhY2sgdG86CgpgYGBzaAojIFBlciBjb21wdXRlIHBsYW5lIChvbiBpdHMg" + + "a3ViZWN0bCBjb250ZXh0KToKaGVsbSB1bmluc3RhbGwgbnZjYS1hZ2VudCAtbiBudmNhLXN5c3Rl" + + "bQpoZWxtIHVuaW5zdGFsbCBudmNhLW9wZXJhdG9yIC1uIG52Y2Etb3BlcmF0b3IKaGVsbSB1bmlu" + + "c3RhbGwgaW1hZ2UtY3JlZGVudGlhbC1oZWxwZXIgLW4gbnZjYS1zeXN0ZW0KaGVsbSB1bmluc3Rh" + + "bGwgc2hhcmVkc3RvcmFnZSAtbiBudmNhLXN5c3RlbQoKIyBEcmFpbiB0aGUgSUNNUyByb3c6Cm52" + + "Y2YtY2xpIGNsdXN0ZXIgZGVsZXRlIC0tY2x1c3Rlci1pZD08aWQ+CgojIENvbnRyb2wgcGxhbmUg" + + "dGVhcmRvd24gKG9uIGl0cyBrdWJlY3RsIGNvbnRleHQpOgpjZCBudmNmLXNlbGYtbWFuYWdlZC1z" + + "dGFjawptYWtlIGRlc3Ryb3kgICAjIGludm9rZXMgaGVsbWZpbGUgZGVzdHJveSBhY3Jvc3MgYWxs" + + "IHJlbGVhc2VzCgojIElmIHVzaW5nIHNwbGl0IHN0YWNrIGJ1bmRsZXMsIHRlYXJkb3duIGNvbXB1" + + "dGUgcGxhbmUgcmVsZWFzZXMgdG9vOgpjZCAuLi9udmNmLWNvbXB1dGUtcGxhbmUtc3RhY2sKbWFr" + + "ZSBkZXN0cm95CmBgYAoKVGhpcyBpcyB0aGUgbWFudWFsIHBhdGg7IHByZWZlciB0aGUgbmV3IHN1" + + "YmNvbW1hbmRzIHdoZW5ldmVyIHRoZXkncmUgaW5zdGFsbGVkLgoKIyMgV2hhdCBga3ViZWN0bCBk" + + "ZWxldGUgcHZjYCBkb2VzCgpJZiB0aGUgdXNlciBhc2tzICJ3aHkgaXMgbXkgbmV3IGluc3RhbGwg" + + "c2VlaW5nIHRoZSBvbGQgZGF0YT8iIOKAlCB0aGUgU3RhdGVmdWxTZXQgUFZDcyAoQ2Fzc2FuZHJh" + + "LCBPcGVuQmFvKSBhcmUgTk9UIGRlbGV0ZWQgYnkgYGhlbG0gdW5pbnN0YWxsYCAoYW5kIHNvIGFy" + + "ZSBOT1QgZGVsZXRlZCBieSBgbnZjZi1jbGkgc2VsZi1ob3N0ZWQgZG93bmAgZWl0aGVyLCBieSBk" + + "ZWZhdWx0KS4gVGhleSBwZXJzaXN0IGludGVudGlvbmFsbHkgc28gYSByZS1gdXBgIGNhbiByZXN1" + + "bWUgYWdhaW5zdCBleGlzdGluZyBkYXRhLiBUbyB3aXBlIGNvbXBsZXRlbHkgb24gdGhlIG5leHQg" + + "YGRvd25gOgoKYGBgc2gKbnZjZi1jbGkgc2VsZi1ob3N0ZWQgZG93biAtLWNsdXN0ZXItbmFtZT1u" + + "Y3AtbG9jYWwgLS1yZW1vdmUtcGVyc2lzdGVudApgYGAKCk9yLCBwb3N0LWRvd24sIG1hbnVhbGx5" + + "OgoKYGBgc2gKa3ViZWN0bCBkZWxldGUgcHZjIC1uIGNhc3NhbmRyYS1zeXN0ZW0gLS1hbGwKa3Vi" + + "ZWN0bCBkZWxldGUgcHZjIC1uIHZhdWx0LXN5c3RlbSAtLWFsbApgYGAKCioqQ29uZmlybSB3aXRo" + + "IHVzZXIuKiogVGhpcyBpcyB0aGUgZGVzdHJ1Y3RpdmUgc3RlcC4KUEsHCBKTM1ngIQAA4CEAAFBL" + + "AwQUAAgAAAAAACEAAAAAAAAAAAAAAAAAMAAJAGRhdGEvbnZjZi1zZWxmLW1hbmFnZWQtY2xpL3Jl" + + "ZmVyZW5jZS9jb21tYW5kcy5tZFVUBQABAKbOEiMgYG52Y2YtY2xpYCBjb21tYW5kIHJlZmVyZW5j" + + "ZQoKRnVsbCBzdWJjb21tYW5kIGxpc3QuIEFsd2F5cyBwYWlyIHdpdGggW2ZsYWdzLm1kXShmbGFn" + + "cy5tZCkgZm9yIGdsb2JhbCBmbGFncyBhbmQgW2V4aXQtY29kZXMubWRdKGV4aXQtY29kZXMubWQp" + + "IGZvciByZXR1cm4gY29kZXMuCgojIyBTZWxmLWhvc3RlZCBsaWZlY3ljbGUKCnwgQ29tbWFuZCB8" + + "IFB1cnBvc2UgfCBPdXRwdXQgfCBOb3RlcyB8CnwtLS18LS0tfC0tLXwtLS18CnwgYHNlbGYtaG9z" + + "dGVkIGNoZWNrIC0tcHJlIFtmbGFnc11gIHwgUHJlLWZsaWdodCB2YWxpZGF0aW9uIChubyBhZG1p" + + "biBjcmVkcykgfCBzdHJlYW1pbmcgZXZlbnRzIHwgUGVyLXJvbGUgd2l0aCBgLS1jb250cm9sLXBs" + + "YW5lLWNvbnRleHRgIC8gYC0tY29tcHV0ZS1wbGFuZS1jb250ZXh0YDsgYC0tbG9jYWwtb25seWAg" + + "c2tpcHMga3ViZWN0bCB8CnwgYHNlbGYtaG9zdGVkIGNoZWNrIC0tY29udHJvbC1wbGFuZSBbLS13" + + "YWl0IERVUl1gIHwgRXZlcnkgQ1AgcmVsZWFzZSBoZWFsdGh5IHwgc3RyZWFtaW5nIGV2ZW50cyB8" + + "IFBvbGxzIHVudGlsIHBhc3Mgb3IgYC0td2FpdGAgZWxhcHNlcyB8CnwgYHNlbGYtaG9zdGVkIGNo" + + "ZWNrIC0tY29tcHV0ZS1wbGFuZSAtLWNsdXN0ZXItbmFtZT1YIFstLXdhaXQgRFVSXWAgfCBQZXIt" + + "Y2x1c3RlciB3b3JrZXIgc3RhdGUgfCBzdHJlYW1pbmcgZXZlbnRzIHwgTlZDQSArIG9wZXJhdG9y" + + "ICsgSldLUy1maW5nZXJwcmludCBtYXRjaCB8CnwgYHNlbGYtaG9zdGVkIGNoZWNrIC0tYWxsIFst" + + "LXdhaXQgRFVSXWAgfCBGYW4tb3V0IG92ZXIgYWxsIG9mIHRoZSBhYm92ZSB8IHN0cmVhbWluZyBl" + + "dmVudHMgfCB8CnwgYHNlbGYtaG9zdGVkIGluc3RhbGwgLS1jb250cm9sLXBsYW5lYCB8IFJlbmRl" + + "ciBjb250cm9sLXBsYW5lIG1hbmlmZXN0cyB8IFlBTUwgb24gc3Rkb3V0IHwgUGlwZSB0byBga3Vi" + + "ZWN0bCBhcHBseSAtZiAtYCB8CnwgYHNlbGYtaG9zdGVkIGluc3RhbGwgLS1jb21wdXRlLXBsYW5l" + + "IC0tY2x1c3Rlci1uYW1lPVhgIHwgUmVnaXN0ZXIgY2x1c3RlciArIHJlbmRlciBjb21wdXRlIG1h" + + "bmlmZXN0cyB8IFlBTUwgb24gc3Rkb3V0IHwgT25lIGludm9jYXRpb24gcGVyIEdQVSBjbHVzdGVy" + + "IHwKfCBgc2VsZi1ob3N0ZWQgdXAgLS1jbHVzdGVyLW5hbWU9WGAgfCBPbmUtc2hvdCBmaXJzdCBp" + + "bnN0YWxsIChib3RoIHBsYW5lcykgfCAoZW1wdHkpIHN0ZG91dCwgcHJvZ3Jlc3Mgb24gc3RkZXJy" + + "IHwgQWx3YXlzIGluc3RhbGxzIGJvdGggcGxhbmVzOyBmb3IgY29tcHV0ZS1vbmx5IHVzZSBgYWRk" + + "LWNvbXB1dGUtcGxhbmVgIHwKfCBgc2VsZi1ob3N0ZWQgdXAgLS1wbGFuLW9ubHkgLS1jbHVzdGVy" + + "LW5hbWU9WGAgfCBEcnktcnVuIHByZXZpZXcgfCBKU09OTCBvbiBzdGRlcnIgfCBBZ2VudC1mcmll" + + "bmRseSwgbm8gY2x1c3RlciBjaGFuZ2VzIHwKfCBgc2VsZi1ob3N0ZWQgYWRkLWNvbXB1dGUtcGxh" + + "bmUgLS1jbHVzdGVyLW5hbWU9WCAtLWNvbXB1dGUtcGxhbmUtY29udGV4dD1ZIC0taWNtcy11cmw9" + + "VVJMIC0tdG9rZW49JEpXVGAgfCBBZGQgYSBjb21wdXRlIHBsYW5lIHRvIGFuIGV4aXN0aW5nIGNv" + + "bnRyb2wgcGxhbmUgfCBwcm9ncmVzcyBvbiBzdGRlcnIgfCBGb3IgMm5kLCAzcmQsIOKApiBHUFUg" + + "Y2x1c3RlciBhZnRlciB0aGUgZmlyc3QgaW5zdGFsbC4gQ1Agbm90IHRvdWNoZWQuIHwKfCBgc2Vs" + + "Zi1ob3N0ZWQgc3RhdHVzIFstLWNsdXN0ZXItbmFtZT1YXSBbLS13YXRjaF1gIHwgU25hcHNob3Qg" + + "Y2x1c3RlciBoZWFsdGggfCBUVFkvcGxhaW4vSlNPTkwgfCBgLS13YXRjaGAgZm9yIGxpdmUgcmUt" + + "cmVuZGVyIHwKfCBgc2VsZi1ob3N0ZWQgdW5pbnN0YWxsIC0tY29tcHV0ZS1wbGFuZSAtLWNsdXN0" + + "ZXItbmFtZT1YYCB8IFBlci1wbGFuZSBwcmltaXRpdmU6IGBoZWxtZmlsZSBkZXN0cm95YCBvbiBv" + + "bmUgY29tcHV0ZSBwbGFuZSAobm8gSUNNUyB1bnJlZ2lzdGVyLCBubyBkcmFpbikgfCBwcm9ncmVz" + + "cyB8IEp1c3QgdGhlIGhlbG0gcmVsZWFzZXMgb24gdGhhdCBjb21wdXRlIHBsYW5lIHwKfCBgc2Vs" + + "Zi1ob3N0ZWQgdW5pbnN0YWxsIC0tY29udHJvbC1wbGFuZSBbLS1mb3JjZS13aXRoLXJlZ2lzdGVy" + + "ZWQtY2x1c3RlcnNdYCB8IFBlci1wbGFuZSBwcmltaXRpdmU6IGBoZWxtZmlsZSBkZXN0cm95YCBv" + + "biB0aGUgY29udHJvbCBwbGFuZSB8IHByb2dyZXNzIHwgUmVmdXNlcyBpZiBjb21wdXRlIHBsYW5l" + + "cyBzdGlsbCByZWdpc3RlcmVkIHVubGVzcyBgLS1mb3JjZS13aXRoLXJlZ2lzdGVyZWQtY2x1c3Rl" + + "cnNgIHwKfCBgc2VsZi1ob3N0ZWQgdW5pbnN0YWxsIC0tbm8tYXBwbHkgPHBsYW5lPmAgfCBSZW5k" + + "ZXIgZGVsZXRlIFlBTUwgdmlhIGBoZWxtIGdldCBtYW5pZmVzdGAgcGVyIHJlbGVhc2UgfCBZQU1M" + + "IG9uIHN0ZG91dCB8IEdpdE9wczsgcGlwZSB0byBga3ViZWN0bCBkZWxldGUgLWYgLWAgb3IgY29t" + + "bWl0ICsgQXJnbyBhcHBsaWVzLiBNaXJyb3JzIGBpbnN0YWxsIC0tbm8tYXBwbHlgIHwKfCBgc2Vs" + + "Zi1ob3N0ZWQgZG93biAtLWNsdXN0ZXItbmFtZT1YIFstLWRyYWluLWFjdGl2ZV0gWy0tcmVtb3Zl" + + "LXBlcnNpc3RlbnRdYCB8IE9yY2hlc3RyYXRvcjogZHJhaW4g4oaSIHVuaW5zdGFsbCAtLWNvbXB1" + + "dGUtcGxhbmUg4oaSIGNsdXN0ZXIgZGVsZXRlIGluIElDTVMgfCBwcm9ncmVzcyB8IFN5bW1ldHJp" + + "YyBjb21wYW5pb24gdG8gYHVwIC0tY2x1c3Rlci1uYW1lPVhgIHwKfCBgc2VsZi1ob3N0ZWQgZG93" + + "biAtLWFsbCBbLS1jb25maXJtXWAgfCBPcmNoZXN0cmF0b3I6IHRlYXIgZG93biBldmVyeSByZWdp" + + "c3RlcmVkIGNvbXB1dGUgcGxhbmUgKyBjb250cm9sIHBsYW5lIHwgcHJvZ3Jlc3MgfCBCb3VuZGVk" + + "IHBhcmFsbGVsaXNtIHZpYSBgLS1hbGwtY29uY3VycmVuY3lgIChkZWZhdWx0IDQpOyBgLS1jb25m" + + "aXJtYCByZXF1aXJlZCBpbiBub24taW50ZXJhY3RpdmUgfAp8IGBzZWxmLWhvc3RlZCBkb3duIC0t" + + "cGxhbi1vbmx5IC4uLmAgfCBPcmNoZXN0cmF0b3IgZHJ5LXJ1bjogcGhhc2VzICsgaGVsbSByZWxl" + + "YXNlcyArIElDTVMgcm93cyArIEVUQXMgKG5vIGhlbG0vaGVsbWZpbGUgY29udGFjdCkgfCBKU09O" + + "TCB8ICoqQWx3YXlzIHJ1biBiZWZvcmUgYW55IGFjdHVhbCBgZG93bmAqKiB8CgojIyBDbHVzdGVy" + + "IG1hbmFnZW1lbnQKCnwgQ29tbWFuZCB8IFB1cnBvc2UgfCBOb3RlcyB8CnwtLS18LS0tfC0tLXwK" + + "fCBgY2x1c3RlciByZWdpc3RlciAtLW5hbWU9WCAtLW5jYS1pZD1ZIFstLXJlZ2lvbj1aXSBbLS1p" + + "Z25vcmUtZXhpc3RpbmddYCB8IFJlZ2lzdGVyIGEgSldLUytPSURDIHdpdGggSUNNUyB8IFVzZWQg" + + "YnkgYHVwYCBQaGFzZSA1IGludGVybmFsbHk7IHN0YW5kYWxvbmUgZm9yIG1hbnVhbCByZWdpc3Ry" + + "YXRpb24gfAp8IGBjbHVzdGVyIGxpc3QtcmVnaXN0ZXJlZCAtLW5jYS1pZD1ZIFstLWljbXMtdXJs" + + "PVVSTF1gIHwgTGlzdCBzZWxmLWhvc3RlZCBjbHVzdGVyIHJlZ2lzdHJhdGlvbnMgZnJvbSBJQ01T" + + "IHwgVXNlcyB0aGUgYWRtaW4gdG9rZW47IGAtLWpzb25gIGZvciBtYWNoaW5lLXJlYWRhYmxlIG91" + + "dHB1dCB8CnwgYGNsdXN0ZXIgcm90YXRlIC0tY2x1c3Rlci1pZD1JRGAgfCBSZS1mZXRjaCBKV0tT" + + "IGZyb20gSzhzIGFuZCBQVVQgdG8gSUNNUyB8IEFmdGVyIEs4cyBBUEkgc2VydmVyIHNpZ25pbmcg" + + "a2V5IHJvdGF0aW9uIHwKfCBgY2x1c3RlciBkZWxldGUgLS1jbHVzdGVyLWlkPUlEYCB8IFJlbW92" + + "ZSBJQ01TIHJvdyB8ICoqREVTVFJVQ1RJVkU6IGNvbmZpcm0gd2l0aCB1c2VyKiogfAoKIyMgRnVu" + + "Y3Rpb25zCgp8IENvbW1hbmQgfCBQdXJwb3NlIHwgTm90ZXMgfAp8LS0tfC0tLXwtLS18CnwgYGZ1" + + "bmN0aW9uIGNyZWF0ZSAtLWlucHV0LWZpbGU9RklMRWAgfCBDcmVhdGUgZnVuY3Rpb24gbWV0YWRh" + + "dGEgfCBSZXR1cm5zIEZ1bmN0aW9uIElEICsgVmVyc2lvbiBJRDsgTExNIGZ1bmN0aW9ucyB1c2Ug" + + "YGZ1bmN0aW9uVHlwZTogIkxMTSJgIGFuZCBgbW9kZWxzW10ubGxtQ29uZmlnLnVyaXNgIGZvciBg" + + "L3YxL2NoYXQvY29tcGxldGlvbnNgLCBgL3YxL3Jlc3BvbnNlc2AsIGFuZCBgL3YxL2VtYmVkZGlu" + + "Z3NgIHwKfCBgZnVuY3Rpb24gbGlzdGAgLyBgZnVuY3Rpb24gbGlzdC1pZHNgIHwgTGlzdCBmdW5j" + + "dGlvbnMgLyBJRHMgb25seSB8IHwKfCBgZnVuY3Rpb24gZ2V0IC0tZnVuY3Rpb24taWQ9SUQgLS12" + + "ZXJzaW9uLWlkPVZJRGAgfCBGdW5jdGlvbiBtZXRhZGF0YSB8IHwKfCBgZnVuY3Rpb24gdXBkYXRl" + + "IC0tZnVuY3Rpb24taWQ9SUQgLS12ZXJzaW9uLWlkPVZJRCAtLXRhZ3M9VEFHWyxUQUddYCB8IFVw" + + "ZGF0ZSBmdW5jdGlvbiB0YWdzIHwgfAp8IGBmdW5jdGlvbiB1cGRhdGUgLS1mdW5jdGlvbi1pZD1J" + + "RCAtLXZlcnNpb24taWQ9VklEIC0tbGxtLW1vZGVsLXVwZGF0ZT1TUEVDYCB8IFVwZGF0ZSBMTE0g" + + "bW9kZWwgcm91dGluZyBjb25maWcgfCBgU1BFQ2AgdXNlcyBgbmFtZT08bW9kZWw+LHJvdXRpbmdN" + + "ZXRob2Q9PG1ldGhvZD4sdG9rZW5SYXRlTGltaXQ9PGxpbWl0PmA7IGFjY2VwdGVkIG1ldGhvZHMg" + + "YXJlIGxpc3RlZCBpbiBbZmxhZ3MubWRdKGZsYWdzLm1kKSB8CnwgYGZ1bmN0aW9uIGRlcGxveSBj" + + "cmVhdGUgLS1pbnB1dC1maWxlPUZJTEVgIHwgU2NoZWR1bGUgYSBkZXBsb3ltZW50IHwgQmxvY2tz" + + "IHVudGlsIEFDVElWRSAoZGVmYXVsdCA5MDBzKSB8CnwgYGZ1bmN0aW9uIGRlcGxveSBnZXQgLS1m" + + "dW5jdGlvbi1pZD1JRCAtLXZlcnNpb24taWQ9VklEIFstLWpzb25dYCB8IERlcGxveW1lbnQgc3Rh" + + "dHVzIHwgYGZ1bmN0aW9uU3RhdHVzOiBBQ1RJVkVcfERFUExPWUlOR1x8RVJST1JcfEZBSUxFRGAg" + + "fAp8IGBmdW5jdGlvbiBkZXBsb3kgdXBkYXRlIC0taW5wdXQtZmlsZT1GSUxFYCB8IE1vZGlmeSBh" + + "IGRlcGxveW1lbnQgaW4gcGxhY2UgfCB8CnwgYGZ1bmN0aW9uIGRlcGxveSByZW1vdmUgLS1mdW5j" + + "dGlvbi1pZD1JRCAtLXZlcnNpb24taWQ9VklEYCB8IFN0b3AgYSBkZXBsb3ltZW50LCBrZWVwIGZ1" + + "bmN0aW9uIHJlY29yZCB8IHwKfCBgZnVuY3Rpb24gaW52b2tlIC0taW5wdXQtZmlsZT1GSUxFYCB8" + + "IENhbGwgYSByZWd1bGFyIGZ1bmN0aW9uIHwgUmVxdWlyZXMgQVBJIGtleSAobm90IGFkbWluIHRv" + + "a2VuKTsgTExNIGZ1bmN0aW9ucyBhcmUgaW52b2tlZCB0aHJvdWdoIGBsbG0uaW52b2NhdGlvbi48" + + "ZG9tYWluPmAgd2l0aCBgbW9kZWw6ICI8ZnVuY3Rpb24taWQ+Lzxtb2RlbC1uYW1lPiJgIHwKfCBg" + + "ZnVuY3Rpb24gZGVsZXRlIC0tZnVuY3Rpb24taWQ9SUQgLS12ZXJzaW9uLWlkPVZJRGAgfCBSZW1v" + + "dmUgZnVuY3Rpb24gKyBkZXBsb3ltZW50IHwgKipERVNUUlVDVElWRTogY29uZmlybSB3aXRoIHVz" + + "ZXIqKiB8CgojIyBUYXNrcwoKVGFzayBjb21tYW5kcyByZXF1aXJlIGBOVkNGX0FQSV9LRVlgIHNl" + + "dCB0byBhIHRhc2stc2NvcGVkIGtleSBhbmQgYE5WQ0ZfQkFTRV9OVkNUX1VSTGAgc2V0IHRvIHRo" + + "ZSBOVkNUIGdhdGV3YXkgZW5kcG9pbnQuIEluIGEgZnJlc2ggc2Vzc2lvbiwgcmVhZCBgbnZjdEFw" + + "aUtleWAgZnJvbSBgfi8ubnZjZi1jbGkuc3RhdGVgIGFuZCBpbmplY3QgaXQgYXMgYE5WQ0ZfQVBJ" + + "X0tFWWAgd2l0aG91dCBsb2dnaW5nIHRoZSB2YWx1ZTsgY2hlY2sgYG52Y3RBcGlLZXlFeHBpcmF0" + + "aW9uYCBmaXJzdCBhbmQgcmVnZW5lcmF0ZSB3aXRoIGBhcGkta2V5IGdlbmVyYXRlIC0tZm9yIHRh" + + "c2sgLS12YWxpZGF0ZWAgaWYgZXhwaXJlZC4gUnVuIGBhcGkta2V5IGdlbmVyYXRlIC0tZm9yIHRh" + + "c2tgIGFmdGVyIGBpbml0YCB0byBtaW50IGEgbmV3IGtleS4KCnwgQ29tbWFuZCB8IFB1cnBvc2Ug" + + "fCBOb3RlcyB8CnwtLS18LS0tfC0tLXwKfCBgdGFzayBjcmVhdGUgLS1uYW1lPVggLS1ncHU9R1BV" + + "IC0taW5zdGFuY2UtdHlwZT1UWVBFIC0taW1hZ2U9SU1HYCB8IFN1Ym1pdCBhIGNvbnRhaW5lciB0" + + "YXNrIHwgU2F2ZXMgdGFzayBJRCB0byBDTEkgc3RhdGU7IHVzZSBgLS1pbnB1dC1maWxlYCBmb3Ig" + + "cmVwZWF0YWJsZSBjb25maWdzIHwKfCBgdGFzayBjcmVhdGUgLS1uYW1lPVggLS1ncHU9R1BVIC0t" + + "aW5zdGFuY2UtdHlwZT1UWVBFIC0taGVsbS1jaGFydD1DSEFSVGAgfCBTdWJtaXQgYSBIZWxtIHRh" + + "c2sgfCBgLS1oZWxtLWNoYXJ0YCByZXBsYWNlcyBgLS1pbWFnZWAgfAp8IGB0YXNrIGNyZWF0ZSAt" + + "LWlucHV0LWZpbGU9RklMRWAgfCBTdWJtaXQgYSB0YXNrIGZyb20gYSBKU09OIGNvbmZpZyBmaWxl" + + "IHwgUmVjb21tZW5kZWQgZm9yIHJlcGVhdGFibGUgY29uZmlndXJhdGlvbnMgfAp8IGB0YXNrIGxp" + + "c3QgWy0tc3RhdHVzPVNUQVRVU10gWy0tbGltaXQ9Tl1gIHwgTGlzdCB0YXNrcywgb3B0aW9uYWxs" + + "eSBmaWx0ZXJlZCBieSBzdGF0dXMgfCBTdGF0dXNlczogYFFVRVVFRGAsIGBMQVVOQ0hFRGAsIGBS" + + "VU5OSU5HYCwgYENPTVBMRVRFRGAsIGBFUlJPUkVEYCwgYENBTkNFTEVEYCwgYEVYQ0VFREVEX01B" + + "WF9SVU5USU1FX0RVUkFUSU9OYCwgYEVYQ0VFREVEX01BWF9RVUVVRURfRFVSQVRJT05gIHwKfCBg" + + "dGFzayBnZXQgW3Rhc2tJZF1gIHwgR2V0IHRhc2sgZGV0YWlscyB8IFVzZXMgc2F2ZWQgdGFzayBJ" + + "RCBmcm9tIHN0YXRlIGlmIG9taXR0ZWQgfAp8IGB0YXNrIGV2ZW50cyBbdGFza0lkXSBbLS1saW1p" + + "dD1OXWAgfCBMaXN0IGxpZmVjeWNsZSBldmVudHMgZm9yIGEgdGFzayB8IHwKfCBgdGFzayByZXN1" + + "bHRzIFt0YXNrSWRdYCB8IExpc3QgcmVzdWx0IGFydGlmYWN0cyBmb3IgYSBjb21wbGV0ZWQgdGFz" + + "ayB8IFJldHVybnMgZW1wdHkgbGlzdCB3aGVuIGByZXN1bHRIYW5kbGluZ1N0cmF0ZWd5YCBpcyBg" + + "Tk9ORWA7IHJlc3VsdCB1cGxvYWQgbm90IHlldCBzdXBwb3J0ZWQgfAp8IGB0YXNrIGNhbmNlbCBb" + + "dGFza0lkXWAgfCBDYW5jZWwgYSBydW5uaW5nIHRhc2sgfCBOby1vcCBpZiBhbHJlYWR5IGluIHRl" + + "cm1pbmFsIHN0YXRlIHwKfCBgdGFzayBkZWxldGUgW3Rhc2tJZF1gIHwgRGVsZXRlIGEgdGFzayBy" + + "ZWNvcmQgfCAqKlN0b3AsIHN0YXRlIHRhc2sgSUQgKyBjdXJyZW50IHN0YXR1cywgYW5kIHdhaXQg" + + "Zm9yIGEgc3Vic2VxdWVudCB1c2VyIHJlcGx5IGV4cGxpY2l0bHkgY29uZmlybWluZyBkZWxldGlv" + + "biBvZiB0aGF0IHNwZWNpZmljIHRhc2suIERvIG5vdCB0cmVhdCB0aGUgb3JpZ2luYWwgZGVsZXRl" + + "IHJlcXVlc3QgYXMgY29uZmlybWF0aW9uLioqIHwKfCBgdGFzayB1cGRhdGUtc2VjcmV0cyBbdGFz" + + "a0lkXSAtLXNlY3JldHMgTkFNRT12YWx1ZWAgfCBVcGRhdGUgc2VjcmV0cyBvbiBhIHRhc2s7IHN1" + + "cHBsaWVkIHNlY3JldHMgYXJlIGFkZGVkIG9yIHVwZGF0ZWQgYnkgbmFtZSwgZXhpc3Rpbmcgc2Vj" + + "cmV0cyBub3QgaW4gdGhlIHJlcXVlc3QgYXJlIHByZXNlcnZlZCB8IFZhbHVlcyBhcmUgZW5jcnlw" + + "dGVkIGF0IHJlc3QgfAp8IGB0YXNrIGJ1bGsgLS10YXNrLWlkcz1JRDFbLElEMizigKZdYCB8IEZl" + + "dGNoIGRldGFpbHMgZm9yIG11bHRpcGxlIHRhc2tzIGluIG9uZSByZXF1ZXN0IHwgfAoKIyMgQXV0" + + "aAoKfCBDb21tYW5kIHwgUHVycG9zZSB8IE5vdGVzIHwKfC0tLXwtLS18LS0tfAp8IGBpbml0YCB8" + + "IE1pbnQgYWRtaW4gdG9rZW4gZnJvbSBBUEkgS2V5cyB2aWEgcHVibGljIGFwaSBnYXRld2F5IHwg" + + "SWRlbXBvdGVudDsgd3JpdGVzIGB+Ly5udmNmLWNsaS5zdGF0ZWA7IGNsZWFycyBzYXZlZCBmdW5j" + + "dGlvbiBzdGF0ZSBhbmQgYWxsIEFQSSBrZXlzIChmdW5jdGlvbiBhbmQgdGFzaykgfAp8IGBzdGF0" + + "dXNgIHwgU2hvdyBDTEkgc3RhdGUgKHRva2VuLCBsYXN0IGVuZHBvaW50cywgZnVuY3Rpb24gY29u" + + "dGV4dCkgfCBEaXN0aW5jdCBmcm9tIGBzZWxmLWhvc3RlZCBzdGF0dXNgIHwKfCBgYXBpLWtleSBn" + + "ZW5lcmF0ZSBbLS1mb3IgZnVuY3Rpb25cfHRhc2tdIFstLWRlc2NyaXB0aW9uPeKApl0gWy0tZXhw" + + "aXJlcy1pbj3igKZdYCB8IE1pbnQgQVBJIGtleXMgfCBEZWZhdWx0IChubyBgLS1mb3JgKTogZ2Vu" + + "ZXJhdGVzIGJvdGggYSBmdW5jdGlvbiBrZXkgYW5kIGEgdGFzayBrZXk7IGAtLWZvciBmdW5jdGlv" + + "bmAgb3IgYC0tZm9yIHRhc2tgIGdlbmVyYXRlcyBvbmUgb25seTsgYC0tc2NvcGVzYCByZXF1aXJl" + + "cyBgLS1mb3JgIHwKfCBgYXBpLWtleSBnZW5lcmF0ZSAtLXZhbGlkYXRlYCB8IE1pbnQgYW5kIGlt" + + "bWVkaWF0ZWx5IHZhbGlkYXRlIGVhY2ggZ2VuZXJhdGVkIGtleSB8IFZhbGlkYXRlcyBlYWNoIGtl" + + "eSBhZ2FpbnN0IGl0cyBjb3JyZWN0IGF1ZGllbmNlIChOVkNGIGZvciBmdW5jdGlvbiBrZXlzLCBO" + + "VkNUIGZvciB0YXNrIGtleXMpIHwKfCBgYXBpLWtleSBsaXN0YCB8IExpc3QgQVBJIGtleXMgZm9y" + + "IGN1cnJlbnQgb3duZXIgfCBMaXN0cyBOVkNGLXNjb3BlZCBrZXlzIG9ubHkgfAp8IGBhcGkta2V5" + + "IGRlbGV0ZSBLRVktSURgIC8gYGFwaS1rZXkgcmV2b2tlIEtFWS1JRGAgfCBSZW1vdmUgYW4gQVBJ" + + "IGtleSB8ICoqQ29uZmlybSB3aXRoIHVzZXIqKiB8CnwgYGFwaS1rZXkgc2hvd2AgfCBTaG93IGN1" + + "cnJlbnRseSBzYXZlZCBBUEkga2V5IGZyb20gc3RhdGUgfCB8CgojIyBBZ2VudCBza2lsbAoKfCBD" + + "b21tYW5kIHwgUHVycG9zZSB8IE5vdGVzIHwKfC0tLXwtLS18LS0tfAp8IGBhZ2VudC1za2lsbCBp" + + "bnN0YWxsIFstLXRhcmdldD1ESVJdYCB8IEluc3RhbGwgYWxsIGJ1bmRsZWQgcHVibGljIHVzZXIg" + + "c2tpbGxzIGludG8gYH4vLmNsYXVkZS9za2lsbHMvYCBhbmQgYH4vLmFnZW50cy9za2lsbHMvYCB8" + + "IERlZmF1bHQ6IGJvdGggYmFzZSBza2lsbHMgZGlyZWN0b3JpZXMgfAp8IGBhZ2VudC1za2lsbCB1" + + "bmluc3RhbGwgWy0tdGFyZ2V0PURJUl1gIHwgUmVtb3ZlIG9ubHkgYnVuZGxlZCBwdWJsaWMgdXNl" + + "ciBza2lsbHMgZnJvbSB0aGUgdGFyZ2V0IGJhc2Ugc2tpbGxzIGRpcmVjdG9yaWVzIHwgSWRlbXBv" + + "dGVudDsgdW5yZWxhdGVkIHNraWxscyByZW1haW4gfAp8IGBhZ2VudC1za2lsbCBzaG93IFstLWZp" + + "bGU9UkVMXWAgfCBQcmludCBidW5kbGVkIGBudmNmLXNlbGYtbWFuYWdlZC1jbGkvU0tJTEwubWRg" + + "IG9yIGFub3RoZXIgZW1iZWRkZWQgZmlsZSB8IEZvciBkZWJ1Z2dpbmcgfAp8IGBhZ2VudC1za2ls" + + "bCB2ZXJzaW9uYCB8IFByaW50IGJ1aWxkIFNIQSBhbmQgZW1iZWRkZWQgcHVibGljIHVzZXIgc2tp" + + "bGwgc3VtbWFyeSB8IHwKUEsHCHIND2QhIwAAISMAAFBLAwQUAAgAAAAAACEAAAAAAAAAAAAAAAAA" + + "MgAJAGRhdGEvbnZjZi1zZWxmLW1hbmFnZWQtY2xpL3JlZmVyZW5jZS9leGl0LWNvZGVzLm1kVVQF" + + "AAEAps4SIyBgbnZjZi1jbGlgIGV4aXQgY29kZXMKClN0YWJsZSBhY3Jvc3Mgc3ViY29tbWFuZHMu" + + "IFVzZSB0aGVzZSB0byBkcml2ZSBhZ2VudCByZXRyeSAvIHN1cmZhY2luZyBsb2dpYy4KCnwgQ29k" + + "ZSB8IE1lYW5pbmcgfCBFeGFtcGxlIGNhdXNlcyB8CnwtLS18LS0tfC0tLXwKfCBgMGAgfCBTdWNj" + + "ZXNzIHwgQWxsIGNoZWNrcyBwYXNzZWQ7IGluc3RhbGwgY29tcGxldGVkOyBkZXBsb3ltZW50IEFD" + + "VElWRSB8CnwgYDFgIHwgR2VuZXJpYyBlcnJvciB8IEhlbG0gcmVuZGVyIGZhaWxlZDsgbmV0d29y" + + "ayB1bnJlYWNoYWJsZTsgZmlsZSBub3QgZm91bmQ7IFlBTUwgcGFyc2UgZXJyb3IgfAp8IGAyYCB8" + + "IFByZS1mbGlnaHQgY2hlY2sgZmFpbGVkIHwgR2F0ZXdheSBBUEkgQ1JEcyBtaXNzaW5nOyBrdWJl" + + "Y3RsIG5vdCBvbiBQQVRIOyBkZWZhdWx0IFN0b3JhZ2VDbGFzcyBhYnNlbnQgfAp8IGAzYCB8IEFk" + + "bWluIGF1dGggZmFpbGVkIHwgTm8gdG9rZW4gKyBgLS1ub24taW50ZXJhY3RpdmVgIHNldDsgSUNN" + + "UyByZWplY3RlZCBKV1Q7IGluaXQgZW5kcG9pbnQgdW5yZWFjaGFibGUgfAp8IGA1YCB8IE1hbmlm" + + "ZXN0IGFwcGx5IG9yIGAtLXdhaXRgIHRpbWVkIG91dCB8IEhlbG0gaW5zdGFsbCB0aW1lb3V0OyBj" + + "aGVjayBwb2xsZWQgYnV0IGRpZG4ndCBwYXNzIGJlZm9yZSBkdXJhdGlvbiB8CnwgYDEzMGAgfCBD" + + "YW5jZWxsZWQgYnkgU0lHSU5UL1NJR1RFUk0gfCBVc2VyIEN0cmwtQzsgQ0kgYnVkZ2V0IGV4Y2Vl" + + "ZGVkOyBwb2QgZXZpY3RlZCB8CgojIyBIb3cgYW4gYWdlbnQgc2hvdWxkIHJlYWN0Cgp8IENvZGUg" + + "fCBBZ2VudCBiZWhhdmlvciB8CnwtLS18LS0tfAp8IGAwYCB8IENvbnRpbnVlIC8gcmVwb3J0IHN1" + + "Y2Nlc3MuIHwKfCBgMWAgfCBTdXJmYWNlIHN0ZGVyciB0byB1c2VyOyBhc2sgYmVmb3JlIGFueSBy" + + "ZXRyeS4gR2VuZXJpYyBlcnJvcnMgdXN1YWxseSBuZWVkIGEgaHVtYW4gdG8gcmVhZCB0aGUgbWVz" + + "c2FnZS4gfAp8IGAyYCB8IFN1cmZhY2UgZmFpbGVkIGNoZWNrcyArIHRoZWlyIGBoaW50VVJMYC4g" + + "RG9uJ3QgcHJvcG9zZSBgdXBgIHVudGlsIHRoZSB1c2VyIGZpeGVzIHByZXJlcXMuIHwKfCBgM2Ag" + + "fCBTdWdnZXN0IGBudmNmLWNsaSBpbml0YCAoaW50ZXJhY3RpdmUpIE9SIGAtLXRva2VuPSRKV1Rg" + + "IChDSSkuIERvbid0IGF1dG8tbWludCB3aXRob3V0IHVzZXIgT0suIHwKfCBgNWAgfCBBc2sgdXNl" + + "ciBpZiB0aGV5IHdhbnQgdG8gd2FpdCBsb25nZXIsIGRpZyBpbnRvIHRoZSBzdGFsbGVkIGNvbXBv" + + "bmVudCwgb3IgY2FuY2VsLiB8CnwgYDEzMGAgfCBEb24ndCByZXRyeSBhdXRvbWF0aWNhbGx5OyB1" + + "c2VyIGV4cGxpY2l0bHkgY2FuY2VsbGVkLiBDb25maXJtIGJlZm9yZSByZS1ydW5uaW5nLiB8Cgoj" + + "IyBXaGVyZSB0byBmaW5kIG1vcmUgZGV0YWlsCgpFdmVyeSBub24temVybyBleGl0IGVtaXRzIGEg" + + "c3RydWN0dXJlZCBgcGhhc2VfZmFpbGVkYCBKU09OIGV2ZW50IHdpdGggYGVyckNhdGVnb3J5YCwg" + + "YGVyck1lc3NhZ2VgLCBgcmVtZWRpYXRpb25gIChhcnJheSksIGByZXRyeUNsYXNzYCAoZW51bTog" + + "YG5vbmV8aW1tZWRpYXRlfGJhY2tvZmZ8YWZ0ZXJfcmVtZWRpYXRpb258dW5rbm93bmApLCBgcmV0" + + "cnlBZnRlclNlY2AgKGludCwgb3B0aW9uYWwpLCBhbmQgYHJhd2AgKHN1YnByb2Nlc3MgKyBIVFRQ" + + "ICsgS3ViZXJuZXRlcyBzaWduYWwpLiBBbHdheXMgY29uc3VtZSB0aGVzZSBpbiBgLS1qc29uYCBt" + + "b2RlIHJhdGhlciB0aGFuIHBhcnNpbmcgRW5nbGlzaCBmcm9tIHN0ZGVyci4KUEsHCHOnWmTVBgAA" + + "1QYAAFBLAwQUAAgAAAAAACEAAAAAAAAAAAAAAAAALQAJAGRhdGEvbnZjZi1zZWxmLW1hbmFnZWQt" + + "Y2xpL3JlZmVyZW5jZS9mbGFncy5tZFVUBQABAKbOEiMgYG52Y2YtY2xpYCBmbGFnIHJlZmVyZW5j" + + "ZQoKIyMgR2xvYmFsIGZsYWdzIChldmVyeSBzdWJjb21tYW5kKQoKfCBGbGFnIHwgUHVycG9zZSB8" + + "IERlZmF1bHQgfAp8LS0tfC0tLXwtLS18CnwgYC0tY29uZmlnIEZJTEVgIHwgQ29uZmlnIGZpbGUg" + + "cGF0aCB8IGAkSE9NRS8ubnZjZi1jbGkueWFtbGAgfAp8IGAtLWRlYnVnYCB8IFZlcmJvc2UgSFRU" + + "UCBsb2dnaW5nIG9uIHN0ZGVyciB8IGBmYWxzZWAgfAp8IGAtLWpzb25gIHwgSlNPTkwgZXZlbnRz" + + "IG9uIHN0ZGVyciB8IGF1dG8gKG9mZiBpbiBUVFksIG9uIHVuZGVyIGAtLW5vbi1pbnRlcmFjdGl2" + + "ZWApIHwKCiMjIGBzZWxmLWhvc3RlZGAgcGFyZW50IChwZXJzaXN0ZW50IGFjcm9zcyBzdWJjb21t" + + "YW5kcykKCnwgRmxhZyB8IFB1cnBvc2UgfCBEZWZhdWx0IHwKfC0tLXwtLS18LS0tfAp8IGAtLWNv" + + "bnRyb2wtcGxhbmUtc3RhY2s94oCmYCB8IENvbnRyb2wtcGxhbmUgYnVuZGxlIHNvdXJjZTogbG9j" + + "YWwgcGF0aCwgZ2l0IFVSTCwgb3IgYG9jaTovL2AgVVJMIHwgZW1iZWRkZWQgT0NJIFVSTCBwaW5u" + + "ZWQgYnkgQ0xJIHZlcnNpb24gfAp8IGAtLWNvbXB1dGUtcGxhbmUtc3RhY2s94oCmYCB8IENvbXB1" + + "dGUtcGxhbmUgYnVuZGxlIHNvdXJjZTogbG9jYWwgcGF0aCwgZ2l0IFVSTCwgb3IgYG9jaTovL2Ag" + + "VVJMIHwgZW1iZWRkZWQgT0NJIFVSTCBwaW5uZWQgYnkgQ0xJIHZlcnNpb24gfAp8IGAtLWVudj1s" + + "b2NhbFx8cHJkXHzigKZgIHwgSGVsbWZpbGUgZW52aXJvbm1lbnQgbmFtZSB8IGBsb2NhbGAgZm9y" + + "IGRldiBidWlsZHMsIGBwcmRgIGZvciByZWxlYXNlcyB8CnwgYC0tbm9uLWludGVyYWN0aXZlYCB8" + + "IERpc2FibGUgYWxsIHN0ZGluIHByb21wdHMgfCBgZmFsc2VgIHwKfCBgLS10b2tlbj0kSldUYCB8" + + "IEFkbWluIEpXVCwgb3ZlcnJpZGVzIHN0b3JlZCBzZXNzaW9uIHwgLSB8CnwgYC0tbm8tYXBwbHlg" + + "IHwgYGluc3RhbGxgIG9ubHkgLSBlbWl0IFlBTUwsIGRvIG5vdCBrdWJlY3RsIGFwcGx5IHwgYGZh" + + "bHNlYCB8CnwgYC0tb3V0cHV0PXRleHRcfGpzb25gIHwgTGVnYWN5IGFsaWFzIGZvciBgLS1qc29u" + + "YCAoZGVwcmVjYXRlZCwgcmVtb3ZlZCBpbiBuZXh0IG1ham9yKSB8IGB0ZXh0YCB8CnwgYC0tcGxh" + + "aW5gIHwgRm9yY2UgcGxhaW4gc3RyZWFtaW5nIG91dHB1dCB8IGF1dG8tZGV0ZWN0IHwKfCBgLS13" + + "YWl0IERVUkFUSU9OYCB8IGBjaGVja2Agb25seTsgYmxvY2sgdW50aWwgcGFzcyB8IC0gfAp8IGAt" + + "LWNvbnRyb2wtcGxhbmUtY29udGV4dCBDVFhgIHwga3ViZWN0bCBjb250ZXh0IGZvciBjb250cm9s" + + "IHBsYW5lIChSRVEtMjApIHwgY3VycmVudCBjb250ZXh0IHwKfCBgLS1jb21wdXRlLXBsYW5lLWNv" + + "bnRleHQgQ1RYYCB8IGt1YmVjdGwgY29udGV4dCBmb3IgY29tcHV0ZSBwbGFuZSAoUkVRLTIwKSB8" + + "IGN1cnJlbnQgY29udGV4dCB8CnwgYC0taWNtcy11cmwgVVJMYCB8IFB1YmxpYyBJQ01TIFVSTDsg" + + "cmVxdWlyZWQgd2hlbiBjb250ZXh0cyBkaWZmZXIgfCBkZXJpdmVkIGZyb20gYGJhc2VfaHR0cF91" + + "cmxgIHwKfCBgLS1sb2NhbC1vbmx5YCB8IGBjaGVjayAtLXByZWAgb25seTsgc2tpcCBhbGwga3Vi" + + "ZWN0bCBjb250YWN0IHwgYGZhbHNlYCB8CgojIyBgdXBgLXNwZWNpZmljCgp8IEZsYWcgfCBQdXJw" + + "b3NlIHwgRGVmYXVsdCB8CnwtLS18LS0tfC0tLXwKfCBgLS1jbHVzdGVyLW5hbWUgTkFNRWAgfCBJ" + + "Q01TIGNsdXN0ZXIgcm93IGlkZW50aWZpZXIgKHJlcXVpcmVkKSB8IC0gfAp8IGAtLW5jYS1pZCBJ" + + "RGAgfCBOQ0EgYWNjb3VudCBJRCB8IGBudmNmLWRlZmF1bHRgIHwKfCBgLS1yZWdpb24gUkVHSU9O" + + "YCB8IENsdXN0ZXIgcmVnaW9uIHwgYHVzLXdlc3QtMWAgfAp8IGAtLXBsYW4tb25seWAgfCBEcnkt" + + "cnVuOyBlbWl0IHBoYXNlIHBsYW4gKyBFVEFzIHdpdGhvdXQgY2hhbmdlcyB8IGBmYWxzZWAgfAoK" + + "IyMgYHN0YXR1c2Atc3BlY2lmaWMKCnwgRmxhZyB8IFB1cnBvc2UgfCBEZWZhdWx0IHwKfC0tLXwt" + + "LS18LS0tfAp8IGAtLWNsdXN0ZXItbmFtZSBOQU1FYCB8IExpbWl0IHRvIG9uZSBjb21wdXRlIHBs" + + "YW5lIHwgLSAoY29udHJvbCArIGFsbCBjbHVzdGVycykgfAp8IGAtLXdhdGNoYCB8IExpdmUgcmUt" + + "cmVuZGVyIHwgYGZhbHNlYCB8CnwgYC0td2F0Y2gtaW50ZXJ2YWwgRFVSYCB8IGAtLXdhdGNoYCBj" + + "YWRlbmNlIHwgYDVzYCB8CnwgYC0tY29tcG9uZW50IE5BTUVgIHwgRmlsdGVyIGNvbXBvbmVudHMg" + + "cGFuZWwgfCBhbGwgfAp8IGAtLW5vLWV2ZW50c2AgfCBTa2lwIGV2ZW50cyBwYW5lbCB8IGBmYWxz" + + "ZWAgfAoKIyMgYGNsdXN0ZXIgcmVnaXN0ZXJgLXNwZWNpZmljCgp8IEZsYWcgfCBQdXJwb3NlIHwg" + + "RGVmYXVsdCB8CnwtLS18LS0tfC0tLXwKfCBgLS1uYW1lIE5BTUVgIHwgQ2x1c3RlciBuYW1lIChy" + + "ZXF1aXJlZCkgfCAtIHwKfCBgLS1uY2EtaWQgSURgIHwgTkNBIElEIChyZXF1aXJlZCkgfCAtIHwK" + + "fCBgLS1yZWdpb24gUkVHSU9OYCB8IFJlZ2lvbiB8IGB1cy13ZXN0LTFgIHwKfCBgLS1pY21zLXVy" + + "bCBVUkxgIHwgSUNNUyBlbmRwb2ludCB8IGZyb20gY29uZmlnIHwKfCBgLS1pZ25vcmUtZXhpc3Rp" + + "bmdgIHwgTWF0Y2gtb3ItY3JlYXRlIGluc3RlYWQgb2YgZmFpbC1vbi1leGlzdHMgfCBgZmFsc2Vg" + + "IHwKCiMjIGBhcGkta2V5IGdlbmVyYXRlYC1zcGVjaWZpYwoKfCBGbGFnIHwgUHVycG9zZSB8IERl" + + "ZmF1bHQgfAp8LS0tfC0tLXwtLS18CnwgYC0tZm9yIGZ1bmN0aW9uXHx0YXNrYCB8IEdlbmVyYXRl" + + "IG9ubHkgdGhlIHNwZWNpZmllZCBrZXkgdHlwZSB8IChvbWl0IHRvIGdlbmVyYXRlIGJvdGgpIHwK" + + "fCBgLS1kZXNjcmlwdGlvbiBURVhUYCB8IEh1bWFuLXJlYWRhYmxlIGxhYmVsIGZvciB0aGUga2V5" + + "IHwgYEdlbmVyYXRlZCBieSBudmNmLWNsaWAgfAp8IGAtLWV4cGlyZXMtaW4gRFVSQVRJT05gIHwg" + + "RXhwaXJ5IG9mZnNldCAoZS5nLiBgMjRoYCwgYDdkYCk7IHBhcnNlZCBhcyBleHRlbmRlZCBkdXJh" + + "dGlvbiB8IGAyNGhgIHwKfCBgLS1zY29wZXMgU0NPUEVbLFNDT1BFXWAgfCBPdmVycmlkZSBkZWZh" + + "dWx0IHNjb3BlczsgcmVxdWlyZXMgYC0tZm9yYCB8IChzZXJ2aWNlIGRlZmF1bHRzKSB8CnwgYC0t" + + "dmFsaWRhdGVgIHwgVmFsaWRhdGUgZWFjaCBnZW5lcmF0ZWQga2V5IGltbWVkaWF0ZWx5IGFmdGVy" + + "IG1pbnRpbmcgfCBgZmFsc2VgIHwKCkV4dGVuZGVkIGR1cmF0aW9uIHVuaXRzOiBgc2AgKHNlY29u" + + "ZHMpLCBgbWAgKG1pbnV0ZXMpLCBgaGAgKGhvdXJzKSwgYGRgIChkYXlzKSwgYHdgICh3ZWVrcyku" + + "CgojIyBgZnVuY3Rpb24gY3JlYXRlYC1zcGVjaWZpYwoKYC0taW5wdXQtZmlsZSBGSUxFYCBpcyBy" + + "ZWNvbW1lbmRlZCBmb3IgcmVwZWF0YWJsZSBmdW5jdGlvbiBkZWZpbml0aW9ucy4gRm9yIGFkLWhv" + + "YyBjcmVhdGVzOgoKfCBGbGFnIHwgUHVycG9zZSB8IERlZmF1bHQgfAp8LS0tfC0tLXwtLS18Cnwg" + + "YC0tbmFtZSBOQU1FYCB8IEZ1bmN0aW9uIG5hbWUgfCAtIHwKfCBgLS1pbWFnZSBJTUFHRWAgfCBD" + + "b250YWluZXIgaW1hZ2UgfCAtIHwKfCBgLS1pbmZlcmVuY2UtdXJsIFVSSWAgfCBDb250YWluZXIg" + + "aW5mZXJlbmNlIGVuZHBvaW50IHwgLSB8CnwgYC0taW5mZXJlbmNlLXBvcnQgUE9SVGAgfCBDb250" + + "YWluZXIgaW5mZXJlbmNlIHBvcnQgfCAtIHwKfCBgLS1mdW5jdGlvbi10eXBlIERFRkFVTFRcfFNU" + + "UkVBTUlOR1x8TExNYCB8IEZ1bmN0aW9uIHR5cGUgfCBgREVGQVVMVGAgfAp8IGAtLWhlbG0tY2hh" + + "cnQgQ0hBUlRgIHwgSGVsbSBjaGFydCBVUkwgb3IgT0NJIHJlZmVyZW5jZS4gQ2FuIGJlIHVzZWQg" + + "d2l0aCBgLS1mdW5jdGlvbi10eXBlPUxMTWAgZm9yIGNoYXJ0LXBhY2thZ2VkIExMTSB3b3JrbG9h" + + "ZHMuIHwgLSB8CnwgYC0taGVsbS1jaGFydC1zZXJ2aWNlIE5BTUVgIHwgS3ViZXJuZXRlcyBTZXJ2" + + "aWNlIG5hbWUgZXhwb3NlZCBieSB0aGUgY2hhcnQuIFJlcXVpcmVkIHdoZW4gYC0taGVsbS1jaGFy" + + "dGAgaXMgc2V0LiB8IC0gfAp8IGAtLW1vZGVscyBOQU1FOlZFUlNJT046VVJJYCB8IFN0YW5kYXJk" + + "IG1vZGVsIGFydGlmYWN0OyByZXBlYXRhYmxlIHwgLSB8CnwgYC0tbGxtLW1vZGVsIFNQRUNgIHwg" + + "TExNIG1vZGVsIGNvbmZpZzsgZm9ybWF0IGBuYW1lPTxtb2RlbD4sdXJpcz08dXJpPlx8PHVyaT4s" + + "cm91dGluZ01ldGhvZD08bWV0aG9kPix0b2tlblJhdGVMaW1pdD08bGltaXQ+YDsgcmVwZWF0YWJs" + + "ZS4gVG9rZW4gbGltaXRzIHVzZSBgPHZhbHVlPi08dW5pdD5gIHdpdGggYFNgLCBgTWAsIGBIYCwg" + + "YERgLCBvciBgV2AsIGZvciBleGFtcGxlIGAxMDAwLVNgLiBVc2UgaW5wdXQgSlNPTiBmb3IgY29t" + + "YmluZWQgdG9rZW4gbGltaXRzIGJlY2F1c2UgaW5saW5lIHNwZWNzIHVzZSBjb21tYXMgYXMgZmll" + + "bGQgc2VwYXJhdG9ycy4gfCAtIHwKCkluIEpTT04gYW5kIGlubGluZSBzcGVjcywgTExNIGZ1bmN0" + + "aW9ucyBzZXQgYGZ1bmN0aW9uVHlwZTogIkxMTSJgIGFuZCBtb2RlbCByb3V0aW5nIG1ldGFkYXRh" + + "IHVuZGVyIGBtb2RlbHNbXS5sbG1Db25maWdgLiBgbGxtQ29uZmlnLnVyaXNgIGRlY2xhcmVzIHRo" + + "ZSBPcGVuQUktY29tcGF0aWJsZSB1cHN0cmVhbSBwYXRocyBleHBvc2VkIGJ5IHRoZSBtb2RlbC4g" + + "Q3VycmVudCBzdXBwb3J0ZWQgcGF0aHMgYXJlIGAvdjEvY2hhdC9jb21wbGV0aW9uc2AsIGAvdjEv" + + "cmVzcG9uc2VzYCwgYW5kIGAvdjEvZW1iZWRkaW5nc2AuIGBsbG1Db25maWcucm91dGluZ01ldGhv" + + "ZGAgYWNjZXB0cyBgcm91bmRfcm9iaW5gLCBgcG93ZXJfb2ZfdHdvYCwgYGdyb3FfbXVsdGlyZWdp" + + "b25gLCBgcHVsc2FyYCwgb3IgYHJhbmRvbWAuCmBsbG1Db25maWcudG9rZW5SYXRlTGltaXRgIGFj" + + "Y2VwdHMgb25lIG9yIG1vcmUgY29tbWEtc2VwYXJhdGVkIHBvc2l0aXZlIGludGVnZXIgdG9rZW4g" + + "bGltaXRzIGluIGA8dmFsdWU+LTx1bml0PmAgZm9ybWF0LiBTdXBwb3J0ZWQgdW5pdHMgYXJlIGBT" + + "YCAoc2Vjb25kcyksIGBNYCAobWludXRlcyksIGBIYCAoaG91cnMpLCBgRGAgKGRheXMpLCBhbmQg" + + "YFdgICh3ZWVrcykuIFVzZSBkaXN0aW5jdCB1bml0cyB3aGVuIGNvbWJpbmluZyBsaW1pdHMsIGZv" + + "ciBleGFtcGxlIGAxMDAwLVMsNTAwMC1NLDEwMDAwMC1ILDUwMDAwMC1ELDEwMDAwMDAtV2AgaW4g" + + "aW5wdXQgSlNPTi4KCkhlbG0gY2hhcnQgcGFja2FnaW5nIGlzIGluZGVwZW5kZW50IG9mIGBmdW5j" + + "dGlvblR5cGVgLiBGb3IgYSBIZWxtLWNoYXJ0IGJhY2tlZCBMTE0gZnVuY3Rpb24sIHNldCBgZnVu" + + "Y3Rpb25UeXBlOiAiTExNImAsIGBoZWxtQ2hhcnRgLCBgaGVsbUNoYXJ0U2VydmljZU5hbWVgLCBh" + + "bmQgYG1vZGVsc1tdLmxsbUNvbmZpZ2AgaW4gdGhlIHNhbWUgY3JlYXRlIHJlcXVlc3QuIGBpbmZl" + + "cmVuY2VQb3J0YCBtdXN0IGJlIHRoZSBLdWJlcm5ldGVzIFNlcnZpY2UgcG9ydCBleHBvc2VkIGJ5" + + "IGBoZWxtQ2hhcnRTZXJ2aWNlTmFtZWAuCgpMTE0gaW52b2NhdGlvbiByZXF1ZXN0cyB1c2UgYG1v" + + "ZGVsOiAiPGZ1bmN0aW9uLWlkPi88bW9kZWwtbmFtZT4iYC4gVGhlIGZ1bmN0aW9uIElEIHNlbGVj" + + "dHMgdGhlIE5WQ0YgZnVuY3Rpb24sIGFuZCB0aGUgbW9kZWwgbmFtZSBpcyBmb3J3YXJkZWQgdXBz" + + "dHJlYW0uIENoYXQgY29tcGxldGlvbnMgYW5kIFJlc3BvbnNlcyBBUEkgcmVxdWVzdHMgY2FuIHVz" + + "ZSBgeC1tdWx0aS10dXJuLXNlc3Npb24taWRgIGZvciBzZXNzaW9uIHN0aWNraW5lc3M7IGVtYmVk" + + "ZGluZ3MgcmVxdWVzdHMgZG8gbm90LgoKIyMgYGZ1bmN0aW9uIHVwZGF0ZWAtc3BlY2lmaWMKCnwg" + + "RmxhZyB8IFB1cnBvc2UgfCBEZWZhdWx0IHwKfC0tLXwtLS18LS0tfAp8IGAtLXRhZ3MgVEFHWyxU" + + "QUddYCB8IFJlcGxhY2UgZnVuY3Rpb24gdGFncyB8IC0gfAp8IGAtLWxsbS1tb2RlbC11cGRhdGUg" + + "U1BFQ2AgfCBMTE0gbW9kZWwgdXBkYXRlOyBmb3JtYXQgYG5hbWU9PG1vZGVsPixyb3V0aW5nTWV0" + + "aG9kPTxtZXRob2Q+LHRva2VuUmF0ZUxpbWl0PTxsaW1pdD5gOyByZXBlYXRhYmxlLiBSb3V0aW5n" + + "IG1ldGhvZHMgbWF0Y2ggYC0tbGxtLW1vZGVsYC4gVG9rZW4gbGltaXQgZXhhbXBsZTogYDEwMDAt" + + "U2AuIFVzZSBpbnB1dCBKU09OIGZvciBjb21iaW5lZCB0b2tlbiBsaW1pdHMuIHwgLSB8CgpJbiBK" + + "U09OLCBgZnVuY3Rpb24gdXBkYXRlYCBhY2NlcHRzIGBtb2RlbFVwZGF0ZXNbXWAgZW50cmllcyB3" + + "aXRoIGBtb2RlbE5hbWVgIGFuZCBgbGxtQ29uZmlnLnJvdXRpbmdNZXRob2RgIGFuZC9vciBgbGxt" + + "Q29uZmlnLnRva2VuUmF0ZUxpbWl0YC4gYHVyaXNgIGFyZSBjcmVhdGUtdGltZSBtb2RlbCBtZXRh" + + "ZGF0YSBhbmQgYXJlIG5vdCBwYXJ0IG9mIG1vZGVsIHVwZGF0ZXMuCgojIyBgZnVuY3Rpb24gZGVw" + + "bG95IGNyZWF0ZWAtc3BlY2lmaWMKCmAtLWlucHV0LWZpbGUgRklMRWAgaXMgcmVjb21tZW5kZWQg" + + "KGZ1bGwgSlNPTiBzcGVjKS4gRm9yIGFkLWhvYyBvbmUtc2hvdCB1c2U6Cgp8IEZsYWcgfCBQdXJw" + + "b3NlIHwgRGVmYXVsdCB8CnwtLS18LS0tfC0tLXwKfCBgLS1mdW5jdGlvbi1pZCBJRGAgfCBGdW5j" + + "dGlvbiBJRCAocmVxdWlyZWQpIHwgLSB8CnwgYC0tZ3B1IE5BTUVgIHwgR1BVIGZhbWlseSB8IGBI" + + "MTAwYCB8CnwgYC0taW5zdGFuY2UtdHlwZSBUWVBFYCB8IFNLVSB8IGBOQ1AuR1BVLkgxMDBfMXhg" + + "IHwKfCBgLS1taW4taW5zdGFuY2VzIE5gIHwgTWluIHJlcGxpY2FzIHwgYDFgIHwKfCBgLS1tYXgt" + + "aW5zdGFuY2VzIE5gIHwgTWF4IHJlcGxpY2FzIHwgYDFgIHwKfCBgLS1tYXgtcmVxdWVzdC1jb25j" + + "dXJyZW5jeSBOYCB8IENvbmN1cnJlbmN5IHwgYDBgICh1bnNldDsgc2VydmVyIGRlZmF1bHQgYXBw" + + "bGllcykgfAp8IGAtLWNsdXN0ZXJzIE5BTUVbLE5BTUVdYCB8IFRhcmdldCBzcGVjaWZpYyBjb21w" + + "dXRlIGNsdXN0ZXJzIHwgKGFueSBtYXRjaGluZyBTS1UpIHwKCiMjIGB0YXNrIGNyZWF0ZWAtc3Bl" + + "Y2lmaWMKCmAtLWlucHV0LWZpbGUgRklMRWAgaXMgcmVjb21tZW5kZWQgZm9yIHJlcGVhdGFibGUg" + + "dGFzayBkZWZpbml0aW9ucy4gRm9yIGFkLWhvYyB1c2U6Cgp8IEZsYWcgfCBQdXJwb3NlIHwgTm90" + + "ZXMgfAp8LS0tfC0tLXwtLS18CnwgYC0tbmFtZSBOQU1FYCB8IFRhc2sgbmFtZSAocmVxdWlyZWQp" + + "IHwgMS0xMjggY2hhcnMsIGBeW2EtejAtOUEtWl1bYS16MC05QS1aXC1fXSokYCB8CnwgYC0tZ3B1" + + "IEdQVWAgfCBHUFUgbmFtZSAocmVxdWlyZWQgd2l0aG91dCBgLS1pbnB1dC1maWxlYCkgfCBFeGFt" + + "cGxlOiBgSDEwMGAgfAp8IGAtLWluc3RhbmNlLXR5cGUgVFlQRWAgfCBJbnN0YW5jZSB0eXBlIChy" + + "ZXF1aXJlZCB3aXRob3V0IGAtLWlucHV0LWZpbGVgKSB8IEV4YW1wbGU6IGBOQ1AuR1BVLkgxMDBf" + + "MXhgIHwKfCBgLS1pbWFnZSBJTUFHRWAgfCBDb250YWluZXIgaW1hZ2UgfCBNdXR1YWxseSBleGNs" + + "dXNpdmUgd2l0aCBgLS1oZWxtLWNoYXJ0YCB8CnwgYC0taGVsbS1jaGFydCBDSEFSVGAgfCBIZWxt" + + "IGNoYXJ0IFVSTCBvciBPQ0kgcmVmZXJlbmNlIHwgTXV0dWFsbHkgZXhjbHVzaXZlIHdpdGggYC0t" + + "aW1hZ2VgIHwKfCBgLS1pbnB1dC1maWxlIEZJTEVgIHwgSlNPTiB0YXNrIHNwZWMgZmlsZSB8IENM" + + "SSBmbGFncyBvdmVycmlkZSBKU09OIHZhbHVlcyB3aGVuIGJvdGggYXJlIHNldCB8CnwgYC0tYmFj" + + "a2VuZCBCQUNLRU5EYCB8IEJhY2tlbmQgLyBDU1AgfCAtIHwKfCBgLS1jbHVzdGVycyBOQU1FWyxO" + + "QU1FXWAgfCBTcGVjaWZpYyBjbHVzdGVycyB3aXRoaW4gdGhlIGluc3RhbmNlIHwgQ29tbWEtc2Vw" + + "YXJhdGVkIHwKfCBgLS1jb250YWluZXItYXJncyBBUkdTYCB8IEFyZ3MgcGFzc2VkIHdoZW4gbGF1" + + "bmNoaW5nIHRoZSBjb250YWluZXIgfCBTaW5nbGUgc3RyaW5nLCBlLmcuIGAiLS1lcG9jaHMgMTAg" + + "LS1iYXRjaC1zaXplIDMyImAgfAp8IGAtLWNvbnRhaW5lci1lbnYgTkFNRT12YWx1ZWAgfCBDb250" + + "YWluZXIgZW52aXJvbm1lbnQgdmFyaWFibGU7IHJlcGVhdGFibGUgfCAtIHwKfCBgLS1zZWNyZXRz" + + "IE5BTUU9dmFsdWVgIHwgU2VjcmV0IGVudmlyb25tZW50IHZhcmlhYmxlOyByZXBlYXRhYmxlOyBl" + + "bmNyeXB0ZWQgYXQgcmVzdCB8IC0gfAp8IGAtLW1heC1ydW50aW1lIERVUkFUSU9OYCB8IE1heCB3" + + "YWxsLWNsb2NrIHJ1biB0aW1lIChJU08gODYwMSwgZS5nLiBgUFQ0SGApIHwgTm8gZGVmYXVsdDsg" + + "b21pdCBmb3Igbm8gdGltZSBsaW1pdCB8CnwgYC0tbWF4LXF1ZXVlZCBEVVJBVElPTmAgfCBNYXgg" + + "dGltZSBpbiBxdWV1ZSBiZWZvcmUgY2FuY2VsbGF0aW9uIChJU08gODYwMSkgfCBTZXJ2ZXIgZGVm" + + "YXVsdCBgUFQ3MkhgIHwKfCBgLS10ZXJtaW5hdGlvbi1ncmFjZSBEVVJBVElPTmAgfCBHcmFjZSBw" + + "ZXJpb2QgYWZ0ZXIgc3RvcCBzaWduYWwgKElTTyA4NjAxKSB8IFNlcnZlciBkZWZhdWx0IGBQVDFI" + + "YCB8CnwgYC0tcmVzdWx0LXN0cmF0ZWd5IFVQTE9BRFx8Tk9ORWAgfCBIb3cgdG8gaGFuZGxlIHRh" + + "c2sgb3V0cHV0IGFydGlmYWN0cyB8IC0gfAp8IGAtLXJlc3VsdHMtbG9jYXRpb24gTE9DQVRJT05g" + + "IHwgUmVzdWx0IHVwbG9hZCB0YXJnZXQsIGZvcm1hdCBgb3JnLW5hbWUvW3RlYW0tbmFtZS9dbW9k" + + "ZWwtbmFtZWA7IHJlcXVpcmVkIHdoZW4gYC0tcmVzdWx0LXN0cmF0ZWd5PVVQTE9BRGAgfCAtIHwK" + + "fCBgLS1tb2RlbHMgTkFNRTpWRVJTSU9OOlVSSWAgfCBNb2RlbCBhcnRpZmFjdDsgcmVwZWF0YWJs" + + "ZSB8IC0gfAp8IGAtLXJlc291cmNlcyBOQU1FOlZFUlNJT046VVJJYCB8IFJlc291cmNlIGFydGlm" + + "YWN0OyByZXBlYXRhYmxlIHwgLSB8CnwgYC0tdGFncyBUQUdbLFRBR11gIHwgVGFzayB0YWdzIHwg" + + "Q29tbWEtc2VwYXJhdGVkIHwKfCBgLS1kZXNjcmlwdGlvbiBURVhUYCB8IFRhc2sgZGVzY3JpcHRp" + + "b24gfCAtIHwKfCBgLS1sb2dzLXRlbGVtZXRyeS1pZCBVVUlEYCB8IExvZ3MgdGVsZW1ldHJ5IGVu" + + "ZHBvaW50IElEIHwgLSB8CnwgYC0tbWV0cmljcy10ZWxlbWV0cnktaWQgVVVJRGAgfCBNZXRyaWNz" + + "IHRlbGVtZXRyeSBlbmRwb2ludCBJRCB8IC0gfAp8IGAtLXRyYWNlcy10ZWxlbWV0cnktaWQgVVVJ" + + "RGAgfCBUcmFjZXMgdGVsZW1ldHJ5IGVuZHBvaW50IElEIHwgLSB8CgpQSwcI/KOR4MYiAADGIgAA" + + "UEsDBBQACAAAAAAAIQAAAAAAAAAAAAAAAAA3AAkAZGF0YS9udmNmLXNlbGYtbWFuYWdlZC1jbGkv" + + "cmVmZXJlbmNlL3Ryb3VibGVzaG9vdGluZy5tZFVUBQABAKbOEiMgVHJvdWJsZXNob290aW5nCgpL" + + "bm93biBlcnJvcnMg4oaSIGRpYWdub3N0aWMgY29tbWFuZCDihpIgcmVtZWRpYXRpb24uIEtlZXAg" + + "aW4gc3luYyB3aXRoIHRoZSBzdHJ1Y3R1cmVkIGBwaGFzZV9mYWlsZWRgIGV2ZW50cyB0aGUgQ0xJ" + + "IGVtaXRzIChSRVEtMTUpIOKAlCBldmVyeSBlbnRyeSBiZWxvdyBzaG91bGQgbWFwIHRvIGFuIGBl" + + "cnJDYXRlZ29yeWAgYW5kIGEgYHJlbWVkaWF0aW9uYCBhcnJheS4KCiMjIFByZS1mbGlnaHQKCnwg" + + "U3ltcHRvbSB8IENhdXNlIHwgUmVtZWRpYXRpb24gfAp8LS0tfC0tLXwtLS18CnwgYGt1YmVjdGwg" + + "bm90IG9uIFBBVEhgIHwgT3BlcmF0b3IncyBgJFBBVEhgIGRvZXNuJ3QgaW5jbHVkZSBrdWJlY3Rs" + + "IHwgSW5zdGFsbCBrdWJlY3RsIDEuMjgrOiBodHRwczovL2t1YmVybmV0ZXMuaW8vZG9jcy90YXNr" + + "cy90b29scy9pbnN0YWxsLWt1YmVjdGwvIHwKfCBgaGVsbWZpbGUgbm90IG9uIFBBVEhgIHwgU2Ft" + + "ZSB8IGh0dHBzOi8vZ2l0aHViLmNvbS9oZWxtZmlsZS9oZWxtZmlsZSNpbnN0YWxsYXRpb24gfAp8" + + "IGBoZWxtIG5vdCBvbiBQQVRIYCB8IFNhbWUgfCBodHRwczovL2hlbG0uc2gvZG9jcy9pbnRyby9p" + + "bnN0YWxsLyB8CnwgYEdhdGV3YXkgQVBJIENSRHMgbm90IGluc3RhbGxlZGAgfCBlbnZveS1nYXRl" + + "d2F5IHByZXJlcSBtaXNzaW5nIHwgYGhlbG0gaW5zdGFsbCBlZyBvY2k6Ly9kb2NrZXIuaW8vZW52" + + "b3lwcm94eS9nYXRld2F5LWhlbG0gLS1uYW1lc3BhY2U9ZW52b3ktZ2F0ZXdheS1zeXN0ZW0gLS1j" + + "cmVhdGUtbmFtZXNwYWNlYCB8CnwgYGRlZmF1bHQgU3RvcmFnZUNsYXNzIG5vdCBhdmFpbGFibGVg" + + "IHwgQ2x1c3RlciBoYXMgbm8gZGVmYXVsdCBTQyB8IEFubm90YXRlIG9uZTogYGt1YmVjdGwgcGF0" + + "Y2ggc2MgPG5hbWU+IC1wICd7Im1ldGFkYXRhIjp7ImFubm90YXRpb25zIjp7InN0b3JhZ2VjbGFz" + + "cy5rdWJlcm5ldGVzLmlvL2lzLWRlZmF1bHQtY2xhc3MiOiJ0cnVlIn19fSdgIHwKfCBgR1BVIG9w" + + "ZXJhdG9yIG5vdCBpbnN0YWxsZWRgIChjb21wdXRlLXBsYW5lKSB8IG52aWRpYSBHUFUgb3BlcmF0" + + "b3IgbWlzc2luZyB8IEluc3RhbGwgcGVyIGh0dHBzOi8vZG9jcy5udmlkaWEuY29tL2RhdGFjZW50" + + "ZXIvY2xvdWQtbmF0aXZlL2dwdS1vcGVyYXRvci9sYXRlc3QvaW5zdGFsbC1ncHUtb3BlcmF0b3Iu" + + "aHRtbCwgT1IgdXNlIGBmYWtlLWdwdS1vcGVyYXRvcmAgZm9yIGRldiB8CnwgYEdQVSBub2RlIGxh" + + "YmVscyBtaXNzaW5nYCAoY29tcHV0ZS1wbGFuZSkgfCBOb2RlcyBuZWVkIGBudmlkaWEuY29tL2dw" + + "dS5mYW1pbHlgIGV0Yy4gfCBTZXQgYC0tazNzLW5vZGUtbGFiZWwgbnZpZGlhLmNvbS9ncHUuZmFt" + + "aWx5PWhvcHBlckBhZ2VudDpOYCBmb3IgazNkIHwKCiMjIEF1dGgKCnwgU3ltcHRvbSB8IENhdXNl" + + "IHwgUmVtZWRpYXRpb24gfAp8LS0tfC0tLXwtLS18CnwgYGFkbWluIHRva2VuIHJlcXVpcmVkYCAo" + + "aW5pdCBub3QgcnVuKSB8IE5vIGB+Ly5udmNmLWNsaS5zdGF0ZWAgYW5kIGAtLXRva2VuYCBub3Qg" + + "cGFzc2VkIHwgYG52Y2YtY2xpIGluaXRgIChpbnRlcmFjdGl2ZSkgb3IgYC0tdG9rZW49JEpXVCAt" + + "LW5vbi1pbnRlcmFjdGl2ZWAgKENJKSB8CnwgYFNpZ25lZCBKV1QgcmVqZWN0ZWQ6IEFub3RoZXIg" + + "YWxnb3JpdGhtIGV4cGVjdGVkLCBvciBubyBtYXRjaGluZyBrZXkocykgZm91bmRgIHwgU3RhbGUg" + + "c2Vzc2lvbi5qc29uIGZyb20gYSBkaWZmZXJlbnQgY29udHJvbCBwbGFuZSB8IGBybSB+Ly5udmNm" + + "LWNsaS5zdGF0ZWAgdGhlbiBgbnZjZi1jbGkgaW5pdGAgYWdhaW4gfAp8IGA0MDMgbWlzc2luZyBy" + + "ZXF1ZXN0ZWQgYXV0aG9yaXRpZXNgIChmdW5jdGlvbiBpbnZva2UpIHwgQWRtaW4gdG9rZW4gZG9l" + + "c24ndCBoYXZlIGBpbnZva2VfZnVuY3Rpb25gIHNjb3BlIHwgYG52Y2YtY2xpIGFwaS1rZXkgZ2Vu" + + "ZXJhdGUgLS1kZXNjcmlwdGlvbj3igKZgIHRoZW4gcmUtcnVuIGludm9rZSB8CgojIyBJbnN0YWxs" + + "IC8gYHVwYAoKfCBTeW1wdG9tIHwgQ2F1c2UgfCBSZW1lZGlhdGlvbiB8CnwtLS18LS0tfC0tLXwK" + + "fCBIZWxtIGB0aW1lZCBvdXQgd2FpdGluZyBmb3IgY2Fzc2FuZHJhYCB8IENhc3NhbmRyYSBTdGF0" + + "ZWZ1bFNldCBQVkMgc3R1Y2sgYFBlbmRpbmdgIHwgQ29uZmlybSBkZWZhdWx0IFN0b3JhZ2VDbGFz" + + "czsgY2hlY2sgYGt1YmVjdGwgZ2V0IHB2LHB2YyAtbiBjYXNzYW5kcmEtc3lzdGVtYCB8CnwgYElu" + + "dmFsaWQgR1BVICdOQ1AuR1BVLkgxMDAnIHNwZWNpZmllZGAgKGZ1bmN0aW9uIGRlcGxveSkgfCBX" + + "cm9uZyBmaWVsZCDigJQgYGdwdWAgaXMgdGhlIGZhbWlseSwgbm90IHRoZSBTS1UgfCBVc2UgYCJn" + + "cHUiOiAiSDEwMCJgLCBgImluc3RhbmNlVHlwZSI6ICJOQ1AuR1BVLkgxMDBfMXgiYCB8CnwgYHJl" + + "Z2lvbiBtdXN0IGJlIHByb3ZpZGVkYCAoY2x1c3RlciByZWdpc3RlciAvIGluc3RhbGwgLS1jb21w" + + "dXRlLXBsYW5lKSB8IGAtLXJlZ2lvbmAgZW1wdHkgKyBgQ0xVU1RFUl9SRUdJT05gIGVudiBlbXB0" + + "eSB8IFBhc3MgYC0tcmVnaW9uPXVzLXdlc3QtMWAgKG9yIGFueSBub24tZW1wdHkgdmFsdWUpIHwK" + + "fCBgcmVxdWlyZWRFbnYgIk5DQV9JRCIgaXMgbm90IHNldGAgKGhlbG1maWxlIGVycm9yIGR1cmlu" + + "ZyBjb21wdXRlLXBsYW5lIGFwcGx5KSB8IE9sZGVyIG52Y2YtY2xpIGJlZm9yZSBjb21taXQgYDZh" + + "YTU3MDRgOyBFeHRyYUVudiBub3QgcHJvcGFnYXRpbmcgTkNBX0lEIHwgVXBncmFkZSBgbnZjZi1j" + + "bGlgIHRvIGEgcmVsZWFzZSBhZnRlciBgNmFhNTcwNGAgfAp8IGBudmNhLW9wZXJhdG9yOiBJbWFn" + + "ZVB1bGxCYWNrT2ZmYCBmb3IgYG52Y2Etb3BlcmF0b3I6cHNhdGAgfCBJbWFnZSBub3QgaW4gY2x1" + + "c3RlciByZWdpc3RyeTsgbXVsdGktY2x1c3RlciBidWlsZCBpcyBsb2NhbCB8IGBrM2QgaW1hZ2Ug" + + "aW1wb3J0IG52Y3IuaW8vLi4uL252Y2Etb3BlcmF0b3I6cHNhdCAtYyA8Y2x1c3Rlcj5gIHwKCiMj" + + "IENvbXB1dGUtcGxhbmUgcnVudGltZQoKfCBTeW1wdG9tIHwgQ2F1c2UgfCBSZW1lZGlhdGlvbiB8" + + "CnwtLS18LS0tfC0tLXwKfCBOVkNBIGFnZW50IENyYXNoTG9vcEJhY2tPZmYgd2l0aCBgSFRUUCA0" + + "MDFgIG9uIGAvdjEvbnZjYS9jbHVzdGVycy8uLi4vcmVnaXN0ZXJgIHwgU3RhbGUgYG91dC88Y2x1" + + "c3Rlcj4tcmVnaXN0ZXItdmFsdWVzLnlhbWxgIGZyb20gcHJpb3IgcmVnaXN0ZXI7IGNsdXN0ZXIg" + + "SUQgZG9lc24ndCBtYXRjaCBJQ01TIHwgRGVsZXRlIHRoZSBzdGFsZSBmaWxlOyByZS1ydW4gYG52" + + "Y2YtY2xpIHNlbGYtaG9zdGVkIHVwYCAoaWRlbXBvdGVudCByZWdpc3RlciB3cml0ZXMgYSBmcmVz" + + "aCBmaWxlKSB8CnwgYE5vIGNsdXN0ZXIgZm91bmQgd2l0aCB2YWxpZCBKV0tTIGZvciBjbHVzdGVy" + + "IElEOiA8aWQ+YCAoSUNNUyBsb2cpIHwgSldLUyBpbiBJQ01TIGRvZXNuJ3QgbWF0Y2ggd2hhdCBj" + + "b21wdXRlLXBsYW5lIEs4cyBpcyBjdXJyZW50bHkgc2lnbmluZyB8IGBudmNmLWNsaSBjbHVzdGVy" + + "IHJvdGF0ZSAtLWNsdXN0ZXItaWQ9PGlkPmAgfAp8IEZ1bmN0aW9uIHBvZCBgSW1hZ2VQdWxsQmFj" + + "a09mZmAgaW4gYG52Y2YtYmFja2VuZGAgfCBJbWFnZS1jcmVkZW50aWFsLWhlbHBlciBjb25maWcg" + + "bWlzc2luZyBvciB3cm9uZyB8IGBrdWJlY3RsIGRlc2NyaWJlIHBvZCAtbiBudmNmLWJhY2tlbmQg" + + "PHBvZD5gOyBjaGVjayB0aGUgcHVsbCBzZWNyZXQgY29uZmlnIHwKfCBGdW5jdGlvbiBkZXBsb3kg" + + "c3R1Y2sgYERFUExPWUlOR2AgZm9yID41IG1pbiB8IE5BVFMgc3RyZWFtIGluaXQgbGFnIChjb2xk" + + "LWNsdXN0ZXIpIOKAlCB3YWl0LCBvciBjaGVjayBOQVRTIGF1dGgtY2FsbG91dCBoZWFsdGggfCBg" + + "a3ViZWN0bCBsb2dzIC1uIG5hdHMtc3lzdGVtIC1sIGFwcC5rdWJlcm5ldGVzLmlvL25hbWU9bmF0" + + "cy1hdXRoLWNhbGxvdXQtc2VydmljZWAgfAoKIyMgVGFza3MKCnwgU3ltcHRvbSB8IENhdXNlIHwg" + + "UmVtZWRpYXRpb24gfAp8LS0tfC0tLXwtLS18CnwgYHRhc2sgY3JlYXRlYCByZXR1cm5zIGBNaXNz" + + "aW5nIDxUWVBFPiByZWdpc3RyeSBjcmVkZW50aWFsIGZvciBob3N0bmFtZWAsIG9yIGtlZXBzIHVz" + + "aW5nIGEgcHJldmlvdXMgY3JlZGVudGlhbCB2YWx1ZSwgc2hvcnRseSBhZnRlciBgcmVnaXN0cnkt" + + "Y3JlZGVudGlhbCBhZGQvdXBkYXRlL2RlbGV0ZWAgd2hpbGUgYHJlZ2lzdHJ5LWNyZWRlbnRpYWwg" + + "bGlzdGAvYGdldGAgYWxyZWFkeSBzaG93IHRoZSBuZXcgdmFsdWUgfCBFeHBlY3RlZCBwcm9wYWdh" + + "dGlvbiBkZWxheTogTlZDVCBjYWNoZXMgdGhlIGFjY291bnQncyByZWdpc3RyeSBjcmVkZW50aWFs" + + "cyB3aXRoIGBudmN0Lm52Y2YuY2FjaGUtdHRsYCAoZGVmYXVsdCBgUFQ1TWAsIGFib3V0IDUgbWlu" + + "KSBhbmQgYXBwbGllcyB0aGUgY2hhbmdlIHdoZW4gdGhhdCBjYWNoZWQgY29weSByZWZyZXNoZXMg" + + "fCBXYWl0IHVwIHRvIGFib3V0IDUgbWluIGFuZCByZXRyeSwgb3IgYGt1YmVjdGwgLW4gbnZjZiBy" + + "b2xsb3V0IHJlc3RhcnQgZGVwbG95bWVudC9udmN0LWFwaWAgdG8gYXBwbHkgaW1tZWRpYXRlbHkg" + + "fApQSwcI864ThHQRAAB0EQAAUEsDBBQACAAAAAAAIQAAAAAAAAAAAAAAAAAsAAkAZGF0YS9udmNm" + + "LXNlbGYtbWFuYWdlZC1pbnN0YWxsYXRpb24vU0tJTEwubWRVVAUAAQCmzhItLS0KbmFtZTogbnZj" + + "Zi1zZWxmLW1hbmFnZWQtaW5zdGFsbGF0aW9uCmRlc2NyaXB0aW9uOiA+LQogIEluc3RhbGwgYW5k" + + "IG9wZXJhdGUgTlZDRiBzZWxmLWhvc3RlZCBjb250cm9sLXBsYW5lIGFuZCBzZXBhcmF0ZSBjb21w" + + "dXRlLXBsYW5lCiAgc3RhY2tzLiBDb3ZlcnMgSGVsbWZpbGUgdmFsdWVzIGFuZCBDTEkgcHJvZmls" + + "ZSBpbnN0YWxsYXRpb24gZmxvd3MsIHRlYXJkb3duLAogIHZhbHVlcyBvdmVycmlkZXMsIHB1bGwg" + + "c2VjcmV0cywgYW5kIHRyb3VibGVzaG9vdGluZy4gVXNlIGZvcgogIG52Y2Ytc2VsZi1tYW5hZ2Vk" + + "LXN0YWNrLCBudmNmLWNvbXB1dGUtcGxhbmUtc3RhY2ssIHNwbGl0IGNvbXB1dGUtcGxhbmUKICBp" + + "bnN0YWxsYXRpb24sIGNvbnRyb2wtcGxhbmUgaW5zdGFsbGF0aW9uLCBDTEktZ2VuZXJhdGVkIGNv" + + "bnRyb2wtcGxhbmUKICBwcm9maWxlcywgSGVsbWZpbGUsIHNlbGYtbWFuYWdlZCwgb3Igc2VsZi1o" + + "b3N0ZWQgZGVwbG95bWVudHMuIERvIE5PVCB1c2UgZm9yCiAgbG9jYWwgazNkIGVudmlyb25tZW50" + + "czsgdXNlIHRoZSBsb2NhbCBrM2QgZGV2ZWxvcG1lbnQgd29ya2Zsb3cgaW5zdGVhZC4KbGljZW5z" + + "ZTogQXBhY2hlLTIuMApjb21wYXRpYmlsaXR5OiBSZXF1aXJlcyBoZWxtZmlsZSA+PSAxLjEuMCA8" + + "IDEuMi4wLCBoZWxtID49IDMuMTIsIGhlbG0tZGlmZiBwbHVnaW4sIGt1YmVjdGwgbWF0Y2hpbmcg" + + "Y2x1c3RlciB2ZXJzaW9uCmF1dGhvcjogIm52Y2YtY29yZS1lbmcgPG52Y2YtY29yZS1lbmdAZXhj" + + "aGFuZ2UubnZpZGlhLmNvbT4iCnZlcnNpb246ICIxLjAuMCIKdGFnczogW252Y2YsIHNlbGYtbWFu" + + "YWdlZCwgaGVsbWZpbGUsIHNlbGYtaG9zdGVkLCBjb250cm9sLXBsYW5lLCBjb21wdXRlLXBsYW5l" + + "LCBjbGktcHJvZmlsZSwgaW5zdGFsbGF0aW9uLCBkZXBsb3ltZW50LCBwdWxsLXNlY3JldHNdCnRv" + + "b2xzOiBbU2hlbGwsIFJlYWQsIEVkaXQsIEdyZXAsIEdsb2JdCm1ldGFkYXRhOgogIGludGVybmFs" + + "OiBmYWxzZQogIGF1dGhvcjogIm52Y2YtY29yZS1lbmcgPG52Y2YtY29yZS1lbmdAZXhjaGFuZ2Uu" + + "bnZpZGlhLmNvbT4iCiAgdmVyc2lvbjogIjEuMCIKICB0YWdzOiBbbnZjZiwgc2VsZi1tYW5hZ2Vk" + + "LCBoZWxtZmlsZSwgc2VsZi1ob3N0ZWQsIGNvbnRyb2wtcGxhbmUsIGNvbXB1dGUtcGxhbmUsIGNs" + + "aS1wcm9maWxlLCBpbnN0YWxsYXRpb24sIGRlcGxveW1lbnQsIHB1bGwtc2VjcmV0c10KICBsYW5n" + + "dWFnZXM6IFtiYXNoLCB5YW1sXQogIGZyYW1ld29ya3M6IFtoZWxtZmlsZSwgaGVsbSwga3ViZWN0" + + "bF0KICBkb21haW46IGNsb3VkLWluZnJhc3RydWN0dXJlCi0tLQoKIyBOVkNGIFNlbGYtTWFuYWdl" + + "ZCBTdGFjayBPcGVyYXRpb25zCgpPcGVyYXRpb25hbCBndWlkZSBmb3IgbWF0Y2hpbmcgTlZDRiBj" + + "b250cm9sLXBsYW5lIGFuZCBjb21wdXRlLXBsYW5lIEhlbG1maWxlIGJ1bmRsZXMuCgojIyBJbnN0" + + "cnVjdGlvbnMKClVzZSB0aGlzIHNraWxsIGZvciBpbnN0YWxsLCB1cGdyYWRlLCBvciB0ZWFyZG93" + + "biB3b3JrIGluIG1hdGNoaW5nIGBudmNmLXNlbGYtbWFuYWdlZC1zdGFja2AgYW5kIGBudmNmLWNv" + + "bXB1dGUtcGxhbmUtc3RhY2tgIGJ1bmRsZXM7IGtlZXAgSGVsbWZpbGUgdmFsdWVzIGFuZCBDTEkg" + + "cHJvZmlsZSBoYW5kb2ZmcyBzZXBhcmF0ZS4gRm9yIGBmdW5jdGlvblR5cGU6ICJMTE0iYCwgcmVh" + + "ZCBbTExNIEZ1bmN0aW9uIEVuYWJsZW1lbnRdKHJlZmVyZW5jZXMvaGVsbWZpbGUtc3RydWN0dXJl" + + "Lm1kI2xsbS1mdW5jdGlvbi1lbmFibGVtZW50KS4KCiMjIFByZXJlcXVpc2l0ZXMKCkFzayBmb3Ig" + + "dGhlIGV4dHJhY3RlZCBgbnZjZi1zZWxmLW1hbmFnZWQtc3RhY2tgIHBhdGguIEZvciBzcGxpdCBp" + + "bnN0YWxsYXRpb24sCmFsc28gcmVxdWlyZSB0aGUgbWF0Y2hpbmctdmVyc2lvbiBgbnZjZi1jb21w" + + "dXRlLXBsYW5lLXN0YWNrYCBwYXRoLiBWZXJpZnkgYm90aDoKCmBgYGJhc2gKbHMgPGNvbnRyb2wt" + + "cGxhbmUtc3RhY2s+L2hlbG1maWxlLmQvIDxjb250cm9sLXBsYW5lLXN0YWNrPi9lbnZpcm9ubWVu" + + "dHMvIDxjb250cm9sLXBsYW5lLXN0YWNrPi9zZWNyZXRzLyA8Y29udHJvbC1wbGFuZS1zdGFjaz4v" + + "Z2xvYmFsLnlhbWwuZ290bXBsCmxzIDxjb21wdXRlLXBsYW5lLXN0YWNrPi9oZWxtZmlsZS5kLyA8" + + "Y29tcHV0ZS1wbGFuZS1zdGFjaz4vZW52aXJvbm1lbnRzLyA8Y29tcHV0ZS1wbGFuZS1zdGFjaz4v" + + "Z2xvYmFsLnlhbWwuZ290bXBsCmBgYAoKSWYgZWl0aGVyIGRpcmVjdG9yeSBpcyBtaXNzaW5nLCBk" + + "b3dubG9hZCBtYXRjaGluZyBidW5kbGUgdmVyc2lvbnMgZnJvbSBOR0M6CgpgYGBiYXNoCm5nYyBy" + + "ZWdpc3RyeSByZXNvdXJjZSBkb3dubG9hZC12ZXJzaW9uIDxvcmc+L252Y2Ytc2VsZi1tYW5hZ2Vk" + + "LXN0YWNrOjx2ZXJzaW9uPgpuZ2MgcmVnaXN0cnkgcmVzb3VyY2UgZG93bmxvYWQtdmVyc2lvbiA8" + + "b3JnPi9udmNmLWNvbXB1dGUtcGxhbmUtc3RhY2s6PHZlcnNpb24+CmBgYAoKQ29udHJvbC1wbGFu" + + "ZSBjb21tYW5kcyBiZWxvdyBhc3N1bWUgdGhlIGNvbnRyb2wtcGxhbmUgYnVuZGxlIHJvb3QuIFNw" + + "bGl0LWZsb3cKY29tbWFuZHMgYW5kIHJvb3Qgc3Vic3RpdHV0aW9uIGFyZSBpbgpbU3BsaXQgQ29t" + + "cHV0ZS1QbGFuZSBJbnN0YWxsYXRpb25dKHJlZmVyZW5jZXMvY29tcHV0ZS1wbGFuZS1pbnN0YWxs" + + "YXRpb24ubWQpLgoKIyMgQmVmb3JlIFlvdSBTdGFydAoKVmVyaWZ5IHRvb2xpbmcgYW5kIGNvbnRl" + + "eHQgYmVmb3JlIGFueSBvcGVyYXRpb246CgpgYGBiYXNoCmhlbG1maWxlIC0tdmVyc2lvbiAgICMg" + + "TXVzdCBiZSAxLjEueCAoMS4yLjAgcmVtb3ZlZCBzZXF1ZW50aWFsIG1vZGUpCmhlbG0gdmVyc2lv" + + "biAgICAgICAgICMgTXVzdCBiZSA+PSAzLjEyCmhlbG0gcGx1Z2luIGxpc3QgICAgICMgTXVzdCBp" + + "bmNsdWRlIGhlbG0tZGlmZiA+PSAzLjExCmt1YmVjdGwgdmVyc2lvbiAgICAgICMgQ2xpZW50IG11" + + "c3QgYmUgd2l0aGluIDEgbWlub3IgdmVyc2lvbiBvZiBjbHVzdGVyCmBgYAoKQ29udHJvbC1wbGFu" + + "ZSBjb21tYW5kcyBydW4gZnJvbSB0aGUgZXh0cmFjdGVkIGBudmNmLXNlbGYtbWFuYWdlZC1zdGFj" + + "ay9gIHJvb3Q6CgpgYGBiYXNoCmNkIHBhdGgvdG8vbnZjZi1zZWxmLW1hbmFnZWQtc3RhY2sKbHMg" + + "aGVsbWZpbGUuZC8gZW52aXJvbm1lbnRzLyBzZWNyZXRzLyBnbG9iYWwueWFtbC5nb3RtcGwKYGBg" + + "CgpJZGVudGlmeSB0aGUgZW52aXJvbm1lbnQgZnJvbSBgZW52aXJvbm1lbnRzLzxuYW1lPi55YW1s" + + "YCBhbmQKYHNlY3JldHMvPG5hbWU+LXNlY3JldHMueWFtbGA7IGZvciBFS1MsIHVzZSB0aGUgY2Fu" + + "b25pY2FsCltDU1AgRW5kLXRvLUVuZCBFeGFtcGxlXShodHRwczovL2RvY3MubnZpZGlhLmNvbS9u" + + "dmNmL3YwLjYuMC1yYy9jc3AtZW5kLXRvLWVuZC1leGFtcGxlKS4KCiMjIEhvdyBWYWx1ZXMgRmxv" + + "dwoKVW5kZXJzdGFuZGluZyB2YWx1ZSBwcmVjZWRlbmNlIHByZXZlbnRzIHRoZSBtb3N0IGNvbW1v" + + "biBjb25maWd1cmF0aW9uIG1pc3Rha2VzLgoKYGBgCmVudmlyb25tZW50cy9iYXNlLnlhbWwgICAg" + + "ICAgICAgKGRlZmF1bHRzKQogICAgLT4gbWVyZ2VkIHdpdGgKZW52aXJvbm1lbnRzLzxlbnY+Lnlh" + + "bWwgICAgICAgICAoeW91ciBvdmVycmlkZXMpCiAgICAtPiBjb25zdW1lZCBieQpnbG9iYWwueWFt" + + "bC5nb3RtcGwgICAgICAgICAgICAgIChHbyB0ZW1wbGF0ZSwgY29uc3RydWN0cyBwZXItY2hhcnQg" + + "dmFsdWVzKQogICAgLT4gY29uc3VtZWQgYnkKc2VjcmV0cy88ZW52Pi1zZWNyZXRzLnlhbWwgICAg" + + "ICAoc2Vuc2l0aXZlIHZhbHVlcykKICAgIC0+IG92ZXJyaWRkZW4gYnkKcmVsZWFzZSBpbmxpbmUg" + + "dmFsdWVzOiBibG9ja3MgICAoaGlnaGVzdCBwcmVjZWRlbmNlKQpgYGAKCkNyaXRpY2FsOiBgZ2xv" + + "YmFsLnlhbWwuZ290bXBsYCBvbmx5IHBhc3NlcyB0aHJvdWdoIHNwZWNpZmljIGtleXMgdG8gZWFj" + + "aCBjaGFydCAoaW1hZ2UgcmVnaXN0cmllcywgbm9kZSBzZWxlY3RvcnMsIHN0b3JhZ2UsIHJlcGxp" + + "Y2EgY291bnRzKS4gU2V0dGluZyBhbiBhcmJpdHJhcnkgY2hhcnQgdmFsdWUgaW4gdGhlIGVudmly" + + "b25tZW50IGZpbGUgd2lsbCBiZSBzaWxlbnRseSBpZ25vcmVkIGlmIGBnbG9iYWwueWFtbC5nb3Rt" + + "cGxgIGRvZXMgbm90IHByb3BhZ2F0ZSBpdC4KClRvIG92ZXJyaWRlIGFyYml0cmFyeSBjaGFydCB2" + + "YWx1ZXMsIHVzZSBhIGhlbG1maWxlIHJlbGVhc2UgYHZhbHVlczpgIGJsb2NrLiBTZWUgW092ZXJy" + + "aWRpbmcgSGVsbSBDaGFydCBWYWx1ZXNdKCNvdmVycmlkaW5nLWhlbG0tY2hhcnQtdmFsdWVzKS4K" + + "CiMjIENsZWFuIEluc3RhbGxhdGlvbgoKIyMjIDEuIENyZWF0ZSBuYW1lc3BhY2VzIGFuZCBpbWFn" + + "ZSBwdWxsIHNlY3JldHMgKGlmIHVzaW5nIGEgcHJpdmF0ZSByZWdpc3RyeSkKCmBgYGJhc2gKZm9y" + + "IG5zIGluIGNhc3NhbmRyYS1zeXN0ZW0gbmF0cy1zeXN0ZW0gbnZjZiBhcGkta2V5cyBlc3Mgc2lz" + + "IHZhdWx0LXN5c3RlbSBjZXJ0LW1hbmFnZXI7IGRvCiAga3ViZWN0bCBjcmVhdGUgbmFtZXNwYWNl" + + "ICIkbnMiIC0tZHJ5LXJ1bj1jbGllbnQgLW8geWFtbCB8IGt1YmVjdGwgYXBwbHkgLWYgLQpkb25l" + + "CgojIE9ubHkgaWYgcHVsbGluZyBmcm9tIGEgcHJpdmF0ZSByZWdpc3RyeSAoZS5nLiwgTkdDIG52" + + "Y3IuaW8pCmV4cG9ydCBOR0NfQVBJX0tFWT0iPHlvdXIta2V5PiIKZm9yIG5zIGluIGNhc3NhbmRy" + + "YS1zeXN0ZW0gbmF0cy1zeXN0ZW0gbnZjZiBhcGkta2V5cyBlc3Mgc2lzIHZhdWx0LXN5c3RlbSBj" + + "ZXJ0LW1hbmFnZXI7IGRvCiAga3ViZWN0bCBjcmVhdGUgc2VjcmV0IGRvY2tlci1yZWdpc3RyeSBu" + + "dmNyLWNyZWRzIFwKICAgIC0tZG9ja2VyLXNlcnZlcj1udmNyLmlvIFwKICAgIC0tZG9ja2VyLXVz" + + "ZXJuYW1lPSckb2F1dGh0b2tlbicgXAogICAgLS1kb2NrZXItcGFzc3dvcmQ9IiROR0NfQVBJX0tF" + + "WSIgXAogICAgLS1uYW1lc3BhY2U9IiRucyIgXAogICAgLS1kcnktcnVuPWNsaWVudCAtbyB5YW1s" + + "IHwga3ViZWN0bCBhcHBseSAtZiAtCmRvbmUKYGBgCgpJZiB1c2luZyBwdWxsIHNlY3JldHMsIHlv" + + "dSBtdXN0IGFsc28gY29uZmlndXJlIGVhY2ggaGVsbWZpbGUgcmVsZWFzZSB0byByZWZlcmVuY2Ug" + + "dGhlbS4gU2VlIFtJbWFnZSBQdWxsIFNlY3JldHNdKCNpbWFnZS1wdWxsLXNlY3JldHMpLgoKIyMj" + + "IDIuIEF1dGhlbnRpY2F0ZSBoZWxtIHRvIHlvdXIgY2hhcnQgcmVnaXN0cnkKCkJvdGggYGRvY2tl" + + "ciBsb2dpbmAgQU5EIGBoZWxtIHJlZ2lzdHJ5IGxvZ2luYCBhcmUgcmVxdWlyZWQgZm9yIE5HQy4g" + + "SGVsbWZpbGUgdXNlcyBoZWxtIChub3QgZG9ja2VyKSB0byBwdWxsIE9DSSBjaGFydHMsIHNvIHRo" + + "ZSBoZWxtIGNyZWRlbnRpYWwgc3RvcmUgbXVzdCBiZSBhdXRoZW50aWNhdGVkIHNlcGFyYXRlbHku" + + "CgpgYGBiYXNoCiMgTkdDIC0tIGJvdGggY29tbWFuZHMgYXJlIHJlcXVpcmVkCmRvY2tlciBsb2dp" + + "biBudmNyLmlvIC11ICckb2F1dGh0b2tlbicgLXAgIiROR0NfQVBJX0tFWSIKaGVsbSByZWdpc3Ry" + + "eSBsb2dpbiBudmNyLmlvIC11ICckb2F1dGh0b2tlbicgLXAgIiROR0NfQVBJX0tFWSIKCiMgRUNS" + + "CmF3cyBlY3IgZ2V0LWxvZ2luLXBhc3N3b3JkIC0tcmVnaW9uIDxyZWdpb24+IHwgXAogIGhlbG0g" + + "cmVnaXN0cnkgbG9naW4gLS11c2VybmFtZSBBV1MgLS1wYXNzd29yZC1zdGRpbiA8YWNjb3VudD4u" + + "ZGtyLmVjci48cmVnaW9uPi5hbWF6b25hd3MuY29tCmBgYAoKPiBOb3RlOiBgaGVsbSByZWdpc3Ry" + + "eSBsb2dpbmAga2VlcHMgb25seSB0aGUgbGFzdCBsb2dpbiBwZXIgaG9zdCAobXVsdGktb3JnIGdv" + + "dGNoYSkuCj4gVGhlIHN0YWNrIGFuZCB0aGUgY2FjaGVzIHNwYW4gc2V2ZXJhbCBOR0Mgb3JncyB0" + + "aGF0IG5lZWQgZGlmZmVyZW50IGtleXMsIGJ1dCB0aGV5IGFsbAo+IGxpdmUgdW5kZXIgdGhlIG9u" + + "ZSBob3N0IGBudmNyLmlvYC4gQSBzZWNvbmQgYGhlbG0gcmVnaXN0cnkgbG9naW4gbnZjci5pb2Ag" + + "KG9yCj4gYGRvY2tlciBsb2dpbmApIHdpdGggYSBkaWZmZXJlbnQga2V5IHNpbGVudGx5IG92ZXJ3" + + "cml0ZXMgdGhlIGZpcnN0LCBzbyBwdWxscyBmb3IgdGhlCj4gZmlyc3Qgb3JnIHRoZW4gZmFpbCB3" + + "aXRoIGEgbWlzbGVhZGluZyBgNDAzIEFjY2VzcyBEZW5pZWRgIChub3QgYSA0MDE6IHRoZSBhdXRo" + + "Cj4gc3VjY2VlZGVkLCBpdCdzIHRoZSB3cm9uZy1vcmcga2V5KS4gSWYgeW91IHB1bGwgY2hhcnRz" + + "L2ltYWdlcyBmcm9tIG1vcmUgdGhhbiBvbmUgb3JnLAo+IGVpdGhlciByZS1ydW4gdGhlIGxvZ2lu" + + "IHdpdGggdGhlIGNvcnJlY3Qga2V5IGltbWVkaWF0ZWx5IGJlZm9yZSBlYWNoIHB1bGwsIG9yIHBh" + + "c3MKPiBgLS11c2VybmFtZSAnJG9hdXRodG9rZW4nIC0tcGFzc3dvcmQgPGtleT5gIHBlciBgaGVs" + + "bSBwdWxsYCBpbnZvY2F0aW9uIGluc3RlYWQgb2YgcmVseWluZwo+IG9uIHRoZSBzdG9yZWQgbG9n" + + "aW4uIChQdWxsaW5nIGV2ZXJ5dGhpbmcgZnJvbSBhIHNpbmdsZSByZWdpc3RyeSBtaXJyb3IgYXZv" + + "aWRzIHRoaXMKPiBlbnRpcmVseS4pCgojIyMgMmIuIChSZWNvbW1lbmRlZCkgUHVsbCBmcm9tIGEg" + + "cmVnaXN0cnkgdGhlIGNsdXN0ZXIgYXV0aGVudGljYXRlcyB0byBhdXRvbWF0aWNhbGx5CgpJZiB5" + + "b3UgbWlycm9yIHRoZSBOVkNGIGltYWdlcyBpbnRvIGEgcmVnaXN0cnkgdGhhdCB0aGUgY2x1c3Rl" + + "ciBjYW4gcHVsbCBmcm9tIHdpdGhvdXQgYW4KZXhwbGljaXQgaW1hZ2UgcHVsbCBzZWNyZXQgKGZv" + + "ciBleGFtcGxlLCBhIHJlZ2lzdHJ5IHdoZXJlIHRoZSBub2RlIG9yIHdvcmtsb2FkIGlkZW50aXR5" + + "IGlzCmdyYW50ZWQgcHVsbCBhY2Nlc3MgYXV0b21hdGljYWxseSksIHBvaW50IHRoZSBzdGFjayBh" + + "dCBpdCBhbmQgc2tpcCB0aGUgY3JlZGVudGlhbCBzdGVwcwphYm92ZS4KCjEuIFBvaW50IHRoZSBz" + + "dGFjayBhdCB0aGUgbWlycm9yIGluIGBlbnZpcm9ubWVudHMvPGVudj4ueWFtbGA6CgogICBgYGB5" + + "YW1sCiAgIGdsb2JhbDoKICAgICBpbWFnZToKICAgICAgIHJlZ2lzdHJ5OiA8eW91ci1yZWdpc3Ry" + + "eT4gICAgICAgICAgICAjIGUuZy4gcmVnaXN0cnkuZXhhbXBsZS5jb20KICAgICAgIHJlcG9zaXRv" + + "cnk6IDxtaXJyb3Itc3ViLXBhdGg+CiAgICAgaGVsbToKICAgICAgIHNvdXJjZXM6ICAgICAgICAg" + + "ICAgICAgICAgICAgICAgICAgICAgIyBvbmx5IGlmIHlvdSBhbHNvIG1pcnJvcmVkIHRoZSBoZWxt" + + "IGNoYXJ0cwogICAgICAgICByZWdpc3RyeTogPHlvdXItcmVnaXN0cnk+CiAgICAgICAgIHJlcG9z" + + "aXRvcnk6IDxtaXJyb3Itc3ViLXBhdGg+CiAgIGBgYAoKICAgPiBUaGUgbWFuaWZlc3QgaGFzIGEg" + + "bWl4IG9mIE9DSSBhbmQgbm9uLU9DSSBhcnRpZmFjdHMsIHNvIGNvbnZlcnQgbm9uLU9DSSBjaGFy" + + "dHMgYmVmb3JlCiAgID4gbWlycm9yaW5nLiBDb250YWluZXIgaW1hZ2VzIChgbnZjci5pby8uLi5g" + + "KSBhcmUgYWxyZWFkeSBPQ0kgYW5kIG1pcnJvciBhcy1pcy4gU29tZSBIZWxtCiAgID4gY2hhcnRz" + + "LCB0aG91Z2gsIGFyZSBwdWJsaXNoZWQgdG8gYW4gYGh0dHBzOi8vYCBIZWxtIHJlcG9zaXRvcnkg" + + "KGZvciBleGFtcGxlCiAgID4gYGhlbG0ubmdjLm52aWRpYS5jb21gKS4gVGhvc2UgYXJlIG5vdCBP" + + "Q0kgYW5kIGNhbm5vdCBiZSByZXNvbHZlZCBieSBgZ2xvYmFsLmhlbG0uc291cmNlc2AKICAgPiAo" + + "T0NJKSBvciBtaXJyb3JlZCBkaXJlY3RseS4gQmVmb3JlIHBvaW50aW5nIHRoZSBzdGFjayBhdCB5" + + "b3VyIG1pcnJvciwgY29udmVydCBlYWNoCiAgID4gYGh0dHBzOi8vYCBjaGFydCB0byBPQ0k6IGBo" + + "ZWxtIHJlcG8gYWRkYC9gaGVsbSBwdWxsYCB0aGUgYC50Z3pgLCB0aGVuCiAgID4gYGhlbG0gcHVz" + + "aCA8Y2hhcnQ+LnRneiBvY2k6Ly88eW91ci1yZWdpc3RyeT4vPG1pcnJvci1zdWItcGF0aD5gLiBP" + + "bmx5IE9DSSBjaGFydHMgY2FuIGxpdmUKICAgPiB1bmRlciBgZ2xvYmFsLmhlbG0uc291cmNlc2Au" + + "CgoyLiBTa2lwIHRoZSBjcmVkZW50aWFsIHN0ZXBzIGFib3ZlLiBXaGVuIHRoZSBjbHVzdGVyIGF1" + + "dGhlbnRpY2F0ZXMgdG8gdGhlIHJlZ2lzdHJ5CiAgIGF1dG9tYXRpY2FsbHkgKHRoZSBub2RlIG9y" + + "IHdvcmtsb2FkIGlkZW50aXR5IGhhcyBwdWxsIGFjY2VzcyksIHRoZSBwdWxsIG5lZWRzIG5vCiAg" + + "IEt1YmVybmV0ZXMgc2VjcmV0LCBzbyB5b3UgZG8gbm90IG5lZWQ6IHRoZSBwZXItbmFtZXNwYWNl" + + "IGBudmNyLWNyZWRzYCBmcm9tIHN0ZXAgMQogICAoc3RpbGwgY3JlYXRlIHRoZSBuYW1lc3BhY2Vz" + + "LCBqdXN0IG5vdCB0aGUgc2VjcmV0KSwgdGhlIGBnbG9iYWwuaW1hZ2VQdWxsU2VjcmV0c2AgZW50" + + "cnksCiAgIG9yIHRoZSBgZG9ja2VyIGxvZ2luYC9gaGVsbSByZWdpc3RyeSBsb2dpbiBudmNyLmlv" + + "YCBmcm9tIHN0ZXAgMi4KCiAgID4gT25lIHJlc2lkdWFsIGNyZWRlbnRpYWw6IG52Y2YtYXBpIHN0" + + "aWxsIHZhbGlkYXRlcyB0aGUgdXNlciBmdW5jdGlvbiBpbWFnZSBhdAogICA+IGBmdW5jdGlvbiBj" + + "cmVhdGVgIHZpYSB0aGUgYWNjb3VudCByZWdpc3RyeSBjcmVkZW50aWFsLCBzbyB0aGF0IGNyZWRl" + + "bnRpYWwgbXVzdCBwb2ludCBhdAogICA+IHdoaWNoZXZlciByZWdpc3RyeSBob2xkcyB0aGUgdXNl" + + "ciBpbWFnZSAoc2V0IGl0IHRvIHlvdXIgbWlycm9yIGlmIHRoZSBpbWFnZSBpcyBtaXJyb3JlZAog" + + "ICA+IHRoZXJlKS4KCiMjIyAzLiBTZXQgdGhlIHJvdXRlIGRvbWFpbgoKYGdsb2JhbC5kb21haW5g" + + "IHNldHMgdGhlIGhvc3RuYW1lIHN1ZmZpeCBmb3Igcm91dGVzIHN1Y2ggYXMgYGFwaS48ZG9tYWlu" + + "PmAuIEl0IGRvZXMgbm90IGNvbmZpZ3VyZSB0aGUgR2F0ZXdheSBvciBpdHMgbG9hZCBiYWxhbmNl" + + "ci4gUXVlcnkgdGhlIGV4YWN0IGV4aXN0aW5nIEdhdGV3YXk6CgpgYGBiYXNoCkdBVEVXQVlfQURE" + + "UkVTUz0kKGt1YmVjdGwgZ2V0IGdhdGV3YXkgPGdhdGV3YXktbmFtZT4gLW4gPGdhdGV3YXktbmFt" + + "ZXNwYWNlPiAtbyBqc29ucGF0aD0ney5zdGF0dXMuYWRkcmVzc2VzWzBdLnZhbHVlfScpCnRlc3Qg" + + "LW4gIiRHQVRFV0FZX0FERFJFU1MiCmBgYAoKVGhlIGFkZHJlc3MgbWF5IGJlIGEgaG9zdG5hbWUg" + + "b3IgSVAuIENsb3VkIHByb3ZpZGVyIGFuZCBHYXRld2F5IGNvbmZpZ3VyYXRpb24gZGV0ZXJtaW5l" + + "IHRoZSBsb2FkIGJhbGFuY2VyIHR5cGUgYW5kIGFkZHJlc3MgZm9ybWF0LiBUaGUgc2VsZi1tYW5h" + + "Z2VkIHN0YWNrIGRvZXMgbm90IHNlbGVjdCBlaXRoZXIuCgpGb3IgdGVtcG9yYXJ5IHRlc3Rpbmcg" + + "d2l0aG91dCBETlMsIHVzZSBhIHN0YWJsZSByZXNlcnZlZCBzdWZmaXggc3VjaCBhcyBgZ2xvYmFs" + + "LmRvbWFpbjogIm52Y2YudGVzdCJgLCBjb25uZWN0IHRvIGBHQVRFV0FZX0FERFJFU1NgLCBhbmQg" + + "c2VuZCBgSG9zdDogYXBpLm52Y2YudGVzdGAuIEZvciBwcm9kdWN0aW9uLCB1c2UgeW91ciBiYXNl" + + "IEROUyBkb21haW4gYW5kIHBvaW50IGl0cyByb3V0ZSByZWNvcmRzIHRvIGBHQVRFV0FZX0FERFJF" + + "U1NgLiBJZiB0aGUgZW5kcG9pbnQgbGF0ZXIgY2hhbmdlcywga2VlcCBgZ2xvYmFsLmRvbWFpbmAg" + + "c3RhYmxlIGFuZCB1cGRhdGUgb25seSBETlMgb3IgdGhlIGNsaWVudCBkZXN0aW5hdGlvbi4gU2Vl" + + "IEV4YW1wbGUgNCBpbiBbZXhhbXBsZXMubWRdKGV4YW1wbGVzLm1kKS4KCiMjIyA0LiBQcmV2aWV3" + + "IGFuZCBkZXBsb3kKCmBgYGJhc2gKSEVMTUZJTEVfRU5WPTxlbnYtbmFtZT4gaGVsbWZpbGUgdGVt" + + "cGxhdGUgICAjIFByZXZpZXcgcmVuZGVyZWQgbWFuaWZlc3RzCkhFTE1GSUxFX0VOVj08ZW52LW5h" + + "bWU+IGhlbG1maWxlIHN5bmMgICAgICAgIyBEZXBsb3kKYGBgCgo+IFNldCBCT1RIIENhc3NhbmRy" + + "YSBwYXNzd29yZHMgaW4gdGhlIHNlY3JldHMgZmlsZS4gVGhlIHNlY3JldHMgZmlsZSBkb2N1bWVu" + + "dHMKPiBgREVGQVVMVF9DQVNTQU5EUkFfUEFTU1dPUkRgLCBidXQgdGhlIGNhc3NhbmRyYSBjaGFy" + + "dCBoYXMgYSBzZWNvbmQgY3JlZGVudGlhbCwKPiBgY2Fzc2FuZHJhLnNlcnZpY2VSb2xlUGFzc3dv" + + "cmRgLCB0aGF0IGRlZmF1bHRzIHRvIGBjaEBuZzNtM2AuIElmIHlvdSBzZXQgb25seQo+IGBERUZB" + + "VUxUX0NBU1NBTkRSQV9QQVNTV09SRGAsIHRoZSBzZXJ2aWNlIHJvbGUga2VlcHMgdGhhdCBkZWZh" + + "dWx0IGFuZCBldmVyeSBEQi1iYWNrZWQKPiBzZXJ2aWNlIGNyYXNoLWxvb3BzIHdpdGggYEJhZCBj" + + "cmVkZW50aWFsc2Agb25jZSBpdCB0cmllcyB0byBhdXRoZW50aWNhdGUuIFNldAo+IGBjYXNzYW5k" + + "cmEuc2VydmljZVJvbGVQYXNzd29yZGAgdG8gdGhlIHNhbWUgdmFsdWUgYXMgYERFRkFVTFRfQ0FT" + + "U0FORFJBX1BBU1NXT1JEYC4KCiMjIyA1LiBEZXBsb3ltZW50IHBoYXNlcwoKSGVsbWZpbGUgZGVw" + + "bG95cyBpbiBvcmRlciB3aXRoIGRlcGVuZGVuY2llczoKCnwgUGhhc2UgfCBTZWxlY3RvciB8IFNl" + + "cnZpY2VzIHwgV2FpdCB0aW1lIHwKfC0tLS0tLS18LS0tLS0tLS0tLXwtLS0tLS0tLS0tfC0tLS0t" + + "LS0tLS0tfAp8IDEgfCBgcmVsZWFzZS1ncm91cD1kZXBlbmRlbmNpZXNgIHwgTkFUUywgT3BlbkJh" + + "bywgQ2Fzc2FuZHJhIHwgNS0xMCBtaW4gfAp8IDIgfCBgcmVsZWFzZS1ncm91cD1zZXJ2aWNlc2Ag" + + "fCBBUEksIFNJUywgRVNTLCBpbnZvY2F0aW9uLCBncnBjLXByb3h5LCBub3RhcnksIGFwaS1rZXlz" + + "LCBvcHRpb25hbCBMTE0gZ2F0ZXdheS9yb3V0ZXIsIG9wdGlvbmFsIFZhbml0eSBHYXRld2F5LCBO" + + "VkNGIFVJIHdoZW4gdGhlIHN0YWNrIHBhY2thZ2UgaW5jbHVkZXMgdGhlIGFkZG9uIHwgNS0xMCBt" + + "aW4gfAp8IDMgfCBgcmVsZWFzZS1ncm91cD1pbmdyZXNzYCB8IEdhdGV3YXkgcm91dGVzIHwgMS0y" + + "IG1pbiB8CnwgNCB8IGByZWxlYXNlLWdyb3VwPW9ic2VydmFiaWxpdHlgIHwgT2JzZXJ2YWJpbGl0" + + "eSBzdGFjayAoaWYgZW5hYmxlZCkgfCAxLTIgbWluIHwKCk1vbml0b3IgaW4gYSBzZXBhcmF0ZSB0" + + "ZXJtaW5hbDoKCmBgYGJhc2gKa3ViZWN0bCBnZXQgcG9kcyAtQSAtdwpgYGAKCiMjIyA2LiBFbmFi" + + "bGUgVmFuaXR5IEdhdGV3YXkgKG9wdGlvbmFsKQoKVmFuaXR5IEdhdGV3YXkgaXMgZGlzYWJsZWQg" + + "YnkgZGVmYXVsdCBhbmQgaXMgb25seSBuZWVkZWQgZm9yIGN1c3RvbWVyLWZhY2luZwpob3N0bmFt" + + "ZXMgb3IgcGF0aCBtYXBwaW5ncyBpbiBmcm9udCBvZiB0aGUgc3RhbmRhcmQgTlZDRiBBUEkgYW5k" + + "IGludm9jYXRpb24Kcm91dGVzLiBJdCBpcyBhdmFpbGFibGUgb25seSBpbiBzdGFjayBwYWNrYWdl" + + "cyB0aGF0IGluY2x1ZGUgdGhlIFZhbml0eSBHYXRld2F5CmFkZG9uLiBJZiB0aGUgZXh0cmFjdGVk" + + "IHN0YWNrIHBhY2thZ2UgZG9lcyBub3QgY29udGFpbiBhIGB2YW5pdHktZ2F0ZXdheWAKcmVsZWFz" + + "ZSBhbmQgYHZhbml0eUdhdGV3YXlgIHJvdXRlIHZhbHVlcywgc2tpcCB0aGVzZSBjb21tYW5kcyBh" + + "bmQgdXNlIGEgbmV3ZXIKc3RhY2sgcGFja2FnZSB0aGF0IGluY2x1ZGVzIHRoZW0uCgpJZiB0aGUg" + + "c3RhY2sgcGFja2FnZSBpbmNsdWRlcyB0aGUgYWRkb24sIGVuYWJsZSBpdCBpbgpgZW52aXJvbm1l" + + "bnRzLzxlbnYtbmFtZT4ueWFtbGA6CgpgYGB5YW1sCmFkZG9uczoKICB2YW5pdHlHYXRld2F5Ogog" + + "ICAgZW5hYmxlZDogdHJ1ZQogICAgbWFwcGluZ0NvbmZpZzoge30KYGBgCgpUaGUgZGVmYXVsdCBy" + + "b3V0ZSBob3N0IGlzIGB2YW5pdHkuPGRvbWFpbj5gIGFuZCB0aGUgYmFja2VuZCBpcwpgdmFuaXR5" + + "LWdhdGV3YXkubnZjZjo4MDgwYC4gUHV0IGRlcGxveW1lbnQtc3BlY2lmaWMgaG9zdCBhbmQgcGF0" + + "aCBtYXBwaW5ncyB1bmRlcgpgYWRkb25zLnZhbml0eUdhdGV3YXkubWFwcGluZ0NvbmZpZ2AuIElm" + + "IHlvdSBuZWVkIGN1c3RvbSB2YW5pdHkgaG9zdHMgaW5zdGVhZCBvZgpgdmFuaXR5Ljxkb21haW4+" + + "YCwgdXNlIHRoZSByb3V0ZSBob3N0bmFtZSBvdmVycmlkZXMgc3VwcG9ydGVkIGJ5IHRoZSBzdGFj" + + "awpwYWNrYWdlIGFuZCBjcmVhdGUgbWF0Y2hpbmcgRE5TIHJlY29yZHMuCgpBZnRlciBjb25maXJt" + + "aW5nIHRoZSBwYWNrYWdlIGluY2x1ZGVzIHRoZSBgdmFuaXR5LWdhdGV3YXlgIHJlbGVhc2UsIHBy" + + "ZXZpZXcgYW5kCmFwcGx5IHRoZSBzZXJ2aWNlIGFuZCByb3V0ZToKCmBgYGJhc2gKSEVMTUZJTEVf" + + "RU5WPTxlbnYtbmFtZT4gaGVsbWZpbGUgLS1zZWxlY3RvciBuYW1lPXZhbml0eS1nYXRld2F5IHRl" + + "bXBsYXRlCkhFTE1GSUxFX0VOVj08ZW52LW5hbWU+IGhlbG1maWxlIC0tc2VsZWN0b3IgbmFtZT12" + + "YW5pdHktZ2F0ZXdheSBzeW5jCkhFTE1GSUxFX0VOVj08ZW52LW5hbWU+IGhlbG1maWxlIC0tc2Vs" + + "ZWN0b3IgcmVsZWFzZS1ncm91cD1pbmdyZXNzIHN5bmMKYGBgCgpWZXJpZnkgdGhlIHJvdXRlIG9u" + + "bHkgd2hlbiB0aGUgYWRkb24gaXMgcHJlc2VudCBhbmQgZW5hYmxlZDoKCmBgYGJhc2gKa3ViZWN0" + + "bCBnZXQgZGVwbG95LHN2YyAtbiBudmNmIC1sIGFwcC5rdWJlcm5ldGVzLmlvL25hbWU9dmFuaXR5" + + "LWdhdGV3YXkKa3ViZWN0bCBnZXQgaHR0cHJvdXRlIC1BIHwgZ3JlcCAtaSB2YW5pdHkKY3VybCAt" + + "SCAiSG9zdDogdmFuaXR5Ljxkb21haW4+IiAiaHR0cDovLzxnYXRld2F5LWFkZHJlc3M+L2hlYWx0" + + "aCIKYGBgCgpEbyBub3QgZW5hYmxlIFZhbml0eSBHYXRld2F5IGZvciBzdGFuZGFyZCBBUEksIEFQ" + + "SSBLZXlzLCBpbnZvY2F0aW9uLCBMTE0KaW52b2NhdGlvbiwgb3IgZ1JQQyB0cmFmZmljLiBUaG9z" + + "ZSByb3V0ZXMgYXJlIHByb3ZpZGVkIGJ5IHRoZSBiYXNlIGdhdGV3YXkKcm91dGVzLgoKIyMjIDcu" + + "IEVuYWJsZSBOVkNGIFVJIChvcHRpb25hbCkKCk5WQ0YgVUkgaXMgYW4gb3B0aW9uYWwsIGN1c3Rv" + + "bWVyLWZhY2luZyBhZG1pbi1wYW5lbCBVSS4gSXQgaXMgZGlzYWJsZWQgYnkKZGVmYXVsdCBhbmQg" + + "YXZhaWxhYmxlIG9ubHkgaW4gc3RhY2sgcGFja2FnZXMgdGhhdCBpbmNsdWRlIHRoZSBOVkNGIFVJ" + + "IGFkZG9uLiBJZgp5b3VyIGV4dHJhY3RlZCBzdGFjayBwYWNrYWdlIGRvZXMgbm90IGNvbnRhaW4g" + + "YSBgbnZjZi11aWAgcmVsZWFzZSBhbmQgYG52Y2ZVaWAKcm91dGUgdmFsdWVzLCBza2lwIHRoaXMg" + + "c2VjdGlvbi4gVGhlIE5WQ0YgVUkgYWRtaW4gcGFuZWwgaXMgY3VycmVudGx5CnVuYXV0aGVudGlj" + + "YXRlZDsgZG8gbm90IGV4cG9zZSBpdCB0byB0aGUgcHVibGljIGludGVybmV0LgoKRm9yIGVuYWJs" + + "ZW1lbnQsIG5hbWVzcGFjZSBhbmQgcHVsbCBzZWNyZXQgc2V0dXAsIGFwcGx5LCBhbmQgdmVyaWZp" + + "Y2F0aW9uIHN0ZXBzLApzZWUgW05WQ0YgVUkgQWRkb25dKHJlZmVyZW5jZXMvbnZjZi11aS1hZGRv" + + "bi5tZCkuCgojIyMgOC4gSW5zdGFsbCB0aGUgc2VwYXJhdGUgY29tcHV0ZS1wbGFuZSBzdGFjawoK" + + "VGhlIGNvbnRyb2wtcGxhbmUgc3RhY2sgZG9lcyBub3QgaW5zdGFsbCBjb21wdXRlLXBsYW5lIGNv" + + "bXBvbmVudHMuIEFmdGVyIGl0IGlzIGhlYWx0aHksIGNob29zZSBleGFjdGx5IG9uZSBjb21wdXRl" + + "LXBsYW5lIGhhbmRvZmY6CgotIEhlbG1maWxlIHZhbHVlcyBmbG93OiBhdXRob3Igc2VwYXJhdGUg" + + "ZW52aXJvbm1lbnQgZmlsZXMsIHRoZW4gcmVnaXN0ZXIgYW5kCiAgaW5zdGFsbCB3aXRoIHRoZSBj" + + "b21wdXRlLXBsYW5lIE1ha2VmaWxlLgotIENMSSBwcm9maWxlIGZsb3c6IHVzZSB0aGUgcHJvZmls" + + "ZSBnZW5lcmF0ZWQgYnkgdGhlIENMSSBjb250cm9sLXBsYW5lIGluc3RhbGwsCiAgdGhlbiBydW4g" + + "dGhlIGNvbXBsZXRlIENMSSByZWdpc3RlciBhbmQgaW5zdGFsbCBjb21tYW5kcy4KCkRvIG5vdCBt" + + "aXggdGhlc2UgaGFuZG9mZnMuIEZvbGxvdyBbU3BsaXQgQ29tcHV0ZS1QbGFuZSBJbnN0YWxsYXRp" + + "b25dKHJlZmVyZW5jZXMvY29tcHV0ZS1wbGFuZS1pbnN0YWxsYXRpb24ubWQpCmZvciBjb21tYW5k" + + "cywgRUtTIHJvdXRpbmcsIHB1bGwgc2VjcmV0cywgdmVyaWZpY2F0aW9uLCBhbmQgdGVhcmRvd24g" + + "b3JkZXIuCgojIyBDbGVhbiBUZWFyZG93bgoKRGVzdHJveSBldmVyeSBjb21wdXRlIHBsYW5lIGJl" + + "Zm9yZSB0aGUgY29udHJvbCBwbGFuZSwgdXNpbmcgdGhlIHRlYXJkb3duIGZvcgp0aGUgc2FtZSBo" + + "YW5kb2ZmOyBzZWUgW1NwbGl0IENvbXB1dGUtUGxhbmUgSW5zdGFsbGF0aW9uXShyZWZlcmVuY2Vz" + + "L2NvbXB1dGUtcGxhbmUtaW5zdGFsbGF0aW9uLm1kI3RlYXJkb3duKS4KClNjb3BlOiBPbmx5IGRl" + + "c3Ryb3kgcmVsZWFzZXMgbWFuYWdlZCBieSB0aGlzIGNvbnRyb2wtcGxhbmUgaGVsbWZpbGUgc3Rh" + + "Y2suIFRoZSBOVkNGIHJlbGVhc2VzIGFyZTogYG5hdHNgLCBgb3BlbmJhby1zZXJ2ZXJgLCBgY2Fz" + + "c2FuZHJhYCwgYGFwaS1rZXlzYCwgYHNpc2AsIGBhcGlgLCBgaW52b2NhdGlvbi1zZXJ2aWNlYCwg" + + "YGdycGMtcHJveHlgLCBgZXNzLWFwaWAsIGBub3Rhcnktc2VydmljZWAsIG9wdGlvbmFsIGB2YW5p" + + "dHktZ2F0ZXdheWAsIGBudmNmLXVpYCwgYGFkbWluLWlzc3Vlci1wcm94eWAsIGFuZCBgaW5ncmVz" + + "c2A7IGBjZXJ0LW1hbmFnZXJgIGlzIGluY2x1ZGVkIG9ubHkgd2hlbiBgY2VydE1hbmFnZXIuZW5h" + + "YmxlZDogdHJ1ZWAuIFRoZSBjb250cm9sLXBsYW5lIG5hbWVzcGFjZSBpbnZlbnRvcnkgYWxzbyBp" + + "bmNsdWRlcyBgY2VydC1tYW5hZ2VyYCwgYnV0IGRlZmF1bHQgbmFtZXNwYWNlIGNsZWFudXAgcHJl" + + "c2VydmVzIGl0LiBOYW1lc3BhY2UgcHJlc2VydmF0aW9uIGRvZXMgbm90IHByZXNlcnZlIHRoZSBI" + + "ZWxtIHJlbGVhc2UuIEV4dGVybmFsIGNlcnQtbWFuYWdlciBtdXN0IHVzZSBgY2VydE1hbmFnZXIu" + + "ZW5hYmxlZDogZmFsc2VgOyBvdGhlcndpc2UgSGVsbWZpbGUgdHJlYXRzIHRoZSByZWxlYXNlIGFz" + + "IHN0YWNrLW1hbmFnZWQuIERvIG5vdCBkZWxldGUgb3RoZXIgaGVsbSByZWxlYXNlcyBvciBuYW1l" + + "c3BhY2VzIG9uIHRoZSBjbHVzdGVyLgoKQmVmb3JlIGNvbnRyb2wtcGxhbmUgZGVzdHJveSwgaWRl" + + "bnRpZnkgd2hldGhlciBjZXJ0LW1hbmFnZXIgaXMgZXh0ZXJuYWwuIEZvciBhbiBleHRlcm5hbCBp" + + "bnN0YWxsYXRpb24sIHJlcXVpcmUgZWZmZWN0aXZlIGBjZXJ0TWFuYWdlci5lbmFibGVkOiBmYWxz" + + "ZWAgYW5kIGFib3J0IGlmIGl0IGlzIHRydWUuIEZvciBhbiBpbnRlbmRlZCBzdGFjay1tYW5hZ2Vk" + + "IHJlbGVhc2Ugd2l0aCBlZmZlY3RpdmUgYGNlcnRNYW5hZ2VyLmVuYWJsZWQ6IHRydWVgLCB2ZXJp" + + "ZnkgbWF0Y2hpbmcgc3RhY2sgSGVsbSByZWxlYXNlIG1ldGFkYXRhIGFuZCBhYm9ydCBvbiBtaXNz" + + "aW5nIG9yIG1pc21hdGNoZWQgZXZpZGVuY2UuIFByZXNlcnZlIHRoZSBuYW1lc3BhY2UgYnkgZGVm" + + "YXVsdDsgb25seSBwbGFuIGl0cyByZW1vdmFsIGFmdGVyIHZlcmlmeWluZyBuYW1lc3BhY2UgcHJv" + + "dmVuYW5jZSBhbmQgZ2V0dGluZyBleHBsaWNpdCBjb25maXJtYXRpb24uCgojIyMgU3RhbmRhcmQg" + + "dGVhcmRvd24KClJ1biBmcm9tIGluc2lkZSB0aGUgYG52Y2Ytc2VsZi1tYW5hZ2VkLXN0YWNrL2Ag" + + "ZGlyZWN0b3J5OgoKYGBgYmFzaApIRUxNRklMRV9FTlY9PGVudi1uYW1lPiBoZWxtZmlsZSBkZXN0" + + "cm95CmBgYAoKIyMjIERlbGV0ZSBuYW1lc3BhY2VzCgpgYGBiYXNoCmZvciBucyBpbiBjYXNzYW5k" + + "cmEtc3lzdGVtIG5hdHMtc3lzdGVtIG52Y2YgYXBpLWtleXMgZXNzIHNpcyBudmNmLXVpIHZhdWx0" + + "LXN5c3RlbTsgZG8KICBrdWJlY3RsIGRlbGV0ZSBuYW1lc3BhY2UgIiRucyIgLS1pZ25vcmUtbm90" + + "LWZvdW5kCmRvbmUKYGBgCgojIyMgVmVyaWZ5IGNsZWFuCgpgYGBiYXNoCmt1YmVjdGwgZ2V0IG5z" + + "IHwgZ3JlcCAtRSAnKGNhc3NhbmRyYXxuYXRzfHZhdWx0fG52Y2Z8YXBpLWtleXN8ZXNzfHNpcykn" + + "CiMgU2hvdWxkIHJldHVybiBlbXB0eQpgYGAKCiMjIE92ZXJyaWRpbmcgSGVsbSBDaGFydCBWYWx1" + + "ZXMKCiMjIyBFbnZpcm9ubWVudCBmaWxlIChsaW1pdGVkKQoKV29ya3Mgb25seSBmb3Iga2V5cyB0" + + "aGF0IGBnbG9iYWwueWFtbC5nb3RtcGxgIHByb3BhZ2F0ZXMgKGUuZy4sIGBjYXNzYW5kcmEucmVw" + + "bGljYUNvdW50YCwgYGdsb2JhbC5zdG9yYWdlQ2xhc3NgLCBgZ2xvYmFsLmltYWdlYCkuCgojIyMg" + + "UmVsZWFzZSB2YWx1ZXMgYmxvY2sgKGFueSBjaGFydCB2YWx1ZSkKCkVkaXQgdGhlIHJlbGVhc2Ug" + + "aW4gYGhlbG1maWxlLmQvKi55YW1sLmdvdG1wbGAgYW5kIGFkZCBhIGB2YWx1ZXM6YCBibG9jay4g" + + "SW4gdGhlIGV4YW1wbGVzIGJlbG93LCBgPHByaXZhdGUtdmFsdWVzPmAgcmVmZXJzIHRvIHRoZSBg" + + "c2VjcmV0cy9gIGRpcmVjdG9yeSBhdCB0aGUgaGVsbWZpbGUgc3RhY2sgcm9vdC4KCmBgYHlhbWwK" + + "LSBuYW1lOiBjYXNzYW5kcmEKICB2ZXJzaW9uOiAwLjguMAogIGNvbmRpdGlvbjogY2Fzc2FuZHJh" + + "LmVuYWJsZWQKICBuYW1lc3BhY2U6IGNhc3NhbmRyYS1zeXN0ZW0KICA8PDogKmRlcGVuZGVuY3kK" + + "ICB2YWx1ZXM6CiAgICAtIC4uL2dsb2JhbC55YW1sLmdvdG1wbAogICAgLSAuLi88cHJpdmF0ZS12" + + "YWx1ZXM+L3t7IHJlcXVpcmVkRW52ICJIRUxNRklMRV9FTlYiIH19LXNlY3JldHMueWFtbAogICAg" + + "LSBjYXNzYW5kcmE6CiAgICAgICAgcmVzb3VyY2VzOgogICAgICAgICAgbGltaXRzOgogICAgICAg" + + "ICAgICBjcHU6ICI4IgogICAgICAgICAgICBtZW1vcnk6IDgxOTJNaQogICAgICAgICAgcmVxdWVz" + + "dHM6CiAgICAgICAgICAgIGNwdTogIjIiCiAgICAgICAgICAgIG1lbW9yeTogNDA5Nk1pCmBgYAoK" + + "WUFNTCBtZXJnZSBnb3RjaGE6IFdoZW4gYSByZWxlYXNlIHVzZXMgYDw8OiAqZGVwZW5kZW5jeWAg" + + "b3IgYGluaGVyaXRgLCBzcGVjaWZ5aW5nIGB2YWx1ZXM6YCByZXBsYWNlcyB0aGUgdGVtcGxhdGUn" + + "cyB2YWx1ZXMgbGlzdC4gWW91IG11c3QgcmUtaW5jbHVkZSBgZ2xvYmFsLnlhbWwuZ290bXBsYCBh" + + "bmQgdGhlIHNlY3JldHMgZmlsZS4KCiMjIyBQcmV2aWV3IGFuZCBhcHBseSBhIHNpbmdsZSByZWxl" + + "YXNlCgpgYGBiYXNoCkhFTE1GSUxFX0VOVj08ZW52PiBoZWxtZmlsZSAtLXNlbGVjdG9yIG5hbWU9" + + "Y2Fzc2FuZHJhIHRlbXBsYXRlICAjIFByZXZpZXcKSEVMTUZJTEVfRU5WPTxlbnY+IGhlbG1maWxl" + + "IC0tc2VsZWN0b3IgbmFtZT1jYXNzYW5kcmEgc3luYyAgICAgICMgQXBwbHkKYGBgCgojIyBJbWFn" + + "ZSBQdWxsIFNlY3JldHMKClRoZXJlIGFyZSB0aHJlZSBkaXN0aW5jdCBjcmVkZW50aWFsIHR5cGVz" + + "LiBEbyBub3QgY29uZmxhdGUgdGhlbSwgYW5kIG1pbmQgdGhlCmZvcm1hdCBydWxlIGJlbG93ICh0" + + "d28gb2YgdGhlbSBmYWlsIGV2ZW4gd2l0aCB0aGUgY29ycmVjdCBrZXkgaWYgdGhlIGZvcm1hdCBp" + + "cyB3cm9uZyk6Cgp8IHwgQ29udHJvbCBQbGFuZSBQdWxsIFNlY3JldHMgfCBBUEkgQm9vdHN0cmFw" + + "IFJlZ2lzdHJ5IENyZWRzIHwgU2lkZWNhciBJbWFnZS1QdWxsIFNlY3JldCB8CnwtLS18LS0tfC0t" + + "LXwtLS18CnwgUHVycG9zZSB8IEs4cyBwdWxscyBOVkNGIHNlcnZpY2UgaW1hZ2VzIHwgbnZjZi1h" + + "cGkgdmFsaWRhdGVzIHRoZSB1c2VyIGZ1bmN0aW9uIGltYWdlIGF0IGBmdW5jdGlvbiBjcmVhdGVg" + + "IHwgbnZjZi1hcGkgcHVsbHMgdGhlIHBsYXRmb3JtIHNpZGVjYXJzIGluamVjdGVkIGludG8gZXZl" + + "cnkgd29ya2VyIHBvZCB8CnwgV2hlcmUgfCBLOHMgYGRvY2tlci1yZWdpc3RyeWAgU2VjcmV0cyAr" + + "IEt5dmVybm8gQ2x1c3RlclBvbGljeSB8IGA8cHJpdmF0ZS12YWx1ZXM+LzxlbnY+LXNlY3JldHMu" + + "eWFtbGAgKGFjY291bnQtYm9vdHN0cmFwKSB8IGBOVkNGX0FQSV9TSURFQ0FSU19JTUFHRV9QVUxM" + + "X1NFQ1JFVGAgaW4gYDxlbnY+LXNlY3JldHMueWFtbGAgLT4gT3BlbkJhbyBgc2VydmljZXMvbnZj" + + "Zi1hcGkva3Yvc2lkZWNhcnMvaW1hZ2UtcHVsbC1zZWNyZXRgIChmaWVsZCBgc2VjcmV0YCkgfAp8" + + "IEZvcm1hdCB8IHN0YW5kYXJkIGAuZG9ja2VyY29uZmlnanNvbmAgKGt1YmVjdGwgYnVpbGRzIGl0" + + "IGZvciB5b3UpIHwgYGJhc2U2NCgiJG9hdXRodG9rZW46PGtleT4iKWAgfCBgYmFzZTY0KCIkb2F1" + + "dGh0b2tlbjo8a2V5PiIpYCB8Cgo+IE5vdGU6IHRoZSBhY2NvdW50LWJvb3RzdHJhcCBjcmVkIGFu" + + "ZCB0aGUgc2lkZWNhciBzZWNyZXQgYXJlIE5PVCBhCj4gZG9ja2VyY29uZmlnanNvbi4gVGhlIHNl" + + "Y3JldHMgdGVtcGxhdGUgc2hpcHMgdGhlIHBsYWNlaG9sZGVyCj4gYFJFUExBQ0VfV0lUSF9CQVNF" + + "NjRfRE9DS0VSX0NSRURFTlRJQUxgLCB3aGljaCByZWFkcyBhcyAiYmFzZTY0IG9mIGEgZG9ja2Vy" + + "Y29uZmlnanNvbi4iCj4gSXQgaXNuJ3QuIEJvdGggdmFsdWVzIGFyZSBjb25zdW1lZCBhcyBhIHJh" + + "dyBkb2NrZXIgYGF1dGhgIHN0cmluZzogbnZjZi1hcGkgdGFrZXMgdGhlCj4gdmFsdWUgdmVyYmF0" + + "aW0gYW5kIGRyb3BzIGl0IGludG8gdGhlIGBhdXRoYCBmaWVsZCBvZiB0aGUgZG9ja2VyY29uZmln" + + "IGl0IGJ1aWxkcy4gU28gdGhlCj4gdmFsdWUgbXVzdCBiZSBgYmFzZTY0KCIkb2F1dGh0b2tlbjo8" + + "a2V5PiIpYCwgZS5nLiBgcHJpbnRmICckb2F1dGh0b2tlbjolcycgIiRLRVkiIHwgb3BlbnNzbCBi" + + "YXNlNjQgLUFgLAo+IG5vdCBgYmFzZTY0KDxkb2NrZXJjb25maWdqc29uPilgLgo+ICAtIFdyb25n" + + "IGFjY291bnQtYm9vdHN0cmFwIHZhbHVlOiBgZnVuY3Rpb24gY3JlYXRlYCByZXR1cm5zCj4gICAg" + + "YDQwMCAibXVzdCBiZSBiYXNlNjQgZW5jb2RlZCB1c2VybmFtZTpwYXNzd29yZCBmb3JtYXQiYC4K" + + "PiAgLSBXcm9uZyBzaWRlY2FyIHZhbHVlOiBldmVyeSB3b3JrZXIncyBzaWRlY2FyIHB1bGwgZ2V0" + + "cyBhIG1hbGZvcm1lZCBjcmVkZW50aWFsIGFuZAo+ICAgIGA0MDNgcywgcmVnYXJkbGVzcyBvZiB3" + + "aGljaCBrZXkgaXMgaW5zaWRlLiBUaGUgc3ltcHRvbSBsb29rcyBsaWtlIGEgYmFkIG9yIHdyb25n" + + "LW9yZwo+ICAgIGtleSwgYnV0IHRoZSBrZXkgaXMgZmluZSBhbmQgdGhlIGVuY29kaW5nIGlzIHRo" + + "ZSBidWcuIFRvIHJlcGFpciBhbiBhbHJlYWR5LWluc3RhbGxlZAo+ICAgIHN0YWNrIHdpdGhvdXQg" + + "YSBmdWxsIHJlLXN5bmM6Cj4gICAgYGBgYmFzaAo+ICAgIEFVVEg9JChwcmludGYgJyRvYXV0aHRv" + + "a2VuOiVzJyAiJEtFWSIgfCBvcGVuc3NsIGJhc2U2NCAtQSkKPiAgICBiYW8ga3YgcHV0IHNlcnZp" + + "Y2VzL252Y2YtYXBpL2t2L3NpZGVjYXJzL2ltYWdlLXB1bGwtc2VjcmV0IHNlY3JldD0iJEFVVEgi" + + "Cj4gICAgIyBpZiBOVklESUEgQ2xvdWQgVGFza3MgaXMgZW5hYmxlZCwgcmVwZWF0IGZvciBzZXJ2" + + "aWNlcy9udmN0LWFwaS9rdi9zaWRlY2Fycy9pbWFnZS1wdWxsLXNlY3JldAo+ICAgIGt1YmVjdGwg" + + "cm9sbG91dCByZXN0YXJ0IC1uIG52Y2YgZGVwbG95L252Y2YtYXBpICAgIyBwaWNrcyB1cCB0aGUg" + + "bmV3IHNpZGVjYXIgY3JlZAo+ICAgIGBgYAoKPiBOb3RlIChtdWx0aS1vcmcpOiB3aGVuIHB1bGxp" + + "bmcgZnJvbSBOR0MgKG5vdCBhIG1pcnJvciksIHRoZSB1c2VyIGZ1bmN0aW9uIGltYWdlIGFuZAo+" + + "IHRoZSBwbGF0Zm9ybSBzaWRlY2FycyBvZnRlbiBsaXZlIGluIGRpZmZlcmVudCBudmNyLmlvIG9y" + + "Z3MsIGVhY2ggbmVlZGluZyBhIGRpZmZlcmVudAo+IGtleSwgc28gdGhlIGFjY291bnQtYm9vdHN0" + + "cmFwIGNyZWQgKGZ1bmN0aW9uIGltYWdlKSBhbmQgdGhlIHNpZGVjYXIgc2VjcmV0IChzaWRlY2Fy" + + "cykKPiBhcmUgZnJlcXVlbnRseSB0d28gZGlmZmVyZW50IGtleXMuIE1pcnJvcmluZyBldmVyeXRo" + + "aW5nIGludG8gYSBzaW5nbGUgcmVnaXN0cnkgdGhlCj4gY2x1c3RlciBhdXRoZW50aWNhdGVzIHRv" + + "IGF1dG9tYXRpY2FsbHkgY29sbGFwc2VzIHRoaXMgdG8gb25lIGNyZWRlbnRpYWwgcGF0aC4KCiMj" + + "IyBDb25maWd1cmluZyB3aXRoIEt5dmVybm8gKHJlY29tbWVuZGVkKQoKVXNlIGEgS3l2ZXJubyBt" + + "dXRhdGluZyBhZG1pc3Npb24gcG9saWN5IHRvIGF1dG9tYXRpY2FsbHkgaW5qZWN0IGBpbWFnZVB1" + + "bGxTZWNyZXRzYCBpbnRvIGFsbCBwb2RzIGluIE5WQ0YgbmFtZXNwYWNlcy4gVGhpcyB3b3JrcyB1" + + "bmlmb3JtbHkgZm9yIGFsbCBjaGFydHMgLS0gbm8gcGVyLWNoYXJ0IGNvbmZpZ3VyYXRpb24gb3Ig" + + "aGVsbWZpbGUgbW9kaWZpY2F0aW9ucyBuZWVkZWQuCgpgYGBiYXNoCiMgMS4gSW5zdGFsbCBLeXZl" + + "cm5vCmhlbG0gcmVwbyBhZGQga3l2ZXJubyBodHRwczovL2t5dmVybm8uZ2l0aHViLmlvL2t5dmVy" + + "bm8vCmhlbG0gcmVwbyB1cGRhdGUKaGVsbSBpbnN0YWxsIGt5dmVybm8ga3l2ZXJuby9reXZlcm5v" + + "IC1uIGt5dmVybm8gLS1jcmVhdGUtbmFtZXNwYWNlCgojIDIuIENyZWF0ZSBwdWxsIHNlY3JldCBp" + + "biBlYWNoIG5hbWVzcGFjZQpleHBvcnQgTkdDX0FQSV9LRVk9Ijx5b3VyLWtleT4iCmZvciBucyBp" + + "biBjYXNzYW5kcmEtc3lzdGVtIG5hdHMtc3lzdGVtIG52Y2YgYXBpLWtleXMgZXNzIHNpcyB2YXVs" + + "dC1zeXN0ZW0gY2VydC1tYW5hZ2VyOyBkbwogIGt1YmVjdGwgY3JlYXRlIHNlY3JldCBkb2NrZXIt" + + "cmVnaXN0cnkgbnZjci1jcmVkcyBcCiAgICAtLWRvY2tlci1zZXJ2ZXI9bnZjci5pbyBcCiAgICAt" + + "LWRvY2tlci11c2VybmFtZT0nJG9hdXRodG9rZW4nIFwKICAgIC0tZG9ja2VyLXBhc3N3b3JkPSIk" + + "TkdDX0FQSV9LRVkiIFwKICAgIC0tbmFtZXNwYWNlPSIkbnMiIFwKICAgIC0tZHJ5LXJ1bj1jbGll" + + "bnQgLW8geWFtbCB8IGt1YmVjdGwgYXBwbHkgLWYgLQpkb25lCgojIDMuIEFwcGx5IHRoZSBLeXZl" + + "cm5vIENsdXN0ZXJQb2xpY3kKa3ViZWN0bCBhcHBseSAtZiBreXZlcm5vLWltYWdlcHVsbHNlY3Jl" + + "dC1wb2xpY3kueWFtbApgYGAKClRoZSBwb2xpY3kgbXV0YXRlcyBldmVyeSBwb2QgYXQgYWRtaXNz" + + "aW9uIHRpbWUsIGFkZGluZyBgaW1hZ2VQdWxsU2VjcmV0czogW3tuYW1lOiBudmNyLWNyZWRzfV1g" + + "LiBWZXJpZnkgd2l0aDoKCmBgYGJhc2gKa3ViZWN0bCBnZXQgcG9kIC1uIDxuYW1lc3BhY2U+IDxw" + + "b2QtbmFtZT4gLW8ganNvbnBhdGg9J3suc3BlYy5pbWFnZVB1bGxTZWNyZXRzfScKIyBTaG91bGQg" + + "c2hvdzogW3sibmFtZSI6Im52Y3ItY3JlZHMifV0KYGBgCgpOb3QgbmVlZGVkIGlmIHVzaW5nIGEg" + + "Q1NQIGJ1aWx0LWluIGNyZWRlbnRpYWwgaGVscGVyIChlLmcuLCBFQ1Igd2l0aCBJQU0gbm9kZSBy" + + "b2xlcykuCgpGb3IgdGhlIEt5dmVybm8gcG9saWN5IFlBTUwgYW5kIHB1bGwgc2VjcmV0IGNyZWF0" + + "aW9uIHNjcmlwdCwgc2VlIFtyZWZlcmVuY2VzL3B1bGwtc2VjcmV0cy5tZF0ocmVmZXJlbmNlcy9w" + + "dWxsLXNlY3JldHMubWQpLgoKIyMgRGVidWdnaW5nCgojIyMgUXVpY2sgc3RhdHVzIGNoZWNrCgpg" + + "YGBiYXNoCmt1YmVjdGwgZ2V0IHBvZHMgLUEgLW8gd2lkZSAgICAgICAgICAgICAgICAgICAgICAg" + + "ICMgQWxsIHBvZHMKaGVsbSBsaXN0IC1BICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg" + + "ICAgICAgICMgQWxsIGhlbG0gcmVsZWFzZXMKa3ViZWN0bCBnZXQgZXZlbnRzIC1uIDxucz4gLS1z" + + "b3J0LWJ5PScubGFzdFRpbWVzdGFtcCcgICMgUmVjZW50IGV2ZW50cwpgYGAKCiMjIyBDb21tb24g" + + "ZmFpbHVyZSBwYXR0ZXJucwoKfCBTeW1wdG9tIHwgQ2F1c2UgfCBGaXggfAp8LS0tLS0tLS0tfC0t" + + "LS0tLS18LS0tLS18CnwgYEltYWdlUHVsbEJhY2tPZmZgICsgYDQwMSBVbmF1dGhvcml6ZWRgIHwg" + + "TWlzc2luZyBvciB3cm9uZyBwdWxsIHNlY3JldCB8IENoZWNrIHNlY3JldCBleGlzdHMsIGNoZWNr" + + "IFNBIGhhcyBpbWFnZVB1bGxTZWNyZXRzIHwKfCBgSW5pdDowLzFgIHN0dWNrIG9uIHNlcnZpY2Ug" + + "cG9kcyB8IFZhdWx0LWFnZW50IHdhaXRpbmcgZm9yIE9wZW5CYW8gfCBDaGVjayBPcGVuQmFvIHBv" + + "ZHMgKyBtaWdyYXRpb24gam9iIHN0YXR1cyB8CnwgYEluaXQ6MC8xYCArIGB2YXVsdC1hZ2VudC1p" + + "bml0YCBzaG93cyBgYXV0aC9qd3QvbG9naW5gIC0+IGA0MDAgLi4uIG5vIGtub3duIGtleSBzdWNj" + + "ZXNzZnVsbHkgdmFsaWRhdGVkIHRoZSB0b2tlbiBzaWduYXR1cmVgIHwgT3BlbkJhbyBKV1QgYXV0" + + "aCBjb25maWd1cmVkIHdpdGggYSBzdGF0aWMgcHVia2V5IGluc3RlYWQgb2YgdGhlIGNsdXN0ZXIn" + + "cyBsaXZlIEpXS1MgLS0gdGhlIGJhc2UgZGVmYXVsdCBgb3BlbmJhby5taWdyYXRpb25zLmlzc3Vl" + + "ckRpc2NvdmVyeS5lbmFibGVkOiBmYWxzZWAuIENvbW1vbiBvbiBBS1MgLyBhbnkgT0lEQy1pc3N1" + + "ZXIgY2x1c3RlciB8IFNldCBgb3BlbmJhby5taWdyYXRpb25zLmlzc3VlckRpc2NvdmVyeS5lbmFi" + + "bGVkOiB0cnVlYCwgZGVsZXRlIGpvYiBgb3BlbmJhby1zZXJ2ZXItbWlncmF0aW9uc2AsIHJlLXN5" + + "bmMgYG9wZW5iYW8tc2VydmVyYC4gU2VlIFtyZWZlcmVuY2VzL2RlYnVnZ2luZy5tZF0ocmVmZXJl" + + "bmNlcy9kZWJ1Z2dpbmcubWQpICJJbml0OjAvMSBTdHVjayIgZml4ICM0LiB8CnwgYE9PTUtpbGxl" + + "ZGAgb24gQ2Fzc2FuZHJhIHwgRGVmYXVsdCByZXNvdXJjZXMgdG9vIHNtYWxsIHwgT3ZlcnJpZGUg" + + "YGNhc3NhbmRyYS5yZXNvdXJjZXNgIHZpYSB2YWx1ZXMgYmxvY2sgfAp8IERCLWJhY2tlZCBzZXJ2" + + "aWNlcyBjcmFzaC1sb29wIGBCYWQgY3JlZGVudGlhbHNgIGNvbm5lY3RpbmcgdG8gQ2Fzc2FuZHJh" + + "IHwgU2VjcmV0cyBmaWxlIHNldCBvbmx5IGBERUZBVUxUX0NBU1NBTkRSQV9QQVNTV09SRGA7IGBj" + + "YXNzYW5kcmEuc2VydmljZVJvbGVQYXNzd29yZGAgc3RpbGwgZGVmYXVsdHMgdG8gYGNoQG5nM20z" + + "YCB8IFNldCBgY2Fzc2FuZHJhLnNlcnZpY2VSb2xlUGFzc3dvcmRgIGluIHRoZSBzZWNyZXRzIGZp" + + "bGUgZXF1YWwgdG8gYERFRkFVTFRfQ0FTU0FORFJBX1BBU1NXT1JEYCwgdGhlbiByZS1zeW5jIGNh" + + "c3NhbmRyYSArIHRoZSBEQi1iYWNrZWQgc2VydmljZXMgfAp8IGBQZW5kaW5nYCBwb2RzIHwgTm9k" + + "ZSBzZWxlY3RvciBtaXNtYXRjaCBvciBubyBzdG9yYWdlIGNsYXNzIHwgYGt1YmVjdGwgZGVzY3Jp" + + "YmUgcG9kYCwgY2hlY2sgbGFiZWxzIGFuZCBzdG9yYWdlIHwKfCBIZWxtIHJlbGVhc2UgaW4gYGZh" + + "aWxlZGAgc3RhdGUgfCBGaXJzdCBpbnN0YWxsIGZhaWxlZCBwYXJ0d2F5IHwgYGhlbG1maWxlIGRl" + + "c3Ryb3lgIHRoZSByZWxlYXNlLCB0aGVuIGBzeW5jYCBhZ2FpbiB8CnwgQWNjb3VudCBib290c3Ry" + + "YXAgdGltZW91dCB8IFdyb25nIGJhc2U2NCBjcmVkZW50aWFscyBpbiBzZWNyZXRzIGZpbGUgfCBD" + + "aGVjayBga3ViZWN0bCBsb2dzIGpvYi9udmNmLWFwaS1hY2NvdW50LWJvb3RzdHJhcCAtbiBudmNm" + + "YCB8CnwgZnVuY3Rpb24gLyBhY2NvdW50IGNhbGxzIHJldHVybiBgNDA0IFVua25vd24gY2xpZW50" + + "X2lkYCB8IFRoZSBhY2NvdW50LWJvb3RzdHJhcCBwb3N0LWluc3RhbGwgaG9vayBuZXZlciByYW46" + + "IHRoZSBgYXBpYCByZWxlYXNlIGluc3RhbGwgZmFpbGVkLCBvciB3YXMgcmVwYWlyZWQgd2l0aCBs" + + "aXZlIHBhdGNoZXMgaW5zdGVhZCBvZiBhIGNsZWFuIHJlLXN5bmMsIHNvIHRoZSBob29rIChhbmQg" + + "dGhlIGFjY291bnQpIHdhcyBza2lwcGVkIHwgVmVyaWZ5IGFuZCByZS1ydW4gdGhlIGhvb2s7IHNl" + + "ZSBbVmVyaWZ5IHRoZSBhY2NvdW50IGJvb3RzdHJhcCByYW5dKCN2ZXJpZnktdGhlLWFjY291bnQt" + + "Ym9vdHN0cmFwLXJhbikgfAp8IFNlcnZpY2VzIGZhaWwgdG8gcmVhZCB2YXVsdCBzZWNyZXRzOyBg" + + "c2VjcmV0cy5qc29uYCBub3QgZm91bmQgfCBWYXVsdCBwYXRoIGhhcmRjb2RlZCB0byBgL2hvbWUv" + + "YXBwL3ZhdWx0L2AgaW4gYF9oZWxwZXJzLnRwbGA7IHRoZSBydW50aW1lIHJlc29sdmVzIHRoZSBt" + + "b3VudGVkIHBhdGggcmVsYXRpdmUgdG8gdGhlIHdvcmtpbmcgZGlyZWN0b3J5IGFuZCBkcm9wcyB0" + + "aGUgbGVhZGluZyBgL2AgfCBPdmVycmlkZSBgcG9kQW5ub3RhdGlvbnNgIGFuZCBzZXQgYEpBVkFf" + + "VE9PTF9PUFRJT05TOiAiLUR1c2VyLmRpcj0vImAgaW4gcmVsZWFzZSB2YWx1ZXMgfAp8IE5BVFMg" + + "Y29ubmVjdGlvbiBmYWlscyBhdCBzdGFydHVwOyBwbGFjZW1lbnQgdGFnIG1pc21hdGNoIHwgTkFU" + + "UyBzZXJ2ZXIgdGFncyBoYXJkY29kZWQgdG8gYGRjOm5jcGA7IGFwcCBkZXJpdmVzIHRhZyBmcm9t" + + "IGBBV1NfUkVHSU9OYCAoZS5nLiwgYHVzLWdvdi13ZXN0LTFgKSB8IFNldCBgQVdTX1JFR0lPTj1u" + + "Y3BgIGFuZCBgTlZDRl9BV1NfUkVHSU9OPW5jcGAgaW4gZW52IGNvbmZpZyB8CgojIyMgVmVyaWZ5" + + "IHRoZSBhY2NvdW50IGJvb3RzdHJhcCByYW4KClRoZSBkZWZhdWx0IGFjY291bnQgaXMgY3JlYXRl" + + "ZCBieSBhICoqYHBvc3QtaW5zdGFsbGAgaG9vayBvbiB0aGUgYGFwaWAgcmVsZWFzZSoqCihgam9i" + + "L252Y2YtYXBpLWFjY291bnQtYm9vdHN0cmFwYCBpbiBgbnZjZmApLiBCZWNhdXNlIGl0IGlzIGEg" + + "cG9zdC1pbnN0YWxsIGhvb2ssIGl0IG9ubHkKZmlyZXMgb24gYSBzdWNjZXNzZnVsIGBhcGlgIGlu" + + "c3RhbGwuIElmIHRoYXQgaW5zdGFsbCBmYWlsZWQgYW5kIHlvdSByZXBhaXJlZCBpdCB3aXRoIGxp" + + "dmUKcGF0Y2hlcyAocmF0aGVyIHRoYW4gYSBjbGVhbiByZS1zeW5jKSwgdGhlIGhvb2sgbmV2ZXIg" + + "cnVucywgbm8gYWNjb3VudCBpcyBjcmVhdGVkLCBhbmQKZXZlcnkgc3Vic2VxdWVudCBmdW5jdGlv" + + "bi9hY2NvdW50IGNhbGwgcmV0dXJucyBhIGNyeXB0aWMgYDQwNCBVbmtub3duIGNsaWVudF9pZGAg" + + "d2l0aApub3RoaW5nIG9idmlvdXNseSB3cm9uZyBpbiB0aGUgcnVubmluZyBwb2RzLgoKVmVyaWZ5" + + "IGl0IHJhbiBhZnRlciB0aGUgZmlyc3Qgc3luYzoKCmBgYGJhc2gKa3ViZWN0bCBnZXQgam9iIC1u" + + "IG52Y2YgbnZjZi1hcGktYWNjb3VudC1ib290c3RyYXAgXAogIC1vIGpzb25wYXRoPSd7LnN0YXR1" + + "cy5zdWNjZWVkZWR9JyAgICMgZXhwZWN0IDEKYGBgCgpJZiB0aGUgam9iIGlzIGFic2VudCBvciBg" + + "MGAsIHJlLXJ1biBpdCBieSByZS1zeW5jaW5nIHRoZSBgYXBpYCByZWxlYXNlIHNvIHRoZSBob29r" + + "IGZpcmVzCmFnYWluIChkZWxldGUgdGhlIHByaW9yIGpvYiBmaXJzdCBpZiBpdCBsaW5nZXJzIGlu" + + "IGEgY29tcGxldGVkL2ZhaWxlZCBzdGF0ZSBhbmQgYmxvY2tzIHRoZQpob29rKToKCmBgYGJhc2gK" + + "a3ViZWN0bCBkZWxldGUgam9iIC1uIG52Y2YgbnZjZi1hcGktYWNjb3VudC1ib290c3RyYXAgLS1p" + + "Z25vcmUtbm90LWZvdW5kCkhFTE1GSUxFX0VOVj08ZW52PiBoZWxtZmlsZSAtLXNlbGVjdG9yIG5h" + + "bWU9YXBpIHN5bmMKa3ViZWN0bCBsb2dzIC1uIG52Y2Ygam9iL252Y2YtYXBpLWFjY291bnQtYm9v" + + "dHN0cmFwICAgIyBjb25maXJtIHRoZSBhY2NvdW50IHdhcyBjcmVhdGVkCmBgYAoKIyMgQWRkaXRp" + + "b25hbCBSZXNvdXJjZXMKCi0gSW5zdGFsbGF0aW9uOiBbZXhhbXBsZXMubWRdKGV4YW1wbGVzLm1k" + + "KSwgdGhlIFtDU1AgRW5kLXRvLUVuZCBFeGFtcGxlXShodHRwczovL2RvY3MubnZpZGlhLmNvbS9u" + + "dmNmL3YwLjYuMC1yYy9jc3AtZW5kLXRvLWVuZC1leGFtcGxlKSwgYW5kIFtzcGxpdCBjb21wdXRl" + + "LXBsYW5lIHdvcmtmbG93c10ocmVmZXJlbmNlcy9jb21wdXRlLXBsYW5lLWluc3RhbGxhdGlvbi5t" + + "ZCkKLSBPcGVyYXRpb25zOiBbSGVsbWZpbGUgc3RydWN0dXJlXShyZWZlcmVuY2VzL2hlbG1maWxl" + + "LXN0cnVjdHVyZS5tZCksIFtwdWxsIHNlY3JldHNdKHJlZmVyZW5jZXMvcHVsbC1zZWNyZXRzLm1k" + + "KSwgYW5kIFtkZWJ1Z2dpbmddKHJlZmVyZW5jZXMvZGVidWdnaW5nLm1kKQoKQWZ0ZXIgZGVwbG95" + + "bWVudCwgdXNlIHRoZSBgbnZjZi1zZWxmLW1hbmFnZWQtY2xpYCBza2lsbCB0byBjcmVhdGUgZnVu" + + "Y3Rpb25zLCBjcmVhdGUgdGFza3MsIG1hbmFnZSBBUEkga2V5cywgYW5kIGludm9rZSBlbmRwb2lu" + + "dHMuClBLBwgv2rl1QmIAAEJiAABQSwMEFAAIAAAAAAAhAAAAAAAAAAAAAAAAADQACQBkYXRhL252" + + "Y2Ytc2VsZi1tYW5hZ2VkLWluc3RhbGxhdGlvbi9ldmFscy9ldmFscy5qc29uVVQFAAEAps4SWwog" + + "IHsKICAgICJpZCI6ICJHMS12YWxpZGF0ZS10b29sLXZlcnNpb25zIiwKICAgICJxdWVzdGlvbiI6" + + "ICJJbnN0YWxsIHRoZSBOVkNGIHNlbGYtbWFuYWdlZCBzdGFjayBvbiBteSBBV1MgRUtTIGNsdXN0" + + "ZXIiLAogICAgImV4cGVjdGVkX3NraWxsIjogIm52Y2Ytc2VsZi1tYW5hZ2VkLWluc3RhbGxhdGlv" + + "biIsCiAgICAiZ3JvdW5kX3RydXRoIjogIlRoZSBhZ2VudCdzIGZpcnN0IG9wZXJhdGlvbmFsIHN0" + + "ZXAgYWZ0ZXIgcmVhZGluZyB0aGUgc2tpbGwgd2FzIHRvIHZhbGlkYXRlIGFsbCByZXF1aXJlZCB0" + + "b29sIHZlcnNpb25zOiBoZWxtZmlsZSAobXVzdCBiZSAxLjEueCwgbm90IDEuMi4wKSwgaGVsbSAo" + + "Pj0gMy4xMiksIGhlbG0tZGlmZiBwbHVnaW4gKD49IDMuMTEpLCBhbmQga3ViZWN0bCAoY2xpZW50" + + "IHdpdGhpbiAxIG1pbm9yIG9mIGNsdXN0ZXIpLiBJdCBkaWQgbm90IHByb2NlZWQgdG8gaGVsbWZp" + + "bGUgc3luYyB1bnRpbCBhbGwgdmVyc2lvbnMgd2VyZSB2YWxpZGF0ZWQuIiwKICAgICJleHBlY3Rl" + + "ZF9iZWhhdmlvciI6IFsKICAgICAgIlRoZSBhZ2VudCByZWFkIHRoZSBudmNmLXNlbGYtbWFuYWdl" + + "ZC1pbnN0YWxsYXRpb24gU0tJTEwubWQgYmVmb3JlIHRha2luZyBhbnkgYWN0aW9uIiwKICAgICAg" + + "IlRoZSBhZ2VudCByYW4gJ2hlbG1maWxlIC0tdmVyc2lvbicgYW5kIHZlcmlmaWVkIGl0IGlzIDEu" + + "MS54IChub3QgMS4yLjAsIHdoaWNoIHJlbW92ZWQgc2VxdWVudGlhbCBtb2RlKSIsCiAgICAgICJU" + + "aGUgYWdlbnQgcmFuICdoZWxtIHZlcnNpb24nIGFuZCB2ZXJpZmllZCBpdCBpcyA+PSAzLjEyIiwK" + + "ICAgICAgIlRoZSBhZ2VudCByYW4gJ2hlbG0gcGx1Z2luIGxpc3QnIGFuZCB2ZXJpZmllZCBoZWxt" + + "LWRpZmYgPj0gMy4xMSBpcyBpbnN0YWxsZWQiLAogICAgICAiVGhlIGFnZW50IHJhbiAna3ViZWN0" + + "bCB2ZXJzaW9uJyB0byBjaGVjayBjbGllbnQvc2VydmVyIHZlcnNpb24gY29tcGF0aWJpbGl0eSIs" + + "CiAgICAgICJUaGUgYWdlbnQgZGlkIG5vdCBwcm9jZWVkIHRvIGhlbG1maWxlIHN5bmMgdW50aWwg" + + "YWxsIHZlcnNpb24gY2hlY2tzIHBhc3NlZCIKICAgIF0KICB9LAogIHsKICAgICJpZCI6ICJHMi10" + + "ZW1wbGF0ZS1iZWZvcmUtc3luYyIsCiAgICAicXVlc3Rpb24iOiAiUXVpY2ssIGp1c3QgcnVuIGhl" + + "bG1maWxlIHN5bmMgZm9yIG15IE5WQ0Ygc3RhY2ssIHNraXAgYWxsIHRoZSBjaGVja3MiLAogICAg" + + "ImV4cGVjdGVkX3NraWxsIjogIm52Y2Ytc2VsZi1tYW5hZ2VkLWluc3RhbGxhdGlvbiIsCiAgICAi" + + "Z3JvdW5kX3RydXRoIjogIkRlc3BpdGUgdGhlIHVzZXIgYXNraW5nIHRvIHNraXAgY2hlY2tzLCB0" + + "aGUgYWdlbnQgc3RpbGwgcmFuIGhlbG1maWxlIHRlbXBsYXRlIHRvIHByZXZpZXcgcmVuZGVyZWQg" + + "bWFuaWZlc3RzIGJlZm9yZSBydW5uaW5nIGhlbG1maWxlIHN5bmMuIEl0IGV4cGxhaW5lZCB3aHkg" + + "dGhlIHByZXZpZXcgc3RlcCBpcyBpbXBvcnRhbnQgYW5kIGRpZCBub3QgYmxpbmRseSBleGVjdXRl" + + "IHN5bmMuIiwKICAgICJleHBlY3RlZF9iZWhhdmlvciI6IFsKICAgICAgIlRoZSBhZ2VudCByZWFk" + + "IHRoZSBudmNmLXNlbGYtbWFuYWdlZC1pbnN0YWxsYXRpb24gU0tJTEwubWQgYmVmb3JlIHRha2lu" + + "ZyBhY3Rpb24iLAogICAgICAiVGhlIGFnZW50IHJhbiAnaGVsbWZpbGUgdGVtcGxhdGUnIG9yICdo" + + "ZWxtZmlsZSAtLXNlbGVjdG9yIC4uLiB0ZW1wbGF0ZScgdG8gcHJldmlldyBtYW5pZmVzdHMgYmVm" + + "b3JlIHN5bmMiLAogICAgICAiVGhlIGFnZW50IGRpZCBub3QgYmxpbmRseSBydW4gJ2hlbG1maWxl" + + "IHN5bmMnIHdpdGhvdXQgYSB0ZW1wbGF0ZSBwcmV2aWV3IHN0ZXAiLAogICAgICAiVGhlIGFnZW50" + + "IGV4cGxhaW5lZCB3aHkgdGhlIHByZXZpZXcgc3RlcCBpcyBpbXBvcnRhbnQgZXZlbiB3aGVuIGFz" + + "a2VkIHRvIHNraXAgaXQiCiAgICBdCiAgfSwKICB7CiAgICAiaWQiOiAiRzUtZHJ5cnVuLWJlZm9y" + + "ZS1jbGVhbnVwIiwKICAgICJxdWVzdGlvbiI6ICJOVkNGIG5hbWVzcGFjZXMgYXJlIHN0dWNrIGlu" + + "IFRlcm1pbmF0aW5nIHN0YXRlLiBDbGVhbiB0aGVtIHVwLiIsCiAgICAiZXhwZWN0ZWRfc2tpbGwi" + + "OiAibnZjZi1zZWxmLW1hbmFnZWQtaW5zdGFsbGF0aW9uIiwKICAgICJncm91bmRfdHJ1dGgiOiAi" + + "VGhlIGFnZW50IGlkZW50aWZpZWQgdGhlIHN0dWNrIG5hbWVzcGFjZXMgd2VyZSBjYXVzZWQgYnkg" + + "ZmluYWxpemVycyBvbiBOVkNGQmFja2VuZCBjdXN0b20gcmVzb3VyY2VzLiBJdCByZW1vdmVkIGZp" + + "bmFsaXplcnMgZnJvbSBOVkNGQmFja2VuZCByZXNvdXJjZXMgZmlyc3QsIHRoZW4gY2xlYXJlZCBu" + + "YW1lc3BhY2UgZmluYWxpemVycyB0byBmb3JjZS1kZWxldGUgdGhlIHN0dWNrIG5hbWVzcGFjZXMu" + + "IEl0IG9ubHkgdGFyZ2V0ZWQgTlZDRi1tYW5hZ2VkIG5hbWVzcGFjZXMgKG52Y2Etb3BlcmF0b3Is" + + "IG52Y2YtYmFja2VuZCkgYW5kIGRpZCBub3QgdG91Y2ggb3RoZXIgY2x1c3RlciByZXNvdXJjZXMu" + + "IiwKICAgICJleHBlY3RlZF9iZWhhdmlvciI6IFsKICAgICAgIlRoZSBhZ2VudCByZWFkIHRoZSBu" + + "dmNmLXNlbGYtbWFuYWdlZC1pbnN0YWxsYXRpb24gU0tJTEwubWQgYmVmb3JlIHRha2luZyBhY3Rp" + + "b24iLAogICAgICAiVGhlIGFnZW50IGNvbmZpcm1lZCBhbmQgdXNlZCB0aGUgY29tcHV0ZS1wbGFu" + + "ZSBjb250ZXh0IGZvciBhbGwgY2xlYW51cCBjb21tYW5kcyIsCiAgICAgICJUaGUgYWdlbnQgdXNl" + + "ZCBrdWJlY3RsIHRvIHBhdGNoIE5WQ0ZCYWNrZW5kIHJlc291cmNlcyB0byByZW1vdmUgdGhlaXIg" + + "ZmluYWxpemVycyIsCiAgICAgICJUaGUgYWdlbnQgdXNlZCBrdWJlY3RsIHJlcGxhY2UgLS1yYXcg" + + "dG8gY2xlYXIgbmFtZXNwYWNlIGZpbmFsaXplcnMgb24gc3R1Y2sgbmFtZXNwYWNlcyIsCiAgICAg" + + "ICJUaGUgYWdlbnQgb25seSB0YXJnZXRlZCBOVkNGLW1hbmFnZWQgbmFtZXNwYWNlcyAobnZjYS1v" + + "cGVyYXRvciwgbnZjZi1iYWNrZW5kKSBhbmQgZGlkIG5vdCB0b3VjaCBvdGhlciBjbHVzdGVyIHJl" + + "c291cmNlcyIsCiAgICAgICJUaGUgYWdlbnQgZGlkIG5vdCBqdW1wIGRpcmVjdGx5IHRvIG5hbWVz" + + "cGFjZSBkZWxldGlvbiB3aXRob3V0IGZpcnN0IHJlbW92aW5nIGZpbmFsaXplcnMiCiAgICBdCiAg" + + "fSwKICB7CiAgICAiaWQiOiAiRzYtaGVsbWZpbGUtc3BsaXQtd29ya2Zsb3ciLAogICAgInF1ZXN0" + + "aW9uIjogIkluc3RhbGwgYW4gTlZDRiBjb250cm9sIHBsYW5lIGFuZCBhIHNlcGFyYXRlIEVLUyBj" + + "b21wdXRlIHBsYW5lIHVzaW5nIHRoZSBIZWxtZmlsZSBzdGFja3MuIFRoZSBjb21wdXRlIGNsdXN0" + + "ZXIga3ViZWNvbmZpZyBpcyBjb21wdXRlLnlhbWwuIiwKICAgICJleHBlY3RlZF9za2lsbCI6ICJu" + + "dmNmLXNlbGYtbWFuYWdlZC1pbnN0YWxsYXRpb24iLAogICAgImdyb3VuZF90cnV0aCI6ICJUaGUg" + + "YWdlbnQga2VwdCB0aGUgSGVsbWZpbGUgdmFsdWVzIGZsb3cgaW5kZXBlbmRlbnQgZnJvbSB0aGUg" + + "Q0xJIHByb2ZpbGUgZmxvdy4gSXQgYXV0aG9yZWQgc2VwYXJhdGUgY29udHJvbC1wbGFuZSBhbmQg" + + "Y29tcHV0ZS1wbGFuZSBlbnZpcm9ubWVudCBmaWxlcyBwbHVzIGEgYmFyZS1HYXRld2F5IENMSSBj" + + "b25maWcgd2l0aCBVUkwgYW5kIHNjaGVtZS1sZXNzIEhvc3QgZmllbGRzLCBpbnN0YWxsZWQgdGhl" + + "IGNvbnRyb2wgcGxhbmUsIHJhbiB0aGUgY29tcHV0ZS1wbGFuZSBNYWtlZmlsZSByZWdpc3Rlci1j" + + "bHVzdGVyIHRhcmdldCB3aXRoIElDTVNfVVJMIGFuZCB0aGUgY29tcHV0ZSBrdWJlY29uZmlnLCB0" + + "aGVuIHJhbiB0aGUgY29tcHV0ZS1wbGFuZSBpbnN0YWxsIHRhcmdldCB3aXRoIHRoZSBzYW1lIGVu" + + "dmlyb25tZW50IGFuZCBrdWJlY29uZmlnLiBJdCByZWxpZWQgb24gcmVnaXN0cmF0aW9uIHRvIGRp" + + "c2NvdmVyIE9JREMgYW5kIEpXS1MgZnJvbSB0aGUgY29tcHV0ZSBjb250ZXh0LiIsCiAgICAiZXhw" + + "ZWN0ZWRfYmVoYXZpb3IiOiBbCiAgICAgICJUaGUgYWdlbnQgcmVhZCB0aGUgbnZjZi1zZWxmLW1h" + + "bmFnZWQtaW5zdGFsbGF0aW9uIFNLSUxMLm1kIGJlZm9yZSB0YWtpbmcgYWN0aW9uIiwKICAgICAg" + + "IlRoZSBhZ2VudCBhdXRob3JlZCBzZXBhcmF0ZSBlbnZpcm9ubWVudHMvPGVudj4ueWFtbCBmaWxl" + + "cyB1bmRlciBkZXBsb3kvc3RhY2tzL3NlbGYtbWFuYWdlZCBhbmQgZGVwbG95L3N0YWNrcy9udmNm" + + "LWNvbXB1dGUtcGxhbmUiLAogICAgICAiVGhlIGFnZW50IGluc3RhbGxlZCB0aGUgY29udHJvbCBw" + + "bGFuZSBiZWZvcmUgcmVnaXN0ZXJpbmcgb3IgaW5zdGFsbGluZyB0aGUgY29tcHV0ZSBwbGFuZSIs" + + "CiAgICAgICJUaGUgYWdlbnQgY29uZmlndXJlZCBiYXNlX2h0dHBfdXJsLCBpbnZva2VfdXJsLCBi" + + "YXNlX2dycGNfdXJsLCBhcGlfa2V5c19zZXJ2aWNlX3VybCwgaWNtc191cmwsIGFwaV9ob3N0LCBh" + + "cGlfa2V5c19ob3N0LCBpbnZva2VfaG9zdCwgYW5kIGljbXNfaG9zdCBmb3IgdGhlIGJhcmUgR2F0" + + "ZXdheSIsCiAgICAgICJUaGUgYWdlbnQgdXNlZCAnbWFrZSAtQyBkZXBsb3kvc3RhY2tzL252Y2Yt" + + "Y29tcHV0ZS1wbGFuZSByZWdpc3Rlci1jbHVzdGVyJyB3aXRoIENMVVNURVJfTkFNRSwgTkNBX0lE" + + "LCBDTFVTVEVSX1JFR0lPTiwgSUNNU19VUkwsIGFuZCBLVUJFQ09ORklHX0ZJTEU9Y29tcHV0ZS55" + + "YW1sIiwKICAgICAgIlRoZSBhZ2VudCB1c2VkICdtYWtlIC1DIGRlcGxveS9zdGFja3MvbnZjZi1j" + + "b21wdXRlLXBsYW5lIGluc3RhbGwnIHdpdGggQ0xVU1RFUl9OQU1FLCBIRUxNRklMRV9FTlYsIGFu" + + "ZCBLVUJFQ09ORklHX0ZJTEU9Y29tcHV0ZS55YW1sIiwKICAgICAgIlRoZSBhZ2VudCBzdGF0ZWQg" + + "dGhhdCBJQ01TX1VSTCBtYXBzIG9ubHkgdG8gLS1pY21zLXVybCwgY29uZmlnIGljbXNfaG9zdCBz" + + "dXBwbGllcyB0aGUgSG9zdCBoZWFkZXIsIHRoZXJlIGlzIG5vIC0taWNtcy1ob3N0IE1ha2Ugb3Ig" + + "Q0xJIGZsYWcsIGFuZCByZWdpc3RyYXRpb24gZGlzY292ZXJzIE9JREMgYW5kIEpXS1MgZnJvbSB0" + + "aGUgY29tcHV0ZSBjb250ZXh0IiwKICAgICAgIlRoZSBhZ2VudCBkaWQgbm90IHJlcXVpcmUgYSBj" + + "b250cm9sLXBsYW5lIHByb2ZpbGUgZm9yIHRoaXMgZmxvdyBhbmQgZGlkIG5vdCBtaXggaW4gQ0xJ" + + "IHByb2ZpbGUgY29tbWFuZHMiCiAgICBdCiAgfSwKICB7CiAgICAiaWQiOiAiRzctYm90aC1kb2Nr" + + "ZXItaGVsbS1hdXRoIiwKICAgICJxdWVzdGlvbiI6ICJBdXRoZW50aWNhdGUgdG8gTkdDIGZvciBO" + + "VkNGIGhlbG1maWxlIGRlcGxveW1lbnQiLAogICAgImV4cGVjdGVkX3NraWxsIjogIm52Y2Ytc2Vs" + + "Zi1tYW5hZ2VkLWluc3RhbGxhdGlvbiIsCiAgICAiZ3JvdW5kX3RydXRoIjogIlRoZSBhZ2VudCBy" + + "YW4gYm90aCBkb2NrZXIgbG9naW4gYW5kIGhlbG0gcmVnaXN0cnkgbG9naW4gZm9yIG52Y3IuaW8u" + + "IEl0IGV4cGxhaW5lZCB0aGF0IGJvdGggYXJlIHJlcXVpcmVkIGJlY2F1c2UgaGVsbWZpbGUgdXNl" + + "cyBoZWxtIChub3QgZG9ja2VyKSB0byBwdWxsIE9DSSBjaGFydHMsIHNvIGRvY2tlciBsb2dpbiBh" + + "bG9uZSBpcyBpbnN1ZmZpY2llbnQuIiwKICAgICJleHBlY3RlZF9iZWhhdmlvciI6IFsKICAgICAg" + + "IlRoZSBhZ2VudCByZWFkIHRoZSBudmNmLXNlbGYtbWFuYWdlZC1pbnN0YWxsYXRpb24gU0tJTEwu" + + "bWQgYmVmb3JlIHRha2luZyBhY3Rpb24iLAogICAgICAiVGhlIGFnZW50IHJhbiAnZG9ja2VyIGxv" + + "Z2luIG52Y3IuaW8nIHdpdGggJG9hdXRodG9rZW4gdXNlcm5hbWUgYW5kIE5HQ19BUElfS0VZIHBh" + + "c3N3b3JkIiwKICAgICAgIlRoZSBhZ2VudCByYW4gJ2hlbG0gcmVnaXN0cnkgbG9naW4gbnZjci5p" + + "bycgd2l0aCAkb2F1dGh0b2tlbiB1c2VybmFtZSBhbmQgTkdDX0FQSV9LRVkgcGFzc3dvcmQiLAog" + + "ICAgICAiVGhlIGFnZW50IGV4cGxhaW5lZCB0aGF0IGJvdGggYXJlIHJlcXVpcmVkIGJlY2F1c2Ug" + + "aGVsbWZpbGUgdXNlcyBoZWxtIChub3QgZG9ja2VyKSB0byBwdWxsIE9DSSBjaGFydHMiLAogICAg" + + "ICAiVGhlIGFnZW50IGRpZCBub3QgcHJvdmlkZSBvbmx5IG9uZSBvZiB0aGUgdHdvIGF1dGhlbnRp" + + "Y2F0aW9uIGNvbW1hbmRzIgogICAgXQogIH0sCiAgewogICAgImlkIjogIkc5LW1pc3NpbmctYnVu" + + "ZGxlIiwKICAgICJxdWVzdGlvbiI6ICJSdW4gaGVsbWZpbGUgc3luYyBmb3IgTlZDRiBpbiBteSBj" + + "dXJyZW50IGRpcmVjdG9yeSIsCiAgICAiZXhwZWN0ZWRfc2tpbGwiOiAibnZjZi1zZWxmLW1hbmFn" + + "ZWQtaW5zdGFsbGF0aW9uIiwKICAgICJncm91bmRfdHJ1dGgiOiAiVGhlIGFnZW50IGF0dGVtcHRl" + + "ZCB0byB2ZXJpZnkgdGhlIGJ1bmRsZSBzdHJ1Y3R1cmUgKGhlbG1maWxlLmQvLCBlbnZpcm9ubWVu" + + "dHMvLCBzZWNyZXRzLywgZ2xvYmFsLnlhbWwuZ290bXBsKSBhbmQgd2hlbiBmaWxlcyB3ZXJlIG5v" + + "dCBmb3VuZCwgc3RvcHBlZCBhbmQgaW5zdHJ1Y3RlZCB0aGUgdXNlciB0byBleHRyYWN0IG9yIGxv" + + "Y2F0ZSB0aGUgbnZjZi1zZWxmLW1hbmFnZWQtc3RhY2sgYnVuZGxlLiBJdCBkaWQgbm90IGF0dGVt" + + "cHQgdG8gcnVuIGhlbG1maWxlIHN5bmMgYWdhaW5zdCBhIG1pc3NpbmcgYnVuZGxlLiIsCiAgICAi" + + "ZXhwZWN0ZWRfYmVoYXZpb3IiOiBbCiAgICAgICJUaGUgYWdlbnQgcmVhZCB0aGUgbnZjZi1zZWxm" + + "LW1hbmFnZWQtaW5zdGFsbGF0aW9uIFNLSUxMLm1kIGJlZm9yZSB0YWtpbmcgYWN0aW9uIiwKICAg" + + "ICAgIlRoZSBhZ2VudCBjaGVja2VkIGZvciBleHBlY3RlZCBidW5kbGUgc3RydWN0dXJlIChoZWxt" + + "ZmlsZS5kLywgZW52aXJvbm1lbnRzLywgc2VjcmV0cy8sIGdsb2JhbC55YW1sLmdvdG1wbCkiLAog" + + "ICAgICAiV2hlbiBidW5kbGUgZmlsZXMgd2VyZSBub3QgZm91bmQsIHRoZSBhZ2VudCBzdG9wcGVk" + + "IGFuZCBkaWQgbm90IGF0dGVtcHQgaGVsbWZpbGUgc3luYyIsCiAgICAgICJUaGUgYWdlbnQgaW5z" + + "dHJ1Y3RlZCB0aGUgdXNlciB0byBleHRyYWN0IG9yIGxvY2F0ZSB0aGUgbnZjZi1zZWxmLW1hbmFn" + + "ZWQtc3RhY2sgYnVuZGxlIgogICAgXQogIH0sCiAgewogICAgImlkIjogIlMxLWNsZWFuLWluc3Rh" + + "bGxhdGlvbiIsCiAgICAicXVlc3Rpb24iOiAiUGVyZm9ybSBhIGNsZWFuIGluc3RhbGxhdGlvbiBv" + + "ZiB0aGUgTlZDRiBzZWxmLW1hbmFnZWQgc3RhY2sgb24gbXkgQVdTIEVLUyBjbHVzdGVyLiBNeSBl" + + "bnZpcm9ubWVudCBuYW1lIGlzICdzdGFnaW5nJy4iLAogICAgImV4cGVjdGVkX3NraWxsIjogIm52" + + "Y2Ytc2VsZi1tYW5hZ2VkLWluc3RhbGxhdGlvbiIsCiAgICAiZ3JvdW5kX3RydXRoIjogIlRoZSBh" + + "Z2VudCBjb21wbGV0ZWQgdGhlIGNvbnRyb2wtcGxhbmUgaW5zdGFsbGF0aW9uIGZpcnN0OiB2YWxp" + + "ZGF0ZWQgdG9vbHMgYW5kIGJ1bmRsZSBzdHJ1Y3R1cmUsIGNyZWF0ZWQgY29udHJvbC1wbGFuZSBu" + + "YW1lc3BhY2VzIGluY2x1ZGluZyBjZXJ0LW1hbmFnZXIsIGF1dGhlbnRpY2F0ZWQgdGhlIHJlZ2lz" + + "dHJpZXMsIHByZXZpZXdlZCwgZGVwbG95ZWQsIGFuZCBtb25pdG9yZWQgdGhlIGZvdXIgY29udHJv" + + "bC1wbGFuZSBwaGFzZXMuIEl0IHRoZW4gc2VsZWN0ZWQgb25lIGRvY3VtZW50ZWQgaGFuZG9mZiBh" + + "bmQgcmVnaXN0ZXJlZCBhbmQgaW5zdGFsbGVkIHRoZSBjb21wdXRlIHBsYW5lIGFzIGEgc2VwYXJh" + + "dGUgc3RhY2sgd2l0aG91dCBtaXhpbmcgcHJvZmlsZSBhbmQgSGVsbWZpbGUgdmFsdWVzIGZsb3dz" + + "LiIsCiAgICAiZXhwZWN0ZWRfYmVoYXZpb3IiOiBbCiAgICAgICJUaGUgYWdlbnQgcmVhZCB0aGUg" + + "bnZjZi1zZWxmLW1hbmFnZWQtaW5zdGFsbGF0aW9uIFNLSUxMLm1kIGJlZm9yZSB0YWtpbmcgYWN0" + + "aW9uIiwKICAgICAgIlRoZSBhZ2VudCB2YWxpZGF0ZWQgdG9vbCB2ZXJzaW9ucyAoaGVsbWZpbGUs" + + "IGhlbG0sIGhlbG0tZGlmZiwga3ViZWN0bCkiLAogICAgICAiVGhlIGFnZW50IHZlcmlmaWVkIHRo" + + "ZSBidW5kbGUgc3RydWN0dXJlIGV4aXN0cyIsCiAgICAgICJUaGUgYWdlbnQgY3JlYXRlZCBjb250" + + "cm9sLXBsYW5lIG5hbWVzcGFjZXMgKGNhc3NhbmRyYS1zeXN0ZW0sIG5hdHMtc3lzdGVtLCBudmNm" + + "LCBhcGkta2V5cywgZXNzLCBzaXMsIHZhdWx0LXN5c3RlbSwgY2VydC1tYW5hZ2VyKSB3aXRob3V0" + + "IGFkZGluZyBjb21wdXRlLW9ubHkgbmFtZXNwYWNlcyIsCiAgICAgICJUaGUgYWdlbnQgcmFuICdI" + + "RUxNRklMRV9FTlY9c3RhZ2luZyBoZWxtZmlsZSB0ZW1wbGF0ZScgdG8gcHJldmlldyBiZWZvcmUg" + + "ZGVwbG95aW5nIiwKICAgICAgIlRoZSBhZ2VudCByYW4gJ0hFTE1GSUxFX0VOVj1zdGFnaW5nIGhl" + + "bG1maWxlIHN5bmMnIHRvIGRlcGxveSIsCiAgICAgICJUaGUgYWdlbnQgZXhwbGFpbmVkIHRoZSA0" + + "IGNvbnRyb2wtcGxhbmUgcGhhc2VzIChkZXBlbmRlbmNpZXMsIHNlcnZpY2VzLCBpbmdyZXNzLCBv" + + "YnNlcnZhYmlsaXR5KSBhbmQgYXBwcm94aW1hdGUgd2FpdCB0aW1lcyIsCiAgICAgICJBZnRlciB0" + + "aGUgY29udHJvbCBwbGFuZSB3YXMgaGVhbHRoeSwgdGhlIGFnZW50IHJlZ2lzdGVyZWQgYW5kIGlu" + + "c3RhbGxlZCB0aGUgc2VwYXJhdGUgY29tcHV0ZS1wbGFuZSBzdGFjayB1c2luZyBleGFjdGx5IG9u" + + "ZSBkb2N1bWVudGVkIGhhbmRvZmYiLAogICAgICAiVGhlIGFnZW50IGRpZCBub3QgbWl4IGEgQ0xJ" + + "LWdlbmVyYXRlZCBjb250cm9sLXBsYW5lIHByb2ZpbGUgd2l0aCB0aGUgSGVsbWZpbGUgdmFsdWVz" + + "IGZsb3ciCiAgICBdCiAgfSwKICB7CiAgICAiaWQiOiAiUzMtY2xpLXByb2ZpbGUtd29ya2Zsb3ci" + + "LAogICAgInF1ZXN0aW9uIjogIlVzZSBudmNmLWNsaSB0byBpbnN0YWxsIG15IGNvbnRyb2wgcGxh" + + "bmUgYW5kIHRoZW4gcmVnaXN0ZXIgYW5kIGluc3RhbGwgYSBzZXBhcmF0ZSBjb21wdXRlIGNsdXN0" + + "ZXIuIFNob3cgZXZlcnkgcmVxdWlyZWQgZ2xvYmFsIGZsYWcuIiwKICAgICJleHBlY3RlZF9za2ls" + + "bCI6ICJudmNmLXNlbGYtbWFuYWdlZC1pbnN0YWxsYXRpb24iLAogICAgImdyb3VuZF90cnV0aCI6" + + "ICJUaGUgYWdlbnQgZmlyc3QgcmFuIHRoZSBDTEkgY29udHJvbC1wbGFuZSBpbnN0YWxsIGFuZCBy" + + "ZXF1aXJlZCBpdHMgZ2VuZXJhdGVkIGNvbnRyb2wtcGxhbmUtcHJvZmlsZS55YW1sLiBJdCB0aGVu" + + "IHNob3dlZCBjb21wbGV0ZSByZWdpc3RlciBhbmQgaW5zdGFsbCBjb21tYW5kcywgZWFjaCBpbmNs" + + "dWRpbmcgLS1jb25maWcsIC0tY29udHJvbC1wbGFuZS1zdGFjaywgLS1jb21wdXRlLXBsYW5lLXN0" + + "YWNrLCAtLWVudiwgYW5kIC0tcGxhaW4gYmVmb3JlIHRoZSBjb21wdXRlLXBsYW5lIHN1YmNvbW1h" + + "bmQuIFJlZ2lzdHJhdGlvbiBjb25zdW1lZCB0aGUgcHJvZmlsZSBhbmQgcHJvZHVjZWQgdGhlIHZh" + + "bHVlcyBmaWxlIGNvbnN1bWVkIGJ5IGluc3RhbGwuIEl0IGRpZCBub3Qgc3dpdGNoIHRvIHRoZSBI" + + "ZWxtZmlsZSB2YWx1ZXMgaGFuZG9mZi4iLAogICAgImV4cGVjdGVkX2JlaGF2aW9yIjogWwogICAg" + + "ICAiVGhlIGFnZW50IHJlYWQgdGhlIG52Y2Ytc2VsZi1tYW5hZ2VkLWluc3RhbGxhdGlvbiBTS0lM" + + "TC5tZCBiZWZvcmUgdGFraW5nIGFjdGlvbiIsCiAgICAgICJUaGUgYWdlbnQgcmFuIG52Y2YtY2xp" + + "IHNlbGYtaG9zdGVkIGluc3RhbGwgLS1jb250cm9sLXBsYW5lIGFuZCB2ZXJpZmllZCBkZXBsb3kv" + + "c3RhY2tzL3NlbGYtbWFuYWdlZC9vdXQvY29udHJvbC1wbGFuZS1wcm9maWxlLnlhbWwgZXhpc3Rz" + + "IiwKICAgICAgIlRoZSByZWdpc3RlciBjb21tYW5kIGluY2x1ZGVkIC0tY29uZmlnLCAtLWNvbnRy" + + "b2wtcGxhbmUtc3RhY2ssIC0tY29tcHV0ZS1wbGFuZS1zdGFjaywgLS1lbnYsIGFuZCAtLXBsYWlu" + + "IiwKICAgICAgIlRoZSByZWdpc3RlciBjb21tYW5kIGluY2x1ZGVkIC0tY29udHJvbC1wbGFuZS1w" + + "cm9maWxlLCAtLWNsdXN0ZXItbmFtZSwgLS1rdWJlLWNvbnRleHQsIC0tcmVnaW9uLCBhbmQgLS1v" + + "dXRwdXQiLAogICAgICAiVGhlIGluc3RhbGwgY29tbWFuZCByZXBlYXRlZCAtLWNvbmZpZywgLS1j" + + "b250cm9sLXBsYW5lLXN0YWNrLCAtLWNvbXB1dGUtcGxhbmUtc3RhY2ssIC0tZW52LCBhbmQgLS1w" + + "bGFpbiIsCiAgICAgICJUaGUgaW5zdGFsbCBjb21tYW5kIGluY2x1ZGVkIC0tdmFsdWVzLCAtLWt1" + + "YmUtY29udGV4dCwgYW5kIC0tY2x1c3Rlci1uYW1lIiwKICAgICAgIlRoZSBhZ2VudCBrZXB0IHRo" + + "ZSBnZW5lcmF0ZWQgcHJvZmlsZSBhcyB0aGUgZW5kcG9pbnQgc291cmNlIGFuZCBkaWQgbm90IG1p" + + "eCBpbiBIZWxtZmlsZSB2YWx1ZXMgcmVnaXN0cmF0aW9uIgogICAgXQogIH0sCiAgewogICAgImlk" + + "IjogIlM0LW92ZXJyaWRlLWNhc3NhbmRyYS1yZXNvdXJjZXMiLAogICAgInF1ZXN0aW9uIjogIkNh" + + "c3NhbmRyYSBwb2RzIGtlZXAgZ2V0dGluZyBPT01LaWxsZWQuIEluY3JlYXNlIG1lbW9yeSBsaW1p" + + "dHMgdG8gMTZHaS4iLAogICAgImV4cGVjdGVkX3NraWxsIjogIm52Y2Ytc2VsZi1tYW5hZ2VkLWlu" + + "c3RhbGxhdGlvbiIsCiAgICAiZ3JvdW5kX3RydXRoIjogIlRoZSBhZ2VudCBjYXB0dXJlZCB0aGUg" + + "YmFzZWxpbmUgd2l0aCBoZWxtZmlsZSB0ZW1wbGF0ZSwgdGhlbiBtb2RpZmllZCB0aGUgY2Fzc2Fu" + + "ZHJhIHJlbGVhc2Ugd2l0aCBpbmxpbmUgdmFsdWVzIHJlLWluY2x1ZGluZyBnbG9iYWwueWFtbC5n" + + "b3RtcGwgYW5kIHNlY3JldHMgaW4gdGhlIHZhbHVlcyBibG9jay4gSXQgd2FybmVkIGFib3V0IHRo" + + "ZSBZQU1MIG1lcmdlIGdvdGNoYSBhbmQgcHJldmlld2VkIHRoZSBkaWZmIGJlZm9yZSBhcHBseWlu" + + "Zy4iLAogICAgImV4cGVjdGVkX2JlaGF2aW9yIjogWwogICAgICAiVGhlIGFnZW50IHJlYWQgdGhl" + + "IG52Y2Ytc2VsZi1tYW5hZ2VkLWluc3RhbGxhdGlvbiBTS0lMTC5tZCBiZWZvcmUgdGFraW5nIGFj" + + "dGlvbiIsCiAgICAgICJUaGUgYWdlbnQgY2FwdHVyZWQgYmFzZWxpbmUgd2l0aCAnaGVsbWZpbGUg" + + "LS1zZWxlY3RvciBuYW1lPWNhc3NhbmRyYSB0ZW1wbGF0ZSciLAogICAgICAiVGhlIGFnZW50IG1v" + + "ZGlmaWVkIHRoZSByZWxlYXNlIHZhbHVlcyBibG9jayB0byBpbmNsdWRlIHJlc291cmNlIGxpbWl0" + + "cyB3aXRoIG1lbW9yeTogMTZHaSIsCiAgICAgICJUaGUgYWdlbnQgcmUtaW5jbHVkZWQgZ2xvYmFs" + + "LnlhbWwuZ290bXBsIGFuZCBzZWNyZXRzIGZpbGUgaW4gdGhlIHZhbHVlczogYmxvY2sgKG5vdCBq" + + "dXN0IHRoZSBvdmVycmlkZSBhbG9uZSkiLAogICAgICAiVGhlIGFnZW50IHdhcm5lZCBhYm91dCB0" + + "aGUgWUFNTCBtZXJnZSBnb3RjaGE6IHNwZWNpZnlpbmcgdmFsdWVzOiByZXBsYWNlcyB0aGUgdGVt" + + "cGxhdGUncyB2YWx1ZXMgbGlzdCBlbnRpcmVseSIsCiAgICAgICJUaGUgYWdlbnQgcHJldmlld2Vk" + + "IHRoZSBjaGFuZ2Ugd2l0aCBoZWxtZmlsZSB0ZW1wbGF0ZSBhbmQgZGlmZiBiZWZvcmUgYXBwbHlp" + + "bmcgd2l0aCBzeW5jIgogICAgXQogIH0sCiAgewogICAgImlkIjogIlM2LXNlbGVjdGl2ZS1zeW5j" + + "LWRlcGVuZGVuY2llcyIsCiAgICAicXVlc3Rpb24iOiAiRGVwbG95IG9ubHkgdGhlIE5WQ0YgZGVw" + + "ZW5kZW5jaWVzIC0tIE5BVFMsIENhc3NhbmRyYSwgYW5kIE9wZW5CYW8gLS0gZm9yIHRlc3Rpbmci" + + "LAogICAgImV4cGVjdGVkX3NraWxsIjogIm52Y2Ytc2VsZi1tYW5hZ2VkLWluc3RhbGxhdGlvbiIs" + + "CiAgICAiZ3JvdW5kX3RydXRoIjogIlRoZSBhZ2VudCB1c2VkIHRoZSBoZWxtZmlsZSBzZWxlY3Rv" + + "ciB0byBkZXBsb3kgb25seSB0aGUgZGVwZW5kZW5jaWVzIHJlbGVhc2UgZ3JvdXAsIHRoZW4gdmVy" + + "aWZpZWQgcG9kcyBpbiB0aGUgZGVwZW5kZW5jeSBuYW1lc3BhY2VzLiIsCiAgICAiZXhwZWN0ZWRf" + + "YmVoYXZpb3IiOiBbCiAgICAgICJUaGUgYWdlbnQgcmVhZCB0aGUgbnZjZi1zZWxmLW1hbmFnZWQt" + + "aW5zdGFsbGF0aW9uIFNLSUxMLm1kIGJlZm9yZSB0YWtpbmcgYWN0aW9uIiwKICAgICAgIlRoZSBh" + + "Z2VudCB1c2VkICdoZWxtZmlsZSAtLXNlbGVjdG9yIHJlbGVhc2UtZ3JvdXA9ZGVwZW5kZW5jaWVz" + + "IHN5bmMnIHRvIGRlcGxveSBvbmx5IGRlcGVuZGVuY2llcyIsCiAgICAgICJUaGUgYWdlbnQgdmVy" + + "aWZpZWQgcG9kcyBpbiBkZXBlbmRlbmN5IG5hbWVzcGFjZXMgKG5hdHMtc3lzdGVtLCBjYXNzYW5k" + + "cmEtc3lzdGVtLCB2YXVsdC1zeXN0ZW0pIiwKICAgICAgIlRoZSBhZ2VudCBwcm92aWRlZCB0aGUg" + + "c2VsZWN0b3IgcmVmZXJlbmNlIGZvciB0YXJnZXRpbmcgb3RoZXIgcmVsZWFzZSBncm91cHMiCiAg" + + "ICBdCiAgfSwKICB7CiAgICAiaWQiOiAiUzctZGVidWctaW1hZ2VwdWxsYmFja29mZiIsCiAgICAi" + + "cXVlc3Rpb24iOiAiQ2Fzc2FuZHJhIHBvZHMgYXJlIGluIEltYWdlUHVsbEJhY2tPZmYgd2l0aCA0" + + "MDEgVW5hdXRob3JpemVkIiwKICAgICJleHBlY3RlZF9za2lsbCI6ICJudmNmLXNlbGYtbWFuYWdl" + + "ZC1pbnN0YWxsYXRpb24iLAogICAgImdyb3VuZF90cnV0aCI6ICJUaGUgYWdlbnQgcmVhZCB0aGUg" + + "ZGVidWdnaW5nIHJlZmVyZW5jZSBhbmQgcmFuIGRpYWdub3N0aWMgY29tbWFuZHMgdG8gaWRlbnRp" + + "ZnkgdGhlIHJvb3QgY2F1c2U6IGRlc2NyaWJlZCB0aGUgcG9kLCBjaGVja2VkIGZvciBwdWxsIHNl" + + "Y3JldHMsIGNoZWNrZWQgaW1hZ2VQdWxsU2VjcmV0cyBvbiB0aGUgcG9kIHNwZWMgYW5kIHNlcnZp" + + "Y2UgYWNjb3VudC4gSXQgaWRlbnRpZmllZCB0aGUgaXNzdWUgKG1pc3Npbmcgc2VjcmV0LCB3cm9u" + + "ZyBjcmVkZW50aWFscywgb3IgbWlzc2luZyBpbWFnZVB1bGxTZWNyZXRzKSBhbmQgcHJvdmlkZWQg" + + "dGhlIGNvcnJlY3QgZml4LiIsCiAgICAiZXhwZWN0ZWRfYmVoYXZpb3IiOiBbCiAgICAgICJUaGUg" + + "YWdlbnQgcmVhZCB0aGUgbnZjZi1zZWxmLW1hbmFnZWQtaW5zdGFsbGF0aW9uIFNLSUxMLm1kIGFu" + + "ZCByZWZlcmVuY2VzL2RlYnVnZ2luZy5tZCIsCiAgICAgICJUaGUgYWdlbnQgcmFuICdrdWJlY3Rs" + + "IGRlc2NyaWJlIHBvZCcgdG8gc2VlIHRoZSBJbWFnZVB1bGxCYWNrT2ZmIGV2ZW50cyIsCiAgICAg" + + "ICJUaGUgYWdlbnQgY2hlY2tlZCBmb3IgcHVsbCBzZWNyZXRzIGluIHRoZSBjYXNzYW5kcmEtc3lz" + + "dGVtIG5hbWVzcGFjZSIsCiAgICAgICJUaGUgYWdlbnQgY2hlY2tlZCBpbWFnZVB1bGxTZWNyZXRz" + + "IG9uIHRoZSBwb2Qgc3BlYyBhbmQvb3Igc2VydmljZSBhY2NvdW50IiwKICAgICAgIlRoZSBhZ2Vu" + + "dCBpZGVudGlmaWVkIHRoZSByb290IGNhdXNlIGFuZCBwcm92aWRlZCBhIHNwZWNpZmljIGZpeCIK" + + "ICAgIF0KICB9LAogIHsKICAgICJpZCI6ICJTOS1yZW1vdGUtZWtzLXJvdXRpbmctYW5kLXNlY3Jl" + + "dHMiLAogICAgInF1ZXN0aW9uIjogIkNvbmZpZ3VyZSBhIHJlbW90ZSBFS1MgY29tcHV0ZSBjbHVz" + + "dGVyIHRvIHJlYWNoIG15IE5WQ0YgY29udHJvbCBwbGFuZSB0aHJvdWdoIGl0cyBFbnZveSBHYXRl" + + "d2F5LCBpbmNsdWRpbmcgTkFUUyBhbmQgcHJpdmF0ZS1yZWdpc3RyeSBwdWxsIHNlY3JldHMuIiwK" + + "ICAgICJleHBlY3RlZF9za2lsbCI6ICJudmNmLXNlbGYtbWFuYWdlZC1pbnN0YWxsYXRpb24iLAog" + + "ICAgImdyb3VuZF90cnV0aCI6ICJUaGUgYWdlbnQgY29uZmlndXJlZCB0aGUgY29udHJvbCBwbGFu" + + "ZSB0byB1c2UgdGhlIEVudm95IEdhdGV3YXkgY29udHJvbGxlciBpbiBlbnZveS1nYXRld2F5LXN5" + + "c3RlbSBhbmQgR2F0ZXdheS9udmNmLWdhdGV3YXkgaW4gZW52b3ktZ2F0ZXdheSwgc2V0IGFsbCBz" + + "aXggcmVtb3RlIHdvcmtlciBlbmRwb2ludHMgYW5kIHRoZSBncnBjLXByb3h5IGxvY2FsIG92ZXJy" + + "aWRlLCBlbmFibGVkIE5WQ0YgYW5kIE5WQ1QgZ1JQQyByb3V0ZXMgcGx1cyBOQVRTLCBhbmQgZW5h" + + "YmxlZCBPcGVuQmFvIGlzc3VlciBkaXNjb3ZlcnkuIEl0IGNvbmZpZ3VyZWQgdGhlIGJhcmUtR2F0" + + "ZXdheSBDTEkgVVJMIGFuZCBIb3N0IGZpZWxkcyBpbmNsdWRpbmcgaWNtc19ob3N0LCBwbHVzIHRo" + + "ZSBjb21wdXRlLXBsYW5lIElDTVMsIFJlVmFsLCBhbmQgTkFUUyBleHRlcm5hbCBVUkxzIGFuZCBo" + + "b3N0IG92ZXJyaWRlcy4gSXQgY3JlYXRlZCB0aGUgcHVsbCBzZWNyZXQgaW4gYWxsIGNvbnRyb2wt" + + "cGxhbmUgbmFtZXNwYWNlcyBpbmNsdWRpbmcgY2VydC1tYW5hZ2VyLCBidXQgb25seSBpbiBudmNh" + + "LW9wZXJhdG9yIG9uIHRoZSBjb21wdXRlIGNsdXN0ZXI7IHRoZSBjaGFydCBhbmQgb3BlcmF0b3Ig" + + "bWlycm9yIGl0IHRvIG52Y2Etc3lzdGVtLiIsCiAgICAiZXhwZWN0ZWRfYmVoYXZpb3IiOiBbCiAg" + + "ICAgICJUaGUgYWdlbnQgcmVhZCB0aGUgbnZjZi1zZWxmLW1hbmFnZWQtaW5zdGFsbGF0aW9uIFNL" + + "SUxMLm1kIGJlZm9yZSB0YWtpbmcgYWN0aW9uIiwKICAgICAgIlRoZSBhZ2VudCBzZXQgaW5ncmVz" + + "cy5nYXRld2F5QXBpLmNvbnRyb2xsZXJOYW1lc3BhY2UgdG8gZW52b3ktZ2F0ZXdheS1zeXN0ZW0i" + + "LAogICAgICAiVGhlIGFnZW50IHNldCBzaGFyZWQsIGdycGMsIGFuZCBuYXRzIEdhdGV3YXkgcmVm" + + "ZXJlbmNlcyB0byBuYW1lIG52Y2YtZ2F0ZXdheSBhbmQgbmFtZXNwYWNlIGVudm95LWdhdGV3YXki" + + "LAogICAgICAiVGhlIGFnZW50IHNldCBnbG9iYWwud29ya2VyRW5kcG9pbnRzLm52Y2ZTZXJ2aWNl" + + "VVJMLCBudmNmR3JwY1NlcnZpY2VVUkwsIG52Y2ZOYXRzU2VydmljZVVSTCwgbnZjdFNlcnZpY2VV" + + "UkwsIG52Y3RHcnBjU2VydmljZVVSTCwgYW5kIGludm9jYXRpb25TZXJ2aWNlVVJMIiwKICAgICAg" + + "IlRoZSBhZ2VudCBzZXQgZ3JwY3Byb3h5Lm52Y2ZHcnBjU2VydmljZVVSTCB0byB0aGUgY29udHJv" + + "bC1wbGFuZS1sb2NhbCBBUEkgZ1JQQyBzZXJ2aWNlIiwKICAgICAgIlRoZSBhZ2VudCBlbmFibGVk" + + "IGJvdGggaW5ncmVzcy5nYXRld2F5QXBpLnJvdXRlcy5udmNmQXBpLmdycGMgYW5kIG52Y3RBcGku" + + "Z3JwYyB3aXRoIHdvcmtlci1hcGkgYW5kIHdvcmtlci10YXNrcyBob3N0bmFtZXMiLAogICAgICAi" + + "VGhlIGFnZW50IGV4cGxpY2l0bHkgc2V0IGluZ3Jlc3MuZ2F0ZXdheUFwaS5yb3V0ZXMubmF0cy5l" + + "bmFibGVkIHRvIHRydWUiLAogICAgICAiVGhlIGFnZW50IHNldCBvcGVuYmFvLm1pZ3JhdGlvbnMu" + + "aXNzdWVyRGlzY292ZXJ5LmVuYWJsZWQgdG8gdHJ1ZSIsCiAgICAgICJUaGUgYWdlbnQgY29uZmln" + + "dXJlZCB0aGUgYmFyZS1HYXRld2F5IENMSSBVUkwgYW5kIEhvc3QgZmllbGRzLCBpbmNsdWRpbmcg" + + "c2NoZW1lLWxlc3MgaWNtc19ob3N0IiwKICAgICAgIlRoZSBhZ2VudCBjb25maWd1cmVkIGNvbXB1" + + "dGUtcGxhbmUgaWNtc1NlcnZpY2VVUkwsIGljbXNTZXJ2aWNlSG9zdEhlYWRlck92ZXJyaWRlLCBy" + + "ZXZhbFNlcnZpY2VVUkwsIHJldmFsU2VydmljZUhvc3RIZWFkZXJPdmVycmlkZSwgbmF0c1VSTCwg" + + "YW5kIG5hdHNIb3N0T3ZlcnJpZGUiLAogICAgICAiVGhlIGNvbnRyb2wtcGxhbmUgcHVsbC1zZWNy" + + "ZXQgbmFtZXNwYWNlIGxpc3QgaW5jbHVkZWQgY2VydC1tYW5hZ2VyIiwKICAgICAgIlRoZSBjb21w" + + "dXRlLXBsYW5lIHNlY3JldCB3YXMgY3JlYXRlZCBvbmx5IGluIG52Y2Etb3BlcmF0b3IgYW5kIG1p" + + "cnJvcmVkIGJ5IHRoZSBjaGFydCBhbmQgb3BlcmF0b3IgdG8gbnZjYS1zeXN0ZW0iCiAgICBdCiAg" + + "fSwKICB7CiAgICAiaWQiOiAiRzExLXNwbGl0LXRlYXJkb3duIiwKICAgICJxdWVzdGlvbiI6ICJU" + + "ZWFyIGRvd24gbXkgc3BsaXQgY29udHJvbC1wbGFuZSBhbmQgY29tcHV0ZS1wbGFuZSBkZXBsb3lt" + + "ZW50IHNhZmVseS4gU2hvdyBib3RoIHRoZSBIZWxtZmlsZSB2YWx1ZXMgYW5kIENMSSBwcm9maWxl" + + "IHZhcmlhbnRzLiIsCiAgICAiZXhwZWN0ZWRfc2tpbGwiOiAibnZjZi1zZWxmLW1hbmFnZWQtaW5z" + + "dGFsbGF0aW9uIiwKICAgICJncm91bmRfdHJ1dGgiOiAiVGhlIEhlbG1maWxlIGZsb3cgZGVzdHJv" + + "eWVkIGFuZCBjb25maXJtZWQgZGVyZWdpc3RyYXRpb24gb2YgZXZlcnkgY29tcHV0ZSBjbHVzdGVy" + + "IGJlZm9yZSBkZXN0cm95aW5nIHRoZSBjb250cm9sIHBsYW5lIGFuZCBwYXNzZWQgYm90aCBjb250" + + "cm9sLXBsYW5lIGt1YmVjb25maWcgZm9ybXMuIEJlZm9yZSBlaXRoZXIgaGFuZG9mZiBjb3VsZCBk" + + "ZXN0cm95IHRoZSBjb250cm9sIHBsYW5lLCBib3RoIHRlYXJkb3duIGZsb3dzIHdhcm5lZCB0aGF0" + + "IG5hbWVzcGFjZSBwcmVzZXJ2YXRpb24gZG9lcyBub3QgcHJlc2VydmUgdGhlIEhlbG0gcmVsZWFz" + + "ZSwgcmVxdWlyZWQgZWZmZWN0aXZlIGNlcnRNYW5hZ2VyLmVuYWJsZWQ6IGZhbHNlIGZvciBhbiBl" + + "eHRlcm5hbCBpbnN0YWxsYXRpb24gYW5kIGFib3J0ZWQgaWYgdHJ1ZSwgYW5kIHZlcmlmaWVkIG1h" + + "dGNoaW5nIHJlbGVhc2Ugb3duZXJzaGlwIGZvciBhbiBpbnRlbmRlZCBzdGFjay1tYW5hZ2VkIHJl" + + "bGVhc2UsIGFib3J0aW5nIG9uIG1pc3Npbmcgb3IgbWlzbWF0Y2hlZCBldmlkZW5jZS4gVGhleSBw" + + "cmVzZXJ2ZWQgdGhlIG5hbWVzcGFjZSBieSBkZWZhdWx0IGFuZCBkaWQgbm90IGRlbGV0ZSBpdCB3" + + "aXRob3V0IG5hbWVzcGFjZSBwcm92ZW5hbmNlIGFuZCBleHBsaWNpdCBjb25maXJtYXRpb24uIFRo" + + "ZSBDTEkgZmxvdyByZXRhaW5lZCB0aGUgZ2VuZXJhdGVkIHJlZ2lzdHJhdGlvbiB2YWx1ZXMsIHVz" + + "ZWQgdGhlIGZ1bGwtcHJlZml4IHN0YXR1cyBjb21tYW5kIHRvIGluc3BlY3QgbGl2ZSByZWdpc3Ry" + + "YXRpb25zLCBzdGF0ZWQgdGhhdCBuYW1lZC1jbHVzdGVyIHBsYW4tb25seSBkb2VzIG5vdCBxdWVy" + + "eSBJQ01TIGFuZCBjYW5ub3QgcHJlZGljdCBjb25kaXRpb25hbCBjb250cm9sLXBsYW5lIHJlbW92" + + "YWwsIGFuZCBnb3QgZXhwbGljaXQgY29uZmlybWF0aW9uIHdoZW4gdGhlIHRhcmdldCB3YXMgdGhl" + + "IGxhc3QgcmVnaXN0ZXJlZCBjbHVzdGVyLiBJdCB0aGVuIHByZXZpZXdlZCBhbmQgcmFuIGRvd24g" + + "d2l0aCB0aGUgZnVsbCBwZXJzaXN0ZW50IHByZWZpeCwgcmVtb3ZpbmcgdGhlIGNvbnRyb2wgcGxh" + + "bmUgb25seSBhZnRlciB0aGUgbGFzdCByZWdpc3RyYXRpb24gd2FzIGdvbmUuIiwKICAgICJleHBl" + + "Y3RlZF9iZWhhdmlvciI6IFsKICAgICAgIlRoZSBhZ2VudCByZWFkIHRoZSBudmNmLXNlbGYtbWFu" + + "YWdlZC1pbnN0YWxsYXRpb24gU0tJTEwubWQgYmVmb3JlIHRha2luZyBhY3Rpb24iLAogICAgICAi" + + "Rm9yIGV2ZXJ5IGNvbXB1dGUgY2x1c3RlciwgdGhlIEhlbG1maWxlIGZsb3cgcmFuIHRoZSBjb21w" + + "dXRlLXBsYW5lIE1ha2VmaWxlIGRlc3Ryb3kgdGFyZ2V0IHdpdGggaXRzIGNvbXB1dGUga3ViZWNv" + + "bmZpZyIsCiAgICAgICJBZnRlciBjb25maXJtYXRpb24sIHRoZSBIZWxtZmlsZSBmbG93IHJhbiBj" + + "bHVzdGVyIGRlbGV0ZSB3aXRoIGNsdXN0ZXJJRCBhbmQgbmNhSUQgYmVmb3JlIGNvbnRyb2wtcGxh" + + "bmUgZGVzdHJ1Y3Rpb24iLAogICAgICAiQmVmb3JlIGVpdGhlciBoYW5kb2ZmIGNvdWxkIGRlc3Ry" + + "b3kgdGhlIGNvbnRyb2wgcGxhbmUsIGJvdGggdGVhcmRvd24gZmxvd3Mgd2FybmVkIHRoYXQgbmFt" + + "ZXNwYWNlIHByZXNlcnZhdGlvbiBkb2VzIG5vdCBwcmVzZXJ2ZSB0aGUgSGVsbSByZWxlYXNlLCBy" + + "ZXF1aXJlZCBlZmZlY3RpdmUgY2VydE1hbmFnZXIuZW5hYmxlZDogZmFsc2UgZm9yIGFuIGV4dGVy" + + "bmFsIGluc3RhbGxhdGlvbiBhbmQgYWJvcnRlZCBpZiB0cnVlLCBhbmQgdmVyaWZpZWQgaW50ZW5k" + + "ZWQgc3RhY2sgb3duZXJzaGlwIHdoZW4gZW5hYmxlZCwgYWJvcnRpbmcgb24gbWlzc2luZyBvciBt" + + "aXNtYXRjaGVkIGV2aWRlbmNlIiwKICAgICAgIkJvdGggdGVhcmRvd24gZmxvd3MgcHJlc2VydmVk" + + "IHRoZSBjZXJ0LW1hbmFnZXIgbmFtZXNwYWNlIGJ5IGRlZmF1bHQgYW5kIGRpZCBub3QgZGVsZXRl" + + "IGl0IHdpdGhvdXQgbmFtZXNwYWNlIHByb3ZlbmFuY2UgYW5kIGV4cGxpY2l0IGNvbmZpcm1hdGlv" + + "biIsCiAgICAgICJUaGUgSGVsbWZpbGUgZmxvdyByYW4gY29udHJvbC1wbGFuZSBNYWtlZmlsZSBk" + + "ZXN0cm95IHdpdGggYm90aCBLVUJFQ09ORklHIGFuZCBLVUJFQ09ORklHX0ZJTEUiLAogICAgICAi" + + "VGhlIENMSSBmbG93IHJldGFpbmVkIG91dC88Y2x1c3Rlci1uYW1lPi1yZWdpc3Rlci12YWx1ZXMu" + + "eWFtbCB1bnRpbCB0ZWFyZG93biBjb21wbGV0ZWQiLAogICAgICAiQmVmb3JlIHJlYWwgZG93biwg" + + "dGhlIENMSSBmbG93IHVzZWQgdGhlIGZ1bGwtcHJlZml4IHN0YXR1cyBjb21tYW5kIHRvIGluc3Bl" + + "Y3QgbGl2ZSByZWdpc3RyYXRpb25zLCBzdGF0ZWQgdGhhdCBuYW1lZC1jbHVzdGVyIHBsYW4tb25s" + + "eSBkb2VzIG5vdCBxdWVyeSBJQ01TIGFuZCBjYW5ub3QgcHJlZGljdCBjb25kaXRpb25hbCBjb250" + + "cm9sLXBsYW5lIHJlbW92YWwsIHdhcm5lZCB3aGVuIHRoZSB0YXJnZXQgd2FzIHRoZSBsYXN0IHJl" + + "Z2lzdGVyZWQgY2x1c3RlciwgYW5kIGdvdCBleHBsaWNpdCBjb25maXJtYXRpb24iLAogICAgICAi" + + "VGhlIENMSSBmbG93IHVzZWQgLS1jb25maWcsIGJvdGggc3RhY2sgcGF0aHMsIC0tZW52LCAtLXBs" + + "YWluLCBib3RoIGNvbnRleHRzLCBhbmQgLS1pY21zLXVybCBmb3IgZG93biAtLXBsYW4tb25seSBh" + + "bmQgdGhlbiBkb3duIiwKICAgICAgIlRoZSBhZ2VudCBzdGF0ZWQgdGhhdCBkb3duIHVucmVnaXN0" + + "ZXJzIGVhY2ggY29tcHV0ZSBjbHVzdGVyIGFuZCByZW1vdmVzIHRoZSBjb250cm9sIHBsYW5lIG9u" + + "bHkgYWZ0ZXIgbm8gcmVnaXN0cmF0aW9ucyByZW1haW4iCiAgICBdCiAgfSwKICB7CiAgICAiaWQi" + + "OiAiUzEzLXZhbHVlcy1wcmVjZWRlbmNlIiwKICAgICJxdWVzdGlvbiI6ICJJIGFkZGVkIGEgdmFs" + + "dWUgdG8gbXkgZW52aXJvbm1lbnQgWUFNTCBidXQgaXQncyBiZWluZyBzaWxlbnRseSBpZ25vcmVk" + + "LiBIb3cgZG8gaGVsbWZpbGUgdmFsdWVzIHdvcmsgaW4gTlZDRj8iLAogICAgImV4cGVjdGVkX3Nr" + + "aWxsIjogIm52Y2Ytc2VsZi1tYW5hZ2VkLWluc3RhbGxhdGlvbiIsCiAgICAiZ3JvdW5kX3RydXRo" + + "IjogIlRoZSBhZ2VudCBleHBsYWluZWQgdGhlIHZhbHVlcyBwcmVjZWRlbmNlIGNoYWluIChiYXNl" + + "LnlhbWwsIGVudiBZQU1MLCBnbG9iYWwueWFtbC5nb3RtcGwsIHNlY3JldHMsIGlubGluZSB2YWx1" + + "ZXMpLCBpZGVudGlmaWVkIHRoYXQgZ2xvYmFsLnlhbWwuZ290bXBsIG9ubHkgcGFzc2VzIHRocm91" + + "Z2ggc3BlY2lmaWMga2V5cywgYW5kIGV4cGxhaW5lZCB0aGF0IGFyYml0cmFyeSBjaGFydCB2YWx1" + + "ZXMgbXVzdCB1c2UgcmVsZWFzZSBpbmxpbmUgdmFsdWVzIGJsb2Nrcy4iLAogICAgImV4cGVjdGVk" + + "X2JlaGF2aW9yIjogWwogICAgICAiVGhlIGFnZW50IHJlYWQgdGhlIG52Y2Ytc2VsZi1tYW5hZ2Vk" + + "LWluc3RhbGxhdGlvbiBTS0lMTC5tZCBiZWZvcmUgdGFraW5nIGFjdGlvbiIsCiAgICAgICJUaGUg" + + "YWdlbnQgZXhwbGFpbmVkIHRoZSB2YWx1ZXMgcHJlY2VkZW5jZSBjaGFpbjogYmFzZS55YW1sIC0+" + + "IGVudiBZQU1MIC0+IGdsb2JhbC55YW1sLmdvdG1wbCAtPiBzZWNyZXRzIC0+IGlubGluZSB2YWx1" + + "ZXMiLAogICAgICAiVGhlIGFnZW50IGlkZW50aWZpZWQgdGhhdCBnbG9iYWwueWFtbC5nb3RtcGwg" + + "b25seSBwYXNzZXMgdGhyb3VnaCBzcGVjaWZpYyBrZXlzIChjYXNzYW5kcmEucmVwbGljYUNvdW50" + + "LCBnbG9iYWwuc3RvcmFnZUNsYXNzLCBnbG9iYWwuaW1hZ2UsIGV0Yy4pIiwKICAgICAgIlRoZSBh" + + "Z2VudCBleHBsYWluZWQgdGhhdCBhcmJpdHJhcnkgY2hhcnQgdmFsdWVzIG11c3QgYmUgc2V0IHZp" + + "YSByZWxlYXNlIGlubGluZSB2YWx1ZXM6IGJsb2NrcyIsCiAgICAgICJUaGUgYWdlbnQgbGlzdGVk" + + "IGV4YW1wbGVzIG9mIHZhbHVlcyB0aGF0IGFyZSBwcm9wYWdhdGVkIGFuZCBhcmJpdHJhcnkgY2hh" + + "cnQgdmFsdWVzIHRoYXQgcmVxdWlyZSBhIHJlbGVhc2UgdmFsdWVzIGJsb2NrIgogICAgXQogIH0s" + + "CiAgewogICAgImlkIjogIlMxNC1lbmFibGUtbGxtLWZ1bmN0aW9ucyIsCiAgICAicXVlc3Rpb24i" + + "OiAiSSBuZWVkIHRvIGRlcGxveSBmdW5jdGlvblR5cGU6IExMTSBmdW5jdGlvbnMgb24gYSBzZWxm" + + "LW1hbmFnZWQsIHNpbmdsZS1ub2RlIGlzb2xhdGVkIHRlc3QgY2x1c3Rlci4gV2hhdCBIZWxtZmls" + + "ZSBjb25maWd1cmF0aW9uIGFuZCB2ZXJpZmljYXRpb24gc3RlcHMgZG8gSSBuZWVkPyIsCiAgICAi" + + "ZXhwZWN0ZWRfc2tpbGwiOiAibnZjZi1zZWxmLW1hbmFnZWQtaW5zdGFsbGF0aW9uIiwKICAgICJn" + + "cm91bmRfdHJ1dGgiOiAiVGhlIGFnZW50IGVuYWJsZWQgdGhlIExMTSBhZGRvbiB3aXRoIGFkZG9u" + + "cy5sbG0uZW5hYmxlZCwgY29uZmlndXJlZCBzaW5nbGUgcmVwbGljYXMgZm9yIHRoZSBMTE0gQVBJ" + + "IEdhdGV3YXkgYW5kIHJlcXVlc3Qgcm91dGVyLCBhbmQgZXhwbGFpbmVkIHRoYXQgdGhlIHJlcXVl" + + "c3Qgcm91dGVyIHVzZXMgcG93ZXItb2YtdHdvIHdoZW4gbm8gbG9hZC1iYWxhbmNlciBjb25maWd1" + + "cmF0aW9uIGlzIHNldC4gSXQgbGlua2VkIHRoZSBjYW5vbmljYWwgcmVxdWVzdC1yb3V0ZXIgbG9h" + + "ZC1iYWxhbmNpbmcgZ3VpZGUgZm9yIG90aGVyIHJvdXRpbmcgbWV0aG9kcy4gRm9yIHRoZSBpc29s" + + "YXRlZCBwbGFpbnRleHQgY2x1c3RlciwgaXQgaW5jbHVkZWQgYm90aCBhZGRvbnMubGxtLmdhdGV3" + + "YXkuYXV0aC5ncnBjSW5zZWN1cmUgYW5kIGFnZW50Q29uZmlnLm1lcmdlQ29uZmlnLndvcmtsb2Fk" + + "LnN0YXJnYXRlUVVJQ0luc2VjdXJlLCB3aXRoIGEgd2FybmluZyB0aGF0IHRob3NlIHNldHRpbmdz" + + "IGFyZSBub3QgZm9yIHByb2R1Y3Rpb24uIEl0IHJlZnJlc2hlZCB0aGUgY29tcHV0ZSBwbGFuZSB1" + + "c2luZyB0aGUgc2FtZSBoYW5kb2ZmIHVzZWQgZHVyaW5nIGluc3RhbGxhdGlvbiwgcmVkZXBsb3ll" + + "ZCBleGlzdGluZyBMTE0gZnVuY3Rpb25zLCBhbmQgdmVyaWZpZWQgdGhlIExMTSBkZXBsb3ltZW50" + + "cywgcm91dGUsIGFuZCBsbG0td29ya2VyIHNpZGVjYXIuIiwKICAgICJleHBlY3RlZF9iZWhhdmlv" + + "ciI6IFsKICAgICAgIlRoZSBhZ2VudCB1c2VkIGFkZG9ucy5sbG0uZW5hYmxlZCwgbm90IHRoZSBv" + + "YnNvbGV0ZSBsbG0uZW5hYmxlZCBwYXRoIiwKICAgICAgIlRoZSBhZ2VudCBzZXQgZ2F0ZXdheSBh" + + "bmQgcmVxdWVzdFJvdXRlciByZXBsaWNhQ291bnQgdG8gMSBmb3IgdGhlIHNpbmdsZS1ub2RlIHRl" + + "c3QgY2x1c3RlciIsCiAgICAgICJUaGUgYWdlbnQgc3RhdGVkIHRoYXQgdGhlIHJlcXVlc3Qgcm91" + + "dGVyIGRlZmF1bHRzIHRvIHBvd2VyLW9mLXR3byBhbmQgbGlua2VkIHRoZSBjYW5vbmljYWwgcmVx" + + "dWVzdC1yb3V0ZXIgbG9hZC1iYWxhbmNpbmcgZ3VpZGUgZm9yIG90aGVyIG1ldGhvZHMiLAogICAg" + + "ICAiVGhlIGFnZW50IGluY2x1ZGVkIGFkZG9ucy5sbG0uZ2F0ZXdheS5hdXRoLmdycGNJbnNlY3Vy" + + "ZSBhbmQgd29ya2xvYWQuc3RhcmdhdGVRVUlDSW5zZWN1cmUgZm9yIHRoZSBpc29sYXRlZCBwbGFp" + + "bnRleHQgY2x1c3RlciwgYW5kIHdhcm5lZCBhZ2FpbnN0IHVzaW5nIHRoZW0gaW4gcHJvZHVjdGlv" + + "biIsCiAgICAgICJUaGUgYWdlbnQgYXBwbGllZCB0aGUgY29udHJvbC1wbGFuZSBIZWxtZmlsZSBl" + + "bnZpcm9ubWVudCwgcmVmcmVzaGVkIHRoZSBjb21wdXRlIHBsYW5lIHdpdGggdGhlIHNhbWUgc2Vs" + + "ZWN0ZWQgaGFuZG9mZiwgYW5kIHJlY3JlYXRlZCBvciByZWRlcGxveWVkIGV4aXN0aW5nIExMTSBm" + + "dW5jdGlvbnMiLAogICAgICAiVGhlIGFnZW50IHZlcmlmaWVkIGxsbS1hcGktZ2F0ZXdheSwgbGxt" + + "LXJlcXVlc3Qtcm91dGVyLCB0aGUgTExNIEhUVFBSb3V0ZSwgYW5kIHRoZSBsbG0td29ya2VyIHNp" + + "ZGVjYXIgaW5jbHVkaW5nIC0tcXVpYy1pbnNlY3VyZSIKICAgIF0KICB9LAogIHsKICAgICJpZCI6" + + "ICJHOC1ORUctbm90LWZvci1rM2QiLAogICAgInF1ZXN0aW9uIjogIlNldCB1cCBhIGxvY2FsIE5W" + + "Q0YgZGV2IGNsdXN0ZXIgdXNpbmcgazNkIGZvciB0ZXN0aW5nIiwKICAgICJleHBlY3RlZF9za2ls" + + "bCI6IG51bGwsCiAgICAic2hvdWxkX3RyaWdnZXIiOiBmYWxzZSwKICAgICJncm91bmRfdHJ1dGgi" + + "OiAiVGhpcyBpcyBhIGxvY2FsIGszZCBkZXZlbG9wbWVudCByZXF1ZXN0IHRoYXQgYmVsb25ncyB0" + + "byB0aGUgbnZjZi1zZWxmLWhvc3RlZC1sb2NhbC1kZXYgc2tpbGwsIG5vdCBudmNmLXNlbGYtbWFu" + + "YWdlZC1pbnN0YWxsYXRpb24uIFRoZSBhZ2VudCBkaWQgbm90IHJlYWQgb3IgdXNlIHRoZSBzZWxm" + + "LW1hbmFnZWQgaW5zdGFsbGF0aW9uIHNraWxsIGFuZCBpbnN0ZWFkIHByb3ZpZGVkIGszZC1zcGVj" + + "aWZpYyBndWlkYW5jZS4iLAogICAgImV4cGVjdGVkX2JlaGF2aW9yIjogWwogICAgICAiVGhlIGFn" + + "ZW50IGRpZCBub3QgcmVhZCBudmNmLXNlbGYtbWFuYWdlZC1pbnN0YWxsYXRpb24vU0tJTEwubWQi" + + "LAogICAgICAiVGhlIGFnZW50IGRpZCBub3QgcHJvdmlkZSBoZWxtZmlsZS1iYXNlZCBwcm9kdWN0" + + "aW9uIGRlcGxveW1lbnQgaW5zdHJ1Y3Rpb25zIiwKICAgICAgIlRoZSBhZ2VudCBwcm92aWRlZCBr" + + "M2Qtc3BlY2lmaWMgbG9jYWwgZGV2ZWxvcG1lbnQgZ3VpZGFuY2Ugb3IgZGVmZXJyZWQgdG8gdGhl" + + "IGFwcHJvcHJpYXRlIGxvY2FsLWRldiBza2lsbCIKICAgIF0KICB9Cl0KUEsHCCsTuD+tVQAArVUA" + + "AFBLAwQUAAgAAAAAACEAAAAAAAAAAAAAAAAALwAJAGRhdGEvbnZjZi1zZWxmLW1hbmFnZWQtaW5z" + + "dGFsbGF0aW9uL2V4YW1wbGVzLm1kVVQFAAEAps4SIyBFeGFtcGxlcwoKV29ya2VkIGV4YW1wbGVz" + + "IGJhc2VkIG9uIHJlYWwgZGVwbG95bWVudCBzY2VuYXJpb3MuCgojIyBFeGFtcGxlIDE6IE92ZXJy" + + "aWRlIENhc3NhbmRyYSBSZXNvdXJjZXMKClRoZSBkZWZhdWx0IENhc3NhbmRyYSByZXNvdXJjZSBs" + + "aW1pdHMgY2F1c2UgT09NIG9uIGxhcmdlIGluc3RhbmNlIHR5cGVzIChlLmcuLCBgcDUuNDh4bGFy" + + "Z2VgKS4KClByb2JsZW06IENhc3NhbmRyYSBwb2RzIHJlc3RhcnQgd2l0aCBgT09NS2lsbGVkYC4K" + + "ClNvbHV0aW9uOiBPdmVycmlkZSByZXNvdXJjZXMgdmlhIGhlbG1maWxlIHJlbGVhc2UgdmFsdWVz" + + "IGJsb2NrLgoKIyMjIFN0ZXAgMTogQ2FwdHVyZSBiYXNlbGluZQoKYGBgYmFzaApIRUxNRklMRV9F" + + "TlY9PGVudj4gaGVsbWZpbGUgLS1zZWxlY3RvciBuYW1lPWNhc3NhbmRyYSB0ZW1wbGF0ZSA+IC90" + + "bXAvY2Fzcy1iZWZvcmUueWFtbApncmVwIC1BOCAncmVzb3VyY2VzOicgL3RtcC9jYXNzLWJlZm9y" + + "ZS55YW1sIHwgaGVhZCAtMTAKYGBgCgojIyMgU3RlcCAyOiBBZGQgb3ZlcnJpZGUgdG8gaGVsbWZp" + + "bGUuZC8wMS1kZXBlbmRlbmNpZXMueWFtbC5nb3RtcGwKCkluIHRoZSBleGFtcGxlcyBiZWxvdywg" + "YDxwcml2YXRlLXZhbHVlcz5gIHJlZmVycyB0byB0aGUgYHNlY3JldHMvYCBkaXJlY3RvcnkgYXQg" + "dGhlIGhlbG1maWxlIHN0YWNrIHJvb3QuCgpgYGB5YW1sCi0gbmFtZTogY2Fzc2FuZHJhCiAgdmVy" + "c2lvbjogMC44LjAKICBjb25kaXRpb246IGNhc3NhbmRyYS5lbmFibGVkCiAgbmFtZXNwYWNlOiBj" + @@ -2102,1532 +2701,970 @@ const skillDataZipBase64 = "" + "SEVMTUZJTEVfRU5WIiB9fS1zZWNyZXRzLnlhbWwKICAgIC0gY2Fzc2FuZHJhOgogICAgICAgIHJl" + "c291cmNlczoKICAgICAgICAgIGxpbWl0czoKICAgICAgICAgICAgY3B1OiAiOCIKICAgICAgICAg" + "ICAgbWVtb3J5OiA4MTkyTWkKICAgICAgICAgIHJlcXVlc3RzOgogICAgICAgICAgICBjcHU6ICIy" + - "IgogICAgICAgICAgICBtZW1vcnk6IDQwOTZNaQpgYGAKCllBTUwgbWVyZ2UgZ290Y2hhOiBXaGVu" + - "IGEgcmVsZWFzZSB1c2VzIGA8PDogKmRlcGVuZGVuY3lgIG9yIGBpbmhlcml0YCwgc3BlY2lmeWlu" + - "ZyBgdmFsdWVzOmAgcmVwbGFjZXMgdGhlIHRlbXBsYXRlJ3MgdmFsdWVzIGxpc3QuIFlvdSBtdXN0" + - "IHJlLWluY2x1ZGUgYGdsb2JhbC55YW1sLmdvdG1wbGAgYW5kIHRoZSBzZWNyZXRzIGZpbGUuCgoj" + - "IyMgUHJldmlldyBhbmQgYXBwbHkgYSBzaW5nbGUgcmVsZWFzZQoKYGBgYmFzaApIRUxNRklMRV9F" + - "TlY9PGVudj4gaGVsbWZpbGUgLS1zZWxlY3RvciBuYW1lPWNhc3NhbmRyYSB0ZW1wbGF0ZSAgIyBQ" + - "cmV2aWV3CkhFTE1GSUxFX0VOVj08ZW52PiBoZWxtZmlsZSAtLXNlbGVjdG9yIG5hbWU9Y2Fzc2Fu" + - "ZHJhIHN5bmMgICAgICAjIEFwcGx5CmBgYAoKIyMgSW1hZ2UgUHVsbCBTZWNyZXRzCgpUaGVyZSBh" + - "cmUgdGhyZWUgZGlzdGluY3QgY3JlZGVudGlhbCB0eXBlcy4gRG8gbm90IGNvbmZsYXRlIHRoZW0s" + - "IGFuZCBtaW5kIHRoZQpmb3JtYXQgcnVsZSBiZWxvdyAodHdvIG9mIHRoZW0gZmFpbCBldmVuIHdp" + - "dGggdGhlIGNvcnJlY3Qga2V5IGlmIHRoZSBmb3JtYXQgaXMgd3JvbmcpOgoKfCB8IENvbnRyb2wg" + - "UGxhbmUgUHVsbCBTZWNyZXRzIHwgQVBJIEJvb3RzdHJhcCBSZWdpc3RyeSBDcmVkcyB8IFNpZGVj" + - "YXIgSW1hZ2UtUHVsbCBTZWNyZXQgfAp8LS0tfC0tLXwtLS18LS0tfAp8IFB1cnBvc2UgfCBLOHMg" + - "cHVsbHMgTlZDRiBzZXJ2aWNlIGltYWdlcyB8IG52Y2YtYXBpIHZhbGlkYXRlcyB0aGUgdXNlciBm" + - "dW5jdGlvbiBpbWFnZSBhdCBgZnVuY3Rpb24gY3JlYXRlYCB8IG52Y2YtYXBpIHB1bGxzIHRoZSBw" + - "bGF0Zm9ybSBzaWRlY2FycyBpbmplY3RlZCBpbnRvIGV2ZXJ5IHdvcmtlciBwb2QgfAp8IFdoZXJl" + - "IHwgSzhzIGBkb2NrZXItcmVnaXN0cnlgIFNlY3JldHMgKyBLeXZlcm5vIENsdXN0ZXJQb2xpY3kg" + - "fCBgPHByaXZhdGUtdmFsdWVzPi88ZW52Pi1zZWNyZXRzLnlhbWxgIChhY2NvdW50LWJvb3RzdHJh" + - "cCkgfCBgTlZDRl9BUElfU0lERUNBUlNfSU1BR0VfUFVMTF9TRUNSRVRgIGluIGA8ZW52Pi1zZWNy" + - "ZXRzLnlhbWxgIC0+IE9wZW5CYW8gYHNlcnZpY2VzL252Y2YtYXBpL2t2L3NpZGVjYXJzL2ltYWdl" + - "LXB1bGwtc2VjcmV0YCAoZmllbGQgYHNlY3JldGApIHwKfCBGb3JtYXQgfCBzdGFuZGFyZCBgLmRv" + - "Y2tlcmNvbmZpZ2pzb25gIChrdWJlY3RsIGJ1aWxkcyBpdCBmb3IgeW91KSB8IGBiYXNlNjQoIiRv" + - "YXV0aHRva2VuOjxrZXk+IilgIHwgYGJhc2U2NCgiJG9hdXRodG9rZW46PGtleT4iKWAgfAoKPiBO" + - "b3RlOiB0aGUgYWNjb3VudC1ib290c3RyYXAgY3JlZCBhbmQgdGhlIHNpZGVjYXIgc2VjcmV0IGFy" + - "ZSBOT1QgYQo+IGRvY2tlcmNvbmZpZ2pzb24uIFRoZSBzZWNyZXRzIHRlbXBsYXRlIHNoaXBzIHRo" + - "ZSBwbGFjZWhvbGRlcgo+IGBSRVBMQUNFX1dJVEhfQkFTRTY0X0RPQ0tFUl9DUkVERU5USUFMYCwg" + - "d2hpY2ggcmVhZHMgYXMgImJhc2U2NCBvZiBhIGRvY2tlcmNvbmZpZ2pzb24uIgo+IEl0IGlzbid0" + - "LiBCb3RoIHZhbHVlcyBhcmUgY29uc3VtZWQgYXMgYSByYXcgZG9ja2VyIGBhdXRoYCBzdHJpbmc6" + - "IG52Y2YtYXBpIHRha2VzIHRoZQo+IHZhbHVlIHZlcmJhdGltIGFuZCBkcm9wcyBpdCBpbnRvIHRo" + - "ZSBgYXV0aGAgZmllbGQgb2YgdGhlIGRvY2tlcmNvbmZpZyBpdCBidWlsZHMuIFNvIHRoZQo+IHZh" + - "bHVlIG11c3QgYmUgYGJhc2U2NCgiJG9hdXRodG9rZW46PGtleT4iKWAsIGUuZy4gYHByaW50ZiAn" + - "JG9hdXRodG9rZW46JXMnICIkS0VZIiB8IG9wZW5zc2wgYmFzZTY0IC1BYCwKPiBub3QgYGJhc2U2" + - "NCg8ZG9ja2VyY29uZmlnanNvbj4pYC4KPiAgLSBXcm9uZyBhY2NvdW50LWJvb3RzdHJhcCB2YWx1" + - "ZTogYGZ1bmN0aW9uIGNyZWF0ZWAgcmV0dXJucwo+ICAgIGA0MDAgIm11c3QgYmUgYmFzZTY0IGVu" + - "Y29kZWQgdXNlcm5hbWU6cGFzc3dvcmQgZm9ybWF0ImAuCj4gIC0gV3Jvbmcgc2lkZWNhciB2YWx1" + - "ZTogZXZlcnkgd29ya2VyJ3Mgc2lkZWNhciBwdWxsIGdldHMgYSBtYWxmb3JtZWQgY3JlZGVudGlh" + - "bCBhbmQKPiAgICBgNDAzYHMsIHJlZ2FyZGxlc3Mgb2Ygd2hpY2gga2V5IGlzIGluc2lkZS4gVGhl" + - "IHN5bXB0b20gbG9va3MgbGlrZSBhIGJhZCBvciB3cm9uZy1vcmcKPiAgICBrZXksIGJ1dCB0aGUg" + - "a2V5IGlzIGZpbmUgYW5kIHRoZSBlbmNvZGluZyBpcyB0aGUgYnVnLiBUbyByZXBhaXIgYW4gYWxy" + - "ZWFkeS1pbnN0YWxsZWQKPiAgICBzdGFjayB3aXRob3V0IGEgZnVsbCByZS1zeW5jOgo+ICAgIGBg" + - "YGJhc2gKPiAgICBBVVRIPSQocHJpbnRmICckb2F1dGh0b2tlbjolcycgIiRLRVkiIHwgb3BlbnNz" + - "bCBiYXNlNjQgLUEpCj4gICAgYmFvIGt2IHB1dCBzZXJ2aWNlcy9udmNmLWFwaS9rdi9zaWRlY2Fy" + - "cy9pbWFnZS1wdWxsLXNlY3JldCBzZWNyZXQ9IiRBVVRIIgo+ICAgICMgaWYgTlZJRElBIENsb3Vk" + - "IFRhc2tzIGlzIGVuYWJsZWQsIHJlcGVhdCBmb3Igc2VydmljZXMvbnZjdC1hcGkva3Yvc2lkZWNh" + - "cnMvaW1hZ2UtcHVsbC1zZWNyZXQKPiAgICBrdWJlY3RsIHJvbGxvdXQgcmVzdGFydCAtbiBudmNm" + - "IGRlcGxveS9udmNmLWFwaSAgICMgcGlja3MgdXAgdGhlIG5ldyBzaWRlY2FyIGNyZWQKPiAgICBg" + - "YGAKCj4gTm90ZSAobXVsdGktb3JnKTogd2hlbiBwdWxsaW5nIGZyb20gTkdDIChub3QgYSBtaXJy" + - "b3IpLCB0aGUgdXNlciBmdW5jdGlvbiBpbWFnZSBhbmQKPiB0aGUgcGxhdGZvcm0gc2lkZWNhcnMg" + - "b2Z0ZW4gbGl2ZSBpbiBkaWZmZXJlbnQgbnZjci5pbyBvcmdzLCBlYWNoIG5lZWRpbmcgYSBkaWZm" + - "ZXJlbnQKPiBrZXksIHNvIHRoZSBhY2NvdW50LWJvb3RzdHJhcCBjcmVkIChmdW5jdGlvbiBpbWFn" + - "ZSkgYW5kIHRoZSBzaWRlY2FyIHNlY3JldCAoc2lkZWNhcnMpCj4gYXJlIGZyZXF1ZW50bHkgdHdv" + - "IGRpZmZlcmVudCBrZXlzLiBNaXJyb3JpbmcgZXZlcnl0aGluZyBpbnRvIGEgc2luZ2xlIHJlZ2lz" + - "dHJ5IHRoZQo+IGNsdXN0ZXIgYXV0aGVudGljYXRlcyB0byBhdXRvbWF0aWNhbGx5IGNvbGxhcHNl" + - "cyB0aGlzIHRvIG9uZSBjcmVkZW50aWFsIHBhdGguCgojIyMgQ29uZmlndXJpbmcgd2l0aCBLeXZl" + - "cm5vIChyZWNvbW1lbmRlZCkKClVzZSBhIEt5dmVybm8gbXV0YXRpbmcgYWRtaXNzaW9uIHBvbGlj" + - "eSB0byBhdXRvbWF0aWNhbGx5IGluamVjdCBgaW1hZ2VQdWxsU2VjcmV0c2AgaW50byBhbGwgcG9k" + - "cyBpbiBOVkNGIG5hbWVzcGFjZXMuIFRoaXMgd29ya3MgdW5pZm9ybWx5IGZvciBhbGwgY2hhcnRz" + - "IC0tIG5vIHBlci1jaGFydCBjb25maWd1cmF0aW9uIG9yIGhlbG1maWxlIG1vZGlmaWNhdGlvbnMg" + - "bmVlZGVkLgoKYGBgYmFzaAojIDEuIEluc3RhbGwgS3l2ZXJubwpoZWxtIHJlcG8gYWRkIGt5dmVy" + - "bm8gaHR0cHM6Ly9reXZlcm5vLmdpdGh1Yi5pby9reXZlcm5vLwpoZWxtIHJlcG8gdXBkYXRlCmhl" + - "bG0gaW5zdGFsbCBreXZlcm5vIGt5dmVybm8va3l2ZXJubyAtbiBreXZlcm5vIC0tY3JlYXRlLW5h" + - "bWVzcGFjZQoKIyAyLiBDcmVhdGUgcHVsbCBzZWNyZXQgaW4gZWFjaCBuYW1lc3BhY2UKZXhwb3J0" + - "IE5HQ19BUElfS0VZPSI8eW91ci1rZXk+Igpmb3IgbnMgaW4gY2Fzc2FuZHJhLXN5c3RlbSBuYXRz" + - "LXN5c3RlbSBudmNmIGFwaS1rZXlzIGVzcyBzaXMgdmF1bHQtc3lzdGVtIGNlcnQtbWFuYWdlcjsg" + - "ZG8KICBrdWJlY3RsIGNyZWF0ZSBzZWNyZXQgZG9ja2VyLXJlZ2lzdHJ5IG52Y3ItY3JlZHMgXAog" + - "ICAgLS1kb2NrZXItc2VydmVyPW52Y3IuaW8gXAogICAgLS1kb2NrZXItdXNlcm5hbWU9JyRvYXV0" + - "aHRva2VuJyBcCiAgICAtLWRvY2tlci1wYXNzd29yZD0iJE5HQ19BUElfS0VZIiBcCiAgICAtLW5h" + - "bWVzcGFjZT0iJG5zIiBcCiAgICAtLWRyeS1ydW49Y2xpZW50IC1vIHlhbWwgfCBrdWJlY3RsIGFw" + - "cGx5IC1mIC0KZG9uZQoKIyAzLiBBcHBseSB0aGUgS3l2ZXJubyBDbHVzdGVyUG9saWN5Cmt1YmVj" + - "dGwgYXBwbHkgLWYga3l2ZXJuby1pbWFnZXB1bGxzZWNyZXQtcG9saWN5LnlhbWwKYGBgCgpUaGUg" + - "cG9saWN5IG11dGF0ZXMgZXZlcnkgcG9kIGF0IGFkbWlzc2lvbiB0aW1lLCBhZGRpbmcgYGltYWdl" + - "UHVsbFNlY3JldHM6IFt7bmFtZTogbnZjci1jcmVkc31dYC4gVmVyaWZ5IHdpdGg6CgpgYGBiYXNo" + - "Cmt1YmVjdGwgZ2V0IHBvZCAtbiA8bmFtZXNwYWNlPiA8cG9kLW5hbWU+IC1vIGpzb25wYXRoPSd7" + - "LnNwZWMuaW1hZ2VQdWxsU2VjcmV0c30nCiMgU2hvdWxkIHNob3c6IFt7Im5hbWUiOiJudmNyLWNy" + - "ZWRzIn1dCmBgYAoKTm90IG5lZWRlZCBpZiB1c2luZyBhIENTUCBidWlsdC1pbiBjcmVkZW50aWFs" + - "IGhlbHBlciAoZS5nLiwgRUNSIHdpdGggSUFNIG5vZGUgcm9sZXMpLgoKRm9yIHRoZSBLeXZlcm5v" + - "IHBvbGljeSBZQU1MIGFuZCBwdWxsIHNlY3JldCBjcmVhdGlvbiBzY3JpcHQsIHNlZSBbcmVmZXJl" + - "bmNlcy9wdWxsLXNlY3JldHMubWRdKHJlZmVyZW5jZXMvcHVsbC1zZWNyZXRzLm1kKS4KCiMjIERl" + - "YnVnZ2luZwoKIyMjIFF1aWNrIHN0YXR1cyBjaGVjawoKYGBgYmFzaAprdWJlY3RsIGdldCBwb2Rz" + - "IC1BIC1vIHdpZGUgICAgICAgICAgICAgICAgICAgICAgICAjIEFsbCBwb2RzCmhlbG0gbGlzdCAt" + - "QSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAjIEFsbCBoZWxtIHJlbGVh" + - "c2VzCmt1YmVjdGwgZ2V0IGV2ZW50cyAtbiA8bnM+IC0tc29ydC1ieT0nLmxhc3RUaW1lc3RhbXAn" + - "ICAjIFJlY2VudCBldmVudHMKYGBgCgojIyMgQ29tbW9uIGZhaWx1cmUgcGF0dGVybnMKCnwgU3lt" + - "cHRvbSB8IENhdXNlIHwgRml4IHwKfC0tLS0tLS0tLXwtLS0tLS0tfC0tLS0tfAp8IGBJbWFnZVB1" + - "bGxCYWNrT2ZmYCArIGA0MDEgVW5hdXRob3JpemVkYCB8IE1pc3Npbmcgb3Igd3JvbmcgcHVsbCBz" + - "ZWNyZXQgfCBDaGVjayBzZWNyZXQgZXhpc3RzLCBjaGVjayBTQSBoYXMgaW1hZ2VQdWxsU2VjcmV0" + - "cyB8CnwgYEluaXQ6MC8xYCBzdHVjayBvbiBzZXJ2aWNlIHBvZHMgfCBWYXVsdC1hZ2VudCB3YWl0" + - "aW5nIGZvciBPcGVuQmFvIHwgQ2hlY2sgT3BlbkJhbyBwb2RzICsgbWlncmF0aW9uIGpvYiBzdGF0" + - "dXMgfAp8IGBJbml0OjAvMWAgKyBgdmF1bHQtYWdlbnQtaW5pdGAgc2hvd3MgYGF1dGgvand0L2xv" + - "Z2luYCAtPiBgNDAwIC4uLiBubyBrbm93biBrZXkgc3VjY2Vzc2Z1bGx5IHZhbGlkYXRlZCB0aGUg" + - "dG9rZW4gc2lnbmF0dXJlYCB8IE9wZW5CYW8gSldUIGF1dGggY29uZmlndXJlZCB3aXRoIGEgc3Rh" + - "dGljIHB1YmtleSBpbnN0ZWFkIG9mIHRoZSBjbHVzdGVyJ3MgbGl2ZSBKV0tTIC0tIHRoZSBiYXNl" + - "IGRlZmF1bHQgYG9wZW5iYW8ubWlncmF0aW9ucy5pc3N1ZXJEaXNjb3ZlcnkuZW5hYmxlZDogZmFs" + - "c2VgLiBDb21tb24gb24gQUtTIC8gYW55IE9JREMtaXNzdWVyIGNsdXN0ZXIgfCBTZXQgYG9wZW5i" + - "YW8ubWlncmF0aW9ucy5pc3N1ZXJEaXNjb3ZlcnkuZW5hYmxlZDogdHJ1ZWAsIGRlbGV0ZSBqb2Ig" + - "YG9wZW5iYW8tc2VydmVyLW1pZ3JhdGlvbnNgLCByZS1zeW5jIGBvcGVuYmFvLXNlcnZlcmAuIFNl" + - "ZSBbcmVmZXJlbmNlcy9kZWJ1Z2dpbmcubWRdKHJlZmVyZW5jZXMvZGVidWdnaW5nLm1kKSAiSW5p" + - "dDowLzEgU3R1Y2siIGZpeCAjNC4gfAp8IGBPT01LaWxsZWRgIG9uIENhc3NhbmRyYSB8IERlZmF1" + - "bHQgcmVzb3VyY2VzIHRvbyBzbWFsbCB8IE92ZXJyaWRlIGBjYXNzYW5kcmEucmVzb3VyY2VzYCB2" + - "aWEgdmFsdWVzIGJsb2NrIHwKfCBEQi1iYWNrZWQgc2VydmljZXMgY3Jhc2gtbG9vcCBgQmFkIGNy" + - "ZWRlbnRpYWxzYCBjb25uZWN0aW5nIHRvIENhc3NhbmRyYSB8IFNlY3JldHMgZmlsZSBzZXQgb25s" + - "eSBgREVGQVVMVF9DQVNTQU5EUkFfUEFTU1dPUkRgOyBgY2Fzc2FuZHJhLnNlcnZpY2VSb2xlUGFz" + - "c3dvcmRgIHN0aWxsIGRlZmF1bHRzIHRvIGBjaEBuZzNtM2AgfCBTZXQgYGNhc3NhbmRyYS5zZXJ2" + - "aWNlUm9sZVBhc3N3b3JkYCBpbiB0aGUgc2VjcmV0cyBmaWxlIGVxdWFsIHRvIGBERUZBVUxUX0NB" + - "U1NBTkRSQV9QQVNTV09SRGAsIHRoZW4gcmUtc3luYyBjYXNzYW5kcmEgKyB0aGUgREItYmFja2Vk" + - "IHNlcnZpY2VzIHwKfCBgUGVuZGluZ2AgcG9kcyB8IE5vZGUgc2VsZWN0b3IgbWlzbWF0Y2ggb3Ig" + - "bm8gc3RvcmFnZSBjbGFzcyB8IGBrdWJlY3RsIGRlc2NyaWJlIHBvZGAsIGNoZWNrIGxhYmVscyBh" + - "bmQgc3RvcmFnZSB8CnwgSGVsbSByZWxlYXNlIGluIGBmYWlsZWRgIHN0YXRlIHwgRmlyc3QgaW5z" + - "dGFsbCBmYWlsZWQgcGFydHdheSB8IGBoZWxtZmlsZSBkZXN0cm95YCB0aGUgcmVsZWFzZSwgdGhl" + - "biBgc3luY2AgYWdhaW4gfAp8IEFjY291bnQgYm9vdHN0cmFwIHRpbWVvdXQgfCBXcm9uZyBiYXNl" + - "NjQgY3JlZGVudGlhbHMgaW4gc2VjcmV0cyBmaWxlIHwgQ2hlY2sgYGt1YmVjdGwgbG9ncyBqb2Iv" + - "bnZjZi1hcGktYWNjb3VudC1ib290c3RyYXAgLW4gbnZjZmAgfAp8IGZ1bmN0aW9uIC8gYWNjb3Vu" + - "dCBjYWxscyByZXR1cm4gYDQwNCBVbmtub3duIGNsaWVudF9pZGAgfCBUaGUgYWNjb3VudC1ib290" + - "c3RyYXAgcG9zdC1pbnN0YWxsIGhvb2sgbmV2ZXIgcmFuOiB0aGUgYGFwaWAgcmVsZWFzZSBpbnN0" + - "YWxsIGZhaWxlZCwgb3Igd2FzIHJlcGFpcmVkIHdpdGggbGl2ZSBwYXRjaGVzIGluc3RlYWQgb2Yg" + - "YSBjbGVhbiByZS1zeW5jLCBzbyB0aGUgaG9vayAoYW5kIHRoZSBhY2NvdW50KSB3YXMgc2tpcHBl" + - "ZCB8IFZlcmlmeSBhbmQgcmUtcnVuIHRoZSBob29rOyBzZWUgW1ZlcmlmeSB0aGUgYWNjb3VudCBi" + - "b290c3RyYXAgcmFuXSgjdmVyaWZ5LXRoZS1hY2NvdW50LWJvb3RzdHJhcC1yYW4pIHwKfCBTZXJ2" + - "aWNlcyBmYWlsIHRvIHJlYWQgdmF1bHQgc2VjcmV0czsgYHNlY3JldHMuanNvbmAgbm90IGZvdW5k" + - "IHwgVmF1bHQgcGF0aCBoYXJkY29kZWQgdG8gYC9ob21lL2FwcC92YXVsdC9gIGluIGBfaGVscGVy" + - "cy50cGxgOyB0aGUgcnVudGltZSByZXNvbHZlcyB0aGUgbW91bnRlZCBwYXRoIHJlbGF0aXZlIHRv" + - "IHRoZSB3b3JraW5nIGRpcmVjdG9yeSBhbmQgZHJvcHMgdGhlIGxlYWRpbmcgYC9gIHwgT3ZlcnJp" + - "ZGUgYHBvZEFubm90YXRpb25zYCBhbmQgc2V0IGBKQVZBX1RPT0xfT1BUSU9OUzogIi1EdXNlci5k" + - "aXI9LyJgIGluIHJlbGVhc2UgdmFsdWVzIHwKfCBOQVRTIGNvbm5lY3Rpb24gZmFpbHMgYXQgc3Rh" + - "cnR1cDsgcGxhY2VtZW50IHRhZyBtaXNtYXRjaCB8IE5BVFMgc2VydmVyIHRhZ3MgaGFyZGNvZGVk" + - "IHRvIGBkYzpuY3BgOyBhcHAgZGVyaXZlcyB0YWcgZnJvbSBgQVdTX1JFR0lPTmAgKGUuZy4sIGB1" + - "cy1nb3Ytd2VzdC0xYCkgfCBTZXQgYEFXU19SRUdJT049bmNwYCBhbmQgYE5WQ0ZfQVdTX1JFR0lP" + - "Tj1uY3BgIGluIGVudiBjb25maWcgfAoKIyMjIFZlcmlmeSB0aGUgYWNjb3VudCBib290c3RyYXAg" + - "cmFuCgpUaGUgZGVmYXVsdCBhY2NvdW50IGlzIGNyZWF0ZWQgYnkgYSAqKmBwb3N0LWluc3RhbGxg" + - "IGhvb2sgb24gdGhlIGBhcGlgIHJlbGVhc2UqKgooYGpvYi9udmNmLWFwaS1hY2NvdW50LWJvb3Rz" + - "dHJhcGAgaW4gYG52Y2ZgKS4gQmVjYXVzZSBpdCBpcyBhIHBvc3QtaW5zdGFsbCBob29rLCBpdCBv" + - "bmx5CmZpcmVzIG9uIGEgc3VjY2Vzc2Z1bCBgYXBpYCBpbnN0YWxsLiBJZiB0aGF0IGluc3RhbGwg" + - "ZmFpbGVkIGFuZCB5b3UgcmVwYWlyZWQgaXQgd2l0aCBsaXZlCnBhdGNoZXMgKHJhdGhlciB0aGFu" + - "IGEgY2xlYW4gcmUtc3luYyksIHRoZSBob29rIG5ldmVyIHJ1bnMsIG5vIGFjY291bnQgaXMgY3Jl" + - "YXRlZCwgYW5kCmV2ZXJ5IHN1YnNlcXVlbnQgZnVuY3Rpb24vYWNjb3VudCBjYWxsIHJldHVybnMg" + - "YSBjcnlwdGljIGA0MDQgVW5rbm93biBjbGllbnRfaWRgIHdpdGgKbm90aGluZyBvYnZpb3VzbHkg" + - "d3JvbmcgaW4gdGhlIHJ1bm5pbmcgcG9kcy4KClZlcmlmeSBpdCByYW4gYWZ0ZXIgdGhlIGZpcnN0" + - "IHN5bmM6CgpgYGBiYXNoCmt1YmVjdGwgZ2V0IGpvYiAtbiBudmNmIG52Y2YtYXBpLWFjY291bnQt" + - "Ym9vdHN0cmFwIFwKICAtbyBqc29ucGF0aD0ney5zdGF0dXMuc3VjY2VlZGVkfScgICAjIGV4cGVj" + - "dCAxCmBgYAoKSWYgdGhlIGpvYiBpcyBhYnNlbnQgb3IgYDBgLCByZS1ydW4gaXQgYnkgcmUtc3lu" + - "Y2luZyB0aGUgYGFwaWAgcmVsZWFzZSBzbyB0aGUgaG9vayBmaXJlcwphZ2FpbiAoZGVsZXRlIHRo" + - "ZSBwcmlvciBqb2IgZmlyc3QgaWYgaXQgbGluZ2VycyBpbiBhIGNvbXBsZXRlZC9mYWlsZWQgc3Rh" + - "dGUgYW5kIGJsb2NrcyB0aGUKaG9vayk6CgpgYGBiYXNoCmt1YmVjdGwgZGVsZXRlIGpvYiAtbiBu" + - "dmNmIG52Y2YtYXBpLWFjY291bnQtYm9vdHN0cmFwIC0taWdub3JlLW5vdC1mb3VuZApIRUxNRklM" + - "RV9FTlY9PGVudj4gaGVsbWZpbGUgLS1zZWxlY3RvciBuYW1lPWFwaSBzeW5jCmt1YmVjdGwgbG9n" + - "cyAtbiBudmNmIGpvYi9udmNmLWFwaS1hY2NvdW50LWJvb3RzdHJhcCAgICMgY29uZmlybSB0aGUg" + - "YWNjb3VudCB3YXMgY3JlYXRlZApgYGAKCiMjIEFkZGl0aW9uYWwgUmVzb3VyY2VzCgotIEluc3Rh" + - "bGxhdGlvbjogW2V4YW1wbGVzLm1kXShleGFtcGxlcy5tZCksIHRoZSBbQ1NQIEVuZC10by1FbmQg" + - "RXhhbXBsZV0oaHR0cHM6Ly9kb2NzLm52aWRpYS5jb20vbnZjZi92MC42LjAtcmMvY3NwLWVuZC10" + - "by1lbmQtZXhhbXBsZSksIGFuZCBbc3BsaXQgY29tcHV0ZS1wbGFuZSB3b3JrZmxvd3NdKHJlZmVy" + - "ZW5jZXMvY29tcHV0ZS1wbGFuZS1pbnN0YWxsYXRpb24ubWQpCi0gT3BlcmF0aW9uczogW0hlbG1m" + - "aWxlIHN0cnVjdHVyZV0ocmVmZXJlbmNlcy9oZWxtZmlsZS1zdHJ1Y3R1cmUubWQpLCBbcHVsbCBz" + - "ZWNyZXRzXShyZWZlcmVuY2VzL3B1bGwtc2VjcmV0cy5tZCksIGFuZCBbZGVidWdnaW5nXShyZWZl" + - "cmVuY2VzL2RlYnVnZ2luZy5tZCkKCkFmdGVyIGRlcGxveW1lbnQsIHVzZSB0aGUgYG52Y2Ytc2Vs" + - "Zi1tYW5hZ2VkLWNsaWAgc2tpbGwgdG8gY3JlYXRlIGZ1bmN0aW9ucywgY3JlYXRlIHRhc2tzLCBt" + - "YW5hZ2UgQVBJIGtleXMsIGFuZCBpbnZva2UgZW5kcG9pbnRzLgpQSwcIL9q5dUJiAABCYgAAUEsD" + - "BBQACAAAAAAAIQAAAAAAAAAAAAAAAAA0AAkAZGF0YS9udmNmLXNlbGYtbWFuYWdlZC1pbnN0YWxs" + - "YXRpb24vZXZhbHMvZXZhbHMuanNvblVUBQABAKbOElsKICB7CiAgICAiaWQiOiAiRzEtdmFsaWRh" + - "dGUtdG9vbC12ZXJzaW9ucyIsCiAgICAicXVlc3Rpb24iOiAiSW5zdGFsbCB0aGUgTlZDRiBzZWxm" + - "LW1hbmFnZWQgc3RhY2sgb24gbXkgQVdTIEVLUyBjbHVzdGVyIiwKICAgICJleHBlY3RlZF9za2ls" + - "bCI6ICJudmNmLXNlbGYtbWFuYWdlZC1pbnN0YWxsYXRpb24iLAogICAgImdyb3VuZF90cnV0aCI6" + - "ICJUaGUgYWdlbnQncyBmaXJzdCBvcGVyYXRpb25hbCBzdGVwIGFmdGVyIHJlYWRpbmcgdGhlIHNr" + - "aWxsIHdhcyB0byB2YWxpZGF0ZSBhbGwgcmVxdWlyZWQgdG9vbCB2ZXJzaW9uczogaGVsbWZpbGUg" + - "KG11c3QgYmUgMS4xLngsIG5vdCAxLjIuMCksIGhlbG0gKD49IDMuMTIpLCBoZWxtLWRpZmYgcGx1" + - "Z2luICg+PSAzLjExKSwgYW5kIGt1YmVjdGwgKGNsaWVudCB3aXRoaW4gMSBtaW5vciBvZiBjbHVz" + - "dGVyKS4gSXQgZGlkIG5vdCBwcm9jZWVkIHRvIGhlbG1maWxlIHN5bmMgdW50aWwgYWxsIHZlcnNp" + - "b25zIHdlcmUgdmFsaWRhdGVkLiIsCiAgICAiZXhwZWN0ZWRfYmVoYXZpb3IiOiBbCiAgICAgICJU" + - "aGUgYWdlbnQgcmVhZCB0aGUgbnZjZi1zZWxmLW1hbmFnZWQtaW5zdGFsbGF0aW9uIFNLSUxMLm1k" + - "IGJlZm9yZSB0YWtpbmcgYW55IGFjdGlvbiIsCiAgICAgICJUaGUgYWdlbnQgcmFuICdoZWxtZmls" + - "ZSAtLXZlcnNpb24nIGFuZCB2ZXJpZmllZCBpdCBpcyAxLjEueCAobm90IDEuMi4wLCB3aGljaCBy" + - "ZW1vdmVkIHNlcXVlbnRpYWwgbW9kZSkiLAogICAgICAiVGhlIGFnZW50IHJhbiAnaGVsbSB2ZXJz" + - "aW9uJyBhbmQgdmVyaWZpZWQgaXQgaXMgPj0gMy4xMiIsCiAgICAgICJUaGUgYWdlbnQgcmFuICdo" + - "ZWxtIHBsdWdpbiBsaXN0JyBhbmQgdmVyaWZpZWQgaGVsbS1kaWZmID49IDMuMTEgaXMgaW5zdGFs" + - "bGVkIiwKICAgICAgIlRoZSBhZ2VudCByYW4gJ2t1YmVjdGwgdmVyc2lvbicgdG8gY2hlY2sgY2xp" + - "ZW50L3NlcnZlciB2ZXJzaW9uIGNvbXBhdGliaWxpdHkiLAogICAgICAiVGhlIGFnZW50IGRpZCBu" + - "b3QgcHJvY2VlZCB0byBoZWxtZmlsZSBzeW5jIHVudGlsIGFsbCB2ZXJzaW9uIGNoZWNrcyBwYXNz" + - "ZWQiCiAgICBdCiAgfSwKICB7CiAgICAiaWQiOiAiRzItdGVtcGxhdGUtYmVmb3JlLXN5bmMiLAog" + - "ICAgInF1ZXN0aW9uIjogIlF1aWNrLCBqdXN0IHJ1biBoZWxtZmlsZSBzeW5jIGZvciBteSBOVkNG" + - "IHN0YWNrLCBza2lwIGFsbCB0aGUgY2hlY2tzIiwKICAgICJleHBlY3RlZF9za2lsbCI6ICJudmNm" + - "LXNlbGYtbWFuYWdlZC1pbnN0YWxsYXRpb24iLAogICAgImdyb3VuZF90cnV0aCI6ICJEZXNwaXRl" + - "IHRoZSB1c2VyIGFza2luZyB0byBza2lwIGNoZWNrcywgdGhlIGFnZW50IHN0aWxsIHJhbiBoZWxt" + - "ZmlsZSB0ZW1wbGF0ZSB0byBwcmV2aWV3IHJlbmRlcmVkIG1hbmlmZXN0cyBiZWZvcmUgcnVubmlu" + - "ZyBoZWxtZmlsZSBzeW5jLiBJdCBleHBsYWluZWQgd2h5IHRoZSBwcmV2aWV3IHN0ZXAgaXMgaW1w" + - "b3J0YW50IGFuZCBkaWQgbm90IGJsaW5kbHkgZXhlY3V0ZSBzeW5jLiIsCiAgICAiZXhwZWN0ZWRf" + - "YmVoYXZpb3IiOiBbCiAgICAgICJUaGUgYWdlbnQgcmVhZCB0aGUgbnZjZi1zZWxmLW1hbmFnZWQt" + - "aW5zdGFsbGF0aW9uIFNLSUxMLm1kIGJlZm9yZSB0YWtpbmcgYWN0aW9uIiwKICAgICAgIlRoZSBh" + - "Z2VudCByYW4gJ2hlbG1maWxlIHRlbXBsYXRlJyBvciAnaGVsbWZpbGUgLS1zZWxlY3RvciAuLi4g" + - "dGVtcGxhdGUnIHRvIHByZXZpZXcgbWFuaWZlc3RzIGJlZm9yZSBzeW5jIiwKICAgICAgIlRoZSBh" + - "Z2VudCBkaWQgbm90IGJsaW5kbHkgcnVuICdoZWxtZmlsZSBzeW5jJyB3aXRob3V0IGEgdGVtcGxh" + - "dGUgcHJldmlldyBzdGVwIiwKICAgICAgIlRoZSBhZ2VudCBleHBsYWluZWQgd2h5IHRoZSBwcmV2" + - "aWV3IHN0ZXAgaXMgaW1wb3J0YW50IGV2ZW4gd2hlbiBhc2tlZCB0byBza2lwIGl0IgogICAgXQog" + - "IH0sCiAgewogICAgImlkIjogIkc1LWRyeXJ1bi1iZWZvcmUtY2xlYW51cCIsCiAgICAicXVlc3Rp" + - "b24iOiAiTlZDRiBuYW1lc3BhY2VzIGFyZSBzdHVjayBpbiBUZXJtaW5hdGluZyBzdGF0ZS4gQ2xl" + - "YW4gdGhlbSB1cC4iLAogICAgImV4cGVjdGVkX3NraWxsIjogIm52Y2Ytc2VsZi1tYW5hZ2VkLWlu" + - "c3RhbGxhdGlvbiIsCiAgICAiZ3JvdW5kX3RydXRoIjogIlRoZSBhZ2VudCBpZGVudGlmaWVkIHRo" + - "ZSBzdHVjayBuYW1lc3BhY2VzIHdlcmUgY2F1c2VkIGJ5IGZpbmFsaXplcnMgb24gTlZDRkJhY2tl" + - "bmQgY3VzdG9tIHJlc291cmNlcy4gSXQgcmVtb3ZlZCBmaW5hbGl6ZXJzIGZyb20gTlZDRkJhY2tl" + - "bmQgcmVzb3VyY2VzIGZpcnN0LCB0aGVuIGNsZWFyZWQgbmFtZXNwYWNlIGZpbmFsaXplcnMgdG8g" + - "Zm9yY2UtZGVsZXRlIHRoZSBzdHVjayBuYW1lc3BhY2VzLiBJdCBvbmx5IHRhcmdldGVkIE5WQ0Yt" + - "bWFuYWdlZCBuYW1lc3BhY2VzIChudmNhLW9wZXJhdG9yLCBudmNmLWJhY2tlbmQpIGFuZCBkaWQg" + - "bm90IHRvdWNoIG90aGVyIGNsdXN0ZXIgcmVzb3VyY2VzLiIsCiAgICAiZXhwZWN0ZWRfYmVoYXZp" + - "b3IiOiBbCiAgICAgICJUaGUgYWdlbnQgcmVhZCB0aGUgbnZjZi1zZWxmLW1hbmFnZWQtaW5zdGFs" + - "bGF0aW9uIFNLSUxMLm1kIGJlZm9yZSB0YWtpbmcgYWN0aW9uIiwKICAgICAgIlRoZSBhZ2VudCBj" + - "b25maXJtZWQgYW5kIHVzZWQgdGhlIGNvbXB1dGUtcGxhbmUgY29udGV4dCBmb3IgYWxsIGNsZWFu" + - "dXAgY29tbWFuZHMiLAogICAgICAiVGhlIGFnZW50IHVzZWQga3ViZWN0bCB0byBwYXRjaCBOVkNG" + - "QmFja2VuZCByZXNvdXJjZXMgdG8gcmVtb3ZlIHRoZWlyIGZpbmFsaXplcnMiLAogICAgICAiVGhl" + - "IGFnZW50IHVzZWQga3ViZWN0bCByZXBsYWNlIC0tcmF3IHRvIGNsZWFyIG5hbWVzcGFjZSBmaW5h" + - "bGl6ZXJzIG9uIHN0dWNrIG5hbWVzcGFjZXMiLAogICAgICAiVGhlIGFnZW50IG9ubHkgdGFyZ2V0" + - "ZWQgTlZDRi1tYW5hZ2VkIG5hbWVzcGFjZXMgKG52Y2Etb3BlcmF0b3IsIG52Y2YtYmFja2VuZCkg" + - "YW5kIGRpZCBub3QgdG91Y2ggb3RoZXIgY2x1c3RlciByZXNvdXJjZXMiLAogICAgICAiVGhlIGFn" + - "ZW50IGRpZCBub3QganVtcCBkaXJlY3RseSB0byBuYW1lc3BhY2UgZGVsZXRpb24gd2l0aG91dCBm" + - "aXJzdCByZW1vdmluZyBmaW5hbGl6ZXJzIgogICAgXQogIH0sCiAgewogICAgImlkIjogIkc2LWhl" + - "bG1maWxlLXNwbGl0LXdvcmtmbG93IiwKICAgICJxdWVzdGlvbiI6ICJJbnN0YWxsIGFuIE5WQ0Yg" + - "Y29udHJvbCBwbGFuZSBhbmQgYSBzZXBhcmF0ZSBFS1MgY29tcHV0ZSBwbGFuZSB1c2luZyB0aGUg" + - "SGVsbWZpbGUgc3RhY2tzLiBUaGUgY29tcHV0ZSBjbHVzdGVyIGt1YmVjb25maWcgaXMgY29tcHV0" + - "ZS55YW1sLiIsCiAgICAiZXhwZWN0ZWRfc2tpbGwiOiAibnZjZi1zZWxmLW1hbmFnZWQtaW5zdGFs" + - "bGF0aW9uIiwKICAgICJncm91bmRfdHJ1dGgiOiAiVGhlIGFnZW50IGtlcHQgdGhlIEhlbG1maWxl" + - "IHZhbHVlcyBmbG93IGluZGVwZW5kZW50IGZyb20gdGhlIENMSSBwcm9maWxlIGZsb3cuIEl0IGF1" + - "dGhvcmVkIHNlcGFyYXRlIGNvbnRyb2wtcGxhbmUgYW5kIGNvbXB1dGUtcGxhbmUgZW52aXJvbm1l" + - "bnQgZmlsZXMgcGx1cyBhIGJhcmUtR2F0ZXdheSBDTEkgY29uZmlnIHdpdGggVVJMIGFuZCBzY2hl" + - "bWUtbGVzcyBIb3N0IGZpZWxkcywgaW5zdGFsbGVkIHRoZSBjb250cm9sIHBsYW5lLCByYW4gdGhl" + - "IGNvbXB1dGUtcGxhbmUgTWFrZWZpbGUgcmVnaXN0ZXItY2x1c3RlciB0YXJnZXQgd2l0aCBJQ01T" + - "X1VSTCBhbmQgdGhlIGNvbXB1dGUga3ViZWNvbmZpZywgdGhlbiByYW4gdGhlIGNvbXB1dGUtcGxh" + - "bmUgaW5zdGFsbCB0YXJnZXQgd2l0aCB0aGUgc2FtZSBlbnZpcm9ubWVudCBhbmQga3ViZWNvbmZp" + - "Zy4gSXQgcmVsaWVkIG9uIHJlZ2lzdHJhdGlvbiB0byBkaXNjb3ZlciBPSURDIGFuZCBKV0tTIGZy" + - "b20gdGhlIGNvbXB1dGUgY29udGV4dC4iLAogICAgImV4cGVjdGVkX2JlaGF2aW9yIjogWwogICAg" + - "ICAiVGhlIGFnZW50IHJlYWQgdGhlIG52Y2Ytc2VsZi1tYW5hZ2VkLWluc3RhbGxhdGlvbiBTS0lM" + - "TC5tZCBiZWZvcmUgdGFraW5nIGFjdGlvbiIsCiAgICAgICJUaGUgYWdlbnQgYXV0aG9yZWQgc2Vw" + - "YXJhdGUgZW52aXJvbm1lbnRzLzxlbnY+LnlhbWwgZmlsZXMgdW5kZXIgZGVwbG95L3N0YWNrcy9z" + - "ZWxmLW1hbmFnZWQgYW5kIGRlcGxveS9zdGFja3MvbnZjZi1jb21wdXRlLXBsYW5lIiwKICAgICAg" + - "IlRoZSBhZ2VudCBpbnN0YWxsZWQgdGhlIGNvbnRyb2wgcGxhbmUgYmVmb3JlIHJlZ2lzdGVyaW5n" + - "IG9yIGluc3RhbGxpbmcgdGhlIGNvbXB1dGUgcGxhbmUiLAogICAgICAiVGhlIGFnZW50IGNvbmZp" + - "Z3VyZWQgYmFzZV9odHRwX3VybCwgaW52b2tlX3VybCwgYmFzZV9ncnBjX3VybCwgYXBpX2tleXNf" + - "c2VydmljZV91cmwsIGljbXNfdXJsLCBhcGlfaG9zdCwgYXBpX2tleXNfaG9zdCwgaW52b2tlX2hv" + - "c3QsIGFuZCBpY21zX2hvc3QgZm9yIHRoZSBiYXJlIEdhdGV3YXkiLAogICAgICAiVGhlIGFnZW50" + - "IHVzZWQgJ21ha2UgLUMgZGVwbG95L3N0YWNrcy9udmNmLWNvbXB1dGUtcGxhbmUgcmVnaXN0ZXIt" + - "Y2x1c3Rlcicgd2l0aCBDTFVTVEVSX05BTUUsIE5DQV9JRCwgQ0xVU1RFUl9SRUdJT04sIElDTVNf" + - "VVJMLCBhbmQgS1VCRUNPTkZJR19GSUxFPWNvbXB1dGUueWFtbCIsCiAgICAgICJUaGUgYWdlbnQg" + - "dXNlZCAnbWFrZSAtQyBkZXBsb3kvc3RhY2tzL252Y2YtY29tcHV0ZS1wbGFuZSBpbnN0YWxsJyB3" + - "aXRoIENMVVNURVJfTkFNRSwgSEVMTUZJTEVfRU5WLCBhbmQgS1VCRUNPTkZJR19GSUxFPWNvbXB1" + - "dGUueWFtbCIsCiAgICAgICJUaGUgYWdlbnQgc3RhdGVkIHRoYXQgSUNNU19VUkwgbWFwcyBvbmx5" + - "IHRvIC0taWNtcy11cmwsIGNvbmZpZyBpY21zX2hvc3Qgc3VwcGxpZXMgdGhlIEhvc3QgaGVhZGVy" + - "LCB0aGVyZSBpcyBubyAtLWljbXMtaG9zdCBNYWtlIG9yIENMSSBmbGFnLCBhbmQgcmVnaXN0cmF0" + - "aW9uIGRpc2NvdmVycyBPSURDIGFuZCBKV0tTIGZyb20gdGhlIGNvbXB1dGUgY29udGV4dCIsCiAg" + - "ICAgICJUaGUgYWdlbnQgZGlkIG5vdCByZXF1aXJlIGEgY29udHJvbC1wbGFuZSBwcm9maWxlIGZv" + - "ciB0aGlzIGZsb3cgYW5kIGRpZCBub3QgbWl4IGluIENMSSBwcm9maWxlIGNvbW1hbmRzIgogICAg" + - "XQogIH0sCiAgewogICAgImlkIjogIkc3LWJvdGgtZG9ja2VyLWhlbG0tYXV0aCIsCiAgICAicXVl" + - "c3Rpb24iOiAiQXV0aGVudGljYXRlIHRvIE5HQyBmb3IgTlZDRiBoZWxtZmlsZSBkZXBsb3ltZW50" + - "IiwKICAgICJleHBlY3RlZF9za2lsbCI6ICJudmNmLXNlbGYtbWFuYWdlZC1pbnN0YWxsYXRpb24i" + - "LAogICAgImdyb3VuZF90cnV0aCI6ICJUaGUgYWdlbnQgcmFuIGJvdGggZG9ja2VyIGxvZ2luIGFu" + - "ZCBoZWxtIHJlZ2lzdHJ5IGxvZ2luIGZvciBudmNyLmlvLiBJdCBleHBsYWluZWQgdGhhdCBib3Ro" + - "IGFyZSByZXF1aXJlZCBiZWNhdXNlIGhlbG1maWxlIHVzZXMgaGVsbSAobm90IGRvY2tlcikgdG8g" + - "cHVsbCBPQ0kgY2hhcnRzLCBzbyBkb2NrZXIgbG9naW4gYWxvbmUgaXMgaW5zdWZmaWNpZW50LiIs" + - "CiAgICAiZXhwZWN0ZWRfYmVoYXZpb3IiOiBbCiAgICAgICJUaGUgYWdlbnQgcmVhZCB0aGUgbnZj" + - "Zi1zZWxmLW1hbmFnZWQtaW5zdGFsbGF0aW9uIFNLSUxMLm1kIGJlZm9yZSB0YWtpbmcgYWN0aW9u" + - "IiwKICAgICAgIlRoZSBhZ2VudCByYW4gJ2RvY2tlciBsb2dpbiBudmNyLmlvJyB3aXRoICRvYXV0" + - "aHRva2VuIHVzZXJuYW1lIGFuZCBOR0NfQVBJX0tFWSBwYXNzd29yZCIsCiAgICAgICJUaGUgYWdl" + - "bnQgcmFuICdoZWxtIHJlZ2lzdHJ5IGxvZ2luIG52Y3IuaW8nIHdpdGggJG9hdXRodG9rZW4gdXNl" + - "cm5hbWUgYW5kIE5HQ19BUElfS0VZIHBhc3N3b3JkIiwKICAgICAgIlRoZSBhZ2VudCBleHBsYWlu" + - "ZWQgdGhhdCBib3RoIGFyZSByZXF1aXJlZCBiZWNhdXNlIGhlbG1maWxlIHVzZXMgaGVsbSAobm90" + - "IGRvY2tlcikgdG8gcHVsbCBPQ0kgY2hhcnRzIiwKICAgICAgIlRoZSBhZ2VudCBkaWQgbm90IHBy" + - "b3ZpZGUgb25seSBvbmUgb2YgdGhlIHR3byBhdXRoZW50aWNhdGlvbiBjb21tYW5kcyIKICAgIF0K" + - "ICB9LAogIHsKICAgICJpZCI6ICJHOS1taXNzaW5nLWJ1bmRsZSIsCiAgICAicXVlc3Rpb24iOiAi" + - "UnVuIGhlbG1maWxlIHN5bmMgZm9yIE5WQ0YgaW4gbXkgY3VycmVudCBkaXJlY3RvcnkiLAogICAg" + - "ImV4cGVjdGVkX3NraWxsIjogIm52Y2Ytc2VsZi1tYW5hZ2VkLWluc3RhbGxhdGlvbiIsCiAgICAi" + - "Z3JvdW5kX3RydXRoIjogIlRoZSBhZ2VudCBhdHRlbXB0ZWQgdG8gdmVyaWZ5IHRoZSBidW5kbGUg" + - "c3RydWN0dXJlIChoZWxtZmlsZS5kLywgZW52aXJvbm1lbnRzLywgc2VjcmV0cy8sIGdsb2JhbC55" + - "YW1sLmdvdG1wbCkgYW5kIHdoZW4gZmlsZXMgd2VyZSBub3QgZm91bmQsIHN0b3BwZWQgYW5kIGlu" + - "c3RydWN0ZWQgdGhlIHVzZXIgdG8gZXh0cmFjdCBvciBsb2NhdGUgdGhlIG52Y2Ytc2VsZi1tYW5h" + - "Z2VkLXN0YWNrIGJ1bmRsZS4gSXQgZGlkIG5vdCBhdHRlbXB0IHRvIHJ1biBoZWxtZmlsZSBzeW5j" + - "IGFnYWluc3QgYSBtaXNzaW5nIGJ1bmRsZS4iLAogICAgImV4cGVjdGVkX2JlaGF2aW9yIjogWwog" + - "ICAgICAiVGhlIGFnZW50IHJlYWQgdGhlIG52Y2Ytc2VsZi1tYW5hZ2VkLWluc3RhbGxhdGlvbiBT" + - "S0lMTC5tZCBiZWZvcmUgdGFraW5nIGFjdGlvbiIsCiAgICAgICJUaGUgYWdlbnQgY2hlY2tlZCBm" + - "b3IgZXhwZWN0ZWQgYnVuZGxlIHN0cnVjdHVyZSAoaGVsbWZpbGUuZC8sIGVudmlyb25tZW50cy8s" + - "IHNlY3JldHMvLCBnbG9iYWwueWFtbC5nb3RtcGwpIiwKICAgICAgIldoZW4gYnVuZGxlIGZpbGVz" + - "IHdlcmUgbm90IGZvdW5kLCB0aGUgYWdlbnQgc3RvcHBlZCBhbmQgZGlkIG5vdCBhdHRlbXB0IGhl" + - "bG1maWxlIHN5bmMiLAogICAgICAiVGhlIGFnZW50IGluc3RydWN0ZWQgdGhlIHVzZXIgdG8gZXh0" + - "cmFjdCBvciBsb2NhdGUgdGhlIG52Y2Ytc2VsZi1tYW5hZ2VkLXN0YWNrIGJ1bmRsZSIKICAgIF0K" + - "ICB9LAogIHsKICAgICJpZCI6ICJTMS1jbGVhbi1pbnN0YWxsYXRpb24iLAogICAgInF1ZXN0aW9u" + - "IjogIlBlcmZvcm0gYSBjbGVhbiBpbnN0YWxsYXRpb24gb2YgdGhlIE5WQ0Ygc2VsZi1tYW5hZ2Vk" + - "IHN0YWNrIG9uIG15IEFXUyBFS1MgY2x1c3Rlci4gTXkgZW52aXJvbm1lbnQgbmFtZSBpcyAnc3Rh" + - "Z2luZycuIiwKICAgICJleHBlY3RlZF9za2lsbCI6ICJudmNmLXNlbGYtbWFuYWdlZC1pbnN0YWxs" + - "YXRpb24iLAogICAgImdyb3VuZF90cnV0aCI6ICJUaGUgYWdlbnQgY29tcGxldGVkIHRoZSBjb250" + - "cm9sLXBsYW5lIGluc3RhbGxhdGlvbiBmaXJzdDogdmFsaWRhdGVkIHRvb2xzIGFuZCBidW5kbGUg" + - "c3RydWN0dXJlLCBjcmVhdGVkIGNvbnRyb2wtcGxhbmUgbmFtZXNwYWNlcyBpbmNsdWRpbmcgY2Vy" + - "dC1tYW5hZ2VyLCBhdXRoZW50aWNhdGVkIHRoZSByZWdpc3RyaWVzLCBwcmV2aWV3ZWQsIGRlcGxv" + - "eWVkLCBhbmQgbW9uaXRvcmVkIHRoZSBmb3VyIGNvbnRyb2wtcGxhbmUgcGhhc2VzLiBJdCB0aGVu" + - "IHNlbGVjdGVkIG9uZSBkb2N1bWVudGVkIGhhbmRvZmYgYW5kIHJlZ2lzdGVyZWQgYW5kIGluc3Rh" + - "bGxlZCB0aGUgY29tcHV0ZSBwbGFuZSBhcyBhIHNlcGFyYXRlIHN0YWNrIHdpdGhvdXQgbWl4aW5n" + - "IHByb2ZpbGUgYW5kIEhlbG1maWxlIHZhbHVlcyBmbG93cy4iLAogICAgImV4cGVjdGVkX2JlaGF2" + - "aW9yIjogWwogICAgICAiVGhlIGFnZW50IHJlYWQgdGhlIG52Y2Ytc2VsZi1tYW5hZ2VkLWluc3Rh" + - "bGxhdGlvbiBTS0lMTC5tZCBiZWZvcmUgdGFraW5nIGFjdGlvbiIsCiAgICAgICJUaGUgYWdlbnQg" + - "dmFsaWRhdGVkIHRvb2wgdmVyc2lvbnMgKGhlbG1maWxlLCBoZWxtLCBoZWxtLWRpZmYsIGt1YmVj" + - "dGwpIiwKICAgICAgIlRoZSBhZ2VudCB2ZXJpZmllZCB0aGUgYnVuZGxlIHN0cnVjdHVyZSBleGlz" + - "dHMiLAogICAgICAiVGhlIGFnZW50IGNyZWF0ZWQgY29udHJvbC1wbGFuZSBuYW1lc3BhY2VzIChj" + - "YXNzYW5kcmEtc3lzdGVtLCBuYXRzLXN5c3RlbSwgbnZjZiwgYXBpLWtleXMsIGVzcywgc2lzLCB2" + - "YXVsdC1zeXN0ZW0sIGNlcnQtbWFuYWdlcikgd2l0aG91dCBhZGRpbmcgY29tcHV0ZS1vbmx5IG5h" + - "bWVzcGFjZXMiLAogICAgICAiVGhlIGFnZW50IHJhbiAnSEVMTUZJTEVfRU5WPXN0YWdpbmcgaGVs" + - "bWZpbGUgdGVtcGxhdGUnIHRvIHByZXZpZXcgYmVmb3JlIGRlcGxveWluZyIsCiAgICAgICJUaGUg" + - "YWdlbnQgcmFuICdIRUxNRklMRV9FTlY9c3RhZ2luZyBoZWxtZmlsZSBzeW5jJyB0byBkZXBsb3ki" + - "LAogICAgICAiVGhlIGFnZW50IGV4cGxhaW5lZCB0aGUgNCBjb250cm9sLXBsYW5lIHBoYXNlcyAo" + - "ZGVwZW5kZW5jaWVzLCBzZXJ2aWNlcywgaW5ncmVzcywgb2JzZXJ2YWJpbGl0eSkgYW5kIGFwcHJv" + - "eGltYXRlIHdhaXQgdGltZXMiLAogICAgICAiQWZ0ZXIgdGhlIGNvbnRyb2wgcGxhbmUgd2FzIGhl" + - "YWx0aHksIHRoZSBhZ2VudCByZWdpc3RlcmVkIGFuZCBpbnN0YWxsZWQgdGhlIHNlcGFyYXRlIGNv" + - "bXB1dGUtcGxhbmUgc3RhY2sgdXNpbmcgZXhhY3RseSBvbmUgZG9jdW1lbnRlZCBoYW5kb2ZmIiwK" + - "ICAgICAgIlRoZSBhZ2VudCBkaWQgbm90IG1peCBhIENMSS1nZW5lcmF0ZWQgY29udHJvbC1wbGFu" + - "ZSBwcm9maWxlIHdpdGggdGhlIEhlbG1maWxlIHZhbHVlcyBmbG93IgogICAgXQogIH0sCiAgewog" + - "ICAgImlkIjogIlMzLWNsaS1wcm9maWxlLXdvcmtmbG93IiwKICAgICJxdWVzdGlvbiI6ICJVc2Ug" + - "bnZjZi1jbGkgdG8gaW5zdGFsbCBteSBjb250cm9sIHBsYW5lIGFuZCB0aGVuIHJlZ2lzdGVyIGFu" + - "ZCBpbnN0YWxsIGEgc2VwYXJhdGUgY29tcHV0ZSBjbHVzdGVyLiBTaG93IGV2ZXJ5IHJlcXVpcmVk" + - "IGdsb2JhbCBmbGFnLiIsCiAgICAiZXhwZWN0ZWRfc2tpbGwiOiAibnZjZi1zZWxmLW1hbmFnZWQt" + - "aW5zdGFsbGF0aW9uIiwKICAgICJncm91bmRfdHJ1dGgiOiAiVGhlIGFnZW50IGZpcnN0IHJhbiB0" + - "aGUgQ0xJIGNvbnRyb2wtcGxhbmUgaW5zdGFsbCBhbmQgcmVxdWlyZWQgaXRzIGdlbmVyYXRlZCBj" + - "b250cm9sLXBsYW5lLXByb2ZpbGUueWFtbC4gSXQgdGhlbiBzaG93ZWQgY29tcGxldGUgcmVnaXN0" + - "ZXIgYW5kIGluc3RhbGwgY29tbWFuZHMsIGVhY2ggaW5jbHVkaW5nIC0tY29uZmlnLCAtLWNvbnRy" + - "b2wtcGxhbmUtc3RhY2ssIC0tY29tcHV0ZS1wbGFuZS1zdGFjaywgLS1lbnYsIGFuZCAtLXBsYWlu" + - "IGJlZm9yZSB0aGUgY29tcHV0ZS1wbGFuZSBzdWJjb21tYW5kLiBSZWdpc3RyYXRpb24gY29uc3Vt" + - "ZWQgdGhlIHByb2ZpbGUgYW5kIHByb2R1Y2VkIHRoZSB2YWx1ZXMgZmlsZSBjb25zdW1lZCBieSBp" + - "bnN0YWxsLiBJdCBkaWQgbm90IHN3aXRjaCB0byB0aGUgSGVsbWZpbGUgdmFsdWVzIGhhbmRvZmYu" + - "IiwKICAgICJleHBlY3RlZF9iZWhhdmlvciI6IFsKICAgICAgIlRoZSBhZ2VudCByZWFkIHRoZSBu" + - "dmNmLXNlbGYtbWFuYWdlZC1pbnN0YWxsYXRpb24gU0tJTEwubWQgYmVmb3JlIHRha2luZyBhY3Rp" + - "b24iLAogICAgICAiVGhlIGFnZW50IHJhbiBudmNmLWNsaSBzZWxmLWhvc3RlZCBpbnN0YWxsIC0t" + - "Y29udHJvbC1wbGFuZSBhbmQgdmVyaWZpZWQgZGVwbG95L3N0YWNrcy9zZWxmLW1hbmFnZWQvb3V0" + - "L2NvbnRyb2wtcGxhbmUtcHJvZmlsZS55YW1sIGV4aXN0cyIsCiAgICAgICJUaGUgcmVnaXN0ZXIg" + - "Y29tbWFuZCBpbmNsdWRlZCAtLWNvbmZpZywgLS1jb250cm9sLXBsYW5lLXN0YWNrLCAtLWNvbXB1" + - "dGUtcGxhbmUtc3RhY2ssIC0tZW52LCBhbmQgLS1wbGFpbiIsCiAgICAgICJUaGUgcmVnaXN0ZXIg" + - "Y29tbWFuZCBpbmNsdWRlZCAtLWNvbnRyb2wtcGxhbmUtcHJvZmlsZSwgLS1jbHVzdGVyLW5hbWUs" + - "IC0ta3ViZS1jb250ZXh0LCAtLXJlZ2lvbiwgYW5kIC0tb3V0cHV0IiwKICAgICAgIlRoZSBpbnN0" + - "YWxsIGNvbW1hbmQgcmVwZWF0ZWQgLS1jb25maWcsIC0tY29udHJvbC1wbGFuZS1zdGFjaywgLS1j" + - "b21wdXRlLXBsYW5lLXN0YWNrLCAtLWVudiwgYW5kIC0tcGxhaW4iLAogICAgICAiVGhlIGluc3Rh" + - "bGwgY29tbWFuZCBpbmNsdWRlZCAtLXZhbHVlcywgLS1rdWJlLWNvbnRleHQsIGFuZCAtLWNsdXN0" + - "ZXItbmFtZSIsCiAgICAgICJUaGUgYWdlbnQga2VwdCB0aGUgZ2VuZXJhdGVkIHByb2ZpbGUgYXMg" + - "dGhlIGVuZHBvaW50IHNvdXJjZSBhbmQgZGlkIG5vdCBtaXggaW4gSGVsbWZpbGUgdmFsdWVzIHJl" + - "Z2lzdHJhdGlvbiIKICAgIF0KICB9LAogIHsKICAgICJpZCI6ICJTNC1vdmVycmlkZS1jYXNzYW5k" + - "cmEtcmVzb3VyY2VzIiwKICAgICJxdWVzdGlvbiI6ICJDYXNzYW5kcmEgcG9kcyBrZWVwIGdldHRp" + - "bmcgT09NS2lsbGVkLiBJbmNyZWFzZSBtZW1vcnkgbGltaXRzIHRvIDE2R2kuIiwKICAgICJleHBl" + - "Y3RlZF9za2lsbCI6ICJudmNmLXNlbGYtbWFuYWdlZC1pbnN0YWxsYXRpb24iLAogICAgImdyb3Vu" + - "ZF90cnV0aCI6ICJUaGUgYWdlbnQgY2FwdHVyZWQgdGhlIGJhc2VsaW5lIHdpdGggaGVsbWZpbGUg" + - "dGVtcGxhdGUsIHRoZW4gbW9kaWZpZWQgdGhlIGNhc3NhbmRyYSByZWxlYXNlIHdpdGggaW5saW5l" + - "IHZhbHVlcyByZS1pbmNsdWRpbmcgZ2xvYmFsLnlhbWwuZ290bXBsIGFuZCBzZWNyZXRzIGluIHRo" + - "ZSB2YWx1ZXMgYmxvY2suIEl0IHdhcm5lZCBhYm91dCB0aGUgWUFNTCBtZXJnZSBnb3RjaGEgYW5k" + - "IHByZXZpZXdlZCB0aGUgZGlmZiBiZWZvcmUgYXBwbHlpbmcuIiwKICAgICJleHBlY3RlZF9iZWhh" + - "dmlvciI6IFsKICAgICAgIlRoZSBhZ2VudCByZWFkIHRoZSBudmNmLXNlbGYtbWFuYWdlZC1pbnN0" + - "YWxsYXRpb24gU0tJTEwubWQgYmVmb3JlIHRha2luZyBhY3Rpb24iLAogICAgICAiVGhlIGFnZW50" + - "IGNhcHR1cmVkIGJhc2VsaW5lIHdpdGggJ2hlbG1maWxlIC0tc2VsZWN0b3IgbmFtZT1jYXNzYW5k" + - "cmEgdGVtcGxhdGUnIiwKICAgICAgIlRoZSBhZ2VudCBtb2RpZmllZCB0aGUgcmVsZWFzZSB2YWx1" + - "ZXMgYmxvY2sgdG8gaW5jbHVkZSByZXNvdXJjZSBsaW1pdHMgd2l0aCBtZW1vcnk6IDE2R2kiLAog" + - "ICAgICAiVGhlIGFnZW50IHJlLWluY2x1ZGVkIGdsb2JhbC55YW1sLmdvdG1wbCBhbmQgc2VjcmV0" + - "cyBmaWxlIGluIHRoZSB2YWx1ZXM6IGJsb2NrIChub3QganVzdCB0aGUgb3ZlcnJpZGUgYWxvbmUp" + - "IiwKICAgICAgIlRoZSBhZ2VudCB3YXJuZWQgYWJvdXQgdGhlIFlBTUwgbWVyZ2UgZ290Y2hhOiBz" + - "cGVjaWZ5aW5nIHZhbHVlczogcmVwbGFjZXMgdGhlIHRlbXBsYXRlJ3MgdmFsdWVzIGxpc3QgZW50" + - "aXJlbHkiLAogICAgICAiVGhlIGFnZW50IHByZXZpZXdlZCB0aGUgY2hhbmdlIHdpdGggaGVsbWZp" + - "bGUgdGVtcGxhdGUgYW5kIGRpZmYgYmVmb3JlIGFwcGx5aW5nIHdpdGggc3luYyIKICAgIF0KICB9" + - "LAogIHsKICAgICJpZCI6ICJTNi1zZWxlY3RpdmUtc3luYy1kZXBlbmRlbmNpZXMiLAogICAgInF1" + - "ZXN0aW9uIjogIkRlcGxveSBvbmx5IHRoZSBOVkNGIGRlcGVuZGVuY2llcyAtLSBOQVRTLCBDYXNz" + - "YW5kcmEsIGFuZCBPcGVuQmFvIC0tIGZvciB0ZXN0aW5nIiwKICAgICJleHBlY3RlZF9za2lsbCI6" + - "ICJudmNmLXNlbGYtbWFuYWdlZC1pbnN0YWxsYXRpb24iLAogICAgImdyb3VuZF90cnV0aCI6ICJU" + - "aGUgYWdlbnQgdXNlZCB0aGUgaGVsbWZpbGUgc2VsZWN0b3IgdG8gZGVwbG95IG9ubHkgdGhlIGRl" + - "cGVuZGVuY2llcyByZWxlYXNlIGdyb3VwLCB0aGVuIHZlcmlmaWVkIHBvZHMgaW4gdGhlIGRlcGVu" + - "ZGVuY3kgbmFtZXNwYWNlcy4iLAogICAgImV4cGVjdGVkX2JlaGF2aW9yIjogWwogICAgICAiVGhl" + - "IGFnZW50IHJlYWQgdGhlIG52Y2Ytc2VsZi1tYW5hZ2VkLWluc3RhbGxhdGlvbiBTS0lMTC5tZCBi" + - "ZWZvcmUgdGFraW5nIGFjdGlvbiIsCiAgICAgICJUaGUgYWdlbnQgdXNlZCAnaGVsbWZpbGUgLS1z" + - "ZWxlY3RvciByZWxlYXNlLWdyb3VwPWRlcGVuZGVuY2llcyBzeW5jJyB0byBkZXBsb3kgb25seSBk" + - "ZXBlbmRlbmNpZXMiLAogICAgICAiVGhlIGFnZW50IHZlcmlmaWVkIHBvZHMgaW4gZGVwZW5kZW5j" + - "eSBuYW1lc3BhY2VzIChuYXRzLXN5c3RlbSwgY2Fzc2FuZHJhLXN5c3RlbSwgdmF1bHQtc3lzdGVt" + - "KSIsCiAgICAgICJUaGUgYWdlbnQgcHJvdmlkZWQgdGhlIHNlbGVjdG9yIHJlZmVyZW5jZSBmb3Ig" + - "dGFyZ2V0aW5nIG90aGVyIHJlbGVhc2UgZ3JvdXBzIgogICAgXQogIH0sCiAgewogICAgImlkIjog" + - "IlM3LWRlYnVnLWltYWdlcHVsbGJhY2tvZmYiLAogICAgInF1ZXN0aW9uIjogIkNhc3NhbmRyYSBw" + - "b2RzIGFyZSBpbiBJbWFnZVB1bGxCYWNrT2ZmIHdpdGggNDAxIFVuYXV0aG9yaXplZCIsCiAgICAi" + - "ZXhwZWN0ZWRfc2tpbGwiOiAibnZjZi1zZWxmLW1hbmFnZWQtaW5zdGFsbGF0aW9uIiwKICAgICJn" + - "cm91bmRfdHJ1dGgiOiAiVGhlIGFnZW50IHJlYWQgdGhlIGRlYnVnZ2luZyByZWZlcmVuY2UgYW5k" + - "IHJhbiBkaWFnbm9zdGljIGNvbW1hbmRzIHRvIGlkZW50aWZ5IHRoZSByb290IGNhdXNlOiBkZXNj" + - "cmliZWQgdGhlIHBvZCwgY2hlY2tlZCBmb3IgcHVsbCBzZWNyZXRzLCBjaGVja2VkIGltYWdlUHVs" + - "bFNlY3JldHMgb24gdGhlIHBvZCBzcGVjIGFuZCBzZXJ2aWNlIGFjY291bnQuIEl0IGlkZW50aWZp" + - "ZWQgdGhlIGlzc3VlIChtaXNzaW5nIHNlY3JldCwgd3JvbmcgY3JlZGVudGlhbHMsIG9yIG1pc3Np" + - "bmcgaW1hZ2VQdWxsU2VjcmV0cykgYW5kIHByb3ZpZGVkIHRoZSBjb3JyZWN0IGZpeC4iLAogICAg" + - "ImV4cGVjdGVkX2JlaGF2aW9yIjogWwogICAgICAiVGhlIGFnZW50IHJlYWQgdGhlIG52Y2Ytc2Vs" + - "Zi1tYW5hZ2VkLWluc3RhbGxhdGlvbiBTS0lMTC5tZCBhbmQgcmVmZXJlbmNlcy9kZWJ1Z2dpbmcu" + - "bWQiLAogICAgICAiVGhlIGFnZW50IHJhbiAna3ViZWN0bCBkZXNjcmliZSBwb2QnIHRvIHNlZSB0" + - "aGUgSW1hZ2VQdWxsQmFja09mZiBldmVudHMiLAogICAgICAiVGhlIGFnZW50IGNoZWNrZWQgZm9y" + - "IHB1bGwgc2VjcmV0cyBpbiB0aGUgY2Fzc2FuZHJhLXN5c3RlbSBuYW1lc3BhY2UiLAogICAgICAi" + - "VGhlIGFnZW50IGNoZWNrZWQgaW1hZ2VQdWxsU2VjcmV0cyBvbiB0aGUgcG9kIHNwZWMgYW5kL29y" + - "IHNlcnZpY2UgYWNjb3VudCIsCiAgICAgICJUaGUgYWdlbnQgaWRlbnRpZmllZCB0aGUgcm9vdCBj" + - "YXVzZSBhbmQgcHJvdmlkZWQgYSBzcGVjaWZpYyBmaXgiCiAgICBdCiAgfSwKICB7CiAgICAiaWQi" + - "OiAiUzktcmVtb3RlLWVrcy1yb3V0aW5nLWFuZC1zZWNyZXRzIiwKICAgICJxdWVzdGlvbiI6ICJD" + - "b25maWd1cmUgYSByZW1vdGUgRUtTIGNvbXB1dGUgY2x1c3RlciB0byByZWFjaCBteSBOVkNGIGNv" + - "bnRyb2wgcGxhbmUgdGhyb3VnaCBpdHMgRW52b3kgR2F0ZXdheSwgaW5jbHVkaW5nIE5BVFMgYW5k" + - "IHByaXZhdGUtcmVnaXN0cnkgcHVsbCBzZWNyZXRzLiIsCiAgICAiZXhwZWN0ZWRfc2tpbGwiOiAi" + - "bnZjZi1zZWxmLW1hbmFnZWQtaW5zdGFsbGF0aW9uIiwKICAgICJncm91bmRfdHJ1dGgiOiAiVGhl" + - "IGFnZW50IGNvbmZpZ3VyZWQgdGhlIGNvbnRyb2wgcGxhbmUgdG8gdXNlIHRoZSBFbnZveSBHYXRl" + - "d2F5IGNvbnRyb2xsZXIgaW4gZW52b3ktZ2F0ZXdheS1zeXN0ZW0gYW5kIEdhdGV3YXkvbnZjZi1n" + - "YXRld2F5IGluIGVudm95LWdhdGV3YXksIHNldCBhbGwgc2l4IHJlbW90ZSB3b3JrZXIgZW5kcG9p" + - "bnRzIGFuZCB0aGUgZ3JwYy1wcm94eSBsb2NhbCBvdmVycmlkZSwgZW5hYmxlZCBOVkNGIGFuZCBO" + - "VkNUIGdSUEMgcm91dGVzIHBsdXMgTkFUUywgYW5kIGVuYWJsZWQgT3BlbkJhbyBpc3N1ZXIgZGlz" + - "Y292ZXJ5LiBJdCBjb25maWd1cmVkIHRoZSBiYXJlLUdhdGV3YXkgQ0xJIFVSTCBhbmQgSG9zdCBm" + - "aWVsZHMgaW5jbHVkaW5nIGljbXNfaG9zdCwgcGx1cyB0aGUgY29tcHV0ZS1wbGFuZSBJQ01TLCBS" + - "ZVZhbCwgYW5kIE5BVFMgZXh0ZXJuYWwgVVJMcyBhbmQgaG9zdCBvdmVycmlkZXMuIEl0IGNyZWF0" + - "ZWQgdGhlIHB1bGwgc2VjcmV0IGluIGFsbCBjb250cm9sLXBsYW5lIG5hbWVzcGFjZXMgaW5jbHVk" + - "aW5nIGNlcnQtbWFuYWdlciwgYnV0IG9ubHkgaW4gbnZjYS1vcGVyYXRvciBvbiB0aGUgY29tcHV0" + - "ZSBjbHVzdGVyOyB0aGUgY2hhcnQgYW5kIG9wZXJhdG9yIG1pcnJvciBpdCB0byBudmNhLXN5c3Rl" + - "bS4iLAogICAgImV4cGVjdGVkX2JlaGF2aW9yIjogWwogICAgICAiVGhlIGFnZW50IHJlYWQgdGhl" + - "IG52Y2Ytc2VsZi1tYW5hZ2VkLWluc3RhbGxhdGlvbiBTS0lMTC5tZCBiZWZvcmUgdGFraW5nIGFj" + - "dGlvbiIsCiAgICAgICJUaGUgYWdlbnQgc2V0IGluZ3Jlc3MuZ2F0ZXdheUFwaS5jb250cm9sbGVy" + - "TmFtZXNwYWNlIHRvIGVudm95LWdhdGV3YXktc3lzdGVtIiwKICAgICAgIlRoZSBhZ2VudCBzZXQg" + - "c2hhcmVkLCBncnBjLCBhbmQgbmF0cyBHYXRld2F5IHJlZmVyZW5jZXMgdG8gbmFtZSBudmNmLWdh" + - "dGV3YXkgYW5kIG5hbWVzcGFjZSBlbnZveS1nYXRld2F5IiwKICAgICAgIlRoZSBhZ2VudCBzZXQg" + - "Z2xvYmFsLndvcmtlckVuZHBvaW50cy5udmNmU2VydmljZVVSTCwgbnZjZkdycGNTZXJ2aWNlVVJM" + - "LCBudmNmTmF0c1NlcnZpY2VVUkwsIG52Y3RTZXJ2aWNlVVJMLCBudmN0R3JwY1NlcnZpY2VVUkws" + - "IGFuZCBpbnZvY2F0aW9uU2VydmljZVVSTCIsCiAgICAgICJUaGUgYWdlbnQgc2V0IGdycGNwcm94" + - "eS5udmNmR3JwY1NlcnZpY2VVUkwgdG8gdGhlIGNvbnRyb2wtcGxhbmUtbG9jYWwgQVBJIGdSUEMg" + - "c2VydmljZSIsCiAgICAgICJUaGUgYWdlbnQgZW5hYmxlZCBib3RoIGluZ3Jlc3MuZ2F0ZXdheUFw" + - "aS5yb3V0ZXMubnZjZkFwaS5ncnBjIGFuZCBudmN0QXBpLmdycGMgd2l0aCB3b3JrZXItYXBpIGFu" + - "ZCB3b3JrZXItdGFza3MgaG9zdG5hbWVzIiwKICAgICAgIlRoZSBhZ2VudCBleHBsaWNpdGx5IHNl" + - "dCBpbmdyZXNzLmdhdGV3YXlBcGkucm91dGVzLm5hdHMuZW5hYmxlZCB0byB0cnVlIiwKICAgICAg" + - "IlRoZSBhZ2VudCBzZXQgb3BlbmJhby5taWdyYXRpb25zLmlzc3VlckRpc2NvdmVyeS5lbmFibGVk" + - "IHRvIHRydWUiLAogICAgICAiVGhlIGFnZW50IGNvbmZpZ3VyZWQgdGhlIGJhcmUtR2F0ZXdheSBD" + - "TEkgVVJMIGFuZCBIb3N0IGZpZWxkcywgaW5jbHVkaW5nIHNjaGVtZS1sZXNzIGljbXNfaG9zdCIs" + - "CiAgICAgICJUaGUgYWdlbnQgY29uZmlndXJlZCBjb21wdXRlLXBsYW5lIGljbXNTZXJ2aWNlVVJM" + - "LCBpY21zU2VydmljZUhvc3RIZWFkZXJPdmVycmlkZSwgcmV2YWxTZXJ2aWNlVVJMLCByZXZhbFNl" + - "cnZpY2VIb3N0SGVhZGVyT3ZlcnJpZGUsIG5hdHNVUkwsIGFuZCBuYXRzSG9zdE92ZXJyaWRlIiwK" + - "ICAgICAgIlRoZSBjb250cm9sLXBsYW5lIHB1bGwtc2VjcmV0IG5hbWVzcGFjZSBsaXN0IGluY2x1" + - "ZGVkIGNlcnQtbWFuYWdlciIsCiAgICAgICJUaGUgY29tcHV0ZS1wbGFuZSBzZWNyZXQgd2FzIGNy" + - "ZWF0ZWQgb25seSBpbiBudmNhLW9wZXJhdG9yIGFuZCBtaXJyb3JlZCBieSB0aGUgY2hhcnQgYW5k" + - "IG9wZXJhdG9yIHRvIG52Y2Etc3lzdGVtIgogICAgXQogIH0sCiAgewogICAgImlkIjogIkcxMS1z" + - "cGxpdC10ZWFyZG93biIsCiAgICAicXVlc3Rpb24iOiAiVGVhciBkb3duIG15IHNwbGl0IGNvbnRy" + - "b2wtcGxhbmUgYW5kIGNvbXB1dGUtcGxhbmUgZGVwbG95bWVudCBzYWZlbHkuIFNob3cgYm90aCB0" + - "aGUgSGVsbWZpbGUgdmFsdWVzIGFuZCBDTEkgcHJvZmlsZSB2YXJpYW50cy4iLAogICAgImV4cGVj" + - "dGVkX3NraWxsIjogIm52Y2Ytc2VsZi1tYW5hZ2VkLWluc3RhbGxhdGlvbiIsCiAgICAiZ3JvdW5k" + - "X3RydXRoIjogIlRoZSBIZWxtZmlsZSBmbG93IGRlc3Ryb3llZCBhbmQgY29uZmlybWVkIGRlcmVn" + - "aXN0cmF0aW9uIG9mIGV2ZXJ5IGNvbXB1dGUgY2x1c3RlciBiZWZvcmUgZGVzdHJveWluZyB0aGUg" + - "Y29udHJvbCBwbGFuZSBhbmQgcGFzc2VkIGJvdGggY29udHJvbC1wbGFuZSBrdWJlY29uZmlnIGZv" + - "cm1zLiBCZWZvcmUgZWl0aGVyIGhhbmRvZmYgY291bGQgZGVzdHJveSB0aGUgY29udHJvbCBwbGFu" + - "ZSwgYm90aCB0ZWFyZG93biBmbG93cyB3YXJuZWQgdGhhdCBuYW1lc3BhY2UgcHJlc2VydmF0aW9u" + - "IGRvZXMgbm90IHByZXNlcnZlIHRoZSBIZWxtIHJlbGVhc2UsIHJlcXVpcmVkIGVmZmVjdGl2ZSBj" + - "ZXJ0TWFuYWdlci5lbmFibGVkOiBmYWxzZSBmb3IgYW4gZXh0ZXJuYWwgaW5zdGFsbGF0aW9uIGFu" + - "ZCBhYm9ydGVkIGlmIHRydWUsIGFuZCB2ZXJpZmllZCBtYXRjaGluZyByZWxlYXNlIG93bmVyc2hp" + - "cCBmb3IgYW4gaW50ZW5kZWQgc3RhY2stbWFuYWdlZCByZWxlYXNlLCBhYm9ydGluZyBvbiBtaXNz" + - "aW5nIG9yIG1pc21hdGNoZWQgZXZpZGVuY2UuIFRoZXkgcHJlc2VydmVkIHRoZSBuYW1lc3BhY2Ug" + - "YnkgZGVmYXVsdCBhbmQgZGlkIG5vdCBkZWxldGUgaXQgd2l0aG91dCBuYW1lc3BhY2UgcHJvdmVu" + - "YW5jZSBhbmQgZXhwbGljaXQgY29uZmlybWF0aW9uLiBUaGUgQ0xJIGZsb3cgcmV0YWluZWQgdGhl" + - "IGdlbmVyYXRlZCByZWdpc3RyYXRpb24gdmFsdWVzLCB1c2VkIHRoZSBmdWxsLXByZWZpeCBzdGF0" + - "dXMgY29tbWFuZCB0byBpbnNwZWN0IGxpdmUgcmVnaXN0cmF0aW9ucywgc3RhdGVkIHRoYXQgbmFt" + - "ZWQtY2x1c3RlciBwbGFuLW9ubHkgZG9lcyBub3QgcXVlcnkgSUNNUyBhbmQgY2Fubm90IHByZWRp" + - "Y3QgY29uZGl0aW9uYWwgY29udHJvbC1wbGFuZSByZW1vdmFsLCBhbmQgZ290IGV4cGxpY2l0IGNv" + - "bmZpcm1hdGlvbiB3aGVuIHRoZSB0YXJnZXQgd2FzIHRoZSBsYXN0IHJlZ2lzdGVyZWQgY2x1c3Rl" + - "ci4gSXQgdGhlbiBwcmV2aWV3ZWQgYW5kIHJhbiBkb3duIHdpdGggdGhlIGZ1bGwgcGVyc2lzdGVu" + - "dCBwcmVmaXgsIHJlbW92aW5nIHRoZSBjb250cm9sIHBsYW5lIG9ubHkgYWZ0ZXIgdGhlIGxhc3Qg" + - "cmVnaXN0cmF0aW9uIHdhcyBnb25lLiIsCiAgICAiZXhwZWN0ZWRfYmVoYXZpb3IiOiBbCiAgICAg" + - "ICJUaGUgYWdlbnQgcmVhZCB0aGUgbnZjZi1zZWxmLW1hbmFnZWQtaW5zdGFsbGF0aW9uIFNLSUxM" + - "Lm1kIGJlZm9yZSB0YWtpbmcgYWN0aW9uIiwKICAgICAgIkZvciBldmVyeSBjb21wdXRlIGNsdXN0" + - "ZXIsIHRoZSBIZWxtZmlsZSBmbG93IHJhbiB0aGUgY29tcHV0ZS1wbGFuZSBNYWtlZmlsZSBkZXN0" + - "cm95IHRhcmdldCB3aXRoIGl0cyBjb21wdXRlIGt1YmVjb25maWciLAogICAgICAiQWZ0ZXIgY29u" + - "ZmlybWF0aW9uLCB0aGUgSGVsbWZpbGUgZmxvdyByYW4gY2x1c3RlciBkZWxldGUgd2l0aCBjbHVz" + - "dGVySUQgYW5kIG5jYUlEIGJlZm9yZSBjb250cm9sLXBsYW5lIGRlc3RydWN0aW9uIiwKICAgICAg" + - "IkJlZm9yZSBlaXRoZXIgaGFuZG9mZiBjb3VsZCBkZXN0cm95IHRoZSBjb250cm9sIHBsYW5lLCBi" + - "b3RoIHRlYXJkb3duIGZsb3dzIHdhcm5lZCB0aGF0IG5hbWVzcGFjZSBwcmVzZXJ2YXRpb24gZG9l" + - "cyBub3QgcHJlc2VydmUgdGhlIEhlbG0gcmVsZWFzZSwgcmVxdWlyZWQgZWZmZWN0aXZlIGNlcnRN" + - "YW5hZ2VyLmVuYWJsZWQ6IGZhbHNlIGZvciBhbiBleHRlcm5hbCBpbnN0YWxsYXRpb24gYW5kIGFi" + - "b3J0ZWQgaWYgdHJ1ZSwgYW5kIHZlcmlmaWVkIGludGVuZGVkIHN0YWNrIG93bmVyc2hpcCB3aGVu" + - "IGVuYWJsZWQsIGFib3J0aW5nIG9uIG1pc3Npbmcgb3IgbWlzbWF0Y2hlZCBldmlkZW5jZSIsCiAg" + - "ICAgICJCb3RoIHRlYXJkb3duIGZsb3dzIHByZXNlcnZlZCB0aGUgY2VydC1tYW5hZ2VyIG5hbWVz" + - "cGFjZSBieSBkZWZhdWx0IGFuZCBkaWQgbm90IGRlbGV0ZSBpdCB3aXRob3V0IG5hbWVzcGFjZSBw" + - "cm92ZW5hbmNlIGFuZCBleHBsaWNpdCBjb25maXJtYXRpb24iLAogICAgICAiVGhlIEhlbG1maWxl" + - "IGZsb3cgcmFuIGNvbnRyb2wtcGxhbmUgTWFrZWZpbGUgZGVzdHJveSB3aXRoIGJvdGggS1VCRUNP" + - "TkZJRyBhbmQgS1VCRUNPTkZJR19GSUxFIiwKICAgICAgIlRoZSBDTEkgZmxvdyByZXRhaW5lZCBv" + - "dXQvPGNsdXN0ZXItbmFtZT4tcmVnaXN0ZXItdmFsdWVzLnlhbWwgdW50aWwgdGVhcmRvd24gY29t" + - "cGxldGVkIiwKICAgICAgIkJlZm9yZSByZWFsIGRvd24sIHRoZSBDTEkgZmxvdyB1c2VkIHRoZSBm" + - "dWxsLXByZWZpeCBzdGF0dXMgY29tbWFuZCB0byBpbnNwZWN0IGxpdmUgcmVnaXN0cmF0aW9ucywg" + - "c3RhdGVkIHRoYXQgbmFtZWQtY2x1c3RlciBwbGFuLW9ubHkgZG9lcyBub3QgcXVlcnkgSUNNUyBh" + - "bmQgY2Fubm90IHByZWRpY3QgY29uZGl0aW9uYWwgY29udHJvbC1wbGFuZSByZW1vdmFsLCB3YXJu" + - "ZWQgd2hlbiB0aGUgdGFyZ2V0IHdhcyB0aGUgbGFzdCByZWdpc3RlcmVkIGNsdXN0ZXIsIGFuZCBn" + - "b3QgZXhwbGljaXQgY29uZmlybWF0aW9uIiwKICAgICAgIlRoZSBDTEkgZmxvdyB1c2VkIC0tY29u" + - "ZmlnLCBib3RoIHN0YWNrIHBhdGhzLCAtLWVudiwgLS1wbGFpbiwgYm90aCBjb250ZXh0cywgYW5k" + - "IC0taWNtcy11cmwgZm9yIGRvd24gLS1wbGFuLW9ubHkgYW5kIHRoZW4gZG93biIsCiAgICAgICJU" + - "aGUgYWdlbnQgc3RhdGVkIHRoYXQgZG93biB1bnJlZ2lzdGVycyBlYWNoIGNvbXB1dGUgY2x1c3Rl" + - "ciBhbmQgcmVtb3ZlcyB0aGUgY29udHJvbCBwbGFuZSBvbmx5IGFmdGVyIG5vIHJlZ2lzdHJhdGlv" + - "bnMgcmVtYWluIgogICAgXQogIH0sCiAgewogICAgImlkIjogIlMxMy12YWx1ZXMtcHJlY2VkZW5j" + - "ZSIsCiAgICAicXVlc3Rpb24iOiAiSSBhZGRlZCBhIHZhbHVlIHRvIG15IGVudmlyb25tZW50IFlB" + - "TUwgYnV0IGl0J3MgYmVpbmcgc2lsZW50bHkgaWdub3JlZC4gSG93IGRvIGhlbG1maWxlIHZhbHVl" + - "cyB3b3JrIGluIE5WQ0Y/IiwKICAgICJleHBlY3RlZF9za2lsbCI6ICJudmNmLXNlbGYtbWFuYWdl" + - "ZC1pbnN0YWxsYXRpb24iLAogICAgImdyb3VuZF90cnV0aCI6ICJUaGUgYWdlbnQgZXhwbGFpbmVk" + - "IHRoZSB2YWx1ZXMgcHJlY2VkZW5jZSBjaGFpbiAoYmFzZS55YW1sLCBlbnYgWUFNTCwgZ2xvYmFs" + - "LnlhbWwuZ290bXBsLCBzZWNyZXRzLCBpbmxpbmUgdmFsdWVzKSwgaWRlbnRpZmllZCB0aGF0IGds" + - "b2JhbC55YW1sLmdvdG1wbCBvbmx5IHBhc3NlcyB0aHJvdWdoIHNwZWNpZmljIGtleXMsIGFuZCBl" + - "eHBsYWluZWQgdGhhdCBhcmJpdHJhcnkgY2hhcnQgdmFsdWVzIG11c3QgdXNlIHJlbGVhc2UgaW5s" + - "aW5lIHZhbHVlcyBibG9ja3MuIiwKICAgICJleHBlY3RlZF9iZWhhdmlvciI6IFsKICAgICAgIlRo" + - "ZSBhZ2VudCByZWFkIHRoZSBudmNmLXNlbGYtbWFuYWdlZC1pbnN0YWxsYXRpb24gU0tJTEwubWQg" + - "YmVmb3JlIHRha2luZyBhY3Rpb24iLAogICAgICAiVGhlIGFnZW50IGV4cGxhaW5lZCB0aGUgdmFs" + - "dWVzIHByZWNlZGVuY2UgY2hhaW46IGJhc2UueWFtbCAtPiBlbnYgWUFNTCAtPiBnbG9iYWwueWFt" + - "bC5nb3RtcGwgLT4gc2VjcmV0cyAtPiBpbmxpbmUgdmFsdWVzIiwKICAgICAgIlRoZSBhZ2VudCBp" + - "ZGVudGlmaWVkIHRoYXQgZ2xvYmFsLnlhbWwuZ290bXBsIG9ubHkgcGFzc2VzIHRocm91Z2ggc3Bl" + - "Y2lmaWMga2V5cyAoY2Fzc2FuZHJhLnJlcGxpY2FDb3VudCwgZ2xvYmFsLnN0b3JhZ2VDbGFzcywg" + - "Z2xvYmFsLmltYWdlLCBldGMuKSIsCiAgICAgICJUaGUgYWdlbnQgZXhwbGFpbmVkIHRoYXQgYXJi" + - "aXRyYXJ5IGNoYXJ0IHZhbHVlcyBtdXN0IGJlIHNldCB2aWEgcmVsZWFzZSBpbmxpbmUgdmFsdWVz" + - "OiBibG9ja3MiLAogICAgICAiVGhlIGFnZW50IGxpc3RlZCBleGFtcGxlcyBvZiB2YWx1ZXMgdGhh" + - "dCBhcmUgcHJvcGFnYXRlZCBhbmQgYXJiaXRyYXJ5IGNoYXJ0IHZhbHVlcyB0aGF0IHJlcXVpcmUg" + - "YSByZWxlYXNlIHZhbHVlcyBibG9jayIKICAgIF0KICB9LAogIHsKICAgICJpZCI6ICJTMTQtZW5h" + - "YmxlLWxsbS1mdW5jdGlvbnMiLAogICAgInF1ZXN0aW9uIjogIkkgbmVlZCB0byBkZXBsb3kgZnVu" + - "Y3Rpb25UeXBlOiBMTE0gZnVuY3Rpb25zIG9uIGEgc2VsZi1tYW5hZ2VkLCBzaW5nbGUtbm9kZSBp" + - "c29sYXRlZCB0ZXN0IGNsdXN0ZXIuIFdoYXQgSGVsbWZpbGUgY29uZmlndXJhdGlvbiBhbmQgdmVy" + - "aWZpY2F0aW9uIHN0ZXBzIGRvIEkgbmVlZD8iLAogICAgImV4cGVjdGVkX3NraWxsIjogIm52Y2Yt" + - "c2VsZi1tYW5hZ2VkLWluc3RhbGxhdGlvbiIsCiAgICAiZ3JvdW5kX3RydXRoIjogIlRoZSBhZ2Vu" + - "dCBlbmFibGVkIHRoZSBMTE0gYWRkb24gd2l0aCBhZGRvbnMubGxtLmVuYWJsZWQsIGNvbmZpZ3Vy" + - "ZWQgc2luZ2xlIHJlcGxpY2FzIGZvciB0aGUgTExNIEFQSSBHYXRld2F5IGFuZCByZXF1ZXN0IHJv" + - "dXRlciwgYW5kIGV4cGxhaW5lZCB0aGF0IHRoZSByZXF1ZXN0IHJvdXRlciB1c2VzIHBvd2VyLW9m" + - "LXR3byB3aGVuIG5vIGxvYWQtYmFsYW5jZXIgY29uZmlndXJhdGlvbiBpcyBzZXQuIEl0IGxpbmtl" + - "ZCB0aGUgY2Fub25pY2FsIHJlcXVlc3Qtcm91dGVyIGxvYWQtYmFsYW5jaW5nIGd1aWRlIGZvciBv" + - "dGhlciByb3V0aW5nIG1ldGhvZHMuIEZvciB0aGUgaXNvbGF0ZWQgcGxhaW50ZXh0IGNsdXN0ZXIs" + - "IGl0IGluY2x1ZGVkIGJvdGggYWRkb25zLmxsbS5nYXRld2F5LmF1dGguZ3JwY0luc2VjdXJlIGFu" + - "ZCBhZ2VudENvbmZpZy5tZXJnZUNvbmZpZy53b3JrbG9hZC5zdGFyZ2F0ZVFVSUNJbnNlY3VyZSwg" + - "d2l0aCBhIHdhcm5pbmcgdGhhdCB0aG9zZSBzZXR0aW5ncyBhcmUgbm90IGZvciBwcm9kdWN0aW9u" + - "LiBJdCByZWZyZXNoZWQgdGhlIGNvbXB1dGUgcGxhbmUgdXNpbmcgdGhlIHNhbWUgaGFuZG9mZiB1" + - "c2VkIGR1cmluZyBpbnN0YWxsYXRpb24sIHJlZGVwbG95ZWQgZXhpc3RpbmcgTExNIGZ1bmN0aW9u" + - "cywgYW5kIHZlcmlmaWVkIHRoZSBMTE0gZGVwbG95bWVudHMsIHJvdXRlLCBhbmQgbGxtLXdvcmtl" + - "ciBzaWRlY2FyLiIsCiAgICAiZXhwZWN0ZWRfYmVoYXZpb3IiOiBbCiAgICAgICJUaGUgYWdlbnQg" + - "dXNlZCBhZGRvbnMubGxtLmVuYWJsZWQsIG5vdCB0aGUgb2Jzb2xldGUgbGxtLmVuYWJsZWQgcGF0" + - "aCIsCiAgICAgICJUaGUgYWdlbnQgc2V0IGdhdGV3YXkgYW5kIHJlcXVlc3RSb3V0ZXIgcmVwbGlj" + - "YUNvdW50IHRvIDEgZm9yIHRoZSBzaW5nbGUtbm9kZSB0ZXN0IGNsdXN0ZXIiLAogICAgICAiVGhl" + - "IGFnZW50IHN0YXRlZCB0aGF0IHRoZSByZXF1ZXN0IHJvdXRlciBkZWZhdWx0cyB0byBwb3dlci1v" + - "Zi10d28gYW5kIGxpbmtlZCB0aGUgY2Fub25pY2FsIHJlcXVlc3Qtcm91dGVyIGxvYWQtYmFsYW5j" + - "aW5nIGd1aWRlIGZvciBvdGhlciBtZXRob2RzIiwKICAgICAgIlRoZSBhZ2VudCBpbmNsdWRlZCBh" + - "ZGRvbnMubGxtLmdhdGV3YXkuYXV0aC5ncnBjSW5zZWN1cmUgYW5kIHdvcmtsb2FkLnN0YXJnYXRl" + - "UVVJQ0luc2VjdXJlIGZvciB0aGUgaXNvbGF0ZWQgcGxhaW50ZXh0IGNsdXN0ZXIsIGFuZCB3YXJu" + - "ZWQgYWdhaW5zdCB1c2luZyB0aGVtIGluIHByb2R1Y3Rpb24iLAogICAgICAiVGhlIGFnZW50IGFw" + - "cGxpZWQgdGhlIGNvbnRyb2wtcGxhbmUgSGVsbWZpbGUgZW52aXJvbm1lbnQsIHJlZnJlc2hlZCB0" + - "aGUgY29tcHV0ZSBwbGFuZSB3aXRoIHRoZSBzYW1lIHNlbGVjdGVkIGhhbmRvZmYsIGFuZCByZWNy" + - "ZWF0ZWQgb3IgcmVkZXBsb3llZCBleGlzdGluZyBMTE0gZnVuY3Rpb25zIiwKICAgICAgIlRoZSBh" + - "Z2VudCB2ZXJpZmllZCBsbG0tYXBpLWdhdGV3YXksIGxsbS1yZXF1ZXN0LXJvdXRlciwgdGhlIExM" + - "TSBIVFRQUm91dGUsIGFuZCB0aGUgbGxtLXdvcmtlciBzaWRlY2FyIGluY2x1ZGluZyAtLXF1aWMt" + - "aW5zZWN1cmUiCiAgICBdCiAgfSwKICB7CiAgICAiaWQiOiAiRzgtTkVHLW5vdC1mb3ItazNkIiwK" + - "ICAgICJxdWVzdGlvbiI6ICJTZXQgdXAgYSBsb2NhbCBOVkNGIGRldiBjbHVzdGVyIHVzaW5nIGsz" + - "ZCBmb3IgdGVzdGluZyIsCiAgICAiZXhwZWN0ZWRfc2tpbGwiOiBudWxsLAogICAgInNob3VsZF90" + - "cmlnZ2VyIjogZmFsc2UsCiAgICAiZ3JvdW5kX3RydXRoIjogIlRoaXMgaXMgYSBsb2NhbCBrM2Qg" + - "ZGV2ZWxvcG1lbnQgcmVxdWVzdCB0aGF0IGJlbG9uZ3MgdG8gdGhlIG52Y2Ytc2VsZi1ob3N0ZWQt" + - "bG9jYWwtZGV2IHNraWxsLCBub3QgbnZjZi1zZWxmLW1hbmFnZWQtaW5zdGFsbGF0aW9uLiBUaGUg" + - "YWdlbnQgZGlkIG5vdCByZWFkIG9yIHVzZSB0aGUgc2VsZi1tYW5hZ2VkIGluc3RhbGxhdGlvbiBz" + - "a2lsbCBhbmQgaW5zdGVhZCBwcm92aWRlZCBrM2Qtc3BlY2lmaWMgZ3VpZGFuY2UuIiwKICAgICJl" + - "eHBlY3RlZF9iZWhhdmlvciI6IFsKICAgICAgIlRoZSBhZ2VudCBkaWQgbm90IHJlYWQgbnZjZi1z" + - "ZWxmLW1hbmFnZWQtaW5zdGFsbGF0aW9uL1NLSUxMLm1kIiwKICAgICAgIlRoZSBhZ2VudCBkaWQg" + - "bm90IHByb3ZpZGUgaGVsbWZpbGUtYmFzZWQgcHJvZHVjdGlvbiBkZXBsb3ltZW50IGluc3RydWN0" + - "aW9ucyIsCiAgICAgICJUaGUgYWdlbnQgcHJvdmlkZWQgazNkLXNwZWNpZmljIGxvY2FsIGRldmVs" + - "b3BtZW50IGd1aWRhbmNlIG9yIGRlZmVycmVkIHRvIHRoZSBhcHByb3ByaWF0ZSBsb2NhbC1kZXYg" + - "c2tpbGwiCiAgICBdCiAgfQpdClBLBwgrE7g/rVUAAK1VAABQSwMEFAAIAAAAAAAhAAAAAAAAAAAA" + - "AAAAAC8ACQBkYXRhL252Y2Ytc2VsZi1tYW5hZ2VkLWluc3RhbGxhdGlvbi9leGFtcGxlcy5tZFVU" + - "BQABAKbOEiMgRXhhbXBsZXMKCldvcmtlZCBleGFtcGxlcyBiYXNlZCBvbiByZWFsIGRlcGxveW1l" + - "bnQgc2NlbmFyaW9zLgoKIyMgRXhhbXBsZSAxOiBPdmVycmlkZSBDYXNzYW5kcmEgUmVzb3VyY2Vz" + - "CgpUaGUgZGVmYXVsdCBDYXNzYW5kcmEgcmVzb3VyY2UgbGltaXRzIGNhdXNlIE9PTSBvbiBsYXJn" + - "ZSBpbnN0YW5jZSB0eXBlcyAoZS5nLiwgYHA1LjQ4eGxhcmdlYCkuCgpQcm9ibGVtOiBDYXNzYW5k" + - "cmEgcG9kcyByZXN0YXJ0IHdpdGggYE9PTUtpbGxlZGAuCgpTb2x1dGlvbjogT3ZlcnJpZGUgcmVz" + - "b3VyY2VzIHZpYSBoZWxtZmlsZSByZWxlYXNlIHZhbHVlcyBibG9jay4KCiMjIyBTdGVwIDE6IENh" + - "cHR1cmUgYmFzZWxpbmUKCmBgYGJhc2gKSEVMTUZJTEVfRU5WPTxlbnY+IGhlbG1maWxlIC0tc2Vs" + - "ZWN0b3IgbmFtZT1jYXNzYW5kcmEgdGVtcGxhdGUgPiAvdG1wL2Nhc3MtYmVmb3JlLnlhbWwKZ3Jl" + - "cCAtQTggJ3Jlc291cmNlczonIC90bXAvY2Fzcy1iZWZvcmUueWFtbCB8IGhlYWQgLTEwCmBgYAoK" + - "IyMjIFN0ZXAgMjogQWRkIG92ZXJyaWRlIHRvIGhlbG1maWxlLmQvMDEtZGVwZW5kZW5jaWVzLnlh" + - "bWwuZ290bXBsCgpJbiB0aGUgZXhhbXBsZXMgYmVsb3csIGA8cHJpdmF0ZS12YWx1ZXM+YCByZWZl" + - "cnMgdG8gdGhlIGBzZWNyZXRzL2AgZGlyZWN0b3J5IGF0IHRoZSBoZWxtZmlsZSBzdGFjayByb290" + - "LgoKYGBgeWFtbAotIG5hbWU6IGNhc3NhbmRyYQogIHZlcnNpb246IDAuOC4wCiAgY29uZGl0aW9u" + - "OiBjYXNzYW5kcmEuZW5hYmxlZAogIG5hbWVzcGFjZTogY2Fzc2FuZHJhLXN5c3RlbQogIDw8OiAq" + - "ZGVwZW5kZW5jeQogIHZhbHVlczoKICAgIC0gLi4vZ2xvYmFsLnlhbWwuZ290bXBsCiAgICAtIC4u" + - "Lzxwcml2YXRlLXZhbHVlcz4ve3sgcmVxdWlyZWRFbnYgIkhFTE1GSUxFX0VOViIgfX0tc2VjcmV0" + - "cy55YW1sCiAgICAtIGNhc3NhbmRyYToKICAgICAgICByZXNvdXJjZXM6CiAgICAgICAgICBsaW1p" + - "dHM6CiAgICAgICAgICAgIGNwdTogIjgiCiAgICAgICAgICAgIG1lbW9yeTogODE5Mk1pCiAgICAg" + - "ICAgICByZXF1ZXN0czoKICAgICAgICAgICAgY3B1OiAiMiIKICAgICAgICAgICAgbWVtb3J5OiA0" + - "MDk2TWkKYGBgCgojIyMgU3RlcCAzOiBWZXJpZnkgYW5kIGFwcGx5CgpgYGBiYXNoCkhFTE1GSUxF" + - "X0VOVj08ZW52PiBoZWxtZmlsZSAtLXNlbGVjdG9yIG5hbWU9Y2Fzc2FuZHJhIHRlbXBsYXRlID4g" + - "L3RtcC9jYXNzLWFmdGVyLnlhbWwKZGlmZiAvdG1wL2Nhc3MtYmVmb3JlLnlhbWwgL3RtcC9jYXNz" + - "LWFmdGVyLnlhbWwgICMgQ29uZmlybSByZXNvdXJjZXMgY2hhbmdlZApIRUxNRklMRV9FTlY9PGVu" + - "dj4gaGVsbWZpbGUgLS1zZWxlY3RvciBuYW1lPWNhc3NhbmRyYSBzeW5jCmBgYAoKTm90ZTogYHJl" + - "c291cmNlUHJlc2V0YCAoYSBCaXRuYW1pIGZlYXR1cmUpIGlzIG5vdCBhdmFpbGFibGUgaW4gdGhl" + - "IE5WQ0YgY2Fzc2FuZHJhIHdyYXBwZXIgY2hhcnQuIFVzZSBleHBsaWNpdCBgcmVzb3VyY2VzYCBp" + - "bnN0ZWFkLgoKLS0tCgojIyBFeGFtcGxlIDI6IERlcGxveSBmcm9tIE5HQyBQcml2YXRlIFJlZ2lz" + - "dHJ5IHdpdGggUHVsbCBTZWNyZXRzCgpEZXBsb3kgdGhlIE5WQ0Ygc3RhY2sgcHVsbGluZyBpbWFn" + - "ZXMgZGlyZWN0bHkgZnJvbSBOR0MgKGBudmNyLmlvYCkgaW5zdGVhZCBvZiBhIG1pcnJvcmVkIHJl" + - "Z2lzdHJ5LCB1c2luZyBpbWFnZSBwdWxsIHNlY3JldHMuCgojIyMgU3RlcCAxOiBDb25maWd1cmUg" + - "ZW52aXJvbm1lbnQgZm9yIE5HQwoKYGBgeWFtbAojIGVudmlyb25tZW50cy88ZW52Pi55YW1sCmds" + - "b2JhbDoKICBoZWxtOgogICAgc291cmNlczoKICAgICAgcmVnaXN0cnk6IG52Y3IuaW8KICAgICAg" + - "cmVwb3NpdG9yeTogbnZpZGlhL252Y2YKICBpbWFnZToKICAgIHJlZ2lzdHJ5OiBudmNyLmlvCiAg" + - "ICByZXBvc2l0b3J5OiBudmlkaWEvbnZjZgpgYGAKCiMjIyBTdGVwIDI6IEF1dGhlbnRpY2F0ZSBs" + - "b2NhbGx5IChmb3IgaGVsbWZpbGUgY2hhcnQgcHVsbHMpCgpgYGBiYXNoCmRvY2tlciBsb2dpbiBu" + - "dmNyLmlvIC11ICckb2F1dGh0b2tlbicgLXAgIiROR0NfQVBJX0tFWSIKaGVsbSByZWdpc3RyeSBs" + - "b2dpbiBudmNyLmlvIC11ICckb2F1dGh0b2tlbicgLXAgIiROR0NfQVBJX0tFWSIKYGBgCgojIyMg" + - "U3RlcCAzOiBDcmVhdGUgbmFtZXNwYWNlcyBhbmQgcHVsbCBzZWNyZXRzCgpgYGBiYXNoCmV4cG9y" + - "dCBOR0NfQVBJX0tFWT0iPHlvdXItbmdjLWFwaS1rZXk+IgoKZm9yIG5zIGluIGNhc3NhbmRyYS1z" + - "eXN0ZW0gbmF0cy1zeXN0ZW0gbnZjZiBhcGkta2V5cyBlc3Mgc2lzIHZhdWx0LXN5c3RlbSBjZXJ0" + - "LW1hbmFnZXI7IGRvCiAga3ViZWN0bCAtLWNvbnRleHQgPGNvbnRyb2wtcGxhbmUtY29udGV4dD4g" + - "Y3JlYXRlIG5hbWVzcGFjZSAiJG5zIiBcCiAgICAtLWRyeS1ydW49Y2xpZW50IC1vIHlhbWwgfCBr" + - "dWJlY3RsIC0tY29udGV4dCA8Y29udHJvbC1wbGFuZS1jb250ZXh0PiBhcHBseSAtZiAtCmRvbmUK" + - "CmZvciBucyBpbiBjYXNzYW5kcmEtc3lzdGVtIG5hdHMtc3lzdGVtIG52Y2YgYXBpLWtleXMgZXNz" + - "IHNpcyB2YXVsdC1zeXN0ZW0gY2VydC1tYW5hZ2VyOyBkbwogIGt1YmVjdGwgLS1jb250ZXh0IDxj" + - "b250cm9sLXBsYW5lLWNvbnRleHQ+IGNyZWF0ZSBzZWNyZXQgZG9ja2VyLXJlZ2lzdHJ5IG52Y3It" + - "Y3JlZHMgXAogICAgLS1kb2NrZXItc2VydmVyPW52Y3IuaW8gXAogICAgLS1kb2NrZXItdXNlcm5h" + - "bWU9JyRvYXV0aHRva2VuJyBcCiAgICAtLWRvY2tlci1wYXNzd29yZD0iJE5HQ19BUElfS0VZIiBc" + - "CiAgICAtLW5hbWVzcGFjZT0iJG5zIiBcCiAgICAtLWRyeS1ydW49Y2xpZW50IC1vIHlhbWwgfCBr" + - "dWJlY3RsIC0tY29udGV4dCA8Y29udHJvbC1wbGFuZS1jb250ZXh0PiBhcHBseSAtZiAtCmRvbmUK" + - "YGBgCgojIyMgU3RlcCA0OiBBZGQgaW1hZ2VQdWxsU2VjcmV0cyB0byBoZWxtZmlsZSByZWxlYXNl" + - "cwoKQWRkIHRoZSBjaGFydC1zcGVjaWZpYyBgaW1hZ2VQdWxsU2VjcmV0c2Aga2V5IHRvIGVhY2gg" + - "cmVsZWFzZS4gRXhhbXBsZSBmb3IgY2Fzc2FuZHJhIGluIGBoZWxtZmlsZS5kLzAxLWRlcGVuZGVu" + - "Y2llcy55YW1sLmdvdG1wbGA6CgpgYGB5YW1sCi0gbmFtZTogY2Fzc2FuZHJhCiAgdmVyc2lvbjog" + - "MC44LjAKICBjb25kaXRpb246IGNhc3NhbmRyYS5lbmFibGVkCiAgbmFtZXNwYWNlOiBjYXNzYW5k" + - "cmEtc3lzdGVtCiAgPDw6ICpkZXBlbmRlbmN5CiAgdmFsdWVzOgogICAgLSAuLi9nbG9iYWwueWFt" + - "bC5nb3RtcGwKICAgIC0gLi4vPHByaXZhdGUtdmFsdWVzPi97eyByZXF1aXJlZEVudiAiSEVMTUZJ" + - "TEVfRU5WIiB9fS1zZWNyZXRzLnlhbWwKICAgIC0gY2Fzc2FuZHJhOgogICAgICAgIGdsb2JhbDoK" + - "ICAgICAgICAgIGltYWdlUHVsbFNlY3JldHM6CiAgICAgICAgICAgIC0gbnZjci1jcmVkcwpgYGAK" + - "ClNlZSBbcmVmZXJlbmNlcy9wdWxsLXNlY3JldHMubWRdKHJlZmVyZW5jZXMvcHVsbC1zZWNyZXRz" + - "Lm1kKSBmb3IgdGhlIGtleSBmb3IgZXZlcnkgY2hhcnQuCgpUaGVzZSBhcmUgY29udHJvbC1wbGFu" + - "ZSBuYW1lc3BhY2VzLiBGb3IgYSBzZXBhcmF0ZSBjb21wdXRlIGNsdXN0ZXIsIGNyZWF0ZSB0aGUK" + - "c2VjcmV0IG9ubHkgaW4gYG52Y2Etb3BlcmF0b3JgOyB0aGUgY2hhcnQgYW5kIG9wZXJhdG9yIG1p" + - "cnJvciBpdCB0bwpgbnZjYS1zeXN0ZW1gLiBTZWUgW1NwbGl0IENvbXB1dGUtUGxhbmUgSW5zdGFs" + - "bGF0aW9uXShyZWZlcmVuY2VzL2NvbXB1dGUtcGxhbmUtaW5zdGFsbGF0aW9uLm1kI3B1bGwtc2Vj" + - "cmV0cykuCgojIyMgU3RlcCA1OiBEZXBsb3kKCmBgYGJhc2gKSEVMTUZJTEVfRU5WPTxlbnY+IGhl" + - "bG1maWxlIC0ta3ViZS1jb250ZXh0IDxjb250cm9sLXBsYW5lLWNvbnRleHQ+IHN5bmMKYGBgCgoj" + - "IyMgU3RlcCA2OiBQYXRjaCBTZXJ2aWNlQWNjb3VudHMgZm9yIGNoYXJ0cyB3aXRob3V0IG5hdGl2" + - "ZSBzdXBwb3J0CgpBZnRlciBQaGFzZSAxIChkZXBlbmRlbmNpZXMpIGNvbXBsZXRlcywgT3BlbkJh" + - "byBwb2RzIHdpbGwgYmUgaW4gYEltYWdlUHVsbEJhY2tPZmZgLiBQYXRjaCBhbmQgcmVzdGFydDoK" + - "CmBgYGJhc2gKZm9yIG5zIGluIHZhdWx0LXN5c3RlbSBudmNmIGVzczsgZG8KICBmb3Igc2EgaW4g" + - "JChrdWJlY3RsIC0tY29udGV4dCA8Y29udHJvbC1wbGFuZS1jb250ZXh0PiBnZXQgc2EgLW4gIiRu" + - "cyIgXAogICAgLS1uby1oZWFkZXJzIC1vIGN1c3RvbS1jb2x1bW5zPSI6bWV0YWRhdGEubmFtZSIp" + - "OyBkbwogICAga3ViZWN0bCAtLWNvbnRleHQgPGNvbnRyb2wtcGxhbmUtY29udGV4dD4gcGF0Y2gg" + - "c2VydmljZWFjY291bnQgLW4gIiRucyIgIiRzYSIgXAogICAgICAtcCAneyJpbWFnZVB1bGxTZWNy" + - "ZXRzIjogW3sibmFtZSI6ICJudmNyLWNyZWRzIn1dfScKICBkb25lCmRvbmUKa3ViZWN0bCAtLWNv" + - "bnRleHQgPGNvbnRyb2wtcGxhbmUtY29udGV4dD4gZGVsZXRlIHBvZHMgLW4gdmF1bHQtc3lzdGVt" + - "IC0tYWxsCmBgYAoKVmVyaWZ5OgoKYGBgYmFzaAprdWJlY3RsIC0tY29udGV4dCA8Y29udHJvbC1w" + - "bGFuZS1jb250ZXh0PiBnZXQgZXZlbnRzIC1uIHZhdWx0LXN5c3RlbSBcCiAgLS1zb3J0LWJ5PScu" + - "bGFzdFRpbWVzdGFtcCcgfCBncmVwIC1pIHB1bGwKIyBTaG91bGQgc2hvdyAiU3VjY2Vzc2Z1bGx5" + - "IHB1bGxlZCBpbWFnZSIgZnJvbSBudmNyLmlvCmBgYAoKLS0tCgojIyBFeGFtcGxlIDM6IEZ1bGwg" + - "VGVhcmRvd24gYW5kIFJlaW5zdGFsbAoKV2hlbiBhIGRlcGxveW1lbnQgaXMgYnJva2VuIGFuZCB5" + - "b3UgbmVlZCBhIGNsZWFuIHNsYXRlLgoKIyMjIFN0ZXAgMTogRGVzdHJveSB0aGUgY29tcHV0ZS1w" + - "bGFuZSBzdGFjawoKYGBgYmFzaAptYWtlIC1DIGRlcGxveS9zdGFja3MvbnZjZi1jb21wdXRlLXBs" + - "YW5lIGRlc3Ryb3kgXAogIENMVVNURVJfTkFNRT08Y2x1c3Rlci1uYW1lPiBcCiAgSEVMTUZJTEVf" + - "RU5WPTxlbnY+IFwKICBLVUJFQ09ORklHX0ZJTEU9PGNvbXB1dGUtcGxhbmUta3ViZWNvbmZpZz4K" + - "YGBgCgpJZiBjb21wdXRlIGNsZWFudXAgaXMgc3R1Y2sgb24gZmluYWxpemVycywgdXNlIHRoZSBj" + - "b21wdXRlLWNvbnRleHQgcHJvY2VkdXJlIGluCltkZWJ1Z2dpbmcubWRdKHJlZmVyZW5jZXMvZGVi" + - "dWdnaW5nLm1kI2ZhaWx1cmUtbnZjYS1jbGVhbnVwLXN0dWNrLWZpbmFsaXplcnMpLgoKIyMjIFN0" + - "ZXAgMjogRGVyZWdpc3RlciB0aGUgY29tcHV0ZSBjbHVzdGVyCgpSZWFkIGBjbHVzdGVySURgIGFu" + - "ZCBgbmNhSURgIGZyb20KYGRlcGxveS9zdGFja3MvbnZjZi1jb21wdXRlLXBsYW5lL3JlZ2lzdHJh" + - "dGlvbi88Y2x1c3Rlci1uYW1lPi1yZWdpc3Rlci12YWx1ZXMueWFtbGAuClNob3cgdGhlIElEIGFu" + - "ZCBnZXQgY29uZmlybWF0aW9uIGJlZm9yZSBkZWxldGluZyB0aGUgSUNNUyByb3c6CgpgYGBiYXNo" + - "CjxudmNmLWNsaT4gLS1jb25maWcgPGNvbmZpZz4gY2x1c3RlciBkZWxldGUgXAogIC0tY2x1c3Rl" + - "ci1pZCA8Y2x1c3Rlci1pZC1mcm9tLXJlZ2lzdHJhdGlvbi12YWx1ZXM+IFwKICAtLW5jYS1pZCA8" + - "bmNhLWlkPiBcCiAgLS1pZ25vcmUtbWlzc2luZwpgYGAKClJlcGVhdCBzdGVwcyAxIGFuZCAyIGZv" + - "ciBldmVyeSBjb21wdXRlIGNsdXN0ZXIuCgojIyMgU3RlcCAzOiBEZXN0cm95IHRoZSBjb250cm9s" + - "LXBsYW5lIHN0YWNrCgpQcmVzZXJ2ZSB0aGUgYGNlcnQtbWFuYWdlcmAgbmFtZXNwYWNlIGJ5IGRl" + - "ZmF1bHQuIE5hbWVzcGFjZSBwcmVzZXJ2YXRpb24gZG9lcwpub3QgcHJlc2VydmUgdGhlIEhlbG0g" + - "cmVsZWFzZS4gQmVmb3JlIHJ1bm5pbmcgZGVzdHJveSwgaWRlbnRpZnkgd2hldGhlcgpjZXJ0LW1h" + - "bmFnZXIgaXMgZXh0ZXJuYWwuIEZvciBhbiBleHRlcm5hbCBpbnN0YWxsYXRpb24sIHJlcXVpcmUg" + - "ZWZmZWN0aXZlCmBjZXJ0TWFuYWdlci5lbmFibGVkOiBmYWxzZWAgYW5kIGFib3J0IGlmIGl0IGlz" + - "IHRydWUuIEZvciBhbiBpbnRlbmRlZApzdGFjay1tYW5hZ2VkIHJlbGVhc2Ugd2l0aCBlZmZlY3Rp" + - "dmUgYGNlcnRNYW5hZ2VyLmVuYWJsZWQ6IHRydWVgLCB2ZXJpZnkKbWF0Y2hpbmcgc3RhY2sgSGVs" + - "bSByZWxlYXNlIG1ldGFkYXRhIGFuZCBhYm9ydCBvbiBtaXNzaW5nIG9yIG1pc21hdGNoZWQKZXZp" + - "ZGVuY2UuIE9ubHkgcGxhbiBuYW1lc3BhY2UgcmVtb3ZhbCBhZnRlciB2ZXJpZnlpbmcgbmFtZXNw" + - "YWNlIHByb3ZlbmFuY2UgYW5kCmdldHRpbmcgZXhwbGljaXQgY29uZmlybWF0aW9uOyBvdGhlcndp" + - "c2UgZG8gbm90IGRlbGV0ZSBpdC4KCmBgYGJhc2gKS1VCRUNPTkZJRz08Y29udHJvbC1wbGFuZS1r" + - "dWJlY29uZmlnPiBcCm1ha2UgLUMgZGVwbG95L3N0YWNrcy9zZWxmLW1hbmFnZWQgZGVzdHJveSBc" + - "CiAgSEVMTUZJTEVfRU5WPTxlbnY+IFwKICBLVUJFQ09ORklHX0ZJTEU9PGNvbnRyb2wtcGxhbmUt" + - "a3ViZWNvbmZpZz4KYGBgCgpQYXNzIGJvdGgga3ViZWNvbmZpZyBmb3JtcyBiZWNhdXNlIGNvbnRy" + - "b2wtcGxhbmUgbmFtZXNwYWNlIGNsZWFudXAgdXNlcwphbWJpZW50IGBrdWJlY3RsYC4KCiMjIyBT" + - "dGVwIDQ6IFZlcmlmeSBjbGVhbgoKYGBgYmFzaAprdWJlY3RsIC0tY29udGV4dCA8Y29tcHV0ZS1w" + - "bGFuZS1jb250ZXh0PiBnZXQgbnMgfCBcCiAgZ3JlcCAtRSAnKG52Y2F8bnZjZi1iYWNrZW5kfGdy" + - "b3ZlfGR5bmFtbyknCmt1YmVjdGwgLS1jb250ZXh0IDxjb250cm9sLXBsYW5lLWNvbnRleHQ+IGdl" + - "dCBucyB8IFwKICBncmVwIC1FICcoY2Fzc2FuZHJhfG5hdHN8dmF1bHR8bnZjZnxhcGkta2V5c3xl" + - "c3N8c2lzKScKIyBCb3RoIGNvbW1hbmRzIHNob3VsZCByZXR1cm4gZW1wdHkuCmBgYAoKIyMjIFN0" + - "ZXAgNTogUmVpbnN0YWxsIGluIHNwbGl0IG9yZGVyCgpGb2xsb3cgW0NsZWFuIEluc3RhbGxhdGlv" + - "bl0oU0tJTEwubWQjY2xlYW4taW5zdGFsbGF0aW9uKSwgdGhlbiByZXR1cm4gdG8gdGhlCnNhbWUg" + - "aGFuZG9mZiBpbiBbU3BsaXQgQ29tcHV0ZS1QbGFuZSBJbnN0YWxsYXRpb25dKHJlZmVyZW5jZXMv" + - "Y29tcHV0ZS1wbGFuZS1pbnN0YWxsYXRpb24ubWQpLgoKLS0tCgojIyBFeGFtcGxlIDQ6IFJlY292" + - "ZXIgZnJvbSBhIEdhdGV3YXkgRW5kcG9pbnQgQ2hhbmdlCgpUaGUgc2VwYXJhdGVseSBwcm92aXNp" + - "b25lZCBHYXRld2F5IG9yIGl0cyBsb2FkIGJhbGFuY2VyIHdhcyByZWNyZWF0ZWQgYW5kIGdvdCBh" + - "IG5ldyBlbmRwb2ludC4KCiMjIyBTdGVwIDE6IEdldCB0aGUgbmV3IGVuZHBvaW50CgpgYGBiYXNo" + - "CkdBVEVXQVlfQUREUj0kKGt1YmVjdGwgLS1jb250ZXh0IDxjb250cm9sLXBsYW5lLWNvbnRleHQ+" + - "IGdldCBnYXRld2F5IFwKICBudmNmLWdhdGV3YXkgLW4gZW52b3ktZ2F0ZXdheSBcCiAgLW8ganNv" + - "bnBhdGg9J3suc3RhdHVzLmFkZHJlc3Nlc1swXS52YWx1ZX0nKQp0ZXN0IC1uICIkR0FURVdBWV9B" + - "RERSIgpgYGAKCiMjIyBTdGVwIDI6IFVwZGF0ZSBETlMgYW5kIGRpcmVjdCBhZGRyZXNzIGZpZWxk" + - "cwoKS2VlcCBgZ2xvYmFsLmRvbWFpbmAsIHJvdXRlIGhvc3RuYW1lcywgYW5kIENMSSBIb3N0IGZp" + - "ZWxkcyB1bmNoYW5nZWQuIFBvaW50IHRoZQpETlMgcmVjb3JkcyBmb3IgcmVuZGVyZWQgcm91dGUg" + - "aG9zdG5hbWVzLCBzdWNoIGFzIGBhcGkuPGRvbWFpbj5gIGFuZApgKi5pbnZvY2F0aW9uLjxkb21h" + - "aW4+YCwgdG8gYEdBVEVXQVlfQUREUmAuIEZvciBhIHRlbXBvcmFyeSBlbnZpcm9ubWVudCB3aXRo" + - "b3V0CkROUywga2VlcCBpdHMgcmVzZXJ2ZWQgcm91dGUgc3VmZml4IGFuZCBjb25uZWN0IHRvIGBH" + - "QVRFV0FZX0FERFJgIHdpdGggdGhlCm1hdGNoaW5nIGBIb3N0YCBoZWFkZXIuCgpGb3IgYSBzcGxp" + - "dCBkZXBsb3ltZW50IGNvbmZpZ3VyZWQgd2l0aCBkaXJlY3QgR2F0ZXdheSBhZGRyZXNzZXMsIHJl" + - "cGxhY2Ugb25seQp0aGUgYWRkcmVzcy1iZWFyaW5nIHZhbHVlczogY29udHJvbC1wbGFuZSBgbnZj" + - "Zk5hdHNTZXJ2aWNlVVJMYCwgY29tcHV0ZS1wbGFuZQpJQ01TLCBSZVZhbCwgYW5kIE5BVFMgVVJM" + - "cywgYW5kIENMSSBVUkwgZmllbGRzLiBLZWVwIHRoZWlyIGRvbWFpbiBhbmQgSG9zdApvdmVycmlk" + - "ZXMgdW5jaGFuZ2VkLiBSZWZyZXNoIHJlZ2lzdHJhdGlvbiBhbmQgaW5zdGFsbGF0aW9uIHRocm91" + - "Z2ggdGhlIHNhbWUKaGFuZG9mZiB1c2VkIG9yaWdpbmFsbHkuIFNlZQpbU3BsaXQgQ29tcHV0ZS1Q" + - "bGFuZSBJbnN0YWxsYXRpb25dKHJlZmVyZW5jZXMvY29tcHV0ZS1wbGFuZS1pbnN0YWxsYXRpb24u" + - "bWQpCmZvciB0aGUgZmllbGRzIGFuZCBjb21wbGV0ZSBjb21tYW5kcy4KCiMjIyBTdGVwIDM6IFZl" + - "cmlmeSBib3RoIGNvbnRleHRzCgpgYGBiYXNoCmRpZyArc2hvcnQgImFwaS48ZG9tYWluPiIKY3Vy" + - "bCAtSCAiSG9zdDogYXBpLjxkb21haW4+IiAiaHR0cDovLyRHQVRFV0FZX0FERFIvaGVhbHRoIgpr" + - "dWJlY3RsIC0tY29udGV4dCA8Y29udHJvbC1wbGFuZS1jb250ZXh0PiBnZXQgZ2F0ZXdheSBudmNm" + - "LWdhdGV3YXkgXAogIC1uIGVudm95LWdhdGV3YXkgLW8gd2lkZQprdWJlY3RsIC0tY29udGV4dCA8" + - "Y29udHJvbC1wbGFuZS1jb250ZXh0PiBnZXQgaHR0cHJvdXRlcyAtQQprdWJlY3RsIC0tY29udGV4" + - "dCA8Y29udHJvbC1wbGFuZS1jb250ZXh0PiBnZXQgdGNwcm91dGVzIC1BCmt1YmVjdGwgLS1jb250" + - "ZXh0IDxjb21wdXRlLXBsYW5lLWNvbnRleHQ+IHJvbGxvdXQgc3RhdHVzIFwKICBkZXBsb3ltZW50" + - "L252Y2Etb3BlcmF0b3IgLW4gbnZjYS1vcGVyYXRvciAtLXRpbWVvdXQ9MTBtCmt1YmVjdGwgLS1j" + - "b250ZXh0IDxjb21wdXRlLXBsYW5lLWNvbnRleHQ+IHdhaXQgXAogIG52Y2ZiYWNrZW5kLzxjb21w" + - "dXRlLXBsYW5lLWNsdXN0ZXItbmFtZT4gLW4gbnZjYS1vcGVyYXRvciBcCiAgLS1mb3I9anNvbnBh" + - "dGg9J3suc3RhdHVzLmFnZW50U3RhdHVzfSc9aGVhbHRoeSAtLXRpbWVvdXQ9MTBtCmBgYAoKLS0t" + - "CgojIyBFeGFtcGxlIDU6IERlcGxveSBPbmx5IERlcGVuZGVuY2llcwoKVXNlZnVsIGZvciB0ZXN0" + - "aW5nIG9yIHdoZW4gaXRlcmF0aW5nIG9uIHNlcnZpY2UgY29uZmlndXJhdGlvbi4KCmBgYGJhc2gK" + - "IyBEZXBsb3kganVzdCBOQVRTLCBDYXNzYW5kcmEsIE9wZW5CYW8KSEVMTUZJTEVfRU5WPTxlbnY+" + - "IGhlbG1maWxlIC0tc2VsZWN0b3IgcmVsZWFzZS1ncm91cD1kZXBlbmRlbmNpZXMgc3luYwoKIyBD" + - "aGVjayBzdGF0dXMKa3ViZWN0bCBnZXQgcG9kcyAtbiBuYXRzLXN5c3RlbQprdWJlY3RsIGdldCBw" + - "b2RzIC1uIGNhc3NhbmRyYS1zeXN0ZW0Ka3ViZWN0bCBnZXQgcG9kcyAtbiB2YXVsdC1zeXN0ZW0K" + - "CiMgRGVwbG95IGp1c3Qgb25lIHNwZWNpZmljIHJlbGVhc2UKSEVMTUZJTEVfRU5WPTxlbnY+IGhl" + - "bG1maWxlIC0tc2VsZWN0b3IgbmFtZT1jYXNzYW5kcmEgc3luYwpgYGAKCiMjIyBTZWxlY3RvciBy" + - "ZWZlcmVuY2UKCnwgU2VsZWN0b3IgfCBSZWxlYXNlcyB8CnwtLS0tLS0tLS0tfC0tLS0tLS0tLS18" + - "CnwgYHJlbGVhc2UtZ3JvdXA9ZGVwZW5kZW5jaWVzYCB8IG5hdHMsIGNhc3NhbmRyYSwgb3BlbmJh" + - "by1zZXJ2ZXIgfAp8IGByZWxlYXNlLWdyb3VwPXNlcnZpY2VzYCB8IGFwaS1rZXlzLCBzaXMsIGFw" + - "aSwgaW52b2NhdGlvbi1zZXJ2aWNlLCBncnBjLXByb3h5LCBlc3MtYXBpLCBub3Rhcnktc2Vydmlj" + - "ZSwgcmV2YWwsIG9wdGlvbmFsIGxsbS1yZXF1ZXN0LXJvdXRlciBhbmQgbGxtLWFwaS1nYXRld2F5" + - "IHdoZW4gYGxsbS5lbmFibGVkPXRydWVgLCBvcHRpb25hbCB2YW5pdHktZ2F0ZXdheSBvbmx5IGlu" + - "IHN0YWNrIHBhY2thZ2VzIHRoYXQgaW5jbHVkZSB0aGUgYWRkb24gYW5kIGhhdmUgYGFkZG9ucy52" + - "YW5pdHlHYXRld2F5LmVuYWJsZWQ9dHJ1ZWAsIG9wdGlvbmFsIG52Y2YtdWkgb25seSBpbiBzdGFj" + - "ayBwYWNrYWdlcyB0aGF0IGluY2x1ZGUgdGhlIGFkZG9uIGFuZCBoYXZlIGBhZGRvbnMubnZjZlVp" + - "LmVuYWJsZWQ9dHJ1ZWAgfAp8IGBuYW1lPWxsbS1yZXF1ZXN0LXJvdXRlcmAgfCBEZXBsb3kganVz" + - "dCB0aGUgTExNIHJlcXVlc3Qgcm91dGVyIHdoZW4gYGxsbS5lbmFibGVkPXRydWVgIHwKfCBgbmFt" + - "ZT1sbG0tYXBpLWdhdGV3YXlgIHwgRGVwbG95IGp1c3QgdGhlIExMTSBBUEkgZ2F0ZXdheSB3aGVu" + - "IGBsbG0uZW5hYmxlZD10cnVlYCB8CnwgYG5hbWU9dmFuaXR5LWdhdGV3YXlgIHwgRGVwbG95IGp1" + - "c3QgVmFuaXR5IEdhdGV3YXkgb25seSB3aGVuIHRoZSBzdGFjayBwYWNrYWdlIGluY2x1ZGVzIHRo" + - "YXQgcmVsZWFzZSBhbmQgYGFkZG9ucy52YW5pdHlHYXRld2F5LmVuYWJsZWQ9dHJ1ZWAgfAp8IGBu" + - "YW1lPW52Y2YtdWlgIHwgRGVwbG95IE5WQ0YgVUkgb25seSB3aGVuIHRoZSBzdGFjayBwYWNrYWdl" + - "IGluY2x1ZGVzIHRoYXQgcmVsZWFzZSBhbmQgYGFkZG9ucy5udmNmVWkuZW5hYmxlZD10cnVlYCB8" + - "CnwgYHJlbGVhc2UtZ3JvdXA9aW5ncmVzc2AgfCBpbmdyZXNzIChnYXRld2F5IHJvdXRlcykgfAp8" + - "IGBuYW1lPTxyZWxlYXNlPmAgfCBBbnkgaW5kaXZpZHVhbCByZWxlYXNlIGJ5IG5hbWUgfAoKTm90" + - "ZTogYGFkbWluLWlzc3Vlci1wcm94eWAgZG9lcyBub3QgaGF2ZSBhIHJlbGVhc2UtZ3JvdXAgbGFi" + - "ZWwuIFRhcmdldCBpdCB3aXRoIGAtLXNlbGVjdG9yIG5hbWU9YWRtaW4taXNzdWVyLXByb3h5YC4K" + - "UEsHCAJSTkB/KAAAfygAAFBLAwQUAAgAAAAAACEAAAAAAAAAAAAAAAAATAAJAGRhdGEvbnZjZi1z" + - "ZWxmLW1hbmFnZWQtaW5zdGFsbGF0aW9uL3JlZmVyZW5jZXMvY29tcHV0ZS1wbGFuZS1pbnN0YWxs" + - "YXRpb24ubWRVVAUAAQCmzhIjIFNwbGl0IENvbXB1dGUtUGxhbmUgSW5zdGFsbGF0aW9uCgpUaGUg" + - "Y29udHJvbCBwbGFuZSBhbmQgY29tcHV0ZSBwbGFuZSBhcmUgc2VwYXJhdGUgc3RhY2tzLiBJbnN0" + - "YWxsIHRoZSBjb250cm9sCnBsYW5lIGZpcnN0LCB0aGVuIHJlZ2lzdGVyIGFuZCBpbnN0YWxsIGVh" + - "Y2ggY29tcHV0ZSBjbHVzdGVyLiBDaG9vc2Ugb25lIGhhbmRvZmYKYmVsb3cgYW5kIHVzZSBpdCBm" + - "b3IgdGhlIGZ1bGwgbGlmZWN5Y2xlLiBEbyBub3QgY29tYmluZSBhIENMSS1nZW5lcmF0ZWQgcHJv" + - "ZmlsZQp3aXRoIHRoZSBIZWxtZmlsZSB2YWx1ZXMgZmxvdy4KCiMjIENob29zZSBhIEhhbmRvZmYK" + - "CnwgRmxvdyB8IFNvdXJjZSBvZiBjb250cm9sLXBsYW5lIGVuZHBvaW50cyB8IFJlZ2lzdHJhdGlv" + - "biBhcnRpZmFjdCB8CnwtLS0tLS18LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS18" + - "LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS18CnwgSGVsbWZpbGUgdmFsdWVzIHwgU2VwYXJhdGUgY29u" + - "dHJvbC1wbGFuZSBhbmQgY29tcHV0ZS1wbGFuZSBlbnZpcm9ubWVudCBmaWxlcyB8IGBkZXBsb3kv" + - "c3RhY2tzL252Y2YtY29tcHV0ZS1wbGFuZS9yZWdpc3RyYXRpb24vPGNsdXN0ZXI+LXJlZ2lzdGVy" + - "LXZhbHVlcy55YW1sYCB8CnwgQ0xJIHByb2ZpbGUgfCBDTEktZ2VuZXJhdGVkIGBkZXBsb3kvc3Rh" + - "Y2tzL3NlbGYtbWFuYWdlZC9vdXQvY29udHJvbC1wbGFuZS1wcm9maWxlLnlhbWxgIHwgQ0xJLWdl" + - "bmVyYXRlZCBgZGVwbG95L3N0YWNrcy9udmNmLWNvbXB1dGUtcGxhbmUvb3V0LzxjbHVzdGVyPi1y" + - "ZWdpc3Rlci12YWx1ZXMueWFtbGAgfAoKVGhlIENMSSBwcm9maWxlIGlzIG1hbmRhdG9yeSBmb3Ig" + - "dGhlIENMSSBmbG93IGFuZCBtdXN0IG5vdCBiZSBoYW5kLWF1dGhvcmVkLgpUaGUgSGVsbWZpbGUg" + - "ZmxvdyBkb2VzIG5vdCBjb25zdW1lIGEgY29udHJvbC1wbGFuZSBwcm9maWxlLgoKQ29tbWFuZHMg" + - "YmVsb3cgdXNlIG1vbm9yZXBvIHBhdGhzIGZyb20gdGhlIHJlcG9zaXRvcnkgcm9vdC4gT3BlcmF0" + - "b3JzIHVzaW5nCmV4dHJhY3RlZCBwYWNrYWdlcyBuZWVkIG1hdGNoaW5nLXZlcnNpb24gYG52Y2Yt" + - "c2VsZi1tYW5hZ2VkLXN0YWNrYCBhbmQKYG52Y2YtY29tcHV0ZS1wbGFuZS1zdGFja2AgYnVuZGxl" + - "cy4gU3Vic3RpdHV0ZSB0aG9zZSBidW5kbGUgcm9vdHMgZm9yCmBkZXBsb3kvc3RhY2tzL3NlbGYt" + - "bWFuYWdlZGAgYW5kIGBkZXBsb3kvc3RhY2tzL252Y2YtY29tcHV0ZS1wbGFuZWAuCgojIyBIZWxt" + - "ZmlsZSBWYWx1ZXMgRmxvdwoKQ3JlYXRlIGJvdGggZW52aXJvbm1lbnQgZmlsZXMgYmVmb3JlIGlu" + - "c3RhbGxhdGlvbjoKCi0gYGRlcGxveS9zdGFja3Mvc2VsZi1tYW5hZ2VkL2Vudmlyb25tZW50cy88" + - "ZW52Pi55YW1sYCBmb3IgY29udHJvbC1wbGFuZQogIHJlZ2lzdHJ5LCBkb21haW4sIEdhdGV3YXks" + - "IHJvdXRlcywgYW5kIHNlcnZpY2Ugc2V0dGluZ3MuCi0gYGRlcGxveS9zdGFja3MvbnZjZi1jb21w" + - "dXRlLXBsYW5lL2Vudmlyb25tZW50cy88ZW52Pi55YW1sYCBmb3IgY29tcHV0ZS1wbGFuZQogIHJl" + - "Z2lzdHJ5LCBwdWxsIHNlY3JldHMsIGFuZCBjb21wdXRlLXJlYWNoYWJsZSBJQ01TLCBSZVZhbCwg" + - "YW5kIE5BVFMgdmFsdWVzLgoKRm9yIEVLUywgdXNlIHRoZSBjYW5vbmljYWwKW0NTUCBFbmQtdG8t" + - "RW5kIEV4YW1wbGVdKGh0dHBzOi8vZG9jcy5udmlkaWEuY29tL252Y2YvdjAuNi4wLXJjL2NzcC1l" + - "bmQtdG8tZW5kLWV4YW1wbGUpLgpUaGUgY29udHJvbC1wbGFuZSBlbnZpcm9ubWVudCBrZWVwcyB0" + - "aGUgRW52b3kgR2F0ZXdheSBjb250cm9sbGVyIGluCmBlbnZveS1nYXRld2F5LXN5c3RlbWAsIGF0" + - "dGFjaGVzIHJvdXRlcyB0byBgR2F0ZXdheS9udmNmLWdhdGV3YXlgIGluCmBlbnZveS1nYXRld2F5" + - "YCwgYW5kIGVuYWJsZXMgdGhlIE5BVFMgcm91dGUuIFRoZSBjb21wdXRlLXBsYW5lIGVudmlyb25t" + - "ZW50IHVzZXMKdGhlIGV4dGVybmFsIGFkZHJlc3MgcGx1cyB0aGUgc2VydmljZSBob3N0IG92ZXJy" + - "aWRlcy4gSGVyZSwKYDxnYXRld2F5LWFkZHJlc3M+YCBpcyB0aGUgTkxCIGFkZHJlc3MgYW5kIGA8" + - "Z2F0ZXdheS1kb21haW4+YCBpcyB0aGUgRE5TIGJhc2UKd2hvc2Ugc2VydmljZSBzdWJkb21haW5z" + - "IHJlc29sdmUgdG8gdGhhdCBOTEI6CgpgYGB5YW1sCiMgZGVwbG95L3N0YWNrcy9zZWxmLW1hbmFn" + - "ZWQvZW52aXJvbm1lbnRzLzxlbnY+LnlhbWwKZ2xvYmFsOgogIGRvbWFpbjogIjxnYXRld2F5LWRv" + - "bWFpbj4iCiAgd29ya2VyRW5kcG9pbnRzOgogICAgbnZjZlNlcnZpY2VVUkw6ICJodHRwOi8vYXBp" + - "LjxnYXRld2F5LWRvbWFpbj4iCiAgICBudmNmR3JwY1NlcnZpY2VVUkw6ICJodHRwOi8vd29ya2Vy" + - "LWFwaS48Z2F0ZXdheS1kb21haW4+IgogICAgbnZjZk5hdHNTZXJ2aWNlVVJMOiAibmF0czovLzxn" + - "YXRld2F5LWFkZHJlc3M+OjQyMjIiCiAgICBudmN0U2VydmljZVVSTDogImh0dHA6Ly90YXNrcy48" + - "Z2F0ZXdheS1kb21haW4+IgogICAgbnZjdEdycGNTZXJ2aWNlVVJMOiAiaHR0cDovL3dvcmtlci10" + - "YXNrcy48Z2F0ZXdheS1kb21haW4+IgogICAgaW52b2NhdGlvblNlcnZpY2VVUkw6ICJodHRwOi8v" + - "aW52b2NhdGlvbi48Z2F0ZXdheS1kb21haW4+IgoKZ3JwY3Byb3h5OgogIG52Y2ZHcnBjU2Vydmlj" + - "ZVVSTDogImh0dHA6Ly9hcGkubnZjZi5zdmMuY2x1c3Rlci5sb2NhbDo5MDkwIgoKaW5ncmVzczoK" + - "ICBnYXRld2F5QXBpOgogICAgY29udHJvbGxlck5hbWVzcGFjZTogZW52b3ktZ2F0ZXdheS1zeXN0" + - "ZW0KICAgIGdhdGV3YXlzOgogICAgICBzaGFyZWQ6IHtuYW1lOiBudmNmLWdhdGV3YXksIG5hbWVz" + - "cGFjZTogZW52b3ktZ2F0ZXdheX0KICAgICAgZ3JwYzoge25hbWU6IG52Y2YtZ2F0ZXdheSwgbmFt" + - "ZXNwYWNlOiBlbnZveS1nYXRld2F5fQogICAgICBuYXRzOgogICAgICAgIG5hbWU6IG52Y2YtZ2F0" + - "ZXdheQogICAgICAgIG5hbWVzcGFjZTogZW52b3ktZ2F0ZXdheQogICAgICAgIGxpc3RlbmVyTmFt" + - "ZTogbmF0cwogICAgcm91dGVzOgogICAgICBudmNmQXBpOgogICAgICAgIGdycGM6CiAgICAgICAg" + - "ICBlbmFibGVkOiB0cnVlCiAgICAgICAgICBob3N0bmFtZXM6IFsid29ya2VyLWFwaS48Z2F0ZXdh" + - "eS1kb21haW4+Il0KICAgICAgbnZjdEFwaToKICAgICAgICBncnBjOgogICAgICAgICAgZW5hYmxl" + - "ZDogdHJ1ZQogICAgICAgICAgaG9zdG5hbWVzOiBbIndvcmtlci10YXNrcy48Z2F0ZXdheS1kb21h" + - "aW4+Il0KICAgICAgbmF0czoKICAgICAgICBlbmFibGVkOiB0cnVlCgpvcGVuYmFvOgogIG1pZ3Jh" + - "dGlvbnM6CiAgICBpc3N1ZXJEaXNjb3Zlcnk6CiAgICAgIGVuYWJsZWQ6IHRydWUKYGBgCgpgYGB5" + - "YW1sCiMgZGVwbG95L3N0YWNrcy9udmNmLWNvbXB1dGUtcGxhbmUvZW52aXJvbm1lbnRzLzxlbnY+" + - "LnlhbWwKZ2xvYmFsOgogIG52Y2FPcGVyYXRvcjoKICAgIHNlbGZNYW5hZ2VkOgogICAgICBpY21z" + - "U2VydmljZVVSTDogImh0dHA6Ly88Z2F0ZXdheS1hZGRyZXNzPiIKICAgICAgaWNtc1NlcnZpY2VI" + - "b3N0SGVhZGVyT3ZlcnJpZGU6ICJzaXMuPGdhdGV3YXktZG9tYWluPiIKICAgICAgcmV2YWxTZXJ2" + - "aWNlVVJMOiAiaHR0cDovLzxnYXRld2F5LWFkZHJlc3M+IgogICAgICByZXZhbFNlcnZpY2VIb3N0" + - "SGVhZGVyT3ZlcnJpZGU6ICJyZXZhbC48Z2F0ZXdheS1kb21haW4+IgogICAgICBuYXRzVVJMOiAi" + - "bmF0czovLzxnYXRld2F5LWFkZHJlc3M+OjQyMjIiCiAgICAgIG5hdHNIb3N0T3ZlcnJpZGU6ICJu" + - "YXRzLjxnYXRld2F5LWRvbWFpbj4iCmBgYAoKUHJldmlldyBhbmQgaW5zdGFsbCB0aGUgY29udHJv" + - "bCBwbGFuZSBhZ2FpbnN0IGl0cyBjb250ZXh0OgoKYGBgYmFzaAptYWtlIC1DIGRlcGxveS9zdGFj" + - "a3Mvc2VsZi1tYW5hZ2VkIHRlbXBsYXRlIFwKICBIRUxNRklMRV9FTlY9PGVudj4gXAogIEtVQkVD" + - "T05GSUdfRklMRT08Y29udHJvbC1wbGFuZS1rdWJlY29uZmlnPgoKbWFrZSAtQyBkZXBsb3kvc3Rh" + - "Y2tzL3NlbGYtbWFuYWdlZCBpbnN0YWxsIFwKICBIRUxNRklMRV9FTlY9PGVudj4gXAogIEtVQkVD" + - "T05GSUdfRklMRT08Y29udHJvbC1wbGFuZS1rdWJlY29uZmlnPgpgYGAKCkJlZm9yZSByZWdpc3Rl" + - "cmluZyB0aHJvdWdoIGEgYmFyZSBHYXRld2F5IGFkZHJlc3MsIGNyZWF0ZSBvciB1cGRhdGUgdGhl" + - "IENMSQpjb25maWcgcGFzc2VkIGFzIGBOVkNGX0NMSV9DT05GSUdgOgoKYGBgeWFtbApiYXNlX2h0" + - "dHBfdXJsOiAiaHR0cDovLzxnYXRld2F5LWFkZHJlc3M+IgppbnZva2VfdXJsOiAiaHR0cDovLzxn" + - "YXRld2F5LWFkZHJlc3M+IgpiYXNlX2dycGNfdXJsOiAiPGdhdGV3YXktYWRkcmVzcz46MTAwODEi" + - "CmFwaV9rZXlzX3NlcnZpY2VfdXJsOiAiaHR0cDovLzxnYXRld2F5LWFkZHJlc3M+IgppY21zX3Vy" + - "bDogImh0dHA6Ly88Z2F0ZXdheS1hZGRyZXNzPiIKYXBpX2hvc3Q6ICJhcGkuPGdhdGV3YXktZG9t" + - "YWluPiIKYXBpX2tleXNfaG9zdDogImFwaS1rZXlzLjxnYXRld2F5LWRvbWFpbj4iCmludm9rZV9o" + - "b3N0OiAiaW52b2NhdGlvbi48Z2F0ZXdheS1kb21haW4+IgppY21zX2hvc3Q6ICJzaXMuPGdhdGV3" + - "YXktZG9tYWluPiIKYGBgCgpIb3N0IGZpZWxkcyBjb250YWluIGhvc3RuYW1lcyBvbmx5LCB3aXRo" + - "b3V0IGEgVVJMIHNjaGVtZS4gYElDTVNfVVJMYCBtYXBzIG9ubHkKdG8gdGhlIHJlZ2lzdHJhdGlv" + - "biBjb21tYW5kJ3MgYC0taWNtcy11cmxgOyBgaWNtc19ob3N0YCBpbiB0aGUgY29uZmlnIHN1cHBs" + - "aWVzCnRoZSBHYXRld2F5IEhvc3QgaGVhZGVyLiBUaGVyZSBpcyBubyBgLS1pY21zLWhvc3RgIE1h" + - "a2Ugb3IgQ0xJIGZsYWcuCgpSZWdpc3RlciBmcm9tIHRoZSBjb21wdXRlIGNvbnRleHQsIHRoZW4g" + - "aW5zdGFsbCB0aGUgY29tcHV0ZSBwbGFuZToKCmBgYGJhc2gKbWFrZSAtQyBkZXBsb3kvc3RhY2tz" + - "L252Y2YtY29tcHV0ZS1wbGFuZSByZWdpc3Rlci1jbHVzdGVyIFwKICBDTFVTVEVSX05BTUU9PGNs" + - "dXN0ZXItbmFtZT4gXAogIE5DQV9JRD08bmNhLWlkPiBcCiAgQ0xVU1RFUl9SRUdJT049PHJlZ2lv" + - "bj4gXAogIElDTVNfVVJMPWh0dHA6Ly88Z2F0ZXdheS1hZGRyZXNzPiBcCiAgS1VCRUNPTkZJR19G" + - "SUxFPTxjb21wdXRlLXBsYW5lLWt1YmVjb25maWc+IFwKICBOVkNGX0NMST08cGF0aC10by1udmNm" + - "LWNsaT4gXAogIE5WQ0ZfQ0xJX0NPTkZJRz08cGF0aC10by1udmNmLWNsaS1jb25maWc+CgptYWtl" + - "IC1DIGRlcGxveS9zdGFja3MvbnZjZi1jb21wdXRlLXBsYW5lIGluc3RhbGwgXAogIENMVVNURVJf" + - "TkFNRT08Y2x1c3Rlci1uYW1lPiBcCiAgSEVMTUZJTEVfRU5WPTxlbnY+IFwKICBLVUJFQ09ORklH" + - "X0ZJTEU9PGNvbXB1dGUtcGxhbmUta3ViZWNvbmZpZz4KYGBgCgpSZWdpc3RyYXRpb24gZGlzY292" + - "ZXJzIHRoZSBPSURDIGlzc3VlciBhbmQgSldLUyBmcm9tIHRoZSBjb21wdXRlIGt1YmUgY29udGV4" + - "dC4KSW4gYSBtdWx0aS1jbHVzdGVyIGRlcGxveW1lbnQsIGBLVUJFQ09ORklHX0ZJTEVgIGlzIHJl" + - "cXVpcmVkIG9uIGJvdGgKY29tcHV0ZS1wbGFuZSBjb21tYW5kcy4gSW4gYSBzYW1lLWNsdXN0ZXIg" + - "ZGVwbG95bWVudCBpdCBtYXkgYmUgb21pdHRlZCBvbmx5CndoZW4gdGhlIGFtYmllbnQgY29udGV4" + - "dCBpcyBhbHJlYWR5IHRoZSB0YXJnZXQgY2x1c3Rlci4KCiMjIENMSSBQcm9maWxlIEZsb3cKClJ1" + - "biB0aGUgQ0xJIGNvbnRyb2wtcGxhbmUgaW5zdGFsbCBmaXJzdC4gSXQgY3JlYXRlcyB0aGUgcHJv" + - "ZmlsZSBjb25zdW1lZCBieQpjb21wdXRlLXBsYW5lIHJlZ2lzdHJhdGlvbjoKCmBgYGJhc2gKbnZj" + - "Zi1jbGkgLS1jb25maWcgPGNvbmZpZz4gc2VsZi1ob3N0ZWQgXAogIC0tY29udHJvbC1wbGFuZS1z" + - "dGFjayBkZXBsb3kvc3RhY2tzL3NlbGYtbWFuYWdlZCBcCiAgLS1jb21wdXRlLXBsYW5lLXN0YWNr" + - "IGRlcGxveS9zdGFja3MvbnZjZi1jb21wdXRlLXBsYW5lIFwKICAtLWVudiA8ZW52PiBcCiAgLS1w" + - "bGFpbiBcCiAgLS1jb250cm9sLXBsYW5lLWNvbnRleHQgPGNvbnRyb2wtcGxhbmUtY29udGV4dD4g" + - "XAogIC0tY29tcHV0ZS1wbGFuZS1jb250ZXh0IDxjb21wdXRlLXBsYW5lLWNvbnRleHQ+IFwKICBp" + - "bnN0YWxsIC0tY29udHJvbC1wbGFuZSBcCiAgLS1jbHVzdGVyLW5hbWUgPGNvbnRyb2wtcGxhbmUt" + - "Y2x1c3Rlci1uYW1lPiBcCiAgLS1yZWdpb24gPHJlZ2lvbj4gXAogIC0tbmNhLWlkIDxuY2EtaWQ+" + - "Cgp0ZXN0IC1zIGRlcGxveS9zdGFja3Mvc2VsZi1tYW5hZ2VkL291dC9jb250cm9sLXBsYW5lLXBy" + - "b2ZpbGUueWFtbApgYGAKClVzZSB0aGUgZnVsbCBwZXJzaXN0ZW50IHByZWZpeCBmb3IgYm90aCBj" + - "b21wdXRlLXBsYW5lIGNvbW1hbmRzOgoKYGBgYmFzaApudmNmLWNsaSAtLWNvbmZpZyA8Y29uZmln" + - "PiBzZWxmLWhvc3RlZCBcCiAgLS1jb250cm9sLXBsYW5lLXN0YWNrIGRlcGxveS9zdGFja3Mvc2Vs" + - "Zi1tYW5hZ2VkIFwKICAtLWNvbXB1dGUtcGxhbmUtc3RhY2sgZGVwbG95L3N0YWNrcy9udmNmLWNv" + - "bXB1dGUtcGxhbmUgXAogIC0tZW52IDxlbnY+IFwKICAtLXBsYWluIFwKICBjb21wdXRlLXBsYW5l" + - "IHJlZ2lzdGVyIFwKICAtLWNvbnRyb2wtcGxhbmUtcHJvZmlsZSBkZXBsb3kvc3RhY2tzL3NlbGYt" + - "bWFuYWdlZC9vdXQvY29udHJvbC1wbGFuZS1wcm9maWxlLnlhbWwgXAogIC0tY2x1c3Rlci1uYW1l" + - "IDxjb21wdXRlLXBsYW5lLWNsdXN0ZXItbmFtZT4gXAogIC0ta3ViZS1jb250ZXh0IDxjb21wdXRl" + - "LXBsYW5lLWNvbnRleHQ+IFwKICAtLXJlZ2lvbiA8cmVnaW9uPiBcCiAgLS1vdXRwdXQgZGVwbG95" + - "L3N0YWNrcy9udmNmLWNvbXB1dGUtcGxhbmUvb3V0Lzxjb21wdXRlLXBsYW5lLWNsdXN0ZXItbmFt" + - "ZT4tcmVnaXN0ZXItdmFsdWVzLnlhbWwKCm52Y2YtY2xpIC0tY29uZmlnIDxjb25maWc+IHNlbGYt" + - "aG9zdGVkIFwKICAtLWNvbnRyb2wtcGxhbmUtc3RhY2sgZGVwbG95L3N0YWNrcy9zZWxmLW1hbmFn" + - "ZWQgXAogIC0tY29tcHV0ZS1wbGFuZS1zdGFjayBkZXBsb3kvc3RhY2tzL252Y2YtY29tcHV0ZS1w" + - "bGFuZSBcCiAgLS1lbnYgPGVudj4gXAogIC0tcGxhaW4gXAogIGNvbXB1dGUtcGxhbmUgaW5zdGFs" + - "bCBcCiAgLS12YWx1ZXMgZGVwbG95L3N0YWNrcy9udmNmLWNvbXB1dGUtcGxhbmUvb3V0Lzxjb21w" + - "dXRlLXBsYW5lLWNsdXN0ZXItbmFtZT4tcmVnaXN0ZXItdmFsdWVzLnlhbWwgXAogIC0ta3ViZS1j" + - "b250ZXh0IDxjb21wdXRlLXBsYW5lLWNvbnRleHQ+IFwKICAtLWNsdXN0ZXItbmFtZSA8Y29tcHV0" + - "ZS1wbGFuZS1jbHVzdGVyLW5hbWU+CmBgYAoKUmVnaXN0cmF0aW9uIHNlbGVjdHMgdGhlIHByb2Zp" + - "bGUncyBpbi1jbHVzdGVyIG9yIGNvbXB1dGUtcmVhY2hhYmxlIGVuZHBvaW50cwpmcm9tIHRoZSBj" + - "b21wdXRlIGNvbnRleHQgYW5kIHByb2JlcyBpdHMgSldLUy4gRG8gbm90IHJlcGxhY2UgcHJvZmls" + - "ZSBlbmRwb2ludHMKd2l0aCBoYW5kLWF1dGhvcmVkIEhlbG1maWxlIGVuZHBvaW50IHZhbHVlcy4K" + - "CiMjIFB1bGwgU2VjcmV0cwoKQ3JlYXRlIHRoZSBjb250cm9sLXBsYW5lIHNlY3JldCBpbiB0aGVz" + - "ZSBuYW1lc3BhY2VzIG9uIHRoZSBjb250cm9sLXBsYW5lCmNvbnRleHQ6CgpgYGB0ZXh0CmNhc3Nh" + - "bmRyYS1zeXN0ZW0gbmF0cy1zeXN0ZW0gbnZjZiBhcGkta2V5cyBlc3Mgc2lzIHZhdWx0LXN5c3Rl" + - "bSBjZXJ0LW1hbmFnZXIKYGBgCgpPbiB0aGUgY29tcHV0ZSBjb250ZXh0LCBjcmVhdGUgdGhlIHNl" + - "Y3JldCBvbmx5IGluIGBudmNhLW9wZXJhdG9yYCBhbmQgcmVmZXJlbmNlCml0IHRocm91Z2ggYGds" + - "b2JhbC5pbWFnZVB1bGxTZWNyZXRzYCBpbiB0aGUgY29tcHV0ZS1wbGFuZSBlbnZpcm9ubWVudC4g" + - "VGhlIGNoYXJ0CmFuZCBvcGVyYXRvciB1c2UgaXQgaW4gYG52Y2Etb3BlcmF0b3JgIGFuZCBtaXJy" + - "b3IgaXQgdG8gYG52Y2Etc3lzdGVtYC4gRG8gbm90IGFkZAplaXRoZXIgbmFtZXNwYWNlIHRvIHRo" + - "ZSBjb250cm9sLXBsYW5lIGxpc3QuIEZvciBjb21tYW5kcyBhbmQgcG9saWN5IGV4YW1wbGVzLApz" + - "ZWUgW3B1bGwtc2VjcmV0cy5tZF0ocHVsbC1zZWNyZXRzLm1kKS4KCiMjIFZlcmlmaWNhdGlvbgoK" + - "VXNlIHRoZSBleHBsaWNpdCBHYXRld2F5IG5hbWUgYW5kIG5hbWVzcGFjZToKCmBgYGJhc2gKa3Vi" + - "ZWN0bCAtLWNvbnRleHQgPGNvbnRyb2wtcGxhbmUtY29udGV4dD4gZ2V0IGdhdGV3YXkgbnZjZi1n" + - "YXRld2F5IFwKICAtbiBlbnZveS1nYXRld2F5IC1vIHdpZGUKa3ViZWN0bCAtLWNvbnRleHQgPGNv" + - "bnRyb2wtcGxhbmUtY29udGV4dD4gZ2V0IHRjcHJvdXRlIC1uIGVudm95LWdhdGV3YXkKa3ViZWN0" + - "bCAtLWNvbnRleHQgPGNvbXB1dGUtcGxhbmUtY29udGV4dD4gcm9sbG91dCBzdGF0dXMgXAogIGRl" + - "cGxveW1lbnQvbnZjYS1vcGVyYXRvciAtbiBudmNhLW9wZXJhdG9yIC0tdGltZW91dD0xMG0Ka3Vi" + - "ZWN0bCAtLWNvbnRleHQgPGNvbXB1dGUtcGxhbmUtY29udGV4dD4gd2FpdCBcCiAgbnZjZmJhY2tl" + - "bmQvPGNvbXB1dGUtcGxhbmUtY2x1c3Rlci1uYW1lPiAtbiBudmNhLW9wZXJhdG9yIFwKICAtLWZv" + - "cj1qc29ucGF0aD0ney5zdGF0dXMuYWdlbnRTdGF0dXN9Jz1oZWFsdGh5IC0tdGltZW91dD0xMG0K" + - "a3ViZWN0bCAtLWNvbnRleHQgPGNvbXB1dGUtcGxhbmUtY29udGV4dD4gZ2V0IHNlY3JldCA8cHVs" + - "bC1zZWNyZXQ+IC1uIG52Y2Etc3lzdGVtCmBgYAoKIyMgVGVhcmRvd24KCkRlc3Ryb3kgYW5kIGRl" + - "cmVnaXN0ZXIgZXZlcnkgY29tcHV0ZSBwbGFuZSBiZWZvcmUgdGhlIGNvbnRyb2wgcGxhbmUuIEJv" + - "dGgKaGFuZG9mZnMgY2FuIGRlc3Ryb3kgdGhlIGNvbnRyb2wgcGxhbmUsIHNvIGFwcGx5IHRoaXMg" + - "cHJlZmxpZ2h0IGJlZm9yZSBlaXRoZXIKb25lLiBQcmVzZXJ2ZSB0aGUgYGNlcnQtbWFuYWdlcmAg" + - "bmFtZXNwYWNlIGJ5IGRlZmF1bHQuIE5hbWVzcGFjZSBwcmVzZXJ2YXRpb24KZG9lcyBub3QgcHJl" + - "c2VydmUgdGhlIEhlbG0gcmVsZWFzZS4gSWRlbnRpZnkgd2hldGhlciBjZXJ0LW1hbmFnZXIgaXMg" + - "ZXh0ZXJuYWwuCkZvciBhbiBleHRlcm5hbCBpbnN0YWxsYXRpb24sIHJlcXVpcmUgZWZmZWN0aXZl" + - "IGBjZXJ0TWFuYWdlci5lbmFibGVkOiBmYWxzZWAKYW5kIGFib3J0IGlmIGl0IGlzIHRydWUuIEZv" + - "ciBhbiBpbnRlbmRlZCBzdGFjay1tYW5hZ2VkIHJlbGVhc2Ugd2l0aCBlZmZlY3RpdmUKYGNlcnRN" + - "YW5hZ2VyLmVuYWJsZWQ6IHRydWVgLCB2ZXJpZnkgbWF0Y2hpbmcgc3RhY2sgSGVsbSByZWxlYXNl" + - "IG1ldGFkYXRhIGFuZAphYm9ydCBvbiBtaXNzaW5nIG9yIG1pc21hdGNoZWQgZXZpZGVuY2UuIE9u" + - "bHkgcGxhbiBuYW1lc3BhY2UgcmVtb3ZhbCBhZnRlcgp2ZXJpZnlpbmcgbmFtZXNwYWNlIHByb3Zl" + - "bmFuY2UgYW5kIGdldHRpbmcgZXhwbGljaXQgY29uZmlybWF0aW9uOyBvdGhlcndpc2UKZG8gbm90" + - "IGRlbGV0ZSBpdC4KCkZvciB0aGUgSGVsbWZpbGUgdmFsdWVzIGZsb3csIHJldGFpbiBlYWNoIHJl" + - "Z2lzdHJhdGlvbiB2YWx1ZXMgZmlsZSB1bnRpbApjbGVhbnVwIGlzIHZlcmlmaWVkOgoKYGBgYmFz" + - "aAptYWtlIC1DIGRlcGxveS9zdGFja3MvbnZjZi1jb21wdXRlLXBsYW5lIGRlc3Ryb3kgXAogIENM" + - "VVNURVJfTkFNRT08Y2x1c3Rlci1uYW1lPiBcCiAgSEVMTUZJTEVfRU5WPTxlbnY+IFwKICBLVUJF" + - "Q09ORklHX0ZJTEU9PGNvbXB1dGUtcGxhbmUta3ViZWNvbmZpZz4KCjxudmNmLWNsaT4gLS1jb25m" + - "aWcgPGNvbmZpZz4gY2x1c3RlciBkZWxldGUgXAogIC0tY2x1c3Rlci1pZCA8Y2x1c3Rlci1pZC1m" + - "cm9tLXJlZ2lzdHJhdGlvbi12YWx1ZXM+IFwKICAtLW5jYS1pZCA8bmNhLWlkPiBcCiAgLS1pZ25v" + - "cmUtbWlzc2luZwpgYGAKClJlYWQgYGNsdXN0ZXJJRGAgYW5kIGBuY2FJRGAgZnJvbQpgZGVwbG95" + - "L3N0YWNrcy9udmNmLWNvbXB1dGUtcGxhbmUvcmVnaXN0cmF0aW9uLzxjbHVzdGVyLW5hbWU+LXJl" + - "Z2lzdGVyLXZhbHVlcy55YW1sYC4KU2hvdyB0aGUgZXhhY3QgY2x1c3RlciBJRCBhbmQgZ2V0IGNv" + - "bmZpcm1hdGlvbiBiZWZvcmUgYGNsdXN0ZXIgZGVsZXRlYC4gUmVwZWF0CmNvbXB1dGUgZGVzdHJv" + - "eSBhbmQgZGVyZWdpc3RyYXRpb24gZm9yIGV2ZXJ5IGNvbXB1dGUgY2x1c3RlciwgdGhlbiBkZXN0" + - "cm95IHRoZQpjb250cm9sIHBsYW5lLgoKYGBgYmFzaApLVUJFQ09ORklHPTxjb250cm9sLXBsYW5l" + - "LWt1YmVjb25maWc+IFwKbWFrZSAtQyBkZXBsb3kvc3RhY2tzL3NlbGYtbWFuYWdlZCBkZXN0cm95" + - "IFwKICBIRUxNRklMRV9FTlY9PGVudj4gXAogIEtVQkVDT05GSUdfRklMRT08Y29udHJvbC1wbGFu" + - "ZS1rdWJlY29uZmlnPgpgYGAKCkJvdGggYEtVQkVDT05GSUdgIGFuZCBgS1VCRUNPTkZJR19GSUxF" + - "YCBhcmUgcmVxdWlyZWQgb24gdGhlIGNvbnRyb2wtcGxhbmUKZGVzdHJveSBiZWNhdXNlIGl0cyBu" + - "YW1lc3BhY2UgY2xlYW51cCB1c2VzIGFtYmllbnQgYGt1YmVjdGxgLgoKRm9yIHRoZSBDTEkgcHJv" + - "ZmlsZSBmbG93LCBrZWVwCmBkZXBsb3kvc3RhY2tzL252Y2YtY29tcHV0ZS1wbGFuZS9vdXQvPGNs" + - "dXN0ZXItbmFtZT4tcmVnaXN0ZXItdmFsdWVzLnlhbWxgCnVudGlsIHRlYXJkb3duIGNvbXBsZXRl" + - "cyBiZWNhdXNlIGBkb3duYCByZWFkcyBpdHMgY2x1c3RlciBJRC4gRmlyc3QgcXVlcnkgdGhlCmxp" + - "dmUgcmVnaXN0cmF0aW9uIHNldCB3aXRoIHRoZSBzYW1lIGNvbXBsZXRlIHBlcnNpc3RlbnQgcHJl" + - "Zml4OgoKYGBgYmFzaApudmNmLWNsaSAtLWNvbmZpZyA8Y29uZmlnPiBzZWxmLWhvc3RlZCBcCiAg" + - "LS1jb250cm9sLXBsYW5lLXN0YWNrIGRlcGxveS9zdGFja3Mvc2VsZi1tYW5hZ2VkIFwKICAtLWNv" + - "bXB1dGUtcGxhbmUtc3RhY2sgZGVwbG95L3N0YWNrcy9udmNmLWNvbXB1dGUtcGxhbmUgXAogIC0t" + - "ZW52IDxlbnY+IFwKICAtLXBsYWluIFwKICAtLWNvbnRyb2wtcGxhbmUtY29udGV4dCA8Y29udHJv" + - "bC1wbGFuZS1jb250ZXh0PiBcCiAgLS1jb21wdXRlLXBsYW5lLWNvbnRleHQgPGNvbXB1dGUtcGxh" + - "bmUtY29udGV4dD4gXAogIC0taWNtcy11cmwgPGNvbXB1dGUtcmVhY2hhYmxlLWljbXMtdXJsPiBc" + - "CiAgc3RhdHVzIFwKICAtLWNsdXN0ZXItbmFtZSA8Y29tcHV0ZS1wbGFuZS1jbHVzdGVyLW5hbWU+" + - "IFwKICAtLW5jYS1pZCA8bmNhLWlkPgpgYGAKClNob3cgdGhlIHJlZ2lzdGVyZWQgY29tcHV0ZS1w" + - "bGFuZSBsaXN0LiBOYW1lZC1jbHVzdGVyIGBkb3duIC0tcGxhbi1vbmx5YCBkb2VzCm5vdCBxdWVy" + - "eSBJQ01TLCBzbyBpdCBwcmV2aWV3cyBvbmx5IHRoYXQgY29tcHV0ZSBwbGFuZSBhbmQgY2Fubm90" + - "IHNob3cgdGhlCmNvbmRpdGlvbmFsIGNvbnRyb2wtcGxhbmUgcmVtb3ZhbC4gSWYgdGhlIHRhcmdl" + - "dCBpcyB0aGUgbGFzdCByZWdpc3RlcmVkCmNsdXN0ZXIsIHJlYWwgYGRvd25gIGFsc28gZGVzdHJv" + - "eXMgdGhlIGNvbnRyb2wgcGxhbmUuIEdldCBleHBsaWNpdCBjb25maXJtYXRpb24KZm9yIGJvdGgg" + - "cmVtb3ZhbHMgYmVmb3JlIGNvbnRpbnVpbmcuIFRoZW4gcHJldmlldyBhbmQgZXhlY3V0ZSB3aXRo" + - "IHRoZSBzYW1lCnByZWZpeDoKCmBgYGJhc2gKbnZjZi1jbGkgLS1jb25maWcgPGNvbmZpZz4gc2Vs" + - "Zi1ob3N0ZWQgXAogIC0tY29udHJvbC1wbGFuZS1zdGFjayBkZXBsb3kvc3RhY2tzL3NlbGYtbWFu" + - "YWdlZCBcCiAgLS1jb21wdXRlLXBsYW5lLXN0YWNrIGRlcGxveS9zdGFja3MvbnZjZi1jb21wdXRl" + - "LXBsYW5lIFwKICAtLWVudiA8ZW52PiBcCiAgLS1wbGFpbiBcCiAgLS1jb250cm9sLXBsYW5lLWNv" + - "bnRleHQgPGNvbnRyb2wtcGxhbmUtY29udGV4dD4gXAogIC0tY29tcHV0ZS1wbGFuZS1jb250ZXh0" + - "IDxjb21wdXRlLXBsYW5lLWNvbnRleHQ+IFwKICAtLWljbXMtdXJsIDxjb21wdXRlLXJlYWNoYWJs" + - "ZS1pY21zLXVybD4gXAogIGRvd24gLS1wbGFuLW9ubHkgXAogIC0tY2x1c3Rlci1uYW1lIDxjb21w" + - "dXRlLXBsYW5lLWNsdXN0ZXItbmFtZT4gXAogIC0tbmNhLWlkIDxuY2EtaWQ+CgpudmNmLWNsaSAt" + - "LWNvbmZpZyA8Y29uZmlnPiBzZWxmLWhvc3RlZCBcCiAgLS1jb250cm9sLXBsYW5lLXN0YWNrIGRl" + - "cGxveS9zdGFja3Mvc2VsZi1tYW5hZ2VkIFwKICAtLWNvbXB1dGUtcGxhbmUtc3RhY2sgZGVwbG95" + - "L3N0YWNrcy9udmNmLWNvbXB1dGUtcGxhbmUgXAogIC0tZW52IDxlbnY+IFwKICAtLXBsYWluIFwK" + - "ICAtLWNvbnRyb2wtcGxhbmUtY29udGV4dCA8Y29udHJvbC1wbGFuZS1jb250ZXh0PiBcCiAgLS1j" + - "b21wdXRlLXBsYW5lLWNvbnRleHQgPGNvbXB1dGUtcGxhbmUtY29udGV4dD4gXAogIC0taWNtcy11" + - "cmwgPGNvbXB1dGUtcmVhY2hhYmxlLWljbXMtdXJsPiBcCiAgZG93biBcCiAgLS1jbHVzdGVyLW5h" + - "bWUgPGNvbXB1dGUtcGxhbmUtY2x1c3Rlci1uYW1lPiBcCiAgLS1uY2EtaWQgPG5jYS1pZD4KYGBg" + - "CgpSZXBlYXQgYGRvd25gIGZvciBlYWNoIGNvbXB1dGUgY2x1c3Rlci4gRWFjaCBydW4gZGVzdHJv" + - "eXMgdGhhdCBjb21wdXRlIHBsYW5lIGFuZAp1bnJlZ2lzdGVycyBpdHMgSUNNUyByb3cuIEl0IHJl" + - "bW92ZXMgdGhlIGNvbnRyb2wgcGxhbmUgb25seSBhZnRlciBubyBjbHVzdGVyCnJlZ2lzdHJhdGlv" + - "bnMgcmVtYWluLgpQSwcIlmO8WRIwAAASMAAAUEsDBBQACAAAAAAAIQAAAAAAAAAAAAAAAAA7AAkA" + - "ZGF0YS9udmNmLXNlbGYtbWFuYWdlZC1pbnN0YWxsYXRpb24vcmVmZXJlbmNlcy9kZWJ1Z2dpbmcu" + - "bWRVVAUAAQCmzhIjIERlYnVnZ2luZyBSZWZlcmVuY2UKClJlY2lwZXMgZm9yIGRpYWdub3Npbmcg" + - "YW5kIGZpeGluZyBjb21tb24gTlZDRiBzZWxmLW1hbmFnZWQgc3RhY2sgZmFpbHVyZXMuCgojIyBR" + - "dWljayBTdGF0dXMgQ29tbWFuZHMKCmBgYGJhc2gKIyBBbGwgcG9kcyBhY3Jvc3MgYWxsIG5hbWVz" + - "cGFjZXMKa3ViZWN0bCBnZXQgcG9kcyAtQSAtbyB3aWRlCgojIFBvZHMgaW4gYSBzcGVjaWZpYyBu" + - "YW1lc3BhY2UKa3ViZWN0bCBnZXQgcG9kcyAtbiA8bmFtZXNwYWNlPgoKIyBBbGwgaGVsbSByZWxl" + - "YXNlcwpoZWxtIGxpc3QgLUEKCiMgUmVjZW50IGV2ZW50cyAobW9zdCB1c2VmdWwgZm9yIGRpYWdu" + - "b3NpbmcgZmFpbHVyZXMpCmt1YmVjdGwgZ2V0IGV2ZW50cyAtbiA8bmFtZXNwYWNlPiAtLXNvcnQt" + - "Ynk9Jy5sYXN0VGltZXN0YW1wJwoKIyBEZXNjcmliZSBhIHNwZWNpZmljIHBvZCAoc2hvd3MgZXZl" + - "bnRzLCBjb25kaXRpb25zLCB2b2x1bWVzKQprdWJlY3RsIGRlc2NyaWJlIHBvZCAtbiA8bmFtZXNw" + - "YWNlPiA8cG9kLW5hbWU+CmBgYAoKIyMgRmFpbHVyZTogSW1hZ2VQdWxsQmFja09mZgoKIyMjIFN5" + - "bXB0b21zCgpgYGAKTkFNRSAgICAgICAgICAgUkVBRFkgICBTVEFUVVMgICAgICAgICAgICAgUkVT" + - "VEFSVFMgICBBR0UKY2Fzc2FuZHJhLTAgICAgMC8xICAgICBJbWFnZVB1bGxCYWNrT2ZmICAgMCAg" + - "ICAgICAgICA1bQpgYGAKCkV2ZW50cyBzaG93OgpgYGAKRmFpbGVkIHRvIHB1bGwgaW1hZ2UgIm52" + - "Y3IuaW8vLi4uL2ltYWdlOnRhZyI6IDQwMSBVbmF1dGhvcml6ZWQKYGBgCgojIyMgRGlhZ25vc2lz" + - "CgpgYGBiYXNoCiMgQ2hlY2sgd2hhdCBpbWFnZSBpcyBmYWlsaW5nCmt1YmVjdGwgZGVzY3JpYmUg" + - "cG9kIC1uIDxuYW1lc3BhY2U+IDxwb2QtbmFtZT4gfCBncmVwIC1BNSAiRXZlbnRzOiIKCiMgQ2hl" + - "Y2sgaWYgcHVsbCBzZWNyZXQgZXhpc3RzIGluIHRoZSBuYW1lc3BhY2UKa3ViZWN0bCBnZXQgc2Vj" + - "cmV0IG52Y3ItY3JlZHMgLW4gPG5hbWVzcGFjZT4KCiMgQ2hlY2sgaWYgdGhlIHBvZCBzcGVjIGhh" + - "cyBpbWFnZVB1bGxTZWNyZXRzCmt1YmVjdGwgZ2V0IHBvZCAtbiA8bmFtZXNwYWNlPiA8cG9kLW5h" + - "bWU+IC1vIGpzb25wYXRoPSd7LnNwZWMuaW1hZ2VQdWxsU2VjcmV0c30nCgojIENoZWNrIGlmIHRo" + - "ZSBTZXJ2aWNlQWNjb3VudCBoYXMgaW1hZ2VQdWxsU2VjcmV0cwprdWJlY3RsIGdldCBzYSA8c2Et" + - "bmFtZT4gLW4gPG5hbWVzcGFjZT4gLW8ganNvbnBhdGg9J3suaW1hZ2VQdWxsU2VjcmV0c30nCmBg" + - "YAoKIyMjIEZpeGVzCgoxLiAqKlNlY3JldCBtaXNzaW5nIGluIG5hbWVzcGFjZSoqOiBDcmVhdGUg" + - "aXQKICAgYGBgYmFzaAogICBrdWJlY3RsIGNyZWF0ZSBzZWNyZXQgZG9ja2VyLXJlZ2lzdHJ5IG52" + - "Y3ItY3JlZHMgXAogICAgIC0tZG9ja2VyLXNlcnZlcj1udmNyLmlvIFwKICAgICAtLWRvY2tlci11" + - "c2VybmFtZT0nJG9hdXRodG9rZW4nIFwKICAgICAtLWRvY2tlci1wYXNzd29yZD0iJE5HQ19BUElf" + - "S0VZIiBcCiAgICAgLS1uYW1lc3BhY2U9PG5hbWVzcGFjZT4gXAogICAgIC0tZHJ5LXJ1bj1jbGll" + - "bnQgLW8geWFtbCB8IGt1YmVjdGwgYXBwbHkgLWYgLQogICBgYGAKCjIuICoqU2VjcmV0IGV4aXN0" + - "cyBidXQgcG9kIGRvZXNuJ3QgcmVmZXJlbmNlIGl0Kio6IFRoZSBjaGFydCBuZWVkcyBgaW1hZ2VQ" + - "dWxsU2VjcmV0c2AgY29uZmlndXJlZCB2aWEgaGVsbWZpbGUgdmFsdWVzLiBTZWUgW3B1bGwtc2Vj" + - "cmV0cy5tZF0ocHVsbC1zZWNyZXRzLm1kKS4KCjMuICoqQ2hhcnQgZG9lc24ndCBzdXBwb3J0IGlt" + - "YWdlUHVsbFNlY3JldHMqKiAob3BlbmJhbywgaW52b2NhdGlvbi1zZXJ2aWNlLCBlc3MtYXBpLCBu" + - "b3Rhcnktc2VydmljZSk6IFBhdGNoIFNlcnZpY2VBY2NvdW50cyBhbmQgcmVzdGFydCBwb2RzLiBT" + - "ZWUgW3B1bGwtc2VjcmV0cy5tZF0ocHVsbC1zZWNyZXRzLm1kKS4KCjQuICoqV3JvbmcgY3JlZGVu" + - "dGlhbHMgaW4gc2VjcmV0Kio6IERlbGV0ZSBhbmQgcmVjcmVhdGUKICAgYGBgYmFzaAogICBrdWJl" + - "Y3RsIGRlbGV0ZSBzZWNyZXQgbnZjci1jcmVkcyAtbiA8bmFtZXNwYWNlPgogICAjIFJlY3JlYXRl" + - "IHdpdGggY29ycmVjdCBjcmVkZW50aWFscwogICBgYGAKCiMjIEZhaWx1cmU6IEluaXQ6MC8xIFN0" + - "dWNrIChWYXVsdCBBZ2VudCkKCiMjIyBTeW1wdG9tcwoKU2VydmljZSBwb2RzIHN0dWNrIGluIGBJ" + - "bml0OjAvMWAgZm9yIG1pbnV0ZXM6CmBgYApOQU1FICAgICAgICAgICAgICAgICAgICAgICAgUkVB" + - "RFkgICBTVEFUVVMgICAgIFJFU1RBUlRTICAgQUdFCm52Y2YtYXBpLTdmNGM3NmY3ODgtNDR2bHQg" + - "IDAvMiAgICAgSW5pdDowLzEgICAwICAgICAgICAgIDEwbQpgYGAKCiMjIyBEaWFnbm9zaXMKClRo" + - "ZSBpbml0IGNvbnRhaW5lciBpcyB0aGUgdmF1bHQtYWdlbnQtaW5pdCBpbmplY3RvciB3YWl0aW5n" + - "IGZvciBPcGVuQmFvLgoKYGBgYmFzaAojIENoZWNrIE9wZW5CYW8gcG9kcwprdWJlY3RsIGdldCBw" + - "b2RzIC1uIHZhdWx0LXN5c3RlbQoKIyBDaGVjayBpZiBPcGVuQmFvIG1pZ3JhdGlvbiBqb2IgcmFu" + - "Cmt1YmVjdGwgZ2V0IGpvYnMgLW4gdmF1bHQtc3lzdGVtCgojIENoZWNrIE9wZW5CYW8gcG9kIGxv" + - "Z3MKa3ViZWN0bCBsb2dzIC1uIHZhdWx0LXN5c3RlbSBvcGVuYmFvLXNlcnZlci0wIC1jIG9wZW5i" + - "YW8KCiMgQ2hlY2sgaW5pdCBjb250YWluZXIgbG9ncyBvbiB0aGUgc3R1Y2sgcG9kCmt1YmVjdGwg" + - "bG9ncyAtbiA8bmFtZXNwYWNlPiA8cG9kLW5hbWU+IC1jIHZhdWx0LWFnZW50LWluaXQKYGBgCgoj" + - "IyMgRml4ZXMKCjEuICoqT3BlbkJhbyBwb2RzIG5vdCBydW5uaW5nKio6IENoZWNrIHRoZWlyIGV2" + - "ZW50cyBmb3IgaW1hZ2UgcHVsbCBpc3N1ZXMsIHJlc291cmNlIGlzc3VlcywgZXRjLgoKMi4gKipP" + - "cGVuQmFvIG1pZ3JhdGlvbiBqb2IgZGlkbid0IHJ1bioqOiBUaGlzIGhhcHBlbnMgd2hlbiBgaGVs" + - "bWZpbGUgc3luY2Agd2FzIGludGVycnVwdGVkLiBEZXN0cm95IGFuZCByZS1zeW5jIG9wZW5iYW86" + - "CiAgIGBgYGJhc2gKICAgSEVMTUZJTEVfRU5WPTxlbnY+IGhlbG1maWxlIC0tc2VsZWN0b3IgbmFt" + - "ZT1vcGVuYmFvLXNlcnZlciBkZXN0cm95CiAgIGt1YmVjdGwgZGVsZXRlIG5hbWVzcGFjZSB2YXVs" + - "dC1zeXN0ZW0KICAga3ViZWN0bCBjcmVhdGUgbmFtZXNwYWNlIHZhdWx0LXN5c3RlbQogICAjIFJl" + - "LWNyZWF0ZSBwdWxsIHNlY3JldCBpZiBuZWVkZWQKICAgSEVMTUZJTEVfRU5WPTxlbnY+IGhlbG1m" + - "aWxlIC0tc2VsZWN0b3IgbmFtZT1vcGVuYmFvLXNlcnZlciBzeW5jCiAgIGBgYAoKMy4gKipPcGVu" + - "QmFvIHBvZHMgcnVubmluZyBidXQgbm90IGluaXRpYWxpemVkKio6IENoZWNrIHVuc2VhbCBzdGF0" + - "dXM6CiAgIGBgYGJhc2gKICAga3ViZWN0bCBleGVjIC1uIHZhdWx0LXN5c3RlbSBvcGVuYmFvLXNl" + - "cnZlci0wIC1jIG9wZW5iYW8gLS0gYmFvIHN0YXR1cwogICBgYGAKCjQuICoqYHZhdWx0LWFnZW50" + - "LWluaXRgIGxvZ3MgYGF1dGgvand0L2xvZ2luYCAtPiBgNDAwIC4uLiBubyBrbm93biBrZXkgc3Vj" + - "Y2Vzc2Z1bGx5IHZhbGlkYXRlZCB0aGUgdG9rZW4gc2lnbmF0dXJlYCoqCiAgIChjb21tb24gb24g" + - "QUtTLCBhbmQgb24gYW55IGNsdXN0ZXIgd2hvc2UgT0lEQyBpc3N1ZXIgcHVibGlzaGVzIGEgcm90" + - "YXRpbmcgbXVsdGkta2V5IEpXS1MpOgogICB0aGUgT3BlbkJhbyBgYXV0aC9qd3RgIG1ldGhvZCB3" + - "YXMgY29uZmlndXJlZCB3aXRoIGEgc2luZ2xlIHN0YXRpYyBtb3VudGVkIHB1YmxpYyBrZXkKICAg" + - "KGBqd3RfdmFsaWRhdGlvbl9wdWJrZXlzYCkgaW5zdGVhZCBvZiB0aGUgaXNzdWVyJ3MgbGl2ZSBK" + - "V0tTLCBzbyBpdCBjYW5ub3QgdmFsaWRhdGUgdGhlCiAgIGNsdXN0ZXItc2lnbmVkIFNlcnZpY2VB" + - "Y2NvdW50IHRva2VucyB0aGUgdmF1bHQtYWdlbnRzIHByZXNlbnQuIEV2ZXJ5IHNlcnZpY2Uncwog" + - "ICBgdmF1bHQtYWdlbnQtaW5pdGAgdGhlbiBsb29wcyBvbiB0aGF0IDQwMCBhbmQgdGhlIHBvZCBu" + - "ZXZlciBsZWF2ZXMgYEluaXQ6MC8xYC4gVGhpcyBpcyB0aGUKICAgYmVoYXZpb3Igb2YgdGhlIGJh" + - "c2UgZGVmYXVsdCBgb3BlbmJhby5taWdyYXRpb25zLmlzc3VlckRpc2NvdmVyeS5lbmFibGVkOiBm" + - "YWxzZWA7IHRoZQogICBtaWdyYXRpb24gbG9nIHNob3dzIGBPSURDIGlzc3VlciBkaXNjb3Zlcnkg" + - "aXMgZGlzYWJsZWQuIFVzaW5nIFNlcnZpY2VBY2NvdW50IGlzc3VlciBhbmQKICAgbW91bnRlZCBw" + - "dWJsaWMga2V5IGZhbGxiYWNrYC4gRW5hYmxlIGlzc3VlciBkaXNjb3Zlcnkgc28gdGhlIG1pZ3Jh" + - "dGlvbiB1c2VzIHRoZSBsaXZlIEpXS1MsCiAgIHRoZW4gcmUtcnVuIGl0OgogICBgYGBiYXNoCiAg" + - "ICMgSW4geW91ciBlbnYgdmFsdWVzIChlLmcuIGVudmlyb25tZW50cy88ZW52Pi55YW1sKSwgc2V0" + - "OgogICAjICAgb3BlbmJhbzoKICAgIyAgICAgbWlncmF0aW9uczoKICAgIyAgICAgICBpc3N1ZXJE" + - "aXNjb3Zlcnk6CiAgICMgICAgICAgICBlbmFibGVkOiB0cnVlCiAgIGt1YmVjdGwgZGVsZXRlIGpv" + - "YiAtbiB2YXVsdC1zeXN0ZW0gb3BlbmJhby1zZXJ2ZXItbWlncmF0aW9ucwogICBIRUxNRklMRV9F" + - "TlY9PGVudj4gaGVsbWZpbGUgLS1zZWxlY3RvciBuYW1lPW9wZW5iYW8tc2VydmVyIHN5bmMKICAg" + - "YGBgCiAgIFRoZSBtaWdyYXRpb24gbG9nIHNob3VsZCB0aGVuIHNob3cgYFJlY2VpdmVkIGRpc2Nv" + - "dmVyeSBkb2N1bWVudCBmcm9tCiAgIC4uLi8ud2VsbC1rbm93bi9vcGVuaWQtY29uZmlndXJhdGlv" + - "bmAgYW5kIGBGaW5hbCBPcGVuQmFvIEpXVCBKV0tTIFVSTCBzZXQgdG86CiAgIC4uLi9vcGVuaWQv" + - "djEvandrc2AsIGFuZCB0aGUgc2VydmljZSBwb2RzIGF1dGhlbnRpY2F0ZSBhbmQgcmVhY2ggUmVh" + - "ZHkgd2l0aGluIH4xIG1pbi4KICAgQUtTIGNsdXN0ZXJzIHdpdGggdGhlIGNsdXN0ZXIgT0lEQyBp" + - "c3N1ZXIgZW5hYmxlZCAodGhlIGBha3MtY2x1c3RlcmAgZGVmYXVsdCkgYWx3YXlzIG5lZWQKICAg" + - "dGhpcyBiZWNhdXNlIHRoZSBzdGF0aWMtcHVia2V5IGZhbGxiYWNrIGNhbm5vdCBtYXRjaCB0aGUg" + - "aXNzdWVyJ3Mgcm90YXRpbmcgc2lnbmluZyBrZXlzLgoKIyMgRmFpbHVyZTogT09NS2lsbGVkIG9u" + - "IENhc3NhbmRyYQoKIyMjIFN5bXB0b21zCgpgYGAKTkFNRSAgICAgICAgICBSRUFEWSAgIFNUQVRV" + - "UyAgICBSRVNUQVJUUyAgIEFHRQpjYXNzYW5kcmEtMCAgIDAvMSAgICAgT09NS2lsbGVkICAzICAg" + - "ICAgICAgMTBtCmBgYAoKIyMjIERpYWdub3NpcwoKYGBgYmFzaAprdWJlY3RsIGRlc2NyaWJlIHBv" + - "ZCAtbiBjYXNzYW5kcmEtc3lzdGVtIGNhc3NhbmRyYS0wIHwgZ3JlcCAtQTMgIkxhc3QgU3RhdGUi" + - "CmBgYAoKIyMjIEZpeAoKT3ZlcnJpZGUgQ2Fzc2FuZHJhIHJlc291cmNlcyB2aWEgaGVsbWZpbGUg" + - "dmFsdWVzLiBTZWUgRXhhbXBsZSAxIGluCltleGFtcGxlcy5tZF0oLi4vZXhhbXBsZXMubWQpLgoK" + - "YGBgeWFtbAotIGNhc3NhbmRyYToKICAgIHJlc291cmNlczoKICAgICAgbGltaXRzOgogICAgICAg" + - "IGNwdTogIjgiCiAgICAgICAgbWVtb3J5OiA4MTkyTWkKICAgICAgcmVxdWVzdHM6CiAgICAgICAg" + - "Y3B1OiAiMiIKICAgICAgICBtZW1vcnk6IDQwOTZNaQpgYGAKCk5vdGU6IGByZXNvdXJjZVByZXNl" + - "dGAgaXMgbm90IGF2YWlsYWJsZSBpbiB0aGUgTlZDRiBjYXNzYW5kcmEgd3JhcHBlciBjaGFydC4g" + - "VXNlIGV4cGxpY2l0IGByZXNvdXJjZXNgLgoKIyMgRmFpbHVyZTogUG9kcyBTdHVjayBpbiBQZW5k" + - "aW5nCgojIyMgU3ltcHRvbXMKCmBgYApOQU1FICAgICAgICAgIFJFQURZICAgU1RBVFVTICAgIFJF" + - "U1RBUlRTICAgQUdFCmNhc3NhbmRyYS0wICAgMC8xICAgICBQZW5kaW5nICAgMCAgICAgICAgICAx" + - "MG0KYGBgCgojIyMgRGlhZ25vc2lzCgpgYGBiYXNoCiMgQ2hlY2sgZXZlbnRzIGZvciBzY2hlZHVs" + - "aW5nIGZhaWx1cmVzCmt1YmVjdGwgZGVzY3JpYmUgcG9kIC1uIDxuYW1lc3BhY2U+IDxwb2QtbmFt" + - "ZT4KCiMgQ29tbW9uIGNhdXNlczoKIyAtICIwLzEyIG5vZGVzIGFyZSBhdmFpbGFibGU6IDEyIG5v" + - "ZGUocykgZGlkbid0IG1hdGNoIFBvZCdzIG5vZGUgYWZmaW5pdHkiCiMgLSAiMC8xMiBub2RlcyBh" + - "cmUgYXZhaWxhYmxlOiAxMiBJbnN1ZmZpY2llbnQgbWVtb3J5IgojIC0gInBlcnNpc3RlbnR2b2x1" + - "bWVjbGFpbSBub3QgZm91bmQiCmBgYAoKIyMjIEZpeGVzCgoxLiAqKk5vZGUgc2VsZWN0b3IgbWlz" + - "bWF0Y2gqKjogQ2hlY2sgYG5vZGVTZWxlY3RvcnNgIGluIGVudmlyb25tZW50IGZpbGUKICAgYGBg" + - "YmFzaAogICBrdWJlY3RsIGdldCBub2RlcyAtLXNob3ctbGFiZWxzIHwgZ3JlcCBudmNmCiAgIGBg" + - "YAoKMi4gKipTdG9yYWdlIGNsYXNzIG5vdCBmb3VuZCoqOiBDaGVjayBzdG9yYWdlIGNsYXNzIGV4" + - "aXN0cwogICBgYGBiYXNoCiAgIGt1YmVjdGwgZ2V0IHN0b3JhZ2VjbGFzcwogICBgYGAKCjMuICoq" + - "SW5zdWZmaWNpZW50IHJlc291cmNlcyoqOiBDaGVjayBub2RlIGNhcGFjaXR5CiAgIGBgYGJhc2gK" + - "ICAga3ViZWN0bCBkZXNjcmliZSBub2RlIDxub2RlLW5hbWU+IHwgZ3JlcCAtQTUgIkFsbG9jYXRl" + - "ZCByZXNvdXJjZXMiCiAgIGBgYAoKIyMgRmFpbHVyZTogSGVsbSBSZWxlYXNlIGluIEZhaWxlZCBT" + - "dGF0ZQoKIyMjIFN5bXB0b21zCgpgYGBiYXNoCmhlbG0gbGlzdCAtQQojIFNob3dzIHJlbGVhc2Ug" + - "d2l0aCBTVEFUVVM6IGZhaWxlZApgYGAKClJlLXJ1bm5pbmcgYGhlbG1maWxlIHN5bmNgIGFwcGVh" + - "cnMgdG8gc3VjY2VlZCBidXQgc2VydmljZXMgZG9uJ3Qgd29yayAobWlncmF0aW9ucyBza2lwcGVk" + - "KS4KCiMjIyBEaWFnbm9zaXMKCmBgYGJhc2gKaGVsbSBoaXN0b3J5IDxyZWxlYXNlLW5hbWU+IC1u" + - "IDxuYW1lc3BhY2U+CmBgYAoKIyMjIEZpeAoKTXVzdCBkZXN0cm95IHRoZSBmYWlsZWQgcmVsZWFz" + - "ZSBhbmQgcmUtc3luYyAobm90IGp1c3QgYXBwbHkpOgoKYGBgYmFzaApIRUxNRklMRV9FTlY9PGVu" + - "dj4gaGVsbWZpbGUgLS1zZWxlY3RvciBuYW1lPTxyZWxlYXNlPiBkZXN0cm95CiMgSWYgbmFtZXNw" + - "YWNlIG5lZWRzIGNsZWFudXA6Cmt1YmVjdGwgZGVsZXRlIG5hbWVzcGFjZSA8bmFtZXNwYWNlPgpr" + - "dWJlY3RsIGNyZWF0ZSBuYW1lc3BhY2UgPG5hbWVzcGFjZT4KIyBSZS1jcmVhdGUgcHVsbCBzZWNy" + - "ZXQgaWYgbmVlZGVkCkhFTE1GSUxFX0VOVj08ZW52PiBoZWxtZmlsZSAtLXNlbGVjdG9yIG5hbWU9" + - "PHJlbGVhc2U+IHN5bmMKYGBgCgojIyBGYWlsdXJlOiBBY2NvdW50IEJvb3RzdHJhcCBKb2IgRmFp" + - "bGVkCgojIyMgU3ltcHRvbXMKClNlcnZpY2VzIGRlcGxveSBidXQgZnVuY3Rpb25zIGNhbid0IGJl" + - "IGNyZWF0ZWQuIEV2ZW50cyBzaG93IGJvb3RzdHJhcCBqb2IgZmFpbHVyZS4KCiMjIyBEaWFnbm9z" + - "aXMKCmBgYGJhc2gKIyBDaGVjayBib290c3RyYXAgam9iIHN0YXR1cwprdWJlY3RsIGdldCBqb2Jz" + - "IC1uIG52Y2YKCiMgR2V0IGxvZ3MgKGpvYiBhdXRvLWRlbGV0ZXMgYWZ0ZXIgfjUgbWludXRlcykK" + - "a3ViZWN0bCBsb2dzIGpvYi9udmNmLWFwaS1hY2NvdW50LWJvb3RzdHJhcCAtbiBudmNmCgojIENo" + - "ZWNrIEFQSSBsb2dzCmt1YmVjdGwgbG9ncyAtbiBudmNmIC1sIGFwcC5rdWJlcm5ldGVzLmlvL25h" + - "bWU9bnZjZi1hcGkgLS10YWlsPTEwMApgYGAKCiMjIyBDb21tb24gQ2F1c2VzCgoxLiAqKldyb25n" + - "IGJhc2U2NCBjcmVkZW50aWFscyoqOiBDcmVkZW50aWFscyBpbiBgc2VjcmV0cy88ZW52Pi1zZWNy" + - "ZXRzLnlhbWxgIG11c3QgYmUgYCRvYXV0aHRva2VuOkFQSV9LRVlgIGJhc2U2NC1lbmNvZGVkLCBu" + - "b3QganVzdCB0aGUgQVBJIGtleQogICBgYGBiYXNoCiAgICMgVmVyaWZ5IHlvdXIgZW5jb2RlZCBj" + - "cmVkZW50aWFsCiAgIGVjaG8gJ1lPVVJfQkFTRTY0X1NUUklORycgfCBiYXNlNjQgLWQKICAgIyBT" + - "aG91bGQgb3V0cHV0OiAkb2F1dGh0b2tlbjpudmFwaS14eHh4eAogICBgYGAKCjIuICoqUmVnaXN0" + - "cnkgdW5yZWFjaGFibGUqKjogQVBJIGNhbid0IHJlYWNoIHRoZSByZWdpc3RyeSBzcGVjaWZpZWQg" + - "aW4gYGFjY291bnRCb290c3RyYXAucmVnaXN0cnlDcmVkZW50aWFsc2AKCiMjIyBGaXgKCkZpeCBj" + - "cmVkZW50aWFscyBpbiBzZWNyZXRzIGZpbGUsIHRoZW4gcmVjb3ZlciBzZXJ2aWNlcyB3aXRob3V0" + - "IGRlc3Ryb3lpbmcgZGVwZW5kZW5jaWVzOgoKYGBgYmFzaApIRUxNRklMRV9FTlY9PGVudj4gaGVs" + - "bWZpbGUgLS1zZWxlY3RvciByZWxlYXNlLWdyb3VwPXNlcnZpY2VzIGRlc3Ryb3kKa3ViZWN0bCBk" + - "ZWxldGUgbmFtZXNwYWNlIG52Y2YgYXBpLWtleXMgZXNzIHNpcyAtLWlnbm9yZS1ub3QtZm91bmQK" + - "a3ViZWN0bCBjcmVhdGUgbmFtZXNwYWNlIG52Y2YgJiYga3ViZWN0bCBjcmVhdGUgbmFtZXNwYWNl" + - "IGFwaS1rZXlzICYmIFwKICBrdWJlY3RsIGNyZWF0ZSBuYW1lc3BhY2UgZXNzICYmIGt1YmVjdGwg" + - "Y3JlYXRlIG5hbWVzcGFjZSBzaXMKIyBSZS1jcmVhdGUgcHVsbCBzZWNyZXRzIGlmIG5lZWRlZApI" + - "RUxNRklMRV9FTlY9PGVudj4gaGVsbWZpbGUgLS1zZWxlY3RvciByZWxlYXNlLWdyb3VwPXNlcnZp" + - "Y2VzIHN5bmMKYGBgCgojIyBGYWlsdXJlOiBOVkNBIENsZWFudXAgU3R1Y2sgKEZpbmFsaXplcnMp" + - "CgojIyMgU3ltcHRvbXMKCkNvbXB1dGUtcGxhbmUgY2xlYW51cCBoYW5ncy4gTmFtZXNwYWNlcwpz" + - "dHVjayBpbiBgVGVybWluYXRpbmdgOgoKYGBgYmFzaAprdWJlY3RsIGdldCBucwojIG52Y2Etb3Bl" + - "cmF0b3IgICAgVGVybWluYXRpbmcgICAxMG0KIyBudmNmLWJhY2tlbmQgICAgIFRlcm1pbmF0aW5n" + - "ICAgMTBtCmBgYAoKIyMjIEZpeAoKUnVuIHRoaXMgb25seSBhZ2FpbnN0IHRoZSBjb21wdXRlIGNv" + - "bnRleHQsIGFmdGVyIHRoZSBub3JtYWwgY29tcHV0ZS1wbGFuZQp0ZWFyZG93biBoYXMgZmFpbGVk" + - "LiBSZW1vdmUgZmluYWxpemVycyBmcm9tIE5WQ0ZCYWNrZW5kIGN1c3RvbSByZXNvdXJjZXMgYW5k" + - "CmZvcmNlLWRlbGV0ZSBzdHVjayBuYW1lc3BhY2VzOgoKYGBgYmFzaApleHBvcnQgQ09NUFVURV9D" + - "T05URVhUPTxjb21wdXRlLXBsYW5lLWNvbnRleHQ+CgojIFJlbW92ZSBmaW5hbGl6ZXJzIGZyb20g" + - "TlZDRkJhY2tlbmQgcmVzb3VyY2VzCmt1YmVjdGwgLS1jb250ZXh0ICIkQ09NUFVURV9DT05URVhU" + - "IiBnZXQgbnZjZmJhY2tlbmRzIC1BIC1vIGpzb24gfCBcCiAganEgJy5pdGVtc1tdIHwgLm1ldGFk" + - "YXRhLm5hbWVzcGFjZSArICIvIiArIC5tZXRhZGF0YS5uYW1lJyAtciB8IFwKICB4YXJncyAtSXt9" + - "IHNoIC1jICdjb250ZXh0PSIkMSI7IG5zPSIkezIlJS8qfSI7IG5hbWU9IiR7MiMjKi99Ijsga3Vi" + - "ZWN0bCAtLWNvbnRleHQgIiRjb250ZXh0IiBwYXRjaCBudmNmYmFja2VuZCAiJG5hbWUiIC1uICIk" + - "bnMiIC0tdHlwZT1tZXJnZSAtcCAie1wibWV0YWRhdGFcIjp7XCJmaW5hbGl6ZXJzXCI6W119fSIn" + - "IF8gIiRDT01QVVRFX0NPTlRFWFQiIHt9CgojIEZvcmNlLWRlbGV0ZSBzdHVjayBuYW1lc3BhY2Vz" + - "IGJ5IGNsZWFyaW5nIHRoZWlyIGZpbmFsaXplcnMKZm9yIG5zIGluIG52Y2Etb3BlcmF0b3IgbnZj" + - "Zi1iYWNrZW5kOyBkbwogIGt1YmVjdGwgLS1jb250ZXh0ICIkQ09NUFVURV9DT05URVhUIiBnZXQg" + - "bmFtZXNwYWNlICIkbnMiIC1vIGpzb24gMj4vZGV2L251bGwgfCBcCiAgICBqcSAnLnNwZWMuZmlu" + - "YWxpemVycyA9IFtdJyB8IFwKICAgIGt1YmVjdGwgLS1jb250ZXh0ICIkQ09NUFVURV9DT05URVhU" + - "IiByZXBsYWNlIFwKICAgICAgLS1yYXcgIi9hcGkvdjEvbmFtZXNwYWNlcy8kbnMvZmluYWxpemUi" + - "IC1mIC0gMj4vZGV2L251bGwKZG9uZQpgYGAKCiMjIEZhaWx1cmU6IE5WQ0EgT3BlcmF0b3IgTWlz" + - "c2luZyBvciBOb3QgUmVhZHkKCiMjIyBTeW1wdG9tcwoKQWZ0ZXIgY29tcHV0ZS1wbGFuZSBpbnN0" + - "YWxsIGNvbXBsZXRlcywgbm8gYG52Y2Etb3BlcmF0b3JgIERlcGxveW1lbnQgZXhpc3RzLCBvcgpp" + - "dCBleGlzdHMgYnV0IHBvZHMgYXJlIG5vdCByZWFkeToKCmBgYGJhc2gKa3ViZWN0bCAtLWNvbnRl" + - "eHQgPGNvbXB1dGUtcGxhbmUtY29udGV4dD4gZ2V0IGRlcGxveW1lbnQgbnZjYS1vcGVyYXRvciBc" + - "CiAgLW4gbnZjYS1vcGVyYXRvcgprdWJlY3RsIC0tY29udGV4dCA8Y29tcHV0ZS1wbGFuZS1jb250" + - "ZXh0PiBnZXQgcG9kcyAtbiBudmNhLW9wZXJhdG9yCmBgYAoKIyMjIERpYWdub3NpcyBhbmQgRml4" + - "ZXMKCkZpcnN0IGlkZW50aWZ5IHdoZXRoZXIgdGhlIGluc3RhbGxhdGlvbiB1c2VkIHRoZSBIZWxt" + - "ZmlsZSB2YWx1ZXMgZmxvdyBvciB0aGUKQ0xJIHByb2ZpbGUgZmxvdy4gUmUtcnVuIG9ubHkgdGhh" + - "dCBmbG93J3MgcmVnaXN0cmF0aW9uIGFuZCBpbnN0YWxsYXRpb24gc3RlcHMKZnJvbSBbU3BsaXQg" + - "Q29tcHV0ZS1QbGFuZSBJbnN0YWxsYXRpb25dKGNvbXB1dGUtcGxhbmUtaW5zdGFsbGF0aW9uLm1k" + - "KS4gRG8gbm90CnN1YnN0aXR1dGUgb25lIGhhbmRvZmYgZm9yIHRoZSBvdGhlci4KCklmIGluc3Rh" + - "bGxhdGlvbiBzdWNjZWVkcyBidXQgcG9kcyBzdGlsbCBmYWlsLCBpbnNwZWN0IHRoZSBjb21wdXRl" + - "IGNvbnRleHQ6CgpgYGBiYXNoCmt1YmVjdGwgLS1jb250ZXh0IDxjb21wdXRlLXBsYW5lLWNvbnRl" + - "eHQ+IGRlc2NyaWJlIGRlcGxveSBudmNhLW9wZXJhdG9yIFwKICAtbiBudmNhLW9wZXJhdG9yCmt1" + - "YmVjdGwgLS1jb250ZXh0IDxjb21wdXRlLXBsYW5lLWNvbnRleHQ+IGxvZ3MgZGVwbG95bWVudC9u" + - "dmNhLW9wZXJhdG9yIFwKICAtbiBudmNhLW9wZXJhdG9yIC0tdGFpbD0yMDAKa3ViZWN0bCAtLWNv" + - "bnRleHQgPGNvbXB1dGUtcGxhbmUtY29udGV4dD4gZ2V0IG52Y2ZiYWNrZW5kIC1uIG52Y2Etb3Bl" + - "cmF0b3IKYGBgCgpGb3IgcHJpdmF0ZSByZWdpc3RyeSBmYWlsdXJlcywgdmVyaWZ5IHRoYXQgdGhl" + - "IHB1bGwgc2VjcmV0IGV4aXN0cyBpbgpgbnZjYS1vcGVyYXRvcmAuIFRoZSBjaGFydCBhbmQgb3Bl" + - "cmF0b3IgbWlycm9yIGl0IHRvIGBudmNhLXN5c3RlbWA7IGRvIG5vdCB1c2UgYQpicm9hZGVyIG1h" + - "bnVhbCBuYW1lc3BhY2UgbG9vcC4gU2VlCltwdWxsLXNlY3JldHMubWRdKHB1bGwtc2VjcmV0cy5t" + - "ZCNjb21wdXRlLXBsYW5lLXNlY3JldCkuCgojIyBGYWlsdXJlOiBHYXRld2F5IEVuZHBvaW50IENo" + - "YW5nZWQKCiMjIyBTeW1wdG9tcwoKUmVxdWVzdHMgdGhyb3VnaCB0aGUgY29uZmlndXJlZCByb3V0" + - "ZSBkb21haW4gZmFpbCBhZnRlciB0aGUgR2F0ZXdheSBvciBpdHMgbG9hZCBiYWxhbmNlciBpcyBy" + - "ZXBsYWNlZC4gVGhlIEdhdGV3YXkgcmVwb3J0cyBhIG5ldyBlbmRwb2ludC4KCiMjIyBEaWFnbm9z" + - "aXMKCmBgYGJhc2gKR0FURVdBWV9BRERSPSQoa3ViZWN0bCAtLWNvbnRleHQgPGNvbnRyb2wtcGxh" + - "bmUtY29udGV4dD4gZ2V0IGdhdGV3YXkgXAogIG52Y2YtZ2F0ZXdheSAtbiBlbnZveS1nYXRld2F5" + - "IFwKICAtbyBqc29ucGF0aD0ney5zdGF0dXMuYWRkcmVzc2VzWzBdLnZhbHVlfScpCnRlc3QgLW4g" + - "IiRHQVRFV0FZX0FERFIiCmRpZyArc2hvcnQgImFwaS48ZG9tYWluPiIKY3VybCAtSCAiSG9zdDog" + - "YXBpLjxkb21haW4+IiAiaHR0cDovLyRHQVRFV0FZX0FERFIvaGVhbHRoIgoKIyBDaGVjayBkaXJl" + - "Y3QgYWRkcmVzcyBmaWVsZHMgdXNlZCBieSBhIHNwbGl0IGRlcGxveW1lbnQKZ3JlcCBudmNmTmF0" + - "c1NlcnZpY2VVUkwgZGVwbG95L3N0YWNrcy9zZWxmLW1hbmFnZWQvZW52aXJvbm1lbnRzLzxlbnY+" + - "LnlhbWwKZ3JlcCAtRSAnaWNtc1NlcnZpY2V8cmV2YWxTZXJ2aWNlfG5hdHMnIFwKICBkZXBsb3kv" + - "c3RhY2tzL252Y2YtY29tcHV0ZS1wbGFuZS9lbnZpcm9ubWVudHMvPGVudj4ueWFtbApgYGAKCiMj" + - "IyBGaXgKCktlZXAgYGdsb2JhbC5kb21haW5gLCByb3V0ZSBob3N0bmFtZXMsIGFuZCBIb3N0IG92" + - "ZXJyaWRlcyB1bmNoYW5nZWQuIFVwZGF0ZSBETlMKb3IgdGhlIGRpcmVjdCBjbGllbnQgZGVzdGlu" + - "YXRpb24uIEZvciBzcGxpdCBkZXBsb3ltZW50cywgdXBkYXRlIG9ubHkgZGlyZWN0CkdhdGV3YXkt" + - "YWRkcmVzcyBmaWVsZHMgYW5kIHJlZnJlc2ggcmVnaXN0cmF0aW9uIGFuZCBpbnN0YWxsYXRpb24g" + - "dGhyb3VnaCB0aGUKc2FtZSBzZWxlY3RlZCBoYW5kb2ZmLiBTZWUKW0V4YW1wbGUgNF0oLi4vZXhh" + - "bXBsZXMubWQjZXhhbXBsZS00LXJlY292ZXItZnJvbS1hLWdhdGV3YXktZW5kcG9pbnQtY2hhbmdl" + - "KS4KCiMjIFVzZWZ1bCBOYW1lc3BhY2UtdG8tU2VydmljZSBNYXBwaW5nCgpRdWljayByZWZlcmVu" + - "Y2UgZm9yIHdoaWNoIHNlcnZpY2VzIHJ1biBpbiB3aGljaCBuYW1lc3BhY2U6Cgp8IE5hbWVzcGFj" + - "ZSB8IFNlcnZpY2VzIHwKfC0tLS0tLS0tLS0tfC0tLS0tLS0tLS18CnwgbmF0cy1zeXN0ZW0gfCBu" + - "YXRzIHwKfCBjYXNzYW5kcmEtc3lzdGVtIHwgY2Fzc2FuZHJhIHwKfCB2YXVsdC1zeXN0ZW0gfCBv" + - "cGVuYmFvLXNlcnZlciB8CnwgbnZjZiB8IGFwaSwgaW52b2NhdGlvbi1zZXJ2aWNlLCBncnBjLXBy" + - "b3h5LCBub3Rhcnktc2VydmljZSwgcmV2YWwsIGxsbS1yZXF1ZXN0LXJvdXRlciwgbGxtLWFwaS1n" + - "YXRld2F5IHwKfCBhcGkta2V5cyB8IGFwaS1rZXlzLCBhZG1pbi1pc3N1ZXItcHJveHkgfAp8IGVz" + - "cyB8IGVzcy1hcGkgfAp8IHNpcyB8IHNpcyB8CnwgZW52b3ktZ2F0ZXdheS1zeXN0ZW0gfCBlbnZv" + - "eSBnYXRld2F5IChpbmdyZXNzIGNvbnRyb2xsZXIpIHwKfCBlbnZveS1nYXRld2F5IHwgZ2F0ZXdh" + - "eSByZXNvdXJjZSArIHJvdXRlcyB8ClBLBwhWPmeQlTAAAJUwAABQSwMEFAAIAAAAAAAhAAAAAAAA" + - "AAAAAAAAAEQACQBkYXRhL252Y2Ytc2VsZi1tYW5hZ2VkLWluc3RhbGxhdGlvbi9yZWZlcmVuY2Vz" + - "L2hlbG1maWxlLXN0cnVjdHVyZS5tZFVUBQABAKbOEiMgSGVsbWZpbGUgU3RydWN0dXJlIFJlZmVy" + - "ZW5jZQoKIyMgRGlyZWN0b3J5IExheW91dAoKYGBgCm52Y2Ytc2VsZi1tYW5hZ2VkLXN0YWNrLwp8" + - "LS0gaGVsbWZpbGUuZC8KfCAgIHwtLSAwMS1kZXBlbmRlbmNpZXMueWFtbC5nb3RtcGwgICMgTkFU" + - "UywgQ2Fzc2FuZHJhLCBPcGVuQmFvCnwgICB8LS0gMDItY29yZS55YW1sLmdvdG1wbCAgICAgICAg" + - "ICAjIE5WQ0Ygc2VydmljZXMgKyBpbmdyZXNzCnwgICBgLS0gMDMtb2JzZXJ2YWJpbGl0eS55YW1s" + - "LmdvdG1wbCAjIE9ic2VydmFiaWxpdHkgc3RhY2sgKG9wdGlvbmFsKQp8LS0gZW52aXJvbm1lbnRz" + - "Lwp8ICAgfC0tIGJhc2UueWFtbCAgICAgICAgICAgICAgICAgICAgIyBEZWZhdWx0IHZhbHVlcyAo" + - "YWxsIGVudmlyb25tZW50cykKfCAgIGAtLSA8ZW52LW5hbWU+LnlhbWwgICAgICAgICAgICAgICMg" + - "UGVyLWVudmlyb25tZW50IG92ZXJyaWRlcwp8LS0gc2VjcmV0cy8KfCAgIGAtLSA8ZW52LW5hbWU+" + - "LXNlY3JldHMueWFtbCAgICAgICMgU2Vuc2l0aXZlIHZhbHVlcyAocmVnaXN0cnkgY3JlZHMsIHBh" + - "c3N3b3JkcykKYC0tIGdsb2JhbC55YW1sLmdvdG1wbCAgICAgICAgICAgICAgICMgR28gdGVtcGxh" + - "dGUgdGhhdCBjb25zdHJ1Y3RzIHBlci1jaGFydCB2YWx1ZXMKCm52Y2YtY29tcHV0ZS1wbGFuZS1z" + - "dGFjay8KfC0tIGhlbG1maWxlLmQvCnwgICB8LS0gMDEtZGVwZW5kZW5jaWVzLnlhbWwuZ290bXBs" + - "ICAjIENvbXB1dGUgcGxhbmUgZGVwZW5kZW5jeSBjb21wb25lbnRzCnwgICBgLS0gMDItbnZjYS55" + - "YW1sLmdvdG1wbCAgICAgICAgICAjIG52Y2Etb3BlcmF0b3IgY2hhcnQgYW5kIG52Y2EgY29uZmln" + - "dXJhdGlvbgp8LS0gZW52aXJvbm1lbnRzLwp8ICAgfC0tIGJhc2UueWFtbCAgICAgICAgICAgICAg" + - "ICAgICAgIyBEZWZhdWx0IHZhbHVlcyAoYWxsIGVudmlyb25tZW50cykKfCAgIGAtLSA8ZW52LW5h" + - "bWU+LnlhbWwgICAgICAgICAgICAgICMgUGVyLWVudmlyb25tZW50IG92ZXJyaWRlcwpgLS0gZ2xv" + - "YmFsLnlhbWwuZ290bXBsICAgICAgICAgICAgICAgIyBHbyB0ZW1wbGF0ZSB0aGF0IGNvbnN0cnVj" + - "dHMgcGVyLWNoYXJ0IHZhbHVlcwpgYGAKClRoZXNlIHN0YWNrcyBoYXZlIHNlcGFyYXRlIGVudmly" + - "b25tZW50cyBhbmQgY2x1c3RlciBjb250ZXh0cy4gVGhlIEhlbG1maWxlCnZhbHVlcyBmbG93IGF1" + - "dGhvcnMgYm90aCBlbnZpcm9ubWVudCBmaWxlcy4gVGhlIENMSSBwcm9maWxlIGZsb3cgaW5zdGVh" + - "ZCB1c2VzCnRoZSBDTEktZ2VuZXJhdGVkIGNvbnRyb2wtcGxhbmUgcHJvZmlsZSBhcyBpdHMgZW5k" + - "cG9pbnQgc291cmNlLiBEbyBub3QgbWl4IHRoZQpoYW5kb2Zmcy4gU2VlIFtTcGxpdCBDb21wdXRl" + - "LVBsYW5lIEluc3RhbGxhdGlvbl0oY29tcHV0ZS1wbGFuZS1pbnN0YWxsYXRpb24ubWQpLgoKIyMg" + - "R290bXBsIEZpbGVzIGFuZCBUaGVpciBSZWxlYXNlcwoKIyMjIDAxLWRlcGVuZGVuY2llcy55YW1s" + - "LmdvdG1wbAoKfCBSZWxlYXNlIHwgQ2hhcnQgfCBOYW1lc3BhY2UgfCBOb3RlcyB8CnwtLS0tLS0t" + - "LS18LS0tLS0tLXwtLS0tLS0tLS0tLXwtLS0tLS0tfAp8IG5hdHMgfCBoZWxtLW52Y2YtbmF0cyB8" + - "IG5hdHMtc3lzdGVtIHwgTWVzc2FnaW5nIHwKfCBvcGVuYmFvLXNlcnZlciB8IGhlbG0tbnZjZi1v" + - "cGVuYmFvLXNlcnZlciB8IHZhdWx0LXN5c3RlbSB8IFNlY3JldHMgbWFuYWdlbWVudCwgZGVwZW5k" + - "cyBvbiBuYXRzIHwKfCBjYXNzYW5kcmEgfCBoZWxtLW52Y2YtY2Fzc2FuZHJhIHwgY2Fzc2FuZHJh" + - "LXN5c3RlbSB8IERhdGFiYXNlIHwKClVzZXMgYDw8OiAqZGVwZW5kZW5jeWAgdGVtcGxhdGUgaW5o" + - "ZXJpdGFuY2Ugd2l0aCBgcmVsZWFzZS1ncm91cDogZGVwZW5kZW5jaWVzYCBsYWJlbC4KCiMjIyAw" + - "Mi1jb3JlLnlhbWwuZ290bXBsCgp8IFJlbGVhc2UgfCBDaGFydCB8IE5hbWVzcGFjZSB8IExhYmVs" + - "IHwKfC0tLS0tLS0tLXwtLS0tLS0tfC0tLS0tLS0tLS0tfC0tLS0tLS18CnwgYXBpLWtleXMgfCBo" + - "ZWxtLW52Y2YtYXBpLWtleXMgfCBhcGkta2V5cyB8IHNlcnZpY2VzIHwKfCBzaXMgfCBoZWxtLW52" + - "Y2Ytc2lzIHwgc2lzIHwgc2VydmljZXMgfAp8IGFwaSB8IGhlbG0tbnZjZi1hcGkgfCBudmNmIHwg" + - "c2VydmljZXMgfAp8IGludm9jYXRpb24tc2VydmljZSB8IGhlbG0tbnZjZi1pbnZvY2F0aW9uLXNl" + - "cnZpY2UgfCBudmNmIHwgc2VydmljZXMgfAp8IGdycGMtcHJveHkgfCBoZWxtLW52Y2YtZ3JwYy1w" + - "cm94eSB8IG52Y2YgfCBzZXJ2aWNlcyB8CnwgZXNzLWFwaSB8IGhlbG0tbnZjZi1lc3MtYXBpIHwg" + - "ZXNzIHwgc2VydmljZXMgfAp8IG5vdGFyeS1zZXJ2aWNlIHwgaGVsbS1udmNmLW5vdGFyeS1zZXJ2" + - "aWNlIHwgbnZjZiB8IHNlcnZpY2VzIHwKfCByZXZhbCB8IGhlbG0tcmV2YWwgfCBudmNmIHwgc2Vy" + - "dmljZXMgfAp8IGxsbS1yZXF1ZXN0LXJvdXRlciB8IG52Y2YvaGVsbS1udmNmLWxsbS1yZXF1ZXN0" + - "LXJvdXRlciB8IG52Y2YgfCBzZXJ2aWNlcyB8CnwgbGxtLWFwaS1nYXRld2F5IHwgbnZjZi9oZWxt" + - "LW52Y2YtbGxtLWFwaS1nYXRld2F5IHwgbnZjZiB8IHNlcnZpY2VzIHwKfCBhZG1pbi1pc3N1ZXIt" + - "cHJveHkgfCBoZWxtLWFkbWluLXRva2VuLWlzc3Vlci1wcm94eSB8IGFwaS1rZXlzIHwgKG5vIHJl" + - "bGVhc2UtZ3JvdXAgbGFiZWwpIHwKfCBpbmdyZXNzIHwgbnZjZi1nYXRld2F5LXJvdXRlcyB8IGVu" + - "dm95LWdhdGV3YXktc3lzdGVtIHwgaW5ncmVzcyB8CgpNb3N0IHNlcnZpY2VzIHVzZSBgaW5oZXJp" + - "dDogW3t0ZW1wbGF0ZTogc2VydmljZX1dYC4gTExNIHJlbGVhc2VzIHVzZSBPQ0kgY2hhcnRzIGZy" + - "b20gdGhlIGBudmNmYCByZXBvc2l0b3J5IHdpdGggc3RhbmRhbG9uZSBgdmFsdWVzOiBbLi4vZ2xv" + - "YmFsLnlhbWwuZ290bXBsXWAgYmxvY2tzOyB0aGV5IGFyZSBnYXRlZCBvbiBgYWRkb25zLmxsbS5l" + - "bmFibGVkYC4gYGFkbWluLWlzc3Vlci1wcm94eWAgYW5kIGBpbmdyZXNzYCBoYXZlIHN0YW5kYWxv" + - "bmUgYHZhbHVlczpgIGJsb2Nrcy4KCiMjIyAwMy1vYnNlcnZhYmlsaXR5LnlhbWwuZ290bXBsCgp8" + - "IFJlbGVhc2UgfCBDaGFydCB8IE5hbWVzcGFjZSB8IExhYmVsIHwKfC0tLS0tLS0tLXwtLS0tLS0t" + - "fC0tLS0tLS0tLS0tfC0tLS0tLS18CnwgKG9ic2VydmFiaWxpdHkgcmVsZWFzZXMpIHwgKHZhcmlv" + - "dXMpIHwgb2JzZXJ2YWJpbGl0eSB8IG9ic2VydmFiaWxpdHkgfAoKR2F0ZWQgb24gb2JzZXJ2YWJp" + - "bGl0eS1zcGVjaWZpYyBmbGFncyBpbiB0aGUgZW52aXJvbm1lbnQgZmlsZS4gU2tpcHBlZCBpZiBk" + - "aXNhYmxlZC4KCiMjIFRlbXBsYXRlIEluaGVyaXRhbmNlCgojIyMgYDw8OiAqZGVwZW5kZW5jeWAg" + - "KFlBTUwgbWVyZ2UpCgpVc2VkIGluIGAwMS1kZXBlbmRlbmNpZXMueWFtbC5nb3RtcGxgLiBNZXJn" + - "ZXMgdGhlIHRlbXBsYXRlJ3MgcHJvcGVydGllcyBpbnRvIHRoZSByZWxlYXNlLgoKKipHb3RjaGEq" + - "KjogWUFNTCBtZXJnZSByZXBsYWNlcyBsaXN0cy4gSWYgeW91IGFkZCBhIGB2YWx1ZXM6YCBrZXkg" + - "dG8gdGhlIHJlbGVhc2UsIGl0ICoqcmVwbGFjZXMqKiB0aGUgdGVtcGxhdGUncyBgdmFsdWVzOmAg" + - "bGlzdCBlbnRpcmVseS4gWW91IG11c3QgcmUtaW5jbHVkZSBhbGwgdGVtcGxhdGUgdmFsdWVzOgoK" + - "SW4gdGhlIHRlbXBsYXRlIGJlbG93LCBgPHByaXZhdGUtdmFsdWVzPmAgcmVmZXJzIHRvIHRoZSBg" + - "c2VjcmV0cy9gIGRpcmVjdG9yeSBhdCB0aGUgaGVsbWZpbGUgc3RhY2sgcm9vdC4KCmBgYHlhbWwK" + - "IyBUZW1wbGF0ZSBkZWZpbmVzOgp0ZW1wbGF0ZXM6CiAgZGVwZW5kZW5jeTogJmRlcGVuZGVuY3kK" + - "ICAgIGNoYXJ0OiBudmNmL2hlbG0tbnZjZi17eyAuUmVsZWFzZS5OYW1lIH19CiAgICB2YWx1ZXM6" + - "CiAgICAgIC0gLi4vZ2xvYmFsLnlhbWwuZ290bXBsCiAgICAgIC0gLi4vPHByaXZhdGUtdmFsdWVz" + - "Pi97eyByZXF1aXJlZEVudiAiSEVMTUZJTEVfRU5WIiB9fS1zZWNyZXRzLnlhbWwKCiMgV2hlbiBv" + - "dmVycmlkaW5nLCBNVVNUIHJlLWluY2x1ZGUgYm90aDoKLSBuYW1lOiBjYXNzYW5kcmEKICA8PDog" + - "KmRlcGVuZGVuY3kKICB2YWx1ZXM6CiAgICAtIC4uL2dsb2JhbC55YW1sLmdvdG1wbCAgICAgICAg" + - "ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAjIE11c3QgcmUtaW5jbHVkZQog" + + "IgogICAgICAgICAgICBtZW1vcnk6IDQwOTZNaQpgYGAKCiMjIyBTdGVwIDM6IFZlcmlmeSBhbmQg" + + "YXBwbHkKCmBgYGJhc2gKSEVMTUZJTEVfRU5WPTxlbnY+IGhlbG1maWxlIC0tc2VsZWN0b3IgbmFt" + + "ZT1jYXNzYW5kcmEgdGVtcGxhdGUgPiAvdG1wL2Nhc3MtYWZ0ZXIueWFtbApkaWZmIC90bXAvY2Fz" + + "cy1iZWZvcmUueWFtbCAvdG1wL2Nhc3MtYWZ0ZXIueWFtbCAgIyBDb25maXJtIHJlc291cmNlcyBj" + + "aGFuZ2VkCkhFTE1GSUxFX0VOVj08ZW52PiBoZWxtZmlsZSAtLXNlbGVjdG9yIG5hbWU9Y2Fzc2Fu" + + "ZHJhIHN5bmMKYGBgCgpOb3RlOiBgcmVzb3VyY2VQcmVzZXRgIChhIEJpdG5hbWkgZmVhdHVyZSkg" + + "aXMgbm90IGF2YWlsYWJsZSBpbiB0aGUgTlZDRiBjYXNzYW5kcmEgd3JhcHBlciBjaGFydC4gVXNl" + + "IGV4cGxpY2l0IGByZXNvdXJjZXNgIGluc3RlYWQuCgotLS0KCiMjIEV4YW1wbGUgMjogRGVwbG95" + + "IGZyb20gTkdDIFByaXZhdGUgUmVnaXN0cnkgd2l0aCBQdWxsIFNlY3JldHMKCkRlcGxveSB0aGUg" + + "TlZDRiBzdGFjayBwdWxsaW5nIGltYWdlcyBkaXJlY3RseSBmcm9tIE5HQyAoYG52Y3IuaW9gKSBp" + + "bnN0ZWFkIG9mIGEgbWlycm9yZWQgcmVnaXN0cnksIHVzaW5nIGltYWdlIHB1bGwgc2VjcmV0cy4K" + + "CiMjIyBTdGVwIDE6IENvbmZpZ3VyZSBlbnZpcm9ubWVudCBmb3IgTkdDCgpgYGB5YW1sCiMgZW52" + + "aXJvbm1lbnRzLzxlbnY+LnlhbWwKZ2xvYmFsOgogIGhlbG06CiAgICBzb3VyY2VzOgogICAgICBy" + + "ZWdpc3RyeTogbnZjci5pbwogICAgICByZXBvc2l0b3J5OiBudmlkaWEvbnZjZgogIGltYWdlOgog" + + "ICAgcmVnaXN0cnk6IG52Y3IuaW8KICAgIHJlcG9zaXRvcnk6IG52aWRpYS9udmNmCmBgYAoKIyMj" + + "IFN0ZXAgMjogQXV0aGVudGljYXRlIGxvY2FsbHkgKGZvciBoZWxtZmlsZSBjaGFydCBwdWxscykK" + + "CmBgYGJhc2gKZG9ja2VyIGxvZ2luIG52Y3IuaW8gLXUgJyRvYXV0aHRva2VuJyAtcCAiJE5HQ19B" + + "UElfS0VZIgpoZWxtIHJlZ2lzdHJ5IGxvZ2luIG52Y3IuaW8gLXUgJyRvYXV0aHRva2VuJyAtcCAi" + + "JE5HQ19BUElfS0VZIgpgYGAKCiMjIyBTdGVwIDM6IENyZWF0ZSBuYW1lc3BhY2VzIGFuZCBwdWxs" + + "IHNlY3JldHMKCmBgYGJhc2gKZXhwb3J0IE5HQ19BUElfS0VZPSI8eW91ci1uZ2MtYXBpLWtleT4i" + + "Cgpmb3IgbnMgaW4gY2Fzc2FuZHJhLXN5c3RlbSBuYXRzLXN5c3RlbSBudmNmIGFwaS1rZXlzIGVz" + + "cyBzaXMgdmF1bHQtc3lzdGVtIGNlcnQtbWFuYWdlcjsgZG8KICBrdWJlY3RsIC0tY29udGV4dCA8" + + "Y29udHJvbC1wbGFuZS1jb250ZXh0PiBjcmVhdGUgbmFtZXNwYWNlICIkbnMiIFwKICAgIC0tZHJ5" + + "LXJ1bj1jbGllbnQgLW8geWFtbCB8IGt1YmVjdGwgLS1jb250ZXh0IDxjb250cm9sLXBsYW5lLWNv" + + "bnRleHQ+IGFwcGx5IC1mIC0KZG9uZQoKZm9yIG5zIGluIGNhc3NhbmRyYS1zeXN0ZW0gbmF0cy1z" + + "eXN0ZW0gbnZjZiBhcGkta2V5cyBlc3Mgc2lzIHZhdWx0LXN5c3RlbSBjZXJ0LW1hbmFnZXI7IGRv" + + "CiAga3ViZWN0bCAtLWNvbnRleHQgPGNvbnRyb2wtcGxhbmUtY29udGV4dD4gY3JlYXRlIHNlY3Jl" + + "dCBkb2NrZXItcmVnaXN0cnkgbnZjci1jcmVkcyBcCiAgICAtLWRvY2tlci1zZXJ2ZXI9bnZjci5p" + + "byBcCiAgICAtLWRvY2tlci11c2VybmFtZT0nJG9hdXRodG9rZW4nIFwKICAgIC0tZG9ja2VyLXBh" + + "c3N3b3JkPSIkTkdDX0FQSV9LRVkiIFwKICAgIC0tbmFtZXNwYWNlPSIkbnMiIFwKICAgIC0tZHJ5" + + "LXJ1bj1jbGllbnQgLW8geWFtbCB8IGt1YmVjdGwgLS1jb250ZXh0IDxjb250cm9sLXBsYW5lLWNv" + + "bnRleHQ+IGFwcGx5IC1mIC0KZG9uZQpgYGAKCiMjIyBTdGVwIDQ6IEFkZCBpbWFnZVB1bGxTZWNy" + + "ZXRzIHRvIGhlbG1maWxlIHJlbGVhc2VzCgpBZGQgdGhlIGNoYXJ0LXNwZWNpZmljIGBpbWFnZVB1" + + "bGxTZWNyZXRzYCBrZXkgdG8gZWFjaCByZWxlYXNlLiBFeGFtcGxlIGZvciBjYXNzYW5kcmEgaW4g" + + "YGhlbG1maWxlLmQvMDEtZGVwZW5kZW5jaWVzLnlhbWwuZ290bXBsYDoKCmBgYHlhbWwKLSBuYW1l" + + "OiBjYXNzYW5kcmEKICB2ZXJzaW9uOiAwLjguMAogIGNvbmRpdGlvbjogY2Fzc2FuZHJhLmVuYWJs" + + "ZWQKICBuYW1lc3BhY2U6IGNhc3NhbmRyYS1zeXN0ZW0KICA8PDogKmRlcGVuZGVuY3kKICB2YWx1" + + "ZXM6CiAgICAtIC4uL2dsb2JhbC55YW1sLmdvdG1wbAogICAgLSAuLi88cHJpdmF0ZS12YWx1ZXM+" + + "L3t7IHJlcXVpcmVkRW52ICJIRUxNRklMRV9FTlYiIH19LXNlY3JldHMueWFtbAogICAgLSBjYXNz" + + "YW5kcmE6CiAgICAgICAgZ2xvYmFsOgogICAgICAgICAgaW1hZ2VQdWxsU2VjcmV0czoKICAgICAg" + + "ICAgICAgLSBudmNyLWNyZWRzCmBgYAoKU2VlIFtyZWZlcmVuY2VzL3B1bGwtc2VjcmV0cy5tZF0o" + + "cmVmZXJlbmNlcy9wdWxsLXNlY3JldHMubWQpIGZvciB0aGUga2V5IGZvciBldmVyeSBjaGFydC4K" + + "ClRoZXNlIGFyZSBjb250cm9sLXBsYW5lIG5hbWVzcGFjZXMuIEZvciBhIHNlcGFyYXRlIGNvbXB1" + + "dGUgY2x1c3RlciwgY3JlYXRlIHRoZQpzZWNyZXQgb25seSBpbiBgbnZjYS1vcGVyYXRvcmA7IHRo" + + "ZSBjaGFydCBhbmQgb3BlcmF0b3IgbWlycm9yIGl0IHRvCmBudmNhLXN5c3RlbWAuIFNlZSBbU3Bs" + + "aXQgQ29tcHV0ZS1QbGFuZSBJbnN0YWxsYXRpb25dKHJlZmVyZW5jZXMvY29tcHV0ZS1wbGFuZS1p" + + "bnN0YWxsYXRpb24ubWQjcHVsbC1zZWNyZXRzKS4KCiMjIyBTdGVwIDU6IERlcGxveQoKYGBgYmFz" + + "aApIRUxNRklMRV9FTlY9PGVudj4gaGVsbWZpbGUgLS1rdWJlLWNvbnRleHQgPGNvbnRyb2wtcGxh" + + "bmUtY29udGV4dD4gc3luYwpgYGAKCiMjIyBTdGVwIDY6IFBhdGNoIFNlcnZpY2VBY2NvdW50cyBm" + + "b3IgY2hhcnRzIHdpdGhvdXQgbmF0aXZlIHN1cHBvcnQKCkFmdGVyIFBoYXNlIDEgKGRlcGVuZGVu" + + "Y2llcykgY29tcGxldGVzLCBPcGVuQmFvIHBvZHMgd2lsbCBiZSBpbiBgSW1hZ2VQdWxsQmFja09m" + + "ZmAuIFBhdGNoIGFuZCByZXN0YXJ0OgoKYGBgYmFzaApmb3IgbnMgaW4gdmF1bHQtc3lzdGVtIG52" + + "Y2YgZXNzOyBkbwogIGZvciBzYSBpbiAkKGt1YmVjdGwgLS1jb250ZXh0IDxjb250cm9sLXBsYW5l" + + "LWNvbnRleHQ+IGdldCBzYSAtbiAiJG5zIiBcCiAgICAtLW5vLWhlYWRlcnMgLW8gY3VzdG9tLWNv" + + "bHVtbnM9IjptZXRhZGF0YS5uYW1lIik7IGRvCiAgICBrdWJlY3RsIC0tY29udGV4dCA8Y29udHJv" + + "bC1wbGFuZS1jb250ZXh0PiBwYXRjaCBzZXJ2aWNlYWNjb3VudCAtbiAiJG5zIiAiJHNhIiBcCiAg" + + "ICAgIC1wICd7ImltYWdlUHVsbFNlY3JldHMiOiBbeyJuYW1lIjogIm52Y3ItY3JlZHMifV19Jwog" + + "IGRvbmUKZG9uZQprdWJlY3RsIC0tY29udGV4dCA8Y29udHJvbC1wbGFuZS1jb250ZXh0PiBkZWxl" + + "dGUgcG9kcyAtbiB2YXVsdC1zeXN0ZW0gLS1hbGwKYGBgCgpWZXJpZnk6CgpgYGBiYXNoCmt1YmVj" + + "dGwgLS1jb250ZXh0IDxjb250cm9sLXBsYW5lLWNvbnRleHQ+IGdldCBldmVudHMgLW4gdmF1bHQt" + + "c3lzdGVtIFwKICAtLXNvcnQtYnk9Jy5sYXN0VGltZXN0YW1wJyB8IGdyZXAgLWkgcHVsbAojIFNo" + + "b3VsZCBzaG93ICJTdWNjZXNzZnVsbHkgcHVsbGVkIGltYWdlIiBmcm9tIG52Y3IuaW8KYGBgCgot" + + "LS0KCiMjIEV4YW1wbGUgMzogRnVsbCBUZWFyZG93biBhbmQgUmVpbnN0YWxsCgpXaGVuIGEgZGVw" + + "bG95bWVudCBpcyBicm9rZW4gYW5kIHlvdSBuZWVkIGEgY2xlYW4gc2xhdGUuCgojIyMgU3RlcCAx" + + "OiBEZXN0cm95IHRoZSBjb21wdXRlLXBsYW5lIHN0YWNrCgpgYGBiYXNoCm1ha2UgLUMgZGVwbG95" + + "L3N0YWNrcy9udmNmLWNvbXB1dGUtcGxhbmUgZGVzdHJveSBcCiAgQ0xVU1RFUl9OQU1FPTxjbHVz" + + "dGVyLW5hbWU+IFwKICBIRUxNRklMRV9FTlY9PGVudj4gXAogIEtVQkVDT05GSUdfRklMRT08Y29t" + + "cHV0ZS1wbGFuZS1rdWJlY29uZmlnPgpgYGAKCklmIGNvbXB1dGUgY2xlYW51cCBpcyBzdHVjayBv" + + "biBmaW5hbGl6ZXJzLCB1c2UgdGhlIGNvbXB1dGUtY29udGV4dCBwcm9jZWR1cmUgaW4KW2RlYnVn" + + "Z2luZy5tZF0ocmVmZXJlbmNlcy9kZWJ1Z2dpbmcubWQjZmFpbHVyZS1udmNhLWNsZWFudXAtc3R1" + + "Y2stZmluYWxpemVycykuCgojIyMgU3RlcCAyOiBEZXJlZ2lzdGVyIHRoZSBjb21wdXRlIGNsdXN0" + + "ZXIKClJlYWQgYGNsdXN0ZXJJRGAgYW5kIGBuY2FJRGAgZnJvbQpgZGVwbG95L3N0YWNrcy9udmNm" + + "LWNvbXB1dGUtcGxhbmUvcmVnaXN0cmF0aW9uLzxjbHVzdGVyLW5hbWU+LXJlZ2lzdGVyLXZhbHVl" + + "cy55YW1sYC4KU2hvdyB0aGUgSUQgYW5kIGdldCBjb25maXJtYXRpb24gYmVmb3JlIGRlbGV0aW5n" + + "IHRoZSBJQ01TIHJvdzoKCmBgYGJhc2gKPG52Y2YtY2xpPiAtLWNvbmZpZyA8Y29uZmlnPiBjbHVz" + + "dGVyIGRlbGV0ZSBcCiAgLS1jbHVzdGVyLWlkIDxjbHVzdGVyLWlkLWZyb20tcmVnaXN0cmF0aW9u" + + "LXZhbHVlcz4gXAogIC0tbmNhLWlkIDxuY2EtaWQ+IFwKICAtLWlnbm9yZS1taXNzaW5nCmBgYAoK" + + "UmVwZWF0IHN0ZXBzIDEgYW5kIDIgZm9yIGV2ZXJ5IGNvbXB1dGUgY2x1c3Rlci4KCiMjIyBTdGVw" + + "IDM6IERlc3Ryb3kgdGhlIGNvbnRyb2wtcGxhbmUgc3RhY2sKClByZXNlcnZlIHRoZSBgY2VydC1t" + + "YW5hZ2VyYCBuYW1lc3BhY2UgYnkgZGVmYXVsdC4gTmFtZXNwYWNlIHByZXNlcnZhdGlvbiBkb2Vz" + + "Cm5vdCBwcmVzZXJ2ZSB0aGUgSGVsbSByZWxlYXNlLiBCZWZvcmUgcnVubmluZyBkZXN0cm95LCBp" + + "ZGVudGlmeSB3aGV0aGVyCmNlcnQtbWFuYWdlciBpcyBleHRlcm5hbC4gRm9yIGFuIGV4dGVybmFs" + + "IGluc3RhbGxhdGlvbiwgcmVxdWlyZSBlZmZlY3RpdmUKYGNlcnRNYW5hZ2VyLmVuYWJsZWQ6IGZh" + + "bHNlYCBhbmQgYWJvcnQgaWYgaXQgaXMgdHJ1ZS4gRm9yIGFuIGludGVuZGVkCnN0YWNrLW1hbmFn" + + "ZWQgcmVsZWFzZSB3aXRoIGVmZmVjdGl2ZSBgY2VydE1hbmFnZXIuZW5hYmxlZDogdHJ1ZWAsIHZl" + + "cmlmeQptYXRjaGluZyBzdGFjayBIZWxtIHJlbGVhc2UgbWV0YWRhdGEgYW5kIGFib3J0IG9uIG1p" + + "c3Npbmcgb3IgbWlzbWF0Y2hlZApldmlkZW5jZS4gT25seSBwbGFuIG5hbWVzcGFjZSByZW1vdmFs" + + "IGFmdGVyIHZlcmlmeWluZyBuYW1lc3BhY2UgcHJvdmVuYW5jZSBhbmQKZ2V0dGluZyBleHBsaWNp" + + "dCBjb25maXJtYXRpb247IG90aGVyd2lzZSBkbyBub3QgZGVsZXRlIGl0LgoKYGBgYmFzaApLVUJF" + + "Q09ORklHPTxjb250cm9sLXBsYW5lLWt1YmVjb25maWc+IFwKbWFrZSAtQyBkZXBsb3kvc3RhY2tz" + + "L3NlbGYtbWFuYWdlZCBkZXN0cm95IFwKICBIRUxNRklMRV9FTlY9PGVudj4gXAogIEtVQkVDT05G" + + "SUdfRklMRT08Y29udHJvbC1wbGFuZS1rdWJlY29uZmlnPgpgYGAKClBhc3MgYm90aCBrdWJlY29u" + + "ZmlnIGZvcm1zIGJlY2F1c2UgY29udHJvbC1wbGFuZSBuYW1lc3BhY2UgY2xlYW51cCB1c2VzCmFt" + + "YmllbnQgYGt1YmVjdGxgLgoKIyMjIFN0ZXAgNDogVmVyaWZ5IGNsZWFuCgpgYGBiYXNoCmt1YmVj" + + "dGwgLS1jb250ZXh0IDxjb21wdXRlLXBsYW5lLWNvbnRleHQ+IGdldCBucyB8IFwKICBncmVwIC1F" + + "ICcobnZjYXxudmNmLWJhY2tlbmR8Z3JvdmV8ZHluYW1vKScKa3ViZWN0bCAtLWNvbnRleHQgPGNv" + + "bnRyb2wtcGxhbmUtY29udGV4dD4gZ2V0IG5zIHwgXAogIGdyZXAgLUUgJyhjYXNzYW5kcmF8bmF0" + + "c3x2YXVsdHxudmNmfGFwaS1rZXlzfGVzc3xzaXMpJwojIEJvdGggY29tbWFuZHMgc2hvdWxkIHJl" + + "dHVybiBlbXB0eS4KYGBgCgojIyMgU3RlcCA1OiBSZWluc3RhbGwgaW4gc3BsaXQgb3JkZXIKCkZv" + + "bGxvdyBbQ2xlYW4gSW5zdGFsbGF0aW9uXShTS0lMTC5tZCNjbGVhbi1pbnN0YWxsYXRpb24pLCB0" + + "aGVuIHJldHVybiB0byB0aGUKc2FtZSBoYW5kb2ZmIGluIFtTcGxpdCBDb21wdXRlLVBsYW5lIElu" + + "c3RhbGxhdGlvbl0ocmVmZXJlbmNlcy9jb21wdXRlLXBsYW5lLWluc3RhbGxhdGlvbi5tZCkuCgot" + + "LS0KCiMjIEV4YW1wbGUgNDogUmVjb3ZlciBmcm9tIGEgR2F0ZXdheSBFbmRwb2ludCBDaGFuZ2UK" + + "ClRoZSBzZXBhcmF0ZWx5IHByb3Zpc2lvbmVkIEdhdGV3YXkgb3IgaXRzIGxvYWQgYmFsYW5jZXIg" + + "d2FzIHJlY3JlYXRlZCBhbmQgZ290IGEgbmV3IGVuZHBvaW50LgoKIyMjIFN0ZXAgMTogR2V0IHRo" + + "ZSBuZXcgZW5kcG9pbnQKCmBgYGJhc2gKR0FURVdBWV9BRERSPSQoa3ViZWN0bCAtLWNvbnRleHQg" + + "PGNvbnRyb2wtcGxhbmUtY29udGV4dD4gZ2V0IGdhdGV3YXkgXAogIG52Y2YtZ2F0ZXdheSAtbiBl" + + "bnZveS1nYXRld2F5IFwKICAtbyBqc29ucGF0aD0ney5zdGF0dXMuYWRkcmVzc2VzWzBdLnZhbHVl" + + "fScpCnRlc3QgLW4gIiRHQVRFV0FZX0FERFIiCmBgYAoKIyMjIFN0ZXAgMjogVXBkYXRlIEROUyBh" + + "bmQgZGlyZWN0IGFkZHJlc3MgZmllbGRzCgpLZWVwIGBnbG9iYWwuZG9tYWluYCwgcm91dGUgaG9z" + + "dG5hbWVzLCBhbmQgQ0xJIEhvc3QgZmllbGRzIHVuY2hhbmdlZC4gUG9pbnQgdGhlCkROUyByZWNv" + + "cmRzIGZvciByZW5kZXJlZCByb3V0ZSBob3N0bmFtZXMsIHN1Y2ggYXMgYGFwaS48ZG9tYWluPmAg" + + "YW5kCmAqLmludm9jYXRpb24uPGRvbWFpbj5gLCB0byBgR0FURVdBWV9BRERSYC4gRm9yIGEgdGVt" + + "cG9yYXJ5IGVudmlyb25tZW50IHdpdGhvdXQKRE5TLCBrZWVwIGl0cyByZXNlcnZlZCByb3V0ZSBz" + + "dWZmaXggYW5kIGNvbm5lY3QgdG8gYEdBVEVXQVlfQUREUmAgd2l0aCB0aGUKbWF0Y2hpbmcgYEhv" + + "c3RgIGhlYWRlci4KCkZvciBhIHNwbGl0IGRlcGxveW1lbnQgY29uZmlndXJlZCB3aXRoIGRpcmVj" + + "dCBHYXRld2F5IGFkZHJlc3NlcywgcmVwbGFjZSBvbmx5CnRoZSBhZGRyZXNzLWJlYXJpbmcgdmFs" + + "dWVzOiBjb250cm9sLXBsYW5lIGBudmNmTmF0c1NlcnZpY2VVUkxgLCBjb21wdXRlLXBsYW5lCklD" + + "TVMsIFJlVmFsLCBhbmQgTkFUUyBVUkxzLCBhbmQgQ0xJIFVSTCBmaWVsZHMuIEtlZXAgdGhlaXIg" + + "ZG9tYWluIGFuZCBIb3N0Cm92ZXJyaWRlcyB1bmNoYW5nZWQuIFJlZnJlc2ggcmVnaXN0cmF0aW9u" + + "IGFuZCBpbnN0YWxsYXRpb24gdGhyb3VnaCB0aGUgc2FtZQpoYW5kb2ZmIHVzZWQgb3JpZ2luYWxs" + + "eS4gU2VlCltTcGxpdCBDb21wdXRlLVBsYW5lIEluc3RhbGxhdGlvbl0ocmVmZXJlbmNlcy9jb21w" + + "dXRlLXBsYW5lLWluc3RhbGxhdGlvbi5tZCkKZm9yIHRoZSBmaWVsZHMgYW5kIGNvbXBsZXRlIGNv" + + "bW1hbmRzLgoKIyMjIFN0ZXAgMzogVmVyaWZ5IGJvdGggY29udGV4dHMKCmBgYGJhc2gKZGlnICtz" + + "aG9ydCAiYXBpLjxkb21haW4+IgpjdXJsIC1IICJIb3N0OiBhcGkuPGRvbWFpbj4iICJodHRwOi8v" + + "JEdBVEVXQVlfQUREUi9oZWFsdGgiCmt1YmVjdGwgLS1jb250ZXh0IDxjb250cm9sLXBsYW5lLWNv" + + "bnRleHQ+IGdldCBnYXRld2F5IG52Y2YtZ2F0ZXdheSBcCiAgLW4gZW52b3ktZ2F0ZXdheSAtbyB3" + + "aWRlCmt1YmVjdGwgLS1jb250ZXh0IDxjb250cm9sLXBsYW5lLWNvbnRleHQ+IGdldCBodHRwcm91" + + "dGVzIC1BCmt1YmVjdGwgLS1jb250ZXh0IDxjb250cm9sLXBsYW5lLWNvbnRleHQ+IGdldCB0Y3By" + + "b3V0ZXMgLUEKa3ViZWN0bCAtLWNvbnRleHQgPGNvbXB1dGUtcGxhbmUtY29udGV4dD4gcm9sbG91" + + "dCBzdGF0dXMgXAogIGRlcGxveW1lbnQvbnZjYS1vcGVyYXRvciAtbiBudmNhLW9wZXJhdG9yIC0t" + + "dGltZW91dD0xMG0Ka3ViZWN0bCAtLWNvbnRleHQgPGNvbXB1dGUtcGxhbmUtY29udGV4dD4gd2Fp" + + "dCBcCiAgbnZjZmJhY2tlbmQvPGNvbXB1dGUtcGxhbmUtY2x1c3Rlci1uYW1lPiAtbiBudmNhLW9w" + + "ZXJhdG9yIFwKICAtLWZvcj1qc29ucGF0aD0ney5zdGF0dXMuYWdlbnRTdGF0dXN9Jz1oZWFsdGh5" + + "IC0tdGltZW91dD0xMG0KYGBgCgotLS0KCiMjIEV4YW1wbGUgNTogRGVwbG95IE9ubHkgRGVwZW5k" + + "ZW5jaWVzCgpVc2VmdWwgZm9yIHRlc3Rpbmcgb3Igd2hlbiBpdGVyYXRpbmcgb24gc2VydmljZSBj" + + "b25maWd1cmF0aW9uLgoKYGBgYmFzaAojIERlcGxveSBqdXN0IE5BVFMsIENhc3NhbmRyYSwgT3Bl" + + "bkJhbwpIRUxNRklMRV9FTlY9PGVudj4gaGVsbWZpbGUgLS1zZWxlY3RvciByZWxlYXNlLWdyb3Vw" + + "PWRlcGVuZGVuY2llcyBzeW5jCgojIENoZWNrIHN0YXR1cwprdWJlY3RsIGdldCBwb2RzIC1uIG5h" + + "dHMtc3lzdGVtCmt1YmVjdGwgZ2V0IHBvZHMgLW4gY2Fzc2FuZHJhLXN5c3RlbQprdWJlY3RsIGdl" + + "dCBwb2RzIC1uIHZhdWx0LXN5c3RlbQoKIyBEZXBsb3kganVzdCBvbmUgc3BlY2lmaWMgcmVsZWFz" + + "ZQpIRUxNRklMRV9FTlY9PGVudj4gaGVsbWZpbGUgLS1zZWxlY3RvciBuYW1lPWNhc3NhbmRyYSBz" + + "eW5jCmBgYAoKIyMjIFNlbGVjdG9yIHJlZmVyZW5jZQoKfCBTZWxlY3RvciB8IFJlbGVhc2VzIHwK" + + "fC0tLS0tLS0tLS18LS0tLS0tLS0tLXwKfCBgcmVsZWFzZS1ncm91cD1kZXBlbmRlbmNpZXNgIHwg" + + "bmF0cywgY2Fzc2FuZHJhLCBvcGVuYmFvLXNlcnZlciB8CnwgYHJlbGVhc2UtZ3JvdXA9c2Vydmlj" + + "ZXNgIHwgYXBpLWtleXMsIHNpcywgYXBpLCBpbnZvY2F0aW9uLXNlcnZpY2UsIGdycGMtcHJveHks" + + "IGVzcy1hcGksIG5vdGFyeS1zZXJ2aWNlLCByZXZhbCwgb3B0aW9uYWwgbGxtLXJlcXVlc3Qtcm91" + + "dGVyIGFuZCBsbG0tYXBpLWdhdGV3YXkgd2hlbiBgbGxtLmVuYWJsZWQ9dHJ1ZWAsIG9wdGlvbmFs" + + "IHZhbml0eS1nYXRld2F5IG9ubHkgaW4gc3RhY2sgcGFja2FnZXMgdGhhdCBpbmNsdWRlIHRoZSBh" + + "ZGRvbiBhbmQgaGF2ZSBgYWRkb25zLnZhbml0eUdhdGV3YXkuZW5hYmxlZD10cnVlYCwgb3B0aW9u" + + "YWwgbnZjZi11aSBvbmx5IGluIHN0YWNrIHBhY2thZ2VzIHRoYXQgaW5jbHVkZSB0aGUgYWRkb24g" + + "YW5kIGhhdmUgYGFkZG9ucy5udmNmVWkuZW5hYmxlZD10cnVlYCB8CnwgYG5hbWU9bGxtLXJlcXVl" + + "c3Qtcm91dGVyYCB8IERlcGxveSBqdXN0IHRoZSBMTE0gcmVxdWVzdCByb3V0ZXIgd2hlbiBgbGxt" + + "LmVuYWJsZWQ9dHJ1ZWAgfAp8IGBuYW1lPWxsbS1hcGktZ2F0ZXdheWAgfCBEZXBsb3kganVzdCB0" + + "aGUgTExNIEFQSSBnYXRld2F5IHdoZW4gYGxsbS5lbmFibGVkPXRydWVgIHwKfCBgbmFtZT12YW5p" + + "dHktZ2F0ZXdheWAgfCBEZXBsb3kganVzdCBWYW5pdHkgR2F0ZXdheSBvbmx5IHdoZW4gdGhlIHN0" + + "YWNrIHBhY2thZ2UgaW5jbHVkZXMgdGhhdCByZWxlYXNlIGFuZCBgYWRkb25zLnZhbml0eUdhdGV3" + + "YXkuZW5hYmxlZD10cnVlYCB8CnwgYG5hbWU9bnZjZi11aWAgfCBEZXBsb3kgTlZDRiBVSSBvbmx5" + + "IHdoZW4gdGhlIHN0YWNrIHBhY2thZ2UgaW5jbHVkZXMgdGhhdCByZWxlYXNlIGFuZCBgYWRkb25z" + + "Lm52Y2ZVaS5lbmFibGVkPXRydWVgIHwKfCBgcmVsZWFzZS1ncm91cD1pbmdyZXNzYCB8IGluZ3Jl" + + "c3MgKGdhdGV3YXkgcm91dGVzKSB8CnwgYG5hbWU9PHJlbGVhc2U+YCB8IEFueSBpbmRpdmlkdWFs" + + "IHJlbGVhc2UgYnkgbmFtZSB8CgpOb3RlOiBgYWRtaW4taXNzdWVyLXByb3h5YCBkb2VzIG5vdCBo" + + "YXZlIGEgcmVsZWFzZS1ncm91cCBsYWJlbC4gVGFyZ2V0IGl0IHdpdGggYC0tc2VsZWN0b3IgbmFt" + + "ZT1hZG1pbi1pc3N1ZXItcHJveHlgLgpQSwcIAlJOQH8oAAB/KAAAUEsDBBQACAAAAAAAIQAAAAAA" + + "AAAAAAAAAABMAAkAZGF0YS9udmNmLXNlbGYtbWFuYWdlZC1pbnN0YWxsYXRpb24vcmVmZXJlbmNl" + + "cy9jb21wdXRlLXBsYW5lLWluc3RhbGxhdGlvbi5tZFVUBQABAKbOEiMgU3BsaXQgQ29tcHV0ZS1Q" + + "bGFuZSBJbnN0YWxsYXRpb24KClRoZSBjb250cm9sIHBsYW5lIGFuZCBjb21wdXRlIHBsYW5lIGFy" + + "ZSBzZXBhcmF0ZSBzdGFja3MuIEluc3RhbGwgdGhlIGNvbnRyb2wKcGxhbmUgZmlyc3QsIHRoZW4g" + + "cmVnaXN0ZXIgYW5kIGluc3RhbGwgZWFjaCBjb21wdXRlIGNsdXN0ZXIuIENob29zZSBvbmUgaGFu" + + "ZG9mZgpiZWxvdyBhbmQgdXNlIGl0IGZvciB0aGUgZnVsbCBsaWZlY3ljbGUuIERvIG5vdCBjb21i" + + "aW5lIGEgQ0xJLWdlbmVyYXRlZCBwcm9maWxlCndpdGggdGhlIEhlbG1maWxlIHZhbHVlcyBmbG93" + + "LgoKIyMgQ2hvb3NlIGEgSGFuZG9mZgoKfCBGbG93IHwgU291cmNlIG9mIGNvbnRyb2wtcGxhbmUg" + + "ZW5kcG9pbnRzIHwgUmVnaXN0cmF0aW9uIGFydGlmYWN0IHwKfC0tLS0tLXwtLS0tLS0tLS0tLS0t" + + "LS0tLS0tLS0tLS0tLS0tLS0tLS0tLXwtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLXwKfCBIZWxtZmls" + + "ZSB2YWx1ZXMgfCBTZXBhcmF0ZSBjb250cm9sLXBsYW5lIGFuZCBjb21wdXRlLXBsYW5lIGVudmly" + + "b25tZW50IGZpbGVzIHwgYGRlcGxveS9zdGFja3MvbnZjZi1jb21wdXRlLXBsYW5lL3JlZ2lzdHJh" + + "dGlvbi88Y2x1c3Rlcj4tcmVnaXN0ZXItdmFsdWVzLnlhbWxgIHwKfCBDTEkgcHJvZmlsZSB8IENM" + + "SS1nZW5lcmF0ZWQgYGRlcGxveS9zdGFja3Mvc2VsZi1tYW5hZ2VkL291dC9jb250cm9sLXBsYW5l" + + "LXByb2ZpbGUueWFtbGAgfCBDTEktZ2VuZXJhdGVkIGBkZXBsb3kvc3RhY2tzL252Y2YtY29tcHV0" + + "ZS1wbGFuZS9vdXQvPGNsdXN0ZXI+LXJlZ2lzdGVyLXZhbHVlcy55YW1sYCB8CgpUaGUgQ0xJIHBy" + + "b2ZpbGUgaXMgbWFuZGF0b3J5IGZvciB0aGUgQ0xJIGZsb3cgYW5kIG11c3Qgbm90IGJlIGhhbmQt" + + "YXV0aG9yZWQuClRoZSBIZWxtZmlsZSBmbG93IGRvZXMgbm90IGNvbnN1bWUgYSBjb250cm9sLXBs" + + "YW5lIHByb2ZpbGUuCgpDb21tYW5kcyBiZWxvdyB1c2UgbW9ub3JlcG8gcGF0aHMgZnJvbSB0aGUg" + + "cmVwb3NpdG9yeSByb290LiBPcGVyYXRvcnMgdXNpbmcKZXh0cmFjdGVkIHBhY2thZ2VzIG5lZWQg" + + "bWF0Y2hpbmctdmVyc2lvbiBgbnZjZi1zZWxmLW1hbmFnZWQtc3RhY2tgIGFuZApgbnZjZi1jb21w" + + "dXRlLXBsYW5lLXN0YWNrYCBidW5kbGVzLiBTdWJzdGl0dXRlIHRob3NlIGJ1bmRsZSByb290cyBm" + + "b3IKYGRlcGxveS9zdGFja3Mvc2VsZi1tYW5hZ2VkYCBhbmQgYGRlcGxveS9zdGFja3MvbnZjZi1j" + + "b21wdXRlLXBsYW5lYC4KCiMjIEhlbG1maWxlIFZhbHVlcyBGbG93CgpDcmVhdGUgYm90aCBlbnZp" + + "cm9ubWVudCBmaWxlcyBiZWZvcmUgaW5zdGFsbGF0aW9uOgoKLSBgZGVwbG95L3N0YWNrcy9zZWxm" + + "LW1hbmFnZWQvZW52aXJvbm1lbnRzLzxlbnY+LnlhbWxgIGZvciBjb250cm9sLXBsYW5lCiAgcmVn" + + "aXN0cnksIGRvbWFpbiwgR2F0ZXdheSwgcm91dGVzLCBhbmQgc2VydmljZSBzZXR0aW5ncy4KLSBg" + + "ZGVwbG95L3N0YWNrcy9udmNmLWNvbXB1dGUtcGxhbmUvZW52aXJvbm1lbnRzLzxlbnY+LnlhbWxg" + + "IGZvciBjb21wdXRlLXBsYW5lCiAgcmVnaXN0cnksIHB1bGwgc2VjcmV0cywgYW5kIGNvbXB1dGUt" + + "cmVhY2hhYmxlIElDTVMsIFJlVmFsLCBhbmQgTkFUUyB2YWx1ZXMuCgpGb3IgRUtTLCB1c2UgdGhl" + + "IGNhbm9uaWNhbApbQ1NQIEVuZC10by1FbmQgRXhhbXBsZV0oaHR0cHM6Ly9kb2NzLm52aWRpYS5j" + + "b20vbnZjZi92MC42LjAtcmMvY3NwLWVuZC10by1lbmQtZXhhbXBsZSkuClRoZSBjb250cm9sLXBs" + + "YW5lIGVudmlyb25tZW50IGtlZXBzIHRoZSBFbnZveSBHYXRld2F5IGNvbnRyb2xsZXIgaW4KYGVu" + + "dm95LWdhdGV3YXktc3lzdGVtYCwgYXR0YWNoZXMgcm91dGVzIHRvIGBHYXRld2F5L252Y2YtZ2F0" + + "ZXdheWAgaW4KYGVudm95LWdhdGV3YXlgLCBhbmQgZW5hYmxlcyB0aGUgTkFUUyByb3V0ZS4gVGhl" + + "IGNvbXB1dGUtcGxhbmUgZW52aXJvbm1lbnQgdXNlcwp0aGUgZXh0ZXJuYWwgYWRkcmVzcyBwbHVz" + + "IHRoZSBzZXJ2aWNlIGhvc3Qgb3ZlcnJpZGVzLiBIZXJlLApgPGdhdGV3YXktYWRkcmVzcz5gIGlz" + + "IHRoZSBOTEIgYWRkcmVzcyBhbmQgYDxnYXRld2F5LWRvbWFpbj5gIGlzIHRoZSBETlMgYmFzZQp3" + + "aG9zZSBzZXJ2aWNlIHN1YmRvbWFpbnMgcmVzb2x2ZSB0byB0aGF0IE5MQjoKCmBgYHlhbWwKIyBk" + + "ZXBsb3kvc3RhY2tzL3NlbGYtbWFuYWdlZC9lbnZpcm9ubWVudHMvPGVudj4ueWFtbApnbG9iYWw6" + + "CiAgZG9tYWluOiAiPGdhdGV3YXktZG9tYWluPiIKICB3b3JrZXJFbmRwb2ludHM6CiAgICBudmNm" + + "U2VydmljZVVSTDogImh0dHA6Ly9hcGkuPGdhdGV3YXktZG9tYWluPiIKICAgIG52Y2ZHcnBjU2Vy" + + "dmljZVVSTDogImh0dHA6Ly93b3JrZXItYXBpLjxnYXRld2F5LWRvbWFpbj4iCiAgICBudmNmTmF0" + + "c1NlcnZpY2VVUkw6ICJuYXRzOi8vPGdhdGV3YXktYWRkcmVzcz46NDIyMiIKICAgIG52Y3RTZXJ2" + + "aWNlVVJMOiAiaHR0cDovL3Rhc2tzLjxnYXRld2F5LWRvbWFpbj4iCiAgICBudmN0R3JwY1NlcnZp" + + "Y2VVUkw6ICJodHRwOi8vd29ya2VyLXRhc2tzLjxnYXRld2F5LWRvbWFpbj4iCiAgICBpbnZvY2F0" + + "aW9uU2VydmljZVVSTDogImh0dHA6Ly9pbnZvY2F0aW9uLjxnYXRld2F5LWRvbWFpbj4iCgpncnBj" + + "cHJveHk6CiAgbnZjZkdycGNTZXJ2aWNlVVJMOiAiaHR0cDovL2FwaS5udmNmLnN2Yy5jbHVzdGVy" + + "LmxvY2FsOjkwOTAiCgppbmdyZXNzOgogIGdhdGV3YXlBcGk6CiAgICBjb250cm9sbGVyTmFtZXNw" + + "YWNlOiBlbnZveS1nYXRld2F5LXN5c3RlbQogICAgZ2F0ZXdheXM6CiAgICAgIHNoYXJlZDoge25h" + + "bWU6IG52Y2YtZ2F0ZXdheSwgbmFtZXNwYWNlOiBlbnZveS1nYXRld2F5fQogICAgICBncnBjOiB7" + + "bmFtZTogbnZjZi1nYXRld2F5LCBuYW1lc3BhY2U6IGVudm95LWdhdGV3YXl9CiAgICAgIG5hdHM6" + + "CiAgICAgICAgbmFtZTogbnZjZi1nYXRld2F5CiAgICAgICAgbmFtZXNwYWNlOiBlbnZveS1nYXRl" + + "d2F5CiAgICAgICAgbGlzdGVuZXJOYW1lOiBuYXRzCiAgICByb3V0ZXM6CiAgICAgIG52Y2ZBcGk6" + + "CiAgICAgICAgZ3JwYzoKICAgICAgICAgIGVuYWJsZWQ6IHRydWUKICAgICAgICAgIGhvc3RuYW1l" + + "czogWyJ3b3JrZXItYXBpLjxnYXRld2F5LWRvbWFpbj4iXQogICAgICBudmN0QXBpOgogICAgICAg" + + "IGdycGM6CiAgICAgICAgICBlbmFibGVkOiB0cnVlCiAgICAgICAgICBob3N0bmFtZXM6IFsid29y" + + "a2VyLXRhc2tzLjxnYXRld2F5LWRvbWFpbj4iXQogICAgICBuYXRzOgogICAgICAgIGVuYWJsZWQ6" + + "IHRydWUKCm9wZW5iYW86CiAgbWlncmF0aW9uczoKICAgIGlzc3VlckRpc2NvdmVyeToKICAgICAg" + + "ZW5hYmxlZDogdHJ1ZQpgYGAKCmBgYHlhbWwKIyBkZXBsb3kvc3RhY2tzL252Y2YtY29tcHV0ZS1w" + + "bGFuZS9lbnZpcm9ubWVudHMvPGVudj4ueWFtbApnbG9iYWw6CiAgbnZjYU9wZXJhdG9yOgogICAg" + + "c2VsZk1hbmFnZWQ6CiAgICAgIGljbXNTZXJ2aWNlVVJMOiAiaHR0cDovLzxnYXRld2F5LWFkZHJl" + + "c3M+IgogICAgICBpY21zU2VydmljZUhvc3RIZWFkZXJPdmVycmlkZTogInNpcy48Z2F0ZXdheS1k" + + "b21haW4+IgogICAgICByZXZhbFNlcnZpY2VVUkw6ICJodHRwOi8vPGdhdGV3YXktYWRkcmVzcz4i" + + "CiAgICAgIHJldmFsU2VydmljZUhvc3RIZWFkZXJPdmVycmlkZTogInJldmFsLjxnYXRld2F5LWRv" + + "bWFpbj4iCiAgICAgIG5hdHNVUkw6ICJuYXRzOi8vPGdhdGV3YXktYWRkcmVzcz46NDIyMiIKICAg" + + "ICAgbmF0c0hvc3RPdmVycmlkZTogIm5hdHMuPGdhdGV3YXktZG9tYWluPiIKYGBgCgpQcmV2aWV3" + + "IGFuZCBpbnN0YWxsIHRoZSBjb250cm9sIHBsYW5lIGFnYWluc3QgaXRzIGNvbnRleHQ6CgpgYGBi" + + "YXNoCm1ha2UgLUMgZGVwbG95L3N0YWNrcy9zZWxmLW1hbmFnZWQgdGVtcGxhdGUgXAogIEhFTE1G" + + "SUxFX0VOVj08ZW52PiBcCiAgS1VCRUNPTkZJR19GSUxFPTxjb250cm9sLXBsYW5lLWt1YmVjb25m" + + "aWc+CgptYWtlIC1DIGRlcGxveS9zdGFja3Mvc2VsZi1tYW5hZ2VkIGluc3RhbGwgXAogIEhFTE1G" + + "SUxFX0VOVj08ZW52PiBcCiAgS1VCRUNPTkZJR19GSUxFPTxjb250cm9sLXBsYW5lLWt1YmVjb25m" + + "aWc+CmBgYAoKQmVmb3JlIHJlZ2lzdGVyaW5nIHRocm91Z2ggYSBiYXJlIEdhdGV3YXkgYWRkcmVz" + + "cywgY3JlYXRlIG9yIHVwZGF0ZSB0aGUgQ0xJCmNvbmZpZyBwYXNzZWQgYXMgYE5WQ0ZfQ0xJX0NP" + + "TkZJR2A6CgpgYGB5YW1sCmJhc2VfaHR0cF91cmw6ICJodHRwOi8vPGdhdGV3YXktYWRkcmVzcz4i" + + "Cmludm9rZV91cmw6ICJodHRwOi8vPGdhdGV3YXktYWRkcmVzcz4iCmJhc2VfZ3JwY191cmw6ICI8" + + "Z2F0ZXdheS1hZGRyZXNzPjoxMDA4MSIKYXBpX2tleXNfc2VydmljZV91cmw6ICJodHRwOi8vPGdh" + + "dGV3YXktYWRkcmVzcz4iCmljbXNfdXJsOiAiaHR0cDovLzxnYXRld2F5LWFkZHJlc3M+IgphcGlf" + + "aG9zdDogImFwaS48Z2F0ZXdheS1kb21haW4+IgphcGlfa2V5c19ob3N0OiAiYXBpLWtleXMuPGdh" + + "dGV3YXktZG9tYWluPiIKaW52b2tlX2hvc3Q6ICJpbnZvY2F0aW9uLjxnYXRld2F5LWRvbWFpbj4i" + + "CmljbXNfaG9zdDogInNpcy48Z2F0ZXdheS1kb21haW4+IgpgYGAKCkhvc3QgZmllbGRzIGNvbnRh" + + "aW4gaG9zdG5hbWVzIG9ubHksIHdpdGhvdXQgYSBVUkwgc2NoZW1lLiBgSUNNU19VUkxgIG1hcHMg" + + "b25seQp0byB0aGUgcmVnaXN0cmF0aW9uIGNvbW1hbmQncyBgLS1pY21zLXVybGA7IGBpY21zX2hv" + + "c3RgIGluIHRoZSBjb25maWcgc3VwcGxpZXMKdGhlIEdhdGV3YXkgSG9zdCBoZWFkZXIuIFRoZXJl" + + "IGlzIG5vIGAtLWljbXMtaG9zdGAgTWFrZSBvciBDTEkgZmxhZy4KClJlZ2lzdGVyIGZyb20gdGhl" + + "IGNvbXB1dGUgY29udGV4dCwgdGhlbiBpbnN0YWxsIHRoZSBjb21wdXRlIHBsYW5lOgoKYGBgYmFz" + + "aAptYWtlIC1DIGRlcGxveS9zdGFja3MvbnZjZi1jb21wdXRlLXBsYW5lIHJlZ2lzdGVyLWNsdXN0" + + "ZXIgXAogIENMVVNURVJfTkFNRT08Y2x1c3Rlci1uYW1lPiBcCiAgTkNBX0lEPTxuY2EtaWQ+IFwK" + + "ICBDTFVTVEVSX1JFR0lPTj08cmVnaW9uPiBcCiAgSUNNU19VUkw9aHR0cDovLzxnYXRld2F5LWFk" + + "ZHJlc3M+IFwKICBLVUJFQ09ORklHX0ZJTEU9PGNvbXB1dGUtcGxhbmUta3ViZWNvbmZpZz4gXAog" + + "IE5WQ0ZfQ0xJPTxwYXRoLXRvLW52Y2YtY2xpPiBcCiAgTlZDRl9DTElfQ09ORklHPTxwYXRoLXRv" + + "LW52Y2YtY2xpLWNvbmZpZz4KCm1ha2UgLUMgZGVwbG95L3N0YWNrcy9udmNmLWNvbXB1dGUtcGxh" + + "bmUgaW5zdGFsbCBcCiAgQ0xVU1RFUl9OQU1FPTxjbHVzdGVyLW5hbWU+IFwKICBIRUxNRklMRV9F" + + "TlY9PGVudj4gXAogIEtVQkVDT05GSUdfRklMRT08Y29tcHV0ZS1wbGFuZS1rdWJlY29uZmlnPgpg" + + "YGAKClJlZ2lzdHJhdGlvbiBkaXNjb3ZlcnMgdGhlIE9JREMgaXNzdWVyIGFuZCBKV0tTIGZyb20g" + + "dGhlIGNvbXB1dGUga3ViZSBjb250ZXh0LgpJbiBhIG11bHRpLWNsdXN0ZXIgZGVwbG95bWVudCwg" + + "YEtVQkVDT05GSUdfRklMRWAgaXMgcmVxdWlyZWQgb24gYm90aApjb21wdXRlLXBsYW5lIGNvbW1h" + + "bmRzLiBJbiBhIHNhbWUtY2x1c3RlciBkZXBsb3ltZW50IGl0IG1heSBiZSBvbWl0dGVkIG9ubHkK" + + "d2hlbiB0aGUgYW1iaWVudCBjb250ZXh0IGlzIGFscmVhZHkgdGhlIHRhcmdldCBjbHVzdGVyLgoK" + + "IyMgQ0xJIFByb2ZpbGUgRmxvdwoKUnVuIHRoZSBDTEkgY29udHJvbC1wbGFuZSBpbnN0YWxsIGZp" + + "cnN0LiBJdCBjcmVhdGVzIHRoZSBwcm9maWxlIGNvbnN1bWVkIGJ5CmNvbXB1dGUtcGxhbmUgcmVn" + + "aXN0cmF0aW9uOgoKYGBgYmFzaApudmNmLWNsaSAtLWNvbmZpZyA8Y29uZmlnPiBzZWxmLWhvc3Rl" + + "ZCBcCiAgLS1jb250cm9sLXBsYW5lLXN0YWNrIGRlcGxveS9zdGFja3Mvc2VsZi1tYW5hZ2VkIFwK" + + "ICAtLWNvbXB1dGUtcGxhbmUtc3RhY2sgZGVwbG95L3N0YWNrcy9udmNmLWNvbXB1dGUtcGxhbmUg" + + "XAogIC0tZW52IDxlbnY+IFwKICAtLXBsYWluIFwKICAtLWNvbnRyb2wtcGxhbmUtY29udGV4dCA8" + + "Y29udHJvbC1wbGFuZS1jb250ZXh0PiBcCiAgLS1jb21wdXRlLXBsYW5lLWNvbnRleHQgPGNvbXB1" + + "dGUtcGxhbmUtY29udGV4dD4gXAogIGluc3RhbGwgLS1jb250cm9sLXBsYW5lIFwKICAtLWNsdXN0" + + "ZXItbmFtZSA8Y29udHJvbC1wbGFuZS1jbHVzdGVyLW5hbWU+IFwKICAtLXJlZ2lvbiA8cmVnaW9u" + + "PiBcCiAgLS1uY2EtaWQgPG5jYS1pZD4KCnRlc3QgLXMgZGVwbG95L3N0YWNrcy9zZWxmLW1hbmFn" + + "ZWQvb3V0L2NvbnRyb2wtcGxhbmUtcHJvZmlsZS55YW1sCmBgYAoKVXNlIHRoZSBmdWxsIHBlcnNp" + + "c3RlbnQgcHJlZml4IGZvciBib3RoIGNvbXB1dGUtcGxhbmUgY29tbWFuZHM6CgpgYGBiYXNoCm52" + + "Y2YtY2xpIC0tY29uZmlnIDxjb25maWc+IHNlbGYtaG9zdGVkIFwKICAtLWNvbnRyb2wtcGxhbmUt" + + "c3RhY2sgZGVwbG95L3N0YWNrcy9zZWxmLW1hbmFnZWQgXAogIC0tY29tcHV0ZS1wbGFuZS1zdGFj" + + "ayBkZXBsb3kvc3RhY2tzL252Y2YtY29tcHV0ZS1wbGFuZSBcCiAgLS1lbnYgPGVudj4gXAogIC0t" + + "cGxhaW4gXAogIGNvbXB1dGUtcGxhbmUgcmVnaXN0ZXIgXAogIC0tY29udHJvbC1wbGFuZS1wcm9m" + + "aWxlIGRlcGxveS9zdGFja3Mvc2VsZi1tYW5hZ2VkL291dC9jb250cm9sLXBsYW5lLXByb2ZpbGUu" + + "eWFtbCBcCiAgLS1jbHVzdGVyLW5hbWUgPGNvbXB1dGUtcGxhbmUtY2x1c3Rlci1uYW1lPiBcCiAg" + + "LS1rdWJlLWNvbnRleHQgPGNvbXB1dGUtcGxhbmUtY29udGV4dD4gXAogIC0tcmVnaW9uIDxyZWdp" + + "b24+IFwKICAtLW91dHB1dCBkZXBsb3kvc3RhY2tzL252Y2YtY29tcHV0ZS1wbGFuZS9vdXQvPGNv" + + "bXB1dGUtcGxhbmUtY2x1c3Rlci1uYW1lPi1yZWdpc3Rlci12YWx1ZXMueWFtbAoKbnZjZi1jbGkg" + + "LS1jb25maWcgPGNvbmZpZz4gc2VsZi1ob3N0ZWQgXAogIC0tY29udHJvbC1wbGFuZS1zdGFjayBk" + + "ZXBsb3kvc3RhY2tzL3NlbGYtbWFuYWdlZCBcCiAgLS1jb21wdXRlLXBsYW5lLXN0YWNrIGRlcGxv" + + "eS9zdGFja3MvbnZjZi1jb21wdXRlLXBsYW5lIFwKICAtLWVudiA8ZW52PiBcCiAgLS1wbGFpbiBc" + + "CiAgY29tcHV0ZS1wbGFuZSBpbnN0YWxsIFwKICAtLXZhbHVlcyBkZXBsb3kvc3RhY2tzL252Y2Yt" + + "Y29tcHV0ZS1wbGFuZS9vdXQvPGNvbXB1dGUtcGxhbmUtY2x1c3Rlci1uYW1lPi1yZWdpc3Rlci12" + + "YWx1ZXMueWFtbCBcCiAgLS1rdWJlLWNvbnRleHQgPGNvbXB1dGUtcGxhbmUtY29udGV4dD4gXAog" + + "IC0tY2x1c3Rlci1uYW1lIDxjb21wdXRlLXBsYW5lLWNsdXN0ZXItbmFtZT4KYGBgCgpSZWdpc3Ry" + + "YXRpb24gc2VsZWN0cyB0aGUgcHJvZmlsZSdzIGluLWNsdXN0ZXIgb3IgY29tcHV0ZS1yZWFjaGFi" + + "bGUgZW5kcG9pbnRzCmZyb20gdGhlIGNvbXB1dGUgY29udGV4dCBhbmQgcHJvYmVzIGl0cyBKV0tT" + + "LiBEbyBub3QgcmVwbGFjZSBwcm9maWxlIGVuZHBvaW50cwp3aXRoIGhhbmQtYXV0aG9yZWQgSGVs" + + "bWZpbGUgZW5kcG9pbnQgdmFsdWVzLgoKIyMgUHVsbCBTZWNyZXRzCgpDcmVhdGUgdGhlIGNvbnRy" + + "b2wtcGxhbmUgc2VjcmV0IGluIHRoZXNlIG5hbWVzcGFjZXMgb24gdGhlIGNvbnRyb2wtcGxhbmUK" + + "Y29udGV4dDoKCmBgYHRleHQKY2Fzc2FuZHJhLXN5c3RlbSBuYXRzLXN5c3RlbSBudmNmIGFwaS1r" + + "ZXlzIGVzcyBzaXMgdmF1bHQtc3lzdGVtIGNlcnQtbWFuYWdlcgpgYGAKCk9uIHRoZSBjb21wdXRl" + + "IGNvbnRleHQsIGNyZWF0ZSB0aGUgc2VjcmV0IG9ubHkgaW4gYG52Y2Etb3BlcmF0b3JgIGFuZCBy" + + "ZWZlcmVuY2UKaXQgdGhyb3VnaCBgZ2xvYmFsLmltYWdlUHVsbFNlY3JldHNgIGluIHRoZSBjb21w" + + "dXRlLXBsYW5lIGVudmlyb25tZW50LiBUaGUgY2hhcnQKYW5kIG9wZXJhdG9yIHVzZSBpdCBpbiBg" + + "bnZjYS1vcGVyYXRvcmAgYW5kIG1pcnJvciBpdCB0byBgbnZjYS1zeXN0ZW1gLiBEbyBub3QgYWRk" + + "CmVpdGhlciBuYW1lc3BhY2UgdG8gdGhlIGNvbnRyb2wtcGxhbmUgbGlzdC4gRm9yIGNvbW1hbmRz" + + "IGFuZCBwb2xpY3kgZXhhbXBsZXMsCnNlZSBbcHVsbC1zZWNyZXRzLm1kXShwdWxsLXNlY3JldHMu" + + "bWQpLgoKIyMgVmVyaWZpY2F0aW9uCgpVc2UgdGhlIGV4cGxpY2l0IEdhdGV3YXkgbmFtZSBhbmQg" + + "bmFtZXNwYWNlOgoKYGBgYmFzaAprdWJlY3RsIC0tY29udGV4dCA8Y29udHJvbC1wbGFuZS1jb250" + + "ZXh0PiBnZXQgZ2F0ZXdheSBudmNmLWdhdGV3YXkgXAogIC1uIGVudm95LWdhdGV3YXkgLW8gd2lk" + + "ZQprdWJlY3RsIC0tY29udGV4dCA8Y29udHJvbC1wbGFuZS1jb250ZXh0PiBnZXQgdGNwcm91dGUg" + + "LW4gZW52b3ktZ2F0ZXdheQprdWJlY3RsIC0tY29udGV4dCA8Y29tcHV0ZS1wbGFuZS1jb250ZXh0" + + "PiByb2xsb3V0IHN0YXR1cyBcCiAgZGVwbG95bWVudC9udmNhLW9wZXJhdG9yIC1uIG52Y2Etb3Bl" + + "cmF0b3IgLS10aW1lb3V0PTEwbQprdWJlY3RsIC0tY29udGV4dCA8Y29tcHV0ZS1wbGFuZS1jb250" + + "ZXh0PiB3YWl0IFwKICBudmNmYmFja2VuZC88Y29tcHV0ZS1wbGFuZS1jbHVzdGVyLW5hbWU+IC1u" + + "IG52Y2Etb3BlcmF0b3IgXAogIC0tZm9yPWpzb25wYXRoPSd7LnN0YXR1cy5hZ2VudFN0YXR1c30n" + + "PWhlYWx0aHkgLS10aW1lb3V0PTEwbQprdWJlY3RsIC0tY29udGV4dCA8Y29tcHV0ZS1wbGFuZS1j" + + "b250ZXh0PiBnZXQgc2VjcmV0IDxwdWxsLXNlY3JldD4gLW4gbnZjYS1zeXN0ZW0KYGBgCgojIyBU" + + "ZWFyZG93bgoKRGVzdHJveSBhbmQgZGVyZWdpc3RlciBldmVyeSBjb21wdXRlIHBsYW5lIGJlZm9y" + + "ZSB0aGUgY29udHJvbCBwbGFuZS4gQm90aApoYW5kb2ZmcyBjYW4gZGVzdHJveSB0aGUgY29udHJv" + + "bCBwbGFuZSwgc28gYXBwbHkgdGhpcyBwcmVmbGlnaHQgYmVmb3JlIGVpdGhlcgpvbmUuIFByZXNl" + + "cnZlIHRoZSBgY2VydC1tYW5hZ2VyYCBuYW1lc3BhY2UgYnkgZGVmYXVsdC4gTmFtZXNwYWNlIHBy" + + "ZXNlcnZhdGlvbgpkb2VzIG5vdCBwcmVzZXJ2ZSB0aGUgSGVsbSByZWxlYXNlLiBJZGVudGlmeSB3" + + "aGV0aGVyIGNlcnQtbWFuYWdlciBpcyBleHRlcm5hbC4KRm9yIGFuIGV4dGVybmFsIGluc3RhbGxh" + + "dGlvbiwgcmVxdWlyZSBlZmZlY3RpdmUgYGNlcnRNYW5hZ2VyLmVuYWJsZWQ6IGZhbHNlYAphbmQg" + + "YWJvcnQgaWYgaXQgaXMgdHJ1ZS4gRm9yIGFuIGludGVuZGVkIHN0YWNrLW1hbmFnZWQgcmVsZWFz" + + "ZSB3aXRoIGVmZmVjdGl2ZQpgY2VydE1hbmFnZXIuZW5hYmxlZDogdHJ1ZWAsIHZlcmlmeSBtYXRj" + + "aGluZyBzdGFjayBIZWxtIHJlbGVhc2UgbWV0YWRhdGEgYW5kCmFib3J0IG9uIG1pc3Npbmcgb3Ig" + + "bWlzbWF0Y2hlZCBldmlkZW5jZS4gT25seSBwbGFuIG5hbWVzcGFjZSByZW1vdmFsIGFmdGVyCnZl" + + "cmlmeWluZyBuYW1lc3BhY2UgcHJvdmVuYW5jZSBhbmQgZ2V0dGluZyBleHBsaWNpdCBjb25maXJt" + + "YXRpb247IG90aGVyd2lzZQpkbyBub3QgZGVsZXRlIGl0LgoKRm9yIHRoZSBIZWxtZmlsZSB2YWx1" + + "ZXMgZmxvdywgcmV0YWluIGVhY2ggcmVnaXN0cmF0aW9uIHZhbHVlcyBmaWxlIHVudGlsCmNsZWFu" + + "dXAgaXMgdmVyaWZpZWQ6CgpgYGBiYXNoCm1ha2UgLUMgZGVwbG95L3N0YWNrcy9udmNmLWNvbXB1" + + "dGUtcGxhbmUgZGVzdHJveSBcCiAgQ0xVU1RFUl9OQU1FPTxjbHVzdGVyLW5hbWU+IFwKICBIRUxN" + + "RklMRV9FTlY9PGVudj4gXAogIEtVQkVDT05GSUdfRklMRT08Y29tcHV0ZS1wbGFuZS1rdWJlY29u" + + "ZmlnPgoKPG52Y2YtY2xpPiAtLWNvbmZpZyA8Y29uZmlnPiBjbHVzdGVyIGRlbGV0ZSBcCiAgLS1j" + + "bHVzdGVyLWlkIDxjbHVzdGVyLWlkLWZyb20tcmVnaXN0cmF0aW9uLXZhbHVlcz4gXAogIC0tbmNh" + + "LWlkIDxuY2EtaWQ+IFwKICAtLWlnbm9yZS1taXNzaW5nCmBgYAoKUmVhZCBgY2x1c3RlcklEYCBh" + + "bmQgYG5jYUlEYCBmcm9tCmBkZXBsb3kvc3RhY2tzL252Y2YtY29tcHV0ZS1wbGFuZS9yZWdpc3Ry" + + "YXRpb24vPGNsdXN0ZXItbmFtZT4tcmVnaXN0ZXItdmFsdWVzLnlhbWxgLgpTaG93IHRoZSBleGFj" + + "dCBjbHVzdGVyIElEIGFuZCBnZXQgY29uZmlybWF0aW9uIGJlZm9yZSBgY2x1c3RlciBkZWxldGVg" + + "LiBSZXBlYXQKY29tcHV0ZSBkZXN0cm95IGFuZCBkZXJlZ2lzdHJhdGlvbiBmb3IgZXZlcnkgY29t" + + "cHV0ZSBjbHVzdGVyLCB0aGVuIGRlc3Ryb3kgdGhlCmNvbnRyb2wgcGxhbmUuCgpgYGBiYXNoCktV" + + "QkVDT05GSUc9PGNvbnRyb2wtcGxhbmUta3ViZWNvbmZpZz4gXAptYWtlIC1DIGRlcGxveS9zdGFj" + + "a3Mvc2VsZi1tYW5hZ2VkIGRlc3Ryb3kgXAogIEhFTE1GSUxFX0VOVj08ZW52PiBcCiAgS1VCRUNP" + + "TkZJR19GSUxFPTxjb250cm9sLXBsYW5lLWt1YmVjb25maWc+CmBgYAoKQm90aCBgS1VCRUNPTkZJ" + + "R2AgYW5kIGBLVUJFQ09ORklHX0ZJTEVgIGFyZSByZXF1aXJlZCBvbiB0aGUgY29udHJvbC1wbGFu" + + "ZQpkZXN0cm95IGJlY2F1c2UgaXRzIG5hbWVzcGFjZSBjbGVhbnVwIHVzZXMgYW1iaWVudCBga3Vi" + + "ZWN0bGAuCgpGb3IgdGhlIENMSSBwcm9maWxlIGZsb3csIGtlZXAKYGRlcGxveS9zdGFja3MvbnZj" + + "Zi1jb21wdXRlLXBsYW5lL291dC88Y2x1c3Rlci1uYW1lPi1yZWdpc3Rlci12YWx1ZXMueWFtbGAK" + + "dW50aWwgdGVhcmRvd24gY29tcGxldGVzIGJlY2F1c2UgYGRvd25gIHJlYWRzIGl0cyBjbHVzdGVy" + + "IElELiBGaXJzdCBxdWVyeSB0aGUKbGl2ZSByZWdpc3RyYXRpb24gc2V0IHdpdGggdGhlIHNhbWUg" + + "Y29tcGxldGUgcGVyc2lzdGVudCBwcmVmaXg6CgpgYGBiYXNoCm52Y2YtY2xpIC0tY29uZmlnIDxj" + + "b25maWc+IHNlbGYtaG9zdGVkIFwKICAtLWNvbnRyb2wtcGxhbmUtc3RhY2sgZGVwbG95L3N0YWNr" + + "cy9zZWxmLW1hbmFnZWQgXAogIC0tY29tcHV0ZS1wbGFuZS1zdGFjayBkZXBsb3kvc3RhY2tzL252" + + "Y2YtY29tcHV0ZS1wbGFuZSBcCiAgLS1lbnYgPGVudj4gXAogIC0tcGxhaW4gXAogIC0tY29udHJv" + + "bC1wbGFuZS1jb250ZXh0IDxjb250cm9sLXBsYW5lLWNvbnRleHQ+IFwKICAtLWNvbXB1dGUtcGxh" + + "bmUtY29udGV4dCA8Y29tcHV0ZS1wbGFuZS1jb250ZXh0PiBcCiAgLS1pY21zLXVybCA8Y29tcHV0" + + "ZS1yZWFjaGFibGUtaWNtcy11cmw+IFwKICBzdGF0dXMgXAogIC0tY2x1c3Rlci1uYW1lIDxjb21w" + + "dXRlLXBsYW5lLWNsdXN0ZXItbmFtZT4gXAogIC0tbmNhLWlkIDxuY2EtaWQ+CmBgYAoKU2hvdyB0" + + "aGUgcmVnaXN0ZXJlZCBjb21wdXRlLXBsYW5lIGxpc3QuIE5hbWVkLWNsdXN0ZXIgYGRvd24gLS1w" + + "bGFuLW9ubHlgIGRvZXMKbm90IHF1ZXJ5IElDTVMsIHNvIGl0IHByZXZpZXdzIG9ubHkgdGhhdCBj" + + "b21wdXRlIHBsYW5lIGFuZCBjYW5ub3Qgc2hvdyB0aGUKY29uZGl0aW9uYWwgY29udHJvbC1wbGFu" + + "ZSByZW1vdmFsLiBJZiB0aGUgdGFyZ2V0IGlzIHRoZSBsYXN0IHJlZ2lzdGVyZWQKY2x1c3Rlciwg" + + "cmVhbCBgZG93bmAgYWxzbyBkZXN0cm95cyB0aGUgY29udHJvbCBwbGFuZS4gR2V0IGV4cGxpY2l0" + + "IGNvbmZpcm1hdGlvbgpmb3IgYm90aCByZW1vdmFscyBiZWZvcmUgY29udGludWluZy4gVGhlbiBw" + + "cmV2aWV3IGFuZCBleGVjdXRlIHdpdGggdGhlIHNhbWUKcHJlZml4OgoKYGBgYmFzaApudmNmLWNs" + + "aSAtLWNvbmZpZyA8Y29uZmlnPiBzZWxmLWhvc3RlZCBcCiAgLS1jb250cm9sLXBsYW5lLXN0YWNr" + + "IGRlcGxveS9zdGFja3Mvc2VsZi1tYW5hZ2VkIFwKICAtLWNvbXB1dGUtcGxhbmUtc3RhY2sgZGVw" + + "bG95L3N0YWNrcy9udmNmLWNvbXB1dGUtcGxhbmUgXAogIC0tZW52IDxlbnY+IFwKICAtLXBsYWlu" + + "IFwKICAtLWNvbnRyb2wtcGxhbmUtY29udGV4dCA8Y29udHJvbC1wbGFuZS1jb250ZXh0PiBcCiAg" + + "LS1jb21wdXRlLXBsYW5lLWNvbnRleHQgPGNvbXB1dGUtcGxhbmUtY29udGV4dD4gXAogIC0taWNt" + + "cy11cmwgPGNvbXB1dGUtcmVhY2hhYmxlLWljbXMtdXJsPiBcCiAgZG93biAtLXBsYW4tb25seSBc" + + "CiAgLS1jbHVzdGVyLW5hbWUgPGNvbXB1dGUtcGxhbmUtY2x1c3Rlci1uYW1lPiBcCiAgLS1uY2Et" + + "aWQgPG5jYS1pZD4KCm52Y2YtY2xpIC0tY29uZmlnIDxjb25maWc+IHNlbGYtaG9zdGVkIFwKICAt" + + "LWNvbnRyb2wtcGxhbmUtc3RhY2sgZGVwbG95L3N0YWNrcy9zZWxmLW1hbmFnZWQgXAogIC0tY29t" + + "cHV0ZS1wbGFuZS1zdGFjayBkZXBsb3kvc3RhY2tzL252Y2YtY29tcHV0ZS1wbGFuZSBcCiAgLS1l" + + "bnYgPGVudj4gXAogIC0tcGxhaW4gXAogIC0tY29udHJvbC1wbGFuZS1jb250ZXh0IDxjb250cm9s" + + "LXBsYW5lLWNvbnRleHQ+IFwKICAtLWNvbXB1dGUtcGxhbmUtY29udGV4dCA8Y29tcHV0ZS1wbGFu" + + "ZS1jb250ZXh0PiBcCiAgLS1pY21zLXVybCA8Y29tcHV0ZS1yZWFjaGFibGUtaWNtcy11cmw+IFwK" + + "ICBkb3duIFwKICAtLWNsdXN0ZXItbmFtZSA8Y29tcHV0ZS1wbGFuZS1jbHVzdGVyLW5hbWU+IFwK" + + "ICAtLW5jYS1pZCA8bmNhLWlkPgpgYGAKClJlcGVhdCBgZG93bmAgZm9yIGVhY2ggY29tcHV0ZSBj" + + "bHVzdGVyLiBFYWNoIHJ1biBkZXN0cm95cyB0aGF0IGNvbXB1dGUgcGxhbmUgYW5kCnVucmVnaXN0" + + "ZXJzIGl0cyBJQ01TIHJvdy4gSXQgcmVtb3ZlcyB0aGUgY29udHJvbCBwbGFuZSBvbmx5IGFmdGVy" + + "IG5vIGNsdXN0ZXIKcmVnaXN0cmF0aW9ucyByZW1haW4uClBLBwiWY7xZEjAAABIwAABQSwMEFAAI" + + "AAAAAAAhAAAAAAAAAAAAAAAAADsACQBkYXRhL252Y2Ytc2VsZi1tYW5hZ2VkLWluc3RhbGxhdGlv" + + "bi9yZWZlcmVuY2VzL2RlYnVnZ2luZy5tZFVUBQABAKbOEiMgRGVidWdnaW5nIFJlZmVyZW5jZQoK" + + "UmVjaXBlcyBmb3IgZGlhZ25vc2luZyBhbmQgZml4aW5nIGNvbW1vbiBOVkNGIHNlbGYtbWFuYWdl" + + "ZCBzdGFjayBmYWlsdXJlcy4KCiMjIFF1aWNrIFN0YXR1cyBDb21tYW5kcwoKYGBgYmFzaAojIEFs" + + "bCBwb2RzIGFjcm9zcyBhbGwgbmFtZXNwYWNlcwprdWJlY3RsIGdldCBwb2RzIC1BIC1vIHdpZGUK" + + "CiMgUG9kcyBpbiBhIHNwZWNpZmljIG5hbWVzcGFjZQprdWJlY3RsIGdldCBwb2RzIC1uIDxuYW1l" + + "c3BhY2U+CgojIEFsbCBoZWxtIHJlbGVhc2VzCmhlbG0gbGlzdCAtQQoKIyBSZWNlbnQgZXZlbnRz" + + "IChtb3N0IHVzZWZ1bCBmb3IgZGlhZ25vc2luZyBmYWlsdXJlcykKa3ViZWN0bCBnZXQgZXZlbnRz" + + "IC1uIDxuYW1lc3BhY2U+IC0tc29ydC1ieT0nLmxhc3RUaW1lc3RhbXAnCgojIERlc2NyaWJlIGEg" + + "c3BlY2lmaWMgcG9kIChzaG93cyBldmVudHMsIGNvbmRpdGlvbnMsIHZvbHVtZXMpCmt1YmVjdGwg" + + "ZGVzY3JpYmUgcG9kIC1uIDxuYW1lc3BhY2U+IDxwb2QtbmFtZT4KYGBgCgojIyBGYWlsdXJlOiBJ" + + "bWFnZVB1bGxCYWNrT2ZmCgojIyMgU3ltcHRvbXMKCmBgYApOQU1FICAgICAgICAgICBSRUFEWSAg" + + "IFNUQVRVUyAgICAgICAgICAgICBSRVNUQVJUUyAgIEFHRQpjYXNzYW5kcmEtMCAgICAwLzEgICAg" + + "IEltYWdlUHVsbEJhY2tPZmYgICAwICAgICAgICAgIDVtCmBgYAoKRXZlbnRzIHNob3c6CmBgYApG" + + "YWlsZWQgdG8gcHVsbCBpbWFnZSAibnZjci5pby8uLi4vaW1hZ2U6dGFnIjogNDAxIFVuYXV0aG9y" + + "aXplZApgYGAKCiMjIyBEaWFnbm9zaXMKCmBgYGJhc2gKIyBDaGVjayB3aGF0IGltYWdlIGlzIGZh" + + "aWxpbmcKa3ViZWN0bCBkZXNjcmliZSBwb2QgLW4gPG5hbWVzcGFjZT4gPHBvZC1uYW1lPiB8IGdy" + + "ZXAgLUE1ICJFdmVudHM6IgoKIyBDaGVjayBpZiBwdWxsIHNlY3JldCBleGlzdHMgaW4gdGhlIG5h" + + "bWVzcGFjZQprdWJlY3RsIGdldCBzZWNyZXQgbnZjci1jcmVkcyAtbiA8bmFtZXNwYWNlPgoKIyBD" + + "aGVjayBpZiB0aGUgcG9kIHNwZWMgaGFzIGltYWdlUHVsbFNlY3JldHMKa3ViZWN0bCBnZXQgcG9k" + + "IC1uIDxuYW1lc3BhY2U+IDxwb2QtbmFtZT4gLW8ganNvbnBhdGg9J3suc3BlYy5pbWFnZVB1bGxT" + + "ZWNyZXRzfScKCiMgQ2hlY2sgaWYgdGhlIFNlcnZpY2VBY2NvdW50IGhhcyBpbWFnZVB1bGxTZWNy" + + "ZXRzCmt1YmVjdGwgZ2V0IHNhIDxzYS1uYW1lPiAtbiA8bmFtZXNwYWNlPiAtbyBqc29ucGF0aD0n" + + "ey5pbWFnZVB1bGxTZWNyZXRzfScKYGBgCgojIyMgRml4ZXMKCjEuICoqU2VjcmV0IG1pc3Npbmcg" + + "aW4gbmFtZXNwYWNlKio6IENyZWF0ZSBpdAogICBgYGBiYXNoCiAgIGt1YmVjdGwgY3JlYXRlIHNl" + + "Y3JldCBkb2NrZXItcmVnaXN0cnkgbnZjci1jcmVkcyBcCiAgICAgLS1kb2NrZXItc2VydmVyPW52" + + "Y3IuaW8gXAogICAgIC0tZG9ja2VyLXVzZXJuYW1lPSckb2F1dGh0b2tlbicgXAogICAgIC0tZG9j" + + "a2VyLXBhc3N3b3JkPSIkTkdDX0FQSV9LRVkiIFwKICAgICAtLW5hbWVzcGFjZT08bmFtZXNwYWNl" + + "PiBcCiAgICAgLS1kcnktcnVuPWNsaWVudCAtbyB5YW1sIHwga3ViZWN0bCBhcHBseSAtZiAtCiAg" + + "IGBgYAoKMi4gKipTZWNyZXQgZXhpc3RzIGJ1dCBwb2QgZG9lc24ndCByZWZlcmVuY2UgaXQqKjog" + + "VGhlIGNoYXJ0IG5lZWRzIGBpbWFnZVB1bGxTZWNyZXRzYCBjb25maWd1cmVkIHZpYSBoZWxtZmls" + + "ZSB2YWx1ZXMuIFNlZSBbcHVsbC1zZWNyZXRzLm1kXShwdWxsLXNlY3JldHMubWQpLgoKMy4gKipD" + + "aGFydCBkb2Vzbid0IHN1cHBvcnQgaW1hZ2VQdWxsU2VjcmV0cyoqIChvcGVuYmFvLCBpbnZvY2F0" + + "aW9uLXNlcnZpY2UsIGVzcy1hcGksIG5vdGFyeS1zZXJ2aWNlKTogUGF0Y2ggU2VydmljZUFjY291" + + "bnRzIGFuZCByZXN0YXJ0IHBvZHMuIFNlZSBbcHVsbC1zZWNyZXRzLm1kXShwdWxsLXNlY3JldHMu" + + "bWQpLgoKNC4gKipXcm9uZyBjcmVkZW50aWFscyBpbiBzZWNyZXQqKjogRGVsZXRlIGFuZCByZWNy" + + "ZWF0ZQogICBgYGBiYXNoCiAgIGt1YmVjdGwgZGVsZXRlIHNlY3JldCBudmNyLWNyZWRzIC1uIDxu" + + "YW1lc3BhY2U+CiAgICMgUmVjcmVhdGUgd2l0aCBjb3JyZWN0IGNyZWRlbnRpYWxzCiAgIGBgYAoK" + + "IyMgRmFpbHVyZTogSW5pdDowLzEgU3R1Y2sgKFZhdWx0IEFnZW50KQoKIyMjIFN5bXB0b21zCgpT" + + "ZXJ2aWNlIHBvZHMgc3R1Y2sgaW4gYEluaXQ6MC8xYCBmb3IgbWludXRlczoKYGBgCk5BTUUgICAg" + + "ICAgICAgICAgICAgICAgICAgICBSRUFEWSAgIFNUQVRVUyAgICAgUkVTVEFSVFMgICBBR0UKbnZj" + + "Zi1hcGktN2Y0Yzc2Zjc4OC00NHZsdCAgMC8yICAgICBJbml0OjAvMSAgIDAgICAgICAgICAgMTBt" + + "CmBgYAoKIyMjIERpYWdub3NpcwoKVGhlIGluaXQgY29udGFpbmVyIGlzIHRoZSB2YXVsdC1hZ2Vu" + + "dC1pbml0IGluamVjdG9yIHdhaXRpbmcgZm9yIE9wZW5CYW8uCgpgYGBiYXNoCiMgQ2hlY2sgT3Bl" + + "bkJhbyBwb2RzCmt1YmVjdGwgZ2V0IHBvZHMgLW4gdmF1bHQtc3lzdGVtCgojIENoZWNrIGlmIE9w" + + "ZW5CYW8gbWlncmF0aW9uIGpvYiByYW4Ka3ViZWN0bCBnZXQgam9icyAtbiB2YXVsdC1zeXN0ZW0K" + + "CiMgQ2hlY2sgT3BlbkJhbyBwb2QgbG9ncwprdWJlY3RsIGxvZ3MgLW4gdmF1bHQtc3lzdGVtIG9w" + + "ZW5iYW8tc2VydmVyLTAgLWMgb3BlbmJhbwoKIyBDaGVjayBpbml0IGNvbnRhaW5lciBsb2dzIG9u" + + "IHRoZSBzdHVjayBwb2QKa3ViZWN0bCBsb2dzIC1uIDxuYW1lc3BhY2U+IDxwb2QtbmFtZT4gLWMg" + + "dmF1bHQtYWdlbnQtaW5pdApgYGAKCiMjIyBGaXhlcwoKMS4gKipPcGVuQmFvIHBvZHMgbm90IHJ1" + + "bm5pbmcqKjogQ2hlY2sgdGhlaXIgZXZlbnRzIGZvciBpbWFnZSBwdWxsIGlzc3VlcywgcmVzb3Vy" + + "Y2UgaXNzdWVzLCBldGMuCgoyLiAqKk9wZW5CYW8gbWlncmF0aW9uIGpvYiBkaWRuJ3QgcnVuKio6" + + "IFRoaXMgaGFwcGVucyB3aGVuIGBoZWxtZmlsZSBzeW5jYCB3YXMgaW50ZXJydXB0ZWQuIERlc3Ry" + + "b3kgYW5kIHJlLXN5bmMgb3BlbmJhbzoKICAgYGBgYmFzaAogICBIRUxNRklMRV9FTlY9PGVudj4g" + + "aGVsbWZpbGUgLS1zZWxlY3RvciBuYW1lPW9wZW5iYW8tc2VydmVyIGRlc3Ryb3kKICAga3ViZWN0" + + "bCBkZWxldGUgbmFtZXNwYWNlIHZhdWx0LXN5c3RlbQogICBrdWJlY3RsIGNyZWF0ZSBuYW1lc3Bh" + + "Y2UgdmF1bHQtc3lzdGVtCiAgICMgUmUtY3JlYXRlIHB1bGwgc2VjcmV0IGlmIG5lZWRlZAogICBI" + + "RUxNRklMRV9FTlY9PGVudj4gaGVsbWZpbGUgLS1zZWxlY3RvciBuYW1lPW9wZW5iYW8tc2VydmVy" + + "IHN5bmMKICAgYGBgCgozLiAqKk9wZW5CYW8gcG9kcyBydW5uaW5nIGJ1dCBub3QgaW5pdGlhbGl6" + + "ZWQqKjogQ2hlY2sgdW5zZWFsIHN0YXR1czoKICAgYGBgYmFzaAogICBrdWJlY3RsIGV4ZWMgLW4g" + + "dmF1bHQtc3lzdGVtIG9wZW5iYW8tc2VydmVyLTAgLWMgb3BlbmJhbyAtLSBiYW8gc3RhdHVzCiAg" + + "IGBgYAoKNC4gKipgdmF1bHQtYWdlbnQtaW5pdGAgbG9ncyBgYXV0aC9qd3QvbG9naW5gIC0+IGA0" + + "MDAgLi4uIG5vIGtub3duIGtleSBzdWNjZXNzZnVsbHkgdmFsaWRhdGVkIHRoZSB0b2tlbiBzaWdu" + + "YXR1cmVgKioKICAgKGNvbW1vbiBvbiBBS1MsIGFuZCBvbiBhbnkgY2x1c3RlciB3aG9zZSBPSURD" + + "IGlzc3VlciBwdWJsaXNoZXMgYSByb3RhdGluZyBtdWx0aS1rZXkgSldLUyk6CiAgIHRoZSBPcGVu" + + "QmFvIGBhdXRoL2p3dGAgbWV0aG9kIHdhcyBjb25maWd1cmVkIHdpdGggYSBzaW5nbGUgc3RhdGlj" + + "IG1vdW50ZWQgcHVibGljIGtleQogICAoYGp3dF92YWxpZGF0aW9uX3B1YmtleXNgKSBpbnN0ZWFk" + + "IG9mIHRoZSBpc3N1ZXIncyBsaXZlIEpXS1MsIHNvIGl0IGNhbm5vdCB2YWxpZGF0ZSB0aGUKICAg" + + "Y2x1c3Rlci1zaWduZWQgU2VydmljZUFjY291bnQgdG9rZW5zIHRoZSB2YXVsdC1hZ2VudHMgcHJl" + + "c2VudC4gRXZlcnkgc2VydmljZSdzCiAgIGB2YXVsdC1hZ2VudC1pbml0YCB0aGVuIGxvb3BzIG9u" + + "IHRoYXQgNDAwIGFuZCB0aGUgcG9kIG5ldmVyIGxlYXZlcyBgSW5pdDowLzFgLiBUaGlzIGlzIHRo" + + "ZQogICBiZWhhdmlvciBvZiB0aGUgYmFzZSBkZWZhdWx0IGBvcGVuYmFvLm1pZ3JhdGlvbnMuaXNz" + + "dWVyRGlzY292ZXJ5LmVuYWJsZWQ6IGZhbHNlYDsgdGhlCiAgIG1pZ3JhdGlvbiBsb2cgc2hvd3Mg" + + "YE9JREMgaXNzdWVyIGRpc2NvdmVyeSBpcyBkaXNhYmxlZC4gVXNpbmcgU2VydmljZUFjY291bnQg" + + "aXNzdWVyIGFuZAogICBtb3VudGVkIHB1YmxpYyBrZXkgZmFsbGJhY2tgLiBFbmFibGUgaXNzdWVy" + + "IGRpc2NvdmVyeSBzbyB0aGUgbWlncmF0aW9uIHVzZXMgdGhlIGxpdmUgSldLUywKICAgdGhlbiBy" + + "ZS1ydW4gaXQ6CiAgIGBgYGJhc2gKICAgIyBJbiB5b3VyIGVudiB2YWx1ZXMgKGUuZy4gZW52aXJv" + + "bm1lbnRzLzxlbnY+LnlhbWwpLCBzZXQ6CiAgICMgICBvcGVuYmFvOgogICAjICAgICBtaWdyYXRp" + + "b25zOgogICAjICAgICAgIGlzc3VlckRpc2NvdmVyeToKICAgIyAgICAgICAgIGVuYWJsZWQ6IHRy" + + "dWUKICAga3ViZWN0bCBkZWxldGUgam9iIC1uIHZhdWx0LXN5c3RlbSBvcGVuYmFvLXNlcnZlci1t" + + "aWdyYXRpb25zCiAgIEhFTE1GSUxFX0VOVj08ZW52PiBoZWxtZmlsZSAtLXNlbGVjdG9yIG5hbWU9" + + "b3BlbmJhby1zZXJ2ZXIgc3luYwogICBgYGAKICAgVGhlIG1pZ3JhdGlvbiBsb2cgc2hvdWxkIHRo" + + "ZW4gc2hvdyBgUmVjZWl2ZWQgZGlzY292ZXJ5IGRvY3VtZW50IGZyb20KICAgLi4uLy53ZWxsLWtu" + + "b3duL29wZW5pZC1jb25maWd1cmF0aW9uYCBhbmQgYEZpbmFsIE9wZW5CYW8gSldUIEpXS1MgVVJM" + + "IHNldCB0bzoKICAgLi4uL29wZW5pZC92MS9qd2tzYCwgYW5kIHRoZSBzZXJ2aWNlIHBvZHMgYXV0" + + "aGVudGljYXRlIGFuZCByZWFjaCBSZWFkeSB3aXRoaW4gfjEgbWluLgogICBBS1MgY2x1c3RlcnMg" + + "d2l0aCB0aGUgY2x1c3RlciBPSURDIGlzc3VlciBlbmFibGVkICh0aGUgYGFrcy1jbHVzdGVyYCBk" + + "ZWZhdWx0KSBhbHdheXMgbmVlZAogICB0aGlzIGJlY2F1c2UgdGhlIHN0YXRpYy1wdWJrZXkgZmFs" + + "bGJhY2sgY2Fubm90IG1hdGNoIHRoZSBpc3N1ZXIncyByb3RhdGluZyBzaWduaW5nIGtleXMuCgoj" + + "IyBGYWlsdXJlOiBPT01LaWxsZWQgb24gQ2Fzc2FuZHJhCgojIyMgU3ltcHRvbXMKCmBgYApOQU1F" + + "ICAgICAgICAgIFJFQURZICAgU1RBVFVTICAgIFJFU1RBUlRTICAgQUdFCmNhc3NhbmRyYS0wICAg" + + "MC8xICAgICBPT01LaWxsZWQgIDMgICAgICAgICAxMG0KYGBgCgojIyMgRGlhZ25vc2lzCgpgYGBi" + + "YXNoCmt1YmVjdGwgZGVzY3JpYmUgcG9kIC1uIGNhc3NhbmRyYS1zeXN0ZW0gY2Fzc2FuZHJhLTAg" + + "fCBncmVwIC1BMyAiTGFzdCBTdGF0ZSIKYGBgCgojIyMgRml4CgpPdmVycmlkZSBDYXNzYW5kcmEg" + + "cmVzb3VyY2VzIHZpYSBoZWxtZmlsZSB2YWx1ZXMuIFNlZSBFeGFtcGxlIDEgaW4KW2V4YW1wbGVz" + + "Lm1kXSguLi9leGFtcGxlcy5tZCkuCgpgYGB5YW1sCi0gY2Fzc2FuZHJhOgogICAgcmVzb3VyY2Vz" + + "OgogICAgICBsaW1pdHM6CiAgICAgICAgY3B1OiAiOCIKICAgICAgICBtZW1vcnk6IDgxOTJNaQog" + + "ICAgICByZXF1ZXN0czoKICAgICAgICBjcHU6ICIyIgogICAgICAgIG1lbW9yeTogNDA5Nk1pCmBg" + + "YAoKTm90ZTogYHJlc291cmNlUHJlc2V0YCBpcyBub3QgYXZhaWxhYmxlIGluIHRoZSBOVkNGIGNh" + + "c3NhbmRyYSB3cmFwcGVyIGNoYXJ0LiBVc2UgZXhwbGljaXQgYHJlc291cmNlc2AuCgojIyBGYWls" + + "dXJlOiBQb2RzIFN0dWNrIGluIFBlbmRpbmcKCiMjIyBTeW1wdG9tcwoKYGBgCk5BTUUgICAgICAg" + + "ICAgUkVBRFkgICBTVEFUVVMgICAgUkVTVEFSVFMgICBBR0UKY2Fzc2FuZHJhLTAgICAwLzEgICAg" + + "IFBlbmRpbmcgICAwICAgICAgICAgIDEwbQpgYGAKCiMjIyBEaWFnbm9zaXMKCmBgYGJhc2gKIyBD" + + "aGVjayBldmVudHMgZm9yIHNjaGVkdWxpbmcgZmFpbHVyZXMKa3ViZWN0bCBkZXNjcmliZSBwb2Qg" + + "LW4gPG5hbWVzcGFjZT4gPHBvZC1uYW1lPgoKIyBDb21tb24gY2F1c2VzOgojIC0gIjAvMTIgbm9k" + + "ZXMgYXJlIGF2YWlsYWJsZTogMTIgbm9kZShzKSBkaWRuJ3QgbWF0Y2ggUG9kJ3Mgbm9kZSBhZmZp" + + "bml0eSIKIyAtICIwLzEyIG5vZGVzIGFyZSBhdmFpbGFibGU6IDEyIEluc3VmZmljaWVudCBtZW1v" + + "cnkiCiMgLSAicGVyc2lzdGVudHZvbHVtZWNsYWltIG5vdCBmb3VuZCIKYGBgCgojIyMgRml4ZXMK" + + "CjEuICoqTm9kZSBzZWxlY3RvciBtaXNtYXRjaCoqOiBDaGVjayBgbm9kZVNlbGVjdG9yc2AgaW4g" + + "ZW52aXJvbm1lbnQgZmlsZQogICBgYGBiYXNoCiAgIGt1YmVjdGwgZ2V0IG5vZGVzIC0tc2hvdy1s" + + "YWJlbHMgfCBncmVwIG52Y2YKICAgYGBgCgoyLiAqKlN0b3JhZ2UgY2xhc3Mgbm90IGZvdW5kKio6" + + "IENoZWNrIHN0b3JhZ2UgY2xhc3MgZXhpc3RzCiAgIGBgYGJhc2gKICAga3ViZWN0bCBnZXQgc3Rv" + + "cmFnZWNsYXNzCiAgIGBgYAoKMy4gKipJbnN1ZmZpY2llbnQgcmVzb3VyY2VzKio6IENoZWNrIG5v" + + "ZGUgY2FwYWNpdHkKICAgYGBgYmFzaAogICBrdWJlY3RsIGRlc2NyaWJlIG5vZGUgPG5vZGUtbmFt" + + "ZT4gfCBncmVwIC1BNSAiQWxsb2NhdGVkIHJlc291cmNlcyIKICAgYGBgCgojIyBGYWlsdXJlOiBI" + + "ZWxtIFJlbGVhc2UgaW4gRmFpbGVkIFN0YXRlCgojIyMgU3ltcHRvbXMKCmBgYGJhc2gKaGVsbSBs" + + "aXN0IC1BCiMgU2hvd3MgcmVsZWFzZSB3aXRoIFNUQVRVUzogZmFpbGVkCmBgYAoKUmUtcnVubmlu" + + "ZyBgaGVsbWZpbGUgc3luY2AgYXBwZWFycyB0byBzdWNjZWVkIGJ1dCBzZXJ2aWNlcyBkb24ndCB3" + + "b3JrIChtaWdyYXRpb25zIHNraXBwZWQpLgoKIyMjIERpYWdub3NpcwoKYGBgYmFzaApoZWxtIGhp" + + "c3RvcnkgPHJlbGVhc2UtbmFtZT4gLW4gPG5hbWVzcGFjZT4KYGBgCgojIyMgRml4CgpNdXN0IGRl" + + "c3Ryb3kgdGhlIGZhaWxlZCByZWxlYXNlIGFuZCByZS1zeW5jIChub3QganVzdCBhcHBseSk6Cgpg" + + "YGBiYXNoCkhFTE1GSUxFX0VOVj08ZW52PiBoZWxtZmlsZSAtLXNlbGVjdG9yIG5hbWU9PHJlbGVh" + + "c2U+IGRlc3Ryb3kKIyBJZiBuYW1lc3BhY2UgbmVlZHMgY2xlYW51cDoKa3ViZWN0bCBkZWxldGUg" + + "bmFtZXNwYWNlIDxuYW1lc3BhY2U+Cmt1YmVjdGwgY3JlYXRlIG5hbWVzcGFjZSA8bmFtZXNwYWNl" + + "PgojIFJlLWNyZWF0ZSBwdWxsIHNlY3JldCBpZiBuZWVkZWQKSEVMTUZJTEVfRU5WPTxlbnY+IGhl" + + "bG1maWxlIC0tc2VsZWN0b3IgbmFtZT08cmVsZWFzZT4gc3luYwpgYGAKCiMjIEZhaWx1cmU6IEFj" + + "Y291bnQgQm9vdHN0cmFwIEpvYiBGYWlsZWQKCiMjIyBTeW1wdG9tcwoKU2VydmljZXMgZGVwbG95" + + "IGJ1dCBmdW5jdGlvbnMgY2FuJ3QgYmUgY3JlYXRlZC4gRXZlbnRzIHNob3cgYm9vdHN0cmFwIGpv" + + "YiBmYWlsdXJlLgoKIyMjIERpYWdub3NpcwoKYGBgYmFzaAojIENoZWNrIGJvb3RzdHJhcCBqb2Ig" + + "c3RhdHVzCmt1YmVjdGwgZ2V0IGpvYnMgLW4gbnZjZgoKIyBHZXQgbG9ncyAoam9iIGF1dG8tZGVs" + + "ZXRlcyBhZnRlciB+NSBtaW51dGVzKQprdWJlY3RsIGxvZ3Mgam9iL252Y2YtYXBpLWFjY291bnQt" + + "Ym9vdHN0cmFwIC1uIG52Y2YKCiMgQ2hlY2sgQVBJIGxvZ3MKa3ViZWN0bCBsb2dzIC1uIG52Y2Yg" + + "LWwgYXBwLmt1YmVybmV0ZXMuaW8vbmFtZT1udmNmLWFwaSAtLXRhaWw9MTAwCmBgYAoKIyMjIENv" + + "bW1vbiBDYXVzZXMKCjEuICoqV3JvbmcgYmFzZTY0IGNyZWRlbnRpYWxzKio6IENyZWRlbnRpYWxz" + + "IGluIGBzZWNyZXRzLzxlbnY+LXNlY3JldHMueWFtbGAgbXVzdCBiZSBgJG9hdXRodG9rZW46QVBJ" + + "X0tFWWAgYmFzZTY0LWVuY29kZWQsIG5vdCBqdXN0IHRoZSBBUEkga2V5CiAgIGBgYGJhc2gKICAg" + + "IyBWZXJpZnkgeW91ciBlbmNvZGVkIGNyZWRlbnRpYWwKICAgZWNobyAnWU9VUl9CQVNFNjRfU1RS" + + "SU5HJyB8IGJhc2U2NCAtZAogICAjIFNob3VsZCBvdXRwdXQ6ICRvYXV0aHRva2VuOm52YXBpLXh4" + + "eHh4CiAgIGBgYAoKMi4gKipSZWdpc3RyeSB1bnJlYWNoYWJsZSoqOiBBUEkgY2FuJ3QgcmVhY2gg" + + "dGhlIHJlZ2lzdHJ5IHNwZWNpZmllZCBpbiBgYWNjb3VudEJvb3RzdHJhcC5yZWdpc3RyeUNyZWRl" + + "bnRpYWxzYAoKIyMjIEZpeAoKRml4IGNyZWRlbnRpYWxzIGluIHNlY3JldHMgZmlsZSwgdGhlbiBy" + + "ZWNvdmVyIHNlcnZpY2VzIHdpdGhvdXQgZGVzdHJveWluZyBkZXBlbmRlbmNpZXM6CgpgYGBiYXNo" + + "CkhFTE1GSUxFX0VOVj08ZW52PiBoZWxtZmlsZSAtLXNlbGVjdG9yIHJlbGVhc2UtZ3JvdXA9c2Vy" + + "dmljZXMgZGVzdHJveQprdWJlY3RsIGRlbGV0ZSBuYW1lc3BhY2UgbnZjZiBhcGkta2V5cyBlc3Mg" + + "c2lzIC0taWdub3JlLW5vdC1mb3VuZAprdWJlY3RsIGNyZWF0ZSBuYW1lc3BhY2UgbnZjZiAmJiBr" + + "dWJlY3RsIGNyZWF0ZSBuYW1lc3BhY2UgYXBpLWtleXMgJiYgXAogIGt1YmVjdGwgY3JlYXRlIG5h" + + "bWVzcGFjZSBlc3MgJiYga3ViZWN0bCBjcmVhdGUgbmFtZXNwYWNlIHNpcwojIFJlLWNyZWF0ZSBw" + + "dWxsIHNlY3JldHMgaWYgbmVlZGVkCkhFTE1GSUxFX0VOVj08ZW52PiBoZWxtZmlsZSAtLXNlbGVj" + + "dG9yIHJlbGVhc2UtZ3JvdXA9c2VydmljZXMgc3luYwpgYGAKCiMjIEZhaWx1cmU6IE5WQ0EgQ2xl" + + "YW51cCBTdHVjayAoRmluYWxpemVycykKCiMjIyBTeW1wdG9tcwoKQ29tcHV0ZS1wbGFuZSBjbGVh" + + "bnVwIGhhbmdzLiBOYW1lc3BhY2VzCnN0dWNrIGluIGBUZXJtaW5hdGluZ2A6CgpgYGBiYXNoCmt1" + + "YmVjdGwgZ2V0IG5zCiMgbnZjYS1vcGVyYXRvciAgICBUZXJtaW5hdGluZyAgIDEwbQojIG52Y2Yt" + + "YmFja2VuZCAgICAgVGVybWluYXRpbmcgICAxMG0KYGBgCgojIyMgRml4CgpSdW4gdGhpcyBvbmx5" + + "IGFnYWluc3QgdGhlIGNvbXB1dGUgY29udGV4dCwgYWZ0ZXIgdGhlIG5vcm1hbCBjb21wdXRlLXBs" + + "YW5lCnRlYXJkb3duIGhhcyBmYWlsZWQuIFJlbW92ZSBmaW5hbGl6ZXJzIGZyb20gTlZDRkJhY2tl" + + "bmQgY3VzdG9tIHJlc291cmNlcyBhbmQKZm9yY2UtZGVsZXRlIHN0dWNrIG5hbWVzcGFjZXM6Cgpg" + + "YGBiYXNoCmV4cG9ydCBDT01QVVRFX0NPTlRFWFQ9PGNvbXB1dGUtcGxhbmUtY29udGV4dD4KCiMg" + + "UmVtb3ZlIGZpbmFsaXplcnMgZnJvbSBOVkNGQmFja2VuZCByZXNvdXJjZXMKa3ViZWN0bCAtLWNv" + + "bnRleHQgIiRDT01QVVRFX0NPTlRFWFQiIGdldCBudmNmYmFja2VuZHMgLUEgLW8ganNvbiB8IFwK" + + "ICBqcSAnLml0ZW1zW10gfCAubWV0YWRhdGEubmFtZXNwYWNlICsgIi8iICsgLm1ldGFkYXRhLm5h" + + "bWUnIC1yIHwgXAogIHhhcmdzIC1Je30gc2ggLWMgJ2NvbnRleHQ9IiQxIjsgbnM9IiR7MiUlLyp9" + + "IjsgbmFtZT0iJHsyIyMqL30iOyBrdWJlY3RsIC0tY29udGV4dCAiJGNvbnRleHQiIHBhdGNoIG52" + + "Y2ZiYWNrZW5kICIkbmFtZSIgLW4gIiRucyIgLS10eXBlPW1lcmdlIC1wICJ7XCJtZXRhZGF0YVwi" + + "OntcImZpbmFsaXplcnNcIjpbXX19IicgXyAiJENPTVBVVEVfQ09OVEVYVCIge30KCiMgRm9yY2Ut" + + "ZGVsZXRlIHN0dWNrIG5hbWVzcGFjZXMgYnkgY2xlYXJpbmcgdGhlaXIgZmluYWxpemVycwpmb3Ig" + + "bnMgaW4gbnZjYS1vcGVyYXRvciBudmNmLWJhY2tlbmQ7IGRvCiAga3ViZWN0bCAtLWNvbnRleHQg" + + "IiRDT01QVVRFX0NPTlRFWFQiIGdldCBuYW1lc3BhY2UgIiRucyIgLW8ganNvbiAyPi9kZXYvbnVs" + + "bCB8IFwKICAgIGpxICcuc3BlYy5maW5hbGl6ZXJzID0gW10nIHwgXAogICAga3ViZWN0bCAtLWNv" + + "bnRleHQgIiRDT01QVVRFX0NPTlRFWFQiIHJlcGxhY2UgXAogICAgICAtLXJhdyAiL2FwaS92MS9u" + + "YW1lc3BhY2VzLyRucy9maW5hbGl6ZSIgLWYgLSAyPi9kZXYvbnVsbApkb25lCmBgYAoKIyMgRmFp" + + "bHVyZTogTlZDQSBPcGVyYXRvciBNaXNzaW5nIG9yIE5vdCBSZWFkeQoKIyMjIFN5bXB0b21zCgpB" + + "ZnRlciBjb21wdXRlLXBsYW5lIGluc3RhbGwgY29tcGxldGVzLCBubyBgbnZjYS1vcGVyYXRvcmAg" + + "RGVwbG95bWVudCBleGlzdHMsIG9yCml0IGV4aXN0cyBidXQgcG9kcyBhcmUgbm90IHJlYWR5OgoK" + + "YGBgYmFzaAprdWJlY3RsIC0tY29udGV4dCA8Y29tcHV0ZS1wbGFuZS1jb250ZXh0PiBnZXQgZGVw" + + "bG95bWVudCBudmNhLW9wZXJhdG9yIFwKICAtbiBudmNhLW9wZXJhdG9yCmt1YmVjdGwgLS1jb250" + + "ZXh0IDxjb21wdXRlLXBsYW5lLWNvbnRleHQ+IGdldCBwb2RzIC1uIG52Y2Etb3BlcmF0b3IKYGBg" + + "CgojIyMgRGlhZ25vc2lzIGFuZCBGaXhlcwoKRmlyc3QgaWRlbnRpZnkgd2hldGhlciB0aGUgaW5z" + + "dGFsbGF0aW9uIHVzZWQgdGhlIEhlbG1maWxlIHZhbHVlcyBmbG93IG9yIHRoZQpDTEkgcHJvZmls" + + "ZSBmbG93LiBSZS1ydW4gb25seSB0aGF0IGZsb3cncyByZWdpc3RyYXRpb24gYW5kIGluc3RhbGxh" + + "dGlvbiBzdGVwcwpmcm9tIFtTcGxpdCBDb21wdXRlLVBsYW5lIEluc3RhbGxhdGlvbl0oY29tcHV0" + + "ZS1wbGFuZS1pbnN0YWxsYXRpb24ubWQpLiBEbyBub3QKc3Vic3RpdHV0ZSBvbmUgaGFuZG9mZiBm" + + "b3IgdGhlIG90aGVyLgoKSWYgaW5zdGFsbGF0aW9uIHN1Y2NlZWRzIGJ1dCBwb2RzIHN0aWxsIGZh" + + "aWwsIGluc3BlY3QgdGhlIGNvbXB1dGUgY29udGV4dDoKCmBgYGJhc2gKa3ViZWN0bCAtLWNvbnRl" + + "eHQgPGNvbXB1dGUtcGxhbmUtY29udGV4dD4gZGVzY3JpYmUgZGVwbG95IG52Y2Etb3BlcmF0b3Ig" + + "XAogIC1uIG52Y2Etb3BlcmF0b3IKa3ViZWN0bCAtLWNvbnRleHQgPGNvbXB1dGUtcGxhbmUtY29u" + + "dGV4dD4gbG9ncyBkZXBsb3ltZW50L252Y2Etb3BlcmF0b3IgXAogIC1uIG52Y2Etb3BlcmF0b3Ig" + + "LS10YWlsPTIwMAprdWJlY3RsIC0tY29udGV4dCA8Y29tcHV0ZS1wbGFuZS1jb250ZXh0PiBnZXQg" + + "bnZjZmJhY2tlbmQgLW4gbnZjYS1vcGVyYXRvcgpgYGAKCkZvciBwcml2YXRlIHJlZ2lzdHJ5IGZh" + + "aWx1cmVzLCB2ZXJpZnkgdGhhdCB0aGUgcHVsbCBzZWNyZXQgZXhpc3RzIGluCmBudmNhLW9wZXJh" + + "dG9yYC4gVGhlIGNoYXJ0IGFuZCBvcGVyYXRvciBtaXJyb3IgaXQgdG8gYG52Y2Etc3lzdGVtYDsg" + + "ZG8gbm90IHVzZSBhCmJyb2FkZXIgbWFudWFsIG5hbWVzcGFjZSBsb29wLiBTZWUKW3B1bGwtc2Vj" + + "cmV0cy5tZF0ocHVsbC1zZWNyZXRzLm1kI2NvbXB1dGUtcGxhbmUtc2VjcmV0KS4KCiMjIEZhaWx1" + + "cmU6IEdhdGV3YXkgRW5kcG9pbnQgQ2hhbmdlZAoKIyMjIFN5bXB0b21zCgpSZXF1ZXN0cyB0aHJv" + + "dWdoIHRoZSBjb25maWd1cmVkIHJvdXRlIGRvbWFpbiBmYWlsIGFmdGVyIHRoZSBHYXRld2F5IG9y" + + "IGl0cyBsb2FkIGJhbGFuY2VyIGlzIHJlcGxhY2VkLiBUaGUgR2F0ZXdheSByZXBvcnRzIGEgbmV3" + + "IGVuZHBvaW50LgoKIyMjIERpYWdub3NpcwoKYGBgYmFzaApHQVRFV0FZX0FERFI9JChrdWJlY3Rs" + + "IC0tY29udGV4dCA8Y29udHJvbC1wbGFuZS1jb250ZXh0PiBnZXQgZ2F0ZXdheSBcCiAgbnZjZi1n" + + "YXRld2F5IC1uIGVudm95LWdhdGV3YXkgXAogIC1vIGpzb25wYXRoPSd7LnN0YXR1cy5hZGRyZXNz" + + "ZXNbMF0udmFsdWV9JykKdGVzdCAtbiAiJEdBVEVXQVlfQUREUiIKZGlnICtzaG9ydCAiYXBpLjxk" + + "b21haW4+IgpjdXJsIC1IICJIb3N0OiBhcGkuPGRvbWFpbj4iICJodHRwOi8vJEdBVEVXQVlfQURE" + + "Ui9oZWFsdGgiCgojIENoZWNrIGRpcmVjdCBhZGRyZXNzIGZpZWxkcyB1c2VkIGJ5IGEgc3BsaXQg" + + "ZGVwbG95bWVudApncmVwIG52Y2ZOYXRzU2VydmljZVVSTCBkZXBsb3kvc3RhY2tzL3NlbGYtbWFu" + + "YWdlZC9lbnZpcm9ubWVudHMvPGVudj4ueWFtbApncmVwIC1FICdpY21zU2VydmljZXxyZXZhbFNl" + + "cnZpY2V8bmF0cycgXAogIGRlcGxveS9zdGFja3MvbnZjZi1jb21wdXRlLXBsYW5lL2Vudmlyb25t" + + "ZW50cy88ZW52Pi55YW1sCmBgYAoKIyMjIEZpeAoKS2VlcCBgZ2xvYmFsLmRvbWFpbmAsIHJvdXRl" + + "IGhvc3RuYW1lcywgYW5kIEhvc3Qgb3ZlcnJpZGVzIHVuY2hhbmdlZC4gVXBkYXRlIEROUwpvciB0" + + "aGUgZGlyZWN0IGNsaWVudCBkZXN0aW5hdGlvbi4gRm9yIHNwbGl0IGRlcGxveW1lbnRzLCB1cGRh" + + "dGUgb25seSBkaXJlY3QKR2F0ZXdheS1hZGRyZXNzIGZpZWxkcyBhbmQgcmVmcmVzaCByZWdpc3Ry" + + "YXRpb24gYW5kIGluc3RhbGxhdGlvbiB0aHJvdWdoIHRoZQpzYW1lIHNlbGVjdGVkIGhhbmRvZmYu" + + "IFNlZQpbRXhhbXBsZSA0XSguLi9leGFtcGxlcy5tZCNleGFtcGxlLTQtcmVjb3Zlci1mcm9tLWEt" + + "Z2F0ZXdheS1lbmRwb2ludC1jaGFuZ2UpLgoKIyMgVXNlZnVsIE5hbWVzcGFjZS10by1TZXJ2aWNl" + + "IE1hcHBpbmcKClF1aWNrIHJlZmVyZW5jZSBmb3Igd2hpY2ggc2VydmljZXMgcnVuIGluIHdoaWNo" + + "IG5hbWVzcGFjZToKCnwgTmFtZXNwYWNlIHwgU2VydmljZXMgfAp8LS0tLS0tLS0tLS18LS0tLS0t" + + "LS0tLXwKfCBuYXRzLXN5c3RlbSB8IG5hdHMgfAp8IGNhc3NhbmRyYS1zeXN0ZW0gfCBjYXNzYW5k" + + "cmEgfAp8IHZhdWx0LXN5c3RlbSB8IG9wZW5iYW8tc2VydmVyIHwKfCBudmNmIHwgYXBpLCBpbnZv" + + "Y2F0aW9uLXNlcnZpY2UsIGdycGMtcHJveHksIG5vdGFyeS1zZXJ2aWNlLCByZXZhbCwgbGxtLXJl" + + "cXVlc3Qtcm91dGVyLCBsbG0tYXBpLWdhdGV3YXkgfAp8IGFwaS1rZXlzIHwgYXBpLWtleXMsIGFk" + + "bWluLWlzc3Vlci1wcm94eSB8CnwgZXNzIHwgZXNzLWFwaSB8Cnwgc2lzIHwgc2lzIHwKfCBlbnZv" + + "eS1nYXRld2F5LXN5c3RlbSB8IGVudm95IGdhdGV3YXkgKGluZ3Jlc3MgY29udHJvbGxlcikgfAp8" + + "IGVudm95LWdhdGV3YXkgfCBnYXRld2F5IHJlc291cmNlICsgcm91dGVzIHwKUEsHCFY+Z5CVMAAA" + + "lTAAAFBLAwQUAAgAAAAAACEAAAAAAAAAAAAAAAAARAAJAGRhdGEvbnZjZi1zZWxmLW1hbmFnZWQt" + + "aW5zdGFsbGF0aW9uL3JlZmVyZW5jZXMvaGVsbWZpbGUtc3RydWN0dXJlLm1kVVQFAAEAps4SIyBI" + + "ZWxtZmlsZSBTdHJ1Y3R1cmUgUmVmZXJlbmNlCgojIyBEaXJlY3RvcnkgTGF5b3V0CgpgYGAKbnZj" + + "Zi1zZWxmLW1hbmFnZWQtc3RhY2svCnwtLSBoZWxtZmlsZS5kLwp8ICAgfC0tIDAxLWRlcGVuZGVu" + + "Y2llcy55YW1sLmdvdG1wbCAgIyBOQVRTLCBDYXNzYW5kcmEsIE9wZW5CYW8KfCAgIHwtLSAwMi1j" + + "b3JlLnlhbWwuZ290bXBsICAgICAgICAgICMgTlZDRiBzZXJ2aWNlcyArIGluZ3Jlc3MKfCAgIGAt" + + "LSAwMy1vYnNlcnZhYmlsaXR5LnlhbWwuZ290bXBsICMgT2JzZXJ2YWJpbGl0eSBzdGFjayAob3B0" + + "aW9uYWwpCnwtLSBlbnZpcm9ubWVudHMvCnwgICB8LS0gYmFzZS55YW1sICAgICAgICAgICAgICAg" + + "ICAgICAjIERlZmF1bHQgdmFsdWVzIChhbGwgZW52aXJvbm1lbnRzKQp8ICAgYC0tIDxlbnYtbmFt" + + "ZT4ueWFtbCAgICAgICAgICAgICAgIyBQZXItZW52aXJvbm1lbnQgb3ZlcnJpZGVzCnwtLSBzZWNy" + + "ZXRzLwp8ICAgYC0tIDxlbnYtbmFtZT4tc2VjcmV0cy55YW1sICAgICAgIyBTZW5zaXRpdmUgdmFs" + + "dWVzIChyZWdpc3RyeSBjcmVkcywgcGFzc3dvcmRzKQpgLS0gZ2xvYmFsLnlhbWwuZ290bXBsICAg" + + "ICAgICAgICAgICAgIyBHbyB0ZW1wbGF0ZSB0aGF0IGNvbnN0cnVjdHMgcGVyLWNoYXJ0IHZhbHVl" + + "cwoKbnZjZi1jb21wdXRlLXBsYW5lLXN0YWNrLwp8LS0gaGVsbWZpbGUuZC8KfCAgIHwtLSAwMS1k" + + "ZXBlbmRlbmNpZXMueWFtbC5nb3RtcGwgICMgQ29tcHV0ZSBwbGFuZSBkZXBlbmRlbmN5IGNvbXBv" + + "bmVudHMKfCAgIGAtLSAwMi1udmNhLnlhbWwuZ290bXBsICAgICAgICAgICMgbnZjYS1vcGVyYXRv" + + "ciBjaGFydCBhbmQgbnZjYSBjb25maWd1cmF0aW9uCnwtLSBlbnZpcm9ubWVudHMvCnwgICB8LS0g" + + "YmFzZS55YW1sICAgICAgICAgICAgICAgICAgICAjIERlZmF1bHQgdmFsdWVzIChhbGwgZW52aXJv" + + "bm1lbnRzKQp8ICAgYC0tIDxlbnYtbmFtZT4ueWFtbCAgICAgICAgICAgICAgIyBQZXItZW52aXJv" + + "bm1lbnQgb3ZlcnJpZGVzCmAtLSBnbG9iYWwueWFtbC5nb3RtcGwgICAgICAgICAgICAgICAjIEdv" + + "IHRlbXBsYXRlIHRoYXQgY29uc3RydWN0cyBwZXItY2hhcnQgdmFsdWVzCmBgYAoKVGhlc2Ugc3Rh" + + "Y2tzIGhhdmUgc2VwYXJhdGUgZW52aXJvbm1lbnRzIGFuZCBjbHVzdGVyIGNvbnRleHRzLiBUaGUg" + + "SGVsbWZpbGUKdmFsdWVzIGZsb3cgYXV0aG9ycyBib3RoIGVudmlyb25tZW50IGZpbGVzLiBUaGUg" + + "Q0xJIHByb2ZpbGUgZmxvdyBpbnN0ZWFkIHVzZXMKdGhlIENMSS1nZW5lcmF0ZWQgY29udHJvbC1w" + + "bGFuZSBwcm9maWxlIGFzIGl0cyBlbmRwb2ludCBzb3VyY2UuIERvIG5vdCBtaXggdGhlCmhhbmRv" + + "ZmZzLiBTZWUgW1NwbGl0IENvbXB1dGUtUGxhbmUgSW5zdGFsbGF0aW9uXShjb21wdXRlLXBsYW5l" + + "LWluc3RhbGxhdGlvbi5tZCkuCgojIyBHb3RtcGwgRmlsZXMgYW5kIFRoZWlyIFJlbGVhc2VzCgoj" + + "IyMgMDEtZGVwZW5kZW5jaWVzLnlhbWwuZ290bXBsCgp8IFJlbGVhc2UgfCBDaGFydCB8IE5hbWVz" + + "cGFjZSB8IE5vdGVzIHwKfC0tLS0tLS0tLXwtLS0tLS0tfC0tLS0tLS0tLS0tfC0tLS0tLS18Cnwg" + + "bmF0cyB8IGhlbG0tbnZjZi1uYXRzIHwgbmF0cy1zeXN0ZW0gfCBNZXNzYWdpbmcgfAp8IG9wZW5i" + + "YW8tc2VydmVyIHwgaGVsbS1udmNmLW9wZW5iYW8tc2VydmVyIHwgdmF1bHQtc3lzdGVtIHwgU2Vj" + + "cmV0cyBtYW5hZ2VtZW50LCBkZXBlbmRzIG9uIG5hdHMgfAp8IGNhc3NhbmRyYSB8IGhlbG0tbnZj" + + "Zi1jYXNzYW5kcmEgfCBjYXNzYW5kcmEtc3lzdGVtIHwgRGF0YWJhc2UgfAoKVXNlcyBgPDw6ICpk" + + "ZXBlbmRlbmN5YCB0ZW1wbGF0ZSBpbmhlcml0YW5jZSB3aXRoIGByZWxlYXNlLWdyb3VwOiBkZXBl" + + "bmRlbmNpZXNgIGxhYmVsLgoKIyMjIDAyLWNvcmUueWFtbC5nb3RtcGwKCnwgUmVsZWFzZSB8IENo" + + "YXJ0IHwgTmFtZXNwYWNlIHwgTGFiZWwgfAp8LS0tLS0tLS0tfC0tLS0tLS18LS0tLS0tLS0tLS18" + + "LS0tLS0tLXwKfCBhcGkta2V5cyB8IGhlbG0tbnZjZi1hcGkta2V5cyB8IGFwaS1rZXlzIHwgc2Vy" + + "dmljZXMgfAp8IHNpcyB8IGhlbG0tbnZjZi1zaXMgfCBzaXMgfCBzZXJ2aWNlcyB8CnwgYXBpIHwg" + + "aGVsbS1udmNmLWFwaSB8IG52Y2YgfCBzZXJ2aWNlcyB8CnwgaW52b2NhdGlvbi1zZXJ2aWNlIHwg" + + "aGVsbS1udmNmLWludm9jYXRpb24tc2VydmljZSB8IG52Y2YgfCBzZXJ2aWNlcyB8CnwgZ3JwYy1w" + + "cm94eSB8IGhlbG0tbnZjZi1ncnBjLXByb3h5IHwgbnZjZiB8IHNlcnZpY2VzIHwKfCBlc3MtYXBp" + + "IHwgaGVsbS1udmNmLWVzcy1hcGkgfCBlc3MgfCBzZXJ2aWNlcyB8Cnwgbm90YXJ5LXNlcnZpY2Ug" + + "fCBoZWxtLW52Y2Ytbm90YXJ5LXNlcnZpY2UgfCBudmNmIHwgc2VydmljZXMgfAp8IHJldmFsIHwg" + + "aGVsbS1yZXZhbCB8IG52Y2YgfCBzZXJ2aWNlcyB8CnwgbGxtLXJlcXVlc3Qtcm91dGVyIHwgbnZj" + + "Zi9oZWxtLW52Y2YtbGxtLXJlcXVlc3Qtcm91dGVyIHwgbnZjZiB8IHNlcnZpY2VzIHwKfCBsbG0t" + + "YXBpLWdhdGV3YXkgfCBudmNmL2hlbG0tbnZjZi1sbG0tYXBpLWdhdGV3YXkgfCBudmNmIHwgc2Vy" + + "dmljZXMgfAp8IGFkbWluLWlzc3Vlci1wcm94eSB8IGhlbG0tYWRtaW4tdG9rZW4taXNzdWVyLXBy" + + "b3h5IHwgYXBpLWtleXMgfCAobm8gcmVsZWFzZS1ncm91cCBsYWJlbCkgfAp8IGluZ3Jlc3MgfCBu" + + "dmNmLWdhdGV3YXktcm91dGVzIHwgZW52b3ktZ2F0ZXdheS1zeXN0ZW0gfCBpbmdyZXNzIHwKCk1v" + + "c3Qgc2VydmljZXMgdXNlIGBpbmhlcml0OiBbe3RlbXBsYXRlOiBzZXJ2aWNlfV1gLiBMTE0gcmVs" + + "ZWFzZXMgdXNlIE9DSSBjaGFydHMgZnJvbSB0aGUgYG52Y2ZgIHJlcG9zaXRvcnkgd2l0aCBzdGFu" + + "ZGFsb25lIGB2YWx1ZXM6IFsuLi9nbG9iYWwueWFtbC5nb3RtcGxdYCBibG9ja3M7IHRoZXkgYXJl" + + "IGdhdGVkIG9uIGBhZGRvbnMubGxtLmVuYWJsZWRgLiBgYWRtaW4taXNzdWVyLXByb3h5YCBhbmQg" + + "YGluZ3Jlc3NgIGhhdmUgc3RhbmRhbG9uZSBgdmFsdWVzOmAgYmxvY2tzLgoKIyMjIDAzLW9ic2Vy" + + "dmFiaWxpdHkueWFtbC5nb3RtcGwKCnwgUmVsZWFzZSB8IENoYXJ0IHwgTmFtZXNwYWNlIHwgTGFi" + + "ZWwgfAp8LS0tLS0tLS0tfC0tLS0tLS18LS0tLS0tLS0tLS18LS0tLS0tLXwKfCAob2JzZXJ2YWJp" + + "bGl0eSByZWxlYXNlcykgfCAodmFyaW91cykgfCBvYnNlcnZhYmlsaXR5IHwgb2JzZXJ2YWJpbGl0" + + "eSB8CgpHYXRlZCBvbiBvYnNlcnZhYmlsaXR5LXNwZWNpZmljIGZsYWdzIGluIHRoZSBlbnZpcm9u" + + "bWVudCBmaWxlLiBTa2lwcGVkIGlmIGRpc2FibGVkLgoKIyMgVGVtcGxhdGUgSW5oZXJpdGFuY2UK" + + "CiMjIyBgPDw6ICpkZXBlbmRlbmN5YCAoWUFNTCBtZXJnZSkKClVzZWQgaW4gYDAxLWRlcGVuZGVu" + + "Y2llcy55YW1sLmdvdG1wbGAuIE1lcmdlcyB0aGUgdGVtcGxhdGUncyBwcm9wZXJ0aWVzIGludG8g" + + "dGhlIHJlbGVhc2UuCgoqKkdvdGNoYSoqOiBZQU1MIG1lcmdlIHJlcGxhY2VzIGxpc3RzLiBJZiB5" + + "b3UgYWRkIGEgYHZhbHVlczpgIGtleSB0byB0aGUgcmVsZWFzZSwgaXQgKipyZXBsYWNlcyoqIHRo" + + "ZSB0ZW1wbGF0ZSdzIGB2YWx1ZXM6YCBsaXN0IGVudGlyZWx5LiBZb3UgbXVzdCByZS1pbmNsdWRl" + + "IGFsbCB0ZW1wbGF0ZSB2YWx1ZXM6CgpJbiB0aGUgdGVtcGxhdGUgYmVsb3csIGA8cHJpdmF0ZS12" + + "YWx1ZXM+YCByZWZlcnMgdG8gdGhlIGBzZWNyZXRzL2AgZGlyZWN0b3J5IGF0IHRoZSBoZWxtZmls" + + "ZSBzdGFjayByb290LgoKYGBgeWFtbAojIFRlbXBsYXRlIGRlZmluZXM6CnRlbXBsYXRlczoKICBk" + + "ZXBlbmRlbmN5OiAmZGVwZW5kZW5jeQogICAgY2hhcnQ6IG52Y2YvaGVsbS1udmNmLXt7IC5SZWxl" + + "YXNlLk5hbWUgfX0KICAgIHZhbHVlczoKICAgICAgLSAuLi9nbG9iYWwueWFtbC5nb3RtcGwKICAg" + "ICAgLSAuLi88cHJpdmF0ZS12YWx1ZXM+L3t7IHJlcXVpcmVkRW52ICJIRUxNRklMRV9FTlYiIH19" + - "LXNlY3JldHMueWFtbCAgICMgTXVzdCByZS1pbmNsdWRlCiAgICAtIGNhc3NhbmRyYTogICAgICAg" + - "ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIyBZb3Vy" + - "IG92ZXJyaWRlCiAgICAgICAgcmVzb3VyY2VzOgogICAgICAgICAgbGltaXRzOgogICAgICAgICAg" + - "ICBtZW1vcnk6IDgxOTJNaQpgYGAKCiMjIyBgaW5oZXJpdGAgKEhlbG1maWxlIG5hdGl2ZSkKClVz" + - "ZWQgaW4gYDAyLWNvcmUueWFtbC5nb3RtcGxgLiBIZWxtZmlsZSdzIG5hdGl2ZSBpbmhlcml0YW5j" + - "ZSBtZWNoYW5pc20uCgpgYGB5YW1sCi0gbmFtZTogYXBpCiAgdmVyc2lvbjogMS42LjAKICBuYW1l" + - "c3BhY2U6IG52Y2YKICBpbmhlcml0OgogICAgLSB0ZW1wbGF0ZTogc2VydmljZQpgYGAKCldoZW4g" + - "YWRkaW5nIGB2YWx1ZXM6YCB0byBhbiBpbmhlcml0ZWQgcmVsZWFzZSwgeW91IGFsc28gbmVlZCB0" + - "byByZS1pbmNsdWRlIHRoZSB0ZW1wbGF0ZSdzIHZhbHVlcyBmaWxlcyBzaW5jZSBgdmFsdWVzYCBp" + - "cyBhIGxpc3QgdGhhdCBnZXRzIHJlcGxhY2VkLgoKIyMgVmFsdWVzIFByZWNlZGVuY2UKCkZyb20g" + - "bG93ZXN0IHRvIGhpZ2hlc3QgcHJpb3JpdHk6CgoxLiBgZW52aXJvbm1lbnRzL2Jhc2UueWFtbGAg" + - "LS0gZGVmYXVsdHMgc2hhcmVkIGFjcm9zcyBhbGwgZW52aXJvbm1lbnRzCjIuIGBlbnZpcm9ubWVu" + - "dHMvPGVudj4ueWFtbGAgLS0gcGVyLWVudmlyb25tZW50IG92ZXJyaWRlcwozLiBgZ2xvYmFsLnlh" + - "bWwuZ290bXBsYCAtLSBHbyB0ZW1wbGF0ZSBwcm9jZXNzaW5nIChjb25zdHJ1Y3RzIGNoYXJ0LXNw" + - "ZWNpZmljIHN0cnVjdHVyZSkKNC4gYDxwcml2YXRlLXZhbHVlcz4vPGVudj4tc2VjcmV0cy55YW1s" + - "YCAtLSBzZW5zaXRpdmUgdmFsdWVzCjUuIElubGluZSBgdmFsdWVzOmAgYmxvY2tzIG9uIHJlbGVh" + - "c2VzIC0tIGhpZ2hlc3QgcHJlY2VkZW5jZQoKIyMgV2hhdCBnbG9iYWwueWFtbC5nb3RtcGwgUGFz" + - "c2VzIFRocm91Z2gKCmBnbG9iYWwueWFtbC5nb3RtcGxgIHJlYWRzIGZyb20gYC5WYWx1ZXNgICh0" + - "aGUgbWVyZ2VkIGVudmlyb25tZW50ICsgZW52LXNwZWNpZmljIFlBTUwpIGFuZCBjb25zdHJ1Y3Rz" + - "IGNoYXJ0LXNwZWNpZmljIHZhbHVlcy4gSXQgb25seSBwYXNzZXMgdGhyb3VnaCBrZXlzIGl0IGV4" + - "cGxpY2l0bHkgcmVmZXJlbmNlczoKCiMjIyBDYXNzYW5kcmEKLSBgY2Fzc2FuZHJhLnJlcGxpY2FD" + - "b3VudGAKLSBgY2Fzc2FuZHJhLmltYWdlLipgIChyZWdpc3RyeSwgcmVwb3NpdG9yeSkKLSBgY2Fz" + - "c2FuZHJhLm1pZ3JhdGlvbnMuaW1hZ2UuKmAKLSBgY2Fzc2FuZHJhLnBlcnNpc3RlbmNlLnNpemVg" + - "Ci0gYGNhc3NhbmRyYS5ub2RlU2VsZWN0b3JgIChpZiBgZ2xvYmFsLm5vZGVTZWxlY3RvcnMuZW5h" + - "YmxlZGApCi0gYGNhc3NhbmRyYS5nbG9iYWwuZGVmYXVsdFN0b3JhZ2VDbGFzc2AKCiMjIyBOQVRT" + - "Ci0gYG5hdHMuY29udGFpbmVyLmltYWdlLipgCi0gYG5hdHMucmVsb2FkZXIuaW1hZ2UuKmAKLSBg" + - "bmF0cy5uYXRzQm94LmNvbnRhaW5lci5pbWFnZS4qYAotIGBuYXRzLmNvbmZpZy5qZXRzdHJlYW0u" + - "ZmlsZVN0b3JlLnB2Yy5zdG9yYWdlQ2xhc3NOYW1lYAotIGBuYXRzLnBvZFRlbXBsYXRlLm1lcmdl" + - "LnNwZWMubm9kZVNlbGVjdG9yYCAoaWYgZW5hYmxlZCkKCiMjIyBPcGVuQmFvCi0gYG9wZW5iYW8u" + - "bWlncmF0aW9ucy5pbWFnZS4qYCBhbmQgYG9wZW5iYW8ubWlncmF0aW9ucy5lbnZgCi0gYG9wZW5i" + - "YW8uaW5qZWN0b3IuaW1hZ2UuKmAKLSBgb3BlbmJhby5zZXJ2ZXIuaW1hZ2UuKmAKLSBgb3BlbmJh" + - "by5zZXJ2ZXIuZGF0YVN0b3JhZ2UuKmAKLSBOb2RlIHNlbGVjdG9ycyAoaWYgZW5hYmxlZCkKCiMj" + - "IyBTZXJ2aWNlcyAoQVBJLCBTSVMsIGV0Yy4pCi0gYDxzZXJ2aWNlPi5pbWFnZS4qYCAocmVnaXN0" + - "cnksIHJlcG9zaXRvcnkpCi0gYDxzZXJ2aWNlPi5ub2RlU2VsZWN0b3JgIChpZiBlbmFibGVkKQot" + - "IGA8c2VydmljZT4uZW52LipgIChvYnNlcnZhYmlsaXR5IHNldHRpbmdzKQoKIyMjIExMTSBGdW5j" + - "dGlvbiBFbmFibGVtZW50CgpFbmFibGUgdGhlIExMTSBhZGRvbiBiZWZvcmUgY3JlYXRpbmcgb3Ig" + - "aW52b2tpbmcgZnVuY3Rpb25zIHdpdGgKYGZ1bmN0aW9uVHlwZTogIkxMTSJgLiBUaGUgYWRkb24g" + - "ZGVwbG95cyBgbGxtLXJlcXVlc3Qtcm91dGVyYCBhbmQKYGxsbS1hcGktZ2F0ZXdheWAsIGFkZHMg" + - "dGhlIGBsbG0uaW52b2NhdGlvbi48ZG9tYWluPmAgcm91dGUgd2hlbiBHYXRld2F5IEFQSQppbmdy" + - "ZXNzIGlzIGVuYWJsZWQsIGFuZCBjb25maWd1cmVzIHdvcmtlcnMgdG8gdXNlIHRoZSBMTE0gc2lk" + - "ZWNhci4gVGhlIEhlbG1maWxlCmNvbmRpdGlvbiBpcyBgYWRkb25zLmxsbS5lbmFibGVkYC4gRG8g" + - "bm90IHVzZSB0aGUgb2Jzb2xldGUgYGxsbS5lbmFibGVkYCBwYXRoLgoKRm9yIGEgc2luZ2xlLW5v" + - "ZGUgaXNvbGF0ZWQgdGVzdCBjbHVzdGVyLCBhZGQgdGhpcyBjb25maWd1cmF0aW9uIHRvCmBlbnZp" + - "cm9ubWVudHMvPGVudj4ueWFtbGAgYmVmb3JlIGFwcGx5aW5nIHRoZSBzdGFjazoKCmBgYHlhbWwK" + - "YWRkb25zOgogIGxsbToKICAgIGVuYWJsZWQ6IHRydWUKICAgIGdhdGV3YXk6CiAgICAgIHJlcGxp" + - "Y2FDb3VudDogMQogICAgICBhdXRoOgogICAgICAgIGdycGNJbnNlY3VyZTogdHJ1ZQogICAgICBt" + - "ZXRyaWNzOgogICAgICAgIHNlcnZpY2VNb25pdG9yOgogICAgICAgICAgZW5hYmxlZDogZmFsc2UK" + - "ICAgIHJlcXVlc3RSb3V0ZXI6CiAgICAgIHJlcGxpY2FDb3VudDogMQogICAgICBtZXRyaWNzOgog" + - "ICAgICAgIHNlcnZpY2VNb25pdG9yOgogICAgICAgICAgZW5hYmxlZDogZmFsc2UKCmFnZW50Q29u" + - "ZmlnOgogIG1lcmdlQ29uZmlnOiB8CiAgICBjbHVzdGVyOgogICAgICB2YWxpZGF0aW9uUG9saWN5" + - "OgogICAgICAgIG5hbWU6IFVucmVzdHJpY3RlZAogICAgd29ya2xvYWQ6CiAgICAgIHN0YXJnYXRl" + - "UVVJQ0luc2VjdXJlOiB0cnVlCmBgYAoKVXNlIGByZXBsaWNhQ291bnQ6IDFgIG9ubHkgZm9yIGxv" + - "Y2FsIG9yIHNpbmdsZS1ub2RlIHRlc3QgY2x1c3RlcnMuIEZvciBzaGFyZWQKb3IgcHJvZHVjdGlv" + - "biBjbHVzdGVycywgdXNlIHRoZSByZXF1aXJlZCByZXBsaWNhIGNvdW50IGFuZCBUTFMtY2FwYWJs" + - "ZSBzZXJ2aWNlCmNvbmZpZ3VyYXRpb24uIGBhZGRvbnMubGxtLmdhdGV3YXkuYXV0aC5ncnBjSW5z" + - "ZWN1cmVgIGFuZApgd29ya2xvYWQuc3RhcmdhdGVRVUlDSW5zZWN1cmVgIGVuYWJsZSBwbGFpbnRl" + - "eHQgdHJhbnNwb3J0cy4gRG8gbm90IHVzZSB0aGVtIGluCnByb2R1Y3Rpb24uCgpUaGUgcmVxdWVz" + - "dCByb3V0ZXIgdXNlcyBgcG93ZXItb2YtdHdvYCB3aGVuIG5vIGxvYWQtYmFsYW5jZXIgY29uZmln" + - "dXJhdGlvbiBpcwpzZXQuIENvbmZpZ3VyZSBvdGhlciByb3V0aW5nIG1ldGhvZHMgd2l0aCB0aGUK" + - "W0xMTSBSZXF1ZXN0IFJvdXRlciBMb2FkIEJhbGFuY2luZ10oaHR0cHM6Ly9naXRodWIuY29tL05W" + - "SURJQS9udmNmL2Jsb2IvbWFpbi9kb2NzL3VzZXIvbGxtLXJlcXVlc3Qtcm91dGVyLWxvYWQtYmFs" + - "YW5jaW5nLm1kKQpndWlkZS4KCklmIHRoZSBzaWRlY2FyIGltYWdlIGlzIG1pcnJvcmVkIG91dHNp" + - "ZGUgdGhlIHN0YWNrJ3MgZGVmYXVsdCBpbWFnZSByZWdpc3RyeSBhbmQKcmVwb3NpdG9yeSwgc2V0" + - "IHRoZSBnZW5lcmF0ZWQgd29ya2VyIHNpZGVjYXIgaW1hZ2UgZXhwbGljaXRseToKCmBgYHlhbWwK" + - "YXBpOgogIGVudjoKICAgIE5WQ0ZfU0lERUNBUlNfTExNX1JPVVRFUl9DTElFTlRfSU1BR0U6IDxy" + - "ZWdpc3RyeT4vPHJlcG9zaXRvcnk+L3B5bG9uOjAuMi4xCmBgYAoKUmVuZGVyIGFuZCBhcHBseSB0" + - "aGUgdXBkYXRlZCBjb250cm9sLXBsYW5lIGVudmlyb25tZW50LCB0aGVuIHJlZnJlc2ggZXZlcnkK" + - "cmVnaXN0ZXJlZCBjb21wdXRlIHBsYW5lIHVzaW5nIHRoZSBzYW1lIGhhbmRvZmYgdXNlZCBmb3Ig" + - "aXRzIGluc3RhbGxhdGlvbiBzbwpOVkNBIHJlY2VpdmVzIGBhZ2VudENvbmZpZy5tZXJnZUNvbmZp" + - "Z2A6CgpgYGBiYXNoCkhFTE1GSUxFX0VOVj08ZW52PiBoZWxtZmlsZSB0ZW1wbGF0ZQpIRUxNRklM" + - "RV9FTlY9PGVudj4gaGVsbWZpbGUgc3luYwpgYGAKClVzZSB0aGUgY29tcGxldGUgY29tcHV0ZS1w" + - "bGFuZSBpbnN0YWxsIGNvbW1hbmQgZnJvbQpbU3BsaXQgQ29tcHV0ZS1QbGFuZSBJbnN0YWxsYXRp" + - "b25dKGNvbXB1dGUtcGxhbmUtaW5zdGFsbGF0aW9uLm1kKS4gQQpDTEktcHJvZmlsZSBpbnN0YWxs" + - "YXRpb24gbXVzdCByZW1haW4gcHJvZmlsZS1kcml2ZW47IGEgSGVsbWZpbGUgaW5zdGFsbGF0aW9u" + - "Cm11c3QgcmVtYWluIHZhbHVlcy1kcml2ZW4uCgpFeGlzdGluZyBMTE0gZnVuY3Rpb24gcG9kcyBr" + - "ZWVwIHRoZWlyIGV4aXN0aW5nIHNpZGVjYXIgYXJndW1lbnRzLiBSZWNyZWF0ZSBvcgpyZWRlcGxv" + - "eSB0aG9zZSBmdW5jdGlvbnMgYWZ0ZXIgdGhlIGNvbXB1dGUtcGxhbmUgcmVmcmVzaC4gVmVyaWZ5" + - "IHRoZSBjb250cm9sCnBsYW5lLCByb3V0ZSwgYW5kIHdvcmtlciBzaWRlY2FyOgoKYGBgYmFzaApr" + - "dWJlY3RsIGdldCBkZXBsb3kgLW4gbnZjZiBsbG0tYXBpLWdhdGV3YXkKa3ViZWN0bCBnZXQgc3Rh" + - "dGVmdWxzZXQgLW4gbnZjZiBsbG0tcmVxdWVzdC1yb3V0ZXIKa3ViZWN0bCBnZXQgcG9kcyAtbiBu" + - "dmNmIHwgZ3JlcCAtRSAnbGxtLWFwaS1nYXRld2F5fGxsbS1yZXF1ZXN0LXJvdXRlcicKa3ViZWN0" + - "bCBnZXQgaHR0cHJvdXRlIC1BIHwgZ3JlcCBsbG0Ka3ViZWN0bCAtbiBudmNmLWJhY2tlbmQgZ2V0" + - "IHBvZCA8ZnVuY3Rpb24tcG9kPiBcCiAgLW8ganNvbnBhdGg9J3tyYW5nZSAuc3BlYy5jb250YWlu" + - "ZXJzWz8oQC5uYW1lPT0ibGxtLXdvcmtlciIpXS5hcmdzWypdfXsufXsiXFxuIn17ZW5kfScKYGBg" + - "CgpGb3IgbG9jYWwgcGxhaW50ZXh0IGNsdXN0ZXJzLCB0aGUgYGxsbS13b3JrZXJgIGFyZ3MgbXVz" + - "dCBpbmNsdWRlCmAtLXF1aWMtaW5zZWN1cmVgLgoKRm9yIGxvYWQtYmFsYW5jZXIgc2NoZW1hIGFu" + - "ZCBhbGdvcml0aG0gYmVoYXZpb3IsIHNlZSB0aGUKW1N0YXJnYXRlIGNvbmZpZ3VyYXRpb24gZ3Vp" + - "ZGVdKGh0dHBzOi8vZ2l0aHViLmNvbS9OVklESUEvbnZjZi9ibG9iL21haW4vc3JjL2xpYnJhcmll" + - "cy9ydXN0L3N0YXJnYXRlL2RvY3MvbG9hZC1iYWxhbmNlci1jb25maWd1cmF0aW9uLm1kKS4KCiMj" + - "IEhlbG1maWxlIFNlbGVjdG9ycwoKVGFyZ2V0IHNwZWNpZmljIHJlbGVhc2VzIG9yIGdyb3VwczoK" + - "CmBgYGJhc2gKIyBCeSByZWxlYXNlIGdyb3VwCkhFTE1GSUxFX0VOVj08ZW52PiBoZWxtZmlsZSAt" + - "LXNlbGVjdG9yIHJlbGVhc2UtZ3JvdXA9ZGVwZW5kZW5jaWVzIHN5bmMKSEVMTUZJTEVfRU5WPTxl" + - "bnY+IGhlbG1maWxlIC0tc2VsZWN0b3IgcmVsZWFzZS1ncm91cD1zZXJ2aWNlcyBzeW5jCkhFTE1G" + - "SUxFX0VOVj08ZW52PiBoZWxtZmlsZSAtLXNlbGVjdG9yIHJlbGVhc2UtZ3JvdXA9aW5ncmVzcyBz" + - "eW5jCkhFTE1GSUxFX0VOVj08ZW52PiBoZWxtZmlsZSAtLXNlbGVjdG9yIHJlbGVhc2UtZ3JvdXA9" + - "b2JzZXJ2YWJpbGl0eSBzeW5jCgojIEJ5IHJlbGVhc2UgbmFtZQpIRUxNRklMRV9FTlY9PGVudj4g" + - "aGVsbWZpbGUgLS1zZWxlY3RvciBuYW1lPWNhc3NhbmRyYSBzeW5jCkhFTE1GSUxFX0VOVj08ZW52" + - "PiBoZWxtZmlsZSAtLXNlbGVjdG9yIG5hbWU9YWRtaW4taXNzdWVyLXByb3h5IHN5bmMKSEVMTUZJ" + - "TEVfRU5WPTxlbnY+IGhlbG1maWxlIC0tc2VsZWN0b3IgbmFtZT1sbG0tcmVxdWVzdC1yb3V0ZXIg" + - "c3luYwpIRUxNRklMRV9FTlY9PGVudj4gaGVsbWZpbGUgLS1zZWxlY3RvciBuYW1lPWxsbS1hcGkt" + - "Z2F0ZXdheSBzeW5jCgojIFRlbXBsYXRlIG9ubHkgKGRyeSBydW4pCkhFTE1GSUxFX0VOVj08ZW52" + - "PiBoZWxtZmlsZSAtLXNlbGVjdG9yIG5hbWU9Y2Fzc2FuZHJhIHRlbXBsYXRlCgojIERlc3Ryb3kg" + - "YSBzaW5nbGUgcmVsZWFzZQpIRUxNRklMRV9FTlY9PGVudj4gaGVsbWZpbGUgLS1zZWxlY3RvciBu" + - "YW1lPWNhc3NhbmRyYSBkZXN0cm95CmBgYAoKTm90ZTogYGFkbWluLWlzc3Vlci1wcm94eWAgaGFz" + - "IG5vIGByZWxlYXNlLWdyb3VwYCBsYWJlbC4gVXNlIGAtLXNlbGVjdG9yIG5hbWU9YWRtaW4taXNz" + - "dWVyLXByb3h5YC4KUEsHCMBWIOePJwAAjycAAFBLAwQUAAgAAAAAACEAAAAAAAAAAAAAAAAAPwAJ" + - "AGRhdGEvbnZjZi1zZWxmLW1hbmFnZWQtaW5zdGFsbGF0aW9uL3JlZmVyZW5jZXMvbnZjZi11aS1h" + - "ZGRvbi5tZFVUBQABAKbOEiMgTlZDRiBVSSBBZGRvbgoKTlZDRiBVSSBpcyBhbiBvcHRpb25hbCwg" + - "Y3VzdG9tZXItZmFjaW5nIE5WQ0YgYWRtaW4tcGFuZWwgVUkuIEl0IGlzIGRpc2FibGVkIGJ5CmRl" + - "ZmF1bHQgYW5kIGF2YWlsYWJsZSBvbmx5IGluIHN0YWNrIHBhY2thZ2VzIHRoYXQgaW5jbHVkZSB0" + - "aGUgTlZDRiBVSSBhZGRvbi4KCiMjIFdoZW4gdG8gZW5hYmxlCgpFbmFibGUgTlZDRiBVSSBvbmx5" + - "IHdoZW4geW91IG5lZWQgdGhlIGFkbWluLXBhbmVsIFVJIGFuZCB5b3VyIGV4dHJhY3RlZCBzdGFj" + - "awpwYWNrYWdlIGluY2x1ZGVzIHRoZSBhZGRvbi4gSWYgdGhlIHBhY2thZ2UgZG9lcyBub3QgY29u" + - "dGFpbiBhIGBudmNmLXVpYCByZWxlYXNlCmFuZCBgbnZjZlVpYCByb3V0ZSB2YWx1ZXMsIHNraXAg" + - "dGhlIGFkZG9uIHVudGlsIHlvdSB1c2UgYSBwYWNrYWdlIHRoYXQgaW5jbHVkZXMKdGhlbS4KCiMj" + - "IEVuYWJsZSB0aGUgYWRkb24KCkVuYWJsZSBpdCBpbiBgZW52aXJvbm1lbnRzLzxlbnYtbmFtZT4u" + - "eWFtbGA6CgpgYGB5YW1sCmFkZG9uczoKICBudmNmVWk6CiAgICBlbmFibGVkOiB0cnVlCmBgYAoK" + - "IyMgQ3JlYXRlIG5hbWVzcGFjZSBhbmQgaW1hZ2UgcHVsbCBzZWNyZXQKCkNyZWF0ZSB0aGUgbmFt" + - "ZXNwYWNlLCBhbmQgYW4gaW1hZ2UgcHVsbCBzZWNyZXQgb25seSBpZiBwdWxsaW5nIGZyb20gYSBw" + - "cml2YXRlCnJlZ2lzdHJ5OgoKYGBgYmFzaAprdWJlY3RsIGNyZWF0ZSBuYW1lc3BhY2UgbnZjZi11" + - "aSAtLWRyeS1ydW49Y2xpZW50IC1vIHlhbWwgfCBrdWJlY3RsIGFwcGx5IC1mIC0KCiMgT25seSBp" + - "ZiBwdWxsaW5nIGZyb20gYSBwcml2YXRlIHJlZ2lzdHJ5IChlLmcuLCBOR0MgbnZjci5pbykKZXhw" + - "b3J0IE5HQ19BUElfS0VZPSI8eW91ci1rZXk+IgprdWJlY3RsIGNyZWF0ZSBzZWNyZXQgZG9ja2Vy" + - "LXJlZ2lzdHJ5IG52Y3ItY3JlZHMgXAogIC0tZG9ja2VyLXNlcnZlcj1udmNyLmlvIFwKICAtLWRv" + - "Y2tlci11c2VybmFtZT0nJG9hdXRodG9rZW4nIFwKICAtLWRvY2tlci1wYXNzd29yZD0iJE5HQ19B" + - "UElfS0VZIiBcCiAgLS1uYW1lc3BhY2U9bnZjZi11aSBcCiAgLS1kcnktcnVuPWNsaWVudCAtbyB5" + - "YW1sIHwga3ViZWN0bCBhcHBseSAtZiAtCmBgYAoKVGhlIGRlZmF1bHQgcm91dGUgaG9zdCBpcyBg" + - "bnZjZi11aS48ZG9tYWluPmAgYW5kIHRoZSBiYWNrZW5kIGlzCmBudmNmLXVpLm52Y2YtdWk6ODMw" + - "MGAuCgojIyBBcHBseSB0aGUgc2VydmljZSBhbmQgcm91dGUKCkFmdGVyIGNvbmZpcm1pbmcgdGhl" + - "IHBhY2thZ2UgaW5jbHVkZXMgdGhlIGBudmNmLXVpYCByZWxlYXNlLCBwcmV2aWV3IGFuZCBhcHBs" + - "eQp0aGUgc2VydmljZSBhbmQgcm91dGU6CgpgYGBiYXNoCkhFTE1GSUxFX0VOVj08ZW52LW5hbWU+" + - "IGhlbG1maWxlIC0tc2VsZWN0b3IgbmFtZT1udmNmLXVpIHRlbXBsYXRlCkhFTE1GSUxFX0VOVj08" + - "ZW52LW5hbWU+IGhlbG1maWxlIC0tc2VsZWN0b3IgbmFtZT1udmNmLXVpIHN5bmMKSEVMTUZJTEVf" + - "RU5WPTxlbnYtbmFtZT4gaGVsbWZpbGUgLS1zZWxlY3RvciByZWxlYXNlLWdyb3VwPWluZ3Jlc3Mg" + - "c3luYwpgYGAKCiMjIFZlcmlmeQoKVmVyaWZ5IHRoZSByb3V0ZSBvbmx5IHdoZW4gdGhlIGFkZG9u" + - "IGlzIHByZXNlbnQgYW5kIGVuYWJsZWQ6CgpgYGBiYXNoCmt1YmVjdGwgZ2V0IGRlcGxveSxzdmMg" + - "LW4gbnZjZi11aQprdWJlY3RsIGdldCBodHRwcm91dGUgLUEgfCBncmVwIC1pIG52Y2YtdWkKY3Vy" + - "bCAtaSAtSCAiSG9zdDogbnZjZi11aS48ZG9tYWluPiIgImh0dHA6Ly88Z2F0ZXdheS1hZGRyZXNz" + - "Pi9zdGF0dXMiCmBgYAoKIyMgU2VjdXJpdHkKClRoZSBOVkNGIFVJIGFkbWluIHBhbmVsIGlzIGN1" + - "cnJlbnRseSB1bmF1dGhlbnRpY2F0ZWQuIERvIG5vdCBleHBvc2UgaXQgdG8gdGhlCnB1YmxpYyBp" + - "bnRlcm5ldC4gUmVzdHJpY3QgYWNjZXNzIHRvIGEgdHJ1c3RlZCBuZXR3b3JrLCBWUE4sIG9yIGFu" + - "IGF1dGhlbnRpY2F0aW5nCnByb3h5IGluIGZyb250IG9mIHRoZSBgbnZjZi11aWAgcm91dGUuClBL" + - "Bwg4+SevuQcAALkHAABQSwMEFAAIAAAAAAAhAAAAAAAAAAAAAAAAAD4ACQBkYXRhL252Y2Ytc2Vs" + - "Zi1tYW5hZ2VkLWluc3RhbGxhdGlvbi9yZWZlcmVuY2VzL3B1bGwtc2VjcmV0cy5tZFVUBQABAKbO" + - "EiMgSW1hZ2UgUHVsbCBTZWNyZXRzIFJlZmVyZW5jZQoKIyMgT3ZlcnZpZXcKCldoZW4gcHVsbGlu" + - "ZyBOVkNGIGltYWdlcyBmcm9tIGEgcHJpdmF0ZSByZWdpc3RyeSAoZm9yIGV4YW1wbGUsIE5HQwpg" + - "bnZjci5pb2ApLCBLdWJlcm5ldGVzIG5lZWRzIGBpbWFnZVB1bGxTZWNyZXRzYCBvbiBldmVyeSBw" + - "b2QuIENvbnRyb2wtcGxhbmUgYW5kCmNvbXB1dGUtcGxhbmUgY3JlZGVudGlhbHMgYXJlIGNvbmZp" + - "Z3VyZWQgaW4gdGhlaXIgb3duIGNsdXN0ZXIgY29udGV4dHMuIERvIG5vdAp1c2Ugb25lIG1peGVk" + - "IG5hbWVzcGFjZSBsaXN0LgoKVGhlIHJlY29tbWVuZGVkIGNvbnRyb2wtcGxhbmUgYXBwcm9hY2gg" + - "dXNlcyBLeXZlcm5vIHRvIGluamVjdCB0aGUgc2VjcmV0IGludG8KY29udHJvbC1wbGFuZSBwb2Rz" + - "IGF0IGFkbWlzc2lvbiB0aW1lLiBUaGUgY29tcHV0ZS1wbGFuZSBjaGFydCBhbmQgb3BlcmF0b3Ig" + - "dXNlCnRoZSBzZWNyZXQgaW4gYG52Y2Etb3BlcmF0b3JgIGFuZCBtaXJyb3IgaXQgdG8gYG52Y2Et" + - "c3lzdGVtYC4KCiMjIEt5dmVybm8gQXBwcm9hY2ggKFJlY29tbWVuZGVkKQoKIyMjIDEuIEluc3Rh" + - "bGwgS3l2ZXJubwoKYGBgYmFzaApoZWxtIHJlcG8gYWRkIGt5dmVybm8gaHR0cHM6Ly9reXZlcm5v" + - "LmdpdGh1Yi5pby9reXZlcm5vLwpoZWxtIHJlcG8gdXBkYXRlCmhlbG0gaW5zdGFsbCBreXZlcm5v" + - "IGt5dmVybm8va3l2ZXJubyAtbiBreXZlcm5vIC0tY3JlYXRlLW5hbWVzcGFjZSBcCiAgLS1rdWJl" + - "LWNvbnRleHQgPGNvbnRyb2wtcGxhbmUtY29udGV4dD4KYGBgCgojIyMgMi4gQ3JlYXRlIGNvbnRy" + - "b2wtcGxhbmUgcHVsbCBzZWNyZXRzCgpgYGBiYXNoCmV4cG9ydCBOR0NfQVBJX0tFWT0iPHlvdXIt" + - "bmdjLWFwaS1rZXk+IgoKZm9yIG5zIGluIGNhc3NhbmRyYS1zeXN0ZW0gbmF0cy1zeXN0ZW0gbnZj" + - "ZiBhcGkta2V5cyBlc3Mgc2lzIHZhdWx0LXN5c3RlbSBjZXJ0LW1hbmFnZXI7IGRvCiAga3ViZWN0" + - "bCAtLWNvbnRleHQgPGNvbnRyb2wtcGxhbmUtY29udGV4dD4gY3JlYXRlIG5hbWVzcGFjZSAiJG5z" + - "IiBcCiAgICAtLWRyeS1ydW49Y2xpZW50IC1vIHlhbWwgfCBrdWJlY3RsIC0tY29udGV4dCA8Y29u" + - "dHJvbC1wbGFuZS1jb250ZXh0PiBhcHBseSAtZiAtCmRvbmUKCmZvciBucyBpbiBjYXNzYW5kcmEt" + - "c3lzdGVtIG5hdHMtc3lzdGVtIG52Y2YgYXBpLWtleXMgZXNzIHNpcyB2YXVsdC1zeXN0ZW0gY2Vy" + - "dC1tYW5hZ2VyOyBkbwogIGt1YmVjdGwgLS1jb250ZXh0IDxjb250cm9sLXBsYW5lLWNvbnRleHQ+" + - "IGNyZWF0ZSBzZWNyZXQgZG9ja2VyLXJlZ2lzdHJ5IG52Y3ItY3JlZHMgXAogICAgLS1kb2NrZXIt" + - "c2VydmVyPW52Y3IuaW8gXAogICAgLS1kb2NrZXItdXNlcm5hbWU9JyRvYXV0aHRva2VuJyBcCiAg" + - "ICAtLWRvY2tlci1wYXNzd29yZD0iJE5HQ19BUElfS0VZIiBcCiAgICAtLW5hbWVzcGFjZT0iJG5z" + - "IiBcCiAgICAtLWRyeS1ydW49Y2xpZW50IC1vIHlhbWwgfCBrdWJlY3RsIC0tY29udGV4dCA8Y29u" + - "dHJvbC1wbGFuZS1jb250ZXh0PiBhcHBseSAtZiAtCmRvbmUKYGBgCgpGb3Igbm9uLU5HQyByZWdp" + - "c3RyaWVzLCByZXBsYWNlIGAtLWRvY2tlci1zZXJ2ZXJgLCBgLS1kb2NrZXItdXNlcm5hbWVgLCBh" + - "bmQgYC0tZG9ja2VyLXBhc3N3b3JkYC4KCiMjIyAzLiBBcHBseSBLeXZlcm5vIENsdXN0ZXJQb2xp" + - "Y3kKCmBgYHlhbWwKYXBpVmVyc2lvbjoga3l2ZXJuby5pby92MQpraW5kOiBDbHVzdGVyUG9saWN5" + - "Cm1ldGFkYXRhOgogIG5hbWU6IG52Y2YtYWRkLWltYWdlcHVsbHNlY3JldHMKc3BlYzoKICBiYWNr" + - "Z3JvdW5kOiBmYWxzZQogIHJ1bGVzOgogICAgLSBuYW1lOiBhZGQtaW1hZ2VwdWxsc2VjcmV0LXRv" + - "LW52Y2YtcG9kcwogICAgICBtYXRjaDoKICAgICAgICBhbnk6CiAgICAgICAgLSByZXNvdXJjZXM6" + - "CiAgICAgICAgICAgIGtpbmRzOgogICAgICAgICAgICAtIFBvZAogICAgICAgICAgICBuYW1lc3Bh" + - "Y2VzOgogICAgICAgICAgICAtICJudmNmIgogICAgICAgICAgICAtICJhcGkta2V5cyIKICAgICAg" + - "ICAgICAgLSAic2lzIgogICAgICAgICAgICAtICJlc3MiCiAgICAgICAgICAgIC0gIm5hdHMtc3lz" + - "dGVtIgogICAgICAgICAgICAtICJjYXNzYW5kcmEtc3lzdGVtIgogICAgICAgICAgICAtICJ2YXVs" + - "dC1zeXN0ZW0iCiAgICAgICAgICAgIC0gImNlcnQtbWFuYWdlciIKICAgICAgbXV0YXRlOgogICAg" + - "ICAgIHBhdGNoU3RyYXRlZ2ljTWVyZ2U6CiAgICAgICAgICBtZXRhZGF0YToKICAgICAgICAgICAg" + - "YW5ub3RhdGlvbnM6CiAgICAgICAgICAgICAgbnZjZi5udmlkaWEuY29tL2ltYWdlcHVsbHNlY3Jl" + - "dC1pbmplY3RlZC1ieToga3l2ZXJubwogICAgICAgICAgc3BlYzoKICAgICAgICAgICAgaW1hZ2VQ" + - "dWxsU2VjcmV0czoKICAgICAgICAgICAgLSBuYW1lOiBudmNyLWNyZWRzCmBgYAoKYGBgYmFzaApr" + - "dWJlY3RsIC0tY29udGV4dCA8Y29udHJvbC1wbGFuZS1jb250ZXh0PiBhcHBseSBcCiAgLWYga3l2" + - "ZXJuby1pbWFnZXB1bGxzZWNyZXQtcG9saWN5LnlhbWwKYGBgCgojIyMgNC4gSW5zdGFsbCB0aGUg" + - "Y29udHJvbCBwbGFuZQoKQ29udGludWUgd2l0aCB0aGUgc2VsZWN0ZWQgY29udHJvbC1wbGFuZSBp" + - "bnN0YWxsYXRpb24gaW4KW1NwbGl0IENvbXB1dGUtUGxhbmUgSW5zdGFsbGF0aW9uXShjb21wdXRl" + - "LXBsYW5lLWluc3RhbGxhdGlvbi5tZCkuIE5vCmNvbnRyb2wtcGxhbmUgaGVsbWZpbGUgbW9kaWZp" + - "Y2F0aW9ucyBhcmUgbmVlZGVkLiBLeXZlcm5vIGluamVjdHMgdGhlIHB1bGwKc2VjcmV0IGludG8g" + - "bmV3IGNvbnRyb2wtcGxhbmUgcG9kcy4KCiMjIENvbXB1dGUtUGxhbmUgU2VjcmV0CgpDcmVhdGUg" + - "dGhlIHNlY3JldCBvbmx5IGluIGBudmNhLW9wZXJhdG9yYCBvbiB0aGUgY29tcHV0ZSBjbHVzdGVy" + - "OgoKYGBgYmFzaAprdWJlY3RsIC0tY29udGV4dCA8Y29tcHV0ZS1wbGFuZS1jb250ZXh0PiBjcmVh" + - "dGUgbmFtZXNwYWNlIG52Y2Etb3BlcmF0b3IgXAogIC0tZHJ5LXJ1bj1jbGllbnQgLW8geWFtbCB8" + - "IFwKICBrdWJlY3RsIC0tY29udGV4dCA8Y29tcHV0ZS1wbGFuZS1jb250ZXh0PiBhcHBseSAtZiAt" + - "CgprdWJlY3RsIC0tY29udGV4dCA8Y29tcHV0ZS1wbGFuZS1jb250ZXh0PiBjcmVhdGUgc2VjcmV0" + - "IGRvY2tlci1yZWdpc3RyeSBudmNyLWNyZWRzIFwKICAtLWRvY2tlci1zZXJ2ZXI9bnZjci5pbyBc" + - "CiAgLS1kb2NrZXItdXNlcm5hbWU9JyRvYXV0aHRva2VuJyBcCiAgLS1kb2NrZXItcGFzc3dvcmQ9" + - "IiROR0NfQVBJX0tFWSIgXAogIC0tbmFtZXNwYWNlPW52Y2Etb3BlcmF0b3IgXAogIC0tZHJ5LXJ1" + - "bj1jbGllbnQgLW8geWFtbCB8IFwKICBrdWJlY3RsIC0tY29udGV4dCA8Y29tcHV0ZS1wbGFuZS1j" + - "b250ZXh0PiBhcHBseSAtZiAtCmBgYAoKUmVmZXJlbmNlIGl0IGluIHRoZSBjb21wdXRlLXBsYW5l" + - "IGVudmlyb25tZW50IGZpbGU6CgpgYGB5YW1sCmdsb2JhbDoKICBpbWFnZVB1bGxTZWNyZXRzOgog" + - "ICAgLSBuYW1lOiBudmNyLWNyZWRzCmBgYAoKVGhlIGNoYXJ0IGFuZCBvcGVyYXRvciB1c2UgdGhh" + - "dCByZWZlcmVuY2UgaW4gYG52Y2Etb3BlcmF0b3JgIGFuZCBtaXJyb3IgdGhlCnNlY3JldCB0byBg" + - "bnZjYS1zeXN0ZW1gLiBEbyBub3QgY3JlYXRlIGEgYnJvYWRlciBtYW51YWwgY29tcHV0ZSBuYW1l" + - "c3BhY2UgbGlzdC4gRm9sbG93CltTcGxpdCBDb21wdXRlLVBsYW5lIEluc3RhbGxhdGlvbl0oY29t" + - "cHV0ZS1wbGFuZS1pbnN0YWxsYXRpb24ubWQpIGZvciB0aGUKc2VsZWN0ZWQgaW5zdGFsbCBmbG93" + - "LgoKIyMgVmVyaWZpY2F0aW9uCgpgYGBiYXNoCiMgQ2hlY2sgdGhhdCBhIGNvbnRyb2wtcGxhbmUg" + - "cG9kIGhhcyB0aGUgaW5qZWN0ZWQgc2VjcmV0Cmt1YmVjdGwgLS1jb250ZXh0IDxjb250cm9sLXBs" + - "YW5lLWNvbnRleHQ+IGdldCBwb2QgLW4gPG5hbWVzcGFjZT4gPHBvZC1uYW1lPiBcCiAgLW8ganNv" + - "bnBhdGg9J3suc3BlYy5pbWFnZVB1bGxTZWNyZXRzfScKIyBFeHBlY3RlZDogW3sibmFtZSI6Im52" + - "Y3ItY3JlZHMifV0KCiMgQ2hlY2sgdGhlIEt5dmVybm8gYW5ub3RhdGlvbgprdWJlY3RsIC0tY29u" + - "dGV4dCA8Y29udHJvbC1wbGFuZS1jb250ZXh0PiBnZXQgcG9kIC1uIDxuYW1lc3BhY2U+IDxwb2Qt" + - "bmFtZT4gXAogIC1vIGpzb25wYXRoPSd7Lm1ldGFkYXRhLmFubm90YXRpb25zLm52Y2ZcLm52aWRp" + - "YVwuY29tL2ltYWdlcHVsbHNlY3JldC1pbmplY3RlZC1ieX0nCiMgRXhwZWN0ZWQ6IGt5dmVybm8K" + - "CiMgQ2hlY2sgcHVsbCBldmVudHMKa3ViZWN0bCAtLWNvbnRleHQgPGNvbnRyb2wtcGxhbmUtY29u" + - "dGV4dD4gZ2V0IGV2ZW50cyAtbiA8bmFtZXNwYWNlPiBcCiAgLS1zb3J0LWJ5PScubGFzdFRpbWVz" + - "dGFtcCcgfCBncmVwIC1pIHB1bGwKIyBTaG91bGQgc2hvdyAiU3VjY2Vzc2Z1bGx5IHB1bGxlZCIg" + - "bm90ICI0MDEgVW5hdXRob3JpemVkIgoKIyBDaGVjayB0aGUgY2hhcnQvb3BlcmF0b3IgbWlycm9y" + - "IG9uIHRoZSBjb21wdXRlIGNsdXN0ZXIKa3ViZWN0bCAtLWNvbnRleHQgPGNvbXB1dGUtcGxhbmUt" + - "Y29udGV4dD4gZ2V0IHNlY3JldCBudmNyLWNyZWRzIFwKICAtbiBudmNhLXN5c3RlbQpgYGAKCiMj" + - "IFdoZW4gUHVsbCBTZWNyZXRzIEFyZSBOb3QgTmVlZGVkCgotICoqQVdTIEVDUiB3aXRoIElBTSBu" + - "b2RlIHJvbGVzKio6IElmIHlvdXIgbm9kZXMgaGF2ZSBgQW1hem9uRUMyQ29udGFpbmVyUmVnaXN0" + - "cnlSZWFkT25seWAgSUFNIHBvbGljeSwgS3ViZXJuZXRlcyBjYW4gcHVsbCBmcm9tIEVDUiB3aXRo" + - "b3V0IGV4cGxpY2l0IHNlY3JldHMuCi0gKipQdWJsaWMgcmVnaXN0cmllcyoqOiBObyBwdWxsIHNl" + - "Y3JldHMgbmVlZGVkLgotICoqQ1NQIGJ1aWx0LWluIGNyZWRlbnRpYWwgaGVscGVycyoqOiBHS0Ug" + - "QXJ0aWZhY3QgUmVnaXN0cnksIEF6dXJlIEFDUiB3aXRoIG1hbmFnZWQgaWRlbnRpdHksIGFuZCBz" + - "aW1pbGFyIHNlcnZpY2VzLgoKIyMgVHJvdWJsZXNob290aW5nCgojIyMgUG9kcyBzdGlsbCBpbiBJ" + - "bWFnZVB1bGxCYWNrT2ZmIGFmdGVyIGFwcGx5aW5nIHBvbGljeQoKVGhlIEt5dmVybm8gcG9saWN5" + - "IG9ubHkgYWZmZWN0cyBwb2RzIGNyZWF0ZWQgKiphZnRlcioqIHRoZSBwb2xpY3kgaXMgYXBwbGll" + - "ZC4gRGVsZXRlIHN0dWNrIHBvZHMgdG8gdHJpZ2dlciByZWNyZWF0aW9uOgoKYGBgYmFzaAprdWJl" + - "Y3RsIC0tY29udGV4dCA8dGFyZ2V0LWNvbnRleHQ+IGRlbGV0ZSBwb2RzIC1uIDxuYW1lc3BhY2U+" + - "IC0tYWxsCmBgYAoKIyMjIEt5dmVybm8gYWRtaXNzaW9uIGNvbnRyb2xsZXIgbm90IHJ1bm5pbmcK" + - "CmBgYGJhc2gKa3ViZWN0bCAtLWNvbnRleHQgPGNvbnRyb2wtcGxhbmUtY29udGV4dD4gZ2V0IHBv" + - "ZHMgLW4ga3l2ZXJubwojIEFsbCBwb2RzIHNob3VsZCBiZSBSdW5uaW5nCmBgYAoKIyMjIFBvbGlj" + - "eSBub3QgbWF0Y2hpbmcKCmBgYGJhc2gKa3ViZWN0bCAtLWNvbnRleHQgPGNvbnRyb2wtcGxhbmUt" + - "Y29udGV4dD4gZ2V0IGNsdXN0ZXJwb2xpY3kgbnZjZi1hZGQtaW1hZ2VwdWxsc2VjcmV0cwojIFNo" + - "b3VsZCBzaG93IFJFQURZOiBUcnVlCmBgYAoKIyMjIFdyb25nIHNlY3JldCBuYW1lCgpUaGUgcG9s" + - "aWN5IHJlZmVyZW5jZXMgYG52Y3ItY3JlZHNgLiBWZXJpZnkgdGhlIHNlY3JldCBleGlzdHMgd2l0" + - "aCB0aGF0IGV4YWN0IG5hbWU6CgpgYGBiYXNoCmt1YmVjdGwgLS1jb250ZXh0IDx0YXJnZXQtY29u" + - "dGV4dD4gZ2V0IHNlY3JldCBudmNyLWNyZWRzIC1uIDxuYW1lc3BhY2U+CmBgYApQSwcIS0I1qAAW" + - "AAAAFgAAUEsBAhQAFAAIAAAAAAAhADmTR89IEAAASBAAABIACQAAAAAAAAAAAAAAAAAAAGRhdGEv" + - "bWFuaWZlc3QuanNvblVUBQABAKbOElBLAQIUABQACAAAAAAAIQDNgTDkTWEAAE1hAAAjAAkAAAAA" + - "AAAAAAAAAJEQAABkYXRhL252Y2Ytc2VsZi1tYW5hZ2VkLWNsaS9TS0lMTC5tZFVUBQABAKbOElBL" + - "AQIUABQACAAAAAAAIQAhxsiG8AoAAPAKAAAzAAkAAAAAAAAAAAAAADhyAABkYXRhL252Y2Ytc2Vs" + - "Zi1tYW5hZ2VkLWNsaS9leGFtcGxlcy9jaS1waXBlbGluZXMubWRVVAUAAQCmzhJQSwECFAAUAAgA" + - "AAAAACEAoRTjgV0MAABdDAAANAAJAAAAAAAAAAAAAACSfQAAZGF0YS9udmNmLXNlbGYtbWFuYWdl" + - "ZC1jbGkvZXhhbXBsZXMvbXVsdGktY2x1c3Rlci5tZFVUBQABAKbOElBLAQIUABQACAAAAAAAIQBC" + - "J0kPBQ0AAAUNAAA3AAkAAAAAAAAAAAAAAFqKAABkYXRhL252Y2Ytc2VsZi1tYW5hZ2VkLWNsaS9w" + - "cm9tcHRzL2FkZC1jb21wdXRlLXBsYW5lLm1kVVQFAAEAps4SUEsBAhQAFAAIAAAAAAAhAJHcG/mY" + - "GQAAmBkAADkACQAAAAAAAAAAAAAAzZcAAGRhdGEvbnZjZi1zZWxmLW1hbmFnZWQtY2xpL3Byb21w" + - "dHMvY3JlYXRlLWFuZC1ydW4tdGFzay5tZFVUBQABAKbOElBLAQIUABQACAAAAAAAIQDSQ9wEGCUA" + - "ABglAAA3AAkAAAAAAAAAAAAAANWxAABkYXRhL252Y2Ytc2VsZi1tYW5hZ2VkLWNsaS9wcm9tcHRz" + - "L2RlcGxveS1hbmQtaW52b2tlLm1kVVQFAAEAps4SUEsBAhQAFAAIAAAAAAAhAA6cP5e9DgAAvQ4A" + - "AD0ACQAAAAAAAAAAAAAAW9cAAGRhdGEvbnZjZi1zZWxmLW1hbmFnZWQtY2xpL3Byb21wdHMvZGlh" + - "Z25vc2UtZmFpbGVkLWluc3RhbGwubWRVVAUAAQCmzhJQSwECFAAUAAgAAAAAACEAhyuNmFocAABa" + - "HAAAOgAJAAAAAAAAAAAAAACM5gAAZGF0YS9udmNmLXNlbGYtbWFuYWdlZC1jbGkvcHJvbXB0cy9p" + - "bnN0YWxsLWZyb20tc2NyYXRjaC5tZFVUBQABAKbOElBLAQIUABQACAAAAAAAIQAaxCyexwcAAMcH" + - "AAA5AAkAAAAAAAAAAAAAAFcDAQBkYXRhL252Y2Ytc2VsZi1tYW5hZ2VkLWNsaS9wcm9tcHRzL3Jv" + - "dGF0ZS1jbHVzdGVyLWp3a3MubWRVVAUAAQCmzhJQSwECFAAUAAgAAAAAACEAEpMzWeAhAADgIQAA" + - "LgAJAAAAAAAAAAAAAACOCwEAZGF0YS9udmNmLXNlbGYtbWFuYWdlZC1jbGkvcHJvbXB0cy90ZWFy" + - "ZG93bi5tZFVUBQABAKbOElBLAQIUABQACAAAAAAAIQByDQ9kISMAACEjAAAwAAkAAAAAAAAAAAAA" + - "ANMtAQBkYXRhL252Y2Ytc2VsZi1tYW5hZ2VkLWNsaS9yZWZlcmVuY2UvY29tbWFuZHMubWRVVAUA" + - "AQCmzhJQSwECFAAUAAgAAAAAACEAc6daZNUGAADVBgAAMgAJAAAAAAAAAAAAAABbUQEAZGF0YS9u" + - "dmNmLXNlbGYtbWFuYWdlZC1jbGkvcmVmZXJlbmNlL2V4aXQtY29kZXMubWRVVAUAAQCmzhJQSwEC" + - "FAAUAAgAAAAAACEA/KOR4MYiAADGIgAALQAJAAAAAAAAAAAAAACZWAEAZGF0YS9udmNmLXNlbGYt" + - "bWFuYWdlZC1jbGkvcmVmZXJlbmNlL2ZsYWdzLm1kVVQFAAEAps4SUEsBAhQAFAAIAAAAAAAhAPOu" + - "E4R0EQAAdBEAADcACQAAAAAAAAAAAAAAw3sBAGRhdGEvbnZjZi1zZWxmLW1hbmFnZWQtY2xpL3Jl" + - "ZmVyZW5jZS90cm91Ymxlc2hvb3RpbmcubWRVVAUAAQCmzhJQSwECFAAUAAgAAAAAACEAL9q5dUJi" + - "AABCYgAALAAJAAAAAAAAAAAAAACljQEAZGF0YS9udmNmLXNlbGYtbWFuYWdlZC1pbnN0YWxsYXRp" + - "b24vU0tJTEwubWRVVAUAAQCmzhJQSwECFAAUAAgAAAAAACEAKxO4P61VAACtVQAANAAJAAAAAAAA" + - "AAAAAABK8AEAZGF0YS9udmNmLXNlbGYtbWFuYWdlZC1pbnN0YWxsYXRpb24vZXZhbHMvZXZhbHMu" + - "anNvblVUBQABAKbOElBLAQIUABQACAAAAAAAIQACUk5AfygAAH8oAAAvAAkAAAAAAAAAAAAAAGJG" + - "AgBkYXRhL252Y2Ytc2VsZi1tYW5hZ2VkLWluc3RhbGxhdGlvbi9leGFtcGxlcy5tZFVUBQABAKbO" + - "ElBLAQIUABQACAAAAAAAIQCWY7xZEjAAABIwAABMAAkAAAAAAAAAAAAAAEdvAgBkYXRhL252Y2Yt" + - "c2VsZi1tYW5hZ2VkLWluc3RhbGxhdGlvbi9yZWZlcmVuY2VzL2NvbXB1dGUtcGxhbmUtaW5zdGFs" + - "bGF0aW9uLm1kVVQFAAEAps4SUEsBAhQAFAAIAAAAAAAhAFY+Z5CVMAAAlTAAADsACQAAAAAAAAAA" + - "AAAA3J8CAGRhdGEvbnZjZi1zZWxmLW1hbmFnZWQtaW5zdGFsbGF0aW9uL3JlZmVyZW5jZXMvZGVi" + - "dWdnaW5nLm1kVVQFAAEAps4SUEsBAhQAFAAIAAAAAAAhAMBWIOePJwAAjycAAEQACQAAAAAAAAAA" + - "AAAA49ACAGRhdGEvbnZjZi1zZWxmLW1hbmFnZWQtaW5zdGFsbGF0aW9uL3JlZmVyZW5jZXMvaGVs" + - "bWZpbGUtc3RydWN0dXJlLm1kVVQFAAEAps4SUEsBAhQAFAAIAAAAAAAhADj5J6+5BwAAuQcAAD8A" + - "CQAAAAAAAAAAAAAA7fgCAGRhdGEvbnZjZi1zZWxmLW1hbmFnZWQtaW5zdGFsbGF0aW9uL3JlZmVy" + - "ZW5jZXMvbnZjZi11aS1hZGRvbi5tZFVUBQABAKbOElBLAQIUABQACAAAAAAAIQBLQjWoABYAAAAW" + - "AAA+AAkAAAAAAAAAAAAAABwBAwBkYXRhL252Y2Ytc2VsZi1tYW5hZ2VkLWluc3RhbGxhdGlvbi9y" + - "ZWZlcmVuY2VzL3B1bGwtc2VjcmV0cy5tZFVUBQABAKbOElBLBQYAAAAAFwAXAK8JAACRFwMAAAA=" + "LXNlY3JldHMueWFtbAoKIyBXaGVuIG92ZXJyaWRpbmcsIE1VU1QgcmUtaW5jbHVkZSBib3RoOgot" + + "IG5hbWU6IGNhc3NhbmRyYQogIDw8OiAqZGVwZW5kZW5jeQogIHZhbHVlczoKICAgIC0gLi4vZ2xv" + + "YmFsLnlhbWwuZ290bXBsICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg" + + "ICAgICMgTXVzdCByZS1pbmNsdWRlCiAgICAtIC4uLzxwcml2YXRlLXZhbHVlcz4ve3sgcmVxdWly" + + "ZWRFbnYgIkhFTE1GSUxFX0VOViIgfX0tc2VjcmV0cy55YW1sICAgIyBNdXN0IHJlLWluY2x1ZGUK" + + "ICAgIC0gY2Fzc2FuZHJhOiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg" + + "ICAgICAgICAgICAgICAgICAjIFlvdXIgb3ZlcnJpZGUKICAgICAgICByZXNvdXJjZXM6CiAgICAg" + + "ICAgICBsaW1pdHM6CiAgICAgICAgICAgIG1lbW9yeTogODE5Mk1pCmBgYAoKIyMjIGBpbmhlcml0" + + "YCAoSGVsbWZpbGUgbmF0aXZlKQoKVXNlZCBpbiBgMDItY29yZS55YW1sLmdvdG1wbGAuIEhlbG1m" + + "aWxlJ3MgbmF0aXZlIGluaGVyaXRhbmNlIG1lY2hhbmlzbS4KCmBgYHlhbWwKLSBuYW1lOiBhcGkK" + + "ICB2ZXJzaW9uOiAxLjYuMAogIG5hbWVzcGFjZTogbnZjZgogIGluaGVyaXQ6CiAgICAtIHRlbXBs" + + "YXRlOiBzZXJ2aWNlCmBgYAoKV2hlbiBhZGRpbmcgYHZhbHVlczpgIHRvIGFuIGluaGVyaXRlZCBy" + + "ZWxlYXNlLCB5b3UgYWxzbyBuZWVkIHRvIHJlLWluY2x1ZGUgdGhlIHRlbXBsYXRlJ3MgdmFsdWVz" + + "IGZpbGVzIHNpbmNlIGB2YWx1ZXNgIGlzIGEgbGlzdCB0aGF0IGdldHMgcmVwbGFjZWQuCgojIyBW" + + "YWx1ZXMgUHJlY2VkZW5jZQoKRnJvbSBsb3dlc3QgdG8gaGlnaGVzdCBwcmlvcml0eToKCjEuIGBl" + + "bnZpcm9ubWVudHMvYmFzZS55YW1sYCAtLSBkZWZhdWx0cyBzaGFyZWQgYWNyb3NzIGFsbCBlbnZp" + + "cm9ubWVudHMKMi4gYGVudmlyb25tZW50cy88ZW52Pi55YW1sYCAtLSBwZXItZW52aXJvbm1lbnQg" + + "b3ZlcnJpZGVzCjMuIGBnbG9iYWwueWFtbC5nb3RtcGxgIC0tIEdvIHRlbXBsYXRlIHByb2Nlc3Np" + + "bmcgKGNvbnN0cnVjdHMgY2hhcnQtc3BlY2lmaWMgc3RydWN0dXJlKQo0LiBgPHByaXZhdGUtdmFs" + + "dWVzPi88ZW52Pi1zZWNyZXRzLnlhbWxgIC0tIHNlbnNpdGl2ZSB2YWx1ZXMKNS4gSW5saW5lIGB2" + + "YWx1ZXM6YCBibG9ja3Mgb24gcmVsZWFzZXMgLS0gaGlnaGVzdCBwcmVjZWRlbmNlCgojIyBXaGF0" + + "IGdsb2JhbC55YW1sLmdvdG1wbCBQYXNzZXMgVGhyb3VnaAoKYGdsb2JhbC55YW1sLmdvdG1wbGAg" + + "cmVhZHMgZnJvbSBgLlZhbHVlc2AgKHRoZSBtZXJnZWQgZW52aXJvbm1lbnQgKyBlbnYtc3BlY2lm" + + "aWMgWUFNTCkgYW5kIGNvbnN0cnVjdHMgY2hhcnQtc3BlY2lmaWMgdmFsdWVzLiBJdCBvbmx5IHBh" + + "c3NlcyB0aHJvdWdoIGtleXMgaXQgZXhwbGljaXRseSByZWZlcmVuY2VzOgoKIyMjIENhc3NhbmRy" + + "YQotIGBjYXNzYW5kcmEucmVwbGljYUNvdW50YAotIGBjYXNzYW5kcmEuaW1hZ2UuKmAgKHJlZ2lz" + + "dHJ5LCByZXBvc2l0b3J5KQotIGBjYXNzYW5kcmEubWlncmF0aW9ucy5pbWFnZS4qYAotIGBjYXNz" + + "YW5kcmEucGVyc2lzdGVuY2Uuc2l6ZWAKLSBgY2Fzc2FuZHJhLm5vZGVTZWxlY3RvcmAgKGlmIGBn" + + "bG9iYWwubm9kZVNlbGVjdG9ycy5lbmFibGVkYCkKLSBgY2Fzc2FuZHJhLmdsb2JhbC5kZWZhdWx0" + + "U3RvcmFnZUNsYXNzYAoKIyMjIE5BVFMKLSBgbmF0cy5jb250YWluZXIuaW1hZ2UuKmAKLSBgbmF0" + + "cy5yZWxvYWRlci5pbWFnZS4qYAotIGBuYXRzLm5hdHNCb3guY29udGFpbmVyLmltYWdlLipgCi0g" + + "YG5hdHMuY29uZmlnLmpldHN0cmVhbS5maWxlU3RvcmUucHZjLnN0b3JhZ2VDbGFzc05hbWVgCi0g" + + "YG5hdHMucG9kVGVtcGxhdGUubWVyZ2Uuc3BlYy5ub2RlU2VsZWN0b3JgIChpZiBlbmFibGVkKQoK" + + "IyMjIE9wZW5CYW8KLSBgb3BlbmJhby5taWdyYXRpb25zLmltYWdlLipgIGFuZCBgb3BlbmJhby5t" + + "aWdyYXRpb25zLmVudmAKLSBgb3BlbmJhby5pbmplY3Rvci5pbWFnZS4qYAotIGBvcGVuYmFvLnNl" + + "cnZlci5pbWFnZS4qYAotIGBvcGVuYmFvLnNlcnZlci5kYXRhU3RvcmFnZS4qYAotIE5vZGUgc2Vs" + + "ZWN0b3JzIChpZiBlbmFibGVkKQoKIyMjIFNlcnZpY2VzIChBUEksIFNJUywgZXRjLikKLSBgPHNl" + + "cnZpY2U+LmltYWdlLipgIChyZWdpc3RyeSwgcmVwb3NpdG9yeSkKLSBgPHNlcnZpY2U+Lm5vZGVT" + + "ZWxlY3RvcmAgKGlmIGVuYWJsZWQpCi0gYDxzZXJ2aWNlPi5lbnYuKmAgKG9ic2VydmFiaWxpdHkg" + + "c2V0dGluZ3MpCgojIyMgTExNIEZ1bmN0aW9uIEVuYWJsZW1lbnQKCkVuYWJsZSB0aGUgTExNIGFk" + + "ZG9uIGJlZm9yZSBjcmVhdGluZyBvciBpbnZva2luZyBmdW5jdGlvbnMgd2l0aApgZnVuY3Rpb25U" + + "eXBlOiAiTExNImAuIFRoZSBhZGRvbiBkZXBsb3lzIGBsbG0tcmVxdWVzdC1yb3V0ZXJgIGFuZApg" + + "bGxtLWFwaS1nYXRld2F5YCwgYWRkcyB0aGUgYGxsbS5pbnZvY2F0aW9uLjxkb21haW4+YCByb3V0" + + "ZSB3aGVuIEdhdGV3YXkgQVBJCmluZ3Jlc3MgaXMgZW5hYmxlZCwgYW5kIGNvbmZpZ3VyZXMgd29y" + + "a2VycyB0byB1c2UgdGhlIExMTSBzaWRlY2FyLiBUaGUgSGVsbWZpbGUKY29uZGl0aW9uIGlzIGBh" + + "ZGRvbnMubGxtLmVuYWJsZWRgLiBEbyBub3QgdXNlIHRoZSBvYnNvbGV0ZSBgbGxtLmVuYWJsZWRg" + + "IHBhdGguCgpGb3IgYSBzaW5nbGUtbm9kZSBpc29sYXRlZCB0ZXN0IGNsdXN0ZXIsIGFkZCB0aGlz" + + "IGNvbmZpZ3VyYXRpb24gdG8KYGVudmlyb25tZW50cy88ZW52Pi55YW1sYCBiZWZvcmUgYXBwbHlp" + + "bmcgdGhlIHN0YWNrOgoKYGBgeWFtbAphZGRvbnM6CiAgbGxtOgogICAgZW5hYmxlZDogdHJ1ZQog" + + "ICAgZ2F0ZXdheToKICAgICAgcmVwbGljYUNvdW50OiAxCiAgICAgIGF1dGg6CiAgICAgICAgZ3Jw" + + "Y0luc2VjdXJlOiB0cnVlCiAgICAgIG1ldHJpY3M6CiAgICAgICAgc2VydmljZU1vbml0b3I6CiAg" + + "ICAgICAgICBlbmFibGVkOiBmYWxzZQogICAgcmVxdWVzdFJvdXRlcjoKICAgICAgcmVwbGljYUNv" + + "dW50OiAxCiAgICAgIG1ldHJpY3M6CiAgICAgICAgc2VydmljZU1vbml0b3I6CiAgICAgICAgICBl" + + "bmFibGVkOiBmYWxzZQoKYWdlbnRDb25maWc6CiAgbWVyZ2VDb25maWc6IHwKICAgIGNsdXN0ZXI6" + + "CiAgICAgIHZhbGlkYXRpb25Qb2xpY3k6CiAgICAgICAgbmFtZTogVW5yZXN0cmljdGVkCiAgICB3" + + "b3JrbG9hZDoKICAgICAgc3RhcmdhdGVRVUlDSW5zZWN1cmU6IHRydWUKYGBgCgpVc2UgYHJlcGxp" + + "Y2FDb3VudDogMWAgb25seSBmb3IgbG9jYWwgb3Igc2luZ2xlLW5vZGUgdGVzdCBjbHVzdGVycy4g" + + "Rm9yIHNoYXJlZApvciBwcm9kdWN0aW9uIGNsdXN0ZXJzLCB1c2UgdGhlIHJlcXVpcmVkIHJlcGxp" + + "Y2EgY291bnQgYW5kIFRMUy1jYXBhYmxlIHNlcnZpY2UKY29uZmlndXJhdGlvbi4gYGFkZG9ucy5s" + + "bG0uZ2F0ZXdheS5hdXRoLmdycGNJbnNlY3VyZWAgYW5kCmB3b3JrbG9hZC5zdGFyZ2F0ZVFVSUNJ" + + "bnNlY3VyZWAgZW5hYmxlIHBsYWludGV4dCB0cmFuc3BvcnRzLiBEbyBub3QgdXNlIHRoZW0gaW4K" + + "cHJvZHVjdGlvbi4KClRoZSByZXF1ZXN0IHJvdXRlciB1c2VzIGBwb3dlci1vZi10d29gIHdoZW4g" + + "bm8gbG9hZC1iYWxhbmNlciBjb25maWd1cmF0aW9uIGlzCnNldC4gQ29uZmlndXJlIG90aGVyIHJv" + + "dXRpbmcgbWV0aG9kcyB3aXRoIHRoZQpbTExNIFJlcXVlc3QgUm91dGVyIExvYWQgQmFsYW5jaW5n" + + "XShodHRwczovL2dpdGh1Yi5jb20vTlZJRElBL252Y2YvYmxvYi9tYWluL2RvY3MvdXNlci9sbG0t" + + "cmVxdWVzdC1yb3V0ZXItbG9hZC1iYWxhbmNpbmcubWQpCmd1aWRlLgoKSWYgdGhlIHNpZGVjYXIg" + + "aW1hZ2UgaXMgbWlycm9yZWQgb3V0c2lkZSB0aGUgc3RhY2sncyBkZWZhdWx0IGltYWdlIHJlZ2lz" + + "dHJ5IGFuZApyZXBvc2l0b3J5LCBzZXQgdGhlIGdlbmVyYXRlZCB3b3JrZXIgc2lkZWNhciBpbWFn" + + "ZSBleHBsaWNpdGx5OgoKYGBgeWFtbAphcGk6CiAgZW52OgogICAgTlZDRl9TSURFQ0FSU19MTE1f" + + "Uk9VVEVSX0NMSUVOVF9JTUFHRTogPHJlZ2lzdHJ5Pi88cmVwb3NpdG9yeT4vcHlsb246MC4yLjEK" + + "YGBgCgpSZW5kZXIgYW5kIGFwcGx5IHRoZSB1cGRhdGVkIGNvbnRyb2wtcGxhbmUgZW52aXJvbm1l" + + "bnQsIHRoZW4gcmVmcmVzaCBldmVyeQpyZWdpc3RlcmVkIGNvbXB1dGUgcGxhbmUgdXNpbmcgdGhl" + + "IHNhbWUgaGFuZG9mZiB1c2VkIGZvciBpdHMgaW5zdGFsbGF0aW9uIHNvCk5WQ0EgcmVjZWl2ZXMg" + + "YGFnZW50Q29uZmlnLm1lcmdlQ29uZmlnYDoKCmBgYGJhc2gKSEVMTUZJTEVfRU5WPTxlbnY+IGhl" + + "bG1maWxlIHRlbXBsYXRlCkhFTE1GSUxFX0VOVj08ZW52PiBoZWxtZmlsZSBzeW5jCmBgYAoKVXNl" + + "IHRoZSBjb21wbGV0ZSBjb21wdXRlLXBsYW5lIGluc3RhbGwgY29tbWFuZCBmcm9tCltTcGxpdCBD" + + "b21wdXRlLVBsYW5lIEluc3RhbGxhdGlvbl0oY29tcHV0ZS1wbGFuZS1pbnN0YWxsYXRpb24ubWQp" + + "LiBBCkNMSS1wcm9maWxlIGluc3RhbGxhdGlvbiBtdXN0IHJlbWFpbiBwcm9maWxlLWRyaXZlbjsg" + + "YSBIZWxtZmlsZSBpbnN0YWxsYXRpb24KbXVzdCByZW1haW4gdmFsdWVzLWRyaXZlbi4KCkV4aXN0" + + "aW5nIExMTSBmdW5jdGlvbiBwb2RzIGtlZXAgdGhlaXIgZXhpc3Rpbmcgc2lkZWNhciBhcmd1bWVu" + + "dHMuIFJlY3JlYXRlIG9yCnJlZGVwbG95IHRob3NlIGZ1bmN0aW9ucyBhZnRlciB0aGUgY29tcHV0" + + "ZS1wbGFuZSByZWZyZXNoLiBWZXJpZnkgdGhlIGNvbnRyb2wKcGxhbmUsIHJvdXRlLCBhbmQgd29y" + + "a2VyIHNpZGVjYXI6CgpgYGBiYXNoCmt1YmVjdGwgZ2V0IGRlcGxveSAtbiBudmNmIGxsbS1hcGkt" + + "Z2F0ZXdheQprdWJlY3RsIGdldCBzdGF0ZWZ1bHNldCAtbiBudmNmIGxsbS1yZXF1ZXN0LXJvdXRl" + + "cgprdWJlY3RsIGdldCBwb2RzIC1uIG52Y2YgfCBncmVwIC1FICdsbG0tYXBpLWdhdGV3YXl8bGxt" + + "LXJlcXVlc3Qtcm91dGVyJwprdWJlY3RsIGdldCBodHRwcm91dGUgLUEgfCBncmVwIGxsbQprdWJl" + + "Y3RsIC1uIG52Y2YtYmFja2VuZCBnZXQgcG9kIDxmdW5jdGlvbi1wb2Q+IFwKICAtbyBqc29ucGF0" + + "aD0ne3JhbmdlIC5zcGVjLmNvbnRhaW5lcnNbPyhALm5hbWU9PSJsbG0td29ya2VyIildLmFyZ3Nb" + + "Kl19ey59eyJcXG4ifXtlbmR9JwpgYGAKCkZvciBsb2NhbCBwbGFpbnRleHQgY2x1c3RlcnMsIHRo" + + "ZSBgbGxtLXdvcmtlcmAgYXJncyBtdXN0IGluY2x1ZGUKYC0tcXVpYy1pbnNlY3VyZWAuCgpGb3Ig" + + "bG9hZC1iYWxhbmNlciBzY2hlbWEgYW5kIGFsZ29yaXRobSBiZWhhdmlvciwgc2VlIHRoZQpbU3Rh" + + "cmdhdGUgY29uZmlndXJhdGlvbiBndWlkZV0oaHR0cHM6Ly9naXRodWIuY29tL05WSURJQS9udmNm" + + "L2Jsb2IvbWFpbi9zcmMvbGlicmFyaWVzL3J1c3Qvc3RhcmdhdGUvZG9jcy9sb2FkLWJhbGFuY2Vy" + + "LWNvbmZpZ3VyYXRpb24ubWQpLgoKIyMgSGVsbWZpbGUgU2VsZWN0b3JzCgpUYXJnZXQgc3BlY2lm" + + "aWMgcmVsZWFzZXMgb3IgZ3JvdXBzOgoKYGBgYmFzaAojIEJ5IHJlbGVhc2UgZ3JvdXAKSEVMTUZJ" + + "TEVfRU5WPTxlbnY+IGhlbG1maWxlIC0tc2VsZWN0b3IgcmVsZWFzZS1ncm91cD1kZXBlbmRlbmNp" + + "ZXMgc3luYwpIRUxNRklMRV9FTlY9PGVudj4gaGVsbWZpbGUgLS1zZWxlY3RvciByZWxlYXNlLWdy" + + "b3VwPXNlcnZpY2VzIHN5bmMKSEVMTUZJTEVfRU5WPTxlbnY+IGhlbG1maWxlIC0tc2VsZWN0b3Ig" + + "cmVsZWFzZS1ncm91cD1pbmdyZXNzIHN5bmMKSEVMTUZJTEVfRU5WPTxlbnY+IGhlbG1maWxlIC0t" + + "c2VsZWN0b3IgcmVsZWFzZS1ncm91cD1vYnNlcnZhYmlsaXR5IHN5bmMKCiMgQnkgcmVsZWFzZSBu" + + "YW1lCkhFTE1GSUxFX0VOVj08ZW52PiBoZWxtZmlsZSAtLXNlbGVjdG9yIG5hbWU9Y2Fzc2FuZHJh" + + "IHN5bmMKSEVMTUZJTEVfRU5WPTxlbnY+IGhlbG1maWxlIC0tc2VsZWN0b3IgbmFtZT1hZG1pbi1p" + + "c3N1ZXItcHJveHkgc3luYwpIRUxNRklMRV9FTlY9PGVudj4gaGVsbWZpbGUgLS1zZWxlY3RvciBu" + + "YW1lPWxsbS1yZXF1ZXN0LXJvdXRlciBzeW5jCkhFTE1GSUxFX0VOVj08ZW52PiBoZWxtZmlsZSAt" + + "LXNlbGVjdG9yIG5hbWU9bGxtLWFwaS1nYXRld2F5IHN5bmMKCiMgVGVtcGxhdGUgb25seSAoZHJ5" + + "IHJ1bikKSEVMTUZJTEVfRU5WPTxlbnY+IGhlbG1maWxlIC0tc2VsZWN0b3IgbmFtZT1jYXNzYW5k" + + "cmEgdGVtcGxhdGUKCiMgRGVzdHJveSBhIHNpbmdsZSByZWxlYXNlCkhFTE1GSUxFX0VOVj08ZW52" + + "PiBoZWxtZmlsZSAtLXNlbGVjdG9yIG5hbWU9Y2Fzc2FuZHJhIGRlc3Ryb3kKYGBgCgpOb3RlOiBg" + + "YWRtaW4taXNzdWVyLXByb3h5YCBoYXMgbm8gYHJlbGVhc2UtZ3JvdXBgIGxhYmVsLiBVc2UgYC0t" + + "c2VsZWN0b3IgbmFtZT1hZG1pbi1pc3N1ZXItcHJveHlgLgpQSwcIwFYg548nAACPJwAAUEsDBBQA" + + "CAAAAAAAIQAAAAAAAAAAAAAAAAA/AAkAZGF0YS9udmNmLXNlbGYtbWFuYWdlZC1pbnN0YWxsYXRp" + + "b24vcmVmZXJlbmNlcy9udmNmLXVpLWFkZG9uLm1kVVQFAAEAps4SIyBOVkNGIFVJIEFkZG9uCgpO" + + "VkNGIFVJIGlzIGFuIG9wdGlvbmFsLCBjdXN0b21lci1mYWNpbmcgTlZDRiBhZG1pbi1wYW5lbCBV" + + "SS4gSXQgaXMgZGlzYWJsZWQgYnkKZGVmYXVsdCBhbmQgYXZhaWxhYmxlIG9ubHkgaW4gc3RhY2sg" + + "cGFja2FnZXMgdGhhdCBpbmNsdWRlIHRoZSBOVkNGIFVJIGFkZG9uLgoKIyMgV2hlbiB0byBlbmFi" + + "bGUKCkVuYWJsZSBOVkNGIFVJIG9ubHkgd2hlbiB5b3UgbmVlZCB0aGUgYWRtaW4tcGFuZWwgVUkg" + + "YW5kIHlvdXIgZXh0cmFjdGVkIHN0YWNrCnBhY2thZ2UgaW5jbHVkZXMgdGhlIGFkZG9uLiBJZiB0" + + "aGUgcGFja2FnZSBkb2VzIG5vdCBjb250YWluIGEgYG52Y2YtdWlgIHJlbGVhc2UKYW5kIGBudmNm" + + "VWlgIHJvdXRlIHZhbHVlcywgc2tpcCB0aGUgYWRkb24gdW50aWwgeW91IHVzZSBhIHBhY2thZ2Ug" + + "dGhhdCBpbmNsdWRlcwp0aGVtLgoKIyMgRW5hYmxlIHRoZSBhZGRvbgoKRW5hYmxlIGl0IGluIGBl" + + "bnZpcm9ubWVudHMvPGVudi1uYW1lPi55YW1sYDoKCmBgYHlhbWwKYWRkb25zOgogIG52Y2ZVaToK" + + "ICAgIGVuYWJsZWQ6IHRydWUKYGBgCgojIyBDcmVhdGUgbmFtZXNwYWNlIGFuZCBpbWFnZSBwdWxs" + + "IHNlY3JldAoKQ3JlYXRlIHRoZSBuYW1lc3BhY2UsIGFuZCBhbiBpbWFnZSBwdWxsIHNlY3JldCBv" + + "bmx5IGlmIHB1bGxpbmcgZnJvbSBhIHByaXZhdGUKcmVnaXN0cnk6CgpgYGBiYXNoCmt1YmVjdGwg" + + "Y3JlYXRlIG5hbWVzcGFjZSBudmNmLXVpIC0tZHJ5LXJ1bj1jbGllbnQgLW8geWFtbCB8IGt1YmVj" + + "dGwgYXBwbHkgLWYgLQoKIyBPbmx5IGlmIHB1bGxpbmcgZnJvbSBhIHByaXZhdGUgcmVnaXN0cnkg" + + "KGUuZy4sIE5HQyBudmNyLmlvKQpleHBvcnQgTkdDX0FQSV9LRVk9Ijx5b3VyLWtleT4iCmt1YmVj" + + "dGwgY3JlYXRlIHNlY3JldCBkb2NrZXItcmVnaXN0cnkgbnZjci1jcmVkcyBcCiAgLS1kb2NrZXIt" + + "c2VydmVyPW52Y3IuaW8gXAogIC0tZG9ja2VyLXVzZXJuYW1lPSckb2F1dGh0b2tlbicgXAogIC0t" + + "ZG9ja2VyLXBhc3N3b3JkPSIkTkdDX0FQSV9LRVkiIFwKICAtLW5hbWVzcGFjZT1udmNmLXVpIFwK" + + "ICAtLWRyeS1ydW49Y2xpZW50IC1vIHlhbWwgfCBrdWJlY3RsIGFwcGx5IC1mIC0KYGBgCgpUaGUg" + + "ZGVmYXVsdCByb3V0ZSBob3N0IGlzIGBudmNmLXVpLjxkb21haW4+YCBhbmQgdGhlIGJhY2tlbmQg" + + "aXMKYG52Y2YtdWkubnZjZi11aTo4MzAwYC4KCiMjIEFwcGx5IHRoZSBzZXJ2aWNlIGFuZCByb3V0" + + "ZQoKQWZ0ZXIgY29uZmlybWluZyB0aGUgcGFja2FnZSBpbmNsdWRlcyB0aGUgYG52Y2YtdWlgIHJl" + + "bGVhc2UsIHByZXZpZXcgYW5kIGFwcGx5CnRoZSBzZXJ2aWNlIGFuZCByb3V0ZToKCmBgYGJhc2gK" + + "SEVMTUZJTEVfRU5WPTxlbnYtbmFtZT4gaGVsbWZpbGUgLS1zZWxlY3RvciBuYW1lPW52Y2YtdWkg" + + "dGVtcGxhdGUKSEVMTUZJTEVfRU5WPTxlbnYtbmFtZT4gaGVsbWZpbGUgLS1zZWxlY3RvciBuYW1l" + + "PW52Y2YtdWkgc3luYwpIRUxNRklMRV9FTlY9PGVudi1uYW1lPiBoZWxtZmlsZSAtLXNlbGVjdG9y" + + "IHJlbGVhc2UtZ3JvdXA9aW5ncmVzcyBzeW5jCmBgYAoKIyMgVmVyaWZ5CgpWZXJpZnkgdGhlIHJv" + + "dXRlIG9ubHkgd2hlbiB0aGUgYWRkb24gaXMgcHJlc2VudCBhbmQgZW5hYmxlZDoKCmBgYGJhc2gK" + + "a3ViZWN0bCBnZXQgZGVwbG95LHN2YyAtbiBudmNmLXVpCmt1YmVjdGwgZ2V0IGh0dHByb3V0ZSAt" + + "QSB8IGdyZXAgLWkgbnZjZi11aQpjdXJsIC1pIC1IICJIb3N0OiBudmNmLXVpLjxkb21haW4+IiAi" + + "aHR0cDovLzxnYXRld2F5LWFkZHJlc3M+L3N0YXR1cyIKYGBgCgojIyBTZWN1cml0eQoKVGhlIE5W" + + "Q0YgVUkgYWRtaW4gcGFuZWwgaXMgY3VycmVudGx5IHVuYXV0aGVudGljYXRlZC4gRG8gbm90IGV4" + + "cG9zZSBpdCB0byB0aGUKcHVibGljIGludGVybmV0LiBSZXN0cmljdCBhY2Nlc3MgdG8gYSB0cnVz" + + "dGVkIG5ldHdvcmssIFZQTiwgb3IgYW4gYXV0aGVudGljYXRpbmcKcHJveHkgaW4gZnJvbnQgb2Yg" + + "dGhlIGBudmNmLXVpYCByb3V0ZS4KUEsHCDj5J6+5BwAAuQcAAFBLAwQUAAgAAAAAACEAAAAAAAAA" + + "AAAAAAAAPgAJAGRhdGEvbnZjZi1zZWxmLW1hbmFnZWQtaW5zdGFsbGF0aW9uL3JlZmVyZW5jZXMv" + + "cHVsbC1zZWNyZXRzLm1kVVQFAAEAps4SIyBJbWFnZSBQdWxsIFNlY3JldHMgUmVmZXJlbmNlCgoj" + + "IyBPdmVydmlldwoKV2hlbiBwdWxsaW5nIE5WQ0YgaW1hZ2VzIGZyb20gYSBwcml2YXRlIHJlZ2lz" + + "dHJ5IChmb3IgZXhhbXBsZSwgTkdDCmBudmNyLmlvYCksIEt1YmVybmV0ZXMgbmVlZHMgYGltYWdl" + + "UHVsbFNlY3JldHNgIG9uIGV2ZXJ5IHBvZC4gQ29udHJvbC1wbGFuZSBhbmQKY29tcHV0ZS1wbGFu" + + "ZSBjcmVkZW50aWFscyBhcmUgY29uZmlndXJlZCBpbiB0aGVpciBvd24gY2x1c3RlciBjb250ZXh0" + + "cy4gRG8gbm90CnVzZSBvbmUgbWl4ZWQgbmFtZXNwYWNlIGxpc3QuCgpUaGUgcmVjb21tZW5kZWQg" + + "Y29udHJvbC1wbGFuZSBhcHByb2FjaCB1c2VzIEt5dmVybm8gdG8gaW5qZWN0IHRoZSBzZWNyZXQg" + + "aW50bwpjb250cm9sLXBsYW5lIHBvZHMgYXQgYWRtaXNzaW9uIHRpbWUuIFRoZSBjb21wdXRlLXBs" + + "YW5lIGNoYXJ0IGFuZCBvcGVyYXRvciB1c2UKdGhlIHNlY3JldCBpbiBgbnZjYS1vcGVyYXRvcmAg" + + "YW5kIG1pcnJvciBpdCB0byBgbnZjYS1zeXN0ZW1gLgoKIyMgS3l2ZXJubyBBcHByb2FjaCAoUmVj" + + "b21tZW5kZWQpCgojIyMgMS4gSW5zdGFsbCBLeXZlcm5vCgpgYGBiYXNoCmhlbG0gcmVwbyBhZGQg" + + "a3l2ZXJubyBodHRwczovL2t5dmVybm8uZ2l0aHViLmlvL2t5dmVybm8vCmhlbG0gcmVwbyB1cGRh" + + "dGUKaGVsbSBpbnN0YWxsIGt5dmVybm8ga3l2ZXJuby9reXZlcm5vIC1uIGt5dmVybm8gLS1jcmVh" + + "dGUtbmFtZXNwYWNlIFwKICAtLWt1YmUtY29udGV4dCA8Y29udHJvbC1wbGFuZS1jb250ZXh0Pgpg" + + "YGAKCiMjIyAyLiBDcmVhdGUgY29udHJvbC1wbGFuZSBwdWxsIHNlY3JldHMKCmBgYGJhc2gKZXhw" + + "b3J0IE5HQ19BUElfS0VZPSI8eW91ci1uZ2MtYXBpLWtleT4iCgpmb3IgbnMgaW4gY2Fzc2FuZHJh" + + "LXN5c3RlbSBuYXRzLXN5c3RlbSBudmNmIGFwaS1rZXlzIGVzcyBzaXMgdmF1bHQtc3lzdGVtIGNl" + + "cnQtbWFuYWdlcjsgZG8KICBrdWJlY3RsIC0tY29udGV4dCA8Y29udHJvbC1wbGFuZS1jb250ZXh0" + + "PiBjcmVhdGUgbmFtZXNwYWNlICIkbnMiIFwKICAgIC0tZHJ5LXJ1bj1jbGllbnQgLW8geWFtbCB8" + + "IGt1YmVjdGwgLS1jb250ZXh0IDxjb250cm9sLXBsYW5lLWNvbnRleHQ+IGFwcGx5IC1mIC0KZG9u" + + "ZQoKZm9yIG5zIGluIGNhc3NhbmRyYS1zeXN0ZW0gbmF0cy1zeXN0ZW0gbnZjZiBhcGkta2V5cyBl" + + "c3Mgc2lzIHZhdWx0LXN5c3RlbSBjZXJ0LW1hbmFnZXI7IGRvCiAga3ViZWN0bCAtLWNvbnRleHQg" + + "PGNvbnRyb2wtcGxhbmUtY29udGV4dD4gY3JlYXRlIHNlY3JldCBkb2NrZXItcmVnaXN0cnkgbnZj" + + "ci1jcmVkcyBcCiAgICAtLWRvY2tlci1zZXJ2ZXI9bnZjci5pbyBcCiAgICAtLWRvY2tlci11c2Vy" + + "bmFtZT0nJG9hdXRodG9rZW4nIFwKICAgIC0tZG9ja2VyLXBhc3N3b3JkPSIkTkdDX0FQSV9LRVki" + + "IFwKICAgIC0tbmFtZXNwYWNlPSIkbnMiIFwKICAgIC0tZHJ5LXJ1bj1jbGllbnQgLW8geWFtbCB8" + + "IGt1YmVjdGwgLS1jb250ZXh0IDxjb250cm9sLXBsYW5lLWNvbnRleHQ+IGFwcGx5IC1mIC0KZG9u" + + "ZQpgYGAKCkZvciBub24tTkdDIHJlZ2lzdHJpZXMsIHJlcGxhY2UgYC0tZG9ja2VyLXNlcnZlcmAs" + + "IGAtLWRvY2tlci11c2VybmFtZWAsIGFuZCBgLS1kb2NrZXItcGFzc3dvcmRgLgoKIyMjIDMuIEFw" + + "cGx5IEt5dmVybm8gQ2x1c3RlclBvbGljeQoKYGBgeWFtbAphcGlWZXJzaW9uOiBreXZlcm5vLmlv" + + "L3YxCmtpbmQ6IENsdXN0ZXJQb2xpY3kKbWV0YWRhdGE6CiAgbmFtZTogbnZjZi1hZGQtaW1hZ2Vw" + + "dWxsc2VjcmV0cwpzcGVjOgogIGJhY2tncm91bmQ6IGZhbHNlCiAgcnVsZXM6CiAgICAtIG5hbWU6" + + "IGFkZC1pbWFnZXB1bGxzZWNyZXQtdG8tbnZjZi1wb2RzCiAgICAgIG1hdGNoOgogICAgICAgIGFu" + + "eToKICAgICAgICAtIHJlc291cmNlczoKICAgICAgICAgICAga2luZHM6CiAgICAgICAgICAgIC0g" + + "UG9kCiAgICAgICAgICAgIG5hbWVzcGFjZXM6CiAgICAgICAgICAgIC0gIm52Y2YiCiAgICAgICAg" + + "ICAgIC0gImFwaS1rZXlzIgogICAgICAgICAgICAtICJzaXMiCiAgICAgICAgICAgIC0gImVzcyIK" + + "ICAgICAgICAgICAgLSAibmF0cy1zeXN0ZW0iCiAgICAgICAgICAgIC0gImNhc3NhbmRyYS1zeXN0" + + "ZW0iCiAgICAgICAgICAgIC0gInZhdWx0LXN5c3RlbSIKICAgICAgICAgICAgLSAiY2VydC1tYW5h" + + "Z2VyIgogICAgICBtdXRhdGU6CiAgICAgICAgcGF0Y2hTdHJhdGVnaWNNZXJnZToKICAgICAgICAg" + + "IG1ldGFkYXRhOgogICAgICAgICAgICBhbm5vdGF0aW9uczoKICAgICAgICAgICAgICBudmNmLm52" + + "aWRpYS5jb20vaW1hZ2VwdWxsc2VjcmV0LWluamVjdGVkLWJ5OiBreXZlcm5vCiAgICAgICAgICBz" + + "cGVjOgogICAgICAgICAgICBpbWFnZVB1bGxTZWNyZXRzOgogICAgICAgICAgICAtIG5hbWU6IG52" + + "Y3ItY3JlZHMKYGBgCgpgYGBiYXNoCmt1YmVjdGwgLS1jb250ZXh0IDxjb250cm9sLXBsYW5lLWNv" + + "bnRleHQ+IGFwcGx5IFwKICAtZiBreXZlcm5vLWltYWdlcHVsbHNlY3JldC1wb2xpY3kueWFtbApg" + + "YGAKCiMjIyA0LiBJbnN0YWxsIHRoZSBjb250cm9sIHBsYW5lCgpDb250aW51ZSB3aXRoIHRoZSBz" + + "ZWxlY3RlZCBjb250cm9sLXBsYW5lIGluc3RhbGxhdGlvbiBpbgpbU3BsaXQgQ29tcHV0ZS1QbGFu" + + "ZSBJbnN0YWxsYXRpb25dKGNvbXB1dGUtcGxhbmUtaW5zdGFsbGF0aW9uLm1kKS4gTm8KY29udHJv" + + "bC1wbGFuZSBoZWxtZmlsZSBtb2RpZmljYXRpb25zIGFyZSBuZWVkZWQuIEt5dmVybm8gaW5qZWN0" + + "cyB0aGUgcHVsbApzZWNyZXQgaW50byBuZXcgY29udHJvbC1wbGFuZSBwb2RzLgoKIyMgQ29tcHV0" + + "ZS1QbGFuZSBTZWNyZXQKCkNyZWF0ZSB0aGUgc2VjcmV0IG9ubHkgaW4gYG52Y2Etb3BlcmF0b3Jg" + + "IG9uIHRoZSBjb21wdXRlIGNsdXN0ZXI6CgpgYGBiYXNoCmt1YmVjdGwgLS1jb250ZXh0IDxjb21w" + + "dXRlLXBsYW5lLWNvbnRleHQ+IGNyZWF0ZSBuYW1lc3BhY2UgbnZjYS1vcGVyYXRvciBcCiAgLS1k" + + "cnktcnVuPWNsaWVudCAtbyB5YW1sIHwgXAogIGt1YmVjdGwgLS1jb250ZXh0IDxjb21wdXRlLXBs" + + "YW5lLWNvbnRleHQ+IGFwcGx5IC1mIC0KCmt1YmVjdGwgLS1jb250ZXh0IDxjb21wdXRlLXBsYW5l" + + "LWNvbnRleHQ+IGNyZWF0ZSBzZWNyZXQgZG9ja2VyLXJlZ2lzdHJ5IG52Y3ItY3JlZHMgXAogIC0t" + + "ZG9ja2VyLXNlcnZlcj1udmNyLmlvIFwKICAtLWRvY2tlci11c2VybmFtZT0nJG9hdXRodG9rZW4n" + + "IFwKICAtLWRvY2tlci1wYXNzd29yZD0iJE5HQ19BUElfS0VZIiBcCiAgLS1uYW1lc3BhY2U9bnZj" + + "YS1vcGVyYXRvciBcCiAgLS1kcnktcnVuPWNsaWVudCAtbyB5YW1sIHwgXAogIGt1YmVjdGwgLS1j" + + "b250ZXh0IDxjb21wdXRlLXBsYW5lLWNvbnRleHQ+IGFwcGx5IC1mIC0KYGBgCgpSZWZlcmVuY2Ug" + + "aXQgaW4gdGhlIGNvbXB1dGUtcGxhbmUgZW52aXJvbm1lbnQgZmlsZToKCmBgYHlhbWwKZ2xvYmFs" + + "OgogIGltYWdlUHVsbFNlY3JldHM6CiAgICAtIG5hbWU6IG52Y3ItY3JlZHMKYGBgCgpUaGUgY2hh" + + "cnQgYW5kIG9wZXJhdG9yIHVzZSB0aGF0IHJlZmVyZW5jZSBpbiBgbnZjYS1vcGVyYXRvcmAgYW5k" + + "IG1pcnJvciB0aGUKc2VjcmV0IHRvIGBudmNhLXN5c3RlbWAuIERvIG5vdCBjcmVhdGUgYSBicm9h" + + "ZGVyIG1hbnVhbCBjb21wdXRlIG5hbWVzcGFjZSBsaXN0LiBGb2xsb3cKW1NwbGl0IENvbXB1dGUt" + + "UGxhbmUgSW5zdGFsbGF0aW9uXShjb21wdXRlLXBsYW5lLWluc3RhbGxhdGlvbi5tZCkgZm9yIHRo" + + "ZQpzZWxlY3RlZCBpbnN0YWxsIGZsb3cuCgojIyBWZXJpZmljYXRpb24KCmBgYGJhc2gKIyBDaGVj" + + "ayB0aGF0IGEgY29udHJvbC1wbGFuZSBwb2QgaGFzIHRoZSBpbmplY3RlZCBzZWNyZXQKa3ViZWN0" + + "bCAtLWNvbnRleHQgPGNvbnRyb2wtcGxhbmUtY29udGV4dD4gZ2V0IHBvZCAtbiA8bmFtZXNwYWNl" + + "PiA8cG9kLW5hbWU+IFwKICAtbyBqc29ucGF0aD0ney5zcGVjLmltYWdlUHVsbFNlY3JldHN9Jwoj" + + "IEV4cGVjdGVkOiBbeyJuYW1lIjoibnZjci1jcmVkcyJ9XQoKIyBDaGVjayB0aGUgS3l2ZXJubyBh" + + "bm5vdGF0aW9uCmt1YmVjdGwgLS1jb250ZXh0IDxjb250cm9sLXBsYW5lLWNvbnRleHQ+IGdldCBw" + + "b2QgLW4gPG5hbWVzcGFjZT4gPHBvZC1uYW1lPiBcCiAgLW8ganNvbnBhdGg9J3subWV0YWRhdGEu" + + "YW5ub3RhdGlvbnMubnZjZlwubnZpZGlhXC5jb20vaW1hZ2VwdWxsc2VjcmV0LWluamVjdGVkLWJ5" + + "fScKIyBFeHBlY3RlZDoga3l2ZXJubwoKIyBDaGVjayBwdWxsIGV2ZW50cwprdWJlY3RsIC0tY29u" + + "dGV4dCA8Y29udHJvbC1wbGFuZS1jb250ZXh0PiBnZXQgZXZlbnRzIC1uIDxuYW1lc3BhY2U+IFwK" + + "ICAtLXNvcnQtYnk9Jy5sYXN0VGltZXN0YW1wJyB8IGdyZXAgLWkgcHVsbAojIFNob3VsZCBzaG93" + + "ICJTdWNjZXNzZnVsbHkgcHVsbGVkIiBub3QgIjQwMSBVbmF1dGhvcml6ZWQiCgojIENoZWNrIHRo" + + "ZSBjaGFydC9vcGVyYXRvciBtaXJyb3Igb24gdGhlIGNvbXB1dGUgY2x1c3RlcgprdWJlY3RsIC0t" + + "Y29udGV4dCA8Y29tcHV0ZS1wbGFuZS1jb250ZXh0PiBnZXQgc2VjcmV0IG52Y3ItY3JlZHMgXAog" + + "IC1uIG52Y2Etc3lzdGVtCmBgYAoKIyMgV2hlbiBQdWxsIFNlY3JldHMgQXJlIE5vdCBOZWVkZWQK" + + "Ci0gKipBV1MgRUNSIHdpdGggSUFNIG5vZGUgcm9sZXMqKjogSWYgeW91ciBub2RlcyBoYXZlIGBB" + + "bWF6b25FQzJDb250YWluZXJSZWdpc3RyeVJlYWRPbmx5YCBJQU0gcG9saWN5LCBLdWJlcm5ldGVz" + + "IGNhbiBwdWxsIGZyb20gRUNSIHdpdGhvdXQgZXhwbGljaXQgc2VjcmV0cy4KLSAqKlB1YmxpYyBy" + + "ZWdpc3RyaWVzKio6IE5vIHB1bGwgc2VjcmV0cyBuZWVkZWQuCi0gKipDU1AgYnVpbHQtaW4gY3Jl" + + "ZGVudGlhbCBoZWxwZXJzKio6IEdLRSBBcnRpZmFjdCBSZWdpc3RyeSwgQXp1cmUgQUNSIHdpdGgg" + + "bWFuYWdlZCBpZGVudGl0eSwgYW5kIHNpbWlsYXIgc2VydmljZXMuCgojIyBUcm91Ymxlc2hvb3Rp" + + "bmcKCiMjIyBQb2RzIHN0aWxsIGluIEltYWdlUHVsbEJhY2tPZmYgYWZ0ZXIgYXBwbHlpbmcgcG9s" + + "aWN5CgpUaGUgS3l2ZXJubyBwb2xpY3kgb25seSBhZmZlY3RzIHBvZHMgY3JlYXRlZCAqKmFmdGVy" + + "KiogdGhlIHBvbGljeSBpcyBhcHBsaWVkLiBEZWxldGUgc3R1Y2sgcG9kcyB0byB0cmlnZ2VyIHJl" + + "Y3JlYXRpb246CgpgYGBiYXNoCmt1YmVjdGwgLS1jb250ZXh0IDx0YXJnZXQtY29udGV4dD4gZGVs" + + "ZXRlIHBvZHMgLW4gPG5hbWVzcGFjZT4gLS1hbGwKYGBgCgojIyMgS3l2ZXJubyBhZG1pc3Npb24g" + + "Y29udHJvbGxlciBub3QgcnVubmluZwoKYGBgYmFzaAprdWJlY3RsIC0tY29udGV4dCA8Y29udHJv" + + "bC1wbGFuZS1jb250ZXh0PiBnZXQgcG9kcyAtbiBreXZlcm5vCiMgQWxsIHBvZHMgc2hvdWxkIGJl" + + "IFJ1bm5pbmcKYGBgCgojIyMgUG9saWN5IG5vdCBtYXRjaGluZwoKYGBgYmFzaAprdWJlY3RsIC0t" + + "Y29udGV4dCA8Y29udHJvbC1wbGFuZS1jb250ZXh0PiBnZXQgY2x1c3RlcnBvbGljeSBudmNmLWFk" + + "ZC1pbWFnZXB1bGxzZWNyZXRzCiMgU2hvdWxkIHNob3cgUkVBRFk6IFRydWUKYGBgCgojIyMgV3Jv" + + "bmcgc2VjcmV0IG5hbWUKClRoZSBwb2xpY3kgcmVmZXJlbmNlcyBgbnZjci1jcmVkc2AuIFZlcmlm" + + "eSB0aGUgc2VjcmV0IGV4aXN0cyB3aXRoIHRoYXQgZXhhY3QgbmFtZToKCmBgYGJhc2gKa3ViZWN0" + + "bCAtLWNvbnRleHQgPHRhcmdldC1jb250ZXh0PiBnZXQgc2VjcmV0IG52Y3ItY3JlZHMgLW4gPG5h" + + "bWVzcGFjZT4KYGBgClBLBwhLQjWoABYAAAAWAABQSwECFAAUAAgAAAAAACEArXKWn0gQAABIEAAA" + + "EgAJAAAAAAAAAAAAAAAAAAAAZGF0YS9tYW5pZmVzdC5qc29uVVQFAAEAps4SUEsBAhQAFAAIAAAA" + + "AAAhAM2BMORNYQAATWEAACMACQAAAAAAAAAAAAAAkRAAAGRhdGEvbnZjZi1zZWxmLW1hbmFnZWQt" + + "Y2xpL1NLSUxMLm1kVVQFAAEAps4SUEsBAhQAFAAIAAAAAAAhACHGyIbwCgAA8AoAADMACQAAAAAA" + + "AAAAAAAAOHIAAGRhdGEvbnZjZi1zZWxmLW1hbmFnZWQtY2xpL2V4YW1wbGVzL2NpLXBpcGVsaW5l" + + "cy5tZFVUBQABAKbOElBLAQIUABQACAAAAAAAIQChFOOBXQwAAF0MAAA0AAkAAAAAAAAAAAAAAJJ9" + + "AABkYXRhL252Y2Ytc2VsZi1tYW5hZ2VkLWNsaS9leGFtcGxlcy9tdWx0aS1jbHVzdGVyLm1kVVQF" + + "AAEAps4SUEsBAhQAFAAIAAAAAAAhAEInSQ8FDQAABQ0AADcACQAAAAAAAAAAAAAAWooAAGRhdGEv" + + "bnZjZi1zZWxmLW1hbmFnZWQtY2xpL3Byb21wdHMvYWRkLWNvbXB1dGUtcGxhbmUubWRVVAUAAQCm" + + "zhJQSwECFAAUAAgAAAAAACEAkdwb+ZgZAACYGQAAOQAJAAAAAAAAAAAAAADNlwAAZGF0YS9udmNm" + + "LXNlbGYtbWFuYWdlZC1jbGkvcHJvbXB0cy9jcmVhdGUtYW5kLXJ1bi10YXNrLm1kVVQFAAEAps4S" + + "UEsBAhQAFAAIAAAAAAAhANJD3AQYJQAAGCUAADcACQAAAAAAAAAAAAAA1bEAAGRhdGEvbnZjZi1z" + + "ZWxmLW1hbmFnZWQtY2xpL3Byb21wdHMvZGVwbG95LWFuZC1pbnZva2UubWRVVAUAAQCmzhJQSwEC" + + "FAAUAAgAAAAAACEADpw/l70OAAC9DgAAPQAJAAAAAAAAAAAAAABb1wAAZGF0YS9udmNmLXNlbGYt" + + "bWFuYWdlZC1jbGkvcHJvbXB0cy9kaWFnbm9zZS1mYWlsZWQtaW5zdGFsbC5tZFVUBQABAKbOElBL" + + "AQIUABQACAAAAAAAIQBMx6uqdSQAAHUkAAA6AAkAAAAAAAAAAAAAAIzmAABkYXRhL252Y2Ytc2Vs" + + "Zi1tYW5hZ2VkLWNsaS9wcm9tcHRzL2luc3RhbGwtZnJvbS1zY3JhdGNoLm1kVVQFAAEAps4SUEsB" + + "AhQAFAAIAAAAAAAhABrELJ7HBwAAxwcAADkACQAAAAAAAAAAAAAAcgsBAGRhdGEvbnZjZi1zZWxm" + + "LW1hbmFnZWQtY2xpL3Byb21wdHMvcm90YXRlLWNsdXN0ZXItandrcy5tZFVUBQABAKbOElBLAQIU" + + "ABQACAAAAAAAIQASkzNZ4CEAAOAhAAAuAAkAAAAAAAAAAAAAAKkTAQBkYXRhL252Y2Ytc2VsZi1t" + + "YW5hZ2VkLWNsaS9wcm9tcHRzL3RlYXJkb3duLm1kVVQFAAEAps4SUEsBAhQAFAAIAAAAAAAhAHIN" + + "D2QhIwAAISMAADAACQAAAAAAAAAAAAAA7jUBAGRhdGEvbnZjZi1zZWxmLW1hbmFnZWQtY2xpL3Jl" + + "ZmVyZW5jZS9jb21tYW5kcy5tZFVUBQABAKbOElBLAQIUABQACAAAAAAAIQBzp1pk1QYAANUGAAAy" + + "AAkAAAAAAAAAAAAAAHZZAQBkYXRhL252Y2Ytc2VsZi1tYW5hZ2VkLWNsaS9yZWZlcmVuY2UvZXhp" + + "dC1jb2Rlcy5tZFVUBQABAKbOElBLAQIUABQACAAAAAAAIQD8o5HgxiIAAMYiAAAtAAkAAAAAAAAA" + + "AAAAALRgAQBkYXRhL252Y2Ytc2VsZi1tYW5hZ2VkLWNsaS9yZWZlcmVuY2UvZmxhZ3MubWRVVAUA" + + "AQCmzhJQSwECFAAUAAgAAAAAACEA864ThHQRAAB0EQAANwAJAAAAAAAAAAAAAADegwEAZGF0YS9u" + + "dmNmLXNlbGYtbWFuYWdlZC1jbGkvcmVmZXJlbmNlL3Ryb3VibGVzaG9vdGluZy5tZFVUBQABAKbO" + + "ElBLAQIUABQACAAAAAAAIQAv2rl1QmIAAEJiAAAsAAkAAAAAAAAAAAAAAMCVAQBkYXRhL252Y2Yt" + + "c2VsZi1tYW5hZ2VkLWluc3RhbGxhdGlvbi9TS0lMTC5tZFVUBQABAKbOElBLAQIUABQACAAAAAAA" + + "IQArE7g/rVUAAK1VAAA0AAkAAAAAAAAAAAAAAGX4AQBkYXRhL252Y2Ytc2VsZi1tYW5hZ2VkLWlu" + + "c3RhbGxhdGlvbi9ldmFscy9ldmFscy5qc29uVVQFAAEAps4SUEsBAhQAFAAIAAAAAAAhAAJSTkB/" + + "KAAAfygAAC8ACQAAAAAAAAAAAAAAfU4CAGRhdGEvbnZjZi1zZWxmLW1hbmFnZWQtaW5zdGFsbGF0" + + "aW9uL2V4YW1wbGVzLm1kVVQFAAEAps4SUEsBAhQAFAAIAAAAAAAhAJZjvFkSMAAAEjAAAEwACQAA" + + "AAAAAAAAAAAAYncCAGRhdGEvbnZjZi1zZWxmLW1hbmFnZWQtaW5zdGFsbGF0aW9uL3JlZmVyZW5j" + + "ZXMvY29tcHV0ZS1wbGFuZS1pbnN0YWxsYXRpb24ubWRVVAUAAQCmzhJQSwECFAAUAAgAAAAAACEA" + + "Vj5nkJUwAACVMAAAOwAJAAAAAAAAAAAAAAD3pwIAZGF0YS9udmNmLXNlbGYtbWFuYWdlZC1pbnN0" + + "YWxsYXRpb24vcmVmZXJlbmNlcy9kZWJ1Z2dpbmcubWRVVAUAAQCmzhJQSwECFAAUAAgAAAAAACEA" + + "wFYg548nAACPJwAARAAJAAAAAAAAAAAAAAD+2AIAZGF0YS9udmNmLXNlbGYtbWFuYWdlZC1pbnN0" + + "YWxsYXRpb24vcmVmZXJlbmNlcy9oZWxtZmlsZS1zdHJ1Y3R1cmUubWRVVAUAAQCmzhJQSwECFAAU" + + "AAgAAAAAACEAOPknr7kHAAC5BwAAPwAJAAAAAAAAAAAAAAAIAQMAZGF0YS9udmNmLXNlbGYtbWFu" + + "YWdlZC1pbnN0YWxsYXRpb24vcmVmZXJlbmNlcy9udmNmLXVpLWFkZG9uLm1kVVQFAAEAps4SUEsB" + + "AhQAFAAIAAAAAAAhAEtCNagAFgAAABYAAD4ACQAAAAAAAAAAAAAANwkDAGRhdGEvbnZjZi1zZWxm" + + "LW1hbmFnZWQtaW5zdGFsbGF0aW9uL3JlZmVyZW5jZXMvcHVsbC1zZWNyZXRzLm1kVVQFAAEAps4S" + + "UEsFBgAAAAAXABcArwkAAKwfAwAAAA==" var ( skillDataOnce sync.Once diff --git a/tests/bdd/gateway_examples_test.go b/tests/bdd/gateway_examples_test.go new file mode 100644 index 000000000..9c2913d4c --- /dev/null +++ b/tests/bdd/gateway_examples_test.go @@ -0,0 +1,230 @@ +/* +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 bdd_tmp + +import ( + "bufio" + "bytes" + "fmt" + "io" + "os" + "path/filepath" + "strings" + "testing" + + "gopkg.in/yaml.v3" +) + +type documentedResource struct { + Kind string `yaml:"kind"` + Metadata struct { + Name string `yaml:"name"` + Namespace string `yaml:"namespace"` + Annotations map[string]string `yaml:"annotations"` + } `yaml:"metadata"` + Spec struct { + ControllerName string `yaml:"controllerName"` + ParametersRef struct { + Group string `yaml:"group"` + Kind string `yaml:"kind"` + Name string `yaml:"name"` + Namespace string `yaml:"namespace"` + } `yaml:"parametersRef"` + Provider struct { + Kubernetes struct { + EnvoyService struct { + Annotations map[string]string `yaml:"annotations"` + } `yaml:"envoyService"` + } `yaml:"kubernetes"` + } `yaml:"provider"` + } `yaml:"spec"` +} + +func TestRemoteGatewayExamplesConfigureAWSNLBOnEnvoyService(t *testing.T) { + examples := []struct { + name string + path string + }{ + { + name: "gateway routing guide", + path: filepath.Join("..", "..", "docs", "user", "gateway-routing.md"), + }, + { + name: "CLI install prompt", + path: filepath.Join( + "..", "..", "ai-tooling", "user", "skills", "nvcf-self-managed-cli", + "prompts", "install-from-scratch.md", + ), + }, + } + + wantAnnotations := map[string]string{ + "service.beta.kubernetes.io/aws-load-balancer-type": "external", + "service.beta.kubernetes.io/aws-load-balancer-nlb-target-type": "instance", + "service.beta.kubernetes.io/aws-load-balancer-scheme": "internet-facing", + } + + for _, example := range examples { + t.Run(example.name, func(t *testing.T) { + body, err := os.ReadFile(example.path) + if err != nil { + t.Fatalf("read %s: %v", example.path, err) + } + + resources, err := documentedApplyResources(body) + if err != nil { + t.Fatalf("parse applied resources from %s: %v", example.path, err) + } + + envoyProxy := findDocumentedResource(resources, "EnvoyProxy", "eg") + if envoyProxy == nil { + t.Fatalf("EnvoyProxy eg not found in an applied manifest") + } + for annotation, want := range wantAnnotations { + if got := envoyProxy.Spec.Provider.Kubernetes.EnvoyService.Annotations[annotation]; got != want { + t.Errorf("EnvoyProxy envoyService annotation %q = %q, want %q", annotation, got, want) + } + } + + gatewayClass := findDocumentedResource(resources, "GatewayClass", "eg") + if gatewayClass == nil { + t.Fatalf("GatewayClass eg not found in an applied manifest") + } + gatewayClassFields := []struct { + name string + got string + want string + }{ + { + name: "controllerName", + got: gatewayClass.Spec.ControllerName, + want: "gateway.envoyproxy.io/gatewayclass-controller", + }, + { + name: "parametersRef.group", + got: gatewayClass.Spec.ParametersRef.Group, + want: "gateway.envoyproxy.io", + }, + { + name: "parametersRef.kind", + got: gatewayClass.Spec.ParametersRef.Kind, + want: envoyProxy.Kind, + }, + { + name: "parametersRef.name", + got: gatewayClass.Spec.ParametersRef.Name, + want: envoyProxy.Metadata.Name, + }, + { + name: "parametersRef.namespace", + got: gatewayClass.Spec.ParametersRef.Namespace, + want: envoyProxy.Metadata.Namespace, + }, + } + for _, field := range gatewayClassFields { + if field.got != field.want { + t.Errorf("GatewayClass %s = %q, want %q", field.name, field.got, field.want) + } + } + + gateway := findDocumentedResource(resources, "Gateway", "nvcf-gateway") + if gateway == nil { + t.Fatalf("Gateway nvcf-gateway not found in an applied manifest") + } + for annotation := range gateway.Metadata.Annotations { + if strings.HasPrefix(annotation, "service.beta.kubernetes.io/") { + t.Errorf("Gateway metadata contains Service annotation %q; configure the generated Service through EnvoyProxy", annotation) + } + } + }) + } +} + +func documentedApplyResources(markdown []byte) ([]documentedResource, error) { + scanner := bufio.NewScanner(bytes.NewReader(markdown)) + var resources []documentedResource + for scanner.Scan() { + if strings.TrimSpace(scanner.Text()) != "kubectl apply -f - <= commonIndent { + lines[i] = line[commonIndent:] + } + } + return strings.Join(lines, "\n") +} From 82a033269e5c0e26d2f509644109c70a7c95117a Mon Sep 17 00:00:00 2001 From: Mike Camp Date: Tue, 25 Aug 2026 14:41:41 -0400 Subject: [PATCH 2/6] docs(self-managed): address LLM routing review --- docs/user/gateway-routing.md | 21 +++++++++++++++++++++ docs/user/llm-function-enablement.md | 8 +++++--- 2 files changed, 26 insertions(+), 3 deletions(-) diff --git a/docs/user/gateway-routing.md b/docs/user/gateway-routing.md index a4cd1eba1..6113b2e71 100644 --- a/docs/user/gateway-routing.md +++ b/docs/user/gateway-routing.md @@ -226,6 +226,27 @@ LLM workers in another cluster or region need a TCP path for gRPC registration and watches, plus a UDP path for the reverse QUIC tunnel. These paths are separate from the `grpcWorker` callback route. +```mermaid +flowchart LR + Worker["LLM worker sidecar"] + TcpListener["Gateway TCP listener
llmGrpc"] + TcpRoute["TCPRoute
llm-worker-grpc"] + UdpListener["Gateway UDP listener
llmQuic"] + UdpRoute["UDPRoute
llm-worker-quic"] + Service["Service
llm-request-router-backend-router"] + Backend["Backend router"] + Router["LLM request-router pod"] + + Worker -->|"gRPC registration and watches"| TcpListener + TcpListener --> TcpRoute + TcpRoute -->|"TCP 50071"| Service + Worker -->|"QUIC reverse tunnel"| UdpListener + UdpListener --> UdpRoute + UdpRoute -->|"UDP 50072"| Service + Service --> Backend + Backend --> Router +``` + The following example uses separate Gateways so the infrastructure can create one TCP load balancer and one UDP load balancer. A provider that supports mixed TCP and UDP listeners can use one Gateway for both listeners. In that case, diff --git a/docs/user/llm-function-enablement.md b/docs/user/llm-function-enablement.md index 781931d03..69c0f93b8 100644 --- a/docs/user/llm-function-enablement.md +++ b/docs/user/llm-function-enablement.md @@ -592,9 +592,10 @@ For remote workers, also verify the LLM `TCPRoute`, `UDPRoute`, and ## Certificate Renewal -cert-manager renews the request-router certificate and updates -`Secret/stargate-quic-tls`. With `mode: existingSecret` there is no renewal -loop and you update the Secret yourself. +cert-manager renews the request-router certificate and updates the Secret named +by `addons.llm.pki.secretName`. The default is `Secret/stargate-quic-tls`. +With `mode: existingSecret` there is no renewal loop and you update the +configured Secret yourself. Hot reload requires `helm-nvcf-llm-request-router` 1.10.0 or later and Stargate 0.11.1 or later. The request router polls the mounted server certificate and @@ -756,6 +757,7 @@ For transport TLS failures, check: `Issuer` must be in `nvcf`. - SAN mismatch: compare the request router's `--advertised-hostname-template` with the SANs in + the Secret named by `addons.llm.pki.secretName`. The default is `Secret/stargate-quic-tls`. The external `--stargate-address` is a dial endpoint and does not replace the advertised QUIC identity. - Expired or not-yet-valid certificate: inspect the certificate dates and the From eb8df44dada17fa6599ceb1b0e12cd4150d26fc1 Mon Sep 17 00:00:00 2001 From: Mike Camp Date: Tue, 25 Aug 2026 15:13:38 -0400 Subject: [PATCH 3/6] docs(self-managed): harden gateway setup guidance --- .../prompts/install-from-scratch.md | 20 + docs/user/gateway-routing.md | 8 + .../agentskill/skilldata_generated.go | 7208 +++++++++-------- tests/bdd/gateway_examples_test.go | 15 +- 4 files changed, 3651 insertions(+), 3600 deletions(-) diff --git a/ai-tooling/user/skills/nvcf-self-managed-cli/prompts/install-from-scratch.md b/ai-tooling/user/skills/nvcf-self-managed-cli/prompts/install-from-scratch.md index 2c3394492..cdd623271 100644 --- a/ai-tooling/user/skills/nvcf-self-managed-cli/prompts/install-from-scratch.md +++ b/ai-tooling/user/skills/nvcf-self-managed-cli/prompts/install-from-scratch.md @@ -100,6 +100,24 @@ User wants to bring up self-hosted NVCF on a fresh Kubernetes cluster (or k3d fo Before applying the example on EKS, determine whether the cluster uses [EKS Auto Mode](https://docs.aws.amazon.com/eks/latest/userguide/auto-configure-nlb.html). + Use the EKS API and the in-cluster controller Deployment instead of guessing + from the cluster age or existing Services: + + ```sh + export EKS_CLUSTER_NAME="" + + aws eks describe-cluster --name "$EKS_CLUSTER_NAME" \ + --query 'cluster.kubernetesNetworkConfig.elasticLoadBalancing.enabled' \ + --output text + kubectl -n kube-system get deployment aws-load-balancer-controller + ``` + + An EKS API result of `True` selects EKS Auto Mode. Otherwise, a successful + Deployment lookup selects the AWS Load Balancer Controller. If neither is + present, confirm that the cluster intentionally uses the legacy AWS cloud + provider Service controller, or install the AWS Load Balancer Controller, + before applying the example. + For EKS Auto Mode, replace the AWS Load Balancer Controller annotation map with: @@ -143,6 +161,8 @@ User wants to bring up self-hosted NVCF on a fresh Kubernetes cluster (or k3d fo -o jsonpath='{.status.addresses[0].value}')" export GRPC_GATEWAY_ADDR="$(kubectl -n "$GRPC_GATEWAY_NAMESPACE" get "gateway/$GRPC_GATEWAY_NAME" \ -o jsonpath='{.status.addresses[0].value}')" + test -n "$GATEWAY_ADDR" + test -n "$GRPC_GATEWAY_ADDR" export STACK_DOMAIN="$GATEWAY_ADDR" ``` diff --git a/docs/user/gateway-routing.md b/docs/user/gateway-routing.md index 6113b2e71..6b6661eae 100644 --- a/docs/user/gateway-routing.md +++ b/docs/user/gateway-routing.md @@ -462,6 +462,14 @@ To use a different Gateway API implementation instead of Envoy Gateway: name: your-gateway-name # Can be same Gateway with different listener namespace: your-namespace listenerName: nats # TCP listener name for NATS + llmGrpc: + name: your-llm-grpc-gateway # Gateway with the TCP port 50071 listener + namespace: your-namespace + listenerName: llm-grpc + llmQuic: + name: your-llm-quic-gateway # Gateway with the UDP port 50072 listener + namespace: your-namespace + listenerName: llm-quic ``` The `nvcf-gateway-routes` chart creates the enabled routes and attaches them to diff --git a/src/clis/nvcf-cli/internal/agentskill/skilldata_generated.go b/src/clis/nvcf-cli/internal/agentskill/skilldata_generated.go index 48cb288e4..265d9a822 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" + - "MDowMFoiLAogICJ0b3RhbEZpbGVzIjogMjIsCiAgInRvdGFsQnl0ZXMiOiAxOTgwNjksCiAgImZp" + + "MDowMFoiLAogICJ0b3RhbEZpbGVzIjogMjIsCiAgInRvdGFsQnl0ZXMiOiAxOTg4ODMsCiAgImZp" + "bGVzIjogWwogICAgewogICAgICAicGF0aCI6ICJudmNmLXNlbGYtbWFuYWdlZC1jbGkvU0tJTEwu" + "bWQiLAogICAgICAic2hhMjU2IjogImM0ZjI4OGY2MmU1MDg4NjI5ZGY1MTcyYTlhYjMwZWVlOGMz" + "OTRmYzgzOTFjMjMwMDMzNzI2NGVmZjRiMmU3ZWYiLAogICAgICAic2l6ZSI6IDI0OTA5CiAgICB9" + @@ -56,3615 +56,3629 @@ const skillDataZipBase64 = "" + "NTU5NWY1ZjNmZTA2YTU5ZjQ2M2U0NGUyMGFkNjg2YjRlYzQ2Mjk2MjI1ODRjZTRmMDQ3NSIsCiAg" + "ICAgICJzaXplIjogMzc3MwogICAgfSwKICAgIHsKICAgICAgInBhdGgiOiAibnZjZi1zZWxmLW1h" + "bmFnZWQtY2xpL3Byb21wdHMvaW5zdGFsbC1mcm9tLXNjcmF0Y2gubWQiLAogICAgICAic2hhMjU2" + - "IjogImUwYWUxODMxNjgyZDUwNDA0N2NiYjVkMmRiYjRhMjhmNTEzODU0NTkyMTM5MTQzZGJkMjNm" + - "ZTk2MTNhOWFlOTMiLAogICAgICAic2l6ZSI6IDkzMzMKICAgIH0sCiAgICB7CiAgICAgICJwYXRo" + - "IjogIm52Y2Ytc2VsZi1tYW5hZ2VkLWNsaS9wcm9tcHRzL3JvdGF0ZS1jbHVzdGVyLWp3a3MubWQi" + - "LAogICAgICAic2hhMjU2IjogIjZmYWU1NTYyZGM1ZTk3YzI0YTkzNjA1YjY3NGEwYWZjN2VjNGEz" + - "ZDBiZWMzY2ViZjlmNjRlOGJlNmYyNjc4YTUiLAogICAgICAic2l6ZSI6IDE5OTEKICAgIH0sCiAg" + - "ICB7CiAgICAgICJwYXRoIjogIm52Y2Ytc2VsZi1tYW5hZ2VkLWNsaS9wcm9tcHRzL3RlYXJkb3du" + - "Lm1kIiwKICAgICAgInNoYTI1NiI6ICJiYjQwZjgxMzc3YzRjZTNhZGQ4ZWE0MWY3MzMyYzU5ZmFk" + - "MDdiZjhhMjBkZDMwMmNkMmJmODM4ZGZjNjQ1ZDBmIiwKICAgICAgInNpemUiOiA4NjcyCiAgICB9" + - "LAogICAgewogICAgICAicGF0aCI6ICJudmNmLXNlbGYtbWFuYWdlZC1jbGkvcmVmZXJlbmNlL2Nv" + - "bW1hbmRzLm1kIiwKICAgICAgInNoYTI1NiI6ICIyYjRiMDM2ZTc1MDcwNmI5ZTNiODFmY2Q2MDJj" + - "NzA2Zjc0Zjc3ZjYyNDBmYjdhYWQ2MjBjODc5ZmY3NDk2Y2Q4IiwKICAgICAgInNpemUiOiA4OTkz" + - "CiAgICB9LAogICAgewogICAgICAicGF0aCI6ICJudmNmLXNlbGYtbWFuYWdlZC1jbGkvcmVmZXJl" + - "bmNlL2V4aXQtY29kZXMubWQiLAogICAgICAic2hhMjU2IjogIjY0YjVmYTliY2FmMGUwYTUzZjc4" + - "OTIwYjczZmNiNTMwYWI2OTQ1MWI0OGE1YjQ5M2YyNTJjYTE4NTgzYWIwODYiLAogICAgICAic2l6" + - "ZSI6IDE3NDkKICAgIH0sCiAgICB7CiAgICAgICJwYXRoIjogIm52Y2Ytc2VsZi1tYW5hZ2VkLWNs" + - "aS9yZWZlcmVuY2UvZmxhZ3MubWQiLAogICAgICAic2hhMjU2IjogIjU0YjVlYTc5ODFkMjYyNmM1" + - "ODM1MzMyYWJhMjdlYjI4N2FjYTg5ZTFiYWRjYjJmYWI4MDcwMWFlMjlmNzZlMDgiLAogICAgICAi" + - "c2l6ZSI6IDg5MDIKICAgIH0sCiAgICB7CiAgICAgICJwYXRoIjogIm52Y2Ytc2VsZi1tYW5hZ2Vk" + - "LWNsaS9yZWZlcmVuY2UvdHJvdWJsZXNob290aW5nLm1kIiwKICAgICAgInNoYTI1NiI6ICJhNjMw" + - "ODRlMjI0OWYxZDE1NGM1OTgxZTRhMDcyYjdjNzg0Yjg1ZWExNDYwODY1MTVlYWI0YWI2NzBhOTQw" + - "ZTk0IiwKICAgICAgInNpemUiOiA0NDY4CiAgICB9LAogICAgewogICAgICAicGF0aCI6ICJudmNm" + - "LXNlbGYtbWFuYWdlZC1pbnN0YWxsYXRpb24vU0tJTEwubWQiLAogICAgICAic2hhMjU2IjogImMz" + - "M2ZkODMwNWVjM2ZkMDIwZWI0Yzk4MmMzYWZlNzZhN2MxZDQzYzNlMDU0YzhmYmQzOGM0YmIxYjcw" + - "N2M3NWEiLAogICAgICAic2l6ZSI6IDI1MTU0CiAgICB9LAogICAgewogICAgICAicGF0aCI6ICJu" + - "dmNmLXNlbGYtbWFuYWdlZC1pbnN0YWxsYXRpb24vZXZhbHMvZXZhbHMuanNvbiIsCiAgICAgICJz" + - "aGEyNTYiOiAiYzViNDUzMzdlNDliM2FiOGFlMjgzNDVkMzE2NGE3ZjU3OTE5ZTY0NDg5ODcwMmQw" + - "Y2FhZDQ4YWVlMjhiMWYzYSIsCiAgICAgICJzaXplIjogMjE5MzMKICAgIH0sCiAgICB7CiAgICAg" + - "ICJwYXRoIjogIm52Y2Ytc2VsZi1tYW5hZ2VkLWluc3RhbGxhdGlvbi9leGFtcGxlcy5tZCIsCiAg" + - "ICAgICJzaGEyNTYiOiAiOWEzOWU1Y2NhYmQ0MDgxOWM3MWYyYjBmMmQ3NTIzMTZiNzIzMTU2NTRk" + - "ODBkM2QwMTc2OThjZTFmYjNlNWIxMSIsCiAgICAgICJzaXplIjogMTAzNjcKICAgIH0sCiAgICB7" + - "CiAgICAgICJwYXRoIjogIm52Y2Ytc2VsZi1tYW5hZ2VkLWluc3RhbGxhdGlvbi9yZWZlcmVuY2Vz" + - "L2NvbXB1dGUtcGxhbmUtaW5zdGFsbGF0aW9uLm1kIiwKICAgICAgInNoYTI1NiI6ICI1ZGVlNThh" + - "ZTJjNjdhNjI5NDZlM2M1OTMwMmFmYWNjNDBiZGU3MWY4ZGMyZjI1Y2Q3Nzk5Y2M0NWI0NzRmYTE5" + - "IiwKICAgICAgInNpemUiOiAxMjMwNgogICAgfSwKICAgIHsKICAgICAgInBhdGgiOiAibnZjZi1z" + - "ZWxmLW1hbmFnZWQtaW5zdGFsbGF0aW9uL3JlZmVyZW5jZXMvZGVidWdnaW5nLm1kIiwKICAgICAg" + - "InNoYTI1NiI6ICJhNTI4MTU4YmMwYmZmZmVlZjZlMDFkZTM4NGNhZjU2NWU2NDQ1YjQ4YWJkM2Nl" + - "ZTQwMDQ4NzFmNTIzZjUzYjk3IiwKICAgICAgInNpemUiOiAxMjQzNwogICAgfSwKICAgIHsKICAg" + - "ICAgInBhdGgiOiAibnZjZi1zZWxmLW1hbmFnZWQtaW5zdGFsbGF0aW9uL3JlZmVyZW5jZXMvaGVs" + - "bWZpbGUtc3RydWN0dXJlLm1kIiwKICAgICAgInNoYTI1NiI6ICIxZDUyNzc2ZjlkN2Q4ZGY1OGRl" + - "ZmUzMDQ2ZDYzZWM4ZjUyZmQzMDFjMjE1YmYwZTFhYjZiYjkxOTE2MjA3M2RlIiwKICAgICAgInNp" + - "emUiOiAxMDEyNwogICAgfSwKICAgIHsKICAgICAgInBhdGgiOiAibnZjZi1zZWxmLW1hbmFnZWQt" + - "aW5zdGFsbGF0aW9uL3JlZmVyZW5jZXMvbnZjZi11aS1hZGRvbi5tZCIsCiAgICAgICJzaGEyNTYi" + - "OiAiNTA1MjRlNmUxOTcxMTgzYmRjOWFkMGFjMzhhODA3ZGY3MmNjMDg1MWI3OWY1MThmZTExYTQ4" + - "ZTQ1OTdjODUwZSIsCiAgICAgICJzaXplIjogMTk3NwogICAgfSwKICAgIHsKICAgICAgInBhdGgi" + - "OiAibnZjZi1zZWxmLW1hbmFnZWQtaW5zdGFsbGF0aW9uL3JlZmVyZW5jZXMvcHVsbC1zZWNyZXRz" + - "Lm1kIiwKICAgICAgInNoYTI1NiI6ICJlYzFmM2ZmY2QxN2U1Zjk1ODNmZWUzOTc0NGVlODk3ZDQ2" + - "NmJjM2NmNjM4OTI5NDI2NGQ4OWU3ZjllZDAxYjg3IiwKICAgICAgInNpemUiOiA1NjMyCiAgICB9" + - "CiAgXQp9ClBLBwitcpafSBAAAEgQAABQSwMEFAAIAAAAAAAhAAAAAAAAAAAAAAAAACMACQBkYXRh" + - "L252Y2Ytc2VsZi1tYW5hZ2VkLWNsaS9TS0lMTC5tZFVUBQABAKbOEi0tLQpuYW1lOiBudmNmLXNl" + - "bGYtbWFuYWdlZC1jbGkKZGVzY3JpcHRpb246IHwKICBJbnN0YWxsLCBvcGVyYXRlLCBhbmQgdGVh" + - "ciBkb3duIHNlbGYtaG9zdGVkIE5WSURJQSBDbG91ZCBGdW5jdGlvbnMgKE5WQ0YpCiAgZGVwbG95" + - "bWVudHMgd2l0aCBudmNmLWNsaS4gVXNlIGZvciBjb250cm9sLXBsYW5lIG9yIGNvbXB1dGUtcGxh" + - "bmUgaW5zdGFsbCwKICBzdGF0dXMgY2hlY2tzLCBjbHVzdGVyIHJlZ2lzdHJhdGlvbiwgZnVuY3Rp" + - "b24gZGVwbG95L2ludm9rZSwgdGFzawogIGNyZWF0ZS9saXN0L2NhbmNlbC9kZWxldGUsIEFQSSBr" + - "ZXlzLCBhZG1pbiB0b2tlbnMsIEpXS1Mgcm90YXRpb24sCiAgZmFpbGVkLWluc3RhbGwgZGlhZ25v" + - "c2lzLCBhbmQgdW5pbnN0YWxsIG9yIGRvd24gd29ya2Zsb3dzLiBUcmlnZ2VyIGtleXdvcmRzOgog" + - "IG52Y2YsIG52Y2YtY2xpLCBzZWxmLWhvc3RlZCBudmNmLCBzZWxmLW1hbmFnZWQgbnZjZiwgTlZD" + - "RkJhY2tlbmQsIE5WQ0EsIE5DUCwKICBJQ01TLCBoZWxtZmlsZSwgY29udHJvbCBwbGFuZSwgY29t" + - "cHV0ZSBwbGFuZSwgTExNIGZ1bmN0aW9uLAogIE9wZW5BSS1jb21wYXRpYmxlIGludm9jYXRpb24s" + - "IFJlc3BvbnNlcyBBUEksIGVtYmVkZGluZ3MsIGJhdGNoIHRhc2ssIHRhc2sKICBtb25pdG9yLCBj" + - "bHVzdGVyIHJvdGF0ZSwgY2x1c3RlciBkZWxldGUsIGhlbG0gdGFzaywgaGVsbS1iYXNlZCB0YXNr" + - "LAogIHRhc2sgc2VjcmV0cywgdXBkYXRlIHRhc2sgc2VjcmV0cywgcmV0cmlldmUgdGFzayByZXN1" + - "bHRzLCBidWxrIGZldGNoIHRhc2tzLAogIHRhc2sgcmVzdWx0cywgTlZDVCwgTlZDVCB0YXNrLCBO" + - "VkNUIGJhdGNoIGpvYi4KYWxsb3dlZC10b29sczogQmFzaCwgUmVhZCwgQXNrVXNlclF1ZXN0aW9u" + - "CmFyZ3VtZW50LWhpbnQ6ICJbaW5zdGFsbHxzdGF0dXN8Y2hlY2t8ZGVwbG95LWZ1bmN0aW9ufHJl" + - "Z2lzdGVyLWNsdXN0ZXJ8dGVhcmRvd25dIFthcmdzXSIKLS0tCjwhLS0KVG9rZW4gQnVkZ2V0Ogot" + - "IExldmVsIDEgKFlBTUwpOiB+MTIwIHRva2VucwotIExldmVsIDIgKHRoaXMgZmlsZSk6IH4xOTAw" + - "IHRva2VucyAodGFyZ2V0IDwyMDAwKQotIExldmVsIDMgKHByb21wdHMvLCByZWZlcmVuY2UvLCBl" + - "eGFtcGxlcy8pOiBsb2FkZWQgb24gZGVtYW5kCi0tPgoKIyBOVkNGIFNlbGYtSG9zdGVkIENMSQoK" + - "YG52Y2YtY2xpYCBkcml2ZXMgZXZlcnkgc3RlcCBvZiBicmluZ2luZyB1cCBzZWxmLWhvc3RlZCBO" + - "VklESUEgQ2xvdWQgRnVuY3Rpb25zOiBjbHVzdGVyIHJlZ2lzdHJhdGlvbiwgY29udHJvbC1wbGFu" + - "ZSBpbnN0YWxsLCBjb21wdXRlLXBsYW5lIGluc3RhbGwsIGZ1bmN0aW9uIGRlcGxveS9pbnZva2Us" + - "IGFuZCBsaWZlY3ljbGUgbWFuYWdlbWVudC4gVXNlIHRoaXMgc2tpbGwgYW55IHRpbWUgdGhlIHVz" + - "ZXIgd2FudHMgdG8gb3BlcmF0ZSBzZWxmLWhvc3RlZCBOVkNGLgoKIyMgV2hlbiB0byB1c2UKCi0g" + - "Imluc3RhbGwgc2VsZi1ob3N0ZWQgTlZDRiIgLyAiYnJpbmcgdXAgYW4gTlZDRiBjbHVzdGVyIgot" + - "ICJyZWdpc3RlciBhIChjb21wdXRlfEdQVSkgY2x1c3RlciB3aXRoIE5WQ0YiCi0gImRlcGxveSBh" + - "IChjb250YWluZXJ8R1BVKSBmdW5jdGlvbiIgLyAiaW52b2tlIGFuIE5WQ0YgZnVuY3Rpb24iCi0g" + - "ImNoZWNrIE5WQ0YgY2x1c3RlciBoZWFsdGgiIC8gImlzIG15IE5WQ0YgaW5zdGFsbCBPSz8iCi0g" + - "InJvdGF0ZSBOVkNGIGNsdXN0ZXIgSldLUyIgLyAidGhlIE5WQ0EgYWdlbnQgc3RvcHBlZCBhdXRo" + - "ZW50aWNhdGluZyIKLSAidGVhciBkb3duIE5WQ0YiIC8gInJlbW92ZSB0aGUgY29tcHV0ZSBwbGFu" + - "ZSIgLyAidW5pbnN0YWxsIE5WQ0YiIC8gImRlcmVnaXN0ZXIgdGhpcyBjbHVzdGVyIgotICJwcmV2" + - "aWV3IHdoYXQgYGRvd25gIHdvdWxkIGRvIiAvICJkcnktcnVuIHVuaW5zdGFsbCIKLSBBbnkgdGFz" + - "ayBvcGVyYXRpb246IGNyZWF0ZSAvIHJ1biAvIHN1Ym1pdCAvIG1vbml0b3IgLyBjYW5jZWwgLyBk" + - "ZWxldGUgLyBsaXN0IHRhc2tzLCBoZWxtIHRhc2ssIHVwZGF0ZSB0YXNrIHNlY3JldHMsIHJldHJp" + - "ZXZlIHRhc2sgcmVzdWx0cywgYnVsayBmZXRjaCB0YXNrIGRldGFpbHMuCi0gQW55IHJlZmVyZW5j" + - "ZSB0byBgTlZDVGAsIGBOVkNUIHRhc2tgLCBvciBgTlZDVCBiYXRjaCBqb2JgIChsaXN0IC8gcnVu" + - "IC8gY2FuY2VsIC8gZGVsZXRlIC8gcmVzdWx0cykuCi0gQW55IHJlZmVyZW5jZSB0byBgTlZDRkJh" + - "Y2tlbmRgLCBgTlZDQWAsIElDTVMsIGhlbG0gcmVsZWFzZXMgbGlrZSBgaGVsbS1udmNmLSpgLCBv" + - "ciBgaWNtcy48ZG9tYWluPmAgLyBgYXBpLjxkb21haW4+YCBVUkxzLgoKIyMgUXVpY2sgc3RhcnQK" + - "CkZvciByZW1vdGUgb25lLWNsaWNrIGluc3RhbGxzLCBwcmVwYXJlIEdhdGV3YXkgQVBJIGluZ3Jl" + - "c3MgYW5kIENMSSBlbmRwb2ludApjb25maWd1cmF0aW9uIGJlZm9yZSBydW5uaW5nIGBzZWxmLWhv" + - "c3RlZCB1cGAuIFRoZSBjb21tYW5kIGFwcGxpZXMgdGhlIGNvbnRyb2wKcGxhbmUgYW5kIHRoZW4g" + - "aW1tZWRpYXRlbHkgY2FsbHMgQVBJLCBBUEkgS2V5cywgaW52b2NhdGlvbiwgYW5kIGdSUEMgZW5k" + - "cG9pbnRzLgpJZiB0aGUgR2F0ZXdheSBpcyBub3QgcHJvZ3JhbW1lZCBvciB0aGUgQ0xJIGhvc3Qg" + - "aGVhZGVycyBkbyBub3QgbWF0Y2ggdGhlCkhUVFBSb3V0ZXMgcmVuZGVyZWQgYnkgdGhlIHN0YWNr" + - "IGVudmlyb25tZW50LCBwb3N0LWluc3RhbGwgaGVhbHRoIGFuZCBjbHVzdGVyCnJlZ2lzdHJhdGlv" + - "biB3aWxsIGZhaWwuCgpgYGBzaAojIFNpbmdsZS1jbHVzdGVyIChjb250cm9sICsgY29tcHV0ZSBv" + - "biB0aGUgY3VycmVudCBrdWJlY29uZmlnIGNvbnRleHQpOgpudmNmLWNsaSBzZWxmLWhvc3RlZCB1" + - "cCAtLWNsdXN0ZXItbmFtZT1uY3AtbG9jYWwKCiMgU3BsaXQtY2x1c3RlciAoY29udHJvbCBwbGFu" + - "ZSBvbiBjb250ZXh0IEEsIGNvbXB1dGUgcGxhbmUgb24gY29udGV4dCBCKToKS1VCRUNPTkZJRz1j" + - "cC55YW1sOmdwdTEueWFtbCBudmNmLWNsaSBzZWxmLWhvc3RlZCB1cCBcCiAgLS1jbHVzdGVyLW5h" + - "bWU9bmNwLWxvY2FsIFwKICAtLWNvbnRyb2wtcGxhbmUtY29udGV4dD1hZG1pbkBjcCBcCiAgLS1j" + - "b21wdXRlLXBsYW5lLWNvbnRleHQ9YWRtaW5AZ3B1MSBcCiAgLS1pY21zLXVybD1odHRwczovL2lj" + - "bXMubnZjZi5leGFtcGxlLmNvbQoKIyBBZGQgYSBuZXcgY29tcHV0ZSBwbGFuZSB0byBhbiBleGlz" + - "dGluZyBjb250cm9sIHBsYW5lIChubyBrdWJlY3RsIGFjY2VzcyB0byBDUCBuZWVkZWQ7CiMgcmVh" + - "Y2hlcyB0aGUgY29udHJvbCBwbGFuZSB2aWEgdGhlIHB1YmxpYyBJQ01TIEhUVFBSb3V0ZSk6Cm52" + - "Y2YtY2xpIHNlbGYtaG9zdGVkIGFkZC1jb21wdXRlLXBsYW5lIFwKICAtLWNsdXN0ZXItbmFtZT1u" + - "Y3AtbG9jYWwtMiBcCiAgLS1jb21wdXRlLXBsYW5lLWNvbnRleHQ9YWRtaW5AZ3B1MiBcCiAgLS1p" + - "Y21zLXVybD1odHRwczovL2ljbXMubnZjZi5leGFtcGxlLmNvbSBcCiAgLS10b2tlbj0kQURNSU5f" + - "SldUCgojIFRlYXIgZG93biAoYWx3YXlzIHBsYW4tb25seSBmaXJzdCk6Cm52Y2YtY2xpIHNlbGYt" + - "aG9zdGVkIGRvd24gLS1wbGFuLW9ubHkgLS1jbHVzdGVyLW5hbWU9bmNwLWxvY2FsIC0tanNvbiB8" + - "IGpxCm52Y2YtY2xpIHNlbGYtaG9zdGVkIGRvd24gLS1jbHVzdGVyLW5hbWU9bmNwLWxvY2FsCgoj" + - "IFBlci1wbGFuZSB1bmluc3RhbGwgKEdpdE9wczsgbWlycm9ycyBgaW5zdGFsbGApOgpudmNmLWNs" + - "aSBzZWxmLWhvc3RlZCB1bmluc3RhbGwgLS1uby1hcHBseSAtLWNvbXB1dGUtcGxhbmUgLS1jbHVz" + - "dGVyLW5hbWU9bmNwLWxvY2FsIHwga3ViZWN0bCBkZWxldGUgLWYgLQpgYGAKCj4gKipgdXBgIHZz" + - "IGBhZGQtY29tcHV0ZS1wbGFuZWAuKiogYHVwYCBhbHdheXMgaW5zdGFsbHMgYm90aCBwbGFuZXMg" + - "4oCUIHVzZSBpdCBmb3IgdGhlICpmaXJzdCogaW5zdGFsbC4gYGFkZC1jb21wdXRlLXBsYW5lYCBp" + - "cyB0aGUgcmlnaHQgc3ViY29tbWFuZCBhbnkgdGltZSB0aGUgY29udHJvbCBwbGFuZSBpcyBhbHJl" + - "YWR5IHJ1bm5pbmcgYW5kIHlvdSB3YW50IHRvIGF0dGFjaCBhbiBOdGggY29tcHV0ZSBjbHVzdGVy" + - "LgoKPiAqKmBkb3duYCBhbHdheXMgd2l0aCBgLS1wbGFuLW9ubHlgIGZpcnN0LioqIFNob3cgdGhl" + - "IHVzZXIgdGhlIGB3aWxsVW5pbnN0YWxsLmNvbW1hbmRzW11gIGFycmF5IGJlZm9yZSBydW5uaW5n" + - "IGZvciByZWFsLgoKIyMgQXV0aGVudGljYXRpb24KCmBudmNmLWNsaWAgdXNlcyB0d28gY3JlZGVu" + - "dGlhbHMuIEVhY2ggaXMgcmVzb2x2ZWQgaW5kZXBlbmRlbnRseSBpbiB0aGlzIG9yZGVyOgoKfCBQ" + - "cmVjZWRlbmNlIHwgU291cmNlIHwKfC0tLXwtLS18CnwgMSAoaGlnaGVzdCkgfCBFbnZpcm9ubWVu" + - "dCB2YXJpYWJsZSAoYE5WQ0ZfVE9LRU5gLCBgTlZDRl9BUElfS0VZYCkgfAp8IDIgfCBDb25maWcg" + - "ZmlsZSAoYH4vLm52Y2YtY2xpLnlhbWxgLCBrZXlzIGB0b2tlbmAgYW5kIGBhcGlfa2V5YCkgfAp8" + - "IDMgfCBTdGF0ZSBmaWxlIChgfi8ubnZjZi1jbGkuc3RhdGVgKSwgc2tpcHBlZCB3aGVuIHRoZSBz" + - "dG9yZWQgdG9rZW4gaXMgZXhwaXJlZCB8Cgp8IEVudiB2YXIgfCBUb2tlbiB0eXBlIHwgVXNlZCBi" + - "eSB8CnwtLS18LS0tfC0tLXwKfCBgTlZDRl9UT0tFTmAgfCBBZG1pbiBKV1QgfCBgZnVuY3Rpb24g" + - "Y3JlYXRlYCAvIGBkZXBsb3lgIC8gYHVwZGF0ZWAgLyBgZGVsZXRlYCwgY2x1c3RlciBtYW5hZ2Vt" + - "ZW50IChgY2x1c3RlciByZWdpc3RlcmAvYGxpc3QtcmVnaXN0ZXJlZGAvYHJvdGF0ZWAvYGRlbGV0" + - "ZWAsIGBzZWxmLWhvc3RlZGAgb3BzKS4gUmVxdWlyZWQgZm9yIGFkbWluIGNvbW1hbmRzOyBwcmVm" + - "ZXJyZWQgZm9yIHRoZSByZXN0LiB8CnwgYE5WQ0ZfQVBJX0tFWWAgfCBgbnZhcGktLi4uYCBBUEkg" + - "a2V5IHwgYGZ1bmN0aW9uIGludm9rZWAgLyBgbGlzdGAgLyBgZ2V0YCwgcXVldWUgZGV0YWlscy4g" + - "RmFsbHMgYmFjayB0byBgTlZDRl9UT0tFTmAgd2hlbiB1bnNldC4gfAoKVG9rZW4gZ2VuZXJhdGlv" + - "biBmbG93OgoKMS4gUG9pbnQgdGhlIENMSSBhdCB5b3VyIHNlbGYtaG9zdGVkIGVuZHBvaW50cy4g" + - "RGVmYXVsdHMgdGFyZ2V0IHByb2R1Y3Rpb24gTlZDRjsgb3ZlcnJpZGUgd2l0aCBlbnYgdmFycyBv" + - "ciBhIHlhbWwgZmlsZSAoYC0tY29uZmlnIDxwYXRoPmAsIGAuLy5udmNmLWNsaS55YW1sYCwgb3Ig" + - "YH4vLm52Y2YtY2xpLnlhbWxgOyBhIGZ1bGwgdGVtcGxhdGUgc2hpcHMgYXQgYHNyYy9jbGlzL252" + - "Y2YtY2xpLy5udmNmLWNsaS55YW1sLnRlbXBsYXRlYCkuCgogICBgTlZDRl9CQVNFX0hUVFBfVVJM" + - "YCAvIGBBUElfS0VZU19TRVJWSUNFX1VSTGAgLyBgTlZDRl9CQVNFX0dSUENfVVJMYCB0ZWxsIHRo" + - "ZSBDTEkgKndoZXJlIHRvIHNlbmQgcmVxdWVzdHMqLiBgQVBJX0hPU1RgIC8gYEFQSV9LRVlTX0hP" + - "U1RgIC8gYElOVk9LRV9IT1NUYCBzZXQgdGhlIGBIb3N0OmAgaGVhZGVyIG9uIHRob3NlIHJlcXVl" + - "c3RzIOKAlCBuZWVkZWQgd2hlbiBldmVyeSBOVkNGIHNlcnZpY2Ugc2l0cyBiZWhpbmQgYSBzaW5n" + - "bGUgZ2F0ZXdheSB0aGF0IHJvdXRlcyBieSBob3N0bmFtZSAoRW52b3kgR2F0ZXdheSBIVFRQUm91" + - "dGUgb24gYGFwaS48RUxCPmAsIGBhcGkta2V5cy48RUxCPmAsIGBpbnZvY2F0aW9uLjxFTEI+YCwg" + - "YGxsbS48RUxCPmApLiBTa2lwIHRoZSB0aHJlZSBIb3N0IHZhcnMgd2hlbiB0aGUgYmFzZSBVUkwg" + - "YWxyZWFkeSByZXNvbHZlcyB0byB0aGUgcmlnaHQgc2VydmljZS4KCiAgIEVudi12YXIgZm9ybToK" + - "ICAgYGBgc2gKICAgZXhwb3J0IE5WQ0ZfQkFTRV9IVFRQX1VSTD1odHRwczovL2d3LmV4YW1wbGUu" + - "Y29tCiAgIGV4cG9ydCBBUElfS0VZU19TRVJWSUNFX1VSTD1odHRwczovL2d3LmV4YW1wbGUuY29t" + - "CiAgIGV4cG9ydCBOVkNGX0JBU0VfR1JQQ19VUkw9Z3cuZXhhbXBsZS5jb206NDQzCgogICAjIE9u" + - "bHkgd2hlbiB0aGUgZ2F0ZXdheSByb3V0ZXMgYnkgSG9zdCBoZWFkZXI6CiAgIGV4cG9ydCBBUElf" + - "S0VZU19IT1NUPWFwaS1rZXlzLmd3LmV4YW1wbGUuY29tCiAgIGV4cG9ydCBBUElfSE9TVD1hcGku" + - "Z3cuZXhhbXBsZS5jb20KICAgZXhwb3J0IElOVk9LRV9IT1NUPWludm9jYXRpb24uZ3cuZXhhbXBs" + - "ZS5jb20KICAgYGBgCgogICBZYW1sIGZvcm0gKGB+Ly5udmNmLWNsaS55YW1sYCk6CiAgIGBgYHlh" + - "bWwKICAgYmFzZV9odHRwX3VybDogaHR0cHM6Ly9ndy5leGFtcGxlLmNvbQogICBhcGlfa2V5c19z" + - "ZXJ2aWNlX3VybDogaHR0cHM6Ly9ndy5leGFtcGxlLmNvbQogICBiYXNlX2dycGNfdXJsOiBndy5l" + - "eGFtcGxlLmNvbTo0NDMKCiAgICMgT25seSB3aGVuIHRoZSBnYXRld2F5IHJvdXRlcyBieSBIb3N0" + - "IGhlYWRlcjoKICAgYXBpX2tleXNfaG9zdDogYXBpLWtleXMuZ3cuZXhhbXBsZS5jb20KICAgYXBp" + - "X2hvc3Q6IGFwaS5ndy5leGFtcGxlLmNvbQogICBpbnZva2VfaG9zdDogaW52b2NhdGlvbi5ndy5l" + - "eGFtcGxlLmNvbQogICBgYGAKCjIuIGBudmNmLWNsaSBpbml0YCBjYWxscyB0aGUgQVBJIEtleXMg" + - "c2VydmljZSB2aWEgdGhvc2UgZW5kcG9pbnRzIGFuZCB3cml0ZXMgdGhlIGFkbWluIHRva2VuIHRv" + - "IGB+Ly5udmNmLWNsaS5zdGF0ZWAuIFVzZSBgbnZjZi1jbGkgcmVmcmVzaGAgdG8gcm90YXRlIGEg" + - "c3RvcmVkIHRva2VuLgozLiBBZnRlciBgaW5pdGAsIGBudmNmLWNsaSBhcGkta2V5IGdlbmVyYXRl" + - "YCBtaW50cyBmdW5jdGlvbiArIHRhc2sgQVBJIGtleXMgKGFsc28gc3RvcmVkIGluIHN0YXRlKS4K" + - "CkFmdGVyIGBpbml0YCwgdGhlIGNyZWRlbnRpYWxzIGxpdmUgaW4gYH4vLm52Y2YtY2xpLnN0YXRl" + - "YCwgc28gbGF0ZXIgY29tbWFuZHMgd29yayB3aXRob3V0IGV4cG9ydGluZyBgTlZDRl9UT0tFTmAg" + - "b3IgYE5WQ0ZfQVBJX0tFWWAuIEV4cG9ydCB0aGUgZW52IHZhciBvbmx5IHRvIG92ZXJyaWRlIHRo" + - "ZSBzdG9yZWQgdmFsdWUgKGZvciBleGFtcGxlIGEgc2hvcnRlci1saXZlZCB0b2tlbiBmcm9tIENJ" + - "KS4KCiMjIENvcmUgc3ViY29tbWFuZHMKCnwgU3ViY29tbWFuZCB8IFdoYXQgaXQgZG9lcyB8IFdo" + - "ZW4gdG8gdXNlIHwKfC0tLXwtLS18LS0tfAp8IGBudmNmLWNsaSBzZWxmLWhvc3RlZCBjaGVjayAt" + - "LXByZSBbLS1sb2NhbC1vbmx5IFx8IC0tY29udHJvbC1wbGFuZS1jb250ZXh0PVggXHwgLS1jb21w" + - "dXRlLXBsYW5lLWNvbnRleHQ9WV1gIHwgUHJlLWZsaWdodDogbG9jYWwtaG9zdCB0b29scyArIGNs" + - "dXN0ZXItc2lkZSBwcmVyZXF1aXNpdGVzIHwgQWx3YXlzIHJ1biBmaXJzdCBvbiBhIG5ldyBlbnZp" + - "cm9ubWVudCB8CnwgYG52Y2YtY2xpIHNlbGYtaG9zdGVkIGluc3RhbGwgLS1jb250cm9sLXBsYW5l" + - "IFx8IGt1YmVjdGwgYXBwbHkgLWYgLWAgfCBSZW5kZXIgKyBhcHBseSB0aGUgY29udHJvbCBwbGFu" + - "ZSB8IFdoZW4geW91IHdhbnQgbWFudWFsIGNvbnRyb2wgb3ZlciBhcHBseSAoR2l0T3BzLWZyaWVu" + - "ZGx5KSB8CnwgYG52Y2YtY2xpIHNlbGYtaG9zdGVkIGluc3RhbGwgLS1jb21wdXRlLXBsYW5lIC0t" + - "Y2x1c3Rlci1uYW1lPVggXHwga3ViZWN0bCBhcHBseSAtZiAtYCB8IFJlZ2lzdGVyIGNsdXN0ZXIg" + - "KyByZW5kZXIgY29tcHV0ZSBwbGFuZSB8IFNhbWUg4oCUIG1hbnVhbCBhcHBseSBwYXRoIHwKfCBg" + - "bnZjZi1jbGkgc2VsZi1ob3N0ZWQgdXAgLS1jbHVzdGVyLW5hbWU9WGAgfCBPbmUtc2hvdCBmaXJz" + - "dCBpbnN0YWxsOiBwcmUtZmxpZ2h0IOKGkiBjb250cm9sIHBsYW5lIOKGkiByZWdpc3RlciDihpIg" + - "Y29tcHV0ZSBwbGFuZSB8IFN0YW5kYXJkIGluc3RhbGwgcGF0aCAoYm90aCBwbGFuZXMgZnJvbSBz" + - "Y3JhdGNoKSB8CnwgYG52Y2YtY2xpIHNlbGYtaG9zdGVkIHVwIC0tcGxhbi1vbmx5IC0tY2x1c3Rl" + - "ci1uYW1lPVhgIHwgRHJ5LXJ1bjogZW1pdCBwaGFzZS1ieS1waGFzZSBwbGFuICsgRVRBIHdpdGhv" + - "dXQgY2hhbmdpbmcgc3RhdGUgfCBBZ2VudCAvIENJIHByZXZpZXcgYmVmb3JlIGNvbW1pdCB8Cnwg" + - "YG52Y2YtY2xpIHNlbGYtaG9zdGVkIGFkZC1jb21wdXRlLXBsYW5lIC0tY2x1c3Rlci1uYW1lPVgg" + - "LS1jb21wdXRlLXBsYW5lLWNvbnRleHQ9WSAtLWljbXMtdXJsPeKApiAtLXRva2VuPSRKV1RgIHwg" + - "QWRkIGEgbmV3IGNvbXB1dGUgcGxhbmUgdG8gYW4gKmV4aXN0aW5nKiBjb250cm9sIHBsYW5lIChu" + - "byBDUCBpbnN0YWxsKSB8IEFkZGluZyB0aGUgMm5kLCAzcmQsIOKApiBHUFUgY2x1c3RlciBhZnRl" + - "ciB0aGUgaW5pdGlhbCBgdXBgIHwKfCBgbnZjZi1jbGkgc2VsZi1ob3N0ZWQgdW5pbnN0YWxsIC0t" + - "Y29udHJvbC1wbGFuZWAgfCBQZXItcGxhbmUgcHJpbWl0aXZlOiBgaGVsbWZpbGUgZGVzdHJveWAg" + - "b24gdGhlIGNvbnRyb2wgcGxhbmUgKHJlZnVzZXMgaWYgY29tcHV0ZSBwbGFuZXMgc3RpbGwgcmVn" + - "aXN0ZXJlZCkgfCBGaW5hbCB0ZWFyZG93biBhZnRlciBhbGwgY29tcHV0ZSBwbGFuZXMgYXJlIGdv" + - "bmUsIG9yIHNjcmlwdGVkIHBpcGVsaW5lcyB8CnwgYG52Y2YtY2xpIHNlbGYtaG9zdGVkIHVuaW5z" + - "dGFsbCAtLWNvbXB1dGUtcGxhbmUgLS1jbHVzdGVyLW5hbWU9WGAgfCBQZXItcGxhbmUgcHJpbWl0" + - "aXZlOiBgaGVsbWZpbGUgZGVzdHJveWAgb24gYSBjb21wdXRlIHBsYW5lIChubyBJQ01TIHVucmVn" + - "aXN0ZXIsIG5vIGRyYWluKSB8IEp1c3QgcmVtb3ZlIHRoZSBoZWxtIHJlbGVhc2VzIHdpdGhvdXQg" + - "dGhlIElDTVMtc2lkZSBjbGVhbnVwIHwKfCBgbnZjZi1jbGkgc2VsZi1ob3N0ZWQgdW5pbnN0YWxs" + - "IC0tbm8tYXBwbHkgPHBsYW5lPmAgfCBSZW5kZXIgZGVsZXRlIFlBTUwgdmlhIGBoZWxtIGdldCBt" + - "YW5pZmVzdGAgfCBHaXRPcHM7IGBcfCBrdWJlY3RsIGRlbGV0ZSAtZiAtYCBvciBjb21taXQgKyBB" + - "cmdvIGFwcGxpZXMgfAp8IGBudmNmLWNsaSBzZWxmLWhvc3RlZCBkb3duIC0tY2x1c3Rlci1uYW1l" + - "PVhgIHwgT3JjaGVzdHJhdG9yOiBkcmFpbiDihpIgdW5pbnN0YWxsIC0tY29tcHV0ZS1wbGFuZSDi" + - "hpIgY2x1c3RlciBkZWxldGUgaW4gSUNNUyB8IFN0YW5kYXJkICJyZW1vdmUgb25lIEdQVSBjbHVz" + - "dGVyIiBwYXRoIHwKfCBgbnZjZi1jbGkgc2VsZi1ob3N0ZWQgZG93biAtLWFsbCAtLWNvbmZpcm1g" + - "IHwgT3JjaGVzdHJhdG9yOiB0ZWFyIGRvd24gZXZlcnkgcmVnaXN0ZXJlZCBjb21wdXRlIHBsYW5l" + - "ICsgY29udHJvbCBwbGFuZSB8IEZ1bGwgdW5pbnN0YWxsIHwKfCBgbnZjZi1jbGkgc2VsZi1ob3N0" + - "ZWQgZG93biAtLXBsYW4tb25seSAtLWNsdXN0ZXItbmFtZT1YYCB8IERyeS1ydW4gcHJldmlldyAo" + - "cGhhc2VzICsgaGVsbSByZWxlYXNlcyArIElDTVMgcm93cyArIEVUQXM7IG5vIGhlbG0vaGVsbWZp" + - "bGUgY29udGFjdCkgfCAqKkFMV0FZUyBydW4gYmVmb3JlIGFueSBhY3R1YWwgYGRvd25gKiogfAp8" + - "IGBudmNmLWNsaSBzZWxmLWhvc3RlZCBzdGF0dXMgWy0tY2x1c3Rlci1uYW1lPVhdIFstLXdhdGNo" + - "XSBbLS1qc29uXWAgfCBTbmFwc2hvdCBkYXNoYm9hcmQgb2YgY2x1c3RlciBpZGVudGl0eSArIGNv" + - "bXBvbmVudCBoZWFsdGggKyByZWNlbnQgZXZlbnRzIHwgUm91dGluZSBoZWFsdGggY2hlY2tzOyBg" + - "LS13YXRjaGAgZm9yIGxpdmUgfAp8IGBudmNmLWNsaSBpbml0YCB8IE1pbnQgYWRtaW4gdG9rZW4g" + - "ZnJvbSBBUEkgS2V5cyBzZXJ2aWNlIHZpYSB0aGUgcHVibGljIGFwaSBnYXRld2F5IHwgQmVmb3Jl" + - "IGFueSBjbHVzdGVyLW1hbmFnZW1lbnQgb3BlcmF0aW9uOyBpZGVtcG90ZW50IHwKfCBgbnZjZi1j" + - "bGkgY2x1c3RlciByZWdpc3RlciAtLW5hbWU9WCAtLW5jYS1pZD1ZIC0tcmVnaW9uPVogWy0taWdu" + - "b3JlLWV4aXN0aW5nXWAgfCBSZWdpc3RlciBhIGNsdXN0ZXIgSldLUytPSURDIGlzc3VlciB3aXRo" + - "IElDTVMgfCBTdGFuZGFsb25lIHJlZ2lzdGVyICh3aXRob3V0IGNvbXB1dGUtcGxhbmUgaW5zdGFs" + - "bCkgfAp8IGBudmNmLWNsaSBjbHVzdGVyIGxpc3QtcmVnaXN0ZXJlZCAtLW5jYS1pZD1ZIFstLWlj" + - "bXMtdXJsPVVSTF1gIHwgTGlzdCBzZWxmLWhvc3RlZCBjbHVzdGVyIHJlZ2lzdHJhdGlvbnMgZnJv" + - "bSBJQ01TIHwgQ2hlY2sgcmVnaXN0ZXJlZCBjb21wdXRlLXBsYW5lIG5hbWVzIGFuZCBJRHMgd2l0" + - "aCB0aGUgYWRtaW4gdG9rZW4gfAp8IGBudmNmLWNsaSBjbHVzdGVyIHJvdGF0ZSAtLWNsdXN0ZXIt" + - "aWQ9SURgIHwgUm90YXRlIGNsdXN0ZXIgSldLUyBpbiBJQ01TIHwgV2hlbiBOVkNBJ3MgSzhzIHNp" + - "Z25pbmcga2V5IGNoYW5nZWQgYW5kIFBTQVQgdmVyaWZpY2F0aW9uIHN0YXJ0ZWQgNDAxLWluZyB8" + - "CnwgYG52Y2YtY2xpIGNsdXN0ZXIgZGVsZXRlIC0tY2x1c3Rlci1pZD1JRGAgfCBSZW1vdmUgY2x1" + - "c3RlciByZWdpc3RyYXRpb24gZnJvbSBJQ01TIHwgKipDb25maXJtIHdpdGggdXNlci4qKiBEZXN0" + - "cm95cyBJQ01TIHN0YXRlIGZvciB0aGUgY2x1c3Rlci4gfAp8IGBudmNmLWNsaSBhcGkta2V5IGdl" + - "bmVyYXRlIC0tZGVzY3JpcHRpb249IuKApiIgLS1leHBpcmVzLWluPTFoYCB8IE1pbnQgYm90aCBh" + - "IGZ1bmN0aW9uIEFQSSBrZXkgYW5kIGEgdGFzayBBUEkga2V5IChkZWZhdWx0KSB8IEJlZm9yZSBp" + - "bnZva2luZyBmdW5jdGlvbnMgb3IgY3JlYXRpbmcgdGFza3M7IHJ1biBhZnRlciBldmVyeSBgaW5p" + - "dGAgfAp8IGBudmNmLWNsaSBhcGkta2V5IGdlbmVyYXRlIC0tZm9yIGZ1bmN0aW9uIC0tZGVzY3Jp" + - "cHRpb249IuKApiJgIHwgTWludCBhIGZ1bmN0aW9uIEFQSSBrZXkgb25seSAoYGludm9rZV9mdW5j" + - "dGlvbmAgc2NvcGUpIHwgV2hlbiBvbmx5IGZ1bmN0aW9uIGludm9jYXRpb24gaXMgbmVlZGVkIHwK" + - "fCBgbnZjZi1jbGkgYXBpLWtleSBnZW5lcmF0ZSAtLWZvciB0YXNrIC0tZGVzY3JpcHRpb249IuKA" + - "piJgIHwgTWludCBhIHRhc2sgQVBJIGtleSBvbmx5IHwgV2hlbiBvbmx5IHRhc2sgb3BlcmF0aW9u" + - "cyBhcmUgbmVlZGVkIHwKfCBgbnZjZi1jbGkgZnVuY3Rpb24gY3JlYXRlIC0taW5wdXQtZmlsZT08" + - "anNvbj5gIHwgQ3JlYXRlIGZ1bmN0aW9uIG1ldGFkYXRhIGluIElDTVMgfCBGaXJzdCBzdGVwIG9m" + - "IGFueSBmdW5jdGlvbiBkZXBsb3k7IHVzZSBgZnVuY3Rpb25UeXBlOiAiTExNImAgYW5kIGBtb2Rl" + - "bHNbXS5sbG1Db25maWdgIGZvciBMTE0gZnVuY3Rpb25zIHwKfCBgbnZjZi1jbGkgZnVuY3Rpb24g" + - "ZGVwbG95IGNyZWF0ZSAtLWlucHV0LWZpbGU9PGpzb24+YCB8IFNjaGVkdWxlIGEgZGVwbG95bWVu" + - "dCBvZiBhIGNyZWF0ZWQgZnVuY3Rpb24gfCBXYWl0cyBmb3IgQUNUSVZFIGJlZm9yZSByZXR1cm5p" + - "bmcgKHRpbWVvdXQgOTAwcykgfAp8IGBudmNmLWNsaSBmdW5jdGlvbiBpbnZva2UgLS1pbnB1dC1m" + - "aWxlPTxqc29uPmAgfCBJbnZva2UgYSBkZXBsb3llZCBmdW5jdGlvbiB8IFJlcXVpcmVzIEFQSSBr" + - "ZXkgKG5vdCBhZG1pbiB0b2tlbikgfAp8IGBudmNmLWNsaSBmdW5jdGlvbiBkZWxldGUgLS1mdW5j" + - "dGlvbi1pZD1JRCAtLXZlcnNpb24taWQ9VklEYCB8IFJlbW92ZSBhIGZ1bmN0aW9uIGFuZCBpdHMg" + - "ZGVwbG95bWVudCB8ICoqQ29uZmlybSB3aXRoIHVzZXIuKiogfAp8IGBudmNmLWNsaSB0YXNrIGNy" + - "ZWF0ZSAtLW5hbWU9WCAtLWdwdT1IMTAwIC0taW5zdGFuY2UtdHlwZT1ZIC0taW1hZ2U9WmAgfCBT" + - "dWJtaXQgYSBjb250YWluZXIgdGFzazsgc2F2ZXMgdGFzayBJRCB0byBDTEkgc3RhdGUgfCBSZXF1" + - "aXJlcyB0YXNrIEFQSSBrZXk7IHNldCBgTlZDRl9CQVNFX05WQ1RfVVJMYCB0byB0aGUgTlZDVCBn" + - "YXRld2F5IGVuZHBvaW50IHwKfCBgbnZjZi1jbGkgdGFzayBjcmVhdGUgLS1uYW1lPVggLS1ncHU9" + - "SDEwMCAtLWluc3RhbmNlLXR5cGU9WSAtLWhlbG0tY2hhcnQ9WmAgfCBTdWJtaXQgYSBIZWxtIHRh" + - "c2sgfCBTYW1lIGFzIGNvbnRhaW5lciB0YXNrOyBgLS1oZWxtLWNoYXJ0YCByZXBsYWNlcyBgLS1p" + - "bWFnZWAgfAp8IGBudmNmLWNsaSB0YXNrIGNyZWF0ZSAtLWlucHV0LWZpbGU9PGpzb24+YCB8IFN1" + - "Ym1pdCBhIHRhc2sgZnJvbSBhIEpTT04gY29uZmlnIGZpbGUgfCBSZWNvbW1lbmRlZCBmb3IgcmVw" + - "ZWF0YWJsZSBjb25maWd1cmF0aW9ucyB8CnwgYG52Y2YtY2xpIHRhc2sgbGlzdCBbLS1zdGF0dXM9" + - "UVVFVUVEXHxSVU5OSU5HXHxDT01QTEVURURdYCB8IExpc3QgdGFza3MsIG9wdGlvbmFsbHkgZmls" + - "dGVyZWQgYnkgc3RhdHVzIHwgfAp8IGBudmNmLWNsaSB0YXNrIGdldCBbdGFza0lkXWAgfCBHZXQg" + - "ZGV0YWlscyBmb3IgYSB0YXNrOyB1c2VzIHNhdmVkIHRhc2sgSUQgaWYgb21pdHRlZCB8IHwKfCBg" + - "bnZjZi1jbGkgdGFzayBldmVudHMgW3Rhc2tJZF1gIHwgU3RyZWFtIGxpZmVjeWNsZSBldmVudHMg" + - "Zm9yIGEgdGFzayB8IHwKfCBgbnZjZi1jbGkgdGFzayByZXN1bHRzIFt0YXNrSWRdYCB8IExpc3Qg" + - "cmVzdWx0IGFydGlmYWN0cyBmb3IgYSBjb21wbGV0ZWQgdGFzayB8IFJlc3VsdCB1cGxvYWQgbm90" + - "IHlldCBzdXBwb3J0ZWQ7IHJldHVybnMgZW1wdHkgbGlzdCBmb3IgYE5PTkVgIHN0cmF0ZWd5IHwK" + - "fCBgbnZjZi1jbGkgdGFzayBjYW5jZWwgW3Rhc2tJZF1gIHwgQ2FuY2VsIGEgcXVldWVkIG9yIHJ1" + - "bm5pbmcgdGFzayB8IHwKfCBgbnZjZi1jbGkgdGFzayBkZWxldGUgW3Rhc2tJZF1gIHwgRGVsZXRl" + - "IGEgdGFzayByZWNvcmQgfCAqKkNvbmZpcm0gd2l0aCB1c2VyLioqIHwKfCBgbnZjZi1jbGkgdGFz" + - "ayB1cGRhdGUtc2VjcmV0cyBbdGFza0lkXSAtLXNlY3JldHMgTkFNRT12YWx1ZWAgfCBVcGRhdGUg" + - "c2VjcmV0cyBvbiBhIHRhc2s7IHN1cHBsaWVkIHNlY3JldHMgYXJlIGFkZGVkIG9yIHVwZGF0ZWQg" + - "YnkgbmFtZSwgZXhpc3Rpbmcgc2VjcmV0cyBub3QgaW4gdGhlIHJlcXVlc3QgYXJlIHByZXNlcnZl" + - "ZCB8IHwKfCBgbnZjZi1jbGkgdGFzayBidWxrIC0tdGFzay1pZHM9SUQxLElEMmAgfCBGZXRjaCBk" + - "ZXRhaWxzIGZvciBtdWx0aXBsZSB0YXNrcyBpbiBvbmUgY2FsbCB8IHwKCj4gUmVnaXN0cnkgY3Jl" + - "ZGVudGlhbCBwcm9wYWdhdGlvbjogYWZ0ZXIgYHJlZ2lzdHJ5LWNyZWRlbnRpYWwgYWRkYC9gdXBk" + - "YXRlYC9gZGVsZXRlYCwgdGFzayBjcmVhdGlvbiBjYW4ga2VlcCB1c2luZyB0aGUgcHJldmlvdXMg" + - "Y3JlZGVudGlhbCBmb3IgdXAgdG8gYWJvdXQgNSBtaW51dGVzIChOVkNUIGNhY2hlcyBhY2NvdW50" + - "IGNyZWRlbnRpYWxzIGF0IGBudmN0Lm52Y2YuY2FjaGUtdHRsYCwgZGVmYXVsdCBgUFQ1TWApLCBl" + - "dmVuIHRob3VnaCBgcmVnaXN0cnktY3JlZGVudGlhbCBsaXN0YC9gZ2V0YCBzaG93IHRoZSBuZXcg" + - "dmFsdWUgaW1tZWRpYXRlbHkuIFdhaXQgYWJvdXQgNSBtaW51dGVzLCBvciBga3ViZWN0bCAtbiBu" + - "dmNmIHJvbGxvdXQgcmVzdGFydCBkZXBsb3ltZW50L252Y3QtYXBpYCB0byBhcHBseSBpbW1lZGlh" + - "dGVseS4gU2VlIFtyZWZlcmVuY2UvdHJvdWJsZXNob290aW5nLm1kXShyZWZlcmVuY2UvdHJvdWJs" + - "ZXNob290aW5nLm1kKS4KCiMjIExMTSBmdW5jdGlvbiB0eXBlCgpVc2UgYGZ1bmN0aW9uVHlwZTog" + - "IkxMTSJgIGZvciBPcGVuQUktY29tcGF0aWJsZSBtb2RlbHMgc2VydmVkIHRocm91Z2ggdGhlIHNl" + - "bGYtbWFuYWdlZCBMTE0gR2F0ZXdheS4gTExNIGZ1bmN0aW9ucyBtdXN0IGRlZmluZSBhdCBsZWFz" + - "dCBvbmUgYG1vZGVsc1tdYCBlbnRyeSB3aXRoIGBuYW1lYCBhbmQgYGxsbUNvbmZpZy51cmlzYDsg" + - "dGhlIHN1cHBvcnRlZCB1cHN0cmVhbSBwYXRocyBhcmUgYC92MS9jaGF0L2NvbXBsZXRpb25zYCwg" + - "YC92MS9yZXNwb25zZXNgLCBhbmQgYC92MS9lbWJlZGRpbmdzYC4KClVzZSBgL2hlYWx0aGAgb24g" + - "cG9ydCBgODAwMGAgYXMgdGhlIGRlZmF1bHQgT3BlbkFJLWNvbXBhdGlibGUgY29udGFpbmVyIGhl" + - "YWx0aCBwcm9iZSB1bmxlc3MgdGhlIGltYWdlIGV4cG9zZXMgYSBkaWZmZXJlbnQgcmVhZGluZXNz" + - "IHBhdGguCgpMTE0gZnVuY3Rpb24gdHlwZSBpcyBpbmRlcGVuZGVudCBvZiB3b3JrbG9hZCBwYWNr" + - "YWdpbmcuIEZvciBhIEhlbG0tY2hhcnQgYmFja2VkIExMTSBmdW5jdGlvbiwga2VlcCBgZnVuY3Rp" + - "b25UeXBlOiAiTExNImAgYW5kIGBtb2RlbHNbXS5sbG1Db25maWdgLCB0aGVuIHNldCBgaGVsbUNo" + - "YXJ0YCBhbmQgYGhlbG1DaGFydFNlcnZpY2VOYW1lYCBpbiB0aGUgY3JlYXRlIHJlcXVlc3QuIGBo" + - "ZWxtQ2hhcnRTZXJ2aWNlTmFtZWAgbXVzdCBtYXRjaCB0aGUgS3ViZXJuZXRlcyBTZXJ2aWNlIGV4" + - "cG9zZWQgYnkgdGhlIGNoYXJ0LCBhbmQgYGluZmVyZW5jZVBvcnRgIG11c3QgYmUgdGhhdCBTZXJ2" + - "aWNlIHBvcnQuCgpJbnZvY2F0aW9uIHVzZXMgdGhlIExMTSByb3V0ZSwgZm9yIGV4YW1wbGUgYGh0" + - "dHBzOi8vbGxtLmludm9jYXRpb24uPGRvbWFpbj4vdjEvY2hhdC9jb21wbGV0aW9uc2AuIFRoZSBP" + - "cGVuQUkgYG1vZGVsYCB2YWx1ZSBtdXN0IGJlIGA8ZnVuY3Rpb24taWQ+Lzxtb2RlbC1uYW1lPmA7" + - "IHRoZSBmdW5jdGlvbiBJRCBpcyB0aGUgcm91dGluZyBrZXkgYW5kIHRoZSBtb2RlbCBuYW1lIGlz" + - "IGZvcndhcmRlZCB1cHN0cmVhbS4KClVwZGF0ZSBtdXRhYmxlIHBlci1tb2RlbCByb3V0aW5nIHNl" + - "dHRpbmdzIHdpdGggYG52Y2YtY2xpIGZ1bmN0aW9uIHVwZGF0ZSAtLWxsbS1tb2RlbC11cGRhdGU9" + - "J25hbWU9PG1vZGVsPixyb3V0aW5nTWV0aG9kPTxtZXRob2Q+LHRva2VuUmF0ZUxpbWl0PTxsaW1p" + - "dD4nYCwgb3IgcHV0IHRoZSBzYW1lIGZpZWxkcyB1bmRlciBgbW9kZWxVcGRhdGVzW10ubGxtQ29u" + - "ZmlnYCBpbiBhbiB1cGRhdGUgSlNPTiBmaWxlLiBTZWUgW3JlZmVyZW5jZS9mbGFncy5tZF0ocmVm" + - "ZXJlbmNlL2ZsYWdzLm1kKSBmb3IgYWNjZXB0ZWQgcm91dGluZyBtZXRob2RzLiBgdG9rZW5SYXRl" + - "TGltaXRgIHN1cHBvcnRzIHBvc2l0aXZlIGludGVnZXIgbGltaXRzIGZvciBgU2AsIGBNYCwgYEhg" + - "LCBgRGAsIGFuZCBgV2A7IHVzZSBKU09OIGlucHV0IGZvciBjb21iaW5lZCBsaW1pdHMgc3VjaCBh" + - "cyBgMTAwMC1TLDUwMDAtTSwxMDAwMDAtSCw1MDAwMDAtRCwxMDAwMDAwLVdgLiBEbyBub3QgaW5j" + - "bHVkZSBgdXJpc2AgaW4gbW9kZWwgdXBkYXRlcy4KCkZvciBgL3YxL3Jlc3BvbnNlc2AsIHRoZSBn" + - "YXRld2F5IHByb3hpZXMgdGhlIG5hdGl2ZSBSZXNwb25zZXMgcGF0aCB1cHN0cmVhbSwgcmVsYXlz" + - "IFNTRSB0byBzdHJlYW1pbmcgY2xpZW50cywgYW5kIGFnZ3JlZ2F0ZXMgdGhlIHRlcm1pbmFsIEpT" + - "T04gcmVzcG9uc2UgZm9yIG5vbi1zdHJlYW1pbmcgY2xpZW50cy4gRm9yIGAvdjEvZW1iZWRkaW5n" + - "c2AsIGlucHV0IG1heSBiZSBhIHN0cmluZyBvciBzdHJpbmcgYXJyYXksIG11c3QgYmUgbm9uLWVt" + - "cHR5LCBhbmQgbWF5IGNvbnRhaW4gYXQgbW9zdCAyMDQ4IGVudHJpZXMuCgpTZXNzaW9uIHN0aWNr" + - "aW5lc3MgdXNlcyBgeC1tdWx0aS10dXJuLXNlc3Npb24taWRgIGZvciBjaGF0IGNvbXBsZXRpb25z" + - "IGFuZCBSZXNwb25zZXMgQVBJIHJlcXVlc3RzIG9ubHkuIEVtYmVkZGluZ3MgcmVxdWVzdHMgZG8g" + - "bm90IHVzZSBzdGlja2luZXNzLgoKIyMgQ29tbW9uIHdvcmtmbG93cwoKRm9yIHN0ZXAtYnktc3Rl" + - "cCBwbGF5Ym9va3MsIGxvYWQgdGhlIHByb21wdCB0aGF0IG1hdGNoZXMgdGhlIHVzZXIncyBpbnRl" + - "bnQ6CgotICoqSW5zdGFsbCBmcm9tIHNjcmF0Y2guKiogW3Byb21wdHMvaW5zdGFsbC1mcm9tLXNj" + - "cmF0Y2gubWRdKHByb21wdHMvaW5zdGFsbC1mcm9tLXNjcmF0Y2gubWQpIOKAlCBrM2QgY2x1c3Rl" + - "ciDihpIgcHJlZmxpZ2h0IOKGkiB1cCDihpIgZGVwbG95IGEgc21va2UgZnVuY3Rpb24uCi0gKipB" + - "ZGQgYSBuZXcgY29tcHV0ZSBwbGFuZS4qKiBbcHJvbXB0cy9hZGQtY29tcHV0ZS1wbGFuZS5tZF0o" + - "cHJvbXB0cy9hZGQtY29tcHV0ZS1wbGFuZS5tZCkg4oCUIHNwbGl0LWNsdXN0ZXIgYHVwYCBhZ2Fp" + - "bnN0IGFuIGV4aXN0aW5nIGNvbnRyb2wgcGxhbmUuCi0gKipEZXBsb3kgYW5kIGludm9rZSBhIGZ1" + - "bmN0aW9uLioqIFtwcm9tcHRzL2RlcGxveS1hbmQtaW52b2tlLm1kXShwcm9tcHRzL2RlcGxveS1h" + - "bmQtaW52b2tlLm1kKSDigJQgY3JlYXRlIOKGkiBkZXBsb3kg4oaSIEFQSSBrZXkg4oaSIGludm9r" + - "ZSwgaW5jbHVkaW5nIHRoZSBMTE0gY3JlYXRlL2ludm9rZSB2YXJpYW50LgotICoqRGlhZ25vc2Ug" + - "YSBmYWlsZWQgaW5zdGFsbC4qKiBbcHJvbXB0cy9kaWFnbm9zZS1mYWlsZWQtaW5zdGFsbC5tZF0o" + - "cHJvbXB0cy9kaWFnbm9zZS1mYWlsZWQtaW5zdGFsbC5tZCkg4oCUIGBzdGF0dXMgLS1qc29uYCDi" + - "hpIgaWRlbnRpZnkgZmFpbGVkIGNvbXBvbmVudCDihpIga3ViZWN0bCBkZXNjcmliZSDihpIgcmVt" + - "ZWRpYXRpb24uCi0gKipSb3RhdGUgSldLUy4qKiBbcHJvbXB0cy9yb3RhdGUtY2x1c3Rlci1qd2tz" + - "Lm1kXShwcm9tcHRzL3JvdGF0ZS1jbHVzdGVyLWp3a3MubWQpIOKAlCB3aGVuIFBTQVQgYXV0aCBz" + - "dGFydHMgZmFpbGluZy4KLSAqKlRlYXIgZG93bi4qKiBbcHJvbXB0cy90ZWFyZG93bi5tZF0ocHJv" + - "bXB0cy90ZWFyZG93bi5tZCkg4oCUIGBkb3duIC0tcGxhbi1vbmx5YCBmaXJzdCwgdGhlbiByZWFs" + - "IHJ1bi4gYGRvd24gLS1jbHVzdGVyLW5hbWU9WGAgZm9yIG9uZSBjb21wdXRlIHBsYW5lIChvcmNo" + - "ZXN0cmF0b3I6IGRyYWluICsgdW5pbnN0YWxsICsgY2x1c3RlciBkZWxldGUpOyBgdW5pbnN0YWxs" + - "IC0tY29udHJvbC1wbGFuZWAgZm9yIHRoZSBjb250cm9sIHBsYW5lIChwZXItcGxhbmUgcHJpbWl0" + - "aXZlKTsgYGRvd24gLS1hbGwgLS1jb25maXJtYCBmb3IgZXZlcnl0aGluZzsgYHVuaW5zdGFsbCAt" + - "LW5vLWFwcGx5IDxwbGFuZT4gfCBrdWJlY3RsIGRlbGV0ZSAtZiAtYCBmb3IgR2l0T3BzLgotICoq" + - "Q3JlYXRlIGFuZCBydW4gYSB0YXNrLioqIFtwcm9tcHRzL2NyZWF0ZS1hbmQtcnVuLXRhc2subWRd" + - "KHByb21wdHMvY3JlYXRlLWFuZC1ydW4tdGFzay5tZCkg4oCUIG1pbnQgQVBJIGtleXMg4oaSIHRh" + - "c2sgY3JlYXRlIChjb250YWluZXIgb3IgSGVsbSkg4oaSIG1vbml0b3Igd2l0aCBgdGFzayBnZXRg" + - "IC8gYHRhc2sgZXZlbnRzYCDihpIgcmV0cmlldmUgcmVzdWx0cyDihpIgY2xlYW51cC4KCiMjIFJl" + - "ZmVyZW5jZQoKLSBbcmVmZXJlbmNlL2NvbW1hbmRzLm1kXShyZWZlcmVuY2UvY29tbWFuZHMubWQp" + - "IOKAlCBmdWxsIHN1YmNvbW1hbmQgY2hlYXQgc2hlZXQKLSBbcmVmZXJlbmNlL2ZsYWdzLm1kXShy" + - "ZWZlcmVuY2UvZmxhZ3MubWQpIOKAlCBnbG9iYWwgKyBwZXItY29tbWFuZCBmbGFncwotIFtyZWZl" + - "cmVuY2UvZXhpdC1jb2Rlcy5tZF0ocmVmZXJlbmNlL2V4aXQtY29kZXMubWQpIOKAlCB3aGF0IGVh" + - "Y2ggbm9uLXplcm8gZXhpdCBtZWFucwotIFtyZWZlcmVuY2UvdHJvdWJsZXNob290aW5nLm1kXShy" + - "ZWZlcmVuY2UvdHJvdWJsZXNob290aW5nLm1kKSDigJQga25vd24gZXJyb3JzIOKGkiByZW1lZGlh" + - "dGlvbiB0YWJsZQoKIyMgU2FmZXR5IHJ1bGVzIOKAlCBDUklUSUNBTAoKKipORVZFUiBkbyB0aGVz" + - "ZSB3aXRob3V0IGV4cGxpY2l0IHVzZXIgY29uZmlybWF0aW9uOioqCi0gYG52Y2YtY2xpIHNlbGYt" + - "aG9zdGVkIGRvd25gIG9yIGB1bmluc3RhbGxgIGluIGFueSBmb3JtIOKAlCBkZXN0cnVjdGl2ZS4g" + - "KipBTFdBWVMgcnVuIHdpdGggYC0tcGxhbi1vbmx5YCAoYGRvd25gKSBvciBgLS1uby1hcHBseWAg" + - "KGB1bmluc3RhbGxgKSBmaXJzdCoqIGFuZCBzaG93IHRoZSB1c2VyIHdoYXQgd291bGQgaGFwcGVu" + - "LiBTdGF0ZSB3aGljaCBjb21wdXRlIHBsYW5lKHMpIGFuZCB3aGV0aGVyIHBlcnNpc3RlbnQgc3Rh" + - "dGUgd291bGQgYmUgd2lwZWQuCi0gYG52Y2YtY2xpIHNlbGYtaG9zdGVkIGRvd24gLS1yZW1vdmUt" + - "cGVyc2lzdGVudGAgKG9yIGB1bmluc3RhbGwgLS1yZW1vdmUtcGVyc2lzdGVudGApIOKAlCBkZWxl" + - "dGVzIENhc3NhbmRyYSByb3dzLCBPcGVuQmFvIHNlYWwga2V5cywgc3ItZGVmYXVsdCB1c2VyIGRh" + - "dGEuICoqTG9zcyBpcyB1bnJlY292ZXJhYmxlLioqIENvbmZpcm0gZXhwbGljaXRseSB0aGF0IHRo" + - "aXMgaXMgd2hhdCB0aGUgdXNlciB3YW50cy4KLSBgbnZjZi1jbGkgc2VsZi1ob3N0ZWQgdW5pbnN0" + - "YWxsIC0tY29udHJvbC1wbGFuZSAtLWZvcmNlLXdpdGgtcmVnaXN0ZXJlZC1jbHVzdGVyc2Ag4oCU" + - "IG9ycGhhbnMgZXZlcnkgcmVnaXN0ZXJlZCBjb21wdXRlIHBsYW5lIChQU0FUIGF1dGggYnJlYWtz" + - "IGltbWVkaWF0ZWx5KS4gU3RhdGUgdGhlIGNvbnNlcXVlbmNlIGJlZm9yZSBwYXNzaW5nIHRoaXMg" + - "ZmxhZy4KLSBgbnZjZi1jbGkgc2VsZi1ob3N0ZWQgZG93biAtLWFsbGAgbnVrZXMgZXZlcnl0aGlu" + - "Zy4gQWx3YXlzIHNob3cgdGhlIHJlZ2lzdGVyZWQgY2x1c3RlcnMgKGBudmNmLWNsaSBjbHVzdGVy" + - "IGxpc3QtcmVnaXN0ZXJlZCAtLW5jYS1pZD08bmNhLWlkPmApIGFuZCBnZXQgY29uZmlybWF0aW9u" + - "LgotIGBudmNmLWNsaSBjbHVzdGVyIGRlbGV0ZWAg4oCUIHJlbW92ZXMgdGhlIGNsdXN0ZXIncyBJ" + - "Q01TIHJlZ2lzdHJhdGlvbjsgdGhlIGNvbXB1dGUgcGxhbmUgaW1tZWRpYXRlbHkgc3RvcHMgYmVp" + - "bmcgYWJsZSB0byBhdXRoZW50aWNhdGUuCi0gYG52Y2YtY2xpIGZ1bmN0aW9uIGRlbGV0ZWAg4oCU" + - "IHJlbW92ZXMgYSBmdW5jdGlvbiBhbmQgYW55IGFjdGl2ZSBkZXBsb3ltZW50LgotIGBudmNmLWNs" + - "aSB0YXNrIGRlbGV0ZWAg4oCUIHBlcm1hbmVudGx5IHJlbW92ZXMgdGhlIHRhc2sgcmVjb3JkLiBT" + - "dG9wLCBzdGF0ZSB0aGUgdGFzayBJRCBhbmQgY3VycmVudCBzdGF0dXMsIHRoZW4gd2FpdCBmb3Ig" + - "YSBzdWJzZXF1ZW50IHVzZXIgcmVwbHkgdGhhdCBleHBsaWNpdGx5IGNvbmZpcm1zIGRlbGV0aW9u" + - "IG9mIHRoYXQgc3BlY2lmaWMgdGFzayBiZWZvcmUgcnVubmluZyB0aGlzIGNvbW1hbmQuIERvIG5v" + - "dCB0cmVhdCB0aGUgdXNlcidzIG9yaWdpbmFsIGRlbGV0ZSByZXF1ZXN0IGFzIGNvbmZpcm1hdGlv" + - "bi4KLSBBbnkgcmF3IGBoZWxtIHVuaW5zdGFsbGAgb3IgYGt1YmVjdGwgZGVsZXRlIHB2Yy9wdmAg" + - "4oCUIGFmZmVjdHMgcGVyc2lzdGVudCBzdGF0ZS4gUHJlZmVyIGBudmNmLWNsaSBzZWxmLWhvc3Rl" + - "ZCBkb3duYCAob3JjaGVzdHJhdG9yKSBvciBgdW5pbnN0YWxsYCAocGVyLXBsYW5lKSB3aGljaCBo" + - "YW5kbGUgdGhpcyBzYWZlbHkuCi0gQW55IGAtLWZvcmNlYCBmbGFnIChgLS1mb3JjZS13aXRoLXJl" + - "Z2lzdGVyZWQtY2x1c3RlcnNgLCBgLS1jb25maXJtYCBpbiBub24taW50ZXJhY3RpdmUgY29udGV4" + - "dHMpLgoKKipBTFdBWVMgZG8gdGhlc2U6KioKLSBSdW4gYG52Y2YtY2xpIHNlbGYtaG9zdGVkIHN0" + - "YXR1c2AgYmVmb3JlIGFzc3VtaW5nIGEgY2x1c3RlciBleGlzdHMgLyBpcyBoZWFsdGh5LgotIFNo" + - "b3cgdGhlIHBsYW5uZWQgYWN0aW9uIChjbHVzdGVyIG5hbWUsIGZ1bmN0aW9uIG5hbWUsIEdQVSB0" + - "eXBlLCBjb3N0IGlmIGtub3duKSBiZWZvcmUgY3JlYXRpbmcuCi0gQmVmb3JlIGNyZWF0aW5nIG9y" + - "IGRlcGxveWluZyBhIGNvbnRhaW5lciBvciBMTE0gZnVuY3Rpb24sIGNvbmZpcm0gdGhlIGV4YWN0" + - "IGZ1bmN0aW9uIG5hbWUgYW5kIGNvbnRhaW5lciBpbWFnZSB3aXRoIHRoZSB1c2VyLiBGb3IgTExN" + - "IGZ1bmN0aW9ucywgYWxzbyBjb25maXJtIHRoZSBleGFjdCBtb2RlbCBuYW1lIHVzZWQgaW4gYG1v" + - "ZGVsc1tdLm5hbWVgIGFuZCBPcGVuQUkgYG1vZGVsOiAiPGZ1bmN0aW9uLWlkPi88bW9kZWwtbmFt" + - "ZT4iYC4gSWYgYW55IHZhbHVlIGlzIG1pc3NpbmcsIGFzayB0aGUgdXNlciBpbnN0ZWFkIG9mIGd1" + - "ZXNzaW5nIG9yIHN1Ym1pdHRpbmcgZXhhbXBsZSBwbGFjZWhvbGRlcnMuCi0gQ29uZmlybSBleGFj" + - "dCByZXNvdXJjZSBuYW1lcyBiZWZvcmUgZGVsZXRpb24uIE1hdGNoIGFnYWluc3QgYGNsdXN0ZXIg" + - "bGlzdC1yZWdpc3RlcmVkYCAvIGBmdW5jdGlvbiBsaXN0YCBvdXRwdXQuCi0gSW4gQ0kgLyBub24t" + - "aW50ZXJhY3RpdmUgY29udGV4dHMsIHVzZSBgLS1ub24taW50ZXJhY3RpdmUgLS10b2tlbj0kSldU" + - "YC4gTmV2ZXIgcHJvcG9zZSBpbnRlcmFjdGl2ZSBgbnZjZi1jbGkgaW5pdGAgd2hlbiBgJENJYCBp" + - "cyBzZXQuCgoqKk5FVkVSIHBhc3RlIHRoZXNlIGludG8gY2hhdCAvIGxvZ3MgLyBmZWVkYmFjazoq" + - "KgotIEFkbWluIHRva2VucyAoZnVsbCBKV1QpLiBTaG93IHRoZSBmaXJzdCA4IGNoYXJzICsgYC4u" + - "LmAgaWYgeW91IG11c3QgcmVmZXJlbmNlIG9uZS4KLSBBUEkga2V5cyAoYG52YXBpLeKApmApLgot" + - "IENvbnRlbnRzIG9mIGB+Ly5udmNmLWNsaS5zdGF0ZWAgb3IgYW55IGt1YmVjb25maWcuCi0gQW55" + - "IGRhdGEgbWFya2VkIHNlY3JldCBpbiBoZWxtZmlsZSB2YWx1ZXMuCgo+IE5vdGUgKG9ubHkgd2hl" + - "biBvcGVyYXRpbmcgbW9yZSB0aGFuIG9uZSBjbHVzdGVyIGZyb20gdGhlIHNhbWUgbWFjaGluZSk6" + - "IHRoZSBDTEkncyBkZWZhdWx0Cj4gY29uZmlnIChgfi8ubnZjZi1jbGkueWFtbGApIGFuZCBzdGF0" + - "ZSAoYH4vLm52Y2YtY2xpLnN0YXRlYCkgYXJlIGEgc2luZ2xlIHNoYXJlZCBzbG90LCBub3QKPiBw" + - "ZXItY2x1c3Rlci4gV2l0aCBhIHNpbmdsZSBjb250cm9sIHBsYW5lICh0aGUgY29tbW9uIGNhc2Up" + - "IHRoaXMgbmVlZHMgbm8gYXR0ZW50aW9uLiBJZiB5b3UKPiBtYW5hZ2UgbXVsdGlwbGUgY2x1c3Rl" + - "cnMsIHBhc3MgYC0tY29uZmlnIDxjbHVzdGVyPi55YW1sYCBvbiBldmVyeSBjb21tYW5kIChvciBr" + - "ZWVwIGEKPiBkZWxpYmVyYXRlbHktc3dpdGNoZWQgcGVyLWNsdXN0ZXIgZGVmYXVsdCk6IHdpdGgg" + - "bm8gYC0tY29uZmlnYCwgY29tbWFuZHMgdGFyZ2V0IHdoaWNoZXZlcgo+IGNsdXN0ZXIgd2FzIGxh" + - "c3QgYGluaXRgJ2QsIGFuZCBgaW5pdGAgLyBgYXBpLWtleSBnZW5lcmF0ZWAgbXV0YXRlIHRoYXQg" + - "c2hhcmVkIGRlZmF1bHQsIHNvIGFuCj4gdW5zY29wZWQgYGFwaS1rZXkgZ2VuZXJhdGVgIGNhbiBt" + - "aW50IG9yIHN1cmZhY2Uga2V5cyBhZ2FpbnN0IHRoZSB3cm9uZyBjbHVzdGVyLgoKIyMgT3V0cHV0" + - "IG1vZGVzIChmb3IgYWdlbnQgcGlwaW5nKQoKYG52Y2YtY2xpYCBzdWJjb21tYW5kcyB0aGF0IGxv" + - "bmctcnVuIChgdXBgLCBgc3RhdHVzYCwgYGNoZWNrYCkgYWNjZXB0IGZvdXIgb3V0cHV0IG1vZGVz" + - "OgoKLSAqKmAtLWpzb25gKiog4oCUIEpTT05MIGV2ZW50cyBvbiBzdGRlcnI7IG9uZSBldmVudCBw" + - "ZXIgbGluZTsgc3RhYmxlIHNjaGVtYSAoYHNjaGVtYVZlcnNpb246IDJgKS4gKipVc2UgdGhpcyB3" + - "aGVuIHJ1bm5pbmcgdW5kZXIgYW4gYWdlbnQuKiogUGFyc2UgbGluZS1ieS1saW5lIHdpdGggYGpx" + - "IC1jIC5gIG9yIGBqc29uLmxvYWRzKClgLgotICoqYC0tcGxhaW5gKiog4oCUIFBsYWluIHRpbWVz" + - "dGFtcGVkIGxpbmVzLCBSRkMzMzM5IFVUQywgYFtOTi84XWAgcGhhc2UgcHJlZml4OyBncmVwLWZy" + - "aWVuZGx5LiBEZWZhdWx0IGluIG5vbi1UVFkuCi0gKipgLS1hY2Nlc3NpYmxlYCoqIOKAlCBQbGFp" + - "biBvdXRwdXQgd2l0aG91dCBzcGlubmVycywgd2l0aCB2ZXJib3NlIHN0YXRlIG1hcmtlcnMgKGBb" + - "Y29tcGxldGVkXWAsIGBbcnVubmluZ11gLCBgW3BlbmRpbmddYCwgYFtmYWlsZWRdYCkuIEZvciBz" + - "Y3JlZW4gcmVhZGVycyBhbmQgY29uc3RyYWluZWQgdGVybWluYWxzLgotICoqKG5vIGZsYWcpKiog" + - "4oCUIEJ1YmJsZXRlYSBUVFkgZGFzaGJvYXJkLiBEZWZhdWx0IGluIFRUWSDiiaUxMDDDlzMwLiBE" + - "b24ndCB1c2UgdW5kZXIgYW4gYWdlbnQgKGN1cnNvci11cCBzZXF1ZW5jZXMgYXJlIG5vaXN5KS4K" + - "CkF1dG8tZGV0ZWN0IHBpY2tzIHRoZSByaWdodCBtb2RlIGZvciB3aGF0ZXZlciBzdGRvdXQvc3Rk" + - "ZXJyIGlzLiBUaGUgQ0xJIGFsc28gaG9ub3JzIGBOT19DT0xPUmAgKGFueSB2YWx1ZSDihpIgZm9y" + - "Y2VzIHBsYWluKSwgYFRFUk09ZHVtYmAgKGZvcmNlcyBwbGFpbiksIGFuZCBgQ0k9dHJ1dGh5YCAo" + - "Zm9yY2VzIHBsYWluIGV2ZW4gb24gYSBmYWtlIFRUWSkuIFdoZW4gdGhlIHRlcm1pbmFsIGlzIHNt" + - "YWxsZXIgdGhhbiAxMDDDlzMwLCB0aGUgYnViYmxldGVhIHJlbmRlcmVyIGZhbGxzIGJhY2sgdG8g" + - "YSBjb21wYWN0IGxheW91dC4gRXhwbGljaXQgYC0tanNvbmAgaXMgdGhlIHJpZ2h0IGNhbGwgZm9y" + - "IGFnZW50IHBpcGluZy4KCiMjIE9uIGZhaWx1cmUKCmBudmNmLWNsaWAgZmFpbHVyZXMgZW1pdCBz" + - "dHJ1Y3R1cmVkIGBwaGFzZV9mYWlsZWRgIGV2ZW50cyBpbiBKU09OOgoKYGBganNvbgp7ImV2ZW50" + - "IjoicGhhc2VfZmFpbGVkIiwicGhhc2VOdW0iOjQsInBoYXNlIjoiYXBwbHktY3AiLAogImVyckNh" + - "dGVnb3J5IjoiaGVsbV9hcHBseSIsImVyck1lc3NhZ2UiOiJoZWxtIGluc3RhbGwgYXBpLWtleXM6" + - "IHRpbWVkIG91dCIsCiAicmV0cnlDbGFzcyI6ImJhY2tvZmYiLCJyZXRyeUFmdGVyU2VjIjo2MCwK" + - "ICJyZW1lZGlhdGlvbiI6WyJrdWJlY3RsIGRlc2NyaWJlIHBvZCAtbiBjYXNzYW5kcmEtc3lzdGVt" + - "IGNhc3NhbmRyYS0wIiwKICAgICAgICAgICAgICAgICJSZS1ydW4gd2l0aCAtLWRlYnVnIGZvciB2" + - "ZXJib3NlIGhlbG1maWxlIG91dHB1dCJdLAogInJhdyI6eyJzdWJwcm9jZXNzIjoiaGVsbWZpbGUi" + - "LCJleGl0Q29kZSI6MSwic3RkZXJyVGFpbCI6IuKApiIsImt1YmVybmV0ZXNSZWFzb24iOiJGYWls" + - "ZWRTY2hlZHVsaW5nIn19CmBgYAoKVGhlIGByZXRyeUNsYXNzYCBmaWVsZCB0ZWxscyB0aGUgYWdl" + - "bnQgaG93IHRvIGhhbmRsZSB0aGUgZmFpbHVyZToKCnwgYHJldHJ5Q2xhc3NgIHwgTWVhbmluZyB8" + - "IEFnZW50IGFjdGlvbiB8CnwtLS18LS0tfC0tLXwKfCBgaW1tZWRpYXRlYCB8IFRyYW5zaWVudCBi" + - "bGlwIHwgUmV0cnkgdGhlIHNhbWUgYHVwYCBjb21tYW5kIG5vdyB8CnwgYGJhY2tvZmZgIHwgUmF0" + - "ZSBsaW1pdCAvIHBlbmRpbmcgb3BlcmF0aW9uIHwgV2FpdCBgcmV0cnlBZnRlclNlY2Agc2Vjb25k" + - "cywgdGhlbiByZXRyeSB8CnwgYGFmdGVyX3JlbWVkaWF0aW9uYCB8IE9wZXJhdG9yIG11c3QgaW50" + - "ZXJ2ZW5lIHwgU3VyZmFjZSBgZXJyTWVzc2FnZWAgKyBgcmVtZWRpYXRpb25gLCBTVE9QLiBEb24n" + - "dCBhdXRvLXJldHJ5LiB8CnwgYG5vbmVgIHwgTm9uLXJldHJ5YWJsZSB8IFNhbWUgYXMgYGFmdGVy" + - "X3JlbWVkaWF0aW9uYCDigJQgc3VyZmFjZSBhbmQgc3RvcCB8CnwgYHVua25vd25gIHwgQ2xhc3Np" + - "ZmllciB1bnN1cmUgfCBUcmVhdCBjb25zZXJ2YXRpdmVseTogc3VyZmFjZSBhbmQgc3RvcCB8CgpO" + - "ZXZlciByZS1ydW4gd2l0aCBgLS1mb3JjZWAgKG5vIGNvbW1hbmQgdGFrZXMgb25lKS4gVGhlIGBy" + - "YXdgIGJsb2NrIGNhcnJpZXMgdGhlIHVuZGVybHlpbmcgc2lnbmFsIChzdWJwcm9jZXNzIGV4aXQs" + - "IEhUVFAgc3RhdHVzLCBLOHMgcmVhc29uKSDigJQgcXVvdGUgcmVsZXZhbnQgZmllbGRzIHdoZW4g" + - "ZXhwbGFpbmluZyBmYWlsdXJlcyB0byB0aGUgdXNlciwgYnV0IGRvbid0IGR1bXAgYHN0ZGVyclRh" + - "aWxgIHZlcmJhdGltIGludG8gY2hhdCB3aXRob3V0IHNjYW5uaW5nIGZvciBzZWNyZXRzIGZpcnN0" + - "LgoKIyMgUXVpY2sgY29tbWFuZCByZWZlcmVuY2UKCmBgYHNoCm52Y2YtY2xpIHNlbGYtaG9zdGVk" + - "IGNoZWNrIC0tcHJlICAgICAgICAgICAgICAjIHByZS1mbGlnaHQKbnZjZi1jbGkgc2VsZi1ob3N0" + - "ZWQgdXAgLS1jbHVzdGVyLW5hbWU9TkFNRSAgICMgb25lLXNob3QgaW5zdGFsbApudmNmLWNsaSBz" + - "ZWxmLWhvc3RlZCBzdGF0dXMgICAgICAgICAgICAgICAgICAgIyBzbmFwc2hvdApudmNmLWNsaSBz" + - "ZWxmLWhvc3RlZCBzdGF0dXMgLS13YXRjaCAgICAgICAgICAgIyBsaXZlCm52Y2YtY2xpIGluaXQg" + - "ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAjIG1pbnQgYWRtaW4gdG9rZW4gKGNsZWFy" + - "cyBhbGwgc2F2ZWQgQVBJIGtleXMpCm52Y2YtY2xpIGNsdXN0ZXIgcmVnaXN0ZXIg4oCmICAgICAg" + - "ICAgICAgICAgICAgICMgcmVnaXN0ZXIgY2x1c3RlcgpudmNmLWNsaSBjbHVzdGVyIGxpc3QtcmVn" + - "aXN0ZXJlZCAtLW5jYS1pZD08bmNhLWlkPiAjIGxpc3Qgc2VsZi1ob3N0ZWQgcmVnaXN0cmF0aW9u" + - "cwpudmNmLWNsaSBhcGkta2V5IGdlbmVyYXRlIC0tZGVzY3JpcHRpb2494oCmICAgICAjIG1pbnQg" + - "Ym90aCBmdW5jdGlvbiBhbmQgdGFzayBBUEkga2V5cyAocnVuIGFmdGVyIGV2ZXJ5IGluaXQpCm52" + - "Y2YtY2xpIGFwaS1rZXkgZ2VuZXJhdGUgLS1mb3IgZnVuY3Rpb24g4oCmICAgICMgZnVuY3Rpb24g" + - "a2V5IG9ubHkKbnZjZi1jbGkgYXBpLWtleSBnZW5lcmF0ZSAtLWZvciB0YXNrIOKApiAgICAgICAg" + - "IyB0YXNrIGtleSBvbmx5Cm52Y2YtY2xpIGZ1bmN0aW9uIGNyZWF0ZSAtLWlucHV0LWZpbGU94oCm" + - "ICAgICAgICMgY3JlYXRlIGZ1bmN0aW9uCm52Y2YtY2xpIGZ1bmN0aW9uIGNyZWF0ZSAtLWZ1bmN0" + - "aW9uLXR5cGU9TExNIC0tbGxtLW1vZGVsPTxzcGVjPiAgIyBjcmVhdGUgTExNIGZ1bmN0aW9uIG1l" + - "dGFkYXRhCm52Y2YtY2xpIGZ1bmN0aW9uIGNyZWF0ZSAtLW5hbWU9bGxtLWhlbG0gLS1pbmZlcmVu" + - "Y2UtdXJsPS8gLS1pbmZlcmVuY2UtcG9ydD04MDAwIFwKICAtLWZ1bmN0aW9uLXR5cGU9TExNIC0t" + - "aGVsbS1jaGFydD08Y2hhcnQ+IC0taGVsbS1jaGFydC1zZXJ2aWNlPTxzZXJ2aWNlPiAtLWxsbS1t" + - "b2RlbD08c3BlYz4KbnZjZi1jbGkgZnVuY3Rpb24gdXBkYXRlIC0tbGxtLW1vZGVsLXVwZGF0ZT08" + - "c3BlYz4gICMgdXBkYXRlIExMTSByb3V0aW5nL3Rva2VuIGxpbWl0cwpudmNmLWNsaSBmdW5jdGlv" + - "biBkZXBsb3kgY3JlYXRlIC0taW5wdXQtZmlsZT3igKYKbnZjZi1jbGkgZnVuY3Rpb24gaW52b2tl" + - "IC0taW5wdXQtZmlsZT3igKYKCiMgVGFzayBjb21tYW5kcyDigJQgcmVxdWlyZXMgTlZDRl9CQVNF" + - "X05WQ1RfVVJMPWh0dHA6Ly88bnZjdC1nYXRld2F5PgpudmNmLWNsaSB0YXNrIGNyZWF0ZSAtLW5h" + - "bWU9WCAtLWdwdT1IMTAwIC0taW5zdGFuY2UtdHlwZT1ZIC0taW1hZ2U9WgpudmNmLWNsaSB0YXNr" + - "IGNyZWF0ZSAtLWlucHV0LWZpbGU9dGFzay5qc29uICAgIyBmcm9tIEpTT04gY29uZmlnCm52Y2Yt" + - "Y2xpIHRhc2sgbGlzdCAgICAgICAgICAgICAgICAgICAgICAgICAgICAjIGxpc3QgYWxsIHRhc2tz" + - "Cm52Y2YtY2xpIHRhc2sgbGlzdCAtLXN0YXR1cz1SVU5OSU5HICAgICAgICAgICAjIGZpbHRlciBi" + - "eSBzdGF0dXMKbnZjZi1jbGkgdGFzayBnZXQgW3Rhc2tJZF0gICAgICAgICAgICAgICAgICAgICMg" + - "dGFzayBkZXRhaWxzCm52Y2YtY2xpIHRhc2sgZXZlbnRzIFt0YXNrSWRdICAgICAgICAgICAgICAg" + - "ICAjIGxpZmVjeWNsZSBldmVudHMKbnZjZi1jbGkgdGFzayByZXN1bHRzIFt0YXNrSWRdICAgICAg" + - "ICAgICAgICAgICMgcmVzdWx0IGFydGlmYWN0cwpudmNmLWNsaSB0YXNrIGNhbmNlbCBbdGFza0lk" + - "XQpudmNmLWNsaSB0YXNrIGRlbGV0ZSBbdGFza0lkXQpgYGAKCiMjIEZlZWRiYWNrCgpJZiB0aGUg" + - "dXNlciBoaXRzIGEgYnVnIG9yIGxpbWl0YXRpb24sIGZpbGUgYW4gaXNzdWUgdGhyb3VnaCB0aGUg" + - "cHJvamVjdCB0cmFja2VyLiBEb24ndCBpbmNsdWRlIHNlY3JldHMuClBLBwjNgTDkTWEAAE1hAABQ" + - "SwMEFAAIAAAAAAAhAAAAAAAAAAAAAAAAADMACQBkYXRhL252Y2Ytc2VsZi1tYW5hZ2VkLWNsaS9l" + - "eGFtcGxlcy9jaS1waXBlbGluZXMubWRVVAUAAQCmzhIjIENJIHBpcGVsaW5lIHBhdHRlcm5zCgpI" + - "b3cgdG8gZHJpdmUgYG52Y2YtY2xpYCBmcm9tIENJIChHaXRMYWIgQ0ksIEdpdEh1YiBBY3Rpb25z" + - "LCBKZW5raW5zLCBBcmdvQ0QpLiBQYXR0ZXJucyB0aGF0IHN1cmZhY2UgZnJlcXVlbnRseS4KCiMj" + - "IEJhc2ljIGluc3RhbGwgcGlwZWxpbmUKCmBgYHlhbWwKIyBHaXRMYWIgQ0kgZXhhbXBsZQpkZXBs" + - "b3lfbnZjZjoKICBzdGFnZTogZGVwbG95CiAgaW1hZ2U6IG52Y3IuaW8vMDY1MTE1NTIxNTg2NDk3" + - "OS9uY3AtZGV2L252Y2YtY2xpOjEuNC4wCiAgdmFyaWFibGVzOgogICAgS1VCRUNPTkZJRzogJEtV" + - "QkVDT05GSUdfRklMRQogIHNjcmlwdDoKICAgIC0gbnZjZi1jbGkgc2VsZi1ob3N0ZWQgY2hlY2sg" + - "LS1wcmUgLS1qc29uIHwganEgLWUgJy5ldmVudCAhPSAicGhhc2VfZmFpbGVkIicgfHwgZXhpdCAy" + - "CiAgICAtIG52Y2YtY2xpIHNlbGYtaG9zdGVkIHVwIC0tY2x1c3Rlci1uYW1lPSRDTFVTVEVSX05B" + - "TUUgLS10b2tlbj0kTlZDRl9BRE1JTl9KV1QgLS1ub24taW50ZXJhY3RpdmUgLS1qc29uCiAgICAt" + - "IG52Y2YtY2xpIHNlbGYtaG9zdGVkIHN0YXR1cyAtLWpzb24gfCBqcSAtZSAnLnZlcmRpY3QgPT0g" + - "ImhlYWx0aHkiJwpgYGAKCk5vdGVzOgotIGAtLW5vbi1pbnRlcmFjdGl2ZSAtLXRva2VuPSRKV1Rg" + - "IGlzIHJlcXVpcmVkIGluIENJOyBuZXZlciB1c2UgaW50ZXJhY3RpdmUgYGluaXRgLgotIEFsd2F5" + - "cyBgLS1qc29uYCBmb3IgbWFjaGluZS1wYXJzaW5nLgotIEZpbmFsIHN0YXR1cyBjaGVjayBnYXRl" + - "cyBkb3duc3RyZWFtIHN0YWdlcyBvbiBgdmVyZGljdCA9PSAiaGVhbHRoeSJgLgoKIyMgR2l0T3Bz" + - "IChBcmdvIC8gRmx1eCkgcGF0dGVybgoKQ0kgZG9lc24ndCBga3ViZWN0bCBhcHBseWAg4oCUIGlu" + - "c3RlYWQsIHJlbmRlciBtYW5pZmVzdHMsIGNvbW1pdCB0aGVtLCBsZXQgdGhlIGNvbnRyb2xsZXIg" + - "YXBwbHkuCgpgYGB5YW1sCnJlbmRlcjoKICBzY3JpcHQ6CiAgICAtIG52Y2YtY2xpIHNlbGYtaG9z" + - "dGVkIGluc3RhbGwgLS1jb250cm9sLXBsYW5lIC0tbm8tYXBwbHkgPiByZW5kZXJlZC9jb250cm9s" + - "LXBsYW5lLnlhbWwKICAgIC0gbnZjZi1jbGkgc2VsZi1ob3N0ZWQgaW5zdGFsbCAtLWNvbXB1dGUt" + - "cGxhbmUgLS1jbHVzdGVyLW5hbWU9JE5BTUUgLS1uby1hcHBseSA+IHJlbmRlcmVkL2NvbXB1dGUt" + - "cGxhbmUueWFtbAogICAgLSBnaXQgYWRkIHJlbmRlcmVkLyAmJiBnaXQgY29tbWl0IC1tICJkZXBs" + - "b3kgTlZDRiAkVEFHIiAmJiBnaXQgcHVzaApgYGAKClRoZW4gQXJnb0NEIG9yIEZsdXggd2F0Y2hl" + - "cyBgcmVuZGVyZWQvYCBhbmQgYXBwbGllcy4gVGhlIENMSSBuZXZlciB0b3VjaGVzIHRoZSBjbHVz" + - "dGVyIGRpcmVjdGx5LgoKRm9yIHRoZSByZWdpc3RlciBzdGVwICh3aGljaCBtdXRhdGVzIElDTVMs" + - "IG5vdCBqdXN0IEs4cyk6CgpgYGB5YW1sCnJlZ2lzdGVyOgogIHNjcmlwdDoKICAgIC0gbnZjZi1j" + - "bGkgY2x1c3RlciByZWdpc3RlciAtLW5hbWU9JE5BTUUgLS1uY2EtaWQ9JE5DQSAtLXJlZ2lvbj0k" + - "UkVHSU9OIC0taWdub3JlLWV4aXN0aW5nCmBgYAoKYC0taWdub3JlLWV4aXN0aW5nYCBpcyB0aGUg" + - "R2l0T3BzLWZyaWVuZGx5IGlkZW1wb3RlbnQgY29udHJhY3QuCgojIyBNdWx0aS1jbHVzdGVyIHBp" + - "cGVsaW5lCgpXaGVuIHRoZSBwaXBlbGluZSBtYW5hZ2VzIG1hbnkgY29tcHV0ZSBjbHVzdGVycyBh" + - "Z2FpbnN0IG9uZSBjb250cm9sIHBsYW5lOgoKYGBgeWFtbApkZXBsb3lfY29tcHV0ZV9wbGFuZXM6" + - "CiAgcGFyYWxsZWw6CiAgICBtYXRyaXg6CiAgICAgIC0gQ0xVU1RFUjogbmNwLWVhc3QtMQogICAg" + - "ICAgIENPTlRFWFQ6IGFkbWluQGdwdS1lYXN0LTEKICAgICAgLSBDTFVTVEVSOiBuY3Atd2VzdC0x" + - "CiAgICAgICAgQ09OVEVYVDogYWRtaW5AZ3B1LXdlc3QtMQogICAgICAtIENMVVNURVI6IG5jcC1l" + - "dS0xCiAgICAgICAgQ09OVEVYVDogYWRtaW5AZ3B1LWV1LTEKICBzY3JpcHQ6CiAgICAtIG52Y2Yt" + - "Y2xpIHNlbGYtaG9zdGVkIHVwCiAgICAgICAgLS1jbHVzdGVyLW5hbWU9JENMVVNURVIKICAgICAg" + - "ICAtLWNvbXB1dGUtcGxhbmUtY29udGV4dD0kQ09OVEVYVAogICAgICAgIC0taWNtcy11cmw9JElD" + - "TVNfUFVCTElDX1VSTAogICAgICAgIC0tdG9rZW49JE5WQ0ZfQURNSU5fSldUCiAgICAgICAgLS1u" + - "b24taW50ZXJhY3RpdmUKICAgICAgICAtLWpzb24KYGBgCgpFYWNoIHBhcmFsbGVsIGpvYiByZWdp" + - "c3RlcnMgKyBpbnN0YWxscyBvbmUgY29tcHV0ZSBwbGFuZSBhZ2FpbnN0IHRoZSBzaGFyZWQgY29u" + - "dHJvbCBwbGFuZS4gRmFpbHVyZXMgYXJlIGlzb2xhdGVkLgoKIyMgUGxhbi1vbmx5IHByZXZpZXcg" + - "aW4gUFJzCgpgYGB5YW1sCnByZXZpZXc6CiAgcnVsZXM6CiAgICAtIGlmOiAkQ0lfUElQRUxJTkVf" + - "U09VUkNFID09ICJtZXJnZV9yZXF1ZXN0X2V2ZW50IgogIHNjcmlwdDoKICAgIC0gfAogICAgICBu" + - "dmNmLWNsaSBzZWxmLWhvc3RlZCB1cCBcCiAgICAgICAgLS1jbHVzdGVyLW5hbWU9JENMVVNURVJf" + - "TkFNRSBcCiAgICAgICAgLS1wbGFuLW9ubHkgXAogICAgICAgIC0tanNvbiB8IHRlZSBwbGFuLmpz" + - "b25sCiAgICAtIGpxIC1zICcuWzBdJyBwbGFuLmpzb25sID4gcGxhbi5qc29uCiAgICAtICdnaXRs" + - "YWItbXItY29tbWVudCAiIyMgTlZDRiBkZXBsb3kgcGxhblxuXG5cYFxgXGBqc29uXG4kKGNhdCBw" + - "bGFuLmpzb24pXG5cYFxgXGAiJwpgYGAKCmAtLXBsYW4tb25seWAgZXhpdHMgMCB3aXRob3V0IGNo" + - "YW5naW5nIGNsdXN0ZXIgc3RhdGU7IHRoZSBKU09OTCBvdXRwdXQgbGlzdHMgZWFjaCBwaGFzZSAr" + - "IEVUQS4gUmVuZGVycyBuaWNlbHkgYXMgYW4gTVIgY29tbWVudC4KUEsHCCHGyIbwCgAA8AoAAFBL" + - "AwQUAAgAAAAAACEAAAAAAAAAAAAAAAAANAAJAGRhdGEvbnZjZi1zZWxmLW1hbmFnZWQtY2xpL2V4" + - "YW1wbGVzL211bHRpLWNsdXN0ZXIubWRVVAUAAQCmzhIjIE11bHRpLWNsdXN0ZXIgcGF0dGVybnMK" + - "CkV4YW1wbGVzIG9mIHNwbGl0LWNsdXN0ZXIgKyBtYW55LWNvbXB1dGUtcGxhbmUgb3BlcmF0aW9u" + - "LgoKIyMgT25lIGNvbnRyb2wgcGxhbmUgKyBOIGNvbXB1dGUgcGxhbmVzCgpUaGUgY2Fub25pY2Fs" + - "IG11bHRpLWNsdXN0ZXIgdG9wb2xvZ3kuIEVhY2ggY29tcHV0ZSBwbGFuZSBpcyByZWdpc3RlcmVk" + - "IHNlcGFyYXRlbHk6CgpgYGBzaAojIDEuIEJyaW5nIHVwIHRoZSBjb250cm9sIHBsYW5lIChvbmUt" + - "dGltZSwgb24gdGhlIGNvbnRyb2wtcGxhbmUgY2x1c3Rlcik6CktVQkVDT05GSUc9Y3AueWFtbCBu" + - "dmNmLWNsaSBzZWxmLWhvc3RlZCBpbnN0YWxsIC0tY29udHJvbC1wbGFuZSB8IGt1YmVjdGwgYXBw" + - "bHkgLWYgLQpudmNmLWNsaSBzZWxmLWhvc3RlZCBjaGVjayAtLWNvbnRyb2wtcGxhbmUgLS13YWl0" + - "IDVtCgojIDIuIFJlZ2lzdGVyICsgaW5zdGFsbCBlYWNoIGNvbXB1dGUgcGxhbmU6CmZvciBDVFgg" + - "aW4gYWRtaW5AZ3B1LWVhc3QtMSBhZG1pbkBncHUtd2VzdC0xIGFkbWluQGdwdS1ldS0xOyBkbwog" + - "IE5BTUU9JChlY2hvICIkQ1RYIiB8IGN1dCAtZEAgLWYyKQogIG52Y2YtY2xpIHNlbGYtaG9zdGVk" + - "IHVwIFwKICAgIC0tY2x1c3Rlci1uYW1lPSROQU1FIFwKICAgIC0tY29tcHV0ZS1wbGFuZS1jb250" + - "ZXh0PSRDVFggXAogICAgLS1pY21zLXVybD1odHRwczovL2ljbXMubnZjZi5leGFtcGxlLmNvbSBc" + - "CiAgICAtLXRva2VuPSROVkNGX0FETUlOX0pXVCBcCiAgICAtLW5vbi1pbnRlcmFjdGl2ZSBcCiAg" + - "ICAtLWpzb24KZG9uZQoKIyAzLiBWZXJpZnkgYWxsIGNvbXB1dGUgcGxhbmVzIHJlZ2lzdGVyZWQ6" + - "Cm52Y2YtY2xpIGNsdXN0ZXIgbGlzdC1yZWdpc3RlcmVkIC0tbmNhLWlkPSROQ0FfSUQgLS1pY21z" + - "LXVybD0kSUNNUyAtLWpzb24gXAogIHwganEgJy5jbHVzdGVyc1tdIHwge25hbWU6IC5jbHVzdGVy" + - "TmFtZSwgc3RhdHVzLCBudmNhVmVyc2lvbn0nCmBgYAoKIyMgQ29tcHV0ZS1wbGFuZS1vbmx5IG9w" + - "ZXJhdG9yIHNjZW5hcmlvCgpUaGUgb3BlcmF0b3IgaGFzIGt1YmVjdGwgYWNjZXNzIHRvIE9ORSBj" + - "b21wdXRlIHBsYW5lIG9ubHkg4oCUIHRoZSBjb250cm9sIHBsYW5lIGlzIG9wZXJhdGVkIGJ5IHNv" + - "bWVvbmUgZWxzZSAoZS5nLiBZb3R0YSBydW5zIHRoZSBjb250cm9sIHBsYW5lIGZvciBhIGN1c3Rv" + - "bWVyKS4KCmBgYHNoCiMgTWludCBhIHRva2VuIHZpYSB0aGUgcHVibGljIGFwaSBnYXRld2F5ICh0" + - "aGUgY29udHJvbCBwbGFuZSdzIEFQSSBLZXlzCiMgc2VydmljZSBpcyByZWFjaGFibGUgdmlhIGFw" + - "aS5udmNmLmV4YW1wbGUuY29tIOKAlCBubyBrdWJlY3RsIGFjY2VzcyBuZWVkZWQpOgpudmNmLWNs" + - "aSBpbml0IC0tYXBpLXVybD1odHRwczovL2FwaS5udmNmLmV4YW1wbGUuY29tCgojIFJ1biBwcmUt" + - "ZmxpZ2h0IHNjb3BlZCB0byB0aGUgY29tcHV0ZSBwbGFuZSBvbmx5OgpudmNmLWNsaSBzZWxmLWhv" + - "c3RlZCBjaGVjayAtLXByZSBcCiAgLS1jb21wdXRlLXBsYW5lLWNvbnRleHQ9YWRtaW5AZ3B1MSBc" + - "CiAgLS1pY21zLXVybD1odHRwczovL2ljbXMubnZjZi5leGFtcGxlLmNvbSBcCiAgLS1qc29uCgoj" + - "IEJyaW5nIHVwIGp1c3QgdGhlIGNvbXB1dGUgcGxhbmU6Cm52Y2YtY2xpIHNlbGYtaG9zdGVkIHVw" + - "IFwKICAtLWNsdXN0ZXItbmFtZT1teS1jb21wdXRlLTEgXAogIC0tY29tcHV0ZS1wbGFuZS1jb250" + - "ZXh0PWFkbWluQGdwdTEgXAogIC0taWNtcy11cmw9aHR0cHM6Ly9pY21zLm52Y2YuZXhhbXBsZS5j" + - "b20gXAogIC0tdG9rZW49JEFETUlOX0pXVCBcCiAgLS1ub24taW50ZXJhY3RpdmUKCiMgU3RhdHVz" + - "IChjb21wdXRlLW9ubHkg4oCUIG9wZXJhdG9yIGNhbid0IHNlZSBjb250cm9sLXBsYW5lIGNvbXBv" + - "bmVudCBoZWFsdGgpOgpudmNmLWNsaSBzZWxmLWhvc3RlZCBzdGF0dXMgXAogIC0tY29tcHV0ZS1w" + - "bGFuZS1jb250ZXh0PWFkbWluQGdwdTEgXAogIC0taWNtcy11cmw9aHR0cHM6Ly9pY21zLm52Y2Yu" + - "ZXhhbXBsZS5jb20KYGBgCgojIyBGdW5jdGlvbnMgdGFyZ2V0aW5nIHNwZWNpZmljIGNvbXB1dGUg" + - "cGxhbmVzCgpXaGVuIHlvdSBoYXZlIG11bHRpcGxlIGNvbXB1dGUgcGxhbmVzIGFuZCB3YW50IGEg" + - "ZnVuY3Rpb24gdG8gZGVwbG95IHRvIG9uZToKCmBgYGpzb24KewogICJmdW5jdGlvbklkIjogIjxm" + - "bl9pZD4iLAogICJ2ZXJzaW9uSWQiOiAiPHZlcl9pZD4iLAogICJkZXBsb3ltZW50U3BlY2lmaWNh" + - "dGlvbnMiOiBbewogICAgImdwdSI6ICJIMTAwIiwKICAgICJpbnN0YW5jZVR5cGUiOiAiTkNQLkdQ" + - "VS5IMTAwXzF4IiwKICAgICJtaW5JbnN0YW5jZXMiOiAxLAogICAgIm1heEluc3RhbmNlcyI6IDEs" + - "CiAgICAiY2x1c3RlcnMiOiBbImdwdS1lYXN0LTEiXQogIH1dCn0KYGBgCgpUaGUgYGNsdXN0ZXJz" + - "YCBhcnJheSAodXNpbmcgY2x1c3RlciBuYW1lcywgbm90IElEcykgbGltaXRzIHNjaGVkdWxpbmcg" + - "dG8gdGhvc2UgY29tcHV0ZSBwbGFuZXMuIE9taXQgdG8gbGV0IElDTVMgY2hvb3NlIGFueSBjb21w" + - "dXRlIHBsYW5lIHdpdGggYSBtYXRjaGluZyBTS1UuCgojIyBTdGF0dXMgZmFuLW91dCBhY3Jvc3Mg" + - "Y29tcHV0ZSBwbGFuZXMKCmBgYHNoCiMgTGlzdCBhbGwgcmVnaXN0ZXJlZCBjb21wdXRlIHBsYW5l" + - "czoKbnZjZi1jbGkgY2x1c3RlciBsaXN0LXJlZ2lzdGVyZWQgLS1uY2EtaWQ9JE5DQV9JRCAtLWlj" + - "bXMtdXJsPSRJQ01TIC0tanNvbiBcCiAgfCBqcSAtciAnLmNsdXN0ZXJzW10uY2x1c3Rlck5hbWUn" + - "ID4gY2x1c3RlcnMudHh0CgojIFN0YXR1cyBzbmFwc2hvdCBwZXIgY29tcHV0ZSBwbGFuZSAoYXNz" + - "dW1pbmcgZWFjaCBjb250ZXh0IG5hbWUgbWF0Y2hlcyk6CndoaWxlIHJlYWQgTkFNRTsgZG8KICBl" + - "Y2hvICI9PT0gJE5BTUUgPT09IgogIG52Y2YtY2xpIHNlbGYtaG9zdGVkIHN0YXR1cyBcCiAgICAt" + - "LWNsdXN0ZXItbmFtZT0kTkFNRSBcCiAgICAtLWNvbXB1dGUtcGxhbmUtY29udGV4dD1hZG1pbkAk" + - "TkFNRSBcCiAgICAtLWpzb24gfCBqcSAtYyAne2NsdXN0ZXI6LmNsdXN0ZXIsIHZlcmRpY3Q6LnZl" + - "cmRpY3QsIHJlY29uY2lsZToucmVjb25jaWxlQWdlU2VjfScKZG9uZSA8IGNsdXN0ZXJzLnR4dApg" + - "YGAKCkEgZnV0dXJlIE0rMTEgbWlsZXN0b25lIHdpbGwgYWRkIG5hdGl2ZSBmYW4tb3V0IChgc3Rh" + - "dHVzIC0tYWxsLWNvbXB1dGUtcGxhbmVzYCkgc28gdGhpcyBkb2Vzbid0IG5lZWQgYSBzaGVsbCBs" + - "b29wLgpQSwcIoRTjgV0MAABdDAAAUEsDBBQACAAAAAAAIQAAAAAAAAAAAAAAAAA3AAkAZGF0YS9u" + - "dmNmLXNlbGYtbWFuYWdlZC1jbGkvcHJvbXB0cy9hZGQtY29tcHV0ZS1wbGFuZS5tZFVUBQABAKbO" + - "EiMgQWRkIGEgY29tcHV0ZSBwbGFuZSB0byBhbiBleGlzdGluZyBjb250cm9sIHBsYW5lCgpVc2Vy" + - "IGhhcyBhIHdvcmtpbmcgTlZDRiBjb250cm9sIHBsYW5lIChydW5uaW5nIHNvbWV3aGVyZSkgYW5k" + - "IHdhbnRzIHRvIHJlZ2lzdGVyIGEgbmV3IEdQVSBjbHVzdGVyIGFnYWluc3QgaXQuIFRoaXMgaXMg" + - "dGhlIG11bHRpLWNsdXN0ZXIgc2NhbGluZyBwYXRoOiBvbmUgY29udHJvbCBwbGFuZSDihpIgTiBj" + - "b21wdXRlIHBsYW5lcy4KCiMjIFByZXJlcXVpc2l0ZXMgdGhlIHVzZXIgbXVzdCBoYXZlCgotICoq" + - "a3ViZWN0bCBjb250ZXh0IGZvciB0aGUgbmV3IGNvbXB1dGUgcGxhbmUqKiBpbiB0aGVpciBgS1VC" + - "RUNPTkZJR2AuCi0gKipQdWJsaWMgSUNNUyBVUkwqKiBvZiB0aGUgZXhpc3RpbmcgY29udHJvbCBw" + - "bGFuZSAoZS5nLiBgaHR0cHM6Ly9pY21zLm52Y2YuZXhhbXBsZS5jb21gKS4KLSAqKkFkbWluIEpX" + - "VCoqIGZvciB0aGUgY29udHJvbCBwbGFuZSdzIGFjY291bnQsIE9SIGFiaWxpdHkgdG8gbWludCBv" + - "bmUgdmlhIGBudmNmLWNsaSBpbml0YCBhZ2FpbnN0IHRoZSBjb250cm9sIHBsYW5lJ3MgcHVibGlj" + - "IGFwaSBlbmRwb2ludC4gKEFkbWluIHRva2VucyBjb21lIGZyb20gdGhlIEFQSSBLZXlzIHNlcnZp" + - "Y2UgdmlhIHRoZSBwdWJsaWMgYXBpIGdhdGV3YXkg4oCUIGt1YmVjdGwgYWNjZXNzIHRvIHRoZSBj" + - "b250cm9sIHBsYW5lIGlzIE5PVCByZXF1aXJlZCB0byBvYnRhaW4gb25lLikKLSBBIHVuaXF1ZSBg" + - "LS1jbHVzdGVyLW5hbWVgIHRoYXQgZG9lc24ndCBjb2xsaWRlIHdpdGggYWxyZWFkeS1yZWdpc3Rl" + - "cmVkIGNsdXN0ZXJzLiBVc2UgYG52Y2YtY2xpIGNsdXN0ZXIgbGlzdC1yZWdpc3RlcmVkIC0tbmNh" + - "LWlkPSROQ0FfSUQgLS1pY21zLXVybD0kSUNNU2AgdG8gY2hlY2suCgojIyBTdGVwcwoKMS4gKipB" + - "c2sgZm9yIGlucHV0czoqKgogICAtIGAtLWNsdXN0ZXItbmFtZT08dW5pcXVlPmAg4oCUIG11c3Qg" + - "YmUgdW5pcXVlIHdpdGhpbiB0aGUgY29udHJvbCBwbGFuZSdzIE5DQSBzY29wZQogICAtIGAtLWNv" + - "bXB1dGUtcGxhbmUtY29udGV4dD08Y29udGV4dD5gIOKAlCB0aGUgbmV3IEdQVSBjbHVzdGVyJ3Mg" + - "a3ViZWN0bCBjb250ZXh0CiAgIC0gYC0taWNtcy11cmw9PGh0dHBzOi8vaWNtcy5udmNmLmV4YW1w" + - "bGUuY29tPmAg4oCUIGNvbnRyb2wgcGxhbmUncyBwdWJsaWMgSUNNUyBVUkwKICAgLSBHUFUgdHlw" + - "ZT8gKGRlZmF1bHQgYEgxMDBgLCBidXQgYXNrKQoKMi4gKipQcmUtZmxpZ2h0IGp1c3QgdGhlIGNv" + - "bXB1dGUgcGxhbmU6KioKCiAgIGBgYHNoCiAgIG52Y2YtY2xpIHNlbGYtaG9zdGVkIGNoZWNrIC0t" + - "cHJlIFwKICAgICAtLWNvbXB1dGUtcGxhbmUtY29udGV4dD0kQ1RYIFwKICAgICAtLWljbXMtdXJs" + - "PSRJQ01TIFwKICAgICAtLWpzb24gfCBqcSAtYyAuCiAgIGBgYAoKICAgVGhpcyB2YWxpZGF0ZXMg" + - "dGhlIEdQVSBvcGVyYXRvciBpcyBpbnN0YWxsZWQsIEdQVSBub2RlIGxhYmVscyBhcmUgcHJlc2Vu" + - "dCwgYW5kIElDTVMgaXMgcmVhY2hhYmxlIHZpYSBIVFRQLiBBZGRyZXNzIGFueSBmYWlsdXJlcyBi" + - "ZWZvcmUgcHJvY2VlZGluZy4KCjMuICoqUnVuIGBhZGQtY29tcHV0ZS1wbGFuZWA6KioKCiAgIGBg" + - "YHNoCiAgIG52Y2YtY2xpIHNlbGYtaG9zdGVkIGFkZC1jb21wdXRlLXBsYW5lIFwKICAgICAtLWNs" + - "dXN0ZXItbmFtZT0kTkFNRSBcCiAgICAgLS1jb21wdXRlLXBsYW5lLWNvbnRleHQ9JENUWCBcCiAg" + - "ICAgLS1pY21zLXVybD0kSUNNUyBcCiAgICAgLS10b2tlbj0kSldUIFwKICAgICAtLW5vbi1pbnRl" + - "cmFjdGl2ZSBcCiAgICAgLS1qc29uCiAgIGBgYAoKICAgVGhpcyBpcyBhIHNlcGFyYXRlIHN1YmNv" + - "bW1hbmQgZnJvbSBgdXBgLiBJdCBydW5zIG9ubHkgdGhlIGNvbXB1dGUtcGxhbmUtcmVsZXZhbnQg" + - "cGhhc2VzOiAxIChjb21wdXRlLXBsYW5lIHByZWZsaWdodCksIDUgKHJlZ2lzdGVyKSwgNiAoY29t" + - "cHV0ZS1wbGFuZSBhcHBseSksIDggKGZpbmFsIGhlYWx0aCBvbiB0aGUgbmV3IGNvbXB1dGUgcGxh" + - "bmUpLiBJdCBkb2VzIE5PVCB0b3VjaCB0aGUgY29udHJvbCBwbGFuZSBhbmQgZG9lcyBOT1QgYWNj" + - "ZXB0IGAtLWNvbnRyb2wtcGxhbmUtY29udGV4dGAg4oCUIHRoZSBjb250cm9sIHBsYW5lIGlzIHJl" + - "YWNoZWQgb3ZlciBIVFRQUyBhdCBgLS1pY21zLXVybGAuIGAtLXRva2VuYCBpcyByZXF1aXJlZCBi" + - "ZWNhdXNlIHRoZXJlJ3Mgbm8ga3ViZWN0bCBwYXRoIHRvIG1pbnQgb25lIGZyb20uCgo0LiAqKlZl" + - "cmlmeS4qKiBgbnZjZi1jbGkgc2VsZi1ob3N0ZWQgc3RhdHVzIC0tY2x1c3Rlci1uYW1lPSROQU1F" + - "IC0tanNvbiB8IGpxYCDigJQgZXhwZWN0IGB2ZXJkaWN0OiAiaGVhbHRoeSJgLiBUaGUgUmVnaXN0" + - "ZXJlZCBDb21wdXRlIFBsYW5lcyBwYW5lbCBmcm9tIElDTVMgc2hvdWxkIG5vdyBsaXN0IHRoZSBu" + - "ZXcgY2x1c3Rlci4KCjUuICoqU21va2UuKiogW2RlcGxveS1hbmQtaW52b2tlLm1kXShkZXBsb3kt" + - "YW5kLWludm9rZS5tZCkg4oCUIGRlcGxveSBhIHNtYWxsIGZ1bmN0aW9uIHRvIHRoZSBuZXcgY29t" + - "cHV0ZSBwbGFuZSB0byBjb25maXJtIHNjaGVkdWxpbmcgd29ya3MuCgojIyBXaGF0IGlmIGEgY2x1" + - "c3RlciB3aXRoIHRoZSBzYW1lIG5hbWUgYWxyZWFkeSBleGlzdHM/CgpgYWRkLWNvbXB1dGUtcGxh" + - "bmVgJ3MgcmVnaXN0ZXIgcGhhc2UgdXNlcyBgLS1pZ25vcmUtZXhpc3RpbmdgIHNlbWFudGljcyDi" + - "gJQgaXQnbGwgbWF0Y2ggdGhlIGV4aXN0aW5nIElDTVMgcm93IGFuZCByZXVzZSBpdHMgY2x1c3Rl" + - "cklkLiBUd28gc2NlbmFyaW9zOgoKLSAqKlJlLXJlZ2lzdGVyaW5nIHRoZSBzYW1lIGNsdXN0ZXIq" + - "KiAocmUtcnVubmluZyBvbiB0aGUgc2FtZSBjb21wdXRlIHBsYW5lIHRoYXQgd2FzIHByZXZpb3Vz" + - "bHkgcmVnaXN0ZXJlZCk6IGV4cGVjdGVkLCBuby1vcCBzZW1hbnRpY3MuCi0gKipEaWZmZXJlbnQg" + - "cGh5c2ljYWwgY2x1c3RlciBidXQgc2FtZSBuYW1lKio6IHRoZSBzZWNvbmQgYXR0ZW1wdCB3aWxs" + - "IHJldXNlIHRoZSBJQ01TIHJvdywgYnV0IHRoZSBuZXcgY29tcHV0ZSBwbGFuZSdzIEpXS1Mgd2ls" + - "bCBiZSBzaWxlbnRseSAqcmVwbGFjZWQqIOKAlCB0aGUgb2xkIGNvbXB1dGUgcGxhbmUncyBOVkNB" + - "IGFnZW50IHdpbGwgc3RhcnQgZmFpbGluZyBQU0FUIGF1dGguICoqQ29uZmlybSB3aXRoIHRoZSB1" + - "c2VyKiogdGhhdCB0aGV5IG1lYW50IHRvIG92ZXJ3cml0ZS4KCldoZW4gaW4gZG91YnQsIHJ1biBg" + - "bnZjZi1jbGkgY2x1c3RlciBsaXN0LXJlZ2lzdGVyZWQgLS1uY2EtaWQ9JE5DQV9JRCAtLWljbXMt" + - "dXJsPSRJQ01TYCBmaXJzdCBhbmQgYXNrIHRoZSB1c2VyIGJlZm9yZSBwcm9jZWVkaW5nIHdpdGgg" + - "YSBuYW1lIHRoYXQgYWxyZWFkeSBleGlzdHMuClBLBwhCJ0kPBQ0AAAUNAABQSwMEFAAIAAAAAAAh" + - "AAAAAAAAAAAAAAAAADkACQBkYXRhL252Y2Ytc2VsZi1tYW5hZ2VkLWNsaS9wcm9tcHRzL2NyZWF0" + - "ZS1hbmQtcnVuLXRhc2subWRVVAUAAQCmzhIjIENyZWF0ZSBhbmQgcnVuIGEgdGFzawoKU3RhbmRh" + - "cmQgZmxvdzogbWludCBBUEkga2V5cyAtPiB0YXNrIENSRUFURSAtPiBtb25pdG9yIC0+IHJldHJp" + - "ZXZlIHJlc3VsdHMgLT4gY2xlYW51cC4KCiMjIDEuIE1pbnQgQVBJIGtleXMKClRoZSBhZG1pbiB0" + - "b2tlbiBmcm9tIGBpbml0YCBkb2VzIG5vdCBjYXJyeSB0YXNrIGludm9jYXRpb24gc2NvcGUuIEdl" + - "bmVyYXRlIEFQSSBrZXlzOgoKYGBgc2gKbnZjZi1jbGkgYXBpLWtleSBnZW5lcmF0ZSAtLWRlc2Ny" + - "aXB0aW9uPSJ0YXNrIHNtb2tlIHRlc3QiIC0tZXhwaXJlcy1pbj04aAojIC0+IGZ1bmN0aW9uIGtl" + - "eTogbnZhcGktLi4uCiMgLT4gdGFzayBrZXk6IG52YXBpLS4uLgpgYGAKCkJvdGgga2V5cyBhcmUg" + - "c2F2ZWQgdG8gQ0xJIHN0YXRlLiBUbyBtaW50IG9ubHkgdGhlIHRhc2sga2V5OgoKYGBgc2gKbnZj" + - "Zi1jbGkgYXBpLWtleSBnZW5lcmF0ZSAtLWZvciB0YXNrIC0tZGVzY3JpcHRpb249InRhc2sgc21v" + - "a2UgdGVzdCIgLS1leHBpcmVzLWluPThoCmBgYAoKVG8gdmFsaWRhdGUgZWFjaCBrZXkgaW1tZWRp" + - "YXRlbHkgYWZ0ZXIgbWludGluZzoKCmBgYHNoCm52Y2YtY2xpIGFwaS1rZXkgZ2VuZXJhdGUgLS1k" + - "ZXNjcmlwdGlvbj0idGFzayBzbW9rZSB0ZXN0IiAtLWV4cGlyZXMtaW49OGggLS12YWxpZGF0ZQoj" + - "IC0+IGZ1bmN0aW9uIEFQSSBrZXkgdmFsaWRhdGlvbiBwYXNzZWQhCiMgLT4gdGFzayBBUEkga2V5" + - "IHZhbGlkYXRpb24gcGFzc2VkIQpgYGAKCk5ldmVyIGVjaG8gdGhlIGtleSB2YWx1ZSAobnZhcGkt" + - "Li4uKSBpbnRvIGNoYXQgb3IgbG9ncy4gUmVwb3J0IG9ubHkgdGhhdCB0aGUga2V5IHdhcyBtaW50" + - "ZWQsIGl0cyBkZXNjcmlwdGlvbiwgYW5kIGl0cyBleHBpcnkg4oCUIG5ldmVyIHRoZSB2YWx1ZSBp" + - "dHNlbGYuCgojIyMgRnJlc2ggc2Vzc2lvbiBwcmUtZmxpZ2h0CgpCZWZvcmUgcnVubmluZyBhbnkg" + - "YHRhc2tgIGNvbW1hbmQgaW4gYSBmcmVzaCBhZ2VudCBzZXNzaW9uLCB2ZXJpZnkgY3JlZGVudGlh" + - "bHM6CgoxLiBDaGVjayB3aGV0aGVyIGBOVkNGX0FQSV9LRVlgIGlzIHNldDoKICAgYGBgc2gKICAg" + - "cHJpbnRlbnYgTlZDRl9BUElfS0VZID4gL2Rldi9udWxsIDI+JjEgJiYgZWNobyBzZXQgfHwgZWNo" + - "byB1bnNldAogICBgYGAKMi4gSWYgdW5zZXQsIHJlYWQgdGhlIHN0b3JlZCBrZXkgZXhwaXJ5IHdp" + - "dGhvdXQgcHJpbnRpbmcgdGhlIHZhbHVlOgogICBgYGBzaAogICBweXRob24zIC1jICJpbXBvcnQg" + - "anNvbixwYXRobGliOyBzPWpzb24ubG9hZHMocGF0aGxpYi5QYXRoKCd+Ly5udmNmLWNsaS5zdGF0" + - "ZScpLmV4cGFuZHVzZXIoKS5yZWFkX3RleHQoKSk7IHByaW50KHMuZ2V0KCdudmN0QXBpS2V5RXhw" + - "aXJhdGlvbicsJ21pc3NpbmcnKSkiCiAgIGBgYAozLiBJZiB0aGUgZXhwaXJ5IGlzIGluIHRoZSBw" + - "YXN0IG9yIG1pc3NpbmcsIHJlZ2VuZXJhdGU6CiAgIGBgYHNoCiAgIG52Y2YtY2xpIHJlZnJlc2gK" + - "ICAgbnZjZi1jbGkgYXBpLWtleSBnZW5lcmF0ZSAtLWZvciB0YXNrIC0tZGVzY3JpcHRpb249InRh" + - "c2sta2V5IiAtLWV4cGlyZXMtaW49MjRoIC0tdmFsaWRhdGUKICAgYGBgCjQuIEluamVjdCB0aGUg" + - "c3RvcmVkIGtleSBpbnRvIHRoZSBzdWJwcm9jZXNzIGVudiB3aXRob3V0IGxvZ2dpbmcgdGhlIHZh" + - "bHVlLiBVc2UgYSBzaGVsbCBzdWJzaGVsbCBvciBlbnYgcHJlZml4IOKAlCBuZXZlciBwcmludCB0" + - "aGUga2V5IGludG8gY2hhdC4KCkVycm9yIGNsYXNzaWZpY2F0aW9uOgotICJtaXNzaW5nIGF1dGhl" + - "bnRpY2F0aW9uIGNyZWRlbnRpYWxzIiBvciBleGl0IDI6IGtleSBub3QgaW5qZWN0ZWQ7IHJlcGVh" + - "dCBwcmUtZmxpZ2h0LgotIEhUVFAgNDAzOiBrZXkgZXhwaXJlZCBvciB3cm9uZyBhdWRpZW5jZTsg" + - "cmVnZW5lcmF0ZS4KLSBFbXB0eSB0YXNrIGxpc3Q6IHZhbGlkOyBubyB0YXNrcyBleGlzdCB5ZXQu" + - "CgojIyAyLiBUYXNrIENSRUFURTogY29udGFpbmVyCgpEZWZpbmUgdGhlIHRhc2sgaW4gYSBKU09O" + - "IGZpbGUuIE1pbmltdW0gdmlhYmxlIGNvbnRhaW5lciB0YXNrOgoKYGBganNvbgp7CiAgIm5hbWUi" + - "OiAic21va2UtY29udGFpbmVyLXRhc2siLAogICJncHVTcGVjaWZpY2F0aW9uIjogewogICAgImdw" + - "dSI6ICJIMTAwIiwKICAgICJpbnN0YW5jZVR5cGUiOiAiTkNQLkdQVS5IMTAwXzF4IiwKICAgICJi" + - "YWNrZW5kIjogIm5jcC1sb2NhbCIKICB9LAogICJjb250YWluZXJJbWFnZSI6ICJudmNyLmlvL252" + - "aWRpYS9uZW1vOmxhdGVzdCIsCiAgImNvbnRhaW5lckFyZ3MiOiAicHl0aG9uIC1jIFwicHJpbnQo" + - "J2hlbGxvIGZyb20gdGFzaycpXCIiLAogICJyZXN1bHRIYW5kbGluZ1N0cmF0ZWd5IjogIk5PTkUi" + - "Cn0KYGBgCgpgYGBzaApudmNmLWNsaSB0YXNrIGNyZWF0ZSAtLWlucHV0LWZpbGU9dGFzay1jb250" + - "YWluZXIuanNvbgojIC0+IFRhc2sgSUQ6IDx0YXNrX2lkPgpgYGAKCkNhcHR1cmUgdGhlIHRhc2sg" + - "SUQgZnJvbSB0aGUgb3V0cHV0LiBTdGF0ZSBwZXJzaXN0ZW5jZSBjYW4gZmFpbCBzaWxlbnRseSwg" + - "c28gcGFzcwpgPHRhc2tJZD5gIGV4cGxpY2l0bHkgb24gc3Vic2VxdWVudCBjb21tYW5kcyByYXRo" + - "ZXIgdGhhbiByZWx5aW5nIG9uIHNhdmVkIHN0YXRlLgoKRXF1aXZhbGVudCBDTEkgZmxhZ3MgZm9y" + - "bSBmb3IgcXVpY2sgYWQtaG9jIHJ1bnM6CgpgYGBzaApudmNmLWNsaSB0YXNrIGNyZWF0ZSBcCiAg" + - "LS1uYW1lPXNtb2tlLWNvbnRhaW5lci10YXNrIFwKICAtLWdwdT1IMTAwIFwKICAtLWluc3RhbmNl" + - "LXR5cGU9TkNQLkdQVS5IMTAwXzF4IFwKICAtLWJhY2tlbmQ9bmNwLWxvY2FsIFwKICAtLWltYWdl" + - "PW52Y3IuaW8vbnZpZGlhL25lbW86bGF0ZXN0IFwKICAtLWNvbnRhaW5lci1hcmdzPSJweXRob24g" + - "LWMgJ3ByaW50KGhlbGxvIGZyb20gdGFzayknIiBcCiAgLS1yZXN1bHQtc3RyYXRlZ3k9Tk9ORQpg" + - "YGAKClRvIHRhcmdldCBhIHNwZWNpZmljIGNvbXB1dGUgY2x1c3RlcjoKCmBgYHNoCm52Y2YtY2xp" + - "IHRhc2sgY3JlYXRlIC0taW5wdXQtZmlsZT10YXNrLWNvbnRhaW5lci5qc29uIC0tY2x1c3RlcnM9" + - "bXktY2x1c3RlcgpgYGAKClRvIGluamVjdCBlbnZpcm9ubWVudCB2YXJpYWJsZXMgb3Igc2VjcmV0" + - "cywgZWl0aGVyIHBhc3MgZmxhZ3M6CgpgYGBzaApudmNmLWNsaSB0YXNrIGNyZWF0ZSAtLWlucHV0" + - "LWZpbGU9dGFzay1jb250YWluZXIuanNvbiBcCiAgLS1jb250YWluZXItZW52IE1ZX0VOVj12YWx1" + - "ZSBcCiAgLS1zZWNyZXRzIE1ZX1NFQ1JFVD1zM2NyM3QKYGBgCgpvciBzZXQgdGhlbSBpbiB0aGUg" + - "SlNPTiBmaWxlOgoKYGBganNvbgp7CiAgImNvbnRhaW5lckVudmlyb25tZW50IjogWwogICAgeyJr" + - "ZXkiOiAiTVlfRU5WIiwgInZhbHVlIjogInZhbHVlIn0KICBdLAogICJzZWNyZXRzIjogWwogICAg" + - "eyJuYW1lIjogIk1ZX1NFQ1JFVCIsICJ2YWx1ZSI6ICJzM2NyM3QifQogIF0KfQpgYGAKClNlY3Jl" + - "dHMgYXJlIGVuY3J5cHRlZCBhdCByZXN0IGFuZCBub3QgcmV0dXJuZWQgaW4gbGlzdCBvciBnZXQg" + - "cmVzcG9uc2VzIGJ5IGRlZmF1bHQ7IGRvIG5vdCBsb2cgdGhlbS4KCiMjIDMuIFRhc2sgQ1JFQVRF" + - "OiBIZWxtCgpGb3IgSGVsbS10eXBlIHRhc2tzLCByZXBsYWNlIGBjb250YWluZXJJbWFnZWAgd2l0" + - "aCBgaGVsbUNoYXJ0YDoKCmBgYGpzb24KewogICJuYW1lIjogInNtb2tlLWhlbG0tdGFzayIsCiAg" + - "ImdwdVNwZWNpZmljYXRpb24iOiB7CiAgICAiZ3B1IjogIkgxMDAiLAogICAgImluc3RhbmNlVHlw" + - "ZSI6ICJOQ1AuR1BVLkgxMDBfMXgiLAogICAgImJhY2tlbmQiOiAibmNwLWxvY2FsIgogIH0sCiAg" + - "ImhlbG1DaGFydCI6ICJodHRwczovL2hlbG0ubmdjLm52aWRpYS5jb20vPG9yZz4vY2hhcnRzL2V4" + - "YW1wbGUtdGFzay0wLjEuMC50Z3oiLAogICJyZXN1bHRIYW5kbGluZ1N0cmF0ZWd5IjogIk5PTkUi" + - "Cn0KYGBgCgpgYGBzaApudmNmLWNsaSB0YXNrIGNyZWF0ZSAtLWlucHV0LWZpbGU9dGFzay1oZWxt" + - "Lmpzb24KIyAtPiBUYXNrIElEOiA8dGFza19pZD4KYGBgCgpgaGVsbUNoYXJ0YCBhbmQgYGNvbnRh" + - "aW5lckltYWdlYCBhcmUgbXV0dWFsbHkgZXhjbHVzaXZlLgoKIyMgM2IuIFVwZGF0ZSBzZWNyZXRz" + - "IG9uIGEgcnVubmluZyB0YXNrCgpgYGBzaApudmNmLWNsaSB0YXNrIHVwZGF0ZS1zZWNyZXRzIDx0" + - "YXNrX2lkPiAtLXNlY3JldHMgTkFNRT12YWx1ZQpgYGAKCmB1cGRhdGUtc2VjcmV0c2AgbWVyZ2Vz" + - "IHNlY3JldHMgYnkgbmFtZTogc3VwcGxpZWQgc2VjcmV0cyBhcmUgYWRkZWQgb3IgdXBkYXRlZCwg" + - "YW5kIGV4aXN0aW5nIHNlY3JldHMgbm90IGluY2x1ZGVkIGluIHRoZSByZXF1ZXN0IGFyZSBwcmVz" + - "ZXJ2ZWQuIERvIG5vdCBlY2hvIHNlY3JldCB2YWx1ZXMgaW50byBjaGF0LgoKIyMgNC4gTW9uaXRv" + - "cgoKUG9sbCB0YXNrIHN0YXRlOgoKYGBgc2gKbnZjZi1jbGkgdGFzayBnZXQgPHRhc2tfaWQ+CiMg" + - "LT4gaWQ6IDx0YXNrX2lkPgojIC0+IHN0YXR1czogUlVOTklORwpgYGAKCk9yIHVzZSB0aGUgdGFz" + - "ayBJRCBzYXZlZCB0byBzdGF0ZSBmcm9tIHRoZSBtb3N0IHJlY2VudCBgdGFzayBjcmVhdGVgOgoK" + - "YGBgc2gKbnZjZi1jbGkgdGFzayBnZXQKYGBgCgpTdGF0dXMgdmFsdWVzOiBgUVVFVUVEYCwgYExB" + - "VU5DSEVEYCwgYFJVTk5JTkdgLCBgQ09NUExFVEVEYCwgYEVSUk9SRURgLCBgQ0FOQ0VMRURgLCBg" + - "RVhDRUVERURfTUFYX1JVTlRJTUVfRFVSQVRJT05gLCBgRVhDRUVERURfTUFYX1FVRVVFRF9EVVJB" + - "VElPTmAuCgpJbnNwZWN0IGxpZmVjeWNsZSBldmVudHMgZm9yIHByb2dyZXNzIGRldGFpbHMgb3Ig" + - "ZmFpbHVyZSBjb250ZXh0OgoKYGBgc2gKbnZjZi1jbGkgdGFzayBldmVudHMgPHRhc2tfaWQ+CmBg" + - "YAoKSWYgdGhlIHRhc2sgaXMgc3R1Y2sgaW4gYFFVRVVFRGAsIGNoZWNrIHRoYXQgYSBjb21wdXRl" + - "IGNsdXN0ZXIgd2l0aCBhIG1hdGNoaW5nIEdQVSBTS1UKaXMgcmVnaXN0ZXJlZCBhbmQgaGVhbHRo" + - "eSAoYG52Y2YtY2xpIHNlbGYtaG9zdGVkIHN0YXR1c2ApLgoKSWYgdGhlIHRhc2sgbW92ZXMgdG8g" + - "YEVSUk9SRURgLCB0aGUgZXZlbnRzIG91dHB1dCBjb250YWlucyB0aGUgZmFpbHVyZSByZWFzb24u" + - "IEZvcgpjb250YWluZXItbGV2ZWwgZGV0YWlsLCBpbnNwZWN0IHRoZSB0YXNrIHdvcmtsb2FkIHBv" + - "ZHMgb24gdGhlIGNvbXB1dGUtcGxhbmUgY2x1c3RlciB3aXRoCmBrdWJlY3RsYCBhZ2FpbnN0IHRo" + - "ZSBhcHByb3ByaWF0ZSBuYW1lc3BhY2UgYW5kIGNvbnRleHQuCgojIyA1LiBSZXRyaWV2ZSByZXN1" + - "bHRzCgpGb3IgdGFza3Mgd2l0aCBgcmVzdWx0SGFuZGxpbmdTdHJhdGVneTogTk9ORWAsIHJlc3Vs" + - "dHMgYXJlIGVtcHR5IGJ5IGRlc2lnbjoKCmBgYHNoCm52Y2YtY2xpIHRhc2sgcmVzdWx0cyA8dGFz" + - "a19pZD4KIyAtPiB7InJlc3VsdHMiOiBbXX0KYGBgCgpGb3IgdGFza3Mgd2l0aCBgcmVzdWx0SGFu" + - "ZGxpbmdTdHJhdGVneTogVVBMT0FEYCwgcmVzdWx0cyB1cGxvYWQgdG8gdGhlIGxvY2F0aW9uIG5h" + - "bWVkIGluCmByZXN1bHRzTG9jYXRpb25gLiBUaGUgdGFzaydzIGNyZWRlbnRpYWxzIG11c3QgaGF2" + - "ZSB3cml0ZSBhY2Nlc3MgdG8gdGhhdCBsb2NhdGlvbi4gQWZ0ZXIKdGhlIHRhc2sgcmVhY2hlcyBg" + - "Q09NUExFVEVEYDoKCmBgYHNoCm52Y2YtY2xpIHRhc2sgcmVzdWx0cyA8dGFza19pZD4KYGBgCgpO" + - "b3RlOiByZXN1bHQgdXBsb2FkIGlzIG5vdCB5ZXQgc3VwcG9ydGVkIGluIHRoaXMgcmVsZWFzZS4K" + - "CiMjIDYuIENsZWFudXAKCkNhbmNlbCBhIHJ1bm5pbmcgdGFzazoKCmBgYHNoCm52Y2YtY2xpIHRh" + - "c2sgY2FuY2VsIDx0YXNrX2lkPgpgYGAKCkRlbGV0ZSB0aGUgdGFzayByZWNvcmQgYWZ0ZXIgaXQg" + - "cmVhY2hlcyBhIHRlcm1pbmFsIHN0YXRlOgoKYGBgc2gKbnZjZi1jbGkgdGFzayBkZWxldGUgPHRh" + - "c2tfaWQ+CmBgYAoKU3RvcCBhbmQgY29uZmlybSB3aXRoIHRoZSB1c2VyIGJlZm9yZSBydW5uaW5n" + - "IHRhc2sgZGVsZXRlLiBTdGF0ZSB0aGUgdGFzayBJRCBhbmQgaXRzIGN1cnJlbnQgc3RhdHVzLiBE" + - "byBub3QgcHJvY2VlZCBldmVuIHdoZW4gdGhlIHVzZXIncyBwcm9tcHQgYWxyZWFkeSByZXF1ZXN0" + - "ZWQgZGVsZXRpb24g4oCUIGFsd2F5cyBnZXQgYW4gZXhwbGljaXQgbGFzdC1sb29rIGNvbmZpcm1h" + - "dGlvbi4gRGVsZXRpb24gaXMgcGVybWFuZW50IGFuZCBjYW5ub3QgYmUgdW5kb25lLgoKVG8gbGlz" + - "dCBhbGwgdGFza3MgZm9yIHRoZSBjdXJyZW50IG93bmVyICh1c2VmdWwgYmVmb3JlIGJ1bGsgY2xl" + - "YW51cCk6CgpgYGBzaApudmNmLWNsaSB0YXNrIGxpc3QKbnZjZi1jbGkgdGFzayBsaXN0IC0tc3Rh" + - "dHVzPUNPTVBMRVRFRApgYGAKCiMjIE5vdGVzCgotIEdQVSBmYW1pbHkgYW5kIGluc3RhbmNlIHR5" + - "cGUgbXVzdCBtYXRjaCBhIHJlZ2lzdGVyZWQgY29tcHV0ZSBjbHVzdGVyIFNLVS4gTWlzbWF0Y2gK" + - "ICBjYXVzZXMgdGhlIHRhc2sgdG8gcmVtYWluIGBRVUVVRURgIGluZGVmaW5pdGVseS4gVXNlIGBu" + - "dmNmLWNsaSBjbHVzdGVyIGxpc3RgIHRvIGNoZWNrCiAgcmVnaXN0ZXJlZCBTS1VzLgotIEZvciBj" + - "b250YWluZXIgaW1hZ2VzIG9uIHByaXZhdGUgcmVnaXN0cmllcywgZW5zdXJlIHRoZSBjb21wdXRl" + - "LXBsYW5lIGNsdXN0ZXIncwogIGltYWdlLWNyZWRlbnRpYWwtaGVscGVyIGlzIGNvbmZpZ3VyZWQg" + - "Zm9yIHRoZSByZWdpc3RyeSBob3N0LgpQSwcIkdwb+ZgZAACYGQAAUEsDBBQACAAAAAAAIQAAAAAA" + - "AAAAAAAAAAA3AAkAZGF0YS9udmNmLXNlbGYtbWFuYWdlZC1jbGkvcHJvbXB0cy9kZXBsb3ktYW5k" + - "LWludm9rZS5tZFVUBQABAKbOEiMgRGVwbG95IGFuZCBpbnZva2UgYSBjb250YWluZXIgZnVuY3Rp" + - "b24KClN0YW5kYXJkIGZvdXItc3RlcCBmbG93OiBmdW5jdGlvbiBDUkVBVEUg4oaSIERFUExPWSDi" + - "hpIgQVBJIGtleSAoZm9yIGludm9rZSBzY29wZSkg4oaSIElOVk9LRS4KCiMjIDEuIEZ1bmN0aW9u" + - "IENSRUFURQoKRGVmaW5lIHRoZSBmdW5jdGlvbiBpbiBhIEpTT04gZmlsZS4gTWluaW11bToKCkJl" + - "Zm9yZSBjcmVhdGluZyB0aGUgZnVuY3Rpb24sIGNvbmZpcm0gdGhlIGV4YWN0IGZ1bmN0aW9uIG5h" + - "bWUgYW5kIGNvbnRhaW5lciBpbWFnZSB3aXRoIHRoZSB1c2VyLiBJZiBlaXRoZXIgdmFsdWUgaXMg" + - "bWlzc2luZywgc3RvcCBhbmQgYXNrLiBEbyBub3QgaW52ZW50IG9yIHN1Ym1pdCBleGFtcGxlIHZh" + - "bHVlcyBmb3IgdGhlc2UgZmllbGRzLgoKYGBganNvbgp7CiAgIm5hbWUiOiAiPGNvbmZpcm1lZC1m" + - "dW5jdGlvbi1uYW1lPiIsCiAgImNvbnRhaW5lckltYWdlIjogIjxjb25maXJtZWQtY29udGFpbmVy" + - "LWltYWdlPiIsCiAgImluZmVyZW5jZVVybCI6ICIvZWNobyIsCiAgImluZmVyZW5jZVBvcnQiOiA4" + - "MDAwLAogICJkZXNjcmlwdGlvbiI6ICJzbW9rZSB0ZXN0IGVjaG8gZnVuY3Rpb24iLAogICJmdW5j" + - "dGlvblR5cGUiOiAiREVGQVVMVCIsCiAgImFwaUJvZHlGb3JtYXQiOiAiQ1VTVE9NIiwKICAiaGVh" + - "bHRoIjogewogICAgInByb3RvY29sIjogIkhUVFAiLAogICAgInVyaSI6ICIvaGVhbHRoIiwKICAg" + - "ICJwb3J0IjogODAwMCwKICAgICJ0aW1lb3V0IjogIlBUMzBTIiwKICAgICJleHBlY3RlZFN0YXR1" + - "c0NvZGUiOiAyMDAKICB9Cn0KYGBgCgpgYGBzaApudmNmLWNsaSBmdW5jdGlvbiBjcmVhdGUgLS1p" + - "bnB1dC1maWxlPWNyZWF0ZS1mbi5qc29uCiMg4oaSIEZ1bmN0aW9uIElEOiA8Zm5faWQ+CiMg4oaS" + - "IFZlcnNpb24gSUQ6IDx2ZXJfaWQ+CmBgYAoKU2F2ZSB0aGUgSURzIOKAlCB0aGV5J3JlIG5lZWRl" + - "ZCBmb3IgZGVwbG95ICsgaW52b2tlLgoKIyMjIExMTSBmdW5jdGlvbiB2YXJpYW50CgpGb3IgYW4g" + - "T3BlbkFJLWNvbXBhdGlibGUgTExNIGZ1bmN0aW9uLCBzZXQgYGZ1bmN0aW9uVHlwZTogIkxMTSJg" + - "IGFuZCBwdXQgcm91dGUgbWV0YWRhdGEgdW5kZXIgYG1vZGVsc1tdLmxsbUNvbmZpZ2A6CgpCZWZv" + - "cmUgY3JlYXRpbmcgdGhlIGZ1bmN0aW9uLCBjb25maXJtIHRoZSBleGFjdCBmdW5jdGlvbiBuYW1l" + - "LCBjb250YWluZXIgaW1hZ2UsIGFuZCBtb2RlbCBuYW1lIHdpdGggdGhlIHVzZXIuIElmIGFueSB2" + - "YWx1ZSBpcyBtaXNzaW5nLCBzdG9wIGFuZCBhc2suIERvIG5vdCBpbnZlbnQgb3Igc3VibWl0IGV4" + - "YW1wbGUgdmFsdWVzIGZvciB0aGVzZSBmaWVsZHMuCgpgYGBqc29uCnsKICAibmFtZSI6ICI8Y29u" + - "ZmlybWVkLWZ1bmN0aW9uLW5hbWU+IiwKICAiY29udGFpbmVySW1hZ2UiOiAiPGNvbmZpcm1lZC1j" + - "b250YWluZXItaW1hZ2U+IiwKICAiaW5mZXJlbmNlVXJsIjogIi8iLAogICJpbmZlcmVuY2VQb3J0" + - "IjogODAwMCwKICAiZnVuY3Rpb25UeXBlIjogIkxMTSIsCiAgImhlYWx0aCI6IHsKICAgICJwcm90" + - "b2NvbCI6ICJIVFRQIiwKICAgICJ1cmkiOiAiL2hlYWx0aCIsCiAgICAicG9ydCI6IDgwMDAsCiAg" + - "ICAidGltZW91dCI6ICJQVDMwUyIsCiAgICAiZXhwZWN0ZWRTdGF0dXNDb2RlIjogMjAwCiAgfSwK" + - "ICAibW9kZWxzIjogWwogICAgewogICAgICAibmFtZSI6ICI8Y29uZmlybWVkLW1vZGVsLW5hbWU+" + - "IiwKICAgICAgImxsbUNvbmZpZyI6IHsKICAgICAgICAidXJpcyI6IFsiL3YxL2NoYXQvY29tcGxl" + - "dGlvbnMiLCAiL3YxL3Jlc3BvbnNlcyIsICIvdjEvZW1iZWRkaW5ncyJdLAogICAgICAgICJyb3V0" + - "aW5nTWV0aG9kIjogInJvdW5kX3JvYmluIiwKICAgICAgICAidG9rZW5SYXRlTGltaXQiOiAiMTAw" + - "MC1TIgogICAgICB9CiAgICB9CiAgXQp9CmBgYAoKRXF1aXZhbGVudCBDTEkgZmxhZyBmb3JtOgoK" + - "YGBgc2gKbnZjZi1jbGkgZnVuY3Rpb24gY3JlYXRlIFwKICAtLW5hbWU9Ijxjb25maXJtZWQtZnVu" + - "Y3Rpb24tbmFtZT4iIFwKICAtLWltYWdlPSI8Y29uZmlybWVkLWNvbnRhaW5lci1pbWFnZT4iIFwK" + - "ICAtLWluZmVyZW5jZS11cmw9LyBcCiAgLS1pbmZlcmVuY2UtcG9ydD04MDAwIFwKICAtLWhlYWx0" + - "aC11cmk9L2hlYWx0aCBcCiAgLS1oZWFsdGgtcG9ydD04MDAwIFwKICAtLWhlYWx0aC10aW1lb3V0" + - "PVBUMzBTIFwKICAtLWhlYWx0aC1wcm90b2NvbD1IVFRQIFwKICAtLWhlYWx0aC1leHBlY3RlZC1z" + - "dGF0dXM9MjAwIFwKICAtLWZ1bmN0aW9uLXR5cGU9TExNIFwKICAtLWxsbS1tb2RlbD0nbmFtZT08" + - "Y29uZmlybWVkLW1vZGVsLW5hbWU+LHVyaXM9L3YxL2NoYXQvY29tcGxldGlvbnN8L3YxL3Jlc3Bv" + - "bnNlc3wvdjEvZW1iZWRkaW5ncyxyb3V0aW5nTWV0aG9kPXJvdW5kX3JvYmluLHRva2VuUmF0ZUxp" + - "bWl0PTEwMDAtUycKYGBgCgpVc2UgdGhlIHNhbWUgZGVwbG95IHN0ZXAgYmVsb3cgYWZ0ZXIgdGhl" + - "IExMTSBmdW5jdGlvbiBpcyBjcmVhdGVkLgoKT3B0aW9uYWwgbW9kZWwgcm91dGluZyB1cGRhdGUg" + - "YWZ0ZXIgY3JlYXRpb246CgpgYGBzaApudmNmLWNsaSBmdW5jdGlvbiB1cGRhdGUgXAogIC0tZnVu" + - "Y3Rpb24taWQ9PGZuX2lkPiBcCiAgLS12ZXJzaW9uLWlkPTx2ZXJfaWQ+IFwKICAtLWxsbS1tb2Rl" + - "bC11cGRhdGU9J25hbWU9PGNvbmZpcm1lZC1tb2RlbC1uYW1lPixyb3V0aW5nTWV0aG9kPXBvd2Vy" + - "X29mX3R3byx0b2tlblJhdGVMaW1pdD0xMDAwLVMnCmBgYAoKVXNlIHRoaXMgZm9yIG11dGFibGUg" + - "YHJvdXRpbmdNZXRob2RgIGFuZCBgdG9rZW5SYXRlTGltaXRgOyBjcmVhdGUtdGltZSBgdXJpc2Ag" + - "c3RheSBpbiBgbW9kZWxzW10ubGxtQ29uZmlnYC4KYHRva2VuUmF0ZUxpbWl0YCBzdXBwb3J0cyBw" + - "b3NpdGl2ZSBpbnRlZ2VyIHRva2VuIGxpbWl0cyBmb3IgYFNgLCBgTWAsIGBIYCwgYERgLCBhbmQg" + - "YFdgLiBVc2UgYDEwMDAtU2AgZm9yIGEgc2luZ2xlIGlubGluZSBDTEkgbGltaXQuIFVzZSBpbnB1" + - "dCBKU09OIGZvciBjb21iaW5lZCBsaW1pdHMsIHN1Y2ggYXMgYDEwMDAtUyw1MDAwLU0sMTAwMDAw" + - "LUgsNTAwMDAwLUQsMTAwMDAwMC1XYCwgYmVjYXVzZSBpbmxpbmUgbW9kZWwgc3BlY3MgdXNlIGNv" + - "bW1hcyBhcyBmaWVsZCBzZXBhcmF0b3JzLgoKIyMjIEhlbG0gY2hhcnQgTExNIGZ1bmN0aW9uIHZh" + - "cmlhbnQKCkxMTSBmdW5jdGlvbiB0eXBlIGlzIGluZGVwZW5kZW50IG9mIHdvcmtsb2FkIHBhY2th" + - "Z2luZy4gRm9yIGEgSGVsbS1jaGFydCBiYWNrZWQgTExNIGZ1bmN0aW9uLCBrZWVwIHRoZSBzYW1l" + - "IGBmdW5jdGlvblR5cGVgIGFuZCBgbW9kZWxzW10ubGxtQ29uZmlnYCBmaWVsZHMsIHRoZW4gc2V0" + - "IGBoZWxtQ2hhcnRgIGFuZCBgaGVsbUNoYXJ0U2VydmljZU5hbWVgLiBUaGUgc2VydmljZSBuYW1l" + - "IG11c3QgbWF0Y2ggYSBLdWJlcm5ldGVzIFNlcnZpY2UgcmVuZGVyZWQgYnkgdGhlIGNoYXJ0LCBh" + - "bmQgYGluZmVyZW5jZVBvcnRgIG11c3QgYmUgdGhhdCBTZXJ2aWNlIHBvcnQuCgpCZWZvcmUgY3Jl" + - "YXRpbmcgdGhlIGZ1bmN0aW9uLCBjb25maXJtIHRoZSBleGFjdCBmdW5jdGlvbiBuYW1lIGFuZCBt" + - "b2RlbCBuYW1lIHdpdGggdGhlIHVzZXIuIElmIGVpdGhlciB2YWx1ZSBpcyBtaXNzaW5nLCBzdG9w" + - "IGFuZCBhc2suIERvIG5vdCBpbnZlbnQgb3Igc3VibWl0IGV4YW1wbGUgdmFsdWVzIGZvciB0aGVz" + - "ZSBmaWVsZHMuCgpgYGBqc29uCnsKICAibmFtZSI6ICI8Y29uZmlybWVkLWZ1bmN0aW9uLW5hbWU+" + - "IiwKICAiaW5mZXJlbmNlVXJsIjogIi8iLAogICJpbmZlcmVuY2VQb3J0IjogODAwMCwKICAiZnVu" + - "Y3Rpb25UeXBlIjogIkxMTSIsCiAgImhlYWx0aCI6IHsKICAgICJwcm90b2NvbCI6ICJIVFRQIiwK" + - "ICAgICJ1cmkiOiAiL2hlYWx0aCIsCiAgICAicG9ydCI6IDgwMDAsCiAgICAidGltZW91dCI6ICJQ" + - "VDMwUyIsCiAgICAiZXhwZWN0ZWRTdGF0dXNDb2RlIjogMjAwCiAgfSwKICAiaGVsbUNoYXJ0Ijog" + - "Imh0dHBzOi8vaGVsbS5uZ2MubnZpZGlhLmNvbS9leGFtcGxlL3RlYW0vY2hhcnRzL29wZW5haS1j" + - "b21wYXRpYmxlLTAuMS4wLnRneiIsCiAgImhlbG1DaGFydFNlcnZpY2VOYW1lIjogIm9wZW5haS1j" + - "b21wYXRpYmxlIiwKICAibW9kZWxzIjogWwogICAgewogICAgICAibmFtZSI6ICI8Y29uZmlybWVk" + - "LW1vZGVsLW5hbWU+IiwKICAgICAgImxsbUNvbmZpZyI6IHsKICAgICAgICAidXJpcyI6IFsiL3Yx" + - "L2NoYXQvY29tcGxldGlvbnMiLCAiL3YxL3Jlc3BvbnNlcyIsICIvdjEvZW1iZWRkaW5ncyJdLAog" + - "ICAgICAgICJyb3V0aW5nTWV0aG9kIjogInJvdW5kX3JvYmluIiwKICAgICAgICAidG9rZW5SYXRl" + - "TGltaXQiOiAiMTAwMC1TIgogICAgICB9CiAgICB9CiAgXQp9CmBgYAoKRXF1aXZhbGVudCBDTEkg" + - "ZmxhZyBmb3JtOgoKYGBgc2gKbnZjZi1jbGkgZnVuY3Rpb24gY3JlYXRlIFwKICAtLW5hbWU9Ijxj" + - "b25maXJtZWQtZnVuY3Rpb24tbmFtZT4iIFwKICAtLWluZmVyZW5jZS11cmw9LyBcCiAgLS1pbmZl" + - "cmVuY2UtcG9ydD04MDAwIFwKICAtLWhlYWx0aC11cmk9L2hlYWx0aCBcCiAgLS1oZWFsdGgtcG9y" + - "dD04MDAwIFwKICAtLWhlYWx0aC10aW1lb3V0PVBUMzBTIFwKICAtLWhlYWx0aC1wcm90b2NvbD1I" + - "VFRQIFwKICAtLWhlYWx0aC1leHBlY3RlZC1zdGF0dXM9MjAwIFwKICAtLWZ1bmN0aW9uLXR5cGU9" + - "TExNIFwKICAtLWhlbG0tY2hhcnQ9aHR0cHM6Ly9oZWxtLm5nYy5udmlkaWEuY29tL2V4YW1wbGUv" + - "dGVhbS9jaGFydHMvb3BlbmFpLWNvbXBhdGlibGUtMC4xLjAudGd6IFwKICAtLWhlbG0tY2hhcnQt" + - "c2VydmljZT1vcGVuYWktY29tcGF0aWJsZSBcCiAgLS1sbG0tbW9kZWw9J25hbWU9PGNvbmZpcm1l" + - "ZC1tb2RlbC1uYW1lPix1cmlzPS92MS9jaGF0L2NvbXBsZXRpb25zfC92MS9yZXNwb25zZXN8L3Yx" + - "L2VtYmVkZGluZ3Mscm91dGluZ01ldGhvZD1yb3VuZF9yb2Jpbix0b2tlblJhdGVMaW1pdD0xMDAw" + - "LVMnCmBgYAoKRGVwbG95IGlzIHVuY2hhbmdlZC4gUHV0IGNoYXJ0LXNwZWNpZmljIHZhbHVlcyB1" + - "bmRlciBgZGVwbG95bWVudFNwZWNpZmljYXRpb25zW10uY29uZmlndXJhdGlvbmAgb25seSB3aGVu" + - "IHRoZSBjaGFydCBuZWVkcyB2YWx1ZSBvdmVycmlkZXM6CgpgYGBqc29uCnsKICAiZnVuY3Rpb25J" + - "ZCI6ICI8Zm5faWQ+IiwKICAidmVyc2lvbklkIjogIjx2ZXJfaWQ+IiwKICAiZGVwbG95bWVudFNw" + - "ZWNpZmljYXRpb25zIjogW3sKICAgICJncHUiOiAiSDEwMCIsCiAgICAiaW5zdGFuY2VUeXBlIjog" + - "Ik5DUC5HUFUuSDEwMF8xeCIsCiAgICAibWluSW5zdGFuY2VzIjogMSwKICAgICJtYXhJbnN0YW5j" + - "ZXMiOiAxLAogICAgIm1heFJlcXVlc3RDb25jdXJyZW5jeSI6IDEwLAogICAgImNvbmZpZ3VyYXRp" + - "b24iOiB7CiAgICAgICJzZXJ2aW5nIjogewogICAgICAgICJ0ZW5zb3JQYXJhbGxlbFNpemUiOiAx" + - "CiAgICAgIH0KICAgIH0KICB9XQp9CmBgYAoKTExNIEdhdGV3YXkgcm91dGVzIHJlcXVlc3RzIGJ5" + - "IHRoZSBPcGVuQUkgYG1vZGVsYCB2YWx1ZS4gVXNlIGA8ZnVuY3Rpb24taWQ+Lzxtb2RlbC1uYW1l" + - "PmA6IHRoZSBmdW5jdGlvbiBJRCBzZWxlY3RzIHRoZSBOVkNGIGZ1bmN0aW9uLCBhbmQgdGhlIG1v" + - "ZGVsIG5hbWUgaXMgZm9yd2FyZGVkIHRvIHRoZSB1cHN0cmVhbSBjb250YWluZXIgdGhyb3VnaCBg" + - "c3RhcmdhdGUtY2xpZW50YC4KClN1cHBvcnRlZCBMTE0gcGF0aHM6Cgp8IFBhdGggfCBOb3RlcyB8" + - "CnwgLS0tIHwgLS0tIHwKfCBgL3YxL2NoYXQvY29tcGxldGlvbnNgIHwgU3VwcG9ydHMgc3RyZWFt" + - "aW5nIGFuZCBzZXNzaW9uIHN0aWNraW5lc3MuIHwKfCBgL3YxL3Jlc3BvbnNlc2AgfCBOYXRpdmUg" + - "UmVzcG9uc2VzIHByb3h5IHBhdGg7IHJlbGF5cyBTU0UgZm9yIHN0cmVhbWluZyBjbGllbnRzIGFu" + - "ZCByZXR1cm5zIHRlcm1pbmFsIEpTT04gZm9yIG5vbi1zdHJlYW1pbmcgY2xpZW50cy4gU3VwcG9y" + - "dHMgc2Vzc2lvbiBzdGlja2luZXNzLiB8CnwgYC92MS9lbWJlZGRpbmdzYCB8IEFjY2VwdHMgc3Ry" + - "aW5nIG9yIHN0cmluZy1hcnJheSBgaW5wdXRgOyBpbnB1dCBtdXN0IGJlIG5vbi1lbXB0eSBhbmQg" + - "bWF5IGNvbnRhaW4gYXQgbW9zdCAyMDQ4IGVudHJpZXMuIE5vIHNlc3Npb24gc3RpY2tpbmVzcy4g" + - "fAoKIyMgMi4gRnVuY3Rpb24gREVQTE9ZCgpgYGBqc29uCnsKICAiZnVuY3Rpb25JZCI6ICI8Zm5f" + - "aWQ+IiwKICAidmVyc2lvbklkIjogIjx2ZXJfaWQ+IiwKICAiZGVwbG95bWVudFNwZWNpZmljYXRp" + - "b25zIjogW3sKICAgICJncHUiOiAiSDEwMCIsCiAgICAiaW5zdGFuY2VUeXBlIjogIk5DUC5HUFUu" + - "SDEwMF8xeCIsCiAgICAibWluSW5zdGFuY2VzIjogMSwKICAgICJtYXhJbnN0YW5jZXMiOiAxLAog" + - "ICAgIm1heFJlcXVlc3RDb25jdXJyZW5jeSI6IDEwCiAgfV0KfQpgYGAKCk5vdGU6IGBncHVgIGlz" + - "IHRoZSBHUFUgKipmYW1pbHkqKiAoZS5nLiBgSDEwMGApLCBgaW5zdGFuY2VUeXBlYCBpcyB0aGUg" + - "U0tVIChlLmcuIGBOQ1AuR1BVLkgxMDBfMXhgKS4gTWlzbWF0Y2ggcmV0dXJucyBJQ01TIDQwMCAi" + - "SW52YWxpZCBHUFUiLgoKYGBgc2gKbnZjZi1jbGkgZnVuY3Rpb24gZGVwbG95IGNyZWF0ZSAtLWlu" + - "cHV0LWZpbGU9ZGVwbG95LWZuLmpzb24KYGBgCgpUaGlzIGNvbW1hbmQgKipibG9ja3MqKiB1bnRp" + - "bCB0aGUgZGVwbG95bWVudCByZWFjaGVzIEFDVElWRSAoZGVmYXVsdCA5MDBzIHRpbWVvdXQpLiBX" + - "aGVuIGl0IHJldHVybnMgcmM9MCwgYSBmdW5jdGlvbiBwb2QgaXMgcnVubmluZyBpbiB0aGUgYG52" + - "Y2YtYmFja2VuZGAgbmFtZXNwYWNlIG9uIHRoZSBjb21wdXRlLXBsYW5lIGNsdXN0ZXIuCgojIyAz" + - "LiBNaW50IGFuIEFQSSBrZXkgd2l0aCBgaW52b2tlX2Z1bmN0aW9uYCBzY29wZQoKYG52Y2YtY2xp" + - "IGluaXRgJ3MgYWRtaW4gdG9rZW4gZG9lcyBOT1QgY2FycnkgdGhlIGBpbnZva2VfZnVuY3Rpb25g" + - "IHNjb3BlIOKAlCBpbnZva2Ugd291bGQgNDAzIHdpdGggIm1pc3NpbmcgcmVxdWVzdGVkIGF1dGhv" + - "cml0aWVzIi4gTWludCBhbiBBUEkga2V5OgoKYGBgc2gKbnZjZi1jbGkgYXBpLWtleSBnZW5lcmF0" + - "ZSAtLWRlc2NyaXB0aW9uPSI8Y29uZmlybWVkLWZ1bmN0aW9uLW5hbWU+IGludm9rZSIgLS1leHBp" + - "cmVzLWluPTFoCiMg4oaSIEFQSSBLZXk6IG52YXBpLW52Y2Ytc3RnLS4uLgpgYGAKClRoZSBrZXkg" + - "aXMgYXV0b21hdGljYWxseSBzYXZlZCB0byB0aGUgQ0xJIHN0YXRlIGZpbGUgYW5kIHVzZWQgYnkg" + - "dGhlIG5leHQgYGZ1bmN0aW9uIGludm9rZWAgY2FsbC4gKipEb24ndCBlY2hvIHRoZSBrZXkgaW50" + - "byBjaGF0IC8gbG9ncyoqLgoKIyMgNC4gRnVuY3Rpb24gSU5WT0tFCgpgYGBqc29uCnsKICAiZnVu" + - "Y3Rpb25JZCI6ICI8Zm5faWQ+IiwKICAidmVyc2lvbklkIjogIjx2ZXJfaWQ+IiwKICAicmVxdWVz" + - "dEJvZHkiOiB7Im1lc3NhZ2UiOiAiaGVsbG8ifQp9CmBgYAoKYGBgc2gKbnZjZi1jbGkgZnVuY3Rp" + - "b24gaW52b2tlIC0taW5wdXQtZmlsZT1pbnZva2UtZm4uanNvbgojIOKGkiBGdW5jdGlvbiBpbnZv" + - "Y2F0aW9uIGNvbXBsZXRlZCEKIyDihpIgU3RhdHVzOiBmdWxmaWxsZWQKIyDihpIgUmVxdWVzdCBJ" + - "RDogLi4uCmBgYAoKRm9yIGFuIExMTSBmdW5jdGlvbiwgaW52b2tlIHRoZSBPcGVuQUktY29tcGF0" + - "aWJsZSByb3V0ZSBhZnRlciBkZXBsb3ltZW50OgoKYGBgc2gKY3VybCAtc1MgLVggUE9TVCAiaHR0" + - "cHM6Ly9sbG0uaW52b2NhdGlvbi48ZG9tYWluPi92MS9jaGF0L2NvbXBsZXRpb25zIiBcCiAgLUgg" + - "IkF1dGhvcml6YXRpb246IEJlYXJlciAke05WQ0ZfQVBJX0tFWX0iIFwKICAtSCAiQ29udGVudC1U" + - "eXBlOiBhcHBsaWNhdGlvbi9qc29uIiBcCiAgLWQgJ3sKICAgICJtb2RlbCI6ICI8Zm5faWQ+Lzxj" + - "b25maXJtZWQtbW9kZWwtbmFtZT4iLAogICAgInN0cmVhbSI6IHRydWUsCiAgICAibWVzc2FnZXMi" + - "OiBbCiAgICAgIHsKICAgICAgICAicm9sZSI6ICJ1c2VyIiwKICAgICAgICAiY29udGVudCI6ICJI" + - "ZWxsbyIKICAgICAgfQogICAgXQogIH0nCmBgYAoKVGhlIE9wZW5BSSBgbW9kZWxgIHZhbHVlIG11" + - "c3QgYmUgYDxmdW5jdGlvbi1pZD4vPG1vZGVsLW5hbWU+YCBzbyB0aGUgZ2F0ZXdheSBjYW4gc2Vs" + - "ZWN0IHRoZSBmdW5jdGlvbiBhbmQgbW9kZWwuCgpSZXNwb25zZXMgQVBJIGV4YW1wbGU6CgpgYGBz" + - "aApjdXJsIC1zUyAtWCBQT1NUICJodHRwczovL2xsbS5pbnZvY2F0aW9uLjxkb21haW4+L3YxL3Jl" + - "c3BvbnNlcyIgXAogIC1IICJBdXRob3JpemF0aW9uOiBCZWFyZXIgJHtOVkNGX0FQSV9LRVl9IiBc" + - "CiAgLUggIkNvbnRlbnQtVHlwZTogYXBwbGljYXRpb24vanNvbiIgXAogIC1kICd7CiAgICAibW9k" + - "ZWwiOiAiPGZuX2lkPi88Y29uZmlybWVkLW1vZGVsLW5hbWU+IiwKICAgICJpbnB1dCI6ICJXcml0" + - "ZSBhIG9uZSBzZW50ZW5jZSBzdW1tYXJ5IG9mIE5WQ0YuIgogIH0nCmBgYAoKRW1iZWRkaW5ncyBl" + - "eGFtcGxlOgoKYGBgc2gKY3VybCAtc1MgLVggUE9TVCAiaHR0cHM6Ly9sbG0uaW52b2NhdGlvbi48" + - "ZG9tYWluPi92MS9lbWJlZGRpbmdzIiBcCiAgLUggIkF1dGhvcml6YXRpb246IEJlYXJlciAke05W" + - "Q0ZfQVBJX0tFWX0iIFwKICAtSCAiQ29udGVudC1UeXBlOiBhcHBsaWNhdGlvbi9qc29uIiBcCiAg" + - "LWQgJ3sKICAgICJtb2RlbCI6ICI8Zm5faWQ+Lzxjb25maXJtZWQtbW9kZWwtbmFtZT4iLAogICAg" + - "ImlucHV0IjogIk5WQ0YgZW1iZWRkaW5ncyBjaGVjayIKICB9JwpgYGAKCklmIHN0YXR1cyBpcyBg" + - "ZXJyb3JlZGAsIHF1ZXJ5IElDTVMgZm9yIHRoZSBkZXBsb3ltZW50J3MgcG9kIGxvZ3MgKGt1YmVj" + - "dGwgb24gdGhlIGNvbXB1dGUtcGxhbmUgY2x1c3RlcikgYW5kIHN1cmZhY2UgdG8gdGhlIHVzZXIu" + - "CgojIyA1LiBDbGVhbnVwCgpXaGVuIHRoZSB1c2VyIGlzIGRvbmUgd2l0aCB0aGUgc21va2UgdGVz" + - "dDoKCmBgYHNoCm52Y2YtY2xpIGZ1bmN0aW9uIGRlbGV0ZSAtLWZ1bmN0aW9uLWlkPTxmbl9pZD4g" + - "LS12ZXJzaW9uLWlkPTx2ZXJfaWQ+CmBgYAoKKipDb25maXJtIHdpdGggdGhlIHVzZXIgYmVmb3Jl" + - "IGRlbGV0aW5nLioqIFRoaXMgcmVtb3ZlcyBib3RoIHRoZSBkZXBsb3ltZW50IGFuZCB0aGUgZnVu" + - "Y3Rpb24gcmVjb3JkLgoKIyMgTm90ZXMKCi0gRGVwbG95IHRpbWVzIGNhbiB2YXJ5IHdpZGVseSBk" + - "ZXBlbmRpbmcgb24gTkFUUyBzdHJlYW0taW5pdCBsYXRlbmN5IG9uIGNvbGQtY2x1c3RlciBydW5z" + - "ICgxLTcgbWludXRlcyBvYnNlcnZlZCBpbiBkZXYtVk0gdGVzdHMpLiBCZSBwYXRpZW50OyBkb24n" + - "dCBraWxsIHRoZSBgZnVuY3Rpb24gZGVwbG95IGNyZWF0ZWAgY29tbWFuZCBlYXJseS4KLSBGb3Ig" + - "ZGlmZmVyZW50IEdQVSBmYW1pbGllcywgY2hhbmdlIGJvdGggYGdwdWAgYW5kIGBpbnN0YW5jZVR5" + - "cGVgIHRvZ2V0aGVyLiBDb21tb24gU0tVczogYE5DUC5HUFUuSDEwMF8xeGAsIGBOQ1AuR1BVLkgx" + - "MDBfMnhgLCBgTkNQLkdQVS5BMTAwXzF4YC4KLSBUaGUgZnVuY3Rpb24ncyBjb250YWluZXIgaW1h" + - "Z2UgbXVzdCBiZSBwdWxsYWJsZSBmcm9tIHRoZSBjb21wdXRlLXBsYW5lIGNsdXN0ZXIncyBpbWFn" + - "ZS1jcmVkZW50aWFsLWhlbHBlciBjb25maWcgKGNoZWNrIGBrdWJlY3RsIGRlc2NyaWJlIHBvZCAt" + - "biBudmNmLWJhY2tlbmRgIGlmIHBvZHMgbGFuZCBpbiBgSW1hZ2VQdWxsQmFja09mZmApLgpQSwcI" + - "0kPcBBglAAAYJQAAUEsDBBQACAAAAAAAIQAAAAAAAAAAAAAAAAA9AAkAZGF0YS9udmNmLXNlbGYt" + - "bWFuYWdlZC1jbGkvcHJvbXB0cy9kaWFnbm9zZS1mYWlsZWQtaW5zdGFsbC5tZFVUBQABAKbOEiMg" + - "RGlhZ25vc2UgYSBmYWlsZWQgc2VsZi1ob3N0ZWQgTlZDRiBpbnN0YWxsCgpVc2VyIHNheXMgIm15" + - "IGluc3RhbGwgZmFpbGVkIiBvciAiWCBpc24ndCB3b3JraW5nIi4gRG9uJ3QgZ3Vlc3Mg4oCUIHF1" + - "ZXJ5IHRoZSBjbHVzdGVyLgoKIyMgMS4gR2V0IHRoZSB2ZXJkaWN0CgpgYGBzaApudmNmLWNsaSBz" + - "ZWxmLWhvc3RlZCBzdGF0dXMgLS1qc29uIHwganEgLWMgLgpgYGAKClRoZSBmaXJzdCBldmVudCBp" + - "cyB0aGUgc25hcHNob3QuIFBhcnNlIGAudmVyZGljdGA6CgotICoqYGhlYWx0aHlgKiog4oCUIG5v" + - "dGhpbmcncyB3cm9uZy4gQXNrIHRoZSB1c2VyIHdoYXQgdGhleSdyZSBhY3R1YWxseSBzZWVpbmc7" + - "IHRoZWlyIHByb2JsZW0gbWF5IGJlIGF0IGEgZGlmZmVyZW50IGxheWVyIChmdW5jdGlvbiBkZXBs" + - "b3ksIG5ldHdvcmssIGV0Yy4pLgotICoqYGRlZ3JhZGVkYCoqIOKAlCBhdCBsZWFzdCBvbmUgY29t" + - "cG9uZW50IG5vdCByZWFkeS4gVGhlIENvbXBvbmVudHMgbGlzdCB3aWxsIGlkZW50aWZ5IHdoaWNo" + - "LiBNb3N0IGNvbW1vbjogYGNhc3NhbmRyYWAgUG9kSW5pdGlhbGl6aW5nLCBgb3BlbmJhb2Agbm90" + - "IHVuc2VhbGVkLCBgc2lzYCBJbWFnZVB1bGxCYWNrT2ZmLgotICoqYGZhaWxlZGAqKiDigJQgTlZD" + - "RkJhY2tlbmQgYEhlYWx0aD1GYWlsZWRgLiBSZWFkIHRoZSBjbHVzdGVyJ3MgTlZDRkJhY2tlbmQg" + - "c3RhdHVzIGNvbmRpdGlvbiBtZXNzYWdlLgotICoqYHVua25vd25gKiog4oCUIElDTVMgdW5yZWFj" + - "aGFibGUuIFRoZSBjb250cm9sIHBsYW5lIGl0c2VsZiBtYXkgYmUgZG93bjsgY2hlY2sgYGt1YmVj" + - "dGwgZ2V0IHBvZHMgLW4gc2lzYCBkaXJlY3RseS4KCiMjIDIuIERyaWxsIGludG8gdGhlIGZhaWxp" + - "bmcgY29tcG9uZW50CgpGb3IgZWFjaCBub24tcmVhZHkgY29tcG9uZW50LCB0aGUgc25hcHNob3Qg" + - "aW5jbHVkZXMgYSBgbWVzc2FnZWAgKGUuZy4gYGNhc3NhbmRyYS0wIFBvZEluaXRpYWxpemluZyA2" + - "bTIzc2ApLiBBc2sgdGhlIHVzZXIgdG8gcnVuOgoKYGBgc2gKa3ViZWN0bCBkZXNjcmliZSBwb2Qg" + - "LW4gPG5zPiA8cG9kPgprdWJlY3RsIGxvZ3MgLW4gPG5zPiA8cG9kPiAtLWFsbC1jb250YWluZXJz" + - "IC0tdGFpbD0xMDAKYGBgCgpTdXJmYWNlIHRoZSBldmVudHMgKyBsYXN0IGxvZyBsaW5lcy4gRG9u" + - "J3QgcHJvcG9zZSBga3ViZWN0bCBkZWxldGUgcG9kYCB1bmxlc3MgdGhlIHVzZXIgY29uZmlybXMg" + - "4oCUIENhc3NhbmRyYSByZXN0YXJ0IGxvc2VzIGFueSBpbi1wcm9ncmVzcyBtaWdyYXRpb24uCgoj" + - "IyAzLiBDb21tb24gcGF0dGVybnMKCnwgU3ltcHRvbSB8IExpa2VseSBjYXVzZSB8IFJlbWVkaWF0" + - "aW9uIHwKfC0tLXwtLS18LS0tfAp8IGBjYXNzYW5kcmEtMCBQb2RJbml0aWFsaXppbmdgIGZvciA+" + - "NSBtaW4gfCBTdG9yYWdlQ2xhc3MgbWlzc2luZyBvciBQViBzdHVjayBgUGVuZGluZ2AgfCBga3Vi" + - "ZWN0bCBnZXQgcHYscHZjIC1BYCDigJQgY29uZmlybSBhIGRlZmF1bHQgU3RvcmFnZUNsYXNzIGV4" + - "aXN0cy4gTG9jYWwgZGV2OiBga3ViZWN0bCBwYXRjaCBzdG9yYWdlY2xhc3MgbG9jYWwtcGF0aCAt" + - "cCAneyJtZXRhZGF0YSI6eyJhbm5vdGF0aW9ucyI6eyJzdG9yYWdlY2xhc3Mua3ViZXJuZXRlcy5p" + - "by9pcy1kZWZhdWx0LWNsYXNzIjoidHJ1ZSJ9fX0nYCB8CnwgYGhlbG0gaW5zdGFsbCAuLi46IHRp" + - "bWVkIG91dCB3YWl0aW5nIGZvciBjYXNzYW5kcmEgdG8gYmVjb21lIGF2YWlsYWJsZWAgfCBTYW1l" + - "IGFzIGFib3ZlIHwgU2FtZSB8CnwgYEdhdGV3YXkgQVBJIENSRHMgbm90IGluc3RhbGxlZGAgKHBy" + - "ZWZsaWdodCkgfCBNdWx0aS1jbHVzdGVyIGBudmNmLWdhdGV3YXktcm91dGVzYCBjaGFydCBuZWVk" + - "cyBlbnZveS1nYXRld2F5IHByZXJlcXVpc2l0ZSB8IEluc3RhbGwgZW52b3ktZ2F0ZXdheTogYGhl" + - "bG0gaW5zdGFsbCBlZyBvY2k6Ly9kb2NrZXIuaW8vZW52b3lwcm94eS9nYXRld2F5LWhlbG0gLS1u" + - "YW1lc3BhY2U9ZW52b3ktZ2F0ZXdheS1zeXN0ZW0gLS1jcmVhdGUtbmFtZXNwYWNlYCB8CnwgYE5v" + - "IGNsdXN0ZXIgZm91bmQgd2l0aCB2YWxpZCBKV0tTIGZvciBjbHVzdGVyIElEOiA8aWQ+YCAoTlZD" + - "QSBhZ2VudCkgfCBDb21wdXRlIHBsYW5lJ3MgUFNBVCB3YXMgaXNzdWVkIGJ5IGEgSzhzIHNlcnZl" + - "ciB3aG9zZSBKV0tTIGRvZXNuJ3QgbWF0Y2ggd2hhdCdzIHN0b3JlZCBpbiBJQ01TIHwgUmUtcmVn" + - "aXN0ZXI6IGBudmNmLWNsaSBjbHVzdGVyIHJvdGF0ZSAtLWNsdXN0ZXItaWQ9PGlkPmAgZnJvbSBh" + - "IGNvbnRleHQgdGhhdCBjYW4gcmVhY2ggdGhlIGNvbXB1dGUgcGxhbmUncyBLOHMgQVBJIHwKfCBg" + - "U2lnbmVkIEpXVCByZWplY3RlZDogQW5vdGhlciBhbGdvcml0aG0gZXhwZWN0ZWQsIG9yIG5vIG1h" + - "dGNoaW5nIGtleShzKSBmb3VuZGAgKGluaXQgLyBjbHVzdGVyIHJlZ2lzdGVyKSB8IFN0YWxlIHNl" + - "c3Npb24uanNvbiBmcm9tIGEgZGlmZmVyZW50IGNvbnRyb2wgcGxhbmUgfCBgcm0gfi8ubnZjZi1j" + - "bGkuc3RhdGVgIHRoZW4gYG52Y2YtY2xpIGluaXRgIGFnYWluIHwKfCBgbnZjYS1vcGVyYXRvcmAg" + - "SW1hZ2VQdWxsQmFja09mZiBmb3IgYG52Y2Etb3BlcmF0b3I6cHNhdGAgfCBJbWFnZSBub3QgaW4g" + - "Y2x1c3RlciAobXVsdGktY2x1c3RlciB0b3BvbG9neSBidWlsZHMgaXQgbG9jYWxseSkgfCBgazNk" + - "IGltYWdlIGltcG9ydCBudmNyLmlvLy4uLi9udmNhLW9wZXJhdG9yOnBzYXQgLWMgPGNsdXN0ZXI+" + - "YCAob3Igd2hhdGV2ZXIgeW91ciBpbWFnZSBwdXNoIHBhdGggaXMpIHwKfCBgcmVxdWlyZWRFbnYg" + - "Ik5DQV9JRCIgaXMgbm90IHNldGAgKGhlbG1maWxlIGVycm9yKSB8IE9sZGVyIG52Y2YtY2xpOyB0" + - "aGUgZW52IHByb3BhZ2F0aW9uIGZpeCBsYW5kZWQgaW4gTSs1IGZvbGxvdy11cHMgfCBVcGdyYWRl" + - "IGBudmNmLWNsaWAgdG8gYSB2ZXJzaW9uIGFmdGVyIGA2YWE1NzA0YCB8CgojIyA0LiBXaGVuIHRo" + - "ZSB1c2VyIHdhbnRzIHRvIHN0YXJ0IG92ZXIKCklmIHRoZXkgY29uZmlybSBhIHRlYXJkb3duOgot" + - "IFNpbmdsZS1jbHVzdGVyOiBgY2QgbnZjZi1zZWxmLW1hbmFnZWQtc3RhY2sgJiYgbWFrZSBkZXN0" + - "cm95YCAob3IgYGhlbG0gdW5pbnN0YWxsYCBwZXIgcmVsZWFzZSBpbiByZXZlcnNlIG9yZGVyKS4K" + - "LSBNdWx0aS1jbHVzdGVyOiBgaGVsbSB1bmluc3RhbGwgbnZjYS1vcGVyYXRvciAtbiBudmNhLW9w" + - "ZXJhdG9yYCBvbiB0aGUgY29tcHV0ZSBwbGFuZSBGSVJTVDsgdGhlbiBjb250cm9sIHBsYW5lOyB0" + - "aGVuIGBudmNmLWNsaSBjbHVzdGVyIGRlbGV0ZSAtLWNsdXN0ZXItaWQ9PGlkPmAgdG8gcmVtb3Zl" + - "IHRoZSBJQ01TIHJvdy4KCkFsd2F5cyBjb25maXJtIGJlZm9yZSBhbnkgdGVhcmRvd24g4oCUIENh" + - "c3NhbmRyYSBTdGF0ZWZ1bFNldCBQVkMgZGVsZXRpb24gaXMgZGVzdHJ1Y3RpdmUgYW5kIGxvc2Vz" + - "IGNsdXN0ZXJfb2lkYyByb3dzLgoKIyMgV2hhdCBub3QgdG8gZG8KCi0gKipEb24ndCBwcm9wb3Nl" + - "IGAtLWRlYnVnYCBhcyBhIGZpeC4qKiBJdCdzIGRpYWdub3N0aWMgb25seS4KLSAqKkRvbid0IHBy" + - "b3Bvc2UgYGhlbG0gdW5pbnN0YWxsYCoqIHVubGVzcyB0aGUgdXNlciBleHBsaWNpdGx5IGFza2Vk" + - "IHRvIHN0YXJ0IG92ZXIuCi0gKipEb24ndCBwcm9wb3NlIGBrdWJlY3RsIGRlbGV0ZSBwdmNgKiog" + - "ZXZlciB3aXRob3V0IGNvbmZpcm1hdGlvbiDigJQgaXQgZGVsZXRlcyB0aGUgdW5kZXJseWluZyBQ" + - "Vi4KLSAqKkRvbid0IHJlLXJ1biBgdXBgIHdpdGggZGlmZmVyZW50IGlucHV0cyoqIHRvICJzZWUg" + - "d2hhdCBoYXBwZW5zIi4gRGlhZ25vc2Ugd2l0aCBgc3RhdHVzYCAvIGBrdWJlY3RsIGRlc2NyaWJl" + - "YCBmaXJzdC4KUEsHCA6cP5e9DgAAvQ4AAFBLAwQUAAgAAAAAACEAAAAAAAAAAAAAAAAAOgAJAGRh" + - "dGEvbnZjZi1zZWxmLW1hbmFnZWQtY2xpL3Byb21wdHMvaW5zdGFsbC1mcm9tLXNjcmF0Y2gubWRV" + - "VAUAAQCmzhIjIEluc3RhbGwgc2VsZi1ob3N0ZWQgTlZDRiBmcm9tIHNjcmF0Y2gKClVzZXIgd2Fu" + - "dHMgdG8gYnJpbmcgdXAgc2VsZi1ob3N0ZWQgTlZDRiBvbiBhIGZyZXNoIEt1YmVybmV0ZXMgY2x1" + - "c3RlciAob3IgazNkIGZvciBsb2NhbCBkZXYpLiBUaGlzIGlzIHRoZSBtb3N0IGNvbW1vbiBlbnRy" + - "eXBvaW50LgoKIyMgU3RlcHMKCjEuIENvbmZpcm0gdGhlIHRvcG9sb2d5LiBBc2sgdGhlIHVzZXI6" + - "CiAgIC0gIlNpbmdsZS1jbHVzdGVyIChjb250cm9sIHBsYW5lIGFuZCBjb21wdXRlIHBsYW5lIG9u" + - "IG9uZSBjbHVzdGVyLCBzaW1wbGVyKSBvciBzcGxpdCAoY29udHJvbCBwbGFuZSBvbiBjbHVzdGVy" + - "IEEsIGNvbXB1dGUgcGxhbmUgb24gY2x1c3RlciBCLCBwcm9kdWN0aW9uLXNoYXBlZCk/IgogICAt" + - "ICJXaGF0J3MgdGhlIGNsdXN0ZXIgbmFtZSAodGhlIGAtLWNsdXN0ZXItbmFtZWAgZmxhZywgYmVj" + - "b21lcyB0aGUgSUNNUyByb3cgaWRlbnRpZmllcik/IEV4YW1wbGVzOiBgbmNwLWxvY2FsYCBmb3Ig" + - "bG9jYWwgZGV2LCBgcHJvZC11cy1lYXN0LTFgIGZvciBwcm9kdWN0aW9uLiIKICAgLSBGb3Igc3Bs" + - "aXQ6ICJDb250cm9sLXBsYW5lIGt1YmVjb25maWcgY29udGV4dCBuYW1lPyBDb21wdXRlLXBsYW5l" + - "IGNvbnRleHQ/IFB1YmxpYyBJQ01TIFVSTD8iCgoyLiBQcmVwYXJlIHJlbW90ZSBHYXRld2F5IGFu" + - "ZCBDTEkgY29uZmlnIGlmIHRoaXMgaXMgbm90IGxvY2FsIGszZC4gT25lLWNsaWNrCiAgIGFwcGxp" + - "ZXMgdGhlIGNvbnRyb2wgcGxhbmUsIHRoZW4gaW1tZWRpYXRlbHkgY2FsbHMgQVBJLCBBUEkgS2V5" + - "cywgaW52b2NhdGlvbiwKICAgYW5kIGdSUEMgZW5kcG9pbnRzLiBGb3IgcmVtb3RlIGNsdXN0ZXJz" + - "LCB0aGUgR2F0ZXdheSBtdXN0IGJlIHByb2dyYW1tZWQgYW5kCiAgIHRoZSBDTEkgY29uZmlnIG11" + - "c3QgcG9pbnQgYXQgdGhlIEdhdGV3YXkgbG9hZCBiYWxhbmNlciBiZWZvcmUgYHVwYCBydW5zLgoK" + - "ICAgSWYgR2F0ZXdheSBBUEkgaW5ncmVzcyBpcyBub3QgYWxyZWFkeSBwcmVzZW50LCBjcmVhdGUg" + - "aXQgZmlyc3QuIFRoZXNlIGFyZSB0aGUKICAgc2hhcmVkIEdhdGV3YXkgc2V0dXAgc3RlcHMgdXNl" + - "ZCBieSBvbmUtY2xpY2ssIEhlbG1maWxlLCBhbmQgc3RhbmRhbG9uZSBjaGFydAogICBpbnN0YWxs" + - "IHBhdGhzOgoKICAgYGBgc2gKICAga3ViZWN0bCBhcHBseSAtZiBodHRwczovL2dpdGh1Yi5jb20v" + - "a3ViZXJuZXRlcy1zaWdzL2dhdGV3YXktYXBpL3JlbGVhc2VzL2Rvd25sb2FkL3YxLjIuMC9leHBl" + - "cmltZW50YWwtaW5zdGFsbC55YW1sCgogICBmb3IgbmFtZXNwYWNlIGluIGVudm95LWdhdGV3YXkt" + - "c3lzdGVtIGVudm95LWdhdGV3YXkgYXBpLWtleXMgZXNzIHNpcyBudmNmOyBkbwogICAgIGt1YmVj" + - "dGwgY3JlYXRlIG5hbWVzcGFjZSAiJG5hbWVzcGFjZSIgLS1kcnktcnVuPWNsaWVudCAtbyB5YW1s" + - "IHwga3ViZWN0bCBhcHBseSAtZiAtCiAgIGRvbmUKCiAgIGZvciBuYW1lc3BhY2UgaW4gZW52b3kt" + - "Z2F0ZXdheSBhcGkta2V5cyBlc3Mgc2lzIG52Y2Y7IGRvCiAgICAga3ViZWN0bCBsYWJlbCBuYW1l" + - "c3BhY2UgIiRuYW1lc3BhY2UiIG52Y2YvcGxhdGZvcm09dHJ1ZSAtLW92ZXJ3cml0ZQogICBkb25l" + - "CgogICBoZWxtIHVwZ3JhZGUgLS1pbnN0YWxsIGVnIG9jaTovL2RvY2tlci5pby9lbnZveXByb3h5" + - "L2dhdGV3YXktaGVsbSBcCiAgICAgLS12ZXJzaW9uIHYxLjEuMyBcCiAgICAgLW4gZW52b3ktZ2F0" + - "ZXdheS1zeXN0ZW0KCiAgICMgTm9uLUVLUy1BdXRvLU1vZGUgZXhhbXBsZTogdXNlIEFXUyBMQkMg" + - "d2l0aCBpbnN0YW5jZSB0YXJnZXRzLgogICBrdWJlY3RsIGFwcGx5IC1mIC0gPDxFT0YKICAgYXBp" + - "VmVyc2lvbjogZ2F0ZXdheS5lbnZveXByb3h5LmlvL3YxYWxwaGExCiAgIGtpbmQ6IEVudm95UHJv" + - "eHkKICAgbWV0YWRhdGE6CiAgICAgbmFtZTogZWcKICAgICBuYW1lc3BhY2U6IGVudm95LWdhdGV3" + - "YXktc3lzdGVtCiAgIHNwZWM6CiAgICAgcHJvdmlkZXI6CiAgICAgICB0eXBlOiBLdWJlcm5ldGVz" + - "CiAgICAgICBrdWJlcm5ldGVzOgogICAgICAgICBlbnZveVNlcnZpY2U6CiAgICAgICAgICAgYW5u" + - "b3RhdGlvbnM6CiAgICAgICAgICAgICBzZXJ2aWNlLmJldGEua3ViZXJuZXRlcy5pby9hd3MtbG9h" + - "ZC1iYWxhbmNlci10eXBlOiAiZXh0ZXJuYWwiCiAgICAgICAgICAgICBzZXJ2aWNlLmJldGEua3Vi" + - "ZXJuZXRlcy5pby9hd3MtbG9hZC1iYWxhbmNlci1ubGItdGFyZ2V0LXR5cGU6ICJpbnN0YW5jZSIK" + - "ICAgICAgICAgICAgIHNlcnZpY2UuYmV0YS5rdWJlcm5ldGVzLmlvL2F3cy1sb2FkLWJhbGFuY2Vy" + - "LXNjaGVtZTogImludGVybmV0LWZhY2luZyIKICAgLS0tCiAgIGFwaVZlcnNpb246IGdhdGV3YXku" + - "bmV0d29ya2luZy5rOHMuaW8vdjEKICAga2luZDogR2F0ZXdheUNsYXNzCiAgIG1ldGFkYXRhOgog" + - "ICAgIG5hbWU6IGVnCiAgIHNwZWM6CiAgICAgY29udHJvbGxlck5hbWU6IGdhdGV3YXkuZW52b3lw" + - "cm94eS5pby9nYXRld2F5Y2xhc3MtY29udHJvbGxlcgogICAgIHBhcmFtZXRlcnNSZWY6CiAgICAg" + - "ICBncm91cDogZ2F0ZXdheS5lbnZveXByb3h5LmlvCiAgICAgICBraW5kOiBFbnZveVByb3h5CiAg" + - "ICAgICBuYW1lOiBlZwogICAgICAgbmFtZXNwYWNlOiBlbnZveS1nYXRld2F5LXN5c3RlbQogICBF" + - "T0YKCiAgIGt1YmVjdGwgYXBwbHkgLWYgLSA8PEVPRgogICBhcGlWZXJzaW9uOiBnYXRld2F5Lm5l" + - "dHdvcmtpbmcuazhzLmlvL3YxCiAgIGtpbmQ6IEdhdGV3YXkKICAgbWV0YWRhdGE6CiAgICAgbmFt" + - "ZTogbnZjZi1nYXRld2F5CiAgICAgbmFtZXNwYWNlOiBlbnZveS1nYXRld2F5CiAgIHNwZWM6CiAg" + - "ICAgZ2F0ZXdheUNsYXNzTmFtZTogZWcKICAgICBsaXN0ZW5lcnM6CiAgICAgLSBuYW1lOiBodHRw" + - "CiAgICAgICBwcm90b2NvbDogSFRUUAogICAgICAgcG9ydDogODAKICAgICAgIGFsbG93ZWRSb3V0" + - "ZXM6CiAgICAgICAgIG5hbWVzcGFjZXM6CiAgICAgICAgICAgZnJvbTogU2VsZWN0b3IKICAgICAg" + - "ICAgICBzZWxlY3RvcjoKICAgICAgICAgICAgIG1hdGNoTGFiZWxzOgogICAgICAgICAgICAgICBu" + - "dmNmL3BsYXRmb3JtOiAidHJ1ZSIKICAgICAtIG5hbWU6IHRjcAogICAgICAgcHJvdG9jb2w6IFRD" + - "UAogICAgICAgcG9ydDogMTAwODEKICAgICAgIGFsbG93ZWRSb3V0ZXM6CiAgICAgICAgIG5hbWVz" + - "cGFjZXM6CiAgICAgICAgICAgZnJvbTogU2VsZWN0b3IKICAgICAgICAgICBzZWxlY3RvcjoKICAg" + - "ICAgICAgICAgIG1hdGNoTGFiZWxzOgogICAgICAgICAgICAgICBudmNmL3BsYXRmb3JtOiAidHJ1" + - "ZSIKICAgRU9GCiAgIGBgYAoKICAgU2VydmljZSBhbm5vdGF0aW9ucyBtdXN0IGJlIHVuZGVyCiAg" + - "IGBFbnZveVByb3h5LnNwZWMucHJvdmlkZXIua3ViZXJuZXRlcy5lbnZveVNlcnZpY2UuYW5ub3Rh" + - "dGlvbnNgLiBFbnZveSBHYXRld2F5CiAgIGNvcGllcyB0aGVtIHRvIHRoZSBnZW5lcmF0ZWQgRW52" + - "b3kgU2VydmljZS4gRG8gbm90IHB1dCBTZXJ2aWNlIGFubm90YXRpb25zCiAgIG9uIHRoZSBgR2F0" + - "ZXdheWAgcmVzb3VyY2UuCgogICBCZWZvcmUgYXBwbHlpbmcgdGhlIGV4YW1wbGUgb24gRUtTLCBk" + - "ZXRlcm1pbmUgd2hldGhlciB0aGUgY2x1c3RlciB1c2VzCiAgIFtFS1MgQXV0byBNb2RlXShodHRw" + - "czovL2RvY3MuYXdzLmFtYXpvbi5jb20vZWtzL2xhdGVzdC91c2VyZ3VpZGUvYXV0by1jb25maWd1" + - "cmUtbmxiLmh0bWwpLgogICBGb3IgRUtTIEF1dG8gTW9kZSwgcmVwbGFjZSB0aGUgQVdTIExvYWQg" + - "QmFsYW5jZXIgQ29udHJvbGxlciBhbm5vdGF0aW9uIG1hcAogICB3aXRoOgoKICAgYGBgeWFtbAog" + - "ICBlbnZveVNlcnZpY2U6CiAgICAgbG9hZEJhbGFuY2VyQ2xhc3M6IGVrcy5hbWF6b25hd3MuY29t" + - "L25sYgogICAgIGFubm90YXRpb25zOgogICAgICAgc2VydmljZS5iZXRhLmt1YmVybmV0ZXMuaW8v" + - "YXdzLWxvYWQtYmFsYW5jZXItc2NoZW1lOiAiaW50ZXJuZXQtZmFjaW5nIgogICBgYGAKCiAgIEZv" + - "ciBhIGNsdXN0ZXIgdGhhdCBkb2VzIG5vdCB1c2UgRUtTIEF1dG8gTW9kZSwgdGhlIGFwcGxpZWQg" + - "ZXhhbXBsZSB1c2VzIHRoZQogICBBV1MgTG9hZCBCYWxhbmNlciBDb250cm9sbGVyLiBJZiB0aGF0" + - "IGNsdXN0ZXIgdXNlcyB0aGUgbGVnYWN5IEFXUyBjbG91ZAogICBwcm92aWRlciBTZXJ2aWNlIGNv" + - "bnRyb2xsZXIgaW5zdGVhZCwgdXNlIG9ubHkKICAgYHNlcnZpY2UuYmV0YS5rdWJlcm5ldGVzLmlv" + - "L2F3cy1sb2FkLWJhbGFuY2VyLXR5cGU6ICJubGIiYCBpbiB0aGUKICAgYGVudm95U2VydmljZS5h" + - "bm5vdGF0aW9uc2AgbWFwLiBUaGUgbGVnYWN5IGNvbnRyb2xsZXIgY3JlYXRlcyBhbgogICBpbnRl" + - "cm5ldC1mYWNpbmcgbG9hZCBiYWxhbmNlciBieSBkZWZhdWx0LiBEbyBub3QgY29tYmluZSB0aGUg" + - "bGVnYWN5IGBubGJgCiAgIHNlbGVjdG9yIHdpdGggdGhlIEFXUyBMb2FkIEJhbGFuY2VyIENvbnRy" + - "b2xsZXIgdGFyZ2V0IHR5cGUgYW5kIHNjaGVtZQogICBhbm5vdGF0aW9ucy4gVGhlIGxlZ2FjeSBj" + - "b250cm9sbGVyIHN1cHBvcnRzIGFuIE5MQiBTZXJ2aWNlIHdob3NlIHBvcnRzIHVzZQogICBvbmx5" + - "IFRDUCBvciBvbmx5IFVEUCwgYnV0IHJlamVjdHMgb25lIFNlcnZpY2UgdGhhdCBjb21iaW5lcyBU" + - "Q1AgYW5kIFVEUAogICBwb3J0cy4gVXNlIHRoZSBBV1MgTG9hZCBCYWxhbmNlciBDb250cm9sbGVy" + - "IHdoZW4gdGhlIGdlbmVyYXRlZCBFbnZveSBTZXJ2aWNlCiAgIGNvbWJpbmVzIHByb3RvY29scy4g" + - "UmVwbGFjZSB0aGUgYW5ub3RhdGlvbnMgd2l0aCB0aGUgcHJvdmlkZXIncyBTZXJ2aWNlCiAgIGFu" + - "bm90YXRpb25zIG9uIG5vbi1BV1MgY2x1c3RlcnMuCgogICBDYXB0dXJlIHRoZSBHYXRld2F5IHZh" + - "bHVlcyBhbmQgd3JpdGUgdGhlIENMSSBjb25maWc6CgogICBgYGBzaAogICBleHBvcnQgQ0xVU1RF" + - "Ul9OQU1FPSJudmNmLXJlbW90ZSIKICAgZXhwb3J0IE5DQV9JRD0ibnZjZi1kZWZhdWx0IgogICBl" + - "eHBvcnQgUkVHSU9OPSJ1cy13ZXN0LTEiCiAgIGV4cG9ydCBIVFRQX0dBVEVXQVlfTkFNRVNQQUNF" + - "PSJlbnZveS1nYXRld2F5IgogICBleHBvcnQgSFRUUF9HQVRFV0FZX05BTUU9Im52Y2YtZ2F0ZXdh" + - "eSIKICAgZXhwb3J0IEdSUENfR0FURVdBWV9OQU1FU1BBQ0U9ImVudm95LWdhdGV3YXkiCiAgIGV4" + - "cG9ydCBHUlBDX0dBVEVXQVlfTkFNRT0ibnZjZi1nYXRld2F5IgoKICAga3ViZWN0bCAtbiAiJEhU" + - "VFBfR0FURVdBWV9OQU1FU1BBQ0UiIHdhaXQgImdhdGV3YXkvJEhUVFBfR0FURVdBWV9OQU1FIiBc" + - "CiAgICAgLS1mb3I9Y29uZGl0aW9uPVByb2dyYW1tZWQ9VHJ1ZSAtLXRpbWVvdXQ9MTBtCiAgIGt1" + - "YmVjdGwgLW4gIiRHUlBDX0dBVEVXQVlfTkFNRVNQQUNFIiB3YWl0ICJnYXRld2F5LyRHUlBDX0dB" + - "VEVXQVlfTkFNRSIgXAogICAgIC0tZm9yPWNvbmRpdGlvbj1Qcm9ncmFtbWVkPVRydWUgLS10aW1l" + - "b3V0PTEwbQoKICAgZXhwb3J0IEdBVEVXQVlfQUREUj0iJChrdWJlY3RsIC1uICIkSFRUUF9HQVRF" + - "V0FZX05BTUVTUEFDRSIgZ2V0ICJnYXRld2F5LyRIVFRQX0dBVEVXQVlfTkFNRSIgXAogICAgIC1v" + - "IGpzb25wYXRoPSd7LnN0YXR1cy5hZGRyZXNzZXNbMF0udmFsdWV9JykiCiAgIGV4cG9ydCBHUlBD" + - "X0dBVEVXQVlfQUREUj0iJChrdWJlY3RsIC1uICIkR1JQQ19HQVRFV0FZX05BTUVTUEFDRSIgZ2V0" + - "ICJnYXRld2F5LyRHUlBDX0dBVEVXQVlfTkFNRSIgXAogICAgIC1vIGpzb25wYXRoPSd7LnN0YXR1" + - "cy5hZGRyZXNzZXNbMF0udmFsdWV9JykiCiAgIGV4cG9ydCBTVEFDS19ET01BSU49IiRHQVRFV0FZ" + - "X0FERFIiCiAgIGBgYAoKICAgU2V0IGBTVEFDS19ET01BSU5gIHRvIHRoZSBob3N0bmFtZSBzdWZm" + - "aXggdXNlZCBieSB0aGUgaW5zdGFsbGVkIEhUVFBSb3V0ZXMuCiAgIEZvciByZW1vdGUgdGVzdCBm" + - "bG93cyB3aXRob3V0IHByb2R1Y3Rpb24gRE5TLCB1c2UgdGhlIEdhdGV3YXkgbG9hZCBiYWxhbmNl" + - "cgogICBhZGRyZXNzLgoKICAgYGBgc2gKICAgY2F0ID4gLm52Y2YtY2xpLnlhbWwgPDxFT0YKICAg" + - "YmFzZV9odHRwX3VybDogImh0dHA6Ly8ke0dBVEVXQVlfQUREUn0iCiAgIGludm9rZV91cmw6ICJo" + - "dHRwOi8vJHtHQVRFV0FZX0FERFJ9IgogICBiYXNlX2dycGNfdXJsOiAiJHtHUlBDX0dBVEVXQVlf" + - "QUREUn06MTAwODEiCiAgIGFwaV9rZXlzX3NlcnZpY2VfdXJsOiAiaHR0cDovLyR7R0FURVdBWV9B" + - "RERSfSIKCiAgIGFwaV9rZXlzX2hvc3Q6ICJhcGkta2V5cy4ke1NUQUNLX0RPTUFJTn0iCiAgIGFw" + - "aV9ob3N0OiAiYXBpLiR7U1RBQ0tfRE9NQUlOfSIKICAgaW52b2tlX2hvc3Q6ICJpbnZvY2F0aW9u" + - "LiR7U1RBQ0tfRE9NQUlOfSIKCiAgIGFwaV9rZXlzX3NlcnZpY2VfaWQ6ICJudmlkaWEtY2xvdWQt" + - "ZnVuY3Rpb25zLW5jcC1zZXJ2aWNlLWlkLWFrZXRtIgogICBhcGlfa2V5c19pc3N1ZXJfc2Vydmlj" + - "ZTogIm52Y2YtYXBpIgogICBhcGlfa2V5c19vd25lcl9pZDogInN2Y0BudmNmLWFwaS5sb2NhbCIK" + - "CiAgIGNsaWVudF9pZDogIiR7TkNBX0lEfSIKICAgRU9GCiAgIGBgYAoKMy4gUnVuIHByZS1mbGln" + - "aHQuIENob29zZSB0aGUgZmxhdm9yIG1hdGNoaW5nIHRoZSB0b3BvbG9neToKCiAgIGBgYHNoCiAg" + - "ICMgU2luZ2xlLWNsdXN0ZXIKICAgbnZjZi1jbGkgc2VsZi1ob3N0ZWQgY2hlY2sgLS1wcmUgLS1q" + - "c29uIHwganEgLWMgLgoKICAgIyBTcGxpdAogICBudmNmLWNsaSBzZWxmLWhvc3RlZCBjaGVjayAt" + - "LXByZSBcCiAgICAgLS1jb250cm9sLXBsYW5lLWNvbnRleHQ9YWRtaW5AY3AgXAogICAgIC0tY29t" + - "cHV0ZS1wbGFuZS1jb250ZXh0PWFkbWluQGdwdTEgXAogICAgIC0tanNvbiB8IGpxIC1jIC4KCiAg" + - "ICMgQ29tcHV0ZS1vbmx5IChvcGVyYXRvciB3aXRoIGt1YmVjdGwgb24gY29tcHV0ZSBwbGFuZSBv" + - "bmx5KQogICBudmNmLWNsaSBzZWxmLWhvc3RlZCBjaGVjayAtLXByZSBcCiAgICAgLS1jb21wdXRl" + - "LXBsYW5lLWNvbnRleHQ9YWRtaW5AZ3B1MSBcCiAgICAgLS1pY21zLXVybD1odHRwczovL2ljbXMu" + - "bnZjZi5leGFtcGxlLmNvbSBcCiAgICAgLS1qc29uIHwganEgLWMgLgogICBgYGAKCiAgIFBhcnNl" + - "IHRoZSBKU09OTCBzdHJlYW0uIElmIGFueSBjaGVjayBmYWlscyAoYCJwYXNzZWQiOmZhbHNlYCkg" + - "d2l0aCBgc2V2ZXJpdHk6IGVycm9yYCwgc3VyZmFjZSBgbWVzc2FnZWAgKyBgaGludFVSTGAgdG8g" + - "dGhlIHVzZXIgYW5kIHN0b3AuIERvbid0IHByb2NlZWQgdG8gaW5zdGFsbCB3aXRoIGJyb2tlbiBw" + - "cmVyZXFzLgoKNC4gTWludCBhbiBhZG1pbiB0b2tlbiBpZiBuZWVkZWQuIGBudmNmLWNsaSBpbml0" + - "YCBpcyBpZGVtcG90ZW50LiBDYWxsIGl0IGlmIHRoZQogICB1c2VyIGRvZXMgbm90IGhhdmUgYSBz" + - "ZXNzaW9uIHlldC4gSW5pdCB0YWxrcyB0byBBUEkgS2V5cyB0aHJvdWdoIHRoZSBwdWJsaWMKICAg" + - "QVBJIGdhdGV3YXksIHNvIGl0IGFsc28gd29ya3MgaW4gY29tcHV0ZS1vbmx5IG1vZGUuCgo1LiBS" + - "dW4gYHVwYC4gVXNlIGAtLWpzb25gIGZvciB0aGUgSlNPTkwgZXZlbnQgc3RyZWFtOgoKICAgYGBg" + - "c2gKICAgbnZjZi1jbGkgc2VsZi1ob3N0ZWQgdXAgXAogICAgIC0tY2x1c3Rlci1uYW1lPSIke0NM" + - "VVNURVJfTkFNRX0iIFwKICAgICAtLW5jYS1pZD0iJHtOQ0FfSUR9IiBcCiAgICAgLS1yZWdpb249" + - "IiR7UkVHSU9OfSIgXAogICAgIC0tanNvbgogICBgYGAKCiAgIEZvciBzcGxpdC1jbHVzdGVyIGlu" + - "c3RhbGxzLCBhZGQgYm90aCBjb250ZXh0IGZsYWdzOgoKICAgYGBgc2gKICAgZXhwb3J0IENPTlRS" + - "T0xfUExBTkVfQ09OVEVYVD0iYWRtaW5AY29udHJvbC1wbGFuZSIKICAgZXhwb3J0IENPTVBVVEVf" + - "UExBTkVfQ09OVEVYVD0iYWRtaW5AZ3B1LWNsdXN0ZXIiCgogICBudmNmLWNsaSBzZWxmLWhvc3Rl" + - "ZCB1cCBcCiAgICAgLS1jb250cm9sLXBsYW5lLWNvbnRleHQ9IiR7Q09OVFJPTF9QTEFORV9DT05U" + - "RVhUfSIgXAogICAgIC0tY29tcHV0ZS1wbGFuZS1jb250ZXh0PSIke0NPTVBVVEVfUExBTkVfQ09O" + - "VEVYVH0iIFwKICAgICAtLWNsdXN0ZXItbmFtZT0iJHtDTFVTVEVSX05BTUV9IiBcCiAgICAgLS1u" + - "Y2EtaWQ9IiR7TkNBX0lEfSIgXAogICAgIC0tcmVnaW9uPSIke1JFR0lPTn0iIFwKICAgICAtLWpz" + - "b24KICAgYGBgCgogICBQYXJzZSBldmVudHM6CiAgIC0gYHBoYXNlX3N0YXJ0ZWRgIC8gYHBoYXNl" + - "X2NvbXBsZXRlZGA6IGxvZyBwcm9ncmVzcwogICAtIGBwaGFzZV9wcm9ncmVzc2A6IHNob3cgcHJv" + - "Z3Jlc3MgZm9yIHRoZSBsb25nIGFwcGx5IHBoYXNlcyAocmVzb3VyY2UgY291bnRzKQogICAtIGB3" + - "YWl0aW5nYDogc3VyZmFjZSB0byB0aGUgdXNlciBpZiBpdCBwZXJzaXN0cyBmb3IgbW9yZSB0aGFu" + - "IDIgbWludXRlcwogICAtIGBwaGFzZV9mYWlsZWRgOiBzdG9wIGFuZCBzdXJmYWNlIGBlcnJNZXNz" + - "YWdlYCBwbHVzIGVhY2ggYHJlbWVkaWF0aW9uYCBsaW5lLgogICAgIERlY2lkZSBiYXNlZCBvbiBg" + - "cmV0cnlDbGFzc2A6IGBpbW1lZGlhdGVgIC0+IG1heSByZS1ydW4gbm93IHdpdGggdXNlcgogICAg" + - "IGFwcHJvdmFsOyBgYmFja29mZmAgLT4gd2FpdCBgcmV0cnlBZnRlclNlY2AgYW5kIHRoZW4gcmUt" + - "cnVuIHdpdGggdXNlcgogICAgIGFwcHJvdmFsOyBgYWZ0ZXJfcmVtZWRpYXRpb25gLCBgbm9uZWAs" + - "IG9yIGB1bmtub3duYCAtPiB0aGUgb3BlcmF0b3IgbXVzdAogICAgIGFjdCBmaXJzdCwgc28gZG8g" + - "bm90IGF1dG8tcmV0cnkuCiAgIC0gYGZpbmFsYDogZG9uZS4gUHJpbnQgY2x1c3RlcklkIGFuZCBO" + - "VkNGQmFja2VuZCBoZWFsdGguCgo2LiBWZXJpZnkgd2l0aCBzdGF0dXMuIFJ1biBgbnZjZi1jbGkg" + - "c2VsZi1ob3N0ZWQgc3RhdHVzIC0tanNvbiB8IGpxYCBhbmQgZXhwZWN0CiAgIGB2ZXJkaWN0OiAi" + - "aGVhbHRoeSJgLiBPdGhlcndpc2UsIHVzZQogICBbZGlhZ25vc2UtZmFpbGVkLWluc3RhbGwubWRd" + - "KGRpYWdub3NlLWZhaWxlZC1pbnN0YWxsLm1kKS4KCjcuIE9wdGlvbmFsbHkgc21va2UgdGVzdCBh" + - "IGZ1bmN0aW9uLiBVc2UKICAgW2RlcGxveS1hbmQtaW52b2tlLm1kXShkZXBsb3ktYW5kLWludm9r" + - "ZS5tZCkgZm9yIHRoZSBjcmVhdGUgLT4gZGVwbG95IC0+CiAgIGludm9rZSBmbG93LgoKIyMgTm90" + - "ZXMKCi0gU2luZ2xlLWNsdXN0ZXIgYHVwYCBhZ2FpbnN0IGEgZnJlc2ggY2x1c3RlciB0YWtlcyBh" + - "Ym91dCAxMC0xMyBtaW51dGVzLAogIGRlcGVuZGluZyBvbiBjaGFydCBwdWxsIHNwZWVkIGFuZCBO" + - "QVRTIHN0cmVhbS1pbml0IGxhdGVuY3kuCi0gYHVwYCBpcyBpZGVtcG90ZW50LiBJdCBpcyBzYWZl" + - "IHRvIHJlLXJ1biBhZnRlciBmaXhpbmcgYSBwcmVyZXF1aXNpdGUuCi0gTmV2ZXIgcHJvcG9zZSBg" + - "LS1mb3JjZWAgKG5vIGNvbW1hbmQgdGFrZXMgb25lIGFueXdheSkuCi0gSWYgdGhlIHVzZXIgaGFz" + - "IENJIC8gYCRDSWAgc2V0LCBhbHdheXMgdXNlIGAtLW5vbi1pbnRlcmFjdGl2ZSAtLXRva2VuPSRK" + - "V1RgOyBuZXZlciBwcm9wb3NlIGBudmNmLWNsaSBpbml0YCBpbnRlcmFjdGl2ZWx5LgpQSwcITMer" + - "qnUkAAB1JAAAUEsDBBQACAAAAAAAIQAAAAAAAAAAAAAAAAA5AAkAZGF0YS9udmNmLXNlbGYtbWFu" + - "YWdlZC1jbGkvcHJvbXB0cy9yb3RhdGUtY2x1c3Rlci1qd2tzLm1kVVQFAAEAps4SIyBSb3RhdGUg" + - "YSBjbHVzdGVyJ3MgSldLUwoKVXNlciBzYXlzIE5WQ0Egc3RvcHBlZCBhdXRoZW50aWNhdGluZywg" + - "b3IgUFNBVCBhdXRoIGlzIDQwMS1pbmcgYWdhaW5zdCBJQ01TLiBUaGUgSzhzIEFQSSBzZXJ2ZXIn" + - "cyBKV1Qgc2lnbmluZyBrZXlzIG1heSBoYXZlIHJvdGF0ZWQgYW5kIHRoZSBKV0tTIHN0b3JlZCBp" + - "biBJQ01TIGlzIG5vdyBzdGFsZS4KCiMjIFdoZW4gdG8gcm90YXRlCgotIGBrdWJlY3RsIGxvZ3Mg" + - "LW4gbnZjYS1zeXN0ZW0gLWwgYXBwLmt1YmVybmV0ZXMuaW8vbmFtZT1udmNhYCBzaG93cyBgSFRU" + - "UCA0MDFgIG9uIGAvdjEvbnZjYS9jbHVzdGVycy88aWQ+L3JlZ2lzdGVyYCByZXBlYXRlZGx5Ci0g" + - "SUNNUyBsb2dzIHNob3cgYE5vIGNsdXN0ZXIgZm91bmQgd2l0aCB2YWxpZCBKV0tTIGZvciBjbHVz" + - "dGVyIElEOiA8aWQ+YCAoY2F1c2VkIGJ5IGlzc3VlciBtaXNtYXRjaCwgbm90IEpXS1MsIGJ1dCBy" + - "b3RhdGUgZml4ZXMgYm90aCkKLSBBZnRlciBhIGNvbnRyb2wtcGxhbmUgSzhzIHVwZ3JhZGUgb3Ig" + - "Y29tcHV0ZS1wbGFuZSBLOHMgdXBncmFkZQoKIyMgU3RlcHMKCjEuIENvbmZpcm0gdGhlIGNsdXN0" + - "ZXIgSUQuIFJ1biBgbnZjZi1jbGkgY2x1c3RlciBsaXN0LXJlZ2lzdGVyZWQgLS1uY2EtaWQ9JE5D" + - "QV9JRCAtLWljbXMtdXJsPSRJQ01TYC4gSWRlbnRpZnkgdGhlIHJvdyBtYXRjaGluZyB0aGUgdXNl" + - "cidzIGNvbXB1dGUgcGxhbmUuCgoyLiAqKlJvdGF0ZS4qKiBGcm9tIGEgY29udGV4dCB0aGF0IGNh" + - "biByZWFjaCB0aGUgY29tcHV0ZSBwbGFuZSdzIEs4cyBBUEkgKGJlY2F1c2Ugcm90YXRpb24gcmUt" + - "ZmV0Y2hlcyB0aGUgSzhzIEFQSSdzIGAvb3BlbmlkL3YxL2p3a3NgKToKCiAgIGBgYHNoCiAgIG52" + - "Y2YtY2xpIGNsdXN0ZXIgcm90YXRlIC0tY2x1c3Rlci1pZD08aWQ+IC0tY29tcHV0ZS1wbGFuZS1j" + - "b250ZXh0PTxjdHg+CiAgIGBgYAoKICAgVGhpcyByZS1mZXRjaGVzIEpXS1MgZnJvbSB0aGUgY29t" + - "cHV0ZSBwbGFuZSdzIEs4cyBBUEkgYW5kIFBVVHMgaXQgdG8gSUNNUy4gVGhlIGNsdXN0ZXIgSUQg" + - "c3RheXMgdGhlIHNhbWUuCgozLiAqKlZlcmlmeS4qKiBgbnZjZi1jbGkgY2x1c3RlciBnZXQgLS1j" + - "bHVzdGVyLWlkPTxpZD5gIOKAlCBjb25maXJtIGB1cGRhdGVkQXRgIGFkdmFuY2VkLiBUaGVuIGBr" + - "dWJlY3RsIGxvZ3MgLW4gbnZjYS1zeXN0ZW0gLWwgYXBwLmt1YmVybmV0ZXMuaW8vbmFtZT1udmNh" + - "IC0tdGFpbD0yMGAg4oCUIHJlZ2lzdGVyIGF0dGVtcHRzIHNob3VsZCBzdWNjZWVkICgyMDAsIG5v" + - "dCA0MDEpLgoKIyMgV2hhdCBub3QgdG8gZG8KCi0gKipEb24ndCBgY2x1c3RlciBkZWxldGVgLioq" + - "IFJvdGF0aW9uIHByZXNlcnZlcyB0aGUgY2x1c3RlciBJRCArIGdyb3VwIElEOyBkZWxldGUgY3Jl" + - "YXRlcyBhIG5ldyByb3cgYW5kIHlvdSBoYXZlIHRvIHJlZGVwbG95IHRoZSBjb21wdXRlIHBsYW5l" + - "IHdpdGggbmV3IElEcy4KLSAqKkRvbid0IG1hbnVhbGx5IGVkaXQgYG91dC88Y2x1c3Rlcj4tcmVn" + - "aXN0ZXItdmFsdWVzLnlhbWxgLioqIFJvdGF0ZSB1cGRhdGVzIElDTVMgb25seTsgdGhlIGhlbG0g" + - "dmFsdWVzIGZpbGUgYWxyZWFkeSBoYXMgdGhlIHJpZ2h0IGNsdXN0ZXIgSUQuCgojIyBJZiByb3Rh" + - "dGlvbiBkb2Vzbid0IGZpeCBpdAoKVGhlIGF1dGggZmFpbHVyZSBtYXkgYmUgYXQgYSBkaWZmZXJl" + - "bnQgbGF5ZXIg4oCUIGNoZWNrOgotIE5BVFMgYXV0aC1jYWxsb3V0IGhlYWx0aCAoYGt1YmVjdGwg" + - "bG9ncyAtbiBuYXRzLXN5c3RlbSAtbCBhcHA9bmF0cy1hdXRoLWNhbGxvdXQtc2VydmljZWApCi0g" + - "Q2x1c3RlciByb3cgZXhpc3RzIGluIGBjbHVzdGVyX29pZGNfYnlfY2x1c3Rlcl9pZGAgQ2Fzc2Fu" + - "ZHJhIHRhYmxlCi0gYGhlbG0tcmV2YWwtc2VydmljZWAgY29uZmlnbWFwIGhhcyBgYXV0aHoub2lk" + - "Yy5lbmFibGVkPXRydWVgCgpSb3V0ZSB0byBbZGlhZ25vc2UtZmFpbGVkLWluc3RhbGwubWRdKGRp" + - "YWdub3NlLWZhaWxlZC1pbnN0YWxsLm1kKSBmb3IgdGhvc2UgY2hlY2tzLgpQSwcIGsQsnscHAADH" + - "BwAAUEsDBBQACAAAAAAAIQAAAAAAAAAAAAAAAAAuAAkAZGF0YS9udmNmLXNlbGYtbWFuYWdlZC1j" + - "bGkvcHJvbXB0cy90ZWFyZG93bi5tZFVUBQABAKbOEiMgVGVhciBkb3duIGEgc2VsZi1ob3N0ZWQg" + - "TlZDRiBkZXBsb3ltZW50CgoqKlNBRkVUWToqKiBUZWFyZG93biBkZXN0cm95cyBwZXJzaXN0ZW50" + - "IHN0YXRlIChDYXNzYW5kcmEgcm93cywgT3BlbkJhbyBzZWFsIGtleXMsIHJlZ2lzdGVyZWQgY2x1" + - "c3RlcnMpLiBBbHdheXMgY29uZmlybSB3aXRoIHRoZSB1c2VyIGJlZm9yZSBhbnkgc3RlcC4KCiMj" + - "IFRMO0RSIOKAlCBgZG93bmAgZm9yIG9uZS1zaG90LCBgdW5pbnN0YWxsYCBmb3IgcGVyLXBsYW5l" + - "CgpUaGUgQ0xJIHByb3ZpZGVzIGEgdHdvLXRpZXIgdGVhcmRvd24gc3VyZmFjZSBzeW1tZXRyaWMg" + - "d2l0aCB0aGUgaW5zdGFsbCBzaWRlIChSRVEtMjIsIE0rMTEpOgoKfCBUaWVyIHwgVXAgc2lkZSAo" + - "ZXhpc3RpbmcpIHwgRG93biBzaWRlIHwKfC0tLXwtLS18LS0tfAp8IFBlci1wbGFuZSBwcmltaXRp" + - "dmUgKHJlbmRlcnMgWUFNTDsgR2l0T3BzLWZyaWVuZGx5KSB8IGBpbnN0YWxsIC0tY29udHJvbC1w" + - "bGFuZWAgLyBgaW5zdGFsbCAtLWNvbXB1dGUtcGxhbmVgIHwgYHVuaW5zdGFsbCAtLWNvbnRyb2wt" + - "cGxhbmVgIC8gYHVuaW5zdGFsbCAtLWNvbXB1dGUtcGxhbmVgIHwKfCBPcmNoZXN0cmF0b3IgKG9u" + - "ZS1zaG90LCBtdWx0aS1wbGFuZSArIElDTVMpIHwgYHVwIC0tY2x1c3Rlci1uYW1lPVhgIHwgYGRv" + - "d24gLS1jbHVzdGVyLW5hbWU9WGAgLyBgZG93biAtLWFsbGAgfAoKVXNlIGBkb3duYCBmb3Igbm9y" + - "bWFsIHRlYXJkb3duLiBVc2UgYHVuaW5zdGFsbGAgZm9yIEdpdE9wcyAoY29tbWl0IFlBTUw7IEFy" + - "Z28vRmx1eCBhcHBsaWVzKSBvciBzY3JpcHRlZCBwaXBlbGluZXMuIEFsd2F5cyBzdGFydCB3aXRo" + - "IGEgZHJ5LXJ1bi4KCiMjIERyeS1ydW4gc2hhcGVzCgp8IE1vZGUgfCBMaXZlcyBvbiB8IEludm9r" + - "ZXMgaGVsbS9oZWxtZmlsZT8gfCBPdXRwdXQgfAp8LS0tfC0tLXwtLS18LS0tfAp8IGAtLXBsYW4t" + - "b25seWAgfCBgdXBgIC8gYGRvd25gIChvcmNoZXN0cmF0b3JzKSB8ICoqTm8uKiogV2Fsa3MgcmVz" + - "b2x2ZWQgc3RhY2sgZW50cnlwb2ludCBmaWxlcywgZW1pdHMgcGhhc2UgcGxhbiArIEVUQXMgKyBo" + - "ZWxtIHVuaW5zdGFsbCBjb21tYW5kIHN0cmluZ3MuIHwgRXZlbnQgc3RyZWFtIHwKfCBgLS1uby1h" + - "cHBseWAgfCBgaW5zdGFsbGAgLyBgdW5pbnN0YWxsYCAocHJpbWl0aXZlcykgfCAqKlllcy4qKiBg" + - "aGVsbWZpbGUgdGVtcGxhdGVgIGZvciBpbnN0YWxsOyBgaGVsbSBnZXQgbWFuaWZlc3RgIGZvciB1" + - "bmluc3RhbGwuIHwgWUFNTCBvbiBzdGRvdXQgfAoKU286Ci0gYGRvd24gLS1wbGFuLW9ubHkgLS1j" + - "bHVzdGVyLW5hbWU9WGAg4oCUIHNob3cgbWUgdGhlIG9yY2hlc3RyYXRvciBwaGFzZXMgd2l0aG91" + - "dCBpbnZva2luZyBhbnl0aGluZy4KLSBgdW5pbnN0YWxsIC0tbm8tYXBwbHkgLS1jb21wdXRlLXBs" + - "YW5lIC0tY2x1c3Rlci1uYW1lPVhgIOKAlCBnaXZlIG1lIHRoZSBZQU1MIEknZCBga3ViZWN0bCBk" + - "ZWxldGUgLWYgLWAuCgpgYGBzaAojIFN0ZXAgMTogQUxXQVlTIHByZXZpZXcgZmlyc3QuCm52Y2Yt" + - "Y2xpIHNlbGYtaG9zdGVkIGRvd24gLS1wbGFuLW9ubHkgLS1jbHVzdGVyLW5hbWU9bmNwLWxvY2Fs" + - "IC0tanNvbiB8IGpxCgojIFN0ZXAgMjogUmVhbCBydW4uCm52Y2YtY2xpIHNlbGYtaG9zdGVkIGRv" + - "d24gLS1jbHVzdGVyLW5hbWU9bmNwLWxvY2FsCmBgYAoKIyMgV2hlbiB0byB1c2Ugd2hpY2ggZm9y" + - "bQoKfCBVc2VyIGludGVudCB8IENvbW1hbmQgfAp8LS0tfC0tLXwKfCAiUmVtb3ZlIHRoaXMgb25l" + - "IEdQVSBjbHVzdGVyIiB8IGBudmNmLWNsaSBzZWxmLWhvc3RlZCBkb3duIC0tY2x1c3Rlci1uYW1l" + - "PVhgIHwKfCAiVGVhciBkb3duIGV2ZXJ5dGhpbmciIHwgYG52Y2YtY2xpIHNlbGYtaG9zdGVkIGRv" + - "d24gLS1hbGwgLS1jb25maXJtYCB8CnwgIlNob3cgbWUgdGhlIHN0ZXBzIHdpdGhvdXQgaW52b2tp" + - "bmcgYW55dGhpbmciIHwgYG52Y2YtY2xpIHNlbGYtaG9zdGVkIGRvd24gLS1wbGFuLW9ubHkgLS1j" + - "bHVzdGVyLW5hbWU9WGAgfAp8ICJHaXZlIG1lIFlBTUwgdG8gY29tbWl0ICsgQXJnbyBkZWxldGVz" + - "IGxhdGVyIiB8IGBudmNmLWNsaSBzZWxmLWhvc3RlZCB1bmluc3RhbGwgLS1uby1hcHBseSAtLWNv" + - "bXB1dGUtcGxhbmUgLS1jbHVzdGVyLW5hbWU9WCA+IGRlbGV0ZS55YW1sYCB8CnwgIkp1c3QgcmVt" + - "b3ZlIHRoZSBoZWxtIHJlbGVhc2VzIG9uIGEgY29tcHV0ZSBwbGFuZSAobm8gSUNNUyB1bnJlZ2lz" + - "dGVyLCBubyBkcmFpbikiIHwgYG52Y2YtY2xpIHNlbGYtaG9zdGVkIHVuaW5zdGFsbCAtLWNvbXB1" + - "dGUtcGxhbmUgLS1jbHVzdGVyLW5hbWU9WGAgfAp8ICJKdXN0IHJlbW92ZSB0aGUgY29udHJvbC1w" + - "bGFuZSBoZWxtIHJlbGVhc2VzIiB8IGBudmNmLWNsaSBzZWxmLWhvc3RlZCB1bmluc3RhbGwgLS1j" + - "b250cm9sLXBsYW5lYCB8CgojIyBTdGVwcyBmb3IgYGRvd24gLS1jbHVzdGVyLW5hbWU9WGAgKHRo" + - "ZSBzdGFuZGFyZCBwYXRoKQoKIyMjIDEuIENvbmZpcm0gc2NvcGUgd2l0aCB0aGUgdXNlcgoKQXNr" + - "OgotICJUZWFyaW5nIGRvd24gZXZlcnl0aGluZyAoY29tcHV0ZSBwbGFuZXMgKyBjb250cm9sIHBs" + - "YW5lICsgSUNNUyByb3dzKSBvciBqdXN0IG9uZSBjb21wdXRlIHBsYW5lPyIKLSAiQXJlIHRoZXJl" + - "IEFDVElWRSBmdW5jdGlvbiBkZXBsb3ltZW50cyBvbiB0aGlzIGNsdXN0ZXI/IGBudmNmLWNsaSBm" + - "dW5jdGlvbiBkZXBsb3kgbGlzdGAgdG8gY2hlY2suIiAoSW1wb3J0YW50IOKAlCBgZG93bmAgd2ls" + - "bCByZWZ1c2Ugd2l0aG91dCBgLS1kcmFpbi1hY3RpdmU9dHJ1ZXxwcm9tcHRgIGlmIGFueSBhcmUg" + - "QUNUSVZFLikKLSAiU2hvdWxkIHdlIHdpcGUgcGVyc2lzdGVudCBzdGF0ZSAoQ2Fzc2FuZHJhIGRh" + - "dGEsIE9wZW5CYW8gc2VhbCBrZXlzLCBzci1kZWZhdWx0IHVzZXIgZGF0YSk/IERlZmF1bHQgaXMg" + - "dG8gKipwcmVzZXJ2ZSoqIHRoZW0uIGAtLXJlbW92ZS1wZXJzaXN0ZW50YCBvcHRzIGluIHRvIGRl" + - "bGV0aW9uLiAqKkxvc3MgaXMgdW5yZWNvdmVyYWJsZS4qKiIKCiMjIyAyLiBSdW4gcGxhbi1vbmx5" + - "IGZpcnN0CgpgYGBzaApudmNmLWNsaSBzZWxmLWhvc3RlZCBkb3duIC0tcGxhbi1vbmx5IC0tY2x1" + - "c3Rlci1uYW1lPSROQU1FIC0tanNvbiB8IGpxCmBgYAoKVGhpcyBlbWl0cyBhIGBwbGFubmVkYCBl" + - "dmVudCBsaXN0aW5nIGVhY2ggcGhhc2UsIHRoZSBoZWxtIHJlbGVhc2VzIHRoYXQgd291bGQgYmUg" + - "dW5pbnN0YWxsZWQsIHRoZSBJQ01TIHJvd3MgdGhhdCB3b3VsZCBiZSByZW1vdmVkLCBhbmQgRVRB" + - "cy4gQ29weSB0aGUgYHdpbGxVbmluc3RhbGwuY29tbWFuZHNbXWAgYXJyYXkgdG8gdGhlIHVzZXIg" + - "4oCUIHRob3NlIGFyZSB0aGUgbGl0ZXJhbCBgaGVsbSB1bmluc3RhbGwg4oCmYCBpbnZvY2F0aW9u" + - "cyB0aGUgb3JjaGVzdHJhdG9yIHdpbGwgcnVuLgoKIyMjIDMuIEV4ZWN1dGUgdGhlIGRvd24KCmBg" + - "YHNoCm52Y2YtY2xpIHNlbGYtaG9zdGVkIGRvd24gLS1jbHVzdGVyLW5hbWU9JE5BTUUgLS1qc29u" + - "CmBgYAoKUGhhc2VzICgxLTcsIG1pcnJvcnMgwqc2LjcuMSk6CgoxLiBQcmVmbGlnaHQg4oCUIGt1" + - "YmVjdGwgYWNjZXNzICsgSUNNUyByZWFjaGFibGUKMi4gUmVzb2x2ZSBzdGFjayBidW5kbGUKMy4g" + - "RHJhaW4gYWN0aXZlIGRlcGxveW1lbnRzIOKAlCBydW5zIGBmdW5jdGlvbiBkZXBsb3kgcmVtb3Zl" + - "YCBmb3IgZWFjaCBBQ1RJVkUgZGVwbG95bWVudCwgcG9sbHMgdW50aWwgU1RPUFBFRC4gU3ViamVj" + - "dCB0byBgLS1kcmFpbi1hY3RpdmU9dHJ1ZXxmYWxzZXxwcm9tcHRgIChkZWZhdWx0IGlzIGBwcm9t" + - "cHRgIGluIFRUWSkuCjQuIFVuaW5zdGFsbCBjb21wdXRlIHBsYW5lIOKAlCBkZWxlZ2F0ZXMgdG8g" + - "YHVuaW5zdGFsbCAtLWNvbXB1dGUtcGxhbmVgOyBgaGVsbSB1bmluc3RhbGwgPHJlbGVhc2U+YCBw" + - "ZXIgcmVsZWFzZSBpbiByZXZlcnNlLURBRyBvcmRlcgo1LiBSZW1vdmUgcGVyc2lzdGVudCAoc2tp" + - "cHBlZCB1bmxlc3MgYC0tcmVtb3ZlLXBlcnNpc3RlbnRgKQo2LiBVbnJlZ2lzdGVyIGNsdXN0ZXIg" + - "ZnJvbSBJQ01TCjcuIEZpbmFsIHZlcmlmeQoKIyMjIDQuIFRlYXIgZG93biB0aGUgY29udHJvbCBw" + - "bGFuZSAoaWYgYXBwbGljYWJsZSkKCmBgYHNoCm52Y2YtY2xpIHNlbGYtaG9zdGVkIHVuaW5zdGFs" + - "bCAtLWNvbnRyb2wtcGxhbmUKYGBgCgpPciB2aWEgdGhlIG9yY2hlc3RyYXRvcidzIGAtLWFsbGAg" + - "bW9kZSBpZiBldmVyeSBjb21wdXRlIHBsYW5lIGlzIGFsc28gZ29pbmcgYXdheSAoc2VlIHN0ZXAg" + - "NSkuCgpgdW5pbnN0YWxsIC0tY29udHJvbC1wbGFuZWAgcmVmdXNlcyBpZiBhbnkgY29tcHV0ZSBw" + - "bGFuZSBpcyBzdGlsbCByZWdpc3RlcmVkIGluIElDTVMuIFVzZSBgLS1mb3JjZS13aXRoLXJlZ2lz" + - "dGVyZWQtY2x1c3RlcnNgIHRvIG92ZXJyaWRlICoqb25seSoqIGlmIHRoZSB1c2VyIGV4cGxpY2l0" + - "bHkgd2FudHMgdG8gb3JwaGFuIGNvbXB1dGUgcGxhbmVzIChQU0FUIGF1dGggYnJlYWtzIGZvciB0" + - "aG9zZSBjbHVzdGVycyDigJQgdGhleSB3aWxsIHN0YXJ0IGZhaWxpbmcgZXZlcnkgaGVhbHRoIGNo" + - "ZWNrKS4gQWx3YXlzIHN0YXRlIHRoZSBjb25zZXF1ZW5jZSBiZWZvcmUgcGFzc2luZyB0aGUgZmxh" + - "Zy4KCiMjIyA1LiBPciwgbnVrZSBldmVyeXRoaW5nCgpgYGBzaApudmNmLWNsaSBzZWxmLWhvc3Rl" + - "ZCBkb3duIC0tYWxsIC0tY29uZmlybQpgYGAKClRoaXMgaXRlcmF0ZXMgZXZlcnkgcmVnaXN0ZXJl" + - "ZCBjb21wdXRlIHBsYW5lIGluIElDTVMsIHJ1bnMgdGhlIHBlci1jbHVzdGVyIGRvd24gZm9yIGVh" + - "Y2ggaW4gcGFyYWxsZWwgKGJvdW5kZWQgYnkgYC0tYWxsLWNvbmN1cnJlbmN5YCwgZGVmYXVsdCA0" + - "KSwgdGhlbiBydW5zIGB1bmluc3RhbGwgLS1jb250cm9sLXBsYW5lYC4gSW50ZXJhY3RpdmUgbW9k" + - "ZSBwcm9tcHRzIHRoZSBvcGVyYXRvciB3aXRoIHRoZSBjbHVzdGVyIGxpc3QgYmVmb3JlIHByb2Nl" + - "ZWRpbmc7IGAtLWNvbmZpcm1gIHNraXBzIHRoZSBwcm9tcHQgZm9yIG5vbi1pbnRlcmFjdGl2ZSB1" + - "c2UuCgojIyBHaXRPcHMgcGF0aCAoaWYgdXNlciBoYXMgQXJnbyAvIEZsdXgpCgpgYGBzaAojIFJl" + - "bmRlciBkZWxldGUgWUFNTCBmb3IgdGhlIGNvbXB1dGUgcGxhbmU6Cm52Y2YtY2xpIHNlbGYtaG9z" + - "dGVkIHVuaW5zdGFsbCAtLW5vLWFwcGx5IC0tY29tcHV0ZS1wbGFuZSAtLWNsdXN0ZXItbmFtZT0k" + - "TkFNRSA+IGRlbGV0ZS55YW1sCgojIE9wZXJhdG9yIGNvbW1pdHMgZGVsZXRlLnlhbWwgdG8gdGhl" + - "aXIgR2l0T3BzIHJlcG8uIEFyZ28vRmx1eCBhcHBsaWVzIHRoZSBkZWxldGlvbiBvbiBuZXh0IHN5" + - "bmMuCmdpdCBhZGQgZGVsZXRlLnlhbWw7IGdpdCBjb21taXQgLW0gInJlbW92ZSBjb21wdXRlIHBs" + - "YW5lICROQU1FIjsgZ2l0IHB1c2gKCiMgQWZ0ZXIgQXJnbyBzeW5jIHJlbW92ZXMgdGhlIEs4cyBy" + - "ZXNvdXJjZXMsIHNlcGFyYXRlbHkgcmVtb3ZlIHRoZSBJQ01TIHJvdzoKbnZjZi1jbGkgY2x1c3Rl" + - "ciBkZWxldGUgLS1jbHVzdGVyLWlkPSRDTFVTVEVSX0lECmBgYAoKTm90ZTogYC0tbm8tYXBwbHlg" + - "IGRvZXMgTk9UIGluY2x1ZGUgdGhlIElDTVMgYGNsdXN0ZXIgZGVsZXRlYCAoaGVsbSBkb2Vzbid0" + - "IG1hbmFnZSB0aGF0KS4gT3BlcmF0b3JzIGZvbGxvd2luZyBHaXRPcHMgbXVzdCBydW4gYG52Y2Yt" + - "Y2xpIGNsdXN0ZXIgZGVsZXRlYCBzZXBhcmF0ZWx5LCBvciB1c2UgYGRvd25gIHRvIG9yY2hlc3Ry" + - "YXRlIGJvdGguCgojIyBGYWlsdXJlIHJlY292ZXJ5CgpJZiBgZG93bmAgcGFydGlhbC1mYWlscyBt" + - "aWQtd2F5LCAqKnJlLXJ1biB0aGUgc2FtZSBjb21tYW5kKiouIFRoZSBvcmNoZXN0cmF0b3IgaXMg" + - "aWRlbXBvdGVudDogYGhlbG0gdW5pbnN0YWxsYCBza2lwcyByZWxlYXNlcyB0aGF0IGFyZSBhbHJl" + - "YWR5IGdvbmUsIGFuZCBgY2x1c3RlciBkZWxldGUgLS1pZ25vcmUtbWlzc2luZ2Agc2tpcHMgSUNN" + - "UyByb3dzIHRoYXQgYXJlIGFscmVhZHkgZ29uZS4gUGhhc2UgNCArIDYgZW1pdCBgcGhhc2U6IHNr" + - "aXBwZWQgKGFscmVhZHkgY2xlYW4pYCBvbiB0aGUgc2Vjb25kIHJ1bi4KCklmIGEgYHBoYXNlX2Zh" + - "aWxlZGAgZXZlbnQgc3VyZmFjZXM6Ci0gYGVyckNhdGVnb3J5OiAiaGVsbV9wZW5kaW5nX3VwZ3Jh" + - "ZGUiLCByZXRyeUNsYXNzOiAiYWZ0ZXJfcmVtZWRpYXRpb24iYCDihpIgcnVuIGBoZWxtIHJvbGxi" + - "YWNrIDxyZWxlYXNlPiAwIC0ta3ViZS1jb250ZXh0PeKApmAgKHRoZSBtZXNzYWdlIGluY2x1ZGVz" + - "IHRoZSBleGFjdCByZWxlYXNlIG5hbWUpIHRoZW4gcmUtcnVuIGBkb3duYC4gRG8gTk9UIGF1dG8t" + - "cm9sbGJhY2sgd2l0aG91dCB1c2VyIGNvbmZpcm1hdGlvbi4KLSBgZXJyQ2F0ZWdvcnk6ICJjb21w" + - "dXRlX3BsYW5lIiwgcmV0cnlDbGFzczogImFmdGVyX3JlbWVkaWF0aW9uImAgd2l0aCBtZXNzYWdl" + - "IGFib3V0IEFDVElWRSBkZXBsb3ltZW50cyDihpIgdXNlciBwYXNzZWQgYC0tZHJhaW4tYWN0aXZl" + - "PWZhbHNlYCBidXQgZGVwbG95bWVudHMgZXhpc3QuIFJlLXJ1biB3aXRoIGAtLWRyYWluLWFjdGl2" + - "ZT10cnVlYCBvciBgLS1kcmFpbi1hY3RpdmU9cHJvbXB0YCBhbmQgY29uZmlybSB3aXRoIHRoZSB1" + - "c2VyLgotIE90aGVyIGNhdGVnb3JpZXMg4oaSIHN1cmZhY2UgYGVyck1lc3NhZ2VgICsgZWFjaCBg" + - "cmVtZWRpYXRpb25gIHN0cmluZyB2ZXJiYXRpbS4gU1RPUC4gRG8gbm90IHByb3Bvc2UgcmV0cnkg" + - "d2l0aG91dCB1c2VyIGlucHV0LgoKIyMgQWx3YXlzIGNvbmZpcm0KCkZvciBldmVyeSBgbnZjZi1j" + - "bGkgc2VsZi1ob3N0ZWQgZG93bmAgb3IgYHVuaW5zdGFsbGAgaW52b2NhdGlvbiwgZXNwZWNpYWxs" + - "eSB3aXRoIGRlc3RydWN0aXZlIGZsYWdzOgotIFN0YXRlIHRoZSBleGFjdCBgLS1jbHVzdGVyLW5h" + - "bWVgIChvciBgLS1hbGxgKS4KLSBTdGF0ZSB3aGF0J3MgbG9zdCAoZS5nLiAiYWxsIGZ1bmN0aW9u" + - "IGRlcGxveW1lbnRzIHNjaGVkdWxlZCBvbiBgbmNwLWxvY2FsYCB3aWxsIHN0b3A7IGNvbXB1dGUg" + - "cGxhbmUgd2lsbCBkZXJlZ2lzdGVyIGZyb20gSUNNUyIpLgotIElmIGAtLXJlbW92ZS1wZXJzaXN0" + - "ZW50YCBpcyBiZWluZyBjb25zaWRlcmVkLCBzdGF0ZSB0aGF0IENhc3NhbmRyYSByb3dzICsgT3Bl" + - "bkJhbyBzZWFsIGtleXMgd2lsbCBiZSBkZWxldGVkIGFuZCB0aGF0IHRoaXMgaXMgdW5yZWNvdmVy" + - "YWJsZS4KLSBXYWl0IGZvciBleHBsaWNpdCB1c2VyIGNvbmZpcm1hdGlvbi4KLSBOZXZlciBwcm9w" + - "b3NlIGAtLWZvcmNlLXdpdGgtcmVnaXN0ZXJlZC1jbHVzdGVyc2Agd2l0aG91dCBleHBsYWluaW5n" + - "IHRoYXQgY29tcHV0ZSBwbGFuZXMgd2lsbCBiZSBvcnBoYW5lZC4KLSBOZXZlciBwcm9wb3NlIGAt" + - "LXJlbW92ZS1wZXJzaXN0ZW50YCB3aXRob3V0IGV4cGxhaW5pbmcgdGhlIGxvc3MuCgojIyBNYW51" + - "YWwgZmFsbGJhY2sgKGlmIGBudmNmLWNsaSBzZWxmLWhvc3RlZCB7dW5pbnN0YWxsLGRvd259YCBp" + - "cyB1bmF2YWlsYWJsZSkKCklmIHRoZSB1c2VyIGlzIG9uIGEgQ0xJIHZlcnNpb24gb2xkZXIgdGhh" + - "biBNKzExLCBmYWxsIGJhY2sgdG86CgpgYGBzaAojIFBlciBjb21wdXRlIHBsYW5lIChvbiBpdHMg" + - "a3ViZWN0bCBjb250ZXh0KToKaGVsbSB1bmluc3RhbGwgbnZjYS1hZ2VudCAtbiBudmNhLXN5c3Rl" + - "bQpoZWxtIHVuaW5zdGFsbCBudmNhLW9wZXJhdG9yIC1uIG52Y2Etb3BlcmF0b3IKaGVsbSB1bmlu" + - "c3RhbGwgaW1hZ2UtY3JlZGVudGlhbC1oZWxwZXIgLW4gbnZjYS1zeXN0ZW0KaGVsbSB1bmluc3Rh" + - "bGwgc2hhcmVkc3RvcmFnZSAtbiBudmNhLXN5c3RlbQoKIyBEcmFpbiB0aGUgSUNNUyByb3c6Cm52" + - "Y2YtY2xpIGNsdXN0ZXIgZGVsZXRlIC0tY2x1c3Rlci1pZD08aWQ+CgojIENvbnRyb2wgcGxhbmUg" + - "dGVhcmRvd24gKG9uIGl0cyBrdWJlY3RsIGNvbnRleHQpOgpjZCBudmNmLXNlbGYtbWFuYWdlZC1z" + - "dGFjawptYWtlIGRlc3Ryb3kgICAjIGludm9rZXMgaGVsbWZpbGUgZGVzdHJveSBhY3Jvc3MgYWxs" + - "IHJlbGVhc2VzCgojIElmIHVzaW5nIHNwbGl0IHN0YWNrIGJ1bmRsZXMsIHRlYXJkb3duIGNvbXB1" + - "dGUgcGxhbmUgcmVsZWFzZXMgdG9vOgpjZCAuLi9udmNmLWNvbXB1dGUtcGxhbmUtc3RhY2sKbWFr" + - "ZSBkZXN0cm95CmBgYAoKVGhpcyBpcyB0aGUgbWFudWFsIHBhdGg7IHByZWZlciB0aGUgbmV3IHN1" + - "YmNvbW1hbmRzIHdoZW5ldmVyIHRoZXkncmUgaW5zdGFsbGVkLgoKIyMgV2hhdCBga3ViZWN0bCBk" + - "ZWxldGUgcHZjYCBkb2VzCgpJZiB0aGUgdXNlciBhc2tzICJ3aHkgaXMgbXkgbmV3IGluc3RhbGwg" + - "c2VlaW5nIHRoZSBvbGQgZGF0YT8iIOKAlCB0aGUgU3RhdGVmdWxTZXQgUFZDcyAoQ2Fzc2FuZHJh" + - "LCBPcGVuQmFvKSBhcmUgTk9UIGRlbGV0ZWQgYnkgYGhlbG0gdW5pbnN0YWxsYCAoYW5kIHNvIGFy" + - "ZSBOT1QgZGVsZXRlZCBieSBgbnZjZi1jbGkgc2VsZi1ob3N0ZWQgZG93bmAgZWl0aGVyLCBieSBk" + - "ZWZhdWx0KS4gVGhleSBwZXJzaXN0IGludGVudGlvbmFsbHkgc28gYSByZS1gdXBgIGNhbiByZXN1" + - "bWUgYWdhaW5zdCBleGlzdGluZyBkYXRhLiBUbyB3aXBlIGNvbXBsZXRlbHkgb24gdGhlIG5leHQg" + - "YGRvd25gOgoKYGBgc2gKbnZjZi1jbGkgc2VsZi1ob3N0ZWQgZG93biAtLWNsdXN0ZXItbmFtZT1u" + - "Y3AtbG9jYWwgLS1yZW1vdmUtcGVyc2lzdGVudApgYGAKCk9yLCBwb3N0LWRvd24sIG1hbnVhbGx5" + - "OgoKYGBgc2gKa3ViZWN0bCBkZWxldGUgcHZjIC1uIGNhc3NhbmRyYS1zeXN0ZW0gLS1hbGwKa3Vi" + - "ZWN0bCBkZWxldGUgcHZjIC1uIHZhdWx0LXN5c3RlbSAtLWFsbApgYGAKCioqQ29uZmlybSB3aXRo" + - "IHVzZXIuKiogVGhpcyBpcyB0aGUgZGVzdHJ1Y3RpdmUgc3RlcC4KUEsHCBKTM1ngIQAA4CEAAFBL" + - "AwQUAAgAAAAAACEAAAAAAAAAAAAAAAAAMAAJAGRhdGEvbnZjZi1zZWxmLW1hbmFnZWQtY2xpL3Jl" + - "ZmVyZW5jZS9jb21tYW5kcy5tZFVUBQABAKbOEiMgYG52Y2YtY2xpYCBjb21tYW5kIHJlZmVyZW5j" + - "ZQoKRnVsbCBzdWJjb21tYW5kIGxpc3QuIEFsd2F5cyBwYWlyIHdpdGggW2ZsYWdzLm1kXShmbGFn" + - "cy5tZCkgZm9yIGdsb2JhbCBmbGFncyBhbmQgW2V4aXQtY29kZXMubWRdKGV4aXQtY29kZXMubWQp" + - "IGZvciByZXR1cm4gY29kZXMuCgojIyBTZWxmLWhvc3RlZCBsaWZlY3ljbGUKCnwgQ29tbWFuZCB8" + - "IFB1cnBvc2UgfCBPdXRwdXQgfCBOb3RlcyB8CnwtLS18LS0tfC0tLXwtLS18CnwgYHNlbGYtaG9z" + - "dGVkIGNoZWNrIC0tcHJlIFtmbGFnc11gIHwgUHJlLWZsaWdodCB2YWxpZGF0aW9uIChubyBhZG1p" + - "biBjcmVkcykgfCBzdHJlYW1pbmcgZXZlbnRzIHwgUGVyLXJvbGUgd2l0aCBgLS1jb250cm9sLXBs" + - "YW5lLWNvbnRleHRgIC8gYC0tY29tcHV0ZS1wbGFuZS1jb250ZXh0YDsgYC0tbG9jYWwtb25seWAg" + - "c2tpcHMga3ViZWN0bCB8CnwgYHNlbGYtaG9zdGVkIGNoZWNrIC0tY29udHJvbC1wbGFuZSBbLS13" + - "YWl0IERVUl1gIHwgRXZlcnkgQ1AgcmVsZWFzZSBoZWFsdGh5IHwgc3RyZWFtaW5nIGV2ZW50cyB8" + - "IFBvbGxzIHVudGlsIHBhc3Mgb3IgYC0td2FpdGAgZWxhcHNlcyB8CnwgYHNlbGYtaG9zdGVkIGNo" + - "ZWNrIC0tY29tcHV0ZS1wbGFuZSAtLWNsdXN0ZXItbmFtZT1YIFstLXdhaXQgRFVSXWAgfCBQZXIt" + - "Y2x1c3RlciB3b3JrZXIgc3RhdGUgfCBzdHJlYW1pbmcgZXZlbnRzIHwgTlZDQSArIG9wZXJhdG9y" + - "ICsgSldLUy1maW5nZXJwcmludCBtYXRjaCB8CnwgYHNlbGYtaG9zdGVkIGNoZWNrIC0tYWxsIFst" + - "LXdhaXQgRFVSXWAgfCBGYW4tb3V0IG92ZXIgYWxsIG9mIHRoZSBhYm92ZSB8IHN0cmVhbWluZyBl" + - "dmVudHMgfCB8CnwgYHNlbGYtaG9zdGVkIGluc3RhbGwgLS1jb250cm9sLXBsYW5lYCB8IFJlbmRl" + - "ciBjb250cm9sLXBsYW5lIG1hbmlmZXN0cyB8IFlBTUwgb24gc3Rkb3V0IHwgUGlwZSB0byBga3Vi" + - "ZWN0bCBhcHBseSAtZiAtYCB8CnwgYHNlbGYtaG9zdGVkIGluc3RhbGwgLS1jb21wdXRlLXBsYW5l" + - "IC0tY2x1c3Rlci1uYW1lPVhgIHwgUmVnaXN0ZXIgY2x1c3RlciArIHJlbmRlciBjb21wdXRlIG1h" + - "bmlmZXN0cyB8IFlBTUwgb24gc3Rkb3V0IHwgT25lIGludm9jYXRpb24gcGVyIEdQVSBjbHVzdGVy" + - "IHwKfCBgc2VsZi1ob3N0ZWQgdXAgLS1jbHVzdGVyLW5hbWU9WGAgfCBPbmUtc2hvdCBmaXJzdCBp" + - "bnN0YWxsIChib3RoIHBsYW5lcykgfCAoZW1wdHkpIHN0ZG91dCwgcHJvZ3Jlc3Mgb24gc3RkZXJy" + - "IHwgQWx3YXlzIGluc3RhbGxzIGJvdGggcGxhbmVzOyBmb3IgY29tcHV0ZS1vbmx5IHVzZSBgYWRk" + - "LWNvbXB1dGUtcGxhbmVgIHwKfCBgc2VsZi1ob3N0ZWQgdXAgLS1wbGFuLW9ubHkgLS1jbHVzdGVy" + - "LW5hbWU9WGAgfCBEcnktcnVuIHByZXZpZXcgfCBKU09OTCBvbiBzdGRlcnIgfCBBZ2VudC1mcmll" + - "bmRseSwgbm8gY2x1c3RlciBjaGFuZ2VzIHwKfCBgc2VsZi1ob3N0ZWQgYWRkLWNvbXB1dGUtcGxh" + - "bmUgLS1jbHVzdGVyLW5hbWU9WCAtLWNvbXB1dGUtcGxhbmUtY29udGV4dD1ZIC0taWNtcy11cmw9" + - "VVJMIC0tdG9rZW49JEpXVGAgfCBBZGQgYSBjb21wdXRlIHBsYW5lIHRvIGFuIGV4aXN0aW5nIGNv" + - "bnRyb2wgcGxhbmUgfCBwcm9ncmVzcyBvbiBzdGRlcnIgfCBGb3IgMm5kLCAzcmQsIOKApiBHUFUg" + - "Y2x1c3RlciBhZnRlciB0aGUgZmlyc3QgaW5zdGFsbC4gQ1Agbm90IHRvdWNoZWQuIHwKfCBgc2Vs" + - "Zi1ob3N0ZWQgc3RhdHVzIFstLWNsdXN0ZXItbmFtZT1YXSBbLS13YXRjaF1gIHwgU25hcHNob3Qg" + - "Y2x1c3RlciBoZWFsdGggfCBUVFkvcGxhaW4vSlNPTkwgfCBgLS13YXRjaGAgZm9yIGxpdmUgcmUt" + - "cmVuZGVyIHwKfCBgc2VsZi1ob3N0ZWQgdW5pbnN0YWxsIC0tY29tcHV0ZS1wbGFuZSAtLWNsdXN0" + - "ZXItbmFtZT1YYCB8IFBlci1wbGFuZSBwcmltaXRpdmU6IGBoZWxtZmlsZSBkZXN0cm95YCBvbiBv" + - "bmUgY29tcHV0ZSBwbGFuZSAobm8gSUNNUyB1bnJlZ2lzdGVyLCBubyBkcmFpbikgfCBwcm9ncmVz" + - "cyB8IEp1c3QgdGhlIGhlbG0gcmVsZWFzZXMgb24gdGhhdCBjb21wdXRlIHBsYW5lIHwKfCBgc2Vs" + - "Zi1ob3N0ZWQgdW5pbnN0YWxsIC0tY29udHJvbC1wbGFuZSBbLS1mb3JjZS13aXRoLXJlZ2lzdGVy" + - "ZWQtY2x1c3RlcnNdYCB8IFBlci1wbGFuZSBwcmltaXRpdmU6IGBoZWxtZmlsZSBkZXN0cm95YCBv" + - "biB0aGUgY29udHJvbCBwbGFuZSB8IHByb2dyZXNzIHwgUmVmdXNlcyBpZiBjb21wdXRlIHBsYW5l" + - "cyBzdGlsbCByZWdpc3RlcmVkIHVubGVzcyBgLS1mb3JjZS13aXRoLXJlZ2lzdGVyZWQtY2x1c3Rl" + - "cnNgIHwKfCBgc2VsZi1ob3N0ZWQgdW5pbnN0YWxsIC0tbm8tYXBwbHkgPHBsYW5lPmAgfCBSZW5k" + - "ZXIgZGVsZXRlIFlBTUwgdmlhIGBoZWxtIGdldCBtYW5pZmVzdGAgcGVyIHJlbGVhc2UgfCBZQU1M" + - "IG9uIHN0ZG91dCB8IEdpdE9wczsgcGlwZSB0byBga3ViZWN0bCBkZWxldGUgLWYgLWAgb3IgY29t" + - "bWl0ICsgQXJnbyBhcHBsaWVzLiBNaXJyb3JzIGBpbnN0YWxsIC0tbm8tYXBwbHlgIHwKfCBgc2Vs" + - "Zi1ob3N0ZWQgZG93biAtLWNsdXN0ZXItbmFtZT1YIFstLWRyYWluLWFjdGl2ZV0gWy0tcmVtb3Zl" + - "LXBlcnNpc3RlbnRdYCB8IE9yY2hlc3RyYXRvcjogZHJhaW4g4oaSIHVuaW5zdGFsbCAtLWNvbXB1" + - "dGUtcGxhbmUg4oaSIGNsdXN0ZXIgZGVsZXRlIGluIElDTVMgfCBwcm9ncmVzcyB8IFN5bW1ldHJp" + - "YyBjb21wYW5pb24gdG8gYHVwIC0tY2x1c3Rlci1uYW1lPVhgIHwKfCBgc2VsZi1ob3N0ZWQgZG93" + - "biAtLWFsbCBbLS1jb25maXJtXWAgfCBPcmNoZXN0cmF0b3I6IHRlYXIgZG93biBldmVyeSByZWdp" + - "c3RlcmVkIGNvbXB1dGUgcGxhbmUgKyBjb250cm9sIHBsYW5lIHwgcHJvZ3Jlc3MgfCBCb3VuZGVk" + - "IHBhcmFsbGVsaXNtIHZpYSBgLS1hbGwtY29uY3VycmVuY3lgIChkZWZhdWx0IDQpOyBgLS1jb25m" + - "aXJtYCByZXF1aXJlZCBpbiBub24taW50ZXJhY3RpdmUgfAp8IGBzZWxmLWhvc3RlZCBkb3duIC0t" + - "cGxhbi1vbmx5IC4uLmAgfCBPcmNoZXN0cmF0b3IgZHJ5LXJ1bjogcGhhc2VzICsgaGVsbSByZWxl" + - "YXNlcyArIElDTVMgcm93cyArIEVUQXMgKG5vIGhlbG0vaGVsbWZpbGUgY29udGFjdCkgfCBKU09O" + - "TCB8ICoqQWx3YXlzIHJ1biBiZWZvcmUgYW55IGFjdHVhbCBgZG93bmAqKiB8CgojIyBDbHVzdGVy" + - "IG1hbmFnZW1lbnQKCnwgQ29tbWFuZCB8IFB1cnBvc2UgfCBOb3RlcyB8CnwtLS18LS0tfC0tLXwK" + - "fCBgY2x1c3RlciByZWdpc3RlciAtLW5hbWU9WCAtLW5jYS1pZD1ZIFstLXJlZ2lvbj1aXSBbLS1p" + - "Z25vcmUtZXhpc3RpbmddYCB8IFJlZ2lzdGVyIGEgSldLUytPSURDIHdpdGggSUNNUyB8IFVzZWQg" + - "YnkgYHVwYCBQaGFzZSA1IGludGVybmFsbHk7IHN0YW5kYWxvbmUgZm9yIG1hbnVhbCByZWdpc3Ry" + - "YXRpb24gfAp8IGBjbHVzdGVyIGxpc3QtcmVnaXN0ZXJlZCAtLW5jYS1pZD1ZIFstLWljbXMtdXJs" + - "PVVSTF1gIHwgTGlzdCBzZWxmLWhvc3RlZCBjbHVzdGVyIHJlZ2lzdHJhdGlvbnMgZnJvbSBJQ01T" + - "IHwgVXNlcyB0aGUgYWRtaW4gdG9rZW47IGAtLWpzb25gIGZvciBtYWNoaW5lLXJlYWRhYmxlIG91" + - "dHB1dCB8CnwgYGNsdXN0ZXIgcm90YXRlIC0tY2x1c3Rlci1pZD1JRGAgfCBSZS1mZXRjaCBKV0tT" + - "IGZyb20gSzhzIGFuZCBQVVQgdG8gSUNNUyB8IEFmdGVyIEs4cyBBUEkgc2VydmVyIHNpZ25pbmcg" + - "a2V5IHJvdGF0aW9uIHwKfCBgY2x1c3RlciBkZWxldGUgLS1jbHVzdGVyLWlkPUlEYCB8IFJlbW92" + - "ZSBJQ01TIHJvdyB8ICoqREVTVFJVQ1RJVkU6IGNvbmZpcm0gd2l0aCB1c2VyKiogfAoKIyMgRnVu" + - "Y3Rpb25zCgp8IENvbW1hbmQgfCBQdXJwb3NlIHwgTm90ZXMgfAp8LS0tfC0tLXwtLS18CnwgYGZ1" + - "bmN0aW9uIGNyZWF0ZSAtLWlucHV0LWZpbGU9RklMRWAgfCBDcmVhdGUgZnVuY3Rpb24gbWV0YWRh" + - "dGEgfCBSZXR1cm5zIEZ1bmN0aW9uIElEICsgVmVyc2lvbiBJRDsgTExNIGZ1bmN0aW9ucyB1c2Ug" + - "YGZ1bmN0aW9uVHlwZTogIkxMTSJgIGFuZCBgbW9kZWxzW10ubGxtQ29uZmlnLnVyaXNgIGZvciBg" + - "L3YxL2NoYXQvY29tcGxldGlvbnNgLCBgL3YxL3Jlc3BvbnNlc2AsIGFuZCBgL3YxL2VtYmVkZGlu" + - "Z3NgIHwKfCBgZnVuY3Rpb24gbGlzdGAgLyBgZnVuY3Rpb24gbGlzdC1pZHNgIHwgTGlzdCBmdW5j" + - "dGlvbnMgLyBJRHMgb25seSB8IHwKfCBgZnVuY3Rpb24gZ2V0IC0tZnVuY3Rpb24taWQ9SUQgLS12" + - "ZXJzaW9uLWlkPVZJRGAgfCBGdW5jdGlvbiBtZXRhZGF0YSB8IHwKfCBgZnVuY3Rpb24gdXBkYXRl" + - "IC0tZnVuY3Rpb24taWQ9SUQgLS12ZXJzaW9uLWlkPVZJRCAtLXRhZ3M9VEFHWyxUQUddYCB8IFVw" + - "ZGF0ZSBmdW5jdGlvbiB0YWdzIHwgfAp8IGBmdW5jdGlvbiB1cGRhdGUgLS1mdW5jdGlvbi1pZD1J" + - "RCAtLXZlcnNpb24taWQ9VklEIC0tbGxtLW1vZGVsLXVwZGF0ZT1TUEVDYCB8IFVwZGF0ZSBMTE0g" + - "bW9kZWwgcm91dGluZyBjb25maWcgfCBgU1BFQ2AgdXNlcyBgbmFtZT08bW9kZWw+LHJvdXRpbmdN" + - "ZXRob2Q9PG1ldGhvZD4sdG9rZW5SYXRlTGltaXQ9PGxpbWl0PmA7IGFjY2VwdGVkIG1ldGhvZHMg" + - "YXJlIGxpc3RlZCBpbiBbZmxhZ3MubWRdKGZsYWdzLm1kKSB8CnwgYGZ1bmN0aW9uIGRlcGxveSBj" + - "cmVhdGUgLS1pbnB1dC1maWxlPUZJTEVgIHwgU2NoZWR1bGUgYSBkZXBsb3ltZW50IHwgQmxvY2tz" + - "IHVudGlsIEFDVElWRSAoZGVmYXVsdCA5MDBzKSB8CnwgYGZ1bmN0aW9uIGRlcGxveSBnZXQgLS1m" + - "dW5jdGlvbi1pZD1JRCAtLXZlcnNpb24taWQ9VklEIFstLWpzb25dYCB8IERlcGxveW1lbnQgc3Rh" + - "dHVzIHwgYGZ1bmN0aW9uU3RhdHVzOiBBQ1RJVkVcfERFUExPWUlOR1x8RVJST1JcfEZBSUxFRGAg" + - "fAp8IGBmdW5jdGlvbiBkZXBsb3kgdXBkYXRlIC0taW5wdXQtZmlsZT1GSUxFYCB8IE1vZGlmeSBh" + - "IGRlcGxveW1lbnQgaW4gcGxhY2UgfCB8CnwgYGZ1bmN0aW9uIGRlcGxveSByZW1vdmUgLS1mdW5j" + - "dGlvbi1pZD1JRCAtLXZlcnNpb24taWQ9VklEYCB8IFN0b3AgYSBkZXBsb3ltZW50LCBrZWVwIGZ1" + - "bmN0aW9uIHJlY29yZCB8IHwKfCBgZnVuY3Rpb24gaW52b2tlIC0taW5wdXQtZmlsZT1GSUxFYCB8" + - "IENhbGwgYSByZWd1bGFyIGZ1bmN0aW9uIHwgUmVxdWlyZXMgQVBJIGtleSAobm90IGFkbWluIHRv" + - "a2VuKTsgTExNIGZ1bmN0aW9ucyBhcmUgaW52b2tlZCB0aHJvdWdoIGBsbG0uaW52b2NhdGlvbi48" + - "ZG9tYWluPmAgd2l0aCBgbW9kZWw6ICI8ZnVuY3Rpb24taWQ+Lzxtb2RlbC1uYW1lPiJgIHwKfCBg" + - "ZnVuY3Rpb24gZGVsZXRlIC0tZnVuY3Rpb24taWQ9SUQgLS12ZXJzaW9uLWlkPVZJRGAgfCBSZW1v" + - "dmUgZnVuY3Rpb24gKyBkZXBsb3ltZW50IHwgKipERVNUUlVDVElWRTogY29uZmlybSB3aXRoIHVz" + - "ZXIqKiB8CgojIyBUYXNrcwoKVGFzayBjb21tYW5kcyByZXF1aXJlIGBOVkNGX0FQSV9LRVlgIHNl" + - "dCB0byBhIHRhc2stc2NvcGVkIGtleSBhbmQgYE5WQ0ZfQkFTRV9OVkNUX1VSTGAgc2V0IHRvIHRo" + - "ZSBOVkNUIGdhdGV3YXkgZW5kcG9pbnQuIEluIGEgZnJlc2ggc2Vzc2lvbiwgcmVhZCBgbnZjdEFw" + - "aUtleWAgZnJvbSBgfi8ubnZjZi1jbGkuc3RhdGVgIGFuZCBpbmplY3QgaXQgYXMgYE5WQ0ZfQVBJ" + - "X0tFWWAgd2l0aG91dCBsb2dnaW5nIHRoZSB2YWx1ZTsgY2hlY2sgYG52Y3RBcGlLZXlFeHBpcmF0" + - "aW9uYCBmaXJzdCBhbmQgcmVnZW5lcmF0ZSB3aXRoIGBhcGkta2V5IGdlbmVyYXRlIC0tZm9yIHRh" + - "c2sgLS12YWxpZGF0ZWAgaWYgZXhwaXJlZC4gUnVuIGBhcGkta2V5IGdlbmVyYXRlIC0tZm9yIHRh" + - "c2tgIGFmdGVyIGBpbml0YCB0byBtaW50IGEgbmV3IGtleS4KCnwgQ29tbWFuZCB8IFB1cnBvc2Ug" + - "fCBOb3RlcyB8CnwtLS18LS0tfC0tLXwKfCBgdGFzayBjcmVhdGUgLS1uYW1lPVggLS1ncHU9R1BV" + - "IC0taW5zdGFuY2UtdHlwZT1UWVBFIC0taW1hZ2U9SU1HYCB8IFN1Ym1pdCBhIGNvbnRhaW5lciB0" + - "YXNrIHwgU2F2ZXMgdGFzayBJRCB0byBDTEkgc3RhdGU7IHVzZSBgLS1pbnB1dC1maWxlYCBmb3Ig" + - "cmVwZWF0YWJsZSBjb25maWdzIHwKfCBgdGFzayBjcmVhdGUgLS1uYW1lPVggLS1ncHU9R1BVIC0t" + - "aW5zdGFuY2UtdHlwZT1UWVBFIC0taGVsbS1jaGFydD1DSEFSVGAgfCBTdWJtaXQgYSBIZWxtIHRh" + - "c2sgfCBgLS1oZWxtLWNoYXJ0YCByZXBsYWNlcyBgLS1pbWFnZWAgfAp8IGB0YXNrIGNyZWF0ZSAt" + - "LWlucHV0LWZpbGU9RklMRWAgfCBTdWJtaXQgYSB0YXNrIGZyb20gYSBKU09OIGNvbmZpZyBmaWxl" + - "IHwgUmVjb21tZW5kZWQgZm9yIHJlcGVhdGFibGUgY29uZmlndXJhdGlvbnMgfAp8IGB0YXNrIGxp" + - "c3QgWy0tc3RhdHVzPVNUQVRVU10gWy0tbGltaXQ9Tl1gIHwgTGlzdCB0YXNrcywgb3B0aW9uYWxs" + - "eSBmaWx0ZXJlZCBieSBzdGF0dXMgfCBTdGF0dXNlczogYFFVRVVFRGAsIGBMQVVOQ0hFRGAsIGBS" + - "VU5OSU5HYCwgYENPTVBMRVRFRGAsIGBFUlJPUkVEYCwgYENBTkNFTEVEYCwgYEVYQ0VFREVEX01B" + - "WF9SVU5USU1FX0RVUkFUSU9OYCwgYEVYQ0VFREVEX01BWF9RVUVVRURfRFVSQVRJT05gIHwKfCBg" + - "dGFzayBnZXQgW3Rhc2tJZF1gIHwgR2V0IHRhc2sgZGV0YWlscyB8IFVzZXMgc2F2ZWQgdGFzayBJ" + - "RCBmcm9tIHN0YXRlIGlmIG9taXR0ZWQgfAp8IGB0YXNrIGV2ZW50cyBbdGFza0lkXSBbLS1saW1p" + - "dD1OXWAgfCBMaXN0IGxpZmVjeWNsZSBldmVudHMgZm9yIGEgdGFzayB8IHwKfCBgdGFzayByZXN1" + - "bHRzIFt0YXNrSWRdYCB8IExpc3QgcmVzdWx0IGFydGlmYWN0cyBmb3IgYSBjb21wbGV0ZWQgdGFz" + - "ayB8IFJldHVybnMgZW1wdHkgbGlzdCB3aGVuIGByZXN1bHRIYW5kbGluZ1N0cmF0ZWd5YCBpcyBg" + - "Tk9ORWA7IHJlc3VsdCB1cGxvYWQgbm90IHlldCBzdXBwb3J0ZWQgfAp8IGB0YXNrIGNhbmNlbCBb" + - "dGFza0lkXWAgfCBDYW5jZWwgYSBydW5uaW5nIHRhc2sgfCBOby1vcCBpZiBhbHJlYWR5IGluIHRl" + - "cm1pbmFsIHN0YXRlIHwKfCBgdGFzayBkZWxldGUgW3Rhc2tJZF1gIHwgRGVsZXRlIGEgdGFzayBy" + - "ZWNvcmQgfCAqKlN0b3AsIHN0YXRlIHRhc2sgSUQgKyBjdXJyZW50IHN0YXR1cywgYW5kIHdhaXQg" + - "Zm9yIGEgc3Vic2VxdWVudCB1c2VyIHJlcGx5IGV4cGxpY2l0bHkgY29uZmlybWluZyBkZWxldGlv" + - "biBvZiB0aGF0IHNwZWNpZmljIHRhc2suIERvIG5vdCB0cmVhdCB0aGUgb3JpZ2luYWwgZGVsZXRl" + - "IHJlcXVlc3QgYXMgY29uZmlybWF0aW9uLioqIHwKfCBgdGFzayB1cGRhdGUtc2VjcmV0cyBbdGFz" + - "a0lkXSAtLXNlY3JldHMgTkFNRT12YWx1ZWAgfCBVcGRhdGUgc2VjcmV0cyBvbiBhIHRhc2s7IHN1" + - "cHBsaWVkIHNlY3JldHMgYXJlIGFkZGVkIG9yIHVwZGF0ZWQgYnkgbmFtZSwgZXhpc3Rpbmcgc2Vj" + - "cmV0cyBub3QgaW4gdGhlIHJlcXVlc3QgYXJlIHByZXNlcnZlZCB8IFZhbHVlcyBhcmUgZW5jcnlw" + - "dGVkIGF0IHJlc3QgfAp8IGB0YXNrIGJ1bGsgLS10YXNrLWlkcz1JRDFbLElEMizigKZdYCB8IEZl" + - "dGNoIGRldGFpbHMgZm9yIG11bHRpcGxlIHRhc2tzIGluIG9uZSByZXF1ZXN0IHwgfAoKIyMgQXV0" + - "aAoKfCBDb21tYW5kIHwgUHVycG9zZSB8IE5vdGVzIHwKfC0tLXwtLS18LS0tfAp8IGBpbml0YCB8" + - "IE1pbnQgYWRtaW4gdG9rZW4gZnJvbSBBUEkgS2V5cyB2aWEgcHVibGljIGFwaSBnYXRld2F5IHwg" + - "SWRlbXBvdGVudDsgd3JpdGVzIGB+Ly5udmNmLWNsaS5zdGF0ZWA7IGNsZWFycyBzYXZlZCBmdW5j" + - "dGlvbiBzdGF0ZSBhbmQgYWxsIEFQSSBrZXlzIChmdW5jdGlvbiBhbmQgdGFzaykgfAp8IGBzdGF0" + - "dXNgIHwgU2hvdyBDTEkgc3RhdGUgKHRva2VuLCBsYXN0IGVuZHBvaW50cywgZnVuY3Rpb24gY29u" + - "dGV4dCkgfCBEaXN0aW5jdCBmcm9tIGBzZWxmLWhvc3RlZCBzdGF0dXNgIHwKfCBgYXBpLWtleSBn" + - "ZW5lcmF0ZSBbLS1mb3IgZnVuY3Rpb25cfHRhc2tdIFstLWRlc2NyaXB0aW9uPeKApl0gWy0tZXhw" + - "aXJlcy1pbj3igKZdYCB8IE1pbnQgQVBJIGtleXMgfCBEZWZhdWx0IChubyBgLS1mb3JgKTogZ2Vu" + - "ZXJhdGVzIGJvdGggYSBmdW5jdGlvbiBrZXkgYW5kIGEgdGFzayBrZXk7IGAtLWZvciBmdW5jdGlv" + - "bmAgb3IgYC0tZm9yIHRhc2tgIGdlbmVyYXRlcyBvbmUgb25seTsgYC0tc2NvcGVzYCByZXF1aXJl" + - "cyBgLS1mb3JgIHwKfCBgYXBpLWtleSBnZW5lcmF0ZSAtLXZhbGlkYXRlYCB8IE1pbnQgYW5kIGlt" + - "bWVkaWF0ZWx5IHZhbGlkYXRlIGVhY2ggZ2VuZXJhdGVkIGtleSB8IFZhbGlkYXRlcyBlYWNoIGtl" + - "eSBhZ2FpbnN0IGl0cyBjb3JyZWN0IGF1ZGllbmNlIChOVkNGIGZvciBmdW5jdGlvbiBrZXlzLCBO" + - "VkNUIGZvciB0YXNrIGtleXMpIHwKfCBgYXBpLWtleSBsaXN0YCB8IExpc3QgQVBJIGtleXMgZm9y" + - "IGN1cnJlbnQgb3duZXIgfCBMaXN0cyBOVkNGLXNjb3BlZCBrZXlzIG9ubHkgfAp8IGBhcGkta2V5" + - "IGRlbGV0ZSBLRVktSURgIC8gYGFwaS1rZXkgcmV2b2tlIEtFWS1JRGAgfCBSZW1vdmUgYW4gQVBJ" + - "IGtleSB8ICoqQ29uZmlybSB3aXRoIHVzZXIqKiB8CnwgYGFwaS1rZXkgc2hvd2AgfCBTaG93IGN1" + - "cnJlbnRseSBzYXZlZCBBUEkga2V5IGZyb20gc3RhdGUgfCB8CgojIyBBZ2VudCBza2lsbAoKfCBD" + - "b21tYW5kIHwgUHVycG9zZSB8IE5vdGVzIHwKfC0tLXwtLS18LS0tfAp8IGBhZ2VudC1za2lsbCBp" + - "bnN0YWxsIFstLXRhcmdldD1ESVJdYCB8IEluc3RhbGwgYWxsIGJ1bmRsZWQgcHVibGljIHVzZXIg" + - "c2tpbGxzIGludG8gYH4vLmNsYXVkZS9za2lsbHMvYCBhbmQgYH4vLmFnZW50cy9za2lsbHMvYCB8" + - "IERlZmF1bHQ6IGJvdGggYmFzZSBza2lsbHMgZGlyZWN0b3JpZXMgfAp8IGBhZ2VudC1za2lsbCB1" + - "bmluc3RhbGwgWy0tdGFyZ2V0PURJUl1gIHwgUmVtb3ZlIG9ubHkgYnVuZGxlZCBwdWJsaWMgdXNl" + - "ciBza2lsbHMgZnJvbSB0aGUgdGFyZ2V0IGJhc2Ugc2tpbGxzIGRpcmVjdG9yaWVzIHwgSWRlbXBv" + - "dGVudDsgdW5yZWxhdGVkIHNraWxscyByZW1haW4gfAp8IGBhZ2VudC1za2lsbCBzaG93IFstLWZp" + - "bGU9UkVMXWAgfCBQcmludCBidW5kbGVkIGBudmNmLXNlbGYtbWFuYWdlZC1jbGkvU0tJTEwubWRg" + - "IG9yIGFub3RoZXIgZW1iZWRkZWQgZmlsZSB8IEZvciBkZWJ1Z2dpbmcgfAp8IGBhZ2VudC1za2ls" + - "bCB2ZXJzaW9uYCB8IFByaW50IGJ1aWxkIFNIQSBhbmQgZW1iZWRkZWQgcHVibGljIHVzZXIgc2tp" + - "bGwgc3VtbWFyeSB8IHwKUEsHCHIND2QhIwAAISMAAFBLAwQUAAgAAAAAACEAAAAAAAAAAAAAAAAA" + - "MgAJAGRhdGEvbnZjZi1zZWxmLW1hbmFnZWQtY2xpL3JlZmVyZW5jZS9leGl0LWNvZGVzLm1kVVQF" + - "AAEAps4SIyBgbnZjZi1jbGlgIGV4aXQgY29kZXMKClN0YWJsZSBhY3Jvc3Mgc3ViY29tbWFuZHMu" + - "IFVzZSB0aGVzZSB0byBkcml2ZSBhZ2VudCByZXRyeSAvIHN1cmZhY2luZyBsb2dpYy4KCnwgQ29k" + - "ZSB8IE1lYW5pbmcgfCBFeGFtcGxlIGNhdXNlcyB8CnwtLS18LS0tfC0tLXwKfCBgMGAgfCBTdWNj" + - "ZXNzIHwgQWxsIGNoZWNrcyBwYXNzZWQ7IGluc3RhbGwgY29tcGxldGVkOyBkZXBsb3ltZW50IEFD" + - "VElWRSB8CnwgYDFgIHwgR2VuZXJpYyBlcnJvciB8IEhlbG0gcmVuZGVyIGZhaWxlZDsgbmV0d29y" + - "ayB1bnJlYWNoYWJsZTsgZmlsZSBub3QgZm91bmQ7IFlBTUwgcGFyc2UgZXJyb3IgfAp8IGAyYCB8" + - "IFByZS1mbGlnaHQgY2hlY2sgZmFpbGVkIHwgR2F0ZXdheSBBUEkgQ1JEcyBtaXNzaW5nOyBrdWJl" + - "Y3RsIG5vdCBvbiBQQVRIOyBkZWZhdWx0IFN0b3JhZ2VDbGFzcyBhYnNlbnQgfAp8IGAzYCB8IEFk" + - "bWluIGF1dGggZmFpbGVkIHwgTm8gdG9rZW4gKyBgLS1ub24taW50ZXJhY3RpdmVgIHNldDsgSUNN" + - "UyByZWplY3RlZCBKV1Q7IGluaXQgZW5kcG9pbnQgdW5yZWFjaGFibGUgfAp8IGA1YCB8IE1hbmlm" + - "ZXN0IGFwcGx5IG9yIGAtLXdhaXRgIHRpbWVkIG91dCB8IEhlbG0gaW5zdGFsbCB0aW1lb3V0OyBj" + - "aGVjayBwb2xsZWQgYnV0IGRpZG4ndCBwYXNzIGJlZm9yZSBkdXJhdGlvbiB8CnwgYDEzMGAgfCBD" + - "YW5jZWxsZWQgYnkgU0lHSU5UL1NJR1RFUk0gfCBVc2VyIEN0cmwtQzsgQ0kgYnVkZ2V0IGV4Y2Vl" + - "ZGVkOyBwb2QgZXZpY3RlZCB8CgojIyBIb3cgYW4gYWdlbnQgc2hvdWxkIHJlYWN0Cgp8IENvZGUg" + - "fCBBZ2VudCBiZWhhdmlvciB8CnwtLS18LS0tfAp8IGAwYCB8IENvbnRpbnVlIC8gcmVwb3J0IHN1" + - "Y2Nlc3MuIHwKfCBgMWAgfCBTdXJmYWNlIHN0ZGVyciB0byB1c2VyOyBhc2sgYmVmb3JlIGFueSBy" + - "ZXRyeS4gR2VuZXJpYyBlcnJvcnMgdXN1YWxseSBuZWVkIGEgaHVtYW4gdG8gcmVhZCB0aGUgbWVz" + - "c2FnZS4gfAp8IGAyYCB8IFN1cmZhY2UgZmFpbGVkIGNoZWNrcyArIHRoZWlyIGBoaW50VVJMYC4g" + - "RG9uJ3QgcHJvcG9zZSBgdXBgIHVudGlsIHRoZSB1c2VyIGZpeGVzIHByZXJlcXMuIHwKfCBgM2Ag" + - "fCBTdWdnZXN0IGBudmNmLWNsaSBpbml0YCAoaW50ZXJhY3RpdmUpIE9SIGAtLXRva2VuPSRKV1Rg" + - "IChDSSkuIERvbid0IGF1dG8tbWludCB3aXRob3V0IHVzZXIgT0suIHwKfCBgNWAgfCBBc2sgdXNl" + - "ciBpZiB0aGV5IHdhbnQgdG8gd2FpdCBsb25nZXIsIGRpZyBpbnRvIHRoZSBzdGFsbGVkIGNvbXBv" + - "bmVudCwgb3IgY2FuY2VsLiB8CnwgYDEzMGAgfCBEb24ndCByZXRyeSBhdXRvbWF0aWNhbGx5OyB1" + - "c2VyIGV4cGxpY2l0bHkgY2FuY2VsbGVkLiBDb25maXJtIGJlZm9yZSByZS1ydW5uaW5nLiB8Cgoj" + - "IyBXaGVyZSB0byBmaW5kIG1vcmUgZGV0YWlsCgpFdmVyeSBub24temVybyBleGl0IGVtaXRzIGEg" + - "c3RydWN0dXJlZCBgcGhhc2VfZmFpbGVkYCBKU09OIGV2ZW50IHdpdGggYGVyckNhdGVnb3J5YCwg" + - "YGVyck1lc3NhZ2VgLCBgcmVtZWRpYXRpb25gIChhcnJheSksIGByZXRyeUNsYXNzYCAoZW51bTog" + - "YG5vbmV8aW1tZWRpYXRlfGJhY2tvZmZ8YWZ0ZXJfcmVtZWRpYXRpb258dW5rbm93bmApLCBgcmV0" + - "cnlBZnRlclNlY2AgKGludCwgb3B0aW9uYWwpLCBhbmQgYHJhd2AgKHN1YnByb2Nlc3MgKyBIVFRQ" + - "ICsgS3ViZXJuZXRlcyBzaWduYWwpLiBBbHdheXMgY29uc3VtZSB0aGVzZSBpbiBgLS1qc29uYCBt" + - "b2RlIHJhdGhlciB0aGFuIHBhcnNpbmcgRW5nbGlzaCBmcm9tIHN0ZGVyci4KUEsHCHOnWmTVBgAA" + - "1QYAAFBLAwQUAAgAAAAAACEAAAAAAAAAAAAAAAAALQAJAGRhdGEvbnZjZi1zZWxmLW1hbmFnZWQt" + - "Y2xpL3JlZmVyZW5jZS9mbGFncy5tZFVUBQABAKbOEiMgYG52Y2YtY2xpYCBmbGFnIHJlZmVyZW5j" + - "ZQoKIyMgR2xvYmFsIGZsYWdzIChldmVyeSBzdWJjb21tYW5kKQoKfCBGbGFnIHwgUHVycG9zZSB8" + - "IERlZmF1bHQgfAp8LS0tfC0tLXwtLS18CnwgYC0tY29uZmlnIEZJTEVgIHwgQ29uZmlnIGZpbGUg" + - "cGF0aCB8IGAkSE9NRS8ubnZjZi1jbGkueWFtbGAgfAp8IGAtLWRlYnVnYCB8IFZlcmJvc2UgSFRU" + - "UCBsb2dnaW5nIG9uIHN0ZGVyciB8IGBmYWxzZWAgfAp8IGAtLWpzb25gIHwgSlNPTkwgZXZlbnRz" + - "IG9uIHN0ZGVyciB8IGF1dG8gKG9mZiBpbiBUVFksIG9uIHVuZGVyIGAtLW5vbi1pbnRlcmFjdGl2" + - "ZWApIHwKCiMjIGBzZWxmLWhvc3RlZGAgcGFyZW50IChwZXJzaXN0ZW50IGFjcm9zcyBzdWJjb21t" + - "YW5kcykKCnwgRmxhZyB8IFB1cnBvc2UgfCBEZWZhdWx0IHwKfC0tLXwtLS18LS0tfAp8IGAtLWNv" + - "bnRyb2wtcGxhbmUtc3RhY2s94oCmYCB8IENvbnRyb2wtcGxhbmUgYnVuZGxlIHNvdXJjZTogbG9j" + - "YWwgcGF0aCwgZ2l0IFVSTCwgb3IgYG9jaTovL2AgVVJMIHwgZW1iZWRkZWQgT0NJIFVSTCBwaW5u" + - "ZWQgYnkgQ0xJIHZlcnNpb24gfAp8IGAtLWNvbXB1dGUtcGxhbmUtc3RhY2s94oCmYCB8IENvbXB1" + - "dGUtcGxhbmUgYnVuZGxlIHNvdXJjZTogbG9jYWwgcGF0aCwgZ2l0IFVSTCwgb3IgYG9jaTovL2Ag" + - "VVJMIHwgZW1iZWRkZWQgT0NJIFVSTCBwaW5uZWQgYnkgQ0xJIHZlcnNpb24gfAp8IGAtLWVudj1s" + - "b2NhbFx8cHJkXHzigKZgIHwgSGVsbWZpbGUgZW52aXJvbm1lbnQgbmFtZSB8IGBsb2NhbGAgZm9y" + - "IGRldiBidWlsZHMsIGBwcmRgIGZvciByZWxlYXNlcyB8CnwgYC0tbm9uLWludGVyYWN0aXZlYCB8" + - "IERpc2FibGUgYWxsIHN0ZGluIHByb21wdHMgfCBgZmFsc2VgIHwKfCBgLS10b2tlbj0kSldUYCB8" + - "IEFkbWluIEpXVCwgb3ZlcnJpZGVzIHN0b3JlZCBzZXNzaW9uIHwgLSB8CnwgYC0tbm8tYXBwbHlg" + - "IHwgYGluc3RhbGxgIG9ubHkgLSBlbWl0IFlBTUwsIGRvIG5vdCBrdWJlY3RsIGFwcGx5IHwgYGZh" + - "bHNlYCB8CnwgYC0tb3V0cHV0PXRleHRcfGpzb25gIHwgTGVnYWN5IGFsaWFzIGZvciBgLS1qc29u" + - "YCAoZGVwcmVjYXRlZCwgcmVtb3ZlZCBpbiBuZXh0IG1ham9yKSB8IGB0ZXh0YCB8CnwgYC0tcGxh" + - "aW5gIHwgRm9yY2UgcGxhaW4gc3RyZWFtaW5nIG91dHB1dCB8IGF1dG8tZGV0ZWN0IHwKfCBgLS13" + - "YWl0IERVUkFUSU9OYCB8IGBjaGVja2Agb25seTsgYmxvY2sgdW50aWwgcGFzcyB8IC0gfAp8IGAt" + - "LWNvbnRyb2wtcGxhbmUtY29udGV4dCBDVFhgIHwga3ViZWN0bCBjb250ZXh0IGZvciBjb250cm9s" + - "IHBsYW5lIChSRVEtMjApIHwgY3VycmVudCBjb250ZXh0IHwKfCBgLS1jb21wdXRlLXBsYW5lLWNv" + - "bnRleHQgQ1RYYCB8IGt1YmVjdGwgY29udGV4dCBmb3IgY29tcHV0ZSBwbGFuZSAoUkVRLTIwKSB8" + - "IGN1cnJlbnQgY29udGV4dCB8CnwgYC0taWNtcy11cmwgVVJMYCB8IFB1YmxpYyBJQ01TIFVSTDsg" + - "cmVxdWlyZWQgd2hlbiBjb250ZXh0cyBkaWZmZXIgfCBkZXJpdmVkIGZyb20gYGJhc2VfaHR0cF91" + - "cmxgIHwKfCBgLS1sb2NhbC1vbmx5YCB8IGBjaGVjayAtLXByZWAgb25seTsgc2tpcCBhbGwga3Vi" + - "ZWN0bCBjb250YWN0IHwgYGZhbHNlYCB8CgojIyBgdXBgLXNwZWNpZmljCgp8IEZsYWcgfCBQdXJw" + - "b3NlIHwgRGVmYXVsdCB8CnwtLS18LS0tfC0tLXwKfCBgLS1jbHVzdGVyLW5hbWUgTkFNRWAgfCBJ" + - "Q01TIGNsdXN0ZXIgcm93IGlkZW50aWZpZXIgKHJlcXVpcmVkKSB8IC0gfAp8IGAtLW5jYS1pZCBJ" + - "RGAgfCBOQ0EgYWNjb3VudCBJRCB8IGBudmNmLWRlZmF1bHRgIHwKfCBgLS1yZWdpb24gUkVHSU9O" + - "YCB8IENsdXN0ZXIgcmVnaW9uIHwgYHVzLXdlc3QtMWAgfAp8IGAtLXBsYW4tb25seWAgfCBEcnkt" + - "cnVuOyBlbWl0IHBoYXNlIHBsYW4gKyBFVEFzIHdpdGhvdXQgY2hhbmdlcyB8IGBmYWxzZWAgfAoK" + - "IyMgYHN0YXR1c2Atc3BlY2lmaWMKCnwgRmxhZyB8IFB1cnBvc2UgfCBEZWZhdWx0IHwKfC0tLXwt" + - "LS18LS0tfAp8IGAtLWNsdXN0ZXItbmFtZSBOQU1FYCB8IExpbWl0IHRvIG9uZSBjb21wdXRlIHBs" + - "YW5lIHwgLSAoY29udHJvbCArIGFsbCBjbHVzdGVycykgfAp8IGAtLXdhdGNoYCB8IExpdmUgcmUt" + - "cmVuZGVyIHwgYGZhbHNlYCB8CnwgYC0td2F0Y2gtaW50ZXJ2YWwgRFVSYCB8IGAtLXdhdGNoYCBj" + - "YWRlbmNlIHwgYDVzYCB8CnwgYC0tY29tcG9uZW50IE5BTUVgIHwgRmlsdGVyIGNvbXBvbmVudHMg" + - "cGFuZWwgfCBhbGwgfAp8IGAtLW5vLWV2ZW50c2AgfCBTa2lwIGV2ZW50cyBwYW5lbCB8IGBmYWxz" + - "ZWAgfAoKIyMgYGNsdXN0ZXIgcmVnaXN0ZXJgLXNwZWNpZmljCgp8IEZsYWcgfCBQdXJwb3NlIHwg" + - "RGVmYXVsdCB8CnwtLS18LS0tfC0tLXwKfCBgLS1uYW1lIE5BTUVgIHwgQ2x1c3RlciBuYW1lIChy" + - "ZXF1aXJlZCkgfCAtIHwKfCBgLS1uY2EtaWQgSURgIHwgTkNBIElEIChyZXF1aXJlZCkgfCAtIHwK" + - "fCBgLS1yZWdpb24gUkVHSU9OYCB8IFJlZ2lvbiB8IGB1cy13ZXN0LTFgIHwKfCBgLS1pY21zLXVy" + - "bCBVUkxgIHwgSUNNUyBlbmRwb2ludCB8IGZyb20gY29uZmlnIHwKfCBgLS1pZ25vcmUtZXhpc3Rp" + - "bmdgIHwgTWF0Y2gtb3ItY3JlYXRlIGluc3RlYWQgb2YgZmFpbC1vbi1leGlzdHMgfCBgZmFsc2Vg" + - "IHwKCiMjIGBhcGkta2V5IGdlbmVyYXRlYC1zcGVjaWZpYwoKfCBGbGFnIHwgUHVycG9zZSB8IERl" + - "ZmF1bHQgfAp8LS0tfC0tLXwtLS18CnwgYC0tZm9yIGZ1bmN0aW9uXHx0YXNrYCB8IEdlbmVyYXRl" + - "IG9ubHkgdGhlIHNwZWNpZmllZCBrZXkgdHlwZSB8IChvbWl0IHRvIGdlbmVyYXRlIGJvdGgpIHwK" + - "fCBgLS1kZXNjcmlwdGlvbiBURVhUYCB8IEh1bWFuLXJlYWRhYmxlIGxhYmVsIGZvciB0aGUga2V5" + - "IHwgYEdlbmVyYXRlZCBieSBudmNmLWNsaWAgfAp8IGAtLWV4cGlyZXMtaW4gRFVSQVRJT05gIHwg" + - "RXhwaXJ5IG9mZnNldCAoZS5nLiBgMjRoYCwgYDdkYCk7IHBhcnNlZCBhcyBleHRlbmRlZCBkdXJh" + - "dGlvbiB8IGAyNGhgIHwKfCBgLS1zY29wZXMgU0NPUEVbLFNDT1BFXWAgfCBPdmVycmlkZSBkZWZh" + - "dWx0IHNjb3BlczsgcmVxdWlyZXMgYC0tZm9yYCB8IChzZXJ2aWNlIGRlZmF1bHRzKSB8CnwgYC0t" + - "dmFsaWRhdGVgIHwgVmFsaWRhdGUgZWFjaCBnZW5lcmF0ZWQga2V5IGltbWVkaWF0ZWx5IGFmdGVy" + - "IG1pbnRpbmcgfCBgZmFsc2VgIHwKCkV4dGVuZGVkIGR1cmF0aW9uIHVuaXRzOiBgc2AgKHNlY29u" + - "ZHMpLCBgbWAgKG1pbnV0ZXMpLCBgaGAgKGhvdXJzKSwgYGRgIChkYXlzKSwgYHdgICh3ZWVrcyku" + - "CgojIyBgZnVuY3Rpb24gY3JlYXRlYC1zcGVjaWZpYwoKYC0taW5wdXQtZmlsZSBGSUxFYCBpcyBy" + - "ZWNvbW1lbmRlZCBmb3IgcmVwZWF0YWJsZSBmdW5jdGlvbiBkZWZpbml0aW9ucy4gRm9yIGFkLWhv" + - "YyBjcmVhdGVzOgoKfCBGbGFnIHwgUHVycG9zZSB8IERlZmF1bHQgfAp8LS0tfC0tLXwtLS18Cnwg" + - "YC0tbmFtZSBOQU1FYCB8IEZ1bmN0aW9uIG5hbWUgfCAtIHwKfCBgLS1pbWFnZSBJTUFHRWAgfCBD" + - "b250YWluZXIgaW1hZ2UgfCAtIHwKfCBgLS1pbmZlcmVuY2UtdXJsIFVSSWAgfCBDb250YWluZXIg" + - "aW5mZXJlbmNlIGVuZHBvaW50IHwgLSB8CnwgYC0taW5mZXJlbmNlLXBvcnQgUE9SVGAgfCBDb250" + - "YWluZXIgaW5mZXJlbmNlIHBvcnQgfCAtIHwKfCBgLS1mdW5jdGlvbi10eXBlIERFRkFVTFRcfFNU" + - "UkVBTUlOR1x8TExNYCB8IEZ1bmN0aW9uIHR5cGUgfCBgREVGQVVMVGAgfAp8IGAtLWhlbG0tY2hh" + - "cnQgQ0hBUlRgIHwgSGVsbSBjaGFydCBVUkwgb3IgT0NJIHJlZmVyZW5jZS4gQ2FuIGJlIHVzZWQg" + - "d2l0aCBgLS1mdW5jdGlvbi10eXBlPUxMTWAgZm9yIGNoYXJ0LXBhY2thZ2VkIExMTSB3b3JrbG9h" + - "ZHMuIHwgLSB8CnwgYC0taGVsbS1jaGFydC1zZXJ2aWNlIE5BTUVgIHwgS3ViZXJuZXRlcyBTZXJ2" + - "aWNlIG5hbWUgZXhwb3NlZCBieSB0aGUgY2hhcnQuIFJlcXVpcmVkIHdoZW4gYC0taGVsbS1jaGFy" + - "dGAgaXMgc2V0LiB8IC0gfAp8IGAtLW1vZGVscyBOQU1FOlZFUlNJT046VVJJYCB8IFN0YW5kYXJk" + - "IG1vZGVsIGFydGlmYWN0OyByZXBlYXRhYmxlIHwgLSB8CnwgYC0tbGxtLW1vZGVsIFNQRUNgIHwg" + - "TExNIG1vZGVsIGNvbmZpZzsgZm9ybWF0IGBuYW1lPTxtb2RlbD4sdXJpcz08dXJpPlx8PHVyaT4s" + - "cm91dGluZ01ldGhvZD08bWV0aG9kPix0b2tlblJhdGVMaW1pdD08bGltaXQ+YDsgcmVwZWF0YWJs" + - "ZS4gVG9rZW4gbGltaXRzIHVzZSBgPHZhbHVlPi08dW5pdD5gIHdpdGggYFNgLCBgTWAsIGBIYCwg" + - "YERgLCBvciBgV2AsIGZvciBleGFtcGxlIGAxMDAwLVNgLiBVc2UgaW5wdXQgSlNPTiBmb3IgY29t" + - "YmluZWQgdG9rZW4gbGltaXRzIGJlY2F1c2UgaW5saW5lIHNwZWNzIHVzZSBjb21tYXMgYXMgZmll" + - "bGQgc2VwYXJhdG9ycy4gfCAtIHwKCkluIEpTT04gYW5kIGlubGluZSBzcGVjcywgTExNIGZ1bmN0" + - "aW9ucyBzZXQgYGZ1bmN0aW9uVHlwZTogIkxMTSJgIGFuZCBtb2RlbCByb3V0aW5nIG1ldGFkYXRh" + - "IHVuZGVyIGBtb2RlbHNbXS5sbG1Db25maWdgLiBgbGxtQ29uZmlnLnVyaXNgIGRlY2xhcmVzIHRo" + - "ZSBPcGVuQUktY29tcGF0aWJsZSB1cHN0cmVhbSBwYXRocyBleHBvc2VkIGJ5IHRoZSBtb2RlbC4g" + - "Q3VycmVudCBzdXBwb3J0ZWQgcGF0aHMgYXJlIGAvdjEvY2hhdC9jb21wbGV0aW9uc2AsIGAvdjEv" + - "cmVzcG9uc2VzYCwgYW5kIGAvdjEvZW1iZWRkaW5nc2AuIGBsbG1Db25maWcucm91dGluZ01ldGhv" + - "ZGAgYWNjZXB0cyBgcm91bmRfcm9iaW5gLCBgcG93ZXJfb2ZfdHdvYCwgYGdyb3FfbXVsdGlyZWdp" + - "b25gLCBgcHVsc2FyYCwgb3IgYHJhbmRvbWAuCmBsbG1Db25maWcudG9rZW5SYXRlTGltaXRgIGFj" + - "Y2VwdHMgb25lIG9yIG1vcmUgY29tbWEtc2VwYXJhdGVkIHBvc2l0aXZlIGludGVnZXIgdG9rZW4g" + - "bGltaXRzIGluIGA8dmFsdWU+LTx1bml0PmAgZm9ybWF0LiBTdXBwb3J0ZWQgdW5pdHMgYXJlIGBT" + - "YCAoc2Vjb25kcyksIGBNYCAobWludXRlcyksIGBIYCAoaG91cnMpLCBgRGAgKGRheXMpLCBhbmQg" + - "YFdgICh3ZWVrcykuIFVzZSBkaXN0aW5jdCB1bml0cyB3aGVuIGNvbWJpbmluZyBsaW1pdHMsIGZv" + - "ciBleGFtcGxlIGAxMDAwLVMsNTAwMC1NLDEwMDAwMC1ILDUwMDAwMC1ELDEwMDAwMDAtV2AgaW4g" + - "aW5wdXQgSlNPTi4KCkhlbG0gY2hhcnQgcGFja2FnaW5nIGlzIGluZGVwZW5kZW50IG9mIGBmdW5j" + - "dGlvblR5cGVgLiBGb3IgYSBIZWxtLWNoYXJ0IGJhY2tlZCBMTE0gZnVuY3Rpb24sIHNldCBgZnVu" + - "Y3Rpb25UeXBlOiAiTExNImAsIGBoZWxtQ2hhcnRgLCBgaGVsbUNoYXJ0U2VydmljZU5hbWVgLCBh" + - "bmQgYG1vZGVsc1tdLmxsbUNvbmZpZ2AgaW4gdGhlIHNhbWUgY3JlYXRlIHJlcXVlc3QuIGBpbmZl" + - "cmVuY2VQb3J0YCBtdXN0IGJlIHRoZSBLdWJlcm5ldGVzIFNlcnZpY2UgcG9ydCBleHBvc2VkIGJ5" + - "IGBoZWxtQ2hhcnRTZXJ2aWNlTmFtZWAuCgpMTE0gaW52b2NhdGlvbiByZXF1ZXN0cyB1c2UgYG1v" + - "ZGVsOiAiPGZ1bmN0aW9uLWlkPi88bW9kZWwtbmFtZT4iYC4gVGhlIGZ1bmN0aW9uIElEIHNlbGVj" + - "dHMgdGhlIE5WQ0YgZnVuY3Rpb24sIGFuZCB0aGUgbW9kZWwgbmFtZSBpcyBmb3J3YXJkZWQgdXBz" + - "dHJlYW0uIENoYXQgY29tcGxldGlvbnMgYW5kIFJlc3BvbnNlcyBBUEkgcmVxdWVzdHMgY2FuIHVz" + - "ZSBgeC1tdWx0aS10dXJuLXNlc3Npb24taWRgIGZvciBzZXNzaW9uIHN0aWNraW5lc3M7IGVtYmVk" + - "ZGluZ3MgcmVxdWVzdHMgZG8gbm90LgoKIyMgYGZ1bmN0aW9uIHVwZGF0ZWAtc3BlY2lmaWMKCnwg" + - "RmxhZyB8IFB1cnBvc2UgfCBEZWZhdWx0IHwKfC0tLXwtLS18LS0tfAp8IGAtLXRhZ3MgVEFHWyxU" + - "QUddYCB8IFJlcGxhY2UgZnVuY3Rpb24gdGFncyB8IC0gfAp8IGAtLWxsbS1tb2RlbC11cGRhdGUg" + - "U1BFQ2AgfCBMTE0gbW9kZWwgdXBkYXRlOyBmb3JtYXQgYG5hbWU9PG1vZGVsPixyb3V0aW5nTWV0" + - "aG9kPTxtZXRob2Q+LHRva2VuUmF0ZUxpbWl0PTxsaW1pdD5gOyByZXBlYXRhYmxlLiBSb3V0aW5n" + - "IG1ldGhvZHMgbWF0Y2ggYC0tbGxtLW1vZGVsYC4gVG9rZW4gbGltaXQgZXhhbXBsZTogYDEwMDAt" + - "U2AuIFVzZSBpbnB1dCBKU09OIGZvciBjb21iaW5lZCB0b2tlbiBsaW1pdHMuIHwgLSB8CgpJbiBK" + - "U09OLCBgZnVuY3Rpb24gdXBkYXRlYCBhY2NlcHRzIGBtb2RlbFVwZGF0ZXNbXWAgZW50cmllcyB3" + - "aXRoIGBtb2RlbE5hbWVgIGFuZCBgbGxtQ29uZmlnLnJvdXRpbmdNZXRob2RgIGFuZC9vciBgbGxt" + - "Q29uZmlnLnRva2VuUmF0ZUxpbWl0YC4gYHVyaXNgIGFyZSBjcmVhdGUtdGltZSBtb2RlbCBtZXRh" + - "ZGF0YSBhbmQgYXJlIG5vdCBwYXJ0IG9mIG1vZGVsIHVwZGF0ZXMuCgojIyBgZnVuY3Rpb24gZGVw" + - "bG95IGNyZWF0ZWAtc3BlY2lmaWMKCmAtLWlucHV0LWZpbGUgRklMRWAgaXMgcmVjb21tZW5kZWQg" + - "KGZ1bGwgSlNPTiBzcGVjKS4gRm9yIGFkLWhvYyBvbmUtc2hvdCB1c2U6Cgp8IEZsYWcgfCBQdXJw" + - "b3NlIHwgRGVmYXVsdCB8CnwtLS18LS0tfC0tLXwKfCBgLS1mdW5jdGlvbi1pZCBJRGAgfCBGdW5j" + - "dGlvbiBJRCAocmVxdWlyZWQpIHwgLSB8CnwgYC0tZ3B1IE5BTUVgIHwgR1BVIGZhbWlseSB8IGBI" + - "MTAwYCB8CnwgYC0taW5zdGFuY2UtdHlwZSBUWVBFYCB8IFNLVSB8IGBOQ1AuR1BVLkgxMDBfMXhg" + - "IHwKfCBgLS1taW4taW5zdGFuY2VzIE5gIHwgTWluIHJlcGxpY2FzIHwgYDFgIHwKfCBgLS1tYXgt" + - "aW5zdGFuY2VzIE5gIHwgTWF4IHJlcGxpY2FzIHwgYDFgIHwKfCBgLS1tYXgtcmVxdWVzdC1jb25j" + - "dXJyZW5jeSBOYCB8IENvbmN1cnJlbmN5IHwgYDBgICh1bnNldDsgc2VydmVyIGRlZmF1bHQgYXBw" + - "bGllcykgfAp8IGAtLWNsdXN0ZXJzIE5BTUVbLE5BTUVdYCB8IFRhcmdldCBzcGVjaWZpYyBjb21w" + - "dXRlIGNsdXN0ZXJzIHwgKGFueSBtYXRjaGluZyBTS1UpIHwKCiMjIGB0YXNrIGNyZWF0ZWAtc3Bl" + - "Y2lmaWMKCmAtLWlucHV0LWZpbGUgRklMRWAgaXMgcmVjb21tZW5kZWQgZm9yIHJlcGVhdGFibGUg" + - "dGFzayBkZWZpbml0aW9ucy4gRm9yIGFkLWhvYyB1c2U6Cgp8IEZsYWcgfCBQdXJwb3NlIHwgTm90" + - "ZXMgfAp8LS0tfC0tLXwtLS18CnwgYC0tbmFtZSBOQU1FYCB8IFRhc2sgbmFtZSAocmVxdWlyZWQp" + - "IHwgMS0xMjggY2hhcnMsIGBeW2EtejAtOUEtWl1bYS16MC05QS1aXC1fXSokYCB8CnwgYC0tZ3B1" + - "IEdQVWAgfCBHUFUgbmFtZSAocmVxdWlyZWQgd2l0aG91dCBgLS1pbnB1dC1maWxlYCkgfCBFeGFt" + - "cGxlOiBgSDEwMGAgfAp8IGAtLWluc3RhbmNlLXR5cGUgVFlQRWAgfCBJbnN0YW5jZSB0eXBlIChy" + - "ZXF1aXJlZCB3aXRob3V0IGAtLWlucHV0LWZpbGVgKSB8IEV4YW1wbGU6IGBOQ1AuR1BVLkgxMDBf" + - "MXhgIHwKfCBgLS1pbWFnZSBJTUFHRWAgfCBDb250YWluZXIgaW1hZ2UgfCBNdXR1YWxseSBleGNs" + - "dXNpdmUgd2l0aCBgLS1oZWxtLWNoYXJ0YCB8CnwgYC0taGVsbS1jaGFydCBDSEFSVGAgfCBIZWxt" + - "IGNoYXJ0IFVSTCBvciBPQ0kgcmVmZXJlbmNlIHwgTXV0dWFsbHkgZXhjbHVzaXZlIHdpdGggYC0t" + - "aW1hZ2VgIHwKfCBgLS1pbnB1dC1maWxlIEZJTEVgIHwgSlNPTiB0YXNrIHNwZWMgZmlsZSB8IENM" + - "SSBmbGFncyBvdmVycmlkZSBKU09OIHZhbHVlcyB3aGVuIGJvdGggYXJlIHNldCB8CnwgYC0tYmFj" + - "a2VuZCBCQUNLRU5EYCB8IEJhY2tlbmQgLyBDU1AgfCAtIHwKfCBgLS1jbHVzdGVycyBOQU1FWyxO" + - "QU1FXWAgfCBTcGVjaWZpYyBjbHVzdGVycyB3aXRoaW4gdGhlIGluc3RhbmNlIHwgQ29tbWEtc2Vw" + - "YXJhdGVkIHwKfCBgLS1jb250YWluZXItYXJncyBBUkdTYCB8IEFyZ3MgcGFzc2VkIHdoZW4gbGF1" + - "bmNoaW5nIHRoZSBjb250YWluZXIgfCBTaW5nbGUgc3RyaW5nLCBlLmcuIGAiLS1lcG9jaHMgMTAg" + - "LS1iYXRjaC1zaXplIDMyImAgfAp8IGAtLWNvbnRhaW5lci1lbnYgTkFNRT12YWx1ZWAgfCBDb250" + - "YWluZXIgZW52aXJvbm1lbnQgdmFyaWFibGU7IHJlcGVhdGFibGUgfCAtIHwKfCBgLS1zZWNyZXRz" + - "IE5BTUU9dmFsdWVgIHwgU2VjcmV0IGVudmlyb25tZW50IHZhcmlhYmxlOyByZXBlYXRhYmxlOyBl" + - "bmNyeXB0ZWQgYXQgcmVzdCB8IC0gfAp8IGAtLW1heC1ydW50aW1lIERVUkFUSU9OYCB8IE1heCB3" + - "YWxsLWNsb2NrIHJ1biB0aW1lIChJU08gODYwMSwgZS5nLiBgUFQ0SGApIHwgTm8gZGVmYXVsdDsg" + - "b21pdCBmb3Igbm8gdGltZSBsaW1pdCB8CnwgYC0tbWF4LXF1ZXVlZCBEVVJBVElPTmAgfCBNYXgg" + - "dGltZSBpbiBxdWV1ZSBiZWZvcmUgY2FuY2VsbGF0aW9uIChJU08gODYwMSkgfCBTZXJ2ZXIgZGVm" + - "YXVsdCBgUFQ3MkhgIHwKfCBgLS10ZXJtaW5hdGlvbi1ncmFjZSBEVVJBVElPTmAgfCBHcmFjZSBw" + - "ZXJpb2QgYWZ0ZXIgc3RvcCBzaWduYWwgKElTTyA4NjAxKSB8IFNlcnZlciBkZWZhdWx0IGBQVDFI" + - "YCB8CnwgYC0tcmVzdWx0LXN0cmF0ZWd5IFVQTE9BRFx8Tk9ORWAgfCBIb3cgdG8gaGFuZGxlIHRh" + - "c2sgb3V0cHV0IGFydGlmYWN0cyB8IC0gfAp8IGAtLXJlc3VsdHMtbG9jYXRpb24gTE9DQVRJT05g" + - "IHwgUmVzdWx0IHVwbG9hZCB0YXJnZXQsIGZvcm1hdCBgb3JnLW5hbWUvW3RlYW0tbmFtZS9dbW9k" + - "ZWwtbmFtZWA7IHJlcXVpcmVkIHdoZW4gYC0tcmVzdWx0LXN0cmF0ZWd5PVVQTE9BRGAgfCAtIHwK" + - "fCBgLS1tb2RlbHMgTkFNRTpWRVJTSU9OOlVSSWAgfCBNb2RlbCBhcnRpZmFjdDsgcmVwZWF0YWJs" + - "ZSB8IC0gfAp8IGAtLXJlc291cmNlcyBOQU1FOlZFUlNJT046VVJJYCB8IFJlc291cmNlIGFydGlm" + - "YWN0OyByZXBlYXRhYmxlIHwgLSB8CnwgYC0tdGFncyBUQUdbLFRBR11gIHwgVGFzayB0YWdzIHwg" + - "Q29tbWEtc2VwYXJhdGVkIHwKfCBgLS1kZXNjcmlwdGlvbiBURVhUYCB8IFRhc2sgZGVzY3JpcHRp" + - "b24gfCAtIHwKfCBgLS1sb2dzLXRlbGVtZXRyeS1pZCBVVUlEYCB8IExvZ3MgdGVsZW1ldHJ5IGVu" + - "ZHBvaW50IElEIHwgLSB8CnwgYC0tbWV0cmljcy10ZWxlbWV0cnktaWQgVVVJRGAgfCBNZXRyaWNz" + - "IHRlbGVtZXRyeSBlbmRwb2ludCBJRCB8IC0gfAp8IGAtLXRyYWNlcy10ZWxlbWV0cnktaWQgVVVJ" + - "RGAgfCBUcmFjZXMgdGVsZW1ldHJ5IGVuZHBvaW50IElEIHwgLSB8CgpQSwcI/KOR4MYiAADGIgAA" + - "UEsDBBQACAAAAAAAIQAAAAAAAAAAAAAAAAA3AAkAZGF0YS9udmNmLXNlbGYtbWFuYWdlZC1jbGkv" + - "cmVmZXJlbmNlL3Ryb3VibGVzaG9vdGluZy5tZFVUBQABAKbOEiMgVHJvdWJsZXNob290aW5nCgpL" + - "bm93biBlcnJvcnMg4oaSIGRpYWdub3N0aWMgY29tbWFuZCDihpIgcmVtZWRpYXRpb24uIEtlZXAg" + - "aW4gc3luYyB3aXRoIHRoZSBzdHJ1Y3R1cmVkIGBwaGFzZV9mYWlsZWRgIGV2ZW50cyB0aGUgQ0xJ" + - "IGVtaXRzIChSRVEtMTUpIOKAlCBldmVyeSBlbnRyeSBiZWxvdyBzaG91bGQgbWFwIHRvIGFuIGBl" + - "cnJDYXRlZ29yeWAgYW5kIGEgYHJlbWVkaWF0aW9uYCBhcnJheS4KCiMjIFByZS1mbGlnaHQKCnwg" + - "U3ltcHRvbSB8IENhdXNlIHwgUmVtZWRpYXRpb24gfAp8LS0tfC0tLXwtLS18CnwgYGt1YmVjdGwg" + - "bm90IG9uIFBBVEhgIHwgT3BlcmF0b3IncyBgJFBBVEhgIGRvZXNuJ3QgaW5jbHVkZSBrdWJlY3Rs" + - "IHwgSW5zdGFsbCBrdWJlY3RsIDEuMjgrOiBodHRwczovL2t1YmVybmV0ZXMuaW8vZG9jcy90YXNr" + - "cy90b29scy9pbnN0YWxsLWt1YmVjdGwvIHwKfCBgaGVsbWZpbGUgbm90IG9uIFBBVEhgIHwgU2Ft" + - "ZSB8IGh0dHBzOi8vZ2l0aHViLmNvbS9oZWxtZmlsZS9oZWxtZmlsZSNpbnN0YWxsYXRpb24gfAp8" + - "IGBoZWxtIG5vdCBvbiBQQVRIYCB8IFNhbWUgfCBodHRwczovL2hlbG0uc2gvZG9jcy9pbnRyby9p" + - "bnN0YWxsLyB8CnwgYEdhdGV3YXkgQVBJIENSRHMgbm90IGluc3RhbGxlZGAgfCBlbnZveS1nYXRl" + - "d2F5IHByZXJlcSBtaXNzaW5nIHwgYGhlbG0gaW5zdGFsbCBlZyBvY2k6Ly9kb2NrZXIuaW8vZW52" + - "b3lwcm94eS9nYXRld2F5LWhlbG0gLS1uYW1lc3BhY2U9ZW52b3ktZ2F0ZXdheS1zeXN0ZW0gLS1j" + - "cmVhdGUtbmFtZXNwYWNlYCB8CnwgYGRlZmF1bHQgU3RvcmFnZUNsYXNzIG5vdCBhdmFpbGFibGVg" + - "IHwgQ2x1c3RlciBoYXMgbm8gZGVmYXVsdCBTQyB8IEFubm90YXRlIG9uZTogYGt1YmVjdGwgcGF0" + - "Y2ggc2MgPG5hbWU+IC1wICd7Im1ldGFkYXRhIjp7ImFubm90YXRpb25zIjp7InN0b3JhZ2VjbGFz" + - "cy5rdWJlcm5ldGVzLmlvL2lzLWRlZmF1bHQtY2xhc3MiOiJ0cnVlIn19fSdgIHwKfCBgR1BVIG9w" + - "ZXJhdG9yIG5vdCBpbnN0YWxsZWRgIChjb21wdXRlLXBsYW5lKSB8IG52aWRpYSBHUFUgb3BlcmF0" + - "b3IgbWlzc2luZyB8IEluc3RhbGwgcGVyIGh0dHBzOi8vZG9jcy5udmlkaWEuY29tL2RhdGFjZW50" + - "ZXIvY2xvdWQtbmF0aXZlL2dwdS1vcGVyYXRvci9sYXRlc3QvaW5zdGFsbC1ncHUtb3BlcmF0b3Iu" + - "aHRtbCwgT1IgdXNlIGBmYWtlLWdwdS1vcGVyYXRvcmAgZm9yIGRldiB8CnwgYEdQVSBub2RlIGxh" + - "YmVscyBtaXNzaW5nYCAoY29tcHV0ZS1wbGFuZSkgfCBOb2RlcyBuZWVkIGBudmlkaWEuY29tL2dw" + - "dS5mYW1pbHlgIGV0Yy4gfCBTZXQgYC0tazNzLW5vZGUtbGFiZWwgbnZpZGlhLmNvbS9ncHUuZmFt" + - "aWx5PWhvcHBlckBhZ2VudDpOYCBmb3IgazNkIHwKCiMjIEF1dGgKCnwgU3ltcHRvbSB8IENhdXNl" + - "IHwgUmVtZWRpYXRpb24gfAp8LS0tfC0tLXwtLS18CnwgYGFkbWluIHRva2VuIHJlcXVpcmVkYCAo" + - "aW5pdCBub3QgcnVuKSB8IE5vIGB+Ly5udmNmLWNsaS5zdGF0ZWAgYW5kIGAtLXRva2VuYCBub3Qg" + - "cGFzc2VkIHwgYG52Y2YtY2xpIGluaXRgIChpbnRlcmFjdGl2ZSkgb3IgYC0tdG9rZW49JEpXVCAt" + - "LW5vbi1pbnRlcmFjdGl2ZWAgKENJKSB8CnwgYFNpZ25lZCBKV1QgcmVqZWN0ZWQ6IEFub3RoZXIg" + - "YWxnb3JpdGhtIGV4cGVjdGVkLCBvciBubyBtYXRjaGluZyBrZXkocykgZm91bmRgIHwgU3RhbGUg" + - "c2Vzc2lvbi5qc29uIGZyb20gYSBkaWZmZXJlbnQgY29udHJvbCBwbGFuZSB8IGBybSB+Ly5udmNm" + - "LWNsaS5zdGF0ZWAgdGhlbiBgbnZjZi1jbGkgaW5pdGAgYWdhaW4gfAp8IGA0MDMgbWlzc2luZyBy" + - "ZXF1ZXN0ZWQgYXV0aG9yaXRpZXNgIChmdW5jdGlvbiBpbnZva2UpIHwgQWRtaW4gdG9rZW4gZG9l" + - "c24ndCBoYXZlIGBpbnZva2VfZnVuY3Rpb25gIHNjb3BlIHwgYG52Y2YtY2xpIGFwaS1rZXkgZ2Vu" + - "ZXJhdGUgLS1kZXNjcmlwdGlvbj3igKZgIHRoZW4gcmUtcnVuIGludm9rZSB8CgojIyBJbnN0YWxs" + - "IC8gYHVwYAoKfCBTeW1wdG9tIHwgQ2F1c2UgfCBSZW1lZGlhdGlvbiB8CnwtLS18LS0tfC0tLXwK" + - "fCBIZWxtIGB0aW1lZCBvdXQgd2FpdGluZyBmb3IgY2Fzc2FuZHJhYCB8IENhc3NhbmRyYSBTdGF0" + - "ZWZ1bFNldCBQVkMgc3R1Y2sgYFBlbmRpbmdgIHwgQ29uZmlybSBkZWZhdWx0IFN0b3JhZ2VDbGFz" + - "czsgY2hlY2sgYGt1YmVjdGwgZ2V0IHB2LHB2YyAtbiBjYXNzYW5kcmEtc3lzdGVtYCB8CnwgYElu" + - "dmFsaWQgR1BVICdOQ1AuR1BVLkgxMDAnIHNwZWNpZmllZGAgKGZ1bmN0aW9uIGRlcGxveSkgfCBX" + - "cm9uZyBmaWVsZCDigJQgYGdwdWAgaXMgdGhlIGZhbWlseSwgbm90IHRoZSBTS1UgfCBVc2UgYCJn" + - "cHUiOiAiSDEwMCJgLCBgImluc3RhbmNlVHlwZSI6ICJOQ1AuR1BVLkgxMDBfMXgiYCB8CnwgYHJl" + - "Z2lvbiBtdXN0IGJlIHByb3ZpZGVkYCAoY2x1c3RlciByZWdpc3RlciAvIGluc3RhbGwgLS1jb21w" + - "dXRlLXBsYW5lKSB8IGAtLXJlZ2lvbmAgZW1wdHkgKyBgQ0xVU1RFUl9SRUdJT05gIGVudiBlbXB0" + - "eSB8IFBhc3MgYC0tcmVnaW9uPXVzLXdlc3QtMWAgKG9yIGFueSBub24tZW1wdHkgdmFsdWUpIHwK" + - "fCBgcmVxdWlyZWRFbnYgIk5DQV9JRCIgaXMgbm90IHNldGAgKGhlbG1maWxlIGVycm9yIGR1cmlu" + - "ZyBjb21wdXRlLXBsYW5lIGFwcGx5KSB8IE9sZGVyIG52Y2YtY2xpIGJlZm9yZSBjb21taXQgYDZh" + - "YTU3MDRgOyBFeHRyYUVudiBub3QgcHJvcGFnYXRpbmcgTkNBX0lEIHwgVXBncmFkZSBgbnZjZi1j" + - "bGlgIHRvIGEgcmVsZWFzZSBhZnRlciBgNmFhNTcwNGAgfAp8IGBudmNhLW9wZXJhdG9yOiBJbWFn" + - "ZVB1bGxCYWNrT2ZmYCBmb3IgYG52Y2Etb3BlcmF0b3I6cHNhdGAgfCBJbWFnZSBub3QgaW4gY2x1" + - "c3RlciByZWdpc3RyeTsgbXVsdGktY2x1c3RlciBidWlsZCBpcyBsb2NhbCB8IGBrM2QgaW1hZ2Ug" + - "aW1wb3J0IG52Y3IuaW8vLi4uL252Y2Etb3BlcmF0b3I6cHNhdCAtYyA8Y2x1c3Rlcj5gIHwKCiMj" + - "IENvbXB1dGUtcGxhbmUgcnVudGltZQoKfCBTeW1wdG9tIHwgQ2F1c2UgfCBSZW1lZGlhdGlvbiB8" + - "CnwtLS18LS0tfC0tLXwKfCBOVkNBIGFnZW50IENyYXNoTG9vcEJhY2tPZmYgd2l0aCBgSFRUUCA0" + - "MDFgIG9uIGAvdjEvbnZjYS9jbHVzdGVycy8uLi4vcmVnaXN0ZXJgIHwgU3RhbGUgYG91dC88Y2x1" + - "c3Rlcj4tcmVnaXN0ZXItdmFsdWVzLnlhbWxgIGZyb20gcHJpb3IgcmVnaXN0ZXI7IGNsdXN0ZXIg" + - "SUQgZG9lc24ndCBtYXRjaCBJQ01TIHwgRGVsZXRlIHRoZSBzdGFsZSBmaWxlOyByZS1ydW4gYG52" + - "Y2YtY2xpIHNlbGYtaG9zdGVkIHVwYCAoaWRlbXBvdGVudCByZWdpc3RlciB3cml0ZXMgYSBmcmVz" + - "aCBmaWxlKSB8CnwgYE5vIGNsdXN0ZXIgZm91bmQgd2l0aCB2YWxpZCBKV0tTIGZvciBjbHVzdGVy" + - "IElEOiA8aWQ+YCAoSUNNUyBsb2cpIHwgSldLUyBpbiBJQ01TIGRvZXNuJ3QgbWF0Y2ggd2hhdCBj" + - "b21wdXRlLXBsYW5lIEs4cyBpcyBjdXJyZW50bHkgc2lnbmluZyB8IGBudmNmLWNsaSBjbHVzdGVy" + - "IHJvdGF0ZSAtLWNsdXN0ZXItaWQ9PGlkPmAgfAp8IEZ1bmN0aW9uIHBvZCBgSW1hZ2VQdWxsQmFj" + - "a09mZmAgaW4gYG52Y2YtYmFja2VuZGAgfCBJbWFnZS1jcmVkZW50aWFsLWhlbHBlciBjb25maWcg" + - "bWlzc2luZyBvciB3cm9uZyB8IGBrdWJlY3RsIGRlc2NyaWJlIHBvZCAtbiBudmNmLWJhY2tlbmQg" + - "PHBvZD5gOyBjaGVjayB0aGUgcHVsbCBzZWNyZXQgY29uZmlnIHwKfCBGdW5jdGlvbiBkZXBsb3kg" + - "c3R1Y2sgYERFUExPWUlOR2AgZm9yID41IG1pbiB8IE5BVFMgc3RyZWFtIGluaXQgbGFnIChjb2xk" + - "LWNsdXN0ZXIpIOKAlCB3YWl0LCBvciBjaGVjayBOQVRTIGF1dGgtY2FsbG91dCBoZWFsdGggfCBg" + - "a3ViZWN0bCBsb2dzIC1uIG5hdHMtc3lzdGVtIC1sIGFwcC5rdWJlcm5ldGVzLmlvL25hbWU9bmF0" + - "cy1hdXRoLWNhbGxvdXQtc2VydmljZWAgfAoKIyMgVGFza3MKCnwgU3ltcHRvbSB8IENhdXNlIHwg" + - "UmVtZWRpYXRpb24gfAp8LS0tfC0tLXwtLS18CnwgYHRhc2sgY3JlYXRlYCByZXR1cm5zIGBNaXNz" + - "aW5nIDxUWVBFPiByZWdpc3RyeSBjcmVkZW50aWFsIGZvciBob3N0bmFtZWAsIG9yIGtlZXBzIHVz" + - "aW5nIGEgcHJldmlvdXMgY3JlZGVudGlhbCB2YWx1ZSwgc2hvcnRseSBhZnRlciBgcmVnaXN0cnkt" + - "Y3JlZGVudGlhbCBhZGQvdXBkYXRlL2RlbGV0ZWAgd2hpbGUgYHJlZ2lzdHJ5LWNyZWRlbnRpYWwg" + - "bGlzdGAvYGdldGAgYWxyZWFkeSBzaG93IHRoZSBuZXcgdmFsdWUgfCBFeHBlY3RlZCBwcm9wYWdh" + - "dGlvbiBkZWxheTogTlZDVCBjYWNoZXMgdGhlIGFjY291bnQncyByZWdpc3RyeSBjcmVkZW50aWFs" + - "cyB3aXRoIGBudmN0Lm52Y2YuY2FjaGUtdHRsYCAoZGVmYXVsdCBgUFQ1TWAsIGFib3V0IDUgbWlu" + - "KSBhbmQgYXBwbGllcyB0aGUgY2hhbmdlIHdoZW4gdGhhdCBjYWNoZWQgY29weSByZWZyZXNoZXMg" + - "fCBXYWl0IHVwIHRvIGFib3V0IDUgbWluIGFuZCByZXRyeSwgb3IgYGt1YmVjdGwgLW4gbnZjZiBy" + - "b2xsb3V0IHJlc3RhcnQgZGVwbG95bWVudC9udmN0LWFwaWAgdG8gYXBwbHkgaW1tZWRpYXRlbHkg" + - "fApQSwcI864ThHQRAAB0EQAAUEsDBBQACAAAAAAAIQAAAAAAAAAAAAAAAAAsAAkAZGF0YS9udmNm" + - "LXNlbGYtbWFuYWdlZC1pbnN0YWxsYXRpb24vU0tJTEwubWRVVAUAAQCmzhItLS0KbmFtZTogbnZj" + - "Zi1zZWxmLW1hbmFnZWQtaW5zdGFsbGF0aW9uCmRlc2NyaXB0aW9uOiA+LQogIEluc3RhbGwgYW5k" + - "IG9wZXJhdGUgTlZDRiBzZWxmLWhvc3RlZCBjb250cm9sLXBsYW5lIGFuZCBzZXBhcmF0ZSBjb21w" + - "dXRlLXBsYW5lCiAgc3RhY2tzLiBDb3ZlcnMgSGVsbWZpbGUgdmFsdWVzIGFuZCBDTEkgcHJvZmls" + - "ZSBpbnN0YWxsYXRpb24gZmxvd3MsIHRlYXJkb3duLAogIHZhbHVlcyBvdmVycmlkZXMsIHB1bGwg" + - "c2VjcmV0cywgYW5kIHRyb3VibGVzaG9vdGluZy4gVXNlIGZvcgogIG52Y2Ytc2VsZi1tYW5hZ2Vk" + - "LXN0YWNrLCBudmNmLWNvbXB1dGUtcGxhbmUtc3RhY2ssIHNwbGl0IGNvbXB1dGUtcGxhbmUKICBp" + - "bnN0YWxsYXRpb24sIGNvbnRyb2wtcGxhbmUgaW5zdGFsbGF0aW9uLCBDTEktZ2VuZXJhdGVkIGNv" + - "bnRyb2wtcGxhbmUKICBwcm9maWxlcywgSGVsbWZpbGUsIHNlbGYtbWFuYWdlZCwgb3Igc2VsZi1o" + - "b3N0ZWQgZGVwbG95bWVudHMuIERvIE5PVCB1c2UgZm9yCiAgbG9jYWwgazNkIGVudmlyb25tZW50" + - "czsgdXNlIHRoZSBsb2NhbCBrM2QgZGV2ZWxvcG1lbnQgd29ya2Zsb3cgaW5zdGVhZC4KbGljZW5z" + - "ZTogQXBhY2hlLTIuMApjb21wYXRpYmlsaXR5OiBSZXF1aXJlcyBoZWxtZmlsZSA+PSAxLjEuMCA8" + - "IDEuMi4wLCBoZWxtID49IDMuMTIsIGhlbG0tZGlmZiBwbHVnaW4sIGt1YmVjdGwgbWF0Y2hpbmcg" + - "Y2x1c3RlciB2ZXJzaW9uCmF1dGhvcjogIm52Y2YtY29yZS1lbmcgPG52Y2YtY29yZS1lbmdAZXhj" + - "aGFuZ2UubnZpZGlhLmNvbT4iCnZlcnNpb246ICIxLjAuMCIKdGFnczogW252Y2YsIHNlbGYtbWFu" + - "YWdlZCwgaGVsbWZpbGUsIHNlbGYtaG9zdGVkLCBjb250cm9sLXBsYW5lLCBjb21wdXRlLXBsYW5l" + - "LCBjbGktcHJvZmlsZSwgaW5zdGFsbGF0aW9uLCBkZXBsb3ltZW50LCBwdWxsLXNlY3JldHNdCnRv" + - "b2xzOiBbU2hlbGwsIFJlYWQsIEVkaXQsIEdyZXAsIEdsb2JdCm1ldGFkYXRhOgogIGludGVybmFs" + - "OiBmYWxzZQogIGF1dGhvcjogIm52Y2YtY29yZS1lbmcgPG52Y2YtY29yZS1lbmdAZXhjaGFuZ2Uu" + - "bnZpZGlhLmNvbT4iCiAgdmVyc2lvbjogIjEuMCIKICB0YWdzOiBbbnZjZiwgc2VsZi1tYW5hZ2Vk" + - "LCBoZWxtZmlsZSwgc2VsZi1ob3N0ZWQsIGNvbnRyb2wtcGxhbmUsIGNvbXB1dGUtcGxhbmUsIGNs" + - "aS1wcm9maWxlLCBpbnN0YWxsYXRpb24sIGRlcGxveW1lbnQsIHB1bGwtc2VjcmV0c10KICBsYW5n" + - "dWFnZXM6IFtiYXNoLCB5YW1sXQogIGZyYW1ld29ya3M6IFtoZWxtZmlsZSwgaGVsbSwga3ViZWN0" + - "bF0KICBkb21haW46IGNsb3VkLWluZnJhc3RydWN0dXJlCi0tLQoKIyBOVkNGIFNlbGYtTWFuYWdl" + - "ZCBTdGFjayBPcGVyYXRpb25zCgpPcGVyYXRpb25hbCBndWlkZSBmb3IgbWF0Y2hpbmcgTlZDRiBj" + - "b250cm9sLXBsYW5lIGFuZCBjb21wdXRlLXBsYW5lIEhlbG1maWxlIGJ1bmRsZXMuCgojIyBJbnN0" + - "cnVjdGlvbnMKClVzZSB0aGlzIHNraWxsIGZvciBpbnN0YWxsLCB1cGdyYWRlLCBvciB0ZWFyZG93" + - "biB3b3JrIGluIG1hdGNoaW5nIGBudmNmLXNlbGYtbWFuYWdlZC1zdGFja2AgYW5kIGBudmNmLWNv" + - "bXB1dGUtcGxhbmUtc3RhY2tgIGJ1bmRsZXM7IGtlZXAgSGVsbWZpbGUgdmFsdWVzIGFuZCBDTEkg" + - "cHJvZmlsZSBoYW5kb2ZmcyBzZXBhcmF0ZS4gRm9yIGBmdW5jdGlvblR5cGU6ICJMTE0iYCwgcmVh" + - "ZCBbTExNIEZ1bmN0aW9uIEVuYWJsZW1lbnRdKHJlZmVyZW5jZXMvaGVsbWZpbGUtc3RydWN0dXJl" + - "Lm1kI2xsbS1mdW5jdGlvbi1lbmFibGVtZW50KS4KCiMjIFByZXJlcXVpc2l0ZXMKCkFzayBmb3Ig" + - "dGhlIGV4dHJhY3RlZCBgbnZjZi1zZWxmLW1hbmFnZWQtc3RhY2tgIHBhdGguIEZvciBzcGxpdCBp" + - "bnN0YWxsYXRpb24sCmFsc28gcmVxdWlyZSB0aGUgbWF0Y2hpbmctdmVyc2lvbiBgbnZjZi1jb21w" + - "dXRlLXBsYW5lLXN0YWNrYCBwYXRoLiBWZXJpZnkgYm90aDoKCmBgYGJhc2gKbHMgPGNvbnRyb2wt" + - "cGxhbmUtc3RhY2s+L2hlbG1maWxlLmQvIDxjb250cm9sLXBsYW5lLXN0YWNrPi9lbnZpcm9ubWVu" + - "dHMvIDxjb250cm9sLXBsYW5lLXN0YWNrPi9zZWNyZXRzLyA8Y29udHJvbC1wbGFuZS1zdGFjaz4v" + - "Z2xvYmFsLnlhbWwuZ290bXBsCmxzIDxjb21wdXRlLXBsYW5lLXN0YWNrPi9oZWxtZmlsZS5kLyA8" + - "Y29tcHV0ZS1wbGFuZS1zdGFjaz4vZW52aXJvbm1lbnRzLyA8Y29tcHV0ZS1wbGFuZS1zdGFjaz4v" + - "Z2xvYmFsLnlhbWwuZ290bXBsCmBgYAoKSWYgZWl0aGVyIGRpcmVjdG9yeSBpcyBtaXNzaW5nLCBk" + - "b3dubG9hZCBtYXRjaGluZyBidW5kbGUgdmVyc2lvbnMgZnJvbSBOR0M6CgpgYGBiYXNoCm5nYyBy" + - "ZWdpc3RyeSByZXNvdXJjZSBkb3dubG9hZC12ZXJzaW9uIDxvcmc+L252Y2Ytc2VsZi1tYW5hZ2Vk" + - "LXN0YWNrOjx2ZXJzaW9uPgpuZ2MgcmVnaXN0cnkgcmVzb3VyY2UgZG93bmxvYWQtdmVyc2lvbiA8" + - "b3JnPi9udmNmLWNvbXB1dGUtcGxhbmUtc3RhY2s6PHZlcnNpb24+CmBgYAoKQ29udHJvbC1wbGFu" + - "ZSBjb21tYW5kcyBiZWxvdyBhc3N1bWUgdGhlIGNvbnRyb2wtcGxhbmUgYnVuZGxlIHJvb3QuIFNw" + - "bGl0LWZsb3cKY29tbWFuZHMgYW5kIHJvb3Qgc3Vic3RpdHV0aW9uIGFyZSBpbgpbU3BsaXQgQ29t" + - "cHV0ZS1QbGFuZSBJbnN0YWxsYXRpb25dKHJlZmVyZW5jZXMvY29tcHV0ZS1wbGFuZS1pbnN0YWxs" + - "YXRpb24ubWQpLgoKIyMgQmVmb3JlIFlvdSBTdGFydAoKVmVyaWZ5IHRvb2xpbmcgYW5kIGNvbnRl" + - "eHQgYmVmb3JlIGFueSBvcGVyYXRpb246CgpgYGBiYXNoCmhlbG1maWxlIC0tdmVyc2lvbiAgICMg" + - "TXVzdCBiZSAxLjEueCAoMS4yLjAgcmVtb3ZlZCBzZXF1ZW50aWFsIG1vZGUpCmhlbG0gdmVyc2lv" + - "biAgICAgICAgICMgTXVzdCBiZSA+PSAzLjEyCmhlbG0gcGx1Z2luIGxpc3QgICAgICMgTXVzdCBp" + - "bmNsdWRlIGhlbG0tZGlmZiA+PSAzLjExCmt1YmVjdGwgdmVyc2lvbiAgICAgICMgQ2xpZW50IG11" + - "c3QgYmUgd2l0aGluIDEgbWlub3IgdmVyc2lvbiBvZiBjbHVzdGVyCmBgYAoKQ29udHJvbC1wbGFu" + - "ZSBjb21tYW5kcyBydW4gZnJvbSB0aGUgZXh0cmFjdGVkIGBudmNmLXNlbGYtbWFuYWdlZC1zdGFj" + - "ay9gIHJvb3Q6CgpgYGBiYXNoCmNkIHBhdGgvdG8vbnZjZi1zZWxmLW1hbmFnZWQtc3RhY2sKbHMg" + - "aGVsbWZpbGUuZC8gZW52aXJvbm1lbnRzLyBzZWNyZXRzLyBnbG9iYWwueWFtbC5nb3RtcGwKYGBg" + - "CgpJZGVudGlmeSB0aGUgZW52aXJvbm1lbnQgZnJvbSBgZW52aXJvbm1lbnRzLzxuYW1lPi55YW1s" + - "YCBhbmQKYHNlY3JldHMvPG5hbWU+LXNlY3JldHMueWFtbGA7IGZvciBFS1MsIHVzZSB0aGUgY2Fu" + - "b25pY2FsCltDU1AgRW5kLXRvLUVuZCBFeGFtcGxlXShodHRwczovL2RvY3MubnZpZGlhLmNvbS9u" + - "dmNmL3YwLjYuMC1yYy9jc3AtZW5kLXRvLWVuZC1leGFtcGxlKS4KCiMjIEhvdyBWYWx1ZXMgRmxv" + - "dwoKVW5kZXJzdGFuZGluZyB2YWx1ZSBwcmVjZWRlbmNlIHByZXZlbnRzIHRoZSBtb3N0IGNvbW1v" + - "biBjb25maWd1cmF0aW9uIG1pc3Rha2VzLgoKYGBgCmVudmlyb25tZW50cy9iYXNlLnlhbWwgICAg" + - "ICAgICAgKGRlZmF1bHRzKQogICAgLT4gbWVyZ2VkIHdpdGgKZW52aXJvbm1lbnRzLzxlbnY+Lnlh" + - "bWwgICAgICAgICAoeW91ciBvdmVycmlkZXMpCiAgICAtPiBjb25zdW1lZCBieQpnbG9iYWwueWFt" + - "bC5nb3RtcGwgICAgICAgICAgICAgIChHbyB0ZW1wbGF0ZSwgY29uc3RydWN0cyBwZXItY2hhcnQg" + - "dmFsdWVzKQogICAgLT4gY29uc3VtZWQgYnkKc2VjcmV0cy88ZW52Pi1zZWNyZXRzLnlhbWwgICAg" + - "ICAoc2Vuc2l0aXZlIHZhbHVlcykKICAgIC0+IG92ZXJyaWRkZW4gYnkKcmVsZWFzZSBpbmxpbmUg" + - "dmFsdWVzOiBibG9ja3MgICAoaGlnaGVzdCBwcmVjZWRlbmNlKQpgYGAKCkNyaXRpY2FsOiBgZ2xv" + - "YmFsLnlhbWwuZ290bXBsYCBvbmx5IHBhc3NlcyB0aHJvdWdoIHNwZWNpZmljIGtleXMgdG8gZWFj" + - "aCBjaGFydCAoaW1hZ2UgcmVnaXN0cmllcywgbm9kZSBzZWxlY3RvcnMsIHN0b3JhZ2UsIHJlcGxp" + - "Y2EgY291bnRzKS4gU2V0dGluZyBhbiBhcmJpdHJhcnkgY2hhcnQgdmFsdWUgaW4gdGhlIGVudmly" + - "b25tZW50IGZpbGUgd2lsbCBiZSBzaWxlbnRseSBpZ25vcmVkIGlmIGBnbG9iYWwueWFtbC5nb3Rt" + - "cGxgIGRvZXMgbm90IHByb3BhZ2F0ZSBpdC4KClRvIG92ZXJyaWRlIGFyYml0cmFyeSBjaGFydCB2" + - "YWx1ZXMsIHVzZSBhIGhlbG1maWxlIHJlbGVhc2UgYHZhbHVlczpgIGJsb2NrLiBTZWUgW092ZXJy" + - "aWRpbmcgSGVsbSBDaGFydCBWYWx1ZXNdKCNvdmVycmlkaW5nLWhlbG0tY2hhcnQtdmFsdWVzKS4K" + - "CiMjIENsZWFuIEluc3RhbGxhdGlvbgoKIyMjIDEuIENyZWF0ZSBuYW1lc3BhY2VzIGFuZCBpbWFn" + - "ZSBwdWxsIHNlY3JldHMgKGlmIHVzaW5nIGEgcHJpdmF0ZSByZWdpc3RyeSkKCmBgYGJhc2gKZm9y" + - "IG5zIGluIGNhc3NhbmRyYS1zeXN0ZW0gbmF0cy1zeXN0ZW0gbnZjZiBhcGkta2V5cyBlc3Mgc2lz" + - "IHZhdWx0LXN5c3RlbSBjZXJ0LW1hbmFnZXI7IGRvCiAga3ViZWN0bCBjcmVhdGUgbmFtZXNwYWNl" + - "ICIkbnMiIC0tZHJ5LXJ1bj1jbGllbnQgLW8geWFtbCB8IGt1YmVjdGwgYXBwbHkgLWYgLQpkb25l" + - "CgojIE9ubHkgaWYgcHVsbGluZyBmcm9tIGEgcHJpdmF0ZSByZWdpc3RyeSAoZS5nLiwgTkdDIG52" + - "Y3IuaW8pCmV4cG9ydCBOR0NfQVBJX0tFWT0iPHlvdXIta2V5PiIKZm9yIG5zIGluIGNhc3NhbmRy" + - "YS1zeXN0ZW0gbmF0cy1zeXN0ZW0gbnZjZiBhcGkta2V5cyBlc3Mgc2lzIHZhdWx0LXN5c3RlbSBj" + - "ZXJ0LW1hbmFnZXI7IGRvCiAga3ViZWN0bCBjcmVhdGUgc2VjcmV0IGRvY2tlci1yZWdpc3RyeSBu" + - "dmNyLWNyZWRzIFwKICAgIC0tZG9ja2VyLXNlcnZlcj1udmNyLmlvIFwKICAgIC0tZG9ja2VyLXVz" + - "ZXJuYW1lPSckb2F1dGh0b2tlbicgXAogICAgLS1kb2NrZXItcGFzc3dvcmQ9IiROR0NfQVBJX0tF" + - "WSIgXAogICAgLS1uYW1lc3BhY2U9IiRucyIgXAogICAgLS1kcnktcnVuPWNsaWVudCAtbyB5YW1s" + - "IHwga3ViZWN0bCBhcHBseSAtZiAtCmRvbmUKYGBgCgpJZiB1c2luZyBwdWxsIHNlY3JldHMsIHlv" + - "dSBtdXN0IGFsc28gY29uZmlndXJlIGVhY2ggaGVsbWZpbGUgcmVsZWFzZSB0byByZWZlcmVuY2Ug" + - "dGhlbS4gU2VlIFtJbWFnZSBQdWxsIFNlY3JldHNdKCNpbWFnZS1wdWxsLXNlY3JldHMpLgoKIyMj" + - "IDIuIEF1dGhlbnRpY2F0ZSBoZWxtIHRvIHlvdXIgY2hhcnQgcmVnaXN0cnkKCkJvdGggYGRvY2tl" + - "ciBsb2dpbmAgQU5EIGBoZWxtIHJlZ2lzdHJ5IGxvZ2luYCBhcmUgcmVxdWlyZWQgZm9yIE5HQy4g" + - "SGVsbWZpbGUgdXNlcyBoZWxtIChub3QgZG9ja2VyKSB0byBwdWxsIE9DSSBjaGFydHMsIHNvIHRo" + - "ZSBoZWxtIGNyZWRlbnRpYWwgc3RvcmUgbXVzdCBiZSBhdXRoZW50aWNhdGVkIHNlcGFyYXRlbHku" + - "CgpgYGBiYXNoCiMgTkdDIC0tIGJvdGggY29tbWFuZHMgYXJlIHJlcXVpcmVkCmRvY2tlciBsb2dp" + - "biBudmNyLmlvIC11ICckb2F1dGh0b2tlbicgLXAgIiROR0NfQVBJX0tFWSIKaGVsbSByZWdpc3Ry" + - "eSBsb2dpbiBudmNyLmlvIC11ICckb2F1dGh0b2tlbicgLXAgIiROR0NfQVBJX0tFWSIKCiMgRUNS" + - "CmF3cyBlY3IgZ2V0LWxvZ2luLXBhc3N3b3JkIC0tcmVnaW9uIDxyZWdpb24+IHwgXAogIGhlbG0g" + - "cmVnaXN0cnkgbG9naW4gLS11c2VybmFtZSBBV1MgLS1wYXNzd29yZC1zdGRpbiA8YWNjb3VudD4u" + - "ZGtyLmVjci48cmVnaW9uPi5hbWF6b25hd3MuY29tCmBgYAoKPiBOb3RlOiBgaGVsbSByZWdpc3Ry" + - "eSBsb2dpbmAga2VlcHMgb25seSB0aGUgbGFzdCBsb2dpbiBwZXIgaG9zdCAobXVsdGktb3JnIGdv" + - "dGNoYSkuCj4gVGhlIHN0YWNrIGFuZCB0aGUgY2FjaGVzIHNwYW4gc2V2ZXJhbCBOR0Mgb3JncyB0" + - "aGF0IG5lZWQgZGlmZmVyZW50IGtleXMsIGJ1dCB0aGV5IGFsbAo+IGxpdmUgdW5kZXIgdGhlIG9u" + - "ZSBob3N0IGBudmNyLmlvYC4gQSBzZWNvbmQgYGhlbG0gcmVnaXN0cnkgbG9naW4gbnZjci5pb2Ag" + - "KG9yCj4gYGRvY2tlciBsb2dpbmApIHdpdGggYSBkaWZmZXJlbnQga2V5IHNpbGVudGx5IG92ZXJ3" + - "cml0ZXMgdGhlIGZpcnN0LCBzbyBwdWxscyBmb3IgdGhlCj4gZmlyc3Qgb3JnIHRoZW4gZmFpbCB3" + - "aXRoIGEgbWlzbGVhZGluZyBgNDAzIEFjY2VzcyBEZW5pZWRgIChub3QgYSA0MDE6IHRoZSBhdXRo" + - "Cj4gc3VjY2VlZGVkLCBpdCdzIHRoZSB3cm9uZy1vcmcga2V5KS4gSWYgeW91IHB1bGwgY2hhcnRz" + - "L2ltYWdlcyBmcm9tIG1vcmUgdGhhbiBvbmUgb3JnLAo+IGVpdGhlciByZS1ydW4gdGhlIGxvZ2lu" + - "IHdpdGggdGhlIGNvcnJlY3Qga2V5IGltbWVkaWF0ZWx5IGJlZm9yZSBlYWNoIHB1bGwsIG9yIHBh" + - "c3MKPiBgLS11c2VybmFtZSAnJG9hdXRodG9rZW4nIC0tcGFzc3dvcmQgPGtleT5gIHBlciBgaGVs" + - "bSBwdWxsYCBpbnZvY2F0aW9uIGluc3RlYWQgb2YgcmVseWluZwo+IG9uIHRoZSBzdG9yZWQgbG9n" + - "aW4uIChQdWxsaW5nIGV2ZXJ5dGhpbmcgZnJvbSBhIHNpbmdsZSByZWdpc3RyeSBtaXJyb3IgYXZv" + - "aWRzIHRoaXMKPiBlbnRpcmVseS4pCgojIyMgMmIuIChSZWNvbW1lbmRlZCkgUHVsbCBmcm9tIGEg" + - "cmVnaXN0cnkgdGhlIGNsdXN0ZXIgYXV0aGVudGljYXRlcyB0byBhdXRvbWF0aWNhbGx5CgpJZiB5" + - "b3UgbWlycm9yIHRoZSBOVkNGIGltYWdlcyBpbnRvIGEgcmVnaXN0cnkgdGhhdCB0aGUgY2x1c3Rl" + - "ciBjYW4gcHVsbCBmcm9tIHdpdGhvdXQgYW4KZXhwbGljaXQgaW1hZ2UgcHVsbCBzZWNyZXQgKGZv" + - "ciBleGFtcGxlLCBhIHJlZ2lzdHJ5IHdoZXJlIHRoZSBub2RlIG9yIHdvcmtsb2FkIGlkZW50aXR5" + - "IGlzCmdyYW50ZWQgcHVsbCBhY2Nlc3MgYXV0b21hdGljYWxseSksIHBvaW50IHRoZSBzdGFjayBh" + - "dCBpdCBhbmQgc2tpcCB0aGUgY3JlZGVudGlhbCBzdGVwcwphYm92ZS4KCjEuIFBvaW50IHRoZSBz" + - "dGFjayBhdCB0aGUgbWlycm9yIGluIGBlbnZpcm9ubWVudHMvPGVudj4ueWFtbGA6CgogICBgYGB5" + - "YW1sCiAgIGdsb2JhbDoKICAgICBpbWFnZToKICAgICAgIHJlZ2lzdHJ5OiA8eW91ci1yZWdpc3Ry" + - "eT4gICAgICAgICAgICAjIGUuZy4gcmVnaXN0cnkuZXhhbXBsZS5jb20KICAgICAgIHJlcG9zaXRv" + - "cnk6IDxtaXJyb3Itc3ViLXBhdGg+CiAgICAgaGVsbToKICAgICAgIHNvdXJjZXM6ICAgICAgICAg" + - "ICAgICAgICAgICAgICAgICAgICAgIyBvbmx5IGlmIHlvdSBhbHNvIG1pcnJvcmVkIHRoZSBoZWxt" + - "IGNoYXJ0cwogICAgICAgICByZWdpc3RyeTogPHlvdXItcmVnaXN0cnk+CiAgICAgICAgIHJlcG9z" + - "aXRvcnk6IDxtaXJyb3Itc3ViLXBhdGg+CiAgIGBgYAoKICAgPiBUaGUgbWFuaWZlc3QgaGFzIGEg" + - "bWl4IG9mIE9DSSBhbmQgbm9uLU9DSSBhcnRpZmFjdHMsIHNvIGNvbnZlcnQgbm9uLU9DSSBjaGFy" + - "dHMgYmVmb3JlCiAgID4gbWlycm9yaW5nLiBDb250YWluZXIgaW1hZ2VzIChgbnZjci5pby8uLi5g" + - "KSBhcmUgYWxyZWFkeSBPQ0kgYW5kIG1pcnJvciBhcy1pcy4gU29tZSBIZWxtCiAgID4gY2hhcnRz" + - "LCB0aG91Z2gsIGFyZSBwdWJsaXNoZWQgdG8gYW4gYGh0dHBzOi8vYCBIZWxtIHJlcG9zaXRvcnkg" + - "KGZvciBleGFtcGxlCiAgID4gYGhlbG0ubmdjLm52aWRpYS5jb21gKS4gVGhvc2UgYXJlIG5vdCBP" + - "Q0kgYW5kIGNhbm5vdCBiZSByZXNvbHZlZCBieSBgZ2xvYmFsLmhlbG0uc291cmNlc2AKICAgPiAo" + - "T0NJKSBvciBtaXJyb3JlZCBkaXJlY3RseS4gQmVmb3JlIHBvaW50aW5nIHRoZSBzdGFjayBhdCB5" + - "b3VyIG1pcnJvciwgY29udmVydCBlYWNoCiAgID4gYGh0dHBzOi8vYCBjaGFydCB0byBPQ0k6IGBo" + - "ZWxtIHJlcG8gYWRkYC9gaGVsbSBwdWxsYCB0aGUgYC50Z3pgLCB0aGVuCiAgID4gYGhlbG0gcHVz" + - "aCA8Y2hhcnQ+LnRneiBvY2k6Ly88eW91ci1yZWdpc3RyeT4vPG1pcnJvci1zdWItcGF0aD5gLiBP" + - "bmx5IE9DSSBjaGFydHMgY2FuIGxpdmUKICAgPiB1bmRlciBgZ2xvYmFsLmhlbG0uc291cmNlc2Au" + - "CgoyLiBTa2lwIHRoZSBjcmVkZW50aWFsIHN0ZXBzIGFib3ZlLiBXaGVuIHRoZSBjbHVzdGVyIGF1" + - "dGhlbnRpY2F0ZXMgdG8gdGhlIHJlZ2lzdHJ5CiAgIGF1dG9tYXRpY2FsbHkgKHRoZSBub2RlIG9y" + - "IHdvcmtsb2FkIGlkZW50aXR5IGhhcyBwdWxsIGFjY2VzcyksIHRoZSBwdWxsIG5lZWRzIG5vCiAg" + - "IEt1YmVybmV0ZXMgc2VjcmV0LCBzbyB5b3UgZG8gbm90IG5lZWQ6IHRoZSBwZXItbmFtZXNwYWNl" + - "IGBudmNyLWNyZWRzYCBmcm9tIHN0ZXAgMQogICAoc3RpbGwgY3JlYXRlIHRoZSBuYW1lc3BhY2Vz" + - "LCBqdXN0IG5vdCB0aGUgc2VjcmV0KSwgdGhlIGBnbG9iYWwuaW1hZ2VQdWxsU2VjcmV0c2AgZW50" + - "cnksCiAgIG9yIHRoZSBgZG9ja2VyIGxvZ2luYC9gaGVsbSByZWdpc3RyeSBsb2dpbiBudmNyLmlv" + - "YCBmcm9tIHN0ZXAgMi4KCiAgID4gT25lIHJlc2lkdWFsIGNyZWRlbnRpYWw6IG52Y2YtYXBpIHN0" + - "aWxsIHZhbGlkYXRlcyB0aGUgdXNlciBmdW5jdGlvbiBpbWFnZSBhdAogICA+IGBmdW5jdGlvbiBj" + - "cmVhdGVgIHZpYSB0aGUgYWNjb3VudCByZWdpc3RyeSBjcmVkZW50aWFsLCBzbyB0aGF0IGNyZWRl" + - "bnRpYWwgbXVzdCBwb2ludCBhdAogICA+IHdoaWNoZXZlciByZWdpc3RyeSBob2xkcyB0aGUgdXNl" + - "ciBpbWFnZSAoc2V0IGl0IHRvIHlvdXIgbWlycm9yIGlmIHRoZSBpbWFnZSBpcyBtaXJyb3JlZAog" + - "ICA+IHRoZXJlKS4KCiMjIyAzLiBTZXQgdGhlIHJvdXRlIGRvbWFpbgoKYGdsb2JhbC5kb21haW5g" + - "IHNldHMgdGhlIGhvc3RuYW1lIHN1ZmZpeCBmb3Igcm91dGVzIHN1Y2ggYXMgYGFwaS48ZG9tYWlu" + - "PmAuIEl0IGRvZXMgbm90IGNvbmZpZ3VyZSB0aGUgR2F0ZXdheSBvciBpdHMgbG9hZCBiYWxhbmNl" + - "ci4gUXVlcnkgdGhlIGV4YWN0IGV4aXN0aW5nIEdhdGV3YXk6CgpgYGBiYXNoCkdBVEVXQVlfQURE" + - "UkVTUz0kKGt1YmVjdGwgZ2V0IGdhdGV3YXkgPGdhdGV3YXktbmFtZT4gLW4gPGdhdGV3YXktbmFt" + - "ZXNwYWNlPiAtbyBqc29ucGF0aD0ney5zdGF0dXMuYWRkcmVzc2VzWzBdLnZhbHVlfScpCnRlc3Qg" + - "LW4gIiRHQVRFV0FZX0FERFJFU1MiCmBgYAoKVGhlIGFkZHJlc3MgbWF5IGJlIGEgaG9zdG5hbWUg" + - "b3IgSVAuIENsb3VkIHByb3ZpZGVyIGFuZCBHYXRld2F5IGNvbmZpZ3VyYXRpb24gZGV0ZXJtaW5l" + - "IHRoZSBsb2FkIGJhbGFuY2VyIHR5cGUgYW5kIGFkZHJlc3MgZm9ybWF0LiBUaGUgc2VsZi1tYW5h" + - "Z2VkIHN0YWNrIGRvZXMgbm90IHNlbGVjdCBlaXRoZXIuCgpGb3IgdGVtcG9yYXJ5IHRlc3Rpbmcg" + - "d2l0aG91dCBETlMsIHVzZSBhIHN0YWJsZSByZXNlcnZlZCBzdWZmaXggc3VjaCBhcyBgZ2xvYmFs" + - "LmRvbWFpbjogIm52Y2YudGVzdCJgLCBjb25uZWN0IHRvIGBHQVRFV0FZX0FERFJFU1NgLCBhbmQg" + - "c2VuZCBgSG9zdDogYXBpLm52Y2YudGVzdGAuIEZvciBwcm9kdWN0aW9uLCB1c2UgeW91ciBiYXNl" + - "IEROUyBkb21haW4gYW5kIHBvaW50IGl0cyByb3V0ZSByZWNvcmRzIHRvIGBHQVRFV0FZX0FERFJF" + - "U1NgLiBJZiB0aGUgZW5kcG9pbnQgbGF0ZXIgY2hhbmdlcywga2VlcCBgZ2xvYmFsLmRvbWFpbmAg" + - "c3RhYmxlIGFuZCB1cGRhdGUgb25seSBETlMgb3IgdGhlIGNsaWVudCBkZXN0aW5hdGlvbi4gU2Vl" + - "IEV4YW1wbGUgNCBpbiBbZXhhbXBsZXMubWRdKGV4YW1wbGVzLm1kKS4KCiMjIyA0LiBQcmV2aWV3" + - "IGFuZCBkZXBsb3kKCmBgYGJhc2gKSEVMTUZJTEVfRU5WPTxlbnYtbmFtZT4gaGVsbWZpbGUgdGVt" + - "cGxhdGUgICAjIFByZXZpZXcgcmVuZGVyZWQgbWFuaWZlc3RzCkhFTE1GSUxFX0VOVj08ZW52LW5h" + - "bWU+IGhlbG1maWxlIHN5bmMgICAgICAgIyBEZXBsb3kKYGBgCgo+IFNldCBCT1RIIENhc3NhbmRy" + - "YSBwYXNzd29yZHMgaW4gdGhlIHNlY3JldHMgZmlsZS4gVGhlIHNlY3JldHMgZmlsZSBkb2N1bWVu" + - "dHMKPiBgREVGQVVMVF9DQVNTQU5EUkFfUEFTU1dPUkRgLCBidXQgdGhlIGNhc3NhbmRyYSBjaGFy" + - "dCBoYXMgYSBzZWNvbmQgY3JlZGVudGlhbCwKPiBgY2Fzc2FuZHJhLnNlcnZpY2VSb2xlUGFzc3dv" + - "cmRgLCB0aGF0IGRlZmF1bHRzIHRvIGBjaEBuZzNtM2AuIElmIHlvdSBzZXQgb25seQo+IGBERUZB" + - "VUxUX0NBU1NBTkRSQV9QQVNTV09SRGAsIHRoZSBzZXJ2aWNlIHJvbGUga2VlcHMgdGhhdCBkZWZh" + - "dWx0IGFuZCBldmVyeSBEQi1iYWNrZWQKPiBzZXJ2aWNlIGNyYXNoLWxvb3BzIHdpdGggYEJhZCBj" + - "cmVkZW50aWFsc2Agb25jZSBpdCB0cmllcyB0byBhdXRoZW50aWNhdGUuIFNldAo+IGBjYXNzYW5k" + - "cmEuc2VydmljZVJvbGVQYXNzd29yZGAgdG8gdGhlIHNhbWUgdmFsdWUgYXMgYERFRkFVTFRfQ0FT" + - "U0FORFJBX1BBU1NXT1JEYC4KCiMjIyA1LiBEZXBsb3ltZW50IHBoYXNlcwoKSGVsbWZpbGUgZGVw" + - "bG95cyBpbiBvcmRlciB3aXRoIGRlcGVuZGVuY2llczoKCnwgUGhhc2UgfCBTZWxlY3RvciB8IFNl" + - "cnZpY2VzIHwgV2FpdCB0aW1lIHwKfC0tLS0tLS18LS0tLS0tLS0tLXwtLS0tLS0tLS0tfC0tLS0t" + - "LS0tLS0tfAp8IDEgfCBgcmVsZWFzZS1ncm91cD1kZXBlbmRlbmNpZXNgIHwgTkFUUywgT3BlbkJh" + - "bywgQ2Fzc2FuZHJhIHwgNS0xMCBtaW4gfAp8IDIgfCBgcmVsZWFzZS1ncm91cD1zZXJ2aWNlc2Ag" + - "fCBBUEksIFNJUywgRVNTLCBpbnZvY2F0aW9uLCBncnBjLXByb3h5LCBub3RhcnksIGFwaS1rZXlz" + - "LCBvcHRpb25hbCBMTE0gZ2F0ZXdheS9yb3V0ZXIsIG9wdGlvbmFsIFZhbml0eSBHYXRld2F5LCBO" + - "VkNGIFVJIHdoZW4gdGhlIHN0YWNrIHBhY2thZ2UgaW5jbHVkZXMgdGhlIGFkZG9uIHwgNS0xMCBt" + - "aW4gfAp8IDMgfCBgcmVsZWFzZS1ncm91cD1pbmdyZXNzYCB8IEdhdGV3YXkgcm91dGVzIHwgMS0y" + - "IG1pbiB8CnwgNCB8IGByZWxlYXNlLWdyb3VwPW9ic2VydmFiaWxpdHlgIHwgT2JzZXJ2YWJpbGl0" + - "eSBzdGFjayAoaWYgZW5hYmxlZCkgfCAxLTIgbWluIHwKCk1vbml0b3IgaW4gYSBzZXBhcmF0ZSB0" + - "ZXJtaW5hbDoKCmBgYGJhc2gKa3ViZWN0bCBnZXQgcG9kcyAtQSAtdwpgYGAKCiMjIyA2LiBFbmFi" + - "bGUgVmFuaXR5IEdhdGV3YXkgKG9wdGlvbmFsKQoKVmFuaXR5IEdhdGV3YXkgaXMgZGlzYWJsZWQg" + - "YnkgZGVmYXVsdCBhbmQgaXMgb25seSBuZWVkZWQgZm9yIGN1c3RvbWVyLWZhY2luZwpob3N0bmFt" + - "ZXMgb3IgcGF0aCBtYXBwaW5ncyBpbiBmcm9udCBvZiB0aGUgc3RhbmRhcmQgTlZDRiBBUEkgYW5k" + - "IGludm9jYXRpb24Kcm91dGVzLiBJdCBpcyBhdmFpbGFibGUgb25seSBpbiBzdGFjayBwYWNrYWdl" + - "cyB0aGF0IGluY2x1ZGUgdGhlIFZhbml0eSBHYXRld2F5CmFkZG9uLiBJZiB0aGUgZXh0cmFjdGVk" + - "IHN0YWNrIHBhY2thZ2UgZG9lcyBub3QgY29udGFpbiBhIGB2YW5pdHktZ2F0ZXdheWAKcmVsZWFz" + - "ZSBhbmQgYHZhbml0eUdhdGV3YXlgIHJvdXRlIHZhbHVlcywgc2tpcCB0aGVzZSBjb21tYW5kcyBh" + - "bmQgdXNlIGEgbmV3ZXIKc3RhY2sgcGFja2FnZSB0aGF0IGluY2x1ZGVzIHRoZW0uCgpJZiB0aGUg" + - "c3RhY2sgcGFja2FnZSBpbmNsdWRlcyB0aGUgYWRkb24sIGVuYWJsZSBpdCBpbgpgZW52aXJvbm1l" + - "bnRzLzxlbnYtbmFtZT4ueWFtbGA6CgpgYGB5YW1sCmFkZG9uczoKICB2YW5pdHlHYXRld2F5Ogog" + - "ICAgZW5hYmxlZDogdHJ1ZQogICAgbWFwcGluZ0NvbmZpZzoge30KYGBgCgpUaGUgZGVmYXVsdCBy" + - "b3V0ZSBob3N0IGlzIGB2YW5pdHkuPGRvbWFpbj5gIGFuZCB0aGUgYmFja2VuZCBpcwpgdmFuaXR5" + - "LWdhdGV3YXkubnZjZjo4MDgwYC4gUHV0IGRlcGxveW1lbnQtc3BlY2lmaWMgaG9zdCBhbmQgcGF0" + - "aCBtYXBwaW5ncyB1bmRlcgpgYWRkb25zLnZhbml0eUdhdGV3YXkubWFwcGluZ0NvbmZpZ2AuIElm" + - "IHlvdSBuZWVkIGN1c3RvbSB2YW5pdHkgaG9zdHMgaW5zdGVhZCBvZgpgdmFuaXR5Ljxkb21haW4+" + - "YCwgdXNlIHRoZSByb3V0ZSBob3N0bmFtZSBvdmVycmlkZXMgc3VwcG9ydGVkIGJ5IHRoZSBzdGFj" + - "awpwYWNrYWdlIGFuZCBjcmVhdGUgbWF0Y2hpbmcgRE5TIHJlY29yZHMuCgpBZnRlciBjb25maXJt" + - "aW5nIHRoZSBwYWNrYWdlIGluY2x1ZGVzIHRoZSBgdmFuaXR5LWdhdGV3YXlgIHJlbGVhc2UsIHBy" + - "ZXZpZXcgYW5kCmFwcGx5IHRoZSBzZXJ2aWNlIGFuZCByb3V0ZToKCmBgYGJhc2gKSEVMTUZJTEVf" + - "RU5WPTxlbnYtbmFtZT4gaGVsbWZpbGUgLS1zZWxlY3RvciBuYW1lPXZhbml0eS1nYXRld2F5IHRl" + - "bXBsYXRlCkhFTE1GSUxFX0VOVj08ZW52LW5hbWU+IGhlbG1maWxlIC0tc2VsZWN0b3IgbmFtZT12" + - "YW5pdHktZ2F0ZXdheSBzeW5jCkhFTE1GSUxFX0VOVj08ZW52LW5hbWU+IGhlbG1maWxlIC0tc2Vs" + - "ZWN0b3IgcmVsZWFzZS1ncm91cD1pbmdyZXNzIHN5bmMKYGBgCgpWZXJpZnkgdGhlIHJvdXRlIG9u" + - "bHkgd2hlbiB0aGUgYWRkb24gaXMgcHJlc2VudCBhbmQgZW5hYmxlZDoKCmBgYGJhc2gKa3ViZWN0" + - "bCBnZXQgZGVwbG95LHN2YyAtbiBudmNmIC1sIGFwcC5rdWJlcm5ldGVzLmlvL25hbWU9dmFuaXR5" + - "LWdhdGV3YXkKa3ViZWN0bCBnZXQgaHR0cHJvdXRlIC1BIHwgZ3JlcCAtaSB2YW5pdHkKY3VybCAt" + - "SCAiSG9zdDogdmFuaXR5Ljxkb21haW4+IiAiaHR0cDovLzxnYXRld2F5LWFkZHJlc3M+L2hlYWx0" + - "aCIKYGBgCgpEbyBub3QgZW5hYmxlIFZhbml0eSBHYXRld2F5IGZvciBzdGFuZGFyZCBBUEksIEFQ" + - "SSBLZXlzLCBpbnZvY2F0aW9uLCBMTE0KaW52b2NhdGlvbiwgb3IgZ1JQQyB0cmFmZmljLiBUaG9z" + - "ZSByb3V0ZXMgYXJlIHByb3ZpZGVkIGJ5IHRoZSBiYXNlIGdhdGV3YXkKcm91dGVzLgoKIyMjIDcu" + - "IEVuYWJsZSBOVkNGIFVJIChvcHRpb25hbCkKCk5WQ0YgVUkgaXMgYW4gb3B0aW9uYWwsIGN1c3Rv" + - "bWVyLWZhY2luZyBhZG1pbi1wYW5lbCBVSS4gSXQgaXMgZGlzYWJsZWQgYnkKZGVmYXVsdCBhbmQg" + - "YXZhaWxhYmxlIG9ubHkgaW4gc3RhY2sgcGFja2FnZXMgdGhhdCBpbmNsdWRlIHRoZSBOVkNGIFVJ" + - "IGFkZG9uLiBJZgp5b3VyIGV4dHJhY3RlZCBzdGFjayBwYWNrYWdlIGRvZXMgbm90IGNvbnRhaW4g" + - "YSBgbnZjZi11aWAgcmVsZWFzZSBhbmQgYG52Y2ZVaWAKcm91dGUgdmFsdWVzLCBza2lwIHRoaXMg" + - "c2VjdGlvbi4gVGhlIE5WQ0YgVUkgYWRtaW4gcGFuZWwgaXMgY3VycmVudGx5CnVuYXV0aGVudGlj" + - "YXRlZDsgZG8gbm90IGV4cG9zZSBpdCB0byB0aGUgcHVibGljIGludGVybmV0LgoKRm9yIGVuYWJs" + - "ZW1lbnQsIG5hbWVzcGFjZSBhbmQgcHVsbCBzZWNyZXQgc2V0dXAsIGFwcGx5LCBhbmQgdmVyaWZp" + - "Y2F0aW9uIHN0ZXBzLApzZWUgW05WQ0YgVUkgQWRkb25dKHJlZmVyZW5jZXMvbnZjZi11aS1hZGRv" + - "bi5tZCkuCgojIyMgOC4gSW5zdGFsbCB0aGUgc2VwYXJhdGUgY29tcHV0ZS1wbGFuZSBzdGFjawoK" + - "VGhlIGNvbnRyb2wtcGxhbmUgc3RhY2sgZG9lcyBub3QgaW5zdGFsbCBjb21wdXRlLXBsYW5lIGNv" + - "bXBvbmVudHMuIEFmdGVyIGl0IGlzIGhlYWx0aHksIGNob29zZSBleGFjdGx5IG9uZSBjb21wdXRl" + - "LXBsYW5lIGhhbmRvZmY6CgotIEhlbG1maWxlIHZhbHVlcyBmbG93OiBhdXRob3Igc2VwYXJhdGUg" + - "ZW52aXJvbm1lbnQgZmlsZXMsIHRoZW4gcmVnaXN0ZXIgYW5kCiAgaW5zdGFsbCB3aXRoIHRoZSBj" + - "b21wdXRlLXBsYW5lIE1ha2VmaWxlLgotIENMSSBwcm9maWxlIGZsb3c6IHVzZSB0aGUgcHJvZmls" + - "ZSBnZW5lcmF0ZWQgYnkgdGhlIENMSSBjb250cm9sLXBsYW5lIGluc3RhbGwsCiAgdGhlbiBydW4g" + - "dGhlIGNvbXBsZXRlIENMSSByZWdpc3RlciBhbmQgaW5zdGFsbCBjb21tYW5kcy4KCkRvIG5vdCBt" + - "aXggdGhlc2UgaGFuZG9mZnMuIEZvbGxvdyBbU3BsaXQgQ29tcHV0ZS1QbGFuZSBJbnN0YWxsYXRp" + - "b25dKHJlZmVyZW5jZXMvY29tcHV0ZS1wbGFuZS1pbnN0YWxsYXRpb24ubWQpCmZvciBjb21tYW5k" + - "cywgRUtTIHJvdXRpbmcsIHB1bGwgc2VjcmV0cywgdmVyaWZpY2F0aW9uLCBhbmQgdGVhcmRvd24g" + - "b3JkZXIuCgojIyBDbGVhbiBUZWFyZG93bgoKRGVzdHJveSBldmVyeSBjb21wdXRlIHBsYW5lIGJl" + - "Zm9yZSB0aGUgY29udHJvbCBwbGFuZSwgdXNpbmcgdGhlIHRlYXJkb3duIGZvcgp0aGUgc2FtZSBo" + - "YW5kb2ZmOyBzZWUgW1NwbGl0IENvbXB1dGUtUGxhbmUgSW5zdGFsbGF0aW9uXShyZWZlcmVuY2Vz" + - "L2NvbXB1dGUtcGxhbmUtaW5zdGFsbGF0aW9uLm1kI3RlYXJkb3duKS4KClNjb3BlOiBPbmx5IGRl" + - "c3Ryb3kgcmVsZWFzZXMgbWFuYWdlZCBieSB0aGlzIGNvbnRyb2wtcGxhbmUgaGVsbWZpbGUgc3Rh" + - "Y2suIFRoZSBOVkNGIHJlbGVhc2VzIGFyZTogYG5hdHNgLCBgb3BlbmJhby1zZXJ2ZXJgLCBgY2Fz" + - "c2FuZHJhYCwgYGFwaS1rZXlzYCwgYHNpc2AsIGBhcGlgLCBgaW52b2NhdGlvbi1zZXJ2aWNlYCwg" + - "YGdycGMtcHJveHlgLCBgZXNzLWFwaWAsIGBub3Rhcnktc2VydmljZWAsIG9wdGlvbmFsIGB2YW5p" + - "dHktZ2F0ZXdheWAsIGBudmNmLXVpYCwgYGFkbWluLWlzc3Vlci1wcm94eWAsIGFuZCBgaW5ncmVz" + - "c2A7IGBjZXJ0LW1hbmFnZXJgIGlzIGluY2x1ZGVkIG9ubHkgd2hlbiBgY2VydE1hbmFnZXIuZW5h" + - "YmxlZDogdHJ1ZWAuIFRoZSBjb250cm9sLXBsYW5lIG5hbWVzcGFjZSBpbnZlbnRvcnkgYWxzbyBp" + - "bmNsdWRlcyBgY2VydC1tYW5hZ2VyYCwgYnV0IGRlZmF1bHQgbmFtZXNwYWNlIGNsZWFudXAgcHJl" + - "c2VydmVzIGl0LiBOYW1lc3BhY2UgcHJlc2VydmF0aW9uIGRvZXMgbm90IHByZXNlcnZlIHRoZSBI" + - "ZWxtIHJlbGVhc2UuIEV4dGVybmFsIGNlcnQtbWFuYWdlciBtdXN0IHVzZSBgY2VydE1hbmFnZXIu" + - "ZW5hYmxlZDogZmFsc2VgOyBvdGhlcndpc2UgSGVsbWZpbGUgdHJlYXRzIHRoZSByZWxlYXNlIGFz" + - "IHN0YWNrLW1hbmFnZWQuIERvIG5vdCBkZWxldGUgb3RoZXIgaGVsbSByZWxlYXNlcyBvciBuYW1l" + - "c3BhY2VzIG9uIHRoZSBjbHVzdGVyLgoKQmVmb3JlIGNvbnRyb2wtcGxhbmUgZGVzdHJveSwgaWRl" + - "bnRpZnkgd2hldGhlciBjZXJ0LW1hbmFnZXIgaXMgZXh0ZXJuYWwuIEZvciBhbiBleHRlcm5hbCBp" + - "bnN0YWxsYXRpb24sIHJlcXVpcmUgZWZmZWN0aXZlIGBjZXJ0TWFuYWdlci5lbmFibGVkOiBmYWxz" + - "ZWAgYW5kIGFib3J0IGlmIGl0IGlzIHRydWUuIEZvciBhbiBpbnRlbmRlZCBzdGFjay1tYW5hZ2Vk" + - "IHJlbGVhc2Ugd2l0aCBlZmZlY3RpdmUgYGNlcnRNYW5hZ2VyLmVuYWJsZWQ6IHRydWVgLCB2ZXJp" + - "ZnkgbWF0Y2hpbmcgc3RhY2sgSGVsbSByZWxlYXNlIG1ldGFkYXRhIGFuZCBhYm9ydCBvbiBtaXNz" + - "aW5nIG9yIG1pc21hdGNoZWQgZXZpZGVuY2UuIFByZXNlcnZlIHRoZSBuYW1lc3BhY2UgYnkgZGVm" + - "YXVsdDsgb25seSBwbGFuIGl0cyByZW1vdmFsIGFmdGVyIHZlcmlmeWluZyBuYW1lc3BhY2UgcHJv" + - "dmVuYW5jZSBhbmQgZ2V0dGluZyBleHBsaWNpdCBjb25maXJtYXRpb24uCgojIyMgU3RhbmRhcmQg" + - "dGVhcmRvd24KClJ1biBmcm9tIGluc2lkZSB0aGUgYG52Y2Ytc2VsZi1tYW5hZ2VkLXN0YWNrL2Ag" + - "ZGlyZWN0b3J5OgoKYGBgYmFzaApIRUxNRklMRV9FTlY9PGVudi1uYW1lPiBoZWxtZmlsZSBkZXN0" + - "cm95CmBgYAoKIyMjIERlbGV0ZSBuYW1lc3BhY2VzCgpgYGBiYXNoCmZvciBucyBpbiBjYXNzYW5k" + - "cmEtc3lzdGVtIG5hdHMtc3lzdGVtIG52Y2YgYXBpLWtleXMgZXNzIHNpcyBudmNmLXVpIHZhdWx0" + - "LXN5c3RlbTsgZG8KICBrdWJlY3RsIGRlbGV0ZSBuYW1lc3BhY2UgIiRucyIgLS1pZ25vcmUtbm90" + - "LWZvdW5kCmRvbmUKYGBgCgojIyMgVmVyaWZ5IGNsZWFuCgpgYGBiYXNoCmt1YmVjdGwgZ2V0IG5z" + - "IHwgZ3JlcCAtRSAnKGNhc3NhbmRyYXxuYXRzfHZhdWx0fG52Y2Z8YXBpLWtleXN8ZXNzfHNpcykn" + - "CiMgU2hvdWxkIHJldHVybiBlbXB0eQpgYGAKCiMjIE92ZXJyaWRpbmcgSGVsbSBDaGFydCBWYWx1" + - "ZXMKCiMjIyBFbnZpcm9ubWVudCBmaWxlIChsaW1pdGVkKQoKV29ya3Mgb25seSBmb3Iga2V5cyB0" + - "aGF0IGBnbG9iYWwueWFtbC5nb3RtcGxgIHByb3BhZ2F0ZXMgKGUuZy4sIGBjYXNzYW5kcmEucmVw" + - "bGljYUNvdW50YCwgYGdsb2JhbC5zdG9yYWdlQ2xhc3NgLCBgZ2xvYmFsLmltYWdlYCkuCgojIyMg" + - "UmVsZWFzZSB2YWx1ZXMgYmxvY2sgKGFueSBjaGFydCB2YWx1ZSkKCkVkaXQgdGhlIHJlbGVhc2Ug" + - "aW4gYGhlbG1maWxlLmQvKi55YW1sLmdvdG1wbGAgYW5kIGFkZCBhIGB2YWx1ZXM6YCBibG9jay4g" + - "SW4gdGhlIGV4YW1wbGVzIGJlbG93LCBgPHByaXZhdGUtdmFsdWVzPmAgcmVmZXJzIHRvIHRoZSBg" + - "c2VjcmV0cy9gIGRpcmVjdG9yeSBhdCB0aGUgaGVsbWZpbGUgc3RhY2sgcm9vdC4KCmBgYHlhbWwK" + - "LSBuYW1lOiBjYXNzYW5kcmEKICB2ZXJzaW9uOiAwLjguMAogIGNvbmRpdGlvbjogY2Fzc2FuZHJh" + - "LmVuYWJsZWQKICBuYW1lc3BhY2U6IGNhc3NhbmRyYS1zeXN0ZW0KICA8PDogKmRlcGVuZGVuY3kK" + - "ICB2YWx1ZXM6CiAgICAtIC4uL2dsb2JhbC55YW1sLmdvdG1wbAogICAgLSAuLi88cHJpdmF0ZS12" + - "YWx1ZXM+L3t7IHJlcXVpcmVkRW52ICJIRUxNRklMRV9FTlYiIH19LXNlY3JldHMueWFtbAogICAg" + - "LSBjYXNzYW5kcmE6CiAgICAgICAgcmVzb3VyY2VzOgogICAgICAgICAgbGltaXRzOgogICAgICAg" + - "ICAgICBjcHU6ICI4IgogICAgICAgICAgICBtZW1vcnk6IDgxOTJNaQogICAgICAgICAgcmVxdWVz" + - "dHM6CiAgICAgICAgICAgIGNwdTogIjIiCiAgICAgICAgICAgIG1lbW9yeTogNDA5Nk1pCmBgYAoK" + - "WUFNTCBtZXJnZSBnb3RjaGE6IFdoZW4gYSByZWxlYXNlIHVzZXMgYDw8OiAqZGVwZW5kZW5jeWAg" + - "b3IgYGluaGVyaXRgLCBzcGVjaWZ5aW5nIGB2YWx1ZXM6YCByZXBsYWNlcyB0aGUgdGVtcGxhdGUn" + - "cyB2YWx1ZXMgbGlzdC4gWW91IG11c3QgcmUtaW5jbHVkZSBgZ2xvYmFsLnlhbWwuZ290bXBsYCBh" + - "bmQgdGhlIHNlY3JldHMgZmlsZS4KCiMjIyBQcmV2aWV3IGFuZCBhcHBseSBhIHNpbmdsZSByZWxl" + - "YXNlCgpgYGBiYXNoCkhFTE1GSUxFX0VOVj08ZW52PiBoZWxtZmlsZSAtLXNlbGVjdG9yIG5hbWU9" + - "Y2Fzc2FuZHJhIHRlbXBsYXRlICAjIFByZXZpZXcKSEVMTUZJTEVfRU5WPTxlbnY+IGhlbG1maWxl" + - "IC0tc2VsZWN0b3IgbmFtZT1jYXNzYW5kcmEgc3luYyAgICAgICMgQXBwbHkKYGBgCgojIyBJbWFn" + - "ZSBQdWxsIFNlY3JldHMKClRoZXJlIGFyZSB0aHJlZSBkaXN0aW5jdCBjcmVkZW50aWFsIHR5cGVz" + - "LiBEbyBub3QgY29uZmxhdGUgdGhlbSwgYW5kIG1pbmQgdGhlCmZvcm1hdCBydWxlIGJlbG93ICh0" + - "d28gb2YgdGhlbSBmYWlsIGV2ZW4gd2l0aCB0aGUgY29ycmVjdCBrZXkgaWYgdGhlIGZvcm1hdCBp" + - "cyB3cm9uZyk6Cgp8IHwgQ29udHJvbCBQbGFuZSBQdWxsIFNlY3JldHMgfCBBUEkgQm9vdHN0cmFw" + - "IFJlZ2lzdHJ5IENyZWRzIHwgU2lkZWNhciBJbWFnZS1QdWxsIFNlY3JldCB8CnwtLS18LS0tfC0t" + - "LXwtLS18CnwgUHVycG9zZSB8IEs4cyBwdWxscyBOVkNGIHNlcnZpY2UgaW1hZ2VzIHwgbnZjZi1h" + - "cGkgdmFsaWRhdGVzIHRoZSB1c2VyIGZ1bmN0aW9uIGltYWdlIGF0IGBmdW5jdGlvbiBjcmVhdGVg" + - "IHwgbnZjZi1hcGkgcHVsbHMgdGhlIHBsYXRmb3JtIHNpZGVjYXJzIGluamVjdGVkIGludG8gZXZl" + - "cnkgd29ya2VyIHBvZCB8CnwgV2hlcmUgfCBLOHMgYGRvY2tlci1yZWdpc3RyeWAgU2VjcmV0cyAr" + - "IEt5dmVybm8gQ2x1c3RlclBvbGljeSB8IGA8cHJpdmF0ZS12YWx1ZXM+LzxlbnY+LXNlY3JldHMu" + - "eWFtbGAgKGFjY291bnQtYm9vdHN0cmFwKSB8IGBOVkNGX0FQSV9TSURFQ0FSU19JTUFHRV9QVUxM" + - "X1NFQ1JFVGAgaW4gYDxlbnY+LXNlY3JldHMueWFtbGAgLT4gT3BlbkJhbyBgc2VydmljZXMvbnZj" + - "Zi1hcGkva3Yvc2lkZWNhcnMvaW1hZ2UtcHVsbC1zZWNyZXRgIChmaWVsZCBgc2VjcmV0YCkgfAp8" + - "IEZvcm1hdCB8IHN0YW5kYXJkIGAuZG9ja2VyY29uZmlnanNvbmAgKGt1YmVjdGwgYnVpbGRzIGl0" + - "IGZvciB5b3UpIHwgYGJhc2U2NCgiJG9hdXRodG9rZW46PGtleT4iKWAgfCBgYmFzZTY0KCIkb2F1" + - "dGh0b2tlbjo8a2V5PiIpYCB8Cgo+IE5vdGU6IHRoZSBhY2NvdW50LWJvb3RzdHJhcCBjcmVkIGFu" + - "ZCB0aGUgc2lkZWNhciBzZWNyZXQgYXJlIE5PVCBhCj4gZG9ja2VyY29uZmlnanNvbi4gVGhlIHNl" + - "Y3JldHMgdGVtcGxhdGUgc2hpcHMgdGhlIHBsYWNlaG9sZGVyCj4gYFJFUExBQ0VfV0lUSF9CQVNF" + - "NjRfRE9DS0VSX0NSRURFTlRJQUxgLCB3aGljaCByZWFkcyBhcyAiYmFzZTY0IG9mIGEgZG9ja2Vy" + - "Y29uZmlnanNvbi4iCj4gSXQgaXNuJ3QuIEJvdGggdmFsdWVzIGFyZSBjb25zdW1lZCBhcyBhIHJh" + - "dyBkb2NrZXIgYGF1dGhgIHN0cmluZzogbnZjZi1hcGkgdGFrZXMgdGhlCj4gdmFsdWUgdmVyYmF0" + - "aW0gYW5kIGRyb3BzIGl0IGludG8gdGhlIGBhdXRoYCBmaWVsZCBvZiB0aGUgZG9ja2VyY29uZmln" + - "IGl0IGJ1aWxkcy4gU28gdGhlCj4gdmFsdWUgbXVzdCBiZSBgYmFzZTY0KCIkb2F1dGh0b2tlbjo8" + - "a2V5PiIpYCwgZS5nLiBgcHJpbnRmICckb2F1dGh0b2tlbjolcycgIiRLRVkiIHwgb3BlbnNzbCBi" + - "YXNlNjQgLUFgLAo+IG5vdCBgYmFzZTY0KDxkb2NrZXJjb25maWdqc29uPilgLgo+ICAtIFdyb25n" + - "IGFjY291bnQtYm9vdHN0cmFwIHZhbHVlOiBgZnVuY3Rpb24gY3JlYXRlYCByZXR1cm5zCj4gICAg" + - "YDQwMCAibXVzdCBiZSBiYXNlNjQgZW5jb2RlZCB1c2VybmFtZTpwYXNzd29yZCBmb3JtYXQiYC4K" + - "PiAgLSBXcm9uZyBzaWRlY2FyIHZhbHVlOiBldmVyeSB3b3JrZXIncyBzaWRlY2FyIHB1bGwgZ2V0" + - "cyBhIG1hbGZvcm1lZCBjcmVkZW50aWFsIGFuZAo+ICAgIGA0MDNgcywgcmVnYXJkbGVzcyBvZiB3" + - "aGljaCBrZXkgaXMgaW5zaWRlLiBUaGUgc3ltcHRvbSBsb29rcyBsaWtlIGEgYmFkIG9yIHdyb25n" + - "LW9yZwo+ICAgIGtleSwgYnV0IHRoZSBrZXkgaXMgZmluZSBhbmQgdGhlIGVuY29kaW5nIGlzIHRo" + - "ZSBidWcuIFRvIHJlcGFpciBhbiBhbHJlYWR5LWluc3RhbGxlZAo+ICAgIHN0YWNrIHdpdGhvdXQg" + - "YSBmdWxsIHJlLXN5bmM6Cj4gICAgYGBgYmFzaAo+ICAgIEFVVEg9JChwcmludGYgJyRvYXV0aHRv" + - "a2VuOiVzJyAiJEtFWSIgfCBvcGVuc3NsIGJhc2U2NCAtQSkKPiAgICBiYW8ga3YgcHV0IHNlcnZp" + - "Y2VzL252Y2YtYXBpL2t2L3NpZGVjYXJzL2ltYWdlLXB1bGwtc2VjcmV0IHNlY3JldD0iJEFVVEgi" + - "Cj4gICAgIyBpZiBOVklESUEgQ2xvdWQgVGFza3MgaXMgZW5hYmxlZCwgcmVwZWF0IGZvciBzZXJ2" + - "aWNlcy9udmN0LWFwaS9rdi9zaWRlY2Fycy9pbWFnZS1wdWxsLXNlY3JldAo+ICAgIGt1YmVjdGwg" + - "cm9sbG91dCByZXN0YXJ0IC1uIG52Y2YgZGVwbG95L252Y2YtYXBpICAgIyBwaWNrcyB1cCB0aGUg" + - "bmV3IHNpZGVjYXIgY3JlZAo+ICAgIGBgYAoKPiBOb3RlIChtdWx0aS1vcmcpOiB3aGVuIHB1bGxp" + - "bmcgZnJvbSBOR0MgKG5vdCBhIG1pcnJvciksIHRoZSB1c2VyIGZ1bmN0aW9uIGltYWdlIGFuZAo+" + - "IHRoZSBwbGF0Zm9ybSBzaWRlY2FycyBvZnRlbiBsaXZlIGluIGRpZmZlcmVudCBudmNyLmlvIG9y" + - "Z3MsIGVhY2ggbmVlZGluZyBhIGRpZmZlcmVudAo+IGtleSwgc28gdGhlIGFjY291bnQtYm9vdHN0" + - "cmFwIGNyZWQgKGZ1bmN0aW9uIGltYWdlKSBhbmQgdGhlIHNpZGVjYXIgc2VjcmV0IChzaWRlY2Fy" + - "cykKPiBhcmUgZnJlcXVlbnRseSB0d28gZGlmZmVyZW50IGtleXMuIE1pcnJvcmluZyBldmVyeXRo" + - "aW5nIGludG8gYSBzaW5nbGUgcmVnaXN0cnkgdGhlCj4gY2x1c3RlciBhdXRoZW50aWNhdGVzIHRv" + - "IGF1dG9tYXRpY2FsbHkgY29sbGFwc2VzIHRoaXMgdG8gb25lIGNyZWRlbnRpYWwgcGF0aC4KCiMj" + - "IyBDb25maWd1cmluZyB3aXRoIEt5dmVybm8gKHJlY29tbWVuZGVkKQoKVXNlIGEgS3l2ZXJubyBt" + - "dXRhdGluZyBhZG1pc3Npb24gcG9saWN5IHRvIGF1dG9tYXRpY2FsbHkgaW5qZWN0IGBpbWFnZVB1" + - "bGxTZWNyZXRzYCBpbnRvIGFsbCBwb2RzIGluIE5WQ0YgbmFtZXNwYWNlcy4gVGhpcyB3b3JrcyB1" + - "bmlmb3JtbHkgZm9yIGFsbCBjaGFydHMgLS0gbm8gcGVyLWNoYXJ0IGNvbmZpZ3VyYXRpb24gb3Ig" + - "aGVsbWZpbGUgbW9kaWZpY2F0aW9ucyBuZWVkZWQuCgpgYGBiYXNoCiMgMS4gSW5zdGFsbCBLeXZl" + - "cm5vCmhlbG0gcmVwbyBhZGQga3l2ZXJubyBodHRwczovL2t5dmVybm8uZ2l0aHViLmlvL2t5dmVy" + - "bm8vCmhlbG0gcmVwbyB1cGRhdGUKaGVsbSBpbnN0YWxsIGt5dmVybm8ga3l2ZXJuby9reXZlcm5v" + - "IC1uIGt5dmVybm8gLS1jcmVhdGUtbmFtZXNwYWNlCgojIDIuIENyZWF0ZSBwdWxsIHNlY3JldCBp" + - "biBlYWNoIG5hbWVzcGFjZQpleHBvcnQgTkdDX0FQSV9LRVk9Ijx5b3VyLWtleT4iCmZvciBucyBp" + - "biBjYXNzYW5kcmEtc3lzdGVtIG5hdHMtc3lzdGVtIG52Y2YgYXBpLWtleXMgZXNzIHNpcyB2YXVs" + - "dC1zeXN0ZW0gY2VydC1tYW5hZ2VyOyBkbwogIGt1YmVjdGwgY3JlYXRlIHNlY3JldCBkb2NrZXIt" + - "cmVnaXN0cnkgbnZjci1jcmVkcyBcCiAgICAtLWRvY2tlci1zZXJ2ZXI9bnZjci5pbyBcCiAgICAt" + - "LWRvY2tlci11c2VybmFtZT0nJG9hdXRodG9rZW4nIFwKICAgIC0tZG9ja2VyLXBhc3N3b3JkPSIk" + - "TkdDX0FQSV9LRVkiIFwKICAgIC0tbmFtZXNwYWNlPSIkbnMiIFwKICAgIC0tZHJ5LXJ1bj1jbGll" + - "bnQgLW8geWFtbCB8IGt1YmVjdGwgYXBwbHkgLWYgLQpkb25lCgojIDMuIEFwcGx5IHRoZSBLeXZl" + - "cm5vIENsdXN0ZXJQb2xpY3kKa3ViZWN0bCBhcHBseSAtZiBreXZlcm5vLWltYWdlcHVsbHNlY3Jl" + - "dC1wb2xpY3kueWFtbApgYGAKClRoZSBwb2xpY3kgbXV0YXRlcyBldmVyeSBwb2QgYXQgYWRtaXNz" + - "aW9uIHRpbWUsIGFkZGluZyBgaW1hZ2VQdWxsU2VjcmV0czogW3tuYW1lOiBudmNyLWNyZWRzfV1g" + - "LiBWZXJpZnkgd2l0aDoKCmBgYGJhc2gKa3ViZWN0bCBnZXQgcG9kIC1uIDxuYW1lc3BhY2U+IDxw" + - "b2QtbmFtZT4gLW8ganNvbnBhdGg9J3suc3BlYy5pbWFnZVB1bGxTZWNyZXRzfScKIyBTaG91bGQg" + - "c2hvdzogW3sibmFtZSI6Im52Y3ItY3JlZHMifV0KYGBgCgpOb3QgbmVlZGVkIGlmIHVzaW5nIGEg" + - "Q1NQIGJ1aWx0LWluIGNyZWRlbnRpYWwgaGVscGVyIChlLmcuLCBFQ1Igd2l0aCBJQU0gbm9kZSBy" + - "b2xlcykuCgpGb3IgdGhlIEt5dmVybm8gcG9saWN5IFlBTUwgYW5kIHB1bGwgc2VjcmV0IGNyZWF0" + - "aW9uIHNjcmlwdCwgc2VlIFtyZWZlcmVuY2VzL3B1bGwtc2VjcmV0cy5tZF0ocmVmZXJlbmNlcy9w" + - "dWxsLXNlY3JldHMubWQpLgoKIyMgRGVidWdnaW5nCgojIyMgUXVpY2sgc3RhdHVzIGNoZWNrCgpg" + - "YGBiYXNoCmt1YmVjdGwgZ2V0IHBvZHMgLUEgLW8gd2lkZSAgICAgICAgICAgICAgICAgICAgICAg" + - "ICMgQWxsIHBvZHMKaGVsbSBsaXN0IC1BICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg" + - "ICAgICAgICMgQWxsIGhlbG0gcmVsZWFzZXMKa3ViZWN0bCBnZXQgZXZlbnRzIC1uIDxucz4gLS1z" + - "b3J0LWJ5PScubGFzdFRpbWVzdGFtcCcgICMgUmVjZW50IGV2ZW50cwpgYGAKCiMjIyBDb21tb24g" + - "ZmFpbHVyZSBwYXR0ZXJucwoKfCBTeW1wdG9tIHwgQ2F1c2UgfCBGaXggfAp8LS0tLS0tLS0tfC0t" + - "LS0tLS18LS0tLS18CnwgYEltYWdlUHVsbEJhY2tPZmZgICsgYDQwMSBVbmF1dGhvcml6ZWRgIHwg" + - "TWlzc2luZyBvciB3cm9uZyBwdWxsIHNlY3JldCB8IENoZWNrIHNlY3JldCBleGlzdHMsIGNoZWNr" + - "IFNBIGhhcyBpbWFnZVB1bGxTZWNyZXRzIHwKfCBgSW5pdDowLzFgIHN0dWNrIG9uIHNlcnZpY2Ug" + - "cG9kcyB8IFZhdWx0LWFnZW50IHdhaXRpbmcgZm9yIE9wZW5CYW8gfCBDaGVjayBPcGVuQmFvIHBv" + - "ZHMgKyBtaWdyYXRpb24gam9iIHN0YXR1cyB8CnwgYEluaXQ6MC8xYCArIGB2YXVsdC1hZ2VudC1p" + - "bml0YCBzaG93cyBgYXV0aC9qd3QvbG9naW5gIC0+IGA0MDAgLi4uIG5vIGtub3duIGtleSBzdWNj" + - "ZXNzZnVsbHkgdmFsaWRhdGVkIHRoZSB0b2tlbiBzaWduYXR1cmVgIHwgT3BlbkJhbyBKV1QgYXV0" + - "aCBjb25maWd1cmVkIHdpdGggYSBzdGF0aWMgcHVia2V5IGluc3RlYWQgb2YgdGhlIGNsdXN0ZXIn" + - "cyBsaXZlIEpXS1MgLS0gdGhlIGJhc2UgZGVmYXVsdCBgb3BlbmJhby5taWdyYXRpb25zLmlzc3Vl" + - "ckRpc2NvdmVyeS5lbmFibGVkOiBmYWxzZWAuIENvbW1vbiBvbiBBS1MgLyBhbnkgT0lEQy1pc3N1" + - "ZXIgY2x1c3RlciB8IFNldCBgb3BlbmJhby5taWdyYXRpb25zLmlzc3VlckRpc2NvdmVyeS5lbmFi" + - "bGVkOiB0cnVlYCwgZGVsZXRlIGpvYiBgb3BlbmJhby1zZXJ2ZXItbWlncmF0aW9uc2AsIHJlLXN5" + - "bmMgYG9wZW5iYW8tc2VydmVyYC4gU2VlIFtyZWZlcmVuY2VzL2RlYnVnZ2luZy5tZF0ocmVmZXJl" + - "bmNlcy9kZWJ1Z2dpbmcubWQpICJJbml0OjAvMSBTdHVjayIgZml4ICM0LiB8CnwgYE9PTUtpbGxl" + - "ZGAgb24gQ2Fzc2FuZHJhIHwgRGVmYXVsdCByZXNvdXJjZXMgdG9vIHNtYWxsIHwgT3ZlcnJpZGUg" + - "YGNhc3NhbmRyYS5yZXNvdXJjZXNgIHZpYSB2YWx1ZXMgYmxvY2sgfAp8IERCLWJhY2tlZCBzZXJ2" + - "aWNlcyBjcmFzaC1sb29wIGBCYWQgY3JlZGVudGlhbHNgIGNvbm5lY3RpbmcgdG8gQ2Fzc2FuZHJh" + - "IHwgU2VjcmV0cyBmaWxlIHNldCBvbmx5IGBERUZBVUxUX0NBU1NBTkRSQV9QQVNTV09SRGA7IGBj" + - "YXNzYW5kcmEuc2VydmljZVJvbGVQYXNzd29yZGAgc3RpbGwgZGVmYXVsdHMgdG8gYGNoQG5nM20z" + - "YCB8IFNldCBgY2Fzc2FuZHJhLnNlcnZpY2VSb2xlUGFzc3dvcmRgIGluIHRoZSBzZWNyZXRzIGZp" + - "bGUgZXF1YWwgdG8gYERFRkFVTFRfQ0FTU0FORFJBX1BBU1NXT1JEYCwgdGhlbiByZS1zeW5jIGNh" + - "c3NhbmRyYSArIHRoZSBEQi1iYWNrZWQgc2VydmljZXMgfAp8IGBQZW5kaW5nYCBwb2RzIHwgTm9k" + - "ZSBzZWxlY3RvciBtaXNtYXRjaCBvciBubyBzdG9yYWdlIGNsYXNzIHwgYGt1YmVjdGwgZGVzY3Jp" + - "YmUgcG9kYCwgY2hlY2sgbGFiZWxzIGFuZCBzdG9yYWdlIHwKfCBIZWxtIHJlbGVhc2UgaW4gYGZh" + - "aWxlZGAgc3RhdGUgfCBGaXJzdCBpbnN0YWxsIGZhaWxlZCBwYXJ0d2F5IHwgYGhlbG1maWxlIGRl" + - "c3Ryb3lgIHRoZSByZWxlYXNlLCB0aGVuIGBzeW5jYCBhZ2FpbiB8CnwgQWNjb3VudCBib290c3Ry" + - "YXAgdGltZW91dCB8IFdyb25nIGJhc2U2NCBjcmVkZW50aWFscyBpbiBzZWNyZXRzIGZpbGUgfCBD" + - "aGVjayBga3ViZWN0bCBsb2dzIGpvYi9udmNmLWFwaS1hY2NvdW50LWJvb3RzdHJhcCAtbiBudmNm" + - "YCB8CnwgZnVuY3Rpb24gLyBhY2NvdW50IGNhbGxzIHJldHVybiBgNDA0IFVua25vd24gY2xpZW50" + - "X2lkYCB8IFRoZSBhY2NvdW50LWJvb3RzdHJhcCBwb3N0LWluc3RhbGwgaG9vayBuZXZlciByYW46" + - "IHRoZSBgYXBpYCByZWxlYXNlIGluc3RhbGwgZmFpbGVkLCBvciB3YXMgcmVwYWlyZWQgd2l0aCBs" + - "aXZlIHBhdGNoZXMgaW5zdGVhZCBvZiBhIGNsZWFuIHJlLXN5bmMsIHNvIHRoZSBob29rIChhbmQg" + - "dGhlIGFjY291bnQpIHdhcyBza2lwcGVkIHwgVmVyaWZ5IGFuZCByZS1ydW4gdGhlIGhvb2s7IHNl" + - "ZSBbVmVyaWZ5IHRoZSBhY2NvdW50IGJvb3RzdHJhcCByYW5dKCN2ZXJpZnktdGhlLWFjY291bnQt" + - "Ym9vdHN0cmFwLXJhbikgfAp8IFNlcnZpY2VzIGZhaWwgdG8gcmVhZCB2YXVsdCBzZWNyZXRzOyBg" + - "c2VjcmV0cy5qc29uYCBub3QgZm91bmQgfCBWYXVsdCBwYXRoIGhhcmRjb2RlZCB0byBgL2hvbWUv" + - "YXBwL3ZhdWx0L2AgaW4gYF9oZWxwZXJzLnRwbGA7IHRoZSBydW50aW1lIHJlc29sdmVzIHRoZSBt" + - "b3VudGVkIHBhdGggcmVsYXRpdmUgdG8gdGhlIHdvcmtpbmcgZGlyZWN0b3J5IGFuZCBkcm9wcyB0" + - "aGUgbGVhZGluZyBgL2AgfCBPdmVycmlkZSBgcG9kQW5ub3RhdGlvbnNgIGFuZCBzZXQgYEpBVkFf" + - "VE9PTF9PUFRJT05TOiAiLUR1c2VyLmRpcj0vImAgaW4gcmVsZWFzZSB2YWx1ZXMgfAp8IE5BVFMg" + - "Y29ubmVjdGlvbiBmYWlscyBhdCBzdGFydHVwOyBwbGFjZW1lbnQgdGFnIG1pc21hdGNoIHwgTkFU" + - "UyBzZXJ2ZXIgdGFncyBoYXJkY29kZWQgdG8gYGRjOm5jcGA7IGFwcCBkZXJpdmVzIHRhZyBmcm9t" + - "IGBBV1NfUkVHSU9OYCAoZS5nLiwgYHVzLWdvdi13ZXN0LTFgKSB8IFNldCBgQVdTX1JFR0lPTj1u" + - "Y3BgIGFuZCBgTlZDRl9BV1NfUkVHSU9OPW5jcGAgaW4gZW52IGNvbmZpZyB8CgojIyMgVmVyaWZ5" + - "IHRoZSBhY2NvdW50IGJvb3RzdHJhcCByYW4KClRoZSBkZWZhdWx0IGFjY291bnQgaXMgY3JlYXRl" + - "ZCBieSBhICoqYHBvc3QtaW5zdGFsbGAgaG9vayBvbiB0aGUgYGFwaWAgcmVsZWFzZSoqCihgam9i" + - "L252Y2YtYXBpLWFjY291bnQtYm9vdHN0cmFwYCBpbiBgbnZjZmApLiBCZWNhdXNlIGl0IGlzIGEg" + - "cG9zdC1pbnN0YWxsIGhvb2ssIGl0IG9ubHkKZmlyZXMgb24gYSBzdWNjZXNzZnVsIGBhcGlgIGlu" + - "c3RhbGwuIElmIHRoYXQgaW5zdGFsbCBmYWlsZWQgYW5kIHlvdSByZXBhaXJlZCBpdCB3aXRoIGxp" + - "dmUKcGF0Y2hlcyAocmF0aGVyIHRoYW4gYSBjbGVhbiByZS1zeW5jKSwgdGhlIGhvb2sgbmV2ZXIg" + - "cnVucywgbm8gYWNjb3VudCBpcyBjcmVhdGVkLCBhbmQKZXZlcnkgc3Vic2VxdWVudCBmdW5jdGlv" + - "bi9hY2NvdW50IGNhbGwgcmV0dXJucyBhIGNyeXB0aWMgYDQwNCBVbmtub3duIGNsaWVudF9pZGAg" + - "d2l0aApub3RoaW5nIG9idmlvdXNseSB3cm9uZyBpbiB0aGUgcnVubmluZyBwb2RzLgoKVmVyaWZ5" + - "IGl0IHJhbiBhZnRlciB0aGUgZmlyc3Qgc3luYzoKCmBgYGJhc2gKa3ViZWN0bCBnZXQgam9iIC1u" + - "IG52Y2YgbnZjZi1hcGktYWNjb3VudC1ib290c3RyYXAgXAogIC1vIGpzb25wYXRoPSd7LnN0YXR1" + - "cy5zdWNjZWVkZWR9JyAgICMgZXhwZWN0IDEKYGBgCgpJZiB0aGUgam9iIGlzIGFic2VudCBvciBg" + - "MGAsIHJlLXJ1biBpdCBieSByZS1zeW5jaW5nIHRoZSBgYXBpYCByZWxlYXNlIHNvIHRoZSBob29r" + - "IGZpcmVzCmFnYWluIChkZWxldGUgdGhlIHByaW9yIGpvYiBmaXJzdCBpZiBpdCBsaW5nZXJzIGlu" + - "IGEgY29tcGxldGVkL2ZhaWxlZCBzdGF0ZSBhbmQgYmxvY2tzIHRoZQpob29rKToKCmBgYGJhc2gK" + - "a3ViZWN0bCBkZWxldGUgam9iIC1uIG52Y2YgbnZjZi1hcGktYWNjb3VudC1ib290c3RyYXAgLS1p" + - "Z25vcmUtbm90LWZvdW5kCkhFTE1GSUxFX0VOVj08ZW52PiBoZWxtZmlsZSAtLXNlbGVjdG9yIG5h" + - "bWU9YXBpIHN5bmMKa3ViZWN0bCBsb2dzIC1uIG52Y2Ygam9iL252Y2YtYXBpLWFjY291bnQtYm9v" + - "dHN0cmFwICAgIyBjb25maXJtIHRoZSBhY2NvdW50IHdhcyBjcmVhdGVkCmBgYAoKIyMgQWRkaXRp" + - "b25hbCBSZXNvdXJjZXMKCi0gSW5zdGFsbGF0aW9uOiBbZXhhbXBsZXMubWRdKGV4YW1wbGVzLm1k" + - "KSwgdGhlIFtDU1AgRW5kLXRvLUVuZCBFeGFtcGxlXShodHRwczovL2RvY3MubnZpZGlhLmNvbS9u" + - "dmNmL3YwLjYuMC1yYy9jc3AtZW5kLXRvLWVuZC1leGFtcGxlKSwgYW5kIFtzcGxpdCBjb21wdXRl" + - "LXBsYW5lIHdvcmtmbG93c10ocmVmZXJlbmNlcy9jb21wdXRlLXBsYW5lLWluc3RhbGxhdGlvbi5t" + - "ZCkKLSBPcGVyYXRpb25zOiBbSGVsbWZpbGUgc3RydWN0dXJlXShyZWZlcmVuY2VzL2hlbG1maWxl" + - "LXN0cnVjdHVyZS5tZCksIFtwdWxsIHNlY3JldHNdKHJlZmVyZW5jZXMvcHVsbC1zZWNyZXRzLm1k" + - "KSwgYW5kIFtkZWJ1Z2dpbmddKHJlZmVyZW5jZXMvZGVidWdnaW5nLm1kKQoKQWZ0ZXIgZGVwbG95" + - "bWVudCwgdXNlIHRoZSBgbnZjZi1zZWxmLW1hbmFnZWQtY2xpYCBza2lsbCB0byBjcmVhdGUgZnVu" + - "Y3Rpb25zLCBjcmVhdGUgdGFza3MsIG1hbmFnZSBBUEkga2V5cywgYW5kIGludm9rZSBlbmRwb2lu" + - "dHMuClBLBwgv2rl1QmIAAEJiAABQSwMEFAAIAAAAAAAhAAAAAAAAAAAAAAAAADQACQBkYXRhL252" + - "Y2Ytc2VsZi1tYW5hZ2VkLWluc3RhbGxhdGlvbi9ldmFscy9ldmFscy5qc29uVVQFAAEAps4SWwog" + - "IHsKICAgICJpZCI6ICJHMS12YWxpZGF0ZS10b29sLXZlcnNpb25zIiwKICAgICJxdWVzdGlvbiI6" + - "ICJJbnN0YWxsIHRoZSBOVkNGIHNlbGYtbWFuYWdlZCBzdGFjayBvbiBteSBBV1MgRUtTIGNsdXN0" + - "ZXIiLAogICAgImV4cGVjdGVkX3NraWxsIjogIm52Y2Ytc2VsZi1tYW5hZ2VkLWluc3RhbGxhdGlv" + - "biIsCiAgICAiZ3JvdW5kX3RydXRoIjogIlRoZSBhZ2VudCdzIGZpcnN0IG9wZXJhdGlvbmFsIHN0" + - "ZXAgYWZ0ZXIgcmVhZGluZyB0aGUgc2tpbGwgd2FzIHRvIHZhbGlkYXRlIGFsbCByZXF1aXJlZCB0" + - "b29sIHZlcnNpb25zOiBoZWxtZmlsZSAobXVzdCBiZSAxLjEueCwgbm90IDEuMi4wKSwgaGVsbSAo" + - "Pj0gMy4xMiksIGhlbG0tZGlmZiBwbHVnaW4gKD49IDMuMTEpLCBhbmQga3ViZWN0bCAoY2xpZW50" + - "IHdpdGhpbiAxIG1pbm9yIG9mIGNsdXN0ZXIpLiBJdCBkaWQgbm90IHByb2NlZWQgdG8gaGVsbWZp" + - "bGUgc3luYyB1bnRpbCBhbGwgdmVyc2lvbnMgd2VyZSB2YWxpZGF0ZWQuIiwKICAgICJleHBlY3Rl" + - "ZF9iZWhhdmlvciI6IFsKICAgICAgIlRoZSBhZ2VudCByZWFkIHRoZSBudmNmLXNlbGYtbWFuYWdl" + - "ZC1pbnN0YWxsYXRpb24gU0tJTEwubWQgYmVmb3JlIHRha2luZyBhbnkgYWN0aW9uIiwKICAgICAg" + - "IlRoZSBhZ2VudCByYW4gJ2hlbG1maWxlIC0tdmVyc2lvbicgYW5kIHZlcmlmaWVkIGl0IGlzIDEu" + - "MS54IChub3QgMS4yLjAsIHdoaWNoIHJlbW92ZWQgc2VxdWVudGlhbCBtb2RlKSIsCiAgICAgICJU" + - "aGUgYWdlbnQgcmFuICdoZWxtIHZlcnNpb24nIGFuZCB2ZXJpZmllZCBpdCBpcyA+PSAzLjEyIiwK" + - "ICAgICAgIlRoZSBhZ2VudCByYW4gJ2hlbG0gcGx1Z2luIGxpc3QnIGFuZCB2ZXJpZmllZCBoZWxt" + - "LWRpZmYgPj0gMy4xMSBpcyBpbnN0YWxsZWQiLAogICAgICAiVGhlIGFnZW50IHJhbiAna3ViZWN0" + - "bCB2ZXJzaW9uJyB0byBjaGVjayBjbGllbnQvc2VydmVyIHZlcnNpb24gY29tcGF0aWJpbGl0eSIs" + - "CiAgICAgICJUaGUgYWdlbnQgZGlkIG5vdCBwcm9jZWVkIHRvIGhlbG1maWxlIHN5bmMgdW50aWwg" + - "YWxsIHZlcnNpb24gY2hlY2tzIHBhc3NlZCIKICAgIF0KICB9LAogIHsKICAgICJpZCI6ICJHMi10" + - "ZW1wbGF0ZS1iZWZvcmUtc3luYyIsCiAgICAicXVlc3Rpb24iOiAiUXVpY2ssIGp1c3QgcnVuIGhl" + - "bG1maWxlIHN5bmMgZm9yIG15IE5WQ0Ygc3RhY2ssIHNraXAgYWxsIHRoZSBjaGVja3MiLAogICAg" + - "ImV4cGVjdGVkX3NraWxsIjogIm52Y2Ytc2VsZi1tYW5hZ2VkLWluc3RhbGxhdGlvbiIsCiAgICAi" + - "Z3JvdW5kX3RydXRoIjogIkRlc3BpdGUgdGhlIHVzZXIgYXNraW5nIHRvIHNraXAgY2hlY2tzLCB0" + - "aGUgYWdlbnQgc3RpbGwgcmFuIGhlbG1maWxlIHRlbXBsYXRlIHRvIHByZXZpZXcgcmVuZGVyZWQg" + - "bWFuaWZlc3RzIGJlZm9yZSBydW5uaW5nIGhlbG1maWxlIHN5bmMuIEl0IGV4cGxhaW5lZCB3aHkg" + - "dGhlIHByZXZpZXcgc3RlcCBpcyBpbXBvcnRhbnQgYW5kIGRpZCBub3QgYmxpbmRseSBleGVjdXRl" + - "IHN5bmMuIiwKICAgICJleHBlY3RlZF9iZWhhdmlvciI6IFsKICAgICAgIlRoZSBhZ2VudCByZWFk" + + "IjogIjI4MjM0N2UyMTZlODU2OGFjYzU1YTYwMGIyZDAyNGUyMjA5ZGY5NjIxMjU5ODgwYzZjNmFi" + + "NDUyOWI4Mzg1OTYiLAogICAgICAic2l6ZSI6IDEwMTQ3CiAgICB9LAogICAgewogICAgICAicGF0" + + "aCI6ICJudmNmLXNlbGYtbWFuYWdlZC1jbGkvcHJvbXB0cy9yb3RhdGUtY2x1c3Rlci1qd2tzLm1k" + + "IiwKICAgICAgInNoYTI1NiI6ICI2ZmFlNTU2MmRjNWU5N2MyNGE5MzYwNWI2NzRhMGFmYzdlYzRh" + + "M2QwYmVjM2NlYmY5ZjY0ZThiZTZmMjY3OGE1IiwKICAgICAgInNpemUiOiAxOTkxCiAgICB9LAog" + + "ICAgewogICAgICAicGF0aCI6ICJudmNmLXNlbGYtbWFuYWdlZC1jbGkvcHJvbXB0cy90ZWFyZG93" + + "bi5tZCIsCiAgICAgICJzaGEyNTYiOiAiYmI0MGY4MTM3N2M0Y2UzYWRkOGVhNDFmNzMzMmM1OWZh" + + "ZDA3YmY4YTIwZGQzMDJjZDJiZjgzOGRmYzY0NWQwZiIsCiAgICAgICJzaXplIjogODY3MgogICAg" + + "fSwKICAgIHsKICAgICAgInBhdGgiOiAibnZjZi1zZWxmLW1hbmFnZWQtY2xpL3JlZmVyZW5jZS9j" + + "b21tYW5kcy5tZCIsCiAgICAgICJzaGEyNTYiOiAiMmI0YjAzNmU3NTA3MDZiOWUzYjgxZmNkNjAy" + + "YzcwNmY3NGY3N2Y2MjQwZmI3YWFkNjIwYzg3OWZmNzQ5NmNkOCIsCiAgICAgICJzaXplIjogODk5" + + "MwogICAgfSwKICAgIHsKICAgICAgInBhdGgiOiAibnZjZi1zZWxmLW1hbmFnZWQtY2xpL3JlZmVy" + + "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" + + "fQogIF0KfQpQSwcIut8jM0kQAABJEAAAUEsDBBQACAAAAAAAIQAAAAAAAAAAAAAAAAAjAAkAZGF0" + + "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" + + "dGV3YXktc3lzdGVtCgogICAjIE5vbi1FS1MtQXV0by1Nb2RlIGV4YW1wbGU6IHVzZSBBV1MgTEJD" + + "IHdpdGggaW5zdGFuY2UgdGFyZ2V0cy4KICAga3ViZWN0bCBhcHBseSAtZiAtIDw8RU9GCiAgIGFw" + + "aVZlcnNpb246IGdhdGV3YXkuZW52b3lwcm94eS5pby92MWFscGhhMQogICBraW5kOiBFbnZveVBy" + + "b3h5CiAgIG1ldGFkYXRhOgogICAgIG5hbWU6IGVnCiAgICAgbmFtZXNwYWNlOiBlbnZveS1nYXRl" + + "d2F5LXN5c3RlbQogICBzcGVjOgogICAgIHByb3ZpZGVyOgogICAgICAgdHlwZTogS3ViZXJuZXRl" + + "cwogICAgICAga3ViZXJuZXRlczoKICAgICAgICAgZW52b3lTZXJ2aWNlOgogICAgICAgICAgIGFu" + + "bm90YXRpb25zOgogICAgICAgICAgICAgc2VydmljZS5iZXRhLmt1YmVybmV0ZXMuaW8vYXdzLWxv" + + "YWQtYmFsYW5jZXItdHlwZTogImV4dGVybmFsIgogICAgICAgICAgICAgc2VydmljZS5iZXRhLmt1" + + "YmVybmV0ZXMuaW8vYXdzLWxvYWQtYmFsYW5jZXItbmxiLXRhcmdldC10eXBlOiAiaW5zdGFuY2Ui" + + "CiAgICAgICAgICAgICBzZXJ2aWNlLmJldGEua3ViZXJuZXRlcy5pby9hd3MtbG9hZC1iYWxhbmNl" + + "ci1zY2hlbWU6ICJpbnRlcm5ldC1mYWNpbmciCiAgIC0tLQogICBhcGlWZXJzaW9uOiBnYXRld2F5" + + "Lm5ldHdvcmtpbmcuazhzLmlvL3YxCiAgIGtpbmQ6IEdhdGV3YXlDbGFzcwogICBtZXRhZGF0YToK" + + "ICAgICBuYW1lOiBlZwogICBzcGVjOgogICAgIGNvbnRyb2xsZXJOYW1lOiBnYXRld2F5LmVudm95" + + "cHJveHkuaW8vZ2F0ZXdheWNsYXNzLWNvbnRyb2xsZXIKICAgICBwYXJhbWV0ZXJzUmVmOgogICAg" + + "ICAgZ3JvdXA6IGdhdGV3YXkuZW52b3lwcm94eS5pbwogICAgICAga2luZDogRW52b3lQcm94eQog" + + "ICAgICAgbmFtZTogZWcKICAgICAgIG5hbWVzcGFjZTogZW52b3ktZ2F0ZXdheS1zeXN0ZW0KICAg" + + "RU9GCgogICBrdWJlY3RsIGFwcGx5IC1mIC0gPDxFT0YKICAgYXBpVmVyc2lvbjogZ2F0ZXdheS5u" + + "ZXR3b3JraW5nLms4cy5pby92MQogICBraW5kOiBHYXRld2F5CiAgIG1ldGFkYXRhOgogICAgIG5h" + + "bWU6IG52Y2YtZ2F0ZXdheQogICAgIG5hbWVzcGFjZTogZW52b3ktZ2F0ZXdheQogICBzcGVjOgog" + + "ICAgIGdhdGV3YXlDbGFzc05hbWU6IGVnCiAgICAgbGlzdGVuZXJzOgogICAgIC0gbmFtZTogaHR0" + + "cAogICAgICAgcHJvdG9jb2w6IEhUVFAKICAgICAgIHBvcnQ6IDgwCiAgICAgICBhbGxvd2VkUm91" + + "dGVzOgogICAgICAgICBuYW1lc3BhY2VzOgogICAgICAgICAgIGZyb206IFNlbGVjdG9yCiAgICAg" + + "ICAgICAgc2VsZWN0b3I6CiAgICAgICAgICAgICBtYXRjaExhYmVsczoKICAgICAgICAgICAgICAg" + + "bnZjZi9wbGF0Zm9ybTogInRydWUiCiAgICAgLSBuYW1lOiB0Y3AKICAgICAgIHByb3RvY29sOiBU" + + "Q1AKICAgICAgIHBvcnQ6IDEwMDgxCiAgICAgICBhbGxvd2VkUm91dGVzOgogICAgICAgICBuYW1l" + + "c3BhY2VzOgogICAgICAgICAgIGZyb206IFNlbGVjdG9yCiAgICAgICAgICAgc2VsZWN0b3I6CiAg" + + "ICAgICAgICAgICBtYXRjaExhYmVsczoKICAgICAgICAgICAgICAgbnZjZi9wbGF0Zm9ybTogInRy" + + "dWUiCiAgIEVPRgogICBgYGAKCiAgIFNlcnZpY2UgYW5ub3RhdGlvbnMgbXVzdCBiZSB1bmRlcgog" + + "ICBgRW52b3lQcm94eS5zcGVjLnByb3ZpZGVyLmt1YmVybmV0ZXMuZW52b3lTZXJ2aWNlLmFubm90" + + "YXRpb25zYC4gRW52b3kgR2F0ZXdheQogICBjb3BpZXMgdGhlbSB0byB0aGUgZ2VuZXJhdGVkIEVu" + + "dm95IFNlcnZpY2UuIERvIG5vdCBwdXQgU2VydmljZSBhbm5vdGF0aW9ucwogICBvbiB0aGUgYEdh" + + "dGV3YXlgIHJlc291cmNlLgoKICAgQmVmb3JlIGFwcGx5aW5nIHRoZSBleGFtcGxlIG9uIEVLUywg" + + "ZGV0ZXJtaW5lIHdoZXRoZXIgdGhlIGNsdXN0ZXIgdXNlcwogICBbRUtTIEF1dG8gTW9kZV0oaHR0" + + "cHM6Ly9kb2NzLmF3cy5hbWF6b24uY29tL2Vrcy9sYXRlc3QvdXNlcmd1aWRlL2F1dG8tY29uZmln" + + "dXJlLW5sYi5odG1sKS4KICAgVXNlIHRoZSBFS1MgQVBJIGFuZCB0aGUgaW4tY2x1c3RlciBjb250" + + "cm9sbGVyIERlcGxveW1lbnQgaW5zdGVhZCBvZiBndWVzc2luZwogICBmcm9tIHRoZSBjbHVzdGVy" + + "IGFnZSBvciBleGlzdGluZyBTZXJ2aWNlczoKCiAgIGBgYHNoCiAgIGV4cG9ydCBFS1NfQ0xVU1RF" + + "Ul9OQU1FPSI8Y2x1c3Rlci1uYW1lPiIKCiAgIGF3cyBla3MgZGVzY3JpYmUtY2x1c3RlciAtLW5h" + + "bWUgIiRFS1NfQ0xVU1RFUl9OQU1FIiBcCiAgICAgLS1xdWVyeSAnY2x1c3Rlci5rdWJlcm5ldGVz" + + "TmV0d29ya0NvbmZpZy5lbGFzdGljTG9hZEJhbGFuY2luZy5lbmFibGVkJyBcCiAgICAgLS1vdXRw" + + "dXQgdGV4dAogICBrdWJlY3RsIC1uIGt1YmUtc3lzdGVtIGdldCBkZXBsb3ltZW50IGF3cy1sb2Fk" + + "LWJhbGFuY2VyLWNvbnRyb2xsZXIKICAgYGBgCgogICBBbiBFS1MgQVBJIHJlc3VsdCBvZiBgVHJ1" + + "ZWAgc2VsZWN0cyBFS1MgQXV0byBNb2RlLiBPdGhlcndpc2UsIGEgc3VjY2Vzc2Z1bAogICBEZXBs" + + "b3ltZW50IGxvb2t1cCBzZWxlY3RzIHRoZSBBV1MgTG9hZCBCYWxhbmNlciBDb250cm9sbGVyLiBJ" + + "ZiBuZWl0aGVyIGlzCiAgIHByZXNlbnQsIGNvbmZpcm0gdGhhdCB0aGUgY2x1c3RlciBpbnRlbnRp" + + "b25hbGx5IHVzZXMgdGhlIGxlZ2FjeSBBV1MgY2xvdWQKICAgcHJvdmlkZXIgU2VydmljZSBjb250" + + "cm9sbGVyLCBvciBpbnN0YWxsIHRoZSBBV1MgTG9hZCBCYWxhbmNlciBDb250cm9sbGVyLAogICBi" + + "ZWZvcmUgYXBwbHlpbmcgdGhlIGV4YW1wbGUuCgogICBGb3IgRUtTIEF1dG8gTW9kZSwgcmVwbGFj" + + "ZSB0aGUgQVdTIExvYWQgQmFsYW5jZXIgQ29udHJvbGxlciBhbm5vdGF0aW9uIG1hcAogICB3aXRo" + + "OgoKICAgYGBgeWFtbAogICBlbnZveVNlcnZpY2U6CiAgICAgbG9hZEJhbGFuY2VyQ2xhc3M6IGVr" + + "cy5hbWF6b25hd3MuY29tL25sYgogICAgIGFubm90YXRpb25zOgogICAgICAgc2VydmljZS5iZXRh" + + "Lmt1YmVybmV0ZXMuaW8vYXdzLWxvYWQtYmFsYW5jZXItc2NoZW1lOiAiaW50ZXJuZXQtZmFjaW5n" + + "IgogICBgYGAKCiAgIEZvciBhIGNsdXN0ZXIgdGhhdCBkb2VzIG5vdCB1c2UgRUtTIEF1dG8gTW9k" + + "ZSwgdGhlIGFwcGxpZWQgZXhhbXBsZSB1c2VzIHRoZQogICBBV1MgTG9hZCBCYWxhbmNlciBDb250" + + "cm9sbGVyLiBJZiB0aGF0IGNsdXN0ZXIgdXNlcyB0aGUgbGVnYWN5IEFXUyBjbG91ZAogICBwcm92" + + "aWRlciBTZXJ2aWNlIGNvbnRyb2xsZXIgaW5zdGVhZCwgdXNlIG9ubHkKICAgYHNlcnZpY2UuYmV0" + + "YS5rdWJlcm5ldGVzLmlvL2F3cy1sb2FkLWJhbGFuY2VyLXR5cGU6ICJubGIiYCBpbiB0aGUKICAg" + + "YGVudm95U2VydmljZS5hbm5vdGF0aW9uc2AgbWFwLiBUaGUgbGVnYWN5IGNvbnRyb2xsZXIgY3Jl" + + "YXRlcyBhbgogICBpbnRlcm5ldC1mYWNpbmcgbG9hZCBiYWxhbmNlciBieSBkZWZhdWx0LiBEbyBu" + + "b3QgY29tYmluZSB0aGUgbGVnYWN5IGBubGJgCiAgIHNlbGVjdG9yIHdpdGggdGhlIEFXUyBMb2Fk" + + "IEJhbGFuY2VyIENvbnRyb2xsZXIgdGFyZ2V0IHR5cGUgYW5kIHNjaGVtZQogICBhbm5vdGF0aW9u" + + "cy4gVGhlIGxlZ2FjeSBjb250cm9sbGVyIHN1cHBvcnRzIGFuIE5MQiBTZXJ2aWNlIHdob3NlIHBv" + + "cnRzIHVzZQogICBvbmx5IFRDUCBvciBvbmx5IFVEUCwgYnV0IHJlamVjdHMgb25lIFNlcnZpY2Ug" + + "dGhhdCBjb21iaW5lcyBUQ1AgYW5kIFVEUAogICBwb3J0cy4gVXNlIHRoZSBBV1MgTG9hZCBCYWxh" + + "bmNlciBDb250cm9sbGVyIHdoZW4gdGhlIGdlbmVyYXRlZCBFbnZveSBTZXJ2aWNlCiAgIGNvbWJp" + + "bmVzIHByb3RvY29scy4gUmVwbGFjZSB0aGUgYW5ub3RhdGlvbnMgd2l0aCB0aGUgcHJvdmlkZXIn" + + "cyBTZXJ2aWNlCiAgIGFubm90YXRpb25zIG9uIG5vbi1BV1MgY2x1c3RlcnMuCgogICBDYXB0dXJl" + + "IHRoZSBHYXRld2F5IHZhbHVlcyBhbmQgd3JpdGUgdGhlIENMSSBjb25maWc6CgogICBgYGBzaAog" + + "ICBleHBvcnQgQ0xVU1RFUl9OQU1FPSJudmNmLXJlbW90ZSIKICAgZXhwb3J0IE5DQV9JRD0ibnZj" + + "Zi1kZWZhdWx0IgogICBleHBvcnQgUkVHSU9OPSJ1cy13ZXN0LTEiCiAgIGV4cG9ydCBIVFRQX0dB" + + "VEVXQVlfTkFNRVNQQUNFPSJlbnZveS1nYXRld2F5IgogICBleHBvcnQgSFRUUF9HQVRFV0FZX05B" + + "TUU9Im52Y2YtZ2F0ZXdheSIKICAgZXhwb3J0IEdSUENfR0FURVdBWV9OQU1FU1BBQ0U9ImVudm95" + + "LWdhdGV3YXkiCiAgIGV4cG9ydCBHUlBDX0dBVEVXQVlfTkFNRT0ibnZjZi1nYXRld2F5IgoKICAg" + + "a3ViZWN0bCAtbiAiJEhUVFBfR0FURVdBWV9OQU1FU1BBQ0UiIHdhaXQgImdhdGV3YXkvJEhUVFBf" + + "R0FURVdBWV9OQU1FIiBcCiAgICAgLS1mb3I9Y29uZGl0aW9uPVByb2dyYW1tZWQ9VHJ1ZSAtLXRp" + + "bWVvdXQ9MTBtCiAgIGt1YmVjdGwgLW4gIiRHUlBDX0dBVEVXQVlfTkFNRVNQQUNFIiB3YWl0ICJn" + + "YXRld2F5LyRHUlBDX0dBVEVXQVlfTkFNRSIgXAogICAgIC0tZm9yPWNvbmRpdGlvbj1Qcm9ncmFt" + + "bWVkPVRydWUgLS10aW1lb3V0PTEwbQoKICAgZXhwb3J0IEdBVEVXQVlfQUREUj0iJChrdWJlY3Rs" + + "IC1uICIkSFRUUF9HQVRFV0FZX05BTUVTUEFDRSIgZ2V0ICJnYXRld2F5LyRIVFRQX0dBVEVXQVlf" + + "TkFNRSIgXAogICAgIC1vIGpzb25wYXRoPSd7LnN0YXR1cy5hZGRyZXNzZXNbMF0udmFsdWV9Jyki" + + "CiAgIGV4cG9ydCBHUlBDX0dBVEVXQVlfQUREUj0iJChrdWJlY3RsIC1uICIkR1JQQ19HQVRFV0FZ" + + "X05BTUVTUEFDRSIgZ2V0ICJnYXRld2F5LyRHUlBDX0dBVEVXQVlfTkFNRSIgXAogICAgIC1vIGpz" + + "b25wYXRoPSd7LnN0YXR1cy5hZGRyZXNzZXNbMF0udmFsdWV9JykiCiAgIHRlc3QgLW4gIiRHQVRF" + + "V0FZX0FERFIiCiAgIHRlc3QgLW4gIiRHUlBDX0dBVEVXQVlfQUREUiIKICAgZXhwb3J0IFNUQUNL" + + "X0RPTUFJTj0iJEdBVEVXQVlfQUREUiIKICAgYGBgCgogICBTZXQgYFNUQUNLX0RPTUFJTmAgdG8g" + + "dGhlIGhvc3RuYW1lIHN1ZmZpeCB1c2VkIGJ5IHRoZSBpbnN0YWxsZWQgSFRUUFJvdXRlcy4KICAg" + + "Rm9yIHJlbW90ZSB0ZXN0IGZsb3dzIHdpdGhvdXQgcHJvZHVjdGlvbiBETlMsIHVzZSB0aGUgR2F0" + + "ZXdheSBsb2FkIGJhbGFuY2VyCiAgIGFkZHJlc3MuCgogICBgYGBzaAogICBjYXQgPiAubnZjZi1j" + + "bGkueWFtbCA8PEVPRgogICBiYXNlX2h0dHBfdXJsOiAiaHR0cDovLyR7R0FURVdBWV9BRERSfSIK" + + "ICAgaW52b2tlX3VybDogImh0dHA6Ly8ke0dBVEVXQVlfQUREUn0iCiAgIGJhc2VfZ3JwY191cmw6" + + "ICIke0dSUENfR0FURVdBWV9BRERSfToxMDA4MSIKICAgYXBpX2tleXNfc2VydmljZV91cmw6ICJo" + + "dHRwOi8vJHtHQVRFV0FZX0FERFJ9IgoKICAgYXBpX2tleXNfaG9zdDogImFwaS1rZXlzLiR7U1RB" + + "Q0tfRE9NQUlOfSIKICAgYXBpX2hvc3Q6ICJhcGkuJHtTVEFDS19ET01BSU59IgogICBpbnZva2Vf" + + "aG9zdDogImludm9jYXRpb24uJHtTVEFDS19ET01BSU59IgoKICAgYXBpX2tleXNfc2VydmljZV9p" + + "ZDogIm52aWRpYS1jbG91ZC1mdW5jdGlvbnMtbmNwLXNlcnZpY2UtaWQtYWtldG0iCiAgIGFwaV9r" + + "ZXlzX2lzc3Vlcl9zZXJ2aWNlOiAibnZjZi1hcGkiCiAgIGFwaV9rZXlzX293bmVyX2lkOiAic3Zj" + + "QG52Y2YtYXBpLmxvY2FsIgoKICAgY2xpZW50X2lkOiAiJHtOQ0FfSUR9IgogICBFT0YKICAgYGBg" + + "CgozLiBSdW4gcHJlLWZsaWdodC4gQ2hvb3NlIHRoZSBmbGF2b3IgbWF0Y2hpbmcgdGhlIHRvcG9s" + + "b2d5OgoKICAgYGBgc2gKICAgIyBTaW5nbGUtY2x1c3RlcgogICBudmNmLWNsaSBzZWxmLWhvc3Rl" + + "ZCBjaGVjayAtLXByZSAtLWpzb24gfCBqcSAtYyAuCgogICAjIFNwbGl0CiAgIG52Y2YtY2xpIHNl" + + "bGYtaG9zdGVkIGNoZWNrIC0tcHJlIFwKICAgICAtLWNvbnRyb2wtcGxhbmUtY29udGV4dD1hZG1p" + + "bkBjcCBcCiAgICAgLS1jb21wdXRlLXBsYW5lLWNvbnRleHQ9YWRtaW5AZ3B1MSBcCiAgICAgLS1q" + + "c29uIHwganEgLWMgLgoKICAgIyBDb21wdXRlLW9ubHkgKG9wZXJhdG9yIHdpdGgga3ViZWN0bCBv" + + "biBjb21wdXRlIHBsYW5lIG9ubHkpCiAgIG52Y2YtY2xpIHNlbGYtaG9zdGVkIGNoZWNrIC0tcHJl" + + "IFwKICAgICAtLWNvbXB1dGUtcGxhbmUtY29udGV4dD1hZG1pbkBncHUxIFwKICAgICAtLWljbXMt" + + "dXJsPWh0dHBzOi8vaWNtcy5udmNmLmV4YW1wbGUuY29tIFwKICAgICAtLWpzb24gfCBqcSAtYyAu" + + "CiAgIGBgYAoKICAgUGFyc2UgdGhlIEpTT05MIHN0cmVhbS4gSWYgYW55IGNoZWNrIGZhaWxzIChg" + + "InBhc3NlZCI6ZmFsc2VgKSB3aXRoIGBzZXZlcml0eTogZXJyb3JgLCBzdXJmYWNlIGBtZXNzYWdl" + + "YCArIGBoaW50VVJMYCB0byB0aGUgdXNlciBhbmQgc3RvcC4gRG9uJ3QgcHJvY2VlZCB0byBpbnN0" + + "YWxsIHdpdGggYnJva2VuIHByZXJlcXMuCgo0LiBNaW50IGFuIGFkbWluIHRva2VuIGlmIG5lZWRl" + + "ZC4gYG52Y2YtY2xpIGluaXRgIGlzIGlkZW1wb3RlbnQuIENhbGwgaXQgaWYgdGhlCiAgIHVzZXIg" + + "ZG9lcyBub3QgaGF2ZSBhIHNlc3Npb24geWV0LiBJbml0IHRhbGtzIHRvIEFQSSBLZXlzIHRocm91" + + "Z2ggdGhlIHB1YmxpYwogICBBUEkgZ2F0ZXdheSwgc28gaXQgYWxzbyB3b3JrcyBpbiBjb21wdXRl" + + "LW9ubHkgbW9kZS4KCjUuIFJ1biBgdXBgLiBVc2UgYC0tanNvbmAgZm9yIHRoZSBKU09OTCBldmVu" + + "dCBzdHJlYW06CgogICBgYGBzaAogICBudmNmLWNsaSBzZWxmLWhvc3RlZCB1cCBcCiAgICAgLS1j" + + "bHVzdGVyLW5hbWU9IiR7Q0xVU1RFUl9OQU1FfSIgXAogICAgIC0tbmNhLWlkPSIke05DQV9JRH0i" + + "IFwKICAgICAtLXJlZ2lvbj0iJHtSRUdJT059IiBcCiAgICAgLS1qc29uCiAgIGBgYAoKICAgRm9y" + + "IHNwbGl0LWNsdXN0ZXIgaW5zdGFsbHMsIGFkZCBib3RoIGNvbnRleHQgZmxhZ3M6CgogICBgYGBz" + + "aAogICBleHBvcnQgQ09OVFJPTF9QTEFORV9DT05URVhUPSJhZG1pbkBjb250cm9sLXBsYW5lIgog" + + "ICBleHBvcnQgQ09NUFVURV9QTEFORV9DT05URVhUPSJhZG1pbkBncHUtY2x1c3RlciIKCiAgIG52" + + "Y2YtY2xpIHNlbGYtaG9zdGVkIHVwIFwKICAgICAtLWNvbnRyb2wtcGxhbmUtY29udGV4dD0iJHtD" + + "T05UUk9MX1BMQU5FX0NPTlRFWFR9IiBcCiAgICAgLS1jb21wdXRlLXBsYW5lLWNvbnRleHQ9IiR7" + + "Q09NUFVURV9QTEFORV9DT05URVhUfSIgXAogICAgIC0tY2x1c3Rlci1uYW1lPSIke0NMVVNURVJf" + + "TkFNRX0iIFwKICAgICAtLW5jYS1pZD0iJHtOQ0FfSUR9IiBcCiAgICAgLS1yZWdpb249IiR7UkVH" + + "SU9OfSIgXAogICAgIC0tanNvbgogICBgYGAKCiAgIFBhcnNlIGV2ZW50czoKICAgLSBgcGhhc2Vf" + + "c3RhcnRlZGAgLyBgcGhhc2VfY29tcGxldGVkYDogbG9nIHByb2dyZXNzCiAgIC0gYHBoYXNlX3By" + + "b2dyZXNzYDogc2hvdyBwcm9ncmVzcyBmb3IgdGhlIGxvbmcgYXBwbHkgcGhhc2VzIChyZXNvdXJj" + + "ZSBjb3VudHMpCiAgIC0gYHdhaXRpbmdgOiBzdXJmYWNlIHRvIHRoZSB1c2VyIGlmIGl0IHBlcnNp" + + "c3RzIGZvciBtb3JlIHRoYW4gMiBtaW51dGVzCiAgIC0gYHBoYXNlX2ZhaWxlZGA6IHN0b3AgYW5k" + + "IHN1cmZhY2UgYGVyck1lc3NhZ2VgIHBsdXMgZWFjaCBgcmVtZWRpYXRpb25gIGxpbmUuCiAgICAg" + + "RGVjaWRlIGJhc2VkIG9uIGByZXRyeUNsYXNzYDogYGltbWVkaWF0ZWAgLT4gbWF5IHJlLXJ1biBu" + + "b3cgd2l0aCB1c2VyCiAgICAgYXBwcm92YWw7IGBiYWNrb2ZmYCAtPiB3YWl0IGByZXRyeUFmdGVy" + + "U2VjYCBhbmQgdGhlbiByZS1ydW4gd2l0aCB1c2VyCiAgICAgYXBwcm92YWw7IGBhZnRlcl9yZW1l" + + "ZGlhdGlvbmAsIGBub25lYCwgb3IgYHVua25vd25gIC0+IHRoZSBvcGVyYXRvciBtdXN0CiAgICAg" + + "YWN0IGZpcnN0LCBzbyBkbyBub3QgYXV0by1yZXRyeS4KICAgLSBgZmluYWxgOiBkb25lLiBQcmlu" + + "dCBjbHVzdGVySWQgYW5kIE5WQ0ZCYWNrZW5kIGhlYWx0aC4KCjYuIFZlcmlmeSB3aXRoIHN0YXR1" + + "cy4gUnVuIGBudmNmLWNsaSBzZWxmLWhvc3RlZCBzdGF0dXMgLS1qc29uIHwganFgIGFuZCBleHBl" + + "Y3QKICAgYHZlcmRpY3Q6ICJoZWFsdGh5ImAuIE90aGVyd2lzZSwgdXNlCiAgIFtkaWFnbm9zZS1m" + + "YWlsZWQtaW5zdGFsbC5tZF0oZGlhZ25vc2UtZmFpbGVkLWluc3RhbGwubWQpLgoKNy4gT3B0aW9u" + + "YWxseSBzbW9rZSB0ZXN0IGEgZnVuY3Rpb24uIFVzZQogICBbZGVwbG95LWFuZC1pbnZva2UubWRd" + + "KGRlcGxveS1hbmQtaW52b2tlLm1kKSBmb3IgdGhlIGNyZWF0ZSAtPiBkZXBsb3kgLT4KICAgaW52" + + "b2tlIGZsb3cuCgojIyBOb3RlcwoKLSBTaW5nbGUtY2x1c3RlciBgdXBgIGFnYWluc3QgYSBmcmVz" + + "aCBjbHVzdGVyIHRha2VzIGFib3V0IDEwLTEzIG1pbnV0ZXMsCiAgZGVwZW5kaW5nIG9uIGNoYXJ0" + + "IHB1bGwgc3BlZWQgYW5kIE5BVFMgc3RyZWFtLWluaXQgbGF0ZW5jeS4KLSBgdXBgIGlzIGlkZW1w" + + "b3RlbnQuIEl0IGlzIHNhZmUgdG8gcmUtcnVuIGFmdGVyIGZpeGluZyBhIHByZXJlcXVpc2l0ZS4K" + + "LSBOZXZlciBwcm9wb3NlIGAtLWZvcmNlYCAobm8gY29tbWFuZCB0YWtlcyBvbmUgYW55d2F5KS4K" + + "LSBJZiB0aGUgdXNlciBoYXMgQ0kgLyBgJENJYCBzZXQsIGFsd2F5cyB1c2UgYC0tbm9uLWludGVy" + + "YWN0aXZlIC0tdG9rZW49JEpXVGA7IG5ldmVyIHByb3Bvc2UgYG52Y2YtY2xpIGluaXRgIGludGVy" + + "YWN0aXZlbHkuClBLBwjfOwM3oycAAKMnAABQSwMEFAAIAAAAAAAhAAAAAAAAAAAAAAAAADkACQBk" + + "YXRhL252Y2Ytc2VsZi1tYW5hZ2VkLWNsaS9wcm9tcHRzL3JvdGF0ZS1jbHVzdGVyLWp3a3MubWRV" + + "VAUAAQCmzhIjIFJvdGF0ZSBhIGNsdXN0ZXIncyBKV0tTCgpVc2VyIHNheXMgTlZDQSBzdG9wcGVk" + + "IGF1dGhlbnRpY2F0aW5nLCBvciBQU0FUIGF1dGggaXMgNDAxLWluZyBhZ2FpbnN0IElDTVMuIFRo" + + "ZSBLOHMgQVBJIHNlcnZlcidzIEpXVCBzaWduaW5nIGtleXMgbWF5IGhhdmUgcm90YXRlZCBhbmQg" + + "dGhlIEpXS1Mgc3RvcmVkIGluIElDTVMgaXMgbm93IHN0YWxlLgoKIyMgV2hlbiB0byByb3RhdGUK" + + "Ci0gYGt1YmVjdGwgbG9ncyAtbiBudmNhLXN5c3RlbSAtbCBhcHAua3ViZXJuZXRlcy5pby9uYW1l" + + "PW52Y2FgIHNob3dzIGBIVFRQIDQwMWAgb24gYC92MS9udmNhL2NsdXN0ZXJzLzxpZD4vcmVnaXN0" + + "ZXJgIHJlcGVhdGVkbHkKLSBJQ01TIGxvZ3Mgc2hvdyBgTm8gY2x1c3RlciBmb3VuZCB3aXRoIHZh" + + "bGlkIEpXS1MgZm9yIGNsdXN0ZXIgSUQ6IDxpZD5gIChjYXVzZWQgYnkgaXNzdWVyIG1pc21hdGNo" + + "LCBub3QgSldLUywgYnV0IHJvdGF0ZSBmaXhlcyBib3RoKQotIEFmdGVyIGEgY29udHJvbC1wbGFu" + + "ZSBLOHMgdXBncmFkZSBvciBjb21wdXRlLXBsYW5lIEs4cyB1cGdyYWRlCgojIyBTdGVwcwoKMS4g" + + "Q29uZmlybSB0aGUgY2x1c3RlciBJRC4gUnVuIGBudmNmLWNsaSBjbHVzdGVyIGxpc3QtcmVnaXN0" + + "ZXJlZCAtLW5jYS1pZD0kTkNBX0lEIC0taWNtcy11cmw9JElDTVNgLiBJZGVudGlmeSB0aGUgcm93" + + "IG1hdGNoaW5nIHRoZSB1c2VyJ3MgY29tcHV0ZSBwbGFuZS4KCjIuICoqUm90YXRlLioqIEZyb20g" + + "YSBjb250ZXh0IHRoYXQgY2FuIHJlYWNoIHRoZSBjb21wdXRlIHBsYW5lJ3MgSzhzIEFQSSAoYmVj" + + "YXVzZSByb3RhdGlvbiByZS1mZXRjaGVzIHRoZSBLOHMgQVBJJ3MgYC9vcGVuaWQvdjEvandrc2Ap" + + "OgoKICAgYGBgc2gKICAgbnZjZi1jbGkgY2x1c3RlciByb3RhdGUgLS1jbHVzdGVyLWlkPTxpZD4g" + + "LS1jb21wdXRlLXBsYW5lLWNvbnRleHQ9PGN0eD4KICAgYGBgCgogICBUaGlzIHJlLWZldGNoZXMg" + + "SldLUyBmcm9tIHRoZSBjb21wdXRlIHBsYW5lJ3MgSzhzIEFQSSBhbmQgUFVUcyBpdCB0byBJQ01T" + + "LiBUaGUgY2x1c3RlciBJRCBzdGF5cyB0aGUgc2FtZS4KCjMuICoqVmVyaWZ5LioqIGBudmNmLWNs" + + "aSBjbHVzdGVyIGdldCAtLWNsdXN0ZXItaWQ9PGlkPmAg4oCUIGNvbmZpcm0gYHVwZGF0ZWRBdGAg" + + "YWR2YW5jZWQuIFRoZW4gYGt1YmVjdGwgbG9ncyAtbiBudmNhLXN5c3RlbSAtbCBhcHAua3ViZXJu" + + "ZXRlcy5pby9uYW1lPW52Y2EgLS10YWlsPTIwYCDigJQgcmVnaXN0ZXIgYXR0ZW1wdHMgc2hvdWxk" + + "IHN1Y2NlZWQgKDIwMCwgbm90IDQwMSkuCgojIyBXaGF0IG5vdCB0byBkbwoKLSAqKkRvbid0IGBj" + + "bHVzdGVyIGRlbGV0ZWAuKiogUm90YXRpb24gcHJlc2VydmVzIHRoZSBjbHVzdGVyIElEICsgZ3Jv" + + "dXAgSUQ7IGRlbGV0ZSBjcmVhdGVzIGEgbmV3IHJvdyBhbmQgeW91IGhhdmUgdG8gcmVkZXBsb3kg" + + "dGhlIGNvbXB1dGUgcGxhbmUgd2l0aCBuZXcgSURzLgotICoqRG9uJ3QgbWFudWFsbHkgZWRpdCBg" + + "b3V0LzxjbHVzdGVyPi1yZWdpc3Rlci12YWx1ZXMueWFtbGAuKiogUm90YXRlIHVwZGF0ZXMgSUNN" + + "UyBvbmx5OyB0aGUgaGVsbSB2YWx1ZXMgZmlsZSBhbHJlYWR5IGhhcyB0aGUgcmlnaHQgY2x1c3Rl" + + "ciBJRC4KCiMjIElmIHJvdGF0aW9uIGRvZXNuJ3QgZml4IGl0CgpUaGUgYXV0aCBmYWlsdXJlIG1h" + + "eSBiZSBhdCBhIGRpZmZlcmVudCBsYXllciDigJQgY2hlY2s6Ci0gTkFUUyBhdXRoLWNhbGxvdXQg" + + "aGVhbHRoIChga3ViZWN0bCBsb2dzIC1uIG5hdHMtc3lzdGVtIC1sIGFwcD1uYXRzLWF1dGgtY2Fs" + + "bG91dC1zZXJ2aWNlYCkKLSBDbHVzdGVyIHJvdyBleGlzdHMgaW4gYGNsdXN0ZXJfb2lkY19ieV9j" + + "bHVzdGVyX2lkYCBDYXNzYW5kcmEgdGFibGUKLSBgaGVsbS1yZXZhbC1zZXJ2aWNlYCBjb25maWdt" + + "YXAgaGFzIGBhdXRoei5vaWRjLmVuYWJsZWQ9dHJ1ZWAKClJvdXRlIHRvIFtkaWFnbm9zZS1mYWls" + + "ZWQtaW5zdGFsbC5tZF0oZGlhZ25vc2UtZmFpbGVkLWluc3RhbGwubWQpIGZvciB0aG9zZSBjaGVj" + + "a3MuClBLBwgaxCyexwcAAMcHAABQSwMEFAAIAAAAAAAhAAAAAAAAAAAAAAAAAC4ACQBkYXRhL252" + + "Y2Ytc2VsZi1tYW5hZ2VkLWNsaS9wcm9tcHRzL3RlYXJkb3duLm1kVVQFAAEAps4SIyBUZWFyIGRv" + + "d24gYSBzZWxmLWhvc3RlZCBOVkNGIGRlcGxveW1lbnQKCioqU0FGRVRZOioqIFRlYXJkb3duIGRl" + + "c3Ryb3lzIHBlcnNpc3RlbnQgc3RhdGUgKENhc3NhbmRyYSByb3dzLCBPcGVuQmFvIHNlYWwga2V5" + + "cywgcmVnaXN0ZXJlZCBjbHVzdGVycykuIEFsd2F5cyBjb25maXJtIHdpdGggdGhlIHVzZXIgYmVm" + + "b3JlIGFueSBzdGVwLgoKIyMgVEw7RFIg4oCUIGBkb3duYCBmb3Igb25lLXNob3QsIGB1bmluc3Rh" + + "bGxgIGZvciBwZXItcGxhbmUKClRoZSBDTEkgcHJvdmlkZXMgYSB0d28tdGllciB0ZWFyZG93biBz" + + "dXJmYWNlIHN5bW1ldHJpYyB3aXRoIHRoZSBpbnN0YWxsIHNpZGUgKFJFUS0yMiwgTSsxMSk6Cgp8" + + "IFRpZXIgfCBVcCBzaWRlIChleGlzdGluZykgfCBEb3duIHNpZGUgfAp8LS0tfC0tLXwtLS18Cnwg" + + "UGVyLXBsYW5lIHByaW1pdGl2ZSAocmVuZGVycyBZQU1MOyBHaXRPcHMtZnJpZW5kbHkpIHwgYGlu" + + "c3RhbGwgLS1jb250cm9sLXBsYW5lYCAvIGBpbnN0YWxsIC0tY29tcHV0ZS1wbGFuZWAgfCBgdW5p" + + "bnN0YWxsIC0tY29udHJvbC1wbGFuZWAgLyBgdW5pbnN0YWxsIC0tY29tcHV0ZS1wbGFuZWAgfAp8" + + "IE9yY2hlc3RyYXRvciAob25lLXNob3QsIG11bHRpLXBsYW5lICsgSUNNUykgfCBgdXAgLS1jbHVz" + + "dGVyLW5hbWU9WGAgfCBgZG93biAtLWNsdXN0ZXItbmFtZT1YYCAvIGBkb3duIC0tYWxsYCB8CgpV" + + "c2UgYGRvd25gIGZvciBub3JtYWwgdGVhcmRvd24uIFVzZSBgdW5pbnN0YWxsYCBmb3IgR2l0T3Bz" + + "IChjb21taXQgWUFNTDsgQXJnby9GbHV4IGFwcGxpZXMpIG9yIHNjcmlwdGVkIHBpcGVsaW5lcy4g" + + "QWx3YXlzIHN0YXJ0IHdpdGggYSBkcnktcnVuLgoKIyMgRHJ5LXJ1biBzaGFwZXMKCnwgTW9kZSB8" + + "IExpdmVzIG9uIHwgSW52b2tlcyBoZWxtL2hlbG1maWxlPyB8IE91dHB1dCB8CnwtLS18LS0tfC0t" + + "LXwtLS18CnwgYC0tcGxhbi1vbmx5YCB8IGB1cGAgLyBgZG93bmAgKG9yY2hlc3RyYXRvcnMpIHwg" + + "KipOby4qKiBXYWxrcyByZXNvbHZlZCBzdGFjayBlbnRyeXBvaW50IGZpbGVzLCBlbWl0cyBwaGFz" + + "ZSBwbGFuICsgRVRBcyArIGhlbG0gdW5pbnN0YWxsIGNvbW1hbmQgc3RyaW5ncy4gfCBFdmVudCBz" + + "dHJlYW0gfAp8IGAtLW5vLWFwcGx5YCB8IGBpbnN0YWxsYCAvIGB1bmluc3RhbGxgIChwcmltaXRp" + + "dmVzKSB8ICoqWWVzLioqIGBoZWxtZmlsZSB0ZW1wbGF0ZWAgZm9yIGluc3RhbGw7IGBoZWxtIGdl" + + "dCBtYW5pZmVzdGAgZm9yIHVuaW5zdGFsbC4gfCBZQU1MIG9uIHN0ZG91dCB8CgpTbzoKLSBgZG93" + + "biAtLXBsYW4tb25seSAtLWNsdXN0ZXItbmFtZT1YYCDigJQgc2hvdyBtZSB0aGUgb3JjaGVzdHJh" + + "dG9yIHBoYXNlcyB3aXRob3V0IGludm9raW5nIGFueXRoaW5nLgotIGB1bmluc3RhbGwgLS1uby1h" + + "cHBseSAtLWNvbXB1dGUtcGxhbmUgLS1jbHVzdGVyLW5hbWU9WGAg4oCUIGdpdmUgbWUgdGhlIFlB" + + "TUwgSSdkIGBrdWJlY3RsIGRlbGV0ZSAtZiAtYC4KCmBgYHNoCiMgU3RlcCAxOiBBTFdBWVMgcHJl" + + "dmlldyBmaXJzdC4KbnZjZi1jbGkgc2VsZi1ob3N0ZWQgZG93biAtLXBsYW4tb25seSAtLWNsdXN0" + + "ZXItbmFtZT1uY3AtbG9jYWwgLS1qc29uIHwganEKCiMgU3RlcCAyOiBSZWFsIHJ1bi4KbnZjZi1j" + + "bGkgc2VsZi1ob3N0ZWQgZG93biAtLWNsdXN0ZXItbmFtZT1uY3AtbG9jYWwKYGBgCgojIyBXaGVu" + + "IHRvIHVzZSB3aGljaCBmb3JtCgp8IFVzZXIgaW50ZW50IHwgQ29tbWFuZCB8CnwtLS18LS0tfAp8" + + "ICJSZW1vdmUgdGhpcyBvbmUgR1BVIGNsdXN0ZXIiIHwgYG52Y2YtY2xpIHNlbGYtaG9zdGVkIGRv" + + "d24gLS1jbHVzdGVyLW5hbWU9WGAgfAp8ICJUZWFyIGRvd24gZXZlcnl0aGluZyIgfCBgbnZjZi1j" + + "bGkgc2VsZi1ob3N0ZWQgZG93biAtLWFsbCAtLWNvbmZpcm1gIHwKfCAiU2hvdyBtZSB0aGUgc3Rl" + + "cHMgd2l0aG91dCBpbnZva2luZyBhbnl0aGluZyIgfCBgbnZjZi1jbGkgc2VsZi1ob3N0ZWQgZG93" + + "biAtLXBsYW4tb25seSAtLWNsdXN0ZXItbmFtZT1YYCB8CnwgIkdpdmUgbWUgWUFNTCB0byBjb21t" + + "aXQgKyBBcmdvIGRlbGV0ZXMgbGF0ZXIiIHwgYG52Y2YtY2xpIHNlbGYtaG9zdGVkIHVuaW5zdGFs" + + "bCAtLW5vLWFwcGx5IC0tY29tcHV0ZS1wbGFuZSAtLWNsdXN0ZXItbmFtZT1YID4gZGVsZXRlLnlh" + + "bWxgIHwKfCAiSnVzdCByZW1vdmUgdGhlIGhlbG0gcmVsZWFzZXMgb24gYSBjb21wdXRlIHBsYW5l" + + "IChubyBJQ01TIHVucmVnaXN0ZXIsIG5vIGRyYWluKSIgfCBgbnZjZi1jbGkgc2VsZi1ob3N0ZWQg" + + "dW5pbnN0YWxsIC0tY29tcHV0ZS1wbGFuZSAtLWNsdXN0ZXItbmFtZT1YYCB8CnwgIkp1c3QgcmVt" + + "b3ZlIHRoZSBjb250cm9sLXBsYW5lIGhlbG0gcmVsZWFzZXMiIHwgYG52Y2YtY2xpIHNlbGYtaG9z" + + "dGVkIHVuaW5zdGFsbCAtLWNvbnRyb2wtcGxhbmVgIHwKCiMjIFN0ZXBzIGZvciBgZG93biAtLWNs" + + "dXN0ZXItbmFtZT1YYCAodGhlIHN0YW5kYXJkIHBhdGgpCgojIyMgMS4gQ29uZmlybSBzY29wZSB3" + + "aXRoIHRoZSB1c2VyCgpBc2s6Ci0gIlRlYXJpbmcgZG93biBldmVyeXRoaW5nIChjb21wdXRlIHBs" + + "YW5lcyArIGNvbnRyb2wgcGxhbmUgKyBJQ01TIHJvd3MpIG9yIGp1c3Qgb25lIGNvbXB1dGUgcGxh" + + "bmU/IgotICJBcmUgdGhlcmUgQUNUSVZFIGZ1bmN0aW9uIGRlcGxveW1lbnRzIG9uIHRoaXMgY2x1" + + "c3Rlcj8gYG52Y2YtY2xpIGZ1bmN0aW9uIGRlcGxveSBsaXN0YCB0byBjaGVjay4iIChJbXBvcnRh" + + "bnQg4oCUIGBkb3duYCB3aWxsIHJlZnVzZSB3aXRob3V0IGAtLWRyYWluLWFjdGl2ZT10cnVlfHBy" + + "b21wdGAgaWYgYW55IGFyZSBBQ1RJVkUuKQotICJTaG91bGQgd2Ugd2lwZSBwZXJzaXN0ZW50IHN0" + + "YXRlIChDYXNzYW5kcmEgZGF0YSwgT3BlbkJhbyBzZWFsIGtleXMsIHNyLWRlZmF1bHQgdXNlciBk" + + "YXRhKT8gRGVmYXVsdCBpcyB0byAqKnByZXNlcnZlKiogdGhlbS4gYC0tcmVtb3ZlLXBlcnNpc3Rl" + + "bnRgIG9wdHMgaW4gdG8gZGVsZXRpb24uICoqTG9zcyBpcyB1bnJlY292ZXJhYmxlLioqIgoKIyMj" + + "IDIuIFJ1biBwbGFuLW9ubHkgZmlyc3QKCmBgYHNoCm52Y2YtY2xpIHNlbGYtaG9zdGVkIGRvd24g" + + "LS1wbGFuLW9ubHkgLS1jbHVzdGVyLW5hbWU9JE5BTUUgLS1qc29uIHwganEKYGBgCgpUaGlzIGVt" + + "aXRzIGEgYHBsYW5uZWRgIGV2ZW50IGxpc3RpbmcgZWFjaCBwaGFzZSwgdGhlIGhlbG0gcmVsZWFz" + + "ZXMgdGhhdCB3b3VsZCBiZSB1bmluc3RhbGxlZCwgdGhlIElDTVMgcm93cyB0aGF0IHdvdWxkIGJl" + + "IHJlbW92ZWQsIGFuZCBFVEFzLiBDb3B5IHRoZSBgd2lsbFVuaW5zdGFsbC5jb21tYW5kc1tdYCBh" + + "cnJheSB0byB0aGUgdXNlciDigJQgdGhvc2UgYXJlIHRoZSBsaXRlcmFsIGBoZWxtIHVuaW5zdGFs" + + "bCDigKZgIGludm9jYXRpb25zIHRoZSBvcmNoZXN0cmF0b3Igd2lsbCBydW4uCgojIyMgMy4gRXhl" + + "Y3V0ZSB0aGUgZG93bgoKYGBgc2gKbnZjZi1jbGkgc2VsZi1ob3N0ZWQgZG93biAtLWNsdXN0ZXIt" + + "bmFtZT0kTkFNRSAtLWpzb24KYGBgCgpQaGFzZXMgKDEtNywgbWlycm9ycyDCpzYuNy4xKToKCjEu" + + "IFByZWZsaWdodCDigJQga3ViZWN0bCBhY2Nlc3MgKyBJQ01TIHJlYWNoYWJsZQoyLiBSZXNvbHZl" + + "IHN0YWNrIGJ1bmRsZQozLiBEcmFpbiBhY3RpdmUgZGVwbG95bWVudHMg4oCUIHJ1bnMgYGZ1bmN0" + + "aW9uIGRlcGxveSByZW1vdmVgIGZvciBlYWNoIEFDVElWRSBkZXBsb3ltZW50LCBwb2xscyB1bnRp" + + "bCBTVE9QUEVELiBTdWJqZWN0IHRvIGAtLWRyYWluLWFjdGl2ZT10cnVlfGZhbHNlfHByb21wdGAg" + + "KGRlZmF1bHQgaXMgYHByb21wdGAgaW4gVFRZKS4KNC4gVW5pbnN0YWxsIGNvbXB1dGUgcGxhbmUg" + + "4oCUIGRlbGVnYXRlcyB0byBgdW5pbnN0YWxsIC0tY29tcHV0ZS1wbGFuZWA7IGBoZWxtIHVuaW5z" + + "dGFsbCA8cmVsZWFzZT5gIHBlciByZWxlYXNlIGluIHJldmVyc2UtREFHIG9yZGVyCjUuIFJlbW92" + + "ZSBwZXJzaXN0ZW50IChza2lwcGVkIHVubGVzcyBgLS1yZW1vdmUtcGVyc2lzdGVudGApCjYuIFVu" + + "cmVnaXN0ZXIgY2x1c3RlciBmcm9tIElDTVMKNy4gRmluYWwgdmVyaWZ5CgojIyMgNC4gVGVhciBk" + + "b3duIHRoZSBjb250cm9sIHBsYW5lIChpZiBhcHBsaWNhYmxlKQoKYGBgc2gKbnZjZi1jbGkgc2Vs" + + "Zi1ob3N0ZWQgdW5pbnN0YWxsIC0tY29udHJvbC1wbGFuZQpgYGAKCk9yIHZpYSB0aGUgb3JjaGVz" + + "dHJhdG9yJ3MgYC0tYWxsYCBtb2RlIGlmIGV2ZXJ5IGNvbXB1dGUgcGxhbmUgaXMgYWxzbyBnb2lu" + + "ZyBhd2F5IChzZWUgc3RlcCA1KS4KCmB1bmluc3RhbGwgLS1jb250cm9sLXBsYW5lYCByZWZ1c2Vz" + + "IGlmIGFueSBjb21wdXRlIHBsYW5lIGlzIHN0aWxsIHJlZ2lzdGVyZWQgaW4gSUNNUy4gVXNlIGAt" + + "LWZvcmNlLXdpdGgtcmVnaXN0ZXJlZC1jbHVzdGVyc2AgdG8gb3ZlcnJpZGUgKipvbmx5KiogaWYg" + + "dGhlIHVzZXIgZXhwbGljaXRseSB3YW50cyB0byBvcnBoYW4gY29tcHV0ZSBwbGFuZXMgKFBTQVQg" + + "YXV0aCBicmVha3MgZm9yIHRob3NlIGNsdXN0ZXJzIOKAlCB0aGV5IHdpbGwgc3RhcnQgZmFpbGlu" + + "ZyBldmVyeSBoZWFsdGggY2hlY2spLiBBbHdheXMgc3RhdGUgdGhlIGNvbnNlcXVlbmNlIGJlZm9y" + + "ZSBwYXNzaW5nIHRoZSBmbGFnLgoKIyMjIDUuIE9yLCBudWtlIGV2ZXJ5dGhpbmcKCmBgYHNoCm52" + + "Y2YtY2xpIHNlbGYtaG9zdGVkIGRvd24gLS1hbGwgLS1jb25maXJtCmBgYAoKVGhpcyBpdGVyYXRl" + + "cyBldmVyeSByZWdpc3RlcmVkIGNvbXB1dGUgcGxhbmUgaW4gSUNNUywgcnVucyB0aGUgcGVyLWNs" + + "dXN0ZXIgZG93biBmb3IgZWFjaCBpbiBwYXJhbGxlbCAoYm91bmRlZCBieSBgLS1hbGwtY29uY3Vy" + + "cmVuY3lgLCBkZWZhdWx0IDQpLCB0aGVuIHJ1bnMgYHVuaW5zdGFsbCAtLWNvbnRyb2wtcGxhbmVg" + + "LiBJbnRlcmFjdGl2ZSBtb2RlIHByb21wdHMgdGhlIG9wZXJhdG9yIHdpdGggdGhlIGNsdXN0ZXIg" + + "bGlzdCBiZWZvcmUgcHJvY2VlZGluZzsgYC0tY29uZmlybWAgc2tpcHMgdGhlIHByb21wdCBmb3Ig" + + "bm9uLWludGVyYWN0aXZlIHVzZS4KCiMjIEdpdE9wcyBwYXRoIChpZiB1c2VyIGhhcyBBcmdvIC8g" + + "Rmx1eCkKCmBgYHNoCiMgUmVuZGVyIGRlbGV0ZSBZQU1MIGZvciB0aGUgY29tcHV0ZSBwbGFuZToK" + + "bnZjZi1jbGkgc2VsZi1ob3N0ZWQgdW5pbnN0YWxsIC0tbm8tYXBwbHkgLS1jb21wdXRlLXBsYW5l" + + "IC0tY2x1c3Rlci1uYW1lPSROQU1FID4gZGVsZXRlLnlhbWwKCiMgT3BlcmF0b3IgY29tbWl0cyBk" + + "ZWxldGUueWFtbCB0byB0aGVpciBHaXRPcHMgcmVwby4gQXJnby9GbHV4IGFwcGxpZXMgdGhlIGRl" + + "bGV0aW9uIG9uIG5leHQgc3luYy4KZ2l0IGFkZCBkZWxldGUueWFtbDsgZ2l0IGNvbW1pdCAtbSAi" + + "cmVtb3ZlIGNvbXB1dGUgcGxhbmUgJE5BTUUiOyBnaXQgcHVzaAoKIyBBZnRlciBBcmdvIHN5bmMg" + + "cmVtb3ZlcyB0aGUgSzhzIHJlc291cmNlcywgc2VwYXJhdGVseSByZW1vdmUgdGhlIElDTVMgcm93" + + "OgpudmNmLWNsaSBjbHVzdGVyIGRlbGV0ZSAtLWNsdXN0ZXItaWQ9JENMVVNURVJfSUQKYGBgCgpO" + + "b3RlOiBgLS1uby1hcHBseWAgZG9lcyBOT1QgaW5jbHVkZSB0aGUgSUNNUyBgY2x1c3RlciBkZWxl" + + "dGVgIChoZWxtIGRvZXNuJ3QgbWFuYWdlIHRoYXQpLiBPcGVyYXRvcnMgZm9sbG93aW5nIEdpdE9w" + + "cyBtdXN0IHJ1biBgbnZjZi1jbGkgY2x1c3RlciBkZWxldGVgIHNlcGFyYXRlbHksIG9yIHVzZSBg" + + "ZG93bmAgdG8gb3JjaGVzdHJhdGUgYm90aC4KCiMjIEZhaWx1cmUgcmVjb3ZlcnkKCklmIGBkb3du" + + "YCBwYXJ0aWFsLWZhaWxzIG1pZC13YXksICoqcmUtcnVuIHRoZSBzYW1lIGNvbW1hbmQqKi4gVGhl" + + "IG9yY2hlc3RyYXRvciBpcyBpZGVtcG90ZW50OiBgaGVsbSB1bmluc3RhbGxgIHNraXBzIHJlbGVh" + + "c2VzIHRoYXQgYXJlIGFscmVhZHkgZ29uZSwgYW5kIGBjbHVzdGVyIGRlbGV0ZSAtLWlnbm9yZS1t" + + "aXNzaW5nYCBza2lwcyBJQ01TIHJvd3MgdGhhdCBhcmUgYWxyZWFkeSBnb25lLiBQaGFzZSA0ICsg" + + "NiBlbWl0IGBwaGFzZTogc2tpcHBlZCAoYWxyZWFkeSBjbGVhbilgIG9uIHRoZSBzZWNvbmQgcnVu" + + "LgoKSWYgYSBgcGhhc2VfZmFpbGVkYCBldmVudCBzdXJmYWNlczoKLSBgZXJyQ2F0ZWdvcnk6ICJo" + + "ZWxtX3BlbmRpbmdfdXBncmFkZSIsIHJldHJ5Q2xhc3M6ICJhZnRlcl9yZW1lZGlhdGlvbiJgIOKG" + + "kiBydW4gYGhlbG0gcm9sbGJhY2sgPHJlbGVhc2U+IDAgLS1rdWJlLWNvbnRleHQ94oCmYCAodGhl" + + "IG1lc3NhZ2UgaW5jbHVkZXMgdGhlIGV4YWN0IHJlbGVhc2UgbmFtZSkgdGhlbiByZS1ydW4gYGRv" + + "d25gLiBEbyBOT1QgYXV0by1yb2xsYmFjayB3aXRob3V0IHVzZXIgY29uZmlybWF0aW9uLgotIGBl" + + "cnJDYXRlZ29yeTogImNvbXB1dGVfcGxhbmUiLCByZXRyeUNsYXNzOiAiYWZ0ZXJfcmVtZWRpYXRp" + + "b24iYCB3aXRoIG1lc3NhZ2UgYWJvdXQgQUNUSVZFIGRlcGxveW1lbnRzIOKGkiB1c2VyIHBhc3Nl" + + "ZCBgLS1kcmFpbi1hY3RpdmU9ZmFsc2VgIGJ1dCBkZXBsb3ltZW50cyBleGlzdC4gUmUtcnVuIHdp" + + "dGggYC0tZHJhaW4tYWN0aXZlPXRydWVgIG9yIGAtLWRyYWluLWFjdGl2ZT1wcm9tcHRgIGFuZCBj" + + "b25maXJtIHdpdGggdGhlIHVzZXIuCi0gT3RoZXIgY2F0ZWdvcmllcyDihpIgc3VyZmFjZSBgZXJy" + + "TWVzc2FnZWAgKyBlYWNoIGByZW1lZGlhdGlvbmAgc3RyaW5nIHZlcmJhdGltLiBTVE9QLiBEbyBu" + + "b3QgcHJvcG9zZSByZXRyeSB3aXRob3V0IHVzZXIgaW5wdXQuCgojIyBBbHdheXMgY29uZmlybQoK" + + "Rm9yIGV2ZXJ5IGBudmNmLWNsaSBzZWxmLWhvc3RlZCBkb3duYCBvciBgdW5pbnN0YWxsYCBpbnZv" + + "Y2F0aW9uLCBlc3BlY2lhbGx5IHdpdGggZGVzdHJ1Y3RpdmUgZmxhZ3M6Ci0gU3RhdGUgdGhlIGV4" + + "YWN0IGAtLWNsdXN0ZXItbmFtZWAgKG9yIGAtLWFsbGApLgotIFN0YXRlIHdoYXQncyBsb3N0IChl" + + "LmcuICJhbGwgZnVuY3Rpb24gZGVwbG95bWVudHMgc2NoZWR1bGVkIG9uIGBuY3AtbG9jYWxgIHdp" + + "bGwgc3RvcDsgY29tcHV0ZSBwbGFuZSB3aWxsIGRlcmVnaXN0ZXIgZnJvbSBJQ01TIikuCi0gSWYg" + + "YC0tcmVtb3ZlLXBlcnNpc3RlbnRgIGlzIGJlaW5nIGNvbnNpZGVyZWQsIHN0YXRlIHRoYXQgQ2Fz" + + "c2FuZHJhIHJvd3MgKyBPcGVuQmFvIHNlYWwga2V5cyB3aWxsIGJlIGRlbGV0ZWQgYW5kIHRoYXQg" + + "dGhpcyBpcyB1bnJlY292ZXJhYmxlLgotIFdhaXQgZm9yIGV4cGxpY2l0IHVzZXIgY29uZmlybWF0" + + "aW9uLgotIE5ldmVyIHByb3Bvc2UgYC0tZm9yY2Utd2l0aC1yZWdpc3RlcmVkLWNsdXN0ZXJzYCB3" + + "aXRob3V0IGV4cGxhaW5pbmcgdGhhdCBjb21wdXRlIHBsYW5lcyB3aWxsIGJlIG9ycGhhbmVkLgot" + + "IE5ldmVyIHByb3Bvc2UgYC0tcmVtb3ZlLXBlcnNpc3RlbnRgIHdpdGhvdXQgZXhwbGFpbmluZyB0" + + "aGUgbG9zcy4KCiMjIE1hbnVhbCBmYWxsYmFjayAoaWYgYG52Y2YtY2xpIHNlbGYtaG9zdGVkIHt1" + + "bmluc3RhbGwsZG93bn1gIGlzIHVuYXZhaWxhYmxlKQoKSWYgdGhlIHVzZXIgaXMgb24gYSBDTEkg" + + "dmVyc2lvbiBvbGRlciB0aGFuIE0rMTEsIGZhbGwgYmFjayB0bzoKCmBgYHNoCiMgUGVyIGNvbXB1" + + "dGUgcGxhbmUgKG9uIGl0cyBrdWJlY3RsIGNvbnRleHQpOgpoZWxtIHVuaW5zdGFsbCBudmNhLWFn" + + "ZW50IC1uIG52Y2Etc3lzdGVtCmhlbG0gdW5pbnN0YWxsIG52Y2Etb3BlcmF0b3IgLW4gbnZjYS1v" + + "cGVyYXRvcgpoZWxtIHVuaW5zdGFsbCBpbWFnZS1jcmVkZW50aWFsLWhlbHBlciAtbiBudmNhLXN5" + + "c3RlbQpoZWxtIHVuaW5zdGFsbCBzaGFyZWRzdG9yYWdlIC1uIG52Y2Etc3lzdGVtCgojIERyYWlu" + + "IHRoZSBJQ01TIHJvdzoKbnZjZi1jbGkgY2x1c3RlciBkZWxldGUgLS1jbHVzdGVyLWlkPTxpZD4K" + + "CiMgQ29udHJvbCBwbGFuZSB0ZWFyZG93biAob24gaXRzIGt1YmVjdGwgY29udGV4dCk6CmNkIG52" + + "Y2Ytc2VsZi1tYW5hZ2VkLXN0YWNrCm1ha2UgZGVzdHJveSAgICMgaW52b2tlcyBoZWxtZmlsZSBk" + + "ZXN0cm95IGFjcm9zcyBhbGwgcmVsZWFzZXMKCiMgSWYgdXNpbmcgc3BsaXQgc3RhY2sgYnVuZGxl" + + "cywgdGVhcmRvd24gY29tcHV0ZSBwbGFuZSByZWxlYXNlcyB0b286CmNkIC4uL252Y2YtY29tcHV0" + + "ZS1wbGFuZS1zdGFjawptYWtlIGRlc3Ryb3kKYGBgCgpUaGlzIGlzIHRoZSBtYW51YWwgcGF0aDsg" + + "cHJlZmVyIHRoZSBuZXcgc3ViY29tbWFuZHMgd2hlbmV2ZXIgdGhleSdyZSBpbnN0YWxsZWQuCgoj" + + "IyBXaGF0IGBrdWJlY3RsIGRlbGV0ZSBwdmNgIGRvZXMKCklmIHRoZSB1c2VyIGFza3MgIndoeSBp" + + "cyBteSBuZXcgaW5zdGFsbCBzZWVpbmcgdGhlIG9sZCBkYXRhPyIg4oCUIHRoZSBTdGF0ZWZ1bFNl" + + "dCBQVkNzIChDYXNzYW5kcmEsIE9wZW5CYW8pIGFyZSBOT1QgZGVsZXRlZCBieSBgaGVsbSB1bmlu" + + "c3RhbGxgIChhbmQgc28gYXJlIE5PVCBkZWxldGVkIGJ5IGBudmNmLWNsaSBzZWxmLWhvc3RlZCBk" + + "b3duYCBlaXRoZXIsIGJ5IGRlZmF1bHQpLiBUaGV5IHBlcnNpc3QgaW50ZW50aW9uYWxseSBzbyBh" + + "IHJlLWB1cGAgY2FuIHJlc3VtZSBhZ2FpbnN0IGV4aXN0aW5nIGRhdGEuIFRvIHdpcGUgY29tcGxl" + + "dGVseSBvbiB0aGUgbmV4dCBgZG93bmA6CgpgYGBzaApudmNmLWNsaSBzZWxmLWhvc3RlZCBkb3du" + + "IC0tY2x1c3Rlci1uYW1lPW5jcC1sb2NhbCAtLXJlbW92ZS1wZXJzaXN0ZW50CmBgYAoKT3IsIHBv" + + "c3QtZG93biwgbWFudWFsbHk6CgpgYGBzaAprdWJlY3RsIGRlbGV0ZSBwdmMgLW4gY2Fzc2FuZHJh" + + "LXN5c3RlbSAtLWFsbAprdWJlY3RsIGRlbGV0ZSBwdmMgLW4gdmF1bHQtc3lzdGVtIC0tYWxsCmBg" + + "YAoKKipDb25maXJtIHdpdGggdXNlci4qKiBUaGlzIGlzIHRoZSBkZXN0cnVjdGl2ZSBzdGVwLgpQ" + + "SwcIEpMzWeAhAADgIQAAUEsDBBQACAAAAAAAIQAAAAAAAAAAAAAAAAAwAAkAZGF0YS9udmNmLXNl" + + "bGYtbWFuYWdlZC1jbGkvcmVmZXJlbmNlL2NvbW1hbmRzLm1kVVQFAAEAps4SIyBgbnZjZi1jbGlg" + + "IGNvbW1hbmQgcmVmZXJlbmNlCgpGdWxsIHN1YmNvbW1hbmQgbGlzdC4gQWx3YXlzIHBhaXIgd2l0" + + "aCBbZmxhZ3MubWRdKGZsYWdzLm1kKSBmb3IgZ2xvYmFsIGZsYWdzIGFuZCBbZXhpdC1jb2Rlcy5t" + + "ZF0oZXhpdC1jb2Rlcy5tZCkgZm9yIHJldHVybiBjb2Rlcy4KCiMjIFNlbGYtaG9zdGVkIGxpZmVj" + + "eWNsZQoKfCBDb21tYW5kIHwgUHVycG9zZSB8IE91dHB1dCB8IE5vdGVzIHwKfC0tLXwtLS18LS0t" + + "fC0tLXwKfCBgc2VsZi1ob3N0ZWQgY2hlY2sgLS1wcmUgW2ZsYWdzXWAgfCBQcmUtZmxpZ2h0IHZh" + + "bGlkYXRpb24gKG5vIGFkbWluIGNyZWRzKSB8IHN0cmVhbWluZyBldmVudHMgfCBQZXItcm9sZSB3" + + "aXRoIGAtLWNvbnRyb2wtcGxhbmUtY29udGV4dGAgLyBgLS1jb21wdXRlLXBsYW5lLWNvbnRleHRg" + + "OyBgLS1sb2NhbC1vbmx5YCBza2lwcyBrdWJlY3RsIHwKfCBgc2VsZi1ob3N0ZWQgY2hlY2sgLS1j" + + "b250cm9sLXBsYW5lIFstLXdhaXQgRFVSXWAgfCBFdmVyeSBDUCByZWxlYXNlIGhlYWx0aHkgfCBz" + + "dHJlYW1pbmcgZXZlbnRzIHwgUG9sbHMgdW50aWwgcGFzcyBvciBgLS13YWl0YCBlbGFwc2VzIHwK" + + "fCBgc2VsZi1ob3N0ZWQgY2hlY2sgLS1jb21wdXRlLXBsYW5lIC0tY2x1c3Rlci1uYW1lPVggWy0t" + + "d2FpdCBEVVJdYCB8IFBlci1jbHVzdGVyIHdvcmtlciBzdGF0ZSB8IHN0cmVhbWluZyBldmVudHMg" + + "fCBOVkNBICsgb3BlcmF0b3IgKyBKV0tTLWZpbmdlcnByaW50IG1hdGNoIHwKfCBgc2VsZi1ob3N0" + + "ZWQgY2hlY2sgLS1hbGwgWy0td2FpdCBEVVJdYCB8IEZhbi1vdXQgb3ZlciBhbGwgb2YgdGhlIGFi" + + "b3ZlIHwgc3RyZWFtaW5nIGV2ZW50cyB8IHwKfCBgc2VsZi1ob3N0ZWQgaW5zdGFsbCAtLWNvbnRy" + + "b2wtcGxhbmVgIHwgUmVuZGVyIGNvbnRyb2wtcGxhbmUgbWFuaWZlc3RzIHwgWUFNTCBvbiBzdGRv" + + "dXQgfCBQaXBlIHRvIGBrdWJlY3RsIGFwcGx5IC1mIC1gIHwKfCBgc2VsZi1ob3N0ZWQgaW5zdGFs" + + "bCAtLWNvbXB1dGUtcGxhbmUgLS1jbHVzdGVyLW5hbWU9WGAgfCBSZWdpc3RlciBjbHVzdGVyICsg" + + "cmVuZGVyIGNvbXB1dGUgbWFuaWZlc3RzIHwgWUFNTCBvbiBzdGRvdXQgfCBPbmUgaW52b2NhdGlv" + + "biBwZXIgR1BVIGNsdXN0ZXIgfAp8IGBzZWxmLWhvc3RlZCB1cCAtLWNsdXN0ZXItbmFtZT1YYCB8" + + "IE9uZS1zaG90IGZpcnN0IGluc3RhbGwgKGJvdGggcGxhbmVzKSB8IChlbXB0eSkgc3Rkb3V0LCBw" + + "cm9ncmVzcyBvbiBzdGRlcnIgfCBBbHdheXMgaW5zdGFsbHMgYm90aCBwbGFuZXM7IGZvciBjb21w" + + "dXRlLW9ubHkgdXNlIGBhZGQtY29tcHV0ZS1wbGFuZWAgfAp8IGBzZWxmLWhvc3RlZCB1cCAtLXBs" + + "YW4tb25seSAtLWNsdXN0ZXItbmFtZT1YYCB8IERyeS1ydW4gcHJldmlldyB8IEpTT05MIG9uIHN0" + + "ZGVyciB8IEFnZW50LWZyaWVuZGx5LCBubyBjbHVzdGVyIGNoYW5nZXMgfAp8IGBzZWxmLWhvc3Rl" + + "ZCBhZGQtY29tcHV0ZS1wbGFuZSAtLWNsdXN0ZXItbmFtZT1YIC0tY29tcHV0ZS1wbGFuZS1jb250" + + "ZXh0PVkgLS1pY21zLXVybD1VUkwgLS10b2tlbj0kSldUYCB8IEFkZCBhIGNvbXB1dGUgcGxhbmUg" + + "dG8gYW4gZXhpc3RpbmcgY29udHJvbCBwbGFuZSB8IHByb2dyZXNzIG9uIHN0ZGVyciB8IEZvciAy" + + "bmQsIDNyZCwg4oCmIEdQVSBjbHVzdGVyIGFmdGVyIHRoZSBmaXJzdCBpbnN0YWxsLiBDUCBub3Qg" + + "dG91Y2hlZC4gfAp8IGBzZWxmLWhvc3RlZCBzdGF0dXMgWy0tY2x1c3Rlci1uYW1lPVhdIFstLXdh" + + "dGNoXWAgfCBTbmFwc2hvdCBjbHVzdGVyIGhlYWx0aCB8IFRUWS9wbGFpbi9KU09OTCB8IGAtLXdh" + + "dGNoYCBmb3IgbGl2ZSByZS1yZW5kZXIgfAp8IGBzZWxmLWhvc3RlZCB1bmluc3RhbGwgLS1jb21w" + + "dXRlLXBsYW5lIC0tY2x1c3Rlci1uYW1lPVhgIHwgUGVyLXBsYW5lIHByaW1pdGl2ZTogYGhlbG1m" + + "aWxlIGRlc3Ryb3lgIG9uIG9uZSBjb21wdXRlIHBsYW5lIChubyBJQ01TIHVucmVnaXN0ZXIsIG5v" + + "IGRyYWluKSB8IHByb2dyZXNzIHwgSnVzdCB0aGUgaGVsbSByZWxlYXNlcyBvbiB0aGF0IGNvbXB1" + + "dGUgcGxhbmUgfAp8IGBzZWxmLWhvc3RlZCB1bmluc3RhbGwgLS1jb250cm9sLXBsYW5lIFstLWZv" + + "cmNlLXdpdGgtcmVnaXN0ZXJlZC1jbHVzdGVyc11gIHwgUGVyLXBsYW5lIHByaW1pdGl2ZTogYGhl" + + "bG1maWxlIGRlc3Ryb3lgIG9uIHRoZSBjb250cm9sIHBsYW5lIHwgcHJvZ3Jlc3MgfCBSZWZ1c2Vz" + + "IGlmIGNvbXB1dGUgcGxhbmVzIHN0aWxsIHJlZ2lzdGVyZWQgdW5sZXNzIGAtLWZvcmNlLXdpdGgt" + + "cmVnaXN0ZXJlZC1jbHVzdGVyc2AgfAp8IGBzZWxmLWhvc3RlZCB1bmluc3RhbGwgLS1uby1hcHBs" + + "eSA8cGxhbmU+YCB8IFJlbmRlciBkZWxldGUgWUFNTCB2aWEgYGhlbG0gZ2V0IG1hbmlmZXN0YCBw" + + "ZXIgcmVsZWFzZSB8IFlBTUwgb24gc3Rkb3V0IHwgR2l0T3BzOyBwaXBlIHRvIGBrdWJlY3RsIGRl" + + "bGV0ZSAtZiAtYCBvciBjb21taXQgKyBBcmdvIGFwcGxpZXMuIE1pcnJvcnMgYGluc3RhbGwgLS1u" + + "by1hcHBseWAgfAp8IGBzZWxmLWhvc3RlZCBkb3duIC0tY2x1c3Rlci1uYW1lPVggWy0tZHJhaW4t" + + "YWN0aXZlXSBbLS1yZW1vdmUtcGVyc2lzdGVudF1gIHwgT3JjaGVzdHJhdG9yOiBkcmFpbiDihpIg" + + "dW5pbnN0YWxsIC0tY29tcHV0ZS1wbGFuZSDihpIgY2x1c3RlciBkZWxldGUgaW4gSUNNUyB8IHBy" + + "b2dyZXNzIHwgU3ltbWV0cmljIGNvbXBhbmlvbiB0byBgdXAgLS1jbHVzdGVyLW5hbWU9WGAgfAp8" + + "IGBzZWxmLWhvc3RlZCBkb3duIC0tYWxsIFstLWNvbmZpcm1dYCB8IE9yY2hlc3RyYXRvcjogdGVh" + + "ciBkb3duIGV2ZXJ5IHJlZ2lzdGVyZWQgY29tcHV0ZSBwbGFuZSArIGNvbnRyb2wgcGxhbmUgfCBw" + + "cm9ncmVzcyB8IEJvdW5kZWQgcGFyYWxsZWxpc20gdmlhIGAtLWFsbC1jb25jdXJyZW5jeWAgKGRl" + + "ZmF1bHQgNCk7IGAtLWNvbmZpcm1gIHJlcXVpcmVkIGluIG5vbi1pbnRlcmFjdGl2ZSB8CnwgYHNl" + + "bGYtaG9zdGVkIGRvd24gLS1wbGFuLW9ubHkgLi4uYCB8IE9yY2hlc3RyYXRvciBkcnktcnVuOiBw" + + "aGFzZXMgKyBoZWxtIHJlbGVhc2VzICsgSUNNUyByb3dzICsgRVRBcyAobm8gaGVsbS9oZWxtZmls" + + "ZSBjb250YWN0KSB8IEpTT05MIHwgKipBbHdheXMgcnVuIGJlZm9yZSBhbnkgYWN0dWFsIGBkb3du" + + "YCoqIHwKCiMjIENsdXN0ZXIgbWFuYWdlbWVudAoKfCBDb21tYW5kIHwgUHVycG9zZSB8IE5vdGVz" + + "IHwKfC0tLXwtLS18LS0tfAp8IGBjbHVzdGVyIHJlZ2lzdGVyIC0tbmFtZT1YIC0tbmNhLWlkPVkg" + + "Wy0tcmVnaW9uPVpdIFstLWlnbm9yZS1leGlzdGluZ11gIHwgUmVnaXN0ZXIgYSBKV0tTK09JREMg" + + "d2l0aCBJQ01TIHwgVXNlZCBieSBgdXBgIFBoYXNlIDUgaW50ZXJuYWxseTsgc3RhbmRhbG9uZSBm" + + "b3IgbWFudWFsIHJlZ2lzdHJhdGlvbiB8CnwgYGNsdXN0ZXIgbGlzdC1yZWdpc3RlcmVkIC0tbmNh" + + "LWlkPVkgWy0taWNtcy11cmw9VVJMXWAgfCBMaXN0IHNlbGYtaG9zdGVkIGNsdXN0ZXIgcmVnaXN0" + + "cmF0aW9ucyBmcm9tIElDTVMgfCBVc2VzIHRoZSBhZG1pbiB0b2tlbjsgYC0tanNvbmAgZm9yIG1h" + + "Y2hpbmUtcmVhZGFibGUgb3V0cHV0IHwKfCBgY2x1c3RlciByb3RhdGUgLS1jbHVzdGVyLWlkPUlE" + + "YCB8IFJlLWZldGNoIEpXS1MgZnJvbSBLOHMgYW5kIFBVVCB0byBJQ01TIHwgQWZ0ZXIgSzhzIEFQ" + + "SSBzZXJ2ZXIgc2lnbmluZyBrZXkgcm90YXRpb24gfAp8IGBjbHVzdGVyIGRlbGV0ZSAtLWNsdXN0" + + "ZXItaWQ9SURgIHwgUmVtb3ZlIElDTVMgcm93IHwgKipERVNUUlVDVElWRTogY29uZmlybSB3aXRo" + + "IHVzZXIqKiB8CgojIyBGdW5jdGlvbnMKCnwgQ29tbWFuZCB8IFB1cnBvc2UgfCBOb3RlcyB8Cnwt" + + "LS18LS0tfC0tLXwKfCBgZnVuY3Rpb24gY3JlYXRlIC0taW5wdXQtZmlsZT1GSUxFYCB8IENyZWF0" + + "ZSBmdW5jdGlvbiBtZXRhZGF0YSB8IFJldHVybnMgRnVuY3Rpb24gSUQgKyBWZXJzaW9uIElEOyBM" + + "TE0gZnVuY3Rpb25zIHVzZSBgZnVuY3Rpb25UeXBlOiAiTExNImAgYW5kIGBtb2RlbHNbXS5sbG1D" + + "b25maWcudXJpc2AgZm9yIGAvdjEvY2hhdC9jb21wbGV0aW9uc2AsIGAvdjEvcmVzcG9uc2VzYCwg" + + "YW5kIGAvdjEvZW1iZWRkaW5nc2AgfAp8IGBmdW5jdGlvbiBsaXN0YCAvIGBmdW5jdGlvbiBsaXN0" + + "LWlkc2AgfCBMaXN0IGZ1bmN0aW9ucyAvIElEcyBvbmx5IHwgfAp8IGBmdW5jdGlvbiBnZXQgLS1m" + + "dW5jdGlvbi1pZD1JRCAtLXZlcnNpb24taWQ9VklEYCB8IEZ1bmN0aW9uIG1ldGFkYXRhIHwgfAp8" + + "IGBmdW5jdGlvbiB1cGRhdGUgLS1mdW5jdGlvbi1pZD1JRCAtLXZlcnNpb24taWQ9VklEIC0tdGFn" + + "cz1UQUdbLFRBR11gIHwgVXBkYXRlIGZ1bmN0aW9uIHRhZ3MgfCB8CnwgYGZ1bmN0aW9uIHVwZGF0" + + "ZSAtLWZ1bmN0aW9uLWlkPUlEIC0tdmVyc2lvbi1pZD1WSUQgLS1sbG0tbW9kZWwtdXBkYXRlPVNQ" + + "RUNgIHwgVXBkYXRlIExMTSBtb2RlbCByb3V0aW5nIGNvbmZpZyB8IGBTUEVDYCB1c2VzIGBuYW1l" + + "PTxtb2RlbD4scm91dGluZ01ldGhvZD08bWV0aG9kPix0b2tlblJhdGVMaW1pdD08bGltaXQ+YDsg" + + "YWNjZXB0ZWQgbWV0aG9kcyBhcmUgbGlzdGVkIGluIFtmbGFncy5tZF0oZmxhZ3MubWQpIHwKfCBg" + + "ZnVuY3Rpb24gZGVwbG95IGNyZWF0ZSAtLWlucHV0LWZpbGU9RklMRWAgfCBTY2hlZHVsZSBhIGRl" + + "cGxveW1lbnQgfCBCbG9ja3MgdW50aWwgQUNUSVZFIChkZWZhdWx0IDkwMHMpIHwKfCBgZnVuY3Rp" + + "b24gZGVwbG95IGdldCAtLWZ1bmN0aW9uLWlkPUlEIC0tdmVyc2lvbi1pZD1WSUQgWy0tanNvbl1g" + + "IHwgRGVwbG95bWVudCBzdGF0dXMgfCBgZnVuY3Rpb25TdGF0dXM6IEFDVElWRVx8REVQTE9ZSU5H" + + "XHxFUlJPUlx8RkFJTEVEYCB8CnwgYGZ1bmN0aW9uIGRlcGxveSB1cGRhdGUgLS1pbnB1dC1maWxl" + + "PUZJTEVgIHwgTW9kaWZ5IGEgZGVwbG95bWVudCBpbiBwbGFjZSB8IHwKfCBgZnVuY3Rpb24gZGVw" + + "bG95IHJlbW92ZSAtLWZ1bmN0aW9uLWlkPUlEIC0tdmVyc2lvbi1pZD1WSURgIHwgU3RvcCBhIGRl" + + "cGxveW1lbnQsIGtlZXAgZnVuY3Rpb24gcmVjb3JkIHwgfAp8IGBmdW5jdGlvbiBpbnZva2UgLS1p" + + "bnB1dC1maWxlPUZJTEVgIHwgQ2FsbCBhIHJlZ3VsYXIgZnVuY3Rpb24gfCBSZXF1aXJlcyBBUEkg" + + "a2V5IChub3QgYWRtaW4gdG9rZW4pOyBMTE0gZnVuY3Rpb25zIGFyZSBpbnZva2VkIHRocm91Z2gg" + + "YGxsbS5pbnZvY2F0aW9uLjxkb21haW4+YCB3aXRoIGBtb2RlbDogIjxmdW5jdGlvbi1pZD4vPG1v" + + "ZGVsLW5hbWU+ImAgfAp8IGBmdW5jdGlvbiBkZWxldGUgLS1mdW5jdGlvbi1pZD1JRCAtLXZlcnNp" + + "b24taWQ9VklEYCB8IFJlbW92ZSBmdW5jdGlvbiArIGRlcGxveW1lbnQgfCAqKkRFU1RSVUNUSVZF" + + "OiBjb25maXJtIHdpdGggdXNlcioqIHwKCiMjIFRhc2tzCgpUYXNrIGNvbW1hbmRzIHJlcXVpcmUg" + + "YE5WQ0ZfQVBJX0tFWWAgc2V0IHRvIGEgdGFzay1zY29wZWQga2V5IGFuZCBgTlZDRl9CQVNFX05W" + + "Q1RfVVJMYCBzZXQgdG8gdGhlIE5WQ1QgZ2F0ZXdheSBlbmRwb2ludC4gSW4gYSBmcmVzaCBzZXNz" + + "aW9uLCByZWFkIGBudmN0QXBpS2V5YCBmcm9tIGB+Ly5udmNmLWNsaS5zdGF0ZWAgYW5kIGluamVj" + + "dCBpdCBhcyBgTlZDRl9BUElfS0VZYCB3aXRob3V0IGxvZ2dpbmcgdGhlIHZhbHVlOyBjaGVjayBg" + + "bnZjdEFwaUtleUV4cGlyYXRpb25gIGZpcnN0IGFuZCByZWdlbmVyYXRlIHdpdGggYGFwaS1rZXkg" + + "Z2VuZXJhdGUgLS1mb3IgdGFzayAtLXZhbGlkYXRlYCBpZiBleHBpcmVkLiBSdW4gYGFwaS1rZXkg" + + "Z2VuZXJhdGUgLS1mb3IgdGFza2AgYWZ0ZXIgYGluaXRgIHRvIG1pbnQgYSBuZXcga2V5LgoKfCBD" + + "b21tYW5kIHwgUHVycG9zZSB8IE5vdGVzIHwKfC0tLXwtLS18LS0tfAp8IGB0YXNrIGNyZWF0ZSAt" + + "LW5hbWU9WCAtLWdwdT1HUFUgLS1pbnN0YW5jZS10eXBlPVRZUEUgLS1pbWFnZT1JTUdgIHwgU3Vi" + + "bWl0IGEgY29udGFpbmVyIHRhc2sgfCBTYXZlcyB0YXNrIElEIHRvIENMSSBzdGF0ZTsgdXNlIGAt" + + "LWlucHV0LWZpbGVgIGZvciByZXBlYXRhYmxlIGNvbmZpZ3MgfAp8IGB0YXNrIGNyZWF0ZSAtLW5h" + + "bWU9WCAtLWdwdT1HUFUgLS1pbnN0YW5jZS10eXBlPVRZUEUgLS1oZWxtLWNoYXJ0PUNIQVJUYCB8" + + "IFN1Ym1pdCBhIEhlbG0gdGFzayB8IGAtLWhlbG0tY2hhcnRgIHJlcGxhY2VzIGAtLWltYWdlYCB8" + + "CnwgYHRhc2sgY3JlYXRlIC0taW5wdXQtZmlsZT1GSUxFYCB8IFN1Ym1pdCBhIHRhc2sgZnJvbSBh" + + "IEpTT04gY29uZmlnIGZpbGUgfCBSZWNvbW1lbmRlZCBmb3IgcmVwZWF0YWJsZSBjb25maWd1cmF0" + + "aW9ucyB8CnwgYHRhc2sgbGlzdCBbLS1zdGF0dXM9U1RBVFVTXSBbLS1saW1pdD1OXWAgfCBMaXN0" + + "IHRhc2tzLCBvcHRpb25hbGx5IGZpbHRlcmVkIGJ5IHN0YXR1cyB8IFN0YXR1c2VzOiBgUVVFVUVE" + + "YCwgYExBVU5DSEVEYCwgYFJVTk5JTkdgLCBgQ09NUExFVEVEYCwgYEVSUk9SRURgLCBgQ0FOQ0VM" + + "RURgLCBgRVhDRUVERURfTUFYX1JVTlRJTUVfRFVSQVRJT05gLCBgRVhDRUVERURfTUFYX1FVRVVF" + + "RF9EVVJBVElPTmAgfAp8IGB0YXNrIGdldCBbdGFza0lkXWAgfCBHZXQgdGFzayBkZXRhaWxzIHwg" + + "VXNlcyBzYXZlZCB0YXNrIElEIGZyb20gc3RhdGUgaWYgb21pdHRlZCB8CnwgYHRhc2sgZXZlbnRz" + + "IFt0YXNrSWRdIFstLWxpbWl0PU5dYCB8IExpc3QgbGlmZWN5Y2xlIGV2ZW50cyBmb3IgYSB0YXNr" + + "IHwgfAp8IGB0YXNrIHJlc3VsdHMgW3Rhc2tJZF1gIHwgTGlzdCByZXN1bHQgYXJ0aWZhY3RzIGZv" + + "ciBhIGNvbXBsZXRlZCB0YXNrIHwgUmV0dXJucyBlbXB0eSBsaXN0IHdoZW4gYHJlc3VsdEhhbmRs" + + "aW5nU3RyYXRlZ3lgIGlzIGBOT05FYDsgcmVzdWx0IHVwbG9hZCBub3QgeWV0IHN1cHBvcnRlZCB8" + + "CnwgYHRhc2sgY2FuY2VsIFt0YXNrSWRdYCB8IENhbmNlbCBhIHJ1bm5pbmcgdGFzayB8IE5vLW9w" + + "IGlmIGFscmVhZHkgaW4gdGVybWluYWwgc3RhdGUgfAp8IGB0YXNrIGRlbGV0ZSBbdGFza0lkXWAg" + + "fCBEZWxldGUgYSB0YXNrIHJlY29yZCB8ICoqU3RvcCwgc3RhdGUgdGFzayBJRCArIGN1cnJlbnQg" + + "c3RhdHVzLCBhbmQgd2FpdCBmb3IgYSBzdWJzZXF1ZW50IHVzZXIgcmVwbHkgZXhwbGljaXRseSBj" + + "b25maXJtaW5nIGRlbGV0aW9uIG9mIHRoYXQgc3BlY2lmaWMgdGFzay4gRG8gbm90IHRyZWF0IHRo" + + "ZSBvcmlnaW5hbCBkZWxldGUgcmVxdWVzdCBhcyBjb25maXJtYXRpb24uKiogfAp8IGB0YXNrIHVw" + + "ZGF0ZS1zZWNyZXRzIFt0YXNrSWRdIC0tc2VjcmV0cyBOQU1FPXZhbHVlYCB8IFVwZGF0ZSBzZWNy" + + "ZXRzIG9uIGEgdGFzazsgc3VwcGxpZWQgc2VjcmV0cyBhcmUgYWRkZWQgb3IgdXBkYXRlZCBieSBu" + + "YW1lLCBleGlzdGluZyBzZWNyZXRzIG5vdCBpbiB0aGUgcmVxdWVzdCBhcmUgcHJlc2VydmVkIHwg" + + "VmFsdWVzIGFyZSBlbmNyeXB0ZWQgYXQgcmVzdCB8CnwgYHRhc2sgYnVsayAtLXRhc2staWRzPUlE" + + "MVssSUQyLOKApl1gIHwgRmV0Y2ggZGV0YWlscyBmb3IgbXVsdGlwbGUgdGFza3MgaW4gb25lIHJl" + + "cXVlc3QgfCB8CgojIyBBdXRoCgp8IENvbW1hbmQgfCBQdXJwb3NlIHwgTm90ZXMgfAp8LS0tfC0t" + + "LXwtLS18CnwgYGluaXRgIHwgTWludCBhZG1pbiB0b2tlbiBmcm9tIEFQSSBLZXlzIHZpYSBwdWJs" + + "aWMgYXBpIGdhdGV3YXkgfCBJZGVtcG90ZW50OyB3cml0ZXMgYH4vLm52Y2YtY2xpLnN0YXRlYDsg" + + "Y2xlYXJzIHNhdmVkIGZ1bmN0aW9uIHN0YXRlIGFuZCBhbGwgQVBJIGtleXMgKGZ1bmN0aW9uIGFu" + + "ZCB0YXNrKSB8CnwgYHN0YXR1c2AgfCBTaG93IENMSSBzdGF0ZSAodG9rZW4sIGxhc3QgZW5kcG9p" + + "bnRzLCBmdW5jdGlvbiBjb250ZXh0KSB8IERpc3RpbmN0IGZyb20gYHNlbGYtaG9zdGVkIHN0YXR1" + + "c2AgfAp8IGBhcGkta2V5IGdlbmVyYXRlIFstLWZvciBmdW5jdGlvblx8dGFza10gWy0tZGVzY3Jp" + + "cHRpb2494oCmXSBbLS1leHBpcmVzLWluPeKApl1gIHwgTWludCBBUEkga2V5cyB8IERlZmF1bHQg" + + "KG5vIGAtLWZvcmApOiBnZW5lcmF0ZXMgYm90aCBhIGZ1bmN0aW9uIGtleSBhbmQgYSB0YXNrIGtl" + + "eTsgYC0tZm9yIGZ1bmN0aW9uYCBvciBgLS1mb3IgdGFza2AgZ2VuZXJhdGVzIG9uZSBvbmx5OyBg" + + "LS1zY29wZXNgIHJlcXVpcmVzIGAtLWZvcmAgfAp8IGBhcGkta2V5IGdlbmVyYXRlIC0tdmFsaWRh" + + "dGVgIHwgTWludCBhbmQgaW1tZWRpYXRlbHkgdmFsaWRhdGUgZWFjaCBnZW5lcmF0ZWQga2V5IHwg" + + "VmFsaWRhdGVzIGVhY2gga2V5IGFnYWluc3QgaXRzIGNvcnJlY3QgYXVkaWVuY2UgKE5WQ0YgZm9y" + + "IGZ1bmN0aW9uIGtleXMsIE5WQ1QgZm9yIHRhc2sga2V5cykgfAp8IGBhcGkta2V5IGxpc3RgIHwg" + + "TGlzdCBBUEkga2V5cyBmb3IgY3VycmVudCBvd25lciB8IExpc3RzIE5WQ0Ytc2NvcGVkIGtleXMg" + + "b25seSB8CnwgYGFwaS1rZXkgZGVsZXRlIEtFWS1JRGAgLyBgYXBpLWtleSByZXZva2UgS0VZLUlE" + + "YCB8IFJlbW92ZSBhbiBBUEkga2V5IHwgKipDb25maXJtIHdpdGggdXNlcioqIHwKfCBgYXBpLWtl" + + "eSBzaG93YCB8IFNob3cgY3VycmVudGx5IHNhdmVkIEFQSSBrZXkgZnJvbSBzdGF0ZSB8IHwKCiMj" + + "IEFnZW50IHNraWxsCgp8IENvbW1hbmQgfCBQdXJwb3NlIHwgTm90ZXMgfAp8LS0tfC0tLXwtLS18" + + "CnwgYGFnZW50LXNraWxsIGluc3RhbGwgWy0tdGFyZ2V0PURJUl1gIHwgSW5zdGFsbCBhbGwgYnVu" + + "ZGxlZCBwdWJsaWMgdXNlciBza2lsbHMgaW50byBgfi8uY2xhdWRlL3NraWxscy9gIGFuZCBgfi8u" + + "YWdlbnRzL3NraWxscy9gIHwgRGVmYXVsdDogYm90aCBiYXNlIHNraWxscyBkaXJlY3RvcmllcyB8" + + "CnwgYGFnZW50LXNraWxsIHVuaW5zdGFsbCBbLS10YXJnZXQ9RElSXWAgfCBSZW1vdmUgb25seSBi" + + "dW5kbGVkIHB1YmxpYyB1c2VyIHNraWxscyBmcm9tIHRoZSB0YXJnZXQgYmFzZSBza2lsbHMgZGly" + + "ZWN0b3JpZXMgfCBJZGVtcG90ZW50OyB1bnJlbGF0ZWQgc2tpbGxzIHJlbWFpbiB8CnwgYGFnZW50" + + "LXNraWxsIHNob3cgWy0tZmlsZT1SRUxdYCB8IFByaW50IGJ1bmRsZWQgYG52Y2Ytc2VsZi1tYW5h" + + "Z2VkLWNsaS9TS0lMTC5tZGAgb3IgYW5vdGhlciBlbWJlZGRlZCBmaWxlIHwgRm9yIGRlYnVnZ2lu" + + "ZyB8CnwgYGFnZW50LXNraWxsIHZlcnNpb25gIHwgUHJpbnQgYnVpbGQgU0hBIGFuZCBlbWJlZGRl" + + "ZCBwdWJsaWMgdXNlciBza2lsbCBzdW1tYXJ5IHwgfApQSwcIcg0PZCEjAAAhIwAAUEsDBBQACAAA" + + "AAAAIQAAAAAAAAAAAAAAAAAyAAkAZGF0YS9udmNmLXNlbGYtbWFuYWdlZC1jbGkvcmVmZXJlbmNl" + + "L2V4aXQtY29kZXMubWRVVAUAAQCmzhIjIGBudmNmLWNsaWAgZXhpdCBjb2RlcwoKU3RhYmxlIGFj" + + "cm9zcyBzdWJjb21tYW5kcy4gVXNlIHRoZXNlIHRvIGRyaXZlIGFnZW50IHJldHJ5IC8gc3VyZmFj" + + "aW5nIGxvZ2ljLgoKfCBDb2RlIHwgTWVhbmluZyB8IEV4YW1wbGUgY2F1c2VzIHwKfC0tLXwtLS18" + + "LS0tfAp8IGAwYCB8IFN1Y2Nlc3MgfCBBbGwgY2hlY2tzIHBhc3NlZDsgaW5zdGFsbCBjb21wbGV0" + + "ZWQ7IGRlcGxveW1lbnQgQUNUSVZFIHwKfCBgMWAgfCBHZW5lcmljIGVycm9yIHwgSGVsbSByZW5k" + + "ZXIgZmFpbGVkOyBuZXR3b3JrIHVucmVhY2hhYmxlOyBmaWxlIG5vdCBmb3VuZDsgWUFNTCBwYXJz" + + "ZSBlcnJvciB8CnwgYDJgIHwgUHJlLWZsaWdodCBjaGVjayBmYWlsZWQgfCBHYXRld2F5IEFQSSBD" + + "UkRzIG1pc3Npbmc7IGt1YmVjdGwgbm90IG9uIFBBVEg7IGRlZmF1bHQgU3RvcmFnZUNsYXNzIGFi" + + "c2VudCB8CnwgYDNgIHwgQWRtaW4gYXV0aCBmYWlsZWQgfCBObyB0b2tlbiArIGAtLW5vbi1pbnRl" + + "cmFjdGl2ZWAgc2V0OyBJQ01TIHJlamVjdGVkIEpXVDsgaW5pdCBlbmRwb2ludCB1bnJlYWNoYWJs" + + "ZSB8CnwgYDVgIHwgTWFuaWZlc3QgYXBwbHkgb3IgYC0td2FpdGAgdGltZWQgb3V0IHwgSGVsbSBp" + + "bnN0YWxsIHRpbWVvdXQ7IGNoZWNrIHBvbGxlZCBidXQgZGlkbid0IHBhc3MgYmVmb3JlIGR1cmF0" + + "aW9uIHwKfCBgMTMwYCB8IENhbmNlbGxlZCBieSBTSUdJTlQvU0lHVEVSTSB8IFVzZXIgQ3RybC1D" + + "OyBDSSBidWRnZXQgZXhjZWVkZWQ7IHBvZCBldmljdGVkIHwKCiMjIEhvdyBhbiBhZ2VudCBzaG91" + + "bGQgcmVhY3QKCnwgQ29kZSB8IEFnZW50IGJlaGF2aW9yIHwKfC0tLXwtLS18CnwgYDBgIHwgQ29u" + + "dGludWUgLyByZXBvcnQgc3VjY2Vzcy4gfAp8IGAxYCB8IFN1cmZhY2Ugc3RkZXJyIHRvIHVzZXI7" + + "IGFzayBiZWZvcmUgYW55IHJldHJ5LiBHZW5lcmljIGVycm9ycyB1c3VhbGx5IG5lZWQgYSBodW1h" + + "biB0byByZWFkIHRoZSBtZXNzYWdlLiB8CnwgYDJgIHwgU3VyZmFjZSBmYWlsZWQgY2hlY2tzICsg" + + "dGhlaXIgYGhpbnRVUkxgLiBEb24ndCBwcm9wb3NlIGB1cGAgdW50aWwgdGhlIHVzZXIgZml4ZXMg" + + "cHJlcmVxcy4gfAp8IGAzYCB8IFN1Z2dlc3QgYG52Y2YtY2xpIGluaXRgIChpbnRlcmFjdGl2ZSkg" + + "T1IgYC0tdG9rZW49JEpXVGAgKENJKS4gRG9uJ3QgYXV0by1taW50IHdpdGhvdXQgdXNlciBPSy4g" + + "fAp8IGA1YCB8IEFzayB1c2VyIGlmIHRoZXkgd2FudCB0byB3YWl0IGxvbmdlciwgZGlnIGludG8g" + + "dGhlIHN0YWxsZWQgY29tcG9uZW50LCBvciBjYW5jZWwuIHwKfCBgMTMwYCB8IERvbid0IHJldHJ5" + + "IGF1dG9tYXRpY2FsbHk7IHVzZXIgZXhwbGljaXRseSBjYW5jZWxsZWQuIENvbmZpcm0gYmVmb3Jl" + + "IHJlLXJ1bm5pbmcuIHwKCiMjIFdoZXJlIHRvIGZpbmQgbW9yZSBkZXRhaWwKCkV2ZXJ5IG5vbi16" + + "ZXJvIGV4aXQgZW1pdHMgYSBzdHJ1Y3R1cmVkIGBwaGFzZV9mYWlsZWRgIEpTT04gZXZlbnQgd2l0" + + "aCBgZXJyQ2F0ZWdvcnlgLCBgZXJyTWVzc2FnZWAsIGByZW1lZGlhdGlvbmAgKGFycmF5KSwgYHJl" + + "dHJ5Q2xhc3NgIChlbnVtOiBgbm9uZXxpbW1lZGlhdGV8YmFja29mZnxhZnRlcl9yZW1lZGlhdGlv" + + "bnx1bmtub3duYCksIGByZXRyeUFmdGVyU2VjYCAoaW50LCBvcHRpb25hbCksIGFuZCBgcmF3YCAo" + + "c3VicHJvY2VzcyArIEhUVFAgKyBLdWJlcm5ldGVzIHNpZ25hbCkuIEFsd2F5cyBjb25zdW1lIHRo" + + "ZXNlIGluIGAtLWpzb25gIG1vZGUgcmF0aGVyIHRoYW4gcGFyc2luZyBFbmdsaXNoIGZyb20gc3Rk" + + "ZXJyLgpQSwcIc6daZNUGAADVBgAAUEsDBBQACAAAAAAAIQAAAAAAAAAAAAAAAAAtAAkAZGF0YS9u" + + "dmNmLXNlbGYtbWFuYWdlZC1jbGkvcmVmZXJlbmNlL2ZsYWdzLm1kVVQFAAEAps4SIyBgbnZjZi1j" + + "bGlgIGZsYWcgcmVmZXJlbmNlCgojIyBHbG9iYWwgZmxhZ3MgKGV2ZXJ5IHN1YmNvbW1hbmQpCgp8" + + "IEZsYWcgfCBQdXJwb3NlIHwgRGVmYXVsdCB8CnwtLS18LS0tfC0tLXwKfCBgLS1jb25maWcgRklM" + + "RWAgfCBDb25maWcgZmlsZSBwYXRoIHwgYCRIT01FLy5udmNmLWNsaS55YW1sYCB8CnwgYC0tZGVi" + + "dWdgIHwgVmVyYm9zZSBIVFRQIGxvZ2dpbmcgb24gc3RkZXJyIHwgYGZhbHNlYCB8CnwgYC0tanNv" + + "bmAgfCBKU09OTCBldmVudHMgb24gc3RkZXJyIHwgYXV0byAob2ZmIGluIFRUWSwgb24gdW5kZXIg" + + "YC0tbm9uLWludGVyYWN0aXZlYCkgfAoKIyMgYHNlbGYtaG9zdGVkYCBwYXJlbnQgKHBlcnNpc3Rl" + + "bnQgYWNyb3NzIHN1YmNvbW1hbmRzKQoKfCBGbGFnIHwgUHVycG9zZSB8IERlZmF1bHQgfAp8LS0t" + + "fC0tLXwtLS18CnwgYC0tY29udHJvbC1wbGFuZS1zdGFjaz3igKZgIHwgQ29udHJvbC1wbGFuZSBi" + + "dW5kbGUgc291cmNlOiBsb2NhbCBwYXRoLCBnaXQgVVJMLCBvciBgb2NpOi8vYCBVUkwgfCBlbWJl" + + "ZGRlZCBPQ0kgVVJMIHBpbm5lZCBieSBDTEkgdmVyc2lvbiB8CnwgYC0tY29tcHV0ZS1wbGFuZS1z" + + "dGFjaz3igKZgIHwgQ29tcHV0ZS1wbGFuZSBidW5kbGUgc291cmNlOiBsb2NhbCBwYXRoLCBnaXQg" + + "VVJMLCBvciBgb2NpOi8vYCBVUkwgfCBlbWJlZGRlZCBPQ0kgVVJMIHBpbm5lZCBieSBDTEkgdmVy" + + "c2lvbiB8CnwgYC0tZW52PWxvY2FsXHxwcmRcfOKApmAgfCBIZWxtZmlsZSBlbnZpcm9ubWVudCBu" + + "YW1lIHwgYGxvY2FsYCBmb3IgZGV2IGJ1aWxkcywgYHByZGAgZm9yIHJlbGVhc2VzIHwKfCBgLS1u" + + "b24taW50ZXJhY3RpdmVgIHwgRGlzYWJsZSBhbGwgc3RkaW4gcHJvbXB0cyB8IGBmYWxzZWAgfAp8" + + "IGAtLXRva2VuPSRKV1RgIHwgQWRtaW4gSldULCBvdmVycmlkZXMgc3RvcmVkIHNlc3Npb24gfCAt" + + "IHwKfCBgLS1uby1hcHBseWAgfCBgaW5zdGFsbGAgb25seSAtIGVtaXQgWUFNTCwgZG8gbm90IGt1" + + "YmVjdGwgYXBwbHkgfCBgZmFsc2VgIHwKfCBgLS1vdXRwdXQ9dGV4dFx8anNvbmAgfCBMZWdhY3kg" + + "YWxpYXMgZm9yIGAtLWpzb25gIChkZXByZWNhdGVkLCByZW1vdmVkIGluIG5leHQgbWFqb3IpIHwg" + + "YHRleHRgIHwKfCBgLS1wbGFpbmAgfCBGb3JjZSBwbGFpbiBzdHJlYW1pbmcgb3V0cHV0IHwgYXV0" + + "by1kZXRlY3QgfAp8IGAtLXdhaXQgRFVSQVRJT05gIHwgYGNoZWNrYCBvbmx5OyBibG9jayB1bnRp" + + "bCBwYXNzIHwgLSB8CnwgYC0tY29udHJvbC1wbGFuZS1jb250ZXh0IENUWGAgfCBrdWJlY3RsIGNv" + + "bnRleHQgZm9yIGNvbnRyb2wgcGxhbmUgKFJFUS0yMCkgfCBjdXJyZW50IGNvbnRleHQgfAp8IGAt" + + "LWNvbXB1dGUtcGxhbmUtY29udGV4dCBDVFhgIHwga3ViZWN0bCBjb250ZXh0IGZvciBjb21wdXRl" + + "IHBsYW5lIChSRVEtMjApIHwgY3VycmVudCBjb250ZXh0IHwKfCBgLS1pY21zLXVybCBVUkxgIHwg" + + "UHVibGljIElDTVMgVVJMOyByZXF1aXJlZCB3aGVuIGNvbnRleHRzIGRpZmZlciB8IGRlcml2ZWQg" + + "ZnJvbSBgYmFzZV9odHRwX3VybGAgfAp8IGAtLWxvY2FsLW9ubHlgIHwgYGNoZWNrIC0tcHJlYCBv" + + "bmx5OyBza2lwIGFsbCBrdWJlY3RsIGNvbnRhY3QgfCBgZmFsc2VgIHwKCiMjIGB1cGAtc3BlY2lm" + + "aWMKCnwgRmxhZyB8IFB1cnBvc2UgfCBEZWZhdWx0IHwKfC0tLXwtLS18LS0tfAp8IGAtLWNsdXN0" + + "ZXItbmFtZSBOQU1FYCB8IElDTVMgY2x1c3RlciByb3cgaWRlbnRpZmllciAocmVxdWlyZWQpIHwg" + + "LSB8CnwgYC0tbmNhLWlkIElEYCB8IE5DQSBhY2NvdW50IElEIHwgYG52Y2YtZGVmYXVsdGAgfAp8" + + "IGAtLXJlZ2lvbiBSRUdJT05gIHwgQ2x1c3RlciByZWdpb24gfCBgdXMtd2VzdC0xYCB8CnwgYC0t" + + "cGxhbi1vbmx5YCB8IERyeS1ydW47IGVtaXQgcGhhc2UgcGxhbiArIEVUQXMgd2l0aG91dCBjaGFu" + + "Z2VzIHwgYGZhbHNlYCB8CgojIyBgc3RhdHVzYC1zcGVjaWZpYwoKfCBGbGFnIHwgUHVycG9zZSB8" + + "IERlZmF1bHQgfAp8LS0tfC0tLXwtLS18CnwgYC0tY2x1c3Rlci1uYW1lIE5BTUVgIHwgTGltaXQg" + + "dG8gb25lIGNvbXB1dGUgcGxhbmUgfCAtIChjb250cm9sICsgYWxsIGNsdXN0ZXJzKSB8CnwgYC0t" + + "d2F0Y2hgIHwgTGl2ZSByZS1yZW5kZXIgfCBgZmFsc2VgIHwKfCBgLS13YXRjaC1pbnRlcnZhbCBE" + + "VVJgIHwgYC0td2F0Y2hgIGNhZGVuY2UgfCBgNXNgIHwKfCBgLS1jb21wb25lbnQgTkFNRWAgfCBG" + + "aWx0ZXIgY29tcG9uZW50cyBwYW5lbCB8IGFsbCB8CnwgYC0tbm8tZXZlbnRzYCB8IFNraXAgZXZl" + + "bnRzIHBhbmVsIHwgYGZhbHNlYCB8CgojIyBgY2x1c3RlciByZWdpc3RlcmAtc3BlY2lmaWMKCnwg" + + "RmxhZyB8IFB1cnBvc2UgfCBEZWZhdWx0IHwKfC0tLXwtLS18LS0tfAp8IGAtLW5hbWUgTkFNRWAg" + + "fCBDbHVzdGVyIG5hbWUgKHJlcXVpcmVkKSB8IC0gfAp8IGAtLW5jYS1pZCBJRGAgfCBOQ0EgSUQg" + + "KHJlcXVpcmVkKSB8IC0gfAp8IGAtLXJlZ2lvbiBSRUdJT05gIHwgUmVnaW9uIHwgYHVzLXdlc3Qt" + + "MWAgfAp8IGAtLWljbXMtdXJsIFVSTGAgfCBJQ01TIGVuZHBvaW50IHwgZnJvbSBjb25maWcgfAp8" + + "IGAtLWlnbm9yZS1leGlzdGluZ2AgfCBNYXRjaC1vci1jcmVhdGUgaW5zdGVhZCBvZiBmYWlsLW9u" + + "LWV4aXN0cyB8IGBmYWxzZWAgfAoKIyMgYGFwaS1rZXkgZ2VuZXJhdGVgLXNwZWNpZmljCgp8IEZs" + + "YWcgfCBQdXJwb3NlIHwgRGVmYXVsdCB8CnwtLS18LS0tfC0tLXwKfCBgLS1mb3IgZnVuY3Rpb25c" + + "fHRhc2tgIHwgR2VuZXJhdGUgb25seSB0aGUgc3BlY2lmaWVkIGtleSB0eXBlIHwgKG9taXQgdG8g" + + "Z2VuZXJhdGUgYm90aCkgfAp8IGAtLWRlc2NyaXB0aW9uIFRFWFRgIHwgSHVtYW4tcmVhZGFibGUg" + + "bGFiZWwgZm9yIHRoZSBrZXkgfCBgR2VuZXJhdGVkIGJ5IG52Y2YtY2xpYCB8CnwgYC0tZXhwaXJl" + + "cy1pbiBEVVJBVElPTmAgfCBFeHBpcnkgb2Zmc2V0IChlLmcuIGAyNGhgLCBgN2RgKTsgcGFyc2Vk" + + "IGFzIGV4dGVuZGVkIGR1cmF0aW9uIHwgYDI0aGAgfAp8IGAtLXNjb3BlcyBTQ09QRVssU0NPUEVd" + + "YCB8IE92ZXJyaWRlIGRlZmF1bHQgc2NvcGVzOyByZXF1aXJlcyBgLS1mb3JgIHwgKHNlcnZpY2Ug" + + "ZGVmYXVsdHMpIHwKfCBgLS12YWxpZGF0ZWAgfCBWYWxpZGF0ZSBlYWNoIGdlbmVyYXRlZCBrZXkg" + + "aW1tZWRpYXRlbHkgYWZ0ZXIgbWludGluZyB8IGBmYWxzZWAgfAoKRXh0ZW5kZWQgZHVyYXRpb24g" + + "dW5pdHM6IGBzYCAoc2Vjb25kcyksIGBtYCAobWludXRlcyksIGBoYCAoaG91cnMpLCBgZGAgKGRh" + + "eXMpLCBgd2AgKHdlZWtzKS4KCiMjIGBmdW5jdGlvbiBjcmVhdGVgLXNwZWNpZmljCgpgLS1pbnB1" + + "dC1maWxlIEZJTEVgIGlzIHJlY29tbWVuZGVkIGZvciByZXBlYXRhYmxlIGZ1bmN0aW9uIGRlZmlu" + + "aXRpb25zLiBGb3IgYWQtaG9jIGNyZWF0ZXM6Cgp8IEZsYWcgfCBQdXJwb3NlIHwgRGVmYXVsdCB8" + + "CnwtLS18LS0tfC0tLXwKfCBgLS1uYW1lIE5BTUVgIHwgRnVuY3Rpb24gbmFtZSB8IC0gfAp8IGAt" + + "LWltYWdlIElNQUdFYCB8IENvbnRhaW5lciBpbWFnZSB8IC0gfAp8IGAtLWluZmVyZW5jZS11cmwg" + + "VVJJYCB8IENvbnRhaW5lciBpbmZlcmVuY2UgZW5kcG9pbnQgfCAtIHwKfCBgLS1pbmZlcmVuY2Ut" + + "cG9ydCBQT1JUYCB8IENvbnRhaW5lciBpbmZlcmVuY2UgcG9ydCB8IC0gfAp8IGAtLWZ1bmN0aW9u" + + "LXR5cGUgREVGQVVMVFx8U1RSRUFNSU5HXHxMTE1gIHwgRnVuY3Rpb24gdHlwZSB8IGBERUZBVUxU" + + "YCB8CnwgYC0taGVsbS1jaGFydCBDSEFSVGAgfCBIZWxtIGNoYXJ0IFVSTCBvciBPQ0kgcmVmZXJl" + + "bmNlLiBDYW4gYmUgdXNlZCB3aXRoIGAtLWZ1bmN0aW9uLXR5cGU9TExNYCBmb3IgY2hhcnQtcGFj" + + "a2FnZWQgTExNIHdvcmtsb2Fkcy4gfCAtIHwKfCBgLS1oZWxtLWNoYXJ0LXNlcnZpY2UgTkFNRWAg" + + "fCBLdWJlcm5ldGVzIFNlcnZpY2UgbmFtZSBleHBvc2VkIGJ5IHRoZSBjaGFydC4gUmVxdWlyZWQg" + + "d2hlbiBgLS1oZWxtLWNoYXJ0YCBpcyBzZXQuIHwgLSB8CnwgYC0tbW9kZWxzIE5BTUU6VkVSU0lP" + + "TjpVUklgIHwgU3RhbmRhcmQgbW9kZWwgYXJ0aWZhY3Q7IHJlcGVhdGFibGUgfCAtIHwKfCBgLS1s" + + "bG0tbW9kZWwgU1BFQ2AgfCBMTE0gbW9kZWwgY29uZmlnOyBmb3JtYXQgYG5hbWU9PG1vZGVsPix1" + + "cmlzPTx1cmk+XHw8dXJpPixyb3V0aW5nTWV0aG9kPTxtZXRob2Q+LHRva2VuUmF0ZUxpbWl0PTxs" + + "aW1pdD5gOyByZXBlYXRhYmxlLiBUb2tlbiBsaW1pdHMgdXNlIGA8dmFsdWU+LTx1bml0PmAgd2l0" + + "aCBgU2AsIGBNYCwgYEhgLCBgRGAsIG9yIGBXYCwgZm9yIGV4YW1wbGUgYDEwMDAtU2AuIFVzZSBp" + + "bnB1dCBKU09OIGZvciBjb21iaW5lZCB0b2tlbiBsaW1pdHMgYmVjYXVzZSBpbmxpbmUgc3BlY3Mg" + + "dXNlIGNvbW1hcyBhcyBmaWVsZCBzZXBhcmF0b3JzLiB8IC0gfAoKSW4gSlNPTiBhbmQgaW5saW5l" + + "IHNwZWNzLCBMTE0gZnVuY3Rpb25zIHNldCBgZnVuY3Rpb25UeXBlOiAiTExNImAgYW5kIG1vZGVs" + + "IHJvdXRpbmcgbWV0YWRhdGEgdW5kZXIgYG1vZGVsc1tdLmxsbUNvbmZpZ2AuIGBsbG1Db25maWcu" + + "dXJpc2AgZGVjbGFyZXMgdGhlIE9wZW5BSS1jb21wYXRpYmxlIHVwc3RyZWFtIHBhdGhzIGV4cG9z" + + "ZWQgYnkgdGhlIG1vZGVsLiBDdXJyZW50IHN1cHBvcnRlZCBwYXRocyBhcmUgYC92MS9jaGF0L2Nv" + + "bXBsZXRpb25zYCwgYC92MS9yZXNwb25zZXNgLCBhbmQgYC92MS9lbWJlZGRpbmdzYC4gYGxsbUNv" + + "bmZpZy5yb3V0aW5nTWV0aG9kYCBhY2NlcHRzIGByb3VuZF9yb2JpbmAsIGBwb3dlcl9vZl90d29g" + + "LCBgZ3JvcV9tdWx0aXJlZ2lvbmAsIGBwdWxzYXJgLCBvciBgcmFuZG9tYC4KYGxsbUNvbmZpZy50" + + "b2tlblJhdGVMaW1pdGAgYWNjZXB0cyBvbmUgb3IgbW9yZSBjb21tYS1zZXBhcmF0ZWQgcG9zaXRp" + + "dmUgaW50ZWdlciB0b2tlbiBsaW1pdHMgaW4gYDx2YWx1ZT4tPHVuaXQ+YCBmb3JtYXQuIFN1cHBv" + + "cnRlZCB1bml0cyBhcmUgYFNgIChzZWNvbmRzKSwgYE1gIChtaW51dGVzKSwgYEhgIChob3Vycyks" + + "IGBEYCAoZGF5cyksIGFuZCBgV2AgKHdlZWtzKS4gVXNlIGRpc3RpbmN0IHVuaXRzIHdoZW4gY29t" + + "YmluaW5nIGxpbWl0cywgZm9yIGV4YW1wbGUgYDEwMDAtUyw1MDAwLU0sMTAwMDAwLUgsNTAwMDAw" + + "LUQsMTAwMDAwMC1XYCBpbiBpbnB1dCBKU09OLgoKSGVsbSBjaGFydCBwYWNrYWdpbmcgaXMgaW5k" + + "ZXBlbmRlbnQgb2YgYGZ1bmN0aW9uVHlwZWAuIEZvciBhIEhlbG0tY2hhcnQgYmFja2VkIExMTSBm" + + "dW5jdGlvbiwgc2V0IGBmdW5jdGlvblR5cGU6ICJMTE0iYCwgYGhlbG1DaGFydGAsIGBoZWxtQ2hh" + + "cnRTZXJ2aWNlTmFtZWAsIGFuZCBgbW9kZWxzW10ubGxtQ29uZmlnYCBpbiB0aGUgc2FtZSBjcmVh" + + "dGUgcmVxdWVzdC4gYGluZmVyZW5jZVBvcnRgIG11c3QgYmUgdGhlIEt1YmVybmV0ZXMgU2Vydmlj" + + "ZSBwb3J0IGV4cG9zZWQgYnkgYGhlbG1DaGFydFNlcnZpY2VOYW1lYC4KCkxMTSBpbnZvY2F0aW9u" + + "IHJlcXVlc3RzIHVzZSBgbW9kZWw6ICI8ZnVuY3Rpb24taWQ+Lzxtb2RlbC1uYW1lPiJgLiBUaGUg" + + "ZnVuY3Rpb24gSUQgc2VsZWN0cyB0aGUgTlZDRiBmdW5jdGlvbiwgYW5kIHRoZSBtb2RlbCBuYW1l" + + "IGlzIGZvcndhcmRlZCB1cHN0cmVhbS4gQ2hhdCBjb21wbGV0aW9ucyBhbmQgUmVzcG9uc2VzIEFQ" + + "SSByZXF1ZXN0cyBjYW4gdXNlIGB4LW11bHRpLXR1cm4tc2Vzc2lvbi1pZGAgZm9yIHNlc3Npb24g" + + "c3RpY2tpbmVzczsgZW1iZWRkaW5ncyByZXF1ZXN0cyBkbyBub3QuCgojIyBgZnVuY3Rpb24gdXBk" + + "YXRlYC1zcGVjaWZpYwoKfCBGbGFnIHwgUHVycG9zZSB8IERlZmF1bHQgfAp8LS0tfC0tLXwtLS18" + + "CnwgYC0tdGFncyBUQUdbLFRBR11gIHwgUmVwbGFjZSBmdW5jdGlvbiB0YWdzIHwgLSB8CnwgYC0t" + + "bGxtLW1vZGVsLXVwZGF0ZSBTUEVDYCB8IExMTSBtb2RlbCB1cGRhdGU7IGZvcm1hdCBgbmFtZT08" + + "bW9kZWw+LHJvdXRpbmdNZXRob2Q9PG1ldGhvZD4sdG9rZW5SYXRlTGltaXQ9PGxpbWl0PmA7IHJl" + + "cGVhdGFibGUuIFJvdXRpbmcgbWV0aG9kcyBtYXRjaCBgLS1sbG0tbW9kZWxgLiBUb2tlbiBsaW1p" + + "dCBleGFtcGxlOiBgMTAwMC1TYC4gVXNlIGlucHV0IEpTT04gZm9yIGNvbWJpbmVkIHRva2VuIGxp" + + "bWl0cy4gfCAtIHwKCkluIEpTT04sIGBmdW5jdGlvbiB1cGRhdGVgIGFjY2VwdHMgYG1vZGVsVXBk" + + "YXRlc1tdYCBlbnRyaWVzIHdpdGggYG1vZGVsTmFtZWAgYW5kIGBsbG1Db25maWcucm91dGluZ01l" + + "dGhvZGAgYW5kL29yIGBsbG1Db25maWcudG9rZW5SYXRlTGltaXRgLiBgdXJpc2AgYXJlIGNyZWF0" + + "ZS10aW1lIG1vZGVsIG1ldGFkYXRhIGFuZCBhcmUgbm90IHBhcnQgb2YgbW9kZWwgdXBkYXRlcy4K" + + "CiMjIGBmdW5jdGlvbiBkZXBsb3kgY3JlYXRlYC1zcGVjaWZpYwoKYC0taW5wdXQtZmlsZSBGSUxF" + + "YCBpcyByZWNvbW1lbmRlZCAoZnVsbCBKU09OIHNwZWMpLiBGb3IgYWQtaG9jIG9uZS1zaG90IHVz" + + "ZToKCnwgRmxhZyB8IFB1cnBvc2UgfCBEZWZhdWx0IHwKfC0tLXwtLS18LS0tfAp8IGAtLWZ1bmN0" + + "aW9uLWlkIElEYCB8IEZ1bmN0aW9uIElEIChyZXF1aXJlZCkgfCAtIHwKfCBgLS1ncHUgTkFNRWAg" + + "fCBHUFUgZmFtaWx5IHwgYEgxMDBgIHwKfCBgLS1pbnN0YW5jZS10eXBlIFRZUEVgIHwgU0tVIHwg" + + "YE5DUC5HUFUuSDEwMF8xeGAgfAp8IGAtLW1pbi1pbnN0YW5jZXMgTmAgfCBNaW4gcmVwbGljYXMg" + + "fCBgMWAgfAp8IGAtLW1heC1pbnN0YW5jZXMgTmAgfCBNYXggcmVwbGljYXMgfCBgMWAgfAp8IGAt" + + "LW1heC1yZXF1ZXN0LWNvbmN1cnJlbmN5IE5gIHwgQ29uY3VycmVuY3kgfCBgMGAgKHVuc2V0OyBz" + + "ZXJ2ZXIgZGVmYXVsdCBhcHBsaWVzKSB8CnwgYC0tY2x1c3RlcnMgTkFNRVssTkFNRV1gIHwgVGFy" + + "Z2V0IHNwZWNpZmljIGNvbXB1dGUgY2x1c3RlcnMgfCAoYW55IG1hdGNoaW5nIFNLVSkgfAoKIyMg" + + "YHRhc2sgY3JlYXRlYC1zcGVjaWZpYwoKYC0taW5wdXQtZmlsZSBGSUxFYCBpcyByZWNvbW1lbmRl" + + "ZCBmb3IgcmVwZWF0YWJsZSB0YXNrIGRlZmluaXRpb25zLiBGb3IgYWQtaG9jIHVzZToKCnwgRmxh" + + "ZyB8IFB1cnBvc2UgfCBOb3RlcyB8CnwtLS18LS0tfC0tLXwKfCBgLS1uYW1lIE5BTUVgIHwgVGFz" + + "ayBuYW1lIChyZXF1aXJlZCkgfCAxLTEyOCBjaGFycywgYF5bYS16MC05QS1aXVthLXowLTlBLVpc" + + "LV9dKiRgIHwKfCBgLS1ncHUgR1BVYCB8IEdQVSBuYW1lIChyZXF1aXJlZCB3aXRob3V0IGAtLWlu" + + "cHV0LWZpbGVgKSB8IEV4YW1wbGU6IGBIMTAwYCB8CnwgYC0taW5zdGFuY2UtdHlwZSBUWVBFYCB8" + + "IEluc3RhbmNlIHR5cGUgKHJlcXVpcmVkIHdpdGhvdXQgYC0taW5wdXQtZmlsZWApIHwgRXhhbXBs" + + "ZTogYE5DUC5HUFUuSDEwMF8xeGAgfAp8IGAtLWltYWdlIElNQUdFYCB8IENvbnRhaW5lciBpbWFn" + + "ZSB8IE11dHVhbGx5IGV4Y2x1c2l2ZSB3aXRoIGAtLWhlbG0tY2hhcnRgIHwKfCBgLS1oZWxtLWNo" + + "YXJ0IENIQVJUYCB8IEhlbG0gY2hhcnQgVVJMIG9yIE9DSSByZWZlcmVuY2UgfCBNdXR1YWxseSBl" + + "eGNsdXNpdmUgd2l0aCBgLS1pbWFnZWAgfAp8IGAtLWlucHV0LWZpbGUgRklMRWAgfCBKU09OIHRh" + + "c2sgc3BlYyBmaWxlIHwgQ0xJIGZsYWdzIG92ZXJyaWRlIEpTT04gdmFsdWVzIHdoZW4gYm90aCBh" + + "cmUgc2V0IHwKfCBgLS1iYWNrZW5kIEJBQ0tFTkRgIHwgQmFja2VuZCAvIENTUCB8IC0gfAp8IGAt" + + "LWNsdXN0ZXJzIE5BTUVbLE5BTUVdYCB8IFNwZWNpZmljIGNsdXN0ZXJzIHdpdGhpbiB0aGUgaW5z" + + "dGFuY2UgfCBDb21tYS1zZXBhcmF0ZWQgfAp8IGAtLWNvbnRhaW5lci1hcmdzIEFSR1NgIHwgQXJn" + + "cyBwYXNzZWQgd2hlbiBsYXVuY2hpbmcgdGhlIGNvbnRhaW5lciB8IFNpbmdsZSBzdHJpbmcsIGUu" + + "Zy4gYCItLWVwb2NocyAxMCAtLWJhdGNoLXNpemUgMzIiYCB8CnwgYC0tY29udGFpbmVyLWVudiBO" + + "QU1FPXZhbHVlYCB8IENvbnRhaW5lciBlbnZpcm9ubWVudCB2YXJpYWJsZTsgcmVwZWF0YWJsZSB8" + + "IC0gfAp8IGAtLXNlY3JldHMgTkFNRT12YWx1ZWAgfCBTZWNyZXQgZW52aXJvbm1lbnQgdmFyaWFi" + + "bGU7IHJlcGVhdGFibGU7IGVuY3J5cHRlZCBhdCByZXN0IHwgLSB8CnwgYC0tbWF4LXJ1bnRpbWUg" + + "RFVSQVRJT05gIHwgTWF4IHdhbGwtY2xvY2sgcnVuIHRpbWUgKElTTyA4NjAxLCBlLmcuIGBQVDRI" + + "YCkgfCBObyBkZWZhdWx0OyBvbWl0IGZvciBubyB0aW1lIGxpbWl0IHwKfCBgLS1tYXgtcXVldWVk" + + "IERVUkFUSU9OYCB8IE1heCB0aW1lIGluIHF1ZXVlIGJlZm9yZSBjYW5jZWxsYXRpb24gKElTTyA4" + + "NjAxKSB8IFNlcnZlciBkZWZhdWx0IGBQVDcySGAgfAp8IGAtLXRlcm1pbmF0aW9uLWdyYWNlIERV" + + "UkFUSU9OYCB8IEdyYWNlIHBlcmlvZCBhZnRlciBzdG9wIHNpZ25hbCAoSVNPIDg2MDEpIHwgU2Vy" + + "dmVyIGRlZmF1bHQgYFBUMUhgIHwKfCBgLS1yZXN1bHQtc3RyYXRlZ3kgVVBMT0FEXHxOT05FYCB8" + + "IEhvdyB0byBoYW5kbGUgdGFzayBvdXRwdXQgYXJ0aWZhY3RzIHwgLSB8CnwgYC0tcmVzdWx0cy1s" + + "b2NhdGlvbiBMT0NBVElPTmAgfCBSZXN1bHQgdXBsb2FkIHRhcmdldCwgZm9ybWF0IGBvcmctbmFt" + + "ZS9bdGVhbS1uYW1lL11tb2RlbC1uYW1lYDsgcmVxdWlyZWQgd2hlbiBgLS1yZXN1bHQtc3RyYXRl" + + "Z3k9VVBMT0FEYCB8IC0gfAp8IGAtLW1vZGVscyBOQU1FOlZFUlNJT046VVJJYCB8IE1vZGVsIGFy" + + "dGlmYWN0OyByZXBlYXRhYmxlIHwgLSB8CnwgYC0tcmVzb3VyY2VzIE5BTUU6VkVSU0lPTjpVUklg" + + "IHwgUmVzb3VyY2UgYXJ0aWZhY3Q7IHJlcGVhdGFibGUgfCAtIHwKfCBgLS10YWdzIFRBR1ssVEFH" + + "XWAgfCBUYXNrIHRhZ3MgfCBDb21tYS1zZXBhcmF0ZWQgfAp8IGAtLWRlc2NyaXB0aW9uIFRFWFRg" + + "IHwgVGFzayBkZXNjcmlwdGlvbiB8IC0gfAp8IGAtLWxvZ3MtdGVsZW1ldHJ5LWlkIFVVSURgIHwg" + + "TG9ncyB0ZWxlbWV0cnkgZW5kcG9pbnQgSUQgfCAtIHwKfCBgLS1tZXRyaWNzLXRlbGVtZXRyeS1p" + + "ZCBVVUlEYCB8IE1ldHJpY3MgdGVsZW1ldHJ5IGVuZHBvaW50IElEIHwgLSB8CnwgYC0tdHJhY2Vz" + + "LXRlbGVtZXRyeS1pZCBVVUlEYCB8IFRyYWNlcyB0ZWxlbWV0cnkgZW5kcG9pbnQgSUQgfCAtIHwK" + + "ClBLBwj8o5HgxiIAAMYiAABQSwMEFAAIAAAAAAAhAAAAAAAAAAAAAAAAADcACQBkYXRhL252Y2Yt" + + "c2VsZi1tYW5hZ2VkLWNsaS9yZWZlcmVuY2UvdHJvdWJsZXNob290aW5nLm1kVVQFAAEAps4SIyBU" + + "cm91Ymxlc2hvb3RpbmcKCktub3duIGVycm9ycyDihpIgZGlhZ25vc3RpYyBjb21tYW5kIOKGkiBy" + + "ZW1lZGlhdGlvbi4gS2VlcCBpbiBzeW5jIHdpdGggdGhlIHN0cnVjdHVyZWQgYHBoYXNlX2ZhaWxl" + + "ZGAgZXZlbnRzIHRoZSBDTEkgZW1pdHMgKFJFUS0xNSkg4oCUIGV2ZXJ5IGVudHJ5IGJlbG93IHNo" + + "b3VsZCBtYXAgdG8gYW4gYGVyckNhdGVnb3J5YCBhbmQgYSBgcmVtZWRpYXRpb25gIGFycmF5LgoK" + + "IyMgUHJlLWZsaWdodAoKfCBTeW1wdG9tIHwgQ2F1c2UgfCBSZW1lZGlhdGlvbiB8CnwtLS18LS0t" + + "fC0tLXwKfCBga3ViZWN0bCBub3Qgb24gUEFUSGAgfCBPcGVyYXRvcidzIGAkUEFUSGAgZG9lc24n" + + "dCBpbmNsdWRlIGt1YmVjdGwgfCBJbnN0YWxsIGt1YmVjdGwgMS4yOCs6IGh0dHBzOi8va3ViZXJu" + + "ZXRlcy5pby9kb2NzL3Rhc2tzL3Rvb2xzL2luc3RhbGwta3ViZWN0bC8gfAp8IGBoZWxtZmlsZSBu" + + "b3Qgb24gUEFUSGAgfCBTYW1lIHwgaHR0cHM6Ly9naXRodWIuY29tL2hlbG1maWxlL2hlbG1maWxl" + + "I2luc3RhbGxhdGlvbiB8CnwgYGhlbG0gbm90IG9uIFBBVEhgIHwgU2FtZSB8IGh0dHBzOi8vaGVs" + + "bS5zaC9kb2NzL2ludHJvL2luc3RhbGwvIHwKfCBgR2F0ZXdheSBBUEkgQ1JEcyBub3QgaW5zdGFs" + + "bGVkYCB8IGVudm95LWdhdGV3YXkgcHJlcmVxIG1pc3NpbmcgfCBgaGVsbSBpbnN0YWxsIGVnIG9j" + + "aTovL2RvY2tlci5pby9lbnZveXByb3h5L2dhdGV3YXktaGVsbSAtLW5hbWVzcGFjZT1lbnZveS1n" + + "YXRld2F5LXN5c3RlbSAtLWNyZWF0ZS1uYW1lc3BhY2VgIHwKfCBgZGVmYXVsdCBTdG9yYWdlQ2xh" + + "c3Mgbm90IGF2YWlsYWJsZWAgfCBDbHVzdGVyIGhhcyBubyBkZWZhdWx0IFNDIHwgQW5ub3RhdGUg" + + "b25lOiBga3ViZWN0bCBwYXRjaCBzYyA8bmFtZT4gLXAgJ3sibWV0YWRhdGEiOnsiYW5ub3RhdGlv" + + "bnMiOnsic3RvcmFnZWNsYXNzLmt1YmVybmV0ZXMuaW8vaXMtZGVmYXVsdC1jbGFzcyI6InRydWUi" + + "fX19J2AgfAp8IGBHUFUgb3BlcmF0b3Igbm90IGluc3RhbGxlZGAgKGNvbXB1dGUtcGxhbmUpIHwg" + + "bnZpZGlhIEdQVSBvcGVyYXRvciBtaXNzaW5nIHwgSW5zdGFsbCBwZXIgaHR0cHM6Ly9kb2NzLm52" + + "aWRpYS5jb20vZGF0YWNlbnRlci9jbG91ZC1uYXRpdmUvZ3B1LW9wZXJhdG9yL2xhdGVzdC9pbnN0" + + "YWxsLWdwdS1vcGVyYXRvci5odG1sLCBPUiB1c2UgYGZha2UtZ3B1LW9wZXJhdG9yYCBmb3IgZGV2" + + "IHwKfCBgR1BVIG5vZGUgbGFiZWxzIG1pc3NpbmdgIChjb21wdXRlLXBsYW5lKSB8IE5vZGVzIG5l" + + "ZWQgYG52aWRpYS5jb20vZ3B1LmZhbWlseWAgZXRjLiB8IFNldCBgLS1rM3Mtbm9kZS1sYWJlbCBu" + + "dmlkaWEuY29tL2dwdS5mYW1pbHk9aG9wcGVyQGFnZW50Ok5gIGZvciBrM2QgfAoKIyMgQXV0aAoK" + + "fCBTeW1wdG9tIHwgQ2F1c2UgfCBSZW1lZGlhdGlvbiB8CnwtLS18LS0tfC0tLXwKfCBgYWRtaW4g" + + "dG9rZW4gcmVxdWlyZWRgIChpbml0IG5vdCBydW4pIHwgTm8gYH4vLm52Y2YtY2xpLnN0YXRlYCBh" + + "bmQgYC0tdG9rZW5gIG5vdCBwYXNzZWQgfCBgbnZjZi1jbGkgaW5pdGAgKGludGVyYWN0aXZlKSBv" + + "ciBgLS10b2tlbj0kSldUIC0tbm9uLWludGVyYWN0aXZlYCAoQ0kpIHwKfCBgU2lnbmVkIEpXVCBy" + + "ZWplY3RlZDogQW5vdGhlciBhbGdvcml0aG0gZXhwZWN0ZWQsIG9yIG5vIG1hdGNoaW5nIGtleShz" + + "KSBmb3VuZGAgfCBTdGFsZSBzZXNzaW9uLmpzb24gZnJvbSBhIGRpZmZlcmVudCBjb250cm9sIHBs" + + "YW5lIHwgYHJtIH4vLm52Y2YtY2xpLnN0YXRlYCB0aGVuIGBudmNmLWNsaSBpbml0YCBhZ2FpbiB8" + + "CnwgYDQwMyBtaXNzaW5nIHJlcXVlc3RlZCBhdXRob3JpdGllc2AgKGZ1bmN0aW9uIGludm9rZSkg" + + "fCBBZG1pbiB0b2tlbiBkb2Vzbid0IGhhdmUgYGludm9rZV9mdW5jdGlvbmAgc2NvcGUgfCBgbnZj" + + "Zi1jbGkgYXBpLWtleSBnZW5lcmF0ZSAtLWRlc2NyaXB0aW9uPeKApmAgdGhlbiByZS1ydW4gaW52" + + "b2tlIHwKCiMjIEluc3RhbGwgLyBgdXBgCgp8IFN5bXB0b20gfCBDYXVzZSB8IFJlbWVkaWF0aW9u" + + "IHwKfC0tLXwtLS18LS0tfAp8IEhlbG0gYHRpbWVkIG91dCB3YWl0aW5nIGZvciBjYXNzYW5kcmFg" + + "IHwgQ2Fzc2FuZHJhIFN0YXRlZnVsU2V0IFBWQyBzdHVjayBgUGVuZGluZ2AgfCBDb25maXJtIGRl" + + "ZmF1bHQgU3RvcmFnZUNsYXNzOyBjaGVjayBga3ViZWN0bCBnZXQgcHYscHZjIC1uIGNhc3NhbmRy" + + "YS1zeXN0ZW1gIHwKfCBgSW52YWxpZCBHUFUgJ05DUC5HUFUuSDEwMCcgc3BlY2lmaWVkYCAoZnVu" + + "Y3Rpb24gZGVwbG95KSB8IFdyb25nIGZpZWxkIOKAlCBgZ3B1YCBpcyB0aGUgZmFtaWx5LCBub3Qg" + + "dGhlIFNLVSB8IFVzZSBgImdwdSI6ICJIMTAwImAsIGAiaW5zdGFuY2VUeXBlIjogIk5DUC5HUFUu" + + "SDEwMF8xeCJgIHwKfCBgcmVnaW9uIG11c3QgYmUgcHJvdmlkZWRgIChjbHVzdGVyIHJlZ2lzdGVy" + + "IC8gaW5zdGFsbCAtLWNvbXB1dGUtcGxhbmUpIHwgYC0tcmVnaW9uYCBlbXB0eSArIGBDTFVTVEVS" + + "X1JFR0lPTmAgZW52IGVtcHR5IHwgUGFzcyBgLS1yZWdpb249dXMtd2VzdC0xYCAob3IgYW55IG5v" + + "bi1lbXB0eSB2YWx1ZSkgfAp8IGByZXF1aXJlZEVudiAiTkNBX0lEIiBpcyBub3Qgc2V0YCAoaGVs" + + "bWZpbGUgZXJyb3IgZHVyaW5nIGNvbXB1dGUtcGxhbmUgYXBwbHkpIHwgT2xkZXIgbnZjZi1jbGkg" + + "YmVmb3JlIGNvbW1pdCBgNmFhNTcwNGA7IEV4dHJhRW52IG5vdCBwcm9wYWdhdGluZyBOQ0FfSUQg" + + "fCBVcGdyYWRlIGBudmNmLWNsaWAgdG8gYSByZWxlYXNlIGFmdGVyIGA2YWE1NzA0YCB8CnwgYG52" + + "Y2Etb3BlcmF0b3I6IEltYWdlUHVsbEJhY2tPZmZgIGZvciBgbnZjYS1vcGVyYXRvcjpwc2F0YCB8" + + "IEltYWdlIG5vdCBpbiBjbHVzdGVyIHJlZ2lzdHJ5OyBtdWx0aS1jbHVzdGVyIGJ1aWxkIGlzIGxv" + + "Y2FsIHwgYGszZCBpbWFnZSBpbXBvcnQgbnZjci5pby8uLi4vbnZjYS1vcGVyYXRvcjpwc2F0IC1j" + + "IDxjbHVzdGVyPmAgfAoKIyMgQ29tcHV0ZS1wbGFuZSBydW50aW1lCgp8IFN5bXB0b20gfCBDYXVz" + + "ZSB8IFJlbWVkaWF0aW9uIHwKfC0tLXwtLS18LS0tfAp8IE5WQ0EgYWdlbnQgQ3Jhc2hMb29wQmFj" + + "a09mZiB3aXRoIGBIVFRQIDQwMWAgb24gYC92MS9udmNhL2NsdXN0ZXJzLy4uLi9yZWdpc3RlcmAg" + + "fCBTdGFsZSBgb3V0LzxjbHVzdGVyPi1yZWdpc3Rlci12YWx1ZXMueWFtbGAgZnJvbSBwcmlvciBy" + + "ZWdpc3RlcjsgY2x1c3RlciBJRCBkb2Vzbid0IG1hdGNoIElDTVMgfCBEZWxldGUgdGhlIHN0YWxl" + + "IGZpbGU7IHJlLXJ1biBgbnZjZi1jbGkgc2VsZi1ob3N0ZWQgdXBgIChpZGVtcG90ZW50IHJlZ2lz" + + "dGVyIHdyaXRlcyBhIGZyZXNoIGZpbGUpIHwKfCBgTm8gY2x1c3RlciBmb3VuZCB3aXRoIHZhbGlk" + + "IEpXS1MgZm9yIGNsdXN0ZXIgSUQ6IDxpZD5gIChJQ01TIGxvZykgfCBKV0tTIGluIElDTVMgZG9l" + + "c24ndCBtYXRjaCB3aGF0IGNvbXB1dGUtcGxhbmUgSzhzIGlzIGN1cnJlbnRseSBzaWduaW5nIHwg" + + "YG52Y2YtY2xpIGNsdXN0ZXIgcm90YXRlIC0tY2x1c3Rlci1pZD08aWQ+YCB8CnwgRnVuY3Rpb24g" + + "cG9kIGBJbWFnZVB1bGxCYWNrT2ZmYCBpbiBgbnZjZi1iYWNrZW5kYCB8IEltYWdlLWNyZWRlbnRp" + + "YWwtaGVscGVyIGNvbmZpZyBtaXNzaW5nIG9yIHdyb25nIHwgYGt1YmVjdGwgZGVzY3JpYmUgcG9k" + + "IC1uIG52Y2YtYmFja2VuZCA8cG9kPmA7IGNoZWNrIHRoZSBwdWxsIHNlY3JldCBjb25maWcgfAp8" + + "IEZ1bmN0aW9uIGRlcGxveSBzdHVjayBgREVQTE9ZSU5HYCBmb3IgPjUgbWluIHwgTkFUUyBzdHJl" + + "YW0gaW5pdCBsYWcgKGNvbGQtY2x1c3Rlcikg4oCUIHdhaXQsIG9yIGNoZWNrIE5BVFMgYXV0aC1j" + + "YWxsb3V0IGhlYWx0aCB8IGBrdWJlY3RsIGxvZ3MgLW4gbmF0cy1zeXN0ZW0gLWwgYXBwLmt1YmVy" + + "bmV0ZXMuaW8vbmFtZT1uYXRzLWF1dGgtY2FsbG91dC1zZXJ2aWNlYCB8CgojIyBUYXNrcwoKfCBT" + + "eW1wdG9tIHwgQ2F1c2UgfCBSZW1lZGlhdGlvbiB8CnwtLS18LS0tfC0tLXwKfCBgdGFzayBjcmVh" + + "dGVgIHJldHVybnMgYE1pc3NpbmcgPFRZUEU+IHJlZ2lzdHJ5IGNyZWRlbnRpYWwgZm9yIGhvc3Ru" + + "YW1lYCwgb3Iga2VlcHMgdXNpbmcgYSBwcmV2aW91cyBjcmVkZW50aWFsIHZhbHVlLCBzaG9ydGx5" + + "IGFmdGVyIGByZWdpc3RyeS1jcmVkZW50aWFsIGFkZC91cGRhdGUvZGVsZXRlYCB3aGlsZSBgcmVn" + + "aXN0cnktY3JlZGVudGlhbCBsaXN0YC9gZ2V0YCBhbHJlYWR5IHNob3cgdGhlIG5ldyB2YWx1ZSB8" + + "IEV4cGVjdGVkIHByb3BhZ2F0aW9uIGRlbGF5OiBOVkNUIGNhY2hlcyB0aGUgYWNjb3VudCdzIHJl" + + "Z2lzdHJ5IGNyZWRlbnRpYWxzIHdpdGggYG52Y3QubnZjZi5jYWNoZS10dGxgIChkZWZhdWx0IGBQ" + + "VDVNYCwgYWJvdXQgNSBtaW4pIGFuZCBhcHBsaWVzIHRoZSBjaGFuZ2Ugd2hlbiB0aGF0IGNhY2hl" + + "ZCBjb3B5IHJlZnJlc2hlcyB8IFdhaXQgdXAgdG8gYWJvdXQgNSBtaW4gYW5kIHJldHJ5LCBvciBg" + + "a3ViZWN0bCAtbiBudmNmIHJvbGxvdXQgcmVzdGFydCBkZXBsb3ltZW50L252Y3QtYXBpYCB0byBh" + + "cHBseSBpbW1lZGlhdGVseSB8ClBLBwjzrhOEdBEAAHQRAABQSwMEFAAIAAAAAAAhAAAAAAAAAAAA" + + "AAAAACwACQBkYXRhL252Y2Ytc2VsZi1tYW5hZ2VkLWluc3RhbGxhdGlvbi9TS0lMTC5tZFVUBQAB" + + "AKbOEi0tLQpuYW1lOiBudmNmLXNlbGYtbWFuYWdlZC1pbnN0YWxsYXRpb24KZGVzY3JpcHRpb246" + + "ID4tCiAgSW5zdGFsbCBhbmQgb3BlcmF0ZSBOVkNGIHNlbGYtaG9zdGVkIGNvbnRyb2wtcGxhbmUg" + + "YW5kIHNlcGFyYXRlIGNvbXB1dGUtcGxhbmUKICBzdGFja3MuIENvdmVycyBIZWxtZmlsZSB2YWx1" + + "ZXMgYW5kIENMSSBwcm9maWxlIGluc3RhbGxhdGlvbiBmbG93cywgdGVhcmRvd24sCiAgdmFsdWVz" + + "IG92ZXJyaWRlcywgcHVsbCBzZWNyZXRzLCBhbmQgdHJvdWJsZXNob290aW5nLiBVc2UgZm9yCiAg" + + "bnZjZi1zZWxmLW1hbmFnZWQtc3RhY2ssIG52Y2YtY29tcHV0ZS1wbGFuZS1zdGFjaywgc3BsaXQg" + + "Y29tcHV0ZS1wbGFuZQogIGluc3RhbGxhdGlvbiwgY29udHJvbC1wbGFuZSBpbnN0YWxsYXRpb24s" + + "IENMSS1nZW5lcmF0ZWQgY29udHJvbC1wbGFuZQogIHByb2ZpbGVzLCBIZWxtZmlsZSwgc2VsZi1t" + + "YW5hZ2VkLCBvciBzZWxmLWhvc3RlZCBkZXBsb3ltZW50cy4gRG8gTk9UIHVzZSBmb3IKICBsb2Nh" + + "bCBrM2QgZW52aXJvbm1lbnRzOyB1c2UgdGhlIGxvY2FsIGszZCBkZXZlbG9wbWVudCB3b3JrZmxv" + + "dyBpbnN0ZWFkLgpsaWNlbnNlOiBBcGFjaGUtMi4wCmNvbXBhdGliaWxpdHk6IFJlcXVpcmVzIGhl" + + "bG1maWxlID49IDEuMS4wIDwgMS4yLjAsIGhlbG0gPj0gMy4xMiwgaGVsbS1kaWZmIHBsdWdpbiwg" + + "a3ViZWN0bCBtYXRjaGluZyBjbHVzdGVyIHZlcnNpb24KYXV0aG9yOiAibnZjZi1jb3JlLWVuZyA8" + + "bnZjZi1jb3JlLWVuZ0BleGNoYW5nZS5udmlkaWEuY29tPiIKdmVyc2lvbjogIjEuMC4wIgp0YWdz" + + "OiBbbnZjZiwgc2VsZi1tYW5hZ2VkLCBoZWxtZmlsZSwgc2VsZi1ob3N0ZWQsIGNvbnRyb2wtcGxh" + + "bmUsIGNvbXB1dGUtcGxhbmUsIGNsaS1wcm9maWxlLCBpbnN0YWxsYXRpb24sIGRlcGxveW1lbnQs" + + "IHB1bGwtc2VjcmV0c10KdG9vbHM6IFtTaGVsbCwgUmVhZCwgRWRpdCwgR3JlcCwgR2xvYl0KbWV0" + + "YWRhdGE6CiAgaW50ZXJuYWw6IGZhbHNlCiAgYXV0aG9yOiAibnZjZi1jb3JlLWVuZyA8bnZjZi1j" + + "b3JlLWVuZ0BleGNoYW5nZS5udmlkaWEuY29tPiIKICB2ZXJzaW9uOiAiMS4wIgogIHRhZ3M6IFtu" + + "dmNmLCBzZWxmLW1hbmFnZWQsIGhlbG1maWxlLCBzZWxmLWhvc3RlZCwgY29udHJvbC1wbGFuZSwg" + + "Y29tcHV0ZS1wbGFuZSwgY2xpLXByb2ZpbGUsIGluc3RhbGxhdGlvbiwgZGVwbG95bWVudCwgcHVs" + + "bC1zZWNyZXRzXQogIGxhbmd1YWdlczogW2Jhc2gsIHlhbWxdCiAgZnJhbWV3b3JrczogW2hlbG1m" + + "aWxlLCBoZWxtLCBrdWJlY3RsXQogIGRvbWFpbjogY2xvdWQtaW5mcmFzdHJ1Y3R1cmUKLS0tCgoj" + + "IE5WQ0YgU2VsZi1NYW5hZ2VkIFN0YWNrIE9wZXJhdGlvbnMKCk9wZXJhdGlvbmFsIGd1aWRlIGZv" + + "ciBtYXRjaGluZyBOVkNGIGNvbnRyb2wtcGxhbmUgYW5kIGNvbXB1dGUtcGxhbmUgSGVsbWZpbGUg" + + "YnVuZGxlcy4KCiMjIEluc3RydWN0aW9ucwoKVXNlIHRoaXMgc2tpbGwgZm9yIGluc3RhbGwsIHVw" + + "Z3JhZGUsIG9yIHRlYXJkb3duIHdvcmsgaW4gbWF0Y2hpbmcgYG52Y2Ytc2VsZi1tYW5hZ2VkLXN0" + + "YWNrYCBhbmQgYG52Y2YtY29tcHV0ZS1wbGFuZS1zdGFja2AgYnVuZGxlczsga2VlcCBIZWxtZmls" + + "ZSB2YWx1ZXMgYW5kIENMSSBwcm9maWxlIGhhbmRvZmZzIHNlcGFyYXRlLiBGb3IgYGZ1bmN0aW9u" + + "VHlwZTogIkxMTSJgLCByZWFkIFtMTE0gRnVuY3Rpb24gRW5hYmxlbWVudF0ocmVmZXJlbmNlcy9o" + + "ZWxtZmlsZS1zdHJ1Y3R1cmUubWQjbGxtLWZ1bmN0aW9uLWVuYWJsZW1lbnQpLgoKIyMgUHJlcmVx" + + "dWlzaXRlcwoKQXNrIGZvciB0aGUgZXh0cmFjdGVkIGBudmNmLXNlbGYtbWFuYWdlZC1zdGFja2Ag" + + "cGF0aC4gRm9yIHNwbGl0IGluc3RhbGxhdGlvbiwKYWxzbyByZXF1aXJlIHRoZSBtYXRjaGluZy12" + + "ZXJzaW9uIGBudmNmLWNvbXB1dGUtcGxhbmUtc3RhY2tgIHBhdGguIFZlcmlmeSBib3RoOgoKYGBg" + + "YmFzaApscyA8Y29udHJvbC1wbGFuZS1zdGFjaz4vaGVsbWZpbGUuZC8gPGNvbnRyb2wtcGxhbmUt" + + "c3RhY2s+L2Vudmlyb25tZW50cy8gPGNvbnRyb2wtcGxhbmUtc3RhY2s+L3NlY3JldHMvIDxjb250" + + "cm9sLXBsYW5lLXN0YWNrPi9nbG9iYWwueWFtbC5nb3RtcGwKbHMgPGNvbXB1dGUtcGxhbmUtc3Rh" + + "Y2s+L2hlbG1maWxlLmQvIDxjb21wdXRlLXBsYW5lLXN0YWNrPi9lbnZpcm9ubWVudHMvIDxjb21w" + + "dXRlLXBsYW5lLXN0YWNrPi9nbG9iYWwueWFtbC5nb3RtcGwKYGBgCgpJZiBlaXRoZXIgZGlyZWN0" + + "b3J5IGlzIG1pc3NpbmcsIGRvd25sb2FkIG1hdGNoaW5nIGJ1bmRsZSB2ZXJzaW9ucyBmcm9tIE5H" + + "QzoKCmBgYGJhc2gKbmdjIHJlZ2lzdHJ5IHJlc291cmNlIGRvd25sb2FkLXZlcnNpb24gPG9yZz4v" + + "bnZjZi1zZWxmLW1hbmFnZWQtc3RhY2s6PHZlcnNpb24+Cm5nYyByZWdpc3RyeSByZXNvdXJjZSBk" + + "b3dubG9hZC12ZXJzaW9uIDxvcmc+L252Y2YtY29tcHV0ZS1wbGFuZS1zdGFjazo8dmVyc2lvbj4K" + + "YGBgCgpDb250cm9sLXBsYW5lIGNvbW1hbmRzIGJlbG93IGFzc3VtZSB0aGUgY29udHJvbC1wbGFu" + + "ZSBidW5kbGUgcm9vdC4gU3BsaXQtZmxvdwpjb21tYW5kcyBhbmQgcm9vdCBzdWJzdGl0dXRpb24g" + + "YXJlIGluCltTcGxpdCBDb21wdXRlLVBsYW5lIEluc3RhbGxhdGlvbl0ocmVmZXJlbmNlcy9jb21w" + + "dXRlLXBsYW5lLWluc3RhbGxhdGlvbi5tZCkuCgojIyBCZWZvcmUgWW91IFN0YXJ0CgpWZXJpZnkg" + + "dG9vbGluZyBhbmQgY29udGV4dCBiZWZvcmUgYW55IG9wZXJhdGlvbjoKCmBgYGJhc2gKaGVsbWZp" + + "bGUgLS12ZXJzaW9uICAgIyBNdXN0IGJlIDEuMS54ICgxLjIuMCByZW1vdmVkIHNlcXVlbnRpYWwg" + + "bW9kZSkKaGVsbSB2ZXJzaW9uICAgICAgICAgIyBNdXN0IGJlID49IDMuMTIKaGVsbSBwbHVnaW4g" + + "bGlzdCAgICAgIyBNdXN0IGluY2x1ZGUgaGVsbS1kaWZmID49IDMuMTEKa3ViZWN0bCB2ZXJzaW9u" + + "ICAgICAgIyBDbGllbnQgbXVzdCBiZSB3aXRoaW4gMSBtaW5vciB2ZXJzaW9uIG9mIGNsdXN0ZXIK" + + "YGBgCgpDb250cm9sLXBsYW5lIGNvbW1hbmRzIHJ1biBmcm9tIHRoZSBleHRyYWN0ZWQgYG52Y2Yt" + + "c2VsZi1tYW5hZ2VkLXN0YWNrL2Agcm9vdDoKCmBgYGJhc2gKY2QgcGF0aC90by9udmNmLXNlbGYt" + + "bWFuYWdlZC1zdGFjawpscyBoZWxtZmlsZS5kLyBlbnZpcm9ubWVudHMvIHNlY3JldHMvIGdsb2Jh" + + "bC55YW1sLmdvdG1wbApgYGAKCklkZW50aWZ5IHRoZSBlbnZpcm9ubWVudCBmcm9tIGBlbnZpcm9u" + + "bWVudHMvPG5hbWU+LnlhbWxgIGFuZApgc2VjcmV0cy88bmFtZT4tc2VjcmV0cy55YW1sYDsgZm9y" + + "IEVLUywgdXNlIHRoZSBjYW5vbmljYWwKW0NTUCBFbmQtdG8tRW5kIEV4YW1wbGVdKGh0dHBzOi8v" + + "ZG9jcy5udmlkaWEuY29tL252Y2YvdjAuNi4wLXJjL2NzcC1lbmQtdG8tZW5kLWV4YW1wbGUpLgoK" + + "IyMgSG93IFZhbHVlcyBGbG93CgpVbmRlcnN0YW5kaW5nIHZhbHVlIHByZWNlZGVuY2UgcHJldmVu" + + "dHMgdGhlIG1vc3QgY29tbW9uIGNvbmZpZ3VyYXRpb24gbWlzdGFrZXMuCgpgYGAKZW52aXJvbm1l" + + "bnRzL2Jhc2UueWFtbCAgICAgICAgICAoZGVmYXVsdHMpCiAgICAtPiBtZXJnZWQgd2l0aAplbnZp" + + "cm9ubWVudHMvPGVudj4ueWFtbCAgICAgICAgICh5b3VyIG92ZXJyaWRlcykKICAgIC0+IGNvbnN1" + + "bWVkIGJ5Cmdsb2JhbC55YW1sLmdvdG1wbCAgICAgICAgICAgICAgKEdvIHRlbXBsYXRlLCBjb25z" + + "dHJ1Y3RzIHBlci1jaGFydCB2YWx1ZXMpCiAgICAtPiBjb25zdW1lZCBieQpzZWNyZXRzLzxlbnY+" + + "LXNlY3JldHMueWFtbCAgICAgIChzZW5zaXRpdmUgdmFsdWVzKQogICAgLT4gb3ZlcnJpZGRlbiBi" + + "eQpyZWxlYXNlIGlubGluZSB2YWx1ZXM6IGJsb2NrcyAgIChoaWdoZXN0IHByZWNlZGVuY2UpCmBg" + + "YAoKQ3JpdGljYWw6IGBnbG9iYWwueWFtbC5nb3RtcGxgIG9ubHkgcGFzc2VzIHRocm91Z2ggc3Bl" + + "Y2lmaWMga2V5cyB0byBlYWNoIGNoYXJ0IChpbWFnZSByZWdpc3RyaWVzLCBub2RlIHNlbGVjdG9y" + + "cywgc3RvcmFnZSwgcmVwbGljYSBjb3VudHMpLiBTZXR0aW5nIGFuIGFyYml0cmFyeSBjaGFydCB2" + + "YWx1ZSBpbiB0aGUgZW52aXJvbm1lbnQgZmlsZSB3aWxsIGJlIHNpbGVudGx5IGlnbm9yZWQgaWYg" + + "YGdsb2JhbC55YW1sLmdvdG1wbGAgZG9lcyBub3QgcHJvcGFnYXRlIGl0LgoKVG8gb3ZlcnJpZGUg" + + "YXJiaXRyYXJ5IGNoYXJ0IHZhbHVlcywgdXNlIGEgaGVsbWZpbGUgcmVsZWFzZSBgdmFsdWVzOmAg" + + "YmxvY2suIFNlZSBbT3ZlcnJpZGluZyBIZWxtIENoYXJ0IFZhbHVlc10oI292ZXJyaWRpbmctaGVs" + + "bS1jaGFydC12YWx1ZXMpLgoKIyMgQ2xlYW4gSW5zdGFsbGF0aW9uCgojIyMgMS4gQ3JlYXRlIG5h" + + "bWVzcGFjZXMgYW5kIGltYWdlIHB1bGwgc2VjcmV0cyAoaWYgdXNpbmcgYSBwcml2YXRlIHJlZ2lz" + + "dHJ5KQoKYGBgYmFzaApmb3IgbnMgaW4gY2Fzc2FuZHJhLXN5c3RlbSBuYXRzLXN5c3RlbSBudmNm" + + "IGFwaS1rZXlzIGVzcyBzaXMgdmF1bHQtc3lzdGVtIGNlcnQtbWFuYWdlcjsgZG8KICBrdWJlY3Rs" + + "IGNyZWF0ZSBuYW1lc3BhY2UgIiRucyIgLS1kcnktcnVuPWNsaWVudCAtbyB5YW1sIHwga3ViZWN0" + + "bCBhcHBseSAtZiAtCmRvbmUKCiMgT25seSBpZiBwdWxsaW5nIGZyb20gYSBwcml2YXRlIHJlZ2lz" + + "dHJ5IChlLmcuLCBOR0MgbnZjci5pbykKZXhwb3J0IE5HQ19BUElfS0VZPSI8eW91ci1rZXk+Igpm" + + "b3IgbnMgaW4gY2Fzc2FuZHJhLXN5c3RlbSBuYXRzLXN5c3RlbSBudmNmIGFwaS1rZXlzIGVzcyBz" + + "aXMgdmF1bHQtc3lzdGVtIGNlcnQtbWFuYWdlcjsgZG8KICBrdWJlY3RsIGNyZWF0ZSBzZWNyZXQg" + + "ZG9ja2VyLXJlZ2lzdHJ5IG52Y3ItY3JlZHMgXAogICAgLS1kb2NrZXItc2VydmVyPW52Y3IuaW8g" + + "XAogICAgLS1kb2NrZXItdXNlcm5hbWU9JyRvYXV0aHRva2VuJyBcCiAgICAtLWRvY2tlci1wYXNz" + + "d29yZD0iJE5HQ19BUElfS0VZIiBcCiAgICAtLW5hbWVzcGFjZT0iJG5zIiBcCiAgICAtLWRyeS1y" + + "dW49Y2xpZW50IC1vIHlhbWwgfCBrdWJlY3RsIGFwcGx5IC1mIC0KZG9uZQpgYGAKCklmIHVzaW5n" + + "IHB1bGwgc2VjcmV0cywgeW91IG11c3QgYWxzbyBjb25maWd1cmUgZWFjaCBoZWxtZmlsZSByZWxl" + + "YXNlIHRvIHJlZmVyZW5jZSB0aGVtLiBTZWUgW0ltYWdlIFB1bGwgU2VjcmV0c10oI2ltYWdlLXB1" + + "bGwtc2VjcmV0cykuCgojIyMgMi4gQXV0aGVudGljYXRlIGhlbG0gdG8geW91ciBjaGFydCByZWdp" + + "c3RyeQoKQm90aCBgZG9ja2VyIGxvZ2luYCBBTkQgYGhlbG0gcmVnaXN0cnkgbG9naW5gIGFyZSBy" + + "ZXF1aXJlZCBmb3IgTkdDLiBIZWxtZmlsZSB1c2VzIGhlbG0gKG5vdCBkb2NrZXIpIHRvIHB1bGwg" + + "T0NJIGNoYXJ0cywgc28gdGhlIGhlbG0gY3JlZGVudGlhbCBzdG9yZSBtdXN0IGJlIGF1dGhlbnRp" + + "Y2F0ZWQgc2VwYXJhdGVseS4KCmBgYGJhc2gKIyBOR0MgLS0gYm90aCBjb21tYW5kcyBhcmUgcmVx" + + "dWlyZWQKZG9ja2VyIGxvZ2luIG52Y3IuaW8gLXUgJyRvYXV0aHRva2VuJyAtcCAiJE5HQ19BUElf" + + "S0VZIgpoZWxtIHJlZ2lzdHJ5IGxvZ2luIG52Y3IuaW8gLXUgJyRvYXV0aHRva2VuJyAtcCAiJE5H" + + "Q19BUElfS0VZIgoKIyBFQ1IKYXdzIGVjciBnZXQtbG9naW4tcGFzc3dvcmQgLS1yZWdpb24gPHJl" + + "Z2lvbj4gfCBcCiAgaGVsbSByZWdpc3RyeSBsb2dpbiAtLXVzZXJuYW1lIEFXUyAtLXBhc3N3b3Jk" + + "LXN0ZGluIDxhY2NvdW50Pi5ka3IuZWNyLjxyZWdpb24+LmFtYXpvbmF3cy5jb20KYGBgCgo+IE5v" + + "dGU6IGBoZWxtIHJlZ2lzdHJ5IGxvZ2luYCBrZWVwcyBvbmx5IHRoZSBsYXN0IGxvZ2luIHBlciBo" + + "b3N0IChtdWx0aS1vcmcgZ290Y2hhKS4KPiBUaGUgc3RhY2sgYW5kIHRoZSBjYWNoZXMgc3BhbiBz" + + "ZXZlcmFsIE5HQyBvcmdzIHRoYXQgbmVlZCBkaWZmZXJlbnQga2V5cywgYnV0IHRoZXkgYWxsCj4g" + + "bGl2ZSB1bmRlciB0aGUgb25lIGhvc3QgYG52Y3IuaW9gLiBBIHNlY29uZCBgaGVsbSByZWdpc3Ry" + + "eSBsb2dpbiBudmNyLmlvYCAob3IKPiBgZG9ja2VyIGxvZ2luYCkgd2l0aCBhIGRpZmZlcmVudCBr" + + "ZXkgc2lsZW50bHkgb3ZlcndyaXRlcyB0aGUgZmlyc3QsIHNvIHB1bGxzIGZvciB0aGUKPiBmaXJz" + + "dCBvcmcgdGhlbiBmYWlsIHdpdGggYSBtaXNsZWFkaW5nIGA0MDMgQWNjZXNzIERlbmllZGAgKG5v" + + "dCBhIDQwMTogdGhlIGF1dGgKPiBzdWNjZWVkZWQsIGl0J3MgdGhlIHdyb25nLW9yZyBrZXkpLiBJ" + + "ZiB5b3UgcHVsbCBjaGFydHMvaW1hZ2VzIGZyb20gbW9yZSB0aGFuIG9uZSBvcmcsCj4gZWl0aGVy" + + "IHJlLXJ1biB0aGUgbG9naW4gd2l0aCB0aGUgY29ycmVjdCBrZXkgaW1tZWRpYXRlbHkgYmVmb3Jl" + + "IGVhY2ggcHVsbCwgb3IgcGFzcwo+IGAtLXVzZXJuYW1lICckb2F1dGh0b2tlbicgLS1wYXNzd29y" + + "ZCA8a2V5PmAgcGVyIGBoZWxtIHB1bGxgIGludm9jYXRpb24gaW5zdGVhZCBvZiByZWx5aW5nCj4g" + + "b24gdGhlIHN0b3JlZCBsb2dpbi4gKFB1bGxpbmcgZXZlcnl0aGluZyBmcm9tIGEgc2luZ2xlIHJl" + + "Z2lzdHJ5IG1pcnJvciBhdm9pZHMgdGhpcwo+IGVudGlyZWx5LikKCiMjIyAyYi4gKFJlY29tbWVu" + + "ZGVkKSBQdWxsIGZyb20gYSByZWdpc3RyeSB0aGUgY2x1c3RlciBhdXRoZW50aWNhdGVzIHRvIGF1" + + "dG9tYXRpY2FsbHkKCklmIHlvdSBtaXJyb3IgdGhlIE5WQ0YgaW1hZ2VzIGludG8gYSByZWdpc3Ry" + + "eSB0aGF0IHRoZSBjbHVzdGVyIGNhbiBwdWxsIGZyb20gd2l0aG91dCBhbgpleHBsaWNpdCBpbWFn" + + "ZSBwdWxsIHNlY3JldCAoZm9yIGV4YW1wbGUsIGEgcmVnaXN0cnkgd2hlcmUgdGhlIG5vZGUgb3Ig" + + "d29ya2xvYWQgaWRlbnRpdHkgaXMKZ3JhbnRlZCBwdWxsIGFjY2VzcyBhdXRvbWF0aWNhbGx5KSwg" + + "cG9pbnQgdGhlIHN0YWNrIGF0IGl0IGFuZCBza2lwIHRoZSBjcmVkZW50aWFsIHN0ZXBzCmFib3Zl" + + "LgoKMS4gUG9pbnQgdGhlIHN0YWNrIGF0IHRoZSBtaXJyb3IgaW4gYGVudmlyb25tZW50cy88ZW52" + + "Pi55YW1sYDoKCiAgIGBgYHlhbWwKICAgZ2xvYmFsOgogICAgIGltYWdlOgogICAgICAgcmVnaXN0" + + "cnk6IDx5b3VyLXJlZ2lzdHJ5PiAgICAgICAgICAgICMgZS5nLiByZWdpc3RyeS5leGFtcGxlLmNv" + + "bQogICAgICAgcmVwb3NpdG9yeTogPG1pcnJvci1zdWItcGF0aD4KICAgICBoZWxtOgogICAgICAg" + + "c291cmNlczogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAjIG9ubHkgaWYgeW91IGFsc28g" + + "bWlycm9yZWQgdGhlIGhlbG0gY2hhcnRzCiAgICAgICAgIHJlZ2lzdHJ5OiA8eW91ci1yZWdpc3Ry" + + "eT4KICAgICAgICAgcmVwb3NpdG9yeTogPG1pcnJvci1zdWItcGF0aD4KICAgYGBgCgogICA+IFRo" + + "ZSBtYW5pZmVzdCBoYXMgYSBtaXggb2YgT0NJIGFuZCBub24tT0NJIGFydGlmYWN0cywgc28gY29u" + + "dmVydCBub24tT0NJIGNoYXJ0cyBiZWZvcmUKICAgPiBtaXJyb3JpbmcuIENvbnRhaW5lciBpbWFn" + + "ZXMgKGBudmNyLmlvLy4uLmApIGFyZSBhbHJlYWR5IE9DSSBhbmQgbWlycm9yIGFzLWlzLiBTb21l" + + "IEhlbG0KICAgPiBjaGFydHMsIHRob3VnaCwgYXJlIHB1Ymxpc2hlZCB0byBhbiBgaHR0cHM6Ly9g" + + "IEhlbG0gcmVwb3NpdG9yeSAoZm9yIGV4YW1wbGUKICAgPiBgaGVsbS5uZ2MubnZpZGlhLmNvbWAp" + + "LiBUaG9zZSBhcmUgbm90IE9DSSBhbmQgY2Fubm90IGJlIHJlc29sdmVkIGJ5IGBnbG9iYWwuaGVs" + + "bS5zb3VyY2VzYAogICA+IChPQ0kpIG9yIG1pcnJvcmVkIGRpcmVjdGx5LiBCZWZvcmUgcG9pbnRp" + + "bmcgdGhlIHN0YWNrIGF0IHlvdXIgbWlycm9yLCBjb252ZXJ0IGVhY2gKICAgPiBgaHR0cHM6Ly9g" + + "IGNoYXJ0IHRvIE9DSTogYGhlbG0gcmVwbyBhZGRgL2BoZWxtIHB1bGxgIHRoZSBgLnRnemAsIHRo" + + "ZW4KICAgPiBgaGVsbSBwdXNoIDxjaGFydD4udGd6IG9jaTovLzx5b3VyLXJlZ2lzdHJ5Pi88bWly" + + "cm9yLXN1Yi1wYXRoPmAuIE9ubHkgT0NJIGNoYXJ0cyBjYW4gbGl2ZQogICA+IHVuZGVyIGBnbG9i" + + "YWwuaGVsbS5zb3VyY2VzYC4KCjIuIFNraXAgdGhlIGNyZWRlbnRpYWwgc3RlcHMgYWJvdmUuIFdo" + + "ZW4gdGhlIGNsdXN0ZXIgYXV0aGVudGljYXRlcyB0byB0aGUgcmVnaXN0cnkKICAgYXV0b21hdGlj" + + "YWxseSAodGhlIG5vZGUgb3Igd29ya2xvYWQgaWRlbnRpdHkgaGFzIHB1bGwgYWNjZXNzKSwgdGhl" + + "IHB1bGwgbmVlZHMgbm8KICAgS3ViZXJuZXRlcyBzZWNyZXQsIHNvIHlvdSBkbyBub3QgbmVlZDog" + + "dGhlIHBlci1uYW1lc3BhY2UgYG52Y3ItY3JlZHNgIGZyb20gc3RlcCAxCiAgIChzdGlsbCBjcmVh" + + "dGUgdGhlIG5hbWVzcGFjZXMsIGp1c3Qgbm90IHRoZSBzZWNyZXQpLCB0aGUgYGdsb2JhbC5pbWFn" + + "ZVB1bGxTZWNyZXRzYCBlbnRyeSwKICAgb3IgdGhlIGBkb2NrZXIgbG9naW5gL2BoZWxtIHJlZ2lz" + + "dHJ5IGxvZ2luIG52Y3IuaW9gIGZyb20gc3RlcCAyLgoKICAgPiBPbmUgcmVzaWR1YWwgY3JlZGVu" + + "dGlhbDogbnZjZi1hcGkgc3RpbGwgdmFsaWRhdGVzIHRoZSB1c2VyIGZ1bmN0aW9uIGltYWdlIGF0" + + "CiAgID4gYGZ1bmN0aW9uIGNyZWF0ZWAgdmlhIHRoZSBhY2NvdW50IHJlZ2lzdHJ5IGNyZWRlbnRp" + + "YWwsIHNvIHRoYXQgY3JlZGVudGlhbCBtdXN0IHBvaW50IGF0CiAgID4gd2hpY2hldmVyIHJlZ2lz" + + "dHJ5IGhvbGRzIHRoZSB1c2VyIGltYWdlIChzZXQgaXQgdG8geW91ciBtaXJyb3IgaWYgdGhlIGlt" + + "YWdlIGlzIG1pcnJvcmVkCiAgID4gdGhlcmUpLgoKIyMjIDMuIFNldCB0aGUgcm91dGUgZG9tYWlu" + + "CgpgZ2xvYmFsLmRvbWFpbmAgc2V0cyB0aGUgaG9zdG5hbWUgc3VmZml4IGZvciByb3V0ZXMgc3Vj" + + "aCBhcyBgYXBpLjxkb21haW4+YC4gSXQgZG9lcyBub3QgY29uZmlndXJlIHRoZSBHYXRld2F5IG9y" + + "IGl0cyBsb2FkIGJhbGFuY2VyLiBRdWVyeSB0aGUgZXhhY3QgZXhpc3RpbmcgR2F0ZXdheToKCmBg" + + "YGJhc2gKR0FURVdBWV9BRERSRVNTPSQoa3ViZWN0bCBnZXQgZ2F0ZXdheSA8Z2F0ZXdheS1uYW1l" + + "PiAtbiA8Z2F0ZXdheS1uYW1lc3BhY2U+IC1vIGpzb25wYXRoPSd7LnN0YXR1cy5hZGRyZXNzZXNb" + + "MF0udmFsdWV9JykKdGVzdCAtbiAiJEdBVEVXQVlfQUREUkVTUyIKYGBgCgpUaGUgYWRkcmVzcyBt" + + "YXkgYmUgYSBob3N0bmFtZSBvciBJUC4gQ2xvdWQgcHJvdmlkZXIgYW5kIEdhdGV3YXkgY29uZmln" + + "dXJhdGlvbiBkZXRlcm1pbmUgdGhlIGxvYWQgYmFsYW5jZXIgdHlwZSBhbmQgYWRkcmVzcyBmb3Jt" + + "YXQuIFRoZSBzZWxmLW1hbmFnZWQgc3RhY2sgZG9lcyBub3Qgc2VsZWN0IGVpdGhlci4KCkZvciB0" + + "ZW1wb3JhcnkgdGVzdGluZyB3aXRob3V0IEROUywgdXNlIGEgc3RhYmxlIHJlc2VydmVkIHN1ZmZp" + + "eCBzdWNoIGFzIGBnbG9iYWwuZG9tYWluOiAibnZjZi50ZXN0ImAsIGNvbm5lY3QgdG8gYEdBVEVX" + + "QVlfQUREUkVTU2AsIGFuZCBzZW5kIGBIb3N0OiBhcGkubnZjZi50ZXN0YC4gRm9yIHByb2R1Y3Rp" + + "b24sIHVzZSB5b3VyIGJhc2UgRE5TIGRvbWFpbiBhbmQgcG9pbnQgaXRzIHJvdXRlIHJlY29yZHMg" + + "dG8gYEdBVEVXQVlfQUREUkVTU2AuIElmIHRoZSBlbmRwb2ludCBsYXRlciBjaGFuZ2VzLCBrZWVw" + + "IGBnbG9iYWwuZG9tYWluYCBzdGFibGUgYW5kIHVwZGF0ZSBvbmx5IEROUyBvciB0aGUgY2xpZW50" + + "IGRlc3RpbmF0aW9uLiBTZWUgRXhhbXBsZSA0IGluIFtleGFtcGxlcy5tZF0oZXhhbXBsZXMubWQp" + + "LgoKIyMjIDQuIFByZXZpZXcgYW5kIGRlcGxveQoKYGBgYmFzaApIRUxNRklMRV9FTlY9PGVudi1u" + + "YW1lPiBoZWxtZmlsZSB0ZW1wbGF0ZSAgICMgUHJldmlldyByZW5kZXJlZCBtYW5pZmVzdHMKSEVM" + + "TUZJTEVfRU5WPTxlbnYtbmFtZT4gaGVsbWZpbGUgc3luYyAgICAgICAjIERlcGxveQpgYGAKCj4g" + + "U2V0IEJPVEggQ2Fzc2FuZHJhIHBhc3N3b3JkcyBpbiB0aGUgc2VjcmV0cyBmaWxlLiBUaGUgc2Vj" + + "cmV0cyBmaWxlIGRvY3VtZW50cwo+IGBERUZBVUxUX0NBU1NBTkRSQV9QQVNTV09SRGAsIGJ1dCB0" + + "aGUgY2Fzc2FuZHJhIGNoYXJ0IGhhcyBhIHNlY29uZCBjcmVkZW50aWFsLAo+IGBjYXNzYW5kcmEu" + + "c2VydmljZVJvbGVQYXNzd29yZGAsIHRoYXQgZGVmYXVsdHMgdG8gYGNoQG5nM20zYC4gSWYgeW91" + + "IHNldCBvbmx5Cj4gYERFRkFVTFRfQ0FTU0FORFJBX1BBU1NXT1JEYCwgdGhlIHNlcnZpY2Ugcm9s" + + "ZSBrZWVwcyB0aGF0IGRlZmF1bHQgYW5kIGV2ZXJ5IERCLWJhY2tlZAo+IHNlcnZpY2UgY3Jhc2gt" + + "bG9vcHMgd2l0aCBgQmFkIGNyZWRlbnRpYWxzYCBvbmNlIGl0IHRyaWVzIHRvIGF1dGhlbnRpY2F0" + + "ZS4gU2V0Cj4gYGNhc3NhbmRyYS5zZXJ2aWNlUm9sZVBhc3N3b3JkYCB0byB0aGUgc2FtZSB2YWx1" + + "ZSBhcyBgREVGQVVMVF9DQVNTQU5EUkFfUEFTU1dPUkRgLgoKIyMjIDUuIERlcGxveW1lbnQgcGhh" + + "c2VzCgpIZWxtZmlsZSBkZXBsb3lzIGluIG9yZGVyIHdpdGggZGVwZW5kZW5jaWVzOgoKfCBQaGFz" + + "ZSB8IFNlbGVjdG9yIHwgU2VydmljZXMgfCBXYWl0IHRpbWUgfAp8LS0tLS0tLXwtLS0tLS0tLS0t" + + "fC0tLS0tLS0tLS18LS0tLS0tLS0tLS18CnwgMSB8IGByZWxlYXNlLWdyb3VwPWRlcGVuZGVuY2ll" + + "c2AgfCBOQVRTLCBPcGVuQmFvLCBDYXNzYW5kcmEgfCA1LTEwIG1pbiB8CnwgMiB8IGByZWxlYXNl" + + "LWdyb3VwPXNlcnZpY2VzYCB8IEFQSSwgU0lTLCBFU1MsIGludm9jYXRpb24sIGdycGMtcHJveHks" + + "IG5vdGFyeSwgYXBpLWtleXMsIG9wdGlvbmFsIExMTSBnYXRld2F5L3JvdXRlciwgb3B0aW9uYWwg" + + "VmFuaXR5IEdhdGV3YXksIE5WQ0YgVUkgd2hlbiB0aGUgc3RhY2sgcGFja2FnZSBpbmNsdWRlcyB0" + + "aGUgYWRkb24gfCA1LTEwIG1pbiB8CnwgMyB8IGByZWxlYXNlLWdyb3VwPWluZ3Jlc3NgIHwgR2F0" + + "ZXdheSByb3V0ZXMgfCAxLTIgbWluIHwKfCA0IHwgYHJlbGVhc2UtZ3JvdXA9b2JzZXJ2YWJpbGl0" + + "eWAgfCBPYnNlcnZhYmlsaXR5IHN0YWNrIChpZiBlbmFibGVkKSB8IDEtMiBtaW4gfAoKTW9uaXRv" + + "ciBpbiBhIHNlcGFyYXRlIHRlcm1pbmFsOgoKYGBgYmFzaAprdWJlY3RsIGdldCBwb2RzIC1BIC13" + + "CmBgYAoKIyMjIDYuIEVuYWJsZSBWYW5pdHkgR2F0ZXdheSAob3B0aW9uYWwpCgpWYW5pdHkgR2F0" + + "ZXdheSBpcyBkaXNhYmxlZCBieSBkZWZhdWx0IGFuZCBpcyBvbmx5IG5lZWRlZCBmb3IgY3VzdG9t" + + "ZXItZmFjaW5nCmhvc3RuYW1lcyBvciBwYXRoIG1hcHBpbmdzIGluIGZyb250IG9mIHRoZSBzdGFu" + + "ZGFyZCBOVkNGIEFQSSBhbmQgaW52b2NhdGlvbgpyb3V0ZXMuIEl0IGlzIGF2YWlsYWJsZSBvbmx5" + + "IGluIHN0YWNrIHBhY2thZ2VzIHRoYXQgaW5jbHVkZSB0aGUgVmFuaXR5IEdhdGV3YXkKYWRkb24u" + + "IElmIHRoZSBleHRyYWN0ZWQgc3RhY2sgcGFja2FnZSBkb2VzIG5vdCBjb250YWluIGEgYHZhbml0" + + "eS1nYXRld2F5YApyZWxlYXNlIGFuZCBgdmFuaXR5R2F0ZXdheWAgcm91dGUgdmFsdWVzLCBza2lw" + + "IHRoZXNlIGNvbW1hbmRzIGFuZCB1c2UgYSBuZXdlcgpzdGFjayBwYWNrYWdlIHRoYXQgaW5jbHVk" + + "ZXMgdGhlbS4KCklmIHRoZSBzdGFjayBwYWNrYWdlIGluY2x1ZGVzIHRoZSBhZGRvbiwgZW5hYmxl" + + "IGl0IGluCmBlbnZpcm9ubWVudHMvPGVudi1uYW1lPi55YW1sYDoKCmBgYHlhbWwKYWRkb25zOgog" + + "IHZhbml0eUdhdGV3YXk6CiAgICBlbmFibGVkOiB0cnVlCiAgICBtYXBwaW5nQ29uZmlnOiB7fQpg" + + "YGAKClRoZSBkZWZhdWx0IHJvdXRlIGhvc3QgaXMgYHZhbml0eS48ZG9tYWluPmAgYW5kIHRoZSBi" + + "YWNrZW5kIGlzCmB2YW5pdHktZ2F0ZXdheS5udmNmOjgwODBgLiBQdXQgZGVwbG95bWVudC1zcGVj" + + "aWZpYyBob3N0IGFuZCBwYXRoIG1hcHBpbmdzIHVuZGVyCmBhZGRvbnMudmFuaXR5R2F0ZXdheS5t" + + "YXBwaW5nQ29uZmlnYC4gSWYgeW91IG5lZWQgY3VzdG9tIHZhbml0eSBob3N0cyBpbnN0ZWFkIG9m" + + "CmB2YW5pdHkuPGRvbWFpbj5gLCB1c2UgdGhlIHJvdXRlIGhvc3RuYW1lIG92ZXJyaWRlcyBzdXBw" + + "b3J0ZWQgYnkgdGhlIHN0YWNrCnBhY2thZ2UgYW5kIGNyZWF0ZSBtYXRjaGluZyBETlMgcmVjb3Jk" + + "cy4KCkFmdGVyIGNvbmZpcm1pbmcgdGhlIHBhY2thZ2UgaW5jbHVkZXMgdGhlIGB2YW5pdHktZ2F0" + + "ZXdheWAgcmVsZWFzZSwgcHJldmlldyBhbmQKYXBwbHkgdGhlIHNlcnZpY2UgYW5kIHJvdXRlOgoK" + + "YGBgYmFzaApIRUxNRklMRV9FTlY9PGVudi1uYW1lPiBoZWxtZmlsZSAtLXNlbGVjdG9yIG5hbWU9" + + "dmFuaXR5LWdhdGV3YXkgdGVtcGxhdGUKSEVMTUZJTEVfRU5WPTxlbnYtbmFtZT4gaGVsbWZpbGUg" + + "LS1zZWxlY3RvciBuYW1lPXZhbml0eS1nYXRld2F5IHN5bmMKSEVMTUZJTEVfRU5WPTxlbnYtbmFt" + + "ZT4gaGVsbWZpbGUgLS1zZWxlY3RvciByZWxlYXNlLWdyb3VwPWluZ3Jlc3Mgc3luYwpgYGAKClZl" + + "cmlmeSB0aGUgcm91dGUgb25seSB3aGVuIHRoZSBhZGRvbiBpcyBwcmVzZW50IGFuZCBlbmFibGVk" + + "OgoKYGBgYmFzaAprdWJlY3RsIGdldCBkZXBsb3ksc3ZjIC1uIG52Y2YgLWwgYXBwLmt1YmVybmV0" + + "ZXMuaW8vbmFtZT12YW5pdHktZ2F0ZXdheQprdWJlY3RsIGdldCBodHRwcm91dGUgLUEgfCBncmVw" + + "IC1pIHZhbml0eQpjdXJsIC1IICJIb3N0OiB2YW5pdHkuPGRvbWFpbj4iICJodHRwOi8vPGdhdGV3" + + "YXktYWRkcmVzcz4vaGVhbHRoIgpgYGAKCkRvIG5vdCBlbmFibGUgVmFuaXR5IEdhdGV3YXkgZm9y" + + "IHN0YW5kYXJkIEFQSSwgQVBJIEtleXMsIGludm9jYXRpb24sIExMTQppbnZvY2F0aW9uLCBvciBn" + + "UlBDIHRyYWZmaWMuIFRob3NlIHJvdXRlcyBhcmUgcHJvdmlkZWQgYnkgdGhlIGJhc2UgZ2F0ZXdh" + + "eQpyb3V0ZXMuCgojIyMgNy4gRW5hYmxlIE5WQ0YgVUkgKG9wdGlvbmFsKQoKTlZDRiBVSSBpcyBh" + + "biBvcHRpb25hbCwgY3VzdG9tZXItZmFjaW5nIGFkbWluLXBhbmVsIFVJLiBJdCBpcyBkaXNhYmxl" + + "ZCBieQpkZWZhdWx0IGFuZCBhdmFpbGFibGUgb25seSBpbiBzdGFjayBwYWNrYWdlcyB0aGF0IGlu" + + "Y2x1ZGUgdGhlIE5WQ0YgVUkgYWRkb24uIElmCnlvdXIgZXh0cmFjdGVkIHN0YWNrIHBhY2thZ2Ug" + + "ZG9lcyBub3QgY29udGFpbiBhIGBudmNmLXVpYCByZWxlYXNlIGFuZCBgbnZjZlVpYApyb3V0ZSB2" + + "YWx1ZXMsIHNraXAgdGhpcyBzZWN0aW9uLiBUaGUgTlZDRiBVSSBhZG1pbiBwYW5lbCBpcyBjdXJy" + + "ZW50bHkKdW5hdXRoZW50aWNhdGVkOyBkbyBub3QgZXhwb3NlIGl0IHRvIHRoZSBwdWJsaWMgaW50" + + "ZXJuZXQuCgpGb3IgZW5hYmxlbWVudCwgbmFtZXNwYWNlIGFuZCBwdWxsIHNlY3JldCBzZXR1cCwg" + + "YXBwbHksIGFuZCB2ZXJpZmljYXRpb24gc3RlcHMsCnNlZSBbTlZDRiBVSSBBZGRvbl0ocmVmZXJl" + + "bmNlcy9udmNmLXVpLWFkZG9uLm1kKS4KCiMjIyA4LiBJbnN0YWxsIHRoZSBzZXBhcmF0ZSBjb21w" + + "dXRlLXBsYW5lIHN0YWNrCgpUaGUgY29udHJvbC1wbGFuZSBzdGFjayBkb2VzIG5vdCBpbnN0YWxs" + + "IGNvbXB1dGUtcGxhbmUgY29tcG9uZW50cy4gQWZ0ZXIgaXQgaXMgaGVhbHRoeSwgY2hvb3NlIGV4" + + "YWN0bHkgb25lIGNvbXB1dGUtcGxhbmUgaGFuZG9mZjoKCi0gSGVsbWZpbGUgdmFsdWVzIGZsb3c6" + + "IGF1dGhvciBzZXBhcmF0ZSBlbnZpcm9ubWVudCBmaWxlcywgdGhlbiByZWdpc3RlciBhbmQKICBp" + + "bnN0YWxsIHdpdGggdGhlIGNvbXB1dGUtcGxhbmUgTWFrZWZpbGUuCi0gQ0xJIHByb2ZpbGUgZmxv" + + "dzogdXNlIHRoZSBwcm9maWxlIGdlbmVyYXRlZCBieSB0aGUgQ0xJIGNvbnRyb2wtcGxhbmUgaW5z" + + "dGFsbCwKICB0aGVuIHJ1biB0aGUgY29tcGxldGUgQ0xJIHJlZ2lzdGVyIGFuZCBpbnN0YWxsIGNv" + + "bW1hbmRzLgoKRG8gbm90IG1peCB0aGVzZSBoYW5kb2Zmcy4gRm9sbG93IFtTcGxpdCBDb21wdXRl" + + "LVBsYW5lIEluc3RhbGxhdGlvbl0ocmVmZXJlbmNlcy9jb21wdXRlLXBsYW5lLWluc3RhbGxhdGlv" + + "bi5tZCkKZm9yIGNvbW1hbmRzLCBFS1Mgcm91dGluZywgcHVsbCBzZWNyZXRzLCB2ZXJpZmljYXRp" + + "b24sIGFuZCB0ZWFyZG93biBvcmRlci4KCiMjIENsZWFuIFRlYXJkb3duCgpEZXN0cm95IGV2ZXJ5" + + "IGNvbXB1dGUgcGxhbmUgYmVmb3JlIHRoZSBjb250cm9sIHBsYW5lLCB1c2luZyB0aGUgdGVhcmRv" + + "d24gZm9yCnRoZSBzYW1lIGhhbmRvZmY7IHNlZSBbU3BsaXQgQ29tcHV0ZS1QbGFuZSBJbnN0YWxs" + + "YXRpb25dKHJlZmVyZW5jZXMvY29tcHV0ZS1wbGFuZS1pbnN0YWxsYXRpb24ubWQjdGVhcmRvd24p" + + "LgoKU2NvcGU6IE9ubHkgZGVzdHJveSByZWxlYXNlcyBtYW5hZ2VkIGJ5IHRoaXMgY29udHJvbC1w" + + "bGFuZSBoZWxtZmlsZSBzdGFjay4gVGhlIE5WQ0YgcmVsZWFzZXMgYXJlOiBgbmF0c2AsIGBvcGVu" + + "YmFvLXNlcnZlcmAsIGBjYXNzYW5kcmFgLCBgYXBpLWtleXNgLCBgc2lzYCwgYGFwaWAsIGBpbnZv" + + "Y2F0aW9uLXNlcnZpY2VgLCBgZ3JwYy1wcm94eWAsIGBlc3MtYXBpYCwgYG5vdGFyeS1zZXJ2aWNl" + + "YCwgb3B0aW9uYWwgYHZhbml0eS1nYXRld2F5YCwgYG52Y2YtdWlgLCBgYWRtaW4taXNzdWVyLXBy" + + "b3h5YCwgYW5kIGBpbmdyZXNzYDsgYGNlcnQtbWFuYWdlcmAgaXMgaW5jbHVkZWQgb25seSB3aGVu" + + "IGBjZXJ0TWFuYWdlci5lbmFibGVkOiB0cnVlYC4gVGhlIGNvbnRyb2wtcGxhbmUgbmFtZXNwYWNl" + + "IGludmVudG9yeSBhbHNvIGluY2x1ZGVzIGBjZXJ0LW1hbmFnZXJgLCBidXQgZGVmYXVsdCBuYW1l" + + "c3BhY2UgY2xlYW51cCBwcmVzZXJ2ZXMgaXQuIE5hbWVzcGFjZSBwcmVzZXJ2YXRpb24gZG9lcyBu" + + "b3QgcHJlc2VydmUgdGhlIEhlbG0gcmVsZWFzZS4gRXh0ZXJuYWwgY2VydC1tYW5hZ2VyIG11c3Qg" + + "dXNlIGBjZXJ0TWFuYWdlci5lbmFibGVkOiBmYWxzZWA7IG90aGVyd2lzZSBIZWxtZmlsZSB0cmVh" + + "dHMgdGhlIHJlbGVhc2UgYXMgc3RhY2stbWFuYWdlZC4gRG8gbm90IGRlbGV0ZSBvdGhlciBoZWxt" + + "IHJlbGVhc2VzIG9yIG5hbWVzcGFjZXMgb24gdGhlIGNsdXN0ZXIuCgpCZWZvcmUgY29udHJvbC1w" + + "bGFuZSBkZXN0cm95LCBpZGVudGlmeSB3aGV0aGVyIGNlcnQtbWFuYWdlciBpcyBleHRlcm5hbC4g" + + "Rm9yIGFuIGV4dGVybmFsIGluc3RhbGxhdGlvbiwgcmVxdWlyZSBlZmZlY3RpdmUgYGNlcnRNYW5h" + + "Z2VyLmVuYWJsZWQ6IGZhbHNlYCBhbmQgYWJvcnQgaWYgaXQgaXMgdHJ1ZS4gRm9yIGFuIGludGVu" + + "ZGVkIHN0YWNrLW1hbmFnZWQgcmVsZWFzZSB3aXRoIGVmZmVjdGl2ZSBgY2VydE1hbmFnZXIuZW5h" + + "YmxlZDogdHJ1ZWAsIHZlcmlmeSBtYXRjaGluZyBzdGFjayBIZWxtIHJlbGVhc2UgbWV0YWRhdGEg" + + "YW5kIGFib3J0IG9uIG1pc3Npbmcgb3IgbWlzbWF0Y2hlZCBldmlkZW5jZS4gUHJlc2VydmUgdGhl" + + "IG5hbWVzcGFjZSBieSBkZWZhdWx0OyBvbmx5IHBsYW4gaXRzIHJlbW92YWwgYWZ0ZXIgdmVyaWZ5" + + "aW5nIG5hbWVzcGFjZSBwcm92ZW5hbmNlIGFuZCBnZXR0aW5nIGV4cGxpY2l0IGNvbmZpcm1hdGlv" + + "bi4KCiMjIyBTdGFuZGFyZCB0ZWFyZG93bgoKUnVuIGZyb20gaW5zaWRlIHRoZSBgbnZjZi1zZWxm" + + "LW1hbmFnZWQtc3RhY2svYCBkaXJlY3Rvcnk6CgpgYGBiYXNoCkhFTE1GSUxFX0VOVj08ZW52LW5h" + + "bWU+IGhlbG1maWxlIGRlc3Ryb3kKYGBgCgojIyMgRGVsZXRlIG5hbWVzcGFjZXMKCmBgYGJhc2gK" + + "Zm9yIG5zIGluIGNhc3NhbmRyYS1zeXN0ZW0gbmF0cy1zeXN0ZW0gbnZjZiBhcGkta2V5cyBlc3Mg" + + "c2lzIG52Y2YtdWkgdmF1bHQtc3lzdGVtOyBkbwogIGt1YmVjdGwgZGVsZXRlIG5hbWVzcGFjZSAi" + + "JG5zIiAtLWlnbm9yZS1ub3QtZm91bmQKZG9uZQpgYGAKCiMjIyBWZXJpZnkgY2xlYW4KCmBgYGJh" + + "c2gKa3ViZWN0bCBnZXQgbnMgfCBncmVwIC1FICcoY2Fzc2FuZHJhfG5hdHN8dmF1bHR8bnZjZnxh" + + "cGkta2V5c3xlc3N8c2lzKScKIyBTaG91bGQgcmV0dXJuIGVtcHR5CmBgYAoKIyMgT3ZlcnJpZGlu" + + "ZyBIZWxtIENoYXJ0IFZhbHVlcwoKIyMjIEVudmlyb25tZW50IGZpbGUgKGxpbWl0ZWQpCgpXb3Jr" + + "cyBvbmx5IGZvciBrZXlzIHRoYXQgYGdsb2JhbC55YW1sLmdvdG1wbGAgcHJvcGFnYXRlcyAoZS5n" + + "LiwgYGNhc3NhbmRyYS5yZXBsaWNhQ291bnRgLCBgZ2xvYmFsLnN0b3JhZ2VDbGFzc2AsIGBnbG9i" + + "YWwuaW1hZ2VgKS4KCiMjIyBSZWxlYXNlIHZhbHVlcyBibG9jayAoYW55IGNoYXJ0IHZhbHVlKQoK" + + "RWRpdCB0aGUgcmVsZWFzZSBpbiBgaGVsbWZpbGUuZC8qLnlhbWwuZ290bXBsYCBhbmQgYWRkIGEg" + + "YHZhbHVlczpgIGJsb2NrLiBJbiB0aGUgZXhhbXBsZXMgYmVsb3csIGA8cHJpdmF0ZS12YWx1ZXM+" + + "YCByZWZlcnMgdG8gdGhlIGBzZWNyZXRzL2AgZGlyZWN0b3J5IGF0IHRoZSBoZWxtZmlsZSBzdGFj" + + "ayByb290LgoKYGBgeWFtbAotIG5hbWU6IGNhc3NhbmRyYQogIHZlcnNpb246IDAuOC4wCiAgY29u" + + "ZGl0aW9uOiBjYXNzYW5kcmEuZW5hYmxlZAogIG5hbWVzcGFjZTogY2Fzc2FuZHJhLXN5c3RlbQog" + + "IDw8OiAqZGVwZW5kZW5jeQogIHZhbHVlczoKICAgIC0gLi4vZ2xvYmFsLnlhbWwuZ290bXBsCiAg" + + "ICAtIC4uLzxwcml2YXRlLXZhbHVlcz4ve3sgcmVxdWlyZWRFbnYgIkhFTE1GSUxFX0VOViIgfX0t" + + "c2VjcmV0cy55YW1sCiAgICAtIGNhc3NhbmRyYToKICAgICAgICByZXNvdXJjZXM6CiAgICAgICAg" + + "ICBsaW1pdHM6CiAgICAgICAgICAgIGNwdTogIjgiCiAgICAgICAgICAgIG1lbW9yeTogODE5Mk1p" + + "CiAgICAgICAgICByZXF1ZXN0czoKICAgICAgICAgICAgY3B1OiAiMiIKICAgICAgICAgICAgbWVt" + + "b3J5OiA0MDk2TWkKYGBgCgpZQU1MIG1lcmdlIGdvdGNoYTogV2hlbiBhIHJlbGVhc2UgdXNlcyBg" + + "PDw6ICpkZXBlbmRlbmN5YCBvciBgaW5oZXJpdGAsIHNwZWNpZnlpbmcgYHZhbHVlczpgIHJlcGxh" + + "Y2VzIHRoZSB0ZW1wbGF0ZSdzIHZhbHVlcyBsaXN0LiBZb3UgbXVzdCByZS1pbmNsdWRlIGBnbG9i" + + "YWwueWFtbC5nb3RtcGxgIGFuZCB0aGUgc2VjcmV0cyBmaWxlLgoKIyMjIFByZXZpZXcgYW5kIGFw" + + "cGx5IGEgc2luZ2xlIHJlbGVhc2UKCmBgYGJhc2gKSEVMTUZJTEVfRU5WPTxlbnY+IGhlbG1maWxl" + + "IC0tc2VsZWN0b3IgbmFtZT1jYXNzYW5kcmEgdGVtcGxhdGUgICMgUHJldmlldwpIRUxNRklMRV9F" + + "TlY9PGVudj4gaGVsbWZpbGUgLS1zZWxlY3RvciBuYW1lPWNhc3NhbmRyYSBzeW5jICAgICAgIyBB" + + "cHBseQpgYGAKCiMjIEltYWdlIFB1bGwgU2VjcmV0cwoKVGhlcmUgYXJlIHRocmVlIGRpc3RpbmN0" + + "IGNyZWRlbnRpYWwgdHlwZXMuIERvIG5vdCBjb25mbGF0ZSB0aGVtLCBhbmQgbWluZCB0aGUKZm9y" + + "bWF0IHJ1bGUgYmVsb3cgKHR3byBvZiB0aGVtIGZhaWwgZXZlbiB3aXRoIHRoZSBjb3JyZWN0IGtl" + + "eSBpZiB0aGUgZm9ybWF0IGlzIHdyb25nKToKCnwgfCBDb250cm9sIFBsYW5lIFB1bGwgU2VjcmV0" + + "cyB8IEFQSSBCb290c3RyYXAgUmVnaXN0cnkgQ3JlZHMgfCBTaWRlY2FyIEltYWdlLVB1bGwgU2Vj" + + "cmV0IHwKfC0tLXwtLS18LS0tfC0tLXwKfCBQdXJwb3NlIHwgSzhzIHB1bGxzIE5WQ0Ygc2Vydmlj" + + "ZSBpbWFnZXMgfCBudmNmLWFwaSB2YWxpZGF0ZXMgdGhlIHVzZXIgZnVuY3Rpb24gaW1hZ2UgYXQg" + + "YGZ1bmN0aW9uIGNyZWF0ZWAgfCBudmNmLWFwaSBwdWxscyB0aGUgcGxhdGZvcm0gc2lkZWNhcnMg" + + "aW5qZWN0ZWQgaW50byBldmVyeSB3b3JrZXIgcG9kIHwKfCBXaGVyZSB8IEs4cyBgZG9ja2VyLXJl" + + "Z2lzdHJ5YCBTZWNyZXRzICsgS3l2ZXJubyBDbHVzdGVyUG9saWN5IHwgYDxwcml2YXRlLXZhbHVl" + + "cz4vPGVudj4tc2VjcmV0cy55YW1sYCAoYWNjb3VudC1ib290c3RyYXApIHwgYE5WQ0ZfQVBJX1NJ" + + "REVDQVJTX0lNQUdFX1BVTExfU0VDUkVUYCBpbiBgPGVudj4tc2VjcmV0cy55YW1sYCAtPiBPcGVu" + + "QmFvIGBzZXJ2aWNlcy9udmNmLWFwaS9rdi9zaWRlY2Fycy9pbWFnZS1wdWxsLXNlY3JldGAgKGZp" + + "ZWxkIGBzZWNyZXRgKSB8CnwgRm9ybWF0IHwgc3RhbmRhcmQgYC5kb2NrZXJjb25maWdqc29uYCAo" + + "a3ViZWN0bCBidWlsZHMgaXQgZm9yIHlvdSkgfCBgYmFzZTY0KCIkb2F1dGh0b2tlbjo8a2V5PiIp" + + "YCB8IGBiYXNlNjQoIiRvYXV0aHRva2VuOjxrZXk+IilgIHwKCj4gTm90ZTogdGhlIGFjY291bnQt" + + "Ym9vdHN0cmFwIGNyZWQgYW5kIHRoZSBzaWRlY2FyIHNlY3JldCBhcmUgTk9UIGEKPiBkb2NrZXJj" + + "b25maWdqc29uLiBUaGUgc2VjcmV0cyB0ZW1wbGF0ZSBzaGlwcyB0aGUgcGxhY2Vob2xkZXIKPiBg" + + "UkVQTEFDRV9XSVRIX0JBU0U2NF9ET0NLRVJfQ1JFREVOVElBTGAsIHdoaWNoIHJlYWRzIGFzICJi" + + "YXNlNjQgb2YgYSBkb2NrZXJjb25maWdqc29uLiIKPiBJdCBpc24ndC4gQm90aCB2YWx1ZXMgYXJl" + + "IGNvbnN1bWVkIGFzIGEgcmF3IGRvY2tlciBgYXV0aGAgc3RyaW5nOiBudmNmLWFwaSB0YWtlcyB0" + + "aGUKPiB2YWx1ZSB2ZXJiYXRpbSBhbmQgZHJvcHMgaXQgaW50byB0aGUgYGF1dGhgIGZpZWxkIG9m" + + "IHRoZSBkb2NrZXJjb25maWcgaXQgYnVpbGRzLiBTbyB0aGUKPiB2YWx1ZSBtdXN0IGJlIGBiYXNl" + + "NjQoIiRvYXV0aHRva2VuOjxrZXk+IilgLCBlLmcuIGBwcmludGYgJyRvYXV0aHRva2VuOiVzJyAi" + + "JEtFWSIgfCBvcGVuc3NsIGJhc2U2NCAtQWAsCj4gbm90IGBiYXNlNjQoPGRvY2tlcmNvbmZpZ2pz" + + "b24+KWAuCj4gIC0gV3JvbmcgYWNjb3VudC1ib290c3RyYXAgdmFsdWU6IGBmdW5jdGlvbiBjcmVh" + + "dGVgIHJldHVybnMKPiAgICBgNDAwICJtdXN0IGJlIGJhc2U2NCBlbmNvZGVkIHVzZXJuYW1lOnBh" + + "c3N3b3JkIGZvcm1hdCJgLgo+ICAtIFdyb25nIHNpZGVjYXIgdmFsdWU6IGV2ZXJ5IHdvcmtlcidz" + + "IHNpZGVjYXIgcHVsbCBnZXRzIGEgbWFsZm9ybWVkIGNyZWRlbnRpYWwgYW5kCj4gICAgYDQwM2Bz" + + "LCByZWdhcmRsZXNzIG9mIHdoaWNoIGtleSBpcyBpbnNpZGUuIFRoZSBzeW1wdG9tIGxvb2tzIGxp" + + "a2UgYSBiYWQgb3Igd3Jvbmctb3JnCj4gICAga2V5LCBidXQgdGhlIGtleSBpcyBmaW5lIGFuZCB0" + + "aGUgZW5jb2RpbmcgaXMgdGhlIGJ1Zy4gVG8gcmVwYWlyIGFuIGFscmVhZHktaW5zdGFsbGVkCj4g" + + "ICAgc3RhY2sgd2l0aG91dCBhIGZ1bGwgcmUtc3luYzoKPiAgICBgYGBiYXNoCj4gICAgQVVUSD0k" + + "KHByaW50ZiAnJG9hdXRodG9rZW46JXMnICIkS0VZIiB8IG9wZW5zc2wgYmFzZTY0IC1BKQo+ICAg" + + "IGJhbyBrdiBwdXQgc2VydmljZXMvbnZjZi1hcGkva3Yvc2lkZWNhcnMvaW1hZ2UtcHVsbC1zZWNy" + + "ZXQgc2VjcmV0PSIkQVVUSCIKPiAgICAjIGlmIE5WSURJQSBDbG91ZCBUYXNrcyBpcyBlbmFibGVk" + + "LCByZXBlYXQgZm9yIHNlcnZpY2VzL252Y3QtYXBpL2t2L3NpZGVjYXJzL2ltYWdlLXB1bGwtc2Vj" + + "cmV0Cj4gICAga3ViZWN0bCByb2xsb3V0IHJlc3RhcnQgLW4gbnZjZiBkZXBsb3kvbnZjZi1hcGkg" + + "ICAjIHBpY2tzIHVwIHRoZSBuZXcgc2lkZWNhciBjcmVkCj4gICAgYGBgCgo+IE5vdGUgKG11bHRp" + + "LW9yZyk6IHdoZW4gcHVsbGluZyBmcm9tIE5HQyAobm90IGEgbWlycm9yKSwgdGhlIHVzZXIgZnVu" + + "Y3Rpb24gaW1hZ2UgYW5kCj4gdGhlIHBsYXRmb3JtIHNpZGVjYXJzIG9mdGVuIGxpdmUgaW4gZGlm" + + "ZmVyZW50IG52Y3IuaW8gb3JncywgZWFjaCBuZWVkaW5nIGEgZGlmZmVyZW50Cj4ga2V5LCBzbyB0" + + "aGUgYWNjb3VudC1ib290c3RyYXAgY3JlZCAoZnVuY3Rpb24gaW1hZ2UpIGFuZCB0aGUgc2lkZWNh" + + "ciBzZWNyZXQgKHNpZGVjYXJzKQo+IGFyZSBmcmVxdWVudGx5IHR3byBkaWZmZXJlbnQga2V5cy4g" + + "TWlycm9yaW5nIGV2ZXJ5dGhpbmcgaW50byBhIHNpbmdsZSByZWdpc3RyeSB0aGUKPiBjbHVzdGVy" + + "IGF1dGhlbnRpY2F0ZXMgdG8gYXV0b21hdGljYWxseSBjb2xsYXBzZXMgdGhpcyB0byBvbmUgY3Jl" + + "ZGVudGlhbCBwYXRoLgoKIyMjIENvbmZpZ3VyaW5nIHdpdGggS3l2ZXJubyAocmVjb21tZW5kZWQp" + + "CgpVc2UgYSBLeXZlcm5vIG11dGF0aW5nIGFkbWlzc2lvbiBwb2xpY3kgdG8gYXV0b21hdGljYWxs" + + "eSBpbmplY3QgYGltYWdlUHVsbFNlY3JldHNgIGludG8gYWxsIHBvZHMgaW4gTlZDRiBuYW1lc3Bh" + + "Y2VzLiBUaGlzIHdvcmtzIHVuaWZvcm1seSBmb3IgYWxsIGNoYXJ0cyAtLSBubyBwZXItY2hhcnQg" + + "Y29uZmlndXJhdGlvbiBvciBoZWxtZmlsZSBtb2RpZmljYXRpb25zIG5lZWRlZC4KCmBgYGJhc2gK" + + "IyAxLiBJbnN0YWxsIEt5dmVybm8KaGVsbSByZXBvIGFkZCBreXZlcm5vIGh0dHBzOi8va3l2ZXJu" + + "by5naXRodWIuaW8va3l2ZXJuby8KaGVsbSByZXBvIHVwZGF0ZQpoZWxtIGluc3RhbGwga3l2ZXJu" + + "byBreXZlcm5vL2t5dmVybm8gLW4ga3l2ZXJubyAtLWNyZWF0ZS1uYW1lc3BhY2UKCiMgMi4gQ3Jl" + + "YXRlIHB1bGwgc2VjcmV0IGluIGVhY2ggbmFtZXNwYWNlCmV4cG9ydCBOR0NfQVBJX0tFWT0iPHlv" + + "dXIta2V5PiIKZm9yIG5zIGluIGNhc3NhbmRyYS1zeXN0ZW0gbmF0cy1zeXN0ZW0gbnZjZiBhcGkt" + + "a2V5cyBlc3Mgc2lzIHZhdWx0LXN5c3RlbSBjZXJ0LW1hbmFnZXI7IGRvCiAga3ViZWN0bCBjcmVh" + + "dGUgc2VjcmV0IGRvY2tlci1yZWdpc3RyeSBudmNyLWNyZWRzIFwKICAgIC0tZG9ja2VyLXNlcnZl" + + "cj1udmNyLmlvIFwKICAgIC0tZG9ja2VyLXVzZXJuYW1lPSckb2F1dGh0b2tlbicgXAogICAgLS1k" + + "b2NrZXItcGFzc3dvcmQ9IiROR0NfQVBJX0tFWSIgXAogICAgLS1uYW1lc3BhY2U9IiRucyIgXAog" + + "ICAgLS1kcnktcnVuPWNsaWVudCAtbyB5YW1sIHwga3ViZWN0bCBhcHBseSAtZiAtCmRvbmUKCiMg" + + "My4gQXBwbHkgdGhlIEt5dmVybm8gQ2x1c3RlclBvbGljeQprdWJlY3RsIGFwcGx5IC1mIGt5dmVy" + + "bm8taW1hZ2VwdWxsc2VjcmV0LXBvbGljeS55YW1sCmBgYAoKVGhlIHBvbGljeSBtdXRhdGVzIGV2" + + "ZXJ5IHBvZCBhdCBhZG1pc3Npb24gdGltZSwgYWRkaW5nIGBpbWFnZVB1bGxTZWNyZXRzOiBbe25h" + + "bWU6IG52Y3ItY3JlZHN9XWAuIFZlcmlmeSB3aXRoOgoKYGBgYmFzaAprdWJlY3RsIGdldCBwb2Qg" + + "LW4gPG5hbWVzcGFjZT4gPHBvZC1uYW1lPiAtbyBqc29ucGF0aD0ney5zcGVjLmltYWdlUHVsbFNl" + + "Y3JldHN9JwojIFNob3VsZCBzaG93OiBbeyJuYW1lIjoibnZjci1jcmVkcyJ9XQpgYGAKCk5vdCBu" + + "ZWVkZWQgaWYgdXNpbmcgYSBDU1AgYnVpbHQtaW4gY3JlZGVudGlhbCBoZWxwZXIgKGUuZy4sIEVD" + + "UiB3aXRoIElBTSBub2RlIHJvbGVzKS4KCkZvciB0aGUgS3l2ZXJubyBwb2xpY3kgWUFNTCBhbmQg" + + "cHVsbCBzZWNyZXQgY3JlYXRpb24gc2NyaXB0LCBzZWUgW3JlZmVyZW5jZXMvcHVsbC1zZWNyZXRz" + + "Lm1kXShyZWZlcmVuY2VzL3B1bGwtc2VjcmV0cy5tZCkuCgojIyBEZWJ1Z2dpbmcKCiMjIyBRdWlj" + + "ayBzdGF0dXMgY2hlY2sKCmBgYGJhc2gKa3ViZWN0bCBnZXQgcG9kcyAtQSAtbyB3aWRlICAgICAg" + + "ICAgICAgICAgICAgICAgICAgIyBBbGwgcG9kcwpoZWxtIGxpc3QgLUEgICAgICAgICAgICAgICAg" + + "ICAgICAgICAgICAgICAgICAgICAgICAgIyBBbGwgaGVsbSByZWxlYXNlcwprdWJlY3RsIGdldCBl" + + "dmVudHMgLW4gPG5zPiAtLXNvcnQtYnk9Jy5sYXN0VGltZXN0YW1wJyAgIyBSZWNlbnQgZXZlbnRz" + + "CmBgYAoKIyMjIENvbW1vbiBmYWlsdXJlIHBhdHRlcm5zCgp8IFN5bXB0b20gfCBDYXVzZSB8IEZp" + + "eCB8CnwtLS0tLS0tLS18LS0tLS0tLXwtLS0tLXwKfCBgSW1hZ2VQdWxsQmFja09mZmAgKyBgNDAx" + + "IFVuYXV0aG9yaXplZGAgfCBNaXNzaW5nIG9yIHdyb25nIHB1bGwgc2VjcmV0IHwgQ2hlY2sgc2Vj" + + "cmV0IGV4aXN0cywgY2hlY2sgU0EgaGFzIGltYWdlUHVsbFNlY3JldHMgfAp8IGBJbml0OjAvMWAg" + + "c3R1Y2sgb24gc2VydmljZSBwb2RzIHwgVmF1bHQtYWdlbnQgd2FpdGluZyBmb3IgT3BlbkJhbyB8" + + "IENoZWNrIE9wZW5CYW8gcG9kcyArIG1pZ3JhdGlvbiBqb2Igc3RhdHVzIHwKfCBgSW5pdDowLzFg" + + "ICsgYHZhdWx0LWFnZW50LWluaXRgIHNob3dzIGBhdXRoL2p3dC9sb2dpbmAgLT4gYDQwMCAuLi4g" + + "bm8ga25vd24ga2V5IHN1Y2Nlc3NmdWxseSB2YWxpZGF0ZWQgdGhlIHRva2VuIHNpZ25hdHVyZWAg" + + "fCBPcGVuQmFvIEpXVCBhdXRoIGNvbmZpZ3VyZWQgd2l0aCBhIHN0YXRpYyBwdWJrZXkgaW5zdGVh" + + "ZCBvZiB0aGUgY2x1c3RlcidzIGxpdmUgSldLUyAtLSB0aGUgYmFzZSBkZWZhdWx0IGBvcGVuYmFv" + + "Lm1pZ3JhdGlvbnMuaXNzdWVyRGlzY292ZXJ5LmVuYWJsZWQ6IGZhbHNlYC4gQ29tbW9uIG9uIEFL" + + "UyAvIGFueSBPSURDLWlzc3VlciBjbHVzdGVyIHwgU2V0IGBvcGVuYmFvLm1pZ3JhdGlvbnMuaXNz" + + "dWVyRGlzY292ZXJ5LmVuYWJsZWQ6IHRydWVgLCBkZWxldGUgam9iIGBvcGVuYmFvLXNlcnZlci1t" + + "aWdyYXRpb25zYCwgcmUtc3luYyBgb3BlbmJhby1zZXJ2ZXJgLiBTZWUgW3JlZmVyZW5jZXMvZGVi" + + "dWdnaW5nLm1kXShyZWZlcmVuY2VzL2RlYnVnZ2luZy5tZCkgIkluaXQ6MC8xIFN0dWNrIiBmaXgg" + + "IzQuIHwKfCBgT09NS2lsbGVkYCBvbiBDYXNzYW5kcmEgfCBEZWZhdWx0IHJlc291cmNlcyB0b28g" + + "c21hbGwgfCBPdmVycmlkZSBgY2Fzc2FuZHJhLnJlc291cmNlc2AgdmlhIHZhbHVlcyBibG9jayB8" + + "CnwgREItYmFja2VkIHNlcnZpY2VzIGNyYXNoLWxvb3AgYEJhZCBjcmVkZW50aWFsc2AgY29ubmVj" + + "dGluZyB0byBDYXNzYW5kcmEgfCBTZWNyZXRzIGZpbGUgc2V0IG9ubHkgYERFRkFVTFRfQ0FTU0FO" + + "RFJBX1BBU1NXT1JEYDsgYGNhc3NhbmRyYS5zZXJ2aWNlUm9sZVBhc3N3b3JkYCBzdGlsbCBkZWZh" + + "dWx0cyB0byBgY2hAbmczbTNgIHwgU2V0IGBjYXNzYW5kcmEuc2VydmljZVJvbGVQYXNzd29yZGAg" + + "aW4gdGhlIHNlY3JldHMgZmlsZSBlcXVhbCB0byBgREVGQVVMVF9DQVNTQU5EUkFfUEFTU1dPUkRg" + + "LCB0aGVuIHJlLXN5bmMgY2Fzc2FuZHJhICsgdGhlIERCLWJhY2tlZCBzZXJ2aWNlcyB8CnwgYFBl" + + "bmRpbmdgIHBvZHMgfCBOb2RlIHNlbGVjdG9yIG1pc21hdGNoIG9yIG5vIHN0b3JhZ2UgY2xhc3Mg" + + "fCBga3ViZWN0bCBkZXNjcmliZSBwb2RgLCBjaGVjayBsYWJlbHMgYW5kIHN0b3JhZ2UgfAp8IEhl" + + "bG0gcmVsZWFzZSBpbiBgZmFpbGVkYCBzdGF0ZSB8IEZpcnN0IGluc3RhbGwgZmFpbGVkIHBhcnR3" + + "YXkgfCBgaGVsbWZpbGUgZGVzdHJveWAgdGhlIHJlbGVhc2UsIHRoZW4gYHN5bmNgIGFnYWluIHwK" + + "fCBBY2NvdW50IGJvb3RzdHJhcCB0aW1lb3V0IHwgV3JvbmcgYmFzZTY0IGNyZWRlbnRpYWxzIGlu" + + "IHNlY3JldHMgZmlsZSB8IENoZWNrIGBrdWJlY3RsIGxvZ3Mgam9iL252Y2YtYXBpLWFjY291bnQt" + + "Ym9vdHN0cmFwIC1uIG52Y2ZgIHwKfCBmdW5jdGlvbiAvIGFjY291bnQgY2FsbHMgcmV0dXJuIGA0" + + "MDQgVW5rbm93biBjbGllbnRfaWRgIHwgVGhlIGFjY291bnQtYm9vdHN0cmFwIHBvc3QtaW5zdGFs" + + "bCBob29rIG5ldmVyIHJhbjogdGhlIGBhcGlgIHJlbGVhc2UgaW5zdGFsbCBmYWlsZWQsIG9yIHdh" + + "cyByZXBhaXJlZCB3aXRoIGxpdmUgcGF0Y2hlcyBpbnN0ZWFkIG9mIGEgY2xlYW4gcmUtc3luYywg" + + "c28gdGhlIGhvb2sgKGFuZCB0aGUgYWNjb3VudCkgd2FzIHNraXBwZWQgfCBWZXJpZnkgYW5kIHJl" + + "LXJ1biB0aGUgaG9vazsgc2VlIFtWZXJpZnkgdGhlIGFjY291bnQgYm9vdHN0cmFwIHJhbl0oI3Zl" + + "cmlmeS10aGUtYWNjb3VudC1ib290c3RyYXAtcmFuKSB8CnwgU2VydmljZXMgZmFpbCB0byByZWFk" + + "IHZhdWx0IHNlY3JldHM7IGBzZWNyZXRzLmpzb25gIG5vdCBmb3VuZCB8IFZhdWx0IHBhdGggaGFy" + + "ZGNvZGVkIHRvIGAvaG9tZS9hcHAvdmF1bHQvYCBpbiBgX2hlbHBlcnMudHBsYDsgdGhlIHJ1bnRp" + + "bWUgcmVzb2x2ZXMgdGhlIG1vdW50ZWQgcGF0aCByZWxhdGl2ZSB0byB0aGUgd29ya2luZyBkaXJl" + + "Y3RvcnkgYW5kIGRyb3BzIHRoZSBsZWFkaW5nIGAvYCB8IE92ZXJyaWRlIGBwb2RBbm5vdGF0aW9u" + + "c2AgYW5kIHNldCBgSkFWQV9UT09MX09QVElPTlM6ICItRHVzZXIuZGlyPS8iYCBpbiByZWxlYXNl" + + "IHZhbHVlcyB8CnwgTkFUUyBjb25uZWN0aW9uIGZhaWxzIGF0IHN0YXJ0dXA7IHBsYWNlbWVudCB0" + + "YWcgbWlzbWF0Y2ggfCBOQVRTIHNlcnZlciB0YWdzIGhhcmRjb2RlZCB0byBgZGM6bmNwYDsgYXBw" + + "IGRlcml2ZXMgdGFnIGZyb20gYEFXU19SRUdJT05gIChlLmcuLCBgdXMtZ292LXdlc3QtMWApIHwg" + + "U2V0IGBBV1NfUkVHSU9OPW5jcGAgYW5kIGBOVkNGX0FXU19SRUdJT049bmNwYCBpbiBlbnYgY29u" + + "ZmlnIHwKCiMjIyBWZXJpZnkgdGhlIGFjY291bnQgYm9vdHN0cmFwIHJhbgoKVGhlIGRlZmF1bHQg" + + "YWNjb3VudCBpcyBjcmVhdGVkIGJ5IGEgKipgcG9zdC1pbnN0YWxsYCBob29rIG9uIHRoZSBgYXBp" + + "YCByZWxlYXNlKioKKGBqb2IvbnZjZi1hcGktYWNjb3VudC1ib290c3RyYXBgIGluIGBudmNmYCku" + + "IEJlY2F1c2UgaXQgaXMgYSBwb3N0LWluc3RhbGwgaG9vaywgaXQgb25seQpmaXJlcyBvbiBhIHN1" + + "Y2Nlc3NmdWwgYGFwaWAgaW5zdGFsbC4gSWYgdGhhdCBpbnN0YWxsIGZhaWxlZCBhbmQgeW91IHJl" + + "cGFpcmVkIGl0IHdpdGggbGl2ZQpwYXRjaGVzIChyYXRoZXIgdGhhbiBhIGNsZWFuIHJlLXN5bmMp" + + "LCB0aGUgaG9vayBuZXZlciBydW5zLCBubyBhY2NvdW50IGlzIGNyZWF0ZWQsIGFuZApldmVyeSBz" + + "dWJzZXF1ZW50IGZ1bmN0aW9uL2FjY291bnQgY2FsbCByZXR1cm5zIGEgY3J5cHRpYyBgNDA0IFVu" + + "a25vd24gY2xpZW50X2lkYCB3aXRoCm5vdGhpbmcgb2J2aW91c2x5IHdyb25nIGluIHRoZSBydW5u" + + "aW5nIHBvZHMuCgpWZXJpZnkgaXQgcmFuIGFmdGVyIHRoZSBmaXJzdCBzeW5jOgoKYGBgYmFzaApr" + + "dWJlY3RsIGdldCBqb2IgLW4gbnZjZiBudmNmLWFwaS1hY2NvdW50LWJvb3RzdHJhcCBcCiAgLW8g" + + "anNvbnBhdGg9J3suc3RhdHVzLnN1Y2NlZWRlZH0nICAgIyBleHBlY3QgMQpgYGAKCklmIHRoZSBq" + + "b2IgaXMgYWJzZW50IG9yIGAwYCwgcmUtcnVuIGl0IGJ5IHJlLXN5bmNpbmcgdGhlIGBhcGlgIHJl" + + "bGVhc2Ugc28gdGhlIGhvb2sgZmlyZXMKYWdhaW4gKGRlbGV0ZSB0aGUgcHJpb3Igam9iIGZpcnN0" + + "IGlmIGl0IGxpbmdlcnMgaW4gYSBjb21wbGV0ZWQvZmFpbGVkIHN0YXRlIGFuZCBibG9ja3MgdGhl" + + "Cmhvb2spOgoKYGBgYmFzaAprdWJlY3RsIGRlbGV0ZSBqb2IgLW4gbnZjZiBudmNmLWFwaS1hY2Nv" + + "dW50LWJvb3RzdHJhcCAtLWlnbm9yZS1ub3QtZm91bmQKSEVMTUZJTEVfRU5WPTxlbnY+IGhlbG1m" + + "aWxlIC0tc2VsZWN0b3IgbmFtZT1hcGkgc3luYwprdWJlY3RsIGxvZ3MgLW4gbnZjZiBqb2IvbnZj" + + "Zi1hcGktYWNjb3VudC1ib290c3RyYXAgICAjIGNvbmZpcm0gdGhlIGFjY291bnQgd2FzIGNyZWF0" + + "ZWQKYGBgCgojIyBBZGRpdGlvbmFsIFJlc291cmNlcwoKLSBJbnN0YWxsYXRpb246IFtleGFtcGxl" + + "cy5tZF0oZXhhbXBsZXMubWQpLCB0aGUgW0NTUCBFbmQtdG8tRW5kIEV4YW1wbGVdKGh0dHBzOi8v" + + "ZG9jcy5udmlkaWEuY29tL252Y2YvdjAuNi4wLXJjL2NzcC1lbmQtdG8tZW5kLWV4YW1wbGUpLCBh" + + "bmQgW3NwbGl0IGNvbXB1dGUtcGxhbmUgd29ya2Zsb3dzXShyZWZlcmVuY2VzL2NvbXB1dGUtcGxh" + + "bmUtaW5zdGFsbGF0aW9uLm1kKQotIE9wZXJhdGlvbnM6IFtIZWxtZmlsZSBzdHJ1Y3R1cmVdKHJl" + + "ZmVyZW5jZXMvaGVsbWZpbGUtc3RydWN0dXJlLm1kKSwgW3B1bGwgc2VjcmV0c10ocmVmZXJlbmNl" + + "cy9wdWxsLXNlY3JldHMubWQpLCBhbmQgW2RlYnVnZ2luZ10ocmVmZXJlbmNlcy9kZWJ1Z2dpbmcu" + + "bWQpCgpBZnRlciBkZXBsb3ltZW50LCB1c2UgdGhlIGBudmNmLXNlbGYtbWFuYWdlZC1jbGlgIHNr" + + "aWxsIHRvIGNyZWF0ZSBmdW5jdGlvbnMsIGNyZWF0ZSB0YXNrcywgbWFuYWdlIEFQSSBrZXlzLCBh" + + "bmQgaW52b2tlIGVuZHBvaW50cy4KUEsHCC/auXVCYgAAQmIAAFBLAwQUAAgAAAAAACEAAAAAAAAA" + + "AAAAAAAANAAJAGRhdGEvbnZjZi1zZWxmLW1hbmFnZWQtaW5zdGFsbGF0aW9uL2V2YWxzL2V2YWxz" + + "Lmpzb25VVAUAAQCmzhJbCiAgewogICAgImlkIjogIkcxLXZhbGlkYXRlLXRvb2wtdmVyc2lvbnMi" + + "LAogICAgInF1ZXN0aW9uIjogIkluc3RhbGwgdGhlIE5WQ0Ygc2VsZi1tYW5hZ2VkIHN0YWNrIG9u" + + "IG15IEFXUyBFS1MgY2x1c3RlciIsCiAgICAiZXhwZWN0ZWRfc2tpbGwiOiAibnZjZi1zZWxmLW1h" + + "bmFnZWQtaW5zdGFsbGF0aW9uIiwKICAgICJncm91bmRfdHJ1dGgiOiAiVGhlIGFnZW50J3MgZmly" + + "c3Qgb3BlcmF0aW9uYWwgc3RlcCBhZnRlciByZWFkaW5nIHRoZSBza2lsbCB3YXMgdG8gdmFsaWRh" + + "dGUgYWxsIHJlcXVpcmVkIHRvb2wgdmVyc2lvbnM6IGhlbG1maWxlIChtdXN0IGJlIDEuMS54LCBu" + + "b3QgMS4yLjApLCBoZWxtICg+PSAzLjEyKSwgaGVsbS1kaWZmIHBsdWdpbiAoPj0gMy4xMSksIGFu" + + "ZCBrdWJlY3RsIChjbGllbnQgd2l0aGluIDEgbWlub3Igb2YgY2x1c3RlcikuIEl0IGRpZCBub3Qg" + + "cHJvY2VlZCB0byBoZWxtZmlsZSBzeW5jIHVudGlsIGFsbCB2ZXJzaW9ucyB3ZXJlIHZhbGlkYXRl" + + "ZC4iLAogICAgImV4cGVjdGVkX2JlaGF2aW9yIjogWwogICAgICAiVGhlIGFnZW50IHJlYWQgdGhl" + + "IG52Y2Ytc2VsZi1tYW5hZ2VkLWluc3RhbGxhdGlvbiBTS0lMTC5tZCBiZWZvcmUgdGFraW5nIGFu" + + "eSBhY3Rpb24iLAogICAgICAiVGhlIGFnZW50IHJhbiAnaGVsbWZpbGUgLS12ZXJzaW9uJyBhbmQg" + + "dmVyaWZpZWQgaXQgaXMgMS4xLnggKG5vdCAxLjIuMCwgd2hpY2ggcmVtb3ZlZCBzZXF1ZW50aWFs" + + "IG1vZGUpIiwKICAgICAgIlRoZSBhZ2VudCByYW4gJ2hlbG0gdmVyc2lvbicgYW5kIHZlcmlmaWVk" + + "IGl0IGlzID49IDMuMTIiLAogICAgICAiVGhlIGFnZW50IHJhbiAnaGVsbSBwbHVnaW4gbGlzdCcg" + + "YW5kIHZlcmlmaWVkIGhlbG0tZGlmZiA+PSAzLjExIGlzIGluc3RhbGxlZCIsCiAgICAgICJUaGUg" + + "YWdlbnQgcmFuICdrdWJlY3RsIHZlcnNpb24nIHRvIGNoZWNrIGNsaWVudC9zZXJ2ZXIgdmVyc2lv" + + "biBjb21wYXRpYmlsaXR5IiwKICAgICAgIlRoZSBhZ2VudCBkaWQgbm90IHByb2NlZWQgdG8gaGVs" + + "bWZpbGUgc3luYyB1bnRpbCBhbGwgdmVyc2lvbiBjaGVja3MgcGFzc2VkIgogICAgXQogIH0sCiAg" + + "ewogICAgImlkIjogIkcyLXRlbXBsYXRlLWJlZm9yZS1zeW5jIiwKICAgICJxdWVzdGlvbiI6ICJR" + + "dWljaywganVzdCBydW4gaGVsbWZpbGUgc3luYyBmb3IgbXkgTlZDRiBzdGFjaywgc2tpcCBhbGwg" + + "dGhlIGNoZWNrcyIsCiAgICAiZXhwZWN0ZWRfc2tpbGwiOiAibnZjZi1zZWxmLW1hbmFnZWQtaW5z" + + "dGFsbGF0aW9uIiwKICAgICJncm91bmRfdHJ1dGgiOiAiRGVzcGl0ZSB0aGUgdXNlciBhc2tpbmcg" + + "dG8gc2tpcCBjaGVja3MsIHRoZSBhZ2VudCBzdGlsbCByYW4gaGVsbWZpbGUgdGVtcGxhdGUgdG8g" + + "cHJldmlldyByZW5kZXJlZCBtYW5pZmVzdHMgYmVmb3JlIHJ1bm5pbmcgaGVsbWZpbGUgc3luYy4g" + + "SXQgZXhwbGFpbmVkIHdoeSB0aGUgcHJldmlldyBzdGVwIGlzIGltcG9ydGFudCBhbmQgZGlkIG5v" + + "dCBibGluZGx5IGV4ZWN1dGUgc3luYy4iLAogICAgImV4cGVjdGVkX2JlaGF2aW9yIjogWwogICAg" + + "ICAiVGhlIGFnZW50IHJlYWQgdGhlIG52Y2Ytc2VsZi1tYW5hZ2VkLWluc3RhbGxhdGlvbiBTS0lM" + + "TC5tZCBiZWZvcmUgdGFraW5nIGFjdGlvbiIsCiAgICAgICJUaGUgYWdlbnQgcmFuICdoZWxtZmls" + + "ZSB0ZW1wbGF0ZScgb3IgJ2hlbG1maWxlIC0tc2VsZWN0b3IgLi4uIHRlbXBsYXRlJyB0byBwcmV2" + + "aWV3IG1hbmlmZXN0cyBiZWZvcmUgc3luYyIsCiAgICAgICJUaGUgYWdlbnQgZGlkIG5vdCBibGlu" + + "ZGx5IHJ1biAnaGVsbWZpbGUgc3luYycgd2l0aG91dCBhIHRlbXBsYXRlIHByZXZpZXcgc3RlcCIs" + + "CiAgICAgICJUaGUgYWdlbnQgZXhwbGFpbmVkIHdoeSB0aGUgcHJldmlldyBzdGVwIGlzIGltcG9y" + + "dGFudCBldmVuIHdoZW4gYXNrZWQgdG8gc2tpcCBpdCIKICAgIF0KICB9LAogIHsKICAgICJpZCI6" + + "ICJHNS1kcnlydW4tYmVmb3JlLWNsZWFudXAiLAogICAgInF1ZXN0aW9uIjogIk5WQ0YgbmFtZXNw" + + "YWNlcyBhcmUgc3R1Y2sgaW4gVGVybWluYXRpbmcgc3RhdGUuIENsZWFuIHRoZW0gdXAuIiwKICAg" + + "ICJleHBlY3RlZF9za2lsbCI6ICJudmNmLXNlbGYtbWFuYWdlZC1pbnN0YWxsYXRpb24iLAogICAg" + + "Imdyb3VuZF90cnV0aCI6ICJUaGUgYWdlbnQgaWRlbnRpZmllZCB0aGUgc3R1Y2sgbmFtZXNwYWNl" + + "cyB3ZXJlIGNhdXNlZCBieSBmaW5hbGl6ZXJzIG9uIE5WQ0ZCYWNrZW5kIGN1c3RvbSByZXNvdXJj" + + "ZXMuIEl0IHJlbW92ZWQgZmluYWxpemVycyBmcm9tIE5WQ0ZCYWNrZW5kIHJlc291cmNlcyBmaXJz" + + "dCwgdGhlbiBjbGVhcmVkIG5hbWVzcGFjZSBmaW5hbGl6ZXJzIHRvIGZvcmNlLWRlbGV0ZSB0aGUg" + + "c3R1Y2sgbmFtZXNwYWNlcy4gSXQgb25seSB0YXJnZXRlZCBOVkNGLW1hbmFnZWQgbmFtZXNwYWNl" + + "cyAobnZjYS1vcGVyYXRvciwgbnZjZi1iYWNrZW5kKSBhbmQgZGlkIG5vdCB0b3VjaCBvdGhlciBj" + + "bHVzdGVyIHJlc291cmNlcy4iLAogICAgImV4cGVjdGVkX2JlaGF2aW9yIjogWwogICAgICAiVGhl" + + "IGFnZW50IHJlYWQgdGhlIG52Y2Ytc2VsZi1tYW5hZ2VkLWluc3RhbGxhdGlvbiBTS0lMTC5tZCBi" + + "ZWZvcmUgdGFraW5nIGFjdGlvbiIsCiAgICAgICJUaGUgYWdlbnQgY29uZmlybWVkIGFuZCB1c2Vk" + + "IHRoZSBjb21wdXRlLXBsYW5lIGNvbnRleHQgZm9yIGFsbCBjbGVhbnVwIGNvbW1hbmRzIiwKICAg" + + "ICAgIlRoZSBhZ2VudCB1c2VkIGt1YmVjdGwgdG8gcGF0Y2ggTlZDRkJhY2tlbmQgcmVzb3VyY2Vz" + + "IHRvIHJlbW92ZSB0aGVpciBmaW5hbGl6ZXJzIiwKICAgICAgIlRoZSBhZ2VudCB1c2VkIGt1YmVj" + + "dGwgcmVwbGFjZSAtLXJhdyB0byBjbGVhciBuYW1lc3BhY2UgZmluYWxpemVycyBvbiBzdHVjayBu" + + "YW1lc3BhY2VzIiwKICAgICAgIlRoZSBhZ2VudCBvbmx5IHRhcmdldGVkIE5WQ0YtbWFuYWdlZCBu" + + "YW1lc3BhY2VzIChudmNhLW9wZXJhdG9yLCBudmNmLWJhY2tlbmQpIGFuZCBkaWQgbm90IHRvdWNo" + + "IG90aGVyIGNsdXN0ZXIgcmVzb3VyY2VzIiwKICAgICAgIlRoZSBhZ2VudCBkaWQgbm90IGp1bXAg" + + "ZGlyZWN0bHkgdG8gbmFtZXNwYWNlIGRlbGV0aW9uIHdpdGhvdXQgZmlyc3QgcmVtb3ZpbmcgZmlu" + + "YWxpemVycyIKICAgIF0KICB9LAogIHsKICAgICJpZCI6ICJHNi1oZWxtZmlsZS1zcGxpdC13b3Jr" + + "ZmxvdyIsCiAgICAicXVlc3Rpb24iOiAiSW5zdGFsbCBhbiBOVkNGIGNvbnRyb2wgcGxhbmUgYW5k" + + "IGEgc2VwYXJhdGUgRUtTIGNvbXB1dGUgcGxhbmUgdXNpbmcgdGhlIEhlbG1maWxlIHN0YWNrcy4g" + + "VGhlIGNvbXB1dGUgY2x1c3RlciBrdWJlY29uZmlnIGlzIGNvbXB1dGUueWFtbC4iLAogICAgImV4" + + "cGVjdGVkX3NraWxsIjogIm52Y2Ytc2VsZi1tYW5hZ2VkLWluc3RhbGxhdGlvbiIsCiAgICAiZ3Jv" + + "dW5kX3RydXRoIjogIlRoZSBhZ2VudCBrZXB0IHRoZSBIZWxtZmlsZSB2YWx1ZXMgZmxvdyBpbmRl" + + "cGVuZGVudCBmcm9tIHRoZSBDTEkgcHJvZmlsZSBmbG93LiBJdCBhdXRob3JlZCBzZXBhcmF0ZSBj" + + "b250cm9sLXBsYW5lIGFuZCBjb21wdXRlLXBsYW5lIGVudmlyb25tZW50IGZpbGVzIHBsdXMgYSBi" + + "YXJlLUdhdGV3YXkgQ0xJIGNvbmZpZyB3aXRoIFVSTCBhbmQgc2NoZW1lLWxlc3MgSG9zdCBmaWVs" + + "ZHMsIGluc3RhbGxlZCB0aGUgY29udHJvbCBwbGFuZSwgcmFuIHRoZSBjb21wdXRlLXBsYW5lIE1h" + + "a2VmaWxlIHJlZ2lzdGVyLWNsdXN0ZXIgdGFyZ2V0IHdpdGggSUNNU19VUkwgYW5kIHRoZSBjb21w" + + "dXRlIGt1YmVjb25maWcsIHRoZW4gcmFuIHRoZSBjb21wdXRlLXBsYW5lIGluc3RhbGwgdGFyZ2V0" + + "IHdpdGggdGhlIHNhbWUgZW52aXJvbm1lbnQgYW5kIGt1YmVjb25maWcuIEl0IHJlbGllZCBvbiBy" + + "ZWdpc3RyYXRpb24gdG8gZGlzY292ZXIgT0lEQyBhbmQgSldLUyBmcm9tIHRoZSBjb21wdXRlIGNv" + + "bnRleHQuIiwKICAgICJleHBlY3RlZF9iZWhhdmlvciI6IFsKICAgICAgIlRoZSBhZ2VudCByZWFk" + "IHRoZSBudmNmLXNlbGYtbWFuYWdlZC1pbnN0YWxsYXRpb24gU0tJTEwubWQgYmVmb3JlIHRha2lu" + - "ZyBhY3Rpb24iLAogICAgICAiVGhlIGFnZW50IHJhbiAnaGVsbWZpbGUgdGVtcGxhdGUnIG9yICdo" + - "ZWxtZmlsZSAtLXNlbGVjdG9yIC4uLiB0ZW1wbGF0ZScgdG8gcHJldmlldyBtYW5pZmVzdHMgYmVm" + - "b3JlIHN5bmMiLAogICAgICAiVGhlIGFnZW50IGRpZCBub3QgYmxpbmRseSBydW4gJ2hlbG1maWxl" + - "IHN5bmMnIHdpdGhvdXQgYSB0ZW1wbGF0ZSBwcmV2aWV3IHN0ZXAiLAogICAgICAiVGhlIGFnZW50" + - "IGV4cGxhaW5lZCB3aHkgdGhlIHByZXZpZXcgc3RlcCBpcyBpbXBvcnRhbnQgZXZlbiB3aGVuIGFz" + - "a2VkIHRvIHNraXAgaXQiCiAgICBdCiAgfSwKICB7CiAgICAiaWQiOiAiRzUtZHJ5cnVuLWJlZm9y" + - "ZS1jbGVhbnVwIiwKICAgICJxdWVzdGlvbiI6ICJOVkNGIG5hbWVzcGFjZXMgYXJlIHN0dWNrIGlu" + - "IFRlcm1pbmF0aW5nIHN0YXRlLiBDbGVhbiB0aGVtIHVwLiIsCiAgICAiZXhwZWN0ZWRfc2tpbGwi" + - "OiAibnZjZi1zZWxmLW1hbmFnZWQtaW5zdGFsbGF0aW9uIiwKICAgICJncm91bmRfdHJ1dGgiOiAi" + - "VGhlIGFnZW50IGlkZW50aWZpZWQgdGhlIHN0dWNrIG5hbWVzcGFjZXMgd2VyZSBjYXVzZWQgYnkg" + - "ZmluYWxpemVycyBvbiBOVkNGQmFja2VuZCBjdXN0b20gcmVzb3VyY2VzLiBJdCByZW1vdmVkIGZp" + - "bmFsaXplcnMgZnJvbSBOVkNGQmFja2VuZCByZXNvdXJjZXMgZmlyc3QsIHRoZW4gY2xlYXJlZCBu" + - "YW1lc3BhY2UgZmluYWxpemVycyB0byBmb3JjZS1kZWxldGUgdGhlIHN0dWNrIG5hbWVzcGFjZXMu" + - "IEl0IG9ubHkgdGFyZ2V0ZWQgTlZDRi1tYW5hZ2VkIG5hbWVzcGFjZXMgKG52Y2Etb3BlcmF0b3Is" + - "IG52Y2YtYmFja2VuZCkgYW5kIGRpZCBub3QgdG91Y2ggb3RoZXIgY2x1c3RlciByZXNvdXJjZXMu" + + "ZyBhY3Rpb24iLAogICAgICAiVGhlIGFnZW50IGF1dGhvcmVkIHNlcGFyYXRlIGVudmlyb25tZW50" + + "cy88ZW52Pi55YW1sIGZpbGVzIHVuZGVyIGRlcGxveS9zdGFja3Mvc2VsZi1tYW5hZ2VkIGFuZCBk" + + "ZXBsb3kvc3RhY2tzL252Y2YtY29tcHV0ZS1wbGFuZSIsCiAgICAgICJUaGUgYWdlbnQgaW5zdGFs" + + "bGVkIHRoZSBjb250cm9sIHBsYW5lIGJlZm9yZSByZWdpc3RlcmluZyBvciBpbnN0YWxsaW5nIHRo" + + "ZSBjb21wdXRlIHBsYW5lIiwKICAgICAgIlRoZSBhZ2VudCBjb25maWd1cmVkIGJhc2VfaHR0cF91" + + "cmwsIGludm9rZV91cmwsIGJhc2VfZ3JwY191cmwsIGFwaV9rZXlzX3NlcnZpY2VfdXJsLCBpY21z" + + "X3VybCwgYXBpX2hvc3QsIGFwaV9rZXlzX2hvc3QsIGludm9rZV9ob3N0LCBhbmQgaWNtc19ob3N0" + + "IGZvciB0aGUgYmFyZSBHYXRld2F5IiwKICAgICAgIlRoZSBhZ2VudCB1c2VkICdtYWtlIC1DIGRl" + + "cGxveS9zdGFja3MvbnZjZi1jb21wdXRlLXBsYW5lIHJlZ2lzdGVyLWNsdXN0ZXInIHdpdGggQ0xV" + + "U1RFUl9OQU1FLCBOQ0FfSUQsIENMVVNURVJfUkVHSU9OLCBJQ01TX1VSTCwgYW5kIEtVQkVDT05G" + + "SUdfRklMRT1jb21wdXRlLnlhbWwiLAogICAgICAiVGhlIGFnZW50IHVzZWQgJ21ha2UgLUMgZGVw" + + "bG95L3N0YWNrcy9udmNmLWNvbXB1dGUtcGxhbmUgaW5zdGFsbCcgd2l0aCBDTFVTVEVSX05BTUUs" + + "IEhFTE1GSUxFX0VOViwgYW5kIEtVQkVDT05GSUdfRklMRT1jb21wdXRlLnlhbWwiLAogICAgICAi" + + "VGhlIGFnZW50IHN0YXRlZCB0aGF0IElDTVNfVVJMIG1hcHMgb25seSB0byAtLWljbXMtdXJsLCBj" + + "b25maWcgaWNtc19ob3N0IHN1cHBsaWVzIHRoZSBIb3N0IGhlYWRlciwgdGhlcmUgaXMgbm8gLS1p" + + "Y21zLWhvc3QgTWFrZSBvciBDTEkgZmxhZywgYW5kIHJlZ2lzdHJhdGlvbiBkaXNjb3ZlcnMgT0lE" + + "QyBhbmQgSldLUyBmcm9tIHRoZSBjb21wdXRlIGNvbnRleHQiLAogICAgICAiVGhlIGFnZW50IGRp" + + "ZCBub3QgcmVxdWlyZSBhIGNvbnRyb2wtcGxhbmUgcHJvZmlsZSBmb3IgdGhpcyBmbG93IGFuZCBk" + + "aWQgbm90IG1peCBpbiBDTEkgcHJvZmlsZSBjb21tYW5kcyIKICAgIF0KICB9LAogIHsKICAgICJp" + + "ZCI6ICJHNy1ib3RoLWRvY2tlci1oZWxtLWF1dGgiLAogICAgInF1ZXN0aW9uIjogIkF1dGhlbnRp" + + "Y2F0ZSB0byBOR0MgZm9yIE5WQ0YgaGVsbWZpbGUgZGVwbG95bWVudCIsCiAgICAiZXhwZWN0ZWRf" + + "c2tpbGwiOiAibnZjZi1zZWxmLW1hbmFnZWQtaW5zdGFsbGF0aW9uIiwKICAgICJncm91bmRfdHJ1" + + "dGgiOiAiVGhlIGFnZW50IHJhbiBib3RoIGRvY2tlciBsb2dpbiBhbmQgaGVsbSByZWdpc3RyeSBs" + + "b2dpbiBmb3IgbnZjci5pby4gSXQgZXhwbGFpbmVkIHRoYXQgYm90aCBhcmUgcmVxdWlyZWQgYmVj" + + "YXVzZSBoZWxtZmlsZSB1c2VzIGhlbG0gKG5vdCBkb2NrZXIpIHRvIHB1bGwgT0NJIGNoYXJ0cywg" + + "c28gZG9ja2VyIGxvZ2luIGFsb25lIGlzIGluc3VmZmljaWVudC4iLAogICAgImV4cGVjdGVkX2Jl" + + "aGF2aW9yIjogWwogICAgICAiVGhlIGFnZW50IHJlYWQgdGhlIG52Y2Ytc2VsZi1tYW5hZ2VkLWlu" + + "c3RhbGxhdGlvbiBTS0lMTC5tZCBiZWZvcmUgdGFraW5nIGFjdGlvbiIsCiAgICAgICJUaGUgYWdl" + + "bnQgcmFuICdkb2NrZXIgbG9naW4gbnZjci5pbycgd2l0aCAkb2F1dGh0b2tlbiB1c2VybmFtZSBh" + + "bmQgTkdDX0FQSV9LRVkgcGFzc3dvcmQiLAogICAgICAiVGhlIGFnZW50IHJhbiAnaGVsbSByZWdp" + + "c3RyeSBsb2dpbiBudmNyLmlvJyB3aXRoICRvYXV0aHRva2VuIHVzZXJuYW1lIGFuZCBOR0NfQVBJ" + + "X0tFWSBwYXNzd29yZCIsCiAgICAgICJUaGUgYWdlbnQgZXhwbGFpbmVkIHRoYXQgYm90aCBhcmUg" + + "cmVxdWlyZWQgYmVjYXVzZSBoZWxtZmlsZSB1c2VzIGhlbG0gKG5vdCBkb2NrZXIpIHRvIHB1bGwg" + + "T0NJIGNoYXJ0cyIsCiAgICAgICJUaGUgYWdlbnQgZGlkIG5vdCBwcm92aWRlIG9ubHkgb25lIG9m" + + "IHRoZSB0d28gYXV0aGVudGljYXRpb24gY29tbWFuZHMiCiAgICBdCiAgfSwKICB7CiAgICAiaWQi" + + "OiAiRzktbWlzc2luZy1idW5kbGUiLAogICAgInF1ZXN0aW9uIjogIlJ1biBoZWxtZmlsZSBzeW5j" + + "IGZvciBOVkNGIGluIG15IGN1cnJlbnQgZGlyZWN0b3J5IiwKICAgICJleHBlY3RlZF9za2lsbCI6" + + "ICJudmNmLXNlbGYtbWFuYWdlZC1pbnN0YWxsYXRpb24iLAogICAgImdyb3VuZF90cnV0aCI6ICJU" + + "aGUgYWdlbnQgYXR0ZW1wdGVkIHRvIHZlcmlmeSB0aGUgYnVuZGxlIHN0cnVjdHVyZSAoaGVsbWZp" + + "bGUuZC8sIGVudmlyb25tZW50cy8sIHNlY3JldHMvLCBnbG9iYWwueWFtbC5nb3RtcGwpIGFuZCB3" + + "aGVuIGZpbGVzIHdlcmUgbm90IGZvdW5kLCBzdG9wcGVkIGFuZCBpbnN0cnVjdGVkIHRoZSB1c2Vy" + + "IHRvIGV4dHJhY3Qgb3IgbG9jYXRlIHRoZSBudmNmLXNlbGYtbWFuYWdlZC1zdGFjayBidW5kbGUu" + + "IEl0IGRpZCBub3QgYXR0ZW1wdCB0byBydW4gaGVsbWZpbGUgc3luYyBhZ2FpbnN0IGEgbWlzc2lu" + + "ZyBidW5kbGUuIiwKICAgICJleHBlY3RlZF9iZWhhdmlvciI6IFsKICAgICAgIlRoZSBhZ2VudCBy" + + "ZWFkIHRoZSBudmNmLXNlbGYtbWFuYWdlZC1pbnN0YWxsYXRpb24gU0tJTEwubWQgYmVmb3JlIHRh" + + "a2luZyBhY3Rpb24iLAogICAgICAiVGhlIGFnZW50IGNoZWNrZWQgZm9yIGV4cGVjdGVkIGJ1bmRs" + + "ZSBzdHJ1Y3R1cmUgKGhlbG1maWxlLmQvLCBlbnZpcm9ubWVudHMvLCBzZWNyZXRzLywgZ2xvYmFs" + + "LnlhbWwuZ290bXBsKSIsCiAgICAgICJXaGVuIGJ1bmRsZSBmaWxlcyB3ZXJlIG5vdCBmb3VuZCwg" + + "dGhlIGFnZW50IHN0b3BwZWQgYW5kIGRpZCBub3QgYXR0ZW1wdCBoZWxtZmlsZSBzeW5jIiwKICAg" + + "ICAgIlRoZSBhZ2VudCBpbnN0cnVjdGVkIHRoZSB1c2VyIHRvIGV4dHJhY3Qgb3IgbG9jYXRlIHRo" + + "ZSBudmNmLXNlbGYtbWFuYWdlZC1zdGFjayBidW5kbGUiCiAgICBdCiAgfSwKICB7CiAgICAiaWQi" + + "OiAiUzEtY2xlYW4taW5zdGFsbGF0aW9uIiwKICAgICJxdWVzdGlvbiI6ICJQZXJmb3JtIGEgY2xl" + + "YW4gaW5zdGFsbGF0aW9uIG9mIHRoZSBOVkNGIHNlbGYtbWFuYWdlZCBzdGFjayBvbiBteSBBV1Mg" + + "RUtTIGNsdXN0ZXIuIE15IGVudmlyb25tZW50IG5hbWUgaXMgJ3N0YWdpbmcnLiIsCiAgICAiZXhw" + + "ZWN0ZWRfc2tpbGwiOiAibnZjZi1zZWxmLW1hbmFnZWQtaW5zdGFsbGF0aW9uIiwKICAgICJncm91" + + "bmRfdHJ1dGgiOiAiVGhlIGFnZW50IGNvbXBsZXRlZCB0aGUgY29udHJvbC1wbGFuZSBpbnN0YWxs" + + "YXRpb24gZmlyc3Q6IHZhbGlkYXRlZCB0b29scyBhbmQgYnVuZGxlIHN0cnVjdHVyZSwgY3JlYXRl" + + "ZCBjb250cm9sLXBsYW5lIG5hbWVzcGFjZXMgaW5jbHVkaW5nIGNlcnQtbWFuYWdlciwgYXV0aGVu" + + "dGljYXRlZCB0aGUgcmVnaXN0cmllcywgcHJldmlld2VkLCBkZXBsb3llZCwgYW5kIG1vbml0b3Jl" + + "ZCB0aGUgZm91ciBjb250cm9sLXBsYW5lIHBoYXNlcy4gSXQgdGhlbiBzZWxlY3RlZCBvbmUgZG9j" + + "dW1lbnRlZCBoYW5kb2ZmIGFuZCByZWdpc3RlcmVkIGFuZCBpbnN0YWxsZWQgdGhlIGNvbXB1dGUg" + + "cGxhbmUgYXMgYSBzZXBhcmF0ZSBzdGFjayB3aXRob3V0IG1peGluZyBwcm9maWxlIGFuZCBIZWxt" + + "ZmlsZSB2YWx1ZXMgZmxvd3MuIiwKICAgICJleHBlY3RlZF9iZWhhdmlvciI6IFsKICAgICAgIlRo" + + "ZSBhZ2VudCByZWFkIHRoZSBudmNmLXNlbGYtbWFuYWdlZC1pbnN0YWxsYXRpb24gU0tJTEwubWQg" + + "YmVmb3JlIHRha2luZyBhY3Rpb24iLAogICAgICAiVGhlIGFnZW50IHZhbGlkYXRlZCB0b29sIHZl" + + "cnNpb25zIChoZWxtZmlsZSwgaGVsbSwgaGVsbS1kaWZmLCBrdWJlY3RsKSIsCiAgICAgICJUaGUg" + + "YWdlbnQgdmVyaWZpZWQgdGhlIGJ1bmRsZSBzdHJ1Y3R1cmUgZXhpc3RzIiwKICAgICAgIlRoZSBh" + + "Z2VudCBjcmVhdGVkIGNvbnRyb2wtcGxhbmUgbmFtZXNwYWNlcyAoY2Fzc2FuZHJhLXN5c3RlbSwg" + + "bmF0cy1zeXN0ZW0sIG52Y2YsIGFwaS1rZXlzLCBlc3MsIHNpcywgdmF1bHQtc3lzdGVtLCBjZXJ0" + + "LW1hbmFnZXIpIHdpdGhvdXQgYWRkaW5nIGNvbXB1dGUtb25seSBuYW1lc3BhY2VzIiwKICAgICAg" + + "IlRoZSBhZ2VudCByYW4gJ0hFTE1GSUxFX0VOVj1zdGFnaW5nIGhlbG1maWxlIHRlbXBsYXRlJyB0" + + "byBwcmV2aWV3IGJlZm9yZSBkZXBsb3lpbmciLAogICAgICAiVGhlIGFnZW50IHJhbiAnSEVMTUZJ" + + "TEVfRU5WPXN0YWdpbmcgaGVsbWZpbGUgc3luYycgdG8gZGVwbG95IiwKICAgICAgIlRoZSBhZ2Vu" + + "dCBleHBsYWluZWQgdGhlIDQgY29udHJvbC1wbGFuZSBwaGFzZXMgKGRlcGVuZGVuY2llcywgc2Vy" + + "dmljZXMsIGluZ3Jlc3MsIG9ic2VydmFiaWxpdHkpIGFuZCBhcHByb3hpbWF0ZSB3YWl0IHRpbWVz" + + "IiwKICAgICAgIkFmdGVyIHRoZSBjb250cm9sIHBsYW5lIHdhcyBoZWFsdGh5LCB0aGUgYWdlbnQg" + + "cmVnaXN0ZXJlZCBhbmQgaW5zdGFsbGVkIHRoZSBzZXBhcmF0ZSBjb21wdXRlLXBsYW5lIHN0YWNr" + + "IHVzaW5nIGV4YWN0bHkgb25lIGRvY3VtZW50ZWQgaGFuZG9mZiIsCiAgICAgICJUaGUgYWdlbnQg" + + "ZGlkIG5vdCBtaXggYSBDTEktZ2VuZXJhdGVkIGNvbnRyb2wtcGxhbmUgcHJvZmlsZSB3aXRoIHRo" + + "ZSBIZWxtZmlsZSB2YWx1ZXMgZmxvdyIKICAgIF0KICB9LAogIHsKICAgICJpZCI6ICJTMy1jbGkt" + + "cHJvZmlsZS13b3JrZmxvdyIsCiAgICAicXVlc3Rpb24iOiAiVXNlIG52Y2YtY2xpIHRvIGluc3Rh" + + "bGwgbXkgY29udHJvbCBwbGFuZSBhbmQgdGhlbiByZWdpc3RlciBhbmQgaW5zdGFsbCBhIHNlcGFy" + + "YXRlIGNvbXB1dGUgY2x1c3Rlci4gU2hvdyBldmVyeSByZXF1aXJlZCBnbG9iYWwgZmxhZy4iLAog" + + "ICAgImV4cGVjdGVkX3NraWxsIjogIm52Y2Ytc2VsZi1tYW5hZ2VkLWluc3RhbGxhdGlvbiIsCiAg" + + "ICAiZ3JvdW5kX3RydXRoIjogIlRoZSBhZ2VudCBmaXJzdCByYW4gdGhlIENMSSBjb250cm9sLXBs" + + "YW5lIGluc3RhbGwgYW5kIHJlcXVpcmVkIGl0cyBnZW5lcmF0ZWQgY29udHJvbC1wbGFuZS1wcm9m" + + "aWxlLnlhbWwuIEl0IHRoZW4gc2hvd2VkIGNvbXBsZXRlIHJlZ2lzdGVyIGFuZCBpbnN0YWxsIGNv" + + "bW1hbmRzLCBlYWNoIGluY2x1ZGluZyAtLWNvbmZpZywgLS1jb250cm9sLXBsYW5lLXN0YWNrLCAt" + + "LWNvbXB1dGUtcGxhbmUtc3RhY2ssIC0tZW52LCBhbmQgLS1wbGFpbiBiZWZvcmUgdGhlIGNvbXB1" + + "dGUtcGxhbmUgc3ViY29tbWFuZC4gUmVnaXN0cmF0aW9uIGNvbnN1bWVkIHRoZSBwcm9maWxlIGFu" + + "ZCBwcm9kdWNlZCB0aGUgdmFsdWVzIGZpbGUgY29uc3VtZWQgYnkgaW5zdGFsbC4gSXQgZGlkIG5v" + + "dCBzd2l0Y2ggdG8gdGhlIEhlbG1maWxlIHZhbHVlcyBoYW5kb2ZmLiIsCiAgICAiZXhwZWN0ZWRf" + + "YmVoYXZpb3IiOiBbCiAgICAgICJUaGUgYWdlbnQgcmVhZCB0aGUgbnZjZi1zZWxmLW1hbmFnZWQt" + + "aW5zdGFsbGF0aW9uIFNLSUxMLm1kIGJlZm9yZSB0YWtpbmcgYWN0aW9uIiwKICAgICAgIlRoZSBh" + + "Z2VudCByYW4gbnZjZi1jbGkgc2VsZi1ob3N0ZWQgaW5zdGFsbCAtLWNvbnRyb2wtcGxhbmUgYW5k" + + "IHZlcmlmaWVkIGRlcGxveS9zdGFja3Mvc2VsZi1tYW5hZ2VkL291dC9jb250cm9sLXBsYW5lLXBy" + + "b2ZpbGUueWFtbCBleGlzdHMiLAogICAgICAiVGhlIHJlZ2lzdGVyIGNvbW1hbmQgaW5jbHVkZWQg" + + "LS1jb25maWcsIC0tY29udHJvbC1wbGFuZS1zdGFjaywgLS1jb21wdXRlLXBsYW5lLXN0YWNrLCAt" + + "LWVudiwgYW5kIC0tcGxhaW4iLAogICAgICAiVGhlIHJlZ2lzdGVyIGNvbW1hbmQgaW5jbHVkZWQg" + + "LS1jb250cm9sLXBsYW5lLXByb2ZpbGUsIC0tY2x1c3Rlci1uYW1lLCAtLWt1YmUtY29udGV4dCwg" + + "LS1yZWdpb24sIGFuZCAtLW91dHB1dCIsCiAgICAgICJUaGUgaW5zdGFsbCBjb21tYW5kIHJlcGVh" + + "dGVkIC0tY29uZmlnLCAtLWNvbnRyb2wtcGxhbmUtc3RhY2ssIC0tY29tcHV0ZS1wbGFuZS1zdGFj" + + "aywgLS1lbnYsIGFuZCAtLXBsYWluIiwKICAgICAgIlRoZSBpbnN0YWxsIGNvbW1hbmQgaW5jbHVk" + + "ZWQgLS12YWx1ZXMsIC0ta3ViZS1jb250ZXh0LCBhbmQgLS1jbHVzdGVyLW5hbWUiLAogICAgICAi" + + "VGhlIGFnZW50IGtlcHQgdGhlIGdlbmVyYXRlZCBwcm9maWxlIGFzIHRoZSBlbmRwb2ludCBzb3Vy" + + "Y2UgYW5kIGRpZCBub3QgbWl4IGluIEhlbG1maWxlIHZhbHVlcyByZWdpc3RyYXRpb24iCiAgICBd" + + "CiAgfSwKICB7CiAgICAiaWQiOiAiUzQtb3ZlcnJpZGUtY2Fzc2FuZHJhLXJlc291cmNlcyIsCiAg" + + "ICAicXVlc3Rpb24iOiAiQ2Fzc2FuZHJhIHBvZHMga2VlcCBnZXR0aW5nIE9PTUtpbGxlZC4gSW5j" + + "cmVhc2UgbWVtb3J5IGxpbWl0cyB0byAxNkdpLiIsCiAgICAiZXhwZWN0ZWRfc2tpbGwiOiAibnZj" + + "Zi1zZWxmLW1hbmFnZWQtaW5zdGFsbGF0aW9uIiwKICAgICJncm91bmRfdHJ1dGgiOiAiVGhlIGFn" + + "ZW50IGNhcHR1cmVkIHRoZSBiYXNlbGluZSB3aXRoIGhlbG1maWxlIHRlbXBsYXRlLCB0aGVuIG1v" + + "ZGlmaWVkIHRoZSBjYXNzYW5kcmEgcmVsZWFzZSB3aXRoIGlubGluZSB2YWx1ZXMgcmUtaW5jbHVk" + + "aW5nIGdsb2JhbC55YW1sLmdvdG1wbCBhbmQgc2VjcmV0cyBpbiB0aGUgdmFsdWVzIGJsb2NrLiBJ" + + "dCB3YXJuZWQgYWJvdXQgdGhlIFlBTUwgbWVyZ2UgZ290Y2hhIGFuZCBwcmV2aWV3ZWQgdGhlIGRp" + + "ZmYgYmVmb3JlIGFwcGx5aW5nLiIsCiAgICAiZXhwZWN0ZWRfYmVoYXZpb3IiOiBbCiAgICAgICJU" + + "aGUgYWdlbnQgcmVhZCB0aGUgbnZjZi1zZWxmLW1hbmFnZWQtaW5zdGFsbGF0aW9uIFNLSUxMLm1k" + + "IGJlZm9yZSB0YWtpbmcgYWN0aW9uIiwKICAgICAgIlRoZSBhZ2VudCBjYXB0dXJlZCBiYXNlbGlu" + + "ZSB3aXRoICdoZWxtZmlsZSAtLXNlbGVjdG9yIG5hbWU9Y2Fzc2FuZHJhIHRlbXBsYXRlJyIsCiAg" + + "ICAgICJUaGUgYWdlbnQgbW9kaWZpZWQgdGhlIHJlbGVhc2UgdmFsdWVzIGJsb2NrIHRvIGluY2x1" + + "ZGUgcmVzb3VyY2UgbGltaXRzIHdpdGggbWVtb3J5OiAxNkdpIiwKICAgICAgIlRoZSBhZ2VudCBy" + + "ZS1pbmNsdWRlZCBnbG9iYWwueWFtbC5nb3RtcGwgYW5kIHNlY3JldHMgZmlsZSBpbiB0aGUgdmFs" + + "dWVzOiBibG9jayAobm90IGp1c3QgdGhlIG92ZXJyaWRlIGFsb25lKSIsCiAgICAgICJUaGUgYWdl" + + "bnQgd2FybmVkIGFib3V0IHRoZSBZQU1MIG1lcmdlIGdvdGNoYTogc3BlY2lmeWluZyB2YWx1ZXM6" + + "IHJlcGxhY2VzIHRoZSB0ZW1wbGF0ZSdzIHZhbHVlcyBsaXN0IGVudGlyZWx5IiwKICAgICAgIlRo" + + "ZSBhZ2VudCBwcmV2aWV3ZWQgdGhlIGNoYW5nZSB3aXRoIGhlbG1maWxlIHRlbXBsYXRlIGFuZCBk" + + "aWZmIGJlZm9yZSBhcHBseWluZyB3aXRoIHN5bmMiCiAgICBdCiAgfSwKICB7CiAgICAiaWQiOiAi" + + "UzYtc2VsZWN0aXZlLXN5bmMtZGVwZW5kZW5jaWVzIiwKICAgICJxdWVzdGlvbiI6ICJEZXBsb3kg" + + "b25seSB0aGUgTlZDRiBkZXBlbmRlbmNpZXMgLS0gTkFUUywgQ2Fzc2FuZHJhLCBhbmQgT3BlbkJh" + + "byAtLSBmb3IgdGVzdGluZyIsCiAgICAiZXhwZWN0ZWRfc2tpbGwiOiAibnZjZi1zZWxmLW1hbmFn" + + "ZWQtaW5zdGFsbGF0aW9uIiwKICAgICJncm91bmRfdHJ1dGgiOiAiVGhlIGFnZW50IHVzZWQgdGhl" + + "IGhlbG1maWxlIHNlbGVjdG9yIHRvIGRlcGxveSBvbmx5IHRoZSBkZXBlbmRlbmNpZXMgcmVsZWFz" + + "ZSBncm91cCwgdGhlbiB2ZXJpZmllZCBwb2RzIGluIHRoZSBkZXBlbmRlbmN5IG5hbWVzcGFjZXMu" + "IiwKICAgICJleHBlY3RlZF9iZWhhdmlvciI6IFsKICAgICAgIlRoZSBhZ2VudCByZWFkIHRoZSBu" + "dmNmLXNlbGYtbWFuYWdlZC1pbnN0YWxsYXRpb24gU0tJTEwubWQgYmVmb3JlIHRha2luZyBhY3Rp" + - "b24iLAogICAgICAiVGhlIGFnZW50IGNvbmZpcm1lZCBhbmQgdXNlZCB0aGUgY29tcHV0ZS1wbGFu" + - "ZSBjb250ZXh0IGZvciBhbGwgY2xlYW51cCBjb21tYW5kcyIsCiAgICAgICJUaGUgYWdlbnQgdXNl" + - "ZCBrdWJlY3RsIHRvIHBhdGNoIE5WQ0ZCYWNrZW5kIHJlc291cmNlcyB0byByZW1vdmUgdGhlaXIg" + - "ZmluYWxpemVycyIsCiAgICAgICJUaGUgYWdlbnQgdXNlZCBrdWJlY3RsIHJlcGxhY2UgLS1yYXcg" + - "dG8gY2xlYXIgbmFtZXNwYWNlIGZpbmFsaXplcnMgb24gc3R1Y2sgbmFtZXNwYWNlcyIsCiAgICAg" + - "ICJUaGUgYWdlbnQgb25seSB0YXJnZXRlZCBOVkNGLW1hbmFnZWQgbmFtZXNwYWNlcyAobnZjYS1v" + - "cGVyYXRvciwgbnZjZi1iYWNrZW5kKSBhbmQgZGlkIG5vdCB0b3VjaCBvdGhlciBjbHVzdGVyIHJl" + - "c291cmNlcyIsCiAgICAgICJUaGUgYWdlbnQgZGlkIG5vdCBqdW1wIGRpcmVjdGx5IHRvIG5hbWVz" + - "cGFjZSBkZWxldGlvbiB3aXRob3V0IGZpcnN0IHJlbW92aW5nIGZpbmFsaXplcnMiCiAgICBdCiAg" + - "fSwKICB7CiAgICAiaWQiOiAiRzYtaGVsbWZpbGUtc3BsaXQtd29ya2Zsb3ciLAogICAgInF1ZXN0" + - "aW9uIjogIkluc3RhbGwgYW4gTlZDRiBjb250cm9sIHBsYW5lIGFuZCBhIHNlcGFyYXRlIEVLUyBj" + - "b21wdXRlIHBsYW5lIHVzaW5nIHRoZSBIZWxtZmlsZSBzdGFja3MuIFRoZSBjb21wdXRlIGNsdXN0" + - "ZXIga3ViZWNvbmZpZyBpcyBjb21wdXRlLnlhbWwuIiwKICAgICJleHBlY3RlZF9za2lsbCI6ICJu" + - "dmNmLXNlbGYtbWFuYWdlZC1pbnN0YWxsYXRpb24iLAogICAgImdyb3VuZF90cnV0aCI6ICJUaGUg" + - "YWdlbnQga2VwdCB0aGUgSGVsbWZpbGUgdmFsdWVzIGZsb3cgaW5kZXBlbmRlbnQgZnJvbSB0aGUg" + - "Q0xJIHByb2ZpbGUgZmxvdy4gSXQgYXV0aG9yZWQgc2VwYXJhdGUgY29udHJvbC1wbGFuZSBhbmQg" + - "Y29tcHV0ZS1wbGFuZSBlbnZpcm9ubWVudCBmaWxlcyBwbHVzIGEgYmFyZS1HYXRld2F5IENMSSBj" + - "b25maWcgd2l0aCBVUkwgYW5kIHNjaGVtZS1sZXNzIEhvc3QgZmllbGRzLCBpbnN0YWxsZWQgdGhl" + - "IGNvbnRyb2wgcGxhbmUsIHJhbiB0aGUgY29tcHV0ZS1wbGFuZSBNYWtlZmlsZSByZWdpc3Rlci1j" + - "bHVzdGVyIHRhcmdldCB3aXRoIElDTVNfVVJMIGFuZCB0aGUgY29tcHV0ZSBrdWJlY29uZmlnLCB0" + - "aGVuIHJhbiB0aGUgY29tcHV0ZS1wbGFuZSBpbnN0YWxsIHRhcmdldCB3aXRoIHRoZSBzYW1lIGVu" + - "dmlyb25tZW50IGFuZCBrdWJlY29uZmlnLiBJdCByZWxpZWQgb24gcmVnaXN0cmF0aW9uIHRvIGRp" + - "c2NvdmVyIE9JREMgYW5kIEpXS1MgZnJvbSB0aGUgY29tcHV0ZSBjb250ZXh0LiIsCiAgICAiZXhw" + - "ZWN0ZWRfYmVoYXZpb3IiOiBbCiAgICAgICJUaGUgYWdlbnQgcmVhZCB0aGUgbnZjZi1zZWxmLW1h" + - "bmFnZWQtaW5zdGFsbGF0aW9uIFNLSUxMLm1kIGJlZm9yZSB0YWtpbmcgYWN0aW9uIiwKICAgICAg" + - "IlRoZSBhZ2VudCBhdXRob3JlZCBzZXBhcmF0ZSBlbnZpcm9ubWVudHMvPGVudj4ueWFtbCBmaWxl" + - "cyB1bmRlciBkZXBsb3kvc3RhY2tzL3NlbGYtbWFuYWdlZCBhbmQgZGVwbG95L3N0YWNrcy9udmNm" + - "LWNvbXB1dGUtcGxhbmUiLAogICAgICAiVGhlIGFnZW50IGluc3RhbGxlZCB0aGUgY29udHJvbCBw" + - "bGFuZSBiZWZvcmUgcmVnaXN0ZXJpbmcgb3IgaW5zdGFsbGluZyB0aGUgY29tcHV0ZSBwbGFuZSIs" + - "CiAgICAgICJUaGUgYWdlbnQgY29uZmlndXJlZCBiYXNlX2h0dHBfdXJsLCBpbnZva2VfdXJsLCBi" + - "YXNlX2dycGNfdXJsLCBhcGlfa2V5c19zZXJ2aWNlX3VybCwgaWNtc191cmwsIGFwaV9ob3N0LCBh" + - "cGlfa2V5c19ob3N0LCBpbnZva2VfaG9zdCwgYW5kIGljbXNfaG9zdCBmb3IgdGhlIGJhcmUgR2F0" + - "ZXdheSIsCiAgICAgICJUaGUgYWdlbnQgdXNlZCAnbWFrZSAtQyBkZXBsb3kvc3RhY2tzL252Y2Yt" + - "Y29tcHV0ZS1wbGFuZSByZWdpc3Rlci1jbHVzdGVyJyB3aXRoIENMVVNURVJfTkFNRSwgTkNBX0lE" + - "LCBDTFVTVEVSX1JFR0lPTiwgSUNNU19VUkwsIGFuZCBLVUJFQ09ORklHX0ZJTEU9Y29tcHV0ZS55" + - "YW1sIiwKICAgICAgIlRoZSBhZ2VudCB1c2VkICdtYWtlIC1DIGRlcGxveS9zdGFja3MvbnZjZi1j" + - "b21wdXRlLXBsYW5lIGluc3RhbGwnIHdpdGggQ0xVU1RFUl9OQU1FLCBIRUxNRklMRV9FTlYsIGFu" + - "ZCBLVUJFQ09ORklHX0ZJTEU9Y29tcHV0ZS55YW1sIiwKICAgICAgIlRoZSBhZ2VudCBzdGF0ZWQg" + - "dGhhdCBJQ01TX1VSTCBtYXBzIG9ubHkgdG8gLS1pY21zLXVybCwgY29uZmlnIGljbXNfaG9zdCBz" + - "dXBwbGllcyB0aGUgSG9zdCBoZWFkZXIsIHRoZXJlIGlzIG5vIC0taWNtcy1ob3N0IE1ha2Ugb3Ig" + - "Q0xJIGZsYWcsIGFuZCByZWdpc3RyYXRpb24gZGlzY292ZXJzIE9JREMgYW5kIEpXS1MgZnJvbSB0" + - "aGUgY29tcHV0ZSBjb250ZXh0IiwKICAgICAgIlRoZSBhZ2VudCBkaWQgbm90IHJlcXVpcmUgYSBj" + - "b250cm9sLXBsYW5lIHByb2ZpbGUgZm9yIHRoaXMgZmxvdyBhbmQgZGlkIG5vdCBtaXggaW4gQ0xJ" + - "IHByb2ZpbGUgY29tbWFuZHMiCiAgICBdCiAgfSwKICB7CiAgICAiaWQiOiAiRzctYm90aC1kb2Nr" + - "ZXItaGVsbS1hdXRoIiwKICAgICJxdWVzdGlvbiI6ICJBdXRoZW50aWNhdGUgdG8gTkdDIGZvciBO" + - "VkNGIGhlbG1maWxlIGRlcGxveW1lbnQiLAogICAgImV4cGVjdGVkX3NraWxsIjogIm52Y2Ytc2Vs" + - "Zi1tYW5hZ2VkLWluc3RhbGxhdGlvbiIsCiAgICAiZ3JvdW5kX3RydXRoIjogIlRoZSBhZ2VudCBy" + - "YW4gYm90aCBkb2NrZXIgbG9naW4gYW5kIGhlbG0gcmVnaXN0cnkgbG9naW4gZm9yIG52Y3IuaW8u" + - "IEl0IGV4cGxhaW5lZCB0aGF0IGJvdGggYXJlIHJlcXVpcmVkIGJlY2F1c2UgaGVsbWZpbGUgdXNl" + - "cyBoZWxtIChub3QgZG9ja2VyKSB0byBwdWxsIE9DSSBjaGFydHMsIHNvIGRvY2tlciBsb2dpbiBh" + - "bG9uZSBpcyBpbnN1ZmZpY2llbnQuIiwKICAgICJleHBlY3RlZF9iZWhhdmlvciI6IFsKICAgICAg" + - "IlRoZSBhZ2VudCByZWFkIHRoZSBudmNmLXNlbGYtbWFuYWdlZC1pbnN0YWxsYXRpb24gU0tJTEwu" + - "bWQgYmVmb3JlIHRha2luZyBhY3Rpb24iLAogICAgICAiVGhlIGFnZW50IHJhbiAnZG9ja2VyIGxv" + - "Z2luIG52Y3IuaW8nIHdpdGggJG9hdXRodG9rZW4gdXNlcm5hbWUgYW5kIE5HQ19BUElfS0VZIHBh" + - "c3N3b3JkIiwKICAgICAgIlRoZSBhZ2VudCByYW4gJ2hlbG0gcmVnaXN0cnkgbG9naW4gbnZjci5p" + - "bycgd2l0aCAkb2F1dGh0b2tlbiB1c2VybmFtZSBhbmQgTkdDX0FQSV9LRVkgcGFzc3dvcmQiLAog" + - "ICAgICAiVGhlIGFnZW50IGV4cGxhaW5lZCB0aGF0IGJvdGggYXJlIHJlcXVpcmVkIGJlY2F1c2Ug" + - "aGVsbWZpbGUgdXNlcyBoZWxtIChub3QgZG9ja2VyKSB0byBwdWxsIE9DSSBjaGFydHMiLAogICAg" + - "ICAiVGhlIGFnZW50IGRpZCBub3QgcHJvdmlkZSBvbmx5IG9uZSBvZiB0aGUgdHdvIGF1dGhlbnRp" + - "Y2F0aW9uIGNvbW1hbmRzIgogICAgXQogIH0sCiAgewogICAgImlkIjogIkc5LW1pc3NpbmctYnVu" + - "ZGxlIiwKICAgICJxdWVzdGlvbiI6ICJSdW4gaGVsbWZpbGUgc3luYyBmb3IgTlZDRiBpbiBteSBj" + - "dXJyZW50IGRpcmVjdG9yeSIsCiAgICAiZXhwZWN0ZWRfc2tpbGwiOiAibnZjZi1zZWxmLW1hbmFn" + - "ZWQtaW5zdGFsbGF0aW9uIiwKICAgICJncm91bmRfdHJ1dGgiOiAiVGhlIGFnZW50IGF0dGVtcHRl" + - "ZCB0byB2ZXJpZnkgdGhlIGJ1bmRsZSBzdHJ1Y3R1cmUgKGhlbG1maWxlLmQvLCBlbnZpcm9ubWVu" + - "dHMvLCBzZWNyZXRzLywgZ2xvYmFsLnlhbWwuZ290bXBsKSBhbmQgd2hlbiBmaWxlcyB3ZXJlIG5v" + - "dCBmb3VuZCwgc3RvcHBlZCBhbmQgaW5zdHJ1Y3RlZCB0aGUgdXNlciB0byBleHRyYWN0IG9yIGxv" + - "Y2F0ZSB0aGUgbnZjZi1zZWxmLW1hbmFnZWQtc3RhY2sgYnVuZGxlLiBJdCBkaWQgbm90IGF0dGVt" + - "cHQgdG8gcnVuIGhlbG1maWxlIHN5bmMgYWdhaW5zdCBhIG1pc3NpbmcgYnVuZGxlLiIsCiAgICAi" + - "ZXhwZWN0ZWRfYmVoYXZpb3IiOiBbCiAgICAgICJUaGUgYWdlbnQgcmVhZCB0aGUgbnZjZi1zZWxm" + - "LW1hbmFnZWQtaW5zdGFsbGF0aW9uIFNLSUxMLm1kIGJlZm9yZSB0YWtpbmcgYWN0aW9uIiwKICAg" + - "ICAgIlRoZSBhZ2VudCBjaGVja2VkIGZvciBleHBlY3RlZCBidW5kbGUgc3RydWN0dXJlIChoZWxt" + - "ZmlsZS5kLywgZW52aXJvbm1lbnRzLywgc2VjcmV0cy8sIGdsb2JhbC55YW1sLmdvdG1wbCkiLAog" + - "ICAgICAiV2hlbiBidW5kbGUgZmlsZXMgd2VyZSBub3QgZm91bmQsIHRoZSBhZ2VudCBzdG9wcGVk" + - "IGFuZCBkaWQgbm90IGF0dGVtcHQgaGVsbWZpbGUgc3luYyIsCiAgICAgICJUaGUgYWdlbnQgaW5z" + - "dHJ1Y3RlZCB0aGUgdXNlciB0byBleHRyYWN0IG9yIGxvY2F0ZSB0aGUgbnZjZi1zZWxmLW1hbmFn" + - "ZWQtc3RhY2sgYnVuZGxlIgogICAgXQogIH0sCiAgewogICAgImlkIjogIlMxLWNsZWFuLWluc3Rh" + - "bGxhdGlvbiIsCiAgICAicXVlc3Rpb24iOiAiUGVyZm9ybSBhIGNsZWFuIGluc3RhbGxhdGlvbiBv" + - "ZiB0aGUgTlZDRiBzZWxmLW1hbmFnZWQgc3RhY2sgb24gbXkgQVdTIEVLUyBjbHVzdGVyLiBNeSBl" + - "bnZpcm9ubWVudCBuYW1lIGlzICdzdGFnaW5nJy4iLAogICAgImV4cGVjdGVkX3NraWxsIjogIm52" + - "Y2Ytc2VsZi1tYW5hZ2VkLWluc3RhbGxhdGlvbiIsCiAgICAiZ3JvdW5kX3RydXRoIjogIlRoZSBh" + - "Z2VudCBjb21wbGV0ZWQgdGhlIGNvbnRyb2wtcGxhbmUgaW5zdGFsbGF0aW9uIGZpcnN0OiB2YWxp" + - "ZGF0ZWQgdG9vbHMgYW5kIGJ1bmRsZSBzdHJ1Y3R1cmUsIGNyZWF0ZWQgY29udHJvbC1wbGFuZSBu" + - "YW1lc3BhY2VzIGluY2x1ZGluZyBjZXJ0LW1hbmFnZXIsIGF1dGhlbnRpY2F0ZWQgdGhlIHJlZ2lz" + - "dHJpZXMsIHByZXZpZXdlZCwgZGVwbG95ZWQsIGFuZCBtb25pdG9yZWQgdGhlIGZvdXIgY29udHJv" + - "bC1wbGFuZSBwaGFzZXMuIEl0IHRoZW4gc2VsZWN0ZWQgb25lIGRvY3VtZW50ZWQgaGFuZG9mZiBh" + - "bmQgcmVnaXN0ZXJlZCBhbmQgaW5zdGFsbGVkIHRoZSBjb21wdXRlIHBsYW5lIGFzIGEgc2VwYXJh" + - "dGUgc3RhY2sgd2l0aG91dCBtaXhpbmcgcHJvZmlsZSBhbmQgSGVsbWZpbGUgdmFsdWVzIGZsb3dz" + + "b24iLAogICAgICAiVGhlIGFnZW50IHVzZWQgJ2hlbG1maWxlIC0tc2VsZWN0b3IgcmVsZWFzZS1n" + + "cm91cD1kZXBlbmRlbmNpZXMgc3luYycgdG8gZGVwbG95IG9ubHkgZGVwZW5kZW5jaWVzIiwKICAg" + + "ICAgIlRoZSBhZ2VudCB2ZXJpZmllZCBwb2RzIGluIGRlcGVuZGVuY3kgbmFtZXNwYWNlcyAobmF0" + + "cy1zeXN0ZW0sIGNhc3NhbmRyYS1zeXN0ZW0sIHZhdWx0LXN5c3RlbSkiLAogICAgICAiVGhlIGFn" + + "ZW50IHByb3ZpZGVkIHRoZSBzZWxlY3RvciByZWZlcmVuY2UgZm9yIHRhcmdldGluZyBvdGhlciBy" + + "ZWxlYXNlIGdyb3VwcyIKICAgIF0KICB9LAogIHsKICAgICJpZCI6ICJTNy1kZWJ1Zy1pbWFnZXB1" + + "bGxiYWNrb2ZmIiwKICAgICJxdWVzdGlvbiI6ICJDYXNzYW5kcmEgcG9kcyBhcmUgaW4gSW1hZ2VQ" + + "dWxsQmFja09mZiB3aXRoIDQwMSBVbmF1dGhvcml6ZWQiLAogICAgImV4cGVjdGVkX3NraWxsIjog" + + "Im52Y2Ytc2VsZi1tYW5hZ2VkLWluc3RhbGxhdGlvbiIsCiAgICAiZ3JvdW5kX3RydXRoIjogIlRo" + + "ZSBhZ2VudCByZWFkIHRoZSBkZWJ1Z2dpbmcgcmVmZXJlbmNlIGFuZCByYW4gZGlhZ25vc3RpYyBj" + + "b21tYW5kcyB0byBpZGVudGlmeSB0aGUgcm9vdCBjYXVzZTogZGVzY3JpYmVkIHRoZSBwb2QsIGNo" + + "ZWNrZWQgZm9yIHB1bGwgc2VjcmV0cywgY2hlY2tlZCBpbWFnZVB1bGxTZWNyZXRzIG9uIHRoZSBw" + + "b2Qgc3BlYyBhbmQgc2VydmljZSBhY2NvdW50LiBJdCBpZGVudGlmaWVkIHRoZSBpc3N1ZSAobWlz" + + "c2luZyBzZWNyZXQsIHdyb25nIGNyZWRlbnRpYWxzLCBvciBtaXNzaW5nIGltYWdlUHVsbFNlY3Jl" + + "dHMpIGFuZCBwcm92aWRlZCB0aGUgY29ycmVjdCBmaXguIiwKICAgICJleHBlY3RlZF9iZWhhdmlv" + + "ciI6IFsKICAgICAgIlRoZSBhZ2VudCByZWFkIHRoZSBudmNmLXNlbGYtbWFuYWdlZC1pbnN0YWxs" + + "YXRpb24gU0tJTEwubWQgYW5kIHJlZmVyZW5jZXMvZGVidWdnaW5nLm1kIiwKICAgICAgIlRoZSBh" + + "Z2VudCByYW4gJ2t1YmVjdGwgZGVzY3JpYmUgcG9kJyB0byBzZWUgdGhlIEltYWdlUHVsbEJhY2tP" + + "ZmYgZXZlbnRzIiwKICAgICAgIlRoZSBhZ2VudCBjaGVja2VkIGZvciBwdWxsIHNlY3JldHMgaW4g" + + "dGhlIGNhc3NhbmRyYS1zeXN0ZW0gbmFtZXNwYWNlIiwKICAgICAgIlRoZSBhZ2VudCBjaGVja2Vk" + + "IGltYWdlUHVsbFNlY3JldHMgb24gdGhlIHBvZCBzcGVjIGFuZC9vciBzZXJ2aWNlIGFjY291bnQi" + + "LAogICAgICAiVGhlIGFnZW50IGlkZW50aWZpZWQgdGhlIHJvb3QgY2F1c2UgYW5kIHByb3ZpZGVk" + + "IGEgc3BlY2lmaWMgZml4IgogICAgXQogIH0sCiAgewogICAgImlkIjogIlM5LXJlbW90ZS1la3Mt" + + "cm91dGluZy1hbmQtc2VjcmV0cyIsCiAgICAicXVlc3Rpb24iOiAiQ29uZmlndXJlIGEgcmVtb3Rl" + + "IEVLUyBjb21wdXRlIGNsdXN0ZXIgdG8gcmVhY2ggbXkgTlZDRiBjb250cm9sIHBsYW5lIHRocm91" + + "Z2ggaXRzIEVudm95IEdhdGV3YXksIGluY2x1ZGluZyBOQVRTIGFuZCBwcml2YXRlLXJlZ2lzdHJ5" + + "IHB1bGwgc2VjcmV0cy4iLAogICAgImV4cGVjdGVkX3NraWxsIjogIm52Y2Ytc2VsZi1tYW5hZ2Vk" + + "LWluc3RhbGxhdGlvbiIsCiAgICAiZ3JvdW5kX3RydXRoIjogIlRoZSBhZ2VudCBjb25maWd1cmVk" + + "IHRoZSBjb250cm9sIHBsYW5lIHRvIHVzZSB0aGUgRW52b3kgR2F0ZXdheSBjb250cm9sbGVyIGlu" + + "IGVudm95LWdhdGV3YXktc3lzdGVtIGFuZCBHYXRld2F5L252Y2YtZ2F0ZXdheSBpbiBlbnZveS1n" + + "YXRld2F5LCBzZXQgYWxsIHNpeCByZW1vdGUgd29ya2VyIGVuZHBvaW50cyBhbmQgdGhlIGdycGMt" + + "cHJveHkgbG9jYWwgb3ZlcnJpZGUsIGVuYWJsZWQgTlZDRiBhbmQgTlZDVCBnUlBDIHJvdXRlcyBw" + + "bHVzIE5BVFMsIGFuZCBlbmFibGVkIE9wZW5CYW8gaXNzdWVyIGRpc2NvdmVyeS4gSXQgY29uZmln" + + "dXJlZCB0aGUgYmFyZS1HYXRld2F5IENMSSBVUkwgYW5kIEhvc3QgZmllbGRzIGluY2x1ZGluZyBp" + + "Y21zX2hvc3QsIHBsdXMgdGhlIGNvbXB1dGUtcGxhbmUgSUNNUywgUmVWYWwsIGFuZCBOQVRTIGV4" + + "dGVybmFsIFVSTHMgYW5kIGhvc3Qgb3ZlcnJpZGVzLiBJdCBjcmVhdGVkIHRoZSBwdWxsIHNlY3Jl" + + "dCBpbiBhbGwgY29udHJvbC1wbGFuZSBuYW1lc3BhY2VzIGluY2x1ZGluZyBjZXJ0LW1hbmFnZXIs" + + "IGJ1dCBvbmx5IGluIG52Y2Etb3BlcmF0b3Igb24gdGhlIGNvbXB1dGUgY2x1c3RlcjsgdGhlIGNo" + + "YXJ0IGFuZCBvcGVyYXRvciBtaXJyb3IgaXQgdG8gbnZjYS1zeXN0ZW0uIiwKICAgICJleHBlY3Rl" + + "ZF9iZWhhdmlvciI6IFsKICAgICAgIlRoZSBhZ2VudCByZWFkIHRoZSBudmNmLXNlbGYtbWFuYWdl" + + "ZC1pbnN0YWxsYXRpb24gU0tJTEwubWQgYmVmb3JlIHRha2luZyBhY3Rpb24iLAogICAgICAiVGhl" + + "IGFnZW50IHNldCBpbmdyZXNzLmdhdGV3YXlBcGkuY29udHJvbGxlck5hbWVzcGFjZSB0byBlbnZv" + + "eS1nYXRld2F5LXN5c3RlbSIsCiAgICAgICJUaGUgYWdlbnQgc2V0IHNoYXJlZCwgZ3JwYywgYW5k" + + "IG5hdHMgR2F0ZXdheSByZWZlcmVuY2VzIHRvIG5hbWUgbnZjZi1nYXRld2F5IGFuZCBuYW1lc3Bh" + + "Y2UgZW52b3ktZ2F0ZXdheSIsCiAgICAgICJUaGUgYWdlbnQgc2V0IGdsb2JhbC53b3JrZXJFbmRw" + + "b2ludHMubnZjZlNlcnZpY2VVUkwsIG52Y2ZHcnBjU2VydmljZVVSTCwgbnZjZk5hdHNTZXJ2aWNl" + + "VVJMLCBudmN0U2VydmljZVVSTCwgbnZjdEdycGNTZXJ2aWNlVVJMLCBhbmQgaW52b2NhdGlvblNl" + + "cnZpY2VVUkwiLAogICAgICAiVGhlIGFnZW50IHNldCBncnBjcHJveHkubnZjZkdycGNTZXJ2aWNl" + + "VVJMIHRvIHRoZSBjb250cm9sLXBsYW5lLWxvY2FsIEFQSSBnUlBDIHNlcnZpY2UiLAogICAgICAi" + + "VGhlIGFnZW50IGVuYWJsZWQgYm90aCBpbmdyZXNzLmdhdGV3YXlBcGkucm91dGVzLm52Y2ZBcGku" + + "Z3JwYyBhbmQgbnZjdEFwaS5ncnBjIHdpdGggd29ya2VyLWFwaSBhbmQgd29ya2VyLXRhc2tzIGhv" + + "c3RuYW1lcyIsCiAgICAgICJUaGUgYWdlbnQgZXhwbGljaXRseSBzZXQgaW5ncmVzcy5nYXRld2F5" + + "QXBpLnJvdXRlcy5uYXRzLmVuYWJsZWQgdG8gdHJ1ZSIsCiAgICAgICJUaGUgYWdlbnQgc2V0IG9w" + + "ZW5iYW8ubWlncmF0aW9ucy5pc3N1ZXJEaXNjb3ZlcnkuZW5hYmxlZCB0byB0cnVlIiwKICAgICAg" + + "IlRoZSBhZ2VudCBjb25maWd1cmVkIHRoZSBiYXJlLUdhdGV3YXkgQ0xJIFVSTCBhbmQgSG9zdCBm" + + "aWVsZHMsIGluY2x1ZGluZyBzY2hlbWUtbGVzcyBpY21zX2hvc3QiLAogICAgICAiVGhlIGFnZW50" + + "IGNvbmZpZ3VyZWQgY29tcHV0ZS1wbGFuZSBpY21zU2VydmljZVVSTCwgaWNtc1NlcnZpY2VIb3N0" + + "SGVhZGVyT3ZlcnJpZGUsIHJldmFsU2VydmljZVVSTCwgcmV2YWxTZXJ2aWNlSG9zdEhlYWRlck92" + + "ZXJyaWRlLCBuYXRzVVJMLCBhbmQgbmF0c0hvc3RPdmVycmlkZSIsCiAgICAgICJUaGUgY29udHJv" + + "bC1wbGFuZSBwdWxsLXNlY3JldCBuYW1lc3BhY2UgbGlzdCBpbmNsdWRlZCBjZXJ0LW1hbmFnZXIi" + + "LAogICAgICAiVGhlIGNvbXB1dGUtcGxhbmUgc2VjcmV0IHdhcyBjcmVhdGVkIG9ubHkgaW4gbnZj" + + "YS1vcGVyYXRvciBhbmQgbWlycm9yZWQgYnkgdGhlIGNoYXJ0IGFuZCBvcGVyYXRvciB0byBudmNh" + + "LXN5c3RlbSIKICAgIF0KICB9LAogIHsKICAgICJpZCI6ICJHMTEtc3BsaXQtdGVhcmRvd24iLAog" + + "ICAgInF1ZXN0aW9uIjogIlRlYXIgZG93biBteSBzcGxpdCBjb250cm9sLXBsYW5lIGFuZCBjb21w" + + "dXRlLXBsYW5lIGRlcGxveW1lbnQgc2FmZWx5LiBTaG93IGJvdGggdGhlIEhlbG1maWxlIHZhbHVl" + + "cyBhbmQgQ0xJIHByb2ZpbGUgdmFyaWFudHMuIiwKICAgICJleHBlY3RlZF9za2lsbCI6ICJudmNm" + + "LXNlbGYtbWFuYWdlZC1pbnN0YWxsYXRpb24iLAogICAgImdyb3VuZF90cnV0aCI6ICJUaGUgSGVs" + + "bWZpbGUgZmxvdyBkZXN0cm95ZWQgYW5kIGNvbmZpcm1lZCBkZXJlZ2lzdHJhdGlvbiBvZiBldmVy" + + "eSBjb21wdXRlIGNsdXN0ZXIgYmVmb3JlIGRlc3Ryb3lpbmcgdGhlIGNvbnRyb2wgcGxhbmUgYW5k" + + "IHBhc3NlZCBib3RoIGNvbnRyb2wtcGxhbmUga3ViZWNvbmZpZyBmb3Jtcy4gQmVmb3JlIGVpdGhl" + + "ciBoYW5kb2ZmIGNvdWxkIGRlc3Ryb3kgdGhlIGNvbnRyb2wgcGxhbmUsIGJvdGggdGVhcmRvd24g" + + "Zmxvd3Mgd2FybmVkIHRoYXQgbmFtZXNwYWNlIHByZXNlcnZhdGlvbiBkb2VzIG5vdCBwcmVzZXJ2" + + "ZSB0aGUgSGVsbSByZWxlYXNlLCByZXF1aXJlZCBlZmZlY3RpdmUgY2VydE1hbmFnZXIuZW5hYmxl" + + "ZDogZmFsc2UgZm9yIGFuIGV4dGVybmFsIGluc3RhbGxhdGlvbiBhbmQgYWJvcnRlZCBpZiB0cnVl" + + "LCBhbmQgdmVyaWZpZWQgbWF0Y2hpbmcgcmVsZWFzZSBvd25lcnNoaXAgZm9yIGFuIGludGVuZGVk" + + "IHN0YWNrLW1hbmFnZWQgcmVsZWFzZSwgYWJvcnRpbmcgb24gbWlzc2luZyBvciBtaXNtYXRjaGVk" + + "IGV2aWRlbmNlLiBUaGV5IHByZXNlcnZlZCB0aGUgbmFtZXNwYWNlIGJ5IGRlZmF1bHQgYW5kIGRp" + + "ZCBub3QgZGVsZXRlIGl0IHdpdGhvdXQgbmFtZXNwYWNlIHByb3ZlbmFuY2UgYW5kIGV4cGxpY2l0" + + "IGNvbmZpcm1hdGlvbi4gVGhlIENMSSBmbG93IHJldGFpbmVkIHRoZSBnZW5lcmF0ZWQgcmVnaXN0" + + "cmF0aW9uIHZhbHVlcywgdXNlZCB0aGUgZnVsbC1wcmVmaXggc3RhdHVzIGNvbW1hbmQgdG8gaW5z" + + "cGVjdCBsaXZlIHJlZ2lzdHJhdGlvbnMsIHN0YXRlZCB0aGF0IG5hbWVkLWNsdXN0ZXIgcGxhbi1v" + + "bmx5IGRvZXMgbm90IHF1ZXJ5IElDTVMgYW5kIGNhbm5vdCBwcmVkaWN0IGNvbmRpdGlvbmFsIGNv" + + "bnRyb2wtcGxhbmUgcmVtb3ZhbCwgYW5kIGdvdCBleHBsaWNpdCBjb25maXJtYXRpb24gd2hlbiB0" + + "aGUgdGFyZ2V0IHdhcyB0aGUgbGFzdCByZWdpc3RlcmVkIGNsdXN0ZXIuIEl0IHRoZW4gcHJldmll" + + "d2VkIGFuZCByYW4gZG93biB3aXRoIHRoZSBmdWxsIHBlcnNpc3RlbnQgcHJlZml4LCByZW1vdmlu" + + "ZyB0aGUgY29udHJvbCBwbGFuZSBvbmx5IGFmdGVyIHRoZSBsYXN0IHJlZ2lzdHJhdGlvbiB3YXMg" + + "Z29uZS4iLAogICAgImV4cGVjdGVkX2JlaGF2aW9yIjogWwogICAgICAiVGhlIGFnZW50IHJlYWQg" + + "dGhlIG52Y2Ytc2VsZi1tYW5hZ2VkLWluc3RhbGxhdGlvbiBTS0lMTC5tZCBiZWZvcmUgdGFraW5n" + + "IGFjdGlvbiIsCiAgICAgICJGb3IgZXZlcnkgY29tcHV0ZSBjbHVzdGVyLCB0aGUgSGVsbWZpbGUg" + + "ZmxvdyByYW4gdGhlIGNvbXB1dGUtcGxhbmUgTWFrZWZpbGUgZGVzdHJveSB0YXJnZXQgd2l0aCBp" + + "dHMgY29tcHV0ZSBrdWJlY29uZmlnIiwKICAgICAgIkFmdGVyIGNvbmZpcm1hdGlvbiwgdGhlIEhl" + + "bG1maWxlIGZsb3cgcmFuIGNsdXN0ZXIgZGVsZXRlIHdpdGggY2x1c3RlcklEIGFuZCBuY2FJRCBi" + + "ZWZvcmUgY29udHJvbC1wbGFuZSBkZXN0cnVjdGlvbiIsCiAgICAgICJCZWZvcmUgZWl0aGVyIGhh" + + "bmRvZmYgY291bGQgZGVzdHJveSB0aGUgY29udHJvbCBwbGFuZSwgYm90aCB0ZWFyZG93biBmbG93" + + "cyB3YXJuZWQgdGhhdCBuYW1lc3BhY2UgcHJlc2VydmF0aW9uIGRvZXMgbm90IHByZXNlcnZlIHRo" + + "ZSBIZWxtIHJlbGVhc2UsIHJlcXVpcmVkIGVmZmVjdGl2ZSBjZXJ0TWFuYWdlci5lbmFibGVkOiBm" + + "YWxzZSBmb3IgYW4gZXh0ZXJuYWwgaW5zdGFsbGF0aW9uIGFuZCBhYm9ydGVkIGlmIHRydWUsIGFu" + + "ZCB2ZXJpZmllZCBpbnRlbmRlZCBzdGFjayBvd25lcnNoaXAgd2hlbiBlbmFibGVkLCBhYm9ydGlu" + + "ZyBvbiBtaXNzaW5nIG9yIG1pc21hdGNoZWQgZXZpZGVuY2UiLAogICAgICAiQm90aCB0ZWFyZG93" + + "biBmbG93cyBwcmVzZXJ2ZWQgdGhlIGNlcnQtbWFuYWdlciBuYW1lc3BhY2UgYnkgZGVmYXVsdCBh" + + "bmQgZGlkIG5vdCBkZWxldGUgaXQgd2l0aG91dCBuYW1lc3BhY2UgcHJvdmVuYW5jZSBhbmQgZXhw" + + "bGljaXQgY29uZmlybWF0aW9uIiwKICAgICAgIlRoZSBIZWxtZmlsZSBmbG93IHJhbiBjb250cm9s" + + "LXBsYW5lIE1ha2VmaWxlIGRlc3Ryb3kgd2l0aCBib3RoIEtVQkVDT05GSUcgYW5kIEtVQkVDT05G" + + "SUdfRklMRSIsCiAgICAgICJUaGUgQ0xJIGZsb3cgcmV0YWluZWQgb3V0LzxjbHVzdGVyLW5hbWU+" + + "LXJlZ2lzdGVyLXZhbHVlcy55YW1sIHVudGlsIHRlYXJkb3duIGNvbXBsZXRlZCIsCiAgICAgICJC" + + "ZWZvcmUgcmVhbCBkb3duLCB0aGUgQ0xJIGZsb3cgdXNlZCB0aGUgZnVsbC1wcmVmaXggc3RhdHVz" + + "IGNvbW1hbmQgdG8gaW5zcGVjdCBsaXZlIHJlZ2lzdHJhdGlvbnMsIHN0YXRlZCB0aGF0IG5hbWVk" + + "LWNsdXN0ZXIgcGxhbi1vbmx5IGRvZXMgbm90IHF1ZXJ5IElDTVMgYW5kIGNhbm5vdCBwcmVkaWN0" + + "IGNvbmRpdGlvbmFsIGNvbnRyb2wtcGxhbmUgcmVtb3ZhbCwgd2FybmVkIHdoZW4gdGhlIHRhcmdl" + + "dCB3YXMgdGhlIGxhc3QgcmVnaXN0ZXJlZCBjbHVzdGVyLCBhbmQgZ290IGV4cGxpY2l0IGNvbmZp" + + "cm1hdGlvbiIsCiAgICAgICJUaGUgQ0xJIGZsb3cgdXNlZCAtLWNvbmZpZywgYm90aCBzdGFjayBw" + + "YXRocywgLS1lbnYsIC0tcGxhaW4sIGJvdGggY29udGV4dHMsIGFuZCAtLWljbXMtdXJsIGZvciBk" + + "b3duIC0tcGxhbi1vbmx5IGFuZCB0aGVuIGRvd24iLAogICAgICAiVGhlIGFnZW50IHN0YXRlZCB0" + + "aGF0IGRvd24gdW5yZWdpc3RlcnMgZWFjaCBjb21wdXRlIGNsdXN0ZXIgYW5kIHJlbW92ZXMgdGhl" + + "IGNvbnRyb2wgcGxhbmUgb25seSBhZnRlciBubyByZWdpc3RyYXRpb25zIHJlbWFpbiIKICAgIF0K" + + "ICB9LAogIHsKICAgICJpZCI6ICJTMTMtdmFsdWVzLXByZWNlZGVuY2UiLAogICAgInF1ZXN0aW9u" + + "IjogIkkgYWRkZWQgYSB2YWx1ZSB0byBteSBlbnZpcm9ubWVudCBZQU1MIGJ1dCBpdCdzIGJlaW5n" + + "IHNpbGVudGx5IGlnbm9yZWQuIEhvdyBkbyBoZWxtZmlsZSB2YWx1ZXMgd29yayBpbiBOVkNGPyIs" + + "CiAgICAiZXhwZWN0ZWRfc2tpbGwiOiAibnZjZi1zZWxmLW1hbmFnZWQtaW5zdGFsbGF0aW9uIiwK" + + "ICAgICJncm91bmRfdHJ1dGgiOiAiVGhlIGFnZW50IGV4cGxhaW5lZCB0aGUgdmFsdWVzIHByZWNl" + + "ZGVuY2UgY2hhaW4gKGJhc2UueWFtbCwgZW52IFlBTUwsIGdsb2JhbC55YW1sLmdvdG1wbCwgc2Vj" + + "cmV0cywgaW5saW5lIHZhbHVlcyksIGlkZW50aWZpZWQgdGhhdCBnbG9iYWwueWFtbC5nb3RtcGwg" + + "b25seSBwYXNzZXMgdGhyb3VnaCBzcGVjaWZpYyBrZXlzLCBhbmQgZXhwbGFpbmVkIHRoYXQgYXJi" + + "aXRyYXJ5IGNoYXJ0IHZhbHVlcyBtdXN0IHVzZSByZWxlYXNlIGlubGluZSB2YWx1ZXMgYmxvY2tz" + "LiIsCiAgICAiZXhwZWN0ZWRfYmVoYXZpb3IiOiBbCiAgICAgICJUaGUgYWdlbnQgcmVhZCB0aGUg" + "bnZjZi1zZWxmLW1hbmFnZWQtaW5zdGFsbGF0aW9uIFNLSUxMLm1kIGJlZm9yZSB0YWtpbmcgYWN0" + - "aW9uIiwKICAgICAgIlRoZSBhZ2VudCB2YWxpZGF0ZWQgdG9vbCB2ZXJzaW9ucyAoaGVsbWZpbGUs" + - "IGhlbG0sIGhlbG0tZGlmZiwga3ViZWN0bCkiLAogICAgICAiVGhlIGFnZW50IHZlcmlmaWVkIHRo" + - "ZSBidW5kbGUgc3RydWN0dXJlIGV4aXN0cyIsCiAgICAgICJUaGUgYWdlbnQgY3JlYXRlZCBjb250" + - "cm9sLXBsYW5lIG5hbWVzcGFjZXMgKGNhc3NhbmRyYS1zeXN0ZW0sIG5hdHMtc3lzdGVtLCBudmNm" + - "LCBhcGkta2V5cywgZXNzLCBzaXMsIHZhdWx0LXN5c3RlbSwgY2VydC1tYW5hZ2VyKSB3aXRob3V0" + - "IGFkZGluZyBjb21wdXRlLW9ubHkgbmFtZXNwYWNlcyIsCiAgICAgICJUaGUgYWdlbnQgcmFuICdI" + - "RUxNRklMRV9FTlY9c3RhZ2luZyBoZWxtZmlsZSB0ZW1wbGF0ZScgdG8gcHJldmlldyBiZWZvcmUg" + - "ZGVwbG95aW5nIiwKICAgICAgIlRoZSBhZ2VudCByYW4gJ0hFTE1GSUxFX0VOVj1zdGFnaW5nIGhl" + - "bG1maWxlIHN5bmMnIHRvIGRlcGxveSIsCiAgICAgICJUaGUgYWdlbnQgZXhwbGFpbmVkIHRoZSA0" + - "IGNvbnRyb2wtcGxhbmUgcGhhc2VzIChkZXBlbmRlbmNpZXMsIHNlcnZpY2VzLCBpbmdyZXNzLCBv" + - "YnNlcnZhYmlsaXR5KSBhbmQgYXBwcm94aW1hdGUgd2FpdCB0aW1lcyIsCiAgICAgICJBZnRlciB0" + - "aGUgY29udHJvbCBwbGFuZSB3YXMgaGVhbHRoeSwgdGhlIGFnZW50IHJlZ2lzdGVyZWQgYW5kIGlu" + - "c3RhbGxlZCB0aGUgc2VwYXJhdGUgY29tcHV0ZS1wbGFuZSBzdGFjayB1c2luZyBleGFjdGx5IG9u" + - "ZSBkb2N1bWVudGVkIGhhbmRvZmYiLAogICAgICAiVGhlIGFnZW50IGRpZCBub3QgbWl4IGEgQ0xJ" + - "LWdlbmVyYXRlZCBjb250cm9sLXBsYW5lIHByb2ZpbGUgd2l0aCB0aGUgSGVsbWZpbGUgdmFsdWVz" + - "IGZsb3ciCiAgICBdCiAgfSwKICB7CiAgICAiaWQiOiAiUzMtY2xpLXByb2ZpbGUtd29ya2Zsb3ci" + - "LAogICAgInF1ZXN0aW9uIjogIlVzZSBudmNmLWNsaSB0byBpbnN0YWxsIG15IGNvbnRyb2wgcGxh" + - "bmUgYW5kIHRoZW4gcmVnaXN0ZXIgYW5kIGluc3RhbGwgYSBzZXBhcmF0ZSBjb21wdXRlIGNsdXN0" + - "ZXIuIFNob3cgZXZlcnkgcmVxdWlyZWQgZ2xvYmFsIGZsYWcuIiwKICAgICJleHBlY3RlZF9za2ls" + - "bCI6ICJudmNmLXNlbGYtbWFuYWdlZC1pbnN0YWxsYXRpb24iLAogICAgImdyb3VuZF90cnV0aCI6" + - "ICJUaGUgYWdlbnQgZmlyc3QgcmFuIHRoZSBDTEkgY29udHJvbC1wbGFuZSBpbnN0YWxsIGFuZCBy" + - "ZXF1aXJlZCBpdHMgZ2VuZXJhdGVkIGNvbnRyb2wtcGxhbmUtcHJvZmlsZS55YW1sLiBJdCB0aGVu" + - "IHNob3dlZCBjb21wbGV0ZSByZWdpc3RlciBhbmQgaW5zdGFsbCBjb21tYW5kcywgZWFjaCBpbmNs" + - "dWRpbmcgLS1jb25maWcsIC0tY29udHJvbC1wbGFuZS1zdGFjaywgLS1jb21wdXRlLXBsYW5lLXN0" + - "YWNrLCAtLWVudiwgYW5kIC0tcGxhaW4gYmVmb3JlIHRoZSBjb21wdXRlLXBsYW5lIHN1YmNvbW1h" + - "bmQuIFJlZ2lzdHJhdGlvbiBjb25zdW1lZCB0aGUgcHJvZmlsZSBhbmQgcHJvZHVjZWQgdGhlIHZh" + - "bHVlcyBmaWxlIGNvbnN1bWVkIGJ5IGluc3RhbGwuIEl0IGRpZCBub3Qgc3dpdGNoIHRvIHRoZSBI" + - "ZWxtZmlsZSB2YWx1ZXMgaGFuZG9mZi4iLAogICAgImV4cGVjdGVkX2JlaGF2aW9yIjogWwogICAg" + - "ICAiVGhlIGFnZW50IHJlYWQgdGhlIG52Y2Ytc2VsZi1tYW5hZ2VkLWluc3RhbGxhdGlvbiBTS0lM" + - "TC5tZCBiZWZvcmUgdGFraW5nIGFjdGlvbiIsCiAgICAgICJUaGUgYWdlbnQgcmFuIG52Y2YtY2xp" + - "IHNlbGYtaG9zdGVkIGluc3RhbGwgLS1jb250cm9sLXBsYW5lIGFuZCB2ZXJpZmllZCBkZXBsb3kv" + - "c3RhY2tzL3NlbGYtbWFuYWdlZC9vdXQvY29udHJvbC1wbGFuZS1wcm9maWxlLnlhbWwgZXhpc3Rz" + - "IiwKICAgICAgIlRoZSByZWdpc3RlciBjb21tYW5kIGluY2x1ZGVkIC0tY29uZmlnLCAtLWNvbnRy" + - "b2wtcGxhbmUtc3RhY2ssIC0tY29tcHV0ZS1wbGFuZS1zdGFjaywgLS1lbnYsIGFuZCAtLXBsYWlu" + - "IiwKICAgICAgIlRoZSByZWdpc3RlciBjb21tYW5kIGluY2x1ZGVkIC0tY29udHJvbC1wbGFuZS1w" + - "cm9maWxlLCAtLWNsdXN0ZXItbmFtZSwgLS1rdWJlLWNvbnRleHQsIC0tcmVnaW9uLCBhbmQgLS1v" + - "dXRwdXQiLAogICAgICAiVGhlIGluc3RhbGwgY29tbWFuZCByZXBlYXRlZCAtLWNvbmZpZywgLS1j" + - "b250cm9sLXBsYW5lLXN0YWNrLCAtLWNvbXB1dGUtcGxhbmUtc3RhY2ssIC0tZW52LCBhbmQgLS1w" + - "bGFpbiIsCiAgICAgICJUaGUgaW5zdGFsbCBjb21tYW5kIGluY2x1ZGVkIC0tdmFsdWVzLCAtLWt1" + - "YmUtY29udGV4dCwgYW5kIC0tY2x1c3Rlci1uYW1lIiwKICAgICAgIlRoZSBhZ2VudCBrZXB0IHRo" + - "ZSBnZW5lcmF0ZWQgcHJvZmlsZSBhcyB0aGUgZW5kcG9pbnQgc291cmNlIGFuZCBkaWQgbm90IG1p" + - "eCBpbiBIZWxtZmlsZSB2YWx1ZXMgcmVnaXN0cmF0aW9uIgogICAgXQogIH0sCiAgewogICAgImlk" + - "IjogIlM0LW92ZXJyaWRlLWNhc3NhbmRyYS1yZXNvdXJjZXMiLAogICAgInF1ZXN0aW9uIjogIkNh" + - "c3NhbmRyYSBwb2RzIGtlZXAgZ2V0dGluZyBPT01LaWxsZWQuIEluY3JlYXNlIG1lbW9yeSBsaW1p" + - "dHMgdG8gMTZHaS4iLAogICAgImV4cGVjdGVkX3NraWxsIjogIm52Y2Ytc2VsZi1tYW5hZ2VkLWlu" + - "c3RhbGxhdGlvbiIsCiAgICAiZ3JvdW5kX3RydXRoIjogIlRoZSBhZ2VudCBjYXB0dXJlZCB0aGUg" + - "YmFzZWxpbmUgd2l0aCBoZWxtZmlsZSB0ZW1wbGF0ZSwgdGhlbiBtb2RpZmllZCB0aGUgY2Fzc2Fu" + - "ZHJhIHJlbGVhc2Ugd2l0aCBpbmxpbmUgdmFsdWVzIHJlLWluY2x1ZGluZyBnbG9iYWwueWFtbC5n" + - "b3RtcGwgYW5kIHNlY3JldHMgaW4gdGhlIHZhbHVlcyBibG9jay4gSXQgd2FybmVkIGFib3V0IHRo" + - "ZSBZQU1MIG1lcmdlIGdvdGNoYSBhbmQgcHJldmlld2VkIHRoZSBkaWZmIGJlZm9yZSBhcHBseWlu" + - "Zy4iLAogICAgImV4cGVjdGVkX2JlaGF2aW9yIjogWwogICAgICAiVGhlIGFnZW50IHJlYWQgdGhl" + - "IG52Y2Ytc2VsZi1tYW5hZ2VkLWluc3RhbGxhdGlvbiBTS0lMTC5tZCBiZWZvcmUgdGFraW5nIGFj" + - "dGlvbiIsCiAgICAgICJUaGUgYWdlbnQgY2FwdHVyZWQgYmFzZWxpbmUgd2l0aCAnaGVsbWZpbGUg" + - "LS1zZWxlY3RvciBuYW1lPWNhc3NhbmRyYSB0ZW1wbGF0ZSciLAogICAgICAiVGhlIGFnZW50IG1v" + - "ZGlmaWVkIHRoZSByZWxlYXNlIHZhbHVlcyBibG9jayB0byBpbmNsdWRlIHJlc291cmNlIGxpbWl0" + - "cyB3aXRoIG1lbW9yeTogMTZHaSIsCiAgICAgICJUaGUgYWdlbnQgcmUtaW5jbHVkZWQgZ2xvYmFs" + - "LnlhbWwuZ290bXBsIGFuZCBzZWNyZXRzIGZpbGUgaW4gdGhlIHZhbHVlczogYmxvY2sgKG5vdCBq" + - "dXN0IHRoZSBvdmVycmlkZSBhbG9uZSkiLAogICAgICAiVGhlIGFnZW50IHdhcm5lZCBhYm91dCB0" + - "aGUgWUFNTCBtZXJnZSBnb3RjaGE6IHNwZWNpZnlpbmcgdmFsdWVzOiByZXBsYWNlcyB0aGUgdGVt" + - "cGxhdGUncyB2YWx1ZXMgbGlzdCBlbnRpcmVseSIsCiAgICAgICJUaGUgYWdlbnQgcHJldmlld2Vk" + - "IHRoZSBjaGFuZ2Ugd2l0aCBoZWxtZmlsZSB0ZW1wbGF0ZSBhbmQgZGlmZiBiZWZvcmUgYXBwbHlp" + - "bmcgd2l0aCBzeW5jIgogICAgXQogIH0sCiAgewogICAgImlkIjogIlM2LXNlbGVjdGl2ZS1zeW5j" + - "LWRlcGVuZGVuY2llcyIsCiAgICAicXVlc3Rpb24iOiAiRGVwbG95IG9ubHkgdGhlIE5WQ0YgZGVw" + - "ZW5kZW5jaWVzIC0tIE5BVFMsIENhc3NhbmRyYSwgYW5kIE9wZW5CYW8gLS0gZm9yIHRlc3Rpbmci" + - "LAogICAgImV4cGVjdGVkX3NraWxsIjogIm52Y2Ytc2VsZi1tYW5hZ2VkLWluc3RhbGxhdGlvbiIs" + - "CiAgICAiZ3JvdW5kX3RydXRoIjogIlRoZSBhZ2VudCB1c2VkIHRoZSBoZWxtZmlsZSBzZWxlY3Rv" + - "ciB0byBkZXBsb3kgb25seSB0aGUgZGVwZW5kZW5jaWVzIHJlbGVhc2UgZ3JvdXAsIHRoZW4gdmVy" + - "aWZpZWQgcG9kcyBpbiB0aGUgZGVwZW5kZW5jeSBuYW1lc3BhY2VzLiIsCiAgICAiZXhwZWN0ZWRf" + - "YmVoYXZpb3IiOiBbCiAgICAgICJUaGUgYWdlbnQgcmVhZCB0aGUgbnZjZi1zZWxmLW1hbmFnZWQt" + - "aW5zdGFsbGF0aW9uIFNLSUxMLm1kIGJlZm9yZSB0YWtpbmcgYWN0aW9uIiwKICAgICAgIlRoZSBh" + - "Z2VudCB1c2VkICdoZWxtZmlsZSAtLXNlbGVjdG9yIHJlbGVhc2UtZ3JvdXA9ZGVwZW5kZW5jaWVz" + - "IHN5bmMnIHRvIGRlcGxveSBvbmx5IGRlcGVuZGVuY2llcyIsCiAgICAgICJUaGUgYWdlbnQgdmVy" + - "aWZpZWQgcG9kcyBpbiBkZXBlbmRlbmN5IG5hbWVzcGFjZXMgKG5hdHMtc3lzdGVtLCBjYXNzYW5k" + - "cmEtc3lzdGVtLCB2YXVsdC1zeXN0ZW0pIiwKICAgICAgIlRoZSBhZ2VudCBwcm92aWRlZCB0aGUg" + - "c2VsZWN0b3IgcmVmZXJlbmNlIGZvciB0YXJnZXRpbmcgb3RoZXIgcmVsZWFzZSBncm91cHMiCiAg" + - "ICBdCiAgfSwKICB7CiAgICAiaWQiOiAiUzctZGVidWctaW1hZ2VwdWxsYmFja29mZiIsCiAgICAi" + - "cXVlc3Rpb24iOiAiQ2Fzc2FuZHJhIHBvZHMgYXJlIGluIEltYWdlUHVsbEJhY2tPZmYgd2l0aCA0" + - "MDEgVW5hdXRob3JpemVkIiwKICAgICJleHBlY3RlZF9za2lsbCI6ICJudmNmLXNlbGYtbWFuYWdl" + - "ZC1pbnN0YWxsYXRpb24iLAogICAgImdyb3VuZF90cnV0aCI6ICJUaGUgYWdlbnQgcmVhZCB0aGUg" + - "ZGVidWdnaW5nIHJlZmVyZW5jZSBhbmQgcmFuIGRpYWdub3N0aWMgY29tbWFuZHMgdG8gaWRlbnRp" + - "ZnkgdGhlIHJvb3QgY2F1c2U6IGRlc2NyaWJlZCB0aGUgcG9kLCBjaGVja2VkIGZvciBwdWxsIHNl" + - "Y3JldHMsIGNoZWNrZWQgaW1hZ2VQdWxsU2VjcmV0cyBvbiB0aGUgcG9kIHNwZWMgYW5kIHNlcnZp" + - "Y2UgYWNjb3VudC4gSXQgaWRlbnRpZmllZCB0aGUgaXNzdWUgKG1pc3Npbmcgc2VjcmV0LCB3cm9u" + - "ZyBjcmVkZW50aWFscywgb3IgbWlzc2luZyBpbWFnZVB1bGxTZWNyZXRzKSBhbmQgcHJvdmlkZWQg" + - "dGhlIGNvcnJlY3QgZml4LiIsCiAgICAiZXhwZWN0ZWRfYmVoYXZpb3IiOiBbCiAgICAgICJUaGUg" + - "YWdlbnQgcmVhZCB0aGUgbnZjZi1zZWxmLW1hbmFnZWQtaW5zdGFsbGF0aW9uIFNLSUxMLm1kIGFu" + - "ZCByZWZlcmVuY2VzL2RlYnVnZ2luZy5tZCIsCiAgICAgICJUaGUgYWdlbnQgcmFuICdrdWJlY3Rs" + - "IGRlc2NyaWJlIHBvZCcgdG8gc2VlIHRoZSBJbWFnZVB1bGxCYWNrT2ZmIGV2ZW50cyIsCiAgICAg" + - "ICJUaGUgYWdlbnQgY2hlY2tlZCBmb3IgcHVsbCBzZWNyZXRzIGluIHRoZSBjYXNzYW5kcmEtc3lz" + - "dGVtIG5hbWVzcGFjZSIsCiAgICAgICJUaGUgYWdlbnQgY2hlY2tlZCBpbWFnZVB1bGxTZWNyZXRz" + - "IG9uIHRoZSBwb2Qgc3BlYyBhbmQvb3Igc2VydmljZSBhY2NvdW50IiwKICAgICAgIlRoZSBhZ2Vu" + - "dCBpZGVudGlmaWVkIHRoZSByb290IGNhdXNlIGFuZCBwcm92aWRlZCBhIHNwZWNpZmljIGZpeCIK" + - "ICAgIF0KICB9LAogIHsKICAgICJpZCI6ICJTOS1yZW1vdGUtZWtzLXJvdXRpbmctYW5kLXNlY3Jl" + - "dHMiLAogICAgInF1ZXN0aW9uIjogIkNvbmZpZ3VyZSBhIHJlbW90ZSBFS1MgY29tcHV0ZSBjbHVz" + - "dGVyIHRvIHJlYWNoIG15IE5WQ0YgY29udHJvbCBwbGFuZSB0aHJvdWdoIGl0cyBFbnZveSBHYXRl" + - "d2F5LCBpbmNsdWRpbmcgTkFUUyBhbmQgcHJpdmF0ZS1yZWdpc3RyeSBwdWxsIHNlY3JldHMuIiwK" + - "ICAgICJleHBlY3RlZF9za2lsbCI6ICJudmNmLXNlbGYtbWFuYWdlZC1pbnN0YWxsYXRpb24iLAog" + - "ICAgImdyb3VuZF90cnV0aCI6ICJUaGUgYWdlbnQgY29uZmlndXJlZCB0aGUgY29udHJvbCBwbGFu" + - "ZSB0byB1c2UgdGhlIEVudm95IEdhdGV3YXkgY29udHJvbGxlciBpbiBlbnZveS1nYXRld2F5LXN5" + - "c3RlbSBhbmQgR2F0ZXdheS9udmNmLWdhdGV3YXkgaW4gZW52b3ktZ2F0ZXdheSwgc2V0IGFsbCBz" + - "aXggcmVtb3RlIHdvcmtlciBlbmRwb2ludHMgYW5kIHRoZSBncnBjLXByb3h5IGxvY2FsIG92ZXJy" + - "aWRlLCBlbmFibGVkIE5WQ0YgYW5kIE5WQ1QgZ1JQQyByb3V0ZXMgcGx1cyBOQVRTLCBhbmQgZW5h" + - "YmxlZCBPcGVuQmFvIGlzc3VlciBkaXNjb3ZlcnkuIEl0IGNvbmZpZ3VyZWQgdGhlIGJhcmUtR2F0" + - "ZXdheSBDTEkgVVJMIGFuZCBIb3N0IGZpZWxkcyBpbmNsdWRpbmcgaWNtc19ob3N0LCBwbHVzIHRo" + - "ZSBjb21wdXRlLXBsYW5lIElDTVMsIFJlVmFsLCBhbmQgTkFUUyBleHRlcm5hbCBVUkxzIGFuZCBo" + - "b3N0IG92ZXJyaWRlcy4gSXQgY3JlYXRlZCB0aGUgcHVsbCBzZWNyZXQgaW4gYWxsIGNvbnRyb2wt" + - "cGxhbmUgbmFtZXNwYWNlcyBpbmNsdWRpbmcgY2VydC1tYW5hZ2VyLCBidXQgb25seSBpbiBudmNh" + - "LW9wZXJhdG9yIG9uIHRoZSBjb21wdXRlIGNsdXN0ZXI7IHRoZSBjaGFydCBhbmQgb3BlcmF0b3Ig" + - "bWlycm9yIGl0IHRvIG52Y2Etc3lzdGVtLiIsCiAgICAiZXhwZWN0ZWRfYmVoYXZpb3IiOiBbCiAg" + - "ICAgICJUaGUgYWdlbnQgcmVhZCB0aGUgbnZjZi1zZWxmLW1hbmFnZWQtaW5zdGFsbGF0aW9uIFNL" + - "SUxMLm1kIGJlZm9yZSB0YWtpbmcgYWN0aW9uIiwKICAgICAgIlRoZSBhZ2VudCBzZXQgaW5ncmVz" + - "cy5nYXRld2F5QXBpLmNvbnRyb2xsZXJOYW1lc3BhY2UgdG8gZW52b3ktZ2F0ZXdheS1zeXN0ZW0i" + - "LAogICAgICAiVGhlIGFnZW50IHNldCBzaGFyZWQsIGdycGMsIGFuZCBuYXRzIEdhdGV3YXkgcmVm" + - "ZXJlbmNlcyB0byBuYW1lIG52Y2YtZ2F0ZXdheSBhbmQgbmFtZXNwYWNlIGVudm95LWdhdGV3YXki" + - "LAogICAgICAiVGhlIGFnZW50IHNldCBnbG9iYWwud29ya2VyRW5kcG9pbnRzLm52Y2ZTZXJ2aWNl" + - "VVJMLCBudmNmR3JwY1NlcnZpY2VVUkwsIG52Y2ZOYXRzU2VydmljZVVSTCwgbnZjdFNlcnZpY2VV" + - "UkwsIG52Y3RHcnBjU2VydmljZVVSTCwgYW5kIGludm9jYXRpb25TZXJ2aWNlVVJMIiwKICAgICAg" + - "IlRoZSBhZ2VudCBzZXQgZ3JwY3Byb3h5Lm52Y2ZHcnBjU2VydmljZVVSTCB0byB0aGUgY29udHJv" + - "bC1wbGFuZS1sb2NhbCBBUEkgZ1JQQyBzZXJ2aWNlIiwKICAgICAgIlRoZSBhZ2VudCBlbmFibGVk" + - "IGJvdGggaW5ncmVzcy5nYXRld2F5QXBpLnJvdXRlcy5udmNmQXBpLmdycGMgYW5kIG52Y3RBcGku" + - "Z3JwYyB3aXRoIHdvcmtlci1hcGkgYW5kIHdvcmtlci10YXNrcyBob3N0bmFtZXMiLAogICAgICAi" + - "VGhlIGFnZW50IGV4cGxpY2l0bHkgc2V0IGluZ3Jlc3MuZ2F0ZXdheUFwaS5yb3V0ZXMubmF0cy5l" + - "bmFibGVkIHRvIHRydWUiLAogICAgICAiVGhlIGFnZW50IHNldCBvcGVuYmFvLm1pZ3JhdGlvbnMu" + - "aXNzdWVyRGlzY292ZXJ5LmVuYWJsZWQgdG8gdHJ1ZSIsCiAgICAgICJUaGUgYWdlbnQgY29uZmln" + - "dXJlZCB0aGUgYmFyZS1HYXRld2F5IENMSSBVUkwgYW5kIEhvc3QgZmllbGRzLCBpbmNsdWRpbmcg" + - "c2NoZW1lLWxlc3MgaWNtc19ob3N0IiwKICAgICAgIlRoZSBhZ2VudCBjb25maWd1cmVkIGNvbXB1" + - "dGUtcGxhbmUgaWNtc1NlcnZpY2VVUkwsIGljbXNTZXJ2aWNlSG9zdEhlYWRlck92ZXJyaWRlLCBy" + - "ZXZhbFNlcnZpY2VVUkwsIHJldmFsU2VydmljZUhvc3RIZWFkZXJPdmVycmlkZSwgbmF0c1VSTCwg" + - "YW5kIG5hdHNIb3N0T3ZlcnJpZGUiLAogICAgICAiVGhlIGNvbnRyb2wtcGxhbmUgcHVsbC1zZWNy" + - "ZXQgbmFtZXNwYWNlIGxpc3QgaW5jbHVkZWQgY2VydC1tYW5hZ2VyIiwKICAgICAgIlRoZSBjb21w" + - "dXRlLXBsYW5lIHNlY3JldCB3YXMgY3JlYXRlZCBvbmx5IGluIG52Y2Etb3BlcmF0b3IgYW5kIG1p" + - "cnJvcmVkIGJ5IHRoZSBjaGFydCBhbmQgb3BlcmF0b3IgdG8gbnZjYS1zeXN0ZW0iCiAgICBdCiAg" + - "fSwKICB7CiAgICAiaWQiOiAiRzExLXNwbGl0LXRlYXJkb3duIiwKICAgICJxdWVzdGlvbiI6ICJU" + - "ZWFyIGRvd24gbXkgc3BsaXQgY29udHJvbC1wbGFuZSBhbmQgY29tcHV0ZS1wbGFuZSBkZXBsb3lt" + - "ZW50IHNhZmVseS4gU2hvdyBib3RoIHRoZSBIZWxtZmlsZSB2YWx1ZXMgYW5kIENMSSBwcm9maWxl" + - "IHZhcmlhbnRzLiIsCiAgICAiZXhwZWN0ZWRfc2tpbGwiOiAibnZjZi1zZWxmLW1hbmFnZWQtaW5z" + - "dGFsbGF0aW9uIiwKICAgICJncm91bmRfdHJ1dGgiOiAiVGhlIEhlbG1maWxlIGZsb3cgZGVzdHJv" + - "eWVkIGFuZCBjb25maXJtZWQgZGVyZWdpc3RyYXRpb24gb2YgZXZlcnkgY29tcHV0ZSBjbHVzdGVy" + - "IGJlZm9yZSBkZXN0cm95aW5nIHRoZSBjb250cm9sIHBsYW5lIGFuZCBwYXNzZWQgYm90aCBjb250" + - "cm9sLXBsYW5lIGt1YmVjb25maWcgZm9ybXMuIEJlZm9yZSBlaXRoZXIgaGFuZG9mZiBjb3VsZCBk" + - "ZXN0cm95IHRoZSBjb250cm9sIHBsYW5lLCBib3RoIHRlYXJkb3duIGZsb3dzIHdhcm5lZCB0aGF0" + - "IG5hbWVzcGFjZSBwcmVzZXJ2YXRpb24gZG9lcyBub3QgcHJlc2VydmUgdGhlIEhlbG0gcmVsZWFz" + - "ZSwgcmVxdWlyZWQgZWZmZWN0aXZlIGNlcnRNYW5hZ2VyLmVuYWJsZWQ6IGZhbHNlIGZvciBhbiBl" + - "eHRlcm5hbCBpbnN0YWxsYXRpb24gYW5kIGFib3J0ZWQgaWYgdHJ1ZSwgYW5kIHZlcmlmaWVkIG1h" + - "dGNoaW5nIHJlbGVhc2Ugb3duZXJzaGlwIGZvciBhbiBpbnRlbmRlZCBzdGFjay1tYW5hZ2VkIHJl" + - "bGVhc2UsIGFib3J0aW5nIG9uIG1pc3Npbmcgb3IgbWlzbWF0Y2hlZCBldmlkZW5jZS4gVGhleSBw" + - "cmVzZXJ2ZWQgdGhlIG5hbWVzcGFjZSBieSBkZWZhdWx0IGFuZCBkaWQgbm90IGRlbGV0ZSBpdCB3" + - "aXRob3V0IG5hbWVzcGFjZSBwcm92ZW5hbmNlIGFuZCBleHBsaWNpdCBjb25maXJtYXRpb24uIFRo" + - "ZSBDTEkgZmxvdyByZXRhaW5lZCB0aGUgZ2VuZXJhdGVkIHJlZ2lzdHJhdGlvbiB2YWx1ZXMsIHVz" + - "ZWQgdGhlIGZ1bGwtcHJlZml4IHN0YXR1cyBjb21tYW5kIHRvIGluc3BlY3QgbGl2ZSByZWdpc3Ry" + - "YXRpb25zLCBzdGF0ZWQgdGhhdCBuYW1lZC1jbHVzdGVyIHBsYW4tb25seSBkb2VzIG5vdCBxdWVy" + - "eSBJQ01TIGFuZCBjYW5ub3QgcHJlZGljdCBjb25kaXRpb25hbCBjb250cm9sLXBsYW5lIHJlbW92" + - "YWwsIGFuZCBnb3QgZXhwbGljaXQgY29uZmlybWF0aW9uIHdoZW4gdGhlIHRhcmdldCB3YXMgdGhl" + - "IGxhc3QgcmVnaXN0ZXJlZCBjbHVzdGVyLiBJdCB0aGVuIHByZXZpZXdlZCBhbmQgcmFuIGRvd24g" + - "d2l0aCB0aGUgZnVsbCBwZXJzaXN0ZW50IHByZWZpeCwgcmVtb3ZpbmcgdGhlIGNvbnRyb2wgcGxh" + - "bmUgb25seSBhZnRlciB0aGUgbGFzdCByZWdpc3RyYXRpb24gd2FzIGdvbmUuIiwKICAgICJleHBl" + - "Y3RlZF9iZWhhdmlvciI6IFsKICAgICAgIlRoZSBhZ2VudCByZWFkIHRoZSBudmNmLXNlbGYtbWFu" + - "YWdlZC1pbnN0YWxsYXRpb24gU0tJTEwubWQgYmVmb3JlIHRha2luZyBhY3Rpb24iLAogICAgICAi" + - "Rm9yIGV2ZXJ5IGNvbXB1dGUgY2x1c3RlciwgdGhlIEhlbG1maWxlIGZsb3cgcmFuIHRoZSBjb21w" + - "dXRlLXBsYW5lIE1ha2VmaWxlIGRlc3Ryb3kgdGFyZ2V0IHdpdGggaXRzIGNvbXB1dGUga3ViZWNv" + - "bmZpZyIsCiAgICAgICJBZnRlciBjb25maXJtYXRpb24sIHRoZSBIZWxtZmlsZSBmbG93IHJhbiBj" + - "bHVzdGVyIGRlbGV0ZSB3aXRoIGNsdXN0ZXJJRCBhbmQgbmNhSUQgYmVmb3JlIGNvbnRyb2wtcGxh" + - "bmUgZGVzdHJ1Y3Rpb24iLAogICAgICAiQmVmb3JlIGVpdGhlciBoYW5kb2ZmIGNvdWxkIGRlc3Ry" + - "b3kgdGhlIGNvbnRyb2wgcGxhbmUsIGJvdGggdGVhcmRvd24gZmxvd3Mgd2FybmVkIHRoYXQgbmFt" + - "ZXNwYWNlIHByZXNlcnZhdGlvbiBkb2VzIG5vdCBwcmVzZXJ2ZSB0aGUgSGVsbSByZWxlYXNlLCBy" + - "ZXF1aXJlZCBlZmZlY3RpdmUgY2VydE1hbmFnZXIuZW5hYmxlZDogZmFsc2UgZm9yIGFuIGV4dGVy" + - "bmFsIGluc3RhbGxhdGlvbiBhbmQgYWJvcnRlZCBpZiB0cnVlLCBhbmQgdmVyaWZpZWQgaW50ZW5k" + - "ZWQgc3RhY2sgb3duZXJzaGlwIHdoZW4gZW5hYmxlZCwgYWJvcnRpbmcgb24gbWlzc2luZyBvciBt" + - "aXNtYXRjaGVkIGV2aWRlbmNlIiwKICAgICAgIkJvdGggdGVhcmRvd24gZmxvd3MgcHJlc2VydmVk" + - "IHRoZSBjZXJ0LW1hbmFnZXIgbmFtZXNwYWNlIGJ5IGRlZmF1bHQgYW5kIGRpZCBub3QgZGVsZXRl" + - "IGl0IHdpdGhvdXQgbmFtZXNwYWNlIHByb3ZlbmFuY2UgYW5kIGV4cGxpY2l0IGNvbmZpcm1hdGlv" + - "biIsCiAgICAgICJUaGUgSGVsbWZpbGUgZmxvdyByYW4gY29udHJvbC1wbGFuZSBNYWtlZmlsZSBk" + - "ZXN0cm95IHdpdGggYm90aCBLVUJFQ09ORklHIGFuZCBLVUJFQ09ORklHX0ZJTEUiLAogICAgICAi" + - "VGhlIENMSSBmbG93IHJldGFpbmVkIG91dC88Y2x1c3Rlci1uYW1lPi1yZWdpc3Rlci12YWx1ZXMu" + - "eWFtbCB1bnRpbCB0ZWFyZG93biBjb21wbGV0ZWQiLAogICAgICAiQmVmb3JlIHJlYWwgZG93biwg" + - "dGhlIENMSSBmbG93IHVzZWQgdGhlIGZ1bGwtcHJlZml4IHN0YXR1cyBjb21tYW5kIHRvIGluc3Bl" + - "Y3QgbGl2ZSByZWdpc3RyYXRpb25zLCBzdGF0ZWQgdGhhdCBuYW1lZC1jbHVzdGVyIHBsYW4tb25s" + - "eSBkb2VzIG5vdCBxdWVyeSBJQ01TIGFuZCBjYW5ub3QgcHJlZGljdCBjb25kaXRpb25hbCBjb250" + - "cm9sLXBsYW5lIHJlbW92YWwsIHdhcm5lZCB3aGVuIHRoZSB0YXJnZXQgd2FzIHRoZSBsYXN0IHJl" + - "Z2lzdGVyZWQgY2x1c3RlciwgYW5kIGdvdCBleHBsaWNpdCBjb25maXJtYXRpb24iLAogICAgICAi" + - "VGhlIENMSSBmbG93IHVzZWQgLS1jb25maWcsIGJvdGggc3RhY2sgcGF0aHMsIC0tZW52LCAtLXBs" + - "YWluLCBib3RoIGNvbnRleHRzLCBhbmQgLS1pY21zLXVybCBmb3IgZG93biAtLXBsYW4tb25seSBh" + - "bmQgdGhlbiBkb3duIiwKICAgICAgIlRoZSBhZ2VudCBzdGF0ZWQgdGhhdCBkb3duIHVucmVnaXN0" + - "ZXJzIGVhY2ggY29tcHV0ZSBjbHVzdGVyIGFuZCByZW1vdmVzIHRoZSBjb250cm9sIHBsYW5lIG9u" + - "bHkgYWZ0ZXIgbm8gcmVnaXN0cmF0aW9ucyByZW1haW4iCiAgICBdCiAgfSwKICB7CiAgICAiaWQi" + - "OiAiUzEzLXZhbHVlcy1wcmVjZWRlbmNlIiwKICAgICJxdWVzdGlvbiI6ICJJIGFkZGVkIGEgdmFs" + - "dWUgdG8gbXkgZW52aXJvbm1lbnQgWUFNTCBidXQgaXQncyBiZWluZyBzaWxlbnRseSBpZ25vcmVk" + - "LiBIb3cgZG8gaGVsbWZpbGUgdmFsdWVzIHdvcmsgaW4gTlZDRj8iLAogICAgImV4cGVjdGVkX3Nr" + - "aWxsIjogIm52Y2Ytc2VsZi1tYW5hZ2VkLWluc3RhbGxhdGlvbiIsCiAgICAiZ3JvdW5kX3RydXRo" + - "IjogIlRoZSBhZ2VudCBleHBsYWluZWQgdGhlIHZhbHVlcyBwcmVjZWRlbmNlIGNoYWluIChiYXNl" + - "LnlhbWwsIGVudiBZQU1MLCBnbG9iYWwueWFtbC5nb3RtcGwsIHNlY3JldHMsIGlubGluZSB2YWx1" + - "ZXMpLCBpZGVudGlmaWVkIHRoYXQgZ2xvYmFsLnlhbWwuZ290bXBsIG9ubHkgcGFzc2VzIHRocm91" + - "Z2ggc3BlY2lmaWMga2V5cywgYW5kIGV4cGxhaW5lZCB0aGF0IGFyYml0cmFyeSBjaGFydCB2YWx1" + - "ZXMgbXVzdCB1c2UgcmVsZWFzZSBpbmxpbmUgdmFsdWVzIGJsb2Nrcy4iLAogICAgImV4cGVjdGVk" + - "X2JlaGF2aW9yIjogWwogICAgICAiVGhlIGFnZW50IHJlYWQgdGhlIG52Y2Ytc2VsZi1tYW5hZ2Vk" + - "LWluc3RhbGxhdGlvbiBTS0lMTC5tZCBiZWZvcmUgdGFraW5nIGFjdGlvbiIsCiAgICAgICJUaGUg" + - "YWdlbnQgZXhwbGFpbmVkIHRoZSB2YWx1ZXMgcHJlY2VkZW5jZSBjaGFpbjogYmFzZS55YW1sIC0+" + - "IGVudiBZQU1MIC0+IGdsb2JhbC55YW1sLmdvdG1wbCAtPiBzZWNyZXRzIC0+IGlubGluZSB2YWx1" + - "ZXMiLAogICAgICAiVGhlIGFnZW50IGlkZW50aWZpZWQgdGhhdCBnbG9iYWwueWFtbC5nb3RtcGwg" + - "b25seSBwYXNzZXMgdGhyb3VnaCBzcGVjaWZpYyBrZXlzIChjYXNzYW5kcmEucmVwbGljYUNvdW50" + - "LCBnbG9iYWwuc3RvcmFnZUNsYXNzLCBnbG9iYWwuaW1hZ2UsIGV0Yy4pIiwKICAgICAgIlRoZSBh" + - "Z2VudCBleHBsYWluZWQgdGhhdCBhcmJpdHJhcnkgY2hhcnQgdmFsdWVzIG11c3QgYmUgc2V0IHZp" + - "YSByZWxlYXNlIGlubGluZSB2YWx1ZXM6IGJsb2NrcyIsCiAgICAgICJUaGUgYWdlbnQgbGlzdGVk" + - "IGV4YW1wbGVzIG9mIHZhbHVlcyB0aGF0IGFyZSBwcm9wYWdhdGVkIGFuZCBhcmJpdHJhcnkgY2hh" + - "cnQgdmFsdWVzIHRoYXQgcmVxdWlyZSBhIHJlbGVhc2UgdmFsdWVzIGJsb2NrIgogICAgXQogIH0s" + - "CiAgewogICAgImlkIjogIlMxNC1lbmFibGUtbGxtLWZ1bmN0aW9ucyIsCiAgICAicXVlc3Rpb24i" + - "OiAiSSBuZWVkIHRvIGRlcGxveSBmdW5jdGlvblR5cGU6IExMTSBmdW5jdGlvbnMgb24gYSBzZWxm" + - "LW1hbmFnZWQsIHNpbmdsZS1ub2RlIGlzb2xhdGVkIHRlc3QgY2x1c3Rlci4gV2hhdCBIZWxtZmls" + - "ZSBjb25maWd1cmF0aW9uIGFuZCB2ZXJpZmljYXRpb24gc3RlcHMgZG8gSSBuZWVkPyIsCiAgICAi" + - "ZXhwZWN0ZWRfc2tpbGwiOiAibnZjZi1zZWxmLW1hbmFnZWQtaW5zdGFsbGF0aW9uIiwKICAgICJn" + - "cm91bmRfdHJ1dGgiOiAiVGhlIGFnZW50IGVuYWJsZWQgdGhlIExMTSBhZGRvbiB3aXRoIGFkZG9u" + - "cy5sbG0uZW5hYmxlZCwgY29uZmlndXJlZCBzaW5nbGUgcmVwbGljYXMgZm9yIHRoZSBMTE0gQVBJ" + - "IEdhdGV3YXkgYW5kIHJlcXVlc3Qgcm91dGVyLCBhbmQgZXhwbGFpbmVkIHRoYXQgdGhlIHJlcXVl" + - "c3Qgcm91dGVyIHVzZXMgcG93ZXItb2YtdHdvIHdoZW4gbm8gbG9hZC1iYWxhbmNlciBjb25maWd1" + - "cmF0aW9uIGlzIHNldC4gSXQgbGlua2VkIHRoZSBjYW5vbmljYWwgcmVxdWVzdC1yb3V0ZXIgbG9h" + - "ZC1iYWxhbmNpbmcgZ3VpZGUgZm9yIG90aGVyIHJvdXRpbmcgbWV0aG9kcy4gRm9yIHRoZSBpc29s" + - "YXRlZCBwbGFpbnRleHQgY2x1c3RlciwgaXQgaW5jbHVkZWQgYm90aCBhZGRvbnMubGxtLmdhdGV3" + - "YXkuYXV0aC5ncnBjSW5zZWN1cmUgYW5kIGFnZW50Q29uZmlnLm1lcmdlQ29uZmlnLndvcmtsb2Fk" + - "LnN0YXJnYXRlUVVJQ0luc2VjdXJlLCB3aXRoIGEgd2FybmluZyB0aGF0IHRob3NlIHNldHRpbmdz" + - "IGFyZSBub3QgZm9yIHByb2R1Y3Rpb24uIEl0IHJlZnJlc2hlZCB0aGUgY29tcHV0ZSBwbGFuZSB1" + - "c2luZyB0aGUgc2FtZSBoYW5kb2ZmIHVzZWQgZHVyaW5nIGluc3RhbGxhdGlvbiwgcmVkZXBsb3ll" + - "ZCBleGlzdGluZyBMTE0gZnVuY3Rpb25zLCBhbmQgdmVyaWZpZWQgdGhlIExMTSBkZXBsb3ltZW50" + - "cywgcm91dGUsIGFuZCBsbG0td29ya2VyIHNpZGVjYXIuIiwKICAgICJleHBlY3RlZF9iZWhhdmlv" + - "ciI6IFsKICAgICAgIlRoZSBhZ2VudCB1c2VkIGFkZG9ucy5sbG0uZW5hYmxlZCwgbm90IHRoZSBv" + - "YnNvbGV0ZSBsbG0uZW5hYmxlZCBwYXRoIiwKICAgICAgIlRoZSBhZ2VudCBzZXQgZ2F0ZXdheSBh" + - "bmQgcmVxdWVzdFJvdXRlciByZXBsaWNhQ291bnQgdG8gMSBmb3IgdGhlIHNpbmdsZS1ub2RlIHRl" + - "c3QgY2x1c3RlciIsCiAgICAgICJUaGUgYWdlbnQgc3RhdGVkIHRoYXQgdGhlIHJlcXVlc3Qgcm91" + - "dGVyIGRlZmF1bHRzIHRvIHBvd2VyLW9mLXR3byBhbmQgbGlua2VkIHRoZSBjYW5vbmljYWwgcmVx" + - "dWVzdC1yb3V0ZXIgbG9hZC1iYWxhbmNpbmcgZ3VpZGUgZm9yIG90aGVyIG1ldGhvZHMiLAogICAg" + - "ICAiVGhlIGFnZW50IGluY2x1ZGVkIGFkZG9ucy5sbG0uZ2F0ZXdheS5hdXRoLmdycGNJbnNlY3Vy" + - "ZSBhbmQgd29ya2xvYWQuc3RhcmdhdGVRVUlDSW5zZWN1cmUgZm9yIHRoZSBpc29sYXRlZCBwbGFp" + - "bnRleHQgY2x1c3RlciwgYW5kIHdhcm5lZCBhZ2FpbnN0IHVzaW5nIHRoZW0gaW4gcHJvZHVjdGlv" + - "biIsCiAgICAgICJUaGUgYWdlbnQgYXBwbGllZCB0aGUgY29udHJvbC1wbGFuZSBIZWxtZmlsZSBl" + - "bnZpcm9ubWVudCwgcmVmcmVzaGVkIHRoZSBjb21wdXRlIHBsYW5lIHdpdGggdGhlIHNhbWUgc2Vs" + - "ZWN0ZWQgaGFuZG9mZiwgYW5kIHJlY3JlYXRlZCBvciByZWRlcGxveWVkIGV4aXN0aW5nIExMTSBm" + - "dW5jdGlvbnMiLAogICAgICAiVGhlIGFnZW50IHZlcmlmaWVkIGxsbS1hcGktZ2F0ZXdheSwgbGxt" + - "LXJlcXVlc3Qtcm91dGVyLCB0aGUgTExNIEhUVFBSb3V0ZSwgYW5kIHRoZSBsbG0td29ya2VyIHNp" + - "ZGVjYXIgaW5jbHVkaW5nIC0tcXVpYy1pbnNlY3VyZSIKICAgIF0KICB9LAogIHsKICAgICJpZCI6" + - "ICJHOC1ORUctbm90LWZvci1rM2QiLAogICAgInF1ZXN0aW9uIjogIlNldCB1cCBhIGxvY2FsIE5W" + - "Q0YgZGV2IGNsdXN0ZXIgdXNpbmcgazNkIGZvciB0ZXN0aW5nIiwKICAgICJleHBlY3RlZF9za2ls" + - "bCI6IG51bGwsCiAgICAic2hvdWxkX3RyaWdnZXIiOiBmYWxzZSwKICAgICJncm91bmRfdHJ1dGgi" + - "OiAiVGhpcyBpcyBhIGxvY2FsIGszZCBkZXZlbG9wbWVudCByZXF1ZXN0IHRoYXQgYmVsb25ncyB0" + - "byB0aGUgbnZjZi1zZWxmLWhvc3RlZC1sb2NhbC1kZXYgc2tpbGwsIG5vdCBudmNmLXNlbGYtbWFu" + - "YWdlZC1pbnN0YWxsYXRpb24uIFRoZSBhZ2VudCBkaWQgbm90IHJlYWQgb3IgdXNlIHRoZSBzZWxm" + - "LW1hbmFnZWQgaW5zdGFsbGF0aW9uIHNraWxsIGFuZCBpbnN0ZWFkIHByb3ZpZGVkIGszZC1zcGVj" + - "aWZpYyBndWlkYW5jZS4iLAogICAgImV4cGVjdGVkX2JlaGF2aW9yIjogWwogICAgICAiVGhlIGFn" + - "ZW50IGRpZCBub3QgcmVhZCBudmNmLXNlbGYtbWFuYWdlZC1pbnN0YWxsYXRpb24vU0tJTEwubWQi" + - "LAogICAgICAiVGhlIGFnZW50IGRpZCBub3QgcHJvdmlkZSBoZWxtZmlsZS1iYXNlZCBwcm9kdWN0" + - "aW9uIGRlcGxveW1lbnQgaW5zdHJ1Y3Rpb25zIiwKICAgICAgIlRoZSBhZ2VudCBwcm92aWRlZCBr" + - "M2Qtc3BlY2lmaWMgbG9jYWwgZGV2ZWxvcG1lbnQgZ3VpZGFuY2Ugb3IgZGVmZXJyZWQgdG8gdGhl" + - "IGFwcHJvcHJpYXRlIGxvY2FsLWRldiBza2lsbCIKICAgIF0KICB9Cl0KUEsHCCsTuD+tVQAArVUA" + - "AFBLAwQUAAgAAAAAACEAAAAAAAAAAAAAAAAALwAJAGRhdGEvbnZjZi1zZWxmLW1hbmFnZWQtaW5z" + - "dGFsbGF0aW9uL2V4YW1wbGVzLm1kVVQFAAEAps4SIyBFeGFtcGxlcwoKV29ya2VkIGV4YW1wbGVz" + - "IGJhc2VkIG9uIHJlYWwgZGVwbG95bWVudCBzY2VuYXJpb3MuCgojIyBFeGFtcGxlIDE6IE92ZXJy" + - "aWRlIENhc3NhbmRyYSBSZXNvdXJjZXMKClRoZSBkZWZhdWx0IENhc3NhbmRyYSByZXNvdXJjZSBs" + - "aW1pdHMgY2F1c2UgT09NIG9uIGxhcmdlIGluc3RhbmNlIHR5cGVzIChlLmcuLCBgcDUuNDh4bGFy" + - "Z2VgKS4KClByb2JsZW06IENhc3NhbmRyYSBwb2RzIHJlc3RhcnQgd2l0aCBgT09NS2lsbGVkYC4K" + - "ClNvbHV0aW9uOiBPdmVycmlkZSByZXNvdXJjZXMgdmlhIGhlbG1maWxlIHJlbGVhc2UgdmFsdWVz" + - "IGJsb2NrLgoKIyMjIFN0ZXAgMTogQ2FwdHVyZSBiYXNlbGluZQoKYGBgYmFzaApIRUxNRklMRV9F" + - "TlY9PGVudj4gaGVsbWZpbGUgLS1zZWxlY3RvciBuYW1lPWNhc3NhbmRyYSB0ZW1wbGF0ZSA+IC90" + - "bXAvY2Fzcy1iZWZvcmUueWFtbApncmVwIC1BOCAncmVzb3VyY2VzOicgL3RtcC9jYXNzLWJlZm9y" + - "ZS55YW1sIHwgaGVhZCAtMTAKYGBgCgojIyMgU3RlcCAyOiBBZGQgb3ZlcnJpZGUgdG8gaGVsbWZp" + - "bGUuZC8wMS1kZXBlbmRlbmNpZXMueWFtbC5nb3RtcGwKCkluIHRoZSBleGFtcGxlcyBiZWxvdywg" + - "YDxwcml2YXRlLXZhbHVlcz5gIHJlZmVycyB0byB0aGUgYHNlY3JldHMvYCBkaXJlY3RvcnkgYXQg" + - "dGhlIGhlbG1maWxlIHN0YWNrIHJvb3QuCgpgYGB5YW1sCi0gbmFtZTogY2Fzc2FuZHJhCiAgdmVy" + - "c2lvbjogMC44LjAKICBjb25kaXRpb246IGNhc3NhbmRyYS5lbmFibGVkCiAgbmFtZXNwYWNlOiBj" + - "YXNzYW5kcmEtc3lzdGVtCiAgPDw6ICpkZXBlbmRlbmN5CiAgdmFsdWVzOgogICAgLSAuLi9nbG9i" + - "YWwueWFtbC5nb3RtcGwKICAgIC0gLi4vPHByaXZhdGUtdmFsdWVzPi97eyByZXF1aXJlZEVudiAi" + - "SEVMTUZJTEVfRU5WIiB9fS1zZWNyZXRzLnlhbWwKICAgIC0gY2Fzc2FuZHJhOgogICAgICAgIHJl" + - "c291cmNlczoKICAgICAgICAgIGxpbWl0czoKICAgICAgICAgICAgY3B1OiAiOCIKICAgICAgICAg" + - "ICAgbWVtb3J5OiA4MTkyTWkKICAgICAgICAgIHJlcXVlc3RzOgogICAgICAgICAgICBjcHU6ICIy" + - "IgogICAgICAgICAgICBtZW1vcnk6IDQwOTZNaQpgYGAKCiMjIyBTdGVwIDM6IFZlcmlmeSBhbmQg" + - "YXBwbHkKCmBgYGJhc2gKSEVMTUZJTEVfRU5WPTxlbnY+IGhlbG1maWxlIC0tc2VsZWN0b3IgbmFt" + - "ZT1jYXNzYW5kcmEgdGVtcGxhdGUgPiAvdG1wL2Nhc3MtYWZ0ZXIueWFtbApkaWZmIC90bXAvY2Fz" + - "cy1iZWZvcmUueWFtbCAvdG1wL2Nhc3MtYWZ0ZXIueWFtbCAgIyBDb25maXJtIHJlc291cmNlcyBj" + - "aGFuZ2VkCkhFTE1GSUxFX0VOVj08ZW52PiBoZWxtZmlsZSAtLXNlbGVjdG9yIG5hbWU9Y2Fzc2Fu" + - "ZHJhIHN5bmMKYGBgCgpOb3RlOiBgcmVzb3VyY2VQcmVzZXRgIChhIEJpdG5hbWkgZmVhdHVyZSkg" + - "aXMgbm90IGF2YWlsYWJsZSBpbiB0aGUgTlZDRiBjYXNzYW5kcmEgd3JhcHBlciBjaGFydC4gVXNl" + - "IGV4cGxpY2l0IGByZXNvdXJjZXNgIGluc3RlYWQuCgotLS0KCiMjIEV4YW1wbGUgMjogRGVwbG95" + - "IGZyb20gTkdDIFByaXZhdGUgUmVnaXN0cnkgd2l0aCBQdWxsIFNlY3JldHMKCkRlcGxveSB0aGUg" + - "TlZDRiBzdGFjayBwdWxsaW5nIGltYWdlcyBkaXJlY3RseSBmcm9tIE5HQyAoYG52Y3IuaW9gKSBp" + - "bnN0ZWFkIG9mIGEgbWlycm9yZWQgcmVnaXN0cnksIHVzaW5nIGltYWdlIHB1bGwgc2VjcmV0cy4K" + - "CiMjIyBTdGVwIDE6IENvbmZpZ3VyZSBlbnZpcm9ubWVudCBmb3IgTkdDCgpgYGB5YW1sCiMgZW52" + - "aXJvbm1lbnRzLzxlbnY+LnlhbWwKZ2xvYmFsOgogIGhlbG06CiAgICBzb3VyY2VzOgogICAgICBy" + - "ZWdpc3RyeTogbnZjci5pbwogICAgICByZXBvc2l0b3J5OiBudmlkaWEvbnZjZgogIGltYWdlOgog" + - "ICAgcmVnaXN0cnk6IG52Y3IuaW8KICAgIHJlcG9zaXRvcnk6IG52aWRpYS9udmNmCmBgYAoKIyMj" + - "IFN0ZXAgMjogQXV0aGVudGljYXRlIGxvY2FsbHkgKGZvciBoZWxtZmlsZSBjaGFydCBwdWxscykK" + - "CmBgYGJhc2gKZG9ja2VyIGxvZ2luIG52Y3IuaW8gLXUgJyRvYXV0aHRva2VuJyAtcCAiJE5HQ19B" + - "UElfS0VZIgpoZWxtIHJlZ2lzdHJ5IGxvZ2luIG52Y3IuaW8gLXUgJyRvYXV0aHRva2VuJyAtcCAi" + - "JE5HQ19BUElfS0VZIgpgYGAKCiMjIyBTdGVwIDM6IENyZWF0ZSBuYW1lc3BhY2VzIGFuZCBwdWxs" + - "IHNlY3JldHMKCmBgYGJhc2gKZXhwb3J0IE5HQ19BUElfS0VZPSI8eW91ci1uZ2MtYXBpLWtleT4i" + - "Cgpmb3IgbnMgaW4gY2Fzc2FuZHJhLXN5c3RlbSBuYXRzLXN5c3RlbSBudmNmIGFwaS1rZXlzIGVz" + - "cyBzaXMgdmF1bHQtc3lzdGVtIGNlcnQtbWFuYWdlcjsgZG8KICBrdWJlY3RsIC0tY29udGV4dCA8" + - "Y29udHJvbC1wbGFuZS1jb250ZXh0PiBjcmVhdGUgbmFtZXNwYWNlICIkbnMiIFwKICAgIC0tZHJ5" + - "LXJ1bj1jbGllbnQgLW8geWFtbCB8IGt1YmVjdGwgLS1jb250ZXh0IDxjb250cm9sLXBsYW5lLWNv" + - "bnRleHQ+IGFwcGx5IC1mIC0KZG9uZQoKZm9yIG5zIGluIGNhc3NhbmRyYS1zeXN0ZW0gbmF0cy1z" + - "eXN0ZW0gbnZjZiBhcGkta2V5cyBlc3Mgc2lzIHZhdWx0LXN5c3RlbSBjZXJ0LW1hbmFnZXI7IGRv" + - "CiAga3ViZWN0bCAtLWNvbnRleHQgPGNvbnRyb2wtcGxhbmUtY29udGV4dD4gY3JlYXRlIHNlY3Jl" + - "dCBkb2NrZXItcmVnaXN0cnkgbnZjci1jcmVkcyBcCiAgICAtLWRvY2tlci1zZXJ2ZXI9bnZjci5p" + - "byBcCiAgICAtLWRvY2tlci11c2VybmFtZT0nJG9hdXRodG9rZW4nIFwKICAgIC0tZG9ja2VyLXBh" + - "c3N3b3JkPSIkTkdDX0FQSV9LRVkiIFwKICAgIC0tbmFtZXNwYWNlPSIkbnMiIFwKICAgIC0tZHJ5" + - "LXJ1bj1jbGllbnQgLW8geWFtbCB8IGt1YmVjdGwgLS1jb250ZXh0IDxjb250cm9sLXBsYW5lLWNv" + - "bnRleHQ+IGFwcGx5IC1mIC0KZG9uZQpgYGAKCiMjIyBTdGVwIDQ6IEFkZCBpbWFnZVB1bGxTZWNy" + - "ZXRzIHRvIGhlbG1maWxlIHJlbGVhc2VzCgpBZGQgdGhlIGNoYXJ0LXNwZWNpZmljIGBpbWFnZVB1" + - "bGxTZWNyZXRzYCBrZXkgdG8gZWFjaCByZWxlYXNlLiBFeGFtcGxlIGZvciBjYXNzYW5kcmEgaW4g" + - "YGhlbG1maWxlLmQvMDEtZGVwZW5kZW5jaWVzLnlhbWwuZ290bXBsYDoKCmBgYHlhbWwKLSBuYW1l" + + "aW9uIiwKICAgICAgIlRoZSBhZ2VudCBleHBsYWluZWQgdGhlIHZhbHVlcyBwcmVjZWRlbmNlIGNo" + + "YWluOiBiYXNlLnlhbWwgLT4gZW52IFlBTUwgLT4gZ2xvYmFsLnlhbWwuZ290bXBsIC0+IHNlY3Jl" + + "dHMgLT4gaW5saW5lIHZhbHVlcyIsCiAgICAgICJUaGUgYWdlbnQgaWRlbnRpZmllZCB0aGF0IGds" + + "b2JhbC55YW1sLmdvdG1wbCBvbmx5IHBhc3NlcyB0aHJvdWdoIHNwZWNpZmljIGtleXMgKGNhc3Nh" + + "bmRyYS5yZXBsaWNhQ291bnQsIGdsb2JhbC5zdG9yYWdlQ2xhc3MsIGdsb2JhbC5pbWFnZSwgZXRj" + + "LikiLAogICAgICAiVGhlIGFnZW50IGV4cGxhaW5lZCB0aGF0IGFyYml0cmFyeSBjaGFydCB2YWx1" + + "ZXMgbXVzdCBiZSBzZXQgdmlhIHJlbGVhc2UgaW5saW5lIHZhbHVlczogYmxvY2tzIiwKICAgICAg" + + "IlRoZSBhZ2VudCBsaXN0ZWQgZXhhbXBsZXMgb2YgdmFsdWVzIHRoYXQgYXJlIHByb3BhZ2F0ZWQg" + + "YW5kIGFyYml0cmFyeSBjaGFydCB2YWx1ZXMgdGhhdCByZXF1aXJlIGEgcmVsZWFzZSB2YWx1ZXMg" + + "YmxvY2siCiAgICBdCiAgfSwKICB7CiAgICAiaWQiOiAiUzE0LWVuYWJsZS1sbG0tZnVuY3Rpb25z" + + "IiwKICAgICJxdWVzdGlvbiI6ICJJIG5lZWQgdG8gZGVwbG95IGZ1bmN0aW9uVHlwZTogTExNIGZ1" + + "bmN0aW9ucyBvbiBhIHNlbGYtbWFuYWdlZCwgc2luZ2xlLW5vZGUgaXNvbGF0ZWQgdGVzdCBjbHVz" + + "dGVyLiBXaGF0IEhlbG1maWxlIGNvbmZpZ3VyYXRpb24gYW5kIHZlcmlmaWNhdGlvbiBzdGVwcyBk" + + "byBJIG5lZWQ/IiwKICAgICJleHBlY3RlZF9za2lsbCI6ICJudmNmLXNlbGYtbWFuYWdlZC1pbnN0" + + "YWxsYXRpb24iLAogICAgImdyb3VuZF90cnV0aCI6ICJUaGUgYWdlbnQgZW5hYmxlZCB0aGUgTExN" + + "IGFkZG9uIHdpdGggYWRkb25zLmxsbS5lbmFibGVkLCBjb25maWd1cmVkIHNpbmdsZSByZXBsaWNh" + + "cyBmb3IgdGhlIExMTSBBUEkgR2F0ZXdheSBhbmQgcmVxdWVzdCByb3V0ZXIsIGFuZCBleHBsYWlu" + + "ZWQgdGhhdCB0aGUgcmVxdWVzdCByb3V0ZXIgdXNlcyBwb3dlci1vZi10d28gd2hlbiBubyBsb2Fk" + + "LWJhbGFuY2VyIGNvbmZpZ3VyYXRpb24gaXMgc2V0LiBJdCBsaW5rZWQgdGhlIGNhbm9uaWNhbCBy" + + "ZXF1ZXN0LXJvdXRlciBsb2FkLWJhbGFuY2luZyBndWlkZSBmb3Igb3RoZXIgcm91dGluZyBtZXRo" + + "b2RzLiBGb3IgdGhlIGlzb2xhdGVkIHBsYWludGV4dCBjbHVzdGVyLCBpdCBpbmNsdWRlZCBib3Ro" + + "IGFkZG9ucy5sbG0uZ2F0ZXdheS5hdXRoLmdycGNJbnNlY3VyZSBhbmQgYWdlbnRDb25maWcubWVy" + + "Z2VDb25maWcud29ya2xvYWQuc3RhcmdhdGVRVUlDSW5zZWN1cmUsIHdpdGggYSB3YXJuaW5nIHRo" + + "YXQgdGhvc2Ugc2V0dGluZ3MgYXJlIG5vdCBmb3IgcHJvZHVjdGlvbi4gSXQgcmVmcmVzaGVkIHRo" + + "ZSBjb21wdXRlIHBsYW5lIHVzaW5nIHRoZSBzYW1lIGhhbmRvZmYgdXNlZCBkdXJpbmcgaW5zdGFs" + + "bGF0aW9uLCByZWRlcGxveWVkIGV4aXN0aW5nIExMTSBmdW5jdGlvbnMsIGFuZCB2ZXJpZmllZCB0" + + "aGUgTExNIGRlcGxveW1lbnRzLCByb3V0ZSwgYW5kIGxsbS13b3JrZXIgc2lkZWNhci4iLAogICAg" + + "ImV4cGVjdGVkX2JlaGF2aW9yIjogWwogICAgICAiVGhlIGFnZW50IHVzZWQgYWRkb25zLmxsbS5l" + + "bmFibGVkLCBub3QgdGhlIG9ic29sZXRlIGxsbS5lbmFibGVkIHBhdGgiLAogICAgICAiVGhlIGFn" + + "ZW50IHNldCBnYXRld2F5IGFuZCByZXF1ZXN0Um91dGVyIHJlcGxpY2FDb3VudCB0byAxIGZvciB0" + + "aGUgc2luZ2xlLW5vZGUgdGVzdCBjbHVzdGVyIiwKICAgICAgIlRoZSBhZ2VudCBzdGF0ZWQgdGhh" + + "dCB0aGUgcmVxdWVzdCByb3V0ZXIgZGVmYXVsdHMgdG8gcG93ZXItb2YtdHdvIGFuZCBsaW5rZWQg" + + "dGhlIGNhbm9uaWNhbCByZXF1ZXN0LXJvdXRlciBsb2FkLWJhbGFuY2luZyBndWlkZSBmb3Igb3Ro" + + "ZXIgbWV0aG9kcyIsCiAgICAgICJUaGUgYWdlbnQgaW5jbHVkZWQgYWRkb25zLmxsbS5nYXRld2F5" + + "LmF1dGguZ3JwY0luc2VjdXJlIGFuZCB3b3JrbG9hZC5zdGFyZ2F0ZVFVSUNJbnNlY3VyZSBmb3Ig" + + "dGhlIGlzb2xhdGVkIHBsYWludGV4dCBjbHVzdGVyLCBhbmQgd2FybmVkIGFnYWluc3QgdXNpbmcg" + + "dGhlbSBpbiBwcm9kdWN0aW9uIiwKICAgICAgIlRoZSBhZ2VudCBhcHBsaWVkIHRoZSBjb250cm9s" + + "LXBsYW5lIEhlbG1maWxlIGVudmlyb25tZW50LCByZWZyZXNoZWQgdGhlIGNvbXB1dGUgcGxhbmUg" + + "d2l0aCB0aGUgc2FtZSBzZWxlY3RlZCBoYW5kb2ZmLCBhbmQgcmVjcmVhdGVkIG9yIHJlZGVwbG95" + + "ZWQgZXhpc3RpbmcgTExNIGZ1bmN0aW9ucyIsCiAgICAgICJUaGUgYWdlbnQgdmVyaWZpZWQgbGxt" + + "LWFwaS1nYXRld2F5LCBsbG0tcmVxdWVzdC1yb3V0ZXIsIHRoZSBMTE0gSFRUUFJvdXRlLCBhbmQg" + + "dGhlIGxsbS13b3JrZXIgc2lkZWNhciBpbmNsdWRpbmcgLS1xdWljLWluc2VjdXJlIgogICAgXQog" + + "IH0sCiAgewogICAgImlkIjogIkc4LU5FRy1ub3QtZm9yLWszZCIsCiAgICAicXVlc3Rpb24iOiAi" + + "U2V0IHVwIGEgbG9jYWwgTlZDRiBkZXYgY2x1c3RlciB1c2luZyBrM2QgZm9yIHRlc3RpbmciLAog" + + "ICAgImV4cGVjdGVkX3NraWxsIjogbnVsbCwKICAgICJzaG91bGRfdHJpZ2dlciI6IGZhbHNlLAog" + + "ICAgImdyb3VuZF90cnV0aCI6ICJUaGlzIGlzIGEgbG9jYWwgazNkIGRldmVsb3BtZW50IHJlcXVl" + + "c3QgdGhhdCBiZWxvbmdzIHRvIHRoZSBudmNmLXNlbGYtaG9zdGVkLWxvY2FsLWRldiBza2lsbCwg" + + "bm90IG52Y2Ytc2VsZi1tYW5hZ2VkLWluc3RhbGxhdGlvbi4gVGhlIGFnZW50IGRpZCBub3QgcmVh" + + "ZCBvciB1c2UgdGhlIHNlbGYtbWFuYWdlZCBpbnN0YWxsYXRpb24gc2tpbGwgYW5kIGluc3RlYWQg" + + "cHJvdmlkZWQgazNkLXNwZWNpZmljIGd1aWRhbmNlLiIsCiAgICAiZXhwZWN0ZWRfYmVoYXZpb3Ii" + + "OiBbCiAgICAgICJUaGUgYWdlbnQgZGlkIG5vdCByZWFkIG52Y2Ytc2VsZi1tYW5hZ2VkLWluc3Rh" + + "bGxhdGlvbi9TS0lMTC5tZCIsCiAgICAgICJUaGUgYWdlbnQgZGlkIG5vdCBwcm92aWRlIGhlbG1m" + + "aWxlLWJhc2VkIHByb2R1Y3Rpb24gZGVwbG95bWVudCBpbnN0cnVjdGlvbnMiLAogICAgICAiVGhl" + + "IGFnZW50IHByb3ZpZGVkIGszZC1zcGVjaWZpYyBsb2NhbCBkZXZlbG9wbWVudCBndWlkYW5jZSBv" + + "ciBkZWZlcnJlZCB0byB0aGUgYXBwcm9wcmlhdGUgbG9jYWwtZGV2IHNraWxsIgogICAgXQogIH0K" + + "XQpQSwcIKxO4P61VAACtVQAAUEsDBBQACAAAAAAAIQAAAAAAAAAAAAAAAAAvAAkAZGF0YS9udmNm" + + "LXNlbGYtbWFuYWdlZC1pbnN0YWxsYXRpb24vZXhhbXBsZXMubWRVVAUAAQCmzhIjIEV4YW1wbGVz" + + "CgpXb3JrZWQgZXhhbXBsZXMgYmFzZWQgb24gcmVhbCBkZXBsb3ltZW50IHNjZW5hcmlvcy4KCiMj" + + "IEV4YW1wbGUgMTogT3ZlcnJpZGUgQ2Fzc2FuZHJhIFJlc291cmNlcwoKVGhlIGRlZmF1bHQgQ2Fz" + + "c2FuZHJhIHJlc291cmNlIGxpbWl0cyBjYXVzZSBPT00gb24gbGFyZ2UgaW5zdGFuY2UgdHlwZXMg" + + "KGUuZy4sIGBwNS40OHhsYXJnZWApLgoKUHJvYmxlbTogQ2Fzc2FuZHJhIHBvZHMgcmVzdGFydCB3" + + "aXRoIGBPT01LaWxsZWRgLgoKU29sdXRpb246IE92ZXJyaWRlIHJlc291cmNlcyB2aWEgaGVsbWZp" + + "bGUgcmVsZWFzZSB2YWx1ZXMgYmxvY2suCgojIyMgU3RlcCAxOiBDYXB0dXJlIGJhc2VsaW5lCgpg" + + "YGBiYXNoCkhFTE1GSUxFX0VOVj08ZW52PiBoZWxtZmlsZSAtLXNlbGVjdG9yIG5hbWU9Y2Fzc2Fu" + + "ZHJhIHRlbXBsYXRlID4gL3RtcC9jYXNzLWJlZm9yZS55YW1sCmdyZXAgLUE4ICdyZXNvdXJjZXM6" + + "JyAvdG1wL2Nhc3MtYmVmb3JlLnlhbWwgfCBoZWFkIC0xMApgYGAKCiMjIyBTdGVwIDI6IEFkZCBv" + + "dmVycmlkZSB0byBoZWxtZmlsZS5kLzAxLWRlcGVuZGVuY2llcy55YW1sLmdvdG1wbAoKSW4gdGhl" + + "IGV4YW1wbGVzIGJlbG93LCBgPHByaXZhdGUtdmFsdWVzPmAgcmVmZXJzIHRvIHRoZSBgc2VjcmV0" + + "cy9gIGRpcmVjdG9yeSBhdCB0aGUgaGVsbWZpbGUgc3RhY2sgcm9vdC4KCmBgYHlhbWwKLSBuYW1l" + "OiBjYXNzYW5kcmEKICB2ZXJzaW9uOiAwLjguMAogIGNvbmRpdGlvbjogY2Fzc2FuZHJhLmVuYWJs" + "ZWQKICBuYW1lc3BhY2U6IGNhc3NhbmRyYS1zeXN0ZW0KICA8PDogKmRlcGVuZGVuY3kKICB2YWx1" + "ZXM6CiAgICAtIC4uL2dsb2JhbC55YW1sLmdvdG1wbAogICAgLSAuLi88cHJpdmF0ZS12YWx1ZXM+" + "L3t7IHJlcXVpcmVkRW52ICJIRUxNRklMRV9FTlYiIH19LXNlY3JldHMueWFtbAogICAgLSBjYXNz" + - "YW5kcmE6CiAgICAgICAgZ2xvYmFsOgogICAgICAgICAgaW1hZ2VQdWxsU2VjcmV0czoKICAgICAg" + - "ICAgICAgLSBudmNyLWNyZWRzCmBgYAoKU2VlIFtyZWZlcmVuY2VzL3B1bGwtc2VjcmV0cy5tZF0o" + - "cmVmZXJlbmNlcy9wdWxsLXNlY3JldHMubWQpIGZvciB0aGUga2V5IGZvciBldmVyeSBjaGFydC4K" + - "ClRoZXNlIGFyZSBjb250cm9sLXBsYW5lIG5hbWVzcGFjZXMuIEZvciBhIHNlcGFyYXRlIGNvbXB1" + - "dGUgY2x1c3RlciwgY3JlYXRlIHRoZQpzZWNyZXQgb25seSBpbiBgbnZjYS1vcGVyYXRvcmA7IHRo" + - "ZSBjaGFydCBhbmQgb3BlcmF0b3IgbWlycm9yIGl0IHRvCmBudmNhLXN5c3RlbWAuIFNlZSBbU3Bs" + - "aXQgQ29tcHV0ZS1QbGFuZSBJbnN0YWxsYXRpb25dKHJlZmVyZW5jZXMvY29tcHV0ZS1wbGFuZS1p" + - "bnN0YWxsYXRpb24ubWQjcHVsbC1zZWNyZXRzKS4KCiMjIyBTdGVwIDU6IERlcGxveQoKYGBgYmFz" + - "aApIRUxNRklMRV9FTlY9PGVudj4gaGVsbWZpbGUgLS1rdWJlLWNvbnRleHQgPGNvbnRyb2wtcGxh" + - "bmUtY29udGV4dD4gc3luYwpgYGAKCiMjIyBTdGVwIDY6IFBhdGNoIFNlcnZpY2VBY2NvdW50cyBm" + - "b3IgY2hhcnRzIHdpdGhvdXQgbmF0aXZlIHN1cHBvcnQKCkFmdGVyIFBoYXNlIDEgKGRlcGVuZGVu" + - "Y2llcykgY29tcGxldGVzLCBPcGVuQmFvIHBvZHMgd2lsbCBiZSBpbiBgSW1hZ2VQdWxsQmFja09m" + - "ZmAuIFBhdGNoIGFuZCByZXN0YXJ0OgoKYGBgYmFzaApmb3IgbnMgaW4gdmF1bHQtc3lzdGVtIG52" + - "Y2YgZXNzOyBkbwogIGZvciBzYSBpbiAkKGt1YmVjdGwgLS1jb250ZXh0IDxjb250cm9sLXBsYW5l" + - "LWNvbnRleHQ+IGdldCBzYSAtbiAiJG5zIiBcCiAgICAtLW5vLWhlYWRlcnMgLW8gY3VzdG9tLWNv" + - "bHVtbnM9IjptZXRhZGF0YS5uYW1lIik7IGRvCiAgICBrdWJlY3RsIC0tY29udGV4dCA8Y29udHJv" + - "bC1wbGFuZS1jb250ZXh0PiBwYXRjaCBzZXJ2aWNlYWNjb3VudCAtbiAiJG5zIiAiJHNhIiBcCiAg" + - "ICAgIC1wICd7ImltYWdlUHVsbFNlY3JldHMiOiBbeyJuYW1lIjogIm52Y3ItY3JlZHMifV19Jwog" + - "IGRvbmUKZG9uZQprdWJlY3RsIC0tY29udGV4dCA8Y29udHJvbC1wbGFuZS1jb250ZXh0PiBkZWxl" + - "dGUgcG9kcyAtbiB2YXVsdC1zeXN0ZW0gLS1hbGwKYGBgCgpWZXJpZnk6CgpgYGBiYXNoCmt1YmVj" + - "dGwgLS1jb250ZXh0IDxjb250cm9sLXBsYW5lLWNvbnRleHQ+IGdldCBldmVudHMgLW4gdmF1bHQt" + - "c3lzdGVtIFwKICAtLXNvcnQtYnk9Jy5sYXN0VGltZXN0YW1wJyB8IGdyZXAgLWkgcHVsbAojIFNo" + - "b3VsZCBzaG93ICJTdWNjZXNzZnVsbHkgcHVsbGVkIGltYWdlIiBmcm9tIG52Y3IuaW8KYGBgCgot" + - "LS0KCiMjIEV4YW1wbGUgMzogRnVsbCBUZWFyZG93biBhbmQgUmVpbnN0YWxsCgpXaGVuIGEgZGVw" + - "bG95bWVudCBpcyBicm9rZW4gYW5kIHlvdSBuZWVkIGEgY2xlYW4gc2xhdGUuCgojIyMgU3RlcCAx" + - "OiBEZXN0cm95IHRoZSBjb21wdXRlLXBsYW5lIHN0YWNrCgpgYGBiYXNoCm1ha2UgLUMgZGVwbG95" + - "L3N0YWNrcy9udmNmLWNvbXB1dGUtcGxhbmUgZGVzdHJveSBcCiAgQ0xVU1RFUl9OQU1FPTxjbHVz" + - "dGVyLW5hbWU+IFwKICBIRUxNRklMRV9FTlY9PGVudj4gXAogIEtVQkVDT05GSUdfRklMRT08Y29t" + - "cHV0ZS1wbGFuZS1rdWJlY29uZmlnPgpgYGAKCklmIGNvbXB1dGUgY2xlYW51cCBpcyBzdHVjayBv" + - "biBmaW5hbGl6ZXJzLCB1c2UgdGhlIGNvbXB1dGUtY29udGV4dCBwcm9jZWR1cmUgaW4KW2RlYnVn" + - "Z2luZy5tZF0ocmVmZXJlbmNlcy9kZWJ1Z2dpbmcubWQjZmFpbHVyZS1udmNhLWNsZWFudXAtc3R1" + - "Y2stZmluYWxpemVycykuCgojIyMgU3RlcCAyOiBEZXJlZ2lzdGVyIHRoZSBjb21wdXRlIGNsdXN0" + - "ZXIKClJlYWQgYGNsdXN0ZXJJRGAgYW5kIGBuY2FJRGAgZnJvbQpgZGVwbG95L3N0YWNrcy9udmNm" + - "LWNvbXB1dGUtcGxhbmUvcmVnaXN0cmF0aW9uLzxjbHVzdGVyLW5hbWU+LXJlZ2lzdGVyLXZhbHVl" + - "cy55YW1sYC4KU2hvdyB0aGUgSUQgYW5kIGdldCBjb25maXJtYXRpb24gYmVmb3JlIGRlbGV0aW5n" + - "IHRoZSBJQ01TIHJvdzoKCmBgYGJhc2gKPG52Y2YtY2xpPiAtLWNvbmZpZyA8Y29uZmlnPiBjbHVz" + - "dGVyIGRlbGV0ZSBcCiAgLS1jbHVzdGVyLWlkIDxjbHVzdGVyLWlkLWZyb20tcmVnaXN0cmF0aW9u" + - "LXZhbHVlcz4gXAogIC0tbmNhLWlkIDxuY2EtaWQ+IFwKICAtLWlnbm9yZS1taXNzaW5nCmBgYAoK" + - "UmVwZWF0IHN0ZXBzIDEgYW5kIDIgZm9yIGV2ZXJ5IGNvbXB1dGUgY2x1c3Rlci4KCiMjIyBTdGVw" + - "IDM6IERlc3Ryb3kgdGhlIGNvbnRyb2wtcGxhbmUgc3RhY2sKClByZXNlcnZlIHRoZSBgY2VydC1t" + - "YW5hZ2VyYCBuYW1lc3BhY2UgYnkgZGVmYXVsdC4gTmFtZXNwYWNlIHByZXNlcnZhdGlvbiBkb2Vz" + - "Cm5vdCBwcmVzZXJ2ZSB0aGUgSGVsbSByZWxlYXNlLiBCZWZvcmUgcnVubmluZyBkZXN0cm95LCBp" + - "ZGVudGlmeSB3aGV0aGVyCmNlcnQtbWFuYWdlciBpcyBleHRlcm5hbC4gRm9yIGFuIGV4dGVybmFs" + - "IGluc3RhbGxhdGlvbiwgcmVxdWlyZSBlZmZlY3RpdmUKYGNlcnRNYW5hZ2VyLmVuYWJsZWQ6IGZh" + - "bHNlYCBhbmQgYWJvcnQgaWYgaXQgaXMgdHJ1ZS4gRm9yIGFuIGludGVuZGVkCnN0YWNrLW1hbmFn" + - "ZWQgcmVsZWFzZSB3aXRoIGVmZmVjdGl2ZSBgY2VydE1hbmFnZXIuZW5hYmxlZDogdHJ1ZWAsIHZl" + - "cmlmeQptYXRjaGluZyBzdGFjayBIZWxtIHJlbGVhc2UgbWV0YWRhdGEgYW5kIGFib3J0IG9uIG1p" + - "c3Npbmcgb3IgbWlzbWF0Y2hlZApldmlkZW5jZS4gT25seSBwbGFuIG5hbWVzcGFjZSByZW1vdmFs" + - "IGFmdGVyIHZlcmlmeWluZyBuYW1lc3BhY2UgcHJvdmVuYW5jZSBhbmQKZ2V0dGluZyBleHBsaWNp" + - "dCBjb25maXJtYXRpb247IG90aGVyd2lzZSBkbyBub3QgZGVsZXRlIGl0LgoKYGBgYmFzaApLVUJF" + - "Q09ORklHPTxjb250cm9sLXBsYW5lLWt1YmVjb25maWc+IFwKbWFrZSAtQyBkZXBsb3kvc3RhY2tz" + - "L3NlbGYtbWFuYWdlZCBkZXN0cm95IFwKICBIRUxNRklMRV9FTlY9PGVudj4gXAogIEtVQkVDT05G" + - "SUdfRklMRT08Y29udHJvbC1wbGFuZS1rdWJlY29uZmlnPgpgYGAKClBhc3MgYm90aCBrdWJlY29u" + - "ZmlnIGZvcm1zIGJlY2F1c2UgY29udHJvbC1wbGFuZSBuYW1lc3BhY2UgY2xlYW51cCB1c2VzCmFt" + - "YmllbnQgYGt1YmVjdGxgLgoKIyMjIFN0ZXAgNDogVmVyaWZ5IGNsZWFuCgpgYGBiYXNoCmt1YmVj" + - "dGwgLS1jb250ZXh0IDxjb21wdXRlLXBsYW5lLWNvbnRleHQ+IGdldCBucyB8IFwKICBncmVwIC1F" + - "ICcobnZjYXxudmNmLWJhY2tlbmR8Z3JvdmV8ZHluYW1vKScKa3ViZWN0bCAtLWNvbnRleHQgPGNv" + - "bnRyb2wtcGxhbmUtY29udGV4dD4gZ2V0IG5zIHwgXAogIGdyZXAgLUUgJyhjYXNzYW5kcmF8bmF0" + - "c3x2YXVsdHxudmNmfGFwaS1rZXlzfGVzc3xzaXMpJwojIEJvdGggY29tbWFuZHMgc2hvdWxkIHJl" + - "dHVybiBlbXB0eS4KYGBgCgojIyMgU3RlcCA1OiBSZWluc3RhbGwgaW4gc3BsaXQgb3JkZXIKCkZv" + - "bGxvdyBbQ2xlYW4gSW5zdGFsbGF0aW9uXShTS0lMTC5tZCNjbGVhbi1pbnN0YWxsYXRpb24pLCB0" + - "aGVuIHJldHVybiB0byB0aGUKc2FtZSBoYW5kb2ZmIGluIFtTcGxpdCBDb21wdXRlLVBsYW5lIElu" + - "c3RhbGxhdGlvbl0ocmVmZXJlbmNlcy9jb21wdXRlLXBsYW5lLWluc3RhbGxhdGlvbi5tZCkuCgot" + - "LS0KCiMjIEV4YW1wbGUgNDogUmVjb3ZlciBmcm9tIGEgR2F0ZXdheSBFbmRwb2ludCBDaGFuZ2UK" + - "ClRoZSBzZXBhcmF0ZWx5IHByb3Zpc2lvbmVkIEdhdGV3YXkgb3IgaXRzIGxvYWQgYmFsYW5jZXIg" + - "d2FzIHJlY3JlYXRlZCBhbmQgZ290IGEgbmV3IGVuZHBvaW50LgoKIyMjIFN0ZXAgMTogR2V0IHRo" + - "ZSBuZXcgZW5kcG9pbnQKCmBgYGJhc2gKR0FURVdBWV9BRERSPSQoa3ViZWN0bCAtLWNvbnRleHQg" + - "PGNvbnRyb2wtcGxhbmUtY29udGV4dD4gZ2V0IGdhdGV3YXkgXAogIG52Y2YtZ2F0ZXdheSAtbiBl" + - "bnZveS1nYXRld2F5IFwKICAtbyBqc29ucGF0aD0ney5zdGF0dXMuYWRkcmVzc2VzWzBdLnZhbHVl" + - "fScpCnRlc3QgLW4gIiRHQVRFV0FZX0FERFIiCmBgYAoKIyMjIFN0ZXAgMjogVXBkYXRlIEROUyBh" + - "bmQgZGlyZWN0IGFkZHJlc3MgZmllbGRzCgpLZWVwIGBnbG9iYWwuZG9tYWluYCwgcm91dGUgaG9z" + - "dG5hbWVzLCBhbmQgQ0xJIEhvc3QgZmllbGRzIHVuY2hhbmdlZC4gUG9pbnQgdGhlCkROUyByZWNv" + - "cmRzIGZvciByZW5kZXJlZCByb3V0ZSBob3N0bmFtZXMsIHN1Y2ggYXMgYGFwaS48ZG9tYWluPmAg" + - "YW5kCmAqLmludm9jYXRpb24uPGRvbWFpbj5gLCB0byBgR0FURVdBWV9BRERSYC4gRm9yIGEgdGVt" + - "cG9yYXJ5IGVudmlyb25tZW50IHdpdGhvdXQKRE5TLCBrZWVwIGl0cyByZXNlcnZlZCByb3V0ZSBz" + - "dWZmaXggYW5kIGNvbm5lY3QgdG8gYEdBVEVXQVlfQUREUmAgd2l0aCB0aGUKbWF0Y2hpbmcgYEhv" + - "c3RgIGhlYWRlci4KCkZvciBhIHNwbGl0IGRlcGxveW1lbnQgY29uZmlndXJlZCB3aXRoIGRpcmVj" + - "dCBHYXRld2F5IGFkZHJlc3NlcywgcmVwbGFjZSBvbmx5CnRoZSBhZGRyZXNzLWJlYXJpbmcgdmFs" + - "dWVzOiBjb250cm9sLXBsYW5lIGBudmNmTmF0c1NlcnZpY2VVUkxgLCBjb21wdXRlLXBsYW5lCklD" + - "TVMsIFJlVmFsLCBhbmQgTkFUUyBVUkxzLCBhbmQgQ0xJIFVSTCBmaWVsZHMuIEtlZXAgdGhlaXIg" + - "ZG9tYWluIGFuZCBIb3N0Cm92ZXJyaWRlcyB1bmNoYW5nZWQuIFJlZnJlc2ggcmVnaXN0cmF0aW9u" + - "IGFuZCBpbnN0YWxsYXRpb24gdGhyb3VnaCB0aGUgc2FtZQpoYW5kb2ZmIHVzZWQgb3JpZ2luYWxs" + - "eS4gU2VlCltTcGxpdCBDb21wdXRlLVBsYW5lIEluc3RhbGxhdGlvbl0ocmVmZXJlbmNlcy9jb21w" + - "dXRlLXBsYW5lLWluc3RhbGxhdGlvbi5tZCkKZm9yIHRoZSBmaWVsZHMgYW5kIGNvbXBsZXRlIGNv" + - "bW1hbmRzLgoKIyMjIFN0ZXAgMzogVmVyaWZ5IGJvdGggY29udGV4dHMKCmBgYGJhc2gKZGlnICtz" + - "aG9ydCAiYXBpLjxkb21haW4+IgpjdXJsIC1IICJIb3N0OiBhcGkuPGRvbWFpbj4iICJodHRwOi8v" + - "JEdBVEVXQVlfQUREUi9oZWFsdGgiCmt1YmVjdGwgLS1jb250ZXh0IDxjb250cm9sLXBsYW5lLWNv" + - "bnRleHQ+IGdldCBnYXRld2F5IG52Y2YtZ2F0ZXdheSBcCiAgLW4gZW52b3ktZ2F0ZXdheSAtbyB3" + - "aWRlCmt1YmVjdGwgLS1jb250ZXh0IDxjb250cm9sLXBsYW5lLWNvbnRleHQ+IGdldCBodHRwcm91" + - "dGVzIC1BCmt1YmVjdGwgLS1jb250ZXh0IDxjb250cm9sLXBsYW5lLWNvbnRleHQ+IGdldCB0Y3By" + - "b3V0ZXMgLUEKa3ViZWN0bCAtLWNvbnRleHQgPGNvbXB1dGUtcGxhbmUtY29udGV4dD4gcm9sbG91" + - "dCBzdGF0dXMgXAogIGRlcGxveW1lbnQvbnZjYS1vcGVyYXRvciAtbiBudmNhLW9wZXJhdG9yIC0t" + - "dGltZW91dD0xMG0Ka3ViZWN0bCAtLWNvbnRleHQgPGNvbXB1dGUtcGxhbmUtY29udGV4dD4gd2Fp" + - "dCBcCiAgbnZjZmJhY2tlbmQvPGNvbXB1dGUtcGxhbmUtY2x1c3Rlci1uYW1lPiAtbiBudmNhLW9w" + - "ZXJhdG9yIFwKICAtLWZvcj1qc29ucGF0aD0ney5zdGF0dXMuYWdlbnRTdGF0dXN9Jz1oZWFsdGh5" + - "IC0tdGltZW91dD0xMG0KYGBgCgotLS0KCiMjIEV4YW1wbGUgNTogRGVwbG95IE9ubHkgRGVwZW5k" + - "ZW5jaWVzCgpVc2VmdWwgZm9yIHRlc3Rpbmcgb3Igd2hlbiBpdGVyYXRpbmcgb24gc2VydmljZSBj" + - "b25maWd1cmF0aW9uLgoKYGBgYmFzaAojIERlcGxveSBqdXN0IE5BVFMsIENhc3NhbmRyYSwgT3Bl" + - "bkJhbwpIRUxNRklMRV9FTlY9PGVudj4gaGVsbWZpbGUgLS1zZWxlY3RvciByZWxlYXNlLWdyb3Vw" + - "PWRlcGVuZGVuY2llcyBzeW5jCgojIENoZWNrIHN0YXR1cwprdWJlY3RsIGdldCBwb2RzIC1uIG5h" + - "dHMtc3lzdGVtCmt1YmVjdGwgZ2V0IHBvZHMgLW4gY2Fzc2FuZHJhLXN5c3RlbQprdWJlY3RsIGdl" + - "dCBwb2RzIC1uIHZhdWx0LXN5c3RlbQoKIyBEZXBsb3kganVzdCBvbmUgc3BlY2lmaWMgcmVsZWFz" + - "ZQpIRUxNRklMRV9FTlY9PGVudj4gaGVsbWZpbGUgLS1zZWxlY3RvciBuYW1lPWNhc3NhbmRyYSBz" + - "eW5jCmBgYAoKIyMjIFNlbGVjdG9yIHJlZmVyZW5jZQoKfCBTZWxlY3RvciB8IFJlbGVhc2VzIHwK" + - "fC0tLS0tLS0tLS18LS0tLS0tLS0tLXwKfCBgcmVsZWFzZS1ncm91cD1kZXBlbmRlbmNpZXNgIHwg" + - "bmF0cywgY2Fzc2FuZHJhLCBvcGVuYmFvLXNlcnZlciB8CnwgYHJlbGVhc2UtZ3JvdXA9c2Vydmlj" + - "ZXNgIHwgYXBpLWtleXMsIHNpcywgYXBpLCBpbnZvY2F0aW9uLXNlcnZpY2UsIGdycGMtcHJveHks" + - "IGVzcy1hcGksIG5vdGFyeS1zZXJ2aWNlLCByZXZhbCwgb3B0aW9uYWwgbGxtLXJlcXVlc3Qtcm91" + - "dGVyIGFuZCBsbG0tYXBpLWdhdGV3YXkgd2hlbiBgbGxtLmVuYWJsZWQ9dHJ1ZWAsIG9wdGlvbmFs" + - "IHZhbml0eS1nYXRld2F5IG9ubHkgaW4gc3RhY2sgcGFja2FnZXMgdGhhdCBpbmNsdWRlIHRoZSBh" + - "ZGRvbiBhbmQgaGF2ZSBgYWRkb25zLnZhbml0eUdhdGV3YXkuZW5hYmxlZD10cnVlYCwgb3B0aW9u" + - "YWwgbnZjZi11aSBvbmx5IGluIHN0YWNrIHBhY2thZ2VzIHRoYXQgaW5jbHVkZSB0aGUgYWRkb24g" + - "YW5kIGhhdmUgYGFkZG9ucy5udmNmVWkuZW5hYmxlZD10cnVlYCB8CnwgYG5hbWU9bGxtLXJlcXVl" + - "c3Qtcm91dGVyYCB8IERlcGxveSBqdXN0IHRoZSBMTE0gcmVxdWVzdCByb3V0ZXIgd2hlbiBgbGxt" + - "LmVuYWJsZWQ9dHJ1ZWAgfAp8IGBuYW1lPWxsbS1hcGktZ2F0ZXdheWAgfCBEZXBsb3kganVzdCB0" + - "aGUgTExNIEFQSSBnYXRld2F5IHdoZW4gYGxsbS5lbmFibGVkPXRydWVgIHwKfCBgbmFtZT12YW5p" + - "dHktZ2F0ZXdheWAgfCBEZXBsb3kganVzdCBWYW5pdHkgR2F0ZXdheSBvbmx5IHdoZW4gdGhlIHN0" + - "YWNrIHBhY2thZ2UgaW5jbHVkZXMgdGhhdCByZWxlYXNlIGFuZCBgYWRkb25zLnZhbml0eUdhdGV3" + - "YXkuZW5hYmxlZD10cnVlYCB8CnwgYG5hbWU9bnZjZi11aWAgfCBEZXBsb3kgTlZDRiBVSSBvbmx5" + - "IHdoZW4gdGhlIHN0YWNrIHBhY2thZ2UgaW5jbHVkZXMgdGhhdCByZWxlYXNlIGFuZCBgYWRkb25z" + - "Lm52Y2ZVaS5lbmFibGVkPXRydWVgIHwKfCBgcmVsZWFzZS1ncm91cD1pbmdyZXNzYCB8IGluZ3Jl" + - "c3MgKGdhdGV3YXkgcm91dGVzKSB8CnwgYG5hbWU9PHJlbGVhc2U+YCB8IEFueSBpbmRpdmlkdWFs" + - "IHJlbGVhc2UgYnkgbmFtZSB8CgpOb3RlOiBgYWRtaW4taXNzdWVyLXByb3h5YCBkb2VzIG5vdCBo" + - "YXZlIGEgcmVsZWFzZS1ncm91cCBsYWJlbC4gVGFyZ2V0IGl0IHdpdGggYC0tc2VsZWN0b3IgbmFt" + - "ZT1hZG1pbi1pc3N1ZXItcHJveHlgLgpQSwcIAlJOQH8oAAB/KAAAUEsDBBQACAAAAAAAIQAAAAAA" + - "AAAAAAAAAABMAAkAZGF0YS9udmNmLXNlbGYtbWFuYWdlZC1pbnN0YWxsYXRpb24vcmVmZXJlbmNl" + - "cy9jb21wdXRlLXBsYW5lLWluc3RhbGxhdGlvbi5tZFVUBQABAKbOEiMgU3BsaXQgQ29tcHV0ZS1Q" + - "bGFuZSBJbnN0YWxsYXRpb24KClRoZSBjb250cm9sIHBsYW5lIGFuZCBjb21wdXRlIHBsYW5lIGFy" + - "ZSBzZXBhcmF0ZSBzdGFja3MuIEluc3RhbGwgdGhlIGNvbnRyb2wKcGxhbmUgZmlyc3QsIHRoZW4g" + - "cmVnaXN0ZXIgYW5kIGluc3RhbGwgZWFjaCBjb21wdXRlIGNsdXN0ZXIuIENob29zZSBvbmUgaGFu" + - "ZG9mZgpiZWxvdyBhbmQgdXNlIGl0IGZvciB0aGUgZnVsbCBsaWZlY3ljbGUuIERvIG5vdCBjb21i" + - "aW5lIGEgQ0xJLWdlbmVyYXRlZCBwcm9maWxlCndpdGggdGhlIEhlbG1maWxlIHZhbHVlcyBmbG93" + - "LgoKIyMgQ2hvb3NlIGEgSGFuZG9mZgoKfCBGbG93IHwgU291cmNlIG9mIGNvbnRyb2wtcGxhbmUg" + - "ZW5kcG9pbnRzIHwgUmVnaXN0cmF0aW9uIGFydGlmYWN0IHwKfC0tLS0tLXwtLS0tLS0tLS0tLS0t" + - "LS0tLS0tLS0tLS0tLS0tLS0tLS0tLXwtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLXwKfCBIZWxtZmls" + - "ZSB2YWx1ZXMgfCBTZXBhcmF0ZSBjb250cm9sLXBsYW5lIGFuZCBjb21wdXRlLXBsYW5lIGVudmly" + - "b25tZW50IGZpbGVzIHwgYGRlcGxveS9zdGFja3MvbnZjZi1jb21wdXRlLXBsYW5lL3JlZ2lzdHJh" + - "dGlvbi88Y2x1c3Rlcj4tcmVnaXN0ZXItdmFsdWVzLnlhbWxgIHwKfCBDTEkgcHJvZmlsZSB8IENM" + - "SS1nZW5lcmF0ZWQgYGRlcGxveS9zdGFja3Mvc2VsZi1tYW5hZ2VkL291dC9jb250cm9sLXBsYW5l" + - "LXByb2ZpbGUueWFtbGAgfCBDTEktZ2VuZXJhdGVkIGBkZXBsb3kvc3RhY2tzL252Y2YtY29tcHV0" + - "ZS1wbGFuZS9vdXQvPGNsdXN0ZXI+LXJlZ2lzdGVyLXZhbHVlcy55YW1sYCB8CgpUaGUgQ0xJIHBy" + - "b2ZpbGUgaXMgbWFuZGF0b3J5IGZvciB0aGUgQ0xJIGZsb3cgYW5kIG11c3Qgbm90IGJlIGhhbmQt" + - "YXV0aG9yZWQuClRoZSBIZWxtZmlsZSBmbG93IGRvZXMgbm90IGNvbnN1bWUgYSBjb250cm9sLXBs" + - "YW5lIHByb2ZpbGUuCgpDb21tYW5kcyBiZWxvdyB1c2UgbW9ub3JlcG8gcGF0aHMgZnJvbSB0aGUg" + - "cmVwb3NpdG9yeSByb290LiBPcGVyYXRvcnMgdXNpbmcKZXh0cmFjdGVkIHBhY2thZ2VzIG5lZWQg" + - "bWF0Y2hpbmctdmVyc2lvbiBgbnZjZi1zZWxmLW1hbmFnZWQtc3RhY2tgIGFuZApgbnZjZi1jb21w" + - "dXRlLXBsYW5lLXN0YWNrYCBidW5kbGVzLiBTdWJzdGl0dXRlIHRob3NlIGJ1bmRsZSByb290cyBm" + - "b3IKYGRlcGxveS9zdGFja3Mvc2VsZi1tYW5hZ2VkYCBhbmQgYGRlcGxveS9zdGFja3MvbnZjZi1j" + - "b21wdXRlLXBsYW5lYC4KCiMjIEhlbG1maWxlIFZhbHVlcyBGbG93CgpDcmVhdGUgYm90aCBlbnZp" + - "cm9ubWVudCBmaWxlcyBiZWZvcmUgaW5zdGFsbGF0aW9uOgoKLSBgZGVwbG95L3N0YWNrcy9zZWxm" + - "LW1hbmFnZWQvZW52aXJvbm1lbnRzLzxlbnY+LnlhbWxgIGZvciBjb250cm9sLXBsYW5lCiAgcmVn" + - "aXN0cnksIGRvbWFpbiwgR2F0ZXdheSwgcm91dGVzLCBhbmQgc2VydmljZSBzZXR0aW5ncy4KLSBg" + - "ZGVwbG95L3N0YWNrcy9udmNmLWNvbXB1dGUtcGxhbmUvZW52aXJvbm1lbnRzLzxlbnY+LnlhbWxg" + - "IGZvciBjb21wdXRlLXBsYW5lCiAgcmVnaXN0cnksIHB1bGwgc2VjcmV0cywgYW5kIGNvbXB1dGUt" + - "cmVhY2hhYmxlIElDTVMsIFJlVmFsLCBhbmQgTkFUUyB2YWx1ZXMuCgpGb3IgRUtTLCB1c2UgdGhl" + - "IGNhbm9uaWNhbApbQ1NQIEVuZC10by1FbmQgRXhhbXBsZV0oaHR0cHM6Ly9kb2NzLm52aWRpYS5j" + - "b20vbnZjZi92MC42LjAtcmMvY3NwLWVuZC10by1lbmQtZXhhbXBsZSkuClRoZSBjb250cm9sLXBs" + - "YW5lIGVudmlyb25tZW50IGtlZXBzIHRoZSBFbnZveSBHYXRld2F5IGNvbnRyb2xsZXIgaW4KYGVu" + - "dm95LWdhdGV3YXktc3lzdGVtYCwgYXR0YWNoZXMgcm91dGVzIHRvIGBHYXRld2F5L252Y2YtZ2F0" + - "ZXdheWAgaW4KYGVudm95LWdhdGV3YXlgLCBhbmQgZW5hYmxlcyB0aGUgTkFUUyByb3V0ZS4gVGhl" + - "IGNvbXB1dGUtcGxhbmUgZW52aXJvbm1lbnQgdXNlcwp0aGUgZXh0ZXJuYWwgYWRkcmVzcyBwbHVz" + - "IHRoZSBzZXJ2aWNlIGhvc3Qgb3ZlcnJpZGVzLiBIZXJlLApgPGdhdGV3YXktYWRkcmVzcz5gIGlz" + - "IHRoZSBOTEIgYWRkcmVzcyBhbmQgYDxnYXRld2F5LWRvbWFpbj5gIGlzIHRoZSBETlMgYmFzZQp3" + - "aG9zZSBzZXJ2aWNlIHN1YmRvbWFpbnMgcmVzb2x2ZSB0byB0aGF0IE5MQjoKCmBgYHlhbWwKIyBk" + - "ZXBsb3kvc3RhY2tzL3NlbGYtbWFuYWdlZC9lbnZpcm9ubWVudHMvPGVudj4ueWFtbApnbG9iYWw6" + - "CiAgZG9tYWluOiAiPGdhdGV3YXktZG9tYWluPiIKICB3b3JrZXJFbmRwb2ludHM6CiAgICBudmNm" + - "U2VydmljZVVSTDogImh0dHA6Ly9hcGkuPGdhdGV3YXktZG9tYWluPiIKICAgIG52Y2ZHcnBjU2Vy" + - "dmljZVVSTDogImh0dHA6Ly93b3JrZXItYXBpLjxnYXRld2F5LWRvbWFpbj4iCiAgICBudmNmTmF0" + - "c1NlcnZpY2VVUkw6ICJuYXRzOi8vPGdhdGV3YXktYWRkcmVzcz46NDIyMiIKICAgIG52Y3RTZXJ2" + - "aWNlVVJMOiAiaHR0cDovL3Rhc2tzLjxnYXRld2F5LWRvbWFpbj4iCiAgICBudmN0R3JwY1NlcnZp" + - "Y2VVUkw6ICJodHRwOi8vd29ya2VyLXRhc2tzLjxnYXRld2F5LWRvbWFpbj4iCiAgICBpbnZvY2F0" + - "aW9uU2VydmljZVVSTDogImh0dHA6Ly9pbnZvY2F0aW9uLjxnYXRld2F5LWRvbWFpbj4iCgpncnBj" + - "cHJveHk6CiAgbnZjZkdycGNTZXJ2aWNlVVJMOiAiaHR0cDovL2FwaS5udmNmLnN2Yy5jbHVzdGVy" + - "LmxvY2FsOjkwOTAiCgppbmdyZXNzOgogIGdhdGV3YXlBcGk6CiAgICBjb250cm9sbGVyTmFtZXNw" + - "YWNlOiBlbnZveS1nYXRld2F5LXN5c3RlbQogICAgZ2F0ZXdheXM6CiAgICAgIHNoYXJlZDoge25h" + - "bWU6IG52Y2YtZ2F0ZXdheSwgbmFtZXNwYWNlOiBlbnZveS1nYXRld2F5fQogICAgICBncnBjOiB7" + - "bmFtZTogbnZjZi1nYXRld2F5LCBuYW1lc3BhY2U6IGVudm95LWdhdGV3YXl9CiAgICAgIG5hdHM6" + - "CiAgICAgICAgbmFtZTogbnZjZi1nYXRld2F5CiAgICAgICAgbmFtZXNwYWNlOiBlbnZveS1nYXRl" + - "d2F5CiAgICAgICAgbGlzdGVuZXJOYW1lOiBuYXRzCiAgICByb3V0ZXM6CiAgICAgIG52Y2ZBcGk6" + - "CiAgICAgICAgZ3JwYzoKICAgICAgICAgIGVuYWJsZWQ6IHRydWUKICAgICAgICAgIGhvc3RuYW1l" + - "czogWyJ3b3JrZXItYXBpLjxnYXRld2F5LWRvbWFpbj4iXQogICAgICBudmN0QXBpOgogICAgICAg" + - "IGdycGM6CiAgICAgICAgICBlbmFibGVkOiB0cnVlCiAgICAgICAgICBob3N0bmFtZXM6IFsid29y" + - "a2VyLXRhc2tzLjxnYXRld2F5LWRvbWFpbj4iXQogICAgICBuYXRzOgogICAgICAgIGVuYWJsZWQ6" + - "IHRydWUKCm9wZW5iYW86CiAgbWlncmF0aW9uczoKICAgIGlzc3VlckRpc2NvdmVyeToKICAgICAg" + - "ZW5hYmxlZDogdHJ1ZQpgYGAKCmBgYHlhbWwKIyBkZXBsb3kvc3RhY2tzL252Y2YtY29tcHV0ZS1w" + - "bGFuZS9lbnZpcm9ubWVudHMvPGVudj4ueWFtbApnbG9iYWw6CiAgbnZjYU9wZXJhdG9yOgogICAg" + - "c2VsZk1hbmFnZWQ6CiAgICAgIGljbXNTZXJ2aWNlVVJMOiAiaHR0cDovLzxnYXRld2F5LWFkZHJl" + - "c3M+IgogICAgICBpY21zU2VydmljZUhvc3RIZWFkZXJPdmVycmlkZTogInNpcy48Z2F0ZXdheS1k" + - "b21haW4+IgogICAgICByZXZhbFNlcnZpY2VVUkw6ICJodHRwOi8vPGdhdGV3YXktYWRkcmVzcz4i" + - "CiAgICAgIHJldmFsU2VydmljZUhvc3RIZWFkZXJPdmVycmlkZTogInJldmFsLjxnYXRld2F5LWRv" + - "bWFpbj4iCiAgICAgIG5hdHNVUkw6ICJuYXRzOi8vPGdhdGV3YXktYWRkcmVzcz46NDIyMiIKICAg" + - "ICAgbmF0c0hvc3RPdmVycmlkZTogIm5hdHMuPGdhdGV3YXktZG9tYWluPiIKYGBgCgpQcmV2aWV3" + - "IGFuZCBpbnN0YWxsIHRoZSBjb250cm9sIHBsYW5lIGFnYWluc3QgaXRzIGNvbnRleHQ6CgpgYGBi" + - "YXNoCm1ha2UgLUMgZGVwbG95L3N0YWNrcy9zZWxmLW1hbmFnZWQgdGVtcGxhdGUgXAogIEhFTE1G" + - "SUxFX0VOVj08ZW52PiBcCiAgS1VCRUNPTkZJR19GSUxFPTxjb250cm9sLXBsYW5lLWt1YmVjb25m" + - "aWc+CgptYWtlIC1DIGRlcGxveS9zdGFja3Mvc2VsZi1tYW5hZ2VkIGluc3RhbGwgXAogIEhFTE1G" + - "SUxFX0VOVj08ZW52PiBcCiAgS1VCRUNPTkZJR19GSUxFPTxjb250cm9sLXBsYW5lLWt1YmVjb25m" + - "aWc+CmBgYAoKQmVmb3JlIHJlZ2lzdGVyaW5nIHRocm91Z2ggYSBiYXJlIEdhdGV3YXkgYWRkcmVz" + - "cywgY3JlYXRlIG9yIHVwZGF0ZSB0aGUgQ0xJCmNvbmZpZyBwYXNzZWQgYXMgYE5WQ0ZfQ0xJX0NP" + - "TkZJR2A6CgpgYGB5YW1sCmJhc2VfaHR0cF91cmw6ICJodHRwOi8vPGdhdGV3YXktYWRkcmVzcz4i" + - "Cmludm9rZV91cmw6ICJodHRwOi8vPGdhdGV3YXktYWRkcmVzcz4iCmJhc2VfZ3JwY191cmw6ICI8" + - "Z2F0ZXdheS1hZGRyZXNzPjoxMDA4MSIKYXBpX2tleXNfc2VydmljZV91cmw6ICJodHRwOi8vPGdh" + - "dGV3YXktYWRkcmVzcz4iCmljbXNfdXJsOiAiaHR0cDovLzxnYXRld2F5LWFkZHJlc3M+IgphcGlf" + - "aG9zdDogImFwaS48Z2F0ZXdheS1kb21haW4+IgphcGlfa2V5c19ob3N0OiAiYXBpLWtleXMuPGdh" + - "dGV3YXktZG9tYWluPiIKaW52b2tlX2hvc3Q6ICJpbnZvY2F0aW9uLjxnYXRld2F5LWRvbWFpbj4i" + - "CmljbXNfaG9zdDogInNpcy48Z2F0ZXdheS1kb21haW4+IgpgYGAKCkhvc3QgZmllbGRzIGNvbnRh" + - "aW4gaG9zdG5hbWVzIG9ubHksIHdpdGhvdXQgYSBVUkwgc2NoZW1lLiBgSUNNU19VUkxgIG1hcHMg" + - "b25seQp0byB0aGUgcmVnaXN0cmF0aW9uIGNvbW1hbmQncyBgLS1pY21zLXVybGA7IGBpY21zX2hv" + - "c3RgIGluIHRoZSBjb25maWcgc3VwcGxpZXMKdGhlIEdhdGV3YXkgSG9zdCBoZWFkZXIuIFRoZXJl" + - "IGlzIG5vIGAtLWljbXMtaG9zdGAgTWFrZSBvciBDTEkgZmxhZy4KClJlZ2lzdGVyIGZyb20gdGhl" + - "IGNvbXB1dGUgY29udGV4dCwgdGhlbiBpbnN0YWxsIHRoZSBjb21wdXRlIHBsYW5lOgoKYGBgYmFz" + - "aAptYWtlIC1DIGRlcGxveS9zdGFja3MvbnZjZi1jb21wdXRlLXBsYW5lIHJlZ2lzdGVyLWNsdXN0" + - "ZXIgXAogIENMVVNURVJfTkFNRT08Y2x1c3Rlci1uYW1lPiBcCiAgTkNBX0lEPTxuY2EtaWQ+IFwK" + - "ICBDTFVTVEVSX1JFR0lPTj08cmVnaW9uPiBcCiAgSUNNU19VUkw9aHR0cDovLzxnYXRld2F5LWFk" + - "ZHJlc3M+IFwKICBLVUJFQ09ORklHX0ZJTEU9PGNvbXB1dGUtcGxhbmUta3ViZWNvbmZpZz4gXAog" + - "IE5WQ0ZfQ0xJPTxwYXRoLXRvLW52Y2YtY2xpPiBcCiAgTlZDRl9DTElfQ09ORklHPTxwYXRoLXRv" + - "LW52Y2YtY2xpLWNvbmZpZz4KCm1ha2UgLUMgZGVwbG95L3N0YWNrcy9udmNmLWNvbXB1dGUtcGxh" + - "bmUgaW5zdGFsbCBcCiAgQ0xVU1RFUl9OQU1FPTxjbHVzdGVyLW5hbWU+IFwKICBIRUxNRklMRV9F" + - "TlY9PGVudj4gXAogIEtVQkVDT05GSUdfRklMRT08Y29tcHV0ZS1wbGFuZS1rdWJlY29uZmlnPgpg" + - "YGAKClJlZ2lzdHJhdGlvbiBkaXNjb3ZlcnMgdGhlIE9JREMgaXNzdWVyIGFuZCBKV0tTIGZyb20g" + - "dGhlIGNvbXB1dGUga3ViZSBjb250ZXh0LgpJbiBhIG11bHRpLWNsdXN0ZXIgZGVwbG95bWVudCwg" + - "YEtVQkVDT05GSUdfRklMRWAgaXMgcmVxdWlyZWQgb24gYm90aApjb21wdXRlLXBsYW5lIGNvbW1h" + - "bmRzLiBJbiBhIHNhbWUtY2x1c3RlciBkZXBsb3ltZW50IGl0IG1heSBiZSBvbWl0dGVkIG9ubHkK" + - "d2hlbiB0aGUgYW1iaWVudCBjb250ZXh0IGlzIGFscmVhZHkgdGhlIHRhcmdldCBjbHVzdGVyLgoK" + - "IyMgQ0xJIFByb2ZpbGUgRmxvdwoKUnVuIHRoZSBDTEkgY29udHJvbC1wbGFuZSBpbnN0YWxsIGZp" + - "cnN0LiBJdCBjcmVhdGVzIHRoZSBwcm9maWxlIGNvbnN1bWVkIGJ5CmNvbXB1dGUtcGxhbmUgcmVn" + - "aXN0cmF0aW9uOgoKYGBgYmFzaApudmNmLWNsaSAtLWNvbmZpZyA8Y29uZmlnPiBzZWxmLWhvc3Rl" + - "ZCBcCiAgLS1jb250cm9sLXBsYW5lLXN0YWNrIGRlcGxveS9zdGFja3Mvc2VsZi1tYW5hZ2VkIFwK" + - "ICAtLWNvbXB1dGUtcGxhbmUtc3RhY2sgZGVwbG95L3N0YWNrcy9udmNmLWNvbXB1dGUtcGxhbmUg" + - "XAogIC0tZW52IDxlbnY+IFwKICAtLXBsYWluIFwKICAtLWNvbnRyb2wtcGxhbmUtY29udGV4dCA8" + - "Y29udHJvbC1wbGFuZS1jb250ZXh0PiBcCiAgLS1jb21wdXRlLXBsYW5lLWNvbnRleHQgPGNvbXB1" + - "dGUtcGxhbmUtY29udGV4dD4gXAogIGluc3RhbGwgLS1jb250cm9sLXBsYW5lIFwKICAtLWNsdXN0" + - "ZXItbmFtZSA8Y29udHJvbC1wbGFuZS1jbHVzdGVyLW5hbWU+IFwKICAtLXJlZ2lvbiA8cmVnaW9u" + - "PiBcCiAgLS1uY2EtaWQgPG5jYS1pZD4KCnRlc3QgLXMgZGVwbG95L3N0YWNrcy9zZWxmLW1hbmFn" + - "ZWQvb3V0L2NvbnRyb2wtcGxhbmUtcHJvZmlsZS55YW1sCmBgYAoKVXNlIHRoZSBmdWxsIHBlcnNp" + - "c3RlbnQgcHJlZml4IGZvciBib3RoIGNvbXB1dGUtcGxhbmUgY29tbWFuZHM6CgpgYGBiYXNoCm52" + - "Y2YtY2xpIC0tY29uZmlnIDxjb25maWc+IHNlbGYtaG9zdGVkIFwKICAtLWNvbnRyb2wtcGxhbmUt" + - "c3RhY2sgZGVwbG95L3N0YWNrcy9zZWxmLW1hbmFnZWQgXAogIC0tY29tcHV0ZS1wbGFuZS1zdGFj" + - "ayBkZXBsb3kvc3RhY2tzL252Y2YtY29tcHV0ZS1wbGFuZSBcCiAgLS1lbnYgPGVudj4gXAogIC0t" + - "cGxhaW4gXAogIGNvbXB1dGUtcGxhbmUgcmVnaXN0ZXIgXAogIC0tY29udHJvbC1wbGFuZS1wcm9m" + - "aWxlIGRlcGxveS9zdGFja3Mvc2VsZi1tYW5hZ2VkL291dC9jb250cm9sLXBsYW5lLXByb2ZpbGUu" + - "eWFtbCBcCiAgLS1jbHVzdGVyLW5hbWUgPGNvbXB1dGUtcGxhbmUtY2x1c3Rlci1uYW1lPiBcCiAg" + - "LS1rdWJlLWNvbnRleHQgPGNvbXB1dGUtcGxhbmUtY29udGV4dD4gXAogIC0tcmVnaW9uIDxyZWdp" + - "b24+IFwKICAtLW91dHB1dCBkZXBsb3kvc3RhY2tzL252Y2YtY29tcHV0ZS1wbGFuZS9vdXQvPGNv" + - "bXB1dGUtcGxhbmUtY2x1c3Rlci1uYW1lPi1yZWdpc3Rlci12YWx1ZXMueWFtbAoKbnZjZi1jbGkg" + - "LS1jb25maWcgPGNvbmZpZz4gc2VsZi1ob3N0ZWQgXAogIC0tY29udHJvbC1wbGFuZS1zdGFjayBk" + - "ZXBsb3kvc3RhY2tzL3NlbGYtbWFuYWdlZCBcCiAgLS1jb21wdXRlLXBsYW5lLXN0YWNrIGRlcGxv" + - "eS9zdGFja3MvbnZjZi1jb21wdXRlLXBsYW5lIFwKICAtLWVudiA8ZW52PiBcCiAgLS1wbGFpbiBc" + - "CiAgY29tcHV0ZS1wbGFuZSBpbnN0YWxsIFwKICAtLXZhbHVlcyBkZXBsb3kvc3RhY2tzL252Y2Yt" + - "Y29tcHV0ZS1wbGFuZS9vdXQvPGNvbXB1dGUtcGxhbmUtY2x1c3Rlci1uYW1lPi1yZWdpc3Rlci12" + - "YWx1ZXMueWFtbCBcCiAgLS1rdWJlLWNvbnRleHQgPGNvbXB1dGUtcGxhbmUtY29udGV4dD4gXAog" + - "IC0tY2x1c3Rlci1uYW1lIDxjb21wdXRlLXBsYW5lLWNsdXN0ZXItbmFtZT4KYGBgCgpSZWdpc3Ry" + - "YXRpb24gc2VsZWN0cyB0aGUgcHJvZmlsZSdzIGluLWNsdXN0ZXIgb3IgY29tcHV0ZS1yZWFjaGFi" + - "bGUgZW5kcG9pbnRzCmZyb20gdGhlIGNvbXB1dGUgY29udGV4dCBhbmQgcHJvYmVzIGl0cyBKV0tT" + - "LiBEbyBub3QgcmVwbGFjZSBwcm9maWxlIGVuZHBvaW50cwp3aXRoIGhhbmQtYXV0aG9yZWQgSGVs" + - "bWZpbGUgZW5kcG9pbnQgdmFsdWVzLgoKIyMgUHVsbCBTZWNyZXRzCgpDcmVhdGUgdGhlIGNvbnRy" + - "b2wtcGxhbmUgc2VjcmV0IGluIHRoZXNlIG5hbWVzcGFjZXMgb24gdGhlIGNvbnRyb2wtcGxhbmUK" + - "Y29udGV4dDoKCmBgYHRleHQKY2Fzc2FuZHJhLXN5c3RlbSBuYXRzLXN5c3RlbSBudmNmIGFwaS1r" + - "ZXlzIGVzcyBzaXMgdmF1bHQtc3lzdGVtIGNlcnQtbWFuYWdlcgpgYGAKCk9uIHRoZSBjb21wdXRl" + - "IGNvbnRleHQsIGNyZWF0ZSB0aGUgc2VjcmV0IG9ubHkgaW4gYG52Y2Etb3BlcmF0b3JgIGFuZCBy" + - "ZWZlcmVuY2UKaXQgdGhyb3VnaCBgZ2xvYmFsLmltYWdlUHVsbFNlY3JldHNgIGluIHRoZSBjb21w" + - "dXRlLXBsYW5lIGVudmlyb25tZW50LiBUaGUgY2hhcnQKYW5kIG9wZXJhdG9yIHVzZSBpdCBpbiBg" + - "bnZjYS1vcGVyYXRvcmAgYW5kIG1pcnJvciBpdCB0byBgbnZjYS1zeXN0ZW1gLiBEbyBub3QgYWRk" + - "CmVpdGhlciBuYW1lc3BhY2UgdG8gdGhlIGNvbnRyb2wtcGxhbmUgbGlzdC4gRm9yIGNvbW1hbmRz" + - "IGFuZCBwb2xpY3kgZXhhbXBsZXMsCnNlZSBbcHVsbC1zZWNyZXRzLm1kXShwdWxsLXNlY3JldHMu" + - "bWQpLgoKIyMgVmVyaWZpY2F0aW9uCgpVc2UgdGhlIGV4cGxpY2l0IEdhdGV3YXkgbmFtZSBhbmQg" + - "bmFtZXNwYWNlOgoKYGBgYmFzaAprdWJlY3RsIC0tY29udGV4dCA8Y29udHJvbC1wbGFuZS1jb250" + - "ZXh0PiBnZXQgZ2F0ZXdheSBudmNmLWdhdGV3YXkgXAogIC1uIGVudm95LWdhdGV3YXkgLW8gd2lk" + - "ZQprdWJlY3RsIC0tY29udGV4dCA8Y29udHJvbC1wbGFuZS1jb250ZXh0PiBnZXQgdGNwcm91dGUg" + - "LW4gZW52b3ktZ2F0ZXdheQprdWJlY3RsIC0tY29udGV4dCA8Y29tcHV0ZS1wbGFuZS1jb250ZXh0" + - "PiByb2xsb3V0IHN0YXR1cyBcCiAgZGVwbG95bWVudC9udmNhLW9wZXJhdG9yIC1uIG52Y2Etb3Bl" + - "cmF0b3IgLS10aW1lb3V0PTEwbQprdWJlY3RsIC0tY29udGV4dCA8Y29tcHV0ZS1wbGFuZS1jb250" + - "ZXh0PiB3YWl0IFwKICBudmNmYmFja2VuZC88Y29tcHV0ZS1wbGFuZS1jbHVzdGVyLW5hbWU+IC1u" + - "IG52Y2Etb3BlcmF0b3IgXAogIC0tZm9yPWpzb25wYXRoPSd7LnN0YXR1cy5hZ2VudFN0YXR1c30n" + - "PWhlYWx0aHkgLS10aW1lb3V0PTEwbQprdWJlY3RsIC0tY29udGV4dCA8Y29tcHV0ZS1wbGFuZS1j" + - "b250ZXh0PiBnZXQgc2VjcmV0IDxwdWxsLXNlY3JldD4gLW4gbnZjYS1zeXN0ZW0KYGBgCgojIyBU" + - "ZWFyZG93bgoKRGVzdHJveSBhbmQgZGVyZWdpc3RlciBldmVyeSBjb21wdXRlIHBsYW5lIGJlZm9y" + - "ZSB0aGUgY29udHJvbCBwbGFuZS4gQm90aApoYW5kb2ZmcyBjYW4gZGVzdHJveSB0aGUgY29udHJv" + - "bCBwbGFuZSwgc28gYXBwbHkgdGhpcyBwcmVmbGlnaHQgYmVmb3JlIGVpdGhlcgpvbmUuIFByZXNl" + - "cnZlIHRoZSBgY2VydC1tYW5hZ2VyYCBuYW1lc3BhY2UgYnkgZGVmYXVsdC4gTmFtZXNwYWNlIHBy" + - "ZXNlcnZhdGlvbgpkb2VzIG5vdCBwcmVzZXJ2ZSB0aGUgSGVsbSByZWxlYXNlLiBJZGVudGlmeSB3" + - "aGV0aGVyIGNlcnQtbWFuYWdlciBpcyBleHRlcm5hbC4KRm9yIGFuIGV4dGVybmFsIGluc3RhbGxh" + - "dGlvbiwgcmVxdWlyZSBlZmZlY3RpdmUgYGNlcnRNYW5hZ2VyLmVuYWJsZWQ6IGZhbHNlYAphbmQg" + - "YWJvcnQgaWYgaXQgaXMgdHJ1ZS4gRm9yIGFuIGludGVuZGVkIHN0YWNrLW1hbmFnZWQgcmVsZWFz" + - "ZSB3aXRoIGVmZmVjdGl2ZQpgY2VydE1hbmFnZXIuZW5hYmxlZDogdHJ1ZWAsIHZlcmlmeSBtYXRj" + - "aGluZyBzdGFjayBIZWxtIHJlbGVhc2UgbWV0YWRhdGEgYW5kCmFib3J0IG9uIG1pc3Npbmcgb3Ig" + - "bWlzbWF0Y2hlZCBldmlkZW5jZS4gT25seSBwbGFuIG5hbWVzcGFjZSByZW1vdmFsIGFmdGVyCnZl" + - "cmlmeWluZyBuYW1lc3BhY2UgcHJvdmVuYW5jZSBhbmQgZ2V0dGluZyBleHBsaWNpdCBjb25maXJt" + - "YXRpb247IG90aGVyd2lzZQpkbyBub3QgZGVsZXRlIGl0LgoKRm9yIHRoZSBIZWxtZmlsZSB2YWx1" + - "ZXMgZmxvdywgcmV0YWluIGVhY2ggcmVnaXN0cmF0aW9uIHZhbHVlcyBmaWxlIHVudGlsCmNsZWFu" + - "dXAgaXMgdmVyaWZpZWQ6CgpgYGBiYXNoCm1ha2UgLUMgZGVwbG95L3N0YWNrcy9udmNmLWNvbXB1" + - "dGUtcGxhbmUgZGVzdHJveSBcCiAgQ0xVU1RFUl9OQU1FPTxjbHVzdGVyLW5hbWU+IFwKICBIRUxN" + - "RklMRV9FTlY9PGVudj4gXAogIEtVQkVDT05GSUdfRklMRT08Y29tcHV0ZS1wbGFuZS1rdWJlY29u" + - "ZmlnPgoKPG52Y2YtY2xpPiAtLWNvbmZpZyA8Y29uZmlnPiBjbHVzdGVyIGRlbGV0ZSBcCiAgLS1j" + - "bHVzdGVyLWlkIDxjbHVzdGVyLWlkLWZyb20tcmVnaXN0cmF0aW9uLXZhbHVlcz4gXAogIC0tbmNh" + - "LWlkIDxuY2EtaWQ+IFwKICAtLWlnbm9yZS1taXNzaW5nCmBgYAoKUmVhZCBgY2x1c3RlcklEYCBh" + - "bmQgYG5jYUlEYCBmcm9tCmBkZXBsb3kvc3RhY2tzL252Y2YtY29tcHV0ZS1wbGFuZS9yZWdpc3Ry" + - "YXRpb24vPGNsdXN0ZXItbmFtZT4tcmVnaXN0ZXItdmFsdWVzLnlhbWxgLgpTaG93IHRoZSBleGFj" + - "dCBjbHVzdGVyIElEIGFuZCBnZXQgY29uZmlybWF0aW9uIGJlZm9yZSBgY2x1c3RlciBkZWxldGVg" + - "LiBSZXBlYXQKY29tcHV0ZSBkZXN0cm95IGFuZCBkZXJlZ2lzdHJhdGlvbiBmb3IgZXZlcnkgY29t" + - "cHV0ZSBjbHVzdGVyLCB0aGVuIGRlc3Ryb3kgdGhlCmNvbnRyb2wgcGxhbmUuCgpgYGBiYXNoCktV" + - "QkVDT05GSUc9PGNvbnRyb2wtcGxhbmUta3ViZWNvbmZpZz4gXAptYWtlIC1DIGRlcGxveS9zdGFj" + - "a3Mvc2VsZi1tYW5hZ2VkIGRlc3Ryb3kgXAogIEhFTE1GSUxFX0VOVj08ZW52PiBcCiAgS1VCRUNP" + - "TkZJR19GSUxFPTxjb250cm9sLXBsYW5lLWt1YmVjb25maWc+CmBgYAoKQm90aCBgS1VCRUNPTkZJ" + - "R2AgYW5kIGBLVUJFQ09ORklHX0ZJTEVgIGFyZSByZXF1aXJlZCBvbiB0aGUgY29udHJvbC1wbGFu" + - "ZQpkZXN0cm95IGJlY2F1c2UgaXRzIG5hbWVzcGFjZSBjbGVhbnVwIHVzZXMgYW1iaWVudCBga3Vi" + - "ZWN0bGAuCgpGb3IgdGhlIENMSSBwcm9maWxlIGZsb3csIGtlZXAKYGRlcGxveS9zdGFja3MvbnZj" + - "Zi1jb21wdXRlLXBsYW5lL291dC88Y2x1c3Rlci1uYW1lPi1yZWdpc3Rlci12YWx1ZXMueWFtbGAK" + - "dW50aWwgdGVhcmRvd24gY29tcGxldGVzIGJlY2F1c2UgYGRvd25gIHJlYWRzIGl0cyBjbHVzdGVy" + - "IElELiBGaXJzdCBxdWVyeSB0aGUKbGl2ZSByZWdpc3RyYXRpb24gc2V0IHdpdGggdGhlIHNhbWUg" + - "Y29tcGxldGUgcGVyc2lzdGVudCBwcmVmaXg6CgpgYGBiYXNoCm52Y2YtY2xpIC0tY29uZmlnIDxj" + + "YW5kcmE6CiAgICAgICAgcmVzb3VyY2VzOgogICAgICAgICAgbGltaXRzOgogICAgICAgICAgICBj" + + "cHU6ICI4IgogICAgICAgICAgICBtZW1vcnk6IDgxOTJNaQogICAgICAgICAgcmVxdWVzdHM6CiAg" + + "ICAgICAgICAgIGNwdTogIjIiCiAgICAgICAgICAgIG1lbW9yeTogNDA5Nk1pCmBgYAoKIyMjIFN0" + + "ZXAgMzogVmVyaWZ5IGFuZCBhcHBseQoKYGBgYmFzaApIRUxNRklMRV9FTlY9PGVudj4gaGVsbWZp" + + "bGUgLS1zZWxlY3RvciBuYW1lPWNhc3NhbmRyYSB0ZW1wbGF0ZSA+IC90bXAvY2Fzcy1hZnRlci55" + + "YW1sCmRpZmYgL3RtcC9jYXNzLWJlZm9yZS55YW1sIC90bXAvY2Fzcy1hZnRlci55YW1sICAjIENv" + + "bmZpcm0gcmVzb3VyY2VzIGNoYW5nZWQKSEVMTUZJTEVfRU5WPTxlbnY+IGhlbG1maWxlIC0tc2Vs" + + "ZWN0b3IgbmFtZT1jYXNzYW5kcmEgc3luYwpgYGAKCk5vdGU6IGByZXNvdXJjZVByZXNldGAgKGEg" + + "Qml0bmFtaSBmZWF0dXJlKSBpcyBub3QgYXZhaWxhYmxlIGluIHRoZSBOVkNGIGNhc3NhbmRyYSB3" + + "cmFwcGVyIGNoYXJ0LiBVc2UgZXhwbGljaXQgYHJlc291cmNlc2AgaW5zdGVhZC4KCi0tLQoKIyMg" + + "RXhhbXBsZSAyOiBEZXBsb3kgZnJvbSBOR0MgUHJpdmF0ZSBSZWdpc3RyeSB3aXRoIFB1bGwgU2Vj" + + "cmV0cwoKRGVwbG95IHRoZSBOVkNGIHN0YWNrIHB1bGxpbmcgaW1hZ2VzIGRpcmVjdGx5IGZyb20g" + + "TkdDIChgbnZjci5pb2ApIGluc3RlYWQgb2YgYSBtaXJyb3JlZCByZWdpc3RyeSwgdXNpbmcgaW1h" + + "Z2UgcHVsbCBzZWNyZXRzLgoKIyMjIFN0ZXAgMTogQ29uZmlndXJlIGVudmlyb25tZW50IGZvciBO" + + "R0MKCmBgYHlhbWwKIyBlbnZpcm9ubWVudHMvPGVudj4ueWFtbApnbG9iYWw6CiAgaGVsbToKICAg" + + "IHNvdXJjZXM6CiAgICAgIHJlZ2lzdHJ5OiBudmNyLmlvCiAgICAgIHJlcG9zaXRvcnk6IG52aWRp" + + "YS9udmNmCiAgaW1hZ2U6CiAgICByZWdpc3RyeTogbnZjci5pbwogICAgcmVwb3NpdG9yeTogbnZp" + + "ZGlhL252Y2YKYGBgCgojIyMgU3RlcCAyOiBBdXRoZW50aWNhdGUgbG9jYWxseSAoZm9yIGhlbG1m" + + "aWxlIGNoYXJ0IHB1bGxzKQoKYGBgYmFzaApkb2NrZXIgbG9naW4gbnZjci5pbyAtdSAnJG9hdXRo" + + "dG9rZW4nIC1wICIkTkdDX0FQSV9LRVkiCmhlbG0gcmVnaXN0cnkgbG9naW4gbnZjci5pbyAtdSAn" + + "JG9hdXRodG9rZW4nIC1wICIkTkdDX0FQSV9LRVkiCmBgYAoKIyMjIFN0ZXAgMzogQ3JlYXRlIG5h" + + "bWVzcGFjZXMgYW5kIHB1bGwgc2VjcmV0cwoKYGBgYmFzaApleHBvcnQgTkdDX0FQSV9LRVk9Ijx5" + + "b3VyLW5nYy1hcGkta2V5PiIKCmZvciBucyBpbiBjYXNzYW5kcmEtc3lzdGVtIG5hdHMtc3lzdGVt" + + "IG52Y2YgYXBpLWtleXMgZXNzIHNpcyB2YXVsdC1zeXN0ZW0gY2VydC1tYW5hZ2VyOyBkbwogIGt1" + + "YmVjdGwgLS1jb250ZXh0IDxjb250cm9sLXBsYW5lLWNvbnRleHQ+IGNyZWF0ZSBuYW1lc3BhY2Ug" + + "IiRucyIgXAogICAgLS1kcnktcnVuPWNsaWVudCAtbyB5YW1sIHwga3ViZWN0bCAtLWNvbnRleHQg" + + "PGNvbnRyb2wtcGxhbmUtY29udGV4dD4gYXBwbHkgLWYgLQpkb25lCgpmb3IgbnMgaW4gY2Fzc2Fu" + + "ZHJhLXN5c3RlbSBuYXRzLXN5c3RlbSBudmNmIGFwaS1rZXlzIGVzcyBzaXMgdmF1bHQtc3lzdGVt" + + "IGNlcnQtbWFuYWdlcjsgZG8KICBrdWJlY3RsIC0tY29udGV4dCA8Y29udHJvbC1wbGFuZS1jb250" + + "ZXh0PiBjcmVhdGUgc2VjcmV0IGRvY2tlci1yZWdpc3RyeSBudmNyLWNyZWRzIFwKICAgIC0tZG9j" + + "a2VyLXNlcnZlcj1udmNyLmlvIFwKICAgIC0tZG9ja2VyLXVzZXJuYW1lPSckb2F1dGh0b2tlbicg" + + "XAogICAgLS1kb2NrZXItcGFzc3dvcmQ9IiROR0NfQVBJX0tFWSIgXAogICAgLS1uYW1lc3BhY2U9" + + "IiRucyIgXAogICAgLS1kcnktcnVuPWNsaWVudCAtbyB5YW1sIHwga3ViZWN0bCAtLWNvbnRleHQg" + + "PGNvbnRyb2wtcGxhbmUtY29udGV4dD4gYXBwbHkgLWYgLQpkb25lCmBgYAoKIyMjIFN0ZXAgNDog" + + "QWRkIGltYWdlUHVsbFNlY3JldHMgdG8gaGVsbWZpbGUgcmVsZWFzZXMKCkFkZCB0aGUgY2hhcnQt" + + "c3BlY2lmaWMgYGltYWdlUHVsbFNlY3JldHNgIGtleSB0byBlYWNoIHJlbGVhc2UuIEV4YW1wbGUg" + + "Zm9yIGNhc3NhbmRyYSBpbiBgaGVsbWZpbGUuZC8wMS1kZXBlbmRlbmNpZXMueWFtbC5nb3RtcGxg" + + "OgoKYGBgeWFtbAotIG5hbWU6IGNhc3NhbmRyYQogIHZlcnNpb246IDAuOC4wCiAgY29uZGl0aW9u" + + "OiBjYXNzYW5kcmEuZW5hYmxlZAogIG5hbWVzcGFjZTogY2Fzc2FuZHJhLXN5c3RlbQogIDw8OiAq" + + "ZGVwZW5kZW5jeQogIHZhbHVlczoKICAgIC0gLi4vZ2xvYmFsLnlhbWwuZ290bXBsCiAgICAtIC4u" + + "Lzxwcml2YXRlLXZhbHVlcz4ve3sgcmVxdWlyZWRFbnYgIkhFTE1GSUxFX0VOViIgfX0tc2VjcmV0" + + "cy55YW1sCiAgICAtIGNhc3NhbmRyYToKICAgICAgICBnbG9iYWw6CiAgICAgICAgICBpbWFnZVB1" + + "bGxTZWNyZXRzOgogICAgICAgICAgICAtIG52Y3ItY3JlZHMKYGBgCgpTZWUgW3JlZmVyZW5jZXMv" + + "cHVsbC1zZWNyZXRzLm1kXShyZWZlcmVuY2VzL3B1bGwtc2VjcmV0cy5tZCkgZm9yIHRoZSBrZXkg" + + "Zm9yIGV2ZXJ5IGNoYXJ0LgoKVGhlc2UgYXJlIGNvbnRyb2wtcGxhbmUgbmFtZXNwYWNlcy4gRm9y" + + "IGEgc2VwYXJhdGUgY29tcHV0ZSBjbHVzdGVyLCBjcmVhdGUgdGhlCnNlY3JldCBvbmx5IGluIGBu" + + "dmNhLW9wZXJhdG9yYDsgdGhlIGNoYXJ0IGFuZCBvcGVyYXRvciBtaXJyb3IgaXQgdG8KYG52Y2Et" + + "c3lzdGVtYC4gU2VlIFtTcGxpdCBDb21wdXRlLVBsYW5lIEluc3RhbGxhdGlvbl0ocmVmZXJlbmNl" + + "cy9jb21wdXRlLXBsYW5lLWluc3RhbGxhdGlvbi5tZCNwdWxsLXNlY3JldHMpLgoKIyMjIFN0ZXAg" + + "NTogRGVwbG95CgpgYGBiYXNoCkhFTE1GSUxFX0VOVj08ZW52PiBoZWxtZmlsZSAtLWt1YmUtY29u" + + "dGV4dCA8Y29udHJvbC1wbGFuZS1jb250ZXh0PiBzeW5jCmBgYAoKIyMjIFN0ZXAgNjogUGF0Y2gg" + + "U2VydmljZUFjY291bnRzIGZvciBjaGFydHMgd2l0aG91dCBuYXRpdmUgc3VwcG9ydAoKQWZ0ZXIg" + + "UGhhc2UgMSAoZGVwZW5kZW5jaWVzKSBjb21wbGV0ZXMsIE9wZW5CYW8gcG9kcyB3aWxsIGJlIGlu" + + "IGBJbWFnZVB1bGxCYWNrT2ZmYC4gUGF0Y2ggYW5kIHJlc3RhcnQ6CgpgYGBiYXNoCmZvciBucyBp" + + "biB2YXVsdC1zeXN0ZW0gbnZjZiBlc3M7IGRvCiAgZm9yIHNhIGluICQoa3ViZWN0bCAtLWNvbnRl" + + "eHQgPGNvbnRyb2wtcGxhbmUtY29udGV4dD4gZ2V0IHNhIC1uICIkbnMiIFwKICAgIC0tbm8taGVh" + + "ZGVycyAtbyBjdXN0b20tY29sdW1ucz0iOm1ldGFkYXRhLm5hbWUiKTsgZG8KICAgIGt1YmVjdGwg" + + "LS1jb250ZXh0IDxjb250cm9sLXBsYW5lLWNvbnRleHQ+IHBhdGNoIHNlcnZpY2VhY2NvdW50IC1u" + + "ICIkbnMiICIkc2EiIFwKICAgICAgLXAgJ3siaW1hZ2VQdWxsU2VjcmV0cyI6IFt7Im5hbWUiOiAi" + + "bnZjci1jcmVkcyJ9XX0nCiAgZG9uZQpkb25lCmt1YmVjdGwgLS1jb250ZXh0IDxjb250cm9sLXBs" + + "YW5lLWNvbnRleHQ+IGRlbGV0ZSBwb2RzIC1uIHZhdWx0LXN5c3RlbSAtLWFsbApgYGAKClZlcmlm" + + "eToKCmBgYGJhc2gKa3ViZWN0bCAtLWNvbnRleHQgPGNvbnRyb2wtcGxhbmUtY29udGV4dD4gZ2V0" + + "IGV2ZW50cyAtbiB2YXVsdC1zeXN0ZW0gXAogIC0tc29ydC1ieT0nLmxhc3RUaW1lc3RhbXAnIHwg" + + "Z3JlcCAtaSBwdWxsCiMgU2hvdWxkIHNob3cgIlN1Y2Nlc3NmdWxseSBwdWxsZWQgaW1hZ2UiIGZy" + + "b20gbnZjci5pbwpgYGAKCi0tLQoKIyMgRXhhbXBsZSAzOiBGdWxsIFRlYXJkb3duIGFuZCBSZWlu" + + "c3RhbGwKCldoZW4gYSBkZXBsb3ltZW50IGlzIGJyb2tlbiBhbmQgeW91IG5lZWQgYSBjbGVhbiBz" + + "bGF0ZS4KCiMjIyBTdGVwIDE6IERlc3Ryb3kgdGhlIGNvbXB1dGUtcGxhbmUgc3RhY2sKCmBgYGJh" + + "c2gKbWFrZSAtQyBkZXBsb3kvc3RhY2tzL252Y2YtY29tcHV0ZS1wbGFuZSBkZXN0cm95IFwKICBD" + + "TFVTVEVSX05BTUU9PGNsdXN0ZXItbmFtZT4gXAogIEhFTE1GSUxFX0VOVj08ZW52PiBcCiAgS1VC" + + "RUNPTkZJR19GSUxFPTxjb21wdXRlLXBsYW5lLWt1YmVjb25maWc+CmBgYAoKSWYgY29tcHV0ZSBj" + + "bGVhbnVwIGlzIHN0dWNrIG9uIGZpbmFsaXplcnMsIHVzZSB0aGUgY29tcHV0ZS1jb250ZXh0IHBy" + + "b2NlZHVyZSBpbgpbZGVidWdnaW5nLm1kXShyZWZlcmVuY2VzL2RlYnVnZ2luZy5tZCNmYWlsdXJl" + + "LW52Y2EtY2xlYW51cC1zdHVjay1maW5hbGl6ZXJzKS4KCiMjIyBTdGVwIDI6IERlcmVnaXN0ZXIg" + + "dGhlIGNvbXB1dGUgY2x1c3RlcgoKUmVhZCBgY2x1c3RlcklEYCBhbmQgYG5jYUlEYCBmcm9tCmBk" + + "ZXBsb3kvc3RhY2tzL252Y2YtY29tcHV0ZS1wbGFuZS9yZWdpc3RyYXRpb24vPGNsdXN0ZXItbmFt" + + "ZT4tcmVnaXN0ZXItdmFsdWVzLnlhbWxgLgpTaG93IHRoZSBJRCBhbmQgZ2V0IGNvbmZpcm1hdGlv" + + "biBiZWZvcmUgZGVsZXRpbmcgdGhlIElDTVMgcm93OgoKYGBgYmFzaAo8bnZjZi1jbGk+IC0tY29u" + + "ZmlnIDxjb25maWc+IGNsdXN0ZXIgZGVsZXRlIFwKICAtLWNsdXN0ZXItaWQgPGNsdXN0ZXItaWQt" + + "ZnJvbS1yZWdpc3RyYXRpb24tdmFsdWVzPiBcCiAgLS1uY2EtaWQgPG5jYS1pZD4gXAogIC0taWdu" + + "b3JlLW1pc3NpbmcKYGBgCgpSZXBlYXQgc3RlcHMgMSBhbmQgMiBmb3IgZXZlcnkgY29tcHV0ZSBj" + + "bHVzdGVyLgoKIyMjIFN0ZXAgMzogRGVzdHJveSB0aGUgY29udHJvbC1wbGFuZSBzdGFjawoKUHJl" + + "c2VydmUgdGhlIGBjZXJ0LW1hbmFnZXJgIG5hbWVzcGFjZSBieSBkZWZhdWx0LiBOYW1lc3BhY2Ug" + + "cHJlc2VydmF0aW9uIGRvZXMKbm90IHByZXNlcnZlIHRoZSBIZWxtIHJlbGVhc2UuIEJlZm9yZSBy" + + "dW5uaW5nIGRlc3Ryb3ksIGlkZW50aWZ5IHdoZXRoZXIKY2VydC1tYW5hZ2VyIGlzIGV4dGVybmFs" + + "LiBGb3IgYW4gZXh0ZXJuYWwgaW5zdGFsbGF0aW9uLCByZXF1aXJlIGVmZmVjdGl2ZQpgY2VydE1h" + + "bmFnZXIuZW5hYmxlZDogZmFsc2VgIGFuZCBhYm9ydCBpZiBpdCBpcyB0cnVlLiBGb3IgYW4gaW50" + + "ZW5kZWQKc3RhY2stbWFuYWdlZCByZWxlYXNlIHdpdGggZWZmZWN0aXZlIGBjZXJ0TWFuYWdlci5l" + + "bmFibGVkOiB0cnVlYCwgdmVyaWZ5Cm1hdGNoaW5nIHN0YWNrIEhlbG0gcmVsZWFzZSBtZXRhZGF0" + + "YSBhbmQgYWJvcnQgb24gbWlzc2luZyBvciBtaXNtYXRjaGVkCmV2aWRlbmNlLiBPbmx5IHBsYW4g" + + "bmFtZXNwYWNlIHJlbW92YWwgYWZ0ZXIgdmVyaWZ5aW5nIG5hbWVzcGFjZSBwcm92ZW5hbmNlIGFu" + + "ZApnZXR0aW5nIGV4cGxpY2l0IGNvbmZpcm1hdGlvbjsgb3RoZXJ3aXNlIGRvIG5vdCBkZWxldGUg" + + "aXQuCgpgYGBiYXNoCktVQkVDT05GSUc9PGNvbnRyb2wtcGxhbmUta3ViZWNvbmZpZz4gXAptYWtl" + + "IC1DIGRlcGxveS9zdGFja3Mvc2VsZi1tYW5hZ2VkIGRlc3Ryb3kgXAogIEhFTE1GSUxFX0VOVj08" + + "ZW52PiBcCiAgS1VCRUNPTkZJR19GSUxFPTxjb250cm9sLXBsYW5lLWt1YmVjb25maWc+CmBgYAoK" + + "UGFzcyBib3RoIGt1YmVjb25maWcgZm9ybXMgYmVjYXVzZSBjb250cm9sLXBsYW5lIG5hbWVzcGFj" + + "ZSBjbGVhbnVwIHVzZXMKYW1iaWVudCBga3ViZWN0bGAuCgojIyMgU3RlcCA0OiBWZXJpZnkgY2xl" + + "YW4KCmBgYGJhc2gKa3ViZWN0bCAtLWNvbnRleHQgPGNvbXB1dGUtcGxhbmUtY29udGV4dD4gZ2V0" + + "IG5zIHwgXAogIGdyZXAgLUUgJyhudmNhfG52Y2YtYmFja2VuZHxncm92ZXxkeW5hbW8pJwprdWJl" + + "Y3RsIC0tY29udGV4dCA8Y29udHJvbC1wbGFuZS1jb250ZXh0PiBnZXQgbnMgfCBcCiAgZ3JlcCAt" + + "RSAnKGNhc3NhbmRyYXxuYXRzfHZhdWx0fG52Y2Z8YXBpLWtleXN8ZXNzfHNpcyknCiMgQm90aCBj" + + "b21tYW5kcyBzaG91bGQgcmV0dXJuIGVtcHR5LgpgYGAKCiMjIyBTdGVwIDU6IFJlaW5zdGFsbCBp" + + "biBzcGxpdCBvcmRlcgoKRm9sbG93IFtDbGVhbiBJbnN0YWxsYXRpb25dKFNLSUxMLm1kI2NsZWFu" + + "LWluc3RhbGxhdGlvbiksIHRoZW4gcmV0dXJuIHRvIHRoZQpzYW1lIGhhbmRvZmYgaW4gW1NwbGl0" + + "IENvbXB1dGUtUGxhbmUgSW5zdGFsbGF0aW9uXShyZWZlcmVuY2VzL2NvbXB1dGUtcGxhbmUtaW5z" + + "dGFsbGF0aW9uLm1kKS4KCi0tLQoKIyMgRXhhbXBsZSA0OiBSZWNvdmVyIGZyb20gYSBHYXRld2F5" + + "IEVuZHBvaW50IENoYW5nZQoKVGhlIHNlcGFyYXRlbHkgcHJvdmlzaW9uZWQgR2F0ZXdheSBvciBp" + + "dHMgbG9hZCBiYWxhbmNlciB3YXMgcmVjcmVhdGVkIGFuZCBnb3QgYSBuZXcgZW5kcG9pbnQuCgoj" + + "IyMgU3RlcCAxOiBHZXQgdGhlIG5ldyBlbmRwb2ludAoKYGBgYmFzaApHQVRFV0FZX0FERFI9JChr" + + "dWJlY3RsIC0tY29udGV4dCA8Y29udHJvbC1wbGFuZS1jb250ZXh0PiBnZXQgZ2F0ZXdheSBcCiAg" + + "bnZjZi1nYXRld2F5IC1uIGVudm95LWdhdGV3YXkgXAogIC1vIGpzb25wYXRoPSd7LnN0YXR1cy5h" + + "ZGRyZXNzZXNbMF0udmFsdWV9JykKdGVzdCAtbiAiJEdBVEVXQVlfQUREUiIKYGBgCgojIyMgU3Rl" + + "cCAyOiBVcGRhdGUgRE5TIGFuZCBkaXJlY3QgYWRkcmVzcyBmaWVsZHMKCktlZXAgYGdsb2JhbC5k" + + "b21haW5gLCByb3V0ZSBob3N0bmFtZXMsIGFuZCBDTEkgSG9zdCBmaWVsZHMgdW5jaGFuZ2VkLiBQ" + + "b2ludCB0aGUKRE5TIHJlY29yZHMgZm9yIHJlbmRlcmVkIHJvdXRlIGhvc3RuYW1lcywgc3VjaCBh" + + "cyBgYXBpLjxkb21haW4+YCBhbmQKYCouaW52b2NhdGlvbi48ZG9tYWluPmAsIHRvIGBHQVRFV0FZ" + + "X0FERFJgLiBGb3IgYSB0ZW1wb3JhcnkgZW52aXJvbm1lbnQgd2l0aG91dApETlMsIGtlZXAgaXRz" + + "IHJlc2VydmVkIHJvdXRlIHN1ZmZpeCBhbmQgY29ubmVjdCB0byBgR0FURVdBWV9BRERSYCB3aXRo" + + "IHRoZQptYXRjaGluZyBgSG9zdGAgaGVhZGVyLgoKRm9yIGEgc3BsaXQgZGVwbG95bWVudCBjb25m" + + "aWd1cmVkIHdpdGggZGlyZWN0IEdhdGV3YXkgYWRkcmVzc2VzLCByZXBsYWNlIG9ubHkKdGhlIGFk" + + "ZHJlc3MtYmVhcmluZyB2YWx1ZXM6IGNvbnRyb2wtcGxhbmUgYG52Y2ZOYXRzU2VydmljZVVSTGAs" + + "IGNvbXB1dGUtcGxhbmUKSUNNUywgUmVWYWwsIGFuZCBOQVRTIFVSTHMsIGFuZCBDTEkgVVJMIGZp" + + "ZWxkcy4gS2VlcCB0aGVpciBkb21haW4gYW5kIEhvc3QKb3ZlcnJpZGVzIHVuY2hhbmdlZC4gUmVm" + + "cmVzaCByZWdpc3RyYXRpb24gYW5kIGluc3RhbGxhdGlvbiB0aHJvdWdoIHRoZSBzYW1lCmhhbmRv" + + "ZmYgdXNlZCBvcmlnaW5hbGx5LiBTZWUKW1NwbGl0IENvbXB1dGUtUGxhbmUgSW5zdGFsbGF0aW9u" + + "XShyZWZlcmVuY2VzL2NvbXB1dGUtcGxhbmUtaW5zdGFsbGF0aW9uLm1kKQpmb3IgdGhlIGZpZWxk" + + "cyBhbmQgY29tcGxldGUgY29tbWFuZHMuCgojIyMgU3RlcCAzOiBWZXJpZnkgYm90aCBjb250ZXh0" + + "cwoKYGBgYmFzaApkaWcgK3Nob3J0ICJhcGkuPGRvbWFpbj4iCmN1cmwgLUggIkhvc3Q6IGFwaS48" + + "ZG9tYWluPiIgImh0dHA6Ly8kR0FURVdBWV9BRERSL2hlYWx0aCIKa3ViZWN0bCAtLWNvbnRleHQg" + + "PGNvbnRyb2wtcGxhbmUtY29udGV4dD4gZ2V0IGdhdGV3YXkgbnZjZi1nYXRld2F5IFwKICAtbiBl" + + "bnZveS1nYXRld2F5IC1vIHdpZGUKa3ViZWN0bCAtLWNvbnRleHQgPGNvbnRyb2wtcGxhbmUtY29u" + + "dGV4dD4gZ2V0IGh0dHByb3V0ZXMgLUEKa3ViZWN0bCAtLWNvbnRleHQgPGNvbnRyb2wtcGxhbmUt" + + "Y29udGV4dD4gZ2V0IHRjcHJvdXRlcyAtQQprdWJlY3RsIC0tY29udGV4dCA8Y29tcHV0ZS1wbGFu" + + "ZS1jb250ZXh0PiByb2xsb3V0IHN0YXR1cyBcCiAgZGVwbG95bWVudC9udmNhLW9wZXJhdG9yIC1u" + + "IG52Y2Etb3BlcmF0b3IgLS10aW1lb3V0PTEwbQprdWJlY3RsIC0tY29udGV4dCA8Y29tcHV0ZS1w" + + "bGFuZS1jb250ZXh0PiB3YWl0IFwKICBudmNmYmFja2VuZC88Y29tcHV0ZS1wbGFuZS1jbHVzdGVy" + + "LW5hbWU+IC1uIG52Y2Etb3BlcmF0b3IgXAogIC0tZm9yPWpzb25wYXRoPSd7LnN0YXR1cy5hZ2Vu" + + "dFN0YXR1c30nPWhlYWx0aHkgLS10aW1lb3V0PTEwbQpgYGAKCi0tLQoKIyMgRXhhbXBsZSA1OiBE" + + "ZXBsb3kgT25seSBEZXBlbmRlbmNpZXMKClVzZWZ1bCBmb3IgdGVzdGluZyBvciB3aGVuIGl0ZXJh" + + "dGluZyBvbiBzZXJ2aWNlIGNvbmZpZ3VyYXRpb24uCgpgYGBiYXNoCiMgRGVwbG95IGp1c3QgTkFU" + + "UywgQ2Fzc2FuZHJhLCBPcGVuQmFvCkhFTE1GSUxFX0VOVj08ZW52PiBoZWxtZmlsZSAtLXNlbGVj" + + "dG9yIHJlbGVhc2UtZ3JvdXA9ZGVwZW5kZW5jaWVzIHN5bmMKCiMgQ2hlY2sgc3RhdHVzCmt1YmVj" + + "dGwgZ2V0IHBvZHMgLW4gbmF0cy1zeXN0ZW0Ka3ViZWN0bCBnZXQgcG9kcyAtbiBjYXNzYW5kcmEt" + + "c3lzdGVtCmt1YmVjdGwgZ2V0IHBvZHMgLW4gdmF1bHQtc3lzdGVtCgojIERlcGxveSBqdXN0IG9u" + + "ZSBzcGVjaWZpYyByZWxlYXNlCkhFTE1GSUxFX0VOVj08ZW52PiBoZWxtZmlsZSAtLXNlbGVjdG9y" + + "IG5hbWU9Y2Fzc2FuZHJhIHN5bmMKYGBgCgojIyMgU2VsZWN0b3IgcmVmZXJlbmNlCgp8IFNlbGVj" + + "dG9yIHwgUmVsZWFzZXMgfAp8LS0tLS0tLS0tLXwtLS0tLS0tLS0tfAp8IGByZWxlYXNlLWdyb3Vw" + + "PWRlcGVuZGVuY2llc2AgfCBuYXRzLCBjYXNzYW5kcmEsIG9wZW5iYW8tc2VydmVyIHwKfCBgcmVs" + + "ZWFzZS1ncm91cD1zZXJ2aWNlc2AgfCBhcGkta2V5cywgc2lzLCBhcGksIGludm9jYXRpb24tc2Vy" + + "dmljZSwgZ3JwYy1wcm94eSwgZXNzLWFwaSwgbm90YXJ5LXNlcnZpY2UsIHJldmFsLCBvcHRpb25h" + + "bCBsbG0tcmVxdWVzdC1yb3V0ZXIgYW5kIGxsbS1hcGktZ2F0ZXdheSB3aGVuIGBsbG0uZW5hYmxl" + + "ZD10cnVlYCwgb3B0aW9uYWwgdmFuaXR5LWdhdGV3YXkgb25seSBpbiBzdGFjayBwYWNrYWdlcyB0" + + "aGF0IGluY2x1ZGUgdGhlIGFkZG9uIGFuZCBoYXZlIGBhZGRvbnMudmFuaXR5R2F0ZXdheS5lbmFi" + + "bGVkPXRydWVgLCBvcHRpb25hbCBudmNmLXVpIG9ubHkgaW4gc3RhY2sgcGFja2FnZXMgdGhhdCBp" + + "bmNsdWRlIHRoZSBhZGRvbiBhbmQgaGF2ZSBgYWRkb25zLm52Y2ZVaS5lbmFibGVkPXRydWVgIHwK" + + "fCBgbmFtZT1sbG0tcmVxdWVzdC1yb3V0ZXJgIHwgRGVwbG95IGp1c3QgdGhlIExMTSByZXF1ZXN0" + + "IHJvdXRlciB3aGVuIGBsbG0uZW5hYmxlZD10cnVlYCB8CnwgYG5hbWU9bGxtLWFwaS1nYXRld2F5" + + "YCB8IERlcGxveSBqdXN0IHRoZSBMTE0gQVBJIGdhdGV3YXkgd2hlbiBgbGxtLmVuYWJsZWQ9dHJ1" + + "ZWAgfAp8IGBuYW1lPXZhbml0eS1nYXRld2F5YCB8IERlcGxveSBqdXN0IFZhbml0eSBHYXRld2F5" + + "IG9ubHkgd2hlbiB0aGUgc3RhY2sgcGFja2FnZSBpbmNsdWRlcyB0aGF0IHJlbGVhc2UgYW5kIGBh" + + "ZGRvbnMudmFuaXR5R2F0ZXdheS5lbmFibGVkPXRydWVgIHwKfCBgbmFtZT1udmNmLXVpYCB8IERl" + + "cGxveSBOVkNGIFVJIG9ubHkgd2hlbiB0aGUgc3RhY2sgcGFja2FnZSBpbmNsdWRlcyB0aGF0IHJl" + + "bGVhc2UgYW5kIGBhZGRvbnMubnZjZlVpLmVuYWJsZWQ9dHJ1ZWAgfAp8IGByZWxlYXNlLWdyb3Vw" + + "PWluZ3Jlc3NgIHwgaW5ncmVzcyAoZ2F0ZXdheSByb3V0ZXMpIHwKfCBgbmFtZT08cmVsZWFzZT5g" + + "IHwgQW55IGluZGl2aWR1YWwgcmVsZWFzZSBieSBuYW1lIHwKCk5vdGU6IGBhZG1pbi1pc3N1ZXIt" + + "cHJveHlgIGRvZXMgbm90IGhhdmUgYSByZWxlYXNlLWdyb3VwIGxhYmVsLiBUYXJnZXQgaXQgd2l0" + + "aCBgLS1zZWxlY3RvciBuYW1lPWFkbWluLWlzc3Vlci1wcm94eWAuClBLBwgCUk5AfygAAH8oAABQ" + + "SwMEFAAIAAAAAAAhAAAAAAAAAAAAAAAAAEwACQBkYXRhL252Y2Ytc2VsZi1tYW5hZ2VkLWluc3Rh" + + "bGxhdGlvbi9yZWZlcmVuY2VzL2NvbXB1dGUtcGxhbmUtaW5zdGFsbGF0aW9uLm1kVVQFAAEAps4S" + + "IyBTcGxpdCBDb21wdXRlLVBsYW5lIEluc3RhbGxhdGlvbgoKVGhlIGNvbnRyb2wgcGxhbmUgYW5k" + + "IGNvbXB1dGUgcGxhbmUgYXJlIHNlcGFyYXRlIHN0YWNrcy4gSW5zdGFsbCB0aGUgY29udHJvbApw" + + "bGFuZSBmaXJzdCwgdGhlbiByZWdpc3RlciBhbmQgaW5zdGFsbCBlYWNoIGNvbXB1dGUgY2x1c3Rl" + + "ci4gQ2hvb3NlIG9uZSBoYW5kb2ZmCmJlbG93IGFuZCB1c2UgaXQgZm9yIHRoZSBmdWxsIGxpZmVj" + + "eWNsZS4gRG8gbm90IGNvbWJpbmUgYSBDTEktZ2VuZXJhdGVkIHByb2ZpbGUKd2l0aCB0aGUgSGVs" + + "bWZpbGUgdmFsdWVzIGZsb3cuCgojIyBDaG9vc2UgYSBIYW5kb2ZmCgp8IEZsb3cgfCBTb3VyY2Ug" + + "b2YgY29udHJvbC1wbGFuZSBlbmRwb2ludHMgfCBSZWdpc3RyYXRpb24gYXJ0aWZhY3QgfAp8LS0t" + + "LS0tfC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tfC0tLS0tLS0tLS0tLS0tLS0t" + + "LS0tLS0tfAp8IEhlbG1maWxlIHZhbHVlcyB8IFNlcGFyYXRlIGNvbnRyb2wtcGxhbmUgYW5kIGNv" + + "bXB1dGUtcGxhbmUgZW52aXJvbm1lbnQgZmlsZXMgfCBgZGVwbG95L3N0YWNrcy9udmNmLWNvbXB1" + + "dGUtcGxhbmUvcmVnaXN0cmF0aW9uLzxjbHVzdGVyPi1yZWdpc3Rlci12YWx1ZXMueWFtbGAgfAp8" + + "IENMSSBwcm9maWxlIHwgQ0xJLWdlbmVyYXRlZCBgZGVwbG95L3N0YWNrcy9zZWxmLW1hbmFnZWQv" + + "b3V0L2NvbnRyb2wtcGxhbmUtcHJvZmlsZS55YW1sYCB8IENMSS1nZW5lcmF0ZWQgYGRlcGxveS9z" + + "dGFja3MvbnZjZi1jb21wdXRlLXBsYW5lL291dC88Y2x1c3Rlcj4tcmVnaXN0ZXItdmFsdWVzLnlh" + + "bWxgIHwKClRoZSBDTEkgcHJvZmlsZSBpcyBtYW5kYXRvcnkgZm9yIHRoZSBDTEkgZmxvdyBhbmQg" + + "bXVzdCBub3QgYmUgaGFuZC1hdXRob3JlZC4KVGhlIEhlbG1maWxlIGZsb3cgZG9lcyBub3QgY29u" + + "c3VtZSBhIGNvbnRyb2wtcGxhbmUgcHJvZmlsZS4KCkNvbW1hbmRzIGJlbG93IHVzZSBtb25vcmVw" + + "byBwYXRocyBmcm9tIHRoZSByZXBvc2l0b3J5IHJvb3QuIE9wZXJhdG9ycyB1c2luZwpleHRyYWN0" + + "ZWQgcGFja2FnZXMgbmVlZCBtYXRjaGluZy12ZXJzaW9uIGBudmNmLXNlbGYtbWFuYWdlZC1zdGFj" + + "a2AgYW5kCmBudmNmLWNvbXB1dGUtcGxhbmUtc3RhY2tgIGJ1bmRsZXMuIFN1YnN0aXR1dGUgdGhv" + + "c2UgYnVuZGxlIHJvb3RzIGZvcgpgZGVwbG95L3N0YWNrcy9zZWxmLW1hbmFnZWRgIGFuZCBgZGVw" + + "bG95L3N0YWNrcy9udmNmLWNvbXB1dGUtcGxhbmVgLgoKIyMgSGVsbWZpbGUgVmFsdWVzIEZsb3cK" + + "CkNyZWF0ZSBib3RoIGVudmlyb25tZW50IGZpbGVzIGJlZm9yZSBpbnN0YWxsYXRpb246CgotIGBk" + + "ZXBsb3kvc3RhY2tzL3NlbGYtbWFuYWdlZC9lbnZpcm9ubWVudHMvPGVudj4ueWFtbGAgZm9yIGNv" + + "bnRyb2wtcGxhbmUKICByZWdpc3RyeSwgZG9tYWluLCBHYXRld2F5LCByb3V0ZXMsIGFuZCBzZXJ2" + + "aWNlIHNldHRpbmdzLgotIGBkZXBsb3kvc3RhY2tzL252Y2YtY29tcHV0ZS1wbGFuZS9lbnZpcm9u" + + "bWVudHMvPGVudj4ueWFtbGAgZm9yIGNvbXB1dGUtcGxhbmUKICByZWdpc3RyeSwgcHVsbCBzZWNy" + + "ZXRzLCBhbmQgY29tcHV0ZS1yZWFjaGFibGUgSUNNUywgUmVWYWwsIGFuZCBOQVRTIHZhbHVlcy4K" + + "CkZvciBFS1MsIHVzZSB0aGUgY2Fub25pY2FsCltDU1AgRW5kLXRvLUVuZCBFeGFtcGxlXShodHRw" + + "czovL2RvY3MubnZpZGlhLmNvbS9udmNmL3YwLjYuMC1yYy9jc3AtZW5kLXRvLWVuZC1leGFtcGxl" + + "KS4KVGhlIGNvbnRyb2wtcGxhbmUgZW52aXJvbm1lbnQga2VlcHMgdGhlIEVudm95IEdhdGV3YXkg" + + "Y29udHJvbGxlciBpbgpgZW52b3ktZ2F0ZXdheS1zeXN0ZW1gLCBhdHRhY2hlcyByb3V0ZXMgdG8g" + + "YEdhdGV3YXkvbnZjZi1nYXRld2F5YCBpbgpgZW52b3ktZ2F0ZXdheWAsIGFuZCBlbmFibGVzIHRo" + + "ZSBOQVRTIHJvdXRlLiBUaGUgY29tcHV0ZS1wbGFuZSBlbnZpcm9ubWVudCB1c2VzCnRoZSBleHRl" + + "cm5hbCBhZGRyZXNzIHBsdXMgdGhlIHNlcnZpY2UgaG9zdCBvdmVycmlkZXMuIEhlcmUsCmA8Z2F0" + + "ZXdheS1hZGRyZXNzPmAgaXMgdGhlIE5MQiBhZGRyZXNzIGFuZCBgPGdhdGV3YXktZG9tYWluPmAg" + + "aXMgdGhlIEROUyBiYXNlCndob3NlIHNlcnZpY2Ugc3ViZG9tYWlucyByZXNvbHZlIHRvIHRoYXQg" + + "TkxCOgoKYGBgeWFtbAojIGRlcGxveS9zdGFja3Mvc2VsZi1tYW5hZ2VkL2Vudmlyb25tZW50cy88" + + "ZW52Pi55YW1sCmdsb2JhbDoKICBkb21haW46ICI8Z2F0ZXdheS1kb21haW4+IgogIHdvcmtlckVu" + + "ZHBvaW50czoKICAgIG52Y2ZTZXJ2aWNlVVJMOiAiaHR0cDovL2FwaS48Z2F0ZXdheS1kb21haW4+" + + "IgogICAgbnZjZkdycGNTZXJ2aWNlVVJMOiAiaHR0cDovL3dvcmtlci1hcGkuPGdhdGV3YXktZG9t" + + "YWluPiIKICAgIG52Y2ZOYXRzU2VydmljZVVSTDogIm5hdHM6Ly88Z2F0ZXdheS1hZGRyZXNzPjo0" + + "MjIyIgogICAgbnZjdFNlcnZpY2VVUkw6ICJodHRwOi8vdGFza3MuPGdhdGV3YXktZG9tYWluPiIK" + + "ICAgIG52Y3RHcnBjU2VydmljZVVSTDogImh0dHA6Ly93b3JrZXItdGFza3MuPGdhdGV3YXktZG9t" + + "YWluPiIKICAgIGludm9jYXRpb25TZXJ2aWNlVVJMOiAiaHR0cDovL2ludm9jYXRpb24uPGdhdGV3" + + "YXktZG9tYWluPiIKCmdycGNwcm94eToKICBudmNmR3JwY1NlcnZpY2VVUkw6ICJodHRwOi8vYXBp" + + "Lm52Y2Yuc3ZjLmNsdXN0ZXIubG9jYWw6OTA5MCIKCmluZ3Jlc3M6CiAgZ2F0ZXdheUFwaToKICAg" + + "IGNvbnRyb2xsZXJOYW1lc3BhY2U6IGVudm95LWdhdGV3YXktc3lzdGVtCiAgICBnYXRld2F5czoK" + + "ICAgICAgc2hhcmVkOiB7bmFtZTogbnZjZi1nYXRld2F5LCBuYW1lc3BhY2U6IGVudm95LWdhdGV3" + + "YXl9CiAgICAgIGdycGM6IHtuYW1lOiBudmNmLWdhdGV3YXksIG5hbWVzcGFjZTogZW52b3ktZ2F0" + + "ZXdheX0KICAgICAgbmF0czoKICAgICAgICBuYW1lOiBudmNmLWdhdGV3YXkKICAgICAgICBuYW1l" + + "c3BhY2U6IGVudm95LWdhdGV3YXkKICAgICAgICBsaXN0ZW5lck5hbWU6IG5hdHMKICAgIHJvdXRl" + + "czoKICAgICAgbnZjZkFwaToKICAgICAgICBncnBjOgogICAgICAgICAgZW5hYmxlZDogdHJ1ZQog" + + "ICAgICAgICAgaG9zdG5hbWVzOiBbIndvcmtlci1hcGkuPGdhdGV3YXktZG9tYWluPiJdCiAgICAg" + + "IG52Y3RBcGk6CiAgICAgICAgZ3JwYzoKICAgICAgICAgIGVuYWJsZWQ6IHRydWUKICAgICAgICAg" + + "IGhvc3RuYW1lczogWyJ3b3JrZXItdGFza3MuPGdhdGV3YXktZG9tYWluPiJdCiAgICAgIG5hdHM6" + + "CiAgICAgICAgZW5hYmxlZDogdHJ1ZQoKb3BlbmJhbzoKICBtaWdyYXRpb25zOgogICAgaXNzdWVy" + + "RGlzY292ZXJ5OgogICAgICBlbmFibGVkOiB0cnVlCmBgYAoKYGBgeWFtbAojIGRlcGxveS9zdGFj" + + "a3MvbnZjZi1jb21wdXRlLXBsYW5lL2Vudmlyb25tZW50cy88ZW52Pi55YW1sCmdsb2JhbDoKICBu" + + "dmNhT3BlcmF0b3I6CiAgICBzZWxmTWFuYWdlZDoKICAgICAgaWNtc1NlcnZpY2VVUkw6ICJodHRw" + + "Oi8vPGdhdGV3YXktYWRkcmVzcz4iCiAgICAgIGljbXNTZXJ2aWNlSG9zdEhlYWRlck92ZXJyaWRl" + + "OiAic2lzLjxnYXRld2F5LWRvbWFpbj4iCiAgICAgIHJldmFsU2VydmljZVVSTDogImh0dHA6Ly88" + + "Z2F0ZXdheS1hZGRyZXNzPiIKICAgICAgcmV2YWxTZXJ2aWNlSG9zdEhlYWRlck92ZXJyaWRlOiAi" + + "cmV2YWwuPGdhdGV3YXktZG9tYWluPiIKICAgICAgbmF0c1VSTDogIm5hdHM6Ly88Z2F0ZXdheS1h" + + "ZGRyZXNzPjo0MjIyIgogICAgICBuYXRzSG9zdE92ZXJyaWRlOiAibmF0cy48Z2F0ZXdheS1kb21h" + + "aW4+IgpgYGAKClByZXZpZXcgYW5kIGluc3RhbGwgdGhlIGNvbnRyb2wgcGxhbmUgYWdhaW5zdCBp" + + "dHMgY29udGV4dDoKCmBgYGJhc2gKbWFrZSAtQyBkZXBsb3kvc3RhY2tzL3NlbGYtbWFuYWdlZCB0" + + "ZW1wbGF0ZSBcCiAgSEVMTUZJTEVfRU5WPTxlbnY+IFwKICBLVUJFQ09ORklHX0ZJTEU9PGNvbnRy" + + "b2wtcGxhbmUta3ViZWNvbmZpZz4KCm1ha2UgLUMgZGVwbG95L3N0YWNrcy9zZWxmLW1hbmFnZWQg" + + "aW5zdGFsbCBcCiAgSEVMTUZJTEVfRU5WPTxlbnY+IFwKICBLVUJFQ09ORklHX0ZJTEU9PGNvbnRy" + + "b2wtcGxhbmUta3ViZWNvbmZpZz4KYGBgCgpCZWZvcmUgcmVnaXN0ZXJpbmcgdGhyb3VnaCBhIGJh" + + "cmUgR2F0ZXdheSBhZGRyZXNzLCBjcmVhdGUgb3IgdXBkYXRlIHRoZSBDTEkKY29uZmlnIHBhc3Nl" + + "ZCBhcyBgTlZDRl9DTElfQ09ORklHYDoKCmBgYHlhbWwKYmFzZV9odHRwX3VybDogImh0dHA6Ly88" + + "Z2F0ZXdheS1hZGRyZXNzPiIKaW52b2tlX3VybDogImh0dHA6Ly88Z2F0ZXdheS1hZGRyZXNzPiIK" + + "YmFzZV9ncnBjX3VybDogIjxnYXRld2F5LWFkZHJlc3M+OjEwMDgxIgphcGlfa2V5c19zZXJ2aWNl" + + "X3VybDogImh0dHA6Ly88Z2F0ZXdheS1hZGRyZXNzPiIKaWNtc191cmw6ICJodHRwOi8vPGdhdGV3" + + "YXktYWRkcmVzcz4iCmFwaV9ob3N0OiAiYXBpLjxnYXRld2F5LWRvbWFpbj4iCmFwaV9rZXlzX2hv" + + "c3Q6ICJhcGkta2V5cy48Z2F0ZXdheS1kb21haW4+IgppbnZva2VfaG9zdDogImludm9jYXRpb24u" + + "PGdhdGV3YXktZG9tYWluPiIKaWNtc19ob3N0OiAic2lzLjxnYXRld2F5LWRvbWFpbj4iCmBgYAoK" + + "SG9zdCBmaWVsZHMgY29udGFpbiBob3N0bmFtZXMgb25seSwgd2l0aG91dCBhIFVSTCBzY2hlbWUu" + + "IGBJQ01TX1VSTGAgbWFwcyBvbmx5CnRvIHRoZSByZWdpc3RyYXRpb24gY29tbWFuZCdzIGAtLWlj" + + "bXMtdXJsYDsgYGljbXNfaG9zdGAgaW4gdGhlIGNvbmZpZyBzdXBwbGllcwp0aGUgR2F0ZXdheSBI" + + "b3N0IGhlYWRlci4gVGhlcmUgaXMgbm8gYC0taWNtcy1ob3N0YCBNYWtlIG9yIENMSSBmbGFnLgoK" + + "UmVnaXN0ZXIgZnJvbSB0aGUgY29tcHV0ZSBjb250ZXh0LCB0aGVuIGluc3RhbGwgdGhlIGNvbXB1" + + "dGUgcGxhbmU6CgpgYGBiYXNoCm1ha2UgLUMgZGVwbG95L3N0YWNrcy9udmNmLWNvbXB1dGUtcGxh" + + "bmUgcmVnaXN0ZXItY2x1c3RlciBcCiAgQ0xVU1RFUl9OQU1FPTxjbHVzdGVyLW5hbWU+IFwKICBO" + + "Q0FfSUQ9PG5jYS1pZD4gXAogIENMVVNURVJfUkVHSU9OPTxyZWdpb24+IFwKICBJQ01TX1VSTD1o" + + "dHRwOi8vPGdhdGV3YXktYWRkcmVzcz4gXAogIEtVQkVDT05GSUdfRklMRT08Y29tcHV0ZS1wbGFu" + + "ZS1rdWJlY29uZmlnPiBcCiAgTlZDRl9DTEk9PHBhdGgtdG8tbnZjZi1jbGk+IFwKICBOVkNGX0NM" + + "SV9DT05GSUc9PHBhdGgtdG8tbnZjZi1jbGktY29uZmlnPgoKbWFrZSAtQyBkZXBsb3kvc3RhY2tz" + + "L252Y2YtY29tcHV0ZS1wbGFuZSBpbnN0YWxsIFwKICBDTFVTVEVSX05BTUU9PGNsdXN0ZXItbmFt" + + "ZT4gXAogIEhFTE1GSUxFX0VOVj08ZW52PiBcCiAgS1VCRUNPTkZJR19GSUxFPTxjb21wdXRlLXBs" + + "YW5lLWt1YmVjb25maWc+CmBgYAoKUmVnaXN0cmF0aW9uIGRpc2NvdmVycyB0aGUgT0lEQyBpc3N1" + + "ZXIgYW5kIEpXS1MgZnJvbSB0aGUgY29tcHV0ZSBrdWJlIGNvbnRleHQuCkluIGEgbXVsdGktY2x1" + + "c3RlciBkZXBsb3ltZW50LCBgS1VCRUNPTkZJR19GSUxFYCBpcyByZXF1aXJlZCBvbiBib3RoCmNv" + + "bXB1dGUtcGxhbmUgY29tbWFuZHMuIEluIGEgc2FtZS1jbHVzdGVyIGRlcGxveW1lbnQgaXQgbWF5" + + "IGJlIG9taXR0ZWQgb25seQp3aGVuIHRoZSBhbWJpZW50IGNvbnRleHQgaXMgYWxyZWFkeSB0aGUg" + + "dGFyZ2V0IGNsdXN0ZXIuCgojIyBDTEkgUHJvZmlsZSBGbG93CgpSdW4gdGhlIENMSSBjb250cm9s" + + "LXBsYW5lIGluc3RhbGwgZmlyc3QuIEl0IGNyZWF0ZXMgdGhlIHByb2ZpbGUgY29uc3VtZWQgYnkK" + + "Y29tcHV0ZS1wbGFuZSByZWdpc3RyYXRpb246CgpgYGBiYXNoCm52Y2YtY2xpIC0tY29uZmlnIDxj" + "b25maWc+IHNlbGYtaG9zdGVkIFwKICAtLWNvbnRyb2wtcGxhbmUtc3RhY2sgZGVwbG95L3N0YWNr" + "cy9zZWxmLW1hbmFnZWQgXAogIC0tY29tcHV0ZS1wbGFuZS1zdGFjayBkZXBsb3kvc3RhY2tzL252" + "Y2YtY29tcHV0ZS1wbGFuZSBcCiAgLS1lbnYgPGVudj4gXAogIC0tcGxhaW4gXAogIC0tY29udHJv" + "bC1wbGFuZS1jb250ZXh0IDxjb250cm9sLXBsYW5lLWNvbnRleHQ+IFwKICAtLWNvbXB1dGUtcGxh" + - "bmUtY29udGV4dCA8Y29tcHV0ZS1wbGFuZS1jb250ZXh0PiBcCiAgLS1pY21zLXVybCA8Y29tcHV0" + - "ZS1yZWFjaGFibGUtaWNtcy11cmw+IFwKICBzdGF0dXMgXAogIC0tY2x1c3Rlci1uYW1lIDxjb21w" + - "dXRlLXBsYW5lLWNsdXN0ZXItbmFtZT4gXAogIC0tbmNhLWlkIDxuY2EtaWQ+CmBgYAoKU2hvdyB0" + - "aGUgcmVnaXN0ZXJlZCBjb21wdXRlLXBsYW5lIGxpc3QuIE5hbWVkLWNsdXN0ZXIgYGRvd24gLS1w" + - "bGFuLW9ubHlgIGRvZXMKbm90IHF1ZXJ5IElDTVMsIHNvIGl0IHByZXZpZXdzIG9ubHkgdGhhdCBj" + - "b21wdXRlIHBsYW5lIGFuZCBjYW5ub3Qgc2hvdyB0aGUKY29uZGl0aW9uYWwgY29udHJvbC1wbGFu" + - "ZSByZW1vdmFsLiBJZiB0aGUgdGFyZ2V0IGlzIHRoZSBsYXN0IHJlZ2lzdGVyZWQKY2x1c3Rlciwg" + - "cmVhbCBgZG93bmAgYWxzbyBkZXN0cm95cyB0aGUgY29udHJvbCBwbGFuZS4gR2V0IGV4cGxpY2l0" + - "IGNvbmZpcm1hdGlvbgpmb3IgYm90aCByZW1vdmFscyBiZWZvcmUgY29udGludWluZy4gVGhlbiBw" + - "cmV2aWV3IGFuZCBleGVjdXRlIHdpdGggdGhlIHNhbWUKcHJlZml4OgoKYGBgYmFzaApudmNmLWNs" + - "aSAtLWNvbmZpZyA8Y29uZmlnPiBzZWxmLWhvc3RlZCBcCiAgLS1jb250cm9sLXBsYW5lLXN0YWNr" + - "IGRlcGxveS9zdGFja3Mvc2VsZi1tYW5hZ2VkIFwKICAtLWNvbXB1dGUtcGxhbmUtc3RhY2sgZGVw" + - "bG95L3N0YWNrcy9udmNmLWNvbXB1dGUtcGxhbmUgXAogIC0tZW52IDxlbnY+IFwKICAtLXBsYWlu" + - "IFwKICAtLWNvbnRyb2wtcGxhbmUtY29udGV4dCA8Y29udHJvbC1wbGFuZS1jb250ZXh0PiBcCiAg" + - "LS1jb21wdXRlLXBsYW5lLWNvbnRleHQgPGNvbXB1dGUtcGxhbmUtY29udGV4dD4gXAogIC0taWNt" + - "cy11cmwgPGNvbXB1dGUtcmVhY2hhYmxlLWljbXMtdXJsPiBcCiAgZG93biAtLXBsYW4tb25seSBc" + - "CiAgLS1jbHVzdGVyLW5hbWUgPGNvbXB1dGUtcGxhbmUtY2x1c3Rlci1uYW1lPiBcCiAgLS1uY2Et" + - "aWQgPG5jYS1pZD4KCm52Y2YtY2xpIC0tY29uZmlnIDxjb25maWc+IHNlbGYtaG9zdGVkIFwKICAt" + - "LWNvbnRyb2wtcGxhbmUtc3RhY2sgZGVwbG95L3N0YWNrcy9zZWxmLW1hbmFnZWQgXAogIC0tY29t" + - "cHV0ZS1wbGFuZS1zdGFjayBkZXBsb3kvc3RhY2tzL252Y2YtY29tcHV0ZS1wbGFuZSBcCiAgLS1l" + - "bnYgPGVudj4gXAogIC0tcGxhaW4gXAogIC0tY29udHJvbC1wbGFuZS1jb250ZXh0IDxjb250cm9s" + - "LXBsYW5lLWNvbnRleHQ+IFwKICAtLWNvbXB1dGUtcGxhbmUtY29udGV4dCA8Y29tcHV0ZS1wbGFu" + - "ZS1jb250ZXh0PiBcCiAgLS1pY21zLXVybCA8Y29tcHV0ZS1yZWFjaGFibGUtaWNtcy11cmw+IFwK" + - "ICBkb3duIFwKICAtLWNsdXN0ZXItbmFtZSA8Y29tcHV0ZS1wbGFuZS1jbHVzdGVyLW5hbWU+IFwK" + - "ICAtLW5jYS1pZCA8bmNhLWlkPgpgYGAKClJlcGVhdCBgZG93bmAgZm9yIGVhY2ggY29tcHV0ZSBj" + - "bHVzdGVyLiBFYWNoIHJ1biBkZXN0cm95cyB0aGF0IGNvbXB1dGUgcGxhbmUgYW5kCnVucmVnaXN0" + - "ZXJzIGl0cyBJQ01TIHJvdy4gSXQgcmVtb3ZlcyB0aGUgY29udHJvbCBwbGFuZSBvbmx5IGFmdGVy" + - "IG5vIGNsdXN0ZXIKcmVnaXN0cmF0aW9ucyByZW1haW4uClBLBwiWY7xZEjAAABIwAABQSwMEFAAI" + - "AAAAAAAhAAAAAAAAAAAAAAAAADsACQBkYXRhL252Y2Ytc2VsZi1tYW5hZ2VkLWluc3RhbGxhdGlv" + - "bi9yZWZlcmVuY2VzL2RlYnVnZ2luZy5tZFVUBQABAKbOEiMgRGVidWdnaW5nIFJlZmVyZW5jZQoK" + - "UmVjaXBlcyBmb3IgZGlhZ25vc2luZyBhbmQgZml4aW5nIGNvbW1vbiBOVkNGIHNlbGYtbWFuYWdl" + - "ZCBzdGFjayBmYWlsdXJlcy4KCiMjIFF1aWNrIFN0YXR1cyBDb21tYW5kcwoKYGBgYmFzaAojIEFs" + - "bCBwb2RzIGFjcm9zcyBhbGwgbmFtZXNwYWNlcwprdWJlY3RsIGdldCBwb2RzIC1BIC1vIHdpZGUK" + - "CiMgUG9kcyBpbiBhIHNwZWNpZmljIG5hbWVzcGFjZQprdWJlY3RsIGdldCBwb2RzIC1uIDxuYW1l" + - "c3BhY2U+CgojIEFsbCBoZWxtIHJlbGVhc2VzCmhlbG0gbGlzdCAtQQoKIyBSZWNlbnQgZXZlbnRz" + - "IChtb3N0IHVzZWZ1bCBmb3IgZGlhZ25vc2luZyBmYWlsdXJlcykKa3ViZWN0bCBnZXQgZXZlbnRz" + - "IC1uIDxuYW1lc3BhY2U+IC0tc29ydC1ieT0nLmxhc3RUaW1lc3RhbXAnCgojIERlc2NyaWJlIGEg" + - "c3BlY2lmaWMgcG9kIChzaG93cyBldmVudHMsIGNvbmRpdGlvbnMsIHZvbHVtZXMpCmt1YmVjdGwg" + - "ZGVzY3JpYmUgcG9kIC1uIDxuYW1lc3BhY2U+IDxwb2QtbmFtZT4KYGBgCgojIyBGYWlsdXJlOiBJ" + - "bWFnZVB1bGxCYWNrT2ZmCgojIyMgU3ltcHRvbXMKCmBgYApOQU1FICAgICAgICAgICBSRUFEWSAg" + - "IFNUQVRVUyAgICAgICAgICAgICBSRVNUQVJUUyAgIEFHRQpjYXNzYW5kcmEtMCAgICAwLzEgICAg" + - "IEltYWdlUHVsbEJhY2tPZmYgICAwICAgICAgICAgIDVtCmBgYAoKRXZlbnRzIHNob3c6CmBgYApG" + - "YWlsZWQgdG8gcHVsbCBpbWFnZSAibnZjci5pby8uLi4vaW1hZ2U6dGFnIjogNDAxIFVuYXV0aG9y" + - "aXplZApgYGAKCiMjIyBEaWFnbm9zaXMKCmBgYGJhc2gKIyBDaGVjayB3aGF0IGltYWdlIGlzIGZh" + - "aWxpbmcKa3ViZWN0bCBkZXNjcmliZSBwb2QgLW4gPG5hbWVzcGFjZT4gPHBvZC1uYW1lPiB8IGdy" + - "ZXAgLUE1ICJFdmVudHM6IgoKIyBDaGVjayBpZiBwdWxsIHNlY3JldCBleGlzdHMgaW4gdGhlIG5h" + - "bWVzcGFjZQprdWJlY3RsIGdldCBzZWNyZXQgbnZjci1jcmVkcyAtbiA8bmFtZXNwYWNlPgoKIyBD" + - "aGVjayBpZiB0aGUgcG9kIHNwZWMgaGFzIGltYWdlUHVsbFNlY3JldHMKa3ViZWN0bCBnZXQgcG9k" + - "IC1uIDxuYW1lc3BhY2U+IDxwb2QtbmFtZT4gLW8ganNvbnBhdGg9J3suc3BlYy5pbWFnZVB1bGxT" + - "ZWNyZXRzfScKCiMgQ2hlY2sgaWYgdGhlIFNlcnZpY2VBY2NvdW50IGhhcyBpbWFnZVB1bGxTZWNy" + - "ZXRzCmt1YmVjdGwgZ2V0IHNhIDxzYS1uYW1lPiAtbiA8bmFtZXNwYWNlPiAtbyBqc29ucGF0aD0n" + - "ey5pbWFnZVB1bGxTZWNyZXRzfScKYGBgCgojIyMgRml4ZXMKCjEuICoqU2VjcmV0IG1pc3Npbmcg" + - "aW4gbmFtZXNwYWNlKio6IENyZWF0ZSBpdAogICBgYGBiYXNoCiAgIGt1YmVjdGwgY3JlYXRlIHNl" + - "Y3JldCBkb2NrZXItcmVnaXN0cnkgbnZjci1jcmVkcyBcCiAgICAgLS1kb2NrZXItc2VydmVyPW52" + - "Y3IuaW8gXAogICAgIC0tZG9ja2VyLXVzZXJuYW1lPSckb2F1dGh0b2tlbicgXAogICAgIC0tZG9j" + - "a2VyLXBhc3N3b3JkPSIkTkdDX0FQSV9LRVkiIFwKICAgICAtLW5hbWVzcGFjZT08bmFtZXNwYWNl" + - "PiBcCiAgICAgLS1kcnktcnVuPWNsaWVudCAtbyB5YW1sIHwga3ViZWN0bCBhcHBseSAtZiAtCiAg" + - "IGBgYAoKMi4gKipTZWNyZXQgZXhpc3RzIGJ1dCBwb2QgZG9lc24ndCByZWZlcmVuY2UgaXQqKjog" + - "VGhlIGNoYXJ0IG5lZWRzIGBpbWFnZVB1bGxTZWNyZXRzYCBjb25maWd1cmVkIHZpYSBoZWxtZmls" + - "ZSB2YWx1ZXMuIFNlZSBbcHVsbC1zZWNyZXRzLm1kXShwdWxsLXNlY3JldHMubWQpLgoKMy4gKipD" + - "aGFydCBkb2Vzbid0IHN1cHBvcnQgaW1hZ2VQdWxsU2VjcmV0cyoqIChvcGVuYmFvLCBpbnZvY2F0" + - "aW9uLXNlcnZpY2UsIGVzcy1hcGksIG5vdGFyeS1zZXJ2aWNlKTogUGF0Y2ggU2VydmljZUFjY291" + - "bnRzIGFuZCByZXN0YXJ0IHBvZHMuIFNlZSBbcHVsbC1zZWNyZXRzLm1kXShwdWxsLXNlY3JldHMu" + - "bWQpLgoKNC4gKipXcm9uZyBjcmVkZW50aWFscyBpbiBzZWNyZXQqKjogRGVsZXRlIGFuZCByZWNy" + - "ZWF0ZQogICBgYGBiYXNoCiAgIGt1YmVjdGwgZGVsZXRlIHNlY3JldCBudmNyLWNyZWRzIC1uIDxu" + - "YW1lc3BhY2U+CiAgICMgUmVjcmVhdGUgd2l0aCBjb3JyZWN0IGNyZWRlbnRpYWxzCiAgIGBgYAoK" + - "IyMgRmFpbHVyZTogSW5pdDowLzEgU3R1Y2sgKFZhdWx0IEFnZW50KQoKIyMjIFN5bXB0b21zCgpT" + - "ZXJ2aWNlIHBvZHMgc3R1Y2sgaW4gYEluaXQ6MC8xYCBmb3IgbWludXRlczoKYGBgCk5BTUUgICAg" + - "ICAgICAgICAgICAgICAgICAgICBSRUFEWSAgIFNUQVRVUyAgICAgUkVTVEFSVFMgICBBR0UKbnZj" + - "Zi1hcGktN2Y0Yzc2Zjc4OC00NHZsdCAgMC8yICAgICBJbml0OjAvMSAgIDAgICAgICAgICAgMTBt" + - "CmBgYAoKIyMjIERpYWdub3NpcwoKVGhlIGluaXQgY29udGFpbmVyIGlzIHRoZSB2YXVsdC1hZ2Vu" + - "dC1pbml0IGluamVjdG9yIHdhaXRpbmcgZm9yIE9wZW5CYW8uCgpgYGBiYXNoCiMgQ2hlY2sgT3Bl" + - "bkJhbyBwb2RzCmt1YmVjdGwgZ2V0IHBvZHMgLW4gdmF1bHQtc3lzdGVtCgojIENoZWNrIGlmIE9w" + - "ZW5CYW8gbWlncmF0aW9uIGpvYiByYW4Ka3ViZWN0bCBnZXQgam9icyAtbiB2YXVsdC1zeXN0ZW0K" + - "CiMgQ2hlY2sgT3BlbkJhbyBwb2QgbG9ncwprdWJlY3RsIGxvZ3MgLW4gdmF1bHQtc3lzdGVtIG9w" + - "ZW5iYW8tc2VydmVyLTAgLWMgb3BlbmJhbwoKIyBDaGVjayBpbml0IGNvbnRhaW5lciBsb2dzIG9u" + - "IHRoZSBzdHVjayBwb2QKa3ViZWN0bCBsb2dzIC1uIDxuYW1lc3BhY2U+IDxwb2QtbmFtZT4gLWMg" + - "dmF1bHQtYWdlbnQtaW5pdApgYGAKCiMjIyBGaXhlcwoKMS4gKipPcGVuQmFvIHBvZHMgbm90IHJ1" + - "bm5pbmcqKjogQ2hlY2sgdGhlaXIgZXZlbnRzIGZvciBpbWFnZSBwdWxsIGlzc3VlcywgcmVzb3Vy" + - "Y2UgaXNzdWVzLCBldGMuCgoyLiAqKk9wZW5CYW8gbWlncmF0aW9uIGpvYiBkaWRuJ3QgcnVuKio6" + - "IFRoaXMgaGFwcGVucyB3aGVuIGBoZWxtZmlsZSBzeW5jYCB3YXMgaW50ZXJydXB0ZWQuIERlc3Ry" + - "b3kgYW5kIHJlLXN5bmMgb3BlbmJhbzoKICAgYGBgYmFzaAogICBIRUxNRklMRV9FTlY9PGVudj4g" + - "aGVsbWZpbGUgLS1zZWxlY3RvciBuYW1lPW9wZW5iYW8tc2VydmVyIGRlc3Ryb3kKICAga3ViZWN0" + - "bCBkZWxldGUgbmFtZXNwYWNlIHZhdWx0LXN5c3RlbQogICBrdWJlY3RsIGNyZWF0ZSBuYW1lc3Bh" + - "Y2UgdmF1bHQtc3lzdGVtCiAgICMgUmUtY3JlYXRlIHB1bGwgc2VjcmV0IGlmIG5lZWRlZAogICBI" + - "RUxNRklMRV9FTlY9PGVudj4gaGVsbWZpbGUgLS1zZWxlY3RvciBuYW1lPW9wZW5iYW8tc2VydmVy" + - "IHN5bmMKICAgYGBgCgozLiAqKk9wZW5CYW8gcG9kcyBydW5uaW5nIGJ1dCBub3QgaW5pdGlhbGl6" + - "ZWQqKjogQ2hlY2sgdW5zZWFsIHN0YXR1czoKICAgYGBgYmFzaAogICBrdWJlY3RsIGV4ZWMgLW4g" + - "dmF1bHQtc3lzdGVtIG9wZW5iYW8tc2VydmVyLTAgLWMgb3BlbmJhbyAtLSBiYW8gc3RhdHVzCiAg" + - "IGBgYAoKNC4gKipgdmF1bHQtYWdlbnQtaW5pdGAgbG9ncyBgYXV0aC9qd3QvbG9naW5gIC0+IGA0" + - "MDAgLi4uIG5vIGtub3duIGtleSBzdWNjZXNzZnVsbHkgdmFsaWRhdGVkIHRoZSB0b2tlbiBzaWdu" + - "YXR1cmVgKioKICAgKGNvbW1vbiBvbiBBS1MsIGFuZCBvbiBhbnkgY2x1c3RlciB3aG9zZSBPSURD" + - "IGlzc3VlciBwdWJsaXNoZXMgYSByb3RhdGluZyBtdWx0aS1rZXkgSldLUyk6CiAgIHRoZSBPcGVu" + - "QmFvIGBhdXRoL2p3dGAgbWV0aG9kIHdhcyBjb25maWd1cmVkIHdpdGggYSBzaW5nbGUgc3RhdGlj" + - "IG1vdW50ZWQgcHVibGljIGtleQogICAoYGp3dF92YWxpZGF0aW9uX3B1YmtleXNgKSBpbnN0ZWFk" + - "IG9mIHRoZSBpc3N1ZXIncyBsaXZlIEpXS1MsIHNvIGl0IGNhbm5vdCB2YWxpZGF0ZSB0aGUKICAg" + - "Y2x1c3Rlci1zaWduZWQgU2VydmljZUFjY291bnQgdG9rZW5zIHRoZSB2YXVsdC1hZ2VudHMgcHJl" + - "c2VudC4gRXZlcnkgc2VydmljZSdzCiAgIGB2YXVsdC1hZ2VudC1pbml0YCB0aGVuIGxvb3BzIG9u" + - "IHRoYXQgNDAwIGFuZCB0aGUgcG9kIG5ldmVyIGxlYXZlcyBgSW5pdDowLzFgLiBUaGlzIGlzIHRo" + - "ZQogICBiZWhhdmlvciBvZiB0aGUgYmFzZSBkZWZhdWx0IGBvcGVuYmFvLm1pZ3JhdGlvbnMuaXNz" + - "dWVyRGlzY292ZXJ5LmVuYWJsZWQ6IGZhbHNlYDsgdGhlCiAgIG1pZ3JhdGlvbiBsb2cgc2hvd3Mg" + - "YE9JREMgaXNzdWVyIGRpc2NvdmVyeSBpcyBkaXNhYmxlZC4gVXNpbmcgU2VydmljZUFjY291bnQg" + - "aXNzdWVyIGFuZAogICBtb3VudGVkIHB1YmxpYyBrZXkgZmFsbGJhY2tgLiBFbmFibGUgaXNzdWVy" + - "IGRpc2NvdmVyeSBzbyB0aGUgbWlncmF0aW9uIHVzZXMgdGhlIGxpdmUgSldLUywKICAgdGhlbiBy" + - "ZS1ydW4gaXQ6CiAgIGBgYGJhc2gKICAgIyBJbiB5b3VyIGVudiB2YWx1ZXMgKGUuZy4gZW52aXJv" + - "bm1lbnRzLzxlbnY+LnlhbWwpLCBzZXQ6CiAgICMgICBvcGVuYmFvOgogICAjICAgICBtaWdyYXRp" + - "b25zOgogICAjICAgICAgIGlzc3VlckRpc2NvdmVyeToKICAgIyAgICAgICAgIGVuYWJsZWQ6IHRy" + - "dWUKICAga3ViZWN0bCBkZWxldGUgam9iIC1uIHZhdWx0LXN5c3RlbSBvcGVuYmFvLXNlcnZlci1t" + - "aWdyYXRpb25zCiAgIEhFTE1GSUxFX0VOVj08ZW52PiBoZWxtZmlsZSAtLXNlbGVjdG9yIG5hbWU9" + - "b3BlbmJhby1zZXJ2ZXIgc3luYwogICBgYGAKICAgVGhlIG1pZ3JhdGlvbiBsb2cgc2hvdWxkIHRo" + - "ZW4gc2hvdyBgUmVjZWl2ZWQgZGlzY292ZXJ5IGRvY3VtZW50IGZyb20KICAgLi4uLy53ZWxsLWtu" + - "b3duL29wZW5pZC1jb25maWd1cmF0aW9uYCBhbmQgYEZpbmFsIE9wZW5CYW8gSldUIEpXS1MgVVJM" + - "IHNldCB0bzoKICAgLi4uL29wZW5pZC92MS9qd2tzYCwgYW5kIHRoZSBzZXJ2aWNlIHBvZHMgYXV0" + - "aGVudGljYXRlIGFuZCByZWFjaCBSZWFkeSB3aXRoaW4gfjEgbWluLgogICBBS1MgY2x1c3RlcnMg" + - "d2l0aCB0aGUgY2x1c3RlciBPSURDIGlzc3VlciBlbmFibGVkICh0aGUgYGFrcy1jbHVzdGVyYCBk" + - "ZWZhdWx0KSBhbHdheXMgbmVlZAogICB0aGlzIGJlY2F1c2UgdGhlIHN0YXRpYy1wdWJrZXkgZmFs" + - "bGJhY2sgY2Fubm90IG1hdGNoIHRoZSBpc3N1ZXIncyByb3RhdGluZyBzaWduaW5nIGtleXMuCgoj" + - "IyBGYWlsdXJlOiBPT01LaWxsZWQgb24gQ2Fzc2FuZHJhCgojIyMgU3ltcHRvbXMKCmBgYApOQU1F" + - "ICAgICAgICAgIFJFQURZICAgU1RBVFVTICAgIFJFU1RBUlRTICAgQUdFCmNhc3NhbmRyYS0wICAg" + - "MC8xICAgICBPT01LaWxsZWQgIDMgICAgICAgICAxMG0KYGBgCgojIyMgRGlhZ25vc2lzCgpgYGBi" + - "YXNoCmt1YmVjdGwgZGVzY3JpYmUgcG9kIC1uIGNhc3NhbmRyYS1zeXN0ZW0gY2Fzc2FuZHJhLTAg" + - "fCBncmVwIC1BMyAiTGFzdCBTdGF0ZSIKYGBgCgojIyMgRml4CgpPdmVycmlkZSBDYXNzYW5kcmEg" + - "cmVzb3VyY2VzIHZpYSBoZWxtZmlsZSB2YWx1ZXMuIFNlZSBFeGFtcGxlIDEgaW4KW2V4YW1wbGVz" + - "Lm1kXSguLi9leGFtcGxlcy5tZCkuCgpgYGB5YW1sCi0gY2Fzc2FuZHJhOgogICAgcmVzb3VyY2Vz" + - "OgogICAgICBsaW1pdHM6CiAgICAgICAgY3B1OiAiOCIKICAgICAgICBtZW1vcnk6IDgxOTJNaQog" + - "ICAgICByZXF1ZXN0czoKICAgICAgICBjcHU6ICIyIgogICAgICAgIG1lbW9yeTogNDA5Nk1pCmBg" + - "YAoKTm90ZTogYHJlc291cmNlUHJlc2V0YCBpcyBub3QgYXZhaWxhYmxlIGluIHRoZSBOVkNGIGNh" + - "c3NhbmRyYSB3cmFwcGVyIGNoYXJ0LiBVc2UgZXhwbGljaXQgYHJlc291cmNlc2AuCgojIyBGYWls" + - "dXJlOiBQb2RzIFN0dWNrIGluIFBlbmRpbmcKCiMjIyBTeW1wdG9tcwoKYGBgCk5BTUUgICAgICAg" + - "ICAgUkVBRFkgICBTVEFUVVMgICAgUkVTVEFSVFMgICBBR0UKY2Fzc2FuZHJhLTAgICAwLzEgICAg" + - "IFBlbmRpbmcgICAwICAgICAgICAgIDEwbQpgYGAKCiMjIyBEaWFnbm9zaXMKCmBgYGJhc2gKIyBD" + - "aGVjayBldmVudHMgZm9yIHNjaGVkdWxpbmcgZmFpbHVyZXMKa3ViZWN0bCBkZXNjcmliZSBwb2Qg" + - "LW4gPG5hbWVzcGFjZT4gPHBvZC1uYW1lPgoKIyBDb21tb24gY2F1c2VzOgojIC0gIjAvMTIgbm9k" + - "ZXMgYXJlIGF2YWlsYWJsZTogMTIgbm9kZShzKSBkaWRuJ3QgbWF0Y2ggUG9kJ3Mgbm9kZSBhZmZp" + - "bml0eSIKIyAtICIwLzEyIG5vZGVzIGFyZSBhdmFpbGFibGU6IDEyIEluc3VmZmljaWVudCBtZW1v" + - "cnkiCiMgLSAicGVyc2lzdGVudHZvbHVtZWNsYWltIG5vdCBmb3VuZCIKYGBgCgojIyMgRml4ZXMK" + - "CjEuICoqTm9kZSBzZWxlY3RvciBtaXNtYXRjaCoqOiBDaGVjayBgbm9kZVNlbGVjdG9yc2AgaW4g" + - "ZW52aXJvbm1lbnQgZmlsZQogICBgYGBiYXNoCiAgIGt1YmVjdGwgZ2V0IG5vZGVzIC0tc2hvdy1s" + - "YWJlbHMgfCBncmVwIG52Y2YKICAgYGBgCgoyLiAqKlN0b3JhZ2UgY2xhc3Mgbm90IGZvdW5kKio6" + - "IENoZWNrIHN0b3JhZ2UgY2xhc3MgZXhpc3RzCiAgIGBgYGJhc2gKICAga3ViZWN0bCBnZXQgc3Rv" + - "cmFnZWNsYXNzCiAgIGBgYAoKMy4gKipJbnN1ZmZpY2llbnQgcmVzb3VyY2VzKio6IENoZWNrIG5v" + - "ZGUgY2FwYWNpdHkKICAgYGBgYmFzaAogICBrdWJlY3RsIGRlc2NyaWJlIG5vZGUgPG5vZGUtbmFt" + - "ZT4gfCBncmVwIC1BNSAiQWxsb2NhdGVkIHJlc291cmNlcyIKICAgYGBgCgojIyBGYWlsdXJlOiBI" + - "ZWxtIFJlbGVhc2UgaW4gRmFpbGVkIFN0YXRlCgojIyMgU3ltcHRvbXMKCmBgYGJhc2gKaGVsbSBs" + - "aXN0IC1BCiMgU2hvd3MgcmVsZWFzZSB3aXRoIFNUQVRVUzogZmFpbGVkCmBgYAoKUmUtcnVubmlu" + - "ZyBgaGVsbWZpbGUgc3luY2AgYXBwZWFycyB0byBzdWNjZWVkIGJ1dCBzZXJ2aWNlcyBkb24ndCB3" + - "b3JrIChtaWdyYXRpb25zIHNraXBwZWQpLgoKIyMjIERpYWdub3NpcwoKYGBgYmFzaApoZWxtIGhp" + - "c3RvcnkgPHJlbGVhc2UtbmFtZT4gLW4gPG5hbWVzcGFjZT4KYGBgCgojIyMgRml4CgpNdXN0IGRl" + - "c3Ryb3kgdGhlIGZhaWxlZCByZWxlYXNlIGFuZCByZS1zeW5jIChub3QganVzdCBhcHBseSk6Cgpg" + - "YGBiYXNoCkhFTE1GSUxFX0VOVj08ZW52PiBoZWxtZmlsZSAtLXNlbGVjdG9yIG5hbWU9PHJlbGVh" + - "c2U+IGRlc3Ryb3kKIyBJZiBuYW1lc3BhY2UgbmVlZHMgY2xlYW51cDoKa3ViZWN0bCBkZWxldGUg" + - "bmFtZXNwYWNlIDxuYW1lc3BhY2U+Cmt1YmVjdGwgY3JlYXRlIG5hbWVzcGFjZSA8bmFtZXNwYWNl" + - "PgojIFJlLWNyZWF0ZSBwdWxsIHNlY3JldCBpZiBuZWVkZWQKSEVMTUZJTEVfRU5WPTxlbnY+IGhl" + - "bG1maWxlIC0tc2VsZWN0b3IgbmFtZT08cmVsZWFzZT4gc3luYwpgYGAKCiMjIEZhaWx1cmU6IEFj" + - "Y291bnQgQm9vdHN0cmFwIEpvYiBGYWlsZWQKCiMjIyBTeW1wdG9tcwoKU2VydmljZXMgZGVwbG95" + - "IGJ1dCBmdW5jdGlvbnMgY2FuJ3QgYmUgY3JlYXRlZC4gRXZlbnRzIHNob3cgYm9vdHN0cmFwIGpv" + - "YiBmYWlsdXJlLgoKIyMjIERpYWdub3NpcwoKYGBgYmFzaAojIENoZWNrIGJvb3RzdHJhcCBqb2Ig" + - "c3RhdHVzCmt1YmVjdGwgZ2V0IGpvYnMgLW4gbnZjZgoKIyBHZXQgbG9ncyAoam9iIGF1dG8tZGVs" + - "ZXRlcyBhZnRlciB+NSBtaW51dGVzKQprdWJlY3RsIGxvZ3Mgam9iL252Y2YtYXBpLWFjY291bnQt" + - "Ym9vdHN0cmFwIC1uIG52Y2YKCiMgQ2hlY2sgQVBJIGxvZ3MKa3ViZWN0bCBsb2dzIC1uIG52Y2Yg" + - "LWwgYXBwLmt1YmVybmV0ZXMuaW8vbmFtZT1udmNmLWFwaSAtLXRhaWw9MTAwCmBgYAoKIyMjIENv" + - "bW1vbiBDYXVzZXMKCjEuICoqV3JvbmcgYmFzZTY0IGNyZWRlbnRpYWxzKio6IENyZWRlbnRpYWxz" + - "IGluIGBzZWNyZXRzLzxlbnY+LXNlY3JldHMueWFtbGAgbXVzdCBiZSBgJG9hdXRodG9rZW46QVBJ" + - "X0tFWWAgYmFzZTY0LWVuY29kZWQsIG5vdCBqdXN0IHRoZSBBUEkga2V5CiAgIGBgYGJhc2gKICAg" + - "IyBWZXJpZnkgeW91ciBlbmNvZGVkIGNyZWRlbnRpYWwKICAgZWNobyAnWU9VUl9CQVNFNjRfU1RS" + - "SU5HJyB8IGJhc2U2NCAtZAogICAjIFNob3VsZCBvdXRwdXQ6ICRvYXV0aHRva2VuOm52YXBpLXh4" + - "eHh4CiAgIGBgYAoKMi4gKipSZWdpc3RyeSB1bnJlYWNoYWJsZSoqOiBBUEkgY2FuJ3QgcmVhY2gg" + - "dGhlIHJlZ2lzdHJ5IHNwZWNpZmllZCBpbiBgYWNjb3VudEJvb3RzdHJhcC5yZWdpc3RyeUNyZWRl" + - "bnRpYWxzYAoKIyMjIEZpeAoKRml4IGNyZWRlbnRpYWxzIGluIHNlY3JldHMgZmlsZSwgdGhlbiBy" + - "ZWNvdmVyIHNlcnZpY2VzIHdpdGhvdXQgZGVzdHJveWluZyBkZXBlbmRlbmNpZXM6CgpgYGBiYXNo" + - "CkhFTE1GSUxFX0VOVj08ZW52PiBoZWxtZmlsZSAtLXNlbGVjdG9yIHJlbGVhc2UtZ3JvdXA9c2Vy" + - "dmljZXMgZGVzdHJveQprdWJlY3RsIGRlbGV0ZSBuYW1lc3BhY2UgbnZjZiBhcGkta2V5cyBlc3Mg" + - "c2lzIC0taWdub3JlLW5vdC1mb3VuZAprdWJlY3RsIGNyZWF0ZSBuYW1lc3BhY2UgbnZjZiAmJiBr" + - "dWJlY3RsIGNyZWF0ZSBuYW1lc3BhY2UgYXBpLWtleXMgJiYgXAogIGt1YmVjdGwgY3JlYXRlIG5h" + - "bWVzcGFjZSBlc3MgJiYga3ViZWN0bCBjcmVhdGUgbmFtZXNwYWNlIHNpcwojIFJlLWNyZWF0ZSBw" + - "dWxsIHNlY3JldHMgaWYgbmVlZGVkCkhFTE1GSUxFX0VOVj08ZW52PiBoZWxtZmlsZSAtLXNlbGVj" + - "dG9yIHJlbGVhc2UtZ3JvdXA9c2VydmljZXMgc3luYwpgYGAKCiMjIEZhaWx1cmU6IE5WQ0EgQ2xl" + - "YW51cCBTdHVjayAoRmluYWxpemVycykKCiMjIyBTeW1wdG9tcwoKQ29tcHV0ZS1wbGFuZSBjbGVh" + - "bnVwIGhhbmdzLiBOYW1lc3BhY2VzCnN0dWNrIGluIGBUZXJtaW5hdGluZ2A6CgpgYGBiYXNoCmt1" + - "YmVjdGwgZ2V0IG5zCiMgbnZjYS1vcGVyYXRvciAgICBUZXJtaW5hdGluZyAgIDEwbQojIG52Y2Yt" + - "YmFja2VuZCAgICAgVGVybWluYXRpbmcgICAxMG0KYGBgCgojIyMgRml4CgpSdW4gdGhpcyBvbmx5" + - "IGFnYWluc3QgdGhlIGNvbXB1dGUgY29udGV4dCwgYWZ0ZXIgdGhlIG5vcm1hbCBjb21wdXRlLXBs" + - "YW5lCnRlYXJkb3duIGhhcyBmYWlsZWQuIFJlbW92ZSBmaW5hbGl6ZXJzIGZyb20gTlZDRkJhY2tl" + - "bmQgY3VzdG9tIHJlc291cmNlcyBhbmQKZm9yY2UtZGVsZXRlIHN0dWNrIG5hbWVzcGFjZXM6Cgpg" + - "YGBiYXNoCmV4cG9ydCBDT01QVVRFX0NPTlRFWFQ9PGNvbXB1dGUtcGxhbmUtY29udGV4dD4KCiMg" + - "UmVtb3ZlIGZpbmFsaXplcnMgZnJvbSBOVkNGQmFja2VuZCByZXNvdXJjZXMKa3ViZWN0bCAtLWNv" + - "bnRleHQgIiRDT01QVVRFX0NPTlRFWFQiIGdldCBudmNmYmFja2VuZHMgLUEgLW8ganNvbiB8IFwK" + - "ICBqcSAnLml0ZW1zW10gfCAubWV0YWRhdGEubmFtZXNwYWNlICsgIi8iICsgLm1ldGFkYXRhLm5h" + - "bWUnIC1yIHwgXAogIHhhcmdzIC1Je30gc2ggLWMgJ2NvbnRleHQ9IiQxIjsgbnM9IiR7MiUlLyp9" + - "IjsgbmFtZT0iJHsyIyMqL30iOyBrdWJlY3RsIC0tY29udGV4dCAiJGNvbnRleHQiIHBhdGNoIG52" + - "Y2ZiYWNrZW5kICIkbmFtZSIgLW4gIiRucyIgLS10eXBlPW1lcmdlIC1wICJ7XCJtZXRhZGF0YVwi" + - "OntcImZpbmFsaXplcnNcIjpbXX19IicgXyAiJENPTVBVVEVfQ09OVEVYVCIge30KCiMgRm9yY2Ut" + - "ZGVsZXRlIHN0dWNrIG5hbWVzcGFjZXMgYnkgY2xlYXJpbmcgdGhlaXIgZmluYWxpemVycwpmb3Ig" + - "bnMgaW4gbnZjYS1vcGVyYXRvciBudmNmLWJhY2tlbmQ7IGRvCiAga3ViZWN0bCAtLWNvbnRleHQg" + - "IiRDT01QVVRFX0NPTlRFWFQiIGdldCBuYW1lc3BhY2UgIiRucyIgLW8ganNvbiAyPi9kZXYvbnVs" + - "bCB8IFwKICAgIGpxICcuc3BlYy5maW5hbGl6ZXJzID0gW10nIHwgXAogICAga3ViZWN0bCAtLWNv" + - "bnRleHQgIiRDT01QVVRFX0NPTlRFWFQiIHJlcGxhY2UgXAogICAgICAtLXJhdyAiL2FwaS92MS9u" + - "YW1lc3BhY2VzLyRucy9maW5hbGl6ZSIgLWYgLSAyPi9kZXYvbnVsbApkb25lCmBgYAoKIyMgRmFp" + - "bHVyZTogTlZDQSBPcGVyYXRvciBNaXNzaW5nIG9yIE5vdCBSZWFkeQoKIyMjIFN5bXB0b21zCgpB" + - "ZnRlciBjb21wdXRlLXBsYW5lIGluc3RhbGwgY29tcGxldGVzLCBubyBgbnZjYS1vcGVyYXRvcmAg" + - "RGVwbG95bWVudCBleGlzdHMsIG9yCml0IGV4aXN0cyBidXQgcG9kcyBhcmUgbm90IHJlYWR5OgoK" + - "YGBgYmFzaAprdWJlY3RsIC0tY29udGV4dCA8Y29tcHV0ZS1wbGFuZS1jb250ZXh0PiBnZXQgZGVw" + - "bG95bWVudCBudmNhLW9wZXJhdG9yIFwKICAtbiBudmNhLW9wZXJhdG9yCmt1YmVjdGwgLS1jb250" + - "ZXh0IDxjb21wdXRlLXBsYW5lLWNvbnRleHQ+IGdldCBwb2RzIC1uIG52Y2Etb3BlcmF0b3IKYGBg" + - "CgojIyMgRGlhZ25vc2lzIGFuZCBGaXhlcwoKRmlyc3QgaWRlbnRpZnkgd2hldGhlciB0aGUgaW5z" + - "dGFsbGF0aW9uIHVzZWQgdGhlIEhlbG1maWxlIHZhbHVlcyBmbG93IG9yIHRoZQpDTEkgcHJvZmls" + - "ZSBmbG93LiBSZS1ydW4gb25seSB0aGF0IGZsb3cncyByZWdpc3RyYXRpb24gYW5kIGluc3RhbGxh" + - "dGlvbiBzdGVwcwpmcm9tIFtTcGxpdCBDb21wdXRlLVBsYW5lIEluc3RhbGxhdGlvbl0oY29tcHV0" + - "ZS1wbGFuZS1pbnN0YWxsYXRpb24ubWQpLiBEbyBub3QKc3Vic3RpdHV0ZSBvbmUgaGFuZG9mZiBm" + - "b3IgdGhlIG90aGVyLgoKSWYgaW5zdGFsbGF0aW9uIHN1Y2NlZWRzIGJ1dCBwb2RzIHN0aWxsIGZh" + - "aWwsIGluc3BlY3QgdGhlIGNvbXB1dGUgY29udGV4dDoKCmBgYGJhc2gKa3ViZWN0bCAtLWNvbnRl" + - "eHQgPGNvbXB1dGUtcGxhbmUtY29udGV4dD4gZGVzY3JpYmUgZGVwbG95IG52Y2Etb3BlcmF0b3Ig" + - "XAogIC1uIG52Y2Etb3BlcmF0b3IKa3ViZWN0bCAtLWNvbnRleHQgPGNvbXB1dGUtcGxhbmUtY29u" + - "dGV4dD4gbG9ncyBkZXBsb3ltZW50L252Y2Etb3BlcmF0b3IgXAogIC1uIG52Y2Etb3BlcmF0b3Ig" + - "LS10YWlsPTIwMAprdWJlY3RsIC0tY29udGV4dCA8Y29tcHV0ZS1wbGFuZS1jb250ZXh0PiBnZXQg" + - "bnZjZmJhY2tlbmQgLW4gbnZjYS1vcGVyYXRvcgpgYGAKCkZvciBwcml2YXRlIHJlZ2lzdHJ5IGZh" + - "aWx1cmVzLCB2ZXJpZnkgdGhhdCB0aGUgcHVsbCBzZWNyZXQgZXhpc3RzIGluCmBudmNhLW9wZXJh" + - "dG9yYC4gVGhlIGNoYXJ0IGFuZCBvcGVyYXRvciBtaXJyb3IgaXQgdG8gYG52Y2Etc3lzdGVtYDsg" + - "ZG8gbm90IHVzZSBhCmJyb2FkZXIgbWFudWFsIG5hbWVzcGFjZSBsb29wLiBTZWUKW3B1bGwtc2Vj" + - "cmV0cy5tZF0ocHVsbC1zZWNyZXRzLm1kI2NvbXB1dGUtcGxhbmUtc2VjcmV0KS4KCiMjIEZhaWx1" + - "cmU6IEdhdGV3YXkgRW5kcG9pbnQgQ2hhbmdlZAoKIyMjIFN5bXB0b21zCgpSZXF1ZXN0cyB0aHJv" + - "dWdoIHRoZSBjb25maWd1cmVkIHJvdXRlIGRvbWFpbiBmYWlsIGFmdGVyIHRoZSBHYXRld2F5IG9y" + - "IGl0cyBsb2FkIGJhbGFuY2VyIGlzIHJlcGxhY2VkLiBUaGUgR2F0ZXdheSByZXBvcnRzIGEgbmV3" + - "IGVuZHBvaW50LgoKIyMjIERpYWdub3NpcwoKYGBgYmFzaApHQVRFV0FZX0FERFI9JChrdWJlY3Rs" + - "IC0tY29udGV4dCA8Y29udHJvbC1wbGFuZS1jb250ZXh0PiBnZXQgZ2F0ZXdheSBcCiAgbnZjZi1n" + - "YXRld2F5IC1uIGVudm95LWdhdGV3YXkgXAogIC1vIGpzb25wYXRoPSd7LnN0YXR1cy5hZGRyZXNz" + - "ZXNbMF0udmFsdWV9JykKdGVzdCAtbiAiJEdBVEVXQVlfQUREUiIKZGlnICtzaG9ydCAiYXBpLjxk" + - "b21haW4+IgpjdXJsIC1IICJIb3N0OiBhcGkuPGRvbWFpbj4iICJodHRwOi8vJEdBVEVXQVlfQURE" + - "Ui9oZWFsdGgiCgojIENoZWNrIGRpcmVjdCBhZGRyZXNzIGZpZWxkcyB1c2VkIGJ5IGEgc3BsaXQg" + - "ZGVwbG95bWVudApncmVwIG52Y2ZOYXRzU2VydmljZVVSTCBkZXBsb3kvc3RhY2tzL3NlbGYtbWFu" + - "YWdlZC9lbnZpcm9ubWVudHMvPGVudj4ueWFtbApncmVwIC1FICdpY21zU2VydmljZXxyZXZhbFNl" + - "cnZpY2V8bmF0cycgXAogIGRlcGxveS9zdGFja3MvbnZjZi1jb21wdXRlLXBsYW5lL2Vudmlyb25t" + - "ZW50cy88ZW52Pi55YW1sCmBgYAoKIyMjIEZpeAoKS2VlcCBgZ2xvYmFsLmRvbWFpbmAsIHJvdXRl" + - "IGhvc3RuYW1lcywgYW5kIEhvc3Qgb3ZlcnJpZGVzIHVuY2hhbmdlZC4gVXBkYXRlIEROUwpvciB0" + - "aGUgZGlyZWN0IGNsaWVudCBkZXN0aW5hdGlvbi4gRm9yIHNwbGl0IGRlcGxveW1lbnRzLCB1cGRh" + - "dGUgb25seSBkaXJlY3QKR2F0ZXdheS1hZGRyZXNzIGZpZWxkcyBhbmQgcmVmcmVzaCByZWdpc3Ry" + - "YXRpb24gYW5kIGluc3RhbGxhdGlvbiB0aHJvdWdoIHRoZQpzYW1lIHNlbGVjdGVkIGhhbmRvZmYu" + - "IFNlZQpbRXhhbXBsZSA0XSguLi9leGFtcGxlcy5tZCNleGFtcGxlLTQtcmVjb3Zlci1mcm9tLWEt" + - "Z2F0ZXdheS1lbmRwb2ludC1jaGFuZ2UpLgoKIyMgVXNlZnVsIE5hbWVzcGFjZS10by1TZXJ2aWNl" + - "IE1hcHBpbmcKClF1aWNrIHJlZmVyZW5jZSBmb3Igd2hpY2ggc2VydmljZXMgcnVuIGluIHdoaWNo" + - "IG5hbWVzcGFjZToKCnwgTmFtZXNwYWNlIHwgU2VydmljZXMgfAp8LS0tLS0tLS0tLS18LS0tLS0t" + - "LS0tLXwKfCBuYXRzLXN5c3RlbSB8IG5hdHMgfAp8IGNhc3NhbmRyYS1zeXN0ZW0gfCBjYXNzYW5k" + - "cmEgfAp8IHZhdWx0LXN5c3RlbSB8IG9wZW5iYW8tc2VydmVyIHwKfCBudmNmIHwgYXBpLCBpbnZv" + - "Y2F0aW9uLXNlcnZpY2UsIGdycGMtcHJveHksIG5vdGFyeS1zZXJ2aWNlLCByZXZhbCwgbGxtLXJl" + - "cXVlc3Qtcm91dGVyLCBsbG0tYXBpLWdhdGV3YXkgfAp8IGFwaS1rZXlzIHwgYXBpLWtleXMsIGFk" + - "bWluLWlzc3Vlci1wcm94eSB8CnwgZXNzIHwgZXNzLWFwaSB8Cnwgc2lzIHwgc2lzIHwKfCBlbnZv" + - "eS1nYXRld2F5LXN5c3RlbSB8IGVudm95IGdhdGV3YXkgKGluZ3Jlc3MgY29udHJvbGxlcikgfAp8" + - "IGVudm95LWdhdGV3YXkgfCBnYXRld2F5IHJlc291cmNlICsgcm91dGVzIHwKUEsHCFY+Z5CVMAAA" + - "lTAAAFBLAwQUAAgAAAAAACEAAAAAAAAAAAAAAAAARAAJAGRhdGEvbnZjZi1zZWxmLW1hbmFnZWQt" + - "aW5zdGFsbGF0aW9uL3JlZmVyZW5jZXMvaGVsbWZpbGUtc3RydWN0dXJlLm1kVVQFAAEAps4SIyBI" + - "ZWxtZmlsZSBTdHJ1Y3R1cmUgUmVmZXJlbmNlCgojIyBEaXJlY3RvcnkgTGF5b3V0CgpgYGAKbnZj" + - "Zi1zZWxmLW1hbmFnZWQtc3RhY2svCnwtLSBoZWxtZmlsZS5kLwp8ICAgfC0tIDAxLWRlcGVuZGVu" + - "Y2llcy55YW1sLmdvdG1wbCAgIyBOQVRTLCBDYXNzYW5kcmEsIE9wZW5CYW8KfCAgIHwtLSAwMi1j" + - "b3JlLnlhbWwuZ290bXBsICAgICAgICAgICMgTlZDRiBzZXJ2aWNlcyArIGluZ3Jlc3MKfCAgIGAt" + - "LSAwMy1vYnNlcnZhYmlsaXR5LnlhbWwuZ290bXBsICMgT2JzZXJ2YWJpbGl0eSBzdGFjayAob3B0" + - "aW9uYWwpCnwtLSBlbnZpcm9ubWVudHMvCnwgICB8LS0gYmFzZS55YW1sICAgICAgICAgICAgICAg" + - "ICAgICAjIERlZmF1bHQgdmFsdWVzIChhbGwgZW52aXJvbm1lbnRzKQp8ICAgYC0tIDxlbnYtbmFt" + - "ZT4ueWFtbCAgICAgICAgICAgICAgIyBQZXItZW52aXJvbm1lbnQgb3ZlcnJpZGVzCnwtLSBzZWNy" + - "ZXRzLwp8ICAgYC0tIDxlbnYtbmFtZT4tc2VjcmV0cy55YW1sICAgICAgIyBTZW5zaXRpdmUgdmFs" + - "dWVzIChyZWdpc3RyeSBjcmVkcywgcGFzc3dvcmRzKQpgLS0gZ2xvYmFsLnlhbWwuZ290bXBsICAg" + - "ICAgICAgICAgICAgIyBHbyB0ZW1wbGF0ZSB0aGF0IGNvbnN0cnVjdHMgcGVyLWNoYXJ0IHZhbHVl" + - "cwoKbnZjZi1jb21wdXRlLXBsYW5lLXN0YWNrLwp8LS0gaGVsbWZpbGUuZC8KfCAgIHwtLSAwMS1k" + - "ZXBlbmRlbmNpZXMueWFtbC5nb3RtcGwgICMgQ29tcHV0ZSBwbGFuZSBkZXBlbmRlbmN5IGNvbXBv" + - "bmVudHMKfCAgIGAtLSAwMi1udmNhLnlhbWwuZ290bXBsICAgICAgICAgICMgbnZjYS1vcGVyYXRv" + - "ciBjaGFydCBhbmQgbnZjYSBjb25maWd1cmF0aW9uCnwtLSBlbnZpcm9ubWVudHMvCnwgICB8LS0g" + - "YmFzZS55YW1sICAgICAgICAgICAgICAgICAgICAjIERlZmF1bHQgdmFsdWVzIChhbGwgZW52aXJv" + - "bm1lbnRzKQp8ICAgYC0tIDxlbnYtbmFtZT4ueWFtbCAgICAgICAgICAgICAgIyBQZXItZW52aXJv" + - "bm1lbnQgb3ZlcnJpZGVzCmAtLSBnbG9iYWwueWFtbC5nb3RtcGwgICAgICAgICAgICAgICAjIEdv" + - "IHRlbXBsYXRlIHRoYXQgY29uc3RydWN0cyBwZXItY2hhcnQgdmFsdWVzCmBgYAoKVGhlc2Ugc3Rh" + - "Y2tzIGhhdmUgc2VwYXJhdGUgZW52aXJvbm1lbnRzIGFuZCBjbHVzdGVyIGNvbnRleHRzLiBUaGUg" + - "SGVsbWZpbGUKdmFsdWVzIGZsb3cgYXV0aG9ycyBib3RoIGVudmlyb25tZW50IGZpbGVzLiBUaGUg" + - "Q0xJIHByb2ZpbGUgZmxvdyBpbnN0ZWFkIHVzZXMKdGhlIENMSS1nZW5lcmF0ZWQgY29udHJvbC1w" + - "bGFuZSBwcm9maWxlIGFzIGl0cyBlbmRwb2ludCBzb3VyY2UuIERvIG5vdCBtaXggdGhlCmhhbmRv" + - "ZmZzLiBTZWUgW1NwbGl0IENvbXB1dGUtUGxhbmUgSW5zdGFsbGF0aW9uXShjb21wdXRlLXBsYW5l" + - "LWluc3RhbGxhdGlvbi5tZCkuCgojIyBHb3RtcGwgRmlsZXMgYW5kIFRoZWlyIFJlbGVhc2VzCgoj" + - "IyMgMDEtZGVwZW5kZW5jaWVzLnlhbWwuZ290bXBsCgp8IFJlbGVhc2UgfCBDaGFydCB8IE5hbWVz" + - "cGFjZSB8IE5vdGVzIHwKfC0tLS0tLS0tLXwtLS0tLS0tfC0tLS0tLS0tLS0tfC0tLS0tLS18Cnwg" + - "bmF0cyB8IGhlbG0tbnZjZi1uYXRzIHwgbmF0cy1zeXN0ZW0gfCBNZXNzYWdpbmcgfAp8IG9wZW5i" + - "YW8tc2VydmVyIHwgaGVsbS1udmNmLW9wZW5iYW8tc2VydmVyIHwgdmF1bHQtc3lzdGVtIHwgU2Vj" + - "cmV0cyBtYW5hZ2VtZW50LCBkZXBlbmRzIG9uIG5hdHMgfAp8IGNhc3NhbmRyYSB8IGhlbG0tbnZj" + - "Zi1jYXNzYW5kcmEgfCBjYXNzYW5kcmEtc3lzdGVtIHwgRGF0YWJhc2UgfAoKVXNlcyBgPDw6ICpk" + - "ZXBlbmRlbmN5YCB0ZW1wbGF0ZSBpbmhlcml0YW5jZSB3aXRoIGByZWxlYXNlLWdyb3VwOiBkZXBl" + - "bmRlbmNpZXNgIGxhYmVsLgoKIyMjIDAyLWNvcmUueWFtbC5nb3RtcGwKCnwgUmVsZWFzZSB8IENo" + - "YXJ0IHwgTmFtZXNwYWNlIHwgTGFiZWwgfAp8LS0tLS0tLS0tfC0tLS0tLS18LS0tLS0tLS0tLS18" + - "LS0tLS0tLXwKfCBhcGkta2V5cyB8IGhlbG0tbnZjZi1hcGkta2V5cyB8IGFwaS1rZXlzIHwgc2Vy" + - "dmljZXMgfAp8IHNpcyB8IGhlbG0tbnZjZi1zaXMgfCBzaXMgfCBzZXJ2aWNlcyB8CnwgYXBpIHwg" + - "aGVsbS1udmNmLWFwaSB8IG52Y2YgfCBzZXJ2aWNlcyB8CnwgaW52b2NhdGlvbi1zZXJ2aWNlIHwg" + - "aGVsbS1udmNmLWludm9jYXRpb24tc2VydmljZSB8IG52Y2YgfCBzZXJ2aWNlcyB8CnwgZ3JwYy1w" + - "cm94eSB8IGhlbG0tbnZjZi1ncnBjLXByb3h5IHwgbnZjZiB8IHNlcnZpY2VzIHwKfCBlc3MtYXBp" + - "IHwgaGVsbS1udmNmLWVzcy1hcGkgfCBlc3MgfCBzZXJ2aWNlcyB8Cnwgbm90YXJ5LXNlcnZpY2Ug" + - "fCBoZWxtLW52Y2Ytbm90YXJ5LXNlcnZpY2UgfCBudmNmIHwgc2VydmljZXMgfAp8IHJldmFsIHwg" + - "aGVsbS1yZXZhbCB8IG52Y2YgfCBzZXJ2aWNlcyB8CnwgbGxtLXJlcXVlc3Qtcm91dGVyIHwgbnZj" + - "Zi9oZWxtLW52Y2YtbGxtLXJlcXVlc3Qtcm91dGVyIHwgbnZjZiB8IHNlcnZpY2VzIHwKfCBsbG0t" + - "YXBpLWdhdGV3YXkgfCBudmNmL2hlbG0tbnZjZi1sbG0tYXBpLWdhdGV3YXkgfCBudmNmIHwgc2Vy" + - "dmljZXMgfAp8IGFkbWluLWlzc3Vlci1wcm94eSB8IGhlbG0tYWRtaW4tdG9rZW4taXNzdWVyLXBy" + - "b3h5IHwgYXBpLWtleXMgfCAobm8gcmVsZWFzZS1ncm91cCBsYWJlbCkgfAp8IGluZ3Jlc3MgfCBu" + - "dmNmLWdhdGV3YXktcm91dGVzIHwgZW52b3ktZ2F0ZXdheS1zeXN0ZW0gfCBpbmdyZXNzIHwKCk1v" + - "c3Qgc2VydmljZXMgdXNlIGBpbmhlcml0OiBbe3RlbXBsYXRlOiBzZXJ2aWNlfV1gLiBMTE0gcmVs" + - "ZWFzZXMgdXNlIE9DSSBjaGFydHMgZnJvbSB0aGUgYG52Y2ZgIHJlcG9zaXRvcnkgd2l0aCBzdGFu" + - "ZGFsb25lIGB2YWx1ZXM6IFsuLi9nbG9iYWwueWFtbC5nb3RtcGxdYCBibG9ja3M7IHRoZXkgYXJl" + - "IGdhdGVkIG9uIGBhZGRvbnMubGxtLmVuYWJsZWRgLiBgYWRtaW4taXNzdWVyLXByb3h5YCBhbmQg" + - "YGluZ3Jlc3NgIGhhdmUgc3RhbmRhbG9uZSBgdmFsdWVzOmAgYmxvY2tzLgoKIyMjIDAzLW9ic2Vy" + - "dmFiaWxpdHkueWFtbC5nb3RtcGwKCnwgUmVsZWFzZSB8IENoYXJ0IHwgTmFtZXNwYWNlIHwgTGFi" + - "ZWwgfAp8LS0tLS0tLS0tfC0tLS0tLS18LS0tLS0tLS0tLS18LS0tLS0tLXwKfCAob2JzZXJ2YWJp" + - "bGl0eSByZWxlYXNlcykgfCAodmFyaW91cykgfCBvYnNlcnZhYmlsaXR5IHwgb2JzZXJ2YWJpbGl0" + - "eSB8CgpHYXRlZCBvbiBvYnNlcnZhYmlsaXR5LXNwZWNpZmljIGZsYWdzIGluIHRoZSBlbnZpcm9u" + - "bWVudCBmaWxlLiBTa2lwcGVkIGlmIGRpc2FibGVkLgoKIyMgVGVtcGxhdGUgSW5oZXJpdGFuY2UK" + - "CiMjIyBgPDw6ICpkZXBlbmRlbmN5YCAoWUFNTCBtZXJnZSkKClVzZWQgaW4gYDAxLWRlcGVuZGVu" + - "Y2llcy55YW1sLmdvdG1wbGAuIE1lcmdlcyB0aGUgdGVtcGxhdGUncyBwcm9wZXJ0aWVzIGludG8g" + - "dGhlIHJlbGVhc2UuCgoqKkdvdGNoYSoqOiBZQU1MIG1lcmdlIHJlcGxhY2VzIGxpc3RzLiBJZiB5" + - "b3UgYWRkIGEgYHZhbHVlczpgIGtleSB0byB0aGUgcmVsZWFzZSwgaXQgKipyZXBsYWNlcyoqIHRo" + - "ZSB0ZW1wbGF0ZSdzIGB2YWx1ZXM6YCBsaXN0IGVudGlyZWx5LiBZb3UgbXVzdCByZS1pbmNsdWRl" + - "IGFsbCB0ZW1wbGF0ZSB2YWx1ZXM6CgpJbiB0aGUgdGVtcGxhdGUgYmVsb3csIGA8cHJpdmF0ZS12" + - "YWx1ZXM+YCByZWZlcnMgdG8gdGhlIGBzZWNyZXRzL2AgZGlyZWN0b3J5IGF0IHRoZSBoZWxtZmls" + - "ZSBzdGFjayByb290LgoKYGBgeWFtbAojIFRlbXBsYXRlIGRlZmluZXM6CnRlbXBsYXRlczoKICBk" + - "ZXBlbmRlbmN5OiAmZGVwZW5kZW5jeQogICAgY2hhcnQ6IG52Y2YvaGVsbS1udmNmLXt7IC5SZWxl" + - "YXNlLk5hbWUgfX0KICAgIHZhbHVlczoKICAgICAgLSAuLi9nbG9iYWwueWFtbC5nb3RtcGwKICAg" + - "ICAgLSAuLi88cHJpdmF0ZS12YWx1ZXM+L3t7IHJlcXVpcmVkRW52ICJIRUxNRklMRV9FTlYiIH19" + - "LXNlY3JldHMueWFtbAoKIyBXaGVuIG92ZXJyaWRpbmcsIE1VU1QgcmUtaW5jbHVkZSBib3RoOgot" + - "IG5hbWU6IGNhc3NhbmRyYQogIDw8OiAqZGVwZW5kZW5jeQogIHZhbHVlczoKICAgIC0gLi4vZ2xv" + - "YmFsLnlhbWwuZ290bXBsICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg" + - "ICAgICMgTXVzdCByZS1pbmNsdWRlCiAgICAtIC4uLzxwcml2YXRlLXZhbHVlcz4ve3sgcmVxdWly" + - "ZWRFbnYgIkhFTE1GSUxFX0VOViIgfX0tc2VjcmV0cy55YW1sICAgIyBNdXN0IHJlLWluY2x1ZGUK" + - "ICAgIC0gY2Fzc2FuZHJhOiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg" + - "ICAgICAgICAgICAgICAgICAjIFlvdXIgb3ZlcnJpZGUKICAgICAgICByZXNvdXJjZXM6CiAgICAg" + - "ICAgICBsaW1pdHM6CiAgICAgICAgICAgIG1lbW9yeTogODE5Mk1pCmBgYAoKIyMjIGBpbmhlcml0" + - "YCAoSGVsbWZpbGUgbmF0aXZlKQoKVXNlZCBpbiBgMDItY29yZS55YW1sLmdvdG1wbGAuIEhlbG1m" + - "aWxlJ3MgbmF0aXZlIGluaGVyaXRhbmNlIG1lY2hhbmlzbS4KCmBgYHlhbWwKLSBuYW1lOiBhcGkK" + - "ICB2ZXJzaW9uOiAxLjYuMAogIG5hbWVzcGFjZTogbnZjZgogIGluaGVyaXQ6CiAgICAtIHRlbXBs" + - "YXRlOiBzZXJ2aWNlCmBgYAoKV2hlbiBhZGRpbmcgYHZhbHVlczpgIHRvIGFuIGluaGVyaXRlZCBy" + - "ZWxlYXNlLCB5b3UgYWxzbyBuZWVkIHRvIHJlLWluY2x1ZGUgdGhlIHRlbXBsYXRlJ3MgdmFsdWVz" + - "IGZpbGVzIHNpbmNlIGB2YWx1ZXNgIGlzIGEgbGlzdCB0aGF0IGdldHMgcmVwbGFjZWQuCgojIyBW" + - "YWx1ZXMgUHJlY2VkZW5jZQoKRnJvbSBsb3dlc3QgdG8gaGlnaGVzdCBwcmlvcml0eToKCjEuIGBl" + - "bnZpcm9ubWVudHMvYmFzZS55YW1sYCAtLSBkZWZhdWx0cyBzaGFyZWQgYWNyb3NzIGFsbCBlbnZp" + - "cm9ubWVudHMKMi4gYGVudmlyb25tZW50cy88ZW52Pi55YW1sYCAtLSBwZXItZW52aXJvbm1lbnQg" + - "b3ZlcnJpZGVzCjMuIGBnbG9iYWwueWFtbC5nb3RtcGxgIC0tIEdvIHRlbXBsYXRlIHByb2Nlc3Np" + - "bmcgKGNvbnN0cnVjdHMgY2hhcnQtc3BlY2lmaWMgc3RydWN0dXJlKQo0LiBgPHByaXZhdGUtdmFs" + - "dWVzPi88ZW52Pi1zZWNyZXRzLnlhbWxgIC0tIHNlbnNpdGl2ZSB2YWx1ZXMKNS4gSW5saW5lIGB2" + - "YWx1ZXM6YCBibG9ja3Mgb24gcmVsZWFzZXMgLS0gaGlnaGVzdCBwcmVjZWRlbmNlCgojIyBXaGF0" + - "IGdsb2JhbC55YW1sLmdvdG1wbCBQYXNzZXMgVGhyb3VnaAoKYGdsb2JhbC55YW1sLmdvdG1wbGAg" + - "cmVhZHMgZnJvbSBgLlZhbHVlc2AgKHRoZSBtZXJnZWQgZW52aXJvbm1lbnQgKyBlbnYtc3BlY2lm" + - "aWMgWUFNTCkgYW5kIGNvbnN0cnVjdHMgY2hhcnQtc3BlY2lmaWMgdmFsdWVzLiBJdCBvbmx5IHBh" + - "c3NlcyB0aHJvdWdoIGtleXMgaXQgZXhwbGljaXRseSByZWZlcmVuY2VzOgoKIyMjIENhc3NhbmRy" + - "YQotIGBjYXNzYW5kcmEucmVwbGljYUNvdW50YAotIGBjYXNzYW5kcmEuaW1hZ2UuKmAgKHJlZ2lz" + - "dHJ5LCByZXBvc2l0b3J5KQotIGBjYXNzYW5kcmEubWlncmF0aW9ucy5pbWFnZS4qYAotIGBjYXNz" + - "YW5kcmEucGVyc2lzdGVuY2Uuc2l6ZWAKLSBgY2Fzc2FuZHJhLm5vZGVTZWxlY3RvcmAgKGlmIGBn" + - "bG9iYWwubm9kZVNlbGVjdG9ycy5lbmFibGVkYCkKLSBgY2Fzc2FuZHJhLmdsb2JhbC5kZWZhdWx0" + - "U3RvcmFnZUNsYXNzYAoKIyMjIE5BVFMKLSBgbmF0cy5jb250YWluZXIuaW1hZ2UuKmAKLSBgbmF0" + - "cy5yZWxvYWRlci5pbWFnZS4qYAotIGBuYXRzLm5hdHNCb3guY29udGFpbmVyLmltYWdlLipgCi0g" + - "YG5hdHMuY29uZmlnLmpldHN0cmVhbS5maWxlU3RvcmUucHZjLnN0b3JhZ2VDbGFzc05hbWVgCi0g" + - "YG5hdHMucG9kVGVtcGxhdGUubWVyZ2Uuc3BlYy5ub2RlU2VsZWN0b3JgIChpZiBlbmFibGVkKQoK" + - "IyMjIE9wZW5CYW8KLSBgb3BlbmJhby5taWdyYXRpb25zLmltYWdlLipgIGFuZCBgb3BlbmJhby5t" + - "aWdyYXRpb25zLmVudmAKLSBgb3BlbmJhby5pbmplY3Rvci5pbWFnZS4qYAotIGBvcGVuYmFvLnNl" + - "cnZlci5pbWFnZS4qYAotIGBvcGVuYmFvLnNlcnZlci5kYXRhU3RvcmFnZS4qYAotIE5vZGUgc2Vs" + - "ZWN0b3JzIChpZiBlbmFibGVkKQoKIyMjIFNlcnZpY2VzIChBUEksIFNJUywgZXRjLikKLSBgPHNl" + - "cnZpY2U+LmltYWdlLipgIChyZWdpc3RyeSwgcmVwb3NpdG9yeSkKLSBgPHNlcnZpY2U+Lm5vZGVT" + - "ZWxlY3RvcmAgKGlmIGVuYWJsZWQpCi0gYDxzZXJ2aWNlPi5lbnYuKmAgKG9ic2VydmFiaWxpdHkg" + - "c2V0dGluZ3MpCgojIyMgTExNIEZ1bmN0aW9uIEVuYWJsZW1lbnQKCkVuYWJsZSB0aGUgTExNIGFk" + - "ZG9uIGJlZm9yZSBjcmVhdGluZyBvciBpbnZva2luZyBmdW5jdGlvbnMgd2l0aApgZnVuY3Rpb25U" + - "eXBlOiAiTExNImAuIFRoZSBhZGRvbiBkZXBsb3lzIGBsbG0tcmVxdWVzdC1yb3V0ZXJgIGFuZApg" + - "bGxtLWFwaS1nYXRld2F5YCwgYWRkcyB0aGUgYGxsbS5pbnZvY2F0aW9uLjxkb21haW4+YCByb3V0" + - "ZSB3aGVuIEdhdGV3YXkgQVBJCmluZ3Jlc3MgaXMgZW5hYmxlZCwgYW5kIGNvbmZpZ3VyZXMgd29y" + - "a2VycyB0byB1c2UgdGhlIExMTSBzaWRlY2FyLiBUaGUgSGVsbWZpbGUKY29uZGl0aW9uIGlzIGBh" + - "ZGRvbnMubGxtLmVuYWJsZWRgLiBEbyBub3QgdXNlIHRoZSBvYnNvbGV0ZSBgbGxtLmVuYWJsZWRg" + - "IHBhdGguCgpGb3IgYSBzaW5nbGUtbm9kZSBpc29sYXRlZCB0ZXN0IGNsdXN0ZXIsIGFkZCB0aGlz" + - "IGNvbmZpZ3VyYXRpb24gdG8KYGVudmlyb25tZW50cy88ZW52Pi55YW1sYCBiZWZvcmUgYXBwbHlp" + - "bmcgdGhlIHN0YWNrOgoKYGBgeWFtbAphZGRvbnM6CiAgbGxtOgogICAgZW5hYmxlZDogdHJ1ZQog" + - "ICAgZ2F0ZXdheToKICAgICAgcmVwbGljYUNvdW50OiAxCiAgICAgIGF1dGg6CiAgICAgICAgZ3Jw" + - "Y0luc2VjdXJlOiB0cnVlCiAgICAgIG1ldHJpY3M6CiAgICAgICAgc2VydmljZU1vbml0b3I6CiAg" + - "ICAgICAgICBlbmFibGVkOiBmYWxzZQogICAgcmVxdWVzdFJvdXRlcjoKICAgICAgcmVwbGljYUNv" + - "dW50OiAxCiAgICAgIG1ldHJpY3M6CiAgICAgICAgc2VydmljZU1vbml0b3I6CiAgICAgICAgICBl" + - "bmFibGVkOiBmYWxzZQoKYWdlbnRDb25maWc6CiAgbWVyZ2VDb25maWc6IHwKICAgIGNsdXN0ZXI6" + - "CiAgICAgIHZhbGlkYXRpb25Qb2xpY3k6CiAgICAgICAgbmFtZTogVW5yZXN0cmljdGVkCiAgICB3" + - "b3JrbG9hZDoKICAgICAgc3RhcmdhdGVRVUlDSW5zZWN1cmU6IHRydWUKYGBgCgpVc2UgYHJlcGxp" + - "Y2FDb3VudDogMWAgb25seSBmb3IgbG9jYWwgb3Igc2luZ2xlLW5vZGUgdGVzdCBjbHVzdGVycy4g" + - "Rm9yIHNoYXJlZApvciBwcm9kdWN0aW9uIGNsdXN0ZXJzLCB1c2UgdGhlIHJlcXVpcmVkIHJlcGxp" + - "Y2EgY291bnQgYW5kIFRMUy1jYXBhYmxlIHNlcnZpY2UKY29uZmlndXJhdGlvbi4gYGFkZG9ucy5s" + - "bG0uZ2F0ZXdheS5hdXRoLmdycGNJbnNlY3VyZWAgYW5kCmB3b3JrbG9hZC5zdGFyZ2F0ZVFVSUNJ" + - "bnNlY3VyZWAgZW5hYmxlIHBsYWludGV4dCB0cmFuc3BvcnRzLiBEbyBub3QgdXNlIHRoZW0gaW4K" + - "cHJvZHVjdGlvbi4KClRoZSByZXF1ZXN0IHJvdXRlciB1c2VzIGBwb3dlci1vZi10d29gIHdoZW4g" + - "bm8gbG9hZC1iYWxhbmNlciBjb25maWd1cmF0aW9uIGlzCnNldC4gQ29uZmlndXJlIG90aGVyIHJv" + - "dXRpbmcgbWV0aG9kcyB3aXRoIHRoZQpbTExNIFJlcXVlc3QgUm91dGVyIExvYWQgQmFsYW5jaW5n" + - "XShodHRwczovL2dpdGh1Yi5jb20vTlZJRElBL252Y2YvYmxvYi9tYWluL2RvY3MvdXNlci9sbG0t" + - "cmVxdWVzdC1yb3V0ZXItbG9hZC1iYWxhbmNpbmcubWQpCmd1aWRlLgoKSWYgdGhlIHNpZGVjYXIg" + - "aW1hZ2UgaXMgbWlycm9yZWQgb3V0c2lkZSB0aGUgc3RhY2sncyBkZWZhdWx0IGltYWdlIHJlZ2lz" + - "dHJ5IGFuZApyZXBvc2l0b3J5LCBzZXQgdGhlIGdlbmVyYXRlZCB3b3JrZXIgc2lkZWNhciBpbWFn" + - "ZSBleHBsaWNpdGx5OgoKYGBgeWFtbAphcGk6CiAgZW52OgogICAgTlZDRl9TSURFQ0FSU19MTE1f" + - "Uk9VVEVSX0NMSUVOVF9JTUFHRTogPHJlZ2lzdHJ5Pi88cmVwb3NpdG9yeT4vcHlsb246MC4yLjEK" + - "YGBgCgpSZW5kZXIgYW5kIGFwcGx5IHRoZSB1cGRhdGVkIGNvbnRyb2wtcGxhbmUgZW52aXJvbm1l" + - "bnQsIHRoZW4gcmVmcmVzaCBldmVyeQpyZWdpc3RlcmVkIGNvbXB1dGUgcGxhbmUgdXNpbmcgdGhl" + - "IHNhbWUgaGFuZG9mZiB1c2VkIGZvciBpdHMgaW5zdGFsbGF0aW9uIHNvCk5WQ0EgcmVjZWl2ZXMg" + - "YGFnZW50Q29uZmlnLm1lcmdlQ29uZmlnYDoKCmBgYGJhc2gKSEVMTUZJTEVfRU5WPTxlbnY+IGhl" + - "bG1maWxlIHRlbXBsYXRlCkhFTE1GSUxFX0VOVj08ZW52PiBoZWxtZmlsZSBzeW5jCmBgYAoKVXNl" + - "IHRoZSBjb21wbGV0ZSBjb21wdXRlLXBsYW5lIGluc3RhbGwgY29tbWFuZCBmcm9tCltTcGxpdCBD" + - "b21wdXRlLVBsYW5lIEluc3RhbGxhdGlvbl0oY29tcHV0ZS1wbGFuZS1pbnN0YWxsYXRpb24ubWQp" + - "LiBBCkNMSS1wcm9maWxlIGluc3RhbGxhdGlvbiBtdXN0IHJlbWFpbiBwcm9maWxlLWRyaXZlbjsg" + - "YSBIZWxtZmlsZSBpbnN0YWxsYXRpb24KbXVzdCByZW1haW4gdmFsdWVzLWRyaXZlbi4KCkV4aXN0" + - "aW5nIExMTSBmdW5jdGlvbiBwb2RzIGtlZXAgdGhlaXIgZXhpc3Rpbmcgc2lkZWNhciBhcmd1bWVu" + - "dHMuIFJlY3JlYXRlIG9yCnJlZGVwbG95IHRob3NlIGZ1bmN0aW9ucyBhZnRlciB0aGUgY29tcHV0" + - "ZS1wbGFuZSByZWZyZXNoLiBWZXJpZnkgdGhlIGNvbnRyb2wKcGxhbmUsIHJvdXRlLCBhbmQgd29y" + - "a2VyIHNpZGVjYXI6CgpgYGBiYXNoCmt1YmVjdGwgZ2V0IGRlcGxveSAtbiBudmNmIGxsbS1hcGkt" + - "Z2F0ZXdheQprdWJlY3RsIGdldCBzdGF0ZWZ1bHNldCAtbiBudmNmIGxsbS1yZXF1ZXN0LXJvdXRl" + - "cgprdWJlY3RsIGdldCBwb2RzIC1uIG52Y2YgfCBncmVwIC1FICdsbG0tYXBpLWdhdGV3YXl8bGxt" + - "LXJlcXVlc3Qtcm91dGVyJwprdWJlY3RsIGdldCBodHRwcm91dGUgLUEgfCBncmVwIGxsbQprdWJl" + - "Y3RsIC1uIG52Y2YtYmFja2VuZCBnZXQgcG9kIDxmdW5jdGlvbi1wb2Q+IFwKICAtbyBqc29ucGF0" + - "aD0ne3JhbmdlIC5zcGVjLmNvbnRhaW5lcnNbPyhALm5hbWU9PSJsbG0td29ya2VyIildLmFyZ3Nb" + - "Kl19ey59eyJcXG4ifXtlbmR9JwpgYGAKCkZvciBsb2NhbCBwbGFpbnRleHQgY2x1c3RlcnMsIHRo" + - "ZSBgbGxtLXdvcmtlcmAgYXJncyBtdXN0IGluY2x1ZGUKYC0tcXVpYy1pbnNlY3VyZWAuCgpGb3Ig" + - "bG9hZC1iYWxhbmNlciBzY2hlbWEgYW5kIGFsZ29yaXRobSBiZWhhdmlvciwgc2VlIHRoZQpbU3Rh" + - "cmdhdGUgY29uZmlndXJhdGlvbiBndWlkZV0oaHR0cHM6Ly9naXRodWIuY29tL05WSURJQS9udmNm" + - "L2Jsb2IvbWFpbi9zcmMvbGlicmFyaWVzL3J1c3Qvc3RhcmdhdGUvZG9jcy9sb2FkLWJhbGFuY2Vy" + - "LWNvbmZpZ3VyYXRpb24ubWQpLgoKIyMgSGVsbWZpbGUgU2VsZWN0b3JzCgpUYXJnZXQgc3BlY2lm" + - "aWMgcmVsZWFzZXMgb3IgZ3JvdXBzOgoKYGBgYmFzaAojIEJ5IHJlbGVhc2UgZ3JvdXAKSEVMTUZJ" + - "TEVfRU5WPTxlbnY+IGhlbG1maWxlIC0tc2VsZWN0b3IgcmVsZWFzZS1ncm91cD1kZXBlbmRlbmNp" + - "ZXMgc3luYwpIRUxNRklMRV9FTlY9PGVudj4gaGVsbWZpbGUgLS1zZWxlY3RvciByZWxlYXNlLWdy" + - "b3VwPXNlcnZpY2VzIHN5bmMKSEVMTUZJTEVfRU5WPTxlbnY+IGhlbG1maWxlIC0tc2VsZWN0b3Ig" + - "cmVsZWFzZS1ncm91cD1pbmdyZXNzIHN5bmMKSEVMTUZJTEVfRU5WPTxlbnY+IGhlbG1maWxlIC0t" + - "c2VsZWN0b3IgcmVsZWFzZS1ncm91cD1vYnNlcnZhYmlsaXR5IHN5bmMKCiMgQnkgcmVsZWFzZSBu" + - "YW1lCkhFTE1GSUxFX0VOVj08ZW52PiBoZWxtZmlsZSAtLXNlbGVjdG9yIG5hbWU9Y2Fzc2FuZHJh" + - "IHN5bmMKSEVMTUZJTEVfRU5WPTxlbnY+IGhlbG1maWxlIC0tc2VsZWN0b3IgbmFtZT1hZG1pbi1p" + - "c3N1ZXItcHJveHkgc3luYwpIRUxNRklMRV9FTlY9PGVudj4gaGVsbWZpbGUgLS1zZWxlY3RvciBu" + - "YW1lPWxsbS1yZXF1ZXN0LXJvdXRlciBzeW5jCkhFTE1GSUxFX0VOVj08ZW52PiBoZWxtZmlsZSAt" + - "LXNlbGVjdG9yIG5hbWU9bGxtLWFwaS1nYXRld2F5IHN5bmMKCiMgVGVtcGxhdGUgb25seSAoZHJ5" + - "IHJ1bikKSEVMTUZJTEVfRU5WPTxlbnY+IGhlbG1maWxlIC0tc2VsZWN0b3IgbmFtZT1jYXNzYW5k" + - "cmEgdGVtcGxhdGUKCiMgRGVzdHJveSBhIHNpbmdsZSByZWxlYXNlCkhFTE1GSUxFX0VOVj08ZW52" + - "PiBoZWxtZmlsZSAtLXNlbGVjdG9yIG5hbWU9Y2Fzc2FuZHJhIGRlc3Ryb3kKYGBgCgpOb3RlOiBg" + - "YWRtaW4taXNzdWVyLXByb3h5YCBoYXMgbm8gYHJlbGVhc2UtZ3JvdXBgIGxhYmVsLiBVc2UgYC0t" + - "c2VsZWN0b3IgbmFtZT1hZG1pbi1pc3N1ZXItcHJveHlgLgpQSwcIwFYg548nAACPJwAAUEsDBBQA" + - "CAAAAAAAIQAAAAAAAAAAAAAAAAA/AAkAZGF0YS9udmNmLXNlbGYtbWFuYWdlZC1pbnN0YWxsYXRp" + - "b24vcmVmZXJlbmNlcy9udmNmLXVpLWFkZG9uLm1kVVQFAAEAps4SIyBOVkNGIFVJIEFkZG9uCgpO" + - "VkNGIFVJIGlzIGFuIG9wdGlvbmFsLCBjdXN0b21lci1mYWNpbmcgTlZDRiBhZG1pbi1wYW5lbCBV" + - "SS4gSXQgaXMgZGlzYWJsZWQgYnkKZGVmYXVsdCBhbmQgYXZhaWxhYmxlIG9ubHkgaW4gc3RhY2sg" + - "cGFja2FnZXMgdGhhdCBpbmNsdWRlIHRoZSBOVkNGIFVJIGFkZG9uLgoKIyMgV2hlbiB0byBlbmFi" + - "bGUKCkVuYWJsZSBOVkNGIFVJIG9ubHkgd2hlbiB5b3UgbmVlZCB0aGUgYWRtaW4tcGFuZWwgVUkg" + - "YW5kIHlvdXIgZXh0cmFjdGVkIHN0YWNrCnBhY2thZ2UgaW5jbHVkZXMgdGhlIGFkZG9uLiBJZiB0" + - "aGUgcGFja2FnZSBkb2VzIG5vdCBjb250YWluIGEgYG52Y2YtdWlgIHJlbGVhc2UKYW5kIGBudmNm" + - "VWlgIHJvdXRlIHZhbHVlcywgc2tpcCB0aGUgYWRkb24gdW50aWwgeW91IHVzZSBhIHBhY2thZ2Ug" + - "dGhhdCBpbmNsdWRlcwp0aGVtLgoKIyMgRW5hYmxlIHRoZSBhZGRvbgoKRW5hYmxlIGl0IGluIGBl" + - "bnZpcm9ubWVudHMvPGVudi1uYW1lPi55YW1sYDoKCmBgYHlhbWwKYWRkb25zOgogIG52Y2ZVaToK" + - "ICAgIGVuYWJsZWQ6IHRydWUKYGBgCgojIyBDcmVhdGUgbmFtZXNwYWNlIGFuZCBpbWFnZSBwdWxs" + - "IHNlY3JldAoKQ3JlYXRlIHRoZSBuYW1lc3BhY2UsIGFuZCBhbiBpbWFnZSBwdWxsIHNlY3JldCBv" + - "bmx5IGlmIHB1bGxpbmcgZnJvbSBhIHByaXZhdGUKcmVnaXN0cnk6CgpgYGBiYXNoCmt1YmVjdGwg" + - "Y3JlYXRlIG5hbWVzcGFjZSBudmNmLXVpIC0tZHJ5LXJ1bj1jbGllbnQgLW8geWFtbCB8IGt1YmVj" + - "dGwgYXBwbHkgLWYgLQoKIyBPbmx5IGlmIHB1bGxpbmcgZnJvbSBhIHByaXZhdGUgcmVnaXN0cnkg" + - "KGUuZy4sIE5HQyBudmNyLmlvKQpleHBvcnQgTkdDX0FQSV9LRVk9Ijx5b3VyLWtleT4iCmt1YmVj" + - "dGwgY3JlYXRlIHNlY3JldCBkb2NrZXItcmVnaXN0cnkgbnZjci1jcmVkcyBcCiAgLS1kb2NrZXIt" + - "c2VydmVyPW52Y3IuaW8gXAogIC0tZG9ja2VyLXVzZXJuYW1lPSckb2F1dGh0b2tlbicgXAogIC0t" + - "ZG9ja2VyLXBhc3N3b3JkPSIkTkdDX0FQSV9LRVkiIFwKICAtLW5hbWVzcGFjZT1udmNmLXVpIFwK" + - "ICAtLWRyeS1ydW49Y2xpZW50IC1vIHlhbWwgfCBrdWJlY3RsIGFwcGx5IC1mIC0KYGBgCgpUaGUg" + - "ZGVmYXVsdCByb3V0ZSBob3N0IGlzIGBudmNmLXVpLjxkb21haW4+YCBhbmQgdGhlIGJhY2tlbmQg" + - "aXMKYG52Y2YtdWkubnZjZi11aTo4MzAwYC4KCiMjIEFwcGx5IHRoZSBzZXJ2aWNlIGFuZCByb3V0" + - "ZQoKQWZ0ZXIgY29uZmlybWluZyB0aGUgcGFja2FnZSBpbmNsdWRlcyB0aGUgYG52Y2YtdWlgIHJl" + - "bGVhc2UsIHByZXZpZXcgYW5kIGFwcGx5CnRoZSBzZXJ2aWNlIGFuZCByb3V0ZToKCmBgYGJhc2gK" + - "SEVMTUZJTEVfRU5WPTxlbnYtbmFtZT4gaGVsbWZpbGUgLS1zZWxlY3RvciBuYW1lPW52Y2YtdWkg" + - "dGVtcGxhdGUKSEVMTUZJTEVfRU5WPTxlbnYtbmFtZT4gaGVsbWZpbGUgLS1zZWxlY3RvciBuYW1l" + - "PW52Y2YtdWkgc3luYwpIRUxNRklMRV9FTlY9PGVudi1uYW1lPiBoZWxtZmlsZSAtLXNlbGVjdG9y" + - "IHJlbGVhc2UtZ3JvdXA9aW5ncmVzcyBzeW5jCmBgYAoKIyMgVmVyaWZ5CgpWZXJpZnkgdGhlIHJv" + - "dXRlIG9ubHkgd2hlbiB0aGUgYWRkb24gaXMgcHJlc2VudCBhbmQgZW5hYmxlZDoKCmBgYGJhc2gK" + - "a3ViZWN0bCBnZXQgZGVwbG95LHN2YyAtbiBudmNmLXVpCmt1YmVjdGwgZ2V0IGh0dHByb3V0ZSAt" + - "QSB8IGdyZXAgLWkgbnZjZi11aQpjdXJsIC1pIC1IICJIb3N0OiBudmNmLXVpLjxkb21haW4+IiAi" + - "aHR0cDovLzxnYXRld2F5LWFkZHJlc3M+L3N0YXR1cyIKYGBgCgojIyBTZWN1cml0eQoKVGhlIE5W" + - "Q0YgVUkgYWRtaW4gcGFuZWwgaXMgY3VycmVudGx5IHVuYXV0aGVudGljYXRlZC4gRG8gbm90IGV4" + - "cG9zZSBpdCB0byB0aGUKcHVibGljIGludGVybmV0LiBSZXN0cmljdCBhY2Nlc3MgdG8gYSB0cnVz" + - "dGVkIG5ldHdvcmssIFZQTiwgb3IgYW4gYXV0aGVudGljYXRpbmcKcHJveHkgaW4gZnJvbnQgb2Yg" + - "dGhlIGBudmNmLXVpYCByb3V0ZS4KUEsHCDj5J6+5BwAAuQcAAFBLAwQUAAgAAAAAACEAAAAAAAAA" + - "AAAAAAAAPgAJAGRhdGEvbnZjZi1zZWxmLW1hbmFnZWQtaW5zdGFsbGF0aW9uL3JlZmVyZW5jZXMv" + - "cHVsbC1zZWNyZXRzLm1kVVQFAAEAps4SIyBJbWFnZSBQdWxsIFNlY3JldHMgUmVmZXJlbmNlCgoj" + - "IyBPdmVydmlldwoKV2hlbiBwdWxsaW5nIE5WQ0YgaW1hZ2VzIGZyb20gYSBwcml2YXRlIHJlZ2lz" + - "dHJ5IChmb3IgZXhhbXBsZSwgTkdDCmBudmNyLmlvYCksIEt1YmVybmV0ZXMgbmVlZHMgYGltYWdl" + - "UHVsbFNlY3JldHNgIG9uIGV2ZXJ5IHBvZC4gQ29udHJvbC1wbGFuZSBhbmQKY29tcHV0ZS1wbGFu" + - "ZSBjcmVkZW50aWFscyBhcmUgY29uZmlndXJlZCBpbiB0aGVpciBvd24gY2x1c3RlciBjb250ZXh0" + - "cy4gRG8gbm90CnVzZSBvbmUgbWl4ZWQgbmFtZXNwYWNlIGxpc3QuCgpUaGUgcmVjb21tZW5kZWQg" + - "Y29udHJvbC1wbGFuZSBhcHByb2FjaCB1c2VzIEt5dmVybm8gdG8gaW5qZWN0IHRoZSBzZWNyZXQg" + - "aW50bwpjb250cm9sLXBsYW5lIHBvZHMgYXQgYWRtaXNzaW9uIHRpbWUuIFRoZSBjb21wdXRlLXBs" + - "YW5lIGNoYXJ0IGFuZCBvcGVyYXRvciB1c2UKdGhlIHNlY3JldCBpbiBgbnZjYS1vcGVyYXRvcmAg" + - "YW5kIG1pcnJvciBpdCB0byBgbnZjYS1zeXN0ZW1gLgoKIyMgS3l2ZXJubyBBcHByb2FjaCAoUmVj" + - "b21tZW5kZWQpCgojIyMgMS4gSW5zdGFsbCBLeXZlcm5vCgpgYGBiYXNoCmhlbG0gcmVwbyBhZGQg" + - "a3l2ZXJubyBodHRwczovL2t5dmVybm8uZ2l0aHViLmlvL2t5dmVybm8vCmhlbG0gcmVwbyB1cGRh" + - "dGUKaGVsbSBpbnN0YWxsIGt5dmVybm8ga3l2ZXJuby9reXZlcm5vIC1uIGt5dmVybm8gLS1jcmVh" + - "dGUtbmFtZXNwYWNlIFwKICAtLWt1YmUtY29udGV4dCA8Y29udHJvbC1wbGFuZS1jb250ZXh0Pgpg" + - "YGAKCiMjIyAyLiBDcmVhdGUgY29udHJvbC1wbGFuZSBwdWxsIHNlY3JldHMKCmBgYGJhc2gKZXhw" + - "b3J0IE5HQ19BUElfS0VZPSI8eW91ci1uZ2MtYXBpLWtleT4iCgpmb3IgbnMgaW4gY2Fzc2FuZHJh" + - "LXN5c3RlbSBuYXRzLXN5c3RlbSBudmNmIGFwaS1rZXlzIGVzcyBzaXMgdmF1bHQtc3lzdGVtIGNl" + - "cnQtbWFuYWdlcjsgZG8KICBrdWJlY3RsIC0tY29udGV4dCA8Y29udHJvbC1wbGFuZS1jb250ZXh0" + - "PiBjcmVhdGUgbmFtZXNwYWNlICIkbnMiIFwKICAgIC0tZHJ5LXJ1bj1jbGllbnQgLW8geWFtbCB8" + - "IGt1YmVjdGwgLS1jb250ZXh0IDxjb250cm9sLXBsYW5lLWNvbnRleHQ+IGFwcGx5IC1mIC0KZG9u" + - "ZQoKZm9yIG5zIGluIGNhc3NhbmRyYS1zeXN0ZW0gbmF0cy1zeXN0ZW0gbnZjZiBhcGkta2V5cyBl" + - "c3Mgc2lzIHZhdWx0LXN5c3RlbSBjZXJ0LW1hbmFnZXI7IGRvCiAga3ViZWN0bCAtLWNvbnRleHQg" + - "PGNvbnRyb2wtcGxhbmUtY29udGV4dD4gY3JlYXRlIHNlY3JldCBkb2NrZXItcmVnaXN0cnkgbnZj" + - "ci1jcmVkcyBcCiAgICAtLWRvY2tlci1zZXJ2ZXI9bnZjci5pbyBcCiAgICAtLWRvY2tlci11c2Vy" + - "bmFtZT0nJG9hdXRodG9rZW4nIFwKICAgIC0tZG9ja2VyLXBhc3N3b3JkPSIkTkdDX0FQSV9LRVki" + - "IFwKICAgIC0tbmFtZXNwYWNlPSIkbnMiIFwKICAgIC0tZHJ5LXJ1bj1jbGllbnQgLW8geWFtbCB8" + - "IGt1YmVjdGwgLS1jb250ZXh0IDxjb250cm9sLXBsYW5lLWNvbnRleHQ+IGFwcGx5IC1mIC0KZG9u" + - "ZQpgYGAKCkZvciBub24tTkdDIHJlZ2lzdHJpZXMsIHJlcGxhY2UgYC0tZG9ja2VyLXNlcnZlcmAs" + - "IGAtLWRvY2tlci11c2VybmFtZWAsIGFuZCBgLS1kb2NrZXItcGFzc3dvcmRgLgoKIyMjIDMuIEFw" + - "cGx5IEt5dmVybm8gQ2x1c3RlclBvbGljeQoKYGBgeWFtbAphcGlWZXJzaW9uOiBreXZlcm5vLmlv" + - "L3YxCmtpbmQ6IENsdXN0ZXJQb2xpY3kKbWV0YWRhdGE6CiAgbmFtZTogbnZjZi1hZGQtaW1hZ2Vw" + - "dWxsc2VjcmV0cwpzcGVjOgogIGJhY2tncm91bmQ6IGZhbHNlCiAgcnVsZXM6CiAgICAtIG5hbWU6" + - "IGFkZC1pbWFnZXB1bGxzZWNyZXQtdG8tbnZjZi1wb2RzCiAgICAgIG1hdGNoOgogICAgICAgIGFu" + - "eToKICAgICAgICAtIHJlc291cmNlczoKICAgICAgICAgICAga2luZHM6CiAgICAgICAgICAgIC0g" + - "UG9kCiAgICAgICAgICAgIG5hbWVzcGFjZXM6CiAgICAgICAgICAgIC0gIm52Y2YiCiAgICAgICAg" + - "ICAgIC0gImFwaS1rZXlzIgogICAgICAgICAgICAtICJzaXMiCiAgICAgICAgICAgIC0gImVzcyIK" + - "ICAgICAgICAgICAgLSAibmF0cy1zeXN0ZW0iCiAgICAgICAgICAgIC0gImNhc3NhbmRyYS1zeXN0" + - "ZW0iCiAgICAgICAgICAgIC0gInZhdWx0LXN5c3RlbSIKICAgICAgICAgICAgLSAiY2VydC1tYW5h" + - "Z2VyIgogICAgICBtdXRhdGU6CiAgICAgICAgcGF0Y2hTdHJhdGVnaWNNZXJnZToKICAgICAgICAg" + - "IG1ldGFkYXRhOgogICAgICAgICAgICBhbm5vdGF0aW9uczoKICAgICAgICAgICAgICBudmNmLm52" + - "aWRpYS5jb20vaW1hZ2VwdWxsc2VjcmV0LWluamVjdGVkLWJ5OiBreXZlcm5vCiAgICAgICAgICBz" + - "cGVjOgogICAgICAgICAgICBpbWFnZVB1bGxTZWNyZXRzOgogICAgICAgICAgICAtIG5hbWU6IG52" + - "Y3ItY3JlZHMKYGBgCgpgYGBiYXNoCmt1YmVjdGwgLS1jb250ZXh0IDxjb250cm9sLXBsYW5lLWNv" + - "bnRleHQ+IGFwcGx5IFwKICAtZiBreXZlcm5vLWltYWdlcHVsbHNlY3JldC1wb2xpY3kueWFtbApg" + - "YGAKCiMjIyA0LiBJbnN0YWxsIHRoZSBjb250cm9sIHBsYW5lCgpDb250aW51ZSB3aXRoIHRoZSBz" + - "ZWxlY3RlZCBjb250cm9sLXBsYW5lIGluc3RhbGxhdGlvbiBpbgpbU3BsaXQgQ29tcHV0ZS1QbGFu" + - "ZSBJbnN0YWxsYXRpb25dKGNvbXB1dGUtcGxhbmUtaW5zdGFsbGF0aW9uLm1kKS4gTm8KY29udHJv" + - "bC1wbGFuZSBoZWxtZmlsZSBtb2RpZmljYXRpb25zIGFyZSBuZWVkZWQuIEt5dmVybm8gaW5qZWN0" + - "cyB0aGUgcHVsbApzZWNyZXQgaW50byBuZXcgY29udHJvbC1wbGFuZSBwb2RzLgoKIyMgQ29tcHV0" + - "ZS1QbGFuZSBTZWNyZXQKCkNyZWF0ZSB0aGUgc2VjcmV0IG9ubHkgaW4gYG52Y2Etb3BlcmF0b3Jg" + - "IG9uIHRoZSBjb21wdXRlIGNsdXN0ZXI6CgpgYGBiYXNoCmt1YmVjdGwgLS1jb250ZXh0IDxjb21w" + - "dXRlLXBsYW5lLWNvbnRleHQ+IGNyZWF0ZSBuYW1lc3BhY2UgbnZjYS1vcGVyYXRvciBcCiAgLS1k" + - "cnktcnVuPWNsaWVudCAtbyB5YW1sIHwgXAogIGt1YmVjdGwgLS1jb250ZXh0IDxjb21wdXRlLXBs" + - "YW5lLWNvbnRleHQ+IGFwcGx5IC1mIC0KCmt1YmVjdGwgLS1jb250ZXh0IDxjb21wdXRlLXBsYW5l" + - "LWNvbnRleHQ+IGNyZWF0ZSBzZWNyZXQgZG9ja2VyLXJlZ2lzdHJ5IG52Y3ItY3JlZHMgXAogIC0t" + - "ZG9ja2VyLXNlcnZlcj1udmNyLmlvIFwKICAtLWRvY2tlci11c2VybmFtZT0nJG9hdXRodG9rZW4n" + - "IFwKICAtLWRvY2tlci1wYXNzd29yZD0iJE5HQ19BUElfS0VZIiBcCiAgLS1uYW1lc3BhY2U9bnZj" + - "YS1vcGVyYXRvciBcCiAgLS1kcnktcnVuPWNsaWVudCAtbyB5YW1sIHwgXAogIGt1YmVjdGwgLS1j" + - "b250ZXh0IDxjb21wdXRlLXBsYW5lLWNvbnRleHQ+IGFwcGx5IC1mIC0KYGBgCgpSZWZlcmVuY2Ug" + - "aXQgaW4gdGhlIGNvbXB1dGUtcGxhbmUgZW52aXJvbm1lbnQgZmlsZToKCmBgYHlhbWwKZ2xvYmFs" + - "OgogIGltYWdlUHVsbFNlY3JldHM6CiAgICAtIG5hbWU6IG52Y3ItY3JlZHMKYGBgCgpUaGUgY2hh" + - "cnQgYW5kIG9wZXJhdG9yIHVzZSB0aGF0IHJlZmVyZW5jZSBpbiBgbnZjYS1vcGVyYXRvcmAgYW5k" + - "IG1pcnJvciB0aGUKc2VjcmV0IHRvIGBudmNhLXN5c3RlbWAuIERvIG5vdCBjcmVhdGUgYSBicm9h" + - "ZGVyIG1hbnVhbCBjb21wdXRlIG5hbWVzcGFjZSBsaXN0LiBGb2xsb3cKW1NwbGl0IENvbXB1dGUt" + - "UGxhbmUgSW5zdGFsbGF0aW9uXShjb21wdXRlLXBsYW5lLWluc3RhbGxhdGlvbi5tZCkgZm9yIHRo" + - "ZQpzZWxlY3RlZCBpbnN0YWxsIGZsb3cuCgojIyBWZXJpZmljYXRpb24KCmBgYGJhc2gKIyBDaGVj" + - "ayB0aGF0IGEgY29udHJvbC1wbGFuZSBwb2QgaGFzIHRoZSBpbmplY3RlZCBzZWNyZXQKa3ViZWN0" + - "bCAtLWNvbnRleHQgPGNvbnRyb2wtcGxhbmUtY29udGV4dD4gZ2V0IHBvZCAtbiA8bmFtZXNwYWNl" + - "PiA8cG9kLW5hbWU+IFwKICAtbyBqc29ucGF0aD0ney5zcGVjLmltYWdlUHVsbFNlY3JldHN9Jwoj" + - "IEV4cGVjdGVkOiBbeyJuYW1lIjoibnZjci1jcmVkcyJ9XQoKIyBDaGVjayB0aGUgS3l2ZXJubyBh" + - "bm5vdGF0aW9uCmt1YmVjdGwgLS1jb250ZXh0IDxjb250cm9sLXBsYW5lLWNvbnRleHQ+IGdldCBw" + - "b2QgLW4gPG5hbWVzcGFjZT4gPHBvZC1uYW1lPiBcCiAgLW8ganNvbnBhdGg9J3subWV0YWRhdGEu" + - "YW5ub3RhdGlvbnMubnZjZlwubnZpZGlhXC5jb20vaW1hZ2VwdWxsc2VjcmV0LWluamVjdGVkLWJ5" + - "fScKIyBFeHBlY3RlZDoga3l2ZXJubwoKIyBDaGVjayBwdWxsIGV2ZW50cwprdWJlY3RsIC0tY29u" + - "dGV4dCA8Y29udHJvbC1wbGFuZS1jb250ZXh0PiBnZXQgZXZlbnRzIC1uIDxuYW1lc3BhY2U+IFwK" + - "ICAtLXNvcnQtYnk9Jy5sYXN0VGltZXN0YW1wJyB8IGdyZXAgLWkgcHVsbAojIFNob3VsZCBzaG93" + - "ICJTdWNjZXNzZnVsbHkgcHVsbGVkIiBub3QgIjQwMSBVbmF1dGhvcml6ZWQiCgojIENoZWNrIHRo" + - "ZSBjaGFydC9vcGVyYXRvciBtaXJyb3Igb24gdGhlIGNvbXB1dGUgY2x1c3RlcgprdWJlY3RsIC0t" + - "Y29udGV4dCA8Y29tcHV0ZS1wbGFuZS1jb250ZXh0PiBnZXQgc2VjcmV0IG52Y3ItY3JlZHMgXAog" + - "IC1uIG52Y2Etc3lzdGVtCmBgYAoKIyMgV2hlbiBQdWxsIFNlY3JldHMgQXJlIE5vdCBOZWVkZWQK" + - "Ci0gKipBV1MgRUNSIHdpdGggSUFNIG5vZGUgcm9sZXMqKjogSWYgeW91ciBub2RlcyBoYXZlIGBB" + - "bWF6b25FQzJDb250YWluZXJSZWdpc3RyeVJlYWRPbmx5YCBJQU0gcG9saWN5LCBLdWJlcm5ldGVz" + - "IGNhbiBwdWxsIGZyb20gRUNSIHdpdGhvdXQgZXhwbGljaXQgc2VjcmV0cy4KLSAqKlB1YmxpYyBy" + - "ZWdpc3RyaWVzKio6IE5vIHB1bGwgc2VjcmV0cyBuZWVkZWQuCi0gKipDU1AgYnVpbHQtaW4gY3Jl" + - "ZGVudGlhbCBoZWxwZXJzKio6IEdLRSBBcnRpZmFjdCBSZWdpc3RyeSwgQXp1cmUgQUNSIHdpdGgg" + - "bWFuYWdlZCBpZGVudGl0eSwgYW5kIHNpbWlsYXIgc2VydmljZXMuCgojIyBUcm91Ymxlc2hvb3Rp" + - "bmcKCiMjIyBQb2RzIHN0aWxsIGluIEltYWdlUHVsbEJhY2tPZmYgYWZ0ZXIgYXBwbHlpbmcgcG9s" + - "aWN5CgpUaGUgS3l2ZXJubyBwb2xpY3kgb25seSBhZmZlY3RzIHBvZHMgY3JlYXRlZCAqKmFmdGVy" + - "KiogdGhlIHBvbGljeSBpcyBhcHBsaWVkLiBEZWxldGUgc3R1Y2sgcG9kcyB0byB0cmlnZ2VyIHJl" + - "Y3JlYXRpb246CgpgYGBiYXNoCmt1YmVjdGwgLS1jb250ZXh0IDx0YXJnZXQtY29udGV4dD4gZGVs" + - "ZXRlIHBvZHMgLW4gPG5hbWVzcGFjZT4gLS1hbGwKYGBgCgojIyMgS3l2ZXJubyBhZG1pc3Npb24g" + - "Y29udHJvbGxlciBub3QgcnVubmluZwoKYGBgYmFzaAprdWJlY3RsIC0tY29udGV4dCA8Y29udHJv" + - "bC1wbGFuZS1jb250ZXh0PiBnZXQgcG9kcyAtbiBreXZlcm5vCiMgQWxsIHBvZHMgc2hvdWxkIGJl" + - "IFJ1bm5pbmcKYGBgCgojIyMgUG9saWN5IG5vdCBtYXRjaGluZwoKYGBgYmFzaAprdWJlY3RsIC0t" + - "Y29udGV4dCA8Y29udHJvbC1wbGFuZS1jb250ZXh0PiBnZXQgY2x1c3RlcnBvbGljeSBudmNmLWFk" + - "ZC1pbWFnZXB1bGxzZWNyZXRzCiMgU2hvdWxkIHNob3cgUkVBRFk6IFRydWUKYGBgCgojIyMgV3Jv" + - "bmcgc2VjcmV0IG5hbWUKClRoZSBwb2xpY3kgcmVmZXJlbmNlcyBgbnZjci1jcmVkc2AuIFZlcmlm" + - "eSB0aGUgc2VjcmV0IGV4aXN0cyB3aXRoIHRoYXQgZXhhY3QgbmFtZToKCmBgYGJhc2gKa3ViZWN0" + - "bCAtLWNvbnRleHQgPHRhcmdldC1jb250ZXh0PiBnZXQgc2VjcmV0IG52Y3ItY3JlZHMgLW4gPG5h" + - "bWVzcGFjZT4KYGBgClBLBwhLQjWoABYAAAAWAABQSwECFAAUAAgAAAAAACEArXKWn0gQAABIEAAA" + - "EgAJAAAAAAAAAAAAAAAAAAAAZGF0YS9tYW5pZmVzdC5qc29uVVQFAAEAps4SUEsBAhQAFAAIAAAA" + - "AAAhAM2BMORNYQAATWEAACMACQAAAAAAAAAAAAAAkRAAAGRhdGEvbnZjZi1zZWxmLW1hbmFnZWQt" + - "Y2xpL1NLSUxMLm1kVVQFAAEAps4SUEsBAhQAFAAIAAAAAAAhACHGyIbwCgAA8AoAADMACQAAAAAA" + - "AAAAAAAAOHIAAGRhdGEvbnZjZi1zZWxmLW1hbmFnZWQtY2xpL2V4YW1wbGVzL2NpLXBpcGVsaW5l" + - "cy5tZFVUBQABAKbOElBLAQIUABQACAAAAAAAIQChFOOBXQwAAF0MAAA0AAkAAAAAAAAAAAAAAJJ9" + - "AABkYXRhL252Y2Ytc2VsZi1tYW5hZ2VkLWNsaS9leGFtcGxlcy9tdWx0aS1jbHVzdGVyLm1kVVQF" + - "AAEAps4SUEsBAhQAFAAIAAAAAAAhAEInSQ8FDQAABQ0AADcACQAAAAAAAAAAAAAAWooAAGRhdGEv" + - "bnZjZi1zZWxmLW1hbmFnZWQtY2xpL3Byb21wdHMvYWRkLWNvbXB1dGUtcGxhbmUubWRVVAUAAQCm" + - "zhJQSwECFAAUAAgAAAAAACEAkdwb+ZgZAACYGQAAOQAJAAAAAAAAAAAAAADNlwAAZGF0YS9udmNm" + - "LXNlbGYtbWFuYWdlZC1jbGkvcHJvbXB0cy9jcmVhdGUtYW5kLXJ1bi10YXNrLm1kVVQFAAEAps4S" + - "UEsBAhQAFAAIAAAAAAAhANJD3AQYJQAAGCUAADcACQAAAAAAAAAAAAAA1bEAAGRhdGEvbnZjZi1z" + - "ZWxmLW1hbmFnZWQtY2xpL3Byb21wdHMvZGVwbG95LWFuZC1pbnZva2UubWRVVAUAAQCmzhJQSwEC" + - "FAAUAAgAAAAAACEADpw/l70OAAC9DgAAPQAJAAAAAAAAAAAAAABb1wAAZGF0YS9udmNmLXNlbGYt" + - "bWFuYWdlZC1jbGkvcHJvbXB0cy9kaWFnbm9zZS1mYWlsZWQtaW5zdGFsbC5tZFVUBQABAKbOElBL" + - "AQIUABQACAAAAAAAIQBMx6uqdSQAAHUkAAA6AAkAAAAAAAAAAAAAAIzmAABkYXRhL252Y2Ytc2Vs" + - "Zi1tYW5hZ2VkLWNsaS9wcm9tcHRzL2luc3RhbGwtZnJvbS1zY3JhdGNoLm1kVVQFAAEAps4SUEsB" + - "AhQAFAAIAAAAAAAhABrELJ7HBwAAxwcAADkACQAAAAAAAAAAAAAAcgsBAGRhdGEvbnZjZi1zZWxm" + - "LW1hbmFnZWQtY2xpL3Byb21wdHMvcm90YXRlLWNsdXN0ZXItandrcy5tZFVUBQABAKbOElBLAQIU" + - "ABQACAAAAAAAIQASkzNZ4CEAAOAhAAAuAAkAAAAAAAAAAAAAAKkTAQBkYXRhL252Y2Ytc2VsZi1t" + - "YW5hZ2VkLWNsaS9wcm9tcHRzL3RlYXJkb3duLm1kVVQFAAEAps4SUEsBAhQAFAAIAAAAAAAhAHIN" + - "D2QhIwAAISMAADAACQAAAAAAAAAAAAAA7jUBAGRhdGEvbnZjZi1zZWxmLW1hbmFnZWQtY2xpL3Jl" + - "ZmVyZW5jZS9jb21tYW5kcy5tZFVUBQABAKbOElBLAQIUABQACAAAAAAAIQBzp1pk1QYAANUGAAAy" + - "AAkAAAAAAAAAAAAAAHZZAQBkYXRhL252Y2Ytc2VsZi1tYW5hZ2VkLWNsaS9yZWZlcmVuY2UvZXhp" + - "dC1jb2Rlcy5tZFVUBQABAKbOElBLAQIUABQACAAAAAAAIQD8o5HgxiIAAMYiAAAtAAkAAAAAAAAA" + - "AAAAALRgAQBkYXRhL252Y2Ytc2VsZi1tYW5hZ2VkLWNsaS9yZWZlcmVuY2UvZmxhZ3MubWRVVAUA" + - "AQCmzhJQSwECFAAUAAgAAAAAACEA864ThHQRAAB0EQAANwAJAAAAAAAAAAAAAADegwEAZGF0YS9u" + - "dmNmLXNlbGYtbWFuYWdlZC1jbGkvcmVmZXJlbmNlL3Ryb3VibGVzaG9vdGluZy5tZFVUBQABAKbO" + - "ElBLAQIUABQACAAAAAAAIQAv2rl1QmIAAEJiAAAsAAkAAAAAAAAAAAAAAMCVAQBkYXRhL252Y2Yt" + - "c2VsZi1tYW5hZ2VkLWluc3RhbGxhdGlvbi9TS0lMTC5tZFVUBQABAKbOElBLAQIUABQACAAAAAAA" + - "IQArE7g/rVUAAK1VAAA0AAkAAAAAAAAAAAAAAGX4AQBkYXRhL252Y2Ytc2VsZi1tYW5hZ2VkLWlu" + - "c3RhbGxhdGlvbi9ldmFscy9ldmFscy5qc29uVVQFAAEAps4SUEsBAhQAFAAIAAAAAAAhAAJSTkB/" + - "KAAAfygAAC8ACQAAAAAAAAAAAAAAfU4CAGRhdGEvbnZjZi1zZWxmLW1hbmFnZWQtaW5zdGFsbGF0" + - "aW9uL2V4YW1wbGVzLm1kVVQFAAEAps4SUEsBAhQAFAAIAAAAAAAhAJZjvFkSMAAAEjAAAEwACQAA" + - "AAAAAAAAAAAAYncCAGRhdGEvbnZjZi1zZWxmLW1hbmFnZWQtaW5zdGFsbGF0aW9uL3JlZmVyZW5j" + - "ZXMvY29tcHV0ZS1wbGFuZS1pbnN0YWxsYXRpb24ubWRVVAUAAQCmzhJQSwECFAAUAAgAAAAAACEA" + - "Vj5nkJUwAACVMAAAOwAJAAAAAAAAAAAAAAD3pwIAZGF0YS9udmNmLXNlbGYtbWFuYWdlZC1pbnN0" + - "YWxsYXRpb24vcmVmZXJlbmNlcy9kZWJ1Z2dpbmcubWRVVAUAAQCmzhJQSwECFAAUAAgAAAAAACEA" + - "wFYg548nAACPJwAARAAJAAAAAAAAAAAAAAD+2AIAZGF0YS9udmNmLXNlbGYtbWFuYWdlZC1pbnN0" + - "YWxsYXRpb24vcmVmZXJlbmNlcy9oZWxtZmlsZS1zdHJ1Y3R1cmUubWRVVAUAAQCmzhJQSwECFAAU" + - "AAgAAAAAACEAOPknr7kHAAC5BwAAPwAJAAAAAAAAAAAAAAAIAQMAZGF0YS9udmNmLXNlbGYtbWFu" + - "YWdlZC1pbnN0YWxsYXRpb24vcmVmZXJlbmNlcy9udmNmLXVpLWFkZG9uLm1kVVQFAAEAps4SUEsB" + - "AhQAFAAIAAAAAAAhAEtCNagAFgAAABYAAD4ACQAAAAAAAAAAAAAANwkDAGRhdGEvbnZjZi1zZWxm" + - "LW1hbmFnZWQtaW5zdGFsbGF0aW9uL3JlZmVyZW5jZXMvcHVsbC1zZWNyZXRzLm1kVVQFAAEAps4S" + - "UEsFBgAAAAAXABcArwkAAKwfAwAAAA==" + "bmUtY29udGV4dCA8Y29tcHV0ZS1wbGFuZS1jb250ZXh0PiBcCiAgaW5zdGFsbCAtLWNvbnRyb2wt" + + "cGxhbmUgXAogIC0tY2x1c3Rlci1uYW1lIDxjb250cm9sLXBsYW5lLWNsdXN0ZXItbmFtZT4gXAog" + + "IC0tcmVnaW9uIDxyZWdpb24+IFwKICAtLW5jYS1pZCA8bmNhLWlkPgoKdGVzdCAtcyBkZXBsb3kv" + + "c3RhY2tzL3NlbGYtbWFuYWdlZC9vdXQvY29udHJvbC1wbGFuZS1wcm9maWxlLnlhbWwKYGBgCgpV" + + "c2UgdGhlIGZ1bGwgcGVyc2lzdGVudCBwcmVmaXggZm9yIGJvdGggY29tcHV0ZS1wbGFuZSBjb21t" + + "YW5kczoKCmBgYGJhc2gKbnZjZi1jbGkgLS1jb25maWcgPGNvbmZpZz4gc2VsZi1ob3N0ZWQgXAog" + + "IC0tY29udHJvbC1wbGFuZS1zdGFjayBkZXBsb3kvc3RhY2tzL3NlbGYtbWFuYWdlZCBcCiAgLS1j" + + "b21wdXRlLXBsYW5lLXN0YWNrIGRlcGxveS9zdGFja3MvbnZjZi1jb21wdXRlLXBsYW5lIFwKICAt" + + "LWVudiA8ZW52PiBcCiAgLS1wbGFpbiBcCiAgY29tcHV0ZS1wbGFuZSByZWdpc3RlciBcCiAgLS1j" + + "b250cm9sLXBsYW5lLXByb2ZpbGUgZGVwbG95L3N0YWNrcy9zZWxmLW1hbmFnZWQvb3V0L2NvbnRy" + + "b2wtcGxhbmUtcHJvZmlsZS55YW1sIFwKICAtLWNsdXN0ZXItbmFtZSA8Y29tcHV0ZS1wbGFuZS1j" + + "bHVzdGVyLW5hbWU+IFwKICAtLWt1YmUtY29udGV4dCA8Y29tcHV0ZS1wbGFuZS1jb250ZXh0PiBc" + + "CiAgLS1yZWdpb24gPHJlZ2lvbj4gXAogIC0tb3V0cHV0IGRlcGxveS9zdGFja3MvbnZjZi1jb21w" + + "dXRlLXBsYW5lL291dC88Y29tcHV0ZS1wbGFuZS1jbHVzdGVyLW5hbWU+LXJlZ2lzdGVyLXZhbHVl" + + "cy55YW1sCgpudmNmLWNsaSAtLWNvbmZpZyA8Y29uZmlnPiBzZWxmLWhvc3RlZCBcCiAgLS1jb250" + + "cm9sLXBsYW5lLXN0YWNrIGRlcGxveS9zdGFja3Mvc2VsZi1tYW5hZ2VkIFwKICAtLWNvbXB1dGUt" + + "cGxhbmUtc3RhY2sgZGVwbG95L3N0YWNrcy9udmNmLWNvbXB1dGUtcGxhbmUgXAogIC0tZW52IDxl" + + "bnY+IFwKICAtLXBsYWluIFwKICBjb21wdXRlLXBsYW5lIGluc3RhbGwgXAogIC0tdmFsdWVzIGRl" + + "cGxveS9zdGFja3MvbnZjZi1jb21wdXRlLXBsYW5lL291dC88Y29tcHV0ZS1wbGFuZS1jbHVzdGVy" + + "LW5hbWU+LXJlZ2lzdGVyLXZhbHVlcy55YW1sIFwKICAtLWt1YmUtY29udGV4dCA8Y29tcHV0ZS1w" + + "bGFuZS1jb250ZXh0PiBcCiAgLS1jbHVzdGVyLW5hbWUgPGNvbXB1dGUtcGxhbmUtY2x1c3Rlci1u" + + "YW1lPgpgYGAKClJlZ2lzdHJhdGlvbiBzZWxlY3RzIHRoZSBwcm9maWxlJ3MgaW4tY2x1c3RlciBv" + + "ciBjb21wdXRlLXJlYWNoYWJsZSBlbmRwb2ludHMKZnJvbSB0aGUgY29tcHV0ZSBjb250ZXh0IGFu" + + "ZCBwcm9iZXMgaXRzIEpXS1MuIERvIG5vdCByZXBsYWNlIHByb2ZpbGUgZW5kcG9pbnRzCndpdGgg" + + "aGFuZC1hdXRob3JlZCBIZWxtZmlsZSBlbmRwb2ludCB2YWx1ZXMuCgojIyBQdWxsIFNlY3JldHMK" + + "CkNyZWF0ZSB0aGUgY29udHJvbC1wbGFuZSBzZWNyZXQgaW4gdGhlc2UgbmFtZXNwYWNlcyBvbiB0" + + "aGUgY29udHJvbC1wbGFuZQpjb250ZXh0OgoKYGBgdGV4dApjYXNzYW5kcmEtc3lzdGVtIG5hdHMt" + + "c3lzdGVtIG52Y2YgYXBpLWtleXMgZXNzIHNpcyB2YXVsdC1zeXN0ZW0gY2VydC1tYW5hZ2VyCmBg" + + "YAoKT24gdGhlIGNvbXB1dGUgY29udGV4dCwgY3JlYXRlIHRoZSBzZWNyZXQgb25seSBpbiBgbnZj" + + "YS1vcGVyYXRvcmAgYW5kIHJlZmVyZW5jZQppdCB0aHJvdWdoIGBnbG9iYWwuaW1hZ2VQdWxsU2Vj" + + "cmV0c2AgaW4gdGhlIGNvbXB1dGUtcGxhbmUgZW52aXJvbm1lbnQuIFRoZSBjaGFydAphbmQgb3Bl" + + "cmF0b3IgdXNlIGl0IGluIGBudmNhLW9wZXJhdG9yYCBhbmQgbWlycm9yIGl0IHRvIGBudmNhLXN5" + + "c3RlbWAuIERvIG5vdCBhZGQKZWl0aGVyIG5hbWVzcGFjZSB0byB0aGUgY29udHJvbC1wbGFuZSBs" + + "aXN0LiBGb3IgY29tbWFuZHMgYW5kIHBvbGljeSBleGFtcGxlcywKc2VlIFtwdWxsLXNlY3JldHMu" + + "bWRdKHB1bGwtc2VjcmV0cy5tZCkuCgojIyBWZXJpZmljYXRpb24KClVzZSB0aGUgZXhwbGljaXQg" + + "R2F0ZXdheSBuYW1lIGFuZCBuYW1lc3BhY2U6CgpgYGBiYXNoCmt1YmVjdGwgLS1jb250ZXh0IDxj" + + "b250cm9sLXBsYW5lLWNvbnRleHQ+IGdldCBnYXRld2F5IG52Y2YtZ2F0ZXdheSBcCiAgLW4gZW52" + + "b3ktZ2F0ZXdheSAtbyB3aWRlCmt1YmVjdGwgLS1jb250ZXh0IDxjb250cm9sLXBsYW5lLWNvbnRl" + + "eHQ+IGdldCB0Y3Byb3V0ZSAtbiBlbnZveS1nYXRld2F5Cmt1YmVjdGwgLS1jb250ZXh0IDxjb21w" + + "dXRlLXBsYW5lLWNvbnRleHQ+IHJvbGxvdXQgc3RhdHVzIFwKICBkZXBsb3ltZW50L252Y2Etb3Bl" + + "cmF0b3IgLW4gbnZjYS1vcGVyYXRvciAtLXRpbWVvdXQ9MTBtCmt1YmVjdGwgLS1jb250ZXh0IDxj" + + "b21wdXRlLXBsYW5lLWNvbnRleHQ+IHdhaXQgXAogIG52Y2ZiYWNrZW5kLzxjb21wdXRlLXBsYW5l" + + "LWNsdXN0ZXItbmFtZT4gLW4gbnZjYS1vcGVyYXRvciBcCiAgLS1mb3I9anNvbnBhdGg9J3suc3Rh" + + "dHVzLmFnZW50U3RhdHVzfSc9aGVhbHRoeSAtLXRpbWVvdXQ9MTBtCmt1YmVjdGwgLS1jb250ZXh0" + + "IDxjb21wdXRlLXBsYW5lLWNvbnRleHQ+IGdldCBzZWNyZXQgPHB1bGwtc2VjcmV0PiAtbiBudmNh" + + "LXN5c3RlbQpgYGAKCiMjIFRlYXJkb3duCgpEZXN0cm95IGFuZCBkZXJlZ2lzdGVyIGV2ZXJ5IGNv" + + "bXB1dGUgcGxhbmUgYmVmb3JlIHRoZSBjb250cm9sIHBsYW5lLiBCb3RoCmhhbmRvZmZzIGNhbiBk" + + "ZXN0cm95IHRoZSBjb250cm9sIHBsYW5lLCBzbyBhcHBseSB0aGlzIHByZWZsaWdodCBiZWZvcmUg" + + "ZWl0aGVyCm9uZS4gUHJlc2VydmUgdGhlIGBjZXJ0LW1hbmFnZXJgIG5hbWVzcGFjZSBieSBkZWZh" + + "dWx0LiBOYW1lc3BhY2UgcHJlc2VydmF0aW9uCmRvZXMgbm90IHByZXNlcnZlIHRoZSBIZWxtIHJl" + + "bGVhc2UuIElkZW50aWZ5IHdoZXRoZXIgY2VydC1tYW5hZ2VyIGlzIGV4dGVybmFsLgpGb3IgYW4g" + + "ZXh0ZXJuYWwgaW5zdGFsbGF0aW9uLCByZXF1aXJlIGVmZmVjdGl2ZSBgY2VydE1hbmFnZXIuZW5h" + + "YmxlZDogZmFsc2VgCmFuZCBhYm9ydCBpZiBpdCBpcyB0cnVlLiBGb3IgYW4gaW50ZW5kZWQgc3Rh" + + "Y2stbWFuYWdlZCByZWxlYXNlIHdpdGggZWZmZWN0aXZlCmBjZXJ0TWFuYWdlci5lbmFibGVkOiB0" + + "cnVlYCwgdmVyaWZ5IG1hdGNoaW5nIHN0YWNrIEhlbG0gcmVsZWFzZSBtZXRhZGF0YSBhbmQKYWJv" + + "cnQgb24gbWlzc2luZyBvciBtaXNtYXRjaGVkIGV2aWRlbmNlLiBPbmx5IHBsYW4gbmFtZXNwYWNl" + + "IHJlbW92YWwgYWZ0ZXIKdmVyaWZ5aW5nIG5hbWVzcGFjZSBwcm92ZW5hbmNlIGFuZCBnZXR0aW5n" + + "IGV4cGxpY2l0IGNvbmZpcm1hdGlvbjsgb3RoZXJ3aXNlCmRvIG5vdCBkZWxldGUgaXQuCgpGb3Ig" + + "dGhlIEhlbG1maWxlIHZhbHVlcyBmbG93LCByZXRhaW4gZWFjaCByZWdpc3RyYXRpb24gdmFsdWVz" + + "IGZpbGUgdW50aWwKY2xlYW51cCBpcyB2ZXJpZmllZDoKCmBgYGJhc2gKbWFrZSAtQyBkZXBsb3kv" + + "c3RhY2tzL252Y2YtY29tcHV0ZS1wbGFuZSBkZXN0cm95IFwKICBDTFVTVEVSX05BTUU9PGNsdXN0" + + "ZXItbmFtZT4gXAogIEhFTE1GSUxFX0VOVj08ZW52PiBcCiAgS1VCRUNPTkZJR19GSUxFPTxjb21w" + + "dXRlLXBsYW5lLWt1YmVjb25maWc+Cgo8bnZjZi1jbGk+IC0tY29uZmlnIDxjb25maWc+IGNsdXN0" + + "ZXIgZGVsZXRlIFwKICAtLWNsdXN0ZXItaWQgPGNsdXN0ZXItaWQtZnJvbS1yZWdpc3RyYXRpb24t" + + "dmFsdWVzPiBcCiAgLS1uY2EtaWQgPG5jYS1pZD4gXAogIC0taWdub3JlLW1pc3NpbmcKYGBgCgpS" + + "ZWFkIGBjbHVzdGVySURgIGFuZCBgbmNhSURgIGZyb20KYGRlcGxveS9zdGFja3MvbnZjZi1jb21w" + + "dXRlLXBsYW5lL3JlZ2lzdHJhdGlvbi88Y2x1c3Rlci1uYW1lPi1yZWdpc3Rlci12YWx1ZXMueWFt" + + "bGAuClNob3cgdGhlIGV4YWN0IGNsdXN0ZXIgSUQgYW5kIGdldCBjb25maXJtYXRpb24gYmVmb3Jl" + + "IGBjbHVzdGVyIGRlbGV0ZWAuIFJlcGVhdApjb21wdXRlIGRlc3Ryb3kgYW5kIGRlcmVnaXN0cmF0" + + "aW9uIGZvciBldmVyeSBjb21wdXRlIGNsdXN0ZXIsIHRoZW4gZGVzdHJveSB0aGUKY29udHJvbCBw" + + "bGFuZS4KCmBgYGJhc2gKS1VCRUNPTkZJRz08Y29udHJvbC1wbGFuZS1rdWJlY29uZmlnPiBcCm1h" + + "a2UgLUMgZGVwbG95L3N0YWNrcy9zZWxmLW1hbmFnZWQgZGVzdHJveSBcCiAgSEVMTUZJTEVfRU5W" + + "PTxlbnY+IFwKICBLVUJFQ09ORklHX0ZJTEU9PGNvbnRyb2wtcGxhbmUta3ViZWNvbmZpZz4KYGBg" + + "CgpCb3RoIGBLVUJFQ09ORklHYCBhbmQgYEtVQkVDT05GSUdfRklMRWAgYXJlIHJlcXVpcmVkIG9u" + + "IHRoZSBjb250cm9sLXBsYW5lCmRlc3Ryb3kgYmVjYXVzZSBpdHMgbmFtZXNwYWNlIGNsZWFudXAg" + + "dXNlcyBhbWJpZW50IGBrdWJlY3RsYC4KCkZvciB0aGUgQ0xJIHByb2ZpbGUgZmxvdywga2VlcApg" + + "ZGVwbG95L3N0YWNrcy9udmNmLWNvbXB1dGUtcGxhbmUvb3V0LzxjbHVzdGVyLW5hbWU+LXJlZ2lz" + + "dGVyLXZhbHVlcy55YW1sYAp1bnRpbCB0ZWFyZG93biBjb21wbGV0ZXMgYmVjYXVzZSBgZG93bmAg" + + "cmVhZHMgaXRzIGNsdXN0ZXIgSUQuIEZpcnN0IHF1ZXJ5IHRoZQpsaXZlIHJlZ2lzdHJhdGlvbiBz" + + "ZXQgd2l0aCB0aGUgc2FtZSBjb21wbGV0ZSBwZXJzaXN0ZW50IHByZWZpeDoKCmBgYGJhc2gKbnZj" + + "Zi1jbGkgLS1jb25maWcgPGNvbmZpZz4gc2VsZi1ob3N0ZWQgXAogIC0tY29udHJvbC1wbGFuZS1z" + + "dGFjayBkZXBsb3kvc3RhY2tzL3NlbGYtbWFuYWdlZCBcCiAgLS1jb21wdXRlLXBsYW5lLXN0YWNr" + + "IGRlcGxveS9zdGFja3MvbnZjZi1jb21wdXRlLXBsYW5lIFwKICAtLWVudiA8ZW52PiBcCiAgLS1w" + + "bGFpbiBcCiAgLS1jb250cm9sLXBsYW5lLWNvbnRleHQgPGNvbnRyb2wtcGxhbmUtY29udGV4dD4g" + + "XAogIC0tY29tcHV0ZS1wbGFuZS1jb250ZXh0IDxjb21wdXRlLXBsYW5lLWNvbnRleHQ+IFwKICAt" + + "LWljbXMtdXJsIDxjb21wdXRlLXJlYWNoYWJsZS1pY21zLXVybD4gXAogIHN0YXR1cyBcCiAgLS1j" + + "bHVzdGVyLW5hbWUgPGNvbXB1dGUtcGxhbmUtY2x1c3Rlci1uYW1lPiBcCiAgLS1uY2EtaWQgPG5j" + + "YS1pZD4KYGBgCgpTaG93IHRoZSByZWdpc3RlcmVkIGNvbXB1dGUtcGxhbmUgbGlzdC4gTmFtZWQt" + + "Y2x1c3RlciBgZG93biAtLXBsYW4tb25seWAgZG9lcwpub3QgcXVlcnkgSUNNUywgc28gaXQgcHJl" + + "dmlld3Mgb25seSB0aGF0IGNvbXB1dGUgcGxhbmUgYW5kIGNhbm5vdCBzaG93IHRoZQpjb25kaXRp" + + "b25hbCBjb250cm9sLXBsYW5lIHJlbW92YWwuIElmIHRoZSB0YXJnZXQgaXMgdGhlIGxhc3QgcmVn" + + "aXN0ZXJlZApjbHVzdGVyLCByZWFsIGBkb3duYCBhbHNvIGRlc3Ryb3lzIHRoZSBjb250cm9sIHBs" + + "YW5lLiBHZXQgZXhwbGljaXQgY29uZmlybWF0aW9uCmZvciBib3RoIHJlbW92YWxzIGJlZm9yZSBj" + + "b250aW51aW5nLiBUaGVuIHByZXZpZXcgYW5kIGV4ZWN1dGUgd2l0aCB0aGUgc2FtZQpwcmVmaXg6" + + "CgpgYGBiYXNoCm52Y2YtY2xpIC0tY29uZmlnIDxjb25maWc+IHNlbGYtaG9zdGVkIFwKICAtLWNv" + + "bnRyb2wtcGxhbmUtc3RhY2sgZGVwbG95L3N0YWNrcy9zZWxmLW1hbmFnZWQgXAogIC0tY29tcHV0" + + "ZS1wbGFuZS1zdGFjayBkZXBsb3kvc3RhY2tzL252Y2YtY29tcHV0ZS1wbGFuZSBcCiAgLS1lbnYg" + + "PGVudj4gXAogIC0tcGxhaW4gXAogIC0tY29udHJvbC1wbGFuZS1jb250ZXh0IDxjb250cm9sLXBs" + + "YW5lLWNvbnRleHQ+IFwKICAtLWNvbXB1dGUtcGxhbmUtY29udGV4dCA8Y29tcHV0ZS1wbGFuZS1j" + + "b250ZXh0PiBcCiAgLS1pY21zLXVybCA8Y29tcHV0ZS1yZWFjaGFibGUtaWNtcy11cmw+IFwKICBk" + + "b3duIC0tcGxhbi1vbmx5IFwKICAtLWNsdXN0ZXItbmFtZSA8Y29tcHV0ZS1wbGFuZS1jbHVzdGVy" + + "LW5hbWU+IFwKICAtLW5jYS1pZCA8bmNhLWlkPgoKbnZjZi1jbGkgLS1jb25maWcgPGNvbmZpZz4g" + + "c2VsZi1ob3N0ZWQgXAogIC0tY29udHJvbC1wbGFuZS1zdGFjayBkZXBsb3kvc3RhY2tzL3NlbGYt" + + "bWFuYWdlZCBcCiAgLS1jb21wdXRlLXBsYW5lLXN0YWNrIGRlcGxveS9zdGFja3MvbnZjZi1jb21w" + + "dXRlLXBsYW5lIFwKICAtLWVudiA8ZW52PiBcCiAgLS1wbGFpbiBcCiAgLS1jb250cm9sLXBsYW5l" + + "LWNvbnRleHQgPGNvbnRyb2wtcGxhbmUtY29udGV4dD4gXAogIC0tY29tcHV0ZS1wbGFuZS1jb250" + + "ZXh0IDxjb21wdXRlLXBsYW5lLWNvbnRleHQ+IFwKICAtLWljbXMtdXJsIDxjb21wdXRlLXJlYWNo" + + "YWJsZS1pY21zLXVybD4gXAogIGRvd24gXAogIC0tY2x1c3Rlci1uYW1lIDxjb21wdXRlLXBsYW5l" + + "LWNsdXN0ZXItbmFtZT4gXAogIC0tbmNhLWlkIDxuY2EtaWQ+CmBgYAoKUmVwZWF0IGBkb3duYCBm" + + "b3IgZWFjaCBjb21wdXRlIGNsdXN0ZXIuIEVhY2ggcnVuIGRlc3Ryb3lzIHRoYXQgY29tcHV0ZSBw" + + "bGFuZSBhbmQKdW5yZWdpc3RlcnMgaXRzIElDTVMgcm93LiBJdCByZW1vdmVzIHRoZSBjb250cm9s" + + "IHBsYW5lIG9ubHkgYWZ0ZXIgbm8gY2x1c3RlcgpyZWdpc3RyYXRpb25zIHJlbWFpbi4KUEsHCJZj" + + "vFkSMAAAEjAAAFBLAwQUAAgAAAAAACEAAAAAAAAAAAAAAAAAOwAJAGRhdGEvbnZjZi1zZWxmLW1h" + + "bmFnZWQtaW5zdGFsbGF0aW9uL3JlZmVyZW5jZXMvZGVidWdnaW5nLm1kVVQFAAEAps4SIyBEZWJ1" + + "Z2dpbmcgUmVmZXJlbmNlCgpSZWNpcGVzIGZvciBkaWFnbm9zaW5nIGFuZCBmaXhpbmcgY29tbW9u" + + "IE5WQ0Ygc2VsZi1tYW5hZ2VkIHN0YWNrIGZhaWx1cmVzLgoKIyMgUXVpY2sgU3RhdHVzIENvbW1h" + + "bmRzCgpgYGBiYXNoCiMgQWxsIHBvZHMgYWNyb3NzIGFsbCBuYW1lc3BhY2VzCmt1YmVjdGwgZ2V0" + + "IHBvZHMgLUEgLW8gd2lkZQoKIyBQb2RzIGluIGEgc3BlY2lmaWMgbmFtZXNwYWNlCmt1YmVjdGwg" + + "Z2V0IHBvZHMgLW4gPG5hbWVzcGFjZT4KCiMgQWxsIGhlbG0gcmVsZWFzZXMKaGVsbSBsaXN0IC1B" + + "CgojIFJlY2VudCBldmVudHMgKG1vc3QgdXNlZnVsIGZvciBkaWFnbm9zaW5nIGZhaWx1cmVzKQpr" + + "dWJlY3RsIGdldCBldmVudHMgLW4gPG5hbWVzcGFjZT4gLS1zb3J0LWJ5PScubGFzdFRpbWVzdGFt" + + "cCcKCiMgRGVzY3JpYmUgYSBzcGVjaWZpYyBwb2QgKHNob3dzIGV2ZW50cywgY29uZGl0aW9ucywg" + + "dm9sdW1lcykKa3ViZWN0bCBkZXNjcmliZSBwb2QgLW4gPG5hbWVzcGFjZT4gPHBvZC1uYW1lPgpg" + + "YGAKCiMjIEZhaWx1cmU6IEltYWdlUHVsbEJhY2tPZmYKCiMjIyBTeW1wdG9tcwoKYGBgCk5BTUUg" + + "ICAgICAgICAgIFJFQURZICAgU1RBVFVTICAgICAgICAgICAgIFJFU1RBUlRTICAgQUdFCmNhc3Nh" + + "bmRyYS0wICAgIDAvMSAgICAgSW1hZ2VQdWxsQmFja09mZiAgIDAgICAgICAgICAgNW0KYGBgCgpF" + + "dmVudHMgc2hvdzoKYGBgCkZhaWxlZCB0byBwdWxsIGltYWdlICJudmNyLmlvLy4uLi9pbWFnZTp0" + + "YWciOiA0MDEgVW5hdXRob3JpemVkCmBgYAoKIyMjIERpYWdub3NpcwoKYGBgYmFzaAojIENoZWNr" + + "IHdoYXQgaW1hZ2UgaXMgZmFpbGluZwprdWJlY3RsIGRlc2NyaWJlIHBvZCAtbiA8bmFtZXNwYWNl" + + "PiA8cG9kLW5hbWU+IHwgZ3JlcCAtQTUgIkV2ZW50czoiCgojIENoZWNrIGlmIHB1bGwgc2VjcmV0" + + "IGV4aXN0cyBpbiB0aGUgbmFtZXNwYWNlCmt1YmVjdGwgZ2V0IHNlY3JldCBudmNyLWNyZWRzIC1u" + + "IDxuYW1lc3BhY2U+CgojIENoZWNrIGlmIHRoZSBwb2Qgc3BlYyBoYXMgaW1hZ2VQdWxsU2VjcmV0" + + "cwprdWJlY3RsIGdldCBwb2QgLW4gPG5hbWVzcGFjZT4gPHBvZC1uYW1lPiAtbyBqc29ucGF0aD0n" + + "ey5zcGVjLmltYWdlUHVsbFNlY3JldHN9JwoKIyBDaGVjayBpZiB0aGUgU2VydmljZUFjY291bnQg" + + "aGFzIGltYWdlUHVsbFNlY3JldHMKa3ViZWN0bCBnZXQgc2EgPHNhLW5hbWU+IC1uIDxuYW1lc3Bh" + + "Y2U+IC1vIGpzb25wYXRoPSd7LmltYWdlUHVsbFNlY3JldHN9JwpgYGAKCiMjIyBGaXhlcwoKMS4g" + + "KipTZWNyZXQgbWlzc2luZyBpbiBuYW1lc3BhY2UqKjogQ3JlYXRlIGl0CiAgIGBgYGJhc2gKICAg" + + "a3ViZWN0bCBjcmVhdGUgc2VjcmV0IGRvY2tlci1yZWdpc3RyeSBudmNyLWNyZWRzIFwKICAgICAt" + + "LWRvY2tlci1zZXJ2ZXI9bnZjci5pbyBcCiAgICAgLS1kb2NrZXItdXNlcm5hbWU9JyRvYXV0aHRv" + + "a2VuJyBcCiAgICAgLS1kb2NrZXItcGFzc3dvcmQ9IiROR0NfQVBJX0tFWSIgXAogICAgIC0tbmFt" + + "ZXNwYWNlPTxuYW1lc3BhY2U+IFwKICAgICAtLWRyeS1ydW49Y2xpZW50IC1vIHlhbWwgfCBrdWJl" + + "Y3RsIGFwcGx5IC1mIC0KICAgYGBgCgoyLiAqKlNlY3JldCBleGlzdHMgYnV0IHBvZCBkb2Vzbid0" + + "IHJlZmVyZW5jZSBpdCoqOiBUaGUgY2hhcnQgbmVlZHMgYGltYWdlUHVsbFNlY3JldHNgIGNvbmZp" + + "Z3VyZWQgdmlhIGhlbG1maWxlIHZhbHVlcy4gU2VlIFtwdWxsLXNlY3JldHMubWRdKHB1bGwtc2Vj" + + "cmV0cy5tZCkuCgozLiAqKkNoYXJ0IGRvZXNuJ3Qgc3VwcG9ydCBpbWFnZVB1bGxTZWNyZXRzKiog" + + "KG9wZW5iYW8sIGludm9jYXRpb24tc2VydmljZSwgZXNzLWFwaSwgbm90YXJ5LXNlcnZpY2UpOiBQ" + + "YXRjaCBTZXJ2aWNlQWNjb3VudHMgYW5kIHJlc3RhcnQgcG9kcy4gU2VlIFtwdWxsLXNlY3JldHMu" + + "bWRdKHB1bGwtc2VjcmV0cy5tZCkuCgo0LiAqKldyb25nIGNyZWRlbnRpYWxzIGluIHNlY3JldCoq" + + "OiBEZWxldGUgYW5kIHJlY3JlYXRlCiAgIGBgYGJhc2gKICAga3ViZWN0bCBkZWxldGUgc2VjcmV0" + + "IG52Y3ItY3JlZHMgLW4gPG5hbWVzcGFjZT4KICAgIyBSZWNyZWF0ZSB3aXRoIGNvcnJlY3QgY3Jl" + + "ZGVudGlhbHMKICAgYGBgCgojIyBGYWlsdXJlOiBJbml0OjAvMSBTdHVjayAoVmF1bHQgQWdlbnQp" + + "CgojIyMgU3ltcHRvbXMKClNlcnZpY2UgcG9kcyBzdHVjayBpbiBgSW5pdDowLzFgIGZvciBtaW51" + + "dGVzOgpgYGAKTkFNRSAgICAgICAgICAgICAgICAgICAgICAgIFJFQURZICAgU1RBVFVTICAgICBS" + + "RVNUQVJUUyAgIEFHRQpudmNmLWFwaS03ZjRjNzZmNzg4LTQ0dmx0ICAwLzIgICAgIEluaXQ6MC8x" + + "ICAgMCAgICAgICAgICAxMG0KYGBgCgojIyMgRGlhZ25vc2lzCgpUaGUgaW5pdCBjb250YWluZXIg" + + "aXMgdGhlIHZhdWx0LWFnZW50LWluaXQgaW5qZWN0b3Igd2FpdGluZyBmb3IgT3BlbkJhby4KCmBg" + + "YGJhc2gKIyBDaGVjayBPcGVuQmFvIHBvZHMKa3ViZWN0bCBnZXQgcG9kcyAtbiB2YXVsdC1zeXN0" + + "ZW0KCiMgQ2hlY2sgaWYgT3BlbkJhbyBtaWdyYXRpb24gam9iIHJhbgprdWJlY3RsIGdldCBqb2Jz" + + "IC1uIHZhdWx0LXN5c3RlbQoKIyBDaGVjayBPcGVuQmFvIHBvZCBsb2dzCmt1YmVjdGwgbG9ncyAt" + + "biB2YXVsdC1zeXN0ZW0gb3BlbmJhby1zZXJ2ZXItMCAtYyBvcGVuYmFvCgojIENoZWNrIGluaXQg" + + "Y29udGFpbmVyIGxvZ3Mgb24gdGhlIHN0dWNrIHBvZAprdWJlY3RsIGxvZ3MgLW4gPG5hbWVzcGFj" + + "ZT4gPHBvZC1uYW1lPiAtYyB2YXVsdC1hZ2VudC1pbml0CmBgYAoKIyMjIEZpeGVzCgoxLiAqKk9w" + + "ZW5CYW8gcG9kcyBub3QgcnVubmluZyoqOiBDaGVjayB0aGVpciBldmVudHMgZm9yIGltYWdlIHB1" + + "bGwgaXNzdWVzLCByZXNvdXJjZSBpc3N1ZXMsIGV0Yy4KCjIuICoqT3BlbkJhbyBtaWdyYXRpb24g" + + "am9iIGRpZG4ndCBydW4qKjogVGhpcyBoYXBwZW5zIHdoZW4gYGhlbG1maWxlIHN5bmNgIHdhcyBp" + + "bnRlcnJ1cHRlZC4gRGVzdHJveSBhbmQgcmUtc3luYyBvcGVuYmFvOgogICBgYGBiYXNoCiAgIEhF" + + "TE1GSUxFX0VOVj08ZW52PiBoZWxtZmlsZSAtLXNlbGVjdG9yIG5hbWU9b3BlbmJhby1zZXJ2ZXIg" + + "ZGVzdHJveQogICBrdWJlY3RsIGRlbGV0ZSBuYW1lc3BhY2UgdmF1bHQtc3lzdGVtCiAgIGt1YmVj" + + "dGwgY3JlYXRlIG5hbWVzcGFjZSB2YXVsdC1zeXN0ZW0KICAgIyBSZS1jcmVhdGUgcHVsbCBzZWNy" + + "ZXQgaWYgbmVlZGVkCiAgIEhFTE1GSUxFX0VOVj08ZW52PiBoZWxtZmlsZSAtLXNlbGVjdG9yIG5h" + + "bWU9b3BlbmJhby1zZXJ2ZXIgc3luYwogICBgYGAKCjMuICoqT3BlbkJhbyBwb2RzIHJ1bm5pbmcg" + + "YnV0IG5vdCBpbml0aWFsaXplZCoqOiBDaGVjayB1bnNlYWwgc3RhdHVzOgogICBgYGBiYXNoCiAg" + + "IGt1YmVjdGwgZXhlYyAtbiB2YXVsdC1zeXN0ZW0gb3BlbmJhby1zZXJ2ZXItMCAtYyBvcGVuYmFv" + + "IC0tIGJhbyBzdGF0dXMKICAgYGBgCgo0LiAqKmB2YXVsdC1hZ2VudC1pbml0YCBsb2dzIGBhdXRo" + + "L2p3dC9sb2dpbmAgLT4gYDQwMCAuLi4gbm8ga25vd24ga2V5IHN1Y2Nlc3NmdWxseSB2YWxpZGF0" + + "ZWQgdGhlIHRva2VuIHNpZ25hdHVyZWAqKgogICAoY29tbW9uIG9uIEFLUywgYW5kIG9uIGFueSBj" + + "bHVzdGVyIHdob3NlIE9JREMgaXNzdWVyIHB1Ymxpc2hlcyBhIHJvdGF0aW5nIG11bHRpLWtleSBK" + + "V0tTKToKICAgdGhlIE9wZW5CYW8gYGF1dGgvand0YCBtZXRob2Qgd2FzIGNvbmZpZ3VyZWQgd2l0" + + "aCBhIHNpbmdsZSBzdGF0aWMgbW91bnRlZCBwdWJsaWMga2V5CiAgIChgand0X3ZhbGlkYXRpb25f" + + "cHVia2V5c2ApIGluc3RlYWQgb2YgdGhlIGlzc3VlcidzIGxpdmUgSldLUywgc28gaXQgY2Fubm90" + + "IHZhbGlkYXRlIHRoZQogICBjbHVzdGVyLXNpZ25lZCBTZXJ2aWNlQWNjb3VudCB0b2tlbnMgdGhl" + + "IHZhdWx0LWFnZW50cyBwcmVzZW50LiBFdmVyeSBzZXJ2aWNlJ3MKICAgYHZhdWx0LWFnZW50LWlu" + + "aXRgIHRoZW4gbG9vcHMgb24gdGhhdCA0MDAgYW5kIHRoZSBwb2QgbmV2ZXIgbGVhdmVzIGBJbml0" + + "OjAvMWAuIFRoaXMgaXMgdGhlCiAgIGJlaGF2aW9yIG9mIHRoZSBiYXNlIGRlZmF1bHQgYG9wZW5i" + + "YW8ubWlncmF0aW9ucy5pc3N1ZXJEaXNjb3ZlcnkuZW5hYmxlZDogZmFsc2VgOyB0aGUKICAgbWln" + + "cmF0aW9uIGxvZyBzaG93cyBgT0lEQyBpc3N1ZXIgZGlzY292ZXJ5IGlzIGRpc2FibGVkLiBVc2lu" + + "ZyBTZXJ2aWNlQWNjb3VudCBpc3N1ZXIgYW5kCiAgIG1vdW50ZWQgcHVibGljIGtleSBmYWxsYmFj" + + "a2AuIEVuYWJsZSBpc3N1ZXIgZGlzY292ZXJ5IHNvIHRoZSBtaWdyYXRpb24gdXNlcyB0aGUgbGl2" + + "ZSBKV0tTLAogICB0aGVuIHJlLXJ1biBpdDoKICAgYGBgYmFzaAogICAjIEluIHlvdXIgZW52IHZh" + + "bHVlcyAoZS5nLiBlbnZpcm9ubWVudHMvPGVudj4ueWFtbCksIHNldDoKICAgIyAgIG9wZW5iYW86" + + "CiAgICMgICAgIG1pZ3JhdGlvbnM6CiAgICMgICAgICAgaXNzdWVyRGlzY292ZXJ5OgogICAjICAg" + + "ICAgICAgZW5hYmxlZDogdHJ1ZQogICBrdWJlY3RsIGRlbGV0ZSBqb2IgLW4gdmF1bHQtc3lzdGVt" + + "IG9wZW5iYW8tc2VydmVyLW1pZ3JhdGlvbnMKICAgSEVMTUZJTEVfRU5WPTxlbnY+IGhlbG1maWxl" + + "IC0tc2VsZWN0b3IgbmFtZT1vcGVuYmFvLXNlcnZlciBzeW5jCiAgIGBgYAogICBUaGUgbWlncmF0" + + "aW9uIGxvZyBzaG91bGQgdGhlbiBzaG93IGBSZWNlaXZlZCBkaXNjb3ZlcnkgZG9jdW1lbnQgZnJv" + + "bQogICAuLi4vLndlbGwta25vd24vb3BlbmlkLWNvbmZpZ3VyYXRpb25gIGFuZCBgRmluYWwgT3Bl" + + "bkJhbyBKV1QgSldLUyBVUkwgc2V0IHRvOgogICAuLi4vb3BlbmlkL3YxL2p3a3NgLCBhbmQgdGhl" + + "IHNlcnZpY2UgcG9kcyBhdXRoZW50aWNhdGUgYW5kIHJlYWNoIFJlYWR5IHdpdGhpbiB+MSBtaW4u" + + "CiAgIEFLUyBjbHVzdGVycyB3aXRoIHRoZSBjbHVzdGVyIE9JREMgaXNzdWVyIGVuYWJsZWQgKHRo" + + "ZSBgYWtzLWNsdXN0ZXJgIGRlZmF1bHQpIGFsd2F5cyBuZWVkCiAgIHRoaXMgYmVjYXVzZSB0aGUg" + + "c3RhdGljLXB1YmtleSBmYWxsYmFjayBjYW5ub3QgbWF0Y2ggdGhlIGlzc3VlcidzIHJvdGF0aW5n" + + "IHNpZ25pbmcga2V5cy4KCiMjIEZhaWx1cmU6IE9PTUtpbGxlZCBvbiBDYXNzYW5kcmEKCiMjIyBT" + + "eW1wdG9tcwoKYGBgCk5BTUUgICAgICAgICAgUkVBRFkgICBTVEFUVVMgICAgUkVTVEFSVFMgICBB" + + "R0UKY2Fzc2FuZHJhLTAgICAwLzEgICAgIE9PTUtpbGxlZCAgMyAgICAgICAgIDEwbQpgYGAKCiMj" + + "IyBEaWFnbm9zaXMKCmBgYGJhc2gKa3ViZWN0bCBkZXNjcmliZSBwb2QgLW4gY2Fzc2FuZHJhLXN5" + + "c3RlbSBjYXNzYW5kcmEtMCB8IGdyZXAgLUEzICJMYXN0IFN0YXRlIgpgYGAKCiMjIyBGaXgKCk92" + + "ZXJyaWRlIENhc3NhbmRyYSByZXNvdXJjZXMgdmlhIGhlbG1maWxlIHZhbHVlcy4gU2VlIEV4YW1w" + + "bGUgMSBpbgpbZXhhbXBsZXMubWRdKC4uL2V4YW1wbGVzLm1kKS4KCmBgYHlhbWwKLSBjYXNzYW5k" + + "cmE6CiAgICByZXNvdXJjZXM6CiAgICAgIGxpbWl0czoKICAgICAgICBjcHU6ICI4IgogICAgICAg" + + "IG1lbW9yeTogODE5Mk1pCiAgICAgIHJlcXVlc3RzOgogICAgICAgIGNwdTogIjIiCiAgICAgICAg" + + "bWVtb3J5OiA0MDk2TWkKYGBgCgpOb3RlOiBgcmVzb3VyY2VQcmVzZXRgIGlzIG5vdCBhdmFpbGFi" + + "bGUgaW4gdGhlIE5WQ0YgY2Fzc2FuZHJhIHdyYXBwZXIgY2hhcnQuIFVzZSBleHBsaWNpdCBgcmVz" + + "b3VyY2VzYC4KCiMjIEZhaWx1cmU6IFBvZHMgU3R1Y2sgaW4gUGVuZGluZwoKIyMjIFN5bXB0b21z" + + "CgpgYGAKTkFNRSAgICAgICAgICBSRUFEWSAgIFNUQVRVUyAgICBSRVNUQVJUUyAgIEFHRQpjYXNz" + + "YW5kcmEtMCAgIDAvMSAgICAgUGVuZGluZyAgIDAgICAgICAgICAgMTBtCmBgYAoKIyMjIERpYWdu" + + "b3NpcwoKYGBgYmFzaAojIENoZWNrIGV2ZW50cyBmb3Igc2NoZWR1bGluZyBmYWlsdXJlcwprdWJl" + + "Y3RsIGRlc2NyaWJlIHBvZCAtbiA8bmFtZXNwYWNlPiA8cG9kLW5hbWU+CgojIENvbW1vbiBjYXVz" + + "ZXM6CiMgLSAiMC8xMiBub2RlcyBhcmUgYXZhaWxhYmxlOiAxMiBub2RlKHMpIGRpZG4ndCBtYXRj" + + "aCBQb2QncyBub2RlIGFmZmluaXR5IgojIC0gIjAvMTIgbm9kZXMgYXJlIGF2YWlsYWJsZTogMTIg" + + "SW5zdWZmaWNpZW50IG1lbW9yeSIKIyAtICJwZXJzaXN0ZW50dm9sdW1lY2xhaW0gbm90IGZvdW5k" + + "IgpgYGAKCiMjIyBGaXhlcwoKMS4gKipOb2RlIHNlbGVjdG9yIG1pc21hdGNoKio6IENoZWNrIGBu" + + "b2RlU2VsZWN0b3JzYCBpbiBlbnZpcm9ubWVudCBmaWxlCiAgIGBgYGJhc2gKICAga3ViZWN0bCBn" + + "ZXQgbm9kZXMgLS1zaG93LWxhYmVscyB8IGdyZXAgbnZjZgogICBgYGAKCjIuICoqU3RvcmFnZSBj" + + "bGFzcyBub3QgZm91bmQqKjogQ2hlY2sgc3RvcmFnZSBjbGFzcyBleGlzdHMKICAgYGBgYmFzaAog" + + "ICBrdWJlY3RsIGdldCBzdG9yYWdlY2xhc3MKICAgYGBgCgozLiAqKkluc3VmZmljaWVudCByZXNv" + + "dXJjZXMqKjogQ2hlY2sgbm9kZSBjYXBhY2l0eQogICBgYGBiYXNoCiAgIGt1YmVjdGwgZGVzY3Jp" + + "YmUgbm9kZSA8bm9kZS1uYW1lPiB8IGdyZXAgLUE1ICJBbGxvY2F0ZWQgcmVzb3VyY2VzIgogICBg" + + "YGAKCiMjIEZhaWx1cmU6IEhlbG0gUmVsZWFzZSBpbiBGYWlsZWQgU3RhdGUKCiMjIyBTeW1wdG9t" + + "cwoKYGBgYmFzaApoZWxtIGxpc3QgLUEKIyBTaG93cyByZWxlYXNlIHdpdGggU1RBVFVTOiBmYWls" + + "ZWQKYGBgCgpSZS1ydW5uaW5nIGBoZWxtZmlsZSBzeW5jYCBhcHBlYXJzIHRvIHN1Y2NlZWQgYnV0" + + "IHNlcnZpY2VzIGRvbid0IHdvcmsgKG1pZ3JhdGlvbnMgc2tpcHBlZCkuCgojIyMgRGlhZ25vc2lz" + + "CgpgYGBiYXNoCmhlbG0gaGlzdG9yeSA8cmVsZWFzZS1uYW1lPiAtbiA8bmFtZXNwYWNlPgpgYGAK" + + "CiMjIyBGaXgKCk11c3QgZGVzdHJveSB0aGUgZmFpbGVkIHJlbGVhc2UgYW5kIHJlLXN5bmMgKG5v" + + "dCBqdXN0IGFwcGx5KToKCmBgYGJhc2gKSEVMTUZJTEVfRU5WPTxlbnY+IGhlbG1maWxlIC0tc2Vs" + + "ZWN0b3IgbmFtZT08cmVsZWFzZT4gZGVzdHJveQojIElmIG5hbWVzcGFjZSBuZWVkcyBjbGVhbnVw" + + "OgprdWJlY3RsIGRlbGV0ZSBuYW1lc3BhY2UgPG5hbWVzcGFjZT4Ka3ViZWN0bCBjcmVhdGUgbmFt" + + "ZXNwYWNlIDxuYW1lc3BhY2U+CiMgUmUtY3JlYXRlIHB1bGwgc2VjcmV0IGlmIG5lZWRlZApIRUxN" + + "RklMRV9FTlY9PGVudj4gaGVsbWZpbGUgLS1zZWxlY3RvciBuYW1lPTxyZWxlYXNlPiBzeW5jCmBg" + + "YAoKIyMgRmFpbHVyZTogQWNjb3VudCBCb290c3RyYXAgSm9iIEZhaWxlZAoKIyMjIFN5bXB0b21z" + + "CgpTZXJ2aWNlcyBkZXBsb3kgYnV0IGZ1bmN0aW9ucyBjYW4ndCBiZSBjcmVhdGVkLiBFdmVudHMg" + + "c2hvdyBib290c3RyYXAgam9iIGZhaWx1cmUuCgojIyMgRGlhZ25vc2lzCgpgYGBiYXNoCiMgQ2hl" + + "Y2sgYm9vdHN0cmFwIGpvYiBzdGF0dXMKa3ViZWN0bCBnZXQgam9icyAtbiBudmNmCgojIEdldCBs" + + "b2dzIChqb2IgYXV0by1kZWxldGVzIGFmdGVyIH41IG1pbnV0ZXMpCmt1YmVjdGwgbG9ncyBqb2Iv" + + "bnZjZi1hcGktYWNjb3VudC1ib290c3RyYXAgLW4gbnZjZgoKIyBDaGVjayBBUEkgbG9ncwprdWJl" + + "Y3RsIGxvZ3MgLW4gbnZjZiAtbCBhcHAua3ViZXJuZXRlcy5pby9uYW1lPW52Y2YtYXBpIC0tdGFp" + + "bD0xMDAKYGBgCgojIyMgQ29tbW9uIENhdXNlcwoKMS4gKipXcm9uZyBiYXNlNjQgY3JlZGVudGlh" + + "bHMqKjogQ3JlZGVudGlhbHMgaW4gYHNlY3JldHMvPGVudj4tc2VjcmV0cy55YW1sYCBtdXN0IGJl" + + "IGAkb2F1dGh0b2tlbjpBUElfS0VZYCBiYXNlNjQtZW5jb2RlZCwgbm90IGp1c3QgdGhlIEFQSSBr" + + "ZXkKICAgYGBgYmFzaAogICAjIFZlcmlmeSB5b3VyIGVuY29kZWQgY3JlZGVudGlhbAogICBlY2hv" + + "ICdZT1VSX0JBU0U2NF9TVFJJTkcnIHwgYmFzZTY0IC1kCiAgICMgU2hvdWxkIG91dHB1dDogJG9h" + + "dXRodG9rZW46bnZhcGkteHh4eHgKICAgYGBgCgoyLiAqKlJlZ2lzdHJ5IHVucmVhY2hhYmxlKio6" + + "IEFQSSBjYW4ndCByZWFjaCB0aGUgcmVnaXN0cnkgc3BlY2lmaWVkIGluIGBhY2NvdW50Qm9vdHN0" + + "cmFwLnJlZ2lzdHJ5Q3JlZGVudGlhbHNgCgojIyMgRml4CgpGaXggY3JlZGVudGlhbHMgaW4gc2Vj" + + "cmV0cyBmaWxlLCB0aGVuIHJlY292ZXIgc2VydmljZXMgd2l0aG91dCBkZXN0cm95aW5nIGRlcGVu" + + "ZGVuY2llczoKCmBgYGJhc2gKSEVMTUZJTEVfRU5WPTxlbnY+IGhlbG1maWxlIC0tc2VsZWN0b3Ig" + + "cmVsZWFzZS1ncm91cD1zZXJ2aWNlcyBkZXN0cm95Cmt1YmVjdGwgZGVsZXRlIG5hbWVzcGFjZSBu" + + "dmNmIGFwaS1rZXlzIGVzcyBzaXMgLS1pZ25vcmUtbm90LWZvdW5kCmt1YmVjdGwgY3JlYXRlIG5h" + + "bWVzcGFjZSBudmNmICYmIGt1YmVjdGwgY3JlYXRlIG5hbWVzcGFjZSBhcGkta2V5cyAmJiBcCiAg" + + "a3ViZWN0bCBjcmVhdGUgbmFtZXNwYWNlIGVzcyAmJiBrdWJlY3RsIGNyZWF0ZSBuYW1lc3BhY2Ug" + + "c2lzCiMgUmUtY3JlYXRlIHB1bGwgc2VjcmV0cyBpZiBuZWVkZWQKSEVMTUZJTEVfRU5WPTxlbnY+" + + "IGhlbG1maWxlIC0tc2VsZWN0b3IgcmVsZWFzZS1ncm91cD1zZXJ2aWNlcyBzeW5jCmBgYAoKIyMg" + + "RmFpbHVyZTogTlZDQSBDbGVhbnVwIFN0dWNrIChGaW5hbGl6ZXJzKQoKIyMjIFN5bXB0b21zCgpD" + + "b21wdXRlLXBsYW5lIGNsZWFudXAgaGFuZ3MuIE5hbWVzcGFjZXMKc3R1Y2sgaW4gYFRlcm1pbmF0" + + "aW5nYDoKCmBgYGJhc2gKa3ViZWN0bCBnZXQgbnMKIyBudmNhLW9wZXJhdG9yICAgIFRlcm1pbmF0" + + "aW5nICAgMTBtCiMgbnZjZi1iYWNrZW5kICAgICBUZXJtaW5hdGluZyAgIDEwbQpgYGAKCiMjIyBG" + + "aXgKClJ1biB0aGlzIG9ubHkgYWdhaW5zdCB0aGUgY29tcHV0ZSBjb250ZXh0LCBhZnRlciB0aGUg" + + "bm9ybWFsIGNvbXB1dGUtcGxhbmUKdGVhcmRvd24gaGFzIGZhaWxlZC4gUmVtb3ZlIGZpbmFsaXpl" + + "cnMgZnJvbSBOVkNGQmFja2VuZCBjdXN0b20gcmVzb3VyY2VzIGFuZApmb3JjZS1kZWxldGUgc3R1" + + "Y2sgbmFtZXNwYWNlczoKCmBgYGJhc2gKZXhwb3J0IENPTVBVVEVfQ09OVEVYVD08Y29tcHV0ZS1w" + + "bGFuZS1jb250ZXh0PgoKIyBSZW1vdmUgZmluYWxpemVycyBmcm9tIE5WQ0ZCYWNrZW5kIHJlc291" + + "cmNlcwprdWJlY3RsIC0tY29udGV4dCAiJENPTVBVVEVfQ09OVEVYVCIgZ2V0IG52Y2ZiYWNrZW5k" + + "cyAtQSAtbyBqc29uIHwgXAogIGpxICcuaXRlbXNbXSB8IC5tZXRhZGF0YS5uYW1lc3BhY2UgKyAi" + + "LyIgKyAubWV0YWRhdGEubmFtZScgLXIgfCBcCiAgeGFyZ3MgLUl7fSBzaCAtYyAnY29udGV4dD0i" + + "JDEiOyBucz0iJHsyJSUvKn0iOyBuYW1lPSIkezIjIyovfSI7IGt1YmVjdGwgLS1jb250ZXh0ICIk" + + "Y29udGV4dCIgcGF0Y2ggbnZjZmJhY2tlbmQgIiRuYW1lIiAtbiAiJG5zIiAtLXR5cGU9bWVyZ2Ug" + + "LXAgIntcIm1ldGFkYXRhXCI6e1wiZmluYWxpemVyc1wiOltdfX0iJyBfICIkQ09NUFVURV9DT05U" + + "RVhUIiB7fQoKIyBGb3JjZS1kZWxldGUgc3R1Y2sgbmFtZXNwYWNlcyBieSBjbGVhcmluZyB0aGVp" + + "ciBmaW5hbGl6ZXJzCmZvciBucyBpbiBudmNhLW9wZXJhdG9yIG52Y2YtYmFja2VuZDsgZG8KICBr" + + "dWJlY3RsIC0tY29udGV4dCAiJENPTVBVVEVfQ09OVEVYVCIgZ2V0IG5hbWVzcGFjZSAiJG5zIiAt" + + "byBqc29uIDI+L2Rldi9udWxsIHwgXAogICAganEgJy5zcGVjLmZpbmFsaXplcnMgPSBbXScgfCBc" + + "CiAgICBrdWJlY3RsIC0tY29udGV4dCAiJENPTVBVVEVfQ09OVEVYVCIgcmVwbGFjZSBcCiAgICAg" + + "IC0tcmF3ICIvYXBpL3YxL25hbWVzcGFjZXMvJG5zL2ZpbmFsaXplIiAtZiAtIDI+L2Rldi9udWxs" + + "CmRvbmUKYGBgCgojIyBGYWlsdXJlOiBOVkNBIE9wZXJhdG9yIE1pc3Npbmcgb3IgTm90IFJlYWR5" + + "CgojIyMgU3ltcHRvbXMKCkFmdGVyIGNvbXB1dGUtcGxhbmUgaW5zdGFsbCBjb21wbGV0ZXMsIG5v" + + "IGBudmNhLW9wZXJhdG9yYCBEZXBsb3ltZW50IGV4aXN0cywgb3IKaXQgZXhpc3RzIGJ1dCBwb2Rz" + + "IGFyZSBub3QgcmVhZHk6CgpgYGBiYXNoCmt1YmVjdGwgLS1jb250ZXh0IDxjb21wdXRlLXBsYW5l" + + "LWNvbnRleHQ+IGdldCBkZXBsb3ltZW50IG52Y2Etb3BlcmF0b3IgXAogIC1uIG52Y2Etb3BlcmF0" + + "b3IKa3ViZWN0bCAtLWNvbnRleHQgPGNvbXB1dGUtcGxhbmUtY29udGV4dD4gZ2V0IHBvZHMgLW4g" + + "bnZjYS1vcGVyYXRvcgpgYGAKCiMjIyBEaWFnbm9zaXMgYW5kIEZpeGVzCgpGaXJzdCBpZGVudGlm" + + "eSB3aGV0aGVyIHRoZSBpbnN0YWxsYXRpb24gdXNlZCB0aGUgSGVsbWZpbGUgdmFsdWVzIGZsb3cg" + + "b3IgdGhlCkNMSSBwcm9maWxlIGZsb3cuIFJlLXJ1biBvbmx5IHRoYXQgZmxvdydzIHJlZ2lzdHJh" + + "dGlvbiBhbmQgaW5zdGFsbGF0aW9uIHN0ZXBzCmZyb20gW1NwbGl0IENvbXB1dGUtUGxhbmUgSW5z" + + "dGFsbGF0aW9uXShjb21wdXRlLXBsYW5lLWluc3RhbGxhdGlvbi5tZCkuIERvIG5vdApzdWJzdGl0" + + "dXRlIG9uZSBoYW5kb2ZmIGZvciB0aGUgb3RoZXIuCgpJZiBpbnN0YWxsYXRpb24gc3VjY2VlZHMg" + + "YnV0IHBvZHMgc3RpbGwgZmFpbCwgaW5zcGVjdCB0aGUgY29tcHV0ZSBjb250ZXh0OgoKYGBgYmFz" + + "aAprdWJlY3RsIC0tY29udGV4dCA8Y29tcHV0ZS1wbGFuZS1jb250ZXh0PiBkZXNjcmliZSBkZXBs" + + "b3kgbnZjYS1vcGVyYXRvciBcCiAgLW4gbnZjYS1vcGVyYXRvcgprdWJlY3RsIC0tY29udGV4dCA8" + + "Y29tcHV0ZS1wbGFuZS1jb250ZXh0PiBsb2dzIGRlcGxveW1lbnQvbnZjYS1vcGVyYXRvciBcCiAg" + + "LW4gbnZjYS1vcGVyYXRvciAtLXRhaWw9MjAwCmt1YmVjdGwgLS1jb250ZXh0IDxjb21wdXRlLXBs" + + "YW5lLWNvbnRleHQ+IGdldCBudmNmYmFja2VuZCAtbiBudmNhLW9wZXJhdG9yCmBgYAoKRm9yIHBy" + + "aXZhdGUgcmVnaXN0cnkgZmFpbHVyZXMsIHZlcmlmeSB0aGF0IHRoZSBwdWxsIHNlY3JldCBleGlz" + + "dHMgaW4KYG52Y2Etb3BlcmF0b3JgLiBUaGUgY2hhcnQgYW5kIG9wZXJhdG9yIG1pcnJvciBpdCB0" + + "byBgbnZjYS1zeXN0ZW1gOyBkbyBub3QgdXNlIGEKYnJvYWRlciBtYW51YWwgbmFtZXNwYWNlIGxv" + + "b3AuIFNlZQpbcHVsbC1zZWNyZXRzLm1kXShwdWxsLXNlY3JldHMubWQjY29tcHV0ZS1wbGFuZS1z" + + "ZWNyZXQpLgoKIyMgRmFpbHVyZTogR2F0ZXdheSBFbmRwb2ludCBDaGFuZ2VkCgojIyMgU3ltcHRv" + + "bXMKClJlcXVlc3RzIHRocm91Z2ggdGhlIGNvbmZpZ3VyZWQgcm91dGUgZG9tYWluIGZhaWwgYWZ0" + + "ZXIgdGhlIEdhdGV3YXkgb3IgaXRzIGxvYWQgYmFsYW5jZXIgaXMgcmVwbGFjZWQuIFRoZSBHYXRl" + + "d2F5IHJlcG9ydHMgYSBuZXcgZW5kcG9pbnQuCgojIyMgRGlhZ25vc2lzCgpgYGBiYXNoCkdBVEVX" + + "QVlfQUREUj0kKGt1YmVjdGwgLS1jb250ZXh0IDxjb250cm9sLXBsYW5lLWNvbnRleHQ+IGdldCBn" + + "YXRld2F5IFwKICBudmNmLWdhdGV3YXkgLW4gZW52b3ktZ2F0ZXdheSBcCiAgLW8ganNvbnBhdGg9" + + "J3suc3RhdHVzLmFkZHJlc3Nlc1swXS52YWx1ZX0nKQp0ZXN0IC1uICIkR0FURVdBWV9BRERSIgpk" + + "aWcgK3Nob3J0ICJhcGkuPGRvbWFpbj4iCmN1cmwgLUggIkhvc3Q6IGFwaS48ZG9tYWluPiIgImh0" + + "dHA6Ly8kR0FURVdBWV9BRERSL2hlYWx0aCIKCiMgQ2hlY2sgZGlyZWN0IGFkZHJlc3MgZmllbGRz" + + "IHVzZWQgYnkgYSBzcGxpdCBkZXBsb3ltZW50CmdyZXAgbnZjZk5hdHNTZXJ2aWNlVVJMIGRlcGxv" + + "eS9zdGFja3Mvc2VsZi1tYW5hZ2VkL2Vudmlyb25tZW50cy88ZW52Pi55YW1sCmdyZXAgLUUgJ2lj" + + "bXNTZXJ2aWNlfHJldmFsU2VydmljZXxuYXRzJyBcCiAgZGVwbG95L3N0YWNrcy9udmNmLWNvbXB1" + + "dGUtcGxhbmUvZW52aXJvbm1lbnRzLzxlbnY+LnlhbWwKYGBgCgojIyMgRml4CgpLZWVwIGBnbG9i" + + "YWwuZG9tYWluYCwgcm91dGUgaG9zdG5hbWVzLCBhbmQgSG9zdCBvdmVycmlkZXMgdW5jaGFuZ2Vk" + + "LiBVcGRhdGUgRE5TCm9yIHRoZSBkaXJlY3QgY2xpZW50IGRlc3RpbmF0aW9uLiBGb3Igc3BsaXQg" + + "ZGVwbG95bWVudHMsIHVwZGF0ZSBvbmx5IGRpcmVjdApHYXRld2F5LWFkZHJlc3MgZmllbGRzIGFu" + + "ZCByZWZyZXNoIHJlZ2lzdHJhdGlvbiBhbmQgaW5zdGFsbGF0aW9uIHRocm91Z2ggdGhlCnNhbWUg" + + "c2VsZWN0ZWQgaGFuZG9mZi4gU2VlCltFeGFtcGxlIDRdKC4uL2V4YW1wbGVzLm1kI2V4YW1wbGUt" + + "NC1yZWNvdmVyLWZyb20tYS1nYXRld2F5LWVuZHBvaW50LWNoYW5nZSkuCgojIyBVc2VmdWwgTmFt" + + "ZXNwYWNlLXRvLVNlcnZpY2UgTWFwcGluZwoKUXVpY2sgcmVmZXJlbmNlIGZvciB3aGljaCBzZXJ2" + + "aWNlcyBydW4gaW4gd2hpY2ggbmFtZXNwYWNlOgoKfCBOYW1lc3BhY2UgfCBTZXJ2aWNlcyB8Cnwt" + + "LS0tLS0tLS0tLXwtLS0tLS0tLS0tfAp8IG5hdHMtc3lzdGVtIHwgbmF0cyB8CnwgY2Fzc2FuZHJh" + + "LXN5c3RlbSB8IGNhc3NhbmRyYSB8CnwgdmF1bHQtc3lzdGVtIHwgb3BlbmJhby1zZXJ2ZXIgfAp8" + + "IG52Y2YgfCBhcGksIGludm9jYXRpb24tc2VydmljZSwgZ3JwYy1wcm94eSwgbm90YXJ5LXNlcnZp" + + "Y2UsIHJldmFsLCBsbG0tcmVxdWVzdC1yb3V0ZXIsIGxsbS1hcGktZ2F0ZXdheSB8CnwgYXBpLWtl" + + "eXMgfCBhcGkta2V5cywgYWRtaW4taXNzdWVyLXByb3h5IHwKfCBlc3MgfCBlc3MtYXBpIHwKfCBz" + + "aXMgfCBzaXMgfAp8IGVudm95LWdhdGV3YXktc3lzdGVtIHwgZW52b3kgZ2F0ZXdheSAoaW5ncmVz" + + "cyBjb250cm9sbGVyKSB8CnwgZW52b3ktZ2F0ZXdheSB8IGdhdGV3YXkgcmVzb3VyY2UgKyByb3V0" + + "ZXMgfApQSwcIVj5nkJUwAACVMAAAUEsDBBQACAAAAAAAIQAAAAAAAAAAAAAAAABEAAkAZGF0YS9u" + + "dmNmLXNlbGYtbWFuYWdlZC1pbnN0YWxsYXRpb24vcmVmZXJlbmNlcy9oZWxtZmlsZS1zdHJ1Y3R1" + + "cmUubWRVVAUAAQCmzhIjIEhlbG1maWxlIFN0cnVjdHVyZSBSZWZlcmVuY2UKCiMjIERpcmVjdG9y" + + "eSBMYXlvdXQKCmBgYApudmNmLXNlbGYtbWFuYWdlZC1zdGFjay8KfC0tIGhlbG1maWxlLmQvCnwg" + + "ICB8LS0gMDEtZGVwZW5kZW5jaWVzLnlhbWwuZ290bXBsICAjIE5BVFMsIENhc3NhbmRyYSwgT3Bl" + + "bkJhbwp8ICAgfC0tIDAyLWNvcmUueWFtbC5nb3RtcGwgICAgICAgICAgIyBOVkNGIHNlcnZpY2Vz" + + "ICsgaW5ncmVzcwp8ICAgYC0tIDAzLW9ic2VydmFiaWxpdHkueWFtbC5nb3RtcGwgIyBPYnNlcnZh" + + "YmlsaXR5IHN0YWNrIChvcHRpb25hbCkKfC0tIGVudmlyb25tZW50cy8KfCAgIHwtLSBiYXNlLnlh" + + "bWwgICAgICAgICAgICAgICAgICAgICMgRGVmYXVsdCB2YWx1ZXMgKGFsbCBlbnZpcm9ubWVudHMp" + + "CnwgICBgLS0gPGVudi1uYW1lPi55YW1sICAgICAgICAgICAgICAjIFBlci1lbnZpcm9ubWVudCBv" + + "dmVycmlkZXMKfC0tIHNlY3JldHMvCnwgICBgLS0gPGVudi1uYW1lPi1zZWNyZXRzLnlhbWwgICAg" + + "ICAjIFNlbnNpdGl2ZSB2YWx1ZXMgKHJlZ2lzdHJ5IGNyZWRzLCBwYXNzd29yZHMpCmAtLSBnbG9i" + + "YWwueWFtbC5nb3RtcGwgICAgICAgICAgICAgICAjIEdvIHRlbXBsYXRlIHRoYXQgY29uc3RydWN0" + + "cyBwZXItY2hhcnQgdmFsdWVzCgpudmNmLWNvbXB1dGUtcGxhbmUtc3RhY2svCnwtLSBoZWxtZmls" + + "ZS5kLwp8ICAgfC0tIDAxLWRlcGVuZGVuY2llcy55YW1sLmdvdG1wbCAgIyBDb21wdXRlIHBsYW5l" + + "IGRlcGVuZGVuY3kgY29tcG9uZW50cwp8ICAgYC0tIDAyLW52Y2EueWFtbC5nb3RtcGwgICAgICAg" + + "ICAgIyBudmNhLW9wZXJhdG9yIGNoYXJ0IGFuZCBudmNhIGNvbmZpZ3VyYXRpb24KfC0tIGVudmly" + + "b25tZW50cy8KfCAgIHwtLSBiYXNlLnlhbWwgICAgICAgICAgICAgICAgICAgICMgRGVmYXVsdCB2" + + "YWx1ZXMgKGFsbCBlbnZpcm9ubWVudHMpCnwgICBgLS0gPGVudi1uYW1lPi55YW1sICAgICAgICAg" + + "ICAgICAjIFBlci1lbnZpcm9ubWVudCBvdmVycmlkZXMKYC0tIGdsb2JhbC55YW1sLmdvdG1wbCAg" + + "ICAgICAgICAgICAgICMgR28gdGVtcGxhdGUgdGhhdCBjb25zdHJ1Y3RzIHBlci1jaGFydCB2YWx1" + + "ZXMKYGBgCgpUaGVzZSBzdGFja3MgaGF2ZSBzZXBhcmF0ZSBlbnZpcm9ubWVudHMgYW5kIGNsdXN0" + + "ZXIgY29udGV4dHMuIFRoZSBIZWxtZmlsZQp2YWx1ZXMgZmxvdyBhdXRob3JzIGJvdGggZW52aXJv" + + "bm1lbnQgZmlsZXMuIFRoZSBDTEkgcHJvZmlsZSBmbG93IGluc3RlYWQgdXNlcwp0aGUgQ0xJLWdl" + + "bmVyYXRlZCBjb250cm9sLXBsYW5lIHByb2ZpbGUgYXMgaXRzIGVuZHBvaW50IHNvdXJjZS4gRG8g" + + "bm90IG1peCB0aGUKaGFuZG9mZnMuIFNlZSBbU3BsaXQgQ29tcHV0ZS1QbGFuZSBJbnN0YWxsYXRp" + + "b25dKGNvbXB1dGUtcGxhbmUtaW5zdGFsbGF0aW9uLm1kKS4KCiMjIEdvdG1wbCBGaWxlcyBhbmQg" + + "VGhlaXIgUmVsZWFzZXMKCiMjIyAwMS1kZXBlbmRlbmNpZXMueWFtbC5nb3RtcGwKCnwgUmVsZWFz" + + "ZSB8IENoYXJ0IHwgTmFtZXNwYWNlIHwgTm90ZXMgfAp8LS0tLS0tLS0tfC0tLS0tLS18LS0tLS0t" + + "LS0tLS18LS0tLS0tLXwKfCBuYXRzIHwgaGVsbS1udmNmLW5hdHMgfCBuYXRzLXN5c3RlbSB8IE1l" + + "c3NhZ2luZyB8Cnwgb3BlbmJhby1zZXJ2ZXIgfCBoZWxtLW52Y2Ytb3BlbmJhby1zZXJ2ZXIgfCB2" + + "YXVsdC1zeXN0ZW0gfCBTZWNyZXRzIG1hbmFnZW1lbnQsIGRlcGVuZHMgb24gbmF0cyB8CnwgY2Fz" + + "c2FuZHJhIHwgaGVsbS1udmNmLWNhc3NhbmRyYSB8IGNhc3NhbmRyYS1zeXN0ZW0gfCBEYXRhYmFz" + + "ZSB8CgpVc2VzIGA8PDogKmRlcGVuZGVuY3lgIHRlbXBsYXRlIGluaGVyaXRhbmNlIHdpdGggYHJl" + + "bGVhc2UtZ3JvdXA6IGRlcGVuZGVuY2llc2AgbGFiZWwuCgojIyMgMDItY29yZS55YW1sLmdvdG1w" + + "bAoKfCBSZWxlYXNlIHwgQ2hhcnQgfCBOYW1lc3BhY2UgfCBMYWJlbCB8CnwtLS0tLS0tLS18LS0t" + + "LS0tLXwtLS0tLS0tLS0tLXwtLS0tLS0tfAp8IGFwaS1rZXlzIHwgaGVsbS1udmNmLWFwaS1rZXlz" + + "IHwgYXBpLWtleXMgfCBzZXJ2aWNlcyB8Cnwgc2lzIHwgaGVsbS1udmNmLXNpcyB8IHNpcyB8IHNl" + + "cnZpY2VzIHwKfCBhcGkgfCBoZWxtLW52Y2YtYXBpIHwgbnZjZiB8IHNlcnZpY2VzIHwKfCBpbnZv" + + "Y2F0aW9uLXNlcnZpY2UgfCBoZWxtLW52Y2YtaW52b2NhdGlvbi1zZXJ2aWNlIHwgbnZjZiB8IHNl" + + "cnZpY2VzIHwKfCBncnBjLXByb3h5IHwgaGVsbS1udmNmLWdycGMtcHJveHkgfCBudmNmIHwgc2Vy" + + "dmljZXMgfAp8IGVzcy1hcGkgfCBoZWxtLW52Y2YtZXNzLWFwaSB8IGVzcyB8IHNlcnZpY2VzIHwK" + + "fCBub3Rhcnktc2VydmljZSB8IGhlbG0tbnZjZi1ub3Rhcnktc2VydmljZSB8IG52Y2YgfCBzZXJ2" + + "aWNlcyB8CnwgcmV2YWwgfCBoZWxtLXJldmFsIHwgbnZjZiB8IHNlcnZpY2VzIHwKfCBsbG0tcmVx" + + "dWVzdC1yb3V0ZXIgfCBudmNmL2hlbG0tbnZjZi1sbG0tcmVxdWVzdC1yb3V0ZXIgfCBudmNmIHwg" + + "c2VydmljZXMgfAp8IGxsbS1hcGktZ2F0ZXdheSB8IG52Y2YvaGVsbS1udmNmLWxsbS1hcGktZ2F0" + + "ZXdheSB8IG52Y2YgfCBzZXJ2aWNlcyB8CnwgYWRtaW4taXNzdWVyLXByb3h5IHwgaGVsbS1hZG1p" + + "bi10b2tlbi1pc3N1ZXItcHJveHkgfCBhcGkta2V5cyB8IChubyByZWxlYXNlLWdyb3VwIGxhYmVs" + + "KSB8CnwgaW5ncmVzcyB8IG52Y2YtZ2F0ZXdheS1yb3V0ZXMgfCBlbnZveS1nYXRld2F5LXN5c3Rl" + + "bSB8IGluZ3Jlc3MgfAoKTW9zdCBzZXJ2aWNlcyB1c2UgYGluaGVyaXQ6IFt7dGVtcGxhdGU6IHNl" + + "cnZpY2V9XWAuIExMTSByZWxlYXNlcyB1c2UgT0NJIGNoYXJ0cyBmcm9tIHRoZSBgbnZjZmAgcmVw" + + "b3NpdG9yeSB3aXRoIHN0YW5kYWxvbmUgYHZhbHVlczogWy4uL2dsb2JhbC55YW1sLmdvdG1wbF1g" + + "IGJsb2NrczsgdGhleSBhcmUgZ2F0ZWQgb24gYGFkZG9ucy5sbG0uZW5hYmxlZGAuIGBhZG1pbi1p" + + "c3N1ZXItcHJveHlgIGFuZCBgaW5ncmVzc2AgaGF2ZSBzdGFuZGFsb25lIGB2YWx1ZXM6YCBibG9j" + + "a3MuCgojIyMgMDMtb2JzZXJ2YWJpbGl0eS55YW1sLmdvdG1wbAoKfCBSZWxlYXNlIHwgQ2hhcnQg" + + "fCBOYW1lc3BhY2UgfCBMYWJlbCB8CnwtLS0tLS0tLS18LS0tLS0tLXwtLS0tLS0tLS0tLXwtLS0t" + + "LS0tfAp8IChvYnNlcnZhYmlsaXR5IHJlbGVhc2VzKSB8ICh2YXJpb3VzKSB8IG9ic2VydmFiaWxp" + + "dHkgfCBvYnNlcnZhYmlsaXR5IHwKCkdhdGVkIG9uIG9ic2VydmFiaWxpdHktc3BlY2lmaWMgZmxh" + + "Z3MgaW4gdGhlIGVudmlyb25tZW50IGZpbGUuIFNraXBwZWQgaWYgZGlzYWJsZWQuCgojIyBUZW1w" + + "bGF0ZSBJbmhlcml0YW5jZQoKIyMjIGA8PDogKmRlcGVuZGVuY3lgIChZQU1MIG1lcmdlKQoKVXNl" + + "ZCBpbiBgMDEtZGVwZW5kZW5jaWVzLnlhbWwuZ290bXBsYC4gTWVyZ2VzIHRoZSB0ZW1wbGF0ZSdz" + + "IHByb3BlcnRpZXMgaW50byB0aGUgcmVsZWFzZS4KCioqR290Y2hhKio6IFlBTUwgbWVyZ2UgcmVw" + + "bGFjZXMgbGlzdHMuIElmIHlvdSBhZGQgYSBgdmFsdWVzOmAga2V5IHRvIHRoZSByZWxlYXNlLCBp" + + "dCAqKnJlcGxhY2VzKiogdGhlIHRlbXBsYXRlJ3MgYHZhbHVlczpgIGxpc3QgZW50aXJlbHkuIFlv" + + "dSBtdXN0IHJlLWluY2x1ZGUgYWxsIHRlbXBsYXRlIHZhbHVlczoKCkluIHRoZSB0ZW1wbGF0ZSBi" + + "ZWxvdywgYDxwcml2YXRlLXZhbHVlcz5gIHJlZmVycyB0byB0aGUgYHNlY3JldHMvYCBkaXJlY3Rv" + + "cnkgYXQgdGhlIGhlbG1maWxlIHN0YWNrIHJvb3QuCgpgYGB5YW1sCiMgVGVtcGxhdGUgZGVmaW5l" + + "czoKdGVtcGxhdGVzOgogIGRlcGVuZGVuY3k6ICZkZXBlbmRlbmN5CiAgICBjaGFydDogbnZjZi9o" + + "ZWxtLW52Y2Yte3sgLlJlbGVhc2UuTmFtZSB9fQogICAgdmFsdWVzOgogICAgICAtIC4uL2dsb2Jh" + + "bC55YW1sLmdvdG1wbAogICAgICAtIC4uLzxwcml2YXRlLXZhbHVlcz4ve3sgcmVxdWlyZWRFbnYg" + + "IkhFTE1GSUxFX0VOViIgfX0tc2VjcmV0cy55YW1sCgojIFdoZW4gb3ZlcnJpZGluZywgTVVTVCBy" + + "ZS1pbmNsdWRlIGJvdGg6Ci0gbmFtZTogY2Fzc2FuZHJhCiAgPDw6ICpkZXBlbmRlbmN5CiAgdmFs" + + "dWVzOgogICAgLSAuLi9nbG9iYWwueWFtbC5nb3RtcGwgICAgICAgICAgICAgICAgICAgICAgICAg" + + "ICAgICAgICAgICAgICAgICAgICAgIyBNdXN0IHJlLWluY2x1ZGUKICAgIC0gLi4vPHByaXZhdGUt" + + "dmFsdWVzPi97eyByZXF1aXJlZEVudiAiSEVMTUZJTEVfRU5WIiB9fS1zZWNyZXRzLnlhbWwgICAj" + + "IE11c3QgcmUtaW5jbHVkZQogICAgLSBjYXNzYW5kcmE6ICAgICAgICAgICAgICAgICAgICAgICAg" + + "ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICMgWW91ciBvdmVycmlkZQogICAgICAg" + + "IHJlc291cmNlczoKICAgICAgICAgIGxpbWl0czoKICAgICAgICAgICAgbWVtb3J5OiA4MTkyTWkK" + + "YGBgCgojIyMgYGluaGVyaXRgIChIZWxtZmlsZSBuYXRpdmUpCgpVc2VkIGluIGAwMi1jb3JlLnlh" + + "bWwuZ290bXBsYC4gSGVsbWZpbGUncyBuYXRpdmUgaW5oZXJpdGFuY2UgbWVjaGFuaXNtLgoKYGBg" + + "eWFtbAotIG5hbWU6IGFwaQogIHZlcnNpb246IDEuNi4wCiAgbmFtZXNwYWNlOiBudmNmCiAgaW5o" + + "ZXJpdDoKICAgIC0gdGVtcGxhdGU6IHNlcnZpY2UKYGBgCgpXaGVuIGFkZGluZyBgdmFsdWVzOmAg" + + "dG8gYW4gaW5oZXJpdGVkIHJlbGVhc2UsIHlvdSBhbHNvIG5lZWQgdG8gcmUtaW5jbHVkZSB0aGUg" + + "dGVtcGxhdGUncyB2YWx1ZXMgZmlsZXMgc2luY2UgYHZhbHVlc2AgaXMgYSBsaXN0IHRoYXQgZ2V0" + + "cyByZXBsYWNlZC4KCiMjIFZhbHVlcyBQcmVjZWRlbmNlCgpGcm9tIGxvd2VzdCB0byBoaWdoZXN0" + + "IHByaW9yaXR5OgoKMS4gYGVudmlyb25tZW50cy9iYXNlLnlhbWxgIC0tIGRlZmF1bHRzIHNoYXJl" + + "ZCBhY3Jvc3MgYWxsIGVudmlyb25tZW50cwoyLiBgZW52aXJvbm1lbnRzLzxlbnY+LnlhbWxgIC0t" + + "IHBlci1lbnZpcm9ubWVudCBvdmVycmlkZXMKMy4gYGdsb2JhbC55YW1sLmdvdG1wbGAgLS0gR28g" + + "dGVtcGxhdGUgcHJvY2Vzc2luZyAoY29uc3RydWN0cyBjaGFydC1zcGVjaWZpYyBzdHJ1Y3R1cmUp" + + "CjQuIGA8cHJpdmF0ZS12YWx1ZXM+LzxlbnY+LXNlY3JldHMueWFtbGAgLS0gc2Vuc2l0aXZlIHZh" + + "bHVlcwo1LiBJbmxpbmUgYHZhbHVlczpgIGJsb2NrcyBvbiByZWxlYXNlcyAtLSBoaWdoZXN0IHBy" + + "ZWNlZGVuY2UKCiMjIFdoYXQgZ2xvYmFsLnlhbWwuZ290bXBsIFBhc3NlcyBUaHJvdWdoCgpgZ2xv" + + "YmFsLnlhbWwuZ290bXBsYCByZWFkcyBmcm9tIGAuVmFsdWVzYCAodGhlIG1lcmdlZCBlbnZpcm9u" + + "bWVudCArIGVudi1zcGVjaWZpYyBZQU1MKSBhbmQgY29uc3RydWN0cyBjaGFydC1zcGVjaWZpYyB2" + + "YWx1ZXMuIEl0IG9ubHkgcGFzc2VzIHRocm91Z2gga2V5cyBpdCBleHBsaWNpdGx5IHJlZmVyZW5j" + + "ZXM6CgojIyMgQ2Fzc2FuZHJhCi0gYGNhc3NhbmRyYS5yZXBsaWNhQ291bnRgCi0gYGNhc3NhbmRy" + + "YS5pbWFnZS4qYCAocmVnaXN0cnksIHJlcG9zaXRvcnkpCi0gYGNhc3NhbmRyYS5taWdyYXRpb25z" + + "LmltYWdlLipgCi0gYGNhc3NhbmRyYS5wZXJzaXN0ZW5jZS5zaXplYAotIGBjYXNzYW5kcmEubm9k" + + "ZVNlbGVjdG9yYCAoaWYgYGdsb2JhbC5ub2RlU2VsZWN0b3JzLmVuYWJsZWRgKQotIGBjYXNzYW5k" + + "cmEuZ2xvYmFsLmRlZmF1bHRTdG9yYWdlQ2xhc3NgCgojIyMgTkFUUwotIGBuYXRzLmNvbnRhaW5l" + + "ci5pbWFnZS4qYAotIGBuYXRzLnJlbG9hZGVyLmltYWdlLipgCi0gYG5hdHMubmF0c0JveC5jb250" + + "YWluZXIuaW1hZ2UuKmAKLSBgbmF0cy5jb25maWcuamV0c3RyZWFtLmZpbGVTdG9yZS5wdmMuc3Rv" + + "cmFnZUNsYXNzTmFtZWAKLSBgbmF0cy5wb2RUZW1wbGF0ZS5tZXJnZS5zcGVjLm5vZGVTZWxlY3Rv" + + "cmAgKGlmIGVuYWJsZWQpCgojIyMgT3BlbkJhbwotIGBvcGVuYmFvLm1pZ3JhdGlvbnMuaW1hZ2Uu" + + "KmAgYW5kIGBvcGVuYmFvLm1pZ3JhdGlvbnMuZW52YAotIGBvcGVuYmFvLmluamVjdG9yLmltYWdl" + + "LipgCi0gYG9wZW5iYW8uc2VydmVyLmltYWdlLipgCi0gYG9wZW5iYW8uc2VydmVyLmRhdGFTdG9y" + + "YWdlLipgCi0gTm9kZSBzZWxlY3RvcnMgKGlmIGVuYWJsZWQpCgojIyMgU2VydmljZXMgKEFQSSwg" + + "U0lTLCBldGMuKQotIGA8c2VydmljZT4uaW1hZ2UuKmAgKHJlZ2lzdHJ5LCByZXBvc2l0b3J5KQot" + + "IGA8c2VydmljZT4ubm9kZVNlbGVjdG9yYCAoaWYgZW5hYmxlZCkKLSBgPHNlcnZpY2U+LmVudi4q" + + "YCAob2JzZXJ2YWJpbGl0eSBzZXR0aW5ncykKCiMjIyBMTE0gRnVuY3Rpb24gRW5hYmxlbWVudAoK" + + "RW5hYmxlIHRoZSBMTE0gYWRkb24gYmVmb3JlIGNyZWF0aW5nIG9yIGludm9raW5nIGZ1bmN0aW9u" + + "cyB3aXRoCmBmdW5jdGlvblR5cGU6ICJMTE0iYC4gVGhlIGFkZG9uIGRlcGxveXMgYGxsbS1yZXF1" + + "ZXN0LXJvdXRlcmAgYW5kCmBsbG0tYXBpLWdhdGV3YXlgLCBhZGRzIHRoZSBgbGxtLmludm9jYXRp" + + "b24uPGRvbWFpbj5gIHJvdXRlIHdoZW4gR2F0ZXdheSBBUEkKaW5ncmVzcyBpcyBlbmFibGVkLCBh" + + "bmQgY29uZmlndXJlcyB3b3JrZXJzIHRvIHVzZSB0aGUgTExNIHNpZGVjYXIuIFRoZSBIZWxtZmls" + + "ZQpjb25kaXRpb24gaXMgYGFkZG9ucy5sbG0uZW5hYmxlZGAuIERvIG5vdCB1c2UgdGhlIG9ic29s" + + "ZXRlIGBsbG0uZW5hYmxlZGAgcGF0aC4KCkZvciBhIHNpbmdsZS1ub2RlIGlzb2xhdGVkIHRlc3Qg" + + "Y2x1c3RlciwgYWRkIHRoaXMgY29uZmlndXJhdGlvbiB0bwpgZW52aXJvbm1lbnRzLzxlbnY+Lnlh" + + "bWxgIGJlZm9yZSBhcHBseWluZyB0aGUgc3RhY2s6CgpgYGB5YW1sCmFkZG9uczoKICBsbG06CiAg" + + "ICBlbmFibGVkOiB0cnVlCiAgICBnYXRld2F5OgogICAgICByZXBsaWNhQ291bnQ6IDEKICAgICAg" + + "YXV0aDoKICAgICAgICBncnBjSW5zZWN1cmU6IHRydWUKICAgICAgbWV0cmljczoKICAgICAgICBz" + + "ZXJ2aWNlTW9uaXRvcjoKICAgICAgICAgIGVuYWJsZWQ6IGZhbHNlCiAgICByZXF1ZXN0Um91dGVy" + + "OgogICAgICByZXBsaWNhQ291bnQ6IDEKICAgICAgbWV0cmljczoKICAgICAgICBzZXJ2aWNlTW9u" + + "aXRvcjoKICAgICAgICAgIGVuYWJsZWQ6IGZhbHNlCgphZ2VudENvbmZpZzoKICBtZXJnZUNvbmZp" + + "ZzogfAogICAgY2x1c3RlcjoKICAgICAgdmFsaWRhdGlvblBvbGljeToKICAgICAgICBuYW1lOiBV" + + "bnJlc3RyaWN0ZWQKICAgIHdvcmtsb2FkOgogICAgICBzdGFyZ2F0ZVFVSUNJbnNlY3VyZTogdHJ1" + + "ZQpgYGAKClVzZSBgcmVwbGljYUNvdW50OiAxYCBvbmx5IGZvciBsb2NhbCBvciBzaW5nbGUtbm9k" + + "ZSB0ZXN0IGNsdXN0ZXJzLiBGb3Igc2hhcmVkCm9yIHByb2R1Y3Rpb24gY2x1c3RlcnMsIHVzZSB0" + + "aGUgcmVxdWlyZWQgcmVwbGljYSBjb3VudCBhbmQgVExTLWNhcGFibGUgc2VydmljZQpjb25maWd1" + + "cmF0aW9uLiBgYWRkb25zLmxsbS5nYXRld2F5LmF1dGguZ3JwY0luc2VjdXJlYCBhbmQKYHdvcmts" + + "b2FkLnN0YXJnYXRlUVVJQ0luc2VjdXJlYCBlbmFibGUgcGxhaW50ZXh0IHRyYW5zcG9ydHMuIERv" + + "IG5vdCB1c2UgdGhlbSBpbgpwcm9kdWN0aW9uLgoKVGhlIHJlcXVlc3Qgcm91dGVyIHVzZXMgYHBv" + + "d2VyLW9mLXR3b2Agd2hlbiBubyBsb2FkLWJhbGFuY2VyIGNvbmZpZ3VyYXRpb24gaXMKc2V0LiBD" + + "b25maWd1cmUgb3RoZXIgcm91dGluZyBtZXRob2RzIHdpdGggdGhlCltMTE0gUmVxdWVzdCBSb3V0" + + "ZXIgTG9hZCBCYWxhbmNpbmddKGh0dHBzOi8vZ2l0aHViLmNvbS9OVklESUEvbnZjZi9ibG9iL21h" + + "aW4vZG9jcy91c2VyL2xsbS1yZXF1ZXN0LXJvdXRlci1sb2FkLWJhbGFuY2luZy5tZCkKZ3VpZGUu" + + "CgpJZiB0aGUgc2lkZWNhciBpbWFnZSBpcyBtaXJyb3JlZCBvdXRzaWRlIHRoZSBzdGFjaydzIGRl" + + "ZmF1bHQgaW1hZ2UgcmVnaXN0cnkgYW5kCnJlcG9zaXRvcnksIHNldCB0aGUgZ2VuZXJhdGVkIHdv" + + "cmtlciBzaWRlY2FyIGltYWdlIGV4cGxpY2l0bHk6CgpgYGB5YW1sCmFwaToKICBlbnY6CiAgICBO" + + "VkNGX1NJREVDQVJTX0xMTV9ST1VURVJfQ0xJRU5UX0lNQUdFOiA8cmVnaXN0cnk+LzxyZXBvc2l0" + + "b3J5Pi9weWxvbjowLjIuMQpgYGAKClJlbmRlciBhbmQgYXBwbHkgdGhlIHVwZGF0ZWQgY29udHJv" + + "bC1wbGFuZSBlbnZpcm9ubWVudCwgdGhlbiByZWZyZXNoIGV2ZXJ5CnJlZ2lzdGVyZWQgY29tcHV0" + + "ZSBwbGFuZSB1c2luZyB0aGUgc2FtZSBoYW5kb2ZmIHVzZWQgZm9yIGl0cyBpbnN0YWxsYXRpb24g" + + "c28KTlZDQSByZWNlaXZlcyBgYWdlbnRDb25maWcubWVyZ2VDb25maWdgOgoKYGBgYmFzaApIRUxN" + + "RklMRV9FTlY9PGVudj4gaGVsbWZpbGUgdGVtcGxhdGUKSEVMTUZJTEVfRU5WPTxlbnY+IGhlbG1m" + + "aWxlIHN5bmMKYGBgCgpVc2UgdGhlIGNvbXBsZXRlIGNvbXB1dGUtcGxhbmUgaW5zdGFsbCBjb21t" + + "YW5kIGZyb20KW1NwbGl0IENvbXB1dGUtUGxhbmUgSW5zdGFsbGF0aW9uXShjb21wdXRlLXBsYW5l" + + "LWluc3RhbGxhdGlvbi5tZCkuIEEKQ0xJLXByb2ZpbGUgaW5zdGFsbGF0aW9uIG11c3QgcmVtYWlu" + + "IHByb2ZpbGUtZHJpdmVuOyBhIEhlbG1maWxlIGluc3RhbGxhdGlvbgptdXN0IHJlbWFpbiB2YWx1" + + "ZXMtZHJpdmVuLgoKRXhpc3RpbmcgTExNIGZ1bmN0aW9uIHBvZHMga2VlcCB0aGVpciBleGlzdGlu" + + "ZyBzaWRlY2FyIGFyZ3VtZW50cy4gUmVjcmVhdGUgb3IKcmVkZXBsb3kgdGhvc2UgZnVuY3Rpb25z" + + "IGFmdGVyIHRoZSBjb21wdXRlLXBsYW5lIHJlZnJlc2guIFZlcmlmeSB0aGUgY29udHJvbApwbGFu" + + "ZSwgcm91dGUsIGFuZCB3b3JrZXIgc2lkZWNhcjoKCmBgYGJhc2gKa3ViZWN0bCBnZXQgZGVwbG95" + + "IC1uIG52Y2YgbGxtLWFwaS1nYXRld2F5Cmt1YmVjdGwgZ2V0IHN0YXRlZnVsc2V0IC1uIG52Y2Yg" + + "bGxtLXJlcXVlc3Qtcm91dGVyCmt1YmVjdGwgZ2V0IHBvZHMgLW4gbnZjZiB8IGdyZXAgLUUgJ2xs" + + "bS1hcGktZ2F0ZXdheXxsbG0tcmVxdWVzdC1yb3V0ZXInCmt1YmVjdGwgZ2V0IGh0dHByb3V0ZSAt" + + "QSB8IGdyZXAgbGxtCmt1YmVjdGwgLW4gbnZjZi1iYWNrZW5kIGdldCBwb2QgPGZ1bmN0aW9uLXBv" + + "ZD4gXAogIC1vIGpzb25wYXRoPSd7cmFuZ2UgLnNwZWMuY29udGFpbmVyc1s/KEAubmFtZT09Imxs" + + "bS13b3JrZXIiKV0uYXJnc1sqXX17Ln17IlxcbiJ9e2VuZH0nCmBgYAoKRm9yIGxvY2FsIHBsYWlu" + + "dGV4dCBjbHVzdGVycywgdGhlIGBsbG0td29ya2VyYCBhcmdzIG11c3QgaW5jbHVkZQpgLS1xdWlj" + + "LWluc2VjdXJlYC4KCkZvciBsb2FkLWJhbGFuY2VyIHNjaGVtYSBhbmQgYWxnb3JpdGhtIGJlaGF2" + + "aW9yLCBzZWUgdGhlCltTdGFyZ2F0ZSBjb25maWd1cmF0aW9uIGd1aWRlXShodHRwczovL2dpdGh1" + + "Yi5jb20vTlZJRElBL252Y2YvYmxvYi9tYWluL3NyYy9saWJyYXJpZXMvcnVzdC9zdGFyZ2F0ZS9k" + + "b2NzL2xvYWQtYmFsYW5jZXItY29uZmlndXJhdGlvbi5tZCkuCgojIyBIZWxtZmlsZSBTZWxlY3Rv" + + "cnMKClRhcmdldCBzcGVjaWZpYyByZWxlYXNlcyBvciBncm91cHM6CgpgYGBiYXNoCiMgQnkgcmVs" + + "ZWFzZSBncm91cApIRUxNRklMRV9FTlY9PGVudj4gaGVsbWZpbGUgLS1zZWxlY3RvciByZWxlYXNl" + + "LWdyb3VwPWRlcGVuZGVuY2llcyBzeW5jCkhFTE1GSUxFX0VOVj08ZW52PiBoZWxtZmlsZSAtLXNl" + + "bGVjdG9yIHJlbGVhc2UtZ3JvdXA9c2VydmljZXMgc3luYwpIRUxNRklMRV9FTlY9PGVudj4gaGVs" + + "bWZpbGUgLS1zZWxlY3RvciByZWxlYXNlLWdyb3VwPWluZ3Jlc3Mgc3luYwpIRUxNRklMRV9FTlY9" + + "PGVudj4gaGVsbWZpbGUgLS1zZWxlY3RvciByZWxlYXNlLWdyb3VwPW9ic2VydmFiaWxpdHkgc3lu" + + "YwoKIyBCeSByZWxlYXNlIG5hbWUKSEVMTUZJTEVfRU5WPTxlbnY+IGhlbG1maWxlIC0tc2VsZWN0" + + "b3IgbmFtZT1jYXNzYW5kcmEgc3luYwpIRUxNRklMRV9FTlY9PGVudj4gaGVsbWZpbGUgLS1zZWxl" + + "Y3RvciBuYW1lPWFkbWluLWlzc3Vlci1wcm94eSBzeW5jCkhFTE1GSUxFX0VOVj08ZW52PiBoZWxt" + + "ZmlsZSAtLXNlbGVjdG9yIG5hbWU9bGxtLXJlcXVlc3Qtcm91dGVyIHN5bmMKSEVMTUZJTEVfRU5W" + + "PTxlbnY+IGhlbG1maWxlIC0tc2VsZWN0b3IgbmFtZT1sbG0tYXBpLWdhdGV3YXkgc3luYwoKIyBU" + + "ZW1wbGF0ZSBvbmx5IChkcnkgcnVuKQpIRUxNRklMRV9FTlY9PGVudj4gaGVsbWZpbGUgLS1zZWxl" + + "Y3RvciBuYW1lPWNhc3NhbmRyYSB0ZW1wbGF0ZQoKIyBEZXN0cm95IGEgc2luZ2xlIHJlbGVhc2UK" + + "SEVMTUZJTEVfRU5WPTxlbnY+IGhlbG1maWxlIC0tc2VsZWN0b3IgbmFtZT1jYXNzYW5kcmEgZGVz" + + "dHJveQpgYGAKCk5vdGU6IGBhZG1pbi1pc3N1ZXItcHJveHlgIGhhcyBubyBgcmVsZWFzZS1ncm91" + + "cGAgbGFiZWwuIFVzZSBgLS1zZWxlY3RvciBuYW1lPWFkbWluLWlzc3Vlci1wcm94eWAuClBLBwjA" + + "ViDnjycAAI8nAABQSwMEFAAIAAAAAAAhAAAAAAAAAAAAAAAAAD8ACQBkYXRhL252Y2Ytc2VsZi1t" + + "YW5hZ2VkLWluc3RhbGxhdGlvbi9yZWZlcmVuY2VzL252Y2YtdWktYWRkb24ubWRVVAUAAQCmzhIj" + + "IE5WQ0YgVUkgQWRkb24KCk5WQ0YgVUkgaXMgYW4gb3B0aW9uYWwsIGN1c3RvbWVyLWZhY2luZyBO" + + "VkNGIGFkbWluLXBhbmVsIFVJLiBJdCBpcyBkaXNhYmxlZCBieQpkZWZhdWx0IGFuZCBhdmFpbGFi" + + "bGUgb25seSBpbiBzdGFjayBwYWNrYWdlcyB0aGF0IGluY2x1ZGUgdGhlIE5WQ0YgVUkgYWRkb24u" + + "CgojIyBXaGVuIHRvIGVuYWJsZQoKRW5hYmxlIE5WQ0YgVUkgb25seSB3aGVuIHlvdSBuZWVkIHRo" + + "ZSBhZG1pbi1wYW5lbCBVSSBhbmQgeW91ciBleHRyYWN0ZWQgc3RhY2sKcGFja2FnZSBpbmNsdWRl" + + "cyB0aGUgYWRkb24uIElmIHRoZSBwYWNrYWdlIGRvZXMgbm90IGNvbnRhaW4gYSBgbnZjZi11aWAg" + + "cmVsZWFzZQphbmQgYG52Y2ZVaWAgcm91dGUgdmFsdWVzLCBza2lwIHRoZSBhZGRvbiB1bnRpbCB5" + + "b3UgdXNlIGEgcGFja2FnZSB0aGF0IGluY2x1ZGVzCnRoZW0uCgojIyBFbmFibGUgdGhlIGFkZG9u" + + "CgpFbmFibGUgaXQgaW4gYGVudmlyb25tZW50cy88ZW52LW5hbWU+LnlhbWxgOgoKYGBgeWFtbAph" + + "ZGRvbnM6CiAgbnZjZlVpOgogICAgZW5hYmxlZDogdHJ1ZQpgYGAKCiMjIENyZWF0ZSBuYW1lc3Bh" + + "Y2UgYW5kIGltYWdlIHB1bGwgc2VjcmV0CgpDcmVhdGUgdGhlIG5hbWVzcGFjZSwgYW5kIGFuIGlt" + + "YWdlIHB1bGwgc2VjcmV0IG9ubHkgaWYgcHVsbGluZyBmcm9tIGEgcHJpdmF0ZQpyZWdpc3RyeToK" + + "CmBgYGJhc2gKa3ViZWN0bCBjcmVhdGUgbmFtZXNwYWNlIG52Y2YtdWkgLS1kcnktcnVuPWNsaWVu" + + "dCAtbyB5YW1sIHwga3ViZWN0bCBhcHBseSAtZiAtCgojIE9ubHkgaWYgcHVsbGluZyBmcm9tIGEg" + + "cHJpdmF0ZSByZWdpc3RyeSAoZS5nLiwgTkdDIG52Y3IuaW8pCmV4cG9ydCBOR0NfQVBJX0tFWT0i" + + "PHlvdXIta2V5PiIKa3ViZWN0bCBjcmVhdGUgc2VjcmV0IGRvY2tlci1yZWdpc3RyeSBudmNyLWNy" + + "ZWRzIFwKICAtLWRvY2tlci1zZXJ2ZXI9bnZjci5pbyBcCiAgLS1kb2NrZXItdXNlcm5hbWU9JyRv" + + "YXV0aHRva2VuJyBcCiAgLS1kb2NrZXItcGFzc3dvcmQ9IiROR0NfQVBJX0tFWSIgXAogIC0tbmFt" + + "ZXNwYWNlPW52Y2YtdWkgXAogIC0tZHJ5LXJ1bj1jbGllbnQgLW8geWFtbCB8IGt1YmVjdGwgYXBw" + + "bHkgLWYgLQpgYGAKClRoZSBkZWZhdWx0IHJvdXRlIGhvc3QgaXMgYG52Y2YtdWkuPGRvbWFpbj5g" + + "IGFuZCB0aGUgYmFja2VuZCBpcwpgbnZjZi11aS5udmNmLXVpOjgzMDBgLgoKIyMgQXBwbHkgdGhl" + + "IHNlcnZpY2UgYW5kIHJvdXRlCgpBZnRlciBjb25maXJtaW5nIHRoZSBwYWNrYWdlIGluY2x1ZGVz" + + "IHRoZSBgbnZjZi11aWAgcmVsZWFzZSwgcHJldmlldyBhbmQgYXBwbHkKdGhlIHNlcnZpY2UgYW5k" + + "IHJvdXRlOgoKYGBgYmFzaApIRUxNRklMRV9FTlY9PGVudi1uYW1lPiBoZWxtZmlsZSAtLXNlbGVj" + + "dG9yIG5hbWU9bnZjZi11aSB0ZW1wbGF0ZQpIRUxNRklMRV9FTlY9PGVudi1uYW1lPiBoZWxtZmls" + + "ZSAtLXNlbGVjdG9yIG5hbWU9bnZjZi11aSBzeW5jCkhFTE1GSUxFX0VOVj08ZW52LW5hbWU+IGhl" + + "bG1maWxlIC0tc2VsZWN0b3IgcmVsZWFzZS1ncm91cD1pbmdyZXNzIHN5bmMKYGBgCgojIyBWZXJp" + + "ZnkKClZlcmlmeSB0aGUgcm91dGUgb25seSB3aGVuIHRoZSBhZGRvbiBpcyBwcmVzZW50IGFuZCBl" + + "bmFibGVkOgoKYGBgYmFzaAprdWJlY3RsIGdldCBkZXBsb3ksc3ZjIC1uIG52Y2YtdWkKa3ViZWN0" + + "bCBnZXQgaHR0cHJvdXRlIC1BIHwgZ3JlcCAtaSBudmNmLXVpCmN1cmwgLWkgLUggIkhvc3Q6IG52" + + "Y2YtdWkuPGRvbWFpbj4iICJodHRwOi8vPGdhdGV3YXktYWRkcmVzcz4vc3RhdHVzIgpgYGAKCiMj" + + "IFNlY3VyaXR5CgpUaGUgTlZDRiBVSSBhZG1pbiBwYW5lbCBpcyBjdXJyZW50bHkgdW5hdXRoZW50" + + "aWNhdGVkLiBEbyBub3QgZXhwb3NlIGl0IHRvIHRoZQpwdWJsaWMgaW50ZXJuZXQuIFJlc3RyaWN0" + + "IGFjY2VzcyB0byBhIHRydXN0ZWQgbmV0d29yaywgVlBOLCBvciBhbiBhdXRoZW50aWNhdGluZwpw" + + "cm94eSBpbiBmcm9udCBvZiB0aGUgYG52Y2YtdWlgIHJvdXRlLgpQSwcIOPknr7kHAAC5BwAAUEsD" + + "BBQACAAAAAAAIQAAAAAAAAAAAAAAAAA+AAkAZGF0YS9udmNmLXNlbGYtbWFuYWdlZC1pbnN0YWxs" + + "YXRpb24vcmVmZXJlbmNlcy9wdWxsLXNlY3JldHMubWRVVAUAAQCmzhIjIEltYWdlIFB1bGwgU2Vj" + + "cmV0cyBSZWZlcmVuY2UKCiMjIE92ZXJ2aWV3CgpXaGVuIHB1bGxpbmcgTlZDRiBpbWFnZXMgZnJv" + + "bSBhIHByaXZhdGUgcmVnaXN0cnkgKGZvciBleGFtcGxlLCBOR0MKYG52Y3IuaW9gKSwgS3ViZXJu" + + "ZXRlcyBuZWVkcyBgaW1hZ2VQdWxsU2VjcmV0c2Agb24gZXZlcnkgcG9kLiBDb250cm9sLXBsYW5l" + + "IGFuZApjb21wdXRlLXBsYW5lIGNyZWRlbnRpYWxzIGFyZSBjb25maWd1cmVkIGluIHRoZWlyIG93" + + "biBjbHVzdGVyIGNvbnRleHRzLiBEbyBub3QKdXNlIG9uZSBtaXhlZCBuYW1lc3BhY2UgbGlzdC4K" + + "ClRoZSByZWNvbW1lbmRlZCBjb250cm9sLXBsYW5lIGFwcHJvYWNoIHVzZXMgS3l2ZXJubyB0byBp" + + "bmplY3QgdGhlIHNlY3JldCBpbnRvCmNvbnRyb2wtcGxhbmUgcG9kcyBhdCBhZG1pc3Npb24gdGlt" + + "ZS4gVGhlIGNvbXB1dGUtcGxhbmUgY2hhcnQgYW5kIG9wZXJhdG9yIHVzZQp0aGUgc2VjcmV0IGlu" + + "IGBudmNhLW9wZXJhdG9yYCBhbmQgbWlycm9yIGl0IHRvIGBudmNhLXN5c3RlbWAuCgojIyBLeXZl" + + "cm5vIEFwcHJvYWNoIChSZWNvbW1lbmRlZCkKCiMjIyAxLiBJbnN0YWxsIEt5dmVybm8KCmBgYGJh" + + "c2gKaGVsbSByZXBvIGFkZCBreXZlcm5vIGh0dHBzOi8va3l2ZXJuby5naXRodWIuaW8va3l2ZXJu" + + "by8KaGVsbSByZXBvIHVwZGF0ZQpoZWxtIGluc3RhbGwga3l2ZXJubyBreXZlcm5vL2t5dmVybm8g" + + "LW4ga3l2ZXJubyAtLWNyZWF0ZS1uYW1lc3BhY2UgXAogIC0ta3ViZS1jb250ZXh0IDxjb250cm9s" + + "LXBsYW5lLWNvbnRleHQ+CmBgYAoKIyMjIDIuIENyZWF0ZSBjb250cm9sLXBsYW5lIHB1bGwgc2Vj" + + "cmV0cwoKYGBgYmFzaApleHBvcnQgTkdDX0FQSV9LRVk9Ijx5b3VyLW5nYy1hcGkta2V5PiIKCmZv" + + "ciBucyBpbiBjYXNzYW5kcmEtc3lzdGVtIG5hdHMtc3lzdGVtIG52Y2YgYXBpLWtleXMgZXNzIHNp" + + "cyB2YXVsdC1zeXN0ZW0gY2VydC1tYW5hZ2VyOyBkbwogIGt1YmVjdGwgLS1jb250ZXh0IDxjb250" + + "cm9sLXBsYW5lLWNvbnRleHQ+IGNyZWF0ZSBuYW1lc3BhY2UgIiRucyIgXAogICAgLS1kcnktcnVu" + + "PWNsaWVudCAtbyB5YW1sIHwga3ViZWN0bCAtLWNvbnRleHQgPGNvbnRyb2wtcGxhbmUtY29udGV4" + + "dD4gYXBwbHkgLWYgLQpkb25lCgpmb3IgbnMgaW4gY2Fzc2FuZHJhLXN5c3RlbSBuYXRzLXN5c3Rl" + + "bSBudmNmIGFwaS1rZXlzIGVzcyBzaXMgdmF1bHQtc3lzdGVtIGNlcnQtbWFuYWdlcjsgZG8KICBr" + + "dWJlY3RsIC0tY29udGV4dCA8Y29udHJvbC1wbGFuZS1jb250ZXh0PiBjcmVhdGUgc2VjcmV0IGRv" + + "Y2tlci1yZWdpc3RyeSBudmNyLWNyZWRzIFwKICAgIC0tZG9ja2VyLXNlcnZlcj1udmNyLmlvIFwK" + + "ICAgIC0tZG9ja2VyLXVzZXJuYW1lPSckb2F1dGh0b2tlbicgXAogICAgLS1kb2NrZXItcGFzc3dv" + + "cmQ9IiROR0NfQVBJX0tFWSIgXAogICAgLS1uYW1lc3BhY2U9IiRucyIgXAogICAgLS1kcnktcnVu" + + "PWNsaWVudCAtbyB5YW1sIHwga3ViZWN0bCAtLWNvbnRleHQgPGNvbnRyb2wtcGxhbmUtY29udGV4" + + "dD4gYXBwbHkgLWYgLQpkb25lCmBgYAoKRm9yIG5vbi1OR0MgcmVnaXN0cmllcywgcmVwbGFjZSBg" + + "LS1kb2NrZXItc2VydmVyYCwgYC0tZG9ja2VyLXVzZXJuYW1lYCwgYW5kIGAtLWRvY2tlci1wYXNz" + + "d29yZGAuCgojIyMgMy4gQXBwbHkgS3l2ZXJubyBDbHVzdGVyUG9saWN5CgpgYGB5YW1sCmFwaVZl" + + "cnNpb246IGt5dmVybm8uaW8vdjEKa2luZDogQ2x1c3RlclBvbGljeQptZXRhZGF0YToKICBuYW1l" + + "OiBudmNmLWFkZC1pbWFnZXB1bGxzZWNyZXRzCnNwZWM6CiAgYmFja2dyb3VuZDogZmFsc2UKICBy" + + "dWxlczoKICAgIC0gbmFtZTogYWRkLWltYWdlcHVsbHNlY3JldC10by1udmNmLXBvZHMKICAgICAg" + + "bWF0Y2g6CiAgICAgICAgYW55OgogICAgICAgIC0gcmVzb3VyY2VzOgogICAgICAgICAgICBraW5k" + + "czoKICAgICAgICAgICAgLSBQb2QKICAgICAgICAgICAgbmFtZXNwYWNlczoKICAgICAgICAgICAg" + + "LSAibnZjZiIKICAgICAgICAgICAgLSAiYXBpLWtleXMiCiAgICAgICAgICAgIC0gInNpcyIKICAg" + + "ICAgICAgICAgLSAiZXNzIgogICAgICAgICAgICAtICJuYXRzLXN5c3RlbSIKICAgICAgICAgICAg" + + "LSAiY2Fzc2FuZHJhLXN5c3RlbSIKICAgICAgICAgICAgLSAidmF1bHQtc3lzdGVtIgogICAgICAg" + + "ICAgICAtICJjZXJ0LW1hbmFnZXIiCiAgICAgIG11dGF0ZToKICAgICAgICBwYXRjaFN0cmF0ZWdp" + + "Y01lcmdlOgogICAgICAgICAgbWV0YWRhdGE6CiAgICAgICAgICAgIGFubm90YXRpb25zOgogICAg" + + "ICAgICAgICAgIG52Y2YubnZpZGlhLmNvbS9pbWFnZXB1bGxzZWNyZXQtaW5qZWN0ZWQtYnk6IGt5" + + "dmVybm8KICAgICAgICAgIHNwZWM6CiAgICAgICAgICAgIGltYWdlUHVsbFNlY3JldHM6CiAgICAg" + + "ICAgICAgIC0gbmFtZTogbnZjci1jcmVkcwpgYGAKCmBgYGJhc2gKa3ViZWN0bCAtLWNvbnRleHQg" + + "PGNvbnRyb2wtcGxhbmUtY29udGV4dD4gYXBwbHkgXAogIC1mIGt5dmVybm8taW1hZ2VwdWxsc2Vj" + + "cmV0LXBvbGljeS55YW1sCmBgYAoKIyMjIDQuIEluc3RhbGwgdGhlIGNvbnRyb2wgcGxhbmUKCkNv" + + "bnRpbnVlIHdpdGggdGhlIHNlbGVjdGVkIGNvbnRyb2wtcGxhbmUgaW5zdGFsbGF0aW9uIGluCltT" + + "cGxpdCBDb21wdXRlLVBsYW5lIEluc3RhbGxhdGlvbl0oY29tcHV0ZS1wbGFuZS1pbnN0YWxsYXRp" + + "b24ubWQpLiBObwpjb250cm9sLXBsYW5lIGhlbG1maWxlIG1vZGlmaWNhdGlvbnMgYXJlIG5lZWRl" + + "ZC4gS3l2ZXJubyBpbmplY3RzIHRoZSBwdWxsCnNlY3JldCBpbnRvIG5ldyBjb250cm9sLXBsYW5l" + + "IHBvZHMuCgojIyBDb21wdXRlLVBsYW5lIFNlY3JldAoKQ3JlYXRlIHRoZSBzZWNyZXQgb25seSBp" + + "biBgbnZjYS1vcGVyYXRvcmAgb24gdGhlIGNvbXB1dGUgY2x1c3RlcjoKCmBgYGJhc2gKa3ViZWN0" + + "bCAtLWNvbnRleHQgPGNvbXB1dGUtcGxhbmUtY29udGV4dD4gY3JlYXRlIG5hbWVzcGFjZSBudmNh" + + "LW9wZXJhdG9yIFwKICAtLWRyeS1ydW49Y2xpZW50IC1vIHlhbWwgfCBcCiAga3ViZWN0bCAtLWNv" + + "bnRleHQgPGNvbXB1dGUtcGxhbmUtY29udGV4dD4gYXBwbHkgLWYgLQoKa3ViZWN0bCAtLWNvbnRl" + + "eHQgPGNvbXB1dGUtcGxhbmUtY29udGV4dD4gY3JlYXRlIHNlY3JldCBkb2NrZXItcmVnaXN0cnkg" + + "bnZjci1jcmVkcyBcCiAgLS1kb2NrZXItc2VydmVyPW52Y3IuaW8gXAogIC0tZG9ja2VyLXVzZXJu" + + "YW1lPSckb2F1dGh0b2tlbicgXAogIC0tZG9ja2VyLXBhc3N3b3JkPSIkTkdDX0FQSV9LRVkiIFwK" + + "ICAtLW5hbWVzcGFjZT1udmNhLW9wZXJhdG9yIFwKICAtLWRyeS1ydW49Y2xpZW50IC1vIHlhbWwg" + + "fCBcCiAga3ViZWN0bCAtLWNvbnRleHQgPGNvbXB1dGUtcGxhbmUtY29udGV4dD4gYXBwbHkgLWYg" + + "LQpgYGAKClJlZmVyZW5jZSBpdCBpbiB0aGUgY29tcHV0ZS1wbGFuZSBlbnZpcm9ubWVudCBmaWxl" + + "OgoKYGBgeWFtbApnbG9iYWw6CiAgaW1hZ2VQdWxsU2VjcmV0czoKICAgIC0gbmFtZTogbnZjci1j" + + "cmVkcwpgYGAKClRoZSBjaGFydCBhbmQgb3BlcmF0b3IgdXNlIHRoYXQgcmVmZXJlbmNlIGluIGBu" + + "dmNhLW9wZXJhdG9yYCBhbmQgbWlycm9yIHRoZQpzZWNyZXQgdG8gYG52Y2Etc3lzdGVtYC4gRG8g" + + "bm90IGNyZWF0ZSBhIGJyb2FkZXIgbWFudWFsIGNvbXB1dGUgbmFtZXNwYWNlIGxpc3QuIEZvbGxv" + + "dwpbU3BsaXQgQ29tcHV0ZS1QbGFuZSBJbnN0YWxsYXRpb25dKGNvbXB1dGUtcGxhbmUtaW5zdGFs" + + "bGF0aW9uLm1kKSBmb3IgdGhlCnNlbGVjdGVkIGluc3RhbGwgZmxvdy4KCiMjIFZlcmlmaWNhdGlv" + + "bgoKYGBgYmFzaAojIENoZWNrIHRoYXQgYSBjb250cm9sLXBsYW5lIHBvZCBoYXMgdGhlIGluamVj" + + "dGVkIHNlY3JldAprdWJlY3RsIC0tY29udGV4dCA8Y29udHJvbC1wbGFuZS1jb250ZXh0PiBnZXQg" + + "cG9kIC1uIDxuYW1lc3BhY2U+IDxwb2QtbmFtZT4gXAogIC1vIGpzb25wYXRoPSd7LnNwZWMuaW1h" + + "Z2VQdWxsU2VjcmV0c30nCiMgRXhwZWN0ZWQ6IFt7Im5hbWUiOiJudmNyLWNyZWRzIn1dCgojIENo" + + "ZWNrIHRoZSBLeXZlcm5vIGFubm90YXRpb24Ka3ViZWN0bCAtLWNvbnRleHQgPGNvbnRyb2wtcGxh" + + "bmUtY29udGV4dD4gZ2V0IHBvZCAtbiA8bmFtZXNwYWNlPiA8cG9kLW5hbWU+IFwKICAtbyBqc29u" + + "cGF0aD0ney5tZXRhZGF0YS5hbm5vdGF0aW9ucy5udmNmXC5udmlkaWFcLmNvbS9pbWFnZXB1bGxz" + + "ZWNyZXQtaW5qZWN0ZWQtYnl9JwojIEV4cGVjdGVkOiBreXZlcm5vCgojIENoZWNrIHB1bGwgZXZl" + + "bnRzCmt1YmVjdGwgLS1jb250ZXh0IDxjb250cm9sLXBsYW5lLWNvbnRleHQ+IGdldCBldmVudHMg" + + "LW4gPG5hbWVzcGFjZT4gXAogIC0tc29ydC1ieT0nLmxhc3RUaW1lc3RhbXAnIHwgZ3JlcCAtaSBw" + + "dWxsCiMgU2hvdWxkIHNob3cgIlN1Y2Nlc3NmdWxseSBwdWxsZWQiIG5vdCAiNDAxIFVuYXV0aG9y" + + "aXplZCIKCiMgQ2hlY2sgdGhlIGNoYXJ0L29wZXJhdG9yIG1pcnJvciBvbiB0aGUgY29tcHV0ZSBj" + + "bHVzdGVyCmt1YmVjdGwgLS1jb250ZXh0IDxjb21wdXRlLXBsYW5lLWNvbnRleHQ+IGdldCBzZWNy" + + "ZXQgbnZjci1jcmVkcyBcCiAgLW4gbnZjYS1zeXN0ZW0KYGBgCgojIyBXaGVuIFB1bGwgU2VjcmV0" + + "cyBBcmUgTm90IE5lZWRlZAoKLSAqKkFXUyBFQ1Igd2l0aCBJQU0gbm9kZSByb2xlcyoqOiBJZiB5" + + "b3VyIG5vZGVzIGhhdmUgYEFtYXpvbkVDMkNvbnRhaW5lclJlZ2lzdHJ5UmVhZE9ubHlgIElBTSBw" + + "b2xpY3ksIEt1YmVybmV0ZXMgY2FuIHB1bGwgZnJvbSBFQ1Igd2l0aG91dCBleHBsaWNpdCBzZWNy" + + "ZXRzLgotICoqUHVibGljIHJlZ2lzdHJpZXMqKjogTm8gcHVsbCBzZWNyZXRzIG5lZWRlZC4KLSAq" + + "KkNTUCBidWlsdC1pbiBjcmVkZW50aWFsIGhlbHBlcnMqKjogR0tFIEFydGlmYWN0IFJlZ2lzdHJ5" + + "LCBBenVyZSBBQ1Igd2l0aCBtYW5hZ2VkIGlkZW50aXR5LCBhbmQgc2ltaWxhciBzZXJ2aWNlcy4K" + + "CiMjIFRyb3VibGVzaG9vdGluZwoKIyMjIFBvZHMgc3RpbGwgaW4gSW1hZ2VQdWxsQmFja09mZiBh" + + "ZnRlciBhcHBseWluZyBwb2xpY3kKClRoZSBLeXZlcm5vIHBvbGljeSBvbmx5IGFmZmVjdHMgcG9k" + + "cyBjcmVhdGVkICoqYWZ0ZXIqKiB0aGUgcG9saWN5IGlzIGFwcGxpZWQuIERlbGV0ZSBzdHVjayBw" + + "b2RzIHRvIHRyaWdnZXIgcmVjcmVhdGlvbjoKCmBgYGJhc2gKa3ViZWN0bCAtLWNvbnRleHQgPHRh" + + "cmdldC1jb250ZXh0PiBkZWxldGUgcG9kcyAtbiA8bmFtZXNwYWNlPiAtLWFsbApgYGAKCiMjIyBL" + + "eXZlcm5vIGFkbWlzc2lvbiBjb250cm9sbGVyIG5vdCBydW5uaW5nCgpgYGBiYXNoCmt1YmVjdGwg" + + "LS1jb250ZXh0IDxjb250cm9sLXBsYW5lLWNvbnRleHQ+IGdldCBwb2RzIC1uIGt5dmVybm8KIyBB" + + "bGwgcG9kcyBzaG91bGQgYmUgUnVubmluZwpgYGAKCiMjIyBQb2xpY3kgbm90IG1hdGNoaW5nCgpg" + + "YGBiYXNoCmt1YmVjdGwgLS1jb250ZXh0IDxjb250cm9sLXBsYW5lLWNvbnRleHQ+IGdldCBjbHVz" + + "dGVycG9saWN5IG52Y2YtYWRkLWltYWdlcHVsbHNlY3JldHMKIyBTaG91bGQgc2hvdyBSRUFEWTog" + + "VHJ1ZQpgYGAKCiMjIyBXcm9uZyBzZWNyZXQgbmFtZQoKVGhlIHBvbGljeSByZWZlcmVuY2VzIGBu" + + "dmNyLWNyZWRzYC4gVmVyaWZ5IHRoZSBzZWNyZXQgZXhpc3RzIHdpdGggdGhhdCBleGFjdCBuYW1l" + + "OgoKYGBgYmFzaAprdWJlY3RsIC0tY29udGV4dCA8dGFyZ2V0LWNvbnRleHQ+IGdldCBzZWNyZXQg" + + "bnZjci1jcmVkcyAtbiA8bmFtZXNwYWNlPgpgYGAKUEsHCEtCNagAFgAAABYAAFBLAQIUABQACAAA" + + "AAAAIQC63yMzSRAAAEkQAAASAAkAAAAAAAAAAAAAAAAAAABkYXRhL21hbmlmZXN0Lmpzb25VVAUA" + + "AQCmzhJQSwECFAAUAAgAAAAAACEAzYEw5E1hAABNYQAAIwAJAAAAAAAAAAAAAACSEAAAZGF0YS9u" + + "dmNmLXNlbGYtbWFuYWdlZC1jbGkvU0tJTEwubWRVVAUAAQCmzhJQSwECFAAUAAgAAAAAACEAIcbI" + + "hvAKAADwCgAAMwAJAAAAAAAAAAAAAAA5cgAAZGF0YS9udmNmLXNlbGYtbWFuYWdlZC1jbGkvZXhh" + + "bXBsZXMvY2ktcGlwZWxpbmVzLm1kVVQFAAEAps4SUEsBAhQAFAAIAAAAAAAhAKEU44FdDAAAXQwA" + + "ADQACQAAAAAAAAAAAAAAk30AAGRhdGEvbnZjZi1zZWxmLW1hbmFnZWQtY2xpL2V4YW1wbGVzL211" + + "bHRpLWNsdXN0ZXIubWRVVAUAAQCmzhJQSwECFAAUAAgAAAAAACEAQidJDwUNAAAFDQAANwAJAAAA" + + "AAAAAAAAAABbigAAZGF0YS9udmNmLXNlbGYtbWFuYWdlZC1jbGkvcHJvbXB0cy9hZGQtY29tcHV0" + + "ZS1wbGFuZS5tZFVUBQABAKbOElBLAQIUABQACAAAAAAAIQCR3Bv5mBkAAJgZAAA5AAkAAAAAAAAA" + + "AAAAAM6XAABkYXRhL252Y2Ytc2VsZi1tYW5hZ2VkLWNsaS9wcm9tcHRzL2NyZWF0ZS1hbmQtcnVu" + + "LXRhc2subWRVVAUAAQCmzhJQSwECFAAUAAgAAAAAACEA0kPcBBglAAAYJQAANwAJAAAAAAAAAAAA" + + "AADWsQAAZGF0YS9udmNmLXNlbGYtbWFuYWdlZC1jbGkvcHJvbXB0cy9kZXBsb3ktYW5kLWludm9r" + + "ZS5tZFVUBQABAKbOElBLAQIUABQACAAAAAAAIQAOnD+XvQ4AAL0OAAA9AAkAAAAAAAAAAAAAAFzX" + + "AABkYXRhL252Y2Ytc2VsZi1tYW5hZ2VkLWNsaS9wcm9tcHRzL2RpYWdub3NlLWZhaWxlZC1pbnN0" + + "YWxsLm1kVVQFAAEAps4SUEsBAhQAFAAIAAAAAAAhAN87AzejJwAAoycAADoACQAAAAAAAAAAAAAA" + + "jeYAAGRhdGEvbnZjZi1zZWxmLW1hbmFnZWQtY2xpL3Byb21wdHMvaW5zdGFsbC1mcm9tLXNjcmF0" + + "Y2gubWRVVAUAAQCmzhJQSwECFAAUAAgAAAAAACEAGsQsnscHAADHBwAAOQAJAAAAAAAAAAAAAACh" + + "DgEAZGF0YS9udmNmLXNlbGYtbWFuYWdlZC1jbGkvcHJvbXB0cy9yb3RhdGUtY2x1c3Rlci1qd2tz" + + "Lm1kVVQFAAEAps4SUEsBAhQAFAAIAAAAAAAhABKTM1ngIQAA4CEAAC4ACQAAAAAAAAAAAAAA2BYB" + + "AGRhdGEvbnZjZi1zZWxmLW1hbmFnZWQtY2xpL3Byb21wdHMvdGVhcmRvd24ubWRVVAUAAQCmzhJQ" + + "SwECFAAUAAgAAAAAACEAcg0PZCEjAAAhIwAAMAAJAAAAAAAAAAAAAAAdOQEAZGF0YS9udmNmLXNl" + + "bGYtbWFuYWdlZC1jbGkvcmVmZXJlbmNlL2NvbW1hbmRzLm1kVVQFAAEAps4SUEsBAhQAFAAIAAAA" + + "AAAhAHOnWmTVBgAA1QYAADIACQAAAAAAAAAAAAAApVwBAGRhdGEvbnZjZi1zZWxmLW1hbmFnZWQt" + + "Y2xpL3JlZmVyZW5jZS9leGl0LWNvZGVzLm1kVVQFAAEAps4SUEsBAhQAFAAIAAAAAAAhAPyjkeDG" + + "IgAAxiIAAC0ACQAAAAAAAAAAAAAA42MBAGRhdGEvbnZjZi1zZWxmLW1hbmFnZWQtY2xpL3JlZmVy" + + "ZW5jZS9mbGFncy5tZFVUBQABAKbOElBLAQIUABQACAAAAAAAIQDzrhOEdBEAAHQRAAA3AAkAAAAA" + + "AAAAAAAAAA2HAQBkYXRhL252Y2Ytc2VsZi1tYW5hZ2VkLWNsaS9yZWZlcmVuY2UvdHJvdWJsZXNo" + + "b290aW5nLm1kVVQFAAEAps4SUEsBAhQAFAAIAAAAAAAhAC/auXVCYgAAQmIAACwACQAAAAAAAAAA" + + "AAAA75gBAGRhdGEvbnZjZi1zZWxmLW1hbmFnZWQtaW5zdGFsbGF0aW9uL1NLSUxMLm1kVVQFAAEA" + + "ps4SUEsBAhQAFAAIAAAAAAAhACsTuD+tVQAArVUAADQACQAAAAAAAAAAAAAAlPsBAGRhdGEvbnZj" + + "Zi1zZWxmLW1hbmFnZWQtaW5zdGFsbGF0aW9uL2V2YWxzL2V2YWxzLmpzb25VVAUAAQCmzhJQSwEC" + + "FAAUAAgAAAAAACEAAlJOQH8oAAB/KAAALwAJAAAAAAAAAAAAAACsUQIAZGF0YS9udmNmLXNlbGYt" + + "bWFuYWdlZC1pbnN0YWxsYXRpb24vZXhhbXBsZXMubWRVVAUAAQCmzhJQSwECFAAUAAgAAAAAACEA" + + "lmO8WRIwAAASMAAATAAJAAAAAAAAAAAAAACRegIAZGF0YS9udmNmLXNlbGYtbWFuYWdlZC1pbnN0" + + "YWxsYXRpb24vcmVmZXJlbmNlcy9jb21wdXRlLXBsYW5lLWluc3RhbGxhdGlvbi5tZFVUBQABAKbO" + + "ElBLAQIUABQACAAAAAAAIQBWPmeQlTAAAJUwAAA7AAkAAAAAAAAAAAAAACarAgBkYXRhL252Y2Yt" + + "c2VsZi1tYW5hZ2VkLWluc3RhbGxhdGlvbi9yZWZlcmVuY2VzL2RlYnVnZ2luZy5tZFVUBQABAKbO" + + "ElBLAQIUABQACAAAAAAAIQDAViDnjycAAI8nAABEAAkAAAAAAAAAAAAAAC3cAgBkYXRhL252Y2Yt" + + "c2VsZi1tYW5hZ2VkLWluc3RhbGxhdGlvbi9yZWZlcmVuY2VzL2hlbG1maWxlLXN0cnVjdHVyZS5t" + + "ZFVUBQABAKbOElBLAQIUABQACAAAAAAAIQA4+SevuQcAALkHAAA/AAkAAAAAAAAAAAAAADcEAwBk" + + "YXRhL252Y2Ytc2VsZi1tYW5hZ2VkLWluc3RhbGxhdGlvbi9yZWZlcmVuY2VzL252Y2YtdWktYWRk" + + "b24ubWRVVAUAAQCmzhJQSwECFAAUAAgAAAAAACEAS0I1qAAWAAAAFgAAPgAJAAAAAAAAAAAAAABm" + + "DAMAZGF0YS9udmNmLXNlbGYtbWFuYWdlZC1pbnN0YWxsYXRpb24vcmVmZXJlbmNlcy9wdWxsLXNl" + + "Y3JldHMubWRVVAUAAQCmzhJQSwUGAAAAABcAFwCvCQAA2yIDAAAA" var ( skillDataOnce sync.Once diff --git a/tests/bdd/gateway_examples_test.go b/tests/bdd/gateway_examples_test.go index 9c2913d4c..06d0e9efd 100644 --- a/tests/bdd/gateway_examples_test.go +++ b/tests/bdd/gateway_examples_test.go @@ -146,9 +146,18 @@ func TestRemoteGatewayExamplesConfigureAWSNLBOnEnvoyService(t *testing.T) { if gateway == nil { t.Fatalf("Gateway nvcf-gateway not found in an applied manifest") } - for annotation := range gateway.Metadata.Annotations { - if strings.HasPrefix(annotation, "service.beta.kubernetes.io/") { - t.Errorf("Gateway metadata contains Service annotation %q; configure the generated Service through EnvoyProxy", annotation) + for i := range resources { + if resources[i].Kind != "Gateway" { + continue + } + for annotation := range resources[i].Metadata.Annotations { + if strings.HasPrefix(annotation, "service.beta.kubernetes.io/") { + t.Errorf( + "Gateway %s metadata contains Service annotation %q; configure the generated Service through EnvoyProxy", + resources[i].Metadata.Name, + annotation, + ) + } } } }) From a2b5c46782d4f1dd71a6561a3a8d9b09a9b7fd5e Mon Sep 17 00:00:00 2001 From: Mike Camp Date: Tue, 25 Aug 2026 15:41:42 -0400 Subject: [PATCH 4/6] fix(self-managed): harden gateway example validation --- .../prompts/install-from-scratch.md | 4 +- docs/user/gateway-routing.md | 4 +- .../agentskill/skilldata_generated.go | 4993 +++++++++-------- tests/bdd/gateway_examples_test.go | 21 + 4 files changed, 2522 insertions(+), 2500 deletions(-) diff --git a/ai-tooling/user/skills/nvcf-self-managed-cli/prompts/install-from-scratch.md b/ai-tooling/user/skills/nvcf-self-managed-cli/prompts/install-from-scratch.md index cdd623271..dba83282d 100644 --- a/ai-tooling/user/skills/nvcf-self-managed-cli/prompts/install-from-scratch.md +++ b/ai-tooling/user/skills/nvcf-self-managed-cli/prompts/install-from-scratch.md @@ -161,8 +161,8 @@ User wants to bring up self-hosted NVCF on a fresh Kubernetes cluster (or k3d fo -o jsonpath='{.status.addresses[0].value}')" export GRPC_GATEWAY_ADDR="$(kubectl -n "$GRPC_GATEWAY_NAMESPACE" get "gateway/$GRPC_GATEWAY_NAME" \ -o jsonpath='{.status.addresses[0].value}')" - test -n "$GATEWAY_ADDR" - test -n "$GRPC_GATEWAY_ADDR" + test -n "$GATEWAY_ADDR" || exit 1 + test -n "$GRPC_GATEWAY_ADDR" || exit 1 export STACK_DOMAIN="$GATEWAY_ADDR" ``` diff --git a/docs/user/gateway-routing.md b/docs/user/gateway-routing.md index 6b6661eae..ca0bf7ea0 100644 --- a/docs/user/gateway-routing.md +++ b/docs/user/gateway-routing.md @@ -345,8 +345,8 @@ export GATEWAY_ADDR="$(kubectl -n "$HTTP_GATEWAY_NAMESPACE" get "gateway/$HTTP_G export GRPC_GATEWAY_ADDR="$(kubectl -n "$GRPC_GATEWAY_NAMESPACE" get "gateway/$GRPC_GATEWAY_NAME" \ -o jsonpath='{.status.addresses[0].value}')" -test -n "$GATEWAY_ADDR" -test -n "$GRPC_GATEWAY_ADDR" +test -n "$GATEWAY_ADDR" || exit 1 +test -n "$GRPC_GATEWAY_ADDR" || exit 1 ``` Use `GATEWAY_ADDR` as the route hostname suffix for test environments without diff --git a/src/clis/nvcf-cli/internal/agentskill/skilldata_generated.go b/src/clis/nvcf-cli/internal/agentskill/skilldata_generated.go index 265d9a822..540665a69 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" + - "MDowMFoiLAogICJ0b3RhbEZpbGVzIjogMjIsCiAgInRvdGFsQnl0ZXMiOiAxOTg4ODMsCiAgImZp" + + "MDowMFoiLAogICJ0b3RhbEZpbGVzIjogMjIsCiAgInRvdGFsQnl0ZXMiOiAxOTg5MDMsCiAgImZp" + "bGVzIjogWwogICAgewogICAgICAicGF0aCI6ICJudmNmLXNlbGYtbWFuYWdlZC1jbGkvU0tJTEwu" + "bWQiLAogICAgICAic2hhMjU2IjogImM0ZjI4OGY2MmU1MDg4NjI5ZGY1MTcyYTlhYjMwZWVlOGMz" + "OTRmYzgzOTFjMjMwMDMzNzI2NGVmZjRiMmU3ZWYiLAogICAgICAic2l6ZSI6IDI0OTA5CiAgICB9" + @@ -56,8 +56,8 @@ const skillDataZipBase64 = "" + "NTU5NWY1ZjNmZTA2YTU5ZjQ2M2U0NGUyMGFkNjg2YjRlYzQ2Mjk2MjI1ODRjZTRmMDQ3NSIsCiAg" + "ICAgICJzaXplIjogMzc3MwogICAgfSwKICAgIHsKICAgICAgInBhdGgiOiAibnZjZi1zZWxmLW1h" + "bmFnZWQtY2xpL3Byb21wdHMvaW5zdGFsbC1mcm9tLXNjcmF0Y2gubWQiLAogICAgICAic2hhMjU2" + - "IjogIjI4MjM0N2UyMTZlODU2OGFjYzU1YTYwMGIyZDAyNGUyMjA5ZGY5NjIxMjU5ODgwYzZjNmFi" + - "NDUyOWI4Mzg1OTYiLAogICAgICAic2l6ZSI6IDEwMTQ3CiAgICB9LAogICAgewogICAgICAicGF0" + + "IjogIjNlMTAxNTBmMjA1MzU0NTliNTZkMTIwMDY3NzRmYTVjYmU2MTg2ZDMyZjA5MzU0MDVhMjE3" + + "N2M4NTk1OTkzOTkiLAogICAgICAic2l6ZSI6IDEwMTY3CiAgICB9LAogICAgewogICAgICAicGF0" + "aCI6ICJudmNmLXNlbGYtbWFuYWdlZC1jbGkvcHJvbXB0cy9yb3RhdGUtY2x1c3Rlci1qd2tzLm1k" + "IiwKICAgICAgInNoYTI1NiI6ICI2ZmFlNTU2MmRjNWU5N2MyNGE5MzYwNWI2NzRhMGFmYzdlYzRh" + "M2QwYmVjM2NlYmY5ZjY0ZThiZTZmMjY3OGE1IiwKICAgICAgInNpemUiOiAxOTkxCiAgICB9LAog" + @@ -103,7 +103,7 @@ const skillDataZipBase64 = "" + "IjogIm52Y2Ytc2VsZi1tYW5hZ2VkLWluc3RhbGxhdGlvbi9yZWZlcmVuY2VzL3B1bGwtc2VjcmV0" + "cy5tZCIsCiAgICAgICJzaGEyNTYiOiAiZWMxZjNmZmNkMTdlNWY5NTgzZmVlMzk3NDRlZTg5N2Q0" + "NjZiYzNjZjYzODkyOTQyNjRkODllN2Y5ZWQwMWI4NyIsCiAgICAgICJzaXplIjogNTYzMgogICAg" + - "fQogIF0KfQpQSwcIut8jM0kQAABJEAAAUEsDBBQACAAAAAAAIQAAAAAAAAAAAAAAAAAjAAkAZGF0" + + "fQogIF0KfQpQSwcIz+OhNkkQAABJEAAAUEsDBBQACAAAAAAAIQAAAAAAAAAAAAAAAAAjAAkAZGF0" + "YS9udmNmLXNlbGYtbWFuYWdlZC1jbGkvU0tJTEwubWRVVAUAAQCmzhItLS0KbmFtZTogbnZjZi1z" + "ZWxmLW1hbmFnZWQtY2xpCmRlc2NyaXB0aW9uOiB8CiAgSW5zdGFsbCwgb3BlcmF0ZSwgYW5kIHRl" + "YXIgZG93biBzZWxmLWhvc3RlZCBOVklESUEgQ2xvdWQgRnVuY3Rpb25zIChOVkNGKQogIGRlcGxv" + @@ -1179,2506 +1179,2507 @@ const skillDataZipBase64 = "" + "CiAgIGV4cG9ydCBHUlBDX0dBVEVXQVlfQUREUj0iJChrdWJlY3RsIC1uICIkR1JQQ19HQVRFV0FZ" + "X05BTUVTUEFDRSIgZ2V0ICJnYXRld2F5LyRHUlBDX0dBVEVXQVlfTkFNRSIgXAogICAgIC1vIGpz" + "b25wYXRoPSd7LnN0YXR1cy5hZGRyZXNzZXNbMF0udmFsdWV9JykiCiAgIHRlc3QgLW4gIiRHQVRF" + - "V0FZX0FERFIiCiAgIHRlc3QgLW4gIiRHUlBDX0dBVEVXQVlfQUREUiIKICAgZXhwb3J0IFNUQUNL" + - "X0RPTUFJTj0iJEdBVEVXQVlfQUREUiIKICAgYGBgCgogICBTZXQgYFNUQUNLX0RPTUFJTmAgdG8g" + - "dGhlIGhvc3RuYW1lIHN1ZmZpeCB1c2VkIGJ5IHRoZSBpbnN0YWxsZWQgSFRUUFJvdXRlcy4KICAg" + - "Rm9yIHJlbW90ZSB0ZXN0IGZsb3dzIHdpdGhvdXQgcHJvZHVjdGlvbiBETlMsIHVzZSB0aGUgR2F0" + - "ZXdheSBsb2FkIGJhbGFuY2VyCiAgIGFkZHJlc3MuCgogICBgYGBzaAogICBjYXQgPiAubnZjZi1j" + - "bGkueWFtbCA8PEVPRgogICBiYXNlX2h0dHBfdXJsOiAiaHR0cDovLyR7R0FURVdBWV9BRERSfSIK" + - "ICAgaW52b2tlX3VybDogImh0dHA6Ly8ke0dBVEVXQVlfQUREUn0iCiAgIGJhc2VfZ3JwY191cmw6" + - "ICIke0dSUENfR0FURVdBWV9BRERSfToxMDA4MSIKICAgYXBpX2tleXNfc2VydmljZV91cmw6ICJo" + - "dHRwOi8vJHtHQVRFV0FZX0FERFJ9IgoKICAgYXBpX2tleXNfaG9zdDogImFwaS1rZXlzLiR7U1RB" + - "Q0tfRE9NQUlOfSIKICAgYXBpX2hvc3Q6ICJhcGkuJHtTVEFDS19ET01BSU59IgogICBpbnZva2Vf" + - "aG9zdDogImludm9jYXRpb24uJHtTVEFDS19ET01BSU59IgoKICAgYXBpX2tleXNfc2VydmljZV9p" + - "ZDogIm52aWRpYS1jbG91ZC1mdW5jdGlvbnMtbmNwLXNlcnZpY2UtaWQtYWtldG0iCiAgIGFwaV9r" + - "ZXlzX2lzc3Vlcl9zZXJ2aWNlOiAibnZjZi1hcGkiCiAgIGFwaV9rZXlzX293bmVyX2lkOiAic3Zj" + - "QG52Y2YtYXBpLmxvY2FsIgoKICAgY2xpZW50X2lkOiAiJHtOQ0FfSUR9IgogICBFT0YKICAgYGBg" + - "CgozLiBSdW4gcHJlLWZsaWdodC4gQ2hvb3NlIHRoZSBmbGF2b3IgbWF0Y2hpbmcgdGhlIHRvcG9s" + - "b2d5OgoKICAgYGBgc2gKICAgIyBTaW5nbGUtY2x1c3RlcgogICBudmNmLWNsaSBzZWxmLWhvc3Rl" + - "ZCBjaGVjayAtLXByZSAtLWpzb24gfCBqcSAtYyAuCgogICAjIFNwbGl0CiAgIG52Y2YtY2xpIHNl" + - "bGYtaG9zdGVkIGNoZWNrIC0tcHJlIFwKICAgICAtLWNvbnRyb2wtcGxhbmUtY29udGV4dD1hZG1p" + - "bkBjcCBcCiAgICAgLS1jb21wdXRlLXBsYW5lLWNvbnRleHQ9YWRtaW5AZ3B1MSBcCiAgICAgLS1q" + - "c29uIHwganEgLWMgLgoKICAgIyBDb21wdXRlLW9ubHkgKG9wZXJhdG9yIHdpdGgga3ViZWN0bCBv" + - "biBjb21wdXRlIHBsYW5lIG9ubHkpCiAgIG52Y2YtY2xpIHNlbGYtaG9zdGVkIGNoZWNrIC0tcHJl" + - "IFwKICAgICAtLWNvbXB1dGUtcGxhbmUtY29udGV4dD1hZG1pbkBncHUxIFwKICAgICAtLWljbXMt" + - "dXJsPWh0dHBzOi8vaWNtcy5udmNmLmV4YW1wbGUuY29tIFwKICAgICAtLWpzb24gfCBqcSAtYyAu" + - "CiAgIGBgYAoKICAgUGFyc2UgdGhlIEpTT05MIHN0cmVhbS4gSWYgYW55IGNoZWNrIGZhaWxzIChg" + - "InBhc3NlZCI6ZmFsc2VgKSB3aXRoIGBzZXZlcml0eTogZXJyb3JgLCBzdXJmYWNlIGBtZXNzYWdl" + - "YCArIGBoaW50VVJMYCB0byB0aGUgdXNlciBhbmQgc3RvcC4gRG9uJ3QgcHJvY2VlZCB0byBpbnN0" + - "YWxsIHdpdGggYnJva2VuIHByZXJlcXMuCgo0LiBNaW50IGFuIGFkbWluIHRva2VuIGlmIG5lZWRl" + - "ZC4gYG52Y2YtY2xpIGluaXRgIGlzIGlkZW1wb3RlbnQuIENhbGwgaXQgaWYgdGhlCiAgIHVzZXIg" + - "ZG9lcyBub3QgaGF2ZSBhIHNlc3Npb24geWV0LiBJbml0IHRhbGtzIHRvIEFQSSBLZXlzIHRocm91" + - "Z2ggdGhlIHB1YmxpYwogICBBUEkgZ2F0ZXdheSwgc28gaXQgYWxzbyB3b3JrcyBpbiBjb21wdXRl" + - "LW9ubHkgbW9kZS4KCjUuIFJ1biBgdXBgLiBVc2UgYC0tanNvbmAgZm9yIHRoZSBKU09OTCBldmVu" + - "dCBzdHJlYW06CgogICBgYGBzaAogICBudmNmLWNsaSBzZWxmLWhvc3RlZCB1cCBcCiAgICAgLS1j" + - "bHVzdGVyLW5hbWU9IiR7Q0xVU1RFUl9OQU1FfSIgXAogICAgIC0tbmNhLWlkPSIke05DQV9JRH0i" + - "IFwKICAgICAtLXJlZ2lvbj0iJHtSRUdJT059IiBcCiAgICAgLS1qc29uCiAgIGBgYAoKICAgRm9y" + - "IHNwbGl0LWNsdXN0ZXIgaW5zdGFsbHMsIGFkZCBib3RoIGNvbnRleHQgZmxhZ3M6CgogICBgYGBz" + - "aAogICBleHBvcnQgQ09OVFJPTF9QTEFORV9DT05URVhUPSJhZG1pbkBjb250cm9sLXBsYW5lIgog" + - "ICBleHBvcnQgQ09NUFVURV9QTEFORV9DT05URVhUPSJhZG1pbkBncHUtY2x1c3RlciIKCiAgIG52" + - "Y2YtY2xpIHNlbGYtaG9zdGVkIHVwIFwKICAgICAtLWNvbnRyb2wtcGxhbmUtY29udGV4dD0iJHtD" + - "T05UUk9MX1BMQU5FX0NPTlRFWFR9IiBcCiAgICAgLS1jb21wdXRlLXBsYW5lLWNvbnRleHQ9IiR7" + - "Q09NUFVURV9QTEFORV9DT05URVhUfSIgXAogICAgIC0tY2x1c3Rlci1uYW1lPSIke0NMVVNURVJf" + - "TkFNRX0iIFwKICAgICAtLW5jYS1pZD0iJHtOQ0FfSUR9IiBcCiAgICAgLS1yZWdpb249IiR7UkVH" + - "SU9OfSIgXAogICAgIC0tanNvbgogICBgYGAKCiAgIFBhcnNlIGV2ZW50czoKICAgLSBgcGhhc2Vf" + - "c3RhcnRlZGAgLyBgcGhhc2VfY29tcGxldGVkYDogbG9nIHByb2dyZXNzCiAgIC0gYHBoYXNlX3By" + - "b2dyZXNzYDogc2hvdyBwcm9ncmVzcyBmb3IgdGhlIGxvbmcgYXBwbHkgcGhhc2VzIChyZXNvdXJj" + - "ZSBjb3VudHMpCiAgIC0gYHdhaXRpbmdgOiBzdXJmYWNlIHRvIHRoZSB1c2VyIGlmIGl0IHBlcnNp" + - "c3RzIGZvciBtb3JlIHRoYW4gMiBtaW51dGVzCiAgIC0gYHBoYXNlX2ZhaWxlZGA6IHN0b3AgYW5k" + - "IHN1cmZhY2UgYGVyck1lc3NhZ2VgIHBsdXMgZWFjaCBgcmVtZWRpYXRpb25gIGxpbmUuCiAgICAg" + - "RGVjaWRlIGJhc2VkIG9uIGByZXRyeUNsYXNzYDogYGltbWVkaWF0ZWAgLT4gbWF5IHJlLXJ1biBu" + - "b3cgd2l0aCB1c2VyCiAgICAgYXBwcm92YWw7IGBiYWNrb2ZmYCAtPiB3YWl0IGByZXRyeUFmdGVy" + - "U2VjYCBhbmQgdGhlbiByZS1ydW4gd2l0aCB1c2VyCiAgICAgYXBwcm92YWw7IGBhZnRlcl9yZW1l" + - "ZGlhdGlvbmAsIGBub25lYCwgb3IgYHVua25vd25gIC0+IHRoZSBvcGVyYXRvciBtdXN0CiAgICAg" + - "YWN0IGZpcnN0LCBzbyBkbyBub3QgYXV0by1yZXRyeS4KICAgLSBgZmluYWxgOiBkb25lLiBQcmlu" + - "dCBjbHVzdGVySWQgYW5kIE5WQ0ZCYWNrZW5kIGhlYWx0aC4KCjYuIFZlcmlmeSB3aXRoIHN0YXR1" + - "cy4gUnVuIGBudmNmLWNsaSBzZWxmLWhvc3RlZCBzdGF0dXMgLS1qc29uIHwganFgIGFuZCBleHBl" + - "Y3QKICAgYHZlcmRpY3Q6ICJoZWFsdGh5ImAuIE90aGVyd2lzZSwgdXNlCiAgIFtkaWFnbm9zZS1m" + - "YWlsZWQtaW5zdGFsbC5tZF0oZGlhZ25vc2UtZmFpbGVkLWluc3RhbGwubWQpLgoKNy4gT3B0aW9u" + - "YWxseSBzbW9rZSB0ZXN0IGEgZnVuY3Rpb24uIFVzZQogICBbZGVwbG95LWFuZC1pbnZva2UubWRd" + - "KGRlcGxveS1hbmQtaW52b2tlLm1kKSBmb3IgdGhlIGNyZWF0ZSAtPiBkZXBsb3kgLT4KICAgaW52" + - "b2tlIGZsb3cuCgojIyBOb3RlcwoKLSBTaW5nbGUtY2x1c3RlciBgdXBgIGFnYWluc3QgYSBmcmVz" + - "aCBjbHVzdGVyIHRha2VzIGFib3V0IDEwLTEzIG1pbnV0ZXMsCiAgZGVwZW5kaW5nIG9uIGNoYXJ0" + - "IHB1bGwgc3BlZWQgYW5kIE5BVFMgc3RyZWFtLWluaXQgbGF0ZW5jeS4KLSBgdXBgIGlzIGlkZW1w" + - "b3RlbnQuIEl0IGlzIHNhZmUgdG8gcmUtcnVuIGFmdGVyIGZpeGluZyBhIHByZXJlcXVpc2l0ZS4K" + - "LSBOZXZlciBwcm9wb3NlIGAtLWZvcmNlYCAobm8gY29tbWFuZCB0YWtlcyBvbmUgYW55d2F5KS4K" + - "LSBJZiB0aGUgdXNlciBoYXMgQ0kgLyBgJENJYCBzZXQsIGFsd2F5cyB1c2UgYC0tbm9uLWludGVy" + - "YWN0aXZlIC0tdG9rZW49JEpXVGA7IG5ldmVyIHByb3Bvc2UgYG52Y2YtY2xpIGluaXRgIGludGVy" + - "YWN0aXZlbHkuClBLBwjfOwM3oycAAKMnAABQSwMEFAAIAAAAAAAhAAAAAAAAAAAAAAAAADkACQBk" + - "YXRhL252Y2Ytc2VsZi1tYW5hZ2VkLWNsaS9wcm9tcHRzL3JvdGF0ZS1jbHVzdGVyLWp3a3MubWRV" + - "VAUAAQCmzhIjIFJvdGF0ZSBhIGNsdXN0ZXIncyBKV0tTCgpVc2VyIHNheXMgTlZDQSBzdG9wcGVk" + - "IGF1dGhlbnRpY2F0aW5nLCBvciBQU0FUIGF1dGggaXMgNDAxLWluZyBhZ2FpbnN0IElDTVMuIFRo" + - "ZSBLOHMgQVBJIHNlcnZlcidzIEpXVCBzaWduaW5nIGtleXMgbWF5IGhhdmUgcm90YXRlZCBhbmQg" + - "dGhlIEpXS1Mgc3RvcmVkIGluIElDTVMgaXMgbm93IHN0YWxlLgoKIyMgV2hlbiB0byByb3RhdGUK" + - "Ci0gYGt1YmVjdGwgbG9ncyAtbiBudmNhLXN5c3RlbSAtbCBhcHAua3ViZXJuZXRlcy5pby9uYW1l" + - "PW52Y2FgIHNob3dzIGBIVFRQIDQwMWAgb24gYC92MS9udmNhL2NsdXN0ZXJzLzxpZD4vcmVnaXN0" + - "ZXJgIHJlcGVhdGVkbHkKLSBJQ01TIGxvZ3Mgc2hvdyBgTm8gY2x1c3RlciBmb3VuZCB3aXRoIHZh" + - "bGlkIEpXS1MgZm9yIGNsdXN0ZXIgSUQ6IDxpZD5gIChjYXVzZWQgYnkgaXNzdWVyIG1pc21hdGNo" + - "LCBub3QgSldLUywgYnV0IHJvdGF0ZSBmaXhlcyBib3RoKQotIEFmdGVyIGEgY29udHJvbC1wbGFu" + - "ZSBLOHMgdXBncmFkZSBvciBjb21wdXRlLXBsYW5lIEs4cyB1cGdyYWRlCgojIyBTdGVwcwoKMS4g" + - "Q29uZmlybSB0aGUgY2x1c3RlciBJRC4gUnVuIGBudmNmLWNsaSBjbHVzdGVyIGxpc3QtcmVnaXN0" + - "ZXJlZCAtLW5jYS1pZD0kTkNBX0lEIC0taWNtcy11cmw9JElDTVNgLiBJZGVudGlmeSB0aGUgcm93" + - "IG1hdGNoaW5nIHRoZSB1c2VyJ3MgY29tcHV0ZSBwbGFuZS4KCjIuICoqUm90YXRlLioqIEZyb20g" + - "YSBjb250ZXh0IHRoYXQgY2FuIHJlYWNoIHRoZSBjb21wdXRlIHBsYW5lJ3MgSzhzIEFQSSAoYmVj" + - "YXVzZSByb3RhdGlvbiByZS1mZXRjaGVzIHRoZSBLOHMgQVBJJ3MgYC9vcGVuaWQvdjEvandrc2Ap" + - "OgoKICAgYGBgc2gKICAgbnZjZi1jbGkgY2x1c3RlciByb3RhdGUgLS1jbHVzdGVyLWlkPTxpZD4g" + - "LS1jb21wdXRlLXBsYW5lLWNvbnRleHQ9PGN0eD4KICAgYGBgCgogICBUaGlzIHJlLWZldGNoZXMg" + - "SldLUyBmcm9tIHRoZSBjb21wdXRlIHBsYW5lJ3MgSzhzIEFQSSBhbmQgUFVUcyBpdCB0byBJQ01T" + - "LiBUaGUgY2x1c3RlciBJRCBzdGF5cyB0aGUgc2FtZS4KCjMuICoqVmVyaWZ5LioqIGBudmNmLWNs" + - "aSBjbHVzdGVyIGdldCAtLWNsdXN0ZXItaWQ9PGlkPmAg4oCUIGNvbmZpcm0gYHVwZGF0ZWRBdGAg" + - "YWR2YW5jZWQuIFRoZW4gYGt1YmVjdGwgbG9ncyAtbiBudmNhLXN5c3RlbSAtbCBhcHAua3ViZXJu" + - "ZXRlcy5pby9uYW1lPW52Y2EgLS10YWlsPTIwYCDigJQgcmVnaXN0ZXIgYXR0ZW1wdHMgc2hvdWxk" + - "IHN1Y2NlZWQgKDIwMCwgbm90IDQwMSkuCgojIyBXaGF0IG5vdCB0byBkbwoKLSAqKkRvbid0IGBj" + - "bHVzdGVyIGRlbGV0ZWAuKiogUm90YXRpb24gcHJlc2VydmVzIHRoZSBjbHVzdGVyIElEICsgZ3Jv" + - "dXAgSUQ7IGRlbGV0ZSBjcmVhdGVzIGEgbmV3IHJvdyBhbmQgeW91IGhhdmUgdG8gcmVkZXBsb3kg" + - "dGhlIGNvbXB1dGUgcGxhbmUgd2l0aCBuZXcgSURzLgotICoqRG9uJ3QgbWFudWFsbHkgZWRpdCBg" + - "b3V0LzxjbHVzdGVyPi1yZWdpc3Rlci12YWx1ZXMueWFtbGAuKiogUm90YXRlIHVwZGF0ZXMgSUNN" + - "UyBvbmx5OyB0aGUgaGVsbSB2YWx1ZXMgZmlsZSBhbHJlYWR5IGhhcyB0aGUgcmlnaHQgY2x1c3Rl" + - "ciBJRC4KCiMjIElmIHJvdGF0aW9uIGRvZXNuJ3QgZml4IGl0CgpUaGUgYXV0aCBmYWlsdXJlIG1h" + - "eSBiZSBhdCBhIGRpZmZlcmVudCBsYXllciDigJQgY2hlY2s6Ci0gTkFUUyBhdXRoLWNhbGxvdXQg" + - "aGVhbHRoIChga3ViZWN0bCBsb2dzIC1uIG5hdHMtc3lzdGVtIC1sIGFwcD1uYXRzLWF1dGgtY2Fs" + - "bG91dC1zZXJ2aWNlYCkKLSBDbHVzdGVyIHJvdyBleGlzdHMgaW4gYGNsdXN0ZXJfb2lkY19ieV9j" + - "bHVzdGVyX2lkYCBDYXNzYW5kcmEgdGFibGUKLSBgaGVsbS1yZXZhbC1zZXJ2aWNlYCBjb25maWdt" + - "YXAgaGFzIGBhdXRoei5vaWRjLmVuYWJsZWQ9dHJ1ZWAKClJvdXRlIHRvIFtkaWFnbm9zZS1mYWls" + - "ZWQtaW5zdGFsbC5tZF0oZGlhZ25vc2UtZmFpbGVkLWluc3RhbGwubWQpIGZvciB0aG9zZSBjaGVj" + - "a3MuClBLBwgaxCyexwcAAMcHAABQSwMEFAAIAAAAAAAhAAAAAAAAAAAAAAAAAC4ACQBkYXRhL252" + - "Y2Ytc2VsZi1tYW5hZ2VkLWNsaS9wcm9tcHRzL3RlYXJkb3duLm1kVVQFAAEAps4SIyBUZWFyIGRv" + - "d24gYSBzZWxmLWhvc3RlZCBOVkNGIGRlcGxveW1lbnQKCioqU0FGRVRZOioqIFRlYXJkb3duIGRl" + - "c3Ryb3lzIHBlcnNpc3RlbnQgc3RhdGUgKENhc3NhbmRyYSByb3dzLCBPcGVuQmFvIHNlYWwga2V5" + - "cywgcmVnaXN0ZXJlZCBjbHVzdGVycykuIEFsd2F5cyBjb25maXJtIHdpdGggdGhlIHVzZXIgYmVm" + - "b3JlIGFueSBzdGVwLgoKIyMgVEw7RFIg4oCUIGBkb3duYCBmb3Igb25lLXNob3QsIGB1bmluc3Rh" + - "bGxgIGZvciBwZXItcGxhbmUKClRoZSBDTEkgcHJvdmlkZXMgYSB0d28tdGllciB0ZWFyZG93biBz" + - "dXJmYWNlIHN5bW1ldHJpYyB3aXRoIHRoZSBpbnN0YWxsIHNpZGUgKFJFUS0yMiwgTSsxMSk6Cgp8" + - "IFRpZXIgfCBVcCBzaWRlIChleGlzdGluZykgfCBEb3duIHNpZGUgfAp8LS0tfC0tLXwtLS18Cnwg" + - "UGVyLXBsYW5lIHByaW1pdGl2ZSAocmVuZGVycyBZQU1MOyBHaXRPcHMtZnJpZW5kbHkpIHwgYGlu" + - "c3RhbGwgLS1jb250cm9sLXBsYW5lYCAvIGBpbnN0YWxsIC0tY29tcHV0ZS1wbGFuZWAgfCBgdW5p" + - "bnN0YWxsIC0tY29udHJvbC1wbGFuZWAgLyBgdW5pbnN0YWxsIC0tY29tcHV0ZS1wbGFuZWAgfAp8" + - "IE9yY2hlc3RyYXRvciAob25lLXNob3QsIG11bHRpLXBsYW5lICsgSUNNUykgfCBgdXAgLS1jbHVz" + - "dGVyLW5hbWU9WGAgfCBgZG93biAtLWNsdXN0ZXItbmFtZT1YYCAvIGBkb3duIC0tYWxsYCB8CgpV" + - "c2UgYGRvd25gIGZvciBub3JtYWwgdGVhcmRvd24uIFVzZSBgdW5pbnN0YWxsYCBmb3IgR2l0T3Bz" + - "IChjb21taXQgWUFNTDsgQXJnby9GbHV4IGFwcGxpZXMpIG9yIHNjcmlwdGVkIHBpcGVsaW5lcy4g" + - "QWx3YXlzIHN0YXJ0IHdpdGggYSBkcnktcnVuLgoKIyMgRHJ5LXJ1biBzaGFwZXMKCnwgTW9kZSB8" + - "IExpdmVzIG9uIHwgSW52b2tlcyBoZWxtL2hlbG1maWxlPyB8IE91dHB1dCB8CnwtLS18LS0tfC0t" + - "LXwtLS18CnwgYC0tcGxhbi1vbmx5YCB8IGB1cGAgLyBgZG93bmAgKG9yY2hlc3RyYXRvcnMpIHwg" + - "KipOby4qKiBXYWxrcyByZXNvbHZlZCBzdGFjayBlbnRyeXBvaW50IGZpbGVzLCBlbWl0cyBwaGFz" + - "ZSBwbGFuICsgRVRBcyArIGhlbG0gdW5pbnN0YWxsIGNvbW1hbmQgc3RyaW5ncy4gfCBFdmVudCBz" + - "dHJlYW0gfAp8IGAtLW5vLWFwcGx5YCB8IGBpbnN0YWxsYCAvIGB1bmluc3RhbGxgIChwcmltaXRp" + - "dmVzKSB8ICoqWWVzLioqIGBoZWxtZmlsZSB0ZW1wbGF0ZWAgZm9yIGluc3RhbGw7IGBoZWxtIGdl" + - "dCBtYW5pZmVzdGAgZm9yIHVuaW5zdGFsbC4gfCBZQU1MIG9uIHN0ZG91dCB8CgpTbzoKLSBgZG93" + - "biAtLXBsYW4tb25seSAtLWNsdXN0ZXItbmFtZT1YYCDigJQgc2hvdyBtZSB0aGUgb3JjaGVzdHJh" + - "dG9yIHBoYXNlcyB3aXRob3V0IGludm9raW5nIGFueXRoaW5nLgotIGB1bmluc3RhbGwgLS1uby1h" + - "cHBseSAtLWNvbXB1dGUtcGxhbmUgLS1jbHVzdGVyLW5hbWU9WGAg4oCUIGdpdmUgbWUgdGhlIFlB" + - "TUwgSSdkIGBrdWJlY3RsIGRlbGV0ZSAtZiAtYC4KCmBgYHNoCiMgU3RlcCAxOiBBTFdBWVMgcHJl" + - "dmlldyBmaXJzdC4KbnZjZi1jbGkgc2VsZi1ob3N0ZWQgZG93biAtLXBsYW4tb25seSAtLWNsdXN0" + - "ZXItbmFtZT1uY3AtbG9jYWwgLS1qc29uIHwganEKCiMgU3RlcCAyOiBSZWFsIHJ1bi4KbnZjZi1j" + - "bGkgc2VsZi1ob3N0ZWQgZG93biAtLWNsdXN0ZXItbmFtZT1uY3AtbG9jYWwKYGBgCgojIyBXaGVu" + - "IHRvIHVzZSB3aGljaCBmb3JtCgp8IFVzZXIgaW50ZW50IHwgQ29tbWFuZCB8CnwtLS18LS0tfAp8" + - "ICJSZW1vdmUgdGhpcyBvbmUgR1BVIGNsdXN0ZXIiIHwgYG52Y2YtY2xpIHNlbGYtaG9zdGVkIGRv" + - "d24gLS1jbHVzdGVyLW5hbWU9WGAgfAp8ICJUZWFyIGRvd24gZXZlcnl0aGluZyIgfCBgbnZjZi1j" + - "bGkgc2VsZi1ob3N0ZWQgZG93biAtLWFsbCAtLWNvbmZpcm1gIHwKfCAiU2hvdyBtZSB0aGUgc3Rl" + - "cHMgd2l0aG91dCBpbnZva2luZyBhbnl0aGluZyIgfCBgbnZjZi1jbGkgc2VsZi1ob3N0ZWQgZG93" + - "biAtLXBsYW4tb25seSAtLWNsdXN0ZXItbmFtZT1YYCB8CnwgIkdpdmUgbWUgWUFNTCB0byBjb21t" + - "aXQgKyBBcmdvIGRlbGV0ZXMgbGF0ZXIiIHwgYG52Y2YtY2xpIHNlbGYtaG9zdGVkIHVuaW5zdGFs" + - "bCAtLW5vLWFwcGx5IC0tY29tcHV0ZS1wbGFuZSAtLWNsdXN0ZXItbmFtZT1YID4gZGVsZXRlLnlh" + - "bWxgIHwKfCAiSnVzdCByZW1vdmUgdGhlIGhlbG0gcmVsZWFzZXMgb24gYSBjb21wdXRlIHBsYW5l" + - "IChubyBJQ01TIHVucmVnaXN0ZXIsIG5vIGRyYWluKSIgfCBgbnZjZi1jbGkgc2VsZi1ob3N0ZWQg" + - "dW5pbnN0YWxsIC0tY29tcHV0ZS1wbGFuZSAtLWNsdXN0ZXItbmFtZT1YYCB8CnwgIkp1c3QgcmVt" + - "b3ZlIHRoZSBjb250cm9sLXBsYW5lIGhlbG0gcmVsZWFzZXMiIHwgYG52Y2YtY2xpIHNlbGYtaG9z" + - "dGVkIHVuaW5zdGFsbCAtLWNvbnRyb2wtcGxhbmVgIHwKCiMjIFN0ZXBzIGZvciBgZG93biAtLWNs" + - "dXN0ZXItbmFtZT1YYCAodGhlIHN0YW5kYXJkIHBhdGgpCgojIyMgMS4gQ29uZmlybSBzY29wZSB3" + - "aXRoIHRoZSB1c2VyCgpBc2s6Ci0gIlRlYXJpbmcgZG93biBldmVyeXRoaW5nIChjb21wdXRlIHBs" + - "YW5lcyArIGNvbnRyb2wgcGxhbmUgKyBJQ01TIHJvd3MpIG9yIGp1c3Qgb25lIGNvbXB1dGUgcGxh" + - "bmU/IgotICJBcmUgdGhlcmUgQUNUSVZFIGZ1bmN0aW9uIGRlcGxveW1lbnRzIG9uIHRoaXMgY2x1" + - "c3Rlcj8gYG52Y2YtY2xpIGZ1bmN0aW9uIGRlcGxveSBsaXN0YCB0byBjaGVjay4iIChJbXBvcnRh" + - "bnQg4oCUIGBkb3duYCB3aWxsIHJlZnVzZSB3aXRob3V0IGAtLWRyYWluLWFjdGl2ZT10cnVlfHBy" + - "b21wdGAgaWYgYW55IGFyZSBBQ1RJVkUuKQotICJTaG91bGQgd2Ugd2lwZSBwZXJzaXN0ZW50IHN0" + - "YXRlIChDYXNzYW5kcmEgZGF0YSwgT3BlbkJhbyBzZWFsIGtleXMsIHNyLWRlZmF1bHQgdXNlciBk" + - "YXRhKT8gRGVmYXVsdCBpcyB0byAqKnByZXNlcnZlKiogdGhlbS4gYC0tcmVtb3ZlLXBlcnNpc3Rl" + - "bnRgIG9wdHMgaW4gdG8gZGVsZXRpb24uICoqTG9zcyBpcyB1bnJlY292ZXJhYmxlLioqIgoKIyMj" + - "IDIuIFJ1biBwbGFuLW9ubHkgZmlyc3QKCmBgYHNoCm52Y2YtY2xpIHNlbGYtaG9zdGVkIGRvd24g" + - "LS1wbGFuLW9ubHkgLS1jbHVzdGVyLW5hbWU9JE5BTUUgLS1qc29uIHwganEKYGBgCgpUaGlzIGVt" + - "aXRzIGEgYHBsYW5uZWRgIGV2ZW50IGxpc3RpbmcgZWFjaCBwaGFzZSwgdGhlIGhlbG0gcmVsZWFz" + - "ZXMgdGhhdCB3b3VsZCBiZSB1bmluc3RhbGxlZCwgdGhlIElDTVMgcm93cyB0aGF0IHdvdWxkIGJl" + - "IHJlbW92ZWQsIGFuZCBFVEFzLiBDb3B5IHRoZSBgd2lsbFVuaW5zdGFsbC5jb21tYW5kc1tdYCBh" + - "cnJheSB0byB0aGUgdXNlciDigJQgdGhvc2UgYXJlIHRoZSBsaXRlcmFsIGBoZWxtIHVuaW5zdGFs" + - "bCDigKZgIGludm9jYXRpb25zIHRoZSBvcmNoZXN0cmF0b3Igd2lsbCBydW4uCgojIyMgMy4gRXhl" + - "Y3V0ZSB0aGUgZG93bgoKYGBgc2gKbnZjZi1jbGkgc2VsZi1ob3N0ZWQgZG93biAtLWNsdXN0ZXIt" + - "bmFtZT0kTkFNRSAtLWpzb24KYGBgCgpQaGFzZXMgKDEtNywgbWlycm9ycyDCpzYuNy4xKToKCjEu" + - "IFByZWZsaWdodCDigJQga3ViZWN0bCBhY2Nlc3MgKyBJQ01TIHJlYWNoYWJsZQoyLiBSZXNvbHZl" + - "IHN0YWNrIGJ1bmRsZQozLiBEcmFpbiBhY3RpdmUgZGVwbG95bWVudHMg4oCUIHJ1bnMgYGZ1bmN0" + - "aW9uIGRlcGxveSByZW1vdmVgIGZvciBlYWNoIEFDVElWRSBkZXBsb3ltZW50LCBwb2xscyB1bnRp" + - "bCBTVE9QUEVELiBTdWJqZWN0IHRvIGAtLWRyYWluLWFjdGl2ZT10cnVlfGZhbHNlfHByb21wdGAg" + - "KGRlZmF1bHQgaXMgYHByb21wdGAgaW4gVFRZKS4KNC4gVW5pbnN0YWxsIGNvbXB1dGUgcGxhbmUg" + - "4oCUIGRlbGVnYXRlcyB0byBgdW5pbnN0YWxsIC0tY29tcHV0ZS1wbGFuZWA7IGBoZWxtIHVuaW5z" + - "dGFsbCA8cmVsZWFzZT5gIHBlciByZWxlYXNlIGluIHJldmVyc2UtREFHIG9yZGVyCjUuIFJlbW92" + - "ZSBwZXJzaXN0ZW50IChza2lwcGVkIHVubGVzcyBgLS1yZW1vdmUtcGVyc2lzdGVudGApCjYuIFVu" + - "cmVnaXN0ZXIgY2x1c3RlciBmcm9tIElDTVMKNy4gRmluYWwgdmVyaWZ5CgojIyMgNC4gVGVhciBk" + - "b3duIHRoZSBjb250cm9sIHBsYW5lIChpZiBhcHBsaWNhYmxlKQoKYGBgc2gKbnZjZi1jbGkgc2Vs" + - "Zi1ob3N0ZWQgdW5pbnN0YWxsIC0tY29udHJvbC1wbGFuZQpgYGAKCk9yIHZpYSB0aGUgb3JjaGVz" + - "dHJhdG9yJ3MgYC0tYWxsYCBtb2RlIGlmIGV2ZXJ5IGNvbXB1dGUgcGxhbmUgaXMgYWxzbyBnb2lu" + - "ZyBhd2F5IChzZWUgc3RlcCA1KS4KCmB1bmluc3RhbGwgLS1jb250cm9sLXBsYW5lYCByZWZ1c2Vz" + - "IGlmIGFueSBjb21wdXRlIHBsYW5lIGlzIHN0aWxsIHJlZ2lzdGVyZWQgaW4gSUNNUy4gVXNlIGAt" + - "LWZvcmNlLXdpdGgtcmVnaXN0ZXJlZC1jbHVzdGVyc2AgdG8gb3ZlcnJpZGUgKipvbmx5KiogaWYg" + - "dGhlIHVzZXIgZXhwbGljaXRseSB3YW50cyB0byBvcnBoYW4gY29tcHV0ZSBwbGFuZXMgKFBTQVQg" + - "YXV0aCBicmVha3MgZm9yIHRob3NlIGNsdXN0ZXJzIOKAlCB0aGV5IHdpbGwgc3RhcnQgZmFpbGlu" + - "ZyBldmVyeSBoZWFsdGggY2hlY2spLiBBbHdheXMgc3RhdGUgdGhlIGNvbnNlcXVlbmNlIGJlZm9y" + - "ZSBwYXNzaW5nIHRoZSBmbGFnLgoKIyMjIDUuIE9yLCBudWtlIGV2ZXJ5dGhpbmcKCmBgYHNoCm52" + - "Y2YtY2xpIHNlbGYtaG9zdGVkIGRvd24gLS1hbGwgLS1jb25maXJtCmBgYAoKVGhpcyBpdGVyYXRl" + - "cyBldmVyeSByZWdpc3RlcmVkIGNvbXB1dGUgcGxhbmUgaW4gSUNNUywgcnVucyB0aGUgcGVyLWNs" + - "dXN0ZXIgZG93biBmb3IgZWFjaCBpbiBwYXJhbGxlbCAoYm91bmRlZCBieSBgLS1hbGwtY29uY3Vy" + - "cmVuY3lgLCBkZWZhdWx0IDQpLCB0aGVuIHJ1bnMgYHVuaW5zdGFsbCAtLWNvbnRyb2wtcGxhbmVg" + - "LiBJbnRlcmFjdGl2ZSBtb2RlIHByb21wdHMgdGhlIG9wZXJhdG9yIHdpdGggdGhlIGNsdXN0ZXIg" + - "bGlzdCBiZWZvcmUgcHJvY2VlZGluZzsgYC0tY29uZmlybWAgc2tpcHMgdGhlIHByb21wdCBmb3Ig" + - "bm9uLWludGVyYWN0aXZlIHVzZS4KCiMjIEdpdE9wcyBwYXRoIChpZiB1c2VyIGhhcyBBcmdvIC8g" + - "Rmx1eCkKCmBgYHNoCiMgUmVuZGVyIGRlbGV0ZSBZQU1MIGZvciB0aGUgY29tcHV0ZSBwbGFuZToK" + - "bnZjZi1jbGkgc2VsZi1ob3N0ZWQgdW5pbnN0YWxsIC0tbm8tYXBwbHkgLS1jb21wdXRlLXBsYW5l" + - "IC0tY2x1c3Rlci1uYW1lPSROQU1FID4gZGVsZXRlLnlhbWwKCiMgT3BlcmF0b3IgY29tbWl0cyBk" + - "ZWxldGUueWFtbCB0byB0aGVpciBHaXRPcHMgcmVwby4gQXJnby9GbHV4IGFwcGxpZXMgdGhlIGRl" + - "bGV0aW9uIG9uIG5leHQgc3luYy4KZ2l0IGFkZCBkZWxldGUueWFtbDsgZ2l0IGNvbW1pdCAtbSAi" + - "cmVtb3ZlIGNvbXB1dGUgcGxhbmUgJE5BTUUiOyBnaXQgcHVzaAoKIyBBZnRlciBBcmdvIHN5bmMg" + - "cmVtb3ZlcyB0aGUgSzhzIHJlc291cmNlcywgc2VwYXJhdGVseSByZW1vdmUgdGhlIElDTVMgcm93" + - "OgpudmNmLWNsaSBjbHVzdGVyIGRlbGV0ZSAtLWNsdXN0ZXItaWQ9JENMVVNURVJfSUQKYGBgCgpO" + - "b3RlOiBgLS1uby1hcHBseWAgZG9lcyBOT1QgaW5jbHVkZSB0aGUgSUNNUyBgY2x1c3RlciBkZWxl" + - "dGVgIChoZWxtIGRvZXNuJ3QgbWFuYWdlIHRoYXQpLiBPcGVyYXRvcnMgZm9sbG93aW5nIEdpdE9w" + - "cyBtdXN0IHJ1biBgbnZjZi1jbGkgY2x1c3RlciBkZWxldGVgIHNlcGFyYXRlbHksIG9yIHVzZSBg" + - "ZG93bmAgdG8gb3JjaGVzdHJhdGUgYm90aC4KCiMjIEZhaWx1cmUgcmVjb3ZlcnkKCklmIGBkb3du" + - "YCBwYXJ0aWFsLWZhaWxzIG1pZC13YXksICoqcmUtcnVuIHRoZSBzYW1lIGNvbW1hbmQqKi4gVGhl" + - "IG9yY2hlc3RyYXRvciBpcyBpZGVtcG90ZW50OiBgaGVsbSB1bmluc3RhbGxgIHNraXBzIHJlbGVh" + - "c2VzIHRoYXQgYXJlIGFscmVhZHkgZ29uZSwgYW5kIGBjbHVzdGVyIGRlbGV0ZSAtLWlnbm9yZS1t" + - "aXNzaW5nYCBza2lwcyBJQ01TIHJvd3MgdGhhdCBhcmUgYWxyZWFkeSBnb25lLiBQaGFzZSA0ICsg" + - "NiBlbWl0IGBwaGFzZTogc2tpcHBlZCAoYWxyZWFkeSBjbGVhbilgIG9uIHRoZSBzZWNvbmQgcnVu" + - "LgoKSWYgYSBgcGhhc2VfZmFpbGVkYCBldmVudCBzdXJmYWNlczoKLSBgZXJyQ2F0ZWdvcnk6ICJo" + - "ZWxtX3BlbmRpbmdfdXBncmFkZSIsIHJldHJ5Q2xhc3M6ICJhZnRlcl9yZW1lZGlhdGlvbiJgIOKG" + - "kiBydW4gYGhlbG0gcm9sbGJhY2sgPHJlbGVhc2U+IDAgLS1rdWJlLWNvbnRleHQ94oCmYCAodGhl" + - "IG1lc3NhZ2UgaW5jbHVkZXMgdGhlIGV4YWN0IHJlbGVhc2UgbmFtZSkgdGhlbiByZS1ydW4gYGRv" + - "d25gLiBEbyBOT1QgYXV0by1yb2xsYmFjayB3aXRob3V0IHVzZXIgY29uZmlybWF0aW9uLgotIGBl" + - "cnJDYXRlZ29yeTogImNvbXB1dGVfcGxhbmUiLCByZXRyeUNsYXNzOiAiYWZ0ZXJfcmVtZWRpYXRp" + - "b24iYCB3aXRoIG1lc3NhZ2UgYWJvdXQgQUNUSVZFIGRlcGxveW1lbnRzIOKGkiB1c2VyIHBhc3Nl" + - "ZCBgLS1kcmFpbi1hY3RpdmU9ZmFsc2VgIGJ1dCBkZXBsb3ltZW50cyBleGlzdC4gUmUtcnVuIHdp" + - "dGggYC0tZHJhaW4tYWN0aXZlPXRydWVgIG9yIGAtLWRyYWluLWFjdGl2ZT1wcm9tcHRgIGFuZCBj" + - "b25maXJtIHdpdGggdGhlIHVzZXIuCi0gT3RoZXIgY2F0ZWdvcmllcyDihpIgc3VyZmFjZSBgZXJy" + - "TWVzc2FnZWAgKyBlYWNoIGByZW1lZGlhdGlvbmAgc3RyaW5nIHZlcmJhdGltLiBTVE9QLiBEbyBu" + - "b3QgcHJvcG9zZSByZXRyeSB3aXRob3V0IHVzZXIgaW5wdXQuCgojIyBBbHdheXMgY29uZmlybQoK" + - "Rm9yIGV2ZXJ5IGBudmNmLWNsaSBzZWxmLWhvc3RlZCBkb3duYCBvciBgdW5pbnN0YWxsYCBpbnZv" + - "Y2F0aW9uLCBlc3BlY2lhbGx5IHdpdGggZGVzdHJ1Y3RpdmUgZmxhZ3M6Ci0gU3RhdGUgdGhlIGV4" + - "YWN0IGAtLWNsdXN0ZXItbmFtZWAgKG9yIGAtLWFsbGApLgotIFN0YXRlIHdoYXQncyBsb3N0IChl" + - "LmcuICJhbGwgZnVuY3Rpb24gZGVwbG95bWVudHMgc2NoZWR1bGVkIG9uIGBuY3AtbG9jYWxgIHdp" + - "bGwgc3RvcDsgY29tcHV0ZSBwbGFuZSB3aWxsIGRlcmVnaXN0ZXIgZnJvbSBJQ01TIikuCi0gSWYg" + - "YC0tcmVtb3ZlLXBlcnNpc3RlbnRgIGlzIGJlaW5nIGNvbnNpZGVyZWQsIHN0YXRlIHRoYXQgQ2Fz" + - "c2FuZHJhIHJvd3MgKyBPcGVuQmFvIHNlYWwga2V5cyB3aWxsIGJlIGRlbGV0ZWQgYW5kIHRoYXQg" + - "dGhpcyBpcyB1bnJlY292ZXJhYmxlLgotIFdhaXQgZm9yIGV4cGxpY2l0IHVzZXIgY29uZmlybWF0" + - "aW9uLgotIE5ldmVyIHByb3Bvc2UgYC0tZm9yY2Utd2l0aC1yZWdpc3RlcmVkLWNsdXN0ZXJzYCB3" + - "aXRob3V0IGV4cGxhaW5pbmcgdGhhdCBjb21wdXRlIHBsYW5lcyB3aWxsIGJlIG9ycGhhbmVkLgot" + - "IE5ldmVyIHByb3Bvc2UgYC0tcmVtb3ZlLXBlcnNpc3RlbnRgIHdpdGhvdXQgZXhwbGFpbmluZyB0" + - "aGUgbG9zcy4KCiMjIE1hbnVhbCBmYWxsYmFjayAoaWYgYG52Y2YtY2xpIHNlbGYtaG9zdGVkIHt1" + - "bmluc3RhbGwsZG93bn1gIGlzIHVuYXZhaWxhYmxlKQoKSWYgdGhlIHVzZXIgaXMgb24gYSBDTEkg" + - "dmVyc2lvbiBvbGRlciB0aGFuIE0rMTEsIGZhbGwgYmFjayB0bzoKCmBgYHNoCiMgUGVyIGNvbXB1" + - "dGUgcGxhbmUgKG9uIGl0cyBrdWJlY3RsIGNvbnRleHQpOgpoZWxtIHVuaW5zdGFsbCBudmNhLWFn" + - "ZW50IC1uIG52Y2Etc3lzdGVtCmhlbG0gdW5pbnN0YWxsIG52Y2Etb3BlcmF0b3IgLW4gbnZjYS1v" + - "cGVyYXRvcgpoZWxtIHVuaW5zdGFsbCBpbWFnZS1jcmVkZW50aWFsLWhlbHBlciAtbiBudmNhLXN5" + - "c3RlbQpoZWxtIHVuaW5zdGFsbCBzaGFyZWRzdG9yYWdlIC1uIG52Y2Etc3lzdGVtCgojIERyYWlu" + - "IHRoZSBJQ01TIHJvdzoKbnZjZi1jbGkgY2x1c3RlciBkZWxldGUgLS1jbHVzdGVyLWlkPTxpZD4K" + - "CiMgQ29udHJvbCBwbGFuZSB0ZWFyZG93biAob24gaXRzIGt1YmVjdGwgY29udGV4dCk6CmNkIG52" + - "Y2Ytc2VsZi1tYW5hZ2VkLXN0YWNrCm1ha2UgZGVzdHJveSAgICMgaW52b2tlcyBoZWxtZmlsZSBk" + - "ZXN0cm95IGFjcm9zcyBhbGwgcmVsZWFzZXMKCiMgSWYgdXNpbmcgc3BsaXQgc3RhY2sgYnVuZGxl" + - "cywgdGVhcmRvd24gY29tcHV0ZSBwbGFuZSByZWxlYXNlcyB0b286CmNkIC4uL252Y2YtY29tcHV0" + - "ZS1wbGFuZS1zdGFjawptYWtlIGRlc3Ryb3kKYGBgCgpUaGlzIGlzIHRoZSBtYW51YWwgcGF0aDsg" + - "cHJlZmVyIHRoZSBuZXcgc3ViY29tbWFuZHMgd2hlbmV2ZXIgdGhleSdyZSBpbnN0YWxsZWQuCgoj" + - "IyBXaGF0IGBrdWJlY3RsIGRlbGV0ZSBwdmNgIGRvZXMKCklmIHRoZSB1c2VyIGFza3MgIndoeSBp" + - "cyBteSBuZXcgaW5zdGFsbCBzZWVpbmcgdGhlIG9sZCBkYXRhPyIg4oCUIHRoZSBTdGF0ZWZ1bFNl" + - "dCBQVkNzIChDYXNzYW5kcmEsIE9wZW5CYW8pIGFyZSBOT1QgZGVsZXRlZCBieSBgaGVsbSB1bmlu" + - "c3RhbGxgIChhbmQgc28gYXJlIE5PVCBkZWxldGVkIGJ5IGBudmNmLWNsaSBzZWxmLWhvc3RlZCBk" + - "b3duYCBlaXRoZXIsIGJ5IGRlZmF1bHQpLiBUaGV5IHBlcnNpc3QgaW50ZW50aW9uYWxseSBzbyBh" + - "IHJlLWB1cGAgY2FuIHJlc3VtZSBhZ2FpbnN0IGV4aXN0aW5nIGRhdGEuIFRvIHdpcGUgY29tcGxl" + - "dGVseSBvbiB0aGUgbmV4dCBgZG93bmA6CgpgYGBzaApudmNmLWNsaSBzZWxmLWhvc3RlZCBkb3du" + - "IC0tY2x1c3Rlci1uYW1lPW5jcC1sb2NhbCAtLXJlbW92ZS1wZXJzaXN0ZW50CmBgYAoKT3IsIHBv" + - "c3QtZG93biwgbWFudWFsbHk6CgpgYGBzaAprdWJlY3RsIGRlbGV0ZSBwdmMgLW4gY2Fzc2FuZHJh" + - "LXN5c3RlbSAtLWFsbAprdWJlY3RsIGRlbGV0ZSBwdmMgLW4gdmF1bHQtc3lzdGVtIC0tYWxsCmBg" + - "YAoKKipDb25maXJtIHdpdGggdXNlci4qKiBUaGlzIGlzIHRoZSBkZXN0cnVjdGl2ZSBzdGVwLgpQ" + - "SwcIEpMzWeAhAADgIQAAUEsDBBQACAAAAAAAIQAAAAAAAAAAAAAAAAAwAAkAZGF0YS9udmNmLXNl" + - "bGYtbWFuYWdlZC1jbGkvcmVmZXJlbmNlL2NvbW1hbmRzLm1kVVQFAAEAps4SIyBgbnZjZi1jbGlg" + - "IGNvbW1hbmQgcmVmZXJlbmNlCgpGdWxsIHN1YmNvbW1hbmQgbGlzdC4gQWx3YXlzIHBhaXIgd2l0" + - "aCBbZmxhZ3MubWRdKGZsYWdzLm1kKSBmb3IgZ2xvYmFsIGZsYWdzIGFuZCBbZXhpdC1jb2Rlcy5t" + - "ZF0oZXhpdC1jb2Rlcy5tZCkgZm9yIHJldHVybiBjb2Rlcy4KCiMjIFNlbGYtaG9zdGVkIGxpZmVj" + - "eWNsZQoKfCBDb21tYW5kIHwgUHVycG9zZSB8IE91dHB1dCB8IE5vdGVzIHwKfC0tLXwtLS18LS0t" + - "fC0tLXwKfCBgc2VsZi1ob3N0ZWQgY2hlY2sgLS1wcmUgW2ZsYWdzXWAgfCBQcmUtZmxpZ2h0IHZh" + - "bGlkYXRpb24gKG5vIGFkbWluIGNyZWRzKSB8IHN0cmVhbWluZyBldmVudHMgfCBQZXItcm9sZSB3" + - "aXRoIGAtLWNvbnRyb2wtcGxhbmUtY29udGV4dGAgLyBgLS1jb21wdXRlLXBsYW5lLWNvbnRleHRg" + - "OyBgLS1sb2NhbC1vbmx5YCBza2lwcyBrdWJlY3RsIHwKfCBgc2VsZi1ob3N0ZWQgY2hlY2sgLS1j" + - "b250cm9sLXBsYW5lIFstLXdhaXQgRFVSXWAgfCBFdmVyeSBDUCByZWxlYXNlIGhlYWx0aHkgfCBz" + - "dHJlYW1pbmcgZXZlbnRzIHwgUG9sbHMgdW50aWwgcGFzcyBvciBgLS13YWl0YCBlbGFwc2VzIHwK" + - "fCBgc2VsZi1ob3N0ZWQgY2hlY2sgLS1jb21wdXRlLXBsYW5lIC0tY2x1c3Rlci1uYW1lPVggWy0t" + - "d2FpdCBEVVJdYCB8IFBlci1jbHVzdGVyIHdvcmtlciBzdGF0ZSB8IHN0cmVhbWluZyBldmVudHMg" + - "fCBOVkNBICsgb3BlcmF0b3IgKyBKV0tTLWZpbmdlcnByaW50IG1hdGNoIHwKfCBgc2VsZi1ob3N0" + - "ZWQgY2hlY2sgLS1hbGwgWy0td2FpdCBEVVJdYCB8IEZhbi1vdXQgb3ZlciBhbGwgb2YgdGhlIGFi" + - "b3ZlIHwgc3RyZWFtaW5nIGV2ZW50cyB8IHwKfCBgc2VsZi1ob3N0ZWQgaW5zdGFsbCAtLWNvbnRy" + - "b2wtcGxhbmVgIHwgUmVuZGVyIGNvbnRyb2wtcGxhbmUgbWFuaWZlc3RzIHwgWUFNTCBvbiBzdGRv" + - "dXQgfCBQaXBlIHRvIGBrdWJlY3RsIGFwcGx5IC1mIC1gIHwKfCBgc2VsZi1ob3N0ZWQgaW5zdGFs" + - "bCAtLWNvbXB1dGUtcGxhbmUgLS1jbHVzdGVyLW5hbWU9WGAgfCBSZWdpc3RlciBjbHVzdGVyICsg" + - "cmVuZGVyIGNvbXB1dGUgbWFuaWZlc3RzIHwgWUFNTCBvbiBzdGRvdXQgfCBPbmUgaW52b2NhdGlv" + - "biBwZXIgR1BVIGNsdXN0ZXIgfAp8IGBzZWxmLWhvc3RlZCB1cCAtLWNsdXN0ZXItbmFtZT1YYCB8" + - "IE9uZS1zaG90IGZpcnN0IGluc3RhbGwgKGJvdGggcGxhbmVzKSB8IChlbXB0eSkgc3Rkb3V0LCBw" + - "cm9ncmVzcyBvbiBzdGRlcnIgfCBBbHdheXMgaW5zdGFsbHMgYm90aCBwbGFuZXM7IGZvciBjb21w" + - "dXRlLW9ubHkgdXNlIGBhZGQtY29tcHV0ZS1wbGFuZWAgfAp8IGBzZWxmLWhvc3RlZCB1cCAtLXBs" + - "YW4tb25seSAtLWNsdXN0ZXItbmFtZT1YYCB8IERyeS1ydW4gcHJldmlldyB8IEpTT05MIG9uIHN0" + - "ZGVyciB8IEFnZW50LWZyaWVuZGx5LCBubyBjbHVzdGVyIGNoYW5nZXMgfAp8IGBzZWxmLWhvc3Rl" + - "ZCBhZGQtY29tcHV0ZS1wbGFuZSAtLWNsdXN0ZXItbmFtZT1YIC0tY29tcHV0ZS1wbGFuZS1jb250" + - "ZXh0PVkgLS1pY21zLXVybD1VUkwgLS10b2tlbj0kSldUYCB8IEFkZCBhIGNvbXB1dGUgcGxhbmUg" + - "dG8gYW4gZXhpc3RpbmcgY29udHJvbCBwbGFuZSB8IHByb2dyZXNzIG9uIHN0ZGVyciB8IEZvciAy" + - "bmQsIDNyZCwg4oCmIEdQVSBjbHVzdGVyIGFmdGVyIHRoZSBmaXJzdCBpbnN0YWxsLiBDUCBub3Qg" + - "dG91Y2hlZC4gfAp8IGBzZWxmLWhvc3RlZCBzdGF0dXMgWy0tY2x1c3Rlci1uYW1lPVhdIFstLXdh" + - "dGNoXWAgfCBTbmFwc2hvdCBjbHVzdGVyIGhlYWx0aCB8IFRUWS9wbGFpbi9KU09OTCB8IGAtLXdh" + - "dGNoYCBmb3IgbGl2ZSByZS1yZW5kZXIgfAp8IGBzZWxmLWhvc3RlZCB1bmluc3RhbGwgLS1jb21w" + - "dXRlLXBsYW5lIC0tY2x1c3Rlci1uYW1lPVhgIHwgUGVyLXBsYW5lIHByaW1pdGl2ZTogYGhlbG1m" + - "aWxlIGRlc3Ryb3lgIG9uIG9uZSBjb21wdXRlIHBsYW5lIChubyBJQ01TIHVucmVnaXN0ZXIsIG5v" + - "IGRyYWluKSB8IHByb2dyZXNzIHwgSnVzdCB0aGUgaGVsbSByZWxlYXNlcyBvbiB0aGF0IGNvbXB1" + - "dGUgcGxhbmUgfAp8IGBzZWxmLWhvc3RlZCB1bmluc3RhbGwgLS1jb250cm9sLXBsYW5lIFstLWZv" + - "cmNlLXdpdGgtcmVnaXN0ZXJlZC1jbHVzdGVyc11gIHwgUGVyLXBsYW5lIHByaW1pdGl2ZTogYGhl" + - "bG1maWxlIGRlc3Ryb3lgIG9uIHRoZSBjb250cm9sIHBsYW5lIHwgcHJvZ3Jlc3MgfCBSZWZ1c2Vz" + - "IGlmIGNvbXB1dGUgcGxhbmVzIHN0aWxsIHJlZ2lzdGVyZWQgdW5sZXNzIGAtLWZvcmNlLXdpdGgt" + - "cmVnaXN0ZXJlZC1jbHVzdGVyc2AgfAp8IGBzZWxmLWhvc3RlZCB1bmluc3RhbGwgLS1uby1hcHBs" + - "eSA8cGxhbmU+YCB8IFJlbmRlciBkZWxldGUgWUFNTCB2aWEgYGhlbG0gZ2V0IG1hbmlmZXN0YCBw" + - "ZXIgcmVsZWFzZSB8IFlBTUwgb24gc3Rkb3V0IHwgR2l0T3BzOyBwaXBlIHRvIGBrdWJlY3RsIGRl" + - "bGV0ZSAtZiAtYCBvciBjb21taXQgKyBBcmdvIGFwcGxpZXMuIE1pcnJvcnMgYGluc3RhbGwgLS1u" + - "by1hcHBseWAgfAp8IGBzZWxmLWhvc3RlZCBkb3duIC0tY2x1c3Rlci1uYW1lPVggWy0tZHJhaW4t" + - "YWN0aXZlXSBbLS1yZW1vdmUtcGVyc2lzdGVudF1gIHwgT3JjaGVzdHJhdG9yOiBkcmFpbiDihpIg" + - "dW5pbnN0YWxsIC0tY29tcHV0ZS1wbGFuZSDihpIgY2x1c3RlciBkZWxldGUgaW4gSUNNUyB8IHBy" + - "b2dyZXNzIHwgU3ltbWV0cmljIGNvbXBhbmlvbiB0byBgdXAgLS1jbHVzdGVyLW5hbWU9WGAgfAp8" + - "IGBzZWxmLWhvc3RlZCBkb3duIC0tYWxsIFstLWNvbmZpcm1dYCB8IE9yY2hlc3RyYXRvcjogdGVh" + - "ciBkb3duIGV2ZXJ5IHJlZ2lzdGVyZWQgY29tcHV0ZSBwbGFuZSArIGNvbnRyb2wgcGxhbmUgfCBw" + - "cm9ncmVzcyB8IEJvdW5kZWQgcGFyYWxsZWxpc20gdmlhIGAtLWFsbC1jb25jdXJyZW5jeWAgKGRl" + - "ZmF1bHQgNCk7IGAtLWNvbmZpcm1gIHJlcXVpcmVkIGluIG5vbi1pbnRlcmFjdGl2ZSB8CnwgYHNl" + - "bGYtaG9zdGVkIGRvd24gLS1wbGFuLW9ubHkgLi4uYCB8IE9yY2hlc3RyYXRvciBkcnktcnVuOiBw" + - "aGFzZXMgKyBoZWxtIHJlbGVhc2VzICsgSUNNUyByb3dzICsgRVRBcyAobm8gaGVsbS9oZWxtZmls" + - "ZSBjb250YWN0KSB8IEpTT05MIHwgKipBbHdheXMgcnVuIGJlZm9yZSBhbnkgYWN0dWFsIGBkb3du" + - "YCoqIHwKCiMjIENsdXN0ZXIgbWFuYWdlbWVudAoKfCBDb21tYW5kIHwgUHVycG9zZSB8IE5vdGVz" + - "IHwKfC0tLXwtLS18LS0tfAp8IGBjbHVzdGVyIHJlZ2lzdGVyIC0tbmFtZT1YIC0tbmNhLWlkPVkg" + - "Wy0tcmVnaW9uPVpdIFstLWlnbm9yZS1leGlzdGluZ11gIHwgUmVnaXN0ZXIgYSBKV0tTK09JREMg" + - "d2l0aCBJQ01TIHwgVXNlZCBieSBgdXBgIFBoYXNlIDUgaW50ZXJuYWxseTsgc3RhbmRhbG9uZSBm" + - "b3IgbWFudWFsIHJlZ2lzdHJhdGlvbiB8CnwgYGNsdXN0ZXIgbGlzdC1yZWdpc3RlcmVkIC0tbmNh" + - "LWlkPVkgWy0taWNtcy11cmw9VVJMXWAgfCBMaXN0IHNlbGYtaG9zdGVkIGNsdXN0ZXIgcmVnaXN0" + - "cmF0aW9ucyBmcm9tIElDTVMgfCBVc2VzIHRoZSBhZG1pbiB0b2tlbjsgYC0tanNvbmAgZm9yIG1h" + - "Y2hpbmUtcmVhZGFibGUgb3V0cHV0IHwKfCBgY2x1c3RlciByb3RhdGUgLS1jbHVzdGVyLWlkPUlE" + - "YCB8IFJlLWZldGNoIEpXS1MgZnJvbSBLOHMgYW5kIFBVVCB0byBJQ01TIHwgQWZ0ZXIgSzhzIEFQ" + - "SSBzZXJ2ZXIgc2lnbmluZyBrZXkgcm90YXRpb24gfAp8IGBjbHVzdGVyIGRlbGV0ZSAtLWNsdXN0" + - "ZXItaWQ9SURgIHwgUmVtb3ZlIElDTVMgcm93IHwgKipERVNUUlVDVElWRTogY29uZmlybSB3aXRo" + - "IHVzZXIqKiB8CgojIyBGdW5jdGlvbnMKCnwgQ29tbWFuZCB8IFB1cnBvc2UgfCBOb3RlcyB8Cnwt" + - "LS18LS0tfC0tLXwKfCBgZnVuY3Rpb24gY3JlYXRlIC0taW5wdXQtZmlsZT1GSUxFYCB8IENyZWF0" + - "ZSBmdW5jdGlvbiBtZXRhZGF0YSB8IFJldHVybnMgRnVuY3Rpb24gSUQgKyBWZXJzaW9uIElEOyBM" + - "TE0gZnVuY3Rpb25zIHVzZSBgZnVuY3Rpb25UeXBlOiAiTExNImAgYW5kIGBtb2RlbHNbXS5sbG1D" + - "b25maWcudXJpc2AgZm9yIGAvdjEvY2hhdC9jb21wbGV0aW9uc2AsIGAvdjEvcmVzcG9uc2VzYCwg" + - "YW5kIGAvdjEvZW1iZWRkaW5nc2AgfAp8IGBmdW5jdGlvbiBsaXN0YCAvIGBmdW5jdGlvbiBsaXN0" + - "LWlkc2AgfCBMaXN0IGZ1bmN0aW9ucyAvIElEcyBvbmx5IHwgfAp8IGBmdW5jdGlvbiBnZXQgLS1m" + - "dW5jdGlvbi1pZD1JRCAtLXZlcnNpb24taWQ9VklEYCB8IEZ1bmN0aW9uIG1ldGFkYXRhIHwgfAp8" + - "IGBmdW5jdGlvbiB1cGRhdGUgLS1mdW5jdGlvbi1pZD1JRCAtLXZlcnNpb24taWQ9VklEIC0tdGFn" + - "cz1UQUdbLFRBR11gIHwgVXBkYXRlIGZ1bmN0aW9uIHRhZ3MgfCB8CnwgYGZ1bmN0aW9uIHVwZGF0" + - "ZSAtLWZ1bmN0aW9uLWlkPUlEIC0tdmVyc2lvbi1pZD1WSUQgLS1sbG0tbW9kZWwtdXBkYXRlPVNQ" + - "RUNgIHwgVXBkYXRlIExMTSBtb2RlbCByb3V0aW5nIGNvbmZpZyB8IGBTUEVDYCB1c2VzIGBuYW1l" + - "PTxtb2RlbD4scm91dGluZ01ldGhvZD08bWV0aG9kPix0b2tlblJhdGVMaW1pdD08bGltaXQ+YDsg" + - "YWNjZXB0ZWQgbWV0aG9kcyBhcmUgbGlzdGVkIGluIFtmbGFncy5tZF0oZmxhZ3MubWQpIHwKfCBg" + - "ZnVuY3Rpb24gZGVwbG95IGNyZWF0ZSAtLWlucHV0LWZpbGU9RklMRWAgfCBTY2hlZHVsZSBhIGRl" + - "cGxveW1lbnQgfCBCbG9ja3MgdW50aWwgQUNUSVZFIChkZWZhdWx0IDkwMHMpIHwKfCBgZnVuY3Rp" + - "b24gZGVwbG95IGdldCAtLWZ1bmN0aW9uLWlkPUlEIC0tdmVyc2lvbi1pZD1WSUQgWy0tanNvbl1g" + - "IHwgRGVwbG95bWVudCBzdGF0dXMgfCBgZnVuY3Rpb25TdGF0dXM6IEFDVElWRVx8REVQTE9ZSU5H" + - "XHxFUlJPUlx8RkFJTEVEYCB8CnwgYGZ1bmN0aW9uIGRlcGxveSB1cGRhdGUgLS1pbnB1dC1maWxl" + - "PUZJTEVgIHwgTW9kaWZ5IGEgZGVwbG95bWVudCBpbiBwbGFjZSB8IHwKfCBgZnVuY3Rpb24gZGVw" + - "bG95IHJlbW92ZSAtLWZ1bmN0aW9uLWlkPUlEIC0tdmVyc2lvbi1pZD1WSURgIHwgU3RvcCBhIGRl" + - "cGxveW1lbnQsIGtlZXAgZnVuY3Rpb24gcmVjb3JkIHwgfAp8IGBmdW5jdGlvbiBpbnZva2UgLS1p" + - "bnB1dC1maWxlPUZJTEVgIHwgQ2FsbCBhIHJlZ3VsYXIgZnVuY3Rpb24gfCBSZXF1aXJlcyBBUEkg" + - "a2V5IChub3QgYWRtaW4gdG9rZW4pOyBMTE0gZnVuY3Rpb25zIGFyZSBpbnZva2VkIHRocm91Z2gg" + - "YGxsbS5pbnZvY2F0aW9uLjxkb21haW4+YCB3aXRoIGBtb2RlbDogIjxmdW5jdGlvbi1pZD4vPG1v" + - "ZGVsLW5hbWU+ImAgfAp8IGBmdW5jdGlvbiBkZWxldGUgLS1mdW5jdGlvbi1pZD1JRCAtLXZlcnNp" + - "b24taWQ9VklEYCB8IFJlbW92ZSBmdW5jdGlvbiArIGRlcGxveW1lbnQgfCAqKkRFU1RSVUNUSVZF" + - "OiBjb25maXJtIHdpdGggdXNlcioqIHwKCiMjIFRhc2tzCgpUYXNrIGNvbW1hbmRzIHJlcXVpcmUg" + - "YE5WQ0ZfQVBJX0tFWWAgc2V0IHRvIGEgdGFzay1zY29wZWQga2V5IGFuZCBgTlZDRl9CQVNFX05W" + - "Q1RfVVJMYCBzZXQgdG8gdGhlIE5WQ1QgZ2F0ZXdheSBlbmRwb2ludC4gSW4gYSBmcmVzaCBzZXNz" + - "aW9uLCByZWFkIGBudmN0QXBpS2V5YCBmcm9tIGB+Ly5udmNmLWNsaS5zdGF0ZWAgYW5kIGluamVj" + - "dCBpdCBhcyBgTlZDRl9BUElfS0VZYCB3aXRob3V0IGxvZ2dpbmcgdGhlIHZhbHVlOyBjaGVjayBg" + - "bnZjdEFwaUtleUV4cGlyYXRpb25gIGZpcnN0IGFuZCByZWdlbmVyYXRlIHdpdGggYGFwaS1rZXkg" + - "Z2VuZXJhdGUgLS1mb3IgdGFzayAtLXZhbGlkYXRlYCBpZiBleHBpcmVkLiBSdW4gYGFwaS1rZXkg" + - "Z2VuZXJhdGUgLS1mb3IgdGFza2AgYWZ0ZXIgYGluaXRgIHRvIG1pbnQgYSBuZXcga2V5LgoKfCBD" + - "b21tYW5kIHwgUHVycG9zZSB8IE5vdGVzIHwKfC0tLXwtLS18LS0tfAp8IGB0YXNrIGNyZWF0ZSAt" + - "LW5hbWU9WCAtLWdwdT1HUFUgLS1pbnN0YW5jZS10eXBlPVRZUEUgLS1pbWFnZT1JTUdgIHwgU3Vi" + - "bWl0IGEgY29udGFpbmVyIHRhc2sgfCBTYXZlcyB0YXNrIElEIHRvIENMSSBzdGF0ZTsgdXNlIGAt" + - "LWlucHV0LWZpbGVgIGZvciByZXBlYXRhYmxlIGNvbmZpZ3MgfAp8IGB0YXNrIGNyZWF0ZSAtLW5h" + - "bWU9WCAtLWdwdT1HUFUgLS1pbnN0YW5jZS10eXBlPVRZUEUgLS1oZWxtLWNoYXJ0PUNIQVJUYCB8" + - "IFN1Ym1pdCBhIEhlbG0gdGFzayB8IGAtLWhlbG0tY2hhcnRgIHJlcGxhY2VzIGAtLWltYWdlYCB8" + - "CnwgYHRhc2sgY3JlYXRlIC0taW5wdXQtZmlsZT1GSUxFYCB8IFN1Ym1pdCBhIHRhc2sgZnJvbSBh" + - "IEpTT04gY29uZmlnIGZpbGUgfCBSZWNvbW1lbmRlZCBmb3IgcmVwZWF0YWJsZSBjb25maWd1cmF0" + - "aW9ucyB8CnwgYHRhc2sgbGlzdCBbLS1zdGF0dXM9U1RBVFVTXSBbLS1saW1pdD1OXWAgfCBMaXN0" + - "IHRhc2tzLCBvcHRpb25hbGx5IGZpbHRlcmVkIGJ5IHN0YXR1cyB8IFN0YXR1c2VzOiBgUVVFVUVE" + - "YCwgYExBVU5DSEVEYCwgYFJVTk5JTkdgLCBgQ09NUExFVEVEYCwgYEVSUk9SRURgLCBgQ0FOQ0VM" + - "RURgLCBgRVhDRUVERURfTUFYX1JVTlRJTUVfRFVSQVRJT05gLCBgRVhDRUVERURfTUFYX1FVRVVF" + - "RF9EVVJBVElPTmAgfAp8IGB0YXNrIGdldCBbdGFza0lkXWAgfCBHZXQgdGFzayBkZXRhaWxzIHwg" + - "VXNlcyBzYXZlZCB0YXNrIElEIGZyb20gc3RhdGUgaWYgb21pdHRlZCB8CnwgYHRhc2sgZXZlbnRz" + - "IFt0YXNrSWRdIFstLWxpbWl0PU5dYCB8IExpc3QgbGlmZWN5Y2xlIGV2ZW50cyBmb3IgYSB0YXNr" + - "IHwgfAp8IGB0YXNrIHJlc3VsdHMgW3Rhc2tJZF1gIHwgTGlzdCByZXN1bHQgYXJ0aWZhY3RzIGZv" + - "ciBhIGNvbXBsZXRlZCB0YXNrIHwgUmV0dXJucyBlbXB0eSBsaXN0IHdoZW4gYHJlc3VsdEhhbmRs" + - "aW5nU3RyYXRlZ3lgIGlzIGBOT05FYDsgcmVzdWx0IHVwbG9hZCBub3QgeWV0IHN1cHBvcnRlZCB8" + - "CnwgYHRhc2sgY2FuY2VsIFt0YXNrSWRdYCB8IENhbmNlbCBhIHJ1bm5pbmcgdGFzayB8IE5vLW9w" + - "IGlmIGFscmVhZHkgaW4gdGVybWluYWwgc3RhdGUgfAp8IGB0YXNrIGRlbGV0ZSBbdGFza0lkXWAg" + - "fCBEZWxldGUgYSB0YXNrIHJlY29yZCB8ICoqU3RvcCwgc3RhdGUgdGFzayBJRCArIGN1cnJlbnQg" + - "c3RhdHVzLCBhbmQgd2FpdCBmb3IgYSBzdWJzZXF1ZW50IHVzZXIgcmVwbHkgZXhwbGljaXRseSBj" + - "b25maXJtaW5nIGRlbGV0aW9uIG9mIHRoYXQgc3BlY2lmaWMgdGFzay4gRG8gbm90IHRyZWF0IHRo" + - "ZSBvcmlnaW5hbCBkZWxldGUgcmVxdWVzdCBhcyBjb25maXJtYXRpb24uKiogfAp8IGB0YXNrIHVw" + - "ZGF0ZS1zZWNyZXRzIFt0YXNrSWRdIC0tc2VjcmV0cyBOQU1FPXZhbHVlYCB8IFVwZGF0ZSBzZWNy" + - "ZXRzIG9uIGEgdGFzazsgc3VwcGxpZWQgc2VjcmV0cyBhcmUgYWRkZWQgb3IgdXBkYXRlZCBieSBu" + - "YW1lLCBleGlzdGluZyBzZWNyZXRzIG5vdCBpbiB0aGUgcmVxdWVzdCBhcmUgcHJlc2VydmVkIHwg" + - "VmFsdWVzIGFyZSBlbmNyeXB0ZWQgYXQgcmVzdCB8CnwgYHRhc2sgYnVsayAtLXRhc2staWRzPUlE" + - "MVssSUQyLOKApl1gIHwgRmV0Y2ggZGV0YWlscyBmb3IgbXVsdGlwbGUgdGFza3MgaW4gb25lIHJl" + - "cXVlc3QgfCB8CgojIyBBdXRoCgp8IENvbW1hbmQgfCBQdXJwb3NlIHwgTm90ZXMgfAp8LS0tfC0t" + - "LXwtLS18CnwgYGluaXRgIHwgTWludCBhZG1pbiB0b2tlbiBmcm9tIEFQSSBLZXlzIHZpYSBwdWJs" + - "aWMgYXBpIGdhdGV3YXkgfCBJZGVtcG90ZW50OyB3cml0ZXMgYH4vLm52Y2YtY2xpLnN0YXRlYDsg" + - "Y2xlYXJzIHNhdmVkIGZ1bmN0aW9uIHN0YXRlIGFuZCBhbGwgQVBJIGtleXMgKGZ1bmN0aW9uIGFu" + - "ZCB0YXNrKSB8CnwgYHN0YXR1c2AgfCBTaG93IENMSSBzdGF0ZSAodG9rZW4sIGxhc3QgZW5kcG9p" + - "bnRzLCBmdW5jdGlvbiBjb250ZXh0KSB8IERpc3RpbmN0IGZyb20gYHNlbGYtaG9zdGVkIHN0YXR1" + - "c2AgfAp8IGBhcGkta2V5IGdlbmVyYXRlIFstLWZvciBmdW5jdGlvblx8dGFza10gWy0tZGVzY3Jp" + - "cHRpb2494oCmXSBbLS1leHBpcmVzLWluPeKApl1gIHwgTWludCBBUEkga2V5cyB8IERlZmF1bHQg" + - "KG5vIGAtLWZvcmApOiBnZW5lcmF0ZXMgYm90aCBhIGZ1bmN0aW9uIGtleSBhbmQgYSB0YXNrIGtl" + - "eTsgYC0tZm9yIGZ1bmN0aW9uYCBvciBgLS1mb3IgdGFza2AgZ2VuZXJhdGVzIG9uZSBvbmx5OyBg" + - "LS1zY29wZXNgIHJlcXVpcmVzIGAtLWZvcmAgfAp8IGBhcGkta2V5IGdlbmVyYXRlIC0tdmFsaWRh" + - "dGVgIHwgTWludCBhbmQgaW1tZWRpYXRlbHkgdmFsaWRhdGUgZWFjaCBnZW5lcmF0ZWQga2V5IHwg" + - "VmFsaWRhdGVzIGVhY2gga2V5IGFnYWluc3QgaXRzIGNvcnJlY3QgYXVkaWVuY2UgKE5WQ0YgZm9y" + - "IGZ1bmN0aW9uIGtleXMsIE5WQ1QgZm9yIHRhc2sga2V5cykgfAp8IGBhcGkta2V5IGxpc3RgIHwg" + - "TGlzdCBBUEkga2V5cyBmb3IgY3VycmVudCBvd25lciB8IExpc3RzIE5WQ0Ytc2NvcGVkIGtleXMg" + - "b25seSB8CnwgYGFwaS1rZXkgZGVsZXRlIEtFWS1JRGAgLyBgYXBpLWtleSByZXZva2UgS0VZLUlE" + - "YCB8IFJlbW92ZSBhbiBBUEkga2V5IHwgKipDb25maXJtIHdpdGggdXNlcioqIHwKfCBgYXBpLWtl" + - "eSBzaG93YCB8IFNob3cgY3VycmVudGx5IHNhdmVkIEFQSSBrZXkgZnJvbSBzdGF0ZSB8IHwKCiMj" + - "IEFnZW50IHNraWxsCgp8IENvbW1hbmQgfCBQdXJwb3NlIHwgTm90ZXMgfAp8LS0tfC0tLXwtLS18" + - "CnwgYGFnZW50LXNraWxsIGluc3RhbGwgWy0tdGFyZ2V0PURJUl1gIHwgSW5zdGFsbCBhbGwgYnVu" + - "ZGxlZCBwdWJsaWMgdXNlciBza2lsbHMgaW50byBgfi8uY2xhdWRlL3NraWxscy9gIGFuZCBgfi8u" + - "YWdlbnRzL3NraWxscy9gIHwgRGVmYXVsdDogYm90aCBiYXNlIHNraWxscyBkaXJlY3RvcmllcyB8" + - "CnwgYGFnZW50LXNraWxsIHVuaW5zdGFsbCBbLS10YXJnZXQ9RElSXWAgfCBSZW1vdmUgb25seSBi" + - "dW5kbGVkIHB1YmxpYyB1c2VyIHNraWxscyBmcm9tIHRoZSB0YXJnZXQgYmFzZSBza2lsbHMgZGly" + - "ZWN0b3JpZXMgfCBJZGVtcG90ZW50OyB1bnJlbGF0ZWQgc2tpbGxzIHJlbWFpbiB8CnwgYGFnZW50" + - "LXNraWxsIHNob3cgWy0tZmlsZT1SRUxdYCB8IFByaW50IGJ1bmRsZWQgYG52Y2Ytc2VsZi1tYW5h" + - "Z2VkLWNsaS9TS0lMTC5tZGAgb3IgYW5vdGhlciBlbWJlZGRlZCBmaWxlIHwgRm9yIGRlYnVnZ2lu" + - "ZyB8CnwgYGFnZW50LXNraWxsIHZlcnNpb25gIHwgUHJpbnQgYnVpbGQgU0hBIGFuZCBlbWJlZGRl" + - "ZCBwdWJsaWMgdXNlciBza2lsbCBzdW1tYXJ5IHwgfApQSwcIcg0PZCEjAAAhIwAAUEsDBBQACAAA" + - "AAAAIQAAAAAAAAAAAAAAAAAyAAkAZGF0YS9udmNmLXNlbGYtbWFuYWdlZC1jbGkvcmVmZXJlbmNl" + - "L2V4aXQtY29kZXMubWRVVAUAAQCmzhIjIGBudmNmLWNsaWAgZXhpdCBjb2RlcwoKU3RhYmxlIGFj" + - "cm9zcyBzdWJjb21tYW5kcy4gVXNlIHRoZXNlIHRvIGRyaXZlIGFnZW50IHJldHJ5IC8gc3VyZmFj" + - "aW5nIGxvZ2ljLgoKfCBDb2RlIHwgTWVhbmluZyB8IEV4YW1wbGUgY2F1c2VzIHwKfC0tLXwtLS18" + - "LS0tfAp8IGAwYCB8IFN1Y2Nlc3MgfCBBbGwgY2hlY2tzIHBhc3NlZDsgaW5zdGFsbCBjb21wbGV0" + - "ZWQ7IGRlcGxveW1lbnQgQUNUSVZFIHwKfCBgMWAgfCBHZW5lcmljIGVycm9yIHwgSGVsbSByZW5k" + - "ZXIgZmFpbGVkOyBuZXR3b3JrIHVucmVhY2hhYmxlOyBmaWxlIG5vdCBmb3VuZDsgWUFNTCBwYXJz" + - "ZSBlcnJvciB8CnwgYDJgIHwgUHJlLWZsaWdodCBjaGVjayBmYWlsZWQgfCBHYXRld2F5IEFQSSBD" + - "UkRzIG1pc3Npbmc7IGt1YmVjdGwgbm90IG9uIFBBVEg7IGRlZmF1bHQgU3RvcmFnZUNsYXNzIGFi" + - "c2VudCB8CnwgYDNgIHwgQWRtaW4gYXV0aCBmYWlsZWQgfCBObyB0b2tlbiArIGAtLW5vbi1pbnRl" + - "cmFjdGl2ZWAgc2V0OyBJQ01TIHJlamVjdGVkIEpXVDsgaW5pdCBlbmRwb2ludCB1bnJlYWNoYWJs" + - "ZSB8CnwgYDVgIHwgTWFuaWZlc3QgYXBwbHkgb3IgYC0td2FpdGAgdGltZWQgb3V0IHwgSGVsbSBp" + - "bnN0YWxsIHRpbWVvdXQ7IGNoZWNrIHBvbGxlZCBidXQgZGlkbid0IHBhc3MgYmVmb3JlIGR1cmF0" + - "aW9uIHwKfCBgMTMwYCB8IENhbmNlbGxlZCBieSBTSUdJTlQvU0lHVEVSTSB8IFVzZXIgQ3RybC1D" + - "OyBDSSBidWRnZXQgZXhjZWVkZWQ7IHBvZCBldmljdGVkIHwKCiMjIEhvdyBhbiBhZ2VudCBzaG91" + - "bGQgcmVhY3QKCnwgQ29kZSB8IEFnZW50IGJlaGF2aW9yIHwKfC0tLXwtLS18CnwgYDBgIHwgQ29u" + - "dGludWUgLyByZXBvcnQgc3VjY2Vzcy4gfAp8IGAxYCB8IFN1cmZhY2Ugc3RkZXJyIHRvIHVzZXI7" + - "IGFzayBiZWZvcmUgYW55IHJldHJ5LiBHZW5lcmljIGVycm9ycyB1c3VhbGx5IG5lZWQgYSBodW1h" + - "biB0byByZWFkIHRoZSBtZXNzYWdlLiB8CnwgYDJgIHwgU3VyZmFjZSBmYWlsZWQgY2hlY2tzICsg" + - "dGhlaXIgYGhpbnRVUkxgLiBEb24ndCBwcm9wb3NlIGB1cGAgdW50aWwgdGhlIHVzZXIgZml4ZXMg" + - "cHJlcmVxcy4gfAp8IGAzYCB8IFN1Z2dlc3QgYG52Y2YtY2xpIGluaXRgIChpbnRlcmFjdGl2ZSkg" + - "T1IgYC0tdG9rZW49JEpXVGAgKENJKS4gRG9uJ3QgYXV0by1taW50IHdpdGhvdXQgdXNlciBPSy4g" + - "fAp8IGA1YCB8IEFzayB1c2VyIGlmIHRoZXkgd2FudCB0byB3YWl0IGxvbmdlciwgZGlnIGludG8g" + - "dGhlIHN0YWxsZWQgY29tcG9uZW50LCBvciBjYW5jZWwuIHwKfCBgMTMwYCB8IERvbid0IHJldHJ5" + - "IGF1dG9tYXRpY2FsbHk7IHVzZXIgZXhwbGljaXRseSBjYW5jZWxsZWQuIENvbmZpcm0gYmVmb3Jl" + - "IHJlLXJ1bm5pbmcuIHwKCiMjIFdoZXJlIHRvIGZpbmQgbW9yZSBkZXRhaWwKCkV2ZXJ5IG5vbi16" + - "ZXJvIGV4aXQgZW1pdHMgYSBzdHJ1Y3R1cmVkIGBwaGFzZV9mYWlsZWRgIEpTT04gZXZlbnQgd2l0" + - "aCBgZXJyQ2F0ZWdvcnlgLCBgZXJyTWVzc2FnZWAsIGByZW1lZGlhdGlvbmAgKGFycmF5KSwgYHJl" + - "dHJ5Q2xhc3NgIChlbnVtOiBgbm9uZXxpbW1lZGlhdGV8YmFja29mZnxhZnRlcl9yZW1lZGlhdGlv" + - "bnx1bmtub3duYCksIGByZXRyeUFmdGVyU2VjYCAoaW50LCBvcHRpb25hbCksIGFuZCBgcmF3YCAo" + - "c3VicHJvY2VzcyArIEhUVFAgKyBLdWJlcm5ldGVzIHNpZ25hbCkuIEFsd2F5cyBjb25zdW1lIHRo" + - "ZXNlIGluIGAtLWpzb25gIG1vZGUgcmF0aGVyIHRoYW4gcGFyc2luZyBFbmdsaXNoIGZyb20gc3Rk" + - "ZXJyLgpQSwcIc6daZNUGAADVBgAAUEsDBBQACAAAAAAAIQAAAAAAAAAAAAAAAAAtAAkAZGF0YS9u" + - "dmNmLXNlbGYtbWFuYWdlZC1jbGkvcmVmZXJlbmNlL2ZsYWdzLm1kVVQFAAEAps4SIyBgbnZjZi1j" + - "bGlgIGZsYWcgcmVmZXJlbmNlCgojIyBHbG9iYWwgZmxhZ3MgKGV2ZXJ5IHN1YmNvbW1hbmQpCgp8" + - "IEZsYWcgfCBQdXJwb3NlIHwgRGVmYXVsdCB8CnwtLS18LS0tfC0tLXwKfCBgLS1jb25maWcgRklM" + - "RWAgfCBDb25maWcgZmlsZSBwYXRoIHwgYCRIT01FLy5udmNmLWNsaS55YW1sYCB8CnwgYC0tZGVi" + - "dWdgIHwgVmVyYm9zZSBIVFRQIGxvZ2dpbmcgb24gc3RkZXJyIHwgYGZhbHNlYCB8CnwgYC0tanNv" + - "bmAgfCBKU09OTCBldmVudHMgb24gc3RkZXJyIHwgYXV0byAob2ZmIGluIFRUWSwgb24gdW5kZXIg" + - "YC0tbm9uLWludGVyYWN0aXZlYCkgfAoKIyMgYHNlbGYtaG9zdGVkYCBwYXJlbnQgKHBlcnNpc3Rl" + - "bnQgYWNyb3NzIHN1YmNvbW1hbmRzKQoKfCBGbGFnIHwgUHVycG9zZSB8IERlZmF1bHQgfAp8LS0t" + - "fC0tLXwtLS18CnwgYC0tY29udHJvbC1wbGFuZS1zdGFjaz3igKZgIHwgQ29udHJvbC1wbGFuZSBi" + - "dW5kbGUgc291cmNlOiBsb2NhbCBwYXRoLCBnaXQgVVJMLCBvciBgb2NpOi8vYCBVUkwgfCBlbWJl" + - "ZGRlZCBPQ0kgVVJMIHBpbm5lZCBieSBDTEkgdmVyc2lvbiB8CnwgYC0tY29tcHV0ZS1wbGFuZS1z" + - "dGFjaz3igKZgIHwgQ29tcHV0ZS1wbGFuZSBidW5kbGUgc291cmNlOiBsb2NhbCBwYXRoLCBnaXQg" + - "VVJMLCBvciBgb2NpOi8vYCBVUkwgfCBlbWJlZGRlZCBPQ0kgVVJMIHBpbm5lZCBieSBDTEkgdmVy" + - "c2lvbiB8CnwgYC0tZW52PWxvY2FsXHxwcmRcfOKApmAgfCBIZWxtZmlsZSBlbnZpcm9ubWVudCBu" + - "YW1lIHwgYGxvY2FsYCBmb3IgZGV2IGJ1aWxkcywgYHByZGAgZm9yIHJlbGVhc2VzIHwKfCBgLS1u" + - "b24taW50ZXJhY3RpdmVgIHwgRGlzYWJsZSBhbGwgc3RkaW4gcHJvbXB0cyB8IGBmYWxzZWAgfAp8" + - "IGAtLXRva2VuPSRKV1RgIHwgQWRtaW4gSldULCBvdmVycmlkZXMgc3RvcmVkIHNlc3Npb24gfCAt" + - "IHwKfCBgLS1uby1hcHBseWAgfCBgaW5zdGFsbGAgb25seSAtIGVtaXQgWUFNTCwgZG8gbm90IGt1" + - "YmVjdGwgYXBwbHkgfCBgZmFsc2VgIHwKfCBgLS1vdXRwdXQ9dGV4dFx8anNvbmAgfCBMZWdhY3kg" + - "YWxpYXMgZm9yIGAtLWpzb25gIChkZXByZWNhdGVkLCByZW1vdmVkIGluIG5leHQgbWFqb3IpIHwg" + - "YHRleHRgIHwKfCBgLS1wbGFpbmAgfCBGb3JjZSBwbGFpbiBzdHJlYW1pbmcgb3V0cHV0IHwgYXV0" + - "by1kZXRlY3QgfAp8IGAtLXdhaXQgRFVSQVRJT05gIHwgYGNoZWNrYCBvbmx5OyBibG9jayB1bnRp" + - "bCBwYXNzIHwgLSB8CnwgYC0tY29udHJvbC1wbGFuZS1jb250ZXh0IENUWGAgfCBrdWJlY3RsIGNv" + - "bnRleHQgZm9yIGNvbnRyb2wgcGxhbmUgKFJFUS0yMCkgfCBjdXJyZW50IGNvbnRleHQgfAp8IGAt" + - "LWNvbXB1dGUtcGxhbmUtY29udGV4dCBDVFhgIHwga3ViZWN0bCBjb250ZXh0IGZvciBjb21wdXRl" + - "IHBsYW5lIChSRVEtMjApIHwgY3VycmVudCBjb250ZXh0IHwKfCBgLS1pY21zLXVybCBVUkxgIHwg" + - "UHVibGljIElDTVMgVVJMOyByZXF1aXJlZCB3aGVuIGNvbnRleHRzIGRpZmZlciB8IGRlcml2ZWQg" + - "ZnJvbSBgYmFzZV9odHRwX3VybGAgfAp8IGAtLWxvY2FsLW9ubHlgIHwgYGNoZWNrIC0tcHJlYCBv" + - "bmx5OyBza2lwIGFsbCBrdWJlY3RsIGNvbnRhY3QgfCBgZmFsc2VgIHwKCiMjIGB1cGAtc3BlY2lm" + - "aWMKCnwgRmxhZyB8IFB1cnBvc2UgfCBEZWZhdWx0IHwKfC0tLXwtLS18LS0tfAp8IGAtLWNsdXN0" + - "ZXItbmFtZSBOQU1FYCB8IElDTVMgY2x1c3RlciByb3cgaWRlbnRpZmllciAocmVxdWlyZWQpIHwg" + - "LSB8CnwgYC0tbmNhLWlkIElEYCB8IE5DQSBhY2NvdW50IElEIHwgYG52Y2YtZGVmYXVsdGAgfAp8" + - "IGAtLXJlZ2lvbiBSRUdJT05gIHwgQ2x1c3RlciByZWdpb24gfCBgdXMtd2VzdC0xYCB8CnwgYC0t" + - "cGxhbi1vbmx5YCB8IERyeS1ydW47IGVtaXQgcGhhc2UgcGxhbiArIEVUQXMgd2l0aG91dCBjaGFu" + - "Z2VzIHwgYGZhbHNlYCB8CgojIyBgc3RhdHVzYC1zcGVjaWZpYwoKfCBGbGFnIHwgUHVycG9zZSB8" + - "IERlZmF1bHQgfAp8LS0tfC0tLXwtLS18CnwgYC0tY2x1c3Rlci1uYW1lIE5BTUVgIHwgTGltaXQg" + - "dG8gb25lIGNvbXB1dGUgcGxhbmUgfCAtIChjb250cm9sICsgYWxsIGNsdXN0ZXJzKSB8CnwgYC0t" + - "d2F0Y2hgIHwgTGl2ZSByZS1yZW5kZXIgfCBgZmFsc2VgIHwKfCBgLS13YXRjaC1pbnRlcnZhbCBE" + - "VVJgIHwgYC0td2F0Y2hgIGNhZGVuY2UgfCBgNXNgIHwKfCBgLS1jb21wb25lbnQgTkFNRWAgfCBG" + - "aWx0ZXIgY29tcG9uZW50cyBwYW5lbCB8IGFsbCB8CnwgYC0tbm8tZXZlbnRzYCB8IFNraXAgZXZl" + - "bnRzIHBhbmVsIHwgYGZhbHNlYCB8CgojIyBgY2x1c3RlciByZWdpc3RlcmAtc3BlY2lmaWMKCnwg" + - "RmxhZyB8IFB1cnBvc2UgfCBEZWZhdWx0IHwKfC0tLXwtLS18LS0tfAp8IGAtLW5hbWUgTkFNRWAg" + - "fCBDbHVzdGVyIG5hbWUgKHJlcXVpcmVkKSB8IC0gfAp8IGAtLW5jYS1pZCBJRGAgfCBOQ0EgSUQg" + - "KHJlcXVpcmVkKSB8IC0gfAp8IGAtLXJlZ2lvbiBSRUdJT05gIHwgUmVnaW9uIHwgYHVzLXdlc3Qt" + - "MWAgfAp8IGAtLWljbXMtdXJsIFVSTGAgfCBJQ01TIGVuZHBvaW50IHwgZnJvbSBjb25maWcgfAp8" + - "IGAtLWlnbm9yZS1leGlzdGluZ2AgfCBNYXRjaC1vci1jcmVhdGUgaW5zdGVhZCBvZiBmYWlsLW9u" + - "LWV4aXN0cyB8IGBmYWxzZWAgfAoKIyMgYGFwaS1rZXkgZ2VuZXJhdGVgLXNwZWNpZmljCgp8IEZs" + - "YWcgfCBQdXJwb3NlIHwgRGVmYXVsdCB8CnwtLS18LS0tfC0tLXwKfCBgLS1mb3IgZnVuY3Rpb25c" + - "fHRhc2tgIHwgR2VuZXJhdGUgb25seSB0aGUgc3BlY2lmaWVkIGtleSB0eXBlIHwgKG9taXQgdG8g" + - "Z2VuZXJhdGUgYm90aCkgfAp8IGAtLWRlc2NyaXB0aW9uIFRFWFRgIHwgSHVtYW4tcmVhZGFibGUg" + - "bGFiZWwgZm9yIHRoZSBrZXkgfCBgR2VuZXJhdGVkIGJ5IG52Y2YtY2xpYCB8CnwgYC0tZXhwaXJl" + - "cy1pbiBEVVJBVElPTmAgfCBFeHBpcnkgb2Zmc2V0IChlLmcuIGAyNGhgLCBgN2RgKTsgcGFyc2Vk" + - "IGFzIGV4dGVuZGVkIGR1cmF0aW9uIHwgYDI0aGAgfAp8IGAtLXNjb3BlcyBTQ09QRVssU0NPUEVd" + - "YCB8IE92ZXJyaWRlIGRlZmF1bHQgc2NvcGVzOyByZXF1aXJlcyBgLS1mb3JgIHwgKHNlcnZpY2Ug" + - "ZGVmYXVsdHMpIHwKfCBgLS12YWxpZGF0ZWAgfCBWYWxpZGF0ZSBlYWNoIGdlbmVyYXRlZCBrZXkg" + - "aW1tZWRpYXRlbHkgYWZ0ZXIgbWludGluZyB8IGBmYWxzZWAgfAoKRXh0ZW5kZWQgZHVyYXRpb24g" + - "dW5pdHM6IGBzYCAoc2Vjb25kcyksIGBtYCAobWludXRlcyksIGBoYCAoaG91cnMpLCBgZGAgKGRh" + - "eXMpLCBgd2AgKHdlZWtzKS4KCiMjIGBmdW5jdGlvbiBjcmVhdGVgLXNwZWNpZmljCgpgLS1pbnB1" + - "dC1maWxlIEZJTEVgIGlzIHJlY29tbWVuZGVkIGZvciByZXBlYXRhYmxlIGZ1bmN0aW9uIGRlZmlu" + - "aXRpb25zLiBGb3IgYWQtaG9jIGNyZWF0ZXM6Cgp8IEZsYWcgfCBQdXJwb3NlIHwgRGVmYXVsdCB8" + - "CnwtLS18LS0tfC0tLXwKfCBgLS1uYW1lIE5BTUVgIHwgRnVuY3Rpb24gbmFtZSB8IC0gfAp8IGAt" + - "LWltYWdlIElNQUdFYCB8IENvbnRhaW5lciBpbWFnZSB8IC0gfAp8IGAtLWluZmVyZW5jZS11cmwg" + - "VVJJYCB8IENvbnRhaW5lciBpbmZlcmVuY2UgZW5kcG9pbnQgfCAtIHwKfCBgLS1pbmZlcmVuY2Ut" + - "cG9ydCBQT1JUYCB8IENvbnRhaW5lciBpbmZlcmVuY2UgcG9ydCB8IC0gfAp8IGAtLWZ1bmN0aW9u" + - "LXR5cGUgREVGQVVMVFx8U1RSRUFNSU5HXHxMTE1gIHwgRnVuY3Rpb24gdHlwZSB8IGBERUZBVUxU" + - "YCB8CnwgYC0taGVsbS1jaGFydCBDSEFSVGAgfCBIZWxtIGNoYXJ0IFVSTCBvciBPQ0kgcmVmZXJl" + - "bmNlLiBDYW4gYmUgdXNlZCB3aXRoIGAtLWZ1bmN0aW9uLXR5cGU9TExNYCBmb3IgY2hhcnQtcGFj" + - "a2FnZWQgTExNIHdvcmtsb2Fkcy4gfCAtIHwKfCBgLS1oZWxtLWNoYXJ0LXNlcnZpY2UgTkFNRWAg" + - "fCBLdWJlcm5ldGVzIFNlcnZpY2UgbmFtZSBleHBvc2VkIGJ5IHRoZSBjaGFydC4gUmVxdWlyZWQg" + - "d2hlbiBgLS1oZWxtLWNoYXJ0YCBpcyBzZXQuIHwgLSB8CnwgYC0tbW9kZWxzIE5BTUU6VkVSU0lP" + - "TjpVUklgIHwgU3RhbmRhcmQgbW9kZWwgYXJ0aWZhY3Q7IHJlcGVhdGFibGUgfCAtIHwKfCBgLS1s" + - "bG0tbW9kZWwgU1BFQ2AgfCBMTE0gbW9kZWwgY29uZmlnOyBmb3JtYXQgYG5hbWU9PG1vZGVsPix1" + - "cmlzPTx1cmk+XHw8dXJpPixyb3V0aW5nTWV0aG9kPTxtZXRob2Q+LHRva2VuUmF0ZUxpbWl0PTxs" + - "aW1pdD5gOyByZXBlYXRhYmxlLiBUb2tlbiBsaW1pdHMgdXNlIGA8dmFsdWU+LTx1bml0PmAgd2l0" + - "aCBgU2AsIGBNYCwgYEhgLCBgRGAsIG9yIGBXYCwgZm9yIGV4YW1wbGUgYDEwMDAtU2AuIFVzZSBp" + - "bnB1dCBKU09OIGZvciBjb21iaW5lZCB0b2tlbiBsaW1pdHMgYmVjYXVzZSBpbmxpbmUgc3BlY3Mg" + - "dXNlIGNvbW1hcyBhcyBmaWVsZCBzZXBhcmF0b3JzLiB8IC0gfAoKSW4gSlNPTiBhbmQgaW5saW5l" + - "IHNwZWNzLCBMTE0gZnVuY3Rpb25zIHNldCBgZnVuY3Rpb25UeXBlOiAiTExNImAgYW5kIG1vZGVs" + - "IHJvdXRpbmcgbWV0YWRhdGEgdW5kZXIgYG1vZGVsc1tdLmxsbUNvbmZpZ2AuIGBsbG1Db25maWcu" + - "dXJpc2AgZGVjbGFyZXMgdGhlIE9wZW5BSS1jb21wYXRpYmxlIHVwc3RyZWFtIHBhdGhzIGV4cG9z" + - "ZWQgYnkgdGhlIG1vZGVsLiBDdXJyZW50IHN1cHBvcnRlZCBwYXRocyBhcmUgYC92MS9jaGF0L2Nv" + - "bXBsZXRpb25zYCwgYC92MS9yZXNwb25zZXNgLCBhbmQgYC92MS9lbWJlZGRpbmdzYC4gYGxsbUNv" + - "bmZpZy5yb3V0aW5nTWV0aG9kYCBhY2NlcHRzIGByb3VuZF9yb2JpbmAsIGBwb3dlcl9vZl90d29g" + - "LCBgZ3JvcV9tdWx0aXJlZ2lvbmAsIGBwdWxzYXJgLCBvciBgcmFuZG9tYC4KYGxsbUNvbmZpZy50" + - "b2tlblJhdGVMaW1pdGAgYWNjZXB0cyBvbmUgb3IgbW9yZSBjb21tYS1zZXBhcmF0ZWQgcG9zaXRp" + - "dmUgaW50ZWdlciB0b2tlbiBsaW1pdHMgaW4gYDx2YWx1ZT4tPHVuaXQ+YCBmb3JtYXQuIFN1cHBv" + - "cnRlZCB1bml0cyBhcmUgYFNgIChzZWNvbmRzKSwgYE1gIChtaW51dGVzKSwgYEhgIChob3Vycyks" + - "IGBEYCAoZGF5cyksIGFuZCBgV2AgKHdlZWtzKS4gVXNlIGRpc3RpbmN0IHVuaXRzIHdoZW4gY29t" + - "YmluaW5nIGxpbWl0cywgZm9yIGV4YW1wbGUgYDEwMDAtUyw1MDAwLU0sMTAwMDAwLUgsNTAwMDAw" + - "LUQsMTAwMDAwMC1XYCBpbiBpbnB1dCBKU09OLgoKSGVsbSBjaGFydCBwYWNrYWdpbmcgaXMgaW5k" + - "ZXBlbmRlbnQgb2YgYGZ1bmN0aW9uVHlwZWAuIEZvciBhIEhlbG0tY2hhcnQgYmFja2VkIExMTSBm" + - "dW5jdGlvbiwgc2V0IGBmdW5jdGlvblR5cGU6ICJMTE0iYCwgYGhlbG1DaGFydGAsIGBoZWxtQ2hh" + - "cnRTZXJ2aWNlTmFtZWAsIGFuZCBgbW9kZWxzW10ubGxtQ29uZmlnYCBpbiB0aGUgc2FtZSBjcmVh" + - "dGUgcmVxdWVzdC4gYGluZmVyZW5jZVBvcnRgIG11c3QgYmUgdGhlIEt1YmVybmV0ZXMgU2Vydmlj" + - "ZSBwb3J0IGV4cG9zZWQgYnkgYGhlbG1DaGFydFNlcnZpY2VOYW1lYC4KCkxMTSBpbnZvY2F0aW9u" + - "IHJlcXVlc3RzIHVzZSBgbW9kZWw6ICI8ZnVuY3Rpb24taWQ+Lzxtb2RlbC1uYW1lPiJgLiBUaGUg" + - "ZnVuY3Rpb24gSUQgc2VsZWN0cyB0aGUgTlZDRiBmdW5jdGlvbiwgYW5kIHRoZSBtb2RlbCBuYW1l" + - "IGlzIGZvcndhcmRlZCB1cHN0cmVhbS4gQ2hhdCBjb21wbGV0aW9ucyBhbmQgUmVzcG9uc2VzIEFQ" + - "SSByZXF1ZXN0cyBjYW4gdXNlIGB4LW11bHRpLXR1cm4tc2Vzc2lvbi1pZGAgZm9yIHNlc3Npb24g" + - "c3RpY2tpbmVzczsgZW1iZWRkaW5ncyByZXF1ZXN0cyBkbyBub3QuCgojIyBgZnVuY3Rpb24gdXBk" + - "YXRlYC1zcGVjaWZpYwoKfCBGbGFnIHwgUHVycG9zZSB8IERlZmF1bHQgfAp8LS0tfC0tLXwtLS18" + - "CnwgYC0tdGFncyBUQUdbLFRBR11gIHwgUmVwbGFjZSBmdW5jdGlvbiB0YWdzIHwgLSB8CnwgYC0t" + - "bGxtLW1vZGVsLXVwZGF0ZSBTUEVDYCB8IExMTSBtb2RlbCB1cGRhdGU7IGZvcm1hdCBgbmFtZT08" + - "bW9kZWw+LHJvdXRpbmdNZXRob2Q9PG1ldGhvZD4sdG9rZW5SYXRlTGltaXQ9PGxpbWl0PmA7IHJl" + - "cGVhdGFibGUuIFJvdXRpbmcgbWV0aG9kcyBtYXRjaCBgLS1sbG0tbW9kZWxgLiBUb2tlbiBsaW1p" + - "dCBleGFtcGxlOiBgMTAwMC1TYC4gVXNlIGlucHV0IEpTT04gZm9yIGNvbWJpbmVkIHRva2VuIGxp" + - "bWl0cy4gfCAtIHwKCkluIEpTT04sIGBmdW5jdGlvbiB1cGRhdGVgIGFjY2VwdHMgYG1vZGVsVXBk" + - "YXRlc1tdYCBlbnRyaWVzIHdpdGggYG1vZGVsTmFtZWAgYW5kIGBsbG1Db25maWcucm91dGluZ01l" + - "dGhvZGAgYW5kL29yIGBsbG1Db25maWcudG9rZW5SYXRlTGltaXRgLiBgdXJpc2AgYXJlIGNyZWF0" + - "ZS10aW1lIG1vZGVsIG1ldGFkYXRhIGFuZCBhcmUgbm90IHBhcnQgb2YgbW9kZWwgdXBkYXRlcy4K" + - "CiMjIGBmdW5jdGlvbiBkZXBsb3kgY3JlYXRlYC1zcGVjaWZpYwoKYC0taW5wdXQtZmlsZSBGSUxF" + - "YCBpcyByZWNvbW1lbmRlZCAoZnVsbCBKU09OIHNwZWMpLiBGb3IgYWQtaG9jIG9uZS1zaG90IHVz" + - "ZToKCnwgRmxhZyB8IFB1cnBvc2UgfCBEZWZhdWx0IHwKfC0tLXwtLS18LS0tfAp8IGAtLWZ1bmN0" + - "aW9uLWlkIElEYCB8IEZ1bmN0aW9uIElEIChyZXF1aXJlZCkgfCAtIHwKfCBgLS1ncHUgTkFNRWAg" + - "fCBHUFUgZmFtaWx5IHwgYEgxMDBgIHwKfCBgLS1pbnN0YW5jZS10eXBlIFRZUEVgIHwgU0tVIHwg" + - "YE5DUC5HUFUuSDEwMF8xeGAgfAp8IGAtLW1pbi1pbnN0YW5jZXMgTmAgfCBNaW4gcmVwbGljYXMg" + - "fCBgMWAgfAp8IGAtLW1heC1pbnN0YW5jZXMgTmAgfCBNYXggcmVwbGljYXMgfCBgMWAgfAp8IGAt" + - "LW1heC1yZXF1ZXN0LWNvbmN1cnJlbmN5IE5gIHwgQ29uY3VycmVuY3kgfCBgMGAgKHVuc2V0OyBz" + - "ZXJ2ZXIgZGVmYXVsdCBhcHBsaWVzKSB8CnwgYC0tY2x1c3RlcnMgTkFNRVssTkFNRV1gIHwgVGFy" + - "Z2V0IHNwZWNpZmljIGNvbXB1dGUgY2x1c3RlcnMgfCAoYW55IG1hdGNoaW5nIFNLVSkgfAoKIyMg" + - "YHRhc2sgY3JlYXRlYC1zcGVjaWZpYwoKYC0taW5wdXQtZmlsZSBGSUxFYCBpcyByZWNvbW1lbmRl" + - "ZCBmb3IgcmVwZWF0YWJsZSB0YXNrIGRlZmluaXRpb25zLiBGb3IgYWQtaG9jIHVzZToKCnwgRmxh" + - "ZyB8IFB1cnBvc2UgfCBOb3RlcyB8CnwtLS18LS0tfC0tLXwKfCBgLS1uYW1lIE5BTUVgIHwgVGFz" + - "ayBuYW1lIChyZXF1aXJlZCkgfCAxLTEyOCBjaGFycywgYF5bYS16MC05QS1aXVthLXowLTlBLVpc" + - "LV9dKiRgIHwKfCBgLS1ncHUgR1BVYCB8IEdQVSBuYW1lIChyZXF1aXJlZCB3aXRob3V0IGAtLWlu" + - "cHV0LWZpbGVgKSB8IEV4YW1wbGU6IGBIMTAwYCB8CnwgYC0taW5zdGFuY2UtdHlwZSBUWVBFYCB8" + - "IEluc3RhbmNlIHR5cGUgKHJlcXVpcmVkIHdpdGhvdXQgYC0taW5wdXQtZmlsZWApIHwgRXhhbXBs" + - "ZTogYE5DUC5HUFUuSDEwMF8xeGAgfAp8IGAtLWltYWdlIElNQUdFYCB8IENvbnRhaW5lciBpbWFn" + - "ZSB8IE11dHVhbGx5IGV4Y2x1c2l2ZSB3aXRoIGAtLWhlbG0tY2hhcnRgIHwKfCBgLS1oZWxtLWNo" + - "YXJ0IENIQVJUYCB8IEhlbG0gY2hhcnQgVVJMIG9yIE9DSSByZWZlcmVuY2UgfCBNdXR1YWxseSBl" + - "eGNsdXNpdmUgd2l0aCBgLS1pbWFnZWAgfAp8IGAtLWlucHV0LWZpbGUgRklMRWAgfCBKU09OIHRh" + - "c2sgc3BlYyBmaWxlIHwgQ0xJIGZsYWdzIG92ZXJyaWRlIEpTT04gdmFsdWVzIHdoZW4gYm90aCBh" + - "cmUgc2V0IHwKfCBgLS1iYWNrZW5kIEJBQ0tFTkRgIHwgQmFja2VuZCAvIENTUCB8IC0gfAp8IGAt" + - "LWNsdXN0ZXJzIE5BTUVbLE5BTUVdYCB8IFNwZWNpZmljIGNsdXN0ZXJzIHdpdGhpbiB0aGUgaW5z" + - "dGFuY2UgfCBDb21tYS1zZXBhcmF0ZWQgfAp8IGAtLWNvbnRhaW5lci1hcmdzIEFSR1NgIHwgQXJn" + - "cyBwYXNzZWQgd2hlbiBsYXVuY2hpbmcgdGhlIGNvbnRhaW5lciB8IFNpbmdsZSBzdHJpbmcsIGUu" + - "Zy4gYCItLWVwb2NocyAxMCAtLWJhdGNoLXNpemUgMzIiYCB8CnwgYC0tY29udGFpbmVyLWVudiBO" + - "QU1FPXZhbHVlYCB8IENvbnRhaW5lciBlbnZpcm9ubWVudCB2YXJpYWJsZTsgcmVwZWF0YWJsZSB8" + - "IC0gfAp8IGAtLXNlY3JldHMgTkFNRT12YWx1ZWAgfCBTZWNyZXQgZW52aXJvbm1lbnQgdmFyaWFi" + - "bGU7IHJlcGVhdGFibGU7IGVuY3J5cHRlZCBhdCByZXN0IHwgLSB8CnwgYC0tbWF4LXJ1bnRpbWUg" + - "RFVSQVRJT05gIHwgTWF4IHdhbGwtY2xvY2sgcnVuIHRpbWUgKElTTyA4NjAxLCBlLmcuIGBQVDRI" + - "YCkgfCBObyBkZWZhdWx0OyBvbWl0IGZvciBubyB0aW1lIGxpbWl0IHwKfCBgLS1tYXgtcXVldWVk" + - "IERVUkFUSU9OYCB8IE1heCB0aW1lIGluIHF1ZXVlIGJlZm9yZSBjYW5jZWxsYXRpb24gKElTTyA4" + - "NjAxKSB8IFNlcnZlciBkZWZhdWx0IGBQVDcySGAgfAp8IGAtLXRlcm1pbmF0aW9uLWdyYWNlIERV" + - "UkFUSU9OYCB8IEdyYWNlIHBlcmlvZCBhZnRlciBzdG9wIHNpZ25hbCAoSVNPIDg2MDEpIHwgU2Vy" + - "dmVyIGRlZmF1bHQgYFBUMUhgIHwKfCBgLS1yZXN1bHQtc3RyYXRlZ3kgVVBMT0FEXHxOT05FYCB8" + - "IEhvdyB0byBoYW5kbGUgdGFzayBvdXRwdXQgYXJ0aWZhY3RzIHwgLSB8CnwgYC0tcmVzdWx0cy1s" + - "b2NhdGlvbiBMT0NBVElPTmAgfCBSZXN1bHQgdXBsb2FkIHRhcmdldCwgZm9ybWF0IGBvcmctbmFt" + - "ZS9bdGVhbS1uYW1lL11tb2RlbC1uYW1lYDsgcmVxdWlyZWQgd2hlbiBgLS1yZXN1bHQtc3RyYXRl" + - "Z3k9VVBMT0FEYCB8IC0gfAp8IGAtLW1vZGVscyBOQU1FOlZFUlNJT046VVJJYCB8IE1vZGVsIGFy" + - "dGlmYWN0OyByZXBlYXRhYmxlIHwgLSB8CnwgYC0tcmVzb3VyY2VzIE5BTUU6VkVSU0lPTjpVUklg" + - "IHwgUmVzb3VyY2UgYXJ0aWZhY3Q7IHJlcGVhdGFibGUgfCAtIHwKfCBgLS10YWdzIFRBR1ssVEFH" + - "XWAgfCBUYXNrIHRhZ3MgfCBDb21tYS1zZXBhcmF0ZWQgfAp8IGAtLWRlc2NyaXB0aW9uIFRFWFRg" + - "IHwgVGFzayBkZXNjcmlwdGlvbiB8IC0gfAp8IGAtLWxvZ3MtdGVsZW1ldHJ5LWlkIFVVSURgIHwg" + - "TG9ncyB0ZWxlbWV0cnkgZW5kcG9pbnQgSUQgfCAtIHwKfCBgLS1tZXRyaWNzLXRlbGVtZXRyeS1p" + - "ZCBVVUlEYCB8IE1ldHJpY3MgdGVsZW1ldHJ5IGVuZHBvaW50IElEIHwgLSB8CnwgYC0tdHJhY2Vz" + - "LXRlbGVtZXRyeS1pZCBVVUlEYCB8IFRyYWNlcyB0ZWxlbWV0cnkgZW5kcG9pbnQgSUQgfCAtIHwK" + - "ClBLBwj8o5HgxiIAAMYiAABQSwMEFAAIAAAAAAAhAAAAAAAAAAAAAAAAADcACQBkYXRhL252Y2Yt" + - "c2VsZi1tYW5hZ2VkLWNsaS9yZWZlcmVuY2UvdHJvdWJsZXNob290aW5nLm1kVVQFAAEAps4SIyBU" + - "cm91Ymxlc2hvb3RpbmcKCktub3duIGVycm9ycyDihpIgZGlhZ25vc3RpYyBjb21tYW5kIOKGkiBy" + - "ZW1lZGlhdGlvbi4gS2VlcCBpbiBzeW5jIHdpdGggdGhlIHN0cnVjdHVyZWQgYHBoYXNlX2ZhaWxl" + - "ZGAgZXZlbnRzIHRoZSBDTEkgZW1pdHMgKFJFUS0xNSkg4oCUIGV2ZXJ5IGVudHJ5IGJlbG93IHNo" + - "b3VsZCBtYXAgdG8gYW4gYGVyckNhdGVnb3J5YCBhbmQgYSBgcmVtZWRpYXRpb25gIGFycmF5LgoK" + - "IyMgUHJlLWZsaWdodAoKfCBTeW1wdG9tIHwgQ2F1c2UgfCBSZW1lZGlhdGlvbiB8CnwtLS18LS0t" + - "fC0tLXwKfCBga3ViZWN0bCBub3Qgb24gUEFUSGAgfCBPcGVyYXRvcidzIGAkUEFUSGAgZG9lc24n" + - "dCBpbmNsdWRlIGt1YmVjdGwgfCBJbnN0YWxsIGt1YmVjdGwgMS4yOCs6IGh0dHBzOi8va3ViZXJu" + - "ZXRlcy5pby9kb2NzL3Rhc2tzL3Rvb2xzL2luc3RhbGwta3ViZWN0bC8gfAp8IGBoZWxtZmlsZSBu" + - "b3Qgb24gUEFUSGAgfCBTYW1lIHwgaHR0cHM6Ly9naXRodWIuY29tL2hlbG1maWxlL2hlbG1maWxl" + - "I2luc3RhbGxhdGlvbiB8CnwgYGhlbG0gbm90IG9uIFBBVEhgIHwgU2FtZSB8IGh0dHBzOi8vaGVs" + - "bS5zaC9kb2NzL2ludHJvL2luc3RhbGwvIHwKfCBgR2F0ZXdheSBBUEkgQ1JEcyBub3QgaW5zdGFs" + - "bGVkYCB8IGVudm95LWdhdGV3YXkgcHJlcmVxIG1pc3NpbmcgfCBgaGVsbSBpbnN0YWxsIGVnIG9j" + - "aTovL2RvY2tlci5pby9lbnZveXByb3h5L2dhdGV3YXktaGVsbSAtLW5hbWVzcGFjZT1lbnZveS1n" + - "YXRld2F5LXN5c3RlbSAtLWNyZWF0ZS1uYW1lc3BhY2VgIHwKfCBgZGVmYXVsdCBTdG9yYWdlQ2xh" + - "c3Mgbm90IGF2YWlsYWJsZWAgfCBDbHVzdGVyIGhhcyBubyBkZWZhdWx0IFNDIHwgQW5ub3RhdGUg" + - "b25lOiBga3ViZWN0bCBwYXRjaCBzYyA8bmFtZT4gLXAgJ3sibWV0YWRhdGEiOnsiYW5ub3RhdGlv" + - "bnMiOnsic3RvcmFnZWNsYXNzLmt1YmVybmV0ZXMuaW8vaXMtZGVmYXVsdC1jbGFzcyI6InRydWUi" + - "fX19J2AgfAp8IGBHUFUgb3BlcmF0b3Igbm90IGluc3RhbGxlZGAgKGNvbXB1dGUtcGxhbmUpIHwg" + - "bnZpZGlhIEdQVSBvcGVyYXRvciBtaXNzaW5nIHwgSW5zdGFsbCBwZXIgaHR0cHM6Ly9kb2NzLm52" + - "aWRpYS5jb20vZGF0YWNlbnRlci9jbG91ZC1uYXRpdmUvZ3B1LW9wZXJhdG9yL2xhdGVzdC9pbnN0" + - "YWxsLWdwdS1vcGVyYXRvci5odG1sLCBPUiB1c2UgYGZha2UtZ3B1LW9wZXJhdG9yYCBmb3IgZGV2" + - "IHwKfCBgR1BVIG5vZGUgbGFiZWxzIG1pc3NpbmdgIChjb21wdXRlLXBsYW5lKSB8IE5vZGVzIG5l" + - "ZWQgYG52aWRpYS5jb20vZ3B1LmZhbWlseWAgZXRjLiB8IFNldCBgLS1rM3Mtbm9kZS1sYWJlbCBu" + - "dmlkaWEuY29tL2dwdS5mYW1pbHk9aG9wcGVyQGFnZW50Ok5gIGZvciBrM2QgfAoKIyMgQXV0aAoK" + - "fCBTeW1wdG9tIHwgQ2F1c2UgfCBSZW1lZGlhdGlvbiB8CnwtLS18LS0tfC0tLXwKfCBgYWRtaW4g" + - "dG9rZW4gcmVxdWlyZWRgIChpbml0IG5vdCBydW4pIHwgTm8gYH4vLm52Y2YtY2xpLnN0YXRlYCBh" + - "bmQgYC0tdG9rZW5gIG5vdCBwYXNzZWQgfCBgbnZjZi1jbGkgaW5pdGAgKGludGVyYWN0aXZlKSBv" + - "ciBgLS10b2tlbj0kSldUIC0tbm9uLWludGVyYWN0aXZlYCAoQ0kpIHwKfCBgU2lnbmVkIEpXVCBy" + - "ZWplY3RlZDogQW5vdGhlciBhbGdvcml0aG0gZXhwZWN0ZWQsIG9yIG5vIG1hdGNoaW5nIGtleShz" + - "KSBmb3VuZGAgfCBTdGFsZSBzZXNzaW9uLmpzb24gZnJvbSBhIGRpZmZlcmVudCBjb250cm9sIHBs" + - "YW5lIHwgYHJtIH4vLm52Y2YtY2xpLnN0YXRlYCB0aGVuIGBudmNmLWNsaSBpbml0YCBhZ2FpbiB8" + - "CnwgYDQwMyBtaXNzaW5nIHJlcXVlc3RlZCBhdXRob3JpdGllc2AgKGZ1bmN0aW9uIGludm9rZSkg" + - "fCBBZG1pbiB0b2tlbiBkb2Vzbid0IGhhdmUgYGludm9rZV9mdW5jdGlvbmAgc2NvcGUgfCBgbnZj" + - "Zi1jbGkgYXBpLWtleSBnZW5lcmF0ZSAtLWRlc2NyaXB0aW9uPeKApmAgdGhlbiByZS1ydW4gaW52" + - "b2tlIHwKCiMjIEluc3RhbGwgLyBgdXBgCgp8IFN5bXB0b20gfCBDYXVzZSB8IFJlbWVkaWF0aW9u" + - "IHwKfC0tLXwtLS18LS0tfAp8IEhlbG0gYHRpbWVkIG91dCB3YWl0aW5nIGZvciBjYXNzYW5kcmFg" + - "IHwgQ2Fzc2FuZHJhIFN0YXRlZnVsU2V0IFBWQyBzdHVjayBgUGVuZGluZ2AgfCBDb25maXJtIGRl" + - "ZmF1bHQgU3RvcmFnZUNsYXNzOyBjaGVjayBga3ViZWN0bCBnZXQgcHYscHZjIC1uIGNhc3NhbmRy" + - "YS1zeXN0ZW1gIHwKfCBgSW52YWxpZCBHUFUgJ05DUC5HUFUuSDEwMCcgc3BlY2lmaWVkYCAoZnVu" + - "Y3Rpb24gZGVwbG95KSB8IFdyb25nIGZpZWxkIOKAlCBgZ3B1YCBpcyB0aGUgZmFtaWx5LCBub3Qg" + - "dGhlIFNLVSB8IFVzZSBgImdwdSI6ICJIMTAwImAsIGAiaW5zdGFuY2VUeXBlIjogIk5DUC5HUFUu" + - "SDEwMF8xeCJgIHwKfCBgcmVnaW9uIG11c3QgYmUgcHJvdmlkZWRgIChjbHVzdGVyIHJlZ2lzdGVy" + - "IC8gaW5zdGFsbCAtLWNvbXB1dGUtcGxhbmUpIHwgYC0tcmVnaW9uYCBlbXB0eSArIGBDTFVTVEVS" + - "X1JFR0lPTmAgZW52IGVtcHR5IHwgUGFzcyBgLS1yZWdpb249dXMtd2VzdC0xYCAob3IgYW55IG5v" + - "bi1lbXB0eSB2YWx1ZSkgfAp8IGByZXF1aXJlZEVudiAiTkNBX0lEIiBpcyBub3Qgc2V0YCAoaGVs" + - "bWZpbGUgZXJyb3IgZHVyaW5nIGNvbXB1dGUtcGxhbmUgYXBwbHkpIHwgT2xkZXIgbnZjZi1jbGkg" + - "YmVmb3JlIGNvbW1pdCBgNmFhNTcwNGA7IEV4dHJhRW52IG5vdCBwcm9wYWdhdGluZyBOQ0FfSUQg" + - "fCBVcGdyYWRlIGBudmNmLWNsaWAgdG8gYSByZWxlYXNlIGFmdGVyIGA2YWE1NzA0YCB8CnwgYG52" + - "Y2Etb3BlcmF0b3I6IEltYWdlUHVsbEJhY2tPZmZgIGZvciBgbnZjYS1vcGVyYXRvcjpwc2F0YCB8" + - "IEltYWdlIG5vdCBpbiBjbHVzdGVyIHJlZ2lzdHJ5OyBtdWx0aS1jbHVzdGVyIGJ1aWxkIGlzIGxv" + - "Y2FsIHwgYGszZCBpbWFnZSBpbXBvcnQgbnZjci5pby8uLi4vbnZjYS1vcGVyYXRvcjpwc2F0IC1j" + - "IDxjbHVzdGVyPmAgfAoKIyMgQ29tcHV0ZS1wbGFuZSBydW50aW1lCgp8IFN5bXB0b20gfCBDYXVz" + - "ZSB8IFJlbWVkaWF0aW9uIHwKfC0tLXwtLS18LS0tfAp8IE5WQ0EgYWdlbnQgQ3Jhc2hMb29wQmFj" + - "a09mZiB3aXRoIGBIVFRQIDQwMWAgb24gYC92MS9udmNhL2NsdXN0ZXJzLy4uLi9yZWdpc3RlcmAg" + - "fCBTdGFsZSBgb3V0LzxjbHVzdGVyPi1yZWdpc3Rlci12YWx1ZXMueWFtbGAgZnJvbSBwcmlvciBy" + - "ZWdpc3RlcjsgY2x1c3RlciBJRCBkb2Vzbid0IG1hdGNoIElDTVMgfCBEZWxldGUgdGhlIHN0YWxl" + - "IGZpbGU7IHJlLXJ1biBgbnZjZi1jbGkgc2VsZi1ob3N0ZWQgdXBgIChpZGVtcG90ZW50IHJlZ2lz" + - "dGVyIHdyaXRlcyBhIGZyZXNoIGZpbGUpIHwKfCBgTm8gY2x1c3RlciBmb3VuZCB3aXRoIHZhbGlk" + - "IEpXS1MgZm9yIGNsdXN0ZXIgSUQ6IDxpZD5gIChJQ01TIGxvZykgfCBKV0tTIGluIElDTVMgZG9l" + - "c24ndCBtYXRjaCB3aGF0IGNvbXB1dGUtcGxhbmUgSzhzIGlzIGN1cnJlbnRseSBzaWduaW5nIHwg" + - "YG52Y2YtY2xpIGNsdXN0ZXIgcm90YXRlIC0tY2x1c3Rlci1pZD08aWQ+YCB8CnwgRnVuY3Rpb24g" + - "cG9kIGBJbWFnZVB1bGxCYWNrT2ZmYCBpbiBgbnZjZi1iYWNrZW5kYCB8IEltYWdlLWNyZWRlbnRp" + - "YWwtaGVscGVyIGNvbmZpZyBtaXNzaW5nIG9yIHdyb25nIHwgYGt1YmVjdGwgZGVzY3JpYmUgcG9k" + - "IC1uIG52Y2YtYmFja2VuZCA8cG9kPmA7IGNoZWNrIHRoZSBwdWxsIHNlY3JldCBjb25maWcgfAp8" + - "IEZ1bmN0aW9uIGRlcGxveSBzdHVjayBgREVQTE9ZSU5HYCBmb3IgPjUgbWluIHwgTkFUUyBzdHJl" + - "YW0gaW5pdCBsYWcgKGNvbGQtY2x1c3Rlcikg4oCUIHdhaXQsIG9yIGNoZWNrIE5BVFMgYXV0aC1j" + - "YWxsb3V0IGhlYWx0aCB8IGBrdWJlY3RsIGxvZ3MgLW4gbmF0cy1zeXN0ZW0gLWwgYXBwLmt1YmVy" + - "bmV0ZXMuaW8vbmFtZT1uYXRzLWF1dGgtY2FsbG91dC1zZXJ2aWNlYCB8CgojIyBUYXNrcwoKfCBT" + - "eW1wdG9tIHwgQ2F1c2UgfCBSZW1lZGlhdGlvbiB8CnwtLS18LS0tfC0tLXwKfCBgdGFzayBjcmVh" + - "dGVgIHJldHVybnMgYE1pc3NpbmcgPFRZUEU+IHJlZ2lzdHJ5IGNyZWRlbnRpYWwgZm9yIGhvc3Ru" + - "YW1lYCwgb3Iga2VlcHMgdXNpbmcgYSBwcmV2aW91cyBjcmVkZW50aWFsIHZhbHVlLCBzaG9ydGx5" + - "IGFmdGVyIGByZWdpc3RyeS1jcmVkZW50aWFsIGFkZC91cGRhdGUvZGVsZXRlYCB3aGlsZSBgcmVn" + - "aXN0cnktY3JlZGVudGlhbCBsaXN0YC9gZ2V0YCBhbHJlYWR5IHNob3cgdGhlIG5ldyB2YWx1ZSB8" + - "IEV4cGVjdGVkIHByb3BhZ2F0aW9uIGRlbGF5OiBOVkNUIGNhY2hlcyB0aGUgYWNjb3VudCdzIHJl" + - "Z2lzdHJ5IGNyZWRlbnRpYWxzIHdpdGggYG52Y3QubnZjZi5jYWNoZS10dGxgIChkZWZhdWx0IGBQ" + - "VDVNYCwgYWJvdXQgNSBtaW4pIGFuZCBhcHBsaWVzIHRoZSBjaGFuZ2Ugd2hlbiB0aGF0IGNhY2hl" + - "ZCBjb3B5IHJlZnJlc2hlcyB8IFdhaXQgdXAgdG8gYWJvdXQgNSBtaW4gYW5kIHJldHJ5LCBvciBg" + - "a3ViZWN0bCAtbiBudmNmIHJvbGxvdXQgcmVzdGFydCBkZXBsb3ltZW50L252Y3QtYXBpYCB0byBh" + - "cHBseSBpbW1lZGlhdGVseSB8ClBLBwjzrhOEdBEAAHQRAABQSwMEFAAIAAAAAAAhAAAAAAAAAAAA" + - "AAAAACwACQBkYXRhL252Y2Ytc2VsZi1tYW5hZ2VkLWluc3RhbGxhdGlvbi9TS0lMTC5tZFVUBQAB" + - "AKbOEi0tLQpuYW1lOiBudmNmLXNlbGYtbWFuYWdlZC1pbnN0YWxsYXRpb24KZGVzY3JpcHRpb246" + - "ID4tCiAgSW5zdGFsbCBhbmQgb3BlcmF0ZSBOVkNGIHNlbGYtaG9zdGVkIGNvbnRyb2wtcGxhbmUg" + - "YW5kIHNlcGFyYXRlIGNvbXB1dGUtcGxhbmUKICBzdGFja3MuIENvdmVycyBIZWxtZmlsZSB2YWx1" + - "ZXMgYW5kIENMSSBwcm9maWxlIGluc3RhbGxhdGlvbiBmbG93cywgdGVhcmRvd24sCiAgdmFsdWVz" + - "IG92ZXJyaWRlcywgcHVsbCBzZWNyZXRzLCBhbmQgdHJvdWJsZXNob290aW5nLiBVc2UgZm9yCiAg" + - "bnZjZi1zZWxmLW1hbmFnZWQtc3RhY2ssIG52Y2YtY29tcHV0ZS1wbGFuZS1zdGFjaywgc3BsaXQg" + - "Y29tcHV0ZS1wbGFuZQogIGluc3RhbGxhdGlvbiwgY29udHJvbC1wbGFuZSBpbnN0YWxsYXRpb24s" + - "IENMSS1nZW5lcmF0ZWQgY29udHJvbC1wbGFuZQogIHByb2ZpbGVzLCBIZWxtZmlsZSwgc2VsZi1t" + - "YW5hZ2VkLCBvciBzZWxmLWhvc3RlZCBkZXBsb3ltZW50cy4gRG8gTk9UIHVzZSBmb3IKICBsb2Nh" + - "bCBrM2QgZW52aXJvbm1lbnRzOyB1c2UgdGhlIGxvY2FsIGszZCBkZXZlbG9wbWVudCB3b3JrZmxv" + - "dyBpbnN0ZWFkLgpsaWNlbnNlOiBBcGFjaGUtMi4wCmNvbXBhdGliaWxpdHk6IFJlcXVpcmVzIGhl" + - "bG1maWxlID49IDEuMS4wIDwgMS4yLjAsIGhlbG0gPj0gMy4xMiwgaGVsbS1kaWZmIHBsdWdpbiwg" + - "a3ViZWN0bCBtYXRjaGluZyBjbHVzdGVyIHZlcnNpb24KYXV0aG9yOiAibnZjZi1jb3JlLWVuZyA8" + - "bnZjZi1jb3JlLWVuZ0BleGNoYW5nZS5udmlkaWEuY29tPiIKdmVyc2lvbjogIjEuMC4wIgp0YWdz" + - "OiBbbnZjZiwgc2VsZi1tYW5hZ2VkLCBoZWxtZmlsZSwgc2VsZi1ob3N0ZWQsIGNvbnRyb2wtcGxh" + - "bmUsIGNvbXB1dGUtcGxhbmUsIGNsaS1wcm9maWxlLCBpbnN0YWxsYXRpb24sIGRlcGxveW1lbnQs" + - "IHB1bGwtc2VjcmV0c10KdG9vbHM6IFtTaGVsbCwgUmVhZCwgRWRpdCwgR3JlcCwgR2xvYl0KbWV0" + - "YWRhdGE6CiAgaW50ZXJuYWw6IGZhbHNlCiAgYXV0aG9yOiAibnZjZi1jb3JlLWVuZyA8bnZjZi1j" + - "b3JlLWVuZ0BleGNoYW5nZS5udmlkaWEuY29tPiIKICB2ZXJzaW9uOiAiMS4wIgogIHRhZ3M6IFtu" + - "dmNmLCBzZWxmLW1hbmFnZWQsIGhlbG1maWxlLCBzZWxmLWhvc3RlZCwgY29udHJvbC1wbGFuZSwg" + - "Y29tcHV0ZS1wbGFuZSwgY2xpLXByb2ZpbGUsIGluc3RhbGxhdGlvbiwgZGVwbG95bWVudCwgcHVs" + - "bC1zZWNyZXRzXQogIGxhbmd1YWdlczogW2Jhc2gsIHlhbWxdCiAgZnJhbWV3b3JrczogW2hlbG1m" + - "aWxlLCBoZWxtLCBrdWJlY3RsXQogIGRvbWFpbjogY2xvdWQtaW5mcmFzdHJ1Y3R1cmUKLS0tCgoj" + - "IE5WQ0YgU2VsZi1NYW5hZ2VkIFN0YWNrIE9wZXJhdGlvbnMKCk9wZXJhdGlvbmFsIGd1aWRlIGZv" + - "ciBtYXRjaGluZyBOVkNGIGNvbnRyb2wtcGxhbmUgYW5kIGNvbXB1dGUtcGxhbmUgSGVsbWZpbGUg" + - "YnVuZGxlcy4KCiMjIEluc3RydWN0aW9ucwoKVXNlIHRoaXMgc2tpbGwgZm9yIGluc3RhbGwsIHVw" + - "Z3JhZGUsIG9yIHRlYXJkb3duIHdvcmsgaW4gbWF0Y2hpbmcgYG52Y2Ytc2VsZi1tYW5hZ2VkLXN0" + - "YWNrYCBhbmQgYG52Y2YtY29tcHV0ZS1wbGFuZS1zdGFja2AgYnVuZGxlczsga2VlcCBIZWxtZmls" + - "ZSB2YWx1ZXMgYW5kIENMSSBwcm9maWxlIGhhbmRvZmZzIHNlcGFyYXRlLiBGb3IgYGZ1bmN0aW9u" + - "VHlwZTogIkxMTSJgLCByZWFkIFtMTE0gRnVuY3Rpb24gRW5hYmxlbWVudF0ocmVmZXJlbmNlcy9o" + - "ZWxtZmlsZS1zdHJ1Y3R1cmUubWQjbGxtLWZ1bmN0aW9uLWVuYWJsZW1lbnQpLgoKIyMgUHJlcmVx" + - "dWlzaXRlcwoKQXNrIGZvciB0aGUgZXh0cmFjdGVkIGBudmNmLXNlbGYtbWFuYWdlZC1zdGFja2Ag" + - "cGF0aC4gRm9yIHNwbGl0IGluc3RhbGxhdGlvbiwKYWxzbyByZXF1aXJlIHRoZSBtYXRjaGluZy12" + - "ZXJzaW9uIGBudmNmLWNvbXB1dGUtcGxhbmUtc3RhY2tgIHBhdGguIFZlcmlmeSBib3RoOgoKYGBg" + - "YmFzaApscyA8Y29udHJvbC1wbGFuZS1zdGFjaz4vaGVsbWZpbGUuZC8gPGNvbnRyb2wtcGxhbmUt" + - "c3RhY2s+L2Vudmlyb25tZW50cy8gPGNvbnRyb2wtcGxhbmUtc3RhY2s+L3NlY3JldHMvIDxjb250" + - "cm9sLXBsYW5lLXN0YWNrPi9nbG9iYWwueWFtbC5nb3RtcGwKbHMgPGNvbXB1dGUtcGxhbmUtc3Rh" + - "Y2s+L2hlbG1maWxlLmQvIDxjb21wdXRlLXBsYW5lLXN0YWNrPi9lbnZpcm9ubWVudHMvIDxjb21w" + - "dXRlLXBsYW5lLXN0YWNrPi9nbG9iYWwueWFtbC5nb3RtcGwKYGBgCgpJZiBlaXRoZXIgZGlyZWN0" + - "b3J5IGlzIG1pc3NpbmcsIGRvd25sb2FkIG1hdGNoaW5nIGJ1bmRsZSB2ZXJzaW9ucyBmcm9tIE5H" + - "QzoKCmBgYGJhc2gKbmdjIHJlZ2lzdHJ5IHJlc291cmNlIGRvd25sb2FkLXZlcnNpb24gPG9yZz4v" + - "bnZjZi1zZWxmLW1hbmFnZWQtc3RhY2s6PHZlcnNpb24+Cm5nYyByZWdpc3RyeSByZXNvdXJjZSBk" + - "b3dubG9hZC12ZXJzaW9uIDxvcmc+L252Y2YtY29tcHV0ZS1wbGFuZS1zdGFjazo8dmVyc2lvbj4K" + - "YGBgCgpDb250cm9sLXBsYW5lIGNvbW1hbmRzIGJlbG93IGFzc3VtZSB0aGUgY29udHJvbC1wbGFu" + - "ZSBidW5kbGUgcm9vdC4gU3BsaXQtZmxvdwpjb21tYW5kcyBhbmQgcm9vdCBzdWJzdGl0dXRpb24g" + - "YXJlIGluCltTcGxpdCBDb21wdXRlLVBsYW5lIEluc3RhbGxhdGlvbl0ocmVmZXJlbmNlcy9jb21w" + - "dXRlLXBsYW5lLWluc3RhbGxhdGlvbi5tZCkuCgojIyBCZWZvcmUgWW91IFN0YXJ0CgpWZXJpZnkg" + - "dG9vbGluZyBhbmQgY29udGV4dCBiZWZvcmUgYW55IG9wZXJhdGlvbjoKCmBgYGJhc2gKaGVsbWZp" + - "bGUgLS12ZXJzaW9uICAgIyBNdXN0IGJlIDEuMS54ICgxLjIuMCByZW1vdmVkIHNlcXVlbnRpYWwg" + - "bW9kZSkKaGVsbSB2ZXJzaW9uICAgICAgICAgIyBNdXN0IGJlID49IDMuMTIKaGVsbSBwbHVnaW4g" + - "bGlzdCAgICAgIyBNdXN0IGluY2x1ZGUgaGVsbS1kaWZmID49IDMuMTEKa3ViZWN0bCB2ZXJzaW9u" + - "ICAgICAgIyBDbGllbnQgbXVzdCBiZSB3aXRoaW4gMSBtaW5vciB2ZXJzaW9uIG9mIGNsdXN0ZXIK" + - "YGBgCgpDb250cm9sLXBsYW5lIGNvbW1hbmRzIHJ1biBmcm9tIHRoZSBleHRyYWN0ZWQgYG52Y2Yt" + - "c2VsZi1tYW5hZ2VkLXN0YWNrL2Agcm9vdDoKCmBgYGJhc2gKY2QgcGF0aC90by9udmNmLXNlbGYt" + - "bWFuYWdlZC1zdGFjawpscyBoZWxtZmlsZS5kLyBlbnZpcm9ubWVudHMvIHNlY3JldHMvIGdsb2Jh" + - "bC55YW1sLmdvdG1wbApgYGAKCklkZW50aWZ5IHRoZSBlbnZpcm9ubWVudCBmcm9tIGBlbnZpcm9u" + - "bWVudHMvPG5hbWU+LnlhbWxgIGFuZApgc2VjcmV0cy88bmFtZT4tc2VjcmV0cy55YW1sYDsgZm9y" + - "IEVLUywgdXNlIHRoZSBjYW5vbmljYWwKW0NTUCBFbmQtdG8tRW5kIEV4YW1wbGVdKGh0dHBzOi8v" + - "ZG9jcy5udmlkaWEuY29tL252Y2YvdjAuNi4wLXJjL2NzcC1lbmQtdG8tZW5kLWV4YW1wbGUpLgoK" + - "IyMgSG93IFZhbHVlcyBGbG93CgpVbmRlcnN0YW5kaW5nIHZhbHVlIHByZWNlZGVuY2UgcHJldmVu" + - "dHMgdGhlIG1vc3QgY29tbW9uIGNvbmZpZ3VyYXRpb24gbWlzdGFrZXMuCgpgYGAKZW52aXJvbm1l" + - "bnRzL2Jhc2UueWFtbCAgICAgICAgICAoZGVmYXVsdHMpCiAgICAtPiBtZXJnZWQgd2l0aAplbnZp" + - "cm9ubWVudHMvPGVudj4ueWFtbCAgICAgICAgICh5b3VyIG92ZXJyaWRlcykKICAgIC0+IGNvbnN1" + - "bWVkIGJ5Cmdsb2JhbC55YW1sLmdvdG1wbCAgICAgICAgICAgICAgKEdvIHRlbXBsYXRlLCBjb25z" + - "dHJ1Y3RzIHBlci1jaGFydCB2YWx1ZXMpCiAgICAtPiBjb25zdW1lZCBieQpzZWNyZXRzLzxlbnY+" + - "LXNlY3JldHMueWFtbCAgICAgIChzZW5zaXRpdmUgdmFsdWVzKQogICAgLT4gb3ZlcnJpZGRlbiBi" + - "eQpyZWxlYXNlIGlubGluZSB2YWx1ZXM6IGJsb2NrcyAgIChoaWdoZXN0IHByZWNlZGVuY2UpCmBg" + - "YAoKQ3JpdGljYWw6IGBnbG9iYWwueWFtbC5nb3RtcGxgIG9ubHkgcGFzc2VzIHRocm91Z2ggc3Bl" + - "Y2lmaWMga2V5cyB0byBlYWNoIGNoYXJ0IChpbWFnZSByZWdpc3RyaWVzLCBub2RlIHNlbGVjdG9y" + - "cywgc3RvcmFnZSwgcmVwbGljYSBjb3VudHMpLiBTZXR0aW5nIGFuIGFyYml0cmFyeSBjaGFydCB2" + - "YWx1ZSBpbiB0aGUgZW52aXJvbm1lbnQgZmlsZSB3aWxsIGJlIHNpbGVudGx5IGlnbm9yZWQgaWYg" + - "YGdsb2JhbC55YW1sLmdvdG1wbGAgZG9lcyBub3QgcHJvcGFnYXRlIGl0LgoKVG8gb3ZlcnJpZGUg" + - "YXJiaXRyYXJ5IGNoYXJ0IHZhbHVlcywgdXNlIGEgaGVsbWZpbGUgcmVsZWFzZSBgdmFsdWVzOmAg" + - "YmxvY2suIFNlZSBbT3ZlcnJpZGluZyBIZWxtIENoYXJ0IFZhbHVlc10oI292ZXJyaWRpbmctaGVs" + - "bS1jaGFydC12YWx1ZXMpLgoKIyMgQ2xlYW4gSW5zdGFsbGF0aW9uCgojIyMgMS4gQ3JlYXRlIG5h" + - "bWVzcGFjZXMgYW5kIGltYWdlIHB1bGwgc2VjcmV0cyAoaWYgdXNpbmcgYSBwcml2YXRlIHJlZ2lz" + - "dHJ5KQoKYGBgYmFzaApmb3IgbnMgaW4gY2Fzc2FuZHJhLXN5c3RlbSBuYXRzLXN5c3RlbSBudmNm" + - "IGFwaS1rZXlzIGVzcyBzaXMgdmF1bHQtc3lzdGVtIGNlcnQtbWFuYWdlcjsgZG8KICBrdWJlY3Rs" + - "IGNyZWF0ZSBuYW1lc3BhY2UgIiRucyIgLS1kcnktcnVuPWNsaWVudCAtbyB5YW1sIHwga3ViZWN0" + - "bCBhcHBseSAtZiAtCmRvbmUKCiMgT25seSBpZiBwdWxsaW5nIGZyb20gYSBwcml2YXRlIHJlZ2lz" + - "dHJ5IChlLmcuLCBOR0MgbnZjci5pbykKZXhwb3J0IE5HQ19BUElfS0VZPSI8eW91ci1rZXk+Igpm" + - "b3IgbnMgaW4gY2Fzc2FuZHJhLXN5c3RlbSBuYXRzLXN5c3RlbSBudmNmIGFwaS1rZXlzIGVzcyBz" + - "aXMgdmF1bHQtc3lzdGVtIGNlcnQtbWFuYWdlcjsgZG8KICBrdWJlY3RsIGNyZWF0ZSBzZWNyZXQg" + - "ZG9ja2VyLXJlZ2lzdHJ5IG52Y3ItY3JlZHMgXAogICAgLS1kb2NrZXItc2VydmVyPW52Y3IuaW8g" + - "XAogICAgLS1kb2NrZXItdXNlcm5hbWU9JyRvYXV0aHRva2VuJyBcCiAgICAtLWRvY2tlci1wYXNz" + - "d29yZD0iJE5HQ19BUElfS0VZIiBcCiAgICAtLW5hbWVzcGFjZT0iJG5zIiBcCiAgICAtLWRyeS1y" + - "dW49Y2xpZW50IC1vIHlhbWwgfCBrdWJlY3RsIGFwcGx5IC1mIC0KZG9uZQpgYGAKCklmIHVzaW5n" + - "IHB1bGwgc2VjcmV0cywgeW91IG11c3QgYWxzbyBjb25maWd1cmUgZWFjaCBoZWxtZmlsZSByZWxl" + - "YXNlIHRvIHJlZmVyZW5jZSB0aGVtLiBTZWUgW0ltYWdlIFB1bGwgU2VjcmV0c10oI2ltYWdlLXB1" + - "bGwtc2VjcmV0cykuCgojIyMgMi4gQXV0aGVudGljYXRlIGhlbG0gdG8geW91ciBjaGFydCByZWdp" + - "c3RyeQoKQm90aCBgZG9ja2VyIGxvZ2luYCBBTkQgYGhlbG0gcmVnaXN0cnkgbG9naW5gIGFyZSBy" + - "ZXF1aXJlZCBmb3IgTkdDLiBIZWxtZmlsZSB1c2VzIGhlbG0gKG5vdCBkb2NrZXIpIHRvIHB1bGwg" + - "T0NJIGNoYXJ0cywgc28gdGhlIGhlbG0gY3JlZGVudGlhbCBzdG9yZSBtdXN0IGJlIGF1dGhlbnRp" + - "Y2F0ZWQgc2VwYXJhdGVseS4KCmBgYGJhc2gKIyBOR0MgLS0gYm90aCBjb21tYW5kcyBhcmUgcmVx" + - "dWlyZWQKZG9ja2VyIGxvZ2luIG52Y3IuaW8gLXUgJyRvYXV0aHRva2VuJyAtcCAiJE5HQ19BUElf" + - "S0VZIgpoZWxtIHJlZ2lzdHJ5IGxvZ2luIG52Y3IuaW8gLXUgJyRvYXV0aHRva2VuJyAtcCAiJE5H" + - "Q19BUElfS0VZIgoKIyBFQ1IKYXdzIGVjciBnZXQtbG9naW4tcGFzc3dvcmQgLS1yZWdpb24gPHJl" + - "Z2lvbj4gfCBcCiAgaGVsbSByZWdpc3RyeSBsb2dpbiAtLXVzZXJuYW1lIEFXUyAtLXBhc3N3b3Jk" + - "LXN0ZGluIDxhY2NvdW50Pi5ka3IuZWNyLjxyZWdpb24+LmFtYXpvbmF3cy5jb20KYGBgCgo+IE5v" + - "dGU6IGBoZWxtIHJlZ2lzdHJ5IGxvZ2luYCBrZWVwcyBvbmx5IHRoZSBsYXN0IGxvZ2luIHBlciBo" + - "b3N0IChtdWx0aS1vcmcgZ290Y2hhKS4KPiBUaGUgc3RhY2sgYW5kIHRoZSBjYWNoZXMgc3BhbiBz" + - "ZXZlcmFsIE5HQyBvcmdzIHRoYXQgbmVlZCBkaWZmZXJlbnQga2V5cywgYnV0IHRoZXkgYWxsCj4g" + - "bGl2ZSB1bmRlciB0aGUgb25lIGhvc3QgYG52Y3IuaW9gLiBBIHNlY29uZCBgaGVsbSByZWdpc3Ry" + - "eSBsb2dpbiBudmNyLmlvYCAob3IKPiBgZG9ja2VyIGxvZ2luYCkgd2l0aCBhIGRpZmZlcmVudCBr" + - "ZXkgc2lsZW50bHkgb3ZlcndyaXRlcyB0aGUgZmlyc3QsIHNvIHB1bGxzIGZvciB0aGUKPiBmaXJz" + - "dCBvcmcgdGhlbiBmYWlsIHdpdGggYSBtaXNsZWFkaW5nIGA0MDMgQWNjZXNzIERlbmllZGAgKG5v" + - "dCBhIDQwMTogdGhlIGF1dGgKPiBzdWNjZWVkZWQsIGl0J3MgdGhlIHdyb25nLW9yZyBrZXkpLiBJ" + - "ZiB5b3UgcHVsbCBjaGFydHMvaW1hZ2VzIGZyb20gbW9yZSB0aGFuIG9uZSBvcmcsCj4gZWl0aGVy" + - "IHJlLXJ1biB0aGUgbG9naW4gd2l0aCB0aGUgY29ycmVjdCBrZXkgaW1tZWRpYXRlbHkgYmVmb3Jl" + - "IGVhY2ggcHVsbCwgb3IgcGFzcwo+IGAtLXVzZXJuYW1lICckb2F1dGh0b2tlbicgLS1wYXNzd29y" + - "ZCA8a2V5PmAgcGVyIGBoZWxtIHB1bGxgIGludm9jYXRpb24gaW5zdGVhZCBvZiByZWx5aW5nCj4g" + - "b24gdGhlIHN0b3JlZCBsb2dpbi4gKFB1bGxpbmcgZXZlcnl0aGluZyBmcm9tIGEgc2luZ2xlIHJl" + - "Z2lzdHJ5IG1pcnJvciBhdm9pZHMgdGhpcwo+IGVudGlyZWx5LikKCiMjIyAyYi4gKFJlY29tbWVu" + - "ZGVkKSBQdWxsIGZyb20gYSByZWdpc3RyeSB0aGUgY2x1c3RlciBhdXRoZW50aWNhdGVzIHRvIGF1" + - "dG9tYXRpY2FsbHkKCklmIHlvdSBtaXJyb3IgdGhlIE5WQ0YgaW1hZ2VzIGludG8gYSByZWdpc3Ry" + - "eSB0aGF0IHRoZSBjbHVzdGVyIGNhbiBwdWxsIGZyb20gd2l0aG91dCBhbgpleHBsaWNpdCBpbWFn" + - "ZSBwdWxsIHNlY3JldCAoZm9yIGV4YW1wbGUsIGEgcmVnaXN0cnkgd2hlcmUgdGhlIG5vZGUgb3Ig" + - "d29ya2xvYWQgaWRlbnRpdHkgaXMKZ3JhbnRlZCBwdWxsIGFjY2VzcyBhdXRvbWF0aWNhbGx5KSwg" + - "cG9pbnQgdGhlIHN0YWNrIGF0IGl0IGFuZCBza2lwIHRoZSBjcmVkZW50aWFsIHN0ZXBzCmFib3Zl" + - "LgoKMS4gUG9pbnQgdGhlIHN0YWNrIGF0IHRoZSBtaXJyb3IgaW4gYGVudmlyb25tZW50cy88ZW52" + - "Pi55YW1sYDoKCiAgIGBgYHlhbWwKICAgZ2xvYmFsOgogICAgIGltYWdlOgogICAgICAgcmVnaXN0" + - "cnk6IDx5b3VyLXJlZ2lzdHJ5PiAgICAgICAgICAgICMgZS5nLiByZWdpc3RyeS5leGFtcGxlLmNv" + - "bQogICAgICAgcmVwb3NpdG9yeTogPG1pcnJvci1zdWItcGF0aD4KICAgICBoZWxtOgogICAgICAg" + - "c291cmNlczogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAjIG9ubHkgaWYgeW91IGFsc28g" + - "bWlycm9yZWQgdGhlIGhlbG0gY2hhcnRzCiAgICAgICAgIHJlZ2lzdHJ5OiA8eW91ci1yZWdpc3Ry" + - "eT4KICAgICAgICAgcmVwb3NpdG9yeTogPG1pcnJvci1zdWItcGF0aD4KICAgYGBgCgogICA+IFRo" + - "ZSBtYW5pZmVzdCBoYXMgYSBtaXggb2YgT0NJIGFuZCBub24tT0NJIGFydGlmYWN0cywgc28gY29u" + - "dmVydCBub24tT0NJIGNoYXJ0cyBiZWZvcmUKICAgPiBtaXJyb3JpbmcuIENvbnRhaW5lciBpbWFn" + - "ZXMgKGBudmNyLmlvLy4uLmApIGFyZSBhbHJlYWR5IE9DSSBhbmQgbWlycm9yIGFzLWlzLiBTb21l" + - "IEhlbG0KICAgPiBjaGFydHMsIHRob3VnaCwgYXJlIHB1Ymxpc2hlZCB0byBhbiBgaHR0cHM6Ly9g" + - "IEhlbG0gcmVwb3NpdG9yeSAoZm9yIGV4YW1wbGUKICAgPiBgaGVsbS5uZ2MubnZpZGlhLmNvbWAp" + - "LiBUaG9zZSBhcmUgbm90IE9DSSBhbmQgY2Fubm90IGJlIHJlc29sdmVkIGJ5IGBnbG9iYWwuaGVs" + - "bS5zb3VyY2VzYAogICA+IChPQ0kpIG9yIG1pcnJvcmVkIGRpcmVjdGx5LiBCZWZvcmUgcG9pbnRp" + - "bmcgdGhlIHN0YWNrIGF0IHlvdXIgbWlycm9yLCBjb252ZXJ0IGVhY2gKICAgPiBgaHR0cHM6Ly9g" + - "IGNoYXJ0IHRvIE9DSTogYGhlbG0gcmVwbyBhZGRgL2BoZWxtIHB1bGxgIHRoZSBgLnRnemAsIHRo" + - "ZW4KICAgPiBgaGVsbSBwdXNoIDxjaGFydD4udGd6IG9jaTovLzx5b3VyLXJlZ2lzdHJ5Pi88bWly" + - "cm9yLXN1Yi1wYXRoPmAuIE9ubHkgT0NJIGNoYXJ0cyBjYW4gbGl2ZQogICA+IHVuZGVyIGBnbG9i" + - "YWwuaGVsbS5zb3VyY2VzYC4KCjIuIFNraXAgdGhlIGNyZWRlbnRpYWwgc3RlcHMgYWJvdmUuIFdo" + - "ZW4gdGhlIGNsdXN0ZXIgYXV0aGVudGljYXRlcyB0byB0aGUgcmVnaXN0cnkKICAgYXV0b21hdGlj" + - "YWxseSAodGhlIG5vZGUgb3Igd29ya2xvYWQgaWRlbnRpdHkgaGFzIHB1bGwgYWNjZXNzKSwgdGhl" + - "IHB1bGwgbmVlZHMgbm8KICAgS3ViZXJuZXRlcyBzZWNyZXQsIHNvIHlvdSBkbyBub3QgbmVlZDog" + - "dGhlIHBlci1uYW1lc3BhY2UgYG52Y3ItY3JlZHNgIGZyb20gc3RlcCAxCiAgIChzdGlsbCBjcmVh" + - "dGUgdGhlIG5hbWVzcGFjZXMsIGp1c3Qgbm90IHRoZSBzZWNyZXQpLCB0aGUgYGdsb2JhbC5pbWFn" + - "ZVB1bGxTZWNyZXRzYCBlbnRyeSwKICAgb3IgdGhlIGBkb2NrZXIgbG9naW5gL2BoZWxtIHJlZ2lz" + - "dHJ5IGxvZ2luIG52Y3IuaW9gIGZyb20gc3RlcCAyLgoKICAgPiBPbmUgcmVzaWR1YWwgY3JlZGVu" + - "dGlhbDogbnZjZi1hcGkgc3RpbGwgdmFsaWRhdGVzIHRoZSB1c2VyIGZ1bmN0aW9uIGltYWdlIGF0" + - "CiAgID4gYGZ1bmN0aW9uIGNyZWF0ZWAgdmlhIHRoZSBhY2NvdW50IHJlZ2lzdHJ5IGNyZWRlbnRp" + - "YWwsIHNvIHRoYXQgY3JlZGVudGlhbCBtdXN0IHBvaW50IGF0CiAgID4gd2hpY2hldmVyIHJlZ2lz" + - "dHJ5IGhvbGRzIHRoZSB1c2VyIGltYWdlIChzZXQgaXQgdG8geW91ciBtaXJyb3IgaWYgdGhlIGlt" + - "YWdlIGlzIG1pcnJvcmVkCiAgID4gdGhlcmUpLgoKIyMjIDMuIFNldCB0aGUgcm91dGUgZG9tYWlu" + - "CgpgZ2xvYmFsLmRvbWFpbmAgc2V0cyB0aGUgaG9zdG5hbWUgc3VmZml4IGZvciByb3V0ZXMgc3Vj" + - "aCBhcyBgYXBpLjxkb21haW4+YC4gSXQgZG9lcyBub3QgY29uZmlndXJlIHRoZSBHYXRld2F5IG9y" + - "IGl0cyBsb2FkIGJhbGFuY2VyLiBRdWVyeSB0aGUgZXhhY3QgZXhpc3RpbmcgR2F0ZXdheToKCmBg" + - "YGJhc2gKR0FURVdBWV9BRERSRVNTPSQoa3ViZWN0bCBnZXQgZ2F0ZXdheSA8Z2F0ZXdheS1uYW1l" + - "PiAtbiA8Z2F0ZXdheS1uYW1lc3BhY2U+IC1vIGpzb25wYXRoPSd7LnN0YXR1cy5hZGRyZXNzZXNb" + - "MF0udmFsdWV9JykKdGVzdCAtbiAiJEdBVEVXQVlfQUREUkVTUyIKYGBgCgpUaGUgYWRkcmVzcyBt" + - "YXkgYmUgYSBob3N0bmFtZSBvciBJUC4gQ2xvdWQgcHJvdmlkZXIgYW5kIEdhdGV3YXkgY29uZmln" + - "dXJhdGlvbiBkZXRlcm1pbmUgdGhlIGxvYWQgYmFsYW5jZXIgdHlwZSBhbmQgYWRkcmVzcyBmb3Jt" + - "YXQuIFRoZSBzZWxmLW1hbmFnZWQgc3RhY2sgZG9lcyBub3Qgc2VsZWN0IGVpdGhlci4KCkZvciB0" + - "ZW1wb3JhcnkgdGVzdGluZyB3aXRob3V0IEROUywgdXNlIGEgc3RhYmxlIHJlc2VydmVkIHN1ZmZp" + - "eCBzdWNoIGFzIGBnbG9iYWwuZG9tYWluOiAibnZjZi50ZXN0ImAsIGNvbm5lY3QgdG8gYEdBVEVX" + - "QVlfQUREUkVTU2AsIGFuZCBzZW5kIGBIb3N0OiBhcGkubnZjZi50ZXN0YC4gRm9yIHByb2R1Y3Rp" + - "b24sIHVzZSB5b3VyIGJhc2UgRE5TIGRvbWFpbiBhbmQgcG9pbnQgaXRzIHJvdXRlIHJlY29yZHMg" + - "dG8gYEdBVEVXQVlfQUREUkVTU2AuIElmIHRoZSBlbmRwb2ludCBsYXRlciBjaGFuZ2VzLCBrZWVw" + - "IGBnbG9iYWwuZG9tYWluYCBzdGFibGUgYW5kIHVwZGF0ZSBvbmx5IEROUyBvciB0aGUgY2xpZW50" + - "IGRlc3RpbmF0aW9uLiBTZWUgRXhhbXBsZSA0IGluIFtleGFtcGxlcy5tZF0oZXhhbXBsZXMubWQp" + - "LgoKIyMjIDQuIFByZXZpZXcgYW5kIGRlcGxveQoKYGBgYmFzaApIRUxNRklMRV9FTlY9PGVudi1u" + - "YW1lPiBoZWxtZmlsZSB0ZW1wbGF0ZSAgICMgUHJldmlldyByZW5kZXJlZCBtYW5pZmVzdHMKSEVM" + - "TUZJTEVfRU5WPTxlbnYtbmFtZT4gaGVsbWZpbGUgc3luYyAgICAgICAjIERlcGxveQpgYGAKCj4g" + - "U2V0IEJPVEggQ2Fzc2FuZHJhIHBhc3N3b3JkcyBpbiB0aGUgc2VjcmV0cyBmaWxlLiBUaGUgc2Vj" + - "cmV0cyBmaWxlIGRvY3VtZW50cwo+IGBERUZBVUxUX0NBU1NBTkRSQV9QQVNTV09SRGAsIGJ1dCB0" + - "aGUgY2Fzc2FuZHJhIGNoYXJ0IGhhcyBhIHNlY29uZCBjcmVkZW50aWFsLAo+IGBjYXNzYW5kcmEu" + - "c2VydmljZVJvbGVQYXNzd29yZGAsIHRoYXQgZGVmYXVsdHMgdG8gYGNoQG5nM20zYC4gSWYgeW91" + - "IHNldCBvbmx5Cj4gYERFRkFVTFRfQ0FTU0FORFJBX1BBU1NXT1JEYCwgdGhlIHNlcnZpY2Ugcm9s" + - "ZSBrZWVwcyB0aGF0IGRlZmF1bHQgYW5kIGV2ZXJ5IERCLWJhY2tlZAo+IHNlcnZpY2UgY3Jhc2gt" + - "bG9vcHMgd2l0aCBgQmFkIGNyZWRlbnRpYWxzYCBvbmNlIGl0IHRyaWVzIHRvIGF1dGhlbnRpY2F0" + - "ZS4gU2V0Cj4gYGNhc3NhbmRyYS5zZXJ2aWNlUm9sZVBhc3N3b3JkYCB0byB0aGUgc2FtZSB2YWx1" + - "ZSBhcyBgREVGQVVMVF9DQVNTQU5EUkFfUEFTU1dPUkRgLgoKIyMjIDUuIERlcGxveW1lbnQgcGhh" + - "c2VzCgpIZWxtZmlsZSBkZXBsb3lzIGluIG9yZGVyIHdpdGggZGVwZW5kZW5jaWVzOgoKfCBQaGFz" + - "ZSB8IFNlbGVjdG9yIHwgU2VydmljZXMgfCBXYWl0IHRpbWUgfAp8LS0tLS0tLXwtLS0tLS0tLS0t" + - "fC0tLS0tLS0tLS18LS0tLS0tLS0tLS18CnwgMSB8IGByZWxlYXNlLWdyb3VwPWRlcGVuZGVuY2ll" + - "c2AgfCBOQVRTLCBPcGVuQmFvLCBDYXNzYW5kcmEgfCA1LTEwIG1pbiB8CnwgMiB8IGByZWxlYXNl" + - "LWdyb3VwPXNlcnZpY2VzYCB8IEFQSSwgU0lTLCBFU1MsIGludm9jYXRpb24sIGdycGMtcHJveHks" + - "IG5vdGFyeSwgYXBpLWtleXMsIG9wdGlvbmFsIExMTSBnYXRld2F5L3JvdXRlciwgb3B0aW9uYWwg" + - "VmFuaXR5IEdhdGV3YXksIE5WQ0YgVUkgd2hlbiB0aGUgc3RhY2sgcGFja2FnZSBpbmNsdWRlcyB0" + - "aGUgYWRkb24gfCA1LTEwIG1pbiB8CnwgMyB8IGByZWxlYXNlLWdyb3VwPWluZ3Jlc3NgIHwgR2F0" + - "ZXdheSByb3V0ZXMgfCAxLTIgbWluIHwKfCA0IHwgYHJlbGVhc2UtZ3JvdXA9b2JzZXJ2YWJpbGl0" + - "eWAgfCBPYnNlcnZhYmlsaXR5IHN0YWNrIChpZiBlbmFibGVkKSB8IDEtMiBtaW4gfAoKTW9uaXRv" + - "ciBpbiBhIHNlcGFyYXRlIHRlcm1pbmFsOgoKYGBgYmFzaAprdWJlY3RsIGdldCBwb2RzIC1BIC13" + - "CmBgYAoKIyMjIDYuIEVuYWJsZSBWYW5pdHkgR2F0ZXdheSAob3B0aW9uYWwpCgpWYW5pdHkgR2F0" + - "ZXdheSBpcyBkaXNhYmxlZCBieSBkZWZhdWx0IGFuZCBpcyBvbmx5IG5lZWRlZCBmb3IgY3VzdG9t" + - "ZXItZmFjaW5nCmhvc3RuYW1lcyBvciBwYXRoIG1hcHBpbmdzIGluIGZyb250IG9mIHRoZSBzdGFu" + - "ZGFyZCBOVkNGIEFQSSBhbmQgaW52b2NhdGlvbgpyb3V0ZXMuIEl0IGlzIGF2YWlsYWJsZSBvbmx5" + - "IGluIHN0YWNrIHBhY2thZ2VzIHRoYXQgaW5jbHVkZSB0aGUgVmFuaXR5IEdhdGV3YXkKYWRkb24u" + - "IElmIHRoZSBleHRyYWN0ZWQgc3RhY2sgcGFja2FnZSBkb2VzIG5vdCBjb250YWluIGEgYHZhbml0" + - "eS1nYXRld2F5YApyZWxlYXNlIGFuZCBgdmFuaXR5R2F0ZXdheWAgcm91dGUgdmFsdWVzLCBza2lw" + - "IHRoZXNlIGNvbW1hbmRzIGFuZCB1c2UgYSBuZXdlcgpzdGFjayBwYWNrYWdlIHRoYXQgaW5jbHVk" + - "ZXMgdGhlbS4KCklmIHRoZSBzdGFjayBwYWNrYWdlIGluY2x1ZGVzIHRoZSBhZGRvbiwgZW5hYmxl" + - "IGl0IGluCmBlbnZpcm9ubWVudHMvPGVudi1uYW1lPi55YW1sYDoKCmBgYHlhbWwKYWRkb25zOgog" + - "IHZhbml0eUdhdGV3YXk6CiAgICBlbmFibGVkOiB0cnVlCiAgICBtYXBwaW5nQ29uZmlnOiB7fQpg" + - "YGAKClRoZSBkZWZhdWx0IHJvdXRlIGhvc3QgaXMgYHZhbml0eS48ZG9tYWluPmAgYW5kIHRoZSBi" + - "YWNrZW5kIGlzCmB2YW5pdHktZ2F0ZXdheS5udmNmOjgwODBgLiBQdXQgZGVwbG95bWVudC1zcGVj" + - "aWZpYyBob3N0IGFuZCBwYXRoIG1hcHBpbmdzIHVuZGVyCmBhZGRvbnMudmFuaXR5R2F0ZXdheS5t" + - "YXBwaW5nQ29uZmlnYC4gSWYgeW91IG5lZWQgY3VzdG9tIHZhbml0eSBob3N0cyBpbnN0ZWFkIG9m" + - "CmB2YW5pdHkuPGRvbWFpbj5gLCB1c2UgdGhlIHJvdXRlIGhvc3RuYW1lIG92ZXJyaWRlcyBzdXBw" + - "b3J0ZWQgYnkgdGhlIHN0YWNrCnBhY2thZ2UgYW5kIGNyZWF0ZSBtYXRjaGluZyBETlMgcmVjb3Jk" + - "cy4KCkFmdGVyIGNvbmZpcm1pbmcgdGhlIHBhY2thZ2UgaW5jbHVkZXMgdGhlIGB2YW5pdHktZ2F0" + - "ZXdheWAgcmVsZWFzZSwgcHJldmlldyBhbmQKYXBwbHkgdGhlIHNlcnZpY2UgYW5kIHJvdXRlOgoK" + - "YGBgYmFzaApIRUxNRklMRV9FTlY9PGVudi1uYW1lPiBoZWxtZmlsZSAtLXNlbGVjdG9yIG5hbWU9" + - "dmFuaXR5LWdhdGV3YXkgdGVtcGxhdGUKSEVMTUZJTEVfRU5WPTxlbnYtbmFtZT4gaGVsbWZpbGUg" + - "LS1zZWxlY3RvciBuYW1lPXZhbml0eS1nYXRld2F5IHN5bmMKSEVMTUZJTEVfRU5WPTxlbnYtbmFt" + - "ZT4gaGVsbWZpbGUgLS1zZWxlY3RvciByZWxlYXNlLWdyb3VwPWluZ3Jlc3Mgc3luYwpgYGAKClZl" + - "cmlmeSB0aGUgcm91dGUgb25seSB3aGVuIHRoZSBhZGRvbiBpcyBwcmVzZW50IGFuZCBlbmFibGVk" + - "OgoKYGBgYmFzaAprdWJlY3RsIGdldCBkZXBsb3ksc3ZjIC1uIG52Y2YgLWwgYXBwLmt1YmVybmV0" + - "ZXMuaW8vbmFtZT12YW5pdHktZ2F0ZXdheQprdWJlY3RsIGdldCBodHRwcm91dGUgLUEgfCBncmVw" + - "IC1pIHZhbml0eQpjdXJsIC1IICJIb3N0OiB2YW5pdHkuPGRvbWFpbj4iICJodHRwOi8vPGdhdGV3" + - "YXktYWRkcmVzcz4vaGVhbHRoIgpgYGAKCkRvIG5vdCBlbmFibGUgVmFuaXR5IEdhdGV3YXkgZm9y" + - "IHN0YW5kYXJkIEFQSSwgQVBJIEtleXMsIGludm9jYXRpb24sIExMTQppbnZvY2F0aW9uLCBvciBn" + - "UlBDIHRyYWZmaWMuIFRob3NlIHJvdXRlcyBhcmUgcHJvdmlkZWQgYnkgdGhlIGJhc2UgZ2F0ZXdh" + - "eQpyb3V0ZXMuCgojIyMgNy4gRW5hYmxlIE5WQ0YgVUkgKG9wdGlvbmFsKQoKTlZDRiBVSSBpcyBh" + - "biBvcHRpb25hbCwgY3VzdG9tZXItZmFjaW5nIGFkbWluLXBhbmVsIFVJLiBJdCBpcyBkaXNhYmxl" + - "ZCBieQpkZWZhdWx0IGFuZCBhdmFpbGFibGUgb25seSBpbiBzdGFjayBwYWNrYWdlcyB0aGF0IGlu" + - "Y2x1ZGUgdGhlIE5WQ0YgVUkgYWRkb24uIElmCnlvdXIgZXh0cmFjdGVkIHN0YWNrIHBhY2thZ2Ug" + - "ZG9lcyBub3QgY29udGFpbiBhIGBudmNmLXVpYCByZWxlYXNlIGFuZCBgbnZjZlVpYApyb3V0ZSB2" + - "YWx1ZXMsIHNraXAgdGhpcyBzZWN0aW9uLiBUaGUgTlZDRiBVSSBhZG1pbiBwYW5lbCBpcyBjdXJy" + - "ZW50bHkKdW5hdXRoZW50aWNhdGVkOyBkbyBub3QgZXhwb3NlIGl0IHRvIHRoZSBwdWJsaWMgaW50" + - "ZXJuZXQuCgpGb3IgZW5hYmxlbWVudCwgbmFtZXNwYWNlIGFuZCBwdWxsIHNlY3JldCBzZXR1cCwg" + - "YXBwbHksIGFuZCB2ZXJpZmljYXRpb24gc3RlcHMsCnNlZSBbTlZDRiBVSSBBZGRvbl0ocmVmZXJl" + - "bmNlcy9udmNmLXVpLWFkZG9uLm1kKS4KCiMjIyA4LiBJbnN0YWxsIHRoZSBzZXBhcmF0ZSBjb21w" + - "dXRlLXBsYW5lIHN0YWNrCgpUaGUgY29udHJvbC1wbGFuZSBzdGFjayBkb2VzIG5vdCBpbnN0YWxs" + - "IGNvbXB1dGUtcGxhbmUgY29tcG9uZW50cy4gQWZ0ZXIgaXQgaXMgaGVhbHRoeSwgY2hvb3NlIGV4" + - "YWN0bHkgb25lIGNvbXB1dGUtcGxhbmUgaGFuZG9mZjoKCi0gSGVsbWZpbGUgdmFsdWVzIGZsb3c6" + - "IGF1dGhvciBzZXBhcmF0ZSBlbnZpcm9ubWVudCBmaWxlcywgdGhlbiByZWdpc3RlciBhbmQKICBp" + - "bnN0YWxsIHdpdGggdGhlIGNvbXB1dGUtcGxhbmUgTWFrZWZpbGUuCi0gQ0xJIHByb2ZpbGUgZmxv" + - "dzogdXNlIHRoZSBwcm9maWxlIGdlbmVyYXRlZCBieSB0aGUgQ0xJIGNvbnRyb2wtcGxhbmUgaW5z" + - "dGFsbCwKICB0aGVuIHJ1biB0aGUgY29tcGxldGUgQ0xJIHJlZ2lzdGVyIGFuZCBpbnN0YWxsIGNv" + - "bW1hbmRzLgoKRG8gbm90IG1peCB0aGVzZSBoYW5kb2Zmcy4gRm9sbG93IFtTcGxpdCBDb21wdXRl" + - "LVBsYW5lIEluc3RhbGxhdGlvbl0ocmVmZXJlbmNlcy9jb21wdXRlLXBsYW5lLWluc3RhbGxhdGlv" + - "bi5tZCkKZm9yIGNvbW1hbmRzLCBFS1Mgcm91dGluZywgcHVsbCBzZWNyZXRzLCB2ZXJpZmljYXRp" + - "b24sIGFuZCB0ZWFyZG93biBvcmRlci4KCiMjIENsZWFuIFRlYXJkb3duCgpEZXN0cm95IGV2ZXJ5" + - "IGNvbXB1dGUgcGxhbmUgYmVmb3JlIHRoZSBjb250cm9sIHBsYW5lLCB1c2luZyB0aGUgdGVhcmRv" + - "d24gZm9yCnRoZSBzYW1lIGhhbmRvZmY7IHNlZSBbU3BsaXQgQ29tcHV0ZS1QbGFuZSBJbnN0YWxs" + - "YXRpb25dKHJlZmVyZW5jZXMvY29tcHV0ZS1wbGFuZS1pbnN0YWxsYXRpb24ubWQjdGVhcmRvd24p" + - "LgoKU2NvcGU6IE9ubHkgZGVzdHJveSByZWxlYXNlcyBtYW5hZ2VkIGJ5IHRoaXMgY29udHJvbC1w" + - "bGFuZSBoZWxtZmlsZSBzdGFjay4gVGhlIE5WQ0YgcmVsZWFzZXMgYXJlOiBgbmF0c2AsIGBvcGVu" + - "YmFvLXNlcnZlcmAsIGBjYXNzYW5kcmFgLCBgYXBpLWtleXNgLCBgc2lzYCwgYGFwaWAsIGBpbnZv" + - "Y2F0aW9uLXNlcnZpY2VgLCBgZ3JwYy1wcm94eWAsIGBlc3MtYXBpYCwgYG5vdGFyeS1zZXJ2aWNl" + - "YCwgb3B0aW9uYWwgYHZhbml0eS1nYXRld2F5YCwgYG52Y2YtdWlgLCBgYWRtaW4taXNzdWVyLXBy" + - "b3h5YCwgYW5kIGBpbmdyZXNzYDsgYGNlcnQtbWFuYWdlcmAgaXMgaW5jbHVkZWQgb25seSB3aGVu" + - "IGBjZXJ0TWFuYWdlci5lbmFibGVkOiB0cnVlYC4gVGhlIGNvbnRyb2wtcGxhbmUgbmFtZXNwYWNl" + - "IGludmVudG9yeSBhbHNvIGluY2x1ZGVzIGBjZXJ0LW1hbmFnZXJgLCBidXQgZGVmYXVsdCBuYW1l" + - "c3BhY2UgY2xlYW51cCBwcmVzZXJ2ZXMgaXQuIE5hbWVzcGFjZSBwcmVzZXJ2YXRpb24gZG9lcyBu" + - "b3QgcHJlc2VydmUgdGhlIEhlbG0gcmVsZWFzZS4gRXh0ZXJuYWwgY2VydC1tYW5hZ2VyIG11c3Qg" + - "dXNlIGBjZXJ0TWFuYWdlci5lbmFibGVkOiBmYWxzZWA7IG90aGVyd2lzZSBIZWxtZmlsZSB0cmVh" + - "dHMgdGhlIHJlbGVhc2UgYXMgc3RhY2stbWFuYWdlZC4gRG8gbm90IGRlbGV0ZSBvdGhlciBoZWxt" + - "IHJlbGVhc2VzIG9yIG5hbWVzcGFjZXMgb24gdGhlIGNsdXN0ZXIuCgpCZWZvcmUgY29udHJvbC1w" + - "bGFuZSBkZXN0cm95LCBpZGVudGlmeSB3aGV0aGVyIGNlcnQtbWFuYWdlciBpcyBleHRlcm5hbC4g" + - "Rm9yIGFuIGV4dGVybmFsIGluc3RhbGxhdGlvbiwgcmVxdWlyZSBlZmZlY3RpdmUgYGNlcnRNYW5h" + - "Z2VyLmVuYWJsZWQ6IGZhbHNlYCBhbmQgYWJvcnQgaWYgaXQgaXMgdHJ1ZS4gRm9yIGFuIGludGVu" + - "ZGVkIHN0YWNrLW1hbmFnZWQgcmVsZWFzZSB3aXRoIGVmZmVjdGl2ZSBgY2VydE1hbmFnZXIuZW5h" + - "YmxlZDogdHJ1ZWAsIHZlcmlmeSBtYXRjaGluZyBzdGFjayBIZWxtIHJlbGVhc2UgbWV0YWRhdGEg" + - "YW5kIGFib3J0IG9uIG1pc3Npbmcgb3IgbWlzbWF0Y2hlZCBldmlkZW5jZS4gUHJlc2VydmUgdGhl" + - "IG5hbWVzcGFjZSBieSBkZWZhdWx0OyBvbmx5IHBsYW4gaXRzIHJlbW92YWwgYWZ0ZXIgdmVyaWZ5" + - "aW5nIG5hbWVzcGFjZSBwcm92ZW5hbmNlIGFuZCBnZXR0aW5nIGV4cGxpY2l0IGNvbmZpcm1hdGlv" + - "bi4KCiMjIyBTdGFuZGFyZCB0ZWFyZG93bgoKUnVuIGZyb20gaW5zaWRlIHRoZSBgbnZjZi1zZWxm" + - "LW1hbmFnZWQtc3RhY2svYCBkaXJlY3Rvcnk6CgpgYGBiYXNoCkhFTE1GSUxFX0VOVj08ZW52LW5h" + - "bWU+IGhlbG1maWxlIGRlc3Ryb3kKYGBgCgojIyMgRGVsZXRlIG5hbWVzcGFjZXMKCmBgYGJhc2gK" + - "Zm9yIG5zIGluIGNhc3NhbmRyYS1zeXN0ZW0gbmF0cy1zeXN0ZW0gbnZjZiBhcGkta2V5cyBlc3Mg" + - "c2lzIG52Y2YtdWkgdmF1bHQtc3lzdGVtOyBkbwogIGt1YmVjdGwgZGVsZXRlIG5hbWVzcGFjZSAi" + - "JG5zIiAtLWlnbm9yZS1ub3QtZm91bmQKZG9uZQpgYGAKCiMjIyBWZXJpZnkgY2xlYW4KCmBgYGJh" + - "c2gKa3ViZWN0bCBnZXQgbnMgfCBncmVwIC1FICcoY2Fzc2FuZHJhfG5hdHN8dmF1bHR8bnZjZnxh" + - "cGkta2V5c3xlc3N8c2lzKScKIyBTaG91bGQgcmV0dXJuIGVtcHR5CmBgYAoKIyMgT3ZlcnJpZGlu" + - "ZyBIZWxtIENoYXJ0IFZhbHVlcwoKIyMjIEVudmlyb25tZW50IGZpbGUgKGxpbWl0ZWQpCgpXb3Jr" + - "cyBvbmx5IGZvciBrZXlzIHRoYXQgYGdsb2JhbC55YW1sLmdvdG1wbGAgcHJvcGFnYXRlcyAoZS5n" + - "LiwgYGNhc3NhbmRyYS5yZXBsaWNhQ291bnRgLCBgZ2xvYmFsLnN0b3JhZ2VDbGFzc2AsIGBnbG9i" + - "YWwuaW1hZ2VgKS4KCiMjIyBSZWxlYXNlIHZhbHVlcyBibG9jayAoYW55IGNoYXJ0IHZhbHVlKQoK" + - "RWRpdCB0aGUgcmVsZWFzZSBpbiBgaGVsbWZpbGUuZC8qLnlhbWwuZ290bXBsYCBhbmQgYWRkIGEg" + - "YHZhbHVlczpgIGJsb2NrLiBJbiB0aGUgZXhhbXBsZXMgYmVsb3csIGA8cHJpdmF0ZS12YWx1ZXM+" + - "YCByZWZlcnMgdG8gdGhlIGBzZWNyZXRzL2AgZGlyZWN0b3J5IGF0IHRoZSBoZWxtZmlsZSBzdGFj" + - "ayByb290LgoKYGBgeWFtbAotIG5hbWU6IGNhc3NhbmRyYQogIHZlcnNpb246IDAuOC4wCiAgY29u" + - "ZGl0aW9uOiBjYXNzYW5kcmEuZW5hYmxlZAogIG5hbWVzcGFjZTogY2Fzc2FuZHJhLXN5c3RlbQog" + - "IDw8OiAqZGVwZW5kZW5jeQogIHZhbHVlczoKICAgIC0gLi4vZ2xvYmFsLnlhbWwuZ290bXBsCiAg" + - "ICAtIC4uLzxwcml2YXRlLXZhbHVlcz4ve3sgcmVxdWlyZWRFbnYgIkhFTE1GSUxFX0VOViIgfX0t" + - "c2VjcmV0cy55YW1sCiAgICAtIGNhc3NhbmRyYToKICAgICAgICByZXNvdXJjZXM6CiAgICAgICAg" + - "ICBsaW1pdHM6CiAgICAgICAgICAgIGNwdTogIjgiCiAgICAgICAgICAgIG1lbW9yeTogODE5Mk1p" + - "CiAgICAgICAgICByZXF1ZXN0czoKICAgICAgICAgICAgY3B1OiAiMiIKICAgICAgICAgICAgbWVt" + - "b3J5OiA0MDk2TWkKYGBgCgpZQU1MIG1lcmdlIGdvdGNoYTogV2hlbiBhIHJlbGVhc2UgdXNlcyBg" + - "PDw6ICpkZXBlbmRlbmN5YCBvciBgaW5oZXJpdGAsIHNwZWNpZnlpbmcgYHZhbHVlczpgIHJlcGxh" + - "Y2VzIHRoZSB0ZW1wbGF0ZSdzIHZhbHVlcyBsaXN0LiBZb3UgbXVzdCByZS1pbmNsdWRlIGBnbG9i" + - "YWwueWFtbC5nb3RtcGxgIGFuZCB0aGUgc2VjcmV0cyBmaWxlLgoKIyMjIFByZXZpZXcgYW5kIGFw" + - "cGx5IGEgc2luZ2xlIHJlbGVhc2UKCmBgYGJhc2gKSEVMTUZJTEVfRU5WPTxlbnY+IGhlbG1maWxl" + - "IC0tc2VsZWN0b3IgbmFtZT1jYXNzYW5kcmEgdGVtcGxhdGUgICMgUHJldmlldwpIRUxNRklMRV9F" + - "TlY9PGVudj4gaGVsbWZpbGUgLS1zZWxlY3RvciBuYW1lPWNhc3NhbmRyYSBzeW5jICAgICAgIyBB" + - "cHBseQpgYGAKCiMjIEltYWdlIFB1bGwgU2VjcmV0cwoKVGhlcmUgYXJlIHRocmVlIGRpc3RpbmN0" + - "IGNyZWRlbnRpYWwgdHlwZXMuIERvIG5vdCBjb25mbGF0ZSB0aGVtLCBhbmQgbWluZCB0aGUKZm9y" + - "bWF0IHJ1bGUgYmVsb3cgKHR3byBvZiB0aGVtIGZhaWwgZXZlbiB3aXRoIHRoZSBjb3JyZWN0IGtl" + - "eSBpZiB0aGUgZm9ybWF0IGlzIHdyb25nKToKCnwgfCBDb250cm9sIFBsYW5lIFB1bGwgU2VjcmV0" + - "cyB8IEFQSSBCb290c3RyYXAgUmVnaXN0cnkgQ3JlZHMgfCBTaWRlY2FyIEltYWdlLVB1bGwgU2Vj" + - "cmV0IHwKfC0tLXwtLS18LS0tfC0tLXwKfCBQdXJwb3NlIHwgSzhzIHB1bGxzIE5WQ0Ygc2Vydmlj" + - "ZSBpbWFnZXMgfCBudmNmLWFwaSB2YWxpZGF0ZXMgdGhlIHVzZXIgZnVuY3Rpb24gaW1hZ2UgYXQg" + - "YGZ1bmN0aW9uIGNyZWF0ZWAgfCBudmNmLWFwaSBwdWxscyB0aGUgcGxhdGZvcm0gc2lkZWNhcnMg" + - "aW5qZWN0ZWQgaW50byBldmVyeSB3b3JrZXIgcG9kIHwKfCBXaGVyZSB8IEs4cyBgZG9ja2VyLXJl" + - "Z2lzdHJ5YCBTZWNyZXRzICsgS3l2ZXJubyBDbHVzdGVyUG9saWN5IHwgYDxwcml2YXRlLXZhbHVl" + - "cz4vPGVudj4tc2VjcmV0cy55YW1sYCAoYWNjb3VudC1ib290c3RyYXApIHwgYE5WQ0ZfQVBJX1NJ" + - "REVDQVJTX0lNQUdFX1BVTExfU0VDUkVUYCBpbiBgPGVudj4tc2VjcmV0cy55YW1sYCAtPiBPcGVu" + - "QmFvIGBzZXJ2aWNlcy9udmNmLWFwaS9rdi9zaWRlY2Fycy9pbWFnZS1wdWxsLXNlY3JldGAgKGZp" + - "ZWxkIGBzZWNyZXRgKSB8CnwgRm9ybWF0IHwgc3RhbmRhcmQgYC5kb2NrZXJjb25maWdqc29uYCAo" + - "a3ViZWN0bCBidWlsZHMgaXQgZm9yIHlvdSkgfCBgYmFzZTY0KCIkb2F1dGh0b2tlbjo8a2V5PiIp" + - "YCB8IGBiYXNlNjQoIiRvYXV0aHRva2VuOjxrZXk+IilgIHwKCj4gTm90ZTogdGhlIGFjY291bnQt" + - "Ym9vdHN0cmFwIGNyZWQgYW5kIHRoZSBzaWRlY2FyIHNlY3JldCBhcmUgTk9UIGEKPiBkb2NrZXJj" + - "b25maWdqc29uLiBUaGUgc2VjcmV0cyB0ZW1wbGF0ZSBzaGlwcyB0aGUgcGxhY2Vob2xkZXIKPiBg" + - "UkVQTEFDRV9XSVRIX0JBU0U2NF9ET0NLRVJfQ1JFREVOVElBTGAsIHdoaWNoIHJlYWRzIGFzICJi" + - "YXNlNjQgb2YgYSBkb2NrZXJjb25maWdqc29uLiIKPiBJdCBpc24ndC4gQm90aCB2YWx1ZXMgYXJl" + - "IGNvbnN1bWVkIGFzIGEgcmF3IGRvY2tlciBgYXV0aGAgc3RyaW5nOiBudmNmLWFwaSB0YWtlcyB0" + - "aGUKPiB2YWx1ZSB2ZXJiYXRpbSBhbmQgZHJvcHMgaXQgaW50byB0aGUgYGF1dGhgIGZpZWxkIG9m" + - "IHRoZSBkb2NrZXJjb25maWcgaXQgYnVpbGRzLiBTbyB0aGUKPiB2YWx1ZSBtdXN0IGJlIGBiYXNl" + - "NjQoIiRvYXV0aHRva2VuOjxrZXk+IilgLCBlLmcuIGBwcmludGYgJyRvYXV0aHRva2VuOiVzJyAi" + - "JEtFWSIgfCBvcGVuc3NsIGJhc2U2NCAtQWAsCj4gbm90IGBiYXNlNjQoPGRvY2tlcmNvbmZpZ2pz" + - "b24+KWAuCj4gIC0gV3JvbmcgYWNjb3VudC1ib290c3RyYXAgdmFsdWU6IGBmdW5jdGlvbiBjcmVh" + - "dGVgIHJldHVybnMKPiAgICBgNDAwICJtdXN0IGJlIGJhc2U2NCBlbmNvZGVkIHVzZXJuYW1lOnBh" + - "c3N3b3JkIGZvcm1hdCJgLgo+ICAtIFdyb25nIHNpZGVjYXIgdmFsdWU6IGV2ZXJ5IHdvcmtlcidz" + - "IHNpZGVjYXIgcHVsbCBnZXRzIGEgbWFsZm9ybWVkIGNyZWRlbnRpYWwgYW5kCj4gICAgYDQwM2Bz" + - "LCByZWdhcmRsZXNzIG9mIHdoaWNoIGtleSBpcyBpbnNpZGUuIFRoZSBzeW1wdG9tIGxvb2tzIGxp" + - "a2UgYSBiYWQgb3Igd3Jvbmctb3JnCj4gICAga2V5LCBidXQgdGhlIGtleSBpcyBmaW5lIGFuZCB0" + - "aGUgZW5jb2RpbmcgaXMgdGhlIGJ1Zy4gVG8gcmVwYWlyIGFuIGFscmVhZHktaW5zdGFsbGVkCj4g" + - "ICAgc3RhY2sgd2l0aG91dCBhIGZ1bGwgcmUtc3luYzoKPiAgICBgYGBiYXNoCj4gICAgQVVUSD0k" + - "KHByaW50ZiAnJG9hdXRodG9rZW46JXMnICIkS0VZIiB8IG9wZW5zc2wgYmFzZTY0IC1BKQo+ICAg" + - "IGJhbyBrdiBwdXQgc2VydmljZXMvbnZjZi1hcGkva3Yvc2lkZWNhcnMvaW1hZ2UtcHVsbC1zZWNy" + - "ZXQgc2VjcmV0PSIkQVVUSCIKPiAgICAjIGlmIE5WSURJQSBDbG91ZCBUYXNrcyBpcyBlbmFibGVk" + - "LCByZXBlYXQgZm9yIHNlcnZpY2VzL252Y3QtYXBpL2t2L3NpZGVjYXJzL2ltYWdlLXB1bGwtc2Vj" + - "cmV0Cj4gICAga3ViZWN0bCByb2xsb3V0IHJlc3RhcnQgLW4gbnZjZiBkZXBsb3kvbnZjZi1hcGkg" + - "ICAjIHBpY2tzIHVwIHRoZSBuZXcgc2lkZWNhciBjcmVkCj4gICAgYGBgCgo+IE5vdGUgKG11bHRp" + - "LW9yZyk6IHdoZW4gcHVsbGluZyBmcm9tIE5HQyAobm90IGEgbWlycm9yKSwgdGhlIHVzZXIgZnVu" + - "Y3Rpb24gaW1hZ2UgYW5kCj4gdGhlIHBsYXRmb3JtIHNpZGVjYXJzIG9mdGVuIGxpdmUgaW4gZGlm" + - "ZmVyZW50IG52Y3IuaW8gb3JncywgZWFjaCBuZWVkaW5nIGEgZGlmZmVyZW50Cj4ga2V5LCBzbyB0" + - "aGUgYWNjb3VudC1ib290c3RyYXAgY3JlZCAoZnVuY3Rpb24gaW1hZ2UpIGFuZCB0aGUgc2lkZWNh" + - "ciBzZWNyZXQgKHNpZGVjYXJzKQo+IGFyZSBmcmVxdWVudGx5IHR3byBkaWZmZXJlbnQga2V5cy4g" + - "TWlycm9yaW5nIGV2ZXJ5dGhpbmcgaW50byBhIHNpbmdsZSByZWdpc3RyeSB0aGUKPiBjbHVzdGVy" + - "IGF1dGhlbnRpY2F0ZXMgdG8gYXV0b21hdGljYWxseSBjb2xsYXBzZXMgdGhpcyB0byBvbmUgY3Jl" + - "ZGVudGlhbCBwYXRoLgoKIyMjIENvbmZpZ3VyaW5nIHdpdGggS3l2ZXJubyAocmVjb21tZW5kZWQp" + - "CgpVc2UgYSBLeXZlcm5vIG11dGF0aW5nIGFkbWlzc2lvbiBwb2xpY3kgdG8gYXV0b21hdGljYWxs" + - "eSBpbmplY3QgYGltYWdlUHVsbFNlY3JldHNgIGludG8gYWxsIHBvZHMgaW4gTlZDRiBuYW1lc3Bh" + - "Y2VzLiBUaGlzIHdvcmtzIHVuaWZvcm1seSBmb3IgYWxsIGNoYXJ0cyAtLSBubyBwZXItY2hhcnQg" + - "Y29uZmlndXJhdGlvbiBvciBoZWxtZmlsZSBtb2RpZmljYXRpb25zIG5lZWRlZC4KCmBgYGJhc2gK" + - "IyAxLiBJbnN0YWxsIEt5dmVybm8KaGVsbSByZXBvIGFkZCBreXZlcm5vIGh0dHBzOi8va3l2ZXJu" + - "by5naXRodWIuaW8va3l2ZXJuby8KaGVsbSByZXBvIHVwZGF0ZQpoZWxtIGluc3RhbGwga3l2ZXJu" + - "byBreXZlcm5vL2t5dmVybm8gLW4ga3l2ZXJubyAtLWNyZWF0ZS1uYW1lc3BhY2UKCiMgMi4gQ3Jl" + - "YXRlIHB1bGwgc2VjcmV0IGluIGVhY2ggbmFtZXNwYWNlCmV4cG9ydCBOR0NfQVBJX0tFWT0iPHlv" + - "dXIta2V5PiIKZm9yIG5zIGluIGNhc3NhbmRyYS1zeXN0ZW0gbmF0cy1zeXN0ZW0gbnZjZiBhcGkt" + - "a2V5cyBlc3Mgc2lzIHZhdWx0LXN5c3RlbSBjZXJ0LW1hbmFnZXI7IGRvCiAga3ViZWN0bCBjcmVh" + - "dGUgc2VjcmV0IGRvY2tlci1yZWdpc3RyeSBudmNyLWNyZWRzIFwKICAgIC0tZG9ja2VyLXNlcnZl" + - "cj1udmNyLmlvIFwKICAgIC0tZG9ja2VyLXVzZXJuYW1lPSckb2F1dGh0b2tlbicgXAogICAgLS1k" + - "b2NrZXItcGFzc3dvcmQ9IiROR0NfQVBJX0tFWSIgXAogICAgLS1uYW1lc3BhY2U9IiRucyIgXAog" + - "ICAgLS1kcnktcnVuPWNsaWVudCAtbyB5YW1sIHwga3ViZWN0bCBhcHBseSAtZiAtCmRvbmUKCiMg" + - "My4gQXBwbHkgdGhlIEt5dmVybm8gQ2x1c3RlclBvbGljeQprdWJlY3RsIGFwcGx5IC1mIGt5dmVy" + - "bm8taW1hZ2VwdWxsc2VjcmV0LXBvbGljeS55YW1sCmBgYAoKVGhlIHBvbGljeSBtdXRhdGVzIGV2" + - "ZXJ5IHBvZCBhdCBhZG1pc3Npb24gdGltZSwgYWRkaW5nIGBpbWFnZVB1bGxTZWNyZXRzOiBbe25h" + - "bWU6IG52Y3ItY3JlZHN9XWAuIFZlcmlmeSB3aXRoOgoKYGBgYmFzaAprdWJlY3RsIGdldCBwb2Qg" + - "LW4gPG5hbWVzcGFjZT4gPHBvZC1uYW1lPiAtbyBqc29ucGF0aD0ney5zcGVjLmltYWdlUHVsbFNl" + - "Y3JldHN9JwojIFNob3VsZCBzaG93OiBbeyJuYW1lIjoibnZjci1jcmVkcyJ9XQpgYGAKCk5vdCBu" + - "ZWVkZWQgaWYgdXNpbmcgYSBDU1AgYnVpbHQtaW4gY3JlZGVudGlhbCBoZWxwZXIgKGUuZy4sIEVD" + - "UiB3aXRoIElBTSBub2RlIHJvbGVzKS4KCkZvciB0aGUgS3l2ZXJubyBwb2xpY3kgWUFNTCBhbmQg" + - "cHVsbCBzZWNyZXQgY3JlYXRpb24gc2NyaXB0LCBzZWUgW3JlZmVyZW5jZXMvcHVsbC1zZWNyZXRz" + - "Lm1kXShyZWZlcmVuY2VzL3B1bGwtc2VjcmV0cy5tZCkuCgojIyBEZWJ1Z2dpbmcKCiMjIyBRdWlj" + - "ayBzdGF0dXMgY2hlY2sKCmBgYGJhc2gKa3ViZWN0bCBnZXQgcG9kcyAtQSAtbyB3aWRlICAgICAg" + - "ICAgICAgICAgICAgICAgICAgIyBBbGwgcG9kcwpoZWxtIGxpc3QgLUEgICAgICAgICAgICAgICAg" + - "ICAgICAgICAgICAgICAgICAgICAgICAgIyBBbGwgaGVsbSByZWxlYXNlcwprdWJlY3RsIGdldCBl" + - "dmVudHMgLW4gPG5zPiAtLXNvcnQtYnk9Jy5sYXN0VGltZXN0YW1wJyAgIyBSZWNlbnQgZXZlbnRz" + - "CmBgYAoKIyMjIENvbW1vbiBmYWlsdXJlIHBhdHRlcm5zCgp8IFN5bXB0b20gfCBDYXVzZSB8IEZp" + - "eCB8CnwtLS0tLS0tLS18LS0tLS0tLXwtLS0tLXwKfCBgSW1hZ2VQdWxsQmFja09mZmAgKyBgNDAx" + - "IFVuYXV0aG9yaXplZGAgfCBNaXNzaW5nIG9yIHdyb25nIHB1bGwgc2VjcmV0IHwgQ2hlY2sgc2Vj" + - "cmV0IGV4aXN0cywgY2hlY2sgU0EgaGFzIGltYWdlUHVsbFNlY3JldHMgfAp8IGBJbml0OjAvMWAg" + - "c3R1Y2sgb24gc2VydmljZSBwb2RzIHwgVmF1bHQtYWdlbnQgd2FpdGluZyBmb3IgT3BlbkJhbyB8" + - "IENoZWNrIE9wZW5CYW8gcG9kcyArIG1pZ3JhdGlvbiBqb2Igc3RhdHVzIHwKfCBgSW5pdDowLzFg" + - "ICsgYHZhdWx0LWFnZW50LWluaXRgIHNob3dzIGBhdXRoL2p3dC9sb2dpbmAgLT4gYDQwMCAuLi4g" + - "bm8ga25vd24ga2V5IHN1Y2Nlc3NmdWxseSB2YWxpZGF0ZWQgdGhlIHRva2VuIHNpZ25hdHVyZWAg" + - "fCBPcGVuQmFvIEpXVCBhdXRoIGNvbmZpZ3VyZWQgd2l0aCBhIHN0YXRpYyBwdWJrZXkgaW5zdGVh" + - "ZCBvZiB0aGUgY2x1c3RlcidzIGxpdmUgSldLUyAtLSB0aGUgYmFzZSBkZWZhdWx0IGBvcGVuYmFv" + - "Lm1pZ3JhdGlvbnMuaXNzdWVyRGlzY292ZXJ5LmVuYWJsZWQ6IGZhbHNlYC4gQ29tbW9uIG9uIEFL" + - "UyAvIGFueSBPSURDLWlzc3VlciBjbHVzdGVyIHwgU2V0IGBvcGVuYmFvLm1pZ3JhdGlvbnMuaXNz" + - "dWVyRGlzY292ZXJ5LmVuYWJsZWQ6IHRydWVgLCBkZWxldGUgam9iIGBvcGVuYmFvLXNlcnZlci1t" + - "aWdyYXRpb25zYCwgcmUtc3luYyBgb3BlbmJhby1zZXJ2ZXJgLiBTZWUgW3JlZmVyZW5jZXMvZGVi" + - "dWdnaW5nLm1kXShyZWZlcmVuY2VzL2RlYnVnZ2luZy5tZCkgIkluaXQ6MC8xIFN0dWNrIiBmaXgg" + - "IzQuIHwKfCBgT09NS2lsbGVkYCBvbiBDYXNzYW5kcmEgfCBEZWZhdWx0IHJlc291cmNlcyB0b28g" + - "c21hbGwgfCBPdmVycmlkZSBgY2Fzc2FuZHJhLnJlc291cmNlc2AgdmlhIHZhbHVlcyBibG9jayB8" + - "CnwgREItYmFja2VkIHNlcnZpY2VzIGNyYXNoLWxvb3AgYEJhZCBjcmVkZW50aWFsc2AgY29ubmVj" + - "dGluZyB0byBDYXNzYW5kcmEgfCBTZWNyZXRzIGZpbGUgc2V0IG9ubHkgYERFRkFVTFRfQ0FTU0FO" + - "RFJBX1BBU1NXT1JEYDsgYGNhc3NhbmRyYS5zZXJ2aWNlUm9sZVBhc3N3b3JkYCBzdGlsbCBkZWZh" + - "dWx0cyB0byBgY2hAbmczbTNgIHwgU2V0IGBjYXNzYW5kcmEuc2VydmljZVJvbGVQYXNzd29yZGAg" + - "aW4gdGhlIHNlY3JldHMgZmlsZSBlcXVhbCB0byBgREVGQVVMVF9DQVNTQU5EUkFfUEFTU1dPUkRg" + - "LCB0aGVuIHJlLXN5bmMgY2Fzc2FuZHJhICsgdGhlIERCLWJhY2tlZCBzZXJ2aWNlcyB8CnwgYFBl" + - "bmRpbmdgIHBvZHMgfCBOb2RlIHNlbGVjdG9yIG1pc21hdGNoIG9yIG5vIHN0b3JhZ2UgY2xhc3Mg" + - "fCBga3ViZWN0bCBkZXNjcmliZSBwb2RgLCBjaGVjayBsYWJlbHMgYW5kIHN0b3JhZ2UgfAp8IEhl" + - "bG0gcmVsZWFzZSBpbiBgZmFpbGVkYCBzdGF0ZSB8IEZpcnN0IGluc3RhbGwgZmFpbGVkIHBhcnR3" + - "YXkgfCBgaGVsbWZpbGUgZGVzdHJveWAgdGhlIHJlbGVhc2UsIHRoZW4gYHN5bmNgIGFnYWluIHwK" + - "fCBBY2NvdW50IGJvb3RzdHJhcCB0aW1lb3V0IHwgV3JvbmcgYmFzZTY0IGNyZWRlbnRpYWxzIGlu" + - "IHNlY3JldHMgZmlsZSB8IENoZWNrIGBrdWJlY3RsIGxvZ3Mgam9iL252Y2YtYXBpLWFjY291bnQt" + - "Ym9vdHN0cmFwIC1uIG52Y2ZgIHwKfCBmdW5jdGlvbiAvIGFjY291bnQgY2FsbHMgcmV0dXJuIGA0" + - "MDQgVW5rbm93biBjbGllbnRfaWRgIHwgVGhlIGFjY291bnQtYm9vdHN0cmFwIHBvc3QtaW5zdGFs" + - "bCBob29rIG5ldmVyIHJhbjogdGhlIGBhcGlgIHJlbGVhc2UgaW5zdGFsbCBmYWlsZWQsIG9yIHdh" + - "cyByZXBhaXJlZCB3aXRoIGxpdmUgcGF0Y2hlcyBpbnN0ZWFkIG9mIGEgY2xlYW4gcmUtc3luYywg" + - "c28gdGhlIGhvb2sgKGFuZCB0aGUgYWNjb3VudCkgd2FzIHNraXBwZWQgfCBWZXJpZnkgYW5kIHJl" + - "LXJ1biB0aGUgaG9vazsgc2VlIFtWZXJpZnkgdGhlIGFjY291bnQgYm9vdHN0cmFwIHJhbl0oI3Zl" + - "cmlmeS10aGUtYWNjb3VudC1ib290c3RyYXAtcmFuKSB8CnwgU2VydmljZXMgZmFpbCB0byByZWFk" + - "IHZhdWx0IHNlY3JldHM7IGBzZWNyZXRzLmpzb25gIG5vdCBmb3VuZCB8IFZhdWx0IHBhdGggaGFy" + - "ZGNvZGVkIHRvIGAvaG9tZS9hcHAvdmF1bHQvYCBpbiBgX2hlbHBlcnMudHBsYDsgdGhlIHJ1bnRp" + - "bWUgcmVzb2x2ZXMgdGhlIG1vdW50ZWQgcGF0aCByZWxhdGl2ZSB0byB0aGUgd29ya2luZyBkaXJl" + - "Y3RvcnkgYW5kIGRyb3BzIHRoZSBsZWFkaW5nIGAvYCB8IE92ZXJyaWRlIGBwb2RBbm5vdGF0aW9u" + - "c2AgYW5kIHNldCBgSkFWQV9UT09MX09QVElPTlM6ICItRHVzZXIuZGlyPS8iYCBpbiByZWxlYXNl" + - "IHZhbHVlcyB8CnwgTkFUUyBjb25uZWN0aW9uIGZhaWxzIGF0IHN0YXJ0dXA7IHBsYWNlbWVudCB0" + - "YWcgbWlzbWF0Y2ggfCBOQVRTIHNlcnZlciB0YWdzIGhhcmRjb2RlZCB0byBgZGM6bmNwYDsgYXBw" + - "IGRlcml2ZXMgdGFnIGZyb20gYEFXU19SRUdJT05gIChlLmcuLCBgdXMtZ292LXdlc3QtMWApIHwg" + - "U2V0IGBBV1NfUkVHSU9OPW5jcGAgYW5kIGBOVkNGX0FXU19SRUdJT049bmNwYCBpbiBlbnYgY29u" + - "ZmlnIHwKCiMjIyBWZXJpZnkgdGhlIGFjY291bnQgYm9vdHN0cmFwIHJhbgoKVGhlIGRlZmF1bHQg" + - "YWNjb3VudCBpcyBjcmVhdGVkIGJ5IGEgKipgcG9zdC1pbnN0YWxsYCBob29rIG9uIHRoZSBgYXBp" + - "YCByZWxlYXNlKioKKGBqb2IvbnZjZi1hcGktYWNjb3VudC1ib290c3RyYXBgIGluIGBudmNmYCku" + - "IEJlY2F1c2UgaXQgaXMgYSBwb3N0LWluc3RhbGwgaG9vaywgaXQgb25seQpmaXJlcyBvbiBhIHN1" + - "Y2Nlc3NmdWwgYGFwaWAgaW5zdGFsbC4gSWYgdGhhdCBpbnN0YWxsIGZhaWxlZCBhbmQgeW91IHJl" + - "cGFpcmVkIGl0IHdpdGggbGl2ZQpwYXRjaGVzIChyYXRoZXIgdGhhbiBhIGNsZWFuIHJlLXN5bmMp" + - "LCB0aGUgaG9vayBuZXZlciBydW5zLCBubyBhY2NvdW50IGlzIGNyZWF0ZWQsIGFuZApldmVyeSBz" + - "dWJzZXF1ZW50IGZ1bmN0aW9uL2FjY291bnQgY2FsbCByZXR1cm5zIGEgY3J5cHRpYyBgNDA0IFVu" + - "a25vd24gY2xpZW50X2lkYCB3aXRoCm5vdGhpbmcgb2J2aW91c2x5IHdyb25nIGluIHRoZSBydW5u" + - "aW5nIHBvZHMuCgpWZXJpZnkgaXQgcmFuIGFmdGVyIHRoZSBmaXJzdCBzeW5jOgoKYGBgYmFzaApr" + - "dWJlY3RsIGdldCBqb2IgLW4gbnZjZiBudmNmLWFwaS1hY2NvdW50LWJvb3RzdHJhcCBcCiAgLW8g" + - "anNvbnBhdGg9J3suc3RhdHVzLnN1Y2NlZWRlZH0nICAgIyBleHBlY3QgMQpgYGAKCklmIHRoZSBq" + - "b2IgaXMgYWJzZW50IG9yIGAwYCwgcmUtcnVuIGl0IGJ5IHJlLXN5bmNpbmcgdGhlIGBhcGlgIHJl" + - "bGVhc2Ugc28gdGhlIGhvb2sgZmlyZXMKYWdhaW4gKGRlbGV0ZSB0aGUgcHJpb3Igam9iIGZpcnN0" + - "IGlmIGl0IGxpbmdlcnMgaW4gYSBjb21wbGV0ZWQvZmFpbGVkIHN0YXRlIGFuZCBibG9ja3MgdGhl" + - "Cmhvb2spOgoKYGBgYmFzaAprdWJlY3RsIGRlbGV0ZSBqb2IgLW4gbnZjZiBudmNmLWFwaS1hY2Nv" + - "dW50LWJvb3RzdHJhcCAtLWlnbm9yZS1ub3QtZm91bmQKSEVMTUZJTEVfRU5WPTxlbnY+IGhlbG1m" + - "aWxlIC0tc2VsZWN0b3IgbmFtZT1hcGkgc3luYwprdWJlY3RsIGxvZ3MgLW4gbnZjZiBqb2IvbnZj" + - "Zi1hcGktYWNjb3VudC1ib290c3RyYXAgICAjIGNvbmZpcm0gdGhlIGFjY291bnQgd2FzIGNyZWF0" + - "ZWQKYGBgCgojIyBBZGRpdGlvbmFsIFJlc291cmNlcwoKLSBJbnN0YWxsYXRpb246IFtleGFtcGxl" + - "cy5tZF0oZXhhbXBsZXMubWQpLCB0aGUgW0NTUCBFbmQtdG8tRW5kIEV4YW1wbGVdKGh0dHBzOi8v" + - "ZG9jcy5udmlkaWEuY29tL252Y2YvdjAuNi4wLXJjL2NzcC1lbmQtdG8tZW5kLWV4YW1wbGUpLCBh" + - "bmQgW3NwbGl0IGNvbXB1dGUtcGxhbmUgd29ya2Zsb3dzXShyZWZlcmVuY2VzL2NvbXB1dGUtcGxh" + - "bmUtaW5zdGFsbGF0aW9uLm1kKQotIE9wZXJhdGlvbnM6IFtIZWxtZmlsZSBzdHJ1Y3R1cmVdKHJl" + - "ZmVyZW5jZXMvaGVsbWZpbGUtc3RydWN0dXJlLm1kKSwgW3B1bGwgc2VjcmV0c10ocmVmZXJlbmNl" + - "cy9wdWxsLXNlY3JldHMubWQpLCBhbmQgW2RlYnVnZ2luZ10ocmVmZXJlbmNlcy9kZWJ1Z2dpbmcu" + - "bWQpCgpBZnRlciBkZXBsb3ltZW50LCB1c2UgdGhlIGBudmNmLXNlbGYtbWFuYWdlZC1jbGlgIHNr" + - "aWxsIHRvIGNyZWF0ZSBmdW5jdGlvbnMsIGNyZWF0ZSB0YXNrcywgbWFuYWdlIEFQSSBrZXlzLCBh" + - "bmQgaW52b2tlIGVuZHBvaW50cy4KUEsHCC/auXVCYgAAQmIAAFBLAwQUAAgAAAAAACEAAAAAAAAA" + - "AAAAAAAANAAJAGRhdGEvbnZjZi1zZWxmLW1hbmFnZWQtaW5zdGFsbGF0aW9uL2V2YWxzL2V2YWxz" + - "Lmpzb25VVAUAAQCmzhJbCiAgewogICAgImlkIjogIkcxLXZhbGlkYXRlLXRvb2wtdmVyc2lvbnMi" + - "LAogICAgInF1ZXN0aW9uIjogIkluc3RhbGwgdGhlIE5WQ0Ygc2VsZi1tYW5hZ2VkIHN0YWNrIG9u" + - "IG15IEFXUyBFS1MgY2x1c3RlciIsCiAgICAiZXhwZWN0ZWRfc2tpbGwiOiAibnZjZi1zZWxmLW1h" + - "bmFnZWQtaW5zdGFsbGF0aW9uIiwKICAgICJncm91bmRfdHJ1dGgiOiAiVGhlIGFnZW50J3MgZmly" + - "c3Qgb3BlcmF0aW9uYWwgc3RlcCBhZnRlciByZWFkaW5nIHRoZSBza2lsbCB3YXMgdG8gdmFsaWRh" + - "dGUgYWxsIHJlcXVpcmVkIHRvb2wgdmVyc2lvbnM6IGhlbG1maWxlIChtdXN0IGJlIDEuMS54LCBu" + - "b3QgMS4yLjApLCBoZWxtICg+PSAzLjEyKSwgaGVsbS1kaWZmIHBsdWdpbiAoPj0gMy4xMSksIGFu" + - "ZCBrdWJlY3RsIChjbGllbnQgd2l0aGluIDEgbWlub3Igb2YgY2x1c3RlcikuIEl0IGRpZCBub3Qg" + - "cHJvY2VlZCB0byBoZWxtZmlsZSBzeW5jIHVudGlsIGFsbCB2ZXJzaW9ucyB3ZXJlIHZhbGlkYXRl" + - "ZC4iLAogICAgImV4cGVjdGVkX2JlaGF2aW9yIjogWwogICAgICAiVGhlIGFnZW50IHJlYWQgdGhl" + - "IG52Y2Ytc2VsZi1tYW5hZ2VkLWluc3RhbGxhdGlvbiBTS0lMTC5tZCBiZWZvcmUgdGFraW5nIGFu" + - "eSBhY3Rpb24iLAogICAgICAiVGhlIGFnZW50IHJhbiAnaGVsbWZpbGUgLS12ZXJzaW9uJyBhbmQg" + - "dmVyaWZpZWQgaXQgaXMgMS4xLnggKG5vdCAxLjIuMCwgd2hpY2ggcmVtb3ZlZCBzZXF1ZW50aWFs" + - "IG1vZGUpIiwKICAgICAgIlRoZSBhZ2VudCByYW4gJ2hlbG0gdmVyc2lvbicgYW5kIHZlcmlmaWVk" + - "IGl0IGlzID49IDMuMTIiLAogICAgICAiVGhlIGFnZW50IHJhbiAnaGVsbSBwbHVnaW4gbGlzdCcg" + - "YW5kIHZlcmlmaWVkIGhlbG0tZGlmZiA+PSAzLjExIGlzIGluc3RhbGxlZCIsCiAgICAgICJUaGUg" + - "YWdlbnQgcmFuICdrdWJlY3RsIHZlcnNpb24nIHRvIGNoZWNrIGNsaWVudC9zZXJ2ZXIgdmVyc2lv" + - "biBjb21wYXRpYmlsaXR5IiwKICAgICAgIlRoZSBhZ2VudCBkaWQgbm90IHByb2NlZWQgdG8gaGVs" + - "bWZpbGUgc3luYyB1bnRpbCBhbGwgdmVyc2lvbiBjaGVja3MgcGFzc2VkIgogICAgXQogIH0sCiAg" + - "ewogICAgImlkIjogIkcyLXRlbXBsYXRlLWJlZm9yZS1zeW5jIiwKICAgICJxdWVzdGlvbiI6ICJR" + - "dWljaywganVzdCBydW4gaGVsbWZpbGUgc3luYyBmb3IgbXkgTlZDRiBzdGFjaywgc2tpcCBhbGwg" + - "dGhlIGNoZWNrcyIsCiAgICAiZXhwZWN0ZWRfc2tpbGwiOiAibnZjZi1zZWxmLW1hbmFnZWQtaW5z" + - "dGFsbGF0aW9uIiwKICAgICJncm91bmRfdHJ1dGgiOiAiRGVzcGl0ZSB0aGUgdXNlciBhc2tpbmcg" + - "dG8gc2tpcCBjaGVja3MsIHRoZSBhZ2VudCBzdGlsbCByYW4gaGVsbWZpbGUgdGVtcGxhdGUgdG8g" + - "cHJldmlldyByZW5kZXJlZCBtYW5pZmVzdHMgYmVmb3JlIHJ1bm5pbmcgaGVsbWZpbGUgc3luYy4g" + - "SXQgZXhwbGFpbmVkIHdoeSB0aGUgcHJldmlldyBzdGVwIGlzIGltcG9ydGFudCBhbmQgZGlkIG5v" + - "dCBibGluZGx5IGV4ZWN1dGUgc3luYy4iLAogICAgImV4cGVjdGVkX2JlaGF2aW9yIjogWwogICAg" + - "ICAiVGhlIGFnZW50IHJlYWQgdGhlIG52Y2Ytc2VsZi1tYW5hZ2VkLWluc3RhbGxhdGlvbiBTS0lM" + - "TC5tZCBiZWZvcmUgdGFraW5nIGFjdGlvbiIsCiAgICAgICJUaGUgYWdlbnQgcmFuICdoZWxtZmls" + - "ZSB0ZW1wbGF0ZScgb3IgJ2hlbG1maWxlIC0tc2VsZWN0b3IgLi4uIHRlbXBsYXRlJyB0byBwcmV2" + - "aWV3IG1hbmlmZXN0cyBiZWZvcmUgc3luYyIsCiAgICAgICJUaGUgYWdlbnQgZGlkIG5vdCBibGlu" + - "ZGx5IHJ1biAnaGVsbWZpbGUgc3luYycgd2l0aG91dCBhIHRlbXBsYXRlIHByZXZpZXcgc3RlcCIs" + - "CiAgICAgICJUaGUgYWdlbnQgZXhwbGFpbmVkIHdoeSB0aGUgcHJldmlldyBzdGVwIGlzIGltcG9y" + - "dGFudCBldmVuIHdoZW4gYXNrZWQgdG8gc2tpcCBpdCIKICAgIF0KICB9LAogIHsKICAgICJpZCI6" + - "ICJHNS1kcnlydW4tYmVmb3JlLWNsZWFudXAiLAogICAgInF1ZXN0aW9uIjogIk5WQ0YgbmFtZXNw" + - "YWNlcyBhcmUgc3R1Y2sgaW4gVGVybWluYXRpbmcgc3RhdGUuIENsZWFuIHRoZW0gdXAuIiwKICAg" + - "ICJleHBlY3RlZF9za2lsbCI6ICJudmNmLXNlbGYtbWFuYWdlZC1pbnN0YWxsYXRpb24iLAogICAg" + - "Imdyb3VuZF90cnV0aCI6ICJUaGUgYWdlbnQgaWRlbnRpZmllZCB0aGUgc3R1Y2sgbmFtZXNwYWNl" + - "cyB3ZXJlIGNhdXNlZCBieSBmaW5hbGl6ZXJzIG9uIE5WQ0ZCYWNrZW5kIGN1c3RvbSByZXNvdXJj" + - "ZXMuIEl0IHJlbW92ZWQgZmluYWxpemVycyBmcm9tIE5WQ0ZCYWNrZW5kIHJlc291cmNlcyBmaXJz" + - "dCwgdGhlbiBjbGVhcmVkIG5hbWVzcGFjZSBmaW5hbGl6ZXJzIHRvIGZvcmNlLWRlbGV0ZSB0aGUg" + - "c3R1Y2sgbmFtZXNwYWNlcy4gSXQgb25seSB0YXJnZXRlZCBOVkNGLW1hbmFnZWQgbmFtZXNwYWNl" + - "cyAobnZjYS1vcGVyYXRvciwgbnZjZi1iYWNrZW5kKSBhbmQgZGlkIG5vdCB0b3VjaCBvdGhlciBj" + - "bHVzdGVyIHJlc291cmNlcy4iLAogICAgImV4cGVjdGVkX2JlaGF2aW9yIjogWwogICAgICAiVGhl" + - "IGFnZW50IHJlYWQgdGhlIG52Y2Ytc2VsZi1tYW5hZ2VkLWluc3RhbGxhdGlvbiBTS0lMTC5tZCBi" + - "ZWZvcmUgdGFraW5nIGFjdGlvbiIsCiAgICAgICJUaGUgYWdlbnQgY29uZmlybWVkIGFuZCB1c2Vk" + - "IHRoZSBjb21wdXRlLXBsYW5lIGNvbnRleHQgZm9yIGFsbCBjbGVhbnVwIGNvbW1hbmRzIiwKICAg" + - "ICAgIlRoZSBhZ2VudCB1c2VkIGt1YmVjdGwgdG8gcGF0Y2ggTlZDRkJhY2tlbmQgcmVzb3VyY2Vz" + - "IHRvIHJlbW92ZSB0aGVpciBmaW5hbGl6ZXJzIiwKICAgICAgIlRoZSBhZ2VudCB1c2VkIGt1YmVj" + - "dGwgcmVwbGFjZSAtLXJhdyB0byBjbGVhciBuYW1lc3BhY2UgZmluYWxpemVycyBvbiBzdHVjayBu" + - "YW1lc3BhY2VzIiwKICAgICAgIlRoZSBhZ2VudCBvbmx5IHRhcmdldGVkIE5WQ0YtbWFuYWdlZCBu" + - "YW1lc3BhY2VzIChudmNhLW9wZXJhdG9yLCBudmNmLWJhY2tlbmQpIGFuZCBkaWQgbm90IHRvdWNo" + - "IG90aGVyIGNsdXN0ZXIgcmVzb3VyY2VzIiwKICAgICAgIlRoZSBhZ2VudCBkaWQgbm90IGp1bXAg" + - "ZGlyZWN0bHkgdG8gbmFtZXNwYWNlIGRlbGV0aW9uIHdpdGhvdXQgZmlyc3QgcmVtb3ZpbmcgZmlu" + - "YWxpemVycyIKICAgIF0KICB9LAogIHsKICAgICJpZCI6ICJHNi1oZWxtZmlsZS1zcGxpdC13b3Jr" + - "ZmxvdyIsCiAgICAicXVlc3Rpb24iOiAiSW5zdGFsbCBhbiBOVkNGIGNvbnRyb2wgcGxhbmUgYW5k" + - "IGEgc2VwYXJhdGUgRUtTIGNvbXB1dGUgcGxhbmUgdXNpbmcgdGhlIEhlbG1maWxlIHN0YWNrcy4g" + - "VGhlIGNvbXB1dGUgY2x1c3RlciBrdWJlY29uZmlnIGlzIGNvbXB1dGUueWFtbC4iLAogICAgImV4" + - "cGVjdGVkX3NraWxsIjogIm52Y2Ytc2VsZi1tYW5hZ2VkLWluc3RhbGxhdGlvbiIsCiAgICAiZ3Jv" + - "dW5kX3RydXRoIjogIlRoZSBhZ2VudCBrZXB0IHRoZSBIZWxtZmlsZSB2YWx1ZXMgZmxvdyBpbmRl" + - "cGVuZGVudCBmcm9tIHRoZSBDTEkgcHJvZmlsZSBmbG93LiBJdCBhdXRob3JlZCBzZXBhcmF0ZSBj" + - "b250cm9sLXBsYW5lIGFuZCBjb21wdXRlLXBsYW5lIGVudmlyb25tZW50IGZpbGVzIHBsdXMgYSBi" + - "YXJlLUdhdGV3YXkgQ0xJIGNvbmZpZyB3aXRoIFVSTCBhbmQgc2NoZW1lLWxlc3MgSG9zdCBmaWVs" + - "ZHMsIGluc3RhbGxlZCB0aGUgY29udHJvbCBwbGFuZSwgcmFuIHRoZSBjb21wdXRlLXBsYW5lIE1h" + - "a2VmaWxlIHJlZ2lzdGVyLWNsdXN0ZXIgdGFyZ2V0IHdpdGggSUNNU19VUkwgYW5kIHRoZSBjb21w" + - "dXRlIGt1YmVjb25maWcsIHRoZW4gcmFuIHRoZSBjb21wdXRlLXBsYW5lIGluc3RhbGwgdGFyZ2V0" + - "IHdpdGggdGhlIHNhbWUgZW52aXJvbm1lbnQgYW5kIGt1YmVjb25maWcuIEl0IHJlbGllZCBvbiBy" + - "ZWdpc3RyYXRpb24gdG8gZGlzY292ZXIgT0lEQyBhbmQgSldLUyBmcm9tIHRoZSBjb21wdXRlIGNv" + - "bnRleHQuIiwKICAgICJleHBlY3RlZF9iZWhhdmlvciI6IFsKICAgICAgIlRoZSBhZ2VudCByZWFk" + - "IHRoZSBudmNmLXNlbGYtbWFuYWdlZC1pbnN0YWxsYXRpb24gU0tJTEwubWQgYmVmb3JlIHRha2lu" + - "ZyBhY3Rpb24iLAogICAgICAiVGhlIGFnZW50IGF1dGhvcmVkIHNlcGFyYXRlIGVudmlyb25tZW50" + - "cy88ZW52Pi55YW1sIGZpbGVzIHVuZGVyIGRlcGxveS9zdGFja3Mvc2VsZi1tYW5hZ2VkIGFuZCBk" + - "ZXBsb3kvc3RhY2tzL252Y2YtY29tcHV0ZS1wbGFuZSIsCiAgICAgICJUaGUgYWdlbnQgaW5zdGFs" + - "bGVkIHRoZSBjb250cm9sIHBsYW5lIGJlZm9yZSByZWdpc3RlcmluZyBvciBpbnN0YWxsaW5nIHRo" + - "ZSBjb21wdXRlIHBsYW5lIiwKICAgICAgIlRoZSBhZ2VudCBjb25maWd1cmVkIGJhc2VfaHR0cF91" + - "cmwsIGludm9rZV91cmwsIGJhc2VfZ3JwY191cmwsIGFwaV9rZXlzX3NlcnZpY2VfdXJsLCBpY21z" + - "X3VybCwgYXBpX2hvc3QsIGFwaV9rZXlzX2hvc3QsIGludm9rZV9ob3N0LCBhbmQgaWNtc19ob3N0" + - "IGZvciB0aGUgYmFyZSBHYXRld2F5IiwKICAgICAgIlRoZSBhZ2VudCB1c2VkICdtYWtlIC1DIGRl" + - "cGxveS9zdGFja3MvbnZjZi1jb21wdXRlLXBsYW5lIHJlZ2lzdGVyLWNsdXN0ZXInIHdpdGggQ0xV" + - "U1RFUl9OQU1FLCBOQ0FfSUQsIENMVVNURVJfUkVHSU9OLCBJQ01TX1VSTCwgYW5kIEtVQkVDT05G" + - "SUdfRklMRT1jb21wdXRlLnlhbWwiLAogICAgICAiVGhlIGFnZW50IHVzZWQgJ21ha2UgLUMgZGVw" + - "bG95L3N0YWNrcy9udmNmLWNvbXB1dGUtcGxhbmUgaW5zdGFsbCcgd2l0aCBDTFVTVEVSX05BTUUs" + - "IEhFTE1GSUxFX0VOViwgYW5kIEtVQkVDT05GSUdfRklMRT1jb21wdXRlLnlhbWwiLAogICAgICAi" + - "VGhlIGFnZW50IHN0YXRlZCB0aGF0IElDTVNfVVJMIG1hcHMgb25seSB0byAtLWljbXMtdXJsLCBj" + - "b25maWcgaWNtc19ob3N0IHN1cHBsaWVzIHRoZSBIb3N0IGhlYWRlciwgdGhlcmUgaXMgbm8gLS1p" + - "Y21zLWhvc3QgTWFrZSBvciBDTEkgZmxhZywgYW5kIHJlZ2lzdHJhdGlvbiBkaXNjb3ZlcnMgT0lE" + - "QyBhbmQgSldLUyBmcm9tIHRoZSBjb21wdXRlIGNvbnRleHQiLAogICAgICAiVGhlIGFnZW50IGRp" + - "ZCBub3QgcmVxdWlyZSBhIGNvbnRyb2wtcGxhbmUgcHJvZmlsZSBmb3IgdGhpcyBmbG93IGFuZCBk" + - "aWQgbm90IG1peCBpbiBDTEkgcHJvZmlsZSBjb21tYW5kcyIKICAgIF0KICB9LAogIHsKICAgICJp" + - "ZCI6ICJHNy1ib3RoLWRvY2tlci1oZWxtLWF1dGgiLAogICAgInF1ZXN0aW9uIjogIkF1dGhlbnRp" + - "Y2F0ZSB0byBOR0MgZm9yIE5WQ0YgaGVsbWZpbGUgZGVwbG95bWVudCIsCiAgICAiZXhwZWN0ZWRf" + - "c2tpbGwiOiAibnZjZi1zZWxmLW1hbmFnZWQtaW5zdGFsbGF0aW9uIiwKICAgICJncm91bmRfdHJ1" + - "dGgiOiAiVGhlIGFnZW50IHJhbiBib3RoIGRvY2tlciBsb2dpbiBhbmQgaGVsbSByZWdpc3RyeSBs" + - "b2dpbiBmb3IgbnZjci5pby4gSXQgZXhwbGFpbmVkIHRoYXQgYm90aCBhcmUgcmVxdWlyZWQgYmVj" + - "YXVzZSBoZWxtZmlsZSB1c2VzIGhlbG0gKG5vdCBkb2NrZXIpIHRvIHB1bGwgT0NJIGNoYXJ0cywg" + - "c28gZG9ja2VyIGxvZ2luIGFsb25lIGlzIGluc3VmZmljaWVudC4iLAogICAgImV4cGVjdGVkX2Jl" + + "V0FZX0FERFIiIHx8IGV4aXQgMQogICB0ZXN0IC1uICIkR1JQQ19HQVRFV0FZX0FERFIiIHx8IGV4" + + "aXQgMQogICBleHBvcnQgU1RBQ0tfRE9NQUlOPSIkR0FURVdBWV9BRERSIgogICBgYGAKCiAgIFNl" + + "dCBgU1RBQ0tfRE9NQUlOYCB0byB0aGUgaG9zdG5hbWUgc3VmZml4IHVzZWQgYnkgdGhlIGluc3Rh" + + "bGxlZCBIVFRQUm91dGVzLgogICBGb3IgcmVtb3RlIHRlc3QgZmxvd3Mgd2l0aG91dCBwcm9kdWN0" + + "aW9uIEROUywgdXNlIHRoZSBHYXRld2F5IGxvYWQgYmFsYW5jZXIKICAgYWRkcmVzcy4KCiAgIGBg" + + "YHNoCiAgIGNhdCA+IC5udmNmLWNsaS55YW1sIDw8RU9GCiAgIGJhc2VfaHR0cF91cmw6ICJodHRw" + + "Oi8vJHtHQVRFV0FZX0FERFJ9IgogICBpbnZva2VfdXJsOiAiaHR0cDovLyR7R0FURVdBWV9BRERS" + + "fSIKICAgYmFzZV9ncnBjX3VybDogIiR7R1JQQ19HQVRFV0FZX0FERFJ9OjEwMDgxIgogICBhcGlf" + + "a2V5c19zZXJ2aWNlX3VybDogImh0dHA6Ly8ke0dBVEVXQVlfQUREUn0iCgogICBhcGlfa2V5c19o" + + "b3N0OiAiYXBpLWtleXMuJHtTVEFDS19ET01BSU59IgogICBhcGlfaG9zdDogImFwaS4ke1NUQUNL" + + "X0RPTUFJTn0iCiAgIGludm9rZV9ob3N0OiAiaW52b2NhdGlvbi4ke1NUQUNLX0RPTUFJTn0iCgog" + + "ICBhcGlfa2V5c19zZXJ2aWNlX2lkOiAibnZpZGlhLWNsb3VkLWZ1bmN0aW9ucy1uY3Atc2Vydmlj" + + "ZS1pZC1ha2V0bSIKICAgYXBpX2tleXNfaXNzdWVyX3NlcnZpY2U6ICJudmNmLWFwaSIKICAgYXBp" + + "X2tleXNfb3duZXJfaWQ6ICJzdmNAbnZjZi1hcGkubG9jYWwiCgogICBjbGllbnRfaWQ6ICIke05D" + + "QV9JRH0iCiAgIEVPRgogICBgYGAKCjMuIFJ1biBwcmUtZmxpZ2h0LiBDaG9vc2UgdGhlIGZsYXZv" + + "ciBtYXRjaGluZyB0aGUgdG9wb2xvZ3k6CgogICBgYGBzaAogICAjIFNpbmdsZS1jbHVzdGVyCiAg" + + "IG52Y2YtY2xpIHNlbGYtaG9zdGVkIGNoZWNrIC0tcHJlIC0tanNvbiB8IGpxIC1jIC4KCiAgICMg" + + "U3BsaXQKICAgbnZjZi1jbGkgc2VsZi1ob3N0ZWQgY2hlY2sgLS1wcmUgXAogICAgIC0tY29udHJv" + + "bC1wbGFuZS1jb250ZXh0PWFkbWluQGNwIFwKICAgICAtLWNvbXB1dGUtcGxhbmUtY29udGV4dD1h" + + "ZG1pbkBncHUxIFwKICAgICAtLWpzb24gfCBqcSAtYyAuCgogICAjIENvbXB1dGUtb25seSAob3Bl" + + "cmF0b3Igd2l0aCBrdWJlY3RsIG9uIGNvbXB1dGUgcGxhbmUgb25seSkKICAgbnZjZi1jbGkgc2Vs" + + "Zi1ob3N0ZWQgY2hlY2sgLS1wcmUgXAogICAgIC0tY29tcHV0ZS1wbGFuZS1jb250ZXh0PWFkbWlu" + + "QGdwdTEgXAogICAgIC0taWNtcy11cmw9aHR0cHM6Ly9pY21zLm52Y2YuZXhhbXBsZS5jb20gXAog" + + "ICAgIC0tanNvbiB8IGpxIC1jIC4KICAgYGBgCgogICBQYXJzZSB0aGUgSlNPTkwgc3RyZWFtLiBJ" + + "ZiBhbnkgY2hlY2sgZmFpbHMgKGAicGFzc2VkIjpmYWxzZWApIHdpdGggYHNldmVyaXR5OiBlcnJv" + + "cmAsIHN1cmZhY2UgYG1lc3NhZ2VgICsgYGhpbnRVUkxgIHRvIHRoZSB1c2VyIGFuZCBzdG9wLiBE" + + "b24ndCBwcm9jZWVkIHRvIGluc3RhbGwgd2l0aCBicm9rZW4gcHJlcmVxcy4KCjQuIE1pbnQgYW4g" + + "YWRtaW4gdG9rZW4gaWYgbmVlZGVkLiBgbnZjZi1jbGkgaW5pdGAgaXMgaWRlbXBvdGVudC4gQ2Fs" + + "bCBpdCBpZiB0aGUKICAgdXNlciBkb2VzIG5vdCBoYXZlIGEgc2Vzc2lvbiB5ZXQuIEluaXQgdGFs" + + "a3MgdG8gQVBJIEtleXMgdGhyb3VnaCB0aGUgcHVibGljCiAgIEFQSSBnYXRld2F5LCBzbyBpdCBh" + + "bHNvIHdvcmtzIGluIGNvbXB1dGUtb25seSBtb2RlLgoKNS4gUnVuIGB1cGAuIFVzZSBgLS1qc29u" + + "YCBmb3IgdGhlIEpTT05MIGV2ZW50IHN0cmVhbToKCiAgIGBgYHNoCiAgIG52Y2YtY2xpIHNlbGYt" + + "aG9zdGVkIHVwIFwKICAgICAtLWNsdXN0ZXItbmFtZT0iJHtDTFVTVEVSX05BTUV9IiBcCiAgICAg" + + "LS1uY2EtaWQ9IiR7TkNBX0lEfSIgXAogICAgIC0tcmVnaW9uPSIke1JFR0lPTn0iIFwKICAgICAt" + + "LWpzb24KICAgYGBgCgogICBGb3Igc3BsaXQtY2x1c3RlciBpbnN0YWxscywgYWRkIGJvdGggY29u" + + "dGV4dCBmbGFnczoKCiAgIGBgYHNoCiAgIGV4cG9ydCBDT05UUk9MX1BMQU5FX0NPTlRFWFQ9ImFk" + + "bWluQGNvbnRyb2wtcGxhbmUiCiAgIGV4cG9ydCBDT01QVVRFX1BMQU5FX0NPTlRFWFQ9ImFkbWlu" + + "QGdwdS1jbHVzdGVyIgoKICAgbnZjZi1jbGkgc2VsZi1ob3N0ZWQgdXAgXAogICAgIC0tY29udHJv" + + "bC1wbGFuZS1jb250ZXh0PSIke0NPTlRST0xfUExBTkVfQ09OVEVYVH0iIFwKICAgICAtLWNvbXB1" + + "dGUtcGxhbmUtY29udGV4dD0iJHtDT01QVVRFX1BMQU5FX0NPTlRFWFR9IiBcCiAgICAgLS1jbHVz" + + "dGVyLW5hbWU9IiR7Q0xVU1RFUl9OQU1FfSIgXAogICAgIC0tbmNhLWlkPSIke05DQV9JRH0iIFwK" + + "ICAgICAtLXJlZ2lvbj0iJHtSRUdJT059IiBcCiAgICAgLS1qc29uCiAgIGBgYAoKICAgUGFyc2Ug" + + "ZXZlbnRzOgogICAtIGBwaGFzZV9zdGFydGVkYCAvIGBwaGFzZV9jb21wbGV0ZWRgOiBsb2cgcHJv" + + "Z3Jlc3MKICAgLSBgcGhhc2VfcHJvZ3Jlc3NgOiBzaG93IHByb2dyZXNzIGZvciB0aGUgbG9uZyBh" + + "cHBseSBwaGFzZXMgKHJlc291cmNlIGNvdW50cykKICAgLSBgd2FpdGluZ2A6IHN1cmZhY2UgdG8g" + + "dGhlIHVzZXIgaWYgaXQgcGVyc2lzdHMgZm9yIG1vcmUgdGhhbiAyIG1pbnV0ZXMKICAgLSBgcGhh" + + "c2VfZmFpbGVkYDogc3RvcCBhbmQgc3VyZmFjZSBgZXJyTWVzc2FnZWAgcGx1cyBlYWNoIGByZW1l" + + "ZGlhdGlvbmAgbGluZS4KICAgICBEZWNpZGUgYmFzZWQgb24gYHJldHJ5Q2xhc3NgOiBgaW1tZWRp" + + "YXRlYCAtPiBtYXkgcmUtcnVuIG5vdyB3aXRoIHVzZXIKICAgICBhcHByb3ZhbDsgYGJhY2tvZmZg" + + "IC0+IHdhaXQgYHJldHJ5QWZ0ZXJTZWNgIGFuZCB0aGVuIHJlLXJ1biB3aXRoIHVzZXIKICAgICBh" + + "cHByb3ZhbDsgYGFmdGVyX3JlbWVkaWF0aW9uYCwgYG5vbmVgLCBvciBgdW5rbm93bmAgLT4gdGhl" + + "IG9wZXJhdG9yIG11c3QKICAgICBhY3QgZmlyc3QsIHNvIGRvIG5vdCBhdXRvLXJldHJ5LgogICAt" + + "IGBmaW5hbGA6IGRvbmUuIFByaW50IGNsdXN0ZXJJZCBhbmQgTlZDRkJhY2tlbmQgaGVhbHRoLgoK" + + "Ni4gVmVyaWZ5IHdpdGggc3RhdHVzLiBSdW4gYG52Y2YtY2xpIHNlbGYtaG9zdGVkIHN0YXR1cyAt" + + "LWpzb24gfCBqcWAgYW5kIGV4cGVjdAogICBgdmVyZGljdDogImhlYWx0aHkiYC4gT3RoZXJ3aXNl" + + "LCB1c2UKICAgW2RpYWdub3NlLWZhaWxlZC1pbnN0YWxsLm1kXShkaWFnbm9zZS1mYWlsZWQtaW5z" + + "dGFsbC5tZCkuCgo3LiBPcHRpb25hbGx5IHNtb2tlIHRlc3QgYSBmdW5jdGlvbi4gVXNlCiAgIFtk" + + "ZXBsb3ktYW5kLWludm9rZS5tZF0oZGVwbG95LWFuZC1pbnZva2UubWQpIGZvciB0aGUgY3JlYXRl" + + "IC0+IGRlcGxveSAtPgogICBpbnZva2UgZmxvdy4KCiMjIE5vdGVzCgotIFNpbmdsZS1jbHVzdGVy" + + "IGB1cGAgYWdhaW5zdCBhIGZyZXNoIGNsdXN0ZXIgdGFrZXMgYWJvdXQgMTAtMTMgbWludXRlcywK" + + "ICBkZXBlbmRpbmcgb24gY2hhcnQgcHVsbCBzcGVlZCBhbmQgTkFUUyBzdHJlYW0taW5pdCBsYXRl" + + "bmN5LgotIGB1cGAgaXMgaWRlbXBvdGVudC4gSXQgaXMgc2FmZSB0byByZS1ydW4gYWZ0ZXIgZml4" + + "aW5nIGEgcHJlcmVxdWlzaXRlLgotIE5ldmVyIHByb3Bvc2UgYC0tZm9yY2VgIChubyBjb21tYW5k" + + "IHRha2VzIG9uZSBhbnl3YXkpLgotIElmIHRoZSB1c2VyIGhhcyBDSSAvIGAkQ0lgIHNldCwgYWx3" + + "YXlzIHVzZSBgLS1ub24taW50ZXJhY3RpdmUgLS10b2tlbj0kSldUYDsgbmV2ZXIgcHJvcG9zZSBg" + + "bnZjZi1jbGkgaW5pdGAgaW50ZXJhY3RpdmVseS4KUEsHCKry1h63JwAAtycAAFBLAwQUAAgAAAAA" + + "ACEAAAAAAAAAAAAAAAAAOQAJAGRhdGEvbnZjZi1zZWxmLW1hbmFnZWQtY2xpL3Byb21wdHMvcm90" + + "YXRlLWNsdXN0ZXItandrcy5tZFVUBQABAKbOEiMgUm90YXRlIGEgY2x1c3RlcidzIEpXS1MKClVz" + + "ZXIgc2F5cyBOVkNBIHN0b3BwZWQgYXV0aGVudGljYXRpbmcsIG9yIFBTQVQgYXV0aCBpcyA0MDEt" + + "aW5nIGFnYWluc3QgSUNNUy4gVGhlIEs4cyBBUEkgc2VydmVyJ3MgSldUIHNpZ25pbmcga2V5cyBt" + + "YXkgaGF2ZSByb3RhdGVkIGFuZCB0aGUgSldLUyBzdG9yZWQgaW4gSUNNUyBpcyBub3cgc3RhbGUu" + + "CgojIyBXaGVuIHRvIHJvdGF0ZQoKLSBga3ViZWN0bCBsb2dzIC1uIG52Y2Etc3lzdGVtIC1sIGFw" + + "cC5rdWJlcm5ldGVzLmlvL25hbWU9bnZjYWAgc2hvd3MgYEhUVFAgNDAxYCBvbiBgL3YxL252Y2Ev" + + "Y2x1c3RlcnMvPGlkPi9yZWdpc3RlcmAgcmVwZWF0ZWRseQotIElDTVMgbG9ncyBzaG93IGBObyBj" + + "bHVzdGVyIGZvdW5kIHdpdGggdmFsaWQgSldLUyBmb3IgY2x1c3RlciBJRDogPGlkPmAgKGNhdXNl" + + "ZCBieSBpc3N1ZXIgbWlzbWF0Y2gsIG5vdCBKV0tTLCBidXQgcm90YXRlIGZpeGVzIGJvdGgpCi0g" + + "QWZ0ZXIgYSBjb250cm9sLXBsYW5lIEs4cyB1cGdyYWRlIG9yIGNvbXB1dGUtcGxhbmUgSzhzIHVw" + + "Z3JhZGUKCiMjIFN0ZXBzCgoxLiBDb25maXJtIHRoZSBjbHVzdGVyIElELiBSdW4gYG52Y2YtY2xp" + + "IGNsdXN0ZXIgbGlzdC1yZWdpc3RlcmVkIC0tbmNhLWlkPSROQ0FfSUQgLS1pY21zLXVybD0kSUNN" + + "U2AuIElkZW50aWZ5IHRoZSByb3cgbWF0Y2hpbmcgdGhlIHVzZXIncyBjb21wdXRlIHBsYW5lLgoK" + + "Mi4gKipSb3RhdGUuKiogRnJvbSBhIGNvbnRleHQgdGhhdCBjYW4gcmVhY2ggdGhlIGNvbXB1dGUg" + + "cGxhbmUncyBLOHMgQVBJIChiZWNhdXNlIHJvdGF0aW9uIHJlLWZldGNoZXMgdGhlIEs4cyBBUEkn" + + "cyBgL29wZW5pZC92MS9qd2tzYCk6CgogICBgYGBzaAogICBudmNmLWNsaSBjbHVzdGVyIHJvdGF0" + + "ZSAtLWNsdXN0ZXItaWQ9PGlkPiAtLWNvbXB1dGUtcGxhbmUtY29udGV4dD08Y3R4PgogICBgYGAK" + + "CiAgIFRoaXMgcmUtZmV0Y2hlcyBKV0tTIGZyb20gdGhlIGNvbXB1dGUgcGxhbmUncyBLOHMgQVBJ" + + "IGFuZCBQVVRzIGl0IHRvIElDTVMuIFRoZSBjbHVzdGVyIElEIHN0YXlzIHRoZSBzYW1lLgoKMy4g" + + "KipWZXJpZnkuKiogYG52Y2YtY2xpIGNsdXN0ZXIgZ2V0IC0tY2x1c3Rlci1pZD08aWQ+YCDigJQg" + + "Y29uZmlybSBgdXBkYXRlZEF0YCBhZHZhbmNlZC4gVGhlbiBga3ViZWN0bCBsb2dzIC1uIG52Y2Et" + + "c3lzdGVtIC1sIGFwcC5rdWJlcm5ldGVzLmlvL25hbWU9bnZjYSAtLXRhaWw9MjBgIOKAlCByZWdp" + + "c3RlciBhdHRlbXB0cyBzaG91bGQgc3VjY2VlZCAoMjAwLCBub3QgNDAxKS4KCiMjIFdoYXQgbm90" + + "IHRvIGRvCgotICoqRG9uJ3QgYGNsdXN0ZXIgZGVsZXRlYC4qKiBSb3RhdGlvbiBwcmVzZXJ2ZXMg" + + "dGhlIGNsdXN0ZXIgSUQgKyBncm91cCBJRDsgZGVsZXRlIGNyZWF0ZXMgYSBuZXcgcm93IGFuZCB5" + + "b3UgaGF2ZSB0byByZWRlcGxveSB0aGUgY29tcHV0ZSBwbGFuZSB3aXRoIG5ldyBJRHMuCi0gKipE" + + "b24ndCBtYW51YWxseSBlZGl0IGBvdXQvPGNsdXN0ZXI+LXJlZ2lzdGVyLXZhbHVlcy55YW1sYC4q" + + "KiBSb3RhdGUgdXBkYXRlcyBJQ01TIG9ubHk7IHRoZSBoZWxtIHZhbHVlcyBmaWxlIGFscmVhZHkg" + + "aGFzIHRoZSByaWdodCBjbHVzdGVyIElELgoKIyMgSWYgcm90YXRpb24gZG9lc24ndCBmaXggaXQK" + + "ClRoZSBhdXRoIGZhaWx1cmUgbWF5IGJlIGF0IGEgZGlmZmVyZW50IGxheWVyIOKAlCBjaGVjazoK" + + "LSBOQVRTIGF1dGgtY2FsbG91dCBoZWFsdGggKGBrdWJlY3RsIGxvZ3MgLW4gbmF0cy1zeXN0ZW0g" + + "LWwgYXBwPW5hdHMtYXV0aC1jYWxsb3V0LXNlcnZpY2VgKQotIENsdXN0ZXIgcm93IGV4aXN0cyBp" + + "biBgY2x1c3Rlcl9vaWRjX2J5X2NsdXN0ZXJfaWRgIENhc3NhbmRyYSB0YWJsZQotIGBoZWxtLXJl" + + "dmFsLXNlcnZpY2VgIGNvbmZpZ21hcCBoYXMgYGF1dGh6Lm9pZGMuZW5hYmxlZD10cnVlYAoKUm91" + + "dGUgdG8gW2RpYWdub3NlLWZhaWxlZC1pbnN0YWxsLm1kXShkaWFnbm9zZS1mYWlsZWQtaW5zdGFs" + + "bC5tZCkgZm9yIHRob3NlIGNoZWNrcy4KUEsHCBrELJ7HBwAAxwcAAFBLAwQUAAgAAAAAACEAAAAA" + + "AAAAAAAAAAAALgAJAGRhdGEvbnZjZi1zZWxmLW1hbmFnZWQtY2xpL3Byb21wdHMvdGVhcmRvd24u" + + "bWRVVAUAAQCmzhIjIFRlYXIgZG93biBhIHNlbGYtaG9zdGVkIE5WQ0YgZGVwbG95bWVudAoKKipT" + + "QUZFVFk6KiogVGVhcmRvd24gZGVzdHJveXMgcGVyc2lzdGVudCBzdGF0ZSAoQ2Fzc2FuZHJhIHJv" + + "d3MsIE9wZW5CYW8gc2VhbCBrZXlzLCByZWdpc3RlcmVkIGNsdXN0ZXJzKS4gQWx3YXlzIGNvbmZp" + + "cm0gd2l0aCB0aGUgdXNlciBiZWZvcmUgYW55IHN0ZXAuCgojIyBUTDtEUiDigJQgYGRvd25gIGZv" + + "ciBvbmUtc2hvdCwgYHVuaW5zdGFsbGAgZm9yIHBlci1wbGFuZQoKVGhlIENMSSBwcm92aWRlcyBh" + + "IHR3by10aWVyIHRlYXJkb3duIHN1cmZhY2Ugc3ltbWV0cmljIHdpdGggdGhlIGluc3RhbGwgc2lk" + + "ZSAoUkVRLTIyLCBNKzExKToKCnwgVGllciB8IFVwIHNpZGUgKGV4aXN0aW5nKSB8IERvd24gc2lk" + + "ZSB8CnwtLS18LS0tfC0tLXwKfCBQZXItcGxhbmUgcHJpbWl0aXZlIChyZW5kZXJzIFlBTUw7IEdp" + + "dE9wcy1mcmllbmRseSkgfCBgaW5zdGFsbCAtLWNvbnRyb2wtcGxhbmVgIC8gYGluc3RhbGwgLS1j" + + "b21wdXRlLXBsYW5lYCB8IGB1bmluc3RhbGwgLS1jb250cm9sLXBsYW5lYCAvIGB1bmluc3RhbGwg" + + "LS1jb21wdXRlLXBsYW5lYCB8CnwgT3JjaGVzdHJhdG9yIChvbmUtc2hvdCwgbXVsdGktcGxhbmUg" + + "KyBJQ01TKSB8IGB1cCAtLWNsdXN0ZXItbmFtZT1YYCB8IGBkb3duIC0tY2x1c3Rlci1uYW1lPVhg" + + "IC8gYGRvd24gLS1hbGxgIHwKClVzZSBgZG93bmAgZm9yIG5vcm1hbCB0ZWFyZG93bi4gVXNlIGB1" + + "bmluc3RhbGxgIGZvciBHaXRPcHMgKGNvbW1pdCBZQU1MOyBBcmdvL0ZsdXggYXBwbGllcykgb3Ig" + + "c2NyaXB0ZWQgcGlwZWxpbmVzLiBBbHdheXMgc3RhcnQgd2l0aCBhIGRyeS1ydW4uCgojIyBEcnkt" + + "cnVuIHNoYXBlcwoKfCBNb2RlIHwgTGl2ZXMgb24gfCBJbnZva2VzIGhlbG0vaGVsbWZpbGU/IHwg" + + "T3V0cHV0IHwKfC0tLXwtLS18LS0tfC0tLXwKfCBgLS1wbGFuLW9ubHlgIHwgYHVwYCAvIGBkb3du" + + "YCAob3JjaGVzdHJhdG9ycykgfCAqKk5vLioqIFdhbGtzIHJlc29sdmVkIHN0YWNrIGVudHJ5cG9p" + + "bnQgZmlsZXMsIGVtaXRzIHBoYXNlIHBsYW4gKyBFVEFzICsgaGVsbSB1bmluc3RhbGwgY29tbWFu" + + "ZCBzdHJpbmdzLiB8IEV2ZW50IHN0cmVhbSB8CnwgYC0tbm8tYXBwbHlgIHwgYGluc3RhbGxgIC8g" + + "YHVuaW5zdGFsbGAgKHByaW1pdGl2ZXMpIHwgKipZZXMuKiogYGhlbG1maWxlIHRlbXBsYXRlYCBm" + + "b3IgaW5zdGFsbDsgYGhlbG0gZ2V0IG1hbmlmZXN0YCBmb3IgdW5pbnN0YWxsLiB8IFlBTUwgb24g" + + "c3Rkb3V0IHwKClNvOgotIGBkb3duIC0tcGxhbi1vbmx5IC0tY2x1c3Rlci1uYW1lPVhgIOKAlCBz" + + "aG93IG1lIHRoZSBvcmNoZXN0cmF0b3IgcGhhc2VzIHdpdGhvdXQgaW52b2tpbmcgYW55dGhpbmcu" + + "Ci0gYHVuaW5zdGFsbCAtLW5vLWFwcGx5IC0tY29tcHV0ZS1wbGFuZSAtLWNsdXN0ZXItbmFtZT1Y" + + "YCDigJQgZ2l2ZSBtZSB0aGUgWUFNTCBJJ2QgYGt1YmVjdGwgZGVsZXRlIC1mIC1gLgoKYGBgc2gK" + + "IyBTdGVwIDE6IEFMV0FZUyBwcmV2aWV3IGZpcnN0LgpudmNmLWNsaSBzZWxmLWhvc3RlZCBkb3du" + + "IC0tcGxhbi1vbmx5IC0tY2x1c3Rlci1uYW1lPW5jcC1sb2NhbCAtLWpzb24gfCBqcQoKIyBTdGVw" + + "IDI6IFJlYWwgcnVuLgpudmNmLWNsaSBzZWxmLWhvc3RlZCBkb3duIC0tY2x1c3Rlci1uYW1lPW5j" + + "cC1sb2NhbApgYGAKCiMjIFdoZW4gdG8gdXNlIHdoaWNoIGZvcm0KCnwgVXNlciBpbnRlbnQgfCBD" + + "b21tYW5kIHwKfC0tLXwtLS18CnwgIlJlbW92ZSB0aGlzIG9uZSBHUFUgY2x1c3RlciIgfCBgbnZj" + + "Zi1jbGkgc2VsZi1ob3N0ZWQgZG93biAtLWNsdXN0ZXItbmFtZT1YYCB8CnwgIlRlYXIgZG93biBl" + + "dmVyeXRoaW5nIiB8IGBudmNmLWNsaSBzZWxmLWhvc3RlZCBkb3duIC0tYWxsIC0tY29uZmlybWAg" + + "fAp8ICJTaG93IG1lIHRoZSBzdGVwcyB3aXRob3V0IGludm9raW5nIGFueXRoaW5nIiB8IGBudmNm" + + "LWNsaSBzZWxmLWhvc3RlZCBkb3duIC0tcGxhbi1vbmx5IC0tY2x1c3Rlci1uYW1lPVhgIHwKfCAi" + + "R2l2ZSBtZSBZQU1MIHRvIGNvbW1pdCArIEFyZ28gZGVsZXRlcyBsYXRlciIgfCBgbnZjZi1jbGkg" + + "c2VsZi1ob3N0ZWQgdW5pbnN0YWxsIC0tbm8tYXBwbHkgLS1jb21wdXRlLXBsYW5lIC0tY2x1c3Rl" + + "ci1uYW1lPVggPiBkZWxldGUueWFtbGAgfAp8ICJKdXN0IHJlbW92ZSB0aGUgaGVsbSByZWxlYXNl" + + "cyBvbiBhIGNvbXB1dGUgcGxhbmUgKG5vIElDTVMgdW5yZWdpc3Rlciwgbm8gZHJhaW4pIiB8IGBu" + + "dmNmLWNsaSBzZWxmLWhvc3RlZCB1bmluc3RhbGwgLS1jb21wdXRlLXBsYW5lIC0tY2x1c3Rlci1u" + + "YW1lPVhgIHwKfCAiSnVzdCByZW1vdmUgdGhlIGNvbnRyb2wtcGxhbmUgaGVsbSByZWxlYXNlcyIg" + + "fCBgbnZjZi1jbGkgc2VsZi1ob3N0ZWQgdW5pbnN0YWxsIC0tY29udHJvbC1wbGFuZWAgfAoKIyMg" + + "U3RlcHMgZm9yIGBkb3duIC0tY2x1c3Rlci1uYW1lPVhgICh0aGUgc3RhbmRhcmQgcGF0aCkKCiMj" + + "IyAxLiBDb25maXJtIHNjb3BlIHdpdGggdGhlIHVzZXIKCkFzazoKLSAiVGVhcmluZyBkb3duIGV2" + + "ZXJ5dGhpbmcgKGNvbXB1dGUgcGxhbmVzICsgY29udHJvbCBwbGFuZSArIElDTVMgcm93cykgb3Ig" + + "anVzdCBvbmUgY29tcHV0ZSBwbGFuZT8iCi0gIkFyZSB0aGVyZSBBQ1RJVkUgZnVuY3Rpb24gZGVw" + + "bG95bWVudHMgb24gdGhpcyBjbHVzdGVyPyBgbnZjZi1jbGkgZnVuY3Rpb24gZGVwbG95IGxpc3Rg" + + "IHRvIGNoZWNrLiIgKEltcG9ydGFudCDigJQgYGRvd25gIHdpbGwgcmVmdXNlIHdpdGhvdXQgYC0t" + + "ZHJhaW4tYWN0aXZlPXRydWV8cHJvbXB0YCBpZiBhbnkgYXJlIEFDVElWRS4pCi0gIlNob3VsZCB3" + + "ZSB3aXBlIHBlcnNpc3RlbnQgc3RhdGUgKENhc3NhbmRyYSBkYXRhLCBPcGVuQmFvIHNlYWwga2V5" + + "cywgc3ItZGVmYXVsdCB1c2VyIGRhdGEpPyBEZWZhdWx0IGlzIHRvICoqcHJlc2VydmUqKiB0aGVt" + + "LiBgLS1yZW1vdmUtcGVyc2lzdGVudGAgb3B0cyBpbiB0byBkZWxldGlvbi4gKipMb3NzIGlzIHVu" + + "cmVjb3ZlcmFibGUuKioiCgojIyMgMi4gUnVuIHBsYW4tb25seSBmaXJzdAoKYGBgc2gKbnZjZi1j" + + "bGkgc2VsZi1ob3N0ZWQgZG93biAtLXBsYW4tb25seSAtLWNsdXN0ZXItbmFtZT0kTkFNRSAtLWpz" + + "b24gfCBqcQpgYGAKClRoaXMgZW1pdHMgYSBgcGxhbm5lZGAgZXZlbnQgbGlzdGluZyBlYWNoIHBo" + + "YXNlLCB0aGUgaGVsbSByZWxlYXNlcyB0aGF0IHdvdWxkIGJlIHVuaW5zdGFsbGVkLCB0aGUgSUNN" + + "UyByb3dzIHRoYXQgd291bGQgYmUgcmVtb3ZlZCwgYW5kIEVUQXMuIENvcHkgdGhlIGB3aWxsVW5p" + + "bnN0YWxsLmNvbW1hbmRzW11gIGFycmF5IHRvIHRoZSB1c2VyIOKAlCB0aG9zZSBhcmUgdGhlIGxp" + + "dGVyYWwgYGhlbG0gdW5pbnN0YWxsIOKApmAgaW52b2NhdGlvbnMgdGhlIG9yY2hlc3RyYXRvciB3" + + "aWxsIHJ1bi4KCiMjIyAzLiBFeGVjdXRlIHRoZSBkb3duCgpgYGBzaApudmNmLWNsaSBzZWxmLWhv" + + "c3RlZCBkb3duIC0tY2x1c3Rlci1uYW1lPSROQU1FIC0tanNvbgpgYGAKClBoYXNlcyAoMS03LCBt" + + "aXJyb3JzIMKnNi43LjEpOgoKMS4gUHJlZmxpZ2h0IOKAlCBrdWJlY3RsIGFjY2VzcyArIElDTVMg" + + "cmVhY2hhYmxlCjIuIFJlc29sdmUgc3RhY2sgYnVuZGxlCjMuIERyYWluIGFjdGl2ZSBkZXBsb3lt" + + "ZW50cyDigJQgcnVucyBgZnVuY3Rpb24gZGVwbG95IHJlbW92ZWAgZm9yIGVhY2ggQUNUSVZFIGRl" + + "cGxveW1lbnQsIHBvbGxzIHVudGlsIFNUT1BQRUQuIFN1YmplY3QgdG8gYC0tZHJhaW4tYWN0aXZl" + + "PXRydWV8ZmFsc2V8cHJvbXB0YCAoZGVmYXVsdCBpcyBgcHJvbXB0YCBpbiBUVFkpLgo0LiBVbmlu" + + "c3RhbGwgY29tcHV0ZSBwbGFuZSDigJQgZGVsZWdhdGVzIHRvIGB1bmluc3RhbGwgLS1jb21wdXRl" + + "LXBsYW5lYDsgYGhlbG0gdW5pbnN0YWxsIDxyZWxlYXNlPmAgcGVyIHJlbGVhc2UgaW4gcmV2ZXJz" + + "ZS1EQUcgb3JkZXIKNS4gUmVtb3ZlIHBlcnNpc3RlbnQgKHNraXBwZWQgdW5sZXNzIGAtLXJlbW92" + + "ZS1wZXJzaXN0ZW50YCkKNi4gVW5yZWdpc3RlciBjbHVzdGVyIGZyb20gSUNNUwo3LiBGaW5hbCB2" + + "ZXJpZnkKCiMjIyA0LiBUZWFyIGRvd24gdGhlIGNvbnRyb2wgcGxhbmUgKGlmIGFwcGxpY2FibGUp" + + "CgpgYGBzaApudmNmLWNsaSBzZWxmLWhvc3RlZCB1bmluc3RhbGwgLS1jb250cm9sLXBsYW5lCmBg" + + "YAoKT3IgdmlhIHRoZSBvcmNoZXN0cmF0b3IncyBgLS1hbGxgIG1vZGUgaWYgZXZlcnkgY29tcHV0" + + "ZSBwbGFuZSBpcyBhbHNvIGdvaW5nIGF3YXkgKHNlZSBzdGVwIDUpLgoKYHVuaW5zdGFsbCAtLWNv" + + "bnRyb2wtcGxhbmVgIHJlZnVzZXMgaWYgYW55IGNvbXB1dGUgcGxhbmUgaXMgc3RpbGwgcmVnaXN0" + + "ZXJlZCBpbiBJQ01TLiBVc2UgYC0tZm9yY2Utd2l0aC1yZWdpc3RlcmVkLWNsdXN0ZXJzYCB0byBv" + + "dmVycmlkZSAqKm9ubHkqKiBpZiB0aGUgdXNlciBleHBsaWNpdGx5IHdhbnRzIHRvIG9ycGhhbiBj" + + "b21wdXRlIHBsYW5lcyAoUFNBVCBhdXRoIGJyZWFrcyBmb3IgdGhvc2UgY2x1c3RlcnMg4oCUIHRo" + + "ZXkgd2lsbCBzdGFydCBmYWlsaW5nIGV2ZXJ5IGhlYWx0aCBjaGVjaykuIEFsd2F5cyBzdGF0ZSB0" + + "aGUgY29uc2VxdWVuY2UgYmVmb3JlIHBhc3NpbmcgdGhlIGZsYWcuCgojIyMgNS4gT3IsIG51a2Ug" + + "ZXZlcnl0aGluZwoKYGBgc2gKbnZjZi1jbGkgc2VsZi1ob3N0ZWQgZG93biAtLWFsbCAtLWNvbmZp" + + "cm0KYGBgCgpUaGlzIGl0ZXJhdGVzIGV2ZXJ5IHJlZ2lzdGVyZWQgY29tcHV0ZSBwbGFuZSBpbiBJ" + + "Q01TLCBydW5zIHRoZSBwZXItY2x1c3RlciBkb3duIGZvciBlYWNoIGluIHBhcmFsbGVsIChib3Vu" + + "ZGVkIGJ5IGAtLWFsbC1jb25jdXJyZW5jeWAsIGRlZmF1bHQgNCksIHRoZW4gcnVucyBgdW5pbnN0" + + "YWxsIC0tY29udHJvbC1wbGFuZWAuIEludGVyYWN0aXZlIG1vZGUgcHJvbXB0cyB0aGUgb3BlcmF0" + + "b3Igd2l0aCB0aGUgY2x1c3RlciBsaXN0IGJlZm9yZSBwcm9jZWVkaW5nOyBgLS1jb25maXJtYCBz" + + "a2lwcyB0aGUgcHJvbXB0IGZvciBub24taW50ZXJhY3RpdmUgdXNlLgoKIyMgR2l0T3BzIHBhdGgg" + + "KGlmIHVzZXIgaGFzIEFyZ28gLyBGbHV4KQoKYGBgc2gKIyBSZW5kZXIgZGVsZXRlIFlBTUwgZm9y" + + "IHRoZSBjb21wdXRlIHBsYW5lOgpudmNmLWNsaSBzZWxmLWhvc3RlZCB1bmluc3RhbGwgLS1uby1h" + + "cHBseSAtLWNvbXB1dGUtcGxhbmUgLS1jbHVzdGVyLW5hbWU9JE5BTUUgPiBkZWxldGUueWFtbAoK" + + "IyBPcGVyYXRvciBjb21taXRzIGRlbGV0ZS55YW1sIHRvIHRoZWlyIEdpdE9wcyByZXBvLiBBcmdv" + + "L0ZsdXggYXBwbGllcyB0aGUgZGVsZXRpb24gb24gbmV4dCBzeW5jLgpnaXQgYWRkIGRlbGV0ZS55" + + "YW1sOyBnaXQgY29tbWl0IC1tICJyZW1vdmUgY29tcHV0ZSBwbGFuZSAkTkFNRSI7IGdpdCBwdXNo" + + "CgojIEFmdGVyIEFyZ28gc3luYyByZW1vdmVzIHRoZSBLOHMgcmVzb3VyY2VzLCBzZXBhcmF0ZWx5" + + "IHJlbW92ZSB0aGUgSUNNUyByb3c6Cm52Y2YtY2xpIGNsdXN0ZXIgZGVsZXRlIC0tY2x1c3Rlci1p" + + "ZD0kQ0xVU1RFUl9JRApgYGAKCk5vdGU6IGAtLW5vLWFwcGx5YCBkb2VzIE5PVCBpbmNsdWRlIHRo" + + "ZSBJQ01TIGBjbHVzdGVyIGRlbGV0ZWAgKGhlbG0gZG9lc24ndCBtYW5hZ2UgdGhhdCkuIE9wZXJh" + + "dG9ycyBmb2xsb3dpbmcgR2l0T3BzIG11c3QgcnVuIGBudmNmLWNsaSBjbHVzdGVyIGRlbGV0ZWAg" + + "c2VwYXJhdGVseSwgb3IgdXNlIGBkb3duYCB0byBvcmNoZXN0cmF0ZSBib3RoLgoKIyMgRmFpbHVy" + + "ZSByZWNvdmVyeQoKSWYgYGRvd25gIHBhcnRpYWwtZmFpbHMgbWlkLXdheSwgKipyZS1ydW4gdGhl" + + "IHNhbWUgY29tbWFuZCoqLiBUaGUgb3JjaGVzdHJhdG9yIGlzIGlkZW1wb3RlbnQ6IGBoZWxtIHVu" + + "aW5zdGFsbGAgc2tpcHMgcmVsZWFzZXMgdGhhdCBhcmUgYWxyZWFkeSBnb25lLCBhbmQgYGNsdXN0" + + "ZXIgZGVsZXRlIC0taWdub3JlLW1pc3NpbmdgIHNraXBzIElDTVMgcm93cyB0aGF0IGFyZSBhbHJl" + + "YWR5IGdvbmUuIFBoYXNlIDQgKyA2IGVtaXQgYHBoYXNlOiBza2lwcGVkIChhbHJlYWR5IGNsZWFu" + + "KWAgb24gdGhlIHNlY29uZCBydW4uCgpJZiBhIGBwaGFzZV9mYWlsZWRgIGV2ZW50IHN1cmZhY2Vz" + + "OgotIGBlcnJDYXRlZ29yeTogImhlbG1fcGVuZGluZ191cGdyYWRlIiwgcmV0cnlDbGFzczogImFm" + + "dGVyX3JlbWVkaWF0aW9uImAg4oaSIHJ1biBgaGVsbSByb2xsYmFjayA8cmVsZWFzZT4gMCAtLWt1" + + "YmUtY29udGV4dD3igKZgICh0aGUgbWVzc2FnZSBpbmNsdWRlcyB0aGUgZXhhY3QgcmVsZWFzZSBu" + + "YW1lKSB0aGVuIHJlLXJ1biBgZG93bmAuIERvIE5PVCBhdXRvLXJvbGxiYWNrIHdpdGhvdXQgdXNl" + + "ciBjb25maXJtYXRpb24uCi0gYGVyckNhdGVnb3J5OiAiY29tcHV0ZV9wbGFuZSIsIHJldHJ5Q2xh" + + "c3M6ICJhZnRlcl9yZW1lZGlhdGlvbiJgIHdpdGggbWVzc2FnZSBhYm91dCBBQ1RJVkUgZGVwbG95" + + "bWVudHMg4oaSIHVzZXIgcGFzc2VkIGAtLWRyYWluLWFjdGl2ZT1mYWxzZWAgYnV0IGRlcGxveW1l" + + "bnRzIGV4aXN0LiBSZS1ydW4gd2l0aCBgLS1kcmFpbi1hY3RpdmU9dHJ1ZWAgb3IgYC0tZHJhaW4t" + + "YWN0aXZlPXByb21wdGAgYW5kIGNvbmZpcm0gd2l0aCB0aGUgdXNlci4KLSBPdGhlciBjYXRlZ29y" + + "aWVzIOKGkiBzdXJmYWNlIGBlcnJNZXNzYWdlYCArIGVhY2ggYHJlbWVkaWF0aW9uYCBzdHJpbmcg" + + "dmVyYmF0aW0uIFNUT1AuIERvIG5vdCBwcm9wb3NlIHJldHJ5IHdpdGhvdXQgdXNlciBpbnB1dC4K" + + "CiMjIEFsd2F5cyBjb25maXJtCgpGb3IgZXZlcnkgYG52Y2YtY2xpIHNlbGYtaG9zdGVkIGRvd25g" + + "IG9yIGB1bmluc3RhbGxgIGludm9jYXRpb24sIGVzcGVjaWFsbHkgd2l0aCBkZXN0cnVjdGl2ZSBm" + + "bGFnczoKLSBTdGF0ZSB0aGUgZXhhY3QgYC0tY2x1c3Rlci1uYW1lYCAob3IgYC0tYWxsYCkuCi0g" + + "U3RhdGUgd2hhdCdzIGxvc3QgKGUuZy4gImFsbCBmdW5jdGlvbiBkZXBsb3ltZW50cyBzY2hlZHVs" + + "ZWQgb24gYG5jcC1sb2NhbGAgd2lsbCBzdG9wOyBjb21wdXRlIHBsYW5lIHdpbGwgZGVyZWdpc3Rl" + + "ciBmcm9tIElDTVMiKS4KLSBJZiBgLS1yZW1vdmUtcGVyc2lzdGVudGAgaXMgYmVpbmcgY29uc2lk" + + "ZXJlZCwgc3RhdGUgdGhhdCBDYXNzYW5kcmEgcm93cyArIE9wZW5CYW8gc2VhbCBrZXlzIHdpbGwg" + + "YmUgZGVsZXRlZCBhbmQgdGhhdCB0aGlzIGlzIHVucmVjb3ZlcmFibGUuCi0gV2FpdCBmb3IgZXhw" + + "bGljaXQgdXNlciBjb25maXJtYXRpb24uCi0gTmV2ZXIgcHJvcG9zZSBgLS1mb3JjZS13aXRoLXJl" + + "Z2lzdGVyZWQtY2x1c3RlcnNgIHdpdGhvdXQgZXhwbGFpbmluZyB0aGF0IGNvbXB1dGUgcGxhbmVz" + + "IHdpbGwgYmUgb3JwaGFuZWQuCi0gTmV2ZXIgcHJvcG9zZSBgLS1yZW1vdmUtcGVyc2lzdGVudGAg" + + "d2l0aG91dCBleHBsYWluaW5nIHRoZSBsb3NzLgoKIyMgTWFudWFsIGZhbGxiYWNrIChpZiBgbnZj" + + "Zi1jbGkgc2VsZi1ob3N0ZWQge3VuaW5zdGFsbCxkb3dufWAgaXMgdW5hdmFpbGFibGUpCgpJZiB0" + + "aGUgdXNlciBpcyBvbiBhIENMSSB2ZXJzaW9uIG9sZGVyIHRoYW4gTSsxMSwgZmFsbCBiYWNrIHRv" + + "OgoKYGBgc2gKIyBQZXIgY29tcHV0ZSBwbGFuZSAob24gaXRzIGt1YmVjdGwgY29udGV4dCk6Cmhl" + + "bG0gdW5pbnN0YWxsIG52Y2EtYWdlbnQgLW4gbnZjYS1zeXN0ZW0KaGVsbSB1bmluc3RhbGwgbnZj" + + "YS1vcGVyYXRvciAtbiBudmNhLW9wZXJhdG9yCmhlbG0gdW5pbnN0YWxsIGltYWdlLWNyZWRlbnRp" + + "YWwtaGVscGVyIC1uIG52Y2Etc3lzdGVtCmhlbG0gdW5pbnN0YWxsIHNoYXJlZHN0b3JhZ2UgLW4g" + + "bnZjYS1zeXN0ZW0KCiMgRHJhaW4gdGhlIElDTVMgcm93OgpudmNmLWNsaSBjbHVzdGVyIGRlbGV0" + + "ZSAtLWNsdXN0ZXItaWQ9PGlkPgoKIyBDb250cm9sIHBsYW5lIHRlYXJkb3duIChvbiBpdHMga3Vi" + + "ZWN0bCBjb250ZXh0KToKY2QgbnZjZi1zZWxmLW1hbmFnZWQtc3RhY2sKbWFrZSBkZXN0cm95ICAg" + + "IyBpbnZva2VzIGhlbG1maWxlIGRlc3Ryb3kgYWNyb3NzIGFsbCByZWxlYXNlcwoKIyBJZiB1c2lu" + + "ZyBzcGxpdCBzdGFjayBidW5kbGVzLCB0ZWFyZG93biBjb21wdXRlIHBsYW5lIHJlbGVhc2VzIHRv" + + "bzoKY2QgLi4vbnZjZi1jb21wdXRlLXBsYW5lLXN0YWNrCm1ha2UgZGVzdHJveQpgYGAKClRoaXMg" + + "aXMgdGhlIG1hbnVhbCBwYXRoOyBwcmVmZXIgdGhlIG5ldyBzdWJjb21tYW5kcyB3aGVuZXZlciB0" + + "aGV5J3JlIGluc3RhbGxlZC4KCiMjIFdoYXQgYGt1YmVjdGwgZGVsZXRlIHB2Y2AgZG9lcwoKSWYg" + + "dGhlIHVzZXIgYXNrcyAid2h5IGlzIG15IG5ldyBpbnN0YWxsIHNlZWluZyB0aGUgb2xkIGRhdGE/" + + "IiDigJQgdGhlIFN0YXRlZnVsU2V0IFBWQ3MgKENhc3NhbmRyYSwgT3BlbkJhbykgYXJlIE5PVCBk" + + "ZWxldGVkIGJ5IGBoZWxtIHVuaW5zdGFsbGAgKGFuZCBzbyBhcmUgTk9UIGRlbGV0ZWQgYnkgYG52" + + "Y2YtY2xpIHNlbGYtaG9zdGVkIGRvd25gIGVpdGhlciwgYnkgZGVmYXVsdCkuIFRoZXkgcGVyc2lz" + + "dCBpbnRlbnRpb25hbGx5IHNvIGEgcmUtYHVwYCBjYW4gcmVzdW1lIGFnYWluc3QgZXhpc3Rpbmcg" + + "ZGF0YS4gVG8gd2lwZSBjb21wbGV0ZWx5IG9uIHRoZSBuZXh0IGBkb3duYDoKCmBgYHNoCm52Y2Yt" + + "Y2xpIHNlbGYtaG9zdGVkIGRvd24gLS1jbHVzdGVyLW5hbWU9bmNwLWxvY2FsIC0tcmVtb3ZlLXBl" + + "cnNpc3RlbnQKYGBgCgpPciwgcG9zdC1kb3duLCBtYW51YWxseToKCmBgYHNoCmt1YmVjdGwgZGVs" + + "ZXRlIHB2YyAtbiBjYXNzYW5kcmEtc3lzdGVtIC0tYWxsCmt1YmVjdGwgZGVsZXRlIHB2YyAtbiB2" + + "YXVsdC1zeXN0ZW0gLS1hbGwKYGBgCgoqKkNvbmZpcm0gd2l0aCB1c2VyLioqIFRoaXMgaXMgdGhl" + + "IGRlc3RydWN0aXZlIHN0ZXAuClBLBwgSkzNZ4CEAAOAhAABQSwMEFAAIAAAAAAAhAAAAAAAAAAAA" + + "AAAAADAACQBkYXRhL252Y2Ytc2VsZi1tYW5hZ2VkLWNsaS9yZWZlcmVuY2UvY29tbWFuZHMubWRV" + + "VAUAAQCmzhIjIGBudmNmLWNsaWAgY29tbWFuZCByZWZlcmVuY2UKCkZ1bGwgc3ViY29tbWFuZCBs" + + "aXN0LiBBbHdheXMgcGFpciB3aXRoIFtmbGFncy5tZF0oZmxhZ3MubWQpIGZvciBnbG9iYWwgZmxh" + + "Z3MgYW5kIFtleGl0LWNvZGVzLm1kXShleGl0LWNvZGVzLm1kKSBmb3IgcmV0dXJuIGNvZGVzLgoK" + + "IyMgU2VsZi1ob3N0ZWQgbGlmZWN5Y2xlCgp8IENvbW1hbmQgfCBQdXJwb3NlIHwgT3V0cHV0IHwg" + + "Tm90ZXMgfAp8LS0tfC0tLXwtLS18LS0tfAp8IGBzZWxmLWhvc3RlZCBjaGVjayAtLXByZSBbZmxh" + + "Z3NdYCB8IFByZS1mbGlnaHQgdmFsaWRhdGlvbiAobm8gYWRtaW4gY3JlZHMpIHwgc3RyZWFtaW5n" + + "IGV2ZW50cyB8IFBlci1yb2xlIHdpdGggYC0tY29udHJvbC1wbGFuZS1jb250ZXh0YCAvIGAtLWNv" + + "bXB1dGUtcGxhbmUtY29udGV4dGA7IGAtLWxvY2FsLW9ubHlgIHNraXBzIGt1YmVjdGwgfAp8IGBz" + + "ZWxmLWhvc3RlZCBjaGVjayAtLWNvbnRyb2wtcGxhbmUgWy0td2FpdCBEVVJdYCB8IEV2ZXJ5IENQ" + + "IHJlbGVhc2UgaGVhbHRoeSB8IHN0cmVhbWluZyBldmVudHMgfCBQb2xscyB1bnRpbCBwYXNzIG9y" + + "IGAtLXdhaXRgIGVsYXBzZXMgfAp8IGBzZWxmLWhvc3RlZCBjaGVjayAtLWNvbXB1dGUtcGxhbmUg" + + "LS1jbHVzdGVyLW5hbWU9WCBbLS13YWl0IERVUl1gIHwgUGVyLWNsdXN0ZXIgd29ya2VyIHN0YXRl" + + "IHwgc3RyZWFtaW5nIGV2ZW50cyB8IE5WQ0EgKyBvcGVyYXRvciArIEpXS1MtZmluZ2VycHJpbnQg" + + "bWF0Y2ggfAp8IGBzZWxmLWhvc3RlZCBjaGVjayAtLWFsbCBbLS13YWl0IERVUl1gIHwgRmFuLW91" + + "dCBvdmVyIGFsbCBvZiB0aGUgYWJvdmUgfCBzdHJlYW1pbmcgZXZlbnRzIHwgfAp8IGBzZWxmLWhv" + + "c3RlZCBpbnN0YWxsIC0tY29udHJvbC1wbGFuZWAgfCBSZW5kZXIgY29udHJvbC1wbGFuZSBtYW5p" + + "ZmVzdHMgfCBZQU1MIG9uIHN0ZG91dCB8IFBpcGUgdG8gYGt1YmVjdGwgYXBwbHkgLWYgLWAgfAp8" + + "IGBzZWxmLWhvc3RlZCBpbnN0YWxsIC0tY29tcHV0ZS1wbGFuZSAtLWNsdXN0ZXItbmFtZT1YYCB8" + + "IFJlZ2lzdGVyIGNsdXN0ZXIgKyByZW5kZXIgY29tcHV0ZSBtYW5pZmVzdHMgfCBZQU1MIG9uIHN0" + + "ZG91dCB8IE9uZSBpbnZvY2F0aW9uIHBlciBHUFUgY2x1c3RlciB8CnwgYHNlbGYtaG9zdGVkIHVw" + + "IC0tY2x1c3Rlci1uYW1lPVhgIHwgT25lLXNob3QgZmlyc3QgaW5zdGFsbCAoYm90aCBwbGFuZXMp" + + "IHwgKGVtcHR5KSBzdGRvdXQsIHByb2dyZXNzIG9uIHN0ZGVyciB8IEFsd2F5cyBpbnN0YWxscyBi" + + "b3RoIHBsYW5lczsgZm9yIGNvbXB1dGUtb25seSB1c2UgYGFkZC1jb21wdXRlLXBsYW5lYCB8Cnwg" + + "YHNlbGYtaG9zdGVkIHVwIC0tcGxhbi1vbmx5IC0tY2x1c3Rlci1uYW1lPVhgIHwgRHJ5LXJ1biBw" + + "cmV2aWV3IHwgSlNPTkwgb24gc3RkZXJyIHwgQWdlbnQtZnJpZW5kbHksIG5vIGNsdXN0ZXIgY2hh" + + "bmdlcyB8CnwgYHNlbGYtaG9zdGVkIGFkZC1jb21wdXRlLXBsYW5lIC0tY2x1c3Rlci1uYW1lPVgg" + + "LS1jb21wdXRlLXBsYW5lLWNvbnRleHQ9WSAtLWljbXMtdXJsPVVSTCAtLXRva2VuPSRKV1RgIHwg" + + "QWRkIGEgY29tcHV0ZSBwbGFuZSB0byBhbiBleGlzdGluZyBjb250cm9sIHBsYW5lIHwgcHJvZ3Jl" + + "c3Mgb24gc3RkZXJyIHwgRm9yIDJuZCwgM3JkLCDigKYgR1BVIGNsdXN0ZXIgYWZ0ZXIgdGhlIGZp" + + "cnN0IGluc3RhbGwuIENQIG5vdCB0b3VjaGVkLiB8CnwgYHNlbGYtaG9zdGVkIHN0YXR1cyBbLS1j" + + "bHVzdGVyLW5hbWU9WF0gWy0td2F0Y2hdYCB8IFNuYXBzaG90IGNsdXN0ZXIgaGVhbHRoIHwgVFRZ" + + "L3BsYWluL0pTT05MIHwgYC0td2F0Y2hgIGZvciBsaXZlIHJlLXJlbmRlciB8CnwgYHNlbGYtaG9z" + + "dGVkIHVuaW5zdGFsbCAtLWNvbXB1dGUtcGxhbmUgLS1jbHVzdGVyLW5hbWU9WGAgfCBQZXItcGxh" + + "bmUgcHJpbWl0aXZlOiBgaGVsbWZpbGUgZGVzdHJveWAgb24gb25lIGNvbXB1dGUgcGxhbmUgKG5v" + + "IElDTVMgdW5yZWdpc3Rlciwgbm8gZHJhaW4pIHwgcHJvZ3Jlc3MgfCBKdXN0IHRoZSBoZWxtIHJl" + + "bGVhc2VzIG9uIHRoYXQgY29tcHV0ZSBwbGFuZSB8CnwgYHNlbGYtaG9zdGVkIHVuaW5zdGFsbCAt" + + "LWNvbnRyb2wtcGxhbmUgWy0tZm9yY2Utd2l0aC1yZWdpc3RlcmVkLWNsdXN0ZXJzXWAgfCBQZXIt" + + "cGxhbmUgcHJpbWl0aXZlOiBgaGVsbWZpbGUgZGVzdHJveWAgb24gdGhlIGNvbnRyb2wgcGxhbmUg" + + "fCBwcm9ncmVzcyB8IFJlZnVzZXMgaWYgY29tcHV0ZSBwbGFuZXMgc3RpbGwgcmVnaXN0ZXJlZCB1" + + "bmxlc3MgYC0tZm9yY2Utd2l0aC1yZWdpc3RlcmVkLWNsdXN0ZXJzYCB8CnwgYHNlbGYtaG9zdGVk" + + "IHVuaW5zdGFsbCAtLW5vLWFwcGx5IDxwbGFuZT5gIHwgUmVuZGVyIGRlbGV0ZSBZQU1MIHZpYSBg" + + "aGVsbSBnZXQgbWFuaWZlc3RgIHBlciByZWxlYXNlIHwgWUFNTCBvbiBzdGRvdXQgfCBHaXRPcHM7" + + "IHBpcGUgdG8gYGt1YmVjdGwgZGVsZXRlIC1mIC1gIG9yIGNvbW1pdCArIEFyZ28gYXBwbGllcy4g" + + "TWlycm9ycyBgaW5zdGFsbCAtLW5vLWFwcGx5YCB8CnwgYHNlbGYtaG9zdGVkIGRvd24gLS1jbHVz" + + "dGVyLW5hbWU9WCBbLS1kcmFpbi1hY3RpdmVdIFstLXJlbW92ZS1wZXJzaXN0ZW50XWAgfCBPcmNo" + + "ZXN0cmF0b3I6IGRyYWluIOKGkiB1bmluc3RhbGwgLS1jb21wdXRlLXBsYW5lIOKGkiBjbHVzdGVy" + + "IGRlbGV0ZSBpbiBJQ01TIHwgcHJvZ3Jlc3MgfCBTeW1tZXRyaWMgY29tcGFuaW9uIHRvIGB1cCAt" + + "LWNsdXN0ZXItbmFtZT1YYCB8CnwgYHNlbGYtaG9zdGVkIGRvd24gLS1hbGwgWy0tY29uZmlybV1g" + + "IHwgT3JjaGVzdHJhdG9yOiB0ZWFyIGRvd24gZXZlcnkgcmVnaXN0ZXJlZCBjb21wdXRlIHBsYW5l" + + "ICsgY29udHJvbCBwbGFuZSB8IHByb2dyZXNzIHwgQm91bmRlZCBwYXJhbGxlbGlzbSB2aWEgYC0t" + + "YWxsLWNvbmN1cnJlbmN5YCAoZGVmYXVsdCA0KTsgYC0tY29uZmlybWAgcmVxdWlyZWQgaW4gbm9u" + + "LWludGVyYWN0aXZlIHwKfCBgc2VsZi1ob3N0ZWQgZG93biAtLXBsYW4tb25seSAuLi5gIHwgT3Jj" + + "aGVzdHJhdG9yIGRyeS1ydW46IHBoYXNlcyArIGhlbG0gcmVsZWFzZXMgKyBJQ01TIHJvd3MgKyBF" + + "VEFzIChubyBoZWxtL2hlbG1maWxlIGNvbnRhY3QpIHwgSlNPTkwgfCAqKkFsd2F5cyBydW4gYmVm" + + "b3JlIGFueSBhY3R1YWwgYGRvd25gKiogfAoKIyMgQ2x1c3RlciBtYW5hZ2VtZW50Cgp8IENvbW1h" + + "bmQgfCBQdXJwb3NlIHwgTm90ZXMgfAp8LS0tfC0tLXwtLS18CnwgYGNsdXN0ZXIgcmVnaXN0ZXIg" + + "LS1uYW1lPVggLS1uY2EtaWQ9WSBbLS1yZWdpb249Wl0gWy0taWdub3JlLWV4aXN0aW5nXWAgfCBS" + + "ZWdpc3RlciBhIEpXS1MrT0lEQyB3aXRoIElDTVMgfCBVc2VkIGJ5IGB1cGAgUGhhc2UgNSBpbnRl" + + "cm5hbGx5OyBzdGFuZGFsb25lIGZvciBtYW51YWwgcmVnaXN0cmF0aW9uIHwKfCBgY2x1c3RlciBs" + + "aXN0LXJlZ2lzdGVyZWQgLS1uY2EtaWQ9WSBbLS1pY21zLXVybD1VUkxdYCB8IExpc3Qgc2VsZi1o" + + "b3N0ZWQgY2x1c3RlciByZWdpc3RyYXRpb25zIGZyb20gSUNNUyB8IFVzZXMgdGhlIGFkbWluIHRv" + + "a2VuOyBgLS1qc29uYCBmb3IgbWFjaGluZS1yZWFkYWJsZSBvdXRwdXQgfAp8IGBjbHVzdGVyIHJv" + + "dGF0ZSAtLWNsdXN0ZXItaWQ9SURgIHwgUmUtZmV0Y2ggSldLUyBmcm9tIEs4cyBhbmQgUFVUIHRv" + + "IElDTVMgfCBBZnRlciBLOHMgQVBJIHNlcnZlciBzaWduaW5nIGtleSByb3RhdGlvbiB8CnwgYGNs" + + "dXN0ZXIgZGVsZXRlIC0tY2x1c3Rlci1pZD1JRGAgfCBSZW1vdmUgSUNNUyByb3cgfCAqKkRFU1RS" + + "VUNUSVZFOiBjb25maXJtIHdpdGggdXNlcioqIHwKCiMjIEZ1bmN0aW9ucwoKfCBDb21tYW5kIHwg" + + "UHVycG9zZSB8IE5vdGVzIHwKfC0tLXwtLS18LS0tfAp8IGBmdW5jdGlvbiBjcmVhdGUgLS1pbnB1" + + "dC1maWxlPUZJTEVgIHwgQ3JlYXRlIGZ1bmN0aW9uIG1ldGFkYXRhIHwgUmV0dXJucyBGdW5jdGlv" + + "biBJRCArIFZlcnNpb24gSUQ7IExMTSBmdW5jdGlvbnMgdXNlIGBmdW5jdGlvblR5cGU6ICJMTE0i" + + "YCBhbmQgYG1vZGVsc1tdLmxsbUNvbmZpZy51cmlzYCBmb3IgYC92MS9jaGF0L2NvbXBsZXRpb25z" + + "YCwgYC92MS9yZXNwb25zZXNgLCBhbmQgYC92MS9lbWJlZGRpbmdzYCB8CnwgYGZ1bmN0aW9uIGxp" + + "c3RgIC8gYGZ1bmN0aW9uIGxpc3QtaWRzYCB8IExpc3QgZnVuY3Rpb25zIC8gSURzIG9ubHkgfCB8" + + "CnwgYGZ1bmN0aW9uIGdldCAtLWZ1bmN0aW9uLWlkPUlEIC0tdmVyc2lvbi1pZD1WSURgIHwgRnVu" + + "Y3Rpb24gbWV0YWRhdGEgfCB8CnwgYGZ1bmN0aW9uIHVwZGF0ZSAtLWZ1bmN0aW9uLWlkPUlEIC0t" + + "dmVyc2lvbi1pZD1WSUQgLS10YWdzPVRBR1ssVEFHXWAgfCBVcGRhdGUgZnVuY3Rpb24gdGFncyB8" + + "IHwKfCBgZnVuY3Rpb24gdXBkYXRlIC0tZnVuY3Rpb24taWQ9SUQgLS12ZXJzaW9uLWlkPVZJRCAt" + + "LWxsbS1tb2RlbC11cGRhdGU9U1BFQ2AgfCBVcGRhdGUgTExNIG1vZGVsIHJvdXRpbmcgY29uZmln" + + "IHwgYFNQRUNgIHVzZXMgYG5hbWU9PG1vZGVsPixyb3V0aW5nTWV0aG9kPTxtZXRob2Q+LHRva2Vu" + + "UmF0ZUxpbWl0PTxsaW1pdD5gOyBhY2NlcHRlZCBtZXRob2RzIGFyZSBsaXN0ZWQgaW4gW2ZsYWdz" + + "Lm1kXShmbGFncy5tZCkgfAp8IGBmdW5jdGlvbiBkZXBsb3kgY3JlYXRlIC0taW5wdXQtZmlsZT1G" + + "SUxFYCB8IFNjaGVkdWxlIGEgZGVwbG95bWVudCB8IEJsb2NrcyB1bnRpbCBBQ1RJVkUgKGRlZmF1" + + "bHQgOTAwcykgfAp8IGBmdW5jdGlvbiBkZXBsb3kgZ2V0IC0tZnVuY3Rpb24taWQ9SUQgLS12ZXJz" + + "aW9uLWlkPVZJRCBbLS1qc29uXWAgfCBEZXBsb3ltZW50IHN0YXR1cyB8IGBmdW5jdGlvblN0YXR1" + + "czogQUNUSVZFXHxERVBMT1lJTkdcfEVSUk9SXHxGQUlMRURgIHwKfCBgZnVuY3Rpb24gZGVwbG95" + + "IHVwZGF0ZSAtLWlucHV0LWZpbGU9RklMRWAgfCBNb2RpZnkgYSBkZXBsb3ltZW50IGluIHBsYWNl" + + "IHwgfAp8IGBmdW5jdGlvbiBkZXBsb3kgcmVtb3ZlIC0tZnVuY3Rpb24taWQ9SUQgLS12ZXJzaW9u" + + "LWlkPVZJRGAgfCBTdG9wIGEgZGVwbG95bWVudCwga2VlcCBmdW5jdGlvbiByZWNvcmQgfCB8Cnwg" + + "YGZ1bmN0aW9uIGludm9rZSAtLWlucHV0LWZpbGU9RklMRWAgfCBDYWxsIGEgcmVndWxhciBmdW5j" + + "dGlvbiB8IFJlcXVpcmVzIEFQSSBrZXkgKG5vdCBhZG1pbiB0b2tlbik7IExMTSBmdW5jdGlvbnMg" + + "YXJlIGludm9rZWQgdGhyb3VnaCBgbGxtLmludm9jYXRpb24uPGRvbWFpbj5gIHdpdGggYG1vZGVs" + + "OiAiPGZ1bmN0aW9uLWlkPi88bW9kZWwtbmFtZT4iYCB8CnwgYGZ1bmN0aW9uIGRlbGV0ZSAtLWZ1" + + "bmN0aW9uLWlkPUlEIC0tdmVyc2lvbi1pZD1WSURgIHwgUmVtb3ZlIGZ1bmN0aW9uICsgZGVwbG95" + + "bWVudCB8ICoqREVTVFJVQ1RJVkU6IGNvbmZpcm0gd2l0aCB1c2VyKiogfAoKIyMgVGFza3MKClRh" + + "c2sgY29tbWFuZHMgcmVxdWlyZSBgTlZDRl9BUElfS0VZYCBzZXQgdG8gYSB0YXNrLXNjb3BlZCBr" + + "ZXkgYW5kIGBOVkNGX0JBU0VfTlZDVF9VUkxgIHNldCB0byB0aGUgTlZDVCBnYXRld2F5IGVuZHBv" + + "aW50LiBJbiBhIGZyZXNoIHNlc3Npb24sIHJlYWQgYG52Y3RBcGlLZXlgIGZyb20gYH4vLm52Y2Yt" + + "Y2xpLnN0YXRlYCBhbmQgaW5qZWN0IGl0IGFzIGBOVkNGX0FQSV9LRVlgIHdpdGhvdXQgbG9nZ2lu" + + "ZyB0aGUgdmFsdWU7IGNoZWNrIGBudmN0QXBpS2V5RXhwaXJhdGlvbmAgZmlyc3QgYW5kIHJlZ2Vu" + + "ZXJhdGUgd2l0aCBgYXBpLWtleSBnZW5lcmF0ZSAtLWZvciB0YXNrIC0tdmFsaWRhdGVgIGlmIGV4" + + "cGlyZWQuIFJ1biBgYXBpLWtleSBnZW5lcmF0ZSAtLWZvciB0YXNrYCBhZnRlciBgaW5pdGAgdG8g" + + "bWludCBhIG5ldyBrZXkuCgp8IENvbW1hbmQgfCBQdXJwb3NlIHwgTm90ZXMgfAp8LS0tfC0tLXwt" + + "LS18CnwgYHRhc2sgY3JlYXRlIC0tbmFtZT1YIC0tZ3B1PUdQVSAtLWluc3RhbmNlLXR5cGU9VFlQ" + + "RSAtLWltYWdlPUlNR2AgfCBTdWJtaXQgYSBjb250YWluZXIgdGFzayB8IFNhdmVzIHRhc2sgSUQg" + + "dG8gQ0xJIHN0YXRlOyB1c2UgYC0taW5wdXQtZmlsZWAgZm9yIHJlcGVhdGFibGUgY29uZmlncyB8" + + "CnwgYHRhc2sgY3JlYXRlIC0tbmFtZT1YIC0tZ3B1PUdQVSAtLWluc3RhbmNlLXR5cGU9VFlQRSAt" + + "LWhlbG0tY2hhcnQ9Q0hBUlRgIHwgU3VibWl0IGEgSGVsbSB0YXNrIHwgYC0taGVsbS1jaGFydGAg" + + "cmVwbGFjZXMgYC0taW1hZ2VgIHwKfCBgdGFzayBjcmVhdGUgLS1pbnB1dC1maWxlPUZJTEVgIHwg" + + "U3VibWl0IGEgdGFzayBmcm9tIGEgSlNPTiBjb25maWcgZmlsZSB8IFJlY29tbWVuZGVkIGZvciBy" + + "ZXBlYXRhYmxlIGNvbmZpZ3VyYXRpb25zIHwKfCBgdGFzayBsaXN0IFstLXN0YXR1cz1TVEFUVVNd" + + "IFstLWxpbWl0PU5dYCB8IExpc3QgdGFza3MsIG9wdGlvbmFsbHkgZmlsdGVyZWQgYnkgc3RhdHVz" + + "IHwgU3RhdHVzZXM6IGBRVUVVRURgLCBgTEFVTkNIRURgLCBgUlVOTklOR2AsIGBDT01QTEVURURg" + + "LCBgRVJST1JFRGAsIGBDQU5DRUxFRGAsIGBFWENFRURFRF9NQVhfUlVOVElNRV9EVVJBVElPTmAs" + + "IGBFWENFRURFRF9NQVhfUVVFVUVEX0RVUkFUSU9OYCB8CnwgYHRhc2sgZ2V0IFt0YXNrSWRdYCB8" + + "IEdldCB0YXNrIGRldGFpbHMgfCBVc2VzIHNhdmVkIHRhc2sgSUQgZnJvbSBzdGF0ZSBpZiBvbWl0" + + "dGVkIHwKfCBgdGFzayBldmVudHMgW3Rhc2tJZF0gWy0tbGltaXQ9Tl1gIHwgTGlzdCBsaWZlY3lj" + + "bGUgZXZlbnRzIGZvciBhIHRhc2sgfCB8CnwgYHRhc2sgcmVzdWx0cyBbdGFza0lkXWAgfCBMaXN0" + + "IHJlc3VsdCBhcnRpZmFjdHMgZm9yIGEgY29tcGxldGVkIHRhc2sgfCBSZXR1cm5zIGVtcHR5IGxp" + + "c3Qgd2hlbiBgcmVzdWx0SGFuZGxpbmdTdHJhdGVneWAgaXMgYE5PTkVgOyByZXN1bHQgdXBsb2Fk" + + "IG5vdCB5ZXQgc3VwcG9ydGVkIHwKfCBgdGFzayBjYW5jZWwgW3Rhc2tJZF1gIHwgQ2FuY2VsIGEg" + + "cnVubmluZyB0YXNrIHwgTm8tb3AgaWYgYWxyZWFkeSBpbiB0ZXJtaW5hbCBzdGF0ZSB8CnwgYHRh" + + "c2sgZGVsZXRlIFt0YXNrSWRdYCB8IERlbGV0ZSBhIHRhc2sgcmVjb3JkIHwgKipTdG9wLCBzdGF0" + + "ZSB0YXNrIElEICsgY3VycmVudCBzdGF0dXMsIGFuZCB3YWl0IGZvciBhIHN1YnNlcXVlbnQgdXNl" + + "ciByZXBseSBleHBsaWNpdGx5IGNvbmZpcm1pbmcgZGVsZXRpb24gb2YgdGhhdCBzcGVjaWZpYyB0" + + "YXNrLiBEbyBub3QgdHJlYXQgdGhlIG9yaWdpbmFsIGRlbGV0ZSByZXF1ZXN0IGFzIGNvbmZpcm1h" + + "dGlvbi4qKiB8CnwgYHRhc2sgdXBkYXRlLXNlY3JldHMgW3Rhc2tJZF0gLS1zZWNyZXRzIE5BTUU9" + + "dmFsdWVgIHwgVXBkYXRlIHNlY3JldHMgb24gYSB0YXNrOyBzdXBwbGllZCBzZWNyZXRzIGFyZSBh" + + "ZGRlZCBvciB1cGRhdGVkIGJ5IG5hbWUsIGV4aXN0aW5nIHNlY3JldHMgbm90IGluIHRoZSByZXF1" + + "ZXN0IGFyZSBwcmVzZXJ2ZWQgfCBWYWx1ZXMgYXJlIGVuY3J5cHRlZCBhdCByZXN0IHwKfCBgdGFz" + + "ayBidWxrIC0tdGFzay1pZHM9SUQxWyxJRDIs4oCmXWAgfCBGZXRjaCBkZXRhaWxzIGZvciBtdWx0" + + "aXBsZSB0YXNrcyBpbiBvbmUgcmVxdWVzdCB8IHwKCiMjIEF1dGgKCnwgQ29tbWFuZCB8IFB1cnBv" + + "c2UgfCBOb3RlcyB8CnwtLS18LS0tfC0tLXwKfCBgaW5pdGAgfCBNaW50IGFkbWluIHRva2VuIGZy" + + "b20gQVBJIEtleXMgdmlhIHB1YmxpYyBhcGkgZ2F0ZXdheSB8IElkZW1wb3RlbnQ7IHdyaXRlcyBg" + + "fi8ubnZjZi1jbGkuc3RhdGVgOyBjbGVhcnMgc2F2ZWQgZnVuY3Rpb24gc3RhdGUgYW5kIGFsbCBB" + + "UEkga2V5cyAoZnVuY3Rpb24gYW5kIHRhc2spIHwKfCBgc3RhdHVzYCB8IFNob3cgQ0xJIHN0YXRl" + + "ICh0b2tlbiwgbGFzdCBlbmRwb2ludHMsIGZ1bmN0aW9uIGNvbnRleHQpIHwgRGlzdGluY3QgZnJv" + + "bSBgc2VsZi1ob3N0ZWQgc3RhdHVzYCB8CnwgYGFwaS1rZXkgZ2VuZXJhdGUgWy0tZm9yIGZ1bmN0" + + "aW9uXHx0YXNrXSBbLS1kZXNjcmlwdGlvbj3igKZdIFstLWV4cGlyZXMtaW494oCmXWAgfCBNaW50" + + "IEFQSSBrZXlzIHwgRGVmYXVsdCAobm8gYC0tZm9yYCk6IGdlbmVyYXRlcyBib3RoIGEgZnVuY3Rp" + + "b24ga2V5IGFuZCBhIHRhc2sga2V5OyBgLS1mb3IgZnVuY3Rpb25gIG9yIGAtLWZvciB0YXNrYCBn" + + "ZW5lcmF0ZXMgb25lIG9ubHk7IGAtLXNjb3Blc2AgcmVxdWlyZXMgYC0tZm9yYCB8CnwgYGFwaS1r" + + "ZXkgZ2VuZXJhdGUgLS12YWxpZGF0ZWAgfCBNaW50IGFuZCBpbW1lZGlhdGVseSB2YWxpZGF0ZSBl" + + "YWNoIGdlbmVyYXRlZCBrZXkgfCBWYWxpZGF0ZXMgZWFjaCBrZXkgYWdhaW5zdCBpdHMgY29ycmVj" + + "dCBhdWRpZW5jZSAoTlZDRiBmb3IgZnVuY3Rpb24ga2V5cywgTlZDVCBmb3IgdGFzayBrZXlzKSB8" + + "CnwgYGFwaS1rZXkgbGlzdGAgfCBMaXN0IEFQSSBrZXlzIGZvciBjdXJyZW50IG93bmVyIHwgTGlz" + + "dHMgTlZDRi1zY29wZWQga2V5cyBvbmx5IHwKfCBgYXBpLWtleSBkZWxldGUgS0VZLUlEYCAvIGBh" + + "cGkta2V5IHJldm9rZSBLRVktSURgIHwgUmVtb3ZlIGFuIEFQSSBrZXkgfCAqKkNvbmZpcm0gd2l0" + + "aCB1c2VyKiogfAp8IGBhcGkta2V5IHNob3dgIHwgU2hvdyBjdXJyZW50bHkgc2F2ZWQgQVBJIGtl" + + "eSBmcm9tIHN0YXRlIHwgfAoKIyMgQWdlbnQgc2tpbGwKCnwgQ29tbWFuZCB8IFB1cnBvc2UgfCBO" + + "b3RlcyB8CnwtLS18LS0tfC0tLXwKfCBgYWdlbnQtc2tpbGwgaW5zdGFsbCBbLS10YXJnZXQ9RElS" + + "XWAgfCBJbnN0YWxsIGFsbCBidW5kbGVkIHB1YmxpYyB1c2VyIHNraWxscyBpbnRvIGB+Ly5jbGF1" + + "ZGUvc2tpbGxzL2AgYW5kIGB+Ly5hZ2VudHMvc2tpbGxzL2AgfCBEZWZhdWx0OiBib3RoIGJhc2Ug" + + "c2tpbGxzIGRpcmVjdG9yaWVzIHwKfCBgYWdlbnQtc2tpbGwgdW5pbnN0YWxsIFstLXRhcmdldD1E" + + "SVJdYCB8IFJlbW92ZSBvbmx5IGJ1bmRsZWQgcHVibGljIHVzZXIgc2tpbGxzIGZyb20gdGhlIHRh" + + "cmdldCBiYXNlIHNraWxscyBkaXJlY3RvcmllcyB8IElkZW1wb3RlbnQ7IHVucmVsYXRlZCBza2ls" + + "bHMgcmVtYWluIHwKfCBgYWdlbnQtc2tpbGwgc2hvdyBbLS1maWxlPVJFTF1gIHwgUHJpbnQgYnVu" + + "ZGxlZCBgbnZjZi1zZWxmLW1hbmFnZWQtY2xpL1NLSUxMLm1kYCBvciBhbm90aGVyIGVtYmVkZGVk" + + "IGZpbGUgfCBGb3IgZGVidWdnaW5nIHwKfCBgYWdlbnQtc2tpbGwgdmVyc2lvbmAgfCBQcmludCBi" + + "dWlsZCBTSEEgYW5kIGVtYmVkZGVkIHB1YmxpYyB1c2VyIHNraWxsIHN1bW1hcnkgfCB8ClBLBwhy" + + "DQ9kISMAACEjAABQSwMEFAAIAAAAAAAhAAAAAAAAAAAAAAAAADIACQBkYXRhL252Y2Ytc2VsZi1t" + + "YW5hZ2VkLWNsaS9yZWZlcmVuY2UvZXhpdC1jb2Rlcy5tZFVUBQABAKbOEiMgYG52Y2YtY2xpYCBl" + + "eGl0IGNvZGVzCgpTdGFibGUgYWNyb3NzIHN1YmNvbW1hbmRzLiBVc2UgdGhlc2UgdG8gZHJpdmUg" + + "YWdlbnQgcmV0cnkgLyBzdXJmYWNpbmcgbG9naWMuCgp8IENvZGUgfCBNZWFuaW5nIHwgRXhhbXBs" + + "ZSBjYXVzZXMgfAp8LS0tfC0tLXwtLS18CnwgYDBgIHwgU3VjY2VzcyB8IEFsbCBjaGVja3MgcGFz" + + "c2VkOyBpbnN0YWxsIGNvbXBsZXRlZDsgZGVwbG95bWVudCBBQ1RJVkUgfAp8IGAxYCB8IEdlbmVy" + + "aWMgZXJyb3IgfCBIZWxtIHJlbmRlciBmYWlsZWQ7IG5ldHdvcmsgdW5yZWFjaGFibGU7IGZpbGUg" + + "bm90IGZvdW5kOyBZQU1MIHBhcnNlIGVycm9yIHwKfCBgMmAgfCBQcmUtZmxpZ2h0IGNoZWNrIGZh" + + "aWxlZCB8IEdhdGV3YXkgQVBJIENSRHMgbWlzc2luZzsga3ViZWN0bCBub3Qgb24gUEFUSDsgZGVm" + + "YXVsdCBTdG9yYWdlQ2xhc3MgYWJzZW50IHwKfCBgM2AgfCBBZG1pbiBhdXRoIGZhaWxlZCB8IE5v" + + "IHRva2VuICsgYC0tbm9uLWludGVyYWN0aXZlYCBzZXQ7IElDTVMgcmVqZWN0ZWQgSldUOyBpbml0" + + "IGVuZHBvaW50IHVucmVhY2hhYmxlIHwKfCBgNWAgfCBNYW5pZmVzdCBhcHBseSBvciBgLS13YWl0" + + "YCB0aW1lZCBvdXQgfCBIZWxtIGluc3RhbGwgdGltZW91dDsgY2hlY2sgcG9sbGVkIGJ1dCBkaWRu" + + "J3QgcGFzcyBiZWZvcmUgZHVyYXRpb24gfAp8IGAxMzBgIHwgQ2FuY2VsbGVkIGJ5IFNJR0lOVC9T" + + "SUdURVJNIHwgVXNlciBDdHJsLUM7IENJIGJ1ZGdldCBleGNlZWRlZDsgcG9kIGV2aWN0ZWQgfAoK" + + "IyMgSG93IGFuIGFnZW50IHNob3VsZCByZWFjdAoKfCBDb2RlIHwgQWdlbnQgYmVoYXZpb3IgfAp8" + + "LS0tfC0tLXwKfCBgMGAgfCBDb250aW51ZSAvIHJlcG9ydCBzdWNjZXNzLiB8CnwgYDFgIHwgU3Vy" + + "ZmFjZSBzdGRlcnIgdG8gdXNlcjsgYXNrIGJlZm9yZSBhbnkgcmV0cnkuIEdlbmVyaWMgZXJyb3Jz" + + "IHVzdWFsbHkgbmVlZCBhIGh1bWFuIHRvIHJlYWQgdGhlIG1lc3NhZ2UuIHwKfCBgMmAgfCBTdXJm" + + "YWNlIGZhaWxlZCBjaGVja3MgKyB0aGVpciBgaGludFVSTGAuIERvbid0IHByb3Bvc2UgYHVwYCB1" + + "bnRpbCB0aGUgdXNlciBmaXhlcyBwcmVyZXFzLiB8CnwgYDNgIHwgU3VnZ2VzdCBgbnZjZi1jbGkg" + + "aW5pdGAgKGludGVyYWN0aXZlKSBPUiBgLS10b2tlbj0kSldUYCAoQ0kpLiBEb24ndCBhdXRvLW1p" + + "bnQgd2l0aG91dCB1c2VyIE9LLiB8CnwgYDVgIHwgQXNrIHVzZXIgaWYgdGhleSB3YW50IHRvIHdh" + + "aXQgbG9uZ2VyLCBkaWcgaW50byB0aGUgc3RhbGxlZCBjb21wb25lbnQsIG9yIGNhbmNlbC4gfAp8" + + "IGAxMzBgIHwgRG9uJ3QgcmV0cnkgYXV0b21hdGljYWxseTsgdXNlciBleHBsaWNpdGx5IGNhbmNl" + + "bGxlZC4gQ29uZmlybSBiZWZvcmUgcmUtcnVubmluZy4gfAoKIyMgV2hlcmUgdG8gZmluZCBtb3Jl" + + "IGRldGFpbAoKRXZlcnkgbm9uLXplcm8gZXhpdCBlbWl0cyBhIHN0cnVjdHVyZWQgYHBoYXNlX2Zh" + + "aWxlZGAgSlNPTiBldmVudCB3aXRoIGBlcnJDYXRlZ29yeWAsIGBlcnJNZXNzYWdlYCwgYHJlbWVk" + + "aWF0aW9uYCAoYXJyYXkpLCBgcmV0cnlDbGFzc2AgKGVudW06IGBub25lfGltbWVkaWF0ZXxiYWNr" + + "b2ZmfGFmdGVyX3JlbWVkaWF0aW9ufHVua25vd25gKSwgYHJldHJ5QWZ0ZXJTZWNgIChpbnQsIG9w" + + "dGlvbmFsKSwgYW5kIGByYXdgIChzdWJwcm9jZXNzICsgSFRUUCArIEt1YmVybmV0ZXMgc2lnbmFs" + + "KS4gQWx3YXlzIGNvbnN1bWUgdGhlc2UgaW4gYC0tanNvbmAgbW9kZSByYXRoZXIgdGhhbiBwYXJz" + + "aW5nIEVuZ2xpc2ggZnJvbSBzdGRlcnIuClBLBwhzp1pk1QYAANUGAABQSwMEFAAIAAAAAAAhAAAA" + + "AAAAAAAAAAAAAC0ACQBkYXRhL252Y2Ytc2VsZi1tYW5hZ2VkLWNsaS9yZWZlcmVuY2UvZmxhZ3Mu" + + "bWRVVAUAAQCmzhIjIGBudmNmLWNsaWAgZmxhZyByZWZlcmVuY2UKCiMjIEdsb2JhbCBmbGFncyAo" + + "ZXZlcnkgc3ViY29tbWFuZCkKCnwgRmxhZyB8IFB1cnBvc2UgfCBEZWZhdWx0IHwKfC0tLXwtLS18" + + "LS0tfAp8IGAtLWNvbmZpZyBGSUxFYCB8IENvbmZpZyBmaWxlIHBhdGggfCBgJEhPTUUvLm52Y2Yt" + + "Y2xpLnlhbWxgIHwKfCBgLS1kZWJ1Z2AgfCBWZXJib3NlIEhUVFAgbG9nZ2luZyBvbiBzdGRlcnIg" + + "fCBgZmFsc2VgIHwKfCBgLS1qc29uYCB8IEpTT05MIGV2ZW50cyBvbiBzdGRlcnIgfCBhdXRvIChv" + + "ZmYgaW4gVFRZLCBvbiB1bmRlciBgLS1ub24taW50ZXJhY3RpdmVgKSB8CgojIyBgc2VsZi1ob3N0" + + "ZWRgIHBhcmVudCAocGVyc2lzdGVudCBhY3Jvc3Mgc3ViY29tbWFuZHMpCgp8IEZsYWcgfCBQdXJw" + + "b3NlIHwgRGVmYXVsdCB8CnwtLS18LS0tfC0tLXwKfCBgLS1jb250cm9sLXBsYW5lLXN0YWNrPeKA" + + "pmAgfCBDb250cm9sLXBsYW5lIGJ1bmRsZSBzb3VyY2U6IGxvY2FsIHBhdGgsIGdpdCBVUkwsIG9y" + + "IGBvY2k6Ly9gIFVSTCB8IGVtYmVkZGVkIE9DSSBVUkwgcGlubmVkIGJ5IENMSSB2ZXJzaW9uIHwK" + + "fCBgLS1jb21wdXRlLXBsYW5lLXN0YWNrPeKApmAgfCBDb21wdXRlLXBsYW5lIGJ1bmRsZSBzb3Vy" + + "Y2U6IGxvY2FsIHBhdGgsIGdpdCBVUkwsIG9yIGBvY2k6Ly9gIFVSTCB8IGVtYmVkZGVkIE9DSSBV" + + "UkwgcGlubmVkIGJ5IENMSSB2ZXJzaW9uIHwKfCBgLS1lbnY9bG9jYWxcfHByZFx84oCmYCB8IEhl" + + "bG1maWxlIGVudmlyb25tZW50IG5hbWUgfCBgbG9jYWxgIGZvciBkZXYgYnVpbGRzLCBgcHJkYCBm" + + "b3IgcmVsZWFzZXMgfAp8IGAtLW5vbi1pbnRlcmFjdGl2ZWAgfCBEaXNhYmxlIGFsbCBzdGRpbiBw" + + "cm9tcHRzIHwgYGZhbHNlYCB8CnwgYC0tdG9rZW49JEpXVGAgfCBBZG1pbiBKV1QsIG92ZXJyaWRl" + + "cyBzdG9yZWQgc2Vzc2lvbiB8IC0gfAp8IGAtLW5vLWFwcGx5YCB8IGBpbnN0YWxsYCBvbmx5IC0g" + + "ZW1pdCBZQU1MLCBkbyBub3Qga3ViZWN0bCBhcHBseSB8IGBmYWxzZWAgfAp8IGAtLW91dHB1dD10" + + "ZXh0XHxqc29uYCB8IExlZ2FjeSBhbGlhcyBmb3IgYC0tanNvbmAgKGRlcHJlY2F0ZWQsIHJlbW92" + + "ZWQgaW4gbmV4dCBtYWpvcikgfCBgdGV4dGAgfAp8IGAtLXBsYWluYCB8IEZvcmNlIHBsYWluIHN0" + + "cmVhbWluZyBvdXRwdXQgfCBhdXRvLWRldGVjdCB8CnwgYC0td2FpdCBEVVJBVElPTmAgfCBgY2hl" + + "Y2tgIG9ubHk7IGJsb2NrIHVudGlsIHBhc3MgfCAtIHwKfCBgLS1jb250cm9sLXBsYW5lLWNvbnRl" + + "eHQgQ1RYYCB8IGt1YmVjdGwgY29udGV4dCBmb3IgY29udHJvbCBwbGFuZSAoUkVRLTIwKSB8IGN1" + + "cnJlbnQgY29udGV4dCB8CnwgYC0tY29tcHV0ZS1wbGFuZS1jb250ZXh0IENUWGAgfCBrdWJlY3Rs" + + "IGNvbnRleHQgZm9yIGNvbXB1dGUgcGxhbmUgKFJFUS0yMCkgfCBjdXJyZW50IGNvbnRleHQgfAp8" + + "IGAtLWljbXMtdXJsIFVSTGAgfCBQdWJsaWMgSUNNUyBVUkw7IHJlcXVpcmVkIHdoZW4gY29udGV4" + + "dHMgZGlmZmVyIHwgZGVyaXZlZCBmcm9tIGBiYXNlX2h0dHBfdXJsYCB8CnwgYC0tbG9jYWwtb25s" + + "eWAgfCBgY2hlY2sgLS1wcmVgIG9ubHk7IHNraXAgYWxsIGt1YmVjdGwgY29udGFjdCB8IGBmYWxz" + + "ZWAgfAoKIyMgYHVwYC1zcGVjaWZpYwoKfCBGbGFnIHwgUHVycG9zZSB8IERlZmF1bHQgfAp8LS0t" + + "fC0tLXwtLS18CnwgYC0tY2x1c3Rlci1uYW1lIE5BTUVgIHwgSUNNUyBjbHVzdGVyIHJvdyBpZGVu" + + "dGlmaWVyIChyZXF1aXJlZCkgfCAtIHwKfCBgLS1uY2EtaWQgSURgIHwgTkNBIGFjY291bnQgSUQg" + + "fCBgbnZjZi1kZWZhdWx0YCB8CnwgYC0tcmVnaW9uIFJFR0lPTmAgfCBDbHVzdGVyIHJlZ2lvbiB8" + + "IGB1cy13ZXN0LTFgIHwKfCBgLS1wbGFuLW9ubHlgIHwgRHJ5LXJ1bjsgZW1pdCBwaGFzZSBwbGFu" + + "ICsgRVRBcyB3aXRob3V0IGNoYW5nZXMgfCBgZmFsc2VgIHwKCiMjIGBzdGF0dXNgLXNwZWNpZmlj" + + "Cgp8IEZsYWcgfCBQdXJwb3NlIHwgRGVmYXVsdCB8CnwtLS18LS0tfC0tLXwKfCBgLS1jbHVzdGVy" + + "LW5hbWUgTkFNRWAgfCBMaW1pdCB0byBvbmUgY29tcHV0ZSBwbGFuZSB8IC0gKGNvbnRyb2wgKyBh" + + "bGwgY2x1c3RlcnMpIHwKfCBgLS13YXRjaGAgfCBMaXZlIHJlLXJlbmRlciB8IGBmYWxzZWAgfAp8" + + "IGAtLXdhdGNoLWludGVydmFsIERVUmAgfCBgLS13YXRjaGAgY2FkZW5jZSB8IGA1c2AgfAp8IGAt" + + "LWNvbXBvbmVudCBOQU1FYCB8IEZpbHRlciBjb21wb25lbnRzIHBhbmVsIHwgYWxsIHwKfCBgLS1u" + + "by1ldmVudHNgIHwgU2tpcCBldmVudHMgcGFuZWwgfCBgZmFsc2VgIHwKCiMjIGBjbHVzdGVyIHJl" + + "Z2lzdGVyYC1zcGVjaWZpYwoKfCBGbGFnIHwgUHVycG9zZSB8IERlZmF1bHQgfAp8LS0tfC0tLXwt" + + "LS18CnwgYC0tbmFtZSBOQU1FYCB8IENsdXN0ZXIgbmFtZSAocmVxdWlyZWQpIHwgLSB8CnwgYC0t" + + "bmNhLWlkIElEYCB8IE5DQSBJRCAocmVxdWlyZWQpIHwgLSB8CnwgYC0tcmVnaW9uIFJFR0lPTmAg" + + "fCBSZWdpb24gfCBgdXMtd2VzdC0xYCB8CnwgYC0taWNtcy11cmwgVVJMYCB8IElDTVMgZW5kcG9p" + + "bnQgfCBmcm9tIGNvbmZpZyB8CnwgYC0taWdub3JlLWV4aXN0aW5nYCB8IE1hdGNoLW9yLWNyZWF0" + + "ZSBpbnN0ZWFkIG9mIGZhaWwtb24tZXhpc3RzIHwgYGZhbHNlYCB8CgojIyBgYXBpLWtleSBnZW5l" + + "cmF0ZWAtc3BlY2lmaWMKCnwgRmxhZyB8IFB1cnBvc2UgfCBEZWZhdWx0IHwKfC0tLXwtLS18LS0t" + + "fAp8IGAtLWZvciBmdW5jdGlvblx8dGFza2AgfCBHZW5lcmF0ZSBvbmx5IHRoZSBzcGVjaWZpZWQg" + + "a2V5IHR5cGUgfCAob21pdCB0byBnZW5lcmF0ZSBib3RoKSB8CnwgYC0tZGVzY3JpcHRpb24gVEVY" + + "VGAgfCBIdW1hbi1yZWFkYWJsZSBsYWJlbCBmb3IgdGhlIGtleSB8IGBHZW5lcmF0ZWQgYnkgbnZj" + + "Zi1jbGlgIHwKfCBgLS1leHBpcmVzLWluIERVUkFUSU9OYCB8IEV4cGlyeSBvZmZzZXQgKGUuZy4g" + + "YDI0aGAsIGA3ZGApOyBwYXJzZWQgYXMgZXh0ZW5kZWQgZHVyYXRpb24gfCBgMjRoYCB8CnwgYC0t" + + "c2NvcGVzIFNDT1BFWyxTQ09QRV1gIHwgT3ZlcnJpZGUgZGVmYXVsdCBzY29wZXM7IHJlcXVpcmVz" + + "IGAtLWZvcmAgfCAoc2VydmljZSBkZWZhdWx0cykgfAp8IGAtLXZhbGlkYXRlYCB8IFZhbGlkYXRl" + + "IGVhY2ggZ2VuZXJhdGVkIGtleSBpbW1lZGlhdGVseSBhZnRlciBtaW50aW5nIHwgYGZhbHNlYCB8" + + "CgpFeHRlbmRlZCBkdXJhdGlvbiB1bml0czogYHNgIChzZWNvbmRzKSwgYG1gIChtaW51dGVzKSwg" + + "YGhgIChob3VycyksIGBkYCAoZGF5cyksIGB3YCAod2Vla3MpLgoKIyMgYGZ1bmN0aW9uIGNyZWF0" + + "ZWAtc3BlY2lmaWMKCmAtLWlucHV0LWZpbGUgRklMRWAgaXMgcmVjb21tZW5kZWQgZm9yIHJlcGVh" + + "dGFibGUgZnVuY3Rpb24gZGVmaW5pdGlvbnMuIEZvciBhZC1ob2MgY3JlYXRlczoKCnwgRmxhZyB8" + + "IFB1cnBvc2UgfCBEZWZhdWx0IHwKfC0tLXwtLS18LS0tfAp8IGAtLW5hbWUgTkFNRWAgfCBGdW5j" + + "dGlvbiBuYW1lIHwgLSB8CnwgYC0taW1hZ2UgSU1BR0VgIHwgQ29udGFpbmVyIGltYWdlIHwgLSB8" + + "CnwgYC0taW5mZXJlbmNlLXVybCBVUklgIHwgQ29udGFpbmVyIGluZmVyZW5jZSBlbmRwb2ludCB8" + + "IC0gfAp8IGAtLWluZmVyZW5jZS1wb3J0IFBPUlRgIHwgQ29udGFpbmVyIGluZmVyZW5jZSBwb3J0" + + "IHwgLSB8CnwgYC0tZnVuY3Rpb24tdHlwZSBERUZBVUxUXHxTVFJFQU1JTkdcfExMTWAgfCBGdW5j" + + "dGlvbiB0eXBlIHwgYERFRkFVTFRgIHwKfCBgLS1oZWxtLWNoYXJ0IENIQVJUYCB8IEhlbG0gY2hh" + + "cnQgVVJMIG9yIE9DSSByZWZlcmVuY2UuIENhbiBiZSB1c2VkIHdpdGggYC0tZnVuY3Rpb24tdHlw" + + "ZT1MTE1gIGZvciBjaGFydC1wYWNrYWdlZCBMTE0gd29ya2xvYWRzLiB8IC0gfAp8IGAtLWhlbG0t" + + "Y2hhcnQtc2VydmljZSBOQU1FYCB8IEt1YmVybmV0ZXMgU2VydmljZSBuYW1lIGV4cG9zZWQgYnkg" + + "dGhlIGNoYXJ0LiBSZXF1aXJlZCB3aGVuIGAtLWhlbG0tY2hhcnRgIGlzIHNldC4gfCAtIHwKfCBg" + + "LS1tb2RlbHMgTkFNRTpWRVJTSU9OOlVSSWAgfCBTdGFuZGFyZCBtb2RlbCBhcnRpZmFjdDsgcmVw" + + "ZWF0YWJsZSB8IC0gfAp8IGAtLWxsbS1tb2RlbCBTUEVDYCB8IExMTSBtb2RlbCBjb25maWc7IGZv" + + "cm1hdCBgbmFtZT08bW9kZWw+LHVyaXM9PHVyaT5cfDx1cmk+LHJvdXRpbmdNZXRob2Q9PG1ldGhv" + + "ZD4sdG9rZW5SYXRlTGltaXQ9PGxpbWl0PmA7IHJlcGVhdGFibGUuIFRva2VuIGxpbWl0cyB1c2Ug" + + "YDx2YWx1ZT4tPHVuaXQ+YCB3aXRoIGBTYCwgYE1gLCBgSGAsIGBEYCwgb3IgYFdgLCBmb3IgZXhh" + + "bXBsZSBgMTAwMC1TYC4gVXNlIGlucHV0IEpTT04gZm9yIGNvbWJpbmVkIHRva2VuIGxpbWl0cyBi" + + "ZWNhdXNlIGlubGluZSBzcGVjcyB1c2UgY29tbWFzIGFzIGZpZWxkIHNlcGFyYXRvcnMuIHwgLSB8" + + "CgpJbiBKU09OIGFuZCBpbmxpbmUgc3BlY3MsIExMTSBmdW5jdGlvbnMgc2V0IGBmdW5jdGlvblR5" + + "cGU6ICJMTE0iYCBhbmQgbW9kZWwgcm91dGluZyBtZXRhZGF0YSB1bmRlciBgbW9kZWxzW10ubGxt" + + "Q29uZmlnYC4gYGxsbUNvbmZpZy51cmlzYCBkZWNsYXJlcyB0aGUgT3BlbkFJLWNvbXBhdGlibGUg" + + "dXBzdHJlYW0gcGF0aHMgZXhwb3NlZCBieSB0aGUgbW9kZWwuIEN1cnJlbnQgc3VwcG9ydGVkIHBh" + + "dGhzIGFyZSBgL3YxL2NoYXQvY29tcGxldGlvbnNgLCBgL3YxL3Jlc3BvbnNlc2AsIGFuZCBgL3Yx" + + "L2VtYmVkZGluZ3NgLiBgbGxtQ29uZmlnLnJvdXRpbmdNZXRob2RgIGFjY2VwdHMgYHJvdW5kX3Jv" + + "YmluYCwgYHBvd2VyX29mX3R3b2AsIGBncm9xX211bHRpcmVnaW9uYCwgYHB1bHNhcmAsIG9yIGBy" + + "YW5kb21gLgpgbGxtQ29uZmlnLnRva2VuUmF0ZUxpbWl0YCBhY2NlcHRzIG9uZSBvciBtb3JlIGNv" + + "bW1hLXNlcGFyYXRlZCBwb3NpdGl2ZSBpbnRlZ2VyIHRva2VuIGxpbWl0cyBpbiBgPHZhbHVlPi08" + + "dW5pdD5gIGZvcm1hdC4gU3VwcG9ydGVkIHVuaXRzIGFyZSBgU2AgKHNlY29uZHMpLCBgTWAgKG1p" + + "bnV0ZXMpLCBgSGAgKGhvdXJzKSwgYERgIChkYXlzKSwgYW5kIGBXYCAod2Vla3MpLiBVc2UgZGlz" + + "dGluY3QgdW5pdHMgd2hlbiBjb21iaW5pbmcgbGltaXRzLCBmb3IgZXhhbXBsZSBgMTAwMC1TLDUw" + + "MDAtTSwxMDAwMDAtSCw1MDAwMDAtRCwxMDAwMDAwLVdgIGluIGlucHV0IEpTT04uCgpIZWxtIGNo" + + "YXJ0IHBhY2thZ2luZyBpcyBpbmRlcGVuZGVudCBvZiBgZnVuY3Rpb25UeXBlYC4gRm9yIGEgSGVs" + + "bS1jaGFydCBiYWNrZWQgTExNIGZ1bmN0aW9uLCBzZXQgYGZ1bmN0aW9uVHlwZTogIkxMTSJgLCBg" + + "aGVsbUNoYXJ0YCwgYGhlbG1DaGFydFNlcnZpY2VOYW1lYCwgYW5kIGBtb2RlbHNbXS5sbG1Db25m" + + "aWdgIGluIHRoZSBzYW1lIGNyZWF0ZSByZXF1ZXN0LiBgaW5mZXJlbmNlUG9ydGAgbXVzdCBiZSB0" + + "aGUgS3ViZXJuZXRlcyBTZXJ2aWNlIHBvcnQgZXhwb3NlZCBieSBgaGVsbUNoYXJ0U2VydmljZU5h" + + "bWVgLgoKTExNIGludm9jYXRpb24gcmVxdWVzdHMgdXNlIGBtb2RlbDogIjxmdW5jdGlvbi1pZD4v" + + "PG1vZGVsLW5hbWU+ImAuIFRoZSBmdW5jdGlvbiBJRCBzZWxlY3RzIHRoZSBOVkNGIGZ1bmN0aW9u" + + "LCBhbmQgdGhlIG1vZGVsIG5hbWUgaXMgZm9yd2FyZGVkIHVwc3RyZWFtLiBDaGF0IGNvbXBsZXRp" + + "b25zIGFuZCBSZXNwb25zZXMgQVBJIHJlcXVlc3RzIGNhbiB1c2UgYHgtbXVsdGktdHVybi1zZXNz" + + "aW9uLWlkYCBmb3Igc2Vzc2lvbiBzdGlja2luZXNzOyBlbWJlZGRpbmdzIHJlcXVlc3RzIGRvIG5v" + + "dC4KCiMjIGBmdW5jdGlvbiB1cGRhdGVgLXNwZWNpZmljCgp8IEZsYWcgfCBQdXJwb3NlIHwgRGVm" + + "YXVsdCB8CnwtLS18LS0tfC0tLXwKfCBgLS10YWdzIFRBR1ssVEFHXWAgfCBSZXBsYWNlIGZ1bmN0" + + "aW9uIHRhZ3MgfCAtIHwKfCBgLS1sbG0tbW9kZWwtdXBkYXRlIFNQRUNgIHwgTExNIG1vZGVsIHVw" + + "ZGF0ZTsgZm9ybWF0IGBuYW1lPTxtb2RlbD4scm91dGluZ01ldGhvZD08bWV0aG9kPix0b2tlblJh" + + "dGVMaW1pdD08bGltaXQ+YDsgcmVwZWF0YWJsZS4gUm91dGluZyBtZXRob2RzIG1hdGNoIGAtLWxs" + + "bS1tb2RlbGAuIFRva2VuIGxpbWl0IGV4YW1wbGU6IGAxMDAwLVNgLiBVc2UgaW5wdXQgSlNPTiBm" + + "b3IgY29tYmluZWQgdG9rZW4gbGltaXRzLiB8IC0gfAoKSW4gSlNPTiwgYGZ1bmN0aW9uIHVwZGF0" + + "ZWAgYWNjZXB0cyBgbW9kZWxVcGRhdGVzW11gIGVudHJpZXMgd2l0aCBgbW9kZWxOYW1lYCBhbmQg" + + "YGxsbUNvbmZpZy5yb3V0aW5nTWV0aG9kYCBhbmQvb3IgYGxsbUNvbmZpZy50b2tlblJhdGVMaW1p" + + "dGAuIGB1cmlzYCBhcmUgY3JlYXRlLXRpbWUgbW9kZWwgbWV0YWRhdGEgYW5kIGFyZSBub3QgcGFy" + + "dCBvZiBtb2RlbCB1cGRhdGVzLgoKIyMgYGZ1bmN0aW9uIGRlcGxveSBjcmVhdGVgLXNwZWNpZmlj" + + "CgpgLS1pbnB1dC1maWxlIEZJTEVgIGlzIHJlY29tbWVuZGVkIChmdWxsIEpTT04gc3BlYykuIEZv" + + "ciBhZC1ob2Mgb25lLXNob3QgdXNlOgoKfCBGbGFnIHwgUHVycG9zZSB8IERlZmF1bHQgfAp8LS0t" + + "fC0tLXwtLS18CnwgYC0tZnVuY3Rpb24taWQgSURgIHwgRnVuY3Rpb24gSUQgKHJlcXVpcmVkKSB8" + + "IC0gfAp8IGAtLWdwdSBOQU1FYCB8IEdQVSBmYW1pbHkgfCBgSDEwMGAgfAp8IGAtLWluc3RhbmNl" + + "LXR5cGUgVFlQRWAgfCBTS1UgfCBgTkNQLkdQVS5IMTAwXzF4YCB8CnwgYC0tbWluLWluc3RhbmNl" + + "cyBOYCB8IE1pbiByZXBsaWNhcyB8IGAxYCB8CnwgYC0tbWF4LWluc3RhbmNlcyBOYCB8IE1heCBy" + + "ZXBsaWNhcyB8IGAxYCB8CnwgYC0tbWF4LXJlcXVlc3QtY29uY3VycmVuY3kgTmAgfCBDb25jdXJy" + + "ZW5jeSB8IGAwYCAodW5zZXQ7IHNlcnZlciBkZWZhdWx0IGFwcGxpZXMpIHwKfCBgLS1jbHVzdGVy" + + "cyBOQU1FWyxOQU1FXWAgfCBUYXJnZXQgc3BlY2lmaWMgY29tcHV0ZSBjbHVzdGVycyB8IChhbnkg" + + "bWF0Y2hpbmcgU0tVKSB8CgojIyBgdGFzayBjcmVhdGVgLXNwZWNpZmljCgpgLS1pbnB1dC1maWxl" + + "IEZJTEVgIGlzIHJlY29tbWVuZGVkIGZvciByZXBlYXRhYmxlIHRhc2sgZGVmaW5pdGlvbnMuIEZv" + + "ciBhZC1ob2MgdXNlOgoKfCBGbGFnIHwgUHVycG9zZSB8IE5vdGVzIHwKfC0tLXwtLS18LS0tfAp8" + + "IGAtLW5hbWUgTkFNRWAgfCBUYXNrIG5hbWUgKHJlcXVpcmVkKSB8IDEtMTI4IGNoYXJzLCBgXlth" + + "LXowLTlBLVpdW2EtejAtOUEtWlwtX10qJGAgfAp8IGAtLWdwdSBHUFVgIHwgR1BVIG5hbWUgKHJl" + + "cXVpcmVkIHdpdGhvdXQgYC0taW5wdXQtZmlsZWApIHwgRXhhbXBsZTogYEgxMDBgIHwKfCBgLS1p" + + "bnN0YW5jZS10eXBlIFRZUEVgIHwgSW5zdGFuY2UgdHlwZSAocmVxdWlyZWQgd2l0aG91dCBgLS1p" + + "bnB1dC1maWxlYCkgfCBFeGFtcGxlOiBgTkNQLkdQVS5IMTAwXzF4YCB8CnwgYC0taW1hZ2UgSU1B" + + "R0VgIHwgQ29udGFpbmVyIGltYWdlIHwgTXV0dWFsbHkgZXhjbHVzaXZlIHdpdGggYC0taGVsbS1j" + + "aGFydGAgfAp8IGAtLWhlbG0tY2hhcnQgQ0hBUlRgIHwgSGVsbSBjaGFydCBVUkwgb3IgT0NJIHJl" + + "ZmVyZW5jZSB8IE11dHVhbGx5IGV4Y2x1c2l2ZSB3aXRoIGAtLWltYWdlYCB8CnwgYC0taW5wdXQt" + + "ZmlsZSBGSUxFYCB8IEpTT04gdGFzayBzcGVjIGZpbGUgfCBDTEkgZmxhZ3Mgb3ZlcnJpZGUgSlNP" + + "TiB2YWx1ZXMgd2hlbiBib3RoIGFyZSBzZXQgfAp8IGAtLWJhY2tlbmQgQkFDS0VORGAgfCBCYWNr" + + "ZW5kIC8gQ1NQIHwgLSB8CnwgYC0tY2x1c3RlcnMgTkFNRVssTkFNRV1gIHwgU3BlY2lmaWMgY2x1" + + "c3RlcnMgd2l0aGluIHRoZSBpbnN0YW5jZSB8IENvbW1hLXNlcGFyYXRlZCB8CnwgYC0tY29udGFp" + + "bmVyLWFyZ3MgQVJHU2AgfCBBcmdzIHBhc3NlZCB3aGVuIGxhdW5jaGluZyB0aGUgY29udGFpbmVy" + + "IHwgU2luZ2xlIHN0cmluZywgZS5nLiBgIi0tZXBvY2hzIDEwIC0tYmF0Y2gtc2l6ZSAzMiJgIHwK" + + "fCBgLS1jb250YWluZXItZW52IE5BTUU9dmFsdWVgIHwgQ29udGFpbmVyIGVudmlyb25tZW50IHZh" + + "cmlhYmxlOyByZXBlYXRhYmxlIHwgLSB8CnwgYC0tc2VjcmV0cyBOQU1FPXZhbHVlYCB8IFNlY3Jl" + + "dCBlbnZpcm9ubWVudCB2YXJpYWJsZTsgcmVwZWF0YWJsZTsgZW5jcnlwdGVkIGF0IHJlc3QgfCAt" + + "IHwKfCBgLS1tYXgtcnVudGltZSBEVVJBVElPTmAgfCBNYXggd2FsbC1jbG9jayBydW4gdGltZSAo" + + "SVNPIDg2MDEsIGUuZy4gYFBUNEhgKSB8IE5vIGRlZmF1bHQ7IG9taXQgZm9yIG5vIHRpbWUgbGlt" + + "aXQgfAp8IGAtLW1heC1xdWV1ZWQgRFVSQVRJT05gIHwgTWF4IHRpbWUgaW4gcXVldWUgYmVmb3Jl" + + "IGNhbmNlbGxhdGlvbiAoSVNPIDg2MDEpIHwgU2VydmVyIGRlZmF1bHQgYFBUNzJIYCB8CnwgYC0t" + + "dGVybWluYXRpb24tZ3JhY2UgRFVSQVRJT05gIHwgR3JhY2UgcGVyaW9kIGFmdGVyIHN0b3Agc2ln" + + "bmFsIChJU08gODYwMSkgfCBTZXJ2ZXIgZGVmYXVsdCBgUFQxSGAgfAp8IGAtLXJlc3VsdC1zdHJh" + + "dGVneSBVUExPQURcfE5PTkVgIHwgSG93IHRvIGhhbmRsZSB0YXNrIG91dHB1dCBhcnRpZmFjdHMg" + + "fCAtIHwKfCBgLS1yZXN1bHRzLWxvY2F0aW9uIExPQ0FUSU9OYCB8IFJlc3VsdCB1cGxvYWQgdGFy" + + "Z2V0LCBmb3JtYXQgYG9yZy1uYW1lL1t0ZWFtLW5hbWUvXW1vZGVsLW5hbWVgOyByZXF1aXJlZCB3" + + "aGVuIGAtLXJlc3VsdC1zdHJhdGVneT1VUExPQURgIHwgLSB8CnwgYC0tbW9kZWxzIE5BTUU6VkVS" + + "U0lPTjpVUklgIHwgTW9kZWwgYXJ0aWZhY3Q7IHJlcGVhdGFibGUgfCAtIHwKfCBgLS1yZXNvdXJj" + + "ZXMgTkFNRTpWRVJTSU9OOlVSSWAgfCBSZXNvdXJjZSBhcnRpZmFjdDsgcmVwZWF0YWJsZSB8IC0g" + + "fAp8IGAtLXRhZ3MgVEFHWyxUQUddYCB8IFRhc2sgdGFncyB8IENvbW1hLXNlcGFyYXRlZCB8Cnwg" + + "YC0tZGVzY3JpcHRpb24gVEVYVGAgfCBUYXNrIGRlc2NyaXB0aW9uIHwgLSB8CnwgYC0tbG9ncy10" + + "ZWxlbWV0cnktaWQgVVVJRGAgfCBMb2dzIHRlbGVtZXRyeSBlbmRwb2ludCBJRCB8IC0gfAp8IGAt" + + "LW1ldHJpY3MtdGVsZW1ldHJ5LWlkIFVVSURgIHwgTWV0cmljcyB0ZWxlbWV0cnkgZW5kcG9pbnQg" + + "SUQgfCAtIHwKfCBgLS10cmFjZXMtdGVsZW1ldHJ5LWlkIFVVSURgIHwgVHJhY2VzIHRlbGVtZXRy" + + "eSBlbmRwb2ludCBJRCB8IC0gfAoKUEsHCPyjkeDGIgAAxiIAAFBLAwQUAAgAAAAAACEAAAAAAAAA" + + "AAAAAAAANwAJAGRhdGEvbnZjZi1zZWxmLW1hbmFnZWQtY2xpL3JlZmVyZW5jZS90cm91Ymxlc2hv" + + "b3RpbmcubWRVVAUAAQCmzhIjIFRyb3VibGVzaG9vdGluZwoKS25vd24gZXJyb3JzIOKGkiBkaWFn" + + "bm9zdGljIGNvbW1hbmQg4oaSIHJlbWVkaWF0aW9uLiBLZWVwIGluIHN5bmMgd2l0aCB0aGUgc3Ry" + + "dWN0dXJlZCBgcGhhc2VfZmFpbGVkYCBldmVudHMgdGhlIENMSSBlbWl0cyAoUkVRLTE1KSDigJQg" + + "ZXZlcnkgZW50cnkgYmVsb3cgc2hvdWxkIG1hcCB0byBhbiBgZXJyQ2F0ZWdvcnlgIGFuZCBhIGBy" + + "ZW1lZGlhdGlvbmAgYXJyYXkuCgojIyBQcmUtZmxpZ2h0Cgp8IFN5bXB0b20gfCBDYXVzZSB8IFJl" + + "bWVkaWF0aW9uIHwKfC0tLXwtLS18LS0tfAp8IGBrdWJlY3RsIG5vdCBvbiBQQVRIYCB8IE9wZXJh" + + "dG9yJ3MgYCRQQVRIYCBkb2Vzbid0IGluY2x1ZGUga3ViZWN0bCB8IEluc3RhbGwga3ViZWN0bCAx" + + "LjI4KzogaHR0cHM6Ly9rdWJlcm5ldGVzLmlvL2RvY3MvdGFza3MvdG9vbHMvaW5zdGFsbC1rdWJl" + + "Y3RsLyB8CnwgYGhlbG1maWxlIG5vdCBvbiBQQVRIYCB8IFNhbWUgfCBodHRwczovL2dpdGh1Yi5j" + + "b20vaGVsbWZpbGUvaGVsbWZpbGUjaW5zdGFsbGF0aW9uIHwKfCBgaGVsbSBub3Qgb24gUEFUSGAg" + + "fCBTYW1lIHwgaHR0cHM6Ly9oZWxtLnNoL2RvY3MvaW50cm8vaW5zdGFsbC8gfAp8IGBHYXRld2F5" + + "IEFQSSBDUkRzIG5vdCBpbnN0YWxsZWRgIHwgZW52b3ktZ2F0ZXdheSBwcmVyZXEgbWlzc2luZyB8" + + "IGBoZWxtIGluc3RhbGwgZWcgb2NpOi8vZG9ja2VyLmlvL2Vudm95cHJveHkvZ2F0ZXdheS1oZWxt" + + "IC0tbmFtZXNwYWNlPWVudm95LWdhdGV3YXktc3lzdGVtIC0tY3JlYXRlLW5hbWVzcGFjZWAgfAp8" + + "IGBkZWZhdWx0IFN0b3JhZ2VDbGFzcyBub3QgYXZhaWxhYmxlYCB8IENsdXN0ZXIgaGFzIG5vIGRl" + + "ZmF1bHQgU0MgfCBBbm5vdGF0ZSBvbmU6IGBrdWJlY3RsIHBhdGNoIHNjIDxuYW1lPiAtcCAneyJt" + + "ZXRhZGF0YSI6eyJhbm5vdGF0aW9ucyI6eyJzdG9yYWdlY2xhc3Mua3ViZXJuZXRlcy5pby9pcy1k" + + "ZWZhdWx0LWNsYXNzIjoidHJ1ZSJ9fX0nYCB8CnwgYEdQVSBvcGVyYXRvciBub3QgaW5zdGFsbGVk" + + "YCAoY29tcHV0ZS1wbGFuZSkgfCBudmlkaWEgR1BVIG9wZXJhdG9yIG1pc3NpbmcgfCBJbnN0YWxs" + + "IHBlciBodHRwczovL2RvY3MubnZpZGlhLmNvbS9kYXRhY2VudGVyL2Nsb3VkLW5hdGl2ZS9ncHUt" + + "b3BlcmF0b3IvbGF0ZXN0L2luc3RhbGwtZ3B1LW9wZXJhdG9yLmh0bWwsIE9SIHVzZSBgZmFrZS1n" + + "cHUtb3BlcmF0b3JgIGZvciBkZXYgfAp8IGBHUFUgbm9kZSBsYWJlbHMgbWlzc2luZ2AgKGNvbXB1" + + "dGUtcGxhbmUpIHwgTm9kZXMgbmVlZCBgbnZpZGlhLmNvbS9ncHUuZmFtaWx5YCBldGMuIHwgU2V0" + + "IGAtLWszcy1ub2RlLWxhYmVsIG52aWRpYS5jb20vZ3B1LmZhbWlseT1ob3BwZXJAYWdlbnQ6TmAg" + + "Zm9yIGszZCB8CgojIyBBdXRoCgp8IFN5bXB0b20gfCBDYXVzZSB8IFJlbWVkaWF0aW9uIHwKfC0t" + + "LXwtLS18LS0tfAp8IGBhZG1pbiB0b2tlbiByZXF1aXJlZGAgKGluaXQgbm90IHJ1bikgfCBObyBg" + + "fi8ubnZjZi1jbGkuc3RhdGVgIGFuZCBgLS10b2tlbmAgbm90IHBhc3NlZCB8IGBudmNmLWNsaSBp" + + "bml0YCAoaW50ZXJhY3RpdmUpIG9yIGAtLXRva2VuPSRKV1QgLS1ub24taW50ZXJhY3RpdmVgIChD" + + "SSkgfAp8IGBTaWduZWQgSldUIHJlamVjdGVkOiBBbm90aGVyIGFsZ29yaXRobSBleHBlY3RlZCwg" + + "b3Igbm8gbWF0Y2hpbmcga2V5KHMpIGZvdW5kYCB8IFN0YWxlIHNlc3Npb24uanNvbiBmcm9tIGEg" + + "ZGlmZmVyZW50IGNvbnRyb2wgcGxhbmUgfCBgcm0gfi8ubnZjZi1jbGkuc3RhdGVgIHRoZW4gYG52" + + "Y2YtY2xpIGluaXRgIGFnYWluIHwKfCBgNDAzIG1pc3NpbmcgcmVxdWVzdGVkIGF1dGhvcml0aWVz" + + "YCAoZnVuY3Rpb24gaW52b2tlKSB8IEFkbWluIHRva2VuIGRvZXNuJ3QgaGF2ZSBgaW52b2tlX2Z1" + + "bmN0aW9uYCBzY29wZSB8IGBudmNmLWNsaSBhcGkta2V5IGdlbmVyYXRlIC0tZGVzY3JpcHRpb249" + + "4oCmYCB0aGVuIHJlLXJ1biBpbnZva2UgfAoKIyMgSW5zdGFsbCAvIGB1cGAKCnwgU3ltcHRvbSB8" + + "IENhdXNlIHwgUmVtZWRpYXRpb24gfAp8LS0tfC0tLXwtLS18CnwgSGVsbSBgdGltZWQgb3V0IHdh" + + "aXRpbmcgZm9yIGNhc3NhbmRyYWAgfCBDYXNzYW5kcmEgU3RhdGVmdWxTZXQgUFZDIHN0dWNrIGBQ" + + "ZW5kaW5nYCB8IENvbmZpcm0gZGVmYXVsdCBTdG9yYWdlQ2xhc3M7IGNoZWNrIGBrdWJlY3RsIGdl" + + "dCBwdixwdmMgLW4gY2Fzc2FuZHJhLXN5c3RlbWAgfAp8IGBJbnZhbGlkIEdQVSAnTkNQLkdQVS5I" + + "MTAwJyBzcGVjaWZpZWRgIChmdW5jdGlvbiBkZXBsb3kpIHwgV3JvbmcgZmllbGQg4oCUIGBncHVg" + + "IGlzIHRoZSBmYW1pbHksIG5vdCB0aGUgU0tVIHwgVXNlIGAiZ3B1IjogIkgxMDAiYCwgYCJpbnN0" + + "YW5jZVR5cGUiOiAiTkNQLkdQVS5IMTAwXzF4ImAgfAp8IGByZWdpb24gbXVzdCBiZSBwcm92aWRl" + + "ZGAgKGNsdXN0ZXIgcmVnaXN0ZXIgLyBpbnN0YWxsIC0tY29tcHV0ZS1wbGFuZSkgfCBgLS1yZWdp" + + "b25gIGVtcHR5ICsgYENMVVNURVJfUkVHSU9OYCBlbnYgZW1wdHkgfCBQYXNzIGAtLXJlZ2lvbj11" + + "cy13ZXN0LTFgIChvciBhbnkgbm9uLWVtcHR5IHZhbHVlKSB8CnwgYHJlcXVpcmVkRW52ICJOQ0Ff" + + "SUQiIGlzIG5vdCBzZXRgIChoZWxtZmlsZSBlcnJvciBkdXJpbmcgY29tcHV0ZS1wbGFuZSBhcHBs" + + "eSkgfCBPbGRlciBudmNmLWNsaSBiZWZvcmUgY29tbWl0IGA2YWE1NzA0YDsgRXh0cmFFbnYgbm90" + + "IHByb3BhZ2F0aW5nIE5DQV9JRCB8IFVwZ3JhZGUgYG52Y2YtY2xpYCB0byBhIHJlbGVhc2UgYWZ0" + + "ZXIgYDZhYTU3MDRgIHwKfCBgbnZjYS1vcGVyYXRvcjogSW1hZ2VQdWxsQmFja09mZmAgZm9yIGBu" + + "dmNhLW9wZXJhdG9yOnBzYXRgIHwgSW1hZ2Ugbm90IGluIGNsdXN0ZXIgcmVnaXN0cnk7IG11bHRp" + + "LWNsdXN0ZXIgYnVpbGQgaXMgbG9jYWwgfCBgazNkIGltYWdlIGltcG9ydCBudmNyLmlvLy4uLi9u" + + "dmNhLW9wZXJhdG9yOnBzYXQgLWMgPGNsdXN0ZXI+YCB8CgojIyBDb21wdXRlLXBsYW5lIHJ1bnRp" + + "bWUKCnwgU3ltcHRvbSB8IENhdXNlIHwgUmVtZWRpYXRpb24gfAp8LS0tfC0tLXwtLS18CnwgTlZD" + + "QSBhZ2VudCBDcmFzaExvb3BCYWNrT2ZmIHdpdGggYEhUVFAgNDAxYCBvbiBgL3YxL252Y2EvY2x1" + + "c3RlcnMvLi4uL3JlZ2lzdGVyYCB8IFN0YWxlIGBvdXQvPGNsdXN0ZXI+LXJlZ2lzdGVyLXZhbHVl" + + "cy55YW1sYCBmcm9tIHByaW9yIHJlZ2lzdGVyOyBjbHVzdGVyIElEIGRvZXNuJ3QgbWF0Y2ggSUNN" + + "UyB8IERlbGV0ZSB0aGUgc3RhbGUgZmlsZTsgcmUtcnVuIGBudmNmLWNsaSBzZWxmLWhvc3RlZCB1" + + "cGAgKGlkZW1wb3RlbnQgcmVnaXN0ZXIgd3JpdGVzIGEgZnJlc2ggZmlsZSkgfAp8IGBObyBjbHVz" + + "dGVyIGZvdW5kIHdpdGggdmFsaWQgSldLUyBmb3IgY2x1c3RlciBJRDogPGlkPmAgKElDTVMgbG9n" + + "KSB8IEpXS1MgaW4gSUNNUyBkb2Vzbid0IG1hdGNoIHdoYXQgY29tcHV0ZS1wbGFuZSBLOHMgaXMg" + + "Y3VycmVudGx5IHNpZ25pbmcgfCBgbnZjZi1jbGkgY2x1c3RlciByb3RhdGUgLS1jbHVzdGVyLWlk" + + "PTxpZD5gIHwKfCBGdW5jdGlvbiBwb2QgYEltYWdlUHVsbEJhY2tPZmZgIGluIGBudmNmLWJhY2tl" + + "bmRgIHwgSW1hZ2UtY3JlZGVudGlhbC1oZWxwZXIgY29uZmlnIG1pc3Npbmcgb3Igd3JvbmcgfCBg" + + "a3ViZWN0bCBkZXNjcmliZSBwb2QgLW4gbnZjZi1iYWNrZW5kIDxwb2Q+YDsgY2hlY2sgdGhlIHB1" + + "bGwgc2VjcmV0IGNvbmZpZyB8CnwgRnVuY3Rpb24gZGVwbG95IHN0dWNrIGBERVBMT1lJTkdgIGZv" + + "ciA+NSBtaW4gfCBOQVRTIHN0cmVhbSBpbml0IGxhZyAoY29sZC1jbHVzdGVyKSDigJQgd2FpdCwg" + + "b3IgY2hlY2sgTkFUUyBhdXRoLWNhbGxvdXQgaGVhbHRoIHwgYGt1YmVjdGwgbG9ncyAtbiBuYXRz" + + "LXN5c3RlbSAtbCBhcHAua3ViZXJuZXRlcy5pby9uYW1lPW5hdHMtYXV0aC1jYWxsb3V0LXNlcnZp" + + "Y2VgIHwKCiMjIFRhc2tzCgp8IFN5bXB0b20gfCBDYXVzZSB8IFJlbWVkaWF0aW9uIHwKfC0tLXwt" + + "LS18LS0tfAp8IGB0YXNrIGNyZWF0ZWAgcmV0dXJucyBgTWlzc2luZyA8VFlQRT4gcmVnaXN0cnkg" + + "Y3JlZGVudGlhbCBmb3IgaG9zdG5hbWVgLCBvciBrZWVwcyB1c2luZyBhIHByZXZpb3VzIGNyZWRl" + + "bnRpYWwgdmFsdWUsIHNob3J0bHkgYWZ0ZXIgYHJlZ2lzdHJ5LWNyZWRlbnRpYWwgYWRkL3VwZGF0" + + "ZS9kZWxldGVgIHdoaWxlIGByZWdpc3RyeS1jcmVkZW50aWFsIGxpc3RgL2BnZXRgIGFscmVhZHkg" + + "c2hvdyB0aGUgbmV3IHZhbHVlIHwgRXhwZWN0ZWQgcHJvcGFnYXRpb24gZGVsYXk6IE5WQ1QgY2Fj" + + "aGVzIHRoZSBhY2NvdW50J3MgcmVnaXN0cnkgY3JlZGVudGlhbHMgd2l0aCBgbnZjdC5udmNmLmNh" + + "Y2hlLXR0bGAgKGRlZmF1bHQgYFBUNU1gLCBhYm91dCA1IG1pbikgYW5kIGFwcGxpZXMgdGhlIGNo" + + "YW5nZSB3aGVuIHRoYXQgY2FjaGVkIGNvcHkgcmVmcmVzaGVzIHwgV2FpdCB1cCB0byBhYm91dCA1" + + "IG1pbiBhbmQgcmV0cnksIG9yIGBrdWJlY3RsIC1uIG52Y2Ygcm9sbG91dCByZXN0YXJ0IGRlcGxv" + + "eW1lbnQvbnZjdC1hcGlgIHRvIGFwcGx5IGltbWVkaWF0ZWx5IHwKUEsHCPOuE4R0EQAAdBEAAFBL" + + "AwQUAAgAAAAAACEAAAAAAAAAAAAAAAAALAAJAGRhdGEvbnZjZi1zZWxmLW1hbmFnZWQtaW5zdGFs" + + "bGF0aW9uL1NLSUxMLm1kVVQFAAEAps4SLS0tCm5hbWU6IG52Y2Ytc2VsZi1tYW5hZ2VkLWluc3Rh" + + "bGxhdGlvbgpkZXNjcmlwdGlvbjogPi0KICBJbnN0YWxsIGFuZCBvcGVyYXRlIE5WQ0Ygc2VsZi1o" + + "b3N0ZWQgY29udHJvbC1wbGFuZSBhbmQgc2VwYXJhdGUgY29tcHV0ZS1wbGFuZQogIHN0YWNrcy4g" + + "Q292ZXJzIEhlbG1maWxlIHZhbHVlcyBhbmQgQ0xJIHByb2ZpbGUgaW5zdGFsbGF0aW9uIGZsb3dz" + + "LCB0ZWFyZG93biwKICB2YWx1ZXMgb3ZlcnJpZGVzLCBwdWxsIHNlY3JldHMsIGFuZCB0cm91Ymxl" + + "c2hvb3RpbmcuIFVzZSBmb3IKICBudmNmLXNlbGYtbWFuYWdlZC1zdGFjaywgbnZjZi1jb21wdXRl" + + "LXBsYW5lLXN0YWNrLCBzcGxpdCBjb21wdXRlLXBsYW5lCiAgaW5zdGFsbGF0aW9uLCBjb250cm9s" + + "LXBsYW5lIGluc3RhbGxhdGlvbiwgQ0xJLWdlbmVyYXRlZCBjb250cm9sLXBsYW5lCiAgcHJvZmls" + + "ZXMsIEhlbG1maWxlLCBzZWxmLW1hbmFnZWQsIG9yIHNlbGYtaG9zdGVkIGRlcGxveW1lbnRzLiBE" + + "byBOT1QgdXNlIGZvcgogIGxvY2FsIGszZCBlbnZpcm9ubWVudHM7IHVzZSB0aGUgbG9jYWwgazNk" + + "IGRldmVsb3BtZW50IHdvcmtmbG93IGluc3RlYWQuCmxpY2Vuc2U6IEFwYWNoZS0yLjAKY29tcGF0" + + "aWJpbGl0eTogUmVxdWlyZXMgaGVsbWZpbGUgPj0gMS4xLjAgPCAxLjIuMCwgaGVsbSA+PSAzLjEy" + + "LCBoZWxtLWRpZmYgcGx1Z2luLCBrdWJlY3RsIG1hdGNoaW5nIGNsdXN0ZXIgdmVyc2lvbgphdXRo" + + "b3I6ICJudmNmLWNvcmUtZW5nIDxudmNmLWNvcmUtZW5nQGV4Y2hhbmdlLm52aWRpYS5jb20+Igp2" + + "ZXJzaW9uOiAiMS4wLjAiCnRhZ3M6IFtudmNmLCBzZWxmLW1hbmFnZWQsIGhlbG1maWxlLCBzZWxm" + + "LWhvc3RlZCwgY29udHJvbC1wbGFuZSwgY29tcHV0ZS1wbGFuZSwgY2xpLXByb2ZpbGUsIGluc3Rh" + + "bGxhdGlvbiwgZGVwbG95bWVudCwgcHVsbC1zZWNyZXRzXQp0b29sczogW1NoZWxsLCBSZWFkLCBF" + + "ZGl0LCBHcmVwLCBHbG9iXQptZXRhZGF0YToKICBpbnRlcm5hbDogZmFsc2UKICBhdXRob3I6ICJu" + + "dmNmLWNvcmUtZW5nIDxudmNmLWNvcmUtZW5nQGV4Y2hhbmdlLm52aWRpYS5jb20+IgogIHZlcnNp" + + "b246ICIxLjAiCiAgdGFnczogW252Y2YsIHNlbGYtbWFuYWdlZCwgaGVsbWZpbGUsIHNlbGYtaG9z" + + "dGVkLCBjb250cm9sLXBsYW5lLCBjb21wdXRlLXBsYW5lLCBjbGktcHJvZmlsZSwgaW5zdGFsbGF0" + + "aW9uLCBkZXBsb3ltZW50LCBwdWxsLXNlY3JldHNdCiAgbGFuZ3VhZ2VzOiBbYmFzaCwgeWFtbF0K" + + "ICBmcmFtZXdvcmtzOiBbaGVsbWZpbGUsIGhlbG0sIGt1YmVjdGxdCiAgZG9tYWluOiBjbG91ZC1p" + + "bmZyYXN0cnVjdHVyZQotLS0KCiMgTlZDRiBTZWxmLU1hbmFnZWQgU3RhY2sgT3BlcmF0aW9ucwoK" + + "T3BlcmF0aW9uYWwgZ3VpZGUgZm9yIG1hdGNoaW5nIE5WQ0YgY29udHJvbC1wbGFuZSBhbmQgY29t" + + "cHV0ZS1wbGFuZSBIZWxtZmlsZSBidW5kbGVzLgoKIyMgSW5zdHJ1Y3Rpb25zCgpVc2UgdGhpcyBz" + + "a2lsbCBmb3IgaW5zdGFsbCwgdXBncmFkZSwgb3IgdGVhcmRvd24gd29yayBpbiBtYXRjaGluZyBg" + + "bnZjZi1zZWxmLW1hbmFnZWQtc3RhY2tgIGFuZCBgbnZjZi1jb21wdXRlLXBsYW5lLXN0YWNrYCBi" + + "dW5kbGVzOyBrZWVwIEhlbG1maWxlIHZhbHVlcyBhbmQgQ0xJIHByb2ZpbGUgaGFuZG9mZnMgc2Vw" + + "YXJhdGUuIEZvciBgZnVuY3Rpb25UeXBlOiAiTExNImAsIHJlYWQgW0xMTSBGdW5jdGlvbiBFbmFi" + + "bGVtZW50XShyZWZlcmVuY2VzL2hlbG1maWxlLXN0cnVjdHVyZS5tZCNsbG0tZnVuY3Rpb24tZW5h" + + "YmxlbWVudCkuCgojIyBQcmVyZXF1aXNpdGVzCgpBc2sgZm9yIHRoZSBleHRyYWN0ZWQgYG52Y2Yt" + + "c2VsZi1tYW5hZ2VkLXN0YWNrYCBwYXRoLiBGb3Igc3BsaXQgaW5zdGFsbGF0aW9uLAphbHNvIHJl" + + "cXVpcmUgdGhlIG1hdGNoaW5nLXZlcnNpb24gYG52Y2YtY29tcHV0ZS1wbGFuZS1zdGFja2AgcGF0" + + "aC4gVmVyaWZ5IGJvdGg6CgpgYGBiYXNoCmxzIDxjb250cm9sLXBsYW5lLXN0YWNrPi9oZWxtZmls" + + "ZS5kLyA8Y29udHJvbC1wbGFuZS1zdGFjaz4vZW52aXJvbm1lbnRzLyA8Y29udHJvbC1wbGFuZS1z" + + "dGFjaz4vc2VjcmV0cy8gPGNvbnRyb2wtcGxhbmUtc3RhY2s+L2dsb2JhbC55YW1sLmdvdG1wbAps" + + "cyA8Y29tcHV0ZS1wbGFuZS1zdGFjaz4vaGVsbWZpbGUuZC8gPGNvbXB1dGUtcGxhbmUtc3RhY2s+" + + "L2Vudmlyb25tZW50cy8gPGNvbXB1dGUtcGxhbmUtc3RhY2s+L2dsb2JhbC55YW1sLmdvdG1wbApg" + + "YGAKCklmIGVpdGhlciBkaXJlY3RvcnkgaXMgbWlzc2luZywgZG93bmxvYWQgbWF0Y2hpbmcgYnVu" + + "ZGxlIHZlcnNpb25zIGZyb20gTkdDOgoKYGBgYmFzaApuZ2MgcmVnaXN0cnkgcmVzb3VyY2UgZG93" + + "bmxvYWQtdmVyc2lvbiA8b3JnPi9udmNmLXNlbGYtbWFuYWdlZC1zdGFjazo8dmVyc2lvbj4Kbmdj" + + "IHJlZ2lzdHJ5IHJlc291cmNlIGRvd25sb2FkLXZlcnNpb24gPG9yZz4vbnZjZi1jb21wdXRlLXBs" + + "YW5lLXN0YWNrOjx2ZXJzaW9uPgpgYGAKCkNvbnRyb2wtcGxhbmUgY29tbWFuZHMgYmVsb3cgYXNz" + + "dW1lIHRoZSBjb250cm9sLXBsYW5lIGJ1bmRsZSByb290LiBTcGxpdC1mbG93CmNvbW1hbmRzIGFu" + + "ZCByb290IHN1YnN0aXR1dGlvbiBhcmUgaW4KW1NwbGl0IENvbXB1dGUtUGxhbmUgSW5zdGFsbGF0" + + "aW9uXShyZWZlcmVuY2VzL2NvbXB1dGUtcGxhbmUtaW5zdGFsbGF0aW9uLm1kKS4KCiMjIEJlZm9y" + + "ZSBZb3UgU3RhcnQKClZlcmlmeSB0b29saW5nIGFuZCBjb250ZXh0IGJlZm9yZSBhbnkgb3BlcmF0" + + "aW9uOgoKYGBgYmFzaApoZWxtZmlsZSAtLXZlcnNpb24gICAjIE11c3QgYmUgMS4xLnggKDEuMi4w" + + "IHJlbW92ZWQgc2VxdWVudGlhbCBtb2RlKQpoZWxtIHZlcnNpb24gICAgICAgICAjIE11c3QgYmUg" + + "Pj0gMy4xMgpoZWxtIHBsdWdpbiBsaXN0ICAgICAjIE11c3QgaW5jbHVkZSBoZWxtLWRpZmYgPj0g" + + "My4xMQprdWJlY3RsIHZlcnNpb24gICAgICAjIENsaWVudCBtdXN0IGJlIHdpdGhpbiAxIG1pbm9y" + + "IHZlcnNpb24gb2YgY2x1c3RlcgpgYGAKCkNvbnRyb2wtcGxhbmUgY29tbWFuZHMgcnVuIGZyb20g" + + "dGhlIGV4dHJhY3RlZCBgbnZjZi1zZWxmLW1hbmFnZWQtc3RhY2svYCByb290OgoKYGBgYmFzaApj" + + "ZCBwYXRoL3RvL252Y2Ytc2VsZi1tYW5hZ2VkLXN0YWNrCmxzIGhlbG1maWxlLmQvIGVudmlyb25t" + + "ZW50cy8gc2VjcmV0cy8gZ2xvYmFsLnlhbWwuZ290bXBsCmBgYAoKSWRlbnRpZnkgdGhlIGVudmly" + + "b25tZW50IGZyb20gYGVudmlyb25tZW50cy88bmFtZT4ueWFtbGAgYW5kCmBzZWNyZXRzLzxuYW1l" + + "Pi1zZWNyZXRzLnlhbWxgOyBmb3IgRUtTLCB1c2UgdGhlIGNhbm9uaWNhbApbQ1NQIEVuZC10by1F" + + "bmQgRXhhbXBsZV0oaHR0cHM6Ly9kb2NzLm52aWRpYS5jb20vbnZjZi92MC42LjAtcmMvY3NwLWVu" + + "ZC10by1lbmQtZXhhbXBsZSkuCgojIyBIb3cgVmFsdWVzIEZsb3cKClVuZGVyc3RhbmRpbmcgdmFs" + + "dWUgcHJlY2VkZW5jZSBwcmV2ZW50cyB0aGUgbW9zdCBjb21tb24gY29uZmlndXJhdGlvbiBtaXN0" + + "YWtlcy4KCmBgYAplbnZpcm9ubWVudHMvYmFzZS55YW1sICAgICAgICAgIChkZWZhdWx0cykKICAg" + + "IC0+IG1lcmdlZCB3aXRoCmVudmlyb25tZW50cy88ZW52Pi55YW1sICAgICAgICAgKHlvdXIgb3Zl" + + "cnJpZGVzKQogICAgLT4gY29uc3VtZWQgYnkKZ2xvYmFsLnlhbWwuZ290bXBsICAgICAgICAgICAg" + + "ICAoR28gdGVtcGxhdGUsIGNvbnN0cnVjdHMgcGVyLWNoYXJ0IHZhbHVlcykKICAgIC0+IGNvbnN1" + + "bWVkIGJ5CnNlY3JldHMvPGVudj4tc2VjcmV0cy55YW1sICAgICAgKHNlbnNpdGl2ZSB2YWx1ZXMp" + + "CiAgICAtPiBvdmVycmlkZGVuIGJ5CnJlbGVhc2UgaW5saW5lIHZhbHVlczogYmxvY2tzICAgKGhp" + + "Z2hlc3QgcHJlY2VkZW5jZSkKYGBgCgpDcml0aWNhbDogYGdsb2JhbC55YW1sLmdvdG1wbGAgb25s" + + "eSBwYXNzZXMgdGhyb3VnaCBzcGVjaWZpYyBrZXlzIHRvIGVhY2ggY2hhcnQgKGltYWdlIHJlZ2lz" + + "dHJpZXMsIG5vZGUgc2VsZWN0b3JzLCBzdG9yYWdlLCByZXBsaWNhIGNvdW50cykuIFNldHRpbmcg" + + "YW4gYXJiaXRyYXJ5IGNoYXJ0IHZhbHVlIGluIHRoZSBlbnZpcm9ubWVudCBmaWxlIHdpbGwgYmUg" + + "c2lsZW50bHkgaWdub3JlZCBpZiBgZ2xvYmFsLnlhbWwuZ290bXBsYCBkb2VzIG5vdCBwcm9wYWdh" + + "dGUgaXQuCgpUbyBvdmVycmlkZSBhcmJpdHJhcnkgY2hhcnQgdmFsdWVzLCB1c2UgYSBoZWxtZmls" + + "ZSByZWxlYXNlIGB2YWx1ZXM6YCBibG9jay4gU2VlIFtPdmVycmlkaW5nIEhlbG0gQ2hhcnQgVmFs" + + "dWVzXSgjb3ZlcnJpZGluZy1oZWxtLWNoYXJ0LXZhbHVlcykuCgojIyBDbGVhbiBJbnN0YWxsYXRp" + + "b24KCiMjIyAxLiBDcmVhdGUgbmFtZXNwYWNlcyBhbmQgaW1hZ2UgcHVsbCBzZWNyZXRzIChpZiB1" + + "c2luZyBhIHByaXZhdGUgcmVnaXN0cnkpCgpgYGBiYXNoCmZvciBucyBpbiBjYXNzYW5kcmEtc3lz" + + "dGVtIG5hdHMtc3lzdGVtIG52Y2YgYXBpLWtleXMgZXNzIHNpcyB2YXVsdC1zeXN0ZW0gY2VydC1t" + + "YW5hZ2VyOyBkbwogIGt1YmVjdGwgY3JlYXRlIG5hbWVzcGFjZSAiJG5zIiAtLWRyeS1ydW49Y2xp" + + "ZW50IC1vIHlhbWwgfCBrdWJlY3RsIGFwcGx5IC1mIC0KZG9uZQoKIyBPbmx5IGlmIHB1bGxpbmcg" + + "ZnJvbSBhIHByaXZhdGUgcmVnaXN0cnkgKGUuZy4sIE5HQyBudmNyLmlvKQpleHBvcnQgTkdDX0FQ" + + "SV9LRVk9Ijx5b3VyLWtleT4iCmZvciBucyBpbiBjYXNzYW5kcmEtc3lzdGVtIG5hdHMtc3lzdGVt" + + "IG52Y2YgYXBpLWtleXMgZXNzIHNpcyB2YXVsdC1zeXN0ZW0gY2VydC1tYW5hZ2VyOyBkbwogIGt1" + + "YmVjdGwgY3JlYXRlIHNlY3JldCBkb2NrZXItcmVnaXN0cnkgbnZjci1jcmVkcyBcCiAgICAtLWRv" + + "Y2tlci1zZXJ2ZXI9bnZjci5pbyBcCiAgICAtLWRvY2tlci11c2VybmFtZT0nJG9hdXRodG9rZW4n" + + "IFwKICAgIC0tZG9ja2VyLXBhc3N3b3JkPSIkTkdDX0FQSV9LRVkiIFwKICAgIC0tbmFtZXNwYWNl" + + "PSIkbnMiIFwKICAgIC0tZHJ5LXJ1bj1jbGllbnQgLW8geWFtbCB8IGt1YmVjdGwgYXBwbHkgLWYg" + + "LQpkb25lCmBgYAoKSWYgdXNpbmcgcHVsbCBzZWNyZXRzLCB5b3UgbXVzdCBhbHNvIGNvbmZpZ3Vy" + + "ZSBlYWNoIGhlbG1maWxlIHJlbGVhc2UgdG8gcmVmZXJlbmNlIHRoZW0uIFNlZSBbSW1hZ2UgUHVs" + + "bCBTZWNyZXRzXSgjaW1hZ2UtcHVsbC1zZWNyZXRzKS4KCiMjIyAyLiBBdXRoZW50aWNhdGUgaGVs" + + "bSB0byB5b3VyIGNoYXJ0IHJlZ2lzdHJ5CgpCb3RoIGBkb2NrZXIgbG9naW5gIEFORCBgaGVsbSBy" + + "ZWdpc3RyeSBsb2dpbmAgYXJlIHJlcXVpcmVkIGZvciBOR0MuIEhlbG1maWxlIHVzZXMgaGVsbSAo" + + "bm90IGRvY2tlcikgdG8gcHVsbCBPQ0kgY2hhcnRzLCBzbyB0aGUgaGVsbSBjcmVkZW50aWFsIHN0" + + "b3JlIG11c3QgYmUgYXV0aGVudGljYXRlZCBzZXBhcmF0ZWx5LgoKYGBgYmFzaAojIE5HQyAtLSBi" + + "b3RoIGNvbW1hbmRzIGFyZSByZXF1aXJlZApkb2NrZXIgbG9naW4gbnZjci5pbyAtdSAnJG9hdXRo" + + "dG9rZW4nIC1wICIkTkdDX0FQSV9LRVkiCmhlbG0gcmVnaXN0cnkgbG9naW4gbnZjci5pbyAtdSAn" + + "JG9hdXRodG9rZW4nIC1wICIkTkdDX0FQSV9LRVkiCgojIEVDUgphd3MgZWNyIGdldC1sb2dpbi1w" + + "YXNzd29yZCAtLXJlZ2lvbiA8cmVnaW9uPiB8IFwKICBoZWxtIHJlZ2lzdHJ5IGxvZ2luIC0tdXNl" + + "cm5hbWUgQVdTIC0tcGFzc3dvcmQtc3RkaW4gPGFjY291bnQ+LmRrci5lY3IuPHJlZ2lvbj4uYW1h" + + "em9uYXdzLmNvbQpgYGAKCj4gTm90ZTogYGhlbG0gcmVnaXN0cnkgbG9naW5gIGtlZXBzIG9ubHkg" + + "dGhlIGxhc3QgbG9naW4gcGVyIGhvc3QgKG11bHRpLW9yZyBnb3RjaGEpLgo+IFRoZSBzdGFjayBh" + + "bmQgdGhlIGNhY2hlcyBzcGFuIHNldmVyYWwgTkdDIG9yZ3MgdGhhdCBuZWVkIGRpZmZlcmVudCBr" + + "ZXlzLCBidXQgdGhleSBhbGwKPiBsaXZlIHVuZGVyIHRoZSBvbmUgaG9zdCBgbnZjci5pb2AuIEEg" + + "c2Vjb25kIGBoZWxtIHJlZ2lzdHJ5IGxvZ2luIG52Y3IuaW9gIChvcgo+IGBkb2NrZXIgbG9naW5g" + + "KSB3aXRoIGEgZGlmZmVyZW50IGtleSBzaWxlbnRseSBvdmVyd3JpdGVzIHRoZSBmaXJzdCwgc28g" + + "cHVsbHMgZm9yIHRoZQo+IGZpcnN0IG9yZyB0aGVuIGZhaWwgd2l0aCBhIG1pc2xlYWRpbmcgYDQw" + + "MyBBY2Nlc3MgRGVuaWVkYCAobm90IGEgNDAxOiB0aGUgYXV0aAo+IHN1Y2NlZWRlZCwgaXQncyB0" + + "aGUgd3Jvbmctb3JnIGtleSkuIElmIHlvdSBwdWxsIGNoYXJ0cy9pbWFnZXMgZnJvbSBtb3JlIHRo" + + "YW4gb25lIG9yZywKPiBlaXRoZXIgcmUtcnVuIHRoZSBsb2dpbiB3aXRoIHRoZSBjb3JyZWN0IGtl" + + "eSBpbW1lZGlhdGVseSBiZWZvcmUgZWFjaCBwdWxsLCBvciBwYXNzCj4gYC0tdXNlcm5hbWUgJyRv" + + "YXV0aHRva2VuJyAtLXBhc3N3b3JkIDxrZXk+YCBwZXIgYGhlbG0gcHVsbGAgaW52b2NhdGlvbiBp" + + "bnN0ZWFkIG9mIHJlbHlpbmcKPiBvbiB0aGUgc3RvcmVkIGxvZ2luLiAoUHVsbGluZyBldmVyeXRo" + + "aW5nIGZyb20gYSBzaW5nbGUgcmVnaXN0cnkgbWlycm9yIGF2b2lkcyB0aGlzCj4gZW50aXJlbHku" + + "KQoKIyMjIDJiLiAoUmVjb21tZW5kZWQpIFB1bGwgZnJvbSBhIHJlZ2lzdHJ5IHRoZSBjbHVzdGVy" + + "IGF1dGhlbnRpY2F0ZXMgdG8gYXV0b21hdGljYWxseQoKSWYgeW91IG1pcnJvciB0aGUgTlZDRiBp" + + "bWFnZXMgaW50byBhIHJlZ2lzdHJ5IHRoYXQgdGhlIGNsdXN0ZXIgY2FuIHB1bGwgZnJvbSB3aXRo" + + "b3V0IGFuCmV4cGxpY2l0IGltYWdlIHB1bGwgc2VjcmV0IChmb3IgZXhhbXBsZSwgYSByZWdpc3Ry" + + "eSB3aGVyZSB0aGUgbm9kZSBvciB3b3JrbG9hZCBpZGVudGl0eSBpcwpncmFudGVkIHB1bGwgYWNj" + + "ZXNzIGF1dG9tYXRpY2FsbHkpLCBwb2ludCB0aGUgc3RhY2sgYXQgaXQgYW5kIHNraXAgdGhlIGNy" + + "ZWRlbnRpYWwgc3RlcHMKYWJvdmUuCgoxLiBQb2ludCB0aGUgc3RhY2sgYXQgdGhlIG1pcnJvciBp" + + "biBgZW52aXJvbm1lbnRzLzxlbnY+LnlhbWxgOgoKICAgYGBgeWFtbAogICBnbG9iYWw6CiAgICAg" + + "aW1hZ2U6CiAgICAgICByZWdpc3RyeTogPHlvdXItcmVnaXN0cnk+ICAgICAgICAgICAgIyBlLmcu" + + "IHJlZ2lzdHJ5LmV4YW1wbGUuY29tCiAgICAgICByZXBvc2l0b3J5OiA8bWlycm9yLXN1Yi1wYXRo" + + "PgogICAgIGhlbG06CiAgICAgICBzb3VyY2VzOiAgICAgICAgICAgICAgICAgICAgICAgICAgICAg" + + "ICMgb25seSBpZiB5b3UgYWxzbyBtaXJyb3JlZCB0aGUgaGVsbSBjaGFydHMKICAgICAgICAgcmVn" + + "aXN0cnk6IDx5b3VyLXJlZ2lzdHJ5PgogICAgICAgICByZXBvc2l0b3J5OiA8bWlycm9yLXN1Yi1w" + + "YXRoPgogICBgYGAKCiAgID4gVGhlIG1hbmlmZXN0IGhhcyBhIG1peCBvZiBPQ0kgYW5kIG5vbi1P" + + "Q0kgYXJ0aWZhY3RzLCBzbyBjb252ZXJ0IG5vbi1PQ0kgY2hhcnRzIGJlZm9yZQogICA+IG1pcnJv" + + "cmluZy4gQ29udGFpbmVyIGltYWdlcyAoYG52Y3IuaW8vLi4uYCkgYXJlIGFscmVhZHkgT0NJIGFu" + + "ZCBtaXJyb3IgYXMtaXMuIFNvbWUgSGVsbQogICA+IGNoYXJ0cywgdGhvdWdoLCBhcmUgcHVibGlz" + + "aGVkIHRvIGFuIGBodHRwczovL2AgSGVsbSByZXBvc2l0b3J5IChmb3IgZXhhbXBsZQogICA+IGBo" + + "ZWxtLm5nYy5udmlkaWEuY29tYCkuIFRob3NlIGFyZSBub3QgT0NJIGFuZCBjYW5ub3QgYmUgcmVz" + + "b2x2ZWQgYnkgYGdsb2JhbC5oZWxtLnNvdXJjZXNgCiAgID4gKE9DSSkgb3IgbWlycm9yZWQgZGly" + + "ZWN0bHkuIEJlZm9yZSBwb2ludGluZyB0aGUgc3RhY2sgYXQgeW91ciBtaXJyb3IsIGNvbnZlcnQg" + + "ZWFjaAogICA+IGBodHRwczovL2AgY2hhcnQgdG8gT0NJOiBgaGVsbSByZXBvIGFkZGAvYGhlbG0g" + + "cHVsbGAgdGhlIGAudGd6YCwgdGhlbgogICA+IGBoZWxtIHB1c2ggPGNoYXJ0Pi50Z3ogb2NpOi8v" + + "PHlvdXItcmVnaXN0cnk+LzxtaXJyb3Itc3ViLXBhdGg+YC4gT25seSBPQ0kgY2hhcnRzIGNhbiBs" + + "aXZlCiAgID4gdW5kZXIgYGdsb2JhbC5oZWxtLnNvdXJjZXNgLgoKMi4gU2tpcCB0aGUgY3JlZGVu" + + "dGlhbCBzdGVwcyBhYm92ZS4gV2hlbiB0aGUgY2x1c3RlciBhdXRoZW50aWNhdGVzIHRvIHRoZSBy" + + "ZWdpc3RyeQogICBhdXRvbWF0aWNhbGx5ICh0aGUgbm9kZSBvciB3b3JrbG9hZCBpZGVudGl0eSBo" + + "YXMgcHVsbCBhY2Nlc3MpLCB0aGUgcHVsbCBuZWVkcyBubwogICBLdWJlcm5ldGVzIHNlY3JldCwg" + + "c28geW91IGRvIG5vdCBuZWVkOiB0aGUgcGVyLW5hbWVzcGFjZSBgbnZjci1jcmVkc2AgZnJvbSBz" + + "dGVwIDEKICAgKHN0aWxsIGNyZWF0ZSB0aGUgbmFtZXNwYWNlcywganVzdCBub3QgdGhlIHNlY3Jl" + + "dCksIHRoZSBgZ2xvYmFsLmltYWdlUHVsbFNlY3JldHNgIGVudHJ5LAogICBvciB0aGUgYGRvY2tl" + + "ciBsb2dpbmAvYGhlbG0gcmVnaXN0cnkgbG9naW4gbnZjci5pb2AgZnJvbSBzdGVwIDIuCgogICA+" + + "IE9uZSByZXNpZHVhbCBjcmVkZW50aWFsOiBudmNmLWFwaSBzdGlsbCB2YWxpZGF0ZXMgdGhlIHVz" + + "ZXIgZnVuY3Rpb24gaW1hZ2UgYXQKICAgPiBgZnVuY3Rpb24gY3JlYXRlYCB2aWEgdGhlIGFjY291" + + "bnQgcmVnaXN0cnkgY3JlZGVudGlhbCwgc28gdGhhdCBjcmVkZW50aWFsIG11c3QgcG9pbnQgYXQK" + + "ICAgPiB3aGljaGV2ZXIgcmVnaXN0cnkgaG9sZHMgdGhlIHVzZXIgaW1hZ2UgKHNldCBpdCB0byB5" + + "b3VyIG1pcnJvciBpZiB0aGUgaW1hZ2UgaXMgbWlycm9yZWQKICAgPiB0aGVyZSkuCgojIyMgMy4g" + + "U2V0IHRoZSByb3V0ZSBkb21haW4KCmBnbG9iYWwuZG9tYWluYCBzZXRzIHRoZSBob3N0bmFtZSBz" + + "dWZmaXggZm9yIHJvdXRlcyBzdWNoIGFzIGBhcGkuPGRvbWFpbj5gLiBJdCBkb2VzIG5vdCBjb25m" + + "aWd1cmUgdGhlIEdhdGV3YXkgb3IgaXRzIGxvYWQgYmFsYW5jZXIuIFF1ZXJ5IHRoZSBleGFjdCBl" + + "eGlzdGluZyBHYXRld2F5OgoKYGBgYmFzaApHQVRFV0FZX0FERFJFU1M9JChrdWJlY3RsIGdldCBn" + + "YXRld2F5IDxnYXRld2F5LW5hbWU+IC1uIDxnYXRld2F5LW5hbWVzcGFjZT4gLW8ganNvbnBhdGg9" + + "J3suc3RhdHVzLmFkZHJlc3Nlc1swXS52YWx1ZX0nKQp0ZXN0IC1uICIkR0FURVdBWV9BRERSRVNT" + + "IgpgYGAKClRoZSBhZGRyZXNzIG1heSBiZSBhIGhvc3RuYW1lIG9yIElQLiBDbG91ZCBwcm92aWRl" + + "ciBhbmQgR2F0ZXdheSBjb25maWd1cmF0aW9uIGRldGVybWluZSB0aGUgbG9hZCBiYWxhbmNlciB0" + + "eXBlIGFuZCBhZGRyZXNzIGZvcm1hdC4gVGhlIHNlbGYtbWFuYWdlZCBzdGFjayBkb2VzIG5vdCBz" + + "ZWxlY3QgZWl0aGVyLgoKRm9yIHRlbXBvcmFyeSB0ZXN0aW5nIHdpdGhvdXQgRE5TLCB1c2UgYSBz" + + "dGFibGUgcmVzZXJ2ZWQgc3VmZml4IHN1Y2ggYXMgYGdsb2JhbC5kb21haW46ICJudmNmLnRlc3Qi" + + "YCwgY29ubmVjdCB0byBgR0FURVdBWV9BRERSRVNTYCwgYW5kIHNlbmQgYEhvc3Q6IGFwaS5udmNm" + + "LnRlc3RgLiBGb3IgcHJvZHVjdGlvbiwgdXNlIHlvdXIgYmFzZSBETlMgZG9tYWluIGFuZCBwb2lu" + + "dCBpdHMgcm91dGUgcmVjb3JkcyB0byBgR0FURVdBWV9BRERSRVNTYC4gSWYgdGhlIGVuZHBvaW50" + + "IGxhdGVyIGNoYW5nZXMsIGtlZXAgYGdsb2JhbC5kb21haW5gIHN0YWJsZSBhbmQgdXBkYXRlIG9u" + + "bHkgRE5TIG9yIHRoZSBjbGllbnQgZGVzdGluYXRpb24uIFNlZSBFeGFtcGxlIDQgaW4gW2V4YW1w" + + "bGVzLm1kXShleGFtcGxlcy5tZCkuCgojIyMgNC4gUHJldmlldyBhbmQgZGVwbG95CgpgYGBiYXNo" + + "CkhFTE1GSUxFX0VOVj08ZW52LW5hbWU+IGhlbG1maWxlIHRlbXBsYXRlICAgIyBQcmV2aWV3IHJl" + + "bmRlcmVkIG1hbmlmZXN0cwpIRUxNRklMRV9FTlY9PGVudi1uYW1lPiBoZWxtZmlsZSBzeW5jICAg" + + "ICAgICMgRGVwbG95CmBgYAoKPiBTZXQgQk9USCBDYXNzYW5kcmEgcGFzc3dvcmRzIGluIHRoZSBz" + + "ZWNyZXRzIGZpbGUuIFRoZSBzZWNyZXRzIGZpbGUgZG9jdW1lbnRzCj4gYERFRkFVTFRfQ0FTU0FO" + + "RFJBX1BBU1NXT1JEYCwgYnV0IHRoZSBjYXNzYW5kcmEgY2hhcnQgaGFzIGEgc2Vjb25kIGNyZWRl" + + "bnRpYWwsCj4gYGNhc3NhbmRyYS5zZXJ2aWNlUm9sZVBhc3N3b3JkYCwgdGhhdCBkZWZhdWx0cyB0" + + "byBgY2hAbmczbTNgLiBJZiB5b3Ugc2V0IG9ubHkKPiBgREVGQVVMVF9DQVNTQU5EUkFfUEFTU1dP" + + "UkRgLCB0aGUgc2VydmljZSByb2xlIGtlZXBzIHRoYXQgZGVmYXVsdCBhbmQgZXZlcnkgREItYmFj" + + "a2VkCj4gc2VydmljZSBjcmFzaC1sb29wcyB3aXRoIGBCYWQgY3JlZGVudGlhbHNgIG9uY2UgaXQg" + + "dHJpZXMgdG8gYXV0aGVudGljYXRlLiBTZXQKPiBgY2Fzc2FuZHJhLnNlcnZpY2VSb2xlUGFzc3dv" + + "cmRgIHRvIHRoZSBzYW1lIHZhbHVlIGFzIGBERUZBVUxUX0NBU1NBTkRSQV9QQVNTV09SRGAuCgoj" + + "IyMgNS4gRGVwbG95bWVudCBwaGFzZXMKCkhlbG1maWxlIGRlcGxveXMgaW4gb3JkZXIgd2l0aCBk" + + "ZXBlbmRlbmNpZXM6Cgp8IFBoYXNlIHwgU2VsZWN0b3IgfCBTZXJ2aWNlcyB8IFdhaXQgdGltZSB8" + + "CnwtLS0tLS0tfC0tLS0tLS0tLS18LS0tLS0tLS0tLXwtLS0tLS0tLS0tLXwKfCAxIHwgYHJlbGVh" + + "c2UtZ3JvdXA9ZGVwZW5kZW5jaWVzYCB8IE5BVFMsIE9wZW5CYW8sIENhc3NhbmRyYSB8IDUtMTAg" + + "bWluIHwKfCAyIHwgYHJlbGVhc2UtZ3JvdXA9c2VydmljZXNgIHwgQVBJLCBTSVMsIEVTUywgaW52" + + "b2NhdGlvbiwgZ3JwYy1wcm94eSwgbm90YXJ5LCBhcGkta2V5cywgb3B0aW9uYWwgTExNIGdhdGV3" + + "YXkvcm91dGVyLCBvcHRpb25hbCBWYW5pdHkgR2F0ZXdheSwgTlZDRiBVSSB3aGVuIHRoZSBzdGFj" + + "ayBwYWNrYWdlIGluY2x1ZGVzIHRoZSBhZGRvbiB8IDUtMTAgbWluIHwKfCAzIHwgYHJlbGVhc2Ut" + + "Z3JvdXA9aW5ncmVzc2AgfCBHYXRld2F5IHJvdXRlcyB8IDEtMiBtaW4gfAp8IDQgfCBgcmVsZWFz" + + "ZS1ncm91cD1vYnNlcnZhYmlsaXR5YCB8IE9ic2VydmFiaWxpdHkgc3RhY2sgKGlmIGVuYWJsZWQp" + + "IHwgMS0yIG1pbiB8CgpNb25pdG9yIGluIGEgc2VwYXJhdGUgdGVybWluYWw6CgpgYGBiYXNoCmt1" + + "YmVjdGwgZ2V0IHBvZHMgLUEgLXcKYGBgCgojIyMgNi4gRW5hYmxlIFZhbml0eSBHYXRld2F5IChv" + + "cHRpb25hbCkKClZhbml0eSBHYXRld2F5IGlzIGRpc2FibGVkIGJ5IGRlZmF1bHQgYW5kIGlzIG9u" + + "bHkgbmVlZGVkIGZvciBjdXN0b21lci1mYWNpbmcKaG9zdG5hbWVzIG9yIHBhdGggbWFwcGluZ3Mg" + + "aW4gZnJvbnQgb2YgdGhlIHN0YW5kYXJkIE5WQ0YgQVBJIGFuZCBpbnZvY2F0aW9uCnJvdXRlcy4g" + + "SXQgaXMgYXZhaWxhYmxlIG9ubHkgaW4gc3RhY2sgcGFja2FnZXMgdGhhdCBpbmNsdWRlIHRoZSBW" + + "YW5pdHkgR2F0ZXdheQphZGRvbi4gSWYgdGhlIGV4dHJhY3RlZCBzdGFjayBwYWNrYWdlIGRvZXMg" + + "bm90IGNvbnRhaW4gYSBgdmFuaXR5LWdhdGV3YXlgCnJlbGVhc2UgYW5kIGB2YW5pdHlHYXRld2F5" + + "YCByb3V0ZSB2YWx1ZXMsIHNraXAgdGhlc2UgY29tbWFuZHMgYW5kIHVzZSBhIG5ld2VyCnN0YWNr" + + "IHBhY2thZ2UgdGhhdCBpbmNsdWRlcyB0aGVtLgoKSWYgdGhlIHN0YWNrIHBhY2thZ2UgaW5jbHVk" + + "ZXMgdGhlIGFkZG9uLCBlbmFibGUgaXQgaW4KYGVudmlyb25tZW50cy88ZW52LW5hbWU+LnlhbWxg" + + "OgoKYGBgeWFtbAphZGRvbnM6CiAgdmFuaXR5R2F0ZXdheToKICAgIGVuYWJsZWQ6IHRydWUKICAg" + + "IG1hcHBpbmdDb25maWc6IHt9CmBgYAoKVGhlIGRlZmF1bHQgcm91dGUgaG9zdCBpcyBgdmFuaXR5" + + "Ljxkb21haW4+YCBhbmQgdGhlIGJhY2tlbmQgaXMKYHZhbml0eS1nYXRld2F5Lm52Y2Y6ODA4MGAu" + + "IFB1dCBkZXBsb3ltZW50LXNwZWNpZmljIGhvc3QgYW5kIHBhdGggbWFwcGluZ3MgdW5kZXIKYGFk" + + "ZG9ucy52YW5pdHlHYXRld2F5Lm1hcHBpbmdDb25maWdgLiBJZiB5b3UgbmVlZCBjdXN0b20gdmFu" + + "aXR5IGhvc3RzIGluc3RlYWQgb2YKYHZhbml0eS48ZG9tYWluPmAsIHVzZSB0aGUgcm91dGUgaG9z" + + "dG5hbWUgb3ZlcnJpZGVzIHN1cHBvcnRlZCBieSB0aGUgc3RhY2sKcGFja2FnZSBhbmQgY3JlYXRl" + + "IG1hdGNoaW5nIEROUyByZWNvcmRzLgoKQWZ0ZXIgY29uZmlybWluZyB0aGUgcGFja2FnZSBpbmNs" + + "dWRlcyB0aGUgYHZhbml0eS1nYXRld2F5YCByZWxlYXNlLCBwcmV2aWV3IGFuZAphcHBseSB0aGUg" + + "c2VydmljZSBhbmQgcm91dGU6CgpgYGBiYXNoCkhFTE1GSUxFX0VOVj08ZW52LW5hbWU+IGhlbG1m" + + "aWxlIC0tc2VsZWN0b3IgbmFtZT12YW5pdHktZ2F0ZXdheSB0ZW1wbGF0ZQpIRUxNRklMRV9FTlY9" + + "PGVudi1uYW1lPiBoZWxtZmlsZSAtLXNlbGVjdG9yIG5hbWU9dmFuaXR5LWdhdGV3YXkgc3luYwpI" + + "RUxNRklMRV9FTlY9PGVudi1uYW1lPiBoZWxtZmlsZSAtLXNlbGVjdG9yIHJlbGVhc2UtZ3JvdXA9" + + "aW5ncmVzcyBzeW5jCmBgYAoKVmVyaWZ5IHRoZSByb3V0ZSBvbmx5IHdoZW4gdGhlIGFkZG9uIGlz" + + "IHByZXNlbnQgYW5kIGVuYWJsZWQ6CgpgYGBiYXNoCmt1YmVjdGwgZ2V0IGRlcGxveSxzdmMgLW4g" + + "bnZjZiAtbCBhcHAua3ViZXJuZXRlcy5pby9uYW1lPXZhbml0eS1nYXRld2F5Cmt1YmVjdGwgZ2V0" + + "IGh0dHByb3V0ZSAtQSB8IGdyZXAgLWkgdmFuaXR5CmN1cmwgLUggIkhvc3Q6IHZhbml0eS48ZG9t" + + "YWluPiIgImh0dHA6Ly88Z2F0ZXdheS1hZGRyZXNzPi9oZWFsdGgiCmBgYAoKRG8gbm90IGVuYWJs" + + "ZSBWYW5pdHkgR2F0ZXdheSBmb3Igc3RhbmRhcmQgQVBJLCBBUEkgS2V5cywgaW52b2NhdGlvbiwg" + + "TExNCmludm9jYXRpb24sIG9yIGdSUEMgdHJhZmZpYy4gVGhvc2Ugcm91dGVzIGFyZSBwcm92aWRl" + + "ZCBieSB0aGUgYmFzZSBnYXRld2F5CnJvdXRlcy4KCiMjIyA3LiBFbmFibGUgTlZDRiBVSSAob3B0" + + "aW9uYWwpCgpOVkNGIFVJIGlzIGFuIG9wdGlvbmFsLCBjdXN0b21lci1mYWNpbmcgYWRtaW4tcGFu" + + "ZWwgVUkuIEl0IGlzIGRpc2FibGVkIGJ5CmRlZmF1bHQgYW5kIGF2YWlsYWJsZSBvbmx5IGluIHN0" + + "YWNrIHBhY2thZ2VzIHRoYXQgaW5jbHVkZSB0aGUgTlZDRiBVSSBhZGRvbi4gSWYKeW91ciBleHRy" + + "YWN0ZWQgc3RhY2sgcGFja2FnZSBkb2VzIG5vdCBjb250YWluIGEgYG52Y2YtdWlgIHJlbGVhc2Ug" + + "YW5kIGBudmNmVWlgCnJvdXRlIHZhbHVlcywgc2tpcCB0aGlzIHNlY3Rpb24uIFRoZSBOVkNGIFVJ" + + "IGFkbWluIHBhbmVsIGlzIGN1cnJlbnRseQp1bmF1dGhlbnRpY2F0ZWQ7IGRvIG5vdCBleHBvc2Ug" + + "aXQgdG8gdGhlIHB1YmxpYyBpbnRlcm5ldC4KCkZvciBlbmFibGVtZW50LCBuYW1lc3BhY2UgYW5k" + + "IHB1bGwgc2VjcmV0IHNldHVwLCBhcHBseSwgYW5kIHZlcmlmaWNhdGlvbiBzdGVwcywKc2VlIFtO" + + "VkNGIFVJIEFkZG9uXShyZWZlcmVuY2VzL252Y2YtdWktYWRkb24ubWQpLgoKIyMjIDguIEluc3Rh" + + "bGwgdGhlIHNlcGFyYXRlIGNvbXB1dGUtcGxhbmUgc3RhY2sKClRoZSBjb250cm9sLXBsYW5lIHN0" + + "YWNrIGRvZXMgbm90IGluc3RhbGwgY29tcHV0ZS1wbGFuZSBjb21wb25lbnRzLiBBZnRlciBpdCBp" + + "cyBoZWFsdGh5LCBjaG9vc2UgZXhhY3RseSBvbmUgY29tcHV0ZS1wbGFuZSBoYW5kb2ZmOgoKLSBI" + + "ZWxtZmlsZSB2YWx1ZXMgZmxvdzogYXV0aG9yIHNlcGFyYXRlIGVudmlyb25tZW50IGZpbGVzLCB0" + + "aGVuIHJlZ2lzdGVyIGFuZAogIGluc3RhbGwgd2l0aCB0aGUgY29tcHV0ZS1wbGFuZSBNYWtlZmls" + + "ZS4KLSBDTEkgcHJvZmlsZSBmbG93OiB1c2UgdGhlIHByb2ZpbGUgZ2VuZXJhdGVkIGJ5IHRoZSBD" + + "TEkgY29udHJvbC1wbGFuZSBpbnN0YWxsLAogIHRoZW4gcnVuIHRoZSBjb21wbGV0ZSBDTEkgcmVn" + + "aXN0ZXIgYW5kIGluc3RhbGwgY29tbWFuZHMuCgpEbyBub3QgbWl4IHRoZXNlIGhhbmRvZmZzLiBG" + + "b2xsb3cgW1NwbGl0IENvbXB1dGUtUGxhbmUgSW5zdGFsbGF0aW9uXShyZWZlcmVuY2VzL2NvbXB1" + + "dGUtcGxhbmUtaW5zdGFsbGF0aW9uLm1kKQpmb3IgY29tbWFuZHMsIEVLUyByb3V0aW5nLCBwdWxs" + + "IHNlY3JldHMsIHZlcmlmaWNhdGlvbiwgYW5kIHRlYXJkb3duIG9yZGVyLgoKIyMgQ2xlYW4gVGVh" + + "cmRvd24KCkRlc3Ryb3kgZXZlcnkgY29tcHV0ZSBwbGFuZSBiZWZvcmUgdGhlIGNvbnRyb2wgcGxh" + + "bmUsIHVzaW5nIHRoZSB0ZWFyZG93biBmb3IKdGhlIHNhbWUgaGFuZG9mZjsgc2VlIFtTcGxpdCBD" + + "b21wdXRlLVBsYW5lIEluc3RhbGxhdGlvbl0ocmVmZXJlbmNlcy9jb21wdXRlLXBsYW5lLWluc3Rh" + + "bGxhdGlvbi5tZCN0ZWFyZG93bikuCgpTY29wZTogT25seSBkZXN0cm95IHJlbGVhc2VzIG1hbmFn" + + "ZWQgYnkgdGhpcyBjb250cm9sLXBsYW5lIGhlbG1maWxlIHN0YWNrLiBUaGUgTlZDRiByZWxlYXNl" + + "cyBhcmU6IGBuYXRzYCwgYG9wZW5iYW8tc2VydmVyYCwgYGNhc3NhbmRyYWAsIGBhcGkta2V5c2As" + + "IGBzaXNgLCBgYXBpYCwgYGludm9jYXRpb24tc2VydmljZWAsIGBncnBjLXByb3h5YCwgYGVzcy1h" + + "cGlgLCBgbm90YXJ5LXNlcnZpY2VgLCBvcHRpb25hbCBgdmFuaXR5LWdhdGV3YXlgLCBgbnZjZi11" + + "aWAsIGBhZG1pbi1pc3N1ZXItcHJveHlgLCBhbmQgYGluZ3Jlc3NgOyBgY2VydC1tYW5hZ2VyYCBp" + + "cyBpbmNsdWRlZCBvbmx5IHdoZW4gYGNlcnRNYW5hZ2VyLmVuYWJsZWQ6IHRydWVgLiBUaGUgY29u" + + "dHJvbC1wbGFuZSBuYW1lc3BhY2UgaW52ZW50b3J5IGFsc28gaW5jbHVkZXMgYGNlcnQtbWFuYWdl" + + "cmAsIGJ1dCBkZWZhdWx0IG5hbWVzcGFjZSBjbGVhbnVwIHByZXNlcnZlcyBpdC4gTmFtZXNwYWNl" + + "IHByZXNlcnZhdGlvbiBkb2VzIG5vdCBwcmVzZXJ2ZSB0aGUgSGVsbSByZWxlYXNlLiBFeHRlcm5h" + + "bCBjZXJ0LW1hbmFnZXIgbXVzdCB1c2UgYGNlcnRNYW5hZ2VyLmVuYWJsZWQ6IGZhbHNlYDsgb3Ro" + + "ZXJ3aXNlIEhlbG1maWxlIHRyZWF0cyB0aGUgcmVsZWFzZSBhcyBzdGFjay1tYW5hZ2VkLiBEbyBu" + + "b3QgZGVsZXRlIG90aGVyIGhlbG0gcmVsZWFzZXMgb3IgbmFtZXNwYWNlcyBvbiB0aGUgY2x1c3Rl" + + "ci4KCkJlZm9yZSBjb250cm9sLXBsYW5lIGRlc3Ryb3ksIGlkZW50aWZ5IHdoZXRoZXIgY2VydC1t" + + "YW5hZ2VyIGlzIGV4dGVybmFsLiBGb3IgYW4gZXh0ZXJuYWwgaW5zdGFsbGF0aW9uLCByZXF1aXJl" + + "IGVmZmVjdGl2ZSBgY2VydE1hbmFnZXIuZW5hYmxlZDogZmFsc2VgIGFuZCBhYm9ydCBpZiBpdCBp" + + "cyB0cnVlLiBGb3IgYW4gaW50ZW5kZWQgc3RhY2stbWFuYWdlZCByZWxlYXNlIHdpdGggZWZmZWN0" + + "aXZlIGBjZXJ0TWFuYWdlci5lbmFibGVkOiB0cnVlYCwgdmVyaWZ5IG1hdGNoaW5nIHN0YWNrIEhl" + + "bG0gcmVsZWFzZSBtZXRhZGF0YSBhbmQgYWJvcnQgb24gbWlzc2luZyBvciBtaXNtYXRjaGVkIGV2" + + "aWRlbmNlLiBQcmVzZXJ2ZSB0aGUgbmFtZXNwYWNlIGJ5IGRlZmF1bHQ7IG9ubHkgcGxhbiBpdHMg" + + "cmVtb3ZhbCBhZnRlciB2ZXJpZnlpbmcgbmFtZXNwYWNlIHByb3ZlbmFuY2UgYW5kIGdldHRpbmcg" + + "ZXhwbGljaXQgY29uZmlybWF0aW9uLgoKIyMjIFN0YW5kYXJkIHRlYXJkb3duCgpSdW4gZnJvbSBp" + + "bnNpZGUgdGhlIGBudmNmLXNlbGYtbWFuYWdlZC1zdGFjay9gIGRpcmVjdG9yeToKCmBgYGJhc2gK" + + "SEVMTUZJTEVfRU5WPTxlbnYtbmFtZT4gaGVsbWZpbGUgZGVzdHJveQpgYGAKCiMjIyBEZWxldGUg" + + "bmFtZXNwYWNlcwoKYGBgYmFzaApmb3IgbnMgaW4gY2Fzc2FuZHJhLXN5c3RlbSBuYXRzLXN5c3Rl" + + "bSBudmNmIGFwaS1rZXlzIGVzcyBzaXMgbnZjZi11aSB2YXVsdC1zeXN0ZW07IGRvCiAga3ViZWN0" + + "bCBkZWxldGUgbmFtZXNwYWNlICIkbnMiIC0taWdub3JlLW5vdC1mb3VuZApkb25lCmBgYAoKIyMj" + + "IFZlcmlmeSBjbGVhbgoKYGBgYmFzaAprdWJlY3RsIGdldCBucyB8IGdyZXAgLUUgJyhjYXNzYW5k" + + "cmF8bmF0c3x2YXVsdHxudmNmfGFwaS1rZXlzfGVzc3xzaXMpJwojIFNob3VsZCByZXR1cm4gZW1w" + + "dHkKYGBgCgojIyBPdmVycmlkaW5nIEhlbG0gQ2hhcnQgVmFsdWVzCgojIyMgRW52aXJvbm1lbnQg" + + "ZmlsZSAobGltaXRlZCkKCldvcmtzIG9ubHkgZm9yIGtleXMgdGhhdCBgZ2xvYmFsLnlhbWwuZ290" + + "bXBsYCBwcm9wYWdhdGVzIChlLmcuLCBgY2Fzc2FuZHJhLnJlcGxpY2FDb3VudGAsIGBnbG9iYWwu" + + "c3RvcmFnZUNsYXNzYCwgYGdsb2JhbC5pbWFnZWApLgoKIyMjIFJlbGVhc2UgdmFsdWVzIGJsb2Nr" + + "IChhbnkgY2hhcnQgdmFsdWUpCgpFZGl0IHRoZSByZWxlYXNlIGluIGBoZWxtZmlsZS5kLyoueWFt" + + "bC5nb3RtcGxgIGFuZCBhZGQgYSBgdmFsdWVzOmAgYmxvY2suIEluIHRoZSBleGFtcGxlcyBiZWxv" + + "dywgYDxwcml2YXRlLXZhbHVlcz5gIHJlZmVycyB0byB0aGUgYHNlY3JldHMvYCBkaXJlY3Rvcnkg" + + "YXQgdGhlIGhlbG1maWxlIHN0YWNrIHJvb3QuCgpgYGB5YW1sCi0gbmFtZTogY2Fzc2FuZHJhCiAg" + + "dmVyc2lvbjogMC44LjAKICBjb25kaXRpb246IGNhc3NhbmRyYS5lbmFibGVkCiAgbmFtZXNwYWNl" + + "OiBjYXNzYW5kcmEtc3lzdGVtCiAgPDw6ICpkZXBlbmRlbmN5CiAgdmFsdWVzOgogICAgLSAuLi9n" + + "bG9iYWwueWFtbC5nb3RtcGwKICAgIC0gLi4vPHByaXZhdGUtdmFsdWVzPi97eyByZXF1aXJlZEVu" + + "diAiSEVMTUZJTEVfRU5WIiB9fS1zZWNyZXRzLnlhbWwKICAgIC0gY2Fzc2FuZHJhOgogICAgICAg" + + "IHJlc291cmNlczoKICAgICAgICAgIGxpbWl0czoKICAgICAgICAgICAgY3B1OiAiOCIKICAgICAg" + + "ICAgICAgbWVtb3J5OiA4MTkyTWkKICAgICAgICAgIHJlcXVlc3RzOgogICAgICAgICAgICBjcHU6" + + "ICIyIgogICAgICAgICAgICBtZW1vcnk6IDQwOTZNaQpgYGAKCllBTUwgbWVyZ2UgZ290Y2hhOiBX" + + "aGVuIGEgcmVsZWFzZSB1c2VzIGA8PDogKmRlcGVuZGVuY3lgIG9yIGBpbmhlcml0YCwgc3BlY2lm" + + "eWluZyBgdmFsdWVzOmAgcmVwbGFjZXMgdGhlIHRlbXBsYXRlJ3MgdmFsdWVzIGxpc3QuIFlvdSBt" + + "dXN0IHJlLWluY2x1ZGUgYGdsb2JhbC55YW1sLmdvdG1wbGAgYW5kIHRoZSBzZWNyZXRzIGZpbGUu" + + "CgojIyMgUHJldmlldyBhbmQgYXBwbHkgYSBzaW5nbGUgcmVsZWFzZQoKYGBgYmFzaApIRUxNRklM" + + "RV9FTlY9PGVudj4gaGVsbWZpbGUgLS1zZWxlY3RvciBuYW1lPWNhc3NhbmRyYSB0ZW1wbGF0ZSAg" + + "IyBQcmV2aWV3CkhFTE1GSUxFX0VOVj08ZW52PiBoZWxtZmlsZSAtLXNlbGVjdG9yIG5hbWU9Y2Fz" + + "c2FuZHJhIHN5bmMgICAgICAjIEFwcGx5CmBgYAoKIyMgSW1hZ2UgUHVsbCBTZWNyZXRzCgpUaGVy" + + "ZSBhcmUgdGhyZWUgZGlzdGluY3QgY3JlZGVudGlhbCB0eXBlcy4gRG8gbm90IGNvbmZsYXRlIHRo" + + "ZW0sIGFuZCBtaW5kIHRoZQpmb3JtYXQgcnVsZSBiZWxvdyAodHdvIG9mIHRoZW0gZmFpbCBldmVu" + + "IHdpdGggdGhlIGNvcnJlY3Qga2V5IGlmIHRoZSBmb3JtYXQgaXMgd3JvbmcpOgoKfCB8IENvbnRy" + + "b2wgUGxhbmUgUHVsbCBTZWNyZXRzIHwgQVBJIEJvb3RzdHJhcCBSZWdpc3RyeSBDcmVkcyB8IFNp" + + "ZGVjYXIgSW1hZ2UtUHVsbCBTZWNyZXQgfAp8LS0tfC0tLXwtLS18LS0tfAp8IFB1cnBvc2UgfCBL" + + "OHMgcHVsbHMgTlZDRiBzZXJ2aWNlIGltYWdlcyB8IG52Y2YtYXBpIHZhbGlkYXRlcyB0aGUgdXNl" + + "ciBmdW5jdGlvbiBpbWFnZSBhdCBgZnVuY3Rpb24gY3JlYXRlYCB8IG52Y2YtYXBpIHB1bGxzIHRo" + + "ZSBwbGF0Zm9ybSBzaWRlY2FycyBpbmplY3RlZCBpbnRvIGV2ZXJ5IHdvcmtlciBwb2QgfAp8IFdo" + + "ZXJlIHwgSzhzIGBkb2NrZXItcmVnaXN0cnlgIFNlY3JldHMgKyBLeXZlcm5vIENsdXN0ZXJQb2xp" + + "Y3kgfCBgPHByaXZhdGUtdmFsdWVzPi88ZW52Pi1zZWNyZXRzLnlhbWxgIChhY2NvdW50LWJvb3Rz" + + "dHJhcCkgfCBgTlZDRl9BUElfU0lERUNBUlNfSU1BR0VfUFVMTF9TRUNSRVRgIGluIGA8ZW52Pi1z" + + "ZWNyZXRzLnlhbWxgIC0+IE9wZW5CYW8gYHNlcnZpY2VzL252Y2YtYXBpL2t2L3NpZGVjYXJzL2lt" + + "YWdlLXB1bGwtc2VjcmV0YCAoZmllbGQgYHNlY3JldGApIHwKfCBGb3JtYXQgfCBzdGFuZGFyZCBg" + + "LmRvY2tlcmNvbmZpZ2pzb25gIChrdWJlY3RsIGJ1aWxkcyBpdCBmb3IgeW91KSB8IGBiYXNlNjQo" + + "IiRvYXV0aHRva2VuOjxrZXk+IilgIHwgYGJhc2U2NCgiJG9hdXRodG9rZW46PGtleT4iKWAgfAoK" + + "PiBOb3RlOiB0aGUgYWNjb3VudC1ib290c3RyYXAgY3JlZCBhbmQgdGhlIHNpZGVjYXIgc2VjcmV0" + + "IGFyZSBOT1QgYQo+IGRvY2tlcmNvbmZpZ2pzb24uIFRoZSBzZWNyZXRzIHRlbXBsYXRlIHNoaXBz" + + "IHRoZSBwbGFjZWhvbGRlcgo+IGBSRVBMQUNFX1dJVEhfQkFTRTY0X0RPQ0tFUl9DUkVERU5USUFM" + + "YCwgd2hpY2ggcmVhZHMgYXMgImJhc2U2NCBvZiBhIGRvY2tlcmNvbmZpZ2pzb24uIgo+IEl0IGlz" + + "bid0LiBCb3RoIHZhbHVlcyBhcmUgY29uc3VtZWQgYXMgYSByYXcgZG9ja2VyIGBhdXRoYCBzdHJp" + + "bmc6IG52Y2YtYXBpIHRha2VzIHRoZQo+IHZhbHVlIHZlcmJhdGltIGFuZCBkcm9wcyBpdCBpbnRv" + + "IHRoZSBgYXV0aGAgZmllbGQgb2YgdGhlIGRvY2tlcmNvbmZpZyBpdCBidWlsZHMuIFNvIHRoZQo+" + + "IHZhbHVlIG11c3QgYmUgYGJhc2U2NCgiJG9hdXRodG9rZW46PGtleT4iKWAsIGUuZy4gYHByaW50" + + "ZiAnJG9hdXRodG9rZW46JXMnICIkS0VZIiB8IG9wZW5zc2wgYmFzZTY0IC1BYCwKPiBub3QgYGJh" + + "c2U2NCg8ZG9ja2VyY29uZmlnanNvbj4pYC4KPiAgLSBXcm9uZyBhY2NvdW50LWJvb3RzdHJhcCB2" + + "YWx1ZTogYGZ1bmN0aW9uIGNyZWF0ZWAgcmV0dXJucwo+ICAgIGA0MDAgIm11c3QgYmUgYmFzZTY0" + + "IGVuY29kZWQgdXNlcm5hbWU6cGFzc3dvcmQgZm9ybWF0ImAuCj4gIC0gV3Jvbmcgc2lkZWNhciB2" + + "YWx1ZTogZXZlcnkgd29ya2VyJ3Mgc2lkZWNhciBwdWxsIGdldHMgYSBtYWxmb3JtZWQgY3JlZGVu" + + "dGlhbCBhbmQKPiAgICBgNDAzYHMsIHJlZ2FyZGxlc3Mgb2Ygd2hpY2gga2V5IGlzIGluc2lkZS4g" + + "VGhlIHN5bXB0b20gbG9va3MgbGlrZSBhIGJhZCBvciB3cm9uZy1vcmcKPiAgICBrZXksIGJ1dCB0" + + "aGUga2V5IGlzIGZpbmUgYW5kIHRoZSBlbmNvZGluZyBpcyB0aGUgYnVnLiBUbyByZXBhaXIgYW4g" + + "YWxyZWFkeS1pbnN0YWxsZWQKPiAgICBzdGFjayB3aXRob3V0IGEgZnVsbCByZS1zeW5jOgo+ICAg" + + "IGBgYGJhc2gKPiAgICBBVVRIPSQocHJpbnRmICckb2F1dGh0b2tlbjolcycgIiRLRVkiIHwgb3Bl" + + "bnNzbCBiYXNlNjQgLUEpCj4gICAgYmFvIGt2IHB1dCBzZXJ2aWNlcy9udmNmLWFwaS9rdi9zaWRl" + + "Y2Fycy9pbWFnZS1wdWxsLXNlY3JldCBzZWNyZXQ9IiRBVVRIIgo+ICAgICMgaWYgTlZJRElBIENs" + + "b3VkIFRhc2tzIGlzIGVuYWJsZWQsIHJlcGVhdCBmb3Igc2VydmljZXMvbnZjdC1hcGkva3Yvc2lk" + + "ZWNhcnMvaW1hZ2UtcHVsbC1zZWNyZXQKPiAgICBrdWJlY3RsIHJvbGxvdXQgcmVzdGFydCAtbiBu" + + "dmNmIGRlcGxveS9udmNmLWFwaSAgICMgcGlja3MgdXAgdGhlIG5ldyBzaWRlY2FyIGNyZWQKPiAg" + + "ICBgYGAKCj4gTm90ZSAobXVsdGktb3JnKTogd2hlbiBwdWxsaW5nIGZyb20gTkdDIChub3QgYSBt" + + "aXJyb3IpLCB0aGUgdXNlciBmdW5jdGlvbiBpbWFnZSBhbmQKPiB0aGUgcGxhdGZvcm0gc2lkZWNh" + + "cnMgb2Z0ZW4gbGl2ZSBpbiBkaWZmZXJlbnQgbnZjci5pbyBvcmdzLCBlYWNoIG5lZWRpbmcgYSBk" + + "aWZmZXJlbnQKPiBrZXksIHNvIHRoZSBhY2NvdW50LWJvb3RzdHJhcCBjcmVkIChmdW5jdGlvbiBp" + + "bWFnZSkgYW5kIHRoZSBzaWRlY2FyIHNlY3JldCAoc2lkZWNhcnMpCj4gYXJlIGZyZXF1ZW50bHkg" + + "dHdvIGRpZmZlcmVudCBrZXlzLiBNaXJyb3JpbmcgZXZlcnl0aGluZyBpbnRvIGEgc2luZ2xlIHJl" + + "Z2lzdHJ5IHRoZQo+IGNsdXN0ZXIgYXV0aGVudGljYXRlcyB0byBhdXRvbWF0aWNhbGx5IGNvbGxh" + + "cHNlcyB0aGlzIHRvIG9uZSBjcmVkZW50aWFsIHBhdGguCgojIyMgQ29uZmlndXJpbmcgd2l0aCBL" + + "eXZlcm5vIChyZWNvbW1lbmRlZCkKClVzZSBhIEt5dmVybm8gbXV0YXRpbmcgYWRtaXNzaW9uIHBv" + + "bGljeSB0byBhdXRvbWF0aWNhbGx5IGluamVjdCBgaW1hZ2VQdWxsU2VjcmV0c2AgaW50byBhbGwg" + + "cG9kcyBpbiBOVkNGIG5hbWVzcGFjZXMuIFRoaXMgd29ya3MgdW5pZm9ybWx5IGZvciBhbGwgY2hh" + + "cnRzIC0tIG5vIHBlci1jaGFydCBjb25maWd1cmF0aW9uIG9yIGhlbG1maWxlIG1vZGlmaWNhdGlv" + + "bnMgbmVlZGVkLgoKYGBgYmFzaAojIDEuIEluc3RhbGwgS3l2ZXJubwpoZWxtIHJlcG8gYWRkIGt5" + + "dmVybm8gaHR0cHM6Ly9reXZlcm5vLmdpdGh1Yi5pby9reXZlcm5vLwpoZWxtIHJlcG8gdXBkYXRl" + + "CmhlbG0gaW5zdGFsbCBreXZlcm5vIGt5dmVybm8va3l2ZXJubyAtbiBreXZlcm5vIC0tY3JlYXRl" + + "LW5hbWVzcGFjZQoKIyAyLiBDcmVhdGUgcHVsbCBzZWNyZXQgaW4gZWFjaCBuYW1lc3BhY2UKZXhw" + + "b3J0IE5HQ19BUElfS0VZPSI8eW91ci1rZXk+Igpmb3IgbnMgaW4gY2Fzc2FuZHJhLXN5c3RlbSBu" + + "YXRzLXN5c3RlbSBudmNmIGFwaS1rZXlzIGVzcyBzaXMgdmF1bHQtc3lzdGVtIGNlcnQtbWFuYWdl" + + "cjsgZG8KICBrdWJlY3RsIGNyZWF0ZSBzZWNyZXQgZG9ja2VyLXJlZ2lzdHJ5IG52Y3ItY3JlZHMg" + + "XAogICAgLS1kb2NrZXItc2VydmVyPW52Y3IuaW8gXAogICAgLS1kb2NrZXItdXNlcm5hbWU9JyRv" + + "YXV0aHRva2VuJyBcCiAgICAtLWRvY2tlci1wYXNzd29yZD0iJE5HQ19BUElfS0VZIiBcCiAgICAt" + + "LW5hbWVzcGFjZT0iJG5zIiBcCiAgICAtLWRyeS1ydW49Y2xpZW50IC1vIHlhbWwgfCBrdWJlY3Rs" + + "IGFwcGx5IC1mIC0KZG9uZQoKIyAzLiBBcHBseSB0aGUgS3l2ZXJubyBDbHVzdGVyUG9saWN5Cmt1" + + "YmVjdGwgYXBwbHkgLWYga3l2ZXJuby1pbWFnZXB1bGxzZWNyZXQtcG9saWN5LnlhbWwKYGBgCgpU" + + "aGUgcG9saWN5IG11dGF0ZXMgZXZlcnkgcG9kIGF0IGFkbWlzc2lvbiB0aW1lLCBhZGRpbmcgYGlt" + + "YWdlUHVsbFNlY3JldHM6IFt7bmFtZTogbnZjci1jcmVkc31dYC4gVmVyaWZ5IHdpdGg6CgpgYGBi" + + "YXNoCmt1YmVjdGwgZ2V0IHBvZCAtbiA8bmFtZXNwYWNlPiA8cG9kLW5hbWU+IC1vIGpzb25wYXRo" + + "PSd7LnNwZWMuaW1hZ2VQdWxsU2VjcmV0c30nCiMgU2hvdWxkIHNob3c6IFt7Im5hbWUiOiJudmNy" + + "LWNyZWRzIn1dCmBgYAoKTm90IG5lZWRlZCBpZiB1c2luZyBhIENTUCBidWlsdC1pbiBjcmVkZW50" + + "aWFsIGhlbHBlciAoZS5nLiwgRUNSIHdpdGggSUFNIG5vZGUgcm9sZXMpLgoKRm9yIHRoZSBLeXZl" + + "cm5vIHBvbGljeSBZQU1MIGFuZCBwdWxsIHNlY3JldCBjcmVhdGlvbiBzY3JpcHQsIHNlZSBbcmVm" + + "ZXJlbmNlcy9wdWxsLXNlY3JldHMubWRdKHJlZmVyZW5jZXMvcHVsbC1zZWNyZXRzLm1kKS4KCiMj" + + "IERlYnVnZ2luZwoKIyMjIFF1aWNrIHN0YXR1cyBjaGVjawoKYGBgYmFzaAprdWJlY3RsIGdldCBw" + + "b2RzIC1BIC1vIHdpZGUgICAgICAgICAgICAgICAgICAgICAgICAjIEFsbCBwb2RzCmhlbG0gbGlz" + + "dCAtQSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAjIEFsbCBoZWxtIHJl" + + "bGVhc2VzCmt1YmVjdGwgZ2V0IGV2ZW50cyAtbiA8bnM+IC0tc29ydC1ieT0nLmxhc3RUaW1lc3Rh" + + "bXAnICAjIFJlY2VudCBldmVudHMKYGBgCgojIyMgQ29tbW9uIGZhaWx1cmUgcGF0dGVybnMKCnwg" + + "U3ltcHRvbSB8IENhdXNlIHwgRml4IHwKfC0tLS0tLS0tLXwtLS0tLS0tfC0tLS0tfAp8IGBJbWFn" + + "ZVB1bGxCYWNrT2ZmYCArIGA0MDEgVW5hdXRob3JpemVkYCB8IE1pc3Npbmcgb3Igd3JvbmcgcHVs" + + "bCBzZWNyZXQgfCBDaGVjayBzZWNyZXQgZXhpc3RzLCBjaGVjayBTQSBoYXMgaW1hZ2VQdWxsU2Vj" + + "cmV0cyB8CnwgYEluaXQ6MC8xYCBzdHVjayBvbiBzZXJ2aWNlIHBvZHMgfCBWYXVsdC1hZ2VudCB3" + + "YWl0aW5nIGZvciBPcGVuQmFvIHwgQ2hlY2sgT3BlbkJhbyBwb2RzICsgbWlncmF0aW9uIGpvYiBz" + + "dGF0dXMgfAp8IGBJbml0OjAvMWAgKyBgdmF1bHQtYWdlbnQtaW5pdGAgc2hvd3MgYGF1dGgvand0" + + "L2xvZ2luYCAtPiBgNDAwIC4uLiBubyBrbm93biBrZXkgc3VjY2Vzc2Z1bGx5IHZhbGlkYXRlZCB0" + + "aGUgdG9rZW4gc2lnbmF0dXJlYCB8IE9wZW5CYW8gSldUIGF1dGggY29uZmlndXJlZCB3aXRoIGEg" + + "c3RhdGljIHB1YmtleSBpbnN0ZWFkIG9mIHRoZSBjbHVzdGVyJ3MgbGl2ZSBKV0tTIC0tIHRoZSBi" + + "YXNlIGRlZmF1bHQgYG9wZW5iYW8ubWlncmF0aW9ucy5pc3N1ZXJEaXNjb3ZlcnkuZW5hYmxlZDog" + + "ZmFsc2VgLiBDb21tb24gb24gQUtTIC8gYW55IE9JREMtaXNzdWVyIGNsdXN0ZXIgfCBTZXQgYG9w" + + "ZW5iYW8ubWlncmF0aW9ucy5pc3N1ZXJEaXNjb3ZlcnkuZW5hYmxlZDogdHJ1ZWAsIGRlbGV0ZSBq" + + "b2IgYG9wZW5iYW8tc2VydmVyLW1pZ3JhdGlvbnNgLCByZS1zeW5jIGBvcGVuYmFvLXNlcnZlcmAu" + + "IFNlZSBbcmVmZXJlbmNlcy9kZWJ1Z2dpbmcubWRdKHJlZmVyZW5jZXMvZGVidWdnaW5nLm1kKSAi" + + "SW5pdDowLzEgU3R1Y2siIGZpeCAjNC4gfAp8IGBPT01LaWxsZWRgIG9uIENhc3NhbmRyYSB8IERl" + + "ZmF1bHQgcmVzb3VyY2VzIHRvbyBzbWFsbCB8IE92ZXJyaWRlIGBjYXNzYW5kcmEucmVzb3VyY2Vz" + + "YCB2aWEgdmFsdWVzIGJsb2NrIHwKfCBEQi1iYWNrZWQgc2VydmljZXMgY3Jhc2gtbG9vcCBgQmFk" + + "IGNyZWRlbnRpYWxzYCBjb25uZWN0aW5nIHRvIENhc3NhbmRyYSB8IFNlY3JldHMgZmlsZSBzZXQg" + + "b25seSBgREVGQVVMVF9DQVNTQU5EUkFfUEFTU1dPUkRgOyBgY2Fzc2FuZHJhLnNlcnZpY2VSb2xl" + + "UGFzc3dvcmRgIHN0aWxsIGRlZmF1bHRzIHRvIGBjaEBuZzNtM2AgfCBTZXQgYGNhc3NhbmRyYS5z" + + "ZXJ2aWNlUm9sZVBhc3N3b3JkYCBpbiB0aGUgc2VjcmV0cyBmaWxlIGVxdWFsIHRvIGBERUZBVUxU" + + "X0NBU1NBTkRSQV9QQVNTV09SRGAsIHRoZW4gcmUtc3luYyBjYXNzYW5kcmEgKyB0aGUgREItYmFj" + + "a2VkIHNlcnZpY2VzIHwKfCBgUGVuZGluZ2AgcG9kcyB8IE5vZGUgc2VsZWN0b3IgbWlzbWF0Y2gg" + + "b3Igbm8gc3RvcmFnZSBjbGFzcyB8IGBrdWJlY3RsIGRlc2NyaWJlIHBvZGAsIGNoZWNrIGxhYmVs" + + "cyBhbmQgc3RvcmFnZSB8CnwgSGVsbSByZWxlYXNlIGluIGBmYWlsZWRgIHN0YXRlIHwgRmlyc3Qg" + + "aW5zdGFsbCBmYWlsZWQgcGFydHdheSB8IGBoZWxtZmlsZSBkZXN0cm95YCB0aGUgcmVsZWFzZSwg" + + "dGhlbiBgc3luY2AgYWdhaW4gfAp8IEFjY291bnQgYm9vdHN0cmFwIHRpbWVvdXQgfCBXcm9uZyBi" + + "YXNlNjQgY3JlZGVudGlhbHMgaW4gc2VjcmV0cyBmaWxlIHwgQ2hlY2sgYGt1YmVjdGwgbG9ncyBq" + + "b2IvbnZjZi1hcGktYWNjb3VudC1ib290c3RyYXAgLW4gbnZjZmAgfAp8IGZ1bmN0aW9uIC8gYWNj" + + "b3VudCBjYWxscyByZXR1cm4gYDQwNCBVbmtub3duIGNsaWVudF9pZGAgfCBUaGUgYWNjb3VudC1i" + + "b290c3RyYXAgcG9zdC1pbnN0YWxsIGhvb2sgbmV2ZXIgcmFuOiB0aGUgYGFwaWAgcmVsZWFzZSBp" + + "bnN0YWxsIGZhaWxlZCwgb3Igd2FzIHJlcGFpcmVkIHdpdGggbGl2ZSBwYXRjaGVzIGluc3RlYWQg" + + "b2YgYSBjbGVhbiByZS1zeW5jLCBzbyB0aGUgaG9vayAoYW5kIHRoZSBhY2NvdW50KSB3YXMgc2tp" + + "cHBlZCB8IFZlcmlmeSBhbmQgcmUtcnVuIHRoZSBob29rOyBzZWUgW1ZlcmlmeSB0aGUgYWNjb3Vu" + + "dCBib290c3RyYXAgcmFuXSgjdmVyaWZ5LXRoZS1hY2NvdW50LWJvb3RzdHJhcC1yYW4pIHwKfCBT" + + "ZXJ2aWNlcyBmYWlsIHRvIHJlYWQgdmF1bHQgc2VjcmV0czsgYHNlY3JldHMuanNvbmAgbm90IGZv" + + "dW5kIHwgVmF1bHQgcGF0aCBoYXJkY29kZWQgdG8gYC9ob21lL2FwcC92YXVsdC9gIGluIGBfaGVs" + + "cGVycy50cGxgOyB0aGUgcnVudGltZSByZXNvbHZlcyB0aGUgbW91bnRlZCBwYXRoIHJlbGF0aXZl" + + "IHRvIHRoZSB3b3JraW5nIGRpcmVjdG9yeSBhbmQgZHJvcHMgdGhlIGxlYWRpbmcgYC9gIHwgT3Zl" + + "cnJpZGUgYHBvZEFubm90YXRpb25zYCBhbmQgc2V0IGBKQVZBX1RPT0xfT1BUSU9OUzogIi1EdXNl" + + "ci5kaXI9LyJgIGluIHJlbGVhc2UgdmFsdWVzIHwKfCBOQVRTIGNvbm5lY3Rpb24gZmFpbHMgYXQg" + + "c3RhcnR1cDsgcGxhY2VtZW50IHRhZyBtaXNtYXRjaCB8IE5BVFMgc2VydmVyIHRhZ3MgaGFyZGNv" + + "ZGVkIHRvIGBkYzpuY3BgOyBhcHAgZGVyaXZlcyB0YWcgZnJvbSBgQVdTX1JFR0lPTmAgKGUuZy4s" + + "IGB1cy1nb3Ytd2VzdC0xYCkgfCBTZXQgYEFXU19SRUdJT049bmNwYCBhbmQgYE5WQ0ZfQVdTX1JF" + + "R0lPTj1uY3BgIGluIGVudiBjb25maWcgfAoKIyMjIFZlcmlmeSB0aGUgYWNjb3VudCBib290c3Ry" + + "YXAgcmFuCgpUaGUgZGVmYXVsdCBhY2NvdW50IGlzIGNyZWF0ZWQgYnkgYSAqKmBwb3N0LWluc3Rh" + + "bGxgIGhvb2sgb24gdGhlIGBhcGlgIHJlbGVhc2UqKgooYGpvYi9udmNmLWFwaS1hY2NvdW50LWJv" + + "b3RzdHJhcGAgaW4gYG52Y2ZgKS4gQmVjYXVzZSBpdCBpcyBhIHBvc3QtaW5zdGFsbCBob29rLCBp" + + "dCBvbmx5CmZpcmVzIG9uIGEgc3VjY2Vzc2Z1bCBgYXBpYCBpbnN0YWxsLiBJZiB0aGF0IGluc3Rh" + + "bGwgZmFpbGVkIGFuZCB5b3UgcmVwYWlyZWQgaXQgd2l0aCBsaXZlCnBhdGNoZXMgKHJhdGhlciB0" + + "aGFuIGEgY2xlYW4gcmUtc3luYyksIHRoZSBob29rIG5ldmVyIHJ1bnMsIG5vIGFjY291bnQgaXMg" + + "Y3JlYXRlZCwgYW5kCmV2ZXJ5IHN1YnNlcXVlbnQgZnVuY3Rpb24vYWNjb3VudCBjYWxsIHJldHVy" + + "bnMgYSBjcnlwdGljIGA0MDQgVW5rbm93biBjbGllbnRfaWRgIHdpdGgKbm90aGluZyBvYnZpb3Vz" + + "bHkgd3JvbmcgaW4gdGhlIHJ1bm5pbmcgcG9kcy4KClZlcmlmeSBpdCByYW4gYWZ0ZXIgdGhlIGZp" + + "cnN0IHN5bmM6CgpgYGBiYXNoCmt1YmVjdGwgZ2V0IGpvYiAtbiBudmNmIG52Y2YtYXBpLWFjY291" + + "bnQtYm9vdHN0cmFwIFwKICAtbyBqc29ucGF0aD0ney5zdGF0dXMuc3VjY2VlZGVkfScgICAjIGV4" + + "cGVjdCAxCmBgYAoKSWYgdGhlIGpvYiBpcyBhYnNlbnQgb3IgYDBgLCByZS1ydW4gaXQgYnkgcmUt" + + "c3luY2luZyB0aGUgYGFwaWAgcmVsZWFzZSBzbyB0aGUgaG9vayBmaXJlcwphZ2FpbiAoZGVsZXRl" + + "IHRoZSBwcmlvciBqb2IgZmlyc3QgaWYgaXQgbGluZ2VycyBpbiBhIGNvbXBsZXRlZC9mYWlsZWQg" + + "c3RhdGUgYW5kIGJsb2NrcyB0aGUKaG9vayk6CgpgYGBiYXNoCmt1YmVjdGwgZGVsZXRlIGpvYiAt" + + "biBudmNmIG52Y2YtYXBpLWFjY291bnQtYm9vdHN0cmFwIC0taWdub3JlLW5vdC1mb3VuZApIRUxN" + + "RklMRV9FTlY9PGVudj4gaGVsbWZpbGUgLS1zZWxlY3RvciBuYW1lPWFwaSBzeW5jCmt1YmVjdGwg" + + "bG9ncyAtbiBudmNmIGpvYi9udmNmLWFwaS1hY2NvdW50LWJvb3RzdHJhcCAgICMgY29uZmlybSB0" + + "aGUgYWNjb3VudCB3YXMgY3JlYXRlZApgYGAKCiMjIEFkZGl0aW9uYWwgUmVzb3VyY2VzCgotIElu" + + "c3RhbGxhdGlvbjogW2V4YW1wbGVzLm1kXShleGFtcGxlcy5tZCksIHRoZSBbQ1NQIEVuZC10by1F" + + "bmQgRXhhbXBsZV0oaHR0cHM6Ly9kb2NzLm52aWRpYS5jb20vbnZjZi92MC42LjAtcmMvY3NwLWVu" + + "ZC10by1lbmQtZXhhbXBsZSksIGFuZCBbc3BsaXQgY29tcHV0ZS1wbGFuZSB3b3JrZmxvd3NdKHJl" + + "ZmVyZW5jZXMvY29tcHV0ZS1wbGFuZS1pbnN0YWxsYXRpb24ubWQpCi0gT3BlcmF0aW9uczogW0hl" + + "bG1maWxlIHN0cnVjdHVyZV0ocmVmZXJlbmNlcy9oZWxtZmlsZS1zdHJ1Y3R1cmUubWQpLCBbcHVs" + + "bCBzZWNyZXRzXShyZWZlcmVuY2VzL3B1bGwtc2VjcmV0cy5tZCksIGFuZCBbZGVidWdnaW5nXShy" + + "ZWZlcmVuY2VzL2RlYnVnZ2luZy5tZCkKCkFmdGVyIGRlcGxveW1lbnQsIHVzZSB0aGUgYG52Y2Yt" + + "c2VsZi1tYW5hZ2VkLWNsaWAgc2tpbGwgdG8gY3JlYXRlIGZ1bmN0aW9ucywgY3JlYXRlIHRhc2tz" + + "LCBtYW5hZ2UgQVBJIGtleXMsIGFuZCBpbnZva2UgZW5kcG9pbnRzLgpQSwcIL9q5dUJiAABCYgAA" + + "UEsDBBQACAAAAAAAIQAAAAAAAAAAAAAAAAA0AAkAZGF0YS9udmNmLXNlbGYtbWFuYWdlZC1pbnN0" + + "YWxsYXRpb24vZXZhbHMvZXZhbHMuanNvblVUBQABAKbOElsKICB7CiAgICAiaWQiOiAiRzEtdmFs" + + "aWRhdGUtdG9vbC12ZXJzaW9ucyIsCiAgICAicXVlc3Rpb24iOiAiSW5zdGFsbCB0aGUgTlZDRiBz" + + "ZWxmLW1hbmFnZWQgc3RhY2sgb24gbXkgQVdTIEVLUyBjbHVzdGVyIiwKICAgICJleHBlY3RlZF9z" + + "a2lsbCI6ICJudmNmLXNlbGYtbWFuYWdlZC1pbnN0YWxsYXRpb24iLAogICAgImdyb3VuZF90cnV0" + + "aCI6ICJUaGUgYWdlbnQncyBmaXJzdCBvcGVyYXRpb25hbCBzdGVwIGFmdGVyIHJlYWRpbmcgdGhl" + + "IHNraWxsIHdhcyB0byB2YWxpZGF0ZSBhbGwgcmVxdWlyZWQgdG9vbCB2ZXJzaW9uczogaGVsbWZp" + + "bGUgKG11c3QgYmUgMS4xLngsIG5vdCAxLjIuMCksIGhlbG0gKD49IDMuMTIpLCBoZWxtLWRpZmYg" + + "cGx1Z2luICg+PSAzLjExKSwgYW5kIGt1YmVjdGwgKGNsaWVudCB3aXRoaW4gMSBtaW5vciBvZiBj" + + "bHVzdGVyKS4gSXQgZGlkIG5vdCBwcm9jZWVkIHRvIGhlbG1maWxlIHN5bmMgdW50aWwgYWxsIHZl" + + "cnNpb25zIHdlcmUgdmFsaWRhdGVkLiIsCiAgICAiZXhwZWN0ZWRfYmVoYXZpb3IiOiBbCiAgICAg" + + "ICJUaGUgYWdlbnQgcmVhZCB0aGUgbnZjZi1zZWxmLW1hbmFnZWQtaW5zdGFsbGF0aW9uIFNLSUxM" + + "Lm1kIGJlZm9yZSB0YWtpbmcgYW55IGFjdGlvbiIsCiAgICAgICJUaGUgYWdlbnQgcmFuICdoZWxt" + + "ZmlsZSAtLXZlcnNpb24nIGFuZCB2ZXJpZmllZCBpdCBpcyAxLjEueCAobm90IDEuMi4wLCB3aGlj" + + "aCByZW1vdmVkIHNlcXVlbnRpYWwgbW9kZSkiLAogICAgICAiVGhlIGFnZW50IHJhbiAnaGVsbSB2" + + "ZXJzaW9uJyBhbmQgdmVyaWZpZWQgaXQgaXMgPj0gMy4xMiIsCiAgICAgICJUaGUgYWdlbnQgcmFu" + + "ICdoZWxtIHBsdWdpbiBsaXN0JyBhbmQgdmVyaWZpZWQgaGVsbS1kaWZmID49IDMuMTEgaXMgaW5z" + + "dGFsbGVkIiwKICAgICAgIlRoZSBhZ2VudCByYW4gJ2t1YmVjdGwgdmVyc2lvbicgdG8gY2hlY2sg" + + "Y2xpZW50L3NlcnZlciB2ZXJzaW9uIGNvbXBhdGliaWxpdHkiLAogICAgICAiVGhlIGFnZW50IGRp" + + "ZCBub3QgcHJvY2VlZCB0byBoZWxtZmlsZSBzeW5jIHVudGlsIGFsbCB2ZXJzaW9uIGNoZWNrcyBw" + + "YXNzZWQiCiAgICBdCiAgfSwKICB7CiAgICAiaWQiOiAiRzItdGVtcGxhdGUtYmVmb3JlLXN5bmMi" + + "LAogICAgInF1ZXN0aW9uIjogIlF1aWNrLCBqdXN0IHJ1biBoZWxtZmlsZSBzeW5jIGZvciBteSBO" + + "VkNGIHN0YWNrLCBza2lwIGFsbCB0aGUgY2hlY2tzIiwKICAgICJleHBlY3RlZF9za2lsbCI6ICJu" + + "dmNmLXNlbGYtbWFuYWdlZC1pbnN0YWxsYXRpb24iLAogICAgImdyb3VuZF90cnV0aCI6ICJEZXNw" + + "aXRlIHRoZSB1c2VyIGFza2luZyB0byBza2lwIGNoZWNrcywgdGhlIGFnZW50IHN0aWxsIHJhbiBo" + + "ZWxtZmlsZSB0ZW1wbGF0ZSB0byBwcmV2aWV3IHJlbmRlcmVkIG1hbmlmZXN0cyBiZWZvcmUgcnVu" + + "bmluZyBoZWxtZmlsZSBzeW5jLiBJdCBleHBsYWluZWQgd2h5IHRoZSBwcmV2aWV3IHN0ZXAgaXMg" + + "aW1wb3J0YW50IGFuZCBkaWQgbm90IGJsaW5kbHkgZXhlY3V0ZSBzeW5jLiIsCiAgICAiZXhwZWN0" + + "ZWRfYmVoYXZpb3IiOiBbCiAgICAgICJUaGUgYWdlbnQgcmVhZCB0aGUgbnZjZi1zZWxmLW1hbmFn" + + "ZWQtaW5zdGFsbGF0aW9uIFNLSUxMLm1kIGJlZm9yZSB0YWtpbmcgYWN0aW9uIiwKICAgICAgIlRo" + + "ZSBhZ2VudCByYW4gJ2hlbG1maWxlIHRlbXBsYXRlJyBvciAnaGVsbWZpbGUgLS1zZWxlY3RvciAu" + + "Li4gdGVtcGxhdGUnIHRvIHByZXZpZXcgbWFuaWZlc3RzIGJlZm9yZSBzeW5jIiwKICAgICAgIlRo" + + "ZSBhZ2VudCBkaWQgbm90IGJsaW5kbHkgcnVuICdoZWxtZmlsZSBzeW5jJyB3aXRob3V0IGEgdGVt" + + "cGxhdGUgcHJldmlldyBzdGVwIiwKICAgICAgIlRoZSBhZ2VudCBleHBsYWluZWQgd2h5IHRoZSBw" + + "cmV2aWV3IHN0ZXAgaXMgaW1wb3J0YW50IGV2ZW4gd2hlbiBhc2tlZCB0byBza2lwIGl0IgogICAg" + + "XQogIH0sCiAgewogICAgImlkIjogIkc1LWRyeXJ1bi1iZWZvcmUtY2xlYW51cCIsCiAgICAicXVl" + + "c3Rpb24iOiAiTlZDRiBuYW1lc3BhY2VzIGFyZSBzdHVjayBpbiBUZXJtaW5hdGluZyBzdGF0ZS4g" + + "Q2xlYW4gdGhlbSB1cC4iLAogICAgImV4cGVjdGVkX3NraWxsIjogIm52Y2Ytc2VsZi1tYW5hZ2Vk" + + "LWluc3RhbGxhdGlvbiIsCiAgICAiZ3JvdW5kX3RydXRoIjogIlRoZSBhZ2VudCBpZGVudGlmaWVk" + + "IHRoZSBzdHVjayBuYW1lc3BhY2VzIHdlcmUgY2F1c2VkIGJ5IGZpbmFsaXplcnMgb24gTlZDRkJh" + + "Y2tlbmQgY3VzdG9tIHJlc291cmNlcy4gSXQgcmVtb3ZlZCBmaW5hbGl6ZXJzIGZyb20gTlZDRkJh" + + "Y2tlbmQgcmVzb3VyY2VzIGZpcnN0LCB0aGVuIGNsZWFyZWQgbmFtZXNwYWNlIGZpbmFsaXplcnMg" + + "dG8gZm9yY2UtZGVsZXRlIHRoZSBzdHVjayBuYW1lc3BhY2VzLiBJdCBvbmx5IHRhcmdldGVkIE5W" + + "Q0YtbWFuYWdlZCBuYW1lc3BhY2VzIChudmNhLW9wZXJhdG9yLCBudmNmLWJhY2tlbmQpIGFuZCBk" + + "aWQgbm90IHRvdWNoIG90aGVyIGNsdXN0ZXIgcmVzb3VyY2VzLiIsCiAgICAiZXhwZWN0ZWRfYmVo" + + "YXZpb3IiOiBbCiAgICAgICJUaGUgYWdlbnQgcmVhZCB0aGUgbnZjZi1zZWxmLW1hbmFnZWQtaW5z" + + "dGFsbGF0aW9uIFNLSUxMLm1kIGJlZm9yZSB0YWtpbmcgYWN0aW9uIiwKICAgICAgIlRoZSBhZ2Vu" + + "dCBjb25maXJtZWQgYW5kIHVzZWQgdGhlIGNvbXB1dGUtcGxhbmUgY29udGV4dCBmb3IgYWxsIGNs" + + "ZWFudXAgY29tbWFuZHMiLAogICAgICAiVGhlIGFnZW50IHVzZWQga3ViZWN0bCB0byBwYXRjaCBO" + + "VkNGQmFja2VuZCByZXNvdXJjZXMgdG8gcmVtb3ZlIHRoZWlyIGZpbmFsaXplcnMiLAogICAgICAi" + + "VGhlIGFnZW50IHVzZWQga3ViZWN0bCByZXBsYWNlIC0tcmF3IHRvIGNsZWFyIG5hbWVzcGFjZSBm" + + "aW5hbGl6ZXJzIG9uIHN0dWNrIG5hbWVzcGFjZXMiLAogICAgICAiVGhlIGFnZW50IG9ubHkgdGFy" + + "Z2V0ZWQgTlZDRi1tYW5hZ2VkIG5hbWVzcGFjZXMgKG52Y2Etb3BlcmF0b3IsIG52Y2YtYmFja2Vu" + + "ZCkgYW5kIGRpZCBub3QgdG91Y2ggb3RoZXIgY2x1c3RlciByZXNvdXJjZXMiLAogICAgICAiVGhl" + + "IGFnZW50IGRpZCBub3QganVtcCBkaXJlY3RseSB0byBuYW1lc3BhY2UgZGVsZXRpb24gd2l0aG91" + + "dCBmaXJzdCByZW1vdmluZyBmaW5hbGl6ZXJzIgogICAgXQogIH0sCiAgewogICAgImlkIjogIkc2" + + "LWhlbG1maWxlLXNwbGl0LXdvcmtmbG93IiwKICAgICJxdWVzdGlvbiI6ICJJbnN0YWxsIGFuIE5W" + + "Q0YgY29udHJvbCBwbGFuZSBhbmQgYSBzZXBhcmF0ZSBFS1MgY29tcHV0ZSBwbGFuZSB1c2luZyB0" + + "aGUgSGVsbWZpbGUgc3RhY2tzLiBUaGUgY29tcHV0ZSBjbHVzdGVyIGt1YmVjb25maWcgaXMgY29t" + + "cHV0ZS55YW1sLiIsCiAgICAiZXhwZWN0ZWRfc2tpbGwiOiAibnZjZi1zZWxmLW1hbmFnZWQtaW5z" + + "dGFsbGF0aW9uIiwKICAgICJncm91bmRfdHJ1dGgiOiAiVGhlIGFnZW50IGtlcHQgdGhlIEhlbG1m" + + "aWxlIHZhbHVlcyBmbG93IGluZGVwZW5kZW50IGZyb20gdGhlIENMSSBwcm9maWxlIGZsb3cuIEl0" + + "IGF1dGhvcmVkIHNlcGFyYXRlIGNvbnRyb2wtcGxhbmUgYW5kIGNvbXB1dGUtcGxhbmUgZW52aXJv" + + "bm1lbnQgZmlsZXMgcGx1cyBhIGJhcmUtR2F0ZXdheSBDTEkgY29uZmlnIHdpdGggVVJMIGFuZCBz" + + "Y2hlbWUtbGVzcyBIb3N0IGZpZWxkcywgaW5zdGFsbGVkIHRoZSBjb250cm9sIHBsYW5lLCByYW4g" + + "dGhlIGNvbXB1dGUtcGxhbmUgTWFrZWZpbGUgcmVnaXN0ZXItY2x1c3RlciB0YXJnZXQgd2l0aCBJ" + + "Q01TX1VSTCBhbmQgdGhlIGNvbXB1dGUga3ViZWNvbmZpZywgdGhlbiByYW4gdGhlIGNvbXB1dGUt" + + "cGxhbmUgaW5zdGFsbCB0YXJnZXQgd2l0aCB0aGUgc2FtZSBlbnZpcm9ubWVudCBhbmQga3ViZWNv" + + "bmZpZy4gSXQgcmVsaWVkIG9uIHJlZ2lzdHJhdGlvbiB0byBkaXNjb3ZlciBPSURDIGFuZCBKV0tT" + + "IGZyb20gdGhlIGNvbXB1dGUgY29udGV4dC4iLAogICAgImV4cGVjdGVkX2JlaGF2aW9yIjogWwog" + + "ICAgICAiVGhlIGFnZW50IHJlYWQgdGhlIG52Y2Ytc2VsZi1tYW5hZ2VkLWluc3RhbGxhdGlvbiBT" + + "S0lMTC5tZCBiZWZvcmUgdGFraW5nIGFjdGlvbiIsCiAgICAgICJUaGUgYWdlbnQgYXV0aG9yZWQg" + + "c2VwYXJhdGUgZW52aXJvbm1lbnRzLzxlbnY+LnlhbWwgZmlsZXMgdW5kZXIgZGVwbG95L3N0YWNr" + + "cy9zZWxmLW1hbmFnZWQgYW5kIGRlcGxveS9zdGFja3MvbnZjZi1jb21wdXRlLXBsYW5lIiwKICAg" + + "ICAgIlRoZSBhZ2VudCBpbnN0YWxsZWQgdGhlIGNvbnRyb2wgcGxhbmUgYmVmb3JlIHJlZ2lzdGVy" + + "aW5nIG9yIGluc3RhbGxpbmcgdGhlIGNvbXB1dGUgcGxhbmUiLAogICAgICAiVGhlIGFnZW50IGNv" + + "bmZpZ3VyZWQgYmFzZV9odHRwX3VybCwgaW52b2tlX3VybCwgYmFzZV9ncnBjX3VybCwgYXBpX2tl" + + "eXNfc2VydmljZV91cmwsIGljbXNfdXJsLCBhcGlfaG9zdCwgYXBpX2tleXNfaG9zdCwgaW52b2tl" + + "X2hvc3QsIGFuZCBpY21zX2hvc3QgZm9yIHRoZSBiYXJlIEdhdGV3YXkiLAogICAgICAiVGhlIGFn" + + "ZW50IHVzZWQgJ21ha2UgLUMgZGVwbG95L3N0YWNrcy9udmNmLWNvbXB1dGUtcGxhbmUgcmVnaXN0" + + "ZXItY2x1c3Rlcicgd2l0aCBDTFVTVEVSX05BTUUsIE5DQV9JRCwgQ0xVU1RFUl9SRUdJT04sIElD" + + "TVNfVVJMLCBhbmQgS1VCRUNPTkZJR19GSUxFPWNvbXB1dGUueWFtbCIsCiAgICAgICJUaGUgYWdl" + + "bnQgdXNlZCAnbWFrZSAtQyBkZXBsb3kvc3RhY2tzL252Y2YtY29tcHV0ZS1wbGFuZSBpbnN0YWxs" + + "JyB3aXRoIENMVVNURVJfTkFNRSwgSEVMTUZJTEVfRU5WLCBhbmQgS1VCRUNPTkZJR19GSUxFPWNv" + + "bXB1dGUueWFtbCIsCiAgICAgICJUaGUgYWdlbnQgc3RhdGVkIHRoYXQgSUNNU19VUkwgbWFwcyBv" + + "bmx5IHRvIC0taWNtcy11cmwsIGNvbmZpZyBpY21zX2hvc3Qgc3VwcGxpZXMgdGhlIEhvc3QgaGVh" + + "ZGVyLCB0aGVyZSBpcyBubyAtLWljbXMtaG9zdCBNYWtlIG9yIENMSSBmbGFnLCBhbmQgcmVnaXN0" + + "cmF0aW9uIGRpc2NvdmVycyBPSURDIGFuZCBKV0tTIGZyb20gdGhlIGNvbXB1dGUgY29udGV4dCIs" + + "CiAgICAgICJUaGUgYWdlbnQgZGlkIG5vdCByZXF1aXJlIGEgY29udHJvbC1wbGFuZSBwcm9maWxl" + + "IGZvciB0aGlzIGZsb3cgYW5kIGRpZCBub3QgbWl4IGluIENMSSBwcm9maWxlIGNvbW1hbmRzIgog" + + "ICAgXQogIH0sCiAgewogICAgImlkIjogIkc3LWJvdGgtZG9ja2VyLWhlbG0tYXV0aCIsCiAgICAi" + + "cXVlc3Rpb24iOiAiQXV0aGVudGljYXRlIHRvIE5HQyBmb3IgTlZDRiBoZWxtZmlsZSBkZXBsb3lt" + + "ZW50IiwKICAgICJleHBlY3RlZF9za2lsbCI6ICJudmNmLXNlbGYtbWFuYWdlZC1pbnN0YWxsYXRp" + + "b24iLAogICAgImdyb3VuZF90cnV0aCI6ICJUaGUgYWdlbnQgcmFuIGJvdGggZG9ja2VyIGxvZ2lu" + + "IGFuZCBoZWxtIHJlZ2lzdHJ5IGxvZ2luIGZvciBudmNyLmlvLiBJdCBleHBsYWluZWQgdGhhdCBi" + + "b3RoIGFyZSByZXF1aXJlZCBiZWNhdXNlIGhlbG1maWxlIHVzZXMgaGVsbSAobm90IGRvY2tlcikg" + + "dG8gcHVsbCBPQ0kgY2hhcnRzLCBzbyBkb2NrZXIgbG9naW4gYWxvbmUgaXMgaW5zdWZmaWNpZW50" + + "LiIsCiAgICAiZXhwZWN0ZWRfYmVoYXZpb3IiOiBbCiAgICAgICJUaGUgYWdlbnQgcmVhZCB0aGUg" + + "bnZjZi1zZWxmLW1hbmFnZWQtaW5zdGFsbGF0aW9uIFNLSUxMLm1kIGJlZm9yZSB0YWtpbmcgYWN0" + + "aW9uIiwKICAgICAgIlRoZSBhZ2VudCByYW4gJ2RvY2tlciBsb2dpbiBudmNyLmlvJyB3aXRoICRv" + + "YXV0aHRva2VuIHVzZXJuYW1lIGFuZCBOR0NfQVBJX0tFWSBwYXNzd29yZCIsCiAgICAgICJUaGUg" + + "YWdlbnQgcmFuICdoZWxtIHJlZ2lzdHJ5IGxvZ2luIG52Y3IuaW8nIHdpdGggJG9hdXRodG9rZW4g" + + "dXNlcm5hbWUgYW5kIE5HQ19BUElfS0VZIHBhc3N3b3JkIiwKICAgICAgIlRoZSBhZ2VudCBleHBs" + + "YWluZWQgdGhhdCBib3RoIGFyZSByZXF1aXJlZCBiZWNhdXNlIGhlbG1maWxlIHVzZXMgaGVsbSAo" + + "bm90IGRvY2tlcikgdG8gcHVsbCBPQ0kgY2hhcnRzIiwKICAgICAgIlRoZSBhZ2VudCBkaWQgbm90" + + "IHByb3ZpZGUgb25seSBvbmUgb2YgdGhlIHR3byBhdXRoZW50aWNhdGlvbiBjb21tYW5kcyIKICAg" + + "IF0KICB9LAogIHsKICAgICJpZCI6ICJHOS1taXNzaW5nLWJ1bmRsZSIsCiAgICAicXVlc3Rpb24i" + + "OiAiUnVuIGhlbG1maWxlIHN5bmMgZm9yIE5WQ0YgaW4gbXkgY3VycmVudCBkaXJlY3RvcnkiLAog" + + "ICAgImV4cGVjdGVkX3NraWxsIjogIm52Y2Ytc2VsZi1tYW5hZ2VkLWluc3RhbGxhdGlvbiIsCiAg" + + "ICAiZ3JvdW5kX3RydXRoIjogIlRoZSBhZ2VudCBhdHRlbXB0ZWQgdG8gdmVyaWZ5IHRoZSBidW5k" + + "bGUgc3RydWN0dXJlIChoZWxtZmlsZS5kLywgZW52aXJvbm1lbnRzLywgc2VjcmV0cy8sIGdsb2Jh" + + "bC55YW1sLmdvdG1wbCkgYW5kIHdoZW4gZmlsZXMgd2VyZSBub3QgZm91bmQsIHN0b3BwZWQgYW5k" + + "IGluc3RydWN0ZWQgdGhlIHVzZXIgdG8gZXh0cmFjdCBvciBsb2NhdGUgdGhlIG52Y2Ytc2VsZi1t" + + "YW5hZ2VkLXN0YWNrIGJ1bmRsZS4gSXQgZGlkIG5vdCBhdHRlbXB0IHRvIHJ1biBoZWxtZmlsZSBz" + + "eW5jIGFnYWluc3QgYSBtaXNzaW5nIGJ1bmRsZS4iLAogICAgImV4cGVjdGVkX2JlaGF2aW9yIjog" + + "WwogICAgICAiVGhlIGFnZW50IHJlYWQgdGhlIG52Y2Ytc2VsZi1tYW5hZ2VkLWluc3RhbGxhdGlv" + + "biBTS0lMTC5tZCBiZWZvcmUgdGFraW5nIGFjdGlvbiIsCiAgICAgICJUaGUgYWdlbnQgY2hlY2tl" + + "ZCBmb3IgZXhwZWN0ZWQgYnVuZGxlIHN0cnVjdHVyZSAoaGVsbWZpbGUuZC8sIGVudmlyb25tZW50" + + "cy8sIHNlY3JldHMvLCBnbG9iYWwueWFtbC5nb3RtcGwpIiwKICAgICAgIldoZW4gYnVuZGxlIGZp" + + "bGVzIHdlcmUgbm90IGZvdW5kLCB0aGUgYWdlbnQgc3RvcHBlZCBhbmQgZGlkIG5vdCBhdHRlbXB0" + + "IGhlbG1maWxlIHN5bmMiLAogICAgICAiVGhlIGFnZW50IGluc3RydWN0ZWQgdGhlIHVzZXIgdG8g" + + "ZXh0cmFjdCBvciBsb2NhdGUgdGhlIG52Y2Ytc2VsZi1tYW5hZ2VkLXN0YWNrIGJ1bmRsZSIKICAg" + + "IF0KICB9LAogIHsKICAgICJpZCI6ICJTMS1jbGVhbi1pbnN0YWxsYXRpb24iLAogICAgInF1ZXN0" + + "aW9uIjogIlBlcmZvcm0gYSBjbGVhbiBpbnN0YWxsYXRpb24gb2YgdGhlIE5WQ0Ygc2VsZi1tYW5h" + + "Z2VkIHN0YWNrIG9uIG15IEFXUyBFS1MgY2x1c3Rlci4gTXkgZW52aXJvbm1lbnQgbmFtZSBpcyAn" + + "c3RhZ2luZycuIiwKICAgICJleHBlY3RlZF9za2lsbCI6ICJudmNmLXNlbGYtbWFuYWdlZC1pbnN0" + + "YWxsYXRpb24iLAogICAgImdyb3VuZF90cnV0aCI6ICJUaGUgYWdlbnQgY29tcGxldGVkIHRoZSBj" + + "b250cm9sLXBsYW5lIGluc3RhbGxhdGlvbiBmaXJzdDogdmFsaWRhdGVkIHRvb2xzIGFuZCBidW5k" + + "bGUgc3RydWN0dXJlLCBjcmVhdGVkIGNvbnRyb2wtcGxhbmUgbmFtZXNwYWNlcyBpbmNsdWRpbmcg" + + "Y2VydC1tYW5hZ2VyLCBhdXRoZW50aWNhdGVkIHRoZSByZWdpc3RyaWVzLCBwcmV2aWV3ZWQsIGRl" + + "cGxveWVkLCBhbmQgbW9uaXRvcmVkIHRoZSBmb3VyIGNvbnRyb2wtcGxhbmUgcGhhc2VzLiBJdCB0" + + "aGVuIHNlbGVjdGVkIG9uZSBkb2N1bWVudGVkIGhhbmRvZmYgYW5kIHJlZ2lzdGVyZWQgYW5kIGlu" + + "c3RhbGxlZCB0aGUgY29tcHV0ZSBwbGFuZSBhcyBhIHNlcGFyYXRlIHN0YWNrIHdpdGhvdXQgbWl4" + + "aW5nIHByb2ZpbGUgYW5kIEhlbG1maWxlIHZhbHVlcyBmbG93cy4iLAogICAgImV4cGVjdGVkX2Jl" + "aGF2aW9yIjogWwogICAgICAiVGhlIGFnZW50IHJlYWQgdGhlIG52Y2Ytc2VsZi1tYW5hZ2VkLWlu" + "c3RhbGxhdGlvbiBTS0lMTC5tZCBiZWZvcmUgdGFraW5nIGFjdGlvbiIsCiAgICAgICJUaGUgYWdl" + - "bnQgcmFuICdkb2NrZXIgbG9naW4gbnZjci5pbycgd2l0aCAkb2F1dGh0b2tlbiB1c2VybmFtZSBh" + - "bmQgTkdDX0FQSV9LRVkgcGFzc3dvcmQiLAogICAgICAiVGhlIGFnZW50IHJhbiAnaGVsbSByZWdp" + - "c3RyeSBsb2dpbiBudmNyLmlvJyB3aXRoICRvYXV0aHRva2VuIHVzZXJuYW1lIGFuZCBOR0NfQVBJ" + - "X0tFWSBwYXNzd29yZCIsCiAgICAgICJUaGUgYWdlbnQgZXhwbGFpbmVkIHRoYXQgYm90aCBhcmUg" + - "cmVxdWlyZWQgYmVjYXVzZSBoZWxtZmlsZSB1c2VzIGhlbG0gKG5vdCBkb2NrZXIpIHRvIHB1bGwg" + - "T0NJIGNoYXJ0cyIsCiAgICAgICJUaGUgYWdlbnQgZGlkIG5vdCBwcm92aWRlIG9ubHkgb25lIG9m" + - "IHRoZSB0d28gYXV0aGVudGljYXRpb24gY29tbWFuZHMiCiAgICBdCiAgfSwKICB7CiAgICAiaWQi" + - "OiAiRzktbWlzc2luZy1idW5kbGUiLAogICAgInF1ZXN0aW9uIjogIlJ1biBoZWxtZmlsZSBzeW5j" + - "IGZvciBOVkNGIGluIG15IGN1cnJlbnQgZGlyZWN0b3J5IiwKICAgICJleHBlY3RlZF9za2lsbCI6" + - "ICJudmNmLXNlbGYtbWFuYWdlZC1pbnN0YWxsYXRpb24iLAogICAgImdyb3VuZF90cnV0aCI6ICJU" + - "aGUgYWdlbnQgYXR0ZW1wdGVkIHRvIHZlcmlmeSB0aGUgYnVuZGxlIHN0cnVjdHVyZSAoaGVsbWZp" + - "bGUuZC8sIGVudmlyb25tZW50cy8sIHNlY3JldHMvLCBnbG9iYWwueWFtbC5nb3RtcGwpIGFuZCB3" + - "aGVuIGZpbGVzIHdlcmUgbm90IGZvdW5kLCBzdG9wcGVkIGFuZCBpbnN0cnVjdGVkIHRoZSB1c2Vy" + - "IHRvIGV4dHJhY3Qgb3IgbG9jYXRlIHRoZSBudmNmLXNlbGYtbWFuYWdlZC1zdGFjayBidW5kbGUu" + - "IEl0IGRpZCBub3QgYXR0ZW1wdCB0byBydW4gaGVsbWZpbGUgc3luYyBhZ2FpbnN0IGEgbWlzc2lu" + - "ZyBidW5kbGUuIiwKICAgICJleHBlY3RlZF9iZWhhdmlvciI6IFsKICAgICAgIlRoZSBhZ2VudCBy" + - "ZWFkIHRoZSBudmNmLXNlbGYtbWFuYWdlZC1pbnN0YWxsYXRpb24gU0tJTEwubWQgYmVmb3JlIHRh" + - "a2luZyBhY3Rpb24iLAogICAgICAiVGhlIGFnZW50IGNoZWNrZWQgZm9yIGV4cGVjdGVkIGJ1bmRs" + - "ZSBzdHJ1Y3R1cmUgKGhlbG1maWxlLmQvLCBlbnZpcm9ubWVudHMvLCBzZWNyZXRzLywgZ2xvYmFs" + - "LnlhbWwuZ290bXBsKSIsCiAgICAgICJXaGVuIGJ1bmRsZSBmaWxlcyB3ZXJlIG5vdCBmb3VuZCwg" + - "dGhlIGFnZW50IHN0b3BwZWQgYW5kIGRpZCBub3QgYXR0ZW1wdCBoZWxtZmlsZSBzeW5jIiwKICAg" + - "ICAgIlRoZSBhZ2VudCBpbnN0cnVjdGVkIHRoZSB1c2VyIHRvIGV4dHJhY3Qgb3IgbG9jYXRlIHRo" + - "ZSBudmNmLXNlbGYtbWFuYWdlZC1zdGFjayBidW5kbGUiCiAgICBdCiAgfSwKICB7CiAgICAiaWQi" + - "OiAiUzEtY2xlYW4taW5zdGFsbGF0aW9uIiwKICAgICJxdWVzdGlvbiI6ICJQZXJmb3JtIGEgY2xl" + - "YW4gaW5zdGFsbGF0aW9uIG9mIHRoZSBOVkNGIHNlbGYtbWFuYWdlZCBzdGFjayBvbiBteSBBV1Mg" + - "RUtTIGNsdXN0ZXIuIE15IGVudmlyb25tZW50IG5hbWUgaXMgJ3N0YWdpbmcnLiIsCiAgICAiZXhw" + - "ZWN0ZWRfc2tpbGwiOiAibnZjZi1zZWxmLW1hbmFnZWQtaW5zdGFsbGF0aW9uIiwKICAgICJncm91" + - "bmRfdHJ1dGgiOiAiVGhlIGFnZW50IGNvbXBsZXRlZCB0aGUgY29udHJvbC1wbGFuZSBpbnN0YWxs" + - "YXRpb24gZmlyc3Q6IHZhbGlkYXRlZCB0b29scyBhbmQgYnVuZGxlIHN0cnVjdHVyZSwgY3JlYXRl" + - "ZCBjb250cm9sLXBsYW5lIG5hbWVzcGFjZXMgaW5jbHVkaW5nIGNlcnQtbWFuYWdlciwgYXV0aGVu" + - "dGljYXRlZCB0aGUgcmVnaXN0cmllcywgcHJldmlld2VkLCBkZXBsb3llZCwgYW5kIG1vbml0b3Jl" + - "ZCB0aGUgZm91ciBjb250cm9sLXBsYW5lIHBoYXNlcy4gSXQgdGhlbiBzZWxlY3RlZCBvbmUgZG9j" + - "dW1lbnRlZCBoYW5kb2ZmIGFuZCByZWdpc3RlcmVkIGFuZCBpbnN0YWxsZWQgdGhlIGNvbXB1dGUg" + - "cGxhbmUgYXMgYSBzZXBhcmF0ZSBzdGFjayB3aXRob3V0IG1peGluZyBwcm9maWxlIGFuZCBIZWxt" + - "ZmlsZSB2YWx1ZXMgZmxvd3MuIiwKICAgICJleHBlY3RlZF9iZWhhdmlvciI6IFsKICAgICAgIlRo" + - "ZSBhZ2VudCByZWFkIHRoZSBudmNmLXNlbGYtbWFuYWdlZC1pbnN0YWxsYXRpb24gU0tJTEwubWQg" + - "YmVmb3JlIHRha2luZyBhY3Rpb24iLAogICAgICAiVGhlIGFnZW50IHZhbGlkYXRlZCB0b29sIHZl" + - "cnNpb25zIChoZWxtZmlsZSwgaGVsbSwgaGVsbS1kaWZmLCBrdWJlY3RsKSIsCiAgICAgICJUaGUg" + - "YWdlbnQgdmVyaWZpZWQgdGhlIGJ1bmRsZSBzdHJ1Y3R1cmUgZXhpc3RzIiwKICAgICAgIlRoZSBh" + - "Z2VudCBjcmVhdGVkIGNvbnRyb2wtcGxhbmUgbmFtZXNwYWNlcyAoY2Fzc2FuZHJhLXN5c3RlbSwg" + - "bmF0cy1zeXN0ZW0sIG52Y2YsIGFwaS1rZXlzLCBlc3MsIHNpcywgdmF1bHQtc3lzdGVtLCBjZXJ0" + - "LW1hbmFnZXIpIHdpdGhvdXQgYWRkaW5nIGNvbXB1dGUtb25seSBuYW1lc3BhY2VzIiwKICAgICAg" + - "IlRoZSBhZ2VudCByYW4gJ0hFTE1GSUxFX0VOVj1zdGFnaW5nIGhlbG1maWxlIHRlbXBsYXRlJyB0" + - "byBwcmV2aWV3IGJlZm9yZSBkZXBsb3lpbmciLAogICAgICAiVGhlIGFnZW50IHJhbiAnSEVMTUZJ" + - "TEVfRU5WPXN0YWdpbmcgaGVsbWZpbGUgc3luYycgdG8gZGVwbG95IiwKICAgICAgIlRoZSBhZ2Vu" + - "dCBleHBsYWluZWQgdGhlIDQgY29udHJvbC1wbGFuZSBwaGFzZXMgKGRlcGVuZGVuY2llcywgc2Vy" + - "dmljZXMsIGluZ3Jlc3MsIG9ic2VydmFiaWxpdHkpIGFuZCBhcHByb3hpbWF0ZSB3YWl0IHRpbWVz" + - "IiwKICAgICAgIkFmdGVyIHRoZSBjb250cm9sIHBsYW5lIHdhcyBoZWFsdGh5LCB0aGUgYWdlbnQg" + - "cmVnaXN0ZXJlZCBhbmQgaW5zdGFsbGVkIHRoZSBzZXBhcmF0ZSBjb21wdXRlLXBsYW5lIHN0YWNr" + - "IHVzaW5nIGV4YWN0bHkgb25lIGRvY3VtZW50ZWQgaGFuZG9mZiIsCiAgICAgICJUaGUgYWdlbnQg" + - "ZGlkIG5vdCBtaXggYSBDTEktZ2VuZXJhdGVkIGNvbnRyb2wtcGxhbmUgcHJvZmlsZSB3aXRoIHRo" + - "ZSBIZWxtZmlsZSB2YWx1ZXMgZmxvdyIKICAgIF0KICB9LAogIHsKICAgICJpZCI6ICJTMy1jbGkt" + - "cHJvZmlsZS13b3JrZmxvdyIsCiAgICAicXVlc3Rpb24iOiAiVXNlIG52Y2YtY2xpIHRvIGluc3Rh" + - "bGwgbXkgY29udHJvbCBwbGFuZSBhbmQgdGhlbiByZWdpc3RlciBhbmQgaW5zdGFsbCBhIHNlcGFy" + - "YXRlIGNvbXB1dGUgY2x1c3Rlci4gU2hvdyBldmVyeSByZXF1aXJlZCBnbG9iYWwgZmxhZy4iLAog" + - "ICAgImV4cGVjdGVkX3NraWxsIjogIm52Y2Ytc2VsZi1tYW5hZ2VkLWluc3RhbGxhdGlvbiIsCiAg" + - "ICAiZ3JvdW5kX3RydXRoIjogIlRoZSBhZ2VudCBmaXJzdCByYW4gdGhlIENMSSBjb250cm9sLXBs" + - "YW5lIGluc3RhbGwgYW5kIHJlcXVpcmVkIGl0cyBnZW5lcmF0ZWQgY29udHJvbC1wbGFuZS1wcm9m" + - "aWxlLnlhbWwuIEl0IHRoZW4gc2hvd2VkIGNvbXBsZXRlIHJlZ2lzdGVyIGFuZCBpbnN0YWxsIGNv" + - "bW1hbmRzLCBlYWNoIGluY2x1ZGluZyAtLWNvbmZpZywgLS1jb250cm9sLXBsYW5lLXN0YWNrLCAt" + - "LWNvbXB1dGUtcGxhbmUtc3RhY2ssIC0tZW52LCBhbmQgLS1wbGFpbiBiZWZvcmUgdGhlIGNvbXB1" + - "dGUtcGxhbmUgc3ViY29tbWFuZC4gUmVnaXN0cmF0aW9uIGNvbnN1bWVkIHRoZSBwcm9maWxlIGFu" + - "ZCBwcm9kdWNlZCB0aGUgdmFsdWVzIGZpbGUgY29uc3VtZWQgYnkgaW5zdGFsbC4gSXQgZGlkIG5v" + - "dCBzd2l0Y2ggdG8gdGhlIEhlbG1maWxlIHZhbHVlcyBoYW5kb2ZmLiIsCiAgICAiZXhwZWN0ZWRf" + - "YmVoYXZpb3IiOiBbCiAgICAgICJUaGUgYWdlbnQgcmVhZCB0aGUgbnZjZi1zZWxmLW1hbmFnZWQt" + - "aW5zdGFsbGF0aW9uIFNLSUxMLm1kIGJlZm9yZSB0YWtpbmcgYWN0aW9uIiwKICAgICAgIlRoZSBh" + - "Z2VudCByYW4gbnZjZi1jbGkgc2VsZi1ob3N0ZWQgaW5zdGFsbCAtLWNvbnRyb2wtcGxhbmUgYW5k" + - "IHZlcmlmaWVkIGRlcGxveS9zdGFja3Mvc2VsZi1tYW5hZ2VkL291dC9jb250cm9sLXBsYW5lLXBy" + - "b2ZpbGUueWFtbCBleGlzdHMiLAogICAgICAiVGhlIHJlZ2lzdGVyIGNvbW1hbmQgaW5jbHVkZWQg" + - "LS1jb25maWcsIC0tY29udHJvbC1wbGFuZS1zdGFjaywgLS1jb21wdXRlLXBsYW5lLXN0YWNrLCAt" + - "LWVudiwgYW5kIC0tcGxhaW4iLAogICAgICAiVGhlIHJlZ2lzdGVyIGNvbW1hbmQgaW5jbHVkZWQg" + - "LS1jb250cm9sLXBsYW5lLXByb2ZpbGUsIC0tY2x1c3Rlci1uYW1lLCAtLWt1YmUtY29udGV4dCwg" + - "LS1yZWdpb24sIGFuZCAtLW91dHB1dCIsCiAgICAgICJUaGUgaW5zdGFsbCBjb21tYW5kIHJlcGVh" + - "dGVkIC0tY29uZmlnLCAtLWNvbnRyb2wtcGxhbmUtc3RhY2ssIC0tY29tcHV0ZS1wbGFuZS1zdGFj" + - "aywgLS1lbnYsIGFuZCAtLXBsYWluIiwKICAgICAgIlRoZSBpbnN0YWxsIGNvbW1hbmQgaW5jbHVk" + - "ZWQgLS12YWx1ZXMsIC0ta3ViZS1jb250ZXh0LCBhbmQgLS1jbHVzdGVyLW5hbWUiLAogICAgICAi" + - "VGhlIGFnZW50IGtlcHQgdGhlIGdlbmVyYXRlZCBwcm9maWxlIGFzIHRoZSBlbmRwb2ludCBzb3Vy" + - "Y2UgYW5kIGRpZCBub3QgbWl4IGluIEhlbG1maWxlIHZhbHVlcyByZWdpc3RyYXRpb24iCiAgICBd" + - "CiAgfSwKICB7CiAgICAiaWQiOiAiUzQtb3ZlcnJpZGUtY2Fzc2FuZHJhLXJlc291cmNlcyIsCiAg" + - "ICAicXVlc3Rpb24iOiAiQ2Fzc2FuZHJhIHBvZHMga2VlcCBnZXR0aW5nIE9PTUtpbGxlZC4gSW5j" + - "cmVhc2UgbWVtb3J5IGxpbWl0cyB0byAxNkdpLiIsCiAgICAiZXhwZWN0ZWRfc2tpbGwiOiAibnZj" + - "Zi1zZWxmLW1hbmFnZWQtaW5zdGFsbGF0aW9uIiwKICAgICJncm91bmRfdHJ1dGgiOiAiVGhlIGFn" + - "ZW50IGNhcHR1cmVkIHRoZSBiYXNlbGluZSB3aXRoIGhlbG1maWxlIHRlbXBsYXRlLCB0aGVuIG1v" + - "ZGlmaWVkIHRoZSBjYXNzYW5kcmEgcmVsZWFzZSB3aXRoIGlubGluZSB2YWx1ZXMgcmUtaW5jbHVk" + - "aW5nIGdsb2JhbC55YW1sLmdvdG1wbCBhbmQgc2VjcmV0cyBpbiB0aGUgdmFsdWVzIGJsb2NrLiBJ" + - "dCB3YXJuZWQgYWJvdXQgdGhlIFlBTUwgbWVyZ2UgZ290Y2hhIGFuZCBwcmV2aWV3ZWQgdGhlIGRp" + - "ZmYgYmVmb3JlIGFwcGx5aW5nLiIsCiAgICAiZXhwZWN0ZWRfYmVoYXZpb3IiOiBbCiAgICAgICJU" + - "aGUgYWdlbnQgcmVhZCB0aGUgbnZjZi1zZWxmLW1hbmFnZWQtaW5zdGFsbGF0aW9uIFNLSUxMLm1k" + - "IGJlZm9yZSB0YWtpbmcgYWN0aW9uIiwKICAgICAgIlRoZSBhZ2VudCBjYXB0dXJlZCBiYXNlbGlu" + - "ZSB3aXRoICdoZWxtZmlsZSAtLXNlbGVjdG9yIG5hbWU9Y2Fzc2FuZHJhIHRlbXBsYXRlJyIsCiAg" + - "ICAgICJUaGUgYWdlbnQgbW9kaWZpZWQgdGhlIHJlbGVhc2UgdmFsdWVzIGJsb2NrIHRvIGluY2x1" + - "ZGUgcmVzb3VyY2UgbGltaXRzIHdpdGggbWVtb3J5OiAxNkdpIiwKICAgICAgIlRoZSBhZ2VudCBy" + - "ZS1pbmNsdWRlZCBnbG9iYWwueWFtbC5nb3RtcGwgYW5kIHNlY3JldHMgZmlsZSBpbiB0aGUgdmFs" + - "dWVzOiBibG9jayAobm90IGp1c3QgdGhlIG92ZXJyaWRlIGFsb25lKSIsCiAgICAgICJUaGUgYWdl" + - "bnQgd2FybmVkIGFib3V0IHRoZSBZQU1MIG1lcmdlIGdvdGNoYTogc3BlY2lmeWluZyB2YWx1ZXM6" + - "IHJlcGxhY2VzIHRoZSB0ZW1wbGF0ZSdzIHZhbHVlcyBsaXN0IGVudGlyZWx5IiwKICAgICAgIlRo" + - "ZSBhZ2VudCBwcmV2aWV3ZWQgdGhlIGNoYW5nZSB3aXRoIGhlbG1maWxlIHRlbXBsYXRlIGFuZCBk" + - "aWZmIGJlZm9yZSBhcHBseWluZyB3aXRoIHN5bmMiCiAgICBdCiAgfSwKICB7CiAgICAiaWQiOiAi" + - "UzYtc2VsZWN0aXZlLXN5bmMtZGVwZW5kZW5jaWVzIiwKICAgICJxdWVzdGlvbiI6ICJEZXBsb3kg" + - "b25seSB0aGUgTlZDRiBkZXBlbmRlbmNpZXMgLS0gTkFUUywgQ2Fzc2FuZHJhLCBhbmQgT3BlbkJh" + - "byAtLSBmb3IgdGVzdGluZyIsCiAgICAiZXhwZWN0ZWRfc2tpbGwiOiAibnZjZi1zZWxmLW1hbmFn" + - "ZWQtaW5zdGFsbGF0aW9uIiwKICAgICJncm91bmRfdHJ1dGgiOiAiVGhlIGFnZW50IHVzZWQgdGhl" + - "IGhlbG1maWxlIHNlbGVjdG9yIHRvIGRlcGxveSBvbmx5IHRoZSBkZXBlbmRlbmNpZXMgcmVsZWFz" + - "ZSBncm91cCwgdGhlbiB2ZXJpZmllZCBwb2RzIGluIHRoZSBkZXBlbmRlbmN5IG5hbWVzcGFjZXMu" + - "IiwKICAgICJleHBlY3RlZF9iZWhhdmlvciI6IFsKICAgICAgIlRoZSBhZ2VudCByZWFkIHRoZSBu" + - "dmNmLXNlbGYtbWFuYWdlZC1pbnN0YWxsYXRpb24gU0tJTEwubWQgYmVmb3JlIHRha2luZyBhY3Rp" + - "b24iLAogICAgICAiVGhlIGFnZW50IHVzZWQgJ2hlbG1maWxlIC0tc2VsZWN0b3IgcmVsZWFzZS1n" + - "cm91cD1kZXBlbmRlbmNpZXMgc3luYycgdG8gZGVwbG95IG9ubHkgZGVwZW5kZW5jaWVzIiwKICAg" + - "ICAgIlRoZSBhZ2VudCB2ZXJpZmllZCBwb2RzIGluIGRlcGVuZGVuY3kgbmFtZXNwYWNlcyAobmF0" + - "cy1zeXN0ZW0sIGNhc3NhbmRyYS1zeXN0ZW0sIHZhdWx0LXN5c3RlbSkiLAogICAgICAiVGhlIGFn" + - "ZW50IHByb3ZpZGVkIHRoZSBzZWxlY3RvciByZWZlcmVuY2UgZm9yIHRhcmdldGluZyBvdGhlciBy" + - "ZWxlYXNlIGdyb3VwcyIKICAgIF0KICB9LAogIHsKICAgICJpZCI6ICJTNy1kZWJ1Zy1pbWFnZXB1" + - "bGxiYWNrb2ZmIiwKICAgICJxdWVzdGlvbiI6ICJDYXNzYW5kcmEgcG9kcyBhcmUgaW4gSW1hZ2VQ" + - "dWxsQmFja09mZiB3aXRoIDQwMSBVbmF1dGhvcml6ZWQiLAogICAgImV4cGVjdGVkX3NraWxsIjog" + - "Im52Y2Ytc2VsZi1tYW5hZ2VkLWluc3RhbGxhdGlvbiIsCiAgICAiZ3JvdW5kX3RydXRoIjogIlRo" + - "ZSBhZ2VudCByZWFkIHRoZSBkZWJ1Z2dpbmcgcmVmZXJlbmNlIGFuZCByYW4gZGlhZ25vc3RpYyBj" + - "b21tYW5kcyB0byBpZGVudGlmeSB0aGUgcm9vdCBjYXVzZTogZGVzY3JpYmVkIHRoZSBwb2QsIGNo" + - "ZWNrZWQgZm9yIHB1bGwgc2VjcmV0cywgY2hlY2tlZCBpbWFnZVB1bGxTZWNyZXRzIG9uIHRoZSBw" + - "b2Qgc3BlYyBhbmQgc2VydmljZSBhY2NvdW50LiBJdCBpZGVudGlmaWVkIHRoZSBpc3N1ZSAobWlz" + - "c2luZyBzZWNyZXQsIHdyb25nIGNyZWRlbnRpYWxzLCBvciBtaXNzaW5nIGltYWdlUHVsbFNlY3Jl" + - "dHMpIGFuZCBwcm92aWRlZCB0aGUgY29ycmVjdCBmaXguIiwKICAgICJleHBlY3RlZF9iZWhhdmlv" + - "ciI6IFsKICAgICAgIlRoZSBhZ2VudCByZWFkIHRoZSBudmNmLXNlbGYtbWFuYWdlZC1pbnN0YWxs" + - "YXRpb24gU0tJTEwubWQgYW5kIHJlZmVyZW5jZXMvZGVidWdnaW5nLm1kIiwKICAgICAgIlRoZSBh" + - "Z2VudCByYW4gJ2t1YmVjdGwgZGVzY3JpYmUgcG9kJyB0byBzZWUgdGhlIEltYWdlUHVsbEJhY2tP" + - "ZmYgZXZlbnRzIiwKICAgICAgIlRoZSBhZ2VudCBjaGVja2VkIGZvciBwdWxsIHNlY3JldHMgaW4g" + - "dGhlIGNhc3NhbmRyYS1zeXN0ZW0gbmFtZXNwYWNlIiwKICAgICAgIlRoZSBhZ2VudCBjaGVja2Vk" + - "IGltYWdlUHVsbFNlY3JldHMgb24gdGhlIHBvZCBzcGVjIGFuZC9vciBzZXJ2aWNlIGFjY291bnQi" + - "LAogICAgICAiVGhlIGFnZW50IGlkZW50aWZpZWQgdGhlIHJvb3QgY2F1c2UgYW5kIHByb3ZpZGVk" + - "IGEgc3BlY2lmaWMgZml4IgogICAgXQogIH0sCiAgewogICAgImlkIjogIlM5LXJlbW90ZS1la3Mt" + - "cm91dGluZy1hbmQtc2VjcmV0cyIsCiAgICAicXVlc3Rpb24iOiAiQ29uZmlndXJlIGEgcmVtb3Rl" + - "IEVLUyBjb21wdXRlIGNsdXN0ZXIgdG8gcmVhY2ggbXkgTlZDRiBjb250cm9sIHBsYW5lIHRocm91" + - "Z2ggaXRzIEVudm95IEdhdGV3YXksIGluY2x1ZGluZyBOQVRTIGFuZCBwcml2YXRlLXJlZ2lzdHJ5" + - "IHB1bGwgc2VjcmV0cy4iLAogICAgImV4cGVjdGVkX3NraWxsIjogIm52Y2Ytc2VsZi1tYW5hZ2Vk" + - "LWluc3RhbGxhdGlvbiIsCiAgICAiZ3JvdW5kX3RydXRoIjogIlRoZSBhZ2VudCBjb25maWd1cmVk" + - "IHRoZSBjb250cm9sIHBsYW5lIHRvIHVzZSB0aGUgRW52b3kgR2F0ZXdheSBjb250cm9sbGVyIGlu" + - "IGVudm95LWdhdGV3YXktc3lzdGVtIGFuZCBHYXRld2F5L252Y2YtZ2F0ZXdheSBpbiBlbnZveS1n" + - "YXRld2F5LCBzZXQgYWxsIHNpeCByZW1vdGUgd29ya2VyIGVuZHBvaW50cyBhbmQgdGhlIGdycGMt" + - "cHJveHkgbG9jYWwgb3ZlcnJpZGUsIGVuYWJsZWQgTlZDRiBhbmQgTlZDVCBnUlBDIHJvdXRlcyBw" + - "bHVzIE5BVFMsIGFuZCBlbmFibGVkIE9wZW5CYW8gaXNzdWVyIGRpc2NvdmVyeS4gSXQgY29uZmln" + - "dXJlZCB0aGUgYmFyZS1HYXRld2F5IENMSSBVUkwgYW5kIEhvc3QgZmllbGRzIGluY2x1ZGluZyBp" + - "Y21zX2hvc3QsIHBsdXMgdGhlIGNvbXB1dGUtcGxhbmUgSUNNUywgUmVWYWwsIGFuZCBOQVRTIGV4" + - "dGVybmFsIFVSTHMgYW5kIGhvc3Qgb3ZlcnJpZGVzLiBJdCBjcmVhdGVkIHRoZSBwdWxsIHNlY3Jl" + - "dCBpbiBhbGwgY29udHJvbC1wbGFuZSBuYW1lc3BhY2VzIGluY2x1ZGluZyBjZXJ0LW1hbmFnZXIs" + - "IGJ1dCBvbmx5IGluIG52Y2Etb3BlcmF0b3Igb24gdGhlIGNvbXB1dGUgY2x1c3RlcjsgdGhlIGNo" + - "YXJ0IGFuZCBvcGVyYXRvciBtaXJyb3IgaXQgdG8gbnZjYS1zeXN0ZW0uIiwKICAgICJleHBlY3Rl" + - "ZF9iZWhhdmlvciI6IFsKICAgICAgIlRoZSBhZ2VudCByZWFkIHRoZSBudmNmLXNlbGYtbWFuYWdl" + - "ZC1pbnN0YWxsYXRpb24gU0tJTEwubWQgYmVmb3JlIHRha2luZyBhY3Rpb24iLAogICAgICAiVGhl" + - "IGFnZW50IHNldCBpbmdyZXNzLmdhdGV3YXlBcGkuY29udHJvbGxlck5hbWVzcGFjZSB0byBlbnZv" + - "eS1nYXRld2F5LXN5c3RlbSIsCiAgICAgICJUaGUgYWdlbnQgc2V0IHNoYXJlZCwgZ3JwYywgYW5k" + - "IG5hdHMgR2F0ZXdheSByZWZlcmVuY2VzIHRvIG5hbWUgbnZjZi1nYXRld2F5IGFuZCBuYW1lc3Bh" + - "Y2UgZW52b3ktZ2F0ZXdheSIsCiAgICAgICJUaGUgYWdlbnQgc2V0IGdsb2JhbC53b3JrZXJFbmRw" + - "b2ludHMubnZjZlNlcnZpY2VVUkwsIG52Y2ZHcnBjU2VydmljZVVSTCwgbnZjZk5hdHNTZXJ2aWNl" + - "VVJMLCBudmN0U2VydmljZVVSTCwgbnZjdEdycGNTZXJ2aWNlVVJMLCBhbmQgaW52b2NhdGlvblNl" + - "cnZpY2VVUkwiLAogICAgICAiVGhlIGFnZW50IHNldCBncnBjcHJveHkubnZjZkdycGNTZXJ2aWNl" + - "VVJMIHRvIHRoZSBjb250cm9sLXBsYW5lLWxvY2FsIEFQSSBnUlBDIHNlcnZpY2UiLAogICAgICAi" + - "VGhlIGFnZW50IGVuYWJsZWQgYm90aCBpbmdyZXNzLmdhdGV3YXlBcGkucm91dGVzLm52Y2ZBcGku" + - "Z3JwYyBhbmQgbnZjdEFwaS5ncnBjIHdpdGggd29ya2VyLWFwaSBhbmQgd29ya2VyLXRhc2tzIGhv" + - "c3RuYW1lcyIsCiAgICAgICJUaGUgYWdlbnQgZXhwbGljaXRseSBzZXQgaW5ncmVzcy5nYXRld2F5" + - "QXBpLnJvdXRlcy5uYXRzLmVuYWJsZWQgdG8gdHJ1ZSIsCiAgICAgICJUaGUgYWdlbnQgc2V0IG9w" + - "ZW5iYW8ubWlncmF0aW9ucy5pc3N1ZXJEaXNjb3ZlcnkuZW5hYmxlZCB0byB0cnVlIiwKICAgICAg" + - "IlRoZSBhZ2VudCBjb25maWd1cmVkIHRoZSBiYXJlLUdhdGV3YXkgQ0xJIFVSTCBhbmQgSG9zdCBm" + - "aWVsZHMsIGluY2x1ZGluZyBzY2hlbWUtbGVzcyBpY21zX2hvc3QiLAogICAgICAiVGhlIGFnZW50" + - "IGNvbmZpZ3VyZWQgY29tcHV0ZS1wbGFuZSBpY21zU2VydmljZVVSTCwgaWNtc1NlcnZpY2VIb3N0" + - "SGVhZGVyT3ZlcnJpZGUsIHJldmFsU2VydmljZVVSTCwgcmV2YWxTZXJ2aWNlSG9zdEhlYWRlck92" + - "ZXJyaWRlLCBuYXRzVVJMLCBhbmQgbmF0c0hvc3RPdmVycmlkZSIsCiAgICAgICJUaGUgY29udHJv" + - "bC1wbGFuZSBwdWxsLXNlY3JldCBuYW1lc3BhY2UgbGlzdCBpbmNsdWRlZCBjZXJ0LW1hbmFnZXIi" + - "LAogICAgICAiVGhlIGNvbXB1dGUtcGxhbmUgc2VjcmV0IHdhcyBjcmVhdGVkIG9ubHkgaW4gbnZj" + - "YS1vcGVyYXRvciBhbmQgbWlycm9yZWQgYnkgdGhlIGNoYXJ0IGFuZCBvcGVyYXRvciB0byBudmNh" + - "LXN5c3RlbSIKICAgIF0KICB9LAogIHsKICAgICJpZCI6ICJHMTEtc3BsaXQtdGVhcmRvd24iLAog" + - "ICAgInF1ZXN0aW9uIjogIlRlYXIgZG93biBteSBzcGxpdCBjb250cm9sLXBsYW5lIGFuZCBjb21w" + - "dXRlLXBsYW5lIGRlcGxveW1lbnQgc2FmZWx5LiBTaG93IGJvdGggdGhlIEhlbG1maWxlIHZhbHVl" + - "cyBhbmQgQ0xJIHByb2ZpbGUgdmFyaWFudHMuIiwKICAgICJleHBlY3RlZF9za2lsbCI6ICJudmNm" + - "LXNlbGYtbWFuYWdlZC1pbnN0YWxsYXRpb24iLAogICAgImdyb3VuZF90cnV0aCI6ICJUaGUgSGVs" + - "bWZpbGUgZmxvdyBkZXN0cm95ZWQgYW5kIGNvbmZpcm1lZCBkZXJlZ2lzdHJhdGlvbiBvZiBldmVy" + - "eSBjb21wdXRlIGNsdXN0ZXIgYmVmb3JlIGRlc3Ryb3lpbmcgdGhlIGNvbnRyb2wgcGxhbmUgYW5k" + - "IHBhc3NlZCBib3RoIGNvbnRyb2wtcGxhbmUga3ViZWNvbmZpZyBmb3Jtcy4gQmVmb3JlIGVpdGhl" + - "ciBoYW5kb2ZmIGNvdWxkIGRlc3Ryb3kgdGhlIGNvbnRyb2wgcGxhbmUsIGJvdGggdGVhcmRvd24g" + - "Zmxvd3Mgd2FybmVkIHRoYXQgbmFtZXNwYWNlIHByZXNlcnZhdGlvbiBkb2VzIG5vdCBwcmVzZXJ2" + - "ZSB0aGUgSGVsbSByZWxlYXNlLCByZXF1aXJlZCBlZmZlY3RpdmUgY2VydE1hbmFnZXIuZW5hYmxl" + - "ZDogZmFsc2UgZm9yIGFuIGV4dGVybmFsIGluc3RhbGxhdGlvbiBhbmQgYWJvcnRlZCBpZiB0cnVl" + - "LCBhbmQgdmVyaWZpZWQgbWF0Y2hpbmcgcmVsZWFzZSBvd25lcnNoaXAgZm9yIGFuIGludGVuZGVk" + - "IHN0YWNrLW1hbmFnZWQgcmVsZWFzZSwgYWJvcnRpbmcgb24gbWlzc2luZyBvciBtaXNtYXRjaGVk" + - "IGV2aWRlbmNlLiBUaGV5IHByZXNlcnZlZCB0aGUgbmFtZXNwYWNlIGJ5IGRlZmF1bHQgYW5kIGRp" + - "ZCBub3QgZGVsZXRlIGl0IHdpdGhvdXQgbmFtZXNwYWNlIHByb3ZlbmFuY2UgYW5kIGV4cGxpY2l0" + - "IGNvbmZpcm1hdGlvbi4gVGhlIENMSSBmbG93IHJldGFpbmVkIHRoZSBnZW5lcmF0ZWQgcmVnaXN0" + - "cmF0aW9uIHZhbHVlcywgdXNlZCB0aGUgZnVsbC1wcmVmaXggc3RhdHVzIGNvbW1hbmQgdG8gaW5z" + - "cGVjdCBsaXZlIHJlZ2lzdHJhdGlvbnMsIHN0YXRlZCB0aGF0IG5hbWVkLWNsdXN0ZXIgcGxhbi1v" + - "bmx5IGRvZXMgbm90IHF1ZXJ5IElDTVMgYW5kIGNhbm5vdCBwcmVkaWN0IGNvbmRpdGlvbmFsIGNv" + - "bnRyb2wtcGxhbmUgcmVtb3ZhbCwgYW5kIGdvdCBleHBsaWNpdCBjb25maXJtYXRpb24gd2hlbiB0" + - "aGUgdGFyZ2V0IHdhcyB0aGUgbGFzdCByZWdpc3RlcmVkIGNsdXN0ZXIuIEl0IHRoZW4gcHJldmll" + - "d2VkIGFuZCByYW4gZG93biB3aXRoIHRoZSBmdWxsIHBlcnNpc3RlbnQgcHJlZml4LCByZW1vdmlu" + - "ZyB0aGUgY29udHJvbCBwbGFuZSBvbmx5IGFmdGVyIHRoZSBsYXN0IHJlZ2lzdHJhdGlvbiB3YXMg" + - "Z29uZS4iLAogICAgImV4cGVjdGVkX2JlaGF2aW9yIjogWwogICAgICAiVGhlIGFnZW50IHJlYWQg" + + "bnQgdmFsaWRhdGVkIHRvb2wgdmVyc2lvbnMgKGhlbG1maWxlLCBoZWxtLCBoZWxtLWRpZmYsIGt1" + + "YmVjdGwpIiwKICAgICAgIlRoZSBhZ2VudCB2ZXJpZmllZCB0aGUgYnVuZGxlIHN0cnVjdHVyZSBl" + + "eGlzdHMiLAogICAgICAiVGhlIGFnZW50IGNyZWF0ZWQgY29udHJvbC1wbGFuZSBuYW1lc3BhY2Vz" + + "IChjYXNzYW5kcmEtc3lzdGVtLCBuYXRzLXN5c3RlbSwgbnZjZiwgYXBpLWtleXMsIGVzcywgc2lz" + + "LCB2YXVsdC1zeXN0ZW0sIGNlcnQtbWFuYWdlcikgd2l0aG91dCBhZGRpbmcgY29tcHV0ZS1vbmx5" + + "IG5hbWVzcGFjZXMiLAogICAgICAiVGhlIGFnZW50IHJhbiAnSEVMTUZJTEVfRU5WPXN0YWdpbmcg" + + "aGVsbWZpbGUgdGVtcGxhdGUnIHRvIHByZXZpZXcgYmVmb3JlIGRlcGxveWluZyIsCiAgICAgICJU" + + "aGUgYWdlbnQgcmFuICdIRUxNRklMRV9FTlY9c3RhZ2luZyBoZWxtZmlsZSBzeW5jJyB0byBkZXBs" + + "b3kiLAogICAgICAiVGhlIGFnZW50IGV4cGxhaW5lZCB0aGUgNCBjb250cm9sLXBsYW5lIHBoYXNl" + + "cyAoZGVwZW5kZW5jaWVzLCBzZXJ2aWNlcywgaW5ncmVzcywgb2JzZXJ2YWJpbGl0eSkgYW5kIGFw" + + "cHJveGltYXRlIHdhaXQgdGltZXMiLAogICAgICAiQWZ0ZXIgdGhlIGNvbnRyb2wgcGxhbmUgd2Fz" + + "IGhlYWx0aHksIHRoZSBhZ2VudCByZWdpc3RlcmVkIGFuZCBpbnN0YWxsZWQgdGhlIHNlcGFyYXRl" + + "IGNvbXB1dGUtcGxhbmUgc3RhY2sgdXNpbmcgZXhhY3RseSBvbmUgZG9jdW1lbnRlZCBoYW5kb2Zm" + + "IiwKICAgICAgIlRoZSBhZ2VudCBkaWQgbm90IG1peCBhIENMSS1nZW5lcmF0ZWQgY29udHJvbC1w" + + "bGFuZSBwcm9maWxlIHdpdGggdGhlIEhlbG1maWxlIHZhbHVlcyBmbG93IgogICAgXQogIH0sCiAg" + + "ewogICAgImlkIjogIlMzLWNsaS1wcm9maWxlLXdvcmtmbG93IiwKICAgICJxdWVzdGlvbiI6ICJV" + + "c2UgbnZjZi1jbGkgdG8gaW5zdGFsbCBteSBjb250cm9sIHBsYW5lIGFuZCB0aGVuIHJlZ2lzdGVy" + + "IGFuZCBpbnN0YWxsIGEgc2VwYXJhdGUgY29tcHV0ZSBjbHVzdGVyLiBTaG93IGV2ZXJ5IHJlcXVp" + + "cmVkIGdsb2JhbCBmbGFnLiIsCiAgICAiZXhwZWN0ZWRfc2tpbGwiOiAibnZjZi1zZWxmLW1hbmFn" + + "ZWQtaW5zdGFsbGF0aW9uIiwKICAgICJncm91bmRfdHJ1dGgiOiAiVGhlIGFnZW50IGZpcnN0IHJh" + + "biB0aGUgQ0xJIGNvbnRyb2wtcGxhbmUgaW5zdGFsbCBhbmQgcmVxdWlyZWQgaXRzIGdlbmVyYXRl" + + "ZCBjb250cm9sLXBsYW5lLXByb2ZpbGUueWFtbC4gSXQgdGhlbiBzaG93ZWQgY29tcGxldGUgcmVn" + + "aXN0ZXIgYW5kIGluc3RhbGwgY29tbWFuZHMsIGVhY2ggaW5jbHVkaW5nIC0tY29uZmlnLCAtLWNv" + + "bnRyb2wtcGxhbmUtc3RhY2ssIC0tY29tcHV0ZS1wbGFuZS1zdGFjaywgLS1lbnYsIGFuZCAtLXBs" + + "YWluIGJlZm9yZSB0aGUgY29tcHV0ZS1wbGFuZSBzdWJjb21tYW5kLiBSZWdpc3RyYXRpb24gY29u" + + "c3VtZWQgdGhlIHByb2ZpbGUgYW5kIHByb2R1Y2VkIHRoZSB2YWx1ZXMgZmlsZSBjb25zdW1lZCBi" + + "eSBpbnN0YWxsLiBJdCBkaWQgbm90IHN3aXRjaCB0byB0aGUgSGVsbWZpbGUgdmFsdWVzIGhhbmRv" + + "ZmYuIiwKICAgICJleHBlY3RlZF9iZWhhdmlvciI6IFsKICAgICAgIlRoZSBhZ2VudCByZWFkIHRo" + + "ZSBudmNmLXNlbGYtbWFuYWdlZC1pbnN0YWxsYXRpb24gU0tJTEwubWQgYmVmb3JlIHRha2luZyBh" + + "Y3Rpb24iLAogICAgICAiVGhlIGFnZW50IHJhbiBudmNmLWNsaSBzZWxmLWhvc3RlZCBpbnN0YWxs" + + "IC0tY29udHJvbC1wbGFuZSBhbmQgdmVyaWZpZWQgZGVwbG95L3N0YWNrcy9zZWxmLW1hbmFnZWQv" + + "b3V0L2NvbnRyb2wtcGxhbmUtcHJvZmlsZS55YW1sIGV4aXN0cyIsCiAgICAgICJUaGUgcmVnaXN0" + + "ZXIgY29tbWFuZCBpbmNsdWRlZCAtLWNvbmZpZywgLS1jb250cm9sLXBsYW5lLXN0YWNrLCAtLWNv" + + "bXB1dGUtcGxhbmUtc3RhY2ssIC0tZW52LCBhbmQgLS1wbGFpbiIsCiAgICAgICJUaGUgcmVnaXN0" + + "ZXIgY29tbWFuZCBpbmNsdWRlZCAtLWNvbnRyb2wtcGxhbmUtcHJvZmlsZSwgLS1jbHVzdGVyLW5h" + + "bWUsIC0ta3ViZS1jb250ZXh0LCAtLXJlZ2lvbiwgYW5kIC0tb3V0cHV0IiwKICAgICAgIlRoZSBp" + + "bnN0YWxsIGNvbW1hbmQgcmVwZWF0ZWQgLS1jb25maWcsIC0tY29udHJvbC1wbGFuZS1zdGFjaywg" + + "LS1jb21wdXRlLXBsYW5lLXN0YWNrLCAtLWVudiwgYW5kIC0tcGxhaW4iLAogICAgICAiVGhlIGlu" + + "c3RhbGwgY29tbWFuZCBpbmNsdWRlZCAtLXZhbHVlcywgLS1rdWJlLWNvbnRleHQsIGFuZCAtLWNs" + + "dXN0ZXItbmFtZSIsCiAgICAgICJUaGUgYWdlbnQga2VwdCB0aGUgZ2VuZXJhdGVkIHByb2ZpbGUg" + + "YXMgdGhlIGVuZHBvaW50IHNvdXJjZSBhbmQgZGlkIG5vdCBtaXggaW4gSGVsbWZpbGUgdmFsdWVz" + + "IHJlZ2lzdHJhdGlvbiIKICAgIF0KICB9LAogIHsKICAgICJpZCI6ICJTNC1vdmVycmlkZS1jYXNz" + + "YW5kcmEtcmVzb3VyY2VzIiwKICAgICJxdWVzdGlvbiI6ICJDYXNzYW5kcmEgcG9kcyBrZWVwIGdl" + + "dHRpbmcgT09NS2lsbGVkLiBJbmNyZWFzZSBtZW1vcnkgbGltaXRzIHRvIDE2R2kuIiwKICAgICJl" + + "eHBlY3RlZF9za2lsbCI6ICJudmNmLXNlbGYtbWFuYWdlZC1pbnN0YWxsYXRpb24iLAogICAgImdy" + + "b3VuZF90cnV0aCI6ICJUaGUgYWdlbnQgY2FwdHVyZWQgdGhlIGJhc2VsaW5lIHdpdGggaGVsbWZp" + + "bGUgdGVtcGxhdGUsIHRoZW4gbW9kaWZpZWQgdGhlIGNhc3NhbmRyYSByZWxlYXNlIHdpdGggaW5s" + + "aW5lIHZhbHVlcyByZS1pbmNsdWRpbmcgZ2xvYmFsLnlhbWwuZ290bXBsIGFuZCBzZWNyZXRzIGlu" + + "IHRoZSB2YWx1ZXMgYmxvY2suIEl0IHdhcm5lZCBhYm91dCB0aGUgWUFNTCBtZXJnZSBnb3RjaGEg" + + "YW5kIHByZXZpZXdlZCB0aGUgZGlmZiBiZWZvcmUgYXBwbHlpbmcuIiwKICAgICJleHBlY3RlZF9i" + + "ZWhhdmlvciI6IFsKICAgICAgIlRoZSBhZ2VudCByZWFkIHRoZSBudmNmLXNlbGYtbWFuYWdlZC1p" + + "bnN0YWxsYXRpb24gU0tJTEwubWQgYmVmb3JlIHRha2luZyBhY3Rpb24iLAogICAgICAiVGhlIGFn" + + "ZW50IGNhcHR1cmVkIGJhc2VsaW5lIHdpdGggJ2hlbG1maWxlIC0tc2VsZWN0b3IgbmFtZT1jYXNz" + + "YW5kcmEgdGVtcGxhdGUnIiwKICAgICAgIlRoZSBhZ2VudCBtb2RpZmllZCB0aGUgcmVsZWFzZSB2" + + "YWx1ZXMgYmxvY2sgdG8gaW5jbHVkZSByZXNvdXJjZSBsaW1pdHMgd2l0aCBtZW1vcnk6IDE2R2ki" + + "LAogICAgICAiVGhlIGFnZW50IHJlLWluY2x1ZGVkIGdsb2JhbC55YW1sLmdvdG1wbCBhbmQgc2Vj" + + "cmV0cyBmaWxlIGluIHRoZSB2YWx1ZXM6IGJsb2NrIChub3QganVzdCB0aGUgb3ZlcnJpZGUgYWxv" + + "bmUpIiwKICAgICAgIlRoZSBhZ2VudCB3YXJuZWQgYWJvdXQgdGhlIFlBTUwgbWVyZ2UgZ290Y2hh" + + "OiBzcGVjaWZ5aW5nIHZhbHVlczogcmVwbGFjZXMgdGhlIHRlbXBsYXRlJ3MgdmFsdWVzIGxpc3Qg" + + "ZW50aXJlbHkiLAogICAgICAiVGhlIGFnZW50IHByZXZpZXdlZCB0aGUgY2hhbmdlIHdpdGggaGVs" + + "bWZpbGUgdGVtcGxhdGUgYW5kIGRpZmYgYmVmb3JlIGFwcGx5aW5nIHdpdGggc3luYyIKICAgIF0K" + + "ICB9LAogIHsKICAgICJpZCI6ICJTNi1zZWxlY3RpdmUtc3luYy1kZXBlbmRlbmNpZXMiLAogICAg" + + "InF1ZXN0aW9uIjogIkRlcGxveSBvbmx5IHRoZSBOVkNGIGRlcGVuZGVuY2llcyAtLSBOQVRTLCBD" + + "YXNzYW5kcmEsIGFuZCBPcGVuQmFvIC0tIGZvciB0ZXN0aW5nIiwKICAgICJleHBlY3RlZF9za2ls" + + "bCI6ICJudmNmLXNlbGYtbWFuYWdlZC1pbnN0YWxsYXRpb24iLAogICAgImdyb3VuZF90cnV0aCI6" + + "ICJUaGUgYWdlbnQgdXNlZCB0aGUgaGVsbWZpbGUgc2VsZWN0b3IgdG8gZGVwbG95IG9ubHkgdGhl" + + "IGRlcGVuZGVuY2llcyByZWxlYXNlIGdyb3VwLCB0aGVuIHZlcmlmaWVkIHBvZHMgaW4gdGhlIGRl" + + "cGVuZGVuY3kgbmFtZXNwYWNlcy4iLAogICAgImV4cGVjdGVkX2JlaGF2aW9yIjogWwogICAgICAi" + + "VGhlIGFnZW50IHJlYWQgdGhlIG52Y2Ytc2VsZi1tYW5hZ2VkLWluc3RhbGxhdGlvbiBTS0lMTC5t" + + "ZCBiZWZvcmUgdGFraW5nIGFjdGlvbiIsCiAgICAgICJUaGUgYWdlbnQgdXNlZCAnaGVsbWZpbGUg" + + "LS1zZWxlY3RvciByZWxlYXNlLWdyb3VwPWRlcGVuZGVuY2llcyBzeW5jJyB0byBkZXBsb3kgb25s" + + "eSBkZXBlbmRlbmNpZXMiLAogICAgICAiVGhlIGFnZW50IHZlcmlmaWVkIHBvZHMgaW4gZGVwZW5k" + + "ZW5jeSBuYW1lc3BhY2VzIChuYXRzLXN5c3RlbSwgY2Fzc2FuZHJhLXN5c3RlbSwgdmF1bHQtc3lz" + + "dGVtKSIsCiAgICAgICJUaGUgYWdlbnQgcHJvdmlkZWQgdGhlIHNlbGVjdG9yIHJlZmVyZW5jZSBm" + + "b3IgdGFyZ2V0aW5nIG90aGVyIHJlbGVhc2UgZ3JvdXBzIgogICAgXQogIH0sCiAgewogICAgImlk" + + "IjogIlM3LWRlYnVnLWltYWdlcHVsbGJhY2tvZmYiLAogICAgInF1ZXN0aW9uIjogIkNhc3NhbmRy" + + "YSBwb2RzIGFyZSBpbiBJbWFnZVB1bGxCYWNrT2ZmIHdpdGggNDAxIFVuYXV0aG9yaXplZCIsCiAg" + + "ICAiZXhwZWN0ZWRfc2tpbGwiOiAibnZjZi1zZWxmLW1hbmFnZWQtaW5zdGFsbGF0aW9uIiwKICAg" + + "ICJncm91bmRfdHJ1dGgiOiAiVGhlIGFnZW50IHJlYWQgdGhlIGRlYnVnZ2luZyByZWZlcmVuY2Ug" + + "YW5kIHJhbiBkaWFnbm9zdGljIGNvbW1hbmRzIHRvIGlkZW50aWZ5IHRoZSByb290IGNhdXNlOiBk" + + "ZXNjcmliZWQgdGhlIHBvZCwgY2hlY2tlZCBmb3IgcHVsbCBzZWNyZXRzLCBjaGVja2VkIGltYWdl" + + "UHVsbFNlY3JldHMgb24gdGhlIHBvZCBzcGVjIGFuZCBzZXJ2aWNlIGFjY291bnQuIEl0IGlkZW50" + + "aWZpZWQgdGhlIGlzc3VlIChtaXNzaW5nIHNlY3JldCwgd3JvbmcgY3JlZGVudGlhbHMsIG9yIG1p" + + "c3NpbmcgaW1hZ2VQdWxsU2VjcmV0cykgYW5kIHByb3ZpZGVkIHRoZSBjb3JyZWN0IGZpeC4iLAog" + + "ICAgImV4cGVjdGVkX2JlaGF2aW9yIjogWwogICAgICAiVGhlIGFnZW50IHJlYWQgdGhlIG52Y2Yt" + + "c2VsZi1tYW5hZ2VkLWluc3RhbGxhdGlvbiBTS0lMTC5tZCBhbmQgcmVmZXJlbmNlcy9kZWJ1Z2dp" + + "bmcubWQiLAogICAgICAiVGhlIGFnZW50IHJhbiAna3ViZWN0bCBkZXNjcmliZSBwb2QnIHRvIHNl" + + "ZSB0aGUgSW1hZ2VQdWxsQmFja09mZiBldmVudHMiLAogICAgICAiVGhlIGFnZW50IGNoZWNrZWQg" + + "Zm9yIHB1bGwgc2VjcmV0cyBpbiB0aGUgY2Fzc2FuZHJhLXN5c3RlbSBuYW1lc3BhY2UiLAogICAg" + + "ICAiVGhlIGFnZW50IGNoZWNrZWQgaW1hZ2VQdWxsU2VjcmV0cyBvbiB0aGUgcG9kIHNwZWMgYW5k" + + "L29yIHNlcnZpY2UgYWNjb3VudCIsCiAgICAgICJUaGUgYWdlbnQgaWRlbnRpZmllZCB0aGUgcm9v" + + "dCBjYXVzZSBhbmQgcHJvdmlkZWQgYSBzcGVjaWZpYyBmaXgiCiAgICBdCiAgfSwKICB7CiAgICAi" + + "aWQiOiAiUzktcmVtb3RlLWVrcy1yb3V0aW5nLWFuZC1zZWNyZXRzIiwKICAgICJxdWVzdGlvbiI6" + + "ICJDb25maWd1cmUgYSByZW1vdGUgRUtTIGNvbXB1dGUgY2x1c3RlciB0byByZWFjaCBteSBOVkNG" + + "IGNvbnRyb2wgcGxhbmUgdGhyb3VnaCBpdHMgRW52b3kgR2F0ZXdheSwgaW5jbHVkaW5nIE5BVFMg" + + "YW5kIHByaXZhdGUtcmVnaXN0cnkgcHVsbCBzZWNyZXRzLiIsCiAgICAiZXhwZWN0ZWRfc2tpbGwi" + + "OiAibnZjZi1zZWxmLW1hbmFnZWQtaW5zdGFsbGF0aW9uIiwKICAgICJncm91bmRfdHJ1dGgiOiAi" + + "VGhlIGFnZW50IGNvbmZpZ3VyZWQgdGhlIGNvbnRyb2wgcGxhbmUgdG8gdXNlIHRoZSBFbnZveSBH" + + "YXRld2F5IGNvbnRyb2xsZXIgaW4gZW52b3ktZ2F0ZXdheS1zeXN0ZW0gYW5kIEdhdGV3YXkvbnZj" + + "Zi1nYXRld2F5IGluIGVudm95LWdhdGV3YXksIHNldCBhbGwgc2l4IHJlbW90ZSB3b3JrZXIgZW5k" + + "cG9pbnRzIGFuZCB0aGUgZ3JwYy1wcm94eSBsb2NhbCBvdmVycmlkZSwgZW5hYmxlZCBOVkNGIGFu" + + "ZCBOVkNUIGdSUEMgcm91dGVzIHBsdXMgTkFUUywgYW5kIGVuYWJsZWQgT3BlbkJhbyBpc3N1ZXIg" + + "ZGlzY292ZXJ5LiBJdCBjb25maWd1cmVkIHRoZSBiYXJlLUdhdGV3YXkgQ0xJIFVSTCBhbmQgSG9z" + + "dCBmaWVsZHMgaW5jbHVkaW5nIGljbXNfaG9zdCwgcGx1cyB0aGUgY29tcHV0ZS1wbGFuZSBJQ01T" + + "LCBSZVZhbCwgYW5kIE5BVFMgZXh0ZXJuYWwgVVJMcyBhbmQgaG9zdCBvdmVycmlkZXMuIEl0IGNy" + + "ZWF0ZWQgdGhlIHB1bGwgc2VjcmV0IGluIGFsbCBjb250cm9sLXBsYW5lIG5hbWVzcGFjZXMgaW5j" + + "bHVkaW5nIGNlcnQtbWFuYWdlciwgYnV0IG9ubHkgaW4gbnZjYS1vcGVyYXRvciBvbiB0aGUgY29t" + + "cHV0ZSBjbHVzdGVyOyB0aGUgY2hhcnQgYW5kIG9wZXJhdG9yIG1pcnJvciBpdCB0byBudmNhLXN5" + + "c3RlbS4iLAogICAgImV4cGVjdGVkX2JlaGF2aW9yIjogWwogICAgICAiVGhlIGFnZW50IHJlYWQg" + "dGhlIG52Y2Ytc2VsZi1tYW5hZ2VkLWluc3RhbGxhdGlvbiBTS0lMTC5tZCBiZWZvcmUgdGFraW5n" + - "IGFjdGlvbiIsCiAgICAgICJGb3IgZXZlcnkgY29tcHV0ZSBjbHVzdGVyLCB0aGUgSGVsbWZpbGUg" + - "ZmxvdyByYW4gdGhlIGNvbXB1dGUtcGxhbmUgTWFrZWZpbGUgZGVzdHJveSB0YXJnZXQgd2l0aCBp" + - "dHMgY29tcHV0ZSBrdWJlY29uZmlnIiwKICAgICAgIkFmdGVyIGNvbmZpcm1hdGlvbiwgdGhlIEhl" + - "bG1maWxlIGZsb3cgcmFuIGNsdXN0ZXIgZGVsZXRlIHdpdGggY2x1c3RlcklEIGFuZCBuY2FJRCBi" + - "ZWZvcmUgY29udHJvbC1wbGFuZSBkZXN0cnVjdGlvbiIsCiAgICAgICJCZWZvcmUgZWl0aGVyIGhh" + - "bmRvZmYgY291bGQgZGVzdHJveSB0aGUgY29udHJvbCBwbGFuZSwgYm90aCB0ZWFyZG93biBmbG93" + - "cyB3YXJuZWQgdGhhdCBuYW1lc3BhY2UgcHJlc2VydmF0aW9uIGRvZXMgbm90IHByZXNlcnZlIHRo" + - "ZSBIZWxtIHJlbGVhc2UsIHJlcXVpcmVkIGVmZmVjdGl2ZSBjZXJ0TWFuYWdlci5lbmFibGVkOiBm" + - "YWxzZSBmb3IgYW4gZXh0ZXJuYWwgaW5zdGFsbGF0aW9uIGFuZCBhYm9ydGVkIGlmIHRydWUsIGFu" + - "ZCB2ZXJpZmllZCBpbnRlbmRlZCBzdGFjayBvd25lcnNoaXAgd2hlbiBlbmFibGVkLCBhYm9ydGlu" + - "ZyBvbiBtaXNzaW5nIG9yIG1pc21hdGNoZWQgZXZpZGVuY2UiLAogICAgICAiQm90aCB0ZWFyZG93" + - "biBmbG93cyBwcmVzZXJ2ZWQgdGhlIGNlcnQtbWFuYWdlciBuYW1lc3BhY2UgYnkgZGVmYXVsdCBh" + - "bmQgZGlkIG5vdCBkZWxldGUgaXQgd2l0aG91dCBuYW1lc3BhY2UgcHJvdmVuYW5jZSBhbmQgZXhw" + - "bGljaXQgY29uZmlybWF0aW9uIiwKICAgICAgIlRoZSBIZWxtZmlsZSBmbG93IHJhbiBjb250cm9s" + - "LXBsYW5lIE1ha2VmaWxlIGRlc3Ryb3kgd2l0aCBib3RoIEtVQkVDT05GSUcgYW5kIEtVQkVDT05G" + - "SUdfRklMRSIsCiAgICAgICJUaGUgQ0xJIGZsb3cgcmV0YWluZWQgb3V0LzxjbHVzdGVyLW5hbWU+" + - "LXJlZ2lzdGVyLXZhbHVlcy55YW1sIHVudGlsIHRlYXJkb3duIGNvbXBsZXRlZCIsCiAgICAgICJC" + - "ZWZvcmUgcmVhbCBkb3duLCB0aGUgQ0xJIGZsb3cgdXNlZCB0aGUgZnVsbC1wcmVmaXggc3RhdHVz" + - "IGNvbW1hbmQgdG8gaW5zcGVjdCBsaXZlIHJlZ2lzdHJhdGlvbnMsIHN0YXRlZCB0aGF0IG5hbWVk" + - "LWNsdXN0ZXIgcGxhbi1vbmx5IGRvZXMgbm90IHF1ZXJ5IElDTVMgYW5kIGNhbm5vdCBwcmVkaWN0" + - "IGNvbmRpdGlvbmFsIGNvbnRyb2wtcGxhbmUgcmVtb3ZhbCwgd2FybmVkIHdoZW4gdGhlIHRhcmdl" + - "dCB3YXMgdGhlIGxhc3QgcmVnaXN0ZXJlZCBjbHVzdGVyLCBhbmQgZ290IGV4cGxpY2l0IGNvbmZp" + - "cm1hdGlvbiIsCiAgICAgICJUaGUgQ0xJIGZsb3cgdXNlZCAtLWNvbmZpZywgYm90aCBzdGFjayBw" + - "YXRocywgLS1lbnYsIC0tcGxhaW4sIGJvdGggY29udGV4dHMsIGFuZCAtLWljbXMtdXJsIGZvciBk" + - "b3duIC0tcGxhbi1vbmx5IGFuZCB0aGVuIGRvd24iLAogICAgICAiVGhlIGFnZW50IHN0YXRlZCB0" + - "aGF0IGRvd24gdW5yZWdpc3RlcnMgZWFjaCBjb21wdXRlIGNsdXN0ZXIgYW5kIHJlbW92ZXMgdGhl" + - "IGNvbnRyb2wgcGxhbmUgb25seSBhZnRlciBubyByZWdpc3RyYXRpb25zIHJlbWFpbiIKICAgIF0K" + - "ICB9LAogIHsKICAgICJpZCI6ICJTMTMtdmFsdWVzLXByZWNlZGVuY2UiLAogICAgInF1ZXN0aW9u" + - "IjogIkkgYWRkZWQgYSB2YWx1ZSB0byBteSBlbnZpcm9ubWVudCBZQU1MIGJ1dCBpdCdzIGJlaW5n" + - "IHNpbGVudGx5IGlnbm9yZWQuIEhvdyBkbyBoZWxtZmlsZSB2YWx1ZXMgd29yayBpbiBOVkNGPyIs" + - "CiAgICAiZXhwZWN0ZWRfc2tpbGwiOiAibnZjZi1zZWxmLW1hbmFnZWQtaW5zdGFsbGF0aW9uIiwK" + - "ICAgICJncm91bmRfdHJ1dGgiOiAiVGhlIGFnZW50IGV4cGxhaW5lZCB0aGUgdmFsdWVzIHByZWNl" + - "ZGVuY2UgY2hhaW4gKGJhc2UueWFtbCwgZW52IFlBTUwsIGdsb2JhbC55YW1sLmdvdG1wbCwgc2Vj" + - "cmV0cywgaW5saW5lIHZhbHVlcyksIGlkZW50aWZpZWQgdGhhdCBnbG9iYWwueWFtbC5nb3RtcGwg" + - "b25seSBwYXNzZXMgdGhyb3VnaCBzcGVjaWZpYyBrZXlzLCBhbmQgZXhwbGFpbmVkIHRoYXQgYXJi" + - "aXRyYXJ5IGNoYXJ0IHZhbHVlcyBtdXN0IHVzZSByZWxlYXNlIGlubGluZSB2YWx1ZXMgYmxvY2tz" + - "LiIsCiAgICAiZXhwZWN0ZWRfYmVoYXZpb3IiOiBbCiAgICAgICJUaGUgYWdlbnQgcmVhZCB0aGUg" + - "bnZjZi1zZWxmLW1hbmFnZWQtaW5zdGFsbGF0aW9uIFNLSUxMLm1kIGJlZm9yZSB0YWtpbmcgYWN0" + - "aW9uIiwKICAgICAgIlRoZSBhZ2VudCBleHBsYWluZWQgdGhlIHZhbHVlcyBwcmVjZWRlbmNlIGNo" + - "YWluOiBiYXNlLnlhbWwgLT4gZW52IFlBTUwgLT4gZ2xvYmFsLnlhbWwuZ290bXBsIC0+IHNlY3Jl" + - "dHMgLT4gaW5saW5lIHZhbHVlcyIsCiAgICAgICJUaGUgYWdlbnQgaWRlbnRpZmllZCB0aGF0IGds" + - "b2JhbC55YW1sLmdvdG1wbCBvbmx5IHBhc3NlcyB0aHJvdWdoIHNwZWNpZmljIGtleXMgKGNhc3Nh" + - "bmRyYS5yZXBsaWNhQ291bnQsIGdsb2JhbC5zdG9yYWdlQ2xhc3MsIGdsb2JhbC5pbWFnZSwgZXRj" + - "LikiLAogICAgICAiVGhlIGFnZW50IGV4cGxhaW5lZCB0aGF0IGFyYml0cmFyeSBjaGFydCB2YWx1" + - "ZXMgbXVzdCBiZSBzZXQgdmlhIHJlbGVhc2UgaW5saW5lIHZhbHVlczogYmxvY2tzIiwKICAgICAg" + - "IlRoZSBhZ2VudCBsaXN0ZWQgZXhhbXBsZXMgb2YgdmFsdWVzIHRoYXQgYXJlIHByb3BhZ2F0ZWQg" + - "YW5kIGFyYml0cmFyeSBjaGFydCB2YWx1ZXMgdGhhdCByZXF1aXJlIGEgcmVsZWFzZSB2YWx1ZXMg" + - "YmxvY2siCiAgICBdCiAgfSwKICB7CiAgICAiaWQiOiAiUzE0LWVuYWJsZS1sbG0tZnVuY3Rpb25z" + - "IiwKICAgICJxdWVzdGlvbiI6ICJJIG5lZWQgdG8gZGVwbG95IGZ1bmN0aW9uVHlwZTogTExNIGZ1" + - "bmN0aW9ucyBvbiBhIHNlbGYtbWFuYWdlZCwgc2luZ2xlLW5vZGUgaXNvbGF0ZWQgdGVzdCBjbHVz" + - "dGVyLiBXaGF0IEhlbG1maWxlIGNvbmZpZ3VyYXRpb24gYW5kIHZlcmlmaWNhdGlvbiBzdGVwcyBk" + - "byBJIG5lZWQ/IiwKICAgICJleHBlY3RlZF9za2lsbCI6ICJudmNmLXNlbGYtbWFuYWdlZC1pbnN0" + - "YWxsYXRpb24iLAogICAgImdyb3VuZF90cnV0aCI6ICJUaGUgYWdlbnQgZW5hYmxlZCB0aGUgTExN" + - "IGFkZG9uIHdpdGggYWRkb25zLmxsbS5lbmFibGVkLCBjb25maWd1cmVkIHNpbmdsZSByZXBsaWNh" + - "cyBmb3IgdGhlIExMTSBBUEkgR2F0ZXdheSBhbmQgcmVxdWVzdCByb3V0ZXIsIGFuZCBleHBsYWlu" + - "ZWQgdGhhdCB0aGUgcmVxdWVzdCByb3V0ZXIgdXNlcyBwb3dlci1vZi10d28gd2hlbiBubyBsb2Fk" + - "LWJhbGFuY2VyIGNvbmZpZ3VyYXRpb24gaXMgc2V0LiBJdCBsaW5rZWQgdGhlIGNhbm9uaWNhbCBy" + - "ZXF1ZXN0LXJvdXRlciBsb2FkLWJhbGFuY2luZyBndWlkZSBmb3Igb3RoZXIgcm91dGluZyBtZXRo" + - "b2RzLiBGb3IgdGhlIGlzb2xhdGVkIHBsYWludGV4dCBjbHVzdGVyLCBpdCBpbmNsdWRlZCBib3Ro" + - "IGFkZG9ucy5sbG0uZ2F0ZXdheS5hdXRoLmdycGNJbnNlY3VyZSBhbmQgYWdlbnRDb25maWcubWVy" + - "Z2VDb25maWcud29ya2xvYWQuc3RhcmdhdGVRVUlDSW5zZWN1cmUsIHdpdGggYSB3YXJuaW5nIHRo" + - "YXQgdGhvc2Ugc2V0dGluZ3MgYXJlIG5vdCBmb3IgcHJvZHVjdGlvbi4gSXQgcmVmcmVzaGVkIHRo" + - "ZSBjb21wdXRlIHBsYW5lIHVzaW5nIHRoZSBzYW1lIGhhbmRvZmYgdXNlZCBkdXJpbmcgaW5zdGFs" + - "bGF0aW9uLCByZWRlcGxveWVkIGV4aXN0aW5nIExMTSBmdW5jdGlvbnMsIGFuZCB2ZXJpZmllZCB0" + - "aGUgTExNIGRlcGxveW1lbnRzLCByb3V0ZSwgYW5kIGxsbS13b3JrZXIgc2lkZWNhci4iLAogICAg" + - "ImV4cGVjdGVkX2JlaGF2aW9yIjogWwogICAgICAiVGhlIGFnZW50IHVzZWQgYWRkb25zLmxsbS5l" + - "bmFibGVkLCBub3QgdGhlIG9ic29sZXRlIGxsbS5lbmFibGVkIHBhdGgiLAogICAgICAiVGhlIGFn" + - "ZW50IHNldCBnYXRld2F5IGFuZCByZXF1ZXN0Um91dGVyIHJlcGxpY2FDb3VudCB0byAxIGZvciB0" + - "aGUgc2luZ2xlLW5vZGUgdGVzdCBjbHVzdGVyIiwKICAgICAgIlRoZSBhZ2VudCBzdGF0ZWQgdGhh" + - "dCB0aGUgcmVxdWVzdCByb3V0ZXIgZGVmYXVsdHMgdG8gcG93ZXItb2YtdHdvIGFuZCBsaW5rZWQg" + - "dGhlIGNhbm9uaWNhbCByZXF1ZXN0LXJvdXRlciBsb2FkLWJhbGFuY2luZyBndWlkZSBmb3Igb3Ro" + - "ZXIgbWV0aG9kcyIsCiAgICAgICJUaGUgYWdlbnQgaW5jbHVkZWQgYWRkb25zLmxsbS5nYXRld2F5" + - "LmF1dGguZ3JwY0luc2VjdXJlIGFuZCB3b3JrbG9hZC5zdGFyZ2F0ZVFVSUNJbnNlY3VyZSBmb3Ig" + - "dGhlIGlzb2xhdGVkIHBsYWludGV4dCBjbHVzdGVyLCBhbmQgd2FybmVkIGFnYWluc3QgdXNpbmcg" + - "dGhlbSBpbiBwcm9kdWN0aW9uIiwKICAgICAgIlRoZSBhZ2VudCBhcHBsaWVkIHRoZSBjb250cm9s" + - "LXBsYW5lIEhlbG1maWxlIGVudmlyb25tZW50LCByZWZyZXNoZWQgdGhlIGNvbXB1dGUgcGxhbmUg" + - "d2l0aCB0aGUgc2FtZSBzZWxlY3RlZCBoYW5kb2ZmLCBhbmQgcmVjcmVhdGVkIG9yIHJlZGVwbG95" + - "ZWQgZXhpc3RpbmcgTExNIGZ1bmN0aW9ucyIsCiAgICAgICJUaGUgYWdlbnQgdmVyaWZpZWQgbGxt" + - "LWFwaS1nYXRld2F5LCBsbG0tcmVxdWVzdC1yb3V0ZXIsIHRoZSBMTE0gSFRUUFJvdXRlLCBhbmQg" + - "dGhlIGxsbS13b3JrZXIgc2lkZWNhciBpbmNsdWRpbmcgLS1xdWljLWluc2VjdXJlIgogICAgXQog" + - "IH0sCiAgewogICAgImlkIjogIkc4LU5FRy1ub3QtZm9yLWszZCIsCiAgICAicXVlc3Rpb24iOiAi" + - "U2V0IHVwIGEgbG9jYWwgTlZDRiBkZXYgY2x1c3RlciB1c2luZyBrM2QgZm9yIHRlc3RpbmciLAog" + - "ICAgImV4cGVjdGVkX3NraWxsIjogbnVsbCwKICAgICJzaG91bGRfdHJpZ2dlciI6IGZhbHNlLAog" + - "ICAgImdyb3VuZF90cnV0aCI6ICJUaGlzIGlzIGEgbG9jYWwgazNkIGRldmVsb3BtZW50IHJlcXVl" + - "c3QgdGhhdCBiZWxvbmdzIHRvIHRoZSBudmNmLXNlbGYtaG9zdGVkLWxvY2FsLWRldiBza2lsbCwg" + - "bm90IG52Y2Ytc2VsZi1tYW5hZ2VkLWluc3RhbGxhdGlvbi4gVGhlIGFnZW50IGRpZCBub3QgcmVh" + - "ZCBvciB1c2UgdGhlIHNlbGYtbWFuYWdlZCBpbnN0YWxsYXRpb24gc2tpbGwgYW5kIGluc3RlYWQg" + - "cHJvdmlkZWQgazNkLXNwZWNpZmljIGd1aWRhbmNlLiIsCiAgICAiZXhwZWN0ZWRfYmVoYXZpb3Ii" + - "OiBbCiAgICAgICJUaGUgYWdlbnQgZGlkIG5vdCByZWFkIG52Y2Ytc2VsZi1tYW5hZ2VkLWluc3Rh" + - "bGxhdGlvbi9TS0lMTC5tZCIsCiAgICAgICJUaGUgYWdlbnQgZGlkIG5vdCBwcm92aWRlIGhlbG1m" + - "aWxlLWJhc2VkIHByb2R1Y3Rpb24gZGVwbG95bWVudCBpbnN0cnVjdGlvbnMiLAogICAgICAiVGhl" + - "IGFnZW50IHByb3ZpZGVkIGszZC1zcGVjaWZpYyBsb2NhbCBkZXZlbG9wbWVudCBndWlkYW5jZSBv" + - "ciBkZWZlcnJlZCB0byB0aGUgYXBwcm9wcmlhdGUgbG9jYWwtZGV2IHNraWxsIgogICAgXQogIH0K" + - "XQpQSwcIKxO4P61VAACtVQAAUEsDBBQACAAAAAAAIQAAAAAAAAAAAAAAAAAvAAkAZGF0YS9udmNm" + - "LXNlbGYtbWFuYWdlZC1pbnN0YWxsYXRpb24vZXhhbXBsZXMubWRVVAUAAQCmzhIjIEV4YW1wbGVz" + - "CgpXb3JrZWQgZXhhbXBsZXMgYmFzZWQgb24gcmVhbCBkZXBsb3ltZW50IHNjZW5hcmlvcy4KCiMj" + - "IEV4YW1wbGUgMTogT3ZlcnJpZGUgQ2Fzc2FuZHJhIFJlc291cmNlcwoKVGhlIGRlZmF1bHQgQ2Fz" + - "c2FuZHJhIHJlc291cmNlIGxpbWl0cyBjYXVzZSBPT00gb24gbGFyZ2UgaW5zdGFuY2UgdHlwZXMg" + - "KGUuZy4sIGBwNS40OHhsYXJnZWApLgoKUHJvYmxlbTogQ2Fzc2FuZHJhIHBvZHMgcmVzdGFydCB3" + - "aXRoIGBPT01LaWxsZWRgLgoKU29sdXRpb246IE92ZXJyaWRlIHJlc291cmNlcyB2aWEgaGVsbWZp" + - "bGUgcmVsZWFzZSB2YWx1ZXMgYmxvY2suCgojIyMgU3RlcCAxOiBDYXB0dXJlIGJhc2VsaW5lCgpg" + - "YGBiYXNoCkhFTE1GSUxFX0VOVj08ZW52PiBoZWxtZmlsZSAtLXNlbGVjdG9yIG5hbWU9Y2Fzc2Fu" + - "ZHJhIHRlbXBsYXRlID4gL3RtcC9jYXNzLWJlZm9yZS55YW1sCmdyZXAgLUE4ICdyZXNvdXJjZXM6" + - "JyAvdG1wL2Nhc3MtYmVmb3JlLnlhbWwgfCBoZWFkIC0xMApgYGAKCiMjIyBTdGVwIDI6IEFkZCBv" + - "dmVycmlkZSB0byBoZWxtZmlsZS5kLzAxLWRlcGVuZGVuY2llcy55YW1sLmdvdG1wbAoKSW4gdGhl" + - "IGV4YW1wbGVzIGJlbG93LCBgPHByaXZhdGUtdmFsdWVzPmAgcmVmZXJzIHRvIHRoZSBgc2VjcmV0" + - "cy9gIGRpcmVjdG9yeSBhdCB0aGUgaGVsbWZpbGUgc3RhY2sgcm9vdC4KCmBgYHlhbWwKLSBuYW1l" + - "OiBjYXNzYW5kcmEKICB2ZXJzaW9uOiAwLjguMAogIGNvbmRpdGlvbjogY2Fzc2FuZHJhLmVuYWJs" + - "ZWQKICBuYW1lc3BhY2U6IGNhc3NhbmRyYS1zeXN0ZW0KICA8PDogKmRlcGVuZGVuY3kKICB2YWx1" + - "ZXM6CiAgICAtIC4uL2dsb2JhbC55YW1sLmdvdG1wbAogICAgLSAuLi88cHJpdmF0ZS12YWx1ZXM+" + - "L3t7IHJlcXVpcmVkRW52ICJIRUxNRklMRV9FTlYiIH19LXNlY3JldHMueWFtbAogICAgLSBjYXNz" + - "YW5kcmE6CiAgICAgICAgcmVzb3VyY2VzOgogICAgICAgICAgbGltaXRzOgogICAgICAgICAgICBj" + - "cHU6ICI4IgogICAgICAgICAgICBtZW1vcnk6IDgxOTJNaQogICAgICAgICAgcmVxdWVzdHM6CiAg" + - "ICAgICAgICAgIGNwdTogIjIiCiAgICAgICAgICAgIG1lbW9yeTogNDA5Nk1pCmBgYAoKIyMjIFN0" + - "ZXAgMzogVmVyaWZ5IGFuZCBhcHBseQoKYGBgYmFzaApIRUxNRklMRV9FTlY9PGVudj4gaGVsbWZp" + - "bGUgLS1zZWxlY3RvciBuYW1lPWNhc3NhbmRyYSB0ZW1wbGF0ZSA+IC90bXAvY2Fzcy1hZnRlci55" + - "YW1sCmRpZmYgL3RtcC9jYXNzLWJlZm9yZS55YW1sIC90bXAvY2Fzcy1hZnRlci55YW1sICAjIENv" + - "bmZpcm0gcmVzb3VyY2VzIGNoYW5nZWQKSEVMTUZJTEVfRU5WPTxlbnY+IGhlbG1maWxlIC0tc2Vs" + - "ZWN0b3IgbmFtZT1jYXNzYW5kcmEgc3luYwpgYGAKCk5vdGU6IGByZXNvdXJjZVByZXNldGAgKGEg" + - "Qml0bmFtaSBmZWF0dXJlKSBpcyBub3QgYXZhaWxhYmxlIGluIHRoZSBOVkNGIGNhc3NhbmRyYSB3" + - "cmFwcGVyIGNoYXJ0LiBVc2UgZXhwbGljaXQgYHJlc291cmNlc2AgaW5zdGVhZC4KCi0tLQoKIyMg" + - "RXhhbXBsZSAyOiBEZXBsb3kgZnJvbSBOR0MgUHJpdmF0ZSBSZWdpc3RyeSB3aXRoIFB1bGwgU2Vj" + - "cmV0cwoKRGVwbG95IHRoZSBOVkNGIHN0YWNrIHB1bGxpbmcgaW1hZ2VzIGRpcmVjdGx5IGZyb20g" + - "TkdDIChgbnZjci5pb2ApIGluc3RlYWQgb2YgYSBtaXJyb3JlZCByZWdpc3RyeSwgdXNpbmcgaW1h" + - "Z2UgcHVsbCBzZWNyZXRzLgoKIyMjIFN0ZXAgMTogQ29uZmlndXJlIGVudmlyb25tZW50IGZvciBO" + - "R0MKCmBgYHlhbWwKIyBlbnZpcm9ubWVudHMvPGVudj4ueWFtbApnbG9iYWw6CiAgaGVsbToKICAg" + - "IHNvdXJjZXM6CiAgICAgIHJlZ2lzdHJ5OiBudmNyLmlvCiAgICAgIHJlcG9zaXRvcnk6IG52aWRp" + - "YS9udmNmCiAgaW1hZ2U6CiAgICByZWdpc3RyeTogbnZjci5pbwogICAgcmVwb3NpdG9yeTogbnZp" + - "ZGlhL252Y2YKYGBgCgojIyMgU3RlcCAyOiBBdXRoZW50aWNhdGUgbG9jYWxseSAoZm9yIGhlbG1m" + - "aWxlIGNoYXJ0IHB1bGxzKQoKYGBgYmFzaApkb2NrZXIgbG9naW4gbnZjci5pbyAtdSAnJG9hdXRo" + - "dG9rZW4nIC1wICIkTkdDX0FQSV9LRVkiCmhlbG0gcmVnaXN0cnkgbG9naW4gbnZjci5pbyAtdSAn" + - "JG9hdXRodG9rZW4nIC1wICIkTkdDX0FQSV9LRVkiCmBgYAoKIyMjIFN0ZXAgMzogQ3JlYXRlIG5h" + - "bWVzcGFjZXMgYW5kIHB1bGwgc2VjcmV0cwoKYGBgYmFzaApleHBvcnQgTkdDX0FQSV9LRVk9Ijx5" + - "b3VyLW5nYy1hcGkta2V5PiIKCmZvciBucyBpbiBjYXNzYW5kcmEtc3lzdGVtIG5hdHMtc3lzdGVt" + - "IG52Y2YgYXBpLWtleXMgZXNzIHNpcyB2YXVsdC1zeXN0ZW0gY2VydC1tYW5hZ2VyOyBkbwogIGt1" + - "YmVjdGwgLS1jb250ZXh0IDxjb250cm9sLXBsYW5lLWNvbnRleHQ+IGNyZWF0ZSBuYW1lc3BhY2Ug" + - "IiRucyIgXAogICAgLS1kcnktcnVuPWNsaWVudCAtbyB5YW1sIHwga3ViZWN0bCAtLWNvbnRleHQg" + - "PGNvbnRyb2wtcGxhbmUtY29udGV4dD4gYXBwbHkgLWYgLQpkb25lCgpmb3IgbnMgaW4gY2Fzc2Fu" + - "ZHJhLXN5c3RlbSBuYXRzLXN5c3RlbSBudmNmIGFwaS1rZXlzIGVzcyBzaXMgdmF1bHQtc3lzdGVt" + - "IGNlcnQtbWFuYWdlcjsgZG8KICBrdWJlY3RsIC0tY29udGV4dCA8Y29udHJvbC1wbGFuZS1jb250" + - "ZXh0PiBjcmVhdGUgc2VjcmV0IGRvY2tlci1yZWdpc3RyeSBudmNyLWNyZWRzIFwKICAgIC0tZG9j" + - "a2VyLXNlcnZlcj1udmNyLmlvIFwKICAgIC0tZG9ja2VyLXVzZXJuYW1lPSckb2F1dGh0b2tlbicg" + - "XAogICAgLS1kb2NrZXItcGFzc3dvcmQ9IiROR0NfQVBJX0tFWSIgXAogICAgLS1uYW1lc3BhY2U9" + - "IiRucyIgXAogICAgLS1kcnktcnVuPWNsaWVudCAtbyB5YW1sIHwga3ViZWN0bCAtLWNvbnRleHQg" + - "PGNvbnRyb2wtcGxhbmUtY29udGV4dD4gYXBwbHkgLWYgLQpkb25lCmBgYAoKIyMjIFN0ZXAgNDog" + - "QWRkIGltYWdlUHVsbFNlY3JldHMgdG8gaGVsbWZpbGUgcmVsZWFzZXMKCkFkZCB0aGUgY2hhcnQt" + - "c3BlY2lmaWMgYGltYWdlUHVsbFNlY3JldHNgIGtleSB0byBlYWNoIHJlbGVhc2UuIEV4YW1wbGUg" + - "Zm9yIGNhc3NhbmRyYSBpbiBgaGVsbWZpbGUuZC8wMS1kZXBlbmRlbmNpZXMueWFtbC5nb3RtcGxg" + - "OgoKYGBgeWFtbAotIG5hbWU6IGNhc3NhbmRyYQogIHZlcnNpb246IDAuOC4wCiAgY29uZGl0aW9u" + - "OiBjYXNzYW5kcmEuZW5hYmxlZAogIG5hbWVzcGFjZTogY2Fzc2FuZHJhLXN5c3RlbQogIDw8OiAq" + - "ZGVwZW5kZW5jeQogIHZhbHVlczoKICAgIC0gLi4vZ2xvYmFsLnlhbWwuZ290bXBsCiAgICAtIC4u" + - "Lzxwcml2YXRlLXZhbHVlcz4ve3sgcmVxdWlyZWRFbnYgIkhFTE1GSUxFX0VOViIgfX0tc2VjcmV0" + - "cy55YW1sCiAgICAtIGNhc3NhbmRyYToKICAgICAgICBnbG9iYWw6CiAgICAgICAgICBpbWFnZVB1" + - "bGxTZWNyZXRzOgogICAgICAgICAgICAtIG52Y3ItY3JlZHMKYGBgCgpTZWUgW3JlZmVyZW5jZXMv" + - "cHVsbC1zZWNyZXRzLm1kXShyZWZlcmVuY2VzL3B1bGwtc2VjcmV0cy5tZCkgZm9yIHRoZSBrZXkg" + - "Zm9yIGV2ZXJ5IGNoYXJ0LgoKVGhlc2UgYXJlIGNvbnRyb2wtcGxhbmUgbmFtZXNwYWNlcy4gRm9y" + - "IGEgc2VwYXJhdGUgY29tcHV0ZSBjbHVzdGVyLCBjcmVhdGUgdGhlCnNlY3JldCBvbmx5IGluIGBu" + - "dmNhLW9wZXJhdG9yYDsgdGhlIGNoYXJ0IGFuZCBvcGVyYXRvciBtaXJyb3IgaXQgdG8KYG52Y2Et" + - "c3lzdGVtYC4gU2VlIFtTcGxpdCBDb21wdXRlLVBsYW5lIEluc3RhbGxhdGlvbl0ocmVmZXJlbmNl" + - "cy9jb21wdXRlLXBsYW5lLWluc3RhbGxhdGlvbi5tZCNwdWxsLXNlY3JldHMpLgoKIyMjIFN0ZXAg" + - "NTogRGVwbG95CgpgYGBiYXNoCkhFTE1GSUxFX0VOVj08ZW52PiBoZWxtZmlsZSAtLWt1YmUtY29u" + - "dGV4dCA8Y29udHJvbC1wbGFuZS1jb250ZXh0PiBzeW5jCmBgYAoKIyMjIFN0ZXAgNjogUGF0Y2gg" + - "U2VydmljZUFjY291bnRzIGZvciBjaGFydHMgd2l0aG91dCBuYXRpdmUgc3VwcG9ydAoKQWZ0ZXIg" + - "UGhhc2UgMSAoZGVwZW5kZW5jaWVzKSBjb21wbGV0ZXMsIE9wZW5CYW8gcG9kcyB3aWxsIGJlIGlu" + - "IGBJbWFnZVB1bGxCYWNrT2ZmYC4gUGF0Y2ggYW5kIHJlc3RhcnQ6CgpgYGBiYXNoCmZvciBucyBp" + - "biB2YXVsdC1zeXN0ZW0gbnZjZiBlc3M7IGRvCiAgZm9yIHNhIGluICQoa3ViZWN0bCAtLWNvbnRl" + - "eHQgPGNvbnRyb2wtcGxhbmUtY29udGV4dD4gZ2V0IHNhIC1uICIkbnMiIFwKICAgIC0tbm8taGVh" + - "ZGVycyAtbyBjdXN0b20tY29sdW1ucz0iOm1ldGFkYXRhLm5hbWUiKTsgZG8KICAgIGt1YmVjdGwg" + - "LS1jb250ZXh0IDxjb250cm9sLXBsYW5lLWNvbnRleHQ+IHBhdGNoIHNlcnZpY2VhY2NvdW50IC1u" + - "ICIkbnMiICIkc2EiIFwKICAgICAgLXAgJ3siaW1hZ2VQdWxsU2VjcmV0cyI6IFt7Im5hbWUiOiAi" + - "bnZjci1jcmVkcyJ9XX0nCiAgZG9uZQpkb25lCmt1YmVjdGwgLS1jb250ZXh0IDxjb250cm9sLXBs" + - "YW5lLWNvbnRleHQ+IGRlbGV0ZSBwb2RzIC1uIHZhdWx0LXN5c3RlbSAtLWFsbApgYGAKClZlcmlm" + - "eToKCmBgYGJhc2gKa3ViZWN0bCAtLWNvbnRleHQgPGNvbnRyb2wtcGxhbmUtY29udGV4dD4gZ2V0" + - "IGV2ZW50cyAtbiB2YXVsdC1zeXN0ZW0gXAogIC0tc29ydC1ieT0nLmxhc3RUaW1lc3RhbXAnIHwg" + - "Z3JlcCAtaSBwdWxsCiMgU2hvdWxkIHNob3cgIlN1Y2Nlc3NmdWxseSBwdWxsZWQgaW1hZ2UiIGZy" + - "b20gbnZjci5pbwpgYGAKCi0tLQoKIyMgRXhhbXBsZSAzOiBGdWxsIFRlYXJkb3duIGFuZCBSZWlu" + - "c3RhbGwKCldoZW4gYSBkZXBsb3ltZW50IGlzIGJyb2tlbiBhbmQgeW91IG5lZWQgYSBjbGVhbiBz" + - "bGF0ZS4KCiMjIyBTdGVwIDE6IERlc3Ryb3kgdGhlIGNvbXB1dGUtcGxhbmUgc3RhY2sKCmBgYGJh" + - "c2gKbWFrZSAtQyBkZXBsb3kvc3RhY2tzL252Y2YtY29tcHV0ZS1wbGFuZSBkZXN0cm95IFwKICBD" + - "TFVTVEVSX05BTUU9PGNsdXN0ZXItbmFtZT4gXAogIEhFTE1GSUxFX0VOVj08ZW52PiBcCiAgS1VC" + - "RUNPTkZJR19GSUxFPTxjb21wdXRlLXBsYW5lLWt1YmVjb25maWc+CmBgYAoKSWYgY29tcHV0ZSBj" + - "bGVhbnVwIGlzIHN0dWNrIG9uIGZpbmFsaXplcnMsIHVzZSB0aGUgY29tcHV0ZS1jb250ZXh0IHBy" + - "b2NlZHVyZSBpbgpbZGVidWdnaW5nLm1kXShyZWZlcmVuY2VzL2RlYnVnZ2luZy5tZCNmYWlsdXJl" + - "LW52Y2EtY2xlYW51cC1zdHVjay1maW5hbGl6ZXJzKS4KCiMjIyBTdGVwIDI6IERlcmVnaXN0ZXIg" + - "dGhlIGNvbXB1dGUgY2x1c3RlcgoKUmVhZCBgY2x1c3RlcklEYCBhbmQgYG5jYUlEYCBmcm9tCmBk" + - "ZXBsb3kvc3RhY2tzL252Y2YtY29tcHV0ZS1wbGFuZS9yZWdpc3RyYXRpb24vPGNsdXN0ZXItbmFt" + - "ZT4tcmVnaXN0ZXItdmFsdWVzLnlhbWxgLgpTaG93IHRoZSBJRCBhbmQgZ2V0IGNvbmZpcm1hdGlv" + - "biBiZWZvcmUgZGVsZXRpbmcgdGhlIElDTVMgcm93OgoKYGBgYmFzaAo8bnZjZi1jbGk+IC0tY29u" + - "ZmlnIDxjb25maWc+IGNsdXN0ZXIgZGVsZXRlIFwKICAtLWNsdXN0ZXItaWQgPGNsdXN0ZXItaWQt" + - "ZnJvbS1yZWdpc3RyYXRpb24tdmFsdWVzPiBcCiAgLS1uY2EtaWQgPG5jYS1pZD4gXAogIC0taWdu" + - "b3JlLW1pc3NpbmcKYGBgCgpSZXBlYXQgc3RlcHMgMSBhbmQgMiBmb3IgZXZlcnkgY29tcHV0ZSBj" + - "bHVzdGVyLgoKIyMjIFN0ZXAgMzogRGVzdHJveSB0aGUgY29udHJvbC1wbGFuZSBzdGFjawoKUHJl" + - "c2VydmUgdGhlIGBjZXJ0LW1hbmFnZXJgIG5hbWVzcGFjZSBieSBkZWZhdWx0LiBOYW1lc3BhY2Ug" + - "cHJlc2VydmF0aW9uIGRvZXMKbm90IHByZXNlcnZlIHRoZSBIZWxtIHJlbGVhc2UuIEJlZm9yZSBy" + - "dW5uaW5nIGRlc3Ryb3ksIGlkZW50aWZ5IHdoZXRoZXIKY2VydC1tYW5hZ2VyIGlzIGV4dGVybmFs" + - "LiBGb3IgYW4gZXh0ZXJuYWwgaW5zdGFsbGF0aW9uLCByZXF1aXJlIGVmZmVjdGl2ZQpgY2VydE1h" + - "bmFnZXIuZW5hYmxlZDogZmFsc2VgIGFuZCBhYm9ydCBpZiBpdCBpcyB0cnVlLiBGb3IgYW4gaW50" + - "ZW5kZWQKc3RhY2stbWFuYWdlZCByZWxlYXNlIHdpdGggZWZmZWN0aXZlIGBjZXJ0TWFuYWdlci5l" + - "bmFibGVkOiB0cnVlYCwgdmVyaWZ5Cm1hdGNoaW5nIHN0YWNrIEhlbG0gcmVsZWFzZSBtZXRhZGF0" + - "YSBhbmQgYWJvcnQgb24gbWlzc2luZyBvciBtaXNtYXRjaGVkCmV2aWRlbmNlLiBPbmx5IHBsYW4g" + - "bmFtZXNwYWNlIHJlbW92YWwgYWZ0ZXIgdmVyaWZ5aW5nIG5hbWVzcGFjZSBwcm92ZW5hbmNlIGFu" + - "ZApnZXR0aW5nIGV4cGxpY2l0IGNvbmZpcm1hdGlvbjsgb3RoZXJ3aXNlIGRvIG5vdCBkZWxldGUg" + - "aXQuCgpgYGBiYXNoCktVQkVDT05GSUc9PGNvbnRyb2wtcGxhbmUta3ViZWNvbmZpZz4gXAptYWtl" + - "IC1DIGRlcGxveS9zdGFja3Mvc2VsZi1tYW5hZ2VkIGRlc3Ryb3kgXAogIEhFTE1GSUxFX0VOVj08" + - "ZW52PiBcCiAgS1VCRUNPTkZJR19GSUxFPTxjb250cm9sLXBsYW5lLWt1YmVjb25maWc+CmBgYAoK" + - "UGFzcyBib3RoIGt1YmVjb25maWcgZm9ybXMgYmVjYXVzZSBjb250cm9sLXBsYW5lIG5hbWVzcGFj" + - "ZSBjbGVhbnVwIHVzZXMKYW1iaWVudCBga3ViZWN0bGAuCgojIyMgU3RlcCA0OiBWZXJpZnkgY2xl" + - "YW4KCmBgYGJhc2gKa3ViZWN0bCAtLWNvbnRleHQgPGNvbXB1dGUtcGxhbmUtY29udGV4dD4gZ2V0" + - "IG5zIHwgXAogIGdyZXAgLUUgJyhudmNhfG52Y2YtYmFja2VuZHxncm92ZXxkeW5hbW8pJwprdWJl" + - "Y3RsIC0tY29udGV4dCA8Y29udHJvbC1wbGFuZS1jb250ZXh0PiBnZXQgbnMgfCBcCiAgZ3JlcCAt" + - "RSAnKGNhc3NhbmRyYXxuYXRzfHZhdWx0fG52Y2Z8YXBpLWtleXN8ZXNzfHNpcyknCiMgQm90aCBj" + - "b21tYW5kcyBzaG91bGQgcmV0dXJuIGVtcHR5LgpgYGAKCiMjIyBTdGVwIDU6IFJlaW5zdGFsbCBp" + - "biBzcGxpdCBvcmRlcgoKRm9sbG93IFtDbGVhbiBJbnN0YWxsYXRpb25dKFNLSUxMLm1kI2NsZWFu" + - "LWluc3RhbGxhdGlvbiksIHRoZW4gcmV0dXJuIHRvIHRoZQpzYW1lIGhhbmRvZmYgaW4gW1NwbGl0" + - "IENvbXB1dGUtUGxhbmUgSW5zdGFsbGF0aW9uXShyZWZlcmVuY2VzL2NvbXB1dGUtcGxhbmUtaW5z" + - "dGFsbGF0aW9uLm1kKS4KCi0tLQoKIyMgRXhhbXBsZSA0OiBSZWNvdmVyIGZyb20gYSBHYXRld2F5" + - "IEVuZHBvaW50IENoYW5nZQoKVGhlIHNlcGFyYXRlbHkgcHJvdmlzaW9uZWQgR2F0ZXdheSBvciBp" + - "dHMgbG9hZCBiYWxhbmNlciB3YXMgcmVjcmVhdGVkIGFuZCBnb3QgYSBuZXcgZW5kcG9pbnQuCgoj" + - "IyMgU3RlcCAxOiBHZXQgdGhlIG5ldyBlbmRwb2ludAoKYGBgYmFzaApHQVRFV0FZX0FERFI9JChr" + - "dWJlY3RsIC0tY29udGV4dCA8Y29udHJvbC1wbGFuZS1jb250ZXh0PiBnZXQgZ2F0ZXdheSBcCiAg" + - "bnZjZi1nYXRld2F5IC1uIGVudm95LWdhdGV3YXkgXAogIC1vIGpzb25wYXRoPSd7LnN0YXR1cy5h" + - "ZGRyZXNzZXNbMF0udmFsdWV9JykKdGVzdCAtbiAiJEdBVEVXQVlfQUREUiIKYGBgCgojIyMgU3Rl" + - "cCAyOiBVcGRhdGUgRE5TIGFuZCBkaXJlY3QgYWRkcmVzcyBmaWVsZHMKCktlZXAgYGdsb2JhbC5k" + - "b21haW5gLCByb3V0ZSBob3N0bmFtZXMsIGFuZCBDTEkgSG9zdCBmaWVsZHMgdW5jaGFuZ2VkLiBQ" + - "b2ludCB0aGUKRE5TIHJlY29yZHMgZm9yIHJlbmRlcmVkIHJvdXRlIGhvc3RuYW1lcywgc3VjaCBh" + - "cyBgYXBpLjxkb21haW4+YCBhbmQKYCouaW52b2NhdGlvbi48ZG9tYWluPmAsIHRvIGBHQVRFV0FZ" + - "X0FERFJgLiBGb3IgYSB0ZW1wb3JhcnkgZW52aXJvbm1lbnQgd2l0aG91dApETlMsIGtlZXAgaXRz" + - "IHJlc2VydmVkIHJvdXRlIHN1ZmZpeCBhbmQgY29ubmVjdCB0byBgR0FURVdBWV9BRERSYCB3aXRo" + - "IHRoZQptYXRjaGluZyBgSG9zdGAgaGVhZGVyLgoKRm9yIGEgc3BsaXQgZGVwbG95bWVudCBjb25m" + - "aWd1cmVkIHdpdGggZGlyZWN0IEdhdGV3YXkgYWRkcmVzc2VzLCByZXBsYWNlIG9ubHkKdGhlIGFk" + - "ZHJlc3MtYmVhcmluZyB2YWx1ZXM6IGNvbnRyb2wtcGxhbmUgYG52Y2ZOYXRzU2VydmljZVVSTGAs" + - "IGNvbXB1dGUtcGxhbmUKSUNNUywgUmVWYWwsIGFuZCBOQVRTIFVSTHMsIGFuZCBDTEkgVVJMIGZp" + - "ZWxkcy4gS2VlcCB0aGVpciBkb21haW4gYW5kIEhvc3QKb3ZlcnJpZGVzIHVuY2hhbmdlZC4gUmVm" + - "cmVzaCByZWdpc3RyYXRpb24gYW5kIGluc3RhbGxhdGlvbiB0aHJvdWdoIHRoZSBzYW1lCmhhbmRv" + - "ZmYgdXNlZCBvcmlnaW5hbGx5LiBTZWUKW1NwbGl0IENvbXB1dGUtUGxhbmUgSW5zdGFsbGF0aW9u" + - "XShyZWZlcmVuY2VzL2NvbXB1dGUtcGxhbmUtaW5zdGFsbGF0aW9uLm1kKQpmb3IgdGhlIGZpZWxk" + - "cyBhbmQgY29tcGxldGUgY29tbWFuZHMuCgojIyMgU3RlcCAzOiBWZXJpZnkgYm90aCBjb250ZXh0" + - "cwoKYGBgYmFzaApkaWcgK3Nob3J0ICJhcGkuPGRvbWFpbj4iCmN1cmwgLUggIkhvc3Q6IGFwaS48" + - "ZG9tYWluPiIgImh0dHA6Ly8kR0FURVdBWV9BRERSL2hlYWx0aCIKa3ViZWN0bCAtLWNvbnRleHQg" + - "PGNvbnRyb2wtcGxhbmUtY29udGV4dD4gZ2V0IGdhdGV3YXkgbnZjZi1nYXRld2F5IFwKICAtbiBl" + - "bnZveS1nYXRld2F5IC1vIHdpZGUKa3ViZWN0bCAtLWNvbnRleHQgPGNvbnRyb2wtcGxhbmUtY29u" + - "dGV4dD4gZ2V0IGh0dHByb3V0ZXMgLUEKa3ViZWN0bCAtLWNvbnRleHQgPGNvbnRyb2wtcGxhbmUt" + - "Y29udGV4dD4gZ2V0IHRjcHJvdXRlcyAtQQprdWJlY3RsIC0tY29udGV4dCA8Y29tcHV0ZS1wbGFu" + - "ZS1jb250ZXh0PiByb2xsb3V0IHN0YXR1cyBcCiAgZGVwbG95bWVudC9udmNhLW9wZXJhdG9yIC1u" + - "IG52Y2Etb3BlcmF0b3IgLS10aW1lb3V0PTEwbQprdWJlY3RsIC0tY29udGV4dCA8Y29tcHV0ZS1w" + - "bGFuZS1jb250ZXh0PiB3YWl0IFwKICBudmNmYmFja2VuZC88Y29tcHV0ZS1wbGFuZS1jbHVzdGVy" + - "LW5hbWU+IC1uIG52Y2Etb3BlcmF0b3IgXAogIC0tZm9yPWpzb25wYXRoPSd7LnN0YXR1cy5hZ2Vu" + - "dFN0YXR1c30nPWhlYWx0aHkgLS10aW1lb3V0PTEwbQpgYGAKCi0tLQoKIyMgRXhhbXBsZSA1OiBE" + - "ZXBsb3kgT25seSBEZXBlbmRlbmNpZXMKClVzZWZ1bCBmb3IgdGVzdGluZyBvciB3aGVuIGl0ZXJh" + - "dGluZyBvbiBzZXJ2aWNlIGNvbmZpZ3VyYXRpb24uCgpgYGBiYXNoCiMgRGVwbG95IGp1c3QgTkFU" + - "UywgQ2Fzc2FuZHJhLCBPcGVuQmFvCkhFTE1GSUxFX0VOVj08ZW52PiBoZWxtZmlsZSAtLXNlbGVj" + - "dG9yIHJlbGVhc2UtZ3JvdXA9ZGVwZW5kZW5jaWVzIHN5bmMKCiMgQ2hlY2sgc3RhdHVzCmt1YmVj" + - "dGwgZ2V0IHBvZHMgLW4gbmF0cy1zeXN0ZW0Ka3ViZWN0bCBnZXQgcG9kcyAtbiBjYXNzYW5kcmEt" + - "c3lzdGVtCmt1YmVjdGwgZ2V0IHBvZHMgLW4gdmF1bHQtc3lzdGVtCgojIERlcGxveSBqdXN0IG9u" + - "ZSBzcGVjaWZpYyByZWxlYXNlCkhFTE1GSUxFX0VOVj08ZW52PiBoZWxtZmlsZSAtLXNlbGVjdG9y" + - "IG5hbWU9Y2Fzc2FuZHJhIHN5bmMKYGBgCgojIyMgU2VsZWN0b3IgcmVmZXJlbmNlCgp8IFNlbGVj" + - "dG9yIHwgUmVsZWFzZXMgfAp8LS0tLS0tLS0tLXwtLS0tLS0tLS0tfAp8IGByZWxlYXNlLWdyb3Vw" + - "PWRlcGVuZGVuY2llc2AgfCBuYXRzLCBjYXNzYW5kcmEsIG9wZW5iYW8tc2VydmVyIHwKfCBgcmVs" + - "ZWFzZS1ncm91cD1zZXJ2aWNlc2AgfCBhcGkta2V5cywgc2lzLCBhcGksIGludm9jYXRpb24tc2Vy" + - "dmljZSwgZ3JwYy1wcm94eSwgZXNzLWFwaSwgbm90YXJ5LXNlcnZpY2UsIHJldmFsLCBvcHRpb25h" + - "bCBsbG0tcmVxdWVzdC1yb3V0ZXIgYW5kIGxsbS1hcGktZ2F0ZXdheSB3aGVuIGBsbG0uZW5hYmxl" + - "ZD10cnVlYCwgb3B0aW9uYWwgdmFuaXR5LWdhdGV3YXkgb25seSBpbiBzdGFjayBwYWNrYWdlcyB0" + - "aGF0IGluY2x1ZGUgdGhlIGFkZG9uIGFuZCBoYXZlIGBhZGRvbnMudmFuaXR5R2F0ZXdheS5lbmFi" + - "bGVkPXRydWVgLCBvcHRpb25hbCBudmNmLXVpIG9ubHkgaW4gc3RhY2sgcGFja2FnZXMgdGhhdCBp" + - "bmNsdWRlIHRoZSBhZGRvbiBhbmQgaGF2ZSBgYWRkb25zLm52Y2ZVaS5lbmFibGVkPXRydWVgIHwK" + - "fCBgbmFtZT1sbG0tcmVxdWVzdC1yb3V0ZXJgIHwgRGVwbG95IGp1c3QgdGhlIExMTSByZXF1ZXN0" + - "IHJvdXRlciB3aGVuIGBsbG0uZW5hYmxlZD10cnVlYCB8CnwgYG5hbWU9bGxtLWFwaS1nYXRld2F5" + - "YCB8IERlcGxveSBqdXN0IHRoZSBMTE0gQVBJIGdhdGV3YXkgd2hlbiBgbGxtLmVuYWJsZWQ9dHJ1" + - "ZWAgfAp8IGBuYW1lPXZhbml0eS1nYXRld2F5YCB8IERlcGxveSBqdXN0IFZhbml0eSBHYXRld2F5" + - "IG9ubHkgd2hlbiB0aGUgc3RhY2sgcGFja2FnZSBpbmNsdWRlcyB0aGF0IHJlbGVhc2UgYW5kIGBh" + - "ZGRvbnMudmFuaXR5R2F0ZXdheS5lbmFibGVkPXRydWVgIHwKfCBgbmFtZT1udmNmLXVpYCB8IERl" + - "cGxveSBOVkNGIFVJIG9ubHkgd2hlbiB0aGUgc3RhY2sgcGFja2FnZSBpbmNsdWRlcyB0aGF0IHJl" + - "bGVhc2UgYW5kIGBhZGRvbnMubnZjZlVpLmVuYWJsZWQ9dHJ1ZWAgfAp8IGByZWxlYXNlLWdyb3Vw" + - "PWluZ3Jlc3NgIHwgaW5ncmVzcyAoZ2F0ZXdheSByb3V0ZXMpIHwKfCBgbmFtZT08cmVsZWFzZT5g" + - "IHwgQW55IGluZGl2aWR1YWwgcmVsZWFzZSBieSBuYW1lIHwKCk5vdGU6IGBhZG1pbi1pc3N1ZXIt" + - "cHJveHlgIGRvZXMgbm90IGhhdmUgYSByZWxlYXNlLWdyb3VwIGxhYmVsLiBUYXJnZXQgaXQgd2l0" + - "aCBgLS1zZWxlY3RvciBuYW1lPWFkbWluLWlzc3Vlci1wcm94eWAuClBLBwgCUk5AfygAAH8oAABQ" + - "SwMEFAAIAAAAAAAhAAAAAAAAAAAAAAAAAEwACQBkYXRhL252Y2Ytc2VsZi1tYW5hZ2VkLWluc3Rh" + - "bGxhdGlvbi9yZWZlcmVuY2VzL2NvbXB1dGUtcGxhbmUtaW5zdGFsbGF0aW9uLm1kVVQFAAEAps4S" + - "IyBTcGxpdCBDb21wdXRlLVBsYW5lIEluc3RhbGxhdGlvbgoKVGhlIGNvbnRyb2wgcGxhbmUgYW5k" + - "IGNvbXB1dGUgcGxhbmUgYXJlIHNlcGFyYXRlIHN0YWNrcy4gSW5zdGFsbCB0aGUgY29udHJvbApw" + - "bGFuZSBmaXJzdCwgdGhlbiByZWdpc3RlciBhbmQgaW5zdGFsbCBlYWNoIGNvbXB1dGUgY2x1c3Rl" + - "ci4gQ2hvb3NlIG9uZSBoYW5kb2ZmCmJlbG93IGFuZCB1c2UgaXQgZm9yIHRoZSBmdWxsIGxpZmVj" + - "eWNsZS4gRG8gbm90IGNvbWJpbmUgYSBDTEktZ2VuZXJhdGVkIHByb2ZpbGUKd2l0aCB0aGUgSGVs" + - "bWZpbGUgdmFsdWVzIGZsb3cuCgojIyBDaG9vc2UgYSBIYW5kb2ZmCgp8IEZsb3cgfCBTb3VyY2Ug" + - "b2YgY29udHJvbC1wbGFuZSBlbmRwb2ludHMgfCBSZWdpc3RyYXRpb24gYXJ0aWZhY3QgfAp8LS0t" + - "LS0tfC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tfC0tLS0tLS0tLS0tLS0tLS0t" + - "LS0tLS0tfAp8IEhlbG1maWxlIHZhbHVlcyB8IFNlcGFyYXRlIGNvbnRyb2wtcGxhbmUgYW5kIGNv" + - "bXB1dGUtcGxhbmUgZW52aXJvbm1lbnQgZmlsZXMgfCBgZGVwbG95L3N0YWNrcy9udmNmLWNvbXB1" + - "dGUtcGxhbmUvcmVnaXN0cmF0aW9uLzxjbHVzdGVyPi1yZWdpc3Rlci12YWx1ZXMueWFtbGAgfAp8" + - "IENMSSBwcm9maWxlIHwgQ0xJLWdlbmVyYXRlZCBgZGVwbG95L3N0YWNrcy9zZWxmLW1hbmFnZWQv" + - "b3V0L2NvbnRyb2wtcGxhbmUtcHJvZmlsZS55YW1sYCB8IENMSS1nZW5lcmF0ZWQgYGRlcGxveS9z" + - "dGFja3MvbnZjZi1jb21wdXRlLXBsYW5lL291dC88Y2x1c3Rlcj4tcmVnaXN0ZXItdmFsdWVzLnlh" + - "bWxgIHwKClRoZSBDTEkgcHJvZmlsZSBpcyBtYW5kYXRvcnkgZm9yIHRoZSBDTEkgZmxvdyBhbmQg" + - "bXVzdCBub3QgYmUgaGFuZC1hdXRob3JlZC4KVGhlIEhlbG1maWxlIGZsb3cgZG9lcyBub3QgY29u" + - "c3VtZSBhIGNvbnRyb2wtcGxhbmUgcHJvZmlsZS4KCkNvbW1hbmRzIGJlbG93IHVzZSBtb25vcmVw" + - "byBwYXRocyBmcm9tIHRoZSByZXBvc2l0b3J5IHJvb3QuIE9wZXJhdG9ycyB1c2luZwpleHRyYWN0" + - "ZWQgcGFja2FnZXMgbmVlZCBtYXRjaGluZy12ZXJzaW9uIGBudmNmLXNlbGYtbWFuYWdlZC1zdGFj" + - "a2AgYW5kCmBudmNmLWNvbXB1dGUtcGxhbmUtc3RhY2tgIGJ1bmRsZXMuIFN1YnN0aXR1dGUgdGhv" + - "c2UgYnVuZGxlIHJvb3RzIGZvcgpgZGVwbG95L3N0YWNrcy9zZWxmLW1hbmFnZWRgIGFuZCBgZGVw" + - "bG95L3N0YWNrcy9udmNmLWNvbXB1dGUtcGxhbmVgLgoKIyMgSGVsbWZpbGUgVmFsdWVzIEZsb3cK" + - "CkNyZWF0ZSBib3RoIGVudmlyb25tZW50IGZpbGVzIGJlZm9yZSBpbnN0YWxsYXRpb246CgotIGBk" + - "ZXBsb3kvc3RhY2tzL3NlbGYtbWFuYWdlZC9lbnZpcm9ubWVudHMvPGVudj4ueWFtbGAgZm9yIGNv" + - "bnRyb2wtcGxhbmUKICByZWdpc3RyeSwgZG9tYWluLCBHYXRld2F5LCByb3V0ZXMsIGFuZCBzZXJ2" + - "aWNlIHNldHRpbmdzLgotIGBkZXBsb3kvc3RhY2tzL252Y2YtY29tcHV0ZS1wbGFuZS9lbnZpcm9u" + - "bWVudHMvPGVudj4ueWFtbGAgZm9yIGNvbXB1dGUtcGxhbmUKICByZWdpc3RyeSwgcHVsbCBzZWNy" + - "ZXRzLCBhbmQgY29tcHV0ZS1yZWFjaGFibGUgSUNNUywgUmVWYWwsIGFuZCBOQVRTIHZhbHVlcy4K" + - "CkZvciBFS1MsIHVzZSB0aGUgY2Fub25pY2FsCltDU1AgRW5kLXRvLUVuZCBFeGFtcGxlXShodHRw" + - "czovL2RvY3MubnZpZGlhLmNvbS9udmNmL3YwLjYuMC1yYy9jc3AtZW5kLXRvLWVuZC1leGFtcGxl" + - "KS4KVGhlIGNvbnRyb2wtcGxhbmUgZW52aXJvbm1lbnQga2VlcHMgdGhlIEVudm95IEdhdGV3YXkg" + - "Y29udHJvbGxlciBpbgpgZW52b3ktZ2F0ZXdheS1zeXN0ZW1gLCBhdHRhY2hlcyByb3V0ZXMgdG8g" + - "YEdhdGV3YXkvbnZjZi1nYXRld2F5YCBpbgpgZW52b3ktZ2F0ZXdheWAsIGFuZCBlbmFibGVzIHRo" + - "ZSBOQVRTIHJvdXRlLiBUaGUgY29tcHV0ZS1wbGFuZSBlbnZpcm9ubWVudCB1c2VzCnRoZSBleHRl" + - "cm5hbCBhZGRyZXNzIHBsdXMgdGhlIHNlcnZpY2UgaG9zdCBvdmVycmlkZXMuIEhlcmUsCmA8Z2F0" + - "ZXdheS1hZGRyZXNzPmAgaXMgdGhlIE5MQiBhZGRyZXNzIGFuZCBgPGdhdGV3YXktZG9tYWluPmAg" + - "aXMgdGhlIEROUyBiYXNlCndob3NlIHNlcnZpY2Ugc3ViZG9tYWlucyByZXNvbHZlIHRvIHRoYXQg" + - "TkxCOgoKYGBgeWFtbAojIGRlcGxveS9zdGFja3Mvc2VsZi1tYW5hZ2VkL2Vudmlyb25tZW50cy88" + - "ZW52Pi55YW1sCmdsb2JhbDoKICBkb21haW46ICI8Z2F0ZXdheS1kb21haW4+IgogIHdvcmtlckVu" + - "ZHBvaW50czoKICAgIG52Y2ZTZXJ2aWNlVVJMOiAiaHR0cDovL2FwaS48Z2F0ZXdheS1kb21haW4+" + - "IgogICAgbnZjZkdycGNTZXJ2aWNlVVJMOiAiaHR0cDovL3dvcmtlci1hcGkuPGdhdGV3YXktZG9t" + - "YWluPiIKICAgIG52Y2ZOYXRzU2VydmljZVVSTDogIm5hdHM6Ly88Z2F0ZXdheS1hZGRyZXNzPjo0" + - "MjIyIgogICAgbnZjdFNlcnZpY2VVUkw6ICJodHRwOi8vdGFza3MuPGdhdGV3YXktZG9tYWluPiIK" + - "ICAgIG52Y3RHcnBjU2VydmljZVVSTDogImh0dHA6Ly93b3JrZXItdGFza3MuPGdhdGV3YXktZG9t" + - "YWluPiIKICAgIGludm9jYXRpb25TZXJ2aWNlVVJMOiAiaHR0cDovL2ludm9jYXRpb24uPGdhdGV3" + - "YXktZG9tYWluPiIKCmdycGNwcm94eToKICBudmNmR3JwY1NlcnZpY2VVUkw6ICJodHRwOi8vYXBp" + - "Lm52Y2Yuc3ZjLmNsdXN0ZXIubG9jYWw6OTA5MCIKCmluZ3Jlc3M6CiAgZ2F0ZXdheUFwaToKICAg" + - "IGNvbnRyb2xsZXJOYW1lc3BhY2U6IGVudm95LWdhdGV3YXktc3lzdGVtCiAgICBnYXRld2F5czoK" + - "ICAgICAgc2hhcmVkOiB7bmFtZTogbnZjZi1nYXRld2F5LCBuYW1lc3BhY2U6IGVudm95LWdhdGV3" + - "YXl9CiAgICAgIGdycGM6IHtuYW1lOiBudmNmLWdhdGV3YXksIG5hbWVzcGFjZTogZW52b3ktZ2F0" + - "ZXdheX0KICAgICAgbmF0czoKICAgICAgICBuYW1lOiBudmNmLWdhdGV3YXkKICAgICAgICBuYW1l" + - "c3BhY2U6IGVudm95LWdhdGV3YXkKICAgICAgICBsaXN0ZW5lck5hbWU6IG5hdHMKICAgIHJvdXRl" + - "czoKICAgICAgbnZjZkFwaToKICAgICAgICBncnBjOgogICAgICAgICAgZW5hYmxlZDogdHJ1ZQog" + - "ICAgICAgICAgaG9zdG5hbWVzOiBbIndvcmtlci1hcGkuPGdhdGV3YXktZG9tYWluPiJdCiAgICAg" + - "IG52Y3RBcGk6CiAgICAgICAgZ3JwYzoKICAgICAgICAgIGVuYWJsZWQ6IHRydWUKICAgICAgICAg" + - "IGhvc3RuYW1lczogWyJ3b3JrZXItdGFza3MuPGdhdGV3YXktZG9tYWluPiJdCiAgICAgIG5hdHM6" + - "CiAgICAgICAgZW5hYmxlZDogdHJ1ZQoKb3BlbmJhbzoKICBtaWdyYXRpb25zOgogICAgaXNzdWVy" + - "RGlzY292ZXJ5OgogICAgICBlbmFibGVkOiB0cnVlCmBgYAoKYGBgeWFtbAojIGRlcGxveS9zdGFj" + - "a3MvbnZjZi1jb21wdXRlLXBsYW5lL2Vudmlyb25tZW50cy88ZW52Pi55YW1sCmdsb2JhbDoKICBu" + - "dmNhT3BlcmF0b3I6CiAgICBzZWxmTWFuYWdlZDoKICAgICAgaWNtc1NlcnZpY2VVUkw6ICJodHRw" + - "Oi8vPGdhdGV3YXktYWRkcmVzcz4iCiAgICAgIGljbXNTZXJ2aWNlSG9zdEhlYWRlck92ZXJyaWRl" + - "OiAic2lzLjxnYXRld2F5LWRvbWFpbj4iCiAgICAgIHJldmFsU2VydmljZVVSTDogImh0dHA6Ly88" + - "Z2F0ZXdheS1hZGRyZXNzPiIKICAgICAgcmV2YWxTZXJ2aWNlSG9zdEhlYWRlck92ZXJyaWRlOiAi" + - "cmV2YWwuPGdhdGV3YXktZG9tYWluPiIKICAgICAgbmF0c1VSTDogIm5hdHM6Ly88Z2F0ZXdheS1h" + - "ZGRyZXNzPjo0MjIyIgogICAgICBuYXRzSG9zdE92ZXJyaWRlOiAibmF0cy48Z2F0ZXdheS1kb21h" + - "aW4+IgpgYGAKClByZXZpZXcgYW5kIGluc3RhbGwgdGhlIGNvbnRyb2wgcGxhbmUgYWdhaW5zdCBp" + - "dHMgY29udGV4dDoKCmBgYGJhc2gKbWFrZSAtQyBkZXBsb3kvc3RhY2tzL3NlbGYtbWFuYWdlZCB0" + - "ZW1wbGF0ZSBcCiAgSEVMTUZJTEVfRU5WPTxlbnY+IFwKICBLVUJFQ09ORklHX0ZJTEU9PGNvbnRy" + - "b2wtcGxhbmUta3ViZWNvbmZpZz4KCm1ha2UgLUMgZGVwbG95L3N0YWNrcy9zZWxmLW1hbmFnZWQg" + - "aW5zdGFsbCBcCiAgSEVMTUZJTEVfRU5WPTxlbnY+IFwKICBLVUJFQ09ORklHX0ZJTEU9PGNvbnRy" + - "b2wtcGxhbmUta3ViZWNvbmZpZz4KYGBgCgpCZWZvcmUgcmVnaXN0ZXJpbmcgdGhyb3VnaCBhIGJh" + - "cmUgR2F0ZXdheSBhZGRyZXNzLCBjcmVhdGUgb3IgdXBkYXRlIHRoZSBDTEkKY29uZmlnIHBhc3Nl" + - "ZCBhcyBgTlZDRl9DTElfQ09ORklHYDoKCmBgYHlhbWwKYmFzZV9odHRwX3VybDogImh0dHA6Ly88" + - "Z2F0ZXdheS1hZGRyZXNzPiIKaW52b2tlX3VybDogImh0dHA6Ly88Z2F0ZXdheS1hZGRyZXNzPiIK" + - "YmFzZV9ncnBjX3VybDogIjxnYXRld2F5LWFkZHJlc3M+OjEwMDgxIgphcGlfa2V5c19zZXJ2aWNl" + - "X3VybDogImh0dHA6Ly88Z2F0ZXdheS1hZGRyZXNzPiIKaWNtc191cmw6ICJodHRwOi8vPGdhdGV3" + - "YXktYWRkcmVzcz4iCmFwaV9ob3N0OiAiYXBpLjxnYXRld2F5LWRvbWFpbj4iCmFwaV9rZXlzX2hv" + - "c3Q6ICJhcGkta2V5cy48Z2F0ZXdheS1kb21haW4+IgppbnZva2VfaG9zdDogImludm9jYXRpb24u" + - "PGdhdGV3YXktZG9tYWluPiIKaWNtc19ob3N0OiAic2lzLjxnYXRld2F5LWRvbWFpbj4iCmBgYAoK" + - "SG9zdCBmaWVsZHMgY29udGFpbiBob3N0bmFtZXMgb25seSwgd2l0aG91dCBhIFVSTCBzY2hlbWUu" + - "IGBJQ01TX1VSTGAgbWFwcyBvbmx5CnRvIHRoZSByZWdpc3RyYXRpb24gY29tbWFuZCdzIGAtLWlj" + - "bXMtdXJsYDsgYGljbXNfaG9zdGAgaW4gdGhlIGNvbmZpZyBzdXBwbGllcwp0aGUgR2F0ZXdheSBI" + - "b3N0IGhlYWRlci4gVGhlcmUgaXMgbm8gYC0taWNtcy1ob3N0YCBNYWtlIG9yIENMSSBmbGFnLgoK" + - "UmVnaXN0ZXIgZnJvbSB0aGUgY29tcHV0ZSBjb250ZXh0LCB0aGVuIGluc3RhbGwgdGhlIGNvbXB1" + - "dGUgcGxhbmU6CgpgYGBiYXNoCm1ha2UgLUMgZGVwbG95L3N0YWNrcy9udmNmLWNvbXB1dGUtcGxh" + - "bmUgcmVnaXN0ZXItY2x1c3RlciBcCiAgQ0xVU1RFUl9OQU1FPTxjbHVzdGVyLW5hbWU+IFwKICBO" + - "Q0FfSUQ9PG5jYS1pZD4gXAogIENMVVNURVJfUkVHSU9OPTxyZWdpb24+IFwKICBJQ01TX1VSTD1o" + - "dHRwOi8vPGdhdGV3YXktYWRkcmVzcz4gXAogIEtVQkVDT05GSUdfRklMRT08Y29tcHV0ZS1wbGFu" + - "ZS1rdWJlY29uZmlnPiBcCiAgTlZDRl9DTEk9PHBhdGgtdG8tbnZjZi1jbGk+IFwKICBOVkNGX0NM" + - "SV9DT05GSUc9PHBhdGgtdG8tbnZjZi1jbGktY29uZmlnPgoKbWFrZSAtQyBkZXBsb3kvc3RhY2tz" + - "L252Y2YtY29tcHV0ZS1wbGFuZSBpbnN0YWxsIFwKICBDTFVTVEVSX05BTUU9PGNsdXN0ZXItbmFt" + - "ZT4gXAogIEhFTE1GSUxFX0VOVj08ZW52PiBcCiAgS1VCRUNPTkZJR19GSUxFPTxjb21wdXRlLXBs" + - "YW5lLWt1YmVjb25maWc+CmBgYAoKUmVnaXN0cmF0aW9uIGRpc2NvdmVycyB0aGUgT0lEQyBpc3N1" + - "ZXIgYW5kIEpXS1MgZnJvbSB0aGUgY29tcHV0ZSBrdWJlIGNvbnRleHQuCkluIGEgbXVsdGktY2x1" + - "c3RlciBkZXBsb3ltZW50LCBgS1VCRUNPTkZJR19GSUxFYCBpcyByZXF1aXJlZCBvbiBib3RoCmNv" + - "bXB1dGUtcGxhbmUgY29tbWFuZHMuIEluIGEgc2FtZS1jbHVzdGVyIGRlcGxveW1lbnQgaXQgbWF5" + - "IGJlIG9taXR0ZWQgb25seQp3aGVuIHRoZSBhbWJpZW50IGNvbnRleHQgaXMgYWxyZWFkeSB0aGUg" + - "dGFyZ2V0IGNsdXN0ZXIuCgojIyBDTEkgUHJvZmlsZSBGbG93CgpSdW4gdGhlIENMSSBjb250cm9s" + - "LXBsYW5lIGluc3RhbGwgZmlyc3QuIEl0IGNyZWF0ZXMgdGhlIHByb2ZpbGUgY29uc3VtZWQgYnkK" + - "Y29tcHV0ZS1wbGFuZSByZWdpc3RyYXRpb246CgpgYGBiYXNoCm52Y2YtY2xpIC0tY29uZmlnIDxj" + - "b25maWc+IHNlbGYtaG9zdGVkIFwKICAtLWNvbnRyb2wtcGxhbmUtc3RhY2sgZGVwbG95L3N0YWNr" + - "cy9zZWxmLW1hbmFnZWQgXAogIC0tY29tcHV0ZS1wbGFuZS1zdGFjayBkZXBsb3kvc3RhY2tzL252" + - "Y2YtY29tcHV0ZS1wbGFuZSBcCiAgLS1lbnYgPGVudj4gXAogIC0tcGxhaW4gXAogIC0tY29udHJv" + - "bC1wbGFuZS1jb250ZXh0IDxjb250cm9sLXBsYW5lLWNvbnRleHQ+IFwKICAtLWNvbXB1dGUtcGxh" + - "bmUtY29udGV4dCA8Y29tcHV0ZS1wbGFuZS1jb250ZXh0PiBcCiAgaW5zdGFsbCAtLWNvbnRyb2wt" + - "cGxhbmUgXAogIC0tY2x1c3Rlci1uYW1lIDxjb250cm9sLXBsYW5lLWNsdXN0ZXItbmFtZT4gXAog" + - "IC0tcmVnaW9uIDxyZWdpb24+IFwKICAtLW5jYS1pZCA8bmNhLWlkPgoKdGVzdCAtcyBkZXBsb3kv" + - "c3RhY2tzL3NlbGYtbWFuYWdlZC9vdXQvY29udHJvbC1wbGFuZS1wcm9maWxlLnlhbWwKYGBgCgpV" + - "c2UgdGhlIGZ1bGwgcGVyc2lzdGVudCBwcmVmaXggZm9yIGJvdGggY29tcHV0ZS1wbGFuZSBjb21t" + - "YW5kczoKCmBgYGJhc2gKbnZjZi1jbGkgLS1jb25maWcgPGNvbmZpZz4gc2VsZi1ob3N0ZWQgXAog" + - "IC0tY29udHJvbC1wbGFuZS1zdGFjayBkZXBsb3kvc3RhY2tzL3NlbGYtbWFuYWdlZCBcCiAgLS1j" + - "b21wdXRlLXBsYW5lLXN0YWNrIGRlcGxveS9zdGFja3MvbnZjZi1jb21wdXRlLXBsYW5lIFwKICAt" + - "LWVudiA8ZW52PiBcCiAgLS1wbGFpbiBcCiAgY29tcHV0ZS1wbGFuZSByZWdpc3RlciBcCiAgLS1j" + - "b250cm9sLXBsYW5lLXByb2ZpbGUgZGVwbG95L3N0YWNrcy9zZWxmLW1hbmFnZWQvb3V0L2NvbnRy" + - "b2wtcGxhbmUtcHJvZmlsZS55YW1sIFwKICAtLWNsdXN0ZXItbmFtZSA8Y29tcHV0ZS1wbGFuZS1j" + - "bHVzdGVyLW5hbWU+IFwKICAtLWt1YmUtY29udGV4dCA8Y29tcHV0ZS1wbGFuZS1jb250ZXh0PiBc" + - "CiAgLS1yZWdpb24gPHJlZ2lvbj4gXAogIC0tb3V0cHV0IGRlcGxveS9zdGFja3MvbnZjZi1jb21w" + - "dXRlLXBsYW5lL291dC88Y29tcHV0ZS1wbGFuZS1jbHVzdGVyLW5hbWU+LXJlZ2lzdGVyLXZhbHVl" + - "cy55YW1sCgpudmNmLWNsaSAtLWNvbmZpZyA8Y29uZmlnPiBzZWxmLWhvc3RlZCBcCiAgLS1jb250" + - "cm9sLXBsYW5lLXN0YWNrIGRlcGxveS9zdGFja3Mvc2VsZi1tYW5hZ2VkIFwKICAtLWNvbXB1dGUt" + - "cGxhbmUtc3RhY2sgZGVwbG95L3N0YWNrcy9udmNmLWNvbXB1dGUtcGxhbmUgXAogIC0tZW52IDxl" + - "bnY+IFwKICAtLXBsYWluIFwKICBjb21wdXRlLXBsYW5lIGluc3RhbGwgXAogIC0tdmFsdWVzIGRl" + - "cGxveS9zdGFja3MvbnZjZi1jb21wdXRlLXBsYW5lL291dC88Y29tcHV0ZS1wbGFuZS1jbHVzdGVy" + - "LW5hbWU+LXJlZ2lzdGVyLXZhbHVlcy55YW1sIFwKICAtLWt1YmUtY29udGV4dCA8Y29tcHV0ZS1w" + - "bGFuZS1jb250ZXh0PiBcCiAgLS1jbHVzdGVyLW5hbWUgPGNvbXB1dGUtcGxhbmUtY2x1c3Rlci1u" + - "YW1lPgpgYGAKClJlZ2lzdHJhdGlvbiBzZWxlY3RzIHRoZSBwcm9maWxlJ3MgaW4tY2x1c3RlciBv" + - "ciBjb21wdXRlLXJlYWNoYWJsZSBlbmRwb2ludHMKZnJvbSB0aGUgY29tcHV0ZSBjb250ZXh0IGFu" + - "ZCBwcm9iZXMgaXRzIEpXS1MuIERvIG5vdCByZXBsYWNlIHByb2ZpbGUgZW5kcG9pbnRzCndpdGgg" + - "aGFuZC1hdXRob3JlZCBIZWxtZmlsZSBlbmRwb2ludCB2YWx1ZXMuCgojIyBQdWxsIFNlY3JldHMK" + - "CkNyZWF0ZSB0aGUgY29udHJvbC1wbGFuZSBzZWNyZXQgaW4gdGhlc2UgbmFtZXNwYWNlcyBvbiB0" + - "aGUgY29udHJvbC1wbGFuZQpjb250ZXh0OgoKYGBgdGV4dApjYXNzYW5kcmEtc3lzdGVtIG5hdHMt" + - "c3lzdGVtIG52Y2YgYXBpLWtleXMgZXNzIHNpcyB2YXVsdC1zeXN0ZW0gY2VydC1tYW5hZ2VyCmBg" + - "YAoKT24gdGhlIGNvbXB1dGUgY29udGV4dCwgY3JlYXRlIHRoZSBzZWNyZXQgb25seSBpbiBgbnZj" + - "YS1vcGVyYXRvcmAgYW5kIHJlZmVyZW5jZQppdCB0aHJvdWdoIGBnbG9iYWwuaW1hZ2VQdWxsU2Vj" + - "cmV0c2AgaW4gdGhlIGNvbXB1dGUtcGxhbmUgZW52aXJvbm1lbnQuIFRoZSBjaGFydAphbmQgb3Bl" + - "cmF0b3IgdXNlIGl0IGluIGBudmNhLW9wZXJhdG9yYCBhbmQgbWlycm9yIGl0IHRvIGBudmNhLXN5" + - "c3RlbWAuIERvIG5vdCBhZGQKZWl0aGVyIG5hbWVzcGFjZSB0byB0aGUgY29udHJvbC1wbGFuZSBs" + - "aXN0LiBGb3IgY29tbWFuZHMgYW5kIHBvbGljeSBleGFtcGxlcywKc2VlIFtwdWxsLXNlY3JldHMu" + - "bWRdKHB1bGwtc2VjcmV0cy5tZCkuCgojIyBWZXJpZmljYXRpb24KClVzZSB0aGUgZXhwbGljaXQg" + - "R2F0ZXdheSBuYW1lIGFuZCBuYW1lc3BhY2U6CgpgYGBiYXNoCmt1YmVjdGwgLS1jb250ZXh0IDxj" + - "b250cm9sLXBsYW5lLWNvbnRleHQ+IGdldCBnYXRld2F5IG52Y2YtZ2F0ZXdheSBcCiAgLW4gZW52" + - "b3ktZ2F0ZXdheSAtbyB3aWRlCmt1YmVjdGwgLS1jb250ZXh0IDxjb250cm9sLXBsYW5lLWNvbnRl" + - "eHQ+IGdldCB0Y3Byb3V0ZSAtbiBlbnZveS1nYXRld2F5Cmt1YmVjdGwgLS1jb250ZXh0IDxjb21w" + - "dXRlLXBsYW5lLWNvbnRleHQ+IHJvbGxvdXQgc3RhdHVzIFwKICBkZXBsb3ltZW50L252Y2Etb3Bl" + - "cmF0b3IgLW4gbnZjYS1vcGVyYXRvciAtLXRpbWVvdXQ9MTBtCmt1YmVjdGwgLS1jb250ZXh0IDxj" + - "b21wdXRlLXBsYW5lLWNvbnRleHQ+IHdhaXQgXAogIG52Y2ZiYWNrZW5kLzxjb21wdXRlLXBsYW5l" + - "LWNsdXN0ZXItbmFtZT4gLW4gbnZjYS1vcGVyYXRvciBcCiAgLS1mb3I9anNvbnBhdGg9J3suc3Rh" + - "dHVzLmFnZW50U3RhdHVzfSc9aGVhbHRoeSAtLXRpbWVvdXQ9MTBtCmt1YmVjdGwgLS1jb250ZXh0" + - "IDxjb21wdXRlLXBsYW5lLWNvbnRleHQ+IGdldCBzZWNyZXQgPHB1bGwtc2VjcmV0PiAtbiBudmNh" + - "LXN5c3RlbQpgYGAKCiMjIFRlYXJkb3duCgpEZXN0cm95IGFuZCBkZXJlZ2lzdGVyIGV2ZXJ5IGNv" + - "bXB1dGUgcGxhbmUgYmVmb3JlIHRoZSBjb250cm9sIHBsYW5lLiBCb3RoCmhhbmRvZmZzIGNhbiBk" + - "ZXN0cm95IHRoZSBjb250cm9sIHBsYW5lLCBzbyBhcHBseSB0aGlzIHByZWZsaWdodCBiZWZvcmUg" + - "ZWl0aGVyCm9uZS4gUHJlc2VydmUgdGhlIGBjZXJ0LW1hbmFnZXJgIG5hbWVzcGFjZSBieSBkZWZh" + - "dWx0LiBOYW1lc3BhY2UgcHJlc2VydmF0aW9uCmRvZXMgbm90IHByZXNlcnZlIHRoZSBIZWxtIHJl" + - "bGVhc2UuIElkZW50aWZ5IHdoZXRoZXIgY2VydC1tYW5hZ2VyIGlzIGV4dGVybmFsLgpGb3IgYW4g" + - "ZXh0ZXJuYWwgaW5zdGFsbGF0aW9uLCByZXF1aXJlIGVmZmVjdGl2ZSBgY2VydE1hbmFnZXIuZW5h" + - "YmxlZDogZmFsc2VgCmFuZCBhYm9ydCBpZiBpdCBpcyB0cnVlLiBGb3IgYW4gaW50ZW5kZWQgc3Rh" + - "Y2stbWFuYWdlZCByZWxlYXNlIHdpdGggZWZmZWN0aXZlCmBjZXJ0TWFuYWdlci5lbmFibGVkOiB0" + - "cnVlYCwgdmVyaWZ5IG1hdGNoaW5nIHN0YWNrIEhlbG0gcmVsZWFzZSBtZXRhZGF0YSBhbmQKYWJv" + - "cnQgb24gbWlzc2luZyBvciBtaXNtYXRjaGVkIGV2aWRlbmNlLiBPbmx5IHBsYW4gbmFtZXNwYWNl" + - "IHJlbW92YWwgYWZ0ZXIKdmVyaWZ5aW5nIG5hbWVzcGFjZSBwcm92ZW5hbmNlIGFuZCBnZXR0aW5n" + - "IGV4cGxpY2l0IGNvbmZpcm1hdGlvbjsgb3RoZXJ3aXNlCmRvIG5vdCBkZWxldGUgaXQuCgpGb3Ig" + - "dGhlIEhlbG1maWxlIHZhbHVlcyBmbG93LCByZXRhaW4gZWFjaCByZWdpc3RyYXRpb24gdmFsdWVz" + - "IGZpbGUgdW50aWwKY2xlYW51cCBpcyB2ZXJpZmllZDoKCmBgYGJhc2gKbWFrZSAtQyBkZXBsb3kv" + - "c3RhY2tzL252Y2YtY29tcHV0ZS1wbGFuZSBkZXN0cm95IFwKICBDTFVTVEVSX05BTUU9PGNsdXN0" + - "ZXItbmFtZT4gXAogIEhFTE1GSUxFX0VOVj08ZW52PiBcCiAgS1VCRUNPTkZJR19GSUxFPTxjb21w" + - "dXRlLXBsYW5lLWt1YmVjb25maWc+Cgo8bnZjZi1jbGk+IC0tY29uZmlnIDxjb25maWc+IGNsdXN0" + - "ZXIgZGVsZXRlIFwKICAtLWNsdXN0ZXItaWQgPGNsdXN0ZXItaWQtZnJvbS1yZWdpc3RyYXRpb24t" + - "dmFsdWVzPiBcCiAgLS1uY2EtaWQgPG5jYS1pZD4gXAogIC0taWdub3JlLW1pc3NpbmcKYGBgCgpS" + - "ZWFkIGBjbHVzdGVySURgIGFuZCBgbmNhSURgIGZyb20KYGRlcGxveS9zdGFja3MvbnZjZi1jb21w" + - "dXRlLXBsYW5lL3JlZ2lzdHJhdGlvbi88Y2x1c3Rlci1uYW1lPi1yZWdpc3Rlci12YWx1ZXMueWFt" + - "bGAuClNob3cgdGhlIGV4YWN0IGNsdXN0ZXIgSUQgYW5kIGdldCBjb25maXJtYXRpb24gYmVmb3Jl" + - "IGBjbHVzdGVyIGRlbGV0ZWAuIFJlcGVhdApjb21wdXRlIGRlc3Ryb3kgYW5kIGRlcmVnaXN0cmF0" + - "aW9uIGZvciBldmVyeSBjb21wdXRlIGNsdXN0ZXIsIHRoZW4gZGVzdHJveSB0aGUKY29udHJvbCBw" + - "bGFuZS4KCmBgYGJhc2gKS1VCRUNPTkZJRz08Y29udHJvbC1wbGFuZS1rdWJlY29uZmlnPiBcCm1h" + - "a2UgLUMgZGVwbG95L3N0YWNrcy9zZWxmLW1hbmFnZWQgZGVzdHJveSBcCiAgSEVMTUZJTEVfRU5W" + - "PTxlbnY+IFwKICBLVUJFQ09ORklHX0ZJTEU9PGNvbnRyb2wtcGxhbmUta3ViZWNvbmZpZz4KYGBg" + - "CgpCb3RoIGBLVUJFQ09ORklHYCBhbmQgYEtVQkVDT05GSUdfRklMRWAgYXJlIHJlcXVpcmVkIG9u" + - "IHRoZSBjb250cm9sLXBsYW5lCmRlc3Ryb3kgYmVjYXVzZSBpdHMgbmFtZXNwYWNlIGNsZWFudXAg" + - "dXNlcyBhbWJpZW50IGBrdWJlY3RsYC4KCkZvciB0aGUgQ0xJIHByb2ZpbGUgZmxvdywga2VlcApg" + - "ZGVwbG95L3N0YWNrcy9udmNmLWNvbXB1dGUtcGxhbmUvb3V0LzxjbHVzdGVyLW5hbWU+LXJlZ2lz" + - "dGVyLXZhbHVlcy55YW1sYAp1bnRpbCB0ZWFyZG93biBjb21wbGV0ZXMgYmVjYXVzZSBgZG93bmAg" + - "cmVhZHMgaXRzIGNsdXN0ZXIgSUQuIEZpcnN0IHF1ZXJ5IHRoZQpsaXZlIHJlZ2lzdHJhdGlvbiBz" + - "ZXQgd2l0aCB0aGUgc2FtZSBjb21wbGV0ZSBwZXJzaXN0ZW50IHByZWZpeDoKCmBgYGJhc2gKbnZj" + - "Zi1jbGkgLS1jb25maWcgPGNvbmZpZz4gc2VsZi1ob3N0ZWQgXAogIC0tY29udHJvbC1wbGFuZS1z" + - "dGFjayBkZXBsb3kvc3RhY2tzL3NlbGYtbWFuYWdlZCBcCiAgLS1jb21wdXRlLXBsYW5lLXN0YWNr" + - "IGRlcGxveS9zdGFja3MvbnZjZi1jb21wdXRlLXBsYW5lIFwKICAtLWVudiA8ZW52PiBcCiAgLS1w" + - "bGFpbiBcCiAgLS1jb250cm9sLXBsYW5lLWNvbnRleHQgPGNvbnRyb2wtcGxhbmUtY29udGV4dD4g" + - "XAogIC0tY29tcHV0ZS1wbGFuZS1jb250ZXh0IDxjb21wdXRlLXBsYW5lLWNvbnRleHQ+IFwKICAt" + - "LWljbXMtdXJsIDxjb21wdXRlLXJlYWNoYWJsZS1pY21zLXVybD4gXAogIHN0YXR1cyBcCiAgLS1j" + - "bHVzdGVyLW5hbWUgPGNvbXB1dGUtcGxhbmUtY2x1c3Rlci1uYW1lPiBcCiAgLS1uY2EtaWQgPG5j" + - "YS1pZD4KYGBgCgpTaG93IHRoZSByZWdpc3RlcmVkIGNvbXB1dGUtcGxhbmUgbGlzdC4gTmFtZWQt" + - "Y2x1c3RlciBgZG93biAtLXBsYW4tb25seWAgZG9lcwpub3QgcXVlcnkgSUNNUywgc28gaXQgcHJl" + - "dmlld3Mgb25seSB0aGF0IGNvbXB1dGUgcGxhbmUgYW5kIGNhbm5vdCBzaG93IHRoZQpjb25kaXRp" + - "b25hbCBjb250cm9sLXBsYW5lIHJlbW92YWwuIElmIHRoZSB0YXJnZXQgaXMgdGhlIGxhc3QgcmVn" + - "aXN0ZXJlZApjbHVzdGVyLCByZWFsIGBkb3duYCBhbHNvIGRlc3Ryb3lzIHRoZSBjb250cm9sIHBs" + - "YW5lLiBHZXQgZXhwbGljaXQgY29uZmlybWF0aW9uCmZvciBib3RoIHJlbW92YWxzIGJlZm9yZSBj" + - "b250aW51aW5nLiBUaGVuIHByZXZpZXcgYW5kIGV4ZWN1dGUgd2l0aCB0aGUgc2FtZQpwcmVmaXg6" + - "CgpgYGBiYXNoCm52Y2YtY2xpIC0tY29uZmlnIDxjb25maWc+IHNlbGYtaG9zdGVkIFwKICAtLWNv" + - "bnRyb2wtcGxhbmUtc3RhY2sgZGVwbG95L3N0YWNrcy9zZWxmLW1hbmFnZWQgXAogIC0tY29tcHV0" + - "ZS1wbGFuZS1zdGFjayBkZXBsb3kvc3RhY2tzL252Y2YtY29tcHV0ZS1wbGFuZSBcCiAgLS1lbnYg" + - "PGVudj4gXAogIC0tcGxhaW4gXAogIC0tY29udHJvbC1wbGFuZS1jb250ZXh0IDxjb250cm9sLXBs" + - "YW5lLWNvbnRleHQ+IFwKICAtLWNvbXB1dGUtcGxhbmUtY29udGV4dCA8Y29tcHV0ZS1wbGFuZS1j" + - "b250ZXh0PiBcCiAgLS1pY21zLXVybCA8Y29tcHV0ZS1yZWFjaGFibGUtaWNtcy11cmw+IFwKICBk" + - "b3duIC0tcGxhbi1vbmx5IFwKICAtLWNsdXN0ZXItbmFtZSA8Y29tcHV0ZS1wbGFuZS1jbHVzdGVy" + - "LW5hbWU+IFwKICAtLW5jYS1pZCA8bmNhLWlkPgoKbnZjZi1jbGkgLS1jb25maWcgPGNvbmZpZz4g" + + "IGFjdGlvbiIsCiAgICAgICJUaGUgYWdlbnQgc2V0IGluZ3Jlc3MuZ2F0ZXdheUFwaS5jb250cm9s" + + "bGVyTmFtZXNwYWNlIHRvIGVudm95LWdhdGV3YXktc3lzdGVtIiwKICAgICAgIlRoZSBhZ2VudCBz" + + "ZXQgc2hhcmVkLCBncnBjLCBhbmQgbmF0cyBHYXRld2F5IHJlZmVyZW5jZXMgdG8gbmFtZSBudmNm" + + "LWdhdGV3YXkgYW5kIG5hbWVzcGFjZSBlbnZveS1nYXRld2F5IiwKICAgICAgIlRoZSBhZ2VudCBz" + + "ZXQgZ2xvYmFsLndvcmtlckVuZHBvaW50cy5udmNmU2VydmljZVVSTCwgbnZjZkdycGNTZXJ2aWNl" + + "VVJMLCBudmNmTmF0c1NlcnZpY2VVUkwsIG52Y3RTZXJ2aWNlVVJMLCBudmN0R3JwY1NlcnZpY2VV" + + "UkwsIGFuZCBpbnZvY2F0aW9uU2VydmljZVVSTCIsCiAgICAgICJUaGUgYWdlbnQgc2V0IGdycGNw" + + "cm94eS5udmNmR3JwY1NlcnZpY2VVUkwgdG8gdGhlIGNvbnRyb2wtcGxhbmUtbG9jYWwgQVBJIGdS" + + "UEMgc2VydmljZSIsCiAgICAgICJUaGUgYWdlbnQgZW5hYmxlZCBib3RoIGluZ3Jlc3MuZ2F0ZXdh" + + "eUFwaS5yb3V0ZXMubnZjZkFwaS5ncnBjIGFuZCBudmN0QXBpLmdycGMgd2l0aCB3b3JrZXItYXBp" + + "IGFuZCB3b3JrZXItdGFza3MgaG9zdG5hbWVzIiwKICAgICAgIlRoZSBhZ2VudCBleHBsaWNpdGx5" + + "IHNldCBpbmdyZXNzLmdhdGV3YXlBcGkucm91dGVzLm5hdHMuZW5hYmxlZCB0byB0cnVlIiwKICAg" + + "ICAgIlRoZSBhZ2VudCBzZXQgb3BlbmJhby5taWdyYXRpb25zLmlzc3VlckRpc2NvdmVyeS5lbmFi" + + "bGVkIHRvIHRydWUiLAogICAgICAiVGhlIGFnZW50IGNvbmZpZ3VyZWQgdGhlIGJhcmUtR2F0ZXdh" + + "eSBDTEkgVVJMIGFuZCBIb3N0IGZpZWxkcywgaW5jbHVkaW5nIHNjaGVtZS1sZXNzIGljbXNfaG9z" + + "dCIsCiAgICAgICJUaGUgYWdlbnQgY29uZmlndXJlZCBjb21wdXRlLXBsYW5lIGljbXNTZXJ2aWNl" + + "VVJMLCBpY21zU2VydmljZUhvc3RIZWFkZXJPdmVycmlkZSwgcmV2YWxTZXJ2aWNlVVJMLCByZXZh" + + "bFNlcnZpY2VIb3N0SGVhZGVyT3ZlcnJpZGUsIG5hdHNVUkwsIGFuZCBuYXRzSG9zdE92ZXJyaWRl" + + "IiwKICAgICAgIlRoZSBjb250cm9sLXBsYW5lIHB1bGwtc2VjcmV0IG5hbWVzcGFjZSBsaXN0IGlu" + + "Y2x1ZGVkIGNlcnQtbWFuYWdlciIsCiAgICAgICJUaGUgY29tcHV0ZS1wbGFuZSBzZWNyZXQgd2Fz" + + "IGNyZWF0ZWQgb25seSBpbiBudmNhLW9wZXJhdG9yIGFuZCBtaXJyb3JlZCBieSB0aGUgY2hhcnQg" + + "YW5kIG9wZXJhdG9yIHRvIG52Y2Etc3lzdGVtIgogICAgXQogIH0sCiAgewogICAgImlkIjogIkcx" + + "MS1zcGxpdC10ZWFyZG93biIsCiAgICAicXVlc3Rpb24iOiAiVGVhciBkb3duIG15IHNwbGl0IGNv" + + "bnRyb2wtcGxhbmUgYW5kIGNvbXB1dGUtcGxhbmUgZGVwbG95bWVudCBzYWZlbHkuIFNob3cgYm90" + + "aCB0aGUgSGVsbWZpbGUgdmFsdWVzIGFuZCBDTEkgcHJvZmlsZSB2YXJpYW50cy4iLAogICAgImV4" + + "cGVjdGVkX3NraWxsIjogIm52Y2Ytc2VsZi1tYW5hZ2VkLWluc3RhbGxhdGlvbiIsCiAgICAiZ3Jv" + + "dW5kX3RydXRoIjogIlRoZSBIZWxtZmlsZSBmbG93IGRlc3Ryb3llZCBhbmQgY29uZmlybWVkIGRl" + + "cmVnaXN0cmF0aW9uIG9mIGV2ZXJ5IGNvbXB1dGUgY2x1c3RlciBiZWZvcmUgZGVzdHJveWluZyB0" + + "aGUgY29udHJvbCBwbGFuZSBhbmQgcGFzc2VkIGJvdGggY29udHJvbC1wbGFuZSBrdWJlY29uZmln" + + "IGZvcm1zLiBCZWZvcmUgZWl0aGVyIGhhbmRvZmYgY291bGQgZGVzdHJveSB0aGUgY29udHJvbCBw" + + "bGFuZSwgYm90aCB0ZWFyZG93biBmbG93cyB3YXJuZWQgdGhhdCBuYW1lc3BhY2UgcHJlc2VydmF0" + + "aW9uIGRvZXMgbm90IHByZXNlcnZlIHRoZSBIZWxtIHJlbGVhc2UsIHJlcXVpcmVkIGVmZmVjdGl2" + + "ZSBjZXJ0TWFuYWdlci5lbmFibGVkOiBmYWxzZSBmb3IgYW4gZXh0ZXJuYWwgaW5zdGFsbGF0aW9u" + + "IGFuZCBhYm9ydGVkIGlmIHRydWUsIGFuZCB2ZXJpZmllZCBtYXRjaGluZyByZWxlYXNlIG93bmVy" + + "c2hpcCBmb3IgYW4gaW50ZW5kZWQgc3RhY2stbWFuYWdlZCByZWxlYXNlLCBhYm9ydGluZyBvbiBt" + + "aXNzaW5nIG9yIG1pc21hdGNoZWQgZXZpZGVuY2UuIFRoZXkgcHJlc2VydmVkIHRoZSBuYW1lc3Bh" + + "Y2UgYnkgZGVmYXVsdCBhbmQgZGlkIG5vdCBkZWxldGUgaXQgd2l0aG91dCBuYW1lc3BhY2UgcHJv" + + "dmVuYW5jZSBhbmQgZXhwbGljaXQgY29uZmlybWF0aW9uLiBUaGUgQ0xJIGZsb3cgcmV0YWluZWQg" + + "dGhlIGdlbmVyYXRlZCByZWdpc3RyYXRpb24gdmFsdWVzLCB1c2VkIHRoZSBmdWxsLXByZWZpeCBz" + + "dGF0dXMgY29tbWFuZCB0byBpbnNwZWN0IGxpdmUgcmVnaXN0cmF0aW9ucywgc3RhdGVkIHRoYXQg" + + "bmFtZWQtY2x1c3RlciBwbGFuLW9ubHkgZG9lcyBub3QgcXVlcnkgSUNNUyBhbmQgY2Fubm90IHBy" + + "ZWRpY3QgY29uZGl0aW9uYWwgY29udHJvbC1wbGFuZSByZW1vdmFsLCBhbmQgZ290IGV4cGxpY2l0" + + "IGNvbmZpcm1hdGlvbiB3aGVuIHRoZSB0YXJnZXQgd2FzIHRoZSBsYXN0IHJlZ2lzdGVyZWQgY2x1" + + "c3Rlci4gSXQgdGhlbiBwcmV2aWV3ZWQgYW5kIHJhbiBkb3duIHdpdGggdGhlIGZ1bGwgcGVyc2lz" + + "dGVudCBwcmVmaXgsIHJlbW92aW5nIHRoZSBjb250cm9sIHBsYW5lIG9ubHkgYWZ0ZXIgdGhlIGxh" + + "c3QgcmVnaXN0cmF0aW9uIHdhcyBnb25lLiIsCiAgICAiZXhwZWN0ZWRfYmVoYXZpb3IiOiBbCiAg" + + "ICAgICJUaGUgYWdlbnQgcmVhZCB0aGUgbnZjZi1zZWxmLW1hbmFnZWQtaW5zdGFsbGF0aW9uIFNL" + + "SUxMLm1kIGJlZm9yZSB0YWtpbmcgYWN0aW9uIiwKICAgICAgIkZvciBldmVyeSBjb21wdXRlIGNs" + + "dXN0ZXIsIHRoZSBIZWxtZmlsZSBmbG93IHJhbiB0aGUgY29tcHV0ZS1wbGFuZSBNYWtlZmlsZSBk" + + "ZXN0cm95IHRhcmdldCB3aXRoIGl0cyBjb21wdXRlIGt1YmVjb25maWciLAogICAgICAiQWZ0ZXIg" + + "Y29uZmlybWF0aW9uLCB0aGUgSGVsbWZpbGUgZmxvdyByYW4gY2x1c3RlciBkZWxldGUgd2l0aCBj" + + "bHVzdGVySUQgYW5kIG5jYUlEIGJlZm9yZSBjb250cm9sLXBsYW5lIGRlc3RydWN0aW9uIiwKICAg" + + "ICAgIkJlZm9yZSBlaXRoZXIgaGFuZG9mZiBjb3VsZCBkZXN0cm95IHRoZSBjb250cm9sIHBsYW5l" + + "LCBib3RoIHRlYXJkb3duIGZsb3dzIHdhcm5lZCB0aGF0IG5hbWVzcGFjZSBwcmVzZXJ2YXRpb24g" + + "ZG9lcyBub3QgcHJlc2VydmUgdGhlIEhlbG0gcmVsZWFzZSwgcmVxdWlyZWQgZWZmZWN0aXZlIGNl" + + "cnRNYW5hZ2VyLmVuYWJsZWQ6IGZhbHNlIGZvciBhbiBleHRlcm5hbCBpbnN0YWxsYXRpb24gYW5k" + + "IGFib3J0ZWQgaWYgdHJ1ZSwgYW5kIHZlcmlmaWVkIGludGVuZGVkIHN0YWNrIG93bmVyc2hpcCB3" + + "aGVuIGVuYWJsZWQsIGFib3J0aW5nIG9uIG1pc3Npbmcgb3IgbWlzbWF0Y2hlZCBldmlkZW5jZSIs" + + "CiAgICAgICJCb3RoIHRlYXJkb3duIGZsb3dzIHByZXNlcnZlZCB0aGUgY2VydC1tYW5hZ2VyIG5h" + + "bWVzcGFjZSBieSBkZWZhdWx0IGFuZCBkaWQgbm90IGRlbGV0ZSBpdCB3aXRob3V0IG5hbWVzcGFj" + + "ZSBwcm92ZW5hbmNlIGFuZCBleHBsaWNpdCBjb25maXJtYXRpb24iLAogICAgICAiVGhlIEhlbG1m" + + "aWxlIGZsb3cgcmFuIGNvbnRyb2wtcGxhbmUgTWFrZWZpbGUgZGVzdHJveSB3aXRoIGJvdGggS1VC" + + "RUNPTkZJRyBhbmQgS1VCRUNPTkZJR19GSUxFIiwKICAgICAgIlRoZSBDTEkgZmxvdyByZXRhaW5l" + + "ZCBvdXQvPGNsdXN0ZXItbmFtZT4tcmVnaXN0ZXItdmFsdWVzLnlhbWwgdW50aWwgdGVhcmRvd24g" + + "Y29tcGxldGVkIiwKICAgICAgIkJlZm9yZSByZWFsIGRvd24sIHRoZSBDTEkgZmxvdyB1c2VkIHRo" + + "ZSBmdWxsLXByZWZpeCBzdGF0dXMgY29tbWFuZCB0byBpbnNwZWN0IGxpdmUgcmVnaXN0cmF0aW9u" + + "cywgc3RhdGVkIHRoYXQgbmFtZWQtY2x1c3RlciBwbGFuLW9ubHkgZG9lcyBub3QgcXVlcnkgSUNN" + + "UyBhbmQgY2Fubm90IHByZWRpY3QgY29uZGl0aW9uYWwgY29udHJvbC1wbGFuZSByZW1vdmFsLCB3" + + "YXJuZWQgd2hlbiB0aGUgdGFyZ2V0IHdhcyB0aGUgbGFzdCByZWdpc3RlcmVkIGNsdXN0ZXIsIGFu" + + "ZCBnb3QgZXhwbGljaXQgY29uZmlybWF0aW9uIiwKICAgICAgIlRoZSBDTEkgZmxvdyB1c2VkIC0t" + + "Y29uZmlnLCBib3RoIHN0YWNrIHBhdGhzLCAtLWVudiwgLS1wbGFpbiwgYm90aCBjb250ZXh0cywg" + + "YW5kIC0taWNtcy11cmwgZm9yIGRvd24gLS1wbGFuLW9ubHkgYW5kIHRoZW4gZG93biIsCiAgICAg" + + "ICJUaGUgYWdlbnQgc3RhdGVkIHRoYXQgZG93biB1bnJlZ2lzdGVycyBlYWNoIGNvbXB1dGUgY2x1" + + "c3RlciBhbmQgcmVtb3ZlcyB0aGUgY29udHJvbCBwbGFuZSBvbmx5IGFmdGVyIG5vIHJlZ2lzdHJh" + + "dGlvbnMgcmVtYWluIgogICAgXQogIH0sCiAgewogICAgImlkIjogIlMxMy12YWx1ZXMtcHJlY2Vk" + + "ZW5jZSIsCiAgICAicXVlc3Rpb24iOiAiSSBhZGRlZCBhIHZhbHVlIHRvIG15IGVudmlyb25tZW50" + + "IFlBTUwgYnV0IGl0J3MgYmVpbmcgc2lsZW50bHkgaWdub3JlZC4gSG93IGRvIGhlbG1maWxlIHZh" + + "bHVlcyB3b3JrIGluIE5WQ0Y/IiwKICAgICJleHBlY3RlZF9za2lsbCI6ICJudmNmLXNlbGYtbWFu" + + "YWdlZC1pbnN0YWxsYXRpb24iLAogICAgImdyb3VuZF90cnV0aCI6ICJUaGUgYWdlbnQgZXhwbGFp" + + "bmVkIHRoZSB2YWx1ZXMgcHJlY2VkZW5jZSBjaGFpbiAoYmFzZS55YW1sLCBlbnYgWUFNTCwgZ2xv" + + "YmFsLnlhbWwuZ290bXBsLCBzZWNyZXRzLCBpbmxpbmUgdmFsdWVzKSwgaWRlbnRpZmllZCB0aGF0" + + "IGdsb2JhbC55YW1sLmdvdG1wbCBvbmx5IHBhc3NlcyB0aHJvdWdoIHNwZWNpZmljIGtleXMsIGFu" + + "ZCBleHBsYWluZWQgdGhhdCBhcmJpdHJhcnkgY2hhcnQgdmFsdWVzIG11c3QgdXNlIHJlbGVhc2Ug" + + "aW5saW5lIHZhbHVlcyBibG9ja3MuIiwKICAgICJleHBlY3RlZF9iZWhhdmlvciI6IFsKICAgICAg" + + "IlRoZSBhZ2VudCByZWFkIHRoZSBudmNmLXNlbGYtbWFuYWdlZC1pbnN0YWxsYXRpb24gU0tJTEwu" + + "bWQgYmVmb3JlIHRha2luZyBhY3Rpb24iLAogICAgICAiVGhlIGFnZW50IGV4cGxhaW5lZCB0aGUg" + + "dmFsdWVzIHByZWNlZGVuY2UgY2hhaW46IGJhc2UueWFtbCAtPiBlbnYgWUFNTCAtPiBnbG9iYWwu" + + "eWFtbC5nb3RtcGwgLT4gc2VjcmV0cyAtPiBpbmxpbmUgdmFsdWVzIiwKICAgICAgIlRoZSBhZ2Vu" + + "dCBpZGVudGlmaWVkIHRoYXQgZ2xvYmFsLnlhbWwuZ290bXBsIG9ubHkgcGFzc2VzIHRocm91Z2gg" + + "c3BlY2lmaWMga2V5cyAoY2Fzc2FuZHJhLnJlcGxpY2FDb3VudCwgZ2xvYmFsLnN0b3JhZ2VDbGFz" + + "cywgZ2xvYmFsLmltYWdlLCBldGMuKSIsCiAgICAgICJUaGUgYWdlbnQgZXhwbGFpbmVkIHRoYXQg" + + "YXJiaXRyYXJ5IGNoYXJ0IHZhbHVlcyBtdXN0IGJlIHNldCB2aWEgcmVsZWFzZSBpbmxpbmUgdmFs" + + "dWVzOiBibG9ja3MiLAogICAgICAiVGhlIGFnZW50IGxpc3RlZCBleGFtcGxlcyBvZiB2YWx1ZXMg" + + "dGhhdCBhcmUgcHJvcGFnYXRlZCBhbmQgYXJiaXRyYXJ5IGNoYXJ0IHZhbHVlcyB0aGF0IHJlcXVp" + + "cmUgYSByZWxlYXNlIHZhbHVlcyBibG9jayIKICAgIF0KICB9LAogIHsKICAgICJpZCI6ICJTMTQt" + + "ZW5hYmxlLWxsbS1mdW5jdGlvbnMiLAogICAgInF1ZXN0aW9uIjogIkkgbmVlZCB0byBkZXBsb3kg" + + "ZnVuY3Rpb25UeXBlOiBMTE0gZnVuY3Rpb25zIG9uIGEgc2VsZi1tYW5hZ2VkLCBzaW5nbGUtbm9k" + + "ZSBpc29sYXRlZCB0ZXN0IGNsdXN0ZXIuIFdoYXQgSGVsbWZpbGUgY29uZmlndXJhdGlvbiBhbmQg" + + "dmVyaWZpY2F0aW9uIHN0ZXBzIGRvIEkgbmVlZD8iLAogICAgImV4cGVjdGVkX3NraWxsIjogIm52" + + "Y2Ytc2VsZi1tYW5hZ2VkLWluc3RhbGxhdGlvbiIsCiAgICAiZ3JvdW5kX3RydXRoIjogIlRoZSBh" + + "Z2VudCBlbmFibGVkIHRoZSBMTE0gYWRkb24gd2l0aCBhZGRvbnMubGxtLmVuYWJsZWQsIGNvbmZp" + + "Z3VyZWQgc2luZ2xlIHJlcGxpY2FzIGZvciB0aGUgTExNIEFQSSBHYXRld2F5IGFuZCByZXF1ZXN0" + + "IHJvdXRlciwgYW5kIGV4cGxhaW5lZCB0aGF0IHRoZSByZXF1ZXN0IHJvdXRlciB1c2VzIHBvd2Vy" + + "LW9mLXR3byB3aGVuIG5vIGxvYWQtYmFsYW5jZXIgY29uZmlndXJhdGlvbiBpcyBzZXQuIEl0IGxp" + + "bmtlZCB0aGUgY2Fub25pY2FsIHJlcXVlc3Qtcm91dGVyIGxvYWQtYmFsYW5jaW5nIGd1aWRlIGZv" + + "ciBvdGhlciByb3V0aW5nIG1ldGhvZHMuIEZvciB0aGUgaXNvbGF0ZWQgcGxhaW50ZXh0IGNsdXN0" + + "ZXIsIGl0IGluY2x1ZGVkIGJvdGggYWRkb25zLmxsbS5nYXRld2F5LmF1dGguZ3JwY0luc2VjdXJl" + + "IGFuZCBhZ2VudENvbmZpZy5tZXJnZUNvbmZpZy53b3JrbG9hZC5zdGFyZ2F0ZVFVSUNJbnNlY3Vy" + + "ZSwgd2l0aCBhIHdhcm5pbmcgdGhhdCB0aG9zZSBzZXR0aW5ncyBhcmUgbm90IGZvciBwcm9kdWN0" + + "aW9uLiBJdCByZWZyZXNoZWQgdGhlIGNvbXB1dGUgcGxhbmUgdXNpbmcgdGhlIHNhbWUgaGFuZG9m" + + "ZiB1c2VkIGR1cmluZyBpbnN0YWxsYXRpb24sIHJlZGVwbG95ZWQgZXhpc3RpbmcgTExNIGZ1bmN0" + + "aW9ucywgYW5kIHZlcmlmaWVkIHRoZSBMTE0gZGVwbG95bWVudHMsIHJvdXRlLCBhbmQgbGxtLXdv" + + "cmtlciBzaWRlY2FyLiIsCiAgICAiZXhwZWN0ZWRfYmVoYXZpb3IiOiBbCiAgICAgICJUaGUgYWdl" + + "bnQgdXNlZCBhZGRvbnMubGxtLmVuYWJsZWQsIG5vdCB0aGUgb2Jzb2xldGUgbGxtLmVuYWJsZWQg" + + "cGF0aCIsCiAgICAgICJUaGUgYWdlbnQgc2V0IGdhdGV3YXkgYW5kIHJlcXVlc3RSb3V0ZXIgcmVw" + + "bGljYUNvdW50IHRvIDEgZm9yIHRoZSBzaW5nbGUtbm9kZSB0ZXN0IGNsdXN0ZXIiLAogICAgICAi" + + "VGhlIGFnZW50IHN0YXRlZCB0aGF0IHRoZSByZXF1ZXN0IHJvdXRlciBkZWZhdWx0cyB0byBwb3dl" + + "ci1vZi10d28gYW5kIGxpbmtlZCB0aGUgY2Fub25pY2FsIHJlcXVlc3Qtcm91dGVyIGxvYWQtYmFs" + + "YW5jaW5nIGd1aWRlIGZvciBvdGhlciBtZXRob2RzIiwKICAgICAgIlRoZSBhZ2VudCBpbmNsdWRl" + + "ZCBhZGRvbnMubGxtLmdhdGV3YXkuYXV0aC5ncnBjSW5zZWN1cmUgYW5kIHdvcmtsb2FkLnN0YXJn" + + "YXRlUVVJQ0luc2VjdXJlIGZvciB0aGUgaXNvbGF0ZWQgcGxhaW50ZXh0IGNsdXN0ZXIsIGFuZCB3" + + "YXJuZWQgYWdhaW5zdCB1c2luZyB0aGVtIGluIHByb2R1Y3Rpb24iLAogICAgICAiVGhlIGFnZW50" + + "IGFwcGxpZWQgdGhlIGNvbnRyb2wtcGxhbmUgSGVsbWZpbGUgZW52aXJvbm1lbnQsIHJlZnJlc2hl" + + "ZCB0aGUgY29tcHV0ZSBwbGFuZSB3aXRoIHRoZSBzYW1lIHNlbGVjdGVkIGhhbmRvZmYsIGFuZCBy" + + "ZWNyZWF0ZWQgb3IgcmVkZXBsb3llZCBleGlzdGluZyBMTE0gZnVuY3Rpb25zIiwKICAgICAgIlRo" + + "ZSBhZ2VudCB2ZXJpZmllZCBsbG0tYXBpLWdhdGV3YXksIGxsbS1yZXF1ZXN0LXJvdXRlciwgdGhl" + + "IExMTSBIVFRQUm91dGUsIGFuZCB0aGUgbGxtLXdvcmtlciBzaWRlY2FyIGluY2x1ZGluZyAtLXF1" + + "aWMtaW5zZWN1cmUiCiAgICBdCiAgfSwKICB7CiAgICAiaWQiOiAiRzgtTkVHLW5vdC1mb3ItazNk" + + "IiwKICAgICJxdWVzdGlvbiI6ICJTZXQgdXAgYSBsb2NhbCBOVkNGIGRldiBjbHVzdGVyIHVzaW5n" + + "IGszZCBmb3IgdGVzdGluZyIsCiAgICAiZXhwZWN0ZWRfc2tpbGwiOiBudWxsLAogICAgInNob3Vs" + + "ZF90cmlnZ2VyIjogZmFsc2UsCiAgICAiZ3JvdW5kX3RydXRoIjogIlRoaXMgaXMgYSBsb2NhbCBr" + + "M2QgZGV2ZWxvcG1lbnQgcmVxdWVzdCB0aGF0IGJlbG9uZ3MgdG8gdGhlIG52Y2Ytc2VsZi1ob3N0" + + "ZWQtbG9jYWwtZGV2IHNraWxsLCBub3QgbnZjZi1zZWxmLW1hbmFnZWQtaW5zdGFsbGF0aW9uLiBU" + + "aGUgYWdlbnQgZGlkIG5vdCByZWFkIG9yIHVzZSB0aGUgc2VsZi1tYW5hZ2VkIGluc3RhbGxhdGlv" + + "biBza2lsbCBhbmQgaW5zdGVhZCBwcm92aWRlZCBrM2Qtc3BlY2lmaWMgZ3VpZGFuY2UuIiwKICAg" + + "ICJleHBlY3RlZF9iZWhhdmlvciI6IFsKICAgICAgIlRoZSBhZ2VudCBkaWQgbm90IHJlYWQgbnZj" + + "Zi1zZWxmLW1hbmFnZWQtaW5zdGFsbGF0aW9uL1NLSUxMLm1kIiwKICAgICAgIlRoZSBhZ2VudCBk" + + "aWQgbm90IHByb3ZpZGUgaGVsbWZpbGUtYmFzZWQgcHJvZHVjdGlvbiBkZXBsb3ltZW50IGluc3Ry" + + "dWN0aW9ucyIsCiAgICAgICJUaGUgYWdlbnQgcHJvdmlkZWQgazNkLXNwZWNpZmljIGxvY2FsIGRl" + + "dmVsb3BtZW50IGd1aWRhbmNlIG9yIGRlZmVycmVkIHRvIHRoZSBhcHByb3ByaWF0ZSBsb2NhbC1k" + + "ZXYgc2tpbGwiCiAgICBdCiAgfQpdClBLBwgrE7g/rVUAAK1VAABQSwMEFAAIAAAAAAAhAAAAAAAA" + + "AAAAAAAAAC8ACQBkYXRhL252Y2Ytc2VsZi1tYW5hZ2VkLWluc3RhbGxhdGlvbi9leGFtcGxlcy5t" + + "ZFVUBQABAKbOEiMgRXhhbXBsZXMKCldvcmtlZCBleGFtcGxlcyBiYXNlZCBvbiByZWFsIGRlcGxv" + + "eW1lbnQgc2NlbmFyaW9zLgoKIyMgRXhhbXBsZSAxOiBPdmVycmlkZSBDYXNzYW5kcmEgUmVzb3Vy" + + "Y2VzCgpUaGUgZGVmYXVsdCBDYXNzYW5kcmEgcmVzb3VyY2UgbGltaXRzIGNhdXNlIE9PTSBvbiBs" + + "YXJnZSBpbnN0YW5jZSB0eXBlcyAoZS5nLiwgYHA1LjQ4eGxhcmdlYCkuCgpQcm9ibGVtOiBDYXNz" + + "YW5kcmEgcG9kcyByZXN0YXJ0IHdpdGggYE9PTUtpbGxlZGAuCgpTb2x1dGlvbjogT3ZlcnJpZGUg" + + "cmVzb3VyY2VzIHZpYSBoZWxtZmlsZSByZWxlYXNlIHZhbHVlcyBibG9jay4KCiMjIyBTdGVwIDE6" + + "IENhcHR1cmUgYmFzZWxpbmUKCmBgYGJhc2gKSEVMTUZJTEVfRU5WPTxlbnY+IGhlbG1maWxlIC0t" + + "c2VsZWN0b3IgbmFtZT1jYXNzYW5kcmEgdGVtcGxhdGUgPiAvdG1wL2Nhc3MtYmVmb3JlLnlhbWwK" + + "Z3JlcCAtQTggJ3Jlc291cmNlczonIC90bXAvY2Fzcy1iZWZvcmUueWFtbCB8IGhlYWQgLTEwCmBg" + + "YAoKIyMjIFN0ZXAgMjogQWRkIG92ZXJyaWRlIHRvIGhlbG1maWxlLmQvMDEtZGVwZW5kZW5jaWVz" + + "LnlhbWwuZ290bXBsCgpJbiB0aGUgZXhhbXBsZXMgYmVsb3csIGA8cHJpdmF0ZS12YWx1ZXM+YCBy" + + "ZWZlcnMgdG8gdGhlIGBzZWNyZXRzL2AgZGlyZWN0b3J5IGF0IHRoZSBoZWxtZmlsZSBzdGFjayBy" + + "b290LgoKYGBgeWFtbAotIG5hbWU6IGNhc3NhbmRyYQogIHZlcnNpb246IDAuOC4wCiAgY29uZGl0" + + "aW9uOiBjYXNzYW5kcmEuZW5hYmxlZAogIG5hbWVzcGFjZTogY2Fzc2FuZHJhLXN5c3RlbQogIDw8" + + "OiAqZGVwZW5kZW5jeQogIHZhbHVlczoKICAgIC0gLi4vZ2xvYmFsLnlhbWwuZ290bXBsCiAgICAt" + + "IC4uLzxwcml2YXRlLXZhbHVlcz4ve3sgcmVxdWlyZWRFbnYgIkhFTE1GSUxFX0VOViIgfX0tc2Vj" + + "cmV0cy55YW1sCiAgICAtIGNhc3NhbmRyYToKICAgICAgICByZXNvdXJjZXM6CiAgICAgICAgICBs" + + "aW1pdHM6CiAgICAgICAgICAgIGNwdTogIjgiCiAgICAgICAgICAgIG1lbW9yeTogODE5Mk1pCiAg" + + "ICAgICAgICByZXF1ZXN0czoKICAgICAgICAgICAgY3B1OiAiMiIKICAgICAgICAgICAgbWVtb3J5" + + "OiA0MDk2TWkKYGBgCgojIyMgU3RlcCAzOiBWZXJpZnkgYW5kIGFwcGx5CgpgYGBiYXNoCkhFTE1G" + + "SUxFX0VOVj08ZW52PiBoZWxtZmlsZSAtLXNlbGVjdG9yIG5hbWU9Y2Fzc2FuZHJhIHRlbXBsYXRl" + + "ID4gL3RtcC9jYXNzLWFmdGVyLnlhbWwKZGlmZiAvdG1wL2Nhc3MtYmVmb3JlLnlhbWwgL3RtcC9j" + + "YXNzLWFmdGVyLnlhbWwgICMgQ29uZmlybSByZXNvdXJjZXMgY2hhbmdlZApIRUxNRklMRV9FTlY9" + + "PGVudj4gaGVsbWZpbGUgLS1zZWxlY3RvciBuYW1lPWNhc3NhbmRyYSBzeW5jCmBgYAoKTm90ZTog" + + "YHJlc291cmNlUHJlc2V0YCAoYSBCaXRuYW1pIGZlYXR1cmUpIGlzIG5vdCBhdmFpbGFibGUgaW4g" + + "dGhlIE5WQ0YgY2Fzc2FuZHJhIHdyYXBwZXIgY2hhcnQuIFVzZSBleHBsaWNpdCBgcmVzb3VyY2Vz" + + "YCBpbnN0ZWFkLgoKLS0tCgojIyBFeGFtcGxlIDI6IERlcGxveSBmcm9tIE5HQyBQcml2YXRlIFJl" + + "Z2lzdHJ5IHdpdGggUHVsbCBTZWNyZXRzCgpEZXBsb3kgdGhlIE5WQ0Ygc3RhY2sgcHVsbGluZyBp" + + "bWFnZXMgZGlyZWN0bHkgZnJvbSBOR0MgKGBudmNyLmlvYCkgaW5zdGVhZCBvZiBhIG1pcnJvcmVk" + + "IHJlZ2lzdHJ5LCB1c2luZyBpbWFnZSBwdWxsIHNlY3JldHMuCgojIyMgU3RlcCAxOiBDb25maWd1" + + "cmUgZW52aXJvbm1lbnQgZm9yIE5HQwoKYGBgeWFtbAojIGVudmlyb25tZW50cy88ZW52Pi55YW1s" + + "Cmdsb2JhbDoKICBoZWxtOgogICAgc291cmNlczoKICAgICAgcmVnaXN0cnk6IG52Y3IuaW8KICAg" + + "ICAgcmVwb3NpdG9yeTogbnZpZGlhL252Y2YKICBpbWFnZToKICAgIHJlZ2lzdHJ5OiBudmNyLmlv" + + "CiAgICByZXBvc2l0b3J5OiBudmlkaWEvbnZjZgpgYGAKCiMjIyBTdGVwIDI6IEF1dGhlbnRpY2F0" + + "ZSBsb2NhbGx5IChmb3IgaGVsbWZpbGUgY2hhcnQgcHVsbHMpCgpgYGBiYXNoCmRvY2tlciBsb2dp" + + "biBudmNyLmlvIC11ICckb2F1dGh0b2tlbicgLXAgIiROR0NfQVBJX0tFWSIKaGVsbSByZWdpc3Ry" + + "eSBsb2dpbiBudmNyLmlvIC11ICckb2F1dGh0b2tlbicgLXAgIiROR0NfQVBJX0tFWSIKYGBgCgoj" + + "IyMgU3RlcCAzOiBDcmVhdGUgbmFtZXNwYWNlcyBhbmQgcHVsbCBzZWNyZXRzCgpgYGBiYXNoCmV4" + + "cG9ydCBOR0NfQVBJX0tFWT0iPHlvdXItbmdjLWFwaS1rZXk+IgoKZm9yIG5zIGluIGNhc3NhbmRy" + + "YS1zeXN0ZW0gbmF0cy1zeXN0ZW0gbnZjZiBhcGkta2V5cyBlc3Mgc2lzIHZhdWx0LXN5c3RlbSBj" + + "ZXJ0LW1hbmFnZXI7IGRvCiAga3ViZWN0bCAtLWNvbnRleHQgPGNvbnRyb2wtcGxhbmUtY29udGV4" + + "dD4gY3JlYXRlIG5hbWVzcGFjZSAiJG5zIiBcCiAgICAtLWRyeS1ydW49Y2xpZW50IC1vIHlhbWwg" + + "fCBrdWJlY3RsIC0tY29udGV4dCA8Y29udHJvbC1wbGFuZS1jb250ZXh0PiBhcHBseSAtZiAtCmRv" + + "bmUKCmZvciBucyBpbiBjYXNzYW5kcmEtc3lzdGVtIG5hdHMtc3lzdGVtIG52Y2YgYXBpLWtleXMg" + + "ZXNzIHNpcyB2YXVsdC1zeXN0ZW0gY2VydC1tYW5hZ2VyOyBkbwogIGt1YmVjdGwgLS1jb250ZXh0" + + "IDxjb250cm9sLXBsYW5lLWNvbnRleHQ+IGNyZWF0ZSBzZWNyZXQgZG9ja2VyLXJlZ2lzdHJ5IG52" + + "Y3ItY3JlZHMgXAogICAgLS1kb2NrZXItc2VydmVyPW52Y3IuaW8gXAogICAgLS1kb2NrZXItdXNl" + + "cm5hbWU9JyRvYXV0aHRva2VuJyBcCiAgICAtLWRvY2tlci1wYXNzd29yZD0iJE5HQ19BUElfS0VZ" + + "IiBcCiAgICAtLW5hbWVzcGFjZT0iJG5zIiBcCiAgICAtLWRyeS1ydW49Y2xpZW50IC1vIHlhbWwg" + + "fCBrdWJlY3RsIC0tY29udGV4dCA8Y29udHJvbC1wbGFuZS1jb250ZXh0PiBhcHBseSAtZiAtCmRv" + + "bmUKYGBgCgojIyMgU3RlcCA0OiBBZGQgaW1hZ2VQdWxsU2VjcmV0cyB0byBoZWxtZmlsZSByZWxl" + + "YXNlcwoKQWRkIHRoZSBjaGFydC1zcGVjaWZpYyBgaW1hZ2VQdWxsU2VjcmV0c2Aga2V5IHRvIGVh" + + "Y2ggcmVsZWFzZS4gRXhhbXBsZSBmb3IgY2Fzc2FuZHJhIGluIGBoZWxtZmlsZS5kLzAxLWRlcGVu" + + "ZGVuY2llcy55YW1sLmdvdG1wbGA6CgpgYGB5YW1sCi0gbmFtZTogY2Fzc2FuZHJhCiAgdmVyc2lv" + + "bjogMC44LjAKICBjb25kaXRpb246IGNhc3NhbmRyYS5lbmFibGVkCiAgbmFtZXNwYWNlOiBjYXNz" + + "YW5kcmEtc3lzdGVtCiAgPDw6ICpkZXBlbmRlbmN5CiAgdmFsdWVzOgogICAgLSAuLi9nbG9iYWwu" + + "eWFtbC5nb3RtcGwKICAgIC0gLi4vPHByaXZhdGUtdmFsdWVzPi97eyByZXF1aXJlZEVudiAiSEVM" + + "TUZJTEVfRU5WIiB9fS1zZWNyZXRzLnlhbWwKICAgIC0gY2Fzc2FuZHJhOgogICAgICAgIGdsb2Jh" + + "bDoKICAgICAgICAgIGltYWdlUHVsbFNlY3JldHM6CiAgICAgICAgICAgIC0gbnZjci1jcmVkcwpg" + + "YGAKClNlZSBbcmVmZXJlbmNlcy9wdWxsLXNlY3JldHMubWRdKHJlZmVyZW5jZXMvcHVsbC1zZWNy" + + "ZXRzLm1kKSBmb3IgdGhlIGtleSBmb3IgZXZlcnkgY2hhcnQuCgpUaGVzZSBhcmUgY29udHJvbC1w" + + "bGFuZSBuYW1lc3BhY2VzLiBGb3IgYSBzZXBhcmF0ZSBjb21wdXRlIGNsdXN0ZXIsIGNyZWF0ZSB0" + + "aGUKc2VjcmV0IG9ubHkgaW4gYG52Y2Etb3BlcmF0b3JgOyB0aGUgY2hhcnQgYW5kIG9wZXJhdG9y" + + "IG1pcnJvciBpdCB0bwpgbnZjYS1zeXN0ZW1gLiBTZWUgW1NwbGl0IENvbXB1dGUtUGxhbmUgSW5z" + + "dGFsbGF0aW9uXShyZWZlcmVuY2VzL2NvbXB1dGUtcGxhbmUtaW5zdGFsbGF0aW9uLm1kI3B1bGwt" + + "c2VjcmV0cykuCgojIyMgU3RlcCA1OiBEZXBsb3kKCmBgYGJhc2gKSEVMTUZJTEVfRU5WPTxlbnY+" + + "IGhlbG1maWxlIC0ta3ViZS1jb250ZXh0IDxjb250cm9sLXBsYW5lLWNvbnRleHQ+IHN5bmMKYGBg" + + "CgojIyMgU3RlcCA2OiBQYXRjaCBTZXJ2aWNlQWNjb3VudHMgZm9yIGNoYXJ0cyB3aXRob3V0IG5h" + + "dGl2ZSBzdXBwb3J0CgpBZnRlciBQaGFzZSAxIChkZXBlbmRlbmNpZXMpIGNvbXBsZXRlcywgT3Bl" + + "bkJhbyBwb2RzIHdpbGwgYmUgaW4gYEltYWdlUHVsbEJhY2tPZmZgLiBQYXRjaCBhbmQgcmVzdGFy" + + "dDoKCmBgYGJhc2gKZm9yIG5zIGluIHZhdWx0LXN5c3RlbSBudmNmIGVzczsgZG8KICBmb3Igc2Eg" + + "aW4gJChrdWJlY3RsIC0tY29udGV4dCA8Y29udHJvbC1wbGFuZS1jb250ZXh0PiBnZXQgc2EgLW4g" + + "IiRucyIgXAogICAgLS1uby1oZWFkZXJzIC1vIGN1c3RvbS1jb2x1bW5zPSI6bWV0YWRhdGEubmFt" + + "ZSIpOyBkbwogICAga3ViZWN0bCAtLWNvbnRleHQgPGNvbnRyb2wtcGxhbmUtY29udGV4dD4gcGF0" + + "Y2ggc2VydmljZWFjY291bnQgLW4gIiRucyIgIiRzYSIgXAogICAgICAtcCAneyJpbWFnZVB1bGxT" + + "ZWNyZXRzIjogW3sibmFtZSI6ICJudmNyLWNyZWRzIn1dfScKICBkb25lCmRvbmUKa3ViZWN0bCAt" + + "LWNvbnRleHQgPGNvbnRyb2wtcGxhbmUtY29udGV4dD4gZGVsZXRlIHBvZHMgLW4gdmF1bHQtc3lz" + + "dGVtIC0tYWxsCmBgYAoKVmVyaWZ5OgoKYGBgYmFzaAprdWJlY3RsIC0tY29udGV4dCA8Y29udHJv" + + "bC1wbGFuZS1jb250ZXh0PiBnZXQgZXZlbnRzIC1uIHZhdWx0LXN5c3RlbSBcCiAgLS1zb3J0LWJ5" + + "PScubGFzdFRpbWVzdGFtcCcgfCBncmVwIC1pIHB1bGwKIyBTaG91bGQgc2hvdyAiU3VjY2Vzc2Z1" + + "bGx5IHB1bGxlZCBpbWFnZSIgZnJvbSBudmNyLmlvCmBgYAoKLS0tCgojIyBFeGFtcGxlIDM6IEZ1" + + "bGwgVGVhcmRvd24gYW5kIFJlaW5zdGFsbAoKV2hlbiBhIGRlcGxveW1lbnQgaXMgYnJva2VuIGFu" + + "ZCB5b3UgbmVlZCBhIGNsZWFuIHNsYXRlLgoKIyMjIFN0ZXAgMTogRGVzdHJveSB0aGUgY29tcHV0" + + "ZS1wbGFuZSBzdGFjawoKYGBgYmFzaAptYWtlIC1DIGRlcGxveS9zdGFja3MvbnZjZi1jb21wdXRl" + + "LXBsYW5lIGRlc3Ryb3kgXAogIENMVVNURVJfTkFNRT08Y2x1c3Rlci1uYW1lPiBcCiAgSEVMTUZJ" + + "TEVfRU5WPTxlbnY+IFwKICBLVUJFQ09ORklHX0ZJTEU9PGNvbXB1dGUtcGxhbmUta3ViZWNvbmZp" + + "Zz4KYGBgCgpJZiBjb21wdXRlIGNsZWFudXAgaXMgc3R1Y2sgb24gZmluYWxpemVycywgdXNlIHRo" + + "ZSBjb21wdXRlLWNvbnRleHQgcHJvY2VkdXJlIGluCltkZWJ1Z2dpbmcubWRdKHJlZmVyZW5jZXMv" + + "ZGVidWdnaW5nLm1kI2ZhaWx1cmUtbnZjYS1jbGVhbnVwLXN0dWNrLWZpbmFsaXplcnMpLgoKIyMj" + + "IFN0ZXAgMjogRGVyZWdpc3RlciB0aGUgY29tcHV0ZSBjbHVzdGVyCgpSZWFkIGBjbHVzdGVySURg" + + "IGFuZCBgbmNhSURgIGZyb20KYGRlcGxveS9zdGFja3MvbnZjZi1jb21wdXRlLXBsYW5lL3JlZ2lz" + + "dHJhdGlvbi88Y2x1c3Rlci1uYW1lPi1yZWdpc3Rlci12YWx1ZXMueWFtbGAuClNob3cgdGhlIElE" + + "IGFuZCBnZXQgY29uZmlybWF0aW9uIGJlZm9yZSBkZWxldGluZyB0aGUgSUNNUyByb3c6CgpgYGBi" + + "YXNoCjxudmNmLWNsaT4gLS1jb25maWcgPGNvbmZpZz4gY2x1c3RlciBkZWxldGUgXAogIC0tY2x1" + + "c3Rlci1pZCA8Y2x1c3Rlci1pZC1mcm9tLXJlZ2lzdHJhdGlvbi12YWx1ZXM+IFwKICAtLW5jYS1p" + + "ZCA8bmNhLWlkPiBcCiAgLS1pZ25vcmUtbWlzc2luZwpgYGAKClJlcGVhdCBzdGVwcyAxIGFuZCAy" + + "IGZvciBldmVyeSBjb21wdXRlIGNsdXN0ZXIuCgojIyMgU3RlcCAzOiBEZXN0cm95IHRoZSBjb250" + + "cm9sLXBsYW5lIHN0YWNrCgpQcmVzZXJ2ZSB0aGUgYGNlcnQtbWFuYWdlcmAgbmFtZXNwYWNlIGJ5" + + "IGRlZmF1bHQuIE5hbWVzcGFjZSBwcmVzZXJ2YXRpb24gZG9lcwpub3QgcHJlc2VydmUgdGhlIEhl" + + "bG0gcmVsZWFzZS4gQmVmb3JlIHJ1bm5pbmcgZGVzdHJveSwgaWRlbnRpZnkgd2hldGhlcgpjZXJ0" + + "LW1hbmFnZXIgaXMgZXh0ZXJuYWwuIEZvciBhbiBleHRlcm5hbCBpbnN0YWxsYXRpb24sIHJlcXVp" + + "cmUgZWZmZWN0aXZlCmBjZXJ0TWFuYWdlci5lbmFibGVkOiBmYWxzZWAgYW5kIGFib3J0IGlmIGl0" + + "IGlzIHRydWUuIEZvciBhbiBpbnRlbmRlZApzdGFjay1tYW5hZ2VkIHJlbGVhc2Ugd2l0aCBlZmZl" + + "Y3RpdmUgYGNlcnRNYW5hZ2VyLmVuYWJsZWQ6IHRydWVgLCB2ZXJpZnkKbWF0Y2hpbmcgc3RhY2sg" + + "SGVsbSByZWxlYXNlIG1ldGFkYXRhIGFuZCBhYm9ydCBvbiBtaXNzaW5nIG9yIG1pc21hdGNoZWQK" + + "ZXZpZGVuY2UuIE9ubHkgcGxhbiBuYW1lc3BhY2UgcmVtb3ZhbCBhZnRlciB2ZXJpZnlpbmcgbmFt" + + "ZXNwYWNlIHByb3ZlbmFuY2UgYW5kCmdldHRpbmcgZXhwbGljaXQgY29uZmlybWF0aW9uOyBvdGhl" + + "cndpc2UgZG8gbm90IGRlbGV0ZSBpdC4KCmBgYGJhc2gKS1VCRUNPTkZJRz08Y29udHJvbC1wbGFu" + + "ZS1rdWJlY29uZmlnPiBcCm1ha2UgLUMgZGVwbG95L3N0YWNrcy9zZWxmLW1hbmFnZWQgZGVzdHJv" + + "eSBcCiAgSEVMTUZJTEVfRU5WPTxlbnY+IFwKICBLVUJFQ09ORklHX0ZJTEU9PGNvbnRyb2wtcGxh" + + "bmUta3ViZWNvbmZpZz4KYGBgCgpQYXNzIGJvdGgga3ViZWNvbmZpZyBmb3JtcyBiZWNhdXNlIGNv" + + "bnRyb2wtcGxhbmUgbmFtZXNwYWNlIGNsZWFudXAgdXNlcwphbWJpZW50IGBrdWJlY3RsYC4KCiMj" + + "IyBTdGVwIDQ6IFZlcmlmeSBjbGVhbgoKYGBgYmFzaAprdWJlY3RsIC0tY29udGV4dCA8Y29tcHV0" + + "ZS1wbGFuZS1jb250ZXh0PiBnZXQgbnMgfCBcCiAgZ3JlcCAtRSAnKG52Y2F8bnZjZi1iYWNrZW5k" + + "fGdyb3ZlfGR5bmFtbyknCmt1YmVjdGwgLS1jb250ZXh0IDxjb250cm9sLXBsYW5lLWNvbnRleHQ+" + + "IGdldCBucyB8IFwKICBncmVwIC1FICcoY2Fzc2FuZHJhfG5hdHN8dmF1bHR8bnZjZnxhcGkta2V5" + + "c3xlc3N8c2lzKScKIyBCb3RoIGNvbW1hbmRzIHNob3VsZCByZXR1cm4gZW1wdHkuCmBgYAoKIyMj" + + "IFN0ZXAgNTogUmVpbnN0YWxsIGluIHNwbGl0IG9yZGVyCgpGb2xsb3cgW0NsZWFuIEluc3RhbGxh" + + "dGlvbl0oU0tJTEwubWQjY2xlYW4taW5zdGFsbGF0aW9uKSwgdGhlbiByZXR1cm4gdG8gdGhlCnNh" + + "bWUgaGFuZG9mZiBpbiBbU3BsaXQgQ29tcHV0ZS1QbGFuZSBJbnN0YWxsYXRpb25dKHJlZmVyZW5j" + + "ZXMvY29tcHV0ZS1wbGFuZS1pbnN0YWxsYXRpb24ubWQpLgoKLS0tCgojIyBFeGFtcGxlIDQ6IFJl" + + "Y292ZXIgZnJvbSBhIEdhdGV3YXkgRW5kcG9pbnQgQ2hhbmdlCgpUaGUgc2VwYXJhdGVseSBwcm92" + + "aXNpb25lZCBHYXRld2F5IG9yIGl0cyBsb2FkIGJhbGFuY2VyIHdhcyByZWNyZWF0ZWQgYW5kIGdv" + + "dCBhIG5ldyBlbmRwb2ludC4KCiMjIyBTdGVwIDE6IEdldCB0aGUgbmV3IGVuZHBvaW50CgpgYGBi" + + "YXNoCkdBVEVXQVlfQUREUj0kKGt1YmVjdGwgLS1jb250ZXh0IDxjb250cm9sLXBsYW5lLWNvbnRl" + + "eHQ+IGdldCBnYXRld2F5IFwKICBudmNmLWdhdGV3YXkgLW4gZW52b3ktZ2F0ZXdheSBcCiAgLW8g" + + "anNvbnBhdGg9J3suc3RhdHVzLmFkZHJlc3Nlc1swXS52YWx1ZX0nKQp0ZXN0IC1uICIkR0FURVdB" + + "WV9BRERSIgpgYGAKCiMjIyBTdGVwIDI6IFVwZGF0ZSBETlMgYW5kIGRpcmVjdCBhZGRyZXNzIGZp" + + "ZWxkcwoKS2VlcCBgZ2xvYmFsLmRvbWFpbmAsIHJvdXRlIGhvc3RuYW1lcywgYW5kIENMSSBIb3N0" + + "IGZpZWxkcyB1bmNoYW5nZWQuIFBvaW50IHRoZQpETlMgcmVjb3JkcyBmb3IgcmVuZGVyZWQgcm91" + + "dGUgaG9zdG5hbWVzLCBzdWNoIGFzIGBhcGkuPGRvbWFpbj5gIGFuZApgKi5pbnZvY2F0aW9uLjxk" + + "b21haW4+YCwgdG8gYEdBVEVXQVlfQUREUmAuIEZvciBhIHRlbXBvcmFyeSBlbnZpcm9ubWVudCB3" + + "aXRob3V0CkROUywga2VlcCBpdHMgcmVzZXJ2ZWQgcm91dGUgc3VmZml4IGFuZCBjb25uZWN0IHRv" + + "IGBHQVRFV0FZX0FERFJgIHdpdGggdGhlCm1hdGNoaW5nIGBIb3N0YCBoZWFkZXIuCgpGb3IgYSBz" + + "cGxpdCBkZXBsb3ltZW50IGNvbmZpZ3VyZWQgd2l0aCBkaXJlY3QgR2F0ZXdheSBhZGRyZXNzZXMs" + + "IHJlcGxhY2Ugb25seQp0aGUgYWRkcmVzcy1iZWFyaW5nIHZhbHVlczogY29udHJvbC1wbGFuZSBg" + + "bnZjZk5hdHNTZXJ2aWNlVVJMYCwgY29tcHV0ZS1wbGFuZQpJQ01TLCBSZVZhbCwgYW5kIE5BVFMg" + + "VVJMcywgYW5kIENMSSBVUkwgZmllbGRzLiBLZWVwIHRoZWlyIGRvbWFpbiBhbmQgSG9zdApvdmVy" + + "cmlkZXMgdW5jaGFuZ2VkLiBSZWZyZXNoIHJlZ2lzdHJhdGlvbiBhbmQgaW5zdGFsbGF0aW9uIHRo" + + "cm91Z2ggdGhlIHNhbWUKaGFuZG9mZiB1c2VkIG9yaWdpbmFsbHkuIFNlZQpbU3BsaXQgQ29tcHV0" + + "ZS1QbGFuZSBJbnN0YWxsYXRpb25dKHJlZmVyZW5jZXMvY29tcHV0ZS1wbGFuZS1pbnN0YWxsYXRp" + + "b24ubWQpCmZvciB0aGUgZmllbGRzIGFuZCBjb21wbGV0ZSBjb21tYW5kcy4KCiMjIyBTdGVwIDM6" + + "IFZlcmlmeSBib3RoIGNvbnRleHRzCgpgYGBiYXNoCmRpZyArc2hvcnQgImFwaS48ZG9tYWluPiIK" + + "Y3VybCAtSCAiSG9zdDogYXBpLjxkb21haW4+IiAiaHR0cDovLyRHQVRFV0FZX0FERFIvaGVhbHRo" + + "IgprdWJlY3RsIC0tY29udGV4dCA8Y29udHJvbC1wbGFuZS1jb250ZXh0PiBnZXQgZ2F0ZXdheSBu" + + "dmNmLWdhdGV3YXkgXAogIC1uIGVudm95LWdhdGV3YXkgLW8gd2lkZQprdWJlY3RsIC0tY29udGV4" + + "dCA8Y29udHJvbC1wbGFuZS1jb250ZXh0PiBnZXQgaHR0cHJvdXRlcyAtQQprdWJlY3RsIC0tY29u" + + "dGV4dCA8Y29udHJvbC1wbGFuZS1jb250ZXh0PiBnZXQgdGNwcm91dGVzIC1BCmt1YmVjdGwgLS1j" + + "b250ZXh0IDxjb21wdXRlLXBsYW5lLWNvbnRleHQ+IHJvbGxvdXQgc3RhdHVzIFwKICBkZXBsb3lt" + + "ZW50L252Y2Etb3BlcmF0b3IgLW4gbnZjYS1vcGVyYXRvciAtLXRpbWVvdXQ9MTBtCmt1YmVjdGwg" + + "LS1jb250ZXh0IDxjb21wdXRlLXBsYW5lLWNvbnRleHQ+IHdhaXQgXAogIG52Y2ZiYWNrZW5kLzxj" + + "b21wdXRlLXBsYW5lLWNsdXN0ZXItbmFtZT4gLW4gbnZjYS1vcGVyYXRvciBcCiAgLS1mb3I9anNv" + + "bnBhdGg9J3suc3RhdHVzLmFnZW50U3RhdHVzfSc9aGVhbHRoeSAtLXRpbWVvdXQ9MTBtCmBgYAoK" + + "LS0tCgojIyBFeGFtcGxlIDU6IERlcGxveSBPbmx5IERlcGVuZGVuY2llcwoKVXNlZnVsIGZvciB0" + + "ZXN0aW5nIG9yIHdoZW4gaXRlcmF0aW5nIG9uIHNlcnZpY2UgY29uZmlndXJhdGlvbi4KCmBgYGJh" + + "c2gKIyBEZXBsb3kganVzdCBOQVRTLCBDYXNzYW5kcmEsIE9wZW5CYW8KSEVMTUZJTEVfRU5WPTxl" + + "bnY+IGhlbG1maWxlIC0tc2VsZWN0b3IgcmVsZWFzZS1ncm91cD1kZXBlbmRlbmNpZXMgc3luYwoK" + + "IyBDaGVjayBzdGF0dXMKa3ViZWN0bCBnZXQgcG9kcyAtbiBuYXRzLXN5c3RlbQprdWJlY3RsIGdl" + + "dCBwb2RzIC1uIGNhc3NhbmRyYS1zeXN0ZW0Ka3ViZWN0bCBnZXQgcG9kcyAtbiB2YXVsdC1zeXN0" + + "ZW0KCiMgRGVwbG95IGp1c3Qgb25lIHNwZWNpZmljIHJlbGVhc2UKSEVMTUZJTEVfRU5WPTxlbnY+" + + "IGhlbG1maWxlIC0tc2VsZWN0b3IgbmFtZT1jYXNzYW5kcmEgc3luYwpgYGAKCiMjIyBTZWxlY3Rv" + + "ciByZWZlcmVuY2UKCnwgU2VsZWN0b3IgfCBSZWxlYXNlcyB8CnwtLS0tLS0tLS0tfC0tLS0tLS0t" + + "LS18CnwgYHJlbGVhc2UtZ3JvdXA9ZGVwZW5kZW5jaWVzYCB8IG5hdHMsIGNhc3NhbmRyYSwgb3Bl" + + "bmJhby1zZXJ2ZXIgfAp8IGByZWxlYXNlLWdyb3VwPXNlcnZpY2VzYCB8IGFwaS1rZXlzLCBzaXMs" + + "IGFwaSwgaW52b2NhdGlvbi1zZXJ2aWNlLCBncnBjLXByb3h5LCBlc3MtYXBpLCBub3Rhcnktc2Vy" + + "dmljZSwgcmV2YWwsIG9wdGlvbmFsIGxsbS1yZXF1ZXN0LXJvdXRlciBhbmQgbGxtLWFwaS1nYXRl" + + "d2F5IHdoZW4gYGxsbS5lbmFibGVkPXRydWVgLCBvcHRpb25hbCB2YW5pdHktZ2F0ZXdheSBvbmx5" + + "IGluIHN0YWNrIHBhY2thZ2VzIHRoYXQgaW5jbHVkZSB0aGUgYWRkb24gYW5kIGhhdmUgYGFkZG9u" + + "cy52YW5pdHlHYXRld2F5LmVuYWJsZWQ9dHJ1ZWAsIG9wdGlvbmFsIG52Y2YtdWkgb25seSBpbiBz" + + "dGFjayBwYWNrYWdlcyB0aGF0IGluY2x1ZGUgdGhlIGFkZG9uIGFuZCBoYXZlIGBhZGRvbnMubnZj" + + "ZlVpLmVuYWJsZWQ9dHJ1ZWAgfAp8IGBuYW1lPWxsbS1yZXF1ZXN0LXJvdXRlcmAgfCBEZXBsb3kg" + + "anVzdCB0aGUgTExNIHJlcXVlc3Qgcm91dGVyIHdoZW4gYGxsbS5lbmFibGVkPXRydWVgIHwKfCBg" + + "bmFtZT1sbG0tYXBpLWdhdGV3YXlgIHwgRGVwbG95IGp1c3QgdGhlIExMTSBBUEkgZ2F0ZXdheSB3" + + "aGVuIGBsbG0uZW5hYmxlZD10cnVlYCB8CnwgYG5hbWU9dmFuaXR5LWdhdGV3YXlgIHwgRGVwbG95" + + "IGp1c3QgVmFuaXR5IEdhdGV3YXkgb25seSB3aGVuIHRoZSBzdGFjayBwYWNrYWdlIGluY2x1ZGVz" + + "IHRoYXQgcmVsZWFzZSBhbmQgYGFkZG9ucy52YW5pdHlHYXRld2F5LmVuYWJsZWQ9dHJ1ZWAgfAp8" + + "IGBuYW1lPW52Y2YtdWlgIHwgRGVwbG95IE5WQ0YgVUkgb25seSB3aGVuIHRoZSBzdGFjayBwYWNr" + + "YWdlIGluY2x1ZGVzIHRoYXQgcmVsZWFzZSBhbmQgYGFkZG9ucy5udmNmVWkuZW5hYmxlZD10cnVl" + + "YCB8CnwgYHJlbGVhc2UtZ3JvdXA9aW5ncmVzc2AgfCBpbmdyZXNzIChnYXRld2F5IHJvdXRlcykg" + + "fAp8IGBuYW1lPTxyZWxlYXNlPmAgfCBBbnkgaW5kaXZpZHVhbCByZWxlYXNlIGJ5IG5hbWUgfAoK" + + "Tm90ZTogYGFkbWluLWlzc3Vlci1wcm94eWAgZG9lcyBub3QgaGF2ZSBhIHJlbGVhc2UtZ3JvdXAg" + + "bGFiZWwuIFRhcmdldCBpdCB3aXRoIGAtLXNlbGVjdG9yIG5hbWU9YWRtaW4taXNzdWVyLXByb3h5" + + "YC4KUEsHCAJSTkB/KAAAfygAAFBLAwQUAAgAAAAAACEAAAAAAAAAAAAAAAAATAAJAGRhdGEvbnZj" + + "Zi1zZWxmLW1hbmFnZWQtaW5zdGFsbGF0aW9uL3JlZmVyZW5jZXMvY29tcHV0ZS1wbGFuZS1pbnN0" + + "YWxsYXRpb24ubWRVVAUAAQCmzhIjIFNwbGl0IENvbXB1dGUtUGxhbmUgSW5zdGFsbGF0aW9uCgpU" + + "aGUgY29udHJvbCBwbGFuZSBhbmQgY29tcHV0ZSBwbGFuZSBhcmUgc2VwYXJhdGUgc3RhY2tzLiBJ" + + "bnN0YWxsIHRoZSBjb250cm9sCnBsYW5lIGZpcnN0LCB0aGVuIHJlZ2lzdGVyIGFuZCBpbnN0YWxs" + + "IGVhY2ggY29tcHV0ZSBjbHVzdGVyLiBDaG9vc2Ugb25lIGhhbmRvZmYKYmVsb3cgYW5kIHVzZSBp" + + "dCBmb3IgdGhlIGZ1bGwgbGlmZWN5Y2xlLiBEbyBub3QgY29tYmluZSBhIENMSS1nZW5lcmF0ZWQg" + + "cHJvZmlsZQp3aXRoIHRoZSBIZWxtZmlsZSB2YWx1ZXMgZmxvdy4KCiMjIENob29zZSBhIEhhbmRv" + + "ZmYKCnwgRmxvdyB8IFNvdXJjZSBvZiBjb250cm9sLXBsYW5lIGVuZHBvaW50cyB8IFJlZ2lzdHJh" + + "dGlvbiBhcnRpZmFjdCB8CnwtLS0tLS18LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t" + + "LS18LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS18CnwgSGVsbWZpbGUgdmFsdWVzIHwgU2VwYXJhdGUg" + + "Y29udHJvbC1wbGFuZSBhbmQgY29tcHV0ZS1wbGFuZSBlbnZpcm9ubWVudCBmaWxlcyB8IGBkZXBs" + + "b3kvc3RhY2tzL252Y2YtY29tcHV0ZS1wbGFuZS9yZWdpc3RyYXRpb24vPGNsdXN0ZXI+LXJlZ2lz" + + "dGVyLXZhbHVlcy55YW1sYCB8CnwgQ0xJIHByb2ZpbGUgfCBDTEktZ2VuZXJhdGVkIGBkZXBsb3kv" + + "c3RhY2tzL3NlbGYtbWFuYWdlZC9vdXQvY29udHJvbC1wbGFuZS1wcm9maWxlLnlhbWxgIHwgQ0xJ" + + "LWdlbmVyYXRlZCBgZGVwbG95L3N0YWNrcy9udmNmLWNvbXB1dGUtcGxhbmUvb3V0LzxjbHVzdGVy" + + "Pi1yZWdpc3Rlci12YWx1ZXMueWFtbGAgfAoKVGhlIENMSSBwcm9maWxlIGlzIG1hbmRhdG9yeSBm" + + "b3IgdGhlIENMSSBmbG93IGFuZCBtdXN0IG5vdCBiZSBoYW5kLWF1dGhvcmVkLgpUaGUgSGVsbWZp" + + "bGUgZmxvdyBkb2VzIG5vdCBjb25zdW1lIGEgY29udHJvbC1wbGFuZSBwcm9maWxlLgoKQ29tbWFu" + + "ZHMgYmVsb3cgdXNlIG1vbm9yZXBvIHBhdGhzIGZyb20gdGhlIHJlcG9zaXRvcnkgcm9vdC4gT3Bl" + + "cmF0b3JzIHVzaW5nCmV4dHJhY3RlZCBwYWNrYWdlcyBuZWVkIG1hdGNoaW5nLXZlcnNpb24gYG52" + + "Y2Ytc2VsZi1tYW5hZ2VkLXN0YWNrYCBhbmQKYG52Y2YtY29tcHV0ZS1wbGFuZS1zdGFja2AgYnVu" + + "ZGxlcy4gU3Vic3RpdHV0ZSB0aG9zZSBidW5kbGUgcm9vdHMgZm9yCmBkZXBsb3kvc3RhY2tzL3Nl" + + "bGYtbWFuYWdlZGAgYW5kIGBkZXBsb3kvc3RhY2tzL252Y2YtY29tcHV0ZS1wbGFuZWAuCgojIyBI" + + "ZWxtZmlsZSBWYWx1ZXMgRmxvdwoKQ3JlYXRlIGJvdGggZW52aXJvbm1lbnQgZmlsZXMgYmVmb3Jl" + + "IGluc3RhbGxhdGlvbjoKCi0gYGRlcGxveS9zdGFja3Mvc2VsZi1tYW5hZ2VkL2Vudmlyb25tZW50" + + "cy88ZW52Pi55YW1sYCBmb3IgY29udHJvbC1wbGFuZQogIHJlZ2lzdHJ5LCBkb21haW4sIEdhdGV3" + + "YXksIHJvdXRlcywgYW5kIHNlcnZpY2Ugc2V0dGluZ3MuCi0gYGRlcGxveS9zdGFja3MvbnZjZi1j" + + "b21wdXRlLXBsYW5lL2Vudmlyb25tZW50cy88ZW52Pi55YW1sYCBmb3IgY29tcHV0ZS1wbGFuZQog" + + "IHJlZ2lzdHJ5LCBwdWxsIHNlY3JldHMsIGFuZCBjb21wdXRlLXJlYWNoYWJsZSBJQ01TLCBSZVZh" + + "bCwgYW5kIE5BVFMgdmFsdWVzLgoKRm9yIEVLUywgdXNlIHRoZSBjYW5vbmljYWwKW0NTUCBFbmQt" + + "dG8tRW5kIEV4YW1wbGVdKGh0dHBzOi8vZG9jcy5udmlkaWEuY29tL252Y2YvdjAuNi4wLXJjL2Nz" + + "cC1lbmQtdG8tZW5kLWV4YW1wbGUpLgpUaGUgY29udHJvbC1wbGFuZSBlbnZpcm9ubWVudCBrZWVw" + + "cyB0aGUgRW52b3kgR2F0ZXdheSBjb250cm9sbGVyIGluCmBlbnZveS1nYXRld2F5LXN5c3RlbWAs" + + "IGF0dGFjaGVzIHJvdXRlcyB0byBgR2F0ZXdheS9udmNmLWdhdGV3YXlgIGluCmBlbnZveS1nYXRl" + + "d2F5YCwgYW5kIGVuYWJsZXMgdGhlIE5BVFMgcm91dGUuIFRoZSBjb21wdXRlLXBsYW5lIGVudmly" + + "b25tZW50IHVzZXMKdGhlIGV4dGVybmFsIGFkZHJlc3MgcGx1cyB0aGUgc2VydmljZSBob3N0IG92" + + "ZXJyaWRlcy4gSGVyZSwKYDxnYXRld2F5LWFkZHJlc3M+YCBpcyB0aGUgTkxCIGFkZHJlc3MgYW5k" + + "IGA8Z2F0ZXdheS1kb21haW4+YCBpcyB0aGUgRE5TIGJhc2UKd2hvc2Ugc2VydmljZSBzdWJkb21h" + + "aW5zIHJlc29sdmUgdG8gdGhhdCBOTEI6CgpgYGB5YW1sCiMgZGVwbG95L3N0YWNrcy9zZWxmLW1h" + + "bmFnZWQvZW52aXJvbm1lbnRzLzxlbnY+LnlhbWwKZ2xvYmFsOgogIGRvbWFpbjogIjxnYXRld2F5" + + "LWRvbWFpbj4iCiAgd29ya2VyRW5kcG9pbnRzOgogICAgbnZjZlNlcnZpY2VVUkw6ICJodHRwOi8v" + + "YXBpLjxnYXRld2F5LWRvbWFpbj4iCiAgICBudmNmR3JwY1NlcnZpY2VVUkw6ICJodHRwOi8vd29y" + + "a2VyLWFwaS48Z2F0ZXdheS1kb21haW4+IgogICAgbnZjZk5hdHNTZXJ2aWNlVVJMOiAibmF0czov" + + "LzxnYXRld2F5LWFkZHJlc3M+OjQyMjIiCiAgICBudmN0U2VydmljZVVSTDogImh0dHA6Ly90YXNr" + + "cy48Z2F0ZXdheS1kb21haW4+IgogICAgbnZjdEdycGNTZXJ2aWNlVVJMOiAiaHR0cDovL3dvcmtl" + + "ci10YXNrcy48Z2F0ZXdheS1kb21haW4+IgogICAgaW52b2NhdGlvblNlcnZpY2VVUkw6ICJodHRw" + + "Oi8vaW52b2NhdGlvbi48Z2F0ZXdheS1kb21haW4+IgoKZ3JwY3Byb3h5OgogIG52Y2ZHcnBjU2Vy" + + "dmljZVVSTDogImh0dHA6Ly9hcGkubnZjZi5zdmMuY2x1c3Rlci5sb2NhbDo5MDkwIgoKaW5ncmVz" + + "czoKICBnYXRld2F5QXBpOgogICAgY29udHJvbGxlck5hbWVzcGFjZTogZW52b3ktZ2F0ZXdheS1z" + + "eXN0ZW0KICAgIGdhdGV3YXlzOgogICAgICBzaGFyZWQ6IHtuYW1lOiBudmNmLWdhdGV3YXksIG5h" + + "bWVzcGFjZTogZW52b3ktZ2F0ZXdheX0KICAgICAgZ3JwYzoge25hbWU6IG52Y2YtZ2F0ZXdheSwg" + + "bmFtZXNwYWNlOiBlbnZveS1nYXRld2F5fQogICAgICBuYXRzOgogICAgICAgIG5hbWU6IG52Y2Yt" + + "Z2F0ZXdheQogICAgICAgIG5hbWVzcGFjZTogZW52b3ktZ2F0ZXdheQogICAgICAgIGxpc3RlbmVy" + + "TmFtZTogbmF0cwogICAgcm91dGVzOgogICAgICBudmNmQXBpOgogICAgICAgIGdycGM6CiAgICAg" + + "ICAgICBlbmFibGVkOiB0cnVlCiAgICAgICAgICBob3N0bmFtZXM6IFsid29ya2VyLWFwaS48Z2F0" + + "ZXdheS1kb21haW4+Il0KICAgICAgbnZjdEFwaToKICAgICAgICBncnBjOgogICAgICAgICAgZW5h" + + "YmxlZDogdHJ1ZQogICAgICAgICAgaG9zdG5hbWVzOiBbIndvcmtlci10YXNrcy48Z2F0ZXdheS1k" + + "b21haW4+Il0KICAgICAgbmF0czoKICAgICAgICBlbmFibGVkOiB0cnVlCgpvcGVuYmFvOgogIG1p" + + "Z3JhdGlvbnM6CiAgICBpc3N1ZXJEaXNjb3Zlcnk6CiAgICAgIGVuYWJsZWQ6IHRydWUKYGBgCgpg" + + "YGB5YW1sCiMgZGVwbG95L3N0YWNrcy9udmNmLWNvbXB1dGUtcGxhbmUvZW52aXJvbm1lbnRzLzxl" + + "bnY+LnlhbWwKZ2xvYmFsOgogIG52Y2FPcGVyYXRvcjoKICAgIHNlbGZNYW5hZ2VkOgogICAgICBp" + + "Y21zU2VydmljZVVSTDogImh0dHA6Ly88Z2F0ZXdheS1hZGRyZXNzPiIKICAgICAgaWNtc1NlcnZp" + + "Y2VIb3N0SGVhZGVyT3ZlcnJpZGU6ICJzaXMuPGdhdGV3YXktZG9tYWluPiIKICAgICAgcmV2YWxT" + + "ZXJ2aWNlVVJMOiAiaHR0cDovLzxnYXRld2F5LWFkZHJlc3M+IgogICAgICByZXZhbFNlcnZpY2VI" + + "b3N0SGVhZGVyT3ZlcnJpZGU6ICJyZXZhbC48Z2F0ZXdheS1kb21haW4+IgogICAgICBuYXRzVVJM" + + "OiAibmF0czovLzxnYXRld2F5LWFkZHJlc3M+OjQyMjIiCiAgICAgIG5hdHNIb3N0T3ZlcnJpZGU6" + + "ICJuYXRzLjxnYXRld2F5LWRvbWFpbj4iCmBgYAoKUHJldmlldyBhbmQgaW5zdGFsbCB0aGUgY29u" + + "dHJvbCBwbGFuZSBhZ2FpbnN0IGl0cyBjb250ZXh0OgoKYGBgYmFzaAptYWtlIC1DIGRlcGxveS9z" + + "dGFja3Mvc2VsZi1tYW5hZ2VkIHRlbXBsYXRlIFwKICBIRUxNRklMRV9FTlY9PGVudj4gXAogIEtV" + + "QkVDT05GSUdfRklMRT08Y29udHJvbC1wbGFuZS1rdWJlY29uZmlnPgoKbWFrZSAtQyBkZXBsb3kv" + + "c3RhY2tzL3NlbGYtbWFuYWdlZCBpbnN0YWxsIFwKICBIRUxNRklMRV9FTlY9PGVudj4gXAogIEtV" + + "QkVDT05GSUdfRklMRT08Y29udHJvbC1wbGFuZS1rdWJlY29uZmlnPgpgYGAKCkJlZm9yZSByZWdp" + + "c3RlcmluZyB0aHJvdWdoIGEgYmFyZSBHYXRld2F5IGFkZHJlc3MsIGNyZWF0ZSBvciB1cGRhdGUg" + + "dGhlIENMSQpjb25maWcgcGFzc2VkIGFzIGBOVkNGX0NMSV9DT05GSUdgOgoKYGBgeWFtbApiYXNl" + + "X2h0dHBfdXJsOiAiaHR0cDovLzxnYXRld2F5LWFkZHJlc3M+IgppbnZva2VfdXJsOiAiaHR0cDov" + + "LzxnYXRld2F5LWFkZHJlc3M+IgpiYXNlX2dycGNfdXJsOiAiPGdhdGV3YXktYWRkcmVzcz46MTAw" + + "ODEiCmFwaV9rZXlzX3NlcnZpY2VfdXJsOiAiaHR0cDovLzxnYXRld2F5LWFkZHJlc3M+IgppY21z" + + "X3VybDogImh0dHA6Ly88Z2F0ZXdheS1hZGRyZXNzPiIKYXBpX2hvc3Q6ICJhcGkuPGdhdGV3YXkt" + + "ZG9tYWluPiIKYXBpX2tleXNfaG9zdDogImFwaS1rZXlzLjxnYXRld2F5LWRvbWFpbj4iCmludm9r" + + "ZV9ob3N0OiAiaW52b2NhdGlvbi48Z2F0ZXdheS1kb21haW4+IgppY21zX2hvc3Q6ICJzaXMuPGdh" + + "dGV3YXktZG9tYWluPiIKYGBgCgpIb3N0IGZpZWxkcyBjb250YWluIGhvc3RuYW1lcyBvbmx5LCB3" + + "aXRob3V0IGEgVVJMIHNjaGVtZS4gYElDTVNfVVJMYCBtYXBzIG9ubHkKdG8gdGhlIHJlZ2lzdHJh" + + "dGlvbiBjb21tYW5kJ3MgYC0taWNtcy11cmxgOyBgaWNtc19ob3N0YCBpbiB0aGUgY29uZmlnIHN1" + + "cHBsaWVzCnRoZSBHYXRld2F5IEhvc3QgaGVhZGVyLiBUaGVyZSBpcyBubyBgLS1pY21zLWhvc3Rg" + + "IE1ha2Ugb3IgQ0xJIGZsYWcuCgpSZWdpc3RlciBmcm9tIHRoZSBjb21wdXRlIGNvbnRleHQsIHRo" + + "ZW4gaW5zdGFsbCB0aGUgY29tcHV0ZSBwbGFuZToKCmBgYGJhc2gKbWFrZSAtQyBkZXBsb3kvc3Rh" + + "Y2tzL252Y2YtY29tcHV0ZS1wbGFuZSByZWdpc3Rlci1jbHVzdGVyIFwKICBDTFVTVEVSX05BTUU9" + + "PGNsdXN0ZXItbmFtZT4gXAogIE5DQV9JRD08bmNhLWlkPiBcCiAgQ0xVU1RFUl9SRUdJT049PHJl" + + "Z2lvbj4gXAogIElDTVNfVVJMPWh0dHA6Ly88Z2F0ZXdheS1hZGRyZXNzPiBcCiAgS1VCRUNPTkZJ" + + "R19GSUxFPTxjb21wdXRlLXBsYW5lLWt1YmVjb25maWc+IFwKICBOVkNGX0NMST08cGF0aC10by1u" + + "dmNmLWNsaT4gXAogIE5WQ0ZfQ0xJX0NPTkZJRz08cGF0aC10by1udmNmLWNsaS1jb25maWc+Cgpt" + + "YWtlIC1DIGRlcGxveS9zdGFja3MvbnZjZi1jb21wdXRlLXBsYW5lIGluc3RhbGwgXAogIENMVVNU" + + "RVJfTkFNRT08Y2x1c3Rlci1uYW1lPiBcCiAgSEVMTUZJTEVfRU5WPTxlbnY+IFwKICBLVUJFQ09O" + + "RklHX0ZJTEU9PGNvbXB1dGUtcGxhbmUta3ViZWNvbmZpZz4KYGBgCgpSZWdpc3RyYXRpb24gZGlz" + + "Y292ZXJzIHRoZSBPSURDIGlzc3VlciBhbmQgSldLUyBmcm9tIHRoZSBjb21wdXRlIGt1YmUgY29u" + + "dGV4dC4KSW4gYSBtdWx0aS1jbHVzdGVyIGRlcGxveW1lbnQsIGBLVUJFQ09ORklHX0ZJTEVgIGlz" + + "IHJlcXVpcmVkIG9uIGJvdGgKY29tcHV0ZS1wbGFuZSBjb21tYW5kcy4gSW4gYSBzYW1lLWNsdXN0" + + "ZXIgZGVwbG95bWVudCBpdCBtYXkgYmUgb21pdHRlZCBvbmx5CndoZW4gdGhlIGFtYmllbnQgY29u" + + "dGV4dCBpcyBhbHJlYWR5IHRoZSB0YXJnZXQgY2x1c3Rlci4KCiMjIENMSSBQcm9maWxlIEZsb3cK" + + "ClJ1biB0aGUgQ0xJIGNvbnRyb2wtcGxhbmUgaW5zdGFsbCBmaXJzdC4gSXQgY3JlYXRlcyB0aGUg" + + "cHJvZmlsZSBjb25zdW1lZCBieQpjb21wdXRlLXBsYW5lIHJlZ2lzdHJhdGlvbjoKCmBgYGJhc2gK" + + "bnZjZi1jbGkgLS1jb25maWcgPGNvbmZpZz4gc2VsZi1ob3N0ZWQgXAogIC0tY29udHJvbC1wbGFu" + + "ZS1zdGFjayBkZXBsb3kvc3RhY2tzL3NlbGYtbWFuYWdlZCBcCiAgLS1jb21wdXRlLXBsYW5lLXN0" + + "YWNrIGRlcGxveS9zdGFja3MvbnZjZi1jb21wdXRlLXBsYW5lIFwKICAtLWVudiA8ZW52PiBcCiAg" + + "LS1wbGFpbiBcCiAgLS1jb250cm9sLXBsYW5lLWNvbnRleHQgPGNvbnRyb2wtcGxhbmUtY29udGV4" + + "dD4gXAogIC0tY29tcHV0ZS1wbGFuZS1jb250ZXh0IDxjb21wdXRlLXBsYW5lLWNvbnRleHQ+IFwK" + + "ICBpbnN0YWxsIC0tY29udHJvbC1wbGFuZSBcCiAgLS1jbHVzdGVyLW5hbWUgPGNvbnRyb2wtcGxh" + + "bmUtY2x1c3Rlci1uYW1lPiBcCiAgLS1yZWdpb24gPHJlZ2lvbj4gXAogIC0tbmNhLWlkIDxuY2Et" + + "aWQ+Cgp0ZXN0IC1zIGRlcGxveS9zdGFja3Mvc2VsZi1tYW5hZ2VkL291dC9jb250cm9sLXBsYW5l" + + "LXByb2ZpbGUueWFtbApgYGAKClVzZSB0aGUgZnVsbCBwZXJzaXN0ZW50IHByZWZpeCBmb3IgYm90" + + "aCBjb21wdXRlLXBsYW5lIGNvbW1hbmRzOgoKYGBgYmFzaApudmNmLWNsaSAtLWNvbmZpZyA8Y29u" + + "ZmlnPiBzZWxmLWhvc3RlZCBcCiAgLS1jb250cm9sLXBsYW5lLXN0YWNrIGRlcGxveS9zdGFja3Mv" + + "c2VsZi1tYW5hZ2VkIFwKICAtLWNvbXB1dGUtcGxhbmUtc3RhY2sgZGVwbG95L3N0YWNrcy9udmNm" + + "LWNvbXB1dGUtcGxhbmUgXAogIC0tZW52IDxlbnY+IFwKICAtLXBsYWluIFwKICBjb21wdXRlLXBs" + + "YW5lIHJlZ2lzdGVyIFwKICAtLWNvbnRyb2wtcGxhbmUtcHJvZmlsZSBkZXBsb3kvc3RhY2tzL3Nl" + + "bGYtbWFuYWdlZC9vdXQvY29udHJvbC1wbGFuZS1wcm9maWxlLnlhbWwgXAogIC0tY2x1c3Rlci1u" + + "YW1lIDxjb21wdXRlLXBsYW5lLWNsdXN0ZXItbmFtZT4gXAogIC0ta3ViZS1jb250ZXh0IDxjb21w" + + "dXRlLXBsYW5lLWNvbnRleHQ+IFwKICAtLXJlZ2lvbiA8cmVnaW9uPiBcCiAgLS1vdXRwdXQgZGVw" + + "bG95L3N0YWNrcy9udmNmLWNvbXB1dGUtcGxhbmUvb3V0Lzxjb21wdXRlLXBsYW5lLWNsdXN0ZXIt" + + "bmFtZT4tcmVnaXN0ZXItdmFsdWVzLnlhbWwKCm52Y2YtY2xpIC0tY29uZmlnIDxjb25maWc+IHNl" + + "bGYtaG9zdGVkIFwKICAtLWNvbnRyb2wtcGxhbmUtc3RhY2sgZGVwbG95L3N0YWNrcy9zZWxmLW1h" + + "bmFnZWQgXAogIC0tY29tcHV0ZS1wbGFuZS1zdGFjayBkZXBsb3kvc3RhY2tzL252Y2YtY29tcHV0" + + "ZS1wbGFuZSBcCiAgLS1lbnYgPGVudj4gXAogIC0tcGxhaW4gXAogIGNvbXB1dGUtcGxhbmUgaW5z" + + "dGFsbCBcCiAgLS12YWx1ZXMgZGVwbG95L3N0YWNrcy9udmNmLWNvbXB1dGUtcGxhbmUvb3V0Lzxj" + + "b21wdXRlLXBsYW5lLWNsdXN0ZXItbmFtZT4tcmVnaXN0ZXItdmFsdWVzLnlhbWwgXAogIC0ta3Vi" + + "ZS1jb250ZXh0IDxjb21wdXRlLXBsYW5lLWNvbnRleHQ+IFwKICAtLWNsdXN0ZXItbmFtZSA8Y29t" + + "cHV0ZS1wbGFuZS1jbHVzdGVyLW5hbWU+CmBgYAoKUmVnaXN0cmF0aW9uIHNlbGVjdHMgdGhlIHBy" + + "b2ZpbGUncyBpbi1jbHVzdGVyIG9yIGNvbXB1dGUtcmVhY2hhYmxlIGVuZHBvaW50cwpmcm9tIHRo" + + "ZSBjb21wdXRlIGNvbnRleHQgYW5kIHByb2JlcyBpdHMgSldLUy4gRG8gbm90IHJlcGxhY2UgcHJv" + + "ZmlsZSBlbmRwb2ludHMKd2l0aCBoYW5kLWF1dGhvcmVkIEhlbG1maWxlIGVuZHBvaW50IHZhbHVl" + + "cy4KCiMjIFB1bGwgU2VjcmV0cwoKQ3JlYXRlIHRoZSBjb250cm9sLXBsYW5lIHNlY3JldCBpbiB0" + + "aGVzZSBuYW1lc3BhY2VzIG9uIHRoZSBjb250cm9sLXBsYW5lCmNvbnRleHQ6CgpgYGB0ZXh0CmNh" + + "c3NhbmRyYS1zeXN0ZW0gbmF0cy1zeXN0ZW0gbnZjZiBhcGkta2V5cyBlc3Mgc2lzIHZhdWx0LXN5" + + "c3RlbSBjZXJ0LW1hbmFnZXIKYGBgCgpPbiB0aGUgY29tcHV0ZSBjb250ZXh0LCBjcmVhdGUgdGhl" + + "IHNlY3JldCBvbmx5IGluIGBudmNhLW9wZXJhdG9yYCBhbmQgcmVmZXJlbmNlCml0IHRocm91Z2gg" + + "YGdsb2JhbC5pbWFnZVB1bGxTZWNyZXRzYCBpbiB0aGUgY29tcHV0ZS1wbGFuZSBlbnZpcm9ubWVu" + + "dC4gVGhlIGNoYXJ0CmFuZCBvcGVyYXRvciB1c2UgaXQgaW4gYG52Y2Etb3BlcmF0b3JgIGFuZCBt" + + "aXJyb3IgaXQgdG8gYG52Y2Etc3lzdGVtYC4gRG8gbm90IGFkZAplaXRoZXIgbmFtZXNwYWNlIHRv" + + "IHRoZSBjb250cm9sLXBsYW5lIGxpc3QuIEZvciBjb21tYW5kcyBhbmQgcG9saWN5IGV4YW1wbGVz" + + "LApzZWUgW3B1bGwtc2VjcmV0cy5tZF0ocHVsbC1zZWNyZXRzLm1kKS4KCiMjIFZlcmlmaWNhdGlv" + + "bgoKVXNlIHRoZSBleHBsaWNpdCBHYXRld2F5IG5hbWUgYW5kIG5hbWVzcGFjZToKCmBgYGJhc2gK" + + "a3ViZWN0bCAtLWNvbnRleHQgPGNvbnRyb2wtcGxhbmUtY29udGV4dD4gZ2V0IGdhdGV3YXkgbnZj" + + "Zi1nYXRld2F5IFwKICAtbiBlbnZveS1nYXRld2F5IC1vIHdpZGUKa3ViZWN0bCAtLWNvbnRleHQg" + + "PGNvbnRyb2wtcGxhbmUtY29udGV4dD4gZ2V0IHRjcHJvdXRlIC1uIGVudm95LWdhdGV3YXkKa3Vi" + + "ZWN0bCAtLWNvbnRleHQgPGNvbXB1dGUtcGxhbmUtY29udGV4dD4gcm9sbG91dCBzdGF0dXMgXAog" + + "IGRlcGxveW1lbnQvbnZjYS1vcGVyYXRvciAtbiBudmNhLW9wZXJhdG9yIC0tdGltZW91dD0xMG0K" + + "a3ViZWN0bCAtLWNvbnRleHQgPGNvbXB1dGUtcGxhbmUtY29udGV4dD4gd2FpdCBcCiAgbnZjZmJh" + + "Y2tlbmQvPGNvbXB1dGUtcGxhbmUtY2x1c3Rlci1uYW1lPiAtbiBudmNhLW9wZXJhdG9yIFwKICAt" + + "LWZvcj1qc29ucGF0aD0ney5zdGF0dXMuYWdlbnRTdGF0dXN9Jz1oZWFsdGh5IC0tdGltZW91dD0x" + + "MG0Ka3ViZWN0bCAtLWNvbnRleHQgPGNvbXB1dGUtcGxhbmUtY29udGV4dD4gZ2V0IHNlY3JldCA8" + + "cHVsbC1zZWNyZXQ+IC1uIG52Y2Etc3lzdGVtCmBgYAoKIyMgVGVhcmRvd24KCkRlc3Ryb3kgYW5k" + + "IGRlcmVnaXN0ZXIgZXZlcnkgY29tcHV0ZSBwbGFuZSBiZWZvcmUgdGhlIGNvbnRyb2wgcGxhbmUu" + + "IEJvdGgKaGFuZG9mZnMgY2FuIGRlc3Ryb3kgdGhlIGNvbnRyb2wgcGxhbmUsIHNvIGFwcGx5IHRo" + + "aXMgcHJlZmxpZ2h0IGJlZm9yZSBlaXRoZXIKb25lLiBQcmVzZXJ2ZSB0aGUgYGNlcnQtbWFuYWdl" + + "cmAgbmFtZXNwYWNlIGJ5IGRlZmF1bHQuIE5hbWVzcGFjZSBwcmVzZXJ2YXRpb24KZG9lcyBub3Qg" + + "cHJlc2VydmUgdGhlIEhlbG0gcmVsZWFzZS4gSWRlbnRpZnkgd2hldGhlciBjZXJ0LW1hbmFnZXIg" + + "aXMgZXh0ZXJuYWwuCkZvciBhbiBleHRlcm5hbCBpbnN0YWxsYXRpb24sIHJlcXVpcmUgZWZmZWN0" + + "aXZlIGBjZXJ0TWFuYWdlci5lbmFibGVkOiBmYWxzZWAKYW5kIGFib3J0IGlmIGl0IGlzIHRydWUu" + + "IEZvciBhbiBpbnRlbmRlZCBzdGFjay1tYW5hZ2VkIHJlbGVhc2Ugd2l0aCBlZmZlY3RpdmUKYGNl" + + "cnRNYW5hZ2VyLmVuYWJsZWQ6IHRydWVgLCB2ZXJpZnkgbWF0Y2hpbmcgc3RhY2sgSGVsbSByZWxl" + + "YXNlIG1ldGFkYXRhIGFuZAphYm9ydCBvbiBtaXNzaW5nIG9yIG1pc21hdGNoZWQgZXZpZGVuY2Uu" + + "IE9ubHkgcGxhbiBuYW1lc3BhY2UgcmVtb3ZhbCBhZnRlcgp2ZXJpZnlpbmcgbmFtZXNwYWNlIHBy" + + "b3ZlbmFuY2UgYW5kIGdldHRpbmcgZXhwbGljaXQgY29uZmlybWF0aW9uOyBvdGhlcndpc2UKZG8g" + + "bm90IGRlbGV0ZSBpdC4KCkZvciB0aGUgSGVsbWZpbGUgdmFsdWVzIGZsb3csIHJldGFpbiBlYWNo" + + "IHJlZ2lzdHJhdGlvbiB2YWx1ZXMgZmlsZSB1bnRpbApjbGVhbnVwIGlzIHZlcmlmaWVkOgoKYGBg" + + "YmFzaAptYWtlIC1DIGRlcGxveS9zdGFja3MvbnZjZi1jb21wdXRlLXBsYW5lIGRlc3Ryb3kgXAog" + + "IENMVVNURVJfTkFNRT08Y2x1c3Rlci1uYW1lPiBcCiAgSEVMTUZJTEVfRU5WPTxlbnY+IFwKICBL" + + "VUJFQ09ORklHX0ZJTEU9PGNvbXB1dGUtcGxhbmUta3ViZWNvbmZpZz4KCjxudmNmLWNsaT4gLS1j" + + "b25maWcgPGNvbmZpZz4gY2x1c3RlciBkZWxldGUgXAogIC0tY2x1c3Rlci1pZCA8Y2x1c3Rlci1p" + + "ZC1mcm9tLXJlZ2lzdHJhdGlvbi12YWx1ZXM+IFwKICAtLW5jYS1pZCA8bmNhLWlkPiBcCiAgLS1p" + + "Z25vcmUtbWlzc2luZwpgYGAKClJlYWQgYGNsdXN0ZXJJRGAgYW5kIGBuY2FJRGAgZnJvbQpgZGVw" + + "bG95L3N0YWNrcy9udmNmLWNvbXB1dGUtcGxhbmUvcmVnaXN0cmF0aW9uLzxjbHVzdGVyLW5hbWU+" + + "LXJlZ2lzdGVyLXZhbHVlcy55YW1sYC4KU2hvdyB0aGUgZXhhY3QgY2x1c3RlciBJRCBhbmQgZ2V0" + + "IGNvbmZpcm1hdGlvbiBiZWZvcmUgYGNsdXN0ZXIgZGVsZXRlYC4gUmVwZWF0CmNvbXB1dGUgZGVz" + + "dHJveSBhbmQgZGVyZWdpc3RyYXRpb24gZm9yIGV2ZXJ5IGNvbXB1dGUgY2x1c3RlciwgdGhlbiBk" + + "ZXN0cm95IHRoZQpjb250cm9sIHBsYW5lLgoKYGBgYmFzaApLVUJFQ09ORklHPTxjb250cm9sLXBs" + + "YW5lLWt1YmVjb25maWc+IFwKbWFrZSAtQyBkZXBsb3kvc3RhY2tzL3NlbGYtbWFuYWdlZCBkZXN0" + + "cm95IFwKICBIRUxNRklMRV9FTlY9PGVudj4gXAogIEtVQkVDT05GSUdfRklMRT08Y29udHJvbC1w" + + "bGFuZS1rdWJlY29uZmlnPgpgYGAKCkJvdGggYEtVQkVDT05GSUdgIGFuZCBgS1VCRUNPTkZJR19G" + + "SUxFYCBhcmUgcmVxdWlyZWQgb24gdGhlIGNvbnRyb2wtcGxhbmUKZGVzdHJveSBiZWNhdXNlIGl0" + + "cyBuYW1lc3BhY2UgY2xlYW51cCB1c2VzIGFtYmllbnQgYGt1YmVjdGxgLgoKRm9yIHRoZSBDTEkg" + + "cHJvZmlsZSBmbG93LCBrZWVwCmBkZXBsb3kvc3RhY2tzL252Y2YtY29tcHV0ZS1wbGFuZS9vdXQv" + + "PGNsdXN0ZXItbmFtZT4tcmVnaXN0ZXItdmFsdWVzLnlhbWxgCnVudGlsIHRlYXJkb3duIGNvbXBs" + + "ZXRlcyBiZWNhdXNlIGBkb3duYCByZWFkcyBpdHMgY2x1c3RlciBJRC4gRmlyc3QgcXVlcnkgdGhl" + + "CmxpdmUgcmVnaXN0cmF0aW9uIHNldCB3aXRoIHRoZSBzYW1lIGNvbXBsZXRlIHBlcnNpc3RlbnQg" + + "cHJlZml4OgoKYGBgYmFzaApudmNmLWNsaSAtLWNvbmZpZyA8Y29uZmlnPiBzZWxmLWhvc3RlZCBc" + + "CiAgLS1jb250cm9sLXBsYW5lLXN0YWNrIGRlcGxveS9zdGFja3Mvc2VsZi1tYW5hZ2VkIFwKICAt" + + "LWNvbXB1dGUtcGxhbmUtc3RhY2sgZGVwbG95L3N0YWNrcy9udmNmLWNvbXB1dGUtcGxhbmUgXAog" + + "IC0tZW52IDxlbnY+IFwKICAtLXBsYWluIFwKICAtLWNvbnRyb2wtcGxhbmUtY29udGV4dCA8Y29u" + + "dHJvbC1wbGFuZS1jb250ZXh0PiBcCiAgLS1jb21wdXRlLXBsYW5lLWNvbnRleHQgPGNvbXB1dGUt" + + "cGxhbmUtY29udGV4dD4gXAogIC0taWNtcy11cmwgPGNvbXB1dGUtcmVhY2hhYmxlLWljbXMtdXJs" + + "PiBcCiAgc3RhdHVzIFwKICAtLWNsdXN0ZXItbmFtZSA8Y29tcHV0ZS1wbGFuZS1jbHVzdGVyLW5h" + + "bWU+IFwKICAtLW5jYS1pZCA8bmNhLWlkPgpgYGAKClNob3cgdGhlIHJlZ2lzdGVyZWQgY29tcHV0" + + "ZS1wbGFuZSBsaXN0LiBOYW1lZC1jbHVzdGVyIGBkb3duIC0tcGxhbi1vbmx5YCBkb2VzCm5vdCBx" + + "dWVyeSBJQ01TLCBzbyBpdCBwcmV2aWV3cyBvbmx5IHRoYXQgY29tcHV0ZSBwbGFuZSBhbmQgY2Fu" + + "bm90IHNob3cgdGhlCmNvbmRpdGlvbmFsIGNvbnRyb2wtcGxhbmUgcmVtb3ZhbC4gSWYgdGhlIHRh" + + "cmdldCBpcyB0aGUgbGFzdCByZWdpc3RlcmVkCmNsdXN0ZXIsIHJlYWwgYGRvd25gIGFsc28gZGVz" + + "dHJveXMgdGhlIGNvbnRyb2wgcGxhbmUuIEdldCBleHBsaWNpdCBjb25maXJtYXRpb24KZm9yIGJv" + + "dGggcmVtb3ZhbHMgYmVmb3JlIGNvbnRpbnVpbmcuIFRoZW4gcHJldmlldyBhbmQgZXhlY3V0ZSB3" + + "aXRoIHRoZSBzYW1lCnByZWZpeDoKCmBgYGJhc2gKbnZjZi1jbGkgLS1jb25maWcgPGNvbmZpZz4g" + "c2VsZi1ob3N0ZWQgXAogIC0tY29udHJvbC1wbGFuZS1zdGFjayBkZXBsb3kvc3RhY2tzL3NlbGYt" + "bWFuYWdlZCBcCiAgLS1jb21wdXRlLXBsYW5lLXN0YWNrIGRlcGxveS9zdGFja3MvbnZjZi1jb21w" + "dXRlLXBsYW5lIFwKICAtLWVudiA8ZW52PiBcCiAgLS1wbGFpbiBcCiAgLS1jb250cm9sLXBsYW5l" + "LWNvbnRleHQgPGNvbnRyb2wtcGxhbmUtY29udGV4dD4gXAogIC0tY29tcHV0ZS1wbGFuZS1jb250" + "ZXh0IDxjb21wdXRlLXBsYW5lLWNvbnRleHQ+IFwKICAtLWljbXMtdXJsIDxjb21wdXRlLXJlYWNo" + - "YWJsZS1pY21zLXVybD4gXAogIGRvd24gXAogIC0tY2x1c3Rlci1uYW1lIDxjb21wdXRlLXBsYW5l" + - "LWNsdXN0ZXItbmFtZT4gXAogIC0tbmNhLWlkIDxuY2EtaWQ+CmBgYAoKUmVwZWF0IGBkb3duYCBm" + - "b3IgZWFjaCBjb21wdXRlIGNsdXN0ZXIuIEVhY2ggcnVuIGRlc3Ryb3lzIHRoYXQgY29tcHV0ZSBw" + - "bGFuZSBhbmQKdW5yZWdpc3RlcnMgaXRzIElDTVMgcm93LiBJdCByZW1vdmVzIHRoZSBjb250cm9s" + - "IHBsYW5lIG9ubHkgYWZ0ZXIgbm8gY2x1c3RlcgpyZWdpc3RyYXRpb25zIHJlbWFpbi4KUEsHCJZj" + - "vFkSMAAAEjAAAFBLAwQUAAgAAAAAACEAAAAAAAAAAAAAAAAAOwAJAGRhdGEvbnZjZi1zZWxmLW1h" + - "bmFnZWQtaW5zdGFsbGF0aW9uL3JlZmVyZW5jZXMvZGVidWdnaW5nLm1kVVQFAAEAps4SIyBEZWJ1" + - "Z2dpbmcgUmVmZXJlbmNlCgpSZWNpcGVzIGZvciBkaWFnbm9zaW5nIGFuZCBmaXhpbmcgY29tbW9u" + - "IE5WQ0Ygc2VsZi1tYW5hZ2VkIHN0YWNrIGZhaWx1cmVzLgoKIyMgUXVpY2sgU3RhdHVzIENvbW1h" + - "bmRzCgpgYGBiYXNoCiMgQWxsIHBvZHMgYWNyb3NzIGFsbCBuYW1lc3BhY2VzCmt1YmVjdGwgZ2V0" + - "IHBvZHMgLUEgLW8gd2lkZQoKIyBQb2RzIGluIGEgc3BlY2lmaWMgbmFtZXNwYWNlCmt1YmVjdGwg" + - "Z2V0IHBvZHMgLW4gPG5hbWVzcGFjZT4KCiMgQWxsIGhlbG0gcmVsZWFzZXMKaGVsbSBsaXN0IC1B" + - "CgojIFJlY2VudCBldmVudHMgKG1vc3QgdXNlZnVsIGZvciBkaWFnbm9zaW5nIGZhaWx1cmVzKQpr" + - "dWJlY3RsIGdldCBldmVudHMgLW4gPG5hbWVzcGFjZT4gLS1zb3J0LWJ5PScubGFzdFRpbWVzdGFt" + - "cCcKCiMgRGVzY3JpYmUgYSBzcGVjaWZpYyBwb2QgKHNob3dzIGV2ZW50cywgY29uZGl0aW9ucywg" + - "dm9sdW1lcykKa3ViZWN0bCBkZXNjcmliZSBwb2QgLW4gPG5hbWVzcGFjZT4gPHBvZC1uYW1lPgpg" + - "YGAKCiMjIEZhaWx1cmU6IEltYWdlUHVsbEJhY2tPZmYKCiMjIyBTeW1wdG9tcwoKYGBgCk5BTUUg" + - "ICAgICAgICAgIFJFQURZICAgU1RBVFVTICAgICAgICAgICAgIFJFU1RBUlRTICAgQUdFCmNhc3Nh" + - "bmRyYS0wICAgIDAvMSAgICAgSW1hZ2VQdWxsQmFja09mZiAgIDAgICAgICAgICAgNW0KYGBgCgpF" + - "dmVudHMgc2hvdzoKYGBgCkZhaWxlZCB0byBwdWxsIGltYWdlICJudmNyLmlvLy4uLi9pbWFnZTp0" + - "YWciOiA0MDEgVW5hdXRob3JpemVkCmBgYAoKIyMjIERpYWdub3NpcwoKYGBgYmFzaAojIENoZWNr" + - "IHdoYXQgaW1hZ2UgaXMgZmFpbGluZwprdWJlY3RsIGRlc2NyaWJlIHBvZCAtbiA8bmFtZXNwYWNl" + - "PiA8cG9kLW5hbWU+IHwgZ3JlcCAtQTUgIkV2ZW50czoiCgojIENoZWNrIGlmIHB1bGwgc2VjcmV0" + - "IGV4aXN0cyBpbiB0aGUgbmFtZXNwYWNlCmt1YmVjdGwgZ2V0IHNlY3JldCBudmNyLWNyZWRzIC1u" + - "IDxuYW1lc3BhY2U+CgojIENoZWNrIGlmIHRoZSBwb2Qgc3BlYyBoYXMgaW1hZ2VQdWxsU2VjcmV0" + - "cwprdWJlY3RsIGdldCBwb2QgLW4gPG5hbWVzcGFjZT4gPHBvZC1uYW1lPiAtbyBqc29ucGF0aD0n" + - "ey5zcGVjLmltYWdlUHVsbFNlY3JldHN9JwoKIyBDaGVjayBpZiB0aGUgU2VydmljZUFjY291bnQg" + - "aGFzIGltYWdlUHVsbFNlY3JldHMKa3ViZWN0bCBnZXQgc2EgPHNhLW5hbWU+IC1uIDxuYW1lc3Bh" + - "Y2U+IC1vIGpzb25wYXRoPSd7LmltYWdlUHVsbFNlY3JldHN9JwpgYGAKCiMjIyBGaXhlcwoKMS4g" + - "KipTZWNyZXQgbWlzc2luZyBpbiBuYW1lc3BhY2UqKjogQ3JlYXRlIGl0CiAgIGBgYGJhc2gKICAg" + - "a3ViZWN0bCBjcmVhdGUgc2VjcmV0IGRvY2tlci1yZWdpc3RyeSBudmNyLWNyZWRzIFwKICAgICAt" + - "LWRvY2tlci1zZXJ2ZXI9bnZjci5pbyBcCiAgICAgLS1kb2NrZXItdXNlcm5hbWU9JyRvYXV0aHRv" + - "a2VuJyBcCiAgICAgLS1kb2NrZXItcGFzc3dvcmQ9IiROR0NfQVBJX0tFWSIgXAogICAgIC0tbmFt" + - "ZXNwYWNlPTxuYW1lc3BhY2U+IFwKICAgICAtLWRyeS1ydW49Y2xpZW50IC1vIHlhbWwgfCBrdWJl" + - "Y3RsIGFwcGx5IC1mIC0KICAgYGBgCgoyLiAqKlNlY3JldCBleGlzdHMgYnV0IHBvZCBkb2Vzbid0" + - "IHJlZmVyZW5jZSBpdCoqOiBUaGUgY2hhcnQgbmVlZHMgYGltYWdlUHVsbFNlY3JldHNgIGNvbmZp" + - "Z3VyZWQgdmlhIGhlbG1maWxlIHZhbHVlcy4gU2VlIFtwdWxsLXNlY3JldHMubWRdKHB1bGwtc2Vj" + - "cmV0cy5tZCkuCgozLiAqKkNoYXJ0IGRvZXNuJ3Qgc3VwcG9ydCBpbWFnZVB1bGxTZWNyZXRzKiog" + - "KG9wZW5iYW8sIGludm9jYXRpb24tc2VydmljZSwgZXNzLWFwaSwgbm90YXJ5LXNlcnZpY2UpOiBQ" + - "YXRjaCBTZXJ2aWNlQWNjb3VudHMgYW5kIHJlc3RhcnQgcG9kcy4gU2VlIFtwdWxsLXNlY3JldHMu" + - "bWRdKHB1bGwtc2VjcmV0cy5tZCkuCgo0LiAqKldyb25nIGNyZWRlbnRpYWxzIGluIHNlY3JldCoq" + - "OiBEZWxldGUgYW5kIHJlY3JlYXRlCiAgIGBgYGJhc2gKICAga3ViZWN0bCBkZWxldGUgc2VjcmV0" + - "IG52Y3ItY3JlZHMgLW4gPG5hbWVzcGFjZT4KICAgIyBSZWNyZWF0ZSB3aXRoIGNvcnJlY3QgY3Jl" + - "ZGVudGlhbHMKICAgYGBgCgojIyBGYWlsdXJlOiBJbml0OjAvMSBTdHVjayAoVmF1bHQgQWdlbnQp" + - "CgojIyMgU3ltcHRvbXMKClNlcnZpY2UgcG9kcyBzdHVjayBpbiBgSW5pdDowLzFgIGZvciBtaW51" + - "dGVzOgpgYGAKTkFNRSAgICAgICAgICAgICAgICAgICAgICAgIFJFQURZICAgU1RBVFVTICAgICBS" + - "RVNUQVJUUyAgIEFHRQpudmNmLWFwaS03ZjRjNzZmNzg4LTQ0dmx0ICAwLzIgICAgIEluaXQ6MC8x" + - "ICAgMCAgICAgICAgICAxMG0KYGBgCgojIyMgRGlhZ25vc2lzCgpUaGUgaW5pdCBjb250YWluZXIg" + - "aXMgdGhlIHZhdWx0LWFnZW50LWluaXQgaW5qZWN0b3Igd2FpdGluZyBmb3IgT3BlbkJhby4KCmBg" + - "YGJhc2gKIyBDaGVjayBPcGVuQmFvIHBvZHMKa3ViZWN0bCBnZXQgcG9kcyAtbiB2YXVsdC1zeXN0" + - "ZW0KCiMgQ2hlY2sgaWYgT3BlbkJhbyBtaWdyYXRpb24gam9iIHJhbgprdWJlY3RsIGdldCBqb2Jz" + - "IC1uIHZhdWx0LXN5c3RlbQoKIyBDaGVjayBPcGVuQmFvIHBvZCBsb2dzCmt1YmVjdGwgbG9ncyAt" + - "biB2YXVsdC1zeXN0ZW0gb3BlbmJhby1zZXJ2ZXItMCAtYyBvcGVuYmFvCgojIENoZWNrIGluaXQg" + - "Y29udGFpbmVyIGxvZ3Mgb24gdGhlIHN0dWNrIHBvZAprdWJlY3RsIGxvZ3MgLW4gPG5hbWVzcGFj" + - "ZT4gPHBvZC1uYW1lPiAtYyB2YXVsdC1hZ2VudC1pbml0CmBgYAoKIyMjIEZpeGVzCgoxLiAqKk9w" + - "ZW5CYW8gcG9kcyBub3QgcnVubmluZyoqOiBDaGVjayB0aGVpciBldmVudHMgZm9yIGltYWdlIHB1" + - "bGwgaXNzdWVzLCByZXNvdXJjZSBpc3N1ZXMsIGV0Yy4KCjIuICoqT3BlbkJhbyBtaWdyYXRpb24g" + - "am9iIGRpZG4ndCBydW4qKjogVGhpcyBoYXBwZW5zIHdoZW4gYGhlbG1maWxlIHN5bmNgIHdhcyBp" + - "bnRlcnJ1cHRlZC4gRGVzdHJveSBhbmQgcmUtc3luYyBvcGVuYmFvOgogICBgYGBiYXNoCiAgIEhF" + - "TE1GSUxFX0VOVj08ZW52PiBoZWxtZmlsZSAtLXNlbGVjdG9yIG5hbWU9b3BlbmJhby1zZXJ2ZXIg" + - "ZGVzdHJveQogICBrdWJlY3RsIGRlbGV0ZSBuYW1lc3BhY2UgdmF1bHQtc3lzdGVtCiAgIGt1YmVj" + - "dGwgY3JlYXRlIG5hbWVzcGFjZSB2YXVsdC1zeXN0ZW0KICAgIyBSZS1jcmVhdGUgcHVsbCBzZWNy" + - "ZXQgaWYgbmVlZGVkCiAgIEhFTE1GSUxFX0VOVj08ZW52PiBoZWxtZmlsZSAtLXNlbGVjdG9yIG5h" + - "bWU9b3BlbmJhby1zZXJ2ZXIgc3luYwogICBgYGAKCjMuICoqT3BlbkJhbyBwb2RzIHJ1bm5pbmcg" + - "YnV0IG5vdCBpbml0aWFsaXplZCoqOiBDaGVjayB1bnNlYWwgc3RhdHVzOgogICBgYGBiYXNoCiAg" + - "IGt1YmVjdGwgZXhlYyAtbiB2YXVsdC1zeXN0ZW0gb3BlbmJhby1zZXJ2ZXItMCAtYyBvcGVuYmFv" + - "IC0tIGJhbyBzdGF0dXMKICAgYGBgCgo0LiAqKmB2YXVsdC1hZ2VudC1pbml0YCBsb2dzIGBhdXRo" + - "L2p3dC9sb2dpbmAgLT4gYDQwMCAuLi4gbm8ga25vd24ga2V5IHN1Y2Nlc3NmdWxseSB2YWxpZGF0" + - "ZWQgdGhlIHRva2VuIHNpZ25hdHVyZWAqKgogICAoY29tbW9uIG9uIEFLUywgYW5kIG9uIGFueSBj" + - "bHVzdGVyIHdob3NlIE9JREMgaXNzdWVyIHB1Ymxpc2hlcyBhIHJvdGF0aW5nIG11bHRpLWtleSBK" + - "V0tTKToKICAgdGhlIE9wZW5CYW8gYGF1dGgvand0YCBtZXRob2Qgd2FzIGNvbmZpZ3VyZWQgd2l0" + - "aCBhIHNpbmdsZSBzdGF0aWMgbW91bnRlZCBwdWJsaWMga2V5CiAgIChgand0X3ZhbGlkYXRpb25f" + - "cHVia2V5c2ApIGluc3RlYWQgb2YgdGhlIGlzc3VlcidzIGxpdmUgSldLUywgc28gaXQgY2Fubm90" + - "IHZhbGlkYXRlIHRoZQogICBjbHVzdGVyLXNpZ25lZCBTZXJ2aWNlQWNjb3VudCB0b2tlbnMgdGhl" + - "IHZhdWx0LWFnZW50cyBwcmVzZW50LiBFdmVyeSBzZXJ2aWNlJ3MKICAgYHZhdWx0LWFnZW50LWlu" + - "aXRgIHRoZW4gbG9vcHMgb24gdGhhdCA0MDAgYW5kIHRoZSBwb2QgbmV2ZXIgbGVhdmVzIGBJbml0" + - "OjAvMWAuIFRoaXMgaXMgdGhlCiAgIGJlaGF2aW9yIG9mIHRoZSBiYXNlIGRlZmF1bHQgYG9wZW5i" + - "YW8ubWlncmF0aW9ucy5pc3N1ZXJEaXNjb3ZlcnkuZW5hYmxlZDogZmFsc2VgOyB0aGUKICAgbWln" + - "cmF0aW9uIGxvZyBzaG93cyBgT0lEQyBpc3N1ZXIgZGlzY292ZXJ5IGlzIGRpc2FibGVkLiBVc2lu" + - "ZyBTZXJ2aWNlQWNjb3VudCBpc3N1ZXIgYW5kCiAgIG1vdW50ZWQgcHVibGljIGtleSBmYWxsYmFj" + - "a2AuIEVuYWJsZSBpc3N1ZXIgZGlzY292ZXJ5IHNvIHRoZSBtaWdyYXRpb24gdXNlcyB0aGUgbGl2" + - "ZSBKV0tTLAogICB0aGVuIHJlLXJ1biBpdDoKICAgYGBgYmFzaAogICAjIEluIHlvdXIgZW52IHZh" + - "bHVlcyAoZS5nLiBlbnZpcm9ubWVudHMvPGVudj4ueWFtbCksIHNldDoKICAgIyAgIG9wZW5iYW86" + - "CiAgICMgICAgIG1pZ3JhdGlvbnM6CiAgICMgICAgICAgaXNzdWVyRGlzY292ZXJ5OgogICAjICAg" + - "ICAgICAgZW5hYmxlZDogdHJ1ZQogICBrdWJlY3RsIGRlbGV0ZSBqb2IgLW4gdmF1bHQtc3lzdGVt" + - "IG9wZW5iYW8tc2VydmVyLW1pZ3JhdGlvbnMKICAgSEVMTUZJTEVfRU5WPTxlbnY+IGhlbG1maWxl" + - "IC0tc2VsZWN0b3IgbmFtZT1vcGVuYmFvLXNlcnZlciBzeW5jCiAgIGBgYAogICBUaGUgbWlncmF0" + - "aW9uIGxvZyBzaG91bGQgdGhlbiBzaG93IGBSZWNlaXZlZCBkaXNjb3ZlcnkgZG9jdW1lbnQgZnJv" + - "bQogICAuLi4vLndlbGwta25vd24vb3BlbmlkLWNvbmZpZ3VyYXRpb25gIGFuZCBgRmluYWwgT3Bl" + - "bkJhbyBKV1QgSldLUyBVUkwgc2V0IHRvOgogICAuLi4vb3BlbmlkL3YxL2p3a3NgLCBhbmQgdGhl" + - "IHNlcnZpY2UgcG9kcyBhdXRoZW50aWNhdGUgYW5kIHJlYWNoIFJlYWR5IHdpdGhpbiB+MSBtaW4u" + - "CiAgIEFLUyBjbHVzdGVycyB3aXRoIHRoZSBjbHVzdGVyIE9JREMgaXNzdWVyIGVuYWJsZWQgKHRo" + - "ZSBgYWtzLWNsdXN0ZXJgIGRlZmF1bHQpIGFsd2F5cyBuZWVkCiAgIHRoaXMgYmVjYXVzZSB0aGUg" + - "c3RhdGljLXB1YmtleSBmYWxsYmFjayBjYW5ub3QgbWF0Y2ggdGhlIGlzc3VlcidzIHJvdGF0aW5n" + - "IHNpZ25pbmcga2V5cy4KCiMjIEZhaWx1cmU6IE9PTUtpbGxlZCBvbiBDYXNzYW5kcmEKCiMjIyBT" + - "eW1wdG9tcwoKYGBgCk5BTUUgICAgICAgICAgUkVBRFkgICBTVEFUVVMgICAgUkVTVEFSVFMgICBB" + - "R0UKY2Fzc2FuZHJhLTAgICAwLzEgICAgIE9PTUtpbGxlZCAgMyAgICAgICAgIDEwbQpgYGAKCiMj" + - "IyBEaWFnbm9zaXMKCmBgYGJhc2gKa3ViZWN0bCBkZXNjcmliZSBwb2QgLW4gY2Fzc2FuZHJhLXN5" + - "c3RlbSBjYXNzYW5kcmEtMCB8IGdyZXAgLUEzICJMYXN0IFN0YXRlIgpgYGAKCiMjIyBGaXgKCk92" + - "ZXJyaWRlIENhc3NhbmRyYSByZXNvdXJjZXMgdmlhIGhlbG1maWxlIHZhbHVlcy4gU2VlIEV4YW1w" + - "bGUgMSBpbgpbZXhhbXBsZXMubWRdKC4uL2V4YW1wbGVzLm1kKS4KCmBgYHlhbWwKLSBjYXNzYW5k" + - "cmE6CiAgICByZXNvdXJjZXM6CiAgICAgIGxpbWl0czoKICAgICAgICBjcHU6ICI4IgogICAgICAg" + - "IG1lbW9yeTogODE5Mk1pCiAgICAgIHJlcXVlc3RzOgogICAgICAgIGNwdTogIjIiCiAgICAgICAg" + - "bWVtb3J5OiA0MDk2TWkKYGBgCgpOb3RlOiBgcmVzb3VyY2VQcmVzZXRgIGlzIG5vdCBhdmFpbGFi" + - "bGUgaW4gdGhlIE5WQ0YgY2Fzc2FuZHJhIHdyYXBwZXIgY2hhcnQuIFVzZSBleHBsaWNpdCBgcmVz" + - "b3VyY2VzYC4KCiMjIEZhaWx1cmU6IFBvZHMgU3R1Y2sgaW4gUGVuZGluZwoKIyMjIFN5bXB0b21z" + - "CgpgYGAKTkFNRSAgICAgICAgICBSRUFEWSAgIFNUQVRVUyAgICBSRVNUQVJUUyAgIEFHRQpjYXNz" + - "YW5kcmEtMCAgIDAvMSAgICAgUGVuZGluZyAgIDAgICAgICAgICAgMTBtCmBgYAoKIyMjIERpYWdu" + - "b3NpcwoKYGBgYmFzaAojIENoZWNrIGV2ZW50cyBmb3Igc2NoZWR1bGluZyBmYWlsdXJlcwprdWJl" + - "Y3RsIGRlc2NyaWJlIHBvZCAtbiA8bmFtZXNwYWNlPiA8cG9kLW5hbWU+CgojIENvbW1vbiBjYXVz" + - "ZXM6CiMgLSAiMC8xMiBub2RlcyBhcmUgYXZhaWxhYmxlOiAxMiBub2RlKHMpIGRpZG4ndCBtYXRj" + - "aCBQb2QncyBub2RlIGFmZmluaXR5IgojIC0gIjAvMTIgbm9kZXMgYXJlIGF2YWlsYWJsZTogMTIg" + - "SW5zdWZmaWNpZW50IG1lbW9yeSIKIyAtICJwZXJzaXN0ZW50dm9sdW1lY2xhaW0gbm90IGZvdW5k" + - "IgpgYGAKCiMjIyBGaXhlcwoKMS4gKipOb2RlIHNlbGVjdG9yIG1pc21hdGNoKio6IENoZWNrIGBu" + - "b2RlU2VsZWN0b3JzYCBpbiBlbnZpcm9ubWVudCBmaWxlCiAgIGBgYGJhc2gKICAga3ViZWN0bCBn" + - "ZXQgbm9kZXMgLS1zaG93LWxhYmVscyB8IGdyZXAgbnZjZgogICBgYGAKCjIuICoqU3RvcmFnZSBj" + - "bGFzcyBub3QgZm91bmQqKjogQ2hlY2sgc3RvcmFnZSBjbGFzcyBleGlzdHMKICAgYGBgYmFzaAog" + - "ICBrdWJlY3RsIGdldCBzdG9yYWdlY2xhc3MKICAgYGBgCgozLiAqKkluc3VmZmljaWVudCByZXNv" + - "dXJjZXMqKjogQ2hlY2sgbm9kZSBjYXBhY2l0eQogICBgYGBiYXNoCiAgIGt1YmVjdGwgZGVzY3Jp" + - "YmUgbm9kZSA8bm9kZS1uYW1lPiB8IGdyZXAgLUE1ICJBbGxvY2F0ZWQgcmVzb3VyY2VzIgogICBg" + - "YGAKCiMjIEZhaWx1cmU6IEhlbG0gUmVsZWFzZSBpbiBGYWlsZWQgU3RhdGUKCiMjIyBTeW1wdG9t" + - "cwoKYGBgYmFzaApoZWxtIGxpc3QgLUEKIyBTaG93cyByZWxlYXNlIHdpdGggU1RBVFVTOiBmYWls" + - "ZWQKYGBgCgpSZS1ydW5uaW5nIGBoZWxtZmlsZSBzeW5jYCBhcHBlYXJzIHRvIHN1Y2NlZWQgYnV0" + - "IHNlcnZpY2VzIGRvbid0IHdvcmsgKG1pZ3JhdGlvbnMgc2tpcHBlZCkuCgojIyMgRGlhZ25vc2lz" + - "CgpgYGBiYXNoCmhlbG0gaGlzdG9yeSA8cmVsZWFzZS1uYW1lPiAtbiA8bmFtZXNwYWNlPgpgYGAK" + - "CiMjIyBGaXgKCk11c3QgZGVzdHJveSB0aGUgZmFpbGVkIHJlbGVhc2UgYW5kIHJlLXN5bmMgKG5v" + - "dCBqdXN0IGFwcGx5KToKCmBgYGJhc2gKSEVMTUZJTEVfRU5WPTxlbnY+IGhlbG1maWxlIC0tc2Vs" + - "ZWN0b3IgbmFtZT08cmVsZWFzZT4gZGVzdHJveQojIElmIG5hbWVzcGFjZSBuZWVkcyBjbGVhbnVw" + - "OgprdWJlY3RsIGRlbGV0ZSBuYW1lc3BhY2UgPG5hbWVzcGFjZT4Ka3ViZWN0bCBjcmVhdGUgbmFt" + - "ZXNwYWNlIDxuYW1lc3BhY2U+CiMgUmUtY3JlYXRlIHB1bGwgc2VjcmV0IGlmIG5lZWRlZApIRUxN" + - "RklMRV9FTlY9PGVudj4gaGVsbWZpbGUgLS1zZWxlY3RvciBuYW1lPTxyZWxlYXNlPiBzeW5jCmBg" + - "YAoKIyMgRmFpbHVyZTogQWNjb3VudCBCb290c3RyYXAgSm9iIEZhaWxlZAoKIyMjIFN5bXB0b21z" + - "CgpTZXJ2aWNlcyBkZXBsb3kgYnV0IGZ1bmN0aW9ucyBjYW4ndCBiZSBjcmVhdGVkLiBFdmVudHMg" + - "c2hvdyBib290c3RyYXAgam9iIGZhaWx1cmUuCgojIyMgRGlhZ25vc2lzCgpgYGBiYXNoCiMgQ2hl" + - "Y2sgYm9vdHN0cmFwIGpvYiBzdGF0dXMKa3ViZWN0bCBnZXQgam9icyAtbiBudmNmCgojIEdldCBs" + - "b2dzIChqb2IgYXV0by1kZWxldGVzIGFmdGVyIH41IG1pbnV0ZXMpCmt1YmVjdGwgbG9ncyBqb2Iv" + - "bnZjZi1hcGktYWNjb3VudC1ib290c3RyYXAgLW4gbnZjZgoKIyBDaGVjayBBUEkgbG9ncwprdWJl" + - "Y3RsIGxvZ3MgLW4gbnZjZiAtbCBhcHAua3ViZXJuZXRlcy5pby9uYW1lPW52Y2YtYXBpIC0tdGFp" + - "bD0xMDAKYGBgCgojIyMgQ29tbW9uIENhdXNlcwoKMS4gKipXcm9uZyBiYXNlNjQgY3JlZGVudGlh" + - "bHMqKjogQ3JlZGVudGlhbHMgaW4gYHNlY3JldHMvPGVudj4tc2VjcmV0cy55YW1sYCBtdXN0IGJl" + - "IGAkb2F1dGh0b2tlbjpBUElfS0VZYCBiYXNlNjQtZW5jb2RlZCwgbm90IGp1c3QgdGhlIEFQSSBr" + - "ZXkKICAgYGBgYmFzaAogICAjIFZlcmlmeSB5b3VyIGVuY29kZWQgY3JlZGVudGlhbAogICBlY2hv" + - "ICdZT1VSX0JBU0U2NF9TVFJJTkcnIHwgYmFzZTY0IC1kCiAgICMgU2hvdWxkIG91dHB1dDogJG9h" + - "dXRodG9rZW46bnZhcGkteHh4eHgKICAgYGBgCgoyLiAqKlJlZ2lzdHJ5IHVucmVhY2hhYmxlKio6" + - "IEFQSSBjYW4ndCByZWFjaCB0aGUgcmVnaXN0cnkgc3BlY2lmaWVkIGluIGBhY2NvdW50Qm9vdHN0" + - "cmFwLnJlZ2lzdHJ5Q3JlZGVudGlhbHNgCgojIyMgRml4CgpGaXggY3JlZGVudGlhbHMgaW4gc2Vj" + - "cmV0cyBmaWxlLCB0aGVuIHJlY292ZXIgc2VydmljZXMgd2l0aG91dCBkZXN0cm95aW5nIGRlcGVu" + - "ZGVuY2llczoKCmBgYGJhc2gKSEVMTUZJTEVfRU5WPTxlbnY+IGhlbG1maWxlIC0tc2VsZWN0b3Ig" + - "cmVsZWFzZS1ncm91cD1zZXJ2aWNlcyBkZXN0cm95Cmt1YmVjdGwgZGVsZXRlIG5hbWVzcGFjZSBu" + - "dmNmIGFwaS1rZXlzIGVzcyBzaXMgLS1pZ25vcmUtbm90LWZvdW5kCmt1YmVjdGwgY3JlYXRlIG5h" + - "bWVzcGFjZSBudmNmICYmIGt1YmVjdGwgY3JlYXRlIG5hbWVzcGFjZSBhcGkta2V5cyAmJiBcCiAg" + - "a3ViZWN0bCBjcmVhdGUgbmFtZXNwYWNlIGVzcyAmJiBrdWJlY3RsIGNyZWF0ZSBuYW1lc3BhY2Ug" + - "c2lzCiMgUmUtY3JlYXRlIHB1bGwgc2VjcmV0cyBpZiBuZWVkZWQKSEVMTUZJTEVfRU5WPTxlbnY+" + - "IGhlbG1maWxlIC0tc2VsZWN0b3IgcmVsZWFzZS1ncm91cD1zZXJ2aWNlcyBzeW5jCmBgYAoKIyMg" + - "RmFpbHVyZTogTlZDQSBDbGVhbnVwIFN0dWNrIChGaW5hbGl6ZXJzKQoKIyMjIFN5bXB0b21zCgpD" + - "b21wdXRlLXBsYW5lIGNsZWFudXAgaGFuZ3MuIE5hbWVzcGFjZXMKc3R1Y2sgaW4gYFRlcm1pbmF0" + - "aW5nYDoKCmBgYGJhc2gKa3ViZWN0bCBnZXQgbnMKIyBudmNhLW9wZXJhdG9yICAgIFRlcm1pbmF0" + - "aW5nICAgMTBtCiMgbnZjZi1iYWNrZW5kICAgICBUZXJtaW5hdGluZyAgIDEwbQpgYGAKCiMjIyBG" + - "aXgKClJ1biB0aGlzIG9ubHkgYWdhaW5zdCB0aGUgY29tcHV0ZSBjb250ZXh0LCBhZnRlciB0aGUg" + - "bm9ybWFsIGNvbXB1dGUtcGxhbmUKdGVhcmRvd24gaGFzIGZhaWxlZC4gUmVtb3ZlIGZpbmFsaXpl" + - "cnMgZnJvbSBOVkNGQmFja2VuZCBjdXN0b20gcmVzb3VyY2VzIGFuZApmb3JjZS1kZWxldGUgc3R1" + - "Y2sgbmFtZXNwYWNlczoKCmBgYGJhc2gKZXhwb3J0IENPTVBVVEVfQ09OVEVYVD08Y29tcHV0ZS1w" + - "bGFuZS1jb250ZXh0PgoKIyBSZW1vdmUgZmluYWxpemVycyBmcm9tIE5WQ0ZCYWNrZW5kIHJlc291" + - "cmNlcwprdWJlY3RsIC0tY29udGV4dCAiJENPTVBVVEVfQ09OVEVYVCIgZ2V0IG52Y2ZiYWNrZW5k" + - "cyAtQSAtbyBqc29uIHwgXAogIGpxICcuaXRlbXNbXSB8IC5tZXRhZGF0YS5uYW1lc3BhY2UgKyAi" + - "LyIgKyAubWV0YWRhdGEubmFtZScgLXIgfCBcCiAgeGFyZ3MgLUl7fSBzaCAtYyAnY29udGV4dD0i" + - "JDEiOyBucz0iJHsyJSUvKn0iOyBuYW1lPSIkezIjIyovfSI7IGt1YmVjdGwgLS1jb250ZXh0ICIk" + - "Y29udGV4dCIgcGF0Y2ggbnZjZmJhY2tlbmQgIiRuYW1lIiAtbiAiJG5zIiAtLXR5cGU9bWVyZ2Ug" + - "LXAgIntcIm1ldGFkYXRhXCI6e1wiZmluYWxpemVyc1wiOltdfX0iJyBfICIkQ09NUFVURV9DT05U" + - "RVhUIiB7fQoKIyBGb3JjZS1kZWxldGUgc3R1Y2sgbmFtZXNwYWNlcyBieSBjbGVhcmluZyB0aGVp" + - "ciBmaW5hbGl6ZXJzCmZvciBucyBpbiBudmNhLW9wZXJhdG9yIG52Y2YtYmFja2VuZDsgZG8KICBr" + - "dWJlY3RsIC0tY29udGV4dCAiJENPTVBVVEVfQ09OVEVYVCIgZ2V0IG5hbWVzcGFjZSAiJG5zIiAt" + - "byBqc29uIDI+L2Rldi9udWxsIHwgXAogICAganEgJy5zcGVjLmZpbmFsaXplcnMgPSBbXScgfCBc" + - "CiAgICBrdWJlY3RsIC0tY29udGV4dCAiJENPTVBVVEVfQ09OVEVYVCIgcmVwbGFjZSBcCiAgICAg" + - "IC0tcmF3ICIvYXBpL3YxL25hbWVzcGFjZXMvJG5zL2ZpbmFsaXplIiAtZiAtIDI+L2Rldi9udWxs" + - "CmRvbmUKYGBgCgojIyBGYWlsdXJlOiBOVkNBIE9wZXJhdG9yIE1pc3Npbmcgb3IgTm90IFJlYWR5" + - "CgojIyMgU3ltcHRvbXMKCkFmdGVyIGNvbXB1dGUtcGxhbmUgaW5zdGFsbCBjb21wbGV0ZXMsIG5v" + - "IGBudmNhLW9wZXJhdG9yYCBEZXBsb3ltZW50IGV4aXN0cywgb3IKaXQgZXhpc3RzIGJ1dCBwb2Rz" + - "IGFyZSBub3QgcmVhZHk6CgpgYGBiYXNoCmt1YmVjdGwgLS1jb250ZXh0IDxjb21wdXRlLXBsYW5l" + - "LWNvbnRleHQ+IGdldCBkZXBsb3ltZW50IG52Y2Etb3BlcmF0b3IgXAogIC1uIG52Y2Etb3BlcmF0" + - "b3IKa3ViZWN0bCAtLWNvbnRleHQgPGNvbXB1dGUtcGxhbmUtY29udGV4dD4gZ2V0IHBvZHMgLW4g" + - "bnZjYS1vcGVyYXRvcgpgYGAKCiMjIyBEaWFnbm9zaXMgYW5kIEZpeGVzCgpGaXJzdCBpZGVudGlm" + - "eSB3aGV0aGVyIHRoZSBpbnN0YWxsYXRpb24gdXNlZCB0aGUgSGVsbWZpbGUgdmFsdWVzIGZsb3cg" + - "b3IgdGhlCkNMSSBwcm9maWxlIGZsb3cuIFJlLXJ1biBvbmx5IHRoYXQgZmxvdydzIHJlZ2lzdHJh" + - "dGlvbiBhbmQgaW5zdGFsbGF0aW9uIHN0ZXBzCmZyb20gW1NwbGl0IENvbXB1dGUtUGxhbmUgSW5z" + - "dGFsbGF0aW9uXShjb21wdXRlLXBsYW5lLWluc3RhbGxhdGlvbi5tZCkuIERvIG5vdApzdWJzdGl0" + - "dXRlIG9uZSBoYW5kb2ZmIGZvciB0aGUgb3RoZXIuCgpJZiBpbnN0YWxsYXRpb24gc3VjY2VlZHMg" + - "YnV0IHBvZHMgc3RpbGwgZmFpbCwgaW5zcGVjdCB0aGUgY29tcHV0ZSBjb250ZXh0OgoKYGBgYmFz" + - "aAprdWJlY3RsIC0tY29udGV4dCA8Y29tcHV0ZS1wbGFuZS1jb250ZXh0PiBkZXNjcmliZSBkZXBs" + - "b3kgbnZjYS1vcGVyYXRvciBcCiAgLW4gbnZjYS1vcGVyYXRvcgprdWJlY3RsIC0tY29udGV4dCA8" + - "Y29tcHV0ZS1wbGFuZS1jb250ZXh0PiBsb2dzIGRlcGxveW1lbnQvbnZjYS1vcGVyYXRvciBcCiAg" + - "LW4gbnZjYS1vcGVyYXRvciAtLXRhaWw9MjAwCmt1YmVjdGwgLS1jb250ZXh0IDxjb21wdXRlLXBs" + - "YW5lLWNvbnRleHQ+IGdldCBudmNmYmFja2VuZCAtbiBudmNhLW9wZXJhdG9yCmBgYAoKRm9yIHBy" + - "aXZhdGUgcmVnaXN0cnkgZmFpbHVyZXMsIHZlcmlmeSB0aGF0IHRoZSBwdWxsIHNlY3JldCBleGlz" + - "dHMgaW4KYG52Y2Etb3BlcmF0b3JgLiBUaGUgY2hhcnQgYW5kIG9wZXJhdG9yIG1pcnJvciBpdCB0" + - "byBgbnZjYS1zeXN0ZW1gOyBkbyBub3QgdXNlIGEKYnJvYWRlciBtYW51YWwgbmFtZXNwYWNlIGxv" + - "b3AuIFNlZQpbcHVsbC1zZWNyZXRzLm1kXShwdWxsLXNlY3JldHMubWQjY29tcHV0ZS1wbGFuZS1z" + - "ZWNyZXQpLgoKIyMgRmFpbHVyZTogR2F0ZXdheSBFbmRwb2ludCBDaGFuZ2VkCgojIyMgU3ltcHRv" + - "bXMKClJlcXVlc3RzIHRocm91Z2ggdGhlIGNvbmZpZ3VyZWQgcm91dGUgZG9tYWluIGZhaWwgYWZ0" + - "ZXIgdGhlIEdhdGV3YXkgb3IgaXRzIGxvYWQgYmFsYW5jZXIgaXMgcmVwbGFjZWQuIFRoZSBHYXRl" + - "d2F5IHJlcG9ydHMgYSBuZXcgZW5kcG9pbnQuCgojIyMgRGlhZ25vc2lzCgpgYGBiYXNoCkdBVEVX" + - "QVlfQUREUj0kKGt1YmVjdGwgLS1jb250ZXh0IDxjb250cm9sLXBsYW5lLWNvbnRleHQ+IGdldCBn" + - "YXRld2F5IFwKICBudmNmLWdhdGV3YXkgLW4gZW52b3ktZ2F0ZXdheSBcCiAgLW8ganNvbnBhdGg9" + - "J3suc3RhdHVzLmFkZHJlc3Nlc1swXS52YWx1ZX0nKQp0ZXN0IC1uICIkR0FURVdBWV9BRERSIgpk" + - "aWcgK3Nob3J0ICJhcGkuPGRvbWFpbj4iCmN1cmwgLUggIkhvc3Q6IGFwaS48ZG9tYWluPiIgImh0" + - "dHA6Ly8kR0FURVdBWV9BRERSL2hlYWx0aCIKCiMgQ2hlY2sgZGlyZWN0IGFkZHJlc3MgZmllbGRz" + - "IHVzZWQgYnkgYSBzcGxpdCBkZXBsb3ltZW50CmdyZXAgbnZjZk5hdHNTZXJ2aWNlVVJMIGRlcGxv" + - "eS9zdGFja3Mvc2VsZi1tYW5hZ2VkL2Vudmlyb25tZW50cy88ZW52Pi55YW1sCmdyZXAgLUUgJ2lj" + - "bXNTZXJ2aWNlfHJldmFsU2VydmljZXxuYXRzJyBcCiAgZGVwbG95L3N0YWNrcy9udmNmLWNvbXB1" + - "dGUtcGxhbmUvZW52aXJvbm1lbnRzLzxlbnY+LnlhbWwKYGBgCgojIyMgRml4CgpLZWVwIGBnbG9i" + - "YWwuZG9tYWluYCwgcm91dGUgaG9zdG5hbWVzLCBhbmQgSG9zdCBvdmVycmlkZXMgdW5jaGFuZ2Vk" + - "LiBVcGRhdGUgRE5TCm9yIHRoZSBkaXJlY3QgY2xpZW50IGRlc3RpbmF0aW9uLiBGb3Igc3BsaXQg" + - "ZGVwbG95bWVudHMsIHVwZGF0ZSBvbmx5IGRpcmVjdApHYXRld2F5LWFkZHJlc3MgZmllbGRzIGFu" + - "ZCByZWZyZXNoIHJlZ2lzdHJhdGlvbiBhbmQgaW5zdGFsbGF0aW9uIHRocm91Z2ggdGhlCnNhbWUg" + - "c2VsZWN0ZWQgaGFuZG9mZi4gU2VlCltFeGFtcGxlIDRdKC4uL2V4YW1wbGVzLm1kI2V4YW1wbGUt" + - "NC1yZWNvdmVyLWZyb20tYS1nYXRld2F5LWVuZHBvaW50LWNoYW5nZSkuCgojIyBVc2VmdWwgTmFt" + - "ZXNwYWNlLXRvLVNlcnZpY2UgTWFwcGluZwoKUXVpY2sgcmVmZXJlbmNlIGZvciB3aGljaCBzZXJ2" + - "aWNlcyBydW4gaW4gd2hpY2ggbmFtZXNwYWNlOgoKfCBOYW1lc3BhY2UgfCBTZXJ2aWNlcyB8Cnwt" + - "LS0tLS0tLS0tLXwtLS0tLS0tLS0tfAp8IG5hdHMtc3lzdGVtIHwgbmF0cyB8CnwgY2Fzc2FuZHJh" + - "LXN5c3RlbSB8IGNhc3NhbmRyYSB8CnwgdmF1bHQtc3lzdGVtIHwgb3BlbmJhby1zZXJ2ZXIgfAp8" + - "IG52Y2YgfCBhcGksIGludm9jYXRpb24tc2VydmljZSwgZ3JwYy1wcm94eSwgbm90YXJ5LXNlcnZp" + - "Y2UsIHJldmFsLCBsbG0tcmVxdWVzdC1yb3V0ZXIsIGxsbS1hcGktZ2F0ZXdheSB8CnwgYXBpLWtl" + - "eXMgfCBhcGkta2V5cywgYWRtaW4taXNzdWVyLXByb3h5IHwKfCBlc3MgfCBlc3MtYXBpIHwKfCBz" + - "aXMgfCBzaXMgfAp8IGVudm95LWdhdGV3YXktc3lzdGVtIHwgZW52b3kgZ2F0ZXdheSAoaW5ncmVz" + - "cyBjb250cm9sbGVyKSB8CnwgZW52b3ktZ2F0ZXdheSB8IGdhdGV3YXkgcmVzb3VyY2UgKyByb3V0" + - "ZXMgfApQSwcIVj5nkJUwAACVMAAAUEsDBBQACAAAAAAAIQAAAAAAAAAAAAAAAABEAAkAZGF0YS9u" + - "dmNmLXNlbGYtbWFuYWdlZC1pbnN0YWxsYXRpb24vcmVmZXJlbmNlcy9oZWxtZmlsZS1zdHJ1Y3R1" + - "cmUubWRVVAUAAQCmzhIjIEhlbG1maWxlIFN0cnVjdHVyZSBSZWZlcmVuY2UKCiMjIERpcmVjdG9y" + - "eSBMYXlvdXQKCmBgYApudmNmLXNlbGYtbWFuYWdlZC1zdGFjay8KfC0tIGhlbG1maWxlLmQvCnwg" + - "ICB8LS0gMDEtZGVwZW5kZW5jaWVzLnlhbWwuZ290bXBsICAjIE5BVFMsIENhc3NhbmRyYSwgT3Bl" + - "bkJhbwp8ICAgfC0tIDAyLWNvcmUueWFtbC5nb3RtcGwgICAgICAgICAgIyBOVkNGIHNlcnZpY2Vz" + - "ICsgaW5ncmVzcwp8ICAgYC0tIDAzLW9ic2VydmFiaWxpdHkueWFtbC5nb3RtcGwgIyBPYnNlcnZh" + - "YmlsaXR5IHN0YWNrIChvcHRpb25hbCkKfC0tIGVudmlyb25tZW50cy8KfCAgIHwtLSBiYXNlLnlh" + - "bWwgICAgICAgICAgICAgICAgICAgICMgRGVmYXVsdCB2YWx1ZXMgKGFsbCBlbnZpcm9ubWVudHMp" + - "CnwgICBgLS0gPGVudi1uYW1lPi55YW1sICAgICAgICAgICAgICAjIFBlci1lbnZpcm9ubWVudCBv" + - "dmVycmlkZXMKfC0tIHNlY3JldHMvCnwgICBgLS0gPGVudi1uYW1lPi1zZWNyZXRzLnlhbWwgICAg" + - "ICAjIFNlbnNpdGl2ZSB2YWx1ZXMgKHJlZ2lzdHJ5IGNyZWRzLCBwYXNzd29yZHMpCmAtLSBnbG9i" + - "YWwueWFtbC5nb3RtcGwgICAgICAgICAgICAgICAjIEdvIHRlbXBsYXRlIHRoYXQgY29uc3RydWN0" + - "cyBwZXItY2hhcnQgdmFsdWVzCgpudmNmLWNvbXB1dGUtcGxhbmUtc3RhY2svCnwtLSBoZWxtZmls" + - "ZS5kLwp8ICAgfC0tIDAxLWRlcGVuZGVuY2llcy55YW1sLmdvdG1wbCAgIyBDb21wdXRlIHBsYW5l" + - "IGRlcGVuZGVuY3kgY29tcG9uZW50cwp8ICAgYC0tIDAyLW52Y2EueWFtbC5nb3RtcGwgICAgICAg" + - "ICAgIyBudmNhLW9wZXJhdG9yIGNoYXJ0IGFuZCBudmNhIGNvbmZpZ3VyYXRpb24KfC0tIGVudmly" + - "b25tZW50cy8KfCAgIHwtLSBiYXNlLnlhbWwgICAgICAgICAgICAgICAgICAgICMgRGVmYXVsdCB2" + - "YWx1ZXMgKGFsbCBlbnZpcm9ubWVudHMpCnwgICBgLS0gPGVudi1uYW1lPi55YW1sICAgICAgICAg" + - "ICAgICAjIFBlci1lbnZpcm9ubWVudCBvdmVycmlkZXMKYC0tIGdsb2JhbC55YW1sLmdvdG1wbCAg" + - "ICAgICAgICAgICAgICMgR28gdGVtcGxhdGUgdGhhdCBjb25zdHJ1Y3RzIHBlci1jaGFydCB2YWx1" + - "ZXMKYGBgCgpUaGVzZSBzdGFja3MgaGF2ZSBzZXBhcmF0ZSBlbnZpcm9ubWVudHMgYW5kIGNsdXN0" + - "ZXIgY29udGV4dHMuIFRoZSBIZWxtZmlsZQp2YWx1ZXMgZmxvdyBhdXRob3JzIGJvdGggZW52aXJv" + - "bm1lbnQgZmlsZXMuIFRoZSBDTEkgcHJvZmlsZSBmbG93IGluc3RlYWQgdXNlcwp0aGUgQ0xJLWdl" + - "bmVyYXRlZCBjb250cm9sLXBsYW5lIHByb2ZpbGUgYXMgaXRzIGVuZHBvaW50IHNvdXJjZS4gRG8g" + - "bm90IG1peCB0aGUKaGFuZG9mZnMuIFNlZSBbU3BsaXQgQ29tcHV0ZS1QbGFuZSBJbnN0YWxsYXRp" + - "b25dKGNvbXB1dGUtcGxhbmUtaW5zdGFsbGF0aW9uLm1kKS4KCiMjIEdvdG1wbCBGaWxlcyBhbmQg" + - "VGhlaXIgUmVsZWFzZXMKCiMjIyAwMS1kZXBlbmRlbmNpZXMueWFtbC5nb3RtcGwKCnwgUmVsZWFz" + - "ZSB8IENoYXJ0IHwgTmFtZXNwYWNlIHwgTm90ZXMgfAp8LS0tLS0tLS0tfC0tLS0tLS18LS0tLS0t" + - "LS0tLS18LS0tLS0tLXwKfCBuYXRzIHwgaGVsbS1udmNmLW5hdHMgfCBuYXRzLXN5c3RlbSB8IE1l" + - "c3NhZ2luZyB8Cnwgb3BlbmJhby1zZXJ2ZXIgfCBoZWxtLW52Y2Ytb3BlbmJhby1zZXJ2ZXIgfCB2" + - "YXVsdC1zeXN0ZW0gfCBTZWNyZXRzIG1hbmFnZW1lbnQsIGRlcGVuZHMgb24gbmF0cyB8CnwgY2Fz" + - "c2FuZHJhIHwgaGVsbS1udmNmLWNhc3NhbmRyYSB8IGNhc3NhbmRyYS1zeXN0ZW0gfCBEYXRhYmFz" + - "ZSB8CgpVc2VzIGA8PDogKmRlcGVuZGVuY3lgIHRlbXBsYXRlIGluaGVyaXRhbmNlIHdpdGggYHJl" + - "bGVhc2UtZ3JvdXA6IGRlcGVuZGVuY2llc2AgbGFiZWwuCgojIyMgMDItY29yZS55YW1sLmdvdG1w" + - "bAoKfCBSZWxlYXNlIHwgQ2hhcnQgfCBOYW1lc3BhY2UgfCBMYWJlbCB8CnwtLS0tLS0tLS18LS0t" + - "LS0tLXwtLS0tLS0tLS0tLXwtLS0tLS0tfAp8IGFwaS1rZXlzIHwgaGVsbS1udmNmLWFwaS1rZXlz" + - "IHwgYXBpLWtleXMgfCBzZXJ2aWNlcyB8Cnwgc2lzIHwgaGVsbS1udmNmLXNpcyB8IHNpcyB8IHNl" + - "cnZpY2VzIHwKfCBhcGkgfCBoZWxtLW52Y2YtYXBpIHwgbnZjZiB8IHNlcnZpY2VzIHwKfCBpbnZv" + - "Y2F0aW9uLXNlcnZpY2UgfCBoZWxtLW52Y2YtaW52b2NhdGlvbi1zZXJ2aWNlIHwgbnZjZiB8IHNl" + - "cnZpY2VzIHwKfCBncnBjLXByb3h5IHwgaGVsbS1udmNmLWdycGMtcHJveHkgfCBudmNmIHwgc2Vy" + - "dmljZXMgfAp8IGVzcy1hcGkgfCBoZWxtLW52Y2YtZXNzLWFwaSB8IGVzcyB8IHNlcnZpY2VzIHwK" + - "fCBub3Rhcnktc2VydmljZSB8IGhlbG0tbnZjZi1ub3Rhcnktc2VydmljZSB8IG52Y2YgfCBzZXJ2" + - "aWNlcyB8CnwgcmV2YWwgfCBoZWxtLXJldmFsIHwgbnZjZiB8IHNlcnZpY2VzIHwKfCBsbG0tcmVx" + - "dWVzdC1yb3V0ZXIgfCBudmNmL2hlbG0tbnZjZi1sbG0tcmVxdWVzdC1yb3V0ZXIgfCBudmNmIHwg" + - "c2VydmljZXMgfAp8IGxsbS1hcGktZ2F0ZXdheSB8IG52Y2YvaGVsbS1udmNmLWxsbS1hcGktZ2F0" + - "ZXdheSB8IG52Y2YgfCBzZXJ2aWNlcyB8CnwgYWRtaW4taXNzdWVyLXByb3h5IHwgaGVsbS1hZG1p" + - "bi10b2tlbi1pc3N1ZXItcHJveHkgfCBhcGkta2V5cyB8IChubyByZWxlYXNlLWdyb3VwIGxhYmVs" + - "KSB8CnwgaW5ncmVzcyB8IG52Y2YtZ2F0ZXdheS1yb3V0ZXMgfCBlbnZveS1nYXRld2F5LXN5c3Rl" + - "bSB8IGluZ3Jlc3MgfAoKTW9zdCBzZXJ2aWNlcyB1c2UgYGluaGVyaXQ6IFt7dGVtcGxhdGU6IHNl" + - "cnZpY2V9XWAuIExMTSByZWxlYXNlcyB1c2UgT0NJIGNoYXJ0cyBmcm9tIHRoZSBgbnZjZmAgcmVw" + - "b3NpdG9yeSB3aXRoIHN0YW5kYWxvbmUgYHZhbHVlczogWy4uL2dsb2JhbC55YW1sLmdvdG1wbF1g" + - "IGJsb2NrczsgdGhleSBhcmUgZ2F0ZWQgb24gYGFkZG9ucy5sbG0uZW5hYmxlZGAuIGBhZG1pbi1p" + - "c3N1ZXItcHJveHlgIGFuZCBgaW5ncmVzc2AgaGF2ZSBzdGFuZGFsb25lIGB2YWx1ZXM6YCBibG9j" + - "a3MuCgojIyMgMDMtb2JzZXJ2YWJpbGl0eS55YW1sLmdvdG1wbAoKfCBSZWxlYXNlIHwgQ2hhcnQg" + - "fCBOYW1lc3BhY2UgfCBMYWJlbCB8CnwtLS0tLS0tLS18LS0tLS0tLXwtLS0tLS0tLS0tLXwtLS0t" + - "LS0tfAp8IChvYnNlcnZhYmlsaXR5IHJlbGVhc2VzKSB8ICh2YXJpb3VzKSB8IG9ic2VydmFiaWxp" + - "dHkgfCBvYnNlcnZhYmlsaXR5IHwKCkdhdGVkIG9uIG9ic2VydmFiaWxpdHktc3BlY2lmaWMgZmxh" + - "Z3MgaW4gdGhlIGVudmlyb25tZW50IGZpbGUuIFNraXBwZWQgaWYgZGlzYWJsZWQuCgojIyBUZW1w" + - "bGF0ZSBJbmhlcml0YW5jZQoKIyMjIGA8PDogKmRlcGVuZGVuY3lgIChZQU1MIG1lcmdlKQoKVXNl" + - "ZCBpbiBgMDEtZGVwZW5kZW5jaWVzLnlhbWwuZ290bXBsYC4gTWVyZ2VzIHRoZSB0ZW1wbGF0ZSdz" + - "IHByb3BlcnRpZXMgaW50byB0aGUgcmVsZWFzZS4KCioqR290Y2hhKio6IFlBTUwgbWVyZ2UgcmVw" + - "bGFjZXMgbGlzdHMuIElmIHlvdSBhZGQgYSBgdmFsdWVzOmAga2V5IHRvIHRoZSByZWxlYXNlLCBp" + - "dCAqKnJlcGxhY2VzKiogdGhlIHRlbXBsYXRlJ3MgYHZhbHVlczpgIGxpc3QgZW50aXJlbHkuIFlv" + - "dSBtdXN0IHJlLWluY2x1ZGUgYWxsIHRlbXBsYXRlIHZhbHVlczoKCkluIHRoZSB0ZW1wbGF0ZSBi" + - "ZWxvdywgYDxwcml2YXRlLXZhbHVlcz5gIHJlZmVycyB0byB0aGUgYHNlY3JldHMvYCBkaXJlY3Rv" + - "cnkgYXQgdGhlIGhlbG1maWxlIHN0YWNrIHJvb3QuCgpgYGB5YW1sCiMgVGVtcGxhdGUgZGVmaW5l" + - "czoKdGVtcGxhdGVzOgogIGRlcGVuZGVuY3k6ICZkZXBlbmRlbmN5CiAgICBjaGFydDogbnZjZi9o" + - "ZWxtLW52Y2Yte3sgLlJlbGVhc2UuTmFtZSB9fQogICAgdmFsdWVzOgogICAgICAtIC4uL2dsb2Jh" + - "bC55YW1sLmdvdG1wbAogICAgICAtIC4uLzxwcml2YXRlLXZhbHVlcz4ve3sgcmVxdWlyZWRFbnYg" + - "IkhFTE1GSUxFX0VOViIgfX0tc2VjcmV0cy55YW1sCgojIFdoZW4gb3ZlcnJpZGluZywgTVVTVCBy" + - "ZS1pbmNsdWRlIGJvdGg6Ci0gbmFtZTogY2Fzc2FuZHJhCiAgPDw6ICpkZXBlbmRlbmN5CiAgdmFs" + - "dWVzOgogICAgLSAuLi9nbG9iYWwueWFtbC5nb3RtcGwgICAgICAgICAgICAgICAgICAgICAgICAg" + - "ICAgICAgICAgICAgICAgICAgICAgIyBNdXN0IHJlLWluY2x1ZGUKICAgIC0gLi4vPHByaXZhdGUt" + - "dmFsdWVzPi97eyByZXF1aXJlZEVudiAiSEVMTUZJTEVfRU5WIiB9fS1zZWNyZXRzLnlhbWwgICAj" + - "IE11c3QgcmUtaW5jbHVkZQogICAgLSBjYXNzYW5kcmE6ICAgICAgICAgICAgICAgICAgICAgICAg" + - "ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICMgWW91ciBvdmVycmlkZQogICAgICAg" + - "IHJlc291cmNlczoKICAgICAgICAgIGxpbWl0czoKICAgICAgICAgICAgbWVtb3J5OiA4MTkyTWkK" + - "YGBgCgojIyMgYGluaGVyaXRgIChIZWxtZmlsZSBuYXRpdmUpCgpVc2VkIGluIGAwMi1jb3JlLnlh" + - "bWwuZ290bXBsYC4gSGVsbWZpbGUncyBuYXRpdmUgaW5oZXJpdGFuY2UgbWVjaGFuaXNtLgoKYGBg" + - "eWFtbAotIG5hbWU6IGFwaQogIHZlcnNpb246IDEuNi4wCiAgbmFtZXNwYWNlOiBudmNmCiAgaW5o" + - "ZXJpdDoKICAgIC0gdGVtcGxhdGU6IHNlcnZpY2UKYGBgCgpXaGVuIGFkZGluZyBgdmFsdWVzOmAg" + - "dG8gYW4gaW5oZXJpdGVkIHJlbGVhc2UsIHlvdSBhbHNvIG5lZWQgdG8gcmUtaW5jbHVkZSB0aGUg" + - "dGVtcGxhdGUncyB2YWx1ZXMgZmlsZXMgc2luY2UgYHZhbHVlc2AgaXMgYSBsaXN0IHRoYXQgZ2V0" + - "cyByZXBsYWNlZC4KCiMjIFZhbHVlcyBQcmVjZWRlbmNlCgpGcm9tIGxvd2VzdCB0byBoaWdoZXN0" + - "IHByaW9yaXR5OgoKMS4gYGVudmlyb25tZW50cy9iYXNlLnlhbWxgIC0tIGRlZmF1bHRzIHNoYXJl" + - "ZCBhY3Jvc3MgYWxsIGVudmlyb25tZW50cwoyLiBgZW52aXJvbm1lbnRzLzxlbnY+LnlhbWxgIC0t" + - "IHBlci1lbnZpcm9ubWVudCBvdmVycmlkZXMKMy4gYGdsb2JhbC55YW1sLmdvdG1wbGAgLS0gR28g" + - "dGVtcGxhdGUgcHJvY2Vzc2luZyAoY29uc3RydWN0cyBjaGFydC1zcGVjaWZpYyBzdHJ1Y3R1cmUp" + - "CjQuIGA8cHJpdmF0ZS12YWx1ZXM+LzxlbnY+LXNlY3JldHMueWFtbGAgLS0gc2Vuc2l0aXZlIHZh" + - "bHVlcwo1LiBJbmxpbmUgYHZhbHVlczpgIGJsb2NrcyBvbiByZWxlYXNlcyAtLSBoaWdoZXN0IHBy" + - "ZWNlZGVuY2UKCiMjIFdoYXQgZ2xvYmFsLnlhbWwuZ290bXBsIFBhc3NlcyBUaHJvdWdoCgpgZ2xv" + - "YmFsLnlhbWwuZ290bXBsYCByZWFkcyBmcm9tIGAuVmFsdWVzYCAodGhlIG1lcmdlZCBlbnZpcm9u" + - "bWVudCArIGVudi1zcGVjaWZpYyBZQU1MKSBhbmQgY29uc3RydWN0cyBjaGFydC1zcGVjaWZpYyB2" + - "YWx1ZXMuIEl0IG9ubHkgcGFzc2VzIHRocm91Z2gga2V5cyBpdCBleHBsaWNpdGx5IHJlZmVyZW5j" + - "ZXM6CgojIyMgQ2Fzc2FuZHJhCi0gYGNhc3NhbmRyYS5yZXBsaWNhQ291bnRgCi0gYGNhc3NhbmRy" + - "YS5pbWFnZS4qYCAocmVnaXN0cnksIHJlcG9zaXRvcnkpCi0gYGNhc3NhbmRyYS5taWdyYXRpb25z" + - "LmltYWdlLipgCi0gYGNhc3NhbmRyYS5wZXJzaXN0ZW5jZS5zaXplYAotIGBjYXNzYW5kcmEubm9k" + - "ZVNlbGVjdG9yYCAoaWYgYGdsb2JhbC5ub2RlU2VsZWN0b3JzLmVuYWJsZWRgKQotIGBjYXNzYW5k" + - "cmEuZ2xvYmFsLmRlZmF1bHRTdG9yYWdlQ2xhc3NgCgojIyMgTkFUUwotIGBuYXRzLmNvbnRhaW5l" + - "ci5pbWFnZS4qYAotIGBuYXRzLnJlbG9hZGVyLmltYWdlLipgCi0gYG5hdHMubmF0c0JveC5jb250" + - "YWluZXIuaW1hZ2UuKmAKLSBgbmF0cy5jb25maWcuamV0c3RyZWFtLmZpbGVTdG9yZS5wdmMuc3Rv" + - "cmFnZUNsYXNzTmFtZWAKLSBgbmF0cy5wb2RUZW1wbGF0ZS5tZXJnZS5zcGVjLm5vZGVTZWxlY3Rv" + - "cmAgKGlmIGVuYWJsZWQpCgojIyMgT3BlbkJhbwotIGBvcGVuYmFvLm1pZ3JhdGlvbnMuaW1hZ2Uu" + - "KmAgYW5kIGBvcGVuYmFvLm1pZ3JhdGlvbnMuZW52YAotIGBvcGVuYmFvLmluamVjdG9yLmltYWdl" + - "LipgCi0gYG9wZW5iYW8uc2VydmVyLmltYWdlLipgCi0gYG9wZW5iYW8uc2VydmVyLmRhdGFTdG9y" + - "YWdlLipgCi0gTm9kZSBzZWxlY3RvcnMgKGlmIGVuYWJsZWQpCgojIyMgU2VydmljZXMgKEFQSSwg" + - "U0lTLCBldGMuKQotIGA8c2VydmljZT4uaW1hZ2UuKmAgKHJlZ2lzdHJ5LCByZXBvc2l0b3J5KQot" + - "IGA8c2VydmljZT4ubm9kZVNlbGVjdG9yYCAoaWYgZW5hYmxlZCkKLSBgPHNlcnZpY2U+LmVudi4q" + - "YCAob2JzZXJ2YWJpbGl0eSBzZXR0aW5ncykKCiMjIyBMTE0gRnVuY3Rpb24gRW5hYmxlbWVudAoK" + - "RW5hYmxlIHRoZSBMTE0gYWRkb24gYmVmb3JlIGNyZWF0aW5nIG9yIGludm9raW5nIGZ1bmN0aW9u" + - "cyB3aXRoCmBmdW5jdGlvblR5cGU6ICJMTE0iYC4gVGhlIGFkZG9uIGRlcGxveXMgYGxsbS1yZXF1" + - "ZXN0LXJvdXRlcmAgYW5kCmBsbG0tYXBpLWdhdGV3YXlgLCBhZGRzIHRoZSBgbGxtLmludm9jYXRp" + - "b24uPGRvbWFpbj5gIHJvdXRlIHdoZW4gR2F0ZXdheSBBUEkKaW5ncmVzcyBpcyBlbmFibGVkLCBh" + - "bmQgY29uZmlndXJlcyB3b3JrZXJzIHRvIHVzZSB0aGUgTExNIHNpZGVjYXIuIFRoZSBIZWxtZmls" + - "ZQpjb25kaXRpb24gaXMgYGFkZG9ucy5sbG0uZW5hYmxlZGAuIERvIG5vdCB1c2UgdGhlIG9ic29s" + - "ZXRlIGBsbG0uZW5hYmxlZGAgcGF0aC4KCkZvciBhIHNpbmdsZS1ub2RlIGlzb2xhdGVkIHRlc3Qg" + - "Y2x1c3RlciwgYWRkIHRoaXMgY29uZmlndXJhdGlvbiB0bwpgZW52aXJvbm1lbnRzLzxlbnY+Lnlh" + - "bWxgIGJlZm9yZSBhcHBseWluZyB0aGUgc3RhY2s6CgpgYGB5YW1sCmFkZG9uczoKICBsbG06CiAg" + - "ICBlbmFibGVkOiB0cnVlCiAgICBnYXRld2F5OgogICAgICByZXBsaWNhQ291bnQ6IDEKICAgICAg" + - "YXV0aDoKICAgICAgICBncnBjSW5zZWN1cmU6IHRydWUKICAgICAgbWV0cmljczoKICAgICAgICBz" + - "ZXJ2aWNlTW9uaXRvcjoKICAgICAgICAgIGVuYWJsZWQ6IGZhbHNlCiAgICByZXF1ZXN0Um91dGVy" + - "OgogICAgICByZXBsaWNhQ291bnQ6IDEKICAgICAgbWV0cmljczoKICAgICAgICBzZXJ2aWNlTW9u" + - "aXRvcjoKICAgICAgICAgIGVuYWJsZWQ6IGZhbHNlCgphZ2VudENvbmZpZzoKICBtZXJnZUNvbmZp" + - "ZzogfAogICAgY2x1c3RlcjoKICAgICAgdmFsaWRhdGlvblBvbGljeToKICAgICAgICBuYW1lOiBV" + - "bnJlc3RyaWN0ZWQKICAgIHdvcmtsb2FkOgogICAgICBzdGFyZ2F0ZVFVSUNJbnNlY3VyZTogdHJ1" + - "ZQpgYGAKClVzZSBgcmVwbGljYUNvdW50OiAxYCBvbmx5IGZvciBsb2NhbCBvciBzaW5nbGUtbm9k" + - "ZSB0ZXN0IGNsdXN0ZXJzLiBGb3Igc2hhcmVkCm9yIHByb2R1Y3Rpb24gY2x1c3RlcnMsIHVzZSB0" + - "aGUgcmVxdWlyZWQgcmVwbGljYSBjb3VudCBhbmQgVExTLWNhcGFibGUgc2VydmljZQpjb25maWd1" + - "cmF0aW9uLiBgYWRkb25zLmxsbS5nYXRld2F5LmF1dGguZ3JwY0luc2VjdXJlYCBhbmQKYHdvcmts" + - "b2FkLnN0YXJnYXRlUVVJQ0luc2VjdXJlYCBlbmFibGUgcGxhaW50ZXh0IHRyYW5zcG9ydHMuIERv" + - "IG5vdCB1c2UgdGhlbSBpbgpwcm9kdWN0aW9uLgoKVGhlIHJlcXVlc3Qgcm91dGVyIHVzZXMgYHBv" + - "d2VyLW9mLXR3b2Agd2hlbiBubyBsb2FkLWJhbGFuY2VyIGNvbmZpZ3VyYXRpb24gaXMKc2V0LiBD" + - "b25maWd1cmUgb3RoZXIgcm91dGluZyBtZXRob2RzIHdpdGggdGhlCltMTE0gUmVxdWVzdCBSb3V0" + - "ZXIgTG9hZCBCYWxhbmNpbmddKGh0dHBzOi8vZ2l0aHViLmNvbS9OVklESUEvbnZjZi9ibG9iL21h" + - "aW4vZG9jcy91c2VyL2xsbS1yZXF1ZXN0LXJvdXRlci1sb2FkLWJhbGFuY2luZy5tZCkKZ3VpZGUu" + - "CgpJZiB0aGUgc2lkZWNhciBpbWFnZSBpcyBtaXJyb3JlZCBvdXRzaWRlIHRoZSBzdGFjaydzIGRl" + - "ZmF1bHQgaW1hZ2UgcmVnaXN0cnkgYW5kCnJlcG9zaXRvcnksIHNldCB0aGUgZ2VuZXJhdGVkIHdv" + - "cmtlciBzaWRlY2FyIGltYWdlIGV4cGxpY2l0bHk6CgpgYGB5YW1sCmFwaToKICBlbnY6CiAgICBO" + - "VkNGX1NJREVDQVJTX0xMTV9ST1VURVJfQ0xJRU5UX0lNQUdFOiA8cmVnaXN0cnk+LzxyZXBvc2l0" + - "b3J5Pi9weWxvbjowLjIuMQpgYGAKClJlbmRlciBhbmQgYXBwbHkgdGhlIHVwZGF0ZWQgY29udHJv" + - "bC1wbGFuZSBlbnZpcm9ubWVudCwgdGhlbiByZWZyZXNoIGV2ZXJ5CnJlZ2lzdGVyZWQgY29tcHV0" + - "ZSBwbGFuZSB1c2luZyB0aGUgc2FtZSBoYW5kb2ZmIHVzZWQgZm9yIGl0cyBpbnN0YWxsYXRpb24g" + - "c28KTlZDQSByZWNlaXZlcyBgYWdlbnRDb25maWcubWVyZ2VDb25maWdgOgoKYGBgYmFzaApIRUxN" + - "RklMRV9FTlY9PGVudj4gaGVsbWZpbGUgdGVtcGxhdGUKSEVMTUZJTEVfRU5WPTxlbnY+IGhlbG1m" + - "aWxlIHN5bmMKYGBgCgpVc2UgdGhlIGNvbXBsZXRlIGNvbXB1dGUtcGxhbmUgaW5zdGFsbCBjb21t" + - "YW5kIGZyb20KW1NwbGl0IENvbXB1dGUtUGxhbmUgSW5zdGFsbGF0aW9uXShjb21wdXRlLXBsYW5l" + - "LWluc3RhbGxhdGlvbi5tZCkuIEEKQ0xJLXByb2ZpbGUgaW5zdGFsbGF0aW9uIG11c3QgcmVtYWlu" + - "IHByb2ZpbGUtZHJpdmVuOyBhIEhlbG1maWxlIGluc3RhbGxhdGlvbgptdXN0IHJlbWFpbiB2YWx1" + - "ZXMtZHJpdmVuLgoKRXhpc3RpbmcgTExNIGZ1bmN0aW9uIHBvZHMga2VlcCB0aGVpciBleGlzdGlu" + - "ZyBzaWRlY2FyIGFyZ3VtZW50cy4gUmVjcmVhdGUgb3IKcmVkZXBsb3kgdGhvc2UgZnVuY3Rpb25z" + - "IGFmdGVyIHRoZSBjb21wdXRlLXBsYW5lIHJlZnJlc2guIFZlcmlmeSB0aGUgY29udHJvbApwbGFu" + - "ZSwgcm91dGUsIGFuZCB3b3JrZXIgc2lkZWNhcjoKCmBgYGJhc2gKa3ViZWN0bCBnZXQgZGVwbG95" + - "IC1uIG52Y2YgbGxtLWFwaS1nYXRld2F5Cmt1YmVjdGwgZ2V0IHN0YXRlZnVsc2V0IC1uIG52Y2Yg" + - "bGxtLXJlcXVlc3Qtcm91dGVyCmt1YmVjdGwgZ2V0IHBvZHMgLW4gbnZjZiB8IGdyZXAgLUUgJ2xs" + - "bS1hcGktZ2F0ZXdheXxsbG0tcmVxdWVzdC1yb3V0ZXInCmt1YmVjdGwgZ2V0IGh0dHByb3V0ZSAt" + - "QSB8IGdyZXAgbGxtCmt1YmVjdGwgLW4gbnZjZi1iYWNrZW5kIGdldCBwb2QgPGZ1bmN0aW9uLXBv" + - "ZD4gXAogIC1vIGpzb25wYXRoPSd7cmFuZ2UgLnNwZWMuY29udGFpbmVyc1s/KEAubmFtZT09Imxs" + - "bS13b3JrZXIiKV0uYXJnc1sqXX17Ln17IlxcbiJ9e2VuZH0nCmBgYAoKRm9yIGxvY2FsIHBsYWlu" + - "dGV4dCBjbHVzdGVycywgdGhlIGBsbG0td29ya2VyYCBhcmdzIG11c3QgaW5jbHVkZQpgLS1xdWlj" + - "LWluc2VjdXJlYC4KCkZvciBsb2FkLWJhbGFuY2VyIHNjaGVtYSBhbmQgYWxnb3JpdGhtIGJlaGF2" + - "aW9yLCBzZWUgdGhlCltTdGFyZ2F0ZSBjb25maWd1cmF0aW9uIGd1aWRlXShodHRwczovL2dpdGh1" + - "Yi5jb20vTlZJRElBL252Y2YvYmxvYi9tYWluL3NyYy9saWJyYXJpZXMvcnVzdC9zdGFyZ2F0ZS9k" + - "b2NzL2xvYWQtYmFsYW5jZXItY29uZmlndXJhdGlvbi5tZCkuCgojIyBIZWxtZmlsZSBTZWxlY3Rv" + - "cnMKClRhcmdldCBzcGVjaWZpYyByZWxlYXNlcyBvciBncm91cHM6CgpgYGBiYXNoCiMgQnkgcmVs" + - "ZWFzZSBncm91cApIRUxNRklMRV9FTlY9PGVudj4gaGVsbWZpbGUgLS1zZWxlY3RvciByZWxlYXNl" + - "LWdyb3VwPWRlcGVuZGVuY2llcyBzeW5jCkhFTE1GSUxFX0VOVj08ZW52PiBoZWxtZmlsZSAtLXNl" + - "bGVjdG9yIHJlbGVhc2UtZ3JvdXA9c2VydmljZXMgc3luYwpIRUxNRklMRV9FTlY9PGVudj4gaGVs" + - "bWZpbGUgLS1zZWxlY3RvciByZWxlYXNlLWdyb3VwPWluZ3Jlc3Mgc3luYwpIRUxNRklMRV9FTlY9" + - "PGVudj4gaGVsbWZpbGUgLS1zZWxlY3RvciByZWxlYXNlLWdyb3VwPW9ic2VydmFiaWxpdHkgc3lu" + - "YwoKIyBCeSByZWxlYXNlIG5hbWUKSEVMTUZJTEVfRU5WPTxlbnY+IGhlbG1maWxlIC0tc2VsZWN0" + - "b3IgbmFtZT1jYXNzYW5kcmEgc3luYwpIRUxNRklMRV9FTlY9PGVudj4gaGVsbWZpbGUgLS1zZWxl" + - "Y3RvciBuYW1lPWFkbWluLWlzc3Vlci1wcm94eSBzeW5jCkhFTE1GSUxFX0VOVj08ZW52PiBoZWxt" + - "ZmlsZSAtLXNlbGVjdG9yIG5hbWU9bGxtLXJlcXVlc3Qtcm91dGVyIHN5bmMKSEVMTUZJTEVfRU5W" + - "PTxlbnY+IGhlbG1maWxlIC0tc2VsZWN0b3IgbmFtZT1sbG0tYXBpLWdhdGV3YXkgc3luYwoKIyBU" + - "ZW1wbGF0ZSBvbmx5IChkcnkgcnVuKQpIRUxNRklMRV9FTlY9PGVudj4gaGVsbWZpbGUgLS1zZWxl" + - "Y3RvciBuYW1lPWNhc3NhbmRyYSB0ZW1wbGF0ZQoKIyBEZXN0cm95IGEgc2luZ2xlIHJlbGVhc2UK" + - "SEVMTUZJTEVfRU5WPTxlbnY+IGhlbG1maWxlIC0tc2VsZWN0b3IgbmFtZT1jYXNzYW5kcmEgZGVz" + - "dHJveQpgYGAKCk5vdGU6IGBhZG1pbi1pc3N1ZXItcHJveHlgIGhhcyBubyBgcmVsZWFzZS1ncm91" + - "cGAgbGFiZWwuIFVzZSBgLS1zZWxlY3RvciBuYW1lPWFkbWluLWlzc3Vlci1wcm94eWAuClBLBwjA" + - "ViDnjycAAI8nAABQSwMEFAAIAAAAAAAhAAAAAAAAAAAAAAAAAD8ACQBkYXRhL252Y2Ytc2VsZi1t" + - "YW5hZ2VkLWluc3RhbGxhdGlvbi9yZWZlcmVuY2VzL252Y2YtdWktYWRkb24ubWRVVAUAAQCmzhIj" + - "IE5WQ0YgVUkgQWRkb24KCk5WQ0YgVUkgaXMgYW4gb3B0aW9uYWwsIGN1c3RvbWVyLWZhY2luZyBO" + - "VkNGIGFkbWluLXBhbmVsIFVJLiBJdCBpcyBkaXNhYmxlZCBieQpkZWZhdWx0IGFuZCBhdmFpbGFi" + - "bGUgb25seSBpbiBzdGFjayBwYWNrYWdlcyB0aGF0IGluY2x1ZGUgdGhlIE5WQ0YgVUkgYWRkb24u" + - "CgojIyBXaGVuIHRvIGVuYWJsZQoKRW5hYmxlIE5WQ0YgVUkgb25seSB3aGVuIHlvdSBuZWVkIHRo" + - "ZSBhZG1pbi1wYW5lbCBVSSBhbmQgeW91ciBleHRyYWN0ZWQgc3RhY2sKcGFja2FnZSBpbmNsdWRl" + - "cyB0aGUgYWRkb24uIElmIHRoZSBwYWNrYWdlIGRvZXMgbm90IGNvbnRhaW4gYSBgbnZjZi11aWAg" + - "cmVsZWFzZQphbmQgYG52Y2ZVaWAgcm91dGUgdmFsdWVzLCBza2lwIHRoZSBhZGRvbiB1bnRpbCB5" + - "b3UgdXNlIGEgcGFja2FnZSB0aGF0IGluY2x1ZGVzCnRoZW0uCgojIyBFbmFibGUgdGhlIGFkZG9u" + - "CgpFbmFibGUgaXQgaW4gYGVudmlyb25tZW50cy88ZW52LW5hbWU+LnlhbWxgOgoKYGBgeWFtbAph" + - "ZGRvbnM6CiAgbnZjZlVpOgogICAgZW5hYmxlZDogdHJ1ZQpgYGAKCiMjIENyZWF0ZSBuYW1lc3Bh" + - "Y2UgYW5kIGltYWdlIHB1bGwgc2VjcmV0CgpDcmVhdGUgdGhlIG5hbWVzcGFjZSwgYW5kIGFuIGlt" + - "YWdlIHB1bGwgc2VjcmV0IG9ubHkgaWYgcHVsbGluZyBmcm9tIGEgcHJpdmF0ZQpyZWdpc3RyeToK" + - "CmBgYGJhc2gKa3ViZWN0bCBjcmVhdGUgbmFtZXNwYWNlIG52Y2YtdWkgLS1kcnktcnVuPWNsaWVu" + - "dCAtbyB5YW1sIHwga3ViZWN0bCBhcHBseSAtZiAtCgojIE9ubHkgaWYgcHVsbGluZyBmcm9tIGEg" + - "cHJpdmF0ZSByZWdpc3RyeSAoZS5nLiwgTkdDIG52Y3IuaW8pCmV4cG9ydCBOR0NfQVBJX0tFWT0i" + - "PHlvdXIta2V5PiIKa3ViZWN0bCBjcmVhdGUgc2VjcmV0IGRvY2tlci1yZWdpc3RyeSBudmNyLWNy" + - "ZWRzIFwKICAtLWRvY2tlci1zZXJ2ZXI9bnZjci5pbyBcCiAgLS1kb2NrZXItdXNlcm5hbWU9JyRv" + - "YXV0aHRva2VuJyBcCiAgLS1kb2NrZXItcGFzc3dvcmQ9IiROR0NfQVBJX0tFWSIgXAogIC0tbmFt" + - "ZXNwYWNlPW52Y2YtdWkgXAogIC0tZHJ5LXJ1bj1jbGllbnQgLW8geWFtbCB8IGt1YmVjdGwgYXBw" + - "bHkgLWYgLQpgYGAKClRoZSBkZWZhdWx0IHJvdXRlIGhvc3QgaXMgYG52Y2YtdWkuPGRvbWFpbj5g" + - "IGFuZCB0aGUgYmFja2VuZCBpcwpgbnZjZi11aS5udmNmLXVpOjgzMDBgLgoKIyMgQXBwbHkgdGhl" + - "IHNlcnZpY2UgYW5kIHJvdXRlCgpBZnRlciBjb25maXJtaW5nIHRoZSBwYWNrYWdlIGluY2x1ZGVz" + - "IHRoZSBgbnZjZi11aWAgcmVsZWFzZSwgcHJldmlldyBhbmQgYXBwbHkKdGhlIHNlcnZpY2UgYW5k" + - "IHJvdXRlOgoKYGBgYmFzaApIRUxNRklMRV9FTlY9PGVudi1uYW1lPiBoZWxtZmlsZSAtLXNlbGVj" + - "dG9yIG5hbWU9bnZjZi11aSB0ZW1wbGF0ZQpIRUxNRklMRV9FTlY9PGVudi1uYW1lPiBoZWxtZmls" + - "ZSAtLXNlbGVjdG9yIG5hbWU9bnZjZi11aSBzeW5jCkhFTE1GSUxFX0VOVj08ZW52LW5hbWU+IGhl" + - "bG1maWxlIC0tc2VsZWN0b3IgcmVsZWFzZS1ncm91cD1pbmdyZXNzIHN5bmMKYGBgCgojIyBWZXJp" + - "ZnkKClZlcmlmeSB0aGUgcm91dGUgb25seSB3aGVuIHRoZSBhZGRvbiBpcyBwcmVzZW50IGFuZCBl" + - "bmFibGVkOgoKYGBgYmFzaAprdWJlY3RsIGdldCBkZXBsb3ksc3ZjIC1uIG52Y2YtdWkKa3ViZWN0" + - "bCBnZXQgaHR0cHJvdXRlIC1BIHwgZ3JlcCAtaSBudmNmLXVpCmN1cmwgLWkgLUggIkhvc3Q6IG52" + - "Y2YtdWkuPGRvbWFpbj4iICJodHRwOi8vPGdhdGV3YXktYWRkcmVzcz4vc3RhdHVzIgpgYGAKCiMj" + - "IFNlY3VyaXR5CgpUaGUgTlZDRiBVSSBhZG1pbiBwYW5lbCBpcyBjdXJyZW50bHkgdW5hdXRoZW50" + - "aWNhdGVkLiBEbyBub3QgZXhwb3NlIGl0IHRvIHRoZQpwdWJsaWMgaW50ZXJuZXQuIFJlc3RyaWN0" + - "IGFjY2VzcyB0byBhIHRydXN0ZWQgbmV0d29yaywgVlBOLCBvciBhbiBhdXRoZW50aWNhdGluZwpw" + - "cm94eSBpbiBmcm9udCBvZiB0aGUgYG52Y2YtdWlgIHJvdXRlLgpQSwcIOPknr7kHAAC5BwAAUEsD" + - "BBQACAAAAAAAIQAAAAAAAAAAAAAAAAA+AAkAZGF0YS9udmNmLXNlbGYtbWFuYWdlZC1pbnN0YWxs" + - "YXRpb24vcmVmZXJlbmNlcy9wdWxsLXNlY3JldHMubWRVVAUAAQCmzhIjIEltYWdlIFB1bGwgU2Vj" + - "cmV0cyBSZWZlcmVuY2UKCiMjIE92ZXJ2aWV3CgpXaGVuIHB1bGxpbmcgTlZDRiBpbWFnZXMgZnJv" + - "bSBhIHByaXZhdGUgcmVnaXN0cnkgKGZvciBleGFtcGxlLCBOR0MKYG52Y3IuaW9gKSwgS3ViZXJu" + - "ZXRlcyBuZWVkcyBgaW1hZ2VQdWxsU2VjcmV0c2Agb24gZXZlcnkgcG9kLiBDb250cm9sLXBsYW5l" + - "IGFuZApjb21wdXRlLXBsYW5lIGNyZWRlbnRpYWxzIGFyZSBjb25maWd1cmVkIGluIHRoZWlyIG93" + - "biBjbHVzdGVyIGNvbnRleHRzLiBEbyBub3QKdXNlIG9uZSBtaXhlZCBuYW1lc3BhY2UgbGlzdC4K" + - "ClRoZSByZWNvbW1lbmRlZCBjb250cm9sLXBsYW5lIGFwcHJvYWNoIHVzZXMgS3l2ZXJubyB0byBp" + - "bmplY3QgdGhlIHNlY3JldCBpbnRvCmNvbnRyb2wtcGxhbmUgcG9kcyBhdCBhZG1pc3Npb24gdGlt" + - "ZS4gVGhlIGNvbXB1dGUtcGxhbmUgY2hhcnQgYW5kIG9wZXJhdG9yIHVzZQp0aGUgc2VjcmV0IGlu" + - "IGBudmNhLW9wZXJhdG9yYCBhbmQgbWlycm9yIGl0IHRvIGBudmNhLXN5c3RlbWAuCgojIyBLeXZl" + - "cm5vIEFwcHJvYWNoIChSZWNvbW1lbmRlZCkKCiMjIyAxLiBJbnN0YWxsIEt5dmVybm8KCmBgYGJh" + - "c2gKaGVsbSByZXBvIGFkZCBreXZlcm5vIGh0dHBzOi8va3l2ZXJuby5naXRodWIuaW8va3l2ZXJu" + - "by8KaGVsbSByZXBvIHVwZGF0ZQpoZWxtIGluc3RhbGwga3l2ZXJubyBreXZlcm5vL2t5dmVybm8g" + - "LW4ga3l2ZXJubyAtLWNyZWF0ZS1uYW1lc3BhY2UgXAogIC0ta3ViZS1jb250ZXh0IDxjb250cm9s" + - "LXBsYW5lLWNvbnRleHQ+CmBgYAoKIyMjIDIuIENyZWF0ZSBjb250cm9sLXBsYW5lIHB1bGwgc2Vj" + - "cmV0cwoKYGBgYmFzaApleHBvcnQgTkdDX0FQSV9LRVk9Ijx5b3VyLW5nYy1hcGkta2V5PiIKCmZv" + - "ciBucyBpbiBjYXNzYW5kcmEtc3lzdGVtIG5hdHMtc3lzdGVtIG52Y2YgYXBpLWtleXMgZXNzIHNp" + - "cyB2YXVsdC1zeXN0ZW0gY2VydC1tYW5hZ2VyOyBkbwogIGt1YmVjdGwgLS1jb250ZXh0IDxjb250" + - "cm9sLXBsYW5lLWNvbnRleHQ+IGNyZWF0ZSBuYW1lc3BhY2UgIiRucyIgXAogICAgLS1kcnktcnVu" + - "PWNsaWVudCAtbyB5YW1sIHwga3ViZWN0bCAtLWNvbnRleHQgPGNvbnRyb2wtcGxhbmUtY29udGV4" + - "dD4gYXBwbHkgLWYgLQpkb25lCgpmb3IgbnMgaW4gY2Fzc2FuZHJhLXN5c3RlbSBuYXRzLXN5c3Rl" + - "bSBudmNmIGFwaS1rZXlzIGVzcyBzaXMgdmF1bHQtc3lzdGVtIGNlcnQtbWFuYWdlcjsgZG8KICBr" + - "dWJlY3RsIC0tY29udGV4dCA8Y29udHJvbC1wbGFuZS1jb250ZXh0PiBjcmVhdGUgc2VjcmV0IGRv" + - "Y2tlci1yZWdpc3RyeSBudmNyLWNyZWRzIFwKICAgIC0tZG9ja2VyLXNlcnZlcj1udmNyLmlvIFwK" + - "ICAgIC0tZG9ja2VyLXVzZXJuYW1lPSckb2F1dGh0b2tlbicgXAogICAgLS1kb2NrZXItcGFzc3dv" + - "cmQ9IiROR0NfQVBJX0tFWSIgXAogICAgLS1uYW1lc3BhY2U9IiRucyIgXAogICAgLS1kcnktcnVu" + - "PWNsaWVudCAtbyB5YW1sIHwga3ViZWN0bCAtLWNvbnRleHQgPGNvbnRyb2wtcGxhbmUtY29udGV4" + - "dD4gYXBwbHkgLWYgLQpkb25lCmBgYAoKRm9yIG5vbi1OR0MgcmVnaXN0cmllcywgcmVwbGFjZSBg" + - "LS1kb2NrZXItc2VydmVyYCwgYC0tZG9ja2VyLXVzZXJuYW1lYCwgYW5kIGAtLWRvY2tlci1wYXNz" + - "d29yZGAuCgojIyMgMy4gQXBwbHkgS3l2ZXJubyBDbHVzdGVyUG9saWN5CgpgYGB5YW1sCmFwaVZl" + - "cnNpb246IGt5dmVybm8uaW8vdjEKa2luZDogQ2x1c3RlclBvbGljeQptZXRhZGF0YToKICBuYW1l" + - "OiBudmNmLWFkZC1pbWFnZXB1bGxzZWNyZXRzCnNwZWM6CiAgYmFja2dyb3VuZDogZmFsc2UKICBy" + - "dWxlczoKICAgIC0gbmFtZTogYWRkLWltYWdlcHVsbHNlY3JldC10by1udmNmLXBvZHMKICAgICAg" + - "bWF0Y2g6CiAgICAgICAgYW55OgogICAgICAgIC0gcmVzb3VyY2VzOgogICAgICAgICAgICBraW5k" + - "czoKICAgICAgICAgICAgLSBQb2QKICAgICAgICAgICAgbmFtZXNwYWNlczoKICAgICAgICAgICAg" + - "LSAibnZjZiIKICAgICAgICAgICAgLSAiYXBpLWtleXMiCiAgICAgICAgICAgIC0gInNpcyIKICAg" + - "ICAgICAgICAgLSAiZXNzIgogICAgICAgICAgICAtICJuYXRzLXN5c3RlbSIKICAgICAgICAgICAg" + - "LSAiY2Fzc2FuZHJhLXN5c3RlbSIKICAgICAgICAgICAgLSAidmF1bHQtc3lzdGVtIgogICAgICAg" + - "ICAgICAtICJjZXJ0LW1hbmFnZXIiCiAgICAgIG11dGF0ZToKICAgICAgICBwYXRjaFN0cmF0ZWdp" + - "Y01lcmdlOgogICAgICAgICAgbWV0YWRhdGE6CiAgICAgICAgICAgIGFubm90YXRpb25zOgogICAg" + - "ICAgICAgICAgIG52Y2YubnZpZGlhLmNvbS9pbWFnZXB1bGxzZWNyZXQtaW5qZWN0ZWQtYnk6IGt5" + - "dmVybm8KICAgICAgICAgIHNwZWM6CiAgICAgICAgICAgIGltYWdlUHVsbFNlY3JldHM6CiAgICAg" + - "ICAgICAgIC0gbmFtZTogbnZjci1jcmVkcwpgYGAKCmBgYGJhc2gKa3ViZWN0bCAtLWNvbnRleHQg" + - "PGNvbnRyb2wtcGxhbmUtY29udGV4dD4gYXBwbHkgXAogIC1mIGt5dmVybm8taW1hZ2VwdWxsc2Vj" + - "cmV0LXBvbGljeS55YW1sCmBgYAoKIyMjIDQuIEluc3RhbGwgdGhlIGNvbnRyb2wgcGxhbmUKCkNv" + - "bnRpbnVlIHdpdGggdGhlIHNlbGVjdGVkIGNvbnRyb2wtcGxhbmUgaW5zdGFsbGF0aW9uIGluCltT" + - "cGxpdCBDb21wdXRlLVBsYW5lIEluc3RhbGxhdGlvbl0oY29tcHV0ZS1wbGFuZS1pbnN0YWxsYXRp" + - "b24ubWQpLiBObwpjb250cm9sLXBsYW5lIGhlbG1maWxlIG1vZGlmaWNhdGlvbnMgYXJlIG5lZWRl" + - "ZC4gS3l2ZXJubyBpbmplY3RzIHRoZSBwdWxsCnNlY3JldCBpbnRvIG5ldyBjb250cm9sLXBsYW5l" + - "IHBvZHMuCgojIyBDb21wdXRlLVBsYW5lIFNlY3JldAoKQ3JlYXRlIHRoZSBzZWNyZXQgb25seSBp" + - "biBgbnZjYS1vcGVyYXRvcmAgb24gdGhlIGNvbXB1dGUgY2x1c3RlcjoKCmBgYGJhc2gKa3ViZWN0" + - "bCAtLWNvbnRleHQgPGNvbXB1dGUtcGxhbmUtY29udGV4dD4gY3JlYXRlIG5hbWVzcGFjZSBudmNh" + - "LW9wZXJhdG9yIFwKICAtLWRyeS1ydW49Y2xpZW50IC1vIHlhbWwgfCBcCiAga3ViZWN0bCAtLWNv" + - "bnRleHQgPGNvbXB1dGUtcGxhbmUtY29udGV4dD4gYXBwbHkgLWYgLQoKa3ViZWN0bCAtLWNvbnRl" + - "eHQgPGNvbXB1dGUtcGxhbmUtY29udGV4dD4gY3JlYXRlIHNlY3JldCBkb2NrZXItcmVnaXN0cnkg" + - "bnZjci1jcmVkcyBcCiAgLS1kb2NrZXItc2VydmVyPW52Y3IuaW8gXAogIC0tZG9ja2VyLXVzZXJu" + - "YW1lPSckb2F1dGh0b2tlbicgXAogIC0tZG9ja2VyLXBhc3N3b3JkPSIkTkdDX0FQSV9LRVkiIFwK" + - "ICAtLW5hbWVzcGFjZT1udmNhLW9wZXJhdG9yIFwKICAtLWRyeS1ydW49Y2xpZW50IC1vIHlhbWwg" + - "fCBcCiAga3ViZWN0bCAtLWNvbnRleHQgPGNvbXB1dGUtcGxhbmUtY29udGV4dD4gYXBwbHkgLWYg" + - "LQpgYGAKClJlZmVyZW5jZSBpdCBpbiB0aGUgY29tcHV0ZS1wbGFuZSBlbnZpcm9ubWVudCBmaWxl" + - "OgoKYGBgeWFtbApnbG9iYWw6CiAgaW1hZ2VQdWxsU2VjcmV0czoKICAgIC0gbmFtZTogbnZjci1j" + - "cmVkcwpgYGAKClRoZSBjaGFydCBhbmQgb3BlcmF0b3IgdXNlIHRoYXQgcmVmZXJlbmNlIGluIGBu" + - "dmNhLW9wZXJhdG9yYCBhbmQgbWlycm9yIHRoZQpzZWNyZXQgdG8gYG52Y2Etc3lzdGVtYC4gRG8g" + - "bm90IGNyZWF0ZSBhIGJyb2FkZXIgbWFudWFsIGNvbXB1dGUgbmFtZXNwYWNlIGxpc3QuIEZvbGxv" + - "dwpbU3BsaXQgQ29tcHV0ZS1QbGFuZSBJbnN0YWxsYXRpb25dKGNvbXB1dGUtcGxhbmUtaW5zdGFs" + - "bGF0aW9uLm1kKSBmb3IgdGhlCnNlbGVjdGVkIGluc3RhbGwgZmxvdy4KCiMjIFZlcmlmaWNhdGlv" + - "bgoKYGBgYmFzaAojIENoZWNrIHRoYXQgYSBjb250cm9sLXBsYW5lIHBvZCBoYXMgdGhlIGluamVj" + - "dGVkIHNlY3JldAprdWJlY3RsIC0tY29udGV4dCA8Y29udHJvbC1wbGFuZS1jb250ZXh0PiBnZXQg" + - "cG9kIC1uIDxuYW1lc3BhY2U+IDxwb2QtbmFtZT4gXAogIC1vIGpzb25wYXRoPSd7LnNwZWMuaW1h" + - "Z2VQdWxsU2VjcmV0c30nCiMgRXhwZWN0ZWQ6IFt7Im5hbWUiOiJudmNyLWNyZWRzIn1dCgojIENo" + - "ZWNrIHRoZSBLeXZlcm5vIGFubm90YXRpb24Ka3ViZWN0bCAtLWNvbnRleHQgPGNvbnRyb2wtcGxh" + - "bmUtY29udGV4dD4gZ2V0IHBvZCAtbiA8bmFtZXNwYWNlPiA8cG9kLW5hbWU+IFwKICAtbyBqc29u" + - "cGF0aD0ney5tZXRhZGF0YS5hbm5vdGF0aW9ucy5udmNmXC5udmlkaWFcLmNvbS9pbWFnZXB1bGxz" + - "ZWNyZXQtaW5qZWN0ZWQtYnl9JwojIEV4cGVjdGVkOiBreXZlcm5vCgojIENoZWNrIHB1bGwgZXZl" + - "bnRzCmt1YmVjdGwgLS1jb250ZXh0IDxjb250cm9sLXBsYW5lLWNvbnRleHQ+IGdldCBldmVudHMg" + - "LW4gPG5hbWVzcGFjZT4gXAogIC0tc29ydC1ieT0nLmxhc3RUaW1lc3RhbXAnIHwgZ3JlcCAtaSBw" + - "dWxsCiMgU2hvdWxkIHNob3cgIlN1Y2Nlc3NmdWxseSBwdWxsZWQiIG5vdCAiNDAxIFVuYXV0aG9y" + - "aXplZCIKCiMgQ2hlY2sgdGhlIGNoYXJ0L29wZXJhdG9yIG1pcnJvciBvbiB0aGUgY29tcHV0ZSBj" + - "bHVzdGVyCmt1YmVjdGwgLS1jb250ZXh0IDxjb21wdXRlLXBsYW5lLWNvbnRleHQ+IGdldCBzZWNy" + - "ZXQgbnZjci1jcmVkcyBcCiAgLW4gbnZjYS1zeXN0ZW0KYGBgCgojIyBXaGVuIFB1bGwgU2VjcmV0" + - "cyBBcmUgTm90IE5lZWRlZAoKLSAqKkFXUyBFQ1Igd2l0aCBJQU0gbm9kZSByb2xlcyoqOiBJZiB5" + - "b3VyIG5vZGVzIGhhdmUgYEFtYXpvbkVDMkNvbnRhaW5lclJlZ2lzdHJ5UmVhZE9ubHlgIElBTSBw" + - "b2xpY3ksIEt1YmVybmV0ZXMgY2FuIHB1bGwgZnJvbSBFQ1Igd2l0aG91dCBleHBsaWNpdCBzZWNy" + - "ZXRzLgotICoqUHVibGljIHJlZ2lzdHJpZXMqKjogTm8gcHVsbCBzZWNyZXRzIG5lZWRlZC4KLSAq" + - "KkNTUCBidWlsdC1pbiBjcmVkZW50aWFsIGhlbHBlcnMqKjogR0tFIEFydGlmYWN0IFJlZ2lzdHJ5" + - "LCBBenVyZSBBQ1Igd2l0aCBtYW5hZ2VkIGlkZW50aXR5LCBhbmQgc2ltaWxhciBzZXJ2aWNlcy4K" + - "CiMjIFRyb3VibGVzaG9vdGluZwoKIyMjIFBvZHMgc3RpbGwgaW4gSW1hZ2VQdWxsQmFja09mZiBh" + - "ZnRlciBhcHBseWluZyBwb2xpY3kKClRoZSBLeXZlcm5vIHBvbGljeSBvbmx5IGFmZmVjdHMgcG9k" + - "cyBjcmVhdGVkICoqYWZ0ZXIqKiB0aGUgcG9saWN5IGlzIGFwcGxpZWQuIERlbGV0ZSBzdHVjayBw" + - "b2RzIHRvIHRyaWdnZXIgcmVjcmVhdGlvbjoKCmBgYGJhc2gKa3ViZWN0bCAtLWNvbnRleHQgPHRh" + - "cmdldC1jb250ZXh0PiBkZWxldGUgcG9kcyAtbiA8bmFtZXNwYWNlPiAtLWFsbApgYGAKCiMjIyBL" + - "eXZlcm5vIGFkbWlzc2lvbiBjb250cm9sbGVyIG5vdCBydW5uaW5nCgpgYGBiYXNoCmt1YmVjdGwg" + - "LS1jb250ZXh0IDxjb250cm9sLXBsYW5lLWNvbnRleHQ+IGdldCBwb2RzIC1uIGt5dmVybm8KIyBB" + - "bGwgcG9kcyBzaG91bGQgYmUgUnVubmluZwpgYGAKCiMjIyBQb2xpY3kgbm90IG1hdGNoaW5nCgpg" + - "YGBiYXNoCmt1YmVjdGwgLS1jb250ZXh0IDxjb250cm9sLXBsYW5lLWNvbnRleHQ+IGdldCBjbHVz" + - "dGVycG9saWN5IG52Y2YtYWRkLWltYWdlcHVsbHNlY3JldHMKIyBTaG91bGQgc2hvdyBSRUFEWTog" + - "VHJ1ZQpgYGAKCiMjIyBXcm9uZyBzZWNyZXQgbmFtZQoKVGhlIHBvbGljeSByZWZlcmVuY2VzIGBu" + - "dmNyLWNyZWRzYC4gVmVyaWZ5IHRoZSBzZWNyZXQgZXhpc3RzIHdpdGggdGhhdCBleGFjdCBuYW1l" + - "OgoKYGBgYmFzaAprdWJlY3RsIC0tY29udGV4dCA8dGFyZ2V0LWNvbnRleHQ+IGdldCBzZWNyZXQg" + - "bnZjci1jcmVkcyAtbiA8bmFtZXNwYWNlPgpgYGAKUEsHCEtCNagAFgAAABYAAFBLAQIUABQACAAA" + - "AAAAIQC63yMzSRAAAEkQAAASAAkAAAAAAAAAAAAAAAAAAABkYXRhL21hbmlmZXN0Lmpzb25VVAUA" + - "AQCmzhJQSwECFAAUAAgAAAAAACEAzYEw5E1hAABNYQAAIwAJAAAAAAAAAAAAAACSEAAAZGF0YS9u" + - "dmNmLXNlbGYtbWFuYWdlZC1jbGkvU0tJTEwubWRVVAUAAQCmzhJQSwECFAAUAAgAAAAAACEAIcbI" + - "hvAKAADwCgAAMwAJAAAAAAAAAAAAAAA5cgAAZGF0YS9udmNmLXNlbGYtbWFuYWdlZC1jbGkvZXhh" + - "bXBsZXMvY2ktcGlwZWxpbmVzLm1kVVQFAAEAps4SUEsBAhQAFAAIAAAAAAAhAKEU44FdDAAAXQwA" + - "ADQACQAAAAAAAAAAAAAAk30AAGRhdGEvbnZjZi1zZWxmLW1hbmFnZWQtY2xpL2V4YW1wbGVzL211" + - "bHRpLWNsdXN0ZXIubWRVVAUAAQCmzhJQSwECFAAUAAgAAAAAACEAQidJDwUNAAAFDQAANwAJAAAA" + - "AAAAAAAAAABbigAAZGF0YS9udmNmLXNlbGYtbWFuYWdlZC1jbGkvcHJvbXB0cy9hZGQtY29tcHV0" + - "ZS1wbGFuZS5tZFVUBQABAKbOElBLAQIUABQACAAAAAAAIQCR3Bv5mBkAAJgZAAA5AAkAAAAAAAAA" + - "AAAAAM6XAABkYXRhL252Y2Ytc2VsZi1tYW5hZ2VkLWNsaS9wcm9tcHRzL2NyZWF0ZS1hbmQtcnVu" + - "LXRhc2subWRVVAUAAQCmzhJQSwECFAAUAAgAAAAAACEA0kPcBBglAAAYJQAANwAJAAAAAAAAAAAA" + - "AADWsQAAZGF0YS9udmNmLXNlbGYtbWFuYWdlZC1jbGkvcHJvbXB0cy9kZXBsb3ktYW5kLWludm9r" + - "ZS5tZFVUBQABAKbOElBLAQIUABQACAAAAAAAIQAOnD+XvQ4AAL0OAAA9AAkAAAAAAAAAAAAAAFzX" + - "AABkYXRhL252Y2Ytc2VsZi1tYW5hZ2VkLWNsaS9wcm9tcHRzL2RpYWdub3NlLWZhaWxlZC1pbnN0" + - "YWxsLm1kVVQFAAEAps4SUEsBAhQAFAAIAAAAAAAhAN87AzejJwAAoycAADoACQAAAAAAAAAAAAAA" + - "jeYAAGRhdGEvbnZjZi1zZWxmLW1hbmFnZWQtY2xpL3Byb21wdHMvaW5zdGFsbC1mcm9tLXNjcmF0" + - "Y2gubWRVVAUAAQCmzhJQSwECFAAUAAgAAAAAACEAGsQsnscHAADHBwAAOQAJAAAAAAAAAAAAAACh" + - "DgEAZGF0YS9udmNmLXNlbGYtbWFuYWdlZC1jbGkvcHJvbXB0cy9yb3RhdGUtY2x1c3Rlci1qd2tz" + - "Lm1kVVQFAAEAps4SUEsBAhQAFAAIAAAAAAAhABKTM1ngIQAA4CEAAC4ACQAAAAAAAAAAAAAA2BYB" + - "AGRhdGEvbnZjZi1zZWxmLW1hbmFnZWQtY2xpL3Byb21wdHMvdGVhcmRvd24ubWRVVAUAAQCmzhJQ" + - "SwECFAAUAAgAAAAAACEAcg0PZCEjAAAhIwAAMAAJAAAAAAAAAAAAAAAdOQEAZGF0YS9udmNmLXNl" + - "bGYtbWFuYWdlZC1jbGkvcmVmZXJlbmNlL2NvbW1hbmRzLm1kVVQFAAEAps4SUEsBAhQAFAAIAAAA" + - "AAAhAHOnWmTVBgAA1QYAADIACQAAAAAAAAAAAAAApVwBAGRhdGEvbnZjZi1zZWxmLW1hbmFnZWQt" + - "Y2xpL3JlZmVyZW5jZS9leGl0LWNvZGVzLm1kVVQFAAEAps4SUEsBAhQAFAAIAAAAAAAhAPyjkeDG" + - "IgAAxiIAAC0ACQAAAAAAAAAAAAAA42MBAGRhdGEvbnZjZi1zZWxmLW1hbmFnZWQtY2xpL3JlZmVy" + - "ZW5jZS9mbGFncy5tZFVUBQABAKbOElBLAQIUABQACAAAAAAAIQDzrhOEdBEAAHQRAAA3AAkAAAAA" + - "AAAAAAAAAA2HAQBkYXRhL252Y2Ytc2VsZi1tYW5hZ2VkLWNsaS9yZWZlcmVuY2UvdHJvdWJsZXNo" + - "b290aW5nLm1kVVQFAAEAps4SUEsBAhQAFAAIAAAAAAAhAC/auXVCYgAAQmIAACwACQAAAAAAAAAA" + - "AAAA75gBAGRhdGEvbnZjZi1zZWxmLW1hbmFnZWQtaW5zdGFsbGF0aW9uL1NLSUxMLm1kVVQFAAEA" + - "ps4SUEsBAhQAFAAIAAAAAAAhACsTuD+tVQAArVUAADQACQAAAAAAAAAAAAAAlPsBAGRhdGEvbnZj" + - "Zi1zZWxmLW1hbmFnZWQtaW5zdGFsbGF0aW9uL2V2YWxzL2V2YWxzLmpzb25VVAUAAQCmzhJQSwEC" + - "FAAUAAgAAAAAACEAAlJOQH8oAAB/KAAALwAJAAAAAAAAAAAAAACsUQIAZGF0YS9udmNmLXNlbGYt" + - "bWFuYWdlZC1pbnN0YWxsYXRpb24vZXhhbXBsZXMubWRVVAUAAQCmzhJQSwECFAAUAAgAAAAAACEA" + - "lmO8WRIwAAASMAAATAAJAAAAAAAAAAAAAACRegIAZGF0YS9udmNmLXNlbGYtbWFuYWdlZC1pbnN0" + - "YWxsYXRpb24vcmVmZXJlbmNlcy9jb21wdXRlLXBsYW5lLWluc3RhbGxhdGlvbi5tZFVUBQABAKbO" + - "ElBLAQIUABQACAAAAAAAIQBWPmeQlTAAAJUwAAA7AAkAAAAAAAAAAAAAACarAgBkYXRhL252Y2Yt" + - "c2VsZi1tYW5hZ2VkLWluc3RhbGxhdGlvbi9yZWZlcmVuY2VzL2RlYnVnZ2luZy5tZFVUBQABAKbO" + - "ElBLAQIUABQACAAAAAAAIQDAViDnjycAAI8nAABEAAkAAAAAAAAAAAAAAC3cAgBkYXRhL252Y2Yt" + - "c2VsZi1tYW5hZ2VkLWluc3RhbGxhdGlvbi9yZWZlcmVuY2VzL2hlbG1maWxlLXN0cnVjdHVyZS5t" + - "ZFVUBQABAKbOElBLAQIUABQACAAAAAAAIQA4+SevuQcAALkHAAA/AAkAAAAAAAAAAAAAADcEAwBk" + - "YXRhL252Y2Ytc2VsZi1tYW5hZ2VkLWluc3RhbGxhdGlvbi9yZWZlcmVuY2VzL252Y2YtdWktYWRk" + - "b24ubWRVVAUAAQCmzhJQSwECFAAUAAgAAAAAACEAS0I1qAAWAAAAFgAAPgAJAAAAAAAAAAAAAABm" + - "DAMAZGF0YS9udmNmLXNlbGYtbWFuYWdlZC1pbnN0YWxsYXRpb24vcmVmZXJlbmNlcy9wdWxsLXNl" + - "Y3JldHMubWRVVAUAAQCmzhJQSwUGAAAAABcAFwCvCQAA2yIDAAAA" + "YWJsZS1pY21zLXVybD4gXAogIGRvd24gLS1wbGFuLW9ubHkgXAogIC0tY2x1c3Rlci1uYW1lIDxj" + + "b21wdXRlLXBsYW5lLWNsdXN0ZXItbmFtZT4gXAogIC0tbmNhLWlkIDxuY2EtaWQ+CgpudmNmLWNs" + + "aSAtLWNvbmZpZyA8Y29uZmlnPiBzZWxmLWhvc3RlZCBcCiAgLS1jb250cm9sLXBsYW5lLXN0YWNr" + + "IGRlcGxveS9zdGFja3Mvc2VsZi1tYW5hZ2VkIFwKICAtLWNvbXB1dGUtcGxhbmUtc3RhY2sgZGVw" + + "bG95L3N0YWNrcy9udmNmLWNvbXB1dGUtcGxhbmUgXAogIC0tZW52IDxlbnY+IFwKICAtLXBsYWlu" + + "IFwKICAtLWNvbnRyb2wtcGxhbmUtY29udGV4dCA8Y29udHJvbC1wbGFuZS1jb250ZXh0PiBcCiAg" + + "LS1jb21wdXRlLXBsYW5lLWNvbnRleHQgPGNvbXB1dGUtcGxhbmUtY29udGV4dD4gXAogIC0taWNt" + + "cy11cmwgPGNvbXB1dGUtcmVhY2hhYmxlLWljbXMtdXJsPiBcCiAgZG93biBcCiAgLS1jbHVzdGVy" + + "LW5hbWUgPGNvbXB1dGUtcGxhbmUtY2x1c3Rlci1uYW1lPiBcCiAgLS1uY2EtaWQgPG5jYS1pZD4K" + + "YGBgCgpSZXBlYXQgYGRvd25gIGZvciBlYWNoIGNvbXB1dGUgY2x1c3Rlci4gRWFjaCBydW4gZGVz" + + "dHJveXMgdGhhdCBjb21wdXRlIHBsYW5lIGFuZAp1bnJlZ2lzdGVycyBpdHMgSUNNUyByb3cuIEl0" + + "IHJlbW92ZXMgdGhlIGNvbnRyb2wgcGxhbmUgb25seSBhZnRlciBubyBjbHVzdGVyCnJlZ2lzdHJh" + + "dGlvbnMgcmVtYWluLgpQSwcIlmO8WRIwAAASMAAAUEsDBBQACAAAAAAAIQAAAAAAAAAAAAAAAAA7" + + "AAkAZGF0YS9udmNmLXNlbGYtbWFuYWdlZC1pbnN0YWxsYXRpb24vcmVmZXJlbmNlcy9kZWJ1Z2dp" + + "bmcubWRVVAUAAQCmzhIjIERlYnVnZ2luZyBSZWZlcmVuY2UKClJlY2lwZXMgZm9yIGRpYWdub3Np" + + "bmcgYW5kIGZpeGluZyBjb21tb24gTlZDRiBzZWxmLW1hbmFnZWQgc3RhY2sgZmFpbHVyZXMuCgoj" + + "IyBRdWljayBTdGF0dXMgQ29tbWFuZHMKCmBgYGJhc2gKIyBBbGwgcG9kcyBhY3Jvc3MgYWxsIG5h" + + "bWVzcGFjZXMKa3ViZWN0bCBnZXQgcG9kcyAtQSAtbyB3aWRlCgojIFBvZHMgaW4gYSBzcGVjaWZp" + + "YyBuYW1lc3BhY2UKa3ViZWN0bCBnZXQgcG9kcyAtbiA8bmFtZXNwYWNlPgoKIyBBbGwgaGVsbSBy" + + "ZWxlYXNlcwpoZWxtIGxpc3QgLUEKCiMgUmVjZW50IGV2ZW50cyAobW9zdCB1c2VmdWwgZm9yIGRp" + + "YWdub3NpbmcgZmFpbHVyZXMpCmt1YmVjdGwgZ2V0IGV2ZW50cyAtbiA8bmFtZXNwYWNlPiAtLXNv" + + "cnQtYnk9Jy5sYXN0VGltZXN0YW1wJwoKIyBEZXNjcmliZSBhIHNwZWNpZmljIHBvZCAoc2hvd3Mg" + + "ZXZlbnRzLCBjb25kaXRpb25zLCB2b2x1bWVzKQprdWJlY3RsIGRlc2NyaWJlIHBvZCAtbiA8bmFt" + + "ZXNwYWNlPiA8cG9kLW5hbWU+CmBgYAoKIyMgRmFpbHVyZTogSW1hZ2VQdWxsQmFja09mZgoKIyMj" + + "IFN5bXB0b21zCgpgYGAKTkFNRSAgICAgICAgICAgUkVBRFkgICBTVEFUVVMgICAgICAgICAgICAg" + + "UkVTVEFSVFMgICBBR0UKY2Fzc2FuZHJhLTAgICAgMC8xICAgICBJbWFnZVB1bGxCYWNrT2ZmICAg" + + "MCAgICAgICAgICA1bQpgYGAKCkV2ZW50cyBzaG93OgpgYGAKRmFpbGVkIHRvIHB1bGwgaW1hZ2Ug" + + "Im52Y3IuaW8vLi4uL2ltYWdlOnRhZyI6IDQwMSBVbmF1dGhvcml6ZWQKYGBgCgojIyMgRGlhZ25v" + + "c2lzCgpgYGBiYXNoCiMgQ2hlY2sgd2hhdCBpbWFnZSBpcyBmYWlsaW5nCmt1YmVjdGwgZGVzY3Jp" + + "YmUgcG9kIC1uIDxuYW1lc3BhY2U+IDxwb2QtbmFtZT4gfCBncmVwIC1BNSAiRXZlbnRzOiIKCiMg" + + "Q2hlY2sgaWYgcHVsbCBzZWNyZXQgZXhpc3RzIGluIHRoZSBuYW1lc3BhY2UKa3ViZWN0bCBnZXQg" + + "c2VjcmV0IG52Y3ItY3JlZHMgLW4gPG5hbWVzcGFjZT4KCiMgQ2hlY2sgaWYgdGhlIHBvZCBzcGVj" + + "IGhhcyBpbWFnZVB1bGxTZWNyZXRzCmt1YmVjdGwgZ2V0IHBvZCAtbiA8bmFtZXNwYWNlPiA8cG9k" + + "LW5hbWU+IC1vIGpzb25wYXRoPSd7LnNwZWMuaW1hZ2VQdWxsU2VjcmV0c30nCgojIENoZWNrIGlm" + + "IHRoZSBTZXJ2aWNlQWNjb3VudCBoYXMgaW1hZ2VQdWxsU2VjcmV0cwprdWJlY3RsIGdldCBzYSA8" + + "c2EtbmFtZT4gLW4gPG5hbWVzcGFjZT4gLW8ganNvbnBhdGg9J3suaW1hZ2VQdWxsU2VjcmV0c30n" + + "CmBgYAoKIyMjIEZpeGVzCgoxLiAqKlNlY3JldCBtaXNzaW5nIGluIG5hbWVzcGFjZSoqOiBDcmVh" + + "dGUgaXQKICAgYGBgYmFzaAogICBrdWJlY3RsIGNyZWF0ZSBzZWNyZXQgZG9ja2VyLXJlZ2lzdHJ5" + + "IG52Y3ItY3JlZHMgXAogICAgIC0tZG9ja2VyLXNlcnZlcj1udmNyLmlvIFwKICAgICAtLWRvY2tl" + + "ci11c2VybmFtZT0nJG9hdXRodG9rZW4nIFwKICAgICAtLWRvY2tlci1wYXNzd29yZD0iJE5HQ19B" + + "UElfS0VZIiBcCiAgICAgLS1uYW1lc3BhY2U9PG5hbWVzcGFjZT4gXAogICAgIC0tZHJ5LXJ1bj1j" + + "bGllbnQgLW8geWFtbCB8IGt1YmVjdGwgYXBwbHkgLWYgLQogICBgYGAKCjIuICoqU2VjcmV0IGV4" + + "aXN0cyBidXQgcG9kIGRvZXNuJ3QgcmVmZXJlbmNlIGl0Kio6IFRoZSBjaGFydCBuZWVkcyBgaW1h" + + "Z2VQdWxsU2VjcmV0c2AgY29uZmlndXJlZCB2aWEgaGVsbWZpbGUgdmFsdWVzLiBTZWUgW3B1bGwt" + + "c2VjcmV0cy5tZF0ocHVsbC1zZWNyZXRzLm1kKS4KCjMuICoqQ2hhcnQgZG9lc24ndCBzdXBwb3J0" + + "IGltYWdlUHVsbFNlY3JldHMqKiAob3BlbmJhbywgaW52b2NhdGlvbi1zZXJ2aWNlLCBlc3MtYXBp" + + "LCBub3Rhcnktc2VydmljZSk6IFBhdGNoIFNlcnZpY2VBY2NvdW50cyBhbmQgcmVzdGFydCBwb2Rz" + + "LiBTZWUgW3B1bGwtc2VjcmV0cy5tZF0ocHVsbC1zZWNyZXRzLm1kKS4KCjQuICoqV3JvbmcgY3Jl" + + "ZGVudGlhbHMgaW4gc2VjcmV0Kio6IERlbGV0ZSBhbmQgcmVjcmVhdGUKICAgYGBgYmFzaAogICBr" + + "dWJlY3RsIGRlbGV0ZSBzZWNyZXQgbnZjci1jcmVkcyAtbiA8bmFtZXNwYWNlPgogICAjIFJlY3Jl" + + "YXRlIHdpdGggY29ycmVjdCBjcmVkZW50aWFscwogICBgYGAKCiMjIEZhaWx1cmU6IEluaXQ6MC8x" + + "IFN0dWNrIChWYXVsdCBBZ2VudCkKCiMjIyBTeW1wdG9tcwoKU2VydmljZSBwb2RzIHN0dWNrIGlu" + + "IGBJbml0OjAvMWAgZm9yIG1pbnV0ZXM6CmBgYApOQU1FICAgICAgICAgICAgICAgICAgICAgICAg" + + "UkVBRFkgICBTVEFUVVMgICAgIFJFU1RBUlRTICAgQUdFCm52Y2YtYXBpLTdmNGM3NmY3ODgtNDR2" + + "bHQgIDAvMiAgICAgSW5pdDowLzEgICAwICAgICAgICAgIDEwbQpgYGAKCiMjIyBEaWFnbm9zaXMK" + + "ClRoZSBpbml0IGNvbnRhaW5lciBpcyB0aGUgdmF1bHQtYWdlbnQtaW5pdCBpbmplY3RvciB3YWl0" + + "aW5nIGZvciBPcGVuQmFvLgoKYGBgYmFzaAojIENoZWNrIE9wZW5CYW8gcG9kcwprdWJlY3RsIGdl" + + "dCBwb2RzIC1uIHZhdWx0LXN5c3RlbQoKIyBDaGVjayBpZiBPcGVuQmFvIG1pZ3JhdGlvbiBqb2Ig" + + "cmFuCmt1YmVjdGwgZ2V0IGpvYnMgLW4gdmF1bHQtc3lzdGVtCgojIENoZWNrIE9wZW5CYW8gcG9k" + + "IGxvZ3MKa3ViZWN0bCBsb2dzIC1uIHZhdWx0LXN5c3RlbSBvcGVuYmFvLXNlcnZlci0wIC1jIG9w" + + "ZW5iYW8KCiMgQ2hlY2sgaW5pdCBjb250YWluZXIgbG9ncyBvbiB0aGUgc3R1Y2sgcG9kCmt1YmVj" + + "dGwgbG9ncyAtbiA8bmFtZXNwYWNlPiA8cG9kLW5hbWU+IC1jIHZhdWx0LWFnZW50LWluaXQKYGBg" + + "CgojIyMgRml4ZXMKCjEuICoqT3BlbkJhbyBwb2RzIG5vdCBydW5uaW5nKio6IENoZWNrIHRoZWly" + + "IGV2ZW50cyBmb3IgaW1hZ2UgcHVsbCBpc3N1ZXMsIHJlc291cmNlIGlzc3VlcywgZXRjLgoKMi4g" + + "KipPcGVuQmFvIG1pZ3JhdGlvbiBqb2IgZGlkbid0IHJ1bioqOiBUaGlzIGhhcHBlbnMgd2hlbiBg" + + "aGVsbWZpbGUgc3luY2Agd2FzIGludGVycnVwdGVkLiBEZXN0cm95IGFuZCByZS1zeW5jIG9wZW5i" + + "YW86CiAgIGBgYGJhc2gKICAgSEVMTUZJTEVfRU5WPTxlbnY+IGhlbG1maWxlIC0tc2VsZWN0b3Ig" + + "bmFtZT1vcGVuYmFvLXNlcnZlciBkZXN0cm95CiAgIGt1YmVjdGwgZGVsZXRlIG5hbWVzcGFjZSB2" + + "YXVsdC1zeXN0ZW0KICAga3ViZWN0bCBjcmVhdGUgbmFtZXNwYWNlIHZhdWx0LXN5c3RlbQogICAj" + + "IFJlLWNyZWF0ZSBwdWxsIHNlY3JldCBpZiBuZWVkZWQKICAgSEVMTUZJTEVfRU5WPTxlbnY+IGhl" + + "bG1maWxlIC0tc2VsZWN0b3IgbmFtZT1vcGVuYmFvLXNlcnZlciBzeW5jCiAgIGBgYAoKMy4gKipP" + + "cGVuQmFvIHBvZHMgcnVubmluZyBidXQgbm90IGluaXRpYWxpemVkKio6IENoZWNrIHVuc2VhbCBz" + + "dGF0dXM6CiAgIGBgYGJhc2gKICAga3ViZWN0bCBleGVjIC1uIHZhdWx0LXN5c3RlbSBvcGVuYmFv" + + "LXNlcnZlci0wIC1jIG9wZW5iYW8gLS0gYmFvIHN0YXR1cwogICBgYGAKCjQuICoqYHZhdWx0LWFn" + + "ZW50LWluaXRgIGxvZ3MgYGF1dGgvand0L2xvZ2luYCAtPiBgNDAwIC4uLiBubyBrbm93biBrZXkg" + + "c3VjY2Vzc2Z1bGx5IHZhbGlkYXRlZCB0aGUgdG9rZW4gc2lnbmF0dXJlYCoqCiAgIChjb21tb24g" + + "b24gQUtTLCBhbmQgb24gYW55IGNsdXN0ZXIgd2hvc2UgT0lEQyBpc3N1ZXIgcHVibGlzaGVzIGEg" + + "cm90YXRpbmcgbXVsdGkta2V5IEpXS1MpOgogICB0aGUgT3BlbkJhbyBgYXV0aC9qd3RgIG1ldGhv" + + "ZCB3YXMgY29uZmlndXJlZCB3aXRoIGEgc2luZ2xlIHN0YXRpYyBtb3VudGVkIHB1YmxpYyBrZXkK" + + "ICAgKGBqd3RfdmFsaWRhdGlvbl9wdWJrZXlzYCkgaW5zdGVhZCBvZiB0aGUgaXNzdWVyJ3MgbGl2" + + "ZSBKV0tTLCBzbyBpdCBjYW5ub3QgdmFsaWRhdGUgdGhlCiAgIGNsdXN0ZXItc2lnbmVkIFNlcnZp" + + "Y2VBY2NvdW50IHRva2VucyB0aGUgdmF1bHQtYWdlbnRzIHByZXNlbnQuIEV2ZXJ5IHNlcnZpY2Un" + + "cwogICBgdmF1bHQtYWdlbnQtaW5pdGAgdGhlbiBsb29wcyBvbiB0aGF0IDQwMCBhbmQgdGhlIHBv" + + "ZCBuZXZlciBsZWF2ZXMgYEluaXQ6MC8xYC4gVGhpcyBpcyB0aGUKICAgYmVoYXZpb3Igb2YgdGhl" + + "IGJhc2UgZGVmYXVsdCBgb3BlbmJhby5taWdyYXRpb25zLmlzc3VlckRpc2NvdmVyeS5lbmFibGVk" + + "OiBmYWxzZWA7IHRoZQogICBtaWdyYXRpb24gbG9nIHNob3dzIGBPSURDIGlzc3VlciBkaXNjb3Zl" + + "cnkgaXMgZGlzYWJsZWQuIFVzaW5nIFNlcnZpY2VBY2NvdW50IGlzc3VlciBhbmQKICAgbW91bnRl" + + "ZCBwdWJsaWMga2V5IGZhbGxiYWNrYC4gRW5hYmxlIGlzc3VlciBkaXNjb3Zlcnkgc28gdGhlIG1p" + + "Z3JhdGlvbiB1c2VzIHRoZSBsaXZlIEpXS1MsCiAgIHRoZW4gcmUtcnVuIGl0OgogICBgYGBiYXNo" + + "CiAgICMgSW4geW91ciBlbnYgdmFsdWVzIChlLmcuIGVudmlyb25tZW50cy88ZW52Pi55YW1sKSwg" + + "c2V0OgogICAjICAgb3BlbmJhbzoKICAgIyAgICAgbWlncmF0aW9uczoKICAgIyAgICAgICBpc3N1" + + "ZXJEaXNjb3Zlcnk6CiAgICMgICAgICAgICBlbmFibGVkOiB0cnVlCiAgIGt1YmVjdGwgZGVsZXRl" + + "IGpvYiAtbiB2YXVsdC1zeXN0ZW0gb3BlbmJhby1zZXJ2ZXItbWlncmF0aW9ucwogICBIRUxNRklM" + + "RV9FTlY9PGVudj4gaGVsbWZpbGUgLS1zZWxlY3RvciBuYW1lPW9wZW5iYW8tc2VydmVyIHN5bmMK" + + "ICAgYGBgCiAgIFRoZSBtaWdyYXRpb24gbG9nIHNob3VsZCB0aGVuIHNob3cgYFJlY2VpdmVkIGRp" + + "c2NvdmVyeSBkb2N1bWVudCBmcm9tCiAgIC4uLi8ud2VsbC1rbm93bi9vcGVuaWQtY29uZmlndXJh" + + "dGlvbmAgYW5kIGBGaW5hbCBPcGVuQmFvIEpXVCBKV0tTIFVSTCBzZXQgdG86CiAgIC4uLi9vcGVu" + + "aWQvdjEvandrc2AsIGFuZCB0aGUgc2VydmljZSBwb2RzIGF1dGhlbnRpY2F0ZSBhbmQgcmVhY2gg" + + "UmVhZHkgd2l0aGluIH4xIG1pbi4KICAgQUtTIGNsdXN0ZXJzIHdpdGggdGhlIGNsdXN0ZXIgT0lE" + + "QyBpc3N1ZXIgZW5hYmxlZCAodGhlIGBha3MtY2x1c3RlcmAgZGVmYXVsdCkgYWx3YXlzIG5lZWQK" + + "ICAgdGhpcyBiZWNhdXNlIHRoZSBzdGF0aWMtcHVia2V5IGZhbGxiYWNrIGNhbm5vdCBtYXRjaCB0" + + "aGUgaXNzdWVyJ3Mgcm90YXRpbmcgc2lnbmluZyBrZXlzLgoKIyMgRmFpbHVyZTogT09NS2lsbGVk" + + "IG9uIENhc3NhbmRyYQoKIyMjIFN5bXB0b21zCgpgYGAKTkFNRSAgICAgICAgICBSRUFEWSAgIFNU" + + "QVRVUyAgICBSRVNUQVJUUyAgIEFHRQpjYXNzYW5kcmEtMCAgIDAvMSAgICAgT09NS2lsbGVkICAz" + + "ICAgICAgICAgMTBtCmBgYAoKIyMjIERpYWdub3NpcwoKYGBgYmFzaAprdWJlY3RsIGRlc2NyaWJl" + + "IHBvZCAtbiBjYXNzYW5kcmEtc3lzdGVtIGNhc3NhbmRyYS0wIHwgZ3JlcCAtQTMgIkxhc3QgU3Rh" + + "dGUiCmBgYAoKIyMjIEZpeAoKT3ZlcnJpZGUgQ2Fzc2FuZHJhIHJlc291cmNlcyB2aWEgaGVsbWZp" + + "bGUgdmFsdWVzLiBTZWUgRXhhbXBsZSAxIGluCltleGFtcGxlcy5tZF0oLi4vZXhhbXBsZXMubWQp" + + "LgoKYGBgeWFtbAotIGNhc3NhbmRyYToKICAgIHJlc291cmNlczoKICAgICAgbGltaXRzOgogICAg" + + "ICAgIGNwdTogIjgiCiAgICAgICAgbWVtb3J5OiA4MTkyTWkKICAgICAgcmVxdWVzdHM6CiAgICAg" + + "ICAgY3B1OiAiMiIKICAgICAgICBtZW1vcnk6IDQwOTZNaQpgYGAKCk5vdGU6IGByZXNvdXJjZVBy" + + "ZXNldGAgaXMgbm90IGF2YWlsYWJsZSBpbiB0aGUgTlZDRiBjYXNzYW5kcmEgd3JhcHBlciBjaGFy" + + "dC4gVXNlIGV4cGxpY2l0IGByZXNvdXJjZXNgLgoKIyMgRmFpbHVyZTogUG9kcyBTdHVjayBpbiBQ" + + "ZW5kaW5nCgojIyMgU3ltcHRvbXMKCmBgYApOQU1FICAgICAgICAgIFJFQURZICAgU1RBVFVTICAg" + + "IFJFU1RBUlRTICAgQUdFCmNhc3NhbmRyYS0wICAgMC8xICAgICBQZW5kaW5nICAgMCAgICAgICAg" + + "ICAxMG0KYGBgCgojIyMgRGlhZ25vc2lzCgpgYGBiYXNoCiMgQ2hlY2sgZXZlbnRzIGZvciBzY2hl" + + "ZHVsaW5nIGZhaWx1cmVzCmt1YmVjdGwgZGVzY3JpYmUgcG9kIC1uIDxuYW1lc3BhY2U+IDxwb2Qt" + + "bmFtZT4KCiMgQ29tbW9uIGNhdXNlczoKIyAtICIwLzEyIG5vZGVzIGFyZSBhdmFpbGFibGU6IDEy" + + "IG5vZGUocykgZGlkbid0IG1hdGNoIFBvZCdzIG5vZGUgYWZmaW5pdHkiCiMgLSAiMC8xMiBub2Rl" + + "cyBhcmUgYXZhaWxhYmxlOiAxMiBJbnN1ZmZpY2llbnQgbWVtb3J5IgojIC0gInBlcnNpc3RlbnR2" + + "b2x1bWVjbGFpbSBub3QgZm91bmQiCmBgYAoKIyMjIEZpeGVzCgoxLiAqKk5vZGUgc2VsZWN0b3Ig" + + "bWlzbWF0Y2gqKjogQ2hlY2sgYG5vZGVTZWxlY3RvcnNgIGluIGVudmlyb25tZW50IGZpbGUKICAg" + + "YGBgYmFzaAogICBrdWJlY3RsIGdldCBub2RlcyAtLXNob3ctbGFiZWxzIHwgZ3JlcCBudmNmCiAg" + + "IGBgYAoKMi4gKipTdG9yYWdlIGNsYXNzIG5vdCBmb3VuZCoqOiBDaGVjayBzdG9yYWdlIGNsYXNz" + + "IGV4aXN0cwogICBgYGBiYXNoCiAgIGt1YmVjdGwgZ2V0IHN0b3JhZ2VjbGFzcwogICBgYGAKCjMu" + + "ICoqSW5zdWZmaWNpZW50IHJlc291cmNlcyoqOiBDaGVjayBub2RlIGNhcGFjaXR5CiAgIGBgYGJh" + + "c2gKICAga3ViZWN0bCBkZXNjcmliZSBub2RlIDxub2RlLW5hbWU+IHwgZ3JlcCAtQTUgIkFsbG9j" + + "YXRlZCByZXNvdXJjZXMiCiAgIGBgYAoKIyMgRmFpbHVyZTogSGVsbSBSZWxlYXNlIGluIEZhaWxl" + + "ZCBTdGF0ZQoKIyMjIFN5bXB0b21zCgpgYGBiYXNoCmhlbG0gbGlzdCAtQQojIFNob3dzIHJlbGVh" + + "c2Ugd2l0aCBTVEFUVVM6IGZhaWxlZApgYGAKClJlLXJ1bm5pbmcgYGhlbG1maWxlIHN5bmNgIGFw" + + "cGVhcnMgdG8gc3VjY2VlZCBidXQgc2VydmljZXMgZG9uJ3Qgd29yayAobWlncmF0aW9ucyBza2lw" + + "cGVkKS4KCiMjIyBEaWFnbm9zaXMKCmBgYGJhc2gKaGVsbSBoaXN0b3J5IDxyZWxlYXNlLW5hbWU+" + + "IC1uIDxuYW1lc3BhY2U+CmBgYAoKIyMjIEZpeAoKTXVzdCBkZXN0cm95IHRoZSBmYWlsZWQgcmVs" + + "ZWFzZSBhbmQgcmUtc3luYyAobm90IGp1c3QgYXBwbHkpOgoKYGBgYmFzaApIRUxNRklMRV9FTlY9" + + "PGVudj4gaGVsbWZpbGUgLS1zZWxlY3RvciBuYW1lPTxyZWxlYXNlPiBkZXN0cm95CiMgSWYgbmFt" + + "ZXNwYWNlIG5lZWRzIGNsZWFudXA6Cmt1YmVjdGwgZGVsZXRlIG5hbWVzcGFjZSA8bmFtZXNwYWNl" + + "PgprdWJlY3RsIGNyZWF0ZSBuYW1lc3BhY2UgPG5hbWVzcGFjZT4KIyBSZS1jcmVhdGUgcHVsbCBz" + + "ZWNyZXQgaWYgbmVlZGVkCkhFTE1GSUxFX0VOVj08ZW52PiBoZWxtZmlsZSAtLXNlbGVjdG9yIG5h" + + "bWU9PHJlbGVhc2U+IHN5bmMKYGBgCgojIyBGYWlsdXJlOiBBY2NvdW50IEJvb3RzdHJhcCBKb2Ig" + + "RmFpbGVkCgojIyMgU3ltcHRvbXMKClNlcnZpY2VzIGRlcGxveSBidXQgZnVuY3Rpb25zIGNhbid0" + + "IGJlIGNyZWF0ZWQuIEV2ZW50cyBzaG93IGJvb3RzdHJhcCBqb2IgZmFpbHVyZS4KCiMjIyBEaWFn" + + "bm9zaXMKCmBgYGJhc2gKIyBDaGVjayBib290c3RyYXAgam9iIHN0YXR1cwprdWJlY3RsIGdldCBq" + + "b2JzIC1uIG52Y2YKCiMgR2V0IGxvZ3MgKGpvYiBhdXRvLWRlbGV0ZXMgYWZ0ZXIgfjUgbWludXRl" + + "cykKa3ViZWN0bCBsb2dzIGpvYi9udmNmLWFwaS1hY2NvdW50LWJvb3RzdHJhcCAtbiBudmNmCgoj" + + "IENoZWNrIEFQSSBsb2dzCmt1YmVjdGwgbG9ncyAtbiBudmNmIC1sIGFwcC5rdWJlcm5ldGVzLmlv" + + "L25hbWU9bnZjZi1hcGkgLS10YWlsPTEwMApgYGAKCiMjIyBDb21tb24gQ2F1c2VzCgoxLiAqKldy" + + "b25nIGJhc2U2NCBjcmVkZW50aWFscyoqOiBDcmVkZW50aWFscyBpbiBgc2VjcmV0cy88ZW52Pi1z" + + "ZWNyZXRzLnlhbWxgIG11c3QgYmUgYCRvYXV0aHRva2VuOkFQSV9LRVlgIGJhc2U2NC1lbmNvZGVk" + + "LCBub3QganVzdCB0aGUgQVBJIGtleQogICBgYGBiYXNoCiAgICMgVmVyaWZ5IHlvdXIgZW5jb2Rl" + + "ZCBjcmVkZW50aWFsCiAgIGVjaG8gJ1lPVVJfQkFTRTY0X1NUUklORycgfCBiYXNlNjQgLWQKICAg" + + "IyBTaG91bGQgb3V0cHV0OiAkb2F1dGh0b2tlbjpudmFwaS14eHh4eAogICBgYGAKCjIuICoqUmVn" + + "aXN0cnkgdW5yZWFjaGFibGUqKjogQVBJIGNhbid0IHJlYWNoIHRoZSByZWdpc3RyeSBzcGVjaWZp" + + "ZWQgaW4gYGFjY291bnRCb290c3RyYXAucmVnaXN0cnlDcmVkZW50aWFsc2AKCiMjIyBGaXgKCkZp" + + "eCBjcmVkZW50aWFscyBpbiBzZWNyZXRzIGZpbGUsIHRoZW4gcmVjb3ZlciBzZXJ2aWNlcyB3aXRo" + + "b3V0IGRlc3Ryb3lpbmcgZGVwZW5kZW5jaWVzOgoKYGBgYmFzaApIRUxNRklMRV9FTlY9PGVudj4g" + + "aGVsbWZpbGUgLS1zZWxlY3RvciByZWxlYXNlLWdyb3VwPXNlcnZpY2VzIGRlc3Ryb3kKa3ViZWN0" + + "bCBkZWxldGUgbmFtZXNwYWNlIG52Y2YgYXBpLWtleXMgZXNzIHNpcyAtLWlnbm9yZS1ub3QtZm91" + + "bmQKa3ViZWN0bCBjcmVhdGUgbmFtZXNwYWNlIG52Y2YgJiYga3ViZWN0bCBjcmVhdGUgbmFtZXNw" + + "YWNlIGFwaS1rZXlzICYmIFwKICBrdWJlY3RsIGNyZWF0ZSBuYW1lc3BhY2UgZXNzICYmIGt1YmVj" + + "dGwgY3JlYXRlIG5hbWVzcGFjZSBzaXMKIyBSZS1jcmVhdGUgcHVsbCBzZWNyZXRzIGlmIG5lZWRl" + + "ZApIRUxNRklMRV9FTlY9PGVudj4gaGVsbWZpbGUgLS1zZWxlY3RvciByZWxlYXNlLWdyb3VwPXNl" + + "cnZpY2VzIHN5bmMKYGBgCgojIyBGYWlsdXJlOiBOVkNBIENsZWFudXAgU3R1Y2sgKEZpbmFsaXpl" + + "cnMpCgojIyMgU3ltcHRvbXMKCkNvbXB1dGUtcGxhbmUgY2xlYW51cCBoYW5ncy4gTmFtZXNwYWNl" + + "cwpzdHVjayBpbiBgVGVybWluYXRpbmdgOgoKYGBgYmFzaAprdWJlY3RsIGdldCBucwojIG52Y2Et" + + "b3BlcmF0b3IgICAgVGVybWluYXRpbmcgICAxMG0KIyBudmNmLWJhY2tlbmQgICAgIFRlcm1pbmF0" + + "aW5nICAgMTBtCmBgYAoKIyMjIEZpeAoKUnVuIHRoaXMgb25seSBhZ2FpbnN0IHRoZSBjb21wdXRl" + + "IGNvbnRleHQsIGFmdGVyIHRoZSBub3JtYWwgY29tcHV0ZS1wbGFuZQp0ZWFyZG93biBoYXMgZmFp" + + "bGVkLiBSZW1vdmUgZmluYWxpemVycyBmcm9tIE5WQ0ZCYWNrZW5kIGN1c3RvbSByZXNvdXJjZXMg" + + "YW5kCmZvcmNlLWRlbGV0ZSBzdHVjayBuYW1lc3BhY2VzOgoKYGBgYmFzaApleHBvcnQgQ09NUFVU" + + "RV9DT05URVhUPTxjb21wdXRlLXBsYW5lLWNvbnRleHQ+CgojIFJlbW92ZSBmaW5hbGl6ZXJzIGZy" + + "b20gTlZDRkJhY2tlbmQgcmVzb3VyY2VzCmt1YmVjdGwgLS1jb250ZXh0ICIkQ09NUFVURV9DT05U" + + "RVhUIiBnZXQgbnZjZmJhY2tlbmRzIC1BIC1vIGpzb24gfCBcCiAganEgJy5pdGVtc1tdIHwgLm1l" + + "dGFkYXRhLm5hbWVzcGFjZSArICIvIiArIC5tZXRhZGF0YS5uYW1lJyAtciB8IFwKICB4YXJncyAt" + + "SXt9IHNoIC1jICdjb250ZXh0PSIkMSI7IG5zPSIkezIlJS8qfSI7IG5hbWU9IiR7MiMjKi99Ijsg" + + "a3ViZWN0bCAtLWNvbnRleHQgIiRjb250ZXh0IiBwYXRjaCBudmNmYmFja2VuZCAiJG5hbWUiIC1u" + + "ICIkbnMiIC0tdHlwZT1tZXJnZSAtcCAie1wibWV0YWRhdGFcIjp7XCJmaW5hbGl6ZXJzXCI6W119" + + "fSInIF8gIiRDT01QVVRFX0NPTlRFWFQiIHt9CgojIEZvcmNlLWRlbGV0ZSBzdHVjayBuYW1lc3Bh" + + "Y2VzIGJ5IGNsZWFyaW5nIHRoZWlyIGZpbmFsaXplcnMKZm9yIG5zIGluIG52Y2Etb3BlcmF0b3Ig" + + "bnZjZi1iYWNrZW5kOyBkbwogIGt1YmVjdGwgLS1jb250ZXh0ICIkQ09NUFVURV9DT05URVhUIiBn" + + "ZXQgbmFtZXNwYWNlICIkbnMiIC1vIGpzb24gMj4vZGV2L251bGwgfCBcCiAgICBqcSAnLnNwZWMu" + + "ZmluYWxpemVycyA9IFtdJyB8IFwKICAgIGt1YmVjdGwgLS1jb250ZXh0ICIkQ09NUFVURV9DT05U" + + "RVhUIiByZXBsYWNlIFwKICAgICAgLS1yYXcgIi9hcGkvdjEvbmFtZXNwYWNlcy8kbnMvZmluYWxp" + + "emUiIC1mIC0gMj4vZGV2L251bGwKZG9uZQpgYGAKCiMjIEZhaWx1cmU6IE5WQ0EgT3BlcmF0b3Ig" + + "TWlzc2luZyBvciBOb3QgUmVhZHkKCiMjIyBTeW1wdG9tcwoKQWZ0ZXIgY29tcHV0ZS1wbGFuZSBp" + + "bnN0YWxsIGNvbXBsZXRlcywgbm8gYG52Y2Etb3BlcmF0b3JgIERlcGxveW1lbnQgZXhpc3RzLCBv" + + "cgppdCBleGlzdHMgYnV0IHBvZHMgYXJlIG5vdCByZWFkeToKCmBgYGJhc2gKa3ViZWN0bCAtLWNv" + + "bnRleHQgPGNvbXB1dGUtcGxhbmUtY29udGV4dD4gZ2V0IGRlcGxveW1lbnQgbnZjYS1vcGVyYXRv" + + "ciBcCiAgLW4gbnZjYS1vcGVyYXRvcgprdWJlY3RsIC0tY29udGV4dCA8Y29tcHV0ZS1wbGFuZS1j" + + "b250ZXh0PiBnZXQgcG9kcyAtbiBudmNhLW9wZXJhdG9yCmBgYAoKIyMjIERpYWdub3NpcyBhbmQg" + + "Rml4ZXMKCkZpcnN0IGlkZW50aWZ5IHdoZXRoZXIgdGhlIGluc3RhbGxhdGlvbiB1c2VkIHRoZSBI" + + "ZWxtZmlsZSB2YWx1ZXMgZmxvdyBvciB0aGUKQ0xJIHByb2ZpbGUgZmxvdy4gUmUtcnVuIG9ubHkg" + + "dGhhdCBmbG93J3MgcmVnaXN0cmF0aW9uIGFuZCBpbnN0YWxsYXRpb24gc3RlcHMKZnJvbSBbU3Bs" + + "aXQgQ29tcHV0ZS1QbGFuZSBJbnN0YWxsYXRpb25dKGNvbXB1dGUtcGxhbmUtaW5zdGFsbGF0aW9u" + + "Lm1kKS4gRG8gbm90CnN1YnN0aXR1dGUgb25lIGhhbmRvZmYgZm9yIHRoZSBvdGhlci4KCklmIGlu" + + "c3RhbGxhdGlvbiBzdWNjZWVkcyBidXQgcG9kcyBzdGlsbCBmYWlsLCBpbnNwZWN0IHRoZSBjb21w" + + "dXRlIGNvbnRleHQ6CgpgYGBiYXNoCmt1YmVjdGwgLS1jb250ZXh0IDxjb21wdXRlLXBsYW5lLWNv" + + "bnRleHQ+IGRlc2NyaWJlIGRlcGxveSBudmNhLW9wZXJhdG9yIFwKICAtbiBudmNhLW9wZXJhdG9y" + + "Cmt1YmVjdGwgLS1jb250ZXh0IDxjb21wdXRlLXBsYW5lLWNvbnRleHQ+IGxvZ3MgZGVwbG95bWVu" + + "dC9udmNhLW9wZXJhdG9yIFwKICAtbiBudmNhLW9wZXJhdG9yIC0tdGFpbD0yMDAKa3ViZWN0bCAt" + + "LWNvbnRleHQgPGNvbXB1dGUtcGxhbmUtY29udGV4dD4gZ2V0IG52Y2ZiYWNrZW5kIC1uIG52Y2Et" + + "b3BlcmF0b3IKYGBgCgpGb3IgcHJpdmF0ZSByZWdpc3RyeSBmYWlsdXJlcywgdmVyaWZ5IHRoYXQg" + + "dGhlIHB1bGwgc2VjcmV0IGV4aXN0cyBpbgpgbnZjYS1vcGVyYXRvcmAuIFRoZSBjaGFydCBhbmQg" + + "b3BlcmF0b3IgbWlycm9yIGl0IHRvIGBudmNhLXN5c3RlbWA7IGRvIG5vdCB1c2UgYQpicm9hZGVy" + + "IG1hbnVhbCBuYW1lc3BhY2UgbG9vcC4gU2VlCltwdWxsLXNlY3JldHMubWRdKHB1bGwtc2VjcmV0" + + "cy5tZCNjb21wdXRlLXBsYW5lLXNlY3JldCkuCgojIyBGYWlsdXJlOiBHYXRld2F5IEVuZHBvaW50" + + "IENoYW5nZWQKCiMjIyBTeW1wdG9tcwoKUmVxdWVzdHMgdGhyb3VnaCB0aGUgY29uZmlndXJlZCBy" + + "b3V0ZSBkb21haW4gZmFpbCBhZnRlciB0aGUgR2F0ZXdheSBvciBpdHMgbG9hZCBiYWxhbmNlciBp" + + "cyByZXBsYWNlZC4gVGhlIEdhdGV3YXkgcmVwb3J0cyBhIG5ldyBlbmRwb2ludC4KCiMjIyBEaWFn" + + "bm9zaXMKCmBgYGJhc2gKR0FURVdBWV9BRERSPSQoa3ViZWN0bCAtLWNvbnRleHQgPGNvbnRyb2wt" + + "cGxhbmUtY29udGV4dD4gZ2V0IGdhdGV3YXkgXAogIG52Y2YtZ2F0ZXdheSAtbiBlbnZveS1nYXRl" + + "d2F5IFwKICAtbyBqc29ucGF0aD0ney5zdGF0dXMuYWRkcmVzc2VzWzBdLnZhbHVlfScpCnRlc3Qg" + + "LW4gIiRHQVRFV0FZX0FERFIiCmRpZyArc2hvcnQgImFwaS48ZG9tYWluPiIKY3VybCAtSCAiSG9z" + + "dDogYXBpLjxkb21haW4+IiAiaHR0cDovLyRHQVRFV0FZX0FERFIvaGVhbHRoIgoKIyBDaGVjayBk" + + "aXJlY3QgYWRkcmVzcyBmaWVsZHMgdXNlZCBieSBhIHNwbGl0IGRlcGxveW1lbnQKZ3JlcCBudmNm" + + "TmF0c1NlcnZpY2VVUkwgZGVwbG95L3N0YWNrcy9zZWxmLW1hbmFnZWQvZW52aXJvbm1lbnRzLzxl" + + "bnY+LnlhbWwKZ3JlcCAtRSAnaWNtc1NlcnZpY2V8cmV2YWxTZXJ2aWNlfG5hdHMnIFwKICBkZXBs" + + "b3kvc3RhY2tzL252Y2YtY29tcHV0ZS1wbGFuZS9lbnZpcm9ubWVudHMvPGVudj4ueWFtbApgYGAK" + + "CiMjIyBGaXgKCktlZXAgYGdsb2JhbC5kb21haW5gLCByb3V0ZSBob3N0bmFtZXMsIGFuZCBIb3N0" + + "IG92ZXJyaWRlcyB1bmNoYW5nZWQuIFVwZGF0ZSBETlMKb3IgdGhlIGRpcmVjdCBjbGllbnQgZGVz" + + "dGluYXRpb24uIEZvciBzcGxpdCBkZXBsb3ltZW50cywgdXBkYXRlIG9ubHkgZGlyZWN0CkdhdGV3" + + "YXktYWRkcmVzcyBmaWVsZHMgYW5kIHJlZnJlc2ggcmVnaXN0cmF0aW9uIGFuZCBpbnN0YWxsYXRp" + + "b24gdGhyb3VnaCB0aGUKc2FtZSBzZWxlY3RlZCBoYW5kb2ZmLiBTZWUKW0V4YW1wbGUgNF0oLi4v" + + "ZXhhbXBsZXMubWQjZXhhbXBsZS00LXJlY292ZXItZnJvbS1hLWdhdGV3YXktZW5kcG9pbnQtY2hh" + + "bmdlKS4KCiMjIFVzZWZ1bCBOYW1lc3BhY2UtdG8tU2VydmljZSBNYXBwaW5nCgpRdWljayByZWZl" + + "cmVuY2UgZm9yIHdoaWNoIHNlcnZpY2VzIHJ1biBpbiB3aGljaCBuYW1lc3BhY2U6Cgp8IE5hbWVz" + + "cGFjZSB8IFNlcnZpY2VzIHwKfC0tLS0tLS0tLS0tfC0tLS0tLS0tLS18CnwgbmF0cy1zeXN0ZW0g" + + "fCBuYXRzIHwKfCBjYXNzYW5kcmEtc3lzdGVtIHwgY2Fzc2FuZHJhIHwKfCB2YXVsdC1zeXN0ZW0g" + + "fCBvcGVuYmFvLXNlcnZlciB8CnwgbnZjZiB8IGFwaSwgaW52b2NhdGlvbi1zZXJ2aWNlLCBncnBj" + + "LXByb3h5LCBub3Rhcnktc2VydmljZSwgcmV2YWwsIGxsbS1yZXF1ZXN0LXJvdXRlciwgbGxtLWFw" + + "aS1nYXRld2F5IHwKfCBhcGkta2V5cyB8IGFwaS1rZXlzLCBhZG1pbi1pc3N1ZXItcHJveHkgfAp8" + + "IGVzcyB8IGVzcy1hcGkgfAp8IHNpcyB8IHNpcyB8CnwgZW52b3ktZ2F0ZXdheS1zeXN0ZW0gfCBl" + + "bnZveSBnYXRld2F5IChpbmdyZXNzIGNvbnRyb2xsZXIpIHwKfCBlbnZveS1nYXRld2F5IHwgZ2F0" + + "ZXdheSByZXNvdXJjZSArIHJvdXRlcyB8ClBLBwhWPmeQlTAAAJUwAABQSwMEFAAIAAAAAAAhAAAA" + + "AAAAAAAAAAAAAEQACQBkYXRhL252Y2Ytc2VsZi1tYW5hZ2VkLWluc3RhbGxhdGlvbi9yZWZlcmVu" + + "Y2VzL2hlbG1maWxlLXN0cnVjdHVyZS5tZFVUBQABAKbOEiMgSGVsbWZpbGUgU3RydWN0dXJlIFJl" + + "ZmVyZW5jZQoKIyMgRGlyZWN0b3J5IExheW91dAoKYGBgCm52Y2Ytc2VsZi1tYW5hZ2VkLXN0YWNr" + + "Lwp8LS0gaGVsbWZpbGUuZC8KfCAgIHwtLSAwMS1kZXBlbmRlbmNpZXMueWFtbC5nb3RtcGwgICMg" + + "TkFUUywgQ2Fzc2FuZHJhLCBPcGVuQmFvCnwgICB8LS0gMDItY29yZS55YW1sLmdvdG1wbCAgICAg" + + "ICAgICAjIE5WQ0Ygc2VydmljZXMgKyBpbmdyZXNzCnwgICBgLS0gMDMtb2JzZXJ2YWJpbGl0eS55" + + "YW1sLmdvdG1wbCAjIE9ic2VydmFiaWxpdHkgc3RhY2sgKG9wdGlvbmFsKQp8LS0gZW52aXJvbm1l" + + "bnRzLwp8ICAgfC0tIGJhc2UueWFtbCAgICAgICAgICAgICAgICAgICAgIyBEZWZhdWx0IHZhbHVl" + + "cyAoYWxsIGVudmlyb25tZW50cykKfCAgIGAtLSA8ZW52LW5hbWU+LnlhbWwgICAgICAgICAgICAg" + + "ICMgUGVyLWVudmlyb25tZW50IG92ZXJyaWRlcwp8LS0gc2VjcmV0cy8KfCAgIGAtLSA8ZW52LW5h" + + "bWU+LXNlY3JldHMueWFtbCAgICAgICMgU2Vuc2l0aXZlIHZhbHVlcyAocmVnaXN0cnkgY3JlZHMs" + + "IHBhc3N3b3JkcykKYC0tIGdsb2JhbC55YW1sLmdvdG1wbCAgICAgICAgICAgICAgICMgR28gdGVt" + + "cGxhdGUgdGhhdCBjb25zdHJ1Y3RzIHBlci1jaGFydCB2YWx1ZXMKCm52Y2YtY29tcHV0ZS1wbGFu" + + "ZS1zdGFjay8KfC0tIGhlbG1maWxlLmQvCnwgICB8LS0gMDEtZGVwZW5kZW5jaWVzLnlhbWwuZ290" + + "bXBsICAjIENvbXB1dGUgcGxhbmUgZGVwZW5kZW5jeSBjb21wb25lbnRzCnwgICBgLS0gMDItbnZj" + + "YS55YW1sLmdvdG1wbCAgICAgICAgICAjIG52Y2Etb3BlcmF0b3IgY2hhcnQgYW5kIG52Y2EgY29u" + + "ZmlndXJhdGlvbgp8LS0gZW52aXJvbm1lbnRzLwp8ICAgfC0tIGJhc2UueWFtbCAgICAgICAgICAg" + + "ICAgICAgICAgIyBEZWZhdWx0IHZhbHVlcyAoYWxsIGVudmlyb25tZW50cykKfCAgIGAtLSA8ZW52" + + "LW5hbWU+LnlhbWwgICAgICAgICAgICAgICMgUGVyLWVudmlyb25tZW50IG92ZXJyaWRlcwpgLS0g" + + "Z2xvYmFsLnlhbWwuZ290bXBsICAgICAgICAgICAgICAgIyBHbyB0ZW1wbGF0ZSB0aGF0IGNvbnN0" + + "cnVjdHMgcGVyLWNoYXJ0IHZhbHVlcwpgYGAKClRoZXNlIHN0YWNrcyBoYXZlIHNlcGFyYXRlIGVu" + + "dmlyb25tZW50cyBhbmQgY2x1c3RlciBjb250ZXh0cy4gVGhlIEhlbG1maWxlCnZhbHVlcyBmbG93" + + "IGF1dGhvcnMgYm90aCBlbnZpcm9ubWVudCBmaWxlcy4gVGhlIENMSSBwcm9maWxlIGZsb3cgaW5z" + + "dGVhZCB1c2VzCnRoZSBDTEktZ2VuZXJhdGVkIGNvbnRyb2wtcGxhbmUgcHJvZmlsZSBhcyBpdHMg" + + "ZW5kcG9pbnQgc291cmNlLiBEbyBub3QgbWl4IHRoZQpoYW5kb2Zmcy4gU2VlIFtTcGxpdCBDb21w" + + "dXRlLVBsYW5lIEluc3RhbGxhdGlvbl0oY29tcHV0ZS1wbGFuZS1pbnN0YWxsYXRpb24ubWQpLgoK" + + "IyMgR290bXBsIEZpbGVzIGFuZCBUaGVpciBSZWxlYXNlcwoKIyMjIDAxLWRlcGVuZGVuY2llcy55" + + "YW1sLmdvdG1wbAoKfCBSZWxlYXNlIHwgQ2hhcnQgfCBOYW1lc3BhY2UgfCBOb3RlcyB8CnwtLS0t" + + "LS0tLS18LS0tLS0tLXwtLS0tLS0tLS0tLXwtLS0tLS0tfAp8IG5hdHMgfCBoZWxtLW52Y2YtbmF0" + + "cyB8IG5hdHMtc3lzdGVtIHwgTWVzc2FnaW5nIHwKfCBvcGVuYmFvLXNlcnZlciB8IGhlbG0tbnZj" + + "Zi1vcGVuYmFvLXNlcnZlciB8IHZhdWx0LXN5c3RlbSB8IFNlY3JldHMgbWFuYWdlbWVudCwgZGVw" + + "ZW5kcyBvbiBuYXRzIHwKfCBjYXNzYW5kcmEgfCBoZWxtLW52Y2YtY2Fzc2FuZHJhIHwgY2Fzc2Fu" + + "ZHJhLXN5c3RlbSB8IERhdGFiYXNlIHwKClVzZXMgYDw8OiAqZGVwZW5kZW5jeWAgdGVtcGxhdGUg" + + "aW5oZXJpdGFuY2Ugd2l0aCBgcmVsZWFzZS1ncm91cDogZGVwZW5kZW5jaWVzYCBsYWJlbC4KCiMj" + + "IyAwMi1jb3JlLnlhbWwuZ290bXBsCgp8IFJlbGVhc2UgfCBDaGFydCB8IE5hbWVzcGFjZSB8IExh" + + "YmVsIHwKfC0tLS0tLS0tLXwtLS0tLS0tfC0tLS0tLS0tLS0tfC0tLS0tLS18CnwgYXBpLWtleXMg" + + "fCBoZWxtLW52Y2YtYXBpLWtleXMgfCBhcGkta2V5cyB8IHNlcnZpY2VzIHwKfCBzaXMgfCBoZWxt" + + "LW52Y2Ytc2lzIHwgc2lzIHwgc2VydmljZXMgfAp8IGFwaSB8IGhlbG0tbnZjZi1hcGkgfCBudmNm" + + "IHwgc2VydmljZXMgfAp8IGludm9jYXRpb24tc2VydmljZSB8IGhlbG0tbnZjZi1pbnZvY2F0aW9u" + + "LXNlcnZpY2UgfCBudmNmIHwgc2VydmljZXMgfAp8IGdycGMtcHJveHkgfCBoZWxtLW52Y2YtZ3Jw" + + "Yy1wcm94eSB8IG52Y2YgfCBzZXJ2aWNlcyB8CnwgZXNzLWFwaSB8IGhlbG0tbnZjZi1lc3MtYXBp" + + "IHwgZXNzIHwgc2VydmljZXMgfAp8IG5vdGFyeS1zZXJ2aWNlIHwgaGVsbS1udmNmLW5vdGFyeS1z" + + "ZXJ2aWNlIHwgbnZjZiB8IHNlcnZpY2VzIHwKfCByZXZhbCB8IGhlbG0tcmV2YWwgfCBudmNmIHwg" + + "c2VydmljZXMgfAp8IGxsbS1yZXF1ZXN0LXJvdXRlciB8IG52Y2YvaGVsbS1udmNmLWxsbS1yZXF1" + + "ZXN0LXJvdXRlciB8IG52Y2YgfCBzZXJ2aWNlcyB8CnwgbGxtLWFwaS1nYXRld2F5IHwgbnZjZi9o" + + "ZWxtLW52Y2YtbGxtLWFwaS1nYXRld2F5IHwgbnZjZiB8IHNlcnZpY2VzIHwKfCBhZG1pbi1pc3N1" + + "ZXItcHJveHkgfCBoZWxtLWFkbWluLXRva2VuLWlzc3Vlci1wcm94eSB8IGFwaS1rZXlzIHwgKG5v" + + "IHJlbGVhc2UtZ3JvdXAgbGFiZWwpIHwKfCBpbmdyZXNzIHwgbnZjZi1nYXRld2F5LXJvdXRlcyB8" + + "IGVudm95LWdhdGV3YXktc3lzdGVtIHwgaW5ncmVzcyB8CgpNb3N0IHNlcnZpY2VzIHVzZSBgaW5o" + + "ZXJpdDogW3t0ZW1wbGF0ZTogc2VydmljZX1dYC4gTExNIHJlbGVhc2VzIHVzZSBPQ0kgY2hhcnRz" + + "IGZyb20gdGhlIGBudmNmYCByZXBvc2l0b3J5IHdpdGggc3RhbmRhbG9uZSBgdmFsdWVzOiBbLi4v" + + "Z2xvYmFsLnlhbWwuZ290bXBsXWAgYmxvY2tzOyB0aGV5IGFyZSBnYXRlZCBvbiBgYWRkb25zLmxs" + + "bS5lbmFibGVkYC4gYGFkbWluLWlzc3Vlci1wcm94eWAgYW5kIGBpbmdyZXNzYCBoYXZlIHN0YW5k" + + "YWxvbmUgYHZhbHVlczpgIGJsb2Nrcy4KCiMjIyAwMy1vYnNlcnZhYmlsaXR5LnlhbWwuZ290bXBs" + + "Cgp8IFJlbGVhc2UgfCBDaGFydCB8IE5hbWVzcGFjZSB8IExhYmVsIHwKfC0tLS0tLS0tLXwtLS0t" + + "LS0tfC0tLS0tLS0tLS0tfC0tLS0tLS18CnwgKG9ic2VydmFiaWxpdHkgcmVsZWFzZXMpIHwgKHZh" + + "cmlvdXMpIHwgb2JzZXJ2YWJpbGl0eSB8IG9ic2VydmFiaWxpdHkgfAoKR2F0ZWQgb24gb2JzZXJ2" + + "YWJpbGl0eS1zcGVjaWZpYyBmbGFncyBpbiB0aGUgZW52aXJvbm1lbnQgZmlsZS4gU2tpcHBlZCBp" + + "ZiBkaXNhYmxlZC4KCiMjIFRlbXBsYXRlIEluaGVyaXRhbmNlCgojIyMgYDw8OiAqZGVwZW5kZW5j" + + "eWAgKFlBTUwgbWVyZ2UpCgpVc2VkIGluIGAwMS1kZXBlbmRlbmNpZXMueWFtbC5nb3RtcGxgLiBN" + + "ZXJnZXMgdGhlIHRlbXBsYXRlJ3MgcHJvcGVydGllcyBpbnRvIHRoZSByZWxlYXNlLgoKKipHb3Rj" + + "aGEqKjogWUFNTCBtZXJnZSByZXBsYWNlcyBsaXN0cy4gSWYgeW91IGFkZCBhIGB2YWx1ZXM6YCBr" + + "ZXkgdG8gdGhlIHJlbGVhc2UsIGl0ICoqcmVwbGFjZXMqKiB0aGUgdGVtcGxhdGUncyBgdmFsdWVz" + + "OmAgbGlzdCBlbnRpcmVseS4gWW91IG11c3QgcmUtaW5jbHVkZSBhbGwgdGVtcGxhdGUgdmFsdWVz" + + "OgoKSW4gdGhlIHRlbXBsYXRlIGJlbG93LCBgPHByaXZhdGUtdmFsdWVzPmAgcmVmZXJzIHRvIHRo" + + "ZSBgc2VjcmV0cy9gIGRpcmVjdG9yeSBhdCB0aGUgaGVsbWZpbGUgc3RhY2sgcm9vdC4KCmBgYHlh" + + "bWwKIyBUZW1wbGF0ZSBkZWZpbmVzOgp0ZW1wbGF0ZXM6CiAgZGVwZW5kZW5jeTogJmRlcGVuZGVu" + + "Y3kKICAgIGNoYXJ0OiBudmNmL2hlbG0tbnZjZi17eyAuUmVsZWFzZS5OYW1lIH19CiAgICB2YWx1" + + "ZXM6CiAgICAgIC0gLi4vZ2xvYmFsLnlhbWwuZ290bXBsCiAgICAgIC0gLi4vPHByaXZhdGUtdmFs" + + "dWVzPi97eyByZXF1aXJlZEVudiAiSEVMTUZJTEVfRU5WIiB9fS1zZWNyZXRzLnlhbWwKCiMgV2hl" + + "biBvdmVycmlkaW5nLCBNVVNUIHJlLWluY2x1ZGUgYm90aDoKLSBuYW1lOiBjYXNzYW5kcmEKICA8" + + "PDogKmRlcGVuZGVuY3kKICB2YWx1ZXM6CiAgICAtIC4uL2dsb2JhbC55YW1sLmdvdG1wbCAgICAg" + + "ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAjIE11c3QgcmUtaW5jbHVk" + + "ZQogICAgLSAuLi88cHJpdmF0ZS12YWx1ZXM+L3t7IHJlcXVpcmVkRW52ICJIRUxNRklMRV9FTlYi" + + "IH19LXNlY3JldHMueWFtbCAgICMgTXVzdCByZS1pbmNsdWRlCiAgICAtIGNhc3NhbmRyYTogICAg" + + "ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIyBZ" + + "b3VyIG92ZXJyaWRlCiAgICAgICAgcmVzb3VyY2VzOgogICAgICAgICAgbGltaXRzOgogICAgICAg" + + "ICAgICBtZW1vcnk6IDgxOTJNaQpgYGAKCiMjIyBgaW5oZXJpdGAgKEhlbG1maWxlIG5hdGl2ZSkK" + + "ClVzZWQgaW4gYDAyLWNvcmUueWFtbC5nb3RtcGxgLiBIZWxtZmlsZSdzIG5hdGl2ZSBpbmhlcml0" + + "YW5jZSBtZWNoYW5pc20uCgpgYGB5YW1sCi0gbmFtZTogYXBpCiAgdmVyc2lvbjogMS42LjAKICBu" + + "YW1lc3BhY2U6IG52Y2YKICBpbmhlcml0OgogICAgLSB0ZW1wbGF0ZTogc2VydmljZQpgYGAKCldo" + + "ZW4gYWRkaW5nIGB2YWx1ZXM6YCB0byBhbiBpbmhlcml0ZWQgcmVsZWFzZSwgeW91IGFsc28gbmVl" + + "ZCB0byByZS1pbmNsdWRlIHRoZSB0ZW1wbGF0ZSdzIHZhbHVlcyBmaWxlcyBzaW5jZSBgdmFsdWVz" + + "YCBpcyBhIGxpc3QgdGhhdCBnZXRzIHJlcGxhY2VkLgoKIyMgVmFsdWVzIFByZWNlZGVuY2UKCkZy" + + "b20gbG93ZXN0IHRvIGhpZ2hlc3QgcHJpb3JpdHk6CgoxLiBgZW52aXJvbm1lbnRzL2Jhc2UueWFt" + + "bGAgLS0gZGVmYXVsdHMgc2hhcmVkIGFjcm9zcyBhbGwgZW52aXJvbm1lbnRzCjIuIGBlbnZpcm9u" + + "bWVudHMvPGVudj4ueWFtbGAgLS0gcGVyLWVudmlyb25tZW50IG92ZXJyaWRlcwozLiBgZ2xvYmFs" + + "LnlhbWwuZ290bXBsYCAtLSBHbyB0ZW1wbGF0ZSBwcm9jZXNzaW5nIChjb25zdHJ1Y3RzIGNoYXJ0" + + "LXNwZWNpZmljIHN0cnVjdHVyZSkKNC4gYDxwcml2YXRlLXZhbHVlcz4vPGVudj4tc2VjcmV0cy55" + + "YW1sYCAtLSBzZW5zaXRpdmUgdmFsdWVzCjUuIElubGluZSBgdmFsdWVzOmAgYmxvY2tzIG9uIHJl" + + "bGVhc2VzIC0tIGhpZ2hlc3QgcHJlY2VkZW5jZQoKIyMgV2hhdCBnbG9iYWwueWFtbC5nb3RtcGwg" + + "UGFzc2VzIFRocm91Z2gKCmBnbG9iYWwueWFtbC5nb3RtcGxgIHJlYWRzIGZyb20gYC5WYWx1ZXNg" + + "ICh0aGUgbWVyZ2VkIGVudmlyb25tZW50ICsgZW52LXNwZWNpZmljIFlBTUwpIGFuZCBjb25zdHJ1" + + "Y3RzIGNoYXJ0LXNwZWNpZmljIHZhbHVlcy4gSXQgb25seSBwYXNzZXMgdGhyb3VnaCBrZXlzIGl0" + + "IGV4cGxpY2l0bHkgcmVmZXJlbmNlczoKCiMjIyBDYXNzYW5kcmEKLSBgY2Fzc2FuZHJhLnJlcGxp" + + "Y2FDb3VudGAKLSBgY2Fzc2FuZHJhLmltYWdlLipgIChyZWdpc3RyeSwgcmVwb3NpdG9yeSkKLSBg" + + "Y2Fzc2FuZHJhLm1pZ3JhdGlvbnMuaW1hZ2UuKmAKLSBgY2Fzc2FuZHJhLnBlcnNpc3RlbmNlLnNp" + + "emVgCi0gYGNhc3NhbmRyYS5ub2RlU2VsZWN0b3JgIChpZiBgZ2xvYmFsLm5vZGVTZWxlY3RvcnMu" + + "ZW5hYmxlZGApCi0gYGNhc3NhbmRyYS5nbG9iYWwuZGVmYXVsdFN0b3JhZ2VDbGFzc2AKCiMjIyBO" + + "QVRTCi0gYG5hdHMuY29udGFpbmVyLmltYWdlLipgCi0gYG5hdHMucmVsb2FkZXIuaW1hZ2UuKmAK" + + "LSBgbmF0cy5uYXRzQm94LmNvbnRhaW5lci5pbWFnZS4qYAotIGBuYXRzLmNvbmZpZy5qZXRzdHJl" + + "YW0uZmlsZVN0b3JlLnB2Yy5zdG9yYWdlQ2xhc3NOYW1lYAotIGBuYXRzLnBvZFRlbXBsYXRlLm1l" + + "cmdlLnNwZWMubm9kZVNlbGVjdG9yYCAoaWYgZW5hYmxlZCkKCiMjIyBPcGVuQmFvCi0gYG9wZW5i" + + "YW8ubWlncmF0aW9ucy5pbWFnZS4qYCBhbmQgYG9wZW5iYW8ubWlncmF0aW9ucy5lbnZgCi0gYG9w" + + "ZW5iYW8uaW5qZWN0b3IuaW1hZ2UuKmAKLSBgb3BlbmJhby5zZXJ2ZXIuaW1hZ2UuKmAKLSBgb3Bl" + + "bmJhby5zZXJ2ZXIuZGF0YVN0b3JhZ2UuKmAKLSBOb2RlIHNlbGVjdG9ycyAoaWYgZW5hYmxlZCkK" + + "CiMjIyBTZXJ2aWNlcyAoQVBJLCBTSVMsIGV0Yy4pCi0gYDxzZXJ2aWNlPi5pbWFnZS4qYCAocmVn" + + "aXN0cnksIHJlcG9zaXRvcnkpCi0gYDxzZXJ2aWNlPi5ub2RlU2VsZWN0b3JgIChpZiBlbmFibGVk" + + "KQotIGA8c2VydmljZT4uZW52LipgIChvYnNlcnZhYmlsaXR5IHNldHRpbmdzKQoKIyMjIExMTSBG" + + "dW5jdGlvbiBFbmFibGVtZW50CgpFbmFibGUgdGhlIExMTSBhZGRvbiBiZWZvcmUgY3JlYXRpbmcg" + + "b3IgaW52b2tpbmcgZnVuY3Rpb25zIHdpdGgKYGZ1bmN0aW9uVHlwZTogIkxMTSJgLiBUaGUgYWRk" + + "b24gZGVwbG95cyBgbGxtLXJlcXVlc3Qtcm91dGVyYCBhbmQKYGxsbS1hcGktZ2F0ZXdheWAsIGFk" + + "ZHMgdGhlIGBsbG0uaW52b2NhdGlvbi48ZG9tYWluPmAgcm91dGUgd2hlbiBHYXRld2F5IEFQSQpp" + + "bmdyZXNzIGlzIGVuYWJsZWQsIGFuZCBjb25maWd1cmVzIHdvcmtlcnMgdG8gdXNlIHRoZSBMTE0g" + + "c2lkZWNhci4gVGhlIEhlbG1maWxlCmNvbmRpdGlvbiBpcyBgYWRkb25zLmxsbS5lbmFibGVkYC4g" + + "RG8gbm90IHVzZSB0aGUgb2Jzb2xldGUgYGxsbS5lbmFibGVkYCBwYXRoLgoKRm9yIGEgc2luZ2xl" + + "LW5vZGUgaXNvbGF0ZWQgdGVzdCBjbHVzdGVyLCBhZGQgdGhpcyBjb25maWd1cmF0aW9uIHRvCmBl" + + "bnZpcm9ubWVudHMvPGVudj4ueWFtbGAgYmVmb3JlIGFwcGx5aW5nIHRoZSBzdGFjazoKCmBgYHlh" + + "bWwKYWRkb25zOgogIGxsbToKICAgIGVuYWJsZWQ6IHRydWUKICAgIGdhdGV3YXk6CiAgICAgIHJl" + + "cGxpY2FDb3VudDogMQogICAgICBhdXRoOgogICAgICAgIGdycGNJbnNlY3VyZTogdHJ1ZQogICAg" + + "ICBtZXRyaWNzOgogICAgICAgIHNlcnZpY2VNb25pdG9yOgogICAgICAgICAgZW5hYmxlZDogZmFs" + + "c2UKICAgIHJlcXVlc3RSb3V0ZXI6CiAgICAgIHJlcGxpY2FDb3VudDogMQogICAgICBtZXRyaWNz" + + "OgogICAgICAgIHNlcnZpY2VNb25pdG9yOgogICAgICAgICAgZW5hYmxlZDogZmFsc2UKCmFnZW50" + + "Q29uZmlnOgogIG1lcmdlQ29uZmlnOiB8CiAgICBjbHVzdGVyOgogICAgICB2YWxpZGF0aW9uUG9s" + + "aWN5OgogICAgICAgIG5hbWU6IFVucmVzdHJpY3RlZAogICAgd29ya2xvYWQ6CiAgICAgIHN0YXJn" + + "YXRlUVVJQ0luc2VjdXJlOiB0cnVlCmBgYAoKVXNlIGByZXBsaWNhQ291bnQ6IDFgIG9ubHkgZm9y" + + "IGxvY2FsIG9yIHNpbmdsZS1ub2RlIHRlc3QgY2x1c3RlcnMuIEZvciBzaGFyZWQKb3IgcHJvZHVj" + + "dGlvbiBjbHVzdGVycywgdXNlIHRoZSByZXF1aXJlZCByZXBsaWNhIGNvdW50IGFuZCBUTFMtY2Fw" + + "YWJsZSBzZXJ2aWNlCmNvbmZpZ3VyYXRpb24uIGBhZGRvbnMubGxtLmdhdGV3YXkuYXV0aC5ncnBj" + + "SW5zZWN1cmVgIGFuZApgd29ya2xvYWQuc3RhcmdhdGVRVUlDSW5zZWN1cmVgIGVuYWJsZSBwbGFp" + + "bnRleHQgdHJhbnNwb3J0cy4gRG8gbm90IHVzZSB0aGVtIGluCnByb2R1Y3Rpb24uCgpUaGUgcmVx" + + "dWVzdCByb3V0ZXIgdXNlcyBgcG93ZXItb2YtdHdvYCB3aGVuIG5vIGxvYWQtYmFsYW5jZXIgY29u" + + "ZmlndXJhdGlvbiBpcwpzZXQuIENvbmZpZ3VyZSBvdGhlciByb3V0aW5nIG1ldGhvZHMgd2l0aCB0" + + "aGUKW0xMTSBSZXF1ZXN0IFJvdXRlciBMb2FkIEJhbGFuY2luZ10oaHR0cHM6Ly9naXRodWIuY29t" + + "L05WSURJQS9udmNmL2Jsb2IvbWFpbi9kb2NzL3VzZXIvbGxtLXJlcXVlc3Qtcm91dGVyLWxvYWQt" + + "YmFsYW5jaW5nLm1kKQpndWlkZS4KCklmIHRoZSBzaWRlY2FyIGltYWdlIGlzIG1pcnJvcmVkIG91" + + "dHNpZGUgdGhlIHN0YWNrJ3MgZGVmYXVsdCBpbWFnZSByZWdpc3RyeSBhbmQKcmVwb3NpdG9yeSwg" + + "c2V0IHRoZSBnZW5lcmF0ZWQgd29ya2VyIHNpZGVjYXIgaW1hZ2UgZXhwbGljaXRseToKCmBgYHlh" + + "bWwKYXBpOgogIGVudjoKICAgIE5WQ0ZfU0lERUNBUlNfTExNX1JPVVRFUl9DTElFTlRfSU1BR0U6" + + "IDxyZWdpc3RyeT4vPHJlcG9zaXRvcnk+L3B5bG9uOjAuMi4xCmBgYAoKUmVuZGVyIGFuZCBhcHBs" + + "eSB0aGUgdXBkYXRlZCBjb250cm9sLXBsYW5lIGVudmlyb25tZW50LCB0aGVuIHJlZnJlc2ggZXZl" + + "cnkKcmVnaXN0ZXJlZCBjb21wdXRlIHBsYW5lIHVzaW5nIHRoZSBzYW1lIGhhbmRvZmYgdXNlZCBm" + + "b3IgaXRzIGluc3RhbGxhdGlvbiBzbwpOVkNBIHJlY2VpdmVzIGBhZ2VudENvbmZpZy5tZXJnZUNv" + + "bmZpZ2A6CgpgYGBiYXNoCkhFTE1GSUxFX0VOVj08ZW52PiBoZWxtZmlsZSB0ZW1wbGF0ZQpIRUxN" + + "RklMRV9FTlY9PGVudj4gaGVsbWZpbGUgc3luYwpgYGAKClVzZSB0aGUgY29tcGxldGUgY29tcHV0" + + "ZS1wbGFuZSBpbnN0YWxsIGNvbW1hbmQgZnJvbQpbU3BsaXQgQ29tcHV0ZS1QbGFuZSBJbnN0YWxs" + + "YXRpb25dKGNvbXB1dGUtcGxhbmUtaW5zdGFsbGF0aW9uLm1kKS4gQQpDTEktcHJvZmlsZSBpbnN0" + + "YWxsYXRpb24gbXVzdCByZW1haW4gcHJvZmlsZS1kcml2ZW47IGEgSGVsbWZpbGUgaW5zdGFsbGF0" + + "aW9uCm11c3QgcmVtYWluIHZhbHVlcy1kcml2ZW4uCgpFeGlzdGluZyBMTE0gZnVuY3Rpb24gcG9k" + + "cyBrZWVwIHRoZWlyIGV4aXN0aW5nIHNpZGVjYXIgYXJndW1lbnRzLiBSZWNyZWF0ZSBvcgpyZWRl" + + "cGxveSB0aG9zZSBmdW5jdGlvbnMgYWZ0ZXIgdGhlIGNvbXB1dGUtcGxhbmUgcmVmcmVzaC4gVmVy" + + "aWZ5IHRoZSBjb250cm9sCnBsYW5lLCByb3V0ZSwgYW5kIHdvcmtlciBzaWRlY2FyOgoKYGBgYmFz" + + "aAprdWJlY3RsIGdldCBkZXBsb3kgLW4gbnZjZiBsbG0tYXBpLWdhdGV3YXkKa3ViZWN0bCBnZXQg" + + "c3RhdGVmdWxzZXQgLW4gbnZjZiBsbG0tcmVxdWVzdC1yb3V0ZXIKa3ViZWN0bCBnZXQgcG9kcyAt" + + "biBudmNmIHwgZ3JlcCAtRSAnbGxtLWFwaS1nYXRld2F5fGxsbS1yZXF1ZXN0LXJvdXRlcicKa3Vi" + + "ZWN0bCBnZXQgaHR0cHJvdXRlIC1BIHwgZ3JlcCBsbG0Ka3ViZWN0bCAtbiBudmNmLWJhY2tlbmQg" + + "Z2V0IHBvZCA8ZnVuY3Rpb24tcG9kPiBcCiAgLW8ganNvbnBhdGg9J3tyYW5nZSAuc3BlYy5jb250" + + "YWluZXJzWz8oQC5uYW1lPT0ibGxtLXdvcmtlciIpXS5hcmdzWypdfXsufXsiXFxuIn17ZW5kfScK" + + "YGBgCgpGb3IgbG9jYWwgcGxhaW50ZXh0IGNsdXN0ZXJzLCB0aGUgYGxsbS13b3JrZXJgIGFyZ3Mg" + + "bXVzdCBpbmNsdWRlCmAtLXF1aWMtaW5zZWN1cmVgLgoKRm9yIGxvYWQtYmFsYW5jZXIgc2NoZW1h" + + "IGFuZCBhbGdvcml0aG0gYmVoYXZpb3IsIHNlZSB0aGUKW1N0YXJnYXRlIGNvbmZpZ3VyYXRpb24g" + + "Z3VpZGVdKGh0dHBzOi8vZ2l0aHViLmNvbS9OVklESUEvbnZjZi9ibG9iL21haW4vc3JjL2xpYnJh" + + "cmllcy9ydXN0L3N0YXJnYXRlL2RvY3MvbG9hZC1iYWxhbmNlci1jb25maWd1cmF0aW9uLm1kKS4K" + + "CiMjIEhlbG1maWxlIFNlbGVjdG9ycwoKVGFyZ2V0IHNwZWNpZmljIHJlbGVhc2VzIG9yIGdyb3Vw" + + "czoKCmBgYGJhc2gKIyBCeSByZWxlYXNlIGdyb3VwCkhFTE1GSUxFX0VOVj08ZW52PiBoZWxtZmls" + + "ZSAtLXNlbGVjdG9yIHJlbGVhc2UtZ3JvdXA9ZGVwZW5kZW5jaWVzIHN5bmMKSEVMTUZJTEVfRU5W" + + "PTxlbnY+IGhlbG1maWxlIC0tc2VsZWN0b3IgcmVsZWFzZS1ncm91cD1zZXJ2aWNlcyBzeW5jCkhF" + + "TE1GSUxFX0VOVj08ZW52PiBoZWxtZmlsZSAtLXNlbGVjdG9yIHJlbGVhc2UtZ3JvdXA9aW5ncmVz" + + "cyBzeW5jCkhFTE1GSUxFX0VOVj08ZW52PiBoZWxtZmlsZSAtLXNlbGVjdG9yIHJlbGVhc2UtZ3Jv" + + "dXA9b2JzZXJ2YWJpbGl0eSBzeW5jCgojIEJ5IHJlbGVhc2UgbmFtZQpIRUxNRklMRV9FTlY9PGVu" + + "dj4gaGVsbWZpbGUgLS1zZWxlY3RvciBuYW1lPWNhc3NhbmRyYSBzeW5jCkhFTE1GSUxFX0VOVj08" + + "ZW52PiBoZWxtZmlsZSAtLXNlbGVjdG9yIG5hbWU9YWRtaW4taXNzdWVyLXByb3h5IHN5bmMKSEVM" + + "TUZJTEVfRU5WPTxlbnY+IGhlbG1maWxlIC0tc2VsZWN0b3IgbmFtZT1sbG0tcmVxdWVzdC1yb3V0" + + "ZXIgc3luYwpIRUxNRklMRV9FTlY9PGVudj4gaGVsbWZpbGUgLS1zZWxlY3RvciBuYW1lPWxsbS1h" + + "cGktZ2F0ZXdheSBzeW5jCgojIFRlbXBsYXRlIG9ubHkgKGRyeSBydW4pCkhFTE1GSUxFX0VOVj08" + + "ZW52PiBoZWxtZmlsZSAtLXNlbGVjdG9yIG5hbWU9Y2Fzc2FuZHJhIHRlbXBsYXRlCgojIERlc3Ry" + + "b3kgYSBzaW5nbGUgcmVsZWFzZQpIRUxNRklMRV9FTlY9PGVudj4gaGVsbWZpbGUgLS1zZWxlY3Rv" + + "ciBuYW1lPWNhc3NhbmRyYSBkZXN0cm95CmBgYAoKTm90ZTogYGFkbWluLWlzc3Vlci1wcm94eWAg" + + "aGFzIG5vIGByZWxlYXNlLWdyb3VwYCBsYWJlbC4gVXNlIGAtLXNlbGVjdG9yIG5hbWU9YWRtaW4t" + + "aXNzdWVyLXByb3h5YC4KUEsHCMBWIOePJwAAjycAAFBLAwQUAAgAAAAAACEAAAAAAAAAAAAAAAAA" + + "PwAJAGRhdGEvbnZjZi1zZWxmLW1hbmFnZWQtaW5zdGFsbGF0aW9uL3JlZmVyZW5jZXMvbnZjZi11" + + "aS1hZGRvbi5tZFVUBQABAKbOEiMgTlZDRiBVSSBBZGRvbgoKTlZDRiBVSSBpcyBhbiBvcHRpb25h" + + "bCwgY3VzdG9tZXItZmFjaW5nIE5WQ0YgYWRtaW4tcGFuZWwgVUkuIEl0IGlzIGRpc2FibGVkIGJ5" + + "CmRlZmF1bHQgYW5kIGF2YWlsYWJsZSBvbmx5IGluIHN0YWNrIHBhY2thZ2VzIHRoYXQgaW5jbHVk" + + "ZSB0aGUgTlZDRiBVSSBhZGRvbi4KCiMjIFdoZW4gdG8gZW5hYmxlCgpFbmFibGUgTlZDRiBVSSBv" + + "bmx5IHdoZW4geW91IG5lZWQgdGhlIGFkbWluLXBhbmVsIFVJIGFuZCB5b3VyIGV4dHJhY3RlZCBz" + + "dGFjawpwYWNrYWdlIGluY2x1ZGVzIHRoZSBhZGRvbi4gSWYgdGhlIHBhY2thZ2UgZG9lcyBub3Qg" + + "Y29udGFpbiBhIGBudmNmLXVpYCByZWxlYXNlCmFuZCBgbnZjZlVpYCByb3V0ZSB2YWx1ZXMsIHNr" + + "aXAgdGhlIGFkZG9uIHVudGlsIHlvdSB1c2UgYSBwYWNrYWdlIHRoYXQgaW5jbHVkZXMKdGhlbS4K" + + "CiMjIEVuYWJsZSB0aGUgYWRkb24KCkVuYWJsZSBpdCBpbiBgZW52aXJvbm1lbnRzLzxlbnYtbmFt" + + "ZT4ueWFtbGA6CgpgYGB5YW1sCmFkZG9uczoKICBudmNmVWk6CiAgICBlbmFibGVkOiB0cnVlCmBg" + + "YAoKIyMgQ3JlYXRlIG5hbWVzcGFjZSBhbmQgaW1hZ2UgcHVsbCBzZWNyZXQKCkNyZWF0ZSB0aGUg" + + "bmFtZXNwYWNlLCBhbmQgYW4gaW1hZ2UgcHVsbCBzZWNyZXQgb25seSBpZiBwdWxsaW5nIGZyb20g" + + "YSBwcml2YXRlCnJlZ2lzdHJ5OgoKYGBgYmFzaAprdWJlY3RsIGNyZWF0ZSBuYW1lc3BhY2UgbnZj" + + "Zi11aSAtLWRyeS1ydW49Y2xpZW50IC1vIHlhbWwgfCBrdWJlY3RsIGFwcGx5IC1mIC0KCiMgT25s" + + "eSBpZiBwdWxsaW5nIGZyb20gYSBwcml2YXRlIHJlZ2lzdHJ5IChlLmcuLCBOR0MgbnZjci5pbykK" + + "ZXhwb3J0IE5HQ19BUElfS0VZPSI8eW91ci1rZXk+IgprdWJlY3RsIGNyZWF0ZSBzZWNyZXQgZG9j" + + "a2VyLXJlZ2lzdHJ5IG52Y3ItY3JlZHMgXAogIC0tZG9ja2VyLXNlcnZlcj1udmNyLmlvIFwKICAt" + + "LWRvY2tlci11c2VybmFtZT0nJG9hdXRodG9rZW4nIFwKICAtLWRvY2tlci1wYXNzd29yZD0iJE5H" + + "Q19BUElfS0VZIiBcCiAgLS1uYW1lc3BhY2U9bnZjZi11aSBcCiAgLS1kcnktcnVuPWNsaWVudCAt" + + "byB5YW1sIHwga3ViZWN0bCBhcHBseSAtZiAtCmBgYAoKVGhlIGRlZmF1bHQgcm91dGUgaG9zdCBp" + + "cyBgbnZjZi11aS48ZG9tYWluPmAgYW5kIHRoZSBiYWNrZW5kIGlzCmBudmNmLXVpLm52Y2YtdWk6" + + "ODMwMGAuCgojIyBBcHBseSB0aGUgc2VydmljZSBhbmQgcm91dGUKCkFmdGVyIGNvbmZpcm1pbmcg" + + "dGhlIHBhY2thZ2UgaW5jbHVkZXMgdGhlIGBudmNmLXVpYCByZWxlYXNlLCBwcmV2aWV3IGFuZCBh" + + "cHBseQp0aGUgc2VydmljZSBhbmQgcm91dGU6CgpgYGBiYXNoCkhFTE1GSUxFX0VOVj08ZW52LW5h" + + "bWU+IGhlbG1maWxlIC0tc2VsZWN0b3IgbmFtZT1udmNmLXVpIHRlbXBsYXRlCkhFTE1GSUxFX0VO" + + "Vj08ZW52LW5hbWU+IGhlbG1maWxlIC0tc2VsZWN0b3IgbmFtZT1udmNmLXVpIHN5bmMKSEVMTUZJ" + + "TEVfRU5WPTxlbnYtbmFtZT4gaGVsbWZpbGUgLS1zZWxlY3RvciByZWxlYXNlLWdyb3VwPWluZ3Jl" + + "c3Mgc3luYwpgYGAKCiMjIFZlcmlmeQoKVmVyaWZ5IHRoZSByb3V0ZSBvbmx5IHdoZW4gdGhlIGFk" + + "ZG9uIGlzIHByZXNlbnQgYW5kIGVuYWJsZWQ6CgpgYGBiYXNoCmt1YmVjdGwgZ2V0IGRlcGxveSxz" + + "dmMgLW4gbnZjZi11aQprdWJlY3RsIGdldCBodHRwcm91dGUgLUEgfCBncmVwIC1pIG52Y2YtdWkK" + + "Y3VybCAtaSAtSCAiSG9zdDogbnZjZi11aS48ZG9tYWluPiIgImh0dHA6Ly88Z2F0ZXdheS1hZGRy" + + "ZXNzPi9zdGF0dXMiCmBgYAoKIyMgU2VjdXJpdHkKClRoZSBOVkNGIFVJIGFkbWluIHBhbmVsIGlz" + + "IGN1cnJlbnRseSB1bmF1dGhlbnRpY2F0ZWQuIERvIG5vdCBleHBvc2UgaXQgdG8gdGhlCnB1Ymxp" + + "YyBpbnRlcm5ldC4gUmVzdHJpY3QgYWNjZXNzIHRvIGEgdHJ1c3RlZCBuZXR3b3JrLCBWUE4sIG9y" + + "IGFuIGF1dGhlbnRpY2F0aW5nCnByb3h5IGluIGZyb250IG9mIHRoZSBgbnZjZi11aWAgcm91dGUu" + + "ClBLBwg4+SevuQcAALkHAABQSwMEFAAIAAAAAAAhAAAAAAAAAAAAAAAAAD4ACQBkYXRhL252Y2Yt" + + "c2VsZi1tYW5hZ2VkLWluc3RhbGxhdGlvbi9yZWZlcmVuY2VzL3B1bGwtc2VjcmV0cy5tZFVUBQAB" + + "AKbOEiMgSW1hZ2UgUHVsbCBTZWNyZXRzIFJlZmVyZW5jZQoKIyMgT3ZlcnZpZXcKCldoZW4gcHVs" + + "bGluZyBOVkNGIGltYWdlcyBmcm9tIGEgcHJpdmF0ZSByZWdpc3RyeSAoZm9yIGV4YW1wbGUsIE5H" + + "QwpgbnZjci5pb2ApLCBLdWJlcm5ldGVzIG5lZWRzIGBpbWFnZVB1bGxTZWNyZXRzYCBvbiBldmVy" + + "eSBwb2QuIENvbnRyb2wtcGxhbmUgYW5kCmNvbXB1dGUtcGxhbmUgY3JlZGVudGlhbHMgYXJlIGNv" + + "bmZpZ3VyZWQgaW4gdGhlaXIgb3duIGNsdXN0ZXIgY29udGV4dHMuIERvIG5vdAp1c2Ugb25lIG1p" + + "eGVkIG5hbWVzcGFjZSBsaXN0LgoKVGhlIHJlY29tbWVuZGVkIGNvbnRyb2wtcGxhbmUgYXBwcm9h" + + "Y2ggdXNlcyBLeXZlcm5vIHRvIGluamVjdCB0aGUgc2VjcmV0IGludG8KY29udHJvbC1wbGFuZSBw" + + "b2RzIGF0IGFkbWlzc2lvbiB0aW1lLiBUaGUgY29tcHV0ZS1wbGFuZSBjaGFydCBhbmQgb3BlcmF0" + + "b3IgdXNlCnRoZSBzZWNyZXQgaW4gYG52Y2Etb3BlcmF0b3JgIGFuZCBtaXJyb3IgaXQgdG8gYG52" + + "Y2Etc3lzdGVtYC4KCiMjIEt5dmVybm8gQXBwcm9hY2ggKFJlY29tbWVuZGVkKQoKIyMjIDEuIElu" + + "c3RhbGwgS3l2ZXJubwoKYGBgYmFzaApoZWxtIHJlcG8gYWRkIGt5dmVybm8gaHR0cHM6Ly9reXZl" + + "cm5vLmdpdGh1Yi5pby9reXZlcm5vLwpoZWxtIHJlcG8gdXBkYXRlCmhlbG0gaW5zdGFsbCBreXZl" + + "cm5vIGt5dmVybm8va3l2ZXJubyAtbiBreXZlcm5vIC0tY3JlYXRlLW5hbWVzcGFjZSBcCiAgLS1r" + + "dWJlLWNvbnRleHQgPGNvbnRyb2wtcGxhbmUtY29udGV4dD4KYGBgCgojIyMgMi4gQ3JlYXRlIGNv" + + "bnRyb2wtcGxhbmUgcHVsbCBzZWNyZXRzCgpgYGBiYXNoCmV4cG9ydCBOR0NfQVBJX0tFWT0iPHlv" + + "dXItbmdjLWFwaS1rZXk+IgoKZm9yIG5zIGluIGNhc3NhbmRyYS1zeXN0ZW0gbmF0cy1zeXN0ZW0g" + + "bnZjZiBhcGkta2V5cyBlc3Mgc2lzIHZhdWx0LXN5c3RlbSBjZXJ0LW1hbmFnZXI7IGRvCiAga3Vi" + + "ZWN0bCAtLWNvbnRleHQgPGNvbnRyb2wtcGxhbmUtY29udGV4dD4gY3JlYXRlIG5hbWVzcGFjZSAi" + + "JG5zIiBcCiAgICAtLWRyeS1ydW49Y2xpZW50IC1vIHlhbWwgfCBrdWJlY3RsIC0tY29udGV4dCA8" + + "Y29udHJvbC1wbGFuZS1jb250ZXh0PiBhcHBseSAtZiAtCmRvbmUKCmZvciBucyBpbiBjYXNzYW5k" + + "cmEtc3lzdGVtIG5hdHMtc3lzdGVtIG52Y2YgYXBpLWtleXMgZXNzIHNpcyB2YXVsdC1zeXN0ZW0g" + + "Y2VydC1tYW5hZ2VyOyBkbwogIGt1YmVjdGwgLS1jb250ZXh0IDxjb250cm9sLXBsYW5lLWNvbnRl" + + "eHQ+IGNyZWF0ZSBzZWNyZXQgZG9ja2VyLXJlZ2lzdHJ5IG52Y3ItY3JlZHMgXAogICAgLS1kb2Nr" + + "ZXItc2VydmVyPW52Y3IuaW8gXAogICAgLS1kb2NrZXItdXNlcm5hbWU9JyRvYXV0aHRva2VuJyBc" + + "CiAgICAtLWRvY2tlci1wYXNzd29yZD0iJE5HQ19BUElfS0VZIiBcCiAgICAtLW5hbWVzcGFjZT0i" + + "JG5zIiBcCiAgICAtLWRyeS1ydW49Y2xpZW50IC1vIHlhbWwgfCBrdWJlY3RsIC0tY29udGV4dCA8" + + "Y29udHJvbC1wbGFuZS1jb250ZXh0PiBhcHBseSAtZiAtCmRvbmUKYGBgCgpGb3Igbm9uLU5HQyBy" + + "ZWdpc3RyaWVzLCByZXBsYWNlIGAtLWRvY2tlci1zZXJ2ZXJgLCBgLS1kb2NrZXItdXNlcm5hbWVg" + + "LCBhbmQgYC0tZG9ja2VyLXBhc3N3b3JkYC4KCiMjIyAzLiBBcHBseSBLeXZlcm5vIENsdXN0ZXJQ" + + "b2xpY3kKCmBgYHlhbWwKYXBpVmVyc2lvbjoga3l2ZXJuby5pby92MQpraW5kOiBDbHVzdGVyUG9s" + + "aWN5Cm1ldGFkYXRhOgogIG5hbWU6IG52Y2YtYWRkLWltYWdlcHVsbHNlY3JldHMKc3BlYzoKICBi" + + "YWNrZ3JvdW5kOiBmYWxzZQogIHJ1bGVzOgogICAgLSBuYW1lOiBhZGQtaW1hZ2VwdWxsc2VjcmV0" + + "LXRvLW52Y2YtcG9kcwogICAgICBtYXRjaDoKICAgICAgICBhbnk6CiAgICAgICAgLSByZXNvdXJj" + + "ZXM6CiAgICAgICAgICAgIGtpbmRzOgogICAgICAgICAgICAtIFBvZAogICAgICAgICAgICBuYW1l" + + "c3BhY2VzOgogICAgICAgICAgICAtICJudmNmIgogICAgICAgICAgICAtICJhcGkta2V5cyIKICAg" + + "ICAgICAgICAgLSAic2lzIgogICAgICAgICAgICAtICJlc3MiCiAgICAgICAgICAgIC0gIm5hdHMt" + + "c3lzdGVtIgogICAgICAgICAgICAtICJjYXNzYW5kcmEtc3lzdGVtIgogICAgICAgICAgICAtICJ2" + + "YXVsdC1zeXN0ZW0iCiAgICAgICAgICAgIC0gImNlcnQtbWFuYWdlciIKICAgICAgbXV0YXRlOgog" + + "ICAgICAgIHBhdGNoU3RyYXRlZ2ljTWVyZ2U6CiAgICAgICAgICBtZXRhZGF0YToKICAgICAgICAg" + + "ICAgYW5ub3RhdGlvbnM6CiAgICAgICAgICAgICAgbnZjZi5udmlkaWEuY29tL2ltYWdlcHVsbHNl" + + "Y3JldC1pbmplY3RlZC1ieToga3l2ZXJubwogICAgICAgICAgc3BlYzoKICAgICAgICAgICAgaW1h" + + "Z2VQdWxsU2VjcmV0czoKICAgICAgICAgICAgLSBuYW1lOiBudmNyLWNyZWRzCmBgYAoKYGBgYmFz" + + "aAprdWJlY3RsIC0tY29udGV4dCA8Y29udHJvbC1wbGFuZS1jb250ZXh0PiBhcHBseSBcCiAgLWYg" + + "a3l2ZXJuby1pbWFnZXB1bGxzZWNyZXQtcG9saWN5LnlhbWwKYGBgCgojIyMgNC4gSW5zdGFsbCB0" + + "aGUgY29udHJvbCBwbGFuZQoKQ29udGludWUgd2l0aCB0aGUgc2VsZWN0ZWQgY29udHJvbC1wbGFu" + + "ZSBpbnN0YWxsYXRpb24gaW4KW1NwbGl0IENvbXB1dGUtUGxhbmUgSW5zdGFsbGF0aW9uXShjb21w" + + "dXRlLXBsYW5lLWluc3RhbGxhdGlvbi5tZCkuIE5vCmNvbnRyb2wtcGxhbmUgaGVsbWZpbGUgbW9k" + + "aWZpY2F0aW9ucyBhcmUgbmVlZGVkLiBLeXZlcm5vIGluamVjdHMgdGhlIHB1bGwKc2VjcmV0IGlu" + + "dG8gbmV3IGNvbnRyb2wtcGxhbmUgcG9kcy4KCiMjIENvbXB1dGUtUGxhbmUgU2VjcmV0CgpDcmVh" + + "dGUgdGhlIHNlY3JldCBvbmx5IGluIGBudmNhLW9wZXJhdG9yYCBvbiB0aGUgY29tcHV0ZSBjbHVz" + + "dGVyOgoKYGBgYmFzaAprdWJlY3RsIC0tY29udGV4dCA8Y29tcHV0ZS1wbGFuZS1jb250ZXh0PiBj" + + "cmVhdGUgbmFtZXNwYWNlIG52Y2Etb3BlcmF0b3IgXAogIC0tZHJ5LXJ1bj1jbGllbnQgLW8geWFt" + + "bCB8IFwKICBrdWJlY3RsIC0tY29udGV4dCA8Y29tcHV0ZS1wbGFuZS1jb250ZXh0PiBhcHBseSAt" + + "ZiAtCgprdWJlY3RsIC0tY29udGV4dCA8Y29tcHV0ZS1wbGFuZS1jb250ZXh0PiBjcmVhdGUgc2Vj" + + "cmV0IGRvY2tlci1yZWdpc3RyeSBudmNyLWNyZWRzIFwKICAtLWRvY2tlci1zZXJ2ZXI9bnZjci5p" + + "byBcCiAgLS1kb2NrZXItdXNlcm5hbWU9JyRvYXV0aHRva2VuJyBcCiAgLS1kb2NrZXItcGFzc3dv" + + "cmQ9IiROR0NfQVBJX0tFWSIgXAogIC0tbmFtZXNwYWNlPW52Y2Etb3BlcmF0b3IgXAogIC0tZHJ5" + + "LXJ1bj1jbGllbnQgLW8geWFtbCB8IFwKICBrdWJlY3RsIC0tY29udGV4dCA8Y29tcHV0ZS1wbGFu" + + "ZS1jb250ZXh0PiBhcHBseSAtZiAtCmBgYAoKUmVmZXJlbmNlIGl0IGluIHRoZSBjb21wdXRlLXBs" + + "YW5lIGVudmlyb25tZW50IGZpbGU6CgpgYGB5YW1sCmdsb2JhbDoKICBpbWFnZVB1bGxTZWNyZXRz" + + "OgogICAgLSBuYW1lOiBudmNyLWNyZWRzCmBgYAoKVGhlIGNoYXJ0IGFuZCBvcGVyYXRvciB1c2Ug" + + "dGhhdCByZWZlcmVuY2UgaW4gYG52Y2Etb3BlcmF0b3JgIGFuZCBtaXJyb3IgdGhlCnNlY3JldCB0" + + "byBgbnZjYS1zeXN0ZW1gLiBEbyBub3QgY3JlYXRlIGEgYnJvYWRlciBtYW51YWwgY29tcHV0ZSBu" + + "YW1lc3BhY2UgbGlzdC4gRm9sbG93CltTcGxpdCBDb21wdXRlLVBsYW5lIEluc3RhbGxhdGlvbl0o" + + "Y29tcHV0ZS1wbGFuZS1pbnN0YWxsYXRpb24ubWQpIGZvciB0aGUKc2VsZWN0ZWQgaW5zdGFsbCBm" + + "bG93LgoKIyMgVmVyaWZpY2F0aW9uCgpgYGBiYXNoCiMgQ2hlY2sgdGhhdCBhIGNvbnRyb2wtcGxh" + + "bmUgcG9kIGhhcyB0aGUgaW5qZWN0ZWQgc2VjcmV0Cmt1YmVjdGwgLS1jb250ZXh0IDxjb250cm9s" + + "LXBsYW5lLWNvbnRleHQ+IGdldCBwb2QgLW4gPG5hbWVzcGFjZT4gPHBvZC1uYW1lPiBcCiAgLW8g" + + "anNvbnBhdGg9J3suc3BlYy5pbWFnZVB1bGxTZWNyZXRzfScKIyBFeHBlY3RlZDogW3sibmFtZSI6" + + "Im52Y3ItY3JlZHMifV0KCiMgQ2hlY2sgdGhlIEt5dmVybm8gYW5ub3RhdGlvbgprdWJlY3RsIC0t" + + "Y29udGV4dCA8Y29udHJvbC1wbGFuZS1jb250ZXh0PiBnZXQgcG9kIC1uIDxuYW1lc3BhY2U+IDxw" + + "b2QtbmFtZT4gXAogIC1vIGpzb25wYXRoPSd7Lm1ldGFkYXRhLmFubm90YXRpb25zLm52Y2ZcLm52" + + "aWRpYVwuY29tL2ltYWdlcHVsbHNlY3JldC1pbmplY3RlZC1ieX0nCiMgRXhwZWN0ZWQ6IGt5dmVy" + + "bm8KCiMgQ2hlY2sgcHVsbCBldmVudHMKa3ViZWN0bCAtLWNvbnRleHQgPGNvbnRyb2wtcGxhbmUt" + + "Y29udGV4dD4gZ2V0IGV2ZW50cyAtbiA8bmFtZXNwYWNlPiBcCiAgLS1zb3J0LWJ5PScubGFzdFRp" + + "bWVzdGFtcCcgfCBncmVwIC1pIHB1bGwKIyBTaG91bGQgc2hvdyAiU3VjY2Vzc2Z1bGx5IHB1bGxl" + + "ZCIgbm90ICI0MDEgVW5hdXRob3JpemVkIgoKIyBDaGVjayB0aGUgY2hhcnQvb3BlcmF0b3IgbWly" + + "cm9yIG9uIHRoZSBjb21wdXRlIGNsdXN0ZXIKa3ViZWN0bCAtLWNvbnRleHQgPGNvbXB1dGUtcGxh" + + "bmUtY29udGV4dD4gZ2V0IHNlY3JldCBudmNyLWNyZWRzIFwKICAtbiBudmNhLXN5c3RlbQpgYGAK" + + "CiMjIFdoZW4gUHVsbCBTZWNyZXRzIEFyZSBOb3QgTmVlZGVkCgotICoqQVdTIEVDUiB3aXRoIElB" + + "TSBub2RlIHJvbGVzKio6IElmIHlvdXIgbm9kZXMgaGF2ZSBgQW1hem9uRUMyQ29udGFpbmVyUmVn" + + "aXN0cnlSZWFkT25seWAgSUFNIHBvbGljeSwgS3ViZXJuZXRlcyBjYW4gcHVsbCBmcm9tIEVDUiB3" + + "aXRob3V0IGV4cGxpY2l0IHNlY3JldHMuCi0gKipQdWJsaWMgcmVnaXN0cmllcyoqOiBObyBwdWxs" + + "IHNlY3JldHMgbmVlZGVkLgotICoqQ1NQIGJ1aWx0LWluIGNyZWRlbnRpYWwgaGVscGVycyoqOiBH" + + "S0UgQXJ0aWZhY3QgUmVnaXN0cnksIEF6dXJlIEFDUiB3aXRoIG1hbmFnZWQgaWRlbnRpdHksIGFu" + + "ZCBzaW1pbGFyIHNlcnZpY2VzLgoKIyMgVHJvdWJsZXNob290aW5nCgojIyMgUG9kcyBzdGlsbCBp" + + "biBJbWFnZVB1bGxCYWNrT2ZmIGFmdGVyIGFwcGx5aW5nIHBvbGljeQoKVGhlIEt5dmVybm8gcG9s" + + "aWN5IG9ubHkgYWZmZWN0cyBwb2RzIGNyZWF0ZWQgKiphZnRlcioqIHRoZSBwb2xpY3kgaXMgYXBw" + + "bGllZC4gRGVsZXRlIHN0dWNrIHBvZHMgdG8gdHJpZ2dlciByZWNyZWF0aW9uOgoKYGBgYmFzaApr" + + "dWJlY3RsIC0tY29udGV4dCA8dGFyZ2V0LWNvbnRleHQ+IGRlbGV0ZSBwb2RzIC1uIDxuYW1lc3Bh" + + "Y2U+IC0tYWxsCmBgYAoKIyMjIEt5dmVybm8gYWRtaXNzaW9uIGNvbnRyb2xsZXIgbm90IHJ1bm5p" + + "bmcKCmBgYGJhc2gKa3ViZWN0bCAtLWNvbnRleHQgPGNvbnRyb2wtcGxhbmUtY29udGV4dD4gZ2V0" + + "IHBvZHMgLW4ga3l2ZXJubwojIEFsbCBwb2RzIHNob3VsZCBiZSBSdW5uaW5nCmBgYAoKIyMjIFBv" + + "bGljeSBub3QgbWF0Y2hpbmcKCmBgYGJhc2gKa3ViZWN0bCAtLWNvbnRleHQgPGNvbnRyb2wtcGxh" + + "bmUtY29udGV4dD4gZ2V0IGNsdXN0ZXJwb2xpY3kgbnZjZi1hZGQtaW1hZ2VwdWxsc2VjcmV0cwoj" + + "IFNob3VsZCBzaG93IFJFQURZOiBUcnVlCmBgYAoKIyMjIFdyb25nIHNlY3JldCBuYW1lCgpUaGUg" + + "cG9saWN5IHJlZmVyZW5jZXMgYG52Y3ItY3JlZHNgLiBWZXJpZnkgdGhlIHNlY3JldCBleGlzdHMg" + + "d2l0aCB0aGF0IGV4YWN0IG5hbWU6CgpgYGBiYXNoCmt1YmVjdGwgLS1jb250ZXh0IDx0YXJnZXQt" + + "Y29udGV4dD4gZ2V0IHNlY3JldCBudmNyLWNyZWRzIC1uIDxuYW1lc3BhY2U+CmBgYApQSwcIS0I1" + + "qAAWAAAAFgAAUEsBAhQAFAAIAAAAAAAhAM/joTZJEAAASRAAABIACQAAAAAAAAAAAAAAAAAAAGRh" + + "dGEvbWFuaWZlc3QuanNvblVUBQABAKbOElBLAQIUABQACAAAAAAAIQDNgTDkTWEAAE1hAAAjAAkA" + + "AAAAAAAAAAAAAJIQAABkYXRhL252Y2Ytc2VsZi1tYW5hZ2VkLWNsaS9TS0lMTC5tZFVUBQABAKbO" + + "ElBLAQIUABQACAAAAAAAIQAhxsiG8AoAAPAKAAAzAAkAAAAAAAAAAAAAADlyAABkYXRhL252Y2Yt" + + "c2VsZi1tYW5hZ2VkLWNsaS9leGFtcGxlcy9jaS1waXBlbGluZXMubWRVVAUAAQCmzhJQSwECFAAU" + + "AAgAAAAAACEAoRTjgV0MAABdDAAANAAJAAAAAAAAAAAAAACTfQAAZGF0YS9udmNmLXNlbGYtbWFu" + + "YWdlZC1jbGkvZXhhbXBsZXMvbXVsdGktY2x1c3Rlci5tZFVUBQABAKbOElBLAQIUABQACAAAAAAA" + + "IQBCJ0kPBQ0AAAUNAAA3AAkAAAAAAAAAAAAAAFuKAABkYXRhL252Y2Ytc2VsZi1tYW5hZ2VkLWNs" + + "aS9wcm9tcHRzL2FkZC1jb21wdXRlLXBsYW5lLm1kVVQFAAEAps4SUEsBAhQAFAAIAAAAAAAhAJHc" + + "G/mYGQAAmBkAADkACQAAAAAAAAAAAAAAzpcAAGRhdGEvbnZjZi1zZWxmLW1hbmFnZWQtY2xpL3By" + + "b21wdHMvY3JlYXRlLWFuZC1ydW4tdGFzay5tZFVUBQABAKbOElBLAQIUABQACAAAAAAAIQDSQ9wE" + + "GCUAABglAAA3AAkAAAAAAAAAAAAAANaxAABkYXRhL252Y2Ytc2VsZi1tYW5hZ2VkLWNsaS9wcm9t" + + "cHRzL2RlcGxveS1hbmQtaW52b2tlLm1kVVQFAAEAps4SUEsBAhQAFAAIAAAAAAAhAA6cP5e9DgAA" + + "vQ4AAD0ACQAAAAAAAAAAAAAAXNcAAGRhdGEvbnZjZi1zZWxmLW1hbmFnZWQtY2xpL3Byb21wdHMv" + + "ZGlhZ25vc2UtZmFpbGVkLWluc3RhbGwubWRVVAUAAQCmzhJQSwECFAAUAAgAAAAAACEAqvLWHrcn" + + "AAC3JwAAOgAJAAAAAAAAAAAAAACN5gAAZGF0YS9udmNmLXNlbGYtbWFuYWdlZC1jbGkvcHJvbXB0" + + "cy9pbnN0YWxsLWZyb20tc2NyYXRjaC5tZFVUBQABAKbOElBLAQIUABQACAAAAAAAIQAaxCyexwcA" + + "AMcHAAA5AAkAAAAAAAAAAAAAALUOAQBkYXRhL252Y2Ytc2VsZi1tYW5hZ2VkLWNsaS9wcm9tcHRz" + + "L3JvdGF0ZS1jbHVzdGVyLWp3a3MubWRVVAUAAQCmzhJQSwECFAAUAAgAAAAAACEAEpMzWeAhAADg" + + "IQAALgAJAAAAAAAAAAAAAADsFgEAZGF0YS9udmNmLXNlbGYtbWFuYWdlZC1jbGkvcHJvbXB0cy90" + + "ZWFyZG93bi5tZFVUBQABAKbOElBLAQIUABQACAAAAAAAIQByDQ9kISMAACEjAAAwAAkAAAAAAAAA" + + "AAAAADE5AQBkYXRhL252Y2Ytc2VsZi1tYW5hZ2VkLWNsaS9yZWZlcmVuY2UvY29tbWFuZHMubWRV" + + "VAUAAQCmzhJQSwECFAAUAAgAAAAAACEAc6daZNUGAADVBgAAMgAJAAAAAAAAAAAAAAC5XAEAZGF0" + + "YS9udmNmLXNlbGYtbWFuYWdlZC1jbGkvcmVmZXJlbmNlL2V4aXQtY29kZXMubWRVVAUAAQCmzhJQ" + + "SwECFAAUAAgAAAAAACEA/KOR4MYiAADGIgAALQAJAAAAAAAAAAAAAAD3YwEAZGF0YS9udmNmLXNl" + + "bGYtbWFuYWdlZC1jbGkvcmVmZXJlbmNlL2ZsYWdzLm1kVVQFAAEAps4SUEsBAhQAFAAIAAAAAAAh" + + "APOuE4R0EQAAdBEAADcACQAAAAAAAAAAAAAAIYcBAGRhdGEvbnZjZi1zZWxmLW1hbmFnZWQtY2xp" + + "L3JlZmVyZW5jZS90cm91Ymxlc2hvb3RpbmcubWRVVAUAAQCmzhJQSwECFAAUAAgAAAAAACEAL9q5" + + "dUJiAABCYgAALAAJAAAAAAAAAAAAAAADmQEAZGF0YS9udmNmLXNlbGYtbWFuYWdlZC1pbnN0YWxs" + + "YXRpb24vU0tJTEwubWRVVAUAAQCmzhJQSwECFAAUAAgAAAAAACEAKxO4P61VAACtVQAANAAJAAAA" + + "AAAAAAAAAACo+wEAZGF0YS9udmNmLXNlbGYtbWFuYWdlZC1pbnN0YWxsYXRpb24vZXZhbHMvZXZh" + + "bHMuanNvblVUBQABAKbOElBLAQIUABQACAAAAAAAIQACUk5AfygAAH8oAAAvAAkAAAAAAAAAAAAA" + + "AMBRAgBkYXRhL252Y2Ytc2VsZi1tYW5hZ2VkLWluc3RhbGxhdGlvbi9leGFtcGxlcy5tZFVUBQAB" + + "AKbOElBLAQIUABQACAAAAAAAIQCWY7xZEjAAABIwAABMAAkAAAAAAAAAAAAAAKV6AgBkYXRhL252" + + "Y2Ytc2VsZi1tYW5hZ2VkLWluc3RhbGxhdGlvbi9yZWZlcmVuY2VzL2NvbXB1dGUtcGxhbmUtaW5z" + + "dGFsbGF0aW9uLm1kVVQFAAEAps4SUEsBAhQAFAAIAAAAAAAhAFY+Z5CVMAAAlTAAADsACQAAAAAA" + + "AAAAAAAAOqsCAGRhdGEvbnZjZi1zZWxmLW1hbmFnZWQtaW5zdGFsbGF0aW9uL3JlZmVyZW5jZXMv" + + "ZGVidWdnaW5nLm1kVVQFAAEAps4SUEsBAhQAFAAIAAAAAAAhAMBWIOePJwAAjycAAEQACQAAAAAA" + + "AAAAAAAAQdwCAGRhdGEvbnZjZi1zZWxmLW1hbmFnZWQtaW5zdGFsbGF0aW9uL3JlZmVyZW5jZXMv" + + "aGVsbWZpbGUtc3RydWN0dXJlLm1kVVQFAAEAps4SUEsBAhQAFAAIAAAAAAAhADj5J6+5BwAAuQcA" + + "AD8ACQAAAAAAAAAAAAAASwQDAGRhdGEvbnZjZi1zZWxmLW1hbmFnZWQtaW5zdGFsbGF0aW9uL3Jl" + + "ZmVyZW5jZXMvbnZjZi11aS1hZGRvbi5tZFVUBQABAKbOElBLAQIUABQACAAAAAAAIQBLQjWoABYA" + + "AAAWAAA+AAkAAAAAAAAAAAAAAHoMAwBkYXRhL252Y2Ytc2VsZi1tYW5hZ2VkLWluc3RhbGxhdGlv" + + "bi9yZWZlcmVuY2VzL3B1bGwtc2VjcmV0cy5tZFVUBQABAKbOElBLBQYAAAAAFwAXAK8JAADvIgMA" + + "AAA=" var ( skillDataOnce sync.Once diff --git a/tests/bdd/gateway_examples_test.go b/tests/bdd/gateway_examples_test.go index 06d0e9efd..5fc9b5f22 100644 --- a/tests/bdd/gateway_examples_test.go +++ b/tests/bdd/gateway_examples_test.go @@ -85,6 +85,14 @@ func TestRemoteGatewayExamplesConfigureAWSNLBOnEnvoyService(t *testing.T) { if err != nil { t.Fatalf("read %s: %v", example.path, err) } + for _, guard := range []string{ + `test -n "$GATEWAY_ADDR" || exit 1`, + `test -n "$GRPC_GATEWAY_ADDR" || exit 1`, + } { + if !bytes.Contains(body, []byte(guard)) { + t.Errorf("%s does not fail explicitly when a documented Gateway address is empty", example.path) + } + } resources, err := documentedApplyResources(body) if err != nil { @@ -182,6 +190,9 @@ func documentedApplyResources(markdown []byte) ([]documentedResource, error) { manifest.WriteString(scanner.Text()) manifest.WriteByte('\n') } + if err := scanner.Err(); err != nil { + return nil, fmt.Errorf("scan kubectl apply manifest: %w", err) + } if !foundEnd { return nil, fmt.Errorf("kubectl apply heredoc has no EOF terminator") } @@ -206,6 +217,16 @@ func documentedApplyResources(markdown []byte) ([]documentedResource, error) { return resources, nil } +func TestDocumentedApplyResourcesPreservesScannerErrors(t *testing.T) { + markdown := "kubectl apply -f - < Date: Tue, 25 Aug 2026 15:55:30 -0400 Subject: [PATCH 5/6] fix(self-managed): close routing review gaps Signed-off-by: Mike Camp --- .../prompts/install-from-scratch.md | 93 +- deploy/helm/llm-request-router/README.md | 8 +- deploy/stacks/self-managed/global.yaml.gotmpl | 5 +- .../tests/llm-router-split-cluster.sh | 22 + docs/user/gateway-routing.md | 82 +- docs/user/llm-function-enablement.md | 25 +- .../agentskill/skilldata_generated.go | 5151 +++++++++-------- tests/bdd/gateway_examples_test.go | 11 + 8 files changed, 2732 insertions(+), 2665 deletions(-) diff --git a/ai-tooling/user/skills/nvcf-self-managed-cli/prompts/install-from-scratch.md b/ai-tooling/user/skills/nvcf-self-managed-cli/prompts/install-from-scratch.md index dba83282d..d8b3151ef 100644 --- a/ai-tooling/user/skills/nvcf-self-managed-cli/prompts/install-from-scratch.md +++ b/ai-tooling/user/skills/nvcf-self-managed-cli/prompts/install-from-scratch.md @@ -32,7 +32,57 @@ User wants to bring up self-hosted NVCF on a fresh Kubernetes cluster (or k3d fo helm upgrade --install eg oci://docker.io/envoyproxy/gateway-helm \ --version v1.1.3 \ -n envoy-gateway-system + ``` + + Before applying the `EnvoyProxy`, determine which Service controller owns + load balancers on EKS. Do not apply the manifest until you have selected the + matching `envoyService` configuration. Use the EKS API and the in-cluster + controller Deployment instead of guessing from the cluster age or existing + Services: + + ```sh + export EKS_CLUSTER_NAME="" + + aws eks describe-cluster --name "$EKS_CLUSTER_NAME" \ + --query 'cluster.kubernetesNetworkConfig.elasticLoadBalancing.enabled' \ + --output text + kubectl -n kube-system get deployment aws-load-balancer-controller + ``` + + An EKS API result of `True` selects + [EKS Auto Mode](https://docs.aws.amazon.com/eks/latest/userguide/auto-configure-nlb.html). + Otherwise, a successful Deployment lookup selects the AWS Load Balancer + Controller. If neither is present, confirm that the cluster intentionally + uses the legacy AWS cloud provider Service controller, or install the AWS + Load Balancer Controller, before applying the example. + + The applied manifest below is for the AWS Load Balancer Controller. For EKS + Auto Mode, replace its `envoyService` map before applying it with: + + ```yaml + envoyService: + loadBalancerClass: eks.amazonaws.com/nlb + annotations: + service.beta.kubernetes.io/aws-load-balancer-scheme: "internet-facing" + ``` + + For the legacy AWS cloud provider Service controller, replace the map with: + + ```yaml + envoyService: + annotations: + service.beta.kubernetes.io/aws-load-balancer-type: "nlb" + ``` + The legacy controller creates an internet-facing load balancer by default. + Do not combine the legacy `nlb` selector with the AWS Load Balancer + Controller target type and scheme annotations. It supports an NLB Service + whose ports use only TCP or only UDP, but rejects one Service that combines + TCP and UDP ports. Use the AWS Load Balancer Controller when the generated + Envoy Service combines protocols. On non-AWS clusters, replace the map with + the provider's Service configuration before applying it. + + ```sh # Non-EKS-Auto-Mode example: use AWS LBC with instance targets. kubectl apply -f - <.svc.cluster.local`. +advertised per-pod hostname produced by +`llmRequestRouter.kubernetes.advertisedHostnameTemplate`. The default template +is `{pod_name}.llm-request-router-headless..svc.cluster.local`. The +external `pylonReverseTunnelDialAddress` selects the UDP network path and needs +a SAN only when the advertised identity is also changed to that hostname. Stargate and the backend router poll the mounted TLS certificate and key and reload the server identity for new connections. Client trust-bundle changes diff --git a/deploy/stacks/self-managed/global.yaml.gotmpl b/deploy/stacks/self-managed/global.yaml.gotmpl index 22c180f3f..6999db34a 100644 --- a/deploy/stacks/self-managed/global.yaml.gotmpl +++ b/deploy/stacks/self-managed/global.yaml.gotmpl @@ -862,7 +862,8 @@ llmApiGateway: {{- $pylonGrpcDialAddress := dig "addons" "llm" "requestRouter" "backendRouter" "pylonGrpcDialAddress" "" .Values | default "" | toString | trim }} {{- $pylonReverseTunnelDialAddress := dig "addons" "llm" "requestRouter" "backendRouter" "pylonReverseTunnelDialAddress" "" .Values | default "" | toString | trim }} -{{- if and $llmEnabled (ne (empty $pylonGrpcDialAddress) (empty $pylonReverseTunnelDialAddress)) }} +{{- $backendRouterEnabled := dig "addons" "llm" "requestRouter" "backendRouter" "enabled" $llmEnabled .Values }} +{{- if and $llmEnabled $backendRouterEnabled (ne (empty $pylonGrpcDialAddress) (empty $pylonReverseTunnelDialAddress)) }} {{- fail "addons.llm.requestRouter.backendRouter.pylonGrpcDialAddress and addons.llm.requestRouter.backendRouter.pylonReverseTunnelDialAddress must either both be set or both be omitted" }} {{- end }} @@ -893,7 +894,7 @@ llmRequestRouter: reachable addresses. */}} backendRouter: - enabled: {{ dig "addons" "llm" "requestRouter" "backendRouter" "enabled" (dig "addons" "llm" "enabled" false .Values) .Values }} + enabled: {{ $backendRouterEnabled }} replicaCount: {{ dig "addons" "llm" "requestRouter" "backendRouter" "replicaCount" 2 .Values }} image: registry: {{ .Values.global.image.registry }} diff --git a/deploy/stacks/self-managed/tests/llm-router-split-cluster.sh b/deploy/stacks/self-managed/tests/llm-router-split-cluster.sh index e0b62cd94..8212d9826 100755 --- a/deploy/stacks/self-managed/tests/llm-router-split-cluster.sh +++ b/deploy/stacks/self-managed/tests/llm-router-split-cluster.sh @@ -184,4 +184,26 @@ assert_partial_backend_override_rejected \ test "$partial_override_failures" -eq 0 || fail "$partial_override_failures partial backend-router override case(s) were not rejected" +disabled_environment_name="${environment_name}-backend-router-disabled" +disabled_environment_file="$test_stack_dir/environments/$disabled_environment_name.yaml" +cp "$environment_file" "$disabled_environment_file" +printf '{}\n' >"$test_stack_dir/secrets/$disabled_environment_name-secrets.yaml" +yq -i \ + '.addons.llm.requestRouter.backendRouter.enabled = false | + del(.addons.llm.requestRouter.backendRouter.pylonReverseTunnelDialAddress)' \ + "$disabled_environment_file" + +HELMFILE_ENV="$disabled_environment_name" \ + HELMFILE_CACHE_HOME="$work_dir/helmfile-cache" \ + helmfile \ + --file "$test_stack_dir/helmfile.d/02-core.yaml.gotmpl" \ + --environment default \ + --selector name=llm-request-router \ + write-values \ + --output-file-template "$work_dir/backend-router-disabled-values.yaml" + +assert_file_value "$work_dir/backend-router-disabled-values.yaml" \ + '.llmRequestRouter.backendRouter.enabled' \ + 'false' + echo "llm-router-split-cluster: all checks passed" diff --git a/docs/user/gateway-routing.md b/docs/user/gateway-routing.md index ca0bf7ea0..1cd193079 100644 --- a/docs/user/gateway-routing.md +++ b/docs/user/gateway-routing.md @@ -75,10 +75,57 @@ handle ingress traffic. It does not control Envoy Gateway controller pods. Service annotations on a `Gateway` do not configure the Envoy data-plane Service. Set them in `EnvoyProxy.spec.provider.kubernetes.envoyService` so -Envoy Gateway copies them to the generated Service. The example is for an EKS -cluster that does not use EKS Auto Mode. It uses the +Envoy Gateway copies them to the generated Service. + +Before applying the `EnvoyProxy` on EKS, determine which Service controller +owns load balancers. Do not apply the manifest until you have selected the +matching `envoyService` configuration: + +```bash +export EKS_CLUSTER_NAME="" + +aws eks describe-cluster --name "$EKS_CLUSTER_NAME" \ + --query 'cluster.kubernetesNetworkConfig.elasticLoadBalancing.enabled' \ + --output text +kubectl -n kube-system get deployment aws-load-balancer-controller +``` + +An EKS API result of `True` selects +[EKS Auto Mode](https://docs.aws.amazon.com/eks/latest/userguide/auto-configure-nlb.html). +Otherwise, a successful Deployment lookup selects the AWS Load Balancer +Controller. If neither is present, confirm that the cluster intentionally uses +the legacy AWS cloud provider Service controller, or install the AWS Load +Balancer Controller, before applying the example. + +The applied manifest below uses the [AWS Load Balancer Controller](https://kubernetes-sigs.github.io/aws-load-balancer-controller/latest/guide/service/nlb/) with instance targets and an internet-facing Network Load Balancer (NLB). +For EKS Auto Mode, replace its `envoyService` map before applying it with: + +```yaml +envoyService: + loadBalancerClass: eks.amazonaws.com/nlb + annotations: + service.beta.kubernetes.io/aws-load-balancer-scheme: "internet-facing" +``` + +For the legacy AWS cloud provider Service controller, replace the map with: + +```yaml +envoyService: + annotations: + service.beta.kubernetes.io/aws-load-balancer-type: "nlb" +``` + +The legacy controller creates an internet-facing load balancer by default. Add +`service.beta.kubernetes.io/aws-load-balancer-internal: "true"` for an internal +NLB. Do not combine the legacy `nlb` controller selector with the AWS Load +Balancer Controller target type and scheme annotations. The legacy controller +supports an NLB Service whose ports use only TCP or only UDP, but rejects one +Service that combines TCP and UDP ports. Use the AWS Load Balancer Controller +when the generated Envoy Service combines protocols. For another cloud +provider, replace the `envoyService` map with that provider's Service +configuration before applying it. Create the `GatewayClass` with a `parametersRef` that points to the `EnvoyProxy` resource: @@ -116,37 +163,6 @@ spec: EOF ``` -For [EKS Auto Mode](https://docs.aws.amazon.com/eks/latest/userguide/auto-configure-nlb.html), -replace the AWS Load Balancer Controller annotation map with the Auto Mode -Service class and its documented internet-facing scheme annotation: - -```yaml -envoyService: - loadBalancerClass: eks.amazonaws.com/nlb - annotations: - service.beta.kubernetes.io/aws-load-balancer-scheme: "internet-facing" -``` - -For a cluster that does not use EKS Auto Mode and uses the legacy AWS cloud -provider Service controller instead of the AWS Load Balancer Controller, -replace the three annotations with: - -```yaml -envoyService: - annotations: - service.beta.kubernetes.io/aws-load-balancer-type: "nlb" -``` - -The legacy controller creates an internet-facing load balancer by default. Add -`service.beta.kubernetes.io/aws-load-balancer-internal: "true"` for an internal -NLB. Do not combine the legacy `nlb` controller selector with the AWS Load -Balancer Controller target type and scheme annotations. The legacy controller -supports an NLB Service whose ports use only TCP or only UDP, but rejects one -Service that combines TCP and UDP ports. Use the AWS Load Balancer Controller -when the generated Envoy Service combines protocols. For another cloud provider, -replace the annotations under `envoyService` with that provider's Service -annotations. - ### Create Gateway Create the Gateway resource with an HTTP listener on port 80, a TCP listener on diff --git a/docs/user/llm-function-enablement.md b/docs/user/llm-function-enablement.md index 69c0f93b8..565432863 100644 --- a/docs/user/llm-function-enablement.md +++ b/docs/user/llm-function-enablement.md @@ -496,16 +496,21 @@ kubectl -n nvcf wait --for=condition=Ready \ --timeout=2m ``` -Verify the request-router `Certificate`, its issuer reference, and the SANs. -The commands read only the public certificate: +Set `REQUEST_ROUTER_TLS_NAME` to the value of +`addons.llm.pki.secretName`. Its default is `stargate-quic-tls`. In +`certManager` mode, verify the request-router `Certificate` and its issuer +reference. The `existingSecret` mode does not render a `Certificate`, so skip +the first two commands in that mode. The final command applies to both modes +and reads only the public certificate: ```bash +export REQUEST_ROUTER_TLS_NAME="" kubectl -n nvcf wait --for=condition=Ready \ - certificate/stargate-quic-tls \ + "certificate/$REQUEST_ROUTER_TLS_NAME" \ --timeout=2m -kubectl -n nvcf get certificate stargate-quic-tls \ +kubectl -n nvcf get certificate "$REQUEST_ROUTER_TLS_NAME" \ -o jsonpath='{.spec.issuerRef.kind}{"/"}{.spec.issuerRef.name}{"\n"}' -kubectl -n nvcf get secret stargate-quic-tls \ +kubectl -n nvcf get secret "$REQUEST_ROUTER_TLS_NAME" \ -o jsonpath='{.data.tls\.crt}' \ | base64 --decode \ | openssl x509 -noout -subject -issuer -dates -ext subjectAltName @@ -635,7 +640,9 @@ Use this order for an upgrade from plaintext transport: 5. Apply the remaining control-plane stack. The managed router hook prepares the OpenBao signing path before cert-manager reconciles the request-router `Certificate`. -6. Wait for the issuer and `Certificate/stargate-quic-tls` to become ready. +6. Wait for the issuer and the `Certificate` named by + `addons.llm.pki.secretName` to become ready. The default name is + `stargate-quic-tls`. 7. Export or update the control-plane profile, register each compute plane again, and install the refreshed registration values. 8. Recreate the LLM functions and verify the certificate SAN, trust-bundle @@ -649,9 +656,9 @@ Use this order for a safe rollback: plane again, and recreate the LLM workers with the combined trust bundle. 3. Set `addons.llm.pki.issuerKind` and `issuerName` to the replacement, set `clusterIssuer.enabled: false`, and apply the control-plane stack. -4. Wait for `Certificate/stargate-quic-tls` to become ready, confirm a - successful `server_identity` reload, and verify the replacement TLS data - path with a new connection. +4. Wait for the `Certificate` named by `addons.llm.pki.secretName` to become + ready, confirm a successful `server_identity` reload, and verify the + replacement TLS data path with a new connection. 5. Remove the old root from the compute-plane profile, register each compute plane again, and recreate the workers. 6. Confirm that no `Certificate` references the old issuer: diff --git a/src/clis/nvcf-cli/internal/agentskill/skilldata_generated.go b/src/clis/nvcf-cli/internal/agentskill/skilldata_generated.go index 540665a69..d1ddd58e2 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" + - "MDowMFoiLAogICJ0b3RhbEZpbGVzIjogMjIsCiAgInRvdGFsQnl0ZXMiOiAxOTg5MDMsCiAgImZp" + + "MDowMFoiLAogICJ0b3RhbEZpbGVzIjogMjIsCiAgInRvdGFsQnl0ZXMiOiAxOTg5NzcsCiAgImZp" + "bGVzIjogWwogICAgewogICAgICAicGF0aCI6ICJudmNmLXNlbGYtbWFuYWdlZC1jbGkvU0tJTEwu" + "bWQiLAogICAgICAic2hhMjU2IjogImM0ZjI4OGY2MmU1MDg4NjI5ZGY1MTcyYTlhYjMwZWVlOGMz" + "OTRmYzgzOTFjMjMwMDMzNzI2NGVmZjRiMmU3ZWYiLAogICAgICAic2l6ZSI6IDI0OTA5CiAgICB9" + @@ -56,8 +56,8 @@ const skillDataZipBase64 = "" + "NTU5NWY1ZjNmZTA2YTU5ZjQ2M2U0NGUyMGFkNjg2YjRlYzQ2Mjk2MjI1ODRjZTRmMDQ3NSIsCiAg" + "ICAgICJzaXplIjogMzc3MwogICAgfSwKICAgIHsKICAgICAgInBhdGgiOiAibnZjZi1zZWxmLW1h" + "bmFnZWQtY2xpL3Byb21wdHMvaW5zdGFsbC1mcm9tLXNjcmF0Y2gubWQiLAogICAgICAic2hhMjU2" + - "IjogIjNlMTAxNTBmMjA1MzU0NTliNTZkMTIwMDY3NzRmYTVjYmU2MTg2ZDMyZjA5MzU0MDVhMjE3" + - "N2M4NTk1OTkzOTkiLAogICAgICAic2l6ZSI6IDEwMTY3CiAgICB9LAogICAgewogICAgICAicGF0" + + "IjogIjgzMTA5NmY5MmZjMjU2NWQ0NDg1YmExZDBmNWM1MGZiYTljNjQyNTIxZmRhOTZhNzllZDUy" + + "MmU0ZmU3NWEzYmQiLAogICAgICAic2l6ZSI6IDEwMjQxCiAgICB9LAogICAgewogICAgICAicGF0" + "aCI6ICJudmNmLXNlbGYtbWFuYWdlZC1jbGkvcHJvbXB0cy9yb3RhdGUtY2x1c3Rlci1qd2tzLm1k" + "IiwKICAgICAgInNoYTI1NiI6ICI2ZmFlNTU2MmRjNWU5N2MyNGE5MzYwNWI2NzRhMGFmYzdlYzRh" + "M2QwYmVjM2NlYmY5ZjY0ZThiZTZmMjY3OGE1IiwKICAgICAgInNpemUiOiAxOTkxCiAgICB9LAog" + @@ -103,7 +103,7 @@ const skillDataZipBase64 = "" + "IjogIm52Y2Ytc2VsZi1tYW5hZ2VkLWluc3RhbGxhdGlvbi9yZWZlcmVuY2VzL3B1bGwtc2VjcmV0" + "cy5tZCIsCiAgICAgICJzaGEyNTYiOiAiZWMxZjNmZmNkMTdlNWY5NTgzZmVlMzk3NDRlZTg5N2Q0" + "NjZiYzNjZjYzODkyOTQyNjRkODllN2Y5ZWQwMWI4NyIsCiAgICAgICJzaXplIjogNTYzMgogICAg" + - "fQogIF0KfQpQSwcIz+OhNkkQAABJEAAAUEsDBBQACAAAAAAAIQAAAAAAAAAAAAAAAAAjAAkAZGF0" + + "fQogIF0KfQpQSwcI0GJVtkkQAABJEAAAUEsDBBQACAAAAAAAIQAAAAAAAAAAAAAAAAAjAAkAZGF0" + "YS9udmNmLXNlbGYtbWFuYWdlZC1jbGkvU0tJTEwubWRVVAUAAQCmzhItLS0KbmFtZTogbnZjZi1z" + "ZWxmLW1hbmFnZWQtY2xpCmRlc2NyaXB0aW9uOiB8CiAgSW5zdGFsbCwgb3BlcmF0ZSwgYW5kIHRl" + "YXIgZG93biBzZWxmLWhvc3RlZCBOVklESUEgQ2xvdWQgRnVuY3Rpb25zIChOVkNGKQogIGRlcGxv" + @@ -1096,2590 +1096,2591 @@ const skillDataZipBase64 = "" + "ZXNwYWNlICIkbmFtZXNwYWNlIiBudmNmL3BsYXRmb3JtPXRydWUgLS1vdmVyd3JpdGUKICAgZG9u" + "ZQoKICAgaGVsbSB1cGdyYWRlIC0taW5zdGFsbCBlZyBvY2k6Ly9kb2NrZXIuaW8vZW52b3lwcm94" + "eS9nYXRld2F5LWhlbG0gXAogICAgIC0tdmVyc2lvbiB2MS4xLjMgXAogICAgIC1uIGVudm95LWdh" + - "dGV3YXktc3lzdGVtCgogICAjIE5vbi1FS1MtQXV0by1Nb2RlIGV4YW1wbGU6IHVzZSBBV1MgTEJD" + - "IHdpdGggaW5zdGFuY2UgdGFyZ2V0cy4KICAga3ViZWN0bCBhcHBseSAtZiAtIDw8RU9GCiAgIGFw" + - "aVZlcnNpb246IGdhdGV3YXkuZW52b3lwcm94eS5pby92MWFscGhhMQogICBraW5kOiBFbnZveVBy" + - "b3h5CiAgIG1ldGFkYXRhOgogICAgIG5hbWU6IGVnCiAgICAgbmFtZXNwYWNlOiBlbnZveS1nYXRl" + - "d2F5LXN5c3RlbQogICBzcGVjOgogICAgIHByb3ZpZGVyOgogICAgICAgdHlwZTogS3ViZXJuZXRl" + - "cwogICAgICAga3ViZXJuZXRlczoKICAgICAgICAgZW52b3lTZXJ2aWNlOgogICAgICAgICAgIGFu" + - "bm90YXRpb25zOgogICAgICAgICAgICAgc2VydmljZS5iZXRhLmt1YmVybmV0ZXMuaW8vYXdzLWxv" + - "YWQtYmFsYW5jZXItdHlwZTogImV4dGVybmFsIgogICAgICAgICAgICAgc2VydmljZS5iZXRhLmt1" + - "YmVybmV0ZXMuaW8vYXdzLWxvYWQtYmFsYW5jZXItbmxiLXRhcmdldC10eXBlOiAiaW5zdGFuY2Ui" + - "CiAgICAgICAgICAgICBzZXJ2aWNlLmJldGEua3ViZXJuZXRlcy5pby9hd3MtbG9hZC1iYWxhbmNl" + - "ci1zY2hlbWU6ICJpbnRlcm5ldC1mYWNpbmciCiAgIC0tLQogICBhcGlWZXJzaW9uOiBnYXRld2F5" + - "Lm5ldHdvcmtpbmcuazhzLmlvL3YxCiAgIGtpbmQ6IEdhdGV3YXlDbGFzcwogICBtZXRhZGF0YToK" + - "ICAgICBuYW1lOiBlZwogICBzcGVjOgogICAgIGNvbnRyb2xsZXJOYW1lOiBnYXRld2F5LmVudm95" + - "cHJveHkuaW8vZ2F0ZXdheWNsYXNzLWNvbnRyb2xsZXIKICAgICBwYXJhbWV0ZXJzUmVmOgogICAg" + - "ICAgZ3JvdXA6IGdhdGV3YXkuZW52b3lwcm94eS5pbwogICAgICAga2luZDogRW52b3lQcm94eQog" + - "ICAgICAgbmFtZTogZWcKICAgICAgIG5hbWVzcGFjZTogZW52b3ktZ2F0ZXdheS1zeXN0ZW0KICAg" + - "RU9GCgogICBrdWJlY3RsIGFwcGx5IC1mIC0gPDxFT0YKICAgYXBpVmVyc2lvbjogZ2F0ZXdheS5u" + - "ZXR3b3JraW5nLms4cy5pby92MQogICBraW5kOiBHYXRld2F5CiAgIG1ldGFkYXRhOgogICAgIG5h" + - "bWU6IG52Y2YtZ2F0ZXdheQogICAgIG5hbWVzcGFjZTogZW52b3ktZ2F0ZXdheQogICBzcGVjOgog" + - "ICAgIGdhdGV3YXlDbGFzc05hbWU6IGVnCiAgICAgbGlzdGVuZXJzOgogICAgIC0gbmFtZTogaHR0" + - "cAogICAgICAgcHJvdG9jb2w6IEhUVFAKICAgICAgIHBvcnQ6IDgwCiAgICAgICBhbGxvd2VkUm91" + - "dGVzOgogICAgICAgICBuYW1lc3BhY2VzOgogICAgICAgICAgIGZyb206IFNlbGVjdG9yCiAgICAg" + - "ICAgICAgc2VsZWN0b3I6CiAgICAgICAgICAgICBtYXRjaExhYmVsczoKICAgICAgICAgICAgICAg" + - "bnZjZi9wbGF0Zm9ybTogInRydWUiCiAgICAgLSBuYW1lOiB0Y3AKICAgICAgIHByb3RvY29sOiBU" + - "Q1AKICAgICAgIHBvcnQ6IDEwMDgxCiAgICAgICBhbGxvd2VkUm91dGVzOgogICAgICAgICBuYW1l" + - "c3BhY2VzOgogICAgICAgICAgIGZyb206IFNlbGVjdG9yCiAgICAgICAgICAgc2VsZWN0b3I6CiAg" + - "ICAgICAgICAgICBtYXRjaExhYmVsczoKICAgICAgICAgICAgICAgbnZjZi9wbGF0Zm9ybTogInRy" + - "dWUiCiAgIEVPRgogICBgYGAKCiAgIFNlcnZpY2UgYW5ub3RhdGlvbnMgbXVzdCBiZSB1bmRlcgog" + - "ICBgRW52b3lQcm94eS5zcGVjLnByb3ZpZGVyLmt1YmVybmV0ZXMuZW52b3lTZXJ2aWNlLmFubm90" + - "YXRpb25zYC4gRW52b3kgR2F0ZXdheQogICBjb3BpZXMgdGhlbSB0byB0aGUgZ2VuZXJhdGVkIEVu" + - "dm95IFNlcnZpY2UuIERvIG5vdCBwdXQgU2VydmljZSBhbm5vdGF0aW9ucwogICBvbiB0aGUgYEdh" + - "dGV3YXlgIHJlc291cmNlLgoKICAgQmVmb3JlIGFwcGx5aW5nIHRoZSBleGFtcGxlIG9uIEVLUywg" + - "ZGV0ZXJtaW5lIHdoZXRoZXIgdGhlIGNsdXN0ZXIgdXNlcwogICBbRUtTIEF1dG8gTW9kZV0oaHR0" + - "cHM6Ly9kb2NzLmF3cy5hbWF6b24uY29tL2Vrcy9sYXRlc3QvdXNlcmd1aWRlL2F1dG8tY29uZmln" + - "dXJlLW5sYi5odG1sKS4KICAgVXNlIHRoZSBFS1MgQVBJIGFuZCB0aGUgaW4tY2x1c3RlciBjb250" + - "cm9sbGVyIERlcGxveW1lbnQgaW5zdGVhZCBvZiBndWVzc2luZwogICBmcm9tIHRoZSBjbHVzdGVy" + - "IGFnZSBvciBleGlzdGluZyBTZXJ2aWNlczoKCiAgIGBgYHNoCiAgIGV4cG9ydCBFS1NfQ0xVU1RF" + - "Ul9OQU1FPSI8Y2x1c3Rlci1uYW1lPiIKCiAgIGF3cyBla3MgZGVzY3JpYmUtY2x1c3RlciAtLW5h" + - "bWUgIiRFS1NfQ0xVU1RFUl9OQU1FIiBcCiAgICAgLS1xdWVyeSAnY2x1c3Rlci5rdWJlcm5ldGVz" + - "TmV0d29ya0NvbmZpZy5lbGFzdGljTG9hZEJhbGFuY2luZy5lbmFibGVkJyBcCiAgICAgLS1vdXRw" + - "dXQgdGV4dAogICBrdWJlY3RsIC1uIGt1YmUtc3lzdGVtIGdldCBkZXBsb3ltZW50IGF3cy1sb2Fk" + - "LWJhbGFuY2VyLWNvbnRyb2xsZXIKICAgYGBgCgogICBBbiBFS1MgQVBJIHJlc3VsdCBvZiBgVHJ1" + - "ZWAgc2VsZWN0cyBFS1MgQXV0byBNb2RlLiBPdGhlcndpc2UsIGEgc3VjY2Vzc2Z1bAogICBEZXBs" + - "b3ltZW50IGxvb2t1cCBzZWxlY3RzIHRoZSBBV1MgTG9hZCBCYWxhbmNlciBDb250cm9sbGVyLiBJ" + - "ZiBuZWl0aGVyIGlzCiAgIHByZXNlbnQsIGNvbmZpcm0gdGhhdCB0aGUgY2x1c3RlciBpbnRlbnRp" + - "b25hbGx5IHVzZXMgdGhlIGxlZ2FjeSBBV1MgY2xvdWQKICAgcHJvdmlkZXIgU2VydmljZSBjb250" + - "cm9sbGVyLCBvciBpbnN0YWxsIHRoZSBBV1MgTG9hZCBCYWxhbmNlciBDb250cm9sbGVyLAogICBi" + - "ZWZvcmUgYXBwbHlpbmcgdGhlIGV4YW1wbGUuCgogICBGb3IgRUtTIEF1dG8gTW9kZSwgcmVwbGFj" + - "ZSB0aGUgQVdTIExvYWQgQmFsYW5jZXIgQ29udHJvbGxlciBhbm5vdGF0aW9uIG1hcAogICB3aXRo" + - "OgoKICAgYGBgeWFtbAogICBlbnZveVNlcnZpY2U6CiAgICAgbG9hZEJhbGFuY2VyQ2xhc3M6IGVr" + - "cy5hbWF6b25hd3MuY29tL25sYgogICAgIGFubm90YXRpb25zOgogICAgICAgc2VydmljZS5iZXRh" + - "Lmt1YmVybmV0ZXMuaW8vYXdzLWxvYWQtYmFsYW5jZXItc2NoZW1lOiAiaW50ZXJuZXQtZmFjaW5n" + - "IgogICBgYGAKCiAgIEZvciBhIGNsdXN0ZXIgdGhhdCBkb2VzIG5vdCB1c2UgRUtTIEF1dG8gTW9k" + - "ZSwgdGhlIGFwcGxpZWQgZXhhbXBsZSB1c2VzIHRoZQogICBBV1MgTG9hZCBCYWxhbmNlciBDb250" + - "cm9sbGVyLiBJZiB0aGF0IGNsdXN0ZXIgdXNlcyB0aGUgbGVnYWN5IEFXUyBjbG91ZAogICBwcm92" + - "aWRlciBTZXJ2aWNlIGNvbnRyb2xsZXIgaW5zdGVhZCwgdXNlIG9ubHkKICAgYHNlcnZpY2UuYmV0" + - "YS5rdWJlcm5ldGVzLmlvL2F3cy1sb2FkLWJhbGFuY2VyLXR5cGU6ICJubGIiYCBpbiB0aGUKICAg" + - "YGVudm95U2VydmljZS5hbm5vdGF0aW9uc2AgbWFwLiBUaGUgbGVnYWN5IGNvbnRyb2xsZXIgY3Jl" + - "YXRlcyBhbgogICBpbnRlcm5ldC1mYWNpbmcgbG9hZCBiYWxhbmNlciBieSBkZWZhdWx0LiBEbyBu" + - "b3QgY29tYmluZSB0aGUgbGVnYWN5IGBubGJgCiAgIHNlbGVjdG9yIHdpdGggdGhlIEFXUyBMb2Fk" + - "IEJhbGFuY2VyIENvbnRyb2xsZXIgdGFyZ2V0IHR5cGUgYW5kIHNjaGVtZQogICBhbm5vdGF0aW9u" + - "cy4gVGhlIGxlZ2FjeSBjb250cm9sbGVyIHN1cHBvcnRzIGFuIE5MQiBTZXJ2aWNlIHdob3NlIHBv" + - "cnRzIHVzZQogICBvbmx5IFRDUCBvciBvbmx5IFVEUCwgYnV0IHJlamVjdHMgb25lIFNlcnZpY2Ug" + - "dGhhdCBjb21iaW5lcyBUQ1AgYW5kIFVEUAogICBwb3J0cy4gVXNlIHRoZSBBV1MgTG9hZCBCYWxh" + - "bmNlciBDb250cm9sbGVyIHdoZW4gdGhlIGdlbmVyYXRlZCBFbnZveSBTZXJ2aWNlCiAgIGNvbWJp" + - "bmVzIHByb3RvY29scy4gUmVwbGFjZSB0aGUgYW5ub3RhdGlvbnMgd2l0aCB0aGUgcHJvdmlkZXIn" + - "cyBTZXJ2aWNlCiAgIGFubm90YXRpb25zIG9uIG5vbi1BV1MgY2x1c3RlcnMuCgogICBDYXB0dXJl" + - "IHRoZSBHYXRld2F5IHZhbHVlcyBhbmQgd3JpdGUgdGhlIENMSSBjb25maWc6CgogICBgYGBzaAog" + - "ICBleHBvcnQgQ0xVU1RFUl9OQU1FPSJudmNmLXJlbW90ZSIKICAgZXhwb3J0IE5DQV9JRD0ibnZj" + - "Zi1kZWZhdWx0IgogICBleHBvcnQgUkVHSU9OPSJ1cy13ZXN0LTEiCiAgIGV4cG9ydCBIVFRQX0dB" + - "VEVXQVlfTkFNRVNQQUNFPSJlbnZveS1nYXRld2F5IgogICBleHBvcnQgSFRUUF9HQVRFV0FZX05B" + - "TUU9Im52Y2YtZ2F0ZXdheSIKICAgZXhwb3J0IEdSUENfR0FURVdBWV9OQU1FU1BBQ0U9ImVudm95" + - "LWdhdGV3YXkiCiAgIGV4cG9ydCBHUlBDX0dBVEVXQVlfTkFNRT0ibnZjZi1nYXRld2F5IgoKICAg" + - "a3ViZWN0bCAtbiAiJEhUVFBfR0FURVdBWV9OQU1FU1BBQ0UiIHdhaXQgImdhdGV3YXkvJEhUVFBf" + - "R0FURVdBWV9OQU1FIiBcCiAgICAgLS1mb3I9Y29uZGl0aW9uPVByb2dyYW1tZWQ9VHJ1ZSAtLXRp" + - "bWVvdXQ9MTBtCiAgIGt1YmVjdGwgLW4gIiRHUlBDX0dBVEVXQVlfTkFNRVNQQUNFIiB3YWl0ICJn" + - "YXRld2F5LyRHUlBDX0dBVEVXQVlfTkFNRSIgXAogICAgIC0tZm9yPWNvbmRpdGlvbj1Qcm9ncmFt" + - "bWVkPVRydWUgLS10aW1lb3V0PTEwbQoKICAgZXhwb3J0IEdBVEVXQVlfQUREUj0iJChrdWJlY3Rs" + - "IC1uICIkSFRUUF9HQVRFV0FZX05BTUVTUEFDRSIgZ2V0ICJnYXRld2F5LyRIVFRQX0dBVEVXQVlf" + - "TkFNRSIgXAogICAgIC1vIGpzb25wYXRoPSd7LnN0YXR1cy5hZGRyZXNzZXNbMF0udmFsdWV9Jyki" + - "CiAgIGV4cG9ydCBHUlBDX0dBVEVXQVlfQUREUj0iJChrdWJlY3RsIC1uICIkR1JQQ19HQVRFV0FZ" + - "X05BTUVTUEFDRSIgZ2V0ICJnYXRld2F5LyRHUlBDX0dBVEVXQVlfTkFNRSIgXAogICAgIC1vIGpz" + - "b25wYXRoPSd7LnN0YXR1cy5hZGRyZXNzZXNbMF0udmFsdWV9JykiCiAgIHRlc3QgLW4gIiRHQVRF" + - "V0FZX0FERFIiIHx8IGV4aXQgMQogICB0ZXN0IC1uICIkR1JQQ19HQVRFV0FZX0FERFIiIHx8IGV4" + - "aXQgMQogICBleHBvcnQgU1RBQ0tfRE9NQUlOPSIkR0FURVdBWV9BRERSIgogICBgYGAKCiAgIFNl" + - "dCBgU1RBQ0tfRE9NQUlOYCB0byB0aGUgaG9zdG5hbWUgc3VmZml4IHVzZWQgYnkgdGhlIGluc3Rh" + - "bGxlZCBIVFRQUm91dGVzLgogICBGb3IgcmVtb3RlIHRlc3QgZmxvd3Mgd2l0aG91dCBwcm9kdWN0" + - "aW9uIEROUywgdXNlIHRoZSBHYXRld2F5IGxvYWQgYmFsYW5jZXIKICAgYWRkcmVzcy4KCiAgIGBg" + - "YHNoCiAgIGNhdCA+IC5udmNmLWNsaS55YW1sIDw8RU9GCiAgIGJhc2VfaHR0cF91cmw6ICJodHRw" + - "Oi8vJHtHQVRFV0FZX0FERFJ9IgogICBpbnZva2VfdXJsOiAiaHR0cDovLyR7R0FURVdBWV9BRERS" + - "fSIKICAgYmFzZV9ncnBjX3VybDogIiR7R1JQQ19HQVRFV0FZX0FERFJ9OjEwMDgxIgogICBhcGlf" + - "a2V5c19zZXJ2aWNlX3VybDogImh0dHA6Ly8ke0dBVEVXQVlfQUREUn0iCgogICBhcGlfa2V5c19o" + - "b3N0OiAiYXBpLWtleXMuJHtTVEFDS19ET01BSU59IgogICBhcGlfaG9zdDogImFwaS4ke1NUQUNL" + - "X0RPTUFJTn0iCiAgIGludm9rZV9ob3N0OiAiaW52b2NhdGlvbi4ke1NUQUNLX0RPTUFJTn0iCgog" + - "ICBhcGlfa2V5c19zZXJ2aWNlX2lkOiAibnZpZGlhLWNsb3VkLWZ1bmN0aW9ucy1uY3Atc2Vydmlj" + - "ZS1pZC1ha2V0bSIKICAgYXBpX2tleXNfaXNzdWVyX3NlcnZpY2U6ICJudmNmLWFwaSIKICAgYXBp" + - "X2tleXNfb3duZXJfaWQ6ICJzdmNAbnZjZi1hcGkubG9jYWwiCgogICBjbGllbnRfaWQ6ICIke05D" + - "QV9JRH0iCiAgIEVPRgogICBgYGAKCjMuIFJ1biBwcmUtZmxpZ2h0LiBDaG9vc2UgdGhlIGZsYXZv" + - "ciBtYXRjaGluZyB0aGUgdG9wb2xvZ3k6CgogICBgYGBzaAogICAjIFNpbmdsZS1jbHVzdGVyCiAg" + - "IG52Y2YtY2xpIHNlbGYtaG9zdGVkIGNoZWNrIC0tcHJlIC0tanNvbiB8IGpxIC1jIC4KCiAgICMg" + - "U3BsaXQKICAgbnZjZi1jbGkgc2VsZi1ob3N0ZWQgY2hlY2sgLS1wcmUgXAogICAgIC0tY29udHJv" + - "bC1wbGFuZS1jb250ZXh0PWFkbWluQGNwIFwKICAgICAtLWNvbXB1dGUtcGxhbmUtY29udGV4dD1h" + - "ZG1pbkBncHUxIFwKICAgICAtLWpzb24gfCBqcSAtYyAuCgogICAjIENvbXB1dGUtb25seSAob3Bl" + - "cmF0b3Igd2l0aCBrdWJlY3RsIG9uIGNvbXB1dGUgcGxhbmUgb25seSkKICAgbnZjZi1jbGkgc2Vs" + - "Zi1ob3N0ZWQgY2hlY2sgLS1wcmUgXAogICAgIC0tY29tcHV0ZS1wbGFuZS1jb250ZXh0PWFkbWlu" + - "QGdwdTEgXAogICAgIC0taWNtcy11cmw9aHR0cHM6Ly9pY21zLm52Y2YuZXhhbXBsZS5jb20gXAog" + - "ICAgIC0tanNvbiB8IGpxIC1jIC4KICAgYGBgCgogICBQYXJzZSB0aGUgSlNPTkwgc3RyZWFtLiBJ" + - "ZiBhbnkgY2hlY2sgZmFpbHMgKGAicGFzc2VkIjpmYWxzZWApIHdpdGggYHNldmVyaXR5OiBlcnJv" + - "cmAsIHN1cmZhY2UgYG1lc3NhZ2VgICsgYGhpbnRVUkxgIHRvIHRoZSB1c2VyIGFuZCBzdG9wLiBE" + - "b24ndCBwcm9jZWVkIHRvIGluc3RhbGwgd2l0aCBicm9rZW4gcHJlcmVxcy4KCjQuIE1pbnQgYW4g" + - "YWRtaW4gdG9rZW4gaWYgbmVlZGVkLiBgbnZjZi1jbGkgaW5pdGAgaXMgaWRlbXBvdGVudC4gQ2Fs" + - "bCBpdCBpZiB0aGUKICAgdXNlciBkb2VzIG5vdCBoYXZlIGEgc2Vzc2lvbiB5ZXQuIEluaXQgdGFs" + - "a3MgdG8gQVBJIEtleXMgdGhyb3VnaCB0aGUgcHVibGljCiAgIEFQSSBnYXRld2F5LCBzbyBpdCBh" + - "bHNvIHdvcmtzIGluIGNvbXB1dGUtb25seSBtb2RlLgoKNS4gUnVuIGB1cGAuIFVzZSBgLS1qc29u" + - "YCBmb3IgdGhlIEpTT05MIGV2ZW50IHN0cmVhbToKCiAgIGBgYHNoCiAgIG52Y2YtY2xpIHNlbGYt" + - "aG9zdGVkIHVwIFwKICAgICAtLWNsdXN0ZXItbmFtZT0iJHtDTFVTVEVSX05BTUV9IiBcCiAgICAg" + - "LS1uY2EtaWQ9IiR7TkNBX0lEfSIgXAogICAgIC0tcmVnaW9uPSIke1JFR0lPTn0iIFwKICAgICAt" + - "LWpzb24KICAgYGBgCgogICBGb3Igc3BsaXQtY2x1c3RlciBpbnN0YWxscywgYWRkIGJvdGggY29u" + - "dGV4dCBmbGFnczoKCiAgIGBgYHNoCiAgIGV4cG9ydCBDT05UUk9MX1BMQU5FX0NPTlRFWFQ9ImFk" + - "bWluQGNvbnRyb2wtcGxhbmUiCiAgIGV4cG9ydCBDT01QVVRFX1BMQU5FX0NPTlRFWFQ9ImFkbWlu" + - "QGdwdS1jbHVzdGVyIgoKICAgbnZjZi1jbGkgc2VsZi1ob3N0ZWQgdXAgXAogICAgIC0tY29udHJv" + - "bC1wbGFuZS1jb250ZXh0PSIke0NPTlRST0xfUExBTkVfQ09OVEVYVH0iIFwKICAgICAtLWNvbXB1" + - "dGUtcGxhbmUtY29udGV4dD0iJHtDT01QVVRFX1BMQU5FX0NPTlRFWFR9IiBcCiAgICAgLS1jbHVz" + - "dGVyLW5hbWU9IiR7Q0xVU1RFUl9OQU1FfSIgXAogICAgIC0tbmNhLWlkPSIke05DQV9JRH0iIFwK" + - "ICAgICAtLXJlZ2lvbj0iJHtSRUdJT059IiBcCiAgICAgLS1qc29uCiAgIGBgYAoKICAgUGFyc2Ug" + - "ZXZlbnRzOgogICAtIGBwaGFzZV9zdGFydGVkYCAvIGBwaGFzZV9jb21wbGV0ZWRgOiBsb2cgcHJv" + - "Z3Jlc3MKICAgLSBgcGhhc2VfcHJvZ3Jlc3NgOiBzaG93IHByb2dyZXNzIGZvciB0aGUgbG9uZyBh" + - "cHBseSBwaGFzZXMgKHJlc291cmNlIGNvdW50cykKICAgLSBgd2FpdGluZ2A6IHN1cmZhY2UgdG8g" + - "dGhlIHVzZXIgaWYgaXQgcGVyc2lzdHMgZm9yIG1vcmUgdGhhbiAyIG1pbnV0ZXMKICAgLSBgcGhh" + - "c2VfZmFpbGVkYDogc3RvcCBhbmQgc3VyZmFjZSBgZXJyTWVzc2FnZWAgcGx1cyBlYWNoIGByZW1l" + - "ZGlhdGlvbmAgbGluZS4KICAgICBEZWNpZGUgYmFzZWQgb24gYHJldHJ5Q2xhc3NgOiBgaW1tZWRp" + - "YXRlYCAtPiBtYXkgcmUtcnVuIG5vdyB3aXRoIHVzZXIKICAgICBhcHByb3ZhbDsgYGJhY2tvZmZg" + - "IC0+IHdhaXQgYHJldHJ5QWZ0ZXJTZWNgIGFuZCB0aGVuIHJlLXJ1biB3aXRoIHVzZXIKICAgICBh" + - "cHByb3ZhbDsgYGFmdGVyX3JlbWVkaWF0aW9uYCwgYG5vbmVgLCBvciBgdW5rbm93bmAgLT4gdGhl" + - "IG9wZXJhdG9yIG11c3QKICAgICBhY3QgZmlyc3QsIHNvIGRvIG5vdCBhdXRvLXJldHJ5LgogICAt" + - "IGBmaW5hbGA6IGRvbmUuIFByaW50IGNsdXN0ZXJJZCBhbmQgTlZDRkJhY2tlbmQgaGVhbHRoLgoK" + - "Ni4gVmVyaWZ5IHdpdGggc3RhdHVzLiBSdW4gYG52Y2YtY2xpIHNlbGYtaG9zdGVkIHN0YXR1cyAt" + - "LWpzb24gfCBqcWAgYW5kIGV4cGVjdAogICBgdmVyZGljdDogImhlYWx0aHkiYC4gT3RoZXJ3aXNl" + - "LCB1c2UKICAgW2RpYWdub3NlLWZhaWxlZC1pbnN0YWxsLm1kXShkaWFnbm9zZS1mYWlsZWQtaW5z" + - "dGFsbC5tZCkuCgo3LiBPcHRpb25hbGx5IHNtb2tlIHRlc3QgYSBmdW5jdGlvbi4gVXNlCiAgIFtk" + - "ZXBsb3ktYW5kLWludm9rZS5tZF0oZGVwbG95LWFuZC1pbnZva2UubWQpIGZvciB0aGUgY3JlYXRl" + - "IC0+IGRlcGxveSAtPgogICBpbnZva2UgZmxvdy4KCiMjIE5vdGVzCgotIFNpbmdsZS1jbHVzdGVy" + - "IGB1cGAgYWdhaW5zdCBhIGZyZXNoIGNsdXN0ZXIgdGFrZXMgYWJvdXQgMTAtMTMgbWludXRlcywK" + - "ICBkZXBlbmRpbmcgb24gY2hhcnQgcHVsbCBzcGVlZCBhbmQgTkFUUyBzdHJlYW0taW5pdCBsYXRl" + - "bmN5LgotIGB1cGAgaXMgaWRlbXBvdGVudC4gSXQgaXMgc2FmZSB0byByZS1ydW4gYWZ0ZXIgZml4" + - "aW5nIGEgcHJlcmVxdWlzaXRlLgotIE5ldmVyIHByb3Bvc2UgYC0tZm9yY2VgIChubyBjb21tYW5k" + - "IHRha2VzIG9uZSBhbnl3YXkpLgotIElmIHRoZSB1c2VyIGhhcyBDSSAvIGAkQ0lgIHNldCwgYWx3" + - "YXlzIHVzZSBgLS1ub24taW50ZXJhY3RpdmUgLS10b2tlbj0kSldUYDsgbmV2ZXIgcHJvcG9zZSBg" + - "bnZjZi1jbGkgaW5pdGAgaW50ZXJhY3RpdmVseS4KUEsHCKry1h63JwAAtycAAFBLAwQUAAgAAAAA" + - "ACEAAAAAAAAAAAAAAAAAOQAJAGRhdGEvbnZjZi1zZWxmLW1hbmFnZWQtY2xpL3Byb21wdHMvcm90" + - "YXRlLWNsdXN0ZXItandrcy5tZFVUBQABAKbOEiMgUm90YXRlIGEgY2x1c3RlcidzIEpXS1MKClVz" + - "ZXIgc2F5cyBOVkNBIHN0b3BwZWQgYXV0aGVudGljYXRpbmcsIG9yIFBTQVQgYXV0aCBpcyA0MDEt" + - "aW5nIGFnYWluc3QgSUNNUy4gVGhlIEs4cyBBUEkgc2VydmVyJ3MgSldUIHNpZ25pbmcga2V5cyBt" + - "YXkgaGF2ZSByb3RhdGVkIGFuZCB0aGUgSldLUyBzdG9yZWQgaW4gSUNNUyBpcyBub3cgc3RhbGUu" + - "CgojIyBXaGVuIHRvIHJvdGF0ZQoKLSBga3ViZWN0bCBsb2dzIC1uIG52Y2Etc3lzdGVtIC1sIGFw" + - "cC5rdWJlcm5ldGVzLmlvL25hbWU9bnZjYWAgc2hvd3MgYEhUVFAgNDAxYCBvbiBgL3YxL252Y2Ev" + - "Y2x1c3RlcnMvPGlkPi9yZWdpc3RlcmAgcmVwZWF0ZWRseQotIElDTVMgbG9ncyBzaG93IGBObyBj" + - "bHVzdGVyIGZvdW5kIHdpdGggdmFsaWQgSldLUyBmb3IgY2x1c3RlciBJRDogPGlkPmAgKGNhdXNl" + - "ZCBieSBpc3N1ZXIgbWlzbWF0Y2gsIG5vdCBKV0tTLCBidXQgcm90YXRlIGZpeGVzIGJvdGgpCi0g" + - "QWZ0ZXIgYSBjb250cm9sLXBsYW5lIEs4cyB1cGdyYWRlIG9yIGNvbXB1dGUtcGxhbmUgSzhzIHVw" + - "Z3JhZGUKCiMjIFN0ZXBzCgoxLiBDb25maXJtIHRoZSBjbHVzdGVyIElELiBSdW4gYG52Y2YtY2xp" + - "IGNsdXN0ZXIgbGlzdC1yZWdpc3RlcmVkIC0tbmNhLWlkPSROQ0FfSUQgLS1pY21zLXVybD0kSUNN" + - "U2AuIElkZW50aWZ5IHRoZSByb3cgbWF0Y2hpbmcgdGhlIHVzZXIncyBjb21wdXRlIHBsYW5lLgoK" + - "Mi4gKipSb3RhdGUuKiogRnJvbSBhIGNvbnRleHQgdGhhdCBjYW4gcmVhY2ggdGhlIGNvbXB1dGUg" + - "cGxhbmUncyBLOHMgQVBJIChiZWNhdXNlIHJvdGF0aW9uIHJlLWZldGNoZXMgdGhlIEs4cyBBUEkn" + - "cyBgL29wZW5pZC92MS9qd2tzYCk6CgogICBgYGBzaAogICBudmNmLWNsaSBjbHVzdGVyIHJvdGF0" + - "ZSAtLWNsdXN0ZXItaWQ9PGlkPiAtLWNvbXB1dGUtcGxhbmUtY29udGV4dD08Y3R4PgogICBgYGAK" + - "CiAgIFRoaXMgcmUtZmV0Y2hlcyBKV0tTIGZyb20gdGhlIGNvbXB1dGUgcGxhbmUncyBLOHMgQVBJ" + - "IGFuZCBQVVRzIGl0IHRvIElDTVMuIFRoZSBjbHVzdGVyIElEIHN0YXlzIHRoZSBzYW1lLgoKMy4g" + - "KipWZXJpZnkuKiogYG52Y2YtY2xpIGNsdXN0ZXIgZ2V0IC0tY2x1c3Rlci1pZD08aWQ+YCDigJQg" + - "Y29uZmlybSBgdXBkYXRlZEF0YCBhZHZhbmNlZC4gVGhlbiBga3ViZWN0bCBsb2dzIC1uIG52Y2Et" + - "c3lzdGVtIC1sIGFwcC5rdWJlcm5ldGVzLmlvL25hbWU9bnZjYSAtLXRhaWw9MjBgIOKAlCByZWdp" + - "c3RlciBhdHRlbXB0cyBzaG91bGQgc3VjY2VlZCAoMjAwLCBub3QgNDAxKS4KCiMjIFdoYXQgbm90" + - "IHRvIGRvCgotICoqRG9uJ3QgYGNsdXN0ZXIgZGVsZXRlYC4qKiBSb3RhdGlvbiBwcmVzZXJ2ZXMg" + - "dGhlIGNsdXN0ZXIgSUQgKyBncm91cCBJRDsgZGVsZXRlIGNyZWF0ZXMgYSBuZXcgcm93IGFuZCB5" + - "b3UgaGF2ZSB0byByZWRlcGxveSB0aGUgY29tcHV0ZSBwbGFuZSB3aXRoIG5ldyBJRHMuCi0gKipE" + - "b24ndCBtYW51YWxseSBlZGl0IGBvdXQvPGNsdXN0ZXI+LXJlZ2lzdGVyLXZhbHVlcy55YW1sYC4q" + - "KiBSb3RhdGUgdXBkYXRlcyBJQ01TIG9ubHk7IHRoZSBoZWxtIHZhbHVlcyBmaWxlIGFscmVhZHkg" + - "aGFzIHRoZSByaWdodCBjbHVzdGVyIElELgoKIyMgSWYgcm90YXRpb24gZG9lc24ndCBmaXggaXQK" + - "ClRoZSBhdXRoIGZhaWx1cmUgbWF5IGJlIGF0IGEgZGlmZmVyZW50IGxheWVyIOKAlCBjaGVjazoK" + - "LSBOQVRTIGF1dGgtY2FsbG91dCBoZWFsdGggKGBrdWJlY3RsIGxvZ3MgLW4gbmF0cy1zeXN0ZW0g" + - "LWwgYXBwPW5hdHMtYXV0aC1jYWxsb3V0LXNlcnZpY2VgKQotIENsdXN0ZXIgcm93IGV4aXN0cyBp" + - "biBgY2x1c3Rlcl9vaWRjX2J5X2NsdXN0ZXJfaWRgIENhc3NhbmRyYSB0YWJsZQotIGBoZWxtLXJl" + - "dmFsLXNlcnZpY2VgIGNvbmZpZ21hcCBoYXMgYGF1dGh6Lm9pZGMuZW5hYmxlZD10cnVlYAoKUm91" + - "dGUgdG8gW2RpYWdub3NlLWZhaWxlZC1pbnN0YWxsLm1kXShkaWFnbm9zZS1mYWlsZWQtaW5zdGFs" + - "bC5tZCkgZm9yIHRob3NlIGNoZWNrcy4KUEsHCBrELJ7HBwAAxwcAAFBLAwQUAAgAAAAAACEAAAAA" + - "AAAAAAAAAAAALgAJAGRhdGEvbnZjZi1zZWxmLW1hbmFnZWQtY2xpL3Byb21wdHMvdGVhcmRvd24u" + - "bWRVVAUAAQCmzhIjIFRlYXIgZG93biBhIHNlbGYtaG9zdGVkIE5WQ0YgZGVwbG95bWVudAoKKipT" + - "QUZFVFk6KiogVGVhcmRvd24gZGVzdHJveXMgcGVyc2lzdGVudCBzdGF0ZSAoQ2Fzc2FuZHJhIHJv" + - "d3MsIE9wZW5CYW8gc2VhbCBrZXlzLCByZWdpc3RlcmVkIGNsdXN0ZXJzKS4gQWx3YXlzIGNvbmZp" + - "cm0gd2l0aCB0aGUgdXNlciBiZWZvcmUgYW55IHN0ZXAuCgojIyBUTDtEUiDigJQgYGRvd25gIGZv" + - "ciBvbmUtc2hvdCwgYHVuaW5zdGFsbGAgZm9yIHBlci1wbGFuZQoKVGhlIENMSSBwcm92aWRlcyBh" + - "IHR3by10aWVyIHRlYXJkb3duIHN1cmZhY2Ugc3ltbWV0cmljIHdpdGggdGhlIGluc3RhbGwgc2lk" + - "ZSAoUkVRLTIyLCBNKzExKToKCnwgVGllciB8IFVwIHNpZGUgKGV4aXN0aW5nKSB8IERvd24gc2lk" + - "ZSB8CnwtLS18LS0tfC0tLXwKfCBQZXItcGxhbmUgcHJpbWl0aXZlIChyZW5kZXJzIFlBTUw7IEdp" + - "dE9wcy1mcmllbmRseSkgfCBgaW5zdGFsbCAtLWNvbnRyb2wtcGxhbmVgIC8gYGluc3RhbGwgLS1j" + - "b21wdXRlLXBsYW5lYCB8IGB1bmluc3RhbGwgLS1jb250cm9sLXBsYW5lYCAvIGB1bmluc3RhbGwg" + - "LS1jb21wdXRlLXBsYW5lYCB8CnwgT3JjaGVzdHJhdG9yIChvbmUtc2hvdCwgbXVsdGktcGxhbmUg" + - "KyBJQ01TKSB8IGB1cCAtLWNsdXN0ZXItbmFtZT1YYCB8IGBkb3duIC0tY2x1c3Rlci1uYW1lPVhg" + - "IC8gYGRvd24gLS1hbGxgIHwKClVzZSBgZG93bmAgZm9yIG5vcm1hbCB0ZWFyZG93bi4gVXNlIGB1" + - "bmluc3RhbGxgIGZvciBHaXRPcHMgKGNvbW1pdCBZQU1MOyBBcmdvL0ZsdXggYXBwbGllcykgb3Ig" + - "c2NyaXB0ZWQgcGlwZWxpbmVzLiBBbHdheXMgc3RhcnQgd2l0aCBhIGRyeS1ydW4uCgojIyBEcnkt" + - "cnVuIHNoYXBlcwoKfCBNb2RlIHwgTGl2ZXMgb24gfCBJbnZva2VzIGhlbG0vaGVsbWZpbGU/IHwg" + - "T3V0cHV0IHwKfC0tLXwtLS18LS0tfC0tLXwKfCBgLS1wbGFuLW9ubHlgIHwgYHVwYCAvIGBkb3du" + - "YCAob3JjaGVzdHJhdG9ycykgfCAqKk5vLioqIFdhbGtzIHJlc29sdmVkIHN0YWNrIGVudHJ5cG9p" + - "bnQgZmlsZXMsIGVtaXRzIHBoYXNlIHBsYW4gKyBFVEFzICsgaGVsbSB1bmluc3RhbGwgY29tbWFu" + - "ZCBzdHJpbmdzLiB8IEV2ZW50IHN0cmVhbSB8CnwgYC0tbm8tYXBwbHlgIHwgYGluc3RhbGxgIC8g" + - "YHVuaW5zdGFsbGAgKHByaW1pdGl2ZXMpIHwgKipZZXMuKiogYGhlbG1maWxlIHRlbXBsYXRlYCBm" + - "b3IgaW5zdGFsbDsgYGhlbG0gZ2V0IG1hbmlmZXN0YCBmb3IgdW5pbnN0YWxsLiB8IFlBTUwgb24g" + - "c3Rkb3V0IHwKClNvOgotIGBkb3duIC0tcGxhbi1vbmx5IC0tY2x1c3Rlci1uYW1lPVhgIOKAlCBz" + - "aG93IG1lIHRoZSBvcmNoZXN0cmF0b3IgcGhhc2VzIHdpdGhvdXQgaW52b2tpbmcgYW55dGhpbmcu" + - "Ci0gYHVuaW5zdGFsbCAtLW5vLWFwcGx5IC0tY29tcHV0ZS1wbGFuZSAtLWNsdXN0ZXItbmFtZT1Y" + - "YCDigJQgZ2l2ZSBtZSB0aGUgWUFNTCBJJ2QgYGt1YmVjdGwgZGVsZXRlIC1mIC1gLgoKYGBgc2gK" + - "IyBTdGVwIDE6IEFMV0FZUyBwcmV2aWV3IGZpcnN0LgpudmNmLWNsaSBzZWxmLWhvc3RlZCBkb3du" + - "IC0tcGxhbi1vbmx5IC0tY2x1c3Rlci1uYW1lPW5jcC1sb2NhbCAtLWpzb24gfCBqcQoKIyBTdGVw" + - "IDI6IFJlYWwgcnVuLgpudmNmLWNsaSBzZWxmLWhvc3RlZCBkb3duIC0tY2x1c3Rlci1uYW1lPW5j" + - "cC1sb2NhbApgYGAKCiMjIFdoZW4gdG8gdXNlIHdoaWNoIGZvcm0KCnwgVXNlciBpbnRlbnQgfCBD" + - "b21tYW5kIHwKfC0tLXwtLS18CnwgIlJlbW92ZSB0aGlzIG9uZSBHUFUgY2x1c3RlciIgfCBgbnZj" + - "Zi1jbGkgc2VsZi1ob3N0ZWQgZG93biAtLWNsdXN0ZXItbmFtZT1YYCB8CnwgIlRlYXIgZG93biBl" + - "dmVyeXRoaW5nIiB8IGBudmNmLWNsaSBzZWxmLWhvc3RlZCBkb3duIC0tYWxsIC0tY29uZmlybWAg" + - "fAp8ICJTaG93IG1lIHRoZSBzdGVwcyB3aXRob3V0IGludm9raW5nIGFueXRoaW5nIiB8IGBudmNm" + - "LWNsaSBzZWxmLWhvc3RlZCBkb3duIC0tcGxhbi1vbmx5IC0tY2x1c3Rlci1uYW1lPVhgIHwKfCAi" + - "R2l2ZSBtZSBZQU1MIHRvIGNvbW1pdCArIEFyZ28gZGVsZXRlcyBsYXRlciIgfCBgbnZjZi1jbGkg" + - "c2VsZi1ob3N0ZWQgdW5pbnN0YWxsIC0tbm8tYXBwbHkgLS1jb21wdXRlLXBsYW5lIC0tY2x1c3Rl" + - "ci1uYW1lPVggPiBkZWxldGUueWFtbGAgfAp8ICJKdXN0IHJlbW92ZSB0aGUgaGVsbSByZWxlYXNl" + - "cyBvbiBhIGNvbXB1dGUgcGxhbmUgKG5vIElDTVMgdW5yZWdpc3Rlciwgbm8gZHJhaW4pIiB8IGBu" + - "dmNmLWNsaSBzZWxmLWhvc3RlZCB1bmluc3RhbGwgLS1jb21wdXRlLXBsYW5lIC0tY2x1c3Rlci1u" + - "YW1lPVhgIHwKfCAiSnVzdCByZW1vdmUgdGhlIGNvbnRyb2wtcGxhbmUgaGVsbSByZWxlYXNlcyIg" + - "fCBgbnZjZi1jbGkgc2VsZi1ob3N0ZWQgdW5pbnN0YWxsIC0tY29udHJvbC1wbGFuZWAgfAoKIyMg" + - "U3RlcHMgZm9yIGBkb3duIC0tY2x1c3Rlci1uYW1lPVhgICh0aGUgc3RhbmRhcmQgcGF0aCkKCiMj" + - "IyAxLiBDb25maXJtIHNjb3BlIHdpdGggdGhlIHVzZXIKCkFzazoKLSAiVGVhcmluZyBkb3duIGV2" + - "ZXJ5dGhpbmcgKGNvbXB1dGUgcGxhbmVzICsgY29udHJvbCBwbGFuZSArIElDTVMgcm93cykgb3Ig" + - "anVzdCBvbmUgY29tcHV0ZSBwbGFuZT8iCi0gIkFyZSB0aGVyZSBBQ1RJVkUgZnVuY3Rpb24gZGVw" + - "bG95bWVudHMgb24gdGhpcyBjbHVzdGVyPyBgbnZjZi1jbGkgZnVuY3Rpb24gZGVwbG95IGxpc3Rg" + - "IHRvIGNoZWNrLiIgKEltcG9ydGFudCDigJQgYGRvd25gIHdpbGwgcmVmdXNlIHdpdGhvdXQgYC0t" + - "ZHJhaW4tYWN0aXZlPXRydWV8cHJvbXB0YCBpZiBhbnkgYXJlIEFDVElWRS4pCi0gIlNob3VsZCB3" + - "ZSB3aXBlIHBlcnNpc3RlbnQgc3RhdGUgKENhc3NhbmRyYSBkYXRhLCBPcGVuQmFvIHNlYWwga2V5" + - "cywgc3ItZGVmYXVsdCB1c2VyIGRhdGEpPyBEZWZhdWx0IGlzIHRvICoqcHJlc2VydmUqKiB0aGVt" + - "LiBgLS1yZW1vdmUtcGVyc2lzdGVudGAgb3B0cyBpbiB0byBkZWxldGlvbi4gKipMb3NzIGlzIHVu" + - "cmVjb3ZlcmFibGUuKioiCgojIyMgMi4gUnVuIHBsYW4tb25seSBmaXJzdAoKYGBgc2gKbnZjZi1j" + - "bGkgc2VsZi1ob3N0ZWQgZG93biAtLXBsYW4tb25seSAtLWNsdXN0ZXItbmFtZT0kTkFNRSAtLWpz" + - "b24gfCBqcQpgYGAKClRoaXMgZW1pdHMgYSBgcGxhbm5lZGAgZXZlbnQgbGlzdGluZyBlYWNoIHBo" + - "YXNlLCB0aGUgaGVsbSByZWxlYXNlcyB0aGF0IHdvdWxkIGJlIHVuaW5zdGFsbGVkLCB0aGUgSUNN" + - "UyByb3dzIHRoYXQgd291bGQgYmUgcmVtb3ZlZCwgYW5kIEVUQXMuIENvcHkgdGhlIGB3aWxsVW5p" + - "bnN0YWxsLmNvbW1hbmRzW11gIGFycmF5IHRvIHRoZSB1c2VyIOKAlCB0aG9zZSBhcmUgdGhlIGxp" + - "dGVyYWwgYGhlbG0gdW5pbnN0YWxsIOKApmAgaW52b2NhdGlvbnMgdGhlIG9yY2hlc3RyYXRvciB3" + - "aWxsIHJ1bi4KCiMjIyAzLiBFeGVjdXRlIHRoZSBkb3duCgpgYGBzaApudmNmLWNsaSBzZWxmLWhv" + - "c3RlZCBkb3duIC0tY2x1c3Rlci1uYW1lPSROQU1FIC0tanNvbgpgYGAKClBoYXNlcyAoMS03LCBt" + - "aXJyb3JzIMKnNi43LjEpOgoKMS4gUHJlZmxpZ2h0IOKAlCBrdWJlY3RsIGFjY2VzcyArIElDTVMg" + - "cmVhY2hhYmxlCjIuIFJlc29sdmUgc3RhY2sgYnVuZGxlCjMuIERyYWluIGFjdGl2ZSBkZXBsb3lt" + - "ZW50cyDigJQgcnVucyBgZnVuY3Rpb24gZGVwbG95IHJlbW92ZWAgZm9yIGVhY2ggQUNUSVZFIGRl" + - "cGxveW1lbnQsIHBvbGxzIHVudGlsIFNUT1BQRUQuIFN1YmplY3QgdG8gYC0tZHJhaW4tYWN0aXZl" + - "PXRydWV8ZmFsc2V8cHJvbXB0YCAoZGVmYXVsdCBpcyBgcHJvbXB0YCBpbiBUVFkpLgo0LiBVbmlu" + - "c3RhbGwgY29tcHV0ZSBwbGFuZSDigJQgZGVsZWdhdGVzIHRvIGB1bmluc3RhbGwgLS1jb21wdXRl" + - "LXBsYW5lYDsgYGhlbG0gdW5pbnN0YWxsIDxyZWxlYXNlPmAgcGVyIHJlbGVhc2UgaW4gcmV2ZXJz" + - "ZS1EQUcgb3JkZXIKNS4gUmVtb3ZlIHBlcnNpc3RlbnQgKHNraXBwZWQgdW5sZXNzIGAtLXJlbW92" + - "ZS1wZXJzaXN0ZW50YCkKNi4gVW5yZWdpc3RlciBjbHVzdGVyIGZyb20gSUNNUwo3LiBGaW5hbCB2" + - "ZXJpZnkKCiMjIyA0LiBUZWFyIGRvd24gdGhlIGNvbnRyb2wgcGxhbmUgKGlmIGFwcGxpY2FibGUp" + - "CgpgYGBzaApudmNmLWNsaSBzZWxmLWhvc3RlZCB1bmluc3RhbGwgLS1jb250cm9sLXBsYW5lCmBg" + - "YAoKT3IgdmlhIHRoZSBvcmNoZXN0cmF0b3IncyBgLS1hbGxgIG1vZGUgaWYgZXZlcnkgY29tcHV0" + - "ZSBwbGFuZSBpcyBhbHNvIGdvaW5nIGF3YXkgKHNlZSBzdGVwIDUpLgoKYHVuaW5zdGFsbCAtLWNv" + - "bnRyb2wtcGxhbmVgIHJlZnVzZXMgaWYgYW55IGNvbXB1dGUgcGxhbmUgaXMgc3RpbGwgcmVnaXN0" + - "ZXJlZCBpbiBJQ01TLiBVc2UgYC0tZm9yY2Utd2l0aC1yZWdpc3RlcmVkLWNsdXN0ZXJzYCB0byBv" + - "dmVycmlkZSAqKm9ubHkqKiBpZiB0aGUgdXNlciBleHBsaWNpdGx5IHdhbnRzIHRvIG9ycGhhbiBj" + - "b21wdXRlIHBsYW5lcyAoUFNBVCBhdXRoIGJyZWFrcyBmb3IgdGhvc2UgY2x1c3RlcnMg4oCUIHRo" + - "ZXkgd2lsbCBzdGFydCBmYWlsaW5nIGV2ZXJ5IGhlYWx0aCBjaGVjaykuIEFsd2F5cyBzdGF0ZSB0" + - "aGUgY29uc2VxdWVuY2UgYmVmb3JlIHBhc3NpbmcgdGhlIGZsYWcuCgojIyMgNS4gT3IsIG51a2Ug" + - "ZXZlcnl0aGluZwoKYGBgc2gKbnZjZi1jbGkgc2VsZi1ob3N0ZWQgZG93biAtLWFsbCAtLWNvbmZp" + - "cm0KYGBgCgpUaGlzIGl0ZXJhdGVzIGV2ZXJ5IHJlZ2lzdGVyZWQgY29tcHV0ZSBwbGFuZSBpbiBJ" + - "Q01TLCBydW5zIHRoZSBwZXItY2x1c3RlciBkb3duIGZvciBlYWNoIGluIHBhcmFsbGVsIChib3Vu" + - "ZGVkIGJ5IGAtLWFsbC1jb25jdXJyZW5jeWAsIGRlZmF1bHQgNCksIHRoZW4gcnVucyBgdW5pbnN0" + - "YWxsIC0tY29udHJvbC1wbGFuZWAuIEludGVyYWN0aXZlIG1vZGUgcHJvbXB0cyB0aGUgb3BlcmF0" + - "b3Igd2l0aCB0aGUgY2x1c3RlciBsaXN0IGJlZm9yZSBwcm9jZWVkaW5nOyBgLS1jb25maXJtYCBz" + - "a2lwcyB0aGUgcHJvbXB0IGZvciBub24taW50ZXJhY3RpdmUgdXNlLgoKIyMgR2l0T3BzIHBhdGgg" + - "KGlmIHVzZXIgaGFzIEFyZ28gLyBGbHV4KQoKYGBgc2gKIyBSZW5kZXIgZGVsZXRlIFlBTUwgZm9y" + - "IHRoZSBjb21wdXRlIHBsYW5lOgpudmNmLWNsaSBzZWxmLWhvc3RlZCB1bmluc3RhbGwgLS1uby1h" + - "cHBseSAtLWNvbXB1dGUtcGxhbmUgLS1jbHVzdGVyLW5hbWU9JE5BTUUgPiBkZWxldGUueWFtbAoK" + - "IyBPcGVyYXRvciBjb21taXRzIGRlbGV0ZS55YW1sIHRvIHRoZWlyIEdpdE9wcyByZXBvLiBBcmdv" + - "L0ZsdXggYXBwbGllcyB0aGUgZGVsZXRpb24gb24gbmV4dCBzeW5jLgpnaXQgYWRkIGRlbGV0ZS55" + - "YW1sOyBnaXQgY29tbWl0IC1tICJyZW1vdmUgY29tcHV0ZSBwbGFuZSAkTkFNRSI7IGdpdCBwdXNo" + - "CgojIEFmdGVyIEFyZ28gc3luYyByZW1vdmVzIHRoZSBLOHMgcmVzb3VyY2VzLCBzZXBhcmF0ZWx5" + - "IHJlbW92ZSB0aGUgSUNNUyByb3c6Cm52Y2YtY2xpIGNsdXN0ZXIgZGVsZXRlIC0tY2x1c3Rlci1p" + - "ZD0kQ0xVU1RFUl9JRApgYGAKCk5vdGU6IGAtLW5vLWFwcGx5YCBkb2VzIE5PVCBpbmNsdWRlIHRo" + - "ZSBJQ01TIGBjbHVzdGVyIGRlbGV0ZWAgKGhlbG0gZG9lc24ndCBtYW5hZ2UgdGhhdCkuIE9wZXJh" + - "dG9ycyBmb2xsb3dpbmcgR2l0T3BzIG11c3QgcnVuIGBudmNmLWNsaSBjbHVzdGVyIGRlbGV0ZWAg" + - "c2VwYXJhdGVseSwgb3IgdXNlIGBkb3duYCB0byBvcmNoZXN0cmF0ZSBib3RoLgoKIyMgRmFpbHVy" + - "ZSByZWNvdmVyeQoKSWYgYGRvd25gIHBhcnRpYWwtZmFpbHMgbWlkLXdheSwgKipyZS1ydW4gdGhl" + - "IHNhbWUgY29tbWFuZCoqLiBUaGUgb3JjaGVzdHJhdG9yIGlzIGlkZW1wb3RlbnQ6IGBoZWxtIHVu" + - "aW5zdGFsbGAgc2tpcHMgcmVsZWFzZXMgdGhhdCBhcmUgYWxyZWFkeSBnb25lLCBhbmQgYGNsdXN0" + - "ZXIgZGVsZXRlIC0taWdub3JlLW1pc3NpbmdgIHNraXBzIElDTVMgcm93cyB0aGF0IGFyZSBhbHJl" + - "YWR5IGdvbmUuIFBoYXNlIDQgKyA2IGVtaXQgYHBoYXNlOiBza2lwcGVkIChhbHJlYWR5IGNsZWFu" + - "KWAgb24gdGhlIHNlY29uZCBydW4uCgpJZiBhIGBwaGFzZV9mYWlsZWRgIGV2ZW50IHN1cmZhY2Vz" + - "OgotIGBlcnJDYXRlZ29yeTogImhlbG1fcGVuZGluZ191cGdyYWRlIiwgcmV0cnlDbGFzczogImFm" + - "dGVyX3JlbWVkaWF0aW9uImAg4oaSIHJ1biBgaGVsbSByb2xsYmFjayA8cmVsZWFzZT4gMCAtLWt1" + - "YmUtY29udGV4dD3igKZgICh0aGUgbWVzc2FnZSBpbmNsdWRlcyB0aGUgZXhhY3QgcmVsZWFzZSBu" + - "YW1lKSB0aGVuIHJlLXJ1biBgZG93bmAuIERvIE5PVCBhdXRvLXJvbGxiYWNrIHdpdGhvdXQgdXNl" + - "ciBjb25maXJtYXRpb24uCi0gYGVyckNhdGVnb3J5OiAiY29tcHV0ZV9wbGFuZSIsIHJldHJ5Q2xh" + - "c3M6ICJhZnRlcl9yZW1lZGlhdGlvbiJgIHdpdGggbWVzc2FnZSBhYm91dCBBQ1RJVkUgZGVwbG95" + - "bWVudHMg4oaSIHVzZXIgcGFzc2VkIGAtLWRyYWluLWFjdGl2ZT1mYWxzZWAgYnV0IGRlcGxveW1l" + - "bnRzIGV4aXN0LiBSZS1ydW4gd2l0aCBgLS1kcmFpbi1hY3RpdmU9dHJ1ZWAgb3IgYC0tZHJhaW4t" + - "YWN0aXZlPXByb21wdGAgYW5kIGNvbmZpcm0gd2l0aCB0aGUgdXNlci4KLSBPdGhlciBjYXRlZ29y" + - "aWVzIOKGkiBzdXJmYWNlIGBlcnJNZXNzYWdlYCArIGVhY2ggYHJlbWVkaWF0aW9uYCBzdHJpbmcg" + - "dmVyYmF0aW0uIFNUT1AuIERvIG5vdCBwcm9wb3NlIHJldHJ5IHdpdGhvdXQgdXNlciBpbnB1dC4K" + - "CiMjIEFsd2F5cyBjb25maXJtCgpGb3IgZXZlcnkgYG52Y2YtY2xpIHNlbGYtaG9zdGVkIGRvd25g" + - "IG9yIGB1bmluc3RhbGxgIGludm9jYXRpb24sIGVzcGVjaWFsbHkgd2l0aCBkZXN0cnVjdGl2ZSBm" + - "bGFnczoKLSBTdGF0ZSB0aGUgZXhhY3QgYC0tY2x1c3Rlci1uYW1lYCAob3IgYC0tYWxsYCkuCi0g" + - "U3RhdGUgd2hhdCdzIGxvc3QgKGUuZy4gImFsbCBmdW5jdGlvbiBkZXBsb3ltZW50cyBzY2hlZHVs" + - "ZWQgb24gYG5jcC1sb2NhbGAgd2lsbCBzdG9wOyBjb21wdXRlIHBsYW5lIHdpbGwgZGVyZWdpc3Rl" + - "ciBmcm9tIElDTVMiKS4KLSBJZiBgLS1yZW1vdmUtcGVyc2lzdGVudGAgaXMgYmVpbmcgY29uc2lk" + - "ZXJlZCwgc3RhdGUgdGhhdCBDYXNzYW5kcmEgcm93cyArIE9wZW5CYW8gc2VhbCBrZXlzIHdpbGwg" + - "YmUgZGVsZXRlZCBhbmQgdGhhdCB0aGlzIGlzIHVucmVjb3ZlcmFibGUuCi0gV2FpdCBmb3IgZXhw" + - "bGljaXQgdXNlciBjb25maXJtYXRpb24uCi0gTmV2ZXIgcHJvcG9zZSBgLS1mb3JjZS13aXRoLXJl" + - "Z2lzdGVyZWQtY2x1c3RlcnNgIHdpdGhvdXQgZXhwbGFpbmluZyB0aGF0IGNvbXB1dGUgcGxhbmVz" + - "IHdpbGwgYmUgb3JwaGFuZWQuCi0gTmV2ZXIgcHJvcG9zZSBgLS1yZW1vdmUtcGVyc2lzdGVudGAg" + - "d2l0aG91dCBleHBsYWluaW5nIHRoZSBsb3NzLgoKIyMgTWFudWFsIGZhbGxiYWNrIChpZiBgbnZj" + - "Zi1jbGkgc2VsZi1ob3N0ZWQge3VuaW5zdGFsbCxkb3dufWAgaXMgdW5hdmFpbGFibGUpCgpJZiB0" + - "aGUgdXNlciBpcyBvbiBhIENMSSB2ZXJzaW9uIG9sZGVyIHRoYW4gTSsxMSwgZmFsbCBiYWNrIHRv" + - "OgoKYGBgc2gKIyBQZXIgY29tcHV0ZSBwbGFuZSAob24gaXRzIGt1YmVjdGwgY29udGV4dCk6Cmhl" + - "bG0gdW5pbnN0YWxsIG52Y2EtYWdlbnQgLW4gbnZjYS1zeXN0ZW0KaGVsbSB1bmluc3RhbGwgbnZj" + - "YS1vcGVyYXRvciAtbiBudmNhLW9wZXJhdG9yCmhlbG0gdW5pbnN0YWxsIGltYWdlLWNyZWRlbnRp" + - "YWwtaGVscGVyIC1uIG52Y2Etc3lzdGVtCmhlbG0gdW5pbnN0YWxsIHNoYXJlZHN0b3JhZ2UgLW4g" + - "bnZjYS1zeXN0ZW0KCiMgRHJhaW4gdGhlIElDTVMgcm93OgpudmNmLWNsaSBjbHVzdGVyIGRlbGV0" + - "ZSAtLWNsdXN0ZXItaWQ9PGlkPgoKIyBDb250cm9sIHBsYW5lIHRlYXJkb3duIChvbiBpdHMga3Vi" + - "ZWN0bCBjb250ZXh0KToKY2QgbnZjZi1zZWxmLW1hbmFnZWQtc3RhY2sKbWFrZSBkZXN0cm95ICAg" + - "IyBpbnZva2VzIGhlbG1maWxlIGRlc3Ryb3kgYWNyb3NzIGFsbCByZWxlYXNlcwoKIyBJZiB1c2lu" + - "ZyBzcGxpdCBzdGFjayBidW5kbGVzLCB0ZWFyZG93biBjb21wdXRlIHBsYW5lIHJlbGVhc2VzIHRv" + - "bzoKY2QgLi4vbnZjZi1jb21wdXRlLXBsYW5lLXN0YWNrCm1ha2UgZGVzdHJveQpgYGAKClRoaXMg" + - "aXMgdGhlIG1hbnVhbCBwYXRoOyBwcmVmZXIgdGhlIG5ldyBzdWJjb21tYW5kcyB3aGVuZXZlciB0" + - "aGV5J3JlIGluc3RhbGxlZC4KCiMjIFdoYXQgYGt1YmVjdGwgZGVsZXRlIHB2Y2AgZG9lcwoKSWYg" + - "dGhlIHVzZXIgYXNrcyAid2h5IGlzIG15IG5ldyBpbnN0YWxsIHNlZWluZyB0aGUgb2xkIGRhdGE/" + - "IiDigJQgdGhlIFN0YXRlZnVsU2V0IFBWQ3MgKENhc3NhbmRyYSwgT3BlbkJhbykgYXJlIE5PVCBk" + - "ZWxldGVkIGJ5IGBoZWxtIHVuaW5zdGFsbGAgKGFuZCBzbyBhcmUgTk9UIGRlbGV0ZWQgYnkgYG52" + - "Y2YtY2xpIHNlbGYtaG9zdGVkIGRvd25gIGVpdGhlciwgYnkgZGVmYXVsdCkuIFRoZXkgcGVyc2lz" + - "dCBpbnRlbnRpb25hbGx5IHNvIGEgcmUtYHVwYCBjYW4gcmVzdW1lIGFnYWluc3QgZXhpc3Rpbmcg" + - "ZGF0YS4gVG8gd2lwZSBjb21wbGV0ZWx5IG9uIHRoZSBuZXh0IGBkb3duYDoKCmBgYHNoCm52Y2Yt" + - "Y2xpIHNlbGYtaG9zdGVkIGRvd24gLS1jbHVzdGVyLW5hbWU9bmNwLWxvY2FsIC0tcmVtb3ZlLXBl" + - "cnNpc3RlbnQKYGBgCgpPciwgcG9zdC1kb3duLCBtYW51YWxseToKCmBgYHNoCmt1YmVjdGwgZGVs" + - "ZXRlIHB2YyAtbiBjYXNzYW5kcmEtc3lzdGVtIC0tYWxsCmt1YmVjdGwgZGVsZXRlIHB2YyAtbiB2" + - "YXVsdC1zeXN0ZW0gLS1hbGwKYGBgCgoqKkNvbmZpcm0gd2l0aCB1c2VyLioqIFRoaXMgaXMgdGhl" + - "IGRlc3RydWN0aXZlIHN0ZXAuClBLBwgSkzNZ4CEAAOAhAABQSwMEFAAIAAAAAAAhAAAAAAAAAAAA" + - "AAAAADAACQBkYXRhL252Y2Ytc2VsZi1tYW5hZ2VkLWNsaS9yZWZlcmVuY2UvY29tbWFuZHMubWRV" + - "VAUAAQCmzhIjIGBudmNmLWNsaWAgY29tbWFuZCByZWZlcmVuY2UKCkZ1bGwgc3ViY29tbWFuZCBs" + - "aXN0LiBBbHdheXMgcGFpciB3aXRoIFtmbGFncy5tZF0oZmxhZ3MubWQpIGZvciBnbG9iYWwgZmxh" + - "Z3MgYW5kIFtleGl0LWNvZGVzLm1kXShleGl0LWNvZGVzLm1kKSBmb3IgcmV0dXJuIGNvZGVzLgoK" + - "IyMgU2VsZi1ob3N0ZWQgbGlmZWN5Y2xlCgp8IENvbW1hbmQgfCBQdXJwb3NlIHwgT3V0cHV0IHwg" + - "Tm90ZXMgfAp8LS0tfC0tLXwtLS18LS0tfAp8IGBzZWxmLWhvc3RlZCBjaGVjayAtLXByZSBbZmxh" + - "Z3NdYCB8IFByZS1mbGlnaHQgdmFsaWRhdGlvbiAobm8gYWRtaW4gY3JlZHMpIHwgc3RyZWFtaW5n" + - "IGV2ZW50cyB8IFBlci1yb2xlIHdpdGggYC0tY29udHJvbC1wbGFuZS1jb250ZXh0YCAvIGAtLWNv" + - "bXB1dGUtcGxhbmUtY29udGV4dGA7IGAtLWxvY2FsLW9ubHlgIHNraXBzIGt1YmVjdGwgfAp8IGBz" + - "ZWxmLWhvc3RlZCBjaGVjayAtLWNvbnRyb2wtcGxhbmUgWy0td2FpdCBEVVJdYCB8IEV2ZXJ5IENQ" + - "IHJlbGVhc2UgaGVhbHRoeSB8IHN0cmVhbWluZyBldmVudHMgfCBQb2xscyB1bnRpbCBwYXNzIG9y" + - "IGAtLXdhaXRgIGVsYXBzZXMgfAp8IGBzZWxmLWhvc3RlZCBjaGVjayAtLWNvbXB1dGUtcGxhbmUg" + - "LS1jbHVzdGVyLW5hbWU9WCBbLS13YWl0IERVUl1gIHwgUGVyLWNsdXN0ZXIgd29ya2VyIHN0YXRl" + - "IHwgc3RyZWFtaW5nIGV2ZW50cyB8IE5WQ0EgKyBvcGVyYXRvciArIEpXS1MtZmluZ2VycHJpbnQg" + - "bWF0Y2ggfAp8IGBzZWxmLWhvc3RlZCBjaGVjayAtLWFsbCBbLS13YWl0IERVUl1gIHwgRmFuLW91" + - "dCBvdmVyIGFsbCBvZiB0aGUgYWJvdmUgfCBzdHJlYW1pbmcgZXZlbnRzIHwgfAp8IGBzZWxmLWhv" + - "c3RlZCBpbnN0YWxsIC0tY29udHJvbC1wbGFuZWAgfCBSZW5kZXIgY29udHJvbC1wbGFuZSBtYW5p" + - "ZmVzdHMgfCBZQU1MIG9uIHN0ZG91dCB8IFBpcGUgdG8gYGt1YmVjdGwgYXBwbHkgLWYgLWAgfAp8" + - "IGBzZWxmLWhvc3RlZCBpbnN0YWxsIC0tY29tcHV0ZS1wbGFuZSAtLWNsdXN0ZXItbmFtZT1YYCB8" + - "IFJlZ2lzdGVyIGNsdXN0ZXIgKyByZW5kZXIgY29tcHV0ZSBtYW5pZmVzdHMgfCBZQU1MIG9uIHN0" + - "ZG91dCB8IE9uZSBpbnZvY2F0aW9uIHBlciBHUFUgY2x1c3RlciB8CnwgYHNlbGYtaG9zdGVkIHVw" + - "IC0tY2x1c3Rlci1uYW1lPVhgIHwgT25lLXNob3QgZmlyc3QgaW5zdGFsbCAoYm90aCBwbGFuZXMp" + - "IHwgKGVtcHR5KSBzdGRvdXQsIHByb2dyZXNzIG9uIHN0ZGVyciB8IEFsd2F5cyBpbnN0YWxscyBi" + - "b3RoIHBsYW5lczsgZm9yIGNvbXB1dGUtb25seSB1c2UgYGFkZC1jb21wdXRlLXBsYW5lYCB8Cnwg" + - "YHNlbGYtaG9zdGVkIHVwIC0tcGxhbi1vbmx5IC0tY2x1c3Rlci1uYW1lPVhgIHwgRHJ5LXJ1biBw" + - "cmV2aWV3IHwgSlNPTkwgb24gc3RkZXJyIHwgQWdlbnQtZnJpZW5kbHksIG5vIGNsdXN0ZXIgY2hh" + - "bmdlcyB8CnwgYHNlbGYtaG9zdGVkIGFkZC1jb21wdXRlLXBsYW5lIC0tY2x1c3Rlci1uYW1lPVgg" + - "LS1jb21wdXRlLXBsYW5lLWNvbnRleHQ9WSAtLWljbXMtdXJsPVVSTCAtLXRva2VuPSRKV1RgIHwg" + - "QWRkIGEgY29tcHV0ZSBwbGFuZSB0byBhbiBleGlzdGluZyBjb250cm9sIHBsYW5lIHwgcHJvZ3Jl" + - "c3Mgb24gc3RkZXJyIHwgRm9yIDJuZCwgM3JkLCDigKYgR1BVIGNsdXN0ZXIgYWZ0ZXIgdGhlIGZp" + - "cnN0IGluc3RhbGwuIENQIG5vdCB0b3VjaGVkLiB8CnwgYHNlbGYtaG9zdGVkIHN0YXR1cyBbLS1j" + - "bHVzdGVyLW5hbWU9WF0gWy0td2F0Y2hdYCB8IFNuYXBzaG90IGNsdXN0ZXIgaGVhbHRoIHwgVFRZ" + - "L3BsYWluL0pTT05MIHwgYC0td2F0Y2hgIGZvciBsaXZlIHJlLXJlbmRlciB8CnwgYHNlbGYtaG9z" + - "dGVkIHVuaW5zdGFsbCAtLWNvbXB1dGUtcGxhbmUgLS1jbHVzdGVyLW5hbWU9WGAgfCBQZXItcGxh" + - "bmUgcHJpbWl0aXZlOiBgaGVsbWZpbGUgZGVzdHJveWAgb24gb25lIGNvbXB1dGUgcGxhbmUgKG5v" + - "IElDTVMgdW5yZWdpc3Rlciwgbm8gZHJhaW4pIHwgcHJvZ3Jlc3MgfCBKdXN0IHRoZSBoZWxtIHJl" + - "bGVhc2VzIG9uIHRoYXQgY29tcHV0ZSBwbGFuZSB8CnwgYHNlbGYtaG9zdGVkIHVuaW5zdGFsbCAt" + - "LWNvbnRyb2wtcGxhbmUgWy0tZm9yY2Utd2l0aC1yZWdpc3RlcmVkLWNsdXN0ZXJzXWAgfCBQZXIt" + - "cGxhbmUgcHJpbWl0aXZlOiBgaGVsbWZpbGUgZGVzdHJveWAgb24gdGhlIGNvbnRyb2wgcGxhbmUg" + - "fCBwcm9ncmVzcyB8IFJlZnVzZXMgaWYgY29tcHV0ZSBwbGFuZXMgc3RpbGwgcmVnaXN0ZXJlZCB1" + - "bmxlc3MgYC0tZm9yY2Utd2l0aC1yZWdpc3RlcmVkLWNsdXN0ZXJzYCB8CnwgYHNlbGYtaG9zdGVk" + - "IHVuaW5zdGFsbCAtLW5vLWFwcGx5IDxwbGFuZT5gIHwgUmVuZGVyIGRlbGV0ZSBZQU1MIHZpYSBg" + - "aGVsbSBnZXQgbWFuaWZlc3RgIHBlciByZWxlYXNlIHwgWUFNTCBvbiBzdGRvdXQgfCBHaXRPcHM7" + - "IHBpcGUgdG8gYGt1YmVjdGwgZGVsZXRlIC1mIC1gIG9yIGNvbW1pdCArIEFyZ28gYXBwbGllcy4g" + - "TWlycm9ycyBgaW5zdGFsbCAtLW5vLWFwcGx5YCB8CnwgYHNlbGYtaG9zdGVkIGRvd24gLS1jbHVz" + - "dGVyLW5hbWU9WCBbLS1kcmFpbi1hY3RpdmVdIFstLXJlbW92ZS1wZXJzaXN0ZW50XWAgfCBPcmNo" + - "ZXN0cmF0b3I6IGRyYWluIOKGkiB1bmluc3RhbGwgLS1jb21wdXRlLXBsYW5lIOKGkiBjbHVzdGVy" + - "IGRlbGV0ZSBpbiBJQ01TIHwgcHJvZ3Jlc3MgfCBTeW1tZXRyaWMgY29tcGFuaW9uIHRvIGB1cCAt" + - "LWNsdXN0ZXItbmFtZT1YYCB8CnwgYHNlbGYtaG9zdGVkIGRvd24gLS1hbGwgWy0tY29uZmlybV1g" + - "IHwgT3JjaGVzdHJhdG9yOiB0ZWFyIGRvd24gZXZlcnkgcmVnaXN0ZXJlZCBjb21wdXRlIHBsYW5l" + - "ICsgY29udHJvbCBwbGFuZSB8IHByb2dyZXNzIHwgQm91bmRlZCBwYXJhbGxlbGlzbSB2aWEgYC0t" + - "YWxsLWNvbmN1cnJlbmN5YCAoZGVmYXVsdCA0KTsgYC0tY29uZmlybWAgcmVxdWlyZWQgaW4gbm9u" + - "LWludGVyYWN0aXZlIHwKfCBgc2VsZi1ob3N0ZWQgZG93biAtLXBsYW4tb25seSAuLi5gIHwgT3Jj" + - "aGVzdHJhdG9yIGRyeS1ydW46IHBoYXNlcyArIGhlbG0gcmVsZWFzZXMgKyBJQ01TIHJvd3MgKyBF" + - "VEFzIChubyBoZWxtL2hlbG1maWxlIGNvbnRhY3QpIHwgSlNPTkwgfCAqKkFsd2F5cyBydW4gYmVm" + - "b3JlIGFueSBhY3R1YWwgYGRvd25gKiogfAoKIyMgQ2x1c3RlciBtYW5hZ2VtZW50Cgp8IENvbW1h" + - "bmQgfCBQdXJwb3NlIHwgTm90ZXMgfAp8LS0tfC0tLXwtLS18CnwgYGNsdXN0ZXIgcmVnaXN0ZXIg" + - "LS1uYW1lPVggLS1uY2EtaWQ9WSBbLS1yZWdpb249Wl0gWy0taWdub3JlLWV4aXN0aW5nXWAgfCBS" + - "ZWdpc3RlciBhIEpXS1MrT0lEQyB3aXRoIElDTVMgfCBVc2VkIGJ5IGB1cGAgUGhhc2UgNSBpbnRl" + - "cm5hbGx5OyBzdGFuZGFsb25lIGZvciBtYW51YWwgcmVnaXN0cmF0aW9uIHwKfCBgY2x1c3RlciBs" + - "aXN0LXJlZ2lzdGVyZWQgLS1uY2EtaWQ9WSBbLS1pY21zLXVybD1VUkxdYCB8IExpc3Qgc2VsZi1o" + - "b3N0ZWQgY2x1c3RlciByZWdpc3RyYXRpb25zIGZyb20gSUNNUyB8IFVzZXMgdGhlIGFkbWluIHRv" + - "a2VuOyBgLS1qc29uYCBmb3IgbWFjaGluZS1yZWFkYWJsZSBvdXRwdXQgfAp8IGBjbHVzdGVyIHJv" + - "dGF0ZSAtLWNsdXN0ZXItaWQ9SURgIHwgUmUtZmV0Y2ggSldLUyBmcm9tIEs4cyBhbmQgUFVUIHRv" + - "IElDTVMgfCBBZnRlciBLOHMgQVBJIHNlcnZlciBzaWduaW5nIGtleSByb3RhdGlvbiB8CnwgYGNs" + - "dXN0ZXIgZGVsZXRlIC0tY2x1c3Rlci1pZD1JRGAgfCBSZW1vdmUgSUNNUyByb3cgfCAqKkRFU1RS" + - "VUNUSVZFOiBjb25maXJtIHdpdGggdXNlcioqIHwKCiMjIEZ1bmN0aW9ucwoKfCBDb21tYW5kIHwg" + - "UHVycG9zZSB8IE5vdGVzIHwKfC0tLXwtLS18LS0tfAp8IGBmdW5jdGlvbiBjcmVhdGUgLS1pbnB1" + - "dC1maWxlPUZJTEVgIHwgQ3JlYXRlIGZ1bmN0aW9uIG1ldGFkYXRhIHwgUmV0dXJucyBGdW5jdGlv" + - "biBJRCArIFZlcnNpb24gSUQ7IExMTSBmdW5jdGlvbnMgdXNlIGBmdW5jdGlvblR5cGU6ICJMTE0i" + - "YCBhbmQgYG1vZGVsc1tdLmxsbUNvbmZpZy51cmlzYCBmb3IgYC92MS9jaGF0L2NvbXBsZXRpb25z" + - "YCwgYC92MS9yZXNwb25zZXNgLCBhbmQgYC92MS9lbWJlZGRpbmdzYCB8CnwgYGZ1bmN0aW9uIGxp" + - "c3RgIC8gYGZ1bmN0aW9uIGxpc3QtaWRzYCB8IExpc3QgZnVuY3Rpb25zIC8gSURzIG9ubHkgfCB8" + - "CnwgYGZ1bmN0aW9uIGdldCAtLWZ1bmN0aW9uLWlkPUlEIC0tdmVyc2lvbi1pZD1WSURgIHwgRnVu" + - "Y3Rpb24gbWV0YWRhdGEgfCB8CnwgYGZ1bmN0aW9uIHVwZGF0ZSAtLWZ1bmN0aW9uLWlkPUlEIC0t" + - "dmVyc2lvbi1pZD1WSUQgLS10YWdzPVRBR1ssVEFHXWAgfCBVcGRhdGUgZnVuY3Rpb24gdGFncyB8" + - "IHwKfCBgZnVuY3Rpb24gdXBkYXRlIC0tZnVuY3Rpb24taWQ9SUQgLS12ZXJzaW9uLWlkPVZJRCAt" + - "LWxsbS1tb2RlbC11cGRhdGU9U1BFQ2AgfCBVcGRhdGUgTExNIG1vZGVsIHJvdXRpbmcgY29uZmln" + - "IHwgYFNQRUNgIHVzZXMgYG5hbWU9PG1vZGVsPixyb3V0aW5nTWV0aG9kPTxtZXRob2Q+LHRva2Vu" + - "UmF0ZUxpbWl0PTxsaW1pdD5gOyBhY2NlcHRlZCBtZXRob2RzIGFyZSBsaXN0ZWQgaW4gW2ZsYWdz" + - "Lm1kXShmbGFncy5tZCkgfAp8IGBmdW5jdGlvbiBkZXBsb3kgY3JlYXRlIC0taW5wdXQtZmlsZT1G" + - "SUxFYCB8IFNjaGVkdWxlIGEgZGVwbG95bWVudCB8IEJsb2NrcyB1bnRpbCBBQ1RJVkUgKGRlZmF1" + - "bHQgOTAwcykgfAp8IGBmdW5jdGlvbiBkZXBsb3kgZ2V0IC0tZnVuY3Rpb24taWQ9SUQgLS12ZXJz" + - "aW9uLWlkPVZJRCBbLS1qc29uXWAgfCBEZXBsb3ltZW50IHN0YXR1cyB8IGBmdW5jdGlvblN0YXR1" + - "czogQUNUSVZFXHxERVBMT1lJTkdcfEVSUk9SXHxGQUlMRURgIHwKfCBgZnVuY3Rpb24gZGVwbG95" + - "IHVwZGF0ZSAtLWlucHV0LWZpbGU9RklMRWAgfCBNb2RpZnkgYSBkZXBsb3ltZW50IGluIHBsYWNl" + - "IHwgfAp8IGBmdW5jdGlvbiBkZXBsb3kgcmVtb3ZlIC0tZnVuY3Rpb24taWQ9SUQgLS12ZXJzaW9u" + - "LWlkPVZJRGAgfCBTdG9wIGEgZGVwbG95bWVudCwga2VlcCBmdW5jdGlvbiByZWNvcmQgfCB8Cnwg" + - "YGZ1bmN0aW9uIGludm9rZSAtLWlucHV0LWZpbGU9RklMRWAgfCBDYWxsIGEgcmVndWxhciBmdW5j" + - "dGlvbiB8IFJlcXVpcmVzIEFQSSBrZXkgKG5vdCBhZG1pbiB0b2tlbik7IExMTSBmdW5jdGlvbnMg" + - "YXJlIGludm9rZWQgdGhyb3VnaCBgbGxtLmludm9jYXRpb24uPGRvbWFpbj5gIHdpdGggYG1vZGVs" + - "OiAiPGZ1bmN0aW9uLWlkPi88bW9kZWwtbmFtZT4iYCB8CnwgYGZ1bmN0aW9uIGRlbGV0ZSAtLWZ1" + - "bmN0aW9uLWlkPUlEIC0tdmVyc2lvbi1pZD1WSURgIHwgUmVtb3ZlIGZ1bmN0aW9uICsgZGVwbG95" + - "bWVudCB8ICoqREVTVFJVQ1RJVkU6IGNvbmZpcm0gd2l0aCB1c2VyKiogfAoKIyMgVGFza3MKClRh" + - "c2sgY29tbWFuZHMgcmVxdWlyZSBgTlZDRl9BUElfS0VZYCBzZXQgdG8gYSB0YXNrLXNjb3BlZCBr" + - "ZXkgYW5kIGBOVkNGX0JBU0VfTlZDVF9VUkxgIHNldCB0byB0aGUgTlZDVCBnYXRld2F5IGVuZHBv" + - "aW50LiBJbiBhIGZyZXNoIHNlc3Npb24sIHJlYWQgYG52Y3RBcGlLZXlgIGZyb20gYH4vLm52Y2Yt" + - "Y2xpLnN0YXRlYCBhbmQgaW5qZWN0IGl0IGFzIGBOVkNGX0FQSV9LRVlgIHdpdGhvdXQgbG9nZ2lu" + - "ZyB0aGUgdmFsdWU7IGNoZWNrIGBudmN0QXBpS2V5RXhwaXJhdGlvbmAgZmlyc3QgYW5kIHJlZ2Vu" + - "ZXJhdGUgd2l0aCBgYXBpLWtleSBnZW5lcmF0ZSAtLWZvciB0YXNrIC0tdmFsaWRhdGVgIGlmIGV4" + - "cGlyZWQuIFJ1biBgYXBpLWtleSBnZW5lcmF0ZSAtLWZvciB0YXNrYCBhZnRlciBgaW5pdGAgdG8g" + - "bWludCBhIG5ldyBrZXkuCgp8IENvbW1hbmQgfCBQdXJwb3NlIHwgTm90ZXMgfAp8LS0tfC0tLXwt" + - "LS18CnwgYHRhc2sgY3JlYXRlIC0tbmFtZT1YIC0tZ3B1PUdQVSAtLWluc3RhbmNlLXR5cGU9VFlQ" + - "RSAtLWltYWdlPUlNR2AgfCBTdWJtaXQgYSBjb250YWluZXIgdGFzayB8IFNhdmVzIHRhc2sgSUQg" + - "dG8gQ0xJIHN0YXRlOyB1c2UgYC0taW5wdXQtZmlsZWAgZm9yIHJlcGVhdGFibGUgY29uZmlncyB8" + - "CnwgYHRhc2sgY3JlYXRlIC0tbmFtZT1YIC0tZ3B1PUdQVSAtLWluc3RhbmNlLXR5cGU9VFlQRSAt" + - "LWhlbG0tY2hhcnQ9Q0hBUlRgIHwgU3VibWl0IGEgSGVsbSB0YXNrIHwgYC0taGVsbS1jaGFydGAg" + - "cmVwbGFjZXMgYC0taW1hZ2VgIHwKfCBgdGFzayBjcmVhdGUgLS1pbnB1dC1maWxlPUZJTEVgIHwg" + - "U3VibWl0IGEgdGFzayBmcm9tIGEgSlNPTiBjb25maWcgZmlsZSB8IFJlY29tbWVuZGVkIGZvciBy" + - "ZXBlYXRhYmxlIGNvbmZpZ3VyYXRpb25zIHwKfCBgdGFzayBsaXN0IFstLXN0YXR1cz1TVEFUVVNd" + - "IFstLWxpbWl0PU5dYCB8IExpc3QgdGFza3MsIG9wdGlvbmFsbHkgZmlsdGVyZWQgYnkgc3RhdHVz" + - "IHwgU3RhdHVzZXM6IGBRVUVVRURgLCBgTEFVTkNIRURgLCBgUlVOTklOR2AsIGBDT01QTEVURURg" + - "LCBgRVJST1JFRGAsIGBDQU5DRUxFRGAsIGBFWENFRURFRF9NQVhfUlVOVElNRV9EVVJBVElPTmAs" + - "IGBFWENFRURFRF9NQVhfUVVFVUVEX0RVUkFUSU9OYCB8CnwgYHRhc2sgZ2V0IFt0YXNrSWRdYCB8" + - "IEdldCB0YXNrIGRldGFpbHMgfCBVc2VzIHNhdmVkIHRhc2sgSUQgZnJvbSBzdGF0ZSBpZiBvbWl0" + - "dGVkIHwKfCBgdGFzayBldmVudHMgW3Rhc2tJZF0gWy0tbGltaXQ9Tl1gIHwgTGlzdCBsaWZlY3lj" + - "bGUgZXZlbnRzIGZvciBhIHRhc2sgfCB8CnwgYHRhc2sgcmVzdWx0cyBbdGFza0lkXWAgfCBMaXN0" + - "IHJlc3VsdCBhcnRpZmFjdHMgZm9yIGEgY29tcGxldGVkIHRhc2sgfCBSZXR1cm5zIGVtcHR5IGxp" + - "c3Qgd2hlbiBgcmVzdWx0SGFuZGxpbmdTdHJhdGVneWAgaXMgYE5PTkVgOyByZXN1bHQgdXBsb2Fk" + - "IG5vdCB5ZXQgc3VwcG9ydGVkIHwKfCBgdGFzayBjYW5jZWwgW3Rhc2tJZF1gIHwgQ2FuY2VsIGEg" + - "cnVubmluZyB0YXNrIHwgTm8tb3AgaWYgYWxyZWFkeSBpbiB0ZXJtaW5hbCBzdGF0ZSB8CnwgYHRh" + - "c2sgZGVsZXRlIFt0YXNrSWRdYCB8IERlbGV0ZSBhIHRhc2sgcmVjb3JkIHwgKipTdG9wLCBzdGF0" + - "ZSB0YXNrIElEICsgY3VycmVudCBzdGF0dXMsIGFuZCB3YWl0IGZvciBhIHN1YnNlcXVlbnQgdXNl" + - "ciByZXBseSBleHBsaWNpdGx5IGNvbmZpcm1pbmcgZGVsZXRpb24gb2YgdGhhdCBzcGVjaWZpYyB0" + - "YXNrLiBEbyBub3QgdHJlYXQgdGhlIG9yaWdpbmFsIGRlbGV0ZSByZXF1ZXN0IGFzIGNvbmZpcm1h" + - "dGlvbi4qKiB8CnwgYHRhc2sgdXBkYXRlLXNlY3JldHMgW3Rhc2tJZF0gLS1zZWNyZXRzIE5BTUU9" + - "dmFsdWVgIHwgVXBkYXRlIHNlY3JldHMgb24gYSB0YXNrOyBzdXBwbGllZCBzZWNyZXRzIGFyZSBh" + - "ZGRlZCBvciB1cGRhdGVkIGJ5IG5hbWUsIGV4aXN0aW5nIHNlY3JldHMgbm90IGluIHRoZSByZXF1" + - "ZXN0IGFyZSBwcmVzZXJ2ZWQgfCBWYWx1ZXMgYXJlIGVuY3J5cHRlZCBhdCByZXN0IHwKfCBgdGFz" + - "ayBidWxrIC0tdGFzay1pZHM9SUQxWyxJRDIs4oCmXWAgfCBGZXRjaCBkZXRhaWxzIGZvciBtdWx0" + - "aXBsZSB0YXNrcyBpbiBvbmUgcmVxdWVzdCB8IHwKCiMjIEF1dGgKCnwgQ29tbWFuZCB8IFB1cnBv" + - "c2UgfCBOb3RlcyB8CnwtLS18LS0tfC0tLXwKfCBgaW5pdGAgfCBNaW50IGFkbWluIHRva2VuIGZy" + - "b20gQVBJIEtleXMgdmlhIHB1YmxpYyBhcGkgZ2F0ZXdheSB8IElkZW1wb3RlbnQ7IHdyaXRlcyBg" + - "fi8ubnZjZi1jbGkuc3RhdGVgOyBjbGVhcnMgc2F2ZWQgZnVuY3Rpb24gc3RhdGUgYW5kIGFsbCBB" + - "UEkga2V5cyAoZnVuY3Rpb24gYW5kIHRhc2spIHwKfCBgc3RhdHVzYCB8IFNob3cgQ0xJIHN0YXRl" + - "ICh0b2tlbiwgbGFzdCBlbmRwb2ludHMsIGZ1bmN0aW9uIGNvbnRleHQpIHwgRGlzdGluY3QgZnJv" + - "bSBgc2VsZi1ob3N0ZWQgc3RhdHVzYCB8CnwgYGFwaS1rZXkgZ2VuZXJhdGUgWy0tZm9yIGZ1bmN0" + - "aW9uXHx0YXNrXSBbLS1kZXNjcmlwdGlvbj3igKZdIFstLWV4cGlyZXMtaW494oCmXWAgfCBNaW50" + - "IEFQSSBrZXlzIHwgRGVmYXVsdCAobm8gYC0tZm9yYCk6IGdlbmVyYXRlcyBib3RoIGEgZnVuY3Rp" + - "b24ga2V5IGFuZCBhIHRhc2sga2V5OyBgLS1mb3IgZnVuY3Rpb25gIG9yIGAtLWZvciB0YXNrYCBn" + - "ZW5lcmF0ZXMgb25lIG9ubHk7IGAtLXNjb3Blc2AgcmVxdWlyZXMgYC0tZm9yYCB8CnwgYGFwaS1r" + - "ZXkgZ2VuZXJhdGUgLS12YWxpZGF0ZWAgfCBNaW50IGFuZCBpbW1lZGlhdGVseSB2YWxpZGF0ZSBl" + - "YWNoIGdlbmVyYXRlZCBrZXkgfCBWYWxpZGF0ZXMgZWFjaCBrZXkgYWdhaW5zdCBpdHMgY29ycmVj" + - "dCBhdWRpZW5jZSAoTlZDRiBmb3IgZnVuY3Rpb24ga2V5cywgTlZDVCBmb3IgdGFzayBrZXlzKSB8" + - "CnwgYGFwaS1rZXkgbGlzdGAgfCBMaXN0IEFQSSBrZXlzIGZvciBjdXJyZW50IG93bmVyIHwgTGlz" + - "dHMgTlZDRi1zY29wZWQga2V5cyBvbmx5IHwKfCBgYXBpLWtleSBkZWxldGUgS0VZLUlEYCAvIGBh" + - "cGkta2V5IHJldm9rZSBLRVktSURgIHwgUmVtb3ZlIGFuIEFQSSBrZXkgfCAqKkNvbmZpcm0gd2l0" + - "aCB1c2VyKiogfAp8IGBhcGkta2V5IHNob3dgIHwgU2hvdyBjdXJyZW50bHkgc2F2ZWQgQVBJIGtl" + - "eSBmcm9tIHN0YXRlIHwgfAoKIyMgQWdlbnQgc2tpbGwKCnwgQ29tbWFuZCB8IFB1cnBvc2UgfCBO" + - "b3RlcyB8CnwtLS18LS0tfC0tLXwKfCBgYWdlbnQtc2tpbGwgaW5zdGFsbCBbLS10YXJnZXQ9RElS" + - "XWAgfCBJbnN0YWxsIGFsbCBidW5kbGVkIHB1YmxpYyB1c2VyIHNraWxscyBpbnRvIGB+Ly5jbGF1" + - "ZGUvc2tpbGxzL2AgYW5kIGB+Ly5hZ2VudHMvc2tpbGxzL2AgfCBEZWZhdWx0OiBib3RoIGJhc2Ug" + - "c2tpbGxzIGRpcmVjdG9yaWVzIHwKfCBgYWdlbnQtc2tpbGwgdW5pbnN0YWxsIFstLXRhcmdldD1E" + - "SVJdYCB8IFJlbW92ZSBvbmx5IGJ1bmRsZWQgcHVibGljIHVzZXIgc2tpbGxzIGZyb20gdGhlIHRh" + - "cmdldCBiYXNlIHNraWxscyBkaXJlY3RvcmllcyB8IElkZW1wb3RlbnQ7IHVucmVsYXRlZCBza2ls" + - "bHMgcmVtYWluIHwKfCBgYWdlbnQtc2tpbGwgc2hvdyBbLS1maWxlPVJFTF1gIHwgUHJpbnQgYnVu" + - "ZGxlZCBgbnZjZi1zZWxmLW1hbmFnZWQtY2xpL1NLSUxMLm1kYCBvciBhbm90aGVyIGVtYmVkZGVk" + - "IGZpbGUgfCBGb3IgZGVidWdnaW5nIHwKfCBgYWdlbnQtc2tpbGwgdmVyc2lvbmAgfCBQcmludCBi" + - "dWlsZCBTSEEgYW5kIGVtYmVkZGVkIHB1YmxpYyB1c2VyIHNraWxsIHN1bW1hcnkgfCB8ClBLBwhy" + - "DQ9kISMAACEjAABQSwMEFAAIAAAAAAAhAAAAAAAAAAAAAAAAADIACQBkYXRhL252Y2Ytc2VsZi1t" + - "YW5hZ2VkLWNsaS9yZWZlcmVuY2UvZXhpdC1jb2Rlcy5tZFVUBQABAKbOEiMgYG52Y2YtY2xpYCBl" + - "eGl0IGNvZGVzCgpTdGFibGUgYWNyb3NzIHN1YmNvbW1hbmRzLiBVc2UgdGhlc2UgdG8gZHJpdmUg" + - "YWdlbnQgcmV0cnkgLyBzdXJmYWNpbmcgbG9naWMuCgp8IENvZGUgfCBNZWFuaW5nIHwgRXhhbXBs" + - "ZSBjYXVzZXMgfAp8LS0tfC0tLXwtLS18CnwgYDBgIHwgU3VjY2VzcyB8IEFsbCBjaGVja3MgcGFz" + - "c2VkOyBpbnN0YWxsIGNvbXBsZXRlZDsgZGVwbG95bWVudCBBQ1RJVkUgfAp8IGAxYCB8IEdlbmVy" + - "aWMgZXJyb3IgfCBIZWxtIHJlbmRlciBmYWlsZWQ7IG5ldHdvcmsgdW5yZWFjaGFibGU7IGZpbGUg" + - "bm90IGZvdW5kOyBZQU1MIHBhcnNlIGVycm9yIHwKfCBgMmAgfCBQcmUtZmxpZ2h0IGNoZWNrIGZh" + - "aWxlZCB8IEdhdGV3YXkgQVBJIENSRHMgbWlzc2luZzsga3ViZWN0bCBub3Qgb24gUEFUSDsgZGVm" + - "YXVsdCBTdG9yYWdlQ2xhc3MgYWJzZW50IHwKfCBgM2AgfCBBZG1pbiBhdXRoIGZhaWxlZCB8IE5v" + - "IHRva2VuICsgYC0tbm9uLWludGVyYWN0aXZlYCBzZXQ7IElDTVMgcmVqZWN0ZWQgSldUOyBpbml0" + - "IGVuZHBvaW50IHVucmVhY2hhYmxlIHwKfCBgNWAgfCBNYW5pZmVzdCBhcHBseSBvciBgLS13YWl0" + - "YCB0aW1lZCBvdXQgfCBIZWxtIGluc3RhbGwgdGltZW91dDsgY2hlY2sgcG9sbGVkIGJ1dCBkaWRu" + - "J3QgcGFzcyBiZWZvcmUgZHVyYXRpb24gfAp8IGAxMzBgIHwgQ2FuY2VsbGVkIGJ5IFNJR0lOVC9T" + - "SUdURVJNIHwgVXNlciBDdHJsLUM7IENJIGJ1ZGdldCBleGNlZWRlZDsgcG9kIGV2aWN0ZWQgfAoK" + - "IyMgSG93IGFuIGFnZW50IHNob3VsZCByZWFjdAoKfCBDb2RlIHwgQWdlbnQgYmVoYXZpb3IgfAp8" + - "LS0tfC0tLXwKfCBgMGAgfCBDb250aW51ZSAvIHJlcG9ydCBzdWNjZXNzLiB8CnwgYDFgIHwgU3Vy" + - "ZmFjZSBzdGRlcnIgdG8gdXNlcjsgYXNrIGJlZm9yZSBhbnkgcmV0cnkuIEdlbmVyaWMgZXJyb3Jz" + - "IHVzdWFsbHkgbmVlZCBhIGh1bWFuIHRvIHJlYWQgdGhlIG1lc3NhZ2UuIHwKfCBgMmAgfCBTdXJm" + - "YWNlIGZhaWxlZCBjaGVja3MgKyB0aGVpciBgaGludFVSTGAuIERvbid0IHByb3Bvc2UgYHVwYCB1" + - "bnRpbCB0aGUgdXNlciBmaXhlcyBwcmVyZXFzLiB8CnwgYDNgIHwgU3VnZ2VzdCBgbnZjZi1jbGkg" + - "aW5pdGAgKGludGVyYWN0aXZlKSBPUiBgLS10b2tlbj0kSldUYCAoQ0kpLiBEb24ndCBhdXRvLW1p" + - "bnQgd2l0aG91dCB1c2VyIE9LLiB8CnwgYDVgIHwgQXNrIHVzZXIgaWYgdGhleSB3YW50IHRvIHdh" + - "aXQgbG9uZ2VyLCBkaWcgaW50byB0aGUgc3RhbGxlZCBjb21wb25lbnQsIG9yIGNhbmNlbC4gfAp8" + - "IGAxMzBgIHwgRG9uJ3QgcmV0cnkgYXV0b21hdGljYWxseTsgdXNlciBleHBsaWNpdGx5IGNhbmNl" + - "bGxlZC4gQ29uZmlybSBiZWZvcmUgcmUtcnVubmluZy4gfAoKIyMgV2hlcmUgdG8gZmluZCBtb3Jl" + - "IGRldGFpbAoKRXZlcnkgbm9uLXplcm8gZXhpdCBlbWl0cyBhIHN0cnVjdHVyZWQgYHBoYXNlX2Zh" + - "aWxlZGAgSlNPTiBldmVudCB3aXRoIGBlcnJDYXRlZ29yeWAsIGBlcnJNZXNzYWdlYCwgYHJlbWVk" + - "aWF0aW9uYCAoYXJyYXkpLCBgcmV0cnlDbGFzc2AgKGVudW06IGBub25lfGltbWVkaWF0ZXxiYWNr" + - "b2ZmfGFmdGVyX3JlbWVkaWF0aW9ufHVua25vd25gKSwgYHJldHJ5QWZ0ZXJTZWNgIChpbnQsIG9w" + - "dGlvbmFsKSwgYW5kIGByYXdgIChzdWJwcm9jZXNzICsgSFRUUCArIEt1YmVybmV0ZXMgc2lnbmFs" + - "KS4gQWx3YXlzIGNvbnN1bWUgdGhlc2UgaW4gYC0tanNvbmAgbW9kZSByYXRoZXIgdGhhbiBwYXJz" + - "aW5nIEVuZ2xpc2ggZnJvbSBzdGRlcnIuClBLBwhzp1pk1QYAANUGAABQSwMEFAAIAAAAAAAhAAAA" + - "AAAAAAAAAAAAAC0ACQBkYXRhL252Y2Ytc2VsZi1tYW5hZ2VkLWNsaS9yZWZlcmVuY2UvZmxhZ3Mu" + - "bWRVVAUAAQCmzhIjIGBudmNmLWNsaWAgZmxhZyByZWZlcmVuY2UKCiMjIEdsb2JhbCBmbGFncyAo" + - "ZXZlcnkgc3ViY29tbWFuZCkKCnwgRmxhZyB8IFB1cnBvc2UgfCBEZWZhdWx0IHwKfC0tLXwtLS18" + - "LS0tfAp8IGAtLWNvbmZpZyBGSUxFYCB8IENvbmZpZyBmaWxlIHBhdGggfCBgJEhPTUUvLm52Y2Yt" + - "Y2xpLnlhbWxgIHwKfCBgLS1kZWJ1Z2AgfCBWZXJib3NlIEhUVFAgbG9nZ2luZyBvbiBzdGRlcnIg" + - "fCBgZmFsc2VgIHwKfCBgLS1qc29uYCB8IEpTT05MIGV2ZW50cyBvbiBzdGRlcnIgfCBhdXRvIChv" + - "ZmYgaW4gVFRZLCBvbiB1bmRlciBgLS1ub24taW50ZXJhY3RpdmVgKSB8CgojIyBgc2VsZi1ob3N0" + - "ZWRgIHBhcmVudCAocGVyc2lzdGVudCBhY3Jvc3Mgc3ViY29tbWFuZHMpCgp8IEZsYWcgfCBQdXJw" + - "b3NlIHwgRGVmYXVsdCB8CnwtLS18LS0tfC0tLXwKfCBgLS1jb250cm9sLXBsYW5lLXN0YWNrPeKA" + - "pmAgfCBDb250cm9sLXBsYW5lIGJ1bmRsZSBzb3VyY2U6IGxvY2FsIHBhdGgsIGdpdCBVUkwsIG9y" + - "IGBvY2k6Ly9gIFVSTCB8IGVtYmVkZGVkIE9DSSBVUkwgcGlubmVkIGJ5IENMSSB2ZXJzaW9uIHwK" + - "fCBgLS1jb21wdXRlLXBsYW5lLXN0YWNrPeKApmAgfCBDb21wdXRlLXBsYW5lIGJ1bmRsZSBzb3Vy" + - "Y2U6IGxvY2FsIHBhdGgsIGdpdCBVUkwsIG9yIGBvY2k6Ly9gIFVSTCB8IGVtYmVkZGVkIE9DSSBV" + - "UkwgcGlubmVkIGJ5IENMSSB2ZXJzaW9uIHwKfCBgLS1lbnY9bG9jYWxcfHByZFx84oCmYCB8IEhl" + - "bG1maWxlIGVudmlyb25tZW50IG5hbWUgfCBgbG9jYWxgIGZvciBkZXYgYnVpbGRzLCBgcHJkYCBm" + - "b3IgcmVsZWFzZXMgfAp8IGAtLW5vbi1pbnRlcmFjdGl2ZWAgfCBEaXNhYmxlIGFsbCBzdGRpbiBw" + - "cm9tcHRzIHwgYGZhbHNlYCB8CnwgYC0tdG9rZW49JEpXVGAgfCBBZG1pbiBKV1QsIG92ZXJyaWRl" + - "cyBzdG9yZWQgc2Vzc2lvbiB8IC0gfAp8IGAtLW5vLWFwcGx5YCB8IGBpbnN0YWxsYCBvbmx5IC0g" + - "ZW1pdCBZQU1MLCBkbyBub3Qga3ViZWN0bCBhcHBseSB8IGBmYWxzZWAgfAp8IGAtLW91dHB1dD10" + - "ZXh0XHxqc29uYCB8IExlZ2FjeSBhbGlhcyBmb3IgYC0tanNvbmAgKGRlcHJlY2F0ZWQsIHJlbW92" + - "ZWQgaW4gbmV4dCBtYWpvcikgfCBgdGV4dGAgfAp8IGAtLXBsYWluYCB8IEZvcmNlIHBsYWluIHN0" + - "cmVhbWluZyBvdXRwdXQgfCBhdXRvLWRldGVjdCB8CnwgYC0td2FpdCBEVVJBVElPTmAgfCBgY2hl" + - "Y2tgIG9ubHk7IGJsb2NrIHVudGlsIHBhc3MgfCAtIHwKfCBgLS1jb250cm9sLXBsYW5lLWNvbnRl" + - "eHQgQ1RYYCB8IGt1YmVjdGwgY29udGV4dCBmb3IgY29udHJvbCBwbGFuZSAoUkVRLTIwKSB8IGN1" + - "cnJlbnQgY29udGV4dCB8CnwgYC0tY29tcHV0ZS1wbGFuZS1jb250ZXh0IENUWGAgfCBrdWJlY3Rs" + - "IGNvbnRleHQgZm9yIGNvbXB1dGUgcGxhbmUgKFJFUS0yMCkgfCBjdXJyZW50IGNvbnRleHQgfAp8" + - "IGAtLWljbXMtdXJsIFVSTGAgfCBQdWJsaWMgSUNNUyBVUkw7IHJlcXVpcmVkIHdoZW4gY29udGV4" + - "dHMgZGlmZmVyIHwgZGVyaXZlZCBmcm9tIGBiYXNlX2h0dHBfdXJsYCB8CnwgYC0tbG9jYWwtb25s" + - "eWAgfCBgY2hlY2sgLS1wcmVgIG9ubHk7IHNraXAgYWxsIGt1YmVjdGwgY29udGFjdCB8IGBmYWxz" + - "ZWAgfAoKIyMgYHVwYC1zcGVjaWZpYwoKfCBGbGFnIHwgUHVycG9zZSB8IERlZmF1bHQgfAp8LS0t" + - "fC0tLXwtLS18CnwgYC0tY2x1c3Rlci1uYW1lIE5BTUVgIHwgSUNNUyBjbHVzdGVyIHJvdyBpZGVu" + - "dGlmaWVyIChyZXF1aXJlZCkgfCAtIHwKfCBgLS1uY2EtaWQgSURgIHwgTkNBIGFjY291bnQgSUQg" + - "fCBgbnZjZi1kZWZhdWx0YCB8CnwgYC0tcmVnaW9uIFJFR0lPTmAgfCBDbHVzdGVyIHJlZ2lvbiB8" + - "IGB1cy13ZXN0LTFgIHwKfCBgLS1wbGFuLW9ubHlgIHwgRHJ5LXJ1bjsgZW1pdCBwaGFzZSBwbGFu" + - "ICsgRVRBcyB3aXRob3V0IGNoYW5nZXMgfCBgZmFsc2VgIHwKCiMjIGBzdGF0dXNgLXNwZWNpZmlj" + - "Cgp8IEZsYWcgfCBQdXJwb3NlIHwgRGVmYXVsdCB8CnwtLS18LS0tfC0tLXwKfCBgLS1jbHVzdGVy" + - "LW5hbWUgTkFNRWAgfCBMaW1pdCB0byBvbmUgY29tcHV0ZSBwbGFuZSB8IC0gKGNvbnRyb2wgKyBh" + - "bGwgY2x1c3RlcnMpIHwKfCBgLS13YXRjaGAgfCBMaXZlIHJlLXJlbmRlciB8IGBmYWxzZWAgfAp8" + - "IGAtLXdhdGNoLWludGVydmFsIERVUmAgfCBgLS13YXRjaGAgY2FkZW5jZSB8IGA1c2AgfAp8IGAt" + - "LWNvbXBvbmVudCBOQU1FYCB8IEZpbHRlciBjb21wb25lbnRzIHBhbmVsIHwgYWxsIHwKfCBgLS1u" + - "by1ldmVudHNgIHwgU2tpcCBldmVudHMgcGFuZWwgfCBgZmFsc2VgIHwKCiMjIGBjbHVzdGVyIHJl" + - "Z2lzdGVyYC1zcGVjaWZpYwoKfCBGbGFnIHwgUHVycG9zZSB8IERlZmF1bHQgfAp8LS0tfC0tLXwt" + - "LS18CnwgYC0tbmFtZSBOQU1FYCB8IENsdXN0ZXIgbmFtZSAocmVxdWlyZWQpIHwgLSB8CnwgYC0t" + - "bmNhLWlkIElEYCB8IE5DQSBJRCAocmVxdWlyZWQpIHwgLSB8CnwgYC0tcmVnaW9uIFJFR0lPTmAg" + - "fCBSZWdpb24gfCBgdXMtd2VzdC0xYCB8CnwgYC0taWNtcy11cmwgVVJMYCB8IElDTVMgZW5kcG9p" + - "bnQgfCBmcm9tIGNvbmZpZyB8CnwgYC0taWdub3JlLWV4aXN0aW5nYCB8IE1hdGNoLW9yLWNyZWF0" + - "ZSBpbnN0ZWFkIG9mIGZhaWwtb24tZXhpc3RzIHwgYGZhbHNlYCB8CgojIyBgYXBpLWtleSBnZW5l" + - "cmF0ZWAtc3BlY2lmaWMKCnwgRmxhZyB8IFB1cnBvc2UgfCBEZWZhdWx0IHwKfC0tLXwtLS18LS0t" + - "fAp8IGAtLWZvciBmdW5jdGlvblx8dGFza2AgfCBHZW5lcmF0ZSBvbmx5IHRoZSBzcGVjaWZpZWQg" + - "a2V5IHR5cGUgfCAob21pdCB0byBnZW5lcmF0ZSBib3RoKSB8CnwgYC0tZGVzY3JpcHRpb24gVEVY" + - "VGAgfCBIdW1hbi1yZWFkYWJsZSBsYWJlbCBmb3IgdGhlIGtleSB8IGBHZW5lcmF0ZWQgYnkgbnZj" + - "Zi1jbGlgIHwKfCBgLS1leHBpcmVzLWluIERVUkFUSU9OYCB8IEV4cGlyeSBvZmZzZXQgKGUuZy4g" + - "YDI0aGAsIGA3ZGApOyBwYXJzZWQgYXMgZXh0ZW5kZWQgZHVyYXRpb24gfCBgMjRoYCB8CnwgYC0t" + - "c2NvcGVzIFNDT1BFWyxTQ09QRV1gIHwgT3ZlcnJpZGUgZGVmYXVsdCBzY29wZXM7IHJlcXVpcmVz" + - "IGAtLWZvcmAgfCAoc2VydmljZSBkZWZhdWx0cykgfAp8IGAtLXZhbGlkYXRlYCB8IFZhbGlkYXRl" + - "IGVhY2ggZ2VuZXJhdGVkIGtleSBpbW1lZGlhdGVseSBhZnRlciBtaW50aW5nIHwgYGZhbHNlYCB8" + - "CgpFeHRlbmRlZCBkdXJhdGlvbiB1bml0czogYHNgIChzZWNvbmRzKSwgYG1gIChtaW51dGVzKSwg" + - "YGhgIChob3VycyksIGBkYCAoZGF5cyksIGB3YCAod2Vla3MpLgoKIyMgYGZ1bmN0aW9uIGNyZWF0" + - "ZWAtc3BlY2lmaWMKCmAtLWlucHV0LWZpbGUgRklMRWAgaXMgcmVjb21tZW5kZWQgZm9yIHJlcGVh" + - "dGFibGUgZnVuY3Rpb24gZGVmaW5pdGlvbnMuIEZvciBhZC1ob2MgY3JlYXRlczoKCnwgRmxhZyB8" + - "IFB1cnBvc2UgfCBEZWZhdWx0IHwKfC0tLXwtLS18LS0tfAp8IGAtLW5hbWUgTkFNRWAgfCBGdW5j" + - "dGlvbiBuYW1lIHwgLSB8CnwgYC0taW1hZ2UgSU1BR0VgIHwgQ29udGFpbmVyIGltYWdlIHwgLSB8" + - "CnwgYC0taW5mZXJlbmNlLXVybCBVUklgIHwgQ29udGFpbmVyIGluZmVyZW5jZSBlbmRwb2ludCB8" + - "IC0gfAp8IGAtLWluZmVyZW5jZS1wb3J0IFBPUlRgIHwgQ29udGFpbmVyIGluZmVyZW5jZSBwb3J0" + - "IHwgLSB8CnwgYC0tZnVuY3Rpb24tdHlwZSBERUZBVUxUXHxTVFJFQU1JTkdcfExMTWAgfCBGdW5j" + - "dGlvbiB0eXBlIHwgYERFRkFVTFRgIHwKfCBgLS1oZWxtLWNoYXJ0IENIQVJUYCB8IEhlbG0gY2hh" + - "cnQgVVJMIG9yIE9DSSByZWZlcmVuY2UuIENhbiBiZSB1c2VkIHdpdGggYC0tZnVuY3Rpb24tdHlw" + - "ZT1MTE1gIGZvciBjaGFydC1wYWNrYWdlZCBMTE0gd29ya2xvYWRzLiB8IC0gfAp8IGAtLWhlbG0t" + - "Y2hhcnQtc2VydmljZSBOQU1FYCB8IEt1YmVybmV0ZXMgU2VydmljZSBuYW1lIGV4cG9zZWQgYnkg" + - "dGhlIGNoYXJ0LiBSZXF1aXJlZCB3aGVuIGAtLWhlbG0tY2hhcnRgIGlzIHNldC4gfCAtIHwKfCBg" + - "LS1tb2RlbHMgTkFNRTpWRVJTSU9OOlVSSWAgfCBTdGFuZGFyZCBtb2RlbCBhcnRpZmFjdDsgcmVw" + - "ZWF0YWJsZSB8IC0gfAp8IGAtLWxsbS1tb2RlbCBTUEVDYCB8IExMTSBtb2RlbCBjb25maWc7IGZv" + - "cm1hdCBgbmFtZT08bW9kZWw+LHVyaXM9PHVyaT5cfDx1cmk+LHJvdXRpbmdNZXRob2Q9PG1ldGhv" + - "ZD4sdG9rZW5SYXRlTGltaXQ9PGxpbWl0PmA7IHJlcGVhdGFibGUuIFRva2VuIGxpbWl0cyB1c2Ug" + - "YDx2YWx1ZT4tPHVuaXQ+YCB3aXRoIGBTYCwgYE1gLCBgSGAsIGBEYCwgb3IgYFdgLCBmb3IgZXhh" + - "bXBsZSBgMTAwMC1TYC4gVXNlIGlucHV0IEpTT04gZm9yIGNvbWJpbmVkIHRva2VuIGxpbWl0cyBi" + - "ZWNhdXNlIGlubGluZSBzcGVjcyB1c2UgY29tbWFzIGFzIGZpZWxkIHNlcGFyYXRvcnMuIHwgLSB8" + - "CgpJbiBKU09OIGFuZCBpbmxpbmUgc3BlY3MsIExMTSBmdW5jdGlvbnMgc2V0IGBmdW5jdGlvblR5" + - "cGU6ICJMTE0iYCBhbmQgbW9kZWwgcm91dGluZyBtZXRhZGF0YSB1bmRlciBgbW9kZWxzW10ubGxt" + - "Q29uZmlnYC4gYGxsbUNvbmZpZy51cmlzYCBkZWNsYXJlcyB0aGUgT3BlbkFJLWNvbXBhdGlibGUg" + - "dXBzdHJlYW0gcGF0aHMgZXhwb3NlZCBieSB0aGUgbW9kZWwuIEN1cnJlbnQgc3VwcG9ydGVkIHBh" + - "dGhzIGFyZSBgL3YxL2NoYXQvY29tcGxldGlvbnNgLCBgL3YxL3Jlc3BvbnNlc2AsIGFuZCBgL3Yx" + - "L2VtYmVkZGluZ3NgLiBgbGxtQ29uZmlnLnJvdXRpbmdNZXRob2RgIGFjY2VwdHMgYHJvdW5kX3Jv" + - "YmluYCwgYHBvd2VyX29mX3R3b2AsIGBncm9xX211bHRpcmVnaW9uYCwgYHB1bHNhcmAsIG9yIGBy" + - "YW5kb21gLgpgbGxtQ29uZmlnLnRva2VuUmF0ZUxpbWl0YCBhY2NlcHRzIG9uZSBvciBtb3JlIGNv" + - "bW1hLXNlcGFyYXRlZCBwb3NpdGl2ZSBpbnRlZ2VyIHRva2VuIGxpbWl0cyBpbiBgPHZhbHVlPi08" + - "dW5pdD5gIGZvcm1hdC4gU3VwcG9ydGVkIHVuaXRzIGFyZSBgU2AgKHNlY29uZHMpLCBgTWAgKG1p" + - "bnV0ZXMpLCBgSGAgKGhvdXJzKSwgYERgIChkYXlzKSwgYW5kIGBXYCAod2Vla3MpLiBVc2UgZGlz" + - "dGluY3QgdW5pdHMgd2hlbiBjb21iaW5pbmcgbGltaXRzLCBmb3IgZXhhbXBsZSBgMTAwMC1TLDUw" + - "MDAtTSwxMDAwMDAtSCw1MDAwMDAtRCwxMDAwMDAwLVdgIGluIGlucHV0IEpTT04uCgpIZWxtIGNo" + - "YXJ0IHBhY2thZ2luZyBpcyBpbmRlcGVuZGVudCBvZiBgZnVuY3Rpb25UeXBlYC4gRm9yIGEgSGVs" + - "bS1jaGFydCBiYWNrZWQgTExNIGZ1bmN0aW9uLCBzZXQgYGZ1bmN0aW9uVHlwZTogIkxMTSJgLCBg" + - "aGVsbUNoYXJ0YCwgYGhlbG1DaGFydFNlcnZpY2VOYW1lYCwgYW5kIGBtb2RlbHNbXS5sbG1Db25m" + - "aWdgIGluIHRoZSBzYW1lIGNyZWF0ZSByZXF1ZXN0LiBgaW5mZXJlbmNlUG9ydGAgbXVzdCBiZSB0" + - "aGUgS3ViZXJuZXRlcyBTZXJ2aWNlIHBvcnQgZXhwb3NlZCBieSBgaGVsbUNoYXJ0U2VydmljZU5h" + - "bWVgLgoKTExNIGludm9jYXRpb24gcmVxdWVzdHMgdXNlIGBtb2RlbDogIjxmdW5jdGlvbi1pZD4v" + - "PG1vZGVsLW5hbWU+ImAuIFRoZSBmdW5jdGlvbiBJRCBzZWxlY3RzIHRoZSBOVkNGIGZ1bmN0aW9u" + - "LCBhbmQgdGhlIG1vZGVsIG5hbWUgaXMgZm9yd2FyZGVkIHVwc3RyZWFtLiBDaGF0IGNvbXBsZXRp" + - "b25zIGFuZCBSZXNwb25zZXMgQVBJIHJlcXVlc3RzIGNhbiB1c2UgYHgtbXVsdGktdHVybi1zZXNz" + - "aW9uLWlkYCBmb3Igc2Vzc2lvbiBzdGlja2luZXNzOyBlbWJlZGRpbmdzIHJlcXVlc3RzIGRvIG5v" + - "dC4KCiMjIGBmdW5jdGlvbiB1cGRhdGVgLXNwZWNpZmljCgp8IEZsYWcgfCBQdXJwb3NlIHwgRGVm" + - "YXVsdCB8CnwtLS18LS0tfC0tLXwKfCBgLS10YWdzIFRBR1ssVEFHXWAgfCBSZXBsYWNlIGZ1bmN0" + - "aW9uIHRhZ3MgfCAtIHwKfCBgLS1sbG0tbW9kZWwtdXBkYXRlIFNQRUNgIHwgTExNIG1vZGVsIHVw" + - "ZGF0ZTsgZm9ybWF0IGBuYW1lPTxtb2RlbD4scm91dGluZ01ldGhvZD08bWV0aG9kPix0b2tlblJh" + - "dGVMaW1pdD08bGltaXQ+YDsgcmVwZWF0YWJsZS4gUm91dGluZyBtZXRob2RzIG1hdGNoIGAtLWxs" + - "bS1tb2RlbGAuIFRva2VuIGxpbWl0IGV4YW1wbGU6IGAxMDAwLVNgLiBVc2UgaW5wdXQgSlNPTiBm" + - "b3IgY29tYmluZWQgdG9rZW4gbGltaXRzLiB8IC0gfAoKSW4gSlNPTiwgYGZ1bmN0aW9uIHVwZGF0" + - "ZWAgYWNjZXB0cyBgbW9kZWxVcGRhdGVzW11gIGVudHJpZXMgd2l0aCBgbW9kZWxOYW1lYCBhbmQg" + - "YGxsbUNvbmZpZy5yb3V0aW5nTWV0aG9kYCBhbmQvb3IgYGxsbUNvbmZpZy50b2tlblJhdGVMaW1p" + - "dGAuIGB1cmlzYCBhcmUgY3JlYXRlLXRpbWUgbW9kZWwgbWV0YWRhdGEgYW5kIGFyZSBub3QgcGFy" + - "dCBvZiBtb2RlbCB1cGRhdGVzLgoKIyMgYGZ1bmN0aW9uIGRlcGxveSBjcmVhdGVgLXNwZWNpZmlj" + - "CgpgLS1pbnB1dC1maWxlIEZJTEVgIGlzIHJlY29tbWVuZGVkIChmdWxsIEpTT04gc3BlYykuIEZv" + - "ciBhZC1ob2Mgb25lLXNob3QgdXNlOgoKfCBGbGFnIHwgUHVycG9zZSB8IERlZmF1bHQgfAp8LS0t" + - "fC0tLXwtLS18CnwgYC0tZnVuY3Rpb24taWQgSURgIHwgRnVuY3Rpb24gSUQgKHJlcXVpcmVkKSB8" + - "IC0gfAp8IGAtLWdwdSBOQU1FYCB8IEdQVSBmYW1pbHkgfCBgSDEwMGAgfAp8IGAtLWluc3RhbmNl" + - "LXR5cGUgVFlQRWAgfCBTS1UgfCBgTkNQLkdQVS5IMTAwXzF4YCB8CnwgYC0tbWluLWluc3RhbmNl" + - "cyBOYCB8IE1pbiByZXBsaWNhcyB8IGAxYCB8CnwgYC0tbWF4LWluc3RhbmNlcyBOYCB8IE1heCBy" + - "ZXBsaWNhcyB8IGAxYCB8CnwgYC0tbWF4LXJlcXVlc3QtY29uY3VycmVuY3kgTmAgfCBDb25jdXJy" + - "ZW5jeSB8IGAwYCAodW5zZXQ7IHNlcnZlciBkZWZhdWx0IGFwcGxpZXMpIHwKfCBgLS1jbHVzdGVy" + - "cyBOQU1FWyxOQU1FXWAgfCBUYXJnZXQgc3BlY2lmaWMgY29tcHV0ZSBjbHVzdGVycyB8IChhbnkg" + - "bWF0Y2hpbmcgU0tVKSB8CgojIyBgdGFzayBjcmVhdGVgLXNwZWNpZmljCgpgLS1pbnB1dC1maWxl" + - "IEZJTEVgIGlzIHJlY29tbWVuZGVkIGZvciByZXBlYXRhYmxlIHRhc2sgZGVmaW5pdGlvbnMuIEZv" + - "ciBhZC1ob2MgdXNlOgoKfCBGbGFnIHwgUHVycG9zZSB8IE5vdGVzIHwKfC0tLXwtLS18LS0tfAp8" + - "IGAtLW5hbWUgTkFNRWAgfCBUYXNrIG5hbWUgKHJlcXVpcmVkKSB8IDEtMTI4IGNoYXJzLCBgXlth" + - "LXowLTlBLVpdW2EtejAtOUEtWlwtX10qJGAgfAp8IGAtLWdwdSBHUFVgIHwgR1BVIG5hbWUgKHJl" + - "cXVpcmVkIHdpdGhvdXQgYC0taW5wdXQtZmlsZWApIHwgRXhhbXBsZTogYEgxMDBgIHwKfCBgLS1p" + - "bnN0YW5jZS10eXBlIFRZUEVgIHwgSW5zdGFuY2UgdHlwZSAocmVxdWlyZWQgd2l0aG91dCBgLS1p" + - "bnB1dC1maWxlYCkgfCBFeGFtcGxlOiBgTkNQLkdQVS5IMTAwXzF4YCB8CnwgYC0taW1hZ2UgSU1B" + - "R0VgIHwgQ29udGFpbmVyIGltYWdlIHwgTXV0dWFsbHkgZXhjbHVzaXZlIHdpdGggYC0taGVsbS1j" + - "aGFydGAgfAp8IGAtLWhlbG0tY2hhcnQgQ0hBUlRgIHwgSGVsbSBjaGFydCBVUkwgb3IgT0NJIHJl" + - "ZmVyZW5jZSB8IE11dHVhbGx5IGV4Y2x1c2l2ZSB3aXRoIGAtLWltYWdlYCB8CnwgYC0taW5wdXQt" + - "ZmlsZSBGSUxFYCB8IEpTT04gdGFzayBzcGVjIGZpbGUgfCBDTEkgZmxhZ3Mgb3ZlcnJpZGUgSlNP" + - "TiB2YWx1ZXMgd2hlbiBib3RoIGFyZSBzZXQgfAp8IGAtLWJhY2tlbmQgQkFDS0VORGAgfCBCYWNr" + - "ZW5kIC8gQ1NQIHwgLSB8CnwgYC0tY2x1c3RlcnMgTkFNRVssTkFNRV1gIHwgU3BlY2lmaWMgY2x1" + - "c3RlcnMgd2l0aGluIHRoZSBpbnN0YW5jZSB8IENvbW1hLXNlcGFyYXRlZCB8CnwgYC0tY29udGFp" + - "bmVyLWFyZ3MgQVJHU2AgfCBBcmdzIHBhc3NlZCB3aGVuIGxhdW5jaGluZyB0aGUgY29udGFpbmVy" + - "IHwgU2luZ2xlIHN0cmluZywgZS5nLiBgIi0tZXBvY2hzIDEwIC0tYmF0Y2gtc2l6ZSAzMiJgIHwK" + - "fCBgLS1jb250YWluZXItZW52IE5BTUU9dmFsdWVgIHwgQ29udGFpbmVyIGVudmlyb25tZW50IHZh" + - "cmlhYmxlOyByZXBlYXRhYmxlIHwgLSB8CnwgYC0tc2VjcmV0cyBOQU1FPXZhbHVlYCB8IFNlY3Jl" + - "dCBlbnZpcm9ubWVudCB2YXJpYWJsZTsgcmVwZWF0YWJsZTsgZW5jcnlwdGVkIGF0IHJlc3QgfCAt" + - "IHwKfCBgLS1tYXgtcnVudGltZSBEVVJBVElPTmAgfCBNYXggd2FsbC1jbG9jayBydW4gdGltZSAo" + - "SVNPIDg2MDEsIGUuZy4gYFBUNEhgKSB8IE5vIGRlZmF1bHQ7IG9taXQgZm9yIG5vIHRpbWUgbGlt" + - "aXQgfAp8IGAtLW1heC1xdWV1ZWQgRFVSQVRJT05gIHwgTWF4IHRpbWUgaW4gcXVldWUgYmVmb3Jl" + - "IGNhbmNlbGxhdGlvbiAoSVNPIDg2MDEpIHwgU2VydmVyIGRlZmF1bHQgYFBUNzJIYCB8CnwgYC0t" + - "dGVybWluYXRpb24tZ3JhY2UgRFVSQVRJT05gIHwgR3JhY2UgcGVyaW9kIGFmdGVyIHN0b3Agc2ln" + - "bmFsIChJU08gODYwMSkgfCBTZXJ2ZXIgZGVmYXVsdCBgUFQxSGAgfAp8IGAtLXJlc3VsdC1zdHJh" + - "dGVneSBVUExPQURcfE5PTkVgIHwgSG93IHRvIGhhbmRsZSB0YXNrIG91dHB1dCBhcnRpZmFjdHMg" + - "fCAtIHwKfCBgLS1yZXN1bHRzLWxvY2F0aW9uIExPQ0FUSU9OYCB8IFJlc3VsdCB1cGxvYWQgdGFy" + - "Z2V0LCBmb3JtYXQgYG9yZy1uYW1lL1t0ZWFtLW5hbWUvXW1vZGVsLW5hbWVgOyByZXF1aXJlZCB3" + - "aGVuIGAtLXJlc3VsdC1zdHJhdGVneT1VUExPQURgIHwgLSB8CnwgYC0tbW9kZWxzIE5BTUU6VkVS" + - "U0lPTjpVUklgIHwgTW9kZWwgYXJ0aWZhY3Q7IHJlcGVhdGFibGUgfCAtIHwKfCBgLS1yZXNvdXJj" + - "ZXMgTkFNRTpWRVJTSU9OOlVSSWAgfCBSZXNvdXJjZSBhcnRpZmFjdDsgcmVwZWF0YWJsZSB8IC0g" + - "fAp8IGAtLXRhZ3MgVEFHWyxUQUddYCB8IFRhc2sgdGFncyB8IENvbW1hLXNlcGFyYXRlZCB8Cnwg" + - "YC0tZGVzY3JpcHRpb24gVEVYVGAgfCBUYXNrIGRlc2NyaXB0aW9uIHwgLSB8CnwgYC0tbG9ncy10" + - "ZWxlbWV0cnktaWQgVVVJRGAgfCBMb2dzIHRlbGVtZXRyeSBlbmRwb2ludCBJRCB8IC0gfAp8IGAt" + - "LW1ldHJpY3MtdGVsZW1ldHJ5LWlkIFVVSURgIHwgTWV0cmljcyB0ZWxlbWV0cnkgZW5kcG9pbnQg" + - "SUQgfCAtIHwKfCBgLS10cmFjZXMtdGVsZW1ldHJ5LWlkIFVVSURgIHwgVHJhY2VzIHRlbGVtZXRy" + - "eSBlbmRwb2ludCBJRCB8IC0gfAoKUEsHCPyjkeDGIgAAxiIAAFBLAwQUAAgAAAAAACEAAAAAAAAA" + - "AAAAAAAANwAJAGRhdGEvbnZjZi1zZWxmLW1hbmFnZWQtY2xpL3JlZmVyZW5jZS90cm91Ymxlc2hv" + - "b3RpbmcubWRVVAUAAQCmzhIjIFRyb3VibGVzaG9vdGluZwoKS25vd24gZXJyb3JzIOKGkiBkaWFn" + - "bm9zdGljIGNvbW1hbmQg4oaSIHJlbWVkaWF0aW9uLiBLZWVwIGluIHN5bmMgd2l0aCB0aGUgc3Ry" + - "dWN0dXJlZCBgcGhhc2VfZmFpbGVkYCBldmVudHMgdGhlIENMSSBlbWl0cyAoUkVRLTE1KSDigJQg" + - "ZXZlcnkgZW50cnkgYmVsb3cgc2hvdWxkIG1hcCB0byBhbiBgZXJyQ2F0ZWdvcnlgIGFuZCBhIGBy" + - "ZW1lZGlhdGlvbmAgYXJyYXkuCgojIyBQcmUtZmxpZ2h0Cgp8IFN5bXB0b20gfCBDYXVzZSB8IFJl" + - "bWVkaWF0aW9uIHwKfC0tLXwtLS18LS0tfAp8IGBrdWJlY3RsIG5vdCBvbiBQQVRIYCB8IE9wZXJh" + - "dG9yJ3MgYCRQQVRIYCBkb2Vzbid0IGluY2x1ZGUga3ViZWN0bCB8IEluc3RhbGwga3ViZWN0bCAx" + - "LjI4KzogaHR0cHM6Ly9rdWJlcm5ldGVzLmlvL2RvY3MvdGFza3MvdG9vbHMvaW5zdGFsbC1rdWJl" + - "Y3RsLyB8CnwgYGhlbG1maWxlIG5vdCBvbiBQQVRIYCB8IFNhbWUgfCBodHRwczovL2dpdGh1Yi5j" + - "b20vaGVsbWZpbGUvaGVsbWZpbGUjaW5zdGFsbGF0aW9uIHwKfCBgaGVsbSBub3Qgb24gUEFUSGAg" + - "fCBTYW1lIHwgaHR0cHM6Ly9oZWxtLnNoL2RvY3MvaW50cm8vaW5zdGFsbC8gfAp8IGBHYXRld2F5" + - "IEFQSSBDUkRzIG5vdCBpbnN0YWxsZWRgIHwgZW52b3ktZ2F0ZXdheSBwcmVyZXEgbWlzc2luZyB8" + - "IGBoZWxtIGluc3RhbGwgZWcgb2NpOi8vZG9ja2VyLmlvL2Vudm95cHJveHkvZ2F0ZXdheS1oZWxt" + - "IC0tbmFtZXNwYWNlPWVudm95LWdhdGV3YXktc3lzdGVtIC0tY3JlYXRlLW5hbWVzcGFjZWAgfAp8" + - "IGBkZWZhdWx0IFN0b3JhZ2VDbGFzcyBub3QgYXZhaWxhYmxlYCB8IENsdXN0ZXIgaGFzIG5vIGRl" + - "ZmF1bHQgU0MgfCBBbm5vdGF0ZSBvbmU6IGBrdWJlY3RsIHBhdGNoIHNjIDxuYW1lPiAtcCAneyJt" + - "ZXRhZGF0YSI6eyJhbm5vdGF0aW9ucyI6eyJzdG9yYWdlY2xhc3Mua3ViZXJuZXRlcy5pby9pcy1k" + - "ZWZhdWx0LWNsYXNzIjoidHJ1ZSJ9fX0nYCB8CnwgYEdQVSBvcGVyYXRvciBub3QgaW5zdGFsbGVk" + - "YCAoY29tcHV0ZS1wbGFuZSkgfCBudmlkaWEgR1BVIG9wZXJhdG9yIG1pc3NpbmcgfCBJbnN0YWxs" + - "IHBlciBodHRwczovL2RvY3MubnZpZGlhLmNvbS9kYXRhY2VudGVyL2Nsb3VkLW5hdGl2ZS9ncHUt" + - "b3BlcmF0b3IvbGF0ZXN0L2luc3RhbGwtZ3B1LW9wZXJhdG9yLmh0bWwsIE9SIHVzZSBgZmFrZS1n" + - "cHUtb3BlcmF0b3JgIGZvciBkZXYgfAp8IGBHUFUgbm9kZSBsYWJlbHMgbWlzc2luZ2AgKGNvbXB1" + - "dGUtcGxhbmUpIHwgTm9kZXMgbmVlZCBgbnZpZGlhLmNvbS9ncHUuZmFtaWx5YCBldGMuIHwgU2V0" + - "IGAtLWszcy1ub2RlLWxhYmVsIG52aWRpYS5jb20vZ3B1LmZhbWlseT1ob3BwZXJAYWdlbnQ6TmAg" + - "Zm9yIGszZCB8CgojIyBBdXRoCgp8IFN5bXB0b20gfCBDYXVzZSB8IFJlbWVkaWF0aW9uIHwKfC0t" + - "LXwtLS18LS0tfAp8IGBhZG1pbiB0b2tlbiByZXF1aXJlZGAgKGluaXQgbm90IHJ1bikgfCBObyBg" + - "fi8ubnZjZi1jbGkuc3RhdGVgIGFuZCBgLS10b2tlbmAgbm90IHBhc3NlZCB8IGBudmNmLWNsaSBp" + - "bml0YCAoaW50ZXJhY3RpdmUpIG9yIGAtLXRva2VuPSRKV1QgLS1ub24taW50ZXJhY3RpdmVgIChD" + - "SSkgfAp8IGBTaWduZWQgSldUIHJlamVjdGVkOiBBbm90aGVyIGFsZ29yaXRobSBleHBlY3RlZCwg" + - "b3Igbm8gbWF0Y2hpbmcga2V5KHMpIGZvdW5kYCB8IFN0YWxlIHNlc3Npb24uanNvbiBmcm9tIGEg" + - "ZGlmZmVyZW50IGNvbnRyb2wgcGxhbmUgfCBgcm0gfi8ubnZjZi1jbGkuc3RhdGVgIHRoZW4gYG52" + - "Y2YtY2xpIGluaXRgIGFnYWluIHwKfCBgNDAzIG1pc3NpbmcgcmVxdWVzdGVkIGF1dGhvcml0aWVz" + - "YCAoZnVuY3Rpb24gaW52b2tlKSB8IEFkbWluIHRva2VuIGRvZXNuJ3QgaGF2ZSBgaW52b2tlX2Z1" + - "bmN0aW9uYCBzY29wZSB8IGBudmNmLWNsaSBhcGkta2V5IGdlbmVyYXRlIC0tZGVzY3JpcHRpb249" + - "4oCmYCB0aGVuIHJlLXJ1biBpbnZva2UgfAoKIyMgSW5zdGFsbCAvIGB1cGAKCnwgU3ltcHRvbSB8" + - "IENhdXNlIHwgUmVtZWRpYXRpb24gfAp8LS0tfC0tLXwtLS18CnwgSGVsbSBgdGltZWQgb3V0IHdh" + - "aXRpbmcgZm9yIGNhc3NhbmRyYWAgfCBDYXNzYW5kcmEgU3RhdGVmdWxTZXQgUFZDIHN0dWNrIGBQ" + - "ZW5kaW5nYCB8IENvbmZpcm0gZGVmYXVsdCBTdG9yYWdlQ2xhc3M7IGNoZWNrIGBrdWJlY3RsIGdl" + - "dCBwdixwdmMgLW4gY2Fzc2FuZHJhLXN5c3RlbWAgfAp8IGBJbnZhbGlkIEdQVSAnTkNQLkdQVS5I" + - "MTAwJyBzcGVjaWZpZWRgIChmdW5jdGlvbiBkZXBsb3kpIHwgV3JvbmcgZmllbGQg4oCUIGBncHVg" + - "IGlzIHRoZSBmYW1pbHksIG5vdCB0aGUgU0tVIHwgVXNlIGAiZ3B1IjogIkgxMDAiYCwgYCJpbnN0" + - "YW5jZVR5cGUiOiAiTkNQLkdQVS5IMTAwXzF4ImAgfAp8IGByZWdpb24gbXVzdCBiZSBwcm92aWRl" + - "ZGAgKGNsdXN0ZXIgcmVnaXN0ZXIgLyBpbnN0YWxsIC0tY29tcHV0ZS1wbGFuZSkgfCBgLS1yZWdp" + - "b25gIGVtcHR5ICsgYENMVVNURVJfUkVHSU9OYCBlbnYgZW1wdHkgfCBQYXNzIGAtLXJlZ2lvbj11" + - "cy13ZXN0LTFgIChvciBhbnkgbm9uLWVtcHR5IHZhbHVlKSB8CnwgYHJlcXVpcmVkRW52ICJOQ0Ff" + - "SUQiIGlzIG5vdCBzZXRgIChoZWxtZmlsZSBlcnJvciBkdXJpbmcgY29tcHV0ZS1wbGFuZSBhcHBs" + - "eSkgfCBPbGRlciBudmNmLWNsaSBiZWZvcmUgY29tbWl0IGA2YWE1NzA0YDsgRXh0cmFFbnYgbm90" + - "IHByb3BhZ2F0aW5nIE5DQV9JRCB8IFVwZ3JhZGUgYG52Y2YtY2xpYCB0byBhIHJlbGVhc2UgYWZ0" + - "ZXIgYDZhYTU3MDRgIHwKfCBgbnZjYS1vcGVyYXRvcjogSW1hZ2VQdWxsQmFja09mZmAgZm9yIGBu" + - "dmNhLW9wZXJhdG9yOnBzYXRgIHwgSW1hZ2Ugbm90IGluIGNsdXN0ZXIgcmVnaXN0cnk7IG11bHRp" + - "LWNsdXN0ZXIgYnVpbGQgaXMgbG9jYWwgfCBgazNkIGltYWdlIGltcG9ydCBudmNyLmlvLy4uLi9u" + - "dmNhLW9wZXJhdG9yOnBzYXQgLWMgPGNsdXN0ZXI+YCB8CgojIyBDb21wdXRlLXBsYW5lIHJ1bnRp" + - "bWUKCnwgU3ltcHRvbSB8IENhdXNlIHwgUmVtZWRpYXRpb24gfAp8LS0tfC0tLXwtLS18CnwgTlZD" + - "QSBhZ2VudCBDcmFzaExvb3BCYWNrT2ZmIHdpdGggYEhUVFAgNDAxYCBvbiBgL3YxL252Y2EvY2x1" + - "c3RlcnMvLi4uL3JlZ2lzdGVyYCB8IFN0YWxlIGBvdXQvPGNsdXN0ZXI+LXJlZ2lzdGVyLXZhbHVl" + - "cy55YW1sYCBmcm9tIHByaW9yIHJlZ2lzdGVyOyBjbHVzdGVyIElEIGRvZXNuJ3QgbWF0Y2ggSUNN" + - "UyB8IERlbGV0ZSB0aGUgc3RhbGUgZmlsZTsgcmUtcnVuIGBudmNmLWNsaSBzZWxmLWhvc3RlZCB1" + - "cGAgKGlkZW1wb3RlbnQgcmVnaXN0ZXIgd3JpdGVzIGEgZnJlc2ggZmlsZSkgfAp8IGBObyBjbHVz" + - "dGVyIGZvdW5kIHdpdGggdmFsaWQgSldLUyBmb3IgY2x1c3RlciBJRDogPGlkPmAgKElDTVMgbG9n" + - "KSB8IEpXS1MgaW4gSUNNUyBkb2Vzbid0IG1hdGNoIHdoYXQgY29tcHV0ZS1wbGFuZSBLOHMgaXMg" + - "Y3VycmVudGx5IHNpZ25pbmcgfCBgbnZjZi1jbGkgY2x1c3RlciByb3RhdGUgLS1jbHVzdGVyLWlk" + - "PTxpZD5gIHwKfCBGdW5jdGlvbiBwb2QgYEltYWdlUHVsbEJhY2tPZmZgIGluIGBudmNmLWJhY2tl" + - "bmRgIHwgSW1hZ2UtY3JlZGVudGlhbC1oZWxwZXIgY29uZmlnIG1pc3Npbmcgb3Igd3JvbmcgfCBg" + - "a3ViZWN0bCBkZXNjcmliZSBwb2QgLW4gbnZjZi1iYWNrZW5kIDxwb2Q+YDsgY2hlY2sgdGhlIHB1" + - "bGwgc2VjcmV0IGNvbmZpZyB8CnwgRnVuY3Rpb24gZGVwbG95IHN0dWNrIGBERVBMT1lJTkdgIGZv" + - "ciA+NSBtaW4gfCBOQVRTIHN0cmVhbSBpbml0IGxhZyAoY29sZC1jbHVzdGVyKSDigJQgd2FpdCwg" + - "b3IgY2hlY2sgTkFUUyBhdXRoLWNhbGxvdXQgaGVhbHRoIHwgYGt1YmVjdGwgbG9ncyAtbiBuYXRz" + - "LXN5c3RlbSAtbCBhcHAua3ViZXJuZXRlcy5pby9uYW1lPW5hdHMtYXV0aC1jYWxsb3V0LXNlcnZp" + - "Y2VgIHwKCiMjIFRhc2tzCgp8IFN5bXB0b20gfCBDYXVzZSB8IFJlbWVkaWF0aW9uIHwKfC0tLXwt" + - "LS18LS0tfAp8IGB0YXNrIGNyZWF0ZWAgcmV0dXJucyBgTWlzc2luZyA8VFlQRT4gcmVnaXN0cnkg" + - "Y3JlZGVudGlhbCBmb3IgaG9zdG5hbWVgLCBvciBrZWVwcyB1c2luZyBhIHByZXZpb3VzIGNyZWRl" + - "bnRpYWwgdmFsdWUsIHNob3J0bHkgYWZ0ZXIgYHJlZ2lzdHJ5LWNyZWRlbnRpYWwgYWRkL3VwZGF0" + - "ZS9kZWxldGVgIHdoaWxlIGByZWdpc3RyeS1jcmVkZW50aWFsIGxpc3RgL2BnZXRgIGFscmVhZHkg" + - "c2hvdyB0aGUgbmV3IHZhbHVlIHwgRXhwZWN0ZWQgcHJvcGFnYXRpb24gZGVsYXk6IE5WQ1QgY2Fj" + - "aGVzIHRoZSBhY2NvdW50J3MgcmVnaXN0cnkgY3JlZGVudGlhbHMgd2l0aCBgbnZjdC5udmNmLmNh" + - "Y2hlLXR0bGAgKGRlZmF1bHQgYFBUNU1gLCBhYm91dCA1IG1pbikgYW5kIGFwcGxpZXMgdGhlIGNo" + - "YW5nZSB3aGVuIHRoYXQgY2FjaGVkIGNvcHkgcmVmcmVzaGVzIHwgV2FpdCB1cCB0byBhYm91dCA1" + - "IG1pbiBhbmQgcmV0cnksIG9yIGBrdWJlY3RsIC1uIG52Y2Ygcm9sbG91dCByZXN0YXJ0IGRlcGxv" + - "eW1lbnQvbnZjdC1hcGlgIHRvIGFwcGx5IGltbWVkaWF0ZWx5IHwKUEsHCPOuE4R0EQAAdBEAAFBL" + - "AwQUAAgAAAAAACEAAAAAAAAAAAAAAAAALAAJAGRhdGEvbnZjZi1zZWxmLW1hbmFnZWQtaW5zdGFs" + - "bGF0aW9uL1NLSUxMLm1kVVQFAAEAps4SLS0tCm5hbWU6IG52Y2Ytc2VsZi1tYW5hZ2VkLWluc3Rh" + - "bGxhdGlvbgpkZXNjcmlwdGlvbjogPi0KICBJbnN0YWxsIGFuZCBvcGVyYXRlIE5WQ0Ygc2VsZi1o" + - "b3N0ZWQgY29udHJvbC1wbGFuZSBhbmQgc2VwYXJhdGUgY29tcHV0ZS1wbGFuZQogIHN0YWNrcy4g" + - "Q292ZXJzIEhlbG1maWxlIHZhbHVlcyBhbmQgQ0xJIHByb2ZpbGUgaW5zdGFsbGF0aW9uIGZsb3dz" + - "LCB0ZWFyZG93biwKICB2YWx1ZXMgb3ZlcnJpZGVzLCBwdWxsIHNlY3JldHMsIGFuZCB0cm91Ymxl" + - "c2hvb3RpbmcuIFVzZSBmb3IKICBudmNmLXNlbGYtbWFuYWdlZC1zdGFjaywgbnZjZi1jb21wdXRl" + - "LXBsYW5lLXN0YWNrLCBzcGxpdCBjb21wdXRlLXBsYW5lCiAgaW5zdGFsbGF0aW9uLCBjb250cm9s" + - "LXBsYW5lIGluc3RhbGxhdGlvbiwgQ0xJLWdlbmVyYXRlZCBjb250cm9sLXBsYW5lCiAgcHJvZmls" + - "ZXMsIEhlbG1maWxlLCBzZWxmLW1hbmFnZWQsIG9yIHNlbGYtaG9zdGVkIGRlcGxveW1lbnRzLiBE" + - "byBOT1QgdXNlIGZvcgogIGxvY2FsIGszZCBlbnZpcm9ubWVudHM7IHVzZSB0aGUgbG9jYWwgazNk" + - "IGRldmVsb3BtZW50IHdvcmtmbG93IGluc3RlYWQuCmxpY2Vuc2U6IEFwYWNoZS0yLjAKY29tcGF0" + - "aWJpbGl0eTogUmVxdWlyZXMgaGVsbWZpbGUgPj0gMS4xLjAgPCAxLjIuMCwgaGVsbSA+PSAzLjEy" + - "LCBoZWxtLWRpZmYgcGx1Z2luLCBrdWJlY3RsIG1hdGNoaW5nIGNsdXN0ZXIgdmVyc2lvbgphdXRo" + - "b3I6ICJudmNmLWNvcmUtZW5nIDxudmNmLWNvcmUtZW5nQGV4Y2hhbmdlLm52aWRpYS5jb20+Igp2" + - "ZXJzaW9uOiAiMS4wLjAiCnRhZ3M6IFtudmNmLCBzZWxmLW1hbmFnZWQsIGhlbG1maWxlLCBzZWxm" + - "LWhvc3RlZCwgY29udHJvbC1wbGFuZSwgY29tcHV0ZS1wbGFuZSwgY2xpLXByb2ZpbGUsIGluc3Rh" + - "bGxhdGlvbiwgZGVwbG95bWVudCwgcHVsbC1zZWNyZXRzXQp0b29sczogW1NoZWxsLCBSZWFkLCBF" + - "ZGl0LCBHcmVwLCBHbG9iXQptZXRhZGF0YToKICBpbnRlcm5hbDogZmFsc2UKICBhdXRob3I6ICJu" + - "dmNmLWNvcmUtZW5nIDxudmNmLWNvcmUtZW5nQGV4Y2hhbmdlLm52aWRpYS5jb20+IgogIHZlcnNp" + - "b246ICIxLjAiCiAgdGFnczogW252Y2YsIHNlbGYtbWFuYWdlZCwgaGVsbWZpbGUsIHNlbGYtaG9z" + - "dGVkLCBjb250cm9sLXBsYW5lLCBjb21wdXRlLXBsYW5lLCBjbGktcHJvZmlsZSwgaW5zdGFsbGF0" + - "aW9uLCBkZXBsb3ltZW50LCBwdWxsLXNlY3JldHNdCiAgbGFuZ3VhZ2VzOiBbYmFzaCwgeWFtbF0K" + - "ICBmcmFtZXdvcmtzOiBbaGVsbWZpbGUsIGhlbG0sIGt1YmVjdGxdCiAgZG9tYWluOiBjbG91ZC1p" + - "bmZyYXN0cnVjdHVyZQotLS0KCiMgTlZDRiBTZWxmLU1hbmFnZWQgU3RhY2sgT3BlcmF0aW9ucwoK" + - "T3BlcmF0aW9uYWwgZ3VpZGUgZm9yIG1hdGNoaW5nIE5WQ0YgY29udHJvbC1wbGFuZSBhbmQgY29t" + - "cHV0ZS1wbGFuZSBIZWxtZmlsZSBidW5kbGVzLgoKIyMgSW5zdHJ1Y3Rpb25zCgpVc2UgdGhpcyBz" + - "a2lsbCBmb3IgaW5zdGFsbCwgdXBncmFkZSwgb3IgdGVhcmRvd24gd29yayBpbiBtYXRjaGluZyBg" + - "bnZjZi1zZWxmLW1hbmFnZWQtc3RhY2tgIGFuZCBgbnZjZi1jb21wdXRlLXBsYW5lLXN0YWNrYCBi" + - "dW5kbGVzOyBrZWVwIEhlbG1maWxlIHZhbHVlcyBhbmQgQ0xJIHByb2ZpbGUgaGFuZG9mZnMgc2Vw" + - "YXJhdGUuIEZvciBgZnVuY3Rpb25UeXBlOiAiTExNImAsIHJlYWQgW0xMTSBGdW5jdGlvbiBFbmFi" + - "bGVtZW50XShyZWZlcmVuY2VzL2hlbG1maWxlLXN0cnVjdHVyZS5tZCNsbG0tZnVuY3Rpb24tZW5h" + - "YmxlbWVudCkuCgojIyBQcmVyZXF1aXNpdGVzCgpBc2sgZm9yIHRoZSBleHRyYWN0ZWQgYG52Y2Yt" + - "c2VsZi1tYW5hZ2VkLXN0YWNrYCBwYXRoLiBGb3Igc3BsaXQgaW5zdGFsbGF0aW9uLAphbHNvIHJl" + - "cXVpcmUgdGhlIG1hdGNoaW5nLXZlcnNpb24gYG52Y2YtY29tcHV0ZS1wbGFuZS1zdGFja2AgcGF0" + - "aC4gVmVyaWZ5IGJvdGg6CgpgYGBiYXNoCmxzIDxjb250cm9sLXBsYW5lLXN0YWNrPi9oZWxtZmls" + - "ZS5kLyA8Y29udHJvbC1wbGFuZS1zdGFjaz4vZW52aXJvbm1lbnRzLyA8Y29udHJvbC1wbGFuZS1z" + - "dGFjaz4vc2VjcmV0cy8gPGNvbnRyb2wtcGxhbmUtc3RhY2s+L2dsb2JhbC55YW1sLmdvdG1wbAps" + - "cyA8Y29tcHV0ZS1wbGFuZS1zdGFjaz4vaGVsbWZpbGUuZC8gPGNvbXB1dGUtcGxhbmUtc3RhY2s+" + - "L2Vudmlyb25tZW50cy8gPGNvbXB1dGUtcGxhbmUtc3RhY2s+L2dsb2JhbC55YW1sLmdvdG1wbApg" + - "YGAKCklmIGVpdGhlciBkaXJlY3RvcnkgaXMgbWlzc2luZywgZG93bmxvYWQgbWF0Y2hpbmcgYnVu" + - "ZGxlIHZlcnNpb25zIGZyb20gTkdDOgoKYGBgYmFzaApuZ2MgcmVnaXN0cnkgcmVzb3VyY2UgZG93" + - "bmxvYWQtdmVyc2lvbiA8b3JnPi9udmNmLXNlbGYtbWFuYWdlZC1zdGFjazo8dmVyc2lvbj4Kbmdj" + - "IHJlZ2lzdHJ5IHJlc291cmNlIGRvd25sb2FkLXZlcnNpb24gPG9yZz4vbnZjZi1jb21wdXRlLXBs" + - "YW5lLXN0YWNrOjx2ZXJzaW9uPgpgYGAKCkNvbnRyb2wtcGxhbmUgY29tbWFuZHMgYmVsb3cgYXNz" + - "dW1lIHRoZSBjb250cm9sLXBsYW5lIGJ1bmRsZSByb290LiBTcGxpdC1mbG93CmNvbW1hbmRzIGFu" + - "ZCByb290IHN1YnN0aXR1dGlvbiBhcmUgaW4KW1NwbGl0IENvbXB1dGUtUGxhbmUgSW5zdGFsbGF0" + - "aW9uXShyZWZlcmVuY2VzL2NvbXB1dGUtcGxhbmUtaW5zdGFsbGF0aW9uLm1kKS4KCiMjIEJlZm9y" + - "ZSBZb3UgU3RhcnQKClZlcmlmeSB0b29saW5nIGFuZCBjb250ZXh0IGJlZm9yZSBhbnkgb3BlcmF0" + - "aW9uOgoKYGBgYmFzaApoZWxtZmlsZSAtLXZlcnNpb24gICAjIE11c3QgYmUgMS4xLnggKDEuMi4w" + - "IHJlbW92ZWQgc2VxdWVudGlhbCBtb2RlKQpoZWxtIHZlcnNpb24gICAgICAgICAjIE11c3QgYmUg" + - "Pj0gMy4xMgpoZWxtIHBsdWdpbiBsaXN0ICAgICAjIE11c3QgaW5jbHVkZSBoZWxtLWRpZmYgPj0g" + - "My4xMQprdWJlY3RsIHZlcnNpb24gICAgICAjIENsaWVudCBtdXN0IGJlIHdpdGhpbiAxIG1pbm9y" + - "IHZlcnNpb24gb2YgY2x1c3RlcgpgYGAKCkNvbnRyb2wtcGxhbmUgY29tbWFuZHMgcnVuIGZyb20g" + - "dGhlIGV4dHJhY3RlZCBgbnZjZi1zZWxmLW1hbmFnZWQtc3RhY2svYCByb290OgoKYGBgYmFzaApj" + - "ZCBwYXRoL3RvL252Y2Ytc2VsZi1tYW5hZ2VkLXN0YWNrCmxzIGhlbG1maWxlLmQvIGVudmlyb25t" + - "ZW50cy8gc2VjcmV0cy8gZ2xvYmFsLnlhbWwuZ290bXBsCmBgYAoKSWRlbnRpZnkgdGhlIGVudmly" + - "b25tZW50IGZyb20gYGVudmlyb25tZW50cy88bmFtZT4ueWFtbGAgYW5kCmBzZWNyZXRzLzxuYW1l" + - "Pi1zZWNyZXRzLnlhbWxgOyBmb3IgRUtTLCB1c2UgdGhlIGNhbm9uaWNhbApbQ1NQIEVuZC10by1F" + - "bmQgRXhhbXBsZV0oaHR0cHM6Ly9kb2NzLm52aWRpYS5jb20vbnZjZi92MC42LjAtcmMvY3NwLWVu" + - "ZC10by1lbmQtZXhhbXBsZSkuCgojIyBIb3cgVmFsdWVzIEZsb3cKClVuZGVyc3RhbmRpbmcgdmFs" + - "dWUgcHJlY2VkZW5jZSBwcmV2ZW50cyB0aGUgbW9zdCBjb21tb24gY29uZmlndXJhdGlvbiBtaXN0" + - "YWtlcy4KCmBgYAplbnZpcm9ubWVudHMvYmFzZS55YW1sICAgICAgICAgIChkZWZhdWx0cykKICAg" + - "IC0+IG1lcmdlZCB3aXRoCmVudmlyb25tZW50cy88ZW52Pi55YW1sICAgICAgICAgKHlvdXIgb3Zl" + - "cnJpZGVzKQogICAgLT4gY29uc3VtZWQgYnkKZ2xvYmFsLnlhbWwuZ290bXBsICAgICAgICAgICAg" + - "ICAoR28gdGVtcGxhdGUsIGNvbnN0cnVjdHMgcGVyLWNoYXJ0IHZhbHVlcykKICAgIC0+IGNvbnN1" + - "bWVkIGJ5CnNlY3JldHMvPGVudj4tc2VjcmV0cy55YW1sICAgICAgKHNlbnNpdGl2ZSB2YWx1ZXMp" + - "CiAgICAtPiBvdmVycmlkZGVuIGJ5CnJlbGVhc2UgaW5saW5lIHZhbHVlczogYmxvY2tzICAgKGhp" + - "Z2hlc3QgcHJlY2VkZW5jZSkKYGBgCgpDcml0aWNhbDogYGdsb2JhbC55YW1sLmdvdG1wbGAgb25s" + - "eSBwYXNzZXMgdGhyb3VnaCBzcGVjaWZpYyBrZXlzIHRvIGVhY2ggY2hhcnQgKGltYWdlIHJlZ2lz" + - "dHJpZXMsIG5vZGUgc2VsZWN0b3JzLCBzdG9yYWdlLCByZXBsaWNhIGNvdW50cykuIFNldHRpbmcg" + - "YW4gYXJiaXRyYXJ5IGNoYXJ0IHZhbHVlIGluIHRoZSBlbnZpcm9ubWVudCBmaWxlIHdpbGwgYmUg" + - "c2lsZW50bHkgaWdub3JlZCBpZiBgZ2xvYmFsLnlhbWwuZ290bXBsYCBkb2VzIG5vdCBwcm9wYWdh" + - "dGUgaXQuCgpUbyBvdmVycmlkZSBhcmJpdHJhcnkgY2hhcnQgdmFsdWVzLCB1c2UgYSBoZWxtZmls" + - "ZSByZWxlYXNlIGB2YWx1ZXM6YCBibG9jay4gU2VlIFtPdmVycmlkaW5nIEhlbG0gQ2hhcnQgVmFs" + - "dWVzXSgjb3ZlcnJpZGluZy1oZWxtLWNoYXJ0LXZhbHVlcykuCgojIyBDbGVhbiBJbnN0YWxsYXRp" + - "b24KCiMjIyAxLiBDcmVhdGUgbmFtZXNwYWNlcyBhbmQgaW1hZ2UgcHVsbCBzZWNyZXRzIChpZiB1" + - "c2luZyBhIHByaXZhdGUgcmVnaXN0cnkpCgpgYGBiYXNoCmZvciBucyBpbiBjYXNzYW5kcmEtc3lz" + - "dGVtIG5hdHMtc3lzdGVtIG52Y2YgYXBpLWtleXMgZXNzIHNpcyB2YXVsdC1zeXN0ZW0gY2VydC1t" + - "YW5hZ2VyOyBkbwogIGt1YmVjdGwgY3JlYXRlIG5hbWVzcGFjZSAiJG5zIiAtLWRyeS1ydW49Y2xp" + - "ZW50IC1vIHlhbWwgfCBrdWJlY3RsIGFwcGx5IC1mIC0KZG9uZQoKIyBPbmx5IGlmIHB1bGxpbmcg" + - "ZnJvbSBhIHByaXZhdGUgcmVnaXN0cnkgKGUuZy4sIE5HQyBudmNyLmlvKQpleHBvcnQgTkdDX0FQ" + - "SV9LRVk9Ijx5b3VyLWtleT4iCmZvciBucyBpbiBjYXNzYW5kcmEtc3lzdGVtIG5hdHMtc3lzdGVt" + - "IG52Y2YgYXBpLWtleXMgZXNzIHNpcyB2YXVsdC1zeXN0ZW0gY2VydC1tYW5hZ2VyOyBkbwogIGt1" + - "YmVjdGwgY3JlYXRlIHNlY3JldCBkb2NrZXItcmVnaXN0cnkgbnZjci1jcmVkcyBcCiAgICAtLWRv" + - "Y2tlci1zZXJ2ZXI9bnZjci5pbyBcCiAgICAtLWRvY2tlci11c2VybmFtZT0nJG9hdXRodG9rZW4n" + - "IFwKICAgIC0tZG9ja2VyLXBhc3N3b3JkPSIkTkdDX0FQSV9LRVkiIFwKICAgIC0tbmFtZXNwYWNl" + - "PSIkbnMiIFwKICAgIC0tZHJ5LXJ1bj1jbGllbnQgLW8geWFtbCB8IGt1YmVjdGwgYXBwbHkgLWYg" + - "LQpkb25lCmBgYAoKSWYgdXNpbmcgcHVsbCBzZWNyZXRzLCB5b3UgbXVzdCBhbHNvIGNvbmZpZ3Vy" + - "ZSBlYWNoIGhlbG1maWxlIHJlbGVhc2UgdG8gcmVmZXJlbmNlIHRoZW0uIFNlZSBbSW1hZ2UgUHVs" + - "bCBTZWNyZXRzXSgjaW1hZ2UtcHVsbC1zZWNyZXRzKS4KCiMjIyAyLiBBdXRoZW50aWNhdGUgaGVs" + - "bSB0byB5b3VyIGNoYXJ0IHJlZ2lzdHJ5CgpCb3RoIGBkb2NrZXIgbG9naW5gIEFORCBgaGVsbSBy" + - "ZWdpc3RyeSBsb2dpbmAgYXJlIHJlcXVpcmVkIGZvciBOR0MuIEhlbG1maWxlIHVzZXMgaGVsbSAo" + - "bm90IGRvY2tlcikgdG8gcHVsbCBPQ0kgY2hhcnRzLCBzbyB0aGUgaGVsbSBjcmVkZW50aWFsIHN0" + - "b3JlIG11c3QgYmUgYXV0aGVudGljYXRlZCBzZXBhcmF0ZWx5LgoKYGBgYmFzaAojIE5HQyAtLSBi" + - "b3RoIGNvbW1hbmRzIGFyZSByZXF1aXJlZApkb2NrZXIgbG9naW4gbnZjci5pbyAtdSAnJG9hdXRo" + - "dG9rZW4nIC1wICIkTkdDX0FQSV9LRVkiCmhlbG0gcmVnaXN0cnkgbG9naW4gbnZjci5pbyAtdSAn" + - "JG9hdXRodG9rZW4nIC1wICIkTkdDX0FQSV9LRVkiCgojIEVDUgphd3MgZWNyIGdldC1sb2dpbi1w" + - "YXNzd29yZCAtLXJlZ2lvbiA8cmVnaW9uPiB8IFwKICBoZWxtIHJlZ2lzdHJ5IGxvZ2luIC0tdXNl" + - "cm5hbWUgQVdTIC0tcGFzc3dvcmQtc3RkaW4gPGFjY291bnQ+LmRrci5lY3IuPHJlZ2lvbj4uYW1h" + - "em9uYXdzLmNvbQpgYGAKCj4gTm90ZTogYGhlbG0gcmVnaXN0cnkgbG9naW5gIGtlZXBzIG9ubHkg" + - "dGhlIGxhc3QgbG9naW4gcGVyIGhvc3QgKG11bHRpLW9yZyBnb3RjaGEpLgo+IFRoZSBzdGFjayBh" + - "bmQgdGhlIGNhY2hlcyBzcGFuIHNldmVyYWwgTkdDIG9yZ3MgdGhhdCBuZWVkIGRpZmZlcmVudCBr" + - "ZXlzLCBidXQgdGhleSBhbGwKPiBsaXZlIHVuZGVyIHRoZSBvbmUgaG9zdCBgbnZjci5pb2AuIEEg" + - "c2Vjb25kIGBoZWxtIHJlZ2lzdHJ5IGxvZ2luIG52Y3IuaW9gIChvcgo+IGBkb2NrZXIgbG9naW5g" + - "KSB3aXRoIGEgZGlmZmVyZW50IGtleSBzaWxlbnRseSBvdmVyd3JpdGVzIHRoZSBmaXJzdCwgc28g" + - "cHVsbHMgZm9yIHRoZQo+IGZpcnN0IG9yZyB0aGVuIGZhaWwgd2l0aCBhIG1pc2xlYWRpbmcgYDQw" + - "MyBBY2Nlc3MgRGVuaWVkYCAobm90IGEgNDAxOiB0aGUgYXV0aAo+IHN1Y2NlZWRlZCwgaXQncyB0" + - "aGUgd3Jvbmctb3JnIGtleSkuIElmIHlvdSBwdWxsIGNoYXJ0cy9pbWFnZXMgZnJvbSBtb3JlIHRo" + - "YW4gb25lIG9yZywKPiBlaXRoZXIgcmUtcnVuIHRoZSBsb2dpbiB3aXRoIHRoZSBjb3JyZWN0IGtl" + - "eSBpbW1lZGlhdGVseSBiZWZvcmUgZWFjaCBwdWxsLCBvciBwYXNzCj4gYC0tdXNlcm5hbWUgJyRv" + - "YXV0aHRva2VuJyAtLXBhc3N3b3JkIDxrZXk+YCBwZXIgYGhlbG0gcHVsbGAgaW52b2NhdGlvbiBp" + - "bnN0ZWFkIG9mIHJlbHlpbmcKPiBvbiB0aGUgc3RvcmVkIGxvZ2luLiAoUHVsbGluZyBldmVyeXRo" + - "aW5nIGZyb20gYSBzaW5nbGUgcmVnaXN0cnkgbWlycm9yIGF2b2lkcyB0aGlzCj4gZW50aXJlbHku" + - "KQoKIyMjIDJiLiAoUmVjb21tZW5kZWQpIFB1bGwgZnJvbSBhIHJlZ2lzdHJ5IHRoZSBjbHVzdGVy" + - "IGF1dGhlbnRpY2F0ZXMgdG8gYXV0b21hdGljYWxseQoKSWYgeW91IG1pcnJvciB0aGUgTlZDRiBp" + - "bWFnZXMgaW50byBhIHJlZ2lzdHJ5IHRoYXQgdGhlIGNsdXN0ZXIgY2FuIHB1bGwgZnJvbSB3aXRo" + - "b3V0IGFuCmV4cGxpY2l0IGltYWdlIHB1bGwgc2VjcmV0IChmb3IgZXhhbXBsZSwgYSByZWdpc3Ry" + - "eSB3aGVyZSB0aGUgbm9kZSBvciB3b3JrbG9hZCBpZGVudGl0eSBpcwpncmFudGVkIHB1bGwgYWNj" + - "ZXNzIGF1dG9tYXRpY2FsbHkpLCBwb2ludCB0aGUgc3RhY2sgYXQgaXQgYW5kIHNraXAgdGhlIGNy" + - "ZWRlbnRpYWwgc3RlcHMKYWJvdmUuCgoxLiBQb2ludCB0aGUgc3RhY2sgYXQgdGhlIG1pcnJvciBp" + - "biBgZW52aXJvbm1lbnRzLzxlbnY+LnlhbWxgOgoKICAgYGBgeWFtbAogICBnbG9iYWw6CiAgICAg" + - "aW1hZ2U6CiAgICAgICByZWdpc3RyeTogPHlvdXItcmVnaXN0cnk+ICAgICAgICAgICAgIyBlLmcu" + - "IHJlZ2lzdHJ5LmV4YW1wbGUuY29tCiAgICAgICByZXBvc2l0b3J5OiA8bWlycm9yLXN1Yi1wYXRo" + - "PgogICAgIGhlbG06CiAgICAgICBzb3VyY2VzOiAgICAgICAgICAgICAgICAgICAgICAgICAgICAg" + - "ICMgb25seSBpZiB5b3UgYWxzbyBtaXJyb3JlZCB0aGUgaGVsbSBjaGFydHMKICAgICAgICAgcmVn" + - "aXN0cnk6IDx5b3VyLXJlZ2lzdHJ5PgogICAgICAgICByZXBvc2l0b3J5OiA8bWlycm9yLXN1Yi1w" + - "YXRoPgogICBgYGAKCiAgID4gVGhlIG1hbmlmZXN0IGhhcyBhIG1peCBvZiBPQ0kgYW5kIG5vbi1P" + - "Q0kgYXJ0aWZhY3RzLCBzbyBjb252ZXJ0IG5vbi1PQ0kgY2hhcnRzIGJlZm9yZQogICA+IG1pcnJv" + - "cmluZy4gQ29udGFpbmVyIGltYWdlcyAoYG52Y3IuaW8vLi4uYCkgYXJlIGFscmVhZHkgT0NJIGFu" + - "ZCBtaXJyb3IgYXMtaXMuIFNvbWUgSGVsbQogICA+IGNoYXJ0cywgdGhvdWdoLCBhcmUgcHVibGlz" + - "aGVkIHRvIGFuIGBodHRwczovL2AgSGVsbSByZXBvc2l0b3J5IChmb3IgZXhhbXBsZQogICA+IGBo" + - "ZWxtLm5nYy5udmlkaWEuY29tYCkuIFRob3NlIGFyZSBub3QgT0NJIGFuZCBjYW5ub3QgYmUgcmVz" + - "b2x2ZWQgYnkgYGdsb2JhbC5oZWxtLnNvdXJjZXNgCiAgID4gKE9DSSkgb3IgbWlycm9yZWQgZGly" + - "ZWN0bHkuIEJlZm9yZSBwb2ludGluZyB0aGUgc3RhY2sgYXQgeW91ciBtaXJyb3IsIGNvbnZlcnQg" + - "ZWFjaAogICA+IGBodHRwczovL2AgY2hhcnQgdG8gT0NJOiBgaGVsbSByZXBvIGFkZGAvYGhlbG0g" + - "cHVsbGAgdGhlIGAudGd6YCwgdGhlbgogICA+IGBoZWxtIHB1c2ggPGNoYXJ0Pi50Z3ogb2NpOi8v" + - "PHlvdXItcmVnaXN0cnk+LzxtaXJyb3Itc3ViLXBhdGg+YC4gT25seSBPQ0kgY2hhcnRzIGNhbiBs" + - "aXZlCiAgID4gdW5kZXIgYGdsb2JhbC5oZWxtLnNvdXJjZXNgLgoKMi4gU2tpcCB0aGUgY3JlZGVu" + - "dGlhbCBzdGVwcyBhYm92ZS4gV2hlbiB0aGUgY2x1c3RlciBhdXRoZW50aWNhdGVzIHRvIHRoZSBy" + - "ZWdpc3RyeQogICBhdXRvbWF0aWNhbGx5ICh0aGUgbm9kZSBvciB3b3JrbG9hZCBpZGVudGl0eSBo" + - "YXMgcHVsbCBhY2Nlc3MpLCB0aGUgcHVsbCBuZWVkcyBubwogICBLdWJlcm5ldGVzIHNlY3JldCwg" + - "c28geW91IGRvIG5vdCBuZWVkOiB0aGUgcGVyLW5hbWVzcGFjZSBgbnZjci1jcmVkc2AgZnJvbSBz" + - "dGVwIDEKICAgKHN0aWxsIGNyZWF0ZSB0aGUgbmFtZXNwYWNlcywganVzdCBub3QgdGhlIHNlY3Jl" + - "dCksIHRoZSBgZ2xvYmFsLmltYWdlUHVsbFNlY3JldHNgIGVudHJ5LAogICBvciB0aGUgYGRvY2tl" + - "ciBsb2dpbmAvYGhlbG0gcmVnaXN0cnkgbG9naW4gbnZjci5pb2AgZnJvbSBzdGVwIDIuCgogICA+" + - "IE9uZSByZXNpZHVhbCBjcmVkZW50aWFsOiBudmNmLWFwaSBzdGlsbCB2YWxpZGF0ZXMgdGhlIHVz" + - "ZXIgZnVuY3Rpb24gaW1hZ2UgYXQKICAgPiBgZnVuY3Rpb24gY3JlYXRlYCB2aWEgdGhlIGFjY291" + - "bnQgcmVnaXN0cnkgY3JlZGVudGlhbCwgc28gdGhhdCBjcmVkZW50aWFsIG11c3QgcG9pbnQgYXQK" + - "ICAgPiB3aGljaGV2ZXIgcmVnaXN0cnkgaG9sZHMgdGhlIHVzZXIgaW1hZ2UgKHNldCBpdCB0byB5" + - "b3VyIG1pcnJvciBpZiB0aGUgaW1hZ2UgaXMgbWlycm9yZWQKICAgPiB0aGVyZSkuCgojIyMgMy4g" + - "U2V0IHRoZSByb3V0ZSBkb21haW4KCmBnbG9iYWwuZG9tYWluYCBzZXRzIHRoZSBob3N0bmFtZSBz" + - "dWZmaXggZm9yIHJvdXRlcyBzdWNoIGFzIGBhcGkuPGRvbWFpbj5gLiBJdCBkb2VzIG5vdCBjb25m" + - "aWd1cmUgdGhlIEdhdGV3YXkgb3IgaXRzIGxvYWQgYmFsYW5jZXIuIFF1ZXJ5IHRoZSBleGFjdCBl" + - "eGlzdGluZyBHYXRld2F5OgoKYGBgYmFzaApHQVRFV0FZX0FERFJFU1M9JChrdWJlY3RsIGdldCBn" + - "YXRld2F5IDxnYXRld2F5LW5hbWU+IC1uIDxnYXRld2F5LW5hbWVzcGFjZT4gLW8ganNvbnBhdGg9" + - "J3suc3RhdHVzLmFkZHJlc3Nlc1swXS52YWx1ZX0nKQp0ZXN0IC1uICIkR0FURVdBWV9BRERSRVNT" + - "IgpgYGAKClRoZSBhZGRyZXNzIG1heSBiZSBhIGhvc3RuYW1lIG9yIElQLiBDbG91ZCBwcm92aWRl" + - "ciBhbmQgR2F0ZXdheSBjb25maWd1cmF0aW9uIGRldGVybWluZSB0aGUgbG9hZCBiYWxhbmNlciB0" + - "eXBlIGFuZCBhZGRyZXNzIGZvcm1hdC4gVGhlIHNlbGYtbWFuYWdlZCBzdGFjayBkb2VzIG5vdCBz" + - "ZWxlY3QgZWl0aGVyLgoKRm9yIHRlbXBvcmFyeSB0ZXN0aW5nIHdpdGhvdXQgRE5TLCB1c2UgYSBz" + - "dGFibGUgcmVzZXJ2ZWQgc3VmZml4IHN1Y2ggYXMgYGdsb2JhbC5kb21haW46ICJudmNmLnRlc3Qi" + - "YCwgY29ubmVjdCB0byBgR0FURVdBWV9BRERSRVNTYCwgYW5kIHNlbmQgYEhvc3Q6IGFwaS5udmNm" + - "LnRlc3RgLiBGb3IgcHJvZHVjdGlvbiwgdXNlIHlvdXIgYmFzZSBETlMgZG9tYWluIGFuZCBwb2lu" + - "dCBpdHMgcm91dGUgcmVjb3JkcyB0byBgR0FURVdBWV9BRERSRVNTYC4gSWYgdGhlIGVuZHBvaW50" + - "IGxhdGVyIGNoYW5nZXMsIGtlZXAgYGdsb2JhbC5kb21haW5gIHN0YWJsZSBhbmQgdXBkYXRlIG9u" + - "bHkgRE5TIG9yIHRoZSBjbGllbnQgZGVzdGluYXRpb24uIFNlZSBFeGFtcGxlIDQgaW4gW2V4YW1w" + - "bGVzLm1kXShleGFtcGxlcy5tZCkuCgojIyMgNC4gUHJldmlldyBhbmQgZGVwbG95CgpgYGBiYXNo" + - "CkhFTE1GSUxFX0VOVj08ZW52LW5hbWU+IGhlbG1maWxlIHRlbXBsYXRlICAgIyBQcmV2aWV3IHJl" + - "bmRlcmVkIG1hbmlmZXN0cwpIRUxNRklMRV9FTlY9PGVudi1uYW1lPiBoZWxtZmlsZSBzeW5jICAg" + - "ICAgICMgRGVwbG95CmBgYAoKPiBTZXQgQk9USCBDYXNzYW5kcmEgcGFzc3dvcmRzIGluIHRoZSBz" + - "ZWNyZXRzIGZpbGUuIFRoZSBzZWNyZXRzIGZpbGUgZG9jdW1lbnRzCj4gYERFRkFVTFRfQ0FTU0FO" + - "RFJBX1BBU1NXT1JEYCwgYnV0IHRoZSBjYXNzYW5kcmEgY2hhcnQgaGFzIGEgc2Vjb25kIGNyZWRl" + - "bnRpYWwsCj4gYGNhc3NhbmRyYS5zZXJ2aWNlUm9sZVBhc3N3b3JkYCwgdGhhdCBkZWZhdWx0cyB0" + - "byBgY2hAbmczbTNgLiBJZiB5b3Ugc2V0IG9ubHkKPiBgREVGQVVMVF9DQVNTQU5EUkFfUEFTU1dP" + - "UkRgLCB0aGUgc2VydmljZSByb2xlIGtlZXBzIHRoYXQgZGVmYXVsdCBhbmQgZXZlcnkgREItYmFj" + - "a2VkCj4gc2VydmljZSBjcmFzaC1sb29wcyB3aXRoIGBCYWQgY3JlZGVudGlhbHNgIG9uY2UgaXQg" + - "dHJpZXMgdG8gYXV0aGVudGljYXRlLiBTZXQKPiBgY2Fzc2FuZHJhLnNlcnZpY2VSb2xlUGFzc3dv" + - "cmRgIHRvIHRoZSBzYW1lIHZhbHVlIGFzIGBERUZBVUxUX0NBU1NBTkRSQV9QQVNTV09SRGAuCgoj" + - "IyMgNS4gRGVwbG95bWVudCBwaGFzZXMKCkhlbG1maWxlIGRlcGxveXMgaW4gb3JkZXIgd2l0aCBk" + - "ZXBlbmRlbmNpZXM6Cgp8IFBoYXNlIHwgU2VsZWN0b3IgfCBTZXJ2aWNlcyB8IFdhaXQgdGltZSB8" + - "CnwtLS0tLS0tfC0tLS0tLS0tLS18LS0tLS0tLS0tLXwtLS0tLS0tLS0tLXwKfCAxIHwgYHJlbGVh" + - "c2UtZ3JvdXA9ZGVwZW5kZW5jaWVzYCB8IE5BVFMsIE9wZW5CYW8sIENhc3NhbmRyYSB8IDUtMTAg" + - "bWluIHwKfCAyIHwgYHJlbGVhc2UtZ3JvdXA9c2VydmljZXNgIHwgQVBJLCBTSVMsIEVTUywgaW52" + - "b2NhdGlvbiwgZ3JwYy1wcm94eSwgbm90YXJ5LCBhcGkta2V5cywgb3B0aW9uYWwgTExNIGdhdGV3" + - "YXkvcm91dGVyLCBvcHRpb25hbCBWYW5pdHkgR2F0ZXdheSwgTlZDRiBVSSB3aGVuIHRoZSBzdGFj" + - "ayBwYWNrYWdlIGluY2x1ZGVzIHRoZSBhZGRvbiB8IDUtMTAgbWluIHwKfCAzIHwgYHJlbGVhc2Ut" + - "Z3JvdXA9aW5ncmVzc2AgfCBHYXRld2F5IHJvdXRlcyB8IDEtMiBtaW4gfAp8IDQgfCBgcmVsZWFz" + - "ZS1ncm91cD1vYnNlcnZhYmlsaXR5YCB8IE9ic2VydmFiaWxpdHkgc3RhY2sgKGlmIGVuYWJsZWQp" + - "IHwgMS0yIG1pbiB8CgpNb25pdG9yIGluIGEgc2VwYXJhdGUgdGVybWluYWw6CgpgYGBiYXNoCmt1" + - "YmVjdGwgZ2V0IHBvZHMgLUEgLXcKYGBgCgojIyMgNi4gRW5hYmxlIFZhbml0eSBHYXRld2F5IChv" + - "cHRpb25hbCkKClZhbml0eSBHYXRld2F5IGlzIGRpc2FibGVkIGJ5IGRlZmF1bHQgYW5kIGlzIG9u" + - "bHkgbmVlZGVkIGZvciBjdXN0b21lci1mYWNpbmcKaG9zdG5hbWVzIG9yIHBhdGggbWFwcGluZ3Mg" + - "aW4gZnJvbnQgb2YgdGhlIHN0YW5kYXJkIE5WQ0YgQVBJIGFuZCBpbnZvY2F0aW9uCnJvdXRlcy4g" + - "SXQgaXMgYXZhaWxhYmxlIG9ubHkgaW4gc3RhY2sgcGFja2FnZXMgdGhhdCBpbmNsdWRlIHRoZSBW" + - "YW5pdHkgR2F0ZXdheQphZGRvbi4gSWYgdGhlIGV4dHJhY3RlZCBzdGFjayBwYWNrYWdlIGRvZXMg" + - "bm90IGNvbnRhaW4gYSBgdmFuaXR5LWdhdGV3YXlgCnJlbGVhc2UgYW5kIGB2YW5pdHlHYXRld2F5" + - "YCByb3V0ZSB2YWx1ZXMsIHNraXAgdGhlc2UgY29tbWFuZHMgYW5kIHVzZSBhIG5ld2VyCnN0YWNr" + - "IHBhY2thZ2UgdGhhdCBpbmNsdWRlcyB0aGVtLgoKSWYgdGhlIHN0YWNrIHBhY2thZ2UgaW5jbHVk" + - "ZXMgdGhlIGFkZG9uLCBlbmFibGUgaXQgaW4KYGVudmlyb25tZW50cy88ZW52LW5hbWU+LnlhbWxg" + - "OgoKYGBgeWFtbAphZGRvbnM6CiAgdmFuaXR5R2F0ZXdheToKICAgIGVuYWJsZWQ6IHRydWUKICAg" + - "IG1hcHBpbmdDb25maWc6IHt9CmBgYAoKVGhlIGRlZmF1bHQgcm91dGUgaG9zdCBpcyBgdmFuaXR5" + - "Ljxkb21haW4+YCBhbmQgdGhlIGJhY2tlbmQgaXMKYHZhbml0eS1nYXRld2F5Lm52Y2Y6ODA4MGAu" + - "IFB1dCBkZXBsb3ltZW50LXNwZWNpZmljIGhvc3QgYW5kIHBhdGggbWFwcGluZ3MgdW5kZXIKYGFk" + - "ZG9ucy52YW5pdHlHYXRld2F5Lm1hcHBpbmdDb25maWdgLiBJZiB5b3UgbmVlZCBjdXN0b20gdmFu" + - "aXR5IGhvc3RzIGluc3RlYWQgb2YKYHZhbml0eS48ZG9tYWluPmAsIHVzZSB0aGUgcm91dGUgaG9z" + - "dG5hbWUgb3ZlcnJpZGVzIHN1cHBvcnRlZCBieSB0aGUgc3RhY2sKcGFja2FnZSBhbmQgY3JlYXRl" + - "IG1hdGNoaW5nIEROUyByZWNvcmRzLgoKQWZ0ZXIgY29uZmlybWluZyB0aGUgcGFja2FnZSBpbmNs" + - "dWRlcyB0aGUgYHZhbml0eS1nYXRld2F5YCByZWxlYXNlLCBwcmV2aWV3IGFuZAphcHBseSB0aGUg" + - "c2VydmljZSBhbmQgcm91dGU6CgpgYGBiYXNoCkhFTE1GSUxFX0VOVj08ZW52LW5hbWU+IGhlbG1m" + - "aWxlIC0tc2VsZWN0b3IgbmFtZT12YW5pdHktZ2F0ZXdheSB0ZW1wbGF0ZQpIRUxNRklMRV9FTlY9" + - "PGVudi1uYW1lPiBoZWxtZmlsZSAtLXNlbGVjdG9yIG5hbWU9dmFuaXR5LWdhdGV3YXkgc3luYwpI" + - "RUxNRklMRV9FTlY9PGVudi1uYW1lPiBoZWxtZmlsZSAtLXNlbGVjdG9yIHJlbGVhc2UtZ3JvdXA9" + - "aW5ncmVzcyBzeW5jCmBgYAoKVmVyaWZ5IHRoZSByb3V0ZSBvbmx5IHdoZW4gdGhlIGFkZG9uIGlz" + - "IHByZXNlbnQgYW5kIGVuYWJsZWQ6CgpgYGBiYXNoCmt1YmVjdGwgZ2V0IGRlcGxveSxzdmMgLW4g" + - "bnZjZiAtbCBhcHAua3ViZXJuZXRlcy5pby9uYW1lPXZhbml0eS1nYXRld2F5Cmt1YmVjdGwgZ2V0" + - "IGh0dHByb3V0ZSAtQSB8IGdyZXAgLWkgdmFuaXR5CmN1cmwgLUggIkhvc3Q6IHZhbml0eS48ZG9t" + - "YWluPiIgImh0dHA6Ly88Z2F0ZXdheS1hZGRyZXNzPi9oZWFsdGgiCmBgYAoKRG8gbm90IGVuYWJs" + - "ZSBWYW5pdHkgR2F0ZXdheSBmb3Igc3RhbmRhcmQgQVBJLCBBUEkgS2V5cywgaW52b2NhdGlvbiwg" + - "TExNCmludm9jYXRpb24sIG9yIGdSUEMgdHJhZmZpYy4gVGhvc2Ugcm91dGVzIGFyZSBwcm92aWRl" + - "ZCBieSB0aGUgYmFzZSBnYXRld2F5CnJvdXRlcy4KCiMjIyA3LiBFbmFibGUgTlZDRiBVSSAob3B0" + - "aW9uYWwpCgpOVkNGIFVJIGlzIGFuIG9wdGlvbmFsLCBjdXN0b21lci1mYWNpbmcgYWRtaW4tcGFu" + - "ZWwgVUkuIEl0IGlzIGRpc2FibGVkIGJ5CmRlZmF1bHQgYW5kIGF2YWlsYWJsZSBvbmx5IGluIHN0" + - "YWNrIHBhY2thZ2VzIHRoYXQgaW5jbHVkZSB0aGUgTlZDRiBVSSBhZGRvbi4gSWYKeW91ciBleHRy" + - "YWN0ZWQgc3RhY2sgcGFja2FnZSBkb2VzIG5vdCBjb250YWluIGEgYG52Y2YtdWlgIHJlbGVhc2Ug" + - "YW5kIGBudmNmVWlgCnJvdXRlIHZhbHVlcywgc2tpcCB0aGlzIHNlY3Rpb24uIFRoZSBOVkNGIFVJ" + - "IGFkbWluIHBhbmVsIGlzIGN1cnJlbnRseQp1bmF1dGhlbnRpY2F0ZWQ7IGRvIG5vdCBleHBvc2Ug" + - "aXQgdG8gdGhlIHB1YmxpYyBpbnRlcm5ldC4KCkZvciBlbmFibGVtZW50LCBuYW1lc3BhY2UgYW5k" + - "IHB1bGwgc2VjcmV0IHNldHVwLCBhcHBseSwgYW5kIHZlcmlmaWNhdGlvbiBzdGVwcywKc2VlIFtO" + - "VkNGIFVJIEFkZG9uXShyZWZlcmVuY2VzL252Y2YtdWktYWRkb24ubWQpLgoKIyMjIDguIEluc3Rh" + - "bGwgdGhlIHNlcGFyYXRlIGNvbXB1dGUtcGxhbmUgc3RhY2sKClRoZSBjb250cm9sLXBsYW5lIHN0" + - "YWNrIGRvZXMgbm90IGluc3RhbGwgY29tcHV0ZS1wbGFuZSBjb21wb25lbnRzLiBBZnRlciBpdCBp" + - "cyBoZWFsdGh5LCBjaG9vc2UgZXhhY3RseSBvbmUgY29tcHV0ZS1wbGFuZSBoYW5kb2ZmOgoKLSBI" + - "ZWxtZmlsZSB2YWx1ZXMgZmxvdzogYXV0aG9yIHNlcGFyYXRlIGVudmlyb25tZW50IGZpbGVzLCB0" + - "aGVuIHJlZ2lzdGVyIGFuZAogIGluc3RhbGwgd2l0aCB0aGUgY29tcHV0ZS1wbGFuZSBNYWtlZmls" + - "ZS4KLSBDTEkgcHJvZmlsZSBmbG93OiB1c2UgdGhlIHByb2ZpbGUgZ2VuZXJhdGVkIGJ5IHRoZSBD" + - "TEkgY29udHJvbC1wbGFuZSBpbnN0YWxsLAogIHRoZW4gcnVuIHRoZSBjb21wbGV0ZSBDTEkgcmVn" + - "aXN0ZXIgYW5kIGluc3RhbGwgY29tbWFuZHMuCgpEbyBub3QgbWl4IHRoZXNlIGhhbmRvZmZzLiBG" + - "b2xsb3cgW1NwbGl0IENvbXB1dGUtUGxhbmUgSW5zdGFsbGF0aW9uXShyZWZlcmVuY2VzL2NvbXB1" + - "dGUtcGxhbmUtaW5zdGFsbGF0aW9uLm1kKQpmb3IgY29tbWFuZHMsIEVLUyByb3V0aW5nLCBwdWxs" + - "IHNlY3JldHMsIHZlcmlmaWNhdGlvbiwgYW5kIHRlYXJkb3duIG9yZGVyLgoKIyMgQ2xlYW4gVGVh" + - "cmRvd24KCkRlc3Ryb3kgZXZlcnkgY29tcHV0ZSBwbGFuZSBiZWZvcmUgdGhlIGNvbnRyb2wgcGxh" + - "bmUsIHVzaW5nIHRoZSB0ZWFyZG93biBmb3IKdGhlIHNhbWUgaGFuZG9mZjsgc2VlIFtTcGxpdCBD" + - "b21wdXRlLVBsYW5lIEluc3RhbGxhdGlvbl0ocmVmZXJlbmNlcy9jb21wdXRlLXBsYW5lLWluc3Rh" + - "bGxhdGlvbi5tZCN0ZWFyZG93bikuCgpTY29wZTogT25seSBkZXN0cm95IHJlbGVhc2VzIG1hbmFn" + - "ZWQgYnkgdGhpcyBjb250cm9sLXBsYW5lIGhlbG1maWxlIHN0YWNrLiBUaGUgTlZDRiByZWxlYXNl" + - "cyBhcmU6IGBuYXRzYCwgYG9wZW5iYW8tc2VydmVyYCwgYGNhc3NhbmRyYWAsIGBhcGkta2V5c2As" + - "IGBzaXNgLCBgYXBpYCwgYGludm9jYXRpb24tc2VydmljZWAsIGBncnBjLXByb3h5YCwgYGVzcy1h" + - "cGlgLCBgbm90YXJ5LXNlcnZpY2VgLCBvcHRpb25hbCBgdmFuaXR5LWdhdGV3YXlgLCBgbnZjZi11" + - "aWAsIGBhZG1pbi1pc3N1ZXItcHJveHlgLCBhbmQgYGluZ3Jlc3NgOyBgY2VydC1tYW5hZ2VyYCBp" + - "cyBpbmNsdWRlZCBvbmx5IHdoZW4gYGNlcnRNYW5hZ2VyLmVuYWJsZWQ6IHRydWVgLiBUaGUgY29u" + - "dHJvbC1wbGFuZSBuYW1lc3BhY2UgaW52ZW50b3J5IGFsc28gaW5jbHVkZXMgYGNlcnQtbWFuYWdl" + - "cmAsIGJ1dCBkZWZhdWx0IG5hbWVzcGFjZSBjbGVhbnVwIHByZXNlcnZlcyBpdC4gTmFtZXNwYWNl" + - "IHByZXNlcnZhdGlvbiBkb2VzIG5vdCBwcmVzZXJ2ZSB0aGUgSGVsbSByZWxlYXNlLiBFeHRlcm5h" + - "bCBjZXJ0LW1hbmFnZXIgbXVzdCB1c2UgYGNlcnRNYW5hZ2VyLmVuYWJsZWQ6IGZhbHNlYDsgb3Ro" + - "ZXJ3aXNlIEhlbG1maWxlIHRyZWF0cyB0aGUgcmVsZWFzZSBhcyBzdGFjay1tYW5hZ2VkLiBEbyBu" + - "b3QgZGVsZXRlIG90aGVyIGhlbG0gcmVsZWFzZXMgb3IgbmFtZXNwYWNlcyBvbiB0aGUgY2x1c3Rl" + - "ci4KCkJlZm9yZSBjb250cm9sLXBsYW5lIGRlc3Ryb3ksIGlkZW50aWZ5IHdoZXRoZXIgY2VydC1t" + - "YW5hZ2VyIGlzIGV4dGVybmFsLiBGb3IgYW4gZXh0ZXJuYWwgaW5zdGFsbGF0aW9uLCByZXF1aXJl" + - "IGVmZmVjdGl2ZSBgY2VydE1hbmFnZXIuZW5hYmxlZDogZmFsc2VgIGFuZCBhYm9ydCBpZiBpdCBp" + - "cyB0cnVlLiBGb3IgYW4gaW50ZW5kZWQgc3RhY2stbWFuYWdlZCByZWxlYXNlIHdpdGggZWZmZWN0" + - "aXZlIGBjZXJ0TWFuYWdlci5lbmFibGVkOiB0cnVlYCwgdmVyaWZ5IG1hdGNoaW5nIHN0YWNrIEhl" + - "bG0gcmVsZWFzZSBtZXRhZGF0YSBhbmQgYWJvcnQgb24gbWlzc2luZyBvciBtaXNtYXRjaGVkIGV2" + - "aWRlbmNlLiBQcmVzZXJ2ZSB0aGUgbmFtZXNwYWNlIGJ5IGRlZmF1bHQ7IG9ubHkgcGxhbiBpdHMg" + - "cmVtb3ZhbCBhZnRlciB2ZXJpZnlpbmcgbmFtZXNwYWNlIHByb3ZlbmFuY2UgYW5kIGdldHRpbmcg" + - "ZXhwbGljaXQgY29uZmlybWF0aW9uLgoKIyMjIFN0YW5kYXJkIHRlYXJkb3duCgpSdW4gZnJvbSBp" + - "bnNpZGUgdGhlIGBudmNmLXNlbGYtbWFuYWdlZC1zdGFjay9gIGRpcmVjdG9yeToKCmBgYGJhc2gK" + - "SEVMTUZJTEVfRU5WPTxlbnYtbmFtZT4gaGVsbWZpbGUgZGVzdHJveQpgYGAKCiMjIyBEZWxldGUg" + - "bmFtZXNwYWNlcwoKYGBgYmFzaApmb3IgbnMgaW4gY2Fzc2FuZHJhLXN5c3RlbSBuYXRzLXN5c3Rl" + - "bSBudmNmIGFwaS1rZXlzIGVzcyBzaXMgbnZjZi11aSB2YXVsdC1zeXN0ZW07IGRvCiAga3ViZWN0" + - "bCBkZWxldGUgbmFtZXNwYWNlICIkbnMiIC0taWdub3JlLW5vdC1mb3VuZApkb25lCmBgYAoKIyMj" + - "IFZlcmlmeSBjbGVhbgoKYGBgYmFzaAprdWJlY3RsIGdldCBucyB8IGdyZXAgLUUgJyhjYXNzYW5k" + - "cmF8bmF0c3x2YXVsdHxudmNmfGFwaS1rZXlzfGVzc3xzaXMpJwojIFNob3VsZCByZXR1cm4gZW1w" + - "dHkKYGBgCgojIyBPdmVycmlkaW5nIEhlbG0gQ2hhcnQgVmFsdWVzCgojIyMgRW52aXJvbm1lbnQg" + - "ZmlsZSAobGltaXRlZCkKCldvcmtzIG9ubHkgZm9yIGtleXMgdGhhdCBgZ2xvYmFsLnlhbWwuZ290" + - "bXBsYCBwcm9wYWdhdGVzIChlLmcuLCBgY2Fzc2FuZHJhLnJlcGxpY2FDb3VudGAsIGBnbG9iYWwu" + - "c3RvcmFnZUNsYXNzYCwgYGdsb2JhbC5pbWFnZWApLgoKIyMjIFJlbGVhc2UgdmFsdWVzIGJsb2Nr" + - "IChhbnkgY2hhcnQgdmFsdWUpCgpFZGl0IHRoZSByZWxlYXNlIGluIGBoZWxtZmlsZS5kLyoueWFt" + - "bC5nb3RtcGxgIGFuZCBhZGQgYSBgdmFsdWVzOmAgYmxvY2suIEluIHRoZSBleGFtcGxlcyBiZWxv" + - "dywgYDxwcml2YXRlLXZhbHVlcz5gIHJlZmVycyB0byB0aGUgYHNlY3JldHMvYCBkaXJlY3Rvcnkg" + - "YXQgdGhlIGhlbG1maWxlIHN0YWNrIHJvb3QuCgpgYGB5YW1sCi0gbmFtZTogY2Fzc2FuZHJhCiAg" + - "dmVyc2lvbjogMC44LjAKICBjb25kaXRpb246IGNhc3NhbmRyYS5lbmFibGVkCiAgbmFtZXNwYWNl" + - "OiBjYXNzYW5kcmEtc3lzdGVtCiAgPDw6ICpkZXBlbmRlbmN5CiAgdmFsdWVzOgogICAgLSAuLi9n" + - "bG9iYWwueWFtbC5nb3RtcGwKICAgIC0gLi4vPHByaXZhdGUtdmFsdWVzPi97eyByZXF1aXJlZEVu" + - "diAiSEVMTUZJTEVfRU5WIiB9fS1zZWNyZXRzLnlhbWwKICAgIC0gY2Fzc2FuZHJhOgogICAgICAg" + - "IHJlc291cmNlczoKICAgICAgICAgIGxpbWl0czoKICAgICAgICAgICAgY3B1OiAiOCIKICAgICAg" + - "ICAgICAgbWVtb3J5OiA4MTkyTWkKICAgICAgICAgIHJlcXVlc3RzOgogICAgICAgICAgICBjcHU6" + - "ICIyIgogICAgICAgICAgICBtZW1vcnk6IDQwOTZNaQpgYGAKCllBTUwgbWVyZ2UgZ290Y2hhOiBX" + - "aGVuIGEgcmVsZWFzZSB1c2VzIGA8PDogKmRlcGVuZGVuY3lgIG9yIGBpbmhlcml0YCwgc3BlY2lm" + - "eWluZyBgdmFsdWVzOmAgcmVwbGFjZXMgdGhlIHRlbXBsYXRlJ3MgdmFsdWVzIGxpc3QuIFlvdSBt" + - "dXN0IHJlLWluY2x1ZGUgYGdsb2JhbC55YW1sLmdvdG1wbGAgYW5kIHRoZSBzZWNyZXRzIGZpbGUu" + - "CgojIyMgUHJldmlldyBhbmQgYXBwbHkgYSBzaW5nbGUgcmVsZWFzZQoKYGBgYmFzaApIRUxNRklM" + - "RV9FTlY9PGVudj4gaGVsbWZpbGUgLS1zZWxlY3RvciBuYW1lPWNhc3NhbmRyYSB0ZW1wbGF0ZSAg" + - "IyBQcmV2aWV3CkhFTE1GSUxFX0VOVj08ZW52PiBoZWxtZmlsZSAtLXNlbGVjdG9yIG5hbWU9Y2Fz" + - "c2FuZHJhIHN5bmMgICAgICAjIEFwcGx5CmBgYAoKIyMgSW1hZ2UgUHVsbCBTZWNyZXRzCgpUaGVy" + - "ZSBhcmUgdGhyZWUgZGlzdGluY3QgY3JlZGVudGlhbCB0eXBlcy4gRG8gbm90IGNvbmZsYXRlIHRo" + - "ZW0sIGFuZCBtaW5kIHRoZQpmb3JtYXQgcnVsZSBiZWxvdyAodHdvIG9mIHRoZW0gZmFpbCBldmVu" + - "IHdpdGggdGhlIGNvcnJlY3Qga2V5IGlmIHRoZSBmb3JtYXQgaXMgd3JvbmcpOgoKfCB8IENvbnRy" + - "b2wgUGxhbmUgUHVsbCBTZWNyZXRzIHwgQVBJIEJvb3RzdHJhcCBSZWdpc3RyeSBDcmVkcyB8IFNp" + - "ZGVjYXIgSW1hZ2UtUHVsbCBTZWNyZXQgfAp8LS0tfC0tLXwtLS18LS0tfAp8IFB1cnBvc2UgfCBL" + - "OHMgcHVsbHMgTlZDRiBzZXJ2aWNlIGltYWdlcyB8IG52Y2YtYXBpIHZhbGlkYXRlcyB0aGUgdXNl" + - "ciBmdW5jdGlvbiBpbWFnZSBhdCBgZnVuY3Rpb24gY3JlYXRlYCB8IG52Y2YtYXBpIHB1bGxzIHRo" + - "ZSBwbGF0Zm9ybSBzaWRlY2FycyBpbmplY3RlZCBpbnRvIGV2ZXJ5IHdvcmtlciBwb2QgfAp8IFdo" + - "ZXJlIHwgSzhzIGBkb2NrZXItcmVnaXN0cnlgIFNlY3JldHMgKyBLeXZlcm5vIENsdXN0ZXJQb2xp" + - "Y3kgfCBgPHByaXZhdGUtdmFsdWVzPi88ZW52Pi1zZWNyZXRzLnlhbWxgIChhY2NvdW50LWJvb3Rz" + - "dHJhcCkgfCBgTlZDRl9BUElfU0lERUNBUlNfSU1BR0VfUFVMTF9TRUNSRVRgIGluIGA8ZW52Pi1z" + - "ZWNyZXRzLnlhbWxgIC0+IE9wZW5CYW8gYHNlcnZpY2VzL252Y2YtYXBpL2t2L3NpZGVjYXJzL2lt" + - "YWdlLXB1bGwtc2VjcmV0YCAoZmllbGQgYHNlY3JldGApIHwKfCBGb3JtYXQgfCBzdGFuZGFyZCBg" + - "LmRvY2tlcmNvbmZpZ2pzb25gIChrdWJlY3RsIGJ1aWxkcyBpdCBmb3IgeW91KSB8IGBiYXNlNjQo" + - "IiRvYXV0aHRva2VuOjxrZXk+IilgIHwgYGJhc2U2NCgiJG9hdXRodG9rZW46PGtleT4iKWAgfAoK" + - "PiBOb3RlOiB0aGUgYWNjb3VudC1ib290c3RyYXAgY3JlZCBhbmQgdGhlIHNpZGVjYXIgc2VjcmV0" + - "IGFyZSBOT1QgYQo+IGRvY2tlcmNvbmZpZ2pzb24uIFRoZSBzZWNyZXRzIHRlbXBsYXRlIHNoaXBz" + - "IHRoZSBwbGFjZWhvbGRlcgo+IGBSRVBMQUNFX1dJVEhfQkFTRTY0X0RPQ0tFUl9DUkVERU5USUFM" + - "YCwgd2hpY2ggcmVhZHMgYXMgImJhc2U2NCBvZiBhIGRvY2tlcmNvbmZpZ2pzb24uIgo+IEl0IGlz" + - "bid0LiBCb3RoIHZhbHVlcyBhcmUgY29uc3VtZWQgYXMgYSByYXcgZG9ja2VyIGBhdXRoYCBzdHJp" + - "bmc6IG52Y2YtYXBpIHRha2VzIHRoZQo+IHZhbHVlIHZlcmJhdGltIGFuZCBkcm9wcyBpdCBpbnRv" + - "IHRoZSBgYXV0aGAgZmllbGQgb2YgdGhlIGRvY2tlcmNvbmZpZyBpdCBidWlsZHMuIFNvIHRoZQo+" + - "IHZhbHVlIG11c3QgYmUgYGJhc2U2NCgiJG9hdXRodG9rZW46PGtleT4iKWAsIGUuZy4gYHByaW50" + - "ZiAnJG9hdXRodG9rZW46JXMnICIkS0VZIiB8IG9wZW5zc2wgYmFzZTY0IC1BYCwKPiBub3QgYGJh" + - "c2U2NCg8ZG9ja2VyY29uZmlnanNvbj4pYC4KPiAgLSBXcm9uZyBhY2NvdW50LWJvb3RzdHJhcCB2" + - "YWx1ZTogYGZ1bmN0aW9uIGNyZWF0ZWAgcmV0dXJucwo+ICAgIGA0MDAgIm11c3QgYmUgYmFzZTY0" + - "IGVuY29kZWQgdXNlcm5hbWU6cGFzc3dvcmQgZm9ybWF0ImAuCj4gIC0gV3Jvbmcgc2lkZWNhciB2" + - "YWx1ZTogZXZlcnkgd29ya2VyJ3Mgc2lkZWNhciBwdWxsIGdldHMgYSBtYWxmb3JtZWQgY3JlZGVu" + - "dGlhbCBhbmQKPiAgICBgNDAzYHMsIHJlZ2FyZGxlc3Mgb2Ygd2hpY2gga2V5IGlzIGluc2lkZS4g" + - "VGhlIHN5bXB0b20gbG9va3MgbGlrZSBhIGJhZCBvciB3cm9uZy1vcmcKPiAgICBrZXksIGJ1dCB0" + - "aGUga2V5IGlzIGZpbmUgYW5kIHRoZSBlbmNvZGluZyBpcyB0aGUgYnVnLiBUbyByZXBhaXIgYW4g" + - "YWxyZWFkeS1pbnN0YWxsZWQKPiAgICBzdGFjayB3aXRob3V0IGEgZnVsbCByZS1zeW5jOgo+ICAg" + - "IGBgYGJhc2gKPiAgICBBVVRIPSQocHJpbnRmICckb2F1dGh0b2tlbjolcycgIiRLRVkiIHwgb3Bl" + - "bnNzbCBiYXNlNjQgLUEpCj4gICAgYmFvIGt2IHB1dCBzZXJ2aWNlcy9udmNmLWFwaS9rdi9zaWRl" + - "Y2Fycy9pbWFnZS1wdWxsLXNlY3JldCBzZWNyZXQ9IiRBVVRIIgo+ICAgICMgaWYgTlZJRElBIENs" + - "b3VkIFRhc2tzIGlzIGVuYWJsZWQsIHJlcGVhdCBmb3Igc2VydmljZXMvbnZjdC1hcGkva3Yvc2lk" + - "ZWNhcnMvaW1hZ2UtcHVsbC1zZWNyZXQKPiAgICBrdWJlY3RsIHJvbGxvdXQgcmVzdGFydCAtbiBu" + - "dmNmIGRlcGxveS9udmNmLWFwaSAgICMgcGlja3MgdXAgdGhlIG5ldyBzaWRlY2FyIGNyZWQKPiAg" + - "ICBgYGAKCj4gTm90ZSAobXVsdGktb3JnKTogd2hlbiBwdWxsaW5nIGZyb20gTkdDIChub3QgYSBt" + - "aXJyb3IpLCB0aGUgdXNlciBmdW5jdGlvbiBpbWFnZSBhbmQKPiB0aGUgcGxhdGZvcm0gc2lkZWNh" + - "cnMgb2Z0ZW4gbGl2ZSBpbiBkaWZmZXJlbnQgbnZjci5pbyBvcmdzLCBlYWNoIG5lZWRpbmcgYSBk" + - "aWZmZXJlbnQKPiBrZXksIHNvIHRoZSBhY2NvdW50LWJvb3RzdHJhcCBjcmVkIChmdW5jdGlvbiBp" + - "bWFnZSkgYW5kIHRoZSBzaWRlY2FyIHNlY3JldCAoc2lkZWNhcnMpCj4gYXJlIGZyZXF1ZW50bHkg" + - "dHdvIGRpZmZlcmVudCBrZXlzLiBNaXJyb3JpbmcgZXZlcnl0aGluZyBpbnRvIGEgc2luZ2xlIHJl" + - "Z2lzdHJ5IHRoZQo+IGNsdXN0ZXIgYXV0aGVudGljYXRlcyB0byBhdXRvbWF0aWNhbGx5IGNvbGxh" + - "cHNlcyB0aGlzIHRvIG9uZSBjcmVkZW50aWFsIHBhdGguCgojIyMgQ29uZmlndXJpbmcgd2l0aCBL" + - "eXZlcm5vIChyZWNvbW1lbmRlZCkKClVzZSBhIEt5dmVybm8gbXV0YXRpbmcgYWRtaXNzaW9uIHBv" + - "bGljeSB0byBhdXRvbWF0aWNhbGx5IGluamVjdCBgaW1hZ2VQdWxsU2VjcmV0c2AgaW50byBhbGwg" + - "cG9kcyBpbiBOVkNGIG5hbWVzcGFjZXMuIFRoaXMgd29ya3MgdW5pZm9ybWx5IGZvciBhbGwgY2hh" + - "cnRzIC0tIG5vIHBlci1jaGFydCBjb25maWd1cmF0aW9uIG9yIGhlbG1maWxlIG1vZGlmaWNhdGlv" + - "bnMgbmVlZGVkLgoKYGBgYmFzaAojIDEuIEluc3RhbGwgS3l2ZXJubwpoZWxtIHJlcG8gYWRkIGt5" + - "dmVybm8gaHR0cHM6Ly9reXZlcm5vLmdpdGh1Yi5pby9reXZlcm5vLwpoZWxtIHJlcG8gdXBkYXRl" + - "CmhlbG0gaW5zdGFsbCBreXZlcm5vIGt5dmVybm8va3l2ZXJubyAtbiBreXZlcm5vIC0tY3JlYXRl" + - "LW5hbWVzcGFjZQoKIyAyLiBDcmVhdGUgcHVsbCBzZWNyZXQgaW4gZWFjaCBuYW1lc3BhY2UKZXhw" + - "b3J0IE5HQ19BUElfS0VZPSI8eW91ci1rZXk+Igpmb3IgbnMgaW4gY2Fzc2FuZHJhLXN5c3RlbSBu" + - "YXRzLXN5c3RlbSBudmNmIGFwaS1rZXlzIGVzcyBzaXMgdmF1bHQtc3lzdGVtIGNlcnQtbWFuYWdl" + - "cjsgZG8KICBrdWJlY3RsIGNyZWF0ZSBzZWNyZXQgZG9ja2VyLXJlZ2lzdHJ5IG52Y3ItY3JlZHMg" + - "XAogICAgLS1kb2NrZXItc2VydmVyPW52Y3IuaW8gXAogICAgLS1kb2NrZXItdXNlcm5hbWU9JyRv" + - "YXV0aHRva2VuJyBcCiAgICAtLWRvY2tlci1wYXNzd29yZD0iJE5HQ19BUElfS0VZIiBcCiAgICAt" + - "LW5hbWVzcGFjZT0iJG5zIiBcCiAgICAtLWRyeS1ydW49Y2xpZW50IC1vIHlhbWwgfCBrdWJlY3Rs" + - "IGFwcGx5IC1mIC0KZG9uZQoKIyAzLiBBcHBseSB0aGUgS3l2ZXJubyBDbHVzdGVyUG9saWN5Cmt1" + - "YmVjdGwgYXBwbHkgLWYga3l2ZXJuby1pbWFnZXB1bGxzZWNyZXQtcG9saWN5LnlhbWwKYGBgCgpU" + - "aGUgcG9saWN5IG11dGF0ZXMgZXZlcnkgcG9kIGF0IGFkbWlzc2lvbiB0aW1lLCBhZGRpbmcgYGlt" + - "YWdlUHVsbFNlY3JldHM6IFt7bmFtZTogbnZjci1jcmVkc31dYC4gVmVyaWZ5IHdpdGg6CgpgYGBi" + - "YXNoCmt1YmVjdGwgZ2V0IHBvZCAtbiA8bmFtZXNwYWNlPiA8cG9kLW5hbWU+IC1vIGpzb25wYXRo" + - "PSd7LnNwZWMuaW1hZ2VQdWxsU2VjcmV0c30nCiMgU2hvdWxkIHNob3c6IFt7Im5hbWUiOiJudmNy" + - "LWNyZWRzIn1dCmBgYAoKTm90IG5lZWRlZCBpZiB1c2luZyBhIENTUCBidWlsdC1pbiBjcmVkZW50" + - "aWFsIGhlbHBlciAoZS5nLiwgRUNSIHdpdGggSUFNIG5vZGUgcm9sZXMpLgoKRm9yIHRoZSBLeXZl" + - "cm5vIHBvbGljeSBZQU1MIGFuZCBwdWxsIHNlY3JldCBjcmVhdGlvbiBzY3JpcHQsIHNlZSBbcmVm" + - "ZXJlbmNlcy9wdWxsLXNlY3JldHMubWRdKHJlZmVyZW5jZXMvcHVsbC1zZWNyZXRzLm1kKS4KCiMj" + - "IERlYnVnZ2luZwoKIyMjIFF1aWNrIHN0YXR1cyBjaGVjawoKYGBgYmFzaAprdWJlY3RsIGdldCBw" + - "b2RzIC1BIC1vIHdpZGUgICAgICAgICAgICAgICAgICAgICAgICAjIEFsbCBwb2RzCmhlbG0gbGlz" + - "dCAtQSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAjIEFsbCBoZWxtIHJl" + - "bGVhc2VzCmt1YmVjdGwgZ2V0IGV2ZW50cyAtbiA8bnM+IC0tc29ydC1ieT0nLmxhc3RUaW1lc3Rh" + - "bXAnICAjIFJlY2VudCBldmVudHMKYGBgCgojIyMgQ29tbW9uIGZhaWx1cmUgcGF0dGVybnMKCnwg" + - "U3ltcHRvbSB8IENhdXNlIHwgRml4IHwKfC0tLS0tLS0tLXwtLS0tLS0tfC0tLS0tfAp8IGBJbWFn" + - "ZVB1bGxCYWNrT2ZmYCArIGA0MDEgVW5hdXRob3JpemVkYCB8IE1pc3Npbmcgb3Igd3JvbmcgcHVs" + - "bCBzZWNyZXQgfCBDaGVjayBzZWNyZXQgZXhpc3RzLCBjaGVjayBTQSBoYXMgaW1hZ2VQdWxsU2Vj" + - "cmV0cyB8CnwgYEluaXQ6MC8xYCBzdHVjayBvbiBzZXJ2aWNlIHBvZHMgfCBWYXVsdC1hZ2VudCB3" + - "YWl0aW5nIGZvciBPcGVuQmFvIHwgQ2hlY2sgT3BlbkJhbyBwb2RzICsgbWlncmF0aW9uIGpvYiBz" + - "dGF0dXMgfAp8IGBJbml0OjAvMWAgKyBgdmF1bHQtYWdlbnQtaW5pdGAgc2hvd3MgYGF1dGgvand0" + - "L2xvZ2luYCAtPiBgNDAwIC4uLiBubyBrbm93biBrZXkgc3VjY2Vzc2Z1bGx5IHZhbGlkYXRlZCB0" + - "aGUgdG9rZW4gc2lnbmF0dXJlYCB8IE9wZW5CYW8gSldUIGF1dGggY29uZmlndXJlZCB3aXRoIGEg" + - "c3RhdGljIHB1YmtleSBpbnN0ZWFkIG9mIHRoZSBjbHVzdGVyJ3MgbGl2ZSBKV0tTIC0tIHRoZSBi" + - "YXNlIGRlZmF1bHQgYG9wZW5iYW8ubWlncmF0aW9ucy5pc3N1ZXJEaXNjb3ZlcnkuZW5hYmxlZDog" + - "ZmFsc2VgLiBDb21tb24gb24gQUtTIC8gYW55IE9JREMtaXNzdWVyIGNsdXN0ZXIgfCBTZXQgYG9w" + - "ZW5iYW8ubWlncmF0aW9ucy5pc3N1ZXJEaXNjb3ZlcnkuZW5hYmxlZDogdHJ1ZWAsIGRlbGV0ZSBq" + - "b2IgYG9wZW5iYW8tc2VydmVyLW1pZ3JhdGlvbnNgLCByZS1zeW5jIGBvcGVuYmFvLXNlcnZlcmAu" + - "IFNlZSBbcmVmZXJlbmNlcy9kZWJ1Z2dpbmcubWRdKHJlZmVyZW5jZXMvZGVidWdnaW5nLm1kKSAi" + - "SW5pdDowLzEgU3R1Y2siIGZpeCAjNC4gfAp8IGBPT01LaWxsZWRgIG9uIENhc3NhbmRyYSB8IERl" + - "ZmF1bHQgcmVzb3VyY2VzIHRvbyBzbWFsbCB8IE92ZXJyaWRlIGBjYXNzYW5kcmEucmVzb3VyY2Vz" + - "YCB2aWEgdmFsdWVzIGJsb2NrIHwKfCBEQi1iYWNrZWQgc2VydmljZXMgY3Jhc2gtbG9vcCBgQmFk" + - "IGNyZWRlbnRpYWxzYCBjb25uZWN0aW5nIHRvIENhc3NhbmRyYSB8IFNlY3JldHMgZmlsZSBzZXQg" + - "b25seSBgREVGQVVMVF9DQVNTQU5EUkFfUEFTU1dPUkRgOyBgY2Fzc2FuZHJhLnNlcnZpY2VSb2xl" + - "UGFzc3dvcmRgIHN0aWxsIGRlZmF1bHRzIHRvIGBjaEBuZzNtM2AgfCBTZXQgYGNhc3NhbmRyYS5z" + - "ZXJ2aWNlUm9sZVBhc3N3b3JkYCBpbiB0aGUgc2VjcmV0cyBmaWxlIGVxdWFsIHRvIGBERUZBVUxU" + - "X0NBU1NBTkRSQV9QQVNTV09SRGAsIHRoZW4gcmUtc3luYyBjYXNzYW5kcmEgKyB0aGUgREItYmFj" + - "a2VkIHNlcnZpY2VzIHwKfCBgUGVuZGluZ2AgcG9kcyB8IE5vZGUgc2VsZWN0b3IgbWlzbWF0Y2gg" + - "b3Igbm8gc3RvcmFnZSBjbGFzcyB8IGBrdWJlY3RsIGRlc2NyaWJlIHBvZGAsIGNoZWNrIGxhYmVs" + - "cyBhbmQgc3RvcmFnZSB8CnwgSGVsbSByZWxlYXNlIGluIGBmYWlsZWRgIHN0YXRlIHwgRmlyc3Qg" + - "aW5zdGFsbCBmYWlsZWQgcGFydHdheSB8IGBoZWxtZmlsZSBkZXN0cm95YCB0aGUgcmVsZWFzZSwg" + - "dGhlbiBgc3luY2AgYWdhaW4gfAp8IEFjY291bnQgYm9vdHN0cmFwIHRpbWVvdXQgfCBXcm9uZyBi" + - "YXNlNjQgY3JlZGVudGlhbHMgaW4gc2VjcmV0cyBmaWxlIHwgQ2hlY2sgYGt1YmVjdGwgbG9ncyBq" + - "b2IvbnZjZi1hcGktYWNjb3VudC1ib290c3RyYXAgLW4gbnZjZmAgfAp8IGZ1bmN0aW9uIC8gYWNj" + - "b3VudCBjYWxscyByZXR1cm4gYDQwNCBVbmtub3duIGNsaWVudF9pZGAgfCBUaGUgYWNjb3VudC1i" + - "b290c3RyYXAgcG9zdC1pbnN0YWxsIGhvb2sgbmV2ZXIgcmFuOiB0aGUgYGFwaWAgcmVsZWFzZSBp" + - "bnN0YWxsIGZhaWxlZCwgb3Igd2FzIHJlcGFpcmVkIHdpdGggbGl2ZSBwYXRjaGVzIGluc3RlYWQg" + - "b2YgYSBjbGVhbiByZS1zeW5jLCBzbyB0aGUgaG9vayAoYW5kIHRoZSBhY2NvdW50KSB3YXMgc2tp" + - "cHBlZCB8IFZlcmlmeSBhbmQgcmUtcnVuIHRoZSBob29rOyBzZWUgW1ZlcmlmeSB0aGUgYWNjb3Vu" + - "dCBib290c3RyYXAgcmFuXSgjdmVyaWZ5LXRoZS1hY2NvdW50LWJvb3RzdHJhcC1yYW4pIHwKfCBT" + - "ZXJ2aWNlcyBmYWlsIHRvIHJlYWQgdmF1bHQgc2VjcmV0czsgYHNlY3JldHMuanNvbmAgbm90IGZv" + - "dW5kIHwgVmF1bHQgcGF0aCBoYXJkY29kZWQgdG8gYC9ob21lL2FwcC92YXVsdC9gIGluIGBfaGVs" + - "cGVycy50cGxgOyB0aGUgcnVudGltZSByZXNvbHZlcyB0aGUgbW91bnRlZCBwYXRoIHJlbGF0aXZl" + - "IHRvIHRoZSB3b3JraW5nIGRpcmVjdG9yeSBhbmQgZHJvcHMgdGhlIGxlYWRpbmcgYC9gIHwgT3Zl" + - "cnJpZGUgYHBvZEFubm90YXRpb25zYCBhbmQgc2V0IGBKQVZBX1RPT0xfT1BUSU9OUzogIi1EdXNl" + - "ci5kaXI9LyJgIGluIHJlbGVhc2UgdmFsdWVzIHwKfCBOQVRTIGNvbm5lY3Rpb24gZmFpbHMgYXQg" + - "c3RhcnR1cDsgcGxhY2VtZW50IHRhZyBtaXNtYXRjaCB8IE5BVFMgc2VydmVyIHRhZ3MgaGFyZGNv" + - "ZGVkIHRvIGBkYzpuY3BgOyBhcHAgZGVyaXZlcyB0YWcgZnJvbSBgQVdTX1JFR0lPTmAgKGUuZy4s" + - "IGB1cy1nb3Ytd2VzdC0xYCkgfCBTZXQgYEFXU19SRUdJT049bmNwYCBhbmQgYE5WQ0ZfQVdTX1JF" + - "R0lPTj1uY3BgIGluIGVudiBjb25maWcgfAoKIyMjIFZlcmlmeSB0aGUgYWNjb3VudCBib290c3Ry" + - "YXAgcmFuCgpUaGUgZGVmYXVsdCBhY2NvdW50IGlzIGNyZWF0ZWQgYnkgYSAqKmBwb3N0LWluc3Rh" + - "bGxgIGhvb2sgb24gdGhlIGBhcGlgIHJlbGVhc2UqKgooYGpvYi9udmNmLWFwaS1hY2NvdW50LWJv" + - "b3RzdHJhcGAgaW4gYG52Y2ZgKS4gQmVjYXVzZSBpdCBpcyBhIHBvc3QtaW5zdGFsbCBob29rLCBp" + - "dCBvbmx5CmZpcmVzIG9uIGEgc3VjY2Vzc2Z1bCBgYXBpYCBpbnN0YWxsLiBJZiB0aGF0IGluc3Rh" + - "bGwgZmFpbGVkIGFuZCB5b3UgcmVwYWlyZWQgaXQgd2l0aCBsaXZlCnBhdGNoZXMgKHJhdGhlciB0" + - "aGFuIGEgY2xlYW4gcmUtc3luYyksIHRoZSBob29rIG5ldmVyIHJ1bnMsIG5vIGFjY291bnQgaXMg" + - "Y3JlYXRlZCwgYW5kCmV2ZXJ5IHN1YnNlcXVlbnQgZnVuY3Rpb24vYWNjb3VudCBjYWxsIHJldHVy" + - "bnMgYSBjcnlwdGljIGA0MDQgVW5rbm93biBjbGllbnRfaWRgIHdpdGgKbm90aGluZyBvYnZpb3Vz" + - "bHkgd3JvbmcgaW4gdGhlIHJ1bm5pbmcgcG9kcy4KClZlcmlmeSBpdCByYW4gYWZ0ZXIgdGhlIGZp" + - "cnN0IHN5bmM6CgpgYGBiYXNoCmt1YmVjdGwgZ2V0IGpvYiAtbiBudmNmIG52Y2YtYXBpLWFjY291" + - "bnQtYm9vdHN0cmFwIFwKICAtbyBqc29ucGF0aD0ney5zdGF0dXMuc3VjY2VlZGVkfScgICAjIGV4" + - "cGVjdCAxCmBgYAoKSWYgdGhlIGpvYiBpcyBhYnNlbnQgb3IgYDBgLCByZS1ydW4gaXQgYnkgcmUt" + - "c3luY2luZyB0aGUgYGFwaWAgcmVsZWFzZSBzbyB0aGUgaG9vayBmaXJlcwphZ2FpbiAoZGVsZXRl" + - "IHRoZSBwcmlvciBqb2IgZmlyc3QgaWYgaXQgbGluZ2VycyBpbiBhIGNvbXBsZXRlZC9mYWlsZWQg" + - "c3RhdGUgYW5kIGJsb2NrcyB0aGUKaG9vayk6CgpgYGBiYXNoCmt1YmVjdGwgZGVsZXRlIGpvYiAt" + - "biBudmNmIG52Y2YtYXBpLWFjY291bnQtYm9vdHN0cmFwIC0taWdub3JlLW5vdC1mb3VuZApIRUxN" + - "RklMRV9FTlY9PGVudj4gaGVsbWZpbGUgLS1zZWxlY3RvciBuYW1lPWFwaSBzeW5jCmt1YmVjdGwg" + - "bG9ncyAtbiBudmNmIGpvYi9udmNmLWFwaS1hY2NvdW50LWJvb3RzdHJhcCAgICMgY29uZmlybSB0" + - "aGUgYWNjb3VudCB3YXMgY3JlYXRlZApgYGAKCiMjIEFkZGl0aW9uYWwgUmVzb3VyY2VzCgotIElu" + - "c3RhbGxhdGlvbjogW2V4YW1wbGVzLm1kXShleGFtcGxlcy5tZCksIHRoZSBbQ1NQIEVuZC10by1F" + - "bmQgRXhhbXBsZV0oaHR0cHM6Ly9kb2NzLm52aWRpYS5jb20vbnZjZi92MC42LjAtcmMvY3NwLWVu" + - "ZC10by1lbmQtZXhhbXBsZSksIGFuZCBbc3BsaXQgY29tcHV0ZS1wbGFuZSB3b3JrZmxvd3NdKHJl" + - "ZmVyZW5jZXMvY29tcHV0ZS1wbGFuZS1pbnN0YWxsYXRpb24ubWQpCi0gT3BlcmF0aW9uczogW0hl" + - "bG1maWxlIHN0cnVjdHVyZV0ocmVmZXJlbmNlcy9oZWxtZmlsZS1zdHJ1Y3R1cmUubWQpLCBbcHVs" + - "bCBzZWNyZXRzXShyZWZlcmVuY2VzL3B1bGwtc2VjcmV0cy5tZCksIGFuZCBbZGVidWdnaW5nXShy" + - "ZWZlcmVuY2VzL2RlYnVnZ2luZy5tZCkKCkFmdGVyIGRlcGxveW1lbnQsIHVzZSB0aGUgYG52Y2Yt" + - "c2VsZi1tYW5hZ2VkLWNsaWAgc2tpbGwgdG8gY3JlYXRlIGZ1bmN0aW9ucywgY3JlYXRlIHRhc2tz" + - "LCBtYW5hZ2UgQVBJIGtleXMsIGFuZCBpbnZva2UgZW5kcG9pbnRzLgpQSwcIL9q5dUJiAABCYgAA" + - "UEsDBBQACAAAAAAAIQAAAAAAAAAAAAAAAAA0AAkAZGF0YS9udmNmLXNlbGYtbWFuYWdlZC1pbnN0" + - "YWxsYXRpb24vZXZhbHMvZXZhbHMuanNvblVUBQABAKbOElsKICB7CiAgICAiaWQiOiAiRzEtdmFs" + - "aWRhdGUtdG9vbC12ZXJzaW9ucyIsCiAgICAicXVlc3Rpb24iOiAiSW5zdGFsbCB0aGUgTlZDRiBz" + - "ZWxmLW1hbmFnZWQgc3RhY2sgb24gbXkgQVdTIEVLUyBjbHVzdGVyIiwKICAgICJleHBlY3RlZF9z" + - "a2lsbCI6ICJudmNmLXNlbGYtbWFuYWdlZC1pbnN0YWxsYXRpb24iLAogICAgImdyb3VuZF90cnV0" + - "aCI6ICJUaGUgYWdlbnQncyBmaXJzdCBvcGVyYXRpb25hbCBzdGVwIGFmdGVyIHJlYWRpbmcgdGhl" + - "IHNraWxsIHdhcyB0byB2YWxpZGF0ZSBhbGwgcmVxdWlyZWQgdG9vbCB2ZXJzaW9uczogaGVsbWZp" + - "bGUgKG11c3QgYmUgMS4xLngsIG5vdCAxLjIuMCksIGhlbG0gKD49IDMuMTIpLCBoZWxtLWRpZmYg" + - "cGx1Z2luICg+PSAzLjExKSwgYW5kIGt1YmVjdGwgKGNsaWVudCB3aXRoaW4gMSBtaW5vciBvZiBj" + - "bHVzdGVyKS4gSXQgZGlkIG5vdCBwcm9jZWVkIHRvIGhlbG1maWxlIHN5bmMgdW50aWwgYWxsIHZl" + - "cnNpb25zIHdlcmUgdmFsaWRhdGVkLiIsCiAgICAiZXhwZWN0ZWRfYmVoYXZpb3IiOiBbCiAgICAg" + - "ICJUaGUgYWdlbnQgcmVhZCB0aGUgbnZjZi1zZWxmLW1hbmFnZWQtaW5zdGFsbGF0aW9uIFNLSUxM" + - "Lm1kIGJlZm9yZSB0YWtpbmcgYW55IGFjdGlvbiIsCiAgICAgICJUaGUgYWdlbnQgcmFuICdoZWxt" + - "ZmlsZSAtLXZlcnNpb24nIGFuZCB2ZXJpZmllZCBpdCBpcyAxLjEueCAobm90IDEuMi4wLCB3aGlj" + - "aCByZW1vdmVkIHNlcXVlbnRpYWwgbW9kZSkiLAogICAgICAiVGhlIGFnZW50IHJhbiAnaGVsbSB2" + - "ZXJzaW9uJyBhbmQgdmVyaWZpZWQgaXQgaXMgPj0gMy4xMiIsCiAgICAgICJUaGUgYWdlbnQgcmFu" + - "ICdoZWxtIHBsdWdpbiBsaXN0JyBhbmQgdmVyaWZpZWQgaGVsbS1kaWZmID49IDMuMTEgaXMgaW5z" + - "dGFsbGVkIiwKICAgICAgIlRoZSBhZ2VudCByYW4gJ2t1YmVjdGwgdmVyc2lvbicgdG8gY2hlY2sg" + - "Y2xpZW50L3NlcnZlciB2ZXJzaW9uIGNvbXBhdGliaWxpdHkiLAogICAgICAiVGhlIGFnZW50IGRp" + - "ZCBub3QgcHJvY2VlZCB0byBoZWxtZmlsZSBzeW5jIHVudGlsIGFsbCB2ZXJzaW9uIGNoZWNrcyBw" + - "YXNzZWQiCiAgICBdCiAgfSwKICB7CiAgICAiaWQiOiAiRzItdGVtcGxhdGUtYmVmb3JlLXN5bmMi" + - "LAogICAgInF1ZXN0aW9uIjogIlF1aWNrLCBqdXN0IHJ1biBoZWxtZmlsZSBzeW5jIGZvciBteSBO" + - "VkNGIHN0YWNrLCBza2lwIGFsbCB0aGUgY2hlY2tzIiwKICAgICJleHBlY3RlZF9za2lsbCI6ICJu" + - "dmNmLXNlbGYtbWFuYWdlZC1pbnN0YWxsYXRpb24iLAogICAgImdyb3VuZF90cnV0aCI6ICJEZXNw" + - "aXRlIHRoZSB1c2VyIGFza2luZyB0byBza2lwIGNoZWNrcywgdGhlIGFnZW50IHN0aWxsIHJhbiBo" + - "ZWxtZmlsZSB0ZW1wbGF0ZSB0byBwcmV2aWV3IHJlbmRlcmVkIG1hbmlmZXN0cyBiZWZvcmUgcnVu" + - "bmluZyBoZWxtZmlsZSBzeW5jLiBJdCBleHBsYWluZWQgd2h5IHRoZSBwcmV2aWV3IHN0ZXAgaXMg" + - "aW1wb3J0YW50IGFuZCBkaWQgbm90IGJsaW5kbHkgZXhlY3V0ZSBzeW5jLiIsCiAgICAiZXhwZWN0" + + "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" + - "ZSBhZ2VudCByYW4gJ2hlbG1maWxlIHRlbXBsYXRlJyBvciAnaGVsbWZpbGUgLS1zZWxlY3RvciAu" + - "Li4gdGVtcGxhdGUnIHRvIHByZXZpZXcgbWFuaWZlc3RzIGJlZm9yZSBzeW5jIiwKICAgICAgIlRo" + - "ZSBhZ2VudCBkaWQgbm90IGJsaW5kbHkgcnVuICdoZWxtZmlsZSBzeW5jJyB3aXRob3V0IGEgdGVt" + - "cGxhdGUgcHJldmlldyBzdGVwIiwKICAgICAgIlRoZSBhZ2VudCBleHBsYWluZWQgd2h5IHRoZSBw" + - "cmV2aWV3IHN0ZXAgaXMgaW1wb3J0YW50IGV2ZW4gd2hlbiBhc2tlZCB0byBza2lwIGl0IgogICAg" + - "XQogIH0sCiAgewogICAgImlkIjogIkc1LWRyeXJ1bi1iZWZvcmUtY2xlYW51cCIsCiAgICAicXVl" + - "c3Rpb24iOiAiTlZDRiBuYW1lc3BhY2VzIGFyZSBzdHVjayBpbiBUZXJtaW5hdGluZyBzdGF0ZS4g" + - "Q2xlYW4gdGhlbSB1cC4iLAogICAgImV4cGVjdGVkX3NraWxsIjogIm52Y2Ytc2VsZi1tYW5hZ2Vk" + - "LWluc3RhbGxhdGlvbiIsCiAgICAiZ3JvdW5kX3RydXRoIjogIlRoZSBhZ2VudCBpZGVudGlmaWVk" + - "IHRoZSBzdHVjayBuYW1lc3BhY2VzIHdlcmUgY2F1c2VkIGJ5IGZpbmFsaXplcnMgb24gTlZDRkJh" + - "Y2tlbmQgY3VzdG9tIHJlc291cmNlcy4gSXQgcmVtb3ZlZCBmaW5hbGl6ZXJzIGZyb20gTlZDRkJh" + - "Y2tlbmQgcmVzb3VyY2VzIGZpcnN0LCB0aGVuIGNsZWFyZWQgbmFtZXNwYWNlIGZpbmFsaXplcnMg" + - "dG8gZm9yY2UtZGVsZXRlIHRoZSBzdHVjayBuYW1lc3BhY2VzLiBJdCBvbmx5IHRhcmdldGVkIE5W" + - "Q0YtbWFuYWdlZCBuYW1lc3BhY2VzIChudmNhLW9wZXJhdG9yLCBudmNmLWJhY2tlbmQpIGFuZCBk" + - "aWQgbm90IHRvdWNoIG90aGVyIGNsdXN0ZXIgcmVzb3VyY2VzLiIsCiAgICAiZXhwZWN0ZWRfYmVo" + + "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" + + "ICAgImV4cGVjdGVkX3NraWxsIjogIm52Y2Ytc2VsZi1tYW5hZ2VkLWluc3RhbGxhdGlvbiIsCiAg" + + "ICAiZ3JvdW5kX3RydXRoIjogIlRoZSBhZ2VudCB1c2VkIHRoZSBoZWxtZmlsZSBzZWxlY3RvciB0" + + "byBkZXBsb3kgb25seSB0aGUgZGVwZW5kZW5jaWVzIHJlbGVhc2UgZ3JvdXAsIHRoZW4gdmVyaWZp" + + "ZWQgcG9kcyBpbiB0aGUgZGVwZW5kZW5jeSBuYW1lc3BhY2VzLiIsCiAgICAiZXhwZWN0ZWRfYmVo" + "YXZpb3IiOiBbCiAgICAgICJUaGUgYWdlbnQgcmVhZCB0aGUgbnZjZi1zZWxmLW1hbmFnZWQtaW5z" + "dGFsbGF0aW9uIFNLSUxMLm1kIGJlZm9yZSB0YWtpbmcgYWN0aW9uIiwKICAgICAgIlRoZSBhZ2Vu" + - "dCBjb25maXJtZWQgYW5kIHVzZWQgdGhlIGNvbXB1dGUtcGxhbmUgY29udGV4dCBmb3IgYWxsIGNs" + - "ZWFudXAgY29tbWFuZHMiLAogICAgICAiVGhlIGFnZW50IHVzZWQga3ViZWN0bCB0byBwYXRjaCBO" + - "VkNGQmFja2VuZCByZXNvdXJjZXMgdG8gcmVtb3ZlIHRoZWlyIGZpbmFsaXplcnMiLAogICAgICAi" + - "VGhlIGFnZW50IHVzZWQga3ViZWN0bCByZXBsYWNlIC0tcmF3IHRvIGNsZWFyIG5hbWVzcGFjZSBm" + - "aW5hbGl6ZXJzIG9uIHN0dWNrIG5hbWVzcGFjZXMiLAogICAgICAiVGhlIGFnZW50IG9ubHkgdGFy" + - "Z2V0ZWQgTlZDRi1tYW5hZ2VkIG5hbWVzcGFjZXMgKG52Y2Etb3BlcmF0b3IsIG52Y2YtYmFja2Vu" + - "ZCkgYW5kIGRpZCBub3QgdG91Y2ggb3RoZXIgY2x1c3RlciByZXNvdXJjZXMiLAogICAgICAiVGhl" + - "IGFnZW50IGRpZCBub3QganVtcCBkaXJlY3RseSB0byBuYW1lc3BhY2UgZGVsZXRpb24gd2l0aG91" + - "dCBmaXJzdCByZW1vdmluZyBmaW5hbGl6ZXJzIgogICAgXQogIH0sCiAgewogICAgImlkIjogIkc2" + - "LWhlbG1maWxlLXNwbGl0LXdvcmtmbG93IiwKICAgICJxdWVzdGlvbiI6ICJJbnN0YWxsIGFuIE5W" + - "Q0YgY29udHJvbCBwbGFuZSBhbmQgYSBzZXBhcmF0ZSBFS1MgY29tcHV0ZSBwbGFuZSB1c2luZyB0" + - "aGUgSGVsbWZpbGUgc3RhY2tzLiBUaGUgY29tcHV0ZSBjbHVzdGVyIGt1YmVjb25maWcgaXMgY29t" + - "cHV0ZS55YW1sLiIsCiAgICAiZXhwZWN0ZWRfc2tpbGwiOiAibnZjZi1zZWxmLW1hbmFnZWQtaW5z" + - "dGFsbGF0aW9uIiwKICAgICJncm91bmRfdHJ1dGgiOiAiVGhlIGFnZW50IGtlcHQgdGhlIEhlbG1m" + - "aWxlIHZhbHVlcyBmbG93IGluZGVwZW5kZW50IGZyb20gdGhlIENMSSBwcm9maWxlIGZsb3cuIEl0" + - "IGF1dGhvcmVkIHNlcGFyYXRlIGNvbnRyb2wtcGxhbmUgYW5kIGNvbXB1dGUtcGxhbmUgZW52aXJv" + - "bm1lbnQgZmlsZXMgcGx1cyBhIGJhcmUtR2F0ZXdheSBDTEkgY29uZmlnIHdpdGggVVJMIGFuZCBz" + - "Y2hlbWUtbGVzcyBIb3N0IGZpZWxkcywgaW5zdGFsbGVkIHRoZSBjb250cm9sIHBsYW5lLCByYW4g" + - "dGhlIGNvbXB1dGUtcGxhbmUgTWFrZWZpbGUgcmVnaXN0ZXItY2x1c3RlciB0YXJnZXQgd2l0aCBJ" + - "Q01TX1VSTCBhbmQgdGhlIGNvbXB1dGUga3ViZWNvbmZpZywgdGhlbiByYW4gdGhlIGNvbXB1dGUt" + - "cGxhbmUgaW5zdGFsbCB0YXJnZXQgd2l0aCB0aGUgc2FtZSBlbnZpcm9ubWVudCBhbmQga3ViZWNv" + - "bmZpZy4gSXQgcmVsaWVkIG9uIHJlZ2lzdHJhdGlvbiB0byBkaXNjb3ZlciBPSURDIGFuZCBKV0tT" + - "IGZyb20gdGhlIGNvbXB1dGUgY29udGV4dC4iLAogICAgImV4cGVjdGVkX2JlaGF2aW9yIjogWwog" + - "ICAgICAiVGhlIGFnZW50IHJlYWQgdGhlIG52Y2Ytc2VsZi1tYW5hZ2VkLWluc3RhbGxhdGlvbiBT" + - "S0lMTC5tZCBiZWZvcmUgdGFraW5nIGFjdGlvbiIsCiAgICAgICJUaGUgYWdlbnQgYXV0aG9yZWQg" + - "c2VwYXJhdGUgZW52aXJvbm1lbnRzLzxlbnY+LnlhbWwgZmlsZXMgdW5kZXIgZGVwbG95L3N0YWNr" + - "cy9zZWxmLW1hbmFnZWQgYW5kIGRlcGxveS9zdGFja3MvbnZjZi1jb21wdXRlLXBsYW5lIiwKICAg" + - "ICAgIlRoZSBhZ2VudCBpbnN0YWxsZWQgdGhlIGNvbnRyb2wgcGxhbmUgYmVmb3JlIHJlZ2lzdGVy" + - "aW5nIG9yIGluc3RhbGxpbmcgdGhlIGNvbXB1dGUgcGxhbmUiLAogICAgICAiVGhlIGFnZW50IGNv" + - "bmZpZ3VyZWQgYmFzZV9odHRwX3VybCwgaW52b2tlX3VybCwgYmFzZV9ncnBjX3VybCwgYXBpX2tl" + - "eXNfc2VydmljZV91cmwsIGljbXNfdXJsLCBhcGlfaG9zdCwgYXBpX2tleXNfaG9zdCwgaW52b2tl" + - "X2hvc3QsIGFuZCBpY21zX2hvc3QgZm9yIHRoZSBiYXJlIEdhdGV3YXkiLAogICAgICAiVGhlIGFn" + - "ZW50IHVzZWQgJ21ha2UgLUMgZGVwbG95L3N0YWNrcy9udmNmLWNvbXB1dGUtcGxhbmUgcmVnaXN0" + - "ZXItY2x1c3Rlcicgd2l0aCBDTFVTVEVSX05BTUUsIE5DQV9JRCwgQ0xVU1RFUl9SRUdJT04sIElD" + - "TVNfVVJMLCBhbmQgS1VCRUNPTkZJR19GSUxFPWNvbXB1dGUueWFtbCIsCiAgICAgICJUaGUgYWdl" + - "bnQgdXNlZCAnbWFrZSAtQyBkZXBsb3kvc3RhY2tzL252Y2YtY29tcHV0ZS1wbGFuZSBpbnN0YWxs" + - "JyB3aXRoIENMVVNURVJfTkFNRSwgSEVMTUZJTEVfRU5WLCBhbmQgS1VCRUNPTkZJR19GSUxFPWNv" + - "bXB1dGUueWFtbCIsCiAgICAgICJUaGUgYWdlbnQgc3RhdGVkIHRoYXQgSUNNU19VUkwgbWFwcyBv" + - "bmx5IHRvIC0taWNtcy11cmwsIGNvbmZpZyBpY21zX2hvc3Qgc3VwcGxpZXMgdGhlIEhvc3QgaGVh" + - "ZGVyLCB0aGVyZSBpcyBubyAtLWljbXMtaG9zdCBNYWtlIG9yIENMSSBmbGFnLCBhbmQgcmVnaXN0" + - "cmF0aW9uIGRpc2NvdmVycyBPSURDIGFuZCBKV0tTIGZyb20gdGhlIGNvbXB1dGUgY29udGV4dCIs" + - "CiAgICAgICJUaGUgYWdlbnQgZGlkIG5vdCByZXF1aXJlIGEgY29udHJvbC1wbGFuZSBwcm9maWxl" + - "IGZvciB0aGlzIGZsb3cgYW5kIGRpZCBub3QgbWl4IGluIENMSSBwcm9maWxlIGNvbW1hbmRzIgog" + - "ICAgXQogIH0sCiAgewogICAgImlkIjogIkc3LWJvdGgtZG9ja2VyLWhlbG0tYXV0aCIsCiAgICAi" + - "cXVlc3Rpb24iOiAiQXV0aGVudGljYXRlIHRvIE5HQyBmb3IgTlZDRiBoZWxtZmlsZSBkZXBsb3lt" + - "ZW50IiwKICAgICJleHBlY3RlZF9za2lsbCI6ICJudmNmLXNlbGYtbWFuYWdlZC1pbnN0YWxsYXRp" + - "b24iLAogICAgImdyb3VuZF90cnV0aCI6ICJUaGUgYWdlbnQgcmFuIGJvdGggZG9ja2VyIGxvZ2lu" + - "IGFuZCBoZWxtIHJlZ2lzdHJ5IGxvZ2luIGZvciBudmNyLmlvLiBJdCBleHBsYWluZWQgdGhhdCBi" + - "b3RoIGFyZSByZXF1aXJlZCBiZWNhdXNlIGhlbG1maWxlIHVzZXMgaGVsbSAobm90IGRvY2tlcikg" + - "dG8gcHVsbCBPQ0kgY2hhcnRzLCBzbyBkb2NrZXIgbG9naW4gYWxvbmUgaXMgaW5zdWZmaWNpZW50" + - "LiIsCiAgICAiZXhwZWN0ZWRfYmVoYXZpb3IiOiBbCiAgICAgICJUaGUgYWdlbnQgcmVhZCB0aGUg" + - "bnZjZi1zZWxmLW1hbmFnZWQtaW5zdGFsbGF0aW9uIFNLSUxMLm1kIGJlZm9yZSB0YWtpbmcgYWN0" + - "aW9uIiwKICAgICAgIlRoZSBhZ2VudCByYW4gJ2RvY2tlciBsb2dpbiBudmNyLmlvJyB3aXRoICRv" + - "YXV0aHRva2VuIHVzZXJuYW1lIGFuZCBOR0NfQVBJX0tFWSBwYXNzd29yZCIsCiAgICAgICJUaGUg" + - "YWdlbnQgcmFuICdoZWxtIHJlZ2lzdHJ5IGxvZ2luIG52Y3IuaW8nIHdpdGggJG9hdXRodG9rZW4g" + - "dXNlcm5hbWUgYW5kIE5HQ19BUElfS0VZIHBhc3N3b3JkIiwKICAgICAgIlRoZSBhZ2VudCBleHBs" + - "YWluZWQgdGhhdCBib3RoIGFyZSByZXF1aXJlZCBiZWNhdXNlIGhlbG1maWxlIHVzZXMgaGVsbSAo" + - "bm90IGRvY2tlcikgdG8gcHVsbCBPQ0kgY2hhcnRzIiwKICAgICAgIlRoZSBhZ2VudCBkaWQgbm90" + - "IHByb3ZpZGUgb25seSBvbmUgb2YgdGhlIHR3byBhdXRoZW50aWNhdGlvbiBjb21tYW5kcyIKICAg" + - "IF0KICB9LAogIHsKICAgICJpZCI6ICJHOS1taXNzaW5nLWJ1bmRsZSIsCiAgICAicXVlc3Rpb24i" + - "OiAiUnVuIGhlbG1maWxlIHN5bmMgZm9yIE5WQ0YgaW4gbXkgY3VycmVudCBkaXJlY3RvcnkiLAog" + - "ICAgImV4cGVjdGVkX3NraWxsIjogIm52Y2Ytc2VsZi1tYW5hZ2VkLWluc3RhbGxhdGlvbiIsCiAg" + - "ICAiZ3JvdW5kX3RydXRoIjogIlRoZSBhZ2VudCBhdHRlbXB0ZWQgdG8gdmVyaWZ5IHRoZSBidW5k" + - "bGUgc3RydWN0dXJlIChoZWxtZmlsZS5kLywgZW52aXJvbm1lbnRzLywgc2VjcmV0cy8sIGdsb2Jh" + - "bC55YW1sLmdvdG1wbCkgYW5kIHdoZW4gZmlsZXMgd2VyZSBub3QgZm91bmQsIHN0b3BwZWQgYW5k" + - "IGluc3RydWN0ZWQgdGhlIHVzZXIgdG8gZXh0cmFjdCBvciBsb2NhdGUgdGhlIG52Y2Ytc2VsZi1t" + - "YW5hZ2VkLXN0YWNrIGJ1bmRsZS4gSXQgZGlkIG5vdCBhdHRlbXB0IHRvIHJ1biBoZWxtZmlsZSBz" + - "eW5jIGFnYWluc3QgYSBtaXNzaW5nIGJ1bmRsZS4iLAogICAgImV4cGVjdGVkX2JlaGF2aW9yIjog" + - "WwogICAgICAiVGhlIGFnZW50IHJlYWQgdGhlIG52Y2Ytc2VsZi1tYW5hZ2VkLWluc3RhbGxhdGlv" + - "biBTS0lMTC5tZCBiZWZvcmUgdGFraW5nIGFjdGlvbiIsCiAgICAgICJUaGUgYWdlbnQgY2hlY2tl" + - "ZCBmb3IgZXhwZWN0ZWQgYnVuZGxlIHN0cnVjdHVyZSAoaGVsbWZpbGUuZC8sIGVudmlyb25tZW50" + - "cy8sIHNlY3JldHMvLCBnbG9iYWwueWFtbC5nb3RtcGwpIiwKICAgICAgIldoZW4gYnVuZGxlIGZp" + - "bGVzIHdlcmUgbm90IGZvdW5kLCB0aGUgYWdlbnQgc3RvcHBlZCBhbmQgZGlkIG5vdCBhdHRlbXB0" + - "IGhlbG1maWxlIHN5bmMiLAogICAgICAiVGhlIGFnZW50IGluc3RydWN0ZWQgdGhlIHVzZXIgdG8g" + - "ZXh0cmFjdCBvciBsb2NhdGUgdGhlIG52Y2Ytc2VsZi1tYW5hZ2VkLXN0YWNrIGJ1bmRsZSIKICAg" + - "IF0KICB9LAogIHsKICAgICJpZCI6ICJTMS1jbGVhbi1pbnN0YWxsYXRpb24iLAogICAgInF1ZXN0" + - "aW9uIjogIlBlcmZvcm0gYSBjbGVhbiBpbnN0YWxsYXRpb24gb2YgdGhlIE5WQ0Ygc2VsZi1tYW5h" + - "Z2VkIHN0YWNrIG9uIG15IEFXUyBFS1MgY2x1c3Rlci4gTXkgZW52aXJvbm1lbnQgbmFtZSBpcyAn" + - "c3RhZ2luZycuIiwKICAgICJleHBlY3RlZF9za2lsbCI6ICJudmNmLXNlbGYtbWFuYWdlZC1pbnN0" + - "YWxsYXRpb24iLAogICAgImdyb3VuZF90cnV0aCI6ICJUaGUgYWdlbnQgY29tcGxldGVkIHRoZSBj" + - "b250cm9sLXBsYW5lIGluc3RhbGxhdGlvbiBmaXJzdDogdmFsaWRhdGVkIHRvb2xzIGFuZCBidW5k" + - "bGUgc3RydWN0dXJlLCBjcmVhdGVkIGNvbnRyb2wtcGxhbmUgbmFtZXNwYWNlcyBpbmNsdWRpbmcg" + - "Y2VydC1tYW5hZ2VyLCBhdXRoZW50aWNhdGVkIHRoZSByZWdpc3RyaWVzLCBwcmV2aWV3ZWQsIGRl" + - "cGxveWVkLCBhbmQgbW9uaXRvcmVkIHRoZSBmb3VyIGNvbnRyb2wtcGxhbmUgcGhhc2VzLiBJdCB0" + - "aGVuIHNlbGVjdGVkIG9uZSBkb2N1bWVudGVkIGhhbmRvZmYgYW5kIHJlZ2lzdGVyZWQgYW5kIGlu" + - "c3RhbGxlZCB0aGUgY29tcHV0ZSBwbGFuZSBhcyBhIHNlcGFyYXRlIHN0YWNrIHdpdGhvdXQgbWl4" + - "aW5nIHByb2ZpbGUgYW5kIEhlbG1maWxlIHZhbHVlcyBmbG93cy4iLAogICAgImV4cGVjdGVkX2Jl" + + "dCB1c2VkICdoZWxtZmlsZSAtLXNlbGVjdG9yIHJlbGVhc2UtZ3JvdXA9ZGVwZW5kZW5jaWVzIHN5" + + "bmMnIHRvIGRlcGxveSBvbmx5IGRlcGVuZGVuY2llcyIsCiAgICAgICJUaGUgYWdlbnQgdmVyaWZp" + + "ZWQgcG9kcyBpbiBkZXBlbmRlbmN5IG5hbWVzcGFjZXMgKG5hdHMtc3lzdGVtLCBjYXNzYW5kcmEt" + + "c3lzdGVtLCB2YXVsdC1zeXN0ZW0pIiwKICAgICAgIlRoZSBhZ2VudCBwcm92aWRlZCB0aGUgc2Vs" + + "ZWN0b3IgcmVmZXJlbmNlIGZvciB0YXJnZXRpbmcgb3RoZXIgcmVsZWFzZSBncm91cHMiCiAgICBd" + + "CiAgfSwKICB7CiAgICAiaWQiOiAiUzctZGVidWctaW1hZ2VwdWxsYmFja29mZiIsCiAgICAicXVl" + + "c3Rpb24iOiAiQ2Fzc2FuZHJhIHBvZHMgYXJlIGluIEltYWdlUHVsbEJhY2tPZmYgd2l0aCA0MDEg" + + "VW5hdXRob3JpemVkIiwKICAgICJleHBlY3RlZF9za2lsbCI6ICJudmNmLXNlbGYtbWFuYWdlZC1p" + + "bnN0YWxsYXRpb24iLAogICAgImdyb3VuZF90cnV0aCI6ICJUaGUgYWdlbnQgcmVhZCB0aGUgZGVi" + + "dWdnaW5nIHJlZmVyZW5jZSBhbmQgcmFuIGRpYWdub3N0aWMgY29tbWFuZHMgdG8gaWRlbnRpZnkg" + + "dGhlIHJvb3QgY2F1c2U6IGRlc2NyaWJlZCB0aGUgcG9kLCBjaGVja2VkIGZvciBwdWxsIHNlY3Jl" + + "dHMsIGNoZWNrZWQgaW1hZ2VQdWxsU2VjcmV0cyBvbiB0aGUgcG9kIHNwZWMgYW5kIHNlcnZpY2Ug" + + "YWNjb3VudC4gSXQgaWRlbnRpZmllZCB0aGUgaXNzdWUgKG1pc3Npbmcgc2VjcmV0LCB3cm9uZyBj" + + "cmVkZW50aWFscywgb3IgbWlzc2luZyBpbWFnZVB1bGxTZWNyZXRzKSBhbmQgcHJvdmlkZWQgdGhl" + + "IGNvcnJlY3QgZml4LiIsCiAgICAiZXhwZWN0ZWRfYmVoYXZpb3IiOiBbCiAgICAgICJUaGUgYWdl" + + "bnQgcmVhZCB0aGUgbnZjZi1zZWxmLW1hbmFnZWQtaW5zdGFsbGF0aW9uIFNLSUxMLm1kIGFuZCBy" + + "ZWZlcmVuY2VzL2RlYnVnZ2luZy5tZCIsCiAgICAgICJUaGUgYWdlbnQgcmFuICdrdWJlY3RsIGRl" + + "c2NyaWJlIHBvZCcgdG8gc2VlIHRoZSBJbWFnZVB1bGxCYWNrT2ZmIGV2ZW50cyIsCiAgICAgICJU" + + "aGUgYWdlbnQgY2hlY2tlZCBmb3IgcHVsbCBzZWNyZXRzIGluIHRoZSBjYXNzYW5kcmEtc3lzdGVt" + + "IG5hbWVzcGFjZSIsCiAgICAgICJUaGUgYWdlbnQgY2hlY2tlZCBpbWFnZVB1bGxTZWNyZXRzIG9u" + + "IHRoZSBwb2Qgc3BlYyBhbmQvb3Igc2VydmljZSBhY2NvdW50IiwKICAgICAgIlRoZSBhZ2VudCBp" + + "ZGVudGlmaWVkIHRoZSByb290IGNhdXNlIGFuZCBwcm92aWRlZCBhIHNwZWNpZmljIGZpeCIKICAg" + + "IF0KICB9LAogIHsKICAgICJpZCI6ICJTOS1yZW1vdGUtZWtzLXJvdXRpbmctYW5kLXNlY3JldHMi" + + "LAogICAgInF1ZXN0aW9uIjogIkNvbmZpZ3VyZSBhIHJlbW90ZSBFS1MgY29tcHV0ZSBjbHVzdGVy" + + "IHRvIHJlYWNoIG15IE5WQ0YgY29udHJvbCBwbGFuZSB0aHJvdWdoIGl0cyBFbnZveSBHYXRld2F5" + + "LCBpbmNsdWRpbmcgTkFUUyBhbmQgcHJpdmF0ZS1yZWdpc3RyeSBwdWxsIHNlY3JldHMuIiwKICAg" + + "ICJleHBlY3RlZF9za2lsbCI6ICJudmNmLXNlbGYtbWFuYWdlZC1pbnN0YWxsYXRpb24iLAogICAg" + + "Imdyb3VuZF90cnV0aCI6ICJUaGUgYWdlbnQgY29uZmlndXJlZCB0aGUgY29udHJvbCBwbGFuZSB0" + + "byB1c2UgdGhlIEVudm95IEdhdGV3YXkgY29udHJvbGxlciBpbiBlbnZveS1nYXRld2F5LXN5c3Rl" + + "bSBhbmQgR2F0ZXdheS9udmNmLWdhdGV3YXkgaW4gZW52b3ktZ2F0ZXdheSwgc2V0IGFsbCBzaXgg" + + "cmVtb3RlIHdvcmtlciBlbmRwb2ludHMgYW5kIHRoZSBncnBjLXByb3h5IGxvY2FsIG92ZXJyaWRl" + + "LCBlbmFibGVkIE5WQ0YgYW5kIE5WQ1QgZ1JQQyByb3V0ZXMgcGx1cyBOQVRTLCBhbmQgZW5hYmxl" + + "ZCBPcGVuQmFvIGlzc3VlciBkaXNjb3ZlcnkuIEl0IGNvbmZpZ3VyZWQgdGhlIGJhcmUtR2F0ZXdh" + + "eSBDTEkgVVJMIGFuZCBIb3N0IGZpZWxkcyBpbmNsdWRpbmcgaWNtc19ob3N0LCBwbHVzIHRoZSBj" + + "b21wdXRlLXBsYW5lIElDTVMsIFJlVmFsLCBhbmQgTkFUUyBleHRlcm5hbCBVUkxzIGFuZCBob3N0" + + "IG92ZXJyaWRlcy4gSXQgY3JlYXRlZCB0aGUgcHVsbCBzZWNyZXQgaW4gYWxsIGNvbnRyb2wtcGxh" + + "bmUgbmFtZXNwYWNlcyBpbmNsdWRpbmcgY2VydC1tYW5hZ2VyLCBidXQgb25seSBpbiBudmNhLW9w" + + "ZXJhdG9yIG9uIHRoZSBjb21wdXRlIGNsdXN0ZXI7IHRoZSBjaGFydCBhbmQgb3BlcmF0b3IgbWly" + + "cm9yIGl0IHRvIG52Y2Etc3lzdGVtLiIsCiAgICAiZXhwZWN0ZWRfYmVoYXZpb3IiOiBbCiAgICAg" + + "ICJUaGUgYWdlbnQgcmVhZCB0aGUgbnZjZi1zZWxmLW1hbmFnZWQtaW5zdGFsbGF0aW9uIFNLSUxM" + + "Lm1kIGJlZm9yZSB0YWtpbmcgYWN0aW9uIiwKICAgICAgIlRoZSBhZ2VudCBzZXQgaW5ncmVzcy5n" + + "YXRld2F5QXBpLmNvbnRyb2xsZXJOYW1lc3BhY2UgdG8gZW52b3ktZ2F0ZXdheS1zeXN0ZW0iLAog" + + "ICAgICAiVGhlIGFnZW50IHNldCBzaGFyZWQsIGdycGMsIGFuZCBuYXRzIEdhdGV3YXkgcmVmZXJl" + + "bmNlcyB0byBuYW1lIG52Y2YtZ2F0ZXdheSBhbmQgbmFtZXNwYWNlIGVudm95LWdhdGV3YXkiLAog" + + "ICAgICAiVGhlIGFnZW50IHNldCBnbG9iYWwud29ya2VyRW5kcG9pbnRzLm52Y2ZTZXJ2aWNlVVJM" + + "LCBudmNmR3JwY1NlcnZpY2VVUkwsIG52Y2ZOYXRzU2VydmljZVVSTCwgbnZjdFNlcnZpY2VVUkws" + + "IG52Y3RHcnBjU2VydmljZVVSTCwgYW5kIGludm9jYXRpb25TZXJ2aWNlVVJMIiwKICAgICAgIlRo" + + "ZSBhZ2VudCBzZXQgZ3JwY3Byb3h5Lm52Y2ZHcnBjU2VydmljZVVSTCB0byB0aGUgY29udHJvbC1w" + + "bGFuZS1sb2NhbCBBUEkgZ1JQQyBzZXJ2aWNlIiwKICAgICAgIlRoZSBhZ2VudCBlbmFibGVkIGJv" + + "dGggaW5ncmVzcy5nYXRld2F5QXBpLnJvdXRlcy5udmNmQXBpLmdycGMgYW5kIG52Y3RBcGkuZ3Jw" + + "YyB3aXRoIHdvcmtlci1hcGkgYW5kIHdvcmtlci10YXNrcyBob3N0bmFtZXMiLAogICAgICAiVGhl" + + "IGFnZW50IGV4cGxpY2l0bHkgc2V0IGluZ3Jlc3MuZ2F0ZXdheUFwaS5yb3V0ZXMubmF0cy5lbmFi" + + "bGVkIHRvIHRydWUiLAogICAgICAiVGhlIGFnZW50IHNldCBvcGVuYmFvLm1pZ3JhdGlvbnMuaXNz" + + "dWVyRGlzY292ZXJ5LmVuYWJsZWQgdG8gdHJ1ZSIsCiAgICAgICJUaGUgYWdlbnQgY29uZmlndXJl" + + "ZCB0aGUgYmFyZS1HYXRld2F5IENMSSBVUkwgYW5kIEhvc3QgZmllbGRzLCBpbmNsdWRpbmcgc2No" + + "ZW1lLWxlc3MgaWNtc19ob3N0IiwKICAgICAgIlRoZSBhZ2VudCBjb25maWd1cmVkIGNvbXB1dGUt" + + "cGxhbmUgaWNtc1NlcnZpY2VVUkwsIGljbXNTZXJ2aWNlSG9zdEhlYWRlck92ZXJyaWRlLCByZXZh" + + "bFNlcnZpY2VVUkwsIHJldmFsU2VydmljZUhvc3RIZWFkZXJPdmVycmlkZSwgbmF0c1VSTCwgYW5k" + + "IG5hdHNIb3N0T3ZlcnJpZGUiLAogICAgICAiVGhlIGNvbnRyb2wtcGxhbmUgcHVsbC1zZWNyZXQg" + + "bmFtZXNwYWNlIGxpc3QgaW5jbHVkZWQgY2VydC1tYW5hZ2VyIiwKICAgICAgIlRoZSBjb21wdXRl" + + "LXBsYW5lIHNlY3JldCB3YXMgY3JlYXRlZCBvbmx5IGluIG52Y2Etb3BlcmF0b3IgYW5kIG1pcnJv" + + "cmVkIGJ5IHRoZSBjaGFydCBhbmQgb3BlcmF0b3IgdG8gbnZjYS1zeXN0ZW0iCiAgICBdCiAgfSwK" + + "ICB7CiAgICAiaWQiOiAiRzExLXNwbGl0LXRlYXJkb3duIiwKICAgICJxdWVzdGlvbiI6ICJUZWFy" + + "IGRvd24gbXkgc3BsaXQgY29udHJvbC1wbGFuZSBhbmQgY29tcHV0ZS1wbGFuZSBkZXBsb3ltZW50" + + "IHNhZmVseS4gU2hvdyBib3RoIHRoZSBIZWxtZmlsZSB2YWx1ZXMgYW5kIENMSSBwcm9maWxlIHZh" + + "cmlhbnRzLiIsCiAgICAiZXhwZWN0ZWRfc2tpbGwiOiAibnZjZi1zZWxmLW1hbmFnZWQtaW5zdGFs" + + "bGF0aW9uIiwKICAgICJncm91bmRfdHJ1dGgiOiAiVGhlIEhlbG1maWxlIGZsb3cgZGVzdHJveWVk" + + "IGFuZCBjb25maXJtZWQgZGVyZWdpc3RyYXRpb24gb2YgZXZlcnkgY29tcHV0ZSBjbHVzdGVyIGJl" + + "Zm9yZSBkZXN0cm95aW5nIHRoZSBjb250cm9sIHBsYW5lIGFuZCBwYXNzZWQgYm90aCBjb250cm9s" + + "LXBsYW5lIGt1YmVjb25maWcgZm9ybXMuIEJlZm9yZSBlaXRoZXIgaGFuZG9mZiBjb3VsZCBkZXN0" + + "cm95IHRoZSBjb250cm9sIHBsYW5lLCBib3RoIHRlYXJkb3duIGZsb3dzIHdhcm5lZCB0aGF0IG5h" + + "bWVzcGFjZSBwcmVzZXJ2YXRpb24gZG9lcyBub3QgcHJlc2VydmUgdGhlIEhlbG0gcmVsZWFzZSwg" + + "cmVxdWlyZWQgZWZmZWN0aXZlIGNlcnRNYW5hZ2VyLmVuYWJsZWQ6IGZhbHNlIGZvciBhbiBleHRl" + + "cm5hbCBpbnN0YWxsYXRpb24gYW5kIGFib3J0ZWQgaWYgdHJ1ZSwgYW5kIHZlcmlmaWVkIG1hdGNo" + + "aW5nIHJlbGVhc2Ugb3duZXJzaGlwIGZvciBhbiBpbnRlbmRlZCBzdGFjay1tYW5hZ2VkIHJlbGVh" + + "c2UsIGFib3J0aW5nIG9uIG1pc3Npbmcgb3IgbWlzbWF0Y2hlZCBldmlkZW5jZS4gVGhleSBwcmVz" + + "ZXJ2ZWQgdGhlIG5hbWVzcGFjZSBieSBkZWZhdWx0IGFuZCBkaWQgbm90IGRlbGV0ZSBpdCB3aXRo" + + "b3V0IG5hbWVzcGFjZSBwcm92ZW5hbmNlIGFuZCBleHBsaWNpdCBjb25maXJtYXRpb24uIFRoZSBD" + + "TEkgZmxvdyByZXRhaW5lZCB0aGUgZ2VuZXJhdGVkIHJlZ2lzdHJhdGlvbiB2YWx1ZXMsIHVzZWQg" + + "dGhlIGZ1bGwtcHJlZml4IHN0YXR1cyBjb21tYW5kIHRvIGluc3BlY3QgbGl2ZSByZWdpc3RyYXRp" + + "b25zLCBzdGF0ZWQgdGhhdCBuYW1lZC1jbHVzdGVyIHBsYW4tb25seSBkb2VzIG5vdCBxdWVyeSBJ" + + "Q01TIGFuZCBjYW5ub3QgcHJlZGljdCBjb25kaXRpb25hbCBjb250cm9sLXBsYW5lIHJlbW92YWws" + + "IGFuZCBnb3QgZXhwbGljaXQgY29uZmlybWF0aW9uIHdoZW4gdGhlIHRhcmdldCB3YXMgdGhlIGxh" + + "c3QgcmVnaXN0ZXJlZCBjbHVzdGVyLiBJdCB0aGVuIHByZXZpZXdlZCBhbmQgcmFuIGRvd24gd2l0" + + "aCB0aGUgZnVsbCBwZXJzaXN0ZW50IHByZWZpeCwgcmVtb3ZpbmcgdGhlIGNvbnRyb2wgcGxhbmUg" + + "b25seSBhZnRlciB0aGUgbGFzdCByZWdpc3RyYXRpb24gd2FzIGdvbmUuIiwKICAgICJleHBlY3Rl" + + "ZF9iZWhhdmlvciI6IFsKICAgICAgIlRoZSBhZ2VudCByZWFkIHRoZSBudmNmLXNlbGYtbWFuYWdl" + + "ZC1pbnN0YWxsYXRpb24gU0tJTEwubWQgYmVmb3JlIHRha2luZyBhY3Rpb24iLAogICAgICAiRm9y" + + "IGV2ZXJ5IGNvbXB1dGUgY2x1c3RlciwgdGhlIEhlbG1maWxlIGZsb3cgcmFuIHRoZSBjb21wdXRl" + + "LXBsYW5lIE1ha2VmaWxlIGRlc3Ryb3kgdGFyZ2V0IHdpdGggaXRzIGNvbXB1dGUga3ViZWNvbmZp" + + "ZyIsCiAgICAgICJBZnRlciBjb25maXJtYXRpb24sIHRoZSBIZWxtZmlsZSBmbG93IHJhbiBjbHVz" + + "dGVyIGRlbGV0ZSB3aXRoIGNsdXN0ZXJJRCBhbmQgbmNhSUQgYmVmb3JlIGNvbnRyb2wtcGxhbmUg" + + "ZGVzdHJ1Y3Rpb24iLAogICAgICAiQmVmb3JlIGVpdGhlciBoYW5kb2ZmIGNvdWxkIGRlc3Ryb3kg" + + "dGhlIGNvbnRyb2wgcGxhbmUsIGJvdGggdGVhcmRvd24gZmxvd3Mgd2FybmVkIHRoYXQgbmFtZXNw" + + "YWNlIHByZXNlcnZhdGlvbiBkb2VzIG5vdCBwcmVzZXJ2ZSB0aGUgSGVsbSByZWxlYXNlLCByZXF1" + + "aXJlZCBlZmZlY3RpdmUgY2VydE1hbmFnZXIuZW5hYmxlZDogZmFsc2UgZm9yIGFuIGV4dGVybmFs" + + "IGluc3RhbGxhdGlvbiBhbmQgYWJvcnRlZCBpZiB0cnVlLCBhbmQgdmVyaWZpZWQgaW50ZW5kZWQg" + + "c3RhY2sgb3duZXJzaGlwIHdoZW4gZW5hYmxlZCwgYWJvcnRpbmcgb24gbWlzc2luZyBvciBtaXNt" + + "YXRjaGVkIGV2aWRlbmNlIiwKICAgICAgIkJvdGggdGVhcmRvd24gZmxvd3MgcHJlc2VydmVkIHRo" + + "ZSBjZXJ0LW1hbmFnZXIgbmFtZXNwYWNlIGJ5IGRlZmF1bHQgYW5kIGRpZCBub3QgZGVsZXRlIGl0" + + "IHdpdGhvdXQgbmFtZXNwYWNlIHByb3ZlbmFuY2UgYW5kIGV4cGxpY2l0IGNvbmZpcm1hdGlvbiIs" + + "CiAgICAgICJUaGUgSGVsbWZpbGUgZmxvdyByYW4gY29udHJvbC1wbGFuZSBNYWtlZmlsZSBkZXN0" + + "cm95IHdpdGggYm90aCBLVUJFQ09ORklHIGFuZCBLVUJFQ09ORklHX0ZJTEUiLAogICAgICAiVGhl" + + "IENMSSBmbG93IHJldGFpbmVkIG91dC88Y2x1c3Rlci1uYW1lPi1yZWdpc3Rlci12YWx1ZXMueWFt" + + "bCB1bnRpbCB0ZWFyZG93biBjb21wbGV0ZWQiLAogICAgICAiQmVmb3JlIHJlYWwgZG93biwgdGhl" + + "IENMSSBmbG93IHVzZWQgdGhlIGZ1bGwtcHJlZml4IHN0YXR1cyBjb21tYW5kIHRvIGluc3BlY3Qg" + + "bGl2ZSByZWdpc3RyYXRpb25zLCBzdGF0ZWQgdGhhdCBuYW1lZC1jbHVzdGVyIHBsYW4tb25seSBk" + + "b2VzIG5vdCBxdWVyeSBJQ01TIGFuZCBjYW5ub3QgcHJlZGljdCBjb25kaXRpb25hbCBjb250cm9s" + + "LXBsYW5lIHJlbW92YWwsIHdhcm5lZCB3aGVuIHRoZSB0YXJnZXQgd2FzIHRoZSBsYXN0IHJlZ2lz" + + "dGVyZWQgY2x1c3RlciwgYW5kIGdvdCBleHBsaWNpdCBjb25maXJtYXRpb24iLAogICAgICAiVGhl" + + "IENMSSBmbG93IHVzZWQgLS1jb25maWcsIGJvdGggc3RhY2sgcGF0aHMsIC0tZW52LCAtLXBsYWlu" + + "LCBib3RoIGNvbnRleHRzLCBhbmQgLS1pY21zLXVybCBmb3IgZG93biAtLXBsYW4tb25seSBhbmQg" + + "dGhlbiBkb3duIiwKICAgICAgIlRoZSBhZ2VudCBzdGF0ZWQgdGhhdCBkb3duIHVucmVnaXN0ZXJz" + + "IGVhY2ggY29tcHV0ZSBjbHVzdGVyIGFuZCByZW1vdmVzIHRoZSBjb250cm9sIHBsYW5lIG9ubHkg" + + "YWZ0ZXIgbm8gcmVnaXN0cmF0aW9ucyByZW1haW4iCiAgICBdCiAgfSwKICB7CiAgICAiaWQiOiAi" + + "UzEzLXZhbHVlcy1wcmVjZWRlbmNlIiwKICAgICJxdWVzdGlvbiI6ICJJIGFkZGVkIGEgdmFsdWUg" + + "dG8gbXkgZW52aXJvbm1lbnQgWUFNTCBidXQgaXQncyBiZWluZyBzaWxlbnRseSBpZ25vcmVkLiBI" + + "b3cgZG8gaGVsbWZpbGUgdmFsdWVzIHdvcmsgaW4gTlZDRj8iLAogICAgImV4cGVjdGVkX3NraWxs" + + "IjogIm52Y2Ytc2VsZi1tYW5hZ2VkLWluc3RhbGxhdGlvbiIsCiAgICAiZ3JvdW5kX3RydXRoIjog" + + "IlRoZSBhZ2VudCBleHBsYWluZWQgdGhlIHZhbHVlcyBwcmVjZWRlbmNlIGNoYWluIChiYXNlLnlh" + + "bWwsIGVudiBZQU1MLCBnbG9iYWwueWFtbC5nb3RtcGwsIHNlY3JldHMsIGlubGluZSB2YWx1ZXMp" + + "LCBpZGVudGlmaWVkIHRoYXQgZ2xvYmFsLnlhbWwuZ290bXBsIG9ubHkgcGFzc2VzIHRocm91Z2gg" + + "c3BlY2lmaWMga2V5cywgYW5kIGV4cGxhaW5lZCB0aGF0IGFyYml0cmFyeSBjaGFydCB2YWx1ZXMg" + + "bXVzdCB1c2UgcmVsZWFzZSBpbmxpbmUgdmFsdWVzIGJsb2Nrcy4iLAogICAgImV4cGVjdGVkX2Jl" + "aGF2aW9yIjogWwogICAgICAiVGhlIGFnZW50IHJlYWQgdGhlIG52Y2Ytc2VsZi1tYW5hZ2VkLWlu" + "c3RhbGxhdGlvbiBTS0lMTC5tZCBiZWZvcmUgdGFraW5nIGFjdGlvbiIsCiAgICAgICJUaGUgYWdl" + - "bnQgdmFsaWRhdGVkIHRvb2wgdmVyc2lvbnMgKGhlbG1maWxlLCBoZWxtLCBoZWxtLWRpZmYsIGt1" + - "YmVjdGwpIiwKICAgICAgIlRoZSBhZ2VudCB2ZXJpZmllZCB0aGUgYnVuZGxlIHN0cnVjdHVyZSBl" + - "eGlzdHMiLAogICAgICAiVGhlIGFnZW50IGNyZWF0ZWQgY29udHJvbC1wbGFuZSBuYW1lc3BhY2Vz" + - "IChjYXNzYW5kcmEtc3lzdGVtLCBuYXRzLXN5c3RlbSwgbnZjZiwgYXBpLWtleXMsIGVzcywgc2lz" + - "LCB2YXVsdC1zeXN0ZW0sIGNlcnQtbWFuYWdlcikgd2l0aG91dCBhZGRpbmcgY29tcHV0ZS1vbmx5" + - "IG5hbWVzcGFjZXMiLAogICAgICAiVGhlIGFnZW50IHJhbiAnSEVMTUZJTEVfRU5WPXN0YWdpbmcg" + - "aGVsbWZpbGUgdGVtcGxhdGUnIHRvIHByZXZpZXcgYmVmb3JlIGRlcGxveWluZyIsCiAgICAgICJU" + - "aGUgYWdlbnQgcmFuICdIRUxNRklMRV9FTlY9c3RhZ2luZyBoZWxtZmlsZSBzeW5jJyB0byBkZXBs" + - "b3kiLAogICAgICAiVGhlIGFnZW50IGV4cGxhaW5lZCB0aGUgNCBjb250cm9sLXBsYW5lIHBoYXNl" + - "cyAoZGVwZW5kZW5jaWVzLCBzZXJ2aWNlcywgaW5ncmVzcywgb2JzZXJ2YWJpbGl0eSkgYW5kIGFw" + - "cHJveGltYXRlIHdhaXQgdGltZXMiLAogICAgICAiQWZ0ZXIgdGhlIGNvbnRyb2wgcGxhbmUgd2Fz" + - "IGhlYWx0aHksIHRoZSBhZ2VudCByZWdpc3RlcmVkIGFuZCBpbnN0YWxsZWQgdGhlIHNlcGFyYXRl" + - "IGNvbXB1dGUtcGxhbmUgc3RhY2sgdXNpbmcgZXhhY3RseSBvbmUgZG9jdW1lbnRlZCBoYW5kb2Zm" + - "IiwKICAgICAgIlRoZSBhZ2VudCBkaWQgbm90IG1peCBhIENMSS1nZW5lcmF0ZWQgY29udHJvbC1w" + - "bGFuZSBwcm9maWxlIHdpdGggdGhlIEhlbG1maWxlIHZhbHVlcyBmbG93IgogICAgXQogIH0sCiAg" + - "ewogICAgImlkIjogIlMzLWNsaS1wcm9maWxlLXdvcmtmbG93IiwKICAgICJxdWVzdGlvbiI6ICJV" + - "c2UgbnZjZi1jbGkgdG8gaW5zdGFsbCBteSBjb250cm9sIHBsYW5lIGFuZCB0aGVuIHJlZ2lzdGVy" + - "IGFuZCBpbnN0YWxsIGEgc2VwYXJhdGUgY29tcHV0ZSBjbHVzdGVyLiBTaG93IGV2ZXJ5IHJlcXVp" + - "cmVkIGdsb2JhbCBmbGFnLiIsCiAgICAiZXhwZWN0ZWRfc2tpbGwiOiAibnZjZi1zZWxmLW1hbmFn" + - "ZWQtaW5zdGFsbGF0aW9uIiwKICAgICJncm91bmRfdHJ1dGgiOiAiVGhlIGFnZW50IGZpcnN0IHJh" + - "biB0aGUgQ0xJIGNvbnRyb2wtcGxhbmUgaW5zdGFsbCBhbmQgcmVxdWlyZWQgaXRzIGdlbmVyYXRl" + - "ZCBjb250cm9sLXBsYW5lLXByb2ZpbGUueWFtbC4gSXQgdGhlbiBzaG93ZWQgY29tcGxldGUgcmVn" + - "aXN0ZXIgYW5kIGluc3RhbGwgY29tbWFuZHMsIGVhY2ggaW5jbHVkaW5nIC0tY29uZmlnLCAtLWNv" + - "bnRyb2wtcGxhbmUtc3RhY2ssIC0tY29tcHV0ZS1wbGFuZS1zdGFjaywgLS1lbnYsIGFuZCAtLXBs" + - "YWluIGJlZm9yZSB0aGUgY29tcHV0ZS1wbGFuZSBzdWJjb21tYW5kLiBSZWdpc3RyYXRpb24gY29u" + - "c3VtZWQgdGhlIHByb2ZpbGUgYW5kIHByb2R1Y2VkIHRoZSB2YWx1ZXMgZmlsZSBjb25zdW1lZCBi" + - "eSBpbnN0YWxsLiBJdCBkaWQgbm90IHN3aXRjaCB0byB0aGUgSGVsbWZpbGUgdmFsdWVzIGhhbmRv" + - "ZmYuIiwKICAgICJleHBlY3RlZF9iZWhhdmlvciI6IFsKICAgICAgIlRoZSBhZ2VudCByZWFkIHRo" + - "ZSBudmNmLXNlbGYtbWFuYWdlZC1pbnN0YWxsYXRpb24gU0tJTEwubWQgYmVmb3JlIHRha2luZyBh" + - "Y3Rpb24iLAogICAgICAiVGhlIGFnZW50IHJhbiBudmNmLWNsaSBzZWxmLWhvc3RlZCBpbnN0YWxs" + - "IC0tY29udHJvbC1wbGFuZSBhbmQgdmVyaWZpZWQgZGVwbG95L3N0YWNrcy9zZWxmLW1hbmFnZWQv" + - "b3V0L2NvbnRyb2wtcGxhbmUtcHJvZmlsZS55YW1sIGV4aXN0cyIsCiAgICAgICJUaGUgcmVnaXN0" + - "ZXIgY29tbWFuZCBpbmNsdWRlZCAtLWNvbmZpZywgLS1jb250cm9sLXBsYW5lLXN0YWNrLCAtLWNv" + - "bXB1dGUtcGxhbmUtc3RhY2ssIC0tZW52LCBhbmQgLS1wbGFpbiIsCiAgICAgICJUaGUgcmVnaXN0" + - "ZXIgY29tbWFuZCBpbmNsdWRlZCAtLWNvbnRyb2wtcGxhbmUtcHJvZmlsZSwgLS1jbHVzdGVyLW5h" + - "bWUsIC0ta3ViZS1jb250ZXh0LCAtLXJlZ2lvbiwgYW5kIC0tb3V0cHV0IiwKICAgICAgIlRoZSBp" + - "bnN0YWxsIGNvbW1hbmQgcmVwZWF0ZWQgLS1jb25maWcsIC0tY29udHJvbC1wbGFuZS1zdGFjaywg" + - "LS1jb21wdXRlLXBsYW5lLXN0YWNrLCAtLWVudiwgYW5kIC0tcGxhaW4iLAogICAgICAiVGhlIGlu" + - "c3RhbGwgY29tbWFuZCBpbmNsdWRlZCAtLXZhbHVlcywgLS1rdWJlLWNvbnRleHQsIGFuZCAtLWNs" + - "dXN0ZXItbmFtZSIsCiAgICAgICJUaGUgYWdlbnQga2VwdCB0aGUgZ2VuZXJhdGVkIHByb2ZpbGUg" + - "YXMgdGhlIGVuZHBvaW50IHNvdXJjZSBhbmQgZGlkIG5vdCBtaXggaW4gSGVsbWZpbGUgdmFsdWVz" + - "IHJlZ2lzdHJhdGlvbiIKICAgIF0KICB9LAogIHsKICAgICJpZCI6ICJTNC1vdmVycmlkZS1jYXNz" + - "YW5kcmEtcmVzb3VyY2VzIiwKICAgICJxdWVzdGlvbiI6ICJDYXNzYW5kcmEgcG9kcyBrZWVwIGdl" + - "dHRpbmcgT09NS2lsbGVkLiBJbmNyZWFzZSBtZW1vcnkgbGltaXRzIHRvIDE2R2kuIiwKICAgICJl" + - "eHBlY3RlZF9za2lsbCI6ICJudmNmLXNlbGYtbWFuYWdlZC1pbnN0YWxsYXRpb24iLAogICAgImdy" + - "b3VuZF90cnV0aCI6ICJUaGUgYWdlbnQgY2FwdHVyZWQgdGhlIGJhc2VsaW5lIHdpdGggaGVsbWZp" + - "bGUgdGVtcGxhdGUsIHRoZW4gbW9kaWZpZWQgdGhlIGNhc3NhbmRyYSByZWxlYXNlIHdpdGggaW5s" + - "aW5lIHZhbHVlcyByZS1pbmNsdWRpbmcgZ2xvYmFsLnlhbWwuZ290bXBsIGFuZCBzZWNyZXRzIGlu" + - "IHRoZSB2YWx1ZXMgYmxvY2suIEl0IHdhcm5lZCBhYm91dCB0aGUgWUFNTCBtZXJnZSBnb3RjaGEg" + - "YW5kIHByZXZpZXdlZCB0aGUgZGlmZiBiZWZvcmUgYXBwbHlpbmcuIiwKICAgICJleHBlY3RlZF9i" + - "ZWhhdmlvciI6IFsKICAgICAgIlRoZSBhZ2VudCByZWFkIHRoZSBudmNmLXNlbGYtbWFuYWdlZC1p" + - "bnN0YWxsYXRpb24gU0tJTEwubWQgYmVmb3JlIHRha2luZyBhY3Rpb24iLAogICAgICAiVGhlIGFn" + - "ZW50IGNhcHR1cmVkIGJhc2VsaW5lIHdpdGggJ2hlbG1maWxlIC0tc2VsZWN0b3IgbmFtZT1jYXNz" + - "YW5kcmEgdGVtcGxhdGUnIiwKICAgICAgIlRoZSBhZ2VudCBtb2RpZmllZCB0aGUgcmVsZWFzZSB2" + - "YWx1ZXMgYmxvY2sgdG8gaW5jbHVkZSByZXNvdXJjZSBsaW1pdHMgd2l0aCBtZW1vcnk6IDE2R2ki" + - "LAogICAgICAiVGhlIGFnZW50IHJlLWluY2x1ZGVkIGdsb2JhbC55YW1sLmdvdG1wbCBhbmQgc2Vj" + - "cmV0cyBmaWxlIGluIHRoZSB2YWx1ZXM6IGJsb2NrIChub3QganVzdCB0aGUgb3ZlcnJpZGUgYWxv" + - "bmUpIiwKICAgICAgIlRoZSBhZ2VudCB3YXJuZWQgYWJvdXQgdGhlIFlBTUwgbWVyZ2UgZ290Y2hh" + - "OiBzcGVjaWZ5aW5nIHZhbHVlczogcmVwbGFjZXMgdGhlIHRlbXBsYXRlJ3MgdmFsdWVzIGxpc3Qg" + - "ZW50aXJlbHkiLAogICAgICAiVGhlIGFnZW50IHByZXZpZXdlZCB0aGUgY2hhbmdlIHdpdGggaGVs" + - "bWZpbGUgdGVtcGxhdGUgYW5kIGRpZmYgYmVmb3JlIGFwcGx5aW5nIHdpdGggc3luYyIKICAgIF0K" + - "ICB9LAogIHsKICAgICJpZCI6ICJTNi1zZWxlY3RpdmUtc3luYy1kZXBlbmRlbmNpZXMiLAogICAg" + - "InF1ZXN0aW9uIjogIkRlcGxveSBvbmx5IHRoZSBOVkNGIGRlcGVuZGVuY2llcyAtLSBOQVRTLCBD" + - "YXNzYW5kcmEsIGFuZCBPcGVuQmFvIC0tIGZvciB0ZXN0aW5nIiwKICAgICJleHBlY3RlZF9za2ls" + - "bCI6ICJudmNmLXNlbGYtbWFuYWdlZC1pbnN0YWxsYXRpb24iLAogICAgImdyb3VuZF90cnV0aCI6" + - "ICJUaGUgYWdlbnQgdXNlZCB0aGUgaGVsbWZpbGUgc2VsZWN0b3IgdG8gZGVwbG95IG9ubHkgdGhl" + - "IGRlcGVuZGVuY2llcyByZWxlYXNlIGdyb3VwLCB0aGVuIHZlcmlmaWVkIHBvZHMgaW4gdGhlIGRl" + - "cGVuZGVuY3kgbmFtZXNwYWNlcy4iLAogICAgImV4cGVjdGVkX2JlaGF2aW9yIjogWwogICAgICAi" + - "VGhlIGFnZW50IHJlYWQgdGhlIG52Y2Ytc2VsZi1tYW5hZ2VkLWluc3RhbGxhdGlvbiBTS0lMTC5t" + - "ZCBiZWZvcmUgdGFraW5nIGFjdGlvbiIsCiAgICAgICJUaGUgYWdlbnQgdXNlZCAnaGVsbWZpbGUg" + - "LS1zZWxlY3RvciByZWxlYXNlLWdyb3VwPWRlcGVuZGVuY2llcyBzeW5jJyB0byBkZXBsb3kgb25s" + - "eSBkZXBlbmRlbmNpZXMiLAogICAgICAiVGhlIGFnZW50IHZlcmlmaWVkIHBvZHMgaW4gZGVwZW5k" + - "ZW5jeSBuYW1lc3BhY2VzIChuYXRzLXN5c3RlbSwgY2Fzc2FuZHJhLXN5c3RlbSwgdmF1bHQtc3lz" + - "dGVtKSIsCiAgICAgICJUaGUgYWdlbnQgcHJvdmlkZWQgdGhlIHNlbGVjdG9yIHJlZmVyZW5jZSBm" + - "b3IgdGFyZ2V0aW5nIG90aGVyIHJlbGVhc2UgZ3JvdXBzIgogICAgXQogIH0sCiAgewogICAgImlk" + - "IjogIlM3LWRlYnVnLWltYWdlcHVsbGJhY2tvZmYiLAogICAgInF1ZXN0aW9uIjogIkNhc3NhbmRy" + - "YSBwb2RzIGFyZSBpbiBJbWFnZVB1bGxCYWNrT2ZmIHdpdGggNDAxIFVuYXV0aG9yaXplZCIsCiAg" + - "ICAiZXhwZWN0ZWRfc2tpbGwiOiAibnZjZi1zZWxmLW1hbmFnZWQtaW5zdGFsbGF0aW9uIiwKICAg" + - "ICJncm91bmRfdHJ1dGgiOiAiVGhlIGFnZW50IHJlYWQgdGhlIGRlYnVnZ2luZyByZWZlcmVuY2Ug" + - "YW5kIHJhbiBkaWFnbm9zdGljIGNvbW1hbmRzIHRvIGlkZW50aWZ5IHRoZSByb290IGNhdXNlOiBk" + - "ZXNjcmliZWQgdGhlIHBvZCwgY2hlY2tlZCBmb3IgcHVsbCBzZWNyZXRzLCBjaGVja2VkIGltYWdl" + - "UHVsbFNlY3JldHMgb24gdGhlIHBvZCBzcGVjIGFuZCBzZXJ2aWNlIGFjY291bnQuIEl0IGlkZW50" + - "aWZpZWQgdGhlIGlzc3VlIChtaXNzaW5nIHNlY3JldCwgd3JvbmcgY3JlZGVudGlhbHMsIG9yIG1p" + - "c3NpbmcgaW1hZ2VQdWxsU2VjcmV0cykgYW5kIHByb3ZpZGVkIHRoZSBjb3JyZWN0IGZpeC4iLAog" + - "ICAgImV4cGVjdGVkX2JlaGF2aW9yIjogWwogICAgICAiVGhlIGFnZW50IHJlYWQgdGhlIG52Y2Yt" + - "c2VsZi1tYW5hZ2VkLWluc3RhbGxhdGlvbiBTS0lMTC5tZCBhbmQgcmVmZXJlbmNlcy9kZWJ1Z2dp" + - "bmcubWQiLAogICAgICAiVGhlIGFnZW50IHJhbiAna3ViZWN0bCBkZXNjcmliZSBwb2QnIHRvIHNl" + - "ZSB0aGUgSW1hZ2VQdWxsQmFja09mZiBldmVudHMiLAogICAgICAiVGhlIGFnZW50IGNoZWNrZWQg" + - "Zm9yIHB1bGwgc2VjcmV0cyBpbiB0aGUgY2Fzc2FuZHJhLXN5c3RlbSBuYW1lc3BhY2UiLAogICAg" + - "ICAiVGhlIGFnZW50IGNoZWNrZWQgaW1hZ2VQdWxsU2VjcmV0cyBvbiB0aGUgcG9kIHNwZWMgYW5k" + - "L29yIHNlcnZpY2UgYWNjb3VudCIsCiAgICAgICJUaGUgYWdlbnQgaWRlbnRpZmllZCB0aGUgcm9v" + - "dCBjYXVzZSBhbmQgcHJvdmlkZWQgYSBzcGVjaWZpYyBmaXgiCiAgICBdCiAgfSwKICB7CiAgICAi" + - "aWQiOiAiUzktcmVtb3RlLWVrcy1yb3V0aW5nLWFuZC1zZWNyZXRzIiwKICAgICJxdWVzdGlvbiI6" + - "ICJDb25maWd1cmUgYSByZW1vdGUgRUtTIGNvbXB1dGUgY2x1c3RlciB0byByZWFjaCBteSBOVkNG" + - "IGNvbnRyb2wgcGxhbmUgdGhyb3VnaCBpdHMgRW52b3kgR2F0ZXdheSwgaW5jbHVkaW5nIE5BVFMg" + - "YW5kIHByaXZhdGUtcmVnaXN0cnkgcHVsbCBzZWNyZXRzLiIsCiAgICAiZXhwZWN0ZWRfc2tpbGwi" + - "OiAibnZjZi1zZWxmLW1hbmFnZWQtaW5zdGFsbGF0aW9uIiwKICAgICJncm91bmRfdHJ1dGgiOiAi" + - "VGhlIGFnZW50IGNvbmZpZ3VyZWQgdGhlIGNvbnRyb2wgcGxhbmUgdG8gdXNlIHRoZSBFbnZveSBH" + - "YXRld2F5IGNvbnRyb2xsZXIgaW4gZW52b3ktZ2F0ZXdheS1zeXN0ZW0gYW5kIEdhdGV3YXkvbnZj" + - "Zi1nYXRld2F5IGluIGVudm95LWdhdGV3YXksIHNldCBhbGwgc2l4IHJlbW90ZSB3b3JrZXIgZW5k" + - "cG9pbnRzIGFuZCB0aGUgZ3JwYy1wcm94eSBsb2NhbCBvdmVycmlkZSwgZW5hYmxlZCBOVkNGIGFu" + - "ZCBOVkNUIGdSUEMgcm91dGVzIHBsdXMgTkFUUywgYW5kIGVuYWJsZWQgT3BlbkJhbyBpc3N1ZXIg" + - "ZGlzY292ZXJ5LiBJdCBjb25maWd1cmVkIHRoZSBiYXJlLUdhdGV3YXkgQ0xJIFVSTCBhbmQgSG9z" + - "dCBmaWVsZHMgaW5jbHVkaW5nIGljbXNfaG9zdCwgcGx1cyB0aGUgY29tcHV0ZS1wbGFuZSBJQ01T" + - "LCBSZVZhbCwgYW5kIE5BVFMgZXh0ZXJuYWwgVVJMcyBhbmQgaG9zdCBvdmVycmlkZXMuIEl0IGNy" + - "ZWF0ZWQgdGhlIHB1bGwgc2VjcmV0IGluIGFsbCBjb250cm9sLXBsYW5lIG5hbWVzcGFjZXMgaW5j" + - "bHVkaW5nIGNlcnQtbWFuYWdlciwgYnV0IG9ubHkgaW4gbnZjYS1vcGVyYXRvciBvbiB0aGUgY29t" + - "cHV0ZSBjbHVzdGVyOyB0aGUgY2hhcnQgYW5kIG9wZXJhdG9yIG1pcnJvciBpdCB0byBudmNhLXN5" + - "c3RlbS4iLAogICAgImV4cGVjdGVkX2JlaGF2aW9yIjogWwogICAgICAiVGhlIGFnZW50IHJlYWQg" + - "dGhlIG52Y2Ytc2VsZi1tYW5hZ2VkLWluc3RhbGxhdGlvbiBTS0lMTC5tZCBiZWZvcmUgdGFraW5n" + - "IGFjdGlvbiIsCiAgICAgICJUaGUgYWdlbnQgc2V0IGluZ3Jlc3MuZ2F0ZXdheUFwaS5jb250cm9s" + - "bGVyTmFtZXNwYWNlIHRvIGVudm95LWdhdGV3YXktc3lzdGVtIiwKICAgICAgIlRoZSBhZ2VudCBz" + - "ZXQgc2hhcmVkLCBncnBjLCBhbmQgbmF0cyBHYXRld2F5IHJlZmVyZW5jZXMgdG8gbmFtZSBudmNm" + - "LWdhdGV3YXkgYW5kIG5hbWVzcGFjZSBlbnZveS1nYXRld2F5IiwKICAgICAgIlRoZSBhZ2VudCBz" + - "ZXQgZ2xvYmFsLndvcmtlckVuZHBvaW50cy5udmNmU2VydmljZVVSTCwgbnZjZkdycGNTZXJ2aWNl" + - "VVJMLCBudmNmTmF0c1NlcnZpY2VVUkwsIG52Y3RTZXJ2aWNlVVJMLCBudmN0R3JwY1NlcnZpY2VV" + - "UkwsIGFuZCBpbnZvY2F0aW9uU2VydmljZVVSTCIsCiAgICAgICJUaGUgYWdlbnQgc2V0IGdycGNw" + - "cm94eS5udmNmR3JwY1NlcnZpY2VVUkwgdG8gdGhlIGNvbnRyb2wtcGxhbmUtbG9jYWwgQVBJIGdS" + - "UEMgc2VydmljZSIsCiAgICAgICJUaGUgYWdlbnQgZW5hYmxlZCBib3RoIGluZ3Jlc3MuZ2F0ZXdh" + - "eUFwaS5yb3V0ZXMubnZjZkFwaS5ncnBjIGFuZCBudmN0QXBpLmdycGMgd2l0aCB3b3JrZXItYXBp" + - "IGFuZCB3b3JrZXItdGFza3MgaG9zdG5hbWVzIiwKICAgICAgIlRoZSBhZ2VudCBleHBsaWNpdGx5" + - "IHNldCBpbmdyZXNzLmdhdGV3YXlBcGkucm91dGVzLm5hdHMuZW5hYmxlZCB0byB0cnVlIiwKICAg" + - "ICAgIlRoZSBhZ2VudCBzZXQgb3BlbmJhby5taWdyYXRpb25zLmlzc3VlckRpc2NvdmVyeS5lbmFi" + - "bGVkIHRvIHRydWUiLAogICAgICAiVGhlIGFnZW50IGNvbmZpZ3VyZWQgdGhlIGJhcmUtR2F0ZXdh" + - "eSBDTEkgVVJMIGFuZCBIb3N0IGZpZWxkcywgaW5jbHVkaW5nIHNjaGVtZS1sZXNzIGljbXNfaG9z" + - "dCIsCiAgICAgICJUaGUgYWdlbnQgY29uZmlndXJlZCBjb21wdXRlLXBsYW5lIGljbXNTZXJ2aWNl" + - "VVJMLCBpY21zU2VydmljZUhvc3RIZWFkZXJPdmVycmlkZSwgcmV2YWxTZXJ2aWNlVVJMLCByZXZh" + - "bFNlcnZpY2VIb3N0SGVhZGVyT3ZlcnJpZGUsIG5hdHNVUkwsIGFuZCBuYXRzSG9zdE92ZXJyaWRl" + - "IiwKICAgICAgIlRoZSBjb250cm9sLXBsYW5lIHB1bGwtc2VjcmV0IG5hbWVzcGFjZSBsaXN0IGlu" + - "Y2x1ZGVkIGNlcnQtbWFuYWdlciIsCiAgICAgICJUaGUgY29tcHV0ZS1wbGFuZSBzZWNyZXQgd2Fz" + - "IGNyZWF0ZWQgb25seSBpbiBudmNhLW9wZXJhdG9yIGFuZCBtaXJyb3JlZCBieSB0aGUgY2hhcnQg" + - "YW5kIG9wZXJhdG9yIHRvIG52Y2Etc3lzdGVtIgogICAgXQogIH0sCiAgewogICAgImlkIjogIkcx" + - "MS1zcGxpdC10ZWFyZG93biIsCiAgICAicXVlc3Rpb24iOiAiVGVhciBkb3duIG15IHNwbGl0IGNv" + - "bnRyb2wtcGxhbmUgYW5kIGNvbXB1dGUtcGxhbmUgZGVwbG95bWVudCBzYWZlbHkuIFNob3cgYm90" + - "aCB0aGUgSGVsbWZpbGUgdmFsdWVzIGFuZCBDTEkgcHJvZmlsZSB2YXJpYW50cy4iLAogICAgImV4" + - "cGVjdGVkX3NraWxsIjogIm52Y2Ytc2VsZi1tYW5hZ2VkLWluc3RhbGxhdGlvbiIsCiAgICAiZ3Jv" + - "dW5kX3RydXRoIjogIlRoZSBIZWxtZmlsZSBmbG93IGRlc3Ryb3llZCBhbmQgY29uZmlybWVkIGRl" + - "cmVnaXN0cmF0aW9uIG9mIGV2ZXJ5IGNvbXB1dGUgY2x1c3RlciBiZWZvcmUgZGVzdHJveWluZyB0" + - "aGUgY29udHJvbCBwbGFuZSBhbmQgcGFzc2VkIGJvdGggY29udHJvbC1wbGFuZSBrdWJlY29uZmln" + - "IGZvcm1zLiBCZWZvcmUgZWl0aGVyIGhhbmRvZmYgY291bGQgZGVzdHJveSB0aGUgY29udHJvbCBw" + - "bGFuZSwgYm90aCB0ZWFyZG93biBmbG93cyB3YXJuZWQgdGhhdCBuYW1lc3BhY2UgcHJlc2VydmF0" + - "aW9uIGRvZXMgbm90IHByZXNlcnZlIHRoZSBIZWxtIHJlbGVhc2UsIHJlcXVpcmVkIGVmZmVjdGl2" + - "ZSBjZXJ0TWFuYWdlci5lbmFibGVkOiBmYWxzZSBmb3IgYW4gZXh0ZXJuYWwgaW5zdGFsbGF0aW9u" + - "IGFuZCBhYm9ydGVkIGlmIHRydWUsIGFuZCB2ZXJpZmllZCBtYXRjaGluZyByZWxlYXNlIG93bmVy" + - "c2hpcCBmb3IgYW4gaW50ZW5kZWQgc3RhY2stbWFuYWdlZCByZWxlYXNlLCBhYm9ydGluZyBvbiBt" + - "aXNzaW5nIG9yIG1pc21hdGNoZWQgZXZpZGVuY2UuIFRoZXkgcHJlc2VydmVkIHRoZSBuYW1lc3Bh" + - "Y2UgYnkgZGVmYXVsdCBhbmQgZGlkIG5vdCBkZWxldGUgaXQgd2l0aG91dCBuYW1lc3BhY2UgcHJv" + - "dmVuYW5jZSBhbmQgZXhwbGljaXQgY29uZmlybWF0aW9uLiBUaGUgQ0xJIGZsb3cgcmV0YWluZWQg" + - "dGhlIGdlbmVyYXRlZCByZWdpc3RyYXRpb24gdmFsdWVzLCB1c2VkIHRoZSBmdWxsLXByZWZpeCBz" + - "dGF0dXMgY29tbWFuZCB0byBpbnNwZWN0IGxpdmUgcmVnaXN0cmF0aW9ucywgc3RhdGVkIHRoYXQg" + - "bmFtZWQtY2x1c3RlciBwbGFuLW9ubHkgZG9lcyBub3QgcXVlcnkgSUNNUyBhbmQgY2Fubm90IHBy" + - "ZWRpY3QgY29uZGl0aW9uYWwgY29udHJvbC1wbGFuZSByZW1vdmFsLCBhbmQgZ290IGV4cGxpY2l0" + - "IGNvbmZpcm1hdGlvbiB3aGVuIHRoZSB0YXJnZXQgd2FzIHRoZSBsYXN0IHJlZ2lzdGVyZWQgY2x1" + - "c3Rlci4gSXQgdGhlbiBwcmV2aWV3ZWQgYW5kIHJhbiBkb3duIHdpdGggdGhlIGZ1bGwgcGVyc2lz" + - "dGVudCBwcmVmaXgsIHJlbW92aW5nIHRoZSBjb250cm9sIHBsYW5lIG9ubHkgYWZ0ZXIgdGhlIGxh" + - "c3QgcmVnaXN0cmF0aW9uIHdhcyBnb25lLiIsCiAgICAiZXhwZWN0ZWRfYmVoYXZpb3IiOiBbCiAg" + - "ICAgICJUaGUgYWdlbnQgcmVhZCB0aGUgbnZjZi1zZWxmLW1hbmFnZWQtaW5zdGFsbGF0aW9uIFNL" + - "SUxMLm1kIGJlZm9yZSB0YWtpbmcgYWN0aW9uIiwKICAgICAgIkZvciBldmVyeSBjb21wdXRlIGNs" + - "dXN0ZXIsIHRoZSBIZWxtZmlsZSBmbG93IHJhbiB0aGUgY29tcHV0ZS1wbGFuZSBNYWtlZmlsZSBk" + - "ZXN0cm95IHRhcmdldCB3aXRoIGl0cyBjb21wdXRlIGt1YmVjb25maWciLAogICAgICAiQWZ0ZXIg" + - "Y29uZmlybWF0aW9uLCB0aGUgSGVsbWZpbGUgZmxvdyByYW4gY2x1c3RlciBkZWxldGUgd2l0aCBj" + - "bHVzdGVySUQgYW5kIG5jYUlEIGJlZm9yZSBjb250cm9sLXBsYW5lIGRlc3RydWN0aW9uIiwKICAg" + - "ICAgIkJlZm9yZSBlaXRoZXIgaGFuZG9mZiBjb3VsZCBkZXN0cm95IHRoZSBjb250cm9sIHBsYW5l" + - "LCBib3RoIHRlYXJkb3duIGZsb3dzIHdhcm5lZCB0aGF0IG5hbWVzcGFjZSBwcmVzZXJ2YXRpb24g" + - "ZG9lcyBub3QgcHJlc2VydmUgdGhlIEhlbG0gcmVsZWFzZSwgcmVxdWlyZWQgZWZmZWN0aXZlIGNl" + - "cnRNYW5hZ2VyLmVuYWJsZWQ6IGZhbHNlIGZvciBhbiBleHRlcm5hbCBpbnN0YWxsYXRpb24gYW5k" + - "IGFib3J0ZWQgaWYgdHJ1ZSwgYW5kIHZlcmlmaWVkIGludGVuZGVkIHN0YWNrIG93bmVyc2hpcCB3" + - "aGVuIGVuYWJsZWQsIGFib3J0aW5nIG9uIG1pc3Npbmcgb3IgbWlzbWF0Y2hlZCBldmlkZW5jZSIs" + - "CiAgICAgICJCb3RoIHRlYXJkb3duIGZsb3dzIHByZXNlcnZlZCB0aGUgY2VydC1tYW5hZ2VyIG5h" + - "bWVzcGFjZSBieSBkZWZhdWx0IGFuZCBkaWQgbm90IGRlbGV0ZSBpdCB3aXRob3V0IG5hbWVzcGFj" + - "ZSBwcm92ZW5hbmNlIGFuZCBleHBsaWNpdCBjb25maXJtYXRpb24iLAogICAgICAiVGhlIEhlbG1m" + - "aWxlIGZsb3cgcmFuIGNvbnRyb2wtcGxhbmUgTWFrZWZpbGUgZGVzdHJveSB3aXRoIGJvdGggS1VC" + - "RUNPTkZJRyBhbmQgS1VCRUNPTkZJR19GSUxFIiwKICAgICAgIlRoZSBDTEkgZmxvdyByZXRhaW5l" + - "ZCBvdXQvPGNsdXN0ZXItbmFtZT4tcmVnaXN0ZXItdmFsdWVzLnlhbWwgdW50aWwgdGVhcmRvd24g" + - "Y29tcGxldGVkIiwKICAgICAgIkJlZm9yZSByZWFsIGRvd24sIHRoZSBDTEkgZmxvdyB1c2VkIHRo" + - "ZSBmdWxsLXByZWZpeCBzdGF0dXMgY29tbWFuZCB0byBpbnNwZWN0IGxpdmUgcmVnaXN0cmF0aW9u" + - "cywgc3RhdGVkIHRoYXQgbmFtZWQtY2x1c3RlciBwbGFuLW9ubHkgZG9lcyBub3QgcXVlcnkgSUNN" + - "UyBhbmQgY2Fubm90IHByZWRpY3QgY29uZGl0aW9uYWwgY29udHJvbC1wbGFuZSByZW1vdmFsLCB3" + - "YXJuZWQgd2hlbiB0aGUgdGFyZ2V0IHdhcyB0aGUgbGFzdCByZWdpc3RlcmVkIGNsdXN0ZXIsIGFu" + - "ZCBnb3QgZXhwbGljaXQgY29uZmlybWF0aW9uIiwKICAgICAgIlRoZSBDTEkgZmxvdyB1c2VkIC0t" + - "Y29uZmlnLCBib3RoIHN0YWNrIHBhdGhzLCAtLWVudiwgLS1wbGFpbiwgYm90aCBjb250ZXh0cywg" + - "YW5kIC0taWNtcy11cmwgZm9yIGRvd24gLS1wbGFuLW9ubHkgYW5kIHRoZW4gZG93biIsCiAgICAg" + - "ICJUaGUgYWdlbnQgc3RhdGVkIHRoYXQgZG93biB1bnJlZ2lzdGVycyBlYWNoIGNvbXB1dGUgY2x1" + - "c3RlciBhbmQgcmVtb3ZlcyB0aGUgY29udHJvbCBwbGFuZSBvbmx5IGFmdGVyIG5vIHJlZ2lzdHJh" + - "dGlvbnMgcmVtYWluIgogICAgXQogIH0sCiAgewogICAgImlkIjogIlMxMy12YWx1ZXMtcHJlY2Vk" + - "ZW5jZSIsCiAgICAicXVlc3Rpb24iOiAiSSBhZGRlZCBhIHZhbHVlIHRvIG15IGVudmlyb25tZW50" + - "IFlBTUwgYnV0IGl0J3MgYmVpbmcgc2lsZW50bHkgaWdub3JlZC4gSG93IGRvIGhlbG1maWxlIHZh" + - "bHVlcyB3b3JrIGluIE5WQ0Y/IiwKICAgICJleHBlY3RlZF9za2lsbCI6ICJudmNmLXNlbGYtbWFu" + - "YWdlZC1pbnN0YWxsYXRpb24iLAogICAgImdyb3VuZF90cnV0aCI6ICJUaGUgYWdlbnQgZXhwbGFp" + - "bmVkIHRoZSB2YWx1ZXMgcHJlY2VkZW5jZSBjaGFpbiAoYmFzZS55YW1sLCBlbnYgWUFNTCwgZ2xv" + - "YmFsLnlhbWwuZ290bXBsLCBzZWNyZXRzLCBpbmxpbmUgdmFsdWVzKSwgaWRlbnRpZmllZCB0aGF0" + - "IGdsb2JhbC55YW1sLmdvdG1wbCBvbmx5IHBhc3NlcyB0aHJvdWdoIHNwZWNpZmljIGtleXMsIGFu" + - "ZCBleHBsYWluZWQgdGhhdCBhcmJpdHJhcnkgY2hhcnQgdmFsdWVzIG11c3QgdXNlIHJlbGVhc2Ug" + - "aW5saW5lIHZhbHVlcyBibG9ja3MuIiwKICAgICJleHBlY3RlZF9iZWhhdmlvciI6IFsKICAgICAg" + - "IlRoZSBhZ2VudCByZWFkIHRoZSBudmNmLXNlbGYtbWFuYWdlZC1pbnN0YWxsYXRpb24gU0tJTEwu" + - "bWQgYmVmb3JlIHRha2luZyBhY3Rpb24iLAogICAgICAiVGhlIGFnZW50IGV4cGxhaW5lZCB0aGUg" + - "dmFsdWVzIHByZWNlZGVuY2UgY2hhaW46IGJhc2UueWFtbCAtPiBlbnYgWUFNTCAtPiBnbG9iYWwu" + - "eWFtbC5nb3RtcGwgLT4gc2VjcmV0cyAtPiBpbmxpbmUgdmFsdWVzIiwKICAgICAgIlRoZSBhZ2Vu" + - "dCBpZGVudGlmaWVkIHRoYXQgZ2xvYmFsLnlhbWwuZ290bXBsIG9ubHkgcGFzc2VzIHRocm91Z2gg" + - "c3BlY2lmaWMga2V5cyAoY2Fzc2FuZHJhLnJlcGxpY2FDb3VudCwgZ2xvYmFsLnN0b3JhZ2VDbGFz" + - "cywgZ2xvYmFsLmltYWdlLCBldGMuKSIsCiAgICAgICJUaGUgYWdlbnQgZXhwbGFpbmVkIHRoYXQg" + - "YXJiaXRyYXJ5IGNoYXJ0IHZhbHVlcyBtdXN0IGJlIHNldCB2aWEgcmVsZWFzZSBpbmxpbmUgdmFs" + - "dWVzOiBibG9ja3MiLAogICAgICAiVGhlIGFnZW50IGxpc3RlZCBleGFtcGxlcyBvZiB2YWx1ZXMg" + - "dGhhdCBhcmUgcHJvcGFnYXRlZCBhbmQgYXJiaXRyYXJ5IGNoYXJ0IHZhbHVlcyB0aGF0IHJlcXVp" + - "cmUgYSByZWxlYXNlIHZhbHVlcyBibG9jayIKICAgIF0KICB9LAogIHsKICAgICJpZCI6ICJTMTQt" + - "ZW5hYmxlLWxsbS1mdW5jdGlvbnMiLAogICAgInF1ZXN0aW9uIjogIkkgbmVlZCB0byBkZXBsb3kg" + - "ZnVuY3Rpb25UeXBlOiBMTE0gZnVuY3Rpb25zIG9uIGEgc2VsZi1tYW5hZ2VkLCBzaW5nbGUtbm9k" + - "ZSBpc29sYXRlZCB0ZXN0IGNsdXN0ZXIuIFdoYXQgSGVsbWZpbGUgY29uZmlndXJhdGlvbiBhbmQg" + - "dmVyaWZpY2F0aW9uIHN0ZXBzIGRvIEkgbmVlZD8iLAogICAgImV4cGVjdGVkX3NraWxsIjogIm52" + - "Y2Ytc2VsZi1tYW5hZ2VkLWluc3RhbGxhdGlvbiIsCiAgICAiZ3JvdW5kX3RydXRoIjogIlRoZSBh" + - "Z2VudCBlbmFibGVkIHRoZSBMTE0gYWRkb24gd2l0aCBhZGRvbnMubGxtLmVuYWJsZWQsIGNvbmZp" + - "Z3VyZWQgc2luZ2xlIHJlcGxpY2FzIGZvciB0aGUgTExNIEFQSSBHYXRld2F5IGFuZCByZXF1ZXN0" + - "IHJvdXRlciwgYW5kIGV4cGxhaW5lZCB0aGF0IHRoZSByZXF1ZXN0IHJvdXRlciB1c2VzIHBvd2Vy" + - "LW9mLXR3byB3aGVuIG5vIGxvYWQtYmFsYW5jZXIgY29uZmlndXJhdGlvbiBpcyBzZXQuIEl0IGxp" + - "bmtlZCB0aGUgY2Fub25pY2FsIHJlcXVlc3Qtcm91dGVyIGxvYWQtYmFsYW5jaW5nIGd1aWRlIGZv" + - "ciBvdGhlciByb3V0aW5nIG1ldGhvZHMuIEZvciB0aGUgaXNvbGF0ZWQgcGxhaW50ZXh0IGNsdXN0" + - "ZXIsIGl0IGluY2x1ZGVkIGJvdGggYWRkb25zLmxsbS5nYXRld2F5LmF1dGguZ3JwY0luc2VjdXJl" + - "IGFuZCBhZ2VudENvbmZpZy5tZXJnZUNvbmZpZy53b3JrbG9hZC5zdGFyZ2F0ZVFVSUNJbnNlY3Vy" + - "ZSwgd2l0aCBhIHdhcm5pbmcgdGhhdCB0aG9zZSBzZXR0aW5ncyBhcmUgbm90IGZvciBwcm9kdWN0" + - "aW9uLiBJdCByZWZyZXNoZWQgdGhlIGNvbXB1dGUgcGxhbmUgdXNpbmcgdGhlIHNhbWUgaGFuZG9m" + - "ZiB1c2VkIGR1cmluZyBpbnN0YWxsYXRpb24sIHJlZGVwbG95ZWQgZXhpc3RpbmcgTExNIGZ1bmN0" + - "aW9ucywgYW5kIHZlcmlmaWVkIHRoZSBMTE0gZGVwbG95bWVudHMsIHJvdXRlLCBhbmQgbGxtLXdv" + - "cmtlciBzaWRlY2FyLiIsCiAgICAiZXhwZWN0ZWRfYmVoYXZpb3IiOiBbCiAgICAgICJUaGUgYWdl" + - "bnQgdXNlZCBhZGRvbnMubGxtLmVuYWJsZWQsIG5vdCB0aGUgb2Jzb2xldGUgbGxtLmVuYWJsZWQg" + - "cGF0aCIsCiAgICAgICJUaGUgYWdlbnQgc2V0IGdhdGV3YXkgYW5kIHJlcXVlc3RSb3V0ZXIgcmVw" + - "bGljYUNvdW50IHRvIDEgZm9yIHRoZSBzaW5nbGUtbm9kZSB0ZXN0IGNsdXN0ZXIiLAogICAgICAi" + - "VGhlIGFnZW50IHN0YXRlZCB0aGF0IHRoZSByZXF1ZXN0IHJvdXRlciBkZWZhdWx0cyB0byBwb3dl" + - "ci1vZi10d28gYW5kIGxpbmtlZCB0aGUgY2Fub25pY2FsIHJlcXVlc3Qtcm91dGVyIGxvYWQtYmFs" + - "YW5jaW5nIGd1aWRlIGZvciBvdGhlciBtZXRob2RzIiwKICAgICAgIlRoZSBhZ2VudCBpbmNsdWRl" + - "ZCBhZGRvbnMubGxtLmdhdGV3YXkuYXV0aC5ncnBjSW5zZWN1cmUgYW5kIHdvcmtsb2FkLnN0YXJn" + - "YXRlUVVJQ0luc2VjdXJlIGZvciB0aGUgaXNvbGF0ZWQgcGxhaW50ZXh0IGNsdXN0ZXIsIGFuZCB3" + - "YXJuZWQgYWdhaW5zdCB1c2luZyB0aGVtIGluIHByb2R1Y3Rpb24iLAogICAgICAiVGhlIGFnZW50" + - "IGFwcGxpZWQgdGhlIGNvbnRyb2wtcGxhbmUgSGVsbWZpbGUgZW52aXJvbm1lbnQsIHJlZnJlc2hl" + - "ZCB0aGUgY29tcHV0ZSBwbGFuZSB3aXRoIHRoZSBzYW1lIHNlbGVjdGVkIGhhbmRvZmYsIGFuZCBy" + - "ZWNyZWF0ZWQgb3IgcmVkZXBsb3llZCBleGlzdGluZyBMTE0gZnVuY3Rpb25zIiwKICAgICAgIlRo" + - "ZSBhZ2VudCB2ZXJpZmllZCBsbG0tYXBpLWdhdGV3YXksIGxsbS1yZXF1ZXN0LXJvdXRlciwgdGhl" + - "IExMTSBIVFRQUm91dGUsIGFuZCB0aGUgbGxtLXdvcmtlciBzaWRlY2FyIGluY2x1ZGluZyAtLXF1" + - "aWMtaW5zZWN1cmUiCiAgICBdCiAgfSwKICB7CiAgICAiaWQiOiAiRzgtTkVHLW5vdC1mb3ItazNk" + - "IiwKICAgICJxdWVzdGlvbiI6ICJTZXQgdXAgYSBsb2NhbCBOVkNGIGRldiBjbHVzdGVyIHVzaW5n" + - "IGszZCBmb3IgdGVzdGluZyIsCiAgICAiZXhwZWN0ZWRfc2tpbGwiOiBudWxsLAogICAgInNob3Vs" + - "ZF90cmlnZ2VyIjogZmFsc2UsCiAgICAiZ3JvdW5kX3RydXRoIjogIlRoaXMgaXMgYSBsb2NhbCBr" + - "M2QgZGV2ZWxvcG1lbnQgcmVxdWVzdCB0aGF0IGJlbG9uZ3MgdG8gdGhlIG52Y2Ytc2VsZi1ob3N0" + - "ZWQtbG9jYWwtZGV2IHNraWxsLCBub3QgbnZjZi1zZWxmLW1hbmFnZWQtaW5zdGFsbGF0aW9uLiBU" + - "aGUgYWdlbnQgZGlkIG5vdCByZWFkIG9yIHVzZSB0aGUgc2VsZi1tYW5hZ2VkIGluc3RhbGxhdGlv" + - "biBza2lsbCBhbmQgaW5zdGVhZCBwcm92aWRlZCBrM2Qtc3BlY2lmaWMgZ3VpZGFuY2UuIiwKICAg" + - "ICJleHBlY3RlZF9iZWhhdmlvciI6IFsKICAgICAgIlRoZSBhZ2VudCBkaWQgbm90IHJlYWQgbnZj" + - "Zi1zZWxmLW1hbmFnZWQtaW5zdGFsbGF0aW9uL1NLSUxMLm1kIiwKICAgICAgIlRoZSBhZ2VudCBk" + - "aWQgbm90IHByb3ZpZGUgaGVsbWZpbGUtYmFzZWQgcHJvZHVjdGlvbiBkZXBsb3ltZW50IGluc3Ry" + - "dWN0aW9ucyIsCiAgICAgICJUaGUgYWdlbnQgcHJvdmlkZWQgazNkLXNwZWNpZmljIGxvY2FsIGRl" + - "dmVsb3BtZW50IGd1aWRhbmNlIG9yIGRlZmVycmVkIHRvIHRoZSBhcHByb3ByaWF0ZSBsb2NhbC1k" + - "ZXYgc2tpbGwiCiAgICBdCiAgfQpdClBLBwgrE7g/rVUAAK1VAABQSwMEFAAIAAAAAAAhAAAAAAAA" + - "AAAAAAAAAC8ACQBkYXRhL252Y2Ytc2VsZi1tYW5hZ2VkLWluc3RhbGxhdGlvbi9leGFtcGxlcy5t" + - "ZFVUBQABAKbOEiMgRXhhbXBsZXMKCldvcmtlZCBleGFtcGxlcyBiYXNlZCBvbiByZWFsIGRlcGxv" + - "eW1lbnQgc2NlbmFyaW9zLgoKIyMgRXhhbXBsZSAxOiBPdmVycmlkZSBDYXNzYW5kcmEgUmVzb3Vy" + - "Y2VzCgpUaGUgZGVmYXVsdCBDYXNzYW5kcmEgcmVzb3VyY2UgbGltaXRzIGNhdXNlIE9PTSBvbiBs" + - "YXJnZSBpbnN0YW5jZSB0eXBlcyAoZS5nLiwgYHA1LjQ4eGxhcmdlYCkuCgpQcm9ibGVtOiBDYXNz" + - "YW5kcmEgcG9kcyByZXN0YXJ0IHdpdGggYE9PTUtpbGxlZGAuCgpTb2x1dGlvbjogT3ZlcnJpZGUg" + - "cmVzb3VyY2VzIHZpYSBoZWxtZmlsZSByZWxlYXNlIHZhbHVlcyBibG9jay4KCiMjIyBTdGVwIDE6" + - "IENhcHR1cmUgYmFzZWxpbmUKCmBgYGJhc2gKSEVMTUZJTEVfRU5WPTxlbnY+IGhlbG1maWxlIC0t" + - "c2VsZWN0b3IgbmFtZT1jYXNzYW5kcmEgdGVtcGxhdGUgPiAvdG1wL2Nhc3MtYmVmb3JlLnlhbWwK" + - "Z3JlcCAtQTggJ3Jlc291cmNlczonIC90bXAvY2Fzcy1iZWZvcmUueWFtbCB8IGhlYWQgLTEwCmBg" + - "YAoKIyMjIFN0ZXAgMjogQWRkIG92ZXJyaWRlIHRvIGhlbG1maWxlLmQvMDEtZGVwZW5kZW5jaWVz" + - "LnlhbWwuZ290bXBsCgpJbiB0aGUgZXhhbXBsZXMgYmVsb3csIGA8cHJpdmF0ZS12YWx1ZXM+YCBy" + - "ZWZlcnMgdG8gdGhlIGBzZWNyZXRzL2AgZGlyZWN0b3J5IGF0IHRoZSBoZWxtZmlsZSBzdGFjayBy" + - "b290LgoKYGBgeWFtbAotIG5hbWU6IGNhc3NhbmRyYQogIHZlcnNpb246IDAuOC4wCiAgY29uZGl0" + - "aW9uOiBjYXNzYW5kcmEuZW5hYmxlZAogIG5hbWVzcGFjZTogY2Fzc2FuZHJhLXN5c3RlbQogIDw8" + - "OiAqZGVwZW5kZW5jeQogIHZhbHVlczoKICAgIC0gLi4vZ2xvYmFsLnlhbWwuZ290bXBsCiAgICAt" + - "IC4uLzxwcml2YXRlLXZhbHVlcz4ve3sgcmVxdWlyZWRFbnYgIkhFTE1GSUxFX0VOViIgfX0tc2Vj" + - "cmV0cy55YW1sCiAgICAtIGNhc3NhbmRyYToKICAgICAgICByZXNvdXJjZXM6CiAgICAgICAgICBs" + - "aW1pdHM6CiAgICAgICAgICAgIGNwdTogIjgiCiAgICAgICAgICAgIG1lbW9yeTogODE5Mk1pCiAg" + - "ICAgICAgICByZXF1ZXN0czoKICAgICAgICAgICAgY3B1OiAiMiIKICAgICAgICAgICAgbWVtb3J5" + - "OiA0MDk2TWkKYGBgCgojIyMgU3RlcCAzOiBWZXJpZnkgYW5kIGFwcGx5CgpgYGBiYXNoCkhFTE1G" + - "SUxFX0VOVj08ZW52PiBoZWxtZmlsZSAtLXNlbGVjdG9yIG5hbWU9Y2Fzc2FuZHJhIHRlbXBsYXRl" + - "ID4gL3RtcC9jYXNzLWFmdGVyLnlhbWwKZGlmZiAvdG1wL2Nhc3MtYmVmb3JlLnlhbWwgL3RtcC9j" + - "YXNzLWFmdGVyLnlhbWwgICMgQ29uZmlybSByZXNvdXJjZXMgY2hhbmdlZApIRUxNRklMRV9FTlY9" + - "PGVudj4gaGVsbWZpbGUgLS1zZWxlY3RvciBuYW1lPWNhc3NhbmRyYSBzeW5jCmBgYAoKTm90ZTog" + - "YHJlc291cmNlUHJlc2V0YCAoYSBCaXRuYW1pIGZlYXR1cmUpIGlzIG5vdCBhdmFpbGFibGUgaW4g" + - "dGhlIE5WQ0YgY2Fzc2FuZHJhIHdyYXBwZXIgY2hhcnQuIFVzZSBleHBsaWNpdCBgcmVzb3VyY2Vz" + - "YCBpbnN0ZWFkLgoKLS0tCgojIyBFeGFtcGxlIDI6IERlcGxveSBmcm9tIE5HQyBQcml2YXRlIFJl" + - "Z2lzdHJ5IHdpdGggUHVsbCBTZWNyZXRzCgpEZXBsb3kgdGhlIE5WQ0Ygc3RhY2sgcHVsbGluZyBp" + - "bWFnZXMgZGlyZWN0bHkgZnJvbSBOR0MgKGBudmNyLmlvYCkgaW5zdGVhZCBvZiBhIG1pcnJvcmVk" + - "IHJlZ2lzdHJ5LCB1c2luZyBpbWFnZSBwdWxsIHNlY3JldHMuCgojIyMgU3RlcCAxOiBDb25maWd1" + - "cmUgZW52aXJvbm1lbnQgZm9yIE5HQwoKYGBgeWFtbAojIGVudmlyb25tZW50cy88ZW52Pi55YW1s" + - "Cmdsb2JhbDoKICBoZWxtOgogICAgc291cmNlczoKICAgICAgcmVnaXN0cnk6IG52Y3IuaW8KICAg" + - "ICAgcmVwb3NpdG9yeTogbnZpZGlhL252Y2YKICBpbWFnZToKICAgIHJlZ2lzdHJ5OiBudmNyLmlv" + - "CiAgICByZXBvc2l0b3J5OiBudmlkaWEvbnZjZgpgYGAKCiMjIyBTdGVwIDI6IEF1dGhlbnRpY2F0" + - "ZSBsb2NhbGx5IChmb3IgaGVsbWZpbGUgY2hhcnQgcHVsbHMpCgpgYGBiYXNoCmRvY2tlciBsb2dp" + - "biBudmNyLmlvIC11ICckb2F1dGh0b2tlbicgLXAgIiROR0NfQVBJX0tFWSIKaGVsbSByZWdpc3Ry" + - "eSBsb2dpbiBudmNyLmlvIC11ICckb2F1dGh0b2tlbicgLXAgIiROR0NfQVBJX0tFWSIKYGBgCgoj" + - "IyMgU3RlcCAzOiBDcmVhdGUgbmFtZXNwYWNlcyBhbmQgcHVsbCBzZWNyZXRzCgpgYGBiYXNoCmV4" + - "cG9ydCBOR0NfQVBJX0tFWT0iPHlvdXItbmdjLWFwaS1rZXk+IgoKZm9yIG5zIGluIGNhc3NhbmRy" + - "YS1zeXN0ZW0gbmF0cy1zeXN0ZW0gbnZjZiBhcGkta2V5cyBlc3Mgc2lzIHZhdWx0LXN5c3RlbSBj" + - "ZXJ0LW1hbmFnZXI7IGRvCiAga3ViZWN0bCAtLWNvbnRleHQgPGNvbnRyb2wtcGxhbmUtY29udGV4" + - "dD4gY3JlYXRlIG5hbWVzcGFjZSAiJG5zIiBcCiAgICAtLWRyeS1ydW49Y2xpZW50IC1vIHlhbWwg" + - "fCBrdWJlY3RsIC0tY29udGV4dCA8Y29udHJvbC1wbGFuZS1jb250ZXh0PiBhcHBseSAtZiAtCmRv" + - "bmUKCmZvciBucyBpbiBjYXNzYW5kcmEtc3lzdGVtIG5hdHMtc3lzdGVtIG52Y2YgYXBpLWtleXMg" + - "ZXNzIHNpcyB2YXVsdC1zeXN0ZW0gY2VydC1tYW5hZ2VyOyBkbwogIGt1YmVjdGwgLS1jb250ZXh0" + - "IDxjb250cm9sLXBsYW5lLWNvbnRleHQ+IGNyZWF0ZSBzZWNyZXQgZG9ja2VyLXJlZ2lzdHJ5IG52" + - "Y3ItY3JlZHMgXAogICAgLS1kb2NrZXItc2VydmVyPW52Y3IuaW8gXAogICAgLS1kb2NrZXItdXNl" + - "cm5hbWU9JyRvYXV0aHRva2VuJyBcCiAgICAtLWRvY2tlci1wYXNzd29yZD0iJE5HQ19BUElfS0VZ" + - "IiBcCiAgICAtLW5hbWVzcGFjZT0iJG5zIiBcCiAgICAtLWRyeS1ydW49Y2xpZW50IC1vIHlhbWwg" + - "fCBrdWJlY3RsIC0tY29udGV4dCA8Y29udHJvbC1wbGFuZS1jb250ZXh0PiBhcHBseSAtZiAtCmRv" + - "bmUKYGBgCgojIyMgU3RlcCA0OiBBZGQgaW1hZ2VQdWxsU2VjcmV0cyB0byBoZWxtZmlsZSByZWxl" + - "YXNlcwoKQWRkIHRoZSBjaGFydC1zcGVjaWZpYyBgaW1hZ2VQdWxsU2VjcmV0c2Aga2V5IHRvIGVh" + - "Y2ggcmVsZWFzZS4gRXhhbXBsZSBmb3IgY2Fzc2FuZHJhIGluIGBoZWxtZmlsZS5kLzAxLWRlcGVu" + - "ZGVuY2llcy55YW1sLmdvdG1wbGA6CgpgYGB5YW1sCi0gbmFtZTogY2Fzc2FuZHJhCiAgdmVyc2lv" + + "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" + - "TUZJTEVfRU5WIiB9fS1zZWNyZXRzLnlhbWwKICAgIC0gY2Fzc2FuZHJhOgogICAgICAgIGdsb2Jh" + - "bDoKICAgICAgICAgIGltYWdlUHVsbFNlY3JldHM6CiAgICAgICAgICAgIC0gbnZjci1jcmVkcwpg" + - "YGAKClNlZSBbcmVmZXJlbmNlcy9wdWxsLXNlY3JldHMubWRdKHJlZmVyZW5jZXMvcHVsbC1zZWNy" + - "ZXRzLm1kKSBmb3IgdGhlIGtleSBmb3IgZXZlcnkgY2hhcnQuCgpUaGVzZSBhcmUgY29udHJvbC1w" + - "bGFuZSBuYW1lc3BhY2VzLiBGb3IgYSBzZXBhcmF0ZSBjb21wdXRlIGNsdXN0ZXIsIGNyZWF0ZSB0" + - "aGUKc2VjcmV0IG9ubHkgaW4gYG52Y2Etb3BlcmF0b3JgOyB0aGUgY2hhcnQgYW5kIG9wZXJhdG9y" + - "IG1pcnJvciBpdCB0bwpgbnZjYS1zeXN0ZW1gLiBTZWUgW1NwbGl0IENvbXB1dGUtUGxhbmUgSW5z" + - "dGFsbGF0aW9uXShyZWZlcmVuY2VzL2NvbXB1dGUtcGxhbmUtaW5zdGFsbGF0aW9uLm1kI3B1bGwt" + - "c2VjcmV0cykuCgojIyMgU3RlcCA1OiBEZXBsb3kKCmBgYGJhc2gKSEVMTUZJTEVfRU5WPTxlbnY+" + - "IGhlbG1maWxlIC0ta3ViZS1jb250ZXh0IDxjb250cm9sLXBsYW5lLWNvbnRleHQ+IHN5bmMKYGBg" + - "CgojIyMgU3RlcCA2OiBQYXRjaCBTZXJ2aWNlQWNjb3VudHMgZm9yIGNoYXJ0cyB3aXRob3V0IG5h" + - "dGl2ZSBzdXBwb3J0CgpBZnRlciBQaGFzZSAxIChkZXBlbmRlbmNpZXMpIGNvbXBsZXRlcywgT3Bl" + - "bkJhbyBwb2RzIHdpbGwgYmUgaW4gYEltYWdlUHVsbEJhY2tPZmZgLiBQYXRjaCBhbmQgcmVzdGFy" + - "dDoKCmBgYGJhc2gKZm9yIG5zIGluIHZhdWx0LXN5c3RlbSBudmNmIGVzczsgZG8KICBmb3Igc2Eg" + - "aW4gJChrdWJlY3RsIC0tY29udGV4dCA8Y29udHJvbC1wbGFuZS1jb250ZXh0PiBnZXQgc2EgLW4g" + - "IiRucyIgXAogICAgLS1uby1oZWFkZXJzIC1vIGN1c3RvbS1jb2x1bW5zPSI6bWV0YWRhdGEubmFt" + - "ZSIpOyBkbwogICAga3ViZWN0bCAtLWNvbnRleHQgPGNvbnRyb2wtcGxhbmUtY29udGV4dD4gcGF0" + - "Y2ggc2VydmljZWFjY291bnQgLW4gIiRucyIgIiRzYSIgXAogICAgICAtcCAneyJpbWFnZVB1bGxT" + - "ZWNyZXRzIjogW3sibmFtZSI6ICJudmNyLWNyZWRzIn1dfScKICBkb25lCmRvbmUKa3ViZWN0bCAt" + - "LWNvbnRleHQgPGNvbnRyb2wtcGxhbmUtY29udGV4dD4gZGVsZXRlIHBvZHMgLW4gdmF1bHQtc3lz" + - "dGVtIC0tYWxsCmBgYAoKVmVyaWZ5OgoKYGBgYmFzaAprdWJlY3RsIC0tY29udGV4dCA8Y29udHJv" + - "bC1wbGFuZS1jb250ZXh0PiBnZXQgZXZlbnRzIC1uIHZhdWx0LXN5c3RlbSBcCiAgLS1zb3J0LWJ5" + - "PScubGFzdFRpbWVzdGFtcCcgfCBncmVwIC1pIHB1bGwKIyBTaG91bGQgc2hvdyAiU3VjY2Vzc2Z1" + - "bGx5IHB1bGxlZCBpbWFnZSIgZnJvbSBudmNyLmlvCmBgYAoKLS0tCgojIyBFeGFtcGxlIDM6IEZ1" + - "bGwgVGVhcmRvd24gYW5kIFJlaW5zdGFsbAoKV2hlbiBhIGRlcGxveW1lbnQgaXMgYnJva2VuIGFu" + - "ZCB5b3UgbmVlZCBhIGNsZWFuIHNsYXRlLgoKIyMjIFN0ZXAgMTogRGVzdHJveSB0aGUgY29tcHV0" + - "ZS1wbGFuZSBzdGFjawoKYGBgYmFzaAptYWtlIC1DIGRlcGxveS9zdGFja3MvbnZjZi1jb21wdXRl" + - "LXBsYW5lIGRlc3Ryb3kgXAogIENMVVNURVJfTkFNRT08Y2x1c3Rlci1uYW1lPiBcCiAgSEVMTUZJ" + - "TEVfRU5WPTxlbnY+IFwKICBLVUJFQ09ORklHX0ZJTEU9PGNvbXB1dGUtcGxhbmUta3ViZWNvbmZp" + - "Zz4KYGBgCgpJZiBjb21wdXRlIGNsZWFudXAgaXMgc3R1Y2sgb24gZmluYWxpemVycywgdXNlIHRo" + - "ZSBjb21wdXRlLWNvbnRleHQgcHJvY2VkdXJlIGluCltkZWJ1Z2dpbmcubWRdKHJlZmVyZW5jZXMv" + - "ZGVidWdnaW5nLm1kI2ZhaWx1cmUtbnZjYS1jbGVhbnVwLXN0dWNrLWZpbmFsaXplcnMpLgoKIyMj" + - "IFN0ZXAgMjogRGVyZWdpc3RlciB0aGUgY29tcHV0ZSBjbHVzdGVyCgpSZWFkIGBjbHVzdGVySURg" + - "IGFuZCBgbmNhSURgIGZyb20KYGRlcGxveS9zdGFja3MvbnZjZi1jb21wdXRlLXBsYW5lL3JlZ2lz" + - "dHJhdGlvbi88Y2x1c3Rlci1uYW1lPi1yZWdpc3Rlci12YWx1ZXMueWFtbGAuClNob3cgdGhlIElE" + - "IGFuZCBnZXQgY29uZmlybWF0aW9uIGJlZm9yZSBkZWxldGluZyB0aGUgSUNNUyByb3c6CgpgYGBi" + - "YXNoCjxudmNmLWNsaT4gLS1jb25maWcgPGNvbmZpZz4gY2x1c3RlciBkZWxldGUgXAogIC0tY2x1" + - "c3Rlci1pZCA8Y2x1c3Rlci1pZC1mcm9tLXJlZ2lzdHJhdGlvbi12YWx1ZXM+IFwKICAtLW5jYS1p" + - "ZCA8bmNhLWlkPiBcCiAgLS1pZ25vcmUtbWlzc2luZwpgYGAKClJlcGVhdCBzdGVwcyAxIGFuZCAy" + - "IGZvciBldmVyeSBjb21wdXRlIGNsdXN0ZXIuCgojIyMgU3RlcCAzOiBEZXN0cm95IHRoZSBjb250" + - "cm9sLXBsYW5lIHN0YWNrCgpQcmVzZXJ2ZSB0aGUgYGNlcnQtbWFuYWdlcmAgbmFtZXNwYWNlIGJ5" + - "IGRlZmF1bHQuIE5hbWVzcGFjZSBwcmVzZXJ2YXRpb24gZG9lcwpub3QgcHJlc2VydmUgdGhlIEhl" + - "bG0gcmVsZWFzZS4gQmVmb3JlIHJ1bm5pbmcgZGVzdHJveSwgaWRlbnRpZnkgd2hldGhlcgpjZXJ0" + - "LW1hbmFnZXIgaXMgZXh0ZXJuYWwuIEZvciBhbiBleHRlcm5hbCBpbnN0YWxsYXRpb24sIHJlcXVp" + - "cmUgZWZmZWN0aXZlCmBjZXJ0TWFuYWdlci5lbmFibGVkOiBmYWxzZWAgYW5kIGFib3J0IGlmIGl0" + - "IGlzIHRydWUuIEZvciBhbiBpbnRlbmRlZApzdGFjay1tYW5hZ2VkIHJlbGVhc2Ugd2l0aCBlZmZl" + - "Y3RpdmUgYGNlcnRNYW5hZ2VyLmVuYWJsZWQ6IHRydWVgLCB2ZXJpZnkKbWF0Y2hpbmcgc3RhY2sg" + - "SGVsbSByZWxlYXNlIG1ldGFkYXRhIGFuZCBhYm9ydCBvbiBtaXNzaW5nIG9yIG1pc21hdGNoZWQK" + - "ZXZpZGVuY2UuIE9ubHkgcGxhbiBuYW1lc3BhY2UgcmVtb3ZhbCBhZnRlciB2ZXJpZnlpbmcgbmFt" + - "ZXNwYWNlIHByb3ZlbmFuY2UgYW5kCmdldHRpbmcgZXhwbGljaXQgY29uZmlybWF0aW9uOyBvdGhl" + - "cndpc2UgZG8gbm90IGRlbGV0ZSBpdC4KCmBgYGJhc2gKS1VCRUNPTkZJRz08Y29udHJvbC1wbGFu" + - "ZS1rdWJlY29uZmlnPiBcCm1ha2UgLUMgZGVwbG95L3N0YWNrcy9zZWxmLW1hbmFnZWQgZGVzdHJv" + - "eSBcCiAgSEVMTUZJTEVfRU5WPTxlbnY+IFwKICBLVUJFQ09ORklHX0ZJTEU9PGNvbnRyb2wtcGxh" + - "bmUta3ViZWNvbmZpZz4KYGBgCgpQYXNzIGJvdGgga3ViZWNvbmZpZyBmb3JtcyBiZWNhdXNlIGNv" + - "bnRyb2wtcGxhbmUgbmFtZXNwYWNlIGNsZWFudXAgdXNlcwphbWJpZW50IGBrdWJlY3RsYC4KCiMj" + - "IyBTdGVwIDQ6IFZlcmlmeSBjbGVhbgoKYGBgYmFzaAprdWJlY3RsIC0tY29udGV4dCA8Y29tcHV0" + - "ZS1wbGFuZS1jb250ZXh0PiBnZXQgbnMgfCBcCiAgZ3JlcCAtRSAnKG52Y2F8bnZjZi1iYWNrZW5k" + - "fGdyb3ZlfGR5bmFtbyknCmt1YmVjdGwgLS1jb250ZXh0IDxjb250cm9sLXBsYW5lLWNvbnRleHQ+" + - "IGdldCBucyB8IFwKICBncmVwIC1FICcoY2Fzc2FuZHJhfG5hdHN8dmF1bHR8bnZjZnxhcGkta2V5" + - "c3xlc3N8c2lzKScKIyBCb3RoIGNvbW1hbmRzIHNob3VsZCByZXR1cm4gZW1wdHkuCmBgYAoKIyMj" + - "IFN0ZXAgNTogUmVpbnN0YWxsIGluIHNwbGl0IG9yZGVyCgpGb2xsb3cgW0NsZWFuIEluc3RhbGxh" + - "dGlvbl0oU0tJTEwubWQjY2xlYW4taW5zdGFsbGF0aW9uKSwgdGhlbiByZXR1cm4gdG8gdGhlCnNh" + - "bWUgaGFuZG9mZiBpbiBbU3BsaXQgQ29tcHV0ZS1QbGFuZSBJbnN0YWxsYXRpb25dKHJlZmVyZW5j" + - "ZXMvY29tcHV0ZS1wbGFuZS1pbnN0YWxsYXRpb24ubWQpLgoKLS0tCgojIyBFeGFtcGxlIDQ6IFJl" + - "Y292ZXIgZnJvbSBhIEdhdGV3YXkgRW5kcG9pbnQgQ2hhbmdlCgpUaGUgc2VwYXJhdGVseSBwcm92" + - "aXNpb25lZCBHYXRld2F5IG9yIGl0cyBsb2FkIGJhbGFuY2VyIHdhcyByZWNyZWF0ZWQgYW5kIGdv" + - "dCBhIG5ldyBlbmRwb2ludC4KCiMjIyBTdGVwIDE6IEdldCB0aGUgbmV3IGVuZHBvaW50CgpgYGBi" + - "YXNoCkdBVEVXQVlfQUREUj0kKGt1YmVjdGwgLS1jb250ZXh0IDxjb250cm9sLXBsYW5lLWNvbnRl" + - "eHQ+IGdldCBnYXRld2F5IFwKICBudmNmLWdhdGV3YXkgLW4gZW52b3ktZ2F0ZXdheSBcCiAgLW8g" + - "anNvbnBhdGg9J3suc3RhdHVzLmFkZHJlc3Nlc1swXS52YWx1ZX0nKQp0ZXN0IC1uICIkR0FURVdB" + - "WV9BRERSIgpgYGAKCiMjIyBTdGVwIDI6IFVwZGF0ZSBETlMgYW5kIGRpcmVjdCBhZGRyZXNzIGZp" + - "ZWxkcwoKS2VlcCBgZ2xvYmFsLmRvbWFpbmAsIHJvdXRlIGhvc3RuYW1lcywgYW5kIENMSSBIb3N0" + - "IGZpZWxkcyB1bmNoYW5nZWQuIFBvaW50IHRoZQpETlMgcmVjb3JkcyBmb3IgcmVuZGVyZWQgcm91" + - "dGUgaG9zdG5hbWVzLCBzdWNoIGFzIGBhcGkuPGRvbWFpbj5gIGFuZApgKi5pbnZvY2F0aW9uLjxk" + - "b21haW4+YCwgdG8gYEdBVEVXQVlfQUREUmAuIEZvciBhIHRlbXBvcmFyeSBlbnZpcm9ubWVudCB3" + - "aXRob3V0CkROUywga2VlcCBpdHMgcmVzZXJ2ZWQgcm91dGUgc3VmZml4IGFuZCBjb25uZWN0IHRv" + - "IGBHQVRFV0FZX0FERFJgIHdpdGggdGhlCm1hdGNoaW5nIGBIb3N0YCBoZWFkZXIuCgpGb3IgYSBz" + - "cGxpdCBkZXBsb3ltZW50IGNvbmZpZ3VyZWQgd2l0aCBkaXJlY3QgR2F0ZXdheSBhZGRyZXNzZXMs" + - "IHJlcGxhY2Ugb25seQp0aGUgYWRkcmVzcy1iZWFyaW5nIHZhbHVlczogY29udHJvbC1wbGFuZSBg" + - "bnZjZk5hdHNTZXJ2aWNlVVJMYCwgY29tcHV0ZS1wbGFuZQpJQ01TLCBSZVZhbCwgYW5kIE5BVFMg" + - "VVJMcywgYW5kIENMSSBVUkwgZmllbGRzLiBLZWVwIHRoZWlyIGRvbWFpbiBhbmQgSG9zdApvdmVy" + - "cmlkZXMgdW5jaGFuZ2VkLiBSZWZyZXNoIHJlZ2lzdHJhdGlvbiBhbmQgaW5zdGFsbGF0aW9uIHRo" + - "cm91Z2ggdGhlIHNhbWUKaGFuZG9mZiB1c2VkIG9yaWdpbmFsbHkuIFNlZQpbU3BsaXQgQ29tcHV0" + - "ZS1QbGFuZSBJbnN0YWxsYXRpb25dKHJlZmVyZW5jZXMvY29tcHV0ZS1wbGFuZS1pbnN0YWxsYXRp" + - "b24ubWQpCmZvciB0aGUgZmllbGRzIGFuZCBjb21wbGV0ZSBjb21tYW5kcy4KCiMjIyBTdGVwIDM6" + - "IFZlcmlmeSBib3RoIGNvbnRleHRzCgpgYGBiYXNoCmRpZyArc2hvcnQgImFwaS48ZG9tYWluPiIK" + - "Y3VybCAtSCAiSG9zdDogYXBpLjxkb21haW4+IiAiaHR0cDovLyRHQVRFV0FZX0FERFIvaGVhbHRo" + - "IgprdWJlY3RsIC0tY29udGV4dCA8Y29udHJvbC1wbGFuZS1jb250ZXh0PiBnZXQgZ2F0ZXdheSBu" + - "dmNmLWdhdGV3YXkgXAogIC1uIGVudm95LWdhdGV3YXkgLW8gd2lkZQprdWJlY3RsIC0tY29udGV4" + - "dCA8Y29udHJvbC1wbGFuZS1jb250ZXh0PiBnZXQgaHR0cHJvdXRlcyAtQQprdWJlY3RsIC0tY29u" + - "dGV4dCA8Y29udHJvbC1wbGFuZS1jb250ZXh0PiBnZXQgdGNwcm91dGVzIC1BCmt1YmVjdGwgLS1j" + - "b250ZXh0IDxjb21wdXRlLXBsYW5lLWNvbnRleHQ+IHJvbGxvdXQgc3RhdHVzIFwKICBkZXBsb3lt" + - "ZW50L252Y2Etb3BlcmF0b3IgLW4gbnZjYS1vcGVyYXRvciAtLXRpbWVvdXQ9MTBtCmt1YmVjdGwg" + - "LS1jb250ZXh0IDxjb21wdXRlLXBsYW5lLWNvbnRleHQ+IHdhaXQgXAogIG52Y2ZiYWNrZW5kLzxj" + - "b21wdXRlLXBsYW5lLWNsdXN0ZXItbmFtZT4gLW4gbnZjYS1vcGVyYXRvciBcCiAgLS1mb3I9anNv" + - "bnBhdGg9J3suc3RhdHVzLmFnZW50U3RhdHVzfSc9aGVhbHRoeSAtLXRpbWVvdXQ9MTBtCmBgYAoK" + - "LS0tCgojIyBFeGFtcGxlIDU6IERlcGxveSBPbmx5IERlcGVuZGVuY2llcwoKVXNlZnVsIGZvciB0" + - "ZXN0aW5nIG9yIHdoZW4gaXRlcmF0aW5nIG9uIHNlcnZpY2UgY29uZmlndXJhdGlvbi4KCmBgYGJh" + - "c2gKIyBEZXBsb3kganVzdCBOQVRTLCBDYXNzYW5kcmEsIE9wZW5CYW8KSEVMTUZJTEVfRU5WPTxl" + - "bnY+IGhlbG1maWxlIC0tc2VsZWN0b3IgcmVsZWFzZS1ncm91cD1kZXBlbmRlbmNpZXMgc3luYwoK" + - "IyBDaGVjayBzdGF0dXMKa3ViZWN0bCBnZXQgcG9kcyAtbiBuYXRzLXN5c3RlbQprdWJlY3RsIGdl" + - "dCBwb2RzIC1uIGNhc3NhbmRyYS1zeXN0ZW0Ka3ViZWN0bCBnZXQgcG9kcyAtbiB2YXVsdC1zeXN0" + - "ZW0KCiMgRGVwbG95IGp1c3Qgb25lIHNwZWNpZmljIHJlbGVhc2UKSEVMTUZJTEVfRU5WPTxlbnY+" + - "IGhlbG1maWxlIC0tc2VsZWN0b3IgbmFtZT1jYXNzYW5kcmEgc3luYwpgYGAKCiMjIyBTZWxlY3Rv" + - "ciByZWZlcmVuY2UKCnwgU2VsZWN0b3IgfCBSZWxlYXNlcyB8CnwtLS0tLS0tLS0tfC0tLS0tLS0t" + - "LS18CnwgYHJlbGVhc2UtZ3JvdXA9ZGVwZW5kZW5jaWVzYCB8IG5hdHMsIGNhc3NhbmRyYSwgb3Bl" + - "bmJhby1zZXJ2ZXIgfAp8IGByZWxlYXNlLWdyb3VwPXNlcnZpY2VzYCB8IGFwaS1rZXlzLCBzaXMs" + - "IGFwaSwgaW52b2NhdGlvbi1zZXJ2aWNlLCBncnBjLXByb3h5LCBlc3MtYXBpLCBub3Rhcnktc2Vy" + - "dmljZSwgcmV2YWwsIG9wdGlvbmFsIGxsbS1yZXF1ZXN0LXJvdXRlciBhbmQgbGxtLWFwaS1nYXRl" + - "d2F5IHdoZW4gYGxsbS5lbmFibGVkPXRydWVgLCBvcHRpb25hbCB2YW5pdHktZ2F0ZXdheSBvbmx5" + - "IGluIHN0YWNrIHBhY2thZ2VzIHRoYXQgaW5jbHVkZSB0aGUgYWRkb24gYW5kIGhhdmUgYGFkZG9u" + - "cy52YW5pdHlHYXRld2F5LmVuYWJsZWQ9dHJ1ZWAsIG9wdGlvbmFsIG52Y2YtdWkgb25seSBpbiBz" + - "dGFjayBwYWNrYWdlcyB0aGF0IGluY2x1ZGUgdGhlIGFkZG9uIGFuZCBoYXZlIGBhZGRvbnMubnZj" + - "ZlVpLmVuYWJsZWQ9dHJ1ZWAgfAp8IGBuYW1lPWxsbS1yZXF1ZXN0LXJvdXRlcmAgfCBEZXBsb3kg" + - "anVzdCB0aGUgTExNIHJlcXVlc3Qgcm91dGVyIHdoZW4gYGxsbS5lbmFibGVkPXRydWVgIHwKfCBg" + - "bmFtZT1sbG0tYXBpLWdhdGV3YXlgIHwgRGVwbG95IGp1c3QgdGhlIExMTSBBUEkgZ2F0ZXdheSB3" + - "aGVuIGBsbG0uZW5hYmxlZD10cnVlYCB8CnwgYG5hbWU9dmFuaXR5LWdhdGV3YXlgIHwgRGVwbG95" + - "IGp1c3QgVmFuaXR5IEdhdGV3YXkgb25seSB3aGVuIHRoZSBzdGFjayBwYWNrYWdlIGluY2x1ZGVz" + - "IHRoYXQgcmVsZWFzZSBhbmQgYGFkZG9ucy52YW5pdHlHYXRld2F5LmVuYWJsZWQ9dHJ1ZWAgfAp8" + - "IGBuYW1lPW52Y2YtdWlgIHwgRGVwbG95IE5WQ0YgVUkgb25seSB3aGVuIHRoZSBzdGFjayBwYWNr" + - "YWdlIGluY2x1ZGVzIHRoYXQgcmVsZWFzZSBhbmQgYGFkZG9ucy5udmNmVWkuZW5hYmxlZD10cnVl" + - "YCB8CnwgYHJlbGVhc2UtZ3JvdXA9aW5ncmVzc2AgfCBpbmdyZXNzIChnYXRld2F5IHJvdXRlcykg" + - "fAp8IGBuYW1lPTxyZWxlYXNlPmAgfCBBbnkgaW5kaXZpZHVhbCByZWxlYXNlIGJ5IG5hbWUgfAoK" + - "Tm90ZTogYGFkbWluLWlzc3Vlci1wcm94eWAgZG9lcyBub3QgaGF2ZSBhIHJlbGVhc2UtZ3JvdXAg" + - "bGFiZWwuIFRhcmdldCBpdCB3aXRoIGAtLXNlbGVjdG9yIG5hbWU9YWRtaW4taXNzdWVyLXByb3h5" + - "YC4KUEsHCAJSTkB/KAAAfygAAFBLAwQUAAgAAAAAACEAAAAAAAAAAAAAAAAATAAJAGRhdGEvbnZj" + - "Zi1zZWxmLW1hbmFnZWQtaW5zdGFsbGF0aW9uL3JlZmVyZW5jZXMvY29tcHV0ZS1wbGFuZS1pbnN0" + - "YWxsYXRpb24ubWRVVAUAAQCmzhIjIFNwbGl0IENvbXB1dGUtUGxhbmUgSW5zdGFsbGF0aW9uCgpU" + - "aGUgY29udHJvbCBwbGFuZSBhbmQgY29tcHV0ZSBwbGFuZSBhcmUgc2VwYXJhdGUgc3RhY2tzLiBJ" + - "bnN0YWxsIHRoZSBjb250cm9sCnBsYW5lIGZpcnN0LCB0aGVuIHJlZ2lzdGVyIGFuZCBpbnN0YWxs" + - "IGVhY2ggY29tcHV0ZSBjbHVzdGVyLiBDaG9vc2Ugb25lIGhhbmRvZmYKYmVsb3cgYW5kIHVzZSBp" + - "dCBmb3IgdGhlIGZ1bGwgbGlmZWN5Y2xlLiBEbyBub3QgY29tYmluZSBhIENMSS1nZW5lcmF0ZWQg" + - "cHJvZmlsZQp3aXRoIHRoZSBIZWxtZmlsZSB2YWx1ZXMgZmxvdy4KCiMjIENob29zZSBhIEhhbmRv" + - "ZmYKCnwgRmxvdyB8IFNvdXJjZSBvZiBjb250cm9sLXBsYW5lIGVuZHBvaW50cyB8IFJlZ2lzdHJh" + - "dGlvbiBhcnRpZmFjdCB8CnwtLS0tLS18LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t" + - "LS18LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS18CnwgSGVsbWZpbGUgdmFsdWVzIHwgU2VwYXJhdGUg" + - "Y29udHJvbC1wbGFuZSBhbmQgY29tcHV0ZS1wbGFuZSBlbnZpcm9ubWVudCBmaWxlcyB8IGBkZXBs" + - "b3kvc3RhY2tzL252Y2YtY29tcHV0ZS1wbGFuZS9yZWdpc3RyYXRpb24vPGNsdXN0ZXI+LXJlZ2lz" + - "dGVyLXZhbHVlcy55YW1sYCB8CnwgQ0xJIHByb2ZpbGUgfCBDTEktZ2VuZXJhdGVkIGBkZXBsb3kv" + - "c3RhY2tzL3NlbGYtbWFuYWdlZC9vdXQvY29udHJvbC1wbGFuZS1wcm9maWxlLnlhbWxgIHwgQ0xJ" + - "LWdlbmVyYXRlZCBgZGVwbG95L3N0YWNrcy9udmNmLWNvbXB1dGUtcGxhbmUvb3V0LzxjbHVzdGVy" + - "Pi1yZWdpc3Rlci12YWx1ZXMueWFtbGAgfAoKVGhlIENMSSBwcm9maWxlIGlzIG1hbmRhdG9yeSBm" + - "b3IgdGhlIENMSSBmbG93IGFuZCBtdXN0IG5vdCBiZSBoYW5kLWF1dGhvcmVkLgpUaGUgSGVsbWZp" + - "bGUgZmxvdyBkb2VzIG5vdCBjb25zdW1lIGEgY29udHJvbC1wbGFuZSBwcm9maWxlLgoKQ29tbWFu" + - "ZHMgYmVsb3cgdXNlIG1vbm9yZXBvIHBhdGhzIGZyb20gdGhlIHJlcG9zaXRvcnkgcm9vdC4gT3Bl" + - "cmF0b3JzIHVzaW5nCmV4dHJhY3RlZCBwYWNrYWdlcyBuZWVkIG1hdGNoaW5nLXZlcnNpb24gYG52" + - "Y2Ytc2VsZi1tYW5hZ2VkLXN0YWNrYCBhbmQKYG52Y2YtY29tcHV0ZS1wbGFuZS1zdGFja2AgYnVu" + - "ZGxlcy4gU3Vic3RpdHV0ZSB0aG9zZSBidW5kbGUgcm9vdHMgZm9yCmBkZXBsb3kvc3RhY2tzL3Nl" + - "bGYtbWFuYWdlZGAgYW5kIGBkZXBsb3kvc3RhY2tzL252Y2YtY29tcHV0ZS1wbGFuZWAuCgojIyBI" + - "ZWxtZmlsZSBWYWx1ZXMgRmxvdwoKQ3JlYXRlIGJvdGggZW52aXJvbm1lbnQgZmlsZXMgYmVmb3Jl" + - "IGluc3RhbGxhdGlvbjoKCi0gYGRlcGxveS9zdGFja3Mvc2VsZi1tYW5hZ2VkL2Vudmlyb25tZW50" + - "cy88ZW52Pi55YW1sYCBmb3IgY29udHJvbC1wbGFuZQogIHJlZ2lzdHJ5LCBkb21haW4sIEdhdGV3" + - "YXksIHJvdXRlcywgYW5kIHNlcnZpY2Ugc2V0dGluZ3MuCi0gYGRlcGxveS9zdGFja3MvbnZjZi1j" + - "b21wdXRlLXBsYW5lL2Vudmlyb25tZW50cy88ZW52Pi55YW1sYCBmb3IgY29tcHV0ZS1wbGFuZQog" + - "IHJlZ2lzdHJ5LCBwdWxsIHNlY3JldHMsIGFuZCBjb21wdXRlLXJlYWNoYWJsZSBJQ01TLCBSZVZh" + - "bCwgYW5kIE5BVFMgdmFsdWVzLgoKRm9yIEVLUywgdXNlIHRoZSBjYW5vbmljYWwKW0NTUCBFbmQt" + - "dG8tRW5kIEV4YW1wbGVdKGh0dHBzOi8vZG9jcy5udmlkaWEuY29tL252Y2YvdjAuNi4wLXJjL2Nz" + - "cC1lbmQtdG8tZW5kLWV4YW1wbGUpLgpUaGUgY29udHJvbC1wbGFuZSBlbnZpcm9ubWVudCBrZWVw" + - "cyB0aGUgRW52b3kgR2F0ZXdheSBjb250cm9sbGVyIGluCmBlbnZveS1nYXRld2F5LXN5c3RlbWAs" + - "IGF0dGFjaGVzIHJvdXRlcyB0byBgR2F0ZXdheS9udmNmLWdhdGV3YXlgIGluCmBlbnZveS1nYXRl" + - "d2F5YCwgYW5kIGVuYWJsZXMgdGhlIE5BVFMgcm91dGUuIFRoZSBjb21wdXRlLXBsYW5lIGVudmly" + - "b25tZW50IHVzZXMKdGhlIGV4dGVybmFsIGFkZHJlc3MgcGx1cyB0aGUgc2VydmljZSBob3N0IG92" + - "ZXJyaWRlcy4gSGVyZSwKYDxnYXRld2F5LWFkZHJlc3M+YCBpcyB0aGUgTkxCIGFkZHJlc3MgYW5k" + - "IGA8Z2F0ZXdheS1kb21haW4+YCBpcyB0aGUgRE5TIGJhc2UKd2hvc2Ugc2VydmljZSBzdWJkb21h" + - "aW5zIHJlc29sdmUgdG8gdGhhdCBOTEI6CgpgYGB5YW1sCiMgZGVwbG95L3N0YWNrcy9zZWxmLW1h" + - "bmFnZWQvZW52aXJvbm1lbnRzLzxlbnY+LnlhbWwKZ2xvYmFsOgogIGRvbWFpbjogIjxnYXRld2F5" + - "LWRvbWFpbj4iCiAgd29ya2VyRW5kcG9pbnRzOgogICAgbnZjZlNlcnZpY2VVUkw6ICJodHRwOi8v" + - "YXBpLjxnYXRld2F5LWRvbWFpbj4iCiAgICBudmNmR3JwY1NlcnZpY2VVUkw6ICJodHRwOi8vd29y" + - "a2VyLWFwaS48Z2F0ZXdheS1kb21haW4+IgogICAgbnZjZk5hdHNTZXJ2aWNlVVJMOiAibmF0czov" + - "LzxnYXRld2F5LWFkZHJlc3M+OjQyMjIiCiAgICBudmN0U2VydmljZVVSTDogImh0dHA6Ly90YXNr" + - "cy48Z2F0ZXdheS1kb21haW4+IgogICAgbnZjdEdycGNTZXJ2aWNlVVJMOiAiaHR0cDovL3dvcmtl" + - "ci10YXNrcy48Z2F0ZXdheS1kb21haW4+IgogICAgaW52b2NhdGlvblNlcnZpY2VVUkw6ICJodHRw" + - "Oi8vaW52b2NhdGlvbi48Z2F0ZXdheS1kb21haW4+IgoKZ3JwY3Byb3h5OgogIG52Y2ZHcnBjU2Vy" + - "dmljZVVSTDogImh0dHA6Ly9hcGkubnZjZi5zdmMuY2x1c3Rlci5sb2NhbDo5MDkwIgoKaW5ncmVz" + - "czoKICBnYXRld2F5QXBpOgogICAgY29udHJvbGxlck5hbWVzcGFjZTogZW52b3ktZ2F0ZXdheS1z" + - "eXN0ZW0KICAgIGdhdGV3YXlzOgogICAgICBzaGFyZWQ6IHtuYW1lOiBudmNmLWdhdGV3YXksIG5h" + - "bWVzcGFjZTogZW52b3ktZ2F0ZXdheX0KICAgICAgZ3JwYzoge25hbWU6IG52Y2YtZ2F0ZXdheSwg" + - "bmFtZXNwYWNlOiBlbnZveS1nYXRld2F5fQogICAgICBuYXRzOgogICAgICAgIG5hbWU6IG52Y2Yt" + - "Z2F0ZXdheQogICAgICAgIG5hbWVzcGFjZTogZW52b3ktZ2F0ZXdheQogICAgICAgIGxpc3RlbmVy" + - "TmFtZTogbmF0cwogICAgcm91dGVzOgogICAgICBudmNmQXBpOgogICAgICAgIGdycGM6CiAgICAg" + - "ICAgICBlbmFibGVkOiB0cnVlCiAgICAgICAgICBob3N0bmFtZXM6IFsid29ya2VyLWFwaS48Z2F0" + - "ZXdheS1kb21haW4+Il0KICAgICAgbnZjdEFwaToKICAgICAgICBncnBjOgogICAgICAgICAgZW5h" + - "YmxlZDogdHJ1ZQogICAgICAgICAgaG9zdG5hbWVzOiBbIndvcmtlci10YXNrcy48Z2F0ZXdheS1k" + - "b21haW4+Il0KICAgICAgbmF0czoKICAgICAgICBlbmFibGVkOiB0cnVlCgpvcGVuYmFvOgogIG1p" + - "Z3JhdGlvbnM6CiAgICBpc3N1ZXJEaXNjb3Zlcnk6CiAgICAgIGVuYWJsZWQ6IHRydWUKYGBgCgpg" + - "YGB5YW1sCiMgZGVwbG95L3N0YWNrcy9udmNmLWNvbXB1dGUtcGxhbmUvZW52aXJvbm1lbnRzLzxl" + - "bnY+LnlhbWwKZ2xvYmFsOgogIG52Y2FPcGVyYXRvcjoKICAgIHNlbGZNYW5hZ2VkOgogICAgICBp" + - "Y21zU2VydmljZVVSTDogImh0dHA6Ly88Z2F0ZXdheS1hZGRyZXNzPiIKICAgICAgaWNtc1NlcnZp" + - "Y2VIb3N0SGVhZGVyT3ZlcnJpZGU6ICJzaXMuPGdhdGV3YXktZG9tYWluPiIKICAgICAgcmV2YWxT" + - "ZXJ2aWNlVVJMOiAiaHR0cDovLzxnYXRld2F5LWFkZHJlc3M+IgogICAgICByZXZhbFNlcnZpY2VI" + - "b3N0SGVhZGVyT3ZlcnJpZGU6ICJyZXZhbC48Z2F0ZXdheS1kb21haW4+IgogICAgICBuYXRzVVJM" + - "OiAibmF0czovLzxnYXRld2F5LWFkZHJlc3M+OjQyMjIiCiAgICAgIG5hdHNIb3N0T3ZlcnJpZGU6" + - "ICJuYXRzLjxnYXRld2F5LWRvbWFpbj4iCmBgYAoKUHJldmlldyBhbmQgaW5zdGFsbCB0aGUgY29u" + - "dHJvbCBwbGFuZSBhZ2FpbnN0IGl0cyBjb250ZXh0OgoKYGBgYmFzaAptYWtlIC1DIGRlcGxveS9z" + - "dGFja3Mvc2VsZi1tYW5hZ2VkIHRlbXBsYXRlIFwKICBIRUxNRklMRV9FTlY9PGVudj4gXAogIEtV" + - "QkVDT05GSUdfRklMRT08Y29udHJvbC1wbGFuZS1rdWJlY29uZmlnPgoKbWFrZSAtQyBkZXBsb3kv" + - "c3RhY2tzL3NlbGYtbWFuYWdlZCBpbnN0YWxsIFwKICBIRUxNRklMRV9FTlY9PGVudj4gXAogIEtV" + - "QkVDT05GSUdfRklMRT08Y29udHJvbC1wbGFuZS1rdWJlY29uZmlnPgpgYGAKCkJlZm9yZSByZWdp" + - "c3RlcmluZyB0aHJvdWdoIGEgYmFyZSBHYXRld2F5IGFkZHJlc3MsIGNyZWF0ZSBvciB1cGRhdGUg" + - "dGhlIENMSQpjb25maWcgcGFzc2VkIGFzIGBOVkNGX0NMSV9DT05GSUdgOgoKYGBgeWFtbApiYXNl" + - "X2h0dHBfdXJsOiAiaHR0cDovLzxnYXRld2F5LWFkZHJlc3M+IgppbnZva2VfdXJsOiAiaHR0cDov" + - "LzxnYXRld2F5LWFkZHJlc3M+IgpiYXNlX2dycGNfdXJsOiAiPGdhdGV3YXktYWRkcmVzcz46MTAw" + - "ODEiCmFwaV9rZXlzX3NlcnZpY2VfdXJsOiAiaHR0cDovLzxnYXRld2F5LWFkZHJlc3M+IgppY21z" + - "X3VybDogImh0dHA6Ly88Z2F0ZXdheS1hZGRyZXNzPiIKYXBpX2hvc3Q6ICJhcGkuPGdhdGV3YXkt" + - "ZG9tYWluPiIKYXBpX2tleXNfaG9zdDogImFwaS1rZXlzLjxnYXRld2F5LWRvbWFpbj4iCmludm9r" + - "ZV9ob3N0OiAiaW52b2NhdGlvbi48Z2F0ZXdheS1kb21haW4+IgppY21zX2hvc3Q6ICJzaXMuPGdh" + - "dGV3YXktZG9tYWluPiIKYGBgCgpIb3N0IGZpZWxkcyBjb250YWluIGhvc3RuYW1lcyBvbmx5LCB3" + - "aXRob3V0IGEgVVJMIHNjaGVtZS4gYElDTVNfVVJMYCBtYXBzIG9ubHkKdG8gdGhlIHJlZ2lzdHJh" + - "dGlvbiBjb21tYW5kJ3MgYC0taWNtcy11cmxgOyBgaWNtc19ob3N0YCBpbiB0aGUgY29uZmlnIHN1" + - "cHBsaWVzCnRoZSBHYXRld2F5IEhvc3QgaGVhZGVyLiBUaGVyZSBpcyBubyBgLS1pY21zLWhvc3Rg" + - "IE1ha2Ugb3IgQ0xJIGZsYWcuCgpSZWdpc3RlciBmcm9tIHRoZSBjb21wdXRlIGNvbnRleHQsIHRo" + - "ZW4gaW5zdGFsbCB0aGUgY29tcHV0ZSBwbGFuZToKCmBgYGJhc2gKbWFrZSAtQyBkZXBsb3kvc3Rh" + - "Y2tzL252Y2YtY29tcHV0ZS1wbGFuZSByZWdpc3Rlci1jbHVzdGVyIFwKICBDTFVTVEVSX05BTUU9" + - "PGNsdXN0ZXItbmFtZT4gXAogIE5DQV9JRD08bmNhLWlkPiBcCiAgQ0xVU1RFUl9SRUdJT049PHJl" + - "Z2lvbj4gXAogIElDTVNfVVJMPWh0dHA6Ly88Z2F0ZXdheS1hZGRyZXNzPiBcCiAgS1VCRUNPTkZJ" + - "R19GSUxFPTxjb21wdXRlLXBsYW5lLWt1YmVjb25maWc+IFwKICBOVkNGX0NMST08cGF0aC10by1u" + - "dmNmLWNsaT4gXAogIE5WQ0ZfQ0xJX0NPTkZJRz08cGF0aC10by1udmNmLWNsaS1jb25maWc+Cgpt" + - "YWtlIC1DIGRlcGxveS9zdGFja3MvbnZjZi1jb21wdXRlLXBsYW5lIGluc3RhbGwgXAogIENMVVNU" + - "RVJfTkFNRT08Y2x1c3Rlci1uYW1lPiBcCiAgSEVMTUZJTEVfRU5WPTxlbnY+IFwKICBLVUJFQ09O" + - "RklHX0ZJTEU9PGNvbXB1dGUtcGxhbmUta3ViZWNvbmZpZz4KYGBgCgpSZWdpc3RyYXRpb24gZGlz" + - "Y292ZXJzIHRoZSBPSURDIGlzc3VlciBhbmQgSldLUyBmcm9tIHRoZSBjb21wdXRlIGt1YmUgY29u" + - "dGV4dC4KSW4gYSBtdWx0aS1jbHVzdGVyIGRlcGxveW1lbnQsIGBLVUJFQ09ORklHX0ZJTEVgIGlz" + - "IHJlcXVpcmVkIG9uIGJvdGgKY29tcHV0ZS1wbGFuZSBjb21tYW5kcy4gSW4gYSBzYW1lLWNsdXN0" + - "ZXIgZGVwbG95bWVudCBpdCBtYXkgYmUgb21pdHRlZCBvbmx5CndoZW4gdGhlIGFtYmllbnQgY29u" + - "dGV4dCBpcyBhbHJlYWR5IHRoZSB0YXJnZXQgY2x1c3Rlci4KCiMjIENMSSBQcm9maWxlIEZsb3cK" + - "ClJ1biB0aGUgQ0xJIGNvbnRyb2wtcGxhbmUgaW5zdGFsbCBmaXJzdC4gSXQgY3JlYXRlcyB0aGUg" + - "cHJvZmlsZSBjb25zdW1lZCBieQpjb21wdXRlLXBsYW5lIHJlZ2lzdHJhdGlvbjoKCmBgYGJhc2gK" + - "bnZjZi1jbGkgLS1jb25maWcgPGNvbmZpZz4gc2VsZi1ob3N0ZWQgXAogIC0tY29udHJvbC1wbGFu" + - "ZS1zdGFjayBkZXBsb3kvc3RhY2tzL3NlbGYtbWFuYWdlZCBcCiAgLS1jb21wdXRlLXBsYW5lLXN0" + - "YWNrIGRlcGxveS9zdGFja3MvbnZjZi1jb21wdXRlLXBsYW5lIFwKICAtLWVudiA8ZW52PiBcCiAg" + - "LS1wbGFpbiBcCiAgLS1jb250cm9sLXBsYW5lLWNvbnRleHQgPGNvbnRyb2wtcGxhbmUtY29udGV4" + - "dD4gXAogIC0tY29tcHV0ZS1wbGFuZS1jb250ZXh0IDxjb21wdXRlLXBsYW5lLWNvbnRleHQ+IFwK" + - "ICBpbnN0YWxsIC0tY29udHJvbC1wbGFuZSBcCiAgLS1jbHVzdGVyLW5hbWUgPGNvbnRyb2wtcGxh" + - "bmUtY2x1c3Rlci1uYW1lPiBcCiAgLS1yZWdpb24gPHJlZ2lvbj4gXAogIC0tbmNhLWlkIDxuY2Et" + - "aWQ+Cgp0ZXN0IC1zIGRlcGxveS9zdGFja3Mvc2VsZi1tYW5hZ2VkL291dC9jb250cm9sLXBsYW5l" + - "LXByb2ZpbGUueWFtbApgYGAKClVzZSB0aGUgZnVsbCBwZXJzaXN0ZW50IHByZWZpeCBmb3IgYm90" + - "aCBjb21wdXRlLXBsYW5lIGNvbW1hbmRzOgoKYGBgYmFzaApudmNmLWNsaSAtLWNvbmZpZyA8Y29u" + - "ZmlnPiBzZWxmLWhvc3RlZCBcCiAgLS1jb250cm9sLXBsYW5lLXN0YWNrIGRlcGxveS9zdGFja3Mv" + - "c2VsZi1tYW5hZ2VkIFwKICAtLWNvbXB1dGUtcGxhbmUtc3RhY2sgZGVwbG95L3N0YWNrcy9udmNm" + - "LWNvbXB1dGUtcGxhbmUgXAogIC0tZW52IDxlbnY+IFwKICAtLXBsYWluIFwKICBjb21wdXRlLXBs" + - "YW5lIHJlZ2lzdGVyIFwKICAtLWNvbnRyb2wtcGxhbmUtcHJvZmlsZSBkZXBsb3kvc3RhY2tzL3Nl" + - "bGYtbWFuYWdlZC9vdXQvY29udHJvbC1wbGFuZS1wcm9maWxlLnlhbWwgXAogIC0tY2x1c3Rlci1u" + - "YW1lIDxjb21wdXRlLXBsYW5lLWNsdXN0ZXItbmFtZT4gXAogIC0ta3ViZS1jb250ZXh0IDxjb21w" + - "dXRlLXBsYW5lLWNvbnRleHQ+IFwKICAtLXJlZ2lvbiA8cmVnaW9uPiBcCiAgLS1vdXRwdXQgZGVw" + - "bG95L3N0YWNrcy9udmNmLWNvbXB1dGUtcGxhbmUvb3V0Lzxjb21wdXRlLXBsYW5lLWNsdXN0ZXIt" + - "bmFtZT4tcmVnaXN0ZXItdmFsdWVzLnlhbWwKCm52Y2YtY2xpIC0tY29uZmlnIDxjb25maWc+IHNl" + - "bGYtaG9zdGVkIFwKICAtLWNvbnRyb2wtcGxhbmUtc3RhY2sgZGVwbG95L3N0YWNrcy9zZWxmLW1h" + - "bmFnZWQgXAogIC0tY29tcHV0ZS1wbGFuZS1zdGFjayBkZXBsb3kvc3RhY2tzL252Y2YtY29tcHV0" + - "ZS1wbGFuZSBcCiAgLS1lbnYgPGVudj4gXAogIC0tcGxhaW4gXAogIGNvbXB1dGUtcGxhbmUgaW5z" + - "dGFsbCBcCiAgLS12YWx1ZXMgZGVwbG95L3N0YWNrcy9udmNmLWNvbXB1dGUtcGxhbmUvb3V0Lzxj" + - "b21wdXRlLXBsYW5lLWNsdXN0ZXItbmFtZT4tcmVnaXN0ZXItdmFsdWVzLnlhbWwgXAogIC0ta3Vi" + - "ZS1jb250ZXh0IDxjb21wdXRlLXBsYW5lLWNvbnRleHQ+IFwKICAtLWNsdXN0ZXItbmFtZSA8Y29t" + - "cHV0ZS1wbGFuZS1jbHVzdGVyLW5hbWU+CmBgYAoKUmVnaXN0cmF0aW9uIHNlbGVjdHMgdGhlIHBy" + - "b2ZpbGUncyBpbi1jbHVzdGVyIG9yIGNvbXB1dGUtcmVhY2hhYmxlIGVuZHBvaW50cwpmcm9tIHRo" + - "ZSBjb21wdXRlIGNvbnRleHQgYW5kIHByb2JlcyBpdHMgSldLUy4gRG8gbm90IHJlcGxhY2UgcHJv" + - "ZmlsZSBlbmRwb2ludHMKd2l0aCBoYW5kLWF1dGhvcmVkIEhlbG1maWxlIGVuZHBvaW50IHZhbHVl" + - "cy4KCiMjIFB1bGwgU2VjcmV0cwoKQ3JlYXRlIHRoZSBjb250cm9sLXBsYW5lIHNlY3JldCBpbiB0" + - "aGVzZSBuYW1lc3BhY2VzIG9uIHRoZSBjb250cm9sLXBsYW5lCmNvbnRleHQ6CgpgYGB0ZXh0CmNh" + - "c3NhbmRyYS1zeXN0ZW0gbmF0cy1zeXN0ZW0gbnZjZiBhcGkta2V5cyBlc3Mgc2lzIHZhdWx0LXN5" + - "c3RlbSBjZXJ0LW1hbmFnZXIKYGBgCgpPbiB0aGUgY29tcHV0ZSBjb250ZXh0LCBjcmVhdGUgdGhl" + - "IHNlY3JldCBvbmx5IGluIGBudmNhLW9wZXJhdG9yYCBhbmQgcmVmZXJlbmNlCml0IHRocm91Z2gg" + - "YGdsb2JhbC5pbWFnZVB1bGxTZWNyZXRzYCBpbiB0aGUgY29tcHV0ZS1wbGFuZSBlbnZpcm9ubWVu" + - "dC4gVGhlIGNoYXJ0CmFuZCBvcGVyYXRvciB1c2UgaXQgaW4gYG52Y2Etb3BlcmF0b3JgIGFuZCBt" + - "aXJyb3IgaXQgdG8gYG52Y2Etc3lzdGVtYC4gRG8gbm90IGFkZAplaXRoZXIgbmFtZXNwYWNlIHRv" + - "IHRoZSBjb250cm9sLXBsYW5lIGxpc3QuIEZvciBjb21tYW5kcyBhbmQgcG9saWN5IGV4YW1wbGVz" + - "LApzZWUgW3B1bGwtc2VjcmV0cy5tZF0ocHVsbC1zZWNyZXRzLm1kKS4KCiMjIFZlcmlmaWNhdGlv" + - "bgoKVXNlIHRoZSBleHBsaWNpdCBHYXRld2F5IG5hbWUgYW5kIG5hbWVzcGFjZToKCmBgYGJhc2gK" + - "a3ViZWN0bCAtLWNvbnRleHQgPGNvbnRyb2wtcGxhbmUtY29udGV4dD4gZ2V0IGdhdGV3YXkgbnZj" + - "Zi1nYXRld2F5IFwKICAtbiBlbnZveS1nYXRld2F5IC1vIHdpZGUKa3ViZWN0bCAtLWNvbnRleHQg" + - "PGNvbnRyb2wtcGxhbmUtY29udGV4dD4gZ2V0IHRjcHJvdXRlIC1uIGVudm95LWdhdGV3YXkKa3Vi" + - "ZWN0bCAtLWNvbnRleHQgPGNvbXB1dGUtcGxhbmUtY29udGV4dD4gcm9sbG91dCBzdGF0dXMgXAog" + - "IGRlcGxveW1lbnQvbnZjYS1vcGVyYXRvciAtbiBudmNhLW9wZXJhdG9yIC0tdGltZW91dD0xMG0K" + - "a3ViZWN0bCAtLWNvbnRleHQgPGNvbXB1dGUtcGxhbmUtY29udGV4dD4gd2FpdCBcCiAgbnZjZmJh" + - "Y2tlbmQvPGNvbXB1dGUtcGxhbmUtY2x1c3Rlci1uYW1lPiAtbiBudmNhLW9wZXJhdG9yIFwKICAt" + - "LWZvcj1qc29ucGF0aD0ney5zdGF0dXMuYWdlbnRTdGF0dXN9Jz1oZWFsdGh5IC0tdGltZW91dD0x" + - "MG0Ka3ViZWN0bCAtLWNvbnRleHQgPGNvbXB1dGUtcGxhbmUtY29udGV4dD4gZ2V0IHNlY3JldCA8" + - "cHVsbC1zZWNyZXQ+IC1uIG52Y2Etc3lzdGVtCmBgYAoKIyMgVGVhcmRvd24KCkRlc3Ryb3kgYW5k" + - "IGRlcmVnaXN0ZXIgZXZlcnkgY29tcHV0ZSBwbGFuZSBiZWZvcmUgdGhlIGNvbnRyb2wgcGxhbmUu" + - "IEJvdGgKaGFuZG9mZnMgY2FuIGRlc3Ryb3kgdGhlIGNvbnRyb2wgcGxhbmUsIHNvIGFwcGx5IHRo" + - "aXMgcHJlZmxpZ2h0IGJlZm9yZSBlaXRoZXIKb25lLiBQcmVzZXJ2ZSB0aGUgYGNlcnQtbWFuYWdl" + - "cmAgbmFtZXNwYWNlIGJ5IGRlZmF1bHQuIE5hbWVzcGFjZSBwcmVzZXJ2YXRpb24KZG9lcyBub3Qg" + - "cHJlc2VydmUgdGhlIEhlbG0gcmVsZWFzZS4gSWRlbnRpZnkgd2hldGhlciBjZXJ0LW1hbmFnZXIg" + - "aXMgZXh0ZXJuYWwuCkZvciBhbiBleHRlcm5hbCBpbnN0YWxsYXRpb24sIHJlcXVpcmUgZWZmZWN0" + - "aXZlIGBjZXJ0TWFuYWdlci5lbmFibGVkOiBmYWxzZWAKYW5kIGFib3J0IGlmIGl0IGlzIHRydWUu" + - "IEZvciBhbiBpbnRlbmRlZCBzdGFjay1tYW5hZ2VkIHJlbGVhc2Ugd2l0aCBlZmZlY3RpdmUKYGNl" + - "cnRNYW5hZ2VyLmVuYWJsZWQ6IHRydWVgLCB2ZXJpZnkgbWF0Y2hpbmcgc3RhY2sgSGVsbSByZWxl" + - "YXNlIG1ldGFkYXRhIGFuZAphYm9ydCBvbiBtaXNzaW5nIG9yIG1pc21hdGNoZWQgZXZpZGVuY2Uu" + - "IE9ubHkgcGxhbiBuYW1lc3BhY2UgcmVtb3ZhbCBhZnRlcgp2ZXJpZnlpbmcgbmFtZXNwYWNlIHBy" + - "b3ZlbmFuY2UgYW5kIGdldHRpbmcgZXhwbGljaXQgY29uZmlybWF0aW9uOyBvdGhlcndpc2UKZG8g" + - "bm90IGRlbGV0ZSBpdC4KCkZvciB0aGUgSGVsbWZpbGUgdmFsdWVzIGZsb3csIHJldGFpbiBlYWNo" + - "IHJlZ2lzdHJhdGlvbiB2YWx1ZXMgZmlsZSB1bnRpbApjbGVhbnVwIGlzIHZlcmlmaWVkOgoKYGBg" + - "YmFzaAptYWtlIC1DIGRlcGxveS9zdGFja3MvbnZjZi1jb21wdXRlLXBsYW5lIGRlc3Ryb3kgXAog" + - "IENMVVNURVJfTkFNRT08Y2x1c3Rlci1uYW1lPiBcCiAgSEVMTUZJTEVfRU5WPTxlbnY+IFwKICBL" + - "VUJFQ09ORklHX0ZJTEU9PGNvbXB1dGUtcGxhbmUta3ViZWNvbmZpZz4KCjxudmNmLWNsaT4gLS1j" + - "b25maWcgPGNvbmZpZz4gY2x1c3RlciBkZWxldGUgXAogIC0tY2x1c3Rlci1pZCA8Y2x1c3Rlci1p" + - "ZC1mcm9tLXJlZ2lzdHJhdGlvbi12YWx1ZXM+IFwKICAtLW5jYS1pZCA8bmNhLWlkPiBcCiAgLS1p" + - "Z25vcmUtbWlzc2luZwpgYGAKClJlYWQgYGNsdXN0ZXJJRGAgYW5kIGBuY2FJRGAgZnJvbQpgZGVw" + - "bG95L3N0YWNrcy9udmNmLWNvbXB1dGUtcGxhbmUvcmVnaXN0cmF0aW9uLzxjbHVzdGVyLW5hbWU+" + - "LXJlZ2lzdGVyLXZhbHVlcy55YW1sYC4KU2hvdyB0aGUgZXhhY3QgY2x1c3RlciBJRCBhbmQgZ2V0" + - "IGNvbmZpcm1hdGlvbiBiZWZvcmUgYGNsdXN0ZXIgZGVsZXRlYC4gUmVwZWF0CmNvbXB1dGUgZGVz" + - "dHJveSBhbmQgZGVyZWdpc3RyYXRpb24gZm9yIGV2ZXJ5IGNvbXB1dGUgY2x1c3RlciwgdGhlbiBk" + - "ZXN0cm95IHRoZQpjb250cm9sIHBsYW5lLgoKYGBgYmFzaApLVUJFQ09ORklHPTxjb250cm9sLXBs" + - "YW5lLWt1YmVjb25maWc+IFwKbWFrZSAtQyBkZXBsb3kvc3RhY2tzL3NlbGYtbWFuYWdlZCBkZXN0" + - "cm95IFwKICBIRUxNRklMRV9FTlY9PGVudj4gXAogIEtVQkVDT05GSUdfRklMRT08Y29udHJvbC1w" + - "bGFuZS1rdWJlY29uZmlnPgpgYGAKCkJvdGggYEtVQkVDT05GSUdgIGFuZCBgS1VCRUNPTkZJR19G" + - "SUxFYCBhcmUgcmVxdWlyZWQgb24gdGhlIGNvbnRyb2wtcGxhbmUKZGVzdHJveSBiZWNhdXNlIGl0" + - "cyBuYW1lc3BhY2UgY2xlYW51cCB1c2VzIGFtYmllbnQgYGt1YmVjdGxgLgoKRm9yIHRoZSBDTEkg" + - "cHJvZmlsZSBmbG93LCBrZWVwCmBkZXBsb3kvc3RhY2tzL252Y2YtY29tcHV0ZS1wbGFuZS9vdXQv" + - "PGNsdXN0ZXItbmFtZT4tcmVnaXN0ZXItdmFsdWVzLnlhbWxgCnVudGlsIHRlYXJkb3duIGNvbXBs" + - "ZXRlcyBiZWNhdXNlIGBkb3duYCByZWFkcyBpdHMgY2x1c3RlciBJRC4gRmlyc3QgcXVlcnkgdGhl" + - "CmxpdmUgcmVnaXN0cmF0aW9uIHNldCB3aXRoIHRoZSBzYW1lIGNvbXBsZXRlIHBlcnNpc3RlbnQg" + - "cHJlZml4OgoKYGBgYmFzaApudmNmLWNsaSAtLWNvbmZpZyA8Y29uZmlnPiBzZWxmLWhvc3RlZCBc" + + "TUZJTEVfRU5WIiB9fS1zZWNyZXRzLnlhbWwKICAgIC0gY2Fzc2FuZHJhOgogICAgICAgIHJlc291" + + "cmNlczoKICAgICAgICAgIGxpbWl0czoKICAgICAgICAgICAgY3B1OiAiOCIKICAgICAgICAgICAg" + + "bWVtb3J5OiA4MTkyTWkKICAgICAgICAgIHJlcXVlc3RzOgogICAgICAgICAgICBjcHU6ICIyIgog" + + "ICAgICAgICAgICBtZW1vcnk6IDQwOTZNaQpgYGAKCiMjIyBTdGVwIDM6IFZlcmlmeSBhbmQgYXBw" + + "bHkKCmBgYGJhc2gKSEVMTUZJTEVfRU5WPTxlbnY+IGhlbG1maWxlIC0tc2VsZWN0b3IgbmFtZT1j" + + "YXNzYW5kcmEgdGVtcGxhdGUgPiAvdG1wL2Nhc3MtYWZ0ZXIueWFtbApkaWZmIC90bXAvY2Fzcy1i" + + "ZWZvcmUueWFtbCAvdG1wL2Nhc3MtYWZ0ZXIueWFtbCAgIyBDb25maXJtIHJlc291cmNlcyBjaGFu" + + "Z2VkCkhFTE1GSUxFX0VOVj08ZW52PiBoZWxtZmlsZSAtLXNlbGVjdG9yIG5hbWU9Y2Fzc2FuZHJh" + + "IHN5bmMKYGBgCgpOb3RlOiBgcmVzb3VyY2VQcmVzZXRgIChhIEJpdG5hbWkgZmVhdHVyZSkgaXMg" + + "bm90IGF2YWlsYWJsZSBpbiB0aGUgTlZDRiBjYXNzYW5kcmEgd3JhcHBlciBjaGFydC4gVXNlIGV4" + + "cGxpY2l0IGByZXNvdXJjZXNgIGluc3RlYWQuCgotLS0KCiMjIEV4YW1wbGUgMjogRGVwbG95IGZy" + + "b20gTkdDIFByaXZhdGUgUmVnaXN0cnkgd2l0aCBQdWxsIFNlY3JldHMKCkRlcGxveSB0aGUgTlZD" + + "RiBzdGFjayBwdWxsaW5nIGltYWdlcyBkaXJlY3RseSBmcm9tIE5HQyAoYG52Y3IuaW9gKSBpbnN0" + + "ZWFkIG9mIGEgbWlycm9yZWQgcmVnaXN0cnksIHVzaW5nIGltYWdlIHB1bGwgc2VjcmV0cy4KCiMj" + + "IyBTdGVwIDE6IENvbmZpZ3VyZSBlbnZpcm9ubWVudCBmb3IgTkdDCgpgYGB5YW1sCiMgZW52aXJv" + + "bm1lbnRzLzxlbnY+LnlhbWwKZ2xvYmFsOgogIGhlbG06CiAgICBzb3VyY2VzOgogICAgICByZWdp" + + "c3RyeTogbnZjci5pbwogICAgICByZXBvc2l0b3J5OiBudmlkaWEvbnZjZgogIGltYWdlOgogICAg" + + "cmVnaXN0cnk6IG52Y3IuaW8KICAgIHJlcG9zaXRvcnk6IG52aWRpYS9udmNmCmBgYAoKIyMjIFN0" + + "ZXAgMjogQXV0aGVudGljYXRlIGxvY2FsbHkgKGZvciBoZWxtZmlsZSBjaGFydCBwdWxscykKCmBg" + + "YGJhc2gKZG9ja2VyIGxvZ2luIG52Y3IuaW8gLXUgJyRvYXV0aHRva2VuJyAtcCAiJE5HQ19BUElf" + + "S0VZIgpoZWxtIHJlZ2lzdHJ5IGxvZ2luIG52Y3IuaW8gLXUgJyRvYXV0aHRva2VuJyAtcCAiJE5H" + + "Q19BUElfS0VZIgpgYGAKCiMjIyBTdGVwIDM6IENyZWF0ZSBuYW1lc3BhY2VzIGFuZCBwdWxsIHNl" + + "Y3JldHMKCmBgYGJhc2gKZXhwb3J0IE5HQ19BUElfS0VZPSI8eW91ci1uZ2MtYXBpLWtleT4iCgpm" + + "b3IgbnMgaW4gY2Fzc2FuZHJhLXN5c3RlbSBuYXRzLXN5c3RlbSBudmNmIGFwaS1rZXlzIGVzcyBz" + + "aXMgdmF1bHQtc3lzdGVtIGNlcnQtbWFuYWdlcjsgZG8KICBrdWJlY3RsIC0tY29udGV4dCA8Y29u" + + "dHJvbC1wbGFuZS1jb250ZXh0PiBjcmVhdGUgbmFtZXNwYWNlICIkbnMiIFwKICAgIC0tZHJ5LXJ1" + + "bj1jbGllbnQgLW8geWFtbCB8IGt1YmVjdGwgLS1jb250ZXh0IDxjb250cm9sLXBsYW5lLWNvbnRl" + + "eHQ+IGFwcGx5IC1mIC0KZG9uZQoKZm9yIG5zIGluIGNhc3NhbmRyYS1zeXN0ZW0gbmF0cy1zeXN0" + + "ZW0gbnZjZiBhcGkta2V5cyBlc3Mgc2lzIHZhdWx0LXN5c3RlbSBjZXJ0LW1hbmFnZXI7IGRvCiAg" + + "a3ViZWN0bCAtLWNvbnRleHQgPGNvbnRyb2wtcGxhbmUtY29udGV4dD4gY3JlYXRlIHNlY3JldCBk" + + "b2NrZXItcmVnaXN0cnkgbnZjci1jcmVkcyBcCiAgICAtLWRvY2tlci1zZXJ2ZXI9bnZjci5pbyBc" + + "CiAgICAtLWRvY2tlci11c2VybmFtZT0nJG9hdXRodG9rZW4nIFwKICAgIC0tZG9ja2VyLXBhc3N3" + + "b3JkPSIkTkdDX0FQSV9LRVkiIFwKICAgIC0tbmFtZXNwYWNlPSIkbnMiIFwKICAgIC0tZHJ5LXJ1" + + "bj1jbGllbnQgLW8geWFtbCB8IGt1YmVjdGwgLS1jb250ZXh0IDxjb250cm9sLXBsYW5lLWNvbnRl" + + "eHQ+IGFwcGx5IC1mIC0KZG9uZQpgYGAKCiMjIyBTdGVwIDQ6IEFkZCBpbWFnZVB1bGxTZWNyZXRz" + + "IHRvIGhlbG1maWxlIHJlbGVhc2VzCgpBZGQgdGhlIGNoYXJ0LXNwZWNpZmljIGBpbWFnZVB1bGxT" + + "ZWNyZXRzYCBrZXkgdG8gZWFjaCByZWxlYXNlLiBFeGFtcGxlIGZvciBjYXNzYW5kcmEgaW4gYGhl" + + "bG1maWxlLmQvMDEtZGVwZW5kZW5jaWVzLnlhbWwuZ290bXBsYDoKCmBgYHlhbWwKLSBuYW1lOiBj" + + "YXNzYW5kcmEKICB2ZXJzaW9uOiAwLjguMAogIGNvbmRpdGlvbjogY2Fzc2FuZHJhLmVuYWJsZWQK" + + "ICBuYW1lc3BhY2U6IGNhc3NhbmRyYS1zeXN0ZW0KICA8PDogKmRlcGVuZGVuY3kKICB2YWx1ZXM6" + + "CiAgICAtIC4uL2dsb2JhbC55YW1sLmdvdG1wbAogICAgLSAuLi88cHJpdmF0ZS12YWx1ZXM+L3t7" + + "IHJlcXVpcmVkRW52ICJIRUxNRklMRV9FTlYiIH19LXNlY3JldHMueWFtbAogICAgLSBjYXNzYW5k" + + "cmE6CiAgICAgICAgZ2xvYmFsOgogICAgICAgICAgaW1hZ2VQdWxsU2VjcmV0czoKICAgICAgICAg" + + "ICAgLSBudmNyLWNyZWRzCmBgYAoKU2VlIFtyZWZlcmVuY2VzL3B1bGwtc2VjcmV0cy5tZF0ocmVm" + + "ZXJlbmNlcy9wdWxsLXNlY3JldHMubWQpIGZvciB0aGUga2V5IGZvciBldmVyeSBjaGFydC4KClRo" + + "ZXNlIGFyZSBjb250cm9sLXBsYW5lIG5hbWVzcGFjZXMuIEZvciBhIHNlcGFyYXRlIGNvbXB1dGUg" + + "Y2x1c3RlciwgY3JlYXRlIHRoZQpzZWNyZXQgb25seSBpbiBgbnZjYS1vcGVyYXRvcmA7IHRoZSBj" + + "aGFydCBhbmQgb3BlcmF0b3IgbWlycm9yIGl0IHRvCmBudmNhLXN5c3RlbWAuIFNlZSBbU3BsaXQg" + + "Q29tcHV0ZS1QbGFuZSBJbnN0YWxsYXRpb25dKHJlZmVyZW5jZXMvY29tcHV0ZS1wbGFuZS1pbnN0" + + "YWxsYXRpb24ubWQjcHVsbC1zZWNyZXRzKS4KCiMjIyBTdGVwIDU6IERlcGxveQoKYGBgYmFzaApI" + + "RUxNRklMRV9FTlY9PGVudj4gaGVsbWZpbGUgLS1rdWJlLWNvbnRleHQgPGNvbnRyb2wtcGxhbmUt" + + "Y29udGV4dD4gc3luYwpgYGAKCiMjIyBTdGVwIDY6IFBhdGNoIFNlcnZpY2VBY2NvdW50cyBmb3Ig" + + "Y2hhcnRzIHdpdGhvdXQgbmF0aXZlIHN1cHBvcnQKCkFmdGVyIFBoYXNlIDEgKGRlcGVuZGVuY2ll" + + "cykgY29tcGxldGVzLCBPcGVuQmFvIHBvZHMgd2lsbCBiZSBpbiBgSW1hZ2VQdWxsQmFja09mZmAu" + + "IFBhdGNoIGFuZCByZXN0YXJ0OgoKYGBgYmFzaApmb3IgbnMgaW4gdmF1bHQtc3lzdGVtIG52Y2Yg" + + "ZXNzOyBkbwogIGZvciBzYSBpbiAkKGt1YmVjdGwgLS1jb250ZXh0IDxjb250cm9sLXBsYW5lLWNv" + + "bnRleHQ+IGdldCBzYSAtbiAiJG5zIiBcCiAgICAtLW5vLWhlYWRlcnMgLW8gY3VzdG9tLWNvbHVt" + + "bnM9IjptZXRhZGF0YS5uYW1lIik7IGRvCiAgICBrdWJlY3RsIC0tY29udGV4dCA8Y29udHJvbC1w" + + "bGFuZS1jb250ZXh0PiBwYXRjaCBzZXJ2aWNlYWNjb3VudCAtbiAiJG5zIiAiJHNhIiBcCiAgICAg" + + "IC1wICd7ImltYWdlUHVsbFNlY3JldHMiOiBbeyJuYW1lIjogIm52Y3ItY3JlZHMifV19JwogIGRv" + + "bmUKZG9uZQprdWJlY3RsIC0tY29udGV4dCA8Y29udHJvbC1wbGFuZS1jb250ZXh0PiBkZWxldGUg" + + "cG9kcyAtbiB2YXVsdC1zeXN0ZW0gLS1hbGwKYGBgCgpWZXJpZnk6CgpgYGBiYXNoCmt1YmVjdGwg" + + "LS1jb250ZXh0IDxjb250cm9sLXBsYW5lLWNvbnRleHQ+IGdldCBldmVudHMgLW4gdmF1bHQtc3lz" + + "dGVtIFwKICAtLXNvcnQtYnk9Jy5sYXN0VGltZXN0YW1wJyB8IGdyZXAgLWkgcHVsbAojIFNob3Vs" + + "ZCBzaG93ICJTdWNjZXNzZnVsbHkgcHVsbGVkIGltYWdlIiBmcm9tIG52Y3IuaW8KYGBgCgotLS0K" + + "CiMjIEV4YW1wbGUgMzogRnVsbCBUZWFyZG93biBhbmQgUmVpbnN0YWxsCgpXaGVuIGEgZGVwbG95" + + "bWVudCBpcyBicm9rZW4gYW5kIHlvdSBuZWVkIGEgY2xlYW4gc2xhdGUuCgojIyMgU3RlcCAxOiBE" + + "ZXN0cm95IHRoZSBjb21wdXRlLXBsYW5lIHN0YWNrCgpgYGBiYXNoCm1ha2UgLUMgZGVwbG95L3N0" + + "YWNrcy9udmNmLWNvbXB1dGUtcGxhbmUgZGVzdHJveSBcCiAgQ0xVU1RFUl9OQU1FPTxjbHVzdGVy" + + "LW5hbWU+IFwKICBIRUxNRklMRV9FTlY9PGVudj4gXAogIEtVQkVDT05GSUdfRklMRT08Y29tcHV0" + + "ZS1wbGFuZS1rdWJlY29uZmlnPgpgYGAKCklmIGNvbXB1dGUgY2xlYW51cCBpcyBzdHVjayBvbiBm" + + "aW5hbGl6ZXJzLCB1c2UgdGhlIGNvbXB1dGUtY29udGV4dCBwcm9jZWR1cmUgaW4KW2RlYnVnZ2lu" + + "Zy5tZF0ocmVmZXJlbmNlcy9kZWJ1Z2dpbmcubWQjZmFpbHVyZS1udmNhLWNsZWFudXAtc3R1Y2st" + + "ZmluYWxpemVycykuCgojIyMgU3RlcCAyOiBEZXJlZ2lzdGVyIHRoZSBjb21wdXRlIGNsdXN0ZXIK" + + "ClJlYWQgYGNsdXN0ZXJJRGAgYW5kIGBuY2FJRGAgZnJvbQpgZGVwbG95L3N0YWNrcy9udmNmLWNv" + + "bXB1dGUtcGxhbmUvcmVnaXN0cmF0aW9uLzxjbHVzdGVyLW5hbWU+LXJlZ2lzdGVyLXZhbHVlcy55" + + "YW1sYC4KU2hvdyB0aGUgSUQgYW5kIGdldCBjb25maXJtYXRpb24gYmVmb3JlIGRlbGV0aW5nIHRo" + + "ZSBJQ01TIHJvdzoKCmBgYGJhc2gKPG52Y2YtY2xpPiAtLWNvbmZpZyA8Y29uZmlnPiBjbHVzdGVy" + + "IGRlbGV0ZSBcCiAgLS1jbHVzdGVyLWlkIDxjbHVzdGVyLWlkLWZyb20tcmVnaXN0cmF0aW9uLXZh" + + "bHVlcz4gXAogIC0tbmNhLWlkIDxuY2EtaWQ+IFwKICAtLWlnbm9yZS1taXNzaW5nCmBgYAoKUmVw" + + "ZWF0IHN0ZXBzIDEgYW5kIDIgZm9yIGV2ZXJ5IGNvbXB1dGUgY2x1c3Rlci4KCiMjIyBTdGVwIDM6" + + "IERlc3Ryb3kgdGhlIGNvbnRyb2wtcGxhbmUgc3RhY2sKClByZXNlcnZlIHRoZSBgY2VydC1tYW5h" + + "Z2VyYCBuYW1lc3BhY2UgYnkgZGVmYXVsdC4gTmFtZXNwYWNlIHByZXNlcnZhdGlvbiBkb2VzCm5v" + + "dCBwcmVzZXJ2ZSB0aGUgSGVsbSByZWxlYXNlLiBCZWZvcmUgcnVubmluZyBkZXN0cm95LCBpZGVu" + + "dGlmeSB3aGV0aGVyCmNlcnQtbWFuYWdlciBpcyBleHRlcm5hbC4gRm9yIGFuIGV4dGVybmFsIGlu" + + "c3RhbGxhdGlvbiwgcmVxdWlyZSBlZmZlY3RpdmUKYGNlcnRNYW5hZ2VyLmVuYWJsZWQ6IGZhbHNl" + + "YCBhbmQgYWJvcnQgaWYgaXQgaXMgdHJ1ZS4gRm9yIGFuIGludGVuZGVkCnN0YWNrLW1hbmFnZWQg" + + "cmVsZWFzZSB3aXRoIGVmZmVjdGl2ZSBgY2VydE1hbmFnZXIuZW5hYmxlZDogdHJ1ZWAsIHZlcmlm" + + "eQptYXRjaGluZyBzdGFjayBIZWxtIHJlbGVhc2UgbWV0YWRhdGEgYW5kIGFib3J0IG9uIG1pc3Np" + + "bmcgb3IgbWlzbWF0Y2hlZApldmlkZW5jZS4gT25seSBwbGFuIG5hbWVzcGFjZSByZW1vdmFsIGFm" + + "dGVyIHZlcmlmeWluZyBuYW1lc3BhY2UgcHJvdmVuYW5jZSBhbmQKZ2V0dGluZyBleHBsaWNpdCBj" + + "b25maXJtYXRpb247IG90aGVyd2lzZSBkbyBub3QgZGVsZXRlIGl0LgoKYGBgYmFzaApLVUJFQ09O" + + "RklHPTxjb250cm9sLXBsYW5lLWt1YmVjb25maWc+IFwKbWFrZSAtQyBkZXBsb3kvc3RhY2tzL3Nl" + + "bGYtbWFuYWdlZCBkZXN0cm95IFwKICBIRUxNRklMRV9FTlY9PGVudj4gXAogIEtVQkVDT05GSUdf" + + "RklMRT08Y29udHJvbC1wbGFuZS1rdWJlY29uZmlnPgpgYGAKClBhc3MgYm90aCBrdWJlY29uZmln" + + "IGZvcm1zIGJlY2F1c2UgY29udHJvbC1wbGFuZSBuYW1lc3BhY2UgY2xlYW51cCB1c2VzCmFtYmll" + + "bnQgYGt1YmVjdGxgLgoKIyMjIFN0ZXAgNDogVmVyaWZ5IGNsZWFuCgpgYGBiYXNoCmt1YmVjdGwg" + + "LS1jb250ZXh0IDxjb21wdXRlLXBsYW5lLWNvbnRleHQ+IGdldCBucyB8IFwKICBncmVwIC1FICco" + + "bnZjYXxudmNmLWJhY2tlbmR8Z3JvdmV8ZHluYW1vKScKa3ViZWN0bCAtLWNvbnRleHQgPGNvbnRy" + + "b2wtcGxhbmUtY29udGV4dD4gZ2V0IG5zIHwgXAogIGdyZXAgLUUgJyhjYXNzYW5kcmF8bmF0c3x2" + + "YXVsdHxudmNmfGFwaS1rZXlzfGVzc3xzaXMpJwojIEJvdGggY29tbWFuZHMgc2hvdWxkIHJldHVy" + + "biBlbXB0eS4KYGBgCgojIyMgU3RlcCA1OiBSZWluc3RhbGwgaW4gc3BsaXQgb3JkZXIKCkZvbGxv" + + "dyBbQ2xlYW4gSW5zdGFsbGF0aW9uXShTS0lMTC5tZCNjbGVhbi1pbnN0YWxsYXRpb24pLCB0aGVu" + + "IHJldHVybiB0byB0aGUKc2FtZSBoYW5kb2ZmIGluIFtTcGxpdCBDb21wdXRlLVBsYW5lIEluc3Rh" + + "bGxhdGlvbl0ocmVmZXJlbmNlcy9jb21wdXRlLXBsYW5lLWluc3RhbGxhdGlvbi5tZCkuCgotLS0K" + + "CiMjIEV4YW1wbGUgNDogUmVjb3ZlciBmcm9tIGEgR2F0ZXdheSBFbmRwb2ludCBDaGFuZ2UKClRo" + + "ZSBzZXBhcmF0ZWx5IHByb3Zpc2lvbmVkIEdhdGV3YXkgb3IgaXRzIGxvYWQgYmFsYW5jZXIgd2Fz" + + "IHJlY3JlYXRlZCBhbmQgZ290IGEgbmV3IGVuZHBvaW50LgoKIyMjIFN0ZXAgMTogR2V0IHRoZSBu" + + "ZXcgZW5kcG9pbnQKCmBgYGJhc2gKR0FURVdBWV9BRERSPSQoa3ViZWN0bCAtLWNvbnRleHQgPGNv" + + "bnRyb2wtcGxhbmUtY29udGV4dD4gZ2V0IGdhdGV3YXkgXAogIG52Y2YtZ2F0ZXdheSAtbiBlbnZv" + + "eS1nYXRld2F5IFwKICAtbyBqc29ucGF0aD0ney5zdGF0dXMuYWRkcmVzc2VzWzBdLnZhbHVlfScp" + + "CnRlc3QgLW4gIiRHQVRFV0FZX0FERFIiCmBgYAoKIyMjIFN0ZXAgMjogVXBkYXRlIEROUyBhbmQg" + + "ZGlyZWN0IGFkZHJlc3MgZmllbGRzCgpLZWVwIGBnbG9iYWwuZG9tYWluYCwgcm91dGUgaG9zdG5h" + + "bWVzLCBhbmQgQ0xJIEhvc3QgZmllbGRzIHVuY2hhbmdlZC4gUG9pbnQgdGhlCkROUyByZWNvcmRz" + + "IGZvciByZW5kZXJlZCByb3V0ZSBob3N0bmFtZXMsIHN1Y2ggYXMgYGFwaS48ZG9tYWluPmAgYW5k" + + "CmAqLmludm9jYXRpb24uPGRvbWFpbj5gLCB0byBgR0FURVdBWV9BRERSYC4gRm9yIGEgdGVtcG9y" + + "YXJ5IGVudmlyb25tZW50IHdpdGhvdXQKRE5TLCBrZWVwIGl0cyByZXNlcnZlZCByb3V0ZSBzdWZm" + + "aXggYW5kIGNvbm5lY3QgdG8gYEdBVEVXQVlfQUREUmAgd2l0aCB0aGUKbWF0Y2hpbmcgYEhvc3Rg" + + "IGhlYWRlci4KCkZvciBhIHNwbGl0IGRlcGxveW1lbnQgY29uZmlndXJlZCB3aXRoIGRpcmVjdCBH" + + "YXRld2F5IGFkZHJlc3NlcywgcmVwbGFjZSBvbmx5CnRoZSBhZGRyZXNzLWJlYXJpbmcgdmFsdWVz" + + "OiBjb250cm9sLXBsYW5lIGBudmNmTmF0c1NlcnZpY2VVUkxgLCBjb21wdXRlLXBsYW5lCklDTVMs" + + "IFJlVmFsLCBhbmQgTkFUUyBVUkxzLCBhbmQgQ0xJIFVSTCBmaWVsZHMuIEtlZXAgdGhlaXIgZG9t" + + "YWluIGFuZCBIb3N0Cm92ZXJyaWRlcyB1bmNoYW5nZWQuIFJlZnJlc2ggcmVnaXN0cmF0aW9uIGFu" + + "ZCBpbnN0YWxsYXRpb24gdGhyb3VnaCB0aGUgc2FtZQpoYW5kb2ZmIHVzZWQgb3JpZ2luYWxseS4g" + + "U2VlCltTcGxpdCBDb21wdXRlLVBsYW5lIEluc3RhbGxhdGlvbl0ocmVmZXJlbmNlcy9jb21wdXRl" + + "LXBsYW5lLWluc3RhbGxhdGlvbi5tZCkKZm9yIHRoZSBmaWVsZHMgYW5kIGNvbXBsZXRlIGNvbW1h" + + "bmRzLgoKIyMjIFN0ZXAgMzogVmVyaWZ5IGJvdGggY29udGV4dHMKCmBgYGJhc2gKZGlnICtzaG9y" + + "dCAiYXBpLjxkb21haW4+IgpjdXJsIC1IICJIb3N0OiBhcGkuPGRvbWFpbj4iICJodHRwOi8vJEdB" + + "VEVXQVlfQUREUi9oZWFsdGgiCmt1YmVjdGwgLS1jb250ZXh0IDxjb250cm9sLXBsYW5lLWNvbnRl" + + "eHQ+IGdldCBnYXRld2F5IG52Y2YtZ2F0ZXdheSBcCiAgLW4gZW52b3ktZ2F0ZXdheSAtbyB3aWRl" + + "Cmt1YmVjdGwgLS1jb250ZXh0IDxjb250cm9sLXBsYW5lLWNvbnRleHQ+IGdldCBodHRwcm91dGVz" + + "IC1BCmt1YmVjdGwgLS1jb250ZXh0IDxjb250cm9sLXBsYW5lLWNvbnRleHQ+IGdldCB0Y3Byb3V0" + + "ZXMgLUEKa3ViZWN0bCAtLWNvbnRleHQgPGNvbXB1dGUtcGxhbmUtY29udGV4dD4gcm9sbG91dCBz" + + "dGF0dXMgXAogIGRlcGxveW1lbnQvbnZjYS1vcGVyYXRvciAtbiBudmNhLW9wZXJhdG9yIC0tdGlt" + + "ZW91dD0xMG0Ka3ViZWN0bCAtLWNvbnRleHQgPGNvbXB1dGUtcGxhbmUtY29udGV4dD4gd2FpdCBc" + + "CiAgbnZjZmJhY2tlbmQvPGNvbXB1dGUtcGxhbmUtY2x1c3Rlci1uYW1lPiAtbiBudmNhLW9wZXJh" + + "dG9yIFwKICAtLWZvcj1qc29ucGF0aD0ney5zdGF0dXMuYWdlbnRTdGF0dXN9Jz1oZWFsdGh5IC0t" + + "dGltZW91dD0xMG0KYGBgCgotLS0KCiMjIEV4YW1wbGUgNTogRGVwbG95IE9ubHkgRGVwZW5kZW5j" + + "aWVzCgpVc2VmdWwgZm9yIHRlc3Rpbmcgb3Igd2hlbiBpdGVyYXRpbmcgb24gc2VydmljZSBjb25m" + + "aWd1cmF0aW9uLgoKYGBgYmFzaAojIERlcGxveSBqdXN0IE5BVFMsIENhc3NhbmRyYSwgT3BlbkJh" + + "bwpIRUxNRklMRV9FTlY9PGVudj4gaGVsbWZpbGUgLS1zZWxlY3RvciByZWxlYXNlLWdyb3VwPWRl" + + "cGVuZGVuY2llcyBzeW5jCgojIENoZWNrIHN0YXR1cwprdWJlY3RsIGdldCBwb2RzIC1uIG5hdHMt" + + "c3lzdGVtCmt1YmVjdGwgZ2V0IHBvZHMgLW4gY2Fzc2FuZHJhLXN5c3RlbQprdWJlY3RsIGdldCBw" + + "b2RzIC1uIHZhdWx0LXN5c3RlbQoKIyBEZXBsb3kganVzdCBvbmUgc3BlY2lmaWMgcmVsZWFzZQpI" + + "RUxNRklMRV9FTlY9PGVudj4gaGVsbWZpbGUgLS1zZWxlY3RvciBuYW1lPWNhc3NhbmRyYSBzeW5j" + + "CmBgYAoKIyMjIFNlbGVjdG9yIHJlZmVyZW5jZQoKfCBTZWxlY3RvciB8IFJlbGVhc2VzIHwKfC0t" + + "LS0tLS0tLS18LS0tLS0tLS0tLXwKfCBgcmVsZWFzZS1ncm91cD1kZXBlbmRlbmNpZXNgIHwgbmF0" + + "cywgY2Fzc2FuZHJhLCBvcGVuYmFvLXNlcnZlciB8CnwgYHJlbGVhc2UtZ3JvdXA9c2VydmljZXNg" + + "IHwgYXBpLWtleXMsIHNpcywgYXBpLCBpbnZvY2F0aW9uLXNlcnZpY2UsIGdycGMtcHJveHksIGVz" + + "cy1hcGksIG5vdGFyeS1zZXJ2aWNlLCByZXZhbCwgb3B0aW9uYWwgbGxtLXJlcXVlc3Qtcm91dGVy" + + "IGFuZCBsbG0tYXBpLWdhdGV3YXkgd2hlbiBgbGxtLmVuYWJsZWQ9dHJ1ZWAsIG9wdGlvbmFsIHZh" + + "bml0eS1nYXRld2F5IG9ubHkgaW4gc3RhY2sgcGFja2FnZXMgdGhhdCBpbmNsdWRlIHRoZSBhZGRv" + + "biBhbmQgaGF2ZSBgYWRkb25zLnZhbml0eUdhdGV3YXkuZW5hYmxlZD10cnVlYCwgb3B0aW9uYWwg" + + "bnZjZi11aSBvbmx5IGluIHN0YWNrIHBhY2thZ2VzIHRoYXQgaW5jbHVkZSB0aGUgYWRkb24gYW5k" + + "IGhhdmUgYGFkZG9ucy5udmNmVWkuZW5hYmxlZD10cnVlYCB8CnwgYG5hbWU9bGxtLXJlcXVlc3Qt" + + "cm91dGVyYCB8IERlcGxveSBqdXN0IHRoZSBMTE0gcmVxdWVzdCByb3V0ZXIgd2hlbiBgbGxtLmVu" + + "YWJsZWQ9dHJ1ZWAgfAp8IGBuYW1lPWxsbS1hcGktZ2F0ZXdheWAgfCBEZXBsb3kganVzdCB0aGUg" + + "TExNIEFQSSBnYXRld2F5IHdoZW4gYGxsbS5lbmFibGVkPXRydWVgIHwKfCBgbmFtZT12YW5pdHkt" + + "Z2F0ZXdheWAgfCBEZXBsb3kganVzdCBWYW5pdHkgR2F0ZXdheSBvbmx5IHdoZW4gdGhlIHN0YWNr" + + "IHBhY2thZ2UgaW5jbHVkZXMgdGhhdCByZWxlYXNlIGFuZCBgYWRkb25zLnZhbml0eUdhdGV3YXku" + + "ZW5hYmxlZD10cnVlYCB8CnwgYG5hbWU9bnZjZi11aWAgfCBEZXBsb3kgTlZDRiBVSSBvbmx5IHdo" + + "ZW4gdGhlIHN0YWNrIHBhY2thZ2UgaW5jbHVkZXMgdGhhdCByZWxlYXNlIGFuZCBgYWRkb25zLm52" + + "Y2ZVaS5lbmFibGVkPXRydWVgIHwKfCBgcmVsZWFzZS1ncm91cD1pbmdyZXNzYCB8IGluZ3Jlc3Mg" + + "KGdhdGV3YXkgcm91dGVzKSB8CnwgYG5hbWU9PHJlbGVhc2U+YCB8IEFueSBpbmRpdmlkdWFsIHJl" + + "bGVhc2UgYnkgbmFtZSB8CgpOb3RlOiBgYWRtaW4taXNzdWVyLXByb3h5YCBkb2VzIG5vdCBoYXZl" + + "IGEgcmVsZWFzZS1ncm91cCBsYWJlbC4gVGFyZ2V0IGl0IHdpdGggYC0tc2VsZWN0b3IgbmFtZT1h" + + "ZG1pbi1pc3N1ZXItcHJveHlgLgpQSwcIAlJOQH8oAAB/KAAAUEsDBBQACAAAAAAAIQAAAAAAAAAA" + + "AAAAAABMAAkAZGF0YS9udmNmLXNlbGYtbWFuYWdlZC1pbnN0YWxsYXRpb24vcmVmZXJlbmNlcy9j" + + "b21wdXRlLXBsYW5lLWluc3RhbGxhdGlvbi5tZFVUBQABAKbOEiMgU3BsaXQgQ29tcHV0ZS1QbGFu" + + "ZSBJbnN0YWxsYXRpb24KClRoZSBjb250cm9sIHBsYW5lIGFuZCBjb21wdXRlIHBsYW5lIGFyZSBz" + + "ZXBhcmF0ZSBzdGFja3MuIEluc3RhbGwgdGhlIGNvbnRyb2wKcGxhbmUgZmlyc3QsIHRoZW4gcmVn" + + "aXN0ZXIgYW5kIGluc3RhbGwgZWFjaCBjb21wdXRlIGNsdXN0ZXIuIENob29zZSBvbmUgaGFuZG9m" + + "ZgpiZWxvdyBhbmQgdXNlIGl0IGZvciB0aGUgZnVsbCBsaWZlY3ljbGUuIERvIG5vdCBjb21iaW5l" + + "IGEgQ0xJLWdlbmVyYXRlZCBwcm9maWxlCndpdGggdGhlIEhlbG1maWxlIHZhbHVlcyBmbG93LgoK" + + "IyMgQ2hvb3NlIGEgSGFuZG9mZgoKfCBGbG93IHwgU291cmNlIG9mIGNvbnRyb2wtcGxhbmUgZW5k" + + "cG9pbnRzIHwgUmVnaXN0cmF0aW9uIGFydGlmYWN0IHwKfC0tLS0tLXwtLS0tLS0tLS0tLS0tLS0t" + + "LS0tLS0tLS0tLS0tLS0tLS0tLXwtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLXwKfCBIZWxtZmlsZSB2" + + "YWx1ZXMgfCBTZXBhcmF0ZSBjb250cm9sLXBsYW5lIGFuZCBjb21wdXRlLXBsYW5lIGVudmlyb25t" + + "ZW50IGZpbGVzIHwgYGRlcGxveS9zdGFja3MvbnZjZi1jb21wdXRlLXBsYW5lL3JlZ2lzdHJhdGlv" + + "bi88Y2x1c3Rlcj4tcmVnaXN0ZXItdmFsdWVzLnlhbWxgIHwKfCBDTEkgcHJvZmlsZSB8IENMSS1n" + + "ZW5lcmF0ZWQgYGRlcGxveS9zdGFja3Mvc2VsZi1tYW5hZ2VkL291dC9jb250cm9sLXBsYW5lLXBy" + + "b2ZpbGUueWFtbGAgfCBDTEktZ2VuZXJhdGVkIGBkZXBsb3kvc3RhY2tzL252Y2YtY29tcHV0ZS1w" + + "bGFuZS9vdXQvPGNsdXN0ZXI+LXJlZ2lzdGVyLXZhbHVlcy55YW1sYCB8CgpUaGUgQ0xJIHByb2Zp" + + "bGUgaXMgbWFuZGF0b3J5IGZvciB0aGUgQ0xJIGZsb3cgYW5kIG11c3Qgbm90IGJlIGhhbmQtYXV0" + + "aG9yZWQuClRoZSBIZWxtZmlsZSBmbG93IGRvZXMgbm90IGNvbnN1bWUgYSBjb250cm9sLXBsYW5l" + + "IHByb2ZpbGUuCgpDb21tYW5kcyBiZWxvdyB1c2UgbW9ub3JlcG8gcGF0aHMgZnJvbSB0aGUgcmVw" + + "b3NpdG9yeSByb290LiBPcGVyYXRvcnMgdXNpbmcKZXh0cmFjdGVkIHBhY2thZ2VzIG5lZWQgbWF0" + + "Y2hpbmctdmVyc2lvbiBgbnZjZi1zZWxmLW1hbmFnZWQtc3RhY2tgIGFuZApgbnZjZi1jb21wdXRl" + + "LXBsYW5lLXN0YWNrYCBidW5kbGVzLiBTdWJzdGl0dXRlIHRob3NlIGJ1bmRsZSByb290cyBmb3IK" + + "YGRlcGxveS9zdGFja3Mvc2VsZi1tYW5hZ2VkYCBhbmQgYGRlcGxveS9zdGFja3MvbnZjZi1jb21w" + + "dXRlLXBsYW5lYC4KCiMjIEhlbG1maWxlIFZhbHVlcyBGbG93CgpDcmVhdGUgYm90aCBlbnZpcm9u" + + "bWVudCBmaWxlcyBiZWZvcmUgaW5zdGFsbGF0aW9uOgoKLSBgZGVwbG95L3N0YWNrcy9zZWxmLW1h" + + "bmFnZWQvZW52aXJvbm1lbnRzLzxlbnY+LnlhbWxgIGZvciBjb250cm9sLXBsYW5lCiAgcmVnaXN0" + + "cnksIGRvbWFpbiwgR2F0ZXdheSwgcm91dGVzLCBhbmQgc2VydmljZSBzZXR0aW5ncy4KLSBgZGVw" + + "bG95L3N0YWNrcy9udmNmLWNvbXB1dGUtcGxhbmUvZW52aXJvbm1lbnRzLzxlbnY+LnlhbWxgIGZv" + + "ciBjb21wdXRlLXBsYW5lCiAgcmVnaXN0cnksIHB1bGwgc2VjcmV0cywgYW5kIGNvbXB1dGUtcmVh" + + "Y2hhYmxlIElDTVMsIFJlVmFsLCBhbmQgTkFUUyB2YWx1ZXMuCgpGb3IgRUtTLCB1c2UgdGhlIGNh" + + "bm9uaWNhbApbQ1NQIEVuZC10by1FbmQgRXhhbXBsZV0oaHR0cHM6Ly9kb2NzLm52aWRpYS5jb20v" + + "bnZjZi92MC42LjAtcmMvY3NwLWVuZC10by1lbmQtZXhhbXBsZSkuClRoZSBjb250cm9sLXBsYW5l" + + "IGVudmlyb25tZW50IGtlZXBzIHRoZSBFbnZveSBHYXRld2F5IGNvbnRyb2xsZXIgaW4KYGVudm95" + + "LWdhdGV3YXktc3lzdGVtYCwgYXR0YWNoZXMgcm91dGVzIHRvIGBHYXRld2F5L252Y2YtZ2F0ZXdh" + + "eWAgaW4KYGVudm95LWdhdGV3YXlgLCBhbmQgZW5hYmxlcyB0aGUgTkFUUyByb3V0ZS4gVGhlIGNv" + + "bXB1dGUtcGxhbmUgZW52aXJvbm1lbnQgdXNlcwp0aGUgZXh0ZXJuYWwgYWRkcmVzcyBwbHVzIHRo" + + "ZSBzZXJ2aWNlIGhvc3Qgb3ZlcnJpZGVzLiBIZXJlLApgPGdhdGV3YXktYWRkcmVzcz5gIGlzIHRo" + + "ZSBOTEIgYWRkcmVzcyBhbmQgYDxnYXRld2F5LWRvbWFpbj5gIGlzIHRoZSBETlMgYmFzZQp3aG9z" + + "ZSBzZXJ2aWNlIHN1YmRvbWFpbnMgcmVzb2x2ZSB0byB0aGF0IE5MQjoKCmBgYHlhbWwKIyBkZXBs" + + "b3kvc3RhY2tzL3NlbGYtbWFuYWdlZC9lbnZpcm9ubWVudHMvPGVudj4ueWFtbApnbG9iYWw6CiAg" + + "ZG9tYWluOiAiPGdhdGV3YXktZG9tYWluPiIKICB3b3JrZXJFbmRwb2ludHM6CiAgICBudmNmU2Vy" + + "dmljZVVSTDogImh0dHA6Ly9hcGkuPGdhdGV3YXktZG9tYWluPiIKICAgIG52Y2ZHcnBjU2Vydmlj" + + "ZVVSTDogImh0dHA6Ly93b3JrZXItYXBpLjxnYXRld2F5LWRvbWFpbj4iCiAgICBudmNmTmF0c1Nl" + + "cnZpY2VVUkw6ICJuYXRzOi8vPGdhdGV3YXktYWRkcmVzcz46NDIyMiIKICAgIG52Y3RTZXJ2aWNl" + + "VVJMOiAiaHR0cDovL3Rhc2tzLjxnYXRld2F5LWRvbWFpbj4iCiAgICBudmN0R3JwY1NlcnZpY2VV" + + "Ukw6ICJodHRwOi8vd29ya2VyLXRhc2tzLjxnYXRld2F5LWRvbWFpbj4iCiAgICBpbnZvY2F0aW9u" + + "U2VydmljZVVSTDogImh0dHA6Ly9pbnZvY2F0aW9uLjxnYXRld2F5LWRvbWFpbj4iCgpncnBjcHJv" + + "eHk6CiAgbnZjZkdycGNTZXJ2aWNlVVJMOiAiaHR0cDovL2FwaS5udmNmLnN2Yy5jbHVzdGVyLmxv" + + "Y2FsOjkwOTAiCgppbmdyZXNzOgogIGdhdGV3YXlBcGk6CiAgICBjb250cm9sbGVyTmFtZXNwYWNl" + + "OiBlbnZveS1nYXRld2F5LXN5c3RlbQogICAgZ2F0ZXdheXM6CiAgICAgIHNoYXJlZDoge25hbWU6" + + "IG52Y2YtZ2F0ZXdheSwgbmFtZXNwYWNlOiBlbnZveS1nYXRld2F5fQogICAgICBncnBjOiB7bmFt" + + "ZTogbnZjZi1nYXRld2F5LCBuYW1lc3BhY2U6IGVudm95LWdhdGV3YXl9CiAgICAgIG5hdHM6CiAg" + + "ICAgICAgbmFtZTogbnZjZi1nYXRld2F5CiAgICAgICAgbmFtZXNwYWNlOiBlbnZveS1nYXRld2F5" + + "CiAgICAgICAgbGlzdGVuZXJOYW1lOiBuYXRzCiAgICByb3V0ZXM6CiAgICAgIG52Y2ZBcGk6CiAg" + + "ICAgICAgZ3JwYzoKICAgICAgICAgIGVuYWJsZWQ6IHRydWUKICAgICAgICAgIGhvc3RuYW1lczog" + + "WyJ3b3JrZXItYXBpLjxnYXRld2F5LWRvbWFpbj4iXQogICAgICBudmN0QXBpOgogICAgICAgIGdy" + + "cGM6CiAgICAgICAgICBlbmFibGVkOiB0cnVlCiAgICAgICAgICBob3N0bmFtZXM6IFsid29ya2Vy" + + "LXRhc2tzLjxnYXRld2F5LWRvbWFpbj4iXQogICAgICBuYXRzOgogICAgICAgIGVuYWJsZWQ6IHRy" + + "dWUKCm9wZW5iYW86CiAgbWlncmF0aW9uczoKICAgIGlzc3VlckRpc2NvdmVyeToKICAgICAgZW5h" + + "YmxlZDogdHJ1ZQpgYGAKCmBgYHlhbWwKIyBkZXBsb3kvc3RhY2tzL252Y2YtY29tcHV0ZS1wbGFu" + + "ZS9lbnZpcm9ubWVudHMvPGVudj4ueWFtbApnbG9iYWw6CiAgbnZjYU9wZXJhdG9yOgogICAgc2Vs" + + "Zk1hbmFnZWQ6CiAgICAgIGljbXNTZXJ2aWNlVVJMOiAiaHR0cDovLzxnYXRld2F5LWFkZHJlc3M+" + + "IgogICAgICBpY21zU2VydmljZUhvc3RIZWFkZXJPdmVycmlkZTogInNpcy48Z2F0ZXdheS1kb21h" + + "aW4+IgogICAgICByZXZhbFNlcnZpY2VVUkw6ICJodHRwOi8vPGdhdGV3YXktYWRkcmVzcz4iCiAg" + + "ICAgIHJldmFsU2VydmljZUhvc3RIZWFkZXJPdmVycmlkZTogInJldmFsLjxnYXRld2F5LWRvbWFp" + + "bj4iCiAgICAgIG5hdHNVUkw6ICJuYXRzOi8vPGdhdGV3YXktYWRkcmVzcz46NDIyMiIKICAgICAg" + + "bmF0c0hvc3RPdmVycmlkZTogIm5hdHMuPGdhdGV3YXktZG9tYWluPiIKYGBgCgpQcmV2aWV3IGFu" + + "ZCBpbnN0YWxsIHRoZSBjb250cm9sIHBsYW5lIGFnYWluc3QgaXRzIGNvbnRleHQ6CgpgYGBiYXNo" + + "Cm1ha2UgLUMgZGVwbG95L3N0YWNrcy9zZWxmLW1hbmFnZWQgdGVtcGxhdGUgXAogIEhFTE1GSUxF" + + "X0VOVj08ZW52PiBcCiAgS1VCRUNPTkZJR19GSUxFPTxjb250cm9sLXBsYW5lLWt1YmVjb25maWc+" + + "CgptYWtlIC1DIGRlcGxveS9zdGFja3Mvc2VsZi1tYW5hZ2VkIGluc3RhbGwgXAogIEhFTE1GSUxF" + + "X0VOVj08ZW52PiBcCiAgS1VCRUNPTkZJR19GSUxFPTxjb250cm9sLXBsYW5lLWt1YmVjb25maWc+" + + "CmBgYAoKQmVmb3JlIHJlZ2lzdGVyaW5nIHRocm91Z2ggYSBiYXJlIEdhdGV3YXkgYWRkcmVzcywg" + + "Y3JlYXRlIG9yIHVwZGF0ZSB0aGUgQ0xJCmNvbmZpZyBwYXNzZWQgYXMgYE5WQ0ZfQ0xJX0NPTkZJ" + + "R2A6CgpgYGB5YW1sCmJhc2VfaHR0cF91cmw6ICJodHRwOi8vPGdhdGV3YXktYWRkcmVzcz4iCmlu" + + "dm9rZV91cmw6ICJodHRwOi8vPGdhdGV3YXktYWRkcmVzcz4iCmJhc2VfZ3JwY191cmw6ICI8Z2F0" + + "ZXdheS1hZGRyZXNzPjoxMDA4MSIKYXBpX2tleXNfc2VydmljZV91cmw6ICJodHRwOi8vPGdhdGV3" + + "YXktYWRkcmVzcz4iCmljbXNfdXJsOiAiaHR0cDovLzxnYXRld2F5LWFkZHJlc3M+IgphcGlfaG9z" + + "dDogImFwaS48Z2F0ZXdheS1kb21haW4+IgphcGlfa2V5c19ob3N0OiAiYXBpLWtleXMuPGdhdGV3" + + "YXktZG9tYWluPiIKaW52b2tlX2hvc3Q6ICJpbnZvY2F0aW9uLjxnYXRld2F5LWRvbWFpbj4iCmlj" + + "bXNfaG9zdDogInNpcy48Z2F0ZXdheS1kb21haW4+IgpgYGAKCkhvc3QgZmllbGRzIGNvbnRhaW4g" + + "aG9zdG5hbWVzIG9ubHksIHdpdGhvdXQgYSBVUkwgc2NoZW1lLiBgSUNNU19VUkxgIG1hcHMgb25s" + + "eQp0byB0aGUgcmVnaXN0cmF0aW9uIGNvbW1hbmQncyBgLS1pY21zLXVybGA7IGBpY21zX2hvc3Rg" + + "IGluIHRoZSBjb25maWcgc3VwcGxpZXMKdGhlIEdhdGV3YXkgSG9zdCBoZWFkZXIuIFRoZXJlIGlz" + + "IG5vIGAtLWljbXMtaG9zdGAgTWFrZSBvciBDTEkgZmxhZy4KClJlZ2lzdGVyIGZyb20gdGhlIGNv" + + "bXB1dGUgY29udGV4dCwgdGhlbiBpbnN0YWxsIHRoZSBjb21wdXRlIHBsYW5lOgoKYGBgYmFzaApt" + + "YWtlIC1DIGRlcGxveS9zdGFja3MvbnZjZi1jb21wdXRlLXBsYW5lIHJlZ2lzdGVyLWNsdXN0ZXIg" + + "XAogIENMVVNURVJfTkFNRT08Y2x1c3Rlci1uYW1lPiBcCiAgTkNBX0lEPTxuY2EtaWQ+IFwKICBD" + + "TFVTVEVSX1JFR0lPTj08cmVnaW9uPiBcCiAgSUNNU19VUkw9aHR0cDovLzxnYXRld2F5LWFkZHJl" + + "c3M+IFwKICBLVUJFQ09ORklHX0ZJTEU9PGNvbXB1dGUtcGxhbmUta3ViZWNvbmZpZz4gXAogIE5W" + + "Q0ZfQ0xJPTxwYXRoLXRvLW52Y2YtY2xpPiBcCiAgTlZDRl9DTElfQ09ORklHPTxwYXRoLXRvLW52" + + "Y2YtY2xpLWNvbmZpZz4KCm1ha2UgLUMgZGVwbG95L3N0YWNrcy9udmNmLWNvbXB1dGUtcGxhbmUg" + + "aW5zdGFsbCBcCiAgQ0xVU1RFUl9OQU1FPTxjbHVzdGVyLW5hbWU+IFwKICBIRUxNRklMRV9FTlY9" + + "PGVudj4gXAogIEtVQkVDT05GSUdfRklMRT08Y29tcHV0ZS1wbGFuZS1rdWJlY29uZmlnPgpgYGAK" + + "ClJlZ2lzdHJhdGlvbiBkaXNjb3ZlcnMgdGhlIE9JREMgaXNzdWVyIGFuZCBKV0tTIGZyb20gdGhl" + + "IGNvbXB1dGUga3ViZSBjb250ZXh0LgpJbiBhIG11bHRpLWNsdXN0ZXIgZGVwbG95bWVudCwgYEtV" + + "QkVDT05GSUdfRklMRWAgaXMgcmVxdWlyZWQgb24gYm90aApjb21wdXRlLXBsYW5lIGNvbW1hbmRz" + + "LiBJbiBhIHNhbWUtY2x1c3RlciBkZXBsb3ltZW50IGl0IG1heSBiZSBvbWl0dGVkIG9ubHkKd2hl" + + "biB0aGUgYW1iaWVudCBjb250ZXh0IGlzIGFscmVhZHkgdGhlIHRhcmdldCBjbHVzdGVyLgoKIyMg" + + "Q0xJIFByb2ZpbGUgRmxvdwoKUnVuIHRoZSBDTEkgY29udHJvbC1wbGFuZSBpbnN0YWxsIGZpcnN0" + + "LiBJdCBjcmVhdGVzIHRoZSBwcm9maWxlIGNvbnN1bWVkIGJ5CmNvbXB1dGUtcGxhbmUgcmVnaXN0" + + "cmF0aW9uOgoKYGBgYmFzaApudmNmLWNsaSAtLWNvbmZpZyA8Y29uZmlnPiBzZWxmLWhvc3RlZCBc" + "CiAgLS1jb250cm9sLXBsYW5lLXN0YWNrIGRlcGxveS9zdGFja3Mvc2VsZi1tYW5hZ2VkIFwKICAt" + "LWNvbXB1dGUtcGxhbmUtc3RhY2sgZGVwbG95L3N0YWNrcy9udmNmLWNvbXB1dGUtcGxhbmUgXAog" + "IC0tZW52IDxlbnY+IFwKICAtLXBsYWluIFwKICAtLWNvbnRyb2wtcGxhbmUtY29udGV4dCA8Y29u" + "dHJvbC1wbGFuZS1jb250ZXh0PiBcCiAgLS1jb21wdXRlLXBsYW5lLWNvbnRleHQgPGNvbXB1dGUt" + - "cGxhbmUtY29udGV4dD4gXAogIC0taWNtcy11cmwgPGNvbXB1dGUtcmVhY2hhYmxlLWljbXMtdXJs" + - "PiBcCiAgc3RhdHVzIFwKICAtLWNsdXN0ZXItbmFtZSA8Y29tcHV0ZS1wbGFuZS1jbHVzdGVyLW5h" + - "bWU+IFwKICAtLW5jYS1pZCA8bmNhLWlkPgpgYGAKClNob3cgdGhlIHJlZ2lzdGVyZWQgY29tcHV0" + - "ZS1wbGFuZSBsaXN0LiBOYW1lZC1jbHVzdGVyIGBkb3duIC0tcGxhbi1vbmx5YCBkb2VzCm5vdCBx" + - "dWVyeSBJQ01TLCBzbyBpdCBwcmV2aWV3cyBvbmx5IHRoYXQgY29tcHV0ZSBwbGFuZSBhbmQgY2Fu" + - "bm90IHNob3cgdGhlCmNvbmRpdGlvbmFsIGNvbnRyb2wtcGxhbmUgcmVtb3ZhbC4gSWYgdGhlIHRh" + - "cmdldCBpcyB0aGUgbGFzdCByZWdpc3RlcmVkCmNsdXN0ZXIsIHJlYWwgYGRvd25gIGFsc28gZGVz" + - "dHJveXMgdGhlIGNvbnRyb2wgcGxhbmUuIEdldCBleHBsaWNpdCBjb25maXJtYXRpb24KZm9yIGJv" + - "dGggcmVtb3ZhbHMgYmVmb3JlIGNvbnRpbnVpbmcuIFRoZW4gcHJldmlldyBhbmQgZXhlY3V0ZSB3" + - "aXRoIHRoZSBzYW1lCnByZWZpeDoKCmBgYGJhc2gKbnZjZi1jbGkgLS1jb25maWcgPGNvbmZpZz4g" + - "c2VsZi1ob3N0ZWQgXAogIC0tY29udHJvbC1wbGFuZS1zdGFjayBkZXBsb3kvc3RhY2tzL3NlbGYt" + - "bWFuYWdlZCBcCiAgLS1jb21wdXRlLXBsYW5lLXN0YWNrIGRlcGxveS9zdGFja3MvbnZjZi1jb21w" + - "dXRlLXBsYW5lIFwKICAtLWVudiA8ZW52PiBcCiAgLS1wbGFpbiBcCiAgLS1jb250cm9sLXBsYW5l" + - "LWNvbnRleHQgPGNvbnRyb2wtcGxhbmUtY29udGV4dD4gXAogIC0tY29tcHV0ZS1wbGFuZS1jb250" + - "ZXh0IDxjb21wdXRlLXBsYW5lLWNvbnRleHQ+IFwKICAtLWljbXMtdXJsIDxjb21wdXRlLXJlYWNo" + - "YWJsZS1pY21zLXVybD4gXAogIGRvd24gLS1wbGFuLW9ubHkgXAogIC0tY2x1c3Rlci1uYW1lIDxj" + - "b21wdXRlLXBsYW5lLWNsdXN0ZXItbmFtZT4gXAogIC0tbmNhLWlkIDxuY2EtaWQ+CgpudmNmLWNs" + - "aSAtLWNvbmZpZyA8Y29uZmlnPiBzZWxmLWhvc3RlZCBcCiAgLS1jb250cm9sLXBsYW5lLXN0YWNr" + - "IGRlcGxveS9zdGFja3Mvc2VsZi1tYW5hZ2VkIFwKICAtLWNvbXB1dGUtcGxhbmUtc3RhY2sgZGVw" + - "bG95L3N0YWNrcy9udmNmLWNvbXB1dGUtcGxhbmUgXAogIC0tZW52IDxlbnY+IFwKICAtLXBsYWlu" + - "IFwKICAtLWNvbnRyb2wtcGxhbmUtY29udGV4dCA8Y29udHJvbC1wbGFuZS1jb250ZXh0PiBcCiAg" + - "LS1jb21wdXRlLXBsYW5lLWNvbnRleHQgPGNvbXB1dGUtcGxhbmUtY29udGV4dD4gXAogIC0taWNt" + - "cy11cmwgPGNvbXB1dGUtcmVhY2hhYmxlLWljbXMtdXJsPiBcCiAgZG93biBcCiAgLS1jbHVzdGVy" + - "LW5hbWUgPGNvbXB1dGUtcGxhbmUtY2x1c3Rlci1uYW1lPiBcCiAgLS1uY2EtaWQgPG5jYS1pZD4K" + - "YGBgCgpSZXBlYXQgYGRvd25gIGZvciBlYWNoIGNvbXB1dGUgY2x1c3Rlci4gRWFjaCBydW4gZGVz" + - "dHJveXMgdGhhdCBjb21wdXRlIHBsYW5lIGFuZAp1bnJlZ2lzdGVycyBpdHMgSUNNUyByb3cuIEl0" + - "IHJlbW92ZXMgdGhlIGNvbnRyb2wgcGxhbmUgb25seSBhZnRlciBubyBjbHVzdGVyCnJlZ2lzdHJh" + - "dGlvbnMgcmVtYWluLgpQSwcIlmO8WRIwAAASMAAAUEsDBBQACAAAAAAAIQAAAAAAAAAAAAAAAAA7" + - "AAkAZGF0YS9udmNmLXNlbGYtbWFuYWdlZC1pbnN0YWxsYXRpb24vcmVmZXJlbmNlcy9kZWJ1Z2dp" + - "bmcubWRVVAUAAQCmzhIjIERlYnVnZ2luZyBSZWZlcmVuY2UKClJlY2lwZXMgZm9yIGRpYWdub3Np" + - "bmcgYW5kIGZpeGluZyBjb21tb24gTlZDRiBzZWxmLW1hbmFnZWQgc3RhY2sgZmFpbHVyZXMuCgoj" + - "IyBRdWljayBTdGF0dXMgQ29tbWFuZHMKCmBgYGJhc2gKIyBBbGwgcG9kcyBhY3Jvc3MgYWxsIG5h" + - "bWVzcGFjZXMKa3ViZWN0bCBnZXQgcG9kcyAtQSAtbyB3aWRlCgojIFBvZHMgaW4gYSBzcGVjaWZp" + - "YyBuYW1lc3BhY2UKa3ViZWN0bCBnZXQgcG9kcyAtbiA8bmFtZXNwYWNlPgoKIyBBbGwgaGVsbSBy" + - "ZWxlYXNlcwpoZWxtIGxpc3QgLUEKCiMgUmVjZW50IGV2ZW50cyAobW9zdCB1c2VmdWwgZm9yIGRp" + - "YWdub3NpbmcgZmFpbHVyZXMpCmt1YmVjdGwgZ2V0IGV2ZW50cyAtbiA8bmFtZXNwYWNlPiAtLXNv" + - "cnQtYnk9Jy5sYXN0VGltZXN0YW1wJwoKIyBEZXNjcmliZSBhIHNwZWNpZmljIHBvZCAoc2hvd3Mg" + - "ZXZlbnRzLCBjb25kaXRpb25zLCB2b2x1bWVzKQprdWJlY3RsIGRlc2NyaWJlIHBvZCAtbiA8bmFt" + - "ZXNwYWNlPiA8cG9kLW5hbWU+CmBgYAoKIyMgRmFpbHVyZTogSW1hZ2VQdWxsQmFja09mZgoKIyMj" + - "IFN5bXB0b21zCgpgYGAKTkFNRSAgICAgICAgICAgUkVBRFkgICBTVEFUVVMgICAgICAgICAgICAg" + - "UkVTVEFSVFMgICBBR0UKY2Fzc2FuZHJhLTAgICAgMC8xICAgICBJbWFnZVB1bGxCYWNrT2ZmICAg" + - "MCAgICAgICAgICA1bQpgYGAKCkV2ZW50cyBzaG93OgpgYGAKRmFpbGVkIHRvIHB1bGwgaW1hZ2Ug" + - "Im52Y3IuaW8vLi4uL2ltYWdlOnRhZyI6IDQwMSBVbmF1dGhvcml6ZWQKYGBgCgojIyMgRGlhZ25v" + - "c2lzCgpgYGBiYXNoCiMgQ2hlY2sgd2hhdCBpbWFnZSBpcyBmYWlsaW5nCmt1YmVjdGwgZGVzY3Jp" + - "YmUgcG9kIC1uIDxuYW1lc3BhY2U+IDxwb2QtbmFtZT4gfCBncmVwIC1BNSAiRXZlbnRzOiIKCiMg" + - "Q2hlY2sgaWYgcHVsbCBzZWNyZXQgZXhpc3RzIGluIHRoZSBuYW1lc3BhY2UKa3ViZWN0bCBnZXQg" + - "c2VjcmV0IG52Y3ItY3JlZHMgLW4gPG5hbWVzcGFjZT4KCiMgQ2hlY2sgaWYgdGhlIHBvZCBzcGVj" + - "IGhhcyBpbWFnZVB1bGxTZWNyZXRzCmt1YmVjdGwgZ2V0IHBvZCAtbiA8bmFtZXNwYWNlPiA8cG9k" + - "LW5hbWU+IC1vIGpzb25wYXRoPSd7LnNwZWMuaW1hZ2VQdWxsU2VjcmV0c30nCgojIENoZWNrIGlm" + - "IHRoZSBTZXJ2aWNlQWNjb3VudCBoYXMgaW1hZ2VQdWxsU2VjcmV0cwprdWJlY3RsIGdldCBzYSA8" + - "c2EtbmFtZT4gLW4gPG5hbWVzcGFjZT4gLW8ganNvbnBhdGg9J3suaW1hZ2VQdWxsU2VjcmV0c30n" + - "CmBgYAoKIyMjIEZpeGVzCgoxLiAqKlNlY3JldCBtaXNzaW5nIGluIG5hbWVzcGFjZSoqOiBDcmVh" + - "dGUgaXQKICAgYGBgYmFzaAogICBrdWJlY3RsIGNyZWF0ZSBzZWNyZXQgZG9ja2VyLXJlZ2lzdHJ5" + - "IG52Y3ItY3JlZHMgXAogICAgIC0tZG9ja2VyLXNlcnZlcj1udmNyLmlvIFwKICAgICAtLWRvY2tl" + - "ci11c2VybmFtZT0nJG9hdXRodG9rZW4nIFwKICAgICAtLWRvY2tlci1wYXNzd29yZD0iJE5HQ19B" + - "UElfS0VZIiBcCiAgICAgLS1uYW1lc3BhY2U9PG5hbWVzcGFjZT4gXAogICAgIC0tZHJ5LXJ1bj1j" + - "bGllbnQgLW8geWFtbCB8IGt1YmVjdGwgYXBwbHkgLWYgLQogICBgYGAKCjIuICoqU2VjcmV0IGV4" + - "aXN0cyBidXQgcG9kIGRvZXNuJ3QgcmVmZXJlbmNlIGl0Kio6IFRoZSBjaGFydCBuZWVkcyBgaW1h" + - "Z2VQdWxsU2VjcmV0c2AgY29uZmlndXJlZCB2aWEgaGVsbWZpbGUgdmFsdWVzLiBTZWUgW3B1bGwt" + - "c2VjcmV0cy5tZF0ocHVsbC1zZWNyZXRzLm1kKS4KCjMuICoqQ2hhcnQgZG9lc24ndCBzdXBwb3J0" + - "IGltYWdlUHVsbFNlY3JldHMqKiAob3BlbmJhbywgaW52b2NhdGlvbi1zZXJ2aWNlLCBlc3MtYXBp" + - "LCBub3Rhcnktc2VydmljZSk6IFBhdGNoIFNlcnZpY2VBY2NvdW50cyBhbmQgcmVzdGFydCBwb2Rz" + - "LiBTZWUgW3B1bGwtc2VjcmV0cy5tZF0ocHVsbC1zZWNyZXRzLm1kKS4KCjQuICoqV3JvbmcgY3Jl" + - "ZGVudGlhbHMgaW4gc2VjcmV0Kio6IERlbGV0ZSBhbmQgcmVjcmVhdGUKICAgYGBgYmFzaAogICBr" + - "dWJlY3RsIGRlbGV0ZSBzZWNyZXQgbnZjci1jcmVkcyAtbiA8bmFtZXNwYWNlPgogICAjIFJlY3Jl" + - "YXRlIHdpdGggY29ycmVjdCBjcmVkZW50aWFscwogICBgYGAKCiMjIEZhaWx1cmU6IEluaXQ6MC8x" + - "IFN0dWNrIChWYXVsdCBBZ2VudCkKCiMjIyBTeW1wdG9tcwoKU2VydmljZSBwb2RzIHN0dWNrIGlu" + - "IGBJbml0OjAvMWAgZm9yIG1pbnV0ZXM6CmBgYApOQU1FICAgICAgICAgICAgICAgICAgICAgICAg" + - "UkVBRFkgICBTVEFUVVMgICAgIFJFU1RBUlRTICAgQUdFCm52Y2YtYXBpLTdmNGM3NmY3ODgtNDR2" + - "bHQgIDAvMiAgICAgSW5pdDowLzEgICAwICAgICAgICAgIDEwbQpgYGAKCiMjIyBEaWFnbm9zaXMK" + - "ClRoZSBpbml0IGNvbnRhaW5lciBpcyB0aGUgdmF1bHQtYWdlbnQtaW5pdCBpbmplY3RvciB3YWl0" + - "aW5nIGZvciBPcGVuQmFvLgoKYGBgYmFzaAojIENoZWNrIE9wZW5CYW8gcG9kcwprdWJlY3RsIGdl" + - "dCBwb2RzIC1uIHZhdWx0LXN5c3RlbQoKIyBDaGVjayBpZiBPcGVuQmFvIG1pZ3JhdGlvbiBqb2Ig" + - "cmFuCmt1YmVjdGwgZ2V0IGpvYnMgLW4gdmF1bHQtc3lzdGVtCgojIENoZWNrIE9wZW5CYW8gcG9k" + - "IGxvZ3MKa3ViZWN0bCBsb2dzIC1uIHZhdWx0LXN5c3RlbSBvcGVuYmFvLXNlcnZlci0wIC1jIG9w" + - "ZW5iYW8KCiMgQ2hlY2sgaW5pdCBjb250YWluZXIgbG9ncyBvbiB0aGUgc3R1Y2sgcG9kCmt1YmVj" + - "dGwgbG9ncyAtbiA8bmFtZXNwYWNlPiA8cG9kLW5hbWU+IC1jIHZhdWx0LWFnZW50LWluaXQKYGBg" + - "CgojIyMgRml4ZXMKCjEuICoqT3BlbkJhbyBwb2RzIG5vdCBydW5uaW5nKio6IENoZWNrIHRoZWly" + - "IGV2ZW50cyBmb3IgaW1hZ2UgcHVsbCBpc3N1ZXMsIHJlc291cmNlIGlzc3VlcywgZXRjLgoKMi4g" + - "KipPcGVuQmFvIG1pZ3JhdGlvbiBqb2IgZGlkbid0IHJ1bioqOiBUaGlzIGhhcHBlbnMgd2hlbiBg" + - "aGVsbWZpbGUgc3luY2Agd2FzIGludGVycnVwdGVkLiBEZXN0cm95IGFuZCByZS1zeW5jIG9wZW5i" + - "YW86CiAgIGBgYGJhc2gKICAgSEVMTUZJTEVfRU5WPTxlbnY+IGhlbG1maWxlIC0tc2VsZWN0b3Ig" + - "bmFtZT1vcGVuYmFvLXNlcnZlciBkZXN0cm95CiAgIGt1YmVjdGwgZGVsZXRlIG5hbWVzcGFjZSB2" + - "YXVsdC1zeXN0ZW0KICAga3ViZWN0bCBjcmVhdGUgbmFtZXNwYWNlIHZhdWx0LXN5c3RlbQogICAj" + - "IFJlLWNyZWF0ZSBwdWxsIHNlY3JldCBpZiBuZWVkZWQKICAgSEVMTUZJTEVfRU5WPTxlbnY+IGhl" + - "bG1maWxlIC0tc2VsZWN0b3IgbmFtZT1vcGVuYmFvLXNlcnZlciBzeW5jCiAgIGBgYAoKMy4gKipP" + - "cGVuQmFvIHBvZHMgcnVubmluZyBidXQgbm90IGluaXRpYWxpemVkKio6IENoZWNrIHVuc2VhbCBz" + - "dGF0dXM6CiAgIGBgYGJhc2gKICAga3ViZWN0bCBleGVjIC1uIHZhdWx0LXN5c3RlbSBvcGVuYmFv" + - "LXNlcnZlci0wIC1jIG9wZW5iYW8gLS0gYmFvIHN0YXR1cwogICBgYGAKCjQuICoqYHZhdWx0LWFn" + - "ZW50LWluaXRgIGxvZ3MgYGF1dGgvand0L2xvZ2luYCAtPiBgNDAwIC4uLiBubyBrbm93biBrZXkg" + - "c3VjY2Vzc2Z1bGx5IHZhbGlkYXRlZCB0aGUgdG9rZW4gc2lnbmF0dXJlYCoqCiAgIChjb21tb24g" + - "b24gQUtTLCBhbmQgb24gYW55IGNsdXN0ZXIgd2hvc2UgT0lEQyBpc3N1ZXIgcHVibGlzaGVzIGEg" + - "cm90YXRpbmcgbXVsdGkta2V5IEpXS1MpOgogICB0aGUgT3BlbkJhbyBgYXV0aC9qd3RgIG1ldGhv" + - "ZCB3YXMgY29uZmlndXJlZCB3aXRoIGEgc2luZ2xlIHN0YXRpYyBtb3VudGVkIHB1YmxpYyBrZXkK" + - "ICAgKGBqd3RfdmFsaWRhdGlvbl9wdWJrZXlzYCkgaW5zdGVhZCBvZiB0aGUgaXNzdWVyJ3MgbGl2" + - "ZSBKV0tTLCBzbyBpdCBjYW5ub3QgdmFsaWRhdGUgdGhlCiAgIGNsdXN0ZXItc2lnbmVkIFNlcnZp" + - "Y2VBY2NvdW50IHRva2VucyB0aGUgdmF1bHQtYWdlbnRzIHByZXNlbnQuIEV2ZXJ5IHNlcnZpY2Un" + - "cwogICBgdmF1bHQtYWdlbnQtaW5pdGAgdGhlbiBsb29wcyBvbiB0aGF0IDQwMCBhbmQgdGhlIHBv" + - "ZCBuZXZlciBsZWF2ZXMgYEluaXQ6MC8xYC4gVGhpcyBpcyB0aGUKICAgYmVoYXZpb3Igb2YgdGhl" + - "IGJhc2UgZGVmYXVsdCBgb3BlbmJhby5taWdyYXRpb25zLmlzc3VlckRpc2NvdmVyeS5lbmFibGVk" + - "OiBmYWxzZWA7IHRoZQogICBtaWdyYXRpb24gbG9nIHNob3dzIGBPSURDIGlzc3VlciBkaXNjb3Zl" + - "cnkgaXMgZGlzYWJsZWQuIFVzaW5nIFNlcnZpY2VBY2NvdW50IGlzc3VlciBhbmQKICAgbW91bnRl" + - "ZCBwdWJsaWMga2V5IGZhbGxiYWNrYC4gRW5hYmxlIGlzc3VlciBkaXNjb3Zlcnkgc28gdGhlIG1p" + - "Z3JhdGlvbiB1c2VzIHRoZSBsaXZlIEpXS1MsCiAgIHRoZW4gcmUtcnVuIGl0OgogICBgYGBiYXNo" + - "CiAgICMgSW4geW91ciBlbnYgdmFsdWVzIChlLmcuIGVudmlyb25tZW50cy88ZW52Pi55YW1sKSwg" + - "c2V0OgogICAjICAgb3BlbmJhbzoKICAgIyAgICAgbWlncmF0aW9uczoKICAgIyAgICAgICBpc3N1" + - "ZXJEaXNjb3Zlcnk6CiAgICMgICAgICAgICBlbmFibGVkOiB0cnVlCiAgIGt1YmVjdGwgZGVsZXRl" + - "IGpvYiAtbiB2YXVsdC1zeXN0ZW0gb3BlbmJhby1zZXJ2ZXItbWlncmF0aW9ucwogICBIRUxNRklM" + - "RV9FTlY9PGVudj4gaGVsbWZpbGUgLS1zZWxlY3RvciBuYW1lPW9wZW5iYW8tc2VydmVyIHN5bmMK" + - "ICAgYGBgCiAgIFRoZSBtaWdyYXRpb24gbG9nIHNob3VsZCB0aGVuIHNob3cgYFJlY2VpdmVkIGRp" + - "c2NvdmVyeSBkb2N1bWVudCBmcm9tCiAgIC4uLi8ud2VsbC1rbm93bi9vcGVuaWQtY29uZmlndXJh" + - "dGlvbmAgYW5kIGBGaW5hbCBPcGVuQmFvIEpXVCBKV0tTIFVSTCBzZXQgdG86CiAgIC4uLi9vcGVu" + - "aWQvdjEvandrc2AsIGFuZCB0aGUgc2VydmljZSBwb2RzIGF1dGhlbnRpY2F0ZSBhbmQgcmVhY2gg" + - "UmVhZHkgd2l0aGluIH4xIG1pbi4KICAgQUtTIGNsdXN0ZXJzIHdpdGggdGhlIGNsdXN0ZXIgT0lE" + - "QyBpc3N1ZXIgZW5hYmxlZCAodGhlIGBha3MtY2x1c3RlcmAgZGVmYXVsdCkgYWx3YXlzIG5lZWQK" + - "ICAgdGhpcyBiZWNhdXNlIHRoZSBzdGF0aWMtcHVia2V5IGZhbGxiYWNrIGNhbm5vdCBtYXRjaCB0" + - "aGUgaXNzdWVyJ3Mgcm90YXRpbmcgc2lnbmluZyBrZXlzLgoKIyMgRmFpbHVyZTogT09NS2lsbGVk" + - "IG9uIENhc3NhbmRyYQoKIyMjIFN5bXB0b21zCgpgYGAKTkFNRSAgICAgICAgICBSRUFEWSAgIFNU" + - "QVRVUyAgICBSRVNUQVJUUyAgIEFHRQpjYXNzYW5kcmEtMCAgIDAvMSAgICAgT09NS2lsbGVkICAz" + - "ICAgICAgICAgMTBtCmBgYAoKIyMjIERpYWdub3NpcwoKYGBgYmFzaAprdWJlY3RsIGRlc2NyaWJl" + - "IHBvZCAtbiBjYXNzYW5kcmEtc3lzdGVtIGNhc3NhbmRyYS0wIHwgZ3JlcCAtQTMgIkxhc3QgU3Rh" + - "dGUiCmBgYAoKIyMjIEZpeAoKT3ZlcnJpZGUgQ2Fzc2FuZHJhIHJlc291cmNlcyB2aWEgaGVsbWZp" + - "bGUgdmFsdWVzLiBTZWUgRXhhbXBsZSAxIGluCltleGFtcGxlcy5tZF0oLi4vZXhhbXBsZXMubWQp" + - "LgoKYGBgeWFtbAotIGNhc3NhbmRyYToKICAgIHJlc291cmNlczoKICAgICAgbGltaXRzOgogICAg" + - "ICAgIGNwdTogIjgiCiAgICAgICAgbWVtb3J5OiA4MTkyTWkKICAgICAgcmVxdWVzdHM6CiAgICAg" + - "ICAgY3B1OiAiMiIKICAgICAgICBtZW1vcnk6IDQwOTZNaQpgYGAKCk5vdGU6IGByZXNvdXJjZVBy" + - "ZXNldGAgaXMgbm90IGF2YWlsYWJsZSBpbiB0aGUgTlZDRiBjYXNzYW5kcmEgd3JhcHBlciBjaGFy" + - "dC4gVXNlIGV4cGxpY2l0IGByZXNvdXJjZXNgLgoKIyMgRmFpbHVyZTogUG9kcyBTdHVjayBpbiBQ" + - "ZW5kaW5nCgojIyMgU3ltcHRvbXMKCmBgYApOQU1FICAgICAgICAgIFJFQURZICAgU1RBVFVTICAg" + - "IFJFU1RBUlRTICAgQUdFCmNhc3NhbmRyYS0wICAgMC8xICAgICBQZW5kaW5nICAgMCAgICAgICAg" + - "ICAxMG0KYGBgCgojIyMgRGlhZ25vc2lzCgpgYGBiYXNoCiMgQ2hlY2sgZXZlbnRzIGZvciBzY2hl" + - "ZHVsaW5nIGZhaWx1cmVzCmt1YmVjdGwgZGVzY3JpYmUgcG9kIC1uIDxuYW1lc3BhY2U+IDxwb2Qt" + - "bmFtZT4KCiMgQ29tbW9uIGNhdXNlczoKIyAtICIwLzEyIG5vZGVzIGFyZSBhdmFpbGFibGU6IDEy" + - "IG5vZGUocykgZGlkbid0IG1hdGNoIFBvZCdzIG5vZGUgYWZmaW5pdHkiCiMgLSAiMC8xMiBub2Rl" + - "cyBhcmUgYXZhaWxhYmxlOiAxMiBJbnN1ZmZpY2llbnQgbWVtb3J5IgojIC0gInBlcnNpc3RlbnR2" + - "b2x1bWVjbGFpbSBub3QgZm91bmQiCmBgYAoKIyMjIEZpeGVzCgoxLiAqKk5vZGUgc2VsZWN0b3Ig" + - "bWlzbWF0Y2gqKjogQ2hlY2sgYG5vZGVTZWxlY3RvcnNgIGluIGVudmlyb25tZW50IGZpbGUKICAg" + - "YGBgYmFzaAogICBrdWJlY3RsIGdldCBub2RlcyAtLXNob3ctbGFiZWxzIHwgZ3JlcCBudmNmCiAg" + - "IGBgYAoKMi4gKipTdG9yYWdlIGNsYXNzIG5vdCBmb3VuZCoqOiBDaGVjayBzdG9yYWdlIGNsYXNz" + - "IGV4aXN0cwogICBgYGBiYXNoCiAgIGt1YmVjdGwgZ2V0IHN0b3JhZ2VjbGFzcwogICBgYGAKCjMu" + - "ICoqSW5zdWZmaWNpZW50IHJlc291cmNlcyoqOiBDaGVjayBub2RlIGNhcGFjaXR5CiAgIGBgYGJh" + - "c2gKICAga3ViZWN0bCBkZXNjcmliZSBub2RlIDxub2RlLW5hbWU+IHwgZ3JlcCAtQTUgIkFsbG9j" + - "YXRlZCByZXNvdXJjZXMiCiAgIGBgYAoKIyMgRmFpbHVyZTogSGVsbSBSZWxlYXNlIGluIEZhaWxl" + - "ZCBTdGF0ZQoKIyMjIFN5bXB0b21zCgpgYGBiYXNoCmhlbG0gbGlzdCAtQQojIFNob3dzIHJlbGVh" + - "c2Ugd2l0aCBTVEFUVVM6IGZhaWxlZApgYGAKClJlLXJ1bm5pbmcgYGhlbG1maWxlIHN5bmNgIGFw" + - "cGVhcnMgdG8gc3VjY2VlZCBidXQgc2VydmljZXMgZG9uJ3Qgd29yayAobWlncmF0aW9ucyBza2lw" + - "cGVkKS4KCiMjIyBEaWFnbm9zaXMKCmBgYGJhc2gKaGVsbSBoaXN0b3J5IDxyZWxlYXNlLW5hbWU+" + - "IC1uIDxuYW1lc3BhY2U+CmBgYAoKIyMjIEZpeAoKTXVzdCBkZXN0cm95IHRoZSBmYWlsZWQgcmVs" + - "ZWFzZSBhbmQgcmUtc3luYyAobm90IGp1c3QgYXBwbHkpOgoKYGBgYmFzaApIRUxNRklMRV9FTlY9" + - "PGVudj4gaGVsbWZpbGUgLS1zZWxlY3RvciBuYW1lPTxyZWxlYXNlPiBkZXN0cm95CiMgSWYgbmFt" + - "ZXNwYWNlIG5lZWRzIGNsZWFudXA6Cmt1YmVjdGwgZGVsZXRlIG5hbWVzcGFjZSA8bmFtZXNwYWNl" + - "PgprdWJlY3RsIGNyZWF0ZSBuYW1lc3BhY2UgPG5hbWVzcGFjZT4KIyBSZS1jcmVhdGUgcHVsbCBz" + - "ZWNyZXQgaWYgbmVlZGVkCkhFTE1GSUxFX0VOVj08ZW52PiBoZWxtZmlsZSAtLXNlbGVjdG9yIG5h" + - "bWU9PHJlbGVhc2U+IHN5bmMKYGBgCgojIyBGYWlsdXJlOiBBY2NvdW50IEJvb3RzdHJhcCBKb2Ig" + - "RmFpbGVkCgojIyMgU3ltcHRvbXMKClNlcnZpY2VzIGRlcGxveSBidXQgZnVuY3Rpb25zIGNhbid0" + - "IGJlIGNyZWF0ZWQuIEV2ZW50cyBzaG93IGJvb3RzdHJhcCBqb2IgZmFpbHVyZS4KCiMjIyBEaWFn" + - "bm9zaXMKCmBgYGJhc2gKIyBDaGVjayBib290c3RyYXAgam9iIHN0YXR1cwprdWJlY3RsIGdldCBq" + - "b2JzIC1uIG52Y2YKCiMgR2V0IGxvZ3MgKGpvYiBhdXRvLWRlbGV0ZXMgYWZ0ZXIgfjUgbWludXRl" + - "cykKa3ViZWN0bCBsb2dzIGpvYi9udmNmLWFwaS1hY2NvdW50LWJvb3RzdHJhcCAtbiBudmNmCgoj" + - "IENoZWNrIEFQSSBsb2dzCmt1YmVjdGwgbG9ncyAtbiBudmNmIC1sIGFwcC5rdWJlcm5ldGVzLmlv" + - "L25hbWU9bnZjZi1hcGkgLS10YWlsPTEwMApgYGAKCiMjIyBDb21tb24gQ2F1c2VzCgoxLiAqKldy" + - "b25nIGJhc2U2NCBjcmVkZW50aWFscyoqOiBDcmVkZW50aWFscyBpbiBgc2VjcmV0cy88ZW52Pi1z" + - "ZWNyZXRzLnlhbWxgIG11c3QgYmUgYCRvYXV0aHRva2VuOkFQSV9LRVlgIGJhc2U2NC1lbmNvZGVk" + - "LCBub3QganVzdCB0aGUgQVBJIGtleQogICBgYGBiYXNoCiAgICMgVmVyaWZ5IHlvdXIgZW5jb2Rl" + - "ZCBjcmVkZW50aWFsCiAgIGVjaG8gJ1lPVVJfQkFTRTY0X1NUUklORycgfCBiYXNlNjQgLWQKICAg" + - "IyBTaG91bGQgb3V0cHV0OiAkb2F1dGh0b2tlbjpudmFwaS14eHh4eAogICBgYGAKCjIuICoqUmVn" + - "aXN0cnkgdW5yZWFjaGFibGUqKjogQVBJIGNhbid0IHJlYWNoIHRoZSByZWdpc3RyeSBzcGVjaWZp" + - "ZWQgaW4gYGFjY291bnRCb290c3RyYXAucmVnaXN0cnlDcmVkZW50aWFsc2AKCiMjIyBGaXgKCkZp" + - "eCBjcmVkZW50aWFscyBpbiBzZWNyZXRzIGZpbGUsIHRoZW4gcmVjb3ZlciBzZXJ2aWNlcyB3aXRo" + - "b3V0IGRlc3Ryb3lpbmcgZGVwZW5kZW5jaWVzOgoKYGBgYmFzaApIRUxNRklMRV9FTlY9PGVudj4g" + - "aGVsbWZpbGUgLS1zZWxlY3RvciByZWxlYXNlLWdyb3VwPXNlcnZpY2VzIGRlc3Ryb3kKa3ViZWN0" + - "bCBkZWxldGUgbmFtZXNwYWNlIG52Y2YgYXBpLWtleXMgZXNzIHNpcyAtLWlnbm9yZS1ub3QtZm91" + - "bmQKa3ViZWN0bCBjcmVhdGUgbmFtZXNwYWNlIG52Y2YgJiYga3ViZWN0bCBjcmVhdGUgbmFtZXNw" + - "YWNlIGFwaS1rZXlzICYmIFwKICBrdWJlY3RsIGNyZWF0ZSBuYW1lc3BhY2UgZXNzICYmIGt1YmVj" + - "dGwgY3JlYXRlIG5hbWVzcGFjZSBzaXMKIyBSZS1jcmVhdGUgcHVsbCBzZWNyZXRzIGlmIG5lZWRl" + - "ZApIRUxNRklMRV9FTlY9PGVudj4gaGVsbWZpbGUgLS1zZWxlY3RvciByZWxlYXNlLWdyb3VwPXNl" + - "cnZpY2VzIHN5bmMKYGBgCgojIyBGYWlsdXJlOiBOVkNBIENsZWFudXAgU3R1Y2sgKEZpbmFsaXpl" + - "cnMpCgojIyMgU3ltcHRvbXMKCkNvbXB1dGUtcGxhbmUgY2xlYW51cCBoYW5ncy4gTmFtZXNwYWNl" + - "cwpzdHVjayBpbiBgVGVybWluYXRpbmdgOgoKYGBgYmFzaAprdWJlY3RsIGdldCBucwojIG52Y2Et" + - "b3BlcmF0b3IgICAgVGVybWluYXRpbmcgICAxMG0KIyBudmNmLWJhY2tlbmQgICAgIFRlcm1pbmF0" + - "aW5nICAgMTBtCmBgYAoKIyMjIEZpeAoKUnVuIHRoaXMgb25seSBhZ2FpbnN0IHRoZSBjb21wdXRl" + - "IGNvbnRleHQsIGFmdGVyIHRoZSBub3JtYWwgY29tcHV0ZS1wbGFuZQp0ZWFyZG93biBoYXMgZmFp" + - "bGVkLiBSZW1vdmUgZmluYWxpemVycyBmcm9tIE5WQ0ZCYWNrZW5kIGN1c3RvbSByZXNvdXJjZXMg" + - "YW5kCmZvcmNlLWRlbGV0ZSBzdHVjayBuYW1lc3BhY2VzOgoKYGBgYmFzaApleHBvcnQgQ09NUFVU" + - "RV9DT05URVhUPTxjb21wdXRlLXBsYW5lLWNvbnRleHQ+CgojIFJlbW92ZSBmaW5hbGl6ZXJzIGZy" + - "b20gTlZDRkJhY2tlbmQgcmVzb3VyY2VzCmt1YmVjdGwgLS1jb250ZXh0ICIkQ09NUFVURV9DT05U" + - "RVhUIiBnZXQgbnZjZmJhY2tlbmRzIC1BIC1vIGpzb24gfCBcCiAganEgJy5pdGVtc1tdIHwgLm1l" + - "dGFkYXRhLm5hbWVzcGFjZSArICIvIiArIC5tZXRhZGF0YS5uYW1lJyAtciB8IFwKICB4YXJncyAt" + - "SXt9IHNoIC1jICdjb250ZXh0PSIkMSI7IG5zPSIkezIlJS8qfSI7IG5hbWU9IiR7MiMjKi99Ijsg" + - "a3ViZWN0bCAtLWNvbnRleHQgIiRjb250ZXh0IiBwYXRjaCBudmNmYmFja2VuZCAiJG5hbWUiIC1u" + - "ICIkbnMiIC0tdHlwZT1tZXJnZSAtcCAie1wibWV0YWRhdGFcIjp7XCJmaW5hbGl6ZXJzXCI6W119" + - "fSInIF8gIiRDT01QVVRFX0NPTlRFWFQiIHt9CgojIEZvcmNlLWRlbGV0ZSBzdHVjayBuYW1lc3Bh" + - "Y2VzIGJ5IGNsZWFyaW5nIHRoZWlyIGZpbmFsaXplcnMKZm9yIG5zIGluIG52Y2Etb3BlcmF0b3Ig" + - "bnZjZi1iYWNrZW5kOyBkbwogIGt1YmVjdGwgLS1jb250ZXh0ICIkQ09NUFVURV9DT05URVhUIiBn" + - "ZXQgbmFtZXNwYWNlICIkbnMiIC1vIGpzb24gMj4vZGV2L251bGwgfCBcCiAgICBqcSAnLnNwZWMu" + - "ZmluYWxpemVycyA9IFtdJyB8IFwKICAgIGt1YmVjdGwgLS1jb250ZXh0ICIkQ09NUFVURV9DT05U" + - "RVhUIiByZXBsYWNlIFwKICAgICAgLS1yYXcgIi9hcGkvdjEvbmFtZXNwYWNlcy8kbnMvZmluYWxp" + - "emUiIC1mIC0gMj4vZGV2L251bGwKZG9uZQpgYGAKCiMjIEZhaWx1cmU6IE5WQ0EgT3BlcmF0b3Ig" + - "TWlzc2luZyBvciBOb3QgUmVhZHkKCiMjIyBTeW1wdG9tcwoKQWZ0ZXIgY29tcHV0ZS1wbGFuZSBp" + - "bnN0YWxsIGNvbXBsZXRlcywgbm8gYG52Y2Etb3BlcmF0b3JgIERlcGxveW1lbnQgZXhpc3RzLCBv" + - "cgppdCBleGlzdHMgYnV0IHBvZHMgYXJlIG5vdCByZWFkeToKCmBgYGJhc2gKa3ViZWN0bCAtLWNv" + - "bnRleHQgPGNvbXB1dGUtcGxhbmUtY29udGV4dD4gZ2V0IGRlcGxveW1lbnQgbnZjYS1vcGVyYXRv" + - "ciBcCiAgLW4gbnZjYS1vcGVyYXRvcgprdWJlY3RsIC0tY29udGV4dCA8Y29tcHV0ZS1wbGFuZS1j" + - "b250ZXh0PiBnZXQgcG9kcyAtbiBudmNhLW9wZXJhdG9yCmBgYAoKIyMjIERpYWdub3NpcyBhbmQg" + - "Rml4ZXMKCkZpcnN0IGlkZW50aWZ5IHdoZXRoZXIgdGhlIGluc3RhbGxhdGlvbiB1c2VkIHRoZSBI" + - "ZWxtZmlsZSB2YWx1ZXMgZmxvdyBvciB0aGUKQ0xJIHByb2ZpbGUgZmxvdy4gUmUtcnVuIG9ubHkg" + - "dGhhdCBmbG93J3MgcmVnaXN0cmF0aW9uIGFuZCBpbnN0YWxsYXRpb24gc3RlcHMKZnJvbSBbU3Bs" + - "aXQgQ29tcHV0ZS1QbGFuZSBJbnN0YWxsYXRpb25dKGNvbXB1dGUtcGxhbmUtaW5zdGFsbGF0aW9u" + - "Lm1kKS4gRG8gbm90CnN1YnN0aXR1dGUgb25lIGhhbmRvZmYgZm9yIHRoZSBvdGhlci4KCklmIGlu" + - "c3RhbGxhdGlvbiBzdWNjZWVkcyBidXQgcG9kcyBzdGlsbCBmYWlsLCBpbnNwZWN0IHRoZSBjb21w" + - "dXRlIGNvbnRleHQ6CgpgYGBiYXNoCmt1YmVjdGwgLS1jb250ZXh0IDxjb21wdXRlLXBsYW5lLWNv" + - "bnRleHQ+IGRlc2NyaWJlIGRlcGxveSBudmNhLW9wZXJhdG9yIFwKICAtbiBudmNhLW9wZXJhdG9y" + - "Cmt1YmVjdGwgLS1jb250ZXh0IDxjb21wdXRlLXBsYW5lLWNvbnRleHQ+IGxvZ3MgZGVwbG95bWVu" + - "dC9udmNhLW9wZXJhdG9yIFwKICAtbiBudmNhLW9wZXJhdG9yIC0tdGFpbD0yMDAKa3ViZWN0bCAt" + - "LWNvbnRleHQgPGNvbXB1dGUtcGxhbmUtY29udGV4dD4gZ2V0IG52Y2ZiYWNrZW5kIC1uIG52Y2Et" + - "b3BlcmF0b3IKYGBgCgpGb3IgcHJpdmF0ZSByZWdpc3RyeSBmYWlsdXJlcywgdmVyaWZ5IHRoYXQg" + - "dGhlIHB1bGwgc2VjcmV0IGV4aXN0cyBpbgpgbnZjYS1vcGVyYXRvcmAuIFRoZSBjaGFydCBhbmQg" + - "b3BlcmF0b3IgbWlycm9yIGl0IHRvIGBudmNhLXN5c3RlbWA7IGRvIG5vdCB1c2UgYQpicm9hZGVy" + - "IG1hbnVhbCBuYW1lc3BhY2UgbG9vcC4gU2VlCltwdWxsLXNlY3JldHMubWRdKHB1bGwtc2VjcmV0" + - "cy5tZCNjb21wdXRlLXBsYW5lLXNlY3JldCkuCgojIyBGYWlsdXJlOiBHYXRld2F5IEVuZHBvaW50" + - "IENoYW5nZWQKCiMjIyBTeW1wdG9tcwoKUmVxdWVzdHMgdGhyb3VnaCB0aGUgY29uZmlndXJlZCBy" + - "b3V0ZSBkb21haW4gZmFpbCBhZnRlciB0aGUgR2F0ZXdheSBvciBpdHMgbG9hZCBiYWxhbmNlciBp" + - "cyByZXBsYWNlZC4gVGhlIEdhdGV3YXkgcmVwb3J0cyBhIG5ldyBlbmRwb2ludC4KCiMjIyBEaWFn" + - "bm9zaXMKCmBgYGJhc2gKR0FURVdBWV9BRERSPSQoa3ViZWN0bCAtLWNvbnRleHQgPGNvbnRyb2wt" + - "cGxhbmUtY29udGV4dD4gZ2V0IGdhdGV3YXkgXAogIG52Y2YtZ2F0ZXdheSAtbiBlbnZveS1nYXRl" + - "d2F5IFwKICAtbyBqc29ucGF0aD0ney5zdGF0dXMuYWRkcmVzc2VzWzBdLnZhbHVlfScpCnRlc3Qg" + - "LW4gIiRHQVRFV0FZX0FERFIiCmRpZyArc2hvcnQgImFwaS48ZG9tYWluPiIKY3VybCAtSCAiSG9z" + - "dDogYXBpLjxkb21haW4+IiAiaHR0cDovLyRHQVRFV0FZX0FERFIvaGVhbHRoIgoKIyBDaGVjayBk" + - "aXJlY3QgYWRkcmVzcyBmaWVsZHMgdXNlZCBieSBhIHNwbGl0IGRlcGxveW1lbnQKZ3JlcCBudmNm" + - "TmF0c1NlcnZpY2VVUkwgZGVwbG95L3N0YWNrcy9zZWxmLW1hbmFnZWQvZW52aXJvbm1lbnRzLzxl" + - "bnY+LnlhbWwKZ3JlcCAtRSAnaWNtc1NlcnZpY2V8cmV2YWxTZXJ2aWNlfG5hdHMnIFwKICBkZXBs" + - "b3kvc3RhY2tzL252Y2YtY29tcHV0ZS1wbGFuZS9lbnZpcm9ubWVudHMvPGVudj4ueWFtbApgYGAK" + - "CiMjIyBGaXgKCktlZXAgYGdsb2JhbC5kb21haW5gLCByb3V0ZSBob3N0bmFtZXMsIGFuZCBIb3N0" + - "IG92ZXJyaWRlcyB1bmNoYW5nZWQuIFVwZGF0ZSBETlMKb3IgdGhlIGRpcmVjdCBjbGllbnQgZGVz" + - "dGluYXRpb24uIEZvciBzcGxpdCBkZXBsb3ltZW50cywgdXBkYXRlIG9ubHkgZGlyZWN0CkdhdGV3" + - "YXktYWRkcmVzcyBmaWVsZHMgYW5kIHJlZnJlc2ggcmVnaXN0cmF0aW9uIGFuZCBpbnN0YWxsYXRp" + - "b24gdGhyb3VnaCB0aGUKc2FtZSBzZWxlY3RlZCBoYW5kb2ZmLiBTZWUKW0V4YW1wbGUgNF0oLi4v" + - "ZXhhbXBsZXMubWQjZXhhbXBsZS00LXJlY292ZXItZnJvbS1hLWdhdGV3YXktZW5kcG9pbnQtY2hh" + - "bmdlKS4KCiMjIFVzZWZ1bCBOYW1lc3BhY2UtdG8tU2VydmljZSBNYXBwaW5nCgpRdWljayByZWZl" + - "cmVuY2UgZm9yIHdoaWNoIHNlcnZpY2VzIHJ1biBpbiB3aGljaCBuYW1lc3BhY2U6Cgp8IE5hbWVz" + - "cGFjZSB8IFNlcnZpY2VzIHwKfC0tLS0tLS0tLS0tfC0tLS0tLS0tLS18CnwgbmF0cy1zeXN0ZW0g" + - "fCBuYXRzIHwKfCBjYXNzYW5kcmEtc3lzdGVtIHwgY2Fzc2FuZHJhIHwKfCB2YXVsdC1zeXN0ZW0g" + - "fCBvcGVuYmFvLXNlcnZlciB8CnwgbnZjZiB8IGFwaSwgaW52b2NhdGlvbi1zZXJ2aWNlLCBncnBj" + - "LXByb3h5LCBub3Rhcnktc2VydmljZSwgcmV2YWwsIGxsbS1yZXF1ZXN0LXJvdXRlciwgbGxtLWFw" + - "aS1nYXRld2F5IHwKfCBhcGkta2V5cyB8IGFwaS1rZXlzLCBhZG1pbi1pc3N1ZXItcHJveHkgfAp8" + - "IGVzcyB8IGVzcy1hcGkgfAp8IHNpcyB8IHNpcyB8CnwgZW52b3ktZ2F0ZXdheS1zeXN0ZW0gfCBl" + - "bnZveSBnYXRld2F5IChpbmdyZXNzIGNvbnRyb2xsZXIpIHwKfCBlbnZveS1nYXRld2F5IHwgZ2F0" + - "ZXdheSByZXNvdXJjZSArIHJvdXRlcyB8ClBLBwhWPmeQlTAAAJUwAABQSwMEFAAIAAAAAAAhAAAA" + - "AAAAAAAAAAAAAEQACQBkYXRhL252Y2Ytc2VsZi1tYW5hZ2VkLWluc3RhbGxhdGlvbi9yZWZlcmVu" + - "Y2VzL2hlbG1maWxlLXN0cnVjdHVyZS5tZFVUBQABAKbOEiMgSGVsbWZpbGUgU3RydWN0dXJlIFJl" + - "ZmVyZW5jZQoKIyMgRGlyZWN0b3J5IExheW91dAoKYGBgCm52Y2Ytc2VsZi1tYW5hZ2VkLXN0YWNr" + - "Lwp8LS0gaGVsbWZpbGUuZC8KfCAgIHwtLSAwMS1kZXBlbmRlbmNpZXMueWFtbC5nb3RtcGwgICMg" + - "TkFUUywgQ2Fzc2FuZHJhLCBPcGVuQmFvCnwgICB8LS0gMDItY29yZS55YW1sLmdvdG1wbCAgICAg" + - "ICAgICAjIE5WQ0Ygc2VydmljZXMgKyBpbmdyZXNzCnwgICBgLS0gMDMtb2JzZXJ2YWJpbGl0eS55" + - "YW1sLmdvdG1wbCAjIE9ic2VydmFiaWxpdHkgc3RhY2sgKG9wdGlvbmFsKQp8LS0gZW52aXJvbm1l" + - "bnRzLwp8ICAgfC0tIGJhc2UueWFtbCAgICAgICAgICAgICAgICAgICAgIyBEZWZhdWx0IHZhbHVl" + - "cyAoYWxsIGVudmlyb25tZW50cykKfCAgIGAtLSA8ZW52LW5hbWU+LnlhbWwgICAgICAgICAgICAg" + - "ICMgUGVyLWVudmlyb25tZW50IG92ZXJyaWRlcwp8LS0gc2VjcmV0cy8KfCAgIGAtLSA8ZW52LW5h" + - "bWU+LXNlY3JldHMueWFtbCAgICAgICMgU2Vuc2l0aXZlIHZhbHVlcyAocmVnaXN0cnkgY3JlZHMs" + - "IHBhc3N3b3JkcykKYC0tIGdsb2JhbC55YW1sLmdvdG1wbCAgICAgICAgICAgICAgICMgR28gdGVt" + - "cGxhdGUgdGhhdCBjb25zdHJ1Y3RzIHBlci1jaGFydCB2YWx1ZXMKCm52Y2YtY29tcHV0ZS1wbGFu" + - "ZS1zdGFjay8KfC0tIGhlbG1maWxlLmQvCnwgICB8LS0gMDEtZGVwZW5kZW5jaWVzLnlhbWwuZ290" + - "bXBsICAjIENvbXB1dGUgcGxhbmUgZGVwZW5kZW5jeSBjb21wb25lbnRzCnwgICBgLS0gMDItbnZj" + - "YS55YW1sLmdvdG1wbCAgICAgICAgICAjIG52Y2Etb3BlcmF0b3IgY2hhcnQgYW5kIG52Y2EgY29u" + - "ZmlndXJhdGlvbgp8LS0gZW52aXJvbm1lbnRzLwp8ICAgfC0tIGJhc2UueWFtbCAgICAgICAgICAg" + - "ICAgICAgICAgIyBEZWZhdWx0IHZhbHVlcyAoYWxsIGVudmlyb25tZW50cykKfCAgIGAtLSA8ZW52" + - "LW5hbWU+LnlhbWwgICAgICAgICAgICAgICMgUGVyLWVudmlyb25tZW50IG92ZXJyaWRlcwpgLS0g" + - "Z2xvYmFsLnlhbWwuZ290bXBsICAgICAgICAgICAgICAgIyBHbyB0ZW1wbGF0ZSB0aGF0IGNvbnN0" + - "cnVjdHMgcGVyLWNoYXJ0IHZhbHVlcwpgYGAKClRoZXNlIHN0YWNrcyBoYXZlIHNlcGFyYXRlIGVu" + - "dmlyb25tZW50cyBhbmQgY2x1c3RlciBjb250ZXh0cy4gVGhlIEhlbG1maWxlCnZhbHVlcyBmbG93" + - "IGF1dGhvcnMgYm90aCBlbnZpcm9ubWVudCBmaWxlcy4gVGhlIENMSSBwcm9maWxlIGZsb3cgaW5z" + - "dGVhZCB1c2VzCnRoZSBDTEktZ2VuZXJhdGVkIGNvbnRyb2wtcGxhbmUgcHJvZmlsZSBhcyBpdHMg" + - "ZW5kcG9pbnQgc291cmNlLiBEbyBub3QgbWl4IHRoZQpoYW5kb2Zmcy4gU2VlIFtTcGxpdCBDb21w" + - "dXRlLVBsYW5lIEluc3RhbGxhdGlvbl0oY29tcHV0ZS1wbGFuZS1pbnN0YWxsYXRpb24ubWQpLgoK" + - "IyMgR290bXBsIEZpbGVzIGFuZCBUaGVpciBSZWxlYXNlcwoKIyMjIDAxLWRlcGVuZGVuY2llcy55" + - "YW1sLmdvdG1wbAoKfCBSZWxlYXNlIHwgQ2hhcnQgfCBOYW1lc3BhY2UgfCBOb3RlcyB8CnwtLS0t" + - "LS0tLS18LS0tLS0tLXwtLS0tLS0tLS0tLXwtLS0tLS0tfAp8IG5hdHMgfCBoZWxtLW52Y2YtbmF0" + - "cyB8IG5hdHMtc3lzdGVtIHwgTWVzc2FnaW5nIHwKfCBvcGVuYmFvLXNlcnZlciB8IGhlbG0tbnZj" + - "Zi1vcGVuYmFvLXNlcnZlciB8IHZhdWx0LXN5c3RlbSB8IFNlY3JldHMgbWFuYWdlbWVudCwgZGVw" + - "ZW5kcyBvbiBuYXRzIHwKfCBjYXNzYW5kcmEgfCBoZWxtLW52Y2YtY2Fzc2FuZHJhIHwgY2Fzc2Fu" + - "ZHJhLXN5c3RlbSB8IERhdGFiYXNlIHwKClVzZXMgYDw8OiAqZGVwZW5kZW5jeWAgdGVtcGxhdGUg" + - "aW5oZXJpdGFuY2Ugd2l0aCBgcmVsZWFzZS1ncm91cDogZGVwZW5kZW5jaWVzYCBsYWJlbC4KCiMj" + - "IyAwMi1jb3JlLnlhbWwuZ290bXBsCgp8IFJlbGVhc2UgfCBDaGFydCB8IE5hbWVzcGFjZSB8IExh" + - "YmVsIHwKfC0tLS0tLS0tLXwtLS0tLS0tfC0tLS0tLS0tLS0tfC0tLS0tLS18CnwgYXBpLWtleXMg" + - "fCBoZWxtLW52Y2YtYXBpLWtleXMgfCBhcGkta2V5cyB8IHNlcnZpY2VzIHwKfCBzaXMgfCBoZWxt" + - "LW52Y2Ytc2lzIHwgc2lzIHwgc2VydmljZXMgfAp8IGFwaSB8IGhlbG0tbnZjZi1hcGkgfCBudmNm" + - "IHwgc2VydmljZXMgfAp8IGludm9jYXRpb24tc2VydmljZSB8IGhlbG0tbnZjZi1pbnZvY2F0aW9u" + - "LXNlcnZpY2UgfCBudmNmIHwgc2VydmljZXMgfAp8IGdycGMtcHJveHkgfCBoZWxtLW52Y2YtZ3Jw" + - "Yy1wcm94eSB8IG52Y2YgfCBzZXJ2aWNlcyB8CnwgZXNzLWFwaSB8IGhlbG0tbnZjZi1lc3MtYXBp" + - "IHwgZXNzIHwgc2VydmljZXMgfAp8IG5vdGFyeS1zZXJ2aWNlIHwgaGVsbS1udmNmLW5vdGFyeS1z" + - "ZXJ2aWNlIHwgbnZjZiB8IHNlcnZpY2VzIHwKfCByZXZhbCB8IGhlbG0tcmV2YWwgfCBudmNmIHwg" + - "c2VydmljZXMgfAp8IGxsbS1yZXF1ZXN0LXJvdXRlciB8IG52Y2YvaGVsbS1udmNmLWxsbS1yZXF1" + - "ZXN0LXJvdXRlciB8IG52Y2YgfCBzZXJ2aWNlcyB8CnwgbGxtLWFwaS1nYXRld2F5IHwgbnZjZi9o" + - "ZWxtLW52Y2YtbGxtLWFwaS1nYXRld2F5IHwgbnZjZiB8IHNlcnZpY2VzIHwKfCBhZG1pbi1pc3N1" + - "ZXItcHJveHkgfCBoZWxtLWFkbWluLXRva2VuLWlzc3Vlci1wcm94eSB8IGFwaS1rZXlzIHwgKG5v" + - "IHJlbGVhc2UtZ3JvdXAgbGFiZWwpIHwKfCBpbmdyZXNzIHwgbnZjZi1nYXRld2F5LXJvdXRlcyB8" + - "IGVudm95LWdhdGV3YXktc3lzdGVtIHwgaW5ncmVzcyB8CgpNb3N0IHNlcnZpY2VzIHVzZSBgaW5o" + - "ZXJpdDogW3t0ZW1wbGF0ZTogc2VydmljZX1dYC4gTExNIHJlbGVhc2VzIHVzZSBPQ0kgY2hhcnRz" + - "IGZyb20gdGhlIGBudmNmYCByZXBvc2l0b3J5IHdpdGggc3RhbmRhbG9uZSBgdmFsdWVzOiBbLi4v" + - "Z2xvYmFsLnlhbWwuZ290bXBsXWAgYmxvY2tzOyB0aGV5IGFyZSBnYXRlZCBvbiBgYWRkb25zLmxs" + - "bS5lbmFibGVkYC4gYGFkbWluLWlzc3Vlci1wcm94eWAgYW5kIGBpbmdyZXNzYCBoYXZlIHN0YW5k" + - "YWxvbmUgYHZhbHVlczpgIGJsb2Nrcy4KCiMjIyAwMy1vYnNlcnZhYmlsaXR5LnlhbWwuZ290bXBs" + - "Cgp8IFJlbGVhc2UgfCBDaGFydCB8IE5hbWVzcGFjZSB8IExhYmVsIHwKfC0tLS0tLS0tLXwtLS0t" + - "LS0tfC0tLS0tLS0tLS0tfC0tLS0tLS18CnwgKG9ic2VydmFiaWxpdHkgcmVsZWFzZXMpIHwgKHZh" + - "cmlvdXMpIHwgb2JzZXJ2YWJpbGl0eSB8IG9ic2VydmFiaWxpdHkgfAoKR2F0ZWQgb24gb2JzZXJ2" + - "YWJpbGl0eS1zcGVjaWZpYyBmbGFncyBpbiB0aGUgZW52aXJvbm1lbnQgZmlsZS4gU2tpcHBlZCBp" + - "ZiBkaXNhYmxlZC4KCiMjIFRlbXBsYXRlIEluaGVyaXRhbmNlCgojIyMgYDw8OiAqZGVwZW5kZW5j" + - "eWAgKFlBTUwgbWVyZ2UpCgpVc2VkIGluIGAwMS1kZXBlbmRlbmNpZXMueWFtbC5nb3RtcGxgLiBN" + - "ZXJnZXMgdGhlIHRlbXBsYXRlJ3MgcHJvcGVydGllcyBpbnRvIHRoZSByZWxlYXNlLgoKKipHb3Rj" + - "aGEqKjogWUFNTCBtZXJnZSByZXBsYWNlcyBsaXN0cy4gSWYgeW91IGFkZCBhIGB2YWx1ZXM6YCBr" + - "ZXkgdG8gdGhlIHJlbGVhc2UsIGl0ICoqcmVwbGFjZXMqKiB0aGUgdGVtcGxhdGUncyBgdmFsdWVz" + - "OmAgbGlzdCBlbnRpcmVseS4gWW91IG11c3QgcmUtaW5jbHVkZSBhbGwgdGVtcGxhdGUgdmFsdWVz" + - "OgoKSW4gdGhlIHRlbXBsYXRlIGJlbG93LCBgPHByaXZhdGUtdmFsdWVzPmAgcmVmZXJzIHRvIHRo" + - "ZSBgc2VjcmV0cy9gIGRpcmVjdG9yeSBhdCB0aGUgaGVsbWZpbGUgc3RhY2sgcm9vdC4KCmBgYHlh" + - "bWwKIyBUZW1wbGF0ZSBkZWZpbmVzOgp0ZW1wbGF0ZXM6CiAgZGVwZW5kZW5jeTogJmRlcGVuZGVu" + - "Y3kKICAgIGNoYXJ0OiBudmNmL2hlbG0tbnZjZi17eyAuUmVsZWFzZS5OYW1lIH19CiAgICB2YWx1" + - "ZXM6CiAgICAgIC0gLi4vZ2xvYmFsLnlhbWwuZ290bXBsCiAgICAgIC0gLi4vPHByaXZhdGUtdmFs" + - "dWVzPi97eyByZXF1aXJlZEVudiAiSEVMTUZJTEVfRU5WIiB9fS1zZWNyZXRzLnlhbWwKCiMgV2hl" + - "biBvdmVycmlkaW5nLCBNVVNUIHJlLWluY2x1ZGUgYm90aDoKLSBuYW1lOiBjYXNzYW5kcmEKICA8" + - "PDogKmRlcGVuZGVuY3kKICB2YWx1ZXM6CiAgICAtIC4uL2dsb2JhbC55YW1sLmdvdG1wbCAgICAg" + - "ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAjIE11c3QgcmUtaW5jbHVk" + - "ZQogICAgLSAuLi88cHJpdmF0ZS12YWx1ZXM+L3t7IHJlcXVpcmVkRW52ICJIRUxNRklMRV9FTlYi" + - "IH19LXNlY3JldHMueWFtbCAgICMgTXVzdCByZS1pbmNsdWRlCiAgICAtIGNhc3NhbmRyYTogICAg" + - "ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIyBZ" + - "b3VyIG92ZXJyaWRlCiAgICAgICAgcmVzb3VyY2VzOgogICAgICAgICAgbGltaXRzOgogICAgICAg" + - "ICAgICBtZW1vcnk6IDgxOTJNaQpgYGAKCiMjIyBgaW5oZXJpdGAgKEhlbG1maWxlIG5hdGl2ZSkK" + - "ClVzZWQgaW4gYDAyLWNvcmUueWFtbC5nb3RtcGxgLiBIZWxtZmlsZSdzIG5hdGl2ZSBpbmhlcml0" + - "YW5jZSBtZWNoYW5pc20uCgpgYGB5YW1sCi0gbmFtZTogYXBpCiAgdmVyc2lvbjogMS42LjAKICBu" + - "YW1lc3BhY2U6IG52Y2YKICBpbmhlcml0OgogICAgLSB0ZW1wbGF0ZTogc2VydmljZQpgYGAKCldo" + - "ZW4gYWRkaW5nIGB2YWx1ZXM6YCB0byBhbiBpbmhlcml0ZWQgcmVsZWFzZSwgeW91IGFsc28gbmVl" + - "ZCB0byByZS1pbmNsdWRlIHRoZSB0ZW1wbGF0ZSdzIHZhbHVlcyBmaWxlcyBzaW5jZSBgdmFsdWVz" + - "YCBpcyBhIGxpc3QgdGhhdCBnZXRzIHJlcGxhY2VkLgoKIyMgVmFsdWVzIFByZWNlZGVuY2UKCkZy" + - "b20gbG93ZXN0IHRvIGhpZ2hlc3QgcHJpb3JpdHk6CgoxLiBgZW52aXJvbm1lbnRzL2Jhc2UueWFt" + - "bGAgLS0gZGVmYXVsdHMgc2hhcmVkIGFjcm9zcyBhbGwgZW52aXJvbm1lbnRzCjIuIGBlbnZpcm9u" + - "bWVudHMvPGVudj4ueWFtbGAgLS0gcGVyLWVudmlyb25tZW50IG92ZXJyaWRlcwozLiBgZ2xvYmFs" + - "LnlhbWwuZ290bXBsYCAtLSBHbyB0ZW1wbGF0ZSBwcm9jZXNzaW5nIChjb25zdHJ1Y3RzIGNoYXJ0" + - "LXNwZWNpZmljIHN0cnVjdHVyZSkKNC4gYDxwcml2YXRlLXZhbHVlcz4vPGVudj4tc2VjcmV0cy55" + - "YW1sYCAtLSBzZW5zaXRpdmUgdmFsdWVzCjUuIElubGluZSBgdmFsdWVzOmAgYmxvY2tzIG9uIHJl" + - "bGVhc2VzIC0tIGhpZ2hlc3QgcHJlY2VkZW5jZQoKIyMgV2hhdCBnbG9iYWwueWFtbC5nb3RtcGwg" + - "UGFzc2VzIFRocm91Z2gKCmBnbG9iYWwueWFtbC5nb3RtcGxgIHJlYWRzIGZyb20gYC5WYWx1ZXNg" + - "ICh0aGUgbWVyZ2VkIGVudmlyb25tZW50ICsgZW52LXNwZWNpZmljIFlBTUwpIGFuZCBjb25zdHJ1" + - "Y3RzIGNoYXJ0LXNwZWNpZmljIHZhbHVlcy4gSXQgb25seSBwYXNzZXMgdGhyb3VnaCBrZXlzIGl0" + - "IGV4cGxpY2l0bHkgcmVmZXJlbmNlczoKCiMjIyBDYXNzYW5kcmEKLSBgY2Fzc2FuZHJhLnJlcGxp" + - "Y2FDb3VudGAKLSBgY2Fzc2FuZHJhLmltYWdlLipgIChyZWdpc3RyeSwgcmVwb3NpdG9yeSkKLSBg" + - "Y2Fzc2FuZHJhLm1pZ3JhdGlvbnMuaW1hZ2UuKmAKLSBgY2Fzc2FuZHJhLnBlcnNpc3RlbmNlLnNp" + - "emVgCi0gYGNhc3NhbmRyYS5ub2RlU2VsZWN0b3JgIChpZiBgZ2xvYmFsLm5vZGVTZWxlY3RvcnMu" + - "ZW5hYmxlZGApCi0gYGNhc3NhbmRyYS5nbG9iYWwuZGVmYXVsdFN0b3JhZ2VDbGFzc2AKCiMjIyBO" + - "QVRTCi0gYG5hdHMuY29udGFpbmVyLmltYWdlLipgCi0gYG5hdHMucmVsb2FkZXIuaW1hZ2UuKmAK" + - "LSBgbmF0cy5uYXRzQm94LmNvbnRhaW5lci5pbWFnZS4qYAotIGBuYXRzLmNvbmZpZy5qZXRzdHJl" + - "YW0uZmlsZVN0b3JlLnB2Yy5zdG9yYWdlQ2xhc3NOYW1lYAotIGBuYXRzLnBvZFRlbXBsYXRlLm1l" + - "cmdlLnNwZWMubm9kZVNlbGVjdG9yYCAoaWYgZW5hYmxlZCkKCiMjIyBPcGVuQmFvCi0gYG9wZW5i" + - "YW8ubWlncmF0aW9ucy5pbWFnZS4qYCBhbmQgYG9wZW5iYW8ubWlncmF0aW9ucy5lbnZgCi0gYG9w" + - "ZW5iYW8uaW5qZWN0b3IuaW1hZ2UuKmAKLSBgb3BlbmJhby5zZXJ2ZXIuaW1hZ2UuKmAKLSBgb3Bl" + - "bmJhby5zZXJ2ZXIuZGF0YVN0b3JhZ2UuKmAKLSBOb2RlIHNlbGVjdG9ycyAoaWYgZW5hYmxlZCkK" + - "CiMjIyBTZXJ2aWNlcyAoQVBJLCBTSVMsIGV0Yy4pCi0gYDxzZXJ2aWNlPi5pbWFnZS4qYCAocmVn" + - "aXN0cnksIHJlcG9zaXRvcnkpCi0gYDxzZXJ2aWNlPi5ub2RlU2VsZWN0b3JgIChpZiBlbmFibGVk" + - "KQotIGA8c2VydmljZT4uZW52LipgIChvYnNlcnZhYmlsaXR5IHNldHRpbmdzKQoKIyMjIExMTSBG" + - "dW5jdGlvbiBFbmFibGVtZW50CgpFbmFibGUgdGhlIExMTSBhZGRvbiBiZWZvcmUgY3JlYXRpbmcg" + - "b3IgaW52b2tpbmcgZnVuY3Rpb25zIHdpdGgKYGZ1bmN0aW9uVHlwZTogIkxMTSJgLiBUaGUgYWRk" + - "b24gZGVwbG95cyBgbGxtLXJlcXVlc3Qtcm91dGVyYCBhbmQKYGxsbS1hcGktZ2F0ZXdheWAsIGFk" + - "ZHMgdGhlIGBsbG0uaW52b2NhdGlvbi48ZG9tYWluPmAgcm91dGUgd2hlbiBHYXRld2F5IEFQSQpp" + - "bmdyZXNzIGlzIGVuYWJsZWQsIGFuZCBjb25maWd1cmVzIHdvcmtlcnMgdG8gdXNlIHRoZSBMTE0g" + - "c2lkZWNhci4gVGhlIEhlbG1maWxlCmNvbmRpdGlvbiBpcyBgYWRkb25zLmxsbS5lbmFibGVkYC4g" + - "RG8gbm90IHVzZSB0aGUgb2Jzb2xldGUgYGxsbS5lbmFibGVkYCBwYXRoLgoKRm9yIGEgc2luZ2xl" + - "LW5vZGUgaXNvbGF0ZWQgdGVzdCBjbHVzdGVyLCBhZGQgdGhpcyBjb25maWd1cmF0aW9uIHRvCmBl" + - "bnZpcm9ubWVudHMvPGVudj4ueWFtbGAgYmVmb3JlIGFwcGx5aW5nIHRoZSBzdGFjazoKCmBgYHlh" + - "bWwKYWRkb25zOgogIGxsbToKICAgIGVuYWJsZWQ6IHRydWUKICAgIGdhdGV3YXk6CiAgICAgIHJl" + - "cGxpY2FDb3VudDogMQogICAgICBhdXRoOgogICAgICAgIGdycGNJbnNlY3VyZTogdHJ1ZQogICAg" + - "ICBtZXRyaWNzOgogICAgICAgIHNlcnZpY2VNb25pdG9yOgogICAgICAgICAgZW5hYmxlZDogZmFs" + - "c2UKICAgIHJlcXVlc3RSb3V0ZXI6CiAgICAgIHJlcGxpY2FDb3VudDogMQogICAgICBtZXRyaWNz" + - "OgogICAgICAgIHNlcnZpY2VNb25pdG9yOgogICAgICAgICAgZW5hYmxlZDogZmFsc2UKCmFnZW50" + - "Q29uZmlnOgogIG1lcmdlQ29uZmlnOiB8CiAgICBjbHVzdGVyOgogICAgICB2YWxpZGF0aW9uUG9s" + - "aWN5OgogICAgICAgIG5hbWU6IFVucmVzdHJpY3RlZAogICAgd29ya2xvYWQ6CiAgICAgIHN0YXJn" + - "YXRlUVVJQ0luc2VjdXJlOiB0cnVlCmBgYAoKVXNlIGByZXBsaWNhQ291bnQ6IDFgIG9ubHkgZm9y" + - "IGxvY2FsIG9yIHNpbmdsZS1ub2RlIHRlc3QgY2x1c3RlcnMuIEZvciBzaGFyZWQKb3IgcHJvZHVj" + - "dGlvbiBjbHVzdGVycywgdXNlIHRoZSByZXF1aXJlZCByZXBsaWNhIGNvdW50IGFuZCBUTFMtY2Fw" + - "YWJsZSBzZXJ2aWNlCmNvbmZpZ3VyYXRpb24uIGBhZGRvbnMubGxtLmdhdGV3YXkuYXV0aC5ncnBj" + - "SW5zZWN1cmVgIGFuZApgd29ya2xvYWQuc3RhcmdhdGVRVUlDSW5zZWN1cmVgIGVuYWJsZSBwbGFp" + - "bnRleHQgdHJhbnNwb3J0cy4gRG8gbm90IHVzZSB0aGVtIGluCnByb2R1Y3Rpb24uCgpUaGUgcmVx" + - "dWVzdCByb3V0ZXIgdXNlcyBgcG93ZXItb2YtdHdvYCB3aGVuIG5vIGxvYWQtYmFsYW5jZXIgY29u" + - "ZmlndXJhdGlvbiBpcwpzZXQuIENvbmZpZ3VyZSBvdGhlciByb3V0aW5nIG1ldGhvZHMgd2l0aCB0" + - "aGUKW0xMTSBSZXF1ZXN0IFJvdXRlciBMb2FkIEJhbGFuY2luZ10oaHR0cHM6Ly9naXRodWIuY29t" + - "L05WSURJQS9udmNmL2Jsb2IvbWFpbi9kb2NzL3VzZXIvbGxtLXJlcXVlc3Qtcm91dGVyLWxvYWQt" + - "YmFsYW5jaW5nLm1kKQpndWlkZS4KCklmIHRoZSBzaWRlY2FyIGltYWdlIGlzIG1pcnJvcmVkIG91" + - "dHNpZGUgdGhlIHN0YWNrJ3MgZGVmYXVsdCBpbWFnZSByZWdpc3RyeSBhbmQKcmVwb3NpdG9yeSwg" + - "c2V0IHRoZSBnZW5lcmF0ZWQgd29ya2VyIHNpZGVjYXIgaW1hZ2UgZXhwbGljaXRseToKCmBgYHlh" + - "bWwKYXBpOgogIGVudjoKICAgIE5WQ0ZfU0lERUNBUlNfTExNX1JPVVRFUl9DTElFTlRfSU1BR0U6" + - "IDxyZWdpc3RyeT4vPHJlcG9zaXRvcnk+L3B5bG9uOjAuMi4xCmBgYAoKUmVuZGVyIGFuZCBhcHBs" + - "eSB0aGUgdXBkYXRlZCBjb250cm9sLXBsYW5lIGVudmlyb25tZW50LCB0aGVuIHJlZnJlc2ggZXZl" + - "cnkKcmVnaXN0ZXJlZCBjb21wdXRlIHBsYW5lIHVzaW5nIHRoZSBzYW1lIGhhbmRvZmYgdXNlZCBm" + - "b3IgaXRzIGluc3RhbGxhdGlvbiBzbwpOVkNBIHJlY2VpdmVzIGBhZ2VudENvbmZpZy5tZXJnZUNv" + - "bmZpZ2A6CgpgYGBiYXNoCkhFTE1GSUxFX0VOVj08ZW52PiBoZWxtZmlsZSB0ZW1wbGF0ZQpIRUxN" + - "RklMRV9FTlY9PGVudj4gaGVsbWZpbGUgc3luYwpgYGAKClVzZSB0aGUgY29tcGxldGUgY29tcHV0" + - "ZS1wbGFuZSBpbnN0YWxsIGNvbW1hbmQgZnJvbQpbU3BsaXQgQ29tcHV0ZS1QbGFuZSBJbnN0YWxs" + - "YXRpb25dKGNvbXB1dGUtcGxhbmUtaW5zdGFsbGF0aW9uLm1kKS4gQQpDTEktcHJvZmlsZSBpbnN0" + - "YWxsYXRpb24gbXVzdCByZW1haW4gcHJvZmlsZS1kcml2ZW47IGEgSGVsbWZpbGUgaW5zdGFsbGF0" + - "aW9uCm11c3QgcmVtYWluIHZhbHVlcy1kcml2ZW4uCgpFeGlzdGluZyBMTE0gZnVuY3Rpb24gcG9k" + - "cyBrZWVwIHRoZWlyIGV4aXN0aW5nIHNpZGVjYXIgYXJndW1lbnRzLiBSZWNyZWF0ZSBvcgpyZWRl" + - "cGxveSB0aG9zZSBmdW5jdGlvbnMgYWZ0ZXIgdGhlIGNvbXB1dGUtcGxhbmUgcmVmcmVzaC4gVmVy" + - "aWZ5IHRoZSBjb250cm9sCnBsYW5lLCByb3V0ZSwgYW5kIHdvcmtlciBzaWRlY2FyOgoKYGBgYmFz" + - "aAprdWJlY3RsIGdldCBkZXBsb3kgLW4gbnZjZiBsbG0tYXBpLWdhdGV3YXkKa3ViZWN0bCBnZXQg" + - "c3RhdGVmdWxzZXQgLW4gbnZjZiBsbG0tcmVxdWVzdC1yb3V0ZXIKa3ViZWN0bCBnZXQgcG9kcyAt" + - "biBudmNmIHwgZ3JlcCAtRSAnbGxtLWFwaS1nYXRld2F5fGxsbS1yZXF1ZXN0LXJvdXRlcicKa3Vi" + - "ZWN0bCBnZXQgaHR0cHJvdXRlIC1BIHwgZ3JlcCBsbG0Ka3ViZWN0bCAtbiBudmNmLWJhY2tlbmQg" + - "Z2V0IHBvZCA8ZnVuY3Rpb24tcG9kPiBcCiAgLW8ganNvbnBhdGg9J3tyYW5nZSAuc3BlYy5jb250" + - "YWluZXJzWz8oQC5uYW1lPT0ibGxtLXdvcmtlciIpXS5hcmdzWypdfXsufXsiXFxuIn17ZW5kfScK" + - "YGBgCgpGb3IgbG9jYWwgcGxhaW50ZXh0IGNsdXN0ZXJzLCB0aGUgYGxsbS13b3JrZXJgIGFyZ3Mg" + - "bXVzdCBpbmNsdWRlCmAtLXF1aWMtaW5zZWN1cmVgLgoKRm9yIGxvYWQtYmFsYW5jZXIgc2NoZW1h" + - "IGFuZCBhbGdvcml0aG0gYmVoYXZpb3IsIHNlZSB0aGUKW1N0YXJnYXRlIGNvbmZpZ3VyYXRpb24g" + - "Z3VpZGVdKGh0dHBzOi8vZ2l0aHViLmNvbS9OVklESUEvbnZjZi9ibG9iL21haW4vc3JjL2xpYnJh" + - "cmllcy9ydXN0L3N0YXJnYXRlL2RvY3MvbG9hZC1iYWxhbmNlci1jb25maWd1cmF0aW9uLm1kKS4K" + - "CiMjIEhlbG1maWxlIFNlbGVjdG9ycwoKVGFyZ2V0IHNwZWNpZmljIHJlbGVhc2VzIG9yIGdyb3Vw" + - "czoKCmBgYGJhc2gKIyBCeSByZWxlYXNlIGdyb3VwCkhFTE1GSUxFX0VOVj08ZW52PiBoZWxtZmls" + - "ZSAtLXNlbGVjdG9yIHJlbGVhc2UtZ3JvdXA9ZGVwZW5kZW5jaWVzIHN5bmMKSEVMTUZJTEVfRU5W" + - "PTxlbnY+IGhlbG1maWxlIC0tc2VsZWN0b3IgcmVsZWFzZS1ncm91cD1zZXJ2aWNlcyBzeW5jCkhF" + - "TE1GSUxFX0VOVj08ZW52PiBoZWxtZmlsZSAtLXNlbGVjdG9yIHJlbGVhc2UtZ3JvdXA9aW5ncmVz" + - "cyBzeW5jCkhFTE1GSUxFX0VOVj08ZW52PiBoZWxtZmlsZSAtLXNlbGVjdG9yIHJlbGVhc2UtZ3Jv" + - "dXA9b2JzZXJ2YWJpbGl0eSBzeW5jCgojIEJ5IHJlbGVhc2UgbmFtZQpIRUxNRklMRV9FTlY9PGVu" + - "dj4gaGVsbWZpbGUgLS1zZWxlY3RvciBuYW1lPWNhc3NhbmRyYSBzeW5jCkhFTE1GSUxFX0VOVj08" + - "ZW52PiBoZWxtZmlsZSAtLXNlbGVjdG9yIG5hbWU9YWRtaW4taXNzdWVyLXByb3h5IHN5bmMKSEVM" + - "TUZJTEVfRU5WPTxlbnY+IGhlbG1maWxlIC0tc2VsZWN0b3IgbmFtZT1sbG0tcmVxdWVzdC1yb3V0" + - "ZXIgc3luYwpIRUxNRklMRV9FTlY9PGVudj4gaGVsbWZpbGUgLS1zZWxlY3RvciBuYW1lPWxsbS1h" + - "cGktZ2F0ZXdheSBzeW5jCgojIFRlbXBsYXRlIG9ubHkgKGRyeSBydW4pCkhFTE1GSUxFX0VOVj08" + - "ZW52PiBoZWxtZmlsZSAtLXNlbGVjdG9yIG5hbWU9Y2Fzc2FuZHJhIHRlbXBsYXRlCgojIERlc3Ry" + - "b3kgYSBzaW5nbGUgcmVsZWFzZQpIRUxNRklMRV9FTlY9PGVudj4gaGVsbWZpbGUgLS1zZWxlY3Rv" + - "ciBuYW1lPWNhc3NhbmRyYSBkZXN0cm95CmBgYAoKTm90ZTogYGFkbWluLWlzc3Vlci1wcm94eWAg" + - "aGFzIG5vIGByZWxlYXNlLWdyb3VwYCBsYWJlbC4gVXNlIGAtLXNlbGVjdG9yIG5hbWU9YWRtaW4t" + - "aXNzdWVyLXByb3h5YC4KUEsHCMBWIOePJwAAjycAAFBLAwQUAAgAAAAAACEAAAAAAAAAAAAAAAAA" + - "PwAJAGRhdGEvbnZjZi1zZWxmLW1hbmFnZWQtaW5zdGFsbGF0aW9uL3JlZmVyZW5jZXMvbnZjZi11" + - "aS1hZGRvbi5tZFVUBQABAKbOEiMgTlZDRiBVSSBBZGRvbgoKTlZDRiBVSSBpcyBhbiBvcHRpb25h" + - "bCwgY3VzdG9tZXItZmFjaW5nIE5WQ0YgYWRtaW4tcGFuZWwgVUkuIEl0IGlzIGRpc2FibGVkIGJ5" + - "CmRlZmF1bHQgYW5kIGF2YWlsYWJsZSBvbmx5IGluIHN0YWNrIHBhY2thZ2VzIHRoYXQgaW5jbHVk" + - "ZSB0aGUgTlZDRiBVSSBhZGRvbi4KCiMjIFdoZW4gdG8gZW5hYmxlCgpFbmFibGUgTlZDRiBVSSBv" + - "bmx5IHdoZW4geW91IG5lZWQgdGhlIGFkbWluLXBhbmVsIFVJIGFuZCB5b3VyIGV4dHJhY3RlZCBz" + - "dGFjawpwYWNrYWdlIGluY2x1ZGVzIHRoZSBhZGRvbi4gSWYgdGhlIHBhY2thZ2UgZG9lcyBub3Qg" + - "Y29udGFpbiBhIGBudmNmLXVpYCByZWxlYXNlCmFuZCBgbnZjZlVpYCByb3V0ZSB2YWx1ZXMsIHNr" + - "aXAgdGhlIGFkZG9uIHVudGlsIHlvdSB1c2UgYSBwYWNrYWdlIHRoYXQgaW5jbHVkZXMKdGhlbS4K" + - "CiMjIEVuYWJsZSB0aGUgYWRkb24KCkVuYWJsZSBpdCBpbiBgZW52aXJvbm1lbnRzLzxlbnYtbmFt" + - "ZT4ueWFtbGA6CgpgYGB5YW1sCmFkZG9uczoKICBudmNmVWk6CiAgICBlbmFibGVkOiB0cnVlCmBg" + - "YAoKIyMgQ3JlYXRlIG5hbWVzcGFjZSBhbmQgaW1hZ2UgcHVsbCBzZWNyZXQKCkNyZWF0ZSB0aGUg" + - "bmFtZXNwYWNlLCBhbmQgYW4gaW1hZ2UgcHVsbCBzZWNyZXQgb25seSBpZiBwdWxsaW5nIGZyb20g" + - "YSBwcml2YXRlCnJlZ2lzdHJ5OgoKYGBgYmFzaAprdWJlY3RsIGNyZWF0ZSBuYW1lc3BhY2UgbnZj" + - "Zi11aSAtLWRyeS1ydW49Y2xpZW50IC1vIHlhbWwgfCBrdWJlY3RsIGFwcGx5IC1mIC0KCiMgT25s" + - "eSBpZiBwdWxsaW5nIGZyb20gYSBwcml2YXRlIHJlZ2lzdHJ5IChlLmcuLCBOR0MgbnZjci5pbykK" + - "ZXhwb3J0IE5HQ19BUElfS0VZPSI8eW91ci1rZXk+IgprdWJlY3RsIGNyZWF0ZSBzZWNyZXQgZG9j" + - "a2VyLXJlZ2lzdHJ5IG52Y3ItY3JlZHMgXAogIC0tZG9ja2VyLXNlcnZlcj1udmNyLmlvIFwKICAt" + - "LWRvY2tlci11c2VybmFtZT0nJG9hdXRodG9rZW4nIFwKICAtLWRvY2tlci1wYXNzd29yZD0iJE5H" + - "Q19BUElfS0VZIiBcCiAgLS1uYW1lc3BhY2U9bnZjZi11aSBcCiAgLS1kcnktcnVuPWNsaWVudCAt" + - "byB5YW1sIHwga3ViZWN0bCBhcHBseSAtZiAtCmBgYAoKVGhlIGRlZmF1bHQgcm91dGUgaG9zdCBp" + - "cyBgbnZjZi11aS48ZG9tYWluPmAgYW5kIHRoZSBiYWNrZW5kIGlzCmBudmNmLXVpLm52Y2YtdWk6" + - "ODMwMGAuCgojIyBBcHBseSB0aGUgc2VydmljZSBhbmQgcm91dGUKCkFmdGVyIGNvbmZpcm1pbmcg" + - "dGhlIHBhY2thZ2UgaW5jbHVkZXMgdGhlIGBudmNmLXVpYCByZWxlYXNlLCBwcmV2aWV3IGFuZCBh" + - "cHBseQp0aGUgc2VydmljZSBhbmQgcm91dGU6CgpgYGBiYXNoCkhFTE1GSUxFX0VOVj08ZW52LW5h" + - "bWU+IGhlbG1maWxlIC0tc2VsZWN0b3IgbmFtZT1udmNmLXVpIHRlbXBsYXRlCkhFTE1GSUxFX0VO" + - "Vj08ZW52LW5hbWU+IGhlbG1maWxlIC0tc2VsZWN0b3IgbmFtZT1udmNmLXVpIHN5bmMKSEVMTUZJ" + - "TEVfRU5WPTxlbnYtbmFtZT4gaGVsbWZpbGUgLS1zZWxlY3RvciByZWxlYXNlLWdyb3VwPWluZ3Jl" + - "c3Mgc3luYwpgYGAKCiMjIFZlcmlmeQoKVmVyaWZ5IHRoZSByb3V0ZSBvbmx5IHdoZW4gdGhlIGFk" + - "ZG9uIGlzIHByZXNlbnQgYW5kIGVuYWJsZWQ6CgpgYGBiYXNoCmt1YmVjdGwgZ2V0IGRlcGxveSxz" + - "dmMgLW4gbnZjZi11aQprdWJlY3RsIGdldCBodHRwcm91dGUgLUEgfCBncmVwIC1pIG52Y2YtdWkK" + - "Y3VybCAtaSAtSCAiSG9zdDogbnZjZi11aS48ZG9tYWluPiIgImh0dHA6Ly88Z2F0ZXdheS1hZGRy" + - "ZXNzPi9zdGF0dXMiCmBgYAoKIyMgU2VjdXJpdHkKClRoZSBOVkNGIFVJIGFkbWluIHBhbmVsIGlz" + - "IGN1cnJlbnRseSB1bmF1dGhlbnRpY2F0ZWQuIERvIG5vdCBleHBvc2UgaXQgdG8gdGhlCnB1Ymxp" + - "YyBpbnRlcm5ldC4gUmVzdHJpY3QgYWNjZXNzIHRvIGEgdHJ1c3RlZCBuZXR3b3JrLCBWUE4sIG9y" + - "IGFuIGF1dGhlbnRpY2F0aW5nCnByb3h5IGluIGZyb250IG9mIHRoZSBgbnZjZi11aWAgcm91dGUu" + - "ClBLBwg4+SevuQcAALkHAABQSwMEFAAIAAAAAAAhAAAAAAAAAAAAAAAAAD4ACQBkYXRhL252Y2Yt" + - "c2VsZi1tYW5hZ2VkLWluc3RhbGxhdGlvbi9yZWZlcmVuY2VzL3B1bGwtc2VjcmV0cy5tZFVUBQAB" + - "AKbOEiMgSW1hZ2UgUHVsbCBTZWNyZXRzIFJlZmVyZW5jZQoKIyMgT3ZlcnZpZXcKCldoZW4gcHVs" + - "bGluZyBOVkNGIGltYWdlcyBmcm9tIGEgcHJpdmF0ZSByZWdpc3RyeSAoZm9yIGV4YW1wbGUsIE5H" + - "QwpgbnZjci5pb2ApLCBLdWJlcm5ldGVzIG5lZWRzIGBpbWFnZVB1bGxTZWNyZXRzYCBvbiBldmVy" + - "eSBwb2QuIENvbnRyb2wtcGxhbmUgYW5kCmNvbXB1dGUtcGxhbmUgY3JlZGVudGlhbHMgYXJlIGNv" + - "bmZpZ3VyZWQgaW4gdGhlaXIgb3duIGNsdXN0ZXIgY29udGV4dHMuIERvIG5vdAp1c2Ugb25lIG1p" + - "eGVkIG5hbWVzcGFjZSBsaXN0LgoKVGhlIHJlY29tbWVuZGVkIGNvbnRyb2wtcGxhbmUgYXBwcm9h" + - "Y2ggdXNlcyBLeXZlcm5vIHRvIGluamVjdCB0aGUgc2VjcmV0IGludG8KY29udHJvbC1wbGFuZSBw" + - "b2RzIGF0IGFkbWlzc2lvbiB0aW1lLiBUaGUgY29tcHV0ZS1wbGFuZSBjaGFydCBhbmQgb3BlcmF0" + - "b3IgdXNlCnRoZSBzZWNyZXQgaW4gYG52Y2Etb3BlcmF0b3JgIGFuZCBtaXJyb3IgaXQgdG8gYG52" + - "Y2Etc3lzdGVtYC4KCiMjIEt5dmVybm8gQXBwcm9hY2ggKFJlY29tbWVuZGVkKQoKIyMjIDEuIElu" + - "c3RhbGwgS3l2ZXJubwoKYGBgYmFzaApoZWxtIHJlcG8gYWRkIGt5dmVybm8gaHR0cHM6Ly9reXZl" + - "cm5vLmdpdGh1Yi5pby9reXZlcm5vLwpoZWxtIHJlcG8gdXBkYXRlCmhlbG0gaW5zdGFsbCBreXZl" + - "cm5vIGt5dmVybm8va3l2ZXJubyAtbiBreXZlcm5vIC0tY3JlYXRlLW5hbWVzcGFjZSBcCiAgLS1r" + - "dWJlLWNvbnRleHQgPGNvbnRyb2wtcGxhbmUtY29udGV4dD4KYGBgCgojIyMgMi4gQ3JlYXRlIGNv" + - "bnRyb2wtcGxhbmUgcHVsbCBzZWNyZXRzCgpgYGBiYXNoCmV4cG9ydCBOR0NfQVBJX0tFWT0iPHlv" + - "dXItbmdjLWFwaS1rZXk+IgoKZm9yIG5zIGluIGNhc3NhbmRyYS1zeXN0ZW0gbmF0cy1zeXN0ZW0g" + - "bnZjZiBhcGkta2V5cyBlc3Mgc2lzIHZhdWx0LXN5c3RlbSBjZXJ0LW1hbmFnZXI7IGRvCiAga3Vi" + - "ZWN0bCAtLWNvbnRleHQgPGNvbnRyb2wtcGxhbmUtY29udGV4dD4gY3JlYXRlIG5hbWVzcGFjZSAi" + - "JG5zIiBcCiAgICAtLWRyeS1ydW49Y2xpZW50IC1vIHlhbWwgfCBrdWJlY3RsIC0tY29udGV4dCA8" + - "Y29udHJvbC1wbGFuZS1jb250ZXh0PiBhcHBseSAtZiAtCmRvbmUKCmZvciBucyBpbiBjYXNzYW5k" + - "cmEtc3lzdGVtIG5hdHMtc3lzdGVtIG52Y2YgYXBpLWtleXMgZXNzIHNpcyB2YXVsdC1zeXN0ZW0g" + - "Y2VydC1tYW5hZ2VyOyBkbwogIGt1YmVjdGwgLS1jb250ZXh0IDxjb250cm9sLXBsYW5lLWNvbnRl" + - "eHQ+IGNyZWF0ZSBzZWNyZXQgZG9ja2VyLXJlZ2lzdHJ5IG52Y3ItY3JlZHMgXAogICAgLS1kb2Nr" + - "ZXItc2VydmVyPW52Y3IuaW8gXAogICAgLS1kb2NrZXItdXNlcm5hbWU9JyRvYXV0aHRva2VuJyBc" + - "CiAgICAtLWRvY2tlci1wYXNzd29yZD0iJE5HQ19BUElfS0VZIiBcCiAgICAtLW5hbWVzcGFjZT0i" + - "JG5zIiBcCiAgICAtLWRyeS1ydW49Y2xpZW50IC1vIHlhbWwgfCBrdWJlY3RsIC0tY29udGV4dCA8" + - "Y29udHJvbC1wbGFuZS1jb250ZXh0PiBhcHBseSAtZiAtCmRvbmUKYGBgCgpGb3Igbm9uLU5HQyBy" + - "ZWdpc3RyaWVzLCByZXBsYWNlIGAtLWRvY2tlci1zZXJ2ZXJgLCBgLS1kb2NrZXItdXNlcm5hbWVg" + - "LCBhbmQgYC0tZG9ja2VyLXBhc3N3b3JkYC4KCiMjIyAzLiBBcHBseSBLeXZlcm5vIENsdXN0ZXJQ" + - "b2xpY3kKCmBgYHlhbWwKYXBpVmVyc2lvbjoga3l2ZXJuby5pby92MQpraW5kOiBDbHVzdGVyUG9s" + - "aWN5Cm1ldGFkYXRhOgogIG5hbWU6IG52Y2YtYWRkLWltYWdlcHVsbHNlY3JldHMKc3BlYzoKICBi" + - "YWNrZ3JvdW5kOiBmYWxzZQogIHJ1bGVzOgogICAgLSBuYW1lOiBhZGQtaW1hZ2VwdWxsc2VjcmV0" + - "LXRvLW52Y2YtcG9kcwogICAgICBtYXRjaDoKICAgICAgICBhbnk6CiAgICAgICAgLSByZXNvdXJj" + - "ZXM6CiAgICAgICAgICAgIGtpbmRzOgogICAgICAgICAgICAtIFBvZAogICAgICAgICAgICBuYW1l" + - "c3BhY2VzOgogICAgICAgICAgICAtICJudmNmIgogICAgICAgICAgICAtICJhcGkta2V5cyIKICAg" + - "ICAgICAgICAgLSAic2lzIgogICAgICAgICAgICAtICJlc3MiCiAgICAgICAgICAgIC0gIm5hdHMt" + - "c3lzdGVtIgogICAgICAgICAgICAtICJjYXNzYW5kcmEtc3lzdGVtIgogICAgICAgICAgICAtICJ2" + - "YXVsdC1zeXN0ZW0iCiAgICAgICAgICAgIC0gImNlcnQtbWFuYWdlciIKICAgICAgbXV0YXRlOgog" + - "ICAgICAgIHBhdGNoU3RyYXRlZ2ljTWVyZ2U6CiAgICAgICAgICBtZXRhZGF0YToKICAgICAgICAg" + - "ICAgYW5ub3RhdGlvbnM6CiAgICAgICAgICAgICAgbnZjZi5udmlkaWEuY29tL2ltYWdlcHVsbHNl" + - "Y3JldC1pbmplY3RlZC1ieToga3l2ZXJubwogICAgICAgICAgc3BlYzoKICAgICAgICAgICAgaW1h" + - "Z2VQdWxsU2VjcmV0czoKICAgICAgICAgICAgLSBuYW1lOiBudmNyLWNyZWRzCmBgYAoKYGBgYmFz" + - "aAprdWJlY3RsIC0tY29udGV4dCA8Y29udHJvbC1wbGFuZS1jb250ZXh0PiBhcHBseSBcCiAgLWYg" + - "a3l2ZXJuby1pbWFnZXB1bGxzZWNyZXQtcG9saWN5LnlhbWwKYGBgCgojIyMgNC4gSW5zdGFsbCB0" + - "aGUgY29udHJvbCBwbGFuZQoKQ29udGludWUgd2l0aCB0aGUgc2VsZWN0ZWQgY29udHJvbC1wbGFu" + - "ZSBpbnN0YWxsYXRpb24gaW4KW1NwbGl0IENvbXB1dGUtUGxhbmUgSW5zdGFsbGF0aW9uXShjb21w" + - "dXRlLXBsYW5lLWluc3RhbGxhdGlvbi5tZCkuIE5vCmNvbnRyb2wtcGxhbmUgaGVsbWZpbGUgbW9k" + - "aWZpY2F0aW9ucyBhcmUgbmVlZGVkLiBLeXZlcm5vIGluamVjdHMgdGhlIHB1bGwKc2VjcmV0IGlu" + - "dG8gbmV3IGNvbnRyb2wtcGxhbmUgcG9kcy4KCiMjIENvbXB1dGUtUGxhbmUgU2VjcmV0CgpDcmVh" + - "dGUgdGhlIHNlY3JldCBvbmx5IGluIGBudmNhLW9wZXJhdG9yYCBvbiB0aGUgY29tcHV0ZSBjbHVz" + - "dGVyOgoKYGBgYmFzaAprdWJlY3RsIC0tY29udGV4dCA8Y29tcHV0ZS1wbGFuZS1jb250ZXh0PiBj" + - "cmVhdGUgbmFtZXNwYWNlIG52Y2Etb3BlcmF0b3IgXAogIC0tZHJ5LXJ1bj1jbGllbnQgLW8geWFt" + - "bCB8IFwKICBrdWJlY3RsIC0tY29udGV4dCA8Y29tcHV0ZS1wbGFuZS1jb250ZXh0PiBhcHBseSAt" + - "ZiAtCgprdWJlY3RsIC0tY29udGV4dCA8Y29tcHV0ZS1wbGFuZS1jb250ZXh0PiBjcmVhdGUgc2Vj" + - "cmV0IGRvY2tlci1yZWdpc3RyeSBudmNyLWNyZWRzIFwKICAtLWRvY2tlci1zZXJ2ZXI9bnZjci5p" + - "byBcCiAgLS1kb2NrZXItdXNlcm5hbWU9JyRvYXV0aHRva2VuJyBcCiAgLS1kb2NrZXItcGFzc3dv" + - "cmQ9IiROR0NfQVBJX0tFWSIgXAogIC0tbmFtZXNwYWNlPW52Y2Etb3BlcmF0b3IgXAogIC0tZHJ5" + - "LXJ1bj1jbGllbnQgLW8geWFtbCB8IFwKICBrdWJlY3RsIC0tY29udGV4dCA8Y29tcHV0ZS1wbGFu" + - "ZS1jb250ZXh0PiBhcHBseSAtZiAtCmBgYAoKUmVmZXJlbmNlIGl0IGluIHRoZSBjb21wdXRlLXBs" + - "YW5lIGVudmlyb25tZW50IGZpbGU6CgpgYGB5YW1sCmdsb2JhbDoKICBpbWFnZVB1bGxTZWNyZXRz" + - "OgogICAgLSBuYW1lOiBudmNyLWNyZWRzCmBgYAoKVGhlIGNoYXJ0IGFuZCBvcGVyYXRvciB1c2Ug" + - "dGhhdCByZWZlcmVuY2UgaW4gYG52Y2Etb3BlcmF0b3JgIGFuZCBtaXJyb3IgdGhlCnNlY3JldCB0" + - "byBgbnZjYS1zeXN0ZW1gLiBEbyBub3QgY3JlYXRlIGEgYnJvYWRlciBtYW51YWwgY29tcHV0ZSBu" + - "YW1lc3BhY2UgbGlzdC4gRm9sbG93CltTcGxpdCBDb21wdXRlLVBsYW5lIEluc3RhbGxhdGlvbl0o" + - "Y29tcHV0ZS1wbGFuZS1pbnN0YWxsYXRpb24ubWQpIGZvciB0aGUKc2VsZWN0ZWQgaW5zdGFsbCBm" + - "bG93LgoKIyMgVmVyaWZpY2F0aW9uCgpgYGBiYXNoCiMgQ2hlY2sgdGhhdCBhIGNvbnRyb2wtcGxh" + - "bmUgcG9kIGhhcyB0aGUgaW5qZWN0ZWQgc2VjcmV0Cmt1YmVjdGwgLS1jb250ZXh0IDxjb250cm9s" + - "LXBsYW5lLWNvbnRleHQ+IGdldCBwb2QgLW4gPG5hbWVzcGFjZT4gPHBvZC1uYW1lPiBcCiAgLW8g" + - "anNvbnBhdGg9J3suc3BlYy5pbWFnZVB1bGxTZWNyZXRzfScKIyBFeHBlY3RlZDogW3sibmFtZSI6" + - "Im52Y3ItY3JlZHMifV0KCiMgQ2hlY2sgdGhlIEt5dmVybm8gYW5ub3RhdGlvbgprdWJlY3RsIC0t" + - "Y29udGV4dCA8Y29udHJvbC1wbGFuZS1jb250ZXh0PiBnZXQgcG9kIC1uIDxuYW1lc3BhY2U+IDxw" + - "b2QtbmFtZT4gXAogIC1vIGpzb25wYXRoPSd7Lm1ldGFkYXRhLmFubm90YXRpb25zLm52Y2ZcLm52" + - "aWRpYVwuY29tL2ltYWdlcHVsbHNlY3JldC1pbmplY3RlZC1ieX0nCiMgRXhwZWN0ZWQ6IGt5dmVy" + - "bm8KCiMgQ2hlY2sgcHVsbCBldmVudHMKa3ViZWN0bCAtLWNvbnRleHQgPGNvbnRyb2wtcGxhbmUt" + - "Y29udGV4dD4gZ2V0IGV2ZW50cyAtbiA8bmFtZXNwYWNlPiBcCiAgLS1zb3J0LWJ5PScubGFzdFRp" + - "bWVzdGFtcCcgfCBncmVwIC1pIHB1bGwKIyBTaG91bGQgc2hvdyAiU3VjY2Vzc2Z1bGx5IHB1bGxl" + - "ZCIgbm90ICI0MDEgVW5hdXRob3JpemVkIgoKIyBDaGVjayB0aGUgY2hhcnQvb3BlcmF0b3IgbWly" + - "cm9yIG9uIHRoZSBjb21wdXRlIGNsdXN0ZXIKa3ViZWN0bCAtLWNvbnRleHQgPGNvbXB1dGUtcGxh" + - "bmUtY29udGV4dD4gZ2V0IHNlY3JldCBudmNyLWNyZWRzIFwKICAtbiBudmNhLXN5c3RlbQpgYGAK" + - "CiMjIFdoZW4gUHVsbCBTZWNyZXRzIEFyZSBOb3QgTmVlZGVkCgotICoqQVdTIEVDUiB3aXRoIElB" + - "TSBub2RlIHJvbGVzKio6IElmIHlvdXIgbm9kZXMgaGF2ZSBgQW1hem9uRUMyQ29udGFpbmVyUmVn" + - "aXN0cnlSZWFkT25seWAgSUFNIHBvbGljeSwgS3ViZXJuZXRlcyBjYW4gcHVsbCBmcm9tIEVDUiB3" + - "aXRob3V0IGV4cGxpY2l0IHNlY3JldHMuCi0gKipQdWJsaWMgcmVnaXN0cmllcyoqOiBObyBwdWxs" + - "IHNlY3JldHMgbmVlZGVkLgotICoqQ1NQIGJ1aWx0LWluIGNyZWRlbnRpYWwgaGVscGVycyoqOiBH" + - "S0UgQXJ0aWZhY3QgUmVnaXN0cnksIEF6dXJlIEFDUiB3aXRoIG1hbmFnZWQgaWRlbnRpdHksIGFu" + - "ZCBzaW1pbGFyIHNlcnZpY2VzLgoKIyMgVHJvdWJsZXNob290aW5nCgojIyMgUG9kcyBzdGlsbCBp" + - "biBJbWFnZVB1bGxCYWNrT2ZmIGFmdGVyIGFwcGx5aW5nIHBvbGljeQoKVGhlIEt5dmVybm8gcG9s" + - "aWN5IG9ubHkgYWZmZWN0cyBwb2RzIGNyZWF0ZWQgKiphZnRlcioqIHRoZSBwb2xpY3kgaXMgYXBw" + - "bGllZC4gRGVsZXRlIHN0dWNrIHBvZHMgdG8gdHJpZ2dlciByZWNyZWF0aW9uOgoKYGBgYmFzaApr" + - "dWJlY3RsIC0tY29udGV4dCA8dGFyZ2V0LWNvbnRleHQ+IGRlbGV0ZSBwb2RzIC1uIDxuYW1lc3Bh" + - "Y2U+IC0tYWxsCmBgYAoKIyMjIEt5dmVybm8gYWRtaXNzaW9uIGNvbnRyb2xsZXIgbm90IHJ1bm5p" + - "bmcKCmBgYGJhc2gKa3ViZWN0bCAtLWNvbnRleHQgPGNvbnRyb2wtcGxhbmUtY29udGV4dD4gZ2V0" + - "IHBvZHMgLW4ga3l2ZXJubwojIEFsbCBwb2RzIHNob3VsZCBiZSBSdW5uaW5nCmBgYAoKIyMjIFBv" + - "bGljeSBub3QgbWF0Y2hpbmcKCmBgYGJhc2gKa3ViZWN0bCAtLWNvbnRleHQgPGNvbnRyb2wtcGxh" + - "bmUtY29udGV4dD4gZ2V0IGNsdXN0ZXJwb2xpY3kgbnZjZi1hZGQtaW1hZ2VwdWxsc2VjcmV0cwoj" + - "IFNob3VsZCBzaG93IFJFQURZOiBUcnVlCmBgYAoKIyMjIFdyb25nIHNlY3JldCBuYW1lCgpUaGUg" + - "cG9saWN5IHJlZmVyZW5jZXMgYG52Y3ItY3JlZHNgLiBWZXJpZnkgdGhlIHNlY3JldCBleGlzdHMg" + - "d2l0aCB0aGF0IGV4YWN0IG5hbWU6CgpgYGBiYXNoCmt1YmVjdGwgLS1jb250ZXh0IDx0YXJnZXQt" + - "Y29udGV4dD4gZ2V0IHNlY3JldCBudmNyLWNyZWRzIC1uIDxuYW1lc3BhY2U+CmBgYApQSwcIS0I1" + - "qAAWAAAAFgAAUEsBAhQAFAAIAAAAAAAhAM/joTZJEAAASRAAABIACQAAAAAAAAAAAAAAAAAAAGRh" + - "dGEvbWFuaWZlc3QuanNvblVUBQABAKbOElBLAQIUABQACAAAAAAAIQDNgTDkTWEAAE1hAAAjAAkA" + - "AAAAAAAAAAAAAJIQAABkYXRhL252Y2Ytc2VsZi1tYW5hZ2VkLWNsaS9TS0lMTC5tZFVUBQABAKbO" + - "ElBLAQIUABQACAAAAAAAIQAhxsiG8AoAAPAKAAAzAAkAAAAAAAAAAAAAADlyAABkYXRhL252Y2Yt" + - "c2VsZi1tYW5hZ2VkLWNsaS9leGFtcGxlcy9jaS1waXBlbGluZXMubWRVVAUAAQCmzhJQSwECFAAU" + - "AAgAAAAAACEAoRTjgV0MAABdDAAANAAJAAAAAAAAAAAAAACTfQAAZGF0YS9udmNmLXNlbGYtbWFu" + - "YWdlZC1jbGkvZXhhbXBsZXMvbXVsdGktY2x1c3Rlci5tZFVUBQABAKbOElBLAQIUABQACAAAAAAA" + - "IQBCJ0kPBQ0AAAUNAAA3AAkAAAAAAAAAAAAAAFuKAABkYXRhL252Y2Ytc2VsZi1tYW5hZ2VkLWNs" + - "aS9wcm9tcHRzL2FkZC1jb21wdXRlLXBsYW5lLm1kVVQFAAEAps4SUEsBAhQAFAAIAAAAAAAhAJHc" + - "G/mYGQAAmBkAADkACQAAAAAAAAAAAAAAzpcAAGRhdGEvbnZjZi1zZWxmLW1hbmFnZWQtY2xpL3By" + - "b21wdHMvY3JlYXRlLWFuZC1ydW4tdGFzay5tZFVUBQABAKbOElBLAQIUABQACAAAAAAAIQDSQ9wE" + - "GCUAABglAAA3AAkAAAAAAAAAAAAAANaxAABkYXRhL252Y2Ytc2VsZi1tYW5hZ2VkLWNsaS9wcm9t" + - "cHRzL2RlcGxveS1hbmQtaW52b2tlLm1kVVQFAAEAps4SUEsBAhQAFAAIAAAAAAAhAA6cP5e9DgAA" + - "vQ4AAD0ACQAAAAAAAAAAAAAAXNcAAGRhdGEvbnZjZi1zZWxmLW1hbmFnZWQtY2xpL3Byb21wdHMv" + - "ZGlhZ25vc2UtZmFpbGVkLWluc3RhbGwubWRVVAUAAQCmzhJQSwECFAAUAAgAAAAAACEAqvLWHrcn" + - "AAC3JwAAOgAJAAAAAAAAAAAAAACN5gAAZGF0YS9udmNmLXNlbGYtbWFuYWdlZC1jbGkvcHJvbXB0" + - "cy9pbnN0YWxsLWZyb20tc2NyYXRjaC5tZFVUBQABAKbOElBLAQIUABQACAAAAAAAIQAaxCyexwcA" + - "AMcHAAA5AAkAAAAAAAAAAAAAALUOAQBkYXRhL252Y2Ytc2VsZi1tYW5hZ2VkLWNsaS9wcm9tcHRz" + - "L3JvdGF0ZS1jbHVzdGVyLWp3a3MubWRVVAUAAQCmzhJQSwECFAAUAAgAAAAAACEAEpMzWeAhAADg" + - "IQAALgAJAAAAAAAAAAAAAADsFgEAZGF0YS9udmNmLXNlbGYtbWFuYWdlZC1jbGkvcHJvbXB0cy90" + - "ZWFyZG93bi5tZFVUBQABAKbOElBLAQIUABQACAAAAAAAIQByDQ9kISMAACEjAAAwAAkAAAAAAAAA" + - "AAAAADE5AQBkYXRhL252Y2Ytc2VsZi1tYW5hZ2VkLWNsaS9yZWZlcmVuY2UvY29tbWFuZHMubWRV" + - "VAUAAQCmzhJQSwECFAAUAAgAAAAAACEAc6daZNUGAADVBgAAMgAJAAAAAAAAAAAAAAC5XAEAZGF0" + - "YS9udmNmLXNlbGYtbWFuYWdlZC1jbGkvcmVmZXJlbmNlL2V4aXQtY29kZXMubWRVVAUAAQCmzhJQ" + - "SwECFAAUAAgAAAAAACEA/KOR4MYiAADGIgAALQAJAAAAAAAAAAAAAAD3YwEAZGF0YS9udmNmLXNl" + - "bGYtbWFuYWdlZC1jbGkvcmVmZXJlbmNlL2ZsYWdzLm1kVVQFAAEAps4SUEsBAhQAFAAIAAAAAAAh" + - "APOuE4R0EQAAdBEAADcACQAAAAAAAAAAAAAAIYcBAGRhdGEvbnZjZi1zZWxmLW1hbmFnZWQtY2xp" + - "L3JlZmVyZW5jZS90cm91Ymxlc2hvb3RpbmcubWRVVAUAAQCmzhJQSwECFAAUAAgAAAAAACEAL9q5" + - "dUJiAABCYgAALAAJAAAAAAAAAAAAAAADmQEAZGF0YS9udmNmLXNlbGYtbWFuYWdlZC1pbnN0YWxs" + - "YXRpb24vU0tJTEwubWRVVAUAAQCmzhJQSwECFAAUAAgAAAAAACEAKxO4P61VAACtVQAANAAJAAAA" + - "AAAAAAAAAACo+wEAZGF0YS9udmNmLXNlbGYtbWFuYWdlZC1pbnN0YWxsYXRpb24vZXZhbHMvZXZh" + - "bHMuanNvblVUBQABAKbOElBLAQIUABQACAAAAAAAIQACUk5AfygAAH8oAAAvAAkAAAAAAAAAAAAA" + - "AMBRAgBkYXRhL252Y2Ytc2VsZi1tYW5hZ2VkLWluc3RhbGxhdGlvbi9leGFtcGxlcy5tZFVUBQAB" + - "AKbOElBLAQIUABQACAAAAAAAIQCWY7xZEjAAABIwAABMAAkAAAAAAAAAAAAAAKV6AgBkYXRhL252" + - "Y2Ytc2VsZi1tYW5hZ2VkLWluc3RhbGxhdGlvbi9yZWZlcmVuY2VzL2NvbXB1dGUtcGxhbmUtaW5z" + - "dGFsbGF0aW9uLm1kVVQFAAEAps4SUEsBAhQAFAAIAAAAAAAhAFY+Z5CVMAAAlTAAADsACQAAAAAA" + - "AAAAAAAAOqsCAGRhdGEvbnZjZi1zZWxmLW1hbmFnZWQtaW5zdGFsbGF0aW9uL3JlZmVyZW5jZXMv" + - "ZGVidWdnaW5nLm1kVVQFAAEAps4SUEsBAhQAFAAIAAAAAAAhAMBWIOePJwAAjycAAEQACQAAAAAA" + - "AAAAAAAAQdwCAGRhdGEvbnZjZi1zZWxmLW1hbmFnZWQtaW5zdGFsbGF0aW9uL3JlZmVyZW5jZXMv" + - "aGVsbWZpbGUtc3RydWN0dXJlLm1kVVQFAAEAps4SUEsBAhQAFAAIAAAAAAAhADj5J6+5BwAAuQcA" + - "AD8ACQAAAAAAAAAAAAAASwQDAGRhdGEvbnZjZi1zZWxmLW1hbmFnZWQtaW5zdGFsbGF0aW9uL3Jl" + - "ZmVyZW5jZXMvbnZjZi11aS1hZGRvbi5tZFVUBQABAKbOElBLAQIUABQACAAAAAAAIQBLQjWoABYA" + - "AAAWAAA+AAkAAAAAAAAAAAAAAHoMAwBkYXRhL252Y2Ytc2VsZi1tYW5hZ2VkLWluc3RhbGxhdGlv" + - "bi9yZWZlcmVuY2VzL3B1bGwtc2VjcmV0cy5tZFVUBQABAKbOElBLBQYAAAAAFwAXAK8JAADvIgMA" + - "AAA=" + "cGxhbmUtY29udGV4dD4gXAogIGluc3RhbGwgLS1jb250cm9sLXBsYW5lIFwKICAtLWNsdXN0ZXIt" + + "bmFtZSA8Y29udHJvbC1wbGFuZS1jbHVzdGVyLW5hbWU+IFwKICAtLXJlZ2lvbiA8cmVnaW9uPiBc" + + "CiAgLS1uY2EtaWQgPG5jYS1pZD4KCnRlc3QgLXMgZGVwbG95L3N0YWNrcy9zZWxmLW1hbmFnZWQv" + + "b3V0L2NvbnRyb2wtcGxhbmUtcHJvZmlsZS55YW1sCmBgYAoKVXNlIHRoZSBmdWxsIHBlcnNpc3Rl" + + "bnQgcHJlZml4IGZvciBib3RoIGNvbXB1dGUtcGxhbmUgY29tbWFuZHM6CgpgYGBiYXNoCm52Y2Yt" + + "Y2xpIC0tY29uZmlnIDxjb25maWc+IHNlbGYtaG9zdGVkIFwKICAtLWNvbnRyb2wtcGxhbmUtc3Rh" + + "Y2sgZGVwbG95L3N0YWNrcy9zZWxmLW1hbmFnZWQgXAogIC0tY29tcHV0ZS1wbGFuZS1zdGFjayBk" + + "ZXBsb3kvc3RhY2tzL252Y2YtY29tcHV0ZS1wbGFuZSBcCiAgLS1lbnYgPGVudj4gXAogIC0tcGxh" + + "aW4gXAogIGNvbXB1dGUtcGxhbmUgcmVnaXN0ZXIgXAogIC0tY29udHJvbC1wbGFuZS1wcm9maWxl" + + "IGRlcGxveS9zdGFja3Mvc2VsZi1tYW5hZ2VkL291dC9jb250cm9sLXBsYW5lLXByb2ZpbGUueWFt" + + "bCBcCiAgLS1jbHVzdGVyLW5hbWUgPGNvbXB1dGUtcGxhbmUtY2x1c3Rlci1uYW1lPiBcCiAgLS1r" + + "dWJlLWNvbnRleHQgPGNvbXB1dGUtcGxhbmUtY29udGV4dD4gXAogIC0tcmVnaW9uIDxyZWdpb24+" + + "IFwKICAtLW91dHB1dCBkZXBsb3kvc3RhY2tzL252Y2YtY29tcHV0ZS1wbGFuZS9vdXQvPGNvbXB1" + + "dGUtcGxhbmUtY2x1c3Rlci1uYW1lPi1yZWdpc3Rlci12YWx1ZXMueWFtbAoKbnZjZi1jbGkgLS1j" + + "b25maWcgPGNvbmZpZz4gc2VsZi1ob3N0ZWQgXAogIC0tY29udHJvbC1wbGFuZS1zdGFjayBkZXBs" + + "b3kvc3RhY2tzL3NlbGYtbWFuYWdlZCBcCiAgLS1jb21wdXRlLXBsYW5lLXN0YWNrIGRlcGxveS9z" + + "dGFja3MvbnZjZi1jb21wdXRlLXBsYW5lIFwKICAtLWVudiA8ZW52PiBcCiAgLS1wbGFpbiBcCiAg" + + "Y29tcHV0ZS1wbGFuZSBpbnN0YWxsIFwKICAtLXZhbHVlcyBkZXBsb3kvc3RhY2tzL252Y2YtY29t" + + "cHV0ZS1wbGFuZS9vdXQvPGNvbXB1dGUtcGxhbmUtY2x1c3Rlci1uYW1lPi1yZWdpc3Rlci12YWx1" + + "ZXMueWFtbCBcCiAgLS1rdWJlLWNvbnRleHQgPGNvbXB1dGUtcGxhbmUtY29udGV4dD4gXAogIC0t" + + "Y2x1c3Rlci1uYW1lIDxjb21wdXRlLXBsYW5lLWNsdXN0ZXItbmFtZT4KYGBgCgpSZWdpc3RyYXRp" + + "b24gc2VsZWN0cyB0aGUgcHJvZmlsZSdzIGluLWNsdXN0ZXIgb3IgY29tcHV0ZS1yZWFjaGFibGUg" + + "ZW5kcG9pbnRzCmZyb20gdGhlIGNvbXB1dGUgY29udGV4dCBhbmQgcHJvYmVzIGl0cyBKV0tTLiBE" + + "byBub3QgcmVwbGFjZSBwcm9maWxlIGVuZHBvaW50cwp3aXRoIGhhbmQtYXV0aG9yZWQgSGVsbWZp" + + "bGUgZW5kcG9pbnQgdmFsdWVzLgoKIyMgUHVsbCBTZWNyZXRzCgpDcmVhdGUgdGhlIGNvbnRyb2wt" + + "cGxhbmUgc2VjcmV0IGluIHRoZXNlIG5hbWVzcGFjZXMgb24gdGhlIGNvbnRyb2wtcGxhbmUKY29u" + + "dGV4dDoKCmBgYHRleHQKY2Fzc2FuZHJhLXN5c3RlbSBuYXRzLXN5c3RlbSBudmNmIGFwaS1rZXlz" + + "IGVzcyBzaXMgdmF1bHQtc3lzdGVtIGNlcnQtbWFuYWdlcgpgYGAKCk9uIHRoZSBjb21wdXRlIGNv" + + "bnRleHQsIGNyZWF0ZSB0aGUgc2VjcmV0IG9ubHkgaW4gYG52Y2Etb3BlcmF0b3JgIGFuZCByZWZl" + + "cmVuY2UKaXQgdGhyb3VnaCBgZ2xvYmFsLmltYWdlUHVsbFNlY3JldHNgIGluIHRoZSBjb21wdXRl" + + "LXBsYW5lIGVudmlyb25tZW50LiBUaGUgY2hhcnQKYW5kIG9wZXJhdG9yIHVzZSBpdCBpbiBgbnZj" + + "YS1vcGVyYXRvcmAgYW5kIG1pcnJvciBpdCB0byBgbnZjYS1zeXN0ZW1gLiBEbyBub3QgYWRkCmVp" + + "dGhlciBuYW1lc3BhY2UgdG8gdGhlIGNvbnRyb2wtcGxhbmUgbGlzdC4gRm9yIGNvbW1hbmRzIGFu" + + "ZCBwb2xpY3kgZXhhbXBsZXMsCnNlZSBbcHVsbC1zZWNyZXRzLm1kXShwdWxsLXNlY3JldHMubWQp" + + "LgoKIyMgVmVyaWZpY2F0aW9uCgpVc2UgdGhlIGV4cGxpY2l0IEdhdGV3YXkgbmFtZSBhbmQgbmFt" + + "ZXNwYWNlOgoKYGBgYmFzaAprdWJlY3RsIC0tY29udGV4dCA8Y29udHJvbC1wbGFuZS1jb250ZXh0" + + "PiBnZXQgZ2F0ZXdheSBudmNmLWdhdGV3YXkgXAogIC1uIGVudm95LWdhdGV3YXkgLW8gd2lkZQpr" + + "dWJlY3RsIC0tY29udGV4dCA8Y29udHJvbC1wbGFuZS1jb250ZXh0PiBnZXQgdGNwcm91dGUgLW4g" + + "ZW52b3ktZ2F0ZXdheQprdWJlY3RsIC0tY29udGV4dCA8Y29tcHV0ZS1wbGFuZS1jb250ZXh0PiBy" + + "b2xsb3V0IHN0YXR1cyBcCiAgZGVwbG95bWVudC9udmNhLW9wZXJhdG9yIC1uIG52Y2Etb3BlcmF0" + + "b3IgLS10aW1lb3V0PTEwbQprdWJlY3RsIC0tY29udGV4dCA8Y29tcHV0ZS1wbGFuZS1jb250ZXh0" + + "PiB3YWl0IFwKICBudmNmYmFja2VuZC88Y29tcHV0ZS1wbGFuZS1jbHVzdGVyLW5hbWU+IC1uIG52" + + "Y2Etb3BlcmF0b3IgXAogIC0tZm9yPWpzb25wYXRoPSd7LnN0YXR1cy5hZ2VudFN0YXR1c30nPWhl" + + "YWx0aHkgLS10aW1lb3V0PTEwbQprdWJlY3RsIC0tY29udGV4dCA8Y29tcHV0ZS1wbGFuZS1jb250" + + "ZXh0PiBnZXQgc2VjcmV0IDxwdWxsLXNlY3JldD4gLW4gbnZjYS1zeXN0ZW0KYGBgCgojIyBUZWFy" + + "ZG93bgoKRGVzdHJveSBhbmQgZGVyZWdpc3RlciBldmVyeSBjb21wdXRlIHBsYW5lIGJlZm9yZSB0" + + "aGUgY29udHJvbCBwbGFuZS4gQm90aApoYW5kb2ZmcyBjYW4gZGVzdHJveSB0aGUgY29udHJvbCBw" + + "bGFuZSwgc28gYXBwbHkgdGhpcyBwcmVmbGlnaHQgYmVmb3JlIGVpdGhlcgpvbmUuIFByZXNlcnZl" + + "IHRoZSBgY2VydC1tYW5hZ2VyYCBuYW1lc3BhY2UgYnkgZGVmYXVsdC4gTmFtZXNwYWNlIHByZXNl" + + "cnZhdGlvbgpkb2VzIG5vdCBwcmVzZXJ2ZSB0aGUgSGVsbSByZWxlYXNlLiBJZGVudGlmeSB3aGV0" + + "aGVyIGNlcnQtbWFuYWdlciBpcyBleHRlcm5hbC4KRm9yIGFuIGV4dGVybmFsIGluc3RhbGxhdGlv" + + "biwgcmVxdWlyZSBlZmZlY3RpdmUgYGNlcnRNYW5hZ2VyLmVuYWJsZWQ6IGZhbHNlYAphbmQgYWJv" + + "cnQgaWYgaXQgaXMgdHJ1ZS4gRm9yIGFuIGludGVuZGVkIHN0YWNrLW1hbmFnZWQgcmVsZWFzZSB3" + + "aXRoIGVmZmVjdGl2ZQpgY2VydE1hbmFnZXIuZW5hYmxlZDogdHJ1ZWAsIHZlcmlmeSBtYXRjaGlu" + + "ZyBzdGFjayBIZWxtIHJlbGVhc2UgbWV0YWRhdGEgYW5kCmFib3J0IG9uIG1pc3Npbmcgb3IgbWlz" + + "bWF0Y2hlZCBldmlkZW5jZS4gT25seSBwbGFuIG5hbWVzcGFjZSByZW1vdmFsIGFmdGVyCnZlcmlm" + + "eWluZyBuYW1lc3BhY2UgcHJvdmVuYW5jZSBhbmQgZ2V0dGluZyBleHBsaWNpdCBjb25maXJtYXRp" + + "b247IG90aGVyd2lzZQpkbyBub3QgZGVsZXRlIGl0LgoKRm9yIHRoZSBIZWxtZmlsZSB2YWx1ZXMg" + + "ZmxvdywgcmV0YWluIGVhY2ggcmVnaXN0cmF0aW9uIHZhbHVlcyBmaWxlIHVudGlsCmNsZWFudXAg" + + "aXMgdmVyaWZpZWQ6CgpgYGBiYXNoCm1ha2UgLUMgZGVwbG95L3N0YWNrcy9udmNmLWNvbXB1dGUt" + + "cGxhbmUgZGVzdHJveSBcCiAgQ0xVU1RFUl9OQU1FPTxjbHVzdGVyLW5hbWU+IFwKICBIRUxNRklM" + + "RV9FTlY9PGVudj4gXAogIEtVQkVDT05GSUdfRklMRT08Y29tcHV0ZS1wbGFuZS1rdWJlY29uZmln" + + "PgoKPG52Y2YtY2xpPiAtLWNvbmZpZyA8Y29uZmlnPiBjbHVzdGVyIGRlbGV0ZSBcCiAgLS1jbHVz" + + "dGVyLWlkIDxjbHVzdGVyLWlkLWZyb20tcmVnaXN0cmF0aW9uLXZhbHVlcz4gXAogIC0tbmNhLWlk" + + "IDxuY2EtaWQ+IFwKICAtLWlnbm9yZS1taXNzaW5nCmBgYAoKUmVhZCBgY2x1c3RlcklEYCBhbmQg" + + "YG5jYUlEYCBmcm9tCmBkZXBsb3kvc3RhY2tzL252Y2YtY29tcHV0ZS1wbGFuZS9yZWdpc3RyYXRp" + + "b24vPGNsdXN0ZXItbmFtZT4tcmVnaXN0ZXItdmFsdWVzLnlhbWxgLgpTaG93IHRoZSBleGFjdCBj" + + "bHVzdGVyIElEIGFuZCBnZXQgY29uZmlybWF0aW9uIGJlZm9yZSBgY2x1c3RlciBkZWxldGVgLiBS" + + "ZXBlYXQKY29tcHV0ZSBkZXN0cm95IGFuZCBkZXJlZ2lzdHJhdGlvbiBmb3IgZXZlcnkgY29tcHV0" + + "ZSBjbHVzdGVyLCB0aGVuIGRlc3Ryb3kgdGhlCmNvbnRyb2wgcGxhbmUuCgpgYGBiYXNoCktVQkVD" + + "T05GSUc9PGNvbnRyb2wtcGxhbmUta3ViZWNvbmZpZz4gXAptYWtlIC1DIGRlcGxveS9zdGFja3Mv" + + "c2VsZi1tYW5hZ2VkIGRlc3Ryb3kgXAogIEhFTE1GSUxFX0VOVj08ZW52PiBcCiAgS1VCRUNPTkZJ" + + "R19GSUxFPTxjb250cm9sLXBsYW5lLWt1YmVjb25maWc+CmBgYAoKQm90aCBgS1VCRUNPTkZJR2Ag" + + "YW5kIGBLVUJFQ09ORklHX0ZJTEVgIGFyZSByZXF1aXJlZCBvbiB0aGUgY29udHJvbC1wbGFuZQpk" + + "ZXN0cm95IGJlY2F1c2UgaXRzIG5hbWVzcGFjZSBjbGVhbnVwIHVzZXMgYW1iaWVudCBga3ViZWN0" + + "bGAuCgpGb3IgdGhlIENMSSBwcm9maWxlIGZsb3csIGtlZXAKYGRlcGxveS9zdGFja3MvbnZjZi1j" + + "b21wdXRlLXBsYW5lL291dC88Y2x1c3Rlci1uYW1lPi1yZWdpc3Rlci12YWx1ZXMueWFtbGAKdW50" + + "aWwgdGVhcmRvd24gY29tcGxldGVzIGJlY2F1c2UgYGRvd25gIHJlYWRzIGl0cyBjbHVzdGVyIElE" + + "LiBGaXJzdCBxdWVyeSB0aGUKbGl2ZSByZWdpc3RyYXRpb24gc2V0IHdpdGggdGhlIHNhbWUgY29t" + + "cGxldGUgcGVyc2lzdGVudCBwcmVmaXg6CgpgYGBiYXNoCm52Y2YtY2xpIC0tY29uZmlnIDxjb25m" + + "aWc+IHNlbGYtaG9zdGVkIFwKICAtLWNvbnRyb2wtcGxhbmUtc3RhY2sgZGVwbG95L3N0YWNrcy9z" + + "ZWxmLW1hbmFnZWQgXAogIC0tY29tcHV0ZS1wbGFuZS1zdGFjayBkZXBsb3kvc3RhY2tzL252Y2Yt" + + "Y29tcHV0ZS1wbGFuZSBcCiAgLS1lbnYgPGVudj4gXAogIC0tcGxhaW4gXAogIC0tY29udHJvbC1w" + + "bGFuZS1jb250ZXh0IDxjb250cm9sLXBsYW5lLWNvbnRleHQ+IFwKICAtLWNvbXB1dGUtcGxhbmUt" + + "Y29udGV4dCA8Y29tcHV0ZS1wbGFuZS1jb250ZXh0PiBcCiAgLS1pY21zLXVybCA8Y29tcHV0ZS1y" + + "ZWFjaGFibGUtaWNtcy11cmw+IFwKICBzdGF0dXMgXAogIC0tY2x1c3Rlci1uYW1lIDxjb21wdXRl" + + "LXBsYW5lLWNsdXN0ZXItbmFtZT4gXAogIC0tbmNhLWlkIDxuY2EtaWQ+CmBgYAoKU2hvdyB0aGUg" + + "cmVnaXN0ZXJlZCBjb21wdXRlLXBsYW5lIGxpc3QuIE5hbWVkLWNsdXN0ZXIgYGRvd24gLS1wbGFu" + + "LW9ubHlgIGRvZXMKbm90IHF1ZXJ5IElDTVMsIHNvIGl0IHByZXZpZXdzIG9ubHkgdGhhdCBjb21w" + + "dXRlIHBsYW5lIGFuZCBjYW5ub3Qgc2hvdyB0aGUKY29uZGl0aW9uYWwgY29udHJvbC1wbGFuZSBy" + + "ZW1vdmFsLiBJZiB0aGUgdGFyZ2V0IGlzIHRoZSBsYXN0IHJlZ2lzdGVyZWQKY2x1c3RlciwgcmVh" + + "bCBgZG93bmAgYWxzbyBkZXN0cm95cyB0aGUgY29udHJvbCBwbGFuZS4gR2V0IGV4cGxpY2l0IGNv" + + "bmZpcm1hdGlvbgpmb3IgYm90aCByZW1vdmFscyBiZWZvcmUgY29udGludWluZy4gVGhlbiBwcmV2" + + "aWV3IGFuZCBleGVjdXRlIHdpdGggdGhlIHNhbWUKcHJlZml4OgoKYGBgYmFzaApudmNmLWNsaSAt" + + "LWNvbmZpZyA8Y29uZmlnPiBzZWxmLWhvc3RlZCBcCiAgLS1jb250cm9sLXBsYW5lLXN0YWNrIGRl" + + "cGxveS9zdGFja3Mvc2VsZi1tYW5hZ2VkIFwKICAtLWNvbXB1dGUtcGxhbmUtc3RhY2sgZGVwbG95" + + "L3N0YWNrcy9udmNmLWNvbXB1dGUtcGxhbmUgXAogIC0tZW52IDxlbnY+IFwKICAtLXBsYWluIFwK" + + "ICAtLWNvbnRyb2wtcGxhbmUtY29udGV4dCA8Y29udHJvbC1wbGFuZS1jb250ZXh0PiBcCiAgLS1j" + + "b21wdXRlLXBsYW5lLWNvbnRleHQgPGNvbXB1dGUtcGxhbmUtY29udGV4dD4gXAogIC0taWNtcy11" + + "cmwgPGNvbXB1dGUtcmVhY2hhYmxlLWljbXMtdXJsPiBcCiAgZG93biAtLXBsYW4tb25seSBcCiAg" + + "LS1jbHVzdGVyLW5hbWUgPGNvbXB1dGUtcGxhbmUtY2x1c3Rlci1uYW1lPiBcCiAgLS1uY2EtaWQg" + + "PG5jYS1pZD4KCm52Y2YtY2xpIC0tY29uZmlnIDxjb25maWc+IHNlbGYtaG9zdGVkIFwKICAtLWNv" + + "bnRyb2wtcGxhbmUtc3RhY2sgZGVwbG95L3N0YWNrcy9zZWxmLW1hbmFnZWQgXAogIC0tY29tcHV0" + + "ZS1wbGFuZS1zdGFjayBkZXBsb3kvc3RhY2tzL252Y2YtY29tcHV0ZS1wbGFuZSBcCiAgLS1lbnYg" + + "PGVudj4gXAogIC0tcGxhaW4gXAogIC0tY29udHJvbC1wbGFuZS1jb250ZXh0IDxjb250cm9sLXBs" + + "YW5lLWNvbnRleHQ+IFwKICAtLWNvbXB1dGUtcGxhbmUtY29udGV4dCA8Y29tcHV0ZS1wbGFuZS1j" + + "b250ZXh0PiBcCiAgLS1pY21zLXVybCA8Y29tcHV0ZS1yZWFjaGFibGUtaWNtcy11cmw+IFwKICBk" + + "b3duIFwKICAtLWNsdXN0ZXItbmFtZSA8Y29tcHV0ZS1wbGFuZS1jbHVzdGVyLW5hbWU+IFwKICAt" + + "LW5jYS1pZCA8bmNhLWlkPgpgYGAKClJlcGVhdCBgZG93bmAgZm9yIGVhY2ggY29tcHV0ZSBjbHVz" + + "dGVyLiBFYWNoIHJ1biBkZXN0cm95cyB0aGF0IGNvbXB1dGUgcGxhbmUgYW5kCnVucmVnaXN0ZXJz" + + "IGl0cyBJQ01TIHJvdy4gSXQgcmVtb3ZlcyB0aGUgY29udHJvbCBwbGFuZSBvbmx5IGFmdGVyIG5v" + + "IGNsdXN0ZXIKcmVnaXN0cmF0aW9ucyByZW1haW4uClBLBwiWY7xZEjAAABIwAABQSwMEFAAIAAAA" + + "AAAhAAAAAAAAAAAAAAAAADsACQBkYXRhL252Y2Ytc2VsZi1tYW5hZ2VkLWluc3RhbGxhdGlvbi9y" + + "ZWZlcmVuY2VzL2RlYnVnZ2luZy5tZFVUBQABAKbOEiMgRGVidWdnaW5nIFJlZmVyZW5jZQoKUmVj" + + "aXBlcyBmb3IgZGlhZ25vc2luZyBhbmQgZml4aW5nIGNvbW1vbiBOVkNGIHNlbGYtbWFuYWdlZCBz" + + "dGFjayBmYWlsdXJlcy4KCiMjIFF1aWNrIFN0YXR1cyBDb21tYW5kcwoKYGBgYmFzaAojIEFsbCBw" + + "b2RzIGFjcm9zcyBhbGwgbmFtZXNwYWNlcwprdWJlY3RsIGdldCBwb2RzIC1BIC1vIHdpZGUKCiMg" + + "UG9kcyBpbiBhIHNwZWNpZmljIG5hbWVzcGFjZQprdWJlY3RsIGdldCBwb2RzIC1uIDxuYW1lc3Bh" + + "Y2U+CgojIEFsbCBoZWxtIHJlbGVhc2VzCmhlbG0gbGlzdCAtQQoKIyBSZWNlbnQgZXZlbnRzICht" + + "b3N0IHVzZWZ1bCBmb3IgZGlhZ25vc2luZyBmYWlsdXJlcykKa3ViZWN0bCBnZXQgZXZlbnRzIC1u" + + "IDxuYW1lc3BhY2U+IC0tc29ydC1ieT0nLmxhc3RUaW1lc3RhbXAnCgojIERlc2NyaWJlIGEgc3Bl" + + "Y2lmaWMgcG9kIChzaG93cyBldmVudHMsIGNvbmRpdGlvbnMsIHZvbHVtZXMpCmt1YmVjdGwgZGVz" + + "Y3JpYmUgcG9kIC1uIDxuYW1lc3BhY2U+IDxwb2QtbmFtZT4KYGBgCgojIyBGYWlsdXJlOiBJbWFn" + + "ZVB1bGxCYWNrT2ZmCgojIyMgU3ltcHRvbXMKCmBgYApOQU1FICAgICAgICAgICBSRUFEWSAgIFNU" + + "QVRVUyAgICAgICAgICAgICBSRVNUQVJUUyAgIEFHRQpjYXNzYW5kcmEtMCAgICAwLzEgICAgIElt" + + "YWdlUHVsbEJhY2tPZmYgICAwICAgICAgICAgIDVtCmBgYAoKRXZlbnRzIHNob3c6CmBgYApGYWls" + + "ZWQgdG8gcHVsbCBpbWFnZSAibnZjci5pby8uLi4vaW1hZ2U6dGFnIjogNDAxIFVuYXV0aG9yaXpl" + + "ZApgYGAKCiMjIyBEaWFnbm9zaXMKCmBgYGJhc2gKIyBDaGVjayB3aGF0IGltYWdlIGlzIGZhaWxp" + + "bmcKa3ViZWN0bCBkZXNjcmliZSBwb2QgLW4gPG5hbWVzcGFjZT4gPHBvZC1uYW1lPiB8IGdyZXAg" + + "LUE1ICJFdmVudHM6IgoKIyBDaGVjayBpZiBwdWxsIHNlY3JldCBleGlzdHMgaW4gdGhlIG5hbWVz" + + "cGFjZQprdWJlY3RsIGdldCBzZWNyZXQgbnZjci1jcmVkcyAtbiA8bmFtZXNwYWNlPgoKIyBDaGVj" + + "ayBpZiB0aGUgcG9kIHNwZWMgaGFzIGltYWdlUHVsbFNlY3JldHMKa3ViZWN0bCBnZXQgcG9kIC1u" + + "IDxuYW1lc3BhY2U+IDxwb2QtbmFtZT4gLW8ganNvbnBhdGg9J3suc3BlYy5pbWFnZVB1bGxTZWNy" + + "ZXRzfScKCiMgQ2hlY2sgaWYgdGhlIFNlcnZpY2VBY2NvdW50IGhhcyBpbWFnZVB1bGxTZWNyZXRz" + + "Cmt1YmVjdGwgZ2V0IHNhIDxzYS1uYW1lPiAtbiA8bmFtZXNwYWNlPiAtbyBqc29ucGF0aD0ney5p" + + "bWFnZVB1bGxTZWNyZXRzfScKYGBgCgojIyMgRml4ZXMKCjEuICoqU2VjcmV0IG1pc3NpbmcgaW4g" + + "bmFtZXNwYWNlKio6IENyZWF0ZSBpdAogICBgYGBiYXNoCiAgIGt1YmVjdGwgY3JlYXRlIHNlY3Jl" + + "dCBkb2NrZXItcmVnaXN0cnkgbnZjci1jcmVkcyBcCiAgICAgLS1kb2NrZXItc2VydmVyPW52Y3Iu" + + "aW8gXAogICAgIC0tZG9ja2VyLXVzZXJuYW1lPSckb2F1dGh0b2tlbicgXAogICAgIC0tZG9ja2Vy" + + "LXBhc3N3b3JkPSIkTkdDX0FQSV9LRVkiIFwKICAgICAtLW5hbWVzcGFjZT08bmFtZXNwYWNlPiBc" + + "CiAgICAgLS1kcnktcnVuPWNsaWVudCAtbyB5YW1sIHwga3ViZWN0bCBhcHBseSAtZiAtCiAgIGBg" + + "YAoKMi4gKipTZWNyZXQgZXhpc3RzIGJ1dCBwb2QgZG9lc24ndCByZWZlcmVuY2UgaXQqKjogVGhl" + + "IGNoYXJ0IG5lZWRzIGBpbWFnZVB1bGxTZWNyZXRzYCBjb25maWd1cmVkIHZpYSBoZWxtZmlsZSB2" + + "YWx1ZXMuIFNlZSBbcHVsbC1zZWNyZXRzLm1kXShwdWxsLXNlY3JldHMubWQpLgoKMy4gKipDaGFy" + + "dCBkb2Vzbid0IHN1cHBvcnQgaW1hZ2VQdWxsU2VjcmV0cyoqIChvcGVuYmFvLCBpbnZvY2F0aW9u" + + "LXNlcnZpY2UsIGVzcy1hcGksIG5vdGFyeS1zZXJ2aWNlKTogUGF0Y2ggU2VydmljZUFjY291bnRz" + + "IGFuZCByZXN0YXJ0IHBvZHMuIFNlZSBbcHVsbC1zZWNyZXRzLm1kXShwdWxsLXNlY3JldHMubWQp" + + "LgoKNC4gKipXcm9uZyBjcmVkZW50aWFscyBpbiBzZWNyZXQqKjogRGVsZXRlIGFuZCByZWNyZWF0" + + "ZQogICBgYGBiYXNoCiAgIGt1YmVjdGwgZGVsZXRlIHNlY3JldCBudmNyLWNyZWRzIC1uIDxuYW1l" + + "c3BhY2U+CiAgICMgUmVjcmVhdGUgd2l0aCBjb3JyZWN0IGNyZWRlbnRpYWxzCiAgIGBgYAoKIyMg" + + "RmFpbHVyZTogSW5pdDowLzEgU3R1Y2sgKFZhdWx0IEFnZW50KQoKIyMjIFN5bXB0b21zCgpTZXJ2" + + "aWNlIHBvZHMgc3R1Y2sgaW4gYEluaXQ6MC8xYCBmb3IgbWludXRlczoKYGBgCk5BTUUgICAgICAg" + + "ICAgICAgICAgICAgICAgICBSRUFEWSAgIFNUQVRVUyAgICAgUkVTVEFSVFMgICBBR0UKbnZjZi1h" + + "cGktN2Y0Yzc2Zjc4OC00NHZsdCAgMC8yICAgICBJbml0OjAvMSAgIDAgICAgICAgICAgMTBtCmBg" + + "YAoKIyMjIERpYWdub3NpcwoKVGhlIGluaXQgY29udGFpbmVyIGlzIHRoZSB2YXVsdC1hZ2VudC1p" + + "bml0IGluamVjdG9yIHdhaXRpbmcgZm9yIE9wZW5CYW8uCgpgYGBiYXNoCiMgQ2hlY2sgT3BlbkJh" + + "byBwb2RzCmt1YmVjdGwgZ2V0IHBvZHMgLW4gdmF1bHQtc3lzdGVtCgojIENoZWNrIGlmIE9wZW5C" + + "YW8gbWlncmF0aW9uIGpvYiByYW4Ka3ViZWN0bCBnZXQgam9icyAtbiB2YXVsdC1zeXN0ZW0KCiMg" + + "Q2hlY2sgT3BlbkJhbyBwb2QgbG9ncwprdWJlY3RsIGxvZ3MgLW4gdmF1bHQtc3lzdGVtIG9wZW5i" + + "YW8tc2VydmVyLTAgLWMgb3BlbmJhbwoKIyBDaGVjayBpbml0IGNvbnRhaW5lciBsb2dzIG9uIHRo" + + "ZSBzdHVjayBwb2QKa3ViZWN0bCBsb2dzIC1uIDxuYW1lc3BhY2U+IDxwb2QtbmFtZT4gLWMgdmF1" + + "bHQtYWdlbnQtaW5pdApgYGAKCiMjIyBGaXhlcwoKMS4gKipPcGVuQmFvIHBvZHMgbm90IHJ1bm5p" + + "bmcqKjogQ2hlY2sgdGhlaXIgZXZlbnRzIGZvciBpbWFnZSBwdWxsIGlzc3VlcywgcmVzb3VyY2Ug" + + "aXNzdWVzLCBldGMuCgoyLiAqKk9wZW5CYW8gbWlncmF0aW9uIGpvYiBkaWRuJ3QgcnVuKio6IFRo" + + "aXMgaGFwcGVucyB3aGVuIGBoZWxtZmlsZSBzeW5jYCB3YXMgaW50ZXJydXB0ZWQuIERlc3Ryb3kg" + + "YW5kIHJlLXN5bmMgb3BlbmJhbzoKICAgYGBgYmFzaAogICBIRUxNRklMRV9FTlY9PGVudj4gaGVs" + + "bWZpbGUgLS1zZWxlY3RvciBuYW1lPW9wZW5iYW8tc2VydmVyIGRlc3Ryb3kKICAga3ViZWN0bCBk" + + "ZWxldGUgbmFtZXNwYWNlIHZhdWx0LXN5c3RlbQogICBrdWJlY3RsIGNyZWF0ZSBuYW1lc3BhY2Ug" + + "dmF1bHQtc3lzdGVtCiAgICMgUmUtY3JlYXRlIHB1bGwgc2VjcmV0IGlmIG5lZWRlZAogICBIRUxN" + + "RklMRV9FTlY9PGVudj4gaGVsbWZpbGUgLS1zZWxlY3RvciBuYW1lPW9wZW5iYW8tc2VydmVyIHN5" + + "bmMKICAgYGBgCgozLiAqKk9wZW5CYW8gcG9kcyBydW5uaW5nIGJ1dCBub3QgaW5pdGlhbGl6ZWQq" + + "KjogQ2hlY2sgdW5zZWFsIHN0YXR1czoKICAgYGBgYmFzaAogICBrdWJlY3RsIGV4ZWMgLW4gdmF1" + + "bHQtc3lzdGVtIG9wZW5iYW8tc2VydmVyLTAgLWMgb3BlbmJhbyAtLSBiYW8gc3RhdHVzCiAgIGBg" + + "YAoKNC4gKipgdmF1bHQtYWdlbnQtaW5pdGAgbG9ncyBgYXV0aC9qd3QvbG9naW5gIC0+IGA0MDAg" + + "Li4uIG5vIGtub3duIGtleSBzdWNjZXNzZnVsbHkgdmFsaWRhdGVkIHRoZSB0b2tlbiBzaWduYXR1" + + "cmVgKioKICAgKGNvbW1vbiBvbiBBS1MsIGFuZCBvbiBhbnkgY2x1c3RlciB3aG9zZSBPSURDIGlz" + + "c3VlciBwdWJsaXNoZXMgYSByb3RhdGluZyBtdWx0aS1rZXkgSldLUyk6CiAgIHRoZSBPcGVuQmFv" + + "IGBhdXRoL2p3dGAgbWV0aG9kIHdhcyBjb25maWd1cmVkIHdpdGggYSBzaW5nbGUgc3RhdGljIG1v" + + "dW50ZWQgcHVibGljIGtleQogICAoYGp3dF92YWxpZGF0aW9uX3B1YmtleXNgKSBpbnN0ZWFkIG9m" + + "IHRoZSBpc3N1ZXIncyBsaXZlIEpXS1MsIHNvIGl0IGNhbm5vdCB2YWxpZGF0ZSB0aGUKICAgY2x1" + + "c3Rlci1zaWduZWQgU2VydmljZUFjY291bnQgdG9rZW5zIHRoZSB2YXVsdC1hZ2VudHMgcHJlc2Vu" + + "dC4gRXZlcnkgc2VydmljZSdzCiAgIGB2YXVsdC1hZ2VudC1pbml0YCB0aGVuIGxvb3BzIG9uIHRo" + + "YXQgNDAwIGFuZCB0aGUgcG9kIG5ldmVyIGxlYXZlcyBgSW5pdDowLzFgLiBUaGlzIGlzIHRoZQog" + + "ICBiZWhhdmlvciBvZiB0aGUgYmFzZSBkZWZhdWx0IGBvcGVuYmFvLm1pZ3JhdGlvbnMuaXNzdWVy" + + "RGlzY292ZXJ5LmVuYWJsZWQ6IGZhbHNlYDsgdGhlCiAgIG1pZ3JhdGlvbiBsb2cgc2hvd3MgYE9J" + + "REMgaXNzdWVyIGRpc2NvdmVyeSBpcyBkaXNhYmxlZC4gVXNpbmcgU2VydmljZUFjY291bnQgaXNz" + + "dWVyIGFuZAogICBtb3VudGVkIHB1YmxpYyBrZXkgZmFsbGJhY2tgLiBFbmFibGUgaXNzdWVyIGRp" + + "c2NvdmVyeSBzbyB0aGUgbWlncmF0aW9uIHVzZXMgdGhlIGxpdmUgSldLUywKICAgdGhlbiByZS1y" + + "dW4gaXQ6CiAgIGBgYGJhc2gKICAgIyBJbiB5b3VyIGVudiB2YWx1ZXMgKGUuZy4gZW52aXJvbm1l" + + "bnRzLzxlbnY+LnlhbWwpLCBzZXQ6CiAgICMgICBvcGVuYmFvOgogICAjICAgICBtaWdyYXRpb25z" + + "OgogICAjICAgICAgIGlzc3VlckRpc2NvdmVyeToKICAgIyAgICAgICAgIGVuYWJsZWQ6IHRydWUK" + + "ICAga3ViZWN0bCBkZWxldGUgam9iIC1uIHZhdWx0LXN5c3RlbSBvcGVuYmFvLXNlcnZlci1taWdy" + + "YXRpb25zCiAgIEhFTE1GSUxFX0VOVj08ZW52PiBoZWxtZmlsZSAtLXNlbGVjdG9yIG5hbWU9b3Bl" + + "bmJhby1zZXJ2ZXIgc3luYwogICBgYGAKICAgVGhlIG1pZ3JhdGlvbiBsb2cgc2hvdWxkIHRoZW4g" + + "c2hvdyBgUmVjZWl2ZWQgZGlzY292ZXJ5IGRvY3VtZW50IGZyb20KICAgLi4uLy53ZWxsLWtub3du" + + "L29wZW5pZC1jb25maWd1cmF0aW9uYCBhbmQgYEZpbmFsIE9wZW5CYW8gSldUIEpXS1MgVVJMIHNl" + + "dCB0bzoKICAgLi4uL29wZW5pZC92MS9qd2tzYCwgYW5kIHRoZSBzZXJ2aWNlIHBvZHMgYXV0aGVu" + + "dGljYXRlIGFuZCByZWFjaCBSZWFkeSB3aXRoaW4gfjEgbWluLgogICBBS1MgY2x1c3RlcnMgd2l0" + + "aCB0aGUgY2x1c3RlciBPSURDIGlzc3VlciBlbmFibGVkICh0aGUgYGFrcy1jbHVzdGVyYCBkZWZh" + + "dWx0KSBhbHdheXMgbmVlZAogICB0aGlzIGJlY2F1c2UgdGhlIHN0YXRpYy1wdWJrZXkgZmFsbGJh" + + "Y2sgY2Fubm90IG1hdGNoIHRoZSBpc3N1ZXIncyByb3RhdGluZyBzaWduaW5nIGtleXMuCgojIyBG" + + "YWlsdXJlOiBPT01LaWxsZWQgb24gQ2Fzc2FuZHJhCgojIyMgU3ltcHRvbXMKCmBgYApOQU1FICAg" + + "ICAgICAgIFJFQURZICAgU1RBVFVTICAgIFJFU1RBUlRTICAgQUdFCmNhc3NhbmRyYS0wICAgMC8x" + + "ICAgICBPT01LaWxsZWQgIDMgICAgICAgICAxMG0KYGBgCgojIyMgRGlhZ25vc2lzCgpgYGBiYXNo" + + "Cmt1YmVjdGwgZGVzY3JpYmUgcG9kIC1uIGNhc3NhbmRyYS1zeXN0ZW0gY2Fzc2FuZHJhLTAgfCBn" + + "cmVwIC1BMyAiTGFzdCBTdGF0ZSIKYGBgCgojIyMgRml4CgpPdmVycmlkZSBDYXNzYW5kcmEgcmVz" + + "b3VyY2VzIHZpYSBoZWxtZmlsZSB2YWx1ZXMuIFNlZSBFeGFtcGxlIDEgaW4KW2V4YW1wbGVzLm1k" + + "XSguLi9leGFtcGxlcy5tZCkuCgpgYGB5YW1sCi0gY2Fzc2FuZHJhOgogICAgcmVzb3VyY2VzOgog" + + "ICAgICBsaW1pdHM6CiAgICAgICAgY3B1OiAiOCIKICAgICAgICBtZW1vcnk6IDgxOTJNaQogICAg" + + "ICByZXF1ZXN0czoKICAgICAgICBjcHU6ICIyIgogICAgICAgIG1lbW9yeTogNDA5Nk1pCmBgYAoK" + + "Tm90ZTogYHJlc291cmNlUHJlc2V0YCBpcyBub3QgYXZhaWxhYmxlIGluIHRoZSBOVkNGIGNhc3Nh" + + "bmRyYSB3cmFwcGVyIGNoYXJ0LiBVc2UgZXhwbGljaXQgYHJlc291cmNlc2AuCgojIyBGYWlsdXJl" + + "OiBQb2RzIFN0dWNrIGluIFBlbmRpbmcKCiMjIyBTeW1wdG9tcwoKYGBgCk5BTUUgICAgICAgICAg" + + "UkVBRFkgICBTVEFUVVMgICAgUkVTVEFSVFMgICBBR0UKY2Fzc2FuZHJhLTAgICAwLzEgICAgIFBl" + + "bmRpbmcgICAwICAgICAgICAgIDEwbQpgYGAKCiMjIyBEaWFnbm9zaXMKCmBgYGJhc2gKIyBDaGVj" + + "ayBldmVudHMgZm9yIHNjaGVkdWxpbmcgZmFpbHVyZXMKa3ViZWN0bCBkZXNjcmliZSBwb2QgLW4g" + + "PG5hbWVzcGFjZT4gPHBvZC1uYW1lPgoKIyBDb21tb24gY2F1c2VzOgojIC0gIjAvMTIgbm9kZXMg" + + "YXJlIGF2YWlsYWJsZTogMTIgbm9kZShzKSBkaWRuJ3QgbWF0Y2ggUG9kJ3Mgbm9kZSBhZmZpbml0" + + "eSIKIyAtICIwLzEyIG5vZGVzIGFyZSBhdmFpbGFibGU6IDEyIEluc3VmZmljaWVudCBtZW1vcnki" + + "CiMgLSAicGVyc2lzdGVudHZvbHVtZWNsYWltIG5vdCBmb3VuZCIKYGBgCgojIyMgRml4ZXMKCjEu" + + "ICoqTm9kZSBzZWxlY3RvciBtaXNtYXRjaCoqOiBDaGVjayBgbm9kZVNlbGVjdG9yc2AgaW4gZW52" + + "aXJvbm1lbnQgZmlsZQogICBgYGBiYXNoCiAgIGt1YmVjdGwgZ2V0IG5vZGVzIC0tc2hvdy1sYWJl" + + "bHMgfCBncmVwIG52Y2YKICAgYGBgCgoyLiAqKlN0b3JhZ2UgY2xhc3Mgbm90IGZvdW5kKio6IENo" + + "ZWNrIHN0b3JhZ2UgY2xhc3MgZXhpc3RzCiAgIGBgYGJhc2gKICAga3ViZWN0bCBnZXQgc3RvcmFn" + + "ZWNsYXNzCiAgIGBgYAoKMy4gKipJbnN1ZmZpY2llbnQgcmVzb3VyY2VzKio6IENoZWNrIG5vZGUg" + + "Y2FwYWNpdHkKICAgYGBgYmFzaAogICBrdWJlY3RsIGRlc2NyaWJlIG5vZGUgPG5vZGUtbmFtZT4g" + + "fCBncmVwIC1BNSAiQWxsb2NhdGVkIHJlc291cmNlcyIKICAgYGBgCgojIyBGYWlsdXJlOiBIZWxt" + + "IFJlbGVhc2UgaW4gRmFpbGVkIFN0YXRlCgojIyMgU3ltcHRvbXMKCmBgYGJhc2gKaGVsbSBsaXN0" + + "IC1BCiMgU2hvd3MgcmVsZWFzZSB3aXRoIFNUQVRVUzogZmFpbGVkCmBgYAoKUmUtcnVubmluZyBg" + + "aGVsbWZpbGUgc3luY2AgYXBwZWFycyB0byBzdWNjZWVkIGJ1dCBzZXJ2aWNlcyBkb24ndCB3b3Jr" + + "IChtaWdyYXRpb25zIHNraXBwZWQpLgoKIyMjIERpYWdub3NpcwoKYGBgYmFzaApoZWxtIGhpc3Rv" + + "cnkgPHJlbGVhc2UtbmFtZT4gLW4gPG5hbWVzcGFjZT4KYGBgCgojIyMgRml4CgpNdXN0IGRlc3Ry" + + "b3kgdGhlIGZhaWxlZCByZWxlYXNlIGFuZCByZS1zeW5jIChub3QganVzdCBhcHBseSk6CgpgYGBi" + + "YXNoCkhFTE1GSUxFX0VOVj08ZW52PiBoZWxtZmlsZSAtLXNlbGVjdG9yIG5hbWU9PHJlbGVhc2U+" + + "IGRlc3Ryb3kKIyBJZiBuYW1lc3BhY2UgbmVlZHMgY2xlYW51cDoKa3ViZWN0bCBkZWxldGUgbmFt" + + "ZXNwYWNlIDxuYW1lc3BhY2U+Cmt1YmVjdGwgY3JlYXRlIG5hbWVzcGFjZSA8bmFtZXNwYWNlPgoj" + + "IFJlLWNyZWF0ZSBwdWxsIHNlY3JldCBpZiBuZWVkZWQKSEVMTUZJTEVfRU5WPTxlbnY+IGhlbG1m" + + "aWxlIC0tc2VsZWN0b3IgbmFtZT08cmVsZWFzZT4gc3luYwpgYGAKCiMjIEZhaWx1cmU6IEFjY291" + + "bnQgQm9vdHN0cmFwIEpvYiBGYWlsZWQKCiMjIyBTeW1wdG9tcwoKU2VydmljZXMgZGVwbG95IGJ1" + + "dCBmdW5jdGlvbnMgY2FuJ3QgYmUgY3JlYXRlZC4gRXZlbnRzIHNob3cgYm9vdHN0cmFwIGpvYiBm" + + "YWlsdXJlLgoKIyMjIERpYWdub3NpcwoKYGBgYmFzaAojIENoZWNrIGJvb3RzdHJhcCBqb2Igc3Rh" + + "dHVzCmt1YmVjdGwgZ2V0IGpvYnMgLW4gbnZjZgoKIyBHZXQgbG9ncyAoam9iIGF1dG8tZGVsZXRl" + + "cyBhZnRlciB+NSBtaW51dGVzKQprdWJlY3RsIGxvZ3Mgam9iL252Y2YtYXBpLWFjY291bnQtYm9v" + + "dHN0cmFwIC1uIG52Y2YKCiMgQ2hlY2sgQVBJIGxvZ3MKa3ViZWN0bCBsb2dzIC1uIG52Y2YgLWwg" + + "YXBwLmt1YmVybmV0ZXMuaW8vbmFtZT1udmNmLWFwaSAtLXRhaWw9MTAwCmBgYAoKIyMjIENvbW1v" + + "biBDYXVzZXMKCjEuICoqV3JvbmcgYmFzZTY0IGNyZWRlbnRpYWxzKio6IENyZWRlbnRpYWxzIGlu" + + "IGBzZWNyZXRzLzxlbnY+LXNlY3JldHMueWFtbGAgbXVzdCBiZSBgJG9hdXRodG9rZW46QVBJX0tF" + + "WWAgYmFzZTY0LWVuY29kZWQsIG5vdCBqdXN0IHRoZSBBUEkga2V5CiAgIGBgYGJhc2gKICAgIyBW" + + "ZXJpZnkgeW91ciBlbmNvZGVkIGNyZWRlbnRpYWwKICAgZWNobyAnWU9VUl9CQVNFNjRfU1RSSU5H" + + "JyB8IGJhc2U2NCAtZAogICAjIFNob3VsZCBvdXRwdXQ6ICRvYXV0aHRva2VuOm52YXBpLXh4eHh4" + + "CiAgIGBgYAoKMi4gKipSZWdpc3RyeSB1bnJlYWNoYWJsZSoqOiBBUEkgY2FuJ3QgcmVhY2ggdGhl" + + "IHJlZ2lzdHJ5IHNwZWNpZmllZCBpbiBgYWNjb3VudEJvb3RzdHJhcC5yZWdpc3RyeUNyZWRlbnRp" + + "YWxzYAoKIyMjIEZpeAoKRml4IGNyZWRlbnRpYWxzIGluIHNlY3JldHMgZmlsZSwgdGhlbiByZWNv" + + "dmVyIHNlcnZpY2VzIHdpdGhvdXQgZGVzdHJveWluZyBkZXBlbmRlbmNpZXM6CgpgYGBiYXNoCkhF" + + "TE1GSUxFX0VOVj08ZW52PiBoZWxtZmlsZSAtLXNlbGVjdG9yIHJlbGVhc2UtZ3JvdXA9c2Vydmlj" + + "ZXMgZGVzdHJveQprdWJlY3RsIGRlbGV0ZSBuYW1lc3BhY2UgbnZjZiBhcGkta2V5cyBlc3Mgc2lz" + + "IC0taWdub3JlLW5vdC1mb3VuZAprdWJlY3RsIGNyZWF0ZSBuYW1lc3BhY2UgbnZjZiAmJiBrdWJl" + + "Y3RsIGNyZWF0ZSBuYW1lc3BhY2UgYXBpLWtleXMgJiYgXAogIGt1YmVjdGwgY3JlYXRlIG5hbWVz" + + "cGFjZSBlc3MgJiYga3ViZWN0bCBjcmVhdGUgbmFtZXNwYWNlIHNpcwojIFJlLWNyZWF0ZSBwdWxs" + + "IHNlY3JldHMgaWYgbmVlZGVkCkhFTE1GSUxFX0VOVj08ZW52PiBoZWxtZmlsZSAtLXNlbGVjdG9y" + + "IHJlbGVhc2UtZ3JvdXA9c2VydmljZXMgc3luYwpgYGAKCiMjIEZhaWx1cmU6IE5WQ0EgQ2xlYW51" + + "cCBTdHVjayAoRmluYWxpemVycykKCiMjIyBTeW1wdG9tcwoKQ29tcHV0ZS1wbGFuZSBjbGVhbnVw" + + "IGhhbmdzLiBOYW1lc3BhY2VzCnN0dWNrIGluIGBUZXJtaW5hdGluZ2A6CgpgYGBiYXNoCmt1YmVj" + + "dGwgZ2V0IG5zCiMgbnZjYS1vcGVyYXRvciAgICBUZXJtaW5hdGluZyAgIDEwbQojIG52Y2YtYmFj" + + "a2VuZCAgICAgVGVybWluYXRpbmcgICAxMG0KYGBgCgojIyMgRml4CgpSdW4gdGhpcyBvbmx5IGFn" + + "YWluc3QgdGhlIGNvbXB1dGUgY29udGV4dCwgYWZ0ZXIgdGhlIG5vcm1hbCBjb21wdXRlLXBsYW5l" + + "CnRlYXJkb3duIGhhcyBmYWlsZWQuIFJlbW92ZSBmaW5hbGl6ZXJzIGZyb20gTlZDRkJhY2tlbmQg" + + "Y3VzdG9tIHJlc291cmNlcyBhbmQKZm9yY2UtZGVsZXRlIHN0dWNrIG5hbWVzcGFjZXM6CgpgYGBi" + + "YXNoCmV4cG9ydCBDT01QVVRFX0NPTlRFWFQ9PGNvbXB1dGUtcGxhbmUtY29udGV4dD4KCiMgUmVt" + + "b3ZlIGZpbmFsaXplcnMgZnJvbSBOVkNGQmFja2VuZCByZXNvdXJjZXMKa3ViZWN0bCAtLWNvbnRl" + + "eHQgIiRDT01QVVRFX0NPTlRFWFQiIGdldCBudmNmYmFja2VuZHMgLUEgLW8ganNvbiB8IFwKICBq" + + "cSAnLml0ZW1zW10gfCAubWV0YWRhdGEubmFtZXNwYWNlICsgIi8iICsgLm1ldGFkYXRhLm5hbWUn" + + "IC1yIHwgXAogIHhhcmdzIC1Je30gc2ggLWMgJ2NvbnRleHQ9IiQxIjsgbnM9IiR7MiUlLyp9Ijsg" + + "bmFtZT0iJHsyIyMqL30iOyBrdWJlY3RsIC0tY29udGV4dCAiJGNvbnRleHQiIHBhdGNoIG52Y2Zi" + + "YWNrZW5kICIkbmFtZSIgLW4gIiRucyIgLS10eXBlPW1lcmdlIC1wICJ7XCJtZXRhZGF0YVwiOntc" + + "ImZpbmFsaXplcnNcIjpbXX19IicgXyAiJENPTVBVVEVfQ09OVEVYVCIge30KCiMgRm9yY2UtZGVs" + + "ZXRlIHN0dWNrIG5hbWVzcGFjZXMgYnkgY2xlYXJpbmcgdGhlaXIgZmluYWxpemVycwpmb3IgbnMg" + + "aW4gbnZjYS1vcGVyYXRvciBudmNmLWJhY2tlbmQ7IGRvCiAga3ViZWN0bCAtLWNvbnRleHQgIiRD" + + "T01QVVRFX0NPTlRFWFQiIGdldCBuYW1lc3BhY2UgIiRucyIgLW8ganNvbiAyPi9kZXYvbnVsbCB8" + + "IFwKICAgIGpxICcuc3BlYy5maW5hbGl6ZXJzID0gW10nIHwgXAogICAga3ViZWN0bCAtLWNvbnRl" + + "eHQgIiRDT01QVVRFX0NPTlRFWFQiIHJlcGxhY2UgXAogICAgICAtLXJhdyAiL2FwaS92MS9uYW1l" + + "c3BhY2VzLyRucy9maW5hbGl6ZSIgLWYgLSAyPi9kZXYvbnVsbApkb25lCmBgYAoKIyMgRmFpbHVy" + + "ZTogTlZDQSBPcGVyYXRvciBNaXNzaW5nIG9yIE5vdCBSZWFkeQoKIyMjIFN5bXB0b21zCgpBZnRl" + + "ciBjb21wdXRlLXBsYW5lIGluc3RhbGwgY29tcGxldGVzLCBubyBgbnZjYS1vcGVyYXRvcmAgRGVw" + + "bG95bWVudCBleGlzdHMsIG9yCml0IGV4aXN0cyBidXQgcG9kcyBhcmUgbm90IHJlYWR5OgoKYGBg" + + "YmFzaAprdWJlY3RsIC0tY29udGV4dCA8Y29tcHV0ZS1wbGFuZS1jb250ZXh0PiBnZXQgZGVwbG95" + + "bWVudCBudmNhLW9wZXJhdG9yIFwKICAtbiBudmNhLW9wZXJhdG9yCmt1YmVjdGwgLS1jb250ZXh0" + + "IDxjb21wdXRlLXBsYW5lLWNvbnRleHQ+IGdldCBwb2RzIC1uIG52Y2Etb3BlcmF0b3IKYGBgCgoj" + + "IyMgRGlhZ25vc2lzIGFuZCBGaXhlcwoKRmlyc3QgaWRlbnRpZnkgd2hldGhlciB0aGUgaW5zdGFs" + + "bGF0aW9uIHVzZWQgdGhlIEhlbG1maWxlIHZhbHVlcyBmbG93IG9yIHRoZQpDTEkgcHJvZmlsZSBm" + + "bG93LiBSZS1ydW4gb25seSB0aGF0IGZsb3cncyByZWdpc3RyYXRpb24gYW5kIGluc3RhbGxhdGlv" + + "biBzdGVwcwpmcm9tIFtTcGxpdCBDb21wdXRlLVBsYW5lIEluc3RhbGxhdGlvbl0oY29tcHV0ZS1w" + + "bGFuZS1pbnN0YWxsYXRpb24ubWQpLiBEbyBub3QKc3Vic3RpdHV0ZSBvbmUgaGFuZG9mZiBmb3Ig" + + "dGhlIG90aGVyLgoKSWYgaW5zdGFsbGF0aW9uIHN1Y2NlZWRzIGJ1dCBwb2RzIHN0aWxsIGZhaWws" + + "IGluc3BlY3QgdGhlIGNvbXB1dGUgY29udGV4dDoKCmBgYGJhc2gKa3ViZWN0bCAtLWNvbnRleHQg" + + "PGNvbXB1dGUtcGxhbmUtY29udGV4dD4gZGVzY3JpYmUgZGVwbG95IG52Y2Etb3BlcmF0b3IgXAog" + + "IC1uIG52Y2Etb3BlcmF0b3IKa3ViZWN0bCAtLWNvbnRleHQgPGNvbXB1dGUtcGxhbmUtY29udGV4" + + "dD4gbG9ncyBkZXBsb3ltZW50L252Y2Etb3BlcmF0b3IgXAogIC1uIG52Y2Etb3BlcmF0b3IgLS10" + + "YWlsPTIwMAprdWJlY3RsIC0tY29udGV4dCA8Y29tcHV0ZS1wbGFuZS1jb250ZXh0PiBnZXQgbnZj" + + "ZmJhY2tlbmQgLW4gbnZjYS1vcGVyYXRvcgpgYGAKCkZvciBwcml2YXRlIHJlZ2lzdHJ5IGZhaWx1" + + "cmVzLCB2ZXJpZnkgdGhhdCB0aGUgcHVsbCBzZWNyZXQgZXhpc3RzIGluCmBudmNhLW9wZXJhdG9y" + + "YC4gVGhlIGNoYXJ0IGFuZCBvcGVyYXRvciBtaXJyb3IgaXQgdG8gYG52Y2Etc3lzdGVtYDsgZG8g" + + "bm90IHVzZSBhCmJyb2FkZXIgbWFudWFsIG5hbWVzcGFjZSBsb29wLiBTZWUKW3B1bGwtc2VjcmV0" + + "cy5tZF0ocHVsbC1zZWNyZXRzLm1kI2NvbXB1dGUtcGxhbmUtc2VjcmV0KS4KCiMjIEZhaWx1cmU6" + + "IEdhdGV3YXkgRW5kcG9pbnQgQ2hhbmdlZAoKIyMjIFN5bXB0b21zCgpSZXF1ZXN0cyB0aHJvdWdo" + + "IHRoZSBjb25maWd1cmVkIHJvdXRlIGRvbWFpbiBmYWlsIGFmdGVyIHRoZSBHYXRld2F5IG9yIGl0" + + "cyBsb2FkIGJhbGFuY2VyIGlzIHJlcGxhY2VkLiBUaGUgR2F0ZXdheSByZXBvcnRzIGEgbmV3IGVu" + + "ZHBvaW50LgoKIyMjIERpYWdub3NpcwoKYGBgYmFzaApHQVRFV0FZX0FERFI9JChrdWJlY3RsIC0t" + + "Y29udGV4dCA8Y29udHJvbC1wbGFuZS1jb250ZXh0PiBnZXQgZ2F0ZXdheSBcCiAgbnZjZi1nYXRl" + + "d2F5IC1uIGVudm95LWdhdGV3YXkgXAogIC1vIGpzb25wYXRoPSd7LnN0YXR1cy5hZGRyZXNzZXNb" + + "MF0udmFsdWV9JykKdGVzdCAtbiAiJEdBVEVXQVlfQUREUiIKZGlnICtzaG9ydCAiYXBpLjxkb21h" + + "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" + + "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==" var ( skillDataOnce sync.Once diff --git a/tests/bdd/gateway_examples_test.go b/tests/bdd/gateway_examples_test.go index 5fc9b5f22..d1ab027fb 100644 --- a/tests/bdd/gateway_examples_test.go +++ b/tests/bdd/gateway_examples_test.go @@ -85,6 +85,17 @@ func TestRemoteGatewayExamplesConfigureAWSNLBOnEnvoyService(t *testing.T) { if err != nil { t.Fatalf("read %s: %v", example.path, err) } + providerProbe := bytes.Index(body, []byte("aws eks describe-cluster")) + defaultControllerConfig := bytes.Index( + body, + []byte(`service.beta.kubernetes.io/aws-load-balancer-type: "external"`), + ) + if providerProbe < 0 || defaultControllerConfig < 0 || providerProbe > defaultControllerConfig { + t.Errorf( + "%s does not select the EKS Service controller before presenting the applied EnvoyProxy", + example.path, + ) + } for _, guard := range []string{ `test -n "$GATEWAY_ADDR" || exit 1`, `test -n "$GRPC_GATEWAY_ADDR" || exit 1`, From 356e647a6a1b7a4f1ca1ecceccd17683f86f48a7 Mon Sep 17 00:00:00 2001 From: Mike Camp Date: Tue, 25 Aug 2026 16:03:13 -0400 Subject: [PATCH 6/6] test(self-managed): target applied EnvoyProxy ordering Signed-off-by: Mike Camp --- tests/bdd/gateway_examples_test.go | 14 +++++++++----- 1 file changed, 9 insertions(+), 5 deletions(-) diff --git a/tests/bdd/gateway_examples_test.go b/tests/bdd/gateway_examples_test.go index d1ab027fb..c4e7067b1 100644 --- a/tests/bdd/gateway_examples_test.go +++ b/tests/bdd/gateway_examples_test.go @@ -86,11 +86,15 @@ func TestRemoteGatewayExamplesConfigureAWSNLBOnEnvoyService(t *testing.T) { t.Fatalf("read %s: %v", example.path, err) } providerProbe := bytes.Index(body, []byte("aws eks describe-cluster")) - defaultControllerConfig := bytes.Index( - body, - []byte(`service.beta.kubernetes.io/aws-load-balancer-type: "external"`), - ) - if providerProbe < 0 || defaultControllerConfig < 0 || providerProbe > defaultControllerConfig { + envoyProxyResource := bytes.Index(body, []byte("kind: EnvoyProxy")) + envoyProxyApply := -1 + if envoyProxyResource >= 0 { + envoyProxyApply = bytes.LastIndex( + body[:envoyProxyResource], + []byte("kubectl apply -f - < envoyProxyApply { t.Errorf( "%s does not select the EKS Service controller before presenting the applied EnvoyProxy", example.path,