From ebf1a3ed24ed08d04f034a13fd780b9771c69be4 Mon Sep 17 00:00:00 2001 From: mitchell amihod Date: Sat, 14 Oct 2023 02:39:31 +0100 Subject: [PATCH] fix(metricprovider): support Datadog v2 API Fixes #2813 (#2997) * Add note in CONTRIBUTING.md that I would have found useful. Signed-off-by: mitchell amihod <4623+meeech@users.noreply.github.com> * Fix gen-openapi to be more portable - make sure it includes the GOPATH in the call. Signed-off-by: mitchell amihod <4623+meeech@users.noreply.github.com> * Update docs. * Expand working with v2 information * Contacted Datadog to get latest info re: v1 deprecation, api limits. * Add tips about rate limits, using helm for templates * Add more example templates Signed-off-by: mitchell amihod <4623+meeech@users.noreply.github.com> * Update Datadog Analysis Type * Make Query omitempty since now possible it won't exist * Add some descriptions * Add new properties we need for v2 Queries: We can pass in key:query for queries Formula: Makes formulas using the keys from queries * Defaults! Use annotations to declare defaults for some fields. This lets us remove some guard rails from the code itself Interval: 5m - Move this from code to here ApiVersion: v1 - Move this from code to here * Enums! Much like defaults, having enums lets us make assumptions about the incoming metric so we dont need as many guardrails. ApiVersion: Enum to restrict to v1 or v2 Signed-off-by: mitchell amihod <4623+meeech@users.noreply.github.com> * Output of make codegen Everything looks ok. Signed-off-by: mitchell amihod <4623+meeech@users.noreply.github.com> * Pass in metric to provider factory. Validate metric. Validating the metric on initialization, rather than spread out throughout. You get earlier feedback if you have a bad metric defined. (Not perfect, but there's limitations with our annotation generator for the rules in the crd. eg: If we could use oneOf, we wouldn't need a lot of this validation) We check all the mutually exclusive props. The props where one requires another. We don't have to check for defaults and set them anymore, since they are guaranteed by the crd. rules: - ensure we have only query OR queries - restrict v1 to query only - make sure you only provide a formula with queries - make sure multiple queries are accompanied by a formula Signed-off-by: mitchell amihod <4623+meeech@users.noreply.github.com> * Remove DefaultApiVersion, remove impossible AnalysisPhaseError ApiVersion is guaranteed to have value, and the enum ensures its v1/v2 when user provided. Updated v1 tests to reflect some of these new realities Signed-off-by: mitchell amihod <4623+meeech@users.noreply.github.com> * extract urlBuilding from run run was getting a bit long according to the checks Signed-off-by: mitchell amihod <4623+meeech@users.noreply.github.com> * Remove some unnecessary stuff for interval. It is a straightline to initialize since default is set to 5m for incoming metrics where it is not set. Signed-off-by: mitchell amihod <4623+meeech@users.noreply.github.com> * Update createRequest Split into createRequest v1/v2 v1 : pretty much unchanged. just extracted v2: support for v2/query/scalar We don't need all the timeseries. I did some testing fetching both scalar and timeseries, and they pretty much lined up. Also confirmed with DD: From support ticket with DD: "...I have also tested the scalar api endpoint with the last aggregator as well as the timeseries api endpoint. They do indeed return the same values when retrieving the values via the api endpoints. Observing the time it takes to retrieve the values, they remain relatively the same..." re: query + v2: Keep backwards compat. if we get in a query, we turn it into a queries object to pass on to requestv2 queries into the QueriesPayload. Signed-off-by: mitchell amihod <4623+meeech@users.noreply.github.com> * Handle v2 scalar responses * update the datadogResponseV2 for scalar values * handle no results so it has parity with v1 - empty will now usually result in `[]` unless something goes very wrong on dd side Signed-off-by: mitchell amihod <4623+meeech@users.noreply.github.com> * update v1 no data tests to better reflect reality Signed-off-by: mitchell amihod <4623+meeech@users.noreply.github.com> * update v2 tests * add some new test cases * update mock server to handle queries / formulas validation * update no data tests to reflect reality * stop all values being the same. it makes it difficult to know find which test case failed. move meaning from comments into the metric name. * stop using deprecated ioutil Signed-off-by: mitchell amihod <4623+meeech@users.noreply.github.com> * re-codegen Signed-off-by: zachaller * fix lint Signed-off-by: zachaller --------- Signed-off-by: mitchell amihod <4623+meeech@users.noreply.github.com> Signed-off-by: zachaller Co-authored-by: zachaller --- Makefile | 4 +- docs/CONTRIBUTING.md | 6 + docs/analysis/datadog.md | 137 +- .../features/kustomize/rollout_cr_schema.json | 54 +- manifests/crds/analysis-run-crd.yaml | 13 +- manifests/crds/analysis-template-crd.yaml | 13 +- .../crds/cluster-analysis-template-crd.yaml | 13 +- manifests/install.yaml | 39 +- metricproviders/datadog/datadog.go | 250 ++-- metricproviders/datadog/datadogV1_test.go | 38 +- metricproviders/datadog/datadogV2_test.go | 176 ++- metricproviders/datadog/datadog_test.go | 147 ++ metricproviders/metricproviders.go | 2 +- pkg/apiclient/rollout/rollout.swagger.json | 16 +- pkg/apis/rollouts/v1alpha1/analysis_types.go | 17 +- pkg/apis/rollouts/v1alpha1/generated.pb.go | 1261 ++++++++++------- pkg/apis/rollouts/v1alpha1/generated.proto | 13 +- .../rollouts/v1alpha1/openapi_generated.go | 32 +- .../v1alpha1/zz_generated.deepcopy.go | 9 +- ui/src/models/rollout/generated/api.ts | 16 +- 20 files changed, 1520 insertions(+), 736 deletions(-) create mode 100644 metricproviders/datadog/datadog_test.go diff --git a/Makefile b/Makefile index a5f77cc568..a17bf33676 100644 --- a/Makefile +++ b/Makefile @@ -20,7 +20,7 @@ DEV_IMAGE ?= false # E2E variables E2E_INSTANCE_ID ?= argo-rollouts-e2e -E2E_TEST_OPTIONS ?= +E2E_TEST_OPTIONS ?= E2E_PARALLEL ?= 1 E2E_WAIT_TIMEOUT ?= 120 GOPATH ?= $(shell go env GOPATH) @@ -149,7 +149,7 @@ gen-mocks: install-go-tools-local ## generate mock files # generates openapi_generated.go .PHONY: gen-openapi gen-openapi: $(DIST_DIR)/openapi-gen ## generate openapi files - PATH=${DIST_DIR}:$$PATH openapi-gen \ + PATH=${DIST_DIR}:$$PATH GOPATH=${GOPATH} openapi-gen \ --go-header-file ${CURRENT_DIR}/hack/custom-boilerplate.go.txt \ --input-dirs github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1 \ --output-package github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1 \ diff --git a/docs/CONTRIBUTING.md b/docs/CONTRIBUTING.md index a37ad29fc0..a13b18ed0e 100644 --- a/docs/CONTRIBUTING.md +++ b/docs/CONTRIBUTING.md @@ -178,6 +178,12 @@ make start-e2e E2E_INSTANCE_ID='' ``` +6. Working on CRDs? While editing them directly works when you are finding the shape of things you want, the final CRDs are autogenerated. Make sure to regenerate them before submitting PRs. They are controlled by the relevant annotations in the types file: + +eg: Analysis Templates are controlled by annotations in `pkg/apis/rollouts/v1alpha1/analysis_types.go`. + +Refer to https://book-v1.book.kubebuilder.io/beyond_basics/generating_crd.html and https://book.kubebuilder.io/reference/markers/crd-validation.html for more info on annotations you can use. + ## Running Local Containers You may need to run containers locally, so here's how: diff --git a/docs/analysis/datadog.md b/docs/analysis/datadog.md index 3010c9a4df..6e89058572 100644 --- a/docs/analysis/datadog.md +++ b/docs/analysis/datadog.md @@ -26,10 +26,7 @@ spec: sum:requests.error.rate{service:{{args.service-name}}} ``` -The field `apiVersion` refers to the API version of Datadog (v1 or v2). Default value is `v1` if this is omitted. - -!!! note - Datadog is moving away from the legacy v1 API. Rate limits imposed by Datadog are therefore stricter when using v1. It is recommended to switch to v2 soon. If you switch to v2, you will not be able to use formulas (operations between individual queries). +The field `apiVersion` refers to the API version of Datadog (v1 or v2). Default value is `v1` if this is omitted. See "Working with Datadog API v2" below for more information. Datadog api and app tokens can be configured in a kubernetes secret in argo-rollouts namespace. @@ -46,3 +43,135 @@ stringData: ``` `apiVersion` here is different from the `apiVersion` from the Datadog configuration above. + +### Working with Datadog API v2 + +#### Moving to v2 + +If your old v1 was just a simple metric query - no formula as part of the query - then you can just move to v2 by updating the `apiVersion` in your existing Analysis Template, and everything should work. + +If you have a formula, you will need to update how you configure your metric. Here is a before/after example of what your Analysis Template should look like: + +Before: + +```yaml +apiVersion: argoproj.io/v1alpha1 +kind: AnalysisTemplate +metadata: + name: log-error-rate +spec: + args: + - name: service-name + metrics: + - name: error-rate + interval: 30s + successCondition: default(result, 0) < 10 + failureLimit: 3 + provider: + datadog: + apiVersion: v1 + interval: 5m + query: "moving_rollup(sum:requests.errors{service:{{args.service-name}}}.as_count(), 60, 'sum') / sum:requests{service:{{args.service-name}}}.as_count()" +``` + +After: + +```yaml +apiVersion: argoproj.io/v1alpha1 +kind: AnalysisTemplate +metadata: + name: loq-error-rate +spec: + args: + - name: service-name + metrics: + - name: error-rate + # Polling rate against the Datadog API + interval: 30s + successCondition: default(result, 0) < 10 + failureLimit: 3 + provider: + datadog: + apiVersion: v2 + # The window of time we are looking at in DD. Basically we will fetch data from (now-5m) to now. + interval: 5m + queries: + a: sum:requests.errors{service:{{args.service-name}}}.as_count() + b: sum:requests{service:{{args.service-name}}}.as_count() + formula: "moving_rollup(a, 60, 'sum') / b" +``` + +#### Examples + +Simple v2 query with no formula + +```yaml +apiVersion: argoproj.io/v1alpha1 +kind: AnalysisTemplate +metadata: + name: canary-container-restarts +spec: + args: + # This is set in rollout using the valueFrom: podTemplateHashValue functionality + - name: canary-hash + - name: service-name + - name: restarts.initial-delay + value: "60s" + - name: restarts.max-restarts + value: "4" + metrics: + - name: kubernetes.containers.restarts + initialDelay: "{{ args.restarts.initial-delay }}" + interval: 15s + failureCondition: default(result, 0) > {{ args.restarts.max-restarts }} + failureLimit: 0 + provider: + datadog: + apiVersion: v2 + interval: 5m + queries: + # The key is arbitrary - you will use this key to refer to the query if you use a formula. + q: "max:kubernetes.containers.restarts{service-name:{{args.service-name}},rollouts_pod_template_hash:{{args.canary-hash}}}" +``` + +### Tips + +#### Datadog Results + +Datadog queries can return empty results if the query takes place during a time interval with no metrics. The Datadog provider will return a `nil` value yielding an error during the evaluation phase like: + +``` +invalid operation: < (mismatched types and float64) +``` + +However, empty query results yielding a `nil` value can be handled using the `default()` function. Here is a succeeding example using the `default()` function: + +```yaml +successCondition: default(result, 0) < 0.05 +``` + +#### Templates and Helm + +Helm and Argo Rollouts both try to parse things between `{{ ... }}` when rendering templates. If you use Helm to deliver your manifests, you will need to escape `{{ args.whatever }}`. Using the example above, here it is set up for Helm: + +```yaml +... +metrics: + - name: kubernetes.containers.restarts + initialDelay: "{{ `{{ args.restarts.initial-delay }}` }}" + interval: 15s + failureCondition: default(result, 0) > {{ `{{ args.restarts.max-restarts }}` }} + failureLimit: 0 + provider: + datadog: + apiVersion: v2 + interval: 5m + queries: + q: "{{ `max:kubernetes.containers.restarts{kube_app_name:{{args.kube_app_name}},rollouts_pod_template_hash:{{args.canary-hash}}}` }}" +``` + +#### Rate Limits + +For the `v1` API, you ask for an increase on the `api/v1/query` route. + +For the `v2` API, the Ratelimit-Name you ask for an increase in is the `query_scalar_public`. diff --git a/docs/features/kustomize/rollout_cr_schema.json b/docs/features/kustomize/rollout_cr_schema.json index 8ba598cc82..21ed8d1d66 100644 --- a/docs/features/kustomize/rollout_cr_schema.json +++ b/docs/features/kustomize/rollout_cr_schema.json @@ -244,18 +244,30 @@ "datadog": { "properties": { "apiVersion": { + "default": "v1", + "enum": [ + "v1", + "v2" + ], + "type": "string" + }, + "formula": { "type": "string" }, "interval": { + "default": "5m", "type": "string" }, + "queries": { + "additionalProperties": { + "type": "string" + }, + "type": "object" + }, "query": { "type": "string" } }, - "required": [ - "query" - ], "type": "object" }, "graphite": { @@ -4750,18 +4762,30 @@ "datadog": { "properties": { "apiVersion": { + "default": "v1", + "enum": [ + "v1", + "v2" + ], + "type": "string" + }, + "formula": { "type": "string" }, "interval": { + "default": "5m", "type": "string" }, + "queries": { + "additionalProperties": { + "type": "string" + }, + "type": "object" + }, "query": { "type": "string" } }, - "required": [ - "query" - ], "type": "object" }, "graphite": { @@ -9256,18 +9280,30 @@ "datadog": { "properties": { "apiVersion": { + "default": "v1", + "enum": [ + "v1", + "v2" + ], + "type": "string" + }, + "formula": { "type": "string" }, "interval": { + "default": "5m", "type": "string" }, + "queries": { + "additionalProperties": { + "type": "string" + }, + "type": "object" + }, "query": { "type": "string" } }, - "required": [ - "query" - ], "type": "object" }, "graphite": { diff --git a/manifests/crds/analysis-run-crd.yaml b/manifests/crds/analysis-run-crd.yaml index 9bf67d49b8..44326292a3 100644 --- a/manifests/crds/analysis-run-crd.yaml +++ b/manifests/crds/analysis-run-crd.yaml @@ -179,13 +179,22 @@ spec: datadog: properties: apiVersion: + default: v1 + enum: + - v1 + - v2 + type: string + formula: type: string interval: + default: 5m type: string + queries: + additionalProperties: + type: string + type: object query: type: string - required: - - query type: object graphite: properties: diff --git a/manifests/crds/analysis-template-crd.yaml b/manifests/crds/analysis-template-crd.yaml index 591847282f..b160a966f2 100644 --- a/manifests/crds/analysis-template-crd.yaml +++ b/manifests/crds/analysis-template-crd.yaml @@ -175,13 +175,22 @@ spec: datadog: properties: apiVersion: + default: v1 + enum: + - v1 + - v2 + type: string + formula: type: string interval: + default: 5m type: string + queries: + additionalProperties: + type: string + type: object query: type: string - required: - - query type: object graphite: properties: diff --git a/manifests/crds/cluster-analysis-template-crd.yaml b/manifests/crds/cluster-analysis-template-crd.yaml index e02cf80946..c38373a3f9 100644 --- a/manifests/crds/cluster-analysis-template-crd.yaml +++ b/manifests/crds/cluster-analysis-template-crd.yaml @@ -175,13 +175,22 @@ spec: datadog: properties: apiVersion: + default: v1 + enum: + - v1 + - v2 + type: string + formula: type: string interval: + default: 5m type: string + queries: + additionalProperties: + type: string + type: object query: type: string - required: - - query type: object graphite: properties: diff --git a/manifests/install.yaml b/manifests/install.yaml index 54c65cc56c..4466ae8106 100755 --- a/manifests/install.yaml +++ b/manifests/install.yaml @@ -180,13 +180,22 @@ spec: datadog: properties: apiVersion: + default: v1 + enum: + - v1 + - v2 + type: string + formula: type: string interval: + default: 5m type: string + queries: + additionalProperties: + type: string + type: object query: type: string - required: - - query type: object graphite: properties: @@ -3226,13 +3235,22 @@ spec: datadog: properties: apiVersion: + default: v1 + enum: + - v1 + - v2 + type: string + formula: type: string interval: + default: 5m type: string + queries: + additionalProperties: + type: string + type: object query: type: string - required: - - query type: object graphite: properties: @@ -6158,13 +6176,22 @@ spec: datadog: properties: apiVersion: + default: v1 + enum: + - v1 + - v2 + type: string + formula: type: string interval: + default: 5m type: string + queries: + additionalProperties: + type: string + type: object query: type: string - required: - - query type: object graphite: properties: diff --git a/metricproviders/datadog/datadog.go b/metricproviders/datadog/datadog.go index 00f9c8a8ac..0924f4cdd3 100644 --- a/metricproviders/datadog/datadog.go +++ b/metricproviders/datadog/datadog.go @@ -26,6 +26,7 @@ import ( "k8s.io/client-go/kubernetes" ) +// This is done so we can explicitly override it in the unit test var unixNow = func() int64 { return timeutil.Now().Unix() } const ( @@ -35,7 +36,6 @@ const ( DatadogApiKey = "api-key" DatadogAppKey = "app-key" DatadogAddress = "address" - DefaultApiVersion = "v1" ) // Provider contains all the required components to run a Datadog query @@ -46,9 +46,10 @@ type Provider struct { } type datadogQueryAttributes struct { - From int64 `json:"from"` - To int64 `json:"to"` - Queries []map[string]string `json:"queries"` + From int64 `json:"from"` + To int64 `json:"to"` + Queries []map[string]string `json:"queries"` + Formulas []map[string]string `json:"formulas"` } type datadogQuery struct { @@ -69,8 +70,9 @@ type datadogResponseV1 struct { type datadogResponseV2 struct { Data struct { Attributes struct { - Values [][]float64 - Times []int64 + Columns []struct { + Values []float64 + } } Errors string } @@ -82,7 +84,7 @@ type datadogConfig struct { AppKey string `yaml:"app-key,omitempty"` } -// Type incidates provider is a Datadog provider +// Type indicates provider is a Datadog provider func (p *Provider) Type() string { return ProviderType } @@ -92,57 +94,58 @@ func (p *Provider) GetMetadata(metric v1alpha1.Metric) map[string]string { return nil } -func (p *Provider) Run(run *v1alpha1.AnalysisRun, metric v1alpha1.Metric) v1alpha1.Measurement { - startTime := timeutil.MetaNow() - - // Measurement to pass back - measurement := v1alpha1.Measurement{ - StartedAt: &startTime, - } - +func (p *Provider) buildEndpointUrl(apiVersion string) (*url.URL, error) { endpoint := "https://api.datadoghq.com" if p.config.Address != "" { endpoint = p.config.Address } - // Check if the URL is valid first before adding the endpoint + // Check if the user provided URL is valid first before adding the endpoint url, err := url.Parse(endpoint) if err != nil { - return metricutil.MarkMeasurementError(measurement, err) + return nil, err + } + + route := "/api/v1/query" + if apiVersion == "v2" { + route = "/api/v2/query/scalar" } - apiVersion := DefaultApiVersion - if metric.Provider.Datadog.ApiVersion != "" { - apiVersion = metric.Provider.Datadog.ApiVersion + // Add endpoint after getting the API version + url, err = url.Parse(endpoint + route) + if err != nil { + return nil, err } + return url, err +} - if apiVersion == "v1" { +func (p *Provider) Run(run *v1alpha1.AnalysisRun, metric v1alpha1.Metric) v1alpha1.Measurement { + startTime := timeutil.MetaNow() + dd := metric.Provider.Datadog + + if dd.ApiVersion == "v1" { p.logCtx.Warn("Datadog will soon deprecate their API v1. Please consider switching to v2 soon.") } - route := "/api/v1/query" - if apiVersion == "v2" { - route = "/api/v2/query/timeseries" + // Measurement to pass back + measurement := v1alpha1.Measurement{ + StartedAt: &startTime, } - // Add endpoint after getting the API version - url, err = url.Parse(endpoint + route) + url, err := p.buildEndpointUrl(dd.ApiVersion) if err != nil { return metricutil.MarkMeasurementError(measurement, err) } - now := unixNow() - var interval int64 = 300 - if metric.Provider.Datadog.Interval != "" { - expDuration, err := metric.Provider.Datadog.Interval.Duration() - if err != nil { - return metricutil.MarkMeasurementError(measurement, err) - } - // Convert to seconds as DataDog expects unix timestamp - interval = int64(expDuration.Seconds()) + // Interval default is in the spec. bigger things would need to fail to get here without an dd.Interval + expDuration, err := dd.Interval.Duration() + if err != nil { + return metricutil.MarkMeasurementError(measurement, err) } + // Convert to seconds as DataDog expects unix timestamp + interval := int64(expDuration.Seconds()) - request, err := p.createRequest(metric.Provider.Datadog.Query, apiVersion, now, interval, url) + request, err := p.createRequest(dd, unixNow(), interval, url) if err != nil { return metricutil.MarkMeasurementError(measurement, err) } @@ -158,12 +161,11 @@ func (p *Provider) Run(run *v1alpha1.AnalysisRun, metric v1alpha1.Metric) v1alph Timeout: time.Duration(10) * time.Second, } response, err := httpClient.Do(request) - if err != nil { return metricutil.MarkMeasurementError(measurement, err) } - value, status, err := p.parseResponse(metric, response, apiVersion) + value, status, err := p.parseResponse(metric, response, dd.ApiVersion) if err != nil { return metricutil.MarkMeasurementError(measurement, err) } @@ -176,52 +178,84 @@ func (p *Provider) Run(run *v1alpha1.AnalysisRun, metric v1alpha1.Metric) v1alph return measurement } -func (p *Provider) createRequest(query string, apiVersion string, now int64, interval int64, url *url.URL) (*http.Request, error) { - if apiVersion == "v1" { - q := url.Query() - q.Set("query", query) - q.Set("from", strconv.FormatInt(now-interval, 10)) - q.Set("to", strconv.FormatInt(now, 10)) - url.RawQuery = q.Encode() - - return &http.Request{Method: "GET"}, nil - } else if apiVersion == "v2" { - queryBody, err := json.Marshal(datadogRequest{ - Data: datadogQuery{ - QueryType: "timeseries_request", - Attributes: datadogQueryAttributes{ - From: (now - interval) * 1000, - To: now * 1000, - Queries: []map[string]string{{ - "data_source": "metrics", - "query": query, - }}, - }, - }}) - if err != nil { - return nil, fmt.Errorf("Could not parse your JSON request: %v", err) +func (p *Provider) createRequest(dd *v1alpha1.DatadogMetric, now int64, interval int64, url *url.URL) (*http.Request, error) { + if dd.ApiVersion == "v1" { + return p.createRequestV1(dd.Query, now, interval, url) + } + + // we know dd.Query and dd.Queries are mutually exclusive. + if dd.Query != "" { + dd.Queries = map[string]string{"query": dd.Query} + } + + return p.createRequestV2(dd.Queries, dd.Formula, now, interval, url) +} + +func (p *Provider) createRequestV1(query string, now int64, interval int64, url *url.URL) (*http.Request, error) { + q := url.Query() + q.Set("query", query) + q.Set("from", strconv.FormatInt(now-interval, 10)) + q.Set("to", strconv.FormatInt(now, 10)) + url.RawQuery = q.Encode() + + return &http.Request{Method: "GET"}, nil +} + +func buildQueriesPayload(queries map[string]string) []map[string]string { + qp := make([]map[string]string, 0, len(queries)) + for k, v := range queries { + p := map[string]string{ + "aggregator": "last", + "data_source": "metrics", + "name": k, + "query": v, } - request := &http.Request{Method: "POST"} - request.Body = io.NopCloser(bytes.NewReader(queryBody)) - return request, nil + qp = append(qp, p) + } + return qp +} + +func (p *Provider) createRequestV2(queries map[string]string, formula string, now int64, interval int64, url *url.URL) (*http.Request, error) { + formulas := []map[string]string{} + // ddAPI supports multiple formulas but doesn't make sense in our context + // can't have a 'blank' formula, so have to guard + if formula != "" { + formulas = []map[string]string{{ + "formula": formula, + }} } - return nil, fmt.Errorf("Invalid API version: %s", apiVersion) + attribs := datadogQueryAttributes{ + // Datadog requires milliseconds for v2 api + From: (now - interval) * 1000, + To: now * 1000, + Queries: buildQueriesPayload(queries), + Formulas: formulas, + } + + queryBody, err := json.Marshal(datadogRequest{ + Data: datadogQuery{ + QueryType: "scalar_request", + Attributes: attribs, + }, + }) + if err != nil { + return nil, fmt.Errorf("Could not parse your JSON request: %v", err) + } + request := &http.Request{Method: "POST"} + request.Body = io.NopCloser(bytes.NewReader(queryBody)) + return request, nil } func (p *Provider) parseResponse(metric v1alpha1.Metric, response *http.Response, apiVersion string) (string, v1alpha1.AnalysisPhase, error) { if apiVersion == "v1" { return p.parseResponseV1(metric, response) - } else if apiVersion == "v2" { - return p.parseResponseV2(metric, response) } - return "", v1alpha1.AnalysisPhaseError, fmt.Errorf("Invalid API version: %s", apiVersion) + return p.parseResponseV2(metric, response) } func (p *Provider) parseResponseV1(metric v1alpha1.Metric, response *http.Response) (string, v1alpha1.AnalysisPhase, error) { - bodyBytes, err := io.ReadAll(response.Body) - if err != nil { return "", v1alpha1.AnalysisPhaseError, fmt.Errorf("Received no bytes in response: %v", err) } @@ -263,9 +297,7 @@ func (p *Provider) parseResponseV1(metric v1alpha1.Metric, response *http.Respon } func (p *Provider) parseResponseV2(metric v1alpha1.Metric, response *http.Response) (string, v1alpha1.AnalysisPhase, error) { - bodyBytes, err := io.ReadAll(response.Body) - if err != nil { return "", v1alpha1.AnalysisPhaseError, fmt.Errorf("Received no bytes in response: %v", err) } @@ -288,26 +320,30 @@ func (p *Provider) parseResponseV2(metric v1alpha1.Metric, response *http.Respon } // Handle an empty query result - if reflect.ValueOf(res.Data.Attributes).IsZero() || len(res.Data.Attributes.Values) == 0 || len(res.Data.Attributes.Times) == 0 { + if reflect.ValueOf(res.Data.Attributes).IsZero() || len(res.Data.Attributes.Columns) == 0 || len(res.Data.Attributes.Columns[0].Values) == 0 { var nilFloat64 *float64 status, err := evaluate.EvaluateResult(nilFloat64, metric, p.logCtx) - attributesBytes, jsonErr := json.Marshal(res.Data.Attributes) + + var attributesBytes []byte + var jsonErr error + // Should be impossible for this to not be true, based on dd openapi spec. + // But in this case, better safe than sorry + if len(res.Data.Attributes.Columns) == 1 { + attributesBytes, jsonErr = json.Marshal(res.Data.Attributes.Columns[0].Values) + } else { + attributesBytes, jsonErr = json.Marshal(res.Data.Attributes) + } + if jsonErr != nil { - return "", v1alpha1.AnalysisPhaseError, fmt.Errorf("Failed to marshall JSON empty series: %v", jsonErr) + return "", v1alpha1.AnalysisPhaseError, fmt.Errorf("Failed to marshall JSON empty Values: %v", jsonErr) } return string(attributesBytes), status, err } // Handle a populated query result - attributes := res.Data.Attributes - datapoint := attributes.Values[0] - timepoint := attributes.Times[len(attributes.Times)-1] - if timepoint == 0 { - return "", v1alpha1.AnalysisPhaseError, fmt.Errorf("Datapoint does not have a corresponding time value") - } - - value := datapoint[len(datapoint)-1] + column := res.Data.Attributes.Columns[0] + value := column.Values[0] status, err := evaluate.EvaluateResult(value, metric, p.logCtx) return strconv.FormatFloat(value, 'f', -1, 64), status, err } @@ -341,7 +377,44 @@ func lookupKeysInEnv(keys []string) map[string]string { return valuesByKey } -func NewDatadogProvider(logCtx log.Entry, kubeclientset kubernetes.Interface) (*Provider, error) { +// The current gen tooling we are using can't generate CRD with all the validations we need. +// This is unfortunate, user has more ways to deliver an invalid Analysis Template vs +// being rejected on delivery by k8s (and allowing for a validation step if desired in CI/CD). +// So we run through all the checks here. If the situation changes (eg: being able to use oneOf with required) +// in the CRD spec, please update. +func validateIncomingProps(dd *v1alpha1.DatadogMetric) error { + // check that we have the required field + if dd.Query == "" && len(dd.Queries) == 0 { + return errors.New("Must have either a query or queries. Please review the Analysis Template.") + } + + // check that we have ONE OF query/queries + if dd.Query != "" && len(dd.Queries) > 0 { + return errors.New("Cannot have both a query and queries. Please review the Analysis Template.") + } + + // check that query is set for apiversion v1 + if dd.ApiVersion == "v1" && dd.Query == "" { + return errors.New("Query is empty. API Version v1 only supports using the query parameter in your Analysis Template.") + } + + // formula <3 queries. won't go anywhere without them + if dd.Formula != "" && len(dd.Queries) == 0 { + return errors.New("Formula are only valid when queries are set. Please review the Analysis Template.") + } + + // Reject queries with more than 1 when NO formula provided. While this would technically work + // DD will return 2 columns of data, and there is no guarantee what order they would be in, so + // there is no way to guess at intention of user. Since this is about metrics and monitoring, we should + // avoid ambiguity. + if dd.Formula == "" && len(dd.Queries) > 1 { + return errors.New("When multiple queries are provided you must include a formula.") + } + + return nil +} + +func NewDatadogProvider(logCtx log.Entry, kubeclientset kubernetes.Interface, metric v1alpha1.Metric) (*Provider, error) { ns := defaults.Namespace() apiKey := "" @@ -366,6 +439,12 @@ func NewDatadogProvider(logCtx log.Entry, kubeclientset kubernetes.Interface) (* } if apiKey != "" && appKey != "" { + + err := validateIncomingProps(metric.Provider.Datadog) + if err != nil { + return nil, err + } + return &Provider{ logCtx: logCtx, config: datadogConfig{ @@ -377,5 +456,4 @@ func NewDatadogProvider(logCtx log.Entry, kubeclientset kubernetes.Interface) (* } else { return nil, errors.New("API or App token not found") } - } diff --git a/metricproviders/datadog/datadogV1_test.go b/metricproviders/datadog/datadogV1_test.go index 5f56ae3c0d..af58d47617 100644 --- a/metricproviders/datadog/datadogV1_test.go +++ b/metricproviders/datadog/datadogV1_test.go @@ -19,7 +19,6 @@ import ( ) func TestRunSuite(t *testing.T) { - const expectedApiKey = "0123456789abcdef0123456789abcdef" const expectedAppKey = "0123456789abcdef0123456789abcdef01234567" @@ -39,7 +38,7 @@ func TestRunSuite(t *testing.T) { } // Test Cases - var tests = []struct { + tests := []struct { serverURL string webServerStatus int webServerResponse string @@ -144,7 +143,7 @@ func TestRunSuite(t *testing.T) { // Expect error with no default() and no data { webServerStatus: 200, - webServerResponse: `{"status":"ok","series":[{"pointlist":[]}]}`, + webServerResponse: `{"status":"ok","series":[]}`, metric: v1alpha1.Metric{ Name: "foo", SuccessCondition: "result < 0.05", @@ -159,14 +158,14 @@ func TestRunSuite(t *testing.T) { // Expect success with default() and no data { webServerStatus: 200, - webServerResponse: `{"status":"ok","series":[{"pointlist":[]}]}`, + webServerResponse: `{"status":"ok","series":[]}`, metric: v1alpha1.Metric{ Name: "foo", SuccessCondition: "default(result, 0) < 0.05", Provider: ddProviderIntervalDefault, }, expectedIntervalSeconds: 300, - expectedValue: `[{"pointlist":[]}]`, + expectedValue: `[]`, expectedPhase: v1alpha1.AnalysisPhaseSuccessful, useEnvVarForKeys: false, }, @@ -174,14 +173,14 @@ func TestRunSuite(t *testing.T) { // Expect failure with bad default() and no data { webServerStatus: 200, - webServerResponse: `{"status":"ok","series":[{"pointlist":[]}]}`, + webServerResponse: `{"status":"ok","series":[]}`, metric: v1alpha1.Metric{ Name: "foo", SuccessCondition: "default(result, 1) < 0.05", Provider: ddProviderIntervalDefault, }, expectedIntervalSeconds: 300, - expectedValue: `[{"pointlist":[]}]`, + expectedValue: `[]`, expectedPhase: v1alpha1.AnalysisPhaseFailed, useEnvVarForKeys: false, }, @@ -219,8 +218,10 @@ func TestRunSuite(t *testing.T) { // Error if server address is faulty { - serverURL: "://wrong.schema", - metric: v1alpha1.Metric{}, + serverURL: "://wrong.schema", + metric: v1alpha1.Metric{ + Provider: ddProviderInterval10m, + }, expectedPhase: v1alpha1.AnalysisPhaseError, expectedErrorMessage: "parse \"://wrong.schema\": missing protocol scheme", useEnvVarForKeys: false, @@ -235,11 +236,7 @@ func TestRunSuite(t *testing.T) { if serverURL == "" { // Server setup with response server := httptest.NewServer(http.HandlerFunc(func(rw http.ResponseWriter, req *http.Request) { - if test.metric.Provider.Datadog.ApiVersion == "" && DefaultApiVersion != "v1" { - t.Errorf("\nApiVersion was left blank in the tests, but the default API version is not v1 anymore.") - } - - //Check query variables + // Check query variables actualQuery := req.URL.Query().Get("query") actualFrom := req.URL.Query().Get("from") actualTo := req.URL.Query().Get("to") @@ -260,7 +257,7 @@ func TestRunSuite(t *testing.T) { t.Errorf("\nfailed to parse to: %v", err) } - //Check headers + // Check headers if req.Header.Get("Content-Type") != "application/json" { t.Errorf("\nContent-Type header expected to be application/json but got %s", req.Header.Get("Content-Type")) } @@ -315,7 +312,16 @@ func TestRunSuite(t *testing.T) { return true, tokenSecret, nil }) - provider, _ := NewDatadogProvider(*logCtx, fakeClient) + // Enforce these having defaults + if test.metric.Provider.Datadog.ApiVersion == "" { + test.metric.Provider.Datadog.ApiVersion = "v1" + } + + if test.metric.Provider.Datadog.Interval == "" { + test.metric.Provider.Datadog.Interval = "5m" + } + + provider, _ := NewDatadogProvider(*logCtx, fakeClient, test.metric) metricsMetadata := provider.GetMetadata(test.metric) assert.Nil(t, metricsMetadata) diff --git a/metricproviders/datadog/datadogV2_test.go b/metricproviders/datadog/datadogV2_test.go index 11a82411c7..f3e481160e 100644 --- a/metricproviders/datadog/datadogV2_test.go +++ b/metricproviders/datadog/datadogV2_test.go @@ -3,7 +3,6 @@ package datadog import ( "encoding/json" "io" - "io/ioutil" "net/http" "net/http/httptest" "os" @@ -19,30 +18,48 @@ import ( kubetesting "k8s.io/client-go/testing" ) -func TestRunSuiteV2(t *testing.T) { - - const expectedApiKey = "0123456789abcdef0123456789abcdef" - const expectedAppKey = "0123456789abcdef0123456789abcdef01234567" - - unixNow = func() int64 { return 1599076435 } - - ddProviderIntervalDefault := v1alpha1.MetricProvider{ +func newQueryDefaultProvider() v1alpha1.MetricProvider { + return v1alpha1.MetricProvider{ Datadog: &v1alpha1.DatadogMetric{ + Interval: "5m", Query: "avg:kubernetes.cpu.user.total{*}", ApiVersion: "v2", }, } +} - ddProviderInterval10m := v1alpha1.MetricProvider{ +func newQueriesDefaultProvider() v1alpha1.MetricProvider { + return v1alpha1.MetricProvider{ + Datadog: &v1alpha1.DatadogMetric{ + Interval: "5m", + Queries: map[string]string{ + "a": "avg:error_requests{*}", + "b": "avg:total_requests{*}", + }, + Formula: "a/b", + ApiVersion: "v2", + }, + } +} + +func newQueryProviderInterval10m() v1alpha1.MetricProvider { + return v1alpha1.MetricProvider{ Datadog: &v1alpha1.DatadogMetric{ Query: "avg:kubernetes.cpu.user.total{*}", Interval: "10m", ApiVersion: "v2", }, } +} + +func TestRunSuiteV2(t *testing.T) { + const expectedApiKey = "0123456789abcdef0123456789abcdef" + const expectedAppKey = "0123456789abcdef0123456789abcdef01234567" + + unixNow = func() int64 { return 1599076435 } // Test Cases - var tests = []struct { + tests := []struct { serverURL string webServerStatus int webServerResponse string @@ -53,75 +70,70 @@ func TestRunSuiteV2(t *testing.T) { expectedErrorMessage string useEnvVarForKeys bool }{ - // When last value of time series matches condition then succeed. { webServerStatus: 200, - webServerResponse: `{"data": {"attributes": {"values": [[0.0020008318672513122, 0.0003332881882246533]], "times": [1598867910000, 1598867925000]}}}`, + webServerResponse: `{"data": {"attributes": {"columns": [ {"values": [0.0006332881882246533]}]}}}`, metric: v1alpha1.Metric{ - Name: "foo", + Name: "simple scalar query", SuccessCondition: "result < 0.001", FailureCondition: "result >= 0.001", - Provider: ddProviderInterval10m, + Provider: newQueryProviderInterval10m(), }, expectedIntervalSeconds: 600, - expectedValue: "0.0003332881882246533", + expectedValue: "0.0006332881882246533", expectedPhase: v1alpha1.AnalysisPhaseSuccessful, useEnvVarForKeys: false, }, - // Same test as above, but derive DD keys from env var instead of k8s secret { webServerStatus: 200, - webServerResponse: `{"data": {"attributes": {"values": [[0.0020008318672513122, 0.0003332881882246533]], "times": [1598867910000, 1598867925000]}}}`, + webServerResponse: `{"data": {"attributes": {"columns": [ {"values": [0.0003332881882246533]}]}}}`, metric: v1alpha1.Metric{ - Name: "foo", + Name: "keys from env vars", SuccessCondition: "result < 0.001", FailureCondition: "result >= 0.001", - Provider: ddProviderInterval10m, + Provider: newQueryProviderInterval10m(), }, expectedIntervalSeconds: 600, expectedValue: "0.0003332881882246533", expectedPhase: v1alpha1.AnalysisPhaseSuccessful, useEnvVarForKeys: true, }, - // When last value of time series does not match condition then fail. { webServerStatus: 200, - webServerResponse: `{"data": {"attributes": {"values": [[0.0020008318672513122, 0.006121378742186943]], "times": [1598867910000, 1598867925000]}}}`, + webServerResponse: `{"data": {"attributes": {"columns": [ {"values": [0.006121374442186943]}]}}}`, metric: v1alpha1.Metric{ - Name: "foo", + Name: "value does not match condition then fail", SuccessCondition: "result < 0.001", FailureCondition: "result >= 0.001", - Provider: ddProviderIntervalDefault, + Provider: newQueryDefaultProvider(), }, expectedIntervalSeconds: 300, - expectedValue: "0.006121378742186943", + expectedValue: "0.006121374442186943", expectedPhase: v1alpha1.AnalysisPhaseFailed, useEnvVarForKeys: false, }, - // Error if the request is invalid { webServerStatus: 400, webServerResponse: `{"status":"error","error":"error messsage"}`, metric: v1alpha1.Metric{ - Name: "foo", + Name: "error for invalid request", SuccessCondition: "result < 0.001", FailureCondition: "result >= 0.001", - Provider: ddProviderIntervalDefault, + Provider: newQueryDefaultProvider(), }, expectedIntervalSeconds: 300, expectedPhase: v1alpha1.AnalysisPhaseError, expectedErrorMessage: "received non 2xx response code: 400 {\"status\":\"error\",\"error\":\"error messsage\"}", useEnvVarForKeys: false, }, - // Error if there is an authentication issue { webServerStatus: 401, webServerResponse: `{"errors": ["No authenticated user."]}`, metric: v1alpha1.Metric{ - Name: "foo", + Name: "no authenticated user", SuccessCondition: "result < 0.001", FailureCondition: "result >= 0.001", - Provider: ddProviderIntervalDefault, + Provider: newQueryDefaultProvider(), }, expectedIntervalSeconds: 300, expectedPhase: v1alpha1.AnalysisPhaseError, @@ -129,14 +141,13 @@ func TestRunSuiteV2(t *testing.T) { useEnvVarForKeys: false, }, - // Expect success with default() and data { webServerStatus: 200, - webServerResponse: `{"data": {"attributes": {"values": [[0.0020008318672513122, 0.006121378742186943]], "times": [1598867910000, 1598867925000]}}}`, + webServerResponse: `{"data": {"attributes": {"columns": [ {"values": [0.006121378742186943]}]}}}`, metric: v1alpha1.Metric{ - Name: "foo", + Name: "success with default and data", SuccessCondition: "default(result, 0) < 0.05", - Provider: ddProviderIntervalDefault, + Provider: newQueryDefaultProvider(), }, expectedIntervalSeconds: 300, expectedValue: "0.006121378742186943", @@ -144,14 +155,13 @@ func TestRunSuiteV2(t *testing.T) { useEnvVarForKeys: false, }, - // Expect error with no default() and no data { webServerStatus: 200, - webServerResponse: `{"data": {"attributes": {"values": [], "times": []}}}`, + webServerResponse: `{"data": {"attributes": {"columns": [ {"values": []}]}}}`, metric: v1alpha1.Metric{ - Name: "foo", + Name: "error with no default and no data", SuccessCondition: "result < 0.05", - Provider: ddProviderIntervalDefault, + Provider: newQueryDefaultProvider(), }, expectedIntervalSeconds: 300, expectedPhase: v1alpha1.AnalysisPhaseError, @@ -159,75 +169,89 @@ func TestRunSuiteV2(t *testing.T) { useEnvVarForKeys: false, }, - // Expect success with default() and no data { webServerStatus: 200, - webServerResponse: `{"data": {"attributes": {"values": [], "times": []}}}`, + webServerResponse: `{"data": {"attributes": {"columns": [ {"values": []}]}}}`, metric: v1alpha1.Metric{ - Name: "foo", + Name: "success with default and no data", SuccessCondition: "default(result, 0) < 0.05", - Provider: ddProviderIntervalDefault, + Provider: newQueryDefaultProvider(), }, expectedIntervalSeconds: 300, - expectedValue: `{"Values":[],"Times":[]}`, + expectedValue: `[]`, expectedPhase: v1alpha1.AnalysisPhaseSuccessful, useEnvVarForKeys: false, }, - // Expect failure with bad default() and no data { webServerStatus: 200, - webServerResponse: `{"data": {"attributes": {"values": [], "times": []}}}`, + webServerResponse: `{"data": {"attributes": {"columns": [ {"values": []}]}}}`, metric: v1alpha1.Metric{ - Name: "foo", + Name: "fail when bad default and no data", SuccessCondition: "default(result, 1) < 0.05", - Provider: ddProviderIntervalDefault, + Provider: newQueryDefaultProvider(), }, expectedIntervalSeconds: 300, - expectedValue: `{"Values":[],"Times":[]}`, + expectedValue: `[]`, expectedPhase: v1alpha1.AnalysisPhaseFailed, useEnvVarForKeys: false, }, - // Expect success with bad default() and good data { webServerStatus: 200, - webServerResponse: `{"data": {"attributes": {"values": [[0.0020008318672513122, 0.006121378742186943]], "times": [1598867910000, 1598867925000]}}}`, + webServerResponse: `{"data": {"attributes": {"columns": [ {"values": [0.006721378742186999]}]}}}`, metric: v1alpha1.Metric{ - Name: "foo", + Name: "success bad default and good data", SuccessCondition: "default(result, 1) < 0.05", - Provider: ddProviderIntervalDefault, + Provider: newQueryDefaultProvider(), }, expectedIntervalSeconds: 300, - expectedValue: `0.006121378742186943`, + expectedValue: `0.006721378742186999`, expectedPhase: v1alpha1.AnalysisPhaseSuccessful, useEnvVarForKeys: false, }, - // Error if datadog returns non-array values { webServerStatus: 200, - webServerResponse: `{"data": {"attributes": {"values": "invalid", "times": "invalid"}}}`, + webServerResponse: `{"data": {"attributes": {"columns": [{"values": "invalid"}]}}}`, metric: v1alpha1.Metric{ - Name: "foo", + Name: "error when bad values from dd", SuccessCondition: "result < 0.001", FailureCondition: "result >= 0.001", - Provider: ddProviderIntervalDefault, + Provider: newQueryDefaultProvider(), }, expectedIntervalSeconds: 300, expectedPhase: v1alpha1.AnalysisPhaseError, - expectedErrorMessage: "Could not parse JSON body: json: cannot unmarshal string into Go struct field .Data.Attributes.Values of type [][]float64", + expectedErrorMessage: "Could not parse JSON body: json: cannot unmarshal string into Go struct field .Data.Attributes.Columns.Values of type []float64", useEnvVarForKeys: false, }, // Error if server address is faulty { - serverURL: "://wrong.schema", - metric: v1alpha1.Metric{}, + serverURL: "://wrong.schema", + metric: v1alpha1.Metric{ + Provider: newQueryProviderInterval10m(), + }, expectedPhase: v1alpha1.AnalysisPhaseError, expectedErrorMessage: "parse \"://wrong.schema\": missing protocol scheme", useEnvVarForKeys: false, }, + + // Queries + Formula + // Expect success with default() and data + { + webServerStatus: 200, + webServerResponse: `{"data": {"attributes": {"columns": [ {"values": [0.0006444881882246533]}]}}}`, + metric: v1alpha1.Metric{ + Name: "expect success queries and formula", + SuccessCondition: "default(result, 0) < 0.05", + Provider: newQueriesDefaultProvider(), + }, + expectedIntervalSeconds: 300, + expectedValue: "0.0006444881882246533", + expectedPhase: v1alpha1.AnalysisPhaseSuccessful, + useEnvVarForKeys: false, + }, } // Run @@ -238,9 +262,8 @@ func TestRunSuiteV2(t *testing.T) { if serverURL == "" { // Server setup with response server := httptest.NewServer(http.HandlerFunc(func(rw http.ResponseWriter, req *http.Request) { - - //Check query variables - bodyBytes, err := ioutil.ReadAll(req.Body) + // Check query variables + bodyBytes, err := io.ReadAll(req.Body) if err != nil { t.Errorf("\nreceived no bytes in request: %v", err) } @@ -251,12 +274,29 @@ func TestRunSuiteV2(t *testing.T) { t.Errorf("\nCould not parse JSON request body: %v", err) } + // Keep the simple check behaviour if there is no Queries passed in from the analysis run + usesQuery := len(test.metric.Provider.Datadog.Queries) == 0 + usesFormula := test.metric.Provider.Datadog.Formula != "" + + actualFormulas := reqBody.Data.Attributes.Formulas actualQuery := reqBody.Data.Attributes.Queries[0]["query"] + actualQueries := reqBody.Data.Attributes.Queries actualFrom := reqBody.Data.Attributes.From actualTo := reqBody.Data.Attributes.To - if actualQuery != "avg:kubernetes.cpu.user.total{*}" { - t.Errorf("\nquery expected avg:kubernetes.cpu.user.total{*} but got %s", actualQuery) + if usesQuery { + if actualQuery != "avg:kubernetes.cpu.user.total{*}" { + t.Errorf("\nquery expected avg:kubernetes.cpu.user.total{*} but got %s", actualQuery) + } + } else { + // Check queries has expected number of queries + if len(actualQueries) != len(test.metric.Provider.Datadog.Queries) { + t.Errorf("\nExpected %d queries but received %d", len(test.metric.Provider.Datadog.Queries), len(reqBody.Data.Attributes.Queries)) + } + + if usesFormula && len(actualFormulas) == 0 { + t.Errorf("\nExpected formula but no Formulas in request: %+v", actualFormulas) + } } if actualFrom != (unixNow()-test.expectedIntervalSeconds)*1000 { @@ -271,7 +311,7 @@ func TestRunSuiteV2(t *testing.T) { t.Errorf("\nfailed to parse to: %v", err) } - //Check headers + // Check headers if req.Header.Get("Content-Type") != "application/json" { t.Errorf("\nContent-Type header expected to be application/json but got %s", req.Header.Get("Content-Type")) } @@ -326,7 +366,7 @@ func TestRunSuiteV2(t *testing.T) { return true, tokenSecret, nil }) - provider, _ := NewDatadogProvider(*logCtx, fakeClient) + provider, _ := NewDatadogProvider(*logCtx, fakeClient, test.metric) metricsMetadata := provider.GetMetadata(test.metric) assert.Nil(t, metricsMetadata) diff --git a/metricproviders/datadog/datadog_test.go b/metricproviders/datadog/datadog_test.go new file mode 100644 index 0000000000..50513d8e13 --- /dev/null +++ b/metricproviders/datadog/datadog_test.go @@ -0,0 +1,147 @@ +// These are tests that don't belong to v1 or v2 API + +package datadog + +import ( + "log" + "os" + "testing" + + "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1" + "github.com/stretchr/testify/assert" + apiextv1 "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1" + "k8s.io/client-go/kubernetes/scheme" +) + +func TestDatadogSpecDefaults(t *testing.T) { + _ = apiextv1.AddToScheme(scheme.Scheme) + decode := scheme.Codecs.UniversalDeserializer().Decode + + // Load CRD yaml. Is this icky? It seems like the best way to guarantee + // what we expect, since setting the default is via annotations + // Only bothering with the analysis-template-crd. We know cluster-analysis-template-crd + // & analysis-run-crd are all generated from the same source object. + data, err := os.ReadFile("../../manifests/crds/analysis-template-crd.yaml") + if err != nil { + log.Fatalf("could not read CRD file: %v", err) + } + obj, gVK, err := decode(data, nil, nil) + if err != nil { + log.Fatalf("error parsing file: %v", err) + } + if gVK.Kind != "CustomResourceDefinition" { + log.Fatalf("object was not a CRD") + } + + o := obj.(*apiextv1.CustomResourceDefinition) + ddSpec := o.Spec.Versions[0].Schema.OpenAPIV3Schema.Properties["spec"].Properties["metrics"].Items.Schema.Properties["provider"].Properties["datadog"] + + t.Run("apiVersion: Validate default is v1", func(t *testing.T) { + defaultVersion := string(ddSpec.Properties["apiVersion"].Default.Raw) + assert.Equal(t, "\"v1\"", defaultVersion, "Default version should be v1") + }) + + t.Run("apiVersion: Validate enum exists to restrict apiVersion to 2 options", func(t *testing.T) { + versionEnums := ddSpec.Properties["apiVersion"].Enum + assert.Equal(t, 2, len(versionEnums), "Expecting 2 enum options") + assert.Equal(t, "\"v1\"", string(versionEnums[0].Raw), "\"v1\" expected, got %s", string(versionEnums[0].Raw)) + assert.Equal(t, "\"v2\"", string(versionEnums[1].Raw), "\"v2\" is missing, got %s", string(versionEnums[1].Raw)) + }) + + t.Run("interval: Validate default is 5m", func(t *testing.T) { + defaultInterval := string(ddSpec.Properties["interval"].Default.Raw) + assert.Equal(t, "\"5m\"", defaultInterval, "Default interval should be \"5m\" ") + }) +} + +func TestValidateIncomingProps(t *testing.T) { + tests := []struct { + name string + metric *v1alpha1.DatadogMetric + expectedErrorMessage string + }{ + { + name: "query and queries missing", + metric: &v1alpha1.DatadogMetric{ + ApiVersion: "v1", + Query: "", + Queries: nil, + }, + expectedErrorMessage: "Must have either a query or queries", + }, + { + name: "both query and queries", + metric: &v1alpha1.DatadogMetric{ + ApiVersion: "v1", + Query: "foo", + Queries: map[string]string{"a": "sum:api_gateway.request.count{*}.as_count()"}, + }, + expectedErrorMessage: "Cannot have both a query and queries", + }, + { + name: "queries with v1 api", + metric: &v1alpha1.DatadogMetric{ + ApiVersion: "v1", + Queries: map[string]string{"a": "sum:api_gateway.request.count{*}.as_count()"}, + }, + expectedErrorMessage: "Query is empty. API Version v1 only supports using the query parameter in your Analysis Template.", + }, + { + name: "formula/queries with wrong apiVersion", + metric: &v1alpha1.DatadogMetric{ + ApiVersion: "v1", + Queries: map[string]string{"a": "sum:api_gateway.request.count{*}.as_count()"}, + Formula: "a", + }, + expectedErrorMessage: "Query is empty. API Version v1 only supports using the query parameter in your Analysis Template.", + }, + { + name: "formula without queries", + metric: &v1alpha1.DatadogMetric{ + ApiVersion: "v1", + Formula: "foo / bar", + Query: "foo", + }, + expectedErrorMessage: "Formula are only valid when queries are set", + }, + { + name: "More than 1 queries with no formula", + metric: &v1alpha1.DatadogMetric{ + ApiVersion: "v2", + Query: "", + Queries: map[string]string{"a": "sum:api_gateway.request.count{*}.as_count()", "b": "fish bike"}, + }, + expectedErrorMessage: "When multiple queries are provided you must include a formula.", + }, + { + name: "valid simple query with v2", + metric: &v1alpha1.DatadogMetric{ + ApiVersion: "v2", + Query: "foo", + }, + expectedErrorMessage: "", + }, + { + name: "valid queries with v2", + metric: &v1alpha1.DatadogMetric{ + ApiVersion: "v2", + Query: "", + Queries: map[string]string{"a": "sum:api_gateway.request.count{*}.as_count()", "b": "fish bike"}, + Formula: "a + b", + }, + expectedErrorMessage: "", + }, + } + + for _, test := range tests { + t.Run(test.name, func(t *testing.T) { + err := validateIncomingProps(test.metric) + if test.expectedErrorMessage != "" { + assert.Error(t, err) + assert.Contains(t, err.Error(), test.expectedErrorMessage) + } else { + assert.NoError(t, err) + } + }) + } +} diff --git a/metricproviders/metricproviders.go b/metricproviders/metricproviders.go index 1be0042c23..d8e6c09881 100644 --- a/metricproviders/metricproviders.go +++ b/metricproviders/metricproviders.go @@ -58,7 +58,7 @@ func (f *ProviderFactory) NewProvider(logCtx log.Entry, metric v1alpha1.Metric) } return webmetric.NewWebMetricProvider(logCtx, c, p), nil case datadog.ProviderType: - return datadog.NewDatadogProvider(logCtx, f.KubeClient) + return datadog.NewDatadogProvider(logCtx, f.KubeClient, metric) case wavefront.ProviderType: client, err := wavefront.NewWavefrontAPI(metric, f.KubeClient) if err != nil { diff --git a/pkg/apiclient/rollout/rollout.swagger.json b/pkg/apiclient/rollout/rollout.swagger.json index c2da4990c7..4a4903a545 100755 --- a/pkg/apiclient/rollout/rollout.swagger.json +++ b/pkg/apiclient/rollout/rollout.swagger.json @@ -1161,14 +1161,26 @@ "type": "object", "properties": { "interval": { - "type": "string" + "type": "string", + "description": "+kubebuilder:default=\"5m\"\nInterval refers to the Interval time window in Datadog (default: 5m). Not to be confused with the polling rate for the metric." }, "query": { "type": "string" }, + "queries": { + "type": "object", + "additionalProperties": { + "type": "string" + }, + "title": "Queries is a map of query_name_as_key: query. You can then use query_name_as_key inside Formula.Used for v2\n+kubebuilder:validation:Type=object" + }, + "formula": { + "type": "string", + "title": "Formula refers to the Formula made up of the queries. Only useful with Queries. Used for v2" + }, "apiVersion": { "type": "string", - "description": "ApiVersion refers to the Datadog API version being used (default: v1). v1 will eventually be deprecated." + "title": "ApiVersion refers to the Datadog API version being used (default: v1). v1 will eventually be deprecated.\n+kubebuilder:validation:Enum=v1;v2\n+kubebuilder:default=v1" } } }, diff --git a/pkg/apis/rollouts/v1alpha1/analysis_types.go b/pkg/apis/rollouts/v1alpha1/analysis_types.go index 1988f44169..af47a99222 100644 --- a/pkg/apis/rollouts/v1alpha1/analysis_types.go +++ b/pkg/apis/rollouts/v1alpha1/analysis_types.go @@ -396,8 +396,8 @@ type ValueFrom struct { // Secret is a reference to where a secret is stored. This field is one of the fields with valueFrom // +optional SecretKeyRef *SecretKeyRef `json:"secretKeyRef,omitempty" protobuf:"bytes,1,opt,name=secretKeyRef"` - //FieldRef is a reference to the fields in metadata which we are referencing. This field is one of the fields with - //valueFrom + // FieldRef is a reference to the fields in metadata which we are referencing. This field is one of the fields with + // valueFrom // +optional FieldRef *FieldRef `json:"fieldRef,omitempty" protobuf:"bytes,2,opt,name=fieldRef"` } @@ -569,8 +569,17 @@ type WebMetricHeader struct { } type DatadogMetric struct { + // +kubebuilder:default="5m" + // Interval refers to the Interval time window in Datadog (default: 5m). Not to be confused with the polling rate for the metric. Interval DurationString `json:"interval,omitempty" protobuf:"bytes,1,opt,name=interval,casttype=DurationString"` - Query string `json:"query" protobuf:"bytes,2,opt,name=query"` + Query string `json:"query,omitempty" protobuf:"bytes,2,opt,name=query"` + // Queries is a map of query_name_as_key: query. You can then use query_name_as_key inside Formula.Used for v2 + // +kubebuilder:validation:Type=object + Queries map[string]string `json:"queries,omitempty" protobuf:"bytes,3,opt,name=queries"` + // Formula refers to the Formula made up of the queries. Only useful with Queries. Used for v2 + Formula string `json:"formula,omitempty" protobuf:"bytes,4,opt,name=formula"` // ApiVersion refers to the Datadog API version being used (default: v1). v1 will eventually be deprecated. - ApiVersion string `json:"apiVersion,omitempty" protobuf:"bytes,3,opt,name=apiVersion"` + // +kubebuilder:validation:Enum=v1;v2 + // +kubebuilder:default=v1 + ApiVersion string `json:"apiVersion,omitempty" protobuf:"bytes,5,opt,name=apiVersion"` } diff --git a/pkg/apis/rollouts/v1alpha1/generated.pb.go b/pkg/apis/rollouts/v1alpha1/generated.pb.go index bfefbed404..5f9239efe8 100644 --- a/pkg/apis/rollouts/v1alpha1/generated.pb.go +++ b/pkg/apis/rollouts/v1alpha1/generated.pb.go @@ -3231,6 +3231,7 @@ func init() { proto.RegisterType((*ClusterAnalysisTemplate)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.ClusterAnalysisTemplate") proto.RegisterType((*ClusterAnalysisTemplateList)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.ClusterAnalysisTemplateList") proto.RegisterType((*DatadogMetric)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.DatadogMetric") + proto.RegisterMapType((map[string]string)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.DatadogMetric.QueriesEntry") proto.RegisterType((*DryRun)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.DryRun") proto.RegisterType((*Experiment)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.Experiment") proto.RegisterType((*ExperimentAnalysisRunStatus)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.ExperimentAnalysisRunStatus") @@ -3321,528 +3322,532 @@ func init() { } var fileDescriptor_e0e705f843545fab = []byte{ - // 8334 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x7d, 0x6d, 0x6c, 0x24, 0xd9, - 0x71, 0xd8, 0x35, 0x87, 0x43, 0x72, 0x8a, 0x5c, 0x92, 0xfb, 0x76, 0x57, 0xcb, 0xe3, 0xdd, 0xee, - 0x9c, 0xfa, 0x9c, 0xcb, 0xca, 0x3a, 0x91, 0xd2, 0xde, 0x5d, 0x72, 0xd2, 0x29, 0x97, 0xcc, 0x90, - 0xbb, 0xb7, 0xdc, 0x23, 0x77, 0xb9, 0x35, 0xdc, 0x5b, 0x59, 0xd2, 0xd9, 0x6a, 0xce, 0x3c, 0x0e, - 0x7b, 0x39, 0xd3, 0x3d, 0xee, 0xee, 0xe1, 0x2e, 0x4f, 0x07, 0xeb, 0x64, 0xe1, 0x14, 0xc5, 0x90, - 0x60, 0x25, 0xb6, 0x10, 0x04, 0x09, 0x02, 0xc5, 0x30, 0x60, 0x27, 0xf6, 0x2f, 0x21, 0x41, 0xfe, - 0x18, 0x88, 0x10, 0xc7, 0xb6, 0x7e, 0xc4, 0x81, 0xfc, 0x23, 0x91, 0x1d, 0xc0, 0x74, 0x44, 0xe7, - 0x4f, 0x82, 0x04, 0x42, 0x02, 0x05, 0x81, 0xf7, 0x47, 0x10, 0xbc, 0xcf, 0x7e, 0xdd, 0xd3, 0xc3, - 0x9d, 0xe1, 0x34, 0x57, 0x4a, 0xac, 0x7f, 0x33, 0xaf, 0xea, 0x55, 0x55, 0xbf, 0xcf, 0x7a, 0xf5, - 0xaa, 0xea, 0xc1, 0x7a, 0xd3, 0x8d, 0x76, 0xbb, 0xdb, 0x4b, 0x75, 0xbf, 0xbd, 0xec, 0x04, 0x4d, - 0xbf, 0x13, 0xf8, 0xf7, 0xf9, 0x8f, 0x8f, 0x04, 0x7e, 0xab, 0xe5, 0x77, 0xa3, 0x70, 0xb9, 0xb3, - 0xd7, 0x5c, 0x76, 0x3a, 0x6e, 0xb8, 0xac, 0x4b, 0xf6, 0x3f, 0xe6, 0xb4, 0x3a, 0xbb, 0xce, 0xc7, - 0x96, 0x9b, 0xd4, 0xa3, 0x81, 0x13, 0xd1, 0xc6, 0x52, 0x27, 0xf0, 0x23, 0x9f, 0x7c, 0x32, 0xa6, - 0xb6, 0xa4, 0xa8, 0xf1, 0x1f, 0x3f, 0xa7, 0xea, 0x2e, 0x75, 0xf6, 0x9a, 0x4b, 0x8c, 0xda, 0x92, - 0x2e, 0x51, 0xd4, 0x16, 0x3f, 0x62, 0xc8, 0xd2, 0xf4, 0x9b, 0xfe, 0x32, 0x27, 0xba, 0xdd, 0xdd, - 0xe1, 0xff, 0xf8, 0x1f, 0xfe, 0x4b, 0x30, 0x5b, 0x7c, 0x7e, 0xef, 0xd5, 0x70, 0xc9, 0xf5, 0x99, - 0x6c, 0xcb, 0xdb, 0x4e, 0x54, 0xdf, 0x5d, 0xde, 0xef, 0x91, 0x68, 0xd1, 0x36, 0x90, 0xea, 0x7e, - 0x40, 0xb3, 0x70, 0x5e, 0x8e, 0x71, 0xda, 0x4e, 0x7d, 0xd7, 0xf5, 0x68, 0x70, 0x10, 0x7f, 0x75, - 0x9b, 0x46, 0x4e, 0x56, 0xad, 0xe5, 0x7e, 0xb5, 0x82, 0xae, 0x17, 0xb9, 0x6d, 0xda, 0x53, 0xe1, - 0xaf, 0x3d, 0xae, 0x42, 0x58, 0xdf, 0xa5, 0x6d, 0xa7, 0xa7, 0xde, 0x4b, 0xfd, 0xea, 0x75, 0x23, - 0xb7, 0xb5, 0xec, 0x7a, 0x51, 0x18, 0x05, 0xe9, 0x4a, 0xf6, 0x0f, 0x0a, 0x50, 0xaa, 0xac, 0x57, - 0x6b, 0x91, 0x13, 0x75, 0x43, 0xf2, 0x65, 0x0b, 0x66, 0x5a, 0xbe, 0xd3, 0xa8, 0x3a, 0x2d, 0xc7, - 0xab, 0xd3, 0x60, 0xc1, 0x7a, 0xce, 0xba, 0x32, 0x7d, 0x75, 0x7d, 0x69, 0x94, 0xfe, 0x5a, 0xaa, - 0x3c, 0x08, 0x91, 0x86, 0x7e, 0x37, 0xa8, 0x53, 0xa4, 0x3b, 0xd5, 0xf3, 0xdf, 0x39, 0x2c, 0x3f, - 0x75, 0x74, 0x58, 0x9e, 0x59, 0x37, 0x38, 0x61, 0x82, 0x2f, 0xf9, 0x86, 0x05, 0x67, 0xeb, 0x8e, - 0xe7, 0x04, 0x07, 0x5b, 0x4e, 0xd0, 0xa4, 0xd1, 0x1b, 0x81, 0xdf, 0xed, 0x2c, 0x8c, 0x9d, 0x82, - 0x34, 0x4f, 0x4b, 0x69, 0xce, 0xae, 0xa4, 0xd9, 0x61, 0xaf, 0x04, 0x5c, 0xae, 0x30, 0x72, 0xb6, - 0x5b, 0xd4, 0x94, 0xab, 0x70, 0x9a, 0x72, 0xd5, 0xd2, 0xec, 0xb0, 0x57, 0x02, 0xf2, 0x21, 0x98, - 0x74, 0xbd, 0x66, 0x40, 0xc3, 0x70, 0x61, 0xfc, 0x39, 0xeb, 0x4a, 0xa9, 0x3a, 0x27, 0xab, 0x4f, - 0xae, 0x89, 0x62, 0x54, 0x70, 0xfb, 0x5b, 0x05, 0x38, 0x5b, 0x59, 0xaf, 0x6e, 0x05, 0xce, 0xce, - 0x8e, 0x5b, 0x47, 0xbf, 0x1b, 0xb9, 0x5e, 0xd3, 0x24, 0x60, 0x1d, 0x4f, 0x80, 0xbc, 0x02, 0xd3, - 0x21, 0x0d, 0xf6, 0xdd, 0x3a, 0xdd, 0xf4, 0x83, 0x88, 0x77, 0x4a, 0xb1, 0x7a, 0x4e, 0xa2, 0x4f, - 0xd7, 0x62, 0x10, 0x9a, 0x78, 0xac, 0x5a, 0xe0, 0xfb, 0x91, 0x84, 0xf3, 0x36, 0x2b, 0xc5, 0xd5, - 0x30, 0x06, 0xa1, 0x89, 0x47, 0x56, 0x61, 0xde, 0xf1, 0x3c, 0x3f, 0x72, 0x22, 0xd7, 0xf7, 0x36, - 0x03, 0xba, 0xe3, 0x3e, 0x94, 0x9f, 0xb8, 0x20, 0xeb, 0xce, 0x57, 0x52, 0x70, 0xec, 0xa9, 0x41, - 0xbe, 0x6e, 0xc1, 0x7c, 0x18, 0xb9, 0xf5, 0x3d, 0xd7, 0xa3, 0x61, 0xb8, 0xe2, 0x7b, 0x3b, 0x6e, - 0x73, 0xa1, 0xc8, 0xbb, 0xed, 0xd6, 0x68, 0xdd, 0x56, 0x4b, 0x51, 0xad, 0x9e, 0x67, 0x22, 0xa5, - 0x4b, 0xb1, 0x87, 0x3b, 0xf9, 0x30, 0x94, 0x64, 0x8b, 0xd2, 0x70, 0x61, 0xe2, 0xb9, 0xc2, 0x95, - 0x52, 0xf5, 0xcc, 0xd1, 0x61, 0xb9, 0xb4, 0xa6, 0x0a, 0x31, 0x86, 0xdb, 0xab, 0xb0, 0x50, 0x69, - 0x6f, 0x3b, 0x61, 0xe8, 0x34, 0xfc, 0x20, 0xd5, 0x75, 0x57, 0x60, 0xaa, 0xed, 0x74, 0x3a, 0xae, - 0xd7, 0x64, 0x7d, 0xc7, 0xe8, 0xcc, 0x1c, 0x1d, 0x96, 0xa7, 0x36, 0x64, 0x19, 0x6a, 0xa8, 0xfd, - 0x27, 0x63, 0x30, 0x5d, 0xf1, 0x9c, 0xd6, 0x41, 0xe8, 0x86, 0xd8, 0xf5, 0xc8, 0xe7, 0x60, 0x8a, - 0xad, 0x5a, 0x0d, 0x27, 0x72, 0xe4, 0x4c, 0xff, 0xe8, 0x92, 0x58, 0x44, 0x96, 0xcc, 0x45, 0x24, - 0xfe, 0x7c, 0x86, 0xbd, 0xb4, 0xff, 0xb1, 0xa5, 0xdb, 0xdb, 0xf7, 0x69, 0x3d, 0xda, 0xa0, 0x91, - 0x53, 0x25, 0xb2, 0x17, 0x20, 0x2e, 0x43, 0x4d, 0x95, 0xf8, 0x30, 0x1e, 0x76, 0x68, 0x5d, 0xce, - 0xdc, 0x8d, 0x11, 0x67, 0x48, 0x2c, 0x7a, 0xad, 0x43, 0xeb, 0xd5, 0x19, 0xc9, 0x7a, 0x9c, 0xfd, - 0x43, 0xce, 0x88, 0x3c, 0x80, 0x89, 0x90, 0xaf, 0x65, 0x72, 0x52, 0xde, 0xce, 0x8f, 0x25, 0x27, - 0x5b, 0x9d, 0x95, 0x4c, 0x27, 0xc4, 0x7f, 0x94, 0xec, 0xec, 0xff, 0x68, 0xc1, 0x39, 0x03, 0xbb, - 0x12, 0x34, 0xbb, 0x6d, 0xea, 0x45, 0xe4, 0x39, 0x18, 0xf7, 0x9c, 0x36, 0x95, 0xb3, 0x4a, 0x8b, - 0x7c, 0xcb, 0x69, 0x53, 0xe4, 0x10, 0xf2, 0x3c, 0x14, 0xf7, 0x9d, 0x56, 0x97, 0xf2, 0x46, 0x2a, - 0x55, 0xcf, 0x48, 0x94, 0xe2, 0x5b, 0xac, 0x10, 0x05, 0x8c, 0xbc, 0x0b, 0x25, 0xfe, 0xe3, 0x7a, - 0xe0, 0xb7, 0x73, 0xfa, 0x34, 0x29, 0xe1, 0x5b, 0x8a, 0xac, 0x18, 0x7e, 0xfa, 0x2f, 0xc6, 0x0c, - 0xed, 0x3f, 0xb3, 0x60, 0xce, 0xf8, 0xb8, 0x75, 0x37, 0x8c, 0xc8, 0x67, 0x7b, 0x06, 0xcf, 0xd2, - 0x60, 0x83, 0x87, 0xd5, 0xe6, 0x43, 0x67, 0x5e, 0x7e, 0xe9, 0x94, 0x2a, 0x31, 0x06, 0x8e, 0x07, - 0x45, 0x37, 0xa2, 0xed, 0x70, 0x61, 0xec, 0xb9, 0xc2, 0x95, 0xe9, 0xab, 0x6b, 0xb9, 0x75, 0x63, - 0xdc, 0xbe, 0x6b, 0x8c, 0x3e, 0x0a, 0x36, 0xf6, 0x3f, 0x2f, 0x24, 0xba, 0x6f, 0x43, 0xc9, 0xf1, - 0xbe, 0x05, 0x13, 0x2d, 0x67, 0x9b, 0xb6, 0xc4, 0xdc, 0x9a, 0xbe, 0xfa, 0x76, 0x6e, 0x92, 0x28, - 0x1e, 0x4b, 0xeb, 0x9c, 0xfe, 0x35, 0x2f, 0x0a, 0x0e, 0xe2, 0xe1, 0x25, 0x0a, 0x51, 0x32, 0x27, - 0xff, 0xc0, 0x82, 0xe9, 0x78, 0x55, 0x53, 0xcd, 0xb2, 0x9d, 0xbf, 0x30, 0xf1, 0x62, 0x2a, 0x25, - 0xd2, 0x4b, 0xb4, 0x01, 0x41, 0x53, 0x96, 0xc5, 0x8f, 0xc3, 0xb4, 0xf1, 0x09, 0x64, 0x1e, 0x0a, - 0x7b, 0xf4, 0x40, 0x0c, 0x78, 0x64, 0x3f, 0xc9, 0xf9, 0xc4, 0x08, 0x97, 0x43, 0xfa, 0x13, 0x63, - 0xaf, 0x5a, 0x8b, 0xaf, 0xc3, 0x7c, 0x9a, 0xe1, 0x30, 0xf5, 0xed, 0x6f, 0x8d, 0x27, 0x06, 0x26, - 0x5b, 0x08, 0x88, 0x0f, 0x93, 0x6d, 0x1a, 0x05, 0x6e, 0x5d, 0x75, 0xd9, 0xea, 0x68, 0xad, 0xb4, - 0xc1, 0x89, 0xc5, 0x1b, 0xa2, 0xf8, 0x1f, 0xa2, 0xe2, 0x42, 0x76, 0x61, 0xdc, 0x09, 0x9a, 0xaa, - 0x4f, 0xae, 0xe7, 0x33, 0x2d, 0xe3, 0xa5, 0xa2, 0x12, 0x34, 0x43, 0xe4, 0x1c, 0xc8, 0x32, 0x94, - 0x22, 0x1a, 0xb4, 0x5d, 0xcf, 0x89, 0xc4, 0x0e, 0x3a, 0x55, 0x3d, 0x2b, 0xd1, 0x4a, 0x5b, 0x0a, - 0x80, 0x31, 0x0e, 0x69, 0xc1, 0x44, 0x23, 0x38, 0xc0, 0xae, 0xb7, 0x30, 0x9e, 0x47, 0x53, 0xac, - 0x72, 0x5a, 0xf1, 0x20, 0x15, 0xff, 0x51, 0xf2, 0x20, 0xbf, 0x6e, 0xc1, 0xf9, 0x36, 0x75, 0xc2, - 0x6e, 0x40, 0xd9, 0x27, 0x20, 0x8d, 0xa8, 0xc7, 0x3a, 0x76, 0xa1, 0xc8, 0x99, 0xe3, 0xa8, 0xfd, - 0xd0, 0x4b, 0xb9, 0xfa, 0xac, 0x14, 0xe5, 0x7c, 0x16, 0x14, 0x33, 0xa5, 0xb1, 0xff, 0x64, 0x1c, - 0xce, 0xf6, 0x2c, 0xec, 0xe4, 0x65, 0x28, 0x76, 0x76, 0x9d, 0x50, 0xad, 0xd4, 0x97, 0xd5, 0x32, - 0xb1, 0xc9, 0x0a, 0x1f, 0x1d, 0x96, 0xcf, 0xa8, 0x2a, 0xbc, 0x00, 0x05, 0x32, 0xd3, 0x9b, 0xda, - 0x34, 0x0c, 0x9d, 0xa6, 0x5a, 0xbe, 0x8d, 0x61, 0xc2, 0x8b, 0x51, 0xc1, 0xc9, 0xdf, 0xb6, 0xe0, - 0x8c, 0x18, 0x32, 0x48, 0xc3, 0x6e, 0x2b, 0x62, 0x5b, 0x14, 0x6b, 0x96, 0x9b, 0x79, 0x0c, 0x4f, - 0x41, 0xb2, 0x7a, 0x41, 0x72, 0x3f, 0x63, 0x96, 0x86, 0x98, 0xe4, 0x4b, 0xee, 0x41, 0x29, 0x8c, - 0x9c, 0x20, 0xa2, 0x8d, 0x4a, 0xc4, 0x95, 0xa9, 0xe9, 0xab, 0x3f, 0x3d, 0xd8, 0xda, 0xbd, 0xe5, - 0xb6, 0xa9, 0xd8, 0x27, 0x6a, 0x8a, 0x00, 0xc6, 0xb4, 0xc8, 0xbb, 0x00, 0x41, 0xd7, 0xab, 0x75, - 0xdb, 0x6d, 0x27, 0x38, 0x90, 0xfa, 0xd5, 0x8d, 0xd1, 0x3e, 0x0f, 0x35, 0xbd, 0x58, 0xd5, 0x88, - 0xcb, 0xd0, 0xe0, 0x47, 0xbe, 0x68, 0xc1, 0x19, 0x31, 0x12, 0x95, 0x04, 0x13, 0x39, 0x4b, 0x70, - 0x96, 0x35, 0xed, 0xaa, 0xc9, 0x02, 0x93, 0x1c, 0xed, 0x7f, 0x9f, 0x54, 0x03, 0x6a, 0x11, 0x3b, - 0x6c, 0x35, 0x0f, 0xc8, 0x67, 0xe0, 0xe9, 0xb0, 0x5b, 0xaf, 0xd3, 0x30, 0xdc, 0xe9, 0xb6, 0xb0, - 0xeb, 0xdd, 0x70, 0xc3, 0xc8, 0x0f, 0x0e, 0xd6, 0xdd, 0xb6, 0x1b, 0xf1, 0x11, 0x57, 0xac, 0x5e, - 0x3a, 0x3a, 0x2c, 0x3f, 0x5d, 0xeb, 0x87, 0x84, 0xfd, 0xeb, 0x13, 0x07, 0x9e, 0xe9, 0x7a, 0xfd, - 0xc9, 0x0b, 0x0d, 0xbd, 0x7c, 0x74, 0x58, 0x7e, 0xe6, 0x6e, 0x7f, 0x34, 0x3c, 0x8e, 0x86, 0xfd, - 0x5f, 0x2d, 0xb6, 0x52, 0x8b, 0xef, 0xda, 0xa2, 0xed, 0x4e, 0x8b, 0xad, 0x2e, 0xa7, 0xaf, 0x3f, - 0x46, 0x09, 0xfd, 0x11, 0xf3, 0xd9, 0xee, 0x94, 0xfc, 0xfd, 0x94, 0x48, 0xfb, 0xbf, 0x58, 0x70, - 0x3e, 0x8d, 0xfc, 0x04, 0x74, 0x9e, 0x30, 0xa9, 0xf3, 0xdc, 0xca, 0xf7, 0x6b, 0xfb, 0x28, 0x3e, - 0x5f, 0x1e, 0xef, 0xfd, 0xd6, 0xff, 0xdf, 0xb7, 0xd1, 0x78, 0x57, 0x2c, 0xfc, 0x28, 0x77, 0xc5, - 0xf1, 0x1f, 0xab, 0x5d, 0xf1, 0x37, 0xc7, 0x61, 0xa6, 0xe2, 0x45, 0x6e, 0x65, 0x67, 0xc7, 0xf5, - 0xdc, 0xe8, 0x80, 0x7c, 0x75, 0x0c, 0x96, 0x3b, 0x01, 0xdd, 0xa1, 0x41, 0x40, 0x1b, 0xab, 0xdd, - 0xc0, 0xf5, 0x9a, 0xb5, 0xfa, 0x2e, 0x6d, 0x74, 0x5b, 0xae, 0xd7, 0x5c, 0x6b, 0x7a, 0xbe, 0x2e, - 0xbe, 0xf6, 0x90, 0xd6, 0xbb, 0xfc, 0x93, 0xc4, 0xa4, 0x68, 0x8f, 0xf6, 0x49, 0x9b, 0xc3, 0x31, - 0xad, 0xbe, 0x74, 0x74, 0x58, 0x5e, 0x1e, 0xb2, 0x12, 0x0e, 0xfb, 0x69, 0xe4, 0x2b, 0x63, 0xb0, - 0x14, 0xd0, 0x9f, 0xef, 0xba, 0x83, 0xb7, 0x86, 0x58, 0xb5, 0x5a, 0x23, 0x6e, 0x3f, 0x43, 0xf1, - 0xac, 0x5e, 0x3d, 0x3a, 0x2c, 0x0f, 0x59, 0x07, 0x87, 0xfc, 0x2e, 0x7b, 0x13, 0xa6, 0x2b, 0x1d, - 0x37, 0x74, 0x1f, 0xa2, 0xdf, 0x8d, 0xe8, 0x00, 0x47, 0xdc, 0x32, 0x14, 0x83, 0x6e, 0x8b, 0x8a, - 0xb9, 0x5d, 0xaa, 0x96, 0xd8, 0x2a, 0x84, 0xac, 0x00, 0x45, 0xb9, 0xfd, 0x8b, 0x6c, 0xc5, 0xe5, - 0x24, 0x53, 0xc6, 0x8d, 0xfb, 0x50, 0x0c, 0x18, 0x13, 0x39, 0xb2, 0x46, 0x3d, 0x07, 0xc6, 0x52, - 0x4b, 0x21, 0xd8, 0x4f, 0x14, 0x2c, 0xec, 0xdf, 0x1d, 0x83, 0x0b, 0x95, 0x4e, 0x67, 0x83, 0x86, - 0xbb, 0x29, 0x29, 0x7e, 0xd9, 0x82, 0xd9, 0x7d, 0x37, 0x88, 0xba, 0x4e, 0x4b, 0xd9, 0xaf, 0x84, - 0x3c, 0xb5, 0x51, 0xe5, 0xe1, 0xdc, 0xde, 0x4a, 0x90, 0xae, 0x92, 0xa3, 0xc3, 0xf2, 0x6c, 0xb2, - 0x0c, 0x53, 0xec, 0xc9, 0xdf, 0xb7, 0x60, 0x5e, 0x16, 0xdd, 0xf2, 0x1b, 0xd4, 0xb4, 0x8f, 0xde, - 0xcd, 0x53, 0x26, 0x4d, 0x5c, 0xd8, 0xb5, 0xd2, 0xa5, 0xd8, 0x23, 0x84, 0xfd, 0xdf, 0xc7, 0xe0, - 0x62, 0x1f, 0x1a, 0xe4, 0x37, 0x2c, 0x38, 0x2f, 0x8c, 0xaa, 0x06, 0x08, 0xe9, 0x8e, 0x6c, 0xcd, - 0x9f, 0xc9, 0x5b, 0x72, 0x64, 0x53, 0x9c, 0x7a, 0x75, 0x5a, 0x5d, 0x60, 0xab, 0xe1, 0x4a, 0x06, - 0x6b, 0xcc, 0x14, 0x88, 0x4b, 0x2a, 0xcc, 0xac, 0x29, 0x49, 0xc7, 0x9e, 0x88, 0xa4, 0xb5, 0x0c, - 0xd6, 0x98, 0x29, 0x90, 0xfd, 0x37, 0xe1, 0x99, 0x63, 0xc8, 0x3d, 0x7e, 0x72, 0xda, 0x6f, 0xeb, - 0x51, 0x9f, 0x1c, 0x73, 0x03, 0xcc, 0x6b, 0x1b, 0x26, 0xf8, 0xd4, 0x51, 0x13, 0x1b, 0xd8, 0xf6, - 0xc7, 0xe7, 0x54, 0x88, 0x12, 0x62, 0xff, 0xae, 0x05, 0x53, 0x43, 0x58, 0xc3, 0xca, 0x49, 0x6b, - 0x58, 0xa9, 0xc7, 0x12, 0x16, 0xf5, 0x5a, 0xc2, 0xde, 0x18, 0xad, 0x37, 0x06, 0xb1, 0x80, 0xfd, - 0xc0, 0x82, 0xb3, 0x3d, 0x16, 0x33, 0xb2, 0x0b, 0xe7, 0x3b, 0x7e, 0x43, 0xa9, 0x4d, 0x37, 0x9c, - 0x70, 0x97, 0xc3, 0xe4, 0xe7, 0xbd, 0xcc, 0x7a, 0x72, 0x33, 0x03, 0xfe, 0xe8, 0xb0, 0xbc, 0xa0, - 0x89, 0xa4, 0x10, 0x30, 0x93, 0x22, 0xe9, 0xc0, 0xd4, 0x8e, 0x4b, 0x5b, 0x8d, 0x78, 0x08, 0x8e, - 0xa8, 0x20, 0x5d, 0x97, 0xd4, 0x84, 0xb1, 0x58, 0xfd, 0x43, 0xcd, 0xc5, 0xfe, 0xa1, 0x05, 0xb3, - 0x95, 0x6e, 0xb4, 0xcb, 0xd4, 0x83, 0x3a, 0xb7, 0xcf, 0x10, 0x0f, 0x8a, 0xa1, 0xdb, 0xdc, 0x7f, - 0x39, 0x9f, 0xc5, 0xb8, 0xc6, 0x48, 0x49, 0xa3, 0xb9, 0xd6, 0x4d, 0x79, 0x21, 0x0a, 0x36, 0x24, - 0x80, 0x09, 0xdf, 0xe9, 0x46, 0xbb, 0x57, 0xe5, 0x27, 0x8f, 0x78, 0x52, 0xbe, 0xcd, 0x3e, 0xe7, - 0xaa, 0xe4, 0xa8, 0xb5, 0x35, 0x51, 0x8a, 0x92, 0x93, 0xfd, 0x05, 0x98, 0x4d, 0xde, 0xc4, 0x0c, - 0x30, 0x66, 0x2f, 0x41, 0xc1, 0x09, 0x3c, 0x39, 0x62, 0xa7, 0x25, 0x42, 0xa1, 0x82, 0xb7, 0x90, - 0x95, 0x93, 0x17, 0x61, 0x6a, 0xa7, 0xdb, 0x6a, 0xb1, 0x0a, 0xf2, 0xda, 0x43, 0x9f, 0x02, 0xae, - 0xcb, 0x72, 0xd4, 0x18, 0xf6, 0x5f, 0x8c, 0xc3, 0x5c, 0xb5, 0xd5, 0xa5, 0x6f, 0x04, 0x94, 0x2a, - 0xdb, 0x44, 0x05, 0xe6, 0x3a, 0x01, 0xdd, 0x77, 0xe9, 0x83, 0x1a, 0x6d, 0xd1, 0x7a, 0xe4, 0x07, - 0x52, 0x9a, 0x8b, 0x92, 0xd0, 0xdc, 0x66, 0x12, 0x8c, 0x69, 0x7c, 0xf2, 0x3a, 0xcc, 0x3a, 0xf5, - 0xc8, 0xdd, 0xa7, 0x9a, 0x82, 0x10, 0xf7, 0x03, 0x92, 0xc2, 0x6c, 0x25, 0x01, 0xc5, 0x14, 0x36, - 0xf9, 0x2c, 0x2c, 0x84, 0x75, 0xa7, 0x45, 0xef, 0x76, 0x24, 0xab, 0x95, 0x5d, 0x5a, 0xdf, 0xdb, - 0xf4, 0x5d, 0x2f, 0x92, 0x96, 0xa8, 0xe7, 0x24, 0xa5, 0x85, 0x5a, 0x1f, 0x3c, 0xec, 0x4b, 0x81, - 0xfc, 0x2b, 0x0b, 0x2e, 0x75, 0x02, 0xba, 0x19, 0xf8, 0x6d, 0x9f, 0x0d, 0xb5, 0x1e, 0xf3, 0x8c, - 0x34, 0x53, 0xbc, 0x35, 0xa2, 0x2e, 0x25, 0x4a, 0x7a, 0xad, 0xfa, 0x1f, 0x3c, 0x3a, 0x2c, 0x5f, - 0xda, 0x3c, 0x4e, 0x00, 0x3c, 0x5e, 0x3e, 0xf2, 0xaf, 0x2d, 0xb8, 0xdc, 0xf1, 0xc3, 0xe8, 0x98, - 0x4f, 0x28, 0x9e, 0xea, 0x27, 0xd8, 0x47, 0x87, 0xe5, 0xcb, 0x9b, 0xc7, 0x4a, 0x80, 0x8f, 0x91, - 0xd0, 0x3e, 0x9a, 0x86, 0xb3, 0xc6, 0xd8, 0x93, 0xb6, 0x8b, 0xd7, 0xe0, 0x8c, 0x1a, 0x0c, 0xb1, - 0xee, 0x53, 0x8a, 0x6d, 0x4d, 0x15, 0x13, 0x88, 0x49, 0x5c, 0x36, 0xee, 0xf4, 0x50, 0x14, 0xb5, - 0x53, 0xe3, 0x6e, 0x33, 0x01, 0xc5, 0x14, 0x36, 0x59, 0x83, 0x73, 0xb2, 0x04, 0x69, 0xa7, 0xe5, - 0xd6, 0x9d, 0x15, 0xbf, 0x2b, 0x87, 0x5c, 0xb1, 0x7a, 0xf1, 0xe8, 0xb0, 0x7c, 0x6e, 0xb3, 0x17, - 0x8c, 0x59, 0x75, 0xc8, 0x3a, 0x9c, 0x77, 0xba, 0x91, 0xaf, 0xbf, 0xff, 0x9a, 0xc7, 0xb6, 0xd3, - 0x06, 0x1f, 0x5a, 0x53, 0x62, 0xdf, 0xad, 0x64, 0xc0, 0x31, 0xb3, 0x16, 0xd9, 0x4c, 0x51, 0xab, - 0xd1, 0xba, 0xef, 0x35, 0x44, 0x2f, 0x17, 0xe3, 0x13, 0x58, 0x25, 0x03, 0x07, 0x33, 0x6b, 0x92, - 0x16, 0xcc, 0xb6, 0x9d, 0x87, 0x77, 0x3d, 0x67, 0xdf, 0x71, 0x5b, 0x8c, 0x89, 0xb4, 0x5f, 0xf5, - 0x37, 0xaa, 0x74, 0x23, 0xb7, 0xb5, 0x24, 0x6e, 0xf6, 0x97, 0xd6, 0xbc, 0xe8, 0x76, 0x50, 0x8b, - 0x98, 0xa6, 0x2e, 0x34, 0xc8, 0x8d, 0x04, 0x2d, 0x4c, 0xd1, 0x26, 0xb7, 0xe1, 0x02, 0x9f, 0x8e, - 0xab, 0xfe, 0x03, 0x6f, 0x95, 0xb6, 0x9c, 0x03, 0xf5, 0x01, 0x93, 0xfc, 0x03, 0x9e, 0x3e, 0x3a, - 0x2c, 0x5f, 0xa8, 0x65, 0x21, 0x60, 0x76, 0x3d, 0xe2, 0xc0, 0x33, 0x49, 0x00, 0xd2, 0x7d, 0x37, - 0x74, 0x7d, 0x4f, 0x58, 0xa1, 0xa6, 0x62, 0x2b, 0x54, 0xad, 0x3f, 0x1a, 0x1e, 0x47, 0x83, 0xfc, - 0x43, 0x0b, 0xce, 0x67, 0x4d, 0xc3, 0x85, 0x52, 0x1e, 0xf7, 0x8b, 0xa9, 0xa9, 0x25, 0x46, 0x44, - 0xe6, 0xa2, 0x90, 0x29, 0x04, 0x79, 0xcf, 0x82, 0x19, 0xc7, 0x38, 0x41, 0x2f, 0x40, 0x1e, 0xbb, - 0x96, 0x79, 0x26, 0xaf, 0xce, 0x1f, 0x1d, 0x96, 0x13, 0xa7, 0x74, 0x4c, 0x70, 0x24, 0xff, 0xd8, - 0x82, 0x0b, 0x99, 0x73, 0x7c, 0x61, 0xfa, 0x34, 0x5a, 0x88, 0x0f, 0x92, 0xec, 0x35, 0x27, 0x5b, - 0x0c, 0xf2, 0x75, 0x4b, 0x6f, 0x65, 0xea, 0xca, 0x69, 0x61, 0x86, 0x8b, 0x76, 0x67, 0x44, 0xa3, - 0x41, 0xac, 0x35, 0x29, 0xc2, 0xd5, 0x73, 0xc6, 0xce, 0xa8, 0x0a, 0x31, 0xcd, 0x9e, 0x7c, 0xcd, - 0x52, 0x5b, 0xa3, 0x96, 0xe8, 0xcc, 0x69, 0x49, 0x44, 0xe2, 0x9d, 0x56, 0x0b, 0x94, 0x62, 0x4e, - 0x7e, 0x16, 0x16, 0x9d, 0x6d, 0x3f, 0x88, 0x32, 0x27, 0xdf, 0xc2, 0x2c, 0x9f, 0x46, 0x97, 0x8f, - 0x0e, 0xcb, 0x8b, 0x95, 0xbe, 0x58, 0x78, 0x0c, 0x05, 0xfb, 0xb7, 0x8b, 0x30, 0x23, 0x4e, 0x42, - 0x72, 0xeb, 0xfa, 0x1d, 0x0b, 0x9e, 0xad, 0x77, 0x83, 0x80, 0x7a, 0x51, 0x2d, 0xa2, 0x9d, 0xde, - 0x8d, 0xcb, 0x3a, 0xd5, 0x8d, 0xeb, 0xb9, 0xa3, 0xc3, 0xf2, 0xb3, 0x2b, 0xc7, 0xf0, 0xc7, 0x63, - 0xa5, 0x23, 0xff, 0xce, 0x02, 0x5b, 0x22, 0x54, 0x9d, 0xfa, 0x5e, 0x33, 0xf0, 0xbb, 0x5e, 0xa3, - 0xf7, 0x23, 0xc6, 0x4e, 0xf5, 0x23, 0x5e, 0x38, 0x3a, 0x2c, 0xdb, 0x2b, 0x8f, 0x95, 0x02, 0x07, - 0x90, 0x94, 0xbc, 0x01, 0x67, 0x25, 0xd6, 0xb5, 0x87, 0x1d, 0x1a, 0xb8, 0xec, 0xcc, 0x21, 0x15, - 0xc7, 0xd8, 0x5b, 0x29, 0x8d, 0x80, 0xbd, 0x75, 0x48, 0x08, 0x93, 0x0f, 0xa8, 0xdb, 0xdc, 0x8d, - 0x94, 0xfa, 0x34, 0xa2, 0x8b, 0x92, 0xb4, 0x8a, 0xdc, 0x13, 0x34, 0xab, 0xd3, 0x47, 0x87, 0xe5, - 0x49, 0xf9, 0x07, 0x15, 0x27, 0x72, 0x0b, 0x66, 0xc5, 0x39, 0x75, 0xd3, 0xf5, 0x9a, 0x9b, 0xbe, - 0x27, 0xfc, 0x6c, 0x4a, 0xd5, 0x17, 0xd4, 0x86, 0x5f, 0x4b, 0x40, 0x1f, 0x1d, 0x96, 0x67, 0xd4, - 0xef, 0xad, 0x83, 0x0e, 0xc5, 0x54, 0x6d, 0xfb, 0xf7, 0x27, 0x00, 0xd4, 0x70, 0xa5, 0x1d, 0xf2, - 0x61, 0x28, 0x85, 0x34, 0x12, 0x5c, 0xe5, 0xc5, 0x89, 0xb8, 0x8f, 0x52, 0x85, 0x18, 0xc3, 0xc9, - 0x1e, 0x14, 0x3b, 0x4e, 0x37, 0xa4, 0xf9, 0x9c, 0x1f, 0x64, 0xe7, 0x6f, 0x32, 0x8a, 0xe2, 0x60, - 0xca, 0x7f, 0xa2, 0xe0, 0x41, 0xbe, 0x64, 0x01, 0xd0, 0x64, 0x87, 0x8d, 0x6c, 0x20, 0x92, 0x2c, - 0xe3, 0x3e, 0x65, 0x6d, 0x50, 0x9d, 0x3d, 0x3a, 0x2c, 0x83, 0xd1, 0xf5, 0x06, 0x5b, 0xf2, 0x00, - 0xa6, 0x1c, 0xb5, 0xe6, 0x8f, 0x9f, 0xc6, 0x9a, 0xcf, 0xcf, 0x8b, 0x7a, 0xd0, 0x6a, 0x66, 0xe4, - 0x2b, 0x16, 0xcc, 0x86, 0x34, 0x92, 0x5d, 0xc5, 0x56, 0x1e, 0xa9, 0xf0, 0x8e, 0x38, 0xe8, 0x6a, - 0x09, 0x9a, 0x62, 0x05, 0x4d, 0x96, 0x61, 0x8a, 0xaf, 0x12, 0xe5, 0x06, 0x75, 0x1a, 0x34, 0xe0, - 0xe6, 0x08, 0xa9, 0x49, 0x8d, 0x2e, 0x8a, 0x41, 0x53, 0x8b, 0x62, 0x94, 0x61, 0x8a, 0xaf, 0x12, - 0x65, 0xc3, 0x0d, 0x02, 0x5f, 0x8a, 0x32, 0x95, 0x93, 0x28, 0x06, 0x4d, 0x2d, 0x8a, 0x51, 0x86, - 0x29, 0xbe, 0xf6, 0x37, 0xcf, 0xc0, 0xac, 0x9a, 0x48, 0xb1, 0x66, 0x2f, 0xac, 0x5f, 0x7d, 0x34, - 0xfb, 0x15, 0x13, 0x88, 0x49, 0x5c, 0x56, 0x59, 0x4c, 0xd5, 0xa4, 0x62, 0xaf, 0x2b, 0xd7, 0x4c, - 0x20, 0x26, 0x71, 0x49, 0x1b, 0x8a, 0x61, 0x44, 0x3b, 0xea, 0x0e, 0x7c, 0xc4, 0x2b, 0xda, 0x78, - 0x7d, 0x30, 0x2c, 0x09, 0x8c, 0x3c, 0x0a, 0x2e, 0xdc, 0x80, 0x1b, 0x25, 0x6c, 0xba, 0x72, 0x72, - 0xe4, 0x33, 0x3f, 0x93, 0xe6, 0x62, 0xd1, 0x1b, 0xc9, 0x32, 0x4c, 0xb1, 0xcf, 0x50, 0xf6, 0x8b, - 0xa7, 0xa8, 0xec, 0x7f, 0x1a, 0xa6, 0xda, 0xce, 0xc3, 0x5a, 0x37, 0x68, 0x9e, 0xfc, 0x50, 0x21, - 0xbd, 0x0a, 0x05, 0x15, 0xd4, 0xf4, 0xc8, 0x17, 0x2d, 0x63, 0xc9, 0x99, 0xe4, 0xc4, 0xef, 0xe5, - 0xbb, 0xe4, 0xe8, 0xbd, 0xb2, 0xef, 0xe2, 0xd3, 0xa3, 0x7a, 0x4f, 0x3d, 0x71, 0xd5, 0x9b, 0xa9, - 0x91, 0x62, 0x82, 0x68, 0x35, 0xb2, 0x74, 0xaa, 0x6a, 0xe4, 0x4a, 0x82, 0x19, 0xa6, 0x98, 0x73, - 0x79, 0xc4, 0x9c, 0xd3, 0xf2, 0xc0, 0xa9, 0xca, 0x53, 0x4b, 0x30, 0xc3, 0x14, 0xf3, 0xfe, 0xe7, - 0xcd, 0xe9, 0xd3, 0x39, 0x6f, 0xce, 0xe4, 0x70, 0xde, 0x3c, 0x5e, 0x15, 0x3f, 0x33, 0xaa, 0x2a, - 0x4e, 0x6e, 0x02, 0x69, 0x1c, 0x78, 0x4e, 0xdb, 0xad, 0xcb, 0xc5, 0x92, 0x6f, 0x9b, 0xb3, 0xdc, - 0x1e, 0xb1, 0x28, 0x17, 0x32, 0xb2, 0xda, 0x83, 0x81, 0x19, 0xb5, 0x48, 0x04, 0x53, 0x1d, 0xa5, - 0x71, 0xcd, 0xe5, 0x31, 0xfa, 0x95, 0x06, 0x26, 0xdc, 0x24, 0xd8, 0xc4, 0x53, 0x25, 0xa8, 0x39, - 0x91, 0x75, 0x38, 0xdf, 0x76, 0xbd, 0x4d, 0xbf, 0x11, 0x6e, 0xd2, 0x40, 0x5a, 0x5b, 0x6a, 0x34, - 0x5a, 0x98, 0xe7, 0x6d, 0xc3, 0x4f, 0xd0, 0x1b, 0x19, 0x70, 0xcc, 0xac, 0x65, 0xff, 0x2f, 0x0b, - 0xe6, 0x57, 0x5a, 0x7e, 0xb7, 0x71, 0xcf, 0x89, 0xea, 0xbb, 0xc2, 0x43, 0x80, 0xbc, 0x0e, 0x53, - 0xae, 0x17, 0xd1, 0x60, 0xdf, 0x69, 0xc9, 0xfd, 0xc9, 0x56, 0xe6, 0xd3, 0x35, 0x59, 0xfe, 0xe8, - 0xb0, 0x3c, 0xbb, 0xda, 0x0d, 0xb8, 0x95, 0x5a, 0xac, 0x56, 0xa8, 0xeb, 0x90, 0x6f, 0x5a, 0x70, - 0x56, 0xf8, 0x18, 0xac, 0x3a, 0x91, 0x73, 0xa7, 0x4b, 0x03, 0x97, 0x2a, 0x2f, 0x83, 0x11, 0x17, - 0xaa, 0xb4, 0xac, 0x8a, 0xc1, 0x41, 0xac, 0xa8, 0x6f, 0xa4, 0x39, 0x63, 0xaf, 0x30, 0xf6, 0xaf, - 0x14, 0xe0, 0xe9, 0xbe, 0xb4, 0xc8, 0x22, 0x8c, 0xb9, 0x0d, 0xf9, 0xe9, 0x20, 0xe9, 0x8e, 0xad, - 0x35, 0x70, 0xcc, 0x6d, 0x90, 0x25, 0xae, 0x73, 0x06, 0x34, 0x0c, 0xd5, 0x85, 0x73, 0x49, 0xab, - 0x87, 0xb2, 0x14, 0x0d, 0x0c, 0x52, 0x86, 0x22, 0xf7, 0x28, 0x95, 0xe7, 0x09, 0xae, 0xc5, 0x72, - 0xe7, 0x4d, 0x14, 0xe5, 0xe4, 0x17, 0x2d, 0x00, 0x21, 0x20, 0x3b, 0x8d, 0xc8, 0x5d, 0x12, 0xf3, - 0x6d, 0x26, 0x46, 0x59, 0x48, 0x19, 0xff, 0x47, 0x83, 0x2b, 0xd9, 0x82, 0x09, 0xa6, 0xd0, 0xfa, - 0x8d, 0x13, 0x6f, 0x8a, 0xfc, 0x26, 0x6a, 0x93, 0xd3, 0x40, 0x49, 0x8b, 0xb5, 0x55, 0x40, 0xa3, - 0x6e, 0xe0, 0xb1, 0xa6, 0xe5, 0xdb, 0xe0, 0x94, 0x90, 0x02, 0x75, 0x29, 0x1a, 0x18, 0xf6, 0xbf, - 0x1c, 0x83, 0xf3, 0x59, 0xa2, 0xb3, 0xdd, 0x66, 0x42, 0x48, 0x2b, 0x8f, 0xc6, 0x9f, 0xca, 0xbf, - 0x7d, 0xa4, 0xbb, 0x8c, 0xbe, 0xa6, 0x90, 0x0e, 0x7d, 0x92, 0x2f, 0xf9, 0x94, 0x6e, 0xa1, 0xb1, - 0x13, 0xb6, 0x90, 0xa6, 0x9c, 0x6a, 0xa5, 0xe7, 0x60, 0x3c, 0x64, 0x3d, 0x5f, 0x48, 0x5e, 0x77, - 0xf0, 0x3e, 0xe2, 0x10, 0x86, 0xd1, 0xf5, 0xdc, 0x48, 0x86, 0x61, 0x68, 0x8c, 0xbb, 0x9e, 0x1b, - 0x21, 0x87, 0xd8, 0xdf, 0x18, 0x83, 0xc5, 0xfe, 0x1f, 0x45, 0xbe, 0x61, 0x01, 0x34, 0xd8, 0x71, - 0x25, 0xe4, 0xbe, 0xcc, 0xc2, 0xbd, 0xc8, 0x39, 0xad, 0x36, 0x5c, 0x55, 0x9c, 0x62, 0x5f, 0x33, - 0x5d, 0x14, 0xa2, 0x21, 0x08, 0xb9, 0xaa, 0x86, 0x3e, 0xbf, 0xaa, 0x11, 0x93, 0x49, 0xd7, 0xd9, - 0xd0, 0x10, 0x34, 0xb0, 0xd8, 0x79, 0xd4, 0x73, 0xda, 0x34, 0xec, 0x38, 0x3a, 0xa8, 0x85, 0x9f, - 0x47, 0x6f, 0xa9, 0x42, 0x8c, 0xe1, 0x76, 0x0b, 0x9e, 0x1f, 0x40, 0xce, 0x9c, 0x62, 0x06, 0xec, - 0xff, 0x61, 0xc1, 0xc5, 0x95, 0x56, 0x37, 0x8c, 0x68, 0xf0, 0x97, 0xc6, 0x75, 0xef, 0x7f, 0x5b, - 0xf0, 0x4c, 0x9f, 0x6f, 0x7e, 0x02, 0x1e, 0x7c, 0xef, 0x24, 0x3d, 0xf8, 0xee, 0x8e, 0x3a, 0xa4, - 0x33, 0xbf, 0xa3, 0x8f, 0x23, 0xdf, 0x6f, 0x5a, 0x70, 0x86, 0x2d, 0x5b, 0x0d, 0xbf, 0x99, 0xd3, - 0xc6, 0xf9, 0x3c, 0x14, 0x7f, 0x9e, 0x6d, 0x40, 0xe9, 0x41, 0xc6, 0x77, 0x25, 0x14, 0x30, 0x36, - 0x67, 0x9c, 0x8e, 0xfb, 0x16, 0x0d, 0xf8, 0x06, 0x54, 0x48, 0xce, 0x99, 0x8a, 0x86, 0xa0, 0x81, - 0x65, 0x7f, 0x12, 0xa4, 0x8f, 0x5c, 0x6a, 0xc6, 0x59, 0x83, 0xcc, 0x38, 0xfb, 0x3f, 0x8c, 0x81, - 0x61, 0xfc, 0x78, 0x02, 0x23, 0xd9, 0x4b, 0x8c, 0xe4, 0x11, 0x0f, 0xee, 0x86, 0x29, 0xa7, 0x5f, - 0x0c, 0xd3, 0x7e, 0x2a, 0x86, 0xe9, 0x56, 0x6e, 0x1c, 0x8f, 0x0f, 0x61, 0xfa, 0x9e, 0x05, 0xcf, - 0xc4, 0xc8, 0xbd, 0x76, 0xc9, 0xc7, 0x2f, 0x4b, 0xaf, 0xc0, 0xb4, 0x13, 0x57, 0x93, 0xe3, 0xc6, - 0x08, 0x20, 0xd1, 0x20, 0x34, 0xf1, 0x62, 0xd7, 0xfb, 0xc2, 0x09, 0x5d, 0xef, 0xc7, 0x8f, 0x77, - 0xbd, 0xb7, 0x7f, 0x38, 0x06, 0x97, 0x7a, 0xbf, 0x4c, 0x4d, 0xa8, 0xc1, 0x2e, 0xf9, 0x5f, 0x85, - 0x99, 0x48, 0x56, 0x30, 0xb6, 0x07, 0x1d, 0xcc, 0xba, 0x65, 0xc0, 0x30, 0x81, 0xc9, 0x6a, 0xd6, - 0xc5, 0x54, 0xae, 0xd5, 0xfd, 0x8e, 0x0a, 0xdc, 0xd0, 0x35, 0x57, 0x0c, 0x18, 0x26, 0x30, 0xb5, - 0x4b, 0xec, 0xf8, 0xa9, 0xbb, 0xc4, 0xd6, 0xe0, 0x82, 0x72, 0x02, 0xbc, 0xee, 0x07, 0x2b, 0x7e, - 0xbb, 0xd3, 0xa2, 0x32, 0x74, 0x83, 0x09, 0x7b, 0x49, 0x56, 0xb9, 0x80, 0x59, 0x48, 0x98, 0x5d, - 0xd7, 0xfe, 0x5e, 0x01, 0xce, 0xc5, 0xcd, 0xbe, 0xe2, 0x7b, 0x0d, 0x97, 0xfb, 0x91, 0xbc, 0x06, - 0xe3, 0xd1, 0x41, 0x47, 0x35, 0xf6, 0x5f, 0x55, 0xe2, 0x6c, 0x1d, 0x74, 0x58, 0x6f, 0x5f, 0xcc, - 0xa8, 0xc2, 0x2d, 0xc3, 0xbc, 0x12, 0x59, 0xd7, 0xb3, 0x43, 0xf4, 0xc0, 0xcb, 0xc9, 0xd1, 0xfc, - 0xe8, 0xb0, 0x9c, 0x11, 0xcb, 0xbd, 0xa4, 0x29, 0x25, 0xc7, 0x3c, 0xb9, 0x0f, 0xb3, 0x2d, 0x27, - 0x8c, 0xee, 0x76, 0x1a, 0x4e, 0x44, 0xb7, 0x5c, 0xe9, 0xa1, 0x31, 0x5c, 0x3c, 0x84, 0xbe, 0xca, - 0x5e, 0x4f, 0x50, 0xc2, 0x14, 0x65, 0xb2, 0x0f, 0x84, 0x95, 0x6c, 0x05, 0x8e, 0x17, 0x8a, 0xaf, - 0x62, 0xfc, 0x86, 0x8f, 0xbf, 0xd0, 0x27, 0xc3, 0xf5, 0x1e, 0x6a, 0x98, 0xc1, 0x81, 0xbc, 0x00, - 0x13, 0x01, 0x75, 0x42, 0xd9, 0x99, 0xa5, 0x78, 0xfe, 0x23, 0x2f, 0x45, 0x09, 0x35, 0x27, 0xd4, - 0xc4, 0x63, 0x26, 0xd4, 0x9f, 0x5a, 0x30, 0x1b, 0x77, 0xd3, 0x13, 0xd8, 0x59, 0xdb, 0xc9, 0x9d, - 0xf5, 0x46, 0x5e, 0x4b, 0x62, 0x9f, 0xcd, 0xf4, 0x0f, 0x26, 0xcc, 0xef, 0xe3, 0xfe, 0xf0, 0x9f, - 0x87, 0x92, 0x9a, 0xd5, 0x4a, 0x65, 0x1d, 0xf1, 0x80, 0x9d, 0x50, 0x66, 0x8c, 0x38, 0x2e, 0xc9, - 0x04, 0x63, 0x7e, 0x6c, 0x2b, 0x6f, 0xc8, 0x6d, 0x5a, 0x0e, 0x7b, 0xbd, 0x95, 0xab, 0xed, 0x3b, - 0x6b, 0x2b, 0x57, 0x75, 0xc8, 0x5d, 0xb8, 0xd8, 0x09, 0x7c, 0x1e, 0x4d, 0xbc, 0x4a, 0x9d, 0x46, - 0xcb, 0xf5, 0xa8, 0xb2, 0x62, 0x08, 0x4f, 0x8a, 0x67, 0x8e, 0x0e, 0xcb, 0x17, 0x37, 0xb3, 0x51, - 0xb0, 0x5f, 0xdd, 0x64, 0x3c, 0xda, 0xf8, 0x00, 0xf1, 0x68, 0x7f, 0x47, 0xdb, 0x0a, 0x69, 0x28, - 0xa3, 0xc2, 0x3e, 0x93, 0x57, 0x57, 0x66, 0x2c, 0xeb, 0xf1, 0x90, 0xaa, 0x48, 0xa6, 0xa8, 0xd9, - 0xf7, 0x37, 0x48, 0x4d, 0x9c, 0xd0, 0x20, 0x15, 0x87, 0x15, 0x4c, 0xfe, 0x28, 0xc3, 0x0a, 0xa6, - 0x7e, 0xac, 0xc2, 0x0a, 0xde, 0x2f, 0xc2, 0x7c, 0x5a, 0x03, 0x39, 0xfd, 0x58, 0xbb, 0xbf, 0x67, - 0xc1, 0xbc, 0x9a, 0x3d, 0x82, 0x27, 0x55, 0x57, 0x0d, 0xeb, 0x39, 0x4d, 0x5a, 0xa1, 0x4b, 0xe9, - 0x24, 0x04, 0x5b, 0x29, 0x6e, 0xd8, 0xc3, 0x9f, 0xbc, 0x0d, 0xd3, 0xda, 0x22, 0x7f, 0xa2, 0xc0, - 0xbb, 0x39, 0xae, 0x45, 0xc5, 0x24, 0xd0, 0xa4, 0x47, 0xde, 0xb7, 0x00, 0xea, 0x6a, 0x9b, 0x53, - 0xb3, 0xeb, 0x4e, 0x5e, 0xb3, 0x4b, 0x6f, 0xa0, 0xb1, 0xb2, 0xac, 0x8b, 0x42, 0x34, 0x18, 0x93, - 0x5f, 0xe1, 0xb6, 0x78, 0xad, 0xdd, 0x89, 0xe4, 0x06, 0x23, 0xbb, 0x4c, 0x1f, 0xa3, 0x98, 0xc6, - 0xaa, 0x94, 0x01, 0x0a, 0x31, 0x21, 0x84, 0xfd, 0x1a, 0x68, 0x27, 0x57, 0xb6, 0x6c, 0x71, 0x37, - 0xd7, 0x4d, 0x27, 0xda, 0x95, 0x43, 0x50, 0x2f, 0x5b, 0xd7, 0x15, 0x00, 0x63, 0x1c, 0xfb, 0x73, - 0x30, 0xfb, 0x46, 0xe0, 0x74, 0x76, 0x5d, 0x6e, 0xf3, 0x66, 0x67, 0xab, 0x0f, 0xc1, 0xa4, 0xd3, - 0x68, 0x64, 0xe5, 0xcb, 0xa8, 0x88, 0x62, 0x54, 0xf0, 0x81, 0x8e, 0x51, 0xf6, 0xef, 0x5b, 0x40, - 0xe2, 0x7b, 0x43, 0xd7, 0x6b, 0x6e, 0x38, 0x51, 0x7d, 0x97, 0x9d, 0x8f, 0x76, 0x79, 0x69, 0xd6, - 0xf9, 0xe8, 0x86, 0x86, 0xa0, 0x81, 0x45, 0xde, 0x85, 0x69, 0xf1, 0xef, 0x2d, 0x6d, 0x21, 0x18, - 0xdd, 0x57, 0x97, 0x6f, 0x28, 0x5c, 0x26, 0x31, 0x0a, 0x6f, 0xc4, 0x1c, 0xd0, 0x64, 0xc7, 0x9a, - 0x6a, 0xcd, 0xdb, 0x69, 0x75, 0x1f, 0x36, 0xb6, 0xe3, 0xa6, 0xea, 0x04, 0xfe, 0x8e, 0xdb, 0xa2, - 0xe9, 0xa6, 0xda, 0x14, 0xc5, 0xa8, 0xe0, 0x83, 0x35, 0xd5, 0xbf, 0xb1, 0xe0, 0xfc, 0x5a, 0x18, - 0xb9, 0xfe, 0x2a, 0x0d, 0x23, 0xb6, 0xad, 0xb0, 0xc5, 0xa7, 0xdb, 0x1a, 0xc4, 0x5f, 0x7d, 0x15, - 0xe6, 0xe5, 0x1d, 0x66, 0x77, 0x3b, 0xa4, 0x91, 0xa1, 0xc7, 0xeb, 0x79, 0xbc, 0x92, 0x82, 0x63, - 0x4f, 0x0d, 0x46, 0x45, 0x5e, 0x66, 0xc6, 0x54, 0x0a, 0x49, 0x2a, 0xb5, 0x14, 0x1c, 0x7b, 0x6a, - 0xd8, 0xdf, 0x2d, 0xc0, 0x39, 0xfe, 0x19, 0xa9, 0x58, 0x93, 0xaf, 0xf5, 0x8b, 0x35, 0x19, 0x71, - 0x2a, 0x73, 0x5e, 0x27, 0x88, 0x34, 0xf9, 0xbb, 0x16, 0xcc, 0x35, 0x92, 0x2d, 0x9d, 0x8f, 0x4d, - 0x27, 0xab, 0x0f, 0x85, 0xcb, 0x56, 0xaa, 0x10, 0xd3, 0xfc, 0xc9, 0xaf, 0x5a, 0x30, 0x97, 0x14, - 0x53, 0xad, 0xee, 0xa7, 0xd0, 0x48, 0xda, 0xc7, 0x3a, 0x59, 0x1e, 0x62, 0x5a, 0x04, 0xfb, 0x0f, - 0xc7, 0x64, 0x97, 0x9e, 0x46, 0x20, 0x05, 0x79, 0x00, 0xa5, 0xa8, 0x15, 0x8a, 0x42, 0xf9, 0xb5, - 0x23, 0x9e, 0x08, 0xb7, 0xd6, 0x6b, 0xc2, 0x7d, 0x20, 0x56, 0xda, 0x64, 0x09, 0x53, 0x3e, 0x15, - 0x2f, 0xce, 0xb8, 0xde, 0x91, 0x8c, 0x73, 0x39, 0x8a, 0x6e, 0xad, 0x6c, 0xa6, 0x19, 0xcb, 0x12, - 0xc6, 0x58, 0xf1, 0xb2, 0x7f, 0xcb, 0x82, 0xd2, 0x4d, 0x5f, 0xad, 0x23, 0x3f, 0x9b, 0x83, 0xa1, - 0x47, 0xeb, 0x83, 0xfa, 0x9a, 0x32, 0x3e, 0x62, 0xbc, 0x9e, 0x30, 0xf3, 0x3c, 0x6b, 0xd0, 0x5e, - 0xe2, 0x69, 0xc3, 0x18, 0xa9, 0x9b, 0xfe, 0x76, 0x5f, 0xd3, 0xe3, 0xaf, 0x15, 0xe1, 0xcc, 0x9b, - 0xce, 0x01, 0xf5, 0x22, 0x67, 0xf8, 0x4d, 0xe2, 0x15, 0x98, 0x76, 0x3a, 0xfc, 0x1e, 0xcc, 0xd0, - 0xf1, 0x63, 0xcb, 0x49, 0x0c, 0x42, 0x13, 0x2f, 0x5e, 0xd0, 0x44, 0x54, 0x43, 0xd6, 0x52, 0xb4, - 0x92, 0x82, 0x63, 0x4f, 0x0d, 0x72, 0x13, 0x88, 0x0c, 0xc2, 0xad, 0xd4, 0xeb, 0x7e, 0xd7, 0x13, - 0x4b, 0x9a, 0x30, 0xaa, 0xe8, 0xc3, 0xe6, 0x46, 0x0f, 0x06, 0x66, 0xd4, 0x22, 0x9f, 0x85, 0x85, - 0x3a, 0xa7, 0x2c, 0x8f, 0x1e, 0x26, 0x45, 0x71, 0xfc, 0xd4, 0x71, 0x02, 0x2b, 0x7d, 0xf0, 0xb0, - 0x2f, 0x05, 0x26, 0x69, 0x18, 0xf9, 0x81, 0xd3, 0xa4, 0x26, 0xdd, 0x89, 0xa4, 0xa4, 0xb5, 0x1e, - 0x0c, 0xcc, 0xa8, 0x45, 0xbe, 0x00, 0xa5, 0x68, 0x37, 0xa0, 0xe1, 0xae, 0xdf, 0x6a, 0x48, 0xbf, - 0x85, 0x11, 0x2d, 0x6d, 0xb2, 0xf7, 0xb7, 0x14, 0x55, 0x63, 0x78, 0xab, 0x22, 0x8c, 0x79, 0x92, - 0x00, 0x26, 0xc2, 0xba, 0xdf, 0xa1, 0xa1, 0x54, 0xd9, 0x6f, 0xe6, 0xc2, 0x9d, 0x5b, 0x8e, 0x0c, - 0x1b, 0x1f, 0xe7, 0x80, 0x92, 0x93, 0xfd, 0x7b, 0x63, 0x30, 0x63, 0x22, 0x0e, 0xb0, 0x36, 0x7d, - 0xc9, 0x82, 0x99, 0xba, 0xef, 0x45, 0x81, 0xdf, 0x12, 0xf6, 0xab, 0x7c, 0x34, 0x0a, 0x46, 0x6a, - 0x95, 0x46, 0x8e, 0xdb, 0x32, 0x4c, 0x61, 0x06, 0x1b, 0x4c, 0x30, 0x25, 0x5f, 0xb5, 0x60, 0x2e, - 0x76, 0x73, 0x8b, 0x0d, 0x69, 0xb9, 0x0a, 0xa2, 0x97, 0xfa, 0x6b, 0x49, 0x4e, 0x98, 0x66, 0x6d, - 0x6f, 0xc3, 0x7c, 0xba, 0xb7, 0x59, 0x53, 0x76, 0x1c, 0x39, 0xd7, 0x0b, 0x71, 0x53, 0x6e, 0x3a, - 0x61, 0x88, 0x1c, 0x42, 0x5e, 0x84, 0xa9, 0xb6, 0x13, 0x34, 0x5d, 0xcf, 0x69, 0xf1, 0x56, 0x2c, - 0x18, 0x0b, 0x92, 0x2c, 0x47, 0x8d, 0x61, 0x7f, 0x14, 0x66, 0x36, 0x1c, 0xaf, 0x49, 0x1b, 0x72, - 0x1d, 0x7e, 0x7c, 0x28, 0xdf, 0x9f, 0x8f, 0xc3, 0xb4, 0x71, 0x36, 0x3b, 0xfd, 0x73, 0x56, 0x22, - 0x93, 0x48, 0x21, 0xc7, 0x4c, 0x22, 0x9f, 0x06, 0xd8, 0x71, 0x3d, 0x37, 0xdc, 0x3d, 0x61, 0x8e, - 0x12, 0x7e, 0xaf, 0x7b, 0x5d, 0x53, 0x40, 0x83, 0x5a, 0x7c, 0x79, 0x56, 0x3c, 0x26, 0xe1, 0xd6, - 0xfb, 0x96, 0xb1, 0xdd, 0x4c, 0xe4, 0xe1, 0x2c, 0x60, 0x74, 0xcc, 0x92, 0xda, 0x7e, 0x44, 0x8a, - 0xa5, 0xe3, 0x76, 0xa5, 0x2d, 0x98, 0x0a, 0x68, 0xd8, 0x6d, 0xb3, 0x13, 0xe3, 0xe4, 0xd0, 0xcd, - 0xc0, 0xdd, 0x36, 0x50, 0xd6, 0x47, 0x4d, 0x69, 0xf1, 0x35, 0x38, 0x93, 0x10, 0x61, 0xa8, 0xa4, - 0x4b, 0x3e, 0x64, 0x1a, 0x00, 0x4e, 0x72, 0x99, 0xc3, 0xfa, 0xa2, 0x65, 0x24, 0x29, 0xd1, 0x7d, - 0x21, 0x9c, 0x73, 0x04, 0xcc, 0xfe, 0xe1, 0x04, 0xc8, 0xfb, 0xef, 0x01, 0x96, 0x2b, 0xf3, 0xd6, - 0x6b, 0xec, 0x04, 0xb7, 0x5e, 0x37, 0x61, 0xc6, 0xf5, 0xdc, 0xc8, 0x75, 0x5a, 0xdc, 0xb8, 0x23, - 0xb7, 0x53, 0xe5, 0xbd, 0x3c, 0xb3, 0x66, 0xc0, 0x32, 0xe8, 0x24, 0xea, 0x92, 0x3b, 0x50, 0xe4, - 0xfb, 0x8d, 0x1c, 0xc0, 0xc3, 0x5f, 0xd2, 0x73, 0xff, 0x0c, 0x11, 0xd2, 0x24, 0x28, 0xf1, 0xc3, - 0x87, 0xc8, 0xd2, 0xa2, 0x8f, 0xdf, 0x72, 0x1c, 0xc7, 0x87, 0x8f, 0x14, 0x1c, 0x7b, 0x6a, 0x30, - 0x2a, 0x3b, 0x8e, 0xdb, 0xea, 0x06, 0x34, 0xa6, 0x32, 0x91, 0xa4, 0x72, 0x3d, 0x05, 0xc7, 0x9e, - 0x1a, 0x64, 0x07, 0x66, 0x64, 0x99, 0x70, 0xb9, 0x9a, 0x3c, 0xe1, 0x57, 0x72, 0xd7, 0xba, 0xeb, - 0x06, 0x25, 0x4c, 0xd0, 0x25, 0x5d, 0x38, 0xeb, 0x7a, 0x75, 0xdf, 0xab, 0xb7, 0xba, 0xa1, 0xbb, - 0x4f, 0xe3, 0x78, 0xa2, 0x93, 0x30, 0xbb, 0x70, 0x74, 0x58, 0x3e, 0xbb, 0x96, 0x26, 0x87, 0xbd, - 0x1c, 0xc8, 0x17, 0x2d, 0xb8, 0x50, 0xf7, 0xbd, 0x90, 0xa7, 0x3d, 0xd8, 0xa7, 0xd7, 0x82, 0xc0, - 0x0f, 0x04, 0xef, 0xd2, 0x09, 0x79, 0x73, 0x9b, 0xe2, 0x4a, 0x16, 0x49, 0xcc, 0xe6, 0x44, 0xde, - 0x81, 0xa9, 0x4e, 0xe0, 0xef, 0xbb, 0x0d, 0x1a, 0x48, 0xf7, 0xbd, 0xf5, 0x3c, 0xd2, 0xb0, 0x6c, - 0x4a, 0x9a, 0xf1, 0xd2, 0xa3, 0x4a, 0x50, 0xf3, 0xb3, 0xff, 0xcf, 0x34, 0xcc, 0x26, 0xd1, 0xc9, - 0x2f, 0x00, 0x74, 0x02, 0xbf, 0x4d, 0xa3, 0x5d, 0xaa, 0xe3, 0x42, 0x6e, 0x8d, 0x9a, 0xed, 0x43, - 0xd1, 0x53, 0x2e, 0x2f, 0x6c, 0xb9, 0x88, 0x4b, 0xd1, 0xe0, 0x48, 0x02, 0x98, 0xdc, 0x13, 0xdb, - 0xae, 0xd4, 0x42, 0xde, 0xcc, 0x45, 0x67, 0x92, 0x9c, 0x79, 0x40, 0x83, 0x2c, 0x42, 0xc5, 0x88, - 0x6c, 0x43, 0xe1, 0x01, 0xdd, 0xce, 0x27, 0xd4, 0xfc, 0x1e, 0x95, 0xa7, 0x99, 0xea, 0xe4, 0xd1, - 0x61, 0xb9, 0x70, 0x8f, 0x6e, 0x23, 0x23, 0xce, 0xbe, 0xab, 0x21, 0xee, 0xee, 0xe5, 0x52, 0x31, - 0xe2, 0x77, 0x25, 0x1c, 0x01, 0xc4, 0x77, 0xc9, 0x22, 0x54, 0x8c, 0xc8, 0x3b, 0x50, 0x7a, 0xe0, - 0xec, 0xd3, 0x9d, 0xc0, 0xf7, 0x22, 0xe9, 0x67, 0x35, 0x62, 0xa8, 0xc0, 0x3d, 0x45, 0x4e, 0xf2, - 0xe5, 0xdb, 0xbb, 0x2e, 0xc4, 0x98, 0x1d, 0xd9, 0x87, 0x29, 0x8f, 0x3e, 0x40, 0xda, 0x72, 0xeb, - 0xf9, 0xb8, 0xe6, 0xdf, 0x92, 0xd4, 0x24, 0x67, 0xbe, 0xef, 0xa9, 0x32, 0xd4, 0xbc, 0x58, 0x5f, - 0xde, 0xf7, 0xb7, 0xe5, 0x42, 0x35, 0x62, 0x5f, 0xea, 0x93, 0xa9, 0xe8, 0xcb, 0x9b, 0xfe, 0x36, - 0x32, 0xe2, 0x6c, 0x8e, 0xd4, 0xb5, 0x93, 0x8f, 0x5c, 0xa6, 0x6e, 0xe5, 0xeb, 0xdc, 0x24, 0xe6, - 0x48, 0x5c, 0x8a, 0x06, 0x47, 0xd6, 0xb6, 0x4d, 0x69, 0xac, 0x94, 0x0b, 0xd5, 0x88, 0x6d, 0x9b, - 0x34, 0x7d, 0x8a, 0xb6, 0x55, 0x65, 0xa8, 0x79, 0x31, 0xbe, 0xae, 0xb4, 0xfc, 0xe5, 0xb3, 0x54, - 0x25, 0xed, 0x88, 0x82, 0xaf, 0x2a, 0x43, 0xcd, 0x8b, 0xb5, 0x77, 0xb8, 0x77, 0xf0, 0xc0, 0x69, - 0xed, 0xb9, 0x5e, 0x53, 0xc6, 0x39, 0x8e, 0x9a, 0xd4, 0x77, 0xef, 0xe0, 0x9e, 0xa0, 0x67, 0xb6, - 0x77, 0x5c, 0x8a, 0x06, 0x47, 0xf2, 0x8f, 0x2c, 0x98, 0xe8, 0xb4, 0xba, 0x4d, 0xd7, 0x5b, 0x98, - 0xe1, 0x7a, 0xe2, 0xa7, 0xf2, 0x5c, 0xa1, 0x97, 0x36, 0x39, 0x69, 0xa1, 0x28, 0xfe, 0xb4, 0xf6, - 0xd9, 0xe3, 0x85, 0xbf, 0xf4, 0x67, 0xe5, 0x05, 0xea, 0xd5, 0xfd, 0x86, 0xeb, 0x35, 0x97, 0xef, - 0x87, 0xbe, 0xb7, 0x84, 0xce, 0x03, 0xa5, 0xa3, 0x4b, 0x99, 0x16, 0x3f, 0x0e, 0xd3, 0x06, 0x89, - 0xc7, 0x29, 0x7a, 0x33, 0xa6, 0xa2, 0xf7, 0x5b, 0x13, 0x30, 0x63, 0x26, 0x12, 0x1c, 0x40, 0xfb, - 0xd2, 0x27, 0x8e, 0xb1, 0x61, 0x4e, 0x1c, 0xec, 0x88, 0x69, 0xdc, 0x1e, 0x29, 0xf3, 0xd6, 0x5a, - 0x6e, 0x0a, 0x77, 0x7c, 0xc4, 0x34, 0x0a, 0x43, 0x4c, 0x30, 0x1d, 0xc2, 0xa1, 0x84, 0xa9, 0xad, - 0x42, 0xb1, 0x2b, 0x26, 0xd5, 0xd6, 0x84, 0xaa, 0x76, 0x15, 0x20, 0x4e, 0xa8, 0x27, 0x6f, 0x15, - 0xb5, 0x3e, 0x6c, 0x24, 0xfa, 0x33, 0xb0, 0xc8, 0x0b, 0x30, 0xc1, 0x54, 0x1f, 0xda, 0x90, 0x61, - 0xd8, 0xfa, 0x1c, 0x7f, 0x9d, 0x97, 0xa2, 0x84, 0x92, 0x57, 0x99, 0x96, 0x1a, 0x2b, 0x2c, 0x32, - 0xba, 0xfa, 0x7c, 0xac, 0xa5, 0xc6, 0x30, 0x4c, 0x60, 0x32, 0xd1, 0x29, 0xd3, 0x2f, 0xf8, 0xda, - 0x60, 0x88, 0xce, 0x95, 0x0e, 0x14, 0x30, 0x6e, 0x57, 0x4a, 0xe9, 0x23, 0x7c, 0x4e, 0x17, 0x0d, - 0xbb, 0x52, 0x0a, 0x8e, 0x3d, 0x35, 0xd8, 0xc7, 0xc8, 0x0b, 0xd1, 0x69, 0xe1, 0x6c, 0xdb, 0xe7, - 0x2a, 0xf3, 0xcb, 0xe6, 0x59, 0x2b, 0xc7, 0x39, 0x24, 0x46, 0xed, 0xe0, 0x87, 0xad, 0xd1, 0x8e, - 0x45, 0x9f, 0x83, 0xd9, 0xe4, 0x2e, 0x94, 0xfb, 0xcd, 0xc7, 0x57, 0xc6, 0xe1, 0xdc, 0xad, 0xa6, - 0xeb, 0xa5, 0x93, 0x64, 0x65, 0xe5, 0x48, 0xb7, 0x86, 0xce, 0x91, 0xae, 0xe3, 0xb9, 0x64, 0x06, - 0xf2, 0xec, 0x78, 0x2e, 0x95, 0x0e, 0x3e, 0x89, 0x4b, 0xfe, 0xd4, 0x82, 0x67, 0x9d, 0x86, 0x38, - 0x17, 0x38, 0x2d, 0x59, 0x6a, 0xa4, 0xf6, 0x95, 0x33, 0x3a, 0x1c, 0x71, 0x97, 0xef, 0xfd, 0xf8, - 0xa5, 0xca, 0x31, 0x5c, 0x45, 0x8f, 0xff, 0x94, 0xfc, 0x82, 0x67, 0x8f, 0x43, 0xc5, 0x63, 0xc5, - 0x27, 0x7f, 0x03, 0xe6, 0x12, 0x1f, 0x2c, 0x2d, 0xe1, 0x25, 0x71, 0x61, 0x51, 0x4b, 0x82, 0x30, - 0x8d, 0xbb, 0x78, 0x1b, 0x3e, 0xf8, 0x58, 0x39, 0x87, 0x1a, 0x6c, 0xdf, 0xb1, 0x60, 0xc6, 0xcc, - 0x67, 0x43, 0x5e, 0x84, 0xa9, 0xc8, 0xdf, 0xa3, 0xde, 0xdd, 0x40, 0x39, 0x7b, 0xea, 0x81, 0xbe, - 0xc5, 0xcb, 0x71, 0x1d, 0x35, 0x06, 0xc3, 0xae, 0xb7, 0x5c, 0xea, 0x45, 0x6b, 0x0d, 0xd9, 0xcd, - 0x1a, 0x7b, 0x45, 0x94, 0xaf, 0xa2, 0xc6, 0x10, 0x0e, 0x6c, 0xec, 0x77, 0x8d, 0xd6, 0x03, 0xaa, - 0x5c, 0xc3, 0x0d, 0x07, 0xb6, 0x18, 0x86, 0x09, 0x4c, 0x62, 0x6b, 0x13, 0xe7, 0x78, 0x7c, 0xaf, - 0x91, 0x32, 0x49, 0x7e, 0xc9, 0x82, 0x92, 0x30, 0xd1, 0x23, 0xdd, 0x49, 0xf9, 0x93, 0xa6, 0x8c, - 0x08, 0x95, 0xcd, 0xb5, 0x0c, 0x7f, 0x52, 0xb6, 0x2d, 0xed, 0xb9, 0x9e, 0xfa, 0x12, 0xbd, 0x2d, - 0xbd, 0xe9, 0x7a, 0x0d, 0xe4, 0x10, 0xbd, 0x71, 0x15, 0xfa, 0x9a, 0xce, 0x7e, 0xdd, 0x82, 0x59, - 0x1e, 0xce, 0x1b, 0x1f, 0x6f, 0x5f, 0xd1, 0x7e, 0x53, 0x42, 0x8c, 0x4b, 0x49, 0xbf, 0xa9, 0x47, - 0x87, 0xe5, 0x69, 0x11, 0x00, 0x9c, 0x74, 0xa3, 0xfa, 0x8c, 0xb4, 0x89, 0x71, 0xef, 0xae, 0xb1, - 0xa1, 0x4d, 0x36, 0xda, 0x66, 0x5c, 0x53, 0x44, 0x30, 0xa6, 0x67, 0xbf, 0x0b, 0x33, 0x66, 0x5c, - 0x0e, 0x79, 0x05, 0xa6, 0x3b, 0xae, 0xd7, 0x4c, 0xc6, 0x6f, 0xea, 0x7b, 0x83, 0xcd, 0x18, 0x84, - 0x26, 0x1e, 0xaf, 0xe6, 0xc7, 0xd5, 0x52, 0xd7, 0x0d, 0x9b, 0xbe, 0x59, 0x2d, 0xfe, 0xc3, 0xb3, - 0xa4, 0x67, 0xc4, 0x7f, 0xe5, 0x9e, 0x25, 0x3d, 0x83, 0xc7, 0x8f, 0x2e, 0x4b, 0x7a, 0x96, 0x30, - 0xff, 0x6f, 0x65, 0x49, 0xff, 0x19, 0x18, 0x36, 0x3d, 0x26, 0xdb, 0xba, 0x1f, 0x98, 0x31, 0xf6, - 0xba, 0xc5, 0x65, 0x90, 0xbd, 0x84, 0xda, 0xdf, 0x2e, 0xc0, 0x7c, 0xfa, 0x04, 0x9f, 0xb7, 0x73, - 0x04, 0xf9, 0xaa, 0x05, 0xb3, 0x4e, 0x22, 0x15, 0x59, 0x4e, 0x4f, 0xae, 0x24, 0x68, 0x1a, 0xa9, - 0xb0, 0x12, 0xe5, 0x98, 0xe2, 0x4d, 0xfe, 0x0a, 0x4c, 0x46, 0x6e, 0x9b, 0xfa, 0x5d, 0x61, 0xd7, - 0x2b, 0x88, 0xf3, 0xf5, 0x96, 0x28, 0x42, 0x05, 0x63, 0x6b, 0xac, 0xcb, 0x15, 0xa2, 0x80, 0x4a, - 0x2f, 0xda, 0xf9, 0xd8, 0x10, 0x29, 0xca, 0x51, 0x63, 0x90, 0x87, 0x30, 0x29, 0xdc, 0x28, 0x94, - 0xbf, 0xcc, 0x46, 0x4e, 0x96, 0x06, 0xe1, 0xa9, 0x11, 0x77, 0x81, 0xf8, 0x1f, 0xa2, 0x62, 0x67, - 0x7f, 0x14, 0x86, 0xcc, 0x17, 0x6a, 0x5f, 0x03, 0x82, 0x7e, 0xab, 0xb5, 0xed, 0xd4, 0xf7, 0xee, - 0xb9, 0x5e, 0xc3, 0x7f, 0xc0, 0x97, 0xa2, 0x65, 0x28, 0x05, 0x32, 0x7a, 0x32, 0x94, 0xa3, 0x46, - 0xaf, 0x65, 0x2a, 0xac, 0x32, 0xc4, 0x18, 0xc7, 0xfe, 0xc3, 0x31, 0x98, 0x94, 0xa1, 0xbe, 0x4f, - 0xc0, 0x8b, 0x7f, 0x2f, 0x71, 0xbd, 0xbb, 0x96, 0x4b, 0x84, 0x72, 0x5f, 0x17, 0xfe, 0x30, 0xe5, - 0xc2, 0xff, 0x66, 0x3e, 0xec, 0x8e, 0xf7, 0xdf, 0xff, 0x83, 0x22, 0xcc, 0xa5, 0x42, 0xa7, 0x99, - 0x6a, 0xdd, 0xe3, 0xb6, 0x7a, 0x37, 0xd7, 0xe8, 0x6c, 0x1d, 0x96, 0x72, 0xbc, 0x07, 0x6b, 0x98, - 0xc8, 0xee, 0x7c, 0x27, 0xb7, 0x87, 0x2b, 0x7e, 0x92, 0xe8, 0x79, 0x48, 0x8f, 0x4c, 0xf2, 0x4d, - 0x0b, 0xce, 0x39, 0xbd, 0x2f, 0x7f, 0x48, 0x13, 0xe0, 0x9d, 0xdc, 0x9f, 0x14, 0xa9, 0x3e, 0x23, - 0x85, 0xcc, 0x7a, 0x60, 0x05, 0xb3, 0x44, 0xb1, 0xff, 0xb3, 0x05, 0x4f, 0xf7, 0x4d, 0x02, 0xc0, - 0x73, 0x48, 0x05, 0x49, 0xa8, 0x5c, 0x33, 0x72, 0x4e, 0x75, 0xa2, 0xaf, 0x83, 0xd3, 0x69, 0x7f, - 0xd2, 0xec, 0xc9, 0xcb, 0x30, 0xc3, 0x75, 0x34, 0xb6, 0x7a, 0x46, 0xb4, 0x23, 0x6f, 0xb3, 0xf8, - 0xbd, 0x46, 0xcd, 0x28, 0xc7, 0x04, 0x96, 0xfd, 0x4d, 0x0b, 0x16, 0xfa, 0x65, 0x14, 0x1a, 0xc0, - 0xd6, 0xf2, 0xd7, 0x53, 0x91, 0x10, 0xe5, 0x9e, 0x48, 0x88, 0x94, 0xb5, 0x45, 0x05, 0x3d, 0x18, - 0x86, 0x8e, 0xc2, 0x63, 0x1c, 0xfd, 0xbf, 0x66, 0xc1, 0xc5, 0x3e, 0x13, 0xbe, 0x27, 0x22, 0xc6, - 0x3a, 0x71, 0x44, 0xcc, 0xd8, 0xa0, 0x11, 0x31, 0xf6, 0x1f, 0x15, 0x60, 0x5e, 0xca, 0x13, 0x2b, - 0xea, 0xaf, 0x26, 0xe2, 0x49, 0x7e, 0x2a, 0x15, 0x4f, 0x72, 0x3e, 0x8d, 0xff, 0x93, 0x60, 0x92, - 0x1f, 0xaf, 0x60, 0x92, 0xbf, 0x18, 0x83, 0x0b, 0x99, 0x89, 0x8e, 0xc8, 0x57, 0x32, 0x76, 0xaf, - 0x7b, 0x39, 0x67, 0x54, 0x1a, 0x70, 0xff, 0x1a, 0x35, 0x02, 0xe3, 0x57, 0xcd, 0xc8, 0x07, 0xb1, - 0x1b, 0xed, 0x9c, 0x42, 0x6e, 0xa8, 0x21, 0x83, 0x20, 0xec, 0x5f, 0x2a, 0xc0, 0x95, 0x41, 0x09, - 0xfd, 0x98, 0x06, 0xc9, 0x85, 0x89, 0x20, 0xb9, 0x27, 0xa4, 0x59, 0x9c, 0x4a, 0xbc, 0xdc, 0x3f, - 0x19, 0xd7, 0xdb, 0x5e, 0xef, 0xf8, 0x1c, 0xc8, 0xf5, 0x61, 0x92, 0x69, 0x9f, 0x2a, 0x47, 0x74, - 0xbc, 0x14, 0x4e, 0xd6, 0x44, 0xf1, 0xa3, 0xc3, 0xf2, 0xd9, 0x38, 0xdd, 0x86, 0x2c, 0x44, 0x55, - 0x89, 0x5c, 0x81, 0xa9, 0x40, 0x40, 0x55, 0x58, 0x90, 0xf4, 0x1f, 0x11, 0x65, 0xa8, 0xa1, 0xe4, - 0x0b, 0x86, 0xba, 0x3e, 0x7e, 0x5a, 0x59, 0x65, 0x8e, 0x73, 0x8b, 0x79, 0x1b, 0xa6, 0x42, 0x95, - 0xc8, 0x58, 0x28, 0x2e, 0x2f, 0x0d, 0x18, 0x6d, 0xc6, 0xce, 0xe0, 0x2a, 0xab, 0xb1, 0xf8, 0x3e, - 0x9d, 0xf3, 0x58, 0x93, 0x24, 0xb6, 0x3e, 0xfe, 0x0a, 0xb3, 0x3d, 0xf4, 0x1e, 0x7d, 0x49, 0x04, - 0x93, 0xf2, 0x7d, 0x4b, 0x79, 0x9f, 0xb8, 0x91, 0x53, 0x64, 0x89, 0xf4, 0x3b, 0xe6, 0xa7, 0x4a, - 0x65, 0x86, 0x51, 0xac, 0xec, 0xef, 0x59, 0x30, 0x2d, 0xc7, 0xc8, 0x13, 0x08, 0xbb, 0xbb, 0x9f, - 0x0c, 0xbb, 0xbb, 0x96, 0xcb, 0x8a, 0xd5, 0x27, 0xe6, 0xee, 0x3e, 0xcc, 0x98, 0x19, 0xf6, 0xc8, - 0xa7, 0x8d, 0x15, 0xd7, 0x1a, 0x25, 0x67, 0x95, 0x5a, 0x93, 0xe3, 0xd5, 0xd8, 0xfe, 0xed, 0x92, - 0x6e, 0x45, 0x7e, 0x76, 0x35, 0x47, 0xbe, 0x75, 0xec, 0xc8, 0x37, 0x07, 0xde, 0x58, 0xfe, 0x03, - 0xef, 0x0e, 0x4c, 0xa9, 0x65, 0x51, 0x2a, 0x0f, 0xcf, 0x9b, 0x8e, 0xc8, 0x4c, 0x03, 0x61, 0xc4, - 0x8c, 0xe9, 0xc2, 0xcf, 0xa0, 0xb1, 0xad, 0x57, 0x2d, 0xd7, 0x9a, 0x0c, 0x79, 0x07, 0xa6, 0x1f, - 0xf8, 0xc1, 0x5e, 0xcb, 0x77, 0x78, 0xf6, 0x78, 0xc8, 0xe3, 0xee, 0x5b, 0xdb, 0x6b, 0x45, 0x34, - 0xc8, 0xbd, 0x98, 0x3e, 0x9a, 0xcc, 0x48, 0x05, 0xe6, 0xda, 0xae, 0x87, 0xd4, 0x69, 0xe8, 0xe8, - 0xba, 0x71, 0x91, 0xb9, 0x59, 0xa9, 0xd6, 0x1b, 0x49, 0x30, 0xa6, 0xf1, 0xb9, 0xf1, 0x27, 0x48, - 0x58, 0x1b, 0x64, 0x7a, 0xd6, 0xcd, 0xd1, 0x07, 0x63, 0xd2, 0x82, 0x21, 0xc2, 0x21, 0x92, 0xe5, - 0x98, 0xe2, 0x4d, 0x3e, 0x0f, 0x53, 0xa1, 0x4c, 0x9f, 0x97, 0x8f, 0xd3, 0x84, 0x3e, 0xdb, 0x0b, - 0xa2, 0x71, 0x57, 0xaa, 0x12, 0xd4, 0x0c, 0xc9, 0x3a, 0x9c, 0x57, 0xe6, 0x93, 0xc4, 0x0b, 0x5f, - 0x13, 0x71, 0xb6, 0x25, 0xcc, 0x80, 0x63, 0x66, 0x2d, 0xa6, 0xca, 0xf1, 0xcc, 0x95, 0xe2, 0xae, - 0xd1, 0xb8, 0x9e, 0xe3, 0xf3, 0xaf, 0x81, 0x12, 0x7a, 0x5c, 0xf0, 0xe8, 0xd4, 0x08, 0xc1, 0xa3, - 0x35, 0xb8, 0x90, 0x06, 0xf1, 0x34, 0x5a, 0x3c, 0x73, 0x97, 0xb1, 0x85, 0x6e, 0x66, 0x21, 0x61, - 0x76, 0x5d, 0x72, 0x0f, 0x4a, 0x01, 0xe5, 0x87, 0xac, 0x8a, 0x72, 0xd3, 0x1a, 0xda, 0x21, 0x15, - 0x15, 0x01, 0x8c, 0x69, 0xb1, 0x7e, 0x77, 0x92, 0xb9, 0x94, 0xef, 0xe4, 0xf8, 0xb4, 0xac, 0xec, - 0xfb, 0x3e, 0xe9, 0xed, 0xec, 0x7f, 0x3b, 0x07, 0x67, 0x12, 0x36, 0x20, 0xf2, 0x3c, 0x14, 0x79, - 0x5e, 0x31, 0xbe, 0x5a, 0x4d, 0xc5, 0x2b, 0xaa, 0x68, 0x1c, 0x01, 0x23, 0xbf, 0x6c, 0xc1, 0x5c, - 0x27, 0x71, 0xa7, 0xa1, 0x16, 0xf2, 0x11, 0x0d, 0xa7, 0xc9, 0x8b, 0x12, 0xe3, 0x15, 0x82, 0x24, - 0x33, 0x4c, 0x73, 0x67, 0xeb, 0x81, 0xf4, 0xea, 0x6e, 0xd1, 0x80, 0x63, 0x4b, 0x45, 0x4f, 0x93, - 0x58, 0x49, 0x82, 0x31, 0x8d, 0xcf, 0x7a, 0x98, 0x7f, 0xdd, 0x28, 0x8f, 0x17, 0x56, 0x14, 0x01, - 0x8c, 0x69, 0x91, 0xd7, 0x61, 0x56, 0xa6, 0xd0, 0xdd, 0xf4, 0x1b, 0x37, 0x9c, 0x70, 0x57, 0x9e, - 0x70, 0xf4, 0x89, 0x6c, 0x25, 0x01, 0xc5, 0x14, 0x36, 0xff, 0xb6, 0x38, 0x4f, 0x31, 0x27, 0x30, - 0x91, 0x7c, 0xa4, 0x61, 0x25, 0x09, 0xc6, 0x34, 0x3e, 0x79, 0xd1, 0xd8, 0x86, 0xc4, 0xfd, 0xbf, - 0x5e, 0x0d, 0x32, 0xb6, 0xa2, 0x0a, 0xcc, 0x75, 0xf9, 0x81, 0xb0, 0xa1, 0x80, 0x72, 0x3e, 0x6a, - 0x86, 0x77, 0x93, 0x60, 0x4c, 0xe3, 0x93, 0xd7, 0xe0, 0x4c, 0xc0, 0x16, 0x5b, 0x4d, 0x40, 0x38, - 0x05, 0xe8, 0x3b, 0x5f, 0x34, 0x81, 0x98, 0xc4, 0x25, 0x6f, 0xc0, 0xd9, 0x38, 0xe3, 0xa4, 0x22, - 0x20, 0xbc, 0x04, 0x74, 0xfa, 0xb3, 0x4a, 0x1a, 0x01, 0x7b, 0xeb, 0x90, 0xbf, 0x05, 0xf3, 0x46, - 0x4b, 0xac, 0x79, 0x0d, 0xfa, 0x50, 0x66, 0x05, 0xe4, 0x8f, 0x0e, 0xad, 0xa4, 0x60, 0xd8, 0x83, - 0x4d, 0x3e, 0x01, 0xb3, 0x75, 0xbf, 0xd5, 0xe2, 0x6b, 0x9c, 0x78, 0x20, 0x40, 0xa4, 0xff, 0x13, - 0x89, 0x12, 0x13, 0x10, 0x4c, 0x61, 0x92, 0x9b, 0x40, 0xfc, 0x6d, 0xa6, 0x5e, 0xd1, 0xc6, 0x1b, - 0xe2, 0x75, 0x7c, 0xa6, 0x71, 0x9c, 0x49, 0xc6, 0x94, 0xdc, 0xee, 0xc1, 0xc0, 0x8c, 0x5a, 0x3c, - 0x7b, 0x9a, 0x11, 0x83, 0x3b, 0x9b, 0xc7, 0x43, 0x7e, 0x69, 0xf3, 0xc5, 0x63, 0x03, 0x70, 0x03, - 0x98, 0x10, 0x21, 0x3e, 0xf9, 0xe4, 0x01, 0x34, 0x73, 0x85, 0xc7, 0x7b, 0x84, 0x28, 0x45, 0xc9, - 0x89, 0xfc, 0x02, 0x94, 0xb6, 0xd5, 0xc3, 0x11, 0x3c, 0xf9, 0xdf, 0xc8, 0xfb, 0x62, 0xea, 0x0d, - 0x94, 0xf8, 0x78, 0xae, 0x01, 0x18, 0xb3, 0x24, 0x2f, 0xc0, 0xf4, 0x8d, 0xcd, 0x8a, 0x1e, 0x85, - 0x67, 0x79, 0xef, 0x8f, 0xb3, 0x2a, 0x68, 0x02, 0xd8, 0x0c, 0xd3, 0xea, 0x1b, 0x49, 0x5e, 0x7c, - 0x67, 0x68, 0x63, 0x0c, 0x9b, 0xdf, 0xe4, 0x63, 0x6d, 0xe1, 0x5c, 0x0a, 0x5b, 0x96, 0xa3, 0xc6, - 0x20, 0x6f, 0xc3, 0xb4, 0xdc, 0x2f, 0xf8, 0xda, 0x74, 0xfe, 0x64, 0xf1, 0xdd, 0x18, 0x93, 0x40, - 0x93, 0x1e, 0xbf, 0xb3, 0xe5, 0xf9, 0xf4, 0xe9, 0xf5, 0x6e, 0xab, 0xb5, 0x70, 0x81, 0xaf, 0x9b, - 0xf1, 0x9d, 0x6d, 0x0c, 0x42, 0x13, 0x8f, 0xbc, 0xa4, 0x3c, 0xb2, 0x3e, 0x90, 0xb8, 0xc4, 0xd6, - 0x1e, 0x59, 0x5a, 0xe9, 0xee, 0x13, 0x02, 0x72, 0xf1, 0x31, 0xae, 0x50, 0xdb, 0xb0, 0xa8, 0x34, - 0xbe, 0xde, 0x49, 0xb2, 0xb0, 0x90, 0x30, 0x95, 0x2c, 0xde, 0xeb, 0x8b, 0x89, 0xc7, 0x50, 0x21, - 0xdb, 0x50, 0x70, 0x5a, 0xdb, 0x0b, 0x4f, 0xe7, 0xa1, 0xba, 0x56, 0xd6, 0xab, 0x72, 0x44, 0x71, - 0xb7, 0xcd, 0xca, 0x7a, 0x15, 0x19, 0x71, 0xe2, 0xc2, 0xb8, 0xd3, 0xda, 0x0e, 0x17, 0x16, 0xf9, - 0x9c, 0xcd, 0x8d, 0x49, 0x6c, 0x3c, 0x58, 0xaf, 0x86, 0xc8, 0x59, 0xd8, 0x5f, 0x1c, 0xd3, 0x17, - 0x35, 0x3a, 0x15, 0xf3, 0xbb, 0xe6, 0x04, 0xb2, 0xf2, 0x78, 0xe0, 0xbd, 0xe7, 0x21, 0x17, 0xb1, - 0xf7, 0x65, 0x4e, 0x9f, 0x8e, 0x5e, 0x32, 0x72, 0x49, 0x72, 0x95, 0x4c, 0x33, 0x2d, 0x4e, 0xcf, - 0xc9, 0x05, 0xc3, 0xfe, 0x36, 0x68, 0xa3, 0x5f, 0xca, 0x9b, 0x29, 0x80, 0xa2, 0x1b, 0x46, 0xae, - 0x9f, 0x63, 0xd8, 0x73, 0x2a, 0x3f, 0x33, 0x8f, 0xaa, 0xe0, 0x00, 0x14, 0xac, 0x18, 0x4f, 0xaf, - 0xe9, 0x7a, 0x0f, 0xe5, 0xe7, 0xdf, 0xc9, 0xdd, 0x4d, 0x49, 0xf0, 0xe4, 0x00, 0x14, 0xac, 0xc8, - 0x7d, 0x31, 0xa8, 0xf3, 0x79, 0xcc, 0x7f, 0xbd, 0x9a, 0xe2, 0x97, 0x1c, 0xdc, 0xf7, 0xa1, 0x10, - 0xb6, 0x5d, 0xa9, 0x2e, 0x8d, 0xc8, 0xab, 0xb6, 0xb1, 0x96, 0xc5, 0xab, 0xb6, 0xb1, 0x86, 0x8c, - 0x09, 0xf9, 0xb2, 0x05, 0xe0, 0xb4, 0xb7, 0x9d, 0x30, 0x74, 0x1a, 0xda, 0x3a, 0x33, 0xe2, 0xbb, - 0x0b, 0x15, 0x4d, 0x2f, 0xc5, 0x9a, 0x3b, 0xe6, 0xc6, 0x50, 0x34, 0x38, 0x93, 0x77, 0x60, 0xd2, - 0x11, 0x0f, 0xdb, 0x49, 0x1f, 0xf3, 0x7c, 0x5e, 0x6b, 0x4c, 0x49, 0xc0, 0xcd, 0x34, 0x12, 0x84, - 0x8a, 0x21, 0xe3, 0x1d, 0x05, 0x0e, 0xdd, 0x71, 0xf7, 0xa4, 0x71, 0xa8, 0x36, 0xf2, 0xd3, 0x0b, - 0x8c, 0x58, 0x16, 0x6f, 0x09, 0x42, 0xc5, 0x50, 0x3c, 0x34, 0xee, 0x78, 0x8e, 0x8e, 0x1c, 0xcc, - 0x27, 0xbe, 0xd4, 0x8c, 0x45, 0x34, 0x1e, 0x1a, 0x37, 0x19, 0x61, 0x92, 0x2f, 0xd9, 0x87, 0x09, - 0x87, 0x3f, 0xb9, 0x29, 0x8f, 0x62, 0x98, 0xc7, 0xf3, 0x9d, 0xa9, 0x36, 0xe0, 0x8b, 0x8b, 0x7c, - 0xd8, 0x53, 0x72, 0x23, 0xbf, 0x61, 0xc1, 0xa4, 0x70, 0x7f, 0x66, 0x0a, 0x29, 0xfb, 0xf6, 0xcf, - 0x9d, 0x42, 0x9e, 0x77, 0xe9, 0x9a, 0x2d, 0x3d, 0x80, 0x3e, 0xac, 0x7d, 0x3b, 0x45, 0xe9, 0xb1, - 0xce, 0xd9, 0x4a, 0xba, 0xc5, 0x4f, 0xc0, 0x8c, 0x49, 0x65, 0x28, 0xf7, 0xec, 0x1f, 0x14, 0x00, - 0x78, 0x43, 0x8b, 0x5c, 0x21, 0x6d, 0x9e, 0x94, 0x76, 0xd7, 0x6f, 0xe4, 0xf4, 0x3c, 0x9f, 0x91, - 0xf2, 0x03, 0x64, 0x06, 0xda, 0x5d, 0xbf, 0x81, 0x92, 0x09, 0x69, 0xc2, 0x78, 0xc7, 0x89, 0x76, - 0xf3, 0xcf, 0x2f, 0x32, 0x25, 0x82, 0x66, 0xa3, 0x5d, 0xe4, 0x0c, 0xc8, 0x7b, 0x56, 0xec, 0x1a, - 0x53, 0xc8, 0xc7, 0x81, 0x41, 0xb5, 0xd9, 0x92, 0x74, 0x86, 0x11, 0x3d, 0xd8, 0xd7, 0x45, 0x66, - 0xf1, 0x7d, 0x0b, 0x66, 0x4c, 0xd4, 0x8c, 0x6e, 0xfa, 0x39, 0xb3, 0x9b, 0xf2, 0x6c, 0x0f, 0xb3, - 0xc7, 0xff, 0x9b, 0x05, 0xc6, 0xe3, 0xf7, 0xb1, 0x17, 0xba, 0x35, 0xb0, 0x17, 0xfa, 0xd8, 0x90, - 0x5e, 0xe8, 0x85, 0xa1, 0xbc, 0xd0, 0xc7, 0x87, 0xf7, 0x42, 0x2f, 0xf6, 0xf7, 0x42, 0xb7, 0xbf, - 0x6e, 0xc1, 0xd9, 0x9e, 0xdd, 0x86, 0xe9, 0xc1, 0x81, 0xef, 0x47, 0x7d, 0x5c, 0x1e, 0x31, 0x06, - 0xa1, 0x89, 0x47, 0x56, 0x61, 0x5e, 0x3e, 0xc1, 0x50, 0xeb, 0xb4, 0xdc, 0xcc, 0xdc, 0x2f, 0x5b, - 0x29, 0x38, 0xf6, 0xd4, 0xb0, 0xbf, 0x6d, 0xc1, 0xb4, 0x11, 0x31, 0xce, 0xbe, 0x83, 0xbb, 0xb1, - 0x4a, 0x31, 0xe2, 0xd7, 0x27, 0xf8, 0x45, 0x95, 0x80, 0x89, 0x3b, 0xd3, 0xa6, 0x91, 0xa0, 0x3b, - 0xbe, 0x33, 0x65, 0xa5, 0x28, 0xa1, 0x22, 0xf5, 0x32, 0xed, 0xf0, 0x46, 0x2f, 0x98, 0xa9, 0x97, - 0x69, 0x07, 0x39, 0x84, 0xb3, 0x63, 0x07, 0x02, 0x19, 0xa0, 0x60, 0x3c, 0x76, 0xe1, 0x04, 0x11, - 0x0a, 0x18, 0xb9, 0x04, 0x05, 0xea, 0x35, 0xa4, 0xf5, 0x42, 0x3f, 0x47, 0x79, 0xcd, 0x6b, 0x20, - 0x2b, 0xb7, 0x6f, 0xc3, 0x8c, 0xf0, 0xce, 0x7d, 0x93, 0x1e, 0x0c, 0xfc, 0xbe, 0x25, 0x1b, 0xed, - 0xa9, 0xf7, 0x2d, 0x59, 0x75, 0x56, 0x6e, 0xff, 0x33, 0x0b, 0x52, 0x2f, 0xb2, 0x18, 0xf7, 0x27, - 0x56, 0xdf, 0xfb, 0x13, 0xd3, 0xe6, 0x3e, 0x76, 0xac, 0xcd, 0xfd, 0x26, 0x90, 0x36, 0x9b, 0x0a, - 0x89, 0xf7, 0x87, 0xa4, 0xe1, 0x28, 0xce, 0x4f, 0xd1, 0x83, 0x81, 0x19, 0xb5, 0xec, 0x7f, 0x2a, - 0x84, 0x35, 0xdf, 0x68, 0x79, 0x7c, 0x03, 0x74, 0xa1, 0xc8, 0x49, 0x49, 0xeb, 0xd9, 0x88, 0x96, - 0xe7, 0xde, 0x3c, 0x4f, 0x71, 0x47, 0xca, 0x29, 0xcf, 0xb9, 0xd9, 0x7f, 0x24, 0x64, 0x35, 0x1e, - 0x71, 0x19, 0x40, 0xd6, 0x76, 0x52, 0xd6, 0x1b, 0x79, 0xad, 0x95, 0xd9, 0x32, 0x92, 0x25, 0x80, - 0x0e, 0x0d, 0xea, 0xd4, 0x8b, 0x54, 0xdc, 0x4c, 0x51, 0x46, 0x70, 0xea, 0x52, 0x34, 0x30, 0xec, - 0xaf, 0xb1, 0x09, 0x14, 0xbf, 0xfc, 0x4a, 0xae, 0xa4, 0x7d, 0x45, 0xd3, 0x93, 0x43, 0xbb, 0x8a, - 0x1a, 0xd1, 0x14, 0x63, 0x8f, 0x89, 0xa6, 0xf8, 0x10, 0x4c, 0x06, 0x7e, 0x8b, 0x56, 0x02, 0x2f, - 0xed, 0xe0, 0x82, 0xac, 0x18, 0x6f, 0xa1, 0x82, 0xdb, 0xbf, 0x66, 0xc1, 0x7c, 0x3a, 0xdc, 0x2b, - 0x77, 0x07, 0x56, 0x33, 0x26, 0xbd, 0x30, 0x7c, 0x4c, 0xba, 0xfd, 0x1e, 0x13, 0x32, 0x72, 0xeb, - 0x7b, 0xae, 0x27, 0xc2, 0xb8, 0x59, 0xcb, 0x7d, 0x08, 0x26, 0xa9, 0x7c, 0xc1, 0x52, 0x18, 0x81, - 0xb5, 0x90, 0xea, 0xe1, 0x4a, 0x05, 0x27, 0x15, 0x98, 0x53, 0x57, 0x5f, 0xca, 0x72, 0x2f, 0xd2, - 0x4f, 0x68, 0x4b, 0xe1, 0x6a, 0x12, 0x8c, 0x69, 0x7c, 0xfb, 0x0b, 0x30, 0x6d, 0x6c, 0x4a, 0x7c, - 0xfd, 0x7e, 0xe8, 0xd4, 0xa3, 0xf4, 0xba, 0x77, 0x8d, 0x15, 0xa2, 0x80, 0xf1, 0x0b, 0x06, 0x11, - 0x8d, 0x92, 0x5a, 0xf7, 0x64, 0x0c, 0x8a, 0x84, 0x32, 0x62, 0x01, 0x6d, 0xd2, 0x87, 0x2a, 0x7f, - 0xba, 0x22, 0x86, 0xac, 0x10, 0x05, 0xcc, 0x7e, 0x11, 0xa6, 0x54, 0x92, 0x20, 0x9e, 0x69, 0x43, - 0x19, 0xbf, 0xcd, 0x4c, 0x1b, 0x7e, 0x10, 0x21, 0x87, 0xd8, 0x6f, 0xc1, 0x94, 0xca, 0x65, 0xf4, - 0x78, 0x6c, 0xb6, 0x14, 0x85, 0x9e, 0x7b, 0xc3, 0x0f, 0x23, 0x95, 0x80, 0x49, 0xdc, 0xcf, 0xdd, - 0x5a, 0xe3, 0x65, 0xa8, 0xa1, 0xf6, 0x4b, 0x30, 0x97, 0xba, 0xa7, 0x1d, 0x20, 0x2d, 0xc7, 0xef, - 0x15, 0x60, 0xc6, 0xbc, 0xae, 0x1b, 0x60, 0x16, 0x0f, 0xbe, 0x38, 0x66, 0x5c, 0xb1, 0x15, 0x86, - 0xbc, 0x62, 0x33, 0xef, 0x34, 0xc7, 0x4f, 0xf7, 0x4e, 0xb3, 0x98, 0xcf, 0x9d, 0xa6, 0x71, 0xf7, - 0x3e, 0xf1, 0xe4, 0xee, 0xde, 0x7f, 0xa7, 0x08, 0xb3, 0xc9, 0x3c, 0x8f, 0x03, 0xf4, 0xe4, 0x8b, - 0x3d, 0x3d, 0x39, 0xa4, 0x4d, 0xbf, 0x30, 0xaa, 0x4d, 0x7f, 0x7c, 0x54, 0x9b, 0x7e, 0xf1, 0x04, - 0x36, 0xfd, 0x5e, 0x8b, 0xfc, 0xc4, 0xc0, 0x16, 0xf9, 0x4f, 0x6a, 0xaf, 0xbc, 0xc9, 0x84, 0x1b, - 0x4b, 0xec, 0x95, 0x47, 0x92, 0xdd, 0xb0, 0xe2, 0x37, 0x32, 0xbd, 0x1b, 0xa7, 0x1e, 0x63, 0xbb, - 0x0c, 0x32, 0x9d, 0xe8, 0x86, 0xbf, 0x36, 0xfc, 0xc0, 0x10, 0x0e, 0x74, 0xaf, 0xc0, 0xb4, 0x1c, - 0x4f, 0x5c, 0x05, 0x85, 0xa4, 0xfa, 0x5a, 0x8b, 0x41, 0x68, 0xe2, 0xf1, 0x27, 0xc0, 0x93, 0x0f, - 0xc3, 0xf3, 0x2b, 0x12, 0xf3, 0x09, 0xf0, 0xd4, 0x43, 0xf2, 0x69, 0x7c, 0xfb, 0xf3, 0x70, 0x21, - 0xd3, 0x8c, 0xc0, 0x4d, 0xb8, 0x5c, 0x3b, 0xa2, 0x0d, 0x89, 0x60, 0x88, 0x91, 0x7a, 0x3a, 0x60, - 0xf1, 0x5e, 0x5f, 0x4c, 0x3c, 0x86, 0x8a, 0xfd, 0xad, 0x02, 0xcc, 0x26, 0xdf, 0x8f, 0x24, 0x0f, - 0xb4, 0xd1, 0x31, 0x17, 0x7b, 0xa7, 0x20, 0x6b, 0xe4, 0x0e, 0xec, 0x7b, 0x59, 0xf1, 0x80, 0x8f, - 0xaf, 0x6d, 0x9d, 0xc8, 0xf0, 0xf4, 0x18, 0xcb, 0x5b, 0x02, 0xc9, 0x8e, 0x3f, 0x11, 0x19, 0x87, - 0x19, 0xca, 0xd3, 0x6c, 0xee, 0xdc, 0xe3, 0x70, 0x39, 0xcd, 0x0a, 0x0d, 0xb6, 0x6c, 0x6f, 0xd9, - 0xa7, 0x81, 0xbb, 0xe3, 0xea, 0xb7, 0xaf, 0xf9, 0xca, 0xfd, 0x96, 0x2c, 0x43, 0x0d, 0xb5, 0xdf, - 0x1b, 0x83, 0x12, 0xcf, 0x8a, 0x74, 0x3d, 0xf0, 0xdb, 0xfc, 0x91, 0xb5, 0xd0, 0x38, 0x39, 0xc8, - 0x6e, 0xbb, 0x39, 0xea, 0x4b, 0x86, 0x31, 0x45, 0xe9, 0x31, 0x6d, 0x94, 0x60, 0x82, 0x23, 0xe9, - 0xc0, 0xd4, 0x8e, 0xcc, 0xe2, 0x2a, 0xfb, 0x6e, 0xc4, 0x4c, 0x84, 0x2a, 0x27, 0xac, 0x68, 0x02, - 0xf5, 0x0f, 0x35, 0x17, 0xdb, 0x81, 0xb9, 0x54, 0x5a, 0x8b, 0xdc, 0x73, 0xbf, 0xfe, 0xcf, 0x71, - 0x28, 0xe9, 0x70, 0x1d, 0xf2, 0xf1, 0x84, 0x19, 0xa7, 0x54, 0xfd, 0xa0, 0xf1, 0x02, 0xd0, 0xae, - 0xdf, 0x78, 0x74, 0x58, 0x9e, 0xd3, 0xc8, 0x29, 0x93, 0xcc, 0x25, 0x28, 0x74, 0x83, 0x56, 0xfa, - 0x9c, 0x76, 0x17, 0xd7, 0x91, 0x95, 0x9b, 0x21, 0x46, 0x85, 0x27, 0x1a, 0x62, 0xc4, 0x76, 0xc9, - 0x6d, 0xbf, 0x71, 0x90, 0x7e, 0x31, 0xa8, 0xea, 0x37, 0x0e, 0x90, 0x43, 0xc8, 0xeb, 0x30, 0x2b, - 0xe3, 0xa6, 0xcc, 0x77, 0xd4, 0x0b, 0xf1, 0xe5, 0xfb, 0x56, 0x02, 0x8a, 0x29, 0x6c, 0xb6, 0xcb, - 0xde, 0x0f, 0x7d, 0x8f, 0x67, 0xf4, 0x9d, 0x48, 0xde, 0xd4, 0xdd, 0xac, 0xdd, 0xbe, 0xc5, 0xcd, - 0x49, 0x1a, 0x23, 0x11, 0x9a, 0x35, 0xf9, 0xd8, 0xd0, 0xac, 0x55, 0x41, 0x9b, 0x49, 0xcb, 0x77, - 0x94, 0x99, 0xea, 0x15, 0x45, 0x97, 0x95, 0x3d, 0x3a, 0x3c, 0xc6, 0xd0, 0xa7, 0x6b, 0x66, 0x05, - 0xb1, 0x95, 0x7e, 0x74, 0x41, 0x6c, 0xf6, 0x5d, 0x98, 0x4b, 0xf5, 0x9f, 0x3a, 0xe6, 0x5b, 0xd9, - 0xc7, 0xfc, 0xc1, 0xde, 0x1c, 0xfa, 0x17, 0x16, 0x9c, 0xed, 0x59, 0x91, 0x06, 0x8d, 0x26, 0x4c, - 0xef, 0x8d, 0x63, 0x27, 0xdf, 0x1b, 0x0b, 0xc3, 0xed, 0x8d, 0xd5, 0xed, 0xef, 0x7c, 0xff, 0xf2, - 0x53, 0xdf, 0xfd, 0xfe, 0xe5, 0xa7, 0xfe, 0xf8, 0xfb, 0x97, 0x9f, 0x7a, 0xef, 0xe8, 0xb2, 0xf5, - 0x9d, 0xa3, 0xcb, 0xd6, 0x77, 0x8f, 0x2e, 0x5b, 0x7f, 0x7c, 0x74, 0xd9, 0xfa, 0x4f, 0x47, 0x97, - 0xad, 0xaf, 0xff, 0xf9, 0xe5, 0xa7, 0x3e, 0xfd, 0xc9, 0xb8, 0xa7, 0x96, 0x55, 0x4f, 0xf1, 0x1f, - 0x1f, 0x51, 0xfd, 0xb2, 0xdc, 0xd9, 0x6b, 0x2e, 0xb3, 0x9e, 0x5a, 0xd6, 0x25, 0xaa, 0xa7, 0xfe, - 0x6f, 0x00, 0x00, 0x00, 0xff, 0xff, 0x7b, 0xb2, 0x75, 0xab, 0x44, 0xa1, 0x00, 0x00, + // 8388 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x7d, 0x6d, 0x6c, 0x24, 0xc9, + 0x75, 0xd8, 0x35, 0x87, 0x43, 0xce, 0x3c, 0x72, 0x49, 0x6e, 0xed, 0xae, 0x8e, 0xc7, 0xbb, 0xdb, + 0x39, 0xf5, 0x39, 0x97, 0x3d, 0xeb, 0x44, 0x4a, 0x7b, 0x77, 0xc9, 0x49, 0xa7, 0x5c, 0x32, 0x43, + 0xee, 0xde, 0x72, 0x8f, 0xdc, 0xe5, 0xbe, 0xe1, 0xde, 0xda, 0x92, 0xce, 0x56, 0x73, 0xa6, 0x38, + 0xec, 0xe5, 0x4c, 0xf7, 0xa8, 0xbb, 0x87, 0xbb, 0x3c, 0x1d, 0xac, 0x93, 0x85, 0x53, 0x14, 0x43, + 0x82, 0x95, 0xd8, 0x42, 0x10, 0x24, 0x08, 0x14, 0xc3, 0x80, 0x93, 0xd8, 0xbf, 0x84, 0x04, 0xf9, + 0x63, 0x20, 0x42, 0x1c, 0xdb, 0xfa, 0x11, 0x07, 0xf2, 0x8f, 0x44, 0x76, 0x00, 0xd3, 0x11, 0x9d, + 0x3f, 0x09, 0x12, 0x08, 0x09, 0x14, 0x04, 0xde, 0x1f, 0x41, 0x50, 0x9f, 0x5d, 0xdd, 0xd3, 0xc3, + 0x9d, 0xd9, 0x69, 0xae, 0x94, 0xc4, 0xff, 0x66, 0xea, 0x55, 0xbd, 0xf7, 0xba, 0x3e, 0x5e, 0xbd, + 0x7a, 0xf5, 0xde, 0x2b, 0xd8, 0x68, 0xb9, 0xd1, 0x5e, 0x6f, 0x67, 0xb9, 0xe1, 0x77, 0x56, 0x9c, + 0xa0, 0xe5, 0x77, 0x03, 0xff, 0x2e, 0xff, 0xf1, 0xd1, 0xc0, 0x6f, 0xb7, 0xfd, 0x5e, 0x14, 0xae, + 0x74, 0xf7, 0x5b, 0x2b, 0x4e, 0xd7, 0x0d, 0x57, 0x74, 0xc9, 0xc1, 0xc7, 0x9d, 0x76, 0x77, 0xcf, + 0xf9, 0xf8, 0x4a, 0x8b, 0x7a, 0x34, 0x70, 0x22, 0xda, 0x5c, 0xee, 0x06, 0x7e, 0xe4, 0x93, 0x4f, + 0xc5, 0xd8, 0x96, 0x15, 0x36, 0xfe, 0xe3, 0xe7, 0x55, 0xdb, 0xe5, 0xee, 0x7e, 0x6b, 0x99, 0x61, + 0x5b, 0xd6, 0x25, 0x0a, 0xdb, 0xd2, 0x47, 0x0d, 0x5e, 0x5a, 0x7e, 0xcb, 0x5f, 0xe1, 0x48, 0x77, + 0x7a, 0xbb, 0xfc, 0x1f, 0xff, 0xc3, 0x7f, 0x09, 0x62, 0x4b, 0xcf, 0xef, 0xbf, 0x16, 0x2e, 0xbb, + 0x3e, 0xe3, 0x6d, 0x65, 0xc7, 0x89, 0x1a, 0x7b, 0x2b, 0x07, 0x7d, 0x1c, 0x2d, 0xd9, 0x46, 0xa5, + 0x86, 0x1f, 0xd0, 0xac, 0x3a, 0xaf, 0xc4, 0x75, 0x3a, 0x4e, 0x63, 0xcf, 0xf5, 0x68, 0x70, 0x18, + 0x7f, 0x75, 0x87, 0x46, 0x4e, 0x56, 0xab, 0x95, 0x41, 0xad, 0x82, 0x9e, 0x17, 0xb9, 0x1d, 0xda, + 0xd7, 0xe0, 0xaf, 0x3c, 0xac, 0x41, 0xd8, 0xd8, 0xa3, 0x1d, 0xa7, 0xaf, 0xdd, 0xcb, 0x83, 0xda, + 0xf5, 0x22, 0xb7, 0xbd, 0xe2, 0x7a, 0x51, 0x18, 0x05, 0xe9, 0x46, 0xf6, 0x0f, 0x0b, 0x50, 0xae, + 0x6e, 0xd4, 0xea, 0x91, 0x13, 0xf5, 0x42, 0xf2, 0x15, 0x0b, 0x66, 0xdb, 0xbe, 0xd3, 0xac, 0x39, + 0x6d, 0xc7, 0x6b, 0xd0, 0x60, 0xd1, 0x7a, 0xce, 0xba, 0x34, 0x73, 0x79, 0x63, 0x79, 0x9c, 0xf1, + 0x5a, 0xae, 0xde, 0x0b, 0x91, 0x86, 0x7e, 0x2f, 0x68, 0x50, 0xa4, 0xbb, 0xb5, 0xf3, 0xdf, 0x3d, + 0xaa, 0x3c, 0x71, 0x7c, 0x54, 0x99, 0xdd, 0x30, 0x28, 0x61, 0x82, 0x2e, 0xf9, 0xa6, 0x05, 0x67, + 0x1b, 0x8e, 0xe7, 0x04, 0x87, 0xdb, 0x4e, 0xd0, 0xa2, 0xd1, 0x9b, 0x81, 0xdf, 0xeb, 0x2e, 0x4e, + 0x9c, 0x02, 0x37, 0x4f, 0x49, 0x6e, 0xce, 0xae, 0xa6, 0xc9, 0x61, 0x3f, 0x07, 0x9c, 0xaf, 0x30, + 0x72, 0x76, 0xda, 0xd4, 0xe4, 0xab, 0x70, 0x9a, 0x7c, 0xd5, 0xd3, 0xe4, 0xb0, 0x9f, 0x03, 0xf2, + 0x22, 0x4c, 0xbb, 0x5e, 0x2b, 0xa0, 0x61, 0xb8, 0x38, 0xf9, 0x9c, 0x75, 0xa9, 0x5c, 0x9b, 0x97, + 0xcd, 0xa7, 0xd7, 0x45, 0x31, 0x2a, 0xb8, 0xfd, 0xed, 0x02, 0x9c, 0xad, 0x6e, 0xd4, 0xb6, 0x03, + 0x67, 0x77, 0xd7, 0x6d, 0xa0, 0xdf, 0x8b, 0x5c, 0xaf, 0x65, 0x22, 0xb0, 0x4e, 0x46, 0x40, 0x5e, + 0x85, 0x99, 0x90, 0x06, 0x07, 0x6e, 0x83, 0x6e, 0xf9, 0x41, 0xc4, 0x07, 0xa5, 0x58, 0x3b, 0x27, + 0xab, 0xcf, 0xd4, 0x63, 0x10, 0x9a, 0xf5, 0x58, 0xb3, 0xc0, 0xf7, 0x23, 0x09, 0xe7, 0x7d, 0x56, + 0x8e, 0x9b, 0x61, 0x0c, 0x42, 0xb3, 0x1e, 0x59, 0x83, 0x05, 0xc7, 0xf3, 0xfc, 0xc8, 0x89, 0x5c, + 0xdf, 0xdb, 0x0a, 0xe8, 0xae, 0x7b, 0x5f, 0x7e, 0xe2, 0xa2, 0x6c, 0xbb, 0x50, 0x4d, 0xc1, 0xb1, + 0xaf, 0x05, 0xf9, 0x86, 0x05, 0x0b, 0x61, 0xe4, 0x36, 0xf6, 0x5d, 0x8f, 0x86, 0xe1, 0xaa, 0xef, + 0xed, 0xba, 0xad, 0xc5, 0x22, 0x1f, 0xb6, 0x1b, 0xe3, 0x0d, 0x5b, 0x3d, 0x85, 0xb5, 0x76, 0x9e, + 0xb1, 0x94, 0x2e, 0xc5, 0x3e, 0xea, 0xe4, 0x23, 0x50, 0x96, 0x3d, 0x4a, 0xc3, 0xc5, 0xa9, 0xe7, + 0x0a, 0x97, 0xca, 0xb5, 0x33, 0xc7, 0x47, 0x95, 0xf2, 0xba, 0x2a, 0xc4, 0x18, 0x6e, 0xaf, 0xc1, + 0x62, 0xb5, 0xb3, 0xe3, 0x84, 0xa1, 0xd3, 0xf4, 0x83, 0xd4, 0xd0, 0x5d, 0x82, 0x52, 0xc7, 0xe9, + 0x76, 0x5d, 0xaf, 0xc5, 0xc6, 0x8e, 0xe1, 0x99, 0x3d, 0x3e, 0xaa, 0x94, 0x36, 0x65, 0x19, 0x6a, + 0xa8, 0xfd, 0xc7, 0x13, 0x30, 0x53, 0xf5, 0x9c, 0xf6, 0x61, 0xe8, 0x86, 0xd8, 0xf3, 0xc8, 0xe7, + 0xa0, 0xc4, 0xa4, 0x56, 0xd3, 0x89, 0x1c, 0xb9, 0xd2, 0x3f, 0xb6, 0x2c, 0x84, 0xc8, 0xb2, 0x29, + 0x44, 0xe2, 0xcf, 0x67, 0xb5, 0x97, 0x0f, 0x3e, 0xbe, 0x7c, 0x73, 0xe7, 0x2e, 0x6d, 0x44, 0x9b, + 0x34, 0x72, 0x6a, 0x44, 0x8e, 0x02, 0xc4, 0x65, 0xa8, 0xb1, 0x12, 0x1f, 0x26, 0xc3, 0x2e, 0x6d, + 0xc8, 0x95, 0xbb, 0x39, 0xe6, 0x0a, 0x89, 0x59, 0xaf, 0x77, 0x69, 0xa3, 0x36, 0x2b, 0x49, 0x4f, + 0xb2, 0x7f, 0xc8, 0x09, 0x91, 0x7b, 0x30, 0x15, 0x72, 0x59, 0x26, 0x17, 0xe5, 0xcd, 0xfc, 0x48, + 0x72, 0xb4, 0xb5, 0x39, 0x49, 0x74, 0x4a, 0xfc, 0x47, 0x49, 0xce, 0xfe, 0x0f, 0x16, 0x9c, 0x33, + 0x6a, 0x57, 0x83, 0x56, 0xaf, 0x43, 0xbd, 0x88, 0x3c, 0x07, 0x93, 0x9e, 0xd3, 0xa1, 0x72, 0x55, + 0x69, 0x96, 0x6f, 0x38, 0x1d, 0x8a, 0x1c, 0x42, 0x9e, 0x87, 0xe2, 0x81, 0xd3, 0xee, 0x51, 0xde, + 0x49, 0xe5, 0xda, 0x19, 0x59, 0xa5, 0xf8, 0x36, 0x2b, 0x44, 0x01, 0x23, 0xef, 0x41, 0x99, 0xff, + 0xb8, 0x1a, 0xf8, 0x9d, 0x9c, 0x3e, 0x4d, 0x72, 0xf8, 0xb6, 0x42, 0x2b, 0xa6, 0x9f, 0xfe, 0x8b, + 0x31, 0x41, 0xfb, 0x4f, 0x2d, 0x98, 0x37, 0x3e, 0x6e, 0xc3, 0x0d, 0x23, 0xf2, 0xd9, 0xbe, 0xc9, + 0xb3, 0x3c, 0xdc, 0xe4, 0x61, 0xad, 0xf9, 0xd4, 0x59, 0x90, 0x5f, 0x5a, 0x52, 0x25, 0xc6, 0xc4, + 0xf1, 0xa0, 0xe8, 0x46, 0xb4, 0x13, 0x2e, 0x4e, 0x3c, 0x57, 0xb8, 0x34, 0x73, 0x79, 0x3d, 0xb7, + 0x61, 0x8c, 0xfb, 0x77, 0x9d, 0xe1, 0x47, 0x41, 0xc6, 0xfe, 0x67, 0x85, 0xc4, 0xf0, 0x6d, 0x2a, + 0x3e, 0x3e, 0xb0, 0x60, 0xaa, 0xed, 0xec, 0xd0, 0xb6, 0x58, 0x5b, 0x33, 0x97, 0xdf, 0xc9, 0x8d, + 0x13, 0x45, 0x63, 0x79, 0x83, 0xe3, 0xbf, 0xe2, 0x45, 0xc1, 0x61, 0x3c, 0xbd, 0x44, 0x21, 0x4a, + 0xe2, 0xe4, 0xef, 0x59, 0x30, 0x13, 0x4b, 0x35, 0xd5, 0x2d, 0x3b, 0xf9, 0x33, 0x13, 0x0b, 0x53, + 0xc9, 0x91, 0x16, 0xd1, 0x06, 0x04, 0x4d, 0x5e, 0x96, 0x3e, 0x01, 0x33, 0xc6, 0x27, 0x90, 0x05, + 0x28, 0xec, 0xd3, 0x43, 0x31, 0xe1, 0x91, 0xfd, 0x24, 0xe7, 0x13, 0x33, 0x5c, 0x4e, 0xe9, 0x4f, + 0x4e, 0xbc, 0x66, 0x2d, 0xbd, 0x01, 0x0b, 0x69, 0x82, 0xa3, 0xb4, 0xb7, 0xbf, 0x3d, 0x99, 0x98, + 0x98, 0x4c, 0x10, 0x10, 0x1f, 0xa6, 0x3b, 0x34, 0x0a, 0xdc, 0x86, 0x1a, 0xb2, 0xb5, 0xf1, 0x7a, + 0x69, 0x93, 0x23, 0x8b, 0x37, 0x44, 0xf1, 0x3f, 0x44, 0x45, 0x85, 0xec, 0xc1, 0xa4, 0x13, 0xb4, + 0xd4, 0x98, 0x5c, 0xcd, 0x67, 0x59, 0xc6, 0xa2, 0xa2, 0x1a, 0xb4, 0x42, 0xe4, 0x14, 0xc8, 0x0a, + 0x94, 0x23, 0x1a, 0x74, 0x5c, 0xcf, 0x89, 0xc4, 0x0e, 0x5a, 0xaa, 0x9d, 0x95, 0xd5, 0xca, 0xdb, + 0x0a, 0x80, 0x71, 0x1d, 0xd2, 0x86, 0xa9, 0x66, 0x70, 0x88, 0x3d, 0x6f, 0x71, 0x32, 0x8f, 0xae, + 0x58, 0xe3, 0xb8, 0xe2, 0x49, 0x2a, 0xfe, 0xa3, 0xa4, 0x41, 0x7e, 0xdd, 0x82, 0xf3, 0x1d, 0xea, + 0x84, 0xbd, 0x80, 0xb2, 0x4f, 0x40, 0x1a, 0x51, 0x8f, 0x0d, 0xec, 0x62, 0x91, 0x13, 0xc7, 0x71, + 0xc7, 0xa1, 0x1f, 0x73, 0xed, 0x19, 0xc9, 0xca, 0xf9, 0x2c, 0x28, 0x66, 0x72, 0x63, 0xff, 0xf1, + 0x24, 0x9c, 0xed, 0x13, 0xec, 0xe4, 0x15, 0x28, 0x76, 0xf7, 0x9c, 0x50, 0x49, 0xea, 0x8b, 0x4a, + 0x4c, 0x6c, 0xb1, 0xc2, 0x07, 0x47, 0x95, 0x33, 0xaa, 0x09, 0x2f, 0x40, 0x51, 0x99, 0xe9, 0x4d, + 0x1d, 0x1a, 0x86, 0x4e, 0x4b, 0x89, 0x6f, 0x63, 0x9a, 0xf0, 0x62, 0x54, 0x70, 0xf2, 0x37, 0x2d, + 0x38, 0x23, 0xa6, 0x0c, 0xd2, 0xb0, 0xd7, 0x8e, 0xd8, 0x16, 0xc5, 0xba, 0xe5, 0x7a, 0x1e, 0xd3, + 0x53, 0xa0, 0xac, 0x5d, 0x90, 0xd4, 0xcf, 0x98, 0xa5, 0x21, 0x26, 0xe9, 0x92, 0x3b, 0x50, 0x0e, + 0x23, 0x27, 0x88, 0x68, 0xb3, 0x1a, 0x71, 0x65, 0x6a, 0xe6, 0xf2, 0x4f, 0x0f, 0x27, 0xbb, 0xb7, + 0xdd, 0x0e, 0x15, 0xfb, 0x44, 0x5d, 0x21, 0xc0, 0x18, 0x17, 0x79, 0x0f, 0x20, 0xe8, 0x79, 0xf5, + 0x5e, 0xa7, 0xe3, 0x04, 0x87, 0x52, 0xbf, 0xba, 0x36, 0xde, 0xe7, 0xa1, 0xc6, 0x17, 0xab, 0x1a, + 0x71, 0x19, 0x1a, 0xf4, 0xc8, 0x97, 0x2c, 0x38, 0x23, 0x66, 0xa2, 0xe2, 0x60, 0x2a, 0x67, 0x0e, + 0xce, 0xb2, 0xae, 0x5d, 0x33, 0x49, 0x60, 0x92, 0xa2, 0xfd, 0xef, 0x92, 0x6a, 0x40, 0x3d, 0x62, + 0x87, 0xad, 0xd6, 0x21, 0xf9, 0x0c, 0x3c, 0x15, 0xf6, 0x1a, 0x0d, 0x1a, 0x86, 0xbb, 0xbd, 0x36, + 0xf6, 0xbc, 0x6b, 0x6e, 0x18, 0xf9, 0xc1, 0xe1, 0x86, 0xdb, 0x71, 0x23, 0x3e, 0xe3, 0x8a, 0xb5, + 0x67, 0x8f, 0x8f, 0x2a, 0x4f, 0xd5, 0x07, 0x55, 0xc2, 0xc1, 0xed, 0x89, 0x03, 0x4f, 0xf7, 0xbc, + 0xc1, 0xe8, 0x85, 0x86, 0x5e, 0x39, 0x3e, 0xaa, 0x3c, 0x7d, 0x7b, 0x70, 0x35, 0x3c, 0x09, 0x87, + 0xfd, 0x5f, 0x2c, 0x26, 0xa9, 0xc5, 0x77, 0x6d, 0xd3, 0x4e, 0xb7, 0xcd, 0xa4, 0xcb, 0xe9, 0xeb, + 0x8f, 0x51, 0x42, 0x7f, 0xc4, 0x7c, 0xb6, 0x3b, 0xc5, 0xff, 0x20, 0x25, 0xd2, 0xfe, 0xcf, 0x16, + 0x9c, 0x4f, 0x57, 0x7e, 0x0c, 0x3a, 0x4f, 0x98, 0xd4, 0x79, 0x6e, 0xe4, 0xfb, 0xb5, 0x03, 0x14, + 0x9f, 0xaf, 0x4c, 0xf6, 0x7f, 0xeb, 0xff, 0xeb, 0xdb, 0x68, 0xbc, 0x2b, 0x16, 0x7e, 0x9c, 0xbb, + 0xe2, 0xe4, 0x4f, 0xd4, 0xae, 0xf8, 0x8f, 0x27, 0x61, 0xb6, 0xea, 0x45, 0x6e, 0x75, 0x77, 0xd7, + 0xf5, 0xdc, 0xe8, 0x90, 0x7c, 0x6d, 0x02, 0x56, 0xba, 0x01, 0xdd, 0xa5, 0x41, 0x40, 0x9b, 0x6b, + 0xbd, 0xc0, 0xf5, 0x5a, 0xf5, 0xc6, 0x1e, 0x6d, 0xf6, 0xda, 0xae, 0xd7, 0x5a, 0x6f, 0x79, 0xbe, + 0x2e, 0xbe, 0x72, 0x9f, 0x36, 0x7a, 0xfc, 0x93, 0xc4, 0xa2, 0xe8, 0x8c, 0xf7, 0x49, 0x5b, 0xa3, + 0x11, 0xad, 0xbd, 0x7c, 0x7c, 0x54, 0x59, 0x19, 0xb1, 0x11, 0x8e, 0xfa, 0x69, 0xe4, 0xab, 0x13, + 0xb0, 0x1c, 0xd0, 0xcf, 0xf7, 0xdc, 0xe1, 0x7b, 0x43, 0x48, 0xad, 0xf6, 0x98, 0xdb, 0xcf, 0x48, + 0x34, 0x6b, 0x97, 0x8f, 0x8f, 0x2a, 0x23, 0xb6, 0xc1, 0x11, 0xbf, 0xcb, 0xde, 0x82, 0x99, 0x6a, + 0xd7, 0x0d, 0xdd, 0xfb, 0xe8, 0xf7, 0x22, 0x3a, 0xc4, 0x11, 0xb7, 0x02, 0xc5, 0xa0, 0xd7, 0xa6, + 0x62, 0x6d, 0x97, 0x6b, 0x65, 0x26, 0x85, 0x90, 0x15, 0xa0, 0x28, 0xb7, 0x7f, 0x91, 0x49, 0x5c, + 0x8e, 0x32, 0x65, 0xdc, 0xb8, 0x0b, 0xc5, 0x80, 0x11, 0x91, 0x33, 0x6b, 0xdc, 0x73, 0x60, 0xcc, + 0xb5, 0x64, 0x82, 0xfd, 0x44, 0x41, 0xc2, 0xfe, 0x9d, 0x09, 0xb8, 0x50, 0xed, 0x76, 0x37, 0x69, + 0xb8, 0x97, 0xe2, 0xe2, 0x97, 0x2d, 0x98, 0x3b, 0x70, 0x83, 0xa8, 0xe7, 0xb4, 0x95, 0xfd, 0x4a, + 0xf0, 0x53, 0x1f, 0x97, 0x1f, 0x4e, 0xed, 0xed, 0x04, 0xea, 0x1a, 0x39, 0x3e, 0xaa, 0xcc, 0x25, + 0xcb, 0x30, 0x45, 0x9e, 0xfc, 0x5d, 0x0b, 0x16, 0x64, 0xd1, 0x0d, 0xbf, 0x49, 0x4d, 0xfb, 0xe8, + 0xed, 0x3c, 0x79, 0xd2, 0xc8, 0x85, 0x5d, 0x2b, 0x5d, 0x8a, 0x7d, 0x4c, 0xd8, 0xff, 0x6d, 0x02, + 0x9e, 0x1c, 0x80, 0x83, 0xfc, 0x86, 0x05, 0xe7, 0x85, 0x51, 0xd5, 0x00, 0x21, 0xdd, 0x95, 0xbd, + 0xf9, 0xb3, 0x79, 0x73, 0x8e, 0x6c, 0x89, 0x53, 0xaf, 0x41, 0x6b, 0x8b, 0x4c, 0x1a, 0xae, 0x66, + 0x90, 0xc6, 0x4c, 0x86, 0x38, 0xa7, 0xc2, 0xcc, 0x9a, 0xe2, 0x74, 0xe2, 0xb1, 0x70, 0x5a, 0xcf, + 0x20, 0x8d, 0x99, 0x0c, 0xd9, 0x7f, 0x1d, 0x9e, 0x3e, 0x01, 0xdd, 0xc3, 0x17, 0xa7, 0xfd, 0x8e, + 0x9e, 0xf5, 0xc9, 0x39, 0x37, 0xc4, 0xba, 0xb6, 0x61, 0x8a, 0x2f, 0x1d, 0xb5, 0xb0, 0x81, 0x6d, + 0x7f, 0x7c, 0x4d, 0x85, 0x28, 0x21, 0xf6, 0xef, 0x58, 0x50, 0x1a, 0xc1, 0x1a, 0x56, 0x49, 0x5a, + 0xc3, 0xca, 0x7d, 0x96, 0xb0, 0xa8, 0xdf, 0x12, 0xf6, 0xe6, 0x78, 0xa3, 0x31, 0x8c, 0x05, 0xec, + 0x87, 0x16, 0x9c, 0xed, 0xb3, 0x98, 0x91, 0x3d, 0x38, 0xdf, 0xf5, 0x9b, 0x4a, 0x6d, 0xba, 0xe6, + 0x84, 0x7b, 0x1c, 0x26, 0x3f, 0xef, 0x15, 0x36, 0x92, 0x5b, 0x19, 0xf0, 0x07, 0x47, 0x95, 0x45, + 0x8d, 0x24, 0x55, 0x01, 0x33, 0x31, 0x92, 0x2e, 0x94, 0x76, 0x5d, 0xda, 0x6e, 0xc6, 0x53, 0x70, + 0x4c, 0x05, 0xe9, 0xaa, 0xc4, 0x26, 0x8c, 0xc5, 0xea, 0x1f, 0x6a, 0x2a, 0xf6, 0x8f, 0x2c, 0x98, + 0xab, 0xf6, 0xa2, 0x3d, 0xa6, 0x1e, 0x34, 0xb8, 0x7d, 0x86, 0x78, 0x50, 0x0c, 0xdd, 0xd6, 0xc1, + 0x2b, 0xf9, 0x08, 0xe3, 0x3a, 0x43, 0x25, 0x8d, 0xe6, 0x5a, 0x37, 0xe5, 0x85, 0x28, 0xc8, 0x90, + 0x00, 0xa6, 0x7c, 0xa7, 0x17, 0xed, 0x5d, 0x96, 0x9f, 0x3c, 0xe6, 0x49, 0xf9, 0x26, 0xfb, 0x9c, + 0xcb, 0x92, 0xa2, 0xd6, 0xd6, 0x44, 0x29, 0x4a, 0x4a, 0xf6, 0x17, 0x61, 0x2e, 0x79, 0x13, 0x33, + 0xc4, 0x9c, 0x7d, 0x16, 0x0a, 0x4e, 0xe0, 0xc9, 0x19, 0x3b, 0x23, 0x2b, 0x14, 0xaa, 0x78, 0x03, + 0x59, 0x39, 0x79, 0x09, 0x4a, 0xbb, 0xbd, 0x76, 0x9b, 0x35, 0x90, 0xd7, 0x1e, 0xfa, 0x14, 0x70, + 0x55, 0x96, 0xa3, 0xae, 0x61, 0xff, 0xf9, 0x24, 0xcc, 0xd7, 0xda, 0x3d, 0xfa, 0x66, 0x40, 0xa9, + 0xb2, 0x4d, 0x54, 0x61, 0xbe, 0x1b, 0xd0, 0x03, 0x97, 0xde, 0xab, 0xd3, 0x36, 0x6d, 0x44, 0x7e, + 0x20, 0xb9, 0x79, 0x52, 0x22, 0x9a, 0xdf, 0x4a, 0x82, 0x31, 0x5d, 0x9f, 0xbc, 0x01, 0x73, 0x4e, + 0x23, 0x72, 0x0f, 0xa8, 0xc6, 0x20, 0xd8, 0xfd, 0x90, 0xc4, 0x30, 0x57, 0x4d, 0x40, 0x31, 0x55, + 0x9b, 0x7c, 0x16, 0x16, 0xc3, 0x86, 0xd3, 0xa6, 0xb7, 0xbb, 0x92, 0xd4, 0xea, 0x1e, 0x6d, 0xec, + 0x6f, 0xf9, 0xae, 0x17, 0x49, 0x4b, 0xd4, 0x73, 0x12, 0xd3, 0x62, 0x7d, 0x40, 0x3d, 0x1c, 0x88, + 0x81, 0xfc, 0x4b, 0x0b, 0x9e, 0xed, 0x06, 0x74, 0x2b, 0xf0, 0x3b, 0x3e, 0x9b, 0x6a, 0x7d, 0xe6, + 0x19, 0x69, 0xa6, 0x78, 0x7b, 0x4c, 0x5d, 0x4a, 0x94, 0xf4, 0x5b, 0xf5, 0x3f, 0x7c, 0x7c, 0x54, + 0x79, 0x76, 0xeb, 0x24, 0x06, 0xf0, 0x64, 0xfe, 0xc8, 0xbf, 0xb2, 0xe0, 0x62, 0xd7, 0x0f, 0xa3, + 0x13, 0x3e, 0xa1, 0x78, 0xaa, 0x9f, 0x60, 0x1f, 0x1f, 0x55, 0x2e, 0x6e, 0x9d, 0xc8, 0x01, 0x3e, + 0x84, 0x43, 0xfb, 0x78, 0x06, 0xce, 0x1a, 0x73, 0x4f, 0xda, 0x2e, 0x5e, 0x87, 0x33, 0x6a, 0x32, + 0xc4, 0xba, 0x4f, 0x39, 0xb6, 0x35, 0x55, 0x4d, 0x20, 0x26, 0xeb, 0xb2, 0x79, 0xa7, 0xa7, 0xa2, + 0x68, 0x9d, 0x9a, 0x77, 0x5b, 0x09, 0x28, 0xa6, 0x6a, 0x93, 0x75, 0x38, 0x27, 0x4b, 0x90, 0x76, + 0xdb, 0x6e, 0xc3, 0x59, 0xf5, 0x7b, 0x72, 0xca, 0x15, 0x6b, 0x4f, 0x1e, 0x1f, 0x55, 0xce, 0x6d, + 0xf5, 0x83, 0x31, 0xab, 0x0d, 0xd9, 0x80, 0xf3, 0x4e, 0x2f, 0xf2, 0xf5, 0xf7, 0x5f, 0xf1, 0xd8, + 0x76, 0xda, 0xe4, 0x53, 0xab, 0x24, 0xf6, 0xdd, 0x6a, 0x06, 0x1c, 0x33, 0x5b, 0x91, 0xad, 0x14, + 0xb6, 0x3a, 0x6d, 0xf8, 0x5e, 0x53, 0x8c, 0x72, 0x31, 0x3e, 0x81, 0x55, 0x33, 0xea, 0x60, 0x66, + 0x4b, 0xd2, 0x86, 0xb9, 0x8e, 0x73, 0xff, 0xb6, 0xe7, 0x1c, 0x38, 0x6e, 0x9b, 0x11, 0x91, 0xf6, + 0xab, 0xc1, 0x46, 0x95, 0x5e, 0xe4, 0xb6, 0x97, 0xc5, 0xcd, 0xfe, 0xf2, 0xba, 0x17, 0xdd, 0x0c, + 0xea, 0x11, 0xd3, 0xd4, 0x85, 0x06, 0xb9, 0x99, 0xc0, 0x85, 0x29, 0xdc, 0xe4, 0x26, 0x5c, 0xe0, + 0xcb, 0x71, 0xcd, 0xbf, 0xe7, 0xad, 0xd1, 0xb6, 0x73, 0xa8, 0x3e, 0x60, 0x9a, 0x7f, 0xc0, 0x53, + 0xc7, 0x47, 0x95, 0x0b, 0xf5, 0xac, 0x0a, 0x98, 0xdd, 0x8e, 0x38, 0xf0, 0x74, 0x12, 0x80, 0xf4, + 0xc0, 0x0d, 0x5d, 0xdf, 0x13, 0x56, 0xa8, 0x52, 0x6c, 0x85, 0xaa, 0x0f, 0xae, 0x86, 0x27, 0xe1, + 0x20, 0x7f, 0xdf, 0x82, 0xf3, 0x59, 0xcb, 0x70, 0xb1, 0x9c, 0xc7, 0xfd, 0x62, 0x6a, 0x69, 0x89, + 0x19, 0x91, 0x29, 0x14, 0x32, 0x99, 0x20, 0xef, 0x5b, 0x30, 0xeb, 0x18, 0x27, 0xe8, 0x45, 0xc8, + 0x63, 0xd7, 0x32, 0xcf, 0xe4, 0xb5, 0x85, 0xe3, 0xa3, 0x4a, 0xe2, 0x94, 0x8e, 0x09, 0x8a, 0xe4, + 0x1f, 0x5a, 0x70, 0x21, 0x73, 0x8d, 0x2f, 0xce, 0x9c, 0x46, 0x0f, 0xf1, 0x49, 0x92, 0x2d, 0x73, + 0xb2, 0xd9, 0x20, 0xdf, 0xb0, 0xf4, 0x56, 0xa6, 0xae, 0x9c, 0x16, 0x67, 0x39, 0x6b, 0xb7, 0xc6, + 0x34, 0x1a, 0xc4, 0x5a, 0x93, 0x42, 0x5c, 0x3b, 0x67, 0xec, 0x8c, 0xaa, 0x10, 0xd3, 0xe4, 0xc9, + 0xd7, 0x2d, 0xb5, 0x35, 0x6a, 0x8e, 0xce, 0x9c, 0x16, 0x47, 0x24, 0xde, 0x69, 0x35, 0x43, 0x29, + 0xe2, 0xe4, 0xe7, 0x60, 0xc9, 0xd9, 0xf1, 0x83, 0x28, 0x73, 0xf1, 0x2d, 0xce, 0xf1, 0x65, 0x74, + 0xf1, 0xf8, 0xa8, 0xb2, 0x54, 0x1d, 0x58, 0x0b, 0x4f, 0xc0, 0x60, 0xff, 0x56, 0x11, 0x66, 0xc5, + 0x49, 0x48, 0x6e, 0x5d, 0xbf, 0x6d, 0xc1, 0x33, 0x8d, 0x5e, 0x10, 0x50, 0x2f, 0xaa, 0x47, 0xb4, + 0xdb, 0xbf, 0x71, 0x59, 0xa7, 0xba, 0x71, 0x3d, 0x77, 0x7c, 0x54, 0x79, 0x66, 0xf5, 0x04, 0xfa, + 0x78, 0x22, 0x77, 0xe4, 0xdf, 0x5a, 0x60, 0xcb, 0x0a, 0x35, 0xa7, 0xb1, 0xdf, 0x0a, 0xfc, 0x9e, + 0xd7, 0xec, 0xff, 0x88, 0x89, 0x53, 0xfd, 0x88, 0x17, 0x8e, 0x8f, 0x2a, 0xf6, 0xea, 0x43, 0xb9, + 0xc0, 0x21, 0x38, 0x25, 0x6f, 0xc2, 0x59, 0x59, 0xeb, 0xca, 0xfd, 0x2e, 0x0d, 0x5c, 0x76, 0xe6, + 0x90, 0x8a, 0x63, 0xec, 0xad, 0x94, 0xae, 0x80, 0xfd, 0x6d, 0x48, 0x08, 0xd3, 0xf7, 0xa8, 0xdb, + 0xda, 0x8b, 0x94, 0xfa, 0x34, 0xa6, 0x8b, 0x92, 0xb4, 0x8a, 0xdc, 0x11, 0x38, 0x6b, 0x33, 0xc7, + 0x47, 0x95, 0x69, 0xf9, 0x07, 0x15, 0x25, 0x72, 0x03, 0xe6, 0xc4, 0x39, 0x75, 0xcb, 0xf5, 0x5a, + 0x5b, 0xbe, 0x27, 0xfc, 0x6c, 0xca, 0xb5, 0x17, 0xd4, 0x86, 0x5f, 0x4f, 0x40, 0x1f, 0x1c, 0x55, + 0x66, 0xd5, 0xef, 0xed, 0xc3, 0x2e, 0xc5, 0x54, 0x6b, 0xfb, 0xf7, 0xa6, 0x00, 0xd4, 0x74, 0xa5, + 0x5d, 0xf2, 0x11, 0x28, 0x87, 0x34, 0x12, 0x54, 0xe5, 0xc5, 0x89, 0xb8, 0x8f, 0x52, 0x85, 0x18, + 0xc3, 0xc9, 0x3e, 0x14, 0xbb, 0x4e, 0x2f, 0xa4, 0xf9, 0x9c, 0x1f, 0xe4, 0xe0, 0x6f, 0x31, 0x8c, + 0xe2, 0x60, 0xca, 0x7f, 0xa2, 0xa0, 0x41, 0xbe, 0x6c, 0x01, 0xd0, 0xe4, 0x80, 0x8d, 0x6d, 0x20, + 0x92, 0x24, 0xe3, 0x31, 0x65, 0x7d, 0x50, 0x9b, 0x3b, 0x3e, 0xaa, 0x80, 0x31, 0xf4, 0x06, 0x59, + 0x72, 0x0f, 0x4a, 0x8e, 0x92, 0xf9, 0x93, 0xa7, 0x21, 0xf3, 0xf9, 0x79, 0x51, 0x4f, 0x5a, 0x4d, + 0x8c, 0x7c, 0xd5, 0x82, 0xb9, 0x90, 0x46, 0x72, 0xa8, 0x98, 0xe4, 0x91, 0x0a, 0xef, 0x98, 0x93, + 0xae, 0x9e, 0xc0, 0x29, 0x24, 0x68, 0xb2, 0x0c, 0x53, 0x74, 0x15, 0x2b, 0xd7, 0xa8, 0xd3, 0xa4, + 0x01, 0x37, 0x47, 0x48, 0x4d, 0x6a, 0x7c, 0x56, 0x0c, 0x9c, 0x9a, 0x15, 0xa3, 0x0c, 0x53, 0x74, + 0x15, 0x2b, 0x9b, 0x6e, 0x10, 0xf8, 0x92, 0x95, 0x52, 0x4e, 0xac, 0x18, 0x38, 0x35, 0x2b, 0x46, + 0x19, 0xa6, 0xe8, 0xda, 0xdf, 0x3a, 0x03, 0x73, 0x6a, 0x21, 0xc5, 0x9a, 0xbd, 0xb0, 0x7e, 0x0d, + 0xd0, 0xec, 0x57, 0x4d, 0x20, 0x26, 0xeb, 0xb2, 0xc6, 0x62, 0xa9, 0x26, 0x15, 0x7b, 0xdd, 0xb8, + 0x6e, 0x02, 0x31, 0x59, 0x97, 0x74, 0xa0, 0x18, 0x46, 0xb4, 0xab, 0xee, 0xc0, 0xc7, 0xbc, 0xa2, + 0x8d, 0xe5, 0x83, 0x61, 0x49, 0x60, 0xe8, 0x51, 0x50, 0xe1, 0x06, 0xdc, 0x28, 0x61, 0xd3, 0x95, + 0x8b, 0x23, 0x9f, 0xf5, 0x99, 0x34, 0x17, 0x8b, 0xd1, 0x48, 0x96, 0x61, 0x8a, 0x7c, 0x86, 0xb2, + 0x5f, 0x3c, 0x45, 0x65, 0xff, 0xd3, 0x50, 0xea, 0x38, 0xf7, 0xeb, 0xbd, 0xa0, 0xf5, 0xe8, 0x87, + 0x0a, 0xe9, 0x55, 0x28, 0xb0, 0xa0, 0xc6, 0x47, 0xbe, 0x64, 0x19, 0x22, 0x67, 0x9a, 0x23, 0xbf, + 0x93, 0xaf, 0xc8, 0xd1, 0x7b, 0xe5, 0x40, 0xe1, 0xd3, 0xa7, 0x7a, 0x97, 0x1e, 0xbb, 0xea, 0xcd, + 0xd4, 0x48, 0xb1, 0x40, 0xb4, 0x1a, 0x59, 0x3e, 0x55, 0x35, 0x72, 0x35, 0x41, 0x0c, 0x53, 0xc4, + 0x39, 0x3f, 0x62, 0xcd, 0x69, 0x7e, 0xe0, 0x54, 0xf9, 0xa9, 0x27, 0x88, 0x61, 0x8a, 0xf8, 0xe0, + 0xf3, 0xe6, 0xcc, 0xe9, 0x9c, 0x37, 0x67, 0x73, 0x38, 0x6f, 0x9e, 0xac, 0x8a, 0x9f, 0x19, 0x57, + 0x15, 0x27, 0xd7, 0x81, 0x34, 0x0f, 0x3d, 0xa7, 0xe3, 0x36, 0xa4, 0xb0, 0xe4, 0xdb, 0xe6, 0x1c, + 0xb7, 0x47, 0x2c, 0x49, 0x41, 0x46, 0xd6, 0xfa, 0x6a, 0x60, 0x46, 0x2b, 0x12, 0x41, 0xa9, 0xab, + 0x34, 0xae, 0xf9, 0x3c, 0x66, 0xbf, 0xd2, 0xc0, 0x84, 0x9b, 0x04, 0x5b, 0x78, 0xaa, 0x04, 0x35, + 0x25, 0xb2, 0x01, 0xe7, 0x3b, 0xae, 0xb7, 0xe5, 0x37, 0xc3, 0x2d, 0x1a, 0x48, 0x6b, 0x4b, 0x9d, + 0x46, 0x8b, 0x0b, 0xbc, 0x6f, 0xf8, 0x09, 0x7a, 0x33, 0x03, 0x8e, 0x99, 0xad, 0xec, 0xff, 0x69, + 0xc1, 0xc2, 0x6a, 0xdb, 0xef, 0x35, 0xef, 0x38, 0x51, 0x63, 0x4f, 0x78, 0x08, 0x90, 0x37, 0xa0, + 0xe4, 0x7a, 0x11, 0x0d, 0x0e, 0x9c, 0xb6, 0xdc, 0x9f, 0x6c, 0x65, 0x3e, 0x5d, 0x97, 0xe5, 0x0f, + 0x8e, 0x2a, 0x73, 0x6b, 0xbd, 0x80, 0x5b, 0xa9, 0x85, 0xb4, 0x42, 0xdd, 0x86, 0x7c, 0xcb, 0x82, + 0xb3, 0xc2, 0xc7, 0x60, 0xcd, 0x89, 0x9c, 0x5b, 0x3d, 0x1a, 0xb8, 0x54, 0x79, 0x19, 0x8c, 0x29, + 0xa8, 0xd2, 0xbc, 0x2a, 0x02, 0x87, 0xb1, 0xa2, 0xbe, 0x99, 0xa6, 0x8c, 0xfd, 0xcc, 0xd8, 0xbf, + 0x52, 0x80, 0xa7, 0x06, 0xe2, 0x22, 0x4b, 0x30, 0xe1, 0x36, 0xe5, 0xa7, 0x83, 0xc4, 0x3b, 0xb1, + 0xde, 0xc4, 0x09, 0xb7, 0x49, 0x96, 0xb9, 0xce, 0x19, 0xd0, 0x30, 0x54, 0x17, 0xce, 0x65, 0xad, + 0x1e, 0xca, 0x52, 0x34, 0x6a, 0x90, 0x0a, 0x14, 0xb9, 0x47, 0xa9, 0x3c, 0x4f, 0x70, 0x2d, 0x96, + 0x3b, 0x6f, 0xa2, 0x28, 0x27, 0xbf, 0x68, 0x01, 0x08, 0x06, 0xd9, 0x69, 0x44, 0xee, 0x92, 0x98, + 0x6f, 0x37, 0x31, 0xcc, 0x82, 0xcb, 0xf8, 0x3f, 0x1a, 0x54, 0xc9, 0x36, 0x4c, 0x31, 0x85, 0xd6, + 0x6f, 0x3e, 0xf2, 0xa6, 0xc8, 0x6f, 0xa2, 0xb6, 0x38, 0x0e, 0x94, 0xb8, 0x58, 0x5f, 0x05, 0x34, + 0xea, 0x05, 0x1e, 0xeb, 0x5a, 0xbe, 0x0d, 0x96, 0x04, 0x17, 0xa8, 0x4b, 0xd1, 0xa8, 0x61, 0xff, + 0x8b, 0x09, 0x38, 0x9f, 0xc5, 0x3a, 0xdb, 0x6d, 0xa6, 0x04, 0xb7, 0xf2, 0x68, 0xfc, 0x33, 0xf9, + 0xf7, 0x8f, 0x74, 0x97, 0xd1, 0xd7, 0x14, 0xd2, 0xa1, 0x4f, 0xd2, 0x25, 0x3f, 0xa3, 0x7b, 0x68, + 0xe2, 0x11, 0x7b, 0x48, 0x63, 0x4e, 0xf5, 0xd2, 0x73, 0x30, 0x19, 0xb2, 0x91, 0x2f, 0x24, 0xaf, + 0x3b, 0xf8, 0x18, 0x71, 0x08, 0xab, 0xd1, 0xf3, 0xdc, 0x48, 0x86, 0x61, 0xe8, 0x1a, 0xb7, 0x3d, + 0x37, 0x42, 0x0e, 0xb1, 0xbf, 0x39, 0x01, 0x4b, 0x83, 0x3f, 0x8a, 0x7c, 0xd3, 0x02, 0x68, 0xb2, + 0xe3, 0x4a, 0xc8, 0x7d, 0x99, 0x85, 0x7b, 0x91, 0x73, 0x5a, 0x7d, 0xb8, 0xa6, 0x28, 0xc5, 0xbe, + 0x66, 0xba, 0x28, 0x44, 0x83, 0x11, 0x72, 0x59, 0x4d, 0x7d, 0x7e, 0x55, 0x23, 0x16, 0x93, 0x6e, + 0xb3, 0xa9, 0x21, 0x68, 0xd4, 0x62, 0xe7, 0x51, 0xcf, 0xe9, 0xd0, 0xb0, 0xeb, 0xe8, 0xa0, 0x16, + 0x7e, 0x1e, 0xbd, 0xa1, 0x0a, 0x31, 0x86, 0xdb, 0x6d, 0x78, 0x7e, 0x08, 0x3e, 0x73, 0x8a, 0x19, + 0xb0, 0xff, 0xbb, 0x05, 0x4f, 0xae, 0xb6, 0x7b, 0x61, 0x44, 0x83, 0xff, 0x6f, 0x5c, 0xf7, 0xfe, + 0x97, 0x05, 0x4f, 0x0f, 0xf8, 0xe6, 0xc7, 0xe0, 0xc1, 0xf7, 0x6e, 0xd2, 0x83, 0xef, 0xf6, 0xb8, + 0x53, 0x3a, 0xf3, 0x3b, 0x06, 0x38, 0xf2, 0x7d, 0xb3, 0x00, 0x67, 0x98, 0xd8, 0x6a, 0xfa, 0xad, + 0x9c, 0x36, 0xce, 0xe7, 0xa1, 0xf8, 0x79, 0xb6, 0x01, 0xa5, 0x27, 0x19, 0xdf, 0x95, 0x50, 0xc0, + 0xc8, 0x97, 0x2d, 0x98, 0xfe, 0xbc, 0xdc, 0x53, 0xc5, 0x59, 0x6e, 0x4c, 0x61, 0x98, 0xf8, 0x86, + 0x65, 0xb9, 0x43, 0x8a, 0x50, 0x04, 0xed, 0x3b, 0xa8, 0xb6, 0x52, 0x45, 0x99, 0xbc, 0x08, 0xd3, + 0xbb, 0x7e, 0xd0, 0xe9, 0xb5, 0x9d, 0x74, 0xfc, 0xdb, 0x55, 0x51, 0x8c, 0x0a, 0xce, 0x16, 0xb9, + 0xd3, 0x75, 0xdf, 0xa6, 0x41, 0x28, 0x3c, 0xd3, 0x13, 0x8b, 0xbc, 0xaa, 0x21, 0x68, 0xd4, 0x5a, + 0xfa, 0x24, 0xcc, 0x9a, 0x8c, 0x8c, 0x14, 0xa2, 0xf0, 0x29, 0x90, 0x0e, 0x81, 0x29, 0xf1, 0x62, + 0x0d, 0x23, 0x5e, 0xec, 0x7f, 0x3f, 0x01, 0x86, 0xa5, 0xe7, 0x31, 0x2c, 0x5b, 0x2f, 0xb1, 0x6c, + 0xc7, 0xb4, 0x52, 0x18, 0x76, 0xab, 0x41, 0x01, 0x5b, 0x07, 0xa9, 0x80, 0xad, 0x1b, 0xb9, 0x51, + 0x3c, 0x39, 0x5e, 0xeb, 0xfb, 0x16, 0x3c, 0x1d, 0x57, 0xee, 0x37, 0xc2, 0x3e, 0x5c, 0x06, 0xbf, + 0x0a, 0x33, 0x4e, 0xdc, 0x4c, 0x2e, 0x12, 0x23, 0x5a, 0x46, 0x83, 0xd0, 0xac, 0x17, 0xc7, 0x19, + 0x14, 0x1e, 0x31, 0xce, 0x60, 0xf2, 0xe4, 0x38, 0x03, 0xfb, 0x47, 0x13, 0xf0, 0x6c, 0xff, 0x97, + 0x29, 0xe9, 0x31, 0x9c, 0x47, 0xc3, 0x6b, 0x30, 0x1b, 0xc9, 0x06, 0xc6, 0x5e, 0xa8, 0x23, 0x77, + 0xb7, 0x0d, 0x18, 0x26, 0x6a, 0xb2, 0x96, 0x0d, 0x21, 0xb7, 0xea, 0x0d, 0xbf, 0xab, 0xa2, 0x54, + 0x74, 0xcb, 0x55, 0x03, 0x86, 0x89, 0x9a, 0xda, 0xff, 0x77, 0xf2, 0xd4, 0xfd, 0x7f, 0xeb, 0x70, + 0x41, 0x79, 0x3c, 0x5e, 0xf5, 0x83, 0x55, 0xbf, 0xd3, 0x6d, 0xd3, 0x48, 0x49, 0x83, 0x52, 0xed, + 0x59, 0xd9, 0xe4, 0x02, 0x66, 0x55, 0xc2, 0xec, 0xb6, 0xf6, 0xf7, 0x0b, 0x70, 0x2e, 0xee, 0xf6, + 0x55, 0xdf, 0x6b, 0xba, 0xdc, 0x69, 0xe6, 0x75, 0x98, 0x8c, 0x0e, 0xbb, 0xaa, 0xb3, 0xff, 0xb2, + 0x62, 0x67, 0xfb, 0xb0, 0xcb, 0x46, 0xfb, 0xc9, 0x8c, 0x26, 0xdc, 0x0c, 0xce, 0x1b, 0x91, 0x0d, + 0xbd, 0x3a, 0xc4, 0x08, 0xbc, 0x92, 0x9c, 0xcd, 0x0f, 0x8e, 0x2a, 0x19, 0x81, 0xeb, 0xcb, 0x1a, + 0x53, 0x72, 0xce, 0x93, 0xbb, 0x30, 0xd7, 0x76, 0xc2, 0xe8, 0x76, 0xb7, 0xe9, 0x44, 0x74, 0xdb, + 0x95, 0xee, 0x28, 0xa3, 0x05, 0x7f, 0xe8, 0x7b, 0xfb, 0x8d, 0x04, 0x26, 0x4c, 0x61, 0x26, 0x07, + 0x40, 0x58, 0xc9, 0x76, 0xe0, 0x78, 0xa1, 0xf8, 0x2a, 0x46, 0x6f, 0xf4, 0x60, 0x13, 0x7d, 0x0c, + 0xde, 0xe8, 0xc3, 0x86, 0x19, 0x14, 0xc8, 0x0b, 0x30, 0x15, 0x50, 0x27, 0xd4, 0xa2, 0x5d, 0xaf, + 0x7f, 0xe4, 0xa5, 0x28, 0xa1, 0xe6, 0x82, 0x9a, 0x7a, 0xc8, 0x82, 0xfa, 0x13, 0x0b, 0xe6, 0xe2, + 0x61, 0x7a, 0x0c, 0x6a, 0x44, 0x27, 0xa9, 0x46, 0x5c, 0xcb, 0x4b, 0x24, 0x0e, 0xd0, 0x1c, 0x7e, + 0x7f, 0xca, 0xfc, 0x3e, 0xee, 0xfc, 0xff, 0x05, 0x28, 0xab, 0x55, 0xad, 0xf4, 0xf3, 0x31, 0xad, + 0x09, 0x09, 0xcd, 0xcd, 0x08, 0x5a, 0x93, 0x44, 0x30, 0xa6, 0xc7, 0xf4, 0x96, 0xa6, 0xd4, 0x49, + 0xe4, 0xb4, 0xd7, 0x7a, 0x8b, 0xd2, 0x55, 0xb2, 0xf4, 0x16, 0xd5, 0x86, 0xdc, 0x86, 0x27, 0xbb, + 0x81, 0xcf, 0x43, 0xa7, 0xd7, 0xa8, 0xd3, 0x6c, 0xbb, 0x1e, 0x55, 0x26, 0x1b, 0xe1, 0x36, 0xf2, + 0xf4, 0xf1, 0x51, 0xe5, 0xc9, 0xad, 0xec, 0x2a, 0x38, 0xa8, 0x6d, 0x32, 0xf8, 0x6e, 0x72, 0x88, + 0xe0, 0xbb, 0xbf, 0xa5, 0x0d, 0xa3, 0x34, 0x94, 0x21, 0x70, 0x9f, 0xc9, 0x6b, 0x28, 0x33, 0xc4, + 0x7a, 0x3c, 0xa5, 0xaa, 0x92, 0x28, 0x6a, 0xf2, 0x83, 0xad, 0x6f, 0x53, 0x8f, 0x68, 0x7d, 0x8b, + 0x63, 0x28, 0xa6, 0x7f, 0x9c, 0x31, 0x14, 0xa5, 0x9f, 0xa8, 0x18, 0x8a, 0x0f, 0x8a, 0xb0, 0x90, + 0xd6, 0x40, 0x4e, 0x3f, 0xb0, 0xf0, 0xef, 0x58, 0xb0, 0xa0, 0x56, 0x8f, 0xa0, 0xa9, 0x75, 0xf1, + 0x8d, 0x9c, 0x16, 0xad, 0xd0, 0xa5, 0x74, 0xc6, 0x85, 0xed, 0x14, 0x35, 0xec, 0xa3, 0x4f, 0xde, + 0x81, 0x19, 0x7d, 0xfd, 0xf0, 0x48, 0x51, 0x86, 0xf3, 0x5c, 0x8b, 0x8a, 0x51, 0xa0, 0x89, 0x8f, + 0x7c, 0x60, 0x01, 0x34, 0xd4, 0x36, 0xa7, 0x56, 0xd7, 0xad, 0xbc, 0x56, 0x97, 0xde, 0x40, 0x63, + 0x65, 0x59, 0x17, 0x85, 0x68, 0x10, 0x26, 0xbf, 0xc2, 0x2f, 0x1e, 0xb4, 0x76, 0x27, 0x32, 0x39, + 0x8c, 0xed, 0x1f, 0x7e, 0x82, 0x62, 0x1a, 0xab, 0x52, 0x06, 0x28, 0xc4, 0x04, 0x13, 0xf6, 0xeb, + 0xa0, 0x3d, 0x7a, 0x99, 0xd8, 0xe2, 0x3e, 0xbd, 0x5b, 0x4e, 0xb4, 0x27, 0xa7, 0xa0, 0x16, 0x5b, + 0x57, 0x15, 0x00, 0xe3, 0x3a, 0xf6, 0xe7, 0x60, 0xee, 0xcd, 0xc0, 0xe9, 0xee, 0xb9, 0xdc, 0xc0, + 0xcf, 0x0e, 0x92, 0x2f, 0xc2, 0xb4, 0xd3, 0x6c, 0x66, 0x25, 0x07, 0xa9, 0x8a, 0x62, 0x54, 0xf0, + 0xa1, 0xce, 0x8c, 0xf6, 0xef, 0x59, 0x40, 0xe2, 0x4b, 0x52, 0xd7, 0x6b, 0x6d, 0x3a, 0x51, 0x63, + 0x8f, 0x9d, 0x8f, 0xf6, 0x78, 0x69, 0xd6, 0xf9, 0xe8, 0x9a, 0x86, 0xa0, 0x51, 0x8b, 0xbc, 0x07, + 0x33, 0xe2, 0xdf, 0xdb, 0xfa, 0xf4, 0x35, 0xbe, 0x63, 0x32, 0xdf, 0x50, 0x38, 0x4f, 0x62, 0x16, + 0x5e, 0x8b, 0x29, 0xa0, 0x49, 0x8e, 0x75, 0xd5, 0xba, 0xb7, 0xdb, 0xee, 0xdd, 0x6f, 0xee, 0xc4, + 0x5d, 0xd5, 0x0d, 0xfc, 0x5d, 0xb7, 0x4d, 0xd3, 0x5d, 0xb5, 0x25, 0x8a, 0x51, 0xc1, 0x87, 0xeb, + 0xaa, 0x7f, 0x6d, 0xc1, 0xf9, 0xf5, 0x30, 0x72, 0xfd, 0x35, 0x1a, 0x46, 0x6c, 0x5b, 0x61, 0xc2, + 0xa7, 0xd7, 0x1e, 0xc6, 0x39, 0x7f, 0x0d, 0x16, 0xe4, 0x85, 0x6d, 0x6f, 0x27, 0xa4, 0x91, 0xa1, + 0xc7, 0xeb, 0x75, 0xbc, 0x9a, 0x82, 0x63, 0x5f, 0x0b, 0x86, 0x45, 0xde, 0xdc, 0xc6, 0x58, 0x0a, + 0x49, 0x2c, 0xf5, 0x14, 0x1c, 0xfb, 0x5a, 0xd8, 0xdf, 0x2b, 0xc0, 0x39, 0xfe, 0x19, 0xa9, 0xc0, + 0x9a, 0xaf, 0x0f, 0x0a, 0xac, 0x19, 0x73, 0x29, 0x73, 0x5a, 0x8f, 0x10, 0x56, 0xf3, 0xb7, 0x2d, + 0x98, 0x6f, 0x26, 0x7b, 0x3a, 0x1f, 0x03, 0x56, 0xd6, 0x18, 0x0a, 0xff, 0xb4, 0x54, 0x21, 0xa6, + 0xe9, 0x93, 0x5f, 0xb5, 0x60, 0x3e, 0xc9, 0xa6, 0x92, 0xee, 0xa7, 0xd0, 0x49, 0xda, 0xa1, 0x3c, + 0x59, 0x1e, 0x62, 0x9a, 0x05, 0xfb, 0x0f, 0x26, 0xe4, 0x90, 0x9e, 0x46, 0xd4, 0x08, 0xb9, 0x07, + 0xe5, 0xa8, 0x1d, 0x8a, 0x42, 0xf9, 0xb5, 0x63, 0x9e, 0x08, 0xb7, 0x37, 0xea, 0xc2, 0x57, 0x22, + 0x56, 0xda, 0x64, 0x09, 0x53, 0x3e, 0x15, 0x2d, 0x4e, 0xb8, 0xd1, 0x95, 0x84, 0x73, 0x39, 0x8a, + 0x6e, 0xaf, 0x6e, 0xa5, 0x09, 0xcb, 0x12, 0x46, 0x58, 0xd1, 0xb2, 0x7f, 0xd3, 0x82, 0xf2, 0x75, + 0x5f, 0xc9, 0x91, 0x9f, 0xcb, 0xc1, 0xd0, 0xa3, 0xf5, 0x41, 0x7d, 0x27, 0x1b, 0x1f, 0x31, 0xde, + 0x48, 0x98, 0x79, 0x9e, 0x31, 0x70, 0x2f, 0xf3, 0x1c, 0x69, 0x0c, 0xd5, 0x75, 0x7f, 0x67, 0xa0, + 0x9d, 0xf5, 0xd7, 0x8a, 0x70, 0xe6, 0x2d, 0xe7, 0x90, 0x7a, 0x91, 0x33, 0xfa, 0x26, 0xf1, 0x2a, + 0xcc, 0x38, 0x5d, 0x7e, 0xe9, 0x67, 0xe8, 0xf8, 0xb1, 0xe5, 0x24, 0x06, 0xa1, 0x59, 0x2f, 0x16, + 0x68, 0x22, 0x84, 0x23, 0x4b, 0x14, 0xad, 0xa6, 0xe0, 0xd8, 0xd7, 0x82, 0x5c, 0x07, 0x22, 0x23, + 0x8e, 0xab, 0x8d, 0x86, 0xdf, 0xf3, 0x84, 0x48, 0x13, 0x46, 0x15, 0x7d, 0xd8, 0xdc, 0xec, 0xab, + 0x81, 0x19, 0xad, 0xc8, 0x67, 0x61, 0xb1, 0xc1, 0x31, 0xcb, 0xa3, 0x87, 0x89, 0x51, 0x1c, 0x3f, + 0x75, 0x50, 0xc4, 0xea, 0x80, 0x7a, 0x38, 0x10, 0x03, 0xe3, 0x34, 0x8c, 0xfc, 0xc0, 0x69, 0x51, + 0x13, 0xef, 0x54, 0x92, 0xd3, 0x7a, 0x5f, 0x0d, 0xcc, 0x68, 0x45, 0xbe, 0x08, 0xe5, 0x68, 0x2f, + 0xa0, 0xe1, 0x9e, 0xdf, 0x6e, 0x4a, 0x27, 0x8d, 0x31, 0x2d, 0x6d, 0x72, 0xf4, 0xb7, 0x15, 0x56, + 0x63, 0x7a, 0xab, 0x22, 0x8c, 0x69, 0x92, 0x00, 0xa6, 0xc2, 0x86, 0xdf, 0xa5, 0xa1, 0x54, 0xd9, + 0xaf, 0xe7, 0x42, 0x9d, 0x5b, 0x8e, 0x0c, 0x1b, 0x1f, 0xa7, 0x80, 0x92, 0x92, 0xfd, 0xbb, 0x13, + 0x30, 0x6b, 0x56, 0x1c, 0x42, 0x36, 0x7d, 0xd9, 0x82, 0xd9, 0x86, 0xef, 0x45, 0x81, 0xdf, 0x16, + 0xf6, 0xab, 0x7c, 0x34, 0x0a, 0x86, 0x6a, 0x8d, 0x46, 0x8e, 0xdb, 0x36, 0x4c, 0x61, 0x06, 0x19, + 0x4c, 0x10, 0x25, 0x5f, 0xb3, 0x60, 0x3e, 0xf6, 0xe9, 0x8b, 0x0d, 0x69, 0xb9, 0x32, 0xa2, 0x45, + 0xfd, 0x95, 0x24, 0x25, 0x4c, 0x93, 0xb6, 0x77, 0x60, 0x21, 0x3d, 0xda, 0xac, 0x2b, 0xbb, 0x8e, + 0x5c, 0xeb, 0x85, 0xb8, 0x2b, 0xb7, 0x9c, 0x30, 0x44, 0x0e, 0x21, 0x2f, 0x41, 0xa9, 0xe3, 0x04, + 0x2d, 0xd7, 0x73, 0xda, 0xbc, 0x17, 0x0b, 0x86, 0x40, 0x92, 0xe5, 0xa8, 0x6b, 0xd8, 0x1f, 0x83, + 0xd9, 0x4d, 0xc7, 0x6b, 0xd1, 0xa6, 0x94, 0xc3, 0x0f, 0x8f, 0x5b, 0xfc, 0xb3, 0x49, 0x98, 0x31, + 0xce, 0x66, 0xa7, 0x7f, 0xce, 0x4a, 0xa4, 0x4d, 0x29, 0xe4, 0x98, 0x36, 0xe5, 0xd3, 0x00, 0xbb, + 0xae, 0xe7, 0x86, 0x7b, 0x8f, 0x98, 0x90, 0x85, 0x5f, 0x62, 0x5f, 0xd5, 0x18, 0xd0, 0xc0, 0x16, + 0xdf, 0x14, 0x16, 0x4f, 0xc8, 0x2e, 0xf6, 0x81, 0x65, 0x6c, 0x37, 0x53, 0x79, 0x78, 0x46, 0x18, + 0x03, 0xb3, 0xac, 0xb6, 0x1f, 0x71, 0x89, 0x73, 0xd2, 0xae, 0xb4, 0x0d, 0xa5, 0x80, 0x86, 0xbd, + 0x0e, 0x3b, 0x31, 0x4e, 0x8f, 0xdc, 0x0d, 0xdc, 0x47, 0x05, 0x65, 0x7b, 0xd4, 0x98, 0x96, 0x5e, + 0x87, 0x33, 0x09, 0x16, 0x46, 0xba, 0xbe, 0xf1, 0x21, 0xd3, 0x00, 0xf0, 0x28, 0x97, 0x39, 0x6c, + 0x2c, 0xda, 0x46, 0x46, 0x16, 0x3d, 0x16, 0xc2, 0x13, 0x49, 0xc0, 0xec, 0x1f, 0x4d, 0x81, 0xbc, + 0xec, 0x1f, 0x42, 0x5c, 0x99, 0x57, 0x7c, 0x13, 0x8f, 0x70, 0xc5, 0x77, 0x1d, 0x66, 0x5d, 0xcf, + 0x8d, 0x5c, 0xa7, 0xcd, 0x8d, 0x3b, 0x72, 0x3b, 0x55, 0xae, 0xda, 0xb3, 0xeb, 0x06, 0x2c, 0x03, + 0x4f, 0xa2, 0x2d, 0xb9, 0x05, 0x45, 0xbe, 0xdf, 0xc8, 0x09, 0x3c, 0xba, 0x47, 0x02, 0x77, 0x46, + 0x11, 0xf1, 0x5b, 0x02, 0x13, 0x3f, 0x7c, 0x88, 0x94, 0x34, 0xfa, 0xf8, 0x2d, 0xe7, 0x71, 0x7c, + 0xf8, 0x48, 0xc1, 0xb1, 0xaf, 0x05, 0xc3, 0xb2, 0xeb, 0xb8, 0xed, 0x5e, 0x40, 0x63, 0x2c, 0x53, + 0x49, 0x2c, 0x57, 0x53, 0x70, 0xec, 0x6b, 0x41, 0x76, 0x61, 0x56, 0x96, 0x09, 0xff, 0xb2, 0xe9, + 0x47, 0xfc, 0x4a, 0xee, 0x47, 0x78, 0xd5, 0xc0, 0x84, 0x09, 0xbc, 0xa4, 0x07, 0x67, 0x5d, 0xaf, + 0xe1, 0x7b, 0x8d, 0x76, 0x2f, 0x74, 0x0f, 0x68, 0x1c, 0x3c, 0xf5, 0x28, 0xc4, 0x2e, 0x1c, 0x1f, + 0x55, 0xce, 0xae, 0xa7, 0xd1, 0x61, 0x3f, 0x05, 0xf2, 0x25, 0x0b, 0x2e, 0x34, 0x7c, 0x2f, 0xe4, + 0x39, 0x1e, 0x0e, 0xe8, 0x95, 0x20, 0xf0, 0x03, 0x41, 0xbb, 0xfc, 0x88, 0xb4, 0xb9, 0x4d, 0x71, + 0x35, 0x0b, 0x25, 0x66, 0x53, 0x22, 0xef, 0x42, 0xa9, 0x1b, 0xf8, 0x07, 0x6e, 0x93, 0x06, 0xd2, + 0x57, 0x71, 0x23, 0x8f, 0x9c, 0x33, 0x5b, 0x12, 0x67, 0x2c, 0x7a, 0x54, 0x09, 0x6a, 0x7a, 0xf6, + 0xff, 0x9e, 0x81, 0xb9, 0x64, 0x75, 0xf2, 0x0b, 0x00, 0xdd, 0xc0, 0xef, 0xd0, 0x68, 0x8f, 0xea, + 0x20, 0x98, 0x1b, 0xe3, 0xa6, 0x36, 0x51, 0xf8, 0x94, 0x7f, 0x0f, 0x13, 0x17, 0x71, 0x29, 0x1a, + 0x14, 0x49, 0x00, 0xd3, 0xfb, 0x62, 0xdb, 0x95, 0x5a, 0xc8, 0x5b, 0xb9, 0xe8, 0x4c, 0x92, 0x32, + 0x8f, 0xde, 0x90, 0x45, 0xa8, 0x08, 0x91, 0x1d, 0x28, 0xdc, 0xa3, 0x3b, 0xf9, 0xc4, 0xd5, 0xdf, + 0xa1, 0xf2, 0x34, 0x53, 0x9b, 0x3e, 0x3e, 0xaa, 0x14, 0xee, 0xd0, 0x1d, 0x64, 0xc8, 0xd9, 0x77, + 0x35, 0xc5, 0x25, 0xbf, 0x14, 0x15, 0x6f, 0xe5, 0xe8, 0x31, 0x20, 0xbe, 0x4b, 0x16, 0xa1, 0x22, + 0x44, 0xde, 0x85, 0xf2, 0x3d, 0xe7, 0x80, 0xee, 0x06, 0xbe, 0x17, 0x49, 0xa7, 0xb2, 0x31, 0xe3, + 0x22, 0xee, 0x28, 0x74, 0x92, 0x2e, 0xdf, 0xde, 0x75, 0x21, 0xc6, 0xe4, 0xc8, 0x01, 0x94, 0x3c, + 0x7a, 0x0f, 0x69, 0xdb, 0x6d, 0xe4, 0x13, 0x87, 0x70, 0x43, 0x62, 0x93, 0x94, 0xf9, 0xbe, 0xa7, + 0xca, 0x50, 0xd3, 0x62, 0x63, 0x79, 0xd7, 0xdf, 0x91, 0x82, 0x6a, 0xcc, 0xb1, 0xd4, 0x27, 0x53, + 0x31, 0x96, 0xd7, 0xfd, 0x1d, 0x64, 0xc8, 0xd9, 0x1a, 0x69, 0x68, 0x8f, 0x26, 0x29, 0xa6, 0x6e, + 0xe4, 0xeb, 0xc9, 0x25, 0xd6, 0x48, 0x5c, 0x8a, 0x06, 0x45, 0xd6, 0xb7, 0x2d, 0x69, 0xac, 0x94, + 0x82, 0x6a, 0xcc, 0xbe, 0x4d, 0x9a, 0x3e, 0x45, 0xdf, 0xaa, 0x32, 0xd4, 0xb4, 0x18, 0x5d, 0x57, + 0x5a, 0xfe, 0xf2, 0x11, 0x55, 0x49, 0x3b, 0xa2, 0xa0, 0xab, 0xca, 0x50, 0xd3, 0x62, 0xfd, 0x1d, + 0xee, 0x1f, 0xde, 0x73, 0xda, 0xfb, 0xae, 0xd7, 0x92, 0x41, 0x9d, 0xe3, 0x66, 0x30, 0xde, 0x3f, + 0xbc, 0x23, 0xf0, 0x99, 0xfd, 0x1d, 0x97, 0xa2, 0x41, 0x91, 0xfc, 0x03, 0x0b, 0xa6, 0xba, 0xed, + 0x5e, 0xcb, 0xf5, 0x16, 0x67, 0xf3, 0xf0, 0xf6, 0x49, 0x8a, 0xdc, 0xe5, 0x2d, 0x8e, 0x5a, 0x28, + 0x8a, 0x3f, 0xad, 0x1d, 0x14, 0x79, 0xe1, 0x2f, 0xfd, 0x69, 0x65, 0x91, 0x7a, 0x0d, 0xbf, 0xe9, + 0x7a, 0xad, 0x95, 0xbb, 0xa1, 0xef, 0x2d, 0xa3, 0x73, 0x4f, 0xe9, 0xe8, 0x92, 0xa7, 0xa5, 0x4f, + 0xc0, 0x8c, 0x81, 0xe2, 0x61, 0x8a, 0xde, 0xac, 0xa9, 0xe8, 0xfd, 0xe6, 0x14, 0xcc, 0x9a, 0x59, + 0x13, 0x87, 0xd0, 0xbe, 0xf4, 0x89, 0x63, 0x62, 0x94, 0x13, 0x07, 0x3b, 0x62, 0x1a, 0xb7, 0x47, + 0xca, 0xbc, 0xb5, 0x9e, 0x9b, 0xc2, 0x1d, 0x1f, 0x31, 0x8d, 0xc2, 0x10, 0x13, 0x44, 0x47, 0x70, + 0x28, 0x61, 0x6a, 0xab, 0x50, 0xec, 0x8a, 0x49, 0xb5, 0x35, 0xa1, 0xaa, 0x5d, 0x06, 0x88, 0xb3, + 0x07, 0xca, 0x5b, 0x45, 0xad, 0x0f, 0x1b, 0x59, 0x0d, 0x8d, 0x5a, 0xe4, 0x05, 0x98, 0x62, 0xaa, + 0x0f, 0x6d, 0xca, 0x98, 0x73, 0x7d, 0x8e, 0xbf, 0xca, 0x4b, 0x51, 0x42, 0xc9, 0x6b, 0x4c, 0x4b, + 0x8d, 0x15, 0x16, 0x19, 0x4a, 0x7e, 0x3e, 0xd6, 0x52, 0x63, 0x18, 0x26, 0x6a, 0x32, 0xd6, 0x29, + 0xd3, 0x2f, 0xb8, 0x6c, 0x30, 0x58, 0xe7, 0x4a, 0x07, 0x0a, 0x18, 0xb7, 0x2b, 0xa5, 0xf4, 0x11, + 0xbe, 0xa6, 0x8b, 0x86, 0x5d, 0x29, 0x05, 0xc7, 0xbe, 0x16, 0xec, 0x63, 0xe4, 0x85, 0xe8, 0x8c, + 0xf0, 0x2c, 0x1e, 0x70, 0x95, 0xf9, 0x15, 0xf3, 0xac, 0x95, 0xe3, 0x1a, 0x12, 0xb3, 0x76, 0xf8, + 0xc3, 0xd6, 0x78, 0xc7, 0xa2, 0xcf, 0xc1, 0x5c, 0x72, 0x17, 0xca, 0xfd, 0xe6, 0xe3, 0xab, 0x93, + 0x70, 0xee, 0x46, 0xcb, 0xf5, 0xd2, 0x19, 0xc1, 0xb2, 0x12, 0xc2, 0x5b, 0x23, 0x27, 0x84, 0xd7, + 0xc1, 0x6b, 0x32, 0xdd, 0x7a, 0x76, 0xf0, 0x9a, 0xca, 0x7d, 0x9f, 0xac, 0x4b, 0xfe, 0xc4, 0x82, + 0x67, 0x9c, 0xa6, 0x38, 0x17, 0x38, 0x6d, 0x59, 0x6a, 0xe4, 0x31, 0x96, 0x2b, 0x3a, 0x1c, 0x73, + 0x97, 0xef, 0xff, 0xf8, 0xe5, 0xea, 0x09, 0x54, 0xc5, 0x88, 0xff, 0x94, 0xfc, 0x82, 0x67, 0x4e, + 0xaa, 0x8a, 0x27, 0xb2, 0x4f, 0xfe, 0x1a, 0xcc, 0x27, 0x3e, 0x58, 0x5a, 0xc2, 0xcb, 0xe2, 0xc2, + 0xa2, 0x9e, 0x04, 0x61, 0xba, 0xee, 0xd2, 0x4d, 0xf8, 0xf0, 0x43, 0xf9, 0x1c, 0x69, 0xb2, 0x7d, + 0xd7, 0x82, 0x59, 0x33, 0x79, 0x0f, 0x79, 0x09, 0x4a, 0x91, 0xbf, 0x4f, 0xbd, 0xdb, 0x81, 0xf2, + 0x6c, 0xd5, 0x13, 0x7d, 0x9b, 0x97, 0xe3, 0x06, 0xea, 0x1a, 0xac, 0x76, 0xa3, 0xed, 0x52, 0x2f, + 0x5a, 0x6f, 0xca, 0x61, 0xd6, 0xb5, 0x57, 0x45, 0xf9, 0x1a, 0xea, 0x1a, 0xc2, 0x81, 0x8d, 0xfd, + 0xae, 0xd3, 0x46, 0x40, 0x95, 0x1f, 0xbc, 0xe1, 0xc0, 0x16, 0xc3, 0x30, 0x51, 0x93, 0xd8, 0xda, + 0xc4, 0x39, 0x19, 0xdf, 0x6b, 0xa4, 0x4c, 0x92, 0x5f, 0xb6, 0xa0, 0x2c, 0x4c, 0xf4, 0x48, 0x77, + 0x53, 0xbe, 0xa8, 0x29, 0x23, 0x42, 0x75, 0x6b, 0x3d, 0xc3, 0x17, 0x95, 0x6d, 0x4b, 0xfb, 0xae, + 0xa7, 0xbe, 0x44, 0x6f, 0x4b, 0x6f, 0xb9, 0x5e, 0x13, 0x39, 0x44, 0x6f, 0x5c, 0x85, 0x81, 0xa6, + 0xb3, 0x5f, 0xb7, 0x60, 0x8e, 0xc7, 0x2e, 0xc7, 0xc7, 0xdb, 0x57, 0xb5, 0xdf, 0x94, 0x60, 0xe3, + 0xd9, 0xa4, 0xdf, 0xd4, 0x83, 0xa3, 0xca, 0x8c, 0x88, 0x76, 0x4e, 0xba, 0x51, 0x7d, 0x46, 0xda, + 0xc4, 0xb8, 0x77, 0xd7, 0xc4, 0xc8, 0x26, 0x1b, 0x6d, 0x33, 0xae, 0x2b, 0x24, 0x18, 0xe3, 0xb3, + 0xdf, 0x83, 0x59, 0x33, 0x08, 0x89, 0xbc, 0x0a, 0x33, 0x5d, 0xd7, 0x6b, 0x25, 0x83, 0x55, 0xf5, + 0xbd, 0xc1, 0x56, 0x0c, 0x42, 0xb3, 0x1e, 0x6f, 0xe6, 0xc7, 0xcd, 0x52, 0xd7, 0x0d, 0x5b, 0xbe, + 0xd9, 0x2c, 0xfe, 0xc3, 0x53, 0xc2, 0x67, 0x04, 0xbb, 0xe5, 0x9e, 0x12, 0x3e, 0x83, 0xc6, 0x8f, + 0x2f, 0x25, 0x7c, 0x16, 0x33, 0xff, 0x77, 0xa5, 0x84, 0xff, 0x59, 0x18, 0x35, 0x17, 0x28, 0xdb, + 0xba, 0xef, 0x99, 0x09, 0x05, 0x74, 0x8f, 0xcb, 0x8c, 0x02, 0x12, 0x6a, 0x7f, 0xa7, 0x00, 0x0b, + 0xe9, 0x13, 0x7c, 0xde, 0xce, 0x11, 0xe4, 0x6b, 0x16, 0xcc, 0x39, 0x89, 0xbc, 0x6b, 0x39, 0xbd, + 0x2f, 0x93, 0xc0, 0x69, 0xe4, 0xfd, 0x4a, 0x94, 0x63, 0x8a, 0x36, 0xf9, 0x4b, 0x30, 0x1d, 0xb9, + 0x1d, 0xea, 0xf7, 0x84, 0x5d, 0xaf, 0x20, 0xce, 0xd7, 0xdb, 0xa2, 0x08, 0x15, 0x8c, 0xc9, 0x58, + 0x97, 0x2b, 0x44, 0x01, 0x95, 0x5e, 0xb4, 0x0b, 0xb1, 0x21, 0x52, 0x94, 0xa3, 0xae, 0x41, 0xee, + 0xc3, 0xb4, 0x70, 0xa3, 0x50, 0xfe, 0x32, 0x9b, 0x39, 0x59, 0x1a, 0x84, 0xa7, 0x46, 0x3c, 0x04, + 0xe2, 0x7f, 0x88, 0x8a, 0x9c, 0xfd, 0x31, 0x18, 0x31, 0x39, 0xaa, 0x7d, 0x05, 0x08, 0xfa, 0xed, + 0xf6, 0x8e, 0xd3, 0xd8, 0xbf, 0xe3, 0x7a, 0x4d, 0xff, 0x1e, 0x17, 0x45, 0x2b, 0x50, 0x0e, 0x64, + 0xa8, 0x68, 0x28, 0x67, 0x8d, 0x96, 0x65, 0x2a, 0x86, 0x34, 0xc4, 0xb8, 0x8e, 0xfd, 0x07, 0x13, + 0x30, 0x2d, 0xe3, 0x9a, 0x1f, 0x83, 0x17, 0xff, 0x7e, 0xe2, 0x7a, 0x77, 0x3d, 0x97, 0x70, 0xec, + 0x81, 0x2e, 0xfc, 0x61, 0xca, 0x85, 0xff, 0xad, 0x7c, 0xc8, 0x9d, 0xec, 0xbf, 0xff, 0xfb, 0x45, + 0x98, 0x4f, 0xc5, 0x89, 0x33, 0xd5, 0xba, 0xcf, 0x6d, 0xf5, 0x76, 0xae, 0xa1, 0xe8, 0x3a, 0x06, + 0xe7, 0x64, 0x0f, 0xd6, 0x30, 0x91, 0xca, 0xfa, 0x56, 0x6e, 0xaf, 0x74, 0xfc, 0x45, 0x56, 0xeb, + 0x11, 0x3d, 0x32, 0xc9, 0xb7, 0x2c, 0x38, 0xe7, 0xf4, 0x3f, 0x73, 0x22, 0x4d, 0x80, 0xb7, 0x72, + 0x7f, 0x3f, 0xa5, 0xf6, 0xb4, 0x64, 0x32, 0xeb, 0x35, 0x19, 0xcc, 0x62, 0xc5, 0xfe, 0x4f, 0x16, + 0x3c, 0x35, 0x30, 0xe3, 0x01, 0x4f, 0x98, 0x15, 0x24, 0xa1, 0x52, 0x66, 0xe4, 0x9c, 0xd7, 0x45, + 0x5f, 0x07, 0xa7, 0x73, 0x1c, 0xa5, 0xc9, 0x93, 0x57, 0x60, 0x96, 0xeb, 0x68, 0x4c, 0x7a, 0x46, + 0xb4, 0x2b, 0x6f, 0xb3, 0xf8, 0xbd, 0x46, 0xdd, 0x28, 0xc7, 0x44, 0x2d, 0xfb, 0x5b, 0x16, 0x2c, + 0x0e, 0x4a, 0x9f, 0x34, 0x84, 0xad, 0xe5, 0xaf, 0xa6, 0x22, 0x21, 0x2a, 0x7d, 0x91, 0x10, 0x29, + 0x6b, 0x8b, 0x0a, 0x7a, 0x30, 0x0c, 0x1d, 0x85, 0x87, 0x38, 0xfa, 0x7f, 0xdd, 0x82, 0x27, 0x07, + 0x2c, 0xf8, 0xbe, 0x88, 0x18, 0xeb, 0x91, 0x23, 0x62, 0x26, 0x86, 0x8d, 0x88, 0xb1, 0xff, 0xb0, + 0x00, 0x0b, 0x92, 0x9f, 0x58, 0x51, 0x7f, 0x2d, 0x11, 0x4f, 0xf2, 0x53, 0xa9, 0x78, 0x92, 0xf3, + 0xe9, 0xfa, 0x7f, 0x11, 0x4c, 0xf2, 0x93, 0x15, 0x4c, 0xf2, 0xe7, 0x13, 0x70, 0x21, 0x33, 0xab, + 0x13, 0xf9, 0x6a, 0xc6, 0xee, 0x75, 0x27, 0xe7, 0xf4, 0x51, 0x43, 0xee, 0x5f, 0xe3, 0x46, 0x60, + 0xfc, 0xaa, 0x19, 0xf9, 0x20, 0x76, 0xa3, 0xdd, 0x53, 0x48, 0x84, 0x35, 0x62, 0x10, 0x84, 0xfd, + 0x4b, 0x05, 0xb8, 0x34, 0x2c, 0xa2, 0x9f, 0xd0, 0x20, 0xb9, 0x30, 0x11, 0x24, 0xf7, 0x98, 0x34, + 0x8b, 0x53, 0x89, 0x97, 0xfb, 0x47, 0x93, 0x7a, 0xdb, 0xeb, 0x9f, 0x9f, 0x43, 0xb9, 0x3e, 0x4c, + 0x33, 0xed, 0x53, 0x25, 0xc4, 0x8e, 0x45, 0xe1, 0x74, 0x5d, 0x14, 0x3f, 0x38, 0xaa, 0x9c, 0x8d, + 0x73, 0x8b, 0xc8, 0x42, 0x54, 0x8d, 0xc8, 0x25, 0x28, 0x05, 0x02, 0xaa, 0xc2, 0x82, 0xa4, 0xff, + 0x88, 0x28, 0x43, 0x0d, 0x25, 0x5f, 0x34, 0xd4, 0xf5, 0xc9, 0xd3, 0x4a, 0xa1, 0x73, 0x92, 0x5b, + 0xcc, 0x3b, 0x50, 0x0a, 0x55, 0xd6, 0x66, 0xa1, 0xb8, 0xbc, 0x3c, 0x64, 0xb4, 0x19, 0x3b, 0x83, + 0xab, 0x14, 0xce, 0xe2, 0xfb, 0x74, 0x82, 0x67, 0x8d, 0x92, 0xd8, 0xfa, 0xf8, 0x2b, 0xcc, 0xf6, + 0xd0, 0x7f, 0xf4, 0x25, 0x11, 0x4c, 0xcb, 0xc7, 0x3c, 0xe5, 0x7d, 0xe2, 0x66, 0x4e, 0x91, 0x25, + 0xd2, 0xef, 0x98, 0x9f, 0x2a, 0x95, 0x19, 0x46, 0x91, 0xb2, 0xbf, 0x6f, 0xc1, 0x8c, 0x9c, 0x23, + 0x8f, 0x21, 0xec, 0xee, 0x6e, 0x32, 0xec, 0xee, 0x4a, 0x2e, 0x12, 0x6b, 0x40, 0xcc, 0xdd, 0x5d, + 0x98, 0x35, 0xd3, 0x09, 0x92, 0x4f, 0x1b, 0x12, 0xd7, 0x1a, 0x27, 0x41, 0x97, 0x92, 0xc9, 0xb1, + 0x34, 0xb6, 0x7f, 0xab, 0xac, 0x7b, 0x91, 0x9f, 0x5d, 0xcd, 0x99, 0x6f, 0x9d, 0x38, 0xf3, 0xcd, + 0x89, 0x37, 0x91, 0xff, 0xc4, 0xbb, 0x05, 0x25, 0x25, 0x16, 0xa5, 0xf2, 0xf0, 0xbc, 0xe9, 0x88, + 0xcc, 0x34, 0x10, 0x86, 0xcc, 0x58, 0x2e, 0xfc, 0x0c, 0x1a, 0xdb, 0x7a, 0x95, 0xb8, 0xd6, 0x68, + 0xc8, 0xbb, 0x30, 0x73, 0xcf, 0x0f, 0xf6, 0xdb, 0xbe, 0xc3, 0x53, 0xe5, 0x43, 0x1e, 0x77, 0xdf, + 0xda, 0x5e, 0x2b, 0xa2, 0x41, 0xee, 0xc4, 0xf8, 0xd1, 0x24, 0x46, 0xaa, 0x30, 0xdf, 0x71, 0x3d, + 0xa4, 0x4e, 0x53, 0x47, 0xd7, 0x4d, 0x8a, 0x34, 0xd5, 0x4a, 0xb5, 0xde, 0x4c, 0x82, 0x31, 0x5d, + 0x9f, 0x1b, 0x7f, 0x82, 0x84, 0xb5, 0x41, 0xe6, 0xa2, 0xdd, 0x1a, 0x7f, 0x32, 0x26, 0x2d, 0x18, + 0x22, 0x1c, 0x22, 0x59, 0x8e, 0x29, 0xda, 0xe4, 0x0b, 0x50, 0x0a, 0x65, 0xae, 0xc0, 0x7c, 0x9c, + 0x26, 0xf4, 0xd9, 0x5e, 0x20, 0x8d, 0x87, 0x52, 0x95, 0xa0, 0x26, 0x48, 0x36, 0xe0, 0xbc, 0x32, + 0x9f, 0x24, 0x9e, 0x33, 0x9b, 0x8a, 0x53, 0x4b, 0x61, 0x06, 0x1c, 0x33, 0x5b, 0x31, 0x55, 0x8e, + 0xa7, 0xe9, 0x14, 0x77, 0x8d, 0xc6, 0xf5, 0x1c, 0x5f, 0x7f, 0x4d, 0x94, 0xd0, 0x93, 0x82, 0x47, + 0x4b, 0x63, 0x04, 0x8f, 0xd6, 0xe1, 0x42, 0x1a, 0xc4, 0x73, 0x86, 0xf1, 0x34, 0x65, 0xc6, 0x16, + 0xba, 0x95, 0x55, 0x09, 0xb3, 0xdb, 0x92, 0x3b, 0x50, 0x0e, 0x28, 0x3f, 0x64, 0x55, 0x95, 0x9b, + 0xd6, 0xc8, 0x0e, 0xa9, 0xa8, 0x10, 0x60, 0x8c, 0x8b, 0x8d, 0xbb, 0x93, 0x4c, 0x1c, 0x7d, 0x2b, + 0xc7, 0x77, 0x74, 0xe5, 0xd8, 0x0f, 0xc8, 0xe5, 0x67, 0xff, 0x9b, 0x79, 0x38, 0x93, 0xb0, 0x01, + 0x91, 0xe7, 0xa1, 0xc8, 0x93, 0xa8, 0x71, 0x69, 0x55, 0x8a, 0x25, 0xaa, 0xe8, 0x1c, 0x01, 0x23, + 0xbf, 0x6c, 0xc1, 0x7c, 0x37, 0x71, 0xa7, 0xa1, 0x04, 0xf9, 0x98, 0x86, 0xd3, 0xe4, 0x45, 0x89, + 0xf1, 0xe4, 0x42, 0x92, 0x18, 0xa6, 0xa9, 0x33, 0x79, 0x20, 0xbd, 0xba, 0xdb, 0x34, 0xe0, 0xb5, + 0xa5, 0xa2, 0xa7, 0x51, 0xac, 0x26, 0xc1, 0x98, 0xae, 0xcf, 0x46, 0x98, 0x7f, 0xdd, 0x38, 0x2f, + 0x35, 0x56, 0x15, 0x02, 0x8c, 0x71, 0x91, 0x37, 0x60, 0x4e, 0xe6, 0x0b, 0xde, 0xf2, 0x9b, 0xd7, + 0x9c, 0x70, 0x4f, 0x9e, 0x70, 0xf4, 0x89, 0x6c, 0x35, 0x01, 0xc5, 0x54, 0x6d, 0xfe, 0x6d, 0x71, + 0x52, 0x66, 0x8e, 0x60, 0x2a, 0xf9, 0x22, 0xc5, 0x6a, 0x12, 0x8c, 0xe9, 0xfa, 0xe4, 0x25, 0x63, + 0x1b, 0x12, 0xf7, 0xff, 0x5a, 0x1a, 0x64, 0x6c, 0x45, 0x55, 0x98, 0xef, 0xf1, 0x03, 0x61, 0x53, + 0x01, 0xe5, 0x7a, 0xd4, 0x04, 0x6f, 0x27, 0xc1, 0x98, 0xae, 0x4f, 0x5e, 0x87, 0x33, 0x01, 0x13, + 0xb6, 0x1a, 0x81, 0x70, 0x0a, 0xd0, 0x77, 0xbe, 0x68, 0x02, 0x31, 0x59, 0x97, 0xbc, 0x09, 0x67, + 0xe3, 0xf4, 0x9a, 0x0a, 0x81, 0xf0, 0x12, 0xd0, 0xb9, 0xde, 0xaa, 0xe9, 0x0a, 0xd8, 0xdf, 0x86, + 0xfc, 0x0d, 0x58, 0x30, 0x7a, 0x62, 0xdd, 0x6b, 0xd2, 0xfb, 0x32, 0x05, 0x22, 0x7f, 0x61, 0x69, + 0x35, 0x05, 0xc3, 0xbe, 0xda, 0xe4, 0x93, 0x30, 0xd7, 0xf0, 0xdb, 0x6d, 0x2e, 0xe3, 0xc4, 0x6b, + 0x08, 0x22, 0xd7, 0xa1, 0xc8, 0x0a, 0x99, 0x80, 0x60, 0xaa, 0x26, 0xb9, 0x0e, 0xc4, 0xdf, 0x61, + 0xea, 0x15, 0x6d, 0xbe, 0x49, 0x3d, 0x2a, 0x35, 0x8e, 0x33, 0xc9, 0x98, 0x92, 0x9b, 0x7d, 0x35, + 0x30, 0xa3, 0x15, 0x4f, 0x15, 0x67, 0xc4, 0xe0, 0xce, 0xe5, 0xf1, 0x6a, 0x61, 0xda, 0x7c, 0xf1, + 0xd0, 0x00, 0xdc, 0x00, 0xa6, 0x44, 0x88, 0x4f, 0x3e, 0x49, 0x0f, 0xcd, 0xc4, 0xe8, 0xf1, 0x1e, + 0x21, 0x4a, 0x51, 0x52, 0x22, 0xbf, 0x00, 0xe5, 0x1d, 0xf5, 0x4a, 0x06, 0xcf, 0x74, 0x38, 0xf6, + 0xbe, 0x98, 0x7a, 0xf0, 0x25, 0x3e, 0x9e, 0x6b, 0x00, 0xc6, 0x24, 0xc9, 0x0b, 0x30, 0x73, 0x6d, + 0xab, 0xaa, 0x67, 0xe1, 0x59, 0x3e, 0xfa, 0x93, 0xac, 0x09, 0x9a, 0x00, 0xb6, 0xc2, 0xb4, 0xfa, + 0x46, 0x92, 0x17, 0xdf, 0x19, 0xda, 0x18, 0xab, 0xcd, 0x6f, 0xf2, 0xb1, 0xbe, 0x78, 0x2e, 0x55, + 0x5b, 0x96, 0xa3, 0xae, 0x41, 0xde, 0x81, 0x19, 0xb9, 0x5f, 0x70, 0xd9, 0x74, 0xfe, 0xd1, 0xe2, + 0xbb, 0x31, 0x46, 0x81, 0x26, 0x3e, 0x7e, 0x67, 0xcb, 0x1f, 0x0f, 0xa0, 0x57, 0x7b, 0xed, 0xf6, + 0xe2, 0x05, 0x2e, 0x37, 0xe3, 0x3b, 0xdb, 0x18, 0x84, 0x66, 0x3d, 0xf2, 0xb2, 0xf2, 0xc8, 0xfa, + 0x50, 0xe2, 0x12, 0x5b, 0x7b, 0x64, 0x69, 0xa5, 0x7b, 0x40, 0x08, 0xc8, 0x93, 0x0f, 0x71, 0x85, + 0xda, 0x81, 0x25, 0xa5, 0xf1, 0xf5, 0x2f, 0x92, 0xc5, 0xc5, 0x84, 0xa9, 0x64, 0xe9, 0xce, 0xc0, + 0x9a, 0x78, 0x02, 0x16, 0xb2, 0x03, 0x05, 0xa7, 0xbd, 0xb3, 0xf8, 0x54, 0x1e, 0xaa, 0x6b, 0x75, + 0xa3, 0x26, 0x67, 0x14, 0x77, 0xdb, 0xac, 0x6e, 0xd4, 0x90, 0x21, 0x27, 0x2e, 0x4c, 0x3a, 0xed, + 0x9d, 0x70, 0x71, 0x89, 0xaf, 0xd9, 0xdc, 0x88, 0xc4, 0xc6, 0x83, 0x8d, 0x5a, 0x88, 0x9c, 0x84, + 0xfd, 0xa5, 0x09, 0x7d, 0x51, 0xa3, 0xf3, 0x4e, 0xbf, 0x67, 0x2e, 0x20, 0x2b, 0x8f, 0xd7, 0xec, + 0xfb, 0x5e, 0xad, 0x11, 0x7b, 0x5f, 0xe6, 0xf2, 0xe9, 0x6a, 0x91, 0x91, 0x4b, 0x92, 0xab, 0x64, + 0x4e, 0x6d, 0x71, 0x7a, 0x4e, 0x0a, 0x0c, 0xfb, 0x3b, 0xa0, 0x8d, 0x7e, 0x29, 0x6f, 0xa6, 0x00, + 0x8a, 0x6e, 0x18, 0xb9, 0x7e, 0x8e, 0x61, 0xcf, 0xa9, 0x64, 0xd4, 0x3c, 0xaa, 0x82, 0x03, 0x50, + 0x90, 0x62, 0x34, 0xbd, 0x96, 0xeb, 0xdd, 0x97, 0x9f, 0x7f, 0x2b, 0x77, 0x37, 0x25, 0x41, 0x93, + 0x03, 0x50, 0x90, 0x22, 0x77, 0xc5, 0xa4, 0x2e, 0xe4, 0x31, 0xd6, 0xd5, 0x8d, 0x5a, 0x8a, 0x5e, + 0x72, 0x72, 0xdf, 0x85, 0x42, 0xd8, 0x71, 0xa5, 0xba, 0x34, 0x26, 0xad, 0xfa, 0xe6, 0x7a, 0x16, + 0xad, 0xfa, 0xe6, 0x3a, 0x32, 0x22, 0xe4, 0x2b, 0x16, 0x80, 0xd3, 0xd9, 0x71, 0xc2, 0xd0, 0x69, + 0x6a, 0xeb, 0xcc, 0x98, 0x8f, 0x4c, 0x54, 0x35, 0xbe, 0x14, 0x69, 0xee, 0x98, 0x1b, 0x43, 0xd1, + 0xa0, 0x4c, 0xde, 0x85, 0x69, 0x47, 0xbc, 0xe2, 0x27, 0x7d, 0xcc, 0xf3, 0x79, 0x9a, 0x32, 0xc5, + 0x01, 0x37, 0xd3, 0x48, 0x10, 0x2a, 0x82, 0x8c, 0x76, 0x14, 0x38, 0x74, 0xd7, 0xdd, 0x97, 0xc6, + 0xa1, 0xfa, 0xd8, 0xef, 0x4c, 0x30, 0x64, 0x59, 0xb4, 0x25, 0x08, 0x15, 0x41, 0xf1, 0xaa, 0xba, + 0xe3, 0x39, 0x3a, 0x72, 0x30, 0x9f, 0xf8, 0x52, 0x33, 0x16, 0xd1, 0x78, 0x55, 0xdd, 0x24, 0x84, + 0x49, 0xba, 0xe4, 0x00, 0xa6, 0x1c, 0xfe, 0xbe, 0xa8, 0x3c, 0x8a, 0x61, 0x1e, 0x6f, 0x95, 0xa6, + 0xfa, 0x80, 0x0b, 0x17, 0xf9, 0x8a, 0xa9, 0xa4, 0x46, 0x7e, 0xc3, 0x82, 0x69, 0xe1, 0xfe, 0xcc, + 0x14, 0x52, 0xf6, 0xed, 0x9f, 0x3b, 0x85, 0xa4, 0xf6, 0xd2, 0x35, 0x5b, 0x7a, 0x00, 0x7d, 0x44, + 0xfb, 0x76, 0x8a, 0xd2, 0x13, 0x9d, 0xb3, 0x15, 0x77, 0x4b, 0x9f, 0x84, 0x59, 0x13, 0xcb, 0x48, + 0xee, 0xd9, 0x3f, 0x2c, 0x00, 0xf0, 0x8e, 0x16, 0xb9, 0x42, 0x3a, 0x3c, 0x03, 0xef, 0x9e, 0xdf, + 0xcc, 0xe9, 0x2d, 0x42, 0x23, 0xe5, 0x07, 0xc8, 0x74, 0xbb, 0x7b, 0x7e, 0x13, 0x25, 0x11, 0xd2, + 0x82, 0xc9, 0xae, 0x13, 0xed, 0xe5, 0x9f, 0x5f, 0xa4, 0x24, 0x82, 0x66, 0xa3, 0x3d, 0xe4, 0x04, + 0xc8, 0xfb, 0x56, 0xec, 0x1a, 0x53, 0xc8, 0xc7, 0x81, 0x41, 0xf5, 0xd9, 0xb2, 0x74, 0x86, 0x49, + 0xe5, 0xd2, 0x4c, 0xbb, 0xc8, 0x2c, 0x7d, 0x60, 0xc1, 0xac, 0x59, 0x35, 0x63, 0x98, 0x7e, 0xde, + 0x1c, 0xa6, 0x3c, 0xfb, 0xc3, 0x1c, 0xf1, 0xff, 0x6a, 0x81, 0xf1, 0xd2, 0x7f, 0xec, 0x85, 0x6e, + 0x0d, 0xed, 0x85, 0x3e, 0x31, 0xa2, 0x17, 0x7a, 0x61, 0x24, 0x2f, 0xf4, 0xc9, 0xd1, 0xbd, 0xd0, + 0x8b, 0x83, 0xbd, 0xd0, 0xed, 0x6f, 0x58, 0x70, 0xb6, 0x6f, 0xb7, 0x61, 0x7a, 0x70, 0xe0, 0xfb, + 0xd1, 0x00, 0x97, 0x47, 0x8c, 0x41, 0x68, 0xd6, 0x23, 0x6b, 0xb0, 0x20, 0xdf, 0x9b, 0xa8, 0x77, + 0xdb, 0x6e, 0x66, 0xee, 0x97, 0xed, 0x14, 0x1c, 0xfb, 0x5a, 0xd8, 0xdf, 0xb1, 0x60, 0xc6, 0x88, + 0x18, 0x67, 0xdf, 0xc1, 0xdd, 0x58, 0x25, 0x1b, 0xf1, 0x53, 0x1b, 0xfc, 0xa2, 0x4a, 0xc0, 0xc4, + 0x9d, 0x69, 0xcb, 0xc8, 0x46, 0x1e, 0xdf, 0x99, 0xb2, 0x52, 0x94, 0x50, 0x91, 0x67, 0x9a, 0x76, + 0x79, 0xa7, 0x17, 0xcc, 0x3c, 0xd3, 0xb4, 0x8b, 0x1c, 0xc2, 0xc9, 0xb1, 0x03, 0x81, 0x0c, 0x50, + 0x30, 0x5e, 0xf6, 0x70, 0x82, 0x08, 0x05, 0x8c, 0x3c, 0x0b, 0x05, 0xea, 0x35, 0xa5, 0xf5, 0x42, + 0xbf, 0xbd, 0x79, 0xc5, 0x6b, 0x22, 0x2b, 0xb7, 0x6f, 0xc2, 0xac, 0xf0, 0xce, 0x7d, 0x8b, 0x1e, + 0x0e, 0xfd, 0x98, 0x27, 0x9b, 0xed, 0xa9, 0xc7, 0x3c, 0x59, 0x73, 0x56, 0x6e, 0xff, 0x53, 0x0b, + 0x52, 0xcf, 0xcf, 0x18, 0xf7, 0x27, 0xd6, 0xc0, 0xfb, 0x13, 0xd3, 0xe6, 0x3e, 0x71, 0xa2, 0xcd, + 0xfd, 0x3a, 0x90, 0x0e, 0x5b, 0x0a, 0x89, 0xc7, 0x96, 0xa4, 0xe1, 0x28, 0xce, 0x4f, 0xd1, 0x57, + 0x03, 0x33, 0x5a, 0xd9, 0xff, 0x44, 0x30, 0x6b, 0x3e, 0x48, 0xf3, 0xf0, 0x0e, 0xe8, 0x41, 0x91, + 0xa3, 0x92, 0xd6, 0xb3, 0x31, 0x2d, 0xcf, 0xfd, 0x79, 0x9e, 0xe2, 0x81, 0x94, 0x4b, 0x9e, 0x53, + 0xb3, 0xff, 0x50, 0xf0, 0x6a, 0xbc, 0x58, 0x33, 0x04, 0xaf, 0x9d, 0x24, 0xaf, 0xd7, 0xf2, 0x92, + 0x95, 0xd9, 0x3c, 0x92, 0x65, 0x80, 0x2e, 0x0d, 0x1a, 0xd4, 0x8b, 0x54, 0xdc, 0x4c, 0x51, 0x46, + 0x70, 0xea, 0x52, 0x34, 0x6a, 0xd8, 0x5f, 0x67, 0x0b, 0x28, 0x7e, 0xe6, 0x96, 0x5c, 0x4a, 0xfb, + 0x8a, 0xa6, 0x17, 0x87, 0x76, 0x15, 0x35, 0xa2, 0x29, 0x26, 0x1e, 0x12, 0x4d, 0xf1, 0x22, 0x4c, + 0x07, 0x7e, 0x9b, 0x56, 0x03, 0x2f, 0xed, 0xe0, 0x82, 0xac, 0x18, 0x6f, 0xa0, 0x82, 0xdb, 0xbf, + 0x66, 0xc1, 0x42, 0x3a, 0xdc, 0x2b, 0x77, 0x07, 0x56, 0x33, 0x26, 0xbd, 0x30, 0x7a, 0x4c, 0xba, + 0xfd, 0x3e, 0x63, 0x32, 0x72, 0x1b, 0xfb, 0xae, 0x27, 0xc2, 0xb8, 0x59, 0xcf, 0xbd, 0x08, 0xd3, + 0x54, 0x3e, 0xd7, 0x29, 0x8c, 0xc0, 0x9a, 0x49, 0xf5, 0x4a, 0xa7, 0x82, 0x93, 0x2a, 0xcc, 0xab, + 0xab, 0x2f, 0x65, 0xb9, 0x17, 0xe9, 0x27, 0xb4, 0xa5, 0x70, 0x2d, 0x09, 0xc6, 0x74, 0x7d, 0xfb, + 0x8b, 0x30, 0x63, 0x6c, 0x4a, 0x5c, 0x7e, 0xdf, 0x77, 0x1a, 0x51, 0x5a, 0xee, 0x5d, 0x61, 0x85, + 0x28, 0x60, 0xfc, 0x82, 0x41, 0x44, 0xa3, 0xa4, 0xe4, 0x9e, 0x8c, 0x41, 0x91, 0x50, 0x86, 0x2c, + 0xa0, 0x2d, 0x7a, 0x5f, 0x25, 0x8b, 0x57, 0xc8, 0x90, 0x15, 0xa2, 0x80, 0xd9, 0x2f, 0x41, 0x49, + 0x25, 0x09, 0xe2, 0x99, 0x36, 0x94, 0xf1, 0xdb, 0xcc, 0xb4, 0xe1, 0x07, 0x11, 0x72, 0x88, 0xfd, + 0x36, 0x94, 0x54, 0x2e, 0xa3, 0x87, 0xd7, 0x66, 0xa2, 0x28, 0xf4, 0xdc, 0x6b, 0x7e, 0x18, 0xa9, + 0x04, 0x4c, 0xe2, 0x7e, 0xee, 0xc6, 0x3a, 0x2f, 0x43, 0x0d, 0xb5, 0x5f, 0x86, 0xf9, 0xd4, 0x3d, + 0xed, 0x10, 0x69, 0x39, 0x7e, 0xb7, 0x00, 0xb3, 0xe6, 0x75, 0xdd, 0x10, 0xab, 0x78, 0x78, 0xe1, + 0x98, 0x71, 0xc5, 0x56, 0x18, 0xf1, 0x8a, 0xcd, 0xbc, 0xd3, 0x9c, 0x3c, 0xdd, 0x3b, 0xcd, 0x62, + 0x3e, 0x77, 0x9a, 0xc6, 0xdd, 0xfb, 0xd4, 0xe3, 0xbb, 0x7b, 0xff, 0xed, 0x22, 0xcc, 0x25, 0xf3, + 0x3c, 0x0e, 0x31, 0x92, 0x2f, 0xf5, 0x8d, 0xe4, 0x88, 0x36, 0xfd, 0xc2, 0xb8, 0x36, 0xfd, 0xc9, + 0x71, 0x6d, 0xfa, 0xc5, 0x47, 0xb0, 0xe9, 0xf7, 0x5b, 0xe4, 0xa7, 0x86, 0xb6, 0xc8, 0x7f, 0x4a, + 0x7b, 0xe5, 0x4d, 0x27, 0xdc, 0x58, 0x62, 0xaf, 0x3c, 0x92, 0x1c, 0x86, 0x55, 0xbf, 0x99, 0xe9, + 0xdd, 0x58, 0x7a, 0x88, 0xed, 0x32, 0xc8, 0x74, 0xa2, 0x1b, 0xfd, 0xda, 0xf0, 0x43, 0x23, 0x38, + 0xd0, 0xbd, 0x0a, 0x33, 0x72, 0x3e, 0x71, 0x15, 0x14, 0x92, 0xea, 0x6b, 0x3d, 0x06, 0xa1, 0x59, + 0x8f, 0xbf, 0x77, 0x9e, 0x7c, 0x05, 0x9f, 0x5f, 0x91, 0x98, 0xef, 0x9d, 0xa7, 0x5e, 0xcd, 0x4f, + 0xd7, 0xb7, 0xbf, 0x00, 0x17, 0x32, 0xcd, 0x08, 0xdc, 0x84, 0xcb, 0xb5, 0x23, 0xda, 0x94, 0x15, + 0x0c, 0x36, 0x52, 0xef, 0x24, 0x2c, 0xdd, 0x19, 0x58, 0x13, 0x4f, 0xc0, 0x62, 0x7f, 0xbb, 0x00, + 0x73, 0xc9, 0xc7, 0x32, 0xc9, 0x3d, 0x6d, 0x74, 0xcc, 0xc5, 0xde, 0x29, 0xd0, 0x1a, 0xb9, 0x03, + 0x07, 0x5e, 0x56, 0xdc, 0xe3, 0xf3, 0x6b, 0x47, 0x27, 0x32, 0x3c, 0x3d, 0xc2, 0xf2, 0x96, 0x40, + 0x92, 0xe3, 0xef, 0x61, 0xc6, 0x61, 0x86, 0xf2, 0x34, 0x9b, 0x3b, 0xf5, 0x38, 0x5c, 0x4e, 0x93, + 0x42, 0x83, 0x2c, 0xdb, 0x5b, 0x0e, 0x68, 0xe0, 0xee, 0xba, 0xfa, 0xa1, 0x6f, 0x2e, 0xb9, 0xdf, + 0x96, 0x65, 0xa8, 0xa1, 0xf6, 0xfb, 0x13, 0x50, 0xe6, 0x59, 0x91, 0xae, 0x06, 0x7e, 0x87, 0xbf, + 0x28, 0x17, 0x1a, 0x27, 0x07, 0x39, 0x6c, 0xd7, 0xc7, 0x7d, 0xb6, 0x31, 0xc6, 0x28, 0x3d, 0xa6, + 0x8d, 0x12, 0x4c, 0x50, 0x24, 0x5d, 0x28, 0xed, 0xca, 0x2c, 0xae, 0x72, 0xec, 0xc6, 0xcc, 0x44, + 0xa8, 0x72, 0xc2, 0x8a, 0x2e, 0x50, 0xff, 0x50, 0x53, 0xb1, 0x1d, 0x98, 0x4f, 0xa5, 0xb5, 0xc8, + 0x3d, 0xf7, 0xeb, 0xff, 0x98, 0x84, 0xb2, 0x0e, 0xd7, 0x21, 0x9f, 0x48, 0x98, 0x71, 0xca, 0xb5, + 0x0f, 0x1b, 0xcf, 0x1d, 0xed, 0xf9, 0xcd, 0x07, 0x47, 0x95, 0x79, 0x5d, 0x39, 0x65, 0x92, 0x79, + 0x16, 0x0a, 0xbd, 0xa0, 0x9d, 0x3e, 0xa7, 0xdd, 0xc6, 0x0d, 0x64, 0xe5, 0x66, 0x88, 0x51, 0xe1, + 0xb1, 0x86, 0x18, 0xb1, 0x5d, 0x72, 0xc7, 0x6f, 0x1e, 0xa6, 0x9f, 0x47, 0xaa, 0xf9, 0xcd, 0x43, + 0xe4, 0x10, 0xf2, 0x06, 0xcc, 0xc9, 0xb8, 0x29, 0xf3, 0xd1, 0xf8, 0x42, 0x7c, 0xf9, 0xbe, 0x9d, + 0x80, 0x62, 0xaa, 0x36, 0xdb, 0x65, 0xef, 0x86, 0xbe, 0xc7, 0x33, 0xfa, 0x4e, 0x25, 0x6f, 0xea, + 0xae, 0xd7, 0x6f, 0xde, 0xe0, 0xe6, 0x24, 0x5d, 0x23, 0x11, 0x9a, 0x35, 0xfd, 0xd0, 0xd0, 0xac, + 0x35, 0x81, 0x9b, 0x71, 0xcb, 0x77, 0x94, 0xd9, 0xda, 0x25, 0x85, 0x97, 0x95, 0x3d, 0x38, 0x3a, + 0xc1, 0xd0, 0xa7, 0x5b, 0x66, 0x05, 0xb1, 0x95, 0x7f, 0x7c, 0x41, 0x6c, 0xf6, 0x6d, 0x98, 0x4f, + 0x8d, 0x9f, 0x3a, 0xe6, 0x5b, 0xd9, 0xc7, 0xfc, 0xe1, 0x1e, 0x58, 0xfa, 0xe7, 0x16, 0x9c, 0xed, + 0x93, 0x48, 0xc3, 0x46, 0x13, 0xa6, 0xf7, 0xc6, 0x89, 0x47, 0xdf, 0x1b, 0x0b, 0xa3, 0xed, 0x8d, + 0xb5, 0x9d, 0xef, 0xfe, 0xe0, 0xe2, 0x13, 0xdf, 0xfb, 0xc1, 0xc5, 0x27, 0xfe, 0xe8, 0x07, 0x17, + 0x9f, 0x78, 0xff, 0xf8, 0xa2, 0xf5, 0xdd, 0xe3, 0x8b, 0xd6, 0xf7, 0x8e, 0x2f, 0x5a, 0x7f, 0x74, + 0x7c, 0xd1, 0xfa, 0x8f, 0xc7, 0x17, 0xad, 0x6f, 0xfc, 0xd9, 0xc5, 0x27, 0x3e, 0xfd, 0xa9, 0x78, + 0xa4, 0x56, 0xd4, 0x48, 0xf1, 0x1f, 0x1f, 0x55, 0xe3, 0xb2, 0xd2, 0xdd, 0x6f, 0xad, 0xb0, 0x91, + 0x5a, 0xd1, 0x25, 0x6a, 0xa4, 0xfe, 0x4f, 0x00, 0x00, 0x00, 0xff, 0xff, 0x43, 0x1e, 0xac, 0xfd, + 0x31, 0xa2, 0x00, 0x00, } func (m *ALBStatus) Marshal() (dAtA []byte, err error) { @@ -5943,7 +5948,36 @@ func (m *DatadogMetric) MarshalToSizedBuffer(dAtA []byte) (int, error) { copy(dAtA[i:], m.ApiVersion) i = encodeVarintGenerated(dAtA, i, uint64(len(m.ApiVersion))) i-- - dAtA[i] = 0x1a + dAtA[i] = 0x2a + i -= len(m.Formula) + copy(dAtA[i:], m.Formula) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.Formula))) + i-- + dAtA[i] = 0x22 + if len(m.Queries) > 0 { + keysForQueries := make([]string, 0, len(m.Queries)) + for k := range m.Queries { + keysForQueries = append(keysForQueries, string(k)) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForQueries) + for iNdEx := len(keysForQueries) - 1; iNdEx >= 0; iNdEx-- { + v := m.Queries[string(keysForQueries[iNdEx])] + baseI := i + i -= len(v) + copy(dAtA[i:], v) + i = encodeVarintGenerated(dAtA, i, uint64(len(v))) + i-- + dAtA[i] = 0x12 + i -= len(keysForQueries[iNdEx]) + copy(dAtA[i:], keysForQueries[iNdEx]) + i = encodeVarintGenerated(dAtA, i, uint64(len(keysForQueries[iNdEx]))) + i-- + dAtA[i] = 0xa + i = encodeVarintGenerated(dAtA, i, uint64(baseI-i)) + i-- + dAtA[i] = 0x1a + } + } i -= len(m.Query) copy(dAtA[i:], m.Query) i = encodeVarintGenerated(dAtA, i, uint64(len(m.Query))) @@ -10989,6 +11023,16 @@ func (m *DatadogMetric) Size() (n int) { n += 1 + l + sovGenerated(uint64(l)) l = len(m.Query) n += 1 + l + sovGenerated(uint64(l)) + if len(m.Queries) > 0 { + for k, v := range m.Queries { + _ = k + _ = v + mapEntrySize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + len(v) + sovGenerated(uint64(len(v))) + n += mapEntrySize + 1 + sovGenerated(uint64(mapEntrySize)) + } + } + l = len(m.Formula) + n += 1 + l + sovGenerated(uint64(l)) l = len(m.ApiVersion) n += 1 + l + sovGenerated(uint64(l)) return n @@ -13113,9 +13157,21 @@ func (this *DatadogMetric) String() string { if this == nil { return "nil" } + keysForQueries := make([]string, 0, len(this.Queries)) + for k := range this.Queries { + keysForQueries = append(keysForQueries, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForQueries) + mapStringForQueries := "map[string]string{" + for _, k := range keysForQueries { + mapStringForQueries += fmt.Sprintf("%v: %v,", k, this.Queries[k]) + } + mapStringForQueries += "}" s := strings.Join([]string{`&DatadogMetric{`, `Interval:` + fmt.Sprintf("%v", this.Interval) + `,`, `Query:` + fmt.Sprintf("%v", this.Query) + `,`, + `Queries:` + mapStringForQueries + `,`, + `Formula:` + fmt.Sprintf("%v", this.Formula) + `,`, `ApiVersion:` + fmt.Sprintf("%v", this.ApiVersion) + `,`, `}`, }, "") @@ -20652,6 +20708,165 @@ func (m *DatadogMetric) Unmarshal(dAtA []byte) error { m.Query = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Queries", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Queries == nil { + m.Queries = make(map[string]string) + } + var mapkey string + var mapvalue string + for iNdEx < postIndex { + entryPreIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + if fieldNum == 1 { + var stringLenmapkey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLenmapkey |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLenmapkey := int(stringLenmapkey) + if intStringLenmapkey < 0 { + return ErrInvalidLengthGenerated + } + postStringIndexmapkey := iNdEx + intStringLenmapkey + if postStringIndexmapkey < 0 { + return ErrInvalidLengthGenerated + } + if postStringIndexmapkey > l { + return io.ErrUnexpectedEOF + } + mapkey = string(dAtA[iNdEx:postStringIndexmapkey]) + iNdEx = postStringIndexmapkey + } else if fieldNum == 2 { + var stringLenmapvalue uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLenmapvalue |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLenmapvalue := int(stringLenmapvalue) + if intStringLenmapvalue < 0 { + return ErrInvalidLengthGenerated + } + postStringIndexmapvalue := iNdEx + intStringLenmapvalue + if postStringIndexmapvalue < 0 { + return ErrInvalidLengthGenerated + } + if postStringIndexmapvalue > l { + return io.ErrUnexpectedEOF + } + mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue]) + iNdEx = postStringIndexmapvalue + } else { + iNdEx = entryPreIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > postIndex { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + m.Queries[mapkey] = mapvalue + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Formula", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Formula = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 5: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ApiVersion", wireType) } diff --git a/pkg/apis/rollouts/v1alpha1/generated.proto b/pkg/apis/rollouts/v1alpha1/generated.proto index e9ca26687b..248eeaec09 100644 --- a/pkg/apis/rollouts/v1alpha1/generated.proto +++ b/pkg/apis/rollouts/v1alpha1/generated.proto @@ -617,12 +617,23 @@ message ClusterAnalysisTemplateList { } message DatadogMetric { + // +kubebuilder:default="5m" + // Interval refers to the Interval time window in Datadog (default: 5m). Not to be confused with the polling rate for the metric. optional string interval = 1; optional string query = 2; + // Queries is a map of query_name_as_key: query. You can then use query_name_as_key inside Formula.Used for v2 + // +kubebuilder:validation:Type=object + map queries = 3; + + // Formula refers to the Formula made up of the queries. Only useful with Queries. Used for v2 + optional string formula = 4; + // ApiVersion refers to the Datadog API version being used (default: v1). v1 will eventually be deprecated. - optional string apiVersion = 3; + // +kubebuilder:validation:Enum=v1;v2 + // +kubebuilder:default=v1 + optional string apiVersion = 5; } // DryRun defines the settings for running the analysis in Dry-Run mode. diff --git a/pkg/apis/rollouts/v1alpha1/openapi_generated.go b/pkg/apis/rollouts/v1alpha1/openapi_generated.go index 28a35188c5..01b39597e2 100644 --- a/pkg/apis/rollouts/v1alpha1/openapi_generated.go +++ b/pkg/apis/rollouts/v1alpha1/openapi_generated.go @@ -1835,16 +1835,39 @@ func schema_pkg_apis_rollouts_v1alpha1_DatadogMetric(ref common.ReferenceCallbac Type: []string{"object"}, Properties: map[string]spec.Schema{ "interval": { + SchemaProps: spec.SchemaProps{ + Description: "Interval refers to the Interval time window in Datadog (default: 5m). Not to be confused with the polling rate for the metric.", + Type: []string{"string"}, + Format: "", + }, + }, + "query": { SchemaProps: spec.SchemaProps{ Type: []string{"string"}, Format: "", }, }, - "query": { + "queries": { SchemaProps: spec.SchemaProps{ - Default: "", - Type: []string{"string"}, - Format: "", + Description: "Queries is a map of query_name_as_key: query. You can then use query_name_as_key inside Formula.Used for v2", + Type: []string{"object"}, + AdditionalProperties: &spec.SchemaOrBool{ + Allows: true, + Schema: &spec.Schema{ + SchemaProps: spec.SchemaProps{ + Default: "", + Type: []string{"string"}, + Format: "", + }, + }, + }, + }, + }, + "formula": { + SchemaProps: spec.SchemaProps{ + Description: "Formula refers to the Formula made up of the queries. Only useful with Queries. Used for v2", + Type: []string{"string"}, + Format: "", }, }, "apiVersion": { @@ -1855,7 +1878,6 @@ func schema_pkg_apis_rollouts_v1alpha1_DatadogMetric(ref common.ReferenceCallbac }, }, }, - Required: []string{"query"}, }, }, } diff --git a/pkg/apis/rollouts/v1alpha1/zz_generated.deepcopy.go b/pkg/apis/rollouts/v1alpha1/zz_generated.deepcopy.go index aec01a262c..82b7cc8cc4 100644 --- a/pkg/apis/rollouts/v1alpha1/zz_generated.deepcopy.go +++ b/pkg/apis/rollouts/v1alpha1/zz_generated.deepcopy.go @@ -1098,6 +1098,13 @@ func (in *ClusterAnalysisTemplateList) DeepCopyObject() runtime.Object { // DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. func (in *DatadogMetric) DeepCopyInto(out *DatadogMetric) { *out = *in + if in.Queries != nil { + in, out := &in.Queries, &out.Queries + *out = make(map[string]string, len(*in)) + for key, val := range *in { + (*out)[key] = val + } + } return } @@ -1684,7 +1691,7 @@ func (in *MetricProvider) DeepCopyInto(out *MetricProvider) { if in.Datadog != nil { in, out := &in.Datadog, &out.Datadog *out = new(DatadogMetric) - **out = **in + (*in).DeepCopyInto(*out) } if in.Wavefront != nil { in, out := &in.Wavefront, &out.Wavefront diff --git a/ui/src/models/rollout/generated/api.ts b/ui/src/models/rollout/generated/api.ts index 28465a76a8..eb0a755c17 100755 --- a/ui/src/models/rollout/generated/api.ts +++ b/ui/src/models/rollout/generated/api.ts @@ -977,7 +977,7 @@ export interface GithubComArgoprojArgoRolloutsPkgApisRolloutsV1alpha1CloudWatchM */ export interface GithubComArgoprojArgoRolloutsPkgApisRolloutsV1alpha1DatadogMetric { /** - * + * +kubebuilder:default=\"5m\" Interval refers to the Interval time window in Datadog (default: 5m). Not to be confused with the polling rate for the metric. * @type {string} * @memberof GithubComArgoprojArgoRolloutsPkgApisRolloutsV1alpha1DatadogMetric */ @@ -989,7 +989,19 @@ export interface GithubComArgoprojArgoRolloutsPkgApisRolloutsV1alpha1DatadogMetr */ query?: string; /** - * ApiVersion refers to the Datadog API version being used (default: v1). v1 will eventually be deprecated. + * + * @type {{ [key: string]: string; }} + * @memberof GithubComArgoprojArgoRolloutsPkgApisRolloutsV1alpha1DatadogMetric + */ + queries?: { [key: string]: string; }; + /** + * + * @type {string} + * @memberof GithubComArgoprojArgoRolloutsPkgApisRolloutsV1alpha1DatadogMetric + */ + formula?: string; + /** + * * @type {string} * @memberof GithubComArgoprojArgoRolloutsPkgApisRolloutsV1alpha1DatadogMetric */